2 * Copyright (C) 2011 - David Goulet <david.goulet@polymtl.ca>
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation; only version 2
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
26 #include <sys/types.h>
29 #include <urcu/compiler.h>
33 #include <lttng-share.h>
35 #include "common/runas.h"
37 #include "ust-consumer.h"
41 * Delete ust context safely. RCU read lock must be held before calling
45 void delete_ust_app_ctx(int sock
, struct ust_app_ctx
*ua_ctx
)
48 ustctl_release_object(sock
, ua_ctx
->obj
);
55 * Delete ust app event safely. RCU read lock must be held before calling
59 void delete_ust_app_event(int sock
, struct ust_app_event
*ua_event
)
62 struct lttng_ht_iter iter
;
63 struct ust_app_ctx
*ua_ctx
;
65 /* Destroy each context of event */
66 cds_lfht_for_each_entry(ua_event
->ctx
->ht
, &iter
.iter
, ua_ctx
,
68 ret
= lttng_ht_del(ua_event
->ctx
, &iter
);
70 delete_ust_app_ctx(sock
, ua_ctx
);
72 lttng_ht_destroy(ua_event
->ctx
);
74 if (ua_event
->obj
!= NULL
) {
75 ustctl_release_object(sock
, ua_event
->obj
);
82 * Delete ust app stream safely. RCU read lock must be held before calling
86 void delete_ust_app_stream(int sock
, struct ltt_ust_stream
*stream
)
89 ustctl_release_object(sock
, stream
->obj
);
96 * Delete ust app channel safely. RCU read lock must be held before calling
100 void delete_ust_app_channel(int sock
, struct ust_app_channel
*ua_chan
)
103 struct lttng_ht_iter iter
;
104 struct ust_app_event
*ua_event
;
105 struct ust_app_ctx
*ua_ctx
;
106 struct ltt_ust_stream
*stream
, *stmp
;
109 cds_list_for_each_entry_safe(stream
, stmp
, &ua_chan
->streams
.head
, list
) {
110 cds_list_del(&stream
->list
);
111 delete_ust_app_stream(sock
, stream
);
115 cds_lfht_for_each_entry(ua_chan
->ctx
->ht
, &iter
.iter
, ua_ctx
, node
.node
) {
116 ret
= lttng_ht_del(ua_chan
->ctx
, &iter
);
118 delete_ust_app_ctx(sock
, ua_ctx
);
120 lttng_ht_destroy(ua_chan
->ctx
);
123 cds_lfht_for_each_entry(ua_chan
->events
->ht
, &iter
.iter
, ua_event
,
125 ret
= lttng_ht_del(ua_chan
->events
, &iter
);
127 delete_ust_app_event(sock
, ua_event
);
129 lttng_ht_destroy(ua_chan
->events
);
131 if (ua_chan
->obj
!= NULL
) {
132 ustctl_release_object(sock
, ua_chan
->obj
);
139 * Delete ust app session safely. RCU read lock must be held before calling
143 void delete_ust_app_session(int sock
, struct ust_app_session
*ua_sess
)
146 struct lttng_ht_iter iter
;
147 struct ust_app_channel
*ua_chan
;
149 if (ua_sess
->metadata
) {
150 if (ua_sess
->metadata
->stream_obj
) {
151 ustctl_release_object(sock
, ua_sess
->metadata
->stream_obj
);
152 free(ua_sess
->metadata
->stream_obj
);
154 if (ua_sess
->metadata
->obj
) {
155 ustctl_release_object(sock
, ua_sess
->metadata
->obj
);
156 free(ua_sess
->metadata
->obj
);
160 cds_lfht_for_each_entry(ua_sess
->channels
->ht
, &iter
.iter
, ua_chan
,
162 ret
= lttng_ht_del(ua_sess
->channels
, &iter
);
164 delete_ust_app_channel(sock
, ua_chan
);
166 lttng_ht_destroy(ua_sess
->channels
);
168 if (ua_sess
->handle
!= -1) {
169 ustctl_release_handle(sock
, ua_sess
->handle
);
175 * Delete a traceable application structure from the global list. Never call
176 * this function outside of a call_rcu call.
179 void delete_ust_app(struct ust_app
*app
)
182 struct lttng_ht_iter iter
;
183 struct ust_app_session
*ua_sess
;
187 /* Delete ust app sessions info */
188 sock
= app
->key
.sock
;
192 cds_lfht_for_each_entry(app
->sessions
->ht
, &iter
.iter
, ua_sess
,
194 ret
= lttng_ht_del(app
->sessions
, &iter
);
196 delete_ust_app_session(app
->key
.sock
, ua_sess
);
198 lttng_ht_destroy(app
->sessions
);
201 * Wait until we have removed the key from the sock hash table before
202 * closing this socket, otherwise an application could re-use the socket ID
203 * and race with the teardown, using the same hash table entry.
207 DBG2("UST app pid %d deleted", app
->key
.pid
);
214 * URCU intermediate call to delete an UST app.
217 void delete_ust_app_rcu(struct rcu_head
*head
)
219 struct lttng_ht_node_ulong
*node
=
220 caa_container_of(head
, struct lttng_ht_node_ulong
, head
);
221 struct ust_app
*app
=
222 caa_container_of(node
, struct ust_app
, node
);
224 DBG3("Call RCU deleting app PID %d", app
->key
.pid
);
229 * Alloc new UST app session.
232 struct ust_app_session
*alloc_ust_app_session(void)
234 struct ust_app_session
*ua_sess
;
236 /* Init most of the default value by allocating and zeroing */
237 ua_sess
= zmalloc(sizeof(struct ust_app_session
));
238 if (ua_sess
== NULL
) {
243 ua_sess
->handle
= -1;
244 ua_sess
->channels
= lttng_ht_new(0, LTTNG_HT_TYPE_STRING
);
253 * Alloc new UST app channel.
256 struct ust_app_channel
*alloc_ust_app_channel(char *name
,
257 struct lttng_ust_channel
*attr
)
259 struct ust_app_channel
*ua_chan
;
261 /* Init most of the default value by allocating and zeroing */
262 ua_chan
= zmalloc(sizeof(struct ust_app_channel
));
263 if (ua_chan
== NULL
) {
268 /* Setup channel name */
269 strncpy(ua_chan
->name
, name
, sizeof(ua_chan
->name
));
270 ua_chan
->name
[sizeof(ua_chan
->name
) - 1] = '\0';
272 ua_chan
->enabled
= 1;
273 ua_chan
->handle
= -1;
274 ua_chan
->ctx
= lttng_ht_new(0, LTTNG_HT_TYPE_ULONG
);
275 ua_chan
->events
= lttng_ht_new(0, LTTNG_HT_TYPE_STRING
);
276 lttng_ht_node_init_str(&ua_chan
->node
, ua_chan
->name
);
278 CDS_INIT_LIST_HEAD(&ua_chan
->streams
.head
);
280 /* Copy attributes */
282 memcpy(&ua_chan
->attr
, attr
, sizeof(ua_chan
->attr
));
285 DBG3("UST app channel %s allocated", ua_chan
->name
);
294 * Alloc new UST app event.
297 struct ust_app_event
*alloc_ust_app_event(char *name
,
298 struct lttng_ust_event
*attr
)
300 struct ust_app_event
*ua_event
;
302 /* Init most of the default value by allocating and zeroing */
303 ua_event
= zmalloc(sizeof(struct ust_app_event
));
304 if (ua_event
== NULL
) {
309 ua_event
->enabled
= 1;
310 strncpy(ua_event
->name
, name
, sizeof(ua_event
->name
));
311 ua_event
->name
[sizeof(ua_event
->name
) - 1] = '\0';
312 ua_event
->ctx
= lttng_ht_new(0, LTTNG_HT_TYPE_ULONG
);
313 lttng_ht_node_init_str(&ua_event
->node
, ua_event
->name
);
315 /* Copy attributes */
317 memcpy(&ua_event
->attr
, attr
, sizeof(ua_event
->attr
));
320 DBG3("UST app event %s allocated", ua_event
->name
);
329 * Alloc new UST app context.
332 struct ust_app_ctx
*alloc_ust_app_ctx(struct lttng_ust_context
*uctx
)
334 struct ust_app_ctx
*ua_ctx
;
336 ua_ctx
= zmalloc(sizeof(struct ust_app_ctx
));
337 if (ua_ctx
== NULL
) {
342 memcpy(&ua_ctx
->ctx
, uctx
, sizeof(ua_ctx
->ctx
));
345 DBG3("UST app context %d allocated", ua_ctx
->ctx
.ctx
);
352 * Find an ust_app using the sock and return it. RCU read side lock must be
353 * held before calling this helper function.
356 struct ust_app
*find_app_by_sock(int sock
)
358 struct lttng_ht_node_ulong
*node
;
359 struct ust_app_key
*key
;
360 struct lttng_ht_iter iter
;
362 lttng_ht_lookup(ust_app_sock_key_map
, (void *)((unsigned long) sock
),
364 node
= lttng_ht_iter_get_node_ulong(&iter
);
366 DBG2("UST app find by sock %d key not found", sock
);
369 key
= caa_container_of(node
, struct ust_app_key
, node
);
371 lttng_ht_lookup(ust_app_ht
, (void *)((unsigned long) key
->pid
), &iter
);
372 node
= lttng_ht_iter_get_node_ulong(&iter
);
374 DBG2("UST app find by sock %d not found", sock
);
377 return caa_container_of(node
, struct ust_app
, node
);
384 * Create the channel context on the tracer.
387 int create_ust_channel_context(struct ust_app_channel
*ua_chan
,
388 struct ust_app_ctx
*ua_ctx
, struct ust_app
*app
)
392 ret
= ustctl_add_context(app
->key
.sock
, &ua_ctx
->ctx
,
393 ua_chan
->obj
, &ua_ctx
->obj
);
398 ua_ctx
->handle
= ua_ctx
->obj
->handle
;
400 DBG2("UST app context added to channel %s successfully", ua_chan
->name
);
407 * Create the event context on the tracer.
410 int create_ust_event_context(struct ust_app_event
*ua_event
,
411 struct ust_app_ctx
*ua_ctx
, struct ust_app
*app
)
415 ret
= ustctl_add_context(app
->key
.sock
, &ua_ctx
->ctx
,
416 ua_event
->obj
, &ua_ctx
->obj
);
421 ua_ctx
->handle
= ua_ctx
->obj
->handle
;
423 DBG2("UST app context added to event %s successfully", ua_event
->name
);
430 * Disable the specified event on to UST tracer for the UST session.
432 static int disable_ust_event(struct ust_app
*app
,
433 struct ust_app_session
*ua_sess
, struct ust_app_event
*ua_event
)
437 ret
= ustctl_disable(app
->key
.sock
, ua_event
->obj
);
439 ERR("UST app event %s disable failed for app (pid: %d) "
440 "and session handle %d with ret %d",
441 ua_event
->attr
.name
, app
->key
.pid
, ua_sess
->handle
, ret
);
445 DBG2("UST app event %s disabled successfully for app (pid: %d)",
446 ua_event
->attr
.name
, app
->key
.pid
);
453 * Disable the specified channel on to UST tracer for the UST session.
455 static int disable_ust_channel(struct ust_app
*app
,
456 struct ust_app_session
*ua_sess
, struct ust_app_channel
*ua_chan
)
460 ret
= ustctl_disable(app
->key
.sock
, ua_chan
->obj
);
462 ERR("UST app channel %s disable failed for app (pid: %d) "
463 "and session handle %d with ret %d",
464 ua_chan
->name
, app
->key
.pid
, ua_sess
->handle
, ret
);
468 DBG2("UST app channel %s disabled successfully for app (pid: %d)",
469 ua_chan
->name
, app
->key
.pid
);
476 * Enable the specified channel on to UST tracer for the UST session.
478 static int enable_ust_channel(struct ust_app
*app
,
479 struct ust_app_session
*ua_sess
, struct ust_app_channel
*ua_chan
)
483 ret
= ustctl_enable(app
->key
.sock
, ua_chan
->obj
);
485 ERR("UST app channel %s enable failed for app (pid: %d) "
486 "and session handle %d with ret %d",
487 ua_chan
->name
, app
->key
.pid
, ua_sess
->handle
, ret
);
491 ua_chan
->enabled
= 1;
493 DBG2("UST app channel %s enabled successfully for app (pid: %d)",
494 ua_chan
->name
, app
->key
.pid
);
501 * Enable the specified event on to UST tracer for the UST session.
503 static int enable_ust_event(struct ust_app
*app
,
504 struct ust_app_session
*ua_sess
, struct ust_app_event
*ua_event
)
508 ret
= ustctl_enable(app
->key
.sock
, ua_event
->obj
);
510 ERR("UST app event %s enable failed for app (pid: %d) "
511 "and session handle %d with ret %d",
512 ua_event
->attr
.name
, app
->key
.pid
, ua_sess
->handle
, ret
);
516 DBG2("UST app event %s enabled successfully for app (pid: %d)",
517 ua_event
->attr
.name
, app
->key
.pid
);
524 * Open metadata onto the UST tracer for a UST session.
526 static int open_ust_metadata(struct ust_app
*app
,
527 struct ust_app_session
*ua_sess
)
530 struct lttng_ust_channel_attr uattr
;
532 uattr
.overwrite
= ua_sess
->metadata
->attr
.overwrite
;
533 uattr
.subbuf_size
= ua_sess
->metadata
->attr
.subbuf_size
;
534 uattr
.num_subbuf
= ua_sess
->metadata
->attr
.num_subbuf
;
535 uattr
.switch_timer_interval
=
536 ua_sess
->metadata
->attr
.switch_timer_interval
;
537 uattr
.read_timer_interval
=
538 ua_sess
->metadata
->attr
.read_timer_interval
;
539 uattr
.output
= ua_sess
->metadata
->attr
.output
;
541 /* UST tracer metadata creation */
542 ret
= ustctl_open_metadata(app
->key
.sock
, ua_sess
->handle
, &uattr
,
543 &ua_sess
->metadata
->obj
);
545 ERR("UST app open metadata failed for app pid:%d with ret %d",
550 ua_sess
->metadata
->handle
= ua_sess
->metadata
->obj
->handle
;
557 * Create stream onto the UST tracer for a UST session.
559 static int create_ust_stream(struct ust_app
*app
,
560 struct ust_app_session
*ua_sess
)
564 ret
= ustctl_create_stream(app
->key
.sock
, ua_sess
->metadata
->obj
,
565 &ua_sess
->metadata
->stream_obj
);
567 ERR("UST create metadata stream failed");
576 * Create the specified channel onto the UST tracer for a UST session.
578 static int create_ust_channel(struct ust_app
*app
,
579 struct ust_app_session
*ua_sess
, struct ust_app_channel
*ua_chan
)
583 /* TODO: remove cast and use lttng-ust-abi.h */
584 ret
= ustctl_create_channel(app
->key
.sock
, ua_sess
->handle
,
585 (struct lttng_ust_channel_attr
*)&ua_chan
->attr
, &ua_chan
->obj
);
587 ERR("Creating channel %s for app (pid: %d, sock: %d) "
588 "and session handle %d with ret %d",
589 ua_chan
->name
, app
->key
.pid
, app
->key
.sock
,
590 ua_sess
->handle
, ret
);
594 ua_chan
->handle
= ua_chan
->obj
->handle
;
596 DBG2("UST app channel %s created successfully for pid:%d and sock:%d",
597 ua_chan
->name
, app
->key
.pid
, app
->key
.sock
);
599 /* If channel is not enabled, disable it on the tracer */
600 if (!ua_chan
->enabled
) {
601 ret
= disable_ust_channel(app
, ua_sess
, ua_chan
);
612 * Create the specified event onto the UST tracer for a UST session.
615 int create_ust_event(struct ust_app
*app
, struct ust_app_session
*ua_sess
,
616 struct ust_app_channel
*ua_chan
, struct ust_app_event
*ua_event
)
620 /* Create UST event on tracer */
621 ret
= ustctl_create_event(app
->key
.sock
, &ua_event
->attr
, ua_chan
->obj
,
624 if (ret
== -EEXIST
) {
628 ERR("Error ustctl create event %s for app pid: %d with ret %d",
629 ua_event
->attr
.name
, app
->key
.pid
, ret
);
633 ua_event
->handle
= ua_event
->obj
->handle
;
635 DBG2("UST app event %s created successfully for pid:%d",
636 ua_event
->attr
.name
, app
->key
.pid
);
638 /* If event not enabled, disable it on the tracer */
639 if (ua_event
->enabled
== 0) {
640 ret
= disable_ust_event(app
, ua_sess
, ua_event
);
643 * If we hit an EPERM, something is wrong with our disable call. If
644 * we get an EEXIST, there is a problem on the tracer side since we
649 /* Code flow problem */
652 /* It's OK for our use case. */
667 * Copy data between an UST app event and a LTT event.
669 static void shadow_copy_event(struct ust_app_event
*ua_event
,
670 struct ltt_ust_event
*uevent
)
672 struct lttng_ht_iter iter
;
673 struct ltt_ust_context
*uctx
;
674 struct ust_app_ctx
*ua_ctx
;
676 strncpy(ua_event
->name
, uevent
->attr
.name
, sizeof(ua_event
->name
));
677 ua_event
->name
[sizeof(ua_event
->name
) - 1] = '\0';
679 ua_event
->enabled
= uevent
->enabled
;
681 /* Copy event attributes */
682 memcpy(&ua_event
->attr
, &uevent
->attr
, sizeof(ua_event
->attr
));
684 cds_lfht_for_each_entry(uevent
->ctx
->ht
, &iter
.iter
, uctx
, node
.node
) {
685 ua_ctx
= alloc_ust_app_ctx(&uctx
->ctx
);
686 if (ua_ctx
== NULL
) {
687 /* malloc() failed. We should simply stop */
691 lttng_ht_node_init_ulong(&ua_ctx
->node
,
692 (unsigned long) ua_ctx
->ctx
.ctx
);
693 lttng_ht_add_unique_ulong(ua_event
->ctx
, &ua_ctx
->node
);
698 * Copy data between an UST app channel and a LTT channel.
700 static void shadow_copy_channel(struct ust_app_channel
*ua_chan
,
701 struct ltt_ust_channel
*uchan
)
703 struct lttng_ht_iter iter
;
704 struct lttng_ht_node_str
*ua_event_node
;
705 struct ltt_ust_event
*uevent
;
706 struct ltt_ust_context
*uctx
;
707 struct ust_app_event
*ua_event
;
708 struct ust_app_ctx
*ua_ctx
;
710 DBG2("UST app shadow copy of channel %s started", ua_chan
->name
);
712 strncpy(ua_chan
->name
, uchan
->name
, sizeof(ua_chan
->name
));
713 ua_chan
->name
[sizeof(ua_chan
->name
) - 1] = '\0';
714 /* Copy event attributes */
715 memcpy(&ua_chan
->attr
, &uchan
->attr
, sizeof(ua_chan
->attr
));
717 ua_chan
->enabled
= uchan
->enabled
;
719 cds_lfht_for_each_entry(uchan
->ctx
->ht
, &iter
.iter
, uctx
, node
.node
) {
720 ua_ctx
= alloc_ust_app_ctx(&uctx
->ctx
);
721 if (ua_ctx
== NULL
) {
724 lttng_ht_node_init_ulong(&ua_ctx
->node
,
725 (unsigned long) ua_ctx
->ctx
.ctx
);
726 lttng_ht_add_unique_ulong(ua_chan
->ctx
, &ua_ctx
->node
);
729 /* Copy all events from ltt ust channel to ust app channel */
730 cds_lfht_for_each_entry(uchan
->events
->ht
, &iter
.iter
, uevent
, node
.node
) {
731 struct lttng_ht_iter uiter
;
733 lttng_ht_lookup(ua_chan
->events
, (void *) uevent
->attr
.name
, &uiter
);
734 ua_event_node
= lttng_ht_iter_get_node_str(&uiter
);
735 if (ua_event_node
== NULL
) {
736 DBG2("UST event %s not found on shadow copy channel",
738 ua_event
= alloc_ust_app_event(uevent
->attr
.name
, &uevent
->attr
);
739 if (ua_event
== NULL
) {
742 shadow_copy_event(ua_event
, uevent
);
743 lttng_ht_add_unique_str(ua_chan
->events
, &ua_event
->node
);
747 DBG3("UST app shadow copy of channel %s done", ua_chan
->name
);
751 * Copy data between a UST app session and a regular LTT session.
753 static void shadow_copy_session(struct ust_app_session
*ua_sess
,
754 struct ltt_ust_session
*usess
, struct ust_app
*app
)
756 struct lttng_ht_node_str
*ua_chan_node
;
757 struct lttng_ht_iter iter
;
758 struct ltt_ust_channel
*uchan
;
759 struct ust_app_channel
*ua_chan
;
765 /* Get date and time for unique app path */
767 timeinfo
= localtime(&rawtime
);
768 strftime(datetime
, sizeof(datetime
), "%Y%m%d-%H%M%S", timeinfo
);
770 DBG2("Shadow copy of session handle %d", ua_sess
->handle
);
772 ua_sess
->id
= usess
->id
;
773 ua_sess
->uid
= usess
->uid
;
774 ua_sess
->gid
= usess
->gid
;
776 ret
= snprintf(ua_sess
->path
, PATH_MAX
, "%s/%s-%d-%s", usess
->pathname
,
777 app
->name
, app
->key
.pid
, datetime
);
779 PERROR("asprintf UST shadow copy session");
780 /* TODO: We cannot return an error from here.. */
784 /* TODO: support all UST domain */
786 /* Iterate over all channels in global domain. */
787 cds_lfht_for_each_entry(usess
->domain_global
.channels
->ht
, &iter
.iter
,
789 struct lttng_ht_iter uiter
;
791 lttng_ht_lookup(ua_sess
->channels
, (void *)uchan
->name
, &uiter
);
792 ua_chan_node
= lttng_ht_iter_get_node_str(&uiter
);
793 if (ua_chan_node
!= NULL
) {
794 /* Session exist. Contiuing. */
798 DBG2("Channel %s not found on shadow session copy, creating it",
800 ua_chan
= alloc_ust_app_channel(uchan
->name
, &uchan
->attr
);
801 if (ua_chan
== NULL
) {
802 /* malloc failed FIXME: Might want to do handle ENOMEM .. */
806 shadow_copy_channel(ua_chan
, uchan
);
807 lttng_ht_add_unique_str(ua_sess
->channels
, &ua_chan
->node
);
812 * Lookup sesison wrapper.
815 void __lookup_session_by_app(struct ltt_ust_session
*usess
,
816 struct ust_app
*app
, struct lttng_ht_iter
*iter
)
818 /* Get right UST app session from app */
819 lttng_ht_lookup(app
->sessions
, (void *)((unsigned long) usess
->id
), iter
);
823 * Return ust app session from the app session hashtable using the UST session
826 static struct ust_app_session
*lookup_session_by_app(
827 struct ltt_ust_session
*usess
, struct ust_app
*app
)
829 struct lttng_ht_iter iter
;
830 struct lttng_ht_node_ulong
*node
;
832 __lookup_session_by_app(usess
, app
, &iter
);
833 node
= lttng_ht_iter_get_node_ulong(&iter
);
838 return caa_container_of(node
, struct ust_app_session
, node
);
845 * Create a UST session onto the tracer of app and add it the session
848 * Return ust app session or NULL on error.
850 static struct ust_app_session
*create_ust_app_session(
851 struct ltt_ust_session
*usess
, struct ust_app
*app
)
854 struct ust_app_session
*ua_sess
;
856 ua_sess
= lookup_session_by_app(usess
, app
);
857 if (ua_sess
== NULL
) {
858 DBG2("UST app pid: %d session id %d not found, creating it",
859 app
->key
.pid
, usess
->id
);
860 ua_sess
= alloc_ust_app_session();
861 if (ua_sess
== NULL
) {
862 /* Only malloc can failed so something is really wrong */
865 shadow_copy_session(ua_sess
, usess
, app
);
868 if (ua_sess
->handle
== -1) {
869 ret
= ustctl_create_session(app
->key
.sock
);
871 ERR("Creating session for app pid %d", app
->key
.pid
);
875 ua_sess
->handle
= ret
;
877 /* Add ust app session to app's HT */
878 lttng_ht_node_init_ulong(&ua_sess
->node
, (unsigned long) ua_sess
->id
);
879 lttng_ht_add_unique_ulong(app
->sessions
, &ua_sess
->node
);
881 DBG2("UST app session created successfully with handle %d", ret
);
888 delete_ust_app_session(-1, ua_sess
);
893 * Create a context for the channel on the tracer.
896 int create_ust_app_channel_context(struct ust_app_session
*ua_sess
,
897 struct ust_app_channel
*ua_chan
, struct lttng_ust_context
*uctx
,
901 struct lttng_ht_iter iter
;
902 struct lttng_ht_node_ulong
*node
;
903 struct ust_app_ctx
*ua_ctx
;
905 DBG2("UST app adding context to channel %s", ua_chan
->name
);
907 lttng_ht_lookup(ua_chan
->ctx
, (void *)((unsigned long)uctx
->ctx
), &iter
);
908 node
= lttng_ht_iter_get_node_ulong(&iter
);
914 ua_ctx
= alloc_ust_app_ctx(uctx
);
915 if (ua_ctx
== NULL
) {
921 lttng_ht_node_init_ulong(&ua_ctx
->node
, (unsigned long) ua_ctx
->ctx
.ctx
);
922 lttng_ht_add_unique_ulong(ua_chan
->ctx
, &ua_ctx
->node
);
924 ret
= create_ust_channel_context(ua_chan
, ua_ctx
, app
);
934 * Create an UST context and enable it for the event on the tracer.
937 int create_ust_app_event_context(struct ust_app_session
*ua_sess
,
938 struct ust_app_event
*ua_event
, struct lttng_ust_context
*uctx
,
942 struct lttng_ht_iter iter
;
943 struct lttng_ht_node_ulong
*node
;
944 struct ust_app_ctx
*ua_ctx
;
946 DBG2("UST app adding context to event %s", ua_event
->name
);
948 lttng_ht_lookup(ua_event
->ctx
, (void *)((unsigned long)uctx
->ctx
), &iter
);
949 node
= lttng_ht_iter_get_node_ulong(&iter
);
955 ua_ctx
= alloc_ust_app_ctx(uctx
);
956 if (ua_ctx
== NULL
) {
962 lttng_ht_node_init_ulong(&ua_ctx
->node
, (unsigned long) ua_ctx
->ctx
.ctx
);
963 lttng_ht_add_unique_ulong(ua_event
->ctx
, &ua_ctx
->node
);
965 ret
= create_ust_event_context(ua_event
, ua_ctx
, app
);
975 * Enable on the tracer side a ust app event for the session and channel.
978 int enable_ust_app_event(struct ust_app_session
*ua_sess
,
979 struct ust_app_event
*ua_event
, struct ust_app
*app
)
983 ret
= enable_ust_event(app
, ua_sess
, ua_event
);
988 ua_event
->enabled
= 1;
995 * Disable on the tracer side a ust app event for the session and channel.
997 static int disable_ust_app_event(struct ust_app_session
*ua_sess
,
998 struct ust_app_event
*ua_event
, struct ust_app
*app
)
1002 ret
= disable_ust_event(app
, ua_sess
, ua_event
);
1007 ua_event
->enabled
= 0;
1014 * Lookup ust app channel for session and disable it on the tracer side.
1017 int disable_ust_app_channel(struct ust_app_session
*ua_sess
,
1018 struct ust_app_channel
*ua_chan
, struct ust_app
*app
)
1022 ret
= disable_ust_channel(app
, ua_sess
, ua_chan
);
1027 ua_chan
->enabled
= 0;
1034 * Lookup ust app channel for session and enable it on the tracer side.
1036 static int enable_ust_app_channel(struct ust_app_session
*ua_sess
,
1037 struct ltt_ust_channel
*uchan
, struct ust_app
*app
)
1040 struct lttng_ht_iter iter
;
1041 struct lttng_ht_node_str
*ua_chan_node
;
1042 struct ust_app_channel
*ua_chan
;
1044 lttng_ht_lookup(ua_sess
->channels
, (void *)uchan
->name
, &iter
);
1045 ua_chan_node
= lttng_ht_iter_get_node_str(&iter
);
1046 if (ua_chan_node
== NULL
) {
1047 DBG2("Unable to find channel %s in ust session id %u",
1048 uchan
->name
, ua_sess
->id
);
1052 ua_chan
= caa_container_of(ua_chan_node
, struct ust_app_channel
, node
);
1054 ret
= enable_ust_channel(app
, ua_sess
, ua_chan
);
1064 * Create UST app channel and create it on the tracer.
1066 static struct ust_app_channel
*create_ust_app_channel(
1067 struct ust_app_session
*ua_sess
, struct ltt_ust_channel
*uchan
,
1068 struct ust_app
*app
)
1071 struct lttng_ht_iter iter
;
1072 struct lttng_ht_node_str
*ua_chan_node
;
1073 struct ust_app_channel
*ua_chan
;
1075 /* Lookup channel in the ust app session */
1076 lttng_ht_lookup(ua_sess
->channels
, (void *)uchan
->name
, &iter
);
1077 ua_chan_node
= lttng_ht_iter_get_node_str(&iter
);
1078 if (ua_chan_node
!= NULL
) {
1079 ua_chan
= caa_container_of(ua_chan_node
, struct ust_app_channel
, node
);
1083 ua_chan
= alloc_ust_app_channel(uchan
->name
, &uchan
->attr
);
1084 if (ua_chan
== NULL
) {
1085 /* Only malloc can fail here */
1088 shadow_copy_channel(ua_chan
, uchan
);
1090 ret
= create_ust_channel(app
, ua_sess
, ua_chan
);
1092 /* Not found previously means that it does not exist on the tracer */
1093 assert(ret
!= -EEXIST
);
1097 lttng_ht_add_unique_str(ua_sess
->channels
, &ua_chan
->node
);
1099 DBG2("UST app create channel %s for PID %d completed", ua_chan
->name
,
1106 delete_ust_app_channel(-1, ua_chan
);
1111 * Create UST app event and create it on the tracer side.
1114 int create_ust_app_event(struct ust_app_session
*ua_sess
,
1115 struct ust_app_channel
*ua_chan
, struct ltt_ust_event
*uevent
,
1116 struct ust_app
*app
)
1119 struct lttng_ht_iter iter
;
1120 struct lttng_ht_node_str
*ua_event_node
;
1121 struct ust_app_event
*ua_event
;
1123 /* Get event node */
1124 lttng_ht_lookup(ua_chan
->events
, (void *)uevent
->attr
.name
, &iter
);
1125 ua_event_node
= lttng_ht_iter_get_node_str(&iter
);
1126 if (ua_event_node
!= NULL
) {
1131 /* Does not exist so create one */
1132 ua_event
= alloc_ust_app_event(uevent
->attr
.name
, &uevent
->attr
);
1133 if (ua_event
== NULL
) {
1134 /* Only malloc can failed so something is really wrong */
1138 shadow_copy_event(ua_event
, uevent
);
1140 /* Create it on the tracer side */
1141 ret
= create_ust_event(app
, ua_sess
, ua_chan
, ua_event
);
1143 /* Not found previously means that it does not exist on the tracer */
1144 assert(ret
!= -EEXIST
);
1148 lttng_ht_add_unique_str(ua_chan
->events
, &ua_event
->node
);
1150 DBG2("UST app create event %s for PID %d completed", ua_event
->name
,
1157 /* Valid. Calling here is already in a read side lock */
1158 delete_ust_app_event(-1, ua_event
);
1163 * Create UST metadata and open it on the tracer side.
1165 static int create_ust_app_metadata(struct ust_app_session
*ua_sess
,
1166 char *pathname
, struct ust_app
*app
)
1170 if (ua_sess
->metadata
== NULL
) {
1171 /* Allocate UST metadata */
1172 ua_sess
->metadata
= trace_ust_create_metadata(pathname
);
1173 if (ua_sess
->metadata
== NULL
) {
1174 /* malloc() failed */
1178 ret
= open_ust_metadata(app
, ua_sess
);
1180 /* Cleanup failed metadata struct */
1181 free(ua_sess
->metadata
);
1185 DBG2("UST metadata opened for app pid %d", app
->key
.pid
);
1188 /* Open UST metadata stream */
1189 if (ua_sess
->metadata
->stream_obj
== NULL
) {
1190 ret
= create_ust_stream(app
, ua_sess
);
1195 ret
= run_as_mkdir(ua_sess
->path
, S_IRWXU
| S_IRWXG
,
1196 ua_sess
->uid
, ua_sess
->gid
);
1198 PERROR("mkdir UST metadata");
1202 ret
= snprintf(ua_sess
->metadata
->pathname
, PATH_MAX
,
1203 "%s/metadata", ua_sess
->path
);
1205 PERROR("asprintf UST create stream");
1209 DBG2("UST metadata stream object created for app pid %d",
1212 ERR("Attempting to create stream without metadata opened");
1223 * Return pointer to traceable apps list.
1225 struct lttng_ht
*ust_app_get_ht(void)
1231 * Return ust app pointer or NULL if not found.
1233 struct ust_app
*ust_app_find_by_pid(pid_t pid
)
1235 struct lttng_ht_node_ulong
*node
;
1236 struct lttng_ht_iter iter
;
1239 lttng_ht_lookup(ust_app_ht
, (void *)((unsigned long) pid
), &iter
);
1240 node
= lttng_ht_iter_get_node_ulong(&iter
);
1242 DBG2("UST app no found with pid %d", pid
);
1247 DBG2("Found UST app by pid %d", pid
);
1249 return caa_container_of(node
, struct ust_app
, node
);
1257 * Using pid and uid (of the app), allocate a new ust_app struct and
1258 * add it to the global traceable app list.
1260 * On success, return 0, else return malloc -ENOMEM, or -EINVAL if app
1261 * bitness is not supported.
1263 int ust_app_register(struct ust_register_msg
*msg
, int sock
)
1265 struct ust_app
*lta
;
1267 if ((msg
->bits_per_long
== 64 && ust_consumerd64_fd
== -EINVAL
)
1268 || (msg
->bits_per_long
== 32 && ust_consumerd32_fd
== -EINVAL
)) {
1269 ERR("Registration failed: application \"%s\" (pid: %d) has "
1270 "%d-bit long, but no consumerd for this long size is available.\n",
1271 msg
->name
, msg
->pid
, msg
->bits_per_long
);
1275 lta
= zmalloc(sizeof(struct ust_app
));
1281 lta
->ppid
= msg
->ppid
;
1282 lta
->uid
= msg
->uid
;
1283 lta
->gid
= msg
->gid
;
1284 lta
->bits_per_long
= msg
->bits_per_long
;
1285 lta
->v_major
= msg
->major
;
1286 lta
->v_minor
= msg
->minor
;
1287 strncpy(lta
->name
, msg
->name
, sizeof(lta
->name
));
1288 lta
->name
[16] = '\0';
1289 lta
->sessions
= lttng_ht_new(0, LTTNG_HT_TYPE_ULONG
);
1292 lta
->key
.pid
= msg
->pid
;
1293 lttng_ht_node_init_ulong(<a
->node
, (unsigned long)lta
->key
.pid
);
1294 lta
->key
.sock
= sock
;
1295 lttng_ht_node_init_ulong(<a
->key
.node
, (unsigned long)lta
->key
.sock
);
1298 lttng_ht_add_unique_ulong(ust_app_sock_key_map
, <a
->key
.node
);
1299 lttng_ht_add_unique_ulong(ust_app_ht
, <a
->node
);
1302 DBG("App registered with pid:%d ppid:%d uid:%d gid:%d sock:%d name:%s"
1303 " (version %d.%d)", lta
->key
.pid
, lta
->ppid
, lta
->uid
, lta
->gid
,
1304 lta
->key
.sock
, lta
->name
, lta
->v_major
, lta
->v_minor
);
1310 * Unregister app by removing it from the global traceable app list and freeing
1313 * The socket is already closed at this point so no close to sock.
1315 void ust_app_unregister(int sock
)
1317 struct ust_app
*lta
;
1318 struct lttng_ht_node_ulong
*node
;
1319 struct lttng_ht_iter iter
;
1323 lta
= find_app_by_sock(sock
);
1325 ERR("Unregister app sock %d not found!", sock
);
1329 DBG("PID %d unregistering with sock %d", lta
->key
.pid
, sock
);
1331 /* Remove application from socket hash table */
1332 lttng_ht_lookup(ust_app_sock_key_map
, (void *)((unsigned long) sock
), &iter
);
1333 ret
= lttng_ht_del(ust_app_sock_key_map
, &iter
);
1336 /* Get the node reference for a call_rcu */
1337 lttng_ht_lookup(ust_app_ht
, (void *)((unsigned long) lta
->key
.pid
), &iter
);
1338 node
= lttng_ht_iter_get_node_ulong(&iter
);
1340 ERR("Unable to find app sock %d by pid %d", sock
, lta
->key
.pid
);
1344 /* Remove application from PID hash table */
1345 ret
= lttng_ht_del(ust_app_ht
, &iter
);
1347 call_rcu(&node
->head
, delete_ust_app_rcu
);
1354 * Return traceable_app_count
1356 unsigned long ust_app_list_count(void)
1358 unsigned long count
;
1361 count
= lttng_ht_get_count(ust_app_ht
);
1368 * Fill events array with all events name of all registered apps.
1370 int ust_app_list_events(struct lttng_event
**events
)
1373 size_t nbmem
, count
= 0;
1374 struct lttng_ht_iter iter
;
1375 struct ust_app
*app
;
1376 struct lttng_event
*tmp
;
1378 nbmem
= UST_APP_EVENT_LIST_SIZE
;
1379 tmp
= zmalloc(nbmem
* sizeof(struct lttng_event
));
1381 PERROR("zmalloc ust app events");
1388 cds_lfht_for_each_entry(ust_app_ht
->ht
, &iter
.iter
, app
, node
.node
) {
1389 struct lttng_ust_tracepoint_iter uiter
;
1391 handle
= ustctl_tracepoint_list(app
->key
.sock
);
1393 ERR("UST app list events getting handle failed for app pid %d",
1398 while ((ret
= ustctl_tracepoint_list_get(app
->key
.sock
, handle
,
1399 &uiter
)) != -ENOENT
) {
1400 if (count
>= nbmem
) {
1401 DBG2("Reallocating event list from %zu to %zu entries", nbmem
,
1404 tmp
= realloc(tmp
, nbmem
* sizeof(struct lttng_event
));
1406 PERROR("realloc ust app events");
1411 memcpy(tmp
[count
].name
, uiter
.name
, LTTNG_UST_SYM_NAME_LEN
);
1412 memcpy(tmp
[count
].loglevel
, uiter
.loglevel
, LTTNG_UST_SYM_NAME_LEN
);
1413 tmp
[count
].loglevel_value
= uiter
.loglevel_value
;
1414 tmp
[count
].type
= LTTNG_UST_TRACEPOINT
;
1415 tmp
[count
].pid
= app
->key
.pid
;
1416 tmp
[count
].enabled
= -1;
1424 DBG2("UST app list events done (%zu events)", count
);
1433 * Free and clean all traceable apps of the global list.
1435 void ust_app_clean_list(void)
1438 struct lttng_ht_iter iter
;
1439 struct lttng_ht_node_ulong
*node
;
1441 DBG2("UST app cleaning registered apps hash table");
1445 cds_lfht_for_each_entry(ust_app_ht
->ht
, &iter
.iter
, node
, node
) {
1446 ret
= lttng_ht_del(ust_app_ht
, &iter
);
1448 call_rcu(&node
->head
, delete_ust_app_rcu
);
1450 /* Destroy is done only when the ht is empty */
1451 lttng_ht_destroy(ust_app_ht
);
1453 cds_lfht_for_each_entry(ust_app_sock_key_map
->ht
, &iter
.iter
, node
, node
) {
1454 ret
= lttng_ht_del(ust_app_sock_key_map
, &iter
);
1457 /* Destroy is done only when the ht is empty */
1458 lttng_ht_destroy(ust_app_sock_key_map
);
1464 * Init UST app hash table.
1466 void ust_app_ht_alloc(void)
1468 ust_app_ht
= lttng_ht_new(0, LTTNG_HT_TYPE_ULONG
);
1469 ust_app_sock_key_map
= lttng_ht_new(0, LTTNG_HT_TYPE_ULONG
);
1473 * For a specific UST session, disable the channel for all registered apps.
1475 int ust_app_disable_channel_glb(struct ltt_ust_session
*usess
,
1476 struct ltt_ust_channel
*uchan
)
1479 struct lttng_ht_iter iter
;
1480 struct lttng_ht_node_str
*ua_chan_node
;
1481 struct ust_app
*app
;
1482 struct ust_app_session
*ua_sess
;
1483 struct ust_app_channel
*ua_chan
;
1485 if (usess
== NULL
|| uchan
== NULL
) {
1486 ERR("Disabling UST global channel with NULL values");
1491 DBG2("UST app disabling channel %s from global domain for session id %d",
1492 uchan
->name
, usess
->id
);
1496 /* For every registered applications */
1497 cds_lfht_for_each_entry(ust_app_ht
->ht
, &iter
.iter
, app
, node
.node
) {
1498 struct lttng_ht_iter uiter
;
1499 ua_sess
= lookup_session_by_app(usess
, app
);
1500 if (ua_sess
== NULL
) {
1505 lttng_ht_lookup(ua_sess
->channels
, (void *)uchan
->name
, &uiter
);
1506 ua_chan_node
= lttng_ht_iter_get_node_str(&uiter
);
1507 /* If the session if found for the app, the channel must be there */
1508 assert(ua_chan_node
);
1510 ua_chan
= caa_container_of(ua_chan_node
, struct ust_app_channel
, node
);
1511 /* The channel must not be already disabled */
1512 assert(ua_chan
->enabled
== 1);
1514 /* Disable channel onto application */
1515 ret
= disable_ust_app_channel(ua_sess
, ua_chan
, app
);
1517 /* XXX: We might want to report this error at some point... */
1529 * For a specific UST session, enable the channel for all registered apps.
1531 int ust_app_enable_channel_glb(struct ltt_ust_session
*usess
,
1532 struct ltt_ust_channel
*uchan
)
1535 struct lttng_ht_iter iter
;
1536 struct ust_app
*app
;
1537 struct ust_app_session
*ua_sess
;
1539 if (usess
== NULL
|| uchan
== NULL
) {
1540 ERR("Adding UST global channel to NULL values");
1545 DBG2("UST app enabling channel %s to global domain for session id %d",
1546 uchan
->name
, usess
->id
);
1550 /* For every registered applications */
1551 cds_lfht_for_each_entry(ust_app_ht
->ht
, &iter
.iter
, app
, node
.node
) {
1552 ua_sess
= lookup_session_by_app(usess
, app
);
1553 if (ua_sess
== NULL
) {
1557 /* Enable channel onto application */
1558 ret
= enable_ust_app_channel(ua_sess
, uchan
, app
);
1560 /* XXX: We might want to report this error at some point... */
1572 * Disable an event in a channel and for a specific session.
1574 int ust_app_disable_event_glb(struct ltt_ust_session
*usess
,
1575 struct ltt_ust_channel
*uchan
, struct ltt_ust_event
*uevent
)
1578 struct lttng_ht_iter iter
, uiter
;
1579 struct lttng_ht_node_str
*ua_chan_node
, *ua_event_node
;
1580 struct ust_app
*app
;
1581 struct ust_app_session
*ua_sess
;
1582 struct ust_app_channel
*ua_chan
;
1583 struct ust_app_event
*ua_event
;
1585 DBG("UST app disabling event %s for all apps in channel "
1586 "%s for session id %d", uevent
->attr
.name
, uchan
->name
, usess
->id
);
1590 /* For all registered applications */
1591 cds_lfht_for_each_entry(ust_app_ht
->ht
, &iter
.iter
, app
, node
.node
) {
1592 ua_sess
= lookup_session_by_app(usess
, app
);
1593 if (ua_sess
== NULL
) {
1598 /* Lookup channel in the ust app session */
1599 lttng_ht_lookup(ua_sess
->channels
, (void *)uchan
->name
, &uiter
);
1600 ua_chan_node
= lttng_ht_iter_get_node_str(&uiter
);
1601 if (ua_chan_node
== NULL
) {
1602 DBG2("Channel %s not found in session id %d for app pid %d."
1603 "Skipping", uchan
->name
, usess
->id
, app
->key
.pid
);
1606 ua_chan
= caa_container_of(ua_chan_node
, struct ust_app_channel
, node
);
1608 lttng_ht_lookup(ua_chan
->events
, (void *)uevent
->attr
.name
, &uiter
);
1609 ua_event_node
= lttng_ht_iter_get_node_str(&uiter
);
1610 if (ua_event_node
== NULL
) {
1611 DBG2("Event %s not found in channel %s for app pid %d."
1612 "Skipping", uevent
->attr
.name
, uchan
->name
, app
->key
.pid
);
1615 ua_event
= caa_container_of(ua_event_node
, struct ust_app_event
, node
);
1617 ret
= disable_ust_app_event(ua_sess
, ua_event
, app
);
1619 /* XXX: Report error someday... */
1630 * For a specific UST session and UST channel, the event for all
1633 int ust_app_disable_all_event_glb(struct ltt_ust_session
*usess
,
1634 struct ltt_ust_channel
*uchan
)
1637 struct lttng_ht_iter iter
, uiter
;
1638 struct lttng_ht_node_str
*ua_chan_node
;
1639 struct ust_app
*app
;
1640 struct ust_app_session
*ua_sess
;
1641 struct ust_app_channel
*ua_chan
;
1642 struct ust_app_event
*ua_event
;
1644 DBG("UST app disabling all event for all apps in channel "
1645 "%s for session id %d", uchan
->name
, usess
->id
);
1649 /* For all registered applications */
1650 cds_lfht_for_each_entry(ust_app_ht
->ht
, &iter
.iter
, app
, node
.node
) {
1651 ua_sess
= lookup_session_by_app(usess
, app
);
1652 /* If ua_sess is NULL, there is a code flow error */
1655 /* Lookup channel in the ust app session */
1656 lttng_ht_lookup(ua_sess
->channels
, (void *)uchan
->name
, &uiter
);
1657 ua_chan_node
= lttng_ht_iter_get_node_str(&uiter
);
1658 /* If the channel is not found, there is a code flow error */
1659 assert(ua_chan_node
);
1661 ua_chan
= caa_container_of(ua_chan_node
, struct ust_app_channel
, node
);
1663 /* Disable each events of channel */
1664 cds_lfht_for_each_entry(ua_chan
->events
->ht
, &uiter
.iter
, ua_event
,
1666 ret
= disable_ust_app_event(ua_sess
, ua_event
, app
);
1668 /* XXX: Report error someday... */
1680 * For a specific UST session, create the channel for all registered apps.
1682 int ust_app_create_channel_glb(struct ltt_ust_session
*usess
,
1683 struct ltt_ust_channel
*uchan
)
1685 struct lttng_ht_iter iter
;
1686 struct ust_app
*app
;
1687 struct ust_app_session
*ua_sess
;
1688 struct ust_app_channel
*ua_chan
;
1690 /* Very wrong code flow */
1694 DBG2("UST app adding channel %s to global domain for session id %d",
1695 uchan
->name
, usess
->id
);
1699 /* For every registered applications */
1700 cds_lfht_for_each_entry(ust_app_ht
->ht
, &iter
.iter
, app
, node
.node
) {
1702 * Create session on the tracer side and add it to app session HT. Note
1703 * that if session exist, it will simply return a pointer to the ust
1706 ua_sess
= create_ust_app_session(usess
, app
);
1707 if (ua_sess
== NULL
) {
1708 /* Major problem here and it's maybe the tracer or malloc() */
1712 /* Create channel onto application */
1713 ua_chan
= create_ust_app_channel(ua_sess
, uchan
, app
);
1714 if (ua_chan
== NULL
) {
1715 /* Major problem here and it's maybe the tracer or malloc() */
1729 * Enable event for a specific session and channel on the tracer.
1731 int ust_app_enable_event_glb(struct ltt_ust_session
*usess
,
1732 struct ltt_ust_channel
*uchan
, struct ltt_ust_event
*uevent
)
1735 struct lttng_ht_iter iter
, uiter
;
1736 struct lttng_ht_node_str
*ua_chan_node
, *ua_event_node
;
1737 struct ust_app
*app
;
1738 struct ust_app_session
*ua_sess
;
1739 struct ust_app_channel
*ua_chan
;
1740 struct ust_app_event
*ua_event
;
1742 DBG("UST app enabling event %s for all apps for session id %d",
1743 uevent
->attr
.name
, usess
->id
);
1746 * NOTE: At this point, this function is called only if the session and
1747 * channel passed are already created for all apps. and enabled on the
1753 /* For all registered applications */
1754 cds_lfht_for_each_entry(ust_app_ht
->ht
, &iter
.iter
, app
, node
.node
) {
1755 ua_sess
= lookup_session_by_app(usess
, app
);
1756 /* If ua_sess is NULL, there is a code flow error */
1759 /* Lookup channel in the ust app session */
1760 lttng_ht_lookup(ua_sess
->channels
, (void *)uchan
->name
, &uiter
);
1761 ua_chan_node
= lttng_ht_iter_get_node_str(&uiter
);
1762 /* If the channel is not found, there is a code flow error */
1763 assert(ua_chan_node
);
1765 ua_chan
= caa_container_of(ua_chan_node
, struct ust_app_channel
, node
);
1767 lttng_ht_lookup(ua_chan
->events
, (void*)uevent
->attr
.name
, &uiter
);
1768 ua_event_node
= lttng_ht_iter_get_node_str(&uiter
);
1769 if (ua_event_node
== NULL
) {
1770 DBG3("UST app enable event %s not found for app PID %d."
1771 "Skipping app", uevent
->attr
.name
, app
->key
.pid
);
1774 ua_event
= caa_container_of(ua_event_node
, struct ust_app_event
, node
);
1776 ret
= enable_ust_app_event(ua_sess
, ua_event
, app
);
1788 * For a specific existing UST session and UST channel, creates the event for
1789 * all registered apps.
1791 int ust_app_create_event_glb(struct ltt_ust_session
*usess
,
1792 struct ltt_ust_channel
*uchan
, struct ltt_ust_event
*uevent
)
1795 struct lttng_ht_iter iter
, uiter
;
1796 struct lttng_ht_node_str
*ua_chan_node
;
1797 struct ust_app
*app
;
1798 struct ust_app_session
*ua_sess
;
1799 struct ust_app_channel
*ua_chan
;
1801 DBG("UST app creating event %s for all apps for session id %d",
1802 uevent
->attr
.name
, usess
->id
);
1806 /* For all registered applications */
1807 cds_lfht_for_each_entry(ust_app_ht
->ht
, &iter
.iter
, app
, node
.node
) {
1808 ua_sess
= lookup_session_by_app(usess
, app
);
1809 /* If ua_sess is NULL, there is a code flow error */
1812 /* Lookup channel in the ust app session */
1813 lttng_ht_lookup(ua_sess
->channels
, (void *)uchan
->name
, &uiter
);
1814 ua_chan_node
= lttng_ht_iter_get_node_str(&uiter
);
1815 /* If the channel is not found, there is a code flow error */
1816 assert(ua_chan_node
);
1818 ua_chan
= caa_container_of(ua_chan_node
, struct ust_app_channel
, node
);
1820 ret
= create_ust_app_event(ua_sess
, ua_chan
, uevent
, app
);
1822 if (ret
!= -EEXIST
) {
1823 /* Possible value at this point: -ENOMEM. If so, we stop! */
1826 DBG2("UST app event %s already exist on app PID %d",
1827 uevent
->attr
.name
, app
->key
.pid
);
1838 * Start tracing for a specific UST session and app.
1840 int ust_app_start_trace(struct ltt_ust_session
*usess
, struct ust_app
*app
)
1843 struct lttng_ht_iter iter
;
1844 struct ust_app_session
*ua_sess
;
1845 struct ust_app_channel
*ua_chan
;
1846 struct ltt_ust_stream
*ustream
;
1849 DBG("Starting tracing for ust app pid %d", app
->key
.pid
);
1853 ua_sess
= lookup_session_by_app(usess
, app
);
1854 if (ua_sess
== NULL
) {
1855 goto error_rcu_unlock
;
1858 /* Upon restart, we skip the setup, already done */
1859 if (ua_sess
->started
) {
1863 ret
= create_ust_app_metadata(ua_sess
, usess
->pathname
, app
);
1865 goto error_rcu_unlock
;
1868 /* For each channel */
1869 cds_lfht_for_each_entry(ua_sess
->channels
->ht
, &iter
.iter
, ua_chan
,
1871 /* Create all streams */
1873 /* Create UST stream */
1874 ustream
= zmalloc(sizeof(*ustream
));
1875 if (ustream
== NULL
) {
1876 PERROR("zmalloc ust stream");
1877 goto error_rcu_unlock
;
1880 ret
= ustctl_create_stream(app
->key
.sock
, ua_chan
->obj
,
1883 /* Got all streams */
1886 ustream
->handle
= ustream
->obj
->handle
;
1888 /* Order is important */
1889 cds_list_add_tail(&ustream
->list
, &ua_chan
->streams
.head
);
1890 ret
= snprintf(ustream
->pathname
, PATH_MAX
, "%s/%s_%u",
1891 ua_sess
->path
, ua_chan
->name
,
1892 ua_chan
->streams
.count
++);
1894 PERROR("asprintf UST create stream");
1897 DBG2("UST stream %d ready at %s", ua_chan
->streams
.count
,
1902 switch (app
->bits_per_long
) {
1904 consumerd_fd
= ust_consumerd64_fd
;
1907 consumerd_fd
= ust_consumerd32_fd
;
1911 goto error_rcu_unlock
;
1914 /* Setup UST consumer socket and send fds to it */
1915 ret
= ust_consumer_send_session(consumerd_fd
, ua_sess
);
1917 goto error_rcu_unlock
;
1919 ua_sess
->started
= 1;
1922 /* This start the UST tracing */
1923 ret
= ustctl_start_session(app
->key
.sock
, ua_sess
->handle
);
1925 ERR("Error starting tracing for app pid: %d", app
->key
.pid
);
1926 goto error_rcu_unlock
;
1931 /* Quiescent wait after starting trace */
1932 ustctl_wait_quiescent(app
->key
.sock
);
1942 * Stop tracing for a specific UST session and app.
1944 int ust_app_stop_trace(struct ltt_ust_session
*usess
, struct ust_app
*app
)
1947 struct lttng_ht_iter iter
;
1948 struct ust_app_session
*ua_sess
;
1949 struct ust_app_channel
*ua_chan
;
1951 DBG("Stopping tracing for ust app pid %d", app
->key
.pid
);
1955 ua_sess
= lookup_session_by_app(usess
, app
);
1956 if (ua_sess
== NULL
) {
1957 /* Only malloc can failed so something is really wrong */
1958 goto error_rcu_unlock
;
1961 /* This inhibits UST tracing */
1962 ret
= ustctl_stop_session(app
->key
.sock
, ua_sess
->handle
);
1964 ERR("Error stopping tracing for app pid: %d", app
->key
.pid
);
1965 goto error_rcu_unlock
;
1968 /* Quiescent wait after stopping trace */
1969 ustctl_wait_quiescent(app
->key
.sock
);
1971 /* Flushing buffers */
1972 cds_lfht_for_each_entry(ua_sess
->channels
->ht
, &iter
.iter
, ua_chan
,
1974 ret
= ustctl_sock_flush_buffer(app
->key
.sock
, ua_chan
->obj
);
1976 ERR("UST app PID %d channel %s flush failed",
1977 app
->key
.pid
, ua_chan
->name
);
1978 ERR("Ended with ret %d", ret
);
1979 /* Continuing flushing all buffers */
1984 /* Flush all buffers before stopping */
1985 ret
= ustctl_sock_flush_buffer(app
->key
.sock
, ua_sess
->metadata
->obj
);
1987 ERR("UST app PID %d metadata flush failed", app
->key
.pid
);
1988 ERR("Ended with ret %d", ret
);
2001 * Destroy a specific UST session in apps.
2003 int ust_app_destroy_trace(struct ltt_ust_session
*usess
, struct ust_app
*app
)
2005 struct ust_app_session
*ua_sess
;
2006 struct lttng_ust_object_data obj
;
2007 struct lttng_ht_iter iter
;
2008 struct lttng_ht_node_ulong
*node
;
2011 DBG("Destroy tracing for ust app pid %d", app
->key
.pid
);
2015 __lookup_session_by_app(usess
, app
, &iter
);
2016 node
= lttng_ht_iter_get_node_ulong(&iter
);
2018 /* Only malloc can failed so something is really wrong */
2019 goto error_rcu_unlock
;
2021 ua_sess
= caa_container_of(node
, struct ust_app_session
, node
);
2022 ret
= lttng_ht_del(app
->sessions
, &iter
);
2024 delete_ust_app_session(app
->key
.sock
, ua_sess
);
2025 obj
.handle
= ua_sess
->handle
;
2028 obj
.memory_map_size
= 0;
2029 ustctl_release_object(app
->key
.sock
, &obj
);
2033 /* Quiescent wait after stopping trace */
2034 ustctl_wait_quiescent(app
->key
.sock
);
2044 * Start tracing for the UST session.
2046 int ust_app_start_trace_all(struct ltt_ust_session
*usess
)
2049 struct lttng_ht_iter iter
;
2050 struct ust_app
*app
;
2052 DBG("Starting all UST traces");
2056 cds_lfht_for_each_entry(ust_app_ht
->ht
, &iter
.iter
, app
, node
.node
) {
2057 ret
= ust_app_start_trace(usess
, app
);
2059 /* Continue to next apps even on error */
2070 * Start tracing for the UST session.
2072 int ust_app_stop_trace_all(struct ltt_ust_session
*usess
)
2075 struct lttng_ht_iter iter
;
2076 struct ust_app
*app
;
2078 DBG("Stopping all UST traces");
2082 cds_lfht_for_each_entry(ust_app_ht
->ht
, &iter
.iter
, app
, node
.node
) {
2083 ret
= ust_app_stop_trace(usess
, app
);
2085 /* Continue to next apps even on error */
2096 * Destroy app UST session.
2098 int ust_app_destroy_trace_all(struct ltt_ust_session
*usess
)
2101 struct lttng_ht_iter iter
;
2102 struct ust_app
*app
;
2104 DBG("Destroy all UST traces");
2108 cds_lfht_for_each_entry(ust_app_ht
->ht
, &iter
.iter
, app
, node
.node
) {
2109 ret
= ust_app_destroy_trace(usess
, app
);
2111 /* Continue to next apps even on error */
2122 * Add channels/events from UST global domain to registered apps at sock.
2124 void ust_app_global_update(struct ltt_ust_session
*usess
, int sock
)
2127 struct lttng_ht_iter iter
, uiter
;
2128 struct ust_app
*app
;
2129 struct ust_app_session
*ua_sess
;
2130 struct ust_app_channel
*ua_chan
;
2131 struct ust_app_event
*ua_event
;
2133 if (usess
== NULL
) {
2134 ERR("No UST session on global update. Returning");
2138 DBG2("UST app global update for app sock %d for session id %d", sock
,
2143 app
= find_app_by_sock(sock
);
2145 ERR("Failed to update app sock %d", sock
);
2149 ua_sess
= create_ust_app_session(usess
, app
);
2150 if (ua_sess
== NULL
) {
2155 * We can iterate safely here over all UST app session sicne the create ust
2156 * app session above made a shadow copy of the UST global domain from the
2159 cds_lfht_for_each_entry(ua_sess
->channels
->ht
, &iter
.iter
, ua_chan
,
2161 ret
= create_ust_channel(app
, ua_sess
, ua_chan
);
2163 /* FIXME: Should we quit here or continue... */
2167 /* For each events */
2168 cds_lfht_for_each_entry(ua_chan
->events
->ht
, &uiter
.iter
, ua_event
,
2170 ret
= create_ust_event(app
, ua_sess
, ua_chan
, ua_event
);
2172 /* FIXME: Should we quit here or continue... */
2178 if (usess
->start_trace
) {
2179 ret
= ust_app_start_trace(usess
, app
);
2184 DBG2("UST trace started for app pid %d", app
->key
.pid
);
2193 * Add context to a specific channel for global UST domain.
2195 int ust_app_add_ctx_channel_glb(struct ltt_ust_session
*usess
,
2196 struct ltt_ust_channel
*uchan
, struct ltt_ust_context
*uctx
)
2199 struct lttng_ht_node_str
*ua_chan_node
;
2200 struct lttng_ht_iter iter
, uiter
;
2201 struct ust_app_channel
*ua_chan
= NULL
;
2202 struct ust_app_session
*ua_sess
;
2203 struct ust_app
*app
;
2207 cds_lfht_for_each_entry(ust_app_ht
->ht
, &iter
.iter
, app
, node
.node
) {
2208 ua_sess
= lookup_session_by_app(usess
, app
);
2209 if (ua_sess
== NULL
) {
2213 /* Lookup channel in the ust app session */
2214 lttng_ht_lookup(ua_sess
->channels
, (void *)uchan
->name
, &uiter
);
2215 ua_chan_node
= lttng_ht_iter_get_node_str(&uiter
);
2216 if (ua_chan_node
== NULL
) {
2219 ua_chan
= caa_container_of(ua_chan_node
, struct ust_app_channel
,
2222 ret
= create_ust_app_channel_context(ua_sess
, ua_chan
, &uctx
->ctx
, app
);
2233 * Add context to a specific event in a channel for global UST domain.
2235 int ust_app_add_ctx_event_glb(struct ltt_ust_session
*usess
,
2236 struct ltt_ust_channel
*uchan
, struct ltt_ust_event
*uevent
,
2237 struct ltt_ust_context
*uctx
)
2240 struct lttng_ht_node_str
*ua_chan_node
, *ua_event_node
;
2241 struct lttng_ht_iter iter
, uiter
;
2242 struct ust_app_session
*ua_sess
;
2243 struct ust_app_event
*ua_event
;
2244 struct ust_app_channel
*ua_chan
= NULL
;
2245 struct ust_app
*app
;
2249 cds_lfht_for_each_entry(ust_app_ht
->ht
, &iter
.iter
, app
, node
.node
) {
2250 ua_sess
= lookup_session_by_app(usess
, app
);
2251 if (ua_sess
== NULL
) {
2255 /* Lookup channel in the ust app session */
2256 lttng_ht_lookup(ua_sess
->channels
, (void *)uchan
->name
, &uiter
);
2257 ua_chan_node
= lttng_ht_iter_get_node_str(&uiter
);
2258 if (ua_chan_node
== NULL
) {
2261 ua_chan
= caa_container_of(ua_chan_node
, struct ust_app_channel
,
2264 lttng_ht_lookup(ua_chan
->events
, (void *)uevent
->attr
.name
, &uiter
);
2265 ua_event_node
= lttng_ht_iter_get_node_str(&uiter
);
2266 if (ua_event_node
== NULL
) {
2269 ua_event
= caa_container_of(ua_event_node
, struct ust_app_event
,
2272 ret
= create_ust_app_event_context(ua_sess
, ua_event
, &uctx
->ctx
, app
);
2283 * Enable event for a channel from a UST session for a specific PID.
2285 int ust_app_enable_event_pid(struct ltt_ust_session
*usess
,
2286 struct ltt_ust_channel
*uchan
, struct ltt_ust_event
*uevent
, pid_t pid
)
2289 struct lttng_ht_iter iter
;
2290 struct lttng_ht_node_str
*ua_chan_node
, *ua_event_node
;
2291 struct ust_app
*app
;
2292 struct ust_app_session
*ua_sess
;
2293 struct ust_app_channel
*ua_chan
;
2294 struct ust_app_event
*ua_event
;
2296 DBG("UST app enabling event %s for PID %d", uevent
->attr
.name
, pid
);
2300 app
= ust_app_find_by_pid(pid
);
2302 ERR("UST app enable event per PID %d not found", pid
);
2307 ua_sess
= lookup_session_by_app(usess
, app
);
2308 /* If ua_sess is NULL, there is a code flow error */
2311 /* Lookup channel in the ust app session */
2312 lttng_ht_lookup(ua_sess
->channels
, (void *)uchan
->name
, &iter
);
2313 ua_chan_node
= lttng_ht_iter_get_node_str(&iter
);
2314 /* If the channel is not found, there is a code flow error */
2315 assert(ua_chan_node
);
2317 ua_chan
= caa_container_of(ua_chan_node
, struct ust_app_channel
, node
);
2319 lttng_ht_lookup(ua_chan
->events
, (void *)uevent
->attr
.name
, &iter
);
2320 ua_event_node
= lttng_ht_iter_get_node_str(&iter
);
2321 if (ua_event_node
== NULL
) {
2322 ret
= create_ust_app_event(ua_sess
, ua_chan
, uevent
, app
);
2327 ua_event
= caa_container_of(ua_event_node
, struct ust_app_event
, node
);
2329 ret
= enable_ust_app_event(ua_sess
, ua_event
, app
);
2341 * Disable event for a channel from a UST session for a specific PID.
2343 int ust_app_disable_event_pid(struct ltt_ust_session
*usess
,
2344 struct ltt_ust_channel
*uchan
, struct ltt_ust_event
*uevent
, pid_t pid
)
2347 struct lttng_ht_iter iter
;
2348 struct lttng_ht_node_str
*ua_chan_node
, *ua_event_node
;
2349 struct ust_app
*app
;
2350 struct ust_app_session
*ua_sess
;
2351 struct ust_app_channel
*ua_chan
;
2352 struct ust_app_event
*ua_event
;
2354 DBG("UST app disabling event %s for PID %d", uevent
->attr
.name
, pid
);
2358 app
= ust_app_find_by_pid(pid
);
2360 ERR("UST app disable event per PID %d not found", pid
);
2365 ua_sess
= lookup_session_by_app(usess
, app
);
2366 /* If ua_sess is NULL, there is a code flow error */
2369 /* Lookup channel in the ust app session */
2370 lttng_ht_lookup(ua_sess
->channels
, (void *)uchan
->name
, &iter
);
2371 ua_chan_node
= lttng_ht_iter_get_node_str(&iter
);
2372 if (ua_chan_node
== NULL
) {
2373 /* Channel does not exist, skip disabling */
2376 ua_chan
= caa_container_of(ua_chan_node
, struct ust_app_channel
, node
);
2378 lttng_ht_lookup(ua_chan
->events
, (void *)uevent
->attr
.name
, &iter
);
2379 ua_event_node
= lttng_ht_iter_get_node_str(&iter
);
2380 if (ua_event_node
== NULL
) {
2381 /* Event does not exist, skip disabling */
2384 ua_event
= caa_container_of(ua_event_node
, struct ust_app_event
, node
);
2386 ret
= disable_ust_app_event(ua_sess
, ua_event
, app
);