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