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