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