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