Sessiond rotation thread
[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 chan_reg_key = ua_chan->tracing_channel_id;
2929
2930 pthread_mutex_lock(&reg_uid->registry->reg.ust->lock);
2931 chan_reg = ust_registry_channel_find(reg_uid->registry->reg.ust,
2932 chan_reg_key);
2933 assert(chan_reg);
2934 chan_reg->consumer_key = ua_chan->key;
2935 chan_reg = NULL;
2936 pthread_mutex_unlock(&reg_uid->registry->reg.ust->lock);
2937
2938 session = session_find_by_id(ua_sess->tracing_id);
2939 assert(session);
2940
2941 cmd_ret = notification_thread_command_add_channel(
2942 notification_thread_handle, session->name,
2943 ua_sess->euid, ua_sess->egid,
2944 ua_chan->name,
2945 ua_chan->key,
2946 LTTNG_DOMAIN_UST,
2947 ua_chan->attr.subbuf_size * ua_chan->attr.num_subbuf);
2948 if (cmd_ret != LTTNG_OK) {
2949 ret = - (int) cmd_ret;
2950 ERR("Failed to add channel to notification thread");
2951 goto error;
2952 }
2953 }
2954
2955 /* Send buffers to the application. */
2956 ret = send_channel_uid_to_ust(reg_chan, app, ua_sess, ua_chan);
2957 if (ret < 0) {
2958 if (ret != -ENOTCONN) {
2959 ERR("Error sending channel to application");
2960 }
2961 goto error;
2962 }
2963
2964 error:
2965 return ret;
2966 }
2967
2968 /*
2969 * Create and send to the application the created buffers with per PID buffers.
2970 *
2971 * Called with UST app session lock held.
2972 *
2973 * Return 0 on success else a negative value.
2974 */
2975 static int create_channel_per_pid(struct ust_app *app,
2976 struct ltt_ust_session *usess, struct ust_app_session *ua_sess,
2977 struct ust_app_channel *ua_chan)
2978 {
2979 int ret;
2980 struct ust_registry_session *registry;
2981 enum lttng_error_code cmd_ret;
2982 struct ltt_session *session;
2983 uint64_t chan_reg_key;
2984 struct ust_registry_channel *chan_reg;
2985
2986 assert(app);
2987 assert(usess);
2988 assert(ua_sess);
2989 assert(ua_chan);
2990
2991 DBG("UST app creating channel %s with per PID buffers", ua_chan->name);
2992
2993 rcu_read_lock();
2994
2995 registry = get_session_registry(ua_sess);
2996 /* The UST app session lock is held, registry shall not be null. */
2997 assert(registry);
2998
2999 /* Create and add a new channel registry to session. */
3000 ret = ust_registry_channel_add(registry, ua_chan->key);
3001 if (ret < 0) {
3002 ERR("Error creating the UST channel \"%s\" registry instance",
3003 ua_chan->name);
3004 goto error;
3005 }
3006
3007 /* Create and get channel on the consumer side. */
3008 ret = do_consumer_create_channel(usess, ua_sess, ua_chan,
3009 app->bits_per_long, registry);
3010 if (ret < 0) {
3011 ERR("Error creating UST channel \"%s\" on the consumer daemon",
3012 ua_chan->name);
3013 goto error;
3014 }
3015
3016 ret = send_channel_pid_to_ust(app, ua_sess, ua_chan);
3017 if (ret < 0) {
3018 if (ret != -ENOTCONN) {
3019 ERR("Error sending channel to application");
3020 }
3021 goto error;
3022 }
3023
3024 session = session_find_by_id(ua_sess->tracing_id);
3025 assert(session);
3026
3027 chan_reg_key = ua_chan->key;
3028 pthread_mutex_lock(&registry->lock);
3029 chan_reg = ust_registry_channel_find(registry, chan_reg_key);
3030 assert(chan_reg);
3031 chan_reg->consumer_key = ua_chan->key;
3032 pthread_mutex_unlock(&registry->lock);
3033
3034 cmd_ret = notification_thread_command_add_channel(
3035 notification_thread_handle, session->name,
3036 ua_sess->euid, ua_sess->egid,
3037 ua_chan->name,
3038 ua_chan->key,
3039 LTTNG_DOMAIN_UST,
3040 ua_chan->attr.subbuf_size * ua_chan->attr.num_subbuf);
3041 if (cmd_ret != LTTNG_OK) {
3042 ret = - (int) cmd_ret;
3043 ERR("Failed to add channel to notification thread");
3044 goto error;
3045 }
3046
3047 error:
3048 rcu_read_unlock();
3049 return ret;
3050 }
3051
3052 /*
3053 * From an already allocated ust app channel, create the channel buffers if
3054 * need and send it to the application. This MUST be called with a RCU read
3055 * side lock acquired.
3056 *
3057 * Called with UST app session lock held.
3058 *
3059 * Return 0 on success or else a negative value. Returns -ENOTCONN if
3060 * the application exited concurrently.
3061 */
3062 static int do_create_channel(struct ust_app *app,
3063 struct ltt_ust_session *usess, struct ust_app_session *ua_sess,
3064 struct ust_app_channel *ua_chan)
3065 {
3066 int ret;
3067
3068 assert(app);
3069 assert(usess);
3070 assert(ua_sess);
3071 assert(ua_chan);
3072
3073 /* Handle buffer type before sending the channel to the application. */
3074 switch (usess->buffer_type) {
3075 case LTTNG_BUFFER_PER_UID:
3076 {
3077 ret = create_channel_per_uid(app, usess, ua_sess, ua_chan);
3078 if (ret < 0) {
3079 goto error;
3080 }
3081 break;
3082 }
3083 case LTTNG_BUFFER_PER_PID:
3084 {
3085 ret = create_channel_per_pid(app, usess, ua_sess, ua_chan);
3086 if (ret < 0) {
3087 goto error;
3088 }
3089 break;
3090 }
3091 default:
3092 assert(0);
3093 ret = -EINVAL;
3094 goto error;
3095 }
3096
3097 /* Initialize ust objd object using the received handle and add it. */
3098 lttng_ht_node_init_ulong(&ua_chan->ust_objd_node, ua_chan->handle);
3099 lttng_ht_add_unique_ulong(app->ust_objd, &ua_chan->ust_objd_node);
3100
3101 /* If channel is not enabled, disable it on the tracer */
3102 if (!ua_chan->enabled) {
3103 ret = disable_ust_channel(app, ua_sess, ua_chan);
3104 if (ret < 0) {
3105 goto error;
3106 }
3107 }
3108
3109 error:
3110 return ret;
3111 }
3112
3113 /*
3114 * Create UST app channel and create it on the tracer. Set ua_chanp of the
3115 * newly created channel if not NULL.
3116 *
3117 * Called with UST app session lock and RCU read-side lock held.
3118 *
3119 * Return 0 on success or else a negative value. Returns -ENOTCONN if
3120 * the application exited concurrently.
3121 */
3122 static int create_ust_app_channel(struct ust_app_session *ua_sess,
3123 struct ltt_ust_channel *uchan, struct ust_app *app,
3124 enum lttng_ust_chan_type type, struct ltt_ust_session *usess,
3125 struct ust_app_channel **ua_chanp)
3126 {
3127 int ret = 0;
3128 struct lttng_ht_iter iter;
3129 struct lttng_ht_node_str *ua_chan_node;
3130 struct ust_app_channel *ua_chan;
3131
3132 /* Lookup channel in the ust app session */
3133 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &iter);
3134 ua_chan_node = lttng_ht_iter_get_node_str(&iter);
3135 if (ua_chan_node != NULL) {
3136 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
3137 goto end;
3138 }
3139
3140 ua_chan = alloc_ust_app_channel(uchan->name, ua_sess, &uchan->attr);
3141 if (ua_chan == NULL) {
3142 /* Only malloc can fail here */
3143 ret = -ENOMEM;
3144 goto error_alloc;
3145 }
3146 shadow_copy_channel(ua_chan, uchan);
3147
3148 /* Set channel type. */
3149 ua_chan->attr.type = type;
3150
3151 ret = do_create_channel(app, usess, ua_sess, ua_chan);
3152 if (ret < 0) {
3153 goto error;
3154 }
3155
3156 DBG2("UST app create channel %s for PID %d completed", ua_chan->name,
3157 app->pid);
3158
3159 /* Only add the channel if successful on the tracer side. */
3160 lttng_ht_add_unique_str(ua_sess->channels, &ua_chan->node);
3161 end:
3162 if (ua_chanp) {
3163 *ua_chanp = ua_chan;
3164 }
3165
3166 /* Everything went well. */
3167 return 0;
3168
3169 error:
3170 delete_ust_app_channel(ua_chan->is_sent ? app->sock : -1, ua_chan, app);
3171 error_alloc:
3172 return ret;
3173 }
3174
3175 /*
3176 * Create UST app event and create it on the tracer side.
3177 *
3178 * Called with ust app session mutex held.
3179 */
3180 static
3181 int create_ust_app_event(struct ust_app_session *ua_sess,
3182 struct ust_app_channel *ua_chan, struct ltt_ust_event *uevent,
3183 struct ust_app *app)
3184 {
3185 int ret = 0;
3186 struct ust_app_event *ua_event;
3187
3188 /* Get event node */
3189 ua_event = find_ust_app_event(ua_chan->events, uevent->attr.name,
3190 uevent->filter, uevent->attr.loglevel, uevent->exclusion);
3191 if (ua_event != NULL) {
3192 ret = -EEXIST;
3193 goto end;
3194 }
3195
3196 /* Does not exist so create one */
3197 ua_event = alloc_ust_app_event(uevent->attr.name, &uevent->attr);
3198 if (ua_event == NULL) {
3199 /* Only malloc can failed so something is really wrong */
3200 ret = -ENOMEM;
3201 goto end;
3202 }
3203 shadow_copy_event(ua_event, uevent);
3204
3205 /* Create it on the tracer side */
3206 ret = create_ust_event(app, ua_sess, ua_chan, ua_event);
3207 if (ret < 0) {
3208 /* Not found previously means that it does not exist on the tracer */
3209 assert(ret != -LTTNG_UST_ERR_EXIST);
3210 goto error;
3211 }
3212
3213 add_unique_ust_app_event(ua_chan, ua_event);
3214
3215 DBG2("UST app create event %s for PID %d completed", ua_event->name,
3216 app->pid);
3217
3218 end:
3219 return ret;
3220
3221 error:
3222 /* Valid. Calling here is already in a read side lock */
3223 delete_ust_app_event(-1, ua_event, app);
3224 return ret;
3225 }
3226
3227 /*
3228 * Create UST metadata and open it on the tracer side.
3229 *
3230 * Called with UST app session lock held and RCU read side lock.
3231 */
3232 static int create_ust_app_metadata(struct ust_app_session *ua_sess,
3233 struct ust_app *app, struct consumer_output *consumer)
3234 {
3235 int ret = 0;
3236 struct ust_app_channel *metadata;
3237 struct consumer_socket *socket;
3238 struct ust_registry_session *registry;
3239
3240 assert(ua_sess);
3241 assert(app);
3242 assert(consumer);
3243
3244 registry = get_session_registry(ua_sess);
3245 /* The UST app session is held registry shall not be null. */
3246 assert(registry);
3247
3248 pthread_mutex_lock(&registry->lock);
3249
3250 /* Metadata already exists for this registry or it was closed previously */
3251 if (registry->metadata_key || registry->metadata_closed) {
3252 ret = 0;
3253 goto error;
3254 }
3255
3256 /* Allocate UST metadata */
3257 metadata = alloc_ust_app_channel(DEFAULT_METADATA_NAME, ua_sess, NULL);
3258 if (!metadata) {
3259 /* malloc() failed */
3260 ret = -ENOMEM;
3261 goto error;
3262 }
3263
3264 memcpy(&metadata->attr, &ua_sess->metadata_attr, sizeof(metadata->attr));
3265
3266 /* Need one fd for the channel. */
3267 ret = lttng_fd_get(LTTNG_FD_APPS, 1);
3268 if (ret < 0) {
3269 ERR("Exhausted number of available FD upon create metadata");
3270 goto error;
3271 }
3272
3273 /* Get the right consumer socket for the application. */
3274 socket = consumer_find_socket_by_bitness(app->bits_per_long, consumer);
3275 if (!socket) {
3276 ret = -EINVAL;
3277 goto error_consumer;
3278 }
3279
3280 /*
3281 * Keep metadata key so we can identify it on the consumer side. Assign it
3282 * to the registry *before* we ask the consumer so we avoid the race of the
3283 * consumer requesting the metadata and the ask_channel call on our side
3284 * did not returned yet.
3285 */
3286 registry->metadata_key = metadata->key;
3287
3288 /*
3289 * Ask the metadata channel creation to the consumer. The metadata object
3290 * will be created by the consumer and kept their. However, the stream is
3291 * never added or monitored until we do a first push metadata to the
3292 * consumer.
3293 */
3294 ret = ust_consumer_ask_channel(ua_sess, metadata, consumer, socket,
3295 registry);
3296 if (ret < 0) {
3297 /* Nullify the metadata key so we don't try to close it later on. */
3298 registry->metadata_key = 0;
3299 goto error_consumer;
3300 }
3301
3302 /*
3303 * The setup command will make the metadata stream be sent to the relayd,
3304 * if applicable, and the thread managing the metadatas. This is important
3305 * because after this point, if an error occurs, the only way the stream
3306 * can be deleted is to be monitored in the consumer.
3307 */
3308 ret = consumer_setup_metadata(socket, metadata->key);
3309 if (ret < 0) {
3310 /* Nullify the metadata key so we don't try to close it later on. */
3311 registry->metadata_key = 0;
3312 goto error_consumer;
3313 }
3314
3315 DBG2("UST metadata with key %" PRIu64 " created for app pid %d",
3316 metadata->key, app->pid);
3317
3318 error_consumer:
3319 lttng_fd_put(LTTNG_FD_APPS, 1);
3320 delete_ust_app_channel(-1, metadata, app);
3321 error:
3322 pthread_mutex_unlock(&registry->lock);
3323 return ret;
3324 }
3325
3326 /*
3327 * Return ust app pointer or NULL if not found. RCU read side lock MUST be
3328 * acquired before calling this function.
3329 */
3330 struct ust_app *ust_app_find_by_pid(pid_t pid)
3331 {
3332 struct ust_app *app = NULL;
3333 struct lttng_ht_node_ulong *node;
3334 struct lttng_ht_iter iter;
3335
3336 lttng_ht_lookup(ust_app_ht, (void *)((unsigned long) pid), &iter);
3337 node = lttng_ht_iter_get_node_ulong(&iter);
3338 if (node == NULL) {
3339 DBG2("UST app no found with pid %d", pid);
3340 goto error;
3341 }
3342
3343 DBG2("Found UST app by pid %d", pid);
3344
3345 app = caa_container_of(node, struct ust_app, pid_n);
3346
3347 error:
3348 return app;
3349 }
3350
3351 /*
3352 * Allocate and init an UST app object using the registration information and
3353 * the command socket. This is called when the command socket connects to the
3354 * session daemon.
3355 *
3356 * The object is returned on success or else NULL.
3357 */
3358 struct ust_app *ust_app_create(struct ust_register_msg *msg, int sock)
3359 {
3360 struct ust_app *lta = NULL;
3361
3362 assert(msg);
3363 assert(sock >= 0);
3364
3365 DBG3("UST app creating application for socket %d", sock);
3366
3367 if ((msg->bits_per_long == 64 &&
3368 (uatomic_read(&ust_consumerd64_fd) == -EINVAL))
3369 || (msg->bits_per_long == 32 &&
3370 (uatomic_read(&ust_consumerd32_fd) == -EINVAL))) {
3371 ERR("Registration failed: application \"%s\" (pid: %d) has "
3372 "%d-bit long, but no consumerd for this size is available.\n",
3373 msg->name, msg->pid, msg->bits_per_long);
3374 goto error;
3375 }
3376
3377 lta = zmalloc(sizeof(struct ust_app));
3378 if (lta == NULL) {
3379 PERROR("malloc");
3380 goto error;
3381 }
3382
3383 lta->ppid = msg->ppid;
3384 lta->uid = msg->uid;
3385 lta->gid = msg->gid;
3386
3387 lta->bits_per_long = msg->bits_per_long;
3388 lta->uint8_t_alignment = msg->uint8_t_alignment;
3389 lta->uint16_t_alignment = msg->uint16_t_alignment;
3390 lta->uint32_t_alignment = msg->uint32_t_alignment;
3391 lta->uint64_t_alignment = msg->uint64_t_alignment;
3392 lta->long_alignment = msg->long_alignment;
3393 lta->byte_order = msg->byte_order;
3394
3395 lta->v_major = msg->major;
3396 lta->v_minor = msg->minor;
3397 lta->sessions = lttng_ht_new(0, LTTNG_HT_TYPE_U64);
3398 lta->ust_objd = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG);
3399 lta->ust_sessions_objd = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG);
3400 lta->notify_sock = -1;
3401
3402 /* Copy name and make sure it's NULL terminated. */
3403 strncpy(lta->name, msg->name, sizeof(lta->name));
3404 lta->name[UST_APP_PROCNAME_LEN] = '\0';
3405
3406 /*
3407 * Before this can be called, when receiving the registration information,
3408 * the application compatibility is checked. So, at this point, the
3409 * application can work with this session daemon.
3410 */
3411 lta->compatible = 1;
3412
3413 lta->pid = msg->pid;
3414 lttng_ht_node_init_ulong(&lta->pid_n, (unsigned long) lta->pid);
3415 lta->sock = sock;
3416 pthread_mutex_init(&lta->sock_lock, NULL);
3417 lttng_ht_node_init_ulong(&lta->sock_n, (unsigned long) lta->sock);
3418
3419 CDS_INIT_LIST_HEAD(&lta->teardown_head);
3420 error:
3421 return lta;
3422 }
3423
3424 /*
3425 * For a given application object, add it to every hash table.
3426 */
3427 void ust_app_add(struct ust_app *app)
3428 {
3429 assert(app);
3430 assert(app->notify_sock >= 0);
3431
3432 rcu_read_lock();
3433
3434 /*
3435 * On a re-registration, we want to kick out the previous registration of
3436 * that pid
3437 */
3438 lttng_ht_add_replace_ulong(ust_app_ht, &app->pid_n);
3439
3440 /*
3441 * The socket _should_ be unique until _we_ call close. So, a add_unique
3442 * for the ust_app_ht_by_sock is used which asserts fail if the entry was
3443 * already in the table.
3444 */
3445 lttng_ht_add_unique_ulong(ust_app_ht_by_sock, &app->sock_n);
3446
3447 /* Add application to the notify socket hash table. */
3448 lttng_ht_node_init_ulong(&app->notify_sock_n, app->notify_sock);
3449 lttng_ht_add_unique_ulong(ust_app_ht_by_notify_sock, &app->notify_sock_n);
3450
3451 DBG("App registered with pid:%d ppid:%d uid:%d gid:%d sock:%d name:%s "
3452 "notify_sock:%d (version %d.%d)", app->pid, app->ppid, app->uid,
3453 app->gid, app->sock, app->name, app->notify_sock, app->v_major,
3454 app->v_minor);
3455
3456 rcu_read_unlock();
3457 }
3458
3459 /*
3460 * Set the application version into the object.
3461 *
3462 * Return 0 on success else a negative value either an errno code or a
3463 * LTTng-UST error code.
3464 */
3465 int ust_app_version(struct ust_app *app)
3466 {
3467 int ret;
3468
3469 assert(app);
3470
3471 pthread_mutex_lock(&app->sock_lock);
3472 ret = ustctl_tracer_version(app->sock, &app->version);
3473 pthread_mutex_unlock(&app->sock_lock);
3474 if (ret < 0) {
3475 if (ret != -LTTNG_UST_ERR_EXITING && ret != -EPIPE) {
3476 ERR("UST app %d version failed with ret %d", app->sock, ret);
3477 } else {
3478 DBG3("UST app %d version failed. Application is dead", app->sock);
3479 }
3480 }
3481
3482 return ret;
3483 }
3484
3485 /*
3486 * Unregister app by removing it from the global traceable app list and freeing
3487 * the data struct.
3488 *
3489 * The socket is already closed at this point so no close to sock.
3490 */
3491 void ust_app_unregister(int sock)
3492 {
3493 struct ust_app *lta;
3494 struct lttng_ht_node_ulong *node;
3495 struct lttng_ht_iter ust_app_sock_iter;
3496 struct lttng_ht_iter iter;
3497 struct ust_app_session *ua_sess;
3498 int ret;
3499
3500 rcu_read_lock();
3501
3502 /* Get the node reference for a call_rcu */
3503 lttng_ht_lookup(ust_app_ht_by_sock, (void *)((unsigned long) sock), &ust_app_sock_iter);
3504 node = lttng_ht_iter_get_node_ulong(&ust_app_sock_iter);
3505 assert(node);
3506
3507 lta = caa_container_of(node, struct ust_app, sock_n);
3508 DBG("PID %d unregistering with sock %d", lta->pid, sock);
3509
3510 /*
3511 * For per-PID buffers, perform "push metadata" and flush all
3512 * application streams before removing app from hash tables,
3513 * ensuring proper behavior of data_pending check.
3514 * Remove sessions so they are not visible during deletion.
3515 */
3516 cds_lfht_for_each_entry(lta->sessions->ht, &iter.iter, ua_sess,
3517 node.node) {
3518 struct ust_registry_session *registry;
3519
3520 ret = lttng_ht_del(lta->sessions, &iter);
3521 if (ret) {
3522 /* The session was already removed so scheduled for teardown. */
3523 continue;
3524 }
3525
3526 if (ua_sess->buffer_type == LTTNG_BUFFER_PER_PID) {
3527 (void) ust_app_flush_app_session(lta, ua_sess);
3528 }
3529
3530 /*
3531 * Add session to list for teardown. This is safe since at this point we
3532 * are the only one using this list.
3533 */
3534 pthread_mutex_lock(&ua_sess->lock);
3535
3536 if (ua_sess->deleted) {
3537 pthread_mutex_unlock(&ua_sess->lock);
3538 continue;
3539 }
3540
3541 /*
3542 * Normally, this is done in the delete session process which is
3543 * executed in the call rcu below. However, upon registration we can't
3544 * afford to wait for the grace period before pushing data or else the
3545 * data pending feature can race between the unregistration and stop
3546 * command where the data pending command is sent *before* the grace
3547 * period ended.
3548 *
3549 * The close metadata below nullifies the metadata pointer in the
3550 * session so the delete session will NOT push/close a second time.
3551 */
3552 registry = get_session_registry(ua_sess);
3553 if (registry) {
3554 /* Push metadata for application before freeing the application. */
3555 (void) push_metadata(registry, ua_sess->consumer);
3556
3557 /*
3558 * Don't ask to close metadata for global per UID buffers. Close
3559 * metadata only on destroy trace session in this case. Also, the
3560 * previous push metadata could have flag the metadata registry to
3561 * close so don't send a close command if closed.
3562 */
3563 if (ua_sess->buffer_type != LTTNG_BUFFER_PER_UID) {
3564 /* And ask to close it for this session registry. */
3565 (void) close_metadata(registry, ua_sess->consumer);
3566 }
3567 }
3568 cds_list_add(&ua_sess->teardown_node, &lta->teardown_head);
3569
3570 pthread_mutex_unlock(&ua_sess->lock);
3571 }
3572
3573 /* Remove application from PID hash table */
3574 ret = lttng_ht_del(ust_app_ht_by_sock, &ust_app_sock_iter);
3575 assert(!ret);
3576
3577 /*
3578 * Remove application from notify hash table. The thread handling the
3579 * notify socket could have deleted the node so ignore on error because
3580 * either way it's valid. The close of that socket is handled by the
3581 * apps_notify_thread.
3582 */
3583 iter.iter.node = &lta->notify_sock_n.node;
3584 (void) lttng_ht_del(ust_app_ht_by_notify_sock, &iter);
3585
3586 /*
3587 * Ignore return value since the node might have been removed before by an
3588 * add replace during app registration because the PID can be reassigned by
3589 * the OS.
3590 */
3591 iter.iter.node = &lta->pid_n.node;
3592 ret = lttng_ht_del(ust_app_ht, &iter);
3593 if (ret) {
3594 DBG3("Unregister app by PID %d failed. This can happen on pid reuse",
3595 lta->pid);
3596 }
3597
3598 /* Free memory */
3599 call_rcu(&lta->pid_n.head, delete_ust_app_rcu);
3600
3601 rcu_read_unlock();
3602 return;
3603 }
3604
3605 /*
3606 * Fill events array with all events name of all registered apps.
3607 */
3608 int ust_app_list_events(struct lttng_event **events)
3609 {
3610 int ret, handle;
3611 size_t nbmem, count = 0;
3612 struct lttng_ht_iter iter;
3613 struct ust_app *app;
3614 struct lttng_event *tmp_event;
3615
3616 nbmem = UST_APP_EVENT_LIST_SIZE;
3617 tmp_event = zmalloc(nbmem * sizeof(struct lttng_event));
3618 if (tmp_event == NULL) {
3619 PERROR("zmalloc ust app events");
3620 ret = -ENOMEM;
3621 goto error;
3622 }
3623
3624 rcu_read_lock();
3625
3626 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
3627 struct lttng_ust_tracepoint_iter uiter;
3628
3629 health_code_update();
3630
3631 if (!app->compatible) {
3632 /*
3633 * TODO: In time, we should notice the caller of this error by
3634 * telling him that this is a version error.
3635 */
3636 continue;
3637 }
3638 pthread_mutex_lock(&app->sock_lock);
3639 handle = ustctl_tracepoint_list(app->sock);
3640 if (handle < 0) {
3641 if (handle != -EPIPE && handle != -LTTNG_UST_ERR_EXITING) {
3642 ERR("UST app list events getting handle failed for app pid %d",
3643 app->pid);
3644 }
3645 pthread_mutex_unlock(&app->sock_lock);
3646 continue;
3647 }
3648
3649 while ((ret = ustctl_tracepoint_list_get(app->sock, handle,
3650 &uiter)) != -LTTNG_UST_ERR_NOENT) {
3651 /* Handle ustctl error. */
3652 if (ret < 0) {
3653 int release_ret;
3654
3655 if (ret != -LTTNG_UST_ERR_EXITING && ret != -EPIPE) {
3656 ERR("UST app tp list get failed for app %d with ret %d",
3657 app->sock, ret);
3658 } else {
3659 DBG3("UST app tp list get failed. Application is dead");
3660 /*
3661 * This is normal behavior, an application can die during the
3662 * creation process. Don't report an error so the execution can
3663 * continue normally. Continue normal execution.
3664 */
3665 break;
3666 }
3667 free(tmp_event);
3668 release_ret = ustctl_release_handle(app->sock, handle);
3669 if (release_ret < 0 &&
3670 release_ret != -LTTNG_UST_ERR_EXITING &&
3671 release_ret != -EPIPE) {
3672 ERR("Error releasing app handle for app %d with ret %d", app->sock, release_ret);
3673 }
3674 pthread_mutex_unlock(&app->sock_lock);
3675 goto rcu_error;
3676 }
3677
3678 health_code_update();
3679 if (count >= nbmem) {
3680 /* In case the realloc fails, we free the memory */
3681 struct lttng_event *new_tmp_event;
3682 size_t new_nbmem;
3683
3684 new_nbmem = nbmem << 1;
3685 DBG2("Reallocating event list from %zu to %zu entries",
3686 nbmem, new_nbmem);
3687 new_tmp_event = realloc(tmp_event,
3688 new_nbmem * sizeof(struct lttng_event));
3689 if (new_tmp_event == NULL) {
3690 int release_ret;
3691
3692 PERROR("realloc ust app events");
3693 free(tmp_event);
3694 ret = -ENOMEM;
3695 release_ret = ustctl_release_handle(app->sock, handle);
3696 if (release_ret < 0 &&
3697 release_ret != -LTTNG_UST_ERR_EXITING &&
3698 release_ret != -EPIPE) {
3699 ERR("Error releasing app handle for app %d with ret %d", app->sock, release_ret);
3700 }
3701 pthread_mutex_unlock(&app->sock_lock);
3702 goto rcu_error;
3703 }
3704 /* Zero the new memory */
3705 memset(new_tmp_event + nbmem, 0,
3706 (new_nbmem - nbmem) * sizeof(struct lttng_event));
3707 nbmem = new_nbmem;
3708 tmp_event = new_tmp_event;
3709 }
3710 memcpy(tmp_event[count].name, uiter.name, LTTNG_UST_SYM_NAME_LEN);
3711 tmp_event[count].loglevel = uiter.loglevel;
3712 tmp_event[count].type = (enum lttng_event_type) LTTNG_UST_TRACEPOINT;
3713 tmp_event[count].pid = app->pid;
3714 tmp_event[count].enabled = -1;
3715 count++;
3716 }
3717 ret = ustctl_release_handle(app->sock, handle);
3718 pthread_mutex_unlock(&app->sock_lock);
3719 if (ret < 0 && ret != -LTTNG_UST_ERR_EXITING && ret != -EPIPE) {
3720 ERR("Error releasing app handle for app %d with ret %d", app->sock, ret);
3721 }
3722 }
3723
3724 ret = count;
3725 *events = tmp_event;
3726
3727 DBG2("UST app list events done (%zu events)", count);
3728
3729 rcu_error:
3730 rcu_read_unlock();
3731 error:
3732 health_code_update();
3733 return ret;
3734 }
3735
3736 /*
3737 * Fill events array with all events name of all registered apps.
3738 */
3739 int ust_app_list_event_fields(struct lttng_event_field **fields)
3740 {
3741 int ret, handle;
3742 size_t nbmem, count = 0;
3743 struct lttng_ht_iter iter;
3744 struct ust_app *app;
3745 struct lttng_event_field *tmp_event;
3746
3747 nbmem = UST_APP_EVENT_LIST_SIZE;
3748 tmp_event = zmalloc(nbmem * sizeof(struct lttng_event_field));
3749 if (tmp_event == NULL) {
3750 PERROR("zmalloc ust app event fields");
3751 ret = -ENOMEM;
3752 goto error;
3753 }
3754
3755 rcu_read_lock();
3756
3757 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
3758 struct lttng_ust_field_iter uiter;
3759
3760 health_code_update();
3761
3762 if (!app->compatible) {
3763 /*
3764 * TODO: In time, we should notice the caller of this error by
3765 * telling him that this is a version error.
3766 */
3767 continue;
3768 }
3769 pthread_mutex_lock(&app->sock_lock);
3770 handle = ustctl_tracepoint_field_list(app->sock);
3771 if (handle < 0) {
3772 if (handle != -EPIPE && handle != -LTTNG_UST_ERR_EXITING) {
3773 ERR("UST app list field getting handle failed for app pid %d",
3774 app->pid);
3775 }
3776 pthread_mutex_unlock(&app->sock_lock);
3777 continue;
3778 }
3779
3780 while ((ret = ustctl_tracepoint_field_list_get(app->sock, handle,
3781 &uiter)) != -LTTNG_UST_ERR_NOENT) {
3782 /* Handle ustctl error. */
3783 if (ret < 0) {
3784 int release_ret;
3785
3786 if (ret != -LTTNG_UST_ERR_EXITING && ret != -EPIPE) {
3787 ERR("UST app tp list field failed for app %d with ret %d",
3788 app->sock, ret);
3789 } else {
3790 DBG3("UST app tp list field failed. Application is dead");
3791 /*
3792 * This is normal behavior, an application can die during the
3793 * creation process. Don't report an error so the execution can
3794 * continue normally. Reset list and count for next app.
3795 */
3796 break;
3797 }
3798 free(tmp_event);
3799 release_ret = ustctl_release_handle(app->sock, handle);
3800 pthread_mutex_unlock(&app->sock_lock);
3801 if (release_ret < 0 &&
3802 release_ret != -LTTNG_UST_ERR_EXITING &&
3803 release_ret != -EPIPE) {
3804 ERR("Error releasing app handle for app %d with ret %d", app->sock, release_ret);
3805 }
3806 goto rcu_error;
3807 }
3808
3809 health_code_update();
3810 if (count >= nbmem) {
3811 /* In case the realloc fails, we free the memory */
3812 struct lttng_event_field *new_tmp_event;
3813 size_t new_nbmem;
3814
3815 new_nbmem = nbmem << 1;
3816 DBG2("Reallocating event field list from %zu to %zu entries",
3817 nbmem, new_nbmem);
3818 new_tmp_event = realloc(tmp_event,
3819 new_nbmem * sizeof(struct lttng_event_field));
3820 if (new_tmp_event == NULL) {
3821 int release_ret;
3822
3823 PERROR("realloc ust app event fields");
3824 free(tmp_event);
3825 ret = -ENOMEM;
3826 release_ret = ustctl_release_handle(app->sock, handle);
3827 pthread_mutex_unlock(&app->sock_lock);
3828 if (release_ret &&
3829 release_ret != -LTTNG_UST_ERR_EXITING &&
3830 release_ret != -EPIPE) {
3831 ERR("Error releasing app handle for app %d with ret %d", app->sock, release_ret);
3832 }
3833 goto rcu_error;
3834 }
3835 /* Zero the new memory */
3836 memset(new_tmp_event + nbmem, 0,
3837 (new_nbmem - nbmem) * sizeof(struct lttng_event_field));
3838 nbmem = new_nbmem;
3839 tmp_event = new_tmp_event;
3840 }
3841
3842 memcpy(tmp_event[count].field_name, uiter.field_name, LTTNG_UST_SYM_NAME_LEN);
3843 /* Mapping between these enums matches 1 to 1. */
3844 tmp_event[count].type = (enum lttng_event_field_type) uiter.type;
3845 tmp_event[count].nowrite = uiter.nowrite;
3846
3847 memcpy(tmp_event[count].event.name, uiter.event_name, LTTNG_UST_SYM_NAME_LEN);
3848 tmp_event[count].event.loglevel = uiter.loglevel;
3849 tmp_event[count].event.type = LTTNG_EVENT_TRACEPOINT;
3850 tmp_event[count].event.pid = app->pid;
3851 tmp_event[count].event.enabled = -1;
3852 count++;
3853 }
3854 ret = ustctl_release_handle(app->sock, handle);
3855 pthread_mutex_unlock(&app->sock_lock);
3856 if (ret < 0 &&
3857 ret != -LTTNG_UST_ERR_EXITING &&
3858 ret != -EPIPE) {
3859 ERR("Error releasing app handle for app %d with ret %d", app->sock, ret);
3860 }
3861 }
3862
3863 ret = count;
3864 *fields = tmp_event;
3865
3866 DBG2("UST app list event fields done (%zu events)", count);
3867
3868 rcu_error:
3869 rcu_read_unlock();
3870 error:
3871 health_code_update();
3872 return ret;
3873 }
3874
3875 /*
3876 * Free and clean all traceable apps of the global list.
3877 *
3878 * Should _NOT_ be called with RCU read-side lock held.
3879 */
3880 void ust_app_clean_list(void)
3881 {
3882 int ret;
3883 struct ust_app *app;
3884 struct lttng_ht_iter iter;
3885
3886 DBG2("UST app cleaning registered apps hash table");
3887
3888 rcu_read_lock();
3889
3890 if (ust_app_ht) {
3891 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
3892 ret = lttng_ht_del(ust_app_ht, &iter);
3893 assert(!ret);
3894 call_rcu(&app->pid_n.head, delete_ust_app_rcu);
3895 }
3896 }
3897
3898 /* Cleanup socket hash table */
3899 if (ust_app_ht_by_sock) {
3900 cds_lfht_for_each_entry(ust_app_ht_by_sock->ht, &iter.iter, app,
3901 sock_n.node) {
3902 ret = lttng_ht_del(ust_app_ht_by_sock, &iter);
3903 assert(!ret);
3904 }
3905 }
3906
3907 /* Cleanup notify socket hash table */
3908 if (ust_app_ht_by_notify_sock) {
3909 cds_lfht_for_each_entry(ust_app_ht_by_notify_sock->ht, &iter.iter, app,
3910 notify_sock_n.node) {
3911 ret = lttng_ht_del(ust_app_ht_by_notify_sock, &iter);
3912 assert(!ret);
3913 }
3914 }
3915 rcu_read_unlock();
3916
3917 /* Destroy is done only when the ht is empty */
3918 if (ust_app_ht) {
3919 ht_cleanup_push(ust_app_ht);
3920 }
3921 if (ust_app_ht_by_sock) {
3922 ht_cleanup_push(ust_app_ht_by_sock);
3923 }
3924 if (ust_app_ht_by_notify_sock) {
3925 ht_cleanup_push(ust_app_ht_by_notify_sock);
3926 }
3927 }
3928
3929 /*
3930 * Init UST app hash table.
3931 */
3932 int ust_app_ht_alloc(void)
3933 {
3934 ust_app_ht = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG);
3935 if (!ust_app_ht) {
3936 return -1;
3937 }
3938 ust_app_ht_by_sock = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG);
3939 if (!ust_app_ht_by_sock) {
3940 return -1;
3941 }
3942 ust_app_ht_by_notify_sock = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG);
3943 if (!ust_app_ht_by_notify_sock) {
3944 return -1;
3945 }
3946 return 0;
3947 }
3948
3949 /*
3950 * For a specific UST session, disable the channel for all registered apps.
3951 */
3952 int ust_app_disable_channel_glb(struct ltt_ust_session *usess,
3953 struct ltt_ust_channel *uchan)
3954 {
3955 int ret = 0;
3956 struct lttng_ht_iter iter;
3957 struct lttng_ht_node_str *ua_chan_node;
3958 struct ust_app *app;
3959 struct ust_app_session *ua_sess;
3960 struct ust_app_channel *ua_chan;
3961
3962 if (usess == NULL || uchan == NULL) {
3963 ERR("Disabling UST global channel with NULL values");
3964 ret = -1;
3965 goto error;
3966 }
3967
3968 DBG2("UST app disabling channel %s from global domain for session id %" PRIu64,
3969 uchan->name, usess->id);
3970
3971 rcu_read_lock();
3972
3973 /* For every registered applications */
3974 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
3975 struct lttng_ht_iter uiter;
3976 if (!app->compatible) {
3977 /*
3978 * TODO: In time, we should notice the caller of this error by
3979 * telling him that this is a version error.
3980 */
3981 continue;
3982 }
3983 ua_sess = lookup_session_by_app(usess, app);
3984 if (ua_sess == NULL) {
3985 continue;
3986 }
3987
3988 /* Get channel */
3989 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &uiter);
3990 ua_chan_node = lttng_ht_iter_get_node_str(&uiter);
3991 /* If the session if found for the app, the channel must be there */
3992 assert(ua_chan_node);
3993
3994 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
3995 /* The channel must not be already disabled */
3996 assert(ua_chan->enabled == 1);
3997
3998 /* Disable channel onto application */
3999 ret = disable_ust_app_channel(ua_sess, ua_chan, app);
4000 if (ret < 0) {
4001 /* XXX: We might want to report this error at some point... */
4002 continue;
4003 }
4004 }
4005
4006 rcu_read_unlock();
4007
4008 error:
4009 return ret;
4010 }
4011
4012 /*
4013 * For a specific UST session, enable the channel for all registered apps.
4014 */
4015 int ust_app_enable_channel_glb(struct ltt_ust_session *usess,
4016 struct ltt_ust_channel *uchan)
4017 {
4018 int ret = 0;
4019 struct lttng_ht_iter iter;
4020 struct ust_app *app;
4021 struct ust_app_session *ua_sess;
4022
4023 if (usess == NULL || uchan == NULL) {
4024 ERR("Adding UST global channel to NULL values");
4025 ret = -1;
4026 goto error;
4027 }
4028
4029 DBG2("UST app enabling channel %s to global domain for session id %" PRIu64,
4030 uchan->name, usess->id);
4031
4032 rcu_read_lock();
4033
4034 /* For every registered applications */
4035 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
4036 if (!app->compatible) {
4037 /*
4038 * TODO: In time, we should notice the caller of this error by
4039 * telling him that this is a version error.
4040 */
4041 continue;
4042 }
4043 ua_sess = lookup_session_by_app(usess, app);
4044 if (ua_sess == NULL) {
4045 continue;
4046 }
4047
4048 /* Enable channel onto application */
4049 ret = enable_ust_app_channel(ua_sess, uchan, app);
4050 if (ret < 0) {
4051 /* XXX: We might want to report this error at some point... */
4052 continue;
4053 }
4054 }
4055
4056 rcu_read_unlock();
4057
4058 error:
4059 return ret;
4060 }
4061
4062 /*
4063 * Disable an event in a channel and for a specific session.
4064 */
4065 int ust_app_disable_event_glb(struct ltt_ust_session *usess,
4066 struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent)
4067 {
4068 int ret = 0;
4069 struct lttng_ht_iter iter, uiter;
4070 struct lttng_ht_node_str *ua_chan_node;
4071 struct ust_app *app;
4072 struct ust_app_session *ua_sess;
4073 struct ust_app_channel *ua_chan;
4074 struct ust_app_event *ua_event;
4075
4076 DBG("UST app disabling event %s for all apps in channel "
4077 "%s for session id %" PRIu64,
4078 uevent->attr.name, uchan->name, usess->id);
4079
4080 rcu_read_lock();
4081
4082 /* For all registered applications */
4083 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
4084 if (!app->compatible) {
4085 /*
4086 * TODO: In time, we should notice the caller of this error by
4087 * telling him that this is a version error.
4088 */
4089 continue;
4090 }
4091 ua_sess = lookup_session_by_app(usess, app);
4092 if (ua_sess == NULL) {
4093 /* Next app */
4094 continue;
4095 }
4096
4097 /* Lookup channel in the ust app session */
4098 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &uiter);
4099 ua_chan_node = lttng_ht_iter_get_node_str(&uiter);
4100 if (ua_chan_node == NULL) {
4101 DBG2("Channel %s not found in session id %" PRIu64 " for app pid %d."
4102 "Skipping", uchan->name, usess->id, app->pid);
4103 continue;
4104 }
4105 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
4106
4107 ua_event = find_ust_app_event(ua_chan->events, uevent->attr.name,
4108 uevent->filter, uevent->attr.loglevel,
4109 uevent->exclusion);
4110 if (ua_event == NULL) {
4111 DBG2("Event %s not found in channel %s for app pid %d."
4112 "Skipping", uevent->attr.name, uchan->name, app->pid);
4113 continue;
4114 }
4115
4116 ret = disable_ust_app_event(ua_sess, ua_event, app);
4117 if (ret < 0) {
4118 /* XXX: Report error someday... */
4119 continue;
4120 }
4121 }
4122
4123 rcu_read_unlock();
4124
4125 return ret;
4126 }
4127
4128 /*
4129 * For a specific UST session, create the channel for all registered apps.
4130 */
4131 int ust_app_create_channel_glb(struct ltt_ust_session *usess,
4132 struct ltt_ust_channel *uchan)
4133 {
4134 int ret = 0, created;
4135 struct lttng_ht_iter iter;
4136 struct ust_app *app;
4137 struct ust_app_session *ua_sess = NULL;
4138
4139 /* Very wrong code flow */
4140 assert(usess);
4141 assert(uchan);
4142
4143 DBG2("UST app adding channel %s to UST domain for session id %" PRIu64,
4144 uchan->name, usess->id);
4145
4146 rcu_read_lock();
4147
4148 /* For every registered applications */
4149 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
4150 if (!app->compatible) {
4151 /*
4152 * TODO: In time, we should notice the caller of this error by
4153 * telling him that this is a version error.
4154 */
4155 continue;
4156 }
4157 if (!trace_ust_pid_tracker_lookup(usess, app->pid)) {
4158 /* Skip. */
4159 continue;
4160 }
4161
4162 /*
4163 * Create session on the tracer side and add it to app session HT. Note
4164 * that if session exist, it will simply return a pointer to the ust
4165 * app session.
4166 */
4167 ret = create_ust_app_session(usess, app, &ua_sess, &created);
4168 if (ret < 0) {
4169 switch (ret) {
4170 case -ENOTCONN:
4171 /*
4172 * The application's socket is not valid. Either a bad socket
4173 * or a timeout on it. We can't inform the caller that for a
4174 * specific app, the session failed so lets continue here.
4175 */
4176 ret = 0; /* Not an error. */
4177 continue;
4178 case -ENOMEM:
4179 default:
4180 goto error_rcu_unlock;
4181 }
4182 }
4183 assert(ua_sess);
4184
4185 pthread_mutex_lock(&ua_sess->lock);
4186
4187 if (ua_sess->deleted) {
4188 pthread_mutex_unlock(&ua_sess->lock);
4189 continue;
4190 }
4191
4192 if (!strncmp(uchan->name, DEFAULT_METADATA_NAME,
4193 sizeof(uchan->name))) {
4194 copy_channel_attr_to_ustctl(&ua_sess->metadata_attr, &uchan->attr);
4195 ret = 0;
4196 } else {
4197 /* Create channel onto application. We don't need the chan ref. */
4198 ret = create_ust_app_channel(ua_sess, uchan, app,
4199 LTTNG_UST_CHAN_PER_CPU, usess, NULL);
4200 }
4201 pthread_mutex_unlock(&ua_sess->lock);
4202 if (ret < 0) {
4203 /* Cleanup the created session if it's the case. */
4204 if (created) {
4205 destroy_app_session(app, ua_sess);
4206 }
4207 switch (ret) {
4208 case -ENOTCONN:
4209 /*
4210 * The application's socket is not valid. Either a bad socket
4211 * or a timeout on it. We can't inform the caller that for a
4212 * specific app, the session failed so lets continue here.
4213 */
4214 ret = 0; /* Not an error. */
4215 continue;
4216 case -ENOMEM:
4217 default:
4218 goto error_rcu_unlock;
4219 }
4220 }
4221 }
4222
4223 error_rcu_unlock:
4224 rcu_read_unlock();
4225 return ret;
4226 }
4227
4228 /*
4229 * Enable event for a specific session and channel on the tracer.
4230 */
4231 int ust_app_enable_event_glb(struct ltt_ust_session *usess,
4232 struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent)
4233 {
4234 int ret = 0;
4235 struct lttng_ht_iter iter, uiter;
4236 struct lttng_ht_node_str *ua_chan_node;
4237 struct ust_app *app;
4238 struct ust_app_session *ua_sess;
4239 struct ust_app_channel *ua_chan;
4240 struct ust_app_event *ua_event;
4241
4242 DBG("UST app enabling event %s for all apps for session id %" PRIu64,
4243 uevent->attr.name, usess->id);
4244
4245 /*
4246 * NOTE: At this point, this function is called only if the session and
4247 * channel passed are already created for all apps. and enabled on the
4248 * tracer also.
4249 */
4250
4251 rcu_read_lock();
4252
4253 /* For all registered applications */
4254 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
4255 if (!app->compatible) {
4256 /*
4257 * TODO: In time, we should notice the caller of this error by
4258 * telling him that this is a version error.
4259 */
4260 continue;
4261 }
4262 ua_sess = lookup_session_by_app(usess, app);
4263 if (!ua_sess) {
4264 /* The application has problem or is probably dead. */
4265 continue;
4266 }
4267
4268 pthread_mutex_lock(&ua_sess->lock);
4269
4270 if (ua_sess->deleted) {
4271 pthread_mutex_unlock(&ua_sess->lock);
4272 continue;
4273 }
4274
4275 /* Lookup channel in the ust app session */
4276 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &uiter);
4277 ua_chan_node = lttng_ht_iter_get_node_str(&uiter);
4278 /*
4279 * It is possible that the channel cannot be found is
4280 * the channel/event creation occurs concurrently with
4281 * an application exit.
4282 */
4283 if (!ua_chan_node) {
4284 pthread_mutex_unlock(&ua_sess->lock);
4285 continue;
4286 }
4287
4288 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
4289
4290 /* Get event node */
4291 ua_event = find_ust_app_event(ua_chan->events, uevent->attr.name,
4292 uevent->filter, uevent->attr.loglevel, uevent->exclusion);
4293 if (ua_event == NULL) {
4294 DBG3("UST app enable event %s not found for app PID %d."
4295 "Skipping app", uevent->attr.name, app->pid);
4296 goto next_app;
4297 }
4298
4299 ret = enable_ust_app_event(ua_sess, ua_event, app);
4300 if (ret < 0) {
4301 pthread_mutex_unlock(&ua_sess->lock);
4302 goto error;
4303 }
4304 next_app:
4305 pthread_mutex_unlock(&ua_sess->lock);
4306 }
4307
4308 error:
4309 rcu_read_unlock();
4310 return ret;
4311 }
4312
4313 /*
4314 * For a specific existing UST session and UST channel, creates the event for
4315 * all registered apps.
4316 */
4317 int ust_app_create_event_glb(struct ltt_ust_session *usess,
4318 struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent)
4319 {
4320 int ret = 0;
4321 struct lttng_ht_iter iter, uiter;
4322 struct lttng_ht_node_str *ua_chan_node;
4323 struct ust_app *app;
4324 struct ust_app_session *ua_sess;
4325 struct ust_app_channel *ua_chan;
4326
4327 DBG("UST app creating event %s for all apps for session id %" PRIu64,
4328 uevent->attr.name, usess->id);
4329
4330 rcu_read_lock();
4331
4332 /* For all registered applications */
4333 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
4334 if (!app->compatible) {
4335 /*
4336 * TODO: In time, we should notice the caller of this error by
4337 * telling him that this is a version error.
4338 */
4339 continue;
4340 }
4341 ua_sess = lookup_session_by_app(usess, app);
4342 if (!ua_sess) {
4343 /* The application has problem or is probably dead. */
4344 continue;
4345 }
4346
4347 pthread_mutex_lock(&ua_sess->lock);
4348
4349 if (ua_sess->deleted) {
4350 pthread_mutex_unlock(&ua_sess->lock);
4351 continue;
4352 }
4353
4354 /* Lookup channel in the ust app session */
4355 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &uiter);
4356 ua_chan_node = lttng_ht_iter_get_node_str(&uiter);
4357 /* If the channel is not found, there is a code flow error */
4358 assert(ua_chan_node);
4359
4360 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
4361
4362 ret = create_ust_app_event(ua_sess, ua_chan, uevent, app);
4363 pthread_mutex_unlock(&ua_sess->lock);
4364 if (ret < 0) {
4365 if (ret != -LTTNG_UST_ERR_EXIST) {
4366 /* Possible value at this point: -ENOMEM. If so, we stop! */
4367 break;
4368 }
4369 DBG2("UST app event %s already exist on app PID %d",
4370 uevent->attr.name, app->pid);
4371 continue;
4372 }
4373 }
4374
4375 rcu_read_unlock();
4376
4377 return ret;
4378 }
4379
4380 /*
4381 * Start tracing for a specific UST session and app.
4382 *
4383 * Called with UST app session lock held.
4384 *
4385 */
4386 static
4387 int ust_app_start_trace(struct ltt_ust_session *usess, struct ust_app *app)
4388 {
4389 int ret = 0;
4390 struct ust_app_session *ua_sess;
4391
4392 DBG("Starting tracing for ust app pid %d", app->pid);
4393
4394 rcu_read_lock();
4395
4396 if (!app->compatible) {
4397 goto end;
4398 }
4399
4400 ua_sess = lookup_session_by_app(usess, app);
4401 if (ua_sess == NULL) {
4402 /* The session is in teardown process. Ignore and continue. */
4403 goto end;
4404 }
4405
4406 pthread_mutex_lock(&ua_sess->lock);
4407
4408 if (ua_sess->deleted) {
4409 pthread_mutex_unlock(&ua_sess->lock);
4410 goto end;
4411 }
4412
4413 /* Upon restart, we skip the setup, already done */
4414 if (ua_sess->started) {
4415 goto skip_setup;
4416 }
4417
4418 /* Create directories if consumer is LOCAL and has a path defined. */
4419 if (usess->consumer->type == CONSUMER_DST_LOCAL &&
4420 usess->consumer->dst.session_root_path[0] != '\0') {
4421 char *tmp_path;
4422
4423 tmp_path = zmalloc(LTTNG_PATH_MAX);
4424 if (!tmp_path) {
4425 ERR("Alloc tmp_path");
4426 goto error_unlock;
4427 }
4428 ret = snprintf(tmp_path, LTTNG_PATH_MAX, "%s%s%s",
4429 usess->consumer->dst.session_root_path,
4430 usess->consumer->chunk_path,
4431 usess->consumer->subdir);
4432 if (ret >= LTTNG_PATH_MAX) {
4433 ERR("Local destination path exceeds the maximal allowed length of %i bytes (needs %i bytes) with path = \"%s%s%s\"",
4434 LTTNG_PATH_MAX, ret,
4435 usess->consumer->dst.session_root_path,
4436 usess->consumer->chunk_path,
4437 usess->consumer->subdir);
4438 goto error_unlock;
4439 }
4440
4441 DBG("Creating directory path for local tracing: \"%s\"",
4442 tmp_path);
4443 ret = run_as_mkdir_recursive(tmp_path, S_IRWXU | S_IRWXG,
4444 ua_sess->euid, ua_sess->egid);
4445 free(tmp_path);
4446 if (ret < 0) {
4447 if (errno != EEXIST) {
4448 ERR("Trace directory creation error");
4449 goto error_unlock;
4450 }
4451 }
4452 }
4453
4454 /*
4455 * Create the metadata for the application. This returns gracefully if a
4456 * metadata was already set for the session.
4457 */
4458 ret = create_ust_app_metadata(ua_sess, app, usess->consumer);
4459 if (ret < 0) {
4460 goto error_unlock;
4461 }
4462
4463 health_code_update();
4464
4465 skip_setup:
4466 /* This start the UST tracing */
4467 pthread_mutex_lock(&app->sock_lock);
4468 ret = ustctl_start_session(app->sock, ua_sess->handle);
4469 pthread_mutex_unlock(&app->sock_lock);
4470 if (ret < 0) {
4471 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
4472 ERR("Error starting tracing for app pid: %d (ret: %d)",
4473 app->pid, ret);
4474 } else {
4475 DBG("UST app start session failed. Application is dead.");
4476 /*
4477 * This is normal behavior, an application can die during the
4478 * creation process. Don't report an error so the execution can
4479 * continue normally.
4480 */
4481 pthread_mutex_unlock(&ua_sess->lock);
4482 goto end;
4483 }
4484 goto error_unlock;
4485 }
4486
4487 /* Indicate that the session has been started once */
4488 ua_sess->started = 1;
4489
4490 pthread_mutex_unlock(&ua_sess->lock);
4491
4492 health_code_update();
4493
4494 /* Quiescent wait after starting trace */
4495 pthread_mutex_lock(&app->sock_lock);
4496 ret = ustctl_wait_quiescent(app->sock);
4497 pthread_mutex_unlock(&app->sock_lock);
4498 if (ret < 0 && ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
4499 ERR("UST app wait quiescent failed for app pid %d ret %d",
4500 app->pid, ret);
4501 }
4502
4503 end:
4504 rcu_read_unlock();
4505 health_code_update();
4506 return 0;
4507
4508 error_unlock:
4509 pthread_mutex_unlock(&ua_sess->lock);
4510 rcu_read_unlock();
4511 health_code_update();
4512 return -1;
4513 }
4514
4515 /*
4516 * Stop tracing for a specific UST session and app.
4517 */
4518 static
4519 int ust_app_stop_trace(struct ltt_ust_session *usess, struct ust_app *app)
4520 {
4521 int ret = 0;
4522 struct ust_app_session *ua_sess;
4523 struct ust_registry_session *registry;
4524
4525 DBG("Stopping tracing for ust app pid %d", app->pid);
4526
4527 rcu_read_lock();
4528
4529 if (!app->compatible) {
4530 goto end_no_session;
4531 }
4532
4533 ua_sess = lookup_session_by_app(usess, app);
4534 if (ua_sess == NULL) {
4535 goto end_no_session;
4536 }
4537
4538 pthread_mutex_lock(&ua_sess->lock);
4539
4540 if (ua_sess->deleted) {
4541 pthread_mutex_unlock(&ua_sess->lock);
4542 goto end_no_session;
4543 }
4544
4545 /*
4546 * If started = 0, it means that stop trace has been called for a session
4547 * that was never started. It's possible since we can have a fail start
4548 * from either the application manager thread or the command thread. Simply
4549 * indicate that this is a stop error.
4550 */
4551 if (!ua_sess->started) {
4552 goto error_rcu_unlock;
4553 }
4554
4555 health_code_update();
4556
4557 /* This inhibits UST tracing */
4558 pthread_mutex_lock(&app->sock_lock);
4559 ret = ustctl_stop_session(app->sock, ua_sess->handle);
4560 pthread_mutex_unlock(&app->sock_lock);
4561 if (ret < 0) {
4562 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
4563 ERR("Error stopping tracing for app pid: %d (ret: %d)",
4564 app->pid, ret);
4565 } else {
4566 DBG("UST app stop session failed. Application is dead.");
4567 /*
4568 * This is normal behavior, an application can die during the
4569 * creation process. Don't report an error so the execution can
4570 * continue normally.
4571 */
4572 goto end_unlock;
4573 }
4574 goto error_rcu_unlock;
4575 }
4576
4577 health_code_update();
4578
4579 /* Quiescent wait after stopping trace */
4580 pthread_mutex_lock(&app->sock_lock);
4581 ret = ustctl_wait_quiescent(app->sock);
4582 pthread_mutex_unlock(&app->sock_lock);
4583 if (ret < 0 && ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
4584 ERR("UST app wait quiescent failed for app pid %d ret %d",
4585 app->pid, ret);
4586 }
4587
4588 health_code_update();
4589
4590 registry = get_session_registry(ua_sess);
4591
4592 /* The UST app session is held registry shall not be null. */
4593 assert(registry);
4594
4595 /* Push metadata for application before freeing the application. */
4596 (void) push_metadata(registry, ua_sess->consumer);
4597
4598 end_unlock:
4599 pthread_mutex_unlock(&ua_sess->lock);
4600 end_no_session:
4601 rcu_read_unlock();
4602 health_code_update();
4603 return 0;
4604
4605 error_rcu_unlock:
4606 pthread_mutex_unlock(&ua_sess->lock);
4607 rcu_read_unlock();
4608 health_code_update();
4609 return -1;
4610 }
4611
4612 static
4613 int ust_app_flush_app_session(struct ust_app *app,
4614 struct ust_app_session *ua_sess)
4615 {
4616 int ret, retval = 0;
4617 struct lttng_ht_iter iter;
4618 struct ust_app_channel *ua_chan;
4619 struct consumer_socket *socket;
4620
4621 DBG("Flushing app session buffers for ust app pid %d", app->pid);
4622
4623 rcu_read_lock();
4624
4625 if (!app->compatible) {
4626 goto end_not_compatible;
4627 }
4628
4629 pthread_mutex_lock(&ua_sess->lock);
4630
4631 if (ua_sess->deleted) {
4632 goto end_deleted;
4633 }
4634
4635 health_code_update();
4636
4637 /* Flushing buffers */
4638 socket = consumer_find_socket_by_bitness(app->bits_per_long,
4639 ua_sess->consumer);
4640
4641 /* Flush buffers and push metadata. */
4642 switch (ua_sess->buffer_type) {
4643 case LTTNG_BUFFER_PER_PID:
4644 cds_lfht_for_each_entry(ua_sess->channels->ht, &iter.iter, ua_chan,
4645 node.node) {
4646 health_code_update();
4647 ret = consumer_flush_channel(socket, ua_chan->key);
4648 if (ret) {
4649 ERR("Error flushing consumer channel");
4650 retval = -1;
4651 continue;
4652 }
4653 }
4654 break;
4655 case LTTNG_BUFFER_PER_UID:
4656 default:
4657 assert(0);
4658 break;
4659 }
4660
4661 health_code_update();
4662
4663 end_deleted:
4664 pthread_mutex_unlock(&ua_sess->lock);
4665
4666 end_not_compatible:
4667 rcu_read_unlock();
4668 health_code_update();
4669 return retval;
4670 }
4671
4672 /*
4673 * Flush buffers for all applications for a specific UST session.
4674 * Called with UST session lock held.
4675 */
4676 static
4677 int ust_app_flush_session(struct ltt_ust_session *usess)
4678
4679 {
4680 int ret = 0;
4681
4682 DBG("Flushing session buffers for all ust apps");
4683
4684 rcu_read_lock();
4685
4686 /* Flush buffers and push metadata. */
4687 switch (usess->buffer_type) {
4688 case LTTNG_BUFFER_PER_UID:
4689 {
4690 struct buffer_reg_uid *reg;
4691 struct lttng_ht_iter iter;
4692
4693 /* Flush all per UID buffers associated to that session. */
4694 cds_list_for_each_entry(reg, &usess->buffer_reg_uid_list, lnode) {
4695 struct ust_registry_session *ust_session_reg;
4696 struct buffer_reg_channel *reg_chan;
4697 struct consumer_socket *socket;
4698
4699 /* Get consumer socket to use to push the metadata.*/
4700 socket = consumer_find_socket_by_bitness(reg->bits_per_long,
4701 usess->consumer);
4702 if (!socket) {
4703 /* Ignore request if no consumer is found for the session. */
4704 continue;
4705 }
4706
4707 cds_lfht_for_each_entry(reg->registry->channels->ht, &iter.iter,
4708 reg_chan, node.node) {
4709 /*
4710 * The following call will print error values so the return
4711 * code is of little importance because whatever happens, we
4712 * have to try them all.
4713 */
4714 (void) consumer_flush_channel(socket, reg_chan->consumer_key);
4715 }
4716
4717 ust_session_reg = reg->registry->reg.ust;
4718 /* Push metadata. */
4719 (void) push_metadata(ust_session_reg, usess->consumer);
4720 }
4721 break;
4722 }
4723 case LTTNG_BUFFER_PER_PID:
4724 {
4725 struct ust_app_session *ua_sess;
4726 struct lttng_ht_iter iter;
4727 struct ust_app *app;
4728
4729 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
4730 ua_sess = lookup_session_by_app(usess, app);
4731 if (ua_sess == NULL) {
4732 continue;
4733 }
4734 (void) ust_app_flush_app_session(app, ua_sess);
4735 }
4736 break;
4737 }
4738 default:
4739 ret = -1;
4740 assert(0);
4741 break;
4742 }
4743
4744 rcu_read_unlock();
4745 health_code_update();
4746 return ret;
4747 }
4748
4749 static
4750 int ust_app_clear_quiescent_app_session(struct ust_app *app,
4751 struct ust_app_session *ua_sess)
4752 {
4753 int ret = 0;
4754 struct lttng_ht_iter iter;
4755 struct ust_app_channel *ua_chan;
4756 struct consumer_socket *socket;
4757
4758 DBG("Clearing stream quiescent state for ust app pid %d", app->pid);
4759
4760 rcu_read_lock();
4761
4762 if (!app->compatible) {
4763 goto end_not_compatible;
4764 }
4765
4766 pthread_mutex_lock(&ua_sess->lock);
4767
4768 if (ua_sess->deleted) {
4769 goto end_unlock;
4770 }
4771
4772 health_code_update();
4773
4774 socket = consumer_find_socket_by_bitness(app->bits_per_long,
4775 ua_sess->consumer);
4776 if (!socket) {
4777 ERR("Failed to find consumer (%" PRIu32 ") socket",
4778 app->bits_per_long);
4779 ret = -1;
4780 goto end_unlock;
4781 }
4782
4783 /* Clear quiescent state. */
4784 switch (ua_sess->buffer_type) {
4785 case LTTNG_BUFFER_PER_PID:
4786 cds_lfht_for_each_entry(ua_sess->channels->ht, &iter.iter,
4787 ua_chan, node.node) {
4788 health_code_update();
4789 ret = consumer_clear_quiescent_channel(socket,
4790 ua_chan->key);
4791 if (ret) {
4792 ERR("Error clearing quiescent state for consumer channel");
4793 ret = -1;
4794 continue;
4795 }
4796 }
4797 break;
4798 case LTTNG_BUFFER_PER_UID:
4799 default:
4800 assert(0);
4801 ret = -1;
4802 break;
4803 }
4804
4805 health_code_update();
4806
4807 end_unlock:
4808 pthread_mutex_unlock(&ua_sess->lock);
4809
4810 end_not_compatible:
4811 rcu_read_unlock();
4812 health_code_update();
4813 return ret;
4814 }
4815
4816 /*
4817 * Clear quiescent state in each stream for all applications for a
4818 * specific UST session.
4819 * Called with UST session lock held.
4820 */
4821 static
4822 int ust_app_clear_quiescent_session(struct ltt_ust_session *usess)
4823
4824 {
4825 int ret = 0;
4826
4827 DBG("Clearing stream quiescent state for all ust apps");
4828
4829 rcu_read_lock();
4830
4831 switch (usess->buffer_type) {
4832 case LTTNG_BUFFER_PER_UID:
4833 {
4834 struct lttng_ht_iter iter;
4835 struct buffer_reg_uid *reg;
4836
4837 /*
4838 * Clear quiescent for all per UID buffers associated to
4839 * that session.
4840 */
4841 cds_list_for_each_entry(reg, &usess->buffer_reg_uid_list, lnode) {
4842 struct consumer_socket *socket;
4843 struct buffer_reg_channel *reg_chan;
4844
4845 /* Get associated consumer socket.*/
4846 socket = consumer_find_socket_by_bitness(
4847 reg->bits_per_long, usess->consumer);
4848 if (!socket) {
4849 /*
4850 * Ignore request if no consumer is found for
4851 * the session.
4852 */
4853 continue;
4854 }
4855
4856 cds_lfht_for_each_entry(reg->registry->channels->ht,
4857 &iter.iter, reg_chan, node.node) {
4858 /*
4859 * The following call will print error values so
4860 * the return code is of little importance
4861 * because whatever happens, we have to try them
4862 * all.
4863 */
4864 (void) consumer_clear_quiescent_channel(socket,
4865 reg_chan->consumer_key);
4866 }
4867 }
4868 break;
4869 }
4870 case LTTNG_BUFFER_PER_PID:
4871 {
4872 struct ust_app_session *ua_sess;
4873 struct lttng_ht_iter iter;
4874 struct ust_app *app;
4875
4876 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app,
4877 pid_n.node) {
4878 ua_sess = lookup_session_by_app(usess, app);
4879 if (ua_sess == NULL) {
4880 continue;
4881 }
4882 (void) ust_app_clear_quiescent_app_session(app,
4883 ua_sess);
4884 }
4885 break;
4886 }
4887 default:
4888 ret = -1;
4889 assert(0);
4890 break;
4891 }
4892
4893 rcu_read_unlock();
4894 health_code_update();
4895 return ret;
4896 }
4897
4898 /*
4899 * Destroy a specific UST session in apps.
4900 */
4901 static int destroy_trace(struct ltt_ust_session *usess, struct ust_app *app)
4902 {
4903 int ret;
4904 struct ust_app_session *ua_sess;
4905 struct lttng_ht_iter iter;
4906 struct lttng_ht_node_u64 *node;
4907
4908 DBG("Destroy tracing for ust app pid %d", app->pid);
4909
4910 rcu_read_lock();
4911
4912 if (!app->compatible) {
4913 goto end;
4914 }
4915
4916 __lookup_session_by_app(usess, app, &iter);
4917 node = lttng_ht_iter_get_node_u64(&iter);
4918 if (node == NULL) {
4919 /* Session is being or is deleted. */
4920 goto end;
4921 }
4922 ua_sess = caa_container_of(node, struct ust_app_session, node);
4923
4924 health_code_update();
4925 destroy_app_session(app, ua_sess);
4926
4927 health_code_update();
4928
4929 /* Quiescent wait after stopping trace */
4930 pthread_mutex_lock(&app->sock_lock);
4931 ret = ustctl_wait_quiescent(app->sock);
4932 pthread_mutex_unlock(&app->sock_lock);
4933 if (ret < 0 && ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
4934 ERR("UST app wait quiescent failed for app pid %d ret %d",
4935 app->pid, ret);
4936 }
4937 end:
4938 rcu_read_unlock();
4939 health_code_update();
4940 return 0;
4941 }
4942
4943 /*
4944 * Start tracing for the UST session.
4945 */
4946 int ust_app_start_trace_all(struct ltt_ust_session *usess)
4947 {
4948 int ret = 0;
4949 struct lttng_ht_iter iter;
4950 struct ust_app *app;
4951
4952 DBG("Starting all UST traces");
4953
4954 rcu_read_lock();
4955
4956 /*
4957 * In a start-stop-start use-case, we need to clear the quiescent state
4958 * of each channel set by the prior stop command, thus ensuring that a
4959 * following stop or destroy is sure to grab a timestamp_end near those
4960 * operations, even if the packet is empty.
4961 */
4962 (void) ust_app_clear_quiescent_session(usess);
4963
4964 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
4965 ret = ust_app_start_trace(usess, app);
4966 if (ret < 0) {
4967 /* Continue to next apps even on error */
4968 continue;
4969 }
4970 }
4971
4972 rcu_read_unlock();
4973
4974 return 0;
4975 }
4976
4977 /*
4978 * Start tracing for the UST session.
4979 * Called with UST session lock held.
4980 */
4981 int ust_app_stop_trace_all(struct ltt_ust_session *usess)
4982 {
4983 int ret = 0;
4984 struct lttng_ht_iter iter;
4985 struct ust_app *app;
4986
4987 DBG("Stopping all UST traces");
4988
4989 rcu_read_lock();
4990
4991 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
4992 ret = ust_app_stop_trace(usess, app);
4993 if (ret < 0) {
4994 /* Continue to next apps even on error */
4995 continue;
4996 }
4997 }
4998
4999 (void) ust_app_flush_session(usess);
5000
5001 rcu_read_unlock();
5002
5003 return 0;
5004 }
5005
5006 /*
5007 * Destroy app UST session.
5008 */
5009 int ust_app_destroy_trace_all(struct ltt_ust_session *usess)
5010 {
5011 int ret = 0;
5012 struct lttng_ht_iter iter;
5013 struct ust_app *app;
5014
5015 DBG("Destroy all UST traces");
5016
5017 rcu_read_lock();
5018
5019 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
5020 ret = destroy_trace(usess, app);
5021 if (ret < 0) {
5022 /* Continue to next apps even on error */
5023 continue;
5024 }
5025 }
5026
5027 rcu_read_unlock();
5028
5029 return 0;
5030 }
5031
5032 static
5033 void ust_app_global_create(struct ltt_ust_session *usess, struct ust_app *app)
5034 {
5035 int ret = 0;
5036 struct lttng_ht_iter iter, uiter;
5037 struct ust_app_session *ua_sess = NULL;
5038 struct ust_app_channel *ua_chan;
5039 struct ust_app_event *ua_event;
5040 struct ust_app_ctx *ua_ctx;
5041 int is_created = 0;
5042
5043 ret = create_ust_app_session(usess, app, &ua_sess, &is_created);
5044 if (ret < 0) {
5045 /* Tracer is probably gone or ENOMEM. */
5046 goto error;
5047 }
5048 if (!is_created) {
5049 /* App session already created. */
5050 goto end;
5051 }
5052 assert(ua_sess);
5053
5054 pthread_mutex_lock(&ua_sess->lock);
5055
5056 if (ua_sess->deleted) {
5057 pthread_mutex_unlock(&ua_sess->lock);
5058 goto end;
5059 }
5060
5061 /*
5062 * We can iterate safely here over all UST app session since the create ust
5063 * app session above made a shadow copy of the UST global domain from the
5064 * ltt ust session.
5065 */
5066 cds_lfht_for_each_entry(ua_sess->channels->ht, &iter.iter, ua_chan,
5067 node.node) {
5068 ret = do_create_channel(app, usess, ua_sess, ua_chan);
5069 if (ret < 0 && ret != -ENOTCONN) {
5070 /*
5071 * Stop everything. On error, the application
5072 * failed, no more file descriptor are available
5073 * or ENOMEM so stopping here is the only thing
5074 * we can do for now. The only exception is
5075 * -ENOTCONN, which indicates that the application
5076 * has exit.
5077 */
5078 goto error_unlock;
5079 }
5080
5081 /*
5082 * Add context using the list so they are enabled in the same order the
5083 * user added them.
5084 */
5085 cds_list_for_each_entry(ua_ctx, &ua_chan->ctx_list, list) {
5086 ret = create_ust_channel_context(ua_chan, ua_ctx, app);
5087 if (ret < 0) {
5088 goto error_unlock;
5089 }
5090 }
5091
5092
5093 /* For each events */
5094 cds_lfht_for_each_entry(ua_chan->events->ht, &uiter.iter, ua_event,
5095 node.node) {
5096 ret = create_ust_event(app, ua_sess, ua_chan, ua_event);
5097 if (ret < 0) {
5098 goto error_unlock;
5099 }
5100 }
5101 }
5102
5103 pthread_mutex_unlock(&ua_sess->lock);
5104
5105 if (usess->active) {
5106 ret = ust_app_start_trace(usess, app);
5107 if (ret < 0) {
5108 goto error;
5109 }
5110
5111 DBG2("UST trace started for app pid %d", app->pid);
5112 }
5113 end:
5114 /* Everything went well at this point. */
5115 return;
5116
5117 error_unlock:
5118 pthread_mutex_unlock(&ua_sess->lock);
5119 error:
5120 if (ua_sess) {
5121 destroy_app_session(app, ua_sess);
5122 }
5123 return;
5124 }
5125
5126 static
5127 void ust_app_global_destroy(struct ltt_ust_session *usess, struct ust_app *app)
5128 {
5129 struct ust_app_session *ua_sess;
5130
5131 ua_sess = lookup_session_by_app(usess, app);
5132 if (ua_sess == NULL) {
5133 return;
5134 }
5135 destroy_app_session(app, ua_sess);
5136 }
5137
5138 /*
5139 * Add channels/events from UST global domain to registered apps at sock.
5140 *
5141 * Called with session lock held.
5142 * Called with RCU read-side lock held.
5143 */
5144 void ust_app_global_update(struct ltt_ust_session *usess, struct ust_app *app)
5145 {
5146 assert(usess);
5147
5148 DBG2("UST app global update for app sock %d for session id %" PRIu64,
5149 app->sock, usess->id);
5150
5151 if (!app->compatible) {
5152 return;
5153 }
5154
5155 if (trace_ust_pid_tracker_lookup(usess, app->pid)) {
5156 ust_app_global_create(usess, app);
5157 } else {
5158 ust_app_global_destroy(usess, app);
5159 }
5160 }
5161
5162 /*
5163 * Called with session lock held.
5164 */
5165 void ust_app_global_update_all(struct ltt_ust_session *usess)
5166 {
5167 struct lttng_ht_iter iter;
5168 struct ust_app *app;
5169
5170 rcu_read_lock();
5171 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
5172 ust_app_global_update(usess, app);
5173 }
5174 rcu_read_unlock();
5175 }
5176
5177 /*
5178 * Add context to a specific channel for global UST domain.
5179 */
5180 int ust_app_add_ctx_channel_glb(struct ltt_ust_session *usess,
5181 struct ltt_ust_channel *uchan, struct ltt_ust_context *uctx)
5182 {
5183 int ret = 0;
5184 struct lttng_ht_node_str *ua_chan_node;
5185 struct lttng_ht_iter iter, uiter;
5186 struct ust_app_channel *ua_chan = NULL;
5187 struct ust_app_session *ua_sess;
5188 struct ust_app *app;
5189
5190 rcu_read_lock();
5191
5192 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
5193 if (!app->compatible) {
5194 /*
5195 * TODO: In time, we should notice the caller of this error by
5196 * telling him that this is a version error.
5197 */
5198 continue;
5199 }
5200 ua_sess = lookup_session_by_app(usess, app);
5201 if (ua_sess == NULL) {
5202 continue;
5203 }
5204
5205 pthread_mutex_lock(&ua_sess->lock);
5206
5207 if (ua_sess->deleted) {
5208 pthread_mutex_unlock(&ua_sess->lock);
5209 continue;
5210 }
5211
5212 /* Lookup channel in the ust app session */
5213 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &uiter);
5214 ua_chan_node = lttng_ht_iter_get_node_str(&uiter);
5215 if (ua_chan_node == NULL) {
5216 goto next_app;
5217 }
5218 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel,
5219 node);
5220 ret = create_ust_app_channel_context(ua_sess, ua_chan, &uctx->ctx, app);
5221 if (ret < 0) {
5222 goto next_app;
5223 }
5224 next_app:
5225 pthread_mutex_unlock(&ua_sess->lock);
5226 }
5227
5228 rcu_read_unlock();
5229 return ret;
5230 }
5231
5232 /*
5233 * Enable event for a channel from a UST session for a specific PID.
5234 */
5235 int ust_app_enable_event_pid(struct ltt_ust_session *usess,
5236 struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent, pid_t pid)
5237 {
5238 int ret = 0;
5239 struct lttng_ht_iter iter;
5240 struct lttng_ht_node_str *ua_chan_node;
5241 struct ust_app *app;
5242 struct ust_app_session *ua_sess;
5243 struct ust_app_channel *ua_chan;
5244 struct ust_app_event *ua_event;
5245
5246 DBG("UST app enabling event %s for PID %d", uevent->attr.name, pid);
5247
5248 rcu_read_lock();
5249
5250 app = ust_app_find_by_pid(pid);
5251 if (app == NULL) {
5252 ERR("UST app enable event per PID %d not found", pid);
5253 ret = -1;
5254 goto end;
5255 }
5256
5257 if (!app->compatible) {
5258 ret = 0;
5259 goto end;
5260 }
5261
5262 ua_sess = lookup_session_by_app(usess, app);
5263 if (!ua_sess) {
5264 /* The application has problem or is probably dead. */
5265 ret = 0;
5266 goto end;
5267 }
5268
5269 pthread_mutex_lock(&ua_sess->lock);
5270
5271 if (ua_sess->deleted) {
5272 ret = 0;
5273 goto end_unlock;
5274 }
5275
5276 /* Lookup channel in the ust app session */
5277 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &iter);
5278 ua_chan_node = lttng_ht_iter_get_node_str(&iter);
5279 /* If the channel is not found, there is a code flow error */
5280 assert(ua_chan_node);
5281
5282 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
5283
5284 ua_event = find_ust_app_event(ua_chan->events, uevent->attr.name,
5285 uevent->filter, uevent->attr.loglevel, uevent->exclusion);
5286 if (ua_event == NULL) {
5287 ret = create_ust_app_event(ua_sess, ua_chan, uevent, app);
5288 if (ret < 0) {
5289 goto end_unlock;
5290 }
5291 } else {
5292 ret = enable_ust_app_event(ua_sess, ua_event, app);
5293 if (ret < 0) {
5294 goto end_unlock;
5295 }
5296 }
5297
5298 end_unlock:
5299 pthread_mutex_unlock(&ua_sess->lock);
5300 end:
5301 rcu_read_unlock();
5302 return ret;
5303 }
5304
5305 /*
5306 * Receive registration and populate the given msg structure.
5307 *
5308 * On success return 0 else a negative value returned by the ustctl call.
5309 */
5310 int ust_app_recv_registration(int sock, struct ust_register_msg *msg)
5311 {
5312 int ret;
5313 uint32_t pid, ppid, uid, gid;
5314
5315 assert(msg);
5316
5317 ret = ustctl_recv_reg_msg(sock, &msg->type, &msg->major, &msg->minor,
5318 &pid, &ppid, &uid, &gid,
5319 &msg->bits_per_long,
5320 &msg->uint8_t_alignment,
5321 &msg->uint16_t_alignment,
5322 &msg->uint32_t_alignment,
5323 &msg->uint64_t_alignment,
5324 &msg->long_alignment,
5325 &msg->byte_order,
5326 msg->name);
5327 if (ret < 0) {
5328 switch (-ret) {
5329 case EPIPE:
5330 case ECONNRESET:
5331 case LTTNG_UST_ERR_EXITING:
5332 DBG3("UST app recv reg message failed. Application died");
5333 break;
5334 case LTTNG_UST_ERR_UNSUP_MAJOR:
5335 ERR("UST app recv reg unsupported version %d.%d. Supporting %d.%d",
5336 msg->major, msg->minor, LTTNG_UST_ABI_MAJOR_VERSION,
5337 LTTNG_UST_ABI_MINOR_VERSION);
5338 break;
5339 default:
5340 ERR("UST app recv reg message failed with ret %d", ret);
5341 break;
5342 }
5343 goto error;
5344 }
5345 msg->pid = (pid_t) pid;
5346 msg->ppid = (pid_t) ppid;
5347 msg->uid = (uid_t) uid;
5348 msg->gid = (gid_t) gid;
5349
5350 error:
5351 return ret;
5352 }
5353
5354 /*
5355 * Return a ust app session object using the application object and the
5356 * session object descriptor has a key. If not found, NULL is returned.
5357 * A RCU read side lock MUST be acquired when calling this function.
5358 */
5359 static struct ust_app_session *find_session_by_objd(struct ust_app *app,
5360 int objd)
5361 {
5362 struct lttng_ht_node_ulong *node;
5363 struct lttng_ht_iter iter;
5364 struct ust_app_session *ua_sess = NULL;
5365
5366 assert(app);
5367
5368 lttng_ht_lookup(app->ust_sessions_objd, (void *)((unsigned long) objd), &iter);
5369 node = lttng_ht_iter_get_node_ulong(&iter);
5370 if (node == NULL) {
5371 DBG2("UST app session find by objd %d not found", objd);
5372 goto error;
5373 }
5374
5375 ua_sess = caa_container_of(node, struct ust_app_session, ust_objd_node);
5376
5377 error:
5378 return ua_sess;
5379 }
5380
5381 /*
5382 * Return a ust app channel object using the application object and the channel
5383 * object descriptor has a key. If not found, NULL is returned. A RCU read side
5384 * lock MUST be acquired before calling this function.
5385 */
5386 static struct ust_app_channel *find_channel_by_objd(struct ust_app *app,
5387 int objd)
5388 {
5389 struct lttng_ht_node_ulong *node;
5390 struct lttng_ht_iter iter;
5391 struct ust_app_channel *ua_chan = NULL;
5392
5393 assert(app);
5394
5395 lttng_ht_lookup(app->ust_objd, (void *)((unsigned long) objd), &iter);
5396 node = lttng_ht_iter_get_node_ulong(&iter);
5397 if (node == NULL) {
5398 DBG2("UST app channel find by objd %d not found", objd);
5399 goto error;
5400 }
5401
5402 ua_chan = caa_container_of(node, struct ust_app_channel, ust_objd_node);
5403
5404 error:
5405 return ua_chan;
5406 }
5407
5408 /*
5409 * Reply to a register channel notification from an application on the notify
5410 * socket. The channel metadata is also created.
5411 *
5412 * The session UST registry lock is acquired in this function.
5413 *
5414 * On success 0 is returned else a negative value.
5415 */
5416 static int reply_ust_register_channel(int sock, int sobjd, int cobjd,
5417 size_t nr_fields, struct ustctl_field *fields)
5418 {
5419 int ret, ret_code = 0;
5420 uint32_t chan_id, reg_count;
5421 uint64_t chan_reg_key;
5422 enum ustctl_channel_header type;
5423 struct ust_app *app;
5424 struct ust_app_channel *ua_chan;
5425 struct ust_app_session *ua_sess;
5426 struct ust_registry_session *registry;
5427 struct ust_registry_channel *chan_reg;
5428
5429 rcu_read_lock();
5430
5431 /* Lookup application. If not found, there is a code flow error. */
5432 app = find_app_by_notify_sock(sock);
5433 if (!app) {
5434 DBG("Application socket %d is being torn down. Abort event notify",
5435 sock);
5436 ret = 0;
5437 goto error_rcu_unlock;
5438 }
5439
5440 /* Lookup channel by UST object descriptor. */
5441 ua_chan = find_channel_by_objd(app, cobjd);
5442 if (!ua_chan) {
5443 DBG("Application channel is being torn down. Abort event notify");
5444 ret = 0;
5445 goto error_rcu_unlock;
5446 }
5447
5448 assert(ua_chan->session);
5449 ua_sess = ua_chan->session;
5450
5451 /* Get right session registry depending on the session buffer type. */
5452 registry = get_session_registry(ua_sess);
5453 if (!registry) {
5454 DBG("Application session is being torn down. Abort event notify");
5455 ret = 0;
5456 goto error_rcu_unlock;
5457 };
5458
5459 /* Depending on the buffer type, a different channel key is used. */
5460 if (ua_sess->buffer_type == LTTNG_BUFFER_PER_UID) {
5461 chan_reg_key = ua_chan->tracing_channel_id;
5462 } else {
5463 chan_reg_key = ua_chan->key;
5464 }
5465
5466 pthread_mutex_lock(&registry->lock);
5467
5468 chan_reg = ust_registry_channel_find(registry, chan_reg_key);
5469 assert(chan_reg);
5470
5471 if (!chan_reg->register_done) {
5472 reg_count = ust_registry_get_event_count(chan_reg);
5473 if (reg_count < 31) {
5474 type = USTCTL_CHANNEL_HEADER_COMPACT;
5475 } else {
5476 type = USTCTL_CHANNEL_HEADER_LARGE;
5477 }
5478
5479 chan_reg->nr_ctx_fields = nr_fields;
5480 chan_reg->ctx_fields = fields;
5481 fields = NULL;
5482 chan_reg->header_type = type;
5483 } else {
5484 /* Get current already assigned values. */
5485 type = chan_reg->header_type;
5486 }
5487 /* Channel id is set during the object creation. */
5488 chan_id = chan_reg->chan_id;
5489
5490 /* Append to metadata */
5491 if (!chan_reg->metadata_dumped) {
5492 ret_code = ust_metadata_channel_statedump(registry, chan_reg);
5493 if (ret_code) {
5494 ERR("Error appending channel metadata (errno = %d)", ret_code);
5495 goto reply;
5496 }
5497 }
5498
5499 reply:
5500 DBG3("UST app replying to register channel key %" PRIu64
5501 " with id %u, type: %d, ret: %d", chan_reg_key, chan_id, type,
5502 ret_code);
5503
5504 ret = ustctl_reply_register_channel(sock, chan_id, type, ret_code);
5505 if (ret < 0) {
5506 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
5507 ERR("UST app reply channel failed with ret %d", ret);
5508 } else {
5509 DBG3("UST app reply channel failed. Application died");
5510 }
5511 goto error;
5512 }
5513
5514 /* This channel registry registration is completed. */
5515 chan_reg->register_done = 1;
5516
5517 error:
5518 pthread_mutex_unlock(&registry->lock);
5519 error_rcu_unlock:
5520 rcu_read_unlock();
5521 free(fields);
5522 return ret;
5523 }
5524
5525 /*
5526 * Add event to the UST channel registry. When the event is added to the
5527 * registry, the metadata is also created. Once done, this replies to the
5528 * application with the appropriate error code.
5529 *
5530 * The session UST registry lock is acquired in the function.
5531 *
5532 * On success 0 is returned else a negative value.
5533 */
5534 static int add_event_ust_registry(int sock, int sobjd, int cobjd, char *name,
5535 char *sig, size_t nr_fields, struct ustctl_field *fields,
5536 int loglevel_value, char *model_emf_uri)
5537 {
5538 int ret, ret_code;
5539 uint32_t event_id = 0;
5540 uint64_t chan_reg_key;
5541 struct ust_app *app;
5542 struct ust_app_channel *ua_chan;
5543 struct ust_app_session *ua_sess;
5544 struct ust_registry_session *registry;
5545
5546 rcu_read_lock();
5547
5548 /* Lookup application. If not found, there is a code flow error. */
5549 app = find_app_by_notify_sock(sock);
5550 if (!app) {
5551 DBG("Application socket %d is being torn down. Abort event notify",
5552 sock);
5553 ret = 0;
5554 goto error_rcu_unlock;
5555 }
5556
5557 /* Lookup channel by UST object descriptor. */
5558 ua_chan = find_channel_by_objd(app, cobjd);
5559 if (!ua_chan) {
5560 DBG("Application channel is being torn down. Abort event notify");
5561 ret = 0;
5562 goto error_rcu_unlock;
5563 }
5564
5565 assert(ua_chan->session);
5566 ua_sess = ua_chan->session;
5567
5568 registry = get_session_registry(ua_sess);
5569 if (!registry) {
5570 DBG("Application session is being torn down. Abort event notify");
5571 ret = 0;
5572 goto error_rcu_unlock;
5573 }
5574
5575 if (ua_sess->buffer_type == LTTNG_BUFFER_PER_UID) {
5576 chan_reg_key = ua_chan->tracing_channel_id;
5577 } else {
5578 chan_reg_key = ua_chan->key;
5579 }
5580
5581 pthread_mutex_lock(&registry->lock);
5582
5583 /*
5584 * From this point on, this call acquires the ownership of the sig, fields
5585 * and model_emf_uri meaning any free are done inside it if needed. These
5586 * three variables MUST NOT be read/write after this.
5587 */
5588 ret_code = ust_registry_create_event(registry, chan_reg_key,
5589 sobjd, cobjd, name, sig, nr_fields, fields,
5590 loglevel_value, model_emf_uri, ua_sess->buffer_type,
5591 &event_id, app);
5592 sig = NULL;
5593 fields = NULL;
5594 model_emf_uri = NULL;
5595
5596 /*
5597 * The return value is returned to ustctl so in case of an error, the
5598 * application can be notified. In case of an error, it's important not to
5599 * return a negative error or else the application will get closed.
5600 */
5601 ret = ustctl_reply_register_event(sock, event_id, ret_code);
5602 if (ret < 0) {
5603 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
5604 ERR("UST app reply event failed with ret %d", ret);
5605 } else {
5606 DBG3("UST app reply event failed. Application died");
5607 }
5608 /*
5609 * No need to wipe the create event since the application socket will
5610 * get close on error hence cleaning up everything by itself.
5611 */
5612 goto error;
5613 }
5614
5615 DBG3("UST registry event %s with id %" PRId32 " added successfully",
5616 name, event_id);
5617
5618 error:
5619 pthread_mutex_unlock(&registry->lock);
5620 error_rcu_unlock:
5621 rcu_read_unlock();
5622 free(sig);
5623 free(fields);
5624 free(model_emf_uri);
5625 return ret;
5626 }
5627
5628 /*
5629 * Add enum to the UST session registry. Once done, this replies to the
5630 * application with the appropriate error code.
5631 *
5632 * The session UST registry lock is acquired within this function.
5633 *
5634 * On success 0 is returned else a negative value.
5635 */
5636 static int add_enum_ust_registry(int sock, int sobjd, char *name,
5637 struct ustctl_enum_entry *entries, size_t nr_entries)
5638 {
5639 int ret = 0, ret_code;
5640 struct ust_app *app;
5641 struct ust_app_session *ua_sess;
5642 struct ust_registry_session *registry;
5643 uint64_t enum_id = -1ULL;
5644
5645 rcu_read_lock();
5646
5647 /* Lookup application. If not found, there is a code flow error. */
5648 app = find_app_by_notify_sock(sock);
5649 if (!app) {
5650 /* Return an error since this is not an error */
5651 DBG("Application socket %d is being torn down. Aborting enum registration",
5652 sock);
5653 free(entries);
5654 goto error_rcu_unlock;
5655 }
5656
5657 /* Lookup session by UST object descriptor. */
5658 ua_sess = find_session_by_objd(app, sobjd);
5659 if (!ua_sess) {
5660 /* Return an error since this is not an error */
5661 DBG("Application session is being torn down (session not found). Aborting enum registration.");
5662 free(entries);
5663 goto error_rcu_unlock;
5664 }
5665
5666 registry = get_session_registry(ua_sess);
5667 if (!registry) {
5668 DBG("Application session is being torn down (registry not found). Aborting enum registration.");
5669 free(entries);
5670 goto error_rcu_unlock;
5671 }
5672
5673 pthread_mutex_lock(&registry->lock);
5674
5675 /*
5676 * From this point on, the callee acquires the ownership of
5677 * entries. The variable entries MUST NOT be read/written after
5678 * call.
5679 */
5680 ret_code = ust_registry_create_or_find_enum(registry, sobjd, name,
5681 entries, nr_entries, &enum_id);
5682 entries = NULL;
5683
5684 /*
5685 * The return value is returned to ustctl so in case of an error, the
5686 * application can be notified. In case of an error, it's important not to
5687 * return a negative error or else the application will get closed.
5688 */
5689 ret = ustctl_reply_register_enum(sock, enum_id, ret_code);
5690 if (ret < 0) {
5691 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
5692 ERR("UST app reply enum failed with ret %d", ret);
5693 } else {
5694 DBG3("UST app reply enum failed. Application died");
5695 }
5696 /*
5697 * No need to wipe the create enum since the application socket will
5698 * get close on error hence cleaning up everything by itself.
5699 */
5700 goto error;
5701 }
5702
5703 DBG3("UST registry enum %s added successfully or already found", name);
5704
5705 error:
5706 pthread_mutex_unlock(&registry->lock);
5707 error_rcu_unlock:
5708 rcu_read_unlock();
5709 return ret;
5710 }
5711
5712 /*
5713 * Handle application notification through the given notify socket.
5714 *
5715 * Return 0 on success or else a negative value.
5716 */
5717 int ust_app_recv_notify(int sock)
5718 {
5719 int ret;
5720 enum ustctl_notify_cmd cmd;
5721
5722 DBG3("UST app receiving notify from sock %d", sock);
5723
5724 ret = ustctl_recv_notify(sock, &cmd);
5725 if (ret < 0) {
5726 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
5727 ERR("UST app recv notify failed with ret %d", ret);
5728 } else {
5729 DBG3("UST app recv notify failed. Application died");
5730 }
5731 goto error;
5732 }
5733
5734 switch (cmd) {
5735 case USTCTL_NOTIFY_CMD_EVENT:
5736 {
5737 int sobjd, cobjd, loglevel_value;
5738 char name[LTTNG_UST_SYM_NAME_LEN], *sig, *model_emf_uri;
5739 size_t nr_fields;
5740 struct ustctl_field *fields;
5741
5742 DBG2("UST app ustctl register event received");
5743
5744 ret = ustctl_recv_register_event(sock, &sobjd, &cobjd, name,
5745 &loglevel_value, &sig, &nr_fields, &fields,
5746 &model_emf_uri);
5747 if (ret < 0) {
5748 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
5749 ERR("UST app recv event failed with ret %d", ret);
5750 } else {
5751 DBG3("UST app recv event failed. Application died");
5752 }
5753 goto error;
5754 }
5755
5756 /*
5757 * Add event to the UST registry coming from the notify socket. This
5758 * call will free if needed the sig, fields and model_emf_uri. This
5759 * code path loses the ownsership of these variables and transfer them
5760 * to the this function.
5761 */
5762 ret = add_event_ust_registry(sock, sobjd, cobjd, name, sig, nr_fields,
5763 fields, loglevel_value, model_emf_uri);
5764 if (ret < 0) {
5765 goto error;
5766 }
5767
5768 break;
5769 }
5770 case USTCTL_NOTIFY_CMD_CHANNEL:
5771 {
5772 int sobjd, cobjd;
5773 size_t nr_fields;
5774 struct ustctl_field *fields;
5775
5776 DBG2("UST app ustctl register channel received");
5777
5778 ret = ustctl_recv_register_channel(sock, &sobjd, &cobjd, &nr_fields,
5779 &fields);
5780 if (ret < 0) {
5781 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
5782 ERR("UST app recv channel failed with ret %d", ret);
5783 } else {
5784 DBG3("UST app recv channel failed. Application died");
5785 }
5786 goto error;
5787 }
5788
5789 /*
5790 * The fields ownership are transfered to this function call meaning
5791 * that if needed it will be freed. After this, it's invalid to access
5792 * fields or clean it up.
5793 */
5794 ret = reply_ust_register_channel(sock, sobjd, cobjd, nr_fields,
5795 fields);
5796 if (ret < 0) {
5797 goto error;
5798 }
5799
5800 break;
5801 }
5802 case USTCTL_NOTIFY_CMD_ENUM:
5803 {
5804 int sobjd;
5805 char name[LTTNG_UST_SYM_NAME_LEN];
5806 size_t nr_entries;
5807 struct ustctl_enum_entry *entries;
5808
5809 DBG2("UST app ustctl register enum received");
5810
5811 ret = ustctl_recv_register_enum(sock, &sobjd, name,
5812 &entries, &nr_entries);
5813 if (ret < 0) {
5814 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
5815 ERR("UST app recv enum failed with ret %d", ret);
5816 } else {
5817 DBG3("UST app recv enum failed. Application died");
5818 }
5819 goto error;
5820 }
5821
5822 /* Callee assumes ownership of entries */
5823 ret = add_enum_ust_registry(sock, sobjd, name,
5824 entries, nr_entries);
5825 if (ret < 0) {
5826 goto error;
5827 }
5828
5829 break;
5830 }
5831 default:
5832 /* Should NEVER happen. */
5833 assert(0);
5834 }
5835
5836 error:
5837 return ret;
5838 }
5839
5840 /*
5841 * Once the notify socket hangs up, this is called. First, it tries to find the
5842 * corresponding application. On failure, the call_rcu to close the socket is
5843 * executed. If an application is found, it tries to delete it from the notify
5844 * socket hash table. Whathever the result, it proceeds to the call_rcu.
5845 *
5846 * Note that an object needs to be allocated here so on ENOMEM failure, the
5847 * call RCU is not done but the rest of the cleanup is.
5848 */
5849 void ust_app_notify_sock_unregister(int sock)
5850 {
5851 int err_enomem = 0;
5852 struct lttng_ht_iter iter;
5853 struct ust_app *app;
5854 struct ust_app_notify_sock_obj *obj;
5855
5856 assert(sock >= 0);
5857
5858 rcu_read_lock();
5859
5860 obj = zmalloc(sizeof(*obj));
5861 if (!obj) {
5862 /*
5863 * An ENOMEM is kind of uncool. If this strikes we continue the
5864 * procedure but the call_rcu will not be called. In this case, we
5865 * accept the fd leak rather than possibly creating an unsynchronized
5866 * state between threads.
5867 *
5868 * TODO: The notify object should be created once the notify socket is
5869 * registered and stored independantely from the ust app object. The
5870 * tricky part is to synchronize the teardown of the application and
5871 * this notify object. Let's keep that in mind so we can avoid this
5872 * kind of shenanigans with ENOMEM in the teardown path.
5873 */
5874 err_enomem = 1;
5875 } else {
5876 obj->fd = sock;
5877 }
5878
5879 DBG("UST app notify socket unregister %d", sock);
5880
5881 /*
5882 * Lookup application by notify socket. If this fails, this means that the
5883 * hash table delete has already been done by the application
5884 * unregistration process so we can safely close the notify socket in a
5885 * call RCU.
5886 */
5887 app = find_app_by_notify_sock(sock);
5888 if (!app) {
5889 goto close_socket;
5890 }
5891
5892 iter.iter.node = &app->notify_sock_n.node;
5893
5894 /*
5895 * Whatever happens here either we fail or succeed, in both cases we have
5896 * to close the socket after a grace period to continue to the call RCU
5897 * here. If the deletion is successful, the application is not visible
5898 * anymore by other threads and is it fails it means that it was already
5899 * deleted from the hash table so either way we just have to close the
5900 * socket.
5901 */
5902 (void) lttng_ht_del(ust_app_ht_by_notify_sock, &iter);
5903
5904 close_socket:
5905 rcu_read_unlock();
5906
5907 /*
5908 * Close socket after a grace period to avoid for the socket to be reused
5909 * before the application object is freed creating potential race between
5910 * threads trying to add unique in the global hash table.
5911 */
5912 if (!err_enomem) {
5913 call_rcu(&obj->head, close_notify_sock_rcu);
5914 }
5915 }
5916
5917 /*
5918 * Destroy a ust app data structure and free its memory.
5919 */
5920 void ust_app_destroy(struct ust_app *app)
5921 {
5922 if (!app) {
5923 return;
5924 }
5925
5926 call_rcu(&app->pid_n.head, delete_ust_app_rcu);
5927 }
5928
5929 /*
5930 * Take a snapshot for a given UST session. The snapshot is sent to the given
5931 * output.
5932 *
5933 * Return 0 on success or else a negative value.
5934 */
5935 int ust_app_snapshot_record(struct ltt_ust_session *usess,
5936 struct snapshot_output *output, int wait,
5937 uint64_t nb_packets_per_stream)
5938 {
5939 int ret = 0;
5940 struct lttng_ht_iter iter;
5941 struct ust_app *app;
5942 char pathname[PATH_MAX];
5943
5944 assert(usess);
5945 assert(output);
5946
5947 rcu_read_lock();
5948
5949 switch (usess->buffer_type) {
5950 case LTTNG_BUFFER_PER_UID:
5951 {
5952 struct buffer_reg_uid *reg;
5953
5954 cds_list_for_each_entry(reg, &usess->buffer_reg_uid_list, lnode) {
5955 struct buffer_reg_channel *reg_chan;
5956 struct consumer_socket *socket;
5957
5958 /* Get consumer socket to use to push the metadata.*/
5959 socket = consumer_find_socket_by_bitness(reg->bits_per_long,
5960 usess->consumer);
5961 if (!socket) {
5962 ret = -EINVAL;
5963 goto error;
5964 }
5965
5966 memset(pathname, 0, sizeof(pathname));
5967 ret = snprintf(pathname, sizeof(pathname),
5968 DEFAULT_UST_TRACE_DIR "/" DEFAULT_UST_TRACE_UID_PATH,
5969 reg->uid, reg->bits_per_long);
5970 if (ret < 0) {
5971 PERROR("snprintf snapshot path");
5972 goto error;
5973 }
5974
5975 /* Add the UST default trace dir to path. */
5976 cds_lfht_for_each_entry(reg->registry->channels->ht, &iter.iter,
5977 reg_chan, node.node) {
5978 ret = consumer_snapshot_channel(socket, reg_chan->consumer_key,
5979 output, 0, usess->uid, usess->gid, pathname, wait,
5980 nb_packets_per_stream);
5981 if (ret < 0) {
5982 goto error;
5983 }
5984 }
5985 ret = consumer_snapshot_channel(socket,
5986 reg->registry->reg.ust->metadata_key, output, 1,
5987 usess->uid, usess->gid, pathname, wait, 0);
5988 if (ret < 0) {
5989 goto error;
5990 }
5991 }
5992 break;
5993 }
5994 case LTTNG_BUFFER_PER_PID:
5995 {
5996 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
5997 struct consumer_socket *socket;
5998 struct lttng_ht_iter chan_iter;
5999 struct ust_app_channel *ua_chan;
6000 struct ust_app_session *ua_sess;
6001 struct ust_registry_session *registry;
6002
6003 ua_sess = lookup_session_by_app(usess, app);
6004 if (!ua_sess) {
6005 /* Session not associated with this app. */
6006 continue;
6007 }
6008
6009 /* Get the right consumer socket for the application. */
6010 socket = consumer_find_socket_by_bitness(app->bits_per_long,
6011 output->consumer);
6012 if (!socket) {
6013 ret = -EINVAL;
6014 goto error;
6015 }
6016
6017 /* Add the UST default trace dir to path. */
6018 memset(pathname, 0, sizeof(pathname));
6019 ret = snprintf(pathname, sizeof(pathname), DEFAULT_UST_TRACE_DIR "/%s",
6020 ua_sess->path);
6021 if (ret < 0) {
6022 PERROR("snprintf snapshot path");
6023 goto error;
6024 }
6025
6026 cds_lfht_for_each_entry(ua_sess->channels->ht, &chan_iter.iter,
6027 ua_chan, node.node) {
6028 ret = consumer_snapshot_channel(socket, ua_chan->key, output,
6029 0, ua_sess->euid, ua_sess->egid, pathname, wait,
6030 nb_packets_per_stream);
6031 if (ret < 0) {
6032 goto error;
6033 }
6034 }
6035
6036 registry = get_session_registry(ua_sess);
6037 if (!registry) {
6038 DBG("Application session is being torn down. Abort snapshot record.");
6039 ret = -1;
6040 goto error;
6041 }
6042 ret = consumer_snapshot_channel(socket, registry->metadata_key, output,
6043 1, ua_sess->euid, ua_sess->egid, pathname, wait, 0);
6044 if (ret < 0) {
6045 goto error;
6046 }
6047 }
6048 break;
6049 }
6050 default:
6051 assert(0);
6052 break;
6053 }
6054
6055 error:
6056 rcu_read_unlock();
6057 return ret;
6058 }
6059
6060 /*
6061 * Return the size taken by one more packet per stream.
6062 */
6063 uint64_t ust_app_get_size_one_more_packet_per_stream(struct ltt_ust_session *usess,
6064 uint64_t cur_nr_packets)
6065 {
6066 uint64_t tot_size = 0;
6067 struct ust_app *app;
6068 struct lttng_ht_iter iter;
6069
6070 assert(usess);
6071
6072 switch (usess->buffer_type) {
6073 case LTTNG_BUFFER_PER_UID:
6074 {
6075 struct buffer_reg_uid *reg;
6076
6077 cds_list_for_each_entry(reg, &usess->buffer_reg_uid_list, lnode) {
6078 struct buffer_reg_channel *reg_chan;
6079
6080 rcu_read_lock();
6081 cds_lfht_for_each_entry(reg->registry->channels->ht, &iter.iter,
6082 reg_chan, node.node) {
6083 if (cur_nr_packets >= reg_chan->num_subbuf) {
6084 /*
6085 * Don't take channel into account if we
6086 * already grab all its packets.
6087 */
6088 continue;
6089 }
6090 tot_size += reg_chan->subbuf_size * reg_chan->stream_count;
6091 }
6092 rcu_read_unlock();
6093 }
6094 break;
6095 }
6096 case LTTNG_BUFFER_PER_PID:
6097 {
6098 rcu_read_lock();
6099 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
6100 struct ust_app_channel *ua_chan;
6101 struct ust_app_session *ua_sess;
6102 struct lttng_ht_iter chan_iter;
6103
6104 ua_sess = lookup_session_by_app(usess, app);
6105 if (!ua_sess) {
6106 /* Session not associated with this app. */
6107 continue;
6108 }
6109
6110 cds_lfht_for_each_entry(ua_sess->channels->ht, &chan_iter.iter,
6111 ua_chan, node.node) {
6112 if (cur_nr_packets >= ua_chan->attr.num_subbuf) {
6113 /*
6114 * Don't take channel into account if we
6115 * already grab all its packets.
6116 */
6117 continue;
6118 }
6119 tot_size += ua_chan->attr.subbuf_size * ua_chan->streams.count;
6120 }
6121 }
6122 rcu_read_unlock();
6123 break;
6124 }
6125 default:
6126 assert(0);
6127 break;
6128 }
6129
6130 return tot_size;
6131 }
6132
6133 int ust_app_uid_get_channel_runtime_stats(uint64_t ust_session_id,
6134 struct cds_list_head *buffer_reg_uid_list,
6135 struct consumer_output *consumer, uint64_t uchan_id,
6136 int overwrite, uint64_t *discarded, uint64_t *lost)
6137 {
6138 int ret;
6139 uint64_t consumer_chan_key;
6140
6141 *discarded = 0;
6142 *lost = 0;
6143
6144 ret = buffer_reg_uid_consumer_channel_key(
6145 buffer_reg_uid_list, ust_session_id,
6146 uchan_id, &consumer_chan_key);
6147 if (ret < 0) {
6148 /* Not found */
6149 ret = 0;
6150 goto end;
6151 }
6152
6153 if (overwrite) {
6154 ret = consumer_get_lost_packets(ust_session_id,
6155 consumer_chan_key, consumer, lost);
6156 } else {
6157 ret = consumer_get_discarded_events(ust_session_id,
6158 consumer_chan_key, consumer, discarded);
6159 }
6160
6161 end:
6162 return ret;
6163 }
6164
6165 int ust_app_pid_get_channel_runtime_stats(struct ltt_ust_session *usess,
6166 struct ltt_ust_channel *uchan,
6167 struct consumer_output *consumer, int overwrite,
6168 uint64_t *discarded, uint64_t *lost)
6169 {
6170 int ret = 0;
6171 struct lttng_ht_iter iter;
6172 struct lttng_ht_node_str *ua_chan_node;
6173 struct ust_app *app;
6174 struct ust_app_session *ua_sess;
6175 struct ust_app_channel *ua_chan;
6176
6177 *discarded = 0;
6178 *lost = 0;
6179
6180 rcu_read_lock();
6181 /*
6182 * Iterate over every registered applications. Sum counters for
6183 * all applications containing requested session and channel.
6184 */
6185 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
6186 struct lttng_ht_iter uiter;
6187
6188 ua_sess = lookup_session_by_app(usess, app);
6189 if (ua_sess == NULL) {
6190 continue;
6191 }
6192
6193 /* Get channel */
6194 lttng_ht_lookup(ua_sess->channels, (void *) uchan->name, &uiter);
6195 ua_chan_node = lttng_ht_iter_get_node_str(&uiter);
6196 /* If the session is found for the app, the channel must be there */
6197 assert(ua_chan_node);
6198
6199 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
6200
6201 if (overwrite) {
6202 uint64_t _lost;
6203
6204 ret = consumer_get_lost_packets(usess->id, ua_chan->key,
6205 consumer, &_lost);
6206 if (ret < 0) {
6207 break;
6208 }
6209 (*lost) += _lost;
6210 } else {
6211 uint64_t _discarded;
6212
6213 ret = consumer_get_discarded_events(usess->id,
6214 ua_chan->key, consumer, &_discarded);
6215 if (ret < 0) {
6216 break;
6217 }
6218 (*discarded) += _discarded;
6219 }
6220 }
6221
6222 rcu_read_unlock();
6223 return ret;
6224 }
6225
6226 static
6227 int ust_app_regenerate_statedump(struct ltt_ust_session *usess,
6228 struct ust_app *app)
6229 {
6230 int ret = 0;
6231 struct ust_app_session *ua_sess;
6232
6233 DBG("Regenerating the metadata for ust app pid %d", app->pid);
6234
6235 rcu_read_lock();
6236
6237 ua_sess = lookup_session_by_app(usess, app);
6238 if (ua_sess == NULL) {
6239 /* The session is in teardown process. Ignore and continue. */
6240 goto end;
6241 }
6242
6243 pthread_mutex_lock(&ua_sess->lock);
6244
6245 if (ua_sess->deleted) {
6246 goto end_unlock;
6247 }
6248
6249 pthread_mutex_lock(&app->sock_lock);
6250 ret = ustctl_regenerate_statedump(app->sock, ua_sess->handle);
6251 pthread_mutex_unlock(&app->sock_lock);
6252
6253 end_unlock:
6254 pthread_mutex_unlock(&ua_sess->lock);
6255
6256 end:
6257 rcu_read_unlock();
6258 health_code_update();
6259 return ret;
6260 }
6261
6262 /*
6263 * Regenerate the statedump for each app in the session.
6264 */
6265 int ust_app_regenerate_statedump_all(struct ltt_ust_session *usess)
6266 {
6267 int ret = 0;
6268 struct lttng_ht_iter iter;
6269 struct ust_app *app;
6270
6271 DBG("Regenerating the metadata for all UST apps");
6272
6273 rcu_read_lock();
6274
6275 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
6276 if (!app->compatible) {
6277 continue;
6278 }
6279
6280 ret = ust_app_regenerate_statedump(usess, app);
6281 if (ret < 0) {
6282 /* Continue to the next app even on error */
6283 continue;
6284 }
6285 }
6286
6287 rcu_read_unlock();
6288
6289 return 0;
6290 }
This page took 0.203995 seconds and 4 git commands to generate.