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