712e577091975dd97bbae4971d79f6005728168b
[lttng-tools.git] / src / bin / lttng-sessiond / ust-app.cpp
1 /*
2 * Copyright (C) 2011 David Goulet <david.goulet@polymtl.ca>
3 * Copyright (C) 2016 Jérémie Galarneau <jeremie.galarneau@efficios.com>
4 *
5 * 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
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;