c30792c3c785e959968dc9c00434c0e12af1ec73
[lttng-tools.git] / src / bin / lttng-sessiond / ust-app.c
1 /*
2 * Copyright (C) 2011 - David Goulet <david.goulet@polymtl.ca>
3 *
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.
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 *
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.
16 */
17
18 #define _GNU_SOURCE
19 #define _LGPL_SOURCE
20 #include <errno.h>
21 #include <inttypes.h>
22 #include <pthread.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <sys/stat.h>
27 #include <sys/types.h>
28 #include <unistd.h>
29 #include <urcu/compiler.h>
30 #include <lttng/ust-error.h>
31 #include <signal.h>
32
33 #include <common/common.h>
34 #include <common/sessiond-comm/sessiond-comm.h>
35
36 #include "buffer-registry.h"
37 #include "fd-limit.h"
38 #include "health-sessiond.h"
39 #include "ust-app.h"
40 #include "ust-consumer.h"
41 #include "ust-ctl.h"
42 #include "utils.h"
43
44 static
45 int ust_app_flush_app_session(struct ust_app *app, struct ust_app_session *ua_sess);
46
47 /* Next available channel key. Access under next_channel_key_lock. */
48 static uint64_t _next_channel_key;
49 static pthread_mutex_t next_channel_key_lock = PTHREAD_MUTEX_INITIALIZER;
50
51 /* Next available session ID. Access under next_session_id_lock. */
52 static uint64_t _next_session_id;
53 static pthread_mutex_t next_session_id_lock = PTHREAD_MUTEX_INITIALIZER;
54
55 /*
56 * Return the incremented value of next_channel_key.
57 */
58 static uint64_t get_next_channel_key(void)
59 {
60 uint64_t ret;
61
62 pthread_mutex_lock(&next_channel_key_lock);
63 ret = ++_next_channel_key;
64 pthread_mutex_unlock(&next_channel_key_lock);
65 return ret;
66 }
67
68 /*
69 * Return the atomically incremented value of next_session_id.
70 */
71 static uint64_t get_next_session_id(void)
72 {
73 uint64_t ret;
74
75 pthread_mutex_lock(&next_session_id_lock);
76 ret = ++_next_session_id;
77 pthread_mutex_unlock(&next_session_id_lock);
78 return ret;
79 }
80
81 static void copy_channel_attr_to_ustctl(
82 struct ustctl_consumer_channel_attr *attr,
83 struct lttng_ust_channel_attr *uattr)
84 {
85 /* Copy event attributes since the layout is different. */
86 attr->subbuf_size = uattr->subbuf_size;
87 attr->num_subbuf = uattr->num_subbuf;
88 attr->overwrite = uattr->overwrite;
89 attr->switch_timer_interval = uattr->switch_timer_interval;
90 attr->read_timer_interval = uattr->read_timer_interval;
91 attr->output = uattr->output;
92 }
93
94 /*
95 * Match function for the hash table lookup.
96 *
97 * It matches an ust app event based on three attributes which are the event
98 * name, the filter bytecode and the loglevel.
99 */
100 static int ht_match_ust_app_event(struct cds_lfht_node *node, const void *_key)
101 {
102 struct ust_app_event *event;
103 const struct ust_app_ht_key *key;
104
105 assert(node);
106 assert(_key);
107
108 event = caa_container_of(node, struct ust_app_event, node.node);
109 key = _key;
110
111 /* Match the 4 elements of the key: name, filter, loglevel, exclusions */
112
113 /* Event name */
114 if (strncmp(event->attr.name, key->name, sizeof(event->attr.name)) != 0) {
115 goto no_match;
116 }
117
118 /* Event loglevel. */
119 if (event->attr.loglevel != key->loglevel) {
120 if (event->attr.loglevel_type == LTTNG_UST_LOGLEVEL_ALL
121 && key->loglevel == 0 && event->attr.loglevel == -1) {
122 /*
123 * Match is accepted. This is because on event creation, the
124 * loglevel is set to -1 if the event loglevel type is ALL so 0 and
125 * -1 are accepted for this loglevel type since 0 is the one set by
126 * the API when receiving an enable event.
127 */
128 } else {
129 goto no_match;
130 }
131 }
132
133 /* One of the filters is NULL, fail. */
134 if ((key->filter && !event->filter) || (!key->filter && event->filter)) {
135 goto no_match;
136 }
137
138 if (key->filter && event->filter) {
139 /* Both filters exists, check length followed by the bytecode. */
140 if (event->filter->len != key->filter->len ||
141 memcmp(event->filter->data, key->filter->data,
142 event->filter->len) != 0) {
143 goto no_match;
144 }
145 }
146
147 /* One of the exclusions is NULL, fail. */
148 if ((key->exclusion && !event->exclusion) || (!key->exclusion && event->exclusion)) {
149 goto no_match;
150 }
151
152 if (key->exclusion && event->exclusion) {
153 /* Both exclusions exists, check count followed by the names. */
154 if (event->exclusion->count != key->exclusion->count ||
155 memcmp(event->exclusion->names, key->exclusion->names,
156 event->exclusion->count * LTTNG_UST_SYM_NAME_LEN) != 0) {
157 goto no_match;
158 }
159 }
160
161
162 /* Match. */
163 return 1;
164
165 no_match:
166 return 0;
167 }
168
169 /*
170 * Unique add of an ust app event in the given ht. This uses the custom
171 * ht_match_ust_app_event match function and the event name as hash.
172 */
173 static void add_unique_ust_app_event(struct ust_app_channel *ua_chan,
174 struct ust_app_event *event)
175 {
176 struct cds_lfht_node *node_ptr;
177 struct ust_app_ht_key key;
178 struct lttng_ht *ht;
179
180 assert(ua_chan);
181 assert(ua_chan->events);
182 assert(event);
183
184 ht = ua_chan->events;
185 key.name = event->attr.name;
186 key.filter = event->filter;
187 key.loglevel = event->attr.loglevel;
188 key.exclusion = event->exclusion;
189
190 node_ptr = cds_lfht_add_unique(ht->ht,
191 ht->hash_fct(event->node.key, lttng_ht_seed),
192 ht_match_ust_app_event, &key, &event->node.node);
193 assert(node_ptr == &event->node.node);
194 }
195
196 /*
197 * Close the notify socket from the given RCU head object. This MUST be called
198 * through a call_rcu().
199 */
200 static void close_notify_sock_rcu(struct rcu_head *head)
201 {
202 int ret;
203 struct ust_app_notify_sock_obj *obj =
204 caa_container_of(head, struct ust_app_notify_sock_obj, head);
205
206 /* Must have a valid fd here. */
207 assert(obj->fd >= 0);
208
209 ret = close(obj->fd);
210 if (ret) {
211 ERR("close notify sock %d RCU", obj->fd);
212 }
213 lttng_fd_put(LTTNG_FD_APPS, 1);
214
215 free(obj);
216 }
217
218 /*
219 * Return the session registry according to the buffer type of the given
220 * session.
221 *
222 * A registry per UID object MUST exists before calling this function or else
223 * it assert() if not found. RCU read side lock must be acquired.
224 */
225 static struct ust_registry_session *get_session_registry(
226 struct ust_app_session *ua_sess)
227 {
228 struct ust_registry_session *registry = NULL;
229
230 assert(ua_sess);
231
232 switch (ua_sess->buffer_type) {
233 case LTTNG_BUFFER_PER_PID:
234 {
235 struct buffer_reg_pid *reg_pid = buffer_reg_pid_find(ua_sess->id);
236 if (!reg_pid) {
237 goto error;
238 }
239 registry = reg_pid->registry->reg.ust;
240 break;
241 }
242 case LTTNG_BUFFER_PER_UID:
243 {
244 struct buffer_reg_uid *reg_uid = buffer_reg_uid_find(
245 ua_sess->tracing_id, ua_sess->bits_per_long, ua_sess->uid);
246 if (!reg_uid) {
247 goto error;
248 }
249 registry = reg_uid->registry->reg.ust;
250 break;
251 }
252 default:
253 assert(0);
254 };
255
256 error:
257 return registry;
258 }
259
260 /*
261 * Delete ust context safely. RCU read lock must be held before calling
262 * this function.
263 */
264 static
265 void delete_ust_app_ctx(int sock, struct ust_app_ctx *ua_ctx)
266 {
267 int ret;
268
269 assert(ua_ctx);
270
271 if (ua_ctx->obj) {
272 ret = ustctl_release_object(sock, ua_ctx->obj);
273 if (ret < 0 && ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
274 ERR("UST app sock %d release ctx obj handle %d failed with ret %d",
275 sock, ua_ctx->obj->handle, ret);
276 }
277 free(ua_ctx->obj);
278 }
279 free(ua_ctx);
280 }
281
282 /*
283 * Delete ust app event safely. RCU read lock must be held before calling
284 * this function.
285 */
286 static
287 void delete_ust_app_event(int sock, struct ust_app_event *ua_event)
288 {
289 int ret;
290
291 assert(ua_event);
292
293 free(ua_event->filter);
294 if (ua_event->exclusion != NULL)
295 free(ua_event->exclusion);
296 if (ua_event->obj != NULL) {
297 ret = ustctl_release_object(sock, ua_event->obj);
298 if (ret < 0 && ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
299 ERR("UST app sock %d release event obj failed with ret %d",
300 sock, ret);
301 }
302 free(ua_event->obj);
303 }
304 free(ua_event);
305 }
306
307 /*
308 * Release ust data object of the given stream.
309 *
310 * Return 0 on success or else a negative value.
311 */
312 static int release_ust_app_stream(int sock, struct ust_app_stream *stream)
313 {
314 int ret = 0;
315
316 assert(stream);
317
318 if (stream->obj) {
319 ret = ustctl_release_object(sock, stream->obj);
320 if (ret < 0 && ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
321 ERR("UST app sock %d release stream obj failed with ret %d",
322 sock, ret);
323 }
324 lttng_fd_put(LTTNG_FD_APPS, 2);
325 free(stream->obj);
326 }
327
328 return ret;
329 }
330
331 /*
332 * Delete ust app stream safely. RCU read lock must be held before calling
333 * this function.
334 */
335 static
336 void delete_ust_app_stream(int sock, struct ust_app_stream *stream)
337 {
338 assert(stream);
339
340 (void) release_ust_app_stream(sock, stream);
341 free(stream);
342 }
343
344 /*
345 * We need to execute ht_destroy outside of RCU read-side critical
346 * section and outside of call_rcu thread, so we postpone its execution
347 * using ht_cleanup_push. It is simpler than to change the semantic of
348 * the many callers of delete_ust_app_session().
349 */
350 static
351 void delete_ust_app_channel_rcu(struct rcu_head *head)
352 {
353 struct ust_app_channel *ua_chan =
354 caa_container_of(head, struct ust_app_channel, rcu_head);
355
356 ht_cleanup_push(ua_chan->ctx);
357 ht_cleanup_push(ua_chan->events);
358 free(ua_chan);
359 }
360
361 /*
362 * Delete ust app channel safely. RCU read lock must be held before calling
363 * this function.
364 */
365 static
366 void delete_ust_app_channel(int sock, struct ust_app_channel *ua_chan,
367 struct ust_app *app)
368 {
369 int ret;
370 struct lttng_ht_iter iter;
371 struct ust_app_event *ua_event;
372 struct ust_app_ctx *ua_ctx;
373 struct ust_app_stream *stream, *stmp;
374 struct ust_registry_session *registry;
375
376 assert(ua_chan);
377
378 DBG3("UST app deleting channel %s", ua_chan->name);
379
380 /* Wipe stream */
381 cds_list_for_each_entry_safe(stream, stmp, &ua_chan->streams.head, list) {
382 cds_list_del(&stream->list);
383 delete_ust_app_stream(sock, stream);
384 }
385
386 /* Wipe context */
387 cds_lfht_for_each_entry(ua_chan->ctx->ht, &iter.iter, ua_ctx, node.node) {
388 cds_list_del(&ua_ctx->list);
389 ret = lttng_ht_del(ua_chan->ctx, &iter);
390 assert(!ret);
391 delete_ust_app_ctx(sock, ua_ctx);
392 }
393
394 /* Wipe events */
395 cds_lfht_for_each_entry(ua_chan->events->ht, &iter.iter, ua_event,
396 node.node) {
397 ret = lttng_ht_del(ua_chan->events, &iter);
398 assert(!ret);
399 delete_ust_app_event(sock, ua_event);
400 }
401
402 if (ua_chan->session->buffer_type == LTTNG_BUFFER_PER_PID) {
403 /* Wipe and free registry from session registry. */
404 registry = get_session_registry(ua_chan->session);
405 if (registry) {
406 ust_registry_channel_del_free(registry, ua_chan->key);
407 }
408 }
409
410 if (ua_chan->obj != NULL) {
411 /* Remove channel from application UST object descriptor. */
412 iter.iter.node = &ua_chan->ust_objd_node.node;
413 ret = lttng_ht_del(app->ust_objd, &iter);
414 assert(!ret);
415 ret = ustctl_release_object(sock, ua_chan->obj);
416 if (ret < 0 && ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
417 ERR("UST app sock %d release channel obj failed with ret %d",
418 sock, ret);
419 }
420 lttng_fd_put(LTTNG_FD_APPS, 1);
421 free(ua_chan->obj);
422 }
423 call_rcu(&ua_chan->rcu_head, delete_ust_app_channel_rcu);
424 }
425
426 /*
427 * Push metadata to consumer socket.
428 *
429 * RCU read-side lock must be held to guarantee existance of socket.
430 * Must be called with the ust app session lock held.
431 * Must be called with the registry lock held.
432 *
433 * On success, return the len of metadata pushed or else a negative value.
434 */
435 ssize_t ust_app_push_metadata(struct ust_registry_session *registry,
436 struct consumer_socket *socket, int send_zero_data)
437 {
438 int ret;
439 char *metadata_str = NULL;
440 size_t len, offset;
441 ssize_t ret_val;
442
443 assert(registry);
444 assert(socket);
445
446 /*
447 * Means that no metadata was assigned to the session. This can
448 * happens if no start has been done previously.
449 */
450 if (!registry->metadata_key) {
451 return 0;
452 }
453
454 /*
455 * On a push metadata error either the consumer is dead or the
456 * metadata channel has been destroyed because its endpoint
457 * might have died (e.g: relayd). If so, the metadata closed
458 * flag is set to 1 so we deny pushing metadata again which is
459 * not valid anymore on the consumer side.
460 */
461 if (registry->metadata_closed) {
462 return -EPIPE;
463 }
464
465 offset = registry->metadata_len_sent;
466 len = registry->metadata_len - registry->metadata_len_sent;
467 if (len == 0) {
468 DBG3("No metadata to push for metadata key %" PRIu64,
469 registry->metadata_key);
470 ret_val = len;
471 if (send_zero_data) {
472 DBG("No metadata to push");
473 goto push_data;
474 }
475 goto end;
476 }
477
478 /* Allocate only what we have to send. */
479 metadata_str = zmalloc(len);
480 if (!metadata_str) {
481 PERROR("zmalloc ust app metadata string");
482 ret_val = -ENOMEM;
483 goto error;
484 }
485 /* Copy what we haven't send out. */
486 memcpy(metadata_str, registry->metadata + offset, len);
487 registry->metadata_len_sent += len;
488
489 push_data:
490 ret = consumer_push_metadata(socket, registry->metadata_key,
491 metadata_str, len, offset);
492 if (ret < 0) {
493 /*
494 * There is an acceptable race here between the registry
495 * metadata key assignment and the creation on the
496 * consumer. The session daemon can concurrently push
497 * metadata for this registry while being created on the
498 * consumer since the metadata key of the registry is
499 * assigned *before* it is setup to avoid the consumer
500 * to ask for metadata that could possibly be not found
501 * in the session daemon.
502 *
503 * The metadata will get pushed either by the session
504 * being stopped or the consumer requesting metadata if
505 * that race is triggered.
506 */
507 if (ret == -LTTCOMM_CONSUMERD_CHANNEL_FAIL) {
508 ret = 0;
509 }
510
511 /*
512 * Update back the actual metadata len sent since it
513 * failed here.
514 */
515 registry->metadata_len_sent -= len;
516 ret_val = ret;
517 goto error_push;
518 }
519
520 free(metadata_str);
521 return len;
522
523 end:
524 error:
525 if (ret_val) {
526 /*
527 * On error, flag the registry that the metadata is
528 * closed. We were unable to push anything and this
529 * means that either the consumer is not responding or
530 * the metadata cache has been destroyed on the
531 * consumer.
532 */
533 registry->metadata_closed = 1;
534 }
535 error_push:
536 free(metadata_str);
537 return ret_val;
538 }
539
540 /*
541 * For a given application and session, push metadata to consumer.
542 * Either sock or consumer is required : if sock is NULL, the default
543 * socket to send the metadata is retrieved from consumer, if sock
544 * is not NULL we use it to send the metadata.
545 * RCU read-side lock must be held while calling this function,
546 * therefore ensuring existance of registry. It also ensures existance
547 * of socket throughout this function.
548 *
549 * Return 0 on success else a negative error.
550 */
551 static int push_metadata(struct ust_registry_session *registry,
552 struct consumer_output *consumer)
553 {
554 int ret_val;
555 ssize_t ret;
556 struct consumer_socket *socket;
557
558 assert(registry);
559 assert(consumer);
560
561 pthread_mutex_lock(&registry->lock);
562 if (registry->metadata_closed) {
563 ret_val = -EPIPE;
564 goto error;
565 }
566
567 /* Get consumer socket to use to push the metadata.*/
568 socket = consumer_find_socket_by_bitness(registry->bits_per_long,
569 consumer);
570 if (!socket) {
571 ret_val = -1;
572 goto error;
573 }
574
575 ret = ust_app_push_metadata(registry, socket, 0);
576 if (ret < 0) {
577 ret_val = ret;
578 goto error;
579 }
580 pthread_mutex_unlock(&registry->lock);
581 return 0;
582
583 error:
584 pthread_mutex_unlock(&registry->lock);
585 return ret_val;
586 }
587
588 /*
589 * Send to the consumer a close metadata command for the given session. Once
590 * done, the metadata channel is deleted and the session metadata pointer is
591 * nullified. The session lock MUST be held unless the application is
592 * in the destroy path.
593 *
594 * Return 0 on success else a negative value.
595 */
596 static int close_metadata(struct ust_registry_session *registry,
597 struct consumer_output *consumer)
598 {
599 int ret;
600 struct consumer_socket *socket;
601
602 assert(registry);
603 assert(consumer);
604
605 rcu_read_lock();
606
607 pthread_mutex_lock(&registry->lock);
608
609 if (!registry->metadata_key || registry->metadata_closed) {
610 ret = 0;
611 goto end;
612 }
613
614 /* Get consumer socket to use to push the metadata.*/
615 socket = consumer_find_socket_by_bitness(registry->bits_per_long,
616 consumer);
617 if (!socket) {
618 ret = -1;
619 goto error;
620 }
621
622 ret = consumer_close_metadata(socket, registry->metadata_key);
623 if (ret < 0) {
624 goto error;
625 }
626
627 error:
628 /*
629 * Metadata closed. Even on error this means that the consumer is not
630 * responding or not found so either way a second close should NOT be emit
631 * for this registry.
632 */
633 registry->metadata_closed = 1;
634 end:
635 pthread_mutex_unlock(&registry->lock);
636 rcu_read_unlock();
637 return ret;
638 }
639
640 /*
641 * We need to execute ht_destroy outside of RCU read-side critical
642 * section and outside of call_rcu thread, so we postpone its execution
643 * using ht_cleanup_push. It is simpler than to change the semantic of
644 * the many callers of delete_ust_app_session().
645 */
646 static
647 void delete_ust_app_session_rcu(struct rcu_head *head)
648 {
649 struct ust_app_session *ua_sess =
650 caa_container_of(head, struct ust_app_session, rcu_head);
651
652 ht_cleanup_push(ua_sess->channels);
653 free(ua_sess);
654 }
655
656 /*
657 * Delete ust app session safely. RCU read lock must be held before calling
658 * this function.
659 */
660 static
661 void delete_ust_app_session(int sock, struct ust_app_session *ua_sess,
662 struct ust_app *app)
663 {
664 int ret;
665 struct lttng_ht_iter iter;
666 struct ust_app_channel *ua_chan;
667 struct ust_registry_session *registry;
668
669 assert(ua_sess);
670
671 pthread_mutex_lock(&ua_sess->lock);
672
673 registry = get_session_registry(ua_sess);
674 if (registry) {
675 /* Push metadata for application before freeing the application. */
676 (void) push_metadata(registry, ua_sess->consumer);
677
678 /*
679 * Don't ask to close metadata for global per UID buffers. Close
680 * metadata only on destroy trace session in this case. Also, the
681 * previous push metadata could have flag the metadata registry to
682 * close so don't send a close command if closed.
683 */
684 if (ua_sess->buffer_type != LTTNG_BUFFER_PER_UID) {
685 /* And ask to close it for this session registry. */
686 (void) close_metadata(registry, ua_sess->consumer);
687 }
688 }
689
690 cds_lfht_for_each_entry(ua_sess->channels->ht, &iter.iter, ua_chan,
691 node.node) {
692 ret = lttng_ht_del(ua_sess->channels, &iter);
693 assert(!ret);
694 delete_ust_app_channel(sock, ua_chan, app);
695 }
696
697 /* In case of per PID, the registry is kept in the session. */
698 if (ua_sess->buffer_type == LTTNG_BUFFER_PER_PID) {
699 struct buffer_reg_pid *reg_pid = buffer_reg_pid_find(ua_sess->id);
700 if (reg_pid) {
701 buffer_reg_pid_remove(reg_pid);
702 buffer_reg_pid_destroy(reg_pid);
703 }
704 }
705
706 if (ua_sess->handle != -1) {
707 ret = ustctl_release_handle(sock, ua_sess->handle);
708 if (ret < 0 && ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
709 ERR("UST app sock %d release session handle failed with ret %d",
710 sock, ret);
711 }
712 }
713 pthread_mutex_unlock(&ua_sess->lock);
714
715 call_rcu(&ua_sess->rcu_head, delete_ust_app_session_rcu);
716 }
717
718 /*
719 * Delete a traceable application structure from the global list. Never call
720 * this function outside of a call_rcu call.
721 *
722 * RCU read side lock should _NOT_ be held when calling this function.
723 */
724 static
725 void delete_ust_app(struct ust_app *app)
726 {
727 int ret, sock;
728 struct ust_app_session *ua_sess, *tmp_ua_sess;
729
730 /* Delete ust app sessions info */
731 sock = app->sock;
732 app->sock = -1;
733
734 /* Wipe sessions */
735 cds_list_for_each_entry_safe(ua_sess, tmp_ua_sess, &app->teardown_head,
736 teardown_node) {
737 /* Free every object in the session and the session. */
738 rcu_read_lock();
739 delete_ust_app_session(sock, ua_sess, app);
740 rcu_read_unlock();
741 }
742
743 ht_cleanup_push(app->sessions);
744 ht_cleanup_push(app->ust_objd);
745
746 /*
747 * Wait until we have deleted the application from the sock hash table
748 * before closing this socket, otherwise an application could re-use the
749 * socket ID and race with the teardown, using the same hash table entry.
750 *
751 * It's OK to leave the close in call_rcu. We want it to stay unique for
752 * all RCU readers that could run concurrently with unregister app,
753 * therefore we _need_ to only close that socket after a grace period. So
754 * it should stay in this RCU callback.
755 *
756 * This close() is a very important step of the synchronization model so
757 * every modification to this function must be carefully reviewed.
758 */
759 ret = close(sock);
760 if (ret) {
761 PERROR("close");
762 }
763 lttng_fd_put(LTTNG_FD_APPS, 1);
764
765 DBG2("UST app pid %d deleted", app->pid);
766 free(app);
767 }
768
769 /*
770 * URCU intermediate call to delete an UST app.
771 */
772 static
773 void delete_ust_app_rcu(struct rcu_head *head)
774 {
775 struct lttng_ht_node_ulong *node =
776 caa_container_of(head, struct lttng_ht_node_ulong, head);
777 struct ust_app *app =
778 caa_container_of(node, struct ust_app, pid_n);
779
780 DBG3("Call RCU deleting app PID %d", app->pid);
781 delete_ust_app(app);
782 }
783
784 /*
785 * Delete the session from the application ht and delete the data structure by
786 * freeing every object inside and releasing them.
787 */
788 static void destroy_app_session(struct ust_app *app,
789 struct ust_app_session *ua_sess)
790 {
791 int ret;
792 struct lttng_ht_iter iter;
793
794 assert(app);
795 assert(ua_sess);
796
797 iter.iter.node = &ua_sess->node.node;
798 ret = lttng_ht_del(app->sessions, &iter);
799 if (ret) {
800 /* Already scheduled for teardown. */
801 goto end;
802 }
803
804 /* Once deleted, free the data structure. */
805 delete_ust_app_session(app->sock, ua_sess, app);
806
807 end:
808 return;
809 }
810
811 /*
812 * Alloc new UST app session.
813 */
814 static
815 struct ust_app_session *alloc_ust_app_session(struct ust_app *app)
816 {
817 struct ust_app_session *ua_sess;
818
819 /* Init most of the default value by allocating and zeroing */
820 ua_sess = zmalloc(sizeof(struct ust_app_session));
821 if (ua_sess == NULL) {
822 PERROR("malloc");
823 goto error_free;
824 }
825
826 ua_sess->handle = -1;
827 ua_sess->channels = lttng_ht_new(0, LTTNG_HT_TYPE_STRING);
828 ua_sess->metadata_attr.type = LTTNG_UST_CHAN_METADATA;
829 pthread_mutex_init(&ua_sess->lock, NULL);
830
831 return ua_sess;
832
833 error_free:
834 return NULL;
835 }
836
837 /*
838 * Alloc new UST app channel.
839 */
840 static
841 struct ust_app_channel *alloc_ust_app_channel(char *name,
842 struct ust_app_session *ua_sess,
843 struct lttng_ust_channel_attr *attr)
844 {
845 struct ust_app_channel *ua_chan;
846
847 /* Init most of the default value by allocating and zeroing */
848 ua_chan = zmalloc(sizeof(struct ust_app_channel));
849 if (ua_chan == NULL) {
850 PERROR("malloc");
851 goto error;
852 }
853
854 /* Setup channel name */
855 strncpy(ua_chan->name, name, sizeof(ua_chan->name));
856 ua_chan->name[sizeof(ua_chan->name) - 1] = '\0';
857
858 ua_chan->enabled = 1;
859 ua_chan->handle = -1;
860 ua_chan->session = ua_sess;
861 ua_chan->key = get_next_channel_key();
862 ua_chan->ctx = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG);
863 ua_chan->events = lttng_ht_new(0, LTTNG_HT_TYPE_STRING);
864 lttng_ht_node_init_str(&ua_chan->node, ua_chan->name);
865
866 CDS_INIT_LIST_HEAD(&ua_chan->streams.head);
867 CDS_INIT_LIST_HEAD(&ua_chan->ctx_list);
868
869 /* Copy attributes */
870 if (attr) {
871 /* Translate from lttng_ust_channel to ustctl_consumer_channel_attr. */
872 ua_chan->attr.subbuf_size = attr->subbuf_size;
873 ua_chan->attr.num_subbuf = attr->num_subbuf;
874 ua_chan->attr.overwrite = attr->overwrite;
875 ua_chan->attr.switch_timer_interval = attr->switch_timer_interval;
876 ua_chan->attr.read_timer_interval = attr->read_timer_interval;
877 ua_chan->attr.output = attr->output;
878 }
879 /* By default, the channel is a per cpu channel. */
880 ua_chan->attr.type = LTTNG_UST_CHAN_PER_CPU;
881
882 DBG3("UST app channel %s allocated", ua_chan->name);
883
884 return ua_chan;
885
886 error:
887 return NULL;
888 }
889
890 /*
891 * Allocate and initialize a UST app stream.
892 *
893 * Return newly allocated stream pointer or NULL on error.
894 */
895 struct ust_app_stream *ust_app_alloc_stream(void)
896 {
897 struct ust_app_stream *stream = NULL;
898
899 stream = zmalloc(sizeof(*stream));
900 if (stream == NULL) {
901 PERROR("zmalloc ust app stream");
902 goto error;
903 }
904
905 /* Zero could be a valid value for a handle so flag it to -1. */
906 stream->handle = -1;
907
908 error:
909 return stream;
910 }
911
912 /*
913 * Alloc new UST app event.
914 */
915 static
916 struct ust_app_event *alloc_ust_app_event(char *name,
917 struct lttng_ust_event *attr)
918 {
919 struct ust_app_event *ua_event;
920
921 /* Init most of the default value by allocating and zeroing */
922 ua_event = zmalloc(sizeof(struct ust_app_event));
923 if (ua_event == NULL) {
924 PERROR("malloc");
925 goto error;
926 }
927
928 ua_event->enabled = 1;
929 strncpy(ua_event->name, name, sizeof(ua_event->name));
930 ua_event->name[sizeof(ua_event->name) - 1] = '\0';
931 lttng_ht_node_init_str(&ua_event->node, ua_event->name);
932
933 /* Copy attributes */
934 if (attr) {
935 memcpy(&ua_event->attr, attr, sizeof(ua_event->attr));
936 }
937
938 DBG3("UST app event %s allocated", ua_event->name);
939
940 return ua_event;
941
942 error:
943 return NULL;
944 }
945
946 /*
947 * Alloc new UST app context.
948 */
949 static
950 struct ust_app_ctx *alloc_ust_app_ctx(struct lttng_ust_context *uctx)
951 {
952 struct ust_app_ctx *ua_ctx;
953
954 ua_ctx = zmalloc(sizeof(struct ust_app_ctx));
955 if (ua_ctx == NULL) {
956 goto error;
957 }
958
959 CDS_INIT_LIST_HEAD(&ua_ctx->list);
960
961 if (uctx) {
962 memcpy(&ua_ctx->ctx, uctx, sizeof(ua_ctx->ctx));
963 }
964
965 DBG3("UST app context %d allocated", ua_ctx->ctx.ctx);
966
967 error:
968 return ua_ctx;
969 }
970
971 /*
972 * Allocate a filter and copy the given original filter.
973 *
974 * Return allocated filter or NULL on error.
975 */
976 static struct lttng_ust_filter_bytecode *alloc_copy_ust_app_filter(
977 struct lttng_ust_filter_bytecode *orig_f)
978 {
979 struct lttng_ust_filter_bytecode *filter = NULL;
980
981 /* Copy filter bytecode */
982 filter = zmalloc(sizeof(*filter) + orig_f->len);
983 if (!filter) {
984 PERROR("zmalloc alloc ust app filter");
985 goto error;
986 }
987
988 memcpy(filter, orig_f, sizeof(*filter) + orig_f->len);
989
990 error:
991 return filter;
992 }
993
994 /*
995 * Find an ust_app using the sock and return it. RCU read side lock must be
996 * held before calling this helper function.
997 */
998 struct ust_app *ust_app_find_by_sock(int sock)
999 {
1000 struct lttng_ht_node_ulong *node;
1001 struct lttng_ht_iter iter;
1002
1003 lttng_ht_lookup(ust_app_ht_by_sock, (void *)((unsigned long) sock), &iter);
1004 node = lttng_ht_iter_get_node_ulong(&iter);
1005 if (node == NULL) {
1006 DBG2("UST app find by sock %d not found", sock);
1007 goto error;
1008 }
1009
1010 return caa_container_of(node, struct ust_app, sock_n);
1011
1012 error:
1013 return NULL;
1014 }
1015
1016 /*
1017 * Find an ust_app using the notify sock and return it. RCU read side lock must
1018 * be held before calling this helper function.
1019 */
1020 static struct ust_app *find_app_by_notify_sock(int sock)
1021 {
1022 struct lttng_ht_node_ulong *node;
1023 struct lttng_ht_iter iter;
1024
1025 lttng_ht_lookup(ust_app_ht_by_notify_sock, (void *)((unsigned long) sock),
1026 &iter);
1027 node = lttng_ht_iter_get_node_ulong(&iter);
1028 if (node == NULL) {
1029 DBG2("UST app find by notify sock %d not found", sock);
1030 goto error;
1031 }
1032
1033 return caa_container_of(node, struct ust_app, notify_sock_n);
1034
1035 error:
1036 return NULL;
1037 }
1038
1039 /*
1040 * Lookup for an ust app event based on event name, filter bytecode and the
1041 * event loglevel.
1042 *
1043 * Return an ust_app_event object or NULL on error.
1044 */
1045 static struct ust_app_event *find_ust_app_event(struct lttng_ht *ht,
1046 char *name, struct lttng_ust_filter_bytecode *filter, int loglevel,
1047 const struct lttng_event_exclusion *exclusion)
1048 {
1049 struct lttng_ht_iter iter;
1050 struct lttng_ht_node_str *node;
1051 struct ust_app_event *event = NULL;
1052 struct ust_app_ht_key key;
1053
1054 assert(name);
1055 assert(ht);
1056
1057 /* Setup key for event lookup. */
1058 key.name = name;
1059 key.filter = filter;
1060 key.loglevel = loglevel;
1061 /* lttng_event_exclusion and lttng_ust_event_exclusion structures are similar */
1062 key.exclusion = (struct lttng_ust_event_exclusion *)exclusion;
1063
1064 /* Lookup using the event name as hash and a custom match fct. */
1065 cds_lfht_lookup(ht->ht, ht->hash_fct((void *) name, lttng_ht_seed),
1066 ht_match_ust_app_event, &key, &iter.iter);
1067 node = lttng_ht_iter_get_node_str(&iter);
1068 if (node == NULL) {
1069 goto end;
1070 }
1071
1072 event = caa_container_of(node, struct ust_app_event, node);
1073
1074 end:
1075 return event;
1076 }
1077
1078 /*
1079 * Create the channel context on the tracer.
1080 *
1081 * Called with UST app session lock held.
1082 */
1083 static
1084 int create_ust_channel_context(struct ust_app_channel *ua_chan,
1085 struct ust_app_ctx *ua_ctx, struct ust_app *app)
1086 {
1087 int ret;
1088
1089 health_code_update();
1090
1091 ret = ustctl_add_context(app->sock, &ua_ctx->ctx,
1092 ua_chan->obj, &ua_ctx->obj);
1093 if (ret < 0) {
1094 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
1095 ERR("UST app create channel context failed for app (pid: %d) "
1096 "with ret %d", app->pid, ret);
1097 } else {
1098 /*
1099 * This is normal behavior, an application can die during the
1100 * creation process. Don't report an error so the execution can
1101 * continue normally.
1102 */
1103 ret = 0;
1104 DBG3("UST app disable event failed. Application is dead.");
1105 }
1106 goto error;
1107 }
1108
1109 ua_ctx->handle = ua_ctx->obj->handle;
1110
1111 DBG2("UST app context handle %d created successfully for channel %s",
1112 ua_ctx->handle, ua_chan->name);
1113
1114 error:
1115 health_code_update();
1116 return ret;
1117 }
1118
1119 /*
1120 * Set the filter on the tracer.
1121 */
1122 static
1123 int set_ust_event_filter(struct ust_app_event *ua_event,
1124 struct ust_app *app)
1125 {
1126 int ret;
1127
1128 health_code_update();
1129
1130 if (!ua_event->filter) {
1131 ret = 0;
1132 goto error;
1133 }
1134
1135 ret = ustctl_set_filter(app->sock, ua_event->filter,
1136 ua_event->obj);
1137 if (ret < 0) {
1138 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
1139 ERR("UST app event %s filter failed for app (pid: %d) "
1140 "with ret %d", ua_event->attr.name, app->pid, ret);
1141 } else {
1142 /*
1143 * This is normal behavior, an application can die during the
1144 * creation process. Don't report an error so the execution can
1145 * continue normally.
1146 */
1147 ret = 0;
1148 DBG3("UST app filter event failed. Application is dead.");
1149 }
1150 goto error;
1151 }
1152
1153 DBG2("UST filter set successfully for event %s", ua_event->name);
1154
1155 error:
1156 health_code_update();
1157 return ret;
1158 }
1159
1160 /*
1161 * Set event exclusions on the tracer.
1162 */
1163 static
1164 int set_ust_event_exclusion(struct ust_app_event *ua_event,
1165 struct ust_app *app)
1166 {
1167 int ret;
1168
1169 health_code_update();
1170
1171 if (!ua_event->exclusion || !ua_event->exclusion->count) {
1172 ret = 0;
1173 goto error;
1174 }
1175
1176 ret = ustctl_set_exclusion(app->sock, ua_event->exclusion,
1177 ua_event->obj);
1178 if (ret < 0) {
1179 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
1180 ERR("UST app event %s exclusions failed for app (pid: %d) "
1181 "with ret %d", ua_event->attr.name, app->pid, ret);
1182 } else {
1183 /*
1184 * This is normal behavior, an application can die during the
1185 * creation process. Don't report an error so the execution can
1186 * continue normally.
1187 */
1188 ret = 0;
1189 DBG3("UST app event exclusion failed. Application is dead.");
1190 }
1191 goto error;
1192 }
1193
1194 DBG2("UST exclusion set successfully for event %s", ua_event->name);
1195
1196 error:
1197 health_code_update();
1198 return ret;
1199 }
1200
1201 /*
1202 * Disable the specified event on to UST tracer for the UST session.
1203 */
1204 static int disable_ust_event(struct ust_app *app,
1205 struct ust_app_session *ua_sess, struct ust_app_event *ua_event)
1206 {
1207 int ret;
1208
1209 health_code_update();
1210
1211 ret = ustctl_disable(app->sock, ua_event->obj);
1212 if (ret < 0) {
1213 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
1214 ERR("UST app event %s disable failed for app (pid: %d) "
1215 "and session handle %d with ret %d",
1216 ua_event->attr.name, app->pid, ua_sess->handle, ret);
1217 } else {
1218 /*
1219 * This is normal behavior, an application can die during the
1220 * creation process. Don't report an error so the execution can
1221 * continue normally.
1222 */
1223 ret = 0;
1224 DBG3("UST app disable event failed. Application is dead.");
1225 }
1226 goto error;
1227 }
1228
1229 DBG2("UST app event %s disabled successfully for app (pid: %d)",
1230 ua_event->attr.name, app->pid);
1231
1232 error:
1233 health_code_update();
1234 return ret;
1235 }
1236
1237 /*
1238 * Disable the specified channel on to UST tracer for the UST session.
1239 */
1240 static int disable_ust_channel(struct ust_app *app,
1241 struct ust_app_session *ua_sess, struct ust_app_channel *ua_chan)
1242 {
1243 int ret;
1244
1245 health_code_update();
1246
1247 ret = ustctl_disable(app->sock, ua_chan->obj);
1248 if (ret < 0) {
1249 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
1250 ERR("UST app channel %s disable failed for app (pid: %d) "
1251 "and session handle %d with ret %d",
1252 ua_chan->name, app->pid, ua_sess->handle, ret);
1253 } else {
1254 /*
1255 * This is normal behavior, an application can die during the
1256 * creation process. Don't report an error so the execution can
1257 * continue normally.
1258 */
1259 ret = 0;
1260 DBG3("UST app disable channel failed. Application is dead.");
1261 }
1262 goto error;
1263 }
1264
1265 DBG2("UST app channel %s disabled successfully for app (pid: %d)",
1266 ua_chan->name, app->pid);
1267
1268 error:
1269 health_code_update();
1270 return ret;
1271 }
1272
1273 /*
1274 * Enable the specified channel on to UST tracer for the UST session.
1275 */
1276 static int enable_ust_channel(struct ust_app *app,
1277 struct ust_app_session *ua_sess, struct ust_app_channel *ua_chan)
1278 {
1279 int ret;
1280
1281 health_code_update();
1282
1283 ret = ustctl_enable(app->sock, ua_chan->obj);
1284 if (ret < 0) {
1285 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
1286 ERR("UST app channel %s enable failed for app (pid: %d) "
1287 "and session handle %d with ret %d",
1288 ua_chan->name, app->pid, ua_sess->handle, ret);
1289 } else {
1290 /*
1291 * This is normal behavior, an application can die during the
1292 * creation process. Don't report an error so the execution can
1293 * continue normally.
1294 */
1295 ret = 0;
1296 DBG3("UST app enable channel failed. Application is dead.");
1297 }
1298 goto error;
1299 }
1300
1301 ua_chan->enabled = 1;
1302
1303 DBG2("UST app channel %s enabled successfully for app (pid: %d)",
1304 ua_chan->name, app->pid);
1305
1306 error:
1307 health_code_update();
1308 return ret;
1309 }
1310
1311 /*
1312 * Enable the specified event on to UST tracer for the UST session.
1313 */
1314 static int enable_ust_event(struct ust_app *app,
1315 struct ust_app_session *ua_sess, struct ust_app_event *ua_event)
1316 {
1317 int ret;
1318
1319 health_code_update();
1320
1321 ret = ustctl_enable(app->sock, ua_event->obj);
1322 if (ret < 0) {
1323 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
1324 ERR("UST app event %s enable failed for app (pid: %d) "
1325 "and session handle %d with ret %d",
1326 ua_event->attr.name, app->pid, ua_sess->handle, ret);
1327 } else {
1328 /*
1329 * This is normal behavior, an application can die during the
1330 * creation process. Don't report an error so the execution can
1331 * continue normally.
1332 */
1333 ret = 0;
1334 DBG3("UST app enable event failed. Application is dead.");
1335 }
1336 goto error;
1337 }
1338
1339 DBG2("UST app event %s enabled successfully for app (pid: %d)",
1340 ua_event->attr.name, app->pid);
1341
1342 error:
1343 health_code_update();
1344 return ret;
1345 }
1346
1347 /*
1348 * Send channel and stream buffer to application.
1349 *
1350 * Return 0 on success. On error, a negative value is returned.
1351 */
1352 static int send_channel_pid_to_ust(struct ust_app *app,
1353 struct ust_app_session *ua_sess, struct ust_app_channel *ua_chan)
1354 {
1355 int ret;
1356 struct ust_app_stream *stream, *stmp;
1357
1358 assert(app);
1359 assert(ua_sess);
1360 assert(ua_chan);
1361
1362 health_code_update();
1363
1364 DBG("UST app sending channel %s to UST app sock %d", ua_chan->name,
1365 app->sock);
1366
1367 /* Send channel to the application. */
1368 ret = ust_consumer_send_channel_to_ust(app, ua_sess, ua_chan);
1369 if (ret < 0) {
1370 goto error;
1371 }
1372
1373 health_code_update();
1374
1375 /* Send all streams to application. */
1376 cds_list_for_each_entry_safe(stream, stmp, &ua_chan->streams.head, list) {
1377 ret = ust_consumer_send_stream_to_ust(app, ua_chan, stream);
1378 if (ret < 0) {
1379 goto error;
1380 }
1381 /* We don't need the stream anymore once sent to the tracer. */
1382 cds_list_del(&stream->list);
1383 delete_ust_app_stream(-1, stream);
1384 }
1385 /* Flag the channel that it is sent to the application. */
1386 ua_chan->is_sent = 1;
1387
1388 error:
1389 health_code_update();
1390 return ret;
1391 }
1392
1393 /*
1394 * Create the specified event onto the UST tracer for a UST session.
1395 *
1396 * Should be called with session mutex held.
1397 */
1398 static
1399 int create_ust_event(struct ust_app *app, struct ust_app_session *ua_sess,
1400 struct ust_app_channel *ua_chan, struct ust_app_event *ua_event)
1401 {
1402 int ret = 0;
1403
1404 health_code_update();
1405
1406 /* Create UST event on tracer */
1407 ret = ustctl_create_event(app->sock, &ua_event->attr, ua_chan->obj,
1408 &ua_event->obj);
1409 if (ret < 0) {
1410 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
1411 ERR("Error ustctl create event %s for app pid: %d with ret %d",
1412 ua_event->attr.name, app->pid, ret);
1413 } else {
1414 /*
1415 * This is normal behavior, an application can die during the
1416 * creation process. Don't report an error so the execution can
1417 * continue normally.
1418 */
1419 ret = 0;
1420 DBG3("UST app create event failed. Application is dead.");
1421 }
1422 goto error;
1423 }
1424
1425 ua_event->handle = ua_event->obj->handle;
1426
1427 DBG2("UST app event %s created successfully for pid:%d",
1428 ua_event->attr.name, app->pid);
1429
1430 health_code_update();
1431
1432 /* Set filter if one is present. */
1433 if (ua_event->filter) {
1434 ret = set_ust_event_filter(ua_event, app);
1435 if (ret < 0) {
1436 goto error;
1437 }
1438 }
1439
1440 /* Set exclusions for the event */
1441 if (ua_event->exclusion) {
1442 ret = set_ust_event_exclusion(ua_event, app);
1443 if (ret < 0) {
1444 goto error;
1445 }
1446 }
1447
1448 /* If event not enabled, disable it on the tracer */
1449 if (ua_event->enabled) {
1450 /*
1451 * We now need to explicitly enable the event, since it
1452 * is now disabled at creation.
1453 */
1454 ret = enable_ust_event(app, ua_sess, ua_event);
1455 if (ret < 0) {
1456 /*
1457 * If we hit an EPERM, something is wrong with our enable call. If
1458 * we get an EEXIST, there is a problem on the tracer side since we
1459 * just created it.
1460 */
1461 switch (ret) {
1462 case -LTTNG_UST_ERR_PERM:
1463 /* Code flow problem */
1464 assert(0);
1465 case -LTTNG_UST_ERR_EXIST:
1466 /* It's OK for our use case. */
1467 ret = 0;
1468 break;
1469 default:
1470 break;
1471 }
1472 goto error;
1473 }
1474 }
1475
1476 error:
1477 health_code_update();
1478 return ret;
1479 }
1480
1481 /*
1482 * Copy data between an UST app event and a LTT event.
1483 */
1484 static void shadow_copy_event(struct ust_app_event *ua_event,
1485 struct ltt_ust_event *uevent)
1486 {
1487 size_t exclusion_alloc_size;
1488
1489 strncpy(ua_event->name, uevent->attr.name, sizeof(ua_event->name));
1490 ua_event->name[sizeof(ua_event->name) - 1] = '\0';
1491
1492 ua_event->enabled = uevent->enabled;
1493
1494 /* Copy event attributes */
1495 memcpy(&ua_event->attr, &uevent->attr, sizeof(ua_event->attr));
1496
1497 /* Copy filter bytecode */
1498 if (uevent->filter) {
1499 ua_event->filter = alloc_copy_ust_app_filter(uevent->filter);
1500 /* Filter might be NULL here in case of ENONEM. */
1501 }
1502
1503 /* Copy exclusion data */
1504 if (uevent->exclusion) {
1505 exclusion_alloc_size = sizeof(struct lttng_ust_event_exclusion) +
1506 LTTNG_UST_SYM_NAME_LEN * uevent->exclusion->count;
1507 ua_event->exclusion = zmalloc(exclusion_alloc_size);
1508 if (ua_event->exclusion == NULL) {
1509 PERROR("malloc");
1510 } else {
1511 memcpy(ua_event->exclusion, uevent->exclusion,
1512 exclusion_alloc_size);
1513 }
1514 }
1515 }
1516
1517 /*
1518 * Copy data between an UST app channel and a LTT channel.
1519 */
1520 static void shadow_copy_channel(struct ust_app_channel *ua_chan,
1521 struct ltt_ust_channel *uchan)
1522 {
1523 struct lttng_ht_iter iter;
1524 struct ltt_ust_event *uevent;
1525 struct ltt_ust_context *uctx;
1526 struct ust_app_event *ua_event;
1527 struct ust_app_ctx *ua_ctx;
1528
1529 DBG2("UST app shadow copy of channel %s started", ua_chan->name);
1530
1531 strncpy(ua_chan->name, uchan->name, sizeof(ua_chan->name));
1532 ua_chan->name[sizeof(ua_chan->name) - 1] = '\0';
1533
1534 ua_chan->tracefile_size = uchan->tracefile_size;
1535 ua_chan->tracefile_count = uchan->tracefile_count;
1536
1537 /* Copy event attributes since the layout is different. */
1538 ua_chan->attr.subbuf_size = uchan->attr.subbuf_size;
1539 ua_chan->attr.num_subbuf = uchan->attr.num_subbuf;
1540 ua_chan->attr.overwrite = uchan->attr.overwrite;
1541 ua_chan->attr.switch_timer_interval = uchan->attr.switch_timer_interval;
1542 ua_chan->attr.read_timer_interval = uchan->attr.read_timer_interval;
1543 ua_chan->attr.output = uchan->attr.output;
1544 /*
1545 * Note that the attribute channel type is not set since the channel on the
1546 * tracing registry side does not have this information.
1547 */
1548
1549 ua_chan->enabled = uchan->enabled;
1550 ua_chan->tracing_channel_id = uchan->id;
1551
1552 cds_list_for_each_entry(uctx, &uchan->ctx_list, list) {
1553 ua_ctx = alloc_ust_app_ctx(&uctx->ctx);
1554 if (ua_ctx == NULL) {
1555 continue;
1556 }
1557 lttng_ht_node_init_ulong(&ua_ctx->node,
1558 (unsigned long) ua_ctx->ctx.ctx);
1559 lttng_ht_add_ulong(ua_chan->ctx, &ua_ctx->node);
1560 cds_list_add_tail(&ua_ctx->list, &ua_chan->ctx_list);
1561 }
1562
1563 /* Copy all events from ltt ust channel to ust app channel */
1564 cds_lfht_for_each_entry(uchan->events->ht, &iter.iter, uevent, node.node) {
1565 ua_event = find_ust_app_event(ua_chan->events, uevent->attr.name,
1566 uevent->filter, uevent->attr.loglevel, uevent->exclusion);
1567 if (ua_event == NULL) {
1568 DBG2("UST event %s not found on shadow copy channel",
1569 uevent->attr.name);
1570 ua_event = alloc_ust_app_event(uevent->attr.name, &uevent->attr);
1571 if (ua_event == NULL) {
1572 continue;
1573 }
1574 shadow_copy_event(ua_event, uevent);
1575 add_unique_ust_app_event(ua_chan, ua_event);
1576 }
1577 }
1578
1579 DBG3("UST app shadow copy of channel %s done", ua_chan->name);
1580 }
1581
1582 /*
1583 * Copy data between a UST app session and a regular LTT session.
1584 */
1585 static void shadow_copy_session(struct ust_app_session *ua_sess,
1586 struct ltt_ust_session *usess, struct ust_app *app)
1587 {
1588 struct lttng_ht_node_str *ua_chan_node;
1589 struct lttng_ht_iter iter;
1590 struct ltt_ust_channel *uchan;
1591 struct ust_app_channel *ua_chan;
1592 time_t rawtime;
1593 struct tm *timeinfo;
1594 char datetime[16];
1595 int ret;
1596 char tmp_shm_path[PATH_MAX];
1597
1598 /* Get date and time for unique app path */
1599 time(&rawtime);
1600 timeinfo = localtime(&rawtime);
1601 strftime(datetime, sizeof(datetime), "%Y%m%d-%H%M%S", timeinfo);
1602
1603 DBG2("Shadow copy of session handle %d", ua_sess->handle);
1604
1605 ua_sess->tracing_id = usess->id;
1606 ua_sess->id = get_next_session_id();
1607 ua_sess->uid = app->uid;
1608 ua_sess->gid = app->gid;
1609 ua_sess->euid = usess->uid;
1610 ua_sess->egid = usess->gid;
1611 ua_sess->buffer_type = usess->buffer_type;
1612 ua_sess->bits_per_long = app->bits_per_long;
1613 /* There is only one consumer object per session possible. */
1614 ua_sess->consumer = usess->consumer;
1615 ua_sess->output_traces = usess->output_traces;
1616 ua_sess->live_timer_interval = usess->live_timer_interval;
1617 copy_channel_attr_to_ustctl(&ua_sess->metadata_attr,
1618 &usess->metadata_attr);
1619
1620 switch (ua_sess->buffer_type) {
1621 case LTTNG_BUFFER_PER_PID:
1622 ret = snprintf(ua_sess->path, sizeof(ua_sess->path),
1623 DEFAULT_UST_TRACE_PID_PATH "/%s-%d-%s", app->name, app->pid,
1624 datetime);
1625 break;
1626 case LTTNG_BUFFER_PER_UID:
1627 ret = snprintf(ua_sess->path, sizeof(ua_sess->path),
1628 DEFAULT_UST_TRACE_UID_PATH, ua_sess->uid, app->bits_per_long);
1629 break;
1630 default:
1631 assert(0);
1632 goto error;
1633 }
1634 if (ret < 0) {
1635 PERROR("asprintf UST shadow copy session");
1636 assert(0);
1637 goto error;
1638 }
1639
1640 strncpy(ua_sess->root_shm_path, usess->root_shm_path,
1641 sizeof(ua_sess->root_shm_path));
1642 ua_sess->root_shm_path[sizeof(ua_sess->root_shm_path) - 1] = '\0';
1643 strncpy(ua_sess->shm_path, usess->shm_path,
1644 sizeof(ua_sess->shm_path));
1645 ua_sess->shm_path[sizeof(ua_sess->shm_path) - 1] = '\0';
1646 if (ua_sess->shm_path[0]) {
1647 switch (ua_sess->buffer_type) {
1648 case LTTNG_BUFFER_PER_PID:
1649 ret = snprintf(tmp_shm_path, sizeof(tmp_shm_path),
1650 DEFAULT_UST_TRACE_PID_PATH "/%s-%d-%s",
1651 app->name, app->pid, datetime);
1652 break;
1653 case LTTNG_BUFFER_PER_UID:
1654 ret = snprintf(tmp_shm_path, sizeof(tmp_shm_path),
1655 DEFAULT_UST_TRACE_UID_PATH,
1656 app->uid, app->bits_per_long);
1657 break;
1658 default:
1659 assert(0);
1660 goto error;
1661 }
1662 if (ret < 0) {
1663 PERROR("sprintf UST shadow copy session");
1664 assert(0);
1665 goto error;
1666 }
1667 strncat(ua_sess->shm_path, tmp_shm_path,
1668 sizeof(ua_sess->shm_path) - strlen(ua_sess->shm_path) - 1);
1669 ua_sess->shm_path[sizeof(ua_sess->shm_path) - 1] = '\0';
1670 }
1671
1672 /* Iterate over all channels in global domain. */
1673 cds_lfht_for_each_entry(usess->domain_global.channels->ht, &iter.iter,
1674 uchan, node.node) {
1675 struct lttng_ht_iter uiter;
1676
1677 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &uiter);
1678 ua_chan_node = lttng_ht_iter_get_node_str(&uiter);
1679 if (ua_chan_node != NULL) {
1680 /* Session exist. Contiuing. */
1681 continue;
1682 }
1683
1684 DBG2("Channel %s not found on shadow session copy, creating it",
1685 uchan->name);
1686 ua_chan = alloc_ust_app_channel(uchan->name, ua_sess, &uchan->attr);
1687 if (ua_chan == NULL) {
1688 /* malloc failed FIXME: Might want to do handle ENOMEM .. */
1689 continue;
1690 }
1691 shadow_copy_channel(ua_chan, uchan);
1692 /*
1693 * The concept of metadata channel does not exist on the tracing
1694 * registry side of the session daemon so this can only be a per CPU
1695 * channel and not metadata.
1696 */
1697 ua_chan->attr.type = LTTNG_UST_CHAN_PER_CPU;
1698
1699 lttng_ht_add_unique_str(ua_sess->channels, &ua_chan->node);
1700 }
1701
1702 error:
1703 return;
1704 }
1705
1706 /*
1707 * Lookup sesison wrapper.
1708 */
1709 static
1710 void __lookup_session_by_app(struct ltt_ust_session *usess,
1711 struct ust_app *app, struct lttng_ht_iter *iter)
1712 {
1713 /* Get right UST app session from app */
1714 lttng_ht_lookup(app->sessions, &usess->id, iter);
1715 }
1716
1717 /*
1718 * Return ust app session from the app session hashtable using the UST session
1719 * id.
1720 */
1721 static struct ust_app_session *lookup_session_by_app(
1722 struct ltt_ust_session *usess, struct ust_app *app)
1723 {
1724 struct lttng_ht_iter iter;
1725 struct lttng_ht_node_u64 *node;
1726
1727 __lookup_session_by_app(usess, app, &iter);
1728 node = lttng_ht_iter_get_node_u64(&iter);
1729 if (node == NULL) {
1730 goto error;
1731 }
1732
1733 return caa_container_of(node, struct ust_app_session, node);
1734
1735 error:
1736 return NULL;
1737 }
1738
1739 /*
1740 * Setup buffer registry per PID for the given session and application. If none
1741 * is found, a new one is created, added to the global registry and
1742 * initialized. If regp is valid, it's set with the newly created object.
1743 *
1744 * Return 0 on success or else a negative value.
1745 */
1746 static int setup_buffer_reg_pid(struct ust_app_session *ua_sess,
1747 struct ust_app *app, struct buffer_reg_pid **regp)
1748 {
1749 int ret = 0;
1750 struct buffer_reg_pid *reg_pid;
1751
1752 assert(ua_sess);
1753 assert(app);
1754
1755 rcu_read_lock();
1756
1757 reg_pid = buffer_reg_pid_find(ua_sess->id);
1758 if (!reg_pid) {
1759 /*
1760 * This is the create channel path meaning that if there is NO
1761 * registry available, we have to create one for this session.
1762 */
1763 ret = buffer_reg_pid_create(ua_sess->id, &reg_pid,
1764 ua_sess->root_shm_path, ua_sess->shm_path);
1765 if (ret < 0) {
1766 goto error;
1767 }
1768 } else {
1769 goto end;
1770 }
1771
1772 /* Initialize registry. */
1773 ret = ust_registry_session_init(&reg_pid->registry->reg.ust, app,
1774 app->bits_per_long, app->uint8_t_alignment,
1775 app->uint16_t_alignment, app->uint32_t_alignment,
1776 app->uint64_t_alignment, app->long_alignment,
1777 app->byte_order, app->version.major,
1778 app->version.minor, reg_pid->root_shm_path,
1779 reg_pid->shm_path,
1780 ua_sess->euid, ua_sess->egid);
1781 if (ret < 0) {
1782 /*
1783 * reg_pid->registry->reg.ust is NULL upon error, so we need to
1784 * destroy the buffer registry, because it is always expected
1785 * that if the buffer registry can be found, its ust registry is
1786 * non-NULL.
1787 */
1788 buffer_reg_pid_destroy(reg_pid);
1789 goto error;
1790 }
1791
1792 buffer_reg_pid_add(reg_pid);
1793
1794 DBG3("UST app buffer registry per PID created successfully");
1795
1796 end:
1797 if (regp) {
1798 *regp = reg_pid;
1799 }
1800 error:
1801 rcu_read_unlock();
1802 return ret;
1803 }
1804
1805 /*
1806 * Setup buffer registry per UID for the given session and application. If none
1807 * is found, a new one is created, added to the global registry and
1808 * initialized. If regp is valid, it's set with the newly created object.
1809 *
1810 * Return 0 on success or else a negative value.
1811 */
1812 static int setup_buffer_reg_uid(struct ltt_ust_session *usess,
1813 struct ust_app_session *ua_sess,
1814 struct ust_app *app, struct buffer_reg_uid **regp)
1815 {
1816 int ret = 0;
1817 struct buffer_reg_uid *reg_uid;
1818
1819 assert(usess);
1820 assert(app);
1821
1822 rcu_read_lock();
1823
1824 reg_uid = buffer_reg_uid_find(usess->id, app->bits_per_long, app->uid);
1825 if (!reg_uid) {
1826 /*
1827 * This is the create channel path meaning that if there is NO
1828 * registry available, we have to create one for this session.
1829 */
1830 ret = buffer_reg_uid_create(usess->id, app->bits_per_long, app->uid,
1831 LTTNG_DOMAIN_UST, &reg_uid,
1832 ua_sess->root_shm_path, ua_sess->shm_path);
1833 if (ret < 0) {
1834 goto error;
1835 }
1836 } else {
1837 goto end;
1838 }
1839
1840 /* Initialize registry. */
1841 ret = ust_registry_session_init(&reg_uid->registry->reg.ust, NULL,
1842 app->bits_per_long, app->uint8_t_alignment,
1843 app->uint16_t_alignment, app->uint32_t_alignment,
1844 app->uint64_t_alignment, app->long_alignment,
1845 app->byte_order, app->version.major,
1846 app->version.minor, reg_uid->root_shm_path,
1847 reg_uid->shm_path, usess->uid, usess->gid);
1848 if (ret < 0) {
1849 /*
1850 * reg_uid->registry->reg.ust is NULL upon error, so we need to
1851 * destroy the buffer registry, because it is always expected
1852 * that if the buffer registry can be found, its ust registry is
1853 * non-NULL.
1854 */
1855 buffer_reg_uid_destroy(reg_uid, NULL);
1856 goto error;
1857 }
1858 /* Add node to teardown list of the session. */
1859 cds_list_add(&reg_uid->lnode, &usess->buffer_reg_uid_list);
1860
1861 buffer_reg_uid_add(reg_uid);
1862
1863 DBG3("UST app buffer registry per UID created successfully");
1864 end:
1865 if (regp) {
1866 *regp = reg_uid;
1867 }
1868 error:
1869 rcu_read_unlock();
1870 return ret;
1871 }
1872
1873 /*
1874 * Create a session on the tracer side for the given app.
1875 *
1876 * On success, ua_sess_ptr is populated with the session pointer or else left
1877 * untouched. If the session was created, is_created is set to 1. On error,
1878 * it's left untouched. Note that ua_sess_ptr is mandatory but is_created can
1879 * be NULL.
1880 *
1881 * Returns 0 on success or else a negative code which is either -ENOMEM or
1882 * -ENOTCONN which is the default code if the ustctl_create_session fails.
1883 */
1884 static int create_ust_app_session(struct ltt_ust_session *usess,
1885 struct ust_app *app, struct ust_app_session **ua_sess_ptr,
1886 int *is_created)
1887 {
1888 int ret, created = 0;
1889 struct ust_app_session *ua_sess;
1890
1891 assert(usess);
1892 assert(app);
1893 assert(ua_sess_ptr);
1894
1895 health_code_update();
1896
1897 ua_sess = lookup_session_by_app(usess, app);
1898 if (ua_sess == NULL) {
1899 DBG2("UST app pid: %d session id %" PRIu64 " not found, creating it",
1900 app->pid, usess->id);
1901 ua_sess = alloc_ust_app_session(app);
1902 if (ua_sess == NULL) {
1903 /* Only malloc can failed so something is really wrong */
1904 ret = -ENOMEM;
1905 goto error;
1906 }
1907 shadow_copy_session(ua_sess, usess, app);
1908 created = 1;
1909 }
1910
1911 switch (usess->buffer_type) {
1912 case LTTNG_BUFFER_PER_PID:
1913 /* Init local registry. */
1914 ret = setup_buffer_reg_pid(ua_sess, app, NULL);
1915 if (ret < 0) {
1916 delete_ust_app_session(-1, ua_sess, app);
1917 goto error;
1918 }
1919 break;
1920 case LTTNG_BUFFER_PER_UID:
1921 /* Look for a global registry. If none exists, create one. */
1922 ret = setup_buffer_reg_uid(usess, ua_sess, app, NULL);
1923 if (ret < 0) {
1924 delete_ust_app_session(-1, ua_sess, app);
1925 goto error;
1926 }
1927 break;
1928 default:
1929 assert(0);
1930 ret = -EINVAL;
1931 goto error;
1932 }
1933
1934 health_code_update();
1935
1936 if (ua_sess->handle == -1) {
1937 ret = ustctl_create_session(app->sock);
1938 if (ret < 0) {
1939 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
1940 ERR("Creating session for app pid %d with ret %d",
1941 app->pid, ret);
1942 } else {
1943 DBG("UST app creating session failed. Application is dead");
1944 /*
1945 * This is normal behavior, an application can die during the
1946 * creation process. Don't report an error so the execution can
1947 * continue normally. This will get flagged ENOTCONN and the
1948 * caller will handle it.
1949 */
1950 ret = 0;
1951 }
1952 delete_ust_app_session(-1, ua_sess, app);
1953 if (ret != -ENOMEM) {
1954 /*
1955 * Tracer is probably gone or got an internal error so let's
1956 * behave like it will soon unregister or not usable.
1957 */
1958 ret = -ENOTCONN;
1959 }
1960 goto error;
1961 }
1962
1963 ua_sess->handle = ret;
1964
1965 /* Add ust app session to app's HT */
1966 lttng_ht_node_init_u64(&ua_sess->node,
1967 ua_sess->tracing_id);
1968 lttng_ht_add_unique_u64(app->sessions, &ua_sess->node);
1969
1970 DBG2("UST app session created successfully with handle %d", ret);
1971 }
1972
1973 *ua_sess_ptr = ua_sess;
1974 if (is_created) {
1975 *is_created = created;
1976 }
1977
1978 /* Everything went well. */
1979 ret = 0;
1980
1981 error:
1982 health_code_update();
1983 return ret;
1984 }
1985
1986 /*
1987 * Match function for a hash table lookup of ust_app_ctx.
1988 *
1989 * It matches an ust app context based on the context type and, in the case
1990 * of perf counters, their name.
1991 */
1992 static int ht_match_ust_app_ctx(struct cds_lfht_node *node, const void *_key)
1993 {
1994 struct ust_app_ctx *ctx;
1995 const struct lttng_ust_context *key;
1996
1997 assert(node);
1998 assert(_key);
1999
2000 ctx = caa_container_of(node, struct ust_app_ctx, node.node);
2001 key = _key;
2002
2003 /* Context type */
2004 if (ctx->ctx.ctx != key->ctx) {
2005 goto no_match;
2006 }
2007
2008 /* Check the name in the case of perf thread counters. */
2009 if (key->ctx == LTTNG_UST_CONTEXT_PERF_THREAD_COUNTER) {
2010 if (strncmp(key->u.perf_counter.name,
2011 ctx->ctx.u.perf_counter.name,
2012 sizeof(key->u.perf_counter.name))) {
2013 goto no_match;
2014 }
2015 }
2016
2017 /* Match. */
2018 return 1;
2019
2020 no_match:
2021 return 0;
2022 }
2023
2024 /*
2025 * Lookup for an ust app context from an lttng_ust_context.
2026 *
2027 * Must be called while holding RCU read side lock.
2028 * Return an ust_app_ctx object or NULL on error.
2029 */
2030 static
2031 struct ust_app_ctx *find_ust_app_context(struct lttng_ht *ht,
2032 struct lttng_ust_context *uctx)
2033 {
2034 struct lttng_ht_iter iter;
2035 struct lttng_ht_node_ulong *node;
2036 struct ust_app_ctx *app_ctx = NULL;
2037
2038 assert(uctx);
2039 assert(ht);
2040
2041 /* Lookup using the lttng_ust_context_type and a custom match fct. */
2042 cds_lfht_lookup(ht->ht, ht->hash_fct((void *) uctx->ctx, lttng_ht_seed),
2043 ht_match_ust_app_ctx, uctx, &iter.iter);
2044 node = lttng_ht_iter_get_node_ulong(&iter);
2045 if (!node) {
2046 goto end;
2047 }
2048
2049 app_ctx = caa_container_of(node, struct ust_app_ctx, node);
2050
2051 end:
2052 return app_ctx;
2053 }
2054
2055 /*
2056 * Create a context for the channel on the tracer.
2057 *
2058 * Called with UST app session lock held and a RCU read side lock.
2059 */
2060 static
2061 int create_ust_app_channel_context(struct ust_app_session *ua_sess,
2062 struct ust_app_channel *ua_chan, struct lttng_ust_context *uctx,
2063 struct ust_app *app)
2064 {
2065 int ret = 0;
2066 struct ust_app_ctx *ua_ctx;
2067
2068 DBG2("UST app adding context to channel %s", ua_chan->name);
2069
2070 ua_ctx = find_ust_app_context(ua_chan->ctx, uctx);
2071 if (ua_ctx) {
2072 ret = -EEXIST;
2073 goto error;
2074 }
2075
2076 ua_ctx = alloc_ust_app_ctx(uctx);
2077 if (ua_ctx == NULL) {
2078 /* malloc failed */
2079 ret = -1;
2080 goto error;
2081 }
2082
2083 lttng_ht_node_init_ulong(&ua_ctx->node, (unsigned long) ua_ctx->ctx.ctx);
2084 lttng_ht_add_ulong(ua_chan->ctx, &ua_ctx->node);
2085 cds_list_add_tail(&ua_ctx->list, &ua_chan->ctx_list);
2086
2087 ret = create_ust_channel_context(ua_chan, ua_ctx, app);
2088 if (ret < 0) {
2089 goto error;
2090 }
2091
2092 error:
2093 return ret;
2094 }
2095
2096 /*
2097 * Enable on the tracer side a ust app event for the session and channel.
2098 *
2099 * Called with UST app session lock held.
2100 */
2101 static
2102 int enable_ust_app_event(struct ust_app_session *ua_sess,
2103 struct ust_app_event *ua_event, struct ust_app *app)
2104 {
2105 int ret;
2106
2107 ret = enable_ust_event(app, ua_sess, ua_event);
2108 if (ret < 0) {
2109 goto error;
2110 }
2111
2112 ua_event->enabled = 1;
2113
2114 error:
2115 return ret;
2116 }
2117
2118 /*
2119 * Disable on the tracer side a ust app event for the session and channel.
2120 */
2121 static int disable_ust_app_event(struct ust_app_session *ua_sess,
2122 struct ust_app_event *ua_event, struct ust_app *app)
2123 {
2124 int ret;
2125
2126 ret = disable_ust_event(app, ua_sess, ua_event);
2127 if (ret < 0) {
2128 goto error;
2129 }
2130
2131 ua_event->enabled = 0;
2132
2133 error:
2134 return ret;
2135 }
2136
2137 /*
2138 * Lookup ust app channel for session and disable it on the tracer side.
2139 */
2140 static
2141 int disable_ust_app_channel(struct ust_app_session *ua_sess,
2142 struct ust_app_channel *ua_chan, struct ust_app *app)
2143 {
2144 int ret;
2145
2146 ret = disable_ust_channel(app, ua_sess, ua_chan);
2147 if (ret < 0) {
2148 goto error;
2149 }
2150
2151 ua_chan->enabled = 0;
2152
2153 error:
2154 return ret;
2155 }
2156
2157 /*
2158 * Lookup ust app channel for session and enable it on the tracer side. This
2159 * MUST be called with a RCU read side lock acquired.
2160 */
2161 static int enable_ust_app_channel(struct ust_app_session *ua_sess,
2162 struct ltt_ust_channel *uchan, struct ust_app *app)
2163 {
2164 int ret = 0;
2165 struct lttng_ht_iter iter;
2166 struct lttng_ht_node_str *ua_chan_node;
2167 struct ust_app_channel *ua_chan;
2168
2169 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &iter);
2170 ua_chan_node = lttng_ht_iter_get_node_str(&iter);
2171 if (ua_chan_node == NULL) {
2172 DBG2("Unable to find channel %s in ust session id %" PRIu64,
2173 uchan->name, ua_sess->tracing_id);
2174 goto error;
2175 }
2176
2177 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
2178
2179 ret = enable_ust_channel(app, ua_sess, ua_chan);
2180 if (ret < 0) {
2181 goto error;
2182 }
2183
2184 error:
2185 return ret;
2186 }
2187
2188 /*
2189 * Ask the consumer to create a channel and get it if successful.
2190 *
2191 * Return 0 on success or else a negative value.
2192 */
2193 static int do_consumer_create_channel(struct ltt_ust_session *usess,
2194 struct ust_app_session *ua_sess, struct ust_app_channel *ua_chan,
2195 int bitness, struct ust_registry_session *registry)
2196 {
2197 int ret;
2198 unsigned int nb_fd = 0;
2199 struct consumer_socket *socket;
2200
2201 assert(usess);
2202 assert(ua_sess);
2203 assert(ua_chan);
2204 assert(registry);
2205
2206 rcu_read_lock();
2207 health_code_update();
2208
2209 /* Get the right consumer socket for the application. */
2210 socket = consumer_find_socket_by_bitness(bitness, usess->consumer);
2211 if (!socket) {
2212 ret = -EINVAL;
2213 goto error;
2214 }
2215
2216 health_code_update();
2217
2218 /* Need one fd for the channel. */
2219 ret = lttng_fd_get(LTTNG_FD_APPS, 1);
2220 if (ret < 0) {
2221 ERR("Exhausted number of available FD upon create channel");
2222 goto error;
2223 }
2224
2225 /*
2226 * Ask consumer to create channel. The consumer will return the number of
2227 * stream we have to expect.
2228 */
2229 ret = ust_consumer_ask_channel(ua_sess, ua_chan, usess->consumer, socket,
2230 registry);
2231 if (ret < 0) {
2232 goto error_ask;
2233 }
2234
2235 /*
2236 * Compute the number of fd needed before receiving them. It must be 2 per
2237 * stream (2 being the default value here).
2238 */
2239 nb_fd = DEFAULT_UST_STREAM_FD_NUM * ua_chan->expected_stream_count;
2240
2241 /* Reserve the amount of file descriptor we need. */
2242 ret = lttng_fd_get(LTTNG_FD_APPS, nb_fd);
2243 if (ret < 0) {
2244 ERR("Exhausted number of available FD upon create channel");
2245 goto error_fd_get_stream;
2246 }
2247
2248 health_code_update();
2249
2250 /*
2251 * Now get the channel from the consumer. This call wil populate the stream
2252 * list of that channel and set the ust objects.
2253 */
2254 if (usess->consumer->enabled) {
2255 ret = ust_consumer_get_channel(socket, ua_chan);
2256 if (ret < 0) {
2257 goto error_destroy;
2258 }
2259 }
2260
2261 rcu_read_unlock();
2262 return 0;
2263
2264 error_destroy:
2265 lttng_fd_put(LTTNG_FD_APPS, nb_fd);
2266 error_fd_get_stream:
2267 /*
2268 * Initiate a destroy channel on the consumer since we had an error
2269 * handling it on our side. The return value is of no importance since we
2270 * already have a ret value set by the previous error that we need to
2271 * return.
2272 */
2273 (void) ust_consumer_destroy_channel(socket, ua_chan);
2274 error_ask:
2275 lttng_fd_put(LTTNG_FD_APPS, 1);
2276 error:
2277 health_code_update();
2278 rcu_read_unlock();
2279 return ret;
2280 }
2281
2282 /*
2283 * Duplicate the ust data object of the ust app stream and save it in the
2284 * buffer registry stream.
2285 *
2286 * Return 0 on success or else a negative value.
2287 */
2288 static int duplicate_stream_object(struct buffer_reg_stream *reg_stream,
2289 struct ust_app_stream *stream)
2290 {
2291 int ret;
2292
2293 assert(reg_stream);
2294 assert(stream);
2295
2296 /* Reserve the amount of file descriptor we need. */
2297 ret = lttng_fd_get(LTTNG_FD_APPS, 2);
2298 if (ret < 0) {
2299 ERR("Exhausted number of available FD upon duplicate stream");
2300 goto error;
2301 }
2302
2303 /* Duplicate object for stream once the original is in the registry. */
2304 ret = ustctl_duplicate_ust_object_data(&stream->obj,
2305 reg_stream->obj.ust);
2306 if (ret < 0) {
2307 ERR("Duplicate stream obj from %p to %p failed with ret %d",
2308 reg_stream->obj.ust, stream->obj, ret);
2309 lttng_fd_put(LTTNG_FD_APPS, 2);
2310 goto error;
2311 }
2312 stream->handle = stream->obj->handle;
2313
2314 error:
2315 return ret;
2316 }
2317
2318 /*
2319 * Duplicate the ust data object of the ust app. channel and save it in the
2320 * buffer registry channel.
2321 *
2322 * Return 0 on success or else a negative value.
2323 */
2324 static int duplicate_channel_object(struct buffer_reg_channel *reg_chan,
2325 struct ust_app_channel *ua_chan)
2326 {
2327 int ret;
2328
2329 assert(reg_chan);
2330 assert(ua_chan);
2331
2332 /* Need two fds for the channel. */
2333 ret = lttng_fd_get(LTTNG_FD_APPS, 1);
2334 if (ret < 0) {
2335 ERR("Exhausted number of available FD upon duplicate channel");
2336 goto error_fd_get;
2337 }
2338
2339 /* Duplicate object for stream once the original is in the registry. */
2340 ret = ustctl_duplicate_ust_object_data(&ua_chan->obj, reg_chan->obj.ust);
2341 if (ret < 0) {
2342 ERR("Duplicate channel obj from %p to %p failed with ret: %d",
2343 reg_chan->obj.ust, ua_chan->obj, ret);
2344 goto error;
2345 }
2346 ua_chan->handle = ua_chan->obj->handle;
2347
2348 return 0;
2349
2350 error:
2351 lttng_fd_put(LTTNG_FD_APPS, 1);
2352 error_fd_get:
2353 return ret;
2354 }
2355
2356 /*
2357 * For a given channel buffer registry, setup all streams of the given ust
2358 * application channel.
2359 *
2360 * Return 0 on success or else a negative value.
2361 */
2362 static int setup_buffer_reg_streams(struct buffer_reg_channel *reg_chan,
2363 struct ust_app_channel *ua_chan)
2364 {
2365 int ret = 0;
2366 struct ust_app_stream *stream, *stmp;
2367
2368 assert(reg_chan);
2369 assert(ua_chan);
2370
2371 DBG2("UST app setup buffer registry stream");
2372
2373 /* Send all streams to application. */
2374 cds_list_for_each_entry_safe(stream, stmp, &ua_chan->streams.head, list) {
2375 struct buffer_reg_stream *reg_stream;
2376
2377 ret = buffer_reg_stream_create(&reg_stream);
2378 if (ret < 0) {
2379 goto error;
2380 }
2381
2382 /*
2383 * Keep original pointer and nullify it in the stream so the delete
2384 * stream call does not release the object.
2385 */
2386 reg_stream->obj.ust = stream->obj;
2387 stream->obj = NULL;
2388 buffer_reg_stream_add(reg_stream, reg_chan);
2389
2390 /* We don't need the streams anymore. */
2391 cds_list_del(&stream->list);
2392 delete_ust_app_stream(-1, stream);
2393 }
2394
2395 error:
2396 return ret;
2397 }
2398
2399 /*
2400 * Create a buffer registry channel for the given session registry and
2401 * application channel object. If regp pointer is valid, it's set with the
2402 * created object. Important, the created object is NOT added to the session
2403 * registry hash table.
2404 *
2405 * Return 0 on success else a negative value.
2406 */
2407 static int create_buffer_reg_channel(struct buffer_reg_session *reg_sess,
2408 struct ust_app_channel *ua_chan, struct buffer_reg_channel **regp)
2409 {
2410 int ret;
2411 struct buffer_reg_channel *reg_chan = NULL;
2412
2413 assert(reg_sess);
2414 assert(ua_chan);
2415
2416 DBG2("UST app creating buffer registry channel for %s", ua_chan->name);
2417
2418 /* Create buffer registry channel. */
2419 ret = buffer_reg_channel_create(ua_chan->tracing_channel_id, &reg_chan);
2420 if (ret < 0) {
2421 goto error_create;
2422 }
2423 assert(reg_chan);
2424 reg_chan->consumer_key = ua_chan->key;
2425 reg_chan->subbuf_size = ua_chan->attr.subbuf_size;
2426 reg_chan->num_subbuf = ua_chan->attr.num_subbuf;
2427
2428 /* Create and add a channel registry to session. */
2429 ret = ust_registry_channel_add(reg_sess->reg.ust,
2430 ua_chan->tracing_channel_id);
2431 if (ret < 0) {
2432 goto error;
2433 }
2434 buffer_reg_channel_add(reg_sess, reg_chan);
2435
2436 if (regp) {
2437 *regp = reg_chan;
2438 }
2439
2440 return 0;
2441
2442 error:
2443 /* Safe because the registry channel object was not added to any HT. */
2444 buffer_reg_channel_destroy(reg_chan, LTTNG_DOMAIN_UST);
2445 error_create:
2446 return ret;
2447 }
2448
2449 /*
2450 * Setup buffer registry channel for the given session registry and application
2451 * channel object. If regp pointer is valid, it's set with the created object.
2452 *
2453 * Return 0 on success else a negative value.
2454 */
2455 static int setup_buffer_reg_channel(struct buffer_reg_session *reg_sess,
2456 struct ust_app_channel *ua_chan, struct buffer_reg_channel *reg_chan)
2457 {
2458 int ret;
2459
2460 assert(reg_sess);
2461 assert(reg_chan);
2462 assert(ua_chan);
2463 assert(ua_chan->obj);
2464
2465 DBG2("UST app setup buffer registry channel for %s", ua_chan->name);
2466
2467 /* Setup all streams for the registry. */
2468 ret = setup_buffer_reg_streams(reg_chan, ua_chan);
2469 if (ret < 0) {
2470 goto error;
2471 }
2472
2473 reg_chan->obj.ust = ua_chan->obj;
2474 ua_chan->obj = NULL;
2475
2476 return 0;
2477
2478 error:
2479 buffer_reg_channel_remove(reg_sess, reg_chan);
2480 buffer_reg_channel_destroy(reg_chan, LTTNG_DOMAIN_UST);
2481 return ret;
2482 }
2483
2484 /*
2485 * Send buffer registry channel to the application.
2486 *
2487 * Return 0 on success else a negative value.
2488 */
2489 static int send_channel_uid_to_ust(struct buffer_reg_channel *reg_chan,
2490 struct ust_app *app, struct ust_app_session *ua_sess,
2491 struct ust_app_channel *ua_chan)
2492 {
2493 int ret;
2494 struct buffer_reg_stream *reg_stream;
2495
2496 assert(reg_chan);
2497 assert(app);
2498 assert(ua_sess);
2499 assert(ua_chan);
2500
2501 DBG("UST app sending buffer registry channel to ust sock %d", app->sock);
2502
2503 ret = duplicate_channel_object(reg_chan, ua_chan);
2504 if (ret < 0) {
2505 goto error;
2506 }
2507
2508 /* Send channel to the application. */
2509 ret = ust_consumer_send_channel_to_ust(app, ua_sess, ua_chan);
2510 if (ret < 0) {
2511 goto error;
2512 }
2513
2514 health_code_update();
2515
2516 /* Send all streams to application. */
2517 pthread_mutex_lock(&reg_chan->stream_list_lock);
2518 cds_list_for_each_entry(reg_stream, &reg_chan->streams, lnode) {
2519 struct ust_app_stream stream;
2520
2521 ret = duplicate_stream_object(reg_stream, &stream);
2522 if (ret < 0) {
2523 goto error_stream_unlock;
2524 }
2525
2526 ret = ust_consumer_send_stream_to_ust(app, ua_chan, &stream);
2527 if (ret < 0) {
2528 (void) release_ust_app_stream(-1, &stream);
2529 goto error_stream_unlock;
2530 }
2531
2532 /*
2533 * The return value is not important here. This function will output an
2534 * error if needed.
2535 */
2536 (void) release_ust_app_stream(-1, &stream);
2537 }
2538 ua_chan->is_sent = 1;
2539
2540 error_stream_unlock:
2541 pthread_mutex_unlock(&reg_chan->stream_list_lock);
2542 error:
2543 return ret;
2544 }
2545
2546 /*
2547 * Create and send to the application the created buffers with per UID buffers.
2548 *
2549 * Return 0 on success else a negative value.
2550 */
2551 static int create_channel_per_uid(struct ust_app *app,
2552 struct ltt_ust_session *usess, struct ust_app_session *ua_sess,
2553 struct ust_app_channel *ua_chan)
2554 {
2555 int ret;
2556 struct buffer_reg_uid *reg_uid;
2557 struct buffer_reg_channel *reg_chan;
2558
2559 assert(app);
2560 assert(usess);
2561 assert(ua_sess);
2562 assert(ua_chan);
2563
2564 DBG("UST app creating channel %s with per UID buffers", ua_chan->name);
2565
2566 reg_uid = buffer_reg_uid_find(usess->id, app->bits_per_long, app->uid);
2567 /*
2568 * The session creation handles the creation of this global registry
2569 * object. If none can be find, there is a code flow problem or a
2570 * teardown race.
2571 */
2572 assert(reg_uid);
2573
2574 reg_chan = buffer_reg_channel_find(ua_chan->tracing_channel_id,
2575 reg_uid);
2576 if (!reg_chan) {
2577 /* Create the buffer registry channel object. */
2578 ret = create_buffer_reg_channel(reg_uid->registry, ua_chan, &reg_chan);
2579 if (ret < 0) {
2580 ERR("Error creating the UST channel \"%s\" registry instance",
2581 ua_chan->name);
2582 goto error;
2583 }
2584 assert(reg_chan);
2585
2586 /*
2587 * Create the buffers on the consumer side. This call populates the
2588 * ust app channel object with all streams and data object.
2589 */
2590 ret = do_consumer_create_channel(usess, ua_sess, ua_chan,
2591 app->bits_per_long, reg_uid->registry->reg.ust);
2592 if (ret < 0) {
2593 ERR("Error creating UST channel \"%s\" on the consumer daemon",
2594 ua_chan->name);
2595
2596 /*
2597 * Let's remove the previously created buffer registry channel so
2598 * it's not visible anymore in the session registry.
2599 */
2600 ust_registry_channel_del_free(reg_uid->registry->reg.ust,
2601 ua_chan->tracing_channel_id);
2602 buffer_reg_channel_remove(reg_uid->registry, reg_chan);
2603 buffer_reg_channel_destroy(reg_chan, LTTNG_DOMAIN_UST);
2604 goto error;
2605 }
2606
2607 /*
2608 * Setup the streams and add it to the session registry.
2609 */
2610 ret = setup_buffer_reg_channel(reg_uid->registry, ua_chan, reg_chan);
2611 if (ret < 0) {
2612 ERR("Error setting up UST channel \"%s\"",
2613 ua_chan->name);
2614 goto error;
2615 }
2616
2617 }
2618
2619 /* Send buffers to the application. */
2620 ret = send_channel_uid_to_ust(reg_chan, app, ua_sess, ua_chan);
2621 if (ret < 0) {
2622 /*
2623 * Don't report error to the console, since it may be
2624 * caused by application concurrently exiting.
2625 */
2626 goto error;
2627 }
2628
2629 error:
2630 return ret;
2631 }
2632
2633 /*
2634 * Create and send to the application the created buffers with per PID buffers.
2635 *
2636 * Return 0 on success else a negative value.
2637 */
2638 static int create_channel_per_pid(struct ust_app *app,
2639 struct ltt_ust_session *usess, struct ust_app_session *ua_sess,
2640 struct ust_app_channel *ua_chan)
2641 {
2642 int ret;
2643 struct ust_registry_session *registry;
2644
2645 assert(app);
2646 assert(usess);
2647 assert(ua_sess);
2648 assert(ua_chan);
2649
2650 DBG("UST app creating channel %s with per PID buffers", ua_chan->name);
2651
2652 rcu_read_lock();
2653
2654 registry = get_session_registry(ua_sess);
2655 assert(registry);
2656
2657 /* Create and add a new channel registry to session. */
2658 ret = ust_registry_channel_add(registry, ua_chan->key);
2659 if (ret < 0) {
2660 ERR("Error creating the UST channel \"%s\" registry instance",
2661 ua_chan->name);
2662 goto error;
2663 }
2664
2665 /* Create and get channel on the consumer side. */
2666 ret = do_consumer_create_channel(usess, ua_sess, ua_chan,
2667 app->bits_per_long, registry);
2668 if (ret < 0) {
2669 ERR("Error creating UST channel \"%s\" on the consumer daemon",
2670 ua_chan->name);
2671 goto error;
2672 }
2673
2674 ret = send_channel_pid_to_ust(app, ua_sess, ua_chan);
2675 if (ret < 0) {
2676 /*
2677 * Don't report error to the console, since it may be
2678 * caused by application concurrently exiting.
2679 */
2680 goto error;
2681 }
2682
2683 error:
2684 rcu_read_unlock();
2685 return ret;
2686 }
2687
2688 /*
2689 * From an already allocated ust app channel, create the channel buffers if
2690 * need and send it to the application. This MUST be called with a RCU read
2691 * side lock acquired.
2692 *
2693 * Return 0 on success or else a negative value.
2694 */
2695 static int do_create_channel(struct ust_app *app,
2696 struct ltt_ust_session *usess, struct ust_app_session *ua_sess,
2697 struct ust_app_channel *ua_chan)
2698 {
2699 int ret;
2700
2701 assert(app);
2702 assert(usess);
2703 assert(ua_sess);
2704 assert(ua_chan);
2705
2706 /* Handle buffer type before sending the channel to the application. */
2707 switch (usess->buffer_type) {
2708 case LTTNG_BUFFER_PER_UID:
2709 {
2710 ret = create_channel_per_uid(app, usess, ua_sess, ua_chan);
2711 if (ret < 0) {
2712 goto error;
2713 }
2714 break;
2715 }
2716 case LTTNG_BUFFER_PER_PID:
2717 {
2718 ret = create_channel_per_pid(app, usess, ua_sess, ua_chan);
2719 if (ret < 0) {
2720 goto error;
2721 }
2722 break;
2723 }
2724 default:
2725 assert(0);
2726 ret = -EINVAL;
2727 goto error;
2728 }
2729
2730 /* Initialize ust objd object using the received handle and add it. */
2731 lttng_ht_node_init_ulong(&ua_chan->ust_objd_node, ua_chan->handle);
2732 lttng_ht_add_unique_ulong(app->ust_objd, &ua_chan->ust_objd_node);
2733
2734 /* If channel is not enabled, disable it on the tracer */
2735 if (!ua_chan->enabled) {
2736 ret = disable_ust_channel(app, ua_sess, ua_chan);
2737 if (ret < 0) {
2738 goto error;
2739 }
2740 }
2741
2742 error:
2743 return ret;
2744 }
2745
2746 /*
2747 * Create UST app channel and create it on the tracer. Set ua_chanp of the
2748 * newly created channel if not NULL.
2749 *
2750 * Called with UST app session lock and RCU read-side lock held.
2751 *
2752 * Return 0 on success or else a negative value.
2753 */
2754 static int create_ust_app_channel(struct ust_app_session *ua_sess,
2755 struct ltt_ust_channel *uchan, struct ust_app *app,
2756 enum lttng_ust_chan_type type, struct ltt_ust_session *usess,
2757 struct ust_app_channel **ua_chanp)
2758 {
2759 int ret = 0;
2760 struct lttng_ht_iter iter;
2761 struct lttng_ht_node_str *ua_chan_node;
2762 struct ust_app_channel *ua_chan;
2763
2764 /* Lookup channel in the ust app session */
2765 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &iter);
2766 ua_chan_node = lttng_ht_iter_get_node_str(&iter);
2767 if (ua_chan_node != NULL) {
2768 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
2769 goto end;
2770 }
2771
2772 ua_chan = alloc_ust_app_channel(uchan->name, ua_sess, &uchan->attr);
2773 if (ua_chan == NULL) {
2774 /* Only malloc can fail here */
2775 ret = -ENOMEM;
2776 goto error_alloc;
2777 }
2778 shadow_copy_channel(ua_chan, uchan);
2779
2780 /* Set channel type. */
2781 ua_chan->attr.type = type;
2782
2783 ret = do_create_channel(app, usess, ua_sess, ua_chan);
2784 if (ret < 0) {
2785 goto error;
2786 }
2787
2788 DBG2("UST app create channel %s for PID %d completed", ua_chan->name,
2789 app->pid);
2790
2791 /* Only add the channel if successful on the tracer side. */
2792 lttng_ht_add_unique_str(ua_sess->channels, &ua_chan->node);
2793
2794 end:
2795 if (ua_chanp) {
2796 *ua_chanp = ua_chan;
2797 }
2798
2799 /* Everything went well. */
2800 return 0;
2801
2802 error:
2803 delete_ust_app_channel(ua_chan->is_sent ? app->sock : -1, ua_chan, app);
2804 error_alloc:
2805 return ret;
2806 }
2807
2808 /*
2809 * Create UST app event and create it on the tracer side.
2810 *
2811 * Called with ust app session mutex held.
2812 */
2813 static
2814 int create_ust_app_event(struct ust_app_session *ua_sess,
2815 struct ust_app_channel *ua_chan, struct ltt_ust_event *uevent,
2816 struct ust_app *app)
2817 {
2818 int ret = 0;
2819 struct ust_app_event *ua_event;
2820
2821 /* Get event node */
2822 ua_event = find_ust_app_event(ua_chan->events, uevent->attr.name,
2823 uevent->filter, uevent->attr.loglevel, uevent->exclusion);
2824 if (ua_event != NULL) {
2825 ret = -EEXIST;
2826 goto end;
2827 }
2828
2829 /* Does not exist so create one */
2830 ua_event = alloc_ust_app_event(uevent->attr.name, &uevent->attr);
2831 if (ua_event == NULL) {
2832 /* Only malloc can failed so something is really wrong */
2833 ret = -ENOMEM;
2834 goto end;
2835 }
2836 shadow_copy_event(ua_event, uevent);
2837
2838 /* Create it on the tracer side */
2839 ret = create_ust_event(app, ua_sess, ua_chan, ua_event);
2840 if (ret < 0) {
2841 /* Not found previously means that it does not exist on the tracer */
2842 assert(ret != -LTTNG_UST_ERR_EXIST);
2843 goto error;
2844 }
2845
2846 add_unique_ust_app_event(ua_chan, ua_event);
2847
2848 DBG2("UST app create event %s for PID %d completed", ua_event->name,
2849 app->pid);
2850
2851 end:
2852 return ret;
2853
2854 error:
2855 /* Valid. Calling here is already in a read side lock */
2856 delete_ust_app_event(-1, ua_event);
2857 return ret;
2858 }
2859
2860 /*
2861 * Create UST metadata and open it on the tracer side.
2862 *
2863 * Called with UST app session lock held and RCU read side lock.
2864 */
2865 static int create_ust_app_metadata(struct ust_app_session *ua_sess,
2866 struct ust_app *app, struct consumer_output *consumer)
2867 {
2868 int ret = 0;
2869 struct ust_app_channel *metadata;
2870 struct consumer_socket *socket;
2871 struct ust_registry_session *registry;
2872
2873 assert(ua_sess);
2874 assert(app);
2875 assert(consumer);
2876
2877 registry = get_session_registry(ua_sess);
2878 assert(registry);
2879
2880 pthread_mutex_lock(&registry->lock);
2881
2882 /* Metadata already exists for this registry or it was closed previously */
2883 if (registry->metadata_key || registry->metadata_closed) {
2884 ret = 0;
2885 goto error;
2886 }
2887
2888 /* Allocate UST metadata */
2889 metadata = alloc_ust_app_channel(DEFAULT_METADATA_NAME, ua_sess, NULL);
2890 if (!metadata) {
2891 /* malloc() failed */
2892 ret = -ENOMEM;
2893 goto error;
2894 }
2895
2896 memcpy(&metadata->attr, &ua_sess->metadata_attr, sizeof(metadata->attr));
2897
2898 /* Need one fd for the channel. */
2899 ret = lttng_fd_get(LTTNG_FD_APPS, 1);
2900 if (ret < 0) {
2901 ERR("Exhausted number of available FD upon create metadata");
2902 goto error;
2903 }
2904
2905 /* Get the right consumer socket for the application. */
2906 socket = consumer_find_socket_by_bitness(app->bits_per_long, consumer);
2907 if (!socket) {
2908 ret = -EINVAL;
2909 goto error_consumer;
2910 }
2911
2912 /*
2913 * Keep metadata key so we can identify it on the consumer side. Assign it
2914 * to the registry *before* we ask the consumer so we avoid the race of the
2915 * consumer requesting the metadata and the ask_channel call on our side
2916 * did not returned yet.
2917 */
2918 registry->metadata_key = metadata->key;
2919
2920 /*
2921 * Ask the metadata channel creation to the consumer. The metadata object
2922 * will be created by the consumer and kept their. However, the stream is
2923 * never added or monitored until we do a first push metadata to the
2924 * consumer.
2925 */
2926 ret = ust_consumer_ask_channel(ua_sess, metadata, consumer, socket,
2927 registry);
2928 if (ret < 0) {
2929 /* Nullify the metadata key so we don't try to close it later on. */
2930 registry->metadata_key = 0;
2931 goto error_consumer;
2932 }
2933
2934 /*
2935 * The setup command will make the metadata stream be sent to the relayd,
2936 * if applicable, and the thread managing the metadatas. This is important
2937 * because after this point, if an error occurs, the only way the stream
2938 * can be deleted is to be monitored in the consumer.
2939 */
2940 ret = consumer_setup_metadata(socket, metadata->key);
2941 if (ret < 0) {
2942 /* Nullify the metadata key so we don't try to close it later on. */
2943 registry->metadata_key = 0;
2944 goto error_consumer;
2945 }
2946
2947 DBG2("UST metadata with key %" PRIu64 " created for app pid %d",
2948 metadata->key, app->pid);
2949
2950 error_consumer:
2951 lttng_fd_put(LTTNG_FD_APPS, 1);
2952 delete_ust_app_channel(-1, metadata, app);
2953 error:
2954 pthread_mutex_unlock(&registry->lock);
2955 return ret;
2956 }
2957
2958 /*
2959 * Return ust app pointer or NULL if not found. RCU read side lock MUST be
2960 * acquired before calling this function.
2961 */
2962 struct ust_app *ust_app_find_by_pid(pid_t pid)
2963 {
2964 struct ust_app *app = NULL;
2965 struct lttng_ht_node_ulong *node;
2966 struct lttng_ht_iter iter;
2967
2968 lttng_ht_lookup(ust_app_ht, (void *)((unsigned long) pid), &iter);
2969 node = lttng_ht_iter_get_node_ulong(&iter);
2970 if (node == NULL) {
2971 DBG2("UST app no found with pid %d", pid);
2972 goto error;
2973 }
2974
2975 DBG2("Found UST app by pid %d", pid);
2976
2977 app = caa_container_of(node, struct ust_app, pid_n);
2978
2979 error:
2980 return app;
2981 }
2982
2983 /*
2984 * Allocate and init an UST app object using the registration information and
2985 * the command socket. This is called when the command socket connects to the
2986 * session daemon.
2987 *
2988 * The object is returned on success or else NULL.
2989 */
2990 struct ust_app *ust_app_create(struct ust_register_msg *msg, int sock)
2991 {
2992 struct ust_app *lta = NULL;
2993
2994 assert(msg);
2995 assert(sock >= 0);
2996
2997 DBG3("UST app creating application for socket %d", sock);
2998
2999 if ((msg->bits_per_long == 64 &&
3000 (uatomic_read(&ust_consumerd64_fd) == -EINVAL))
3001 || (msg->bits_per_long == 32 &&
3002 (uatomic_read(&ust_consumerd32_fd) == -EINVAL))) {
3003 ERR("Registration failed: application \"%s\" (pid: %d) has "
3004 "%d-bit long, but no consumerd for this size is available.\n",
3005 msg->name, msg->pid, msg->bits_per_long);
3006 goto error;
3007 }
3008
3009 lta = zmalloc(sizeof(struct ust_app));
3010 if (lta == NULL) {
3011 PERROR("malloc");
3012 goto error;
3013 }
3014
3015 lta->ppid = msg->ppid;
3016 lta->uid = msg->uid;
3017 lta->gid = msg->gid;
3018
3019 lta->bits_per_long = msg->bits_per_long;
3020 lta->uint8_t_alignment = msg->uint8_t_alignment;
3021 lta->uint16_t_alignment = msg->uint16_t_alignment;
3022 lta->uint32_t_alignment = msg->uint32_t_alignment;
3023 lta->uint64_t_alignment = msg->uint64_t_alignment;
3024 lta->long_alignment = msg->long_alignment;
3025 lta->byte_order = msg->byte_order;
3026
3027 lta->v_major = msg->major;
3028 lta->v_minor = msg->minor;
3029 lta->sessions = lttng_ht_new(0, LTTNG_HT_TYPE_U64);
3030 lta->ust_objd = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG);
3031 lta->notify_sock = -1;
3032
3033 /* Copy name and make sure it's NULL terminated. */
3034 strncpy(lta->name, msg->name, sizeof(lta->name));
3035 lta->name[UST_APP_PROCNAME_LEN] = '\0';
3036
3037 /*
3038 * Before this can be called, when receiving the registration information,
3039 * the application compatibility is checked. So, at this point, the
3040 * application can work with this session daemon.
3041 */
3042 lta->compatible = 1;
3043
3044 lta->pid = msg->pid;
3045 lttng_ht_node_init_ulong(&lta->pid_n, (unsigned long) lta->pid);
3046 lta->sock = sock;
3047 lttng_ht_node_init_ulong(&lta->sock_n, (unsigned long) lta->sock);
3048
3049 CDS_INIT_LIST_HEAD(&lta->teardown_head);
3050
3051 error:
3052 return lta;
3053 }
3054
3055 /*
3056 * For a given application object, add it to every hash table.
3057 */
3058 void ust_app_add(struct ust_app *app)
3059 {
3060 assert(app);
3061 assert(app->notify_sock >= 0);
3062
3063 rcu_read_lock();
3064
3065 /*
3066 * On a re-registration, we want to kick out the previous registration of
3067 * that pid
3068 */
3069 lttng_ht_add_replace_ulong(ust_app_ht, &app->pid_n);
3070
3071 /*
3072 * The socket _should_ be unique until _we_ call close. So, a add_unique
3073 * for the ust_app_ht_by_sock is used which asserts fail if the entry was
3074 * already in the table.
3075 */
3076 lttng_ht_add_unique_ulong(ust_app_ht_by_sock, &app->sock_n);
3077
3078 /* Add application to the notify socket hash table. */
3079 lttng_ht_node_init_ulong(&app->notify_sock_n, app->notify_sock);
3080 lttng_ht_add_unique_ulong(ust_app_ht_by_notify_sock, &app->notify_sock_n);
3081
3082 DBG("App registered with pid:%d ppid:%d uid:%d gid:%d sock:%d name:%s "
3083 "notify_sock:%d (version %d.%d)", app->pid, app->ppid, app->uid,
3084 app->gid, app->sock, app->name, app->notify_sock, app->v_major,
3085 app->v_minor);
3086
3087 rcu_read_unlock();
3088 }
3089
3090 /*
3091 * Set the application version into the object.
3092 *
3093 * Return 0 on success else a negative value either an errno code or a
3094 * LTTng-UST error code.
3095 */
3096 int ust_app_version(struct ust_app *app)
3097 {
3098 int ret;
3099
3100 assert(app);
3101
3102 ret = ustctl_tracer_version(app->sock, &app->version);
3103 if (ret < 0) {
3104 if (ret != -LTTNG_UST_ERR_EXITING && ret != -EPIPE) {
3105 ERR("UST app %d version failed with ret %d", app->sock, ret);
3106 } else {
3107 DBG3("UST app %d version failed. Application is dead", app->sock);
3108 }
3109 }
3110
3111 return ret;
3112 }
3113
3114 /*
3115 * Unregister app by removing it from the global traceable app list and freeing
3116 * the data struct.
3117 *
3118 * The socket is already closed at this point so no close to sock.
3119 */
3120 void ust_app_unregister(int sock)
3121 {
3122 struct ust_app *lta;
3123 struct lttng_ht_node_ulong *node;
3124 struct lttng_ht_iter ust_app_sock_iter;
3125 struct lttng_ht_iter iter;
3126 struct ust_app_session *ua_sess;
3127 int ret;
3128
3129 rcu_read_lock();
3130
3131 /* Get the node reference for a call_rcu */
3132 lttng_ht_lookup(ust_app_ht_by_sock, (void *)((unsigned long) sock), &ust_app_sock_iter);
3133 node = lttng_ht_iter_get_node_ulong(&ust_app_sock_iter);
3134 assert(node);
3135
3136 lta = caa_container_of(node, struct ust_app, sock_n);
3137 DBG("PID %d unregistering with sock %d", lta->pid, sock);
3138
3139 /*
3140 * For per-PID buffers, perform "push metadata" and flush all
3141 * application streams before removing app from hash tables,
3142 * ensuring proper behavior of data_pending check.
3143 * Remove sessions so they are not visible during deletion.
3144 */
3145 cds_lfht_for_each_entry(lta->sessions->ht, &iter.iter, ua_sess,
3146 node.node) {
3147 struct ust_registry_session *registry;
3148
3149 ret = lttng_ht_del(lta->sessions, &iter);
3150 if (ret) {
3151 /* The session was already removed so scheduled for teardown. */
3152 continue;
3153 }
3154
3155 if (ua_sess->buffer_type == LTTNG_BUFFER_PER_PID) {
3156 (void) ust_app_flush_app_session(lta, ua_sess);
3157 }
3158
3159 /*
3160 * Add session to list for teardown. This is safe since at this point we
3161 * are the only one using this list.
3162 */
3163 pthread_mutex_lock(&ua_sess->lock);
3164
3165 /*
3166 * Normally, this is done in the delete session process which is
3167 * executed in the call rcu below. However, upon registration we can't
3168 * afford to wait for the grace period before pushing data or else the
3169 * data pending feature can race between the unregistration and stop
3170 * command where the data pending command is sent *before* the grace
3171 * period ended.
3172 *
3173 * The close metadata below nullifies the metadata pointer in the
3174 * session so the delete session will NOT push/close a second time.
3175 */
3176 registry = get_session_registry(ua_sess);
3177 if (registry) {
3178 /* Push metadata for application before freeing the application. */
3179 (void) push_metadata(registry, ua_sess->consumer);
3180
3181 /*
3182 * Don't ask to close metadata for global per UID buffers. Close
3183 * metadata only on destroy trace session in this case. Also, the
3184 * previous push metadata could have flag the metadata registry to
3185 * close so don't send a close command if closed.
3186 */
3187 if (ua_sess->buffer_type != LTTNG_BUFFER_PER_UID) {
3188 /* And ask to close it for this session registry. */
3189 (void) close_metadata(registry, ua_sess->consumer);
3190 }
3191 }
3192 cds_list_add(&ua_sess->teardown_node, &lta->teardown_head);
3193
3194 pthread_mutex_unlock(&ua_sess->lock);
3195 }
3196
3197 /* Remove application from PID hash table */
3198 ret = lttng_ht_del(ust_app_ht_by_sock, &ust_app_sock_iter);
3199 assert(!ret);
3200
3201 /*
3202 * Remove application from notify hash table. The thread handling the
3203 * notify socket could have deleted the node so ignore on error because
3204 * either way it's valid. The close of that socket is handled by the other
3205 * thread.
3206 */
3207 iter.iter.node = &lta->notify_sock_n.node;
3208 (void) lttng_ht_del(ust_app_ht_by_notify_sock, &iter);
3209
3210 /*
3211 * Ignore return value since the node might have been removed before by an
3212 * add replace during app registration because the PID can be reassigned by
3213 * the OS.
3214 */
3215 iter.iter.node = &lta->pid_n.node;
3216 ret = lttng_ht_del(ust_app_ht, &iter);
3217 if (ret) {
3218 DBG3("Unregister app by PID %d failed. This can happen on pid reuse",
3219 lta->pid);
3220 }
3221
3222 /* Free memory */
3223 call_rcu(&lta->pid_n.head, delete_ust_app_rcu);
3224
3225 rcu_read_unlock();
3226 return;
3227 }
3228
3229 /*
3230 * Fill events array with all events name of all registered apps.
3231 */
3232 int ust_app_list_events(struct lttng_event **events)
3233 {
3234 int ret, handle;
3235 size_t nbmem, count = 0;
3236 struct lttng_ht_iter iter;
3237 struct ust_app *app;
3238 struct lttng_event *tmp_event;
3239
3240 nbmem = UST_APP_EVENT_LIST_SIZE;
3241 tmp_event = zmalloc(nbmem * sizeof(struct lttng_event));
3242 if (tmp_event == NULL) {
3243 PERROR("zmalloc ust app events");
3244 ret = -ENOMEM;
3245 goto error;
3246 }
3247
3248 rcu_read_lock();
3249
3250 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
3251 struct lttng_ust_tracepoint_iter uiter;
3252
3253 health_code_update();
3254
3255 if (!app->compatible) {
3256 /*
3257 * TODO: In time, we should notice the caller of this error by
3258 * telling him that this is a version error.
3259 */
3260 continue;
3261 }
3262 handle = ustctl_tracepoint_list(app->sock);
3263 if (handle < 0) {
3264 if (handle != -EPIPE && handle != -LTTNG_UST_ERR_EXITING) {
3265 ERR("UST app list events getting handle failed for app pid %d",
3266 app->pid);
3267 }
3268 continue;
3269 }
3270
3271 while ((ret = ustctl_tracepoint_list_get(app->sock, handle,
3272 &uiter)) != -LTTNG_UST_ERR_NOENT) {
3273 /* Handle ustctl error. */
3274 if (ret < 0) {
3275 if (ret != -LTTNG_UST_ERR_EXITING && ret != -EPIPE) {
3276 ERR("UST app tp list get failed for app %d with ret %d",
3277 app->sock, ret);
3278 } else {
3279 DBG3("UST app tp list get failed. Application is dead");
3280 /*
3281 * This is normal behavior, an application can die during the
3282 * creation process. Don't report an error so the execution can
3283 * continue normally. Continue normal execution.
3284 */
3285 break;
3286 }
3287 free(tmp_event);
3288 goto rcu_error;
3289 }
3290
3291 health_code_update();
3292 if (count >= nbmem) {
3293 /* In case the realloc fails, we free the memory */
3294 struct lttng_event *new_tmp_event;
3295 size_t new_nbmem;
3296
3297 new_nbmem = nbmem << 1;
3298 DBG2("Reallocating event list from %zu to %zu entries",
3299 nbmem, new_nbmem);
3300 new_tmp_event = realloc(tmp_event,
3301 new_nbmem * sizeof(struct lttng_event));
3302 if (new_tmp_event == NULL) {
3303 PERROR("realloc ust app events");
3304 free(tmp_event);
3305 ret = -ENOMEM;
3306 goto rcu_error;
3307 }
3308 /* Zero the new memory */
3309 memset(new_tmp_event + nbmem, 0,
3310 (new_nbmem - nbmem) * sizeof(struct lttng_event));
3311 nbmem = new_nbmem;
3312 tmp_event = new_tmp_event;
3313 }
3314 memcpy(tmp_event[count].name, uiter.name, LTTNG_UST_SYM_NAME_LEN);
3315 tmp_event[count].loglevel = uiter.loglevel;
3316 tmp_event[count].type = (enum lttng_event_type) LTTNG_UST_TRACEPOINT;
3317 tmp_event[count].pid = app->pid;
3318 tmp_event[count].enabled = -1;
3319 count++;
3320 }
3321 }
3322
3323 ret = count;
3324 *events = tmp_event;
3325
3326 DBG2("UST app list events done (%zu events)", count);
3327
3328 rcu_error:
3329 rcu_read_unlock();
3330 error:
3331 health_code_update();
3332 return ret;
3333 }
3334
3335 /*
3336 * Fill events array with all events name of all registered apps.
3337 */
3338 int ust_app_list_event_fields(struct lttng_event_field **fields)
3339 {
3340 int ret, handle;
3341 size_t nbmem, count = 0;
3342 struct lttng_ht_iter iter;
3343 struct ust_app *app;
3344 struct lttng_event_field *tmp_event;
3345
3346 nbmem = UST_APP_EVENT_LIST_SIZE;
3347 tmp_event = zmalloc(nbmem * sizeof(struct lttng_event_field));
3348 if (tmp_event == NULL) {
3349 PERROR("zmalloc ust app event fields");
3350 ret = -ENOMEM;
3351 goto error;
3352 }
3353
3354 rcu_read_lock();
3355
3356 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
3357 struct lttng_ust_field_iter uiter;
3358
3359 health_code_update();
3360
3361 if (!app->compatible) {
3362 /*
3363 * TODO: In time, we should notice the caller of this error by
3364 * telling him that this is a version error.
3365 */
3366 continue;
3367 }
3368 handle = ustctl_tracepoint_field_list(app->sock);
3369 if (handle < 0) {
3370 if (handle != -EPIPE && handle != -LTTNG_UST_ERR_EXITING) {
3371 ERR("UST app list field getting handle failed for app pid %d",
3372 app->pid);
3373 }
3374 continue;
3375 }
3376
3377 while ((ret = ustctl_tracepoint_field_list_get(app->sock, handle,
3378 &uiter)) != -LTTNG_UST_ERR_NOENT) {
3379 /* Handle ustctl error. */
3380 if (ret < 0) {
3381 if (ret != -LTTNG_UST_ERR_EXITING && ret != -EPIPE) {
3382 ERR("UST app tp list field failed for app %d with ret %d",
3383 app->sock, ret);
3384 } else {
3385 DBG3("UST app tp list field failed. Application is dead");
3386 /*
3387 * This is normal behavior, an application can die during the
3388 * creation process. Don't report an error so the execution can
3389 * continue normally. Reset list and count for next app.
3390 */
3391 break;
3392 }
3393 free(tmp_event);
3394 goto rcu_error;
3395 }
3396
3397 health_code_update();
3398 if (count >= nbmem) {
3399 /* In case the realloc fails, we free the memory */
3400 struct lttng_event_field *new_tmp_event;
3401 size_t new_nbmem;
3402
3403 new_nbmem = nbmem << 1;
3404 DBG2("Reallocating event field list from %zu to %zu entries",
3405 nbmem, new_nbmem);
3406 new_tmp_event = realloc(tmp_event,
3407 new_nbmem * sizeof(struct lttng_event_field));
3408 if (new_tmp_event == NULL) {
3409 PERROR("realloc ust app event fields");
3410 free(tmp_event);
3411 ret = -ENOMEM;
3412 goto rcu_error;
3413 }
3414 /* Zero the new memory */
3415 memset(new_tmp_event + nbmem, 0,
3416 (new_nbmem - nbmem) * sizeof(struct lttng_event_field));
3417 nbmem = new_nbmem;
3418 tmp_event = new_tmp_event;
3419 }
3420
3421 memcpy(tmp_event[count].field_name, uiter.field_name, LTTNG_UST_SYM_NAME_LEN);
3422 /* Mapping between these enums matches 1 to 1. */
3423 tmp_event[count].type = (enum lttng_event_field_type) uiter.type;
3424 tmp_event[count].nowrite = uiter.nowrite;
3425
3426 memcpy(tmp_event[count].event.name, uiter.event_name, LTTNG_UST_SYM_NAME_LEN);
3427 tmp_event[count].event.loglevel = uiter.loglevel;
3428 tmp_event[count].event.type = LTTNG_EVENT_TRACEPOINT;
3429 tmp_event[count].event.pid = app->pid;
3430 tmp_event[count].event.enabled = -1;
3431 count++;
3432 }
3433 }
3434
3435 ret = count;
3436 *fields = tmp_event;
3437
3438 DBG2("UST app list event fields done (%zu events)", count);
3439
3440 rcu_error:
3441 rcu_read_unlock();
3442 error:
3443 health_code_update();
3444 return ret;
3445 }
3446
3447 /*
3448 * Free and clean all traceable apps of the global list.
3449 *
3450 * Should _NOT_ be called with RCU read-side lock held.
3451 */
3452 void ust_app_clean_list(void)
3453 {
3454 int ret;
3455 struct ust_app *app;
3456 struct lttng_ht_iter iter;
3457
3458 DBG2("UST app cleaning registered apps hash table");
3459
3460 rcu_read_lock();
3461
3462 if (ust_app_ht) {
3463 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
3464 ret = lttng_ht_del(ust_app_ht, &iter);
3465 assert(!ret);
3466 call_rcu(&app->pid_n.head, delete_ust_app_rcu);
3467 }
3468 }
3469
3470 /* Cleanup socket hash table */
3471 if (ust_app_ht_by_sock) {
3472 cds_lfht_for_each_entry(ust_app_ht_by_sock->ht, &iter.iter, app,
3473 sock_n.node) {
3474 ret = lttng_ht_del(ust_app_ht_by_sock, &iter);
3475 assert(!ret);
3476 }
3477 }
3478
3479 /* Cleanup notify socket hash table */
3480 if (ust_app_ht_by_notify_sock) {
3481 cds_lfht_for_each_entry(ust_app_ht_by_notify_sock->ht, &iter.iter, app,
3482 notify_sock_n.node) {
3483 ret = lttng_ht_del(ust_app_ht_by_notify_sock, &iter);
3484 assert(!ret);
3485 }
3486 }
3487 rcu_read_unlock();
3488
3489 /* Destroy is done only when the ht is empty */
3490 if (ust_app_ht) {
3491 ht_cleanup_push(ust_app_ht);
3492 }
3493 if (ust_app_ht_by_sock) {
3494 ht_cleanup_push(ust_app_ht_by_sock);
3495 }
3496 if (ust_app_ht_by_notify_sock) {
3497 ht_cleanup_push(ust_app_ht_by_notify_sock);
3498 }
3499 }
3500
3501 /*
3502 * Init UST app hash table.
3503 */
3504 int ust_app_ht_alloc(void)
3505 {
3506 ust_app_ht = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG);
3507 if (!ust_app_ht) {
3508 return -1;
3509 }
3510 ust_app_ht_by_sock = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG);
3511 if (!ust_app_ht_by_sock) {
3512 return -1;
3513 }
3514 ust_app_ht_by_notify_sock = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG);
3515 if (!ust_app_ht_by_notify_sock) {
3516 return -1;
3517 }
3518 return 0;
3519 }
3520
3521 /*
3522 * For a specific UST session, disable the channel for all registered apps.
3523 */
3524 int ust_app_disable_channel_glb(struct ltt_ust_session *usess,
3525 struct ltt_ust_channel *uchan)
3526 {
3527 int ret = 0;
3528 struct lttng_ht_iter iter;
3529 struct lttng_ht_node_str *ua_chan_node;
3530 struct ust_app *app;
3531 struct ust_app_session *ua_sess;
3532 struct ust_app_channel *ua_chan;
3533
3534 if (usess == NULL || uchan == NULL) {
3535 ERR("Disabling UST global channel with NULL values");
3536 ret = -1;
3537 goto error;
3538 }
3539
3540 DBG2("UST app disabling channel %s from global domain for session id %" PRIu64,
3541 uchan->name, usess->id);
3542
3543 rcu_read_lock();
3544
3545 /* For every registered applications */
3546 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
3547 struct lttng_ht_iter uiter;
3548 if (!app->compatible) {
3549 /*
3550 * TODO: In time, we should notice the caller of this error by
3551 * telling him that this is a version error.
3552 */
3553 continue;
3554 }
3555 ua_sess = lookup_session_by_app(usess, app);
3556 if (ua_sess == NULL) {
3557 continue;
3558 }
3559
3560 /* Get channel */
3561 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &uiter);
3562 ua_chan_node = lttng_ht_iter_get_node_str(&uiter);
3563 /* If the session if found for the app, the channel must be there */
3564 assert(ua_chan_node);
3565
3566 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
3567 /* The channel must not be already disabled */
3568 assert(ua_chan->enabled == 1);
3569
3570 /* Disable channel onto application */
3571 ret = disable_ust_app_channel(ua_sess, ua_chan, app);
3572 if (ret < 0) {
3573 /* XXX: We might want to report this error at some point... */
3574 continue;
3575 }
3576 }
3577
3578 rcu_read_unlock();
3579
3580 error:
3581 return ret;
3582 }
3583
3584 /*
3585 * For a specific UST session, enable the channel for all registered apps.
3586 */
3587 int ust_app_enable_channel_glb(struct ltt_ust_session *usess,
3588 struct ltt_ust_channel *uchan)
3589 {
3590 int ret = 0;
3591 struct lttng_ht_iter iter;
3592 struct ust_app *app;
3593 struct ust_app_session *ua_sess;
3594
3595 if (usess == NULL || uchan == NULL) {
3596 ERR("Adding UST global channel to NULL values");
3597 ret = -1;
3598 goto error;
3599 }
3600
3601 DBG2("UST app enabling channel %s to global domain for session id %" PRIu64,
3602 uchan->name, usess->id);
3603
3604 rcu_read_lock();
3605
3606 /* For every registered applications */
3607 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
3608 if (!app->compatible) {
3609 /*
3610 * TODO: In time, we should notice the caller of this error by
3611 * telling him that this is a version error.
3612 */
3613 continue;
3614 }
3615 ua_sess = lookup_session_by_app(usess, app);
3616 if (ua_sess == NULL) {
3617 continue;
3618 }
3619
3620 /* Enable channel onto application */
3621 ret = enable_ust_app_channel(ua_sess, uchan, app);
3622 if (ret < 0) {
3623 /* XXX: We might want to report this error at some point... */
3624 continue;
3625 }
3626 }
3627
3628 rcu_read_unlock();
3629
3630 error:
3631 return ret;
3632 }
3633
3634 /*
3635 * Disable an event in a channel and for a specific session.
3636 */
3637 int ust_app_disable_event_glb(struct ltt_ust_session *usess,
3638 struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent)
3639 {
3640 int ret = 0;
3641 struct lttng_ht_iter iter, uiter;
3642 struct lttng_ht_node_str *ua_chan_node, *ua_event_node;
3643 struct ust_app *app;
3644 struct ust_app_session *ua_sess;
3645 struct ust_app_channel *ua_chan;
3646 struct ust_app_event *ua_event;
3647
3648 DBG("UST app disabling event %s for all apps in channel "
3649 "%s for session id %" PRIu64,
3650 uevent->attr.name, uchan->name, usess->id);
3651
3652 rcu_read_lock();
3653
3654 /* For all registered applications */
3655 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
3656 if (!app->compatible) {
3657 /*
3658 * TODO: In time, we should notice the caller of this error by
3659 * telling him that this is a version error.
3660 */
3661 continue;
3662 }
3663 ua_sess = lookup_session_by_app(usess, app);
3664 if (ua_sess == NULL) {
3665 /* Next app */
3666 continue;
3667 }
3668
3669 /* Lookup channel in the ust app session */
3670 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &uiter);
3671 ua_chan_node = lttng_ht_iter_get_node_str(&uiter);
3672 if (ua_chan_node == NULL) {
3673 DBG2("Channel %s not found in session id %" PRIu64 " for app pid %d."
3674 "Skipping", uchan->name, usess->id, app->pid);
3675 continue;
3676 }
3677 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
3678
3679 lttng_ht_lookup(ua_chan->events, (void *)uevent->attr.name, &uiter);
3680 ua_event_node = lttng_ht_iter_get_node_str(&uiter);
3681 if (ua_event_node == NULL) {
3682 DBG2("Event %s not found in channel %s for app pid %d."
3683 "Skipping", uevent->attr.name, uchan->name, app->pid);
3684 continue;
3685 }
3686 ua_event = caa_container_of(ua_event_node, struct ust_app_event, node);
3687
3688 ret = disable_ust_app_event(ua_sess, ua_event, app);
3689 if (ret < 0) {
3690 /* XXX: Report error someday... */
3691 continue;
3692 }
3693 }
3694
3695 rcu_read_unlock();
3696
3697 return ret;
3698 }
3699
3700 /*
3701 * For a specific UST session, create the channel for all registered apps.
3702 */
3703 int ust_app_create_channel_glb(struct ltt_ust_session *usess,
3704 struct ltt_ust_channel *uchan)
3705 {
3706 int ret = 0, created;
3707 struct lttng_ht_iter iter;
3708 struct ust_app *app;
3709 struct ust_app_session *ua_sess = NULL;
3710
3711 /* Very wrong code flow */
3712 assert(usess);
3713 assert(uchan);
3714
3715 DBG2("UST app adding channel %s to UST domain for session id %" PRIu64,
3716 uchan->name, usess->id);
3717
3718 rcu_read_lock();
3719
3720 /* For every registered applications */
3721 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
3722 if (!app->compatible) {
3723 /*
3724 * TODO: In time, we should notice the caller of this error by
3725 * telling him that this is a version error.
3726 */
3727 continue;
3728 }
3729 if (!trace_ust_pid_tracker_lookup(usess, app->pid)) {
3730 /* Skip. */
3731 continue;
3732 }
3733
3734 /*
3735 * Create session on the tracer side and add it to app session HT. Note
3736 * that if session exist, it will simply return a pointer to the ust
3737 * app session.
3738 */
3739 ret = create_ust_app_session(usess, app, &ua_sess, &created);
3740 if (ret < 0) {
3741 switch (ret) {
3742 case -ENOTCONN: