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