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