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