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