675283aa63477b3679aa27a7f8942d1c52453dae
[lttng-tools.git] / src / bin / lttng-sessiond / ust-app.c
1 /*
2 * Copyright (C) 2011 - David Goulet <david.goulet@polymtl.ca>
3 * Copyright (C) 2016 - Jérémie Galarneau <jeremie.galarneau@efficios.com>
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License, version 2 only,
7 * as published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License along
15 * with this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
17 */
18
19 #define _LGPL_SOURCE
20 #include <errno.h>
21 #include <inttypes.h>
22 #include <pthread.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <sys/stat.h>
27 #include <sys/types.h>
28 #include <unistd.h>
29 #include <urcu/compiler.h>
30 #include <lttng/ust-error.h>
31 #include <signal.h>
32
33 #include <common/common.h>
34 #include <common/sessiond-comm/sessiond-comm.h>
35
36 #include "buffer-registry.h"
37 #include "fd-limit.h"
38 #include "health-sessiond.h"
39 #include "ust-app.h"
40 #include "ust-consumer.h"
41 #include "ust-ctl.h"
42 #include "utils.h"
43 #include "session.h"
44 #include "lttng-sessiond.h"
45 #include "notification-thread-commands.h"
46
47 static
48 int ust_app_flush_app_session(struct ust_app *app, struct ust_app_session *ua_sess);
49
50 /* Next available channel key. Access under next_channel_key_lock. */
51 static uint64_t _next_channel_key;
52 static pthread_mutex_t next_channel_key_lock = PTHREAD_MUTEX_INITIALIZER;
53
54 /* Next available session ID. Access under next_session_id_lock. */
55 static uint64_t _next_session_id;
56 static pthread_mutex_t next_session_id_lock = PTHREAD_MUTEX_INITIALIZER;
57
58 /*
59 * Return the incremented value of next_channel_key.
60 */
61 static uint64_t get_next_channel_key(void)
62 {
63 uint64_t ret;
64
65 pthread_mutex_lock(&next_channel_key_lock);
66 ret = ++_next_channel_key;
67 pthread_mutex_unlock(&next_channel_key_lock);
68 return ret;
69 }
70
71 /*
72 * Return the atomically incremented value of next_session_id.
73 */
74 static uint64_t get_next_session_id(void)
75 {
76 uint64_t ret;
77
78 pthread_mutex_lock(&next_session_id_lock);
79 ret = ++_next_session_id;
80 pthread_mutex_unlock(&next_session_id_lock);
81 return ret;
82 }
83
84 static void copy_channel_attr_to_ustctl(
85 struct ustctl_consumer_channel_attr *attr,
86 struct lttng_ust_channel_attr *uattr)
87 {
88 /* Copy event attributes since the layout is different. */
89 attr->subbuf_size = uattr->subbuf_size;
90 attr->num_subbuf = uattr->num_subbuf;
91 attr->overwrite = uattr->overwrite;
92 attr->switch_timer_interval = uattr->switch_timer_interval;
93 attr->read_timer_interval = uattr->read_timer_interval;
94 attr->output = uattr->output;
95 attr->blocking_timeout = uattr->u.s.blocking_timeout;
96 }
97
98 /*
99 * Match function for the hash table lookup.
100 *
101 * It matches an ust app event based on three attributes which are the event
102 * name, the filter bytecode and the loglevel.
103 */
104 static int ht_match_ust_app_event(struct cds_lfht_node *node, const void *_key)
105 {
106 struct ust_app_event *event;
107 const struct ust_app_ht_key *key;
108 int ev_loglevel_value;
109
110 assert(node);
111 assert(_key);
112
113 event = caa_container_of(node, struct ust_app_event, node.node);
114 key = _key;
115 ev_loglevel_value = event->attr.loglevel;
116
117 /* Match the 4 elements of the key: name, filter, loglevel, exclusions */
118
119 /* Event name */
120 if (strncmp(event->attr.name, key->name, sizeof(event->attr.name)) != 0) {
121 goto no_match;
122 }
123
124 /* Event loglevel. */
125 if (ev_loglevel_value != key->loglevel_type) {
126 if (event->attr.loglevel_type == LTTNG_UST_LOGLEVEL_ALL
127 && key->loglevel_type == 0 &&
128 ev_loglevel_value == -1) {
129 /*
130 * Match is accepted. This is because on event creation, the
131 * loglevel is set to -1 if the event loglevel type is ALL so 0 and
132 * -1 are accepted for this loglevel type since 0 is the one set by
133 * the API when receiving an enable event.
134 */
135 } else {
136 goto no_match;
137 }
138 }
139
140 /* One of the filters is NULL, fail. */
141 if ((key->filter && !event->filter) || (!key->filter && event->filter)) {
142 goto no_match;
143 }
144
145 if (key->filter && event->filter) {
146 /* Both filters exists, check length followed by the bytecode. */
147 if (event->filter->len != key->filter->len ||
148 memcmp(event->filter->data, key->filter->data,
149 event->filter->len) != 0) {
150 goto no_match;
151 }
152 }
153
154 /* One of the exclusions is NULL, fail. */
155 if ((key->exclusion && !event->exclusion) || (!key->exclusion && event->exclusion)) {
156 goto no_match;
157 }
158
159 if (key->exclusion && event->exclusion) {
160 /* Both exclusions exists, check count followed by the names. */
161 if (event->exclusion->count != key->exclusion->count ||
162 memcmp(event->exclusion->names, key->exclusion->names,
163 event->exclusion->count * LTTNG_UST_SYM_NAME_LEN) != 0) {
164 goto no_match;
165 }
166 }
167
168
169 /* Match. */
170 return 1;
171
172 no_match:
173 return 0;
174 }
175
176 /*
177 * Unique add of an ust app event in the given ht. This uses the custom
178 * ht_match_ust_app_event match function and the event name as hash.
179 */
180 static void add_unique_ust_app_event(struct ust_app_channel *ua_chan,
181 struct ust_app_event *event)
182 {
183 struct cds_lfht_node *node_ptr;
184 struct ust_app_ht_key key;
185 struct lttng_ht *ht;
186
187 assert(ua_chan);
188 assert(ua_chan->events);
189 assert(event);
190
191 ht = ua_chan->events;
192 key.name = event->attr.name;
193 key.filter = event->filter;
194 key.loglevel_type = event->attr.loglevel;
195 key.exclusion = event->exclusion;
196
197 node_ptr = cds_lfht_add_unique(ht->ht,
198 ht->hash_fct(event->node.key, lttng_ht_seed),
199 ht_match_ust_app_event, &key, &event->node.node);
200 assert(node_ptr == &event->node.node);
201 }
202
203 /*
204 * Close the notify socket from the given RCU head object. This MUST be called
205 * through a call_rcu().
206 */
207 static void close_notify_sock_rcu(struct rcu_head *head)
208 {
209 int ret;
210 struct ust_app_notify_sock_obj *obj =
211 caa_container_of(head, struct ust_app_notify_sock_obj, head);
212
213 /* Must have a valid fd here. */
214 assert(obj->fd >= 0);
215
216 ret = close(obj->fd);
217 if (ret) {
218 ERR("close notify sock %d RCU", obj->fd);
219 }
220 lttng_fd_put(LTTNG_FD_APPS, 1);
221
222 free(obj);
223 }
224
225 /*
226 * Return the session registry according to the buffer type of the given
227 * session.
228 *
229 * A registry per UID object MUST exists before calling this function or else
230 * it assert() if not found. RCU read side lock must be acquired.
231 */
232 static struct ust_registry_session *get_session_registry(
233 struct ust_app_session *ua_sess)
234 {
235 struct ust_registry_session *registry = NULL;
236
237 assert(ua_sess);
238
239 switch (ua_sess->buffer_type) {
240 case LTTNG_BUFFER_PER_PID:
241 {
242 struct buffer_reg_pid *reg_pid = buffer_reg_pid_find(ua_sess->id);
243 if (!reg_pid) {
244 goto error;
245 }
246 registry = reg_pid->registry->reg.ust;
247 break;
248 }
249 case LTTNG_BUFFER_PER_UID:
250 {
251 struct buffer_reg_uid *reg_uid = buffer_reg_uid_find(
252 ua_sess->tracing_id, ua_sess->bits_per_long, ua_sess->uid);
253 if (!reg_uid) {
254 goto error;
255 }
256 registry = reg_uid->registry->reg.ust;
257 break;
258 }
259 default:
260 assert(0);
261 };
262
263 error:
264 return registry;
265 }
266
267 /*
268 * Delete ust context safely. RCU read lock must be held before calling
269 * this function.
270 */
271 static
272 void delete_ust_app_ctx(int sock, struct ust_app_ctx *ua_ctx,
273 struct ust_app *app)
274 {
275 int ret;
276
277 assert(ua_ctx);
278
279 if (ua_ctx->obj) {
280 pthread_mutex_lock(&app->sock_lock);
281 ret = ustctl_release_object(sock, ua_ctx->obj);
282 pthread_mutex_unlock(&app->sock_lock);
283 if (ret < 0 && ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
284 ERR("UST app sock %d release ctx obj handle %d failed with ret %d",
285 sock, ua_ctx->obj->handle, ret);
286 }
287 free(ua_ctx->obj);
288 }
289 free(ua_ctx);
290 }
291
292 /*
293 * Delete ust app event safely. RCU read lock must be held before calling
294 * this function.
295 */
296 static
297 void delete_ust_app_event(int sock, struct ust_app_event *ua_event,
298 struct ust_app *app)
299 {
300 int ret;
301
302 assert(ua_event);
303
304 free(ua_event->filter);
305 if (ua_event->exclusion != NULL)
306 free(ua_event->exclusion);
307 if (ua_event->obj != NULL) {
308 pthread_mutex_lock(&app->sock_lock);
309 ret = ustctl_release_object(sock, ua_event->obj);
310 pthread_mutex_unlock(&app->sock_lock);
311 if (ret < 0 && ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
312 ERR("UST app sock %d release event obj failed with ret %d",
313 sock, ret);
314 }
315 free(ua_event->obj);
316 }
317 free(ua_event);
318 }
319
320 /*
321 * Release ust data object of the given stream.
322 *
323 * Return 0 on success or else a negative value.
324 */
325 static int release_ust_app_stream(int sock, struct ust_app_stream *stream,
326 struct ust_app *app)
327 {
328 int ret = 0;
329
330 assert(stream);
331
332 if (stream->obj) {
333 pthread_mutex_lock(&app->sock_lock);
334 ret = ustctl_release_object(sock, stream->obj);
335 pthread_mutex_unlock(&app->sock_lock);
336 if (ret < 0 && ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
337 ERR("UST app sock %d release stream obj failed with ret %d",
338 sock, ret);
339 }
340 lttng_fd_put(LTTNG_FD_APPS, 2);
341 free(stream->obj);
342 }
343
344 return ret;
345 }
346
347 /*
348 * Delete ust app stream safely. RCU read lock must be held before calling
349 * this function.
350 */
351 static
352 void delete_ust_app_stream(int sock, struct ust_app_stream *stream,
353 struct ust_app *app)
354 {
355 assert(stream);
356
357 (void) release_ust_app_stream(sock, stream, app);
358 free(stream);
359 }
360
361 /*
362 * We need to execute ht_destroy outside of RCU read-side critical
363 * section and outside of call_rcu thread, so we postpone its execution
364 * using ht_cleanup_push. It is simpler than to change the semantic of
365 * the many callers of delete_ust_app_session().
366 */
367 static
368 void delete_ust_app_channel_rcu(struct rcu_head *head)
369 {
370 struct ust_app_channel *ua_chan =
371 caa_container_of(head, struct ust_app_channel, rcu_head);
372
373 ht_cleanup_push(ua_chan->ctx);
374 ht_cleanup_push(ua_chan->events);
375 free(ua_chan);
376 }
377
378 /*
379 * Extract the lost packet or discarded events counter when the channel is
380 * being deleted and store the value in the parent channel so we can
381 * access it from lttng list and at stop/destroy.
382 *
383 * The session list lock must be held by the caller.
384 */
385 static
386 void save_per_pid_lost_discarded_counters(struct ust_app_channel *ua_chan)
387 {
388 uint64_t discarded = 0, lost = 0;
389 struct ltt_session *session;
390 struct ltt_ust_channel *uchan;
391
392 if (ua_chan->attr.type != LTTNG_UST_CHAN_PER_CPU) {
393 return;
394 }
395
396 rcu_read_lock();
397 session = session_find_by_id(ua_chan->session->tracing_id);
398 if (!session || !session->ust_session) {
399 /*
400 * Not finding the session is not an error because there are
401 * multiple ways the channels can be torn down.
402 *
403 * 1) The session daemon can initiate the destruction of the
404 * ust app session after receiving a destroy command or
405 * during its shutdown/teardown.
406 * 2) The application, since we are in per-pid tracing, is
407 * unregistering and tearing down its ust app session.
408 *
409 * Both paths are protected by the session list lock which
410 * ensures that the accounting of lost packets and discarded
411 * events is done exactly once. The session is then unpublished
412 * from the session list, resulting in this condition.
413 */
414 goto end;
415 }
416
417 if (ua_chan->attr.overwrite) {
418 consumer_get_lost_packets(ua_chan->session->tracing_id,
419 ua_chan->key, session->ust_session->consumer,
420 &lost);
421 } else {
422 consumer_get_discarded_events(ua_chan->session->tracing_id,
423 ua_chan->key, session->ust_session->consumer,
424 &discarded);
425 }
426 uchan = trace_ust_find_channel_by_name(
427 session->ust_session->domain_global.channels,
428 ua_chan->name);
429 if (!uchan) {
430 ERR("Missing UST channel to store discarded counters");
431 goto end;
432 }
433
434 uchan->per_pid_closed_app_discarded += discarded;
435 uchan->per_pid_closed_app_lost += lost;
436
437 end:
438 rcu_read_unlock();
439 }
440
441 /*
442 * Delete ust app channel safely. RCU read lock must be held before calling
443 * this function.
444 *
445 * The session list lock must be held by the caller.
446 */
447 static
448 void delete_ust_app_channel(int sock, struct ust_app_channel *ua_chan,
449 struct ust_app *app)
450 {
451 int ret;
452 struct lttng_ht_iter iter;
453 struct ust_app_event *ua_event;
454 struct ust_app_ctx *ua_ctx;
455 struct ust_app_stream *stream, *stmp;
456 struct ust_registry_session *registry;
457
458 assert(ua_chan);
459
460 DBG3("UST app deleting channel %s", ua_chan->name);
461
462 /* Wipe stream */
463 cds_list_for_each_entry_safe(stream, stmp, &ua_chan->streams.head, list) {
464 cds_list_del(&stream->list);
465 delete_ust_app_stream(sock, stream, app);
466 }
467
468 /* Wipe context */
469 cds_lfht_for_each_entry(ua_chan->ctx->ht, &iter.iter, ua_ctx, node.node) {
470 cds_list_del(&ua_ctx->list);
471 ret = lttng_ht_del(ua_chan->ctx, &iter);
472 assert(!ret);
473 delete_ust_app_ctx(sock, ua_ctx, app);
474 }
475
476 /* Wipe events */
477 cds_lfht_for_each_entry(ua_chan->events->ht, &iter.iter, ua_event,
478 node.node) {
479 ret = lttng_ht_del(ua_chan->events, &iter);
480 assert(!ret);
481 delete_ust_app_event(sock, ua_event, app);
482 }
483
484 if (ua_chan->session->buffer_type == LTTNG_BUFFER_PER_PID) {
485 /* Wipe and free registry from session registry. */
486 registry = get_session_registry(ua_chan->session);
487 if (registry) {
488 ust_registry_channel_del_free(registry, ua_chan->key,
489 true);
490 }
491 save_per_pid_lost_discarded_counters(ua_chan);
492 }
493
494 if (ua_chan->obj != NULL) {
495 /* Remove channel from application UST object descriptor. */
496 iter.iter.node = &ua_chan->ust_objd_node.node;
497 ret = lttng_ht_del(app->ust_objd, &iter);
498 assert(!ret);
499 pthread_mutex_lock(&app->sock_lock);
500 ret = ustctl_release_object(sock, ua_chan->obj);
501 pthread_mutex_unlock(&app->sock_lock);
502 if (ret < 0 && ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
503 ERR("UST app sock %d release channel obj failed with ret %d",
504 sock, ret);
505 }
506 lttng_fd_put(LTTNG_FD_APPS, 1);
507 free(ua_chan->obj);
508 }
509 call_rcu(&ua_chan->rcu_head, delete_ust_app_channel_rcu);
510 }
511
512 int ust_app_register_done(struct ust_app *app)
513 {
514 int ret;
515
516 pthread_mutex_lock(&app->sock_lock);
517 ret = ustctl_register_done(app->sock);
518 pthread_mutex_unlock(&app->sock_lock);
519 return ret;
520 }
521
522 int ust_app_release_object(struct ust_app *app, struct lttng_ust_object_data *data)
523 {
524 int ret, sock;
525
526 if (app) {
527 pthread_mutex_lock(&app->sock_lock);
528 sock = app->sock;
529 } else {
530 sock = -1;
531 }
532 ret = ustctl_release_object(sock, data);
533 if (app) {
534 pthread_mutex_unlock(&app->sock_lock);
535 }
536 return ret;
537 }
538
539 /*
540 * Push metadata to consumer socket.
541 *
542 * RCU read-side lock must be held to guarantee existance of socket.
543 * Must be called with the ust app session lock held.
544 * Must be called with the registry lock held.
545 *
546 * On success, return the len of metadata pushed or else a negative value.
547 * Returning a -EPIPE return value means we could not send the metadata,
548 * but it can be caused by recoverable errors (e.g. the application has
549 * terminated concurrently).
550 */
551 ssize_t ust_app_push_metadata(struct ust_registry_session *registry,
552 struct consumer_socket *socket, int send_zero_data)
553 {
554 int ret;
555 char *metadata_str = NULL;
556 size_t len, offset, new_metadata_len_sent;
557 ssize_t ret_val;
558 uint64_t metadata_key, metadata_version;
559
560 assert(registry);
561 assert(socket);
562
563 metadata_key = registry->metadata_key;
564
565 /*
566 * Means that no metadata was assigned to the session. This can
567 * happens if no start has been done previously.
568 */
569 if (!metadata_key) {
570 return 0;
571 }
572
573 offset = registry->metadata_len_sent;
574 len = registry->metadata_len - registry->metadata_len_sent;
575 new_metadata_len_sent = registry->metadata_len;
576 metadata_version = registry->metadata_version;
577 if (len == 0) {
578 DBG3("No metadata to push for metadata key %" PRIu64,
579 registry->metadata_key);
580 ret_val = len;
581 if (send_zero_data) {
582 DBG("No metadata to push");
583 goto push_data;
584 }
585 goto end;
586 }
587
588 /* Allocate only what we have to send. */
589 metadata_str = zmalloc(len);
590 if (!metadata_str) {
591 PERROR("zmalloc ust app metadata string");
592 ret_val = -ENOMEM;
593 goto error;
594 }
595 /* Copy what we haven't sent out. */
596 memcpy(metadata_str, registry->metadata + offset, len);
597
598 push_data:
599 pthread_mutex_unlock(&registry->lock);
600 /*
601 * We need to unlock the registry while we push metadata to
602 * break a circular dependency between the consumerd metadata
603 * lock and the sessiond registry lock. Indeed, pushing metadata
604 * to the consumerd awaits that it gets pushed all the way to
605 * relayd, but doing so requires grabbing the metadata lock. If
606 * a concurrent metadata request is being performed by
607 * consumerd, this can try to grab the registry lock on the
608 * sessiond while holding the metadata lock on the consumer
609 * daemon. Those push and pull schemes are performed on two
610 * different bidirectionnal communication sockets.
611 */
612 ret = consumer_push_metadata(socket, metadata_key,
613 metadata_str, len, offset, metadata_version);
614 pthread_mutex_lock(&registry->lock);
615 if (ret < 0) {
616 /*
617 * There is an acceptable race here between the registry
618 * metadata key assignment and the creation on the
619 * consumer. The session daemon can concurrently push
620 * metadata for this registry while being created on the
621 * consumer since the metadata key of the registry is
622 * assigned *before* it is setup to avoid the consumer
623 * to ask for metadata that could possibly be not found
624 * in the session daemon.
625 *
626 * The metadata will get pushed either by the session
627 * being stopped or the consumer requesting metadata if
628 * that race is triggered.
629 */
630 if (ret == -LTTCOMM_CONSUMERD_CHANNEL_FAIL) {
631 ret = 0;
632 } else {
633 ERR("Error pushing metadata to consumer");
634 }
635 ret_val = ret;
636 goto error_push;
637 } else {
638 /*
639 * Metadata may have been concurrently pushed, since
640 * we're not holding the registry lock while pushing to
641 * consumer. This is handled by the fact that we send
642 * the metadata content, size, and the offset at which
643 * that metadata belongs. This may arrive out of order
644 * on the consumer side, and the consumer is able to
645 * deal with overlapping fragments. The consumer
646 * supports overlapping fragments, which must be
647 * contiguous starting from offset 0. We keep the
648 * largest metadata_len_sent value of the concurrent
649 * send.
650 */
651 registry->metadata_len_sent =
652 max_t(size_t, registry->metadata_len_sent,
653 new_metadata_len_sent);
654 }
655 free(metadata_str);
656 return len;
657
658 end:
659 error:
660 if (ret_val) {
661 /*
662 * On error, flag the registry that the metadata is
663 * closed. We were unable to push anything and this
664 * means that either the consumer is not responding or
665 * the metadata cache has been destroyed on the
666 * consumer.
667 */
668 registry->metadata_closed = 1;
669 }
670 error_push:
671 free(metadata_str);
672 return ret_val;
673 }
674
675 /*
676 * For a given application and session, push metadata to consumer.
677 * Either sock or consumer is required : if sock is NULL, the default
678 * socket to send the metadata is retrieved from consumer, if sock
679 * is not NULL we use it to send the metadata.
680 * RCU read-side lock must be held while calling this function,
681 * therefore ensuring existance of registry. It also ensures existance
682 * of socket throughout this function.
683 *
684 * Return 0 on success else a negative error.
685 * Returning a -EPIPE return value means we could not send the metadata,
686 * but it can be caused by recoverable errors (e.g. the application has
687 * terminated concurrently).
688 */
689 static int push_metadata(struct ust_registry_session *registry,
690 struct consumer_output *consumer)
691 {
692 int ret_val;
693 ssize_t ret;
694 struct consumer_socket *socket;
695
696 assert(registry);
697 assert(consumer);
698
699 pthread_mutex_lock(&registry->lock);
700 if (registry->metadata_closed) {
701 ret_val = -EPIPE;
702 goto error;
703 }
704
705 /* Get consumer socket to use to push the metadata.*/
706 socket = consumer_find_socket_by_bitness(registry->bits_per_long,
707 consumer);
708 if (!socket) {
709 ret_val = -1;
710 goto error;
711 }
712
713 ret = ust_app_push_metadata(registry, socket, 0);
714 if (ret < 0) {
715 ret_val = ret;
716 goto error;
717 }
718 pthread_mutex_unlock(&registry->lock);
719 return 0;
720
721 error:
722 pthread_mutex_unlock(&registry->lock);
723 return ret_val;
724 }
725
726 /*
727 * Send to the consumer a close metadata command for the given session. Once
728 * done, the metadata channel is deleted and the session metadata pointer is
729 * nullified. The session lock MUST be held unless the application is
730 * in the destroy path.
731 *
732 * Return 0 on success else a negative value.
733 */
734 static int close_metadata(struct ust_registry_session *registry,
735 struct consumer_output *consumer)
736 {
737 int ret;
738 struct consumer_socket *socket;
739
740 assert(registry);
741 assert(consumer);
742
743 rcu_read_lock();
744
745 pthread_mutex_lock(&registry->lock);
746
747 if (!registry->metadata_key || registry->metadata_closed) {
748 ret = 0;
749 goto end;
750 }
751
752 /* Get consumer socket to use to push the metadata.*/
753 socket = consumer_find_socket_by_bitness(registry->bits_per_long,
754 consumer);
755 if (!socket) {
756 ret = -1;
757 goto error;
758 }
759
760 ret = consumer_close_metadata(socket, registry->metadata_key);
761 if (ret < 0) {
762 goto error;
763 }
764
765 error:
766 /*
767 * Metadata closed. Even on error this means that the consumer is not
768 * responding or not found so either way a second close should NOT be emit
769 * for this registry.
770 */
771 registry->metadata_closed = 1;
772 end:
773 pthread_mutex_unlock(&registry->lock);
774 rcu_read_unlock();
775 return ret;
776 }
777
778 /*
779 * We need to execute ht_destroy outside of RCU read-side critical
780 * section and outside of call_rcu thread, so we postpone its execution
781 * using ht_cleanup_push. It is simpler than to change the semantic of
782 * the many callers of delete_ust_app_session().
783 */
784 static
785 void delete_ust_app_session_rcu(struct rcu_head *head)
786 {
787 struct ust_app_session *ua_sess =
788 caa_container_of(head, struct ust_app_session, rcu_head);
789
790 ht_cleanup_push(ua_sess->channels);
791 free(ua_sess);
792 }
793
794 /*
795 * Delete ust app session safely. RCU read lock must be held before calling
796 * this function.
797 *
798 * The session list lock must be held by the caller.
799 */
800 static
801 void delete_ust_app_session(int sock, struct ust_app_session *ua_sess,
802 struct ust_app *app)
803 {
804 int ret;
805 struct lttng_ht_iter iter;
806 struct ust_app_channel *ua_chan;
807 struct ust_registry_session *registry;
808
809 assert(ua_sess);
810
811 pthread_mutex_lock(&ua_sess->lock);
812
813 assert(!ua_sess->deleted);
814 ua_sess->deleted = true;
815
816 registry = get_session_registry(ua_sess);
817 /* Registry can be null on error path during initialization. */
818 if (registry) {
819 /* Push metadata for application before freeing the application. */
820 (void) push_metadata(registry, ua_sess->consumer);
821
822 /*
823 * Don't ask to close metadata for global per UID buffers. Close
824 * metadata only on destroy trace session in this case. Also, the
825 * previous push metadata could have flag the metadata registry to
826 * close so don't send a close command if closed.
827 */
828 if (ua_sess->buffer_type != LTTNG_BUFFER_PER_UID) {
829 /* And ask to close it for this session registry. */
830 (void) close_metadata(registry, ua_sess->consumer);
831 }
832 }
833
834 cds_lfht_for_each_entry(ua_sess->channels->ht, &iter.iter, ua_chan,
835 node.node) {
836 ret = lttng_ht_del(ua_sess->channels, &iter);
837 assert(!ret);
838 delete_ust_app_channel(sock, ua_chan, app);
839 }
840
841 /* In case of per PID, the registry is kept in the session. */
842 if (ua_sess->buffer_type == LTTNG_BUFFER_PER_PID) {
843 struct buffer_reg_pid *reg_pid = buffer_reg_pid_find(ua_sess->id);
844 if (reg_pid) {
845 /*
846 * Registry can be null on error path during
847 * initialization.
848 */
849 buffer_reg_pid_remove(reg_pid);
850 buffer_reg_pid_destroy(reg_pid);
851 }
852 }
853
854 if (ua_sess->handle != -1) {
855 pthread_mutex_lock(&app->sock_lock);
856 ret = ustctl_release_handle(sock, ua_sess->handle);
857 pthread_mutex_unlock(&app->sock_lock);
858 if (ret < 0 && ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
859 ERR("UST app sock %d release session handle failed with ret %d",
860 sock, ret);
861 }
862 /* Remove session from application UST object descriptor. */
863 iter.iter.node = &ua_sess->ust_objd_node.node;
864 ret = lttng_ht_del(app->ust_sessions_objd, &iter);
865 assert(!ret);
866 }
867
868 pthread_mutex_unlock(&ua_sess->lock);
869
870 consumer_output_put(ua_sess->consumer);
871
872 call_rcu(&ua_sess->rcu_head, delete_ust_app_session_rcu);
873 }
874
875 /*
876 * Delete a traceable application structure from the global list. Never call
877 * this function outside of a call_rcu call.
878 *
879 * RCU read side lock should _NOT_ be held when calling this function.
880 */
881 static
882 void delete_ust_app(struct ust_app *app)
883 {
884 int ret, sock;
885 struct ust_app_session *ua_sess, *tmp_ua_sess;
886
887 /*
888 * The session list lock must be held during this function to guarantee
889 * the existence of ua_sess.
890 */
891 session_lock_list();
892 /* Delete ust app sessions info */
893 sock = app->sock;
894 app->sock = -1;
895
896 /* Wipe sessions */
897 cds_list_for_each_entry_safe(ua_sess, tmp_ua_sess, &app->teardown_head,
898 teardown_node) {
899 /* Free every object in the session and the session. */
900 rcu_read_lock();
901 delete_ust_app_session(sock, ua_sess, app);
902 rcu_read_unlock();
903 }
904
905 ht_cleanup_push(app->sessions);
906 ht_cleanup_push(app->ust_sessions_objd);
907 ht_cleanup_push(app->ust_objd);
908
909 /*
910 * Wait until we have deleted the application from the sock hash table
911 * before closing this socket, otherwise an application could re-use the
912 * socket ID and race with the teardown, using the same hash table entry.
913 *
914 * It's OK to leave the close in call_rcu. We want it to stay unique for
915 * all RCU readers that could run concurrently with unregister app,
916 * therefore we _need_ to only close that socket after a grace period. So
917 * it should stay in this RCU callback.
918 *
919 * This close() is a very important step of the synchronization model so
920 * every modification to this function must be carefully reviewed.
921 */
922 ret = close(sock);
923 if (ret) {
924 PERROR("close");
925 }
926 lttng_fd_put(LTTNG_FD_APPS, 1);
927
928 DBG2("UST app pid %d deleted", app->pid);
929 free(app);
930 session_unlock_list();
931 }
932
933 /*
934 * URCU intermediate call to delete an UST app.
935 */
936 static
937 void delete_ust_app_rcu(struct rcu_head *head)
938 {
939 struct lttng_ht_node_ulong *node =
940 caa_container_of(head, struct lttng_ht_node_ulong, head);
941 struct ust_app *app =
942 caa_container_of(node, struct ust_app, pid_n);
943
944 DBG3("Call RCU deleting app PID %d", app->pid);
945 delete_ust_app(app);
946 }
947
948 /*
949 * Delete the session from the application ht and delete the data structure by
950 * freeing every object inside and releasing them.
951 *
952 * The session list lock must be held by the caller.
953 */
954 static void destroy_app_session(struct ust_app *app,
955 struct ust_app_session *ua_sess)
956 {
957 int ret;
958 struct lttng_ht_iter iter;
959
960 assert(app);
961 assert(ua_sess);
962
963 iter.iter.node = &ua_sess->node.node;
964 ret = lttng_ht_del(app->sessions, &iter);
965 if (ret) {
966 /* Already scheduled for teardown. */
967 goto end;
968 }
969
970 /* Once deleted, free the data structure. */
971 delete_ust_app_session(app->sock, ua_sess, app);
972
973 end:
974 return;
975 }
976
977 /*
978 * Alloc new UST app session.
979 */
980 static
981 struct ust_app_session *alloc_ust_app_session(struct ust_app *app)
982 {
983 struct ust_app_session *ua_sess;
984
985 /* Init most of the default value by allocating and zeroing */
986 ua_sess = zmalloc(sizeof(struct ust_app_session));
987 if (ua_sess == NULL) {
988 PERROR("malloc");
989 goto error_free;
990 }
991
992 ua_sess->handle = -1;
993 ua_sess->channels = lttng_ht_new(0, LTTNG_HT_TYPE_STRING);
994 ua_sess->metadata_attr.type = LTTNG_UST_CHAN_METADATA;
995 pthread_mutex_init(&ua_sess->lock, NULL);
996
997 return ua_sess;
998
999 error_free:
1000 return NULL;
1001 }
1002
1003 /*
1004 * Alloc new UST app channel.
1005 */
1006 static
1007 struct ust_app_channel *alloc_ust_app_channel(char *name,
1008 struct ust_app_session *ua_sess,
1009 struct lttng_ust_channel_attr *attr)
1010 {
1011 struct ust_app_channel *ua_chan;
1012
1013 /* Init most of the default value by allocating and zeroing */
1014 ua_chan = zmalloc(sizeof(struct ust_app_channel));
1015 if (ua_chan == NULL) {
1016 PERROR("malloc");
1017 goto error;
1018 }
1019
1020 /* Setup channel name */
1021 strncpy(ua_chan->name, name, sizeof(ua_chan->name));
1022 ua_chan->name[sizeof(ua_chan->name) - 1] = '\0';
1023
1024 ua_chan->enabled = 1;
1025 ua_chan->handle = -1;
1026 ua_chan->session = ua_sess;
1027 ua_chan->key = get_next_channel_key();
1028 ua_chan->ctx = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG);
1029 ua_chan->events = lttng_ht_new(0, LTTNG_HT_TYPE_STRING);
1030 lttng_ht_node_init_str(&ua_chan->node, ua_chan->name);
1031
1032 CDS_INIT_LIST_HEAD(&ua_chan->streams.head);
1033 CDS_INIT_LIST_HEAD(&ua_chan->ctx_list);
1034
1035 /* Copy attributes */
1036 if (attr) {
1037 /* Translate from lttng_ust_channel to ustctl_consumer_channel_attr. */
1038 ua_chan->attr.subbuf_size = attr->subbuf_size;
1039 ua_chan->attr.num_subbuf = attr->num_subbuf;
1040 ua_chan->attr.overwrite = attr->overwrite;
1041 ua_chan->attr.switch_timer_interval = attr->switch_timer_interval;
1042 ua_chan->attr.read_timer_interval = attr->read_timer_interval;
1043 ua_chan->attr.output = attr->output;
1044 ua_chan->attr.blocking_timeout = attr->u.s.blocking_timeout;
1045 }
1046 /* By default, the channel is a per cpu channel. */
1047 ua_chan->attr.type = LTTNG_UST_CHAN_PER_CPU;
1048
1049 DBG3("UST app channel %s allocated", ua_chan->name);
1050
1051 return ua_chan;
1052
1053 error:
1054 return NULL;
1055 }
1056
1057 /*
1058 * Allocate and initialize a UST app stream.
1059 *
1060 * Return newly allocated stream pointer or NULL on error.
1061 */
1062 struct ust_app_stream *ust_app_alloc_stream(void)
1063 {
1064 struct ust_app_stream *stream = NULL;
1065
1066 stream = zmalloc(sizeof(*stream));
1067 if (stream == NULL) {
1068 PERROR("zmalloc ust app stream");
1069 goto error;
1070 }
1071
1072 /* Zero could be a valid value for a handle so flag it to -1. */
1073 stream->handle = -1;
1074
1075 error:
1076 return stream;
1077 }
1078
1079 /*
1080 * Alloc new UST app event.
1081 */
1082 static
1083 struct ust_app_event *alloc_ust_app_event(char *name,
1084 struct lttng_ust_event *attr)
1085 {
1086 struct ust_app_event *ua_event;
1087
1088 /* Init most of the default value by allocating and zeroing */
1089 ua_event = zmalloc(sizeof(struct ust_app_event));
1090 if (ua_event == NULL) {
1091 PERROR("malloc");
1092 goto error;
1093 }
1094
1095 ua_event->enabled = 1;
1096 strncpy(ua_event->name, name, sizeof(ua_event->name));
1097 ua_event->name[sizeof(ua_event->name) - 1] = '\0';
1098 lttng_ht_node_init_str(&ua_event->node, ua_event->name);
1099
1100 /* Copy attributes */
1101 if (attr) {
1102 memcpy(&ua_event->attr, attr, sizeof(ua_event->attr));
1103 }
1104
1105 DBG3("UST app event %s allocated", ua_event->name);
1106
1107 return ua_event;
1108
1109 error:
1110 return NULL;
1111 }
1112
1113 /*
1114 * Alloc new UST app context.
1115 */
1116 static
1117 struct ust_app_ctx *alloc_ust_app_ctx(struct lttng_ust_context_attr *uctx)
1118 {
1119 struct ust_app_ctx *ua_ctx;
1120
1121 ua_ctx = zmalloc(sizeof(struct ust_app_ctx));
1122 if (ua_ctx == NULL) {
1123 goto error;
1124 }
1125
1126 CDS_INIT_LIST_HEAD(&ua_ctx->list);
1127
1128 if (uctx) {
1129 memcpy(&ua_ctx->ctx, uctx, sizeof(ua_ctx->ctx));
1130 if (uctx->ctx == LTTNG_UST_CONTEXT_APP_CONTEXT) {
1131 char *provider_name = NULL, *ctx_name = NULL;
1132
1133 provider_name = strdup(uctx->u.app_ctx.provider_name);
1134 ctx_name = strdup(uctx->u.app_ctx.ctx_name);
1135 if (!provider_name || !ctx_name) {
1136 free(provider_name);
1137 free(ctx_name);
1138 goto error;
1139 }
1140
1141 ua_ctx->ctx.u.app_ctx.provider_name = provider_name;
1142 ua_ctx->ctx.u.app_ctx.ctx_name = ctx_name;
1143 }
1144 }
1145
1146 DBG3("UST app context %d allocated", ua_ctx->ctx.ctx);
1147 return ua_ctx;
1148 error:
1149 free(ua_ctx);
1150 return NULL;
1151 }
1152
1153 /*
1154 * Allocate a filter and copy the given original filter.
1155 *
1156 * Return allocated filter or NULL on error.
1157 */
1158 static struct lttng_filter_bytecode *copy_filter_bytecode(
1159 struct lttng_filter_bytecode *orig_f)
1160 {
1161 struct lttng_filter_bytecode *filter = NULL;
1162
1163 /* Copy filter bytecode */
1164 filter = zmalloc(sizeof(*filter) + orig_f->len);
1165 if (!filter) {
1166 PERROR("zmalloc alloc filter bytecode");
1167 goto error;
1168 }
1169
1170 memcpy(filter, orig_f, sizeof(*filter) + orig_f->len);
1171
1172 error:
1173 return filter;
1174 }
1175
1176 /*
1177 * Create a liblttng-ust filter bytecode from given bytecode.
1178 *
1179 * Return allocated filter or NULL on error.
1180 */
1181 static struct lttng_ust_filter_bytecode *create_ust_bytecode_from_bytecode(
1182 struct lttng_filter_bytecode *orig_f)
1183 {
1184 struct lttng_ust_filter_bytecode *filter = NULL;
1185
1186 /* Copy filter bytecode */
1187 filter = zmalloc(sizeof(*filter) + orig_f->len);
1188 if (!filter) {
1189 PERROR("zmalloc alloc ust filter bytecode");
1190 goto error;
1191 }
1192
1193 assert(sizeof(struct lttng_filter_bytecode) ==
1194 sizeof(struct lttng_ust_filter_bytecode));
1195 memcpy(filter, orig_f, sizeof(*filter) + orig_f->len);
1196 error:
1197 return filter;
1198 }
1199
1200 /*
1201 * Find an ust_app using the sock and return it. RCU read side lock must be
1202 * held before calling this helper function.
1203 */
1204 struct ust_app *ust_app_find_by_sock(int sock)
1205 {
1206 struct lttng_ht_node_ulong *node;
1207 struct lttng_ht_iter iter;
1208
1209 lttng_ht_lookup(ust_app_ht_by_sock, (void *)((unsigned long) sock), &iter);
1210 node = lttng_ht_iter_get_node_ulong(&iter);
1211 if (node == NULL) {
1212 DBG2("UST app find by sock %d not found", sock);
1213 goto error;
1214 }
1215
1216 return caa_container_of(node, struct ust_app, sock_n);
1217
1218 error:
1219 return NULL;
1220 }
1221
1222 /*
1223 * Find an ust_app using the notify sock and return it. RCU read side lock must
1224 * be held before calling this helper function.
1225 */
1226 static struct ust_app *find_app_by_notify_sock(int sock)
1227 {
1228 struct lttng_ht_node_ulong *node;
1229 struct lttng_ht_iter iter;
1230
1231 lttng_ht_lookup(ust_app_ht_by_notify_sock, (void *)((unsigned long) sock),
1232 &iter);
1233 node = lttng_ht_iter_get_node_ulong(&iter);
1234 if (node == NULL) {
1235 DBG2("UST app find by notify sock %d not found", sock);
1236 goto error;
1237 }
1238
1239 return caa_container_of(node, struct ust_app, notify_sock_n);
1240
1241 error:
1242 return NULL;
1243 }
1244
1245 /*
1246 * Lookup for an ust app event based on event name, filter bytecode and the
1247 * event loglevel.
1248 *
1249 * Return an ust_app_event object or NULL on error.
1250 */
1251 static struct ust_app_event *find_ust_app_event(struct lttng_ht *ht,
1252 char *name, struct lttng_filter_bytecode *filter,
1253 int loglevel_value,
1254 const struct lttng_event_exclusion *exclusion)
1255 {
1256 struct lttng_ht_iter iter;
1257 struct lttng_ht_node_str *node;
1258 struct ust_app_event *event = NULL;
1259 struct ust_app_ht_key key;
1260
1261 assert(name);
1262 assert(ht);
1263
1264 /* Setup key for event lookup. */
1265 key.name = name;
1266 key.filter = filter;
1267 key.loglevel_type = loglevel_value;
1268 /* lttng_event_exclusion and lttng_ust_event_exclusion structures are similar */
1269 key.exclusion = exclusion;
1270
1271 /* Lookup using the event name as hash and a custom match fct. */
1272 cds_lfht_lookup(ht->ht, ht->hash_fct((void *) name, lttng_ht_seed),
1273 ht_match_ust_app_event, &key, &iter.iter);
1274 node = lttng_ht_iter_get_node_str(&iter);
1275 if (node == NULL) {
1276 goto end;
1277 }
1278
1279 event = caa_container_of(node, struct ust_app_event, node);
1280
1281 end:
1282 return event;
1283 }
1284
1285 /*
1286 * Create the channel context on the tracer.
1287 *
1288 * Called with UST app session lock held.
1289 */
1290 static
1291 int create_ust_channel_context(struct ust_app_channel *ua_chan,
1292 struct ust_app_ctx *ua_ctx, struct ust_app *app)
1293 {
1294 int ret;
1295
1296 health_code_update();
1297
1298 pthread_mutex_lock(&app->sock_lock);
1299 ret = ustctl_add_context(app->sock, &ua_ctx->ctx,
1300 ua_chan->obj, &ua_ctx->obj);
1301 pthread_mutex_unlock(&app->sock_lock);
1302 if (ret < 0) {
1303 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
1304 ERR("UST app create channel context failed for app (pid: %d) "
1305 "with ret %d", app->pid, ret);
1306 } else {
1307 /*
1308 * This is normal behavior, an application can die during the
1309 * creation process. Don't report an error so the execution can
1310 * continue normally.
1311 */
1312 ret = 0;
1313 DBG3("UST app disable event failed. Application is dead.");
1314 }
1315 goto error;
1316 }
1317
1318 ua_ctx->handle = ua_ctx->obj->handle;
1319
1320 DBG2("UST app context handle %d created successfully for channel %s",
1321 ua_ctx->handle, ua_chan->name);
1322
1323 error:
1324 health_code_update();
1325 return ret;
1326 }
1327
1328 /*
1329 * Set the filter on the tracer.
1330 */
1331 static
1332 int set_ust_event_filter(struct ust_app_event *ua_event,
1333 struct ust_app *app)
1334 {
1335 int ret;
1336 struct lttng_ust_filter_bytecode *ust_bytecode = NULL;
1337
1338 health_code_update();
1339
1340 if (!ua_event->filter) {
1341 ret = 0;
1342 goto error;
1343 }
1344
1345 ust_bytecode = create_ust_bytecode_from_bytecode(ua_event->filter);
1346 if (!ust_bytecode) {
1347 ret = -LTTNG_ERR_NOMEM;
1348 goto error;
1349 }
1350 pthread_mutex_lock(&app->sock_lock);
1351 ret = ustctl_set_filter(app->sock, ust_bytecode,
1352 ua_event->obj);
1353 pthread_mutex_unlock(&app->sock_lock);
1354 if (ret < 0) {
1355 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
1356 ERR("UST app event %s filter failed for app (pid: %d) "
1357 "with ret %d", ua_event->attr.name, app->pid, ret);
1358 } else {
1359 /*
1360 * This is normal behavior, an application can die during the
1361 * creation process. Don't report an error so the execution can
1362 * continue normally.
1363 */
1364 ret = 0;
1365 DBG3("UST app filter event failed. Application is dead.");
1366 }
1367 goto error;
1368 }
1369
1370 DBG2("UST filter set successfully for event %s", ua_event->name);
1371
1372 error:
1373 health_code_update();
1374 free(ust_bytecode);
1375 return ret;
1376 }
1377
1378 static
1379 struct lttng_ust_event_exclusion *create_ust_exclusion_from_exclusion(
1380 struct lttng_event_exclusion *exclusion)
1381 {
1382 struct lttng_ust_event_exclusion *ust_exclusion = NULL;
1383 size_t exclusion_alloc_size = sizeof(struct lttng_ust_event_exclusion) +
1384 LTTNG_UST_SYM_NAME_LEN * exclusion->count;
1385
1386 ust_exclusion = zmalloc(exclusion_alloc_size);
1387 if (!ust_exclusion) {
1388 PERROR("malloc");
1389 goto end;
1390 }
1391
1392 assert(sizeof(struct lttng_event_exclusion) ==
1393 sizeof(struct lttng_ust_event_exclusion));
1394 memcpy(ust_exclusion, exclusion, exclusion_alloc_size);
1395 end:
1396 return ust_exclusion;
1397 }
1398
1399 /*
1400 * Set event exclusions on the tracer.
1401 */
1402 static
1403 int set_ust_event_exclusion(struct ust_app_event *ua_event,
1404 struct ust_app *app)
1405 {
1406 int ret;
1407 struct lttng_ust_event_exclusion *ust_exclusion = NULL;
1408
1409 health_code_update();
1410
1411 if (!ua_event->exclusion || !ua_event->exclusion->count) {
1412 ret = 0;
1413 goto error;
1414 }
1415
1416 ust_exclusion = create_ust_exclusion_from_exclusion(
1417 ua_event->exclusion);
1418 if (!ust_exclusion) {
1419 ret = -LTTNG_ERR_NOMEM;
1420 goto error;
1421 }
1422 pthread_mutex_lock(&app->sock_lock);
1423 ret = ustctl_set_exclusion(app->sock, ust_exclusion, ua_event->obj);
1424 pthread_mutex_unlock(&app->sock_lock);
1425 if (ret < 0) {
1426 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
1427 ERR("UST app event %s exclusions failed for app (pid: %d) "
1428 "with ret %d", ua_event->attr.name, app->pid, ret);
1429 } else {
1430 /*
1431 * This is normal behavior, an application can die during the
1432 * creation process. Don't report an error so the execution can
1433 * continue normally.
1434 */
1435 ret = 0;
1436 DBG3("UST app event exclusion failed. Application is dead.");
1437 }
1438 goto error;
1439 }
1440
1441 DBG2("UST exclusion set successfully for event %s", ua_event->name);
1442
1443 error:
1444 health_code_update();
1445 free(ust_exclusion);
1446 return ret;
1447 }
1448
1449 /*
1450 * Disable the specified event on to UST tracer for the UST session.
1451 */
1452 static int disable_ust_event(struct ust_app *app,
1453 struct ust_app_session *ua_sess, struct ust_app_event *ua_event)
1454 {
1455 int ret;
1456
1457 health_code_update();
1458
1459 pthread_mutex_lock(&app->sock_lock);
1460 ret = ustctl_disable(app->sock, ua_event->obj);
1461 pthread_mutex_unlock(&app->sock_lock);
1462 if (ret < 0) {
1463 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
1464 ERR("UST app event %s disable failed for app (pid: %d) "
1465 "and session handle %d with ret %d",
1466 ua_event->attr.name, app->pid, ua_sess->handle, ret);
1467 } else {
1468 /*
1469 * This is normal behavior, an application can die during the
1470 * creation process. Don't report an error so the execution can
1471 * continue normally.
1472 */
1473 ret = 0;
1474 DBG3("UST app disable event failed. Application is dead.");
1475 }
1476 goto error;
1477 }
1478
1479 DBG2("UST app event %s disabled successfully for app (pid: %d)",
1480 ua_event->attr.name, app->pid);
1481
1482 error:
1483 health_code_update();
1484 return ret;
1485 }
1486
1487 /*
1488 * Disable the specified channel on to UST tracer for the UST session.
1489 */
1490 static int disable_ust_channel(struct ust_app *app,
1491 struct ust_app_session *ua_sess, struct ust_app_channel *ua_chan)
1492 {
1493 int ret;
1494
1495 health_code_update();
1496
1497 pthread_mutex_lock(&app->sock_lock);
1498 ret = ustctl_disable(app->sock, ua_chan->obj);
1499 pthread_mutex_unlock(&app->sock_lock);
1500 if (ret < 0) {
1501 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
1502 ERR("UST app channel %s disable failed for app (pid: %d) "
1503 "and session handle %d with ret %d",
1504 ua_chan->name, app->pid, ua_sess->handle, ret);
1505 } else {
1506 /*
1507 * This is normal behavior, an application can die during the
1508 * creation process. Don't report an error so the execution can
1509 * continue normally.
1510 */
1511 ret = 0;
1512 DBG3("UST app disable channel failed. Application is dead.");
1513 }
1514 goto error;
1515 }
1516
1517 DBG2("UST app channel %s disabled successfully for app (pid: %d)",
1518 ua_chan->name, app->pid);
1519
1520 error:
1521 health_code_update();
1522 return ret;
1523 }
1524
1525 /*
1526 * Enable the specified channel on to UST tracer for the UST session.
1527 */
1528 static int enable_ust_channel(struct ust_app *app,
1529 struct ust_app_session *ua_sess, struct ust_app_channel *ua_chan)
1530 {
1531 int ret;
1532
1533 health_code_update();
1534
1535 pthread_mutex_lock(&app->sock_lock);
1536 ret = ustctl_enable(app->sock, ua_chan->obj);
1537 pthread_mutex_unlock(&app->sock_lock);
1538 if (ret < 0) {
1539 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
1540 ERR("UST app channel %s enable failed for app (pid: %d) "
1541 "and session handle %d with ret %d",
1542 ua_chan->name, app->pid, ua_sess->handle, ret);
1543 } else {
1544 /*
1545 * This is normal behavior, an application can die during the
1546 * creation process. Don't report an error so the execution can
1547 * continue normally.
1548 */
1549 ret = 0;
1550 DBG3("UST app enable channel failed. Application is dead.");
1551 }
1552 goto error;
1553 }
1554
1555 ua_chan->enabled = 1;
1556
1557 DBG2("UST app channel %s enabled successfully for app (pid: %d)",
1558 ua_chan->name, app->pid);
1559
1560 error:
1561 health_code_update();
1562 return ret;
1563 }
1564
1565 /*
1566 * Enable the specified event on to UST tracer for the UST session.
1567 */
1568 static int enable_ust_event(struct ust_app *app,
1569 struct ust_app_session *ua_sess, struct ust_app_event *ua_event)
1570 {
1571 int ret;
1572
1573 health_code_update();
1574
1575 pthread_mutex_lock(&app->sock_lock);
1576 ret = ustctl_enable(app->sock, ua_event->obj);
1577 pthread_mutex_unlock(&app->sock_lock);
1578 if (ret < 0) {
1579 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
1580 ERR("UST app event %s enable failed for app (pid: %d) "
1581 "and session handle %d with ret %d",
1582 ua_event->attr.name, app->pid, ua_sess->handle, ret);
1583 } else {
1584 /*
1585 * This is normal behavior, an application can die during the
1586 * creation process. Don't report an error so the execution can
1587 * continue normally.
1588 */
1589 ret = 0;
1590 DBG3("UST app enable event failed. Application is dead.");
1591 }
1592 goto error;
1593 }
1594
1595 DBG2("UST app event %s enabled successfully for app (pid: %d)",
1596 ua_event->attr.name, app->pid);
1597
1598 error:
1599 health_code_update();
1600 return ret;
1601 }
1602
1603 /*
1604 * Send channel and stream buffer to application.
1605 *
1606 * Return 0 on success. On error, a negative value is returned.
1607 */
1608 static int send_channel_pid_to_ust(struct ust_app *app,
1609 struct ust_app_session *ua_sess, struct ust_app_channel *ua_chan)
1610 {
1611 int ret;
1612 struct ust_app_stream *stream, *stmp;
1613
1614 assert(app);
1615 assert(ua_sess);
1616 assert(ua_chan);
1617
1618 health_code_update();
1619
1620 DBG("UST app sending channel %s to UST app sock %d", ua_chan->name,
1621 app->sock);
1622
1623 /* Send channel to the application. */
1624 ret = ust_consumer_send_channel_to_ust(app, ua_sess, ua_chan);
1625 if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
1626 ret = -ENOTCONN; /* Caused by app exiting. */
1627 goto error;
1628 } else if (ret < 0) {
1629 goto error;
1630 }
1631
1632 health_code_update();
1633
1634 /* Send all streams to application. */
1635 cds_list_for_each_entry_safe(stream, stmp, &ua_chan->streams.head, list) {
1636 ret = ust_consumer_send_stream_to_ust(app, ua_chan, stream);
1637 if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
1638 ret = -ENOTCONN; /* Caused by app exiting. */
1639 goto error;
1640 } else if (ret < 0) {
1641 goto error;
1642 }
1643 /* We don't need the stream anymore once sent to the tracer. */
1644 cds_list_del(&stream->list);
1645 delete_ust_app_stream(-1, stream, app);
1646 }
1647 /* Flag the channel that it is sent to the application. */
1648 ua_chan->is_sent = 1;
1649
1650 error:
1651 health_code_update();
1652 return ret;
1653 }
1654
1655 /*
1656 * Create the specified event onto the UST tracer for a UST session.
1657 *
1658 * Should be called with session mutex held.
1659 */
1660 static
1661 int create_ust_event(struct ust_app *app, struct ust_app_session *ua_sess,
1662 struct ust_app_channel *ua_chan, struct ust_app_event *ua_event)
1663 {
1664 int ret = 0;
1665
1666 health_code_update();
1667
1668 /* Create UST event on tracer */
1669 pthread_mutex_lock(&app->sock_lock);
1670 ret = ustctl_create_event(app->sock, &ua_event->attr, ua_chan->obj,
1671 &ua_event->obj);
1672 pthread_mutex_unlock(&app->sock_lock);
1673 if (ret < 0) {
1674 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
1675 ERR("Error ustctl create event %s for app pid: %d with ret %d",
1676 ua_event->attr.name, app->pid, ret);
1677 } else {
1678 /*
1679 * This is normal behavior, an application can die during the
1680 * creation process. Don't report an error so the execution can
1681 * continue normally.
1682 */
1683 ret = 0;
1684 DBG3("UST app create event failed. Application is dead.");
1685 }
1686 goto error;
1687 }
1688
1689 ua_event->handle = ua_event->obj->handle;
1690
1691 DBG2("UST app event %s created successfully for pid:%d",
1692 ua_event->attr.name, app->pid);
1693
1694 health_code_update();
1695
1696 /* Set filter if one is present. */
1697 if (ua_event->filter) {
1698 ret = set_ust_event_filter(ua_event, app);
1699 if (ret < 0) {
1700 goto error;
1701 }
1702 }
1703
1704 /* Set exclusions for the event */
1705 if (ua_event->exclusion) {
1706 ret = set_ust_event_exclusion(ua_event, app);
1707 if (ret < 0) {
1708 goto error;
1709 }
1710 }
1711
1712 /* If event not enabled, disable it on the tracer */
1713 if (ua_event->enabled) {
1714 /*
1715 * We now need to explicitly enable the event, since it
1716 * is now disabled at creation.
1717 */
1718 ret = enable_ust_event(app, ua_sess, ua_event);
1719 if (ret < 0) {
1720 /*
1721 * If we hit an EPERM, something is wrong with our enable call. If
1722 * we get an EEXIST, there is a problem on the tracer side since we
1723 * just created it.
1724 */
1725 switch (ret) {
1726 case -LTTNG_UST_ERR_PERM:
1727 /* Code flow problem */
1728 assert(0);
1729 case -LTTNG_UST_ERR_EXIST:
1730 /* It's OK for our use case. */
1731 ret = 0;
1732 break;
1733 default:
1734 break;
1735 }
1736 goto error;
1737 }
1738 }
1739
1740 error:
1741 health_code_update();
1742 return ret;
1743 }
1744
1745 /*
1746 * Copy data between an UST app event and a LTT event.
1747 */
1748 static void shadow_copy_event(struct ust_app_event *ua_event,
1749 struct ltt_ust_event *uevent)
1750 {
1751 size_t exclusion_alloc_size;
1752
1753 strncpy(ua_event->name, uevent->attr.name, sizeof(ua_event->name));
1754 ua_event->name[sizeof(ua_event->name) - 1] = '\0';
1755
1756 ua_event->enabled = uevent->enabled;
1757
1758 /* Copy event attributes */
1759 memcpy(&ua_event->attr, &uevent->attr, sizeof(ua_event->attr));
1760
1761 /* Copy filter bytecode */
1762 if (uevent->filter) {
1763 ua_event->filter = copy_filter_bytecode(uevent->filter);
1764 /* Filter might be NULL here in case of ENONEM. */
1765 }
1766
1767 /* Copy exclusion data */
1768 if (uevent->exclusion) {
1769 exclusion_alloc_size = sizeof(struct lttng_event_exclusion) +
1770 LTTNG_UST_SYM_NAME_LEN * uevent->exclusion->count;
1771 ua_event->exclusion = zmalloc(exclusion_alloc_size);
1772 if (ua_event->exclusion == NULL) {
1773 PERROR("malloc");
1774 } else {
1775 memcpy(ua_event->exclusion, uevent->exclusion,
1776 exclusion_alloc_size);
1777 }
1778 }
1779 }
1780
1781 /*
1782 * Copy data between an UST app channel and a LTT channel.
1783 */
1784 static void shadow_copy_channel(struct ust_app_channel *ua_chan,
1785 struct ltt_ust_channel *uchan)
1786 {
1787 struct lttng_ht_iter iter;
1788 struct ltt_ust_event *uevent;
1789 struct ltt_ust_context *uctx;
1790 struct ust_app_event *ua_event;
1791
1792 DBG2("UST app shadow copy of channel %s started", ua_chan->name);
1793
1794 strncpy(ua_chan->name, uchan->name, sizeof(ua_chan->name));
1795 ua_chan->name[sizeof(ua_chan->name) - 1] = '\0';
1796
1797 ua_chan->tracefile_size = uchan->tracefile_size;
1798 ua_chan->tracefile_count = uchan->tracefile_count;
1799
1800 /* Copy event attributes since the layout is different. */
1801 ua_chan->attr.subbuf_size = uchan->attr.subbuf_size;
1802 ua_chan->attr.num_subbuf = uchan->attr.num_subbuf;
1803 ua_chan->attr.overwrite = uchan->attr.overwrite;
1804 ua_chan->attr.switch_timer_interval = uchan->attr.switch_timer_interval;
1805 ua_chan->attr.read_timer_interval = uchan->attr.read_timer_interval;
1806 ua_chan->monitor_timer_interval = uchan->monitor_timer_interval;
1807 ua_chan->attr.output = uchan->attr.output;
1808 ua_chan->attr.blocking_timeout = uchan->attr.u.s.blocking_timeout;
1809
1810 /*
1811 * Note that the attribute channel type is not set since the channel on the
1812 * tracing registry side does not have this information.
1813 */
1814
1815 ua_chan->enabled = uchan->enabled;
1816 ua_chan->tracing_channel_id = uchan->id;
1817
1818 cds_list_for_each_entry(uctx, &uchan->ctx_list, list) {
1819 struct ust_app_ctx *ua_ctx = alloc_ust_app_ctx(&uctx->ctx);
1820
1821 if (ua_ctx == NULL) {
1822 continue;
1823 }
1824 lttng_ht_node_init_ulong(&ua_ctx->node,
1825 (unsigned long) ua_ctx->ctx.ctx);
1826 lttng_ht_add_ulong(ua_chan->ctx, &ua_ctx->node);
1827 cds_list_add_tail(&ua_ctx->list, &ua_chan->ctx_list);
1828 }
1829
1830 /* Copy all events from ltt ust channel to ust app channel */
1831 cds_lfht_for_each_entry(uchan->events->ht, &iter.iter, uevent, node.node) {
1832 ua_event = find_ust_app_event(ua_chan->events, uevent->attr.name,
1833 uevent->filter, uevent->attr.loglevel, uevent->exclusion);
1834 if (ua_event == NULL) {
1835 DBG2("UST event %s not found on shadow copy channel",
1836 uevent->attr.name);
1837 ua_event = alloc_ust_app_event(uevent->attr.name, &uevent->attr);
1838 if (ua_event == NULL) {
1839 continue;
1840 }
1841 shadow_copy_event(ua_event, uevent);
1842 add_unique_ust_app_event(ua_chan, ua_event);
1843 }
1844 }
1845
1846 DBG3("UST app shadow copy of channel %s done", ua_chan->name);
1847 }
1848
1849 /*
1850 * Copy data between a UST app session and a regular LTT session.
1851 */
1852 static void shadow_copy_session(struct ust_app_session *ua_sess,
1853 struct ltt_ust_session *usess, struct ust_app *app)
1854 {
1855 struct lttng_ht_node_str *ua_chan_node;
1856 struct lttng_ht_iter iter;
1857 struct ltt_ust_channel *uchan;
1858 struct ust_app_channel *ua_chan;
1859 time_t rawtime;
1860 struct tm *timeinfo;
1861 char datetime[16];
1862 int ret;
1863 char tmp_shm_path[PATH_MAX];
1864
1865 /* Get date and time for unique app path */
1866 time(&rawtime);
1867 timeinfo = localtime(&rawtime);
1868 strftime(datetime, sizeof(datetime), "%Y%m%d-%H%M%S", timeinfo);
1869
1870 DBG2("Shadow copy of session handle %d", ua_sess->handle);
1871
1872 ua_sess->tracing_id = usess->id;
1873 ua_sess->id = get_next_session_id();
1874 ua_sess->uid = app->uid;
1875 ua_sess->gid = app->gid;
1876 ua_sess->euid = usess->uid;
1877 ua_sess->egid = usess->gid;
1878 ua_sess->buffer_type = usess->buffer_type;
1879 ua_sess->bits_per_long = app->bits_per_long;
1880
1881 /* There is only one consumer object per session possible. */
1882 consumer_output_get(usess->consumer);
1883 ua_sess->consumer = usess->consumer;
1884
1885 ua_sess->output_traces = usess->output_traces;
1886 ua_sess->live_timer_interval = usess->live_timer_interval;
1887 copy_channel_attr_to_ustctl(&ua_sess->metadata_attr,
1888 &usess->metadata_attr);
1889
1890 switch (ua_sess->buffer_type) {
1891 case LTTNG_BUFFER_PER_PID:
1892 ret = snprintf(ua_sess->path, sizeof(ua_sess->path),
1893 DEFAULT_UST_TRACE_PID_PATH "/%s-%d-%s", app->name, app->pid,
1894 datetime);
1895 break;
1896 case LTTNG_BUFFER_PER_UID:
1897 ret = snprintf(ua_sess->path, sizeof(ua_sess->path),
1898 DEFAULT_UST_TRACE_UID_PATH, ua_sess->uid, app->bits_per_long);
1899 break;
1900 default:
1901 assert(0);
1902 goto error;
1903 }
1904 if (ret < 0) {
1905 PERROR("asprintf UST shadow copy session");
1906 assert(0);
1907 goto error;
1908 }
1909
1910 strncpy(ua_sess->root_shm_path, usess->root_shm_path,
1911 sizeof(ua_sess->root_shm_path));
1912 ua_sess->root_shm_path[sizeof(ua_sess->root_shm_path) - 1] = '\0';
1913 strncpy(ua_sess->shm_path, usess->shm_path,
1914 sizeof(ua_sess->shm_path));
1915 ua_sess->shm_path[sizeof(ua_sess->shm_path) - 1] = '\0';
1916 if (ua_sess->shm_path[0]) {
1917 switch (ua_sess->buffer_type) {
1918 case LTTNG_BUFFER_PER_PID:
1919 ret = snprintf(tmp_shm_path, sizeof(tmp_shm_path),
1920 DEFAULT_UST_TRACE_PID_PATH "/%s-%d-%s",
1921 app->name, app->pid, datetime);
1922 break;
1923 case LTTNG_BUFFER_PER_UID:
1924 ret = snprintf(tmp_shm_path, sizeof(tmp_shm_path),
1925 DEFAULT_UST_TRACE_UID_PATH,
1926 app->uid, app->bits_per_long);
1927 break;
1928 default:
1929 assert(0);
1930 goto error;
1931 }
1932 if (ret < 0) {
1933 PERROR("sprintf UST shadow copy session");
1934 assert(0);
1935 goto error;
1936 }
1937 strncat(ua_sess->shm_path, tmp_shm_path,
1938 sizeof(ua_sess->shm_path) - strlen(ua_sess->shm_path) - 1);
1939 ua_sess->shm_path[sizeof(ua_sess->shm_path) - 1] = '\0';
1940 }
1941
1942 /* Iterate over all channels in global domain. */
1943 cds_lfht_for_each_entry(usess->domain_global.channels->ht, &iter.iter,
1944 uchan, node.node) {
1945 struct lttng_ht_iter uiter;
1946
1947 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &uiter);
1948 ua_chan_node = lttng_ht_iter_get_node_str(&uiter);
1949 if (ua_chan_node != NULL) {
1950 /* Session exist. Contiuing. */
1951 continue;
1952 }
1953
1954 DBG2("Channel %s not found on shadow session copy, creating it",
1955 uchan->name);
1956 ua_chan = alloc_ust_app_channel(uchan->name, ua_sess,
1957 &uchan->attr);
1958 if (ua_chan == NULL) {
1959 /* malloc failed FIXME: Might want to do handle ENOMEM .. */
1960 continue;
1961 }
1962 shadow_copy_channel(ua_chan, uchan);
1963 /*
1964 * The concept of metadata channel does not exist on the tracing
1965 * registry side of the session daemon so this can only be a per CPU
1966 * channel and not metadata.
1967 */
1968 ua_chan->attr.type = LTTNG_UST_CHAN_PER_CPU;
1969
1970 lttng_ht_add_unique_str(ua_sess->channels, &ua_chan->node);
1971 }
1972 return;
1973
1974 error:
1975 consumer_output_put(ua_sess->consumer);
1976 }
1977
1978 /*
1979 * Lookup sesison wrapper.
1980 */
1981 static
1982 void __lookup_session_by_app(struct ltt_ust_session *usess,
1983 struct ust_app *app, struct lttng_ht_iter *iter)
1984 {
1985 /* Get right UST app session from app */
1986 lttng_ht_lookup(app->sessions, &usess->id, iter);
1987 }
1988
1989 /*
1990 * Return ust app session from the app session hashtable using the UST session
1991 * id.
1992 */
1993 static struct ust_app_session *lookup_session_by_app(
1994 struct ltt_ust_session *usess, struct ust_app *app)
1995 {
1996 struct lttng_ht_iter iter;
1997 struct lttng_ht_node_u64 *node;
1998
1999 __lookup_session_by_app(usess, app, &iter);
2000 node = lttng_ht_iter_get_node_u64(&iter);
2001 if (node == NULL) {
2002 goto error;
2003 }
2004
2005 return caa_container_of(node, struct ust_app_session, node);
2006
2007 error:
2008 return NULL;
2009 }
2010
2011 /*
2012 * Setup buffer registry per PID for the given session and application. If none
2013 * is found, a new one is created, added to the global registry and
2014 * initialized. If regp is valid, it's set with the newly created object.
2015 *
2016 * Return 0 on success or else a negative value.
2017 */
2018 static int setup_buffer_reg_pid(struct ust_app_session *ua_sess,
2019 struct ust_app *app, struct buffer_reg_pid **regp)
2020 {
2021 int ret = 0;
2022 struct buffer_reg_pid *reg_pid;
2023
2024 assert(ua_sess);
2025 assert(app);
2026
2027 rcu_read_lock();
2028
2029 reg_pid = buffer_reg_pid_find(ua_sess->id);
2030 if (!reg_pid) {
2031 /*
2032 * This is the create channel path meaning that if there is NO
2033 * registry available, we have to create one for this session.
2034 */
2035 ret = buffer_reg_pid_create(ua_sess->id, &reg_pid,
2036 ua_sess->root_shm_path, ua_sess->shm_path);
2037 if (ret < 0) {
2038 goto error;
2039 }
2040 } else {
2041 goto end;
2042 }
2043
2044 /* Initialize registry. */
2045 ret = ust_registry_session_init(&reg_pid->registry->reg.ust, app,
2046 app->bits_per_long, app->uint8_t_alignment,
2047 app->uint16_t_alignment, app->uint32_t_alignment,
2048 app->uint64_t_alignment, app->long_alignment,
2049 app->byte_order, app->version.major,
2050 app->version.minor, reg_pid->root_shm_path,
2051 reg_pid->shm_path,
2052 ua_sess->euid, ua_sess->egid);
2053 if (ret < 0) {
2054 /*
2055 * reg_pid->registry->reg.ust is NULL upon error, so we need to
2056 * destroy the buffer registry, because it is always expected
2057 * that if the buffer registry can be found, its ust registry is
2058 * non-NULL.
2059 */
2060 buffer_reg_pid_destroy(reg_pid);
2061 goto error;
2062 }
2063
2064 buffer_reg_pid_add(reg_pid);
2065
2066 DBG3("UST app buffer registry per PID created successfully");
2067
2068 end:
2069 if (regp) {
2070 *regp = reg_pid;
2071 }
2072 error:
2073 rcu_read_unlock();
2074 return ret;
2075 }
2076
2077 /*
2078 * Setup buffer registry per UID for the given session and application. If none
2079 * is found, a new one is created, added to the global registry and
2080 * initialized. If regp is valid, it's set with the newly created object.
2081 *
2082 * Return 0 on success or else a negative value.
2083 */
2084 static int setup_buffer_reg_uid(struct ltt_ust_session *usess,
2085 struct ust_app_session *ua_sess,
2086 struct ust_app *app, struct buffer_reg_uid **regp)
2087 {
2088 int ret = 0;
2089 struct buffer_reg_uid *reg_uid;
2090
2091 assert(usess);
2092 assert(app);
2093
2094 rcu_read_lock();
2095
2096 reg_uid = buffer_reg_uid_find(usess->id, app->bits_per_long, app->uid);
2097 if (!reg_uid) {
2098 /*
2099 * This is the create channel path meaning that if there is NO
2100 * registry available, we have to create one for this session.
2101 */
2102 ret = buffer_reg_uid_create(usess->id, app->bits_per_long, app->uid,
2103 LTTNG_DOMAIN_UST, &reg_uid,
2104 ua_sess->root_shm_path, ua_sess->shm_path);
2105 if (ret < 0) {
2106 goto error;
2107 }
2108 } else {
2109 goto end;
2110 }
2111
2112 /* Initialize registry. */
2113 ret = ust_registry_session_init(&reg_uid->registry->reg.ust, NULL,
2114 app->bits_per_long, app->uint8_t_alignment,
2115 app->uint16_t_alignment, app->uint32_t_alignment,
2116 app->uint64_t_alignment, app->long_alignment,
2117 app->byte_order, app->version.major,
2118 app->version.minor, reg_uid->root_shm_path,
2119 reg_uid->shm_path, usess->uid, usess->gid);
2120 if (ret < 0) {
2121 /*
2122 * reg_uid->registry->reg.ust is NULL upon error, so we need to
2123 * destroy the buffer registry, because it is always expected
2124 * that if the buffer registry can be found, its ust registry is
2125 * non-NULL.
2126 */
2127 buffer_reg_uid_destroy(reg_uid, NULL);
2128 goto error;
2129 }
2130 /* Add node to teardown list of the session. */
2131 cds_list_add(&reg_uid->lnode, &usess->buffer_reg_uid_list);
2132
2133 buffer_reg_uid_add(reg_uid);
2134
2135 DBG3("UST app buffer registry per UID created successfully");
2136 end:
2137 if (regp) {
2138 *regp = reg_uid;
2139 }
2140 error:
2141 rcu_read_unlock();
2142 return ret;
2143 }
2144
2145 /*
2146 * Create a session on the tracer side for the given app.
2147 *
2148 * On success, ua_sess_ptr is populated with the session pointer or else left
2149 * untouched. If the session was created, is_created is set to 1. On error,
2150 * it's left untouched. Note that ua_sess_ptr is mandatory but is_created can
2151 * be NULL.
2152 *
2153 * Returns 0 on success or else a negative code which is either -ENOMEM or
2154 * -ENOTCONN which is the default code if the ustctl_create_session fails.
2155 */
2156 static int create_ust_app_session(struct ltt_ust_session *usess,
2157 struct ust_app *app, struct ust_app_session **ua_sess_ptr,
2158 int *is_created)
2159 {
2160 int ret, created = 0;
2161 struct ust_app_session *ua_sess;
2162
2163 assert(usess);
2164 assert(app);
2165 assert(ua_sess_ptr);
2166
2167 health_code_update();
2168
2169 ua_sess = lookup_session_by_app(usess, app);
2170 if (ua_sess == NULL) {
2171 DBG2("UST app pid: %d session id %" PRIu64 " not found, creating it",
2172 app->pid, usess->id);
2173 ua_sess = alloc_ust_app_session(app);
2174 if (ua_sess == NULL) {
2175 /* Only malloc can failed so something is really wrong */
2176 ret = -ENOMEM;
2177 goto error;
2178 }
2179 shadow_copy_session(ua_sess, usess, app);
2180 created = 1;
2181 }
2182
2183 switch (usess->buffer_type) {
2184 case LTTNG_BUFFER_PER_PID:
2185 /* Init local registry. */
2186 ret = setup_buffer_reg_pid(ua_sess, app, NULL);
2187 if (ret < 0) {
2188 delete_ust_app_session(-1, ua_sess, app);
2189 goto error;
2190 }
2191 break;
2192 case LTTNG_BUFFER_PER_UID:
2193 /* Look for a global registry. If none exists, create one. */
2194 ret = setup_buffer_reg_uid(usess, ua_sess, app, NULL);
2195 if (ret < 0) {
2196 delete_ust_app_session(-1, ua_sess, app);
2197 goto error;
2198 }
2199 break;
2200 default:
2201 assert(0);
2202 ret = -EINVAL;
2203 goto error;
2204 }
2205
2206 health_code_update();
2207
2208 if (ua_sess->handle == -1) {
2209 pthread_mutex_lock(&app->sock_lock);
2210 ret = ustctl_create_session(app->sock);
2211 pthread_mutex_unlock(&app->sock_lock);
2212 if (ret < 0) {
2213 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
2214 ERR("Creating session for app pid %d with ret %d",
2215 app->pid, ret);
2216 } else {
2217 DBG("UST app creating session failed. Application is dead");
2218 /*
2219 * This is normal behavior, an application can die during the
2220 * creation process. Don't report an error so the execution can
2221 * continue normally. This will get flagged ENOTCONN and the
2222 * caller will handle it.
2223 */
2224 ret = 0;
2225 }
2226 delete_ust_app_session(-1, ua_sess, app);
2227 if (ret != -ENOMEM) {
2228 /*
2229 * Tracer is probably gone or got an internal error so let's
2230 * behave like it will soon unregister or not usable.
2231 */
2232 ret = -ENOTCONN;
2233 }
2234 goto error;
2235 }
2236
2237 ua_sess->handle = ret;
2238
2239 /* Add ust app session to app's HT */
2240 lttng_ht_node_init_u64(&ua_sess->node,
2241 ua_sess->tracing_id);
2242 lttng_ht_add_unique_u64(app->sessions, &ua_sess->node);
2243 lttng_ht_node_init_ulong(&ua_sess->ust_objd_node, ua_sess->handle);
2244 lttng_ht_add_unique_ulong(app->ust_sessions_objd,
2245 &ua_sess->ust_objd_node);
2246
2247 DBG2("UST app session created successfully with handle %d", ret);
2248 }
2249
2250 *ua_sess_ptr = ua_sess;
2251 if (is_created) {
2252 *is_created = created;
2253 }
2254
2255 /* Everything went well. */
2256 ret = 0;
2257
2258 error:
2259 health_code_update();
2260 return ret;
2261 }
2262
2263 /*
2264 * Match function for a hash table lookup of ust_app_ctx.
2265 *
2266 * It matches an ust app context based on the context type and, in the case
2267 * of perf counters, their name.
2268 */
2269 static int ht_match_ust_app_ctx(struct cds_lfht_node *node, const void *_key)
2270 {
2271 struct ust_app_ctx *ctx;
2272 const struct lttng_ust_context_attr *key;
2273
2274 assert(node);
2275 assert(_key);
2276
2277 ctx = caa_container_of(node, struct ust_app_ctx, node.node);
2278 key = _key;
2279
2280 /* Context type */
2281 if (ctx->ctx.ctx != key->ctx) {
2282 goto no_match;
2283 }
2284
2285 switch(key->ctx) {
2286 case LTTNG_UST_CONTEXT_PERF_THREAD_COUNTER:
2287 if (strncmp(key->u.perf_counter.name,
2288 ctx->ctx.u.perf_counter.name,
2289 sizeof(key->u.perf_counter.name))) {
2290 goto no_match;
2291 }
2292 break;
2293 case LTTNG_UST_CONTEXT_APP_CONTEXT:
2294 if (strcmp(key->u.app_ctx.provider_name,
2295 ctx->ctx.u.app_ctx.provider_name) ||
2296 strcmp(key->u.app_ctx.ctx_name,
2297 ctx->ctx.u.app_ctx.ctx_name)) {
2298 goto no_match;
2299 }
2300 break;
2301 default:
2302 break;
2303 }
2304
2305 /* Match. */
2306 return 1;
2307
2308 no_match:
2309 return 0;
2310 }
2311
2312 /*
2313 * Lookup for an ust app context from an lttng_ust_context.
2314 *
2315 * Must be called while holding RCU read side lock.
2316 * Return an ust_app_ctx object or NULL on error.
2317 */
2318 static
2319 struct ust_app_ctx *find_ust_app_context(struct lttng_ht *ht,
2320 struct lttng_ust_context_attr *uctx)
2321 {
2322 struct lttng_ht_iter iter;
2323 struct lttng_ht_node_ulong *node;
2324 struct ust_app_ctx *app_ctx = NULL;
2325
2326 assert(uctx);
2327 assert(ht);
2328
2329 /* Lookup using the lttng_ust_context_type and a custom match fct. */
2330 cds_lfht_lookup(ht->ht, ht->hash_fct((void *) uctx->ctx, lttng_ht_seed),
2331 ht_match_ust_app_ctx, uctx, &iter.iter);
2332 node = lttng_ht_iter_get_node_ulong(&iter);
2333 if (!node) {
2334 goto end;
2335 }
2336
2337 app_ctx = caa_container_of(node, struct ust_app_ctx, node);
2338
2339 end:
2340 return app_ctx;
2341 }
2342
2343 /*
2344 * Create a context for the channel on the tracer.
2345 *
2346 * Called with UST app session lock held and a RCU read side lock.
2347 */
2348 static
2349 int create_ust_app_channel_context(struct ust_app_session *ua_sess,
2350 struct ust_app_channel *ua_chan,
2351 struct lttng_ust_context_attr *uctx,
2352 struct ust_app *app)
2353 {
2354 int ret = 0;
2355 struct ust_app_ctx *ua_ctx;
2356
2357 DBG2("UST app adding context to channel %s", ua_chan->name);
2358
2359 ua_ctx = find_ust_app_context(ua_chan->ctx, uctx);
2360 if (ua_ctx) {
2361 ret = -EEXIST;
2362 goto error;
2363 }
2364
2365 ua_ctx = alloc_ust_app_ctx(uctx);
2366 if (ua_ctx == NULL) {
2367 /* malloc failed */
2368 ret = -ENOMEM;
2369 goto error;
2370 }
2371
2372 lttng_ht_node_init_ulong(&ua_ctx->node, (unsigned long) ua_ctx->ctx.ctx);
2373 lttng_ht_add_ulong(ua_chan->ctx, &ua_ctx->node);
2374 cds_list_add_tail(&ua_ctx->list, &ua_chan->ctx_list);
2375
2376 ret = create_ust_channel_context(ua_chan, ua_ctx, app);
2377 if (ret < 0) {
2378 goto error;
2379 }
2380
2381 error:
2382 return ret;
2383 }
2384
2385 /*
2386 * Enable on the tracer side a ust app event for the session and channel.
2387 *
2388 * Called with UST app session lock held.
2389 */
2390 static
2391 int enable_ust_app_event(struct ust_app_session *ua_sess,
2392 struct ust_app_event *ua_event, struct ust_app *app)
2393 {
2394 int ret;
2395
2396 ret = enable_ust_event(app, ua_sess, ua_event);
2397 if (ret < 0) {
2398 goto error;
2399 }
2400
2401 ua_event->enabled = 1;
2402
2403 error:
2404 return ret;
2405 }
2406
2407 /*
2408 * Disable on the tracer side a ust app event for the session and channel.
2409 */
2410 static int disable_ust_app_event(struct ust_app_session *ua_sess,
2411 struct ust_app_event *ua_event, struct ust_app *app)
2412 {
2413 int ret;
2414
2415 ret = disable_ust_event(app, ua_sess, ua_event);
2416 if (ret < 0) {
2417 goto error;
2418 }
2419
2420 ua_event->enabled = 0;
2421
2422 error:
2423 return ret;
2424 }
2425
2426 /*
2427 * Lookup ust app channel for session and disable it on the tracer side.
2428 */
2429 static
2430 int disable_ust_app_channel(struct ust_app_session *ua_sess,
2431 struct ust_app_channel *ua_chan, struct ust_app *app)
2432 {
2433 int ret;
2434
2435 ret = disable_ust_channel(app, ua_sess, ua_chan);
2436 if (ret < 0) {
2437 goto error;
2438 }
2439
2440 ua_chan->enabled = 0;
2441
2442 error:
2443 return ret;
2444 }
2445
2446 /*
2447 * Lookup ust app channel for session and enable it on the tracer side. This
2448 * MUST be called with a RCU read side lock acquired.
2449 */
2450 static int enable_ust_app_channel(struct ust_app_session *ua_sess,
2451 struct ltt_ust_channel *uchan, struct ust_app *app)
2452 {
2453 int ret = 0;
2454 struct lttng_ht_iter iter;
2455 struct lttng_ht_node_str *ua_chan_node;
2456 struct ust_app_channel *ua_chan;
2457
2458 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &iter);
2459 ua_chan_node = lttng_ht_iter_get_node_str(&iter);
2460 if (ua_chan_node == NULL) {
2461 DBG2("Unable to find channel %s in ust session id %" PRIu64,
2462 uchan->name, ua_sess->tracing_id);
2463 goto error;
2464 }
2465
2466 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
2467
2468 ret = enable_ust_channel(app, ua_sess, ua_chan);
2469 if (ret < 0) {
2470 goto error;
2471 }
2472
2473 error:
2474 return ret;
2475 }
2476
2477 /*
2478 * Ask the consumer to create a channel and get it if successful.
2479 *
2480 * Called with UST app session lock held.
2481 *
2482 * Return 0 on success or else a negative value.
2483 */
2484 static int do_consumer_create_channel(struct ltt_ust_session *usess,
2485 struct ust_app_session *ua_sess, struct ust_app_channel *ua_chan,
2486 int bitness, struct ust_registry_session *registry)
2487 {
2488 int ret;
2489 unsigned int nb_fd = 0;
2490 struct consumer_socket *socket;
2491
2492 assert(usess);
2493 assert(ua_sess);
2494 assert(ua_chan);
2495 assert(registry);
2496
2497 rcu_read_lock();
2498 health_code_update();
2499
2500 /* Get the right consumer socket for the application. */
2501 socket = consumer_find_socket_by_bitness(bitness, usess->consumer);
2502 if (!socket) {
2503 ret = -EINVAL;
2504 goto error;
2505 }
2506
2507 health_code_update();
2508
2509 /* Need one fd for the channel. */
2510 ret = lttng_fd_get(LTTNG_FD_APPS, 1);
2511 if (ret < 0) {
2512 ERR("Exhausted number of available FD upon create channel");
2513 goto error;
2514 }
2515
2516 /*
2517 * Ask consumer to create channel. The consumer will return the number of
2518 * stream we have to expect.
2519 */
2520 ret = ust_consumer_ask_channel(ua_sess, ua_chan, usess->consumer, socket,
2521 registry);
2522 if (ret < 0) {
2523 goto error_ask;
2524 }
2525
2526 /*
2527 * Compute the number of fd needed before receiving them. It must be 2 per
2528 * stream (2 being the default value here).
2529 */
2530 nb_fd = DEFAULT_UST_STREAM_FD_NUM * ua_chan->expected_stream_count;
2531
2532 /* Reserve the amount of file descriptor we need. */
2533 ret = lttng_fd_get(LTTNG_FD_APPS, nb_fd);
2534 if (ret < 0) {
2535 ERR("Exhausted number of available FD upon create channel");
2536 goto error_fd_get_stream;
2537 }
2538
2539 health_code_update();
2540
2541 /*
2542 * Now get the channel from the consumer. This call wil populate the stream
2543 * list of that channel and set the ust objects.
2544 */
2545 if (usess->consumer->enabled) {
2546 ret = ust_consumer_get_channel(socket, ua_chan);
2547 if (ret < 0) {
2548 goto error_destroy;
2549 }
2550 }
2551
2552 rcu_read_unlock();
2553 return 0;
2554
2555 error_destroy:
2556 lttng_fd_put(LTTNG_FD_APPS, nb_fd);
2557 error_fd_get_stream:
2558 /*
2559 * Initiate a destroy channel on the consumer since we had an error
2560 * handling it on our side. The return value is of no importance since we
2561 * already have a ret value set by the previous error that we need to
2562 * return.
2563 */
2564 (void) ust_consumer_destroy_channel(socket, ua_chan);
2565 error_ask:
2566 lttng_fd_put(LTTNG_FD_APPS, 1);
2567 error:
2568 health_code_update();
2569 rcu_read_unlock();
2570 return ret;
2571 }
2572
2573 /*
2574 * Duplicate the ust data object of the ust app stream and save it in the
2575 * buffer registry stream.
2576 *
2577 * Return 0 on success or else a negative value.
2578 */
2579 static int duplicate_stream_object(struct buffer_reg_stream *reg_stream,
2580 struct ust_app_stream *stream)
2581 {
2582 int ret;
2583
2584 assert(reg_stream);
2585 assert(stream);
2586
2587 /* Reserve the amount of file descriptor we need. */
2588 ret = lttng_fd_get(LTTNG_FD_APPS, 2);
2589 if (ret < 0) {
2590 ERR("Exhausted number of available FD upon duplicate stream");
2591 goto error;
2592 }
2593
2594 /* Duplicate object for stream once the original is in the registry. */
2595 ret = ustctl_duplicate_ust_object_data(&stream->obj,
2596 reg_stream->obj.ust);
2597 if (ret < 0) {
2598 ERR("Duplicate stream obj from %p to %p failed with ret %d",
2599 reg_stream->obj.ust, stream->obj, ret);
2600 lttng_fd_put(LTTNG_FD_APPS, 2);
2601 goto error;
2602 }
2603 stream->handle = stream->obj->handle;
2604
2605 error:
2606 return ret;
2607 }
2608
2609 /*
2610 * Duplicate the ust data object of the ust app. channel and save it in the
2611 * buffer registry channel.
2612 *
2613 * Return 0 on success or else a negative value.
2614 */
2615 static int duplicate_channel_object(struct buffer_reg_channel *reg_chan,
2616 struct ust_app_channel *ua_chan)
2617 {
2618 int ret;
2619
2620 assert(reg_chan);
2621 assert(ua_chan);
2622
2623 /* Need two fds for the channel. */
2624 ret = lttng_fd_get(LTTNG_FD_APPS, 1);
2625 if (ret < 0) {
2626 ERR("Exhausted number of available FD upon duplicate channel");
2627 goto error_fd_get;
2628 }
2629
2630 /* Duplicate object for stream once the original is in the registry. */
2631 ret = ustctl_duplicate_ust_object_data(&ua_chan->obj, reg_chan->obj.ust);
2632 if (ret < 0) {
2633 ERR("Duplicate channel obj from %p to %p failed with ret: %d",
2634 reg_chan->obj.ust, ua_chan->obj, ret);
2635 goto error;
2636 }
2637 ua_chan->handle = ua_chan->obj->handle;
2638
2639 return 0;
2640
2641 error:
2642 lttng_fd_put(LTTNG_FD_APPS, 1);
2643 error_fd_get:
2644 return ret;
2645 }
2646
2647 /*
2648 * For a given channel buffer registry, setup all streams of the given ust
2649 * application channel.
2650 *
2651 * Return 0 on success or else a negative value.
2652 */
2653 static int setup_buffer_reg_streams(struct buffer_reg_channel *reg_chan,
2654 struct ust_app_channel *ua_chan,
2655 struct ust_app *app)
2656 {
2657 int ret = 0;
2658 struct ust_app_stream *stream, *stmp;
2659
2660 assert(reg_chan);
2661 assert(ua_chan);
2662
2663 DBG2("UST app setup buffer registry stream");
2664
2665 /* Send all streams to application. */
2666 cds_list_for_each_entry_safe(stream, stmp, &ua_chan->streams.head, list) {
2667 struct buffer_reg_stream *reg_stream;
2668
2669 ret = buffer_reg_stream_create(&reg_stream);
2670 if (ret < 0) {
2671 goto error;
2672 }
2673
2674 /*
2675 * Keep original pointer and nullify it in the stream so the delete
2676 * stream call does not release the object.
2677 */
2678 reg_stream->obj.ust = stream->obj;
2679 stream->obj = NULL;
2680 buffer_reg_stream_add(reg_stream, reg_chan);
2681
2682 /* We don't need the streams anymore. */
2683 cds_list_del(&stream->list);
2684 delete_ust_app_stream(-1, stream, app);
2685 }
2686
2687 error:
2688 return ret;
2689 }
2690
2691 /*
2692 * Create a buffer registry channel for the given session registry and
2693 * application channel object. If regp pointer is valid, it's set with the
2694 * created object. Important, the created object is NOT added to the session
2695 * registry hash table.
2696 *
2697 * Return 0 on success else a negative value.
2698 */
2699 static int create_buffer_reg_channel(struct buffer_reg_session *reg_sess,
2700 struct ust_app_channel *ua_chan, struct buffer_reg_channel **regp)
2701 {
2702 int ret;
2703 struct buffer_reg_channel *reg_chan = NULL;
2704
2705 assert(reg_sess);
2706 assert(ua_chan);
2707
2708 DBG2("UST app creating buffer registry channel for %s", ua_chan->name);
2709
2710 /* Create buffer registry channel. */
2711 ret = buffer_reg_channel_create(ua_chan->tracing_channel_id, &reg_chan);
2712 if (ret < 0) {
2713 goto error_create;
2714 }
2715 assert(reg_chan);
2716 reg_chan->consumer_key = ua_chan->key;
2717 reg_chan->subbuf_size = ua_chan->attr.subbuf_size;
2718 reg_chan->num_subbuf = ua_chan->attr.num_subbuf;
2719
2720 /* Create and add a channel registry to session. */
2721 ret = ust_registry_channel_add(reg_sess->reg.ust,
2722 ua_chan->tracing_channel_id);
2723 if (ret < 0) {
2724 goto error;
2725 }
2726 buffer_reg_channel_add(reg_sess, reg_chan);
2727
2728 if (regp) {
2729 *regp = reg_chan;
2730 }
2731
2732 return 0;
2733
2734 error:
2735 /* Safe because the registry channel object was not added to any HT. */
2736 buffer_reg_channel_destroy(reg_chan, LTTNG_DOMAIN_UST);
2737 error_create:
2738 return ret;
2739 }
2740
2741 /*
2742 * Setup buffer registry channel for the given session registry and application
2743 * channel object. If regp pointer is valid, it's set with the created object.
2744 *
2745 * Return 0 on success else a negative value.
2746 */
2747 static int setup_buffer_reg_channel(struct buffer_reg_session *reg_sess,
2748 struct ust_app_channel *ua_chan, struct buffer_reg_channel *reg_chan,
2749 struct ust_app *app)
2750 {
2751 int ret;
2752
2753 assert(reg_sess);
2754 assert(reg_chan);
2755 assert(ua_chan);
2756 assert(ua_chan->obj);
2757
2758 DBG2("UST app setup buffer registry channel for %s", ua_chan->name);
2759
2760 /* Setup all streams for the registry. */
2761 ret = setup_buffer_reg_streams(reg_chan, ua_chan, app);
2762 if (ret < 0) {
2763 goto error;
2764 }
2765
2766 reg_chan->obj.ust = ua_chan->obj;
2767 ua_chan->obj = NULL;
2768
2769 return 0;
2770
2771 error:
2772 buffer_reg_channel_remove(reg_sess, reg_chan);
2773 buffer_reg_channel_destroy(reg_chan, LTTNG_DOMAIN_UST);
2774 return ret;
2775 }
2776
2777 /*
2778 * Send buffer registry channel to the application.
2779 *
2780 * Return 0 on success else a negative value.
2781 */
2782 static int send_channel_uid_to_ust(struct buffer_reg_channel *reg_chan,
2783 struct ust_app *app, struct ust_app_session *ua_sess,
2784 struct ust_app_channel *ua_chan)
2785 {
2786 int ret;
2787 struct buffer_reg_stream *reg_stream;
2788
2789 assert(reg_chan);
2790 assert(app);
2791 assert(ua_sess);
2792 assert(ua_chan);
2793
2794 DBG("UST app sending buffer registry channel to ust sock %d", app->sock);
2795
2796 ret = duplicate_channel_object(reg_chan, ua_chan);
2797 if (ret < 0) {
2798 goto error;
2799 }
2800
2801 /* Send channel to the application. */
2802 ret = ust_consumer_send_channel_to_ust(app, ua_sess, ua_chan);
2803 if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
2804 ret = -ENOTCONN; /* Caused by app exiting. */
2805 goto error;
2806 } else if (ret < 0) {
2807 goto error;
2808 }
2809
2810 health_code_update();
2811
2812 /* Send all streams to application. */
2813 pthread_mutex_lock(&reg_chan->stream_list_lock);
2814 cds_list_for_each_entry(reg_stream, &reg_chan->streams, lnode) {
2815 struct ust_app_stream stream;
2816
2817 ret = duplicate_stream_object(reg_stream, &stream);
2818 if (ret < 0) {
2819 goto error_stream_unlock;
2820 }
2821
2822 ret = ust_consumer_send_stream_to_ust(app, ua_chan, &stream);
2823 if (ret < 0) {
2824 (void) release_ust_app_stream(-1, &stream, app);
2825 if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
2826 ret = -ENOTCONN; /* Caused by app exiting. */
2827 }
2828 goto error_stream_unlock;
2829 }
2830
2831 /*
2832 * The return value is not important here. This function will output an
2833 * error if needed.
2834 */
2835 (void) release_ust_app_stream(-1, &stream, app);
2836 }
2837 ua_chan->is_sent = 1;
2838
2839 error_stream_unlock:
2840 pthread_mutex_unlock(&reg_chan->stream_list_lock);
2841 error:
2842 return ret;
2843 }
2844
2845 /*
2846 * Create and send to the application the created buffers with per UID buffers.
2847 *
2848 * This MUST be called with a RCU read side lock acquired.
2849 *
2850 * Return 0 on success else a negative value.
2851 */
2852 static int create_channel_per_uid(struct ust_app *app,
2853 struct ltt_ust_session *usess, struct ust_app_session *ua_sess,
2854 struct ust_app_channel *ua_chan)
2855 {
2856 int ret;
2857 struct buffer_reg_uid *reg_uid;
2858 struct buffer_reg_channel *reg_chan;
2859 bool created = false;
2860
2861 assert(app);
2862 assert(usess);
2863 assert(ua_sess);
2864 assert(ua_chan);
2865
2866 DBG("UST app creating channel %s with per UID buffers", ua_chan->name);
2867
2868 reg_uid = buffer_reg_uid_find(usess->id, app->bits_per_long, app->uid);
2869 /*
2870 * The session creation handles the creation of this global registry
2871 * object. If none can be find, there is a code flow problem or a
2872 * teardown race.
2873 */
2874 assert(reg_uid);
2875
2876 reg_chan = buffer_reg_channel_find(ua_chan->tracing_channel_id,
2877 reg_uid);
2878 if (!reg_chan) {
2879 /* Create the buffer registry channel object. */
2880 ret = create_buffer_reg_channel(reg_uid->registry, ua_chan, &reg_chan);
2881 if (ret < 0) {
2882 ERR("Error creating the UST channel \"%s\" registry instance",
2883 ua_chan->name);
2884 goto error;
2885 }
2886 assert(reg_chan);
2887
2888 /*
2889 * Create the buffers on the consumer side. This call populates the
2890 * ust app channel object with all streams and data object.
2891 */
2892 ret = do_consumer_create_channel(usess, ua_sess, ua_chan,
2893 app->bits_per_long, reg_uid->registry->reg.ust);
2894 if (ret < 0) {
2895 ERR("Error creating UST channel \"%s\" on the consumer daemon",
2896 ua_chan->name);
2897
2898 /*
2899 * Let's remove the previously created buffer registry channel so
2900 * it's not visible anymore in the session registry.
2901 */
2902 ust_registry_channel_del_free(reg_uid->registry->reg.ust,
2903 ua_chan->tracing_channel_id, false);
2904 buffer_reg_channel_remove(reg_uid->registry, reg_chan);
2905 buffer_reg_channel_destroy(reg_chan, LTTNG_DOMAIN_UST);
2906 goto error;
2907 }
2908
2909 /*
2910 * Setup the streams and add it to the session registry.
2911 */
2912 ret = setup_buffer_reg_channel(reg_uid->registry,
2913 ua_chan, reg_chan, app);
2914 if (ret < 0) {
2915 ERR("Error setting up UST channel \"%s\"",
2916 ua_chan->name);
2917 goto error;
2918 }
2919 created = true;
2920 }
2921
2922 if (created) {
2923 enum lttng_error_code cmd_ret;
2924 struct ltt_session *session;
2925 uint64_t chan_reg_key;
2926 struct ust_registry_channel *chan_reg;
2927
2928 rcu_read_lock();
2929 chan_reg_key = ua_chan->tracing_channel_id;
2930
2931 pthread_mutex_lock(&reg_uid->registry->reg.ust->lock);
2932 chan_reg = ust_registry_channel_find(reg_uid->registry->reg.ust,
2933 chan_reg_key);
2934 assert(chan_reg);
2935 chan_reg->consumer_key = ua_chan->key;
2936 chan_reg = NULL;
2937 pthread_mutex_unlock(&reg_uid->registry->reg.ust->lock);
2938
2939 session = session_find_by_id(ua_sess->tracing_id);
2940 assert(session);
2941
2942 cmd_ret = notification_thread_command_add_channel(
2943 notification_thread_handle, session->name,
2944 ua_sess->euid, ua_sess->egid,
2945 ua_chan->name,
2946 ua_chan->key,
2947 LTTNG_DOMAIN_UST,
2948 ua_chan->attr.subbuf_size * ua_chan->attr.num_subbuf);
2949 rcu_read_unlock();
2950 if (cmd_ret != LTTNG_OK) {
2951 ret = - (int) cmd_ret;
2952 ERR("Failed to add channel to notification thread");
2953 goto error;
2954 }
2955 }
2956
2957 /* Send buffers to the application. */
2958 ret = send_channel_uid_to_ust(reg_chan, app, ua_sess, ua_chan);
2959 if (ret < 0) {
2960 if (ret != -ENOTCONN) {
2961 ERR("Error sending channel to application");
2962 }
2963 goto error;
2964 }
2965
2966 error:
2967 return ret;
2968 }
2969
2970 /*
2971 * Create and send to the application the created buffers with per PID buffers.
2972 *
2973 * Called with UST app session lock held.
2974 *
2975 * Return 0 on success else a negative value.
2976 */
2977 static int create_channel_per_pid(struct ust_app *app,
2978 struct ltt_ust_session *usess, struct ust_app_session *ua_sess,
2979 struct ust_app_channel *ua_chan)
2980 {
2981 int ret;
2982 struct ust_registry_session *registry;
2983 enum lttng_error_code cmd_ret;
2984 struct ltt_session *session;
2985 uint64_t chan_reg_key;
2986 struct ust_registry_channel *chan_reg;
2987
2988 assert(app);
2989 assert(usess);
2990 assert(ua_sess);
2991 assert(ua_chan);
2992
2993 DBG("UST app creating channel %s with per PID buffers", ua_chan->name);
2994
2995 rcu_read_lock();
2996
2997 registry = get_session_registry(ua_sess);
2998 /* The UST app session lock is held, registry shall not be null. */
2999 assert(registry);
3000
3001 /* Create and add a new channel registry to session. */
3002 ret = ust_registry_channel_add(registry, ua_chan->key);
3003 if (ret < 0) {
3004 ERR("Error creating the UST channel \"%s\" registry instance",
3005 ua_chan->name);
3006 goto error;
3007 }
3008
3009 /* Create and get channel on the consumer side. */
3010 ret = do_consumer_create_channel(usess, ua_sess, ua_chan,
3011 app->bits_per_long, registry);
3012 if (ret < 0) {
3013 ERR("Error creating UST channel \"%s\" on the consumer daemon",
3014 ua_chan->name);
3015 goto error;
3016 }
3017
3018 ret = send_channel_pid_to_ust(app, ua_sess, ua_chan);
3019 if (ret < 0) {
3020 if (ret != -ENOTCONN) {
3021 ERR("Error sending channel to application");
3022 }
3023 goto error;
3024 }
3025
3026 session = session_find_by_id(ua_sess->tracing_id);
3027 assert(session);
3028
3029 chan_reg_key = ua_chan->key;
3030 pthread_mutex_lock(&registry->lock);
3031 chan_reg = ust_registry_channel_find(registry, chan_reg_key);
3032 assert(chan_reg);
3033 chan_reg->consumer_key = ua_chan->key;
3034 pthread_mutex_unlock(&registry->lock);
3035
3036 cmd_ret = notification_thread_command_add_channel(
3037 notification_thread_handle, session->name,
3038 ua_sess->euid, ua_sess->egid,
3039 ua_chan->name,
3040 ua_chan->key,
3041 LTTNG_DOMAIN_UST,
3042 ua_chan->attr.subbuf_size * ua_chan->attr.num_subbuf);
3043 if (cmd_ret != LTTNG_OK) {
3044 ret = - (int) cmd_ret;
3045 ERR("Failed to add channel to notification thread");
3046 goto error;
3047 }
3048
3049 error:
3050 rcu_read_unlock();
3051 return ret;
3052 }
3053
3054 /*
3055 * From an already allocated ust app channel, create the channel buffers if
3056 * need and send it to the application. This MUST be called with a RCU read
3057 * side lock acquired.
3058 *
3059 * Called with UST app session lock held.
3060 *
3061 * Return 0 on success or else a negative value. Returns -ENOTCONN if
3062 * the application exited concurrently.
3063 */
3064 static int do_create_channel(struct ust_app *app,
3065 struct ltt_ust_session *usess, struct ust_app_session *ua_sess,
3066 struct ust_app_channel *ua_chan)
3067 {
3068 int ret;
3069
3070 assert(app);
3071 assert(usess);
3072 assert(ua_sess);
3073 assert(ua_chan);
3074
3075 /* Handle buffer type before sending the channel to the application. */
3076 switch (usess->buffer_type) {
3077 case LTTNG_BUFFER_PER_UID:
3078 {
3079 ret = create_channel_per_uid(app, usess, ua_sess, ua_chan);
3080 if (ret < 0) {
3081 goto error;
3082 }
3083 break;
3084 }
3085 case LTTNG_BUFFER_PER_PID:
3086 {
3087 ret = create_channel_per_pid(app, usess, ua_sess, ua_chan);
3088 if (ret < 0) {
3089 goto error;
3090 }
3091 break;
3092 }
3093 default:
3094 assert(0);
3095 ret = -EINVAL;
3096 goto error;
3097 }
3098
3099 /* Initialize ust objd object using the received handle and add it. */
3100 lttng_ht_node_init_ulong(&ua_chan->ust_objd_node, ua_chan->handle);
3101 lttng_ht_add_unique_ulong(app->ust_objd, &ua_chan->ust_objd_node);
3102
3103 /* If channel is not enabled, disable it on the tracer */
3104 if (!ua_chan->enabled) {
3105 ret = disable_ust_channel(app, ua_sess, ua_chan);
3106 if (ret < 0) {
3107 goto error;
3108 }
3109 }
3110
3111 error:
3112 return ret;
3113 }
3114
3115 /*
3116 * Create UST app channel and create it on the tracer. Set ua_chanp of the
3117 * newly created channel if not NULL.
3118 *
3119 * Called with UST app session lock and RCU read-side lock held.
3120 *
3121 * Return 0 on success or else a negative value. Returns -ENOTCONN if
3122 * the application exited concurrently.
3123 */
3124 static int create_ust_app_channel(struct ust_app_session *ua_sess,
3125 struct ltt_ust_channel *uchan, struct ust_app *app,
3126 enum lttng_ust_chan_type type, struct ltt_ust_session *usess,
3127 struct ust_app_channel **ua_chanp)
3128 {
3129 int ret = 0;
3130 struct lttng_ht_iter iter;
3131 struct lttng_ht_node_str *ua_chan_node;
3132 struct ust_app_channel *ua_chan;
3133
3134 /* Lookup channel in the ust app session */
3135 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &iter);
3136 ua_chan_node = lttng_ht_iter_get_node_str(&iter);
3137 if (ua_chan_node != NULL) {
3138 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
3139 goto end;
3140 }
3141
3142 ua_chan = alloc_ust_app_channel(uchan->name, ua_sess, &uchan->attr);
3143 if (ua_chan == NULL) {
3144 /* Only malloc can fail here */
3145 ret = -ENOMEM;
3146 goto error_alloc;
3147 }
3148 shadow_copy_channel(ua_chan, uchan);
3149
3150 /* Set channel type. */
3151 ua_chan->attr.type = type;
3152
3153 ret = do_create_channel(app, usess, ua_sess, ua_chan);
3154 if (ret < 0) {
3155 goto error;
3156 }
3157
3158 DBG2("UST app create channel %s for PID %d completed", ua_chan->name,
3159 app->pid);
3160
3161 /* Only add the channel if successful on the tracer side. */
3162 lttng_ht_add_unique_str(ua_sess->channels, &ua_chan->node);
3163 end:
3164 if (ua_chanp) {
3165 *ua_chanp = ua_chan;
3166 }
3167
3168 /* Everything went well. */
3169 return 0;
3170
3171 error:
3172 delete_ust_app_channel(ua_chan->is_sent ? app->sock : -1, ua_chan, app);
3173 error_alloc:
3174 return ret;
3175 }
3176
3177 /*
3178 * Create UST app event and create it on the tracer side.
3179 *
3180 * Called with ust app session mutex held.
3181 */
3182 static
3183 int create_ust_app_event(struct ust_app_session *ua_sess,
3184 struct ust_app_channel *ua_chan, struct ltt_ust_event *uevent,
3185 struct ust_app *app)
3186 {
3187 int ret = 0;
3188 struct ust_app_event *ua_event;
3189
3190 /* Get event node */
3191 ua_event = find_ust_app_event(ua_chan->events, uevent->attr.name,
3192 uevent->filter, uevent->attr.loglevel, uevent->exclusion);
3193 if (ua_event != NULL) {
3194 ret = -EEXIST;
3195 goto end;
3196 }
3197
3198 /* Does not exist so create one */
3199 ua_event = alloc_ust_app_event(uevent->attr.name, &uevent->attr);
3200 if (ua_event == NULL) {
3201 /* Only malloc can failed so something is really wrong */
3202 ret = -ENOMEM;
3203 goto end;
3204 }
3205 shadow_copy_event(ua_event, uevent);
3206
3207 /* Create it on the tracer side */
3208 ret = create_ust_event(app, ua_sess, ua_chan, ua_event);
3209 if (ret < 0) {
3210 /* Not found previously means that it does not exist on the tracer */
3211 assert(ret != -LTTNG_UST_ERR_EXIST);
3212 goto error;
3213 }
3214
3215 add_unique_ust_app_event(ua_chan, ua_event);
3216
3217 DBG2("UST app create event %s for PID %d completed", ua_event->name,
3218 app->pid);
3219
3220 end:
3221 return ret;
3222
3223 error:
3224 /* Valid. Calling here is already in a read side lock */
3225 delete_ust_app_event(-1, ua_event, app);
3226 return ret;
3227 }
3228
3229 /*
3230 * Create UST metadata and open it on the tracer side.
3231 *
3232 * Called with UST app session lock held and RCU read side lock.
3233 */
3234 static int create_ust_app_metadata(struct ust_app_session *ua_sess,
3235 struct ust_app *app, struct consumer_output *consumer)
3236 {
3237 int ret = 0;
3238 struct ust_app_channel *metadata;
3239 struct consumer_socket *socket;
3240 struct ust_registry_session *registry;
3241
3242 assert(ua_sess);
3243 assert(app);
3244 assert(consumer);
3245
3246 registry = get_session_registry(ua_sess);
3247 /* The UST app session is held registry shall not be null. */
3248 assert(registry);
3249
3250 pthread_mutex_lock(&registry->lock);
3251
3252 /* Metadata already exists for this registry or it was closed previously */
3253 if (registry->metadata_key || registry->metadata_closed) {
3254 ret = 0;
3255 goto error;
3256 }
3257
3258 /* Allocate UST metadata */
3259 metadata = alloc_ust_app_channel(DEFAULT_METADATA_NAME, ua_sess, NULL);
3260 if (!metadata) {
3261 /* malloc() failed */
3262 ret = -ENOMEM;
3263 goto error;
3264 }
3265
3266 memcpy(&metadata->attr, &ua_sess->metadata_attr, sizeof(metadata->attr));
3267
3268 /* Need one fd for the channel. */
3269 ret = lttng_fd_get(LTTNG_FD_APPS, 1);
3270 if (ret < 0) {
3271 ERR("Exhausted number of available FD upon create metadata");
3272 goto error;
3273 }
3274
3275 /* Get the right consumer socket for the application. */
3276 socket = consumer_find_socket_by_bitness(app->bits_per_long, consumer);
3277 if (!socket) {
3278 ret = -EINVAL;
3279 goto error_consumer;
3280 }
3281
3282 /*
3283 * Keep metadata key so we can identify it on the consumer side. Assign it
3284 * to the registry *before* we ask the consumer so we avoid the race of the
3285 * consumer requesting the metadata and the ask_channel call on our side
3286 * did not returned yet.
3287 */
3288 registry->metadata_key = metadata->key;
3289
3290 /*
3291 * Ask the metadata channel creation to the consumer. The metadata object
3292 * will be created by the consumer and kept their. However, the stream is
3293 * never added or monitored until we do a first push metadata to the
3294 * consumer.
3295 */
3296 ret = ust_consumer_ask_channel(ua_sess, metadata, consumer, socket,
3297 registry);
3298 if (ret < 0) {
3299 /* Nullify the metadata key so we don't try to close it later on. */
3300 registry->metadata_key = 0;
3301 goto error_consumer;
3302 }
3303
3304 /*
3305 * The setup command will make the metadata stream be sent to the relayd,
3306 * if applicable, and the thread managing the metadatas. This is important
3307 * because after this point, if an error occurs, the only way the stream
3308 * can be deleted is to be monitored in the consumer.
3309 */
3310 ret = consumer_setup_metadata(socket, metadata->key);
3311 if (ret < 0) {
3312 /* Nullify the metadata key so we don't try to close it later on. */
3313 registry->metadata_key = 0;
3314 goto error_consumer;
3315 }
3316
3317 DBG2("UST metadata with key %" PRIu64 " created for app pid %d",
3318 metadata->key, app->pid);
3319
3320 error_consumer:
3321 lttng_fd_put(LTTNG_FD_APPS, 1);
3322 delete_ust_app_channel(-1, metadata, app);
3323 error:
3324 pthread_mutex_unlock(&registry->lock);
3325 return ret;
3326 }
3327
3328 /*
3329 * Return ust app pointer or NULL if not found. RCU read side lock MUST be
3330 * acquired before calling this function.
3331 */
3332 struct ust_app *ust_app_find_by_pid(pid_t pid)
3333 {
3334 struct ust_app *app = NULL;
3335 struct lttng_ht_node_ulong *node;
3336 struct lttng_ht_iter iter;
3337
3338 lttng_ht_lookup(ust_app_ht, (void *)((unsigned long) pid), &iter);
3339 node = lttng_ht_iter_get_node_ulong(&iter);
3340 if (node == NULL) {
3341 DBG2("UST app no found with pid %d", pid);
3342 goto error;
3343 }
3344
3345 DBG2("Found UST app by pid %d", pid);
3346
3347 app = caa_container_of(node, struct ust_app, pid_n);
3348
3349 error:
3350 return app;
3351 }
3352
3353 /*
3354 * Allocate and init an UST app object using the registration information and
3355 * the command socket. This is called when the command socket connects to the
3356 * session daemon.
3357 *
3358 * The object is returned on success or else NULL.
3359 */
3360 struct ust_app *ust_app_create(struct ust_register_msg *msg, int sock)
3361 {
3362 struct ust_app *lta = NULL;
3363
3364 assert(msg);
3365 assert(sock >= 0);
3366
3367 DBG3("UST app creating application for socket %d", sock);
3368
3369 if ((msg->bits_per_long == 64 &&
3370 (uatomic_read(&ust_consumerd64_fd) == -EINVAL))
3371 || (msg->bits_per_long == 32 &&
3372 (uatomic_read(&ust_consumerd32_fd) == -EINVAL))) {
3373 ERR("Registration failed: application \"%s\" (pid: %d) has "
3374 "%d-bit long, but no consumerd for this size is available.\n",
3375 msg->name, msg->pid, msg->bits_per_long);
3376 goto error;
3377 }
3378
3379 lta = zmalloc(sizeof(struct ust_app));
3380 if (lta == NULL) {
3381 PERROR("malloc");
3382 goto error;
3383 }
3384
3385 lta->ppid = msg->ppid;
3386 lta->uid = msg->uid;
3387 lta->gid = msg->gid;
3388
3389 lta->bits_per_long = msg->bits_per_long;
3390 lta->uint8_t_alignment = msg->uint8_t_alignment;
3391 lta->uint16_t_alignment = msg->uint16_t_alignment;
3392 lta->uint32_t_alignment = msg->uint32_t_alignment;
3393 lta->uint64_t_alignment = msg->uint64_t_alignment;
3394 lta->long_alignment = msg->long_alignment;
3395 lta->byte_order = msg->byte_order;
3396
3397 lta->v_major = msg->major;
3398 lta->v_minor = msg->minor;
3399 lta->sessions = lttng_ht_new(0, LTTNG_HT_TYPE_U64);
3400 lta->ust_objd = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG);
3401 lta->ust_sessions_objd = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG);
3402 lta->notify_sock = -1;
3403
3404 /* Copy name and make sure it's NULL terminated. */
3405 strncpy(lta->name, msg->name, sizeof(lta->name));
3406 lta->name[UST_APP_PROCNAME_LEN] = '\0';
3407
3408 /*
3409 * Before this can be called, when receiving the registration information,
3410 * the application compatibility is checked. So, at this point, the
3411 * application can work with this session daemon.
3412 */
3413 lta->compatible = 1;
3414
3415 lta->pid = msg->pid;
3416 lttng_ht_node_init_ulong(&lta->pid_n, (unsigned long) lta->pid);
3417 lta->sock = sock;
3418 pthread_mutex_init(&lta->sock_lock, NULL);
3419 lttng_ht_node_init_ulong(&lta->sock_n, (unsigned long) lta->sock);
3420
3421 CDS_INIT_LIST_HEAD(&lta->teardown_head);
3422 error:
3423 return lta;
3424 }
3425
3426 /*
3427 * For a given application object, add it to every hash table.
3428 */
3429 void ust_app_add(struct ust_app *app)
3430 {
3431 assert(app);
3432 assert(app->notify_sock >= 0);
3433
3434 rcu_read_lock();
3435
3436 /*
3437 * On a re-registration, we want to kick out the previous registration of
3438 * that pid
3439 */
3440 lttng_ht_add_replace_ulong(ust_app_ht, &app->pid_n);
3441
3442 /*
3443 * The socket _should_ be unique until _we_ call close. So, a add_unique
3444 * for the ust_app_ht_by_sock is used which asserts fail if the entry was
3445 * already in the table.
3446 */
3447 lttng_ht_add_unique_ulong(ust_app_ht_by_sock, &app->sock_n);
3448
3449 /* Add application to the notify socket hash table. */
3450 lttng_ht_node_init_ulong(&app->notify_sock_n, app->notify_sock);
3451 lttng_ht_add_unique_ulong(ust_app_ht_by_notify_sock, &app->notify_sock_n);
3452
3453 DBG("App registered with pid:%d ppid:%d uid:%d gid:%d sock:%d name:%s "
3454 "notify_sock:%d (version %d.%d)", app->pid, app->ppid, app->uid,
3455 app->gid, app->sock, app->name, app->notify_sock, app->v_major,
3456 app->v_minor);
3457
3458 rcu_read_unlock();
3459 }
3460
3461 /*
3462 * Set the application version into the object.
3463 *
3464 * Return 0 on success else a negative value either an errno code or a
3465 * LTTng-UST error code.
3466 */
3467 int ust_app_version(struct ust_app *app)
3468 {
3469 int ret;
3470
3471 assert(app);
3472
3473 pthread_mutex_lock(&app->sock_lock);
3474 ret = ustctl_tracer_version(app->sock, &app->version);
3475 pthread_mutex_unlock(&app->sock_lock);
3476 if (ret < 0) {
3477 if (ret != -LTTNG_UST_ERR_EXITING && ret != -EPIPE) {
3478 ERR("UST app %d version failed with ret %d", app->sock, ret);
3479 } else {
3480 DBG3("UST app %d version failed. Application is dead", app->sock);
3481 }
3482 }
3483
3484 return ret;
3485 }
3486
3487 /*
3488 * Unregister app by removing it from the global traceable app list and freeing
3489 * the data struct.
3490 *
3491 * The socket is already closed at this point so no close to sock.
3492 */
3493 void ust_app_unregister(int sock)
3494 {
3495 struct ust_app *lta;
3496 struct lttng_ht_node_ulong *node;
3497 struct lttng_ht_iter ust_app_sock_iter;
3498 struct lttng_ht_iter iter;
3499 struct ust_app_session *ua_sess;
3500 int ret;
3501
3502 rcu_read_lock();
3503
3504 /* Get the node reference for a call_rcu */
3505 lttng_ht_lookup(ust_app_ht_by_sock, (void *)((unsigned long) sock), &ust_app_sock_iter);
3506 node = lttng_ht_iter_get_node_ulong(&ust_app_sock_iter);
3507 assert(node);
3508
3509 lta = caa_container_of(node, struct ust_app, sock_n);
3510 DBG("PID %d unregistering with sock %d", lta->pid, sock);
3511
3512 /*
3513 * For per-PID buffers, perform "push metadata" and flush all
3514 * application streams before removing app from hash tables,
3515 * ensuring proper behavior of data_pending check.
3516 * Remove sessions so they are not visible during deletion.
3517 */
3518 cds_lfht_for_each_entry(lta->sessions->ht, &iter.iter, ua_sess,
3519 node.node) {
3520 struct ust_registry_session *registry;
3521
3522 ret = lttng_ht_del(lta->sessions, &iter);
3523 if (ret) {
3524 /* The session was already removed so scheduled for teardown. */
3525 continue;
3526 }
3527
3528 if (ua_sess->buffer_type == LTTNG_BUFFER_PER_PID) {
3529 (void) ust_app_flush_app_session(lta, ua_sess);
3530 }
3531
3532 /*
3533 * Add session to list for teardown. This is safe since at this point we
3534 * are the only one using this list.
3535 */
3536 pthread_mutex_lock(&ua_sess->lock);
3537
3538 if (ua_sess->deleted) {
3539 pthread_mutex_unlock(&ua_sess->lock);
3540 continue;
3541 }
3542
3543 /*
3544 * Normally, this is done in the delete session process which is
3545 * executed in the call rcu below. However, upon registration we can't
3546 * afford to wait for the grace period before pushing data or else the
3547 * data pending feature can race between the unregistration and stop
3548 * command where the data pending command is sent *before* the grace
3549 * period ended.
3550 *
3551 * The close metadata below nullifies the metadata pointer in the
3552 * session so the delete session will NOT push/close a second time.
3553 */
3554 registry = get_session_registry(ua_sess);
3555 if (registry) {
3556 /* Push metadata for application before freeing the application. */
3557 (void) push_metadata(registry, ua_sess->consumer);
3558
3559 /*
3560 * Don't ask to close metadata for global per UID buffers. Close
3561 * metadata only on destroy trace session in this case. Also, the
3562 * previous push metadata could have flag the metadata registry to
3563 * close so don't send a close command if closed.
3564 */
3565 if (ua_sess->buffer_type != LTTNG_BUFFER_PER_UID) {
3566 /* And ask to close it for this session registry. */
3567 (void) close_metadata(registry, ua_sess->consumer);
3568 }
3569 }
3570 cds_list_add(&ua_sess->teardown_node, &lta->teardown_head);
3571
3572 pthread_mutex_unlock(&ua_sess->lock);
3573 }
3574
3575 /* Remove application from PID hash table */
3576 ret = lttng_ht_del(ust_app_ht_by_sock, &ust_app_sock_iter);
3577 assert(!ret);
3578
3579 /*
3580 * Remove application from notify hash table. The thread handling the
3581 * notify socket could have deleted the node so ignore on error because
3582 * either way it's valid. The close of that socket is handled by the other
3583 * thread.
3584 */
3585 iter.iter.node = &lta->notify_sock_n.node;
3586 (void) lttng_ht_del(ust_app_ht_by_notify_sock, &iter);
3587
3588 /*
3589 * Ignore return value since the node might have been removed before by an
3590 * add replace during app registration because the PID can be reassigned by
3591 * the OS.
3592 */
3593 iter.iter.node = &lta->pid_n.node;
3594 ret = lttng_ht_del(ust_app_ht, &iter);
3595 if (ret) {
3596 DBG3("Unregister app by PID %d failed. This can happen on pid reuse",
3597 lta->pid);
3598 }
3599
3600 /* Free memory */
3601 call_rcu(&lta->pid_n.head, delete_ust_app_rcu);
3602
3603 rcu_read_unlock();
3604 return;
3605 }
3606
3607 /*
3608 * Fill events array with all events name of all registered apps.
3609 */
3610 int ust_app_list_events(struct lttng_event **events)
3611 {
3612 int ret, handle;
3613 size_t nbmem, count = 0;
3614 struct lttng_ht_iter iter;
3615 struct ust_app *app;
3616 struct lttng_event *tmp_event;
3617
3618 nbmem = UST_APP_EVENT_LIST_SIZE;
3619 tmp_event = zmalloc(nbmem * sizeof(struct lttng_event));
3620 if (tmp_event == NULL) {
3621 PERROR("zmalloc ust app events");
3622 ret = -ENOMEM;
3623 goto error;
3624 }
3625
3626 rcu_read_lock();
3627
3628 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
3629 struct lttng_ust_tracepoint_iter uiter;
3630
3631 health_code_update();
3632
3633 if (!app->compatible) {
3634 /*
3635 * TODO: In time, we should notice the caller of this error by
3636 * telling him that this is a version error.
3637 */
3638 continue;
3639 }
3640 pthread_mutex_lock(&app->sock_lock);
3641 handle = ustctl_tracepoint_list(app->sock);
3642 if (handle < 0) {
3643 if (handle != -EPIPE && handle != -LTTNG_UST_ERR_EXITING) {
3644 ERR("UST app list events getting handle failed for app pid %d",
3645 app->pid);
3646 }
3647 pthread_mutex_unlock(&app->sock_lock);
3648 continue;
3649 }
3650
3651 while ((ret = ustctl_tracepoint_list_get(app->sock, handle,
3652 &uiter)) != -LTTNG_UST_ERR_NOENT) {
3653 /* Handle ustctl error. */
3654 if (ret < 0) {
3655 int release_ret;
3656
3657 if (ret != -LTTNG_UST_ERR_EXITING && ret != -EPIPE) {
3658 ERR("UST app tp list get failed for app %d with ret %d",
3659 app->sock, ret);
3660 } else {
3661 DBG3("UST app tp list get failed. Application is dead");
3662 /*
3663 * This is normal behavior, an application can die during the
3664 * creation process. Don't report an error so the execution can
3665 * continue normally. Continue normal execution.
3666 */
3667 break;
3668 }
3669 free(tmp_event);
3670 release_ret = ustctl_release_handle(app->sock, handle);
3671 if (release_ret < 0 &&
3672 release_ret != -LTTNG_UST_ERR_EXITING &&
3673 release_ret != -EPIPE) {
3674 ERR("Error releasing app handle for app %d with ret %d", app->sock, release_ret);
3675 }
3676 pthread_mutex_unlock(&app->sock_lock);
3677 goto rcu_error;
3678 }
3679
3680 health_code_update();
3681 if (count >= nbmem) {
3682 /* In case the realloc fails, we free the memory */
3683 struct lttng_event *new_tmp_event;
3684 size_t new_nbmem;
3685
3686 new_nbmem = nbmem << 1;
3687 DBG2("Reallocating event list from %zu to %zu entries",
3688 nbmem, new_nbmem);
3689 new_tmp_event = realloc(tmp_event,
3690 new_nbmem * sizeof(struct lttng_event));
3691 if (new_tmp_event == NULL) {
3692 int release_ret;
3693
3694 PERROR("realloc ust app events");
3695 free(tmp_event);
3696 ret = -ENOMEM;
3697 release_ret = ustctl_release_handle(app->sock, handle);
3698 if (release_ret < 0 &&
3699 release_ret != -LTTNG_UST_ERR_EXITING &&
3700 release_ret != -EPIPE) {
3701 ERR("Error releasing app handle for app %d with ret %d", app->sock, release_ret);
3702 }
3703 pthread_mutex_unlock(&app->sock_lock);
3704 goto rcu_error;
3705 }
3706 /* Zero the new memory */
3707 memset(new_tmp_event + nbmem, 0,
3708 (new_nbmem - nbmem) * sizeof(struct lttng_event));
3709 nbmem = new_nbmem;
3710 tmp_event = new_tmp_event;
3711 }
3712 memcpy(tmp_event[count].name, uiter.name, LTTNG_UST_SYM_NAME_LEN);
3713 tmp_event[count].loglevel = uiter.loglevel;
3714 tmp_event[count].type = (enum lttng_event_type) LTTNG_UST_TRACEPOINT;
3715 tmp_event[count].pid = app->pid;
3716 tmp_event[count].enabled = -1;
3717 count++;
3718 }
3719 ret = ustctl_release_handle(app->sock, handle);
3720 pthread_mutex_unlock(&app->sock_lock);
3721 if (ret < 0 && ret != -LTTNG_UST_ERR_EXITING && ret != -EPIPE) {
3722 ERR("Error releasing app handle for app %d with ret %d", app->sock, ret);
3723 }
3724 }
3725
3726 ret = count;
3727 *events = tmp_event;
3728
3729 DBG2("UST app list events done (%zu events)", count);
3730
3731 rcu_error:
3732 rcu_read_unlock();
3733 error:
3734 health_code_update();
3735 return ret;
3736 }
3737
3738 /*
3739 * Fill events array with all events name of all registered apps.
3740 */
3741 int ust_app_list_event_fields(struct lttng_event_field **fields)
3742 {
3743 int ret, handle;
3744 size_t nbmem, count = 0;
3745 struct lttng_ht_iter iter;
3746 struct ust_app *app;
3747 struct lttng_event_field *tmp_event;
3748
3749 nbmem = UST_APP_EVENT_LIST_SIZE;
3750 tmp_event = zmalloc(nbmem * sizeof(struct lttng_event_field));
3751 if (tmp_event == NULL) {
3752 PERROR("zmalloc ust app event fields");
3753 ret = -ENOMEM;
3754 goto error;
3755 }
3756
3757 rcu_read_lock();
3758
3759 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
3760 struct lttng_ust_field_iter uiter;
3761
3762 health_code_update();
3763
3764 if (!app->compatible) {
3765 /*
3766 * TODO: In time, we should notice the caller of this error by
3767 * telling him that this is a version error.
3768 */
3769 continue;
3770 }
3771 pthread_mutex_lock(&app->sock_lock);
3772 handle = ustctl_tracepoint_field_list(app->sock);
3773 if (handle < 0) {
3774 if (handle != -EPIPE && handle != -LTTNG_UST_ERR_EXITING) {
3775 ERR("UST app list field getting handle failed for app pid %d",
3776 app->pid);
3777 }
3778 pthread_mutex_unlock(&app->sock_lock);
3779 continue;
3780 }
3781
3782 while ((ret = ustctl_tracepoint_field_list_get(app->sock, handle,
3783 &uiter)) != -LTTNG_UST_ERR_NOENT) {
3784 /* Handle ustctl error. */
3785 if (ret < 0) {
3786 int release_ret;
3787
3788 if (ret != -LTTNG_UST_ERR_EXITING && ret != -EPIPE) {
3789 ERR("UST app tp list field failed for app %d with ret %d",
3790 app->sock, ret);
3791 } else {
3792 DBG3("UST app tp list field failed. Application is dead");
3793 /*
3794 * This is normal behavior, an application can die during the
3795 * creation process. Don't report an error so the execution can
3796 * continue normally. Reset list and count for next app.
3797 */
3798 break;
3799 }
3800 free(tmp_event);
3801 release_ret = ustctl_release_handle(app->sock, handle);
3802 pthread_mutex_unlock(&app->sock_lock);
3803 if (release_ret < 0 &&
3804 release_ret != -LTTNG_UST_ERR_EXITING &&
3805 release_ret != -EPIPE) {
3806 ERR("Error releasing app handle for app %d with ret %d", app->sock, release_ret);
3807 }
3808 goto rcu_error;
3809 }
3810
3811 health_code_update();
3812 if (count >= nbmem) {
3813 /* In case the realloc fails, we free the memory */
3814 struct lttng_event_field *new_tmp_event;
3815 size_t new_nbmem;
3816
3817 new_nbmem = nbmem << 1;
3818 DBG2("Reallocating event field list from %zu to %zu entries",
3819 nbmem, new_nbmem);
3820 new_tmp_event = realloc(tmp_event,
3821 new_nbmem * sizeof(struct lttng_event_field));
3822 if (new_tmp_event == NULL) {
3823 int release_ret;
3824
3825 PERROR("realloc ust app event fields");
3826 free(tmp_event);
3827 ret = -ENOMEM;
3828 release_ret = ustctl_release_handle(app->sock, handle);
3829 pthread_mutex_unlock(&app->sock_lock);
3830 if (release_ret &&
3831 release_ret != -LTTNG_UST_ERR_EXITING &&
3832 release_ret != -EPIPE) {
3833 ERR("Error releasing app handle for app %d with ret %d", app->sock, release_ret);
3834 }
3835 goto rcu_error;
3836 }
3837 /* Zero the new memory */
3838 memset(new_tmp_event + nbmem, 0,
3839 (new_nbmem - nbmem) * sizeof(struct lttng_event_field));
3840 nbmem = new_nbmem;
3841 tmp_event = new_tmp_event;
3842 }
3843
3844 memcpy(tmp_event[count].field_name, uiter.field_name, LTTNG_UST_SYM_NAME_LEN);
3845 /* Mapping between these enums matches 1 to 1. */
3846 tmp_event[count].type = (enum lttng_event_field_type) uiter.type;
3847 tmp_event[count].nowrite = uiter.nowrite;
3848
3849 memcpy(tmp_event[count].event.name, uiter.event_name, LTTNG_UST_SYM_NAME_LEN);
3850 tmp_event[count].event.loglevel = uiter.loglevel;
3851 tmp_event[count].event.type = LTTNG_EVENT_TRACEPOINT;
3852 tmp_event[count].event.pid = app->pid;
3853 tmp_event[count].event.enabled = -1;
3854 count++;
3855 }
3856 ret = ustctl_release_handle(app->sock, handle);
3857 pthread_mutex_unlock(&app->sock_lock);
3858 if (ret < 0 &&
3859 ret != -LTTNG_UST_ERR_EXITING &&
3860 ret != -EPIPE) {
3861 ERR("Error releasing app handle for app %d with ret %d", app->sock, ret);
3862 }
3863 }
3864
3865 ret = count;
3866 *fields = tmp_event;
3867
3868 DBG2("UST app list event fields done (%zu events)", count);
3869
3870 rcu_error:
3871 rcu_read_unlock();
3872 error:
3873 health_code_update();
3874 return ret;
3875 }
3876
3877 /*
3878 * Free and clean all traceable apps of the global list.
3879 *
3880 * Should _NOT_ be called with RCU read-side lock held.
3881 */
3882 void ust_app_clean_list(void)
3883 {
3884 int ret;
3885 struct ust_app *app;
3886 struct lttng_ht_iter iter;
3887
3888 DBG2("UST app cleaning registered apps hash table");
3889
3890 rcu_read_lock();
3891
3892 if (ust_app_ht) {
3893 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
3894 ret = lttng_ht_del(ust_app_ht, &iter);
3895 assert(!ret);
3896 call_rcu(&app->pid_n.head, delete_ust_app_rcu);
3897 }
3898 }
3899
3900 /* Cleanup socket hash table */
3901 if (ust_app_ht_by_sock) {
3902 cds_lfht_for_each_entry(ust_app_ht_by_sock->ht, &iter.iter, app,
3903 sock_n.node) {
3904 ret = lttng_ht_del(ust_app_ht_by_sock, &iter);
3905 assert(!ret);
3906 }
3907 }
3908
3909 /* Cleanup notify socket hash table */
3910 if (ust_app_ht_by_notify_sock) {
3911 cds_lfht_for_each_entry(ust_app_ht_by_notify_sock->ht, &iter.iter, app,
3912 notify_sock_n.node) {
3913 ret = lttng_ht_del(ust_app_ht_by_notify_sock, &iter);
3914 assert(!ret);
3915 }
3916 }
3917 rcu_read_unlock();
3918
3919 /* Destroy is done only when the ht is empty */
3920 if (ust_app_ht) {
3921 ht_cleanup_push(ust_app_ht);
3922 }
3923 if (ust_app_ht_by_sock) {
3924 ht_cleanup_push(ust_app_ht_by_sock);
3925 }
3926 if (ust_app_ht_by_notify_sock) {
3927 ht_cleanup_push(ust_app_ht_by_notify_sock);
3928 }
3929 }
3930
3931 /*
3932 * Init UST app hash table.
3933 */
3934 int ust_app_ht_alloc(void)
3935 {
3936 ust_app_ht = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG);
3937 if (!ust_app_ht) {
3938 return -1;
3939 }
3940 ust_app_ht_by_sock = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG);
3941 if (!ust_app_ht_by_sock) {
3942 return -1;
3943 }
3944 ust_app_ht_by_notify_sock = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG);
3945 if (!ust_app_ht_by_notify_sock) {
3946 return -1;
3947 }
3948 return 0;
3949 }
3950
3951 /*
3952 * For a specific UST session, disable the channel for all registered apps.
3953 */
3954 int ust_app_disable_channel_glb(struct ltt_ust_session *usess,
3955 struct ltt_ust_channel *uchan)
3956 {
3957 int ret = 0;
3958 struct lttng_ht_iter iter;
3959 struct lttng_ht_node_str *ua_chan_node;
3960 struct ust_app *app;
3961 struct ust_app_session *ua_sess;
3962 struct ust_app_channel *ua_chan;
3963
3964 if (usess == NULL || uchan == NULL) {
3965 ERR("Disabling UST global channel with NULL values");
3966 ret = -1;
3967 goto error;
3968 }
3969
3970 DBG2("UST app disabling channel %s from global domain for session id %" PRIu64,
3971 uchan->name, usess->id);
3972
3973 rcu_read_lock();
3974
3975 /* For every registered applications */
3976 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
3977 struct lttng_ht_iter uiter;
3978 if (!app->compatible) {
3979 /*
3980 * TODO: In time, we should notice the caller of this error by
3981 * telling him that this is a version error.
3982 */
3983 continue;
3984 }
3985 ua_sess = lookup_session_by_app(usess, app);
3986 if (ua_sess == NULL) {
3987 continue;
3988 }
3989
3990 /* Get channel */
3991 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &uiter);
3992 ua_chan_node = lttng_ht_iter_get_node_str(&uiter);
3993 /* If the session if found for the app, the channel must be there */
3994 assert(ua_chan_node);
3995
3996 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
3997 /* The channel must not be already disabled */
3998 assert(ua_chan->enabled == 1);
3999
4000 /* Disable channel onto application */
4001 ret = disable_ust_app_channel(ua_sess, ua_chan, app);
4002 if (ret < 0) {
4003 /* XXX: We might want to report this error at some point... */
4004 continue;
4005 }
4006 }
4007
4008 rcu_read_unlock();
4009
4010 error:
4011 return ret;
4012 }
4013
4014 /*
4015 * For a specific UST session, enable the channel for all registered apps.
4016 */
4017 int ust_app_enable_channel_glb(struct ltt_ust_session *usess,
4018 struct ltt_ust_channel *uchan)
4019 {
4020 int ret = 0;
4021 struct lttng_ht_iter iter;
4022 struct ust_app *app;
4023 struct ust_app_session *ua_sess;
4024
4025 if (usess == NULL || uchan == NULL) {
4026 ERR("Adding UST global channel to NULL values");
4027 ret = -1;
4028 goto error;
4029 }
4030
4031 DBG2("UST app enabling channel %s to global domain for session id %" PRIu64,
4032 uchan->name, usess->id);
4033
4034 rcu_read_lock();
4035
4036 /* For every registered applications */
4037 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
4038 if (!app->compatible) {
4039 /*
4040 * TODO: In time, we should notice the caller of this error by
4041 * telling him that this is a version error.
4042 */
4043 continue;
4044 }
4045 ua_sess = lookup_session_by_app(usess, app);
4046 if (ua_sess == NULL) {
4047 continue;
4048 }
4049
4050 /* Enable channel onto application */
4051 ret = enable_ust_app_channel(ua_sess, uchan, app);
4052 if (ret < 0) {
4053 /* XXX: We might want to report this error at some point... */
4054 continue;
4055 }
4056 }
4057
4058 rcu_read_unlock();
4059
4060 error:
4061 return ret;
4062 }
4063
4064 /*
4065 * Disable an event in a channel and for a specific session.
4066 */
4067 int ust_app_disable_event_glb(struct ltt_ust_session *usess,
4068 struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent)
4069 {
4070 int ret = 0;
4071 struct lttng_ht_iter iter, uiter;
4072 struct lttng_ht_node_str *ua_chan_node;
4073 struct ust_app *app;
4074 struct ust_app_session *ua_sess;
4075 struct ust_app_channel *ua_chan;
4076 struct ust_app_event *ua_event;
4077
4078 DBG("UST app disabling event %s for all apps in channel "
4079 "%s for session id %" PRIu64,
4080 uevent->attr.name, uchan->name, usess->id);
4081
4082 rcu_read_lock();
4083
4084 /* For all registered applications */
4085 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
4086 if (!app->compatible) {
4087 /*
4088 * TODO: In time, we should notice the caller of this error by
4089 * telling him that this is a version error.
4090 */
4091 continue;
4092 }
4093 ua_sess = lookup_session_by_app(usess, app);
4094 if (ua_sess == NULL) {
4095 /* Next app */
4096 continue;
4097 }
4098
4099 /* Lookup channel in the ust app session */
4100 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &uiter);
4101 ua_chan_node = lttng_ht_iter_get_node_str(&uiter);
4102 if (ua_chan_node == NULL) {
4103 DBG2("Channel %s not found in session id %" PRIu64 " for app pid %d."
4104 "Skipping", uchan->name, usess->id, app->pid);
4105 continue;
4106 }
4107 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
4108
4109 ua_event = find_ust_app_event(ua_chan->events, uevent->attr.name,
4110 uevent->filter, uevent->attr.loglevel,
4111 uevent->exclusion);
4112 if (ua_event == NULL) {
4113 DBG2("Event %s not found in channel %s for app pid %d."
4114 "Skipping", uevent->attr.name, uchan->name, app->pid);
4115 continue;
4116 }
4117
4118 ret = disable_ust_app_event(ua_sess, ua_event, app);
4119 if (ret < 0) {
4120 /* XXX: Report error someday... */
4121 continue;
4122 }
4123 }
4124
4125 rcu_read_unlock();
4126
4127 return ret;
4128 }
4129
4130 /*
4131 * For a specific UST session, create the channel for all registered apps.
4132 */
4133 int ust_app_create_channel_glb(struct ltt_ust_session *usess,
4134 struct ltt_ust_channel *uchan)
4135 {
4136 int ret = 0, created;
4137 struct lttng_ht_iter iter;
4138 struct ust_app *app;
4139 struct ust_app_session *ua_sess = NULL;
4140
4141 /* Very wrong code flow */
4142 assert(usess);
4143 assert(uchan);
4144
4145 DBG2("UST app adding channel %s to UST domain for session id %" PRIu64,
4146 uchan->name, usess->id);
4147
4148 rcu_read_lock();
4149
4150 /* For every registered applications */
4151 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
4152 if (!app->compatible) {
4153 /*
4154 * TODO: In time, we should notice the caller of this error by
4155 * telling him that this is a version error.
4156 */
4157 continue;
4158 }
4159 if (!trace_ust_pid_tracker_lookup(usess, app->pid)) {
4160 /* Skip. */
4161 continue;
4162 }
4163
4164 /*
4165 * Create session on the tracer side and add it to app session HT. Note
4166 * that if session exist, it will simply return a pointer to the ust
4167 * app session.
4168 */
4169 ret = create_ust_app_session(usess, app, &ua_sess, &created);
4170 if (ret < 0) {
4171 switch (ret) {
4172 case -ENOTCONN:
4173 /*
4174 * The application's socket is not valid. Either a bad socket
4175 * or a timeout on it. We can't inform the caller that for a
4176 * specific app, the session failed so lets continue here.
4177 */
4178 ret = 0; /* Not an error. */
4179 continue;
4180 case -ENOMEM:
4181 default:
4182 goto error_rcu_unlock;
4183 }
4184 }
4185 assert(ua_sess);
4186
4187 pthread_mutex_lock(&ua_sess->lock);
4188
4189 if (ua_sess->deleted) {
4190 pthread_mutex_unlock(&ua_sess->lock);
4191 continue;
4192 }
4193
4194 if (!strncmp(uchan->name, DEFAULT_METADATA_NAME,
4195 sizeof(uchan->name))) {
4196 copy_channel_attr_to_ustctl(&ua_sess->metadata_attr, &uchan->attr);
4197 ret = 0;
4198 } else {
4199 /* Create channel onto application. We don't need the chan ref. */
4200 ret = create_ust_app_channel(ua_sess, uchan, app,
4201 LTTNG_UST_CHAN_PER_CPU, usess, NULL);
4202 }
4203 pthread_mutex_unlock(&ua_sess->lock);
4204 if (ret < 0) {
4205 /* Cleanup the created session if it's the case. */
4206 if (created) {
4207 destroy_app_session(app, ua_sess);
4208 }
4209 switch (ret) {
4210 case -ENOTCONN:
4211 /*
4212 * The application's socket is not valid. Either a bad socket
4213 * or a timeout on it. We can't inform the caller that for a
4214 * specific app, the session failed so lets continue here.
4215 */
4216 ret = 0; /* Not an error. */
4217 continue;
4218 case -ENOMEM:
4219 default:
4220 goto error_rcu_unlock;
4221 }
4222 }
4223 }
4224
4225 error_rcu_unlock:
4226 rcu_read_unlock();
4227 return ret;
4228 }
4229
4230 /*
4231 * Enable event for a specific session and channel on the tracer.
4232 */
4233 int ust_app_enable_event_glb(struct ltt_ust_session *usess,
4234 struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent)
4235 {
4236 int ret = 0;
4237 struct lttng_ht_iter iter, uiter;
4238 struct lttng_ht_node_str *ua_chan_node;
4239 struct ust_app *app;
4240 struct ust_app_session *ua_sess;
4241 struct ust_app_channel *ua_chan;
4242 struct ust_app_event *ua_event;
4243
4244 DBG("UST app enabling event %s for all apps for session id %" PRIu64,
4245 uevent->attr.name, usess->id);
4246
4247 /*
4248 * NOTE: At this point, this function is called only if the session and
4249 * channel passed are already created for all apps. and enabled on the
4250 * tracer also.
4251 */
4252
4253 rcu_read_lock();
4254
4255 /* For all registered applications */
4256 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
4257 if (!app->compatible) {
4258 /*
4259 * TODO: In time, we should notice the caller of this error by
4260 * telling him that this is a version error.
4261 */
4262 continue;
4263 }
4264 ua_sess = lookup_session_by_app(usess, app);
4265 if (!ua_sess) {
4266 /* The application has problem or is probably dead. */
4267 continue;
4268 }
4269
4270 pthread_mutex_lock(&ua_sess->lock);
4271
4272 if (ua_sess->deleted) {
4273 pthread_mutex_unlock(&ua_sess->lock);
4274 continue;
4275 }
4276
4277 /* Lookup channel in the ust app session */
4278 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &uiter);
4279 ua_chan_node = lttng_ht_iter_get_node_str(&uiter);
4280 /*
4281 * It is possible that the channel cannot be found is
4282 * the channel/event creation occurs concurrently with
4283 * an application exit.
4284 */
4285 if (!ua_chan_node) {
4286 pthread_mutex_unlock(&ua_sess->lock);
4287 continue;
4288 }
4289
4290 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
4291
4292 /* Get event node */
4293 ua_event = find_ust_app_event(ua_chan->events, uevent->attr.name,
4294 uevent->filter, uevent->attr.loglevel, uevent->exclusion);
4295 if (ua_event == NULL) {
4296 DBG3("UST app enable event %s not found for app PID %d."
4297 "Skipping app", uevent->attr.name, app->pid);
4298 goto next_app;
4299 }
4300
4301 ret = enable_ust_app_event(ua_sess, ua_event, app);
4302 if (ret < 0) {
4303 pthread_mutex_unlock(&ua_sess->lock);
4304 goto error;
4305 }
4306 next_app:
4307 pthread_mutex_unlock(&ua_sess->lock);
4308 }
4309
4310 error:
4311 rcu_read_unlock();
4312 return ret;
4313 }
4314
4315 /*
4316 * For a specific existing UST session and UST channel, creates the event for
4317 * all registered apps.
4318 */
4319 int ust_app_create_event_glb(struct ltt_ust_session *usess,
4320 struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent)
4321 {
4322 int ret = 0;
4323 struct lttng_ht_iter iter, uiter;
4324 struct lttng_ht_node_str *ua_chan_node;
4325 struct ust_app *app;
4326 struct ust_app_session *ua_sess;
4327 struct ust_app_channel *ua_chan;
4328
4329 DBG("UST app creating event %s for all apps for session id %" PRIu64,
4330 uevent->attr.name, usess->id);
4331
4332 rcu_read_lock();
4333
4334 /* For all registered applications */
4335 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
4336 if (!app->compatible) {
4337 /*
4338 * TODO: In time, we should notice the caller of this error by
4339 * telling him that this is a version error.
4340 */
4341 continue;
4342 }
4343 ua_sess = lookup_session_by_app(usess, app);
4344 if (!ua_sess) {
4345 /* The application has problem or is probably dead. */
4346 continue;
4347 }
4348
4349 pthread_mutex_lock(&ua_sess->lock);
4350
4351 if (ua_sess->deleted) {
4352 pthread_mutex_unlock(&ua_sess->lock);
4353 continue;
4354 }
4355
4356 /* Lookup channel in the ust app session */
4357 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &uiter);
4358 ua_chan_node = lttng_ht_iter_get_node_str(&uiter);
4359 /* If the channel is not found, there is a code flow error */
4360 assert(ua_chan_node);
4361
4362 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
4363
4364 ret = create_ust_app_event(ua_sess, ua_chan, uevent, app);
4365 pthread_mutex_unlock(&ua_sess->lock);
4366 if (ret < 0) {
4367 if (ret != -LTTNG_UST_ERR_EXIST) {
4368 /* Possible value at this point: -ENOMEM. If so, we stop! */
4369 break;
4370 }
4371 DBG2("UST app event %s already exist on app PID %d",
4372 uevent->attr.name, app->pid);
4373 continue;
4374 }
4375 }
4376
4377 rcu_read_unlock();
4378
4379 return ret;
4380 }
4381
4382 /*
4383 * Start tracing for a specific UST session and app.
4384 *
4385 * Called with UST app session lock held.
4386 *
4387 */
4388 static
4389 int ust_app_start_trace(struct ltt_ust_session *usess, struct ust_app *app)
4390 {
4391 int ret = 0;
4392 struct ust_app_session *ua_sess;
4393
4394 DBG("Starting tracing for ust app pid %d", app->pid);
4395
4396 rcu_read_lock();
4397
4398 if (!app->compatible) {
4399 goto end;
4400 }
4401
4402 ua_sess = lookup_session_by_app(usess, app);
4403 if (ua_sess == NULL) {
4404 /* The session is in teardown process. Ignore and continue. */
4405 goto end;
4406 }
4407
4408 pthread_mutex_lock(&ua_sess->lock);
4409
4410 if (ua_sess->deleted) {
4411 pthread_mutex_unlock(&ua_sess->lock);
4412 goto end;
4413 }
4414
4415 /* Upon restart, we skip the setup, already done */
4416 if (ua_sess->started) {
4417 goto skip_setup;
4418 }
4419
4420 /* Create directories if consumer is LOCAL and has a path defined. */
4421 if (usess->consumer->type == CONSUMER_DST_LOCAL &&
4422 strlen(usess->consumer->dst.trace_path) > 0) {
4423 ret = run_as_mkdir_recursive(usess->consumer->dst.trace_path,
4424 S_IRWXU | S_IRWXG, ua_sess->euid, ua_sess->egid);
4425 if (ret < 0) {
4426 if (errno != EEXIST) {
4427 ERR("Trace directory creation error");
4428 goto error_unlock;
4429 }
4430 }
4431 }
4432
4433 /*
4434 * Create the metadata for the application. This returns gracefully if a
4435 * metadata was already set for the session.
4436 */
4437 ret = create_ust_app_metadata(ua_sess, app, usess->consumer);
4438 if (ret < 0) {
4439 goto error_unlock;
4440 }
4441
4442 health_code_update();
4443
4444 skip_setup:
4445 /* This start the UST tracing */
4446 pthread_mutex_lock(&app->sock_lock);
4447 ret = ustctl_start_session(app->sock, ua_sess->handle);
4448 pthread_mutex_unlock(&app->sock_lock);
4449 if (ret < 0) {
4450 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
4451 ERR("Error starting tracing for app pid: %d (ret: %d)",
4452 app->pid, ret);
4453 } else {
4454 DBG("UST app start session failed. Application is dead.");
4455 /*
4456 * This is normal behavior, an application can die during the
4457 * creation process. Don't report an error so the execution can
4458 * continue normally.
4459 */
4460 pthread_mutex_unlock(&ua_sess->lock);
4461 goto end;
4462 }
4463 goto error_unlock;
4464 }
4465
4466 /* Indicate that the session has been started once */
4467 ua_sess->started = 1;
4468
4469 pthread_mutex_unlock(&ua_sess->lock);
4470
4471 health_code_update();
4472
4473 /* Quiescent wait after starting trace */
4474 pthread_mutex_lock(&app->sock_lock);
4475 ret = ustctl_wait_quiescent(app->sock);
4476 pthread_mutex_unlock(&app->sock_lock);
4477 if (ret < 0 && ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
4478 ERR("UST app wait quiescent failed for app pid %d ret %d",
4479 app->pid, ret);
4480 }
4481
4482 end:
4483 rcu_read_unlock();
4484 health_code_update();
4485 return 0;
4486
4487 error_unlock:
4488 pthread_mutex_unlock(&ua_sess->lock);
4489 rcu_read_unlock();
4490 health_code_update();
4491 return -1;
4492 }
4493
4494 /*
4495 * Stop tracing for a specific UST session and app.
4496 */
4497 static
4498 int ust_app_stop_trace(struct ltt_ust_session *usess, struct ust_app *app)
4499 {
4500 int ret = 0;
4501 struct ust_app_session *ua_sess;
4502 struct ust_registry_session *registry;
4503
4504 DBG("Stopping tracing for ust app pid %d", app->pid);
4505
4506 rcu_read_lock();
4507
4508 if (!app->compatible) {
4509 goto end_no_session;
4510 }
4511
4512 ua_sess = lookup_session_by_app(usess, app);
4513 if (ua_sess == NULL) {
4514 goto end_no_session;
4515 }
4516
4517 pthread_mutex_lock(&ua_sess->lock);
4518
4519 if (ua_sess->deleted) {
4520 pthread_mutex_unlock(&ua_sess->lock);
4521 goto end_no_session;
4522 }
4523
4524 /*
4525 * If started = 0, it means that stop trace has been called for a session
4526 * that was never started. It's possible since we can have a fail start
4527 * from either the application manager thread or the command thread. Simply
4528 * indicate that this is a stop error.
4529 */
4530 if (!ua_sess->started) {
4531 goto error_rcu_unlock;
4532 }
4533
4534 health_code_update();
4535
4536 /* This inhibits UST tracing */
4537 pthread_mutex_lock(&app->sock_lock);
4538 ret = ustctl_stop_session(app->sock, ua_sess->handle);
4539 pthread_mutex_unlock(&app->sock_lock);
4540 if (ret < 0) {
4541 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
4542 ERR("Error stopping tracing for app pid: %d (ret: %d)",
4543 app->pid, ret);
4544 } else {
4545 DBG("UST app stop session failed. Application is dead.");
4546 /*
4547 * This is normal behavior, an application can die during the
4548 * creation process. Don't report an error so the execution can
4549 * continue normally.
4550 */
4551 goto end_unlock;
4552 }
4553 goto error_rcu_unlock;
4554 }
4555
4556 health_code_update();
4557
4558 /* Quiescent wait after stopping trace */
4559 pthread_mutex_lock(&app->sock_lock);
4560 ret = ustctl_wait_quiescent(app->sock);
4561 pthread_mutex_unlock(&app->sock_lock);
4562 if (ret < 0 && ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
4563 ERR("UST app wait quiescent failed for app pid %d ret %d",
4564 app->pid, ret);
4565 }
4566
4567 health_code_update();
4568
4569 registry = get_session_registry(ua_sess);
4570
4571 /* The UST app session is held registry shall not be null. */
4572 assert(registry);
4573
4574 /* Push metadata for application before freeing the application. */
4575 (void) push_metadata(registry, ua_sess->consumer);
4576
4577 end_unlock:
4578 pthread_mutex_unlock(&ua_sess->lock);
4579 end_no_session:
4580 rcu_read_unlock();
4581 health_code_update();
4582 return 0;
4583
4584 error_rcu_unlock:
4585 pthread_mutex_unlock(&ua_sess->lock);
4586 rcu_read_unlock();
4587 health_code_update();
4588 return -1;
4589 }
4590
4591 static
4592 int ust_app_flush_app_session(struct ust_app *app,
4593 struct ust_app_session *ua_sess)
4594 {
4595 int ret, retval = 0;
4596 struct lttng_ht_iter iter;
4597 struct ust_app_channel *ua_chan;
4598 struct consumer_socket *socket;
4599
4600 DBG("Flushing app session buffers for ust app pid %d", app->pid);
4601
4602 rcu_read_lock();
4603
4604 if (!app->compatible) {
4605 goto end_not_compatible;
4606 }
4607
4608 pthread_mutex_lock(&ua_sess->lock);
4609
4610 if (ua_sess->deleted) {
4611 goto end_deleted;
4612 }
4613
4614 health_code_update();
4615
4616 /* Flushing buffers */
4617 socket = consumer_find_socket_by_bitness(app->bits_per_long,
4618 ua_sess->consumer);
4619
4620 /* Flush buffers and push metadata. */
4621 switch (ua_sess->buffer_type) {
4622 case LTTNG_BUFFER_PER_PID:
4623 cds_lfht_for_each_entry(ua_sess->channels->ht, &iter.iter, ua_chan,
4624 node.node) {
4625 health_code_update();
4626 ret = consumer_flush_channel(socket, ua_chan->key);
4627 if (ret) {
4628 ERR("Error flushing consumer channel");
4629 retval = -1;
4630 continue;
4631 }
4632 }
4633 break;
4634 case LTTNG_BUFFER_PER_UID:
4635 default:
4636 assert(0);
4637 break;
4638 }
4639
4640 health_code_update();
4641
4642 end_deleted:
4643 pthread_mutex_unlock(&ua_sess->lock);
4644
4645 end_not_compatible:
4646 rcu_read_unlock();
4647 health_code_update();
4648 return retval;
4649 }
4650
4651 /*
4652 * Flush buffers for all applications for a specific UST session.
4653 * Called with UST session lock held.
4654 */
4655 static
4656 int ust_app_flush_session(struct ltt_ust_session *usess)
4657
4658 {
4659 int ret = 0;
4660
4661 DBG("Flushing session buffers for all ust apps");
4662
4663 rcu_read_lock();
4664
4665 /* Flush buffers and push metadata. */
4666 switch (usess->buffer_type) {
4667 case LTTNG_BUFFER_PER_UID:
4668 {
4669 struct buffer_reg_uid *reg;
4670 struct lttng_ht_iter iter;
4671
4672 /* Flush all per UID buffers associated to that session. */
4673 cds_list_for_each_entry(reg, &usess->buffer_reg_uid_list, lnode) {
4674 struct ust_registry_session *ust_session_reg;
4675 struct buffer_reg_channel *reg_chan;
4676 struct consumer_socket *socket;
4677
4678 /* Get consumer socket to use to push the metadata.*/
4679 socket = consumer_find_socket_by_bitness(reg->bits_per_long,
4680 usess->consumer);
4681 if (!socket) {
4682 /* Ignore request if no consumer is found for the session. */
4683 continue;
4684 }
4685
4686 cds_lfht_for_each_entry(reg->registry->channels->ht, &iter.iter,
4687 reg_chan, node.node) {
4688 /*
4689 * The following call will print error values so the return
4690 * code is of little importance because whatever happens, we
4691 * have to try them all.
4692 */
4693 (void) consumer_flush_channel(socket, reg_chan->consumer_key);
4694 }
4695
4696 ust_session_reg = reg->registry->reg.ust;
4697 /* Push metadata. */
4698 (void) push_metadata(ust_session_reg, usess->consumer);
4699 }
4700 break;
4701 }
4702 case LTTNG_BUFFER_PER_PID:
4703 {
4704 struct ust_app_session *ua_sess;
4705 struct lttng_ht_iter iter;
4706 struct ust_app *app;
4707
4708 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
4709 ua_sess = lookup_session_by_app(usess, app);
4710 if (ua_sess == NULL) {
4711 continue;
4712 }
4713 (void) ust_app_flush_app_session(app, ua_sess);
4714 }
4715 break;
4716 }
4717 default:
4718 ret = -1;
4719 assert(0);
4720 break;
4721 }
4722
4723 rcu_read_unlock();
4724 health_code_update();
4725 return ret;
4726 }
4727
4728 static
4729 int ust_app_clear_quiescent_app_session(struct ust_app *app,
4730 struct ust_app_session *ua_sess)
4731 {
4732 int ret = 0;
4733 struct lttng_ht_iter iter;
4734 struct ust_app_channel *ua_chan;
4735 struct consumer_socket *socket;
4736
4737 DBG("Clearing stream quiescent state for ust app pid %d", app->pid);
4738
4739 rcu_read_lock();
4740
4741 if (!app->compatible) {
4742 goto end_not_compatible;
4743 }
4744
4745 pthread_mutex_lock(&ua_sess->lock);
4746
4747 if (ua_sess->deleted) {
4748 goto end_unlock;
4749 }
4750
4751 health_code_update();
4752
4753 socket = consumer_find_socket_by_bitness(app->bits_per_long,
4754 ua_sess->consumer);
4755 if (!socket) {
4756 ERR("Failed to find consumer (%" PRIu32 ") socket",
4757 app->bits_per_long);
4758 ret = -1;
4759 goto end_unlock;
4760 }
4761
4762 /* Clear quiescent state. */
4763 switch (ua_sess->buffer_type) {
4764 case LTTNG_BUFFER_PER_PID:
4765 cds_lfht_for_each_entry(ua_sess->channels->ht, &iter.iter,
4766 ua_chan, node.node) {
4767 health_code_update();
4768 ret = consumer_clear_quiescent_channel(socket,
4769 ua_chan->key);
4770 if (ret) {
4771 ERR("Error clearing quiescent state for consumer channel");
4772 ret = -1;
4773 continue;
4774 }
4775 }
4776 break;
4777 case LTTNG_BUFFER_PER_UID:
4778 default:
4779 assert(0);
4780 ret = -1;
4781 break;
4782 }
4783
4784 health_code_update();
4785
4786 end_unlock:
4787 pthread_mutex_unlock(&ua_sess->lock);
4788
4789 end_not_compatible:
4790 rcu_read_unlock();
4791 health_code_update();
4792 return ret;
4793 }
4794
4795 /*
4796 * Clear quiescent state in each stream for all applications for a
4797 * specific UST session.
4798 * Called with UST session lock held.
4799 */
4800 static
4801 int ust_app_clear_quiescent_session(struct ltt_ust_session *usess)
4802
4803 {
4804 int ret = 0;
4805
4806 DBG("Clearing stream quiescent state for all ust apps");
4807
4808 rcu_read_lock();
4809
4810 switch (usess->buffer_type) {
4811 case LTTNG_BUFFER_PER_UID:
4812 {
4813 struct lttng_ht_iter iter;
4814 struct buffer_reg_uid *reg;
4815
4816 /*
4817 * Clear quiescent for all per UID buffers associated to
4818 * that session.
4819 */
4820 cds_list_for_each_entry(reg, &usess->buffer_reg_uid_list, lnode) {
4821 struct consumer_socket *socket;
4822 struct buffer_reg_channel *reg_chan;
4823
4824 /* Get associated consumer socket.*/
4825 socket = consumer_find_socket_by_bitness(
4826 reg->bits_per_long, usess->consumer);
4827 if (!socket) {
4828 /*
4829 * Ignore request if no consumer is found for
4830 * the session.
4831 */
4832 continue;
4833 }
4834
4835 cds_lfht_for_each_entry(reg->registry->channels->ht,
4836 &iter.iter, reg_chan, node.node) {
4837 /*
4838 * The following call will print error values so
4839 * the return code is of little importance
4840 * because whatever happens, we have to try them
4841 * all.
4842 */
4843 (void) consumer_clear_quiescent_channel(socket,
4844 reg_chan->consumer_key);
4845 }
4846 }
4847 break;
4848 }
4849 case LTTNG_BUFFER_PER_PID:
4850 {
4851 struct ust_app_session *ua_sess;
4852 struct lttng_ht_iter iter;
4853 struct ust_app *app;
4854
4855 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app,
4856 pid_n.node) {
4857 ua_sess = lookup_session_by_app(usess, app);
4858 if (ua_sess == NULL) {
4859 continue;
4860 }
4861 (void) ust_app_clear_quiescent_app_session(app,
4862 ua_sess);
4863 }
4864 break;
4865 }
4866 default:
4867 ret = -1;
4868 assert(0);
4869 break;
4870 }
4871
4872 rcu_read_unlock();
4873 health_code_update();
4874 return ret;
4875 }
4876
4877 /*
4878 * Destroy a specific UST session in apps.
4879 */
4880 static int destroy_trace(struct ltt_ust_session *usess, struct ust_app *app)
4881 {
4882 int ret;
4883 struct ust_app_session *ua_sess;
4884 struct lttng_ht_iter iter;
4885 struct lttng_ht_node_u64 *node;
4886
4887 DBG("Destroy tracing for ust app pid %d", app->pid);
4888
4889 rcu_read_lock();
4890
4891 if (!app->compatible) {
4892 goto end;
4893 }
4894
4895 __lookup_session_by_app(usess, app, &iter);
4896 node = lttng_ht_iter_get_node_u64(&iter);
4897 if (node == NULL) {
4898 /* Session is being or is deleted. */
4899 goto end;
4900 }
4901 ua_sess = caa_container_of(node, struct ust_app_session, node);
4902
4903 health_code_update();
4904 destroy_app_session(app, ua_sess);
4905
4906 health_code_update();
4907
4908 /* Quiescent wait after stopping trace */
4909 pthread_mutex_lock(&app->sock_lock);
4910 ret = ustctl_wait_quiescent(app->sock);
4911 pthread_mutex_unlock(&app->sock_lock);
4912 if (ret < 0 && ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
4913 ERR("UST app wait quiescent failed for app pid %d ret %d",
4914 app->pid, ret);
4915 }
4916 end:
4917 rcu_read_unlock();
4918 health_code_update();
4919 return 0;
4920 }
4921
4922 /*
4923 * Start tracing for the UST session.
4924 */
4925 int ust_app_start_trace_all(struct ltt_ust_session *usess)
4926 {
4927 int ret = 0;
4928 struct lttng_ht_iter iter;
4929 struct ust_app *app;
4930
4931 DBG("Starting all UST traces");
4932
4933 rcu_read_lock();
4934
4935 /*
4936 * In a start-stop-start use-case, we need to clear the quiescent state
4937 * of each channel set by the prior stop command, thus ensuring that a
4938 * following stop or destroy is sure to grab a timestamp_end near those
4939 * operations, even if the packet is empty.
4940 */
4941 (void) ust_app_clear_quiescent_session(usess);
4942
4943 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
4944 ret = ust_app_start_trace(usess, app);
4945 if (ret < 0) {
4946 /* Continue to next apps even on error */
4947 continue;
4948 }
4949 }
4950
4951 rcu_read_unlock();
4952
4953 return 0;
4954 }
4955
4956 /*
4957 * Start tracing for the UST session.
4958 * Called with UST session lock held.
4959 */
4960 int ust_app_stop_trace_all(struct ltt_ust_session *usess)
4961 {
4962 int ret = 0;
4963 struct lttng_ht_iter iter;
4964 struct ust_app *app;
4965
4966 DBG("Stopping all UST traces");
4967
4968 rcu_read_lock();
4969
4970 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
4971 ret = ust_app_stop_trace(usess, app);
4972 if (ret < 0) {
4973 /* Continue to next apps even on error */
4974 continue;
4975 }
4976 }
4977
4978 (void) ust_app_flush_session(usess);
4979
4980 rcu_read_unlock();
4981
4982 return 0;
4983 }
4984
4985 /*
4986 * Destroy app UST session.
4987 */
4988 int ust_app_destroy_trace_all(struct ltt_ust_session *usess)
4989 {
4990 int ret = 0;
4991 struct lttng_ht_iter iter;
4992 struct ust_app *app;
4993
4994 DBG("Destroy all UST traces");
4995
4996 rcu_read_lock();
4997
4998 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
4999 ret = destroy_trace(usess, app);
5000 if (ret < 0) {
5001 /* Continue to next apps even on error */
5002 continue;
5003 }
5004 }
5005
5006 rcu_read_unlock();
5007
5008 return 0;
5009 }
5010
5011 static
5012 void ust_app_global_create(struct ltt_ust_session *usess, struct ust_app *app)
5013 {
5014 int ret = 0;
5015 struct lttng_ht_iter iter, uiter;
5016 struct ust_app_session *ua_sess = NULL;
5017 struct ust_app_channel *ua_chan;
5018 struct ust_app_event *ua_event;
5019 struct ust_app_ctx *ua_ctx;
5020 int is_created = 0;
5021
5022 ret = create_ust_app_session(usess, app, &ua_sess, &is_created);
5023 if (ret < 0) {
5024 /* Tracer is probably gone or ENOMEM. */
5025 goto error;
5026 }
5027 if (!is_created) {
5028 /* App session already created. */
5029 goto end;
5030 }
5031 assert(ua_sess);
5032
5033 pthread_mutex_lock(&ua_sess->lock);
5034
5035 if (ua_sess->deleted) {
5036 pthread_mutex_unlock(&ua_sess->lock);
5037 goto end;
5038 }
5039
5040 /*
5041 * We can iterate safely here over all UST app session since the create ust
5042 * app session above made a shadow copy of the UST global domain from the
5043 * ltt ust session.
5044 */
5045 cds_lfht_for_each_entry(ua_sess->channels->ht, &iter.iter, ua_chan,
5046 node.node) {
5047 ret = do_create_channel(app, usess, ua_sess, ua_chan);
5048 if (ret < 0 && ret != -ENOTCONN) {
5049 /*
5050 * Stop everything. On error, the application
5051 * failed, no more file descriptor are available
5052 * or ENOMEM so stopping here is the only thing
5053 * we can do for now. The only exception is
5054 * -ENOTCONN, which indicates that the application
5055 * has exit.
5056 */
5057 goto error_unlock;
5058 }
5059
5060 /*
5061 * Add context using the list so they are enabled in the same order the
5062 * user added them.
5063 */
5064 cds_list_for_each_entry(ua_ctx, &ua_chan->ctx_list, list) {
5065 ret = create_ust_channel_context(ua_chan, ua_ctx, app);
5066 if (ret < 0) {
5067 goto error_unlock;
5068 }
5069 }
5070
5071
5072 /* For each events */
5073 cds_lfht_for_each_entry(ua_chan->events->ht, &uiter.iter, ua_event,
5074 node.node) {
5075 ret = create_ust_event(app, ua_sess, ua_chan, ua_event);
5076 if (ret < 0) {
5077 goto error_unlock;
5078 }
5079 }
5080 }
5081
5082 pthread_mutex_unlock(&ua_sess->lock);
5083
5084 if (usess->active) {
5085 ret = ust_app_start_trace(usess, app);
5086 if (ret < 0) {
5087 goto error;
5088 }
5089
5090 DBG2("UST trace started for app pid %d", app->pid);
5091 }
5092 end:
5093 /* Everything went well at this point. */
5094 return;
5095
5096 error_unlock:
5097 pthread_mutex_unlock(&ua_sess->lock);
5098 error:
5099 if (ua_sess) {
5100 destroy_app_session(app, ua_sess);
5101 }
5102 return;
5103 }
5104
5105 static
5106 void ust_app_global_destroy(struct ltt_ust_session *usess, struct ust_app *app)
5107 {
5108 struct ust_app_session *ua_sess;
5109
5110 ua_sess = lookup_session_by_app(usess, app);
5111 if (ua_sess == NULL) {
5112 return;
5113 }
5114 destroy_app_session(app, ua_sess);
5115 }
5116
5117 /*
5118 * Add channels/events from UST global domain to registered apps at sock.
5119 *
5120 * Called with session lock held.
5121 * Called with RCU read-side lock held.
5122 */
5123 void ust_app_global_update(struct ltt_ust_session *usess, struct ust_app *app)
5124 {
5125 assert(usess);
5126
5127 DBG2("UST app global update for app sock %d for session id %" PRIu64,
5128 app->sock, usess->id);
5129
5130 if (!app->compatible) {
5131 return;
5132 }
5133
5134 if (trace_ust_pid_tracker_lookup(usess, app->pid)) {
5135 ust_app_global_create(usess, app);
5136 } else {
5137 ust_app_global_destroy(usess, app);
5138 }
5139 }
5140
5141 /*
5142 * Called with session lock held.
5143 */
5144 void ust_app_global_update_all(struct ltt_ust_session *usess)
5145 {
5146 struct lttng_ht_iter iter;
5147 struct ust_app *app;
5148
5149 rcu_read_lock();
5150 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
5151 ust_app_global_update(usess, app);
5152 }
5153 rcu_read_unlock();
5154 }
5155
5156 /*
5157 * Add context to a specific channel for global UST domain.
5158 */
5159 int ust_app_add_ctx_channel_glb(struct ltt_ust_session *usess,
5160 struct ltt_ust_channel *uchan, struct ltt_ust_context *uctx)
5161 {
5162 int ret = 0;
5163 struct lttng_ht_node_str *ua_chan_node;
5164 struct lttng_ht_iter iter, uiter;
5165 struct ust_app_channel *ua_chan = NULL;
5166 struct ust_app_session *ua_sess;
5167 struct ust_app *app;
5168
5169 rcu_read_lock();
5170
5171 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
5172 if (!app->compatible) {
5173 /*
5174 * TODO: In time, we should notice the caller of this error by
5175 * telling him that this is a version error.
5176 */
5177 continue;
5178 }
5179 ua_sess = lookup_session_by_app(usess, app);
5180 if (ua_sess == NULL) {
5181 continue;
5182 }
5183
5184 pthread_mutex_lock(&ua_sess->lock);
5185
5186 if (ua_sess->deleted) {
5187 pthread_mutex_unlock(&ua_sess->lock);
5188 continue;
5189 }
5190
5191 /* Lookup channel in the ust app session */
5192 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &uiter);
5193 ua_chan_node = lttng_ht_iter_get_node_str(&uiter);
5194 if (ua_chan_node == NULL) {
5195 goto next_app;
5196 }
5197 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel,
5198 node);
5199 ret = create_ust_app_channel_context(ua_sess, ua_chan, &uctx->ctx, app);
5200 if (ret < 0) {
5201 goto next_app;
5202 }
5203 next_app:
5204 pthread_mutex_unlock(&ua_sess->lock);
5205 }
5206
5207 rcu_read_unlock();
5208 return ret;
5209 }
5210
5211 /*
5212 * Enable event for a channel from a UST session for a specific PID.
5213 */
5214 int ust_app_enable_event_pid(struct ltt_ust_session *usess,
5215 struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent, pid_t pid)
5216 {
5217 int ret = 0;
5218 struct lttng_ht_iter iter;
5219 struct lttng_ht_node_str *ua_chan_node;
5220 struct ust_app *app;
5221 struct ust_app_session *ua_sess;
5222 struct ust_app_channel *ua_chan;
5223 struct ust_app_event *ua_event;
5224
5225 DBG("UST app enabling event %s for PID %d", uevent->attr.name, pid);
5226
5227 rcu_read_lock();
5228
5229 app = ust_app_find_by_pid(pid);
5230 if (app == NULL) {
5231 ERR("UST app enable event per PID %d not found", pid);
5232 ret = -1;
5233 goto end;
5234 }
5235
5236 if (!app->compatible) {
5237 ret = 0;
5238 goto end;
5239 }
5240
5241 ua_sess = lookup_session_by_app(usess, app);
5242 if (!ua_sess) {
5243 /* The application has problem or is probably dead. */
5244 ret = 0;
5245 goto end;
5246 }
5247
5248 pthread_mutex_lock(&ua_sess->lock);
5249
5250 if (ua_sess->deleted) {
5251 ret = 0;
5252 goto end_unlock;
5253 }
5254
5255 /* Lookup channel in the ust app session */
5256 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &iter);
5257 ua_chan_node = lttng_ht_iter_get_node_str(&iter);
5258 /* If the channel is not found, there is a code flow error */
5259 assert(ua_chan_node);
5260
5261 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
5262
5263 ua_event = find_ust_app_event(ua_chan->events, uevent->attr.name,
5264 uevent->filter, uevent->attr.loglevel, uevent->exclusion);
5265 if (ua_event == NULL) {
5266 ret = create_ust_app_event(ua_sess, ua_chan, uevent, app);
5267 if (ret < 0) {
5268 goto end_unlock;
5269 }
5270 } else {
5271 ret = enable_ust_app_event(ua_sess, ua_event, app);
5272 if (ret < 0) {
5273 goto end_unlock;
5274 }
5275 }
5276
5277 end_unlock:
5278 pthread_mutex_unlock(&ua_sess->lock);
5279 end:
5280 rcu_read_unlock();
5281 return ret;
5282 }
5283
5284 /*
5285 * Receive registration and populate the given msg structure.
5286 *
5287 * On success return 0 else a negative value returned by the ustctl call.
5288 */
5289 int ust_app_recv_registration(int sock, struct ust_register_msg *msg)
5290 {
5291 int ret;
5292 uint32_t pid, ppid, uid, gid;
5293
5294 assert(msg);
5295
5296 ret = ustctl_recv_reg_msg(sock, &msg->type, &msg->major, &msg->minor,
5297 &pid, &ppid, &uid, &gid,
5298 &msg->bits_per_long,
5299 &msg->uint8_t_alignment,
5300 &msg->uint16_t_alignment,
5301 &msg->uint32_t_alignment,
5302 &msg->uint64_t_alignment,
5303 &msg->long_alignment,
5304 &msg->byte_order,
5305 msg->name);
5306 if (ret < 0) {
5307 switch (-ret) {
5308 case EPIPE:
5309 case ECONNRESET:
5310 case LTTNG_UST_ERR_EXITING:
5311 DBG3("UST app recv reg message failed. Application died");
5312 break;
5313 case LTTNG_UST_ERR_UNSUP_MAJOR:
5314 ERR("UST app recv reg unsupported version %d.%d. Supporting %d.%d",
5315 msg->major, msg->minor, LTTNG_UST_ABI_MAJOR_VERSION,
5316 LTTNG_UST_ABI_MINOR_VERSION);
5317 break;
5318 default:
5319 ERR("UST app recv reg message failed with ret %d", ret);
5320 break;
5321 }
5322 goto error;
5323 }
5324 msg->pid = (pid_t) pid;
5325 msg->ppid = (pid_t) ppid;
5326 msg->uid = (uid_t) uid;
5327 msg->gid = (gid_t) gid;
5328
5329 error:
5330 return ret;
5331 }
5332
5333 /*
5334 * Return a ust app session object using the application object and the
5335 * session object descriptor has a key. If not found, NULL is returned.
5336 * A RCU read side lock MUST be acquired when calling this function.
5337 */
5338 static struct ust_app_session *find_session_by_objd(struct ust_app *app,
5339 int objd)
5340 {
5341 struct lttng_ht_node_ulong *node;
5342 struct lttng_ht_iter iter;
5343 struct ust_app_session *ua_sess = NULL;
5344
5345 assert(app);
5346
5347 lttng_ht_lookup(app->ust_sessions_objd, (void *)((unsigned long) objd), &iter);
5348 node = lttng_ht_iter_get_node_ulong(&iter);
5349 if (node == NULL) {
5350 DBG2("UST app session find by objd %d not found", objd);
5351 goto error;
5352 }
5353
5354 ua_sess = caa_container_of(node, struct ust_app_session, ust_objd_node);
5355
5356 error:
5357 return ua_sess;
5358 }
5359
5360 /*
5361 * Return a ust app channel object using the application object and the channel
5362 * object descriptor has a key. If not found, NULL is returned. A RCU read side
5363 * lock MUST be acquired before calling this function.
5364 */
5365 static struct ust_app_channel *find_channel_by_objd(struct ust_app *app,
5366 int objd)
5367 {
5368 struct lttng_ht_node_ulong *node;
5369 struct lttng_ht_iter iter;
5370 struct ust_app_channel *ua_chan = NULL;
5371
5372 assert(app);
5373
5374 lttng_ht_lookup(app->ust_objd, (void *)((unsigned long) objd), &iter);
5375 node = lttng_ht_iter_get_node_ulong(&iter);
5376 if (node == NULL) {
5377 DBG2("UST app channel find by objd %d not found", objd);
5378 goto error;
5379 }
5380
5381 ua_chan = caa_container_of(node, struct ust_app_channel, ust_objd_node);
5382
5383 error:
5384 return ua_chan;
5385 }
5386
5387 /*
5388 * Reply to a register channel notification from an application on the notify
5389 * socket. The channel metadata is also created.
5390 *
5391 * The session UST registry lock is acquired in this function.
5392 *
5393 * On success 0 is returned else a negative value.
5394 */
5395 static int reply_ust_register_channel(int sock, int sobjd, int cobjd,
5396 size_t nr_fields, struct ustctl_field *fields)
5397 {
5398 int ret, ret_code = 0;
5399 uint32_t chan_id, reg_count;
5400 uint64_t chan_reg_key;
5401 enum ustctl_channel_header type;
5402 struct ust_app *app;
5403 struct ust_app_channel *ua_chan;
5404 struct ust_app_session *ua_sess;
5405 struct ust_registry_session *registry;
5406 struct ust_registry_channel *chan_reg;
5407
5408 rcu_read_lock();
5409
5410 /* Lookup application. If not found, there is a code flow error. */
5411 app = find_app_by_notify_sock(sock);
5412 if (!app) {
5413 DBG("Application socket %d is being torn down. Abort event notify",
5414 sock);
5415 ret = 0;
5416 goto error_rcu_unlock;
5417 }
5418
5419 /* Lookup channel by UST object descriptor. */
5420 ua_chan = find_channel_by_objd(app, cobjd);
5421 if (!ua_chan) {
5422 DBG("Application channel is being torn down. Abort event notify");
5423 ret = 0;
5424 goto error_rcu_unlock;
5425 }
5426
5427 assert(ua_chan->session);
5428 ua_sess = ua_chan->session;
5429
5430 /* Get right session registry depending on the session buffer type. */
5431 registry = get_session_registry(ua_sess);
5432 if (!registry) {
5433 DBG("Application session is being torn down. Abort event notify");
5434 ret = 0;
5435 goto error_rcu_unlock;
5436 };
5437
5438 /* Depending on the buffer type, a different channel key is used. */
5439 if (ua_sess->buffer_type == LTTNG_BUFFER_PER_UID) {
5440 chan_reg_key = ua_chan->tracing_channel_id;
5441 } else {
5442 chan_reg_key = ua_chan->key;
5443 }
5444
5445 pthread_mutex_lock(&registry->lock);
5446
5447 chan_reg = ust_registry_channel_find(registry, chan_reg_key);
5448 assert(chan_reg);
5449
5450 if (!chan_reg->register_done) {
5451 reg_count = ust_registry_get_event_count(chan_reg);
5452 if (reg_count < 31) {
5453 type = USTCTL_CHANNEL_HEADER_COMPACT;
5454 } else {
5455 type = USTCTL_CHANNEL_HEADER_LARGE;
5456 }
5457
5458 chan_reg->nr_ctx_fields = nr_fields;
5459 chan_reg->ctx_fields = fields;
5460 fields = NULL;
5461 chan_reg->header_type = type;
5462 } else {
5463 /* Get current already assigned values. */
5464 type = chan_reg->header_type;
5465 }
5466 /* Channel id is set during the object creation. */
5467 chan_id = chan_reg->chan_id;
5468
5469 /* Append to metadata */
5470 if (!chan_reg->metadata_dumped) {
5471 ret_code = ust_metadata_channel_statedump(registry, chan_reg);
5472 if (ret_code) {
5473 ERR("Error appending channel metadata (errno = %d)", ret_code);
5474 goto reply;
5475 }
5476 }
5477
5478 reply:
5479 DBG3("UST app replying to register channel key %" PRIu64
5480 " with id %u, type: %d, ret: %d", chan_reg_key, chan_id, type,
5481 ret_code);
5482
5483 ret = ustctl_reply_register_channel(sock, chan_id, type, ret_code);
5484 if (ret < 0) {
5485 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
5486 ERR("UST app reply channel failed with ret %d", ret);
5487 } else {
5488 DBG3("UST app reply channel failed. Application died");
5489 }
5490 goto error;
5491 }
5492
5493 /* This channel registry registration is completed. */
5494 chan_reg->register_done = 1;
5495
5496 error:
5497 pthread_mutex_unlock(&registry->lock);
5498 error_rcu_unlock:
5499 rcu_read_unlock();
5500 free(fields);
5501 return ret;
5502 }
5503
5504 /*
5505 * Add event to the UST channel registry. When the event is added to the
5506 * registry, the metadata is also created. Once done, this replies to the
5507 * application with the appropriate error code.
5508 *
5509 * The session UST registry lock is acquired in the function.
5510 *
5511 * On success 0 is returned else a negative value.
5512 */
5513 static int add_event_ust_registry(int sock, int sobjd, int cobjd, char *name,
5514 char *sig, size_t nr_fields, struct ustctl_field *fields,
5515 int loglevel_value, char *model_emf_uri)
5516 {
5517 int ret, ret_code;
5518 uint32_t event_id = 0;
5519 uint64_t chan_reg_key;
5520 struct ust_app *app;
5521 struct ust_app_channel *ua_chan;
5522 struct ust_app_session *ua_sess;
5523 struct ust_registry_session *registry;
5524
5525 rcu_read_lock();
5526
5527 /* Lookup application. If not found, there is a code flow error. */
5528 app = find_app_by_notify_sock(sock);
5529 if (!app) {
5530 DBG("Application socket %d is being torn down. Abort event notify",
5531 sock);
5532 ret = 0;
5533 goto error_rcu_unlock;
5534 }
5535
5536 /* Lookup channel by UST object descriptor. */
5537 ua_chan = find_channel_by_objd(app, cobjd);
5538 if (!ua_chan) {
5539 DBG("Application channel is being torn down. Abort event notify");
5540 ret = 0;
5541 goto error_rcu_unlock;
5542 }
5543
5544 assert(ua_chan->session);
5545 ua_sess = ua_chan->session;
5546
5547 registry = get_session_registry(ua_sess);
5548 if (!registry) {
5549 DBG("Application session is being torn down. Abort event notify");
5550 ret = 0;
5551 goto error_rcu_unlock;
5552 }
5553
5554 if (ua_sess->buffer_type == LTTNG_BUFFER_PER_UID) {
5555 chan_reg_key = ua_chan->tracing_channel_id;
5556 } else {
5557 chan_reg_key = ua_chan->key;
5558 }
5559
5560 pthread_mutex_lock(&registry->lock);
5561
5562 /*
5563 * From this point on, this call acquires the ownership of the sig, fields
5564 * and model_emf_uri meaning any free are done inside it if needed. These
5565 * three variables MUST NOT be read/write after this.
5566 */
5567 ret_code = ust_registry_create_event(registry, chan_reg_key,
5568 sobjd, cobjd, name, sig, nr_fields, fields,
5569 loglevel_value, model_emf_uri, ua_sess->buffer_type,
5570 &event_id, app);
5571 sig = NULL;
5572 fields = NULL;
5573 model_emf_uri = NULL;
5574
5575 /*
5576 * The return value is returned to ustctl so in case of an error, the
5577 * application can be notified. In case of an error, it's important not to
5578 * return a negative error or else the application will get closed.
5579 */
5580 ret = ustctl_reply_register_event(sock, event_id, ret_code);
5581 if (ret < 0) {
5582 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
5583 ERR("UST app reply event failed with ret %d", ret);
5584 } else {
5585 DBG3("UST app reply event failed. Application died");
5586 }
5587 /*
5588 * No need to wipe the create event since the application socket will
5589 * get close on error hence cleaning up everything by itself.
5590 */
5591 goto error;
5592 }
5593
5594 DBG3("UST registry event %s with id %" PRId32 " added successfully",
5595 name, event_id);
5596
5597 error:
5598 pthread_mutex_unlock(&registry->lock);
5599 error_rcu_unlock:
5600 rcu_read_unlock();
5601 free(sig);
5602 free(fields);
5603 free(model_emf_uri);
5604 return ret;
5605 }
5606
5607 /*
5608 * Add enum to the UST session registry. Once done, this replies to the
5609 * application with the appropriate error code.
5610 *
5611 * The session UST registry lock is acquired within this function.
5612 *
5613 * On success 0 is returned else a negative value.
5614 */
5615 static int add_enum_ust_registry(int sock, int sobjd, char *name,
5616 struct ustctl_enum_entry *entries, size_t nr_entries)
5617 {
5618 int ret = 0, ret_code;
5619 struct ust_app *app;
5620 struct ust_app_session *ua_sess;
5621 struct ust_registry_session *registry;
5622 uint64_t enum_id = -1ULL;
5623
5624 rcu_read_lock();
5625
5626 /* Lookup application. If not found, there is a code flow error. */
5627 app = find_app_by_notify_sock(sock);
5628 if (!app) {
5629 /* Return an error since this is not an error */
5630 DBG("Application socket %d is being torn down. Aborting enum registration",
5631 sock);
5632 free(entries);
5633 goto error_rcu_unlock;
5634 }
5635
5636 /* Lookup session by UST object descriptor. */
5637 ua_sess = find_session_by_objd(app, sobjd);
5638 if (!ua_sess) {
5639 /* Return an error since this is not an error */
5640 DBG("Application session is being torn down (session not found). Aborting enum registration.");
5641 free(entries);
5642 goto error_rcu_unlock;
5643 }
5644
5645 registry = get_session_registry(ua_sess);
5646 if (!registry) {
5647 DBG("Application session is being torn down (registry not found). Aborting enum registration.");
5648 free(entries);
5649 goto error_rcu_unlock;
5650 }
5651
5652 pthread_mutex_lock(&registry->lock);
5653
5654 /*
5655 * From this point on, the callee acquires the ownership of
5656 * entries. The variable entries MUST NOT be read/written after
5657 * call.
5658 */
5659 ret_code = ust_registry_create_or_find_enum(registry, sobjd, name,
5660 entries, nr_entries, &enum_id);
5661 entries = NULL;
5662
5663 /*
5664 * The return value is returned to ustctl so in case of an error, the
5665 * application can be notified. In case of an error, it's important not to
5666 * return a negative error or else the application will get closed.
5667 */
5668 ret = ustctl_reply_register_enum(sock, enum_id, ret_code);
5669 if (ret < 0) {
5670 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
5671 ERR("UST app reply enum failed with ret %d", ret);
5672 } else {
5673 DBG3("UST app reply enum failed. Application died");
5674 }
5675 /*
5676 * No need to wipe the create enum since the application socket will
5677 * get close on error hence cleaning up everything by itself.
5678 */
5679 goto error;
5680 }
5681
5682 DBG3("UST registry enum %s added successfully or already found", name);
5683
5684 error:
5685 pthread_mutex_unlock(&registry->lock);
5686 error_rcu_unlock:
5687 rcu_read_unlock();
5688 return ret;
5689 }
5690
5691 /*
5692 * Handle application notification through the given notify socket.
5693 *
5694 * Return 0 on success or else a negative value.
5695 */
5696 int ust_app_recv_notify(int sock)
5697 {
5698 int ret;
5699 enum ustctl_notify_cmd cmd;
5700
5701 DBG3("UST app receiving notify from sock %d", sock);
5702
5703 ret = ustctl_recv_notify(sock, &cmd);
5704 if (ret < 0) {
5705 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
5706 ERR("UST app recv notify failed with ret %d", ret);
5707 } else {
5708 DBG3("UST app recv notify failed. Application died");
5709 }
5710 goto error;
5711 }
5712
5713 switch (cmd) {
5714 case USTCTL_NOTIFY_CMD_EVENT:
5715 {
5716 int sobjd, cobjd, loglevel_value;
5717 char name[LTTNG_UST_SYM_NAME_LEN], *sig, *model_emf_uri;
5718 size_t nr_fields;
5719 struct ustctl_field *fields;
5720
5721 DBG2("UST app ustctl register event received");
5722
5723 ret = ustctl_recv_register_event(sock, &sobjd, &cobjd, name,
5724 &loglevel_value, &sig, &nr_fields, &fields,
5725 &model_emf_uri);
5726 if (ret < 0) {
5727 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
5728 ERR("UST app recv event failed with ret %d", ret);
5729 } else {
5730 DBG3("UST app recv event failed. Application died");
5731 }
5732 goto error;
5733 }
5734
5735 /*
5736 * Add event to the UST registry coming from the notify socket. This
5737 * call will free if needed the sig, fields and model_emf_uri. This
5738 * code path loses the ownsership of these variables and transfer them
5739 * to the this function.
5740 */
5741 ret = add_event_ust_registry(sock, sobjd, cobjd, name, sig, nr_fields,
5742 fields, loglevel_value, model_emf_uri);
5743 if (ret < 0) {
5744 goto error;
5745 }
5746
5747 break;
5748 }
5749 case USTCTL_NOTIFY_CMD_CHANNEL:
5750 {
5751 int sobjd, cobjd;
5752 size_t nr_fields;
5753 struct ustctl_field *fields;
5754
5755 DBG2("UST app ustctl register channel received");
5756
5757 ret = ustctl_recv_register_channel(sock, &sobjd, &cobjd, &nr_fields,
5758 &fields);
5759 if (ret < 0) {
5760 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
5761 ERR("UST app recv channel failed with ret %d", ret);
5762 } else {
5763 DBG3("UST app recv channel failed. Application died");
5764 }
5765 goto error;
5766 }
5767
5768 /*
5769 * The fields ownership are transfered to this function call meaning
5770 * that if needed it will be freed. After this, it's invalid to access
5771 * fields or clean it up.
5772 */
5773 ret = reply_ust_register_channel(sock, sobjd, cobjd, nr_fields,
5774 fields);
5775 if (ret < 0) {
5776 goto error;
5777 }
5778
5779 break;
5780 }
5781 case USTCTL_NOTIFY_CMD_ENUM:
5782 {
5783 int sobjd;
5784 char name[LTTNG_UST_SYM_NAME_LEN];
5785 size_t nr_entries;
5786 struct ustctl_enum_entry *entries;
5787
5788 DBG2("UST app ustctl register enum received");
5789
5790 ret = ustctl_recv_register_enum(sock, &sobjd, name,
5791 &entries, &nr_entries);
5792 if (ret < 0) {
5793 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
5794 ERR("UST app recv enum failed with ret %d", ret);
5795 } else {
5796 DBG3("UST app recv enum failed. Application died");
5797 }
5798 goto error;
5799 }
5800
5801 /* Callee assumes ownership of entries */
5802 ret = add_enum_ust_registry(sock, sobjd, name,
5803 entries, nr_entries);
5804 if (ret < 0) {
5805 goto error;
5806 }
5807
5808 break;
5809 }
5810 default:
5811 /* Should NEVER happen. */
5812 assert(0);
5813 }
5814
5815 error:
5816 return ret;
5817 }
5818
5819 /*
5820 * Once the notify socket hangs up, this is called. First, it tries to find the
5821 * corresponding application. On failure, the call_rcu to close the socket is
5822 * executed. If an application is found, it tries to delete it from the notify
5823 * socket hash table. Whathever the result, it proceeds to the call_rcu.
5824 *
5825 * Note that an object needs to be allocated here so on ENOMEM failure, the
5826 * call RCU is not done but the rest of the cleanup is.
5827 */
5828 void ust_app_notify_sock_unregister(int sock)
5829 {
5830 int err_enomem = 0;
5831 struct lttng_ht_iter iter;
5832 struct ust_app *app;
5833 struct ust_app_notify_sock_obj *obj;
5834
5835 assert(sock >= 0);
5836
5837 rcu_read_lock();
5838
5839 obj = zmalloc(sizeof(*obj));
5840 if (!obj) {
5841 /*
5842 * An ENOMEM is kind of uncool. If this strikes we continue the
5843 * procedure but the call_rcu will not be called. In this case, we
5844 * accept the fd leak rather than possibly creating an unsynchronized
5845 * state between threads.
5846 *
5847 * TODO: The notify object should be created once the notify socket is
5848 * registered and stored independantely from the ust app object. The
5849 * tricky part is to synchronize the teardown of the application and
5850 * this notify object. Let's keep that in mind so we can avoid this
5851 * kind of shenanigans with ENOMEM in the teardown path.
5852 */
5853 err_enomem = 1;
5854 } else {
5855 obj->fd = sock;
5856 }
5857
5858 DBG("UST app notify socket unregister %d", sock);
5859
5860 /*
5861 * Lookup application by notify socket. If this fails, this means that the
5862 * hash table delete has already been done by the application
5863 * unregistration process so we can safely close the notify socket in a
5864 * call RCU.
5865 */
5866 app = find_app_by_notify_sock(sock);
5867 if (!app) {
5868 goto close_socket;
5869 }
5870
5871 iter.iter.node = &app->notify_sock_n.node;
5872
5873 /*
5874 * Whatever happens here either we fail or succeed, in both cases we have
5875 * to close the socket after a grace period to continue to the call RCU
5876 * here. If the deletion is successful, the application is not visible
5877 * anymore by other threads and is it fails it means that it was already
5878 * deleted from the hash table so either way we just have to close the
5879 * socket.
5880 */
5881 (void) lttng_ht_del(ust_app_ht_by_notify_sock, &iter);
5882
5883 close_socket:
5884 rcu_read_unlock();
5885
5886 /*
5887 * Close socket after a grace period to avoid for the socket to be reused
5888 * before the application object is freed creating potential race between
5889 * threads trying to add unique in the global hash table.
5890 */
5891 if (!err_enomem) {
5892 call_rcu(&obj->head, close_notify_sock_rcu);
5893 }
5894 }
5895
5896 /*
5897 * Destroy a ust app data structure and free its memory.
5898 */
5899 void ust_app_destroy(struct ust_app *app)
5900 {
5901 if (!app) {
5902 return;
5903 }
5904
5905 call_rcu(&app->pid_n.head, delete_ust_app_rcu);
5906 }
5907
5908 /*
5909 * Take a snapshot for a given UST session. The snapshot is sent to the given
5910 * output.
5911 *
5912 * Return 0 on success or else a negative value.
5913 */
5914 int ust_app_snapshot_record(struct ltt_ust_session *usess,
5915 struct snapshot_output *output, int wait,
5916 uint64_t nb_packets_per_stream)
5917 {
5918 int ret = 0;
5919 struct lttng_ht_iter iter;
5920 struct ust_app *app;
5921 char pathname[PATH_MAX];
5922
5923 assert(usess);
5924 assert(output);
5925
5926 rcu_read_lock();
5927
5928 switch (usess->buffer_type) {
5929 case LTTNG_BUFFER_PER_UID:
5930 {
5931 struct buffer_reg_uid *reg;
5932
5933 cds_list_for_each_entry(reg, &usess->buffer_reg_uid_list, lnode) {
5934 struct buffer_reg_channel *reg_chan;
5935 struct consumer_socket *socket;
5936
5937 /* Get consumer socket to use to push the metadata.*/
5938 socket = consumer_find_socket_by_bitness(reg->bits_per_long,
5939 usess->consumer);
5940 if (!socket) {
5941 ret = -EINVAL;
5942 goto error;
5943 }
5944
5945 memset(pathname, 0, sizeof(pathname));
5946 ret = snprintf(pathname, sizeof(pathname),
5947 DEFAULT_UST_TRACE_DIR "/" DEFAULT_UST_TRACE_UID_PATH,
5948 reg->uid, reg->bits_per_long);
5949 if (ret < 0) {
5950 PERROR("snprintf snapshot path");
5951 goto error;
5952 }
5953
5954 /* Add the UST default trace dir to path. */
5955 cds_lfht_for_each_entry(reg->registry->channels->ht, &iter.iter,
5956 reg_chan, node.node) {
5957 ret = consumer_snapshot_channel(socket, reg_chan->consumer_key,
5958 output, 0, usess->uid, usess->gid, pathname, wait,
5959 nb_packets_per_stream);
5960 if (ret < 0) {
5961 goto error;
5962 }
5963 }
5964 ret = consumer_snapshot_channel(socket,
5965 reg->registry->reg.ust->metadata_key, output, 1,
5966 usess->uid, usess->gid, pathname, wait, 0);
5967 if (ret < 0) {
5968 goto error;
5969 }
5970 }
5971 break;
5972 }
5973 case LTTNG_BUFFER_PER_PID:
5974 {
5975 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
5976 struct consumer_socket *socket;
5977 struct lttng_ht_iter chan_iter;
5978 struct ust_app_channel *ua_chan;
5979 struct ust_app_session *ua_sess;
5980 struct ust_registry_session *registry;
5981
5982 ua_sess = lookup_session_by_app(usess, app);
5983 if (!ua_sess) {
5984 /* Session not associated with this app. */
5985 continue;
5986 }
5987
5988 /* Get the right consumer socket for the application. */
5989 socket = consumer_find_socket_by_bitness(app->bits_per_long,
5990 output->consumer);
5991 if (!socket) {
5992 ret = -EINVAL;
5993 goto error;
5994 }
5995
5996 /* Add the UST default trace dir to path. */
5997 memset(pathname, 0, sizeof(pathname));
5998 ret = snprintf(pathname, sizeof(pathname), DEFAULT_UST_TRACE_DIR "/%s",
5999 ua_sess->path);
6000 if (ret < 0) {
6001 PERROR("snprintf snapshot path");
6002 goto error;
6003 }
6004
6005 cds_lfht_for_each_entry(ua_sess->channels->ht, &chan_iter.iter,
6006 ua_chan, node.node) {
6007 ret = consumer_snapshot_channel(socket, ua_chan->key, output,
6008 0, ua_sess->euid, ua_sess->egid, pathname, wait,
6009 nb_packets_per_stream);
6010 if (ret < 0) {
6011 goto error;
6012 }
6013 }
6014
6015 registry = get_session_registry(ua_sess);
6016 if (!registry) {
6017 DBG("Application session is being torn down. Abort snapshot record.");
6018 ret = -1;
6019 goto error;
6020 }
6021 ret = consumer_snapshot_channel(socket, registry->metadata_key, output,
6022 1, ua_sess->euid, ua_sess->egid, pathname, wait, 0);
6023 if (ret < 0) {
6024 goto error;
6025 }
6026 }
6027 break;
6028 }
6029 default:
6030 assert(0);
6031 break;
6032 }
6033
6034 error:
6035 rcu_read_unlock();
6036 return ret;
6037 }
6038
6039 /*
6040 * Return the size taken by one more packet per stream.
6041 */
6042 uint64_t ust_app_get_size_one_more_packet_per_stream(struct ltt_ust_session *usess,
6043 uint64_t cur_nr_packets)
6044 {
6045 uint64_t tot_size = 0;
6046 struct ust_app *app;
6047 struct lttng_ht_iter iter;
6048
6049 assert(usess);
6050
6051 switch (usess->buffer_type) {
6052 case LTTNG_BUFFER_PER_UID:
6053 {
6054 struct buffer_reg_uid *reg;
6055
6056 cds_list_for_each_entry(reg, &usess->buffer_reg_uid_list, lnode) {
6057 struct buffer_reg_channel *reg_chan;
6058
6059 rcu_read_lock();
6060 cds_lfht_for_each_entry(reg->registry->channels->ht, &iter.iter,
6061 reg_chan, node.node) {
6062 if (cur_nr_packets >= reg_chan->num_subbuf) {
6063 /*
6064 * Don't take channel into account if we
6065 * already grab all its packets.
6066 */
6067 continue;
6068 }
6069 tot_size += reg_chan->subbuf_size * reg_chan->stream_count;
6070 }
6071 rcu_read_unlock();
6072 }
6073 break;
6074 }
6075 case LTTNG_BUFFER_PER_PID:
6076 {
6077 rcu_read_lock();
6078 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
6079 struct ust_app_channel *ua_chan;
6080 struct ust_app_session *ua_sess;
6081 struct lttng_ht_iter chan_iter;
6082
6083 ua_sess = lookup_session_by_app(usess, app);
6084 if (!ua_sess) {
6085 /* Session not associated with this app. */
6086 continue;
6087 }
6088
6089 cds_lfht_for_each_entry(ua_sess->channels->ht, &chan_iter.iter,
6090 ua_chan, node.node) {
6091 if (cur_nr_packets >= ua_chan->attr.num_subbuf) {
6092 /*
6093 * Don't take channel into account if we
6094 * already grab all its packets.
6095 */
6096 continue;
6097 }
6098 tot_size += ua_chan->attr.subbuf_size * ua_chan->streams.count;
6099 }
6100 }
6101 rcu_read_unlock();
6102 break;
6103 }
6104 default:
6105 assert(0);
6106 break;
6107 }
6108
6109 return tot_size;
6110 }
6111
6112 int ust_app_uid_get_channel_runtime_stats(uint64_t ust_session_id,
6113 struct cds_list_head *buffer_reg_uid_list,
6114 struct consumer_output *consumer, uint64_t uchan_id,
6115 int overwrite, uint64_t *discarded, uint64_t *lost)
6116 {
6117 int ret;
6118 uint64_t consumer_chan_key;
6119
6120 *discarded = 0;
6121 *lost = 0;
6122
6123 ret = buffer_reg_uid_consumer_channel_key(
6124 buffer_reg_uid_list, ust_session_id,
6125 uchan_id, &consumer_chan_key);
6126 if (ret < 0) {
6127 /* Not found */
6128 ret = 0;
6129 goto end;
6130 }
6131
6132 if (overwrite) {
6133 ret = consumer_get_lost_packets(ust_session_id,
6134 consumer_chan_key, consumer, lost);
6135 } else {
6136 ret = consumer_get_discarded_events(ust_session_id,
6137 consumer_chan_key, consumer, discarded);
6138 }
6139
6140 end:
6141 return ret;
6142 }
6143
6144 int ust_app_pid_get_channel_runtime_stats(struct ltt_ust_session *usess,
6145 struct ltt_ust_channel *uchan,
6146 struct consumer_output *consumer, int overwrite,
6147 uint64_t *discarded, uint64_t *lost)
6148 {
6149 int ret = 0;
6150 struct lttng_ht_iter iter;
6151 struct lttng_ht_node_str *ua_chan_node;
6152 struct ust_app *app;
6153 struct ust_app_session *ua_sess;
6154 struct ust_app_channel *ua_chan;
6155
6156 *discarded = 0;
6157 *lost = 0;
6158
6159 rcu_read_lock();
6160 /*
6161 * Iterate over every registered applications. Sum counters for
6162 * all applications containing requested session and channel.
6163 */
6164 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
6165 struct lttng_ht_iter uiter;
6166
6167 ua_sess = lookup_session_by_app(usess, app);
6168 if (ua_sess == NULL) {
6169 continue;
6170 }
6171
6172 /* Get channel */
6173 lttng_ht_lookup(ua_sess->channels, (void *) uchan->name, &uiter);
6174 ua_chan_node = lttng_ht_iter_get_node_str(&uiter);
6175 /* If the session is found for the app, the channel must be there */
6176 assert(ua_chan_node);
6177
6178 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
6179
6180 if (overwrite) {
6181 uint64_t _lost;
6182
6183 ret = consumer_get_lost_packets(usess->id, ua_chan->key,
6184 consumer, &_lost);
6185 if (ret < 0) {
6186 break;
6187 }
6188 (*lost) += _lost;
6189 } else {
6190 uint64_t _discarded;
6191
6192 ret = consumer_get_discarded_events(usess->id,
6193 ua_chan->key, consumer, &_discarded);
6194 if (ret < 0) {
6195 break;
6196 }
6197 (*discarded) += _discarded;
6198 }
6199 }
6200
6201 rcu_read_unlock();
6202 return ret;
6203 }
6204
6205 static
6206 int ust_app_regenerate_statedump(struct ltt_ust_session *usess,
6207 struct ust_app *app)
6208 {
6209 int ret = 0;
6210 struct ust_app_session *ua_sess;
6211
6212 DBG("Regenerating the metadata for ust app pid %d", app->pid);
6213
6214 rcu_read_lock();
6215
6216 ua_sess = lookup_session_by_app(usess, app);
6217 if (ua_sess == NULL) {
6218 /* The session is in teardown process. Ignore and continue. */
6219 goto end;
6220 }
6221
6222 pthread_mutex_lock(&ua_sess->lock);
6223
6224 if (ua_sess->deleted) {
6225 goto end_unlock;
6226 }
6227
6228 pthread_mutex_lock(&app->sock_lock);
6229 ret = ustctl_regenerate_statedump(app->sock, ua_sess->handle);
6230 pthread_mutex_unlock(&app->sock_lock);
6231
6232 end_unlock:
6233 pthread_mutex_unlock(&ua_sess->lock);
6234
6235 end:
6236 rcu_read_unlock();
6237 health_code_update();
6238 return ret;
6239 }
6240
6241 /*
6242 * Regenerate the statedump for each app in the session.
6243 */
6244 int ust_app_regenerate_statedump_all(struct ltt_ust_session *usess)
6245 {
6246 int ret = 0;
6247 struct lttng_ht_iter iter;
6248 struct ust_app *app;
6249
6250 DBG("Regenerating the metadata for all UST apps");
6251
6252 rcu_read_lock();
6253
6254 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
6255 if (!app->compatible) {
6256 continue;
6257 }
6258
6259 ret = ust_app_regenerate_statedump(usess, app);
6260 if (ret < 0) {
6261 /* Continue to the next app even on error */
6262 continue;
6263 }
6264 }
6265
6266 rcu_read_unlock();
6267
6268 return 0;
6269 }
This page took 0.176173 seconds and 4 git commands to generate.