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