Fix: bad logical check of error codes
[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
2820/*
2821 * Return pointer to traceable apps list.
2822 */
bec39940 2823struct lttng_ht *ust_app_get_ht(void)
5b4a0ec0
DG
2824{
2825 return ust_app_ht;
2826}
2827
2828/*
d88aee68
DG
2829 * Return ust app pointer or NULL if not found. RCU read side lock MUST be
2830 * acquired before calling this function.
5b4a0ec0
DG
2831 */
2832struct ust_app *ust_app_find_by_pid(pid_t pid)
2833{
d88aee68 2834 struct ust_app *app = NULL;
bec39940
DG
2835 struct lttng_ht_node_ulong *node;
2836 struct lttng_ht_iter iter;
5b4a0ec0 2837
bec39940
DG
2838 lttng_ht_lookup(ust_app_ht, (void *)((unsigned long) pid), &iter);
2839 node = lttng_ht_iter_get_node_ulong(&iter);
5b4a0ec0
DG
2840 if (node == NULL) {
2841 DBG2("UST app no found with pid %d", pid);
2842 goto error;
2843 }
5b4a0ec0
DG
2844
2845 DBG2("Found UST app by pid %d", pid);
2846
d88aee68 2847 app = caa_container_of(node, struct ust_app, pid_n);
5b4a0ec0
DG
2848
2849error:
d88aee68 2850 return app;
5b4a0ec0
DG
2851}
2852
d88aee68
DG
2853/*
2854 * Allocate and init an UST app object using the registration information and
2855 * the command socket. This is called when the command socket connects to the
2856 * session daemon.
2857 *
2858 * The object is returned on success or else NULL.
2859 */
d0b96690 2860struct ust_app *ust_app_create(struct ust_register_msg *msg, int sock)
5b4a0ec0 2861{
d0b96690
DG
2862 struct ust_app *lta = NULL;
2863
2864 assert(msg);
2865 assert(sock >= 0);
2866
2867 DBG3("UST app creating application for socket %d", sock);
5b4a0ec0 2868
173af62f
DG
2869 if ((msg->bits_per_long == 64 &&
2870 (uatomic_read(&ust_consumerd64_fd) == -EINVAL))
2871 || (msg->bits_per_long == 32 &&
2872 (uatomic_read(&ust_consumerd32_fd) == -EINVAL))) {
f943b0fb 2873 ERR("Registration failed: application \"%s\" (pid: %d) has "
d0b96690
DG
2874 "%d-bit long, but no consumerd for this size is available.\n",
2875 msg->name, msg->pid, msg->bits_per_long);
2876 goto error;
3f2c5fcc 2877 }
d0b96690 2878
5b4a0ec0
DG
2879 lta = zmalloc(sizeof(struct ust_app));
2880 if (lta == NULL) {
2881 PERROR("malloc");
d0b96690 2882 goto error;
5b4a0ec0
DG
2883 }
2884
2885 lta->ppid = msg->ppid;
2886 lta->uid = msg->uid;
2887 lta->gid = msg->gid;
d0b96690 2888
7753dea8 2889 lta->bits_per_long = msg->bits_per_long;
d0b96690
DG
2890 lta->uint8_t_alignment = msg->uint8_t_alignment;
2891 lta->uint16_t_alignment = msg->uint16_t_alignment;
2892 lta->uint32_t_alignment = msg->uint32_t_alignment;
2893 lta->uint64_t_alignment = msg->uint64_t_alignment;
2894 lta->long_alignment = msg->long_alignment;
2895 lta->byte_order = msg->byte_order;
2896
5b4a0ec0
DG
2897 lta->v_major = msg->major;
2898 lta->v_minor = msg->minor;
d9bf3ca4 2899 lta->sessions = lttng_ht_new(0, LTTNG_HT_TYPE_U64);
d0b96690
DG
2900 lta->ust_objd = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG);
2901 lta->notify_sock = -1;
d88aee68
DG
2902
2903 /* Copy name and make sure it's NULL terminated. */
2904 strncpy(lta->name, msg->name, sizeof(lta->name));
2905 lta->name[UST_APP_PROCNAME_LEN] = '\0';
2906
2907 /*
2908 * Before this can be called, when receiving the registration information,
2909 * the application compatibility is checked. So, at this point, the
2910 * application can work with this session daemon.
2911 */
d0b96690 2912 lta->compatible = 1;
5b4a0ec0 2913
852d0037 2914 lta->pid = msg->pid;
d0b96690 2915 lttng_ht_node_init_ulong(&lta->pid_n, (unsigned long) lta->pid);
852d0037 2916 lta->sock = sock;
d0b96690 2917 lttng_ht_node_init_ulong(&lta->sock_n, (unsigned long) lta->sock);
5b4a0ec0 2918
d42f20df
DG
2919 CDS_INIT_LIST_HEAD(&lta->teardown_head);
2920
d0b96690
DG
2921error:
2922 return lta;
2923}
2924
d88aee68
DG
2925/*
2926 * For a given application object, add it to every hash table.
2927 */
d0b96690
DG
2928void ust_app_add(struct ust_app *app)
2929{
2930 assert(app);
2931 assert(app->notify_sock >= 0);
2932
5b4a0ec0 2933 rcu_read_lock();
852d0037
DG
2934
2935 /*
2936 * On a re-registration, we want to kick out the previous registration of
2937 * that pid
2938 */
d0b96690 2939 lttng_ht_add_replace_ulong(ust_app_ht, &app->pid_n);
852d0037
DG
2940
2941 /*
2942 * The socket _should_ be unique until _we_ call close. So, a add_unique
2943 * for the ust_app_ht_by_sock is used which asserts fail if the entry was
2944 * already in the table.
2945 */
d0b96690 2946 lttng_ht_add_unique_ulong(ust_app_ht_by_sock, &app->sock_n);
852d0037 2947
d0b96690
DG
2948 /* Add application to the notify socket hash table. */
2949 lttng_ht_node_init_ulong(&app->notify_sock_n, app->notify_sock);
2950 lttng_ht_add_unique_ulong(ust_app_ht_by_notify_sock, &app->notify_sock_n);
5b4a0ec0 2951
d0b96690 2952 DBG("App registered with pid:%d ppid:%d uid:%d gid:%d sock:%d name:%s "
d88aee68
DG
2953 "notify_sock:%d (version %d.%d)", app->pid, app->ppid, app->uid,
2954 app->gid, app->sock, app->name, app->notify_sock, app->v_major,
2955 app->v_minor);
5b4a0ec0 2956
d0b96690
DG
2957 rcu_read_unlock();
2958}
2959
d88aee68
DG
2960/*
2961 * Set the application version into the object.
2962 *
2963 * Return 0 on success else a negative value either an errno code or a
2964 * LTTng-UST error code.
2965 */
d0b96690
DG
2966int ust_app_version(struct ust_app *app)
2967{
d88aee68
DG
2968 int ret;
2969
d0b96690 2970 assert(app);
d88aee68
DG
2971
2972 ret = ustctl_tracer_version(app->sock, &app->version);
2973 if (ret < 0) {
2974 if (ret != -LTTNG_UST_ERR_EXITING && ret != -EPIPE) {
2975 ERR("UST app %d verson failed with ret %d", app->sock, ret);
2976 } else {
2977 DBG3("UST app %d verion failed. Application is dead", app->sock);
2978 }
2979 }
2980
2981 return ret;
5b4a0ec0
DG
2982}
2983
2984/*
2985 * Unregister app by removing it from the global traceable app list and freeing
2986 * the data struct.
2987 *
2988 * The socket is already closed at this point so no close to sock.
2989 */
2990void ust_app_unregister(int sock)
2991{
2992 struct ust_app *lta;
bec39940
DG
2993 struct lttng_ht_node_ulong *node;
2994 struct lttng_ht_iter iter;
d42f20df 2995 struct ust_app_session *ua_sess;
525b0740 2996 int ret;
5b4a0ec0
DG
2997
2998 rcu_read_lock();
886459c6 2999
5b4a0ec0 3000 /* Get the node reference for a call_rcu */
852d0037 3001 lttng_ht_lookup(ust_app_ht_by_sock, (void *)((unsigned long) sock), &iter);
bec39940 3002 node = lttng_ht_iter_get_node_ulong(&iter);
d0b96690 3003 assert(node);
284d8f55 3004
852d0037 3005 lta = caa_container_of(node, struct ust_app, sock_n);
852d0037
DG
3006 DBG("PID %d unregistering with sock %d", lta->pid, sock);
3007
886459c6 3008 /* Remove application from PID hash table */
852d0037
DG
3009 ret = lttng_ht_del(ust_app_ht_by_sock, &iter);
3010 assert(!ret);
3011
d88aee68
DG
3012 /*
3013 * Remove application from notify hash table. The thread handling the
3014 * notify socket could have deleted the node so ignore on error because
3015 * either way it's valid. The close of that socket is handled by the other
3016 * thread.
3017 */
d0b96690 3018 iter.iter.node = &lta->notify_sock_n.node;
d88aee68 3019 (void) lttng_ht_del(ust_app_ht_by_notify_sock, &iter);
852d0037 3020
5b98a774
DG
3021 /*
3022 * Ignore return value since the node might have been removed before by an
3023 * add replace during app registration because the PID can be reassigned by
3024 * the OS.
3025 */
d0b96690 3026 iter.iter.node = &lta->pid_n.node;
bec39940 3027 ret = lttng_ht_del(ust_app_ht, &iter);
5b98a774
DG
3028 if (ret) {
3029 DBG3("Unregister app by PID %d failed. This can happen on pid reuse",
3030 lta->pid);
3031 }
852d0037 3032
d42f20df
DG
3033 /* Remove sessions so they are not visible during deletion.*/
3034 cds_lfht_for_each_entry(lta->sessions->ht, &iter.iter, ua_sess,
3035 node.node) {
7972aab2
DG
3036 struct ust_registry_session *registry;
3037
d42f20df
DG
3038 ret = lttng_ht_del(lta->sessions, &iter);
3039 if (ret) {
3040 /* The session was already removed so scheduled for teardown. */
3041 continue;
3042 }
3043
3044 /*
3045 * Add session to list for teardown. This is safe since at this point we
3046 * are the only one using this list.
3047 */
d88aee68
DG
3048 pthread_mutex_lock(&ua_sess->lock);
3049
3050 /*
3051 * Normally, this is done in the delete session process which is
3052 * executed in the call rcu below. However, upon registration we can't
3053 * afford to wait for the grace period before pushing data or else the
3054 * data pending feature can race between the unregistration and stop
3055 * command where the data pending command is sent *before* the grace
3056 * period ended.
3057 *
3058 * The close metadata below nullifies the metadata pointer in the
3059 * session so the delete session will NOT push/close a second time.
3060 */
7972aab2 3061 registry = get_session_registry(ua_sess);
1b532a60 3062 if (registry && !registry->metadata_closed) {
7972aab2
DG
3063 /* Push metadata for application before freeing the application. */
3064 (void) push_metadata(registry, ua_sess->consumer);
3065
3066 /*
3067 * Don't ask to close metadata for global per UID buffers. Close
1b532a60
DG
3068 * metadata only on destroy trace session in this case. Also, the
3069 * previous push metadata could have flag the metadata registry to
3070 * close so don't send a close command if closed.
7972aab2 3071 */
1b532a60
DG
3072 if (ua_sess->buffer_type != LTTNG_BUFFER_PER_UID &&
3073 !registry->metadata_closed) {
7972aab2
DG
3074 /* And ask to close it for this session registry. */
3075 (void) close_metadata(registry, ua_sess->consumer);
3076 }
3077 }
d88aee68 3078
d42f20df 3079 cds_list_add(&ua_sess->teardown_node, &lta->teardown_head);
d88aee68 3080 pthread_mutex_unlock(&ua_sess->lock);
d42f20df
DG
3081 }
3082
852d0037
DG
3083 /* Free memory */
3084 call_rcu(&lta->pid_n.head, delete_ust_app_rcu);
3085
5b4a0ec0
DG
3086 rcu_read_unlock();
3087 return;
284d8f55
DG
3088}
3089
3090/*
5b4a0ec0 3091 * Return traceable_app_count
284d8f55 3092 */
5b4a0ec0 3093unsigned long ust_app_list_count(void)
284d8f55 3094{
5b4a0ec0 3095 unsigned long count;
284d8f55 3096
5b4a0ec0 3097 rcu_read_lock();
bec39940 3098 count = lttng_ht_get_count(ust_app_ht);
5b4a0ec0 3099 rcu_read_unlock();
284d8f55 3100
5b4a0ec0 3101 return count;
284d8f55
DG
3102}
3103
5b4a0ec0
DG
3104/*
3105 * Fill events array with all events name of all registered apps.
3106 */
3107int ust_app_list_events(struct lttng_event **events)
421cb601 3108{
5b4a0ec0
DG
3109 int ret, handle;
3110 size_t nbmem, count = 0;
bec39940 3111 struct lttng_ht_iter iter;
5b4a0ec0 3112 struct ust_app *app;
c617c0c6 3113 struct lttng_event *tmp_event;
421cb601 3114
5b4a0ec0 3115 nbmem = UST_APP_EVENT_LIST_SIZE;
c617c0c6
MD
3116 tmp_event = zmalloc(nbmem * sizeof(struct lttng_event));
3117 if (tmp_event == NULL) {
5b4a0ec0
DG
3118 PERROR("zmalloc ust app events");
3119 ret = -ENOMEM;
421cb601
DG
3120 goto error;
3121 }
3122
5b4a0ec0 3123 rcu_read_lock();
421cb601 3124
852d0037 3125 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
90eaa0d2 3126 struct lttng_ust_tracepoint_iter uiter;
ac3bd9c0 3127
840cb59c 3128 health_code_update();
86acf0da 3129
e0c7ec2b
DG
3130 if (!app->compatible) {
3131 /*
3132 * TODO: In time, we should notice the caller of this error by
3133 * telling him that this is a version error.
3134 */
3135 continue;
3136 }
852d0037 3137 handle = ustctl_tracepoint_list(app->sock);
5b4a0ec0 3138 if (handle < 0) {
ffe60014
DG
3139 if (handle != -EPIPE && handle != -LTTNG_UST_ERR_EXITING) {
3140 ERR("UST app list events getting handle failed for app pid %d",
3141 app->pid);
3142 }
5b4a0ec0
DG
3143 continue;
3144 }
421cb601 3145
852d0037 3146 while ((ret = ustctl_tracepoint_list_get(app->sock, handle,
fb54cdbf 3147 &uiter)) != -LTTNG_UST_ERR_NOENT) {
ffe60014
DG
3148 /* Handle ustctl error. */
3149 if (ret < 0) {
3150 free(tmp_event);
a2ba1ab0 3151 if (ret != -LTTNG_UST_ERR_EXITING && ret != -EPIPE) {
ffe60014
DG
3152 ERR("UST app tp list get failed for app %d with ret %d",
3153 app->sock, ret);
3154 } else {
3155 DBG3("UST app tp list get failed. Application is dead");
3757b385
DG
3156 /*
3157 * This is normal behavior, an application can die during the
3158 * creation process. Don't report an error so the execution can
3159 * continue normally. Continue normal execution.
3160 */
3161 break;
ffe60014
DG
3162 }
3163 goto rcu_error;
3164 }
3165
840cb59c 3166 health_code_update();
815564d8 3167 if (count >= nbmem) {
d7b3776f 3168 /* In case the realloc fails, we free the memory */
c617c0c6
MD
3169 void *ptr;
3170
815564d8
MD
3171 DBG2("Reallocating event list from %zu to %zu entries", nbmem,
3172 2 * nbmem);
3173 nbmem *= 2;
c617c0c6
MD
3174 ptr = realloc(tmp_event, nbmem * sizeof(struct lttng_event));
3175 if (ptr == NULL) {
5b4a0ec0 3176 PERROR("realloc ust app events");
c617c0c6 3177 free(tmp_event);
5b4a0ec0
DG
3178 ret = -ENOMEM;
3179 goto rcu_error;
3180 }
c617c0c6 3181 tmp_event = ptr;
5b4a0ec0 3182 }
c617c0c6
MD
3183 memcpy(tmp_event[count].name, uiter.name, LTTNG_UST_SYM_NAME_LEN);
3184 tmp_event[count].loglevel = uiter.loglevel;
3185 tmp_event[count].type = (enum lttng_event_type) LTTNG_UST_TRACEPOINT;
3186 tmp_event[count].pid = app->pid;
3187 tmp_event[count].enabled = -1;
5b4a0ec0 3188 count++;
421cb601 3189 }
421cb601
DG
3190 }
3191
5b4a0ec0 3192 ret = count;
c617c0c6 3193 *events = tmp_event;
421cb601 3194
5b4a0ec0 3195 DBG2("UST app list events done (%zu events)", count);
421cb601 3196
5b4a0ec0
DG
3197rcu_error:
3198 rcu_read_unlock();
421cb601 3199error:
840cb59c 3200 health_code_update();
5b4a0ec0 3201 return ret;
421cb601
DG
3202}
3203
f37d259d
MD
3204/*
3205 * Fill events array with all events name of all registered apps.
3206 */
3207int ust_app_list_event_fields(struct lttng_event_field **fields)
3208{
3209 int ret, handle;
3210 size_t nbmem, count = 0;
3211 struct lttng_ht_iter iter;
3212 struct ust_app *app;
c617c0c6 3213 struct lttng_event_field *tmp_event;
f37d259d
MD
3214
3215 nbmem = UST_APP_EVENT_LIST_SIZE;
c617c0c6
MD
3216 tmp_event = zmalloc(nbmem * sizeof(struct lttng_event_field));
3217 if (tmp_event == NULL) {
f37d259d
MD
3218 PERROR("zmalloc ust app event fields");
3219 ret = -ENOMEM;
3220 goto error;
3221 }
3222
3223 rcu_read_lock();
3224
3225 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
3226 struct lttng_ust_field_iter uiter;
3227
840cb59c 3228 health_code_update();
86acf0da 3229
f37d259d
MD
3230 if (!app->compatible) {
3231 /*
3232 * TODO: In time, we should notice the caller of this error by
3233 * telling him that this is a version error.
3234 */
3235 continue;
3236 }
3237 handle = ustctl_tracepoint_field_list(app->sock);
3238 if (handle < 0) {
ffe60014
DG
3239 if (handle != -EPIPE && handle != -LTTNG_UST_ERR_EXITING) {
3240 ERR("UST app list field getting handle failed for app pid %d",
3241 app->pid);
3242 }
f37d259d
MD
3243 continue;
3244 }
3245
3246 while ((ret = ustctl_tracepoint_field_list_get(app->sock, handle,
fb54cdbf 3247 &uiter)) != -LTTNG_UST_ERR_NOENT) {
ffe60014
DG
3248 /* Handle ustctl error. */
3249 if (ret < 0) {
3250 free(tmp_event);
a2ba1ab0 3251 if (ret != -LTTNG_UST_ERR_EXITING && ret != -EPIPE) {
ffe60014
DG
3252 ERR("UST app tp list field failed for app %d with ret %d",
3253 app->sock, ret);
3254 } else {
3255 DBG3("UST app tp list field failed. Application is dead");
3757b385
DG
3256 /*
3257 * This is normal behavior, an application can die during the
3258 * creation process. Don't report an error so the execution can
3259 * continue normally.
3260 */
3261 break;
ffe60014
DG
3262 }
3263 goto rcu_error;
3264 }
3265
840cb59c 3266 health_code_update();
f37d259d 3267 if (count >= nbmem) {
d7b3776f 3268 /* In case the realloc fails, we free the memory */
c617c0c6
MD
3269 void *ptr;
3270
f37d259d
MD
3271 DBG2("Reallocating event field list from %zu to %zu entries", nbmem,
3272 2 * nbmem);
3273 nbmem *= 2;
c617c0c6
MD
3274 ptr = realloc(tmp_event, nbmem * sizeof(struct lttng_event_field));
3275 if (ptr == NULL) {
f37d259d 3276 PERROR("realloc ust app event fields");
c617c0c6 3277 free(tmp_event);
f37d259d
MD
3278 ret = -ENOMEM;
3279 goto rcu_error;
3280 }
c617c0c6 3281 tmp_event = ptr;
f37d259d 3282 }
f37d259d 3283
c617c0c6 3284 memcpy(tmp_event[count].field_name, uiter.field_name, LTTNG_UST_SYM_NAME_LEN);
2e84128e
DG
3285 /* Mapping between these enums matches 1 to 1. */
3286 tmp_event[count].type = (enum lttng_event_field_type) uiter.type;
c617c0c6 3287 tmp_event[count].nowrite = uiter.nowrite;
f37d259d 3288
c617c0c6
MD
3289 memcpy(tmp_event[count].event.name, uiter.event_name, LTTNG_UST_SYM_NAME_LEN);
3290 tmp_event[count].event.loglevel = uiter.loglevel;
2e84128e 3291 tmp_event[count].event.type = LTTNG_EVENT_TRACEPOINT;
c617c0c6
MD
3292 tmp_event[count].event.pid = app->pid;
3293 tmp_event[count].event.enabled = -1;
f37d259d
MD
3294 count++;
3295 }
3296 }
3297
3298 ret = count;
c617c0c6 3299 *fields = tmp_event;
f37d259d
MD
3300
3301 DBG2("UST app list event fields done (%zu events)", count);
3302
3303rcu_error:
3304 rcu_read_unlock();
3305error:
840cb59c 3306 health_code_update();
f37d259d
MD
3307 return ret;
3308}
3309
5b4a0ec0
DG
3310/*
3311 * Free and clean all traceable apps of the global list.
36b588ed
MD
3312 *
3313 * Should _NOT_ be called with RCU read-side lock held.
5b4a0ec0
DG
3314 */
3315void ust_app_clean_list(void)
421cb601 3316{
5b4a0ec0 3317 int ret;
659ed79f 3318 struct ust_app *app;
bec39940 3319 struct lttng_ht_iter iter;
421cb601 3320
5b4a0ec0 3321 DBG2("UST app cleaning registered apps hash table");
421cb601 3322
5b4a0ec0 3323 rcu_read_lock();
421cb601 3324
659ed79f 3325 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
bec39940 3326 ret = lttng_ht_del(ust_app_ht, &iter);
525b0740 3327 assert(!ret);
659ed79f 3328 call_rcu(&app->pid_n.head, delete_ust_app_rcu);
421cb601
DG
3329 }
3330
852d0037 3331 /* Cleanup socket hash table */
659ed79f
DG
3332 cds_lfht_for_each_entry(ust_app_ht_by_sock->ht, &iter.iter, app,
3333 sock_n.node) {
852d0037 3334 ret = lttng_ht_del(ust_app_ht_by_sock, &iter);
bec39940
DG
3335 assert(!ret);
3336 }
852d0037 3337
d88aee68
DG
3338 /* Cleanup notify socket hash table */
3339 cds_lfht_for_each_entry(ust_app_ht_by_notify_sock->ht, &iter.iter, app,
3340 notify_sock_n.node) {
3341 ret = lttng_ht_del(ust_app_ht_by_notify_sock, &iter);
3342 assert(!ret);
3343 }
36b588ed 3344 rcu_read_unlock();
d88aee68 3345
bec39940 3346 /* Destroy is done only when the ht is empty */
0b2dc8df
MD
3347 ht_cleanup_push(ust_app_ht);
3348 ht_cleanup_push(ust_app_ht_by_sock);
3349 ht_cleanup_push(ust_app_ht_by_notify_sock);
5b4a0ec0
DG
3350}
3351
3352/*
3353 * Init UST app hash table.
3354 */
3355void ust_app_ht_alloc(void)
3356{
bec39940 3357 ust_app_ht = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG);
852d0037 3358 ust_app_ht_by_sock = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG);
d0b96690 3359 ust_app_ht_by_notify_sock = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG);
421cb601
DG
3360}
3361
78f0bacd
DG
3362/*
3363 * For a specific UST session, disable the channel for all registered apps.
3364 */
35a9059d 3365int ust_app_disable_channel_glb(struct ltt_ust_session *usess,
78f0bacd
DG
3366 struct ltt_ust_channel *uchan)
3367{
3368 int ret = 0;
bec39940
DG
3369 struct lttng_ht_iter iter;
3370 struct lttng_ht_node_str *ua_chan_node;
78f0bacd
DG
3371 struct ust_app *app;
3372 struct ust_app_session *ua_sess;
8535a6d9 3373 struct ust_app_channel *ua_chan;
78f0bacd
DG
3374
3375 if (usess == NULL || uchan == NULL) {
3376 ERR("Disabling UST global channel with NULL values");
3377 ret = -1;
3378 goto error;
3379 }
3380
d9bf3ca4 3381 DBG2("UST app disabling channel %s from global domain for session id %" PRIu64,
a991f516 3382 uchan->name, usess->id);
78f0bacd
DG
3383
3384 rcu_read_lock();
3385
3386 /* For every registered applications */
852d0037 3387 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
bec39940 3388 struct lttng_ht_iter uiter;
e0c7ec2b
DG
3389 if (!app->compatible) {
3390 /*
3391 * TODO: In time, we should notice the caller of this error by
3392 * telling him that this is a version error.
3393 */
3394 continue;
3395 }
78f0bacd
DG
3396 ua_sess = lookup_session_by_app(usess, app);
3397 if (ua_sess == NULL) {
3398 continue;
3399 }
3400
8535a6d9 3401 /* Get channel */
bec39940
DG
3402 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &uiter);
3403 ua_chan_node = lttng_ht_iter_get_node_str(&uiter);
8535a6d9
DG
3404 /* If the session if found for the app, the channel must be there */
3405 assert(ua_chan_node);
3406
3407 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
3408 /* The channel must not be already disabled */
3409 assert(ua_chan->enabled == 1);
3410
3411 /* Disable channel onto application */
3412 ret = disable_ust_app_channel(ua_sess, ua_chan, app);
78f0bacd
DG
3413 if (ret < 0) {
3414 /* XXX: We might want to report this error at some point... */
3415 continue;
3416 }
3417 }
3418
3419 rcu_read_unlock();
3420
3421error:
3422 return ret;
3423}
3424
3425/*
3426 * For a specific UST session, enable the channel for all registered apps.
3427 */
35a9059d 3428int ust_app_enable_channel_glb(struct ltt_ust_session *usess,
78f0bacd
DG
3429 struct ltt_ust_channel *uchan)
3430{
3431 int ret = 0;
bec39940 3432 struct lttng_ht_iter iter;
78f0bacd
DG
3433 struct ust_app *app;
3434 struct ust_app_session *ua_sess;
3435
3436 if (usess == NULL || uchan == NULL) {
3437 ERR("Adding UST global channel to NULL values");
3438 ret = -1;
3439 goto error;
3440 }
3441
d9bf3ca4 3442 DBG2("UST app enabling channel %s to global domain for session id %" PRIu64,
a991f516 3443 uchan->name, usess->id);
78f0bacd
DG
3444
3445 rcu_read_lock();
3446
3447 /* For every registered applications */
852d0037 3448 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
e0c7ec2b
DG
3449 if (!app->compatible) {
3450 /*
3451 * TODO: In time, we should notice the caller of this error by
3452 * telling him that this is a version error.
3453 */
3454 continue;
3455 }
78f0bacd
DG
3456 ua_sess = lookup_session_by_app(usess, app);
3457 if (ua_sess == NULL) {
3458 continue;
3459 }
3460
3461 /* Enable channel onto application */
3462 ret = enable_ust_app_channel(ua_sess, uchan, app);
3463 if (ret < 0) {
3464 /* XXX: We might want to report this error at some point... */
3465 continue;
3466 }
3467 }
3468
3469 rcu_read_unlock();
3470
3471error:
3472 return ret;
3473}
3474
b0a40d28
DG
3475/*
3476 * Disable an event in a channel and for a specific session.
3477 */
35a9059d
DG
3478int ust_app_disable_event_glb(struct ltt_ust_session *usess,
3479 struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent)
b0a40d28
DG
3480{
3481 int ret = 0;
bec39940
DG
3482 struct lttng_ht_iter iter, uiter;
3483 struct lttng_ht_node_str *ua_chan_node, *ua_event_node;
b0a40d28
DG
3484 struct ust_app *app;
3485 struct ust_app_session *ua_sess;
3486 struct ust_app_channel *ua_chan;
3487 struct ust_app_event *ua_event;
3488
3489 DBG("UST app disabling event %s for all apps in channel "
d9bf3ca4
MD
3490 "%s for session id %" PRIu64,
3491 uevent->attr.name, uchan->name, usess->id);
b0a40d28
DG
3492
3493 rcu_read_lock();
3494
3495 /* For all registered applications */
852d0037 3496 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
e0c7ec2b
DG
3497 if (!app->compatible) {
3498 /*
3499 * TODO: In time, we should notice the caller of this error by
3500 * telling him that this is a version error.
3501 */
3502 continue;
3503 }
b0a40d28
DG
3504 ua_sess = lookup_session_by_app(usess, app);
3505 if (ua_sess == NULL) {
3506 /* Next app */
3507 continue;
3508 }
3509
3510 /* Lookup channel in the ust app session */
bec39940
DG
3511 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &uiter);
3512 ua_chan_node = lttng_ht_iter_get_node_str(&uiter);
b0a40d28 3513 if (ua_chan_node == NULL) {
d9bf3ca4 3514 DBG2("Channel %s not found in session id %" PRIu64 " for app pid %d."
852d0037 3515 "Skipping", uchan->name, usess->id, app->pid);
b0a40d28
DG
3516 continue;
3517 }
3518 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
3519
bec39940
DG
3520 lttng_ht_lookup(ua_chan->events, (void *)uevent->attr.name, &uiter);
3521 ua_event_node = lttng_ht_iter_get_node_str(&uiter);
b0a40d28
DG
3522 if (ua_event_node == NULL) {
3523 DBG2("Event %s not found in channel %s for app pid %d."
852d0037 3524 "Skipping", uevent->attr.name, uchan->name, app->pid);
b0a40d28
DG
3525 continue;
3526 }
3527 ua_event = caa_container_of(ua_event_node, struct ust_app_event, node);
3528
7f79d3a1 3529 ret = disable_ust_app_event(ua_sess, ua_event, app);
b0a40d28
DG
3530 if (ret < 0) {
3531 /* XXX: Report error someday... */
3532 continue;
3533 }
3534 }
3535
3536 rcu_read_unlock();
3537
3538 return ret;
3539}
3540
9730260e 3541/*
edb67388 3542 * For a specific UST session and UST channel, the event for all
9730260e
DG
3543 * registered apps.
3544 */
35a9059d 3545int ust_app_disable_all_event_glb(struct ltt_ust_session *usess,
9730260e
DG
3546 struct ltt_ust_channel *uchan)
3547{
3548 int ret = 0;
bec39940
DG
3549 struct lttng_ht_iter iter, uiter;
3550 struct lttng_ht_node_str *ua_chan_node;
9730260e
DG
3551 struct ust_app *app;
3552 struct ust_app_session *ua_sess;
3553 struct ust_app_channel *ua_chan;
3554 struct ust_app_event *ua_event;
3555
3556 DBG("UST app disabling all event for all apps in channel "
d9bf3ca4 3557 "%s for session id %" PRIu64, uchan->name, usess->id);
9730260e
DG
3558
3559 rcu_read_lock();
3560
3561 /* For all registered applications */
852d0037 3562 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
e0c7ec2b
DG
3563 if (!app->compatible) {
3564 /*
3565 * TODO: In time, we should notice the caller of this error by
3566 * telling him that this is a version error.
3567 */
3568 continue;
3569 }
9730260e 3570 ua_sess = lookup_session_by_app(usess, app);
c4a1715b
DG
3571 if (!ua_sess) {
3572 /* The application has problem or is probably dead. */
3573 continue;
3574 }
9730260e
DG
3575
3576 /* Lookup channel in the ust app session */
bec39940
DG
3577 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &uiter);
3578 ua_chan_node = lttng_ht_iter_get_node_str(&uiter);
edb67388
DG
3579 /* If the channel is not found, there is a code flow error */
3580 assert(ua_chan_node);
3581
9730260e
DG
3582 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
3583
3584 /* Disable each events of channel */
bec39940
DG
3585 cds_lfht_for_each_entry(ua_chan->events->ht, &uiter.iter, ua_event,
3586 node.node) {
7f79d3a1 3587 ret = disable_ust_app_event(ua_sess, ua_event, app);
9730260e
DG
3588 if (ret < 0) {
3589 /* XXX: Report error someday... */
3590 continue;
3591 }
3592 }
3593 }
3594
3595 rcu_read_unlock();
3596
3597 return ret;
3598}
3599
421cb601 3600/*
5b4a0ec0 3601 * For a specific UST session, create the channel for all registered apps.
421cb601 3602 */
35a9059d 3603int ust_app_create_channel_glb(struct ltt_ust_session *usess,
48842b30
DG
3604 struct ltt_ust_channel *uchan)
3605{
3d8ca23b 3606 int ret = 0, created;
bec39940 3607 struct lttng_ht_iter iter;
48842b30 3608 struct ust_app *app;
3d8ca23b 3609 struct ust_app_session *ua_sess = NULL;
48842b30 3610
fc34caaa
DG
3611 /* Very wrong code flow */
3612 assert(usess);
3613 assert(uchan);
421cb601 3614
d9bf3ca4 3615 DBG2("UST app adding channel %s to UST domain for session id %" PRIu64,
a991f516 3616 uchan->name, usess->id);
48842b30
DG
3617
3618 rcu_read_lock();
421cb601 3619
5b4a0ec0 3620 /* For every registered applications */
852d0037 3621 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
e0c7ec2b
DG
3622 if (!app->compatible) {
3623 /*
3624 * TODO: In time, we should notice the caller of this error by
3625 * telling him that this is a version error.
3626 */
3627 continue;
3628 }
edb67388
DG
3629 /*
3630 * Create session on the tracer side and add it to app session HT. Note
3631 * that if session exist, it will simply return a pointer to the ust
3632 * app session.
3633 */
3d8ca23b
DG
3634 ret = create_ust_app_session(usess, app, &ua_sess, &created);
3635 if (ret < 0) {
3636 switch (ret) {
3637 case -ENOTCONN:
3638 /*
3639 * The application's socket is not valid. Either a bad socket
3640 * or a timeout on it. We can't inform the caller that for a
3641 * specific app, the session failed so lets continue here.
3642 */
3643 continue;
3644 case -ENOMEM:
3645 default:
3646 goto error_rcu_unlock;
3647 }
48842b30 3648 }
3d8ca23b 3649 assert(ua_sess);
48842b30 3650
d0b96690 3651 pthread_mutex_lock(&ua_sess->lock);
d65d2de8
DG
3652 if (!strncmp(uchan->name, DEFAULT_METADATA_NAME,
3653 sizeof(uchan->name))) {
3654 struct ustctl_consumer_channel_attr attr;
3655 copy_channel_attr_to_ustctl(&attr, &uchan->attr);
3656 ret = create_ust_app_metadata(ua_sess, app, usess->consumer,
3657 &attr);
3658 } else {
3659 /* Create channel onto application. We don't need the chan ref. */
3660 ret = create_ust_app_channel(ua_sess, uchan, app,
3661 LTTNG_UST_CHAN_PER_CPU, usess, NULL);
3662 }
d0b96690 3663 pthread_mutex_unlock(&ua_sess->lock);
3d8ca23b
DG
3664 if (ret < 0) {
3665 if (ret == -ENOMEM) {
3666 /* No more memory is a fatal error. Stop right now. */
3667 goto error_rcu_unlock;
3668 }
3669 /* Cleanup the created session if it's the case. */
3670 if (created) {
d0b96690 3671 destroy_app_session(app, ua_sess);
3d8ca23b 3672 }
48842b30 3673 }
48842b30 3674 }
5b4a0ec0 3675
95e047ff 3676error_rcu_unlock:
48842b30 3677 rcu_read_unlock();
3c14c33f 3678 return ret;
48842b30
DG
3679}
3680
5b4a0ec0 3681/*
edb67388 3682 * Enable event for a specific session and channel on the tracer.
5b4a0ec0 3683 */
35a9059d 3684int ust_app_enable_event_glb(struct ltt_ust_session *usess,
48842b30
DG
3685 struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent)
3686{
3687 int ret = 0;
bec39940 3688 struct lttng_ht_iter iter, uiter;
18eace3b 3689 struct lttng_ht_node_str *ua_chan_node;
48842b30
DG
3690 struct ust_app *app;
3691 struct ust_app_session *ua_sess;
3692 struct ust_app_channel *ua_chan;
3693 struct ust_app_event *ua_event;
48842b30 3694
d9bf3ca4 3695 DBG("UST app enabling event %s for all apps for session id %" PRIu64,
a991f516 3696 uevent->attr.name, usess->id);
48842b30 3697
edb67388
DG
3698 /*
3699 * NOTE: At this point, this function is called only if the session and
3700 * channel passed are already created for all apps. and enabled on the
3701 * tracer also.
3702 */
3703
48842b30 3704 rcu_read_lock();
421cb601
DG
3705
3706 /* For all registered applications */
852d0037 3707 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
e0c7ec2b
DG
3708 if (!app->compatible) {
3709 /*
3710 * TODO: In time, we should notice the caller of this error by
3711 * telling him that this is a version error.
3712 */
3713 continue;
3714 }
edb67388 3715 ua_sess = lookup_session_by_app(usess, app);
c4a1715b
DG
3716 if (!ua_sess) {
3717 /* The application has problem or is probably dead. */
3718 continue;
3719 }
ba767faf 3720
d0b96690
DG
3721 pthread_mutex_lock(&ua_sess->lock);
3722
edb67388 3723 /* Lookup channel in the ust app session */
bec39940
DG
3724 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &uiter);
3725 ua_chan_node = lttng_ht_iter_get_node_str(&uiter);
edb67388
DG
3726 /* If the channel is not found, there is a code flow error */
3727 assert(ua_chan_node);
3728
3729 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
3730
18eace3b
DG
3731 /* Get event node */
3732 ua_event = find_ust_app_event(ua_chan->events, uevent->attr.name,
39c5a3a7 3733 uevent->filter, uevent->attr.loglevel, uevent->exclusion);
18eace3b 3734 if (ua_event == NULL) {
7f79d3a1 3735 DBG3("UST app enable event %s not found for app PID %d."
852d0037 3736 "Skipping app", uevent->attr.name, app->pid);
d0b96690 3737 goto next_app;
35a9059d 3738 }
35a9059d
DG
3739
3740 ret = enable_ust_app_event(ua_sess, ua_event, app);
3741 if (ret < 0) {
d0b96690 3742 pthread_mutex_unlock(&ua_sess->lock);
7f79d3a1 3743 goto error;
48842b30 3744 }
d0b96690
DG
3745 next_app:
3746 pthread_mutex_unlock(&ua_sess->lock);
edb67388
DG
3747 }
3748
7f79d3a1 3749error:
edb67388 3750 rcu_read_unlock();
edb67388
DG
3751 return ret;
3752}
3753
3754/*
3755 * For a specific existing UST session and UST channel, creates the event for
3756 * all registered apps.
3757 */
35a9059d 3758int ust_app_create_event_glb(struct ltt_ust_session *usess,
edb67388
DG
3759 struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent)
3760{
3761 int ret = 0;
bec39940
DG
3762 struct lttng_ht_iter iter, uiter;
3763 struct lttng_ht_node_str *ua_chan_node;
edb67388
DG
3764 struct ust_app *app;
3765 struct ust_app_session *ua_sess;
3766 struct ust_app_channel *ua_chan;
3767
d9bf3ca4 3768 DBG("UST app creating event %s for all apps for session id %" PRIu64,
a991f516 3769 uevent->attr.name, usess->id);
edb67388 3770
edb67388
DG
3771 rcu_read_lock();
3772
3773 /* For all registered applications */
852d0037 3774 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
e0c7ec2b
DG
3775 if (!app->compatible) {
3776 /*
3777 * TODO: In time, we should notice the caller of this error by
3778 * telling him that this is a version error.
3779 */
3780 continue;
3781 }
edb67388 3782 ua_sess = lookup_session_by_app(usess, app);
c4a1715b
DG
3783 if (!ua_sess) {
3784 /* The application has problem or is probably dead. */
3785 continue;
3786 }
48842b30 3787
d0b96690 3788 pthread_mutex_lock(&ua_sess->lock);
48842b30 3789 /* Lookup channel in the ust app session */
bec39940
DG
3790 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &uiter);
3791 ua_chan_node = lttng_ht_iter_get_node_str(&uiter);
edb67388
DG
3792 /* If the channel is not found, there is a code flow error */
3793 assert(ua_chan_node);
3794
48842b30
DG
3795 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
3796
edb67388 3797 ret = create_ust_app_event(ua_sess, ua_chan, uevent, app);
d0b96690 3798 pthread_mutex_unlock(&ua_sess->lock);
edb67388 3799 if (ret < 0) {
49c336c1 3800 if (ret != -LTTNG_UST_ERR_EXIST) {
fc34caaa
DG
3801 /* Possible value at this point: -ENOMEM. If so, we stop! */
3802 break;
3803 }
3804 DBG2("UST app event %s already exist on app PID %d",
852d0037 3805 uevent->attr.name, app->pid);
5b4a0ec0 3806 continue;
48842b30 3807 }
48842b30 3808 }
5b4a0ec0 3809
48842b30
DG
3810 rcu_read_unlock();
3811
3812 return ret;
3813}
3814
5b4a0ec0
DG
3815/*
3816 * Start tracing for a specific UST session and app.
3817 */
b34cbebf 3818static
421cb601 3819int ust_app_start_trace(struct ltt_ust_session *usess, struct ust_app *app)
48842b30
DG
3820{
3821 int ret = 0;
48842b30 3822 struct ust_app_session *ua_sess;
48842b30 3823
852d0037 3824 DBG("Starting tracing for ust app pid %d", app->pid);
5cf5d0e7 3825
509cbaf8
MD
3826 rcu_read_lock();
3827
e0c7ec2b
DG
3828 if (!app->compatible) {
3829 goto end;
3830 }
3831
421cb601
DG
3832 ua_sess = lookup_session_by_app(usess, app);
3833 if (ua_sess == NULL) {
d42f20df
DG
3834 /* The session is in teardown process. Ignore and continue. */
3835 goto end;
421cb601 3836 }
48842b30 3837
d0b96690
DG
3838 pthread_mutex_lock(&ua_sess->lock);
3839
aea829b3
DG
3840 /* Upon restart, we skip the setup, already done */
3841 if (ua_sess->started) {
8be98f9a 3842 goto skip_setup;
aea829b3 3843 }
8be98f9a 3844
a4b92340
DG
3845 /* Create directories if consumer is LOCAL and has a path defined. */
3846 if (usess->consumer->type == CONSUMER_DST_LOCAL &&
3847 strlen(usess->consumer->dst.trace_path) > 0) {
3848 ret = run_as_mkdir_recursive(usess->consumer->dst.trace_path,
7972aab2 3849 S_IRWXU | S_IRWXG, ua_sess->euid, ua_sess->egid);
a4b92340
DG
3850 if (ret < 0) {
3851 if (ret != -EEXIST) {
3852 ERR("Trace directory creation error");
d0b96690 3853 goto error_unlock;
421cb601 3854 }
173af62f 3855 }
7753dea8 3856 }
aea829b3 3857
d65d2de8
DG
3858 /*
3859 * Create the metadata for the application. This returns gracefully if a
3860 * metadata was already set for the session.
3861 */
3862 ret = create_ust_app_metadata(ua_sess, app, usess->consumer, NULL);
421cb601 3863 if (ret < 0) {
d0b96690 3864 goto error_unlock;
421cb601 3865 }
48842b30 3866
840cb59c 3867 health_code_update();
86acf0da 3868
8be98f9a 3869skip_setup:
421cb601 3870 /* This start the UST tracing */
852d0037 3871 ret = ustctl_start_session(app->sock, ua_sess->handle);
421cb601 3872 if (ret < 0) {
ffe60014
DG
3873 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
3874 ERR("Error starting tracing for app pid: %d (ret: %d)",
3875 app->pid, ret);
3876 } else {
3877 DBG("UST app start session failed. Application is dead.");
3757b385
DG
3878 /*
3879 * This is normal behavior, an application can die during the
3880 * creation process. Don't report an error so the execution can
3881 * continue normally.
3882 */
3883 pthread_mutex_unlock(&ua_sess->lock);
3884 goto end;
ffe60014 3885 }
d0b96690 3886 goto error_unlock;
421cb601 3887 }
5b4a0ec0 3888
55c3953d
DG
3889 /* Indicate that the session has been started once */
3890 ua_sess->started = 1;
3891
d0b96690
DG
3892 pthread_mutex_unlock(&ua_sess->lock);
3893
840cb59c 3894 health_code_update();
86acf0da 3895
421cb601 3896 /* Quiescent wait after starting trace */
ffe60014
DG
3897 ret = ustctl_wait_quiescent(app->sock);
3898 if (ret < 0 && ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
3899 ERR("UST app wait quiescent failed for app pid %d ret %d",
3900 app->pid, ret);
3901 }
48842b30 3902
e0c7ec2b
DG
3903end:
3904 rcu_read_unlock();
840cb59c 3905 health_code_update();
421cb601 3906 return 0;
48842b30 3907
d0b96690
DG
3908error_unlock:
3909 pthread_mutex_unlock(&ua_sess->lock);
509cbaf8 3910 rcu_read_unlock();
840cb59c 3911 health_code_update();
421cb601
DG
3912 return -1;
3913}
48842b30 3914
8be98f9a
MD
3915/*
3916 * Stop tracing for a specific UST session and app.
3917 */
b34cbebf 3918static
8be98f9a
MD
3919int ust_app_stop_trace(struct ltt_ust_session *usess, struct ust_app *app)
3920{
3921 int ret = 0;
3922 struct ust_app_session *ua_sess;
7972aab2 3923 struct ust_registry_session *registry;
8be98f9a 3924
852d0037 3925 DBG("Stopping tracing for ust app pid %d", app->pid);
8be98f9a
MD
3926
3927 rcu_read_lock();
3928
e0c7ec2b 3929 if (!app->compatible) {
d88aee68 3930 goto end_no_session;
e0c7ec2b
DG
3931 }
3932
8be98f9a
MD
3933 ua_sess = lookup_session_by_app(usess, app);
3934 if (ua_sess == NULL) {
d88aee68 3935 goto end_no_session;
8be98f9a
MD
3936 }
3937
d88aee68
DG
3938 pthread_mutex_lock(&ua_sess->lock);
3939
9bc07046
DG
3940 /*
3941 * If started = 0, it means that stop trace has been called for a session
c45536e1
DG
3942 * that was never started. It's possible since we can have a fail start
3943 * from either the application manager thread or the command thread. Simply
3944 * indicate that this is a stop error.
9bc07046 3945 */
f9dfc3d9 3946 if (!ua_sess->started) {
c45536e1
DG
3947 goto error_rcu_unlock;
3948 }
7db205b5 3949
840cb59c 3950 health_code_update();
86acf0da 3951
9d6c7d3f 3952 /* This inhibits UST tracing */
852d0037 3953 ret = ustctl_stop_session(app->sock, ua_sess->handle);
9d6c7d3f 3954 if (ret < 0) {
ffe60014
DG
3955 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
3956 ERR("Error stopping tracing for app pid: %d (ret: %d)",
3957 app->pid, ret);
3958 } else {
3959 DBG("UST app stop session failed. Application is dead.");
3757b385
DG
3960 /*
3961 * This is normal behavior, an application can die during the
3962 * creation process. Don't report an error so the execution can
3963 * continue normally.
3964 */
3965 goto end_unlock;
ffe60014 3966 }
9d6c7d3f
DG
3967 goto error_rcu_unlock;
3968 }
3969
840cb59c 3970 health_code_update();
86acf0da 3971
9d6c7d3f 3972 /* Quiescent wait after stopping trace */
ffe60014
DG
3973 ret = ustctl_wait_quiescent(app->sock);
3974 if (ret < 0 && ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
3975 ERR("UST app wait quiescent failed for app pid %d ret %d",
3976 app->pid, ret);
3977 }
9d6c7d3f 3978
840cb59c 3979 health_code_update();
86acf0da 3980
b34cbebf
MD
3981 registry = get_session_registry(ua_sess);
3982 assert(registry);
1b532a60
DG
3983
3984 if (!registry->metadata_closed) {
3985 /* Push metadata for application before freeing the application. */
3986 (void) push_metadata(registry, ua_sess->consumer);
3987 }
b34cbebf 3988
3757b385 3989end_unlock:
b34cbebf
MD
3990 pthread_mutex_unlock(&ua_sess->lock);
3991end_no_session:
3992 rcu_read_unlock();
3993 health_code_update();
3994 return 0;
3995
3996error_rcu_unlock:
3997 pthread_mutex_unlock(&ua_sess->lock);
3998 rcu_read_unlock();
3999 health_code_update();
4000 return -1;
4001}
4002
4003/*
4004 * Flush buffers for a specific UST session and app.
4005 */
4006static
4007int ust_app_flush_trace(struct ltt_ust_session *usess, struct ust_app *app)
4008{
4009 int ret = 0;
4010 struct lttng_ht_iter iter;
4011 struct ust_app_session *ua_sess;
4012 struct ust_app_channel *ua_chan;
4013
4014 DBG("Flushing buffers for ust app pid %d", app->pid);
4015
4016 rcu_read_lock();
4017
4018 if (!app->compatible) {
4019 goto end_no_session;
4020 }
4021
4022 ua_sess = lookup_session_by_app(usess, app);
4023 if (ua_sess == NULL) {
4024 goto end_no_session;
4025 }
4026
4027 pthread_mutex_lock(&ua_sess->lock);
4028
4029 health_code_update();
4030
9d6c7d3f 4031 /* Flushing buffers */
bec39940
DG
4032 cds_lfht_for_each_entry(ua_sess->channels->ht, &iter.iter, ua_chan,
4033 node.node) {
840cb59c 4034 health_code_update();
ffe60014 4035 assert(ua_chan->is_sent);
852d0037 4036 ret = ustctl_sock_flush_buffer(app->sock, ua_chan->obj);
8be98f9a 4037 if (ret < 0) {
ffe60014
DG
4038 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
4039 ERR("UST app PID %d channel %s flush failed with ret %d",
4040 app->pid, ua_chan->name, ret);
4041 } else {
4042 DBG3("UST app failed to flush %s. Application is dead.",
4043 ua_chan->name);
3757b385
DG
4044 /*
4045 * This is normal behavior, an application can die during the
4046 * creation process. Don't report an error so the execution can
4047 * continue normally.
4048 */
ffe60014 4049 }
6d3686da
DG
4050 /* Continuing flushing all buffers */
4051 continue;
8be98f9a
MD
4052 }
4053 }
8be98f9a 4054
840cb59c 4055 health_code_update();
86acf0da 4056
d88aee68
DG
4057 pthread_mutex_unlock(&ua_sess->lock);
4058end_no_session:
7db205b5 4059 rcu_read_unlock();
840cb59c 4060 health_code_update();
8be98f9a 4061 return 0;
8be98f9a
MD
4062}
4063
84cd17c6
MD
4064/*
4065 * Destroy a specific UST session in apps.
4066 */
3353de95 4067static int destroy_trace(struct ltt_ust_session *usess, struct ust_app *app)
84cd17c6 4068{
ffe60014 4069 int ret;
84cd17c6 4070 struct ust_app_session *ua_sess;
bec39940 4071 struct lttng_ht_iter iter;
d9bf3ca4 4072 struct lttng_ht_node_u64 *node;
84cd17c6 4073
852d0037 4074 DBG("Destroy tracing for ust app pid %d", app->pid);
84cd17c6
MD
4075
4076 rcu_read_lock();
4077
e0c7ec2b
DG
4078 if (!app->compatible) {
4079 goto end;
4080 }
4081
84cd17c6 4082 __lookup_session_by_app(usess, app, &iter);
d9bf3ca4 4083 node = lttng_ht_iter_get_node_u64(&iter);
84cd17c6 4084 if (node == NULL) {
d42f20df
DG
4085 /* Session is being or is deleted. */
4086 goto end;
84cd17c6
MD
4087 }
4088 ua_sess = caa_container_of(node, struct ust_app_session, node);
c4a1715b 4089
840cb59c 4090 health_code_update();
d0b96690 4091 destroy_app_session(app, ua_sess);
84cd17c6 4092
840cb59c 4093 health_code_update();
7db205b5 4094
84cd17c6 4095 /* Quiescent wait after stopping trace */
ffe60014
DG
4096 ret = ustctl_wait_quiescent(app->sock);
4097 if (ret < 0 && ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
4098 ERR("UST app wait quiescent failed for app pid %d ret %d",
4099 app->pid, ret);
4100 }
e0c7ec2b
DG
4101end:
4102 rcu_read_unlock();
840cb59c 4103 health_code_update();
84cd17c6 4104 return 0;
84cd17c6
MD
4105}
4106
5b4a0ec0
DG
4107/*
4108 * Start tracing for the UST session.
4109 */
421cb601
DG
4110int ust_app_start_trace_all(struct ltt_ust_session *usess)
4111{
4112 int ret = 0;
bec39940 4113 struct lttng_ht_iter iter;
421cb601 4114 struct ust_app *app;
48842b30 4115
421cb601
DG
4116 DBG("Starting all UST traces");
4117
4118 rcu_read_lock();
421cb601 4119
852d0037 4120 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
421cb601 4121 ret = ust_app_start_trace(usess, app);
48842b30 4122 if (ret < 0) {
5b4a0ec0
DG
4123 /* Continue to next apps even on error */
4124 continue;
48842b30 4125 }
48842b30 4126 }
5b4a0ec0 4127
48842b30
DG
4128 rcu_read_unlock();
4129
4130 return 0;
4131}
487cf67c 4132
8be98f9a
MD
4133/*
4134 * Start tracing for the UST session.
4135 */
4136int ust_app_stop_trace_all(struct ltt_ust_session *usess)
4137{
4138 int ret = 0;
bec39940 4139 struct lttng_ht_iter iter;
8be98f9a
MD
4140 struct ust_app *app;
4141
4142 DBG("Stopping all UST traces");
4143
4144 rcu_read_lock();
4145
b34cbebf
MD
4146 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
4147 ret = ust_app_stop_trace(usess, app);
4148 if (ret < 0) {
4149 /* Continue to next apps even on error */
4150 continue;
4151 }
4152 }
4153
b0a5f0fb 4154 /* Flush buffers and push metadata (for UID buffers). */
b34cbebf
MD
4155 switch (usess->buffer_type) {
4156 case LTTNG_BUFFER_PER_UID:
4157 {
7972aab2 4158 struct buffer_reg_uid *reg;
b34cbebf
MD
4159
4160 /* Flush all per UID buffers associated to that session. */
7972aab2 4161 cds_list_for_each_entry(reg, &usess->buffer_reg_uid_list, lnode) {
b0a5f0fb 4162 struct ust_registry_session *ust_session_reg;
7972aab2
DG
4163 struct buffer_reg_channel *reg_chan;
4164 struct consumer_socket *socket;
4165
4166 /* Get consumer socket to use to push the metadata.*/
4167 socket = consumer_find_socket_by_bitness(reg->bits_per_long,
4168 usess->consumer);
4169 if (!socket) {
4170 /* Ignore request if no consumer is found for the session. */
4171 continue;
4172 }
4173
4174 cds_lfht_for_each_entry(reg->registry->channels->ht, &iter.iter,
4175 reg_chan, node.node) {
4176 /*
4177 * The following call will print error values so the return
4178 * code is of little importance because whatever happens, we
4179 * have to try them all.
4180 */
4181 (void) consumer_flush_channel(socket, reg_chan->consumer_key);
4182 }
b0a5f0fb
MD
4183
4184 ust_session_reg = reg->registry->reg.ust;
4185 if (!ust_session_reg->metadata_closed) {
4186 /* Push metadata. */
4187 (void) push_metadata(ust_session_reg, usess->consumer);
4188 }
7972aab2 4189 }
b0a5f0fb 4190
b34cbebf 4191 break;
7972aab2 4192 }
b34cbebf
MD
4193 case LTTNG_BUFFER_PER_PID:
4194 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
4195 ret = ust_app_flush_trace(usess, app);
4196 if (ret < 0) {
4197 /* Continue to next apps even on error */
4198 continue;
4199 }
8be98f9a 4200 }
b34cbebf
MD
4201 break;
4202 default:
4203 assert(0);
4204 break;
8be98f9a
MD
4205 }
4206
4207 rcu_read_unlock();
4208
4209 return 0;
4210}
4211
84cd17c6
MD
4212/*
4213 * Destroy app UST session.
4214 */
4215int ust_app_destroy_trace_all(struct ltt_ust_session *usess)
4216{
4217 int ret = 0;
bec39940 4218 struct lttng_ht_iter iter;
84cd17c6
MD
4219 struct ust_app *app;
4220
4221 DBG("Destroy all UST traces");
4222
4223 rcu_read_lock();
4224
852d0037 4225 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
3353de95 4226 ret = destroy_trace(usess, app);
84cd17c6
MD
4227 if (ret < 0) {
4228 /* Continue to next apps even on error */
4229 continue;
4230 }
4231 }
4232
4233 rcu_read_unlock();
4234
4235 return 0;
4236}
4237
5b4a0ec0
DG
4238/*
4239 * Add channels/events from UST global domain to registered apps at sock.
4240 */
487cf67c
DG
4241void ust_app_global_update(struct ltt_ust_session *usess, int sock)
4242{
55c54cce 4243 int ret = 0;
31746f93 4244 struct lttng_ht_iter iter, uiter;
487cf67c 4245 struct ust_app *app;
3d8ca23b 4246 struct ust_app_session *ua_sess = NULL;
487cf67c
DG
4247 struct ust_app_channel *ua_chan;
4248 struct ust_app_event *ua_event;
727d5404 4249 struct ust_app_ctx *ua_ctx;
1f3580c7 4250
95e047ff 4251 assert(usess);
ffe60014 4252 assert(sock >= 0);
1f3580c7 4253
d9bf3ca4 4254 DBG2("UST app global update for app sock %d for session id %" PRIu64, sock,
a991f516 4255 usess->id);
487cf67c 4256
284d8f55
DG
4257 rcu_read_lock();
4258
f20baf8e 4259 app = ust_app_find_by_sock(sock);
487cf67c 4260 if (app == NULL) {
d88aee68
DG
4261 /*
4262 * Application can be unregistered before so this is possible hence
4263 * simply stopping the update.
4264 */
4265 DBG3("UST app update failed to find app sock %d", sock);
487cf67c
DG
4266 goto error;
4267 }
4268
e0c7ec2b
DG
4269 if (!app->compatible) {
4270 goto error;
4271 }
4272
3d8ca23b
DG
4273 ret = create_ust_app_session(usess, app, &ua_sess, NULL);
4274 if (ret < 0) {
4275 /* Tracer is probably gone or ENOMEM. */
487cf67c
DG
4276 goto error;
4277 }
3d8ca23b 4278 assert(ua_sess);
487cf67c 4279
d0b96690
DG
4280 pthread_mutex_lock(&ua_sess->lock);
4281
284d8f55 4282 /*
d0b96690 4283 * We can iterate safely here over all UST app session since the create ust
284d8f55
DG
4284 * app session above made a shadow copy of the UST global domain from the
4285 * ltt ust session.
4286 */
bec39940
DG
4287 cds_lfht_for_each_entry(ua_sess->channels->ht, &iter.iter, ua_chan,
4288 node.node) {
d65d2de8
DG
4289 /*
4290 * For a metadata channel, handle it differently.
4291 */
4292 if (!strncmp(ua_chan->name, DEFAULT_METADATA_NAME,
4293 sizeof(ua_chan->name))) {
4294 ret = create_ust_app_metadata(ua_sess, app, usess->consumer,
4295 &ua_chan->attr);
c7a339aa
DG
4296 if (ret < 0) {
4297 goto error_unlock;
4298 }
d65d2de8
DG
4299 /* Remove it from the hash table and continue!. */
4300 ret = lttng_ht_del(ua_sess->channels, &iter);
4301 assert(!ret);
4302 delete_ust_app_channel(-1, ua_chan, app);
4303 continue;
4304 } else {
4305 ret = do_create_channel(app, usess, ua_sess, ua_chan);
c7a339aa
DG
4306 if (ret < 0) {
4307 /*
4308 * Stop everything. On error, the application failed, no more
4309 * file descriptor are available or ENOMEM so stopping here is
4310 * the only thing we can do for now.
4311 */
4312 goto error_unlock;
4313 }
487cf67c
DG
4314 }
4315
31746f93
DG
4316 /*
4317 * Add context using the list so they are enabled in the same order the
4318 * user added them.
4319 */
4320 cds_list_for_each_entry(ua_ctx, &ua_chan->ctx_list, list) {
727d5404
DG
4321 ret = create_ust_channel_context(ua_chan, ua_ctx, app);
4322 if (ret < 0) {
d0b96690 4323 goto error_unlock;
727d5404
DG
4324 }
4325 }
4326
4327
284d8f55 4328 /* For each events */
bec39940
DG
4329 cds_lfht_for_each_entry(ua_chan->events->ht, &uiter.iter, ua_event,
4330 node.node) {
284d8f55
DG
4331 ret = create_ust_event(app, ua_sess, ua_chan, ua_event);
4332 if (ret < 0) {
d0b96690 4333 goto error_unlock;
487cf67c 4334 }
36dc12cc 4335 }
487cf67c
DG
4336 }
4337
d0b96690
DG
4338 pthread_mutex_unlock(&ua_sess->lock);
4339
36dc12cc 4340 if (usess->start_trace) {
421cb601 4341 ret = ust_app_start_trace(usess, app);
36dc12cc 4342 if (ret < 0) {
36dc12cc
DG
4343 goto error;
4344 }
4345
852d0037 4346 DBG2("UST trace started for app pid %d", app->pid);
36dc12cc
DG
4347 }
4348
ffe60014
DG
4349 /* Everything went well at this point. */
4350 rcu_read_unlock();
4351 return;
4352
d0b96690
DG
4353error_unlock:
4354 pthread_mutex_unlock(&ua_sess->lock);
487cf67c 4355error:
ffe60014 4356 if (ua_sess) {
d0b96690 4357 destroy_app_session(app, ua_sess);
ffe60014 4358 }
487cf67c
DG
4359 rcu_read_unlock();
4360 return;
4361}
55cc08a6
DG
4362
4363/*
4364 * Add context to a specific channel for global UST domain.
4365 */
4366int ust_app_add_ctx_channel_glb(struct ltt_ust_session *usess,
4367 struct ltt_ust_channel *uchan, struct ltt_ust_context *uctx)
4368{
4369 int ret = 0;
bec39940
DG
4370 struct lttng_ht_node_str *ua_chan_node;
4371 struct lttng_ht_iter iter, uiter;
55cc08a6
DG
4372 struct ust_app_channel *ua_chan = NULL;
4373 struct ust_app_session *ua_sess;
4374 struct ust_app *app;
4375
4376 rcu_read_lock();
4377
852d0037 4378 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
e0c7ec2b
DG
4379 if (!app->compatible) {
4380 /*
4381 * TODO: In time, we should notice the caller of this error by
4382 * telling him that this is a version error.
4383 */
4384 continue;
4385 }
55cc08a6
DG
4386 ua_sess = lookup_session_by_app(usess, app);
4387 if (ua_sess == NULL) {
4388 continue;
4389 }
4390
d0b96690 4391 pthread_mutex_lock(&ua_sess->lock);
55cc08a6 4392 /* Lookup channel in the ust app session */
bec39940
DG
4393 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &uiter);
4394 ua_chan_node = lttng_ht_iter_get_node_str(&uiter);
55cc08a6 4395 if (ua_chan_node == NULL) {
d0b96690 4396 goto next_app;
55cc08a6
DG
4397 }
4398 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel,
4399 node);
55cc08a6
DG
4400 ret = create_ust_app_channel_context(ua_sess, ua_chan, &uctx->ctx, app);
4401 if (ret < 0) {
d0b96690 4402 goto next_app;
55cc08a6 4403 }
d0b96690
DG
4404 next_app:
4405 pthread_mutex_unlock(&ua_sess->lock);
55cc08a6
DG
4406 }
4407
55cc08a6
DG
4408 rcu_read_unlock();
4409 return ret;
4410}
4411
76d45b40
DG
4412/*
4413 * Enable event for a channel from a UST session for a specific PID.
4414 */
4415int ust_app_enable_event_pid(struct ltt_ust_session *usess,
4416 struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent, pid_t pid)
4417{
4418 int ret = 0;
bec39940 4419 struct lttng_ht_iter iter;
18eace3b 4420 struct lttng_ht_node_str *ua_chan_node;
76d45b40
DG
4421 struct ust_app *app;
4422 struct ust_app_session *ua_sess;
4423 struct ust_app_channel *ua_chan;
4424 struct ust_app_event *ua_event;
4425
4426 DBG("UST app enabling event %s for PID %d", uevent->attr.name, pid);
4427
4428 rcu_read_lock();
4429
4430 app = ust_app_find_by_pid(pid);
4431 if (app == NULL) {
4432 ERR("UST app enable event per PID %d not found", pid);
4433 ret = -1;
d0b96690 4434 goto end;
76d45b40
DG
4435 }
4436
e0c7ec2b
DG
4437 if (!app->compatible) {
4438 ret = 0;
d0b96690 4439 goto end;
e0c7ec2b
DG
4440 }
4441
76d45b40 4442 ua_sess = lookup_session_by_app(usess, app);
c4a1715b
DG
4443 if (!ua_sess) {
4444 /* The application has problem or is probably dead. */
d0b96690
DG
4445 ret = 0;
4446 goto end;
c4a1715b 4447 }
76d45b40 4448
d0b96690 4449 pthread_mutex_lock(&ua_sess->lock);
76d45b40 4450 /* Lookup channel in the ust app session */
bec39940
DG
4451 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &iter);
4452 ua_chan_node = lttng_ht_iter_get_node_str(&iter);
76d45b40
DG
4453 /* If the channel is not found, there is a code flow error */
4454 assert(ua_chan_node);
4455
4456 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
4457
18eace3b 4458 ua_event = find_ust_app_event(ua_chan->events, uevent->attr.name,
39c5a3a7 4459 uevent->filter, uevent->attr.loglevel, uevent->exclusion);
18eace3b 4460 if (ua_event == NULL) {
76d45b40
DG
4461 ret = create_ust_app_event(ua_sess, ua_chan, uevent, app);
4462 if (ret < 0) {
d0b96690 4463 goto end_unlock;
76d45b40
DG
4464 }
4465 } else {
76d45b40
DG
4466 ret = enable_ust_app_event(ua_sess, ua_event, app);
4467 if (ret < 0) {
d0b96690 4468 goto end_unlock;
76d45b40
DG
4469 }
4470 }
4471
d0b96690
DG
4472end_unlock:
4473 pthread_mutex_unlock(&ua_sess->lock);
4474end:
76d45b40
DG
4475 rcu_read_unlock();
4476 return ret;
4477}
7f79d3a1
DG
4478
4479/*
4480 * Disable event for a channel from a UST session for a specific PID.
4481 */
4482int ust_app_disable_event_pid(struct ltt_ust_session *usess,
4483 struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent, pid_t pid)
4484{
4485 int ret = 0;
bec39940
DG
4486 struct lttng_ht_iter iter;
4487 struct lttng_ht_node_str *ua_chan_node, *ua_event_node;
7f79d3a1
DG
4488 struct ust_app *app;
4489 struct ust_app_session *ua_sess;
4490 struct ust_app_channel *ua_chan;
4491 struct ust_app_event *ua_event;
4492
4493 DBG("UST app disabling event %s for PID %d", uevent->attr.name, pid);
4494
4495 rcu_read_lock();
4496
4497 app = ust_app_find_by_pid(pid);
4498 if (app == NULL) {
4499 ERR("UST app disable event per PID %d not found", pid);
4500 ret = -1;
4501 goto error;
4502 }
4503
e0c7ec2b
DG
4504 if (!app->compatible) {
4505 ret = 0;
4506 goto error;
4507 }
4508
7f79d3a1 4509 ua_sess = lookup_session_by_app(usess, app);
c4a1715b
DG
4510 if (!ua_sess) {
4511 /* The application has problem or is probably dead. */
4512 goto error;
4513 }
7f79d3a1
DG
4514
4515 /* Lookup channel in the ust app session */
bec39940
DG
4516 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &iter);
4517 ua_chan_node = lttng_ht_iter_get_node_str(&iter);
7f79d3a1
DG
4518 if (ua_chan_node == NULL) {
4519 /* Channel does not exist, skip disabling */
4520 goto error;
4521 }
4522 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
4523
bec39940
DG
4524 lttng_ht_lookup(ua_chan->events, (void *)uevent->attr.name, &iter);
4525 ua_event_node = lttng_ht_iter_get_node_str(&iter);
7f79d3a1
DG
4526 if (ua_event_node == NULL) {
4527 /* Event does not exist, skip disabling */
4528 goto error;
4529 }
4530 ua_event = caa_container_of(ua_event_node, struct ust_app_event, node);
4531
4532 ret = disable_ust_app_event(ua_sess, ua_event, app);
4533 if (ret < 0) {
4534 goto error;
4535 }
4536
4537error:
4538 rcu_read_unlock();
4539 return ret;
4540}
e0c7ec2b 4541
4466912f
DG
4542/*
4543 * Calibrate registered applications.
4544 */
4545int ust_app_calibrate_glb(struct lttng_ust_calibrate *calibrate)
4546{
4547 int ret = 0;
4548 struct lttng_ht_iter iter;
4549 struct ust_app *app;
4550
4551 rcu_read_lock();
4552
852d0037 4553 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
4466912f
DG
4554 if (!app->compatible) {
4555 /*
4556 * TODO: In time, we should notice the caller of this error by
4557 * telling him that this is a version error.
4558 */
4559 continue;
4560 }
4561
840cb59c 4562 health_code_update();
86acf0da 4563
852d0037 4564 ret = ustctl_calibrate(app->sock, calibrate);
4466912f
DG
4565 if (ret < 0) {
4566 switch (ret) {
4567 case -ENOSYS:
4568 /* Means that it's not implemented on the tracer side. */
4569 ret = 0;
4570 break;
4571 default:
4466912f 4572 DBG2("Calibrate app PID %d returned with error %d",
852d0037 4573 app->pid, ret);
4466912f
DG
4574 break;
4575 }
4576 }
4577 }
4578
4579 DBG("UST app global domain calibration finished");
4580
4581 rcu_read_unlock();
4582
840cb59c 4583 health_code_update();
86acf0da 4584
4466912f
DG
4585 return ret;
4586}
d0b96690
DG
4587
4588/*
4589 * Receive registration and populate the given msg structure.
4590 *
4591 * On success return 0 else a negative value returned by the ustctl call.
4592 */
4593int ust_app_recv_registration(int sock, struct ust_register_msg *msg)
4594{
4595 int ret;
4596 uint32_t pid, ppid, uid, gid;
4597
4598 assert(msg);
4599
4600 ret = ustctl_recv_reg_msg(sock, &msg->type, &msg->major, &msg->minor,
4601 &pid, &ppid, &uid, &gid,
4602 &msg->bits_per_long,
4603 &msg->uint8_t_alignment,
4604 &msg->uint16_t_alignment,
4605 &msg->uint32_t_alignment,
4606 &msg->uint64_t_alignment,
4607 &msg->long_alignment,
4608 &msg->byte_order,
4609 msg->name);
4610 if (ret < 0) {
4611 switch (-ret) {
4612 case EPIPE:
4613 case ECONNRESET:
4614 case LTTNG_UST_ERR_EXITING:
4615 DBG3("UST app recv reg message failed. Application died");
4616 break;
4617 case LTTNG_UST_ERR_UNSUP_MAJOR:
4618 ERR("UST app recv reg unsupported version %d.%d. Supporting %d.%d",
4619 msg->major, msg->minor, LTTNG_UST_ABI_MAJOR_VERSION,
4620 LTTNG_UST_ABI_MINOR_VERSION);
4621 break;
4622 default:
4623 ERR("UST app recv reg message failed with ret %d", ret);
4624 break;
4625 }
4626 goto error;
4627 }
4628 msg->pid = (pid_t) pid;
4629 msg->ppid = (pid_t) ppid;
4630 msg->uid = (uid_t) uid;
4631 msg->gid = (gid_t) gid;
4632
4633error:
4634 return ret;
4635}
4636
d88aee68
DG
4637/*
4638 * Return a ust app channel object using the application object and the channel
4639 * object descriptor has a key. If not found, NULL is returned. A RCU read side
4640 * lock MUST be acquired before calling this function.
4641 */
d0b96690
DG
4642static struct ust_app_channel *find_channel_by_objd(struct ust_app *app,
4643 int objd)
4644{
4645 struct lttng_ht_node_ulong *node;
4646 struct lttng_ht_iter iter;
4647 struct ust_app_channel *ua_chan = NULL;
4648
4649 assert(app);
4650
4651 lttng_ht_lookup(app->ust_objd, (void *)((unsigned long) objd), &iter);
4652 node = lttng_ht_iter_get_node_ulong(&iter);
4653 if (node == NULL) {
4654 DBG2("UST app channel find by objd %d not found", objd);
4655 goto error;
4656 }
4657
4658 ua_chan = caa_container_of(node, struct ust_app_channel, ust_objd_node);
4659
4660error:
4661 return ua_chan;
4662}
4663
d88aee68
DG
4664/*
4665 * Reply to a register channel notification from an application on the notify
4666 * socket. The channel metadata is also created.
4667 *
4668 * The session UST registry lock is acquired in this function.
4669 *
4670 * On success 0 is returned else a negative value.
4671 */
d0b96690
DG
4672static int reply_ust_register_channel(int sock, int sobjd, int cobjd,
4673 size_t nr_fields, struct ustctl_field *fields)
4674{
4675 int ret, ret_code = 0;
4676 uint32_t chan_id, reg_count;
7972aab2 4677 uint64_t chan_reg_key;
d0b96690
DG
4678 enum ustctl_channel_header type;
4679 struct ust_app *app;
4680 struct ust_app_channel *ua_chan;
4681 struct ust_app_session *ua_sess;
7972aab2 4682 struct ust_registry_session *registry;
45893984 4683 struct ust_registry_channel *chan_reg;
d0b96690
DG
4684
4685 rcu_read_lock();
4686
4687 /* Lookup application. If not found, there is a code flow error. */
4688 app = find_app_by_notify_sock(sock);
d88aee68
DG
4689 if (!app) {
4690 DBG("Application socket %d is being teardown. Abort event notify",
4691 sock);
4692 ret = 0;
d5d629b5 4693 free(fields);
d88aee68
DG
4694 goto error_rcu_unlock;
4695 }
d0b96690 4696
4950b860 4697 /* Lookup channel by UST object descriptor. */
d0b96690 4698 ua_chan = find_channel_by_objd(app, cobjd);
4950b860
MD
4699 if (!ua_chan) {
4700 DBG("Application channel is being teardown. Abort event notify");
4701 ret = 0;
d5d629b5 4702 free(fields);
4950b860
MD
4703 goto error_rcu_unlock;
4704 }
4705
d0b96690
DG
4706 assert(ua_chan->session);
4707 ua_sess = ua_chan->session;
d0b96690 4708
7972aab2
DG
4709 /* Get right session registry depending on the session buffer type. */
4710 registry = get_session_registry(ua_sess);
4711 assert(registry);
45893984 4712
7972aab2
DG
4713 /* Depending on the buffer type, a different channel key is used. */
4714 if (ua_sess->buffer_type == LTTNG_BUFFER_PER_UID) {
4715 chan_reg_key = ua_chan->tracing_channel_id;
d0b96690 4716 } else {
7972aab2 4717 chan_reg_key = ua_chan->key;
d0b96690
DG
4718 }
4719
7972aab2
DG
4720 pthread_mutex_lock(&registry->lock);
4721
4722 chan_reg = ust_registry_channel_find(registry, chan_reg_key);
4723 assert(chan_reg);
4724
4725 if (!chan_reg->register_done) {
4726 reg_count = ust_registry_get_event_count(chan_reg);
4727 if (reg_count < 31) {
4728 type = USTCTL_CHANNEL_HEADER_COMPACT;
4729 } else {
4730 type = USTCTL_CHANNEL_HEADER_LARGE;
4731 }
4732
4733 chan_reg->nr_ctx_fields = nr_fields;
4734 chan_reg->ctx_fields = fields;
4735 chan_reg->header_type = type;
d0b96690 4736 } else {
7972aab2
DG
4737 /* Get current already assigned values. */
4738 type = chan_reg->header_type;
d5d629b5
DG
4739 free(fields);
4740 /* Set to NULL so the error path does not do a double free. */
4741 fields = NULL;
d0b96690 4742 }
7972aab2
DG
4743 /* Channel id is set during the object creation. */
4744 chan_id = chan_reg->chan_id;
d0b96690
DG
4745
4746 /* Append to metadata */
7972aab2
DG
4747 if (!chan_reg->metadata_dumped) {
4748 ret_code = ust_metadata_channel_statedump(registry, chan_reg);
d0b96690
DG
4749 if (ret_code) {
4750 ERR("Error appending channel metadata (errno = %d)", ret_code);
4751 goto reply;
4752 }
4753 }
4754
4755reply:
7972aab2
DG
4756 DBG3("UST app replying to register channel key %" PRIu64
4757 " with id %u, type: %d, ret: %d", chan_reg_key, chan_id, type,
4758 ret_code);
d0b96690
DG
4759
4760 ret = ustctl_reply_register_channel(sock, chan_id, type, ret_code);
4761 if (ret < 0) {
4762 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
4763 ERR("UST app reply channel failed with ret %d", ret);
4764 } else {
4765 DBG3("UST app reply channel failed. Application died");
4766 }
4767 goto error;
4768 }
4769
7972aab2
DG
4770 /* This channel registry registration is completed. */
4771 chan_reg->register_done = 1;
4772
d0b96690 4773error:
7972aab2 4774 pthread_mutex_unlock(&registry->lock);
d88aee68 4775error_rcu_unlock:
d0b96690 4776 rcu_read_unlock();
d5d629b5
DG
4777 if (ret) {
4778 free(fields);
4779 }
d0b96690
DG
4780 return ret;
4781}
4782
d88aee68
DG
4783/*
4784 * Add event to the UST channel registry. When the event is added to the
4785 * registry, the metadata is also created. Once done, this replies to the
4786 * application with the appropriate error code.
4787 *
4788 * The session UST registry lock is acquired in the function.
4789 *
4790 * On success 0 is returned else a negative value.
4791 */
d0b96690
DG
4792static int add_event_ust_registry(int sock, int sobjd, int cobjd, char *name,
4793 char *sig, size_t nr_fields, struct ustctl_field *fields, int loglevel,
4794 char *model_emf_uri)
4795{
4796 int ret, ret_code;
4797 uint32_t event_id = 0;
7972aab2 4798 uint64_t chan_reg_key;
d0b96690
DG
4799 struct ust_app *app;
4800 struct ust_app_channel *ua_chan;
4801 struct ust_app_session *ua_sess;
7972aab2 4802 struct ust_registry_session *registry;
d0b96690
DG
4803
4804 rcu_read_lock();
4805
4806 /* Lookup application. If not found, there is a code flow error. */
4807 app = find_app_by_notify_sock(sock);
d88aee68
DG
4808 if (!app) {
4809 DBG("Application socket %d is being teardown. Abort event notify",
4810 sock);
4811 ret = 0;
d5d629b5
DG
4812 free(sig);
4813 free(fields);
4814 free(model_emf_uri);
d88aee68
DG
4815 goto error_rcu_unlock;
4816 }
d0b96690 4817
4950b860 4818 /* Lookup channel by UST object descriptor. */
d0b96690 4819 ua_chan = find_channel_by_objd(app, cobjd);
4950b860
MD
4820 if (!ua_chan) {
4821 DBG("Application channel is being teardown. Abort event notify");
4822 ret = 0;
d5d629b5
DG
4823 free(sig);
4824 free(fields);
4825 free(model_emf_uri);
4950b860
MD
4826 goto error_rcu_unlock;
4827 }
4828
d0b96690
DG
4829 assert(ua_chan->session);
4830 ua_sess = ua_chan->session;
4831
7972aab2
DG
4832 registry = get_session_registry(ua_sess);
4833 assert(registry);
4834
4835 if (ua_sess->buffer_type == LTTNG_BUFFER_PER_UID) {
4836 chan_reg_key = ua_chan->tracing_channel_id;
4837 } else {
4838 chan_reg_key = ua_chan->key;
4839 }
4840
4841 pthread_mutex_lock(&registry->lock);
d0b96690 4842
d5d629b5
DG
4843 /*
4844 * From this point on, this call acquires the ownership of the sig, fields
4845 * and model_emf_uri meaning any free are done inside it if needed. These
4846 * three variables MUST NOT be read/write after this.
4847 */
7972aab2 4848 ret_code = ust_registry_create_event(registry, chan_reg_key,
45893984 4849 sobjd, cobjd, name, sig, nr_fields, fields, loglevel,
8494bda5
MD
4850 model_emf_uri, ua_sess->buffer_type, &event_id,
4851 app);
d0b96690
DG
4852
4853 /*
4854 * The return value is returned to ustctl so in case of an error, the
4855 * application can be notified. In case of an error, it's important not to
4856 * return a negative error or else the application will get closed.
4857 */
4858 ret = ustctl_reply_register_event(sock, event_id, ret_code);
4859 if (ret < 0) {
4860 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
4861 ERR("UST app reply event failed with ret %d", ret);
4862 } else {
4863 DBG3("UST app reply event failed. Application died");
4864 }
4865 /*
4866 * No need to wipe the create event since the application socket will
4867 * get close on error hence cleaning up everything by itself.
4868 */
4869 goto error;
4870 }
4871
7972aab2
DG
4872 DBG3("UST registry event %s with id %" PRId32 " added successfully",
4873 name, event_id);
d88aee68 4874
d0b96690 4875error:
7972aab2 4876 pthread_mutex_unlock(&registry->lock);
d88aee68 4877error_rcu_unlock:
d0b96690
DG
4878 rcu_read_unlock();
4879 return ret;
4880}
4881
d88aee68
DG
4882/*
4883 * Handle application notification through the given notify socket.
4884 *
4885 * Return 0 on success or else a negative value.
4886 */
d0b96690
DG
4887int ust_app_recv_notify(int sock)
4888{
4889 int ret;
4890 enum ustctl_notify_cmd cmd;
4891
4892 DBG3("UST app receiving notify from sock %d", sock);
4893
4894 ret = ustctl_recv_notify(sock, &cmd);
4895 if (ret < 0) {
4896 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
4897 ERR("UST app recv notify failed with ret %d", ret);
4898 } else {
4899 DBG3("UST app recv notify failed. Application died");
4900 }
4901 goto error;
4902 }
4903
4904 switch (cmd) {
4905 case USTCTL_NOTIFY_CMD_EVENT:
4906 {
4907 int sobjd, cobjd, loglevel;
4908 char name[LTTNG_UST_SYM_NAME_LEN], *sig, *model_emf_uri;
4909 size_t nr_fields;
4910 struct ustctl_field *fields;
4911
4912 DBG2("UST app ustctl register event received");
4913
4914 ret = ustctl_recv_register_event(sock, &sobjd, &cobjd, name, &loglevel,
4915 &sig, &nr_fields, &fields, &model_emf_uri);
4916 if (ret < 0) {
4917 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
4918 ERR("UST app recv event failed with ret %d", ret);
4919 } else {
4920 DBG3("UST app recv event failed. Application died");
4921 }
4922 goto error;
4923 }
4924
d5d629b5
DG
4925 /*
4926 * Add event to the UST registry coming from the notify socket. This
4927 * call will free if needed the sig, fields and model_emf_uri. This
4928 * code path loses the ownsership of these variables and transfer them
4929 * to the this function.
4930 */
d0b96690
DG
4931 ret = add_event_ust_registry(sock, sobjd, cobjd, name, sig, nr_fields,
4932 fields, loglevel, model_emf_uri);
4933 if (ret < 0) {
4934 goto error;
4935 }
4936
4937 break;
4938 }
4939 case USTCTL_NOTIFY_CMD_CHANNEL:
4940 {
4941 int sobjd, cobjd;
4942 size_t nr_fields;
4943 struct ustctl_field *fields;
4944
4945 DBG2("UST app ustctl register channel received");
4946
4947 ret = ustctl_recv_register_channel(sock, &sobjd, &cobjd, &nr_fields,
4948 &fields);
4949 if (ret < 0) {
4950 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
4951 ERR("UST app recv channel failed with ret %d", ret);
4952 } else {
4953 DBG3("UST app recv channel failed. Application died");
4954 }
4955 goto error;
4956 }
4957
d5d629b5
DG
4958 /*
4959 * The fields ownership are transfered to this function call meaning
4960 * that if needed it will be freed. After this, it's invalid to access
4961 * fields or clean it up.
4962 */
d0b96690
DG
4963 ret = reply_ust_register_channel(sock, sobjd, cobjd, nr_fields,
4964 fields);
4965 if (ret < 0) {
4966 goto error;
4967 }
4968
4969 break;
4970 }
4971 default:
4972 /* Should NEVER happen. */
4973 assert(0);
4974 }
4975
4976error:
4977 return ret;
4978}
d88aee68
DG
4979
4980/*
4981 * Once the notify socket hangs up, this is called. First, it tries to find the
4982 * corresponding application. On failure, the call_rcu to close the socket is
4983 * executed. If an application is found, it tries to delete it from the notify
4984 * socket hash table. Whathever the result, it proceeds to the call_rcu.
4985 *
4986 * Note that an object needs to be allocated here so on ENOMEM failure, the
4987 * call RCU is not done but the rest of the cleanup is.
4988 */
4989void ust_app_notify_sock_unregister(int sock)
4990{
4991 int err_enomem = 0;
4992 struct lttng_ht_iter iter;
4993 struct ust_app *app;
4994 struct ust_app_notify_sock_obj *obj;
4995
4996 assert(sock >= 0);
4997
4998 rcu_read_lock();
4999
5000 obj = zmalloc(sizeof(*obj));
5001 if (!obj) {
5002 /*
5003 * An ENOMEM is kind of uncool. If this strikes we continue the
5004 * procedure but the call_rcu will not be called. In this case, we
5005 * accept the fd leak rather than possibly creating an unsynchronized
5006 * state between threads.
5007 *
5008 * TODO: The notify object should be created once the notify socket is
5009 * registered and stored independantely from the ust app object. The
5010 * tricky part is to synchronize the teardown of the application and
5011 * this notify object. Let's keep that in mind so we can avoid this
5012 * kind of shenanigans with ENOMEM in the teardown path.
5013 */
5014 err_enomem = 1;
5015 } else {
5016 obj->fd = sock;
5017 }
5018
5019 DBG("UST app notify socket unregister %d", sock);
5020
5021 /*
5022 * Lookup application by notify socket. If this fails, this means that the
5023 * hash table delete has already been done by the application
5024 * unregistration process so we can safely close the notify socket in a
5025 * call RCU.
5026 */
5027 app = find_app_by_notify_sock(sock);
5028 if (!app) {
5029 goto close_socket;
5030 }
5031
5032 iter.iter.node = &app->notify_sock_n.node;
5033
5034 /*
5035 * Whatever happens here either we fail or succeed, in both cases we have
5036 * to close the socket after a grace period to continue to the call RCU
5037 * here. If the deletion is successful, the application is not visible
5038 * anymore by other threads and is it fails it means that it was already
5039 * deleted from the hash table so either way we just have to close the
5040 * socket.
5041 */
5042 (void) lttng_ht_del(ust_app_ht_by_notify_sock, &iter);
5043
5044close_socket:
5045 rcu_read_unlock();
5046
5047 /*
5048 * Close socket after a grace period to avoid for the socket to be reused
5049 * before the application object is freed creating potential race between
5050 * threads trying to add unique in the global hash table.
5051 */
5052 if (!err_enomem) {
5053 call_rcu(&obj->head, close_notify_sock_rcu);
5054 }
5055}
f45e313d
DG
5056
5057/*
5058 * Destroy a ust app data structure and free its memory.
5059 */
5060void ust_app_destroy(struct ust_app *app)
5061{
5062 if (!app) {
5063 return;
5064 }
5065
5066 call_rcu(&app->pid_n.head, delete_ust_app_rcu);
5067}
6dc3064a
DG
5068
5069/*
5070 * Take a snapshot for a given UST session. The snapshot is sent to the given
5071 * output.
5072 *
5073 * Return 0 on success or else a negative value.
5074 */
5075int ust_app_snapshot_record(struct ltt_ust_session *usess,
5c786ded 5076 struct snapshot_output *output, int wait, unsigned int nb_streams)
6dc3064a
DG
5077{
5078 int ret = 0;
5079 struct lttng_ht_iter iter;
5080 struct ust_app *app;
af706bb7 5081 char pathname[PATH_MAX];
5c786ded 5082 uint64_t max_stream_size = 0;
6dc3064a
DG
5083
5084 assert(usess);
5085 assert(output);
5086
5087 rcu_read_lock();
5088
5c786ded
JD
5089 /*
5090 * Compute the maximum size of a single stream if a max size is asked by
5091 * the caller.
5092 */
5093 if (output->max_size > 0 && nb_streams > 0) {
5094 max_stream_size = output->max_size / nb_streams;
5095 }
5096
8c924c7b
MD
5097 switch (usess->buffer_type) {
5098 case LTTNG_BUFFER_PER_UID:
5099 {
5100 struct buffer_reg_uid *reg;
6dc3064a 5101
8c924c7b
MD
5102 cds_list_for_each_entry(reg, &usess->buffer_reg_uid_list, lnode) {
5103 struct buffer_reg_channel *reg_chan;
5104 struct consumer_socket *socket;
6dc3064a 5105
8c924c7b
MD
5106 /* Get consumer socket to use to push the metadata.*/
5107 socket = consumer_find_socket_by_bitness(reg->bits_per_long,
5108 usess->consumer);
5109 if (!socket) {
5110 ret = -EINVAL;
5111 goto error;
5112 }
6dc3064a 5113
8c924c7b
MD
5114 memset(pathname, 0, sizeof(pathname));
5115 ret = snprintf(pathname, sizeof(pathname),
5116 DEFAULT_UST_TRACE_DIR "/" DEFAULT_UST_TRACE_UID_PATH,
5117 reg->uid, reg->bits_per_long);
5118 if (ret < 0) {
5119 PERROR("snprintf snapshot path");
5120 goto error;
5121 }
5122
5123 /* Add the UST default trace dir to path. */
5124 cds_lfht_for_each_entry(reg->registry->channels->ht, &iter.iter,
5125 reg_chan, node.node) {
5126
5127 /*
5128 * Make sure the maximum stream size is not lower than the
5129 * subbuffer size or else it's an error since we won't be able to
5130 * snapshot anything.
5131 */
5132 if (max_stream_size &&
5133 reg_chan->subbuf_size > max_stream_size) {
5134 ret = -EINVAL;
5135 DBG3("UST app snapshot record maximum stream size %" PRIu64
6a00837f 5136 " is smaller than subbuffer size of %zu",
8c924c7b
MD
5137 max_stream_size, reg_chan->subbuf_size);
5138 goto error;
5139 }
5140 ret = consumer_snapshot_channel(socket, reg_chan->consumer_key, output, 0,
5141 usess->uid, usess->gid, pathname, wait,
5142 max_stream_size);
5143 if (ret < 0) {
5144 goto error;
5145 }
5146 }
5147 ret = consumer_snapshot_channel(socket, reg->registry->reg.ust->metadata_key, output,
5148 1, usess->uid, usess->gid, pathname, wait,
5149 max_stream_size);
5150 if (ret < 0) {
5151 goto error;
5152 }
af706bb7 5153 }
8c924c7b
MD
5154 break;
5155 }
5156 case LTTNG_BUFFER_PER_PID:
5157 {
5158 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
5159 struct consumer_socket *socket;
5160 struct lttng_ht_iter chan_iter;
5161 struct ust_app_channel *ua_chan;
5162 struct ust_app_session *ua_sess;
5163 struct ust_registry_session *registry;
5164
5165 ua_sess = lookup_session_by_app(usess, app);
5166 if (!ua_sess) {
5167 /* Session not associated with this app. */
5168 continue;
5169 }
af706bb7 5170
8c924c7b
MD
5171 /* Get the right consumer socket for the application. */
5172 socket = consumer_find_socket_by_bitness(app->bits_per_long,
5173 output->consumer);
5174 if (!socket) {
5c786ded 5175 ret = -EINVAL;
5c786ded
JD
5176 goto error;
5177 }
5178
8c924c7b
MD
5179 /* Add the UST default trace dir to path. */
5180 memset(pathname, 0, sizeof(pathname));
5181 ret = snprintf(pathname, sizeof(pathname), DEFAULT_UST_TRACE_DIR "/%s",
5182 ua_sess->path);
6dc3064a 5183 if (ret < 0) {
8c924c7b 5184 PERROR("snprintf snapshot path");
6dc3064a
DG
5185 goto error;
5186 }
6dc3064a 5187
8c924c7b
MD
5188 cds_lfht_for_each_entry(ua_sess->channels->ht, &chan_iter.iter,
5189 ua_chan, node.node) {
5190 /*
5191 * Make sure the maximum stream size is not lower than the
5192 * subbuffer size or else it's an error since we won't be able to
5193 * snapshot anything.
5194 */
5195 if (max_stream_size &&
5196 ua_chan->attr.subbuf_size > max_stream_size) {
5197 ret = -EINVAL;
5198 DBG3("UST app snapshot record maximum stream size %" PRIu64
5199 " is smaller than subbuffer size of %" PRIu64,
5200 max_stream_size, ua_chan->attr.subbuf_size);
5201 goto error;
5202 }
6dc3064a 5203
8c924c7b
MD
5204 ret = consumer_snapshot_channel(socket, ua_chan->key, output, 0,
5205 ua_sess->euid, ua_sess->egid, pathname, wait,
5206 max_stream_size);
5207 if (ret < 0) {
5208 goto error;
5209 }
5210 }
5211
5212 registry = get_session_registry(ua_sess);
5213 assert(registry);
5214 ret = consumer_snapshot_channel(socket, registry->metadata_key, output,
5215 1, ua_sess->euid, ua_sess->egid, pathname, wait,
5216 max_stream_size);
5217 if (ret < 0) {
5218 goto error;
5219 }
5220 }
5221 break;
5222 }
5223 default:
5224 assert(0);
5225 break;
6dc3064a
DG
5226 }
5227
5228error:
5229 rcu_read_unlock();
5230 return ret;
5231}
5c786ded
JD
5232
5233/*
5234 * Return the number of streams for a UST session.
5235 */
5236unsigned int ust_app_get_nb_stream(struct ltt_ust_session *usess)
5237{
5238 unsigned int ret = 0;
5239 struct ust_app *app;
5240 struct lttng_ht_iter iter;
5241
5242 assert(usess);
5243
5244 switch (usess->buffer_type) {
5245 case LTTNG_BUFFER_PER_UID:
5246 {
5247 struct buffer_reg_uid *reg;
5248
5249 cds_list_for_each_entry(reg, &usess->buffer_reg_uid_list, lnode) {
5250 struct buffer_reg_channel *reg_chan;
5251
5252 cds_lfht_for_each_entry(reg->registry->channels->ht, &iter.iter,
5253 reg_chan, node.node) {
5254 ret += reg_chan->stream_count;
5255 }
5256 }
5257 break;
5258 }
5259 case LTTNG_BUFFER_PER_PID:
5260 {
5261 rcu_read_lock();
5262 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
5263 struct ust_app_channel *ua_chan;
5264 struct ust_app_session *ua_sess;
5265 struct lttng_ht_iter chan_iter;
5266
5267 ua_sess = lookup_session_by_app(usess, app);
5268 if (!ua_sess) {
5269 /* Session not associated with this app. */
5270 continue;
5271 }
5272
5273 cds_lfht_for_each_entry(ua_sess->channels->ht, &chan_iter.iter,
5274 ua_chan, node.node) {
5275 ret += ua_chan->streams.count;
5276 }
5277 }
5278 rcu_read_unlock();
5279 break;
5280 }
5281 default:
5282 assert(0);
5283 break;
5284 }
5285
5286 return ret;
5287}
This page took 0.360579 seconds and 4 git commands to generate.