cb5ba6c485ec33ec1dafe5366dba5b0a1792d8c0
[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 other
3581 * 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 strlen(usess->consumer->dst.trace_path) > 0) {
4421 ret = run_as_mkdir_recursive(usess->consumer->dst.trace_path,
4422 S_IRWXU | S_IRWXG, ua_sess->euid, ua_sess->egid);
4423 if (ret < 0) {
4424 if (errno != EEXIST) {
4425 ERR("Trace directory creation error");
4426 goto error_unlock;
4427 }
4428 }
4429 }
4430
4431 /*
4432 * Create the metadata for the application. This returns gracefully if a
4433 * metadata was already set for the session.
4434 */
4435 ret = create_ust_app_metadata(ua_sess, app, usess->consumer);
4436 if (ret < 0) {
4437 goto error_unlock;
4438 }
4439
4440 health_code_update();
4441
4442 skip_setup:
4443 /* This start the UST tracing */
4444 pthread_mutex_lock(&app->sock_lock);
4445 ret = ustctl_start_session(app->sock, ua_sess->handle);
4446 pthread_mutex_unlock(&app->sock_lock);
4447 if (ret < 0) {
4448 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
4449 ERR("Error starting tracing for app pid: %d (ret: %d)",
4450 app->pid, ret);
4451 } else {
4452 DBG("UST app start session failed. Application is dead.");
4453 /*
4454 * This is normal behavior, an application can die during the
4455 * creation process. Don't report an error so the execution can
4456 * continue normally.
4457 */
4458 pthread_mutex_unlock(&ua_sess->lock);
4459 goto end;
4460 }
4461 goto error_unlock;
4462 }
4463
4464 /* Indicate that the session has been started once */
4465 ua_sess->started = 1;
4466
4467 pthread_mutex_unlock(&ua_sess->lock);
4468
4469 health_code_update();
4470
4471 /* Quiescent wait after starting trace */
4472 pthread_mutex_lock(&app->sock_lock);
4473 ret = ustctl_wait_quiescent(app->sock);
4474 pthread_mutex_unlock(&app->sock_lock);
4475 if (ret < 0 && ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
4476 ERR("UST app wait quiescent failed for app pid %d ret %d",
4477 app->pid, ret);
4478 }
4479
4480 end:
4481 rcu_read_unlock();
4482 health_code_update();
4483 return 0;
4484
4485 error_unlock:
4486 pthread_mutex_unlock(&ua_sess->lock);
4487 rcu_read_unlock();
4488 health_code_update();
4489 return -1;
4490 }
4491
4492 /*
4493 * Stop tracing for a specific UST session and app.
4494 */
4495 static
4496 int ust_app_stop_trace(struct ltt_ust_session *usess, struct ust_app *app)
4497 {
4498 int ret = 0;
4499 struct ust_app_session *ua_sess;
4500 struct ust_registry_session *registry;
4501
4502 DBG("Stopping tracing for ust app pid %d", app->pid);
4503
4504 rcu_read_lock();
4505
4506 if (!app->compatible) {
4507 goto end_no_session;
4508 }
4509
4510 ua_sess = lookup_session_by_app(usess, app);
4511 if (ua_sess == NULL) {
4512 goto end_no_session;
4513 }
4514
4515 pthread_mutex_lock(&ua_sess->lock);
4516
4517 if (ua_sess->deleted) {
4518 pthread_mutex_unlock(&ua_sess->lock);
4519 goto end_no_session;
4520 }
4521
4522 /*
4523 * If started = 0, it means that stop trace has been called for a session
4524 * that was never started. It's possible since we can have a fail start
4525 * from either the application manager thread or the command thread. Simply
4526 * indicate that this is a stop error.
4527 */
4528 if (!ua_sess->started) {
4529 goto error_rcu_unlock;
4530 }
4531
4532 health_code_update();
4533
4534 /* This inhibits UST tracing */
4535 pthread_mutex_lock(&app->sock_lock);
4536 ret = ustctl_stop_session(app->sock, ua_sess->handle);
4537 pthread_mutex_unlock(&app->sock_lock);
4538 if (ret < 0) {
4539 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
4540 ERR("Error stopping tracing for app pid: %d (ret: %d)",
4541 app->pid, ret);
4542 } else {
4543 DBG("UST app stop session failed. Application is dead.");
4544 /*
4545 * This is normal behavior, an application can die during the
4546 * creation process. Don't report an error so the execution can
4547 * continue normally.
4548 */
4549 goto end_unlock;
4550 }
4551 goto error_rcu_unlock;
4552 }
4553
4554 health_code_update();
4555
4556 /* Quiescent wait after stopping trace */
4557 pthread_mutex_lock(&app->sock_lock);
4558 ret = ustctl_wait_quiescent(app->sock);
4559 pthread_mutex_unlock(&app->sock_lock);
4560 if (ret < 0 && ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
4561 ERR("UST app wait quiescent failed for app pid %d ret %d",
4562 app->pid, ret);
4563 }
4564
4565 health_code_update();
4566
4567 registry = get_session_registry(ua_sess);
4568
4569 /* The UST app session is held registry shall not be null. */
4570 assert(registry);
4571
4572 /* Push metadata for application before freeing the application. */
4573 (void) push_metadata(registry, ua_sess->consumer);
4574
4575 end_unlock:
4576 pthread_mutex_unlock(&ua_sess->lock);
4577 end_no_session:
4578 rcu_read_unlock();
4579 health_code_update();
4580 return 0;
4581
4582 error_rcu_unlock:
4583 pthread_mutex_unlock(&ua_sess->lock);
4584 rcu_read_unlock();
4585 health_code_update();
4586 return -1;
4587 }
4588
4589 static
4590 int ust_app_flush_app_session(struct ust_app *app,
4591 struct ust_app_session *ua_sess)
4592 {
4593 int ret, retval = 0;
4594 struct lttng_ht_iter iter;
4595 struct ust_app_channel *ua_chan;
4596 struct consumer_socket *socket;
4597
4598 DBG("Flushing app session buffers for ust app pid %d", app->pid);
4599
4600 rcu_read_lock();
4601
4602 if (!app->compatible) {
4603 goto end_not_compatible;
4604 }
4605
4606 pthread_mutex_lock(&ua_sess->lock);
4607
4608 if (ua_sess->deleted) {
4609 goto end_deleted;
4610 }
4611
4612 health_code_update();
4613
4614 /* Flushing buffers */
4615 socket = consumer_find_socket_by_bitness(app->bits_per_long,
4616 ua_sess->consumer);
4617
4618 /* Flush buffers and push metadata. */
4619 switch (ua_sess->buffer_type) {
4620 case LTTNG_BUFFER_PER_PID:
4621 cds_lfht_for_each_entry(ua_sess->channels->ht, &iter.iter, ua_chan,
4622 node.node) {
4623 health_code_update();
4624 ret = consumer_flush_channel(socket, ua_chan->key);
4625 if (ret) {
4626 ERR("Error flushing consumer channel");
4627 retval = -1;
4628 continue;
4629 }
4630 }
4631 break;
4632 case LTTNG_BUFFER_PER_UID:
4633 default:
4634 assert(0);
4635 break;
4636 }
4637
4638 health_code_update();
4639
4640 end_deleted:
4641 pthread_mutex_unlock(&ua_sess->lock);
4642
4643 end_not_compatible:
4644 rcu_read_unlock();
4645 health_code_update();
4646 return retval;
4647 }
4648
4649 /*
4650 * Flush buffers for all applications for a specific UST session.
4651 * Called with UST session lock held.
4652 */
4653 static
4654 int ust_app_flush_session(struct ltt_ust_session *usess)
4655
4656 {
4657 int ret = 0;
4658
4659 DBG("Flushing session buffers for all ust apps");
4660
4661 rcu_read_lock();
4662
4663 /* Flush buffers and push metadata. */
4664 switch (usess->buffer_type) {
4665 case LTTNG_BUFFER_PER_UID:
4666 {
4667 struct buffer_reg_uid *reg;
4668 struct lttng_ht_iter iter;
4669
4670 /* Flush all per UID buffers associated to that session. */
4671 cds_list_for_each_entry(reg, &usess->buffer_reg_uid_list, lnode) {
4672 struct ust_registry_session *ust_session_reg;
4673 struct buffer_reg_channel *reg_chan;
4674 struct consumer_socket *socket;
4675
4676 /* Get consumer socket to use to push the metadata.*/
4677 socket = consumer_find_socket_by_bitness(reg->bits_per_long,
4678 usess->consumer);
4679 if (!socket) {
4680 /* Ignore request if no consumer is found for the session. */
4681 continue;
4682 }
4683
4684 cds_lfht_for_each_entry(reg->registry->channels->ht, &iter.iter,
4685 reg_chan, node.node) {
4686 /*
4687 * The following call will print error values so the return
4688 * code is of little importance because whatever happens, we
4689 * have to try them all.
4690 */
4691 (void) consumer_flush_channel(socket, reg_chan->consumer_key);
4692 }
4693
4694 ust_session_reg = reg->registry->reg.ust;
4695 /* Push metadata. */
4696 (void) push_metadata(ust_session_reg, usess->consumer);
4697 }
4698 break;
4699 }
4700 case LTTNG_BUFFER_PER_PID:
4701 {
4702 struct ust_app_session *ua_sess;
4703 struct lttng_ht_iter iter;
4704 struct ust_app *app;
4705
4706 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
4707 ua_sess = lookup_session_by_app(usess, app);
4708 if (ua_sess == NULL) {
4709 continue;
4710 }
4711 (void) ust_app_flush_app_session(app, ua_sess);
4712 }
4713 break;
4714 }
4715 default:
4716 ret = -1;
4717 assert(0);
4718 break;
4719 }
4720
4721 rcu_read_unlock();
4722 health_code_update();
4723 return ret;
4724 }
4725
4726 static
4727 int ust_app_clear_quiescent_app_session(struct ust_app *app,
4728 struct ust_app_session *ua_sess)
4729 {
4730 int ret = 0;
4731 struct lttng_ht_iter iter;
4732 struct ust_app_channel *ua_chan;
4733 struct consumer_socket *socket;
4734
4735 DBG("Clearing stream quiescent state for ust app pid %d", app->pid);
4736
4737 rcu_read_lock();
4738
4739 if (!app->compatible) {
4740 goto end_not_compatible;
4741 }
4742
4743 pthread_mutex_lock(&ua_sess->lock);
4744
4745 if (ua_sess->deleted) {
4746 goto end_unlock;
4747 }
4748
4749 health_code_update();
4750
4751 socket = consumer_find_socket_by_bitness(app->bits_per_long,
4752 ua_sess->consumer);
4753 if (!socket) {
4754 ERR("Failed to find consumer (%" PRIu32 ") socket",
4755 app->bits_per_long);
4756 ret = -1;
4757 goto end_unlock;
4758 }
4759
4760 /* Clear quiescent state. */
4761 switch (ua_sess->buffer_type) {
4762 case LTTNG_BUFFER_PER_PID:
4763 cds_lfht_for_each_entry(ua_sess->channels->ht, &iter.iter,
4764 ua_chan, node.node) {
4765 health_code_update();
4766 ret = consumer_clear_quiescent_channel(socket,
4767 ua_chan->key);
4768 if (ret) {
4769 ERR("Error clearing quiescent state for consumer channel");
4770 ret = -1;
4771 continue;
4772 }
4773 }
4774 break;
4775 case LTTNG_BUFFER_PER_UID:
4776 default:
4777 assert(0);
4778 ret = -1;
4779 break;
4780 }
4781
4782 health_code_update();
4783
4784 end_unlock:
4785 pthread_mutex_unlock(&ua_sess->lock);
4786
4787 end_not_compatible:
4788 rcu_read_unlock();
4789 health_code_update();
4790 return ret;
4791 }
4792
4793 /*
4794 * Clear quiescent state in each stream for all applications for a
4795 * specific UST session.
4796 * Called with UST session lock held.
4797 */
4798 static
4799 int ust_app_clear_quiescent_session(struct ltt_ust_session *usess)
4800
4801 {
4802 int ret = 0;
4803
4804 DBG("Clearing stream quiescent state for all ust apps");
4805
4806 rcu_read_lock();
4807
4808 switch (usess->buffer_type) {
4809 case LTTNG_BUFFER_PER_UID:
4810 {
4811 struct lttng_ht_iter iter;
4812 struct buffer_reg_uid *reg;
4813
4814 /*
4815 * Clear quiescent for all per UID buffers associated to
4816 * that session.
4817 */
4818 cds_list_for_each_entry(reg, &usess->buffer_reg_uid_list, lnode) {
4819 struct consumer_socket *socket;
4820 struct buffer_reg_channel *reg_chan;
4821
4822 /* Get associated consumer socket.*/
4823 socket = consumer_find_socket_by_bitness(
4824 reg->bits_per_long, usess->consumer);
4825 if (!socket) {
4826 /*
4827 * Ignore request if no consumer is found for
4828 * the session.
4829 */
4830 continue;
4831 }
4832
4833 cds_lfht_for_each_entry(reg->registry->channels->ht,
4834 &iter.iter, reg_chan, node.node) {
4835 /*
4836 * The following call will print error values so
4837 * the return code is of little importance
4838 * because whatever happens, we have to try them
4839 * all.
4840 */
4841 (void) consumer_clear_quiescent_channel(socket,
4842 reg_chan->consumer_key);
4843 }
4844 }
4845 break;
4846 }
4847 case LTTNG_BUFFER_PER_PID:
4848 {
4849 struct ust_app_session *ua_sess;
4850 struct lttng_ht_iter iter;
4851 struct ust_app *app;
4852
4853 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app,
4854 pid_n.node) {
4855 ua_sess = lookup_session_by_app(usess, app);
4856 if (ua_sess == NULL) {
4857 continue;
4858 }
4859 (void) ust_app_clear_quiescent_app_session(app,
4860 ua_sess);
4861 }
4862 break;
4863 }
4864 default:
4865 ret = -1;
4866 assert(0);
4867 break;
4868 }
4869
4870 rcu_read_unlock();
4871 health_code_update();
4872 return ret;
4873 }
4874
4875 /*
4876 * Destroy a specific UST session in apps.
4877 */
4878 static int destroy_trace(struct ltt_ust_session *usess, struct ust_app *app)
4879 {
4880 int ret;
4881 struct ust_app_session *ua_sess;
4882 struct lttng_ht_iter iter;
4883 struct lttng_ht_node_u64 *node;
4884
4885 DBG("Destroy tracing for ust app pid %d", app->pid);
4886
4887 rcu_read_lock();
4888
4889 if (!app->compatible) {
4890 goto end;
4891 }
4892
4893 __lookup_session_by_app(usess, app, &iter);
4894 node = lttng_ht_iter_get_node_u64(&iter);
4895 if (node == NULL) {
4896 /* Session is being or is deleted. */
4897 goto end;
4898 }
4899 ua_sess = caa_container_of(node, struct ust_app_session, node);
4900
4901 health_code_update();
4902 destroy_app_session(app, ua_sess);
4903
4904 health_code_update();
4905
4906 /* Quiescent wait after stopping trace */
4907 pthread_mutex_lock(&app->sock_lock);
4908 ret = ustctl_wait_quiescent(app->sock);
4909 pthread_mutex_unlock(&app->sock_lock);
4910 if (ret < 0 && ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
4911 ERR("UST app wait quiescent failed for app pid %d ret %d",
4912 app->pid, ret);
4913 }
4914 end:
4915 rcu_read_unlock();
4916 health_code_update();
4917 return 0;
4918 }
4919
4920 /*
4921 * Start tracing for the UST session.
4922 */
4923 int ust_app_start_trace_all(struct ltt_ust_session *usess)
4924 {
4925 int ret = 0;
4926 struct lttng_ht_iter iter;
4927 struct ust_app *app;
4928
4929 DBG("Starting all UST traces");
4930
4931 rcu_read_lock();
4932
4933 /*
4934 * In a start-stop-start use-case, we need to clear the quiescent state
4935 * of each channel set by the prior stop command, thus ensuring that a
4936 * following stop or destroy is sure to grab a timestamp_end near those
4937 * operations, even if the packet is empty.
4938 */
4939 (void) ust_app_clear_quiescent_session(usess);
4940
4941 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
4942 ret = ust_app_start_trace(usess, app);
4943 if (ret < 0) {
4944 /* Continue to next apps even on error */
4945 continue;
4946 }
4947 }
4948
4949 rcu_read_unlock();
4950
4951 return 0;
4952 }
4953
4954 /*
4955 * Start tracing for the UST session.
4956 * Called with UST session lock held.
4957 */
4958 int ust_app_stop_trace_all(struct ltt_ust_session *usess)
4959 {
4960 int ret = 0;
4961 struct lttng_ht_iter iter;
4962 struct ust_app *app;
4963
4964 DBG("Stopping all UST traces");
4965
4966 rcu_read_lock();
4967
4968 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
4969 ret = ust_app_stop_trace(usess, app);
4970 if (ret < 0) {
4971 /* Continue to next apps even on error */
4972 continue;
4973 }
4974 }
4975
4976 (void) ust_app_flush_session(usess);
4977
4978 rcu_read_unlock();
4979
4980 return 0;
4981 }
4982
4983 /*
4984 * Destroy app UST session.
4985 */
4986 int ust_app_destroy_trace_all(struct ltt_ust_session *usess)
4987 {
4988 int ret = 0;
4989 struct lttng_ht_iter iter;
4990 struct ust_app *app;
4991
4992 DBG("Destroy all UST traces");
4993
4994 rcu_read_lock();
4995
4996 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
4997 ret = destroy_trace(usess, app);
4998 if (ret < 0) {
4999 /* Continue to next apps even on error */
5000 continue;
5001 }
5002 }
5003
5004 rcu_read_unlock();
5005
5006 return 0;
5007 }
5008
5009 static
5010 void ust_app_global_create(struct ltt_ust_session *usess, struct ust_app *app)
5011 {
5012 int ret = 0;
5013 struct lttng_ht_iter iter, uiter;
5014 struct ust_app_session *ua_sess = NULL;
5015 struct ust_app_channel *ua_chan;
5016 struct ust_app_event *ua_event;
5017 struct ust_app_ctx *ua_ctx;
5018 int is_created = 0;
5019
5020 ret = create_ust_app_session(usess, app, &ua_sess, &is_created);
5021 if (ret < 0) {
5022 /* Tracer is probably gone or ENOMEM. */
5023 goto error;
5024 }
5025 if (!is_created) {
5026 /* App session already created. */
5027 goto end;
5028 }
5029 assert(ua_sess);
5030
5031 pthread_mutex_lock(&ua_sess->lock);
5032
5033 if (ua_sess->deleted) {
5034 pthread_mutex_unlock(&ua_sess->lock);
5035 goto end;
5036 }
5037
5038 /*
5039 * We can iterate safely here over all UST app session since the create ust
5040 * app session above made a shadow copy of the UST global domain from the
5041 * ltt ust session.
5042 */
5043 cds_lfht_for_each_entry(ua_sess->channels->ht, &iter.iter, ua_chan,
5044 node.node) {
5045 ret = do_create_channel(app, usess, ua_sess, ua_chan);
5046 if (ret < 0 && ret != -ENOTCONN) {
5047 /*
5048 * Stop everything. On error, the application
5049 * failed, no more file descriptor are available
5050 * or ENOMEM so stopping here is the only thing
5051 * we can do for now. The only exception is
5052 * -ENOTCONN, which indicates that the application
5053 * has exit.
5054 */
5055 goto error_unlock;
5056 }
5057
5058 /*
5059 * Add context using the list so they are enabled in the same order the
5060 * user added them.
5061 */
5062 cds_list_for_each_entry(ua_ctx, &ua_chan->ctx_list, list) {
5063 ret = create_ust_channel_context(ua_chan, ua_ctx, app);
5064 if (ret < 0) {
5065 goto error_unlock;
5066 }
5067 }
5068
5069
5070 /* For each events */
5071 cds_lfht_for_each_entry(ua_chan->events->ht, &uiter.iter, ua_event,
5072 node.node) {
5073 ret = create_ust_event(app, ua_sess, ua_chan, ua_event);
5074 if (ret < 0) {
5075 goto error_unlock;
5076 }
5077 }
5078 }
5079
5080 pthread_mutex_unlock(&ua_sess->lock);
5081
5082 if (usess->active) {
5083 ret = ust_app_start_trace(usess, app);
5084 if (ret < 0) {
5085 goto error;
5086 }
5087
5088 DBG2("UST trace started for app pid %d", app->pid);
5089 }
5090 end:
5091 /* Everything went well at this point. */
5092 return;
5093
5094 error_unlock:
5095 pthread_mutex_unlock(&ua_sess->lock);
5096 error:
5097 if (ua_sess) {
5098 destroy_app_session(app, ua_sess);
5099 }
5100 return;
5101 }
5102
5103 static
5104 void ust_app_global_destroy(struct ltt_ust_session *usess, struct ust_app *app)
5105 {
5106 struct ust_app_session *ua_sess;
5107
5108 ua_sess = lookup_session_by_app(usess, app);
5109 if (ua_sess == NULL) {
5110 return;
5111 }
5112 destroy_app_session(app, ua_sess);
5113 }
5114
5115 /*
5116 * Add channels/events from UST global domain to registered apps at sock.
5117 *
5118 * Called with session lock held.
5119 * Called with RCU read-side lock held.
5120 */
5121 void ust_app_global_update(struct ltt_ust_session *usess, struct ust_app *app)
5122 {
5123 assert(usess);
5124
5125 DBG2("UST app global update for app sock %d for session id %" PRIu64,
5126 app->sock, usess->id);
5127
5128 if (!app->compatible) {
5129 return;
5130 }
5131
5132 if (trace_ust_pid_tracker_lookup(usess, app->pid)) {
5133 ust_app_global_create(usess, app);
5134 } else {
5135 ust_app_global_destroy(usess, app);
5136 }
5137 }
5138
5139 /*
5140 * Called with session lock held.
5141 */
5142 void ust_app_global_update_all(struct ltt_ust_session *usess)
5143 {
5144 struct lttng_ht_iter iter;
5145 struct ust_app *app;
5146
5147 rcu_read_lock();
5148 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
5149 ust_app_global_update(usess, app);
5150 }
5151 rcu_read_unlock();
5152 }
5153
5154 /*
5155 * Add context to a specific channel for global UST domain.
5156 */
5157 int ust_app_add_ctx_channel_glb(struct ltt_ust_session *usess,
5158 struct ltt_ust_channel *uchan, struct ltt_ust_context *uctx)
5159 {
5160 int ret = 0;
5161 struct lttng_ht_node_str *ua_chan_node;
5162 struct lttng_ht_iter iter, uiter;
5163 struct ust_app_channel *ua_chan = NULL;
5164 struct ust_app_session *ua_sess;
5165 struct ust_app *app;
5166
5167 rcu_read_lock();
5168
5169 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
5170 if (!app->compatible) {
5171 /*
5172 * TODO: In time, we should notice the caller of this error by
5173 * telling him that this is a version error.
5174 */
5175 continue;
5176 }
5177 ua_sess = lookup_session_by_app(usess, app);
5178 if (ua_sess == NULL) {
5179 continue;
5180 }
5181
5182 pthread_mutex_lock(&ua_sess->lock);
5183
5184 if (ua_sess->deleted) {
5185 pthread_mutex_unlock(&ua_sess->lock);
5186 continue;
5187 }
5188
5189 /* Lookup channel in the ust app session */
5190 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &uiter);
5191 ua_chan_node = lttng_ht_iter_get_node_str(&uiter);
5192 if (ua_chan_node == NULL) {
5193 goto next_app;
5194 }
5195 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel,
5196 node);
5197 ret = create_ust_app_channel_context(ua_sess, ua_chan, &uctx->ctx, app);
5198 if (ret < 0) {
5199 goto next_app;
5200 }
5201 next_app:
5202 pthread_mutex_unlock(&ua_sess->lock);
5203 }
5204
5205 rcu_read_unlock();
5206 return ret;
5207 }
5208
5209 /*
5210 * Enable event for a channel from a UST session for a specific PID.
5211 */
5212 int ust_app_enable_event_pid(struct ltt_ust_session *usess,
5213 struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent, pid_t pid)
5214 {
5215 int ret = 0;
5216 struct lttng_ht_iter iter;
5217 struct lttng_ht_node_str *ua_chan_node;
5218 struct ust_app *app;
5219 struct ust_app_session *ua_sess;
5220 struct ust_app_channel *ua_chan;
5221 struct ust_app_event *ua_event;
5222
5223 DBG("UST app enabling event %s for PID %d", uevent->attr.name, pid);
5224
5225 rcu_read_lock();
5226
5227 app = ust_app_find_by_pid(pid);
5228 if (app == NULL) {
5229 ERR("UST app enable event per PID %d not found", pid);
5230 ret = -1;
5231 goto end;
5232 }
5233
5234 if (!app->compatible) {
5235 ret = 0;
5236 goto end;
5237 }
5238
5239 ua_sess = lookup_session_by_app(usess, app);
5240 if (!ua_sess) {
5241 /* The application has problem or is probably dead. */
5242 ret = 0;
5243 goto end;
5244 }
5245
5246 pthread_mutex_lock(&ua_sess->lock);
5247
5248 if (ua_sess->deleted) {
5249 ret = 0;
5250 goto end_unlock;
5251 }
5252
5253 /* Lookup channel in the ust app session */
5254 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &iter);
5255 ua_chan_node = lttng_ht_iter_get_node_str(&iter);
5256 /* If the channel is not found, there is a code flow error */
5257 assert(ua_chan_node);
5258
5259 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
5260
5261 ua_event = find_ust_app_event(ua_chan->events, uevent->attr.name,
5262 uevent->filter, uevent->attr.loglevel, uevent->exclusion);
5263 if (ua_event == NULL) {
5264 ret = create_ust_app_event(ua_sess, ua_chan, uevent, app);
5265 if (ret < 0) {
5266 goto end_unlock;
5267 }
5268 } else {
5269 ret = enable_ust_app_event(ua_sess, ua_event, app);
5270 if (ret < 0) {
5271 goto end_unlock;
5272 }
5273 }
5274
5275 end_unlock:
5276 pthread_mutex_unlock(&ua_sess->lock);
5277 end:
5278 rcu_read_unlock();
5279 return ret;
5280 }
5281
5282 /*
5283 * Receive registration and populate the given msg structure.
5284 *
5285 * On success return 0 else a negative value returned by the ustctl call.
5286 */
5287 int ust_app_recv_registration(int sock, struct ust_register_msg *msg)
5288 {
5289 int ret;
5290 uint32_t pid, ppid, uid, gid;
5291
5292 assert(msg);
5293
5294 ret = ustctl_recv_reg_msg(sock, &msg->type, &msg->major, &msg->minor,
5295 &pid, &ppid, &uid, &gid,
5296 &msg->bits_per_long,
5297 &msg->uint8_t_alignment,
5298 &msg->uint16_t_alignment,
5299 &msg->uint32_t_alignment,
5300 &msg->uint64_t_alignment,
5301 &msg->long_alignment,
5302 &msg->byte_order,
5303 msg->name);
5304 if (ret < 0) {
5305 switch (-ret) {
5306 case EPIPE:
5307 case ECONNRESET:
5308 case LTTNG_UST_ERR_EXITING:
5309 DBG3("UST app recv reg message failed. Application died");
5310 break;
5311 case LTTNG_UST_ERR_UNSUP_MAJOR:
5312 ERR("UST app recv reg unsupported version %d.%d. Supporting %d.%d",
5313 msg->major, msg->minor, LTTNG_UST_ABI_MAJOR_VERSION,
5314 LTTNG_UST_ABI_MINOR_VERSION);
5315 break;
5316 default:
5317 ERR("UST app recv reg message failed with ret %d", ret);
5318 break;
5319 }
5320 goto error;
5321 }
5322 msg->pid = (pid_t) pid;
5323 msg->ppid = (pid_t) ppid;
5324 msg->uid = (uid_t) uid;
5325 msg->gid = (gid_t) gid;
5326
5327 error:
5328 return ret;
5329 }
5330
5331 /*
5332 * Return a ust app session object using the application object and the
5333 * session object descriptor has a key. If not found, NULL is returned.
5334 * A RCU read side lock MUST be acquired when calling this function.
5335 */
5336 static struct ust_app_session *find_session_by_objd(struct ust_app *app,
5337 int objd)
5338 {
5339 struct lttng_ht_node_ulong *node;
5340 struct lttng_ht_iter iter;
5341 struct ust_app_session *ua_sess = NULL;
5342
5343 assert(app);
5344
5345 lttng_ht_lookup(app->ust_sessions_objd, (void *)((unsigned long) objd), &iter);
5346 node = lttng_ht_iter_get_node_ulong(&iter);
5347 if (node == NULL) {
5348 DBG2("UST app session find by objd %d not found", objd);
5349 goto error;
5350 }
5351
5352 ua_sess = caa_container_of(node, struct ust_app_session, ust_objd_node);
5353
5354 error:
5355 return ua_sess;
5356 }
5357
5358 /*
5359 * Return a ust app channel object using the application object and the channel
5360 * object descriptor has a key. If not found, NULL is returned. A RCU read side
5361 * lock MUST be acquired before calling this function.
5362 */
5363 static struct ust_app_channel *find_channel_by_objd(struct ust_app *app,
5364 int objd)
5365 {
5366 struct lttng_ht_node_ulong *node;
5367 struct lttng_ht_iter iter;
5368 struct ust_app_channel *ua_chan = NULL;
5369
5370 assert(app);
5371
5372 lttng_ht_lookup(app->ust_objd, (void *)((unsigned long) objd), &iter);
5373 node = lttng_ht_iter_get_node_ulong(&iter);
5374 if (node == NULL) {
5375 DBG2("UST app channel find by objd %d not found", objd);
5376 goto error;
5377 }
5378
5379 ua_chan = caa_container_of(node, struct ust_app_channel, ust_objd_node);
5380
5381 error:
5382 return ua_chan;
5383 }
5384
5385 /*
5386 * Reply to a register channel notification from an application on the notify
5387 * socket. The channel metadata is also created.
5388 *
5389 * The session UST registry lock is acquired in this function.
5390 *
5391 * On success 0 is returned else a negative value.
5392 */
5393 static int reply_ust_register_channel(int sock, int sobjd, int cobjd,
5394 size_t nr_fields, struct ustctl_field *fields)
5395 {
5396 int ret, ret_code = 0;
5397 uint32_t chan_id, reg_count;
5398 uint64_t chan_reg_key;
5399 enum ustctl_channel_header type;
5400 struct ust_app *app;
5401 struct ust_app_channel *ua_chan;
5402 struct ust_app_session *ua_sess;
5403 struct ust_registry_session *registry;
5404 struct ust_registry_channel *chan_reg;
5405
5406 rcu_read_lock();
5407
5408 /* Lookup application. If not found, there is a code flow error. */
5409 app = find_app_by_notify_sock(sock);
5410 if (!app) {
5411 DBG("Application socket %d is being torn down. Abort event notify",
5412 sock);
5413 ret = 0;
5414 goto error_rcu_unlock;
5415 }
5416
5417 /* Lookup channel by UST object descriptor. */
5418 ua_chan = find_channel_by_objd(app, cobjd);
5419 if (!ua_chan) {
5420 DBG("Application channel is being torn down. Abort event notify");
5421 ret = 0;
5422 goto error_rcu_unlock;
5423 }
5424
5425 assert(ua_chan->session);
5426 ua_sess = ua_chan->session;
5427
5428 /* Get right session registry depending on the session buffer type. */
5429 registry = get_session_registry(ua_sess);
5430 if (!registry) {
5431 DBG("Application session is being torn down. Abort event notify");
5432 ret = 0;
5433 goto error_rcu_unlock;
5434 };
5435
5436 /* Depending on the buffer type, a different channel key is used. */
5437 if (ua_sess->buffer_type == LTTNG_BUFFER_PER_UID) {
5438 chan_reg_key = ua_chan->tracing_channel_id;
5439 } else {
5440 chan_reg_key = ua_chan->key;
5441 }
5442
5443 pthread_mutex_lock(&registry->lock);
5444
5445 chan_reg = ust_registry_channel_find(registry, chan_reg_key);
5446 assert(chan_reg);
5447
5448 if (!chan_reg->register_done) {
5449 reg_count = ust_registry_get_event_count(chan_reg);
5450 if (reg_count < 31) {
5451 type = USTCTL_CHANNEL_HEADER_COMPACT;
5452 } else {
5453 type = USTCTL_CHANNEL_HEADER_LARGE;
5454 }
5455
5456 chan_reg->nr_ctx_fields = nr_fields;
5457 chan_reg->ctx_fields = fields;
5458 fields = NULL;
5459 chan_reg->header_type = type;
5460 } else {
5461 /* Get current already assigned values. */
5462 type = chan_reg->header_type;
5463 }
5464 /* Channel id is set during the object creation. */
5465 chan_id = chan_reg->chan_id;
5466
5467 /* Append to metadata */
5468 if (!chan_reg->metadata_dumped) {
5469 ret_code = ust_metadata_channel_statedump(registry, chan_reg);
5470 if (ret_code) {
5471 ERR("Error appending channel metadata (errno = %d)", ret_code);
5472 goto reply;
5473 }
5474 }
5475
5476 reply:
5477 DBG3("UST app replying to register channel key %" PRIu64
5478 " with id %u, type: %d, ret: %d", chan_reg_key, chan_id, type,
5479 ret_code);
5480
5481 ret = ustctl_reply_register_channel(sock, chan_id, type, ret_code);
5482 if (ret < 0) {
5483 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
5484 ERR("UST app reply channel failed with ret %d", ret);
5485 } else {
5486 DBG3("UST app reply channel failed. Application died");
5487 }
5488 goto error;
5489 }
5490
5491 /* This channel registry registration is completed. */
5492 chan_reg->register_done = 1;
5493
5494 error:
5495 pthread_mutex_unlock(&registry->lock);
5496 error_rcu_unlock:
5497 rcu_read_unlock();
5498 free(fields);
5499 return ret;
5500 }
5501
5502 /*
5503 * Add event to the UST channel registry. When the event is added to the
5504 * registry, the metadata is also created. Once done, this replies to the
5505 * application with the appropriate error code.
5506 *
5507 * The session UST registry lock is acquired in the function.
5508 *
5509 * On success 0 is returned else a negative value.
5510 */
5511 static int add_event_ust_registry(int sock, int sobjd, int cobjd, char *name,
5512 char *sig, size_t nr_fields, struct ustctl_field *fields,
5513 int loglevel_value, char *model_emf_uri)
5514 {
5515 int ret, ret_code;
5516 uint32_t event_id = 0;
5517 uint64_t chan_reg_key;
5518 struct ust_app *app;
5519 struct ust_app_channel *ua_chan;
5520 struct ust_app_session *ua_sess;
5521 struct ust_registry_session *registry;
5522
5523 rcu_read_lock();
5524
5525 /* Lookup application. If not found, there is a code flow error. */
5526 app = find_app_by_notify_sock(sock);
5527 if (!app) {
5528 DBG("Application socket %d is being torn down. Abort event notify",
5529 sock);
5530 ret = 0;
5531 goto error_rcu_unlock;
5532 }
5533
5534 /* Lookup channel by UST object descriptor. */
5535 ua_chan = find_channel_by_objd(app, cobjd);
5536 if (!ua_chan) {
5537 DBG("Application channel is being torn down. Abort event notify");
5538 ret = 0;
5539 goto error_rcu_unlock;
5540 }
5541
5542 assert(ua_chan->session);
5543 ua_sess = ua_chan->session;
5544
5545 registry = get_session_registry(ua_sess);
5546 if (!registry) {
5547 DBG("Application session is being torn down. Abort event notify");
5548 ret = 0;
5549 goto error_rcu_unlock;
5550 }
5551
5552 if (ua_sess->buffer_type == LTTNG_BUFFER_PER_UID) {
5553 chan_reg_key = ua_chan->tracing_channel_id;
5554 } else {
5555 chan_reg_key = ua_chan->key;
5556 }
5557
5558 pthread_mutex_lock(&registry->lock);
5559
5560 /*
5561 * From this point on, this call acquires the ownership of the sig, fields
5562 * and model_emf_uri meaning any free are done inside it if needed. These
5563 * three variables MUST NOT be read/write after this.
5564 */
5565 ret_code = ust_registry_create_event(registry, chan_reg_key,
5566 sobjd, cobjd, name, sig, nr_fields, fields,
5567 loglevel_value, model_emf_uri, ua_sess->buffer_type,
5568 &event_id, app);
5569 sig = NULL;
5570 fields = NULL;
5571 model_emf_uri = NULL;
5572
5573 /*
5574 * The return value is returned to ustctl so in case of an error, the
5575 * application can be notified. In case of an error, it's important not to
5576 * return a negative error or else the application will get closed.
5577 */
5578 ret = ustctl_reply_register_event(sock, event_id, ret_code);
5579 if (ret < 0) {
5580 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
5581 ERR("UST app reply event failed with ret %d", ret);
5582 } else {
5583 DBG3("UST app reply event failed. Application died");
5584 }
5585 /*
5586 * No need to wipe the create event since the application socket will
5587 * get close on error hence cleaning up everything by itself.
5588 */
5589 goto error;
5590 }
5591
5592 DBG3("UST registry event %s with id %" PRId32 " added successfully",
5593 name, event_id);
5594
5595 error:
5596 pthread_mutex_unlock(&registry->lock);
5597 error_rcu_unlock:
5598 rcu_read_unlock();
5599 free(sig);
5600 free(fields);
5601 free(model_emf_uri);
5602 return ret;
5603 }
5604
5605 /*
5606 * Add enum to the UST session registry. Once done, this replies to the
5607 * application with the appropriate error code.
5608 *
5609 * The session UST registry lock is acquired within this function.
5610 *
5611 * On success 0 is returned else a negative value.
5612 */
5613 static int add_enum_ust_registry(int sock, int sobjd, char *name,
5614 struct ustctl_enum_entry *entries, size_t nr_entries)
5615 {
5616 int ret = 0, ret_code;
5617 struct ust_app *app;
5618 struct ust_app_session *ua_sess;
5619 struct ust_registry_session *registry;
5620 uint64_t enum_id = -1ULL;
5621
5622 rcu_read_lock();
5623
5624 /* Lookup application. If not found, there is a code flow error. */
5625 app = find_app_by_notify_sock(sock);
5626 if (!app) {
5627 /* Return an error since this is not an error */
5628 DBG("Application socket %d is being torn down. Aborting enum registration",
5629 sock);
5630 free(entries);
5631 goto error_rcu_unlock;
5632 }
5633
5634 /* Lookup session by UST object descriptor. */
5635 ua_sess = find_session_by_objd(app, sobjd);
5636 if (!ua_sess) {
5637 /* Return an error since this is not an error */
5638 DBG("Application session is being torn down (session not found). Aborting enum registration.");
5639 free(entries);
5640 goto error_rcu_unlock;
5641 }
5642
5643 registry = get_session_registry(ua_sess);
5644 if (!registry) {
5645 DBG("Application session is being torn down (registry not found). Aborting enum registration.");
5646 free(entries);
5647 goto error_rcu_unlock;
5648 }
5649
5650 pthread_mutex_lock(&registry->lock);
5651
5652 /*
5653 * From this point on, the callee acquires the ownership of
5654 * entries. The variable entries MUST NOT be read/written after
5655 * call.
5656 */
5657 ret_code = ust_registry_create_or_find_enum(registry, sobjd, name,
5658 entries, nr_entries, &enum_id);
5659 entries = NULL;
5660
5661 /*
5662 * The return value is returned to ustctl so in case of an error, the
5663 * application can be notified. In case of an error, it's important not to
5664 * return a negative error or else the application will get closed.
5665 */
5666 ret = ustctl_reply_register_enum(sock, enum_id, ret_code);
5667 if (ret < 0) {
5668 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
5669 ERR("UST app reply enum failed with ret %d", ret);
5670 } else {
5671 DBG3("UST app reply enum failed. Application died");
5672 }
5673 /*
5674 * No need to wipe the create enum since the application socket will
5675 * get close on error hence cleaning up everything by itself.
5676 */
5677 goto error;
5678 }
5679
5680 DBG3("UST registry enum %s added successfully or already found", name);
5681
5682 error:
5683 pthread_mutex_unlock(&registry->lock);
5684 error_rcu_unlock:
5685 rcu_read_unlock();
5686 return ret;
5687 }
5688
5689 /*
5690 * Handle application notification through the given notify socket.
5691 *
5692 * Return 0 on success or else a negative value.
5693 */
5694 int ust_app_recv_notify(int sock)
5695 {
5696 int ret;
5697 enum ustctl_notify_cmd cmd;
5698
5699 DBG3("UST app receiving notify from sock %d", sock);
5700
5701 ret = ustctl_recv_notify(sock, &cmd);
5702 if (ret < 0) {
5703 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
5704 ERR("UST app recv notify failed with ret %d", ret);
5705 } else {
5706 DBG3("UST app recv notify failed. Application died");
5707 }
5708 goto error;
5709 }
5710
5711 switch (cmd) {
5712 case USTCTL_NOTIFY_CMD_EVENT:
5713 {
5714 int sobjd, cobjd, loglevel_value;
5715 char name[LTTNG_UST_SYM_NAME_LEN], *sig, *model_emf_uri;
5716 size_t nr_fields;
5717 struct ustctl_field *fields;
5718
5719 DBG2("UST app ustctl register event received");
5720
5721 ret = ustctl_recv_register_event(sock, &sobjd, &cobjd, name,
5722 &loglevel_value, &sig, &nr_fields, &fields,
5723 &model_emf_uri);
5724 if (ret < 0) {
5725 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
5726 ERR("UST app recv event failed with ret %d", ret);
5727 } else {
5728 DBG3("UST app recv event failed. Application died");
5729 }
5730 goto error;
5731 }
5732
5733 /*
5734 * Add event to the UST registry coming from the notify socket. This
5735 * call will free if needed the sig, fields and model_emf_uri. This
5736 * code path loses the ownsership of these variables and transfer them
5737 * to the this function.
5738 */
5739 ret = add_event_ust_registry(sock, sobjd, cobjd, name, sig, nr_fields,
5740 fields, loglevel_value, model_emf_uri);
5741 if (ret < 0) {
5742 goto error;
5743 }
5744
5745 break;
5746 }
5747 case USTCTL_NOTIFY_CMD_CHANNEL:
5748 {
5749 int sobjd, cobjd;
5750 size_t nr_fields;
5751 struct ustctl_field *fields;
5752
5753 DBG2("UST app ustctl register channel received");
5754
5755 ret = ustctl_recv_register_channel(sock, &sobjd, &cobjd, &nr_fields,
5756 &fields);
5757 if (ret < 0) {
5758 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
5759 ERR("UST app recv channel failed with ret %d", ret);
5760 } else {
5761 DBG3("UST app recv channel failed. Application died");
5762 }
5763 goto error;
5764 }
5765
5766 /*
5767 * The fields ownership are transfered to this function call meaning
5768 * that if needed it will be freed. After this, it's invalid to access
5769 * fields or clean it up.
5770 */
5771 ret = reply_ust_register_channel(sock, sobjd, cobjd, nr_fields,
5772 fields);
5773 if (ret < 0) {
5774 goto error;
5775 }
5776
5777 break;
5778 }
5779 case USTCTL_NOTIFY_CMD_ENUM:
5780 {
5781 int sobjd;
5782 char name[LTTNG_UST_SYM_NAME_LEN];
5783 size_t nr_entries;
5784 struct ustctl_enum_entry *entries;
5785
5786 DBG2("UST app ustctl register enum received");
5787
5788 ret = ustctl_recv_register_enum(sock, &sobjd, name,
5789 &entries, &nr_entries);
5790 if (ret < 0) {
5791 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
5792 ERR("UST app recv enum failed with ret %d", ret);
5793 } else {
5794 DBG3("UST app recv enum failed. Application died");
5795 }
5796 goto error;
5797 }
5798
5799 /* Callee assumes ownership of entries */
5800 ret = add_enum_ust_registry(sock, sobjd, name,
5801 entries, nr_entries);
5802 if (ret < 0) {
5803 goto error;
5804 }
5805
5806 break;
5807 }
5808 default:
5809 /* Should NEVER happen. */
5810 assert(0);
5811 }
5812
5813 error:
5814 return ret;
5815 }
5816
5817 /*
5818 * Once the notify socket hangs up, this is called. First, it tries to find the
5819 * corresponding application. On failure, the call_rcu to close the socket is
5820 * executed. If an application is found, it tries to delete it from the notify
5821 * socket hash table. Whathever the result, it proceeds to the call_rcu.
5822 *
5823 * Note that an object needs to be allocated here so on ENOMEM failure, the
5824 * call RCU is not done but the rest of the cleanup is.
5825 */
5826 void ust_app_notify_sock_unregister(int sock)
5827 {
5828 int err_enomem = 0;
5829 struct lttng_ht_iter iter;
5830 struct ust_app *app;
5831 struct ust_app_notify_sock_obj *obj;
5832
5833 assert(sock >= 0);
5834
5835 rcu_read_lock();
5836
5837 obj = zmalloc(sizeof(*obj));
5838 if (!obj) {
5839 /*
5840 * An ENOMEM is kind of uncool. If this strikes we continue the
5841 * procedure but the call_rcu will not be called. In this case, we
5842 * accept the fd leak rather than possibly creating an unsynchronized
5843 * state between threads.
5844 *
5845 * TODO: The notify object should be created once the notify socket is
5846 * registered and stored independantely from the ust app object. The
5847 * tricky part is to synchronize the teardown of the application and
5848 * this notify object. Let's keep that in mind so we can avoid this
5849 * kind of shenanigans with ENOMEM in the teardown path.
5850 */
5851 err_enomem = 1;
5852 } else {
5853 obj->fd = sock;
5854 }
5855
5856 DBG("UST app notify socket unregister %d", sock);
5857
5858 /*
5859 * Lookup application by notify socket. If this fails, this means that the
5860 * hash table delete has already been done by the application
5861 * unregistration process so we can safely close the notify socket in a
5862 * call RCU.
5863 */
5864 app = find_app_by_notify_sock(sock);
5865 if (!app) {
5866 goto close_socket;
5867 }
5868
5869 iter.iter.node = &app->notify_sock_n.node;
5870
5871 /*
5872 * Whatever happens here either we fail or succeed, in both cases we have
5873 * to close the socket after a grace period to continue to the call RCU
5874 * here. If the deletion is successful, the application is not visible
5875 * anymore by other threads and is it fails it means that it was already
5876 * deleted from the hash table so either way we just have to close the
5877 * socket.
5878 */
5879 (void) lttng_ht_del(ust_app_ht_by_notify_sock, &iter);
5880
5881 close_socket:
5882 rcu_read_unlock();
5883
5884 /*
5885 * Close socket after a grace period to avoid for the socket to be reused
5886 * before the application object is freed creating potential race between
5887 * threads trying to add unique in the global hash table.
5888 */
5889 if (!err_enomem) {
5890 call_rcu(&obj->head, close_notify_sock_rcu);
5891 }
5892 }
5893
5894 /*
5895 * Destroy a ust app data structure and free its memory.
5896 */
5897 void ust_app_destroy(struct ust_app *app)
5898 {
5899 if (!app) {
5900 return;
5901 }
5902
5903 call_rcu(&app->pid_n.head, delete_ust_app_rcu);
5904 }
5905
5906 /*
5907 * Take a snapshot for a given UST session. The snapshot is sent to the given
5908 * output.
5909 *
5910 * Return 0 on success or else a negative value.
5911 */
5912 int ust_app_snapshot_record(struct ltt_ust_session *usess,
5913 struct snapshot_output *output, int wait,
5914 uint64_t nb_packets_per_stream)
5915 {
5916 int ret = 0;
5917 struct lttng_ht_iter iter;
5918 struct ust_app *app;
5919 char pathname[PATH_MAX];
5920
5921 assert(usess);
5922 assert(output);
5923
5924 rcu_read_lock();
5925
5926 switch (usess->buffer_type) {
5927 case LTTNG_BUFFER_PER_UID:
5928 {
5929 struct buffer_reg_uid *reg;
5930
5931 cds_list_for_each_entry(reg, &usess->buffer_reg_uid_list, lnode) {
5932 struct buffer_reg_channel *reg_chan;
5933 struct consumer_socket *socket;
5934
5935 /* Get consumer socket to use to push the metadata.*/
5936 socket = consumer_find_socket_by_bitness(reg->bits_per_long,
5937 usess->consumer);
5938 if (!socket) {
5939 ret = -EINVAL;
5940 goto error;
5941 }
5942
5943 memset(pathname, 0, sizeof(pathname));
5944 ret = snprintf(pathname, sizeof(pathname),
5945 DEFAULT_UST_TRACE_DIR "/" DEFAULT_UST_TRACE_UID_PATH,
5946 reg->uid, reg->bits_per_long);
5947 if (ret < 0) {
5948 PERROR("snprintf snapshot path");
5949 goto error;
5950 }
5951
5952 /* Add the UST default trace dir to path. */
5953 cds_lfht_for_each_entry(reg->registry->channels->ht, &iter.iter,
5954 reg_chan, node.node) {
5955 ret = consumer_snapshot_channel(socket, reg_chan->consumer_key,
5956 output, 0, usess->uid, usess->gid, pathname, wait,
5957 nb_packets_per_stream);
5958 if (ret < 0) {
5959 goto error;
5960 }
5961 }
5962 ret = consumer_snapshot_channel(socket,
5963 reg->registry->reg.ust->metadata_key, output, 1,
5964 usess->uid, usess->gid, pathname, wait, 0);
5965 if (ret < 0) {
5966 goto error;
5967 }
5968 }
5969 break;
5970 }
5971 case LTTNG_BUFFER_PER_PID:
5972 {
5973 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
5974 struct consumer_socket *socket;
5975 struct lttng_ht_iter chan_iter;
5976 struct ust_app_channel *ua_chan;
5977 struct ust_app_session *ua_sess;
5978 struct ust_registry_session *registry;
5979
5980 ua_sess = lookup_session_by_app(usess, app);
5981 if (!ua_sess) {
5982 /* Session not associated with this app. */
5983 continue;
5984 }
5985
5986 /* Get the right consumer socket for the application. */
5987 socket = consumer_find_socket_by_bitness(app->bits_per_long,
5988 output->consumer);
5989 if (!socket) {
5990 ret = -EINVAL;
5991 goto error;
5992 }
5993
5994 /* Add the UST default trace dir to path. */
5995 memset(pathname, 0, sizeof(pathname));
5996 ret = snprintf(pathname, sizeof(pathname), DEFAULT_UST_TRACE_DIR "/%s",
5997 ua_sess->path);
5998 if (ret < 0) {
5999 PERROR("snprintf snapshot path");
6000 goto error;
6001 }
6002
6003 cds_lfht_for_each_entry(ua_sess->channels->ht, &chan_iter.iter,
6004 ua_chan, node.node) {
6005 ret = consumer_snapshot_channel(socket, ua_chan->key, output,
6006 0, ua_sess->euid, ua_sess->egid, pathname, wait,
6007 nb_packets_per_stream);
6008 if (ret < 0) {
6009 goto error;
6010 }
6011 }
6012
6013 registry = get_session_registry(ua_sess);
6014 if (!registry) {
6015 DBG("Application session is being torn down. Abort snapshot record.");
6016 ret = -1;
6017 goto error;
6018 }
6019 ret = consumer_snapshot_channel(socket, registry->metadata_key, output,
6020 1, ua_sess->euid, ua_sess->egid, pathname, wait, 0);
6021 if (ret < 0) {
6022 goto error;
6023 }
6024 }
6025 break;
6026 }
6027 default:
6028 assert(0);
6029 break;
6030 }
6031
6032 error:
6033 rcu_read_unlock();
6034 return ret;
6035 }
6036
6037 /*
6038 * Return the size taken by one more packet per stream.
6039 */
6040 uint64_t ust_app_get_size_one_more_packet_per_stream(struct ltt_ust_session *usess,
6041 uint64_t cur_nr_packets)
6042 {
6043 uint64_t tot_size = 0;
6044 struct ust_app *app;
6045 struct lttng_ht_iter iter;
6046
6047 assert(usess);
6048
6049 switch (usess->buffer_type) {
6050 case LTTNG_BUFFER_PER_UID:
6051 {
6052 struct buffer_reg_uid *reg;
6053
6054 cds_list_for_each_entry(reg, &usess->buffer_reg_uid_list, lnode) {
6055 struct buffer_reg_channel *reg_chan;
6056
6057 rcu_read_lock();
6058 cds_lfht_for_each_entry(reg->registry->channels->ht, &iter.iter,
6059 reg_chan, node.node) {
6060 if (cur_nr_packets >= reg_chan->num_subbuf) {
6061 /*
6062 * Don't take channel into account if we
6063 * already grab all its packets.
6064 */
6065 continue;
6066 }
6067 tot_size += reg_chan->subbuf_size * reg_chan->stream_count;
6068 }
6069 rcu_read_unlock();
6070 }
6071 break;
6072 }
6073 case LTTNG_BUFFER_PER_PID:
6074 {
6075 rcu_read_lock();
6076 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
6077 struct ust_app_channel *ua_chan;
6078 struct ust_app_session *ua_sess;
6079 struct lttng_ht_iter chan_iter;
6080
6081 ua_sess = lookup_session_by_app(usess, app);
6082 if (!ua_sess) {
6083 /* Session not associated with this app. */
6084 continue;
6085 }
6086
6087 cds_lfht_for_each_entry(ua_sess->channels->ht, &chan_iter.iter,
6088 ua_chan, node.node) {
6089 if (cur_nr_packets >= ua_chan->attr.num_subbuf) {
6090 /*
6091 * Don't take channel into account if we
6092 * already grab all its packets.
6093 */
6094 continue;
6095 }
6096 tot_size += ua_chan->attr.subbuf_size * ua_chan->streams.count;
6097 }
6098 }
6099 rcu_read_unlock();
6100 break;
6101 }
6102 default:
6103 assert(0);
6104 break;
6105 }
6106
6107 return tot_size;
6108 }
6109
6110 int ust_app_uid_get_channel_runtime_stats(uint64_t ust_session_id,
6111 struct cds_list_head *buffer_reg_uid_list,
6112 struct consumer_output *consumer, uint64_t uchan_id,
6113 int overwrite, uint64_t *discarded, uint64_t *lost)
6114 {
6115 int ret;
6116 uint64_t consumer_chan_key;
6117
6118 *discarded = 0;
6119 *lost = 0;
6120
6121 ret = buffer_reg_uid_consumer_channel_key(
6122 buffer_reg_uid_list, ust_session_id,
6123 uchan_id, &consumer_chan_key);
6124 if (ret < 0) {
6125 /* Not found */
6126 ret = 0;
6127 goto end;
6128 }
6129
6130 if (overwrite) {
6131 ret = consumer_get_lost_packets(ust_session_id,
6132 consumer_chan_key, consumer, lost);
6133 } else {
6134 ret = consumer_get_discarded_events(ust_session_id,
6135 consumer_chan_key, consumer, discarded);
6136 }
6137
6138 end:
6139 return ret;
6140 }
6141
6142 int ust_app_pid_get_channel_runtime_stats(struct ltt_ust_session *usess,
6143 struct ltt_ust_channel *uchan,
6144 struct consumer_output *consumer, int overwrite,
6145 uint64_t *discarded, uint64_t *lost)
6146 {
6147 int ret = 0;
6148 struct lttng_ht_iter iter;
6149 struct lttng_ht_node_str *ua_chan_node;
6150 struct ust_app *app;
6151 struct ust_app_session *ua_sess;
6152 struct ust_app_channel *ua_chan;
6153
6154 *discarded = 0;
6155 *lost = 0;
6156
6157 rcu_read_lock();
6158 /*
6159 * Iterate over every registered applications. Sum counters for
6160 * all applications containing requested session and channel.
6161 */
6162 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
6163 struct lttng_ht_iter uiter;
6164
6165 ua_sess = lookup_session_by_app(usess, app);
6166 if (ua_sess == NULL) {
6167 continue;
6168 }
6169
6170 /* Get channel */
6171 lttng_ht_lookup(ua_sess->channels, (void *) uchan->name, &uiter);
6172 ua_chan_node = lttng_ht_iter_get_node_str(&uiter);
6173 /* If the session is found for the app, the channel must be there */
6174 assert(ua_chan_node);
6175
6176 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
6177
6178 if (overwrite) {
6179 uint64_t _lost;
6180
6181 ret = consumer_get_lost_packets(usess->id, ua_chan->key,
6182 consumer, &_lost);
6183 if (ret < 0) {
6184 break;
6185 }
6186 (*lost) += _lost;
6187 } else {
6188 uint64_t _discarded;
6189
6190 ret = consumer_get_discarded_events(usess->id,
6191 ua_chan->key, consumer, &_discarded);
6192 if (ret < 0) {
6193 break;
6194 }
6195 (*discarded) += _discarded;
6196 }
6197 }
6198
6199 rcu_read_unlock();
6200 return ret;
6201 }
6202
6203 static
6204 int ust_app_regenerate_statedump(struct ltt_ust_session *usess,
6205 struct ust_app *app)
6206 {
6207 int ret = 0;
6208 struct ust_app_session *ua_sess;
6209
6210 DBG("Regenerating the metadata for ust app pid %d", app->pid);
6211
6212 rcu_read_lock();
6213
6214 ua_sess = lookup_session_by_app(usess, app);
6215 if (ua_sess == NULL) {
6216 /* The session is in teardown process. Ignore and continue. */
6217 goto end;
6218 }
6219
6220 pthread_mutex_lock(&ua_sess->lock);
6221
6222 if (ua_sess->deleted) {
6223 goto end_unlock;
6224 }
6225
6226 pthread_mutex_lock(&app->sock_lock);
6227 ret = ustctl_regenerate_statedump(app->sock, ua_sess->handle);
6228 pthread_mutex_unlock(&app->sock_lock);
6229
6230 end_unlock:
6231 pthread_mutex_unlock(&ua_sess->lock);
6232
6233 end:
6234 rcu_read_unlock();
6235 health_code_update();
6236 return ret;
6237 }
6238
6239 /*
6240 * Regenerate the statedump for each app in the session.
6241 */
6242 int ust_app_regenerate_statedump_all(struct ltt_ust_session *usess)
6243 {
6244 int ret = 0;
6245 struct lttng_ht_iter iter;
6246 struct ust_app *app;
6247
6248 DBG("Regenerating the metadata for all UST apps");
6249
6250 rcu_read_lock();
6251
6252 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
6253 if (!app->compatible) {
6254 continue;
6255 }
6256
6257 ret = ust_app_regenerate_statedump(usess, app);
6258 if (ret < 0) {
6259 /* Continue to the next app even on error */
6260 continue;
6261 }
6262 }
6263
6264 rcu_read_unlock();
6265
6266 return 0;
6267 }
This page took 0.181109 seconds and 4 git commands to generate.