f12262101819d08b9c5d365ee1290de3bcac373b
[lttng-tools.git] / src / bin / lttng-sessiond / ust-app.cpp
1 /*
2 * Copyright (C) 2011 EfficiOS Inc.
3 * Copyright (C) 2016 Jérémie Galarneau <jeremie.galarneau@efficios.com>
4 *
5 * SPDX-License-Identifier: GPL-2.0-only
6 *
7 */
8
9 #define _LGPL_SOURCE
10 #include <errno.h>
11 #include <fcntl.h>
12 #include <inttypes.h>
13 #include <pthread.h>
14 #include <stdio.h>
15 #include <stdlib.h>
16 #include <string.h>
17 #include <sys/mman.h>
18 #include <sys/stat.h>
19 #include <sys/types.h>
20 #include <unistd.h>
21 #include <urcu/compiler.h>
22 #include <signal.h>
23
24 #include <common/bytecode/bytecode.h>
25 #include <common/compat/errno.h>
26 #include <common/common.h>
27 #include <common/hashtable/utils.h>
28 #include <lttng/event-rule/event-rule.h>
29 #include <lttng/event-rule/event-rule-internal.h>
30 #include <lttng/event-rule/user-tracepoint.h>
31 #include <lttng/condition/condition.h>
32 #include <lttng/condition/event-rule-matches-internal.h>
33 #include <lttng/condition/event-rule-matches.h>
34 #include <lttng/trigger/trigger-internal.h>
35 #include <common/sessiond-comm/sessiond-comm.h>
36
37 #include "buffer-registry.h"
38 #include "condition-internal.h"
39 #include "fd-limit.h"
40 #include "health-sessiond.h"
41 #include "ust-app.h"
42 #include "ust-consumer.h"
43 #include "lttng-ust-ctl.h"
44 #include "lttng-ust-error.h"
45 #include "utils.h"
46 #include "session.h"
47 #include "lttng-sessiond.h"
48 #include "notification-thread-commands.h"
49 #include "rotate.h"
50 #include "event.h"
51 #include "event-notifier-error-accounting.h"
52 #include "ust-field-utils.h"
53
54 struct lttng_ht *ust_app_ht;
55 struct lttng_ht *ust_app_ht_by_sock;
56 struct lttng_ht *ust_app_ht_by_notify_sock;
57
58 static
59 int ust_app_flush_app_session(struct ust_app *app, struct ust_app_session *ua_sess);
60
61 /* Next available channel key. Access under next_channel_key_lock. */
62 static uint64_t _next_channel_key;
63 static pthread_mutex_t next_channel_key_lock = PTHREAD_MUTEX_INITIALIZER;
64
65 /* Next available session ID. Access under next_session_id_lock. */
66 static uint64_t _next_session_id;
67 static pthread_mutex_t next_session_id_lock = PTHREAD_MUTEX_INITIALIZER;
68
69 /*
70 * Return the incremented value of next_channel_key.
71 */
72 static uint64_t get_next_channel_key(void)
73 {
74 uint64_t ret;
75
76 pthread_mutex_lock(&next_channel_key_lock);
77 ret = ++_next_channel_key;
78 pthread_mutex_unlock(&next_channel_key_lock);
79 return ret;
80 }
81
82 /*
83 * Return the atomically incremented value of next_session_id.
84 */
85 static uint64_t get_next_session_id(void)
86 {
87 uint64_t ret;
88
89 pthread_mutex_lock(&next_session_id_lock);
90 ret = ++_next_session_id;
91 pthread_mutex_unlock(&next_session_id_lock);
92 return ret;
93 }
94
95 static void copy_channel_attr_to_ustctl(
96 struct lttng_ust_ctl_consumer_channel_attr *attr,
97 struct lttng_ust_abi_channel_attr *uattr)
98 {
99 /* Copy event attributes since the layout is different. */
100 attr->subbuf_size = uattr->subbuf_size;
101 attr->num_subbuf = uattr->num_subbuf;
102 attr->overwrite = uattr->overwrite;
103 attr->switch_timer_interval = uattr->switch_timer_interval;
104 attr->read_timer_interval = uattr->read_timer_interval;
105 attr->output = (lttng_ust_abi_output) uattr->output;
106 attr->blocking_timeout = uattr->u.s.blocking_timeout;
107 }
108
109 /*
110 * Match function for the hash table lookup.
111 *
112 * It matches an ust app event based on three attributes which are the event
113 * name, the filter bytecode and the loglevel.
114 */
115 static int ht_match_ust_app_event(struct cds_lfht_node *node, const void *_key)
116 {
117 struct ust_app_event *event;
118 const struct ust_app_ht_key *key;
119 int ev_loglevel_value;
120
121 LTTNG_ASSERT(node);
122 LTTNG_ASSERT(_key);
123
124 event = caa_container_of(node, struct ust_app_event, node.node);
125 key = (ust_app_ht_key *) _key;
126 ev_loglevel_value = event->attr.loglevel;
127
128 /* Match the 4 elements of the key: name, filter, loglevel, exclusions */
129
130 /* Event name */
131 if (strncmp(event->attr.name, key->name, sizeof(event->attr.name)) != 0) {
132 goto no_match;
133 }
134
135 /* Event loglevel. */
136 if (ev_loglevel_value != key->loglevel_type) {
137 if (event->attr.loglevel_type == LTTNG_UST_ABI_LOGLEVEL_ALL
138 && key->loglevel_type == 0 &&
139 ev_loglevel_value == -1) {
140 /*
141 * Match is accepted. This is because on event creation, the
142 * loglevel is set to -1 if the event loglevel type is ALL so 0 and
143 * -1 are accepted for this loglevel type since 0 is the one set by
144 * the API when receiving an enable event.
145 */
146 } else {
147 goto no_match;
148 }
149 }
150
151 /* One of the filters is NULL, fail. */
152 if ((key->filter && !event->filter) || (!key->filter && event->filter)) {
153 goto no_match;
154 }
155
156 if (key->filter && event->filter) {
157 /* Both filters exists, check length followed by the bytecode. */
158 if (event->filter->len != key->filter->len ||
159 memcmp(event->filter->data, key->filter->data,
160 event->filter->len) != 0) {
161 goto no_match;
162 }
163 }
164
165 /* One of the exclusions is NULL, fail. */
166 if ((key->exclusion && !event->exclusion) || (!key->exclusion && event->exclusion)) {
167 goto no_match;
168 }
169
170 if (key->exclusion && event->exclusion) {
171 /* Both exclusions exists, check count followed by the names. */
172 if (event->exclusion->count != key->exclusion->count ||
173 memcmp(event->exclusion->names, key->exclusion->names,
174 event->exclusion->count * LTTNG_UST_ABI_SYM_NAME_LEN) != 0) {
175 goto no_match;
176 }
177 }
178
179
180 /* Match. */
181 return 1;
182
183 no_match:
184 return 0;
185 }
186
187 /*
188 * Unique add of an ust app event in the given ht. This uses the custom
189 * ht_match_ust_app_event match function and the event name as hash.
190 */
191 static void add_unique_ust_app_event(struct ust_app_channel *ua_chan,
192 struct ust_app_event *event)
193 {
194 struct cds_lfht_node *node_ptr;
195 struct ust_app_ht_key key;
196 struct lttng_ht *ht;
197
198 LTTNG_ASSERT(ua_chan);
199 LTTNG_ASSERT(ua_chan->events);
200 LTTNG_ASSERT(event);
201
202 ht = ua_chan->events;
203 key.name = event->attr.name;
204 key.filter = event->filter;
205 key.loglevel_type = (lttng_ust_abi_loglevel_type) event->attr.loglevel;
206 key.exclusion = event->exclusion;
207
208 node_ptr = cds_lfht_add_unique(ht->ht,
209 ht->hash_fct(event->node.key, lttng_ht_seed),
210 ht_match_ust_app_event, &key, &event->node.node);
211 LTTNG_ASSERT(node_ptr == &event->node.node);
212 }
213
214 /*
215 * Close the notify socket from the given RCU head object. This MUST be called
216 * through a call_rcu().
217 */
218 static void close_notify_sock_rcu(struct rcu_head *head)
219 {
220 int ret;
221 struct ust_app_notify_sock_obj *obj =
222 caa_container_of(head, struct ust_app_notify_sock_obj, head);
223
224 /* Must have a valid fd here. */
225 LTTNG_ASSERT(obj->fd >= 0);
226
227 ret = close(obj->fd);
228 if (ret) {
229 ERR("close notify sock %d RCU", obj->fd);
230 }
231 lttng_fd_put(LTTNG_FD_APPS, 1);
232
233 free(obj);
234 }
235
236 /*
237 * Return the session registry according to the buffer type of the given
238 * session.
239 *
240 * A registry per UID object MUST exists before calling this function or else
241 * it LTTNG_ASSERT() if not found. RCU read side lock must be acquired.
242 */
243 static struct ust_registry_session *get_session_registry(
244 struct ust_app_session *ua_sess)
245 {
246 struct ust_registry_session *registry = NULL;
247
248 LTTNG_ASSERT(ua_sess);
249
250 switch (ua_sess->buffer_type) {
251 case LTTNG_BUFFER_PER_PID:
252 {
253 struct buffer_reg_pid *reg_pid = buffer_reg_pid_find(ua_sess->id);
254 if (!reg_pid) {
255 goto error;
256 }
257 registry = reg_pid->registry->reg.ust;
258 break;
259 }
260 case LTTNG_BUFFER_PER_UID:
261 {
262 struct buffer_reg_uid *reg_uid = buffer_reg_uid_find(
263 ua_sess->tracing_id, ua_sess->bits_per_long,
264 lttng_credentials_get_uid(&ua_sess->real_credentials));
265 if (!reg_uid) {
266 goto error;
267 }
268 registry = reg_uid->registry->reg.ust;
269 break;
270 }
271 default:
272 abort();
273 };
274
275 error:
276 return registry;
277 }
278
279 /*
280 * Delete ust context safely. RCU read lock must be held before calling
281 * this function.
282 */
283 static
284 void delete_ust_app_ctx(int sock, struct ust_app_ctx *ua_ctx,
285 struct ust_app *app)
286 {
287 int ret;
288
289 LTTNG_ASSERT(ua_ctx);
290
291 if (ua_ctx->obj) {
292 pthread_mutex_lock(&app->sock_lock);
293 ret = lttng_ust_ctl_release_object(sock, ua_ctx->obj);
294 pthread_mutex_unlock(&app->sock_lock);
295 if (ret < 0) {
296 if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
297 DBG3("UST app release ctx failed. Application is dead: pid = %d, sock = %d",
298 app->pid, app->sock);
299 } else if (ret == -EAGAIN) {
300 WARN("UST app release ctx failed. Communication time out: pid = %d, sock = %d",
301 app->pid, app->sock);
302 } else {
303 ERR("UST app release ctx obj handle %d failed with ret %d: pid = %d, sock = %d",
304 ua_ctx->obj->handle, ret,
305 app->pid, app->sock);
306 }
307 }
308 free(ua_ctx->obj);
309 }
310 free(ua_ctx);
311 }
312
313 /*
314 * Delete ust app event safely. RCU read lock must be held before calling
315 * this function.
316 */
317 static
318 void delete_ust_app_event(int sock, struct ust_app_event *ua_event,
319 struct ust_app *app)
320 {
321 int ret;
322
323 LTTNG_ASSERT(ua_event);
324
325 free(ua_event->filter);
326 if (ua_event->exclusion != NULL)
327 free(ua_event->exclusion);
328 if (ua_event->obj != NULL) {
329 pthread_mutex_lock(&app->sock_lock);
330 ret = lttng_ust_ctl_release_object(sock, ua_event->obj);
331 pthread_mutex_unlock(&app->sock_lock);
332 if (ret < 0) {
333 if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
334 DBG3("UST app release event failed. Application is dead: pid = %d, sock = %d",
335 app->pid, app->sock);
336 } else if (ret == -EAGAIN) {
337 WARN("UST app release event failed. Communication time out: pid = %d, sock = %d",
338 app->pid, app->sock);
339 } else {
340 ERR("UST app release event obj failed with ret %d: pid = %d, sock = %d",
341 ret, app->pid, app->sock);
342 }
343 }
344 free(ua_event->obj);
345 }
346 free(ua_event);
347 }
348
349 /*
350 * Delayed reclaim of a ust_app_event_notifier_rule object. This MUST be called
351 * through a call_rcu().
352 */
353 static
354 void free_ust_app_event_notifier_rule_rcu(struct rcu_head *head)
355 {
356 struct ust_app_event_notifier_rule *obj = caa_container_of(
357 head, struct ust_app_event_notifier_rule, rcu_head);
358
359 free(obj);
360 }
361
362 /*
363 * Delete ust app event notifier rule safely.
364 */
365 static void delete_ust_app_event_notifier_rule(int sock,
366 struct ust_app_event_notifier_rule *ua_event_notifier_rule,
367 struct ust_app *app)
368 {
369 int ret;
370
371 LTTNG_ASSERT(ua_event_notifier_rule);
372
373 if (ua_event_notifier_rule->exclusion != NULL) {
374 free(ua_event_notifier_rule->exclusion);
375 }
376
377 if (ua_event_notifier_rule->obj != NULL) {
378 pthread_mutex_lock(&app->sock_lock);
379 ret = lttng_ust_ctl_release_object(sock, ua_event_notifier_rule->obj);
380 pthread_mutex_unlock(&app->sock_lock);
381 if (ret < 0) {
382 if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
383 DBG3("UST app release event notifier failed. Application is dead: pid = %d, sock = %d",
384 app->pid, app->sock);
385 } else if (ret == -EAGAIN) {
386 WARN("UST app release event notifier failed. Communication time out: pid = %d, sock = %d",
387 app->pid, app->sock);
388 } else {
389 ERR("UST app release event notifier failed with ret %d: pid = %d, sock = %d",
390 ret, app->pid, app->sock);
391 }
392 }
393
394 free(ua_event_notifier_rule->obj);
395 }
396
397 lttng_trigger_put(ua_event_notifier_rule->trigger);
398 call_rcu(&ua_event_notifier_rule->rcu_head,
399 free_ust_app_event_notifier_rule_rcu);
400 }
401
402 /*
403 * Release ust data object of the given stream.
404 *
405 * Return 0 on success or else a negative value.
406 */
407 static int release_ust_app_stream(int sock, struct ust_app_stream *stream,
408 struct ust_app *app)
409 {
410 int ret = 0;
411
412 LTTNG_ASSERT(stream);
413
414 if (stream->obj) {
415 pthread_mutex_lock(&app->sock_lock);
416 ret = lttng_ust_ctl_release_object(sock, stream->obj);
417 pthread_mutex_unlock(&app->sock_lock);
418 if (ret < 0) {
419 if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
420 DBG3("UST app release stream failed. Application is dead: pid = %d, sock = %d",
421 app->pid, app->sock);
422 } else if (ret == -EAGAIN) {
423 WARN("UST app release stream failed. Communication time out: pid = %d, sock = %d",
424 app->pid, app->sock);
425 } else {
426 ERR("UST app release stream obj failed with ret %d: pid = %d, sock = %d",
427 ret, app->pid, app->sock);
428 }
429 }
430 lttng_fd_put(LTTNG_FD_APPS, 2);
431 free(stream->obj);
432 }
433
434 return ret;
435 }
436
437 /*
438 * Delete ust app stream safely. RCU read lock must be held before calling
439 * this function.
440 */
441 static
442 void delete_ust_app_stream(int sock, struct ust_app_stream *stream,
443 struct ust_app *app)
444 {
445 LTTNG_ASSERT(stream);
446
447 (void) release_ust_app_stream(sock, stream, app);
448 free(stream);
449 }
450
451 /*
452 * We need to execute ht_destroy outside of RCU read-side critical
453 * section and outside of call_rcu thread, so we postpone its execution
454 * using ht_cleanup_push. It is simpler than to change the semantic of
455 * the many callers of delete_ust_app_session().
456 */
457 static
458 void delete_ust_app_channel_rcu(struct rcu_head *head)
459 {
460 struct ust_app_channel *ua_chan =
461 caa_container_of(head, struct ust_app_channel, rcu_head);
462
463 ht_cleanup_push(ua_chan->ctx);
464 ht_cleanup_push(ua_chan->events);
465 free(ua_chan);
466 }
467
468 /*
469 * Extract the lost packet or discarded events counter when the channel is
470 * being deleted and store the value in the parent channel so we can
471 * access it from lttng list and at stop/destroy.
472 *
473 * The session list lock must be held by the caller.
474 */
475 static
476 void save_per_pid_lost_discarded_counters(struct ust_app_channel *ua_chan)
477 {
478 uint64_t discarded = 0, lost = 0;
479 struct ltt_session *session;
480 struct ltt_ust_channel *uchan;
481
482 if (ua_chan->attr.type != LTTNG_UST_ABI_CHAN_PER_CPU) {
483 return;
484 }
485
486 rcu_read_lock();
487 session = session_find_by_id(ua_chan->session->tracing_id);
488 if (!session || !session->ust_session) {
489 /*
490 * Not finding the session is not an error because there are
491 * multiple ways the channels can be torn down.
492 *
493 * 1) The session daemon can initiate the destruction of the
494 * ust app session after receiving a destroy command or
495 * during its shutdown/teardown.
496 * 2) The application, since we are in per-pid tracing, is
497 * unregistering and tearing down its ust app session.
498 *
499 * Both paths are protected by the session list lock which
500 * ensures that the accounting of lost packets and discarded
501 * events is done exactly once. The session is then unpublished
502 * from the session list, resulting in this condition.
503 */
504 goto end;
505 }
506
507 if (ua_chan->attr.overwrite) {
508 consumer_get_lost_packets(ua_chan->session->tracing_id,
509 ua_chan->key, session->ust_session->consumer,
510 &lost);
511 } else {
512 consumer_get_discarded_events(ua_chan->session->tracing_id,
513 ua_chan->key, session->ust_session->consumer,
514 &discarded);
515 }
516 uchan = trace_ust_find_channel_by_name(
517 session->ust_session->domain_global.channels,
518 ua_chan->name);
519 if (!uchan) {
520 ERR("Missing UST channel to store discarded counters");
521 goto end;
522 }
523
524 uchan->per_pid_closed_app_discarded += discarded;
525 uchan->per_pid_closed_app_lost += lost;
526
527 end:
528 rcu_read_unlock();
529 if (session) {
530 session_put(session);
531 }
532 }
533
534 /*
535 * Delete ust app channel safely. RCU read lock must be held before calling
536 * this function.
537 *
538 * The session list lock must be held by the caller.
539 */
540 static
541 void delete_ust_app_channel(int sock, struct ust_app_channel *ua_chan,
542 struct ust_app *app)
543 {
544 int ret;
545 struct lttng_ht_iter iter;
546 struct ust_app_event *ua_event;
547 struct ust_app_ctx *ua_ctx;
548 struct ust_app_stream *stream, *stmp;
549 struct ust_registry_session *registry;
550
551 LTTNG_ASSERT(ua_chan);
552
553 DBG3("UST app deleting channel %s", ua_chan->name);
554
555 /* Wipe stream */
556 cds_list_for_each_entry_safe(stream, stmp, &ua_chan->streams.head, list) {
557 cds_list_del(&stream->list);
558 delete_ust_app_stream(sock, stream, app);
559 }
560
561 /* Wipe context */
562 cds_lfht_for_each_entry(ua_chan->ctx->ht, &iter.iter, ua_ctx, node.node) {
563 cds_list_del(&ua_ctx->list);
564 ret = lttng_ht_del(ua_chan->ctx, &iter);
565 LTTNG_ASSERT(!ret);
566 delete_ust_app_ctx(sock, ua_ctx, app);
567 }
568
569 /* Wipe events */
570 cds_lfht_for_each_entry(ua_chan->events->ht, &iter.iter, ua_event,
571 node.node) {
572 ret = lttng_ht_del(ua_chan->events, &iter);
573 LTTNG_ASSERT(!ret);
574 delete_ust_app_event(sock, ua_event, app);
575 }
576
577 if (ua_chan->session->buffer_type == LTTNG_BUFFER_PER_PID) {
578 /* Wipe and free registry from session registry. */
579 registry = get_session_registry(ua_chan->session);
580 if (registry) {
581 ust_registry_channel_del_free(registry, ua_chan->key,
582 sock >= 0);
583 }
584 /*
585 * A negative socket can be used by the caller when
586 * cleaning-up a ua_chan in an error path. Skip the
587 * accounting in this case.
588 */
589 if (sock >= 0) {
590 save_per_pid_lost_discarded_counters(ua_chan);
591 }
592 }
593
594 if (ua_chan->obj != NULL) {
595 /* Remove channel from application UST object descriptor. */
596 iter.iter.node = &ua_chan->ust_objd_node.node;
597 ret = lttng_ht_del(app->ust_objd, &iter);
598 LTTNG_ASSERT(!ret);
599 pthread_mutex_lock(&app->sock_lock);
600 ret = lttng_ust_ctl_release_object(sock, ua_chan->obj);
601 pthread_mutex_unlock(&app->sock_lock);
602 if (ret < 0) {
603 if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
604 DBG3("UST app channel %s release failed. Application is dead: pid = %d, sock = %d",
605 ua_chan->name, app->pid,
606 app->sock);
607 } else if (ret == -EAGAIN) {
608 WARN("UST app channel %s release failed. Communication time out: pid = %d, sock = %d",
609 ua_chan->name, app->pid,
610 app->sock);
611 } else {
612 ERR("UST app channel %s release failed with ret %d: pid = %d, sock = %d",
613 ua_chan->name, ret, app->pid,
614 app->sock);
615 }
616 }
617 lttng_fd_put(LTTNG_FD_APPS, 1);
618 free(ua_chan->obj);
619 }
620 call_rcu(&ua_chan->rcu_head, delete_ust_app_channel_rcu);
621 }
622
623 int ust_app_register_done(struct ust_app *app)
624 {
625 int ret;
626
627 pthread_mutex_lock(&app->sock_lock);
628 ret = lttng_ust_ctl_register_done(app->sock);
629 pthread_mutex_unlock(&app->sock_lock);
630 return ret;
631 }
632
633 int ust_app_release_object(struct ust_app *app, struct lttng_ust_abi_object_data *data)
634 {
635 int ret, sock;
636
637 if (app) {
638 pthread_mutex_lock(&app->sock_lock);
639 sock = app->sock;
640 } else {
641 sock = -1;
642 }
643 ret = lttng_ust_ctl_release_object(sock, data);
644 if (app) {
645 pthread_mutex_unlock(&app->sock_lock);
646 }
647 return ret;
648 }
649
650 /*
651 * Push metadata to consumer socket.
652 *
653 * RCU read-side lock must be held to guarantee existence of socket.
654 * Must be called with the ust app session lock held.
655 * Must be called with the registry lock held.
656 *
657 * On success, return the len of metadata pushed or else a negative value.
658 * Returning a -EPIPE return value means we could not send the metadata,
659 * but it can be caused by recoverable errors (e.g. the application has
660 * terminated concurrently).
661 */
662 ssize_t ust_app_push_metadata(struct ust_registry_session *registry,
663 struct consumer_socket *socket, int send_zero_data)
664 {
665 int ret;
666 char *metadata_str = NULL;
667 size_t len, offset, new_metadata_len_sent;
668 ssize_t ret_val;
669 uint64_t metadata_key, metadata_version;
670
671 LTTNG_ASSERT(registry);
672 LTTNG_ASSERT(socket);
673
674 metadata_key = registry->metadata_key;
675
676 /*
677 * Means that no metadata was assigned to the session. This can
678 * happens if no start has been done previously.
679 */
680 if (!metadata_key) {
681 return 0;
682 }
683
684 offset = registry->metadata_len_sent;
685 len = registry->metadata_len - registry->metadata_len_sent;
686 new_metadata_len_sent = registry->metadata_len;
687 metadata_version = registry->metadata_version;
688 if (len == 0) {
689 DBG3("No metadata to push for metadata key %" PRIu64,
690 registry->metadata_key);
691 ret_val = len;
692 if (send_zero_data) {
693 DBG("No metadata to push");
694 goto push_data;
695 }
696 goto end;
697 }
698
699 /* Allocate only what we have to send. */
700 metadata_str = (char *) zmalloc(len);
701 if (!metadata_str) {
702 PERROR("zmalloc ust app metadata string");
703 ret_val = -ENOMEM;
704 goto error;
705 }
706 /* Copy what we haven't sent out. */
707 memcpy(metadata_str, registry->metadata + offset, len);
708
709 push_data:
710 pthread_mutex_unlock(&registry->lock);
711 /*
712 * We need to unlock the registry while we push metadata to
713 * break a circular dependency between the consumerd metadata
714 * lock and the sessiond registry lock. Indeed, pushing metadata
715 * to the consumerd awaits that it gets pushed all the way to
716 * relayd, but doing so requires grabbing the metadata lock. If
717 * a concurrent metadata request is being performed by
718 * consumerd, this can try to grab the registry lock on the
719 * sessiond while holding the metadata lock on the consumer
720 * daemon. Those push and pull schemes are performed on two
721 * different bidirectionnal communication sockets.
722 */
723 ret = consumer_push_metadata(socket, metadata_key,
724 metadata_str, len, offset, metadata_version);
725 pthread_mutex_lock(&registry->lock);
726 if (ret < 0) {
727 /*
728 * There is an acceptable race here between the registry
729 * metadata key assignment and the creation on the
730 * consumer. The session daemon can concurrently push
731 * metadata for this registry while being created on the
732 * consumer since the metadata key of the registry is
733 * assigned *before* it is setup to avoid the consumer
734 * to ask for metadata that could possibly be not found
735 * in the session daemon.
736 *
737 * The metadata will get pushed either by the session
738 * being stopped or the consumer requesting metadata if
739 * that race is triggered.
740 */
741 if (ret == -LTTCOMM_CONSUMERD_CHANNEL_FAIL) {
742 ret = 0;
743 } else {
744 ERR("Error pushing metadata to consumer");
745 }
746 ret_val = ret;
747 goto error_push;
748 } else {
749 /*
750 * Metadata may have been concurrently pushed, since
751 * we're not holding the registry lock while pushing to
752 * consumer. This is handled by the fact that we send
753 * the metadata content, size, and the offset at which
754 * that metadata belongs. This may arrive out of order
755 * on the consumer side, and the consumer is able to
756 * deal with overlapping fragments. The consumer
757 * supports overlapping fragments, which must be
758 * contiguous starting from offset 0. We keep the
759 * largest metadata_len_sent value of the concurrent
760 * send.
761 */
762 registry->metadata_len_sent =
763 std::max(registry->metadata_len_sent,
764 new_metadata_len_sent);
765 }
766 free(metadata_str);
767 return len;
768
769 end:
770 error:
771 if (ret_val) {
772 /*
773 * On error, flag the registry that the metadata is
774 * closed. We were unable to push anything and this
775 * means that either the consumer is not responding or
776 * the metadata cache has been destroyed on the
777 * consumer.
778 */
779 registry->metadata_closed = 1;
780 }
781 error_push:
782 free(metadata_str);
783 return ret_val;
784 }
785
786 /*
787 * For a given application and session, push metadata to consumer.
788 * Either sock or consumer is required : if sock is NULL, the default
789 * socket to send the metadata is retrieved from consumer, if sock
790 * is not NULL we use it to send the metadata.
791 * RCU read-side lock must be held while calling this function,
792 * therefore ensuring existence of registry. It also ensures existence
793 * of socket throughout this function.
794 *
795 * Return 0 on success else a negative error.
796 * Returning a -EPIPE return value means we could not send the metadata,
797 * but it can be caused by recoverable errors (e.g. the application has
798 * terminated concurrently).
799 */
800 static int push_metadata(struct ust_registry_session *registry,
801 struct consumer_output *consumer)
802 {
803 int ret_val;
804 ssize_t ret;
805 struct consumer_socket *socket;
806
807 LTTNG_ASSERT(registry);
808 LTTNG_ASSERT(consumer);
809
810 pthread_mutex_lock(&registry->lock);
811 if (registry->metadata_closed) {
812 ret_val = -EPIPE;
813 goto error;
814 }
815
816 /* Get consumer socket to use to push the metadata.*/
817 socket = consumer_find_socket_by_bitness(registry->bits_per_long,
818 consumer);
819 if (!socket) {
820 ret_val = -1;
821 goto error;
822 }
823
824 ret = ust_app_push_metadata(registry, socket, 0);
825 if (ret < 0) {
826 ret_val = ret;
827 goto error;
828 }
829 pthread_mutex_unlock(&registry->lock);
830 return 0;
831
832 error:
833 pthread_mutex_unlock(&registry->lock);
834 return ret_val;
835 }
836
837 /*
838 * Send to the consumer a close metadata command for the given session. Once
839 * done, the metadata channel is deleted and the session metadata pointer is
840 * nullified. The session lock MUST be held unless the application is
841 * in the destroy path.
842 *
843 * Do not hold the registry lock while communicating with the consumerd, because
844 * doing so causes inter-process deadlocks between consumerd and sessiond with
845 * the metadata request notification.
846 *
847 * Return 0 on success else a negative value.
848 */
849 static int close_metadata(struct ust_registry_session *registry,
850 struct consumer_output *consumer)
851 {
852 int ret;
853 struct consumer_socket *socket;
854 uint64_t metadata_key;
855 bool registry_was_already_closed;
856
857 LTTNG_ASSERT(registry);
858 LTTNG_ASSERT(consumer);
859
860 rcu_read_lock();
861
862 pthread_mutex_lock(&registry->lock);
863 metadata_key = registry->metadata_key;
864 registry_was_already_closed = registry->metadata_closed;
865 if (metadata_key != 0) {
866 /*
867 * Metadata closed. Even on error this means that the consumer
868 * is not responding or not found so either way a second close
869 * should NOT be emit for this registry.
870 */
871 registry->metadata_closed = 1;
872 }
873 pthread_mutex_unlock(&registry->lock);
874
875 if (metadata_key == 0 || registry_was_already_closed) {
876 ret = 0;
877 goto end;
878 }
879
880 /* Get consumer socket to use to push the metadata.*/
881 socket = consumer_find_socket_by_bitness(registry->bits_per_long,
882 consumer);
883 if (!socket) {
884 ret = -1;
885 goto end;
886 }
887
888 ret = consumer_close_metadata(socket, metadata_key);
889 if (ret < 0) {
890 goto end;
891 }
892
893 end:
894 rcu_read_unlock();
895 return ret;
896 }
897
898 /*
899 * We need to execute ht_destroy outside of RCU read-side critical
900 * section and outside of call_rcu thread, so we postpone its execution
901 * using ht_cleanup_push. It is simpler than to change the semantic of
902 * the many callers of delete_ust_app_session().
903 */
904 static
905 void delete_ust_app_session_rcu(struct rcu_head *head)
906 {
907 struct ust_app_session *ua_sess =
908 caa_container_of(head, struct ust_app_session, rcu_head);
909
910 ht_cleanup_push(ua_sess->channels);
911 free(ua_sess);
912 }
913
914 /*
915 * Delete ust app session safely. RCU read lock must be held before calling
916 * this function.
917 *
918 * The session list lock must be held by the caller.
919 */
920 static
921 void delete_ust_app_session(int sock, struct ust_app_session *ua_sess,
922 struct ust_app *app)
923 {
924 int ret;
925 struct lttng_ht_iter iter;
926 struct ust_app_channel *ua_chan;
927 struct ust_registry_session *registry;
928
929 LTTNG_ASSERT(ua_sess);
930
931 pthread_mutex_lock(&ua_sess->lock);
932
933 LTTNG_ASSERT(!ua_sess->deleted);
934 ua_sess->deleted = true;
935
936 registry = get_session_registry(ua_sess);
937 /* Registry can be null on error path during initialization. */
938 if (registry) {
939 /* Push metadata for application before freeing the application. */
940 (void) push_metadata(registry, ua_sess->consumer);
941
942 /*
943 * Don't ask to close metadata for global per UID buffers. Close
944 * metadata only on destroy trace session in this case. Also, the
945 * previous push metadata could have flag the metadata registry to
946 * close so don't send a close command if closed.
947 */
948 if (ua_sess->buffer_type != LTTNG_BUFFER_PER_UID) {
949 /* And ask to close it for this session registry. */
950 (void) close_metadata(registry, ua_sess->consumer);
951 }
952 }
953
954 cds_lfht_for_each_entry(ua_sess->channels->ht, &iter.iter, ua_chan,
955 node.node) {
956 ret = lttng_ht_del(ua_sess->channels, &iter);
957 LTTNG_ASSERT(!ret);
958 delete_ust_app_channel(sock, ua_chan, app);
959 }
960
961 /* In case of per PID, the registry is kept in the session. */
962 if (ua_sess->buffer_type == LTTNG_BUFFER_PER_PID) {
963 struct buffer_reg_pid *reg_pid = buffer_reg_pid_find(ua_sess->id);
964 if (reg_pid) {
965 /*
966 * Registry can be null on error path during
967 * initialization.
968 */
969 buffer_reg_pid_remove(reg_pid);
970 buffer_reg_pid_destroy(reg_pid);
971 }
972 }
973
974 if (ua_sess->handle != -1) {
975 pthread_mutex_lock(&app->sock_lock);
976 ret = lttng_ust_ctl_release_handle(sock, ua_sess->handle);
977 pthread_mutex_unlock(&app->sock_lock);
978 if (ret < 0) {
979 if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
980 DBG3("UST app release session handle failed. Application is dead: pid = %d, sock = %d",
981 app->pid, app->sock);
982 } else if (ret == -EAGAIN) {
983 WARN("UST app release session handle failed. Communication time out: pid = %d, sock = %d",
984 app->pid, app->sock);
985 } else {
986 ERR("UST app release session handle failed with ret %d: pid = %d, sock = %d",
987 ret, app->pid, app->sock);
988 }
989 }
990
991 /* Remove session from application UST object descriptor. */
992 iter.iter.node = &ua_sess->ust_objd_node.node;
993 ret = lttng_ht_del(app->ust_sessions_objd, &iter);
994 LTTNG_ASSERT(!ret);
995 }
996
997 pthread_mutex_unlock(&ua_sess->lock);
998
999 consumer_output_put(ua_sess->consumer);
1000
1001 call_rcu(&ua_sess->rcu_head, delete_ust_app_session_rcu);
1002 }
1003
1004 /*
1005 * Delete a traceable application structure from the global list. Never call
1006 * this function outside of a call_rcu call.
1007 *
1008 * RCU read side lock should _NOT_ be held when calling this function.
1009 */
1010 static
1011 void delete_ust_app(struct ust_app *app)
1012 {
1013 int ret, sock;
1014 struct ust_app_session *ua_sess, *tmp_ua_sess;
1015 struct lttng_ht_iter iter;
1016 struct ust_app_event_notifier_rule *event_notifier_rule;
1017 bool event_notifier_write_fd_is_open;
1018
1019 /*
1020 * The session list lock must be held during this function to guarantee
1021 * the existence of ua_sess.
1022 */
1023 session_lock_list();
1024 /* Delete ust app sessions info */
1025 sock = app->sock;
1026 app->sock = -1;
1027
1028 /* Wipe sessions */
1029 cds_list_for_each_entry_safe(ua_sess, tmp_ua_sess, &app->teardown_head,
1030 teardown_node) {
1031 /* Free every object in the session and the session. */
1032 rcu_read_lock();
1033 delete_ust_app_session(sock, ua_sess, app);
1034 rcu_read_unlock();
1035 }
1036
1037 /* Remove the event notifier rules associated with this app. */
1038 rcu_read_lock();
1039 cds_lfht_for_each_entry (app->token_to_event_notifier_rule_ht->ht,
1040 &iter.iter, event_notifier_rule, node.node) {
1041 ret = lttng_ht_del(app->token_to_event_notifier_rule_ht, &iter);
1042 LTTNG_ASSERT(!ret);
1043
1044 delete_ust_app_event_notifier_rule(
1045 app->sock, event_notifier_rule, app);
1046 }
1047
1048 rcu_read_unlock();
1049
1050 ht_cleanup_push(app->sessions);
1051 ht_cleanup_push(app->ust_sessions_objd);
1052 ht_cleanup_push(app->ust_objd);
1053 ht_cleanup_push(app->token_to_event_notifier_rule_ht);
1054
1055 /*
1056 * This could be NULL if the event notifier setup failed (e.g the app
1057 * was killed or the tracer does not support this feature).
1058 */
1059 if (app->event_notifier_group.object) {
1060 enum lttng_error_code ret_code;
1061 enum event_notifier_error_accounting_status status;
1062
1063 const int event_notifier_read_fd = lttng_pipe_get_readfd(
1064 app->event_notifier_group.event_pipe);
1065
1066 ret_code = notification_thread_command_remove_tracer_event_source(
1067 the_notification_thread_handle,
1068 event_notifier_read_fd);
1069 if (ret_code != LTTNG_OK) {
1070 ERR("Failed to remove application tracer event source from notification thread");
1071 }
1072
1073 status = event_notifier_error_accounting_unregister_app(app);
1074 if (status != EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_OK) {
1075 ERR("Error unregistering app from event notifier error accounting");
1076 }
1077
1078 lttng_ust_ctl_release_object(sock, app->event_notifier_group.object);
1079 free(app->event_notifier_group.object);
1080 }
1081
1082 event_notifier_write_fd_is_open = lttng_pipe_is_write_open(
1083 app->event_notifier_group.event_pipe);
1084 lttng_pipe_destroy(app->event_notifier_group.event_pipe);
1085 /*
1086 * Release the file descriptors reserved for the event notifier pipe.
1087 * The app could be destroyed before the write end of the pipe could be
1088 * passed to the application (and closed). In that case, both file
1089 * descriptors must be released.
1090 */
1091 lttng_fd_put(LTTNG_FD_APPS, event_notifier_write_fd_is_open ? 2 : 1);
1092
1093 /*
1094 * Wait until we have deleted the application from the sock hash table
1095 * before closing this socket, otherwise an application could re-use the
1096 * socket ID and race with the teardown, using the same hash table entry.
1097 *
1098 * It's OK to leave the close in call_rcu. We want it to stay unique for
1099 * all RCU readers that could run concurrently with unregister app,
1100 * therefore we _need_ to only close that socket after a grace period. So
1101 * it should stay in this RCU callback.
1102 *
1103 * This close() is a very important step of the synchronization model so
1104 * every modification to this function must be carefully reviewed.
1105 */
1106 ret = close(sock);
1107 if (ret) {
1108 PERROR("close");
1109 }
1110 lttng_fd_put(LTTNG_FD_APPS, 1);
1111
1112 DBG2("UST app pid %d deleted", app->pid);
1113 free(app);
1114 session_unlock_list();
1115 }
1116
1117 /*
1118 * URCU intermediate call to delete an UST app.
1119 */
1120 static
1121 void delete_ust_app_rcu(struct rcu_head *head)
1122 {
1123 struct lttng_ht_node_ulong *node =
1124 caa_container_of(head, struct lttng_ht_node_ulong, head);
1125 struct ust_app *app =
1126 caa_container_of(node, struct ust_app, pid_n);
1127
1128 DBG3("Call RCU deleting app PID %d", app->pid);
1129 delete_ust_app(app);
1130 }
1131
1132 /*
1133 * Delete the session from the application ht and delete the data structure by
1134 * freeing every object inside and releasing them.
1135 *
1136 * The session list lock must be held by the caller.
1137 */
1138 static void destroy_app_session(struct ust_app *app,
1139 struct ust_app_session *ua_sess)
1140 {
1141 int ret;
1142 struct lttng_ht_iter iter;
1143
1144 LTTNG_ASSERT(app);
1145 LTTNG_ASSERT(ua_sess);
1146
1147 iter.iter.node = &ua_sess->node.node;
1148 ret = lttng_ht_del(app->sessions, &iter);
1149 if (ret) {
1150 /* Already scheduled for teardown. */
1151 goto end;
1152 }
1153
1154 /* Once deleted, free the data structure. */
1155 delete_ust_app_session(app->sock, ua_sess, app);
1156
1157 end:
1158 return;
1159 }
1160
1161 /*
1162 * Alloc new UST app session.
1163 */
1164 static
1165 struct ust_app_session *alloc_ust_app_session(void)
1166 {
1167 struct ust_app_session *ua_sess;
1168
1169 /* Init most of the default value by allocating and zeroing */
1170 ua_sess = (ust_app_session *) zmalloc(sizeof(struct ust_app_session));
1171 if (ua_sess == NULL) {
1172 PERROR("malloc");
1173 goto error_free;
1174 }
1175
1176 ua_sess->handle = -1;
1177 ua_sess->channels = lttng_ht_new(0, LTTNG_HT_TYPE_STRING);
1178 ua_sess->metadata_attr.type = LTTNG_UST_ABI_CHAN_METADATA;
1179 pthread_mutex_init(&ua_sess->lock, NULL);
1180
1181 return ua_sess;
1182
1183 error_free:
1184 return NULL;
1185 }
1186
1187 /*
1188 * Alloc new UST app channel.
1189 */
1190 static
1191 struct ust_app_channel *alloc_ust_app_channel(const char *name,
1192 struct ust_app_session *ua_sess,
1193 struct lttng_ust_abi_channel_attr *attr)
1194 {
1195 struct ust_app_channel *ua_chan;
1196
1197 /* Init most of the default value by allocating and zeroing */
1198 ua_chan = (ust_app_channel *) zmalloc(sizeof(struct ust_app_channel));
1199 if (ua_chan == NULL) {
1200 PERROR("malloc");
1201 goto error;
1202 }
1203
1204 /* Setup channel name */
1205 strncpy(ua_chan->name, name, sizeof(ua_chan->name));
1206 ua_chan->name[sizeof(ua_chan->name) - 1] = '\0';
1207
1208 ua_chan->enabled = 1;
1209 ua_chan->handle = -1;
1210 ua_chan->session = ua_sess;
1211 ua_chan->key = get_next_channel_key();
1212 ua_chan->ctx = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG);
1213 ua_chan->events = lttng_ht_new(0, LTTNG_HT_TYPE_STRING);
1214 lttng_ht_node_init_str(&ua_chan->node, ua_chan->name);
1215
1216 CDS_INIT_LIST_HEAD(&ua_chan->streams.head);
1217 CDS_INIT_LIST_HEAD(&ua_chan->ctx_list);
1218
1219 /* Copy attributes */
1220 if (attr) {
1221 /* Translate from lttng_ust_channel to lttng_ust_ctl_consumer_channel_attr. */
1222 ua_chan->attr.subbuf_size = attr->subbuf_size;
1223 ua_chan->attr.num_subbuf = attr->num_subbuf;
1224 ua_chan->attr.overwrite = attr->overwrite;
1225 ua_chan->attr.switch_timer_interval = attr->switch_timer_interval;
1226 ua_chan->attr.read_timer_interval = attr->read_timer_interval;
1227 ua_chan->attr.output = (lttng_ust_abi_output) attr->output;
1228 ua_chan->attr.blocking_timeout = attr->u.s.blocking_timeout;
1229 }
1230 /* By default, the channel is a per cpu channel. */
1231 ua_chan->attr.type = LTTNG_UST_ABI_CHAN_PER_CPU;
1232
1233 DBG3("UST app channel %s allocated", ua_chan->name);
1234
1235 return ua_chan;
1236
1237 error:
1238 return NULL;
1239 }
1240
1241 /*
1242 * Allocate and initialize a UST app stream.
1243 *
1244 * Return newly allocated stream pointer or NULL on error.
1245 */
1246 struct ust_app_stream *ust_app_alloc_stream(void)
1247 {
1248 struct ust_app_stream *stream = NULL;
1249
1250 stream = (ust_app_stream *) zmalloc(sizeof(*stream));
1251 if (stream == NULL) {
1252 PERROR("zmalloc ust app stream");
1253 goto error;
1254 }
1255
1256 /* Zero could be a valid value for a handle so flag it to -1. */
1257 stream->handle = -1;
1258
1259 error:
1260 return stream;
1261 }
1262
1263 /*
1264 * Alloc new UST app event.
1265 */
1266 static
1267 struct ust_app_event *alloc_ust_app_event(char *name,
1268 struct lttng_ust_abi_event *attr)
1269 {
1270 struct ust_app_event *ua_event;
1271
1272 /* Init most of the default value by allocating and zeroing */
1273 ua_event = (ust_app_event *) zmalloc(sizeof(struct ust_app_event));
1274 if (ua_event == NULL) {
1275 PERROR("Failed to allocate ust_app_event structure");
1276 goto error;
1277 }
1278
1279 ua_event->enabled = 1;
1280 strncpy(ua_event->name, name, sizeof(ua_event->name));
1281 ua_event->name[sizeof(ua_event->name) - 1] = '\0';
1282 lttng_ht_node_init_str(&ua_event->node, ua_event->name);
1283
1284 /* Copy attributes */
1285 if (attr) {
1286 memcpy(&ua_event->attr, attr, sizeof(ua_event->attr));
1287 }
1288
1289 DBG3("UST app event %s allocated", ua_event->name);
1290
1291 return ua_event;
1292
1293 error:
1294 return NULL;
1295 }
1296
1297 /*
1298 * Allocate a new UST app event notifier rule.
1299 */
1300 static struct ust_app_event_notifier_rule *alloc_ust_app_event_notifier_rule(
1301 struct lttng_trigger *trigger)
1302 {
1303 enum lttng_event_rule_generate_exclusions_status
1304 generate_exclusion_status;
1305 enum lttng_condition_status cond_status;
1306 struct ust_app_event_notifier_rule *ua_event_notifier_rule;
1307 struct lttng_condition *condition = NULL;
1308 const struct lttng_event_rule *event_rule = NULL;
1309
1310 ua_event_notifier_rule = (ust_app_event_notifier_rule *) zmalloc(sizeof(struct ust_app_event_notifier_rule));
1311 if (ua_event_notifier_rule == NULL) {
1312 PERROR("Failed to allocate ust_app_event_notifier_rule structure");
1313 goto error;
1314 }
1315
1316 ua_event_notifier_rule->enabled = 1;
1317 ua_event_notifier_rule->token = lttng_trigger_get_tracer_token(trigger);
1318 lttng_ht_node_init_u64(&ua_event_notifier_rule->node,
1319 ua_event_notifier_rule->token);
1320
1321 condition = lttng_trigger_get_condition(trigger);
1322 LTTNG_ASSERT(condition);
1323 LTTNG_ASSERT(lttng_condition_get_type(condition) ==
1324 LTTNG_CONDITION_TYPE_EVENT_RULE_MATCHES);
1325
1326 cond_status = lttng_condition_event_rule_matches_get_rule(
1327 condition, &event_rule);
1328 LTTNG_ASSERT(cond_status == LTTNG_CONDITION_STATUS_OK);
1329 LTTNG_ASSERT(event_rule);
1330
1331 ua_event_notifier_rule->error_counter_index =
1332 lttng_condition_event_rule_matches_get_error_counter_index(condition);
1333 /* Acquire the event notifier's reference to the trigger. */
1334 lttng_trigger_get(trigger);
1335
1336 ua_event_notifier_rule->trigger = trigger;
1337 ua_event_notifier_rule->filter = lttng_event_rule_get_filter_bytecode(event_rule);
1338 generate_exclusion_status = lttng_event_rule_generate_exclusions(
1339 event_rule, &ua_event_notifier_rule->exclusion);
1340 switch (generate_exclusion_status) {
1341 case LTTNG_EVENT_RULE_GENERATE_EXCLUSIONS_STATUS_OK:
1342 case LTTNG_EVENT_RULE_GENERATE_EXCLUSIONS_STATUS_NONE:
1343 break;
1344 default:
1345 /* Error occurred. */
1346 ERR("Failed to generate exclusions from trigger while allocating an event notifier rule");
1347 goto error_put_trigger;
1348 }
1349
1350 DBG3("UST app event notifier rule allocated: token = %" PRIu64,
1351 ua_event_notifier_rule->token);
1352
1353 return ua_event_notifier_rule;
1354
1355 error_put_trigger:
1356 lttng_trigger_put(trigger);
1357 error:
1358 free(ua_event_notifier_rule);
1359 return NULL;
1360 }
1361
1362 /*
1363 * Alloc new UST app context.
1364 */
1365 static
1366 struct ust_app_ctx *alloc_ust_app_ctx(struct lttng_ust_context_attr *uctx)
1367 {
1368 struct ust_app_ctx *ua_ctx;
1369
1370 ua_ctx = (ust_app_ctx *) zmalloc(sizeof(struct ust_app_ctx));
1371 if (ua_ctx == NULL) {
1372 goto error;
1373 }
1374
1375 CDS_INIT_LIST_HEAD(&ua_ctx->list);
1376
1377 if (uctx) {
1378 memcpy(&ua_ctx->ctx, uctx, sizeof(ua_ctx->ctx));
1379 if (uctx->ctx == LTTNG_UST_ABI_CONTEXT_APP_CONTEXT) {
1380 char *provider_name = NULL, *ctx_name = NULL;
1381
1382 provider_name = strdup(uctx->u.app_ctx.provider_name);
1383 ctx_name = strdup(uctx->u.app_ctx.ctx_name);
1384 if (!provider_name || !ctx_name) {
1385 free(provider_name);
1386 free(ctx_name);
1387 goto error;
1388 }
1389
1390 ua_ctx->ctx.u.app_ctx.provider_name = provider_name;
1391 ua_ctx->ctx.u.app_ctx.ctx_name = ctx_name;
1392 }
1393 }
1394
1395 DBG3("UST app context %d allocated", ua_ctx->ctx.ctx);
1396 return ua_ctx;
1397 error:
1398 free(ua_ctx);
1399 return NULL;
1400 }
1401
1402 /*
1403 * Create a liblttng-ust filter bytecode from given bytecode.
1404 *
1405 * Return allocated filter or NULL on error.
1406 */
1407 static struct lttng_ust_abi_filter_bytecode *create_ust_filter_bytecode_from_bytecode(
1408 const struct lttng_bytecode *orig_f)
1409 {
1410 struct lttng_ust_abi_filter_bytecode *filter = NULL;
1411
1412 /* Copy filter bytecode. */
1413 filter = (lttng_ust_abi_filter_bytecode *) zmalloc(sizeof(*filter) + orig_f->len);
1414 if (!filter) {
1415 PERROR("Failed to allocate lttng_ust_filter_bytecode: bytecode len = %" PRIu32 " bytes", orig_f->len);
1416 goto error;
1417 }
1418
1419 LTTNG_ASSERT(sizeof(struct lttng_bytecode) ==
1420 sizeof(struct lttng_ust_abi_filter_bytecode));
1421 memcpy(filter, orig_f, sizeof(*filter) + orig_f->len);
1422 error:
1423 return filter;
1424 }
1425
1426 /*
1427 * Create a liblttng-ust capture bytecode from given bytecode.
1428 *
1429 * Return allocated filter or NULL on error.
1430 */
1431 static struct lttng_ust_abi_capture_bytecode *
1432 create_ust_capture_bytecode_from_bytecode(const struct lttng_bytecode *orig_f)
1433 {
1434 struct lttng_ust_abi_capture_bytecode *capture = NULL;
1435
1436 /* Copy capture bytecode. */
1437 capture = (lttng_ust_abi_capture_bytecode *) zmalloc(sizeof(*capture) + orig_f->len);
1438 if (!capture) {
1439 PERROR("Failed to allocate lttng_ust_abi_capture_bytecode: bytecode len = %" PRIu32 " bytes", orig_f->len);
1440 goto error;
1441 }
1442
1443 LTTNG_ASSERT(sizeof(struct lttng_bytecode) ==
1444 sizeof(struct lttng_ust_abi_capture_bytecode));
1445 memcpy(capture, orig_f, sizeof(*capture) + orig_f->len);
1446 error:
1447 return capture;
1448 }
1449
1450 /*
1451 * Find an ust_app using the sock and return it. RCU read side lock must be
1452 * held before calling this helper function.
1453 */
1454 struct ust_app *ust_app_find_by_sock(int sock)
1455 {
1456 struct lttng_ht_node_ulong *node;
1457 struct lttng_ht_iter iter;
1458
1459 lttng_ht_lookup(ust_app_ht_by_sock, (void *)((unsigned long) sock), &iter);
1460 node = lttng_ht_iter_get_node_ulong(&iter);
1461 if (node == NULL) {
1462 DBG2("UST app find by sock %d not found", sock);
1463 goto error;
1464 }
1465
1466 return caa_container_of(node, struct ust_app, sock_n);
1467
1468 error:
1469 return NULL;
1470 }
1471
1472 /*
1473 * Find an ust_app using the notify sock and return it. RCU read side lock must
1474 * be held before calling this helper function.
1475 */
1476 static struct ust_app *find_app_by_notify_sock(int sock)
1477 {
1478 struct lttng_ht_node_ulong *node;
1479 struct lttng_ht_iter iter;
1480
1481 lttng_ht_lookup(ust_app_ht_by_notify_sock, (void *)((unsigned long) sock),
1482 &iter);
1483 node = lttng_ht_iter_get_node_ulong(&iter);
1484 if (node == NULL) {
1485 DBG2("UST app find by notify sock %d not found", sock);
1486 goto error;
1487 }
1488
1489 return caa_container_of(node, struct ust_app, notify_sock_n);
1490
1491 error:
1492 return NULL;
1493 }
1494
1495 /*
1496 * Lookup for an ust app event based on event name, filter bytecode and the
1497 * event loglevel.
1498 *
1499 * Return an ust_app_event object or NULL on error.
1500 */
1501 static struct ust_app_event *find_ust_app_event(struct lttng_ht *ht,
1502 const char *name, const struct lttng_bytecode *filter,
1503 int loglevel_value,
1504 const struct lttng_event_exclusion *exclusion)
1505 {
1506 struct lttng_ht_iter iter;
1507 struct lttng_ht_node_str *node;
1508 struct ust_app_event *event = NULL;
1509 struct ust_app_ht_key key;
1510
1511 LTTNG_ASSERT(name);
1512 LTTNG_ASSERT(ht);
1513
1514 /* Setup key for event lookup. */
1515 key.name = name;
1516 key.filter = filter;
1517 key.loglevel_type = (lttng_ust_abi_loglevel_type) loglevel_value;
1518 /* lttng_event_exclusion and lttng_ust_event_exclusion structures are similar */
1519 key.exclusion = exclusion;
1520
1521 /* Lookup using the event name as hash and a custom match fct. */
1522 cds_lfht_lookup(ht->ht, ht->hash_fct((void *) name, lttng_ht_seed),
1523 ht_match_ust_app_event, &key, &iter.iter);
1524 node = lttng_ht_iter_get_node_str(&iter);
1525 if (node == NULL) {
1526 goto end;
1527 }
1528
1529 event = caa_container_of(node, struct ust_app_event, node);
1530
1531 end:
1532 return event;
1533 }
1534
1535 /*
1536 * Look-up an event notifier rule based on its token id.
1537 *
1538 * Must be called with the RCU read lock held.
1539 * Return an ust_app_event_notifier_rule object or NULL on error.
1540 */
1541 static struct ust_app_event_notifier_rule *find_ust_app_event_notifier_rule(
1542 struct lttng_ht *ht, uint64_t token)
1543 {
1544 struct lttng_ht_iter iter;
1545 struct lttng_ht_node_u64 *node;
1546 struct ust_app_event_notifier_rule *event_notifier_rule = NULL;
1547
1548 LTTNG_ASSERT(ht);
1549
1550 lttng_ht_lookup(ht, &token, &iter);
1551 node = lttng_ht_iter_get_node_u64(&iter);
1552 if (node == NULL) {
1553 DBG2("UST app event notifier rule token not found: token = %" PRIu64,
1554 token);
1555 goto end;
1556 }
1557
1558 event_notifier_rule = caa_container_of(
1559 node, struct ust_app_event_notifier_rule, node);
1560 end:
1561 return event_notifier_rule;
1562 }
1563
1564 /*
1565 * Create the channel context on the tracer.
1566 *
1567 * Called with UST app session lock held.
1568 */
1569 static
1570 int create_ust_channel_context(struct ust_app_channel *ua_chan,
1571 struct ust_app_ctx *ua_ctx, struct ust_app *app)
1572 {
1573 int ret;
1574
1575 health_code_update();
1576
1577 pthread_mutex_lock(&app->sock_lock);
1578 ret = lttng_ust_ctl_add_context(app->sock, &ua_ctx->ctx,
1579 ua_chan->obj, &ua_ctx->obj);
1580 pthread_mutex_unlock(&app->sock_lock);
1581 if (ret < 0) {
1582 if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
1583 ret = 0;
1584 DBG3("UST app create channel context failed. Application is dead: pid = %d, sock = %d",
1585 app->pid, app->sock);
1586 } else if (ret == -EAGAIN) {
1587 ret = 0;
1588 WARN("UST app create channel context failed. Communication time out: pid = %d, sock = %d",
1589 app->pid, app->sock);
1590 } else {
1591 ERR("UST app create channel context failed with ret %d: pid = %d, sock = %d",
1592 ret, app->pid, app->sock);
1593 }
1594 goto error;
1595 }
1596
1597 ua_ctx->handle = ua_ctx->obj->handle;
1598
1599 DBG2("UST app context handle %d created successfully for channel %s",
1600 ua_ctx->handle, ua_chan->name);
1601
1602 error:
1603 health_code_update();
1604 return ret;
1605 }
1606
1607 /*
1608 * Set the filter on the tracer.
1609 */
1610 static int set_ust_object_filter(struct ust_app *app,
1611 const struct lttng_bytecode *bytecode,
1612 struct lttng_ust_abi_object_data *ust_object)
1613 {
1614 int ret;
1615 struct lttng_ust_abi_filter_bytecode *ust_bytecode = NULL;
1616
1617 health_code_update();
1618
1619 ust_bytecode = create_ust_filter_bytecode_from_bytecode(bytecode);
1620 if (!ust_bytecode) {
1621 ret = -LTTNG_ERR_NOMEM;
1622 goto error;
1623 }
1624 pthread_mutex_lock(&app->sock_lock);
1625 ret = lttng_ust_ctl_set_filter(app->sock, ust_bytecode,
1626 ust_object);
1627 pthread_mutex_unlock(&app->sock_lock);
1628 if (ret < 0) {
1629 if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
1630 ret = 0;
1631 DBG3("UST app set filter failed. Application is dead: pid = %d, sock = %d",
1632 app->pid, app->sock);
1633 } else if (ret == -EAGAIN) {
1634 ret = 0;
1635 WARN("UST app set filter failed. Communication time out: pid = %d, sock = %d",
1636 app->pid, app->sock);
1637 } else {
1638 ERR("UST app set filter failed with ret %d: pid = %d, sock = %d, object = %p",
1639 ret, app->pid, app->sock, ust_object);
1640 }
1641 goto error;
1642 }
1643
1644 DBG2("UST filter successfully set: object = %p", ust_object);
1645
1646 error:
1647 health_code_update();
1648 free(ust_bytecode);
1649 return ret;
1650 }
1651
1652 /*
1653 * Set a capture bytecode for the passed object.
1654 * The sequence number enforces the ordering at runtime and on reception of
1655 * the captured payloads.
1656 */
1657 static int set_ust_capture(struct ust_app *app,
1658 const struct lttng_bytecode *bytecode,
1659 unsigned int capture_seqnum,
1660 struct lttng_ust_abi_object_data *ust_object)
1661 {
1662 int ret;
1663 struct lttng_ust_abi_capture_bytecode *ust_bytecode = NULL;
1664
1665 health_code_update();
1666
1667 ust_bytecode = create_ust_capture_bytecode_from_bytecode(bytecode);
1668 if (!ust_bytecode) {
1669 ret = -LTTNG_ERR_NOMEM;
1670 goto error;
1671 }
1672
1673 /*
1674 * Set the sequence number to ensure the capture of fields is ordered.
1675 */
1676 ust_bytecode->seqnum = capture_seqnum;
1677
1678 pthread_mutex_lock(&app->sock_lock);
1679 ret = lttng_ust_ctl_set_capture(app->sock, ust_bytecode,
1680 ust_object);
1681 pthread_mutex_unlock(&app->sock_lock);
1682 if (ret < 0) {
1683 if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
1684 ret = 0;
1685 DBG3("UST app set capture failed. Application is dead: pid = %d, sock = %d",
1686 app->pid, app->sock);
1687 } else if (ret == -EAGAIN) {
1688 ret = 0;
1689 DBG3("UST app set capture failed. Communication timeout: pid = %d, sock = %d",
1690 app->pid, app->sock);
1691 } else {
1692 ERR("UST app event set capture failed with ret %d: pid = %d, sock = %d",
1693 ret, app->pid,
1694 app->sock);
1695 }
1696
1697 goto error;
1698 }
1699
1700 DBG2("UST capture successfully set: object = %p", ust_object);
1701
1702 error:
1703 health_code_update();
1704 free(ust_bytecode);
1705 return ret;
1706 }
1707
1708 static
1709 struct lttng_ust_abi_event_exclusion *create_ust_exclusion_from_exclusion(
1710 const struct lttng_event_exclusion *exclusion)
1711 {
1712 struct lttng_ust_abi_event_exclusion *ust_exclusion = NULL;
1713 size_t exclusion_alloc_size = sizeof(struct lttng_ust_abi_event_exclusion) +
1714 LTTNG_UST_ABI_SYM_NAME_LEN * exclusion->count;
1715
1716 ust_exclusion = (lttng_ust_abi_event_exclusion *) zmalloc(exclusion_alloc_size);
1717 if (!ust_exclusion) {
1718 PERROR("malloc");
1719 goto end;
1720 }
1721
1722 LTTNG_ASSERT(sizeof(struct lttng_event_exclusion) ==
1723 sizeof(struct lttng_ust_abi_event_exclusion));
1724 memcpy(ust_exclusion, exclusion, exclusion_alloc_size);
1725 end:
1726 return ust_exclusion;
1727 }
1728
1729 /*
1730 * Set event exclusions on the tracer.
1731 */
1732 static int set_ust_object_exclusions(struct ust_app *app,
1733 const struct lttng_event_exclusion *exclusions,
1734 struct lttng_ust_abi_object_data *ust_object)
1735 {
1736 int ret;
1737 struct lttng_ust_abi_event_exclusion *ust_exclusions = NULL;
1738
1739 LTTNG_ASSERT(exclusions && exclusions->count > 0);
1740
1741 health_code_update();
1742
1743 ust_exclusions = create_ust_exclusion_from_exclusion(
1744 exclusions);
1745 if (!ust_exclusions) {
1746 ret = -LTTNG_ERR_NOMEM;
1747 goto error;
1748 }
1749 pthread_mutex_lock(&app->sock_lock);
1750 ret = lttng_ust_ctl_set_exclusion(app->sock, ust_exclusions, ust_object);
1751 pthread_mutex_unlock(&app->sock_lock);
1752 if (ret < 0) {
1753 if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
1754 ret = 0;
1755 DBG3("UST app event exclusion failed. Application is dead: pid = %d, sock = %d",
1756 app->pid, app->sock);
1757 } else if (ret == -EAGAIN) {
1758 ret = 0;
1759 WARN("UST app event exclusion failed. Communication time out(pid: %d, sock = %d",
1760 app->pid, app->sock);
1761 } else {
1762 ERR("UST app event exclusions failed with ret %d: pid = %d, sock = %d, object = %p",
1763 ret, app->pid, app->sock, ust_object);
1764 }
1765 goto error;
1766 }
1767
1768 DBG2("UST exclusions set successfully for object %p", ust_object);
1769
1770 error:
1771 health_code_update();
1772 free(ust_exclusions);
1773 return ret;
1774 }
1775
1776 /*
1777 * Disable the specified event on to UST tracer for the UST session.
1778 */
1779 static int disable_ust_object(struct ust_app *app,
1780 struct lttng_ust_abi_object_data *object)
1781 {
1782 int ret;
1783
1784 health_code_update();
1785
1786 pthread_mutex_lock(&app->sock_lock);
1787 ret = lttng_ust_ctl_disable(app->sock, object);
1788 pthread_mutex_unlock(&app->sock_lock);
1789 if (ret < 0) {
1790 if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
1791 ret = 0;
1792 DBG3("UST app disable object failed. Application is dead: pid = %d, sock = %d",
1793 app->pid, app->sock);
1794 } else if (ret == -EAGAIN) {
1795 ret = 0;
1796 WARN("UST app disable object failed. Communication time out: pid = %d, sock = %d",
1797 app->pid, app->sock);
1798 } else {
1799 ERR("UST app disable object failed with ret %d: pid = %d, sock = %d, object = %p",
1800 ret, app->pid, app->sock, object);
1801 }
1802 goto error;
1803 }
1804
1805 DBG2("UST app object %p disabled successfully for app: pid = %d",
1806 object, app->pid);
1807
1808 error:
1809 health_code_update();
1810 return ret;
1811 }
1812
1813 /*
1814 * Disable the specified channel on to UST tracer for the UST session.
1815 */
1816 static int disable_ust_channel(struct ust_app *app,
1817 struct ust_app_session *ua_sess, struct ust_app_channel *ua_chan)
1818 {
1819 int ret;
1820
1821 health_code_update();
1822
1823 pthread_mutex_lock(&app->sock_lock);
1824 ret = lttng_ust_ctl_disable(app->sock, ua_chan->obj);
1825 pthread_mutex_unlock(&app->sock_lock);
1826 if (ret < 0) {
1827 if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
1828 ret = 0;
1829 DBG3("UST app disable channel failed. Application is dead: pid = %d, sock = %d",
1830 app->pid, app->sock);
1831 } else if (ret == -EAGAIN) {
1832 ret = 0;
1833 WARN("UST app disable channel failed. Communication time out: pid = %d, sock = %d",
1834 app->pid, app->sock);
1835 } else {
1836 ERR("UST app channel %s disable failed, session handle %d, with ret %d: pid = %d, sock = %d",
1837 ua_chan->name, ua_sess->handle, ret,
1838 app->pid, app->sock);
1839 }
1840 goto error;
1841 }
1842
1843 DBG2("UST app channel %s disabled successfully for app: pid = %d",
1844 ua_chan->name, app->pid);
1845
1846 error:
1847 health_code_update();
1848 return ret;
1849 }
1850
1851 /*
1852 * Enable the specified channel on to UST tracer for the UST session.
1853 */
1854 static int enable_ust_channel(struct ust_app *app,
1855 struct ust_app_session *ua_sess, struct ust_app_channel *ua_chan)
1856 {
1857 int ret;
1858
1859 health_code_update();
1860
1861 pthread_mutex_lock(&app->sock_lock);
1862 ret = lttng_ust_ctl_enable(app->sock, ua_chan->obj);
1863 pthread_mutex_unlock(&app->sock_lock);
1864 if (ret < 0) {
1865 if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
1866 ret = 0;
1867 DBG3("UST app channel %s enable failed. Application is dead: pid = %d, sock = %d",
1868 ua_chan->name, app->pid, app->sock);
1869 } else if (ret == -EAGAIN) {
1870 ret = 0;
1871 WARN("UST app channel %s enable failed. Communication time out: pid = %d, sock = %d",
1872 ua_chan->name, app->pid, app->sock);
1873 } else {
1874 ERR("UST app channel %s enable failed, session handle %d, with ret %d: pid = %d, sock = %d",
1875 ua_chan->name, ua_sess->handle, ret,
1876 app->pid, app->sock);
1877 }
1878 goto error;
1879 }
1880
1881 ua_chan->enabled = 1;
1882
1883 DBG2("UST app channel %s enabled successfully for app: pid = %d",
1884 ua_chan->name, app->pid);
1885
1886 error:
1887 health_code_update();
1888 return ret;
1889 }
1890
1891 /*
1892 * Enable the specified event on to UST tracer for the UST session.
1893 */
1894 static int enable_ust_object(
1895 struct ust_app *app, struct lttng_ust_abi_object_data *ust_object)
1896 {
1897 int ret;
1898
1899 health_code_update();
1900
1901 pthread_mutex_lock(&app->sock_lock);
1902 ret = lttng_ust_ctl_enable(app->sock, ust_object);
1903 pthread_mutex_unlock(&app->sock_lock);
1904 if (ret < 0) {
1905 if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
1906 ret = 0;
1907 DBG3("UST app enable object failed. Application is dead: pid = %d, sock = %d",
1908 app->pid, app->sock);
1909 } else if (ret == -EAGAIN) {
1910 ret = 0;
1911 WARN("UST app enable object failed. Communication time out: pid = %d, sock = %d",
1912 app->pid, app->sock);
1913 } else {
1914 ERR("UST app enable object failed with ret %d: pid = %d, sock = %d, object = %p",
1915 ret, app->pid, app->sock, ust_object);
1916 }
1917 goto error;
1918 }
1919
1920 DBG2("UST app object %p enabled successfully for app: pid = %d",
1921 ust_object, app->pid);
1922
1923 error:
1924 health_code_update();
1925 return ret;
1926 }
1927
1928 /*
1929 * Send channel and stream buffer to application.
1930 *
1931 * Return 0 on success. On error, a negative value is returned.
1932 */
1933 static int send_channel_pid_to_ust(struct ust_app *app,
1934 struct ust_app_session *ua_sess, struct ust_app_channel *ua_chan)
1935 {
1936 int ret;
1937 struct ust_app_stream *stream, *stmp;
1938
1939 LTTNG_ASSERT(app);
1940 LTTNG_ASSERT(ua_sess);
1941 LTTNG_ASSERT(ua_chan);
1942
1943 health_code_update();
1944
1945 DBG("UST app sending channel %s to UST app sock %d", ua_chan->name,
1946 app->sock);
1947
1948 /* Send channel to the application. */
1949 ret = ust_consumer_send_channel_to_ust(app, ua_sess, ua_chan);
1950 if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
1951 ret = -ENOTCONN; /* Caused by app exiting. */
1952 goto error;
1953 } else if (ret == -EAGAIN) {
1954 /* Caused by timeout. */
1955 WARN("Communication with application %d timed out on send_channel for channel \"%s\" of session \"%" PRIu64 "\".",
1956 app->pid, ua_chan->name, ua_sess->tracing_id);
1957 /* Treat this the same way as an application that is exiting. */
1958 ret = -ENOTCONN;
1959 goto error;
1960 } else if (ret < 0) {
1961 goto error;
1962 }
1963
1964 health_code_update();
1965
1966 /* Send all streams to application. */
1967 cds_list_for_each_entry_safe(stream, stmp, &ua_chan->streams.head, list) {
1968 ret = ust_consumer_send_stream_to_ust(app, ua_chan, stream);
1969 if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
1970 ret = -ENOTCONN; /* Caused by app exiting. */
1971 goto error;
1972 } else if (ret == -EAGAIN) {
1973 /* Caused by timeout. */
1974 WARN("Communication with application %d timed out on send_stream for stream \"%s\" of channel \"%s\" of session \"%" PRIu64 "\".",
1975 app->pid, stream->name, ua_chan->name,
1976 ua_sess->tracing_id);
1977 /*
1978 * Treat this the same way as an application that is
1979 * exiting.
1980 */
1981 ret = -ENOTCONN;
1982 } else if (ret < 0) {
1983 goto error;
1984 }
1985 /* We don't need the stream anymore once sent to the tracer. */
1986 cds_list_del(&stream->list);
1987 delete_ust_app_stream(-1, stream, app);
1988 }
1989 /* Flag the channel that it is sent to the application. */
1990 ua_chan->is_sent = 1;
1991
1992 error:
1993 health_code_update();
1994 return ret;
1995 }
1996
1997 /*
1998 * Create the specified event onto the UST tracer for a UST session.
1999 *
2000 * Should be called with session mutex held.
2001 */
2002 static
2003 int create_ust_event(struct ust_app *app, struct ust_app_session *ua_sess,
2004 struct ust_app_channel *ua_chan, struct ust_app_event *ua_event)
2005 {
2006 int ret = 0;
2007
2008 health_code_update();
2009
2010 /* Create UST event on tracer */
2011 pthread_mutex_lock(&app->sock_lock);
2012 ret = lttng_ust_ctl_create_event(app->sock, &ua_event->attr, ua_chan->obj,
2013 &ua_event->obj);
2014 pthread_mutex_unlock(&app->sock_lock);
2015 if (ret < 0) {
2016 if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
2017 ret = 0;
2018 DBG3("UST app create event failed. Application is dead: pid = %d, sock = %d",
2019 app->pid, app->sock);
2020 } else if (ret == -EAGAIN) {
2021 ret = 0;
2022 WARN("UST app create event failed. Communication time out: pid = %d, sock = %d",
2023 app->pid, app->sock);
2024 } else {
2025 ERR("UST app create event '%s' failed with ret %d: pid = %d, sock = %d",
2026 ua_event->attr.name, ret, app->pid,
2027 app->sock);
2028 }
2029 goto error;
2030 }
2031
2032 ua_event->handle = ua_event->obj->handle;
2033
2034 DBG2("UST app event %s created successfully for pid:%d object = %p",
2035 ua_event->attr.name, app->pid, ua_event->obj);
2036
2037 health_code_update();
2038
2039 /* Set filter if one is present. */
2040 if (ua_event->filter) {
2041 ret = set_ust_object_filter(app, ua_event->filter, ua_event->obj);
2042 if (ret < 0) {
2043 goto error;
2044 }
2045 }
2046
2047 /* Set exclusions for the event */
2048 if (ua_event->exclusion) {
2049 ret = set_ust_object_exclusions(app, ua_event->exclusion, ua_event->obj);
2050 if (ret < 0) {
2051 goto error;
2052 }
2053 }
2054
2055 /* If event not enabled, disable it on the tracer */
2056 if (ua_event->enabled) {
2057 /*
2058 * We now need to explicitly enable the event, since it
2059 * is now disabled at creation.
2060 */
2061 ret = enable_ust_object(app, ua_event->obj);
2062 if (ret < 0) {
2063 /*
2064 * If we hit an EPERM, something is wrong with our enable call. If
2065 * we get an EEXIST, there is a problem on the tracer side since we
2066 * just created it.
2067 */
2068 switch (ret) {
2069 case -LTTNG_UST_ERR_PERM:
2070 /* Code flow problem */
2071 abort();
2072 case -LTTNG_UST_ERR_EXIST:
2073 /* It's OK for our use case. */
2074 ret = 0;
2075 break;
2076 default:
2077 break;
2078 }
2079 goto error;
2080 }
2081 }
2082
2083 error:
2084 health_code_update();
2085 return ret;
2086 }
2087
2088 static int init_ust_event_notifier_from_event_rule(
2089 const struct lttng_event_rule *rule,
2090 struct lttng_ust_abi_event_notifier *event_notifier)
2091 {
2092 enum lttng_event_rule_status status;
2093 enum lttng_ust_abi_loglevel_type ust_loglevel_type = LTTNG_UST_ABI_LOGLEVEL_ALL;
2094 int loglevel = -1, ret = 0;
2095 const char *pattern;
2096
2097
2098 memset(event_notifier, 0, sizeof(*event_notifier));
2099
2100 if (lttng_event_rule_targets_agent_domain(rule)) {
2101 /*
2102 * Special event for agents
2103 * The actual meat of the event is in the filter that will be
2104 * attached later on.
2105 * Set the default values for the agent event.
2106 */
2107 pattern = event_get_default_agent_ust_name(
2108 lttng_event_rule_get_domain_type(rule));
2109 loglevel = 0;
2110 ust_loglevel_type = LTTNG_UST_ABI_LOGLEVEL_ALL;
2111 } else {
2112 const struct lttng_log_level_rule *log_level_rule;
2113
2114 LTTNG_ASSERT(lttng_event_rule_get_type(rule) ==
2115 LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT);
2116
2117 status = lttng_event_rule_user_tracepoint_get_name_pattern(rule, &pattern);
2118 if (status != LTTNG_EVENT_RULE_STATUS_OK) {
2119 /* At this point, this is a fatal error. */
2120 abort();
2121 }
2122
2123 status = lttng_event_rule_user_tracepoint_get_log_level_rule(
2124 rule, &log_level_rule);
2125 if (status == LTTNG_EVENT_RULE_STATUS_UNSET) {
2126 ust_loglevel_type = LTTNG_UST_ABI_LOGLEVEL_ALL;
2127 } else if (status == LTTNG_EVENT_RULE_STATUS_OK) {
2128 enum lttng_log_level_rule_status llr_status;
2129
2130 switch (lttng_log_level_rule_get_type(log_level_rule)) {
2131 case LTTNG_LOG_LEVEL_RULE_TYPE_EXACTLY:
2132 ust_loglevel_type = LTTNG_UST_ABI_LOGLEVEL_SINGLE;
2133 llr_status = lttng_log_level_rule_exactly_get_level(
2134 log_level_rule, &loglevel);
2135 break;
2136 case LTTNG_LOG_LEVEL_RULE_TYPE_AT_LEAST_AS_SEVERE_AS:
2137 ust_loglevel_type = LTTNG_UST_ABI_LOGLEVEL_RANGE;
2138 llr_status = lttng_log_level_rule_at_least_as_severe_as_get_level(
2139 log_level_rule, &loglevel);
2140 break;
2141 default:
2142 abort();
2143 }
2144
2145 LTTNG_ASSERT(llr_status == LTTNG_LOG_LEVEL_RULE_STATUS_OK);
2146 } else {
2147 /* At this point this is a fatal error. */
2148 abort();
2149 }
2150 }
2151
2152 event_notifier->event.instrumentation = LTTNG_UST_ABI_TRACEPOINT;
2153 ret = lttng_strncpy(event_notifier->event.name, pattern,
2154 LTTNG_UST_ABI_SYM_NAME_LEN - 1);
2155 if (ret) {
2156 ERR("Failed to copy event rule pattern to notifier: pattern = '%s' ",
2157 pattern);
2158 goto end;
2159 }
2160
2161 event_notifier->event.loglevel_type = ust_loglevel_type;
2162 event_notifier->event.loglevel = loglevel;
2163 end:
2164 return ret;
2165 }
2166
2167 /*
2168 * Create the specified event notifier against the user space tracer of a
2169 * given application.
2170 */
2171 static int create_ust_event_notifier(struct ust_app *app,
2172 struct ust_app_event_notifier_rule *ua_event_notifier_rule)
2173 {
2174 int ret = 0;
2175 enum lttng_condition_status condition_status;
2176 const struct lttng_condition *condition = NULL;
2177 struct lttng_ust_abi_event_notifier event_notifier;
2178 const struct lttng_event_rule *event_rule = NULL;
2179 unsigned int capture_bytecode_count = 0, i;
2180 enum lttng_condition_status cond_status;
2181 enum lttng_event_rule_type event_rule_type;
2182
2183 health_code_update();
2184 LTTNG_ASSERT(app->event_notifier_group.object);
2185
2186 condition = lttng_trigger_get_const_condition(
2187 ua_event_notifier_rule->trigger);
2188 LTTNG_ASSERT(condition);
2189 LTTNG_ASSERT(lttng_condition_get_type(condition) ==
2190 LTTNG_CONDITION_TYPE_EVENT_RULE_MATCHES);
2191
2192 condition_status = lttng_condition_event_rule_matches_get_rule(
2193 condition, &event_rule);
2194 LTTNG_ASSERT(condition_status == LTTNG_CONDITION_STATUS_OK);
2195
2196 LTTNG_ASSERT(event_rule);
2197
2198 event_rule_type = lttng_event_rule_get_type(event_rule);
2199 LTTNG_ASSERT(event_rule_type == LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT ||
2200 event_rule_type == LTTNG_EVENT_RULE_TYPE_JUL_LOGGING ||
2201 event_rule_type ==
2202 LTTNG_EVENT_RULE_TYPE_LOG4J_LOGGING ||
2203 event_rule_type ==
2204 LTTNG_EVENT_RULE_TYPE_PYTHON_LOGGING);
2205
2206 init_ust_event_notifier_from_event_rule(event_rule, &event_notifier);
2207 event_notifier.event.token = ua_event_notifier_rule->token;
2208 event_notifier.error_counter_index = ua_event_notifier_rule->error_counter_index;
2209
2210 /* Create UST event notifier against the tracer. */
2211 pthread_mutex_lock(&app->sock_lock);
2212 ret = lttng_ust_ctl_create_event_notifier(app->sock, &event_notifier,
2213 app->event_notifier_group.object,
2214 &ua_event_notifier_rule->obj);
2215 pthread_mutex_unlock(&app->sock_lock);
2216 if (ret < 0) {
2217 if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
2218 ret = 0;
2219 DBG3("UST app create event notifier failed. Application is dead: pid = %d, sock = %d",
2220 app->pid, app->sock);
2221 } else if (ret == -EAGAIN) {
2222 ret = 0;
2223 WARN("UST app create event notifier failed. Communication time out: pid = %d, sock = %d",
2224 app->pid, app->sock);
2225 } else {
2226 ERR("UST app create event notifier '%s' failed with ret %d: pid = %d, sock = %d",
2227 event_notifier.event.name, ret, app->pid,
2228 app->sock);
2229 }
2230 goto error;
2231 }
2232
2233 ua_event_notifier_rule->handle = ua_event_notifier_rule->obj->handle;
2234
2235 DBG2("UST app event notifier %s created successfully: app = '%s': pid = %d, object = %p",
2236 event_notifier.event.name, app->name, app->pid,
2237 ua_event_notifier_rule->obj);
2238
2239 health_code_update();
2240
2241 /* Set filter if one is present. */
2242 if (ua_event_notifier_rule->filter) {
2243 ret = set_ust_object_filter(app, ua_event_notifier_rule->filter,
2244 ua_event_notifier_rule->obj);
2245 if (ret < 0) {
2246 goto error;
2247 }
2248 }
2249
2250 /* Set exclusions for the event. */
2251 if (ua_event_notifier_rule->exclusion) {
2252 ret = set_ust_object_exclusions(app,
2253 ua_event_notifier_rule->exclusion,
2254 ua_event_notifier_rule->obj);
2255 if (ret < 0) {
2256 goto error;
2257 }
2258 }
2259
2260 /* Set the capture bytecodes. */
2261 cond_status = lttng_condition_event_rule_matches_get_capture_descriptor_count(
2262 condition, &capture_bytecode_count);
2263 LTTNG_ASSERT(cond_status == LTTNG_CONDITION_STATUS_OK);
2264
2265 for (i = 0; i < capture_bytecode_count; i++) {
2266 const struct lttng_bytecode *capture_bytecode =
2267 lttng_condition_event_rule_matches_get_capture_bytecode_at_index(
2268 condition, i);
2269
2270 ret = set_ust_capture(app, capture_bytecode, i,
2271 ua_event_notifier_rule->obj);
2272 if (ret < 0) {
2273 goto error;
2274 }
2275 }
2276
2277 /*
2278 * We now need to explicitly enable the event, since it
2279 * is disabled at creation.
2280 */
2281 ret = enable_ust_object(app, ua_event_notifier_rule->obj);
2282 if (ret < 0) {
2283 /*
2284 * If we hit an EPERM, something is wrong with our enable call.
2285 * If we get an EEXIST, there is a problem on the tracer side
2286 * since we just created it.
2287 */
2288 switch (ret) {
2289 case -LTTNG_UST_ERR_PERM:
2290 /* Code flow problem. */
2291 abort();
2292 case -LTTNG_UST_ERR_EXIST:
2293 /* It's OK for our use case. */
2294 ret = 0;
2295 break;
2296 default:
2297 break;
2298 }
2299
2300 goto error;
2301 }
2302
2303 ua_event_notifier_rule->enabled = true;
2304
2305 error:
2306 health_code_update();
2307 return ret;
2308 }
2309
2310 /*
2311 * Copy data between an UST app event and a LTT event.
2312 */
2313 static void shadow_copy_event(struct ust_app_event *ua_event,
2314 struct ltt_ust_event *uevent)
2315 {
2316 size_t exclusion_alloc_size;
2317
2318 strncpy(ua_event->name, uevent->attr.name, sizeof(ua_event->name));
2319 ua_event->name[sizeof(ua_event->name) - 1] = '\0';
2320
2321 ua_event->enabled = uevent->enabled;
2322
2323 /* Copy event attributes */
2324 memcpy(&ua_event->attr, &uevent->attr, sizeof(ua_event->attr));
2325
2326 /* Copy filter bytecode */
2327 if (uevent->filter) {
2328 ua_event->filter = lttng_bytecode_copy(uevent->filter);
2329 /* Filter might be NULL here in case of ENONEM. */
2330 }
2331
2332 /* Copy exclusion data */
2333 if (uevent->exclusion) {
2334 exclusion_alloc_size = sizeof(struct lttng_event_exclusion) +
2335 LTTNG_UST_ABI_SYM_NAME_LEN * uevent->exclusion->count;
2336 ua_event->exclusion = (lttng_event_exclusion *) zmalloc(exclusion_alloc_size);
2337 if (ua_event->exclusion == NULL) {
2338 PERROR("malloc");
2339 } else {
2340 memcpy(ua_event->exclusion, uevent->exclusion,
2341 exclusion_alloc_size);
2342 }
2343 }
2344 }
2345
2346 /*
2347 * Copy data between an UST app channel and a LTT channel.
2348 */
2349 static void shadow_copy_channel(struct ust_app_channel *ua_chan,
2350 struct ltt_ust_channel *uchan)
2351 {
2352 DBG2("UST app shadow copy of channel %s started", ua_chan->name);
2353
2354 strncpy(ua_chan->name, uchan->name, sizeof(ua_chan->name));
2355 ua_chan->name[sizeof(ua_chan->name) - 1] = '\0';
2356
2357 ua_chan->tracefile_size = uchan->tracefile_size;
2358 ua_chan->tracefile_count = uchan->tracefile_count;
2359
2360 /* Copy event attributes since the layout is different. */
2361 ua_chan->attr.subbuf_size = uchan->attr.subbuf_size;
2362 ua_chan->attr.num_subbuf = uchan->attr.num_subbuf;
2363 ua_chan->attr.overwrite = uchan->attr.overwrite;
2364 ua_chan->attr.switch_timer_interval = uchan->attr.switch_timer_interval;
2365 ua_chan->attr.read_timer_interval = uchan->attr.read_timer_interval;
2366 ua_chan->monitor_timer_interval = uchan->monitor_timer_interval;
2367 ua_chan->attr.output = (lttng_ust_abi_output) uchan->attr.output;
2368 ua_chan->attr.blocking_timeout = uchan->attr.u.s.blocking_timeout;
2369
2370 /*
2371 * Note that the attribute channel type is not set since the channel on the
2372 * tracing registry side does not have this information.
2373 */
2374
2375 ua_chan->enabled = uchan->enabled;
2376 ua_chan->tracing_channel_id = uchan->id;
2377
2378 DBG3("UST app shadow copy of channel %s done", ua_chan->name);
2379 }
2380
2381 /*
2382 * Copy data between a UST app session and a regular LTT session.
2383 */
2384 static void shadow_copy_session(struct ust_app_session *ua_sess,
2385 struct ltt_ust_session *usess, struct ust_app *app)
2386 {
2387 struct tm *timeinfo;
2388 char datetime[16];
2389 int ret;
2390 char tmp_shm_path[PATH_MAX];
2391
2392 timeinfo = localtime(&app->registration_time);
2393 strftime(datetime, sizeof(datetime), "%Y%m%d-%H%M%S", timeinfo);
2394
2395 DBG2("Shadow copy of session handle %d", ua_sess->handle);
2396
2397 ua_sess->tracing_id = usess->id;
2398 ua_sess->id = get_next_session_id();
2399 LTTNG_OPTIONAL_SET(&ua_sess->real_credentials.uid, app->uid);
2400 LTTNG_OPTIONAL_SET(&ua_sess->real_credentials.gid, app->gid);
2401 LTTNG_OPTIONAL_SET(&ua_sess->effective_credentials.uid, usess->uid);
2402 LTTNG_OPTIONAL_SET(&ua_sess->effective_credentials.gid, usess->gid);
2403 ua_sess->buffer_type = usess->buffer_type;
2404 ua_sess->bits_per_long = app->bits_per_long;
2405
2406 /* There is only one consumer object per session possible. */
2407 consumer_output_get(usess->consumer);
2408 ua_sess->consumer = usess->consumer;
2409
2410 ua_sess->output_traces = usess->output_traces;
2411 ua_sess->live_timer_interval = usess->live_timer_interval;
2412 copy_channel_attr_to_ustctl(&ua_sess->metadata_attr,
2413 &usess->metadata_attr);
2414
2415 switch (ua_sess->buffer_type) {
2416 case LTTNG_BUFFER_PER_PID:
2417 ret = snprintf(ua_sess->path, sizeof(ua_sess->path),
2418 DEFAULT_UST_TRACE_PID_PATH "/%s-%d-%s", app->name, app->pid,
2419 datetime);
2420 break;
2421 case LTTNG_BUFFER_PER_UID:
2422 ret = snprintf(ua_sess->path, sizeof(ua_sess->path),
2423 DEFAULT_UST_TRACE_UID_PATH,
2424 lttng_credentials_get_uid(&ua_sess->real_credentials),
2425 app->bits_per_long);
2426 break;
2427 default:
2428 abort();
2429 goto error;
2430 }
2431 if (ret < 0) {
2432 PERROR("asprintf UST shadow copy session");
2433 abort();
2434 goto error;
2435 }
2436
2437 strncpy(ua_sess->root_shm_path, usess->root_shm_path,
2438 sizeof(ua_sess->root_shm_path));
2439 ua_sess->root_shm_path[sizeof(ua_sess->root_shm_path) - 1] = '\0';
2440 strncpy(ua_sess->shm_path, usess->shm_path,
2441 sizeof(ua_sess->shm_path));
2442 ua_sess->shm_path[sizeof(ua_sess->shm_path) - 1] = '\0';
2443 if (ua_sess->shm_path[0]) {
2444 switch (ua_sess->buffer_type) {
2445 case LTTNG_BUFFER_PER_PID:
2446 ret = snprintf(tmp_shm_path, sizeof(tmp_shm_path),
2447 "/" DEFAULT_UST_TRACE_PID_PATH "/%s-%d-%s",
2448 app->name, app->pid, datetime);
2449 break;
2450 case LTTNG_BUFFER_PER_UID:
2451 ret = snprintf(tmp_shm_path, sizeof(tmp_shm_path),
2452 "/" DEFAULT_UST_TRACE_UID_PATH,
2453 app->uid, app->bits_per_long);
2454 break;
2455 default:
2456 abort();
2457 goto error;
2458 }
2459 if (ret < 0) {
2460 PERROR("sprintf UST shadow copy session");
2461 abort();
2462 goto error;
2463 }
2464 strncat(ua_sess->shm_path, tmp_shm_path,
2465 sizeof(ua_sess->shm_path) - strlen(ua_sess->shm_path) - 1);
2466 ua_sess->shm_path[sizeof(ua_sess->shm_path) - 1] = '\0';
2467 }
2468 return;
2469
2470 error:
2471 consumer_output_put(ua_sess->consumer);
2472 }
2473
2474 /*
2475 * Lookup sesison wrapper.
2476 */
2477 static
2478 void __lookup_session_by_app(const struct ltt_ust_session *usess,
2479 struct ust_app *app, struct lttng_ht_iter *iter)
2480 {
2481 /* Get right UST app session from app */
2482 lttng_ht_lookup(app->sessions, &usess->id, iter);
2483 }
2484
2485 /*
2486 * Return ust app session from the app session hashtable using the UST session
2487 * id.
2488 */
2489 static struct ust_app_session *lookup_session_by_app(
2490 const struct ltt_ust_session *usess, struct ust_app *app)
2491 {
2492 struct lttng_ht_iter iter;
2493 struct lttng_ht_node_u64 *node;
2494
2495 __lookup_session_by_app(usess, app, &iter);
2496 node = lttng_ht_iter_get_node_u64(&iter);
2497 if (node == NULL) {
2498 goto error;
2499 }
2500
2501 return caa_container_of(node, struct ust_app_session, node);
2502
2503 error:
2504 return NULL;
2505 }
2506
2507 /*
2508 * Setup buffer registry per PID for the given session and application. If none
2509 * is found, a new one is created, added to the global registry and
2510 * initialized. If regp is valid, it's set with the newly created object.
2511 *
2512 * Return 0 on success or else a negative value.
2513 */
2514 static int setup_buffer_reg_pid(struct ust_app_session *ua_sess,
2515 struct ust_app *app, struct buffer_reg_pid **regp)
2516 {
2517 int ret = 0;
2518 struct buffer_reg_pid *reg_pid;
2519
2520 LTTNG_ASSERT(ua_sess);
2521 LTTNG_ASSERT(app);
2522
2523 rcu_read_lock();
2524
2525 reg_pid = buffer_reg_pid_find(ua_sess->id);
2526 if (!reg_pid) {
2527 /*
2528 * This is the create channel path meaning that if there is NO
2529 * registry available, we have to create one for this session.
2530 */
2531 ret = buffer_reg_pid_create(ua_sess->id, &reg_pid,
2532 ua_sess->root_shm_path, ua_sess->shm_path);
2533 if (ret < 0) {
2534 goto error;
2535 }
2536 } else {
2537 goto end;
2538 }
2539
2540 /* Initialize registry. */
2541 ret = ust_registry_session_init(&reg_pid->registry->reg.ust, app,
2542 app->bits_per_long, app->uint8_t_alignment,
2543 app->uint16_t_alignment, app->uint32_t_alignment,
2544 app->uint64_t_alignment, app->long_alignment,
2545 app->byte_order, app->version.major, app->version.minor,
2546 reg_pid->root_shm_path, reg_pid->shm_path,
2547 lttng_credentials_get_uid(&ua_sess->effective_credentials),
2548 lttng_credentials_get_gid(&ua_sess->effective_credentials),
2549 ua_sess->tracing_id,
2550 app->uid);
2551 if (ret < 0) {
2552 /*
2553 * reg_pid->registry->reg.ust is NULL upon error, so we need to
2554 * destroy the buffer registry, because it is always expected
2555 * that if the buffer registry can be found, its ust registry is
2556 * non-NULL.
2557 */
2558 buffer_reg_pid_destroy(reg_pid);
2559 goto error;
2560 }
2561
2562 buffer_reg_pid_add(reg_pid);
2563
2564 DBG3("UST app buffer registry per PID created successfully");
2565
2566 end:
2567 if (regp) {
2568 *regp = reg_pid;
2569 }
2570 error:
2571 rcu_read_unlock();
2572 return ret;
2573 }
2574
2575 /*
2576 * Setup buffer registry per UID for the given session and application. If none
2577 * is found, a new one is created, added to the global registry and
2578 * initialized. If regp is valid, it's set with the newly created object.
2579 *
2580 * Return 0 on success or else a negative value.
2581 */
2582 static int setup_buffer_reg_uid(struct ltt_ust_session *usess,
2583 struct ust_app_session *ua_sess,
2584 struct ust_app *app, struct buffer_reg_uid **regp)
2585 {
2586 int ret = 0;
2587 struct buffer_reg_uid *reg_uid;
2588
2589 LTTNG_ASSERT(usess);
2590 LTTNG_ASSERT(app);
2591
2592 rcu_read_lock();
2593
2594 reg_uid = buffer_reg_uid_find(usess->id, app->bits_per_long, app->uid);
2595 if (!reg_uid) {
2596 /*
2597 * This is the create channel path meaning that if there is NO
2598 * registry available, we have to create one for this session.
2599 */
2600 ret = buffer_reg_uid_create(usess->id, app->bits_per_long, app->uid,
2601 LTTNG_DOMAIN_UST, &reg_uid,
2602 ua_sess->root_shm_path, ua_sess->shm_path);
2603 if (ret < 0) {
2604 goto error;
2605 }
2606 } else {
2607 goto end;
2608 }
2609
2610 /* Initialize registry. */
2611 ret = ust_registry_session_init(&reg_uid->registry->reg.ust, NULL,
2612 app->bits_per_long, app->uint8_t_alignment,
2613 app->uint16_t_alignment, app->uint32_t_alignment,
2614 app->uint64_t_alignment, app->long_alignment,
2615 app->byte_order, app->version.major,
2616 app->version.minor, reg_uid->root_shm_path,
2617 reg_uid->shm_path, usess->uid, usess->gid,
2618 ua_sess->tracing_id, app->uid);
2619 if (ret < 0) {
2620 /*
2621 * reg_uid->registry->reg.ust is NULL upon error, so we need to
2622 * destroy the buffer registry, because it is always expected
2623 * that if the buffer registry can be found, its ust registry is
2624 * non-NULL.
2625 */
2626 buffer_reg_uid_destroy(reg_uid, NULL);
2627 goto error;
2628 }
2629 /* Add node to teardown list of the session. */
2630 cds_list_add(&reg_uid->lnode, &usess->buffer_reg_uid_list);
2631
2632 buffer_reg_uid_add(reg_uid);
2633
2634 DBG3("UST app buffer registry per UID created successfully");
2635 end:
2636 if (regp) {
2637 *regp = reg_uid;
2638 }
2639 error:
2640 rcu_read_unlock();
2641 return ret;
2642 }
2643
2644 /*
2645 * Create a session on the tracer side for the given app.
2646 *
2647 * On success, ua_sess_ptr is populated with the session pointer or else left
2648 * untouched. If the session was created, is_created is set to 1. On error,
2649 * it's left untouched. Note that ua_sess_ptr is mandatory but is_created can
2650 * be NULL.
2651 *
2652 * Returns 0 on success or else a negative code which is either -ENOMEM or
2653 * -ENOTCONN which is the default code if the lttng_ust_ctl_create_session fails.
2654 */
2655 static int find_or_create_ust_app_session(struct ltt_ust_session *usess,
2656 struct ust_app *app, struct ust_app_session **ua_sess_ptr,
2657 int *is_created)
2658 {
2659 int ret, created = 0;
2660 struct ust_app_session *ua_sess;
2661
2662 LTTNG_ASSERT(usess);
2663 LTTNG_ASSERT(app);
2664 LTTNG_ASSERT(ua_sess_ptr);
2665
2666 health_code_update();
2667
2668 ua_sess = lookup_session_by_app(usess, app);
2669 if (ua_sess == NULL) {
2670 DBG2("UST app pid: %d session id %" PRIu64 " not found, creating it",
2671 app->pid, usess->id);
2672 ua_sess = alloc_ust_app_session();
2673 if (ua_sess == NULL) {
2674 /* Only malloc can failed so something is really wrong */
2675 ret = -ENOMEM;
2676 goto error;
2677 }
2678 shadow_copy_session(ua_sess, usess, app);
2679 created = 1;
2680 }
2681
2682 switch (usess->buffer_type) {
2683 case LTTNG_BUFFER_PER_PID:
2684 /* Init local registry. */
2685 ret = setup_buffer_reg_pid(ua_sess, app, NULL);
2686 if (ret < 0) {
2687 delete_ust_app_session(-1, ua_sess, app);
2688 goto error;
2689 }
2690 break;
2691 case LTTNG_BUFFER_PER_UID:
2692 /* Look for a global registry. If none exists, create one. */
2693 ret = setup_buffer_reg_uid(usess, ua_sess, app, NULL);
2694 if (ret < 0) {
2695 delete_ust_app_session(-1, ua_sess, app);
2696 goto error;
2697 }
2698 break;
2699 default:
2700 abort();
2701 ret = -EINVAL;
2702 goto error;
2703 }
2704
2705 health_code_update();
2706
2707 if (ua_sess->handle == -1) {
2708 pthread_mutex_lock(&app->sock_lock);
2709 ret = lttng_ust_ctl_create_session(app->sock);
2710 pthread_mutex_unlock(&app->sock_lock);
2711 if (ret < 0) {
2712 if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
2713 DBG("UST app creating session failed. Application is dead: pid = %d, sock = %d",
2714 app->pid, app->sock);
2715 ret = 0;
2716 } else if (ret == -EAGAIN) {
2717 DBG("UST app creating session failed. Communication time out: pid = %d, sock = %d",
2718 app->pid, app->sock);
2719 ret = 0;
2720 } else {
2721 ERR("UST app creating session failed with ret %d: pid = %d, sock =%d",
2722 ret, app->pid, app->sock);
2723 }
2724 delete_ust_app_session(-1, ua_sess, app);
2725 if (ret != -ENOMEM) {
2726 /*
2727 * Tracer is probably gone or got an internal error so let's
2728 * behave like it will soon unregister or not usable.
2729 */
2730 ret = -ENOTCONN;
2731 }
2732 goto error;
2733 }
2734
2735 ua_sess->handle = ret;
2736
2737 /* Add ust app session to app's HT */
2738 lttng_ht_node_init_u64(&ua_sess->node,
2739 ua_sess->tracing_id);
2740 lttng_ht_add_unique_u64(app->sessions, &ua_sess->node);
2741 lttng_ht_node_init_ulong(&ua_sess->ust_objd_node, ua_sess->handle);
2742 lttng_ht_add_unique_ulong(app->ust_sessions_objd,
2743 &ua_sess->ust_objd_node);
2744
2745 DBG2("UST app session created successfully with handle %d", ret);
2746 }
2747
2748 *ua_sess_ptr = ua_sess;
2749 if (is_created) {
2750 *is_created = created;
2751 }
2752
2753 /* Everything went well. */
2754 ret = 0;
2755
2756 error:
2757 health_code_update();
2758 return ret;
2759 }
2760
2761 /*
2762 * Match function for a hash table lookup of ust_app_ctx.
2763 *
2764 * It matches an ust app context based on the context type and, in the case
2765 * of perf counters, their name.
2766 */
2767 static int ht_match_ust_app_ctx(struct cds_lfht_node *node, const void *_key)
2768 {
2769 struct ust_app_ctx *ctx;
2770 const struct lttng_ust_context_attr *key;
2771
2772 LTTNG_ASSERT(node);
2773 LTTNG_ASSERT(_key);
2774
2775 ctx = caa_container_of(node, struct ust_app_ctx, node.node);
2776 key = (lttng_ust_context_attr *) _key;
2777
2778 /* Context type */
2779 if (ctx->ctx.ctx != key->ctx) {
2780 goto no_match;
2781 }
2782
2783 switch(key->ctx) {
2784 case LTTNG_UST_ABI_CONTEXT_PERF_THREAD_COUNTER:
2785 if (strncmp(key->u.perf_counter.name,
2786 ctx->ctx.u.perf_counter.name,
2787 sizeof(key->u.perf_counter.name))) {
2788 goto no_match;
2789 }
2790 break;
2791 case LTTNG_UST_ABI_CONTEXT_APP_CONTEXT:
2792 if (strcmp(key->u.app_ctx.provider_name,
2793 ctx->ctx.u.app_ctx.provider_name) ||
2794 strcmp(key->u.app_ctx.ctx_name,
2795 ctx->ctx.u.app_ctx.ctx_name)) {
2796 goto no_match;
2797 }
2798 break;
2799 default:
2800 break;
2801 }
2802
2803 /* Match. */
2804 return 1;
2805
2806 no_match:
2807 return 0;
2808 }
2809
2810 /*
2811 * Lookup for an ust app context from an lttng_ust_context.
2812 *
2813 * Must be called while holding RCU read side lock.
2814 * Return an ust_app_ctx object or NULL on error.
2815 */
2816 static
2817 struct ust_app_ctx *find_ust_app_context(struct lttng_ht *ht,
2818 struct lttng_ust_context_attr *uctx)
2819 {
2820 struct lttng_ht_iter iter;
2821 struct lttng_ht_node_ulong *node;
2822 struct ust_app_ctx *app_ctx = NULL;
2823
2824 LTTNG_ASSERT(uctx);
2825 LTTNG_ASSERT(ht);
2826
2827 /* Lookup using the lttng_ust_context_type and a custom match fct. */
2828 cds_lfht_lookup(ht->ht, ht->hash_fct((void *) uctx->ctx, lttng_ht_seed),
2829 ht_match_ust_app_ctx, uctx, &iter.iter);
2830 node = lttng_ht_iter_get_node_ulong(&iter);
2831 if (!node) {
2832 goto end;
2833 }
2834
2835 app_ctx = caa_container_of(node, struct ust_app_ctx, node);
2836
2837 end:
2838 return app_ctx;
2839 }
2840
2841 /*
2842 * Create a context for the channel on the tracer.
2843 *
2844 * Called with UST app session lock held and a RCU read side lock.
2845 */
2846 static
2847 int create_ust_app_channel_context(struct ust_app_channel *ua_chan,
2848 struct lttng_ust_context_attr *uctx,
2849 struct ust_app *app)
2850 {
2851 int ret = 0;
2852 struct ust_app_ctx *ua_ctx;
2853
2854 DBG2("UST app adding context to channel %s", ua_chan->name);
2855
2856 ua_ctx = find_ust_app_context(ua_chan->ctx, uctx);
2857 if (ua_ctx) {
2858 ret = -EEXIST;
2859 goto error;
2860 }
2861
2862 ua_ctx = alloc_ust_app_ctx(uctx);
2863 if (ua_ctx == NULL) {
2864 /* malloc failed */
2865 ret = -ENOMEM;
2866 goto error;
2867 }
2868
2869 lttng_ht_node_init_ulong(&ua_ctx->node, (unsigned long) ua_ctx->ctx.ctx);
2870 lttng_ht_add_ulong(ua_chan->ctx, &ua_ctx->node);
2871 cds_list_add_tail(&ua_ctx->list, &ua_chan->ctx_list);
2872
2873 ret = create_ust_channel_context(ua_chan, ua_ctx, app);
2874 if (ret < 0) {
2875 goto error;
2876 }
2877
2878 error:
2879 return ret;
2880 }
2881
2882 /*
2883 * Enable on the tracer side a ust app event for the session and channel.
2884 *
2885 * Called with UST app session lock held.
2886 */
2887 static
2888 int enable_ust_app_event(struct ust_app_session *ua_sess,
2889 struct ust_app_event *ua_event, struct ust_app *app)
2890 {
2891 int ret;
2892
2893 ret = enable_ust_object(app, ua_event->obj);
2894 if (ret < 0) {
2895 goto error;
2896 }
2897
2898 ua_event->enabled = 1;
2899
2900 error:
2901 return ret;
2902 }
2903
2904 /*
2905 * Disable on the tracer side a ust app event for the session and channel.
2906 */
2907 static int disable_ust_app_event(struct ust_app_session *ua_sess,
2908 struct ust_app_event *ua_event, struct ust_app *app)
2909 {
2910 int ret;
2911
2912 ret = disable_ust_object(app, ua_event->obj);
2913 if (ret < 0) {
2914 goto error;
2915 }
2916
2917 ua_event->enabled = 0;
2918
2919 error:
2920 return ret;
2921 }
2922
2923 /*
2924 * Lookup ust app channel for session and disable it on the tracer side.
2925 */
2926 static
2927 int disable_ust_app_channel(struct ust_app_session *ua_sess,
2928 struct ust_app_channel *ua_chan, struct ust_app *app)
2929 {
2930 int ret;
2931
2932 ret = disable_ust_channel(app, ua_sess, ua_chan);
2933 if (ret < 0) {
2934 goto error;
2935 }
2936
2937 ua_chan->enabled = 0;
2938
2939 error:
2940 return ret;
2941 }
2942
2943 /*
2944 * Lookup ust app channel for session and enable it on the tracer side. This
2945 * MUST be called with a RCU read side lock acquired.
2946 */
2947 static int enable_ust_app_channel(struct ust_app_session *ua_sess,
2948 struct ltt_ust_channel *uchan, struct ust_app *app)
2949 {
2950 int ret = 0;
2951 struct lttng_ht_iter iter;
2952 struct lttng_ht_node_str *ua_chan_node;
2953 struct ust_app_channel *ua_chan;
2954
2955 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &iter);
2956 ua_chan_node = lttng_ht_iter_get_node_str(&iter);
2957 if (ua_chan_node == NULL) {
2958 DBG2("Unable to find channel %s in ust session id %" PRIu64,
2959 uchan->name, ua_sess->tracing_id);
2960 goto error;
2961 }
2962
2963 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
2964
2965 ret = enable_ust_channel(app, ua_sess, ua_chan);
2966 if (ret < 0) {
2967 goto error;
2968 }
2969
2970 error:
2971 return ret;
2972 }
2973
2974 /*
2975 * Ask the consumer to create a channel and get it if successful.
2976 *
2977 * Called with UST app session lock held.
2978 *
2979 * Return 0 on success or else a negative value.
2980 */
2981 static int do_consumer_create_channel(struct ltt_ust_session *usess,
2982 struct ust_app_session *ua_sess, struct ust_app_channel *ua_chan,
2983 int bitness, struct ust_registry_session *registry,
2984 uint64_t trace_archive_id)
2985 {
2986 int ret;
2987 unsigned int nb_fd = 0;
2988 struct consumer_socket *socket;
2989
2990 LTTNG_ASSERT(usess);
2991 LTTNG_ASSERT(ua_sess);
2992 LTTNG_ASSERT(ua_chan);
2993 LTTNG_ASSERT(registry);
2994
2995 rcu_read_lock();
2996 health_code_update();
2997
2998 /* Get the right consumer socket for the application. */
2999 socket = consumer_find_socket_by_bitness(bitness, usess->consumer);
3000 if (!socket) {
3001 ret = -EINVAL;
3002 goto error;
3003 }
3004
3005 health_code_update();
3006
3007 /* Need one fd for the channel. */
3008 ret = lttng_fd_get(LTTNG_FD_APPS, 1);
3009 if (ret < 0) {
3010 ERR("Exhausted number of available FD upon create channel");
3011 goto error;
3012 }
3013
3014 /*
3015 * Ask consumer to create channel. The consumer will return the number of
3016 * stream we have to expect.
3017 */
3018 ret = ust_consumer_ask_channel(ua_sess, ua_chan, usess->consumer, socket,
3019 registry, usess->current_trace_chunk);
3020 if (ret < 0) {
3021 goto error_ask;
3022 }
3023
3024 /*
3025 * Compute the number of fd needed before receiving them. It must be 2 per
3026 * stream (2 being the default value here).
3027 */
3028 nb_fd = DEFAULT_UST_STREAM_FD_NUM * ua_chan->expected_stream_count;
3029
3030 /* Reserve the amount of file descriptor we need. */
3031 ret = lttng_fd_get(LTTNG_FD_APPS, nb_fd);
3032 if (ret < 0) {
3033 ERR("Exhausted number of available FD upon create channel");
3034 goto error_fd_get_stream;
3035 }
3036
3037 health_code_update();
3038
3039 /*
3040 * Now get the channel from the consumer. This call will populate the stream
3041 * list of that channel and set the ust objects.
3042 */
3043 if (usess->consumer->enabled) {
3044 ret = ust_consumer_get_channel(socket, ua_chan);
3045 if (ret < 0) {
3046 goto error_destroy;
3047 }
3048 }
3049
3050 rcu_read_unlock();
3051 return 0;
3052
3053 error_destroy:
3054 lttng_fd_put(LTTNG_FD_APPS, nb_fd);
3055 error_fd_get_stream:
3056 /*
3057 * Initiate a destroy channel on the consumer since we had an error
3058 * handling it on our side. The return value is of no importance since we
3059 * already have a ret value set by the previous error that we need to
3060 * return.
3061 */
3062 (void) ust_consumer_destroy_channel(socket, ua_chan);
3063 error_ask:
3064 lttng_fd_put(LTTNG_FD_APPS, 1);
3065 error:
3066 health_code_update();
3067 rcu_read_unlock();
3068 return ret;
3069 }
3070
3071 /*
3072 * Duplicate the ust data object of the ust app stream and save it in the
3073 * buffer registry stream.
3074 *
3075 * Return 0 on success or else a negative value.
3076 */
3077 static int duplicate_stream_object(struct buffer_reg_stream *reg_stream,
3078 struct ust_app_stream *stream)
3079 {
3080 int ret;
3081
3082 LTTNG_ASSERT(reg_stream);
3083 LTTNG_ASSERT(stream);
3084
3085 /* Duplicating a stream requires 2 new fds. Reserve them. */
3086 ret = lttng_fd_get(LTTNG_FD_APPS, 2);
3087 if (ret < 0) {
3088 ERR("Exhausted number of available FD upon duplicate stream");
3089 goto error;
3090 }
3091
3092 /* Duplicate object for stream once the original is in the registry. */
3093 ret = lttng_ust_ctl_duplicate_ust_object_data(&stream->obj,
3094 reg_stream->obj.ust);
3095 if (ret < 0) {
3096 ERR("Duplicate stream obj from %p to %p failed with ret %d",
3097 reg_stream->obj.ust, stream->obj, ret);
3098 lttng_fd_put(LTTNG_FD_APPS, 2);
3099 goto error;
3100 }
3101 stream->handle = stream->obj->handle;
3102
3103 error:
3104 return ret;
3105 }
3106
3107 /*
3108 * Duplicate the ust data object of the ust app. channel and save it in the
3109 * buffer registry channel.
3110 *
3111 * Return 0 on success or else a negative value.
3112 */
3113 static int duplicate_channel_object(struct buffer_reg_channel *buf_reg_chan,
3114 struct ust_app_channel *ua_chan)
3115 {
3116 int ret;
3117
3118 LTTNG_ASSERT(buf_reg_chan);
3119 LTTNG_ASSERT(ua_chan);
3120
3121 /* Duplicating a channel requires 1 new fd. Reserve it. */
3122 ret = lttng_fd_get(LTTNG_FD_APPS, 1);
3123 if (ret < 0) {
3124 ERR("Exhausted number of available FD upon duplicate channel");
3125 goto error_fd_get;
3126 }
3127
3128 /* Duplicate object for stream once the original is in the registry. */
3129 ret = lttng_ust_ctl_duplicate_ust_object_data(&ua_chan->obj, buf_reg_chan->obj.ust);
3130 if (ret < 0) {
3131 ERR("Duplicate channel obj from %p to %p failed with ret: %d",
3132 buf_reg_chan->obj.ust, ua_chan->obj, ret);
3133 goto error;
3134 }
3135 ua_chan->handle = ua_chan->obj->handle;
3136
3137 return 0;
3138
3139 error:
3140 lttng_fd_put(LTTNG_FD_APPS, 1);
3141 error_fd_get:
3142 return ret;
3143 }
3144
3145 /*
3146 * For a given channel buffer registry, setup all streams of the given ust
3147 * application channel.
3148 *
3149 * Return 0 on success or else a negative value.
3150 */
3151 static int setup_buffer_reg_streams(struct buffer_reg_channel *buf_reg_chan,
3152 struct ust_app_channel *ua_chan,
3153 struct ust_app *app)
3154 {
3155 int ret = 0;
3156 struct ust_app_stream *stream, *stmp;
3157
3158 LTTNG_ASSERT(buf_reg_chan);
3159 LTTNG_ASSERT(ua_chan);
3160
3161 DBG2("UST app setup buffer registry stream");
3162
3163 /* Send all streams to application. */
3164 cds_list_for_each_entry_safe(stream, stmp, &ua_chan->streams.head, list) {
3165 struct buffer_reg_stream *reg_stream;
3166
3167 ret = buffer_reg_stream_create(&reg_stream);
3168 if (ret < 0) {
3169 goto error;
3170 }
3171
3172 /*
3173 * Keep original pointer and nullify it in the stream so the delete
3174 * stream call does not release the object.
3175 */
3176 reg_stream->obj.ust = stream->obj;
3177 stream->obj = NULL;
3178 buffer_reg_stream_add(reg_stream, buf_reg_chan);
3179
3180 /* We don't need the streams anymore. */
3181 cds_list_del(&stream->list);
3182 delete_ust_app_stream(-1, stream, app);
3183 }
3184
3185 error:
3186 return ret;
3187 }
3188
3189 /*
3190 * Create a buffer registry channel for the given session registry and
3191 * application channel object. If regp pointer is valid, it's set with the
3192 * created object. Important, the created object is NOT added to the session
3193 * registry hash table.
3194 *
3195 * Return 0 on success else a negative value.
3196 */
3197 static int create_buffer_reg_channel(struct buffer_reg_session *reg_sess,
3198 struct ust_app_channel *ua_chan, struct buffer_reg_channel **regp)
3199 {
3200 int ret;
3201 struct buffer_reg_channel *buf_reg_chan = NULL;
3202
3203 LTTNG_ASSERT(reg_sess);
3204 LTTNG_ASSERT(ua_chan);
3205
3206 DBG2("UST app creating buffer registry channel for %s", ua_chan->name);
3207
3208 /* Create buffer registry channel. */
3209 ret = buffer_reg_channel_create(ua_chan->tracing_channel_id, &buf_reg_chan);
3210 if (ret < 0) {
3211 goto error_create;
3212 }
3213 LTTNG_ASSERT(buf_reg_chan);
3214 buf_reg_chan->consumer_key = ua_chan->key;
3215 buf_reg_chan->subbuf_size = ua_chan->attr.subbuf_size;
3216 buf_reg_chan->num_subbuf = ua_chan->attr.num_subbuf;
3217
3218 /* Create and add a channel registry to session. */
3219 ret = ust_registry_channel_add(reg_sess->reg.ust,
3220 ua_chan->tracing_channel_id);
3221 if (ret < 0) {
3222 goto error;
3223 }
3224 buffer_reg_channel_add(reg_sess, buf_reg_chan);
3225
3226 if (regp) {
3227 *regp = buf_reg_chan;
3228 }
3229
3230 return 0;
3231
3232 error:
3233 /* Safe because the registry channel object was not added to any HT. */
3234 buffer_reg_channel_destroy(buf_reg_chan, LTTNG_DOMAIN_UST);
3235 error_create:
3236 return ret;
3237 }
3238
3239 /*
3240 * Setup buffer registry channel for the given session registry and application
3241 * channel object. If regp pointer is valid, it's set with the created object.
3242 *
3243 * Return 0 on success else a negative value.
3244 */
3245 static int setup_buffer_reg_channel(struct buffer_reg_session *reg_sess,
3246 struct ust_app_channel *ua_chan, struct buffer_reg_channel *buf_reg_chan,
3247 struct ust_app *app)
3248 {
3249 int ret;
3250
3251 LTTNG_ASSERT(reg_sess);
3252 LTTNG_ASSERT(buf_reg_chan);
3253 LTTNG_ASSERT(ua_chan);
3254 LTTNG_ASSERT(ua_chan->obj);
3255
3256 DBG2("UST app setup buffer registry channel for %s", ua_chan->name);
3257
3258 /* Setup all streams for the registry. */
3259 ret = setup_buffer_reg_streams(buf_reg_chan, ua_chan, app);
3260 if (ret < 0) {
3261 goto error;
3262 }
3263
3264 buf_reg_chan->obj.ust = ua_chan->obj;
3265 ua_chan->obj = NULL;
3266
3267 return 0;
3268
3269 error:
3270 buffer_reg_channel_remove(reg_sess, buf_reg_chan);
3271 buffer_reg_channel_destroy(buf_reg_chan, LTTNG_DOMAIN_UST);
3272 return ret;
3273 }
3274
3275 /*
3276 * Send buffer registry channel to the application.
3277 *
3278 * Return 0 on success else a negative value.
3279 */
3280 static int send_channel_uid_to_ust(struct buffer_reg_channel *buf_reg_chan,
3281 struct ust_app *app, struct ust_app_session *ua_sess,
3282 struct ust_app_channel *ua_chan)
3283 {
3284 int ret;
3285 struct buffer_reg_stream *reg_stream;
3286
3287 LTTNG_ASSERT(buf_reg_chan);
3288 LTTNG_ASSERT(app);
3289 LTTNG_ASSERT(ua_sess);
3290 LTTNG_ASSERT(ua_chan);
3291
3292 DBG("UST app sending buffer registry channel to ust sock %d", app->sock);
3293
3294 ret = duplicate_channel_object(buf_reg_chan, ua_chan);
3295 if (ret < 0) {
3296 goto error;
3297 }
3298
3299 /* Send channel to the application. */
3300 ret = ust_consumer_send_channel_to_ust(app, ua_sess, ua_chan);
3301 if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
3302 ret = -ENOTCONN; /* Caused by app exiting. */
3303 goto error;
3304 } else if (ret == -EAGAIN) {
3305 /* Caused by timeout. */
3306 WARN("Communication with application %d timed out on send_channel for channel \"%s\" of session \"%" PRIu64 "\".",
3307 app->pid, ua_chan->name, ua_sess->tracing_id);
3308 /* Treat this the same way as an application that is exiting. */
3309 ret = -ENOTCONN;
3310 goto error;
3311 } else if (ret < 0) {
3312 goto error;
3313 }
3314
3315 health_code_update();
3316
3317 /* Send all streams to application. */
3318 pthread_mutex_lock(&buf_reg_chan->stream_list_lock);
3319 cds_list_for_each_entry(reg_stream, &buf_reg_chan->streams, lnode) {
3320 struct ust_app_stream stream;
3321
3322 ret = duplicate_stream_object(reg_stream, &stream);
3323 if (ret < 0) {
3324 goto error_stream_unlock;
3325 }
3326
3327 ret = ust_consumer_send_stream_to_ust(app, ua_chan, &stream);
3328 if (ret < 0) {
3329 if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
3330 ret = -ENOTCONN; /* Caused by app exiting. */
3331 } else if (ret == -EAGAIN) {
3332 /*
3333 * Caused by timeout.
3334 * Treat this the same way as an application
3335 * that is exiting.
3336 */
3337 WARN("Communication with application %d timed out on send_stream for stream \"%s\" of channel \"%s\" of session \"%" PRIu64 "\".",
3338 app->pid, stream.name,
3339 ua_chan->name,
3340 ua_sess->tracing_id);
3341 ret = -ENOTCONN;
3342 }
3343 (void) release_ust_app_stream(-1, &stream, app);
3344 goto error_stream_unlock;
3345 }
3346
3347 /*
3348 * The return value is not important here. This function will output an
3349 * error if needed.
3350 */
3351 (void) release_ust_app_stream(-1, &stream, app);
3352 }
3353 ua_chan->is_sent = 1;
3354
3355 error_stream_unlock:
3356 pthread_mutex_unlock(&buf_reg_chan->stream_list_lock);
3357 error:
3358 return ret;
3359 }
3360
3361 /*
3362 * Create and send to the application the created buffers with per UID buffers.
3363 *
3364 * This MUST be called with a RCU read side lock acquired.
3365 * The session list lock and the session's lock must be acquired.
3366 *
3367 * Return 0 on success else a negative value.
3368 */
3369 static int create_channel_per_uid(struct ust_app *app,
3370 struct ltt_ust_session *usess, struct ust_app_session *ua_sess,
3371 struct ust_app_channel *ua_chan)
3372 {
3373 int ret;
3374 struct buffer_reg_uid *reg_uid;
3375 struct buffer_reg_channel *buf_reg_chan;
3376 struct ltt_session *session = NULL;
3377 enum lttng_error_code notification_ret;
3378 struct ust_registry_channel *ust_reg_chan;
3379
3380 LTTNG_ASSERT(app);
3381 LTTNG_ASSERT(usess);
3382 LTTNG_ASSERT(ua_sess);
3383 LTTNG_ASSERT(ua_chan);
3384
3385 DBG("UST app creating channel %s with per UID buffers", ua_chan->name);
3386
3387 reg_uid = buffer_reg_uid_find(usess->id, app->bits_per_long, app->uid);
3388 /*
3389 * The session creation handles the creation of this global registry
3390 * object. If none can be find, there is a code flow problem or a
3391 * teardown race.
3392 */
3393 LTTNG_ASSERT(reg_uid);
3394
3395 buf_reg_chan = buffer_reg_channel_find(ua_chan->tracing_channel_id,
3396 reg_uid);
3397 if (buf_reg_chan) {
3398 goto send_channel;
3399 }
3400
3401 /* Create the buffer registry channel object. */
3402 ret = create_buffer_reg_channel(reg_uid->registry, ua_chan, &buf_reg_chan);
3403 if (ret < 0) {
3404 ERR("Error creating the UST channel \"%s\" registry instance",
3405 ua_chan->name);
3406 goto error;
3407 }
3408
3409 session = session_find_by_id(ua_sess->tracing_id);
3410 LTTNG_ASSERT(session);
3411 LTTNG_ASSERT(pthread_mutex_trylock(&session->lock));
3412 LTTNG_ASSERT(session_trylock_list());
3413
3414 /*
3415 * Create the buffers on the consumer side. This call populates the
3416 * ust app channel object with all streams and data object.
3417 */
3418 ret = do_consumer_create_channel(usess, ua_sess, ua_chan,
3419 app->bits_per_long, reg_uid->registry->reg.ust,
3420 session->most_recent_chunk_id.value);
3421 if (ret < 0) {
3422 ERR("Error creating UST channel \"%s\" on the consumer daemon",
3423 ua_chan->name);
3424
3425 /*
3426 * Let's remove the previously created buffer registry channel so
3427 * it's not visible anymore in the session registry.
3428 */
3429 ust_registry_channel_del_free(reg_uid->registry->reg.ust,
3430 ua_chan->tracing_channel_id, false);
3431 buffer_reg_channel_remove(reg_uid->registry, buf_reg_chan);
3432 buffer_reg_channel_destroy(buf_reg_chan, LTTNG_DOMAIN_UST);
3433 goto error;
3434 }
3435
3436 /*
3437 * Setup the streams and add it to the session registry.
3438 */
3439 ret = setup_buffer_reg_channel(reg_uid->registry,
3440 ua_chan, buf_reg_chan, app);
3441 if (ret < 0) {
3442 ERR("Error setting up UST channel \"%s\"", ua_chan->name);
3443 goto error;
3444 }
3445
3446 /* Notify the notification subsystem of the channel's creation. */
3447 pthread_mutex_lock(&reg_uid->registry->reg.ust->lock);
3448 ust_reg_chan = ust_registry_channel_find(reg_uid->registry->reg.ust,
3449 ua_chan->tracing_channel_id);
3450 LTTNG_ASSERT(ust_reg_chan);
3451 ust_reg_chan->consumer_key = ua_chan->key;
3452 ust_reg_chan = NULL;
3453 pthread_mutex_unlock(&reg_uid->registry->reg.ust->lock);
3454
3455 notification_ret = notification_thread_command_add_channel(
3456 the_notification_thread_handle, session->name,
3457 lttng_credentials_get_uid(
3458 &ua_sess->effective_credentials),
3459 lttng_credentials_get_gid(
3460 &ua_sess->effective_credentials),
3461 ua_chan->name, ua_chan->key, LTTNG_DOMAIN_UST,
3462 ua_chan->attr.subbuf_size * ua_chan->attr.num_subbuf);
3463 if (notification_ret != LTTNG_OK) {
3464 ret = - (int) notification_ret;
3465 ERR("Failed to add channel to notification thread");
3466 goto error;
3467 }
3468
3469 send_channel:
3470 /* Send buffers to the application. */
3471 ret = send_channel_uid_to_ust(buf_reg_chan, app, ua_sess, ua_chan);
3472 if (ret < 0) {
3473 if (ret != -ENOTCONN) {
3474 ERR("Error sending channel to application");
3475 }
3476 goto error;
3477 }
3478
3479 error:
3480 if (session) {
3481 session_put(session);
3482 }
3483 return ret;
3484 }
3485
3486 /*
3487 * Create and send to the application the created buffers with per PID buffers.
3488 *
3489 * Called with UST app session lock held.
3490 * The session list lock and the session's lock must be acquired.
3491 *
3492 * Return 0 on success else a negative value.
3493 */
3494 static int create_channel_per_pid(struct ust_app *app,
3495 struct ltt_ust_session *usess, struct ust_app_session *ua_sess,
3496 struct ust_app_channel *ua_chan)
3497 {
3498 int ret;
3499 struct ust_registry_session *registry;
3500 enum lttng_error_code cmd_ret;
3501 struct ltt_session *session = NULL;
3502 uint64_t chan_reg_key;
3503 struct ust_registry_channel *ust_reg_chan;
3504
3505 LTTNG_ASSERT(app);
3506 LTTNG_ASSERT(usess);
3507 LTTNG_ASSERT(ua_sess);
3508 LTTNG_ASSERT(ua_chan);
3509
3510 DBG("UST app creating channel %s with per PID buffers", ua_chan->name);
3511
3512 rcu_read_lock();
3513
3514 registry = get_session_registry(ua_sess);
3515 /* The UST app session lock is held, registry shall not be null. */
3516 LTTNG_ASSERT(registry);
3517
3518 /* Create and add a new channel registry to session. */
3519 ret = ust_registry_channel_add(registry, ua_chan->key);
3520 if (ret < 0) {
3521 ERR("Error creating the UST channel \"%s\" registry instance",
3522 ua_chan->name);
3523 goto error;
3524 }
3525
3526 session = session_find_by_id(ua_sess->tracing_id);
3527 LTTNG_ASSERT(session);
3528
3529 LTTNG_ASSERT(pthread_mutex_trylock(&session->lock));
3530 LTTNG_ASSERT(session_trylock_list());
3531
3532 /* Create and get channel on the consumer side. */
3533 ret = do_consumer_create_channel(usess, ua_sess, ua_chan,
3534 app->bits_per_long, registry,
3535 session->most_recent_chunk_id.value);
3536 if (ret < 0) {
3537 ERR("Error creating UST channel \"%s\" on the consumer daemon",
3538 ua_chan->name);
3539 goto error_remove_from_registry;
3540 }
3541
3542 ret = send_channel_pid_to_ust(app, ua_sess, ua_chan);
3543 if (ret < 0) {
3544 if (ret != -ENOTCONN) {
3545 ERR("Error sending channel to application");
3546 }
3547 goto error_remove_from_registry;
3548 }
3549
3550 chan_reg_key = ua_chan->key;
3551 pthread_mutex_lock(&registry->lock);
3552 ust_reg_chan = ust_registry_channel_find(registry, chan_reg_key);
3553 LTTNG_ASSERT(ust_reg_chan);
3554 ust_reg_chan->consumer_key = ua_chan->key;
3555 pthread_mutex_unlock(&registry->lock);
3556
3557 cmd_ret = notification_thread_command_add_channel(
3558 the_notification_thread_handle, session->name,
3559 lttng_credentials_get_uid(
3560 &ua_sess->effective_credentials),
3561 lttng_credentials_get_gid(
3562 &ua_sess->effective_credentials),
3563 ua_chan->name, ua_chan->key, LTTNG_DOMAIN_UST,
3564 ua_chan->attr.subbuf_size * ua_chan->attr.num_subbuf);
3565 if (cmd_ret != LTTNG_OK) {
3566 ret = - (int) cmd_ret;
3567 ERR("Failed to add channel to notification thread");
3568 goto error_remove_from_registry;
3569 }
3570
3571 error_remove_from_registry:
3572 if (ret) {
3573 ust_registry_channel_del_free(registry, ua_chan->key, false);
3574 }
3575 error:
3576 rcu_read_unlock();
3577 if (session) {
3578 session_put(session);
3579 }
3580 return ret;
3581 }
3582
3583 /*
3584 * From an already allocated ust app channel, create the channel buffers if
3585 * needed and send them to the application. This MUST be called with a RCU read
3586 * side lock acquired.
3587 *
3588 * Called with UST app session lock held.
3589 *
3590 * Return 0 on success or else a negative value. Returns -ENOTCONN if
3591 * the application exited concurrently.
3592 */
3593 static int ust_app_channel_send(struct ust_app *app,
3594 struct ltt_ust_session *usess, struct ust_app_session *ua_sess,
3595 struct ust_app_channel *ua_chan)
3596 {
3597 int ret;
3598
3599 LTTNG_ASSERT(app);
3600 LTTNG_ASSERT(usess);
3601 LTTNG_ASSERT(usess->active);
3602 LTTNG_ASSERT(ua_sess);
3603 LTTNG_ASSERT(ua_chan);
3604
3605 /* Handle buffer type before sending the channel to the application. */
3606 switch (usess->buffer_type) {
3607 case LTTNG_BUFFER_PER_UID:
3608 {
3609 ret = create_channel_per_uid(app, usess, ua_sess, ua_chan);
3610 if (ret < 0) {
3611 goto error;
3612 }
3613 break;
3614 }
3615 case LTTNG_BUFFER_PER_PID:
3616 {
3617 ret = create_channel_per_pid(app, usess, ua_sess, ua_chan);
3618 if (ret < 0) {
3619 goto error;
3620 }
3621 break;
3622 }
3623 default:
3624 abort();
3625 ret = -EINVAL;
3626 goto error;
3627 }
3628
3629 /* Initialize ust objd object using the received handle and add it. */
3630 lttng_ht_node_init_ulong(&ua_chan->ust_objd_node, ua_chan->handle);
3631 lttng_ht_add_unique_ulong(app->ust_objd, &ua_chan->ust_objd_node);
3632
3633 /* If channel is not enabled, disable it on the tracer */
3634 if (!ua_chan->enabled) {
3635 ret = disable_ust_channel(app, ua_sess, ua_chan);
3636 if (ret < 0) {
3637 goto error;
3638 }
3639 }
3640
3641 error:
3642 return ret;
3643 }
3644
3645 /*
3646 * Create UST app channel and return it through ua_chanp if not NULL.
3647 *
3648 * Called with UST app session lock and RCU read-side lock held.
3649 *
3650 * Return 0 on success or else a negative value.
3651 */
3652 static int ust_app_channel_allocate(struct ust_app_session *ua_sess,
3653 struct ltt_ust_channel *uchan,
3654 enum lttng_ust_abi_chan_type type, struct ltt_ust_session *usess,
3655 struct ust_app_channel **ua_chanp)
3656 {
3657 int ret = 0;
3658 struct lttng_ht_iter iter;
3659 struct lttng_ht_node_str *ua_chan_node;
3660 struct ust_app_channel *ua_chan;
3661
3662 /* Lookup channel in the ust app session */
3663 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &iter);
3664 ua_chan_node = lttng_ht_iter_get_node_str(&iter);
3665 if (ua_chan_node != NULL) {
3666 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
3667 goto end;
3668 }
3669
3670 ua_chan = alloc_ust_app_channel(uchan->name, ua_sess, &uchan->attr);
3671 if (ua_chan == NULL) {
3672 /* Only malloc can fail here */
3673 ret = -ENOMEM;
3674 goto error;
3675 }
3676 shadow_copy_channel(ua_chan, uchan);
3677
3678 /* Set channel type. */
3679 ua_chan->attr.type = type;
3680
3681 /* Only add the channel if successful on the tracer side. */
3682 lttng_ht_add_unique_str(ua_sess->channels, &ua_chan->node);
3683 end:
3684 if (ua_chanp) {
3685 *ua_chanp = ua_chan;
3686 }
3687
3688 /* Everything went well. */
3689 return 0;
3690
3691 error:
3692 return ret;
3693 }
3694
3695 /*
3696 * Create UST app event and create it on the tracer side.
3697 *
3698 * Must be called with the RCU read side lock held.
3699 * Called with ust app session mutex held.
3700 */
3701 static
3702 int create_ust_app_event(struct ust_app_session *ua_sess,
3703 struct ust_app_channel *ua_chan, struct ltt_ust_event *uevent,
3704 struct ust_app *app)
3705 {
3706 int ret = 0;
3707 struct ust_app_event *ua_event;
3708
3709 ua_event = alloc_ust_app_event(uevent->attr.name, &uevent->attr);
3710 if (ua_event == NULL) {
3711 /* Only failure mode of alloc_ust_app_event(). */
3712 ret = -ENOMEM;
3713 goto end;
3714 }
3715 shadow_copy_event(ua_event, uevent);
3716
3717 /* Create it on the tracer side */
3718 ret = create_ust_event(app, ua_sess, ua_chan, ua_event);
3719 if (ret < 0) {
3720 /*
3721 * Not found previously means that it does not exist on the
3722 * tracer. If the application reports that the event existed,
3723 * it means there is a bug in the sessiond or lttng-ust
3724 * (or corruption, etc.)
3725 */
3726 if (ret == -LTTNG_UST_ERR_EXIST) {
3727 ERR("Tracer for application reported that an event being created already existed: "
3728 "event_name = \"%s\", pid = %d, ppid = %d, uid = %d, gid = %d",
3729 uevent->attr.name,
3730 app->pid, app->ppid, app->uid,
3731 app->gid);
3732 }
3733 goto error;
3734 }
3735
3736 add_unique_ust_app_event(ua_chan, ua_event);
3737
3738 DBG2("UST app create event completed: app = '%s' pid = %d",
3739 app->name, app->pid);
3740
3741 end:
3742 return ret;
3743
3744 error:
3745 /* Valid. Calling here is already in a read side lock */
3746 delete_ust_app_event(-1, ua_event, app);
3747 return ret;
3748 }
3749
3750 /*
3751 * Create UST app event notifier rule and create it on the tracer side.
3752 *
3753 * Must be called with the RCU read side lock held.
3754 * Called with ust app session mutex held.
3755 */
3756 static
3757 int create_ust_app_event_notifier_rule(struct lttng_trigger *trigger,
3758 struct ust_app *app)
3759 {
3760 int ret = 0;
3761 struct ust_app_event_notifier_rule *ua_event_notifier_rule;
3762
3763 ua_event_notifier_rule = alloc_ust_app_event_notifier_rule(trigger);
3764 if (ua_event_notifier_rule == NULL) {
3765 ret = -ENOMEM;
3766 goto end;
3767 }
3768
3769 /* Create it on the tracer side. */
3770 ret = create_ust_event_notifier(app, ua_event_notifier_rule);
3771 if (ret < 0) {
3772 /*
3773 * Not found previously means that it does not exist on the
3774 * tracer. If the application reports that the event existed,
3775 * it means there is a bug in the sessiond or lttng-ust
3776 * (or corruption, etc.)
3777 */
3778 if (ret == -LTTNG_UST_ERR_EXIST) {
3779 ERR("Tracer for application reported that an event notifier being created already exists: "
3780 "token = \"%" PRIu64 "\", pid = %d, ppid = %d, uid = %d, gid = %d",
3781 lttng_trigger_get_tracer_token(trigger),
3782 app->pid, app->ppid, app->uid,
3783 app->gid);
3784 }
3785 goto error;
3786 }
3787
3788 lttng_ht_add_unique_u64(app->token_to_event_notifier_rule_ht,
3789 &ua_event_notifier_rule->node);
3790
3791 DBG2("UST app create token event rule completed: app = '%s', pid = %d, token = %" PRIu64,
3792 app->name, app->pid, lttng_trigger_get_tracer_token(trigger));
3793
3794 goto end;
3795
3796 error:
3797 /* The RCU read side lock is already being held by the caller. */
3798 delete_ust_app_event_notifier_rule(-1, ua_event_notifier_rule, app);
3799 end:
3800 return ret;
3801 }
3802
3803 /*
3804 * Create UST metadata and open it on the tracer side.
3805 *
3806 * Called with UST app session lock held and RCU read side lock.
3807 */
3808 static int create_ust_app_metadata(struct ust_app_session *ua_sess,
3809 struct ust_app *app, struct consumer_output *consumer)
3810 {
3811 int ret = 0;
3812 struct ust_app_channel *metadata;
3813 struct consumer_socket *socket;
3814 struct ust_registry_session *registry;
3815 struct ltt_session *session = NULL;
3816
3817 LTTNG_ASSERT(ua_sess);
3818 LTTNG_ASSERT(app);
3819 LTTNG_ASSERT(consumer);
3820
3821 registry = get_session_registry(ua_sess);
3822 /* The UST app session is held registry shall not be null. */
3823 LTTNG_ASSERT(registry);
3824
3825 pthread_mutex_lock(&registry->lock);
3826
3827 /* Metadata already exists for this registry or it was closed previously */
3828 if (registry->metadata_key || registry->metadata_closed) {
3829 ret = 0;
3830 goto error;
3831 }
3832
3833 /* Allocate UST metadata */
3834 metadata = alloc_ust_app_channel(DEFAULT_METADATA_NAME, ua_sess, NULL);
3835 if (!metadata) {
3836 /* malloc() failed */
3837 ret = -ENOMEM;
3838 goto error;
3839 }
3840
3841 memcpy(&metadata->attr, &ua_sess->metadata_attr, sizeof(metadata->attr));
3842
3843 /* Need one fd for the channel. */
3844 ret = lttng_fd_get(LTTNG_FD_APPS, 1);
3845 if (ret < 0) {
3846 ERR("Exhausted number of available FD upon create metadata");
3847 goto error;
3848 }
3849
3850 /* Get the right consumer socket for the application. */
3851 socket = consumer_find_socket_by_bitness(app->bits_per_long, consumer);
3852 if (!socket) {
3853 ret = -EINVAL;
3854 goto error_consumer;
3855 }
3856
3857 /*
3858 * Keep metadata key so we can identify it on the consumer side. Assign it
3859 * to the registry *before* we ask the consumer so we avoid the race of the
3860 * consumer requesting the metadata and the ask_channel call on our side
3861 * did not returned yet.
3862 */
3863 registry->metadata_key = metadata->key;
3864
3865 session = session_find_by_id(ua_sess->tracing_id);
3866 LTTNG_ASSERT(session);
3867
3868 LTTNG_ASSERT(pthread_mutex_trylock(&session->lock));
3869 LTTNG_ASSERT(session_trylock_list());
3870
3871 /*
3872 * Ask the metadata channel creation to the consumer. The metadata object
3873 * will be created by the consumer and kept their. However, the stream is
3874 * never added or monitored until we do a first push metadata to the
3875 * consumer.
3876 */
3877 ret = ust_consumer_ask_channel(ua_sess, metadata, consumer, socket,
3878 registry, session->current_trace_chunk);
3879 if (ret < 0) {
3880 /* Nullify the metadata key so we don't try to close it later on. */
3881 registry->metadata_key = 0;
3882 goto error_consumer;
3883 }
3884
3885 /*
3886 * The setup command will make the metadata stream be sent to the relayd,
3887 * if applicable, and the thread managing the metadatas. This is important
3888 * because after this point, if an error occurs, the only way the stream
3889 * can be deleted is to be monitored in the consumer.
3890 */
3891 ret = consumer_setup_metadata(socket, metadata->key);
3892 if (ret < 0) {
3893 /* Nullify the metadata key so we don't try to close it later on. */
3894 registry->metadata_key = 0;
3895 goto error_consumer;
3896 }
3897
3898 DBG2("UST metadata with key %" PRIu64 " created for app pid %d",
3899 metadata->key, app->pid);
3900
3901 error_consumer:
3902 lttng_fd_put(LTTNG_FD_APPS, 1);
3903 delete_ust_app_channel(-1, metadata, app);
3904 error:
3905 pthread_mutex_unlock(&registry->lock);
3906 if (session) {
3907 session_put(session);
3908 }
3909 return ret;
3910 }
3911
3912 /*
3913 * Return ust app pointer or NULL if not found. RCU read side lock MUST be
3914 * acquired before calling this function.
3915 */
3916 struct ust_app *ust_app_find_by_pid(pid_t pid)
3917 {
3918 struct ust_app *app = NULL;
3919 struct lttng_ht_node_ulong *node;
3920 struct lttng_ht_iter iter;
3921
3922 lttng_ht_lookup(ust_app_ht, (void *)((unsigned long) pid), &iter);
3923 node = lttng_ht_iter_get_node_ulong(&iter);
3924 if (node == NULL) {
3925 DBG2("UST app no found with pid %d", pid);
3926 goto error;
3927 }
3928
3929 DBG2("Found UST app by pid %d", pid);
3930
3931 app = caa_container_of(node, struct ust_app, pid_n);
3932
3933 error:
3934 return app;
3935 }
3936
3937 /*
3938 * Allocate and init an UST app object using the registration information and
3939 * the command socket. This is called when the command socket connects to the
3940 * session daemon.
3941 *
3942 * The object is returned on success or else NULL.
3943 */
3944 struct ust_app *ust_app_create(struct ust_register_msg *msg, int sock)
3945 {
3946 int ret;
3947 struct ust_app *lta = NULL;
3948 struct lttng_pipe *event_notifier_event_source_pipe = NULL;
3949
3950 LTTNG_ASSERT(msg);
3951 LTTNG_ASSERT(sock >= 0);
3952
3953 DBG3("UST app creating application for socket %d", sock);
3954
3955 if ((msg->bits_per_long == 64 &&
3956 (uatomic_read(&the_ust_consumerd64_fd) ==
3957 -EINVAL)) ||
3958 (msg->bits_per_long == 32 &&
3959 (uatomic_read(&the_ust_consumerd32_fd) ==
3960 -EINVAL))) {
3961 ERR("Registration failed: application \"%s\" (pid: %d) has "
3962 "%d-bit long, but no consumerd for this size is available.\n",
3963 msg->name, msg->pid, msg->bits_per_long);
3964 goto error;
3965 }
3966
3967 /*
3968 * Reserve the two file descriptors of the event source pipe. The write
3969 * end will be closed once it is passed to the application, at which
3970 * point a single 'put' will be performed.
3971 */
3972 ret = lttng_fd_get(LTTNG_FD_APPS, 2);
3973 if (ret) {
3974 ERR("Failed to reserve two file descriptors for the event source pipe while creating a new application instance: app = '%s', pid = %d",
3975 msg->name, (int) msg->pid);
3976 goto error;
3977 }
3978
3979 event_notifier_event_source_pipe = lttng_pipe_open(FD_CLOEXEC);
3980 if (!event_notifier_event_source_pipe) {
3981 PERROR("Failed to open application event source pipe: '%s' (pid = %d)",
3982 msg->name, msg->pid);
3983 goto error;
3984 }
3985
3986 lta = (ust_app *) zmalloc(sizeof(struct ust_app));
3987 if (lta == NULL) {
3988 PERROR("malloc");
3989 goto error_free_pipe;
3990 }
3991
3992 lta->event_notifier_group.event_pipe = event_notifier_event_source_pipe;
3993
3994 lta->ppid = msg->ppid;
3995 lta->uid = msg->uid;
3996 lta->gid = msg->gid;
3997
3998 lta->bits_per_long = msg->bits_per_long;
3999 lta->uint8_t_alignment = msg->uint8_t_alignment;
4000 lta->uint16_t_alignment = msg->uint16_t_alignment;
4001 lta->uint32_t_alignment = msg->uint32_t_alignment;
4002 lta->uint64_t_alignment = msg->uint64_t_alignment;
4003 lta->long_alignment = msg->long_alignment;
4004 lta->byte_order = msg->byte_order;
4005
4006 lta->v_major = msg->major;
4007 lta->v_minor = msg->minor;
4008 lta->sessions = lttng_ht_new(0, LTTNG_HT_TYPE_U64);
4009 lta->ust_objd = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG);
4010 lta->ust_sessions_objd = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG);
4011 lta->notify_sock = -1;
4012 lta->token_to_event_notifier_rule_ht = lttng_ht_new(0, LTTNG_HT_TYPE_U64);
4013
4014 /* Copy name and make sure it's NULL terminated. */
4015 strncpy(lta->name, msg->name, sizeof(lta->name));
4016 lta->name[UST_APP_PROCNAME_LEN] = '\0';
4017
4018 /*
4019 * Before this can be called, when receiving the registration information,
4020 * the application compatibility is checked. So, at this point, the
4021 * application can work with this session daemon.
4022 */
4023 lta->compatible = 1;
4024
4025 lta->pid = msg->pid;
4026 lttng_ht_node_init_ulong(&lta->pid_n, (unsigned long) lta->pid);
4027 lta->sock = sock;
4028 pthread_mutex_init(&lta->sock_lock, NULL);
4029 lttng_ht_node_init_ulong(&lta->sock_n, (unsigned long) lta->sock);
4030
4031 CDS_INIT_LIST_HEAD(&lta->teardown_head);
4032 return lta;
4033
4034 error_free_pipe:
4035 lttng_pipe_destroy(event_notifier_event_source_pipe);
4036 lttng_fd_put(LTTNG_FD_APPS, 2);
4037 error:
4038 return NULL;
4039 }
4040
4041 /*
4042 * For a given application object, add it to every hash table.
4043 */
4044 void ust_app_add(struct ust_app *app)
4045 {
4046 LTTNG_ASSERT(app);
4047 LTTNG_ASSERT(app->notify_sock >= 0);
4048
4049 app->registration_time = time(NULL);
4050
4051 rcu_read_lock();
4052
4053 /*
4054 * On a re-registration, we want to kick out the previous registration of
4055 * that pid
4056 */
4057 lttng_ht_add_replace_ulong(ust_app_ht, &app->pid_n);
4058
4059 /*
4060 * The socket _should_ be unique until _we_ call close. So, a add_unique
4061 * for the ust_app_ht_by_sock is used which asserts fail if the entry was
4062 * already in the table.
4063 */
4064 lttng_ht_add_unique_ulong(ust_app_ht_by_sock, &app->sock_n);
4065
4066 /* Add application to the notify socket hash table. */
4067 lttng_ht_node_init_ulong(&app->notify_sock_n, app->notify_sock);
4068 lttng_ht_add_unique_ulong(ust_app_ht_by_notify_sock, &app->notify_sock_n);
4069
4070 DBG("App registered with pid:%d ppid:%d uid:%d gid:%d sock =%d name:%s "
4071 "notify_sock =%d (version %d.%d)", app->pid, app->ppid, app->uid,
4072 app->gid, app->sock, app->name, app->notify_sock, app->v_major,
4073 app->v_minor);
4074
4075 rcu_read_unlock();
4076 }
4077
4078 /*
4079 * Set the application version into the object.
4080 *
4081 * Return 0 on success else a negative value either an errno code or a
4082 * LTTng-UST error code.
4083 */
4084 int ust_app_version(struct ust_app *app)
4085 {
4086 int ret;
4087
4088 LTTNG_ASSERT(app);
4089
4090 pthread_mutex_lock(&app->sock_lock);
4091 ret = lttng_ust_ctl_tracer_version(app->sock, &app->version);
4092 pthread_mutex_unlock(&app->sock_lock);
4093 if (ret < 0) {
4094 if (ret == -LTTNG_UST_ERR_EXITING || ret == -EPIPE) {
4095 DBG3("UST app version failed. Application is dead: pid = %d, sock = %d",
4096 app->pid, app->sock);
4097 } else if (ret == -EAGAIN) {
4098 WARN("UST app version failed. Communication time out: pid = %d, sock = %d",
4099 app->pid, app->sock);
4100 } else {
4101 ERR("UST app version failed with ret %d: pid = %d, sock = %d",
4102 ret, app->pid, app->sock);
4103 }
4104 }
4105
4106 return ret;
4107 }
4108
4109 bool ust_app_supports_notifiers(const struct ust_app *app)
4110 {
4111 return app->v_major >= 9;
4112 }
4113
4114 bool ust_app_supports_counters(const struct ust_app *app)
4115 {
4116 return app->v_major >= 9;
4117 }
4118
4119 /*
4120 * Setup the base event notifier group.
4121 *
4122 * Return 0 on success else a negative value either an errno code or a
4123 * LTTng-UST error code.
4124 */
4125 int ust_app_setup_event_notifier_group(struct ust_app *app)
4126 {
4127 int ret;
4128 int event_pipe_write_fd;
4129 struct lttng_ust_abi_object_data *event_notifier_group = NULL;
4130 enum lttng_error_code lttng_ret;
4131 enum event_notifier_error_accounting_status event_notifier_error_accounting_status;
4132
4133 LTTNG_ASSERT(app);
4134
4135 if (!ust_app_supports_notifiers(app)) {
4136 ret = -ENOSYS;
4137 goto error;
4138 }
4139
4140 /* Get the write side of the pipe. */
4141 event_pipe_write_fd = lttng_pipe_get_writefd(
4142 app->event_notifier_group.event_pipe);
4143
4144 pthread_mutex_lock(&app->sock_lock);
4145 ret = lttng_ust_ctl_create_event_notifier_group(app->sock,
4146 event_pipe_write_fd, &event_notifier_group);
4147 pthread_mutex_unlock(&app->sock_lock);
4148 if (ret < 0) {
4149 if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
4150 ret = 0;
4151 DBG3("UST app create event notifier group failed. Application is dead: pid = %d, sock = %d",
4152 app->pid, app->sock);
4153 } else if (ret == -EAGAIN) {
4154 ret = 0;
4155 WARN("UST app create event notifier group failed. Communication time out: pid = %d, sock = %d",
4156 app->pid, app->sock);
4157 } else {
4158 ERR("UST app create event notifier group failed with ret %d: pid = %d, sock = %d, event_pipe_write_fd: %d",
4159 ret, app->pid, app->sock, event_pipe_write_fd);
4160 }
4161 goto error;
4162 }
4163
4164 ret = lttng_pipe_write_close(app->event_notifier_group.event_pipe);
4165 if (ret) {
4166 ERR("Failed to close write end of the application's event source pipe: app = '%s' (pid = %d)",
4167 app->name, app->pid);
4168 goto error;
4169 }
4170
4171 /*
4172 * Release the file descriptor that was reserved for the write-end of
4173 * the pipe.
4174 */
4175 lttng_fd_put(LTTNG_FD_APPS, 1);
4176
4177 lttng_ret = notification_thread_command_add_tracer_event_source(
4178 the_notification_thread_handle,
4179 lttng_pipe_get_readfd(
4180 app->event_notifier_group.event_pipe),
4181 LTTNG_DOMAIN_UST);
4182 if (lttng_ret != LTTNG_OK) {
4183 ERR("Failed to add tracer event source to notification thread");
4184 ret = - 1;
4185 goto error;
4186 }
4187
4188 /* Assign handle only when the complete setup is valid. */
4189 app->event_notifier_group.object = event_notifier_group;
4190
4191 event_notifier_error_accounting_status =
4192 event_notifier_error_accounting_register_app(app);
4193 switch (event_notifier_error_accounting_status) {
4194 case EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_OK:
4195 break;
4196 case EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_UNSUPPORTED:
4197 DBG3("Failed to setup event notifier error accounting (application does not support notifier error accounting): app socket fd = %d, app name = '%s', app pid = %d",
4198 app->sock, app->name, (int) app->pid);
4199 ret = 0;
4200 goto error_accounting;
4201 case EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_APP_DEAD:
4202 DBG3("Failed to setup event notifier error accounting (application is dead): app socket fd = %d, app name = '%s', app pid = %d",
4203 app->sock, app->name, (int) app->pid);
4204 ret = 0;
4205 goto error_accounting;
4206 default:
4207 ERR("Failed to setup event notifier error accounting for app");
4208 ret = -1;
4209 goto error_accounting;
4210 }
4211
4212 return ret;
4213
4214 error_accounting:
4215 lttng_ret = notification_thread_command_remove_tracer_event_source(
4216 the_notification_thread_handle,
4217 lttng_pipe_get_readfd(
4218 app->event_notifier_group.event_pipe));
4219 if (lttng_ret != LTTNG_OK) {
4220 ERR("Failed to remove application tracer event source from notification thread");
4221 }
4222
4223 error:
4224 lttng_ust_ctl_release_object(app->sock, app->event_notifier_group.object);
4225 free(app->event_notifier_group.object);
4226 app->event_notifier_group.object = NULL;
4227 return ret;
4228 }
4229
4230 /*
4231 * Unregister app by removing it from the global traceable app list and freeing
4232 * the data struct.
4233 *
4234 * The socket is already closed at this point so no close to sock.
4235 */
4236 void ust_app_unregister(int sock)
4237 {
4238 struct ust_app *lta;
4239 struct lttng_ht_node_ulong *node;
4240 struct lttng_ht_iter ust_app_sock_iter;
4241 struct lttng_ht_iter iter;
4242 struct ust_app_session *ua_sess;
4243 int ret;
4244
4245 rcu_read_lock();
4246
4247 /* Get the node reference for a call_rcu */
4248 lttng_ht_lookup(ust_app_ht_by_sock, (void *)((unsigned long) sock), &ust_app_sock_iter);
4249 node = lttng_ht_iter_get_node_ulong(&ust_app_sock_iter);
4250 LTTNG_ASSERT(node);
4251
4252 lta = caa_container_of(node, struct ust_app, sock_n);
4253 DBG("PID %d unregistering with sock %d", lta->pid, sock);
4254
4255 /*
4256 * For per-PID buffers, perform "push metadata" and flush all
4257 * application streams before removing app from hash tables,
4258 * ensuring proper behavior of data_pending check.
4259 * Remove sessions so they are not visible during deletion.
4260 */
4261 cds_lfht_for_each_entry(lta->sessions->ht, &iter.iter, ua_sess,
4262 node.node) {
4263 struct ust_registry_session *registry;
4264
4265 ret = lttng_ht_del(lta->sessions, &iter);
4266 if (ret) {
4267 /* The session was already removed so scheduled for teardown. */
4268 continue;
4269 }
4270
4271 if (ua_sess->buffer_type == LTTNG_BUFFER_PER_PID) {
4272 (void) ust_app_flush_app_session(lta, ua_sess);
4273 }
4274
4275 /*
4276 * Add session to list for teardown. This is safe since at this point we
4277 * are the only one using this list.
4278 */
4279 pthread_mutex_lock(&ua_sess->lock);
4280
4281 if (ua_sess->deleted) {
4282 pthread_mutex_unlock(&ua_sess->lock);
4283 continue;
4284 }
4285
4286 /*
4287 * Normally, this is done in the delete session process which is
4288 * executed in the call rcu below. However, upon registration we can't
4289 * afford to wait for the grace period before pushing data or else the
4290 * data pending feature can race between the unregistration and stop
4291 * command where the data pending command is sent *before* the grace
4292 * period ended.
4293 *
4294 * The close metadata below nullifies the metadata pointer in the
4295 * session so the delete session will NOT push/close a second time.
4296 */
4297 registry = get_session_registry(ua_sess);
4298 if (registry) {
4299 /* Push metadata for application before freeing the application. */
4300 (void) push_metadata(registry, ua_sess->consumer);
4301
4302 /*
4303 * Don't ask to close metadata for global per UID buffers. Close
4304 * metadata only on destroy trace session in this case. Also, the
4305 * previous push metadata could have flag the metadata registry to
4306 * close so don't send a close command if closed.
4307 */
4308 if (ua_sess->buffer_type != LTTNG_BUFFER_PER_UID) {
4309 /* And ask to close it for this session registry. */
4310 (void) close_metadata(registry, ua_sess->consumer);
4311 }
4312 }
4313 cds_list_add(&ua_sess->teardown_node, &lta->teardown_head);
4314
4315 pthread_mutex_unlock(&ua_sess->lock);
4316 }
4317
4318 /* Remove application from PID hash table */
4319 ret = lttng_ht_del(ust_app_ht_by_sock, &ust_app_sock_iter);
4320 LTTNG_ASSERT(!ret);
4321
4322 /*
4323 * Remove application from notify hash table. The thread handling the
4324 * notify socket could have deleted the node so ignore on error because
4325 * either way it's valid. The close of that socket is handled by the
4326 * apps_notify_thread.
4327 */
4328 iter.iter.node = &lta->notify_sock_n.node;
4329 (void) lttng_ht_del(ust_app_ht_by_notify_sock, &iter);
4330
4331 /*
4332 * Ignore return value since the node might have been removed before by an
4333 * add replace during app registration because the PID can be reassigned by
4334 * the OS.
4335 */
4336 iter.iter.node = &lta->pid_n.node;
4337 ret = lttng_ht_del(ust_app_ht, &iter);
4338 if (ret) {
4339 DBG3("Unregister app by PID %d failed. This can happen on pid reuse",
4340 lta->pid);
4341 }
4342
4343 /* Free memory */
4344 call_rcu(&lta->pid_n.head, delete_ust_app_rcu);
4345
4346 rcu_read_unlock();
4347 return;
4348 }
4349
4350 /*
4351 * Fill events array with all events name of all registered apps.
4352 */
4353 int ust_app_list_events(struct lttng_event **events)
4354 {
4355 int ret, handle;
4356 size_t nbmem, count = 0;
4357 struct lttng_ht_iter iter;
4358 struct ust_app *app;
4359 struct lttng_event *tmp_event;
4360
4361 nbmem = UST_APP_EVENT_LIST_SIZE;
4362 tmp_event = (lttng_event *) zmalloc(nbmem * sizeof(struct lttng_event));
4363 if (tmp_event == NULL) {
4364 PERROR("zmalloc ust app events");
4365 ret = -ENOMEM;
4366 goto error;
4367 }
4368
4369 rcu_read_lock();
4370
4371 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
4372 struct lttng_ust_abi_tracepoint_iter uiter;
4373
4374 health_code_update();
4375
4376 if (!app->compatible) {
4377 /*
4378 * TODO: In time, we should notice the caller of this error by
4379 * telling him that this is a version error.
4380 */
4381 continue;
4382 }
4383 pthread_mutex_lock(&app->sock_lock);
4384 handle = lttng_ust_ctl_tracepoint_list(app->sock);
4385 if (handle < 0) {
4386 if (handle != -EPIPE && handle != -LTTNG_UST_ERR_EXITING) {
4387 ERR("UST app list events getting handle failed for app pid %d",
4388 app->pid);
4389 }
4390 pthread_mutex_unlock(&app->sock_lock);
4391 continue;
4392 }
4393
4394 while ((ret = lttng_ust_ctl_tracepoint_list_get(app->sock, handle,
4395 &uiter)) != -LTTNG_UST_ERR_NOENT) {
4396 /* Handle ustctl error. */
4397 if (ret < 0) {
4398 int release_ret;
4399
4400 if (ret != -LTTNG_UST_ERR_EXITING && ret != -EPIPE) {
4401 ERR("UST app tp list get failed for app %d with ret %d",
4402 app->sock, ret);
4403 } else {
4404 DBG3("UST app tp list get failed. Application is dead");
4405 break;
4406 }
4407 free(tmp_event);
4408 release_ret = lttng_ust_ctl_release_handle(app->sock, handle);
4409 if (release_ret < 0 &&
4410 release_ret != -LTTNG_UST_ERR_EXITING &&
4411 release_ret != -EPIPE) {
4412 ERR("Error releasing app handle for app %d with ret %d", app->sock, release_ret);
4413 }
4414 pthread_mutex_unlock(&app->sock_lock);
4415 goto rcu_error;
4416 }
4417
4418 health_code_update();
4419 if (count >= nbmem) {
4420 /* In case the realloc fails, we free the memory */
4421 struct lttng_event *new_tmp_event;
4422 size_t new_nbmem;
4423
4424 new_nbmem = nbmem << 1;
4425 DBG2("Reallocating event list from %zu to %zu entries",
4426 nbmem, new_nbmem);
4427 new_tmp_event = (lttng_event *) realloc(tmp_event,
4428 new_nbmem * sizeof(struct lttng_event));
4429 if (new_tmp_event == NULL) {
4430 int release_ret;
4431
4432 PERROR("realloc ust app events");
4433 free(tmp_event);
4434 ret = -ENOMEM;
4435 release_ret = lttng_ust_ctl_release_handle(app->sock, handle);
4436 if (release_ret < 0 &&
4437 release_ret != -LTTNG_UST_ERR_EXITING &&
4438 release_ret != -EPIPE) {
4439 ERR("Error releasing app handle for app %d with ret %d", app->sock, release_ret);
4440 }
4441 pthread_mutex_unlock(&app->sock_lock);
4442 goto rcu_error;
4443 }
4444 /* Zero the new memory */
4445 memset(new_tmp_event + nbmem, 0,
4446 (new_nbmem - nbmem) * sizeof(struct lttng_event));
4447 nbmem = new_nbmem;
4448 tmp_event = new_tmp_event;
4449 }
4450 memcpy(tmp_event[count].name, uiter.name, LTTNG_UST_ABI_SYM_NAME_LEN);
4451 tmp_event[count].loglevel = uiter.loglevel;
4452 tmp_event[count].type = (enum lttng_event_type) LTTNG_UST_ABI_TRACEPOINT;
4453 tmp_event[count].pid = app->pid;
4454 tmp_event[count].enabled = -1;
4455 count++;
4456 }
4457 ret = lttng_ust_ctl_release_handle(app->sock, handle);
4458 pthread_mutex_unlock(&app->sock_lock);
4459 if (ret < 0) {
4460 if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
4461 DBG3("Error releasing app handle. Application died: pid = %d, sock = %d",
4462 app->pid, app->sock);
4463 } else if (ret == -EAGAIN) {
4464 WARN("Error releasing app handle. Communication time out: pid = %d, sock = %d",
4465 app->pid, app->sock);
4466 } else {
4467 ERR("Error releasing app handle with ret %d: pid = %d, sock = %d",
4468 ret, app->pid, app->sock);
4469 }
4470 }
4471 }
4472
4473 ret = count;
4474 *events = tmp_event;
4475
4476 DBG2("UST app list events done (%zu events)", count);
4477
4478 rcu_error:
4479 rcu_read_unlock();
4480 error:
4481 health_code_update();
4482 return ret;
4483 }
4484
4485 /*
4486 * Fill events array with all events name of all registered apps.
4487 */
4488 int ust_app_list_event_fields(struct lttng_event_field **fields)
4489 {
4490 int ret, handle;
4491 size_t nbmem, count = 0;
4492 struct lttng_ht_iter iter;
4493 struct ust_app *app;
4494 struct lttng_event_field *tmp_event;
4495
4496 nbmem = UST_APP_EVENT_LIST_SIZE;
4497 tmp_event = (lttng_event_field *) zmalloc(nbmem * sizeof(struct lttng_event_field));
4498 if (tmp_event == NULL) {
4499 PERROR("zmalloc ust app event fields");
4500 ret = -ENOMEM;
4501 goto error;
4502 }
4503
4504 rcu_read_lock();
4505
4506 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
4507 struct lttng_ust_abi_field_iter uiter;
4508
4509 health_code_update();
4510
4511 if (!app->compatible) {
4512 /*
4513 * TODO: In time, we should notice the caller of this error by
4514 * telling him that this is a version error.
4515 */
4516 continue;
4517 }
4518 pthread_mutex_lock(&app->sock_lock);
4519 handle = lttng_ust_ctl_tracepoint_field_list(app->sock);
4520 if (handle < 0) {
4521 if (handle != -EPIPE && handle != -LTTNG_UST_ERR_EXITING) {
4522 ERR("UST app list field getting handle failed for app pid %d",
4523 app->pid);
4524 }
4525 pthread_mutex_unlock(&app->sock_lock);
4526 continue;
4527 }
4528
4529 while ((ret = lttng_ust_ctl_tracepoint_field_list_get(app->sock, handle,
4530 &uiter)) != -LTTNG_UST_ERR_NOENT) {
4531 /* Handle ustctl error. */
4532 if (ret < 0) {
4533 int release_ret;
4534
4535 if (ret != -LTTNG_UST_ERR_EXITING && ret != -EPIPE) {
4536 ERR("UST app tp list field failed for app %d with ret %d",
4537 app->sock, ret);
4538 } else {
4539 DBG3("UST app tp list field failed. Application is dead");
4540 break;
4541 }
4542 free(tmp_event);
4543 release_ret = lttng_ust_ctl_release_handle(app->sock, handle);
4544 pthread_mutex_unlock(&app->sock_lock);
4545 if (release_ret < 0 &&
4546 release_ret != -LTTNG_UST_ERR_EXITING &&
4547 release_ret != -EPIPE) {
4548 ERR("Error releasing app handle for app %d with ret %d", app->sock, release_ret);
4549 }
4550 goto rcu_error;
4551 }
4552
4553 health_code_update();
4554 if (count >= nbmem) {
4555 /* In case the realloc fails, we free the memory */
4556 struct lttng_event_field *new_tmp_event;
4557 size_t new_nbmem;
4558
4559 new_nbmem = nbmem << 1;
4560 DBG2("Reallocating event field list from %zu to %zu entries",
4561 nbmem, new_nbmem);
4562 new_tmp_event = (lttng_event_field *) realloc(tmp_event,
4563 new_nbmem * sizeof(struct lttng_event_field));
4564 if (new_tmp_event == NULL) {
4565 int release_ret;
4566
4567 PERROR("realloc ust app event fields");
4568 free(tmp_event);
4569 ret = -ENOMEM;
4570 release_ret = lttng_ust_ctl_release_handle(app->sock, handle);
4571 pthread_mutex_unlock(&app->sock_lock);
4572 if (release_ret &&
4573 release_ret != -LTTNG_UST_ERR_EXITING &&
4574 release_ret != -EPIPE) {
4575 ERR("Error releasing app handle for app %d with ret %d", app->sock, release_ret);
4576 }
4577 goto rcu_error;
4578 }
4579 /* Zero the new memory */
4580 memset(new_tmp_event + nbmem, 0,
4581 (new_nbmem - nbmem) * sizeof(struct lttng_event_field));
4582 nbmem = new_nbmem;
4583 tmp_event = new_tmp_event;
4584 }
4585
4586 memcpy(tmp_event[count].field_name, uiter.field_name, LTTNG_UST_ABI_SYM_NAME_LEN);
4587 /* Mapping between these enums matches 1 to 1. */
4588 tmp_event[count].type = (enum lttng_event_field_type) uiter.type;
4589 tmp_event[count].nowrite = uiter.nowrite;
4590
4591 memcpy(tmp_event[count].event.name, uiter.event_name, LTTNG_UST_ABI_SYM_NAME_LEN);
4592 tmp_event[count].event.loglevel = uiter.loglevel;
4593 tmp_event[count].event.type = LTTNG_EVENT_TRACEPOINT;
4594 tmp_event[count].event.pid = app->pid;
4595 tmp_event[count].event.enabled = -1;
4596 count++;
4597 }
4598 ret = lttng_ust_ctl_release_handle(app->sock, handle);
4599 pthread_mutex_unlock(&app->sock_lock);
4600 if (ret < 0 &&
4601 ret != -LTTNG_UST_ERR_EXITING &&
4602 ret != -EPIPE) {
4603 ERR("Error releasing app handle for app %d with ret %d", app->sock, ret);
4604 }
4605 }
4606
4607 ret = count;
4608 *fields = tmp_event;
4609
4610 DBG2("UST app list event fields done (%zu events)", count);
4611
4612 rcu_error:
4613 rcu_read_unlock();
4614 error:
4615 health_code_update();
4616 return ret;
4617 }
4618
4619 /*
4620 * Free and clean all traceable apps of the global list.
4621 *
4622 * Should _NOT_ be called with RCU read-side lock held.
4623 */
4624 void ust_app_clean_list(void)
4625 {
4626 int ret;
4627 struct ust_app *app;
4628 struct lttng_ht_iter iter;
4629
4630 DBG2("UST app cleaning registered apps hash table");
4631
4632 rcu_read_lock();
4633
4634 /* Cleanup notify socket hash table */
4635 if (ust_app_ht_by_notify_sock) {
4636 cds_lfht_for_each_entry(ust_app_ht_by_notify_sock->ht, &iter.iter, app,
4637 notify_sock_n.node) {
4638 /*
4639 * Assert that all notifiers are gone as all triggers
4640 * are unregistered prior to this clean-up.
4641 */
4642 LTTNG_ASSERT(lttng_ht_get_count(app->token_to_event_notifier_rule_ht) == 0);
4643
4644 ust_app_notify_sock_unregister(app->notify_sock);
4645 }
4646 }
4647
4648 if (ust_app_ht) {
4649 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
4650 ret = lttng_ht_del(ust_app_ht, &iter);
4651 LTTNG_ASSERT(!ret);
4652 call_rcu(&app->pid_n.head, delete_ust_app_rcu);
4653 }
4654 }
4655
4656 /* Cleanup socket hash table */
4657 if (ust_app_ht_by_sock) {
4658 cds_lfht_for_each_entry(ust_app_ht_by_sock->ht, &iter.iter, app,
4659 sock_n.node) {
4660 ret = lttng_ht_del(ust_app_ht_by_sock, &iter);
4661 LTTNG_ASSERT(!ret);
4662 }
4663 }
4664
4665 rcu_read_unlock();
4666
4667 /* Destroy is done only when the ht is empty */
4668 if (ust_app_ht) {
4669 ht_cleanup_push(ust_app_ht);
4670 }
4671 if (ust_app_ht_by_sock) {
4672 ht_cleanup_push(ust_app_ht_by_sock);
4673 }
4674 if (ust_app_ht_by_notify_sock) {
4675 ht_cleanup_push(ust_app_ht_by_notify_sock);
4676 }
4677 }
4678
4679 /*
4680 * Init UST app hash table.
4681 */
4682 int ust_app_ht_alloc(void)
4683 {
4684 ust_app_ht = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG);
4685 if (!ust_app_ht) {
4686 return -1;
4687 }
4688 ust_app_ht_by_sock = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG);
4689 if (!ust_app_ht_by_sock) {
4690 return -1;
4691 }
4692 ust_app_ht_by_notify_sock = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG);
4693 if (!ust_app_ht_by_notify_sock) {
4694 return -1;
4695 }
4696 return 0;
4697 }
4698
4699 /*
4700 * For a specific UST session, disable the channel for all registered apps.
4701 */
4702 int ust_app_disable_channel_glb(struct ltt_ust_session *usess,
4703 struct ltt_ust_channel *uchan)
4704 {
4705 int ret = 0;
4706 struct lttng_ht_iter iter;
4707 struct lttng_ht_node_str *ua_chan_node;
4708 struct ust_app *app;
4709 struct ust_app_session *ua_sess;
4710 struct ust_app_channel *ua_chan;
4711
4712 LTTNG_ASSERT(usess->active);
4713 DBG2("UST app disabling channel %s from global domain for session id %" PRIu64,
4714 uchan->name, usess->id);
4715
4716 rcu_read_lock();
4717
4718 /* For every registered applications */
4719 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
4720 struct lttng_ht_iter uiter;
4721 if (!app->compatible) {
4722 /*
4723 * TODO: In time, we should notice the caller of this error by
4724 * telling him that this is a version error.
4725 */
4726 continue;
4727 }
4728 ua_sess = lookup_session_by_app(usess, app);
4729 if (ua_sess == NULL) {
4730 continue;
4731 }
4732
4733 /* Get channel */
4734 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &uiter);
4735 ua_chan_node = lttng_ht_iter_get_node_str(&uiter);
4736 /* If the session if found for the app, the channel must be there */
4737 LTTNG_ASSERT(ua_chan_node);
4738
4739 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
4740 /* The channel must not be already disabled */
4741 LTTNG_ASSERT(ua_chan->enabled == 1);
4742
4743 /* Disable channel onto application */
4744 ret = disable_ust_app_channel(ua_sess, ua_chan, app);
4745 if (ret < 0) {
4746 /* XXX: We might want to report this error at some point... */
4747 continue;
4748 }
4749 }
4750
4751 rcu_read_unlock();
4752 return ret;
4753 }
4754
4755 /*
4756 * For a specific UST session, enable the channel for all registered apps.
4757 */
4758 int ust_app_enable_channel_glb(struct ltt_ust_session *usess,
4759 struct ltt_ust_channel *uchan)
4760 {
4761 int ret = 0;
4762 struct lttng_ht_iter iter;
4763 struct ust_app *app;
4764 struct ust_app_session *ua_sess;
4765
4766 LTTNG_ASSERT(usess->active);
4767 DBG2("UST app enabling channel %s to global domain for session id %" PRIu64,
4768 uchan->name, usess->id);
4769
4770 rcu_read_lock();
4771
4772 /* For every registered applications */
4773 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
4774 if (!app->compatible) {
4775 /*
4776 * TODO: In time, we should notice the caller of this error by
4777 * telling him that this is a version error.
4778 */
4779 continue;
4780 }
4781 ua_sess = lookup_session_by_app(usess, app);
4782 if (ua_sess == NULL) {
4783 continue;
4784 }
4785
4786 /* Enable channel onto application */
4787 ret = enable_ust_app_channel(ua_sess, uchan, app);
4788 if (ret < 0) {
4789 /* XXX: We might want to report this error at some point... */
4790 continue;
4791 }
4792 }
4793
4794 rcu_read_unlock();
4795 return ret;
4796 }
4797
4798 /*
4799 * Disable an event in a channel and for a specific session.
4800 */
4801 int ust_app_disable_event_glb(struct ltt_ust_session *usess,
4802 struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent)
4803 {
4804 int ret = 0;
4805 struct lttng_ht_iter iter, uiter;
4806 struct lttng_ht_node_str *ua_chan_node;
4807 struct ust_app *app;
4808 struct ust_app_session *ua_sess;
4809 struct ust_app_channel *ua_chan;
4810 struct ust_app_event *ua_event;
4811
4812 LTTNG_ASSERT(usess->active);
4813 DBG("UST app disabling event %s for all apps in channel "
4814 "%s for session id %" PRIu64,
4815 uevent->attr.name, uchan->name, usess->id);
4816
4817 rcu_read_lock();
4818
4819 /* For all registered applications */
4820 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
4821 if (!app->compatible) {
4822 /*
4823 * TODO: In time, we should notice the caller of this error by
4824 * telling him that this is a version error.
4825 */
4826 continue;
4827 }
4828 ua_sess = lookup_session_by_app(usess, app);
4829 if (ua_sess == NULL) {
4830 /* Next app */
4831 continue;
4832 }
4833
4834 /* Lookup channel in the ust app session */
4835 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &uiter);
4836 ua_chan_node = lttng_ht_iter_get_node_str(&uiter);
4837 if (ua_chan_node == NULL) {
4838 DBG2("Channel %s not found in session id %" PRIu64 " for app pid %d."
4839 "Skipping", uchan->name, usess->id, app->pid);
4840 continue;
4841 }
4842 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
4843
4844 ua_event = find_ust_app_event(ua_chan->events, uevent->attr.name,
4845 uevent->filter, uevent->attr.loglevel,
4846 uevent->exclusion);
4847 if (ua_event == NULL) {
4848 DBG2("Event %s not found in channel %s for app pid %d."
4849 "Skipping", uevent->attr.name, uchan->name, app->pid);
4850 continue;
4851 }
4852
4853 ret = disable_ust_app_event(ua_sess, ua_event, app);
4854 if (ret < 0) {
4855 /* XXX: Report error someday... */
4856 continue;
4857 }
4858 }
4859
4860 rcu_read_unlock();
4861 return ret;
4862 }
4863
4864 /* The ua_sess lock must be held by the caller. */
4865 static
4866 int ust_app_channel_create(struct ltt_ust_session *usess,
4867 struct ust_app_session *ua_sess,
4868 struct ltt_ust_channel *uchan, struct ust_app *app,
4869 struct ust_app_channel **_ua_chan)
4870 {
4871 int ret = 0;
4872 struct ust_app_channel *ua_chan = NULL;
4873
4874 LTTNG_ASSERT(ua_sess);
4875 ASSERT_LOCKED(ua_sess->lock);
4876
4877 if (!strncmp(uchan->name, DEFAULT_METADATA_NAME,
4878 sizeof(uchan->name))) {
4879 copy_channel_attr_to_ustctl(&ua_sess->metadata_attr,
4880 &uchan->attr);
4881 ret = 0;
4882 } else {
4883 struct ltt_ust_context *uctx = NULL;
4884
4885 /*
4886 * Create channel onto application and synchronize its
4887 * configuration.
4888 */
4889 ret = ust_app_channel_allocate(ua_sess, uchan,
4890 LTTNG_UST_ABI_CHAN_PER_CPU, usess,
4891 &ua_chan);
4892 if (ret < 0) {
4893 goto error;
4894 }
4895
4896 ret = ust_app_channel_send(app, usess,
4897 ua_sess, ua_chan);
4898 if (ret) {
4899 goto error;
4900 }
4901
4902 /* Add contexts. */
4903 cds_list_for_each_entry(uctx, &uchan->ctx_list, list) {
4904 ret = create_ust_app_channel_context(ua_chan,
4905 &uctx->ctx, app);
4906 if (ret) {
4907 goto error;
4908 }
4909 }
4910 }
4911
4912 error:
4913 if (ret < 0) {
4914 switch (ret) {
4915 case -ENOTCONN:
4916 /*
4917 * The application's socket is not valid. Either a bad socket
4918 * or a timeout on it. We can't inform the caller that for a
4919 * specific app, the session failed so lets continue here.
4920 */
4921 ret = 0; /* Not an error. */
4922 break;
4923 case -ENOMEM:
4924 default:
4925 break;
4926 }
4927 }
4928
4929 if (ret == 0 && _ua_chan) {
4930 /*
4931 * Only return the application's channel on success. Note
4932 * that the channel can still be part of the application's
4933 * channel hashtable on error.
4934 */
4935 *_ua_chan = ua_chan;
4936 }
4937 return ret;
4938 }
4939
4940 /*
4941 * Enable event for a specific session and channel on the tracer.
4942 */
4943 int ust_app_enable_event_glb(struct ltt_ust_session *usess,
4944 struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent)
4945 {
4946 int ret = 0;
4947 struct lttng_ht_iter iter, uiter;
4948 struct lttng_ht_node_str *ua_chan_node;
4949 struct ust_app *app;
4950 struct ust_app_session *ua_sess;
4951 struct ust_app_channel *ua_chan;
4952 struct ust_app_event *ua_event;
4953
4954 LTTNG_ASSERT(usess->active);
4955 DBG("UST app enabling event %s for all apps for session id %" PRIu64,
4956 uevent->attr.name, usess->id);
4957
4958 /*
4959 * NOTE: At this point, this function is called only if the session and
4960 * channel passed are already created for all apps. and enabled on the
4961 * tracer also.
4962 */
4963
4964 rcu_read_lock();
4965
4966 /* For all registered applications */
4967 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
4968 if (!app->compatible) {
4969 /*
4970 * TODO: In time, we should notice the caller of this error by
4971 * telling him that this is a version error.
4972 */
4973 continue;
4974 }
4975 ua_sess = lookup_session_by_app(usess, app);
4976 if (!ua_sess) {
4977 /* The application has problem or is probably dead. */
4978 continue;
4979 }
4980
4981 pthread_mutex_lock(&ua_sess->lock);
4982
4983 if (ua_sess->deleted) {
4984 pthread_mutex_unlock(&ua_sess->lock);
4985 continue;
4986 }
4987
4988 /* Lookup channel in the ust app session */
4989 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &uiter);
4990 ua_chan_node = lttng_ht_iter_get_node_str(&uiter);
4991 /*
4992 * It is possible that the channel cannot be found is
4993 * the channel/event creation occurs concurrently with
4994 * an application exit.
4995 */
4996 if (!ua_chan_node) {
4997 pthread_mutex_unlock(&ua_sess->lock);
4998 continue;
4999 }
5000
5001 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
5002
5003 /* Get event node */
5004 ua_event = find_ust_app_event(ua_chan->events, uevent->attr.name,
5005 uevent->filter, uevent->attr.loglevel, uevent->exclusion);
5006 if (ua_event == NULL) {
5007 DBG3("UST app enable event %s not found for app PID %d."
5008 "Skipping app", uevent->attr.name, app->pid);
5009 goto next_app;
5010 }
5011
5012 ret = enable_ust_app_event(ua_sess, ua_event, app);
5013 if (ret < 0) {
5014 pthread_mutex_unlock(&ua_sess->lock);
5015 goto error;
5016 }
5017 next_app:
5018 pthread_mutex_unlock(&ua_sess->lock);
5019 }
5020
5021 error:
5022 rcu_read_unlock();
5023 return ret;
5024 }
5025
5026 /*
5027 * For a specific existing UST session and UST channel, creates the event for
5028 * all registered apps.
5029 */
5030 int ust_app_create_event_glb(struct ltt_ust_session *usess,
5031 struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent)
5032 {
5033 int ret = 0;
5034 struct lttng_ht_iter iter, uiter;
5035 struct lttng_ht_node_str *ua_chan_node;
5036 struct ust_app *app;
5037 struct ust_app_session *ua_sess;
5038 struct ust_app_channel *ua_chan;
5039
5040 LTTNG_ASSERT(usess->active);
5041 DBG("UST app creating event %s for all apps for session id %" PRIu64,
5042 uevent->attr.name, usess->id);
5043
5044 rcu_read_lock();
5045
5046 /* For all registered applications */
5047 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
5048 if (!app->compatible) {
5049 /*
5050 * TODO: In time, we should notice the caller of this error by
5051 * telling him that this is a version error.
5052 */
5053 continue;
5054 }
5055 ua_sess = lookup_session_by_app(usess, app);
5056 if (!ua_sess) {
5057 /* The application has problem or is probably dead. */
5058 continue;
5059 }
5060
5061 pthread_mutex_lock(&ua_sess->lock);
5062
5063 if (ua_sess->deleted) {
5064 pthread_mutex_unlock(&ua_sess->lock);
5065 continue;
5066 }
5067
5068 /* Lookup channel in the ust app session */
5069 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &uiter);
5070 ua_chan_node = lttng_ht_iter_get_node_str(&uiter);
5071 /* If the channel is not found, there is a code flow error */
5072 LTTNG_ASSERT(ua_chan_node);
5073
5074 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
5075
5076 ret = create_ust_app_event(ua_sess, ua_chan, uevent, app);
5077 pthread_mutex_unlock(&ua_sess->lock);
5078 if (ret < 0) {
5079 if (ret != -LTTNG_UST_ERR_EXIST) {
5080 /* Possible value at this point: -ENOMEM. If so, we stop! */
5081 break;
5082 }
5083 DBG2("UST app event %s already exist on app PID %d",
5084 uevent->attr.name, app->pid);
5085 continue;
5086 }
5087 }
5088
5089 rcu_read_unlock();
5090 return ret;
5091 }
5092
5093 /*
5094 * Start tracing for a specific UST session and app.
5095 *
5096 * Called with UST app session lock held.
5097 *
5098 */
5099 static
5100 int ust_app_start_trace(struct ltt_ust_session *usess, struct ust_app *app)
5101 {
5102 int ret = 0;
5103 struct ust_app_session *ua_sess;
5104
5105 DBG("Starting tracing for ust app pid %d", app->pid);
5106
5107 rcu_read_lock();
5108
5109 if (!app->compatible) {
5110 goto end;
5111 }
5112
5113 ua_sess = lookup_session_by_app(usess, app);
5114 if (ua_sess == NULL) {
5115 /* The session is in teardown process. Ignore and continue. */
5116 goto end;
5117 }
5118
5119 pthread_mutex_lock(&ua_sess->lock);
5120
5121 if (ua_sess->deleted) {
5122 pthread_mutex_unlock(&ua_sess->lock);
5123 goto end;
5124 }
5125
5126 if (ua_sess->enabled) {
5127 pthread_mutex_unlock(&ua_sess->lock);
5128 goto end;
5129 }
5130
5131 /* Upon restart, we skip the setup, already done */
5132 if (ua_sess->started) {
5133 goto skip_setup;
5134 }
5135
5136 health_code_update();
5137
5138 skip_setup:
5139 /* This starts the UST tracing */
5140 pthread_mutex_lock(&app->sock_lock);
5141 ret = lttng_ust_ctl_start_session(app->sock, ua_sess->handle);
5142 pthread_mutex_unlock(&app->sock_lock);
5143 if (ret < 0) {
5144 if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
5145 DBG3("UST app start session failed. Application is dead: pid = %d, sock = %d",
5146 app->pid, app->sock);
5147 pthread_mutex_unlock(&ua_sess->lock);
5148 goto end;
5149 } else if (ret == -EAGAIN) {
5150 WARN("UST app start session failed. Communication time out: pid = %d, sock = %d",
5151 app->pid, app->sock);
5152 pthread_mutex_unlock(&ua_sess->lock);
5153 goto end;
5154
5155 } else {
5156 ERR("UST app start session failed with ret %d: pid = %d, sock = %d",
5157 ret, app->pid, app->sock);
5158 }
5159 goto error_unlock;
5160 }
5161
5162 /* Indicate that the session has been started once */
5163 ua_sess->started = 1;
5164 ua_sess->enabled = 1;
5165
5166 pthread_mutex_unlock(&ua_sess->lock);
5167
5168 health_code_update();
5169
5170 /* Quiescent wait after starting trace */
5171 pthread_mutex_lock(&app->sock_lock);
5172 ret = lttng_ust_ctl_wait_quiescent(app->sock);
5173 pthread_mutex_unlock(&app->sock_lock);
5174 if (ret < 0) {
5175 if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
5176 DBG3("UST app wait quiescent failed. Application is dead: pid = %d, sock = %d",
5177 app->pid, app->sock);
5178 } else if (ret == -EAGAIN) {
5179 WARN("UST app wait quiescent failed. Communication time out: pid = %d, sock = %d",
5180 app->pid, app->sock);
5181 } else {
5182 ERR("UST app wait quiescent failed with ret %d: pid %d, sock = %d",
5183 ret, app->pid, app->sock);
5184 }
5185 }
5186
5187 end:
5188 rcu_read_unlock();
5189 health_code_update();
5190 return 0;
5191
5192 error_unlock:
5193 pthread_mutex_unlock(&ua_sess->lock);
5194 rcu_read_unlock();
5195 health_code_update();
5196 return -1;
5197 }
5198
5199 /*
5200 * Stop tracing for a specific UST session and app.
5201 */
5202 static
5203 int ust_app_stop_trace(struct ltt_ust_session *usess, struct ust_app *app)
5204 {
5205 int ret = 0;
5206 struct ust_app_session *ua_sess;
5207 struct ust_registry_session *registry;
5208
5209 DBG("Stopping tracing for ust app pid %d", app->pid);
5210
5211 rcu_read_lock();
5212
5213 if (!app->compatible) {
5214 goto end_no_session;
5215 }
5216
5217 ua_sess = lookup_session_by_app(usess, app);
5218 if (ua_sess == NULL) {
5219 goto end_no_session;
5220 }
5221
5222 pthread_mutex_lock(&ua_sess->lock);
5223
5224 if (ua_sess->deleted) {
5225 pthread_mutex_unlock(&ua_sess->lock);
5226 goto end_no_session;
5227 }
5228
5229 /*
5230 * If started = 0, it means that stop trace has been called for a session
5231 * that was never started. It's possible since we can have a fail start
5232 * from either the application manager thread or the command thread. Simply
5233 * indicate that this is a stop error.
5234 */
5235 if (!ua_sess->started) {
5236 goto error_rcu_unlock;
5237 }
5238
5239 health_code_update();
5240
5241 /* This inhibits UST tracing */
5242 pthread_mutex_lock(&app->sock_lock);
5243 ret = lttng_ust_ctl_stop_session(app->sock, ua_sess->handle);
5244 pthread_mutex_unlock(&app->sock_lock);
5245 if (ret < 0) {
5246 if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
5247 DBG3("UST app stop session failed. Application is dead: pid = %d, sock = %d",
5248 app->pid, app->sock);
5249 goto end_unlock;
5250 } else if (ret == -EAGAIN) {
5251 WARN("UST app stop session failed. Communication time out: pid = %d, sock = %d",
5252 app->pid, app->sock);
5253 goto end_unlock;
5254
5255 } else {
5256 ERR("UST app stop session failed with ret %d: pid = %d, sock = %d",
5257 ret, app->pid, app->sock);
5258 }
5259 goto error_rcu_unlock;
5260 }
5261
5262 health_code_update();
5263 ua_sess->enabled = 0;
5264
5265 /* Quiescent wait after stopping trace */
5266 pthread_mutex_lock(&app->sock_lock);
5267 ret = lttng_ust_ctl_wait_quiescent(app->sock);
5268 pthread_mutex_unlock(&app->sock_lock);
5269 if (ret < 0) {
5270 if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
5271 DBG3("UST app wait quiescent failed. Application is dead: pid= %d, sock = %d",
5272 app->pid, app->sock);
5273 } else if (ret == -EAGAIN) {
5274 WARN("UST app wait quiescent failed. Communication time out: pid= %d, sock = %d",
5275 app->pid, app->sock);
5276 } else {
5277 ERR("UST app wait quiescent failed with ret %d: pid= %d, sock = %d",
5278 ret, app->pid, app->sock);
5279 }
5280 }
5281
5282 health_code_update();
5283
5284 registry = get_session_registry(ua_sess);
5285
5286 /* The UST app session is held registry shall not be null. */
5287 LTTNG_ASSERT(registry);
5288
5289 /* Push metadata for application before freeing the application. */
5290 (void) push_metadata(registry, ua_sess->consumer);
5291
5292 end_unlock:
5293 pthread_mutex_unlock(&ua_sess->lock);
5294 end_no_session:
5295 rcu_read_unlock();
5296 health_code_update();
5297 return 0;
5298
5299 error_rcu_unlock:
5300 pthread_mutex_unlock(&ua_sess->lock);
5301 rcu_read_unlock();
5302 health_code_update();
5303 return -1;
5304 }
5305
5306 static
5307 int ust_app_flush_app_session(struct ust_app *app,
5308 struct ust_app_session *ua_sess)
5309 {
5310 int ret, retval = 0;
5311 struct lttng_ht_iter iter;
5312 struct ust_app_channel *ua_chan;
5313 struct consumer_socket *socket;
5314
5315 DBG("Flushing app session buffers for ust app pid %d", app->pid);
5316
5317 rcu_read_lock();
5318
5319 if (!app->compatible) {
5320 goto end_not_compatible;
5321 }
5322
5323 pthread_mutex_lock(&ua_sess->lock);
5324
5325 if (ua_sess->deleted) {
5326 goto end_deleted;
5327 }
5328
5329 health_code_update();
5330
5331 /* Flushing buffers */
5332 socket = consumer_find_socket_by_bitness(app->bits_per_long,
5333 ua_sess->consumer);
5334
5335 /* Flush buffers and push metadata. */
5336 switch (ua_sess->buffer_type) {
5337 case LTTNG_BUFFER_PER_PID:
5338 cds_lfht_for_each_entry(ua_sess->channels->ht, &iter.iter, ua_chan,
5339 node.node) {
5340 health_code_update();
5341 ret = consumer_flush_channel(socket, ua_chan->key);
5342 if (ret) {
5343 ERR("Error flushing consumer channel");
5344 retval = -1;
5345 continue;
5346 }
5347 }
5348 break;
5349 case LTTNG_BUFFER_PER_UID:
5350 default:
5351 abort();
5352 break;
5353 }
5354
5355 health_code_update();
5356
5357 end_deleted:
5358 pthread_mutex_unlock(&ua_sess->lock);
5359
5360 end_not_compatible:
5361 rcu_read_unlock();
5362 health_code_update();
5363 return retval;
5364 }
5365
5366 /*
5367 * Flush buffers for all applications for a specific UST session.
5368 * Called with UST session lock held.
5369 */
5370 static
5371 int ust_app_flush_session(struct ltt_ust_session *usess)
5372
5373 {
5374 int ret = 0;
5375
5376 DBG("Flushing session buffers for all ust apps");
5377
5378 rcu_read_lock();
5379
5380 /* Flush buffers and push metadata. */
5381 switch (usess->buffer_type) {
5382 case LTTNG_BUFFER_PER_UID:
5383 {
5384 struct buffer_reg_uid *reg;
5385 struct lttng_ht_iter iter;
5386
5387 /* Flush all per UID buffers associated to that session. */
5388 cds_list_for_each_entry(reg, &usess->buffer_reg_uid_list, lnode) {
5389 struct ust_registry_session *ust_session_reg;
5390 struct buffer_reg_channel *buf_reg_chan;
5391 struct consumer_socket *socket;
5392
5393 /* Get consumer socket to use to push the metadata.*/
5394 socket = consumer_find_socket_by_bitness(reg->bits_per_long,
5395 usess->consumer);
5396 if (!socket) {
5397 /* Ignore request if no consumer is found for the session. */
5398 continue;
5399 }
5400
5401 cds_lfht_for_each_entry(reg->registry->channels->ht, &iter.iter,
5402 buf_reg_chan, node.node) {
5403 /*
5404 * The following call will print error values so the return
5405 * code is of little importance because whatever happens, we
5406 * have to try them all.
5407 */
5408 (void) consumer_flush_channel(socket, buf_reg_chan->consumer_key);
5409 }
5410
5411 ust_session_reg = reg->registry->reg.ust;
5412 /* Push metadata. */
5413 (void) push_metadata(ust_session_reg, usess->consumer);
5414 }
5415 break;
5416 }
5417 case LTTNG_BUFFER_PER_PID:
5418 {
5419 struct ust_app_session *ua_sess;
5420 struct lttng_ht_iter iter;
5421 struct ust_app *app;
5422
5423 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
5424 ua_sess = lookup_session_by_app(usess, app);
5425 if (ua_sess == NULL) {
5426 continue;
5427 }
5428 (void) ust_app_flush_app_session(app, ua_sess);
5429 }
5430 break;
5431 }
5432 default:
5433 ret = -1;
5434 abort();
5435 break;
5436 }
5437
5438 rcu_read_unlock();
5439 health_code_update();
5440 return ret;
5441 }
5442
5443 static
5444 int ust_app_clear_quiescent_app_session(struct ust_app *app,
5445 struct ust_app_session *ua_sess)
5446 {
5447 int ret = 0;
5448 struct lttng_ht_iter iter;
5449 struct ust_app_channel *ua_chan;
5450 struct consumer_socket *socket;
5451
5452 DBG("Clearing stream quiescent state for ust app pid %d", app->pid);
5453
5454 rcu_read_lock();
5455
5456 if (!app->compatible) {
5457 goto end_not_compatible;
5458 }
5459
5460 pthread_mutex_lock(&ua_sess->lock);
5461
5462 if (ua_sess->deleted) {
5463 goto end_unlock;
5464 }
5465
5466 health_code_update();
5467
5468 socket = consumer_find_socket_by_bitness(app->bits_per_long,
5469 ua_sess->consumer);
5470 if (!socket) {
5471 ERR("Failed to find consumer (%" PRIu32 ") socket",
5472 app->bits_per_long);
5473 ret = -1;
5474 goto end_unlock;
5475 }
5476
5477 /* Clear quiescent state. */
5478 switch (ua_sess->buffer_type) {
5479 case LTTNG_BUFFER_PER_PID:
5480 cds_lfht_for_each_entry(ua_sess->channels->ht, &iter.iter,
5481 ua_chan, node.node) {
5482 health_code_update();
5483 ret = consumer_clear_quiescent_channel(socket,
5484 ua_chan->key);
5485 if (ret) {
5486 ERR("Error clearing quiescent state for consumer channel");
5487 ret = -1;
5488 continue;
5489 }
5490 }
5491 break;
5492 case LTTNG_BUFFER_PER_UID:
5493 default:
5494 abort();
5495 ret = -1;
5496 break;
5497 }
5498
5499 health_code_update();
5500
5501 end_unlock:
5502 pthread_mutex_unlock(&ua_sess->lock);
5503
5504 end_not_compatible:
5505 rcu_read_unlock();
5506 health_code_update();
5507 return ret;
5508 }
5509
5510 /*
5511 * Clear quiescent state in each stream for all applications for a
5512 * specific UST session.
5513 * Called with UST session lock held.
5514 */
5515 static
5516 int ust_app_clear_quiescent_session(struct ltt_ust_session *usess)
5517
5518 {
5519 int ret = 0;
5520
5521 DBG("Clearing stream quiescent state for all ust apps");
5522
5523 rcu_read_lock();
5524
5525 switch (usess->buffer_type) {
5526 case LTTNG_BUFFER_PER_UID:
5527 {
5528 struct lttng_ht_iter iter;
5529 struct buffer_reg_uid *reg;
5530
5531 /*
5532 * Clear quiescent for all per UID buffers associated to
5533 * that session.
5534 */
5535 cds_list_for_each_entry(reg, &usess->buffer_reg_uid_list, lnode) {
5536 struct consumer_socket *socket;
5537 struct buffer_reg_channel *buf_reg_chan;
5538
5539 /* Get associated consumer socket.*/
5540 socket = consumer_find_socket_by_bitness(
5541 reg->bits_per_long, usess->consumer);
5542 if (!socket) {
5543 /*
5544 * Ignore request if no consumer is found for
5545 * the session.
5546 */
5547 continue;
5548 }
5549
5550 cds_lfht_for_each_entry(reg->registry->channels->ht,
5551 &iter.iter, buf_reg_chan, node.node) {
5552 /*
5553 * The following call will print error values so
5554 * the return code is of little importance
5555 * because whatever happens, we have to try them
5556 * all.
5557 */
5558 (void) consumer_clear_quiescent_channel(socket,
5559 buf_reg_chan->consumer_key);
5560 }
5561 }
5562 break;
5563 }
5564 case LTTNG_BUFFER_PER_PID:
5565 {
5566 struct ust_app_session *ua_sess;
5567 struct lttng_ht_iter iter;
5568 struct ust_app *app;
5569
5570 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app,
5571 pid_n.node) {
5572 ua_sess = lookup_session_by_app(usess, app);
5573 if (ua_sess == NULL) {
5574 continue;
5575 }
5576 (void) ust_app_clear_quiescent_app_session(app,
5577 ua_sess);
5578 }
5579 break;
5580 }
5581 default:
5582 ret = -1;
5583 abort();
5584 break;
5585 }
5586
5587 rcu_read_unlock();
5588 health_code_update();
5589 return ret;
5590 }
5591
5592 /*
5593 * Destroy a specific UST session in apps.
5594 */
5595 static int destroy_trace(struct ltt_ust_session *usess, struct ust_app *app)
5596 {
5597 int ret;
5598 struct ust_app_session *ua_sess;
5599 struct lttng_ht_iter iter;
5600 struct lttng_ht_node_u64 *node;
5601
5602 DBG("Destroy tracing for ust app pid %d", app->pid);
5603
5604 rcu_read_lock();
5605
5606 if (!app->compatible) {
5607 goto end;
5608 }
5609
5610 __lookup_session_by_app(usess, app, &iter);
5611 node = lttng_ht_iter_get_node_u64(&iter);
5612 if (node == NULL) {
5613 /* Session is being or is deleted. */
5614 goto end;
5615 }
5616 ua_sess = caa_container_of(node, struct ust_app_session, node);
5617
5618 health_code_update();
5619 destroy_app_session(app, ua_sess);
5620
5621 health_code_update();
5622
5623 /* Quiescent wait after stopping trace */
5624 pthread_mutex_lock(&app->sock_lock);
5625 ret = lttng_ust_ctl_wait_quiescent(app->sock);
5626 pthread_mutex_unlock(&app->sock_lock);
5627 if (ret < 0) {
5628 if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
5629 DBG3("UST app wait quiescent failed. Application is dead: pid= %d, sock = %d",
5630 app->pid, app->sock);
5631 } else if (ret == -EAGAIN) {
5632 WARN("UST app wait quiescent failed. Communication time out: pid= %d, sock = %d",
5633 app->pid, app->sock);
5634 } else {
5635 ERR("UST app wait quiescent failed with ret %d: pid= %d, sock = %d",
5636 ret, app->pid, app->sock);
5637 }
5638 }
5639 end:
5640 rcu_read_unlock();
5641 health_code_update();
5642 return 0;
5643 }
5644
5645 /*
5646 * Start tracing for the UST session.
5647 */
5648 int ust_app_start_trace_all(struct ltt_ust_session *usess)
5649 {
5650 struct lttng_ht_iter iter;
5651 struct ust_app *app;
5652
5653 DBG("Starting all UST traces");
5654
5655 /*
5656 * Even though the start trace might fail, flag this session active so
5657 * other application coming in are started by default.
5658 */
5659 usess->active = 1;
5660
5661 rcu_read_lock();
5662
5663 /*
5664 * In a start-stop-start use-case, we need to clear the quiescent state
5665 * of each channel set by the prior stop command, thus ensuring that a
5666 * following stop or destroy is sure to grab a timestamp_end near those
5667 * operations, even if the packet is empty.
5668 */
5669 (void) ust_app_clear_quiescent_session(usess);
5670
5671 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
5672 ust_app_global_update(usess, app);
5673 }
5674
5675 rcu_read_unlock();
5676
5677 return 0;
5678 }
5679
5680 /*
5681 * Start tracing for the UST session.
5682 * Called with UST session lock held.
5683 */
5684 int ust_app_stop_trace_all(struct ltt_ust_session *usess)
5685 {
5686 int ret = 0;
5687 struct lttng_ht_iter iter;
5688 struct ust_app *app;
5689
5690 DBG("Stopping all UST traces");
5691
5692 /*
5693 * Even though the stop trace might fail, flag this session inactive so
5694 * other application coming in are not started by default.
5695 */
5696 usess->active = 0;
5697
5698 rcu_read_lock();
5699
5700 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
5701 ret = ust_app_stop_trace(usess, app);
5702 if (ret < 0) {
5703 /* Continue to next apps even on error */
5704 continue;
5705 }
5706 }
5707
5708 (void) ust_app_flush_session(usess);
5709
5710 rcu_read_unlock();
5711
5712 return 0;
5713 }
5714
5715 /*
5716 * Destroy app UST session.
5717 */
5718 int ust_app_destroy_trace_all(struct ltt_ust_session *usess)
5719 {
5720 int ret = 0;
5721 struct lttng_ht_iter iter;
5722 struct ust_app *app;
5723
5724 DBG("Destroy all UST traces");
5725
5726 rcu_read_lock();
5727
5728 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
5729 ret = destroy_trace(usess, app);
5730 if (ret < 0) {
5731 /* Continue to next apps even on error */
5732 continue;
5733 }
5734 }
5735
5736 rcu_read_unlock();
5737
5738 return 0;
5739 }
5740
5741 /* The ua_sess lock must be held by the caller. */
5742 static
5743 int find_or_create_ust_app_channel(
5744 struct ltt_ust_session *usess,
5745 struct ust_app_session *ua_sess,
5746 struct ust_app *app,
5747 struct ltt_ust_channel *uchan,
5748 struct ust_app_channel **ua_chan)
5749 {
5750 int ret = 0;
5751 struct lttng_ht_iter iter;
5752 struct lttng_ht_node_str *ua_chan_node;
5753
5754 lttng_ht_lookup(ua_sess->channels, (void *) uchan->name, &iter);
5755 ua_chan_node = lttng_ht_iter_get_node_str(&iter);
5756 if (ua_chan_node) {
5757 *ua_chan = caa_container_of(ua_chan_node,
5758 struct ust_app_channel, node);
5759 goto end;
5760 }
5761
5762 ret = ust_app_channel_create(usess, ua_sess, uchan, app, ua_chan);
5763 if (ret) {
5764 goto end;
5765 }
5766 end:
5767 return ret;
5768 }
5769
5770 static
5771 int ust_app_channel_synchronize_event(struct ust_app_channel *ua_chan,
5772 struct ltt_ust_event *uevent, struct ust_app_session *ua_sess,
5773 struct ust_app *app)
5774 {
5775 int ret = 0;
5776 struct ust_app_event *ua_event = NULL;
5777
5778 ua_event = find_ust_app_event(ua_chan->events, uevent->attr.name,
5779 uevent->filter, uevent->attr.loglevel, uevent->exclusion);
5780 if (!ua_event) {
5781 ret = create_ust_app_event(ua_sess, ua_chan, uevent, app);
5782 if (ret < 0) {
5783 goto end;
5784 }
5785 } else {
5786 if (ua_event->enabled != uevent->enabled) {
5787 ret = uevent->enabled ?
5788 enable_ust_app_event(ua_sess, ua_event, app) :
5789 disable_ust_app_event(ua_sess, ua_event, app);
5790 }
5791 }
5792
5793 end:
5794 return ret;
5795 }
5796
5797 /* Called with RCU read-side lock held. */
5798 static
5799 void ust_app_synchronize_event_notifier_rules(struct ust_app *app)
5800 {
5801 int ret = 0;
5802 enum lttng_error_code ret_code;
5803 enum lttng_trigger_status t_status;
5804 struct lttng_ht_iter app_trigger_iter;
5805 struct lttng_triggers *triggers = NULL;
5806 struct ust_app_event_notifier_rule *event_notifier_rule;
5807 unsigned int count, i;
5808
5809 if (!ust_app_supports_notifiers(app)) {
5810 goto end;
5811 }
5812
5813 /*
5814 * Currrently, registering or unregistering a trigger with an
5815 * event rule condition causes a full synchronization of the event
5816 * notifiers.
5817 *
5818 * The first step attempts to add an event notifier for all registered
5819 * triggers that apply to the user space tracers. Then, the
5820 * application's event notifiers rules are all checked against the list
5821 * of registered triggers. Any event notifier that doesn't have a
5822 * matching trigger can be assumed to have been disabled.
5823 *
5824 * All of this is inefficient, but is put in place to get the feature
5825 * rolling as it is simpler at this moment. It will be optimized Soon™
5826 * to allow the state of enabled
5827 * event notifiers to be synchronized in a piece-wise way.
5828 */
5829
5830 /* Get all triggers using uid 0 (root) */
5831 ret_code = notification_thread_command_list_triggers(
5832 the_notification_thread_handle, 0, &triggers);
5833 if (ret_code != LTTNG_OK) {
5834 goto end;
5835 }
5836
5837 LTTNG_ASSERT(triggers);
5838
5839 t_status = lttng_triggers_get_count(triggers, &count);
5840 if (t_status != LTTNG_TRIGGER_STATUS_OK) {
5841 goto end;
5842 }
5843
5844 for (i = 0; i < count; i++) {
5845 struct lttng_condition *condition;
5846 struct lttng_event_rule *event_rule;
5847 struct lttng_trigger *trigger;
5848 const struct ust_app_event_notifier_rule *looked_up_event_notifier_rule;
5849 enum lttng_condition_status condition_status;
5850 uint64_t token;
5851
5852 trigger = lttng_triggers_borrow_mutable_at_index(triggers, i);
5853 LTTNG_ASSERT(trigger);
5854
5855 token = lttng_trigger_get_tracer_token(trigger);
5856 condition = lttng_trigger_get_condition(trigger);
5857
5858 if (lttng_condition_get_type(condition) !=
5859 LTTNG_CONDITION_TYPE_EVENT_RULE_MATCHES) {
5860 /* Does not apply */
5861 continue;
5862 }
5863
5864 condition_status =
5865 lttng_condition_event_rule_matches_borrow_rule_mutable(
5866 condition, &event_rule);
5867 LTTNG_ASSERT(condition_status == LTTNG_CONDITION_STATUS_OK);
5868
5869 if (lttng_event_rule_get_domain_type(event_rule) == LTTNG_DOMAIN_KERNEL) {
5870 /* Skip kernel related triggers. */
5871 continue;
5872 }
5873
5874 /*
5875 * Find or create the associated token event rule. The caller
5876 * holds the RCU read lock, so this is safe to call without
5877 * explicitly acquiring it here.
5878 */
5879 looked_up_event_notifier_rule = find_ust_app_event_notifier_rule(
5880 app->token_to_event_notifier_rule_ht, token);
5881 if (!looked_up_event_notifier_rule) {
5882 ret = create_ust_app_event_notifier_rule(trigger, app);
5883 if (ret < 0) {
5884 goto end;
5885 }
5886 }
5887 }
5888
5889 rcu_read_lock();
5890 /* Remove all unknown event sources from the app. */
5891 cds_lfht_for_each_entry (app->token_to_event_notifier_rule_ht->ht,
5892 &app_trigger_iter.iter, event_notifier_rule,
5893 node.node) {
5894 const uint64_t app_token = event_notifier_rule->token;
5895 bool found = false;
5896
5897 /*
5898 * Check if the app event trigger still exists on the
5899 * notification side.
5900 */
5901 for (i = 0; i < count; i++) {
5902 uint64_t notification_thread_token;
5903 const struct lttng_trigger *trigger =
5904 lttng_triggers_get_at_index(
5905 triggers, i);
5906
5907 LTTNG_ASSERT(trigger);
5908
5909 notification_thread_token =
5910 lttng_trigger_get_tracer_token(trigger);
5911
5912 if (notification_thread_token == app_token) {
5913 found = true;
5914 break;
5915 }
5916 }
5917
5918 if (found) {
5919 /* Still valid. */
5920 continue;
5921 }
5922
5923 /*
5924 * This trigger was unregistered, disable it on the tracer's
5925 * side.
5926 */
5927 ret = lttng_ht_del(app->token_to_event_notifier_rule_ht,
5928 &app_trigger_iter);
5929 LTTNG_ASSERT(ret == 0);
5930
5931 /* Callee logs errors. */
5932 (void) disable_ust_object(app, event_notifier_rule->obj);
5933
5934 delete_ust_app_event_notifier_rule(
5935 app->sock, event_notifier_rule, app);
5936 }
5937
5938 rcu_read_unlock();
5939
5940 end:
5941 lttng_triggers_destroy(triggers);
5942 return;
5943 }
5944
5945 /*
5946 * RCU read lock must be held by the caller.
5947 */
5948 static
5949 void ust_app_synchronize_all_channels(struct ltt_ust_session *usess,
5950 struct ust_app_session *ua_sess,
5951 struct ust_app *app)
5952 {
5953 int ret = 0;
5954 struct cds_lfht_iter uchan_iter;
5955 struct ltt_ust_channel *uchan;
5956
5957 LTTNG_ASSERT(usess);
5958 LTTNG_ASSERT(ua_sess);
5959 LTTNG_ASSERT(app);
5960
5961 cds_lfht_for_each_entry(usess->domain_global.channels->ht, &uchan_iter,
5962 uchan, node.node) {
5963 struct ust_app_channel *ua_chan;
5964 struct cds_lfht_iter uevent_iter;
5965 struct ltt_ust_event *uevent;
5966
5967 /*
5968 * Search for a matching ust_app_channel. If none is found,
5969 * create it. Creating the channel will cause the ua_chan
5970 * structure to be allocated, the channel buffers to be
5971 * allocated (if necessary) and sent to the application, and
5972 * all enabled contexts will be added to the channel.
5973 */
5974 ret = find_or_create_ust_app_channel(usess, ua_sess,
5975 app, uchan, &ua_chan);
5976 if (ret) {
5977 /* Tracer is probably gone or ENOMEM. */
5978 goto end;
5979 }
5980
5981 if (!ua_chan) {
5982 /* ua_chan will be NULL for the metadata channel */
5983 continue;
5984 }
5985
5986 cds_lfht_for_each_entry(uchan->events->ht, &uevent_iter, uevent,
5987 node.node) {
5988 ret = ust_app_channel_synchronize_event(ua_chan,
5989 uevent, ua_sess, app);
5990 if (ret) {
5991 goto end;
5992 }
5993 }
5994
5995 if (ua_chan->enabled != uchan->enabled) {
5996 ret = uchan->enabled ?
5997 enable_ust_app_channel(ua_sess, uchan, app) :
5998 disable_ust_app_channel(ua_sess, ua_chan, app);
5999 if (ret) {
6000 goto end;
6001 }
6002 }
6003 }
6004 end:
6005 return;
6006 }
6007
6008 /*
6009 * The caller must ensure that the application is compatible and is tracked
6010 * by the process attribute trackers.
6011 */
6012 static
6013 void ust_app_synchronize(struct ltt_ust_session *usess,
6014 struct ust_app *app)
6015 {
6016 int ret = 0;
6017 struct ust_app_session *ua_sess = NULL;
6018
6019 /*
6020 * The application's configuration should only be synchronized for
6021 * active sessions.
6022 */
6023 LTTNG_ASSERT(usess->active);
6024
6025 ret = find_or_create_ust_app_session(usess, app, &ua_sess, NULL);
6026 if (ret < 0) {
6027 /* Tracer is probably gone or ENOMEM. */
6028 if (ua_sess) {
6029 destroy_app_session(app, ua_sess);
6030 }
6031 goto end;
6032 }
6033 LTTNG_ASSERT(ua_sess);
6034
6035 pthread_mutex_lock(&ua_sess->lock);
6036 if (ua_sess->deleted) {
6037 goto deleted_session;
6038 }
6039
6040 rcu_read_lock();
6041
6042 ust_app_synchronize_all_channels(usess, ua_sess, app);
6043
6044 /*
6045 * Create the metadata for the application. This returns gracefully if a
6046 * metadata was already set for the session.
6047 *
6048 * The metadata channel must be created after the data channels as the
6049 * consumer daemon assumes this ordering. When interacting with a relay
6050 * daemon, the consumer will use this assumption to send the
6051 * "STREAMS_SENT" message to the relay daemon.
6052 */
6053 ret = create_ust_app_metadata(ua_sess, app, usess->consumer);
6054 if (ret < 0) {
6055 ERR("Metadata creation failed for app sock %d for session id %" PRIu64,
6056 app->sock, usess->id);
6057 }
6058
6059 rcu_read_unlock();
6060
6061 deleted_session:
6062 pthread_mutex_unlock(&ua_sess->lock);
6063 end:
6064 return;
6065 }
6066
6067 static
6068 void ust_app_global_destroy(struct ltt_ust_session *usess, struct ust_app *app)
6069 {
6070 struct ust_app_session *ua_sess;
6071
6072 ua_sess = lookup_session_by_app(usess, app);
6073 if (ua_sess == NULL) {
6074 return;
6075 }
6076 destroy_app_session(app, ua_sess);
6077 }
6078
6079 /*
6080 * Add channels/events from UST global domain to registered apps at sock.
6081 *
6082 * Called with session lock held.
6083 * Called with RCU read-side lock held.
6084 */
6085 void ust_app_global_update(struct ltt_ust_session *usess, struct ust_app *app)
6086 {
6087 LTTNG_ASSERT(usess);
6088 LTTNG_ASSERT(usess->active);
6089
6090 DBG2("UST app global update for app sock %d for session id %" PRIu64,
6091 app->sock, usess->id);
6092
6093 if (!app->compatible) {
6094 return;
6095 }
6096 if (trace_ust_id_tracker_lookup(LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID,
6097 usess, app->pid) &&
6098 trace_ust_id_tracker_lookup(
6099 LTTNG_PROCESS_ATTR_VIRTUAL_USER_ID,
6100 usess, app->uid) &&
6101 trace_ust_id_tracker_lookup(
6102 LTTNG_PROCESS_ATTR_VIRTUAL_GROUP_ID,
6103 usess, app->gid)) {
6104 /*
6105 * Synchronize the application's internal tracing configuration
6106 * and start tracing.
6107 */
6108 ust_app_synchronize(usess, app);
6109 ust_app_start_trace(usess, app);
6110 } else {
6111 ust_app_global_destroy(usess, app);
6112 }
6113 }
6114
6115 /*
6116 * Add all event notifiers to an application.
6117 *
6118 * Called with session lock held.
6119 * Called with RCU read-side lock held.
6120 */
6121 void ust_app_global_update_event_notifier_rules(struct ust_app *app)
6122 {
6123 DBG2("UST application global event notifier rules update: app = '%s', pid = %d",
6124 app->name, app->pid);
6125
6126 if (!app->compatible || !ust_app_supports_notifiers(app)) {
6127 return;
6128 }
6129
6130 if (app->event_notifier_group.object == NULL) {
6131 WARN("UST app global update of event notifiers for app skipped since communication handle is null: app = '%s', pid = %d",
6132 app->name, app->pid);
6133 return;
6134 }
6135
6136 ust_app_synchronize_event_notifier_rules(app);
6137 }
6138
6139 /*
6140 * Called with session lock held.
6141 */
6142 void ust_app_global_update_all(struct ltt_ust_session *usess)
6143 {
6144 struct lttng_ht_iter iter;
6145 struct ust_app *app;
6146
6147 rcu_read_lock();
6148 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
6149 ust_app_global_update(usess, app);
6150 }
6151 rcu_read_unlock();
6152 }
6153
6154 void ust_app_global_update_all_event_notifier_rules(void)
6155 {
6156 struct lttng_ht_iter iter;
6157 struct ust_app *app;
6158
6159 rcu_read_lock();
6160 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
6161 ust_app_global_update_event_notifier_rules(app);
6162 }
6163
6164 rcu_read_unlock();
6165 }
6166
6167 /*
6168 * Add context to a specific channel for global UST domain.
6169 */
6170 int ust_app_add_ctx_channel_glb(struct ltt_ust_session *usess,
6171 struct ltt_ust_channel *uchan, struct ltt_ust_context *uctx)
6172 {
6173 int ret = 0;
6174 struct lttng_ht_node_str *ua_chan_node;
6175 struct lttng_ht_iter iter, uiter;
6176 struct ust_app_channel *ua_chan = NULL;
6177 struct ust_app_session *ua_sess;
6178 struct ust_app *app;
6179
6180 LTTNG_ASSERT(usess->active);
6181
6182 rcu_read_lock();
6183 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
6184 if (!app->compatible) {
6185 /*
6186 * TODO: In time, we should notice the caller of this error by
6187 * telling him that this is a version error.
6188 */
6189 continue;
6190 }
6191 ua_sess = lookup_session_by_app(usess, app);
6192 if (ua_sess == NULL) {
6193 continue;
6194 }
6195
6196 pthread_mutex_lock(&ua_sess->lock);
6197
6198 if (ua_sess->deleted) {
6199 pthread_mutex_unlock(&ua_sess->lock);
6200 continue;
6201 }
6202
6203 /* Lookup channel in the ust app session */
6204 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &uiter);
6205 ua_chan_node = lttng_ht_iter_get_node_str(&uiter);
6206 if (ua_chan_node == NULL) {
6207 goto next_app;
6208 }
6209 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel,
6210 node);
6211 ret = create_ust_app_channel_context(ua_chan, &uctx->ctx, app);
6212 if (ret < 0) {
6213 goto next_app;
6214 }
6215 next_app:
6216 pthread_mutex_unlock(&ua_sess->lock);
6217 }
6218
6219 rcu_read_unlock();
6220 return ret;
6221 }
6222
6223 /*
6224 * Receive registration and populate the given msg structure.
6225 *
6226 * On success return 0 else a negative value returned by the ustctl call.
6227 */
6228 int ust_app_recv_registration(int sock, struct ust_register_msg *msg)
6229 {
6230 int ret;
6231 uint32_t pid, ppid, uid, gid;
6232
6233 LTTNG_ASSERT(msg);
6234
6235 ret = lttng_ust_ctl_recv_reg_msg(sock, &msg->type, &msg->major, &msg->minor,
6236 &pid, &ppid, &uid, &gid,
6237 &msg->bits_per_long,
6238 &msg->uint8_t_alignment,
6239 &msg->uint16_t_alignment,
6240 &msg->uint32_t_alignment,
6241 &msg->uint64_t_alignment,
6242 &msg->long_alignment,
6243 &msg->byte_order,
6244 msg->name);
6245 if (ret < 0) {
6246 switch (-ret) {
6247 case EPIPE:
6248 case ECONNRESET:
6249 case LTTNG_UST_ERR_EXITING:
6250 DBG3("UST app recv reg message failed. Application died");
6251 break;
6252 case LTTNG_UST_ERR_UNSUP_MAJOR:
6253 ERR("UST app recv reg unsupported version %d.%d. Supporting %d.%d",
6254 msg->major, msg->minor, LTTNG_UST_ABI_MAJOR_VERSION,
6255 LTTNG_UST_ABI_MINOR_VERSION);
6256 break;
6257 default:
6258 ERR("UST app recv reg message failed with ret %d", ret);
6259 break;
6260 }
6261 goto error;
6262 }
6263 msg->pid = (pid_t) pid;
6264 msg->ppid = (pid_t) ppid;
6265 msg->uid = (uid_t) uid;
6266 msg->gid = (gid_t) gid;
6267
6268 error:
6269 return ret;
6270 }
6271
6272 /*
6273 * Return a ust app session object using the application object and the
6274 * session object descriptor has a key. If not found, NULL is returned.
6275 * A RCU read side lock MUST be acquired when calling this function.
6276 */
6277 static struct ust_app_session *find_session_by_objd(struct ust_app *app,
6278 int objd)
6279 {
6280 struct lttng_ht_node_ulong *node;
6281 struct lttng_ht_iter iter;
6282 struct ust_app_session *ua_sess = NULL;
6283
6284 LTTNG_ASSERT(app);
6285
6286 lttng_ht_lookup(app->ust_sessions_objd, (void *)((unsigned long) objd), &iter);
6287 node = lttng_ht_iter_get_node_ulong(&iter);
6288 if (node == NULL) {
6289 DBG2("UST app session find by objd %d not found", objd);
6290 goto error;
6291 }
6292
6293 ua_sess = caa_container_of(node, struct ust_app_session, ust_objd_node);
6294
6295 error:
6296 return ua_sess;
6297 }
6298
6299 /*
6300 * Return a ust app channel object using the application object and the channel
6301 * object descriptor has a key. If not found, NULL is returned. A RCU read side
6302 * lock MUST be acquired before calling this function.
6303 */
6304 static struct ust_app_channel *find_channel_by_objd(struct ust_app *app,
6305 int objd)
6306 {
6307 struct lttng_ht_node_ulong *node;
6308 struct lttng_ht_iter iter;
6309 struct ust_app_channel *ua_chan = NULL;
6310
6311 LTTNG_ASSERT(app);
6312
6313 lttng_ht_lookup(app->ust_objd, (void *)((unsigned long) objd), &iter);
6314 node = lttng_ht_iter_get_node_ulong(&iter);
6315 if (node == NULL) {
6316 DBG2("UST app channel find by objd %d not found", objd);
6317 goto error;
6318 }
6319
6320 ua_chan = caa_container_of(node, struct ust_app_channel, ust_objd_node);
6321
6322 error:
6323 return ua_chan;
6324 }
6325
6326 /*
6327 * Fixup legacy context fields for comparison:
6328 * - legacy array becomes array_nestable,
6329 * - legacy struct becomes struct_nestable,
6330 * - legacy variant becomes variant_nestable,
6331 * legacy sequences are not emitted in LTTng-UST contexts.
6332 */
6333 static int ust_app_fixup_legacy_context_fields(size_t *_nr_fields,
6334 struct lttng_ust_ctl_field **_fields)
6335 {
6336 struct lttng_ust_ctl_field *fields = *_fields, *new_fields = NULL;
6337 size_t nr_fields = *_nr_fields, new_nr_fields = 0, i, j;
6338 bool found = false;
6339 int ret = 0;
6340
6341 for (i = 0; i < nr_fields; i++) {
6342 const struct lttng_ust_ctl_field *field = &fields[i];
6343
6344 switch (field->type.atype) {
6345 case lttng_ust_ctl_atype_sequence:
6346 ERR("Unexpected legacy sequence context.");
6347 ret = -EINVAL;
6348 goto end;
6349 case lttng_ust_ctl_atype_array:
6350 switch (field->type.u.legacy.array.elem_type.atype) {
6351 case lttng_ust_ctl_atype_integer:
6352 break;
6353 default:
6354 ERR("Unexpected legacy array element type in context.");
6355 ret = -EINVAL;
6356 goto end;
6357 }
6358 found = true;
6359 /* One field for array_nested, one field for elem type. */
6360 new_nr_fields += 2;
6361 break;
6362
6363 case lttng_ust_ctl_atype_struct: /* Fallthrough */
6364 case lttng_ust_ctl_atype_variant:
6365 found = true;
6366 new_nr_fields++;
6367 break;
6368 default:
6369 new_nr_fields++;
6370 break;
6371 }
6372 }
6373 if (!found) {
6374 goto end;
6375 }
6376 new_fields = (struct lttng_ust_ctl_field *) zmalloc(sizeof(*new_fields) * new_nr_fields);
6377 if (!new_fields) {
6378 ret = -ENOMEM;
6379 goto end;
6380 }
6381 for (i = 0, j = 0; i < nr_fields; i++, j++) {
6382 const struct lttng_ust_ctl_field *field = &fields[i];
6383 struct lttng_ust_ctl_field *new_field = &new_fields[j];
6384
6385 switch (field->type.atype) {
6386 case lttng_ust_ctl_atype_array:
6387 /* One field for array_nested, one field for elem type. */
6388 strncpy(new_field->name, field->name, LTTNG_UST_ABI_SYM_NAME_LEN - 1);
6389 new_field->type.atype = lttng_ust_ctl_atype_array_nestable;
6390 new_field->type.u.array_nestable.length = field->type.u.legacy.array.length;
6391 new_field->type.u.array_nestable.alignment = 0;
6392 new_field = &new_fields[++j]; /* elem type */
6393 new_field->type.atype = field->type.u.legacy.array.elem_type.atype;
6394 assert(new_field->type.atype == lttng_ust_ctl_atype_integer);
6395 new_field->type.u.integer = field->type.u.legacy.array.elem_type.u.basic.integer;
6396 break;
6397 case lttng_ust_ctl_atype_struct:
6398 strncpy(new_field->name, field->name, LTTNG_UST_ABI_SYM_NAME_LEN - 1);
6399 new_field->type.atype = lttng_ust_ctl_atype_struct_nestable;
6400 new_field->type.u.struct_nestable.nr_fields = field->type.u.legacy._struct.nr_fields;
6401 new_field->type.u.struct_nestable.alignment = 0;
6402 break;
6403 case lttng_ust_ctl_atype_variant:
6404 strncpy(new_field->name, field->name, LTTNG_UST_ABI_SYM_NAME_LEN - 1);
6405 new_field->type.atype = lttng_ust_ctl_atype_variant_nestable;
6406 new_field->type.u.variant_nestable.nr_choices = field->type.u.legacy.variant.nr_choices;
6407 strncpy(new_field->type.u.variant_nestable.tag_name,
6408 field->type.u.legacy.variant.tag_name,
6409 LTTNG_UST_ABI_SYM_NAME_LEN - 1);
6410 new_field->type.u.variant_nestable.alignment = 0;
6411 break;
6412 default:
6413 *new_field = *field;
6414 break;
6415 }
6416 }
6417 free(fields);
6418 *_fields = new_fields;
6419 *_nr_fields = new_nr_fields;
6420 end:
6421 return ret;
6422 }
6423
6424 /*
6425 * Reply to a register channel notification from an application on the notify
6426 * socket. The channel metadata is also created.
6427 *
6428 * The session UST registry lock is acquired in this function.
6429 *
6430 * On success 0 is returned else a negative value.
6431 */
6432 static int reply_ust_register_channel(int sock, int cobjd,
6433 size_t nr_fields, struct lttng_ust_ctl_field *fields)
6434 {
6435 int ret, ret_code = 0;
6436 uint32_t chan_id;
6437 uint64_t chan_reg_key;
6438 enum lttng_ust_ctl_channel_header type = LTTNG_UST_CTL_CHANNEL_HEADER_UNKNOWN;
6439 struct ust_app *app;
6440 struct ust_app_channel *ua_chan;
6441 struct ust_app_session *ua_sess;
6442 struct ust_registry_session *registry;
6443 struct ust_registry_channel *ust_reg_chan;
6444
6445 rcu_read_lock();
6446
6447 /* Lookup application. If not found, there is a code flow error. */
6448 app = find_app_by_notify_sock(sock);
6449 if (!app) {
6450 DBG("Application socket %d is being torn down. Abort event notify",
6451 sock);
6452 ret = -1;
6453 goto error_rcu_unlock;
6454 }
6455
6456 /* Lookup channel by UST object descriptor. */
6457 ua_chan = find_channel_by_objd(app, cobjd);
6458 if (!ua_chan) {
6459 DBG("Application channel is being torn down. Abort event notify");
6460 ret = 0;
6461 goto error_rcu_unlock;
6462 }
6463
6464 LTTNG_ASSERT(ua_chan->session);
6465 ua_sess = ua_chan->session;
6466
6467 /* Get right session registry depending on the session buffer type. */
6468 registry = get_session_registry(ua_sess);
6469 if (!registry) {
6470 DBG("Application session is being torn down. Abort event notify");
6471 ret = 0;
6472 goto error_rcu_unlock;
6473 };
6474
6475 /* Depending on the buffer type, a different channel key is used. */
6476 if (ua_sess->buffer_type == LTTNG_BUFFER_PER_UID) {
6477 chan_reg_key = ua_chan->tracing_channel_id;
6478 } else {
6479 chan_reg_key = ua_chan->key;
6480 }
6481
6482 pthread_mutex_lock(&registry->lock);
6483
6484 ust_reg_chan = ust_registry_channel_find(registry, chan_reg_key);
6485 LTTNG_ASSERT(ust_reg_chan);
6486
6487 /* Channel id is set during the object creation. */
6488 chan_id = ust_reg_chan->chan_id;
6489
6490 ret = ust_app_fixup_legacy_context_fields(&nr_fields, &fields);
6491 if (ret < 0) {
6492 ERR("Registering application channel due to legacy context fields fixup error: pid = %d, sock = %d",
6493 app->pid, app->sock);
6494 ret_code = -EINVAL;
6495 goto reply;
6496 }
6497 if (!ust_reg_chan->register_done) {
6498 /*
6499 * TODO: eventually use the registry event count for
6500 * this channel to better guess header type for per-pid
6501 * buffers.
6502 */
6503 type = LTTNG_UST_CTL_CHANNEL_HEADER_LARGE;
6504 ust_reg_chan->nr_ctx_fields = nr_fields;
6505 ust_reg_chan->ctx_fields = fields;
6506 fields = NULL;
6507 ust_reg_chan->header_type = type;
6508 } else {
6509 /* Get current already assigned values. */
6510 type = ust_reg_chan->header_type;
6511 /*
6512 * Validate that the context fields match between
6513 * registry and newcoming application.
6514 */
6515 if (!match_lttng_ust_ctl_field_array(ust_reg_chan->ctx_fields,
6516 ust_reg_chan->nr_ctx_fields,
6517 fields, nr_fields)) {
6518 ERR("Registering application channel due to context field mismatch: pid = %d, sock = %d",
6519 app->pid, app->sock);
6520 ret_code = -EINVAL;
6521 goto reply;
6522 }
6523 }
6524
6525 /* Append to metadata */
6526 if (!ust_reg_chan->metadata_dumped) {
6527 ret_code = ust_metadata_channel_statedump(registry, ust_reg_chan);
6528 if (ret_code) {
6529 ERR("Error appending channel metadata (errno = %d)", ret_code);
6530 goto reply;
6531 }
6532 }
6533
6534 reply:
6535 DBG3("UST app replying to register channel key %" PRIu64
6536 " with id %u, type = %d, ret = %d", chan_reg_key, chan_id, type,
6537 ret_code);
6538
6539 ret = lttng_ust_ctl_reply_register_channel(sock, chan_id, type, ret_code);
6540 if (ret < 0) {
6541 if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
6542 DBG3("UST app reply channel failed. Application died: pid = %d, sock = %d",
6543 app->pid, app->sock);
6544 } else if (ret == -EAGAIN) {
6545 WARN("UST app reply channel failed. Communication time out: pid = %d, sock = %d",
6546 app->pid, app->sock);
6547 } else {
6548 ERR("UST app reply channel failed with ret %d: pid = %d, sock = %d",
6549 ret, app->pid, app->sock);
6550 }
6551 goto error;
6552 }
6553
6554 /* This channel registry registration is completed. */
6555 ust_reg_chan->register_done = 1;
6556
6557 error:
6558 pthread_mutex_unlock(&registry->lock);
6559 error_rcu_unlock:
6560 rcu_read_unlock();
6561 free(fields);
6562 return ret;
6563 }
6564
6565 /*
6566 * Add event to the UST channel registry. When the event is added to the
6567 * registry, the metadata is also created. Once done, this replies to the
6568 * application with the appropriate error code.
6569 *
6570 * The session UST registry lock is acquired in the function.
6571 *
6572 * On success 0 is returned else a negative value.
6573 */
6574 static int add_event_ust_registry(int sock, int sobjd, int cobjd, char *name,
6575 char *sig, size_t nr_fields, struct lttng_ust_ctl_field *fields,
6576 int loglevel_value, char *model_emf_uri)
6577 {
6578 int ret, ret_code;
6579 uint32_t event_id = 0;
6580 uint64_t chan_reg_key;
6581 struct ust_app *app;
6582 struct ust_app_channel *ua_chan;
6583 struct ust_app_session *ua_sess;
6584 struct ust_registry_session *registry;
6585
6586 rcu_read_lock();
6587
6588 /* Lookup application. If not found, there is a code flow error. */
6589 app = find_app_by_notify_sock(sock);
6590 if (!app) {
6591 DBG("Application socket %d is being torn down. Abort event notify",
6592 sock);
6593 ret = -1;
6594 goto error_rcu_unlock;
6595 }
6596
6597 /* Lookup channel by UST object descriptor. */
6598 ua_chan = find_channel_by_objd(app, cobjd);
6599 if (!ua_chan) {
6600 DBG("Application channel is being torn down. Abort event notify");
6601 ret = 0;
6602 goto error_rcu_unlock;
6603 }
6604
6605 LTTNG_ASSERT(ua_chan->session);
6606 ua_sess = ua_chan->session;
6607
6608 registry = get_session_registry(ua_sess);
6609 if (!registry) {
6610 DBG("Application session is being torn down. Abort event notify");
6611 ret = 0;
6612 goto error_rcu_unlock;
6613 }
6614
6615 if (ua_sess->buffer_type == LTTNG_BUFFER_PER_UID) {
6616 chan_reg_key = ua_chan->tracing_channel_id;
6617 } else {
6618 chan_reg_key = ua_chan->key;
6619 }
6620
6621 pthread_mutex_lock(&registry->lock);
6622
6623 /*
6624 * From this point on, this call acquires the ownership of the sig, fields
6625 * and model_emf_uri meaning any free are done inside it if needed. These
6626 * three variables MUST NOT be read/write after this.
6627 */
6628 ret_code = ust_registry_create_event(registry, chan_reg_key,
6629 sobjd, cobjd, name, sig, nr_fields, fields,
6630 loglevel_value, model_emf_uri, ua_sess->buffer_type,
6631 &event_id, app);
6632 sig = NULL;
6633 fields = NULL;
6634 model_emf_uri = NULL;
6635
6636 /*
6637 * The return value is returned to ustctl so in case of an error, the
6638 * application can be notified. In case of an error, it's important not to
6639 * return a negative error or else the application will get closed.
6640 */
6641 ret = lttng_ust_ctl_reply_register_event(sock, event_id, ret_code);
6642 if (ret < 0) {
6643 if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
6644 DBG3("UST app reply event failed. Application died: pid = %d, sock = %d.",
6645 app->pid, app->sock);
6646 } else if (ret == -EAGAIN) {
6647 WARN("UST app reply event failed. Communication time out: pid = %d, sock = %d",
6648 app->pid, app->sock);
6649 } else {
6650 ERR("UST app reply event failed with ret %d: pid = %d, sock = %d",
6651 ret, app->pid, app->sock);
6652 }
6653 /*
6654 * No need to wipe the create event since the application socket will
6655 * get close on error hence cleaning up everything by itself.
6656 */
6657 goto error;
6658 }
6659
6660 DBG3("UST registry event %s with id %" PRId32 " added successfully",
6661 name, event_id);
6662
6663 error:
6664 pthread_mutex_unlock(&registry->lock);
6665 error_rcu_unlock:
6666 rcu_read_unlock();
6667 free(sig);
6668 free(fields);
6669 free(model_emf_uri);
6670 return ret;
6671 }
6672
6673 /*
6674 * Add enum to the UST session registry. Once done, this replies to the
6675 * application with the appropriate error code.
6676 *
6677 * The session UST registry lock is acquired within this function.
6678 *
6679 * On success 0 is returned else a negative value.
6680 */
6681 static int add_enum_ust_registry(int sock, int sobjd, char *name,
6682 struct lttng_ust_ctl_enum_entry *entries, size_t nr_entries)
6683 {
6684 int ret = 0, ret_code;
6685 struct ust_app *app;
6686 struct ust_app_session *ua_sess;
6687 struct ust_registry_session *registry;
6688 uint64_t enum_id = -1ULL;
6689
6690 rcu_read_lock();
6691
6692 /* Lookup application. If not found, there is a code flow error. */
6693 app = find_app_by_notify_sock(sock);
6694 if (!app) {
6695 /* Return an error since this is not an error */
6696 DBG("Application socket %d is being torn down. Aborting enum registration",
6697 sock);
6698 free(entries);
6699 ret = -1;
6700 goto error_rcu_unlock;
6701 }
6702
6703 /* Lookup session by UST object descriptor. */
6704 ua_sess = find_session_by_objd(app, sobjd);
6705 if (!ua_sess) {
6706 /* Return an error since this is not an error */
6707 DBG("Application session is being torn down (session not found). Aborting enum registration.");
6708 free(entries);
6709 goto error_rcu_unlock;
6710 }
6711
6712 registry = get_session_registry(ua_sess);
6713 if (!registry) {
6714 DBG("Application session is being torn down (registry not found). Aborting enum registration.");
6715 free(entries);
6716 goto error_rcu_unlock;
6717 }
6718
6719 pthread_mutex_lock(&registry->lock);
6720
6721 /*
6722 * From this point on, the callee acquires the ownership of
6723 * entries. The variable entries MUST NOT be read/written after
6724 * call.
6725 */
6726 ret_code = ust_registry_create_or_find_enum(registry, sobjd, name,
6727 entries, nr_entries, &enum_id);
6728 entries = NULL;
6729
6730 /*
6731 * The return value is returned to ustctl so in case of an error, the
6732 * application can be notified. In case of an error, it's important not to
6733 * return a negative error or else the application will get closed.
6734 */
6735 ret = lttng_ust_ctl_reply_register_enum(sock, enum_id, ret_code);
6736 if (ret < 0) {
6737 if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
6738 DBG3("UST app reply enum failed. Application died: pid = %d, sock = %d",
6739 app->pid, app->sock);
6740 } else if (ret == -EAGAIN) {
6741 WARN("UST app reply enum failed. Communication time out: pid = %d, sock = %d",
6742 app->pid, app->sock);
6743 } else {
6744 ERR("UST app reply enum failed with ret %d: pid = %d, sock = %d",
6745 ret, app->pid, app->sock);
6746 }
6747 /*
6748 * No need to wipe the create enum since the application socket will
6749 * get close on error hence cleaning up everything by itself.
6750 */
6751 goto error;
6752 }
6753
6754 DBG3("UST registry enum %s added successfully or already found", name);
6755
6756 error:
6757 pthread_mutex_unlock(&registry->lock);
6758 error_rcu_unlock:
6759 rcu_read_unlock();
6760 return ret;
6761 }
6762
6763 /*
6764 * Handle application notification through the given notify socket.
6765 *
6766 * Return 0 on success or else a negative value.
6767 */
6768 int ust_app_recv_notify(int sock)
6769 {
6770 int ret;
6771 enum lttng_ust_ctl_notify_cmd cmd;
6772
6773 DBG3("UST app receiving notify from sock %d", sock);
6774
6775 ret = lttng_ust_ctl_recv_notify(sock, &cmd);
6776 if (ret < 0) {
6777 if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
6778 DBG3("UST app recv notify failed. Application died: sock = %d",
6779 sock);
6780 } else if (ret == -EAGAIN) {
6781 WARN("UST app recv notify failed. Communication time out: sock = %d",
6782 sock);
6783 } else {
6784 ERR("UST app recv notify failed with ret %d: sock = %d",
6785 ret, sock);
6786 }
6787 goto error;
6788 }
6789
6790 switch (cmd) {
6791 case LTTNG_UST_CTL_NOTIFY_CMD_EVENT:
6792 {
6793 int sobjd, cobjd, loglevel_value;
6794 char name[LTTNG_UST_ABI_SYM_NAME_LEN], *sig, *model_emf_uri;
6795 size_t nr_fields;
6796 struct lttng_ust_ctl_field *fields;
6797
6798 DBG2("UST app ustctl register event received");
6799
6800 ret = lttng_ust_ctl_recv_register_event(sock, &sobjd, &cobjd, name,
6801 &loglevel_value, &sig, &nr_fields, &fields,
6802 &model_emf_uri);
6803 if (ret < 0) {
6804 if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
6805 DBG3("UST app recv event failed. Application died: sock = %d",
6806 sock);
6807 } else if (ret == -EAGAIN) {
6808 WARN("UST app recv event failed. Communication time out: sock = %d",
6809 sock);
6810 } else {
6811 ERR("UST app recv event failed with ret %d: sock = %d",
6812 ret, sock);
6813 }
6814 goto error;
6815 }
6816
6817 /*
6818 * Add event to the UST registry coming from the notify socket. This
6819 * call will free if needed the sig, fields and model_emf_uri. This
6820 * code path loses the ownsership of these variables and transfer them
6821 * to the this function.
6822 */
6823 ret = add_event_ust_registry(sock, sobjd, cobjd, name, sig, nr_fields,
6824 fields, loglevel_value, model_emf_uri);
6825 if (ret < 0) {
6826 goto error;
6827 }
6828
6829 break;
6830 }
6831 case LTTNG_UST_CTL_NOTIFY_CMD_CHANNEL:
6832 {
6833 int sobjd, cobjd;
6834 size_t nr_fields;
6835 struct lttng_ust_ctl_field *fields;
6836
6837 DBG2("UST app ustctl register channel received");
6838
6839 ret = lttng_ust_ctl_recv_register_channel(sock, &sobjd, &cobjd, &nr_fields,
6840 &fields);
6841 if (ret < 0) {
6842 if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
6843 DBG3("UST app recv channel failed. Application died: sock = %d",
6844 sock);
6845 } else if (ret == -EAGAIN) {
6846 WARN("UST app recv channel failed. Communication time out: sock = %d",
6847 sock);
6848 } else {
6849 ERR("UST app recv channel failed with ret %d: sock = %d",
6850 ret, sock);
6851 }
6852 goto error;
6853 }
6854
6855 /*
6856 * The fields ownership are transfered to this function call meaning
6857 * that if needed it will be freed. After this, it's invalid to access
6858 * fields or clean it up.
6859 */
6860 ret = reply_ust_register_channel(sock, cobjd, nr_fields,
6861 fields);
6862 if (ret < 0) {
6863 goto error;
6864 }
6865
6866 break;
6867 }
6868 case LTTNG_UST_CTL_NOTIFY_CMD_ENUM:
6869 {
6870 int sobjd;
6871 char name[LTTNG_UST_ABI_SYM_NAME_LEN];
6872 size_t nr_entries;
6873 struct lttng_ust_ctl_enum_entry *entries;
6874
6875 DBG2("UST app ustctl register enum received");
6876
6877 ret = lttng_ust_ctl_recv_register_enum(sock, &sobjd, name,
6878 &entries, &nr_entries);
6879 if (ret < 0) {
6880 if (ret == -EPIPE || ret == -LTTNG_UST_ERR_EXITING) {
6881 DBG3("UST app recv enum failed. Application died: sock = %d",
6882 sock);
6883 } else if (ret == -EAGAIN) {
6884 WARN("UST app recv enum failed. Communication time out: sock = %d",
6885 sock);
6886 } else {
6887 ERR("UST app recv enum failed with ret %d: sock = %d",
6888 ret, sock);
6889 }
6890 goto error;
6891 }
6892
6893 /* Callee assumes ownership of entries */
6894 ret = add_enum_ust_registry(sock, sobjd, name,
6895 entries, nr_entries);
6896 if (ret < 0) {
6897 goto error;
6898 }
6899
6900 break;
6901 }
6902 default:
6903 /* Should NEVER happen. */
6904 abort();
6905 }
6906
6907 error:
6908 return ret;
6909 }
6910
6911 /*
6912 * Once the notify socket hangs up, this is called. First, it tries to find the
6913 * corresponding application. On failure, the call_rcu to close the socket is
6914 * executed. If an application is found, it tries to delete it from the notify
6915 * socket hash table. Whathever the result, it proceeds to the call_rcu.
6916 *
6917 * Note that an object needs to be allocated here so on ENOMEM failure, the
6918 * call RCU is not done but the rest of the cleanup is.
6919 */
6920 void ust_app_notify_sock_unregister(int sock)
6921 {
6922 int err_enomem = 0;
6923 struct lttng_ht_iter iter;
6924 struct ust_app *app;
6925 struct ust_app_notify_sock_obj *obj;
6926
6927 LTTNG_ASSERT(sock >= 0);
6928
6929 rcu_read_lock();
6930
6931 obj = (ust_app_notify_sock_obj *) zmalloc(sizeof(*obj));
6932 if (!obj) {
6933 /*
6934 * An ENOMEM is kind of uncool. If this strikes we continue the
6935 * procedure but the call_rcu will not be called. In this case, we
6936 * accept the fd leak rather than possibly creating an unsynchronized
6937 * state between threads.
6938 *
6939 * TODO: The notify object should be created once the notify socket is
6940 * registered and stored independantely from the ust app object. The
6941 * tricky part is to synchronize the teardown of the application and
6942 * this notify object. Let's keep that in mind so we can avoid this
6943 * kind of shenanigans with ENOMEM in the teardown path.
6944 */
6945 err_enomem = 1;
6946 } else {
6947 obj->fd = sock;
6948 }
6949
6950 DBG("UST app notify socket unregister %d", sock);
6951
6952 /*
6953 * Lookup application by notify socket. If this fails, this means that the
6954 * hash table delete has already been done by the application
6955 * unregistration process so we can safely close the notify socket in a
6956 * call RCU.
6957 */
6958 app = find_app_by_notify_sock(sock);
6959 if (!app) {
6960 goto close_socket;
6961 }
6962
6963 iter.iter.node = &app->notify_sock_n.node;
6964
6965 /*
6966 * Whatever happens here either we fail or succeed, in both cases we have
6967 * to close the socket after a grace period to continue to the call RCU
6968 * here. If the deletion is successful, the application is not visible
6969 * anymore by other threads and is it fails it means that it was already
6970 * deleted from the hash table so either way we just have to close the
6971 * socket.
6972 */
6973 (void) lttng_ht_del(ust_app_ht_by_notify_sock, &iter);
6974
6975 close_socket:
6976 rcu_read_unlock();
6977
6978 /*
6979 * Close socket after a grace period to avoid for the socket to be reused
6980 * before the application object is freed creating potential race between
6981 * threads trying to add unique in the global hash table.
6982 */
6983 if (!err_enomem) {
6984 call_rcu(&obj->head, close_notify_sock_rcu);
6985 }
6986 }
6987
6988 /*
6989 * Destroy a ust app data structure and free its memory.
6990 */
6991 void ust_app_destroy(struct ust_app *app)
6992 {
6993 if (!app) {
6994 return;
6995 }
6996
6997 call_rcu(&app->pid_n.head, delete_ust_app_rcu);
6998 }
6999
7000 /*
7001 * Take a snapshot for a given UST session. The snapshot is sent to the given
7002 * output.
7003 *
7004 * Returns LTTNG_OK on success or a LTTNG_ERR error code.
7005 */
7006 enum lttng_error_code ust_app_snapshot_record(
7007 const struct ltt_ust_session *usess,
7008 const struct consumer_output *output, int wait,
7009 uint64_t nb_packets_per_stream)
7010 {
7011 int ret = 0;
7012 enum lttng_error_code status = LTTNG_OK;
7013 struct lttng_ht_iter iter;
7014 struct ust_app *app;
7015 char *trace_path = NULL;
7016
7017 LTTNG_ASSERT(usess);
7018 LTTNG_ASSERT(output);
7019
7020 rcu_read_lock();
7021
7022 switch (usess->buffer_type) {
7023 case LTTNG_BUFFER_PER_UID:
7024 {
7025 struct buffer_reg_uid *reg;
7026
7027 cds_list_for_each_entry(reg, &usess->buffer_reg_uid_list, lnode) {
7028 struct buffer_reg_channel *buf_reg_chan;
7029 struct consumer_socket *socket;
7030 char pathname[PATH_MAX];
7031 size_t consumer_path_offset = 0;
7032
7033 if (!reg->registry->reg.ust->metadata_key) {
7034 /* Skip since no metadata is present */
7035 continue;
7036 }
7037
7038 /* Get consumer socket to use to push the metadata.*/
7039 socket = consumer_find_socket_by_bitness(reg->bits_per_long,
7040 usess->consumer);
7041 if (!socket) {
7042 status = LTTNG_ERR_INVALID;
7043 goto error;
7044 }
7045
7046 memset(pathname, 0, sizeof(pathname));
7047 ret = snprintf(pathname, sizeof(pathname),
7048 DEFAULT_UST_TRACE_UID_PATH,
7049 reg->uid, reg->bits_per_long);
7050 if (ret < 0) {
7051 PERROR("snprintf snapshot path");
7052 status = LTTNG_ERR_INVALID;
7053 goto error;
7054 }
7055 /* Free path allowed on previous iteration. */
7056 free(trace_path);
7057 trace_path = setup_channel_trace_path(usess->consumer, pathname,
7058 &consumer_path_offset);
7059 if (!trace_path) {
7060 status = LTTNG_ERR_INVALID;
7061 goto error;
7062 }
7063 /* Add the UST default trace dir to path. */
7064 cds_lfht_for_each_entry(reg->registry->channels->ht, &iter.iter,
7065 buf_reg_chan, node.node) {
7066 status = consumer_snapshot_channel(socket,
7067 buf_reg_chan->consumer_key,
7068 output, 0, usess->uid,
7069 usess->gid, &trace_path[consumer_path_offset], wait,
7070 nb_packets_per_stream);
7071 if (status != LTTNG_OK) {
7072 goto error;
7073 }
7074 }
7075 status = consumer_snapshot_channel(socket,
7076 reg->registry->reg.ust->metadata_key, output, 1,
7077 usess->uid, usess->gid, &trace_path[consumer_path_offset],
7078 wait, 0);
7079 if (status != LTTNG_OK) {
7080 goto error;
7081 }
7082 }
7083 break;
7084 }
7085 case LTTNG_BUFFER_PER_PID:
7086 {
7087 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
7088 struct consumer_socket *socket;
7089 struct lttng_ht_iter chan_iter;
7090 struct ust_app_channel *ua_chan;
7091 struct ust_app_session *ua_sess;
7092 struct ust_registry_session *registry;
7093 char pathname[PATH_MAX];
7094 size_t consumer_path_offset = 0;
7095
7096 ua_sess = lookup_session_by_app(usess, app);
7097 if (!ua_sess) {
7098 /* Session not associated with this app. */
7099 continue;
7100 }
7101
7102 /* Get the right consumer socket for the application. */
7103 socket = consumer_find_socket_by_bitness(app->bits_per_long,
7104 output);
7105 if (!socket) {
7106 status = LTTNG_ERR_INVALID;
7107 goto error;
7108 }
7109
7110 /* Add the UST default trace dir to path. */
7111 memset(pathname, 0, sizeof(pathname));
7112 ret = snprintf(pathname, sizeof(pathname), "%s",
7113 ua_sess->path);
7114 if (ret < 0) {
7115 status = LTTNG_ERR_INVALID;
7116 PERROR("snprintf snapshot path");
7117 goto error;
7118 }
7119 /* Free path allowed on previous iteration. */
7120 free(trace_path);
7121 trace_path = setup_channel_trace_path(usess->consumer, pathname,
7122 &consumer_path_offset);
7123 if (!trace_path) {
7124 status = LTTNG_ERR_INVALID;
7125 goto error;
7126 }
7127 cds_lfht_for_each_entry(ua_sess->channels->ht, &chan_iter.iter,
7128 ua_chan, node.node) {
7129 status = consumer_snapshot_channel(socket,
7130 ua_chan->key, output, 0,
7131 lttng_credentials_get_uid(&ua_sess->effective_credentials),
7132 lttng_credentials_get_gid(&ua_sess->effective_credentials),
7133 &trace_path[consumer_path_offset], wait,
7134 nb_packets_per_stream);
7135 switch (status) {
7136 case LTTNG_OK:
7137 break;
7138 case LTTNG_ERR_CHAN_NOT_FOUND:
7139 continue;
7140 default:
7141 goto error;
7142 }
7143 }
7144
7145 registry = get_session_registry(ua_sess);
7146 if (!registry) {
7147 DBG("Application session is being torn down. Skip application.");
7148 continue;
7149 }
7150 status = consumer_snapshot_channel(socket,
7151 registry->metadata_key, output, 1,
7152 lttng_credentials_get_uid(&ua_sess->effective_credentials),
7153 lttng_credentials_get_gid(&ua_sess->effective_credentials),
7154 &trace_path[consumer_path_offset], wait, 0);
7155 switch (status) {
7156 case LTTNG_OK:
7157 break;
7158 case LTTNG_ERR_CHAN_NOT_FOUND:
7159 continue;
7160 default:
7161 goto error;
7162 }
7163 }
7164 break;
7165 }
7166 default:
7167 abort();
7168 break;
7169 }
7170
7171 error:
7172 free(trace_path);
7173 rcu_read_unlock();
7174 return status;
7175 }
7176
7177 /*
7178 * Return the size taken by one more packet per stream.
7179 */
7180 uint64_t ust_app_get_size_one_more_packet_per_stream(
7181 const struct ltt_ust_session *usess, uint64_t cur_nr_packets)
7182 {
7183 uint64_t tot_size = 0;
7184 struct ust_app *app;
7185 struct lttng_ht_iter iter;
7186
7187 LTTNG_ASSERT(usess);
7188
7189 switch (usess->buffer_type) {
7190 case LTTNG_BUFFER_PER_UID:
7191 {
7192 struct buffer_reg_uid *reg;
7193
7194 cds_list_for_each_entry(reg, &usess->buffer_reg_uid_list, lnode) {
7195 struct buffer_reg_channel *buf_reg_chan;
7196
7197 rcu_read_lock();
7198 cds_lfht_for_each_entry(reg->registry->channels->ht, &iter.iter,
7199 buf_reg_chan, node.node) {
7200 if (cur_nr_packets >= buf_reg_chan->num_subbuf) {
7201 /*
7202 * Don't take channel into account if we
7203 * already grab all its packets.
7204 */
7205 continue;
7206 }
7207 tot_size += buf_reg_chan->subbuf_size * buf_reg_chan->stream_count;
7208 }
7209 rcu_read_unlock();
7210 }
7211 break;
7212 }
7213 case LTTNG_BUFFER_PER_PID:
7214 {
7215 rcu_read_lock();
7216 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
7217 struct ust_app_channel *ua_chan;
7218 struct ust_app_session *ua_sess;
7219 struct lttng_ht_iter chan_iter;
7220
7221 ua_sess = lookup_session_by_app(usess, app);
7222 if (!ua_sess) {
7223 /* Session not associated with this app. */
7224 continue;
7225 }
7226
7227 cds_lfht_for_each_entry(ua_sess->channels->ht, &chan_iter.iter,
7228 ua_chan, node.node) {
7229 if (cur_nr_packets >= ua_chan->attr.num_subbuf) {
7230 /*
7231 * Don't take channel into account if we
7232 * already grab all its packets.
7233 */
7234 continue;
7235 }
7236 tot_size += ua_chan->attr.subbuf_size * ua_chan->streams.count;
7237 }
7238 }
7239 rcu_read_unlock();
7240 break;
7241 }
7242 default:
7243 abort();
7244 break;
7245 }
7246
7247 return tot_size;
7248 }
7249
7250 int ust_app_uid_get_channel_runtime_stats(uint64_t ust_session_id,
7251 struct cds_list_head *buffer_reg_uid_list,
7252 struct consumer_output *consumer, uint64_t uchan_id,
7253 int overwrite, uint64_t *discarded, uint64_t *lost)
7254 {
7255 int ret;
7256 uint64_t consumer_chan_key;
7257
7258 *discarded = 0;
7259 *lost = 0;
7260
7261 ret = buffer_reg_uid_consumer_channel_key(
7262 buffer_reg_uid_list, uchan_id, &consumer_chan_key);
7263 if (ret < 0) {
7264 /* Not found */
7265 ret = 0;
7266 goto end;
7267 }
7268
7269 if (overwrite) {
7270 ret = consumer_get_lost_packets(ust_session_id,
7271 consumer_chan_key, consumer, lost);
7272 } else {
7273 ret = consumer_get_discarded_events(ust_session_id,
7274 consumer_chan_key, consumer, discarded);
7275 }
7276
7277 end:
7278 return ret;
7279 }
7280
7281 int ust_app_pid_get_channel_runtime_stats(struct ltt_ust_session *usess,
7282 struct ltt_ust_channel *uchan,
7283 struct consumer_output *consumer, int overwrite,
7284 uint64_t *discarded, uint64_t *lost)
7285 {
7286 int ret = 0;
7287 struct lttng_ht_iter iter;
7288 struct lttng_ht_node_str *ua_chan_node;
7289 struct ust_app *app;
7290 struct ust_app_session *ua_sess;
7291 struct ust_app_channel *ua_chan;
7292
7293 *discarded = 0;
7294 *lost = 0;
7295
7296 rcu_read_lock();
7297 /*
7298 * Iterate over every registered applications. Sum counters for
7299 * all applications containing requested session and channel.
7300 */
7301 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
7302 struct lttng_ht_iter uiter;
7303
7304 ua_sess = lookup_session_by_app(usess, app);
7305 if (ua_sess == NULL) {
7306 continue;
7307 }
7308
7309 /* Get channel */
7310 lttng_ht_lookup(ua_sess->channels, (void *) uchan->name, &uiter);
7311 ua_chan_node = lttng_ht_iter_get_node_str(&uiter);
7312 /* If the session is found for the app, the channel must be there */
7313 LTTNG_ASSERT(ua_chan_node);
7314
7315 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
7316
7317 if (overwrite) {
7318 uint64_t _lost;
7319
7320 ret = consumer_get_lost_packets(usess->id, ua_chan->key,
7321 consumer, &_lost);
7322 if (ret < 0) {
7323 break;
7324 }
7325 (*lost) += _lost;
7326 } else {
7327 uint64_t _discarded;
7328
7329 ret = consumer_get_discarded_events(usess->id,
7330 ua_chan->key, consumer, &_discarded);
7331 if (ret < 0) {
7332 break;
7333 }
7334 (*discarded) += _discarded;
7335 }
7336 }
7337
7338 rcu_read_unlock();
7339 return ret;
7340 }
7341
7342 static
7343 int ust_app_regenerate_statedump(struct ltt_ust_session *usess,
7344 struct ust_app *app)
7345 {
7346 int ret = 0;
7347 struct ust_app_session *ua_sess;
7348
7349 DBG("Regenerating the metadata for ust app pid %d", app->pid);
7350
7351 rcu_read_lock();
7352
7353 ua_sess = lookup_session_by_app(usess, app);
7354 if (ua_sess == NULL) {
7355 /* The session is in teardown process. Ignore and continue. */
7356 goto end;
7357 }
7358
7359 pthread_mutex_lock(&ua_sess->lock);
7360
7361 if (ua_sess->deleted) {
7362 goto end_unlock;
7363 }
7364
7365 pthread_mutex_lock(&app->sock_lock);
7366 ret = lttng_ust_ctl_regenerate_statedump(app->sock, ua_sess->handle);
7367 pthread_mutex_unlock(&app->sock_lock);
7368
7369 end_unlock:
7370 pthread_mutex_unlock(&ua_sess->lock);
7371
7372 end:
7373 rcu_read_unlock();
7374 health_code_update();
7375 return ret;
7376 }
7377
7378 /*
7379 * Regenerate the statedump for each app in the session.
7380 */
7381 int ust_app_regenerate_statedump_all(struct ltt_ust_session *usess)
7382 {
7383 int ret = 0;
7384 struct lttng_ht_iter iter;
7385 struct ust_app *app;
7386
7387 DBG("Regenerating the metadata for all UST apps");
7388
7389 rcu_read_lock();
7390
7391 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
7392 if (!app->compatible) {
7393 continue;
7394 }
7395
7396 ret = ust_app_regenerate_statedump(usess, app);
7397 if (ret < 0) {
7398 /* Continue to the next app even on error */
7399 continue;
7400 }
7401 }
7402
7403 rcu_read_unlock();
7404
7405 return 0;
7406 }
7407
7408 /*
7409 * Rotate all the channels of a session.
7410 *
7411 * Return LTTNG_OK on success or else an LTTng error code.
7412 */
7413 enum lttng_error_code ust_app_rotate_session(struct ltt_session *session)
7414 {
7415 int ret;
7416 enum lttng_error_code cmd_ret = LTTNG_OK;
7417 struct lttng_ht_iter iter;
7418 struct ust_app *app;
7419 struct ltt_ust_session *usess = session->ust_session;
7420
7421 LTTNG_ASSERT(usess);
7422
7423 rcu_read_lock();
7424
7425 switch (usess->buffer_type) {
7426 case LTTNG_BUFFER_PER_UID:
7427 {
7428 struct buffer_reg_uid *reg;
7429
7430 cds_list_for_each_entry(reg, &usess->buffer_reg_uid_list, lnode) {
7431 struct buffer_reg_channel *buf_reg_chan;
7432 struct consumer_socket *socket;
7433
7434 /* Get consumer socket to use to push the metadata.*/
7435 socket = consumer_find_socket_by_bitness(reg->bits_per_long,
7436 usess->consumer);
7437 if (!socket) {
7438 cmd_ret = LTTNG_ERR_INVALID;
7439 goto error;
7440 }
7441
7442 /* Rotate the data channels. */
7443 cds_lfht_for_each_entry(reg->registry->channels->ht, &iter.iter,
7444 buf_reg_chan, node.node) {
7445 ret = consumer_rotate_channel(socket,
7446 buf_reg_chan->consumer_key,
7447 usess->uid, usess->gid,
7448 usess->consumer,
7449 /* is_metadata_channel */ false);
7450 if (ret < 0) {
7451 cmd_ret = LTTNG_ERR_ROTATION_FAIL_CONSUMER;
7452 goto error;
7453 }
7454 }
7455
7456 /*
7457 * The metadata channel might not be present.
7458 *
7459 * Consumer stream allocation can be done
7460 * asynchronously and can fail on intermediary
7461 * operations (i.e add context) and lead to data
7462 * channels created with no metadata channel.
7463 */
7464 if (!reg->registry->reg.ust->metadata_key) {
7465 /* Skip since no metadata is present. */
7466 continue;
7467 }
7468
7469 (void) push_metadata(reg->registry->reg.ust, usess->consumer);
7470
7471 ret = consumer_rotate_channel(socket,
7472 reg->registry->reg.ust->metadata_key,
7473 usess->uid, usess->gid,
7474 usess->consumer,
7475 /* is_metadata_channel */ true);
7476 if (ret < 0) {
7477 cmd_ret = LTTNG_ERR_ROTATION_FAIL_CONSUMER;
7478 goto error;
7479 }
7480 }
7481 break;
7482 }
7483 case LTTNG_BUFFER_PER_PID:
7484 {
7485 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
7486 struct consumer_socket *socket;
7487 struct lttng_ht_iter chan_iter;
7488 struct ust_app_channel *ua_chan;
7489 struct ust_app_session *ua_sess;
7490 struct ust_registry_session *registry;
7491
7492 ua_sess = lookup_session_by_app(usess, app);
7493 if (!ua_sess) {
7494 /* Session not associated with this app. */
7495 continue;
7496 }
7497
7498 /* Get the right consumer socket for the application. */
7499 socket = consumer_find_socket_by_bitness(app->bits_per_long,
7500 usess->consumer);
7501 if (!socket) {
7502 cmd_ret = LTTNG_ERR_INVALID;
7503 goto error;
7504 }
7505
7506 registry = get_session_registry(ua_sess);
7507 if (!registry) {
7508 DBG("Application session is being torn down. Skip application.");
7509 continue;
7510 }
7511
7512 /* Rotate the data channels. */
7513 cds_lfht_for_each_entry(ua_sess->channels->ht, &chan_iter.iter,
7514 ua_chan, node.node) {
7515 ret = consumer_rotate_channel(socket,
7516 ua_chan->key,
7517 lttng_credentials_get_uid(&ua_sess->effective_credentials),
7518 lttng_credentials_get_gid(&ua_sess->effective_credentials),
7519 ua_sess->consumer,
7520 /* is_metadata_channel */ false);
7521 if (ret < 0) {
7522 /* Per-PID buffer and application going away. */
7523 if (ret == -LTTNG_ERR_CHAN_NOT_FOUND)
7524 continue;
7525 cmd_ret = LTTNG_ERR_ROTATION_FAIL_CONSUMER;
7526 goto error;
7527 }
7528 }
7529
7530 /* Rotate the metadata channel. */
7531 (void) push_metadata(registry, usess->consumer);
7532 ret = consumer_rotate_channel(socket,
7533 registry->metadata_key,
7534 lttng_credentials_get_uid(&ua_sess->effective_credentials),
7535 lttng_credentials_get_gid(&ua_sess->effective_credentials),
7536 ua_sess->consumer,
7537 /* is_metadata_channel */ true);
7538 if (ret < 0) {
7539 /* Per-PID buffer and application going away. */
7540 if (ret == -LTTNG_ERR_CHAN_NOT_FOUND)
7541 continue;
7542 cmd_ret = LTTNG_ERR_ROTATION_FAIL_CONSUMER;
7543 goto error;
7544 }
7545 }
7546 break;
7547 }
7548 default:
7549 abort();
7550 break;
7551 }
7552
7553 cmd_ret = LTTNG_OK;
7554
7555 error:
7556 rcu_read_unlock();
7557 return cmd_ret;
7558 }
7559
7560 enum lttng_error_code ust_app_create_channel_subdirectories(
7561 const struct ltt_ust_session *usess)
7562 {
7563 enum lttng_error_code ret = LTTNG_OK;
7564 struct lttng_ht_iter iter;
7565 enum lttng_trace_chunk_status chunk_status;
7566 char *pathname_index;
7567 int fmt_ret;
7568
7569 LTTNG_ASSERT(usess->current_trace_chunk);
7570 rcu_read_lock();
7571
7572 switch (usess->buffer_type) {
7573 case LTTNG_BUFFER_PER_UID:
7574 {
7575 struct buffer_reg_uid *reg;
7576
7577 cds_list_for_each_entry(reg, &usess->buffer_reg_uid_list, lnode) {
7578 fmt_ret = asprintf(&pathname_index,
7579 DEFAULT_UST_TRACE_DIR "/" DEFAULT_UST_TRACE_UID_PATH "/" DEFAULT_INDEX_DIR,
7580 reg->uid, reg->bits_per_long);
7581 if (fmt_ret < 0) {
7582 ERR("Failed to format channel index directory");
7583 ret = LTTNG_ERR_CREATE_DIR_FAIL;
7584 goto error;
7585 }
7586
7587 /*
7588 * Create the index subdirectory which will take care
7589 * of implicitly creating the channel's path.
7590 */
7591 chunk_status = lttng_trace_chunk_create_subdirectory(
7592 usess->current_trace_chunk,
7593 pathname_index);
7594 free(pathname_index);
7595 if (chunk_status != LTTNG_TRACE_CHUNK_STATUS_OK) {
7596 ret = LTTNG_ERR_CREATE_DIR_FAIL;
7597 goto error;
7598 }
7599 }
7600 break;
7601 }
7602 case LTTNG_BUFFER_PER_PID:
7603 {
7604 struct ust_app *app;
7605
7606 /*
7607 * Create the toplevel ust/ directory in case no apps are running.
7608 */
7609 chunk_status = lttng_trace_chunk_create_subdirectory(
7610 usess->current_trace_chunk,
7611 DEFAULT_UST_TRACE_DIR);
7612 if (chunk_status != LTTNG_TRACE_CHUNK_STATUS_OK) {
7613 ret = LTTNG_ERR_CREATE_DIR_FAIL;
7614 goto error;
7615 }
7616
7617 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app,
7618 pid_n.node) {
7619 struct ust_app_session *ua_sess;
7620 struct ust_registry_session *registry;
7621
7622 ua_sess = lookup_session_by_app(usess, app);
7623 if (!ua_sess) {
7624 /* Session not associated with this app. */
7625 continue;
7626 }
7627
7628 registry = get_session_registry(ua_sess);
7629 if (!registry) {
7630 DBG("Application session is being torn down. Skip application.");
7631 continue;
7632 }
7633
7634 fmt_ret = asprintf(&pathname_index,
7635 DEFAULT_UST_TRACE_DIR "/%s/" DEFAULT_INDEX_DIR,
7636 ua_sess->path);
7637 if (fmt_ret < 0) {
7638 ERR("Failed to format channel index directory");
7639 ret = LTTNG_ERR_CREATE_DIR_FAIL;
7640 goto error;
7641 }
7642 /*
7643 * Create the index subdirectory which will take care
7644 * of implicitly creating the channel's path.
7645 */
7646 chunk_status = lttng_trace_chunk_create_subdirectory(
7647 usess->current_trace_chunk,
7648 pathname_index);
7649 free(pathname_index);
7650 if (chunk_status != LTTNG_TRACE_CHUNK_STATUS_OK) {
7651 ret = LTTNG_ERR_CREATE_DIR_FAIL;
7652 goto error;
7653 }
7654 }
7655 break;
7656 }
7657 default:
7658 abort();
7659 }
7660
7661 ret = LTTNG_OK;
7662 error:
7663 rcu_read_unlock();
7664 return ret;
7665 }
7666
7667 /*
7668 * Clear all the channels of a session.
7669 *
7670 * Return LTTNG_OK on success or else an LTTng error code.
7671 */
7672 enum lttng_error_code ust_app_clear_session(struct ltt_session *session)
7673 {
7674 int ret;
7675 enum lttng_error_code cmd_ret = LTTNG_OK;
7676 struct lttng_ht_iter iter;
7677 struct ust_app *app;
7678 struct ltt_ust_session *usess = session->ust_session;
7679
7680 LTTNG_ASSERT(usess);
7681
7682 rcu_read_lock();
7683
7684 if (usess->active) {
7685 ERR("Expecting inactive session %s (%" PRIu64 ")", session->name, session->id);
7686 cmd_ret = LTTNG_ERR_FATAL;
7687 goto end;
7688 }
7689
7690 switch (usess->buffer_type) {
7691 case LTTNG_BUFFER_PER_UID:
7692 {
7693 struct buffer_reg_uid *reg;
7694
7695 cds_list_for_each_entry(reg, &usess->buffer_reg_uid_list, lnode) {
7696 struct buffer_reg_channel *buf_reg_chan;
7697 struct consumer_socket *socket;
7698
7699 /* Get consumer socket to use to push the metadata.*/
7700 socket = consumer_find_socket_by_bitness(reg->bits_per_long,
7701 usess->consumer);
7702 if (!socket) {
7703 cmd_ret = LTTNG_ERR_INVALID;
7704 goto error_socket;
7705 }
7706
7707 /* Clear the data channels. */
7708 cds_lfht_for_each_entry(reg->registry->channels->ht, &iter.iter,
7709 buf_reg_chan, node.node) {
7710 ret = consumer_clear_channel(socket,
7711 buf_reg_chan->consumer_key);
7712 if (ret < 0) {
7713 goto error;
7714 }
7715 }
7716
7717 (void) push_metadata(reg->registry->reg.ust, usess->consumer);
7718
7719 /*
7720 * Clear the metadata channel.
7721 * Metadata channel is not cleared per se but we still need to
7722 * perform a rotation operation on it behind the scene.
7723 */
7724 ret = consumer_clear_channel(socket,
7725 reg->registry->reg.ust->metadata_key);
7726 if (ret < 0) {
7727 goto error;
7728 }
7729 }
7730 break;
7731 }
7732 case LTTNG_BUFFER_PER_PID:
7733 {
7734 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
7735 struct consumer_socket *socket;
7736 struct lttng_ht_iter chan_iter;
7737 struct ust_app_channel *ua_chan;
7738 struct ust_app_session *ua_sess;
7739 struct ust_registry_session *registry;
7740
7741 ua_sess = lookup_session_by_app(usess, app);
7742 if (!ua_sess) {
7743 /* Session not associated with this app. */
7744 continue;
7745 }
7746
7747 /* Get the right consumer socket for the application. */
7748 socket = consumer_find_socket_by_bitness(app->bits_per_long,
7749 usess->consumer);
7750 if (!socket) {
7751 cmd_ret = LTTNG_ERR_INVALID;
7752 goto error_socket;
7753 }
7754
7755 registry = get_session_registry(ua_sess);
7756 if (!registry) {
7757 DBG("Application session is being torn down. Skip application.");
7758 continue;
7759 }
7760
7761 /* Clear the data channels. */
7762 cds_lfht_for_each_entry(ua_sess->channels->ht, &chan_iter.iter,
7763 ua_chan, node.node) {
7764 ret = consumer_clear_channel(socket, ua_chan->key);
7765 if (ret < 0) {
7766 /* Per-PID buffer and application going away. */
7767 if (ret == -LTTNG_ERR_CHAN_NOT_FOUND) {
7768 continue;
7769 }
7770 goto error;
7771 }
7772 }
7773
7774 (void) push_metadata(registry, usess->consumer);
7775
7776 /*
7777 * Clear the metadata channel.
7778 * Metadata channel is not cleared per se but we still need to
7779 * perform rotation operation on it behind the scene.
7780 */
7781 ret = consumer_clear_channel(socket, registry->metadata_key);
7782 if (ret < 0) {
7783 /* Per-PID buffer and application going away. */
7784 if (ret == -LTTNG_ERR_CHAN_NOT_FOUND) {
7785 continue;
7786 }
7787 goto error;
7788 }
7789 }
7790 break;
7791 }
7792 default:
7793 abort();
7794 break;
7795 }
7796
7797 cmd_ret = LTTNG_OK;
7798 goto end;
7799
7800 error:
7801 switch (-ret) {
7802 case LTTCOMM_CONSUMERD_RELAYD_CLEAR_DISALLOWED:
7803 cmd_ret = LTTNG_ERR_CLEAR_RELAY_DISALLOWED;
7804 break;
7805 default:
7806 cmd_ret = LTTNG_ERR_CLEAR_FAIL_CONSUMER;
7807 }
7808
7809 error_socket:
7810 end:
7811 rcu_read_unlock();
7812 return cmd_ret;
7813 }
7814
7815 /*
7816 * This function skips the metadata channel as the begin/end timestamps of a
7817 * metadata packet are useless.
7818 *
7819 * Moreover, opening a packet after a "clear" will cause problems for live
7820 * sessions as it will introduce padding that was not part of the first trace
7821 * chunk. The relay daemon expects the content of the metadata stream of
7822 * successive metadata trace chunks to be strict supersets of one another.
7823 *
7824 * For example, flushing a packet at the beginning of the metadata stream of
7825 * a trace chunk resulting from a "clear" session command will cause the
7826 * size of the metadata stream of the new trace chunk to not match the size of
7827 * the metadata stream of the original chunk. This will confuse the relay
7828 * daemon as the same "offset" in a metadata stream will no longer point
7829 * to the same content.
7830 */
7831 enum lttng_error_code ust_app_open_packets(struct ltt_session *session)
7832 {
7833 enum lttng_error_code ret = LTTNG_OK;
7834 struct lttng_ht_iter iter;
7835 struct ltt_ust_session *usess = session->ust_session;
7836
7837 LTTNG_ASSERT(usess);
7838
7839 rcu_read_lock();
7840
7841 switch (usess->buffer_type) {
7842 case LTTNG_BUFFER_PER_UID:
7843 {
7844 struct buffer_reg_uid *reg;
7845
7846 cds_list_for_each_entry (
7847 reg, &usess->buffer_reg_uid_list, lnode) {
7848 struct buffer_reg_channel *buf_reg_chan;
7849 struct consumer_socket *socket;
7850
7851 socket = consumer_find_socket_by_bitness(
7852 reg->bits_per_long, usess->consumer);
7853 if (!socket) {
7854 ret = LTTNG_ERR_FATAL;
7855 goto error;
7856 }
7857
7858 cds_lfht_for_each_entry(reg->registry->channels->ht,
7859 &iter.iter, buf_reg_chan, node.node) {
7860 const int open_ret =
7861 consumer_open_channel_packets(
7862 socket,
7863 buf_reg_chan->consumer_key);
7864
7865 if (open_ret < 0) {
7866 ret = LTTNG_ERR_UNK;
7867 goto error;
7868 }
7869 }
7870 }
7871 break;
7872 }
7873 case LTTNG_BUFFER_PER_PID:
7874 {
7875 struct ust_app *app;
7876
7877 cds_lfht_for_each_entry (
7878 ust_app_ht->ht, &iter.iter, app, pid_n.node) {
7879 struct consumer_socket *socket;
7880 struct lttng_ht_iter chan_iter;
7881 struct ust_app_channel *ua_chan;
7882 struct ust_app_session *ua_sess;
7883 struct ust_registry_session *registry;
7884
7885 ua_sess = lookup_session_by_app(usess, app);
7886 if (!ua_sess) {
7887 /* Session not associated with this app. */
7888 continue;
7889 }
7890
7891 /* Get the right consumer socket for the application. */
7892 socket = consumer_find_socket_by_bitness(
7893 app->bits_per_long, usess->consumer);
7894 if (!socket) {
7895 ret = LTTNG_ERR_FATAL;
7896 goto error;
7897 }
7898
7899 registry = get_session_registry(ua_sess);
7900 if (!registry) {
7901 DBG("Application session is being torn down. Skip application.");
7902 continue;
7903 }
7904
7905 cds_lfht_for_each_entry(ua_sess->channels->ht,
7906 &chan_iter.iter, ua_chan, node.node) {
7907 const int open_ret =
7908 consumer_open_channel_packets(
7909 socket,
7910 ua_chan->key);
7911
7912 if (open_ret < 0) {
7913 /*
7914 * Per-PID buffer and application going
7915 * away.
7916 */
7917 if (open_ret == -LTTNG_ERR_CHAN_NOT_FOUND) {
7918 continue;
7919 }
7920
7921 ret = LTTNG_ERR_UNK;
7922 goto error;
7923 }
7924 }
7925 }
7926 break;
7927 }
7928 default:
7929 abort();
7930 break;
7931 }
7932
7933 error:
7934 rcu_read_unlock();
7935 return ret;
7936 }
This page took 0.195754 seconds and 4 git commands to generate.