Fix RCU-related hangs: incorrect lttng_ht_destroy use
[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
DG
36#include "fd-limit.h"
37#include "health.h"
56fff090 38#include "ust-app.h"
48842b30 39#include "ust-consumer.h"
d80a6244
DG
40#include "ust-ctl.h"
41
ffe60014
DG
42/* Next available channel key. */
43static unsigned long next_channel_key;
7972aab2 44static unsigned long next_session_id;
ffe60014
DG
45
46/*
47 * Return the atomically incremented value of next_channel_key.
48 */
49static inline unsigned long get_next_channel_key(void)
50{
51 return uatomic_add_return(&next_channel_key, 1);
52}
53
54/*
7972aab2 55 * Return the atomically incremented value of next_session_id.
ffe60014 56 */
7972aab2 57static inline unsigned long get_next_session_id(void)
ffe60014 58{
7972aab2 59 return uatomic_add_return(&next_session_id, 1);
ffe60014
DG
60}
61
d65d2de8
DG
62static void copy_channel_attr_to_ustctl(
63 struct ustctl_consumer_channel_attr *attr,
64 struct lttng_ust_channel_attr *uattr)
65{
66 /* Copy event attributes since the layout is different. */
67 attr->subbuf_size = uattr->subbuf_size;
68 attr->num_subbuf = uattr->num_subbuf;
69 attr->overwrite = uattr->overwrite;
70 attr->switch_timer_interval = uattr->switch_timer_interval;
71 attr->read_timer_interval = uattr->read_timer_interval;
72 attr->output = uattr->output;
73}
74
025faf73
DG
75/*
76 * Match function for the hash table lookup.
77 *
78 * It matches an ust app event based on three attributes which are the event
79 * name, the filter bytecode and the loglevel.
80 */
18eace3b
DG
81static int ht_match_ust_app_event(struct cds_lfht_node *node, const void *_key)
82{
83 struct ust_app_event *event;
84 const struct ust_app_ht_key *key;
85
86 assert(node);
87 assert(_key);
88
89 event = caa_container_of(node, struct ust_app_event, node.node);
90 key = _key;
91
92 /* Match the 3 elements of the key: name, filter and loglevel. */
93
94 /* Event name */
95 if (strncmp(event->attr.name, key->name, sizeof(event->attr.name)) != 0) {
96 goto no_match;
97 }
98
99 /* Event loglevel. */
100 if (event->attr.loglevel != key->loglevel) {
025faf73
DG
101 if (event->attr.loglevel_type == LTTNG_UST_LOGLEVEL_ALL
102 && key->loglevel == 0 && event->attr.loglevel == -1) {
103 /*
104 * Match is accepted. This is because on event creation, the
105 * loglevel is set to -1 if the event loglevel type is ALL so 0 and
106 * -1 are accepted for this loglevel type since 0 is the one set by
107 * the API when receiving an enable event.
108 */
109 } else {
110 goto no_match;
111 }
18eace3b
DG
112 }
113
114 /* One of the filters is NULL, fail. */
115 if ((key->filter && !event->filter) || (!key->filter && event->filter)) {
116 goto no_match;
117 }
118
025faf73
DG
119 if (key->filter && event->filter) {
120 /* Both filters exists, check length followed by the bytecode. */
121 if (event->filter->len != key->filter->len ||
122 memcmp(event->filter->data, key->filter->data,
123 event->filter->len) != 0) {
124 goto no_match;
125 }
18eace3b
DG
126 }
127
025faf73 128 /* Match. */
18eace3b
DG
129 return 1;
130
131no_match:
132 return 0;
18eace3b
DG
133}
134
025faf73
DG
135/*
136 * Unique add of an ust app event in the given ht. This uses the custom
137 * ht_match_ust_app_event match function and the event name as hash.
138 */
d0b96690 139static void add_unique_ust_app_event(struct ust_app_channel *ua_chan,
18eace3b
DG
140 struct ust_app_event *event)
141{
142 struct cds_lfht_node *node_ptr;
143 struct ust_app_ht_key key;
d0b96690 144 struct lttng_ht *ht;
18eace3b 145
d0b96690
DG
146 assert(ua_chan);
147 assert(ua_chan->events);
18eace3b
DG
148 assert(event);
149
d0b96690 150 ht = ua_chan->events;
18eace3b
DG
151 key.name = event->attr.name;
152 key.filter = event->filter;
153 key.loglevel = event->attr.loglevel;
154
155 node_ptr = cds_lfht_add_unique(ht->ht,
156 ht->hash_fct(event->node.key, lttng_ht_seed),
157 ht_match_ust_app_event, &key, &event->node.node);
158 assert(node_ptr == &event->node.node);
159}
160
d88aee68
DG
161/*
162 * Close the notify socket from the given RCU head object. This MUST be called
163 * through a call_rcu().
164 */
165static void close_notify_sock_rcu(struct rcu_head *head)
166{
167 int ret;
168 struct ust_app_notify_sock_obj *obj =
169 caa_container_of(head, struct ust_app_notify_sock_obj, head);
170
171 /* Must have a valid fd here. */
172 assert(obj->fd >= 0);
173
174 ret = close(obj->fd);
175 if (ret) {
176 ERR("close notify sock %d RCU", obj->fd);
177 }
178 lttng_fd_put(LTTNG_FD_APPS, 1);
179
180 free(obj);
181}
182
7972aab2
DG
183/*
184 * Return the session registry according to the buffer type of the given
185 * session.
186 *
187 * A registry per UID object MUST exists before calling this function or else
188 * it assert() if not found. RCU read side lock must be acquired.
189 */
190static struct ust_registry_session *get_session_registry(
191 struct ust_app_session *ua_sess)
192{
193 struct ust_registry_session *registry = NULL;
194
195 assert(ua_sess);
196
197 switch (ua_sess->buffer_type) {
198 case LTTNG_BUFFER_PER_PID:
199 {
200 struct buffer_reg_pid *reg_pid = buffer_reg_pid_find(ua_sess->id);
201 if (!reg_pid) {
202 goto error;
203 }
204 registry = reg_pid->registry->reg.ust;
205 break;
206 }
207 case LTTNG_BUFFER_PER_UID:
208 {
209 struct buffer_reg_uid *reg_uid = buffer_reg_uid_find(
210 ua_sess->tracing_id, ua_sess->bits_per_long, ua_sess->uid);
211 if (!reg_uid) {
212 goto error;
213 }
214 registry = reg_uid->registry->reg.ust;
215 break;
216 }
217 default:
218 assert(0);
219 };
220
221error:
222 return registry;
223}
224
55cc08a6
DG
225/*
226 * Delete ust context safely. RCU read lock must be held before calling
227 * this function.
228 */
229static
230void delete_ust_app_ctx(int sock, struct ust_app_ctx *ua_ctx)
231{
ffe60014
DG
232 int ret;
233
234 assert(ua_ctx);
235
55cc08a6 236 if (ua_ctx->obj) {
ffe60014 237 ret = ustctl_release_object(sock, ua_ctx->obj);
d0b96690
DG
238 if (ret < 0 && ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
239 ERR("UST app sock %d release ctx obj handle %d failed with ret %d",
240 sock, ua_ctx->obj->handle, ret);
ffe60014 241 }
55cc08a6
DG
242 free(ua_ctx->obj);
243 }
244 free(ua_ctx);
245}
246
d80a6244
DG
247/*
248 * Delete ust app event safely. RCU read lock must be held before calling
249 * this function.
250 */
8b366481
DG
251static
252void delete_ust_app_event(int sock, struct ust_app_event *ua_event)
d80a6244 253{
ffe60014
DG
254 int ret;
255
256 assert(ua_event);
257
53a80697 258 free(ua_event->filter);
d80a6244 259
edb67388 260 if (ua_event->obj != NULL) {
ffe60014
DG
261 ret = ustctl_release_object(sock, ua_event->obj);
262 if (ret < 0 && ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
263 ERR("UST app sock %d release event obj failed with ret %d",
264 sock, ret);
265 }
edb67388
DG
266 free(ua_event->obj);
267 }
d80a6244
DG
268 free(ua_event);
269}
270
271/*
7972aab2
DG
272 * Release ust data object of the given stream.
273 *
274 * Return 0 on success or else a negative value.
d80a6244 275 */
7972aab2 276static int release_ust_app_stream(int sock, struct ust_app_stream *stream)
d80a6244 277{
7972aab2 278 int ret = 0;
ffe60014
DG
279
280 assert(stream);
281
8b366481 282 if (stream->obj) {
ffe60014
DG
283 ret = ustctl_release_object(sock, stream->obj);
284 if (ret < 0 && ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
285 ERR("UST app sock %d release stream obj failed with ret %d",
286 sock, ret);
287 }
4063050c 288 lttng_fd_put(LTTNG_FD_APPS, 2);
8b366481
DG
289 free(stream->obj);
290 }
7972aab2
DG
291
292 return ret;
293}
294
295/*
296 * Delete ust app stream safely. RCU read lock must be held before calling
297 * this function.
298 */
299static
300void delete_ust_app_stream(int sock, struct ust_app_stream *stream)
301{
302 assert(stream);
303
304 (void) release_ust_app_stream(sock, stream);
84cd17c6 305 free(stream);
d80a6244
DG
306}
307
36b588ed
MD
308/*
309 * We need to execute ht_destroy outside of RCU read-side critical
310 * section, so we postpone its execution using call_rcu. It is simpler
311 * than to change the semantic of the many callers of
312 * delete_ust_app_channel().
313 */
314static
315void delete_ust_app_channel_rcu(struct rcu_head *head)
316{
317 struct ust_app_channel *ua_chan =
318 caa_container_of(head, struct ust_app_channel, rcu_head);
319
320 lttng_ht_destroy(ua_chan->ctx);
321 lttng_ht_destroy(ua_chan->events);
322 free(ua_chan);
323}
324
d80a6244
DG
325/*
326 * Delete ust app channel safely. RCU read lock must be held before calling
327 * this function.
328 */
8b366481 329static
d0b96690
DG
330void delete_ust_app_channel(int sock, struct ust_app_channel *ua_chan,
331 struct ust_app *app)
d80a6244
DG
332{
333 int ret;
bec39940 334 struct lttng_ht_iter iter;
d80a6244 335 struct ust_app_event *ua_event;
55cc08a6 336 struct ust_app_ctx *ua_ctx;
030a66fa 337 struct ust_app_stream *stream, *stmp;
7972aab2 338 struct ust_registry_session *registry;
d80a6244 339
ffe60014
DG
340 assert(ua_chan);
341
342 DBG3("UST app deleting channel %s", ua_chan->name);
343
55cc08a6 344 /* Wipe stream */
d80a6244 345 cds_list_for_each_entry_safe(stream, stmp, &ua_chan->streams.head, list) {
84cd17c6 346 cds_list_del(&stream->list);
d80a6244
DG
347 delete_ust_app_stream(sock, stream);
348 }
349
55cc08a6 350 /* Wipe context */
bec39940
DG
351 cds_lfht_for_each_entry(ua_chan->ctx->ht, &iter.iter, ua_ctx, node.node) {
352 ret = lttng_ht_del(ua_chan->ctx, &iter);
55cc08a6
DG
353 assert(!ret);
354 delete_ust_app_ctx(sock, ua_ctx);
355 }
d80a6244 356
55cc08a6 357 /* Wipe events */
bec39940
DG
358 cds_lfht_for_each_entry(ua_chan->events->ht, &iter.iter, ua_event,
359 node.node) {
360 ret = lttng_ht_del(ua_chan->events, &iter);
525b0740 361 assert(!ret);
d80a6244
DG
362 delete_ust_app_event(sock, ua_event);
363 }
edb67388 364
45893984 365 /* Wipe and free registry from session registry. */
7972aab2
DG
366 registry = get_session_registry(ua_chan->session);
367 if (registry) {
368 ust_registry_channel_del_free(registry, ua_chan->key);
369 }
d0b96690 370
edb67388 371 if (ua_chan->obj != NULL) {
d0b96690
DG
372 /* Remove channel from application UST object descriptor. */
373 iter.iter.node = &ua_chan->ust_objd_node.node;
374 lttng_ht_del(app->ust_objd, &iter);
ffe60014
DG
375 ret = ustctl_release_object(sock, ua_chan->obj);
376 if (ret < 0 && ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
377 ERR("UST app sock %d release channel obj failed with ret %d",
378 sock, ret);
379 }
7972aab2 380 lttng_fd_put(LTTNG_FD_APPS, 1);
edb67388
DG
381 free(ua_chan->obj);
382 }
36b588ed 383 call_rcu(&ua_chan->rcu_head, delete_ust_app_channel_rcu);
d80a6244
DG
384}
385
331744e3
JD
386/*
387 * Push metadata to consumer socket. The socket lock MUST be acquired.
388 *
389 * On success, return the len of metadata pushed or else a negative value.
390 */
391ssize_t ust_app_push_metadata(struct ust_registry_session *registry,
392 struct consumer_socket *socket, int send_zero_data)
393{
394 int ret;
395 char *metadata_str = NULL;
396 size_t len, offset;
397 ssize_t ret_val;
398
399 assert(registry);
400 assert(socket);
401 /* Should never be 0 which is the initial state. */
402 assert(registry->metadata_key);
403
404 pthread_mutex_lock(&registry->lock);
405
406 offset = registry->metadata_len_sent;
407 len = registry->metadata_len - registry->metadata_len_sent;
408 if (len == 0) {
409 DBG3("No metadata to push for metadata key %" PRIu64,
410 registry->metadata_key);
411 ret_val = len;
412 if (send_zero_data) {
413 DBG("No metadata to push");
414 goto push_data;
415 }
416 goto end;
417 }
418
419 /* Allocate only what we have to send. */
420 metadata_str = zmalloc(len);
421 if (!metadata_str) {
422 PERROR("zmalloc ust app metadata string");
423 ret_val = -ENOMEM;
424 goto error;
425 }
426 /* Copy what we haven't send out. */
427 memcpy(metadata_str, registry->metadata + offset, len);
428 registry->metadata_len_sent += len;
429
430push_data:
431 pthread_mutex_unlock(&registry->lock);
432 ret = consumer_push_metadata(socket, registry->metadata_key,
433 metadata_str, len, offset);
434 if (ret < 0) {
435 ret_val = ret;
436 goto error_push;
437 }
438
439 free(metadata_str);
440 return len;
441
442end:
443error:
444 pthread_mutex_unlock(&registry->lock);
445error_push:
446 free(metadata_str);
447 return ret_val;
448}
449
d88aee68
DG
450/*
451 * For a given application and session, push metadata to consumer. The session
452 * lock MUST be acquired here before calling this.
331744e3
JD
453 * Either sock or consumer is required : if sock is NULL, the default
454 * socket to send the metadata is retrieved from consumer, if sock
455 * is not NULL we use it to send the metadata.
d88aee68
DG
456 *
457 * Return 0 on success else a negative error.
458 */
7972aab2
DG
459static int push_metadata(struct ust_registry_session *registry,
460 struct consumer_output *consumer)
d88aee68 461{
331744e3
JD
462 int ret_val;
463 ssize_t ret;
d88aee68
DG
464 struct consumer_socket *socket;
465
7972aab2
DG
466 assert(registry);
467 assert(consumer);
468
469 rcu_read_lock();
d88aee68 470
7972aab2
DG
471 /*
472 * Means that no metadata was assigned to the session. This can happens if
473 * no start has been done previously.
474 */
475 if (!registry->metadata_key) {
331744e3 476 ret_val = 0;
7972aab2 477 goto error_rcu_unlock;
d88aee68
DG
478 }
479
d88aee68 480 /* Get consumer socket to use to push the metadata.*/
7972aab2
DG
481 socket = consumer_find_socket_by_bitness(registry->bits_per_long,
482 consumer);
d88aee68 483 if (!socket) {
331744e3 484 ret_val = -1;
d88aee68
DG
485 goto error_rcu_unlock;
486 }
487
488 /*
489 * TODO: Currently, we hold the socket lock around sampling of the next
490 * metadata segment to ensure we send metadata over the consumer socket in
491 * the correct order. This makes the registry lock nest inside the socket
492 * lock.
493 *
494 * Please note that this is a temporary measure: we should move this lock
495 * back into ust_consumer_push_metadata() when the consumer gets the
496 * ability to reorder the metadata it receives.
497 */
498 pthread_mutex_lock(socket->lock);
331744e3
JD
499 ret = ust_app_push_metadata(registry, socket, 0);
500 pthread_mutex_unlock(socket->lock);
d88aee68 501 if (ret < 0) {
331744e3 502 ret_val = ret;
d88aee68
DG
503 goto error_rcu_unlock;
504 }
505
d88aee68 506 rcu_read_unlock();
d88aee68
DG
507 return 0;
508
d88aee68
DG
509error_rcu_unlock:
510 rcu_read_unlock();
331744e3 511 return ret_val;
d88aee68
DG
512}
513
514/*
515 * Send to the consumer a close metadata command for the given session. Once
516 * done, the metadata channel is deleted and the session metadata pointer is
517 * nullified. The session lock MUST be acquired here unless the application is
518 * in the destroy path.
519 *
520 * Return 0 on success else a negative value.
521 */
7972aab2
DG
522static int close_metadata(struct ust_registry_session *registry,
523 struct consumer_output *consumer)
d88aee68
DG
524{
525 int ret;
526 struct consumer_socket *socket;
527
7972aab2
DG
528 assert(registry);
529 assert(consumer);
d88aee68 530
7972aab2
DG
531 rcu_read_lock();
532
533 if (!registry->metadata_key || registry->metadata_closed) {
d88aee68
DG
534 ret = 0;
535 goto error;
536 }
537
d88aee68 538 /* Get consumer socket to use to push the metadata.*/
7972aab2
DG
539 socket = consumer_find_socket_by_bitness(registry->bits_per_long,
540 consumer);
d88aee68
DG
541 if (!socket) {
542 ret = -1;
7972aab2 543 goto error;
d88aee68
DG
544 }
545
7972aab2 546 ret = consumer_close_metadata(socket, registry->metadata_key);
d88aee68 547 if (ret < 0) {
7972aab2 548 goto error;
d88aee68
DG
549 }
550
7972aab2
DG
551 /* Metadata successfully closed. Flag the registry. */
552 registry->metadata_closed = 1;
d88aee68 553
d88aee68 554error:
7972aab2 555 rcu_read_unlock();
d88aee68
DG
556 return ret;
557}
558
36b588ed
MD
559/*
560 * We need to execute ht_destroy outside of RCU read-side critical
561 * section, so we postpone its execution using call_rcu. It is simpler
562 * than to change the semantic of the many callers of
563 * delete_ust_app_session().
564 */
565static
566void delete_ust_app_session_rcu(struct rcu_head *head)
567{
568 struct ust_app_session *ua_sess =
569 caa_container_of(head, struct ust_app_session, rcu_head);
570
571 lttng_ht_destroy(ua_sess->channels);
572 free(ua_sess);
573}
574
d80a6244
DG
575/*
576 * Delete ust app session safely. RCU read lock must be held before calling
577 * this function.
578 */
8b366481 579static
d0b96690
DG
580void delete_ust_app_session(int sock, struct ust_app_session *ua_sess,
581 struct ust_app *app)
d80a6244
DG
582{
583 int ret;
bec39940 584 struct lttng_ht_iter iter;
d80a6244 585 struct ust_app_channel *ua_chan;
7972aab2 586 struct ust_registry_session *registry;
d80a6244 587
d88aee68
DG
588 assert(ua_sess);
589
7972aab2
DG
590 registry = get_session_registry(ua_sess);
591 if (registry) {
d88aee68 592 /* Push metadata for application before freeing the application. */
7972aab2 593 (void) push_metadata(registry, ua_sess->consumer);
d88aee68 594
7972aab2
DG
595 /*
596 * Don't ask to close metadata for global per UID buffers. Close
597 * metadata only on destroy trace session in this case.
598 */
599 if (ua_sess->buffer_type != LTTNG_BUFFER_PER_UID) {
600 /* And ask to close it for this session registry. */
601 (void) close_metadata(registry, ua_sess->consumer);
602 }
d80a6244
DG
603 }
604
bec39940
DG
605 cds_lfht_for_each_entry(ua_sess->channels->ht, &iter.iter, ua_chan,
606 node.node) {
607 ret = lttng_ht_del(ua_sess->channels, &iter);
525b0740 608 assert(!ret);
d0b96690 609 delete_ust_app_channel(sock, ua_chan, app);
d80a6244 610 }
d80a6244 611
7972aab2
DG
612 /* In case of per PID, the registry is kept in the session. */
613 if (ua_sess->buffer_type == LTTNG_BUFFER_PER_PID) {
614 struct buffer_reg_pid *reg_pid = buffer_reg_pid_find(ua_sess->id);
615 if (reg_pid) {
616 buffer_reg_pid_remove(reg_pid);
617 buffer_reg_pid_destroy(reg_pid);
618 }
619 }
d0b96690 620
aee6bafd 621 if (ua_sess->handle != -1) {
ffe60014
DG
622 ret = ustctl_release_handle(sock, ua_sess->handle);
623 if (ret < 0 && ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
624 ERR("UST app sock %d release session handle failed with ret %d",
625 sock, ret);
626 }
aee6bafd 627 }
36b588ed 628 call_rcu(&ua_sess->rcu_head, delete_ust_app_session_rcu);
d80a6244 629}
91d76f53
DG
630
631/*
284d8f55
DG
632 * Delete a traceable application structure from the global list. Never call
633 * this function outside of a call_rcu call.
36b588ed
MD
634 *
635 * RCU read side lock should _NOT_ be held when calling this function.
91d76f53 636 */
8b366481
DG
637static
638void delete_ust_app(struct ust_app *app)
91d76f53 639{
8b366481 640 int ret, sock;
d42f20df 641 struct ust_app_session *ua_sess, *tmp_ua_sess;
44d3bd01 642
d80a6244 643 /* Delete ust app sessions info */
852d0037
DG
644 sock = app->sock;
645 app->sock = -1;
d80a6244 646
8b366481 647 /* Wipe sessions */
d42f20df
DG
648 cds_list_for_each_entry_safe(ua_sess, tmp_ua_sess, &app->teardown_head,
649 teardown_node) {
650 /* Free every object in the session and the session. */
36b588ed 651 rcu_read_lock();
d0b96690 652 delete_ust_app_session(sock, ua_sess, app);
36b588ed 653 rcu_read_unlock();
d80a6244 654 }
36b588ed
MD
655
656 lttng_ht_destroy(app->sessions);
7972aab2 657 lttng_ht_destroy(app->ust_objd);
d80a6244 658
6414a713 659 /*
852d0037
DG
660 * Wait until we have deleted the application from the sock hash table
661 * before closing this socket, otherwise an application could re-use the
662 * socket ID and race with the teardown, using the same hash table entry.
663 *
664 * It's OK to leave the close in call_rcu. We want it to stay unique for
665 * all RCU readers that could run concurrently with unregister app,
666 * therefore we _need_ to only close that socket after a grace period. So
667 * it should stay in this RCU callback.
668 *
669 * This close() is a very important step of the synchronization model so
670 * every modification to this function must be carefully reviewed.
6414a713 671 */
799e2c4f
MD
672 ret = close(sock);
673 if (ret) {
674 PERROR("close");
675 }
4063050c 676 lttng_fd_put(LTTNG_FD_APPS, 1);
d80a6244 677
852d0037 678 DBG2("UST app pid %d deleted", app->pid);
284d8f55 679 free(app);
099e26bd
DG
680}
681
682/*
f6a9efaa 683 * URCU intermediate call to delete an UST app.
099e26bd 684 */
8b366481
DG
685static
686void delete_ust_app_rcu(struct rcu_head *head)
099e26bd 687{
bec39940
DG
688 struct lttng_ht_node_ulong *node =
689 caa_container_of(head, struct lttng_ht_node_ulong, head);
f6a9efaa 690 struct ust_app *app =
852d0037 691 caa_container_of(node, struct ust_app, pid_n);
f6a9efaa 692
852d0037 693 DBG3("Call RCU deleting app PID %d", app->pid);
f6a9efaa 694 delete_ust_app(app);
099e26bd
DG
695}
696
ffe60014
DG
697/*
698 * Delete the session from the application ht and delete the data structure by
699 * freeing every object inside and releasing them.
700 */
d0b96690 701static void destroy_app_session(struct ust_app *app,
ffe60014
DG
702 struct ust_app_session *ua_sess)
703{
704 int ret;
705 struct lttng_ht_iter iter;
706
707 assert(app);
708 assert(ua_sess);
709
710 iter.iter.node = &ua_sess->node.node;
711 ret = lttng_ht_del(app->sessions, &iter);
712 if (ret) {
713 /* Already scheduled for teardown. */
714 goto end;
715 }
716
717 /* Once deleted, free the data structure. */
d0b96690 718 delete_ust_app_session(app->sock, ua_sess, app);
ffe60014
DG
719
720end:
721 return;
722}
723
8b366481
DG
724/*
725 * Alloc new UST app session.
726 */
727static
d0b96690 728struct ust_app_session *alloc_ust_app_session(struct ust_app *app)
8b366481
DG
729{
730 struct ust_app_session *ua_sess;
731
732 /* Init most of the default value by allocating and zeroing */
733 ua_sess = zmalloc(sizeof(struct ust_app_session));
734 if (ua_sess == NULL) {
735 PERROR("malloc");
ffe60014 736 goto error_free;
8b366481
DG
737 }
738
739 ua_sess->handle = -1;
bec39940 740 ua_sess->channels = lttng_ht_new(0, LTTNG_HT_TYPE_STRING);
d0b96690 741 pthread_mutex_init(&ua_sess->lock, NULL);
ffe60014 742
8b366481
DG
743 return ua_sess;
744
ffe60014 745error_free:
8b366481
DG
746 return NULL;
747}
748
749/*
750 * Alloc new UST app channel.
751 */
752static
753struct ust_app_channel *alloc_ust_app_channel(char *name,
d0b96690 754 struct ust_app_session *ua_sess,
ffe60014 755 struct lttng_ust_channel_attr *attr)
8b366481
DG
756{
757 struct ust_app_channel *ua_chan;
758
759 /* Init most of the default value by allocating and zeroing */
760 ua_chan = zmalloc(sizeof(struct ust_app_channel));
761 if (ua_chan == NULL) {
762 PERROR("malloc");
763 goto error;
764 }
765
766 /* Setup channel name */
767 strncpy(ua_chan->name, name, sizeof(ua_chan->name));
768 ua_chan->name[sizeof(ua_chan->name) - 1] = '\0';
769
770 ua_chan->enabled = 1;
771 ua_chan->handle = -1;
45893984 772 ua_chan->session = ua_sess;
ffe60014 773 ua_chan->key = get_next_channel_key();
bec39940
DG
774 ua_chan->ctx = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG);
775 ua_chan->events = lttng_ht_new(0, LTTNG_HT_TYPE_STRING);
776 lttng_ht_node_init_str(&ua_chan->node, ua_chan->name);
8b366481
DG
777
778 CDS_INIT_LIST_HEAD(&ua_chan->streams.head);
779
780 /* Copy attributes */
781 if (attr) {
ffe60014 782 /* Translate from lttng_ust_channel to ustctl_consumer_channel_attr. */
2fe6e7f5
DG
783 ua_chan->attr.subbuf_size = attr->subbuf_size;
784 ua_chan->attr.num_subbuf = attr->num_subbuf;
785 ua_chan->attr.overwrite = attr->overwrite;
786 ua_chan->attr.switch_timer_interval = attr->switch_timer_interval;
787 ua_chan->attr.read_timer_interval = attr->read_timer_interval;
788 ua_chan->attr.output = attr->output;
8b366481 789 }
ffe60014
DG
790 /* By default, the channel is a per cpu channel. */
791 ua_chan->attr.type = LTTNG_UST_CHAN_PER_CPU;
8b366481
DG
792
793 DBG3("UST app channel %s allocated", ua_chan->name);
794
795 return ua_chan;
796
797error:
798 return NULL;
799}
800
37f1c236
DG
801/*
802 * Allocate and initialize a UST app stream.
803 *
804 * Return newly allocated stream pointer or NULL on error.
805 */
ffe60014 806struct ust_app_stream *ust_app_alloc_stream(void)
37f1c236
DG
807{
808 struct ust_app_stream *stream = NULL;
809
810 stream = zmalloc(sizeof(*stream));
811 if (stream == NULL) {
812 PERROR("zmalloc ust app stream");
813 goto error;
814 }
815
816 /* Zero could be a valid value for a handle so flag it to -1. */
817 stream->handle = -1;
818
819error:
820 return stream;
821}
822
8b366481
DG
823/*
824 * Alloc new UST app event.
825 */
826static
827struct ust_app_event *alloc_ust_app_event(char *name,
828 struct lttng_ust_event *attr)
829{
830 struct ust_app_event *ua_event;
831
832 /* Init most of the default value by allocating and zeroing */
833 ua_event = zmalloc(sizeof(struct ust_app_event));
834 if (ua_event == NULL) {
835 PERROR("malloc");
836 goto error;
837 }
838
839 ua_event->enabled = 1;
840 strncpy(ua_event->name, name, sizeof(ua_event->name));
841 ua_event->name[sizeof(ua_event->name) - 1] = '\0';
bec39940 842 lttng_ht_node_init_str(&ua_event->node, ua_event->name);
8b366481
DG
843
844 /* Copy attributes */
845 if (attr) {
846 memcpy(&ua_event->attr, attr, sizeof(ua_event->attr));
847 }
848
849 DBG3("UST app event %s allocated", ua_event->name);
850
851 return ua_event;
852
853error:
854 return NULL;
855}
856
857/*
858 * Alloc new UST app context.
859 */
860static
861struct ust_app_ctx *alloc_ust_app_ctx(struct lttng_ust_context *uctx)
862{
863 struct ust_app_ctx *ua_ctx;
864
865 ua_ctx = zmalloc(sizeof(struct ust_app_ctx));
866 if (ua_ctx == NULL) {
867 goto error;
868 }
869
870 if (uctx) {
871 memcpy(&ua_ctx->ctx, uctx, sizeof(ua_ctx->ctx));
872 }
873
874 DBG3("UST app context %d allocated", ua_ctx->ctx.ctx);
875
876error:
877 return ua_ctx;
878}
879
025faf73
DG
880/*
881 * Allocate a filter and copy the given original filter.
882 *
883 * Return allocated filter or NULL on error.
884 */
885static struct lttng_ust_filter_bytecode *alloc_copy_ust_app_filter(
886 struct lttng_ust_filter_bytecode *orig_f)
887{
888 struct lttng_ust_filter_bytecode *filter = NULL;
889
890 /* Copy filter bytecode */
891 filter = zmalloc(sizeof(*filter) + orig_f->len);
892 if (!filter) {
893 PERROR("zmalloc alloc ust app filter");
894 goto error;
895 }
896
897 memcpy(filter, orig_f, sizeof(*filter) + orig_f->len);
898
899error:
900 return filter;
901}
902
099e26bd 903/*
421cb601
DG
904 * Find an ust_app using the sock and return it. RCU read side lock must be
905 * held before calling this helper function.
099e26bd 906 */
8b366481
DG
907static
908struct ust_app *find_app_by_sock(int sock)
099e26bd 909{
bec39940 910 struct lttng_ht_node_ulong *node;
bec39940 911 struct lttng_ht_iter iter;
f6a9efaa 912
852d0037 913 lttng_ht_lookup(ust_app_ht_by_sock, (void *)((unsigned long) sock), &iter);
bec39940 914 node = lttng_ht_iter_get_node_ulong(&iter);
f6a9efaa
DG
915 if (node == NULL) {
916 DBG2("UST app find by sock %d not found", sock);
f6a9efaa
DG
917 goto error;
918 }
852d0037
DG
919
920 return caa_container_of(node, struct ust_app, sock_n);
f6a9efaa
DG
921
922error:
923 return NULL;
099e26bd
DG
924}
925
d0b96690
DG
926/*
927 * Find an ust_app using the notify sock and return it. RCU read side lock must
928 * be held before calling this helper function.
929 */
930static struct ust_app *find_app_by_notify_sock(int sock)
931{
932 struct lttng_ht_node_ulong *node;
933 struct lttng_ht_iter iter;
934
935 lttng_ht_lookup(ust_app_ht_by_notify_sock, (void *)((unsigned long) sock),
936 &iter);
937 node = lttng_ht_iter_get_node_ulong(&iter);
938 if (node == NULL) {
939 DBG2("UST app find by notify sock %d not found", sock);
940 goto error;
941 }
942
943 return caa_container_of(node, struct ust_app, notify_sock_n);
944
945error:
946 return NULL;
947}
948
025faf73
DG
949/*
950 * Lookup for an ust app event based on event name, filter bytecode and the
951 * event loglevel.
952 *
953 * Return an ust_app_event object or NULL on error.
954 */
18eace3b
DG
955static struct ust_app_event *find_ust_app_event(struct lttng_ht *ht,
956 char *name, struct lttng_ust_filter_bytecode *filter, int loglevel)
957{
958 struct lttng_ht_iter iter;
959 struct lttng_ht_node_str *node;
960 struct ust_app_event *event = NULL;
961 struct ust_app_ht_key key;
18eace3b
DG
962
963 assert(name);
964 assert(ht);
965
966 /* Setup key for event lookup. */
967 key.name = name;
968 key.filter = filter;
969 key.loglevel = loglevel;
970
025faf73
DG
971 /* Lookup using the event name as hash and a custom match fct. */
972 cds_lfht_lookup(ht->ht, ht->hash_fct((void *) name, lttng_ht_seed),
973 ht_match_ust_app_event, &key, &iter.iter);
18eace3b
DG
974 node = lttng_ht_iter_get_node_str(&iter);
975 if (node == NULL) {
976 goto end;
977 }
978
979 event = caa_container_of(node, struct ust_app_event, node);
980
981end:
18eace3b
DG
982 return event;
983}
984
55cc08a6
DG
985/*
986 * Create the channel context on the tracer.
d0b96690
DG
987 *
988 * Called with UST app session lock held.
55cc08a6
DG
989 */
990static
991int create_ust_channel_context(struct ust_app_channel *ua_chan,
992 struct ust_app_ctx *ua_ctx, struct ust_app *app)
993{
994 int ret;
995
840cb59c 996 health_code_update();
86acf0da 997
852d0037 998 ret = ustctl_add_context(app->sock, &ua_ctx->ctx,
55cc08a6
DG
999 ua_chan->obj, &ua_ctx->obj);
1000 if (ret < 0) {
ffe60014
DG
1001 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
1002 ERR("UST app create channel context failed for app (pid: %d) "
1003 "with ret %d", app->pid, ret);
1004 } else {
1005 DBG3("UST app disable event failed. Application is dead.");
1006 }
55cc08a6
DG
1007 goto error;
1008 }
1009
1010 ua_ctx->handle = ua_ctx->obj->handle;
1011
d0b96690
DG
1012 DBG2("UST app context handle %d created successfully for channel %s",
1013 ua_ctx->handle, ua_chan->name);
55cc08a6
DG
1014
1015error:
840cb59c 1016 health_code_update();
55cc08a6
DG
1017 return ret;
1018}
1019
53a80697
MD
1020/*
1021 * Set the filter on the tracer.
1022 */
1023static
1024int set_ust_event_filter(struct ust_app_event *ua_event,
1025 struct ust_app *app)
1026{
1027 int ret;
1028
840cb59c 1029 health_code_update();
86acf0da 1030
53a80697 1031 if (!ua_event->filter) {
86acf0da
DG
1032 ret = 0;
1033 goto error;
53a80697
MD
1034 }
1035
1036 ret = ustctl_set_filter(app->sock, ua_event->filter,
1037 ua_event->obj);
1038 if (ret < 0) {
ffe60014
DG
1039 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
1040 ERR("UST app event %s filter failed for app (pid: %d) "
1041 "with ret %d", ua_event->attr.name, app->pid, ret);
1042 } else {
1043 DBG3("UST app filter event failed. Application is dead.");
1044 }
53a80697
MD
1045 goto error;
1046 }
1047
1048 DBG2("UST filter set successfully for event %s", ua_event->name);
1049
1050error:
840cb59c 1051 health_code_update();
53a80697
MD
1052 return ret;
1053}
1054
9730260e
DG
1055/*
1056 * Disable the specified event on to UST tracer for the UST session.
1057 */
1058static int disable_ust_event(struct ust_app *app,
1059 struct ust_app_session *ua_sess, struct ust_app_event *ua_event)
1060{
1061 int ret;
1062
840cb59c 1063 health_code_update();
86acf0da 1064
852d0037 1065 ret = ustctl_disable(app->sock, ua_event->obj);
9730260e 1066 if (ret < 0) {
ffe60014
DG
1067 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
1068 ERR("UST app event %s disable failed for app (pid: %d) "
1069 "and session handle %d with ret %d",
1070 ua_event->attr.name, app->pid, ua_sess->handle, ret);
1071 } else {
1072 DBG3("UST app disable event failed. Application is dead.");
1073 }
9730260e
DG
1074 goto error;
1075 }
1076
1077 DBG2("UST app event %s disabled successfully for app (pid: %d)",
852d0037 1078 ua_event->attr.name, app->pid);
9730260e
DG
1079
1080error:
840cb59c 1081 health_code_update();
9730260e
DG
1082 return ret;
1083}
1084
78f0bacd
DG
1085/*
1086 * Disable the specified channel on to UST tracer for the UST session.
1087 */
1088static int disable_ust_channel(struct ust_app *app,
1089 struct ust_app_session *ua_sess, struct ust_app_channel *ua_chan)
1090{
1091 int ret;
1092
840cb59c 1093 health_code_update();
86acf0da 1094
852d0037 1095 ret = ustctl_disable(app->sock, ua_chan->obj);
78f0bacd 1096 if (ret < 0) {
ffe60014
DG
1097 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
1098 ERR("UST app channel %s disable failed for app (pid: %d) "
1099 "and session handle %d with ret %d",
1100 ua_chan->name, app->pid, ua_sess->handle, ret);
1101 } else {
1102 DBG3("UST app disable channel failed. Application is dead.");
1103 }
78f0bacd
DG
1104 goto error;
1105 }
1106
78f0bacd 1107 DBG2("UST app channel %s disabled successfully for app (pid: %d)",
852d0037 1108 ua_chan->name, app->pid);
78f0bacd
DG
1109
1110error:
840cb59c 1111 health_code_update();
78f0bacd
DG
1112 return ret;
1113}
1114
1115/*
1116 * Enable the specified channel on to UST tracer for the UST session.
1117 */
1118static int enable_ust_channel(struct ust_app *app,
1119 struct ust_app_session *ua_sess, struct ust_app_channel *ua_chan)
1120{
1121 int ret;
1122
840cb59c 1123 health_code_update();
86acf0da 1124
852d0037 1125 ret = ustctl_enable(app->sock, ua_chan->obj);
78f0bacd 1126 if (ret < 0) {
ffe60014
DG
1127 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
1128 ERR("UST app channel %s enable failed for app (pid: %d) "
1129 "and session handle %d with ret %d",
1130 ua_chan->name, app->pid, ua_sess->handle, ret);
1131 } else {
1132 DBG3("UST app enable channel failed. Application is dead.");
1133 }
78f0bacd
DG
1134 goto error;
1135 }
1136
1137 ua_chan->enabled = 1;
1138
1139 DBG2("UST app channel %s enabled successfully for app (pid: %d)",
852d0037 1140 ua_chan->name, app->pid);
78f0bacd
DG
1141
1142error:
840cb59c 1143 health_code_update();
78f0bacd
DG
1144 return ret;
1145}
1146
edb67388
DG
1147/*
1148 * Enable the specified event on to UST tracer for the UST session.
1149 */
1150static int enable_ust_event(struct ust_app *app,
1151 struct ust_app_session *ua_sess, struct ust_app_event *ua_event)
1152{
1153 int ret;
1154
840cb59c 1155 health_code_update();
86acf0da 1156
852d0037 1157 ret = ustctl_enable(app->sock, ua_event->obj);
edb67388 1158 if (ret < 0) {
ffe60014
DG
1159 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
1160 ERR("UST app event %s enable failed for app (pid: %d) "
1161 "and session handle %d with ret %d",
1162 ua_event->attr.name, app->pid, ua_sess->handle, ret);
1163 } else {
1164 DBG3("UST app enable event failed. Application is dead.");
1165 }
edb67388
DG
1166 goto error;
1167 }
1168
1169 DBG2("UST app event %s enabled successfully for app (pid: %d)",
852d0037 1170 ua_event->attr.name, app->pid);
edb67388
DG
1171
1172error:
840cb59c 1173 health_code_update();
edb67388
DG
1174 return ret;
1175}
1176
099e26bd 1177/*
7972aab2 1178 * Send channel and stream buffer to application.
4f3ab6ee 1179 *
ffe60014 1180 * Return 0 on success. On error, a negative value is returned.
4f3ab6ee 1181 */
7972aab2
DG
1182static int send_channel_pid_to_ust(struct ust_app *app,
1183 struct ust_app_session *ua_sess, struct ust_app_channel *ua_chan)
4f3ab6ee
DG
1184{
1185 int ret;
ffe60014 1186 struct ust_app_stream *stream, *stmp;
4f3ab6ee
DG
1187
1188 assert(app);
ffe60014 1189 assert(ua_sess);
4f3ab6ee 1190 assert(ua_chan);
4f3ab6ee 1191
840cb59c 1192 health_code_update();
4f3ab6ee 1193
7972aab2
DG
1194 DBG("UST app sending channel %s to UST app sock %d", ua_chan->name,
1195 app->sock);
86acf0da 1196
ffe60014
DG
1197 /* Send channel to the application. */
1198 ret = ust_consumer_send_channel_to_ust(app, ua_sess, ua_chan);
5b4a0ec0 1199 if (ret < 0) {
b551a063
DG
1200 goto error;
1201 }
1202
d88aee68
DG
1203 health_code_update();
1204
ffe60014
DG
1205 /* Send all streams to application. */
1206 cds_list_for_each_entry_safe(stream, stmp, &ua_chan->streams.head, list) {
1207 ret = ust_consumer_send_stream_to_ust(app, ua_chan, stream);
1208 if (ret < 0) {
1209 goto error;
1210 }
1211 /* We don't need the stream anymore once sent to the tracer. */
1212 cds_list_del(&stream->list);
1213 delete_ust_app_stream(-1, stream);
1214 }
ffe60014
DG
1215 /* Flag the channel that it is sent to the application. */
1216 ua_chan->is_sent = 1;
ffe60014 1217
b551a063 1218error:
840cb59c 1219 health_code_update();
b551a063
DG
1220 return ret;
1221}
1222
91d76f53 1223/*
5b4a0ec0 1224 * Create the specified event onto the UST tracer for a UST session.
d0b96690
DG
1225 *
1226 * Should be called with session mutex held.
91d76f53 1227 */
edb67388
DG
1228static
1229int create_ust_event(struct ust_app *app, struct ust_app_session *ua_sess,
1230 struct ust_app_channel *ua_chan, struct ust_app_event *ua_event)
91d76f53 1231{
5b4a0ec0 1232 int ret = 0;
284d8f55 1233
840cb59c 1234 health_code_update();
86acf0da 1235
5b4a0ec0 1236 /* Create UST event on tracer */
852d0037 1237 ret = ustctl_create_event(app->sock, &ua_event->attr, ua_chan->obj,
5b4a0ec0
DG
1238 &ua_event->obj);
1239 if (ret < 0) {
ffe60014
DG
1240 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
1241 ERR("Error ustctl create event %s for app pid: %d with ret %d",
1242 ua_event->attr.name, app->pid, ret);
1243 } else {
1244 DBG3("UST app create event failed. Application is dead.");
1245 }
5b4a0ec0 1246 goto error;
91d76f53 1247 }
f6a9efaa 1248
5b4a0ec0 1249 ua_event->handle = ua_event->obj->handle;
284d8f55 1250
5b4a0ec0 1251 DBG2("UST app event %s created successfully for pid:%d",
852d0037 1252 ua_event->attr.name, app->pid);
f6a9efaa 1253
840cb59c 1254 health_code_update();
86acf0da 1255
025faf73
DG
1256 /* Set filter if one is present. */
1257 if (ua_event->filter) {
1258 ret = set_ust_event_filter(ua_event, app);
1259 if (ret < 0) {
1260 goto error;
1261 }
1262 }
1263
8535a6d9 1264 /* If event not enabled, disable it on the tracer */
fc34caaa 1265 if (ua_event->enabled == 0) {
8535a6d9
DG
1266 ret = disable_ust_event(app, ua_sess, ua_event);
1267 if (ret < 0) {
fc34caaa
DG
1268 /*
1269 * If we hit an EPERM, something is wrong with our disable call. If
1270 * we get an EEXIST, there is a problem on the tracer side since we
1271 * just created it.
1272 */
1273 switch (ret) {
49c336c1 1274 case -LTTNG_UST_ERR_PERM:
fc34caaa
DG
1275 /* Code flow problem */
1276 assert(0);
49c336c1 1277 case -LTTNG_UST_ERR_EXIST:
fc34caaa
DG
1278 /* It's OK for our use case. */
1279 ret = 0;
1280 break;
1281 default:
1282 break;
1283 }
8535a6d9
DG
1284 goto error;
1285 }
1286 }
1287
5b4a0ec0 1288error:
840cb59c 1289 health_code_update();
5b4a0ec0 1290 return ret;
91d76f53 1291}
48842b30 1292
5b4a0ec0
DG
1293/*
1294 * Copy data between an UST app event and a LTT event.
1295 */
421cb601 1296static void shadow_copy_event(struct ust_app_event *ua_event,
48842b30
DG
1297 struct ltt_ust_event *uevent)
1298{
1299 strncpy(ua_event->name, uevent->attr.name, sizeof(ua_event->name));
1300 ua_event->name[sizeof(ua_event->name) - 1] = '\0';
1301
fc34caaa
DG
1302 ua_event->enabled = uevent->enabled;
1303
5b4a0ec0
DG
1304 /* Copy event attributes */
1305 memcpy(&ua_event->attr, &uevent->attr, sizeof(ua_event->attr));
1306
53a80697
MD
1307 /* Copy filter bytecode */
1308 if (uevent->filter) {
025faf73
DG
1309 ua_event->filter = alloc_copy_ust_app_filter(uevent->filter);
1310 /* Filter might be NULL here in case of ENONEM. */
53a80697 1311 }
48842b30
DG
1312}
1313
5b4a0ec0
DG
1314/*
1315 * Copy data between an UST app channel and a LTT channel.
1316 */
421cb601 1317static void shadow_copy_channel(struct ust_app_channel *ua_chan,
48842b30
DG
1318 struct ltt_ust_channel *uchan)
1319{
bec39940 1320 struct lttng_ht_iter iter;
48842b30 1321 struct ltt_ust_event *uevent;
55cc08a6 1322 struct ltt_ust_context *uctx;
48842b30 1323 struct ust_app_event *ua_event;
55cc08a6 1324 struct ust_app_ctx *ua_ctx;
48842b30 1325
fc34caaa 1326 DBG2("UST app shadow copy of channel %s started", ua_chan->name);
48842b30
DG
1327
1328 strncpy(ua_chan->name, uchan->name, sizeof(ua_chan->name));
1329 ua_chan->name[sizeof(ua_chan->name) - 1] = '\0';
ffe60014 1330
1624d5b7
JD
1331 ua_chan->tracefile_size = uchan->tracefile_size;
1332 ua_chan->tracefile_count = uchan->tracefile_count;
1333
ffe60014
DG
1334 /* Copy event attributes since the layout is different. */
1335 ua_chan->attr.subbuf_size = uchan->attr.subbuf_size;
1336 ua_chan->attr.num_subbuf = uchan->attr.num_subbuf;
1337 ua_chan->attr.overwrite = uchan->attr.overwrite;
1338 ua_chan->attr.switch_timer_interval = uchan->attr.switch_timer_interval;
1339 ua_chan->attr.read_timer_interval = uchan->attr.read_timer_interval;
1340 ua_chan->attr.output = uchan->attr.output;
1341 /*
1342 * Note that the attribute channel type is not set since the channel on the
1343 * tracing registry side does not have this information.
1344 */
48842b30 1345
fc34caaa 1346 ua_chan->enabled = uchan->enabled;
7972aab2 1347 ua_chan->tracing_channel_id = uchan->id;
fc34caaa 1348
bec39940 1349 cds_lfht_for_each_entry(uchan->ctx->ht, &iter.iter, uctx, node.node) {
55cc08a6
DG
1350 ua_ctx = alloc_ust_app_ctx(&uctx->ctx);
1351 if (ua_ctx == NULL) {
1352 continue;
1353 }
bec39940
DG
1354 lttng_ht_node_init_ulong(&ua_ctx->node,
1355 (unsigned long) ua_ctx->ctx.ctx);
1356 lttng_ht_add_unique_ulong(ua_chan->ctx, &ua_ctx->node);
55cc08a6 1357 }
48842b30 1358
421cb601 1359 /* Copy all events from ltt ust channel to ust app channel */
bec39940 1360 cds_lfht_for_each_entry(uchan->events->ht, &iter.iter, uevent, node.node) {
18eace3b
DG
1361 ua_event = find_ust_app_event(ua_chan->events, uevent->attr.name,
1362 uevent->filter, uevent->attr.loglevel);
1363 if (ua_event == NULL) {
421cb601 1364 DBG2("UST event %s not found on shadow copy channel",
48842b30 1365 uevent->attr.name);
284d8f55 1366 ua_event = alloc_ust_app_event(uevent->attr.name, &uevent->attr);
48842b30 1367 if (ua_event == NULL) {
5b4a0ec0 1368 continue;
48842b30 1369 }
421cb601 1370 shadow_copy_event(ua_event, uevent);
d0b96690 1371 add_unique_ust_app_event(ua_chan, ua_event);
48842b30 1372 }
48842b30
DG
1373 }
1374
fc34caaa 1375 DBG3("UST app shadow copy of channel %s done", ua_chan->name);
48842b30
DG
1376}
1377
5b4a0ec0
DG
1378/*
1379 * Copy data between a UST app session and a regular LTT session.
1380 */
421cb601 1381static void shadow_copy_session(struct ust_app_session *ua_sess,
bec39940 1382 struct ltt_ust_session *usess, struct ust_app *app)
48842b30 1383{
bec39940
DG
1384 struct lttng_ht_node_str *ua_chan_node;
1385 struct lttng_ht_iter iter;
48842b30
DG
1386 struct ltt_ust_channel *uchan;
1387 struct ust_app_channel *ua_chan;
477d7741
MD
1388 time_t rawtime;
1389 struct tm *timeinfo;
1390 char datetime[16];
1391 int ret;
1392
1393 /* Get date and time for unique app path */
1394 time(&rawtime);
1395 timeinfo = localtime(&rawtime);
1396 strftime(datetime, sizeof(datetime), "%Y%m%d-%H%M%S", timeinfo);
48842b30 1397
421cb601 1398 DBG2("Shadow copy of session handle %d", ua_sess->handle);
48842b30 1399
7972aab2
DG
1400 ua_sess->tracing_id = usess->id;
1401 ua_sess->id = get_next_session_id();
1402 ua_sess->uid = app->uid;
1403 ua_sess->gid = app->gid;
1404 ua_sess->euid = usess->uid;
1405 ua_sess->egid = usess->gid;
1406 ua_sess->buffer_type = usess->buffer_type;
1407 ua_sess->bits_per_long = app->bits_per_long;
1408 /* There is only one consumer object per session possible. */
1409 ua_sess->consumer = usess->consumer;
1410
1411 switch (ua_sess->buffer_type) {
1412 case LTTNG_BUFFER_PER_PID:
1413 ret = snprintf(ua_sess->path, sizeof(ua_sess->path),
dec56f6c 1414 DEFAULT_UST_TRACE_PID_PATH "/%s-%d-%s", app->name, app->pid,
7972aab2
DG
1415 datetime);
1416 break;
1417 case LTTNG_BUFFER_PER_UID:
1418 ret = snprintf(ua_sess->path, sizeof(ua_sess->path),
1419 DEFAULT_UST_TRACE_UID_PATH, ua_sess->uid, app->bits_per_long);
1420 break;
1421 default:
1422 assert(0);
1423 goto error;
1424 }
477d7741
MD
1425 if (ret < 0) {
1426 PERROR("asprintf UST shadow copy session");
477d7741 1427 assert(0);
7972aab2 1428 goto error;
477d7741
MD
1429 }
1430
48842b30 1431 /* Iterate over all channels in global domain. */
bec39940
DG
1432 cds_lfht_for_each_entry(usess->domain_global.channels->ht, &iter.iter,
1433 uchan, node.node) {
1434 struct lttng_ht_iter uiter;
ba767faf 1435
bec39940
DG
1436 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &uiter);
1437 ua_chan_node = lttng_ht_iter_get_node_str(&uiter);
5b4a0ec0 1438 if (ua_chan_node != NULL) {
fc34caaa 1439 /* Session exist. Contiuing. */
5b4a0ec0
DG
1440 continue;
1441 }
421cb601 1442
5b4a0ec0
DG
1443 DBG2("Channel %s not found on shadow session copy, creating it",
1444 uchan->name);
d0b96690 1445 ua_chan = alloc_ust_app_channel(uchan->name, ua_sess, &uchan->attr);
5b4a0ec0 1446 if (ua_chan == NULL) {
fc34caaa 1447 /* malloc failed FIXME: Might want to do handle ENOMEM .. */
5b4a0ec0 1448 continue;
48842b30 1449 }
5b4a0ec0 1450 shadow_copy_channel(ua_chan, uchan);
ffe60014
DG
1451 /*
1452 * The concept of metadata channel does not exist on the tracing
1453 * registry side of the session daemon so this can only be a per CPU
1454 * channel and not metadata.
1455 */
1456 ua_chan->attr.type = LTTNG_UST_CHAN_PER_CPU;
1457
bec39940 1458 lttng_ht_add_unique_str(ua_sess->channels, &ua_chan->node);
48842b30 1459 }
7972aab2
DG
1460
1461error:
1462 return;
48842b30
DG
1463}
1464
78f0bacd
DG
1465/*
1466 * Lookup sesison wrapper.
1467 */
84cd17c6
MD
1468static
1469void __lookup_session_by_app(struct ltt_ust_session *usess,
bec39940 1470 struct ust_app *app, struct lttng_ht_iter *iter)
84cd17c6
MD
1471{
1472 /* Get right UST app session from app */
2c348c10 1473 lttng_ht_lookup(app->sessions, (void *)((unsigned long) usess->id), iter);
84cd17c6
MD
1474}
1475
421cb601
DG
1476/*
1477 * Return ust app session from the app session hashtable using the UST session
a991f516 1478 * id.
421cb601 1479 */
48842b30
DG
1480static struct ust_app_session *lookup_session_by_app(
1481 struct ltt_ust_session *usess, struct ust_app *app)
1482{
bec39940
DG
1483 struct lttng_ht_iter iter;
1484 struct lttng_ht_node_ulong *node;
48842b30 1485
84cd17c6 1486 __lookup_session_by_app(usess, app, &iter);
bec39940 1487 node = lttng_ht_iter_get_node_ulong(&iter);
48842b30
DG
1488 if (node == NULL) {
1489 goto error;
1490 }
1491
1492 return caa_container_of(node, struct ust_app_session, node);
1493
1494error:
1495 return NULL;
1496}
1497
7972aab2
DG
1498/*
1499 * Setup buffer registry per PID for the given session and application. If none
1500 * is found, a new one is created, added to the global registry and
1501 * initialized. If regp is valid, it's set with the newly created object.
1502 *
1503 * Return 0 on success or else a negative value.
1504 */
1505static int setup_buffer_reg_pid(struct ust_app_session *ua_sess,
1506 struct ust_app *app, struct buffer_reg_pid **regp)
1507{
1508 int ret = 0;
1509 struct buffer_reg_pid *reg_pid;
1510
1511 assert(ua_sess);
1512 assert(app);
1513
1514 rcu_read_lock();
1515
1516 reg_pid = buffer_reg_pid_find(ua_sess->id);
1517 if (!reg_pid) {
1518 /*
1519 * This is the create channel path meaning that if there is NO
1520 * registry available, we have to create one for this session.
1521 */
1522 ret = buffer_reg_pid_create(ua_sess->id, &reg_pid);
1523 if (ret < 0) {
1524 goto error;
1525 }
1526 buffer_reg_pid_add(reg_pid);
1527 } else {
1528 goto end;
1529 }
1530
1531 /* Initialize registry. */
1532 ret = ust_registry_session_init(&reg_pid->registry->reg.ust, app,
1533 app->bits_per_long, app->uint8_t_alignment,
1534 app->uint16_t_alignment, app->uint32_t_alignment,
af6142cf
MD
1535 app->uint64_t_alignment, app->long_alignment,
1536 app->byte_order, app->version.major,
1537 app->version.minor);
7972aab2
DG
1538 if (ret < 0) {
1539 goto error;
1540 }
1541
1542 DBG3("UST app buffer registry per PID created successfully");
1543
1544end:
1545 if (regp) {
1546 *regp = reg_pid;
1547 }
1548error:
1549 rcu_read_unlock();
1550 return ret;
1551}
1552
1553/*
1554 * Setup buffer registry per UID for the given session and application. If none
1555 * is found, a new one is created, added to the global registry and
1556 * initialized. If regp is valid, it's set with the newly created object.
1557 *
1558 * Return 0 on success or else a negative value.
1559 */
1560static int setup_buffer_reg_uid(struct ltt_ust_session *usess,
1561 struct ust_app *app, struct buffer_reg_uid **regp)
1562{
1563 int ret = 0;
1564 struct buffer_reg_uid *reg_uid;
1565
1566 assert(usess);
1567 assert(app);
1568
1569 rcu_read_lock();
1570
1571 reg_uid = buffer_reg_uid_find(usess->id, app->bits_per_long, app->uid);
1572 if (!reg_uid) {
1573 /*
1574 * This is the create channel path meaning that if there is NO
1575 * registry available, we have to create one for this session.
1576 */
1577 ret = buffer_reg_uid_create(usess->id, app->bits_per_long, app->uid,
1578 LTTNG_DOMAIN_UST, &reg_uid);
1579 if (ret < 0) {
1580 goto error;
1581 }
1582 buffer_reg_uid_add(reg_uid);
1583 } else {
1584 goto end;
1585 }
1586
1587 /* Initialize registry. */
af6142cf 1588 ret = ust_registry_session_init(&reg_uid->registry->reg.ust, NULL,
7972aab2
DG
1589 app->bits_per_long, app->uint8_t_alignment,
1590 app->uint16_t_alignment, app->uint32_t_alignment,
af6142cf
MD
1591 app->uint64_t_alignment, app->long_alignment,
1592 app->byte_order, app->version.major,
1593 app->version.minor);
7972aab2
DG
1594 if (ret < 0) {
1595 goto error;
1596 }
1597 /* Add node to teardown list of the session. */
1598 cds_list_add(&reg_uid->lnode, &usess->buffer_reg_uid_list);
1599
1600 DBG3("UST app buffer registry per UID created successfully");
1601
1602end:
1603 if (regp) {
1604 *regp = reg_uid;
1605 }
1606error:
1607 rcu_read_unlock();
1608 return ret;
1609}
1610
421cb601 1611/*
3d8ca23b 1612 * Create a session on the tracer side for the given app.
421cb601 1613 *
3d8ca23b
DG
1614 * On success, ua_sess_ptr is populated with the session pointer or else left
1615 * untouched. If the session was created, is_created is set to 1. On error,
1616 * it's left untouched. Note that ua_sess_ptr is mandatory but is_created can
1617 * be NULL.
1618 *
1619 * Returns 0 on success or else a negative code which is either -ENOMEM or
1620 * -ENOTCONN which is the default code if the ustctl_create_session fails.
421cb601 1621 */
3d8ca23b
DG
1622static int create_ust_app_session(struct ltt_ust_session *usess,
1623 struct ust_app *app, struct ust_app_session **ua_sess_ptr,
1624 int *is_created)
421cb601 1625{
3d8ca23b 1626 int ret, created = 0;
421cb601
DG
1627 struct ust_app_session *ua_sess;
1628
3d8ca23b
DG
1629 assert(usess);
1630 assert(app);
1631 assert(ua_sess_ptr);
1632
840cb59c 1633 health_code_update();
86acf0da 1634
421cb601
DG
1635 ua_sess = lookup_session_by_app(usess, app);
1636 if (ua_sess == NULL) {
a991f516 1637 DBG2("UST app pid: %d session id %d not found, creating it",
852d0037 1638 app->pid, usess->id);
d0b96690 1639 ua_sess = alloc_ust_app_session(app);
421cb601
DG
1640 if (ua_sess == NULL) {
1641 /* Only malloc can failed so something is really wrong */
3d8ca23b
DG
1642 ret = -ENOMEM;
1643 goto error;
421cb601 1644 }
477d7741 1645 shadow_copy_session(ua_sess, usess, app);
3d8ca23b 1646 created = 1;
421cb601
DG
1647 }
1648
7972aab2
DG
1649 switch (usess->buffer_type) {
1650 case LTTNG_BUFFER_PER_PID:
1651 /* Init local registry. */
1652 ret = setup_buffer_reg_pid(ua_sess, app, NULL);
421cb601 1653 if (ret < 0) {
7972aab2
DG
1654 goto error;
1655 }
1656 break;
1657 case LTTNG_BUFFER_PER_UID:
1658 /* Look for a global registry. If none exists, create one. */
1659 ret = setup_buffer_reg_uid(usess, app, NULL);
1660 if (ret < 0) {
1661 goto error;
1662 }
1663 break;
1664 default:
1665 assert(0);
1666 ret = -EINVAL;
1667 goto error;
1668 }
1669
1670 health_code_update();
1671
1672 if (ua_sess->handle == -1) {
1673 ret = ustctl_create_session(app->sock);
1674 if (ret < 0) {
1675 if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
1676 ERR("Creating session for app pid %d with ret %d",
ffe60014
DG
1677 app->pid, ret);
1678 } else {
1679 DBG("UST app creating session failed. Application is dead");
1680 }
d0b96690 1681 delete_ust_app_session(-1, ua_sess, app);
3d8ca23b
DG
1682 if (ret != -ENOMEM) {
1683 /*
1684 * Tracer is probably gone or got an internal error so let's
1685 * behave like it will soon unregister or not usable.
1686 */
1687 ret = -ENOTCONN;
1688 }
1689 goto error;
421cb601
DG
1690 }
1691
7972aab2
DG
1692 ua_sess->handle = ret;
1693
1694 /* Add ust app session to app's HT */
1695 lttng_ht_node_init_ulong(&ua_sess->node,
1696 (unsigned long) ua_sess->tracing_id);
1697 lttng_ht_add_unique_ulong(app->sessions, &ua_sess->node);
1698
1699 DBG2("UST app session created successfully with handle %d", ret);
1700 }
1701
1702 *ua_sess_ptr = ua_sess;
1703 if (is_created) {
1704 *is_created = created;
1705 }
1706
1707 /* Everything went well. */
1708 ret = 0;
1709
1710error:
1711 health_code_update();
1712 return ret;
1713}
1714
1715/*
1716 * Create a context for the channel on the tracer.
1717 *
1718 * Called with UST app session lock held and a RCU read side lock.
1719 */
1720static
1721int create_ust_app_channel_context(struct ust_app_session *ua_sess,
1722 struct ust_app_channel *ua_chan, struct lttng_ust_context *uctx,
1723 struct ust_app *app)
1724{
1725 int ret = 0;
1726 struct lttng_ht_iter iter;
1727 struct lttng_ht_node_ulong *node;
1728 struct ust_app_ctx *ua_ctx;
1729
1730 DBG2("UST app adding context to channel %s", ua_chan->name);
1731
1732 lttng_ht_lookup(ua_chan->ctx, (void *)((unsigned long)uctx->ctx), &iter);
1733 node = lttng_ht_iter_get_node_ulong(&iter);
1734 if (node != NULL) {
1735 ret = -EEXIST;
1736 goto error;
1737 }
1738
1739 ua_ctx = alloc_ust_app_ctx(uctx);
1740 if (ua_ctx == NULL) {
1741 /* malloc failed */
1742 ret = -1;
1743 goto error;
1744 }
1745
1746 lttng_ht_node_init_ulong(&ua_ctx->node, (unsigned long) ua_ctx->ctx.ctx);
1747 lttng_ht_add_unique_ulong(ua_chan->ctx, &ua_ctx->node);
1748
1749 ret = create_ust_channel_context(ua_chan, ua_ctx, app);
1750 if (ret < 0) {
1751 goto error;
1752 }
1753
1754error:
1755 return ret;
1756}
1757
1758/*
1759 * Enable on the tracer side a ust app event for the session and channel.
1760 *
1761 * Called with UST app session lock held.
1762 */
1763static
1764int enable_ust_app_event(struct ust_app_session *ua_sess,
1765 struct ust_app_event *ua_event, struct ust_app *app)
1766{
1767 int ret;
1768
1769 ret = enable_ust_event(app, ua_sess, ua_event);
1770 if (ret < 0) {
1771 goto error;
1772 }
1773
1774 ua_event->enabled = 1;
1775
1776error:
1777 return ret;
1778}
1779
1780/*
1781 * Disable on the tracer side a ust app event for the session and channel.
1782 */
1783static int disable_ust_app_event(struct ust_app_session *ua_sess,
1784 struct ust_app_event *ua_event, struct ust_app *app)
1785{
1786 int ret;
1787
1788 ret = disable_ust_event(app, ua_sess, ua_event);
1789 if (ret < 0) {
1790 goto error;
1791 }
1792
1793 ua_event->enabled = 0;
1794
1795error:
1796 return ret;
1797}
1798
1799/*
1800 * Lookup ust app channel for session and disable it on the tracer side.
1801 */
1802static
1803int disable_ust_app_channel(struct ust_app_session *ua_sess,
1804 struct ust_app_channel *ua_chan, struct ust_app *app)
1805{
1806 int ret;
1807
1808 ret = disable_ust_channel(app, ua_sess, ua_chan);
1809 if (ret < 0) {
1810 goto error;
1811 }
1812
1813 ua_chan->enabled = 0;
1814
1815error:
1816 return ret;
1817}
1818
1819/*
1820 * Lookup ust app channel for session and enable it on the tracer side. This
1821 * MUST be called with a RCU read side lock acquired.
1822 */
1823static int enable_ust_app_channel(struct ust_app_session *ua_sess,
1824 struct ltt_ust_channel *uchan, struct ust_app *app)
1825{
1826 int ret = 0;
1827 struct lttng_ht_iter iter;
1828 struct lttng_ht_node_str *ua_chan_node;
1829 struct ust_app_channel *ua_chan;
1830
1831 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &iter);
1832 ua_chan_node = lttng_ht_iter_get_node_str(&iter);
1833 if (ua_chan_node == NULL) {
1834 DBG2("Unable to find channel %s in ust session id %u",
1835 uchan->name, ua_sess->tracing_id);
1836 goto error;
1837 }
1838
1839 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
1840
1841 ret = enable_ust_channel(app, ua_sess, ua_chan);
1842 if (ret < 0) {
1843 goto error;
1844 }
1845
1846error:
1847 return ret;
1848}
1849
1850/*
1851 * Ask the consumer to create a channel and get it if successful.
1852 *
1853 * Return 0 on success or else a negative value.
1854 */
1855static int do_consumer_create_channel(struct ltt_ust_session *usess,
1856 struct ust_app_session *ua_sess, struct ust_app_channel *ua_chan,
1857 int bitness, struct ust_registry_session *registry)
1858{
1859 int ret;
1860 unsigned int nb_fd = 0;
1861 struct consumer_socket *socket;
1862
1863 assert(usess);
1864 assert(ua_sess);
1865 assert(ua_chan);
1866 assert(registry);
1867
1868 rcu_read_lock();
1869 health_code_update();
1870
1871 /* Get the right consumer socket for the application. */
1872 socket = consumer_find_socket_by_bitness(bitness, usess->consumer);
1873 if (!socket) {
1874 ret = -EINVAL;
1875 goto error;
1876 }
1877
1878 health_code_update();
1879
1880 /* Need one fd for the channel. */
1881 ret = lttng_fd_get(LTTNG_FD_APPS, 1);
1882 if (ret < 0) {
1883 ERR("Exhausted number of available FD upon create channel");
1884 goto error;
1885 }
1886
1887 /*
1888 * Ask consumer to create channel. The consumer will return the number of
1889 * stream we have to expect.
1890 */
1891 ret = ust_consumer_ask_channel(ua_sess, ua_chan, usess->consumer, socket,
1892 registry);
1893 if (ret < 0) {
1894 goto error_ask;
1895 }
1896
1897 /*
1898 * Compute the number of fd needed before receiving them. It must be 2 per
1899 * stream (2 being the default value here).
1900 */
1901 nb_fd = DEFAULT_UST_STREAM_FD_NUM * ua_chan->expected_stream_count;
1902
1903 /* Reserve the amount of file descriptor we need. */
1904 ret = lttng_fd_get(LTTNG_FD_APPS, nb_fd);
1905 if (ret < 0) {
1906 ERR("Exhausted number of available FD upon create channel");
1907 goto error_fd_get_stream;
1908 }
1909
1910 health_code_update();
1911
1912 /*
1913 * Now get the channel from the consumer. This call wil populate the stream
1914 * list of that channel and set the ust objects.
1915 */
1916 ret = ust_consumer_get_channel(socket, ua_chan);
1917 if (ret < 0) {
1918 goto error_destroy;
1919 }
1920
1921 rcu_read_unlock();
1922 return 0;
1923
1924error_destroy:
1925 lttng_fd_put(LTTNG_FD_APPS, nb_fd);
1926error_fd_get_stream:
1927 /*
1928 * Initiate a destroy channel on the consumer since we had an error
1929 * handling it on our side. The return value is of no importance since we
1930 * already have a ret value set by the previous error that we need to
1931 * return.
1932 */
1933 (void) ust_consumer_destroy_channel(socket, ua_chan);
1934error_ask:
1935 lttng_fd_put(LTTNG_FD_APPS, 1);
1936error:
1937 health_code_update();
1938 rcu_read_unlock();
1939 return ret;
1940}
1941
1942/*
1943 * Duplicate the ust data object of the ust app stream and save it in the
1944 * buffer registry stream.
1945 *
1946 * Return 0 on success or else a negative value.
1947 */
1948static int duplicate_stream_object(struct buffer_reg_stream *reg_stream,
1949 struct ust_app_stream *stream)
1950{
1951 int ret;
1952
1953 assert(reg_stream);
1954 assert(stream);
1955
1956 /* Reserve the amount of file descriptor we need. */
1957 ret = lttng_fd_get(LTTNG_FD_APPS, 2);
1958 if (ret < 0) {
1959 ERR("Exhausted number of available FD upon duplicate stream");
1960 goto error;
1961 }
1962
1963 /* Duplicate object for stream once the original is in the registry. */
1964 ret = ustctl_duplicate_ust_object_data(&stream->obj,
1965 reg_stream->obj.ust);
1966 if (ret < 0) {
1967 ERR("Duplicate stream obj from %p to %p failed with ret %d",
1968 reg_stream->obj.ust, stream->obj, ret);
1969 lttng_fd_put(LTTNG_FD_APPS, 2);
1970 goto error;
1971 }
1972 stream->handle = stream->obj->handle;
1973
1974error:
1975 return ret;
1976}
1977
1978/*
1979 * Duplicate the ust data object of the ust app. channel and save it in the
1980 * buffer registry channel.
1981 *
1982 * Return 0 on success or else a negative value.
1983 */
1984static int duplicate_channel_object(struct buffer_reg_channel *reg_chan,
1985 struct ust_app_channel *ua_chan)
1986{
1987 int ret;
1988
1989 assert(reg_chan);
1990 assert(ua_chan);
1991
1992 /* Need two fds for the channel. */
1993 ret = lttng_fd_get(LTTNG_FD_APPS, 1);
1994 if (ret < 0) {
1995 ERR("Exhausted number of available FD upon duplicate channel");
1996 goto error_fd_get;
1997 }
1998
1999 /* Duplicate object for stream once the original is in the registry. */
2000 ret = ustctl_duplicate_ust_object_data(&ua_chan->obj, reg_chan->obj.ust);
2001 if (ret < 0) {
2002 ERR("Duplicate channel obj from %p to %p failed with ret: %d",
2003 reg_chan->obj.ust, ua_chan->obj, ret);
2004 goto error;
2005 }
2006 ua_chan->handle = ua_chan->obj->handle;
2007
2008 return 0;
2009
2010error:
2011 lttng_fd_put(LTTNG_FD_APPS, 1);
2012error_fd_get:
2013 return ret;
2014}
2015
2016/*
2017 * For a given channel buffer registry, setup all streams of the given ust
2018 * application channel.
2019 *
2020 * Return 0 on success or else a negative value.
2021 */
2022static int setup_buffer_reg_streams(struct buffer_reg_channel *reg_chan,
2023 struct ust_app_channel *ua_chan)
2024{
2025 int ret = 0;
2026 struct ust_app_stream *stream, *stmp;
2027
2028 assert(reg_chan);
2029 assert(ua_chan);
2030
2031 DBG2("UST app setup buffer registry stream");
2032
2033 /* Send all streams to application. */
2034 cds_list_for_each_entry_safe(stream, stmp, &ua_chan->streams.head, list) {
2035 struct buffer_reg_stream *reg_stream;
2036
2037 ret = buffer_reg_stream_create(&reg_stream);
2038 if (ret < 0) {
2039 goto error;
2040 }
2041
2042 /*
2043 * Keep original pointer and nullify it in the stream so the delete
2044 * stream call does not release the object.
2045 */
2046 reg_stream->obj.ust = stream->obj;
2047 stream->obj = NULL;
2048 buffer_reg_stream_add(reg_stream, reg_chan);
421cb601 2049
7972aab2
DG
2050 /* We don't need the streams anymore. */
2051 cds_list_del(&stream->list);
2052 delete_ust_app_stream(-1, stream);
2053 }
421cb601 2054
7972aab2
DG
2055error:
2056 return ret;
2057}
2058
2059/*
2060 * Create a buffer registry channel for the given session registry and
2061 * application channel object. If regp pointer is valid, it's set with the
2062 * created object. Important, the created object is NOT added to the session
2063 * registry hash table.
2064 *
2065 * Return 0 on success else a negative value.
2066 */
2067static int create_buffer_reg_channel(struct buffer_reg_session *reg_sess,
2068 struct ust_app_channel *ua_chan, struct buffer_reg_channel **regp)
2069{
2070 int ret;
2071 struct buffer_reg_channel *reg_chan = NULL;
2072
2073 assert(reg_sess);
2074 assert(ua_chan);
2075
2076 DBG2("UST app creating buffer registry channel for %s", ua_chan->name);
2077
2078 /* Create buffer registry channel. */
2079 ret = buffer_reg_channel_create(ua_chan->tracing_channel_id, &reg_chan);
2080 if (ret < 0) {
2081 goto error_create;
421cb601 2082 }
7972aab2
DG
2083 assert(reg_chan);
2084 reg_chan->consumer_key = ua_chan->key;
421cb601 2085
7972aab2
DG
2086 /* Create and add a channel registry to session. */
2087 ret = ust_registry_channel_add(reg_sess->reg.ust,
2088 ua_chan->tracing_channel_id);
2089 if (ret < 0) {
2090 goto error;
d88aee68 2091 }
7972aab2 2092 buffer_reg_channel_add(reg_sess, reg_chan);
d88aee68 2093
7972aab2
DG
2094 if (regp) {
2095 *regp = reg_chan;
3d8ca23b 2096 }
d88aee68 2097
7972aab2 2098 return 0;
3d8ca23b
DG
2099
2100error:
7972aab2
DG
2101 /* Safe because the registry channel object was not added to any HT. */
2102 buffer_reg_channel_destroy(reg_chan, LTTNG_DOMAIN_UST);
2103error_create:
3d8ca23b 2104 return ret;
421cb601
DG
2105}
2106
55cc08a6 2107/*
7972aab2
DG
2108 * Setup buffer registry channel for the given session registry and application
2109 * channel object. If regp pointer is valid, it's set with the created object.
d0b96690 2110 *
7972aab2 2111 * Return 0 on success else a negative value.
55cc08a6 2112 */
7972aab2
DG
2113static int setup_buffer_reg_channel(struct buffer_reg_session *reg_sess,
2114 struct ust_app_channel *ua_chan, struct buffer_reg_channel *reg_chan)
55cc08a6 2115{
7972aab2 2116 int ret;
55cc08a6 2117
7972aab2
DG
2118 assert(reg_sess);
2119 assert(reg_chan);
2120 assert(ua_chan);
2121 assert(ua_chan->obj);
55cc08a6 2122
7972aab2 2123 DBG2("UST app setup buffer registry channel for %s", ua_chan->name);
55cc08a6 2124
7972aab2
DG
2125 /* Setup all streams for the registry. */
2126 ret = setup_buffer_reg_streams(reg_chan, ua_chan);
2127 if (ret < 0) {
55cc08a6
DG
2128 goto error;
2129 }
2130
7972aab2
DG
2131 reg_chan->obj.ust = ua_chan->obj;
2132 ua_chan->obj = NULL;
55cc08a6 2133
7972aab2 2134 return 0;
55cc08a6
DG
2135
2136error:
7972aab2
DG
2137 buffer_reg_channel_remove(reg_sess, reg_chan);
2138 buffer_reg_channel_destroy(reg_chan, LTTNG_DOMAIN_UST);
55cc08a6
DG
2139 return ret;
2140}
2141
edb67388 2142/*
7972aab2 2143 * Send buffer registry channel to the application.
d0b96690 2144 *
7972aab2 2145 * Return 0 on success else a negative value.
edb67388 2146 */
7972aab2
DG
2147static int send_channel_uid_to_ust(struct buffer_reg_channel *reg_chan,
2148 struct ust_app *app, struct ust_app_session *ua_sess,
2149 struct ust_app_channel *ua_chan)
edb67388
DG
2150{
2151 int ret;
7972aab2 2152 struct buffer_reg_stream *reg_stream;
edb67388 2153
7972aab2
DG
2154 assert(reg_chan);
2155 assert(app);
2156 assert(ua_sess);
2157 assert(ua_chan);
2158
2159 DBG("UST app sending buffer registry channel to ust sock %d", app->sock);
2160
2161 ret = duplicate_channel_object(reg_chan, ua_chan);
edb67388
DG
2162 if (ret < 0) {
2163 goto error;
2164 }
2165
7972aab2
DG
2166 /* Send channel to the application. */
2167 ret = ust_consumer_send_channel_to_ust(app, ua_sess, ua_chan);
2168 if (ret < 0) {
2169 goto error;
2170 }
2171
2172 health_code_update();
2173
2174 /* Send all streams to application. */
2175 pthread_mutex_lock(&reg_chan->stream_list_lock);
2176 cds_list_for_each_entry(reg_stream, &reg_chan->streams, lnode) {
2177 struct ust_app_stream stream;
2178
2179 ret = duplicate_stream_object(reg_stream, &stream);
2180 if (ret < 0) {
2181 goto error_stream_unlock;
2182 }
2183
2184 ret = ust_consumer_send_stream_to_ust(app, ua_chan, &stream);
2185 if (ret < 0) {
2186 goto error_stream_unlock;
2187 }
edb67388 2188
7972aab2
DG
2189 /*
2190 * The return value is not important here. This function will output an
2191 * error if needed.
2192 */
2193 (void) release_ust_app_stream(-1, &stream);
2194 }
2195 ua_chan->is_sent = 1;
2196
2197error_stream_unlock:
2198 pthread_mutex_unlock(&reg_chan->stream_list_lock);
edb67388
DG
2199error:
2200 return ret;
2201}
2202
9730260e 2203/*
7972aab2
DG
2204 * Create and send to the application the created buffers with per UID buffers.
2205 *
2206 * Return 0 on success else a negative value.
9730260e 2207 */
7972aab2
DG
2208static int create_channel_per_uid(struct ust_app *app,
2209 struct ltt_ust_session *usess, struct ust_app_session *ua_sess,
2210 struct ust_app_channel *ua_chan)
9730260e
DG
2211{
2212 int ret;
7972aab2
DG
2213 struct buffer_reg_uid *reg_uid;
2214 struct buffer_reg_channel *reg_chan;
9730260e 2215
7972aab2
DG
2216 assert(app);
2217 assert(usess);
2218 assert(ua_sess);
2219 assert(ua_chan);
2220
2221 DBG("UST app creating channel %s with per UID buffers", ua_chan->name);
2222
2223 reg_uid = buffer_reg_uid_find(usess->id, app->bits_per_long, app->uid);
2224 /*
2225 * The session creation handles the creation of this global registry
2226 * object. If none can be find, there is a code flow problem or a
2227 * teardown race.
2228 */
2229 assert(reg_uid);
2230
2231 reg_chan = buffer_reg_channel_find(ua_chan->tracing_channel_id,
2232 reg_uid);
2233 if (!reg_chan) {
2234 /* Create the buffer registry channel object. */
2235 ret = create_buffer_reg_channel(reg_uid->registry, ua_chan, &reg_chan);
2236 if (ret < 0) {
2237 goto error;
2238 }
2239 assert(reg_chan);
2240
2241 /*
2242 * Create the buffers on the consumer side. This call populates the
2243 * ust app channel object with all streams and data object.
2244 */
2245 ret = do_consumer_create_channel(usess, ua_sess, ua_chan,
2246 app->bits_per_long, reg_uid->registry->reg.ust);
2247 if (ret < 0) {
2248 goto error;
2249 }
2250
2251 /*
2252 * Setup the streams and add it to the session registry.
2253 */
2254 ret = setup_buffer_reg_channel(reg_uid->registry, ua_chan, reg_chan);
2255 if (ret < 0) {
2256 goto error;
2257 }
2258
2259 }
2260
2261 /* Send buffers to the application. */
2262 ret = send_channel_uid_to_ust(reg_chan, app, ua_sess, ua_chan);
9730260e
DG
2263 if (ret < 0) {
2264 goto error;
2265 }
2266
9730260e
DG
2267error:
2268 return ret;
2269}
2270
78f0bacd 2271/*
7972aab2
DG
2272 * Create and send to the application the created buffers with per PID buffers.
2273 *
2274 * Return 0 on success else a negative value.
78f0bacd 2275 */
7972aab2
DG
2276static int create_channel_per_pid(struct ust_app *app,
2277 struct ltt_ust_session *usess, struct ust_app_session *ua_sess,
2278 struct ust_app_channel *ua_chan)
78f0bacd 2279{
8535a6d9 2280 int ret;
7972aab2 2281 struct ust_registry_session *registry;
78f0bacd 2282
7972aab2
DG
2283 assert(app);
2284 assert(usess);
2285 assert(ua_sess);
2286 assert(ua_chan);
2287
2288 DBG("UST app creating channel %s with per PID buffers", ua_chan->name);
2289
2290 rcu_read_lock();
2291
2292 registry = get_session_registry(ua_sess);
2293 assert(registry);
2294
2295 /* Create and add a new channel registry to session. */
2296 ret = ust_registry_channel_add(registry, ua_chan->key);
78f0bacd
DG
2297 if (ret < 0) {
2298 goto error;
2299 }
2300
7972aab2
DG
2301 /* Create and get channel on the consumer side. */
2302 ret = do_consumer_create_channel(usess, ua_sess, ua_chan,
2303 app->bits_per_long, registry);
2304 if (ret < 0) {
2305 goto error;
2306 }
2307
2308 ret = send_channel_pid_to_ust(app, ua_sess, ua_chan);
2309 if (ret < 0) {
2310 goto error;
2311 }
8535a6d9 2312
78f0bacd 2313error:
7972aab2 2314 rcu_read_unlock();
78f0bacd
DG
2315 return ret;
2316}
2317
2318/*
7972aab2
DG
2319 * From an already allocated ust app channel, create the channel buffers if
2320 * need and send it to the application. This MUST be called with a RCU read
2321 * side lock acquired.
2322 *
2323 * Return 0 on success or else a negative value.
78f0bacd 2324 */
7972aab2
DG
2325static int do_create_channel(struct ust_app *app,
2326 struct ltt_ust_session *usess, struct ust_app_session *ua_sess,
2327 struct ust_app_channel *ua_chan)
78f0bacd 2328{
7972aab2 2329 int ret;
78f0bacd 2330
7972aab2
DG
2331 assert(app);
2332 assert(usess);
2333 assert(ua_sess);
2334 assert(ua_chan);
2335
2336 /* Handle buffer type before sending the channel to the application. */
2337 switch (usess->buffer_type) {
2338 case LTTNG_BUFFER_PER_UID:
2339 {
2340 ret = create_channel_per_uid(app, usess, ua_sess, ua_chan);
2341 if (ret < 0) {
2342 goto error;
2343 }
2344 break;
2345 }
2346 case LTTNG_BUFFER_PER_PID:
2347 {
2348 ret = create_channel_per_pid(app, usess, ua_sess, ua_chan);
2349 if (ret < 0) {
2350 goto error;
2351 }
2352 break;
2353 }
2354 default:
2355 assert(0);
2356 ret = -EINVAL;
78f0bacd
DG
2357 goto error;
2358 }
2359
7972aab2
DG
2360 /* Initialize ust objd object using the received handle and add it. */
2361 lttng_ht_node_init_ulong(&ua_chan->ust_objd_node, ua_chan->handle);
2362 lttng_ht_add_unique_ulong(app->ust_objd, &ua_chan->ust_objd_node);
78f0bacd 2363
7972aab2
DG
2364 /* If channel is not enabled, disable it on the tracer */
2365 if (!ua_chan->enabled) {
2366 ret = disable_ust_channel(app, ua_sess, ua_chan);
2367 if (ret < 0) {
2368 goto error;
2369 }
78f0bacd
DG
2370 }
2371
2372error:
2373 return ret;
2374}
2375
284d8f55 2376/*
4d710ac2
DG
2377 * Create UST app channel and create it on the tracer. Set ua_chanp of the
2378 * newly created channel if not NULL.
d0b96690 2379 *
36b588ed 2380 * Called with UST app session lock and RCU read-side lock held.
7972aab2
DG
2381 *
2382 * Return 0 on success or else a negative value.
284d8f55 2383 */
4d710ac2
DG
2384static int create_ust_app_channel(struct ust_app_session *ua_sess,
2385 struct ltt_ust_channel *uchan, struct ust_app *app,
7972aab2 2386 enum lttng_ust_chan_type type, struct ltt_ust_session *usess,
4d710ac2 2387 struct ust_app_channel **ua_chanp)
5b4a0ec0
DG
2388{
2389 int ret = 0;
bec39940
DG
2390 struct lttng_ht_iter iter;
2391 struct lttng_ht_node_str *ua_chan_node;
5b4a0ec0
DG
2392 struct ust_app_channel *ua_chan;
2393
2394 /* Lookup channel in the ust app session */
bec39940
DG
2395 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &iter);
2396 ua_chan_node = lttng_ht_iter_get_node_str(&iter);
fc34caaa 2397 if (ua_chan_node != NULL) {
5b4a0ec0 2398 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
fc34caaa 2399 goto end;
5b4a0ec0
DG
2400 }
2401
d0b96690 2402 ua_chan = alloc_ust_app_channel(uchan->name, ua_sess, &uchan->attr);
fc34caaa
DG
2403 if (ua_chan == NULL) {
2404 /* Only malloc can fail here */
4d710ac2 2405 ret = -ENOMEM;
fc34caaa
DG
2406 goto error;
2407 }
2408 shadow_copy_channel(ua_chan, uchan);
2409
ffe60014
DG
2410 /* Set channel type. */
2411 ua_chan->attr.type = type;
2412
7972aab2 2413 ret = do_create_channel(app, usess, ua_sess, ua_chan);
5b4a0ec0
DG
2414 if (ret < 0) {
2415 goto error;
2416 }
2417
fc34caaa 2418 DBG2("UST app create channel %s for PID %d completed", ua_chan->name,
852d0037 2419 app->pid);
fc34caaa 2420
d0b96690
DG
2421 /* Only add the channel if successful on the tracer side. */
2422 lttng_ht_add_unique_str(ua_sess->channels, &ua_chan->node);
2423
fc34caaa 2424end:
4d710ac2
DG
2425 if (ua_chanp) {
2426 *ua_chanp = ua_chan;
2427 }
2428
2429 /* Everything went well. */
2430 return 0;
5b4a0ec0
DG
2431
2432error:
d0b96690 2433 delete_ust_app_channel(ua_chan->is_sent ? app->sock : -1, ua_chan, app);
4d710ac2 2434 return ret;
5b4a0ec0
DG
2435}
2436
2437/*
2438 * Create UST app event and create it on the tracer side.
d0b96690
DG
2439 *
2440 * Called with ust app session mutex held.
5b4a0ec0 2441 */
edb67388
DG
2442static
2443int create_ust_app_event(struct ust_app_session *ua_sess,
2444 struct ust_app_channel *ua_chan, struct ltt_ust_event *uevent,
2445 struct ust_app *app)
284d8f55 2446{
edb67388 2447 int ret = 0;
5b4a0ec0 2448 struct ust_app_event *ua_event;
284d8f55 2449
5b4a0ec0 2450 /* Get event node */
18eace3b
DG
2451 ua_event = find_ust_app_event(ua_chan->events, uevent->attr.name,
2452 uevent->filter, uevent->attr.loglevel);
2453 if (ua_event != NULL) {
fc34caaa 2454 ret = -EEXIST;
edb67388
DG
2455 goto end;
2456 }
5b4a0ec0 2457
edb67388
DG
2458 /* Does not exist so create one */
2459 ua_event = alloc_ust_app_event(uevent->attr.name, &uevent->attr);
2460 if (ua_event == NULL) {
2461 /* Only malloc can failed so something is really wrong */
2462 ret = -ENOMEM;
fc34caaa 2463 goto end;
5b4a0ec0 2464 }
edb67388 2465 shadow_copy_event(ua_event, uevent);
5b4a0ec0 2466
edb67388 2467 /* Create it on the tracer side */
5b4a0ec0 2468 ret = create_ust_event(app, ua_sess, ua_chan, ua_event);
284d8f55 2469 if (ret < 0) {
fc34caaa 2470 /* Not found previously means that it does not exist on the tracer */
76f66f63 2471 assert(ret != -LTTNG_UST_ERR_EXIST);
284d8f55
DG
2472 goto error;
2473 }
2474
d0b96690 2475 add_unique_ust_app_event(ua_chan, ua_event);
284d8f55 2476
fc34caaa 2477 DBG2("UST app create event %s for PID %d completed", ua_event->name,
852d0037 2478 app->pid);
7f79d3a1 2479
edb67388 2480end:
fc34caaa
DG
2481 return ret;
2482
5b4a0ec0 2483error:
fc34caaa
DG
2484 /* Valid. Calling here is already in a read side lock */
2485 delete_ust_app_event(-1, ua_event);
edb67388 2486 return ret;
5b4a0ec0
DG
2487}
2488
2489/*
2490 * Create UST metadata and open it on the tracer side.
d0b96690 2491 *
7972aab2 2492 * Called with UST app session lock held and RCU read side lock.
5b4a0ec0
DG
2493 */
2494static int create_ust_app_metadata(struct ust_app_session *ua_sess,
d65d2de8
DG
2495 struct ust_app *app, struct consumer_output *consumer,
2496 struct ustctl_consumer_channel_attr *attr)
5b4a0ec0
DG
2497{
2498 int ret = 0;
ffe60014 2499 struct ust_app_channel *metadata;
d88aee68 2500 struct consumer_socket *socket;
7972aab2 2501 struct ust_registry_session *registry;
5b4a0ec0 2502
ffe60014
DG
2503 assert(ua_sess);
2504 assert(app);
d88aee68 2505 assert(consumer);
5b4a0ec0 2506
7972aab2
DG
2507 registry = get_session_registry(ua_sess);
2508 assert(registry);
2509
2510 /* Metadata already exists for this registry. */
2511 if (registry->metadata_key) {
2512 ret = 0;
2513 goto error;
5b4a0ec0
DG
2514 }
2515
ffe60014 2516 /* Allocate UST metadata */
d0b96690 2517 metadata = alloc_ust_app_channel(DEFAULT_METADATA_NAME, ua_sess, NULL);
ffe60014
DG
2518 if (!metadata) {
2519 /* malloc() failed */
2520 ret = -ENOMEM;
2521 goto error;
2522 }
5b4a0ec0 2523
d65d2de8
DG
2524 if (!attr) {
2525 /* Set default attributes for metadata. */
2526 metadata->attr.overwrite = DEFAULT_CHANNEL_OVERWRITE;
2527 metadata->attr.subbuf_size = default_get_metadata_subbuf_size();
2528 metadata->attr.num_subbuf = DEFAULT_METADATA_SUBBUF_NUM;
2529 metadata->attr.switch_timer_interval = DEFAULT_UST_CHANNEL_SWITCH_TIMER;
2530 metadata->attr.read_timer_interval = DEFAULT_UST_CHANNEL_READ_TIMER;
2531 metadata->attr.output = LTTNG_UST_MMAP;
2532 metadata->attr.type = LTTNG_UST_CHAN_METADATA;
2533 } else {
2534 memcpy(&metadata->attr, attr, sizeof(metadata->attr));
2535 metadata->attr.output = LTTNG_UST_MMAP;
2536 metadata->attr.type = LTTNG_UST_CHAN_METADATA;
2537 }
5b4a0ec0 2538
d88aee68 2539 /* Get the right consumer socket for the application. */
7972aab2 2540 socket = consumer_find_socket_by_bitness(app->bits_per_long, consumer);
d88aee68
DG
2541 if (!socket) {
2542 ret = -EINVAL;
2543 goto error_consumer;
2544 }
2545
7972aab2
DG
2546 /* Need one fd for the channel. */
2547 ret = lttng_fd_get(LTTNG_FD_APPS, 1);
2548 if (ret < 0) {
2549 ERR("Exhausted number of available FD upon create metadata");
2550 goto error;
2551 }
2552
331744e3
JD
2553 /*
2554 * Keep metadata key so we can identify it on the consumer side. Assign it
2555 * to the registry *before* we ask the consumer so we avoid the race of the
2556 * consumer requesting the metadata and the ask_channel call on our side
2557 * did not returned yet.
2558 */
2559 registry->metadata_key = metadata->key;
2560
d88aee68
DG
2561 /*
2562 * Ask the metadata channel creation to the consumer. The metadata object
2563 * will be created by the consumer and kept their. However, the stream is
2564 * never added or monitored until we do a first push metadata to the
2565 * consumer.
2566 */
7972aab2
DG
2567 ret = ust_consumer_ask_channel(ua_sess, metadata, consumer, socket,
2568 registry);
d88aee68 2569 if (ret < 0) {
7972aab2
DG
2570 /*
2571 * Safe because the metadata obj pointer is not set so the delete below
2572 * will not put a FD back again.
2573 */
2574 lttng_fd_put(LTTNG_FD_APPS, 1);
d88aee68
DG
2575 goto error_consumer;
2576 }
2577
2578 /*
2579 * The setup command will make the metadata stream be sent to the relayd,
2580 * if applicable, and the thread managing the metadatas. This is important
2581 * because after this point, if an error occurs, the only way the stream
2582 * can be deleted is to be monitored in the consumer.
2583 */
7972aab2 2584 ret = consumer_setup_metadata(socket, metadata->key);
ffe60014 2585 if (ret < 0) {
7972aab2
DG
2586 /*
2587 * Safe because the metadata obj pointer is not set so the delete below
2588 * will not put a FD back again.
2589 */
2590 lttng_fd_put(LTTNG_FD_APPS, 1);
d88aee68 2591 goto error_consumer;
5b4a0ec0
DG
2592 }
2593
7972aab2
DG
2594 DBG2("UST metadata with key %" PRIu64 " created for app pid %d",
2595 metadata->key, app->pid);
5b4a0ec0 2596
d88aee68
DG
2597error_consumer:
2598 delete_ust_app_channel(-1, metadata, app);
5b4a0ec0 2599error:
ffe60014 2600 return ret;
5b4a0ec0
DG
2601}
2602
2603/*
2604 * Return pointer to traceable apps list.
2605 */
bec39940 2606struct lttng_ht *ust_app_get_ht(void)
5b4a0ec0
DG
2607{
2608 return ust_app_ht;
2609}
2610
2611/*
d88aee68
DG
2612 * Return ust app pointer or NULL if not found. RCU read side lock MUST be
2613 * acquired before calling this function.
5b4a0ec0
DG
2614 */
2615struct ust_app *ust_app_find_by_pid(pid_t pid)
2616{
d88aee68 2617 struct ust_app *app = NULL;
bec39940
DG
2618 struct lttng_ht_node_ulong *node;
2619 struct lttng_ht_iter iter;
5b4a0ec0 2620
bec39940
DG
2621 lttng_ht_lookup(ust_app_ht, (void *)((unsigned long) pid), &iter);
2622 node = lttng_ht_iter_get_node_ulong(&iter);
5b4a0ec0
DG
2623 if (node == NULL) {
2624 DBG2("UST app no found with pid %d", pid);
2625 goto error;
2626 }
5b4a0ec0
DG
2627
2628 DBG2("Found UST app by pid %d", pid);
2629
d88aee68 2630 app = caa_container_of(node, struct ust_app, pid_n);
5b4a0ec0
DG
2631
2632error:
d88aee68 2633 return app;
5b4a0ec0
DG
2634}
2635
d88aee68
DG
2636/*
2637 * Allocate and init an UST app object using the registration information and
2638 * the command socket. This is called when the command socket connects to the
2639 * session daemon.
2640 *
2641 * The object is returned on success or else NULL.
2642 */
d0b96690 2643struct ust_app *ust_app_create(struct ust_register_msg *msg, int sock)
5b4a0ec0 2644{
d0b96690
DG
2645 struct ust_app *lta = NULL;
2646
2647 assert(msg);
2648 assert(sock >= 0);
2649
2650 DBG3("UST app creating application for socket %d", sock);
5b4a0ec0 2651
173af62f
DG
2652 if ((msg->bits_per_long == 64 &&
2653 (uatomic_read(&ust_consumerd64_fd) == -EINVAL))
2654 || (msg->bits_per_long == 32 &&
2655 (uatomic_read(&ust_consumerd32_fd) == -EINVAL))) {
f943b0fb 2656 ERR("Registration failed: application \"%s\" (pid: %d) has "
d0b96690
DG
2657 "%d-bit long, but no consumerd for this size is available.\n",
2658 msg->name, msg->pid, msg->bits_per_long);
2659 goto error;
3f2c5fcc 2660 }
d0b96690 2661
5b4a0ec0
DG
2662 lta = zmalloc(sizeof(struct ust_app));
2663 if (lta == NULL) {
2664 PERROR("malloc");
d0b96690 2665 goto error;
5b4a0ec0
DG
2666 }
2667
2668 lta->ppid = msg->ppid;
2669 lta->uid = msg->uid;
2670 lta->gid = msg->gid;
d0b96690 2671
7753dea8 2672 lta->bits_per_long = msg->bits_per_long;
d0b96690
DG
2673 lta->uint8_t_alignment = msg->uint8_t_alignment;
2674 lta->uint16_t_alignment = msg->uint16_t_alignment;
2675 lta->uint32_t_alignment = msg->uint32_t_alignment;
2676 lta->uint64_t_alignment = msg->uint64_t_alignment;
2677 lta->long_alignment = msg->long_alignment;
2678 lta->byte_order = msg->byte_order;
2679
5b4a0ec0
DG
2680 lta->v_major = msg->major;
2681 lta->v_minor = msg->minor;
bec39940 2682 lta->sessions = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG);
d0b96690
DG
2683 lta->ust_objd = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG);
2684 lta->notify_sock = -1;
d88aee68
DG
2685
2686 /* Copy name and make sure it's NULL terminated. */
2687 strncpy(lta->name, msg->name, sizeof(lta->name));
2688 lta->name[UST_APP_PROCNAME_LEN] = '\0';
2689
2690 /*
2691 * Before this can be called, when receiving the registration information,
2692 * the application compatibility is checked. So, at this point, the
2693 * application can work with this session daemon.
2694 */
d0b96690 2695 lta->compatible = 1;
5b4a0ec0 2696
852d0037 2697 lta->pid = msg->pid;
d0b96690 2698 lttng_ht_node_init_ulong(&lta->pid_n, (unsigned long) lta->pid);
852d0037 2699 lta->sock = sock;
d0b96690 2700 lttng_ht_node_init_ulong(&lta->sock_n, (unsigned long) lta->sock);
5b4a0ec0 2701
d42f20df
DG
2702 CDS_INIT_LIST_HEAD(&lta->teardown_head);
2703
d0b96690
DG
2704error:
2705 return lta;
2706}
2707
d88aee68
DG
2708/*
2709 * For a given application object, add it to every hash table.
2710 */
d0b96690
DG
2711void ust_app_add(struct ust_app *app)
2712{
2713 assert(app);
2714 assert(app->notify_sock >= 0);
2715
5b4a0ec0 2716 rcu_read_lock();
852d0037
DG
2717
2718 /*
2719 * On a re-registration, we want to kick out the previous registration of
2720 * that pid
2721 */
d0b96690 2722 lttng_ht_add_replace_ulong(ust_app_ht, &app->pid_n);
852d0037
DG
2723
2724 /*
2725 * The socket _should_ be unique until _we_ call close. So, a add_unique
2726 * for the ust_app_ht_by_sock is used which asserts fail if the entry was
2727 * already in the table.
2728 */
d0b96690 2729 lttng_ht_add_unique_ulong(ust_app_ht_by_sock, &app->sock_n);
852d0037 2730
d0b96690
DG
2731 /* Add application to the notify socket hash table. */
2732 lttng_ht_node_init_ulong(&app->notify_sock_n, app->notify_sock);
2733 lttng_ht_add_unique_ulong(ust_app_ht_by_notify_sock, &app->notify_sock_n);
5b4a0ec0 2734
d0b96690 2735 DBG("App registered with pid:%d ppid:%d uid:%d gid:%d sock:%d name:%s "
d88aee68
DG
2736 "notify_sock:%d (version %d.%d)", app->pid, app->ppid, app->uid,
2737 app->gid, app->sock, app->name, app->notify_sock, app->v_major,
2738 app->v_minor);
5b4a0ec0 2739
d0b96690
DG
2740 rcu_read_unlock();
2741}
2742
d88aee68
DG
2743/*
2744 * Set the application version into the object.
2745 *
2746 * Return 0 on success else a negative value either an errno code or a
2747 * LTTng-UST error code.
2748 */
d0b96690
DG
2749int ust_app_version(struct ust_app *app)
2750{
d88aee68
DG
2751 int ret;
2752
d0b96690 2753 assert(app);
d88aee68
DG
2754
2755 ret = ustctl_tracer_version(app->sock, &app->version);
2756 if (ret < 0) {
2757 if (ret != -LTTNG_UST_ERR_EXITING && ret != -EPIPE) {
2758 ERR("UST app %d verson failed with ret %d", app->sock, ret);
2759 } else {
2760 DBG3("UST app %d verion failed. Application is dead", app->sock);
2761 }
2762 }
2763
2764 return ret;
5b4a0ec0
DG
2765}
2766
2767/*
2768 * Unregister app by removing it from the global traceable app list and freeing
2769 * the data struct.
2770 *
2771 * The socket is already closed at this point so no close to sock.
2772 */
2773void ust_app_unregister(int sock)
2774{
2775 struct ust_app *lta;
bec39940
DG
2776 struct lttng_ht_node_ulong *node;
2777 struct lttng_ht_iter iter;
d42f20df 2778 struct ust_app_session *ua_sess;
525b0740 2779 int ret;
5b4a0ec0
DG
2780
2781 rcu_read_lock();
886459c6 2782
5b4a0ec0 2783 /* Get the node reference for a call_rcu */
852d0037 2784 lttng_ht_lookup(ust_app_ht_by_sock, (void *)((unsigned long) sock), &iter);
bec39940 2785 node = lttng_ht_iter_get_node_ulong(&iter);
d0b96690 2786 assert(node);
284d8f55 2787
852d0037 2788 lta = caa_container_of(node, struct ust_app, sock_n);
852d0037
DG
2789 DBG("PID %d unregistering with sock %d", lta->pid, sock);
2790
886459c6 2791 /* Remove application from PID hash table */
852d0037
DG
2792 ret = lttng_ht_del(ust_app_ht_by_sock, &iter);
2793 assert(!ret);
2794
d88aee68
DG
2795 /*
2796 * Remove application from notify hash table. The thread handling the
2797 * notify socket could have deleted the node so ignore on error because
2798 * either way it's valid. The close of that socket is handled by the other
2799 * thread.
2800 */
d0b96690 2801 iter.iter.node = &lta->notify_sock_n.node;
d88aee68 2802 (void) lttng_ht_del(ust_app_ht_by_notify_sock, &iter);
852d0037 2803
5b98a774
DG
2804 /*
2805 * Ignore return value since the node might have been removed before by an
2806 * add replace during app registration because the PID can be reassigned by
2807 * the OS.
2808 */
d0b96690 2809 iter.iter.node = &lta->pid_n.node;
bec39940 2810 ret = lttng_ht_del(ust_app_ht, &iter);
5b98a774
DG
2811 if (ret) {
2812 DBG3("Unregister app by PID %d failed. This can happen on pid reuse",
2813 lta->pid);
2814 }
852d0037 2815
d42f20df
DG
2816 /* Remove sessions so they are not visible during deletion.*/
2817 cds_lfht_for_each_entry(lta->sessions->ht, &iter.iter, ua_sess,
2818 node.node) {
7972aab2
DG
2819 struct ust_registry_session *registry;
2820
d42f20df
DG
2821 ret = lttng_ht_del(lta->sessions, &iter);
2822 if (ret) {
2823 /* The session was already removed so scheduled for teardown. */
2824 continue;
2825 }
2826
2827 /*
2828 * Add session to list for teardown. This is safe since at this point we
2829 * are the only one using this list.
2830 */
d88aee68
DG
2831 pthread_mutex_lock(&ua_sess->lock);
2832
2833 /*
2834 * Normally, this is done in the delete session process which is
2835 * executed in the call rcu below. However, upon registration we can't
2836 * afford to wait for the grace period before pushing data or else the
2837 * data pending feature can race between the unregistration and stop
2838 * command where the data pending command is sent *before* the grace
2839 * period ended.
2840 *
2841 * The close metadata below nullifies the metadata pointer in the
2842 * session so the delete session will NOT push/close a second time.
2843 */
7972aab2
DG
2844 registry = get_session_registry(ua_sess);
2845 if (registry) {
2846 /* Push metadata for application before freeing the application. */
2847 (void) push_metadata(registry, ua_sess->consumer);
2848
2849 /*
2850 * Don't ask to close metadata for global per UID buffers. Close
2851 * metadata only on destroy trace session in this case.
2852 */
2853 if (ua_sess->buffer_type != LTTNG_BUFFER_PER_UID) {
2854 /* And ask to close it for this session registry. */
2855 (void) close_metadata(registry, ua_sess->consumer);
2856 }
2857 }
d88aee68 2858
d42f20df 2859 cds_list_add(&ua_sess->teardown_node, &lta->teardown_head);
d88aee68 2860 pthread_mutex_unlock(&ua_sess->lock);
d42f20df
DG
2861 }
2862
852d0037
DG
2863 /* Free memory */
2864 call_rcu(&lta->pid_n.head, delete_ust_app_rcu);
2865
5b4a0ec0
DG
2866 rcu_read_unlock();
2867 return;
284d8f55
DG
2868}
2869
2870/*
5b4a0ec0 2871 * Return traceable_app_count
284d8f55 2872 */
5b4a0ec0 2873unsigned long ust_app_list_count(void)
284d8f55 2874{
5b4a0ec0 2875 unsigned long count;
284d8f55 2876
5b4a0ec0 2877 rcu_read_lock();
bec39940 2878 count = lttng_ht_get_count(ust_app_ht);
5b4a0ec0 2879 rcu_read_unlock();
284d8f55 2880
5b4a0ec0 2881 return count;
284d8f55
DG
2882}
2883
5b4a0ec0
DG
2884/*
2885 * Fill events array with all events name of all registered apps.
2886 */
2887int ust_app_list_events(struct lttng_event **events)
421cb601 2888{
5b4a0ec0
DG
2889 int ret, handle;
2890 size_t nbmem, count = 0;
bec39940 2891 struct lttng_ht_iter iter;
5b4a0ec0 2892 struct ust_app *app;
c617c0c6 2893 struct lttng_event *tmp_event;
421cb601 2894
5b4a0ec0 2895 nbmem = UST_APP_EVENT_LIST_SIZE;
c617c0c6
MD
2896 tmp_event = zmalloc(nbmem * sizeof(struct lttng_event));
2897 if (tmp_event == NULL) {
5b4a0ec0
DG
2898 PERROR("zmalloc ust app events");
2899 ret = -ENOMEM;
421cb601
DG
2900 goto error;
2901 }
2902
5b4a0ec0 2903 rcu_read_lock();
421cb601 2904
852d0037 2905 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
90eaa0d2 2906 struct lttng_ust_tracepoint_iter uiter;
ac3bd9c0 2907
840cb59c 2908 health_code_update();
86acf0da 2909
e0c7ec2b
DG
2910 if (!app->compatible) {
2911 /*
2912 * TODO: In time, we should notice the caller of this error by
2913 * telling him that this is a version error.
2914 */
2915 continue;
2916 }
852d0037 2917 handle = ustctl_tracepoint_list(app->sock);
5b4a0ec0 2918 if (handle < 0) {
ffe60014
DG
2919 if (handle != -EPIPE && handle != -LTTNG_UST_ERR_EXITING) {
2920 ERR("UST app list events getting handle failed for app pid %d",
2921 app->pid);
2922 }
5b4a0ec0
DG
2923 continue;
2924 }
421cb601 2925
852d0037 2926 while ((ret = ustctl_tracepoint_list_get(app->sock, handle,
fb54cdbf 2927 &uiter)) != -LTTNG_UST_ERR_NOENT) {
ffe60014
DG
2928 /* Handle ustctl error. */
2929 if (ret < 0) {
2930 free(tmp_event);
2931 if (ret != -LTTNG_UST_ERR_EXITING || ret != -EPIPE) {
2932 ERR("UST app tp list get failed for app %d with ret %d",
2933 app->sock, ret);
2934 } else {
2935 DBG3("UST app tp list get failed. Application is dead");
2936 }
2937 goto rcu_error;
2938 }
2939
840cb59c 2940 health_code_update();
815564d8 2941 if (count >= nbmem) {
d7b3776f 2942 /* In case the realloc fails, we free the memory */
c617c0c6
MD
2943 void *ptr;
2944
815564d8
MD
2945 DBG2("Reallocating event list from %zu to %zu entries", nbmem,
2946 2 * nbmem);
2947 nbmem *= 2;
c617c0c6
MD
2948 ptr = realloc(tmp_event, nbmem * sizeof(struct lttng_event));
2949 if (ptr == NULL) {
5b4a0ec0 2950 PERROR("realloc ust app events");
c617c0c6 2951 free(tmp_event);
5b4a0ec0
DG
2952 ret = -ENOMEM;
2953 goto rcu_error;
2954 }
c617c0c6 2955 tmp_event = ptr;
5b4a0ec0 2956 }
c617c0c6
MD
2957 memcpy(tmp_event[count].name, uiter.name, LTTNG_UST_SYM_NAME_LEN);
2958 tmp_event[count].loglevel = uiter.loglevel;
2959 tmp_event[count].type = (enum lttng_event_type) LTTNG_UST_TRACEPOINT;
2960 tmp_event[count].pid = app->pid;
2961 tmp_event[count].enabled = -1;
5b4a0ec0 2962 count++;
421cb601 2963 }
421cb601
DG
2964 }
2965
5b4a0ec0 2966 ret = count;
c617c0c6 2967 *events = tmp_event;
421cb601 2968
5b4a0ec0 2969 DBG2("UST app list events done (%zu events)", count);
421cb601 2970
5b4a0ec0
DG
2971rcu_error:
2972 rcu_read_unlock();
421cb601 2973error:
840cb59c 2974 health_code_update();
5b4a0ec0 2975 return ret;
421cb601
DG
2976}
2977
f37d259d
MD
2978/*
2979 * Fill events array with all events name of all registered apps.
2980 */
2981int ust_app_list_event_fields(struct lttng_event_field **fields)
2982{
2983 int ret, handle;
2984 size_t nbmem, count = 0;
2985 struct lttng_ht_iter iter;
2986 struct ust_app *app;
c617c0c6 2987 struct lttng_event_field *tmp_event;
f37d259d
MD
2988
2989 nbmem = UST_APP_EVENT_LIST_SIZE;
c617c0c6
MD
2990 tmp_event = zmalloc(nbmem * sizeof(struct lttng_event_field));
2991 if (tmp_event == NULL) {
f37d259d
MD
2992 PERROR("zmalloc ust app event fields");
2993 ret = -ENOMEM;
2994 goto error;
2995 }
2996
2997 rcu_read_lock();
2998
2999 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
3000 struct lttng_ust_field_iter uiter;
3001
840cb59c 3002 health_code_update();
86acf0da 3003
f37d259d
MD
3004 if (!app->compatible) {
3005 /*
3006 * TODO: In time, we should notice the caller of this error by
3007 * telling him that this is a version error.
3008 */
3009 continue;
3010 }
3011 handle = ustctl_tracepoint_field_list(app->sock);
3012 if (handle < 0) {
ffe60014
DG
3013 if (handle != -EPIPE && handle != -LTTNG_UST_ERR_EXITING) {
3014 ERR("UST app list field getting handle failed for app pid %d",
3015 app->pid);
3016 }
f37d259d
MD
3017 continue;
3018 }
3019
3020 while ((ret = ustctl_tracepoint_field_list_get(app->sock, handle,
fb54cdbf 3021 &uiter)) != -LTTNG_UST_ERR_NOENT) {
ffe60014
DG
3022 /* Handle ustctl error. */
3023 if (ret < 0) {
3024 free(tmp_event);
3025 if (ret != -LTTNG_UST_ERR_EXITING || ret != -EPIPE) {
3026 ERR("UST app tp list field failed for app %d with ret %d",
3027 app->sock, ret);
3028 } else {
3029 DBG3("UST app tp list field failed. Application is dead");
3030 }
3031 goto rcu_error;
3032 }
3033
840cb59c 3034 health_code_update();
f37d259d 3035 if (count >= nbmem) {
d7b3776f 3036 /* In case the realloc fails, we free the memory */
c617c0c6
MD
3037 void *ptr;
3038
f37d259d
MD
3039 DBG2("Reallocating event field list from %zu to %zu entries", nbmem,
3040 2 * nbmem);
3041 nbmem *= 2;
c617c0c6
MD
3042 ptr = realloc(tmp_event, nbmem * sizeof(struct lttng_event_field));
3043 if (ptr == NULL) {
f37d259d 3044 PERROR("realloc ust app event fields");
c617c0c6 3045 free(tmp_event);
f37d259d
MD
3046 ret = -ENOMEM;
3047 goto rcu_error;
3048 }
c617c0c6 3049 tmp_event = ptr;
f37d259d 3050 }
f37d259d 3051
c617c0c6
MD
3052 memcpy(tmp_event[count].field_name, uiter.field_name, LTTNG_UST_SYM_NAME_LEN);
3053 tmp_event[count].type = uiter.type;
3054 tmp_event[count].nowrite = uiter.nowrite;
f37d259d 3055
c617c0c6
MD
3056 memcpy(tmp_event[count].event.name, uiter.event_name, LTTNG_UST_SYM_NAME_LEN);
3057 tmp_event[count].event.loglevel = uiter.loglevel;
3058 tmp_event[count].event.type = LTTNG_UST_TRACEPOINT;
3059 tmp_event[count].event.pid = app->pid;
3060 tmp_event[count].event.enabled = -1;
f37d259d
MD
3061 count++;
3062 }
3063 }
3064
3065 ret = count;
c617c0c6 3066 *fields = tmp_event;
f37d259d
MD
3067
3068 DBG2("UST app list event fields done (%zu events)", count);
3069
3070rcu_error:
3071 rcu_read_unlock();
3072error:
840cb59c 3073 health_code_update();
f37d259d
MD
3074 return ret;
3075}
3076
5b4a0ec0
DG
3077/*
3078 * Free and clean all traceable apps of the global list.
36b588ed
MD
3079 *
3080 * Should _NOT_ be called with RCU read-side lock held.
5b4a0ec0
DG
3081 */
3082void ust_app_clean_list(void)
421cb601 3083{
5b4a0ec0 3084 int ret;
659ed79f 3085 struct ust_app *app;
bec39940 3086 struct lttng_ht_iter iter;
421cb601 3087
5b4a0ec0 3088 DBG2("UST app cleaning registered apps hash table");
421cb601 3089
5b4a0ec0 3090 rcu_read_lock();
421cb601 3091
659ed79f 3092 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
bec39940 3093 ret = lttng_ht_del(ust_app_ht, &iter);
525b0740 3094 assert(!ret);
659ed79f 3095 call_rcu(&app->pid_n.head, delete_ust_app_rcu);
421cb601
DG
3096 }
3097
852d0037 3098 /* Cleanup socket hash table */
659ed79f
DG
3099 cds_lfht_for_each_entry(ust_app_ht_by_sock->ht, &iter.iter, app,
3100 sock_n.node) {
852d0037 3101 ret = lttng_ht_del(ust_app_ht_by_sock, &iter);
bec39940
DG
3102 assert(!ret);
3103 }
852d0037 3104
d88aee68
DG
3105 /* Cleanup notify socket hash table */
3106 cds_lfht_for_each_entry(ust_app_ht_by_notify_sock->ht, &iter.iter, app,
3107 notify_sock_n.node) {
3108 ret = lttng_ht_del(ust_app_ht_by_notify_sock, &iter);
3109 assert(!ret);
3110 }
36b588ed 3111 rcu_read_unlock();
d88aee68 3112
bec39940 3113 /* Destroy is done only when the ht is empty */
852d0037
DG
3114 lttng_ht_destroy(ust_app_ht);
3115 lttng_ht_destroy(ust_app_ht_by_sock);
d88aee68 3116 lttng_ht_destroy(ust_app_ht_by_notify_sock);
5b4a0ec0
DG
3117}
3118
3119/*
3120 * Init UST app hash table.
3121 */
3122void ust_app_ht_alloc(void)
3123{
bec39940 3124 ust_app_ht = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG);
852d0037 3125 ust_app_ht_by_sock = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG);
d0b96690 3126 ust_app_ht_by_notify_sock = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG);
421cb601
DG
3127}
3128
78f0bacd
DG
3129/*
3130 * For a specific UST session, disable the channel for all registered apps.
3131 */
35a9059d 3132int ust_app_disable_channel_glb(struct ltt_ust_session *usess,
78f0bacd
DG
3133 struct ltt_ust_channel *uchan)
3134{
3135 int ret = 0;
bec39940
DG
3136 struct lttng_ht_iter iter;
3137 struct lttng_ht_node_str *ua_chan_node;
78f0bacd
DG
3138 struct ust_app *app;
3139 struct ust_app_session *ua_sess;
8535a6d9 3140 struct ust_app_channel *ua_chan;
78f0bacd
DG
3141
3142 if (usess == NULL || uchan == NULL) {
3143 ERR("Disabling UST global channel with NULL values");
3144 ret = -1;
3145 goto error;
3146 }
3147
a991f516
MD
3148 DBG2("UST app disabling channel %s from global domain for session id %d",
3149 uchan->name, usess->id);
78f0bacd
DG
3150
3151 rcu_read_lock();
3152
3153 /* For every registered applications */
852d0037 3154 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
bec39940 3155 struct lttng_ht_iter uiter;
e0c7ec2b
DG
3156 if (!app->compatible) {
3157 /*
3158 * TODO: In time, we should notice the caller of this error by
3159 * telling him that this is a version error.
3160 */
3161 continue;
3162 }
78f0bacd
DG
3163 ua_sess = lookup_session_by_app(usess, app);
3164 if (ua_sess == NULL) {
3165 continue;
3166 }
3167
8535a6d9 3168 /* Get channel */
bec39940
DG
3169 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &uiter);
3170 ua_chan_node = lttng_ht_iter_get_node_str(&uiter);
8535a6d9
DG
3171 /* If the session if found for the app, the channel must be there */
3172 assert(ua_chan_node);
3173
3174 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
3175 /* The channel must not be already disabled */
3176 assert(ua_chan->enabled == 1);
3177
3178 /* Disable channel onto application */
3179 ret = disable_ust_app_channel(ua_sess, ua_chan, app);
78f0bacd
DG
3180 if (ret < 0) {
3181 /* XXX: We might want to report this error at some point... */
3182 continue;
3183 }
3184 }
3185
3186 rcu_read_unlock();
3187
3188error:
3189 return ret;
3190}
3191
3192/*
3193 * For a specific UST session, enable the channel for all registered apps.
3194 */
35a9059d 3195int ust_app_enable_channel_glb(struct ltt_ust_session *usess,
78f0bacd
DG
3196 struct ltt_ust_channel *uchan)
3197{
3198 int ret = 0;
bec39940 3199 struct lttng_ht_iter iter;
78f0bacd
DG
3200 struct ust_app *app;
3201 struct ust_app_session *ua_sess;
3202
3203 if (usess == NULL || uchan == NULL) {
3204 ERR("Adding UST global channel to NULL values");
3205 ret = -1;
3206 goto error;
3207 }
3208
a991f516
MD
3209 DBG2("UST app enabling channel %s to global domain for session id %d",
3210 uchan->name, usess->id);
78f0bacd
DG
3211
3212 rcu_read_lock();
3213
3214 /* For every registered applications */
852d0037 3215 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
e0c7ec2b
DG
3216 if (!app->compatible) {
3217 /*
3218 * TODO: In time, we should notice the caller of this error by
3219 * telling him that this is a version error.
3220 */
3221 continue;
3222 }
78f0bacd
DG
3223 ua_sess = lookup_session_by_app(usess, app);
3224 if (ua_sess == NULL) {
3225 continue;
3226 }
3227
3228 /* Enable channel onto application */
3229 ret = enable_ust_app_channel(ua_sess, uchan, app);
3230 if (ret < 0) {
3231 /* XXX: We might want to report this error at some point... */
3232 continue;
3233 }
3234 }
3235
3236 rcu_read_unlock();
3237
3238error:
3239 return ret;
3240}
3241
b0a40d28
DG
3242/*
3243 * Disable an event in a channel and for a specific session.
3244 */
35a9059d
DG
3245int ust_app_disable_event_glb(struct ltt_ust_session *usess,
3246 struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent)
b0a40d28
DG
3247{
3248 int ret = 0;
bec39940
DG
3249 struct lttng_ht_iter iter, uiter;
3250 struct lttng_ht_node_str *ua_chan_node, *ua_event_node;
b0a40d28
DG
3251 struct ust_app *app;
3252 struct ust_app_session *ua_sess;
3253 struct ust_app_channel *ua_chan;
3254 struct ust_app_event *ua_event;
3255
3256 DBG("UST app disabling event %s for all apps in channel "
a991f516 3257 "%s for session id %d", uevent->attr.name, uchan->name, usess->id);
b0a40d28
DG
3258
3259 rcu_read_lock();
3260
3261 /* For all registered applications */
852d0037 3262 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
e0c7ec2b
DG
3263 if (!app->compatible) {
3264 /*
3265 * TODO: In time, we should notice the caller of this error by
3266 * telling him that this is a version error.
3267 */
3268 continue;
3269 }
b0a40d28
DG
3270 ua_sess = lookup_session_by_app(usess, app);
3271 if (ua_sess == NULL) {
3272 /* Next app */
3273 continue;
3274 }
3275
3276 /* Lookup channel in the ust app session */
bec39940
DG
3277 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &uiter);
3278 ua_chan_node = lttng_ht_iter_get_node_str(&uiter);
b0a40d28 3279 if (ua_chan_node == NULL) {
a991f516 3280 DBG2("Channel %s not found in session id %d for app pid %d."
852d0037 3281 "Skipping", uchan->name, usess->id, app->pid);
b0a40d28
DG
3282 continue;
3283 }
3284 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
3285
bec39940
DG
3286 lttng_ht_lookup(ua_chan->events, (void *)uevent->attr.name, &uiter);
3287 ua_event_node = lttng_ht_iter_get_node_str(&uiter);
b0a40d28
DG
3288 if (ua_event_node == NULL) {
3289 DBG2("Event %s not found in channel %s for app pid %d."
852d0037 3290 "Skipping", uevent->attr.name, uchan->name, app->pid);
b0a40d28
DG
3291 continue;
3292 }
3293 ua_event = caa_container_of(ua_event_node, struct ust_app_event, node);
3294
7f79d3a1 3295 ret = disable_ust_app_event(ua_sess, ua_event, app);
b0a40d28
DG
3296 if (ret < 0) {
3297 /* XXX: Report error someday... */
3298 continue;
3299 }
3300 }
3301
3302 rcu_read_unlock();
3303
3304 return ret;
3305}
3306
9730260e 3307/*
edb67388 3308 * For a specific UST session and UST channel, the event for all
9730260e
DG
3309 * registered apps.
3310 */
35a9059d 3311int ust_app_disable_all_event_glb(struct ltt_ust_session *usess,
9730260e
DG
3312 struct ltt_ust_channel *uchan)
3313{
3314 int ret = 0;
bec39940
DG
3315 struct lttng_ht_iter iter, uiter;
3316 struct lttng_ht_node_str *ua_chan_node;
9730260e
DG
3317 struct ust_app *app;
3318 struct ust_app_session *ua_sess;
3319 struct ust_app_channel *ua_chan;
3320 struct ust_app_event *ua_event;
3321
3322 DBG("UST app disabling all event for all apps in channel "
a991f516 3323 "%s for session id %d", uchan->name, usess->id);
9730260e
DG
3324
3325 rcu_read_lock();
3326
3327 /* For all registered applications */