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