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