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