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