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