Fix: skip metadata flushed check if write failed
[lttng-tools.git] / src / bin / lttng-sessiond / ust-app.c
CommitLineData
91d76f53
DG
1/*
2 * Copyright (C) 2011 - David Goulet <david.goulet@polymtl.ca>
3 *
d14d33bf
AM
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License, version 2 only,
6 * as published by the Free Software Foundation.
91d76f53
DG
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
d14d33bf
AM
13 * You should have received a copy of the GNU General Public License along
14 * with this program; if not, write to the Free Software Foundation, Inc.,
15 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
91d76f53
DG
16 */
17
18#define _GNU_SOURCE
19#include <errno.h>
7972aab2 20#include <inttypes.h>
91d76f53
DG
21#include <pthread.h>
22#include <stdio.h>
23#include <stdlib.h>
099e26bd 24#include <string.h>
aba8e916
DG
25#include <sys/stat.h>
26#include <sys/types.h>
099e26bd 27#include <unistd.h>
0df502fd 28#include <urcu/compiler.h>
fb54cdbf 29#include <lttng/ust-error.h>
331744e3 30#include <signal.h>
bec39940 31
990570ed 32#include <common/common.h>
86acf0da 33#include <common/sessiond-comm/sessiond-comm.h>
1e307fab 34
7972aab2 35#include "buffer-registry.h"
86acf0da
DG
36#include "fd-limit.h"
37#include "health.h"
56fff090 38#include "ust-app.h"
48842b30 39#include "ust-consumer.h"
d80a6244
DG
40#include "ust-ctl.h"
41
ffe60014
DG
42/* Next available channel key. */
43static unsigned long next_channel_key;
7972aab2 44static unsigned long next_session_id;
ffe60014
DG
45
46/*
47 * Return the atomically incremented value of next_channel_key.
48 */
49static inline unsigned long get_next_channel_key(void)
50{
51 return uatomic_add_return(&next_channel_key, 1);
52}
53
54/*
7972aab2 55 * Return the atomically incremented value of next_session_id.
ffe60014 56 */
7972aab2 57static inline unsigned long get_next_session_id(void)
ffe60014 58{
7972aab2 59 return uatomic_add_return(&next_session_id, 1);
ffe60014
DG
60}
61
d65d2de8
DG
62static void copy_channel_attr_to_ustctl(
63 struct ustctl_consumer_channel_attr *attr,
64 struct lttng_ust_channel_attr *uattr)
65{
66 /* Copy event attributes since the layout is different. */
67 attr->subbuf_size = uattr->subbuf_size;
68 attr->num_subbuf = uattr->num_subbuf;
69 attr->overwrite = uattr->overwrite;
70 attr->switch_timer_interval = uattr->switch_timer_interval;
71 attr->read_timer_interval = uattr->read_timer_interval;
72 attr->output = uattr->output;
73}
74
025faf73
DG
75/*
76 * Match function for the hash table lookup.
77 *
78 * It matches an ust app event based on three attributes which are the event
79 * name, the filter bytecode and the loglevel.
80 */
18eace3b
DG
81static int ht_match_ust_app_event(struct cds_lfht_node *node, const void *_key)
82{
83 struct ust_app_event *event;
84 const struct ust_app_ht_key *key;
85
86 assert(node);
87 assert(_key);
88
89 event = caa_container_of(node, struct ust_app_event, node.node);
90 key = _key;
91
92 /* Match the 3 elements of the key: name, filter and loglevel. */
93
94 /* Event name */
95 if (strncmp(event->attr.name, key->name, sizeof(event->attr.name)) != 0) {
96 goto no_match;
97 }
98
99 /* Event loglevel. */
100 if (event->attr.loglevel != key->loglevel) {
025faf73
DG
101 if (event->attr.loglevel_type == LTTNG_UST_LOGLEVEL_ALL
102 && key->loglevel == 0 && event->attr.loglevel == -1) {
103 /*
104 * Match is accepted. This is because on event creation, the
105 * loglevel is set to -1 if the event loglevel type is ALL so 0 and
106 * -1 are accepted for this loglevel type since 0 is the one set by
107 * the API when receiving an enable event.
108 */
109 } else {
110 goto no_match;
111 }
18eace3b
DG
112 }
113
114 /* One of the filters is NULL, fail. */
115 if ((key->filter && !event->filter) || (!key->filter && event->filter)) {
116 goto no_match;
117 }
118
025faf73
DG
119 if (key->filter && event->filter) {
120 /* Both filters exists, check length followed by the bytecode. */
121 if (event->filter->len != key->filter->len ||
122 memcmp(event->filter->data, key->filter->data,
123 event->filter->len) != 0) {
124 goto no_match;
125 }
18eace3b
DG
126 }
127
025faf73 128 /* Match. */
18eace3b
DG
129 return 1;
130
131no_match:
132 return 0;
18eace3b
DG
133}
134
025faf73
DG
135/*
136 * Unique add of an ust app event in the given ht. This uses the custom
137 * ht_match_ust_app_event match function and the event name as hash.
138 */
d0b96690 139static void add_unique_ust_app_event(struct ust_app_channel *ua_chan,
18eace3b
DG
140 struct ust_app_event *event)
141{
142 struct cds_lfht_node *node_ptr;
143 struct ust_app_ht_key key;
d0b96690 144 struct lttng_ht *ht;
18eace3b 145
d0b96690
DG
146 assert(ua_chan);
147 assert(ua_chan->events);
18eace3b
DG
148 assert(event);
149
d0b96690 150 ht = ua_chan->events;
18eace3b
DG
151 key.name = event->attr.name;
152 key.filter = event->filter;
153 key.loglevel = event->attr.loglevel;
154
155 node_ptr = cds_lfht_add_unique(ht->ht,
156 ht->hash_fct(event->node.key, lttng_ht_seed),
157 ht_match_ust_app_event, &key, &event->node.node);
158 assert(node_ptr == &event->node.node);
159}
160
d88aee68
DG
161/*
162 * Close the notify socket from the given RCU head object. This MUST be called
163 * through a call_rcu().
164 */
165static void close_notify_sock_rcu(struct rcu_head *head)
166{
167 int ret;
168 struct ust_app_notify_sock_obj *obj =
169 caa_container_of(head, struct ust_app_notify_sock_obj, head);
170
171 /* Must have a valid fd here. */
172 assert(obj->fd >= 0);
173
174 ret = close(obj->fd);
175 if (ret) {
176 ERR("close notify sock %d RCU", obj->fd);
177 }
178 lttng_fd_put(LTTNG_FD_APPS, 1);
179
180 free(obj);
181}
182
7972aab2
DG
183/*
184 * Return the session registry according to the buffer type of the given
185 * session.
186 *
187 * A registry per UID object MUST exists before calling this function or else
188 * it assert() if not found. RCU read side lock must be acquired.
189 */
190static struct ust_registry_session *get_session_registry(
191 struct ust_app_session *ua_sess)
192{
193 struct ust_registry_session *registry = NULL;
194
195 assert(ua_sess);
196
197 switch (ua_sess->buffer_type) {
198 case LTTNG_BUFFER_PER_PID:
199 {
200 struct buffer_reg_pid *reg_pid = buffer_reg_pid_find(ua_sess->id);
201 if (!reg_pid) {
202 goto error;
203 }
204 registry = reg_pid->registry->reg.ust;
205 break;
206 }
207 case LTTNG_BUFFER_PER_UID:
208 {
209 struct buffer_reg_uid *reg_uid = buffer_reg_uid_find(
210 ua_sess->tracing_id, ua_sess->bits_per_long, ua_sess->uid);
211 if (!reg_uid) {
212 goto error;
213 }
214 registry = reg_uid->registry->reg.ust;
215 break;
216 }
217 default:
218 assert(0);
219 };
220
221error:
222 return registry;
223}
224
55cc08a6
DG
225/*
226 * Delete ust context safely. RCU read lock must be held before calling
227 * this function.
228 */
229static
230void delete_ust_app_ctx(int sock, struct ust_app_ctx *ua_ctx)
231{
ffe60014
DG
232 int ret;
233
234 assert(ua_ctx);
235
55cc08a6 236 if (ua_ctx->obj) {
ffe60014 237 ret = ustctl_release_object(sock, ua_ctx->obj);
d0b96690
DG
238 if (ret < 0 && ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
239 ERR("UST app sock %d release ctx obj handle %d failed with ret %d",
240 sock, ua_ctx->obj->handle, ret);
ffe60014 241 }
55cc08a6
DG
242 free(ua_ctx->obj);
243 }
244 free(ua_ctx);
245}
246
d80a6244
DG
247/*
248 * Delete ust app event safely. RCU read lock must be held before calling
249 * this function.
250 */
8b366481
DG
251static
252void delete_ust_app_event(int sock, struct ust_app_event *ua_event)
d80a6244 253{
ffe60014
DG
254 int ret;
255
256 assert(ua_event);
257
53a80697 258 free(ua_event->filter);
d80a6244 259
edb67388 260 if (ua_event->obj != NULL) {
ffe60014
DG
261 ret = ustctl_release_object(sock, ua_event->obj);
262 if (ret < 0 && ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
263 ERR("UST app sock %d release event obj failed with ret %d",
264 sock, ret);
265 }
edb67388
DG
266 free(ua_event->obj);
267 }
d80a6244
DG
268 free(ua_event);
269}
270
271/*
7972aab2
DG
272 * Release ust data object of the given stream.
273 *
274 * Return 0 on success or else a negative value.
d80a6244 275 */
7972aab2 276static int release_ust_app_stream(int sock, struct ust_app_stream *stream)
d80a6244 277{
7972aab2 278 int ret = 0;
ffe60014
DG
279
280 assert(stream);
281
8b366481 282 if (stream->obj) {
ffe60014
DG
283 ret = ustctl_release_object(sock, stream->obj);
284 if (ret < 0 && ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
285 ERR("UST app sock %d release stream obj failed with ret %d",
286 sock, ret);
287 }
4063050c 288 lttng_fd_put(LTTNG_FD_APPS, 2);
8b366481
DG
289 free(stream->obj);
290 }
7972aab2
DG
291
292 return ret;
293}
294
295/*
296 * Delete ust app stream safely. RCU read lock must be held before calling
297 * this function.
298 */
299static
300void delete_ust_app_stream(int sock, struct ust_app_stream *stream)
301{
302 assert(stream);
303
304 (void) release_ust_app_stream(sock, stream);
84cd17c6 305 free(stream);
d80a6244
DG
306}
307
36b588ed
MD
308/*
309 * We need to execute ht_destroy outside of RCU read-side critical
310 * section, so we postpone its execution using call_rcu. It is simpler
311 * than to change the semantic of the many callers of
312 * delete_ust_app_channel().
313 */
314static
315void delete_ust_app_channel_rcu(struct rcu_head *head)
316{
317 struct ust_app_channel *ua_chan =
318 caa_container_of(head, struct ust_app_channel, rcu_head);
319
320 lttng_ht_destroy(ua_chan->ctx);
321 lttng_ht_destroy(ua_chan->events);
322 free(ua_chan);
323}
324
d80a6244
DG
325/*
326 * Delete ust app channel safely. RCU read lock must be held before calling
327 * this function.
328 */
8b366481 329static
d0b96690
DG
330void delete_ust_app_channel(int sock, struct ust_app_channel *ua_chan,
331 struct ust_app *app)
d80a6244
DG
332{
333 int ret;
bec39940 334 struct lttng_ht_iter iter;
d80a6244 335 struct ust_app_event *ua_event;
55cc08a6 336 struct ust_app_ctx *ua_ctx;
030a66fa 337 struct ust_app_stream *stream, *stmp;
7972aab2 338 struct ust_registry_session *registry;
d80a6244 339
ffe60014
DG
340 assert(ua_chan);
341
342 DBG3("UST app deleting channel %s", ua_chan->name);
343
55cc08a6 344 /* Wipe stream */
d80a6244 345 cds_list_for_each_entry_safe(stream, stmp, &ua_chan->streams.head, list) {
84cd17c6 346 cds_list_del(&stream->list);
d80a6244
DG
347 delete_ust_app_stream(sock, stream);
348 }
349
55cc08a6 350 /* Wipe context */
bec39940
DG
351 cds_lfht_for_each_entry(ua_chan->ctx->ht, &iter.iter, ua_ctx, node.node) {
352 ret = lttng_ht_del(ua_chan->ctx, &iter);
55cc08a6
DG
353 assert(!ret);
354 delete_ust_app_ctx(sock, ua_ctx);
355 }
d80a6244 356
55cc08a6 357 /* Wipe events */
bec39940
DG
358 cds_lfht_for_each_entry(ua_chan->events->ht, &iter.iter, ua_event,
359 node.node) {
360 ret = lttng_ht_del(ua_chan->events, &iter);
525b0740 361 assert(!ret);
d80a6244
DG
362 delete_ust_app_event(sock, ua_event);
363 }
edb67388 364
45893984 365 /* Wipe and free registry from session registry. */
7972aab2
DG
366 registry = get_session_registry(ua_chan->session);
367 if (registry) {
368 ust_registry_channel_del_free(registry, ua_chan->key);
369 }
d0b96690 370
edb67388 371 if (ua_chan->obj != NULL) {
d0b96690
DG
372 /* Remove channel from application UST object descriptor. */
373 iter.iter.node = &ua_chan->ust_objd_node.node;
374 lttng_ht_del(app->ust_objd, &iter);
ffe60014
DG
375 ret = ustctl_release_object(sock, ua_chan->obj);
376 if (ret < 0 && ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
377 ERR("UST app sock %d release channel obj failed with ret %d",
378 sock, ret);
379 }
7972aab2 380 lttng_fd_put(LTTNG_FD_APPS, 1);
edb67388
DG
381 free(ua_chan->obj);
382 }
36b588ed 383 call_rcu(&ua_chan->rcu_head, delete_ust_app_channel_rcu);
d80a6244
DG
384}
385
331744e3
JD
386/*
387 * Push metadata to consumer socket. The socket lock MUST be acquired.
388 *
389 * On success, return the len of metadata pushed or else a negative value.
390 */
391ssize_t ust_app_push_metadata(struct ust_registry_session *registry,
392 struct consumer_socket *socket, int send_zero_data)
393{
394 int ret;
395 char *metadata_str = NULL;
396 size_t len, offset;
397 ssize_t ret_val;
398
399 assert(registry);
400 assert(socket);
401 /* Should never be 0 which is the initial state. */
402 assert(registry->metadata_key);
403
404 pthread_mutex_lock(&registry->lock);
405
406 offset = registry->metadata_len_sent;
407 len = registry->metadata_len - registry->metadata_len_sent;
408 if (len == 0) {
409 DBG3("No metadata to push for metadata key %" PRIu64,
410 registry->metadata_key);
411 ret_val = len;
412 if (send_zero_data) {
413 DBG("No metadata to push");
414 goto push_data;
415 }
416 goto end;
417 }
418
419 /* Allocate only what we have to send. */
420 metadata_str = zmalloc(len);
421 if (!metadata_str) {
422 PERROR("zmalloc ust app metadata string");
423 ret_val = -ENOMEM;
424 goto error;
425 }
426 /* Copy what we haven't send out. */
427 memcpy(metadata_str, registry->metadata + offset, len);
428 registry->metadata_len_sent += len;
429
430push_data:
431 pthread_mutex_unlock(&registry->lock);
432 ret = consumer_push_metadata(socket, registry->metadata_key,
433 metadata_str, len, offset);
434 if (ret < 0) {
435 ret_val = ret;
436 goto error_push;
437 }
438
439 free(metadata_str);
440 return len;
441
442end:
443error:
444 pthread_mutex_unlock(&registry->lock);
445error_push:
446 free(metadata_str);
447 return ret_val;
448}
449
d88aee68
DG
450/*
451 * For a given application and session, push metadata to consumer. The session
452 * lock MUST be acquired here before calling this.
331744e3
JD
453 * Either sock or consumer is required : if sock is NULL, the default
454 * socket to send the metadata is retrieved from consumer, if sock
455 * is not NULL we use it to send the metadata.
d88aee68
DG
456 *
457 * Return 0 on success else a negative error.
458 */
7972aab2
DG
459static int push_metadata(struct ust_registry_session *registry,
460 struct consumer_output *consumer)
d88aee68 461{
331744e3
JD
462 int ret_val;
463 ssize_t ret;
d88aee68
DG
464 struct consumer_socket *socket;
465
7972aab2
DG
466 assert(registry);
467 assert(consumer);
468
469 rcu_read_lock();
d88aee68 470
7972aab2
DG
471 /*
472 * Means that no metadata was assigned to the session. This can happens if
473 * no start has been done previously.
474 */
475 if (!registry->metadata_key) {
331744e3 476 ret_val = 0;
7972aab2 477 goto error_rcu_unlock;
d88aee68
DG
478 }
479
d88aee68 480 /* Get consumer socket to use to push the metadata.*/
7972aab2
DG
481 socket = consumer_find_socket_by_bitness(registry->bits_per_long,
482 consumer);
d88aee68 483 if (!socket) {
331744e3 484 ret_val = -1;
d88aee68
DG
485 goto error_rcu_unlock;
486 }
487
488 /*
489 * TODO: Currently, we hold the socket lock around sampling of the next
490 * metadata segment to ensure we send metadata over the consumer socket in
491 * the correct order. This makes the registry lock nest inside the socket
492 * lock.
493 *
494 * Please note that this is a temporary measure: we should move this lock
495 * back into ust_consumer_push_metadata() when the consumer gets the
496 * ability to reorder the metadata it receives.
497 */
498 pthread_mutex_lock(socket->lock);
331744e3
JD
499 ret = ust_app_push_metadata(registry, socket, 0);
500 pthread_mutex_unlock(socket->lock);
d88aee68 501 if (ret < 0) {
331744e3 502 ret_val = ret;
d88aee68
DG
503 goto error_rcu_unlock;
504 }
505
d88aee68 506 rcu_read_unlock();
d88aee68
DG
507 return 0;
508
d88aee68
DG
509error_rcu_unlock:
510 rcu_read_unlock();
331744e3 511 return ret_val;
d88aee68
DG
512}
513
514/*
515 * Send to the consumer a close metadata command for the given session. Once
516 * done, the metadata channel is deleted and the session metadata pointer is
517 * nullified. The session lock MUST be acquired here unless the application is
518 * in the destroy path.
519 *
520 * Return 0 on success else a negative value.
521 */
7972aab2
DG
522static int close_metadata(struct ust_registry_session *registry,
523 struct consumer_output *consumer)
d88aee68
DG
524{
525 int ret;
526 struct consumer_socket *socket;
527
7972aab2
DG
528 assert(registry);
529 assert(consumer);
d88aee68 530
7972aab2
DG
531 rcu_read_lock();
532
533 if (!registry->metadata_key || registry->metadata_closed) {
d88aee68
DG
534 ret = 0;
535 goto error;
536 }
537
d88aee68 538 /* Get consumer socket to use to push the metadata.*/
7972aab2
DG
539 socket = consumer_find_socket_by_bitness(registry->bits_per_long,
540 consumer);
d88aee68
DG
541 if (!socket) {
542 ret = -1;
7972aab2 543 goto error;
d88aee68
DG
544 }
545
7972aab2 546 ret = consumer_close_metadata(socket, registry->metadata_key);
d88aee68 547 if (ret < 0) {
7972aab2 548 goto error;
d88aee68
DG
549 }
550
7972aab2
DG
551 /* Metadata successfully closed. Flag the registry. */
552 registry->metadata_closed = 1;
d88aee68 553
d88aee68 554error:
7972aab2 555 rcu_read_unlock();
d88aee68
DG
556 return ret;
557}
558
36b588ed
MD
559/*
560 * We need to execute ht_destroy outside of RCU read-side critical
561 * section, so we postpone its execution using call_rcu. It is simpler
562 * than to change the semantic of the many callers of
563 * delete_ust_app_session().
564 */
565static
566void delete_ust_app_session_rcu(struct rcu_head *head)
567{
568 struct ust_app_session *ua_sess =
569 caa_container_of(head, struct ust_app_session, rcu_head);
570
571 lttng_ht_destroy(ua_sess->channels);
572 free(ua_sess);
573}
574
d80a6244
DG
575/*
576 * Delete ust app session safely. RCU read lock must be held before calling
577 * this function.
578 */
8b366481 579static
d0b96690
DG
580void delete_ust_app_session(int sock, struct ust_app_session *ua_sess,
581 struct ust_app *app)
d80a6244
DG
582{
583 int ret;
bec39940 584 struct lttng_ht_iter iter;
d80a6244 585 struct ust_app_channel *ua_chan;
7972aab2 586 struct ust_registry_session *registry;
d80a6244 587
d88aee68
DG
588 assert(ua_sess);
589
7972aab2
DG
590 registry = get_session_registry(ua_sess);
591 if (registry) {
d88aee68 592 /* Push metadata for application before freeing the application. */
7972aab2 593 (void) push_metadata(registry, ua_sess->consumer);
d88aee68 594
7972aab2
DG
595 /*
596 * Don't ask to close metadata for global per UID buffers. Close
597 * metadata only on destroy trace session in this case.
598 */
599 if (ua_sess->buffer_type != LTTNG_BUFFER_PER_UID) {
600 /* And ask to close it for this session registry. */
601 (void) close_metadata(registry, ua_sess->consumer);
602 }
d80a6244
DG
603 }
604
bec39940
DG
605 cds_lfht_for_each_entry(ua_sess->channels->ht, &iter.iter, ua_chan,
606 node.node) {
607 ret = lttng_ht_del(ua_sess->channels, &iter);
525b0740 608 assert(!ret);
d0b96690 609 delete_ust_app_channel(sock, ua_chan, app);
d80a6244 610 }
d80a6244 611
7972aab2
DG
612 /* In case of per PID, the registry is kept in the session. */
613 if (ua_sess->buffer_type == LTTNG_BUFFER_PER_PID) {
614 struct buffer_reg_pid *reg_pid = buffer_reg_pid_find(ua_sess->id);
615 if (reg_pid) {
616 buffer_reg_pid_remove(reg_pid);
617 buffer_reg_pid_destroy(reg_pid);
618 }
619 }
d0b96690 620
aee6bafd 621 if (ua_sess->handle != -1) {
ffe60014
DG
622 ret = ustctl_release_handle(sock, ua_sess->handle);
623 if (ret < 0 && ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
624 ERR("UST app sock %d release session handle failed with ret %d",
625 sock, ret);
626 }
aee6bafd 627 }
36b588ed 628 call_rcu(&ua_sess->rcu_head, delete_ust_app_session_rcu);
d80a6244 629}
91d76f53
DG
630
631/*
284d8f55
DG
632 * Delete a traceable application structure from the global list. Never call
633 * this function outside of a call_rcu call.
36b588ed
MD
634 *
635 * RCU read side lock should _NOT_ be held when calling this function.
91d76f53 636 */
8b366481
DG
637static
638void delete_ust_app(struct ust_app *app)
91d76f53 639{
8b366481 640 int ret, sock;
d42f20df 641 struct ust_app_session *ua_sess, *tmp_ua_sess;
44d3bd01 642
d80a6244 643 /* Delete ust app sessions info */
852d0037
DG
644 sock = app->sock;
645 app->sock = -1;
d80a6244 646
8b366481 647 /* Wipe sessions */
d42f20df
DG
648 cds_list_for_each_entry_safe(ua_sess, tmp_ua_sess, &app->teardown_head,
649 teardown_node) {
650 /* Free every object in the session and the session. */
36b588ed 651 rcu_read_lock();
d0b96690 652 delete_ust_app_session(sock, ua_sess, app);
36b588ed 653 rcu_read_unlock();
d80a6244 654 }
36b588ed
MD
655
656 lttng_ht_destroy(app->sessions);
7972aab2 657 lttng_ht_destroy(app->ust_objd);
d80a6244 658
6414a713 659 /*
852d0037
DG
660 * Wait until we have deleted the application from the sock hash table
661 * before closing this socket, otherwise an application could re-use the
662 * socket ID and race with the teardown, using the same hash table entry.
663 *
664 * It's OK to leave the close in call_rcu. We want it to stay unique for
665 * all RCU readers that could run concurrently with unregister app,
666 * therefore we _need_ to only close that socket after a grace period. So
667 * it should stay in this RCU callback.
668 *
669 * This close() is a very important step of the synchronization model so
670 * every modification to this function must be carefully reviewed.
6414a713 671 */
799e2c4f
MD
672 ret = close(sock);
673 if (ret) {
674 PERROR("close");
675 }
4063050c 676 lttng_fd_put(LTTNG_FD_APPS, 1);
d80a6244 677
852d0037 678 DBG2("UST app pid %d deleted", app->pid);
284d8f55 679 free(app);
099e26bd
DG
680}
681
682/*
f6a9efaa 683 * URCU intermediate call to delete an UST app.
099e26bd 684 */
8b366481
DG
685static
686void delete_ust_app_rcu(struct rcu_head *head)
099e26bd 687{
bec39940
DG
688 struct lttng_ht_node_ulong *node =
689 caa_container_of(head, struct lttng_ht_node_ulong, head);
f6a9efaa 690 struct ust_app *app =
852d0037 691 caa_container_of(node, struct ust_app, pid_n);
f6a9efaa 692
852d0037 693 DBG3("Call RCU deleting app PID %d", app->pid);
f6a9efaa 694 delete_ust_app(app);
099e26bd
DG
695}
696
ffe60014
DG
697/*
698 * Delete the session from the application ht and delete the data structure by
699 * freeing every object inside and releasing them.
700 */
d0b96690 701static void destroy_app_session(struct ust_app *app,
ffe60014
DG
702 struct ust_app_session *ua_sess)
703{
704 int ret;
705 struct lttng_ht_iter iter;
706
707 assert(app);
708 assert(ua_sess);
709
710 iter.iter.node = &ua_sess->node.node;
711 ret = lttng_ht_del(app->sessions, &iter);
712 if (ret) {
713 /* Already scheduled for teardown. */
714 goto end;
715 }
716
717 /* Once deleted, free the data structure. */
d0b96690 718 delete_ust_app_session(app->sock, ua_sess, app);
ffe60014
DG
719
720end:
721 return;
722}
723
8b366481
DG
724/*
725 * Alloc new UST app session.
726 */
727static
d0b96690 728struct ust_app_session *alloc_ust_app_session(struct ust_app *app)
8b366481
DG
729{
730 struct ust_app_session *ua_sess;
731
732 /* Init most of the default value by allocating and zeroing */
733 ua_sess = zmalloc(sizeof(struct ust_app_session));
734 if (ua_sess == NULL) {
735 PERROR("malloc");
ffe60014 736 goto error_free;
8b366481
DG
737 }
738
739 ua_sess->handle = -1;
bec39940 740 ua_sess->channels = lttng_ht_new(0, LTTNG_HT_TYPE_STRING);
d0b96690 741 pthread_mutex_init(&ua_sess->lock, NULL);
ffe60014 742
8b366481
DG
743 return ua_sess;
744
ffe60014 745error_free:
8b366481
DG
746 return NULL;
747}
748
749/*
750 * Alloc new UST app channel.
751 */
752static
753struct ust_app_channel *alloc_ust_app_channel(char *name,
d0b96690 754 struct ust_app_session *ua_sess,
ffe60014 755 struct lttng_ust_channel_attr *attr)
8b366481
DG
756{
757 struct ust_app_channel *ua_chan;
758
759 /* Init most of the default value by allocating and zeroing */
760 ua_chan = zmalloc(sizeof(struct ust_app_channel));
761 if (ua_chan == NULL) {
762 PERROR("malloc");
763 goto error;
764 }
765
766 /* Setup channel name */
767 strncpy(ua_chan->name, name, sizeof(ua_chan->name));
768 ua_chan->name[sizeof(ua_chan->name) - 1] = '\0';
769
770 ua_chan->enabled = 1;
771 ua_chan->handle = -1;
45893984 772 ua_chan->session = ua_sess;
ffe60014 773 ua_chan->key = get_next_channel_key();
bec39940
DG
774 ua_chan->ctx = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG);
775 ua_chan->events = lttng_ht_new(0, LTTNG_HT_TYPE_STRING);
776 lttng_ht_node_init_str(&ua_chan->node, ua_chan->name);
8b366481
DG
777
778 CDS_INIT_LIST_HEAD(&ua_chan->streams.head);
779
780 /* Copy attributes */
781 if (attr) {
ffe60014 782 /* Translate from lttng_ust_channel to ustctl_consumer_channel_attr. */
2fe6e7f5
DG
783 ua_chan->attr.subbuf_size = attr->subbuf_size;
784 ua_chan->attr.num_subbuf = attr->num_subbuf;
785 ua_chan->attr.overwrite = attr->overwrite;
786 ua_chan->attr.switch_timer_interval = attr->switch_timer_interval;
787 ua_chan->attr.read_timer_interval = attr->read_timer_interval;
788 ua_chan->attr.output = attr->output;
8b366481 789 }
ffe60014
DG
790 /* By default, the channel is a per cpu channel. */
791 ua_chan->attr.type = LTTNG_UST_CHAN_PER_CPU;
8b366481
DG
792
793 DBG3("UST app channel %s allocated", ua_chan->name);
794
795 return ua_chan;
796
797error:
798 return NULL;
799}
800
37f1c236
DG
801/*
802 * Allocate and initialize a UST app stream.
803 *
804 * Return newly allocated stream pointer or NULL on error.
805 */
ffe60014 806struct ust_app_stream *ust_app_alloc_stream(void)
37f1c236
DG
807{
808 struct ust_app_stream *stream = NULL;
809
810 stream = zmalloc(sizeof(*stream));
811 if (stream == NULL) {
812 PERROR("zmalloc ust app stream");
813 goto error;
814 }
815
816 /* Zero could be a valid value for a handle so flag it to -1. */
817 stream->handle = -1;
818
819error:
820 return stream;
821}
822
8b366481
DG
823/*
824 * Alloc new UST app event.
825 */
826static
827struct ust_app_event *alloc_ust_app_event(char *name,
828 struct lttng_ust_event *attr)
829{
830 struct ust_app_event *ua_event;
831
832 /* Init most of the default value by allocating and zeroing */
833 ua_event = zmalloc(sizeof(struct ust_app_event));
834 if (ua_event == NULL) {
835 PERROR("malloc");
836 goto error;
837 }
838
839 ua_event->enabled = 1;
840 strncpy(ua_event->name, name, sizeof(ua_event->name));
841 ua_event->name[sizeof(ua_event->name) - 1] = '\0';
bec39940 842 lttng_ht_node_init_str(&ua_event->node, ua_event->name);
8b366481
DG
843
844 /* Copy attributes */
845 if (attr) {
846 memcpy(&ua_event->attr, attr, sizeof(ua_event->attr));
847 }
848
849 DBG3("UST app event %s allocated", ua_event->name);
850
851 return ua_event;
852
853error:
854 return NULL;
855}
856
857/*
858 * Alloc new UST app context.
859 */
860static
861struct ust_app_ctx *alloc_ust_app_ctx(struct lttng_ust_context *uctx)
862{
863 struct ust_app_ctx *ua_ctx;
864
865 ua_ctx = zmalloc(sizeof(struct ust_app_ctx));
866 if (ua_ctx == NULL) {
867 goto error;
868 }
869
870 if (uctx) {
871 memcpy(&ua_ctx->ctx, uctx, sizeof(ua_ctx->ctx));
872 }
873
874 DBG3("UST app context %d allocated", ua_ctx->ctx.ctx);
875
876error:
877 return ua_ctx;
878}
879
025faf73
DG
880/*
881 * Allocate a filter and copy the given original filter.
882 *
883 * Return allocated filter or NULL on error.
884 */
885static struct lttng_ust_filter_bytecode *alloc_copy_ust_app_filter(
886 struct lttng_ust_filter_bytecode *orig_f)
887{
888 struct lttng_ust_filter_bytecode *filter = NULL;
889
890 /* Copy filter bytecode */
891 filter = zmalloc(sizeof(*filter) + orig_f->len);
892 if (!filter) {
893 PERROR("zmalloc alloc ust app filter");
894 goto error;
895 }
896
897 memcpy(filter, orig_f, sizeof(*filter) + orig_f->len);
898
899error:
900 return filter;
901}
902
099e26bd 903/*
421cb601
DG
904 * Find an ust_app using the sock and return it. RCU read side lock must be
905 * held before calling this helper function.
099e26bd 906 */
8b366481
DG
907static
908struct ust_app *find_app_by_sock(int sock)
099e26bd 909{
bec39940 910 struct lttng_ht_node_ulong *node;
bec39940 911 struct lttng_ht_iter iter;
f6a9efaa 912
852d0037 913 lttng_ht_lookup(ust_app_ht_by_sock, (void *)((unsigned long) sock), &iter);
bec39940 914 node = lttng_ht_iter_get_node_ulong(&iter);
f6a9efaa
DG
915 if (node == NULL) {
916 DBG2("UST app find by sock %d not found", sock);
f6a9efaa
DG
917 goto error;
918 }
852d0037
DG
919
920 return caa_container_of(node, struct ust_app, sock_n);
f6a9efaa
DG
921
922error:
923 return NULL;
099e26bd
DG
924}
925
d0b96690
DG
926/*
927 * Find an ust_app using the notify sock and return it. RCU read side lock must
928 * be held before calling this helper function.
929 */
930static struct ust_app *find_app_by_notify_sock(int sock)
931{
932 struct lttng_ht_node_ulong *node;
933 struct lttng_ht_iter iter;
934
935 lttng_ht_lookup(ust_app_ht_by_notify_sock, (void *)((unsigned long) sock),
936 &iter);
937 node = lttng_ht_iter_get_node_ulong(&iter);
938 if (node == NULL) {
939 DBG2("UST app find by notify sock %d not found", sock);
940 goto error;
941 }
942
943 return caa_container_of(node, struct ust_app, notify_sock_n);
944
945error:
946 return NULL;
947}
948
025faf73
DG
949/*
950 * Lookup for an ust app event based on event name, filter bytecode and the
951 * event loglevel.
952 *
953 * Return an ust_app_event object or NULL on error.
954 */
18eace3b
DG
955static struct ust_app_event *find_ust_app_event(struct lttng_ht *ht,
956 char *name, struct lttng_ust_filter_bytecode *filter, int loglevel)
957{
958 struct lttng_ht_iter iter;
959 struct lttng_ht_node_str *node;
960 struct ust_app_event *event = NULL;
961 struct ust_app_ht_key key;
18eace3b
DG
962
963 assert(name);
964 assert(ht);
965
966 /* Setup key for event lookup. */
967 key.name = name;
968 key.filter = filter;
969 key.loglevel = loglevel;
970
025faf73
DG
971 /* Lookup using the event name as hash and a custom match fct. */
972 cds_lfht_lookup(ht->ht, ht->hash_fct((void *) name, lttng_ht_seed),
973 ht_match_ust_app_event, &key, &iter.iter);
18eace3b
DG
974 node = lttng_ht_iter_get_node_str(&iter);
975 if (node == NULL) {
976 goto end;
977 }
978
979 event = caa_container_of(node, struct ust_app_event, node);
980
981end:
18eace3b
DG
982 return event;
983}
984
55cc08a6
DG
985/*
986 * Create the channel context on the tracer.
d0b96690
DG
987 *
988 * Called with UST app session lock held.
55cc08a6
DG
989 */
990static
991int create_ust_channel_context(struct ust_app_channel *ua_chan,
992 struct ust_app_ctx *ua_ctx, struct ust_app *app)
993{
994 int ret;
995
840cb59c 996 health_code_update();
86acf0da 997
852d0037 998 ret = ustctl_add_context(app->sock, &ua_ctx->ctx,
55cc08a6
DG
999 ua_chan->obj, &ua_ctx->obj);
1000 if (ret < 0) {
ffe60014
DG
1001 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
1002 ERR("UST app create channel context failed for app (pid: %d) "
1003 "with ret %d", app->pid, ret);
1004 } else {
1005 DBG3("UST app disable event failed. Application is dead.");
1006 }
55cc08a6
DG
1007 goto error;
1008 }
1009
1010 ua_ctx->handle = ua_ctx->obj->handle;
1011
d0b96690
DG
1012 DBG2("UST app context handle %d created successfully for channel %s",
1013 ua_ctx->handle, ua_chan->name);
55cc08a6
DG
1014
1015error:
840cb59c 1016 health_code_update();
55cc08a6
DG
1017 return ret;
1018}
1019
53a80697
MD
1020/*
1021 * Set the filter on the tracer.
1022 */
1023static
1024int set_ust_event_filter(struct ust_app_event *ua_event,
1025 struct ust_app *app)
1026{
1027 int ret;
1028
840cb59c 1029 health_code_update();
86acf0da 1030
53a80697 1031 if (!ua_event->filter) {
86acf0da
DG
1032 ret = 0;
1033 goto error;
53a80697
MD
1034 }
1035
1036 ret = ustctl_set_filter(app->sock, ua_event->filter,
1037 ua_event->obj);
1038 if (ret < 0) {
ffe60014
DG
1039 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
1040 ERR("UST app event %s filter failed for app (pid: %d) "
1041 "with ret %d", ua_event->attr.name, app->pid, ret);
1042 } else {
1043 DBG3("UST app filter event failed. Application is dead.");
1044 }
53a80697
MD
1045 goto error;
1046 }
1047
1048 DBG2("UST filter set successfully for event %s", ua_event->name);
1049
1050error:
840cb59c 1051 health_code_update();
53a80697
MD
1052 return ret;
1053}
1054
9730260e
DG
1055/*
1056 * Disable the specified event on to UST tracer for the UST session.
1057 */
1058static int disable_ust_event(struct ust_app *app,
1059 struct ust_app_session *ua_sess, struct ust_app_event *ua_event)
1060{
1061 int ret;
1062
840cb59c 1063 health_code_update();
86acf0da 1064
852d0037 1065 ret = ustctl_disable(app->sock, ua_event->obj);
9730260e 1066 if (ret < 0) {
ffe60014
DG
1067 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
1068 ERR("UST app event %s disable failed for app (pid: %d) "
1069 "and session handle %d with ret %d",
1070 ua_event->attr.name, app->pid, ua_sess->handle, ret);
1071 } else {
1072 DBG3("UST app disable event failed. Application is dead.");
1073 }
9730260e
DG
1074 goto error;
1075 }
1076
1077 DBG2("UST app event %s disabled successfully for app (pid: %d)",
852d0037 1078 ua_event->attr.name, app->pid);
9730260e
DG
1079
1080error:
840cb59c 1081 health_code_update();
9730260e
DG
1082 return ret;
1083}
1084
78f0bacd
DG
1085/*
1086 * Disable the specified channel on to UST tracer for the UST session.
1087 */
1088static int disable_ust_channel(struct ust_app *app,
1089 struct ust_app_session *ua_sess, struct ust_app_channel *ua_chan)
1090{
1091 int ret;
1092
840cb59c 1093 health_code_update();
86acf0da 1094
852d0037 1095 ret = ustctl_disable(app->sock, ua_chan->obj);
78f0bacd 1096 if (ret < 0) {
ffe60014
DG
1097 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
1098 ERR("UST app channel %s disable failed for app (pid: %d) "
1099 "and session handle %d with ret %d",
1100 ua_chan->name, app->pid, ua_sess->handle, ret);
1101 } else {
1102 DBG3("UST app disable channel failed. Application is dead.");
1103 }
78f0bacd
DG
1104 goto error;
1105 }
1106
78f0bacd 1107 DBG2("UST app channel %s disabled successfully for app (pid: %d)",
852d0037 1108 ua_chan->name, app->pid);
78f0bacd
DG
1109
1110error:
840cb59c 1111 health_code_update();
78f0bacd
DG
1112 return ret;
1113}
1114
1115/*
1116 * Enable the specified channel on to UST tracer for the UST session.
1117 */
1118static int enable_ust_channel(struct ust_app *app,
1119 struct ust_app_session *ua_sess, struct ust_app_channel *ua_chan)
1120{
1121 int ret;
1122
840cb59c 1123 health_code_update();
86acf0da 1124
852d0037 1125 ret = ustctl_enable(app->sock, ua_chan->obj);
78f0bacd 1126 if (ret < 0) {
ffe60014
DG
1127 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
1128 ERR("UST app channel %s enable failed for app (pid: %d) "
1129 "and session handle %d with ret %d",
1130 ua_chan->name, app->pid, ua_sess->handle, ret);
1131 } else {
1132 DBG3("UST app enable channel failed. Application is dead.");
1133 }
78f0bacd
DG
1134 goto error;
1135 }
1136
1137 ua_chan->enabled = 1;
1138
1139 DBG2("UST app channel %s enabled successfully for app (pid: %d)",
852d0037 1140 ua_chan->name, app->pid);
78f0bacd
DG
1141
1142error:
840cb59c 1143 health_code_update();
78f0bacd
DG
1144 return ret;
1145}
1146
edb67388
DG
1147/*
1148 * Enable the specified event on to UST tracer for the UST session.
1149 */
1150static int enable_ust_event(struct ust_app *app,
1151 struct ust_app_session *ua_sess, struct ust_app_event *ua_event)
1152{
1153 int ret;
1154
840cb59c 1155 health_code_update();
86acf0da 1156
852d0037 1157 ret = ustctl_enable(app->sock, ua_event->obj);
edb67388 1158 if (ret < 0) {
ffe60014
DG
1159 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
1160 ERR("UST app event %s enable failed for app (pid: %d) "
1161 "and session handle %d with ret %d",
1162 ua_event->attr.name, app->pid, ua_sess->handle, ret);
1163 } else {
1164 DBG3("UST app enable event failed. Application is dead.");
1165 }
edb67388
DG
1166 goto error;
1167 }
1168
1169 DBG2("UST app event %s enabled successfully for app (pid: %d)",
852d0037 1170 ua_event->attr.name, app->pid);
edb67388
DG
1171
1172error:
840cb59c 1173 health_code_update();
edb67388
DG
1174 return ret;
1175}
1176
099e26bd 1177/*
7972aab2 1178 * Send channel and stream buffer to application.
4f3ab6ee 1179 *
ffe60014 1180 * Return 0 on success. On error, a negative value is returned.
4f3ab6ee 1181 */
7972aab2
DG
1182static int send_channel_pid_to_ust(struct ust_app *app,
1183 struct ust_app_session *ua_sess, struct ust_app_channel *ua_chan)
4f3ab6ee
DG
1184{
1185 int ret;
ffe60014 1186 struct ust_app_stream *stream, *stmp;
4f3ab6ee
DG
1187
1188 assert(app);
ffe60014 1189 assert(ua_sess);
4f3ab6ee 1190 assert(ua_chan);
4f3ab6ee 1191
840cb59c 1192 health_code_update();
4f3ab6ee 1193
7972aab2
DG
1194 DBG("UST app sending channel %s to UST app sock %d", ua_chan->name,
1195 app->sock);
86acf0da 1196
ffe60014
DG
1197 /* Send channel to the application. */
1198 ret = ust_consumer_send_channel_to_ust(app, ua_sess, ua_chan);
5b4a0ec0 1199 if (ret < 0) {
b551a063
DG
1200 goto error;
1201 }
1202
d88aee68
DG
1203 health_code_update();
1204
ffe60014
DG
1205 /* Send all streams to application. */
1206 cds_list_for_each_entry_safe(stream, stmp, &ua_chan->streams.head, list) {
1207 ret = ust_consumer_send_stream_to_ust(app, ua_chan, stream);
1208 if (ret < 0) {
1209 goto error;
1210 }
1211 /* We don't need the stream anymore once sent to the tracer. */
1212 cds_list_del(&stream->list);
1213 delete_ust_app_stream(-1, stream);
1214 }
ffe60014
DG
1215 /* Flag the channel that it is sent to the application. */
1216 ua_chan->is_sent = 1;
ffe60014 1217
b551a063 1218error:
840cb59c 1219 health_code_update();
b551a063
DG
1220 return ret;
1221}
1222
91d76f53 1223/*
5b4a0ec0 1224 * Create the specified event onto the UST tracer for a UST session.
d0b96690
DG
1225 *
1226 * Should be called with session mutex held.
91d76f53 1227 */
edb67388
DG
1228static
1229int create_ust_event(struct ust_app *app, struct ust_app_session *ua_sess,
1230 struct ust_app_channel *ua_chan, struct ust_app_event *ua_event)
91d76f53 1231{
5b4a0ec0 1232 int ret = 0;
284d8f55 1233
840cb59c 1234 health_code_update();
86acf0da 1235
5b4a0ec0 1236 /* Create UST event on tracer */
852d0037 1237 ret = ustctl_create_event(app->sock, &ua_event->attr, ua_chan->obj,
5b4a0ec0
DG
1238 &ua_event->obj);
1239 if (ret < 0) {
ffe60014
DG
1240 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
1241 ERR("Error ustctl create event %s for app pid: %d with ret %d",
1242 ua_event->attr.name, app->pid, ret);
1243 } else {
1244 DBG3("UST app create event failed. Application is dead.");
1245 }
5b4a0ec0 1246 goto error;
91d76f53 1247 }
f6a9efaa 1248
5b4a0ec0 1249 ua_event->handle = ua_event->obj->handle;
284d8f55 1250
5b4a0ec0 1251 DBG2("UST app event %s created successfully for pid:%d",
852d0037 1252 ua_event->attr.name, app->pid);
f6a9efaa 1253
840cb59c 1254 health_code_update();
86acf0da 1255
025faf73
DG
1256 /* Set filter if one is present. */
1257 if (ua_event->filter) {
1258 ret = set_ust_event_filter(ua_event, app);
1259 if (ret < 0) {
1260 goto error;
1261 }
1262 }
1263
8535a6d9 1264 /* If event not enabled, disable it on the tracer */
fc34caaa 1265 if (ua_event->enabled == 0) {
8535a6d9
DG
1266 ret = disable_ust_event(app, ua_sess, ua_event);
1267 if (ret < 0) {
fc34caaa
DG
1268 /*
1269 * If we hit an EPERM, something is wrong with our disable call. If
1270 * we get an EEXIST, there is a problem on the tracer side since we
1271 * just created it.
1272 */
1273 switch (ret) {
49c336c1 1274 case -LTTNG_UST_ERR_PERM:
fc34caaa
DG
1275 /* Code flow problem */
1276 assert(0);
49c336c1 1277 case -LTTNG_UST_ERR_EXIST:
fc34caaa
DG
1278 /* It's OK for our use case. */
1279 ret = 0;
1280 break;
1281 default:
1282 break;
1283 }
8535a6d9
DG
1284 goto error;
1285 }
1286 }
1287
5b4a0ec0 1288error:
840cb59c 1289 health_code_update();
5b4a0ec0 1290 return ret;
91d76f53 1291}
48842b30 1292
5b4a0ec0
DG
1293/*
1294 * Copy data between an UST app event and a LTT event.
1295 */
421cb601 1296static void shadow_copy_event(struct ust_app_event *ua_event,
48842b30
DG
1297 struct ltt_ust_event *uevent)
1298{
1299 strncpy(ua_event->name, uevent->attr.name, sizeof(ua_event->name));
1300 ua_event->name[sizeof(ua_event->name) - 1] = '\0';
1301
fc34caaa
DG
1302 ua_event->enabled = uevent->enabled;
1303
5b4a0ec0
DG
1304 /* Copy event attributes */
1305 memcpy(&ua_event->attr, &uevent->attr, sizeof(ua_event->attr));
1306
53a80697
MD
1307 /* Copy filter bytecode */
1308 if (uevent->filter) {
025faf73
DG
1309 ua_event->filter = alloc_copy_ust_app_filter(uevent->filter);
1310 /* Filter might be NULL here in case of ENONEM. */
53a80697 1311 }
48842b30
DG
1312}
1313
5b4a0ec0
DG
1314/*
1315 * Copy data between an UST app channel and a LTT channel.
1316 */
421cb601 1317static void shadow_copy_channel(struct ust_app_channel *ua_chan,
48842b30
DG
1318 struct ltt_ust_channel *uchan)
1319{
bec39940 1320 struct lttng_ht_iter iter;
48842b30 1321 struct ltt_ust_event *uevent;
55cc08a6 1322 struct ltt_ust_context *uctx;
48842b30 1323 struct ust_app_event *ua_event;
55cc08a6 1324 struct ust_app_ctx *ua_ctx;
48842b30 1325
fc34caaa 1326 DBG2("UST app shadow copy of channel %s started", ua_chan->name);
48842b30
DG
1327
1328 strncpy(ua_chan->name, uchan->name, sizeof(ua_chan->name));
1329 ua_chan->name[sizeof(ua_chan->name) - 1] = '\0';
ffe60014 1330
1624d5b7
JD
1331 ua_chan->tracefile_size = uchan->tracefile_size;
1332 ua_chan->tracefile_count = uchan->tracefile_count;
1333
ffe60014
DG
1334 /* Copy event attributes since the layout is different. */
1335 ua_chan->attr.subbuf_size = uchan->attr.subbuf_size;
1336 ua_chan->attr.num_subbuf = uchan->attr.num_subbuf;
1337 ua_chan->attr.overwrite = uchan->attr.overwrite;
1338 ua_chan->attr.switch_timer_interval = uchan->attr.switch_timer_interval;
1339 ua_chan->attr.read_timer_interval = uchan->attr.read_timer_interval;
1340 ua_chan->attr.output = uchan->attr.output;
1341 /*
1342 * Note that the attribute channel type is not set since the channel on the
1343 * tracing registry side does not have this information.
1344 */
48842b30 1345
fc34caaa 1346 ua_chan->enabled = uchan->enabled;
7972aab2 1347 ua_chan->tracing_channel_id = uchan->id;
fc34caaa 1348
bec39940 1349 cds_lfht_for_each_entry(uchan->ctx->ht, &iter.iter, uctx, node.node) {
55cc08a6
DG
1350 ua_ctx = alloc_ust_app_ctx(&uctx->ctx);
1351 if (ua_ctx == NULL) {
1352 continue;
1353 }
bec39940
DG
1354 lttng_ht_node_init_ulong(&ua_ctx->node,
1355 (unsigned long) ua_ctx->ctx.ctx);
1356 lttng_ht_add_unique_ulong(ua_chan->ctx, &ua_ctx->node);
55cc08a6 1357 }
48842b30 1358
421cb601 1359 /* Copy all events from ltt ust channel to ust app channel */
bec39940 1360 cds_lfht_for_each_entry(uchan->events->ht, &iter.iter, uevent, node.node) {
18eace3b
DG
1361 ua_event = find_ust_app_event(ua_chan->events, uevent->attr.name,
1362 uevent->filter, uevent->attr.loglevel);
1363 if (ua_event == NULL) {
421cb601 1364 DBG2("UST event %s not found on shadow copy channel",
48842b30 1365 uevent->attr.name);
284d8f55 1366 ua_event = alloc_ust_app_event(uevent->attr.name, &uevent->attr);
48842b30 1367 if (ua_event == NULL) {
5b4a0ec0 1368 continue;
48842b30 1369 }
421cb601 1370 shadow_copy_event(ua_event, uevent);
d0b96690 1371 add_unique_ust_app_event(ua_chan, ua_event);
48842b30 1372 }
48842b30
DG
1373 }
1374
fc34caaa 1375 DBG3("UST app shadow copy of channel %s done", ua_chan->name);
48842b30
DG
1376}
1377
5b4a0ec0
DG
1378/*
1379 * Copy data between a UST app session and a regular LTT session.
1380 */
421cb601 1381static void shadow_copy_session(struct ust_app_session *ua_sess,
bec39940 1382 struct ltt_ust_session *usess, struct ust_app *app)
48842b30 1383{
bec39940
DG
1384 struct lttng_ht_node_str *ua_chan_node;
1385 struct lttng_ht_iter iter;
48842b30
DG
1386 struct ltt_ust_channel *uchan;
1387 struct ust_app_channel *ua_chan;
477d7741
MD
1388 time_t rawtime;
1389 struct tm *timeinfo;
1390 char datetime[16];
1391 int ret;
1392
1393 /* Get date and time for unique app path */
1394 time(&rawtime);
1395 timeinfo = localtime(&rawtime);
1396 strftime(datetime, sizeof(datetime), "%Y%m%d-%H%M%S", timeinfo);
48842b30 1397
421cb601 1398 DBG2("Shadow copy of session handle %d", ua_sess->handle);
48842b30 1399
7972aab2
DG
1400 ua_sess->tracing_id = usess->id;
1401 ua_sess->id = get_next_session_id();
1402 ua_sess->uid = app->uid;
1403 ua_sess->gid = app->gid;
1404 ua_sess->euid = usess->uid;
1405 ua_sess->egid = usess->gid;
1406 ua_sess->buffer_type = usess->buffer_type;
1407 ua_sess->bits_per_long = app->bits_per_long;
1408 /* There is only one consumer object per session possible. */
1409 ua_sess->consumer = usess->consumer;
1410
1411 switch (ua_sess->buffer_type) {
1412 case LTTNG_BUFFER_PER_PID:
1413 ret = snprintf(ua_sess->path, sizeof(ua_sess->path),
dec56f6c 1414 DEFAULT_UST_TRACE_PID_PATH "/%s-%d-%s", app->name, app->pid,
7972aab2
DG
1415 datetime);
1416 break;
1417 case LTTNG_BUFFER_PER_UID:
1418 ret = snprintf(ua_sess->path, sizeof(ua_sess->path),
1419 DEFAULT_UST_TRACE_UID_PATH, ua_sess->uid, app->bits_per_long);
1420 break;
1421 default:
1422 assert(0);
1423 goto error;
1424 }
477d7741
MD
1425 if (ret < 0) {
1426 PERROR("asprintf UST shadow copy session");
477d7741 1427 assert(0);
7972aab2 1428 goto error;
477d7741
MD
1429 }
1430
48842b30 1431 /* Iterate over all channels in global domain. */
bec39940
DG
1432 cds_lfht_for_each_entry(usess->domain_global.channels->ht, &iter.iter,
1433 uchan, node.node) {
1434 struct lttng_ht_iter uiter;
ba767faf 1435
bec39940
DG
1436 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &uiter);
1437 ua_chan_node = lttng_ht_iter_get_node_str(&uiter);
5b4a0ec0 1438 if (ua_chan_node != NULL) {
fc34caaa 1439 /* Session exist. Contiuing. */
5b4a0ec0
DG
1440 continue;
1441 }
421cb601 1442
5b4a0ec0
DG
1443 DBG2("Channel %s not found on shadow session copy, creating it",
1444 uchan->name);
d0b96690 1445 ua_chan = alloc_ust_app_channel(uchan->name, ua_sess, &uchan->attr);
5b4a0ec0 1446 if (ua_chan == NULL) {
fc34caaa 1447 /* malloc failed FIXME: Might want to do handle ENOMEM .. */
5b4a0ec0 1448 continue;
48842b30 1449 }
5b4a0ec0 1450 shadow_copy_channel(ua_chan, uchan);
ffe60014
DG
1451 /*
1452 * The concept of metadata channel does not exist on the tracing
1453 * registry side of the session daemon so this can only be a per CPU
1454 * channel and not metadata.
1455 */
1456 ua_chan->attr.type = LTTNG_UST_CHAN_PER_CPU;
1457
bec39940 1458 lttng_ht_add_unique_str(ua_sess->channels, &ua_chan->node);
48842b30 1459 }
7972aab2
DG
1460
1461error:
1462 return;
48842b30
DG
1463}
1464
78f0bacd
DG
1465/*
1466 * Lookup sesison wrapper.
1467 */
84cd17c6
MD
1468static
1469void __lookup_session_by_app(struct ltt_ust_session *usess,
bec39940 1470 struct ust_app *app, struct lttng_ht_iter *iter)
84cd17c6
MD
1471{
1472 /* Get right UST app session from app */
2c348c10 1473 lttng_ht_lookup(app->sessions, (void *)((unsigned long) usess->id), iter);
84cd17c6
MD
1474}
1475
421cb601
DG
1476/*
1477 * Return ust app session from the app session hashtable using the UST session
a991f516 1478 * id.
421cb601 1479 */
48842b30
DG
1480static struct ust_app_session *lookup_session_by_app(
1481 struct ltt_ust_session *usess, struct ust_app *app)
1482{
bec39940
DG
1483 struct lttng_ht_iter iter;
1484 struct lttng_ht_node_ulong *node;
48842b30 1485
84cd17c6 1486 __lookup_session_by_app(usess, app, &iter);
bec39940 1487 node = lttng_ht_iter_get_node_ulong(&iter);
48842b30
DG
1488 if (node == NULL) {
1489 goto error;
1490 }
1491
1492 return caa_container_of(node, struct ust_app_session, node);
1493
1494error:
1495 return NULL;
1496}
1497
7972aab2
DG
1498/*
1499 * Setup buffer registry per PID for the given session and application. If none
1500 * is found, a new one is created, added to the global registry and
1501 * initialized. If regp is valid, it's set with the newly created object.
1502 *
1503 * Return 0 on success or else a negative value.
1504 */
1505static int setup_buffer_reg_pid(struct ust_app_session *ua_sess,
1506 struct ust_app *app, struct buffer_reg_pid **regp)
1507{
1508 int ret = 0;
1509 struct buffer_reg_pid *reg_pid;
1510
1511 assert(ua_sess);
1512 assert(app);
1513
1514 rcu_read_lock();
1515
1516 reg_pid = buffer_reg_pid_find(ua_sess->id);
1517 if (!reg_pid) {
1518 /*
1519 * This is the create channel path meaning that if there is NO
1520 * registry available, we have to create one for this session.
1521 */
1522 ret = buffer_reg_pid_create(ua_sess->id, &reg_pid);
1523 if (ret < 0) {
1524 goto error;
1525 }
1526 buffer_reg_pid_add(reg_pid);
1527 } else {
1528 goto end;
1529 }
1530
1531 /* Initialize registry. */
1532 ret = ust_registry_session_init(&reg_pid->registry->reg.ust, app,
1533 app->bits_per_long, app->uint8_t_alignment,
1534 app->uint16_t_alignment, app->uint32_t_alignment,
af6142cf
MD
1535 app->uint64_t_alignment, app->long_alignment,
1536 app->byte_order, app->version.major,
1537 app->version.minor);
7972aab2
DG
1538 if (ret < 0) {
1539 goto error;
1540 }
1541
1542 DBG3("UST app buffer registry per PID created successfully");
1543
1544end:
1545 if (regp) {
1546 *regp = reg_pid;
1547 }
1548error:
1549 rcu_read_unlock();
1550 return ret;
1551}
1552
1553/*
1554 * Setup buffer registry per UID for the given session and application. If none
1555 * is found, a new one is created, added to the global registry and
1556 * initialized. If regp is valid, it's set with the newly created object.
1557 *
1558 * Return 0 on success or else a negative value.
1559 */
1560static int setup_buffer_reg_uid(struct ltt_ust_session *usess,
1561 struct ust_app *app, struct buffer_reg_uid **regp)
1562{
1563 int ret = 0;
1564 struct buffer_reg_uid *reg_uid;
1565
1566 assert(usess);
1567 assert(app);
1568
1569 rcu_read_lock();
1570
1571 reg_uid = buffer_reg_uid_find(usess->id, app->bits_per_long, app->uid);
1572 if (!reg_uid) {
1573 /*
1574 * This is the create channel path meaning that if there is NO
1575 * registry available, we have to create one for this session.
1576 */
1577 ret = buffer_reg_uid_create(usess->id, app->bits_per_long, app->uid,
1578 LTTNG_DOMAIN_UST, &reg_uid);
1579 if (ret < 0) {
1580 goto error;
1581 }
1582 buffer_reg_uid_add(reg_uid);
1583 } else {
1584 goto end;
1585 }
1586
1587 /* Initialize registry. */
af6142cf 1588 ret = ust_registry_session_init(&reg_uid->registry->reg.ust, NULL,
7972aab2
DG
1589 app->bits_per_long, app->uint8_t_alignment,
1590 app->uint16_t_alignment, app->uint32_t_alignment,
af6142cf
MD
1591 app->uint64_t_alignment, app->long_alignment,
1592 app->byte_order, app->version.major,
1593 app->version.minor);
7972aab2
DG
1594 if (ret < 0) {
1595 goto error;
1596 }
1597 /* Add node to teardown list of the session. */
1598 cds_list_add(&reg_uid->lnode, &usess->buffer_reg_uid_list);
1599
1600 DBG3("UST app buffer registry per UID created successfully");
1601
1602end:
1603 if (regp) {
1604 *regp = reg_uid;
1605 }
1606error:
1607 rcu_read_unlock();
1608 return ret;
1609}
1610
421cb601 1611/*
3d8ca23b 1612 * Create a session on the tracer side for the given app.
421cb601 1613 *
3d8ca23b
DG
1614 * On success, ua_sess_ptr is populated with the session pointer or else left
1615 * untouched. If the session was created, is_created is set to 1. On error,
1616 * it's left untouched. Note that ua_sess_ptr is mandatory but is_created can
1617 * be NULL.
1618 *
1619 * Returns 0 on success or else a negative code which is either -ENOMEM or
1620 * -ENOTCONN which is the default code if the ustctl_create_session fails.
421cb601 1621 */
3d8ca23b
DG
1622static int create_ust_app_session(struct ltt_ust_session *usess,
1623 struct ust_app *app, struct ust_app_session **ua_sess_ptr,
1624 int *is_created)
421cb601 1625{
3d8ca23b 1626 int ret, created = 0;
421cb601
DG
1627 struct ust_app_session *ua_sess;
1628
3d8ca23b
DG
1629 assert(usess);
1630 assert(app);
1631 assert(ua_sess_ptr);
1632
840cb59c 1633 health_code_update();
86acf0da 1634
421cb601
DG
1635 ua_sess = lookup_session_by_app(usess, app);
1636 if (ua_sess == NULL) {
a991f516 1637 DBG2("UST app pid: %d session id %d not found, creating it",
852d0037 1638 app->pid, usess->id);
d0b96690 1639 ua_sess = alloc_ust_app_session(app);
421cb601
DG
1640 if (ua_sess == NULL) {
1641 /* Only malloc can failed so something is really wrong */
3d8ca23b
DG
1642 ret = -ENOMEM;
1643 goto error;
421cb601 1644 }
477d7741 1645 shadow_copy_session(ua_sess, usess, app);
3d8ca23b 1646 created = 1;
421cb601
DG
1647 }
1648
7972aab2
DG
1649 switch (usess->buffer_type) {
1650 case LTTNG_BUFFER_PER_PID:
1651 /* Init local registry. */
1652 ret = setup_buffer_reg_pid(ua_sess, app, NULL);
421cb601 1653 if (ret < 0) {
7972aab2
DG
1654 goto error;
1655 }
1656 break;
1657 case LTTNG_BUFFER_PER_UID:
1658 /* Look for a global registry. If none exists, create one. */
1659 ret = setup_buffer_reg_uid(usess, app, NULL);
1660 if (ret < 0) {
1661 goto error;
1662 }
1663 break;
1664 default:
1665 assert(0);
1666 ret = -EINVAL;
1667 goto error;
1668 }
1669
1670 health_code_update();
1671
1672 if (ua_sess->handle == -1) {
1673 ret = ustctl_create_session(app->sock);
1674 if (ret < 0) {
1675 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
1676 ERR("Creating session for app pid %d with ret %d",
ffe60014
DG
1677 app->pid, ret);
1678 } else {
1679 DBG("UST app creating session failed. Application is dead");
1680 }
d0b96690 1681 delete_ust_app_session(-1, ua_sess, app);
3d8ca23b
DG
1682 if (ret != -ENOMEM) {
1683 /*
1684 * Tracer is probably gone or got an internal error so let's
1685 * behave like it will soon unregister or not usable.
1686 */
1687 ret = -ENOTCONN;
1688 }
1689 goto error;
421cb601
DG
1690 }
1691
7972aab2
DG
1692 ua_sess->handle = ret;
1693
1694 /* Add ust app session to app's HT */
1695 lttng_ht_node_init_ulong(&ua_sess->node,
1696 (unsigned long) ua_sess->tracing_id);
1697 lttng_ht_add_unique_ulong(app->sessions, &ua_sess->node);
1698
1699 DBG2("UST app session created successfully with handle %d", ret);
1700 }
1701
1702 *ua_sess_ptr = ua_sess;
1703 if (is_created) {
1704 *is_created = created;
1705 }
1706
1707 /* Everything went well. */
1708 ret = 0;
1709
1710error:
1711 health_code_update();
1712 return ret;
1713}
1714
1715/*
1716 * Create a context for the channel on the tracer.
1717 *
1718 * Called with UST app session lock held and a RCU read side lock.
1719 */
1720static
1721int create_ust_app_channel_context(struct ust_app_session *ua_sess,
1722 struct ust_app_channel *ua_chan, struct lttng_ust_context *uctx,
1723 struct ust_app *app)
1724{
1725 int ret = 0;
1726 struct lttng_ht_iter iter;
1727 struct lttng_ht_node_ulong *node;
1728 struct ust_app_ctx *ua_ctx;
1729
1730 DBG2("UST app adding context to channel %s", ua_chan->name);
1731
1732 lttng_ht_lookup(ua_chan->ctx, (void *)((unsigned long)uctx->ctx), &iter);
1733 node = lttng_ht_iter_get_node_ulong(&iter);
1734 if (node != NULL) {
1735 ret = -EEXIST;
1736 goto error;
1737 }
1738
1739 ua_ctx = alloc_ust_app_ctx(uctx);
1740 if (ua_ctx == NULL) {
1741 /* malloc failed */
1742 ret = -1;
1743 goto error;
1744 }
1745
1746 lttng_ht_node_init_ulong(&ua_ctx->node, (unsigned long) ua_ctx->ctx.ctx);
1747 lttng_ht_add_unique_ulong(ua_chan->ctx, &ua_ctx->node);
1748
1749 ret = create_ust_channel_context(ua_chan, ua_ctx, app);
1750 if (ret < 0) {
1751 goto error;
1752 }
1753
1754error:
1755 return ret;
1756}
1757
1758/*
1759 * Enable on the tracer side a ust app event for the session and channel.
1760 *
1761 * Called with UST app session lock held.
1762 */
1763static
1764int enable_ust_app_event(struct ust_app_session *ua_sess,
1765 struct ust_app_event *ua_event, struct ust_app *app)
1766{
1767 int ret;
1768
1769 ret = enable_ust_event(app, ua_sess, ua_event);
1770 if (ret < 0) {
1771 goto error;
1772 }
1773
1774 ua_event->enabled = 1;
1775
1776error:
1777 return ret;
1778}
1779
1780/*
1781 * Disable on the tracer side a ust app event for the session and channel.
1782 */
1783static int disable_ust_app_event(struct ust_app_session *ua_sess,
1784 struct ust_app_event *ua_event, struct ust_app *app)
1785{
1786 int ret;
1787
1788 ret = disable_ust_event(app, ua_sess, ua_event);
1789 if (ret < 0) {
1790 goto error;
1791 }
1792
1793 ua_event->enabled = 0;
1794
1795error:
1796 return ret;
1797}
1798
1799/*
1800 * Lookup ust app channel for session and disable it on the tracer side.
1801 */
1802static
1803int disable_ust_app_channel(struct ust_app_session *ua_sess,
1804 struct ust_app_channel *ua_chan, struct ust_app *app)
1805{
1806 int ret;
1807
1808 ret = disable_ust_channel(app, ua_sess, ua_chan);
1809 if (ret < 0) {
1810 goto error;
1811 }
1812
1813 ua_chan->enabled = 0;
1814
1815error:
1816 return ret;
1817}
1818
1819/*
1820 * Lookup ust app channel for session and enable it on the tracer side. This
1821 * MUST be called with a RCU read side lock acquired.
1822 */
1823static int enable_ust_app_channel(struct ust_app_session *ua_sess,
1824 struct ltt_ust_channel *uchan, struct ust_app *app)
1825{
1826 int ret = 0;
1827 struct lttng_ht_iter iter;
1828 struct lttng_ht_node_str *ua_chan_node;
1829 struct ust_app_channel *ua_chan;
1830
1831 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &iter);
1832 ua_chan_node = lttng_ht_iter_get_node_str(&iter);
1833 if (ua_chan_node == NULL) {
1834 DBG2("Unable to find channel %s in ust session id %u",
1835 uchan->name, ua_sess->tracing_id);
1836 goto error;
1837 }
1838
1839 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
1840
1841 ret = enable_ust_channel(app, ua_sess, ua_chan);
1842 if (ret < 0) {
1843 goto error;
1844 }
1845
1846error:
1847 return ret;
1848}
1849
1850/*
1851 * Ask the consumer to create a channel and get it if successful.
1852 *
1853 * Return 0 on success or else a negative value.
1854 */
1855static int do_consumer_create_channel(struct ltt_ust_session *usess,
1856 struct ust_app_session *ua_sess, struct ust_app_channel *ua_chan,
1857 int bitness, struct ust_registry_session *registry)
1858{
1859 int ret;
1860 unsigned int nb_fd = 0;
1861 struct consumer_socket *socket;
1862
1863 assert(usess);
1864 assert(ua_sess);
1865 assert(ua_chan);
1866 assert(registry);
1867
1868 rcu_read_lock();
1869 health_code_update();
1870
1871 /* Get the right consumer socket for the application. */
1872 socket = consumer_find_socket_by_bitness(bitness, usess->consumer);
1873 if (!socket) {
1874 ret = -EINVAL;
1875 goto error;
1876 }
1877
1878 health_code_update();
1879
1880 /* Need one fd for the channel. */
1881 ret = lttng_fd_get(LTTNG_FD_APPS, 1);
1882 if (ret < 0) {
1883 ERR("Exhausted number of available FD upon create channel");
1884 goto error;
1885 }
1886
1887 /*
1888 * Ask consumer to create channel. The consumer will return the number of
1889 * stream we have to expect.
1890 */
1891 ret = ust_consumer_ask_channel(ua_sess, ua_chan, usess->consumer, socket,
1892 registry);
1893 if (ret < 0) {
1894 goto error_ask;
1895 }
1896
1897 /*
1898 * Compute the number of fd needed before receiving them. It must be 2 per
1899 * stream (2 being the default value here).
1900 */
1901 nb_fd = DEFAULT_UST_STREAM_FD_NUM * ua_chan->expected_stream_count;
1902
1903 /* Reserve the amount of file descriptor we need. */
1904 ret = lttng_fd_get(LTTNG_FD_APPS, nb_fd);
1905 if (ret < 0) {
1906 ERR("Exhausted number of available FD upon create channel");
1907 goto error_fd_get_stream;
1908 }
1909
1910 health_code_update();
1911
1912 /*
1913 * Now get the channel from the consumer. This call wil populate the stream
1914 * list of that channel and set the ust objects.
1915 */
1916 ret = ust_consumer_get_channel(socket, ua_chan);
1917 if (ret < 0) {
1918 goto error_destroy;
1919 }
1920
1921 rcu_read_unlock();
1922 return 0;
1923
1924error_destroy:
1925 lttng_fd_put(LTTNG_FD_APPS, nb_fd);
1926error_fd_get_stream:
1927 /*
1928 * Initiate a destroy channel on the consumer since we had an error
1929 * handling it on our side. The return value is of no importance since we
1930 * already have a ret value set by the previous error that we need to
1931 * return.
1932 */
1933 (void) ust_consumer_destroy_channel(socket, ua_chan);
1934error_ask:
1935 lttng_fd_put(LTTNG_FD_APPS, 1);
1936error:
1937 health_code_update();
1938 rcu_read_unlock();
1939 return ret;
1940}
1941
1942/*
1943 * Duplicate the ust data object of the ust app stream and save it in the
1944 * buffer registry stream.
1945 *
1946 * Return 0 on success or else a negative value.
1947 */
1948static int duplicate_stream_object(struct buffer_reg_stream *reg_stream,
1949 struct ust_app_stream *stream)
1950{
1951 int ret;
1952
1953 assert(reg_stream);
1954 assert(stream);
1955
1956 /* Reserve the amount of file descriptor we need. */
1957 ret = lttng_fd_get(LTTNG_FD_APPS, 2);
1958 if (ret < 0) {
1959 ERR("Exhausted number of available FD upon duplicate stream");
1960 goto error;
1961 }
1962
1963 /* Duplicate object for stream once the original is in the registry. */
1964 ret = ustctl_duplicate_ust_object_data(&stream->obj,
1965 reg_stream->obj.ust);
1966 if (ret < 0) {
1967 ERR("Duplicate stream obj from %p to %p failed with ret %d",
1968 reg_stream->obj.ust, stream->obj, ret);
1969 lttng_fd_put(LTTNG_FD_APPS, 2);
1970 goto error;
1971 }
1972 stream->handle = stream->obj->handle;
1973
1974error:
1975 return ret;
1976}
1977
1978/*
1979 * Duplicate the ust data object of the ust app. channel and save it in the
1980 * buffer registry channel.
1981 *
1982 * Return 0 on success or else a negative value.
1983 */
1984static int duplicate_channel_object(struct buffer_reg_channel *reg_chan,
1985 struct ust_app_channel *ua_chan)
1986{
1987 int ret;
1988
1989 assert(reg_chan);
1990 assert(ua_chan);
1991
1992 /* Need two fds for the channel. */
1993 ret = lttng_fd_get(LTTNG_FD_APPS, 1);
1994 if (ret < 0) {
1995 ERR("Exhausted number of available FD upon duplicate channel");
1996 goto error_fd_get;
1997 }
1998
1999 /* Duplicate object for stream once the original is in the registry. */
2000 ret = ustctl_duplicate_ust_object_data(&ua_chan->obj, reg_chan->obj.ust);
2001 if (ret < 0) {
2002 ERR("Duplicate channel obj from %p to %p failed with ret: %d",
2003 reg_chan->obj.ust, ua_chan->obj, ret);
2004 goto error;
2005 }
2006 ua_chan->handle = ua_chan->obj->handle;
2007
2008 return 0;
2009
2010error:
2011 lttng_fd_put(LTTNG_FD_APPS, 1);
2012error_fd_get:
2013 return ret;
2014}
2015
2016/*
2017 * For a given channel buffer registry, setup all streams of the given ust
2018 * application channel.
2019 *
2020 * Return 0 on success or else a negative value.
2021 */
2022static int setup_buffer_reg_streams(struct buffer_reg_channel *reg_chan,
2023 struct ust_app_channel *ua_chan)
2024{
2025 int ret = 0;
2026 struct ust_app_stream *stream, *stmp;
2027
2028 assert(reg_chan);
2029 assert(ua_chan);
2030
2031 DBG2("UST app setup buffer registry stream");
2032
2033 /* Send all streams to application. */
2034 cds_list_for_each_entry_safe(stream, stmp, &ua_chan->streams.head, list) {
2035 struct buffer_reg_stream *reg_stream;
2036
2037 ret = buffer_reg_stream_create(&reg_stream);
2038 if (ret < 0) {
2039 goto error;
2040 }
2041
2042 /*
2043 * Keep original pointer and nullify it in the stream so the delete
2044 * stream call does not release the object.
2045 */
2046 reg_stream->obj.ust = stream->obj;
2047 stream->obj = NULL;
2048 buffer_reg_stream_add(reg_stream, reg_chan);
421cb601 2049
7972aab2
DG
2050 /* We don't need the streams anymore. */
2051 cds_list_del(&stream->list);
2052 delete_ust_app_stream(-1, stream);
2053 }
421cb601 2054
7972aab2
DG
2055error:
2056 return ret;
2057}
2058
2059/*
2060 * Create a buffer registry channel for the given session registry and
2061 * application channel object. If regp pointer is valid, it's set with the
2062 * created object. Important, the created object is NOT added to the session
2063 * registry hash table.
2064 *
2065 * Return 0 on success else a negative value.
2066 */
2067static int create_buffer_reg_channel(struct buffer_reg_session *reg_sess,
2068 struct ust_app_channel *ua_chan, struct buffer_reg_channel **regp)
2069{
2070 int ret;
2071 struct buffer_reg_channel *reg_chan = NULL;
2072
2073 assert(reg_sess);
2074 assert(ua_chan);
2075
2076 DBG2("UST app creating buffer registry channel for %s", ua_chan->name);
2077
2078 /* Create buffer registry channel. */
2079 ret = buffer_reg_channel_create(ua_chan->tracing_channel_id, &reg_chan);
2080 if (ret < 0) {
2081 goto error_create;
421cb601 2082 }
7972aab2
DG
2083 assert(reg_chan);
2084 reg_chan->consumer_key = ua_chan->key;
421cb601 2085
7972aab2
DG
2086 /* Create and add a channel registry to session. */
2087 ret = ust_registry_channel_add(reg_sess->reg.ust,
2088 ua_chan->tracing_channel_id);
2089 if (ret < 0) {
2090 goto error;
d88aee68 2091 }
7972aab2 2092 buffer_reg_channel_add(reg_sess, reg_chan);
d88aee68 2093
7972aab2
DG
2094 if (regp) {
2095 *regp = reg_chan;
3d8ca23b 2096 }
d88aee68 2097
7972aab2 2098 return 0;
3d8ca23b
DG
2099
2100error:
7972aab2
DG
2101 /* Safe because the registry channel object was not added to any HT. */
2102 buffer_reg_channel_destroy(reg_chan, LTTNG_DOMAIN_UST);
2103error_create:
3d8ca23b 2104 return ret;
421cb601
DG
2105}
2106
55cc08a6 2107/*
7972aab2
DG
2108 * Setup buffer registry channel for the given session registry and application
2109 * channel object. If regp pointer is valid, it's set with the created object.
d0b96690 2110 *
7972aab2 2111 * Return 0 on success else a negative value.
55cc08a6 2112 */
7972aab2
DG
2113static int setup_buffer_reg_channel(struct buffer_reg_session *reg_sess,
2114 struct ust_app_channel *ua_chan, struct buffer_reg_channel *reg_chan)
55cc08a6 2115{
7972aab2 2116 int ret;
55cc08a6 2117
7972aab2
DG
2118 assert(reg_sess);
2119 assert(reg_chan);
2120 assert(ua_chan);
2121 assert(ua_chan->obj);
55cc08a6 2122
7972aab2 2123 DBG2("UST app setup buffer registry channel for %s", ua_chan->name);
55cc08a6 2124
7972aab2
DG
2125 /* Setup all streams for the registry. */
2126 ret = setup_buffer_reg_streams(reg_chan, ua_chan);
2127 if (ret < 0) {
55cc08a6
DG
2128 goto error;
2129 }
2130
7972aab2
DG
2131 reg_chan->obj.ust = ua_chan->obj;
2132 ua_chan->obj = NULL;
55cc08a6 2133
7972aab2 2134 return 0;
55cc08a6
DG
2135
2136error:
7972aab2
DG
2137 buffer_reg_channel_remove(reg_sess, reg_chan);
2138 buffer_reg_channel_destroy(reg_chan, LTTNG_DOMAIN_UST);
55cc08a6
DG
2139 return ret;
2140}
2141
edb67388 2142/*
7972aab2 2143 * Send buffer registry channel to the application.
d0b96690 2144 *
7972aab2 2145 * Return 0 on success else a negative value.
edb67388 2146 */
7972aab2
DG
2147static int send_channel_uid_to_ust(struct buffer_reg_channel *reg_chan,
2148 struct ust_app *app, struct ust_app_session *ua_sess,
2149 struct ust_app_channel *ua_chan)
edb67388
DG
2150{
2151 int ret;
7972aab2 2152 struct buffer_reg_stream *reg_stream;
edb67388 2153
7972aab2
DG
2154 assert(reg_chan);
2155 assert(app);
2156 assert(ua_sess);
2157 assert(ua_chan);
2158
2159 DBG("UST app sending buffer registry channel to ust sock %d", app->sock);
2160
2161 ret = duplicate_channel_object(reg_chan, ua_chan);
edb67388
DG
2162 if (ret < 0) {
2163 goto error;
2164 }
2165
7972aab2
DG
2166 /* Send channel to the application. */
2167 ret = ust_consumer_send_channel_to_ust(app, ua_sess, ua_chan);
2168 if (ret < 0) {
2169 goto error;
2170 }
2171
2172 health_code_update();
2173
2174 /* Send all streams to application. */
2175 pthread_mutex_lock(&reg_chan->stream_list_lock);
2176 cds_list_for_each_entry(reg_stream, &reg_chan->streams, lnode) {
2177 struct ust_app_stream stream;
2178
2179 ret = duplicate_stream_object(reg_stream, &stream);
2180 if (ret < 0) {
2181 goto error_stream_unlock;
2182 }
2183
2184 ret = ust_consumer_send_stream_to_ust(app, ua_chan, &stream);
2185 if (ret < 0) {
8c067051 2186 (void) release_ust_app_stream(-1, &stream);
7972aab2
DG
2187 goto error_stream_unlock;
2188 }
edb67388 2189
7972aab2
DG
2190 /*
2191 * The return value is not important here. This function will output an
2192 * error if needed.
2193 */
2194 (void) release_ust_app_stream(-1, &stream);
2195 }
2196 ua_chan->is_sent = 1;
2197
2198error_stream_unlock:
2199 pthread_mutex_unlock(&reg_chan->stream_list_lock);
edb67388
DG
2200error:
2201 return ret;
2202}
2203
9730260e 2204/*
7972aab2
DG
2205 * Create and send to the application the created buffers with per UID buffers.
2206 *
2207 * Return 0 on success else a negative value.
9730260e 2208 */
7972aab2
DG
2209static int create_channel_per_uid(struct ust_app *app,
2210 struct ltt_ust_session *usess, struct ust_app_session *ua_sess,
2211 struct ust_app_channel *ua_chan)
9730260e
DG
2212{
2213 int ret;
7972aab2
DG
2214 struct buffer_reg_uid *reg_uid;
2215 struct buffer_reg_channel *reg_chan;
9730260e 2216
7972aab2
DG
2217 assert(app);
2218 assert(usess);
2219 assert(ua_sess);
2220 assert(ua_chan);
2221
2222 DBG("UST app creating channel %s with per UID buffers", ua_chan->name);
2223
2224 reg_uid = buffer_reg_uid_find(usess->id, app->bits_per_long, app->uid);
2225 /*
2226 * The session creation handles the creation of this global registry
2227 * object. If none can be find, there is a code flow problem or a
2228 * teardown race.
2229 */
2230 assert(reg_uid);
2231
2232 reg_chan = buffer_reg_channel_find(ua_chan->tracing_channel_id,
2233 reg_uid);
2234 if (!reg_chan) {
2235 /* Create the buffer registry channel object. */
2236 ret = create_buffer_reg_channel(reg_uid->registry, ua_chan, &reg_chan);
2237 if (ret < 0) {
2238 goto error;
2239 }
2240 assert(reg_chan);
2241
2242 /*
2243 * Create the buffers on the consumer side. This call populates the
2244 * ust app channel object with all streams and data object.
2245 */
2246 ret = do_consumer_create_channel(usess, ua_sess, ua_chan,
2247 app->bits_per_long, reg_uid->registry->reg.ust);
2248 if (ret < 0) {
07d2ae95
DG
2249 /*
2250 * Let's remove the previously created buffer registry channel so
2251 * it's not visible anymore in the session registry.
2252 */
2253 ust_registry_channel_del_free(reg_uid->registry->reg.ust,
2254 ua_chan->tracing_channel_id);
2255 buffer_reg_channel_remove(reg_uid->registry, reg_chan);
2256 buffer_reg_channel_destroy(reg_chan, LTTNG_DOMAIN_UST);
7972aab2
DG
2257 goto error;
2258 }
2259
2260 /*
2261 * Setup the streams and add it to the session registry.
2262 */
2263 ret = setup_buffer_reg_channel(reg_uid->registry, ua_chan, reg_chan);
2264 if (ret < 0) {
2265 goto error;
2266 }
2267
2268 }
2269
2270 /* Send buffers to the application. */
2271 ret = send_channel_uid_to_ust(reg_chan, app, ua_sess, ua_chan);
9730260e
DG
2272 if (ret < 0) {
2273 goto error;
2274 }
2275
9730260e
DG
2276error:
2277 return ret;
2278}
2279
78f0bacd 2280/*
7972aab2
DG
2281 * Create and send to the application the created buffers with per PID buffers.
2282 *
2283 * Return 0 on success else a negative value.
78f0bacd 2284 */
7972aab2
DG
2285static int create_channel_per_pid(struct ust_app *app,
2286 struct ltt_ust_session *usess, struct ust_app_session *ua_sess,
2287 struct ust_app_channel *ua_chan)
78f0bacd 2288{
8535a6d9 2289 int ret;
7972aab2 2290 struct ust_registry_session *registry;
78f0bacd 2291
7972aab2
DG
2292 assert(app);
2293 assert(usess);
2294 assert(ua_sess);
2295 assert(ua_chan);
2296
2297 DBG("UST app creating channel %s with per PID buffers", ua_chan->name);
2298
2299 rcu_read_lock();
2300
2301 registry = get_session_registry(ua_sess);
2302 assert(registry);
2303
2304 /* Create and add a new channel registry to session. */
2305 ret = ust_registry_channel_add(registry, ua_chan->key);
78f0bacd
DG
2306 if (ret < 0) {
2307 goto error;
2308 }
2309
7972aab2
DG
2310 /* Create and get channel on the consumer side. */
2311 ret = do_consumer_create_channel(usess, ua_sess, ua_chan,
2312 app->bits_per_long, registry);
2313 if (ret < 0) {
2314 goto error;
2315 }
2316
2317 ret = send_channel_pid_to_ust(app, ua_sess, ua_chan);
2318 if (ret < 0) {
2319 goto error;
2320 }
8535a6d9 2321
78f0bacd 2322error:
7972aab2 2323 rcu_read_unlock();
78f0bacd
DG
2324 return ret;
2325}
2326
2327/*
7972aab2
DG
2328 * From an already allocated ust app channel, create the channel buffers if
2329 * need and send it to the application. This MUST be called with a RCU read
2330 * side lock acquired.
2331 *
2332 * Return 0 on success or else a negative value.
78f0bacd 2333 */
7972aab2
DG
2334static int do_create_channel(struct ust_app *app,
2335 struct ltt_ust_session *usess, struct ust_app_session *ua_sess,
2336 struct ust_app_channel *ua_chan)
78f0bacd 2337{
7972aab2 2338 int ret;
78f0bacd 2339
7972aab2
DG
2340 assert(app);
2341 assert(usess);
2342 assert(ua_sess);
2343 assert(ua_chan);
2344
2345 /* Handle buffer type before sending the channel to the application. */
2346 switch (usess->buffer_type) {
2347 case LTTNG_BUFFER_PER_UID:
2348 {
2349 ret = create_channel_per_uid(app, usess, ua_sess, ua_chan);
2350 if (ret < 0) {
2351 goto error;
2352 }
2353 break;
2354 }
2355 case LTTNG_BUFFER_PER_PID:
2356 {
2357 ret = create_channel_per_pid(app, usess, ua_sess, ua_chan);
2358 if (ret < 0) {
2359 goto error;
2360 }
2361 break;
2362 }
2363 default:
2364 assert(0);
2365 ret = -EINVAL;
78f0bacd
DG
2366 goto error;
2367 }
2368
7972aab2
DG
2369 /* Initialize ust objd object using the received handle and add it. */
2370 lttng_ht_node_init_ulong(&ua_chan->ust_objd_node, ua_chan->handle);
2371 lttng_ht_add_unique_ulong(app->ust_objd, &ua_chan->ust_objd_node);
78f0bacd 2372
7972aab2
DG
2373 /* If channel is not enabled, disable it on the tracer */
2374 if (!ua_chan->enabled) {
2375 ret = disable_ust_channel(app, ua_sess, ua_chan);
2376 if (ret < 0) {
2377 goto error;
2378 }
78f0bacd
DG
2379 }
2380
2381error:
2382 return ret;
2383}
2384
284d8f55 2385/*
4d710ac2
DG
2386 * Create UST app channel and create it on the tracer. Set ua_chanp of the
2387 * newly created channel if not NULL.
d0b96690 2388 *
36b588ed 2389 * Called with UST app session lock and RCU read-side lock held.
7972aab2
DG
2390 *
2391 * Return 0 on success or else a negative value.
284d8f55 2392 */
4d710ac2
DG
2393static int create_ust_app_channel(struct ust_app_session *ua_sess,
2394 struct ltt_ust_channel *uchan, struct ust_app *app,
7972aab2 2395 enum lttng_ust_chan_type type, struct ltt_ust_session *usess,
4d710ac2 2396 struct ust_app_channel **ua_chanp)
5b4a0ec0
DG
2397{
2398 int ret = 0;
bec39940
DG
2399 struct lttng_ht_iter iter;
2400 struct lttng_ht_node_str *ua_chan_node;
5b4a0ec0
DG
2401 struct ust_app_channel *ua_chan;
2402
2403 /* Lookup channel in the ust app session */
bec39940
DG
2404 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &iter);
2405 ua_chan_node = lttng_ht_iter_get_node_str(&iter);
fc34caaa 2406 if (ua_chan_node != NULL) {
5b4a0ec0 2407 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
fc34caaa 2408 goto end;
5b4a0ec0
DG
2409 }
2410
d0b96690 2411 ua_chan = alloc_ust_app_channel(uchan->name, ua_sess, &uchan->attr);
fc34caaa
DG
2412 if (ua_chan == NULL) {
2413 /* Only malloc can fail here */
4d710ac2 2414 ret = -ENOMEM;
094d1690 2415 goto error_alloc;
fc34caaa
DG
2416 }
2417 shadow_copy_channel(ua_chan, uchan);
2418
ffe60014
DG
2419 /* Set channel type. */
2420 ua_chan->attr.type = type;
2421
7972aab2 2422 ret = do_create_channel(app, usess, ua_sess, ua_chan);
5b4a0ec0
DG
2423 if (ret < 0) {
2424 goto error;
2425 }
2426
fc34caaa 2427 DBG2("UST app create channel %s for PID %d completed", ua_chan->name,
852d0037 2428 app->pid);
fc34caaa 2429
d0b96690
DG
2430 /* Only add the channel if successful on the tracer side. */
2431 lttng_ht_add_unique_str(ua_sess->channels, &ua_chan->node);
2432
fc34caaa 2433end:
4d710ac2
DG
2434 if (ua_chanp) {
2435 *ua_chanp = ua_chan;
2436 }
2437
2438 /* Everything went well. */
2439 return 0;
5b4a0ec0
DG
2440
2441error:
d0b96690 2442 delete_ust_app_channel(ua_chan->is_sent ? app->sock : -1, ua_chan, app);
094d1690 2443error_alloc:
4d710ac2 2444 return ret;
5b4a0ec0
DG
2445}
2446
2447/*
2448 * Create UST app event and create it on the tracer side.
d0b96690
DG
2449 *
2450 * Called with ust app session mutex held.
5b4a0ec0 2451 */
edb67388
DG
2452static
2453int create_ust_app_event(struct ust_app_session *ua_sess,
2454 struct ust_app_channel *ua_chan, struct ltt_ust_event *uevent,
2455 struct ust_app *app)
284d8f55 2456{
edb67388 2457 int ret = 0;
5b4a0ec0 2458 struct ust_app_event *ua_event;
284d8f55 2459
5b4a0ec0 2460 /* Get event node */
18eace3b
DG
2461 ua_event = find_ust_app_event(ua_chan->events, uevent->attr.name,
2462 uevent->filter, uevent->attr.loglevel);
2463 if (ua_event != NULL) {
fc34caaa 2464 ret = -EEXIST;
edb67388
DG
2465 goto end;
2466 }
5b4a0ec0 2467
edb67388
DG
2468 /* Does not exist so create one */
2469 ua_event = alloc_ust_app_event(uevent->attr.name, &uevent->attr);
2470 if (ua_event == NULL) {
2471 /* Only malloc can failed so something is really wrong */
2472 ret = -ENOMEM;
fc34caaa 2473 goto end;
5b4a0ec0 2474 }
edb67388 2475 shadow_copy_event(ua_event, uevent);
5b4a0ec0 2476
edb67388 2477 /* Create it on the tracer side */
5b4a0ec0 2478 ret = create_ust_event(app, ua_sess, ua_chan, ua_event);
284d8f55 2479 if (ret < 0) {
fc34caaa 2480 /* Not found previously means that it does not exist on the tracer */
76f66f63 2481 assert(ret != -LTTNG_UST_ERR_EXIST);
284d8f55
DG
2482 goto error;
2483 }
2484
d0b96690 2485 add_unique_ust_app_event(ua_chan, ua_event);
284d8f55 2486
fc34caaa 2487 DBG2("UST app create event %s for PID %d completed", ua_event->name,
852d0037 2488 app->pid);
7f79d3a1 2489
edb67388 2490end:
fc34caaa
DG
2491 return ret;
2492
5b4a0ec0 2493error:
fc34caaa
DG
2494 /* Valid. Calling here is already in a read side lock */
2495 delete_ust_app_event(-1, ua_event);
edb67388 2496 return ret;
5b4a0ec0
DG
2497}
2498
2499/*
2500 * Create UST metadata and open it on the tracer side.
d0b96690 2501 *
7972aab2 2502 * Called with UST app session lock held and RCU read side lock.
5b4a0ec0
DG
2503 */
2504static int create_ust_app_metadata(struct ust_app_session *ua_sess,
d65d2de8
DG
2505 struct ust_app *app, struct consumer_output *consumer,
2506 struct ustctl_consumer_channel_attr *attr)
5b4a0ec0
DG
2507{
2508 int ret = 0;
ffe60014 2509 struct ust_app_channel *metadata;
d88aee68 2510 struct consumer_socket *socket;
7972aab2 2511 struct ust_registry_session *registry;
5b4a0ec0 2512
ffe60014
DG
2513 assert(ua_sess);
2514 assert(app);
d88aee68 2515 assert(consumer);
5b4a0ec0 2516
7972aab2
DG
2517 registry = get_session_registry(ua_sess);
2518 assert(registry);
2519
2520 /* Metadata already exists for this registry. */
2521 if (registry->metadata_key) {
2522 ret = 0;
2523 goto error;
5b4a0ec0
DG
2524 }
2525
ffe60014 2526 /* Allocate UST metadata */
d0b96690 2527 metadata = alloc_ust_app_channel(DEFAULT_METADATA_NAME, ua_sess, NULL);
ffe60014
DG
2528 if (!metadata) {
2529 /* malloc() failed */
2530 ret = -ENOMEM;
2531 goto error;
2532 }
5b4a0ec0 2533
d65d2de8
DG
2534 if (!attr) {
2535 /* Set default attributes for metadata. */
2536 metadata->attr.overwrite = DEFAULT_CHANNEL_OVERWRITE;
2537 metadata->attr.subbuf_size = default_get_metadata_subbuf_size();
2538 metadata->attr.num_subbuf = DEFAULT_METADATA_SUBBUF_NUM;
0a9c6494
DG
2539 metadata->attr.switch_timer_interval = DEFAULT_METADATA_SWITCH_TIMER;
2540 metadata->attr.read_timer_interval = DEFAULT_METADATA_READ_TIMER;
d65d2de8
DG
2541 metadata->attr.output = LTTNG_UST_MMAP;
2542 metadata->attr.type = LTTNG_UST_CHAN_METADATA;
2543 } else {
2544 memcpy(&metadata->attr, attr, sizeof(metadata->attr));
2545 metadata->attr.output = LTTNG_UST_MMAP;
2546 metadata->attr.type = LTTNG_UST_CHAN_METADATA;
2547 }
5b4a0ec0 2548
7972aab2
DG
2549 /* Need one fd for the channel. */
2550 ret = lttng_fd_get(LTTNG_FD_APPS, 1);
2551 if (ret < 0) {
2552 ERR("Exhausted number of available FD upon create metadata");
2553 goto error;
2554 }
2555
4dc3dfc5
DG
2556 /* Get the right consumer socket for the application. */
2557 socket = consumer_find_socket_by_bitness(app->bits_per_long, consumer);
2558 if (!socket) {
2559 ret = -EINVAL;
2560 goto error_consumer;
2561 }
2562
331744e3
JD
2563 /*
2564 * Keep metadata key so we can identify it on the consumer side. Assign it
2565 * to the registry *before* we ask the consumer so we avoid the race of the
2566 * consumer requesting the metadata and the ask_channel call on our side
2567 * did not returned yet.
2568 */
2569 registry->metadata_key = metadata->key;
2570
d88aee68
DG
2571 /*
2572 * Ask the metadata channel creation to the consumer. The metadata object
2573 * will be created by the consumer and kept their. However, the stream is
2574 * never added or monitored until we do a first push metadata to the
2575 * consumer.
2576 */
7972aab2
DG
2577 ret = ust_consumer_ask_channel(ua_sess, metadata, consumer, socket,
2578 registry);
d88aee68 2579 if (ret < 0) {
7972aab2
DG
2580 /*
2581 * Safe because the metadata obj pointer is not set so the delete below
2582 * will not put a FD back again.
2583 */
d88aee68
DG
2584 goto error_consumer;
2585 }
2586
2587 /*
2588 * The setup command will make the metadata stream be sent to the relayd,
2589 * if applicable, and the thread managing the metadatas. This is important
2590 * because after this point, if an error occurs, the only way the stream
2591 * can be deleted is to be monitored in the consumer.
2592 */
7972aab2 2593 ret = consumer_setup_metadata(socket, metadata->key);
ffe60014 2594 if (ret < 0) {
7972aab2
DG
2595 /*
2596 * Safe because the metadata obj pointer is not set so the delete below
2597 * will not put a FD back again.
2598 */
d88aee68 2599 goto error_consumer;
5b4a0ec0
DG
2600 }
2601
7972aab2
DG
2602 DBG2("UST metadata with key %" PRIu64 " created for app pid %d",
2603 metadata->key, app->pid);
5b4a0ec0 2604
d88aee68 2605error_consumer:
b80f0b6c 2606 lttng_fd_put(LTTNG_FD_APPS, 1);
d88aee68 2607 delete_ust_app_channel(-1, metadata, app);
5b4a0ec0 2608error:
ffe60014 2609 return ret;
5b4a0ec0
DG
2610}
2611
2612/*
2613 * Return pointer to traceable apps list.
2614 */
bec39940 2615struct lttng_ht *ust_app_get_ht(void)
5b4a0ec0
DG
2616{
2617 return ust_app_ht;
2618}
2619
2620/*
d88aee68
DG
2621 * Return ust app pointer or NULL if not found. RCU read side lock MUST be
2622 * acquired before calling this function.
5b4a0ec0
DG
2623 */
2624struct ust_app *ust_app_find_by_pid(pid_t pid)
2625{
d88aee68 2626 struct ust_app *app = NULL;
bec39940
DG
2627 struct lttng_ht_node_ulong *node;
2628 struct lttng_ht_iter iter;
5b4a0ec0 2629
bec39940
DG
2630 lttng_ht_lookup(ust_app_ht, (void *)((unsigned long) pid), &iter);
2631 node = lttng_ht_iter_get_node_ulong(&iter);
5b4a0ec0
DG
2632 if (node == NULL) {
2633 DBG2("UST app no found with pid %d", pid);
2634 goto error;
2635 }
5b4a0ec0
DG
2636
2637 DBG2("Found UST app by pid %d", pid);
2638
d88aee68 2639 app = caa_container_of(node, struct ust_app, pid_n);
5b4a0ec0
DG
2640
2641error:
d88aee68 2642 return app;
5b4a0ec0
DG
2643}
2644
d88aee68
DG
2645/*
2646 * Allocate and init an UST app object using the registration information and
2647 * the command socket. This is called when the command socket connects to the
2648 * session daemon.
2649 *
2650 * The object is returned on success or else NULL.
2651 */
d0b96690 2652struct ust_app *ust_app_create(struct ust_register_msg *msg, int sock)
5b4a0ec0 2653{
d0b96690
DG
2654 struct ust_app *lta = NULL;
2655
2656 assert(msg);
2657 assert(sock >= 0);
2658
2659 DBG3("UST app creating application for socket %d", sock);
5b4a0ec0 2660
173af62f
DG
2661 if ((msg->bits_per_long == 64 &&
2662 (uatomic_read(&ust_consumerd64_fd) == -EINVAL))
2663 || (msg->bits_per_long == 32 &&
2664 (uatomic_read(&ust_consumerd32_fd) == -EINVAL))) {
f943b0fb 2665 ERR("Registration failed: application \"%s\" (pid: %d) has "
d0b96690
DG
2666 "%d-bit long, but no consumerd for this size is available.\n",
2667 msg->name, msg->pid, msg->bits_per_long);
2668 goto error;
3f2c5fcc 2669 }
d0b96690 2670
5b4a0ec0
DG
2671 lta = zmalloc(sizeof(struct ust_app));
2672 if (lta == NULL) {
2673 PERROR("malloc");
d0b96690 2674 goto error;
5b4a0ec0
DG
2675 }
2676
2677 lta->ppid = msg->ppid;
2678 lta->uid = msg->uid;
2679 lta->gid = msg->gid;
d0b96690 2680
7753dea8 2681 lta->bits_per_long = msg->bits_per_long;
d0b96690
DG
2682 lta->uint8_t_alignment = msg->uint8_t_alignment;
2683 lta->uint16_t_alignment = msg->uint16_t_alignment;
2684 lta->uint32_t_alignment = msg->uint32_t_alignment;
2685 lta->uint64_t_alignment = msg->uint64_t_alignment;
2686 lta->long_alignment = msg->long_alignment;
2687 lta->byte_order = msg->byte_order;
2688
5b4a0ec0
DG
2689 lta->v_major = msg->major;
2690 lta->v_minor = msg->minor;
bec39940 2691 lta->sessions = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG);
d0b96690
DG
2692 lta->ust_objd = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG);
2693 lta->notify_sock = -1;
d88aee68
DG
2694
2695 /* Copy name and make sure it's NULL terminated. */
2696 strncpy(lta->name, msg->name, sizeof(lta->name));
2697 lta->name[UST_APP_PROCNAME_LEN] = '\0';
2698
2699 /*
2700 * Before this can be called, when receiving the registration information,
2701 * the application compatibility is checked. So, at this point, the
2702 * application can work with this session daemon.
2703 */
d0b96690 2704 lta->compatible = 1;
5b4a0ec0 2705
852d0037 2706 lta->pid = msg->pid;
d0b96690 2707 lttng_ht_node_init_ulong(&lta->pid_n, (unsigned long) lta->pid);
852d0037 2708 lta->sock = sock;
d0b96690 2709 lttng_ht_node_init_ulong(&lta->sock_n, (unsigned long) lta->sock);
5b4a0ec0 2710
d42f20df
DG
2711 CDS_INIT_LIST_HEAD(&lta->teardown_head);
2712
d0b96690
DG
2713error:
2714 return lta;
2715}
2716
d88aee68
DG
2717/*
2718 * For a given application object, add it to every hash table.
2719 */
d0b96690
DG
2720void ust_app_add(struct ust_app *app)
2721{
2722 assert(app);
2723 assert(app->notify_sock >= 0);
2724
5b4a0ec0 2725 rcu_read_lock();
852d0037
DG
2726
2727 /*
2728 * On a re-registration, we want to kick out the previous registration of
2729 * that pid
2730 */
d0b96690 2731 lttng_ht_add_replace_ulong(ust_app_ht, &app->pid_n);
852d0037
DG
2732
2733 /*
2734 * The socket _should_ be unique until _we_ call close. So, a add_unique
2735 * for the ust_app_ht_by_sock is used which asserts fail if the entry was
2736 * already in the table.
2737 */
d0b96690 2738 lttng_ht_add_unique_ulong(ust_app_ht_by_sock, &app->sock_n);
852d0037 2739
d0b96690
DG
2740 /* Add application to the notify socket hash table. */
2741 lttng_ht_node_init_ulong(&app->notify_sock_n, app->notify_sock);
2742 lttng_ht_add_unique_ulong(ust_app_ht_by_notify_sock, &app->notify_sock_n);
5b4a0ec0 2743
d0b96690 2744 DBG("App registered with pid:%d ppid:%d uid:%d gid:%d sock:%d name:%s "
d88aee68
DG
2745 "notify_sock:%d (version %d.%d)", app->pid, app->ppid, app->uid,
2746 app->gid, app->sock, app->name, app->notify_sock, app->v_major,
2747 app->v_minor);
5b4a0ec0 2748
d0b96690
DG
2749 rcu_read_unlock();
2750}
2751
d88aee68
DG
2752/*
2753 * Set the application version into the object.
2754 *
2755 * Return 0 on success else a negative value either an errno code or a
2756 * LTTng-UST error code.
2757 */
d0b96690
DG
2758int ust_app_version(struct ust_app *app)
2759{
d88aee68
DG
2760 int ret;
2761
d0b96690 2762 assert(app);
d88aee68
DG
2763
2764 ret = ustctl_tracer_version(app->sock, &app->version);
2765 if (ret < 0) {
2766 if (ret != -LTTNG_UST_ERR_EXITING && ret != -EPIPE) {
2767 ERR("UST app %d verson failed with ret %d", app->sock, ret);
2768 } else {
2769 DBG3("UST app %d verion failed. Application is dead", app->sock);
2770 }
2771 }
2772
2773 return ret;
5b4a0ec0
DG
2774}
2775
2776/*
2777 * Unregister app by removing it from the global traceable app list and freeing
2778 * the data struct.
2779 *
2780 * The socket is already closed at this point so no close to sock.
2781 */
2782void ust_app_unregister(int sock)
2783{
2784 struct ust_app *lta;
bec39940
DG
2785 struct lttng_ht_node_ulong *node;
2786 struct lttng_ht_iter iter;
d42f20df 2787 struct ust_app_session *ua_sess;
525b0740 2788 int ret;
5b4a0ec0
DG
2789
2790 rcu_read_lock();
886459c6 2791
5b4a0ec0 2792 /* Get the node reference for a call_rcu */
852d0037 2793 lttng_ht_lookup(ust_app_ht_by_sock, (void *)((unsigned long) sock), &iter);
bec39940 2794 node = lttng_ht_iter_get_node_ulong(&iter);
d0b96690 2795 assert(node);
284d8f55 2796
852d0037 2797 lta = caa_container_of(node, struct ust_app, sock_n);
852d0037
DG
2798 DBG("PID %d unregistering with sock %d", lta->pid, sock);
2799
886459c6 2800 /* Remove application from PID hash table */
852d0037
DG
2801 ret = lttng_ht_del(ust_app_ht_by_sock, &iter);
2802 assert(!ret);
2803
d88aee68
DG
2804 /*
2805 * Remove application from notify hash table. The thread handling the
2806 * notify socket could have deleted the node so ignore on error because
2807 * either way it's valid. The close of that socket is handled by the other
2808 * thread.
2809 */
d0b96690 2810 iter.iter.node = &lta->notify_sock_n.node;
d88aee68 2811 (void) lttng_ht_del(ust_app_ht_by_notify_sock, &iter);
852d0037 2812
5b98a774
DG
2813 /*
2814 * Ignore return value since the node might have been removed before by an
2815 * add replace during app registration because the PID can be reassigned by
2816 * the OS.
2817 */
d0b96690 2818 iter.iter.node = &lta->pid_n.node;
bec39940 2819 ret = lttng_ht_del(ust_app_ht, &iter);
5b98a774
DG
2820 if (ret) {
2821 DBG3("Unregister app by PID %d failed. This can happen on pid reuse",
2822 lta->pid);
2823 }
852d0037 2824
d42f20df
DG
2825 /* Remove sessions so they are not visible during deletion.*/
2826 cds_lfht_for_each_entry(lta->sessions->ht, &iter.iter, ua_sess,
2827 node.node) {
7972aab2
DG
2828 struct ust_registry_session *registry;
2829
d42f20df
DG
2830 ret = lttng_ht_del(lta->sessions, &iter);
2831 if (ret) {
2832 /* The session was already removed so scheduled for teardown. */
2833 continue;
2834 }
2835
2836 /*
2837 * Add session to list for teardown. This is safe since at this point we
2838 * are the only one using this list.
2839 */
d88aee68
DG
2840 pthread_mutex_lock(&ua_sess->lock);
2841
2842 /*
2843 * Normally, this is done in the delete session process which is
2844 * executed in the call rcu below. However, upon registration we can't
2845 * afford to wait for the grace period before pushing data or else the
2846 * data pending feature can race between the unregistration and stop
2847 * command where the data pending command is sent *before* the grace
2848 * period ended.
2849 *
2850 * The close metadata below nullifies the metadata pointer in the
2851 * session so the delete session will NOT push/close a second time.
2852 */
7972aab2
DG
2853 registry = get_session_registry(ua_sess);
2854 if (registry) {
2855 /* Push metadata for application before freeing the application. */
2856 (void) push_metadata(registry, ua_sess->consumer);
2857
2858 /*
2859 * Don't ask to close metadata for global per UID buffers. Close
2860 * metadata only on destroy trace session in this case.
2861 */
2862 if (ua_sess->buffer_type != LTTNG_BUFFER_PER_UID) {
2863 /* And ask to close it for this session registry. */
2864 (void) close_metadata(registry, ua_sess->consumer);
2865 }
2866 }
d88aee68 2867
d42f20df 2868 cds_list_add(&ua_sess->teardown_node, &lta->teardown_head);
d88aee68 2869 pthread_mutex_unlock(&ua_sess->lock);
d42f20df
DG
2870 }
2871
852d0037
DG
2872 /* Free memory */
2873 call_rcu(&lta->pid_n.head, delete_ust_app_rcu);
2874
5b4a0ec0
DG
2875 rcu_read_unlock();
2876 return;
284d8f55
DG
2877}
2878
2879/*
5b4a0ec0 2880 * Return traceable_app_count
284d8f55 2881 */
5b4a0ec0 2882unsigned long ust_app_list_count(void)
284d8f55 2883{
5b4a0ec0 2884 unsigned long count;
284d8f55 2885
5b4a0ec0 2886 rcu_read_lock();
bec39940 2887 count = lttng_ht_get_count(ust_app_ht);
5b4a0ec0 2888 rcu_read_unlock();
284d8f55 2889
5b4a0ec0 2890 return count;
284d8f55
DG
2891}
2892
5b4a0ec0
DG
2893/*
2894 * Fill events array with all events name of all registered apps.
2895 */
2896int ust_app_list_events(struct lttng_event **events)
421cb601 2897{
5b4a0ec0
DG
2898 int ret, handle;
2899 size_t nbmem, count = 0;
bec39940 2900 struct lttng_ht_iter iter;
5b4a0ec0 2901 struct ust_app *app;
c617c0c6 2902 struct lttng_event *tmp_event;
421cb601 2903
5b4a0ec0 2904 nbmem = UST_APP_EVENT_LIST_SIZE;
c617c0c6
MD
2905 tmp_event = zmalloc(nbmem * sizeof(struct lttng_event));
2906 if (tmp_event == NULL) {
5b4a0ec0
DG
2907 PERROR("zmalloc ust app events");
2908 ret = -ENOMEM;
421cb601
DG
2909 goto error;
2910 }
2911
5b4a0ec0 2912 rcu_read_lock();
421cb601 2913
852d0037 2914 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
90eaa0d2 2915 struct lttng_ust_tracepoint_iter uiter;
ac3bd9c0 2916
840cb59c 2917 health_code_update();
86acf0da 2918
e0c7ec2b
DG
2919 if (!app->compatible) {
2920 /*
2921 * TODO: In time, we should notice the caller of this error by
2922 * telling him that this is a version error.
2923 */
2924 continue;
2925 }
852d0037 2926 handle = ustctl_tracepoint_list(app->sock);
5b4a0ec0 2927 if (handle < 0) {
ffe60014
DG
2928 if (handle != -EPIPE && handle != -LTTNG_UST_ERR_EXITING) {
2929 ERR("UST app list events getting handle failed for app pid %d",
2930 app->pid);
2931 }
5b4a0ec0
DG
2932 continue;
2933 }
421cb601 2934
852d0037 2935 while ((ret = ustctl_tracepoint_list_get(app->sock, handle,
fb54cdbf 2936 &uiter)) != -LTTNG_UST_ERR_NOENT) {
ffe60014
DG
2937 /* Handle ustctl error. */
2938 if (ret < 0) {
2939 free(tmp_event);
2940 if (ret != -LTTNG_UST_ERR_EXITING || ret != -EPIPE) {
2941 ERR("UST app tp list get failed for app %d with ret %d",
2942 app->sock, ret);
2943 } else {
2944 DBG3("UST app tp list get failed. Application is dead");
2945 }
2946 goto rcu_error;
2947 }
2948
840cb59c 2949 health_code_update();
815564d8 2950 if (count >= nbmem) {
d7b3776f 2951 /* In case the realloc fails, we free the memory */
c617c0c6
MD
2952 void *ptr;
2953
815564d8
MD
2954 DBG2("Reallocating event list from %zu to %zu entries", nbmem,
2955 2 * nbmem);
2956 nbmem *= 2;
c617c0c6
MD
2957 ptr = realloc(tmp_event, nbmem * sizeof(struct lttng_event));
2958 if (ptr == NULL) {
5b4a0ec0 2959 PERROR("realloc ust app events");
c617c0c6 2960 free(tmp_event);
5b4a0ec0
DG
2961 ret = -ENOMEM;
2962 goto rcu_error;
2963 }
c617c0c6 2964 tmp_event = ptr;
5b4a0ec0 2965 }
c617c0c6
MD
2966 memcpy(tmp_event[count].name, uiter.name, LTTNG_UST_SYM_NAME_LEN);
2967 tmp_event[count].loglevel = uiter.loglevel;
2968 tmp_event[count].type = (enum lttng_event_type) LTTNG_UST_TRACEPOINT;
2969 tmp_event[count].pid = app->pid;
2970 tmp_event[count].enabled = -1;
5b4a0ec0 2971 count++;
421cb601 2972 }
421cb601
DG
2973 }
2974
5b4a0ec0 2975 ret = count;
c617c0c6 2976 *events = tmp_event;
421cb601 2977
5b4a0ec0 2978 DBG2("UST app list events done (%zu events)", count);
421cb601 2979
5b4a0ec0
DG
2980rcu_error:
2981 rcu_read_unlock();
421cb601 2982error:
840cb59c 2983 health_code_update();
5b4a0ec0 2984 return ret;
421cb601
DG
2985}
2986
f37d259d
MD
2987/*
2988 * Fill events array with all events name of all registered apps.
2989 */
2990int ust_app_list_event_fields(struct lttng_event_field **fields)
2991{
2992 int ret, handle;
2993 size_t nbmem, count = 0;
2994 struct lttng_ht_iter iter;
2995 struct ust_app *app;
c617c0c6 2996 struct lttng_event_field *tmp_event;
f37d259d
MD
2997
2998 nbmem = UST_APP_EVENT_LIST_SIZE;
c617c0c6
MD
2999 tmp_event = zmalloc(nbmem * sizeof(struct lttng_event_field));
3000 if (tmp_event == NULL) {
f37d259d
MD
3001 PERROR("zmalloc ust app event fields");
3002 ret = -ENOMEM;
3003 goto error;
3004 }
3005
3006 rcu_read_lock();
3007
3008 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
3009 struct lttng_ust_field_iter uiter;
3010
840cb59c 3011 health_code_update();
86acf0da 3012
f37d259d
MD
3013 if (!app->compatible) {
3014 /*
3015 * TODO: In time, we should notice the caller of this error by
3016 * telling him that this is a version error.
3017 */
3018 continue;
3019 }
3020 handle = ustctl_tracepoint_field_list(app->sock);
3021 if (handle < 0) {
ffe60014
DG
3022 if (handle != -EPIPE && handle != -LTTNG_UST_ERR_EXITING) {
3023 ERR("UST app list field getting handle failed for app pid %d",
3024 app->pid);
3025 }
f37d259d
MD
3026 continue;
3027 }
3028
3029 while ((ret = ustctl_tracepoint_field_list_get(app->sock, handle,
fb54cdbf 3030 &uiter)) != -LTTNG_UST_ERR_NOENT) {
ffe60014
DG
3031 /* Handle ustctl error. */
3032 if (ret < 0) {
3033 free(tmp_event);
3034 if (ret != -LTTNG_UST_ERR_EXITING || ret != -EPIPE) {
3035 ERR("UST app tp list field failed for app %d with ret %d",
3036 app->sock, ret);
3037 } else {
3038 DBG3("UST app tp list field failed. Application is dead");
3039 }
3040 goto rcu_error;
3041 }
3042
840cb59c 3043 health_code_update();
f37d259d 3044 if (count >= nbmem) {
d7b3776f 3045 /* In case the realloc fails, we free the memory */
c617c0c6
MD
3046 void *ptr;
3047
f37d259d
MD
3048 DBG2("Reallocating event field list from %zu to %zu entries", nbmem,
3049 2 * nbmem);
3050 nbmem *= 2;
c617c0c6
MD
3051 ptr = realloc(tmp_event, nbmem * sizeof(struct lttng_event_field));
3052 if (ptr == NULL) {
f37d259d 3053 PERROR("realloc ust app event fields");
c617c0c6 3054 free(tmp_event);
f37d259d
MD
3055 ret = -ENOMEM;
3056 goto rcu_error;
3057 }
c617c0c6 3058 tmp_event = ptr;
f37d259d 3059 }
f37d259d 3060
c617c0c6
MD
3061 memcpy(tmp_event[count].field_name, uiter.field_name, LTTNG_UST_SYM_NAME_LEN);
3062 tmp_event[count].type = uiter.type;
3063 tmp_event[count].nowrite = uiter.nowrite;
f37d259d 3064
c617c0c6
MD
3065 memcpy(tmp_event[count].event.name, uiter.event_name, LTTNG_UST_SYM_NAME_LEN);
3066 tmp_event[count].event.loglevel = uiter.loglevel;
3067 tmp_event[count].event.type = LTTNG_UST_TRACEPOINT;
3068 tmp_event[count].event.pid = app->pid;
3069 tmp_event[count].event.enabled = -1;
f37d259d
MD
3070 count++;
3071 }
3072 }
3073
3074 ret = count;
c617c0c6 3075 *fields = tmp_event;
f37d259d
MD
3076
3077 DBG2("UST app list event fields done (%zu events)", count);
3078
3079rcu_error:
3080 rcu_read_unlock();
3081error:
840cb59c 3082 health_code_update();
f37d259d
MD
3083 return ret;
3084}
3085
5b4a0ec0
DG
3086/*
3087 * Free and clean all traceable apps of the global list.
36b588ed
MD
3088 *
3089 * Should _NOT_ be called with RCU read-side lock held.
5b4a0ec0
DG
3090 */
3091void ust_app_clean_list(void)
421cb601 3092{
5b4a0ec0 3093 int ret;
659ed79f 3094 struct ust_app *app;
bec39940 3095 struct lttng_ht_iter iter;
421cb601 3096
5b4a0ec0 3097 DBG2("UST app cleaning registered apps hash table");
421cb601 3098
5b4a0ec0 3099 rcu_read_lock();
421cb601 3100
659ed79f 3101 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
bec39940 3102 ret = lttng_ht_del(ust_app_ht, &iter);
525b0740 3103 assert(!ret);
659ed79f 3104 call_rcu(&app->pid_n.head, delete_ust_app_rcu);
421cb601
DG
3105 }
3106
852d0037 3107 /* Cleanup socket hash table */
659ed79f
DG
3108 cds_lfht_for_each_entry(ust_app_ht_by_sock->ht, &iter.iter, app,
3109 sock_n.node) {
852d0037 3110 ret = lttng_ht_del(ust_app_ht_by_sock, &iter);
bec39940
DG
3111 assert(!ret);
3112 }
852d0037 3113
d88aee68
DG
3114 /* Cleanup notify socket hash table */
3115 cds_lfht_for_each_entry(ust_app_ht_by_notify_sock->ht, &iter.iter, app,
3116 notify_sock_n.node) {
3117 ret = lttng_ht_del(ust_app_ht_by_notify_sock, &iter);
3118 assert(!ret);
3119 }
36b588ed 3120 rcu_read_unlock();
d88aee68 3121
bec39940 3122 /* Destroy is done only when the ht is empty */
852d0037
DG
3123 lttng_ht_destroy(ust_app_ht);
3124 lttng_ht_destroy(ust_app_ht_by_sock);
d88aee68 3125 lttng_ht_destroy(ust_app_ht_by_notify_sock);
5b4a0ec0
DG
3126}
3127
3128/*
3129 * Init UST app hash table.
3130 */
3131void ust_app_ht_alloc(void)
3132{
bec39940 3133 ust_app_ht = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG);
852d0037 3134 ust_app_ht_by_sock = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG);
d0b96690 3135 ust_app_ht_by_notify_sock = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG);
421cb601
DG
3136}
3137
78f0bacd
DG
3138/*
3139 * For a specific UST session, disable the channel for all registered apps.
3140 */
35a9059d 3141int ust_app_disable_channel_glb(struct ltt_ust_session *usess,
78f0bacd
DG
3142 struct ltt_ust_channel *uchan)
3143{
3144 int ret = 0;
bec39940
DG
3145 struct lttng_ht_iter iter;
3146 struct lttng_ht_node_str *ua_chan_node;
78f0bacd
DG
3147 struct ust_app *app;
3148 struct ust_app_session *ua_sess;
8535a6d9 3149 struct ust_app_channel *ua_chan;
78f0bacd
DG
3150
3151 if (usess == NULL || uchan == NULL) {
3152 ERR("Disabling UST global channel with NULL values");
3153 ret = -1;
3154 goto error;
3155 }
3156
a991f516
MD
3157 DBG2("UST app disabling channel %s from global domain for session id %d",
3158 uchan->name, usess->id);
78f0bacd
DG
3159
3160 rcu_read_lock();
3161
3162 /* For every registered applications */
852d0037 3163 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
bec39940 3164 struct lttng_ht_iter uiter;
e0c7ec2b
DG
3165 if (!app->compatible) {
3166 /*
3167 * TODO: In time, we should notice the caller of this error by
3168 * telling him that this is a version error.
3169 */
3170 continue;
3171 }
78f0bacd
DG
3172 ua_sess = lookup_session_by_app(usess, app);
3173 if (ua_sess == NULL) {
3174 continue;
3175 }
3176
8535a6d9 3177 /* Get channel */
bec39940
DG
3178 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &uiter);
3179 ua_chan_node = lttng_ht_iter_get_node_str(&uiter);
8535a6d9
DG
3180 /* If the session if found for the app, the channel must be there */
3181 assert(ua_chan_node);
3182
3183 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
3184 /* The channel must not be already disabled */
3185 assert(ua_chan->enabled == 1);
3186
3187 /* Disable channel onto application */
3188 ret = disable_ust_app_channel(ua_sess, ua_chan, app);
78f0bacd
DG
3189 if (ret < 0) {
3190 /* XXX: We might want to report this error at some point... */
3191 continue;
3192 }
3193 }
3194
3195 rcu_read_unlock();
3196
3197error:
3198 return ret;
3199}
3200
3201/*
3202 * For a specific UST session, enable the channel for all registered apps.
3203 */
35a9059d 3204int ust_app_enable_channel_glb(struct ltt_ust_session *usess,
78f0bacd
DG
3205 struct ltt_ust_channel *uchan)
3206{
3207 int ret = 0;
bec39940 3208 struct lttng_ht_iter iter;
78f0bacd
DG
3209 struct ust_app *app;
3210 struct ust_app_session *ua_sess;
3211
3212 if (usess == NULL || uchan == NULL) {
3213 ERR("Adding UST global channel to NULL values");
3214 ret = -1;
3215 goto error;
3216 }
3217
a991f516
MD
3218 DBG2("UST app enabling channel %s to global domain for session id %d",
3219 uchan->name, usess->id);
78f0bacd
DG
3220
3221 rcu_read_lock();
3222
3223 /* For every registered applications */
852d0037 3224 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
e0c7ec2b
DG
3225 if (!app->compatible) {
3226 /*
3227 * TODO: In time, we should notice the caller of this error by
3228 * telling him that this is a version error.
3229 */
3230 continue;
3231 }
78f0bacd
DG
3232 ua_sess = lookup_session_by_app(usess, app);
3233 if (ua_sess == NULL) {
3234 continue;
3235 }
3236
3237 /* Enable channel onto application */
3238 ret = enable_ust_app_channel(ua_sess, uchan, app);
3239 if (ret < 0) {
3240 /* XXX: We might want to report this error at some point... */
3241 continue;
3242 }
3243 }
3244
3245 rcu_read_unlock();
3246
3247error:
3248 return ret;
3249}
3250
b0a40d28
DG
3251/*
3252 * Disable an event in a channel and for a specific session.
3253 */
35a9059d
DG
3254int ust_app_disable_event_glb(struct ltt_ust_session *usess,
3255 struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent)
b0a40d28
DG
3256{
3257 int ret = 0;
bec39940
DG
3258 struct lttng_ht_iter iter, uiter;
3259 struct lttng_ht_node_str *ua_chan_node, *ua_event_node;
b0a40d28
DG
3260 struct ust_app *app;
3261 struct ust_app_session *ua_sess;
3262 struct ust_app_channel *ua_chan;
3263 struct ust_app_event *ua_event;
3264
3265 DBG("UST app disabling event %s for all apps in channel "
a991f516 3266 "%s for session id %d", uevent->attr.name, uchan->name, usess->id);
b0a40d28
DG
3267
3268 rcu_read_lock();
3269
3270 /* For all registered applications */
852d0037 3271 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
e0c7ec2b
DG
3272 if (!app->compatible) {
3273 /*
3274 * TODO: In time, we should notice the caller of this error by
3275 * telling him that this is a version error.
3276 */
3277 continue;
3278 }
b0a40d28
DG
3279 ua_sess = lookup_session_by_app(usess, app);
3280 if (ua_sess == NULL) {
3281 /* Next app */
3282 continue;
3283 }
3284
3285 /* Lookup channel in the ust app session */
bec39940
DG
3286 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &uiter);
3287 ua_chan_node = lttng_ht_iter_get_node_str(&uiter);
b0a40d28 3288 if (ua_chan_node == NULL) {
a991f516 3289 DBG2("Channel %s not found in session id %d for app pid %d."
852d0037 3290 "Skipping", uchan->name, usess->id, app->pid);
b0a40d28
DG
3291 continue;
3292 }
3293 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
3294
bec39940
DG
3295 lttng_ht_lookup(ua_chan->events, (void *)uevent->attr.name, &uiter);
3296 ua_event_node = lttng_ht_iter_get_node_str(&uiter);
b0a40d28
DG
3297 if (ua_event_node == NULL) {
3298 DBG2("Event %s not found in channel %s for app pid %d."
852d0037 3299 "Skipping", uevent->attr.name, uchan->name, app->pid);
b0a40d28
DG
3300 continue;
3301 }
3302 ua_event = caa_container_of(ua_event_node, struct ust_app_event, node);
3303
7f79d3a1 3304 ret = disable_ust_app_event(ua_sess, ua_event, app);
b0a40d28
DG
3305 if (ret < 0) {
3306 /* XXX: Report error someday... */
3307 continue;
3308 }
3309 }
3310
3311 rcu_read_unlock();
3312
3313 return ret;
3314}
3315
9730260e 3316/*
edb67388 3317 * For a specific UST session and UST channel, the event for all
9730260e
DG
3318 * registered apps.
3319 */
35a9059d 3320int ust_app_disable_all_event_glb(struct ltt_ust_session *usess,
9730260e
DG
3321 struct ltt_ust_channel *uchan)
3322{
3323 int ret = 0;
bec39940
DG
3324 struct lttng_ht_iter iter, uiter;
3325 struct lttng_ht_node_str *ua_chan_node;
9730260e
DG
3326 struct ust_app *app;
3327 struct ust_app_session *ua_sess;
3328 struct ust_app_channel *ua_chan;
3329 struct ust_app_event *ua_event;
3330
3331 DBG("UST app disabling all event for all apps in channel "
a991f516 3332 "%s for session id %d", uchan->name, usess->id);
9730260e
DG
3333
3334 rcu_read_lock();
3335
3336 /* For all registered applications */
852d0037 3337 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
e0c7ec2b
DG
3338 if (!app->compatible) {
3339 /*
3340 * TODO: In time, we should notice the caller of this error by
3341 * telling him that this is a version error.
3342 */
3343 continue;
3344 }
9730260e 3345 ua_sess = lookup_session_by_app(usess, app);
c4a1715b
DG
3346 if (!ua_sess) {
3347 /* The application has problem or is probably dead. */
3348 continue;
3349 }
9730260e
DG
3350
3351 /* Lookup channel in the ust app session */
bec39940
DG
3352 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &uiter);
3353 ua_chan_node = lttng_ht_iter_get_node_str(&uiter);
edb67388
DG
3354 /* If the channel is not found, there is a code flow error */
3355 assert(ua_chan_node);
3356
9730260e
DG
3357 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
3358
3359 /* Disable each events of channel */
bec39940
DG
3360 cds_lfht_for_each_entry(ua_chan->events->ht, &uiter.iter, ua_event,
3361 node.node) {
7f79d3a1 3362 ret = disable_ust_app_event(ua_sess, ua_event, app);
9730260e
DG
3363 if (ret < 0) {
3364 /* XXX: Report error someday... */
3365 continue;
3366 }
3367 }
3368 }
3369
3370 rcu_read_unlock();
3371
3372 return ret;
3373}
3374
421cb601 3375/*
5b4a0ec0 3376 * For a specific UST session, create the channel for all registered apps.
421cb601 3377 */
35a9059d 3378int ust_app_create_channel_glb(struct ltt_ust_session *usess,
48842b30
DG
3379 struct ltt_ust_channel *uchan)
3380{
3d8ca23b 3381 int ret = 0, created;
bec39940 3382 struct lttng_ht_iter iter;
48842b30 3383 struct ust_app *app;
3d8ca23b 3384 struct ust_app_session *ua_sess = NULL;
48842b30 3385
fc34caaa
DG
3386 /* Very wrong code flow */
3387 assert(usess);
3388 assert(uchan);
421cb601 3389
7972aab2 3390 DBG2("UST app adding channel %s to UST domain for session id %d",
a991f516 3391 uchan->name, usess->id);
48842b30
DG
3392
3393 rcu_read_lock();
421cb601 3394
5b4a0ec0 3395 /* For every registered applications */
852d0037 3396 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
e0c7ec2b
DG
3397 if (!app->compatible) {
3398 /*
3399 * TODO: In time, we should notice the caller of this error by
3400 * telling him that this is a version error.
3401 */
3402 continue;
3403 }
edb67388
DG
3404 /*
3405 * Create session on the tracer side and add it to app session HT. Note
3406 * that if session exist, it will simply return a pointer to the ust
3407 * app session.
3408 */
3d8ca23b
DG
3409 ret = create_ust_app_session(usess, app, &ua_sess, &created);
3410 if (ret < 0) {
3411 switch (ret) {
3412 case -ENOTCONN:
3413 /*
3414 * The application's socket is not valid. Either a bad socket
3415 * or a timeout on it. We can't inform the caller that for a
3416 * specific app, the session failed so lets continue here.
3417 */
3418 continue;
3419 case -ENOMEM:
3420 default:
3421 goto error_rcu_unlock;
3422 }
48842b30 3423 }
3d8ca23b 3424 assert(ua_sess);
48842b30 3425
d0b96690 3426 pthread_mutex_lock(&ua_sess->lock);
d65d2de8
DG
3427 if (!strncmp(uchan->name, DEFAULT_METADATA_NAME,
3428 sizeof(uchan->name))) {
3429 struct ustctl_consumer_channel_attr attr;
3430 copy_channel_attr_to_ustctl(&attr, &uchan->attr);
3431 ret = create_ust_app_metadata(ua_sess, app, usess->consumer,
3432 &attr);
3433 } else {
3434 /* Create channel onto application. We don't need the chan ref. */
3435 ret = create_ust_app_channel(ua_sess, uchan, app,
3436 LTTNG_UST_CHAN_PER_CPU, usess, NULL);
3437 }
d0b96690 3438 pthread_mutex_unlock(&ua_sess->lock);
3d8ca23b
DG
3439 if (ret < 0) {
3440 if (ret == -ENOMEM) {
3441 /* No more memory is a fatal error. Stop right now. */
3442 goto error_rcu_unlock;
3443 }
3444 /* Cleanup the created session if it's the case. */
3445 if (created) {
d0b96690 3446 destroy_app_session(app, ua_sess);
3d8ca23b 3447 }
48842b30 3448 }
48842b30 3449 }
5b4a0ec0 3450
95e047ff 3451error_rcu_unlock:
48842b30 3452 rcu_read_unlock();
3c14c33f 3453 return ret;
48842b30
DG
3454}
3455
5b4a0ec0 3456/*
edb67388 3457 * Enable event for a specific session and channel on the tracer.
5b4a0ec0 3458 */
35a9059d 3459int ust_app_enable_event_glb(struct ltt_ust_session *usess,
48842b30
DG
3460 struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent)
3461{
3462 int ret = 0;
bec39940 3463 struct lttng_ht_iter iter, uiter;
18eace3b 3464 struct lttng_ht_node_str *ua_chan_node;
48842b30
DG
3465 struct ust_app *app;
3466 struct ust_app_session *ua_sess;
3467 struct ust_app_channel *ua_chan;
3468 struct ust_app_event *ua_event;
48842b30 3469
a991f516
MD
3470 DBG("UST app enabling event %s for all apps for session id %d",
3471 uevent->attr.name, usess->id);
48842b30 3472
edb67388
DG
3473 /*
3474 * NOTE: At this point, this function is called only if the session and
3475 * channel passed are already created for all apps. and enabled on the
3476 * tracer also.
3477 */
3478
48842b30 3479 rcu_read_lock();
421cb601
DG
3480
3481 /* For all registered applications */
852d0037 3482 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
e0c7ec2b
DG
3483 if (!app->compatible) {
3484 /*
3485 * TODO: In time, we should notice the caller of this error by
3486 * telling him that this is a version error.
3487 */
3488 continue;
3489 }
edb67388 3490 ua_sess = lookup_session_by_app(usess, app);
c4a1715b
DG
3491 if (!ua_sess) {
3492 /* The application has problem or is probably dead. */
3493 continue;
3494 }
ba767faf 3495
d0b96690
DG
3496 pthread_mutex_lock(&ua_sess->lock);
3497
edb67388 3498 /* Lookup channel in the ust app session */
bec39940
DG
3499 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &uiter);
3500 ua_chan_node = lttng_ht_iter_get_node_str(&uiter);
edb67388
DG
3501 /* If the channel is not found, there is a code flow error */
3502 assert(ua_chan_node);
3503
3504 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
3505
18eace3b
DG
3506 /* Get event node */
3507 ua_event = find_ust_app_event(ua_chan->events, uevent->attr.name,
3508 uevent->filter, uevent->attr.loglevel);
3509 if (ua_event == NULL) {
7f79d3a1 3510 DBG3("UST app enable event %s not found for app PID %d."
852d0037 3511 "Skipping app", uevent->attr.name, app->pid);
d0b96690 3512 goto next_app;
35a9059d 3513 }
35a9059d
DG
3514
3515 ret = enable_ust_app_event(ua_sess, ua_event, app);
3516 if (ret < 0) {
d0b96690 3517 pthread_mutex_unlock(&ua_sess->lock);
7f79d3a1 3518 goto error;
48842b30 3519 }
d0b96690
DG
3520 next_app:
3521 pthread_mutex_unlock(&ua_sess->lock);
edb67388
DG
3522 }
3523
7f79d3a1 3524error:
edb67388 3525 rcu_read_unlock();
edb67388
DG
3526 return ret;
3527}
3528
3529/*
3530 * For a specific existing UST session and UST channel, creates the event for
3531 * all registered apps.
3532 */
35a9059d 3533int ust_app_create_event_glb(struct ltt_ust_session *usess,
edb67388
DG
3534 struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent)
3535{
3536 int ret = 0;
bec39940
DG
3537 struct lttng_ht_iter iter, uiter;
3538 struct lttng_ht_node_str *ua_chan_node;
edb67388
DG
3539 struct ust_app *app;
3540 struct ust_app_session *ua_sess;
3541 struct ust_app_channel *ua_chan;
3542
a991f516
MD
3543 DBG("UST app creating event %s for all apps for session id %d",
3544 uevent->attr.name, usess->id);
edb67388 3545
edb67388
DG
3546 rcu_read_lock();
3547
3548 /* For all registered applications */
852d0037 3549 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
e0c7ec2b
DG
3550 if (!app->compatible) {
3551 /*
3552 * TODO: In time, we should notice the caller of this error by
3553 * telling him that this is a version error.
3554 */
3555 continue;
3556 }
edb67388 3557 ua_sess = lookup_session_by_app(usess, app);
c4a1715b
DG
3558 if (!ua_sess) {
3559 /* The application has problem or is probably dead. */
3560 continue;
3561 }
48842b30 3562
d0b96690 3563 pthread_mutex_lock(&ua_sess->lock);
48842b30 3564 /* Lookup channel in the ust app session */
bec39940
DG
3565 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &uiter);
3566 ua_chan_node = lttng_ht_iter_get_node_str(&uiter);
edb67388
DG
3567 /* If the channel is not found, there is a code flow error */
3568 assert(ua_chan_node);
3569
48842b30
DG
3570 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
3571
edb67388 3572 ret = create_ust_app_event(ua_sess, ua_chan, uevent, app);
d0b96690 3573 pthread_mutex_unlock(&ua_sess->lock);
edb67388 3574 if (ret < 0) {
49c336c1 3575 if (ret != -LTTNG_UST_ERR_EXIST) {
fc34caaa
DG
3576 /* Possible value at this point: -ENOMEM. If so, we stop! */
3577 break;
3578 }
3579 DBG2("UST app event %s already exist on app PID %d",
852d0037 3580 uevent->attr.name, app->pid);
5b4a0ec0 3581 continue;
48842b30 3582 }
48842b30 3583 }
5b4a0ec0 3584
48842b30
DG
3585 rcu_read_unlock();
3586
3587 return ret;
3588}
3589
5b4a0ec0
DG
3590/*
3591 * Start tracing for a specific UST session and app.
3592 */
b34cbebf 3593static
421cb601 3594int ust_app_start_trace(struct ltt_ust_session *usess, struct ust_app *app)
48842b30
DG
3595{
3596 int ret = 0;
48842b30 3597 struct ust_app_session *ua_sess;
48842b30 3598
852d0037 3599 DBG("Starting tracing for ust app pid %d", app->pid);
5cf5d0e7 3600
509cbaf8
MD
3601 rcu_read_lock();
3602
e0c7ec2b
DG
3603 if (!app->compatible) {
3604 goto end;
3605 }
3606
421cb601
DG
3607 ua_sess = lookup_session_by_app(usess, app);
3608 if (ua_sess == NULL) {
d42f20df
DG
3609 /* The session is in teardown process. Ignore and continue. */
3610 goto end;
421cb601 3611 }
48842b30 3612
d0b96690
DG
3613 pthread_mutex_lock(&ua_sess->lock);
3614
aea829b3
DG
3615 /* Upon restart, we skip the setup, already done */
3616 if (ua_sess->started) {
8be98f9a 3617 goto skip_setup;
aea829b3 3618 }
8be98f9a 3619
a4b92340
DG
3620 /* Create directories if consumer is LOCAL and has a path defined. */
3621 if (usess->consumer->type == CONSUMER_DST_LOCAL &&
3622 strlen(usess->consumer->dst.trace_path) > 0) {
3623 ret = run_as_mkdir_recursive(usess->consumer->dst.trace_path,
7972aab2 3624 S_IRWXU | S_IRWXG, ua_sess->euid, ua_sess->egid);
a4b92340
DG
3625 if (ret < 0) {
3626 if (ret != -EEXIST) {
3627 ERR("Trace directory creation error");
d0b96690 3628 goto error_unlock;
421cb601 3629 }
173af62f 3630 }
7753dea8 3631 }
aea829b3 3632
d65d2de8
DG
3633 /*
3634 * Create the metadata for the application. This returns gracefully if a
3635 * metadata was already set for the session.
3636 */
3637 ret = create_ust_app_metadata(ua_sess, app, usess->consumer, NULL);
421cb601 3638 if (ret < 0) {
d0b96690 3639 goto error_unlock;
421cb601 3640 }
48842b30 3641
840cb59c 3642 health_code_update();
86acf0da 3643
8be98f9a 3644skip_setup:
421cb601 3645 /* This start the UST tracing */
852d0037 3646 ret = ustctl_start_session(app->sock, ua_sess->handle);
421cb601 3647 if (ret < 0) {
ffe60014
DG
3648 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
3649 ERR("Error starting tracing for app pid: %d (ret: %d)",
3650 app->pid, ret);
3651 } else {
3652 DBG("UST app start session failed. Application is dead.");
3653 }
d0b96690 3654 goto error_unlock;
421cb601 3655 }
5b4a0ec0 3656
55c3953d
DG
3657 /* Indicate that the session has been started once */
3658 ua_sess->started = 1;
3659
d0b96690
DG
3660 pthread_mutex_unlock(&ua_sess->lock);
3661
840cb59c 3662 health_code_update();
86acf0da 3663
421cb601 3664 /* Quiescent wait after starting trace */
ffe60014
DG
3665 ret = ustctl_wait_quiescent(app->sock);
3666 if (ret < 0 && ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
3667 ERR("UST app wait quiescent failed for app pid %d ret %d",
3668 app->pid, ret);
3669 }
48842b30 3670
e0c7ec2b
DG
3671end:
3672 rcu_read_unlock();
840cb59c 3673 health_code_update();
421cb601 3674 return 0;
48842b30 3675
d0b96690
DG
3676error_unlock:
3677 pthread_mutex_unlock(&ua_sess->lock);
509cbaf8 3678 rcu_read_unlock();
840cb59c 3679 health_code_update();
421cb601
DG
3680 return -1;
3681}
48842b30 3682
8be98f9a
MD
3683/*
3684 * Stop tracing for a specific UST session and app.
3685 */
b34cbebf 3686static
8be98f9a
MD
3687int ust_app_stop_trace(struct ltt_ust_session *usess, struct ust_app *app)
3688{
3689 int ret = 0;
3690 struct ust_app_session *ua_sess;
7972aab2 3691 struct ust_registry_session *registry;
8be98f9a 3692
852d0037 3693 DBG("Stopping tracing for ust app pid %d", app->pid);
8be98f9a
MD
3694
3695 rcu_read_lock();
3696
e0c7ec2b 3697 if (!app->compatible) {
d88aee68 3698 goto end_no_session;
e0c7ec2b
DG
3699 }
3700
8be98f9a
MD
3701 ua_sess = lookup_session_by_app(usess, app);
3702 if (ua_sess == NULL) {
d88aee68 3703 goto end_no_session;
8be98f9a
MD
3704 }
3705
d88aee68
DG
3706 pthread_mutex_lock(&ua_sess->lock);
3707
9bc07046
DG
3708 /*
3709 * If started = 0, it means that stop trace has been called for a session
c45536e1
DG
3710 * that was never started. It's possible since we can have a fail start
3711 * from either the application manager thread or the command thread. Simply
3712 * indicate that this is a stop error.
9bc07046 3713 */
f9dfc3d9 3714 if (!ua_sess->started) {
c45536e1
DG
3715 goto error_rcu_unlock;
3716 }
7db205b5 3717
840cb59c 3718 health_code_update();
86acf0da 3719
9d6c7d3f 3720 /* This inhibits UST tracing */
852d0037 3721 ret = ustctl_stop_session(app->sock, ua_sess->handle);
9d6c7d3f 3722 if (ret < 0) {
ffe60014
DG
3723 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
3724 ERR("Error stopping tracing for app pid: %d (ret: %d)",
3725 app->pid, ret);
3726 } else {
3727 DBG("UST app stop session failed. Application is dead.");
3728 }
9d6c7d3f
DG
3729 goto error_rcu_unlock;
3730 }
3731
840cb59c 3732 health_code_update();
86acf0da 3733
9d6c7d3f 3734 /* Quiescent wait after stopping trace */
ffe60014
DG
3735 ret = ustctl_wait_quiescent(app->sock);
3736 if (ret < 0 && ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
3737 ERR("UST app wait quiescent failed for app pid %d ret %d",
3738 app->pid, ret);
3739 }
9d6c7d3f 3740
840cb59c 3741 health_code_update();
86acf0da 3742
b34cbebf
MD
3743 registry = get_session_registry(ua_sess);
3744 assert(registry);
3745 /* Push metadata for application before freeing the application. */
3746 (void) push_metadata(registry, ua_sess->consumer);
3747
3748 pthread_mutex_unlock(&ua_sess->lock);
3749end_no_session:
3750 rcu_read_unlock();
3751 health_code_update();
3752 return 0;
3753
3754error_rcu_unlock:
3755 pthread_mutex_unlock(&ua_sess->lock);
3756 rcu_read_unlock();
3757 health_code_update();
3758 return -1;
3759}
3760
3761/*
3762 * Flush buffers for a specific UST session and app.
3763 */
3764static
3765int ust_app_flush_trace(struct ltt_ust_session *usess, struct ust_app *app)
3766{
3767 int ret = 0;
3768 struct lttng_ht_iter iter;
3769 struct ust_app_session *ua_sess;
3770 struct ust_app_channel *ua_chan;
3771
3772 DBG("Flushing buffers for ust app pid %d", app->pid);
3773
3774 rcu_read_lock();
3775
3776 if (!app->compatible) {
3777 goto end_no_session;
3778 }
3779
3780 ua_sess = lookup_session_by_app(usess, app);
3781 if (ua_sess == NULL) {
3782 goto end_no_session;
3783 }
3784
3785 pthread_mutex_lock(&ua_sess->lock);
3786
3787 health_code_update();
3788
9d6c7d3f 3789 /* Flushing buffers */
bec39940
DG
3790 cds_lfht_for_each_entry(ua_sess->channels->ht, &iter.iter, ua_chan,
3791 node.node) {
840cb59c 3792 health_code_update();
ffe60014 3793 assert(ua_chan->is_sent);
852d0037 3794 ret = ustctl_sock_flush_buffer(app->sock, ua_chan->obj);
8be98f9a 3795 if (ret < 0) {
ffe60014
DG
3796 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
3797 ERR("UST app PID %d channel %s flush failed with ret %d",
3798 app->pid, ua_chan->name, ret);
3799 } else {
3800 DBG3("UST app failed to flush %s. Application is dead.",
3801 ua_chan->name);
3802 /* No need to continue. */
d88aee68 3803 break;
ffe60014 3804 }
6d3686da
DG
3805 /* Continuing flushing all buffers */
3806 continue;
8be98f9a
MD
3807 }
3808 }
8be98f9a 3809
840cb59c 3810 health_code_update();
86acf0da 3811
d88aee68
DG
3812 pthread_mutex_unlock(&ua_sess->lock);
3813end_no_session:
7db205b5 3814 rcu_read_unlock();
840cb59c 3815 health_code_update();
8be98f9a 3816 return 0;
8be98f9a
MD
3817}
3818
84cd17c6
MD
3819/*
3820 * Destroy a specific UST session in apps.
3821 */
3353de95 3822static int destroy_trace(struct ltt_ust_session *usess, struct ust_app *app)
84cd17c6 3823{
ffe60014 3824 int ret;
84cd17c6 3825 struct ust_app_session *ua_sess;
bec39940
DG
3826 struct lttng_ht_iter iter;
3827 struct lttng_ht_node_ulong *node;
84cd17c6 3828
852d0037 3829 DBG("Destroy tracing for ust app pid %d", app->pid);
84cd17c6
MD
3830
3831 rcu_read_lock();
3832
e0c7ec2b
DG
3833 if (!app->compatible) {
3834 goto end;
3835 }
3836
84cd17c6 3837 __lookup_session_by_app(usess, app, &iter);
bec39940 3838 node = lttng_ht_iter_get_node_ulong(&iter);
84cd17c6 3839 if (node == NULL) {
d42f20df
DG
3840 /* Session is being or is deleted. */
3841 goto end;
84cd17c6
MD
3842 }
3843 ua_sess = caa_container_of(node, struct ust_app_session, node);
c4a1715b 3844
840cb59c 3845 health_code_update();
d0b96690 3846 destroy_app_session(app, ua_sess);
84cd17c6 3847
840cb59c 3848 health_code_update();
7db205b5 3849
84cd17c6 3850 /* Quiescent wait after stopping trace */
ffe60014
DG
3851 ret = ustctl_wait_quiescent(app->sock);
3852 if (ret < 0 && ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
3853 ERR("UST app wait quiescent failed for app pid %d ret %d",
3854 app->pid, ret);
3855 }
e0c7ec2b
DG
3856end:
3857 rcu_read_unlock();
840cb59c 3858 health_code_update();
84cd17c6 3859 return 0;
84cd17c6
MD
3860}
3861
5b4a0ec0
DG
3862/*
3863 * Start tracing for the UST session.
3864 */
421cb601
DG
3865int ust_app_start_trace_all(struct ltt_ust_session *usess)
3866{
3867 int ret = 0;
bec39940 3868 struct lttng_ht_iter iter;
421cb601 3869 struct ust_app *app;
48842b30 3870
421cb601
DG
3871 DBG("Starting all UST traces");
3872
3873 rcu_read_lock();
421cb601 3874
852d0037 3875 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
421cb601 3876 ret = ust_app_start_trace(usess, app);
48842b30 3877 if (ret < 0) {
5b4a0ec0
DG
3878 /* Continue to next apps even on error */
3879 continue;
48842b30 3880 }
48842b30 3881 }
5b4a0ec0 3882
48842b30
DG
3883 rcu_read_unlock();
3884
3885 return 0;
3886}
487cf67c 3887
8be98f9a
MD
3888/*
3889 * Start tracing for the UST session.
3890 */
3891int ust_app_stop_trace_all(struct ltt_ust_session *usess)
3892{
3893 int ret = 0;
bec39940 3894 struct lttng_ht_iter iter;
8be98f9a
MD
3895 struct ust_app *app;
3896
3897 DBG("Stopping all UST traces");
3898
3899 rcu_read_lock();
3900
b34cbebf
MD
3901 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
3902 ret = ust_app_stop_trace(usess, app);
3903 if (ret < 0) {
3904 /* Continue to next apps even on error */
3905 continue;
3906 }
3907 }
3908
3909 /* Flush buffers */
3910 switch (usess->buffer_type) {
3911 case LTTNG_BUFFER_PER_UID:
3912 {
7972aab2 3913 struct buffer_reg_uid *reg;
b34cbebf
MD
3914
3915 /* Flush all per UID buffers associated to that session. */
7972aab2
DG
3916 cds_list_for_each_entry(reg, &usess->buffer_reg_uid_list, lnode) {
3917 struct buffer_reg_channel *reg_chan;
3918 struct consumer_socket *socket;
3919
3920 /* Get consumer socket to use to push the metadata.*/
3921 socket = consumer_find_socket_by_bitness(reg->bits_per_long,
3922 usess->consumer);
3923 if (!socket) {
3924 /* Ignore request if no consumer is found for the session. */
3925 continue;
3926 }
3927
3928 cds_lfht_for_each_entry(reg->registry->channels->ht, &iter.iter,
3929 reg_chan, node.node) {
3930 /*
3931 * The following call will print error values so the return
3932 * code is of little importance because whatever happens, we
3933 * have to try them all.
3934 */
3935 (void) consumer_flush_channel(socket, reg_chan->consumer_key);
3936 }
3937 }
b34cbebf 3938 break;
7972aab2 3939 }
b34cbebf
MD
3940 case LTTNG_BUFFER_PER_PID:
3941 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
3942 ret = ust_app_flush_trace(usess, app);
3943 if (ret < 0) {
3944 /* Continue to next apps even on error */
3945 continue;
3946 }
8be98f9a 3947 }
b34cbebf
MD
3948 break;
3949 default:
3950 assert(0);
3951 break;
8be98f9a
MD
3952 }
3953
3954 rcu_read_unlock();
3955
3956 return 0;
3957}
3958
84cd17c6
MD
3959/*
3960 * Destroy app UST session.
3961 */
3962int ust_app_destroy_trace_all(struct ltt_ust_session *usess)
3963{
3964 int ret = 0;
bec39940 3965 struct lttng_ht_iter iter;
84cd17c6
MD
3966 struct ust_app *app;
3967
3968 DBG("Destroy all UST traces");
3969
3970 rcu_read_lock();
3971
852d0037 3972 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
3353de95 3973 ret = destroy_trace(usess, app);
84cd17c6
MD
3974 if (ret < 0) {
3975 /* Continue to next apps even on error */
3976 continue;
3977 }
3978 }
3979
3980 rcu_read_unlock();
3981
3982 return 0;
3983}
3984
5b4a0ec0
DG
3985/*
3986 * Add channels/events from UST global domain to registered apps at sock.
3987 */
487cf67c
DG
3988void ust_app_global_update(struct ltt_ust_session *usess, int sock)
3989{
55c54cce 3990 int ret = 0;
727d5404 3991 struct lttng_ht_iter iter, uiter, iter_ctx;
487cf67c 3992 struct ust_app *app;
3d8ca23b 3993 struct ust_app_session *ua_sess = NULL;
487cf67c
DG
3994 struct ust_app_channel *ua_chan;
3995 struct ust_app_event *ua_event;
727d5404 3996 struct ust_app_ctx *ua_ctx;
1f3580c7 3997
95e047ff 3998 assert(usess);
ffe60014 3999 assert(sock >= 0);
1f3580c7 4000
a991f516
MD
4001 DBG2("UST app global update for app sock %d for session id %d", sock,
4002 usess->id);
487cf67c 4003
284d8f55
DG
4004 rcu_read_lock();
4005
487cf67c
DG
4006 app = find_app_by_sock(sock);
4007 if (app == NULL) {
d88aee68
DG
4008 /*
4009 * Application can be unregistered before so this is possible hence
4010 * simply stopping the update.
4011 */
4012 DBG3("UST app update failed to find app sock %d", sock);
487cf67c
DG
4013 goto error;
4014 }
4015
e0c7ec2b
DG
4016 if (!app->compatible) {
4017 goto error;
4018 }
4019
3d8ca23b
DG
4020 ret = create_ust_app_session(usess, app, &ua_sess, NULL);
4021 if (ret < 0) {
4022 /* Tracer is probably gone or ENOMEM. */
487cf67c
DG
4023 goto error;
4024 }
3d8ca23b 4025 assert(ua_sess);
487cf67c 4026
d0b96690
DG
4027 pthread_mutex_lock(&ua_sess->lock);
4028
284d8f55 4029 /*
d0b96690 4030 * We can iterate safely here over all UST app session since the create ust
284d8f55
DG
4031 * app session above made a shadow copy of the UST global domain from the
4032 * ltt ust session.
4033 */
bec39940
DG
4034 cds_lfht_for_each_entry(ua_sess->channels->ht, &iter.iter, ua_chan,
4035 node.node) {
d65d2de8
DG
4036 /*
4037 * For a metadata channel, handle it differently.
4038 */
4039 if (!strncmp(ua_chan->name, DEFAULT_METADATA_NAME,
4040 sizeof(ua_chan->name))) {
4041 ret = create_ust_app_metadata(ua_sess, app, usess->consumer,
4042 &ua_chan->attr);
c7a339aa
DG
4043 if (ret < 0) {
4044 goto error_unlock;
4045 }
d65d2de8
DG
4046 /* Remove it from the hash table and continue!. */
4047 ret = lttng_ht_del(ua_sess->channels, &iter);
4048 assert(!ret);
4049 delete_ust_app_channel(-1, ua_chan, app);
4050 continue;
4051 } else {
4052 ret = do_create_channel(app, usess, ua_sess, ua_chan);
c7a339aa
DG
4053 if (ret < 0) {
4054 /*
4055 * Stop everything. On error, the application failed, no more
4056 * file descriptor are available or ENOMEM so stopping here is
4057 * the only thing we can do for now.
4058 */
4059 goto error_unlock;
4060 }
487cf67c
DG
4061 }
4062
727d5404
DG
4063 cds_lfht_for_each_entry(ua_chan->ctx->ht, &iter_ctx.iter, ua_ctx,
4064 node.node) {
4065 ret = create_ust_channel_context(ua_chan, ua_ctx, app);
4066 if (ret < 0) {
d0b96690 4067 goto error_unlock;
727d5404
DG
4068 }
4069 }
4070
4071
284d8f55 4072 /* For each events */
bec39940
DG
4073 cds_lfht_for_each_entry(ua_chan->events->ht, &uiter.iter, ua_event,
4074 node.node) {
284d8f55
DG
4075 ret = create_ust_event(app, ua_sess, ua_chan, ua_event);
4076 if (ret < 0) {
d0b96690 4077 goto error_unlock;
487cf67c 4078 }
36dc12cc 4079 }
487cf67c
DG
4080 }
4081
d0b96690
DG
4082 pthread_mutex_unlock(&ua_sess->lock);
4083
36dc12cc 4084 if (usess->start_trace) {
421cb601 4085 ret = ust_app_start_trace(usess, app);
36dc12cc 4086 if (ret < 0) {
36dc12cc
DG
4087 goto error;
4088 }
4089
852d0037 4090 DBG2("UST trace started for app pid %d", app->pid);
36dc12cc
DG
4091 }
4092
ffe60014
DG
4093 /* Everything went well at this point. */
4094 rcu_read_unlock();
4095 return;
4096
d0b96690
DG
4097error_unlock:
4098 pthread_mutex_unlock(&ua_sess->lock);
487cf67c 4099error:
ffe60014 4100 if (ua_sess) {
d0b96690 4101 destroy_app_session(app, ua_sess);
ffe60014 4102 }
487cf67c
DG
4103 rcu_read_unlock();
4104 return;
4105}
55cc08a6
DG
4106
4107/*
4108 * Add context to a specific channel for global UST domain.
4109 */
4110int ust_app_add_ctx_channel_glb(struct ltt_ust_session *usess,
4111 struct ltt_ust_channel *uchan, struct ltt_ust_context *uctx)
4112{
4113 int ret = 0;
bec39940
DG
4114 struct lttng_ht_node_str *ua_chan_node;
4115 struct lttng_ht_iter iter, uiter;
55cc08a6
DG
4116 struct ust_app_channel *ua_chan = NULL;
4117 struct ust_app_session *ua_sess;
4118 struct ust_app *app;
4119
4120 rcu_read_lock();
4121
852d0037 4122 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
e0c7ec2b
DG
4123 if (!app->compatible) {
4124 /*
4125 * TODO: In time, we should notice the caller of this error by
4126 * telling him that this is a version error.
4127 */
4128 continue;
4129 }
55cc08a6
DG
4130 ua_sess = lookup_session_by_app(usess, app);
4131 if (ua_sess == NULL) {
4132 continue;
4133 }
4134
d0b96690 4135 pthread_mutex_lock(&ua_sess->lock);
55cc08a6 4136 /* Lookup channel in the ust app session */
bec39940
DG
4137 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &uiter);
4138 ua_chan_node = lttng_ht_iter_get_node_str(&uiter);
55cc08a6 4139 if (ua_chan_node == NULL) {
d0b96690 4140 goto next_app;
55cc08a6
DG
4141 }
4142 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel,
4143 node);
55cc08a6
DG
4144 ret = create_ust_app_channel_context(ua_sess, ua_chan, &uctx->ctx, app);
4145 if (ret < 0) {
d0b96690 4146 goto next_app;
55cc08a6 4147 }
d0b96690
DG
4148 next_app:
4149 pthread_mutex_unlock(&ua_sess->lock);
55cc08a6
DG
4150 }
4151
55cc08a6
DG
4152 rcu_read_unlock();
4153 return ret;
4154}
4155
76d45b40
DG
4156/*
4157 * Enable event for a channel from a UST session for a specific PID.
4158 */
4159int ust_app_enable_event_pid(struct ltt_ust_session *usess,
4160 struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent, pid_t pid)
4161{
4162 int ret = 0;
bec39940 4163 struct lttng_ht_iter iter;
18eace3b 4164 struct lttng_ht_node_str *ua_chan_node;
76d45b40
DG
4165 struct ust_app *app;
4166 struct ust_app_session *ua_sess;
4167 struct ust_app_channel *ua_chan;
4168 struct ust_app_event *ua_event;
4169
4170 DBG("UST app enabling event %s for PID %d", uevent->attr.name, pid);
4171
4172 rcu_read_lock();
4173
4174 app = ust_app_find_by_pid(pid);
4175 if (app == NULL) {
4176 ERR("UST app enable event per PID %d not found", pid);
4177 ret = -1;
d0b96690 4178 goto end;
76d45b40
DG
4179 }
4180
e0c7ec2b
DG
4181 if (!app->compatible) {
4182 ret = 0;
d0b96690 4183 goto end;
e0c7ec2b
DG
4184 }
4185
76d45b40 4186 ua_sess = lookup_session_by_app(usess, app);
c4a1715b
DG
4187 if (!ua_sess) {
4188 /* The application has problem or is probably dead. */
d0b96690
DG
4189 ret = 0;
4190 goto end;
c4a1715b 4191 }
76d45b40 4192
d0b96690 4193 pthread_mutex_lock(&ua_sess->lock);
76d45b40 4194 /* Lookup channel in the ust app session */
bec39940
DG
4195 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &iter);
4196 ua_chan_node = lttng_ht_iter_get_node_str(&iter);
76d45b40
DG
4197 /* If the channel is not found, there is a code flow error */
4198 assert(ua_chan_node);
4199
4200 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
4201
18eace3b
DG
4202 ua_event = find_ust_app_event(ua_chan->events, uevent->attr.name,
4203 uevent->filter, uevent->attr.loglevel);
4204 if (ua_event == NULL) {
76d45b40
DG
4205 ret = create_ust_app_event(ua_sess, ua_chan, uevent, app);
4206 if (ret < 0) {
d0b96690 4207 goto end_unlock;
76d45b40
DG
4208 }
4209 } else {
76d45b40
DG
4210 ret = enable_ust_app_event(ua_sess, ua_event, app);
4211 if (ret < 0) {
d0b96690 4212 goto end_unlock;
76d45b40
DG
4213 }
4214 }
4215
d0b96690
DG
4216end_unlock:
4217 pthread_mutex_unlock(&ua_sess->lock);
4218end:
76d45b40
DG
4219 rcu_read_unlock();
4220 return ret;
4221}
7f79d3a1
DG
4222
4223/*
4224 * Disable event for a channel from a UST session for a specific PID.
4225 */
4226int ust_app_disable_event_pid(struct ltt_ust_session *usess,
4227 struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent, pid_t pid)
4228{
4229 int ret = 0;
bec39940
DG
4230 struct lttng_ht_iter iter;
4231 struct lttng_ht_node_str *ua_chan_node, *ua_event_node;
7f79d3a1
DG
4232 struct ust_app *app;
4233 struct ust_app_session *ua_sess;
4234 struct ust_app_channel *ua_chan;
4235 struct ust_app_event *ua_event;
4236
4237 DBG("UST app disabling event %s for PID %d", uevent->attr.name, pid);
4238
4239 rcu_read_lock();
4240
4241 app = ust_app_find_by_pid(pid);
4242 if (app == NULL) {
4243 ERR("UST app disable event per PID %d not found", pid);
4244 ret = -1;
4245 goto error;
4246 }
4247
e0c7ec2b
DG
4248 if (!app->compatible) {
4249 ret = 0;
4250 goto error;
4251 }
4252
7f79d3a1 4253 ua_sess = lookup_session_by_app(usess, app);
c4a1715b
DG
4254 if (!ua_sess) {
4255 /* The application has problem or is probably dead. */
4256 goto error;
4257 }
7f79d3a1
DG
4258
4259 /* Lookup channel in the ust app session */
bec39940
DG
4260 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &iter);
4261 ua_chan_node = lttng_ht_iter_get_node_str(&iter);
7f79d3a1
DG
4262 if (ua_chan_node == NULL) {
4263 /* Channel does not exist, skip disabling */
4264 goto error;
4265 }
4266 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
4267
bec39940
DG
4268 lttng_ht_lookup(ua_chan->events, (void *)uevent->attr.name, &iter);
4269 ua_event_node = lttng_ht_iter_get_node_str(&iter);
7f79d3a1
DG
4270 if (ua_event_node == NULL) {
4271 /* Event does not exist, skip disabling */
4272 goto error;
4273 }
4274 ua_event = caa_container_of(ua_event_node, struct ust_app_event, node);
4275
4276 ret = disable_ust_app_event(ua_sess, ua_event, app);
4277 if (ret < 0) {
4278 goto error;
4279 }
4280
4281error:
4282 rcu_read_unlock();
4283 return ret;
4284}
e0c7ec2b 4285
4466912f
DG
4286/*
4287 * Calibrate registered applications.
4288 */
4289int ust_app_calibrate_glb(struct lttng_ust_calibrate *calibrate)
4290{
4291 int ret = 0;
4292 struct lttng_ht_iter iter;
4293 struct ust_app *app;
4294
4295 rcu_read_lock();
4296
852d0037 4297 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
4466912f
DG
4298 if (!app->compatible) {
4299 /*
4300 * TODO: In time, we should notice the caller of this error by
4301 * telling him that this is a version error.
4302 */
4303 continue;
4304 }
4305
840cb59c 4306 health_code_update();
86acf0da 4307
852d0037 4308 ret = ustctl_calibrate(app->sock, calibrate);
4466912f
DG
4309 if (ret < 0) {
4310 switch (ret) {
4311 case -ENOSYS:
4312 /* Means that it's not implemented on the tracer side. */
4313 ret = 0;
4314 break;
4315 default:
4466912f 4316 DBG2("Calibrate app PID %d returned with error %d",
852d0037 4317 app->pid, ret);
4466912f
DG
4318 break;
4319 }
4320 }
4321 }
4322
4323 DBG("UST app global domain calibration finished");
4324
4325 rcu_read_unlock();
4326
840cb59c 4327 health_code_update();
86acf0da 4328
4466912f
DG
4329 return ret;
4330}
d0b96690
DG
4331
4332/*
4333 * Receive registration and populate the given msg structure.
4334 *
4335 * On success return 0 else a negative value returned by the ustctl call.
4336 */
4337int ust_app_recv_registration(int sock, struct ust_register_msg *msg)
4338{
4339 int ret;
4340 uint32_t pid, ppid, uid, gid;
4341
4342 assert(msg);
4343
4344 ret = ustctl_recv_reg_msg(sock, &msg->type, &msg->major, &msg->minor,
4345 &pid, &ppid, &uid, &gid,
4346 &msg->bits_per_long,
4347 &msg->uint8_t_alignment,
4348 &msg->uint16_t_alignment,
4349 &msg->uint32_t_alignment,
4350 &msg->uint64_t_alignment,
4351 &msg->long_alignment,
4352 &msg->byte_order,
4353 msg->name);
4354 if (ret < 0) {
4355 switch (-ret) {
4356 case EPIPE:
4357 case ECONNRESET:
4358 case LTTNG_UST_ERR_EXITING:
4359 DBG3("UST app recv reg message failed. Application died");
4360 break;
4361 case LTTNG_UST_ERR_UNSUP_MAJOR:
4362 ERR("UST app recv reg unsupported version %d.%d. Supporting %d.%d",
4363 msg->major, msg->minor, LTTNG_UST_ABI_MAJOR_VERSION,
4364 LTTNG_UST_ABI_MINOR_VERSION);
4365 break;
4366 default:
4367 ERR("UST app recv reg message failed with ret %d", ret);
4368 break;
4369 }
4370 goto error;
4371 }
4372 msg->pid = (pid_t) pid;
4373 msg->ppid = (pid_t) ppid;
4374 msg->uid = (uid_t) uid;
4375 msg->gid = (gid_t) gid;
4376
4377error:
4378 return ret;
4379}
4380
d88aee68
DG
4381/*
4382 * Return a ust app channel object using the application object and the channel
4383 * object descriptor has a key. If not found, NULL is returned. A RCU read side
4384 * lock MUST be acquired before calling this function.
4385 */
d0b96690
DG
4386static struct ust_app_channel *find_channel_by_objd(struct ust_app *app,
4387 int objd)
4388{
4389 struct lttng_ht_node_ulong *node;
4390 struct lttng_ht_iter iter;
4391 struct ust_app_channel *ua_chan = NULL;
4392
4393 assert(app);
4394
4395 lttng_ht_lookup(app->ust_objd, (void *)((unsigned long) objd), &iter);
4396 node = lttng_ht_iter_get_node_ulong(&iter);
4397 if (node == NULL) {
4398 DBG2("UST app channel find by objd %d not found", objd);
4399 goto error;
4400 }
4401
4402 ua_chan = caa_container_of(node, struct ust_app_channel, ust_objd_node);
4403
4404error:
4405 return ua_chan;
4406}
4407
d88aee68
DG
4408/*
4409 * Reply to a register channel notification from an application on the notify
4410 * socket. The channel metadata is also created.
4411 *
4412 * The session UST registry lock is acquired in this function.
4413 *
4414 * On success 0 is returned else a negative value.
4415 */
d0b96690
DG
4416static int reply_ust_register_channel(int sock, int sobjd, int cobjd,
4417 size_t nr_fields, struct ustctl_field *fields)
4418{
4419 int ret, ret_code = 0;
4420 uint32_t chan_id, reg_count;
7972aab2 4421 uint64_t chan_reg_key;
d0b96690
DG
4422 enum ustctl_channel_header type;
4423 struct ust_app *app;
4424 struct ust_app_channel *ua_chan;
4425 struct ust_app_session *ua_sess;
7972aab2 4426 struct ust_registry_session *registry;
45893984 4427 struct ust_registry_channel *chan_reg;
d0b96690
DG
4428
4429 rcu_read_lock();
4430
4431 /* Lookup application. If not found, there is a code flow error. */
4432 app = find_app_by_notify_sock(sock);
d88aee68
DG
4433 if (!app) {
4434 DBG("Application socket %d is being teardown. Abort event notify",
4435 sock);
4436 ret = 0;
4437 goto error_rcu_unlock;
4438 }
d0b96690
DG
4439
4440 /* Lookup channel by UST object descriptor. Should always be found. */
4441 ua_chan = find_channel_by_objd(app, cobjd);
4442 assert(ua_chan);
4443 assert(ua_chan->session);
4444 ua_sess = ua_chan->session;
d0b96690 4445
7972aab2
DG
4446 /* Get right session registry depending on the session buffer type. */
4447 registry = get_session_registry(ua_sess);
4448 assert(registry);
45893984 4449
7972aab2
DG
4450 /* Depending on the buffer type, a different channel key is used. */
4451 if (ua_sess->buffer_type == LTTNG_BUFFER_PER_UID) {
4452 chan_reg_key = ua_chan->tracing_channel_id;
d0b96690 4453 } else {
7972aab2 4454 chan_reg_key = ua_chan->key;
d0b96690
DG
4455 }
4456
7972aab2
DG
4457 pthread_mutex_lock(&registry->lock);
4458
4459 chan_reg = ust_registry_channel_find(registry, chan_reg_key);
4460 assert(chan_reg);
4461
4462 if (!chan_reg->register_done) {
4463 reg_count = ust_registry_get_event_count(chan_reg);
4464 if (reg_count < 31) {
4465 type = USTCTL_CHANNEL_HEADER_COMPACT;
4466 } else {
4467 type = USTCTL_CHANNEL_HEADER_LARGE;
4468 }
4469
4470 chan_reg->nr_ctx_fields = nr_fields;
4471 chan_reg->ctx_fields = fields;
4472 chan_reg->header_type = type;
d0b96690 4473 } else {
7972aab2
DG
4474 /* Get current already assigned values. */
4475 type = chan_reg->header_type;
d0b96690 4476 }
7972aab2
DG
4477 /* Channel id is set during the object creation. */
4478 chan_id = chan_reg->chan_id;
d0b96690
DG
4479
4480 /* Append to metadata */
7972aab2
DG
4481 if (!chan_reg->metadata_dumped) {
4482 ret_code = ust_metadata_channel_statedump(registry, chan_reg);
d0b96690
DG
4483 if (ret_code) {
4484 ERR("Error appending channel metadata (errno = %d)", ret_code);
4485 goto reply;
4486 }
4487 }
4488
4489reply:
7972aab2
DG
4490 DBG3("UST app replying to register channel key %" PRIu64
4491 " with id %u, type: %d, ret: %d", chan_reg_key, chan_id, type,
4492 ret_code);
d0b96690
DG
4493
4494 ret = ustctl_reply_register_channel(sock, chan_id, type, ret_code);
4495 if (ret < 0) {
4496 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
4497 ERR("UST app reply channel failed with ret %d", ret);
4498 } else {
4499 DBG3("UST app reply channel failed. Application died");
4500 }
4501 goto error;
4502 }
4503
7972aab2
DG
4504 /* This channel registry registration is completed. */
4505 chan_reg->register_done = 1;
4506
d0b96690 4507error:
7972aab2 4508 pthread_mutex_unlock(&registry->lock);
d88aee68 4509error_rcu_unlock:
d0b96690
DG
4510 rcu_read_unlock();
4511 return ret;
4512}
4513
d88aee68
DG
4514/*
4515 * Add event to the UST channel registry. When the event is added to the
4516 * registry, the metadata is also created. Once done, this replies to the
4517 * application with the appropriate error code.
4518 *
4519 * The session UST registry lock is acquired in the function.
4520 *
4521 * On success 0 is returned else a negative value.
4522 */
d0b96690
DG
4523static int add_event_ust_registry(int sock, int sobjd, int cobjd, char *name,
4524 char *sig, size_t nr_fields, struct ustctl_field *fields, int loglevel,
4525 char *model_emf_uri)
4526{
4527 int ret, ret_code;
4528 uint32_t event_id = 0;
7972aab2 4529 uint64_t chan_reg_key;
d0b96690
DG
4530 struct ust_app *app;
4531 struct ust_app_channel *ua_chan;
4532 struct ust_app_session *ua_sess;
7972aab2 4533 struct ust_registry_session *registry;
d0b96690
DG
4534
4535 rcu_read_lock();
4536
4537 /* Lookup application. If not found, there is a code flow error. */
4538 app = find_app_by_notify_sock(sock);
d88aee68
DG
4539 if (!app) {
4540 DBG("Application socket %d is being teardown. Abort event notify",
4541 sock);
4542 ret = 0;
4543 goto error_rcu_unlock;
4544 }
d0b96690
DG
4545
4546 /* Lookup channel by UST object descriptor. Should always be found. */
4547 ua_chan = find_channel_by_objd(app, cobjd);
4548 assert(ua_chan);
4549 assert(ua_chan->session);
4550 ua_sess = ua_chan->session;
4551
7972aab2
DG
4552 registry = get_session_registry(ua_sess);
4553 assert(registry);
4554
4555 if (ua_sess->buffer_type == LTTNG_BUFFER_PER_UID) {
4556 chan_reg_key = ua_chan->tracing_channel_id;
4557 } else {
4558 chan_reg_key = ua_chan->key;
4559 }
4560
4561 pthread_mutex_lock(&registry->lock);
d0b96690 4562
7972aab2 4563 ret_code = ust_registry_create_event(registry, chan_reg_key,
45893984 4564 sobjd, cobjd, name, sig, nr_fields, fields, loglevel,
7972aab2 4565 model_emf_uri, ua_sess->buffer_type, &event_id);
d0b96690
DG
4566
4567 /*
4568 * The return value is returned to ustctl so in case of an error, the
4569 * application can be notified. In case of an error, it's important not to
4570 * return a negative error or else the application will get closed.
4571 */
4572 ret = ustctl_reply_register_event(sock, event_id, ret_code);
4573 if (ret < 0) {
4574 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
4575 ERR("UST app reply event failed with ret %d", ret);
4576 } else {
4577 DBG3("UST app reply event failed. Application died");
4578 }
4579 /*
4580 * No need to wipe the create event since the application socket will
4581 * get close on error hence cleaning up everything by itself.
4582 */
4583 goto error;
4584 }
4585
7972aab2
DG
4586 DBG3("UST registry event %s with id %" PRId32 " added successfully",
4587 name, event_id);
d88aee68 4588
d0b96690 4589error:
7972aab2 4590 pthread_mutex_unlock(&registry->lock);
d88aee68 4591error_rcu_unlock:
d0b96690
DG
4592 rcu_read_unlock();
4593 return ret;
4594}
4595
d88aee68
DG
4596/*
4597 * Handle application notification through the given notify socket.
4598 *
4599 * Return 0 on success or else a negative value.
4600 */
d0b96690
DG
4601int ust_app_recv_notify(int sock)
4602{
4603 int ret;
4604 enum ustctl_notify_cmd cmd;
4605
4606 DBG3("UST app receiving notify from sock %d", sock);
4607
4608 ret = ustctl_recv_notify(sock, &cmd);
4609 if (ret < 0) {
4610 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
4611 ERR("UST app recv notify failed with ret %d", ret);
4612 } else {
4613 DBG3("UST app recv notify failed. Application died");
4614 }
4615 goto error;
4616 }
4617
4618 switch (cmd) {
4619 case USTCTL_NOTIFY_CMD_EVENT:
4620 {
4621 int sobjd, cobjd, loglevel;
4622 char name[LTTNG_UST_SYM_NAME_LEN], *sig, *model_emf_uri;
4623 size_t nr_fields;
4624 struct ustctl_field *fields;
4625
4626 DBG2("UST app ustctl register event received");
4627
4628 ret = ustctl_recv_register_event(sock, &sobjd, &cobjd, name, &loglevel,
4629 &sig, &nr_fields, &fields, &model_emf_uri);
4630 if (ret < 0) {
4631 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
4632 ERR("UST app recv event failed with ret %d", ret);
4633 } else {
4634 DBG3("UST app recv event failed. Application died");
4635 }
4636 goto error;
4637 }
4638
4639 /* Add event to the UST registry coming from the notify socket. */
4640 ret = add_event_ust_registry(sock, sobjd, cobjd, name, sig, nr_fields,
4641 fields, loglevel, model_emf_uri);
4642 if (ret < 0) {
4643 goto error;
4644 }
4645
4646 break;
4647 }
4648 case USTCTL_NOTIFY_CMD_CHANNEL:
4649 {
4650 int sobjd, cobjd;
4651 size_t nr_fields;
4652 struct ustctl_field *fields;
4653
4654 DBG2("UST app ustctl register channel received");
4655
4656 ret = ustctl_recv_register_channel(sock, &sobjd, &cobjd, &nr_fields,
4657 &fields);
4658 if (ret < 0) {
4659 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
4660 ERR("UST app recv channel failed with ret %d", ret);
4661 } else {
4662 DBG3("UST app recv channel failed. Application died");
4663 }
4664 goto error;
4665 }
4666
4667 ret = reply_ust_register_channel(sock, sobjd, cobjd, nr_fields,
4668 fields);
4669 if (ret < 0) {
4670 goto error;
4671 }
4672
4673 break;
4674 }
4675 default:
4676 /* Should NEVER happen. */
4677 assert(0);
4678 }
4679
4680error:
4681 return ret;
4682}
d88aee68
DG
4683
4684/*
4685 * Once the notify socket hangs up, this is called. First, it tries to find the
4686 * corresponding application. On failure, the call_rcu to close the socket is
4687 * executed. If an application is found, it tries to delete it from the notify
4688 * socket hash table. Whathever the result, it proceeds to the call_rcu.
4689 *
4690 * Note that an object needs to be allocated here so on ENOMEM failure, the
4691 * call RCU is not done but the rest of the cleanup is.
4692 */
4693void ust_app_notify_sock_unregister(int sock)
4694{
4695 int err_enomem = 0;
4696 struct lttng_ht_iter iter;
4697 struct ust_app *app;
4698 struct ust_app_notify_sock_obj *obj;
4699
4700 assert(sock >= 0);
4701
4702 rcu_read_lock();
4703
4704 obj = zmalloc(sizeof(*obj));
4705 if (!obj) {
4706 /*
4707 * An ENOMEM is kind of uncool. If this strikes we continue the
4708 * procedure but the call_rcu will not be called. In this case, we
4709 * accept the fd leak rather than possibly creating an unsynchronized
4710 * state between threads.
4711 *
4712 * TODO: The notify object should be created once the notify socket is
4713 * registered and stored independantely from the ust app object. The
4714 * tricky part is to synchronize the teardown of the application and
4715 * this notify object. Let's keep that in mind so we can avoid this
4716 * kind of shenanigans with ENOMEM in the teardown path.
4717 */
4718 err_enomem = 1;
4719 } else {
4720 obj->fd = sock;
4721 }
4722
4723 DBG("UST app notify socket unregister %d", sock);
4724
4725 /*
4726 * Lookup application by notify socket. If this fails, this means that the
4727 * hash table delete has already been done by the application
4728 * unregistration process so we can safely close the notify socket in a
4729 * call RCU.
4730 */
4731 app = find_app_by_notify_sock(sock);
4732 if (!app) {
4733 goto close_socket;
4734 }
4735
4736 iter.iter.node = &app->notify_sock_n.node;
4737
4738 /*
4739 * Whatever happens here either we fail or succeed, in both cases we have
4740 * to close the socket after a grace period to continue to the call RCU
4741 * here. If the deletion is successful, the application is not visible
4742 * anymore by other threads and is it fails it means that it was already
4743 * deleted from the hash table so either way we just have to close the
4744 * socket.
4745 */
4746 (void) lttng_ht_del(ust_app_ht_by_notify_sock, &iter);
4747
4748close_socket:
4749 rcu_read_unlock();
4750
4751 /*
4752 * Close socket after a grace period to avoid for the socket to be reused
4753 * before the application object is freed creating potential race between
4754 * threads trying to add unique in the global hash table.
4755 */
4756 if (!err_enomem) {
4757 call_rcu(&obj->head, close_notify_sock_rcu);
4758 }
4759}
This page took 0.305907 seconds and 4 git commands to generate.