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>
31 #include <lttng-share.h>
33 #include "hashtable.h"
35 #include "ust-consumer.h"
39 * Delete ust context safely. RCU read lock must be held before calling
43 void delete_ust_app_ctx(int sock
, struct ust_app_ctx
*ua_ctx
)
46 ustctl_release_object(sock
, ua_ctx
->obj
);
53 * Delete ust app event safely. RCU read lock must be held before calling
57 void delete_ust_app_event(int sock
, struct ust_app_event
*ua_event
)
60 struct cds_lfht_iter iter
;
61 struct ust_app_ctx
*ua_ctx
;
63 cds_lfht_for_each_entry(ua_event
->ctx
, &iter
, ua_ctx
, node
) {
64 ret
= hashtable_del(ua_event
->ctx
, &iter
);
66 delete_ust_app_ctx(sock
, ua_ctx
);
68 ret
= hashtable_destroy(ua_event
->ctx
);
71 if (ua_event
->obj
!= NULL
) {
72 ustctl_release_object(sock
, ua_event
->obj
);
79 * Delete ust app stream safely. RCU read lock must be held before calling
83 void delete_ust_app_stream(int sock
, struct ltt_ust_stream
*stream
)
86 ustctl_release_object(sock
, stream
->obj
);
93 * Delete ust app channel safely. RCU read lock must be held before calling
97 void delete_ust_app_channel(int sock
, struct ust_app_channel
*ua_chan
)
100 struct cds_lfht_iter iter
;
101 struct ust_app_event
*ua_event
;
102 struct ust_app_ctx
*ua_ctx
;
103 struct ltt_ust_stream
*stream
, *stmp
;
106 cds_list_for_each_entry_safe(stream
, stmp
, &ua_chan
->streams
.head
, list
) {
107 cds_list_del(&stream
->list
);
108 delete_ust_app_stream(sock
, stream
);
112 cds_lfht_for_each_entry(ua_chan
->ctx
, &iter
, ua_ctx
, node
) {
113 ret
= hashtable_del(ua_chan
->ctx
, &iter
);
115 delete_ust_app_ctx(sock
, ua_ctx
);
117 ret
= hashtable_destroy(ua_chan
->ctx
);
121 cds_lfht_for_each_entry(ua_chan
->events
, &iter
, ua_event
, node
) {
122 ret
= hashtable_del(ua_chan
->events
, &iter
);
124 delete_ust_app_event(sock
, ua_event
);
126 ret
= hashtable_destroy(ua_chan
->events
);
129 if (ua_chan
->obj
!= NULL
) {
130 ustctl_release_object(sock
, ua_chan
->obj
);
137 * Delete ust app session safely. RCU read lock must be held before calling
141 void delete_ust_app_session(int sock
, struct ust_app_session
*ua_sess
)
144 struct cds_lfht_iter iter
;
145 struct ust_app_channel
*ua_chan
;
147 if (ua_sess
->metadata
) {
148 if (ua_sess
->metadata
->stream_obj
) {
149 ustctl_release_object(sock
, ua_sess
->metadata
->stream_obj
);
150 free(ua_sess
->metadata
->stream_obj
);
152 if (ua_sess
->metadata
->obj
) {
153 ustctl_release_object(sock
, ua_sess
->metadata
->obj
);
154 free(ua_sess
->metadata
->obj
);
158 cds_lfht_for_each_entry(ua_sess
->channels
, &iter
, ua_chan
, node
) {
159 ret
= hashtable_del(ua_sess
->channels
, &iter
);
161 delete_ust_app_channel(sock
, ua_chan
);
163 ret
= hashtable_destroy(ua_sess
->channels
);
166 if (ua_sess
->handle
!= -1) {
167 ustctl_release_handle(sock
, ua_sess
->handle
);
173 * Delete a traceable application structure from the global list. Never call
174 * this function outside of a call_rcu call.
177 void delete_ust_app(struct ust_app
*app
)
180 struct cds_lfht_node
*node
;
181 struct cds_lfht_iter iter
;
182 struct ust_app_session
*ua_sess
;
186 /* Remove from key hash table */
187 node
= hashtable_lookup(ust_app_sock_key_map
,
188 (void *) ((unsigned long) app
->key
.sock
), sizeof(void *), &iter
);
190 /* Not suppose to happen */
191 ERR("UST app key %d not found in key hash table", app
->key
.sock
);
195 ret
= hashtable_del(ust_app_sock_key_map
, &iter
);
197 ERR("UST app unable to delete app sock %d from key hash table",
200 DBG2("UST app pair sock %d key %d deleted",
201 app
->key
.sock
, app
->key
.pid
);
204 /* Socket is already closed at this point */
206 /* Delete ust app sessions info */
207 sock
= app
->key
.sock
;
211 cds_lfht_for_each_entry(app
->sessions
, &iter
, ua_sess
, node
) {
212 ret
= hashtable_del(app
->sessions
, &iter
);
214 delete_ust_app_session(app
->key
.sock
, ua_sess
);
216 ret
= hashtable_destroy(app
->sessions
);
220 * Wait until we have removed the key from the sock hash table
221 * before closing this socket, otherwise an application could
222 * re-use the socket ID and race with the teardown, using the
223 * same hash table entry.
227 DBG2("UST app pid %d deleted", app
->key
.pid
);
234 * URCU intermediate call to delete an UST app.
237 void delete_ust_app_rcu(struct rcu_head
*head
)
239 struct cds_lfht_node
*node
=
240 caa_container_of(head
, struct cds_lfht_node
, head
);
241 struct ust_app
*app
=
242 caa_container_of(node
, struct ust_app
, node
);
248 * Alloc new UST app session.
251 struct ust_app_session
*alloc_ust_app_session(void)
253 struct ust_app_session
*ua_sess
;
255 /* Init most of the default value by allocating and zeroing */
256 ua_sess
= zmalloc(sizeof(struct ust_app_session
));
257 if (ua_sess
== NULL
) {
262 ua_sess
->handle
= -1;
263 ua_sess
->channels
= hashtable_new_str(0);
272 * Alloc new UST app channel.
275 struct ust_app_channel
*alloc_ust_app_channel(char *name
,
276 struct lttng_ust_channel
*attr
)
278 struct ust_app_channel
*ua_chan
;
280 /* Init most of the default value by allocating and zeroing */
281 ua_chan
= zmalloc(sizeof(struct ust_app_channel
));
282 if (ua_chan
== NULL
) {
287 /* Setup channel name */
288 strncpy(ua_chan
->name
, name
, sizeof(ua_chan
->name
));
289 ua_chan
->name
[sizeof(ua_chan
->name
) - 1] = '\0';
291 ua_chan
->enabled
= 1;
292 ua_chan
->handle
= -1;
293 ua_chan
->ctx
= hashtable_new(0);
294 ua_chan
->events
= hashtable_new_str(0);
295 hashtable_node_init(&ua_chan
->node
, (void *) ua_chan
->name
,
296 strlen(ua_chan
->name
));
298 CDS_INIT_LIST_HEAD(&ua_chan
->streams
.head
);
300 /* Copy attributes */
302 memcpy(&ua_chan
->attr
, attr
, sizeof(ua_chan
->attr
));
305 DBG3("UST app channel %s allocated", ua_chan
->name
);
314 * Alloc new UST app event.
317 struct ust_app_event
*alloc_ust_app_event(char *name
,
318 struct lttng_ust_event
*attr
)
320 struct ust_app_event
*ua_event
;
322 /* Init most of the default value by allocating and zeroing */
323 ua_event
= zmalloc(sizeof(struct ust_app_event
));
324 if (ua_event
== NULL
) {
329 ua_event
->enabled
= 1;
330 strncpy(ua_event
->name
, name
, sizeof(ua_event
->name
));
331 ua_event
->name
[sizeof(ua_event
->name
) - 1] = '\0';
332 ua_event
->ctx
= hashtable_new(0);
333 hashtable_node_init(&ua_event
->node
, (void *) ua_event
->name
,
334 strlen(ua_event
->name
));
336 /* Copy attributes */
338 memcpy(&ua_event
->attr
, attr
, sizeof(ua_event
->attr
));
341 DBG3("UST app event %s allocated", ua_event
->name
);
350 * Alloc new UST app context.
353 struct ust_app_ctx
*alloc_ust_app_ctx(struct lttng_ust_context
*uctx
)
355 struct ust_app_ctx
*ua_ctx
;
357 ua_ctx
= zmalloc(sizeof(struct ust_app_ctx
));
358 if (ua_ctx
== NULL
) {
363 memcpy(&ua_ctx
->ctx
, uctx
, sizeof(ua_ctx
->ctx
));
366 DBG3("UST app context %d allocated", ua_ctx
->ctx
.ctx
);
373 * Find an ust_app using the sock and return it. RCU read side lock must be
374 * held before calling this helper function.
377 struct ust_app
*find_app_by_sock(int sock
)
379 struct cds_lfht_node
*node
;
380 struct ust_app_key
*key
;
381 struct cds_lfht_iter iter
;
383 node
= hashtable_lookup(ust_app_sock_key_map
,
384 (void *)((unsigned long) sock
), sizeof(void *), &iter
);
386 DBG2("UST app find by sock %d key not found", sock
);
390 key
= caa_container_of(node
, struct ust_app_key
, node
);
392 node
= hashtable_lookup(ust_app_ht
,
393 (void *)((unsigned long) key
->pid
), sizeof(void *), &iter
);
395 DBG2("UST app find by sock %d not found", sock
);
398 return caa_container_of(node
, struct ust_app
, node
);
405 * Create the channel context on the tracer.
408 int create_ust_channel_context(struct ust_app_channel
*ua_chan
,
409 struct ust_app_ctx
*ua_ctx
, struct ust_app
*app
)
413 ret
= ustctl_add_context(app
->key
.sock
, &ua_ctx
->ctx
,
414 ua_chan
->obj
, &ua_ctx
->obj
);
419 ua_ctx
->handle
= ua_ctx
->obj
->handle
;
421 DBG2("UST app context added to channel %s successfully", ua_chan
->name
);
428 * Create the event context on the tracer.
431 int create_ust_event_context(struct ust_app_event
*ua_event
,
432 struct ust_app_ctx
*ua_ctx
, struct ust_app
*app
)
436 ret
= ustctl_add_context(app
->key
.sock
, &ua_ctx
->ctx
,
437 ua_event
->obj
, &ua_ctx
->obj
);
442 ua_ctx
->handle
= ua_ctx
->obj
->handle
;
444 DBG2("UST app context added to event %s successfully", ua_event
->name
);
451 * Disable the specified event on to UST tracer for the UST session.
453 static int disable_ust_event(struct ust_app
*app
,
454 struct ust_app_session
*ua_sess
, struct ust_app_event
*ua_event
)
458 ret
= ustctl_disable(app
->key
.sock
, ua_event
->obj
);
460 ERR("UST app event %s disable failed for app (pid: %d) "
461 "and session handle %d with ret %d",
462 ua_event
->attr
.name
, app
->key
.pid
, ua_sess
->handle
, ret
);
466 DBG2("UST app event %s disabled successfully for app (pid: %d)",
467 ua_event
->attr
.name
, app
->key
.pid
);
474 * Disable the specified channel on to UST tracer for the UST session.
476 static int disable_ust_channel(struct ust_app
*app
,
477 struct ust_app_session
*ua_sess
, struct ust_app_channel
*ua_chan
)
481 ret
= ustctl_disable(app
->key
.sock
, ua_chan
->obj
);
483 ERR("UST app channel %s disable failed for app (pid: %d) "
484 "and session handle %d with ret %d",
485 ua_chan
->name
, app
->key
.pid
, ua_sess
->handle
, ret
);
489 DBG2("UST app channel %s disabled successfully for app (pid: %d)",
490 ua_chan
->name
, app
->key
.pid
);
497 * Enable the specified channel on to UST tracer for the UST session.
499 static int enable_ust_channel(struct ust_app
*app
,
500 struct ust_app_session
*ua_sess
, struct ust_app_channel
*ua_chan
)
504 ret
= ustctl_enable(app
->key
.sock
, ua_chan
->obj
);
506 ERR("UST app channel %s enable failed for app (pid: %d) "
507 "and session handle %d with ret %d",
508 ua_chan
->name
, app
->key
.pid
, ua_sess
->handle
, ret
);
512 ua_chan
->enabled
= 1;
514 DBG2("UST app channel %s enabled successfully for app (pid: %d)",
515 ua_chan
->name
, app
->key
.pid
);
522 * Enable the specified event on to UST tracer for the UST session.
524 static int enable_ust_event(struct ust_app
*app
,
525 struct ust_app_session
*ua_sess
, struct ust_app_event
*ua_event
)
529 ret
= ustctl_enable(app
->key
.sock
, ua_event
->obj
);
531 ERR("UST app event %s enable failed for app (pid: %d) "
532 "and session handle %d with ret %d",
533 ua_event
->attr
.name
, app
->key
.pid
, ua_sess
->handle
, ret
);
537 DBG2("UST app event %s enabled successfully for app (pid: %d)",
538 ua_event
->attr
.name
, app
->key
.pid
);
545 * Open metadata onto the UST tracer for a UST session.
547 static int open_ust_metadata(struct ust_app
*app
,
548 struct ust_app_session
*ua_sess
)
551 struct lttng_ust_channel_attr uattr
;
553 uattr
.overwrite
= ua_sess
->metadata
->attr
.overwrite
;
554 uattr
.subbuf_size
= ua_sess
->metadata
->attr
.subbuf_size
;
555 uattr
.num_subbuf
= ua_sess
->metadata
->attr
.num_subbuf
;
556 uattr
.switch_timer_interval
=
557 ua_sess
->metadata
->attr
.switch_timer_interval
;
558 uattr
.read_timer_interval
=
559 ua_sess
->metadata
->attr
.read_timer_interval
;
560 uattr
.output
= ua_sess
->metadata
->attr
.output
;
562 /* UST tracer metadata creation */
563 ret
= ustctl_open_metadata(app
->key
.sock
, ua_sess
->handle
, &uattr
,
564 &ua_sess
->metadata
->obj
);
566 ERR("UST app open metadata failed for app pid:%d",
571 ua_sess
->metadata
->handle
= ua_sess
->metadata
->obj
->handle
;
578 * Create stream onto the UST tracer for a UST session.
580 static int create_ust_stream(struct ust_app
*app
,
581 struct ust_app_session
*ua_sess
)
585 ret
= ustctl_create_stream(app
->key
.sock
, ua_sess
->metadata
->obj
,
586 &ua_sess
->metadata
->stream_obj
);
588 ERR("UST create metadata stream failed");
597 * Create the specified channel onto the UST tracer for a UST session.
599 static int create_ust_channel(struct ust_app
*app
,
600 struct ust_app_session
*ua_sess
, struct ust_app_channel
*ua_chan
)
604 /* TODO: remove cast and use lttng-ust-abi.h */
605 ret
= ustctl_create_channel(app
->key
.sock
, ua_sess
->handle
,
606 (struct lttng_ust_channel_attr
*)&ua_chan
->attr
, &ua_chan
->obj
);
608 DBG("Error creating channel %s for app (pid: %d, sock: %d) "
609 "and session handle %d with ret %d",
610 ua_chan
->name
, app
->key
.pid
, app
->key
.sock
,
611 ua_sess
->handle
, ret
);
615 ua_chan
->handle
= ua_chan
->obj
->handle
;
616 ua_chan
->attr
.shm_fd
= ua_chan
->obj
->shm_fd
;
617 ua_chan
->attr
.wait_fd
= ua_chan
->obj
->wait_fd
;
618 ua_chan
->attr
.memory_map_size
= ua_chan
->obj
->memory_map_size
;
620 DBG2("UST app channel %s created successfully for pid:%d and sock:%d",
621 ua_chan
->name
, app
->key
.pid
, app
->key
.sock
);
623 /* If channel is not enabled, disable it on the tracer */
624 if (!ua_chan
->enabled
) {
625 ret
= disable_ust_channel(app
, ua_sess
, ua_chan
);
636 * Create the specified event onto the UST tracer for a UST session.
639 int create_ust_event(struct ust_app
*app
, struct ust_app_session
*ua_sess
,
640 struct ust_app_channel
*ua_chan
, struct ust_app_event
*ua_event
)
644 /* Create UST event on tracer */
645 ret
= ustctl_create_event(app
->key
.sock
, &ua_event
->attr
, ua_chan
->obj
,
648 ERR("Error ustctl create event %s for app pid: %d with ret %d",
649 ua_event
->attr
.name
, app
->key
.pid
, ret
);
653 ua_event
->handle
= ua_event
->obj
->handle
;
655 DBG2("UST app event %s created successfully for pid:%d",
656 ua_event
->attr
.name
, app
->key
.pid
);
658 /* If event not enabled, disable it on the tracer */
659 if (!ua_event
->enabled
) {
660 ret
= disable_ust_event(app
, ua_sess
, ua_event
);
671 * Copy data between an UST app event and a LTT event.
673 static void shadow_copy_event(struct ust_app_event
*ua_event
,
674 struct ltt_ust_event
*uevent
)
676 struct cds_lfht_iter iter
;
677 struct ltt_ust_context
*uctx
;
678 struct ust_app_ctx
*ua_ctx
;
680 strncpy(ua_event
->name
, uevent
->attr
.name
, sizeof(ua_event
->name
));
681 ua_event
->name
[sizeof(ua_event
->name
) - 1] = '\0';
683 /* Copy event attributes */
684 memcpy(&ua_event
->attr
, &uevent
->attr
, sizeof(ua_event
->attr
));
686 cds_lfht_for_each_entry(uevent
->ctx
, &iter
, uctx
, node
) {
687 ua_ctx
= alloc_ust_app_ctx(&uctx
->ctx
);
688 if (ua_ctx
== NULL
) {
691 hashtable_node_init(&ua_ctx
->node
,
692 (void *)((unsigned long) ua_ctx
->ctx
.ctx
), sizeof(void *));
693 hashtable_add_unique(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 cds_lfht_iter iter
;
704 struct cds_lfht_node
*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("Shadow copy of UST app channel %s", 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 cds_lfht_for_each_entry(uchan
->ctx
, &iter
, uctx
, node
) {
718 ua_ctx
= alloc_ust_app_ctx(&uctx
->ctx
);
719 if (ua_ctx
== NULL
) {
722 hashtable_node_init(&ua_ctx
->node
,
723 (void *)((unsigned long) ua_ctx
->ctx
.ctx
), sizeof(void *));
724 hashtable_add_unique(ua_chan
->ctx
, &ua_ctx
->node
);
727 /* Copy all events from ltt ust channel to ust app channel */
728 cds_lfht_for_each_entry(uchan
->events
, &iter
, uevent
, node
) {
729 struct cds_lfht_iter uiter
;
731 ua_event_node
= hashtable_lookup(ua_chan
->events
,
732 (void *) uevent
->attr
.name
, strlen(uevent
->attr
.name
),
734 if (ua_event_node
== NULL
) {
735 DBG2("UST event %s not found on shadow copy channel",
737 ua_event
= alloc_ust_app_event(uevent
->attr
.name
, &uevent
->attr
);
738 if (ua_event
== NULL
) {
741 shadow_copy_event(ua_event
, uevent
);
742 hashtable_add_unique(ua_chan
->events
, &ua_event
->node
);
746 DBG3("Shadow copy channel done");
750 * Copy data between a UST app session and a regular LTT session.
752 static void shadow_copy_session(struct ust_app_session
*ua_sess
,
753 struct ltt_ust_session
*usess
,
756 struct cds_lfht_node
*ua_chan_node
;
757 struct cds_lfht_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
,
778 usess
->pathname
, app
->name
, app
->key
.pid
,
781 PERROR("asprintf UST shadow copy session");
782 /* TODO: We cannot return an error from here.. */
786 /* TODO: support all UST domain */
788 /* Iterate over all channels in global domain. */
789 cds_lfht_for_each_entry(usess
->domain_global
.channels
, &iter
,
791 struct cds_lfht_iter uiter
;
793 ua_chan_node
= hashtable_lookup(ua_sess
->channels
,
794 (void *)uchan
->name
, strlen(uchan
->name
),
796 if (ua_chan_node
!= NULL
) {
800 DBG2("Channel %s not found on shadow session copy, creating it",
802 ua_chan
= alloc_ust_app_channel(uchan
->name
, &uchan
->attr
);
803 if (ua_chan
== NULL
) {
804 /* malloc failed... continuing */
808 shadow_copy_channel(ua_chan
, uchan
);
809 hashtable_add_unique(ua_sess
->channels
, &ua_chan
->node
);
814 * Lookup sesison wrapper.
817 void __lookup_session_by_app(struct ltt_ust_session
*usess
,
818 struct ust_app
*app
, struct cds_lfht_iter
*iter
)
820 /* Get right UST app session from app */
821 (void) hashtable_lookup(app
->sessions
,
822 (void *) ((unsigned long) usess
->id
), sizeof(void *),
827 * Return ust app session from the app session hashtable using the UST session
830 static struct ust_app_session
*lookup_session_by_app(
831 struct ltt_ust_session
*usess
, struct ust_app
*app
)
833 struct cds_lfht_iter iter
;
834 struct cds_lfht_node
*node
;
836 __lookup_session_by_app(usess
, app
, &iter
);
837 node
= hashtable_iter_get_node(&iter
);
842 return caa_container_of(node
, struct ust_app_session
, node
);
849 * Create a UST session onto the tracer of app and add it the session
852 * Return ust app session or NULL on error.
854 static struct ust_app_session
*create_ust_app_session(
855 struct ltt_ust_session
*usess
, struct ust_app
*app
)
858 struct ust_app_session
*ua_sess
;
860 ua_sess
= lookup_session_by_app(usess
, app
);
861 if (ua_sess
== NULL
) {
862 DBG2("UST app pid: %d session id %d not found, creating it",
863 app
->key
.pid
, usess
->id
);
864 ua_sess
= alloc_ust_app_session();
865 if (ua_sess
== NULL
) {
866 /* Only malloc can failed so something is really wrong */
869 shadow_copy_session(ua_sess
, usess
, app
);
872 if (ua_sess
->handle
== -1) {
873 ret
= ustctl_create_session(app
->key
.sock
);
875 ERR("Error creating session for app pid %d, sock %d",
876 app
->key
.pid
, app
->key
.sock
);
877 /* TODO: free() ua_sess */
881 DBG2("UST app ustctl create session handle %d", ret
);
882 ua_sess
->handle
= ret
;
884 /* Add ust app session to app's HT */
885 hashtable_node_init(&ua_sess
->node
,
886 (void *)((unsigned long) ua_sess
->id
), sizeof(void *));
887 hashtable_add_unique(app
->sessions
, &ua_sess
->node
);
889 DBG2("UST app session created successfully with handle %d", ret
);
899 * Create a context for the channel on the tracer.
902 int create_ust_app_channel_context(struct ust_app_session
*ua_sess
,
903 struct ust_app_channel
*ua_chan
, struct lttng_ust_context
*uctx
,
907 struct cds_lfht_iter iter
;
908 struct cds_lfht_node
*node
;
909 struct ust_app_ctx
*ua_ctx
;
911 DBG2("UST app adding context to channel %s", ua_chan
->name
);
913 node
= hashtable_lookup(ua_chan
->ctx
, (void *)((unsigned long)uctx
->ctx
),
914 sizeof(void *), &iter
);
920 ua_ctx
= alloc_ust_app_ctx(uctx
);
921 if (ua_ctx
== NULL
) {
927 hashtable_node_init(&ua_ctx
->node
,
928 (void *)((unsigned long) ua_ctx
->ctx
.ctx
), sizeof(void *));
929 hashtable_add_unique(ua_chan
->ctx
, &ua_ctx
->node
);
931 ret
= create_ust_channel_context(ua_chan
, ua_ctx
, app
);
941 * Create an UST context and enable it for the event on the tracer.
944 int create_ust_app_event_context(struct ust_app_session
*ua_sess
,
945 struct ust_app_event
*ua_event
, struct lttng_ust_context
*uctx
,
949 struct cds_lfht_iter iter
;
950 struct cds_lfht_node
*node
;
951 struct ust_app_ctx
*ua_ctx
;
953 DBG2("UST app adding context to event %s", ua_event
->name
);
955 node
= hashtable_lookup(ua_event
->ctx
, (void *)((unsigned long)uctx
->ctx
),
956 sizeof(void *), &iter
);
962 ua_ctx
= alloc_ust_app_ctx(uctx
);
963 if (ua_ctx
== NULL
) {
969 hashtable_node_init(&ua_ctx
->node
,
970 (void *)((unsigned long) ua_ctx
->ctx
.ctx
), sizeof(void *));
971 hashtable_add_unique(ua_event
->ctx
, &ua_ctx
->node
);
973 ret
= create_ust_event_context(ua_event
, ua_ctx
, app
);
983 * Enable on the tracer side a ust app event for the session and channel.
986 int enable_ust_app_event(struct ust_app_session
*ua_sess
,
987 struct ust_app_event
*ua_event
, struct ust_app
*app
)
991 ret
= enable_ust_event(app
, ua_sess
, ua_event
);
996 ua_event
->enabled
= 1;
1003 * Disable on the tracer side a ust app event for the session and channel.
1005 static int disable_ust_app_event(struct ust_app_session
*ua_sess
,
1006 struct ust_app_event
*ua_event
, struct ust_app
*app
)
1010 ret
= disable_ust_event(app
, ua_sess
, ua_event
);
1015 ua_event
->enabled
= 0;
1022 * Lookup ust app channel for session and disable it on the tracer side.
1025 int disable_ust_app_channel(struct ust_app_session
*ua_sess
,
1026 struct ust_app_channel
*ua_chan
, struct ust_app
*app
)
1030 ret
= disable_ust_channel(app
, ua_sess
, ua_chan
);
1035 ua_chan
->enabled
= 0;
1042 * Lookup ust app channel for session and enable it on the tracer side.
1044 static int enable_ust_app_channel(struct ust_app_session
*ua_sess
,
1045 struct ltt_ust_channel
*uchan
, struct ust_app
*app
)
1048 struct cds_lfht_iter iter
;
1049 struct cds_lfht_node
*ua_chan_node
;
1050 struct ust_app_channel
*ua_chan
;
1052 ua_chan_node
= hashtable_lookup(ua_sess
->channels
,
1053 (void *)uchan
->name
, strlen(uchan
->name
), &iter
);
1054 if (ua_chan_node
== NULL
) {
1055 DBG2("Unable to find channel %s in ust session id %u",
1056 uchan
->name
, ua_sess
->id
);
1060 ua_chan
= caa_container_of(ua_chan_node
, struct ust_app_channel
, node
);
1062 ret
= enable_ust_channel(app
, ua_sess
, ua_chan
);
1072 * Create UST app channel and create it on the tracer.
1074 static struct ust_app_channel
*create_ust_app_channel(
1075 struct ust_app_session
*ua_sess
, struct ltt_ust_channel
*uchan
,
1076 struct ust_app
*app
)
1079 struct cds_lfht_iter iter
;
1080 struct cds_lfht_node
*ua_chan_node
;
1081 struct ust_app_channel
*ua_chan
;
1083 /* Lookup channel in the ust app session */
1084 ua_chan_node
= hashtable_lookup(ua_sess
->channels
,
1085 (void *)uchan
->name
, strlen(uchan
->name
), &iter
);
1086 if (ua_chan_node
== NULL
) {
1087 DBG2("Unable to find channel %s in ust session id %u",
1088 uchan
->name
, ua_sess
->id
);
1089 ua_chan
= alloc_ust_app_channel(uchan
->name
, &uchan
->attr
);
1090 if (ua_chan
== NULL
) {
1093 shadow_copy_channel(ua_chan
, uchan
);
1095 hashtable_add_unique(ua_sess
->channels
, &ua_chan
->node
);
1097 ua_chan
= caa_container_of(ua_chan_node
, struct ust_app_channel
, node
);
1100 ret
= create_ust_channel(app
, ua_sess
, ua_chan
);
1112 * Create UST app event and create it on the tracer side.
1115 int create_ust_app_event(struct ust_app_session
*ua_sess
,
1116 struct ust_app_channel
*ua_chan
, struct ltt_ust_event
*uevent
,
1117 struct ust_app
*app
)
1120 struct cds_lfht_iter iter
;
1121 struct cds_lfht_node
*ua_event_node
;
1122 struct ust_app_event
*ua_event
;
1124 /* Get event node */
1125 ua_event_node
= hashtable_lookup(ua_chan
->events
,
1126 (void *)uevent
->attr
.name
, strlen(uevent
->attr
.name
), &iter
);
1127 if (ua_event_node
!= NULL
) {
1128 ERR("UST app event %s already exist. Stopping creation.",
1133 /* Does not exist so create one */
1134 ua_event
= alloc_ust_app_event(uevent
->attr
.name
, &uevent
->attr
);
1135 if (ua_event
== NULL
) {
1136 /* Only malloc can failed so something is really wrong */
1140 shadow_copy_event(ua_event
, uevent
);
1142 /* Create it on the tracer side */
1143 ret
= create_ust_event(app
, ua_sess
, ua_chan
, ua_event
);
1146 delete_ust_app_event(app
->key
.sock
, ua_event
);
1151 ua_event
->enabled
= 1;
1153 hashtable_add_unique(ua_chan
->events
, &ua_event
->node
);
1155 DBG2("UST app create event %s for PID %d completed",
1156 ua_event
->name
, app
->key
.pid
);
1164 * Create UST metadata and open it on the tracer side.
1166 static int create_ust_app_metadata(struct ust_app_session
*ua_sess
,
1167 char *pathname
, struct ust_app
*app
)
1172 if (ua_sess
->metadata
== NULL
) {
1173 /* Allocate UST metadata */
1174 ua_sess
->metadata
= trace_ust_create_metadata(pathname
);
1175 if (ua_sess
->metadata
== NULL
) {
1176 ERR("UST app session %d creating metadata failed",
1181 ret
= open_ust_metadata(app
, ua_sess
);
1186 DBG2("UST metadata opened for app pid %d", app
->key
.pid
);
1189 /* Open UST metadata stream */
1190 if (ua_sess
->metadata
->stream_obj
== NULL
) {
1191 ret
= create_ust_stream(app
, ua_sess
);
1196 old_umask
= umask(0);
1197 ret
= mkdir(ua_sess
->path
, S_IRWXU
| S_IRWXG
);
1199 PERROR("mkdir UST metadata");
1202 ret
= chown(ua_sess
->path
, ua_sess
->uid
, ua_sess
->gid
);
1204 ERR("Unable to change owner of %s", ua_sess
->path
);
1209 ret
= snprintf(ua_sess
->metadata
->pathname
, PATH_MAX
,
1210 "%s/metadata", ua_sess
->path
);
1212 PERROR("asprintf UST create stream");
1216 DBG2("UST metadata stream object created for app pid %d",
1219 ERR("Attempting to create stream without metadata opened");
1230 * Return pointer to traceable apps list.
1232 struct cds_lfht
*ust_app_get_ht(void)
1238 * Return ust app pointer or NULL if not found.
1240 struct ust_app
*ust_app_find_by_pid(pid_t pid
)
1242 struct cds_lfht_node
*node
;
1243 struct cds_lfht_iter iter
;
1246 node
= hashtable_lookup(ust_app_ht
,
1247 (void *)((unsigned long) pid
), sizeof(void *), &iter
);
1249 DBG2("UST app no found with pid %d", pid
);
1254 DBG2("Found UST app by pid %d", pid
);
1256 return caa_container_of(node
, struct ust_app
, node
);
1264 * Using pid and uid (of the app), allocate a new ust_app struct and
1265 * add it to the global traceable app list.
1267 * On success, return 0, else return malloc -ENOMEM, or -EINVAL if app
1268 * bitness is not supported.
1270 int ust_app_register(struct ust_register_msg
*msg
, int sock
)
1272 struct ust_app
*lta
;
1274 if ((msg
->bits_per_long
== 64 && ust_consumerd64_fd
== -EINVAL
)
1275 || (msg
->bits_per_long
== 32 && ust_consumerd32_fd
== -EINVAL
)) {
1276 ERR("Registration failed: application \"%s\" (pid: %d) has "
1277 "%d-bit long, but no consumerd for this long size is available.\n",
1278 msg
->name
, msg
->pid
, msg
->bits_per_long
);
1282 lta
= zmalloc(sizeof(struct ust_app
));
1288 lta
->ppid
= msg
->ppid
;
1289 lta
->uid
= msg
->uid
;
1290 lta
->gid
= msg
->gid
;
1291 lta
->bits_per_long
= msg
->bits_per_long
;
1292 lta
->v_major
= msg
->major
;
1293 lta
->v_minor
= msg
->minor
;
1294 strncpy(lta
->name
, msg
->name
, sizeof(lta
->name
));
1295 lta
->name
[16] = '\0';
1296 lta
->sessions
= hashtable_new(0);
1299 lta
->key
.pid
= msg
->pid
;
1300 hashtable_node_init(<a
->node
, (void *)((unsigned long)lta
->key
.pid
),
1302 lta
->key
.sock
= sock
;
1303 hashtable_node_init(<a
->key
.node
, (void *)((unsigned long)lta
->key
.sock
),
1307 hashtable_add_unique(ust_app_sock_key_map
, <a
->key
.node
);
1308 hashtable_add_unique(ust_app_ht
, <a
->node
);
1311 DBG("App registered with pid:%d ppid:%d uid:%d gid:%d sock:%d name:%s"
1312 " (version %d.%d)", lta
->key
.pid
, lta
->ppid
, lta
->uid
, lta
->gid
,
1313 lta
->key
.sock
, lta
->name
, lta
->v_major
, lta
->v_minor
);
1319 * Unregister app by removing it from the global traceable app list and freeing
1322 * The socket is already closed at this point so no close to sock.
1324 void ust_app_unregister(int sock
)
1326 struct ust_app
*lta
;
1327 struct cds_lfht_node
*node
;
1328 struct cds_lfht_iter iter
;
1332 lta
= find_app_by_sock(sock
);
1334 ERR("Unregister app sock %d not found!", sock
);
1338 DBG("PID %d unregistering with sock %d", lta
->key
.pid
, sock
);
1340 /* Get the node reference for a call_rcu */
1341 node
= hashtable_lookup(ust_app_ht
,
1342 (void *)((unsigned long) lta
->key
.pid
), sizeof(void *), &iter
);
1344 ERR("Unable to find app sock %d by pid %d", sock
, lta
->key
.pid
);
1348 ret
= hashtable_del(ust_app_ht
, &iter
);
1350 call_rcu(&node
->head
, delete_ust_app_rcu
);
1357 * Return traceable_app_count
1359 unsigned long ust_app_list_count(void)
1361 unsigned long count
;
1364 count
= hashtable_get_count(ust_app_ht
);
1371 * Fill events array with all events name of all registered apps.
1373 int ust_app_list_events(struct lttng_event
**events
)
1376 size_t nbmem
, count
= 0;
1377 struct cds_lfht_iter iter
;
1378 struct ust_app
*app
;
1379 struct lttng_event
*tmp
;
1381 nbmem
= UST_APP_EVENT_LIST_SIZE
;
1382 tmp
= zmalloc(nbmem
* sizeof(struct lttng_event
));
1384 PERROR("zmalloc ust app events");
1391 cds_lfht_for_each_entry(ust_app_ht
, &iter
, app
, node
) {
1392 struct lttng_ust_tracepoint_iter uiter
;
1394 handle
= ustctl_tracepoint_list(app
->key
.sock
);
1396 ERR("UST app list events getting handle failed for app pid %d",
1401 while ((ret
= ustctl_tracepoint_list_get(app
->key
.sock
, handle
,
1402 &uiter
)) != -ENOENT
) {
1403 if (count
>= nbmem
) {
1404 DBG2("Reallocating event list from %zu to %zu entries", nbmem
,
1407 tmp
= realloc(tmp
, nbmem
* sizeof(struct lttng_event
));
1409 PERROR("realloc ust app events");
1414 memcpy(tmp
[count
].name
, uiter
.name
, LTTNG_UST_SYM_NAME_LEN
);
1415 memcpy(tmp
[count
].loglevel
, uiter
.loglevel
, LTTNG_UST_SYM_NAME_LEN
);
1416 tmp
[count
].loglevel_value
= uiter
.loglevel_value
;
1417 tmp
[count
].type
= LTTNG_UST_TRACEPOINT
;
1418 tmp
[count
].pid
= app
->key
.pid
;
1419 tmp
[count
].enabled
= -1;
1427 DBG2("UST app list events done (%zu events)", count
);
1436 * Free and clean all traceable apps of the global list.
1438 void ust_app_clean_list(void)
1441 struct cds_lfht_iter iter
;
1442 struct ust_app
*app
;
1444 DBG2("UST app cleaning registered apps hash table");
1448 cds_lfht_for_each_entry(ust_app_ht
, &iter
, app
, node
) {
1449 ret
= hashtable_del(ust_app_ht
, &iter
);
1451 call_rcu(&iter
.node
->head
, delete_ust_app_rcu
);
1454 hashtable_destroy(ust_app_ht
);
1455 hashtable_destroy(ust_app_sock_key_map
);
1461 * Init UST app hash table.
1463 void ust_app_ht_alloc(void)
1465 ust_app_ht
= hashtable_new(0);
1466 ust_app_sock_key_map
= hashtable_new(0);
1470 * For a specific UST session, disable the channel for all registered apps.
1472 int ust_app_disable_channel_glb(struct ltt_ust_session
*usess
,
1473 struct ltt_ust_channel
*uchan
)
1476 struct cds_lfht_iter iter
;
1477 struct cds_lfht_node
*ua_chan_node
;
1478 struct ust_app
*app
;
1479 struct ust_app_session
*ua_sess
;
1480 struct ust_app_channel
*ua_chan
;
1482 if (usess
== NULL
|| uchan
== NULL
) {
1483 ERR("Disabling UST global channel with NULL values");
1488 DBG2("UST app disabling channel %s from global domain for session id %d",
1489 uchan
->name
, usess
->id
);
1493 /* For every registered applications */
1494 cds_lfht_for_each_entry(ust_app_ht
, &iter
, app
, node
) {
1495 struct cds_lfht_iter uiter
;
1497 ua_sess
= lookup_session_by_app(usess
, app
);
1498 if (ua_sess
== NULL
) {
1503 ua_chan_node
= hashtable_lookup(ua_sess
->channels
,
1504 (void *)uchan
->name
, strlen(uchan
->name
), &uiter
);
1505 /* If the session if found for the app, the channel must be there */
1506 assert(ua_chan_node
);
1508 ua_chan
= caa_container_of(ua_chan_node
, struct ust_app_channel
, node
);
1509 /* The channel must not be already disabled */
1510 assert(ua_chan
->enabled
== 1);
1512 /* Disable channel onto application */
1513 ret
= disable_ust_app_channel(ua_sess
, ua_chan
, app
);
1515 /* XXX: We might want to report this error at some point... */
1527 * For a specific UST session, enable the channel for all registered apps.
1529 int ust_app_enable_channel_glb(struct ltt_ust_session
*usess
,
1530 struct ltt_ust_channel
*uchan
)
1533 struct cds_lfht_iter iter
;
1534 struct ust_app
*app
;
1535 struct ust_app_session
*ua_sess
;
1537 if (usess
== NULL
|| uchan
== NULL
) {
1538 ERR("Adding UST global channel to NULL values");
1543 DBG2("UST app enabling channel %s to global domain for session id %d",
1544 uchan
->name
, usess
->id
);
1548 /* For every registered applications */
1549 cds_lfht_for_each_entry(ust_app_ht
, &iter
, app
, node
) {
1550 ua_sess
= lookup_session_by_app(usess
, app
);
1551 if (ua_sess
== NULL
) {
1555 /* Enable channel onto application */
1556 ret
= enable_ust_app_channel(ua_sess
, uchan
, app
);
1558 /* XXX: We might want to report this error at some point... */
1570 * Disable an event in a channel and for a specific session.
1572 int ust_app_disable_event_glb(struct ltt_ust_session
*usess
,
1573 struct ltt_ust_channel
*uchan
, struct ltt_ust_event
*uevent
)
1576 struct cds_lfht_iter iter
;
1577 struct cds_lfht_node
*ua_chan_node
, *ua_event_node
;
1578 struct ust_app
*app
;
1579 struct ust_app_session
*ua_sess
;
1580 struct ust_app_channel
*ua_chan
;
1581 struct ust_app_event
*ua_event
;
1583 DBG("UST app disabling event %s for all apps in channel "
1584 "%s for session id %d", uevent
->attr
.name
, uchan
->name
, usess
->id
);
1588 /* For all registered applications */
1589 cds_lfht_for_each_entry(ust_app_ht
, &iter
, app
, node
) {
1590 struct cds_lfht_iter uiter
;
1592 ua_sess
= lookup_session_by_app(usess
, app
);
1593 if (ua_sess
== NULL
) {
1598 /* Lookup channel in the ust app session */
1599 ua_chan_node
= hashtable_lookup(ua_sess
->channels
,
1600 (void *)uchan
->name
, strlen(uchan
->name
), &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 ua_event_node
= hashtable_lookup(ua_chan
->events
,
1609 (void *)uevent
->attr
.name
, strlen(uevent
->attr
.name
), &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 cds_lfht_iter iter
;
1638 struct cds_lfht_node
*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
, &iter
, app
, node
) {
1651 struct cds_lfht_iter uiter
;
1653 ua_sess
= lookup_session_by_app(usess
, app
);
1654 /* If ua_sess is NULL, there is a code flow error */
1657 /* Lookup channel in the ust app session */
1658 ua_chan_node
= hashtable_lookup(ua_sess
->channels
, (void *)uchan
->name
,
1659 strlen(uchan
->name
), &uiter
);
1660 /* If the channel is not found, there is a code flow error */
1661 assert(ua_chan_node
);
1663 ua_chan
= caa_container_of(ua_chan_node
, struct ust_app_channel
, node
);
1665 /* Disable each events of channel */
1666 cds_lfht_for_each_entry(ua_chan
->events
, &uiter
, ua_event
, node
) {
1667 ret
= disable_ust_app_event(ua_sess
, ua_event
, app
);
1669 /* XXX: Report error someday... */
1681 * For a specific UST session, create the channel for all registered apps.
1683 int ust_app_create_channel_glb(struct ltt_ust_session
*usess
,
1684 struct ltt_ust_channel
*uchan
)
1687 struct cds_lfht_iter iter
;
1688 struct ust_app
*app
;
1689 struct ust_app_session
*ua_sess
;
1690 struct ust_app_channel
*ua_chan
;
1692 if (usess
== NULL
|| uchan
== NULL
) {
1693 ERR("Adding UST global channel to NULL values");
1698 DBG2("UST app adding channel %s to global domain for session id %d",
1699 uchan
->name
, usess
->id
);
1703 /* For every registered applications */
1704 cds_lfht_for_each_entry(ust_app_ht
, &iter
, app
, node
) {
1706 * Create session on the tracer side and add it to app session HT. Note
1707 * that if session exist, it will simply return a pointer to the ust
1710 ua_sess
= create_ust_app_session(usess
, app
);
1711 if (ua_sess
== NULL
) {
1715 /* Create channel onto application */
1716 ua_chan
= create_ust_app_channel(ua_sess
, uchan
, app
);
1717 if (ua_chan
== NULL
) {
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 cds_lfht_iter iter
;
1736 struct cds_lfht_node
*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
, &iter
, app
, node
) {
1755 struct cds_lfht_iter uiter
;
1757 ua_sess
= lookup_session_by_app(usess
, app
);
1758 /* If ua_sess is NULL, there is a code flow error */
1761 /* Lookup channel in the ust app session */
1762 ua_chan_node
= hashtable_lookup(ua_sess
->channels
, (void *)uchan
->name
,
1763 strlen(uchan
->name
), &uiter
);
1764 /* If the channel is not found, there is a code flow error */
1765 assert(ua_chan_node
);
1767 ua_chan
= caa_container_of(ua_chan_node
, struct ust_app_channel
, node
);
1769 ua_event_node
= hashtable_lookup(ua_chan
->events
,
1770 (void*)uevent
->attr
.name
, strlen(uevent
->attr
.name
), &uiter
);
1771 if (ua_event_node
== NULL
) {
1772 DBG3("UST app enable event %s not found for app PID %d."
1773 "Skipping app", uevent
->attr
.name
, app
->key
.pid
);
1776 ua_event
= caa_container_of(ua_event_node
, struct ust_app_event
, node
);
1778 ret
= enable_ust_app_event(ua_sess
, ua_event
, app
);
1790 * For a specific existing UST session and UST channel, creates the event for
1791 * all registered apps.
1793 int ust_app_create_event_glb(struct ltt_ust_session
*usess
,
1794 struct ltt_ust_channel
*uchan
, struct ltt_ust_event
*uevent
)
1797 struct cds_lfht_iter iter
;
1798 struct cds_lfht_node
*ua_chan_node
;
1799 struct ust_app
*app
;
1800 struct ust_app_session
*ua_sess
;
1801 struct ust_app_channel
*ua_chan
;
1803 DBG("UST app creating event %s for all apps for session id %d",
1804 uevent
->attr
.name
, usess
->id
);
1807 * NOTE: At this point, this function is called only if the session and
1808 * channel passed are already created for all apps. and enabled on the
1814 /* For all registered applications */
1815 cds_lfht_for_each_entry(ust_app_ht
, &iter
, app
, node
) {
1816 struct cds_lfht_iter uiter
;
1818 ua_sess
= lookup_session_by_app(usess
, app
);
1819 /* If ua_sess is NULL, there is a code flow error */
1822 /* Lookup channel in the ust app session */
1823 ua_chan_node
= hashtable_lookup(ua_sess
->channels
, (void *)uchan
->name
,
1824 strlen(uchan
->name
), &uiter
);
1825 /* If the channel is not found, there is a code flow error */
1826 assert(ua_chan_node
);
1828 ua_chan
= caa_container_of(ua_chan_node
, struct ust_app_channel
, node
);
1830 ret
= create_ust_app_event(ua_sess
, ua_chan
, uevent
, app
);
1842 * Start tracing for a specific UST session and app.
1844 int ust_app_start_trace(struct ltt_ust_session
*usess
, struct ust_app
*app
)
1847 struct cds_lfht_iter iter
;
1848 struct ust_app_session
*ua_sess
;
1849 struct ust_app_channel
*ua_chan
;
1850 struct ltt_ust_stream
*ustream
;
1853 DBG("Starting tracing for ust app pid %d", app
->key
.pid
);
1857 ua_sess
= lookup_session_by_app(usess
, app
);
1858 if (ua_sess
== NULL
) {
1859 goto error_rcu_unlock
;
1862 /* Upon restart, we skip the setup, already done */
1863 if (ua_sess
->started
) {
1867 ret
= create_ust_app_metadata(ua_sess
, usess
->pathname
, app
);
1869 goto error_rcu_unlock
;
1872 /* For each channel */
1873 cds_lfht_for_each_entry(ua_sess
->channels
, &iter
, ua_chan
, node
) {
1874 /* Create all streams */
1876 /* Create UST stream */
1877 ustream
= zmalloc(sizeof(*ustream
));
1878 if (ustream
== NULL
) {
1879 PERROR("zmalloc ust stream");
1880 goto error_rcu_unlock
;
1883 ret
= ustctl_create_stream(app
->key
.sock
, ua_chan
->obj
,
1886 /* Got all streams */
1889 ustream
->handle
= ustream
->obj
->handle
;
1891 /* Order is important */
1892 cds_list_add_tail(&ustream
->list
, &ua_chan
->streams
.head
);
1893 ret
= snprintf(ustream
->pathname
, PATH_MAX
, "%s/%s_%u",
1894 ua_sess
->path
, ua_chan
->name
,
1895 ua_chan
->streams
.count
++);
1897 PERROR("asprintf UST create stream");
1900 DBG2("UST stream %d ready at %s", ua_chan
->streams
.count
,
1905 switch (app
->bits_per_long
) {
1907 consumerd_fd
= ust_consumerd64_fd
;
1910 consumerd_fd
= ust_consumerd32_fd
;
1914 goto error_rcu_unlock
;
1917 /* Setup UST consumer socket and send fds to it */
1918 ret
= ust_consumer_send_session(consumerd_fd
, ua_sess
);
1920 goto error_rcu_unlock
;
1922 ua_sess
->started
= 1;
1925 /* This start the UST tracing */
1926 ret
= ustctl_start_session(app
->key
.sock
, ua_sess
->handle
);
1928 ERR("Error starting tracing for app pid: %d", app
->key
.pid
);
1929 goto error_rcu_unlock
;
1934 /* Quiescent wait after starting trace */
1935 ustctl_wait_quiescent(app
->key
.sock
);
1945 * Stop tracing for a specific UST session and app.
1947 int ust_app_stop_trace(struct ltt_ust_session
*usess
, struct ust_app
*app
)
1950 struct cds_lfht_iter iter
;
1951 struct ust_app_session
*ua_sess
;
1952 struct ust_app_channel
*ua_chan
;
1954 DBG("Stopping tracing for ust app pid %d", app
->key
.pid
);
1958 ua_sess
= lookup_session_by_app(usess
, app
);
1959 if (ua_sess
== NULL
) {
1960 /* Only malloc can failed so something is really wrong */
1961 goto error_rcu_unlock
;
1964 /* This inhibits UST tracing */
1965 ret
= ustctl_stop_session(app
->key
.sock
, ua_sess
->handle
);
1967 ERR("Error stopping tracing for app pid: %d", app
->key
.pid
);
1968 goto error_rcu_unlock
;
1971 /* Quiescent wait after stopping trace */
1972 ustctl_wait_quiescent(app
->key
.sock
);
1974 /* Flushing buffers */
1975 cds_lfht_for_each_entry(ua_sess
->channels
, &iter
, ua_chan
, node
) {
1976 ret
= ustctl_sock_flush_buffer(app
->key
.sock
, ua_chan
->obj
);
1978 ERR("UST app PID %d channel %s flush failed",
1979 app
->key
.pid
, ua_chan
->name
);
1980 ERR("Ended with ret %d", ret
);
1981 /* Continuing flushing all buffers */
1986 /* Flush all buffers before stopping */
1987 ret
= ustctl_sock_flush_buffer(app
->key
.sock
, ua_sess
->metadata
->obj
);
1989 ERR("UST app PID %d metadata flush failed", app
->key
.pid
);
1990 ERR("Ended with ret %d", ret
);
2003 * Destroy a specific UST session in apps.
2005 int ust_app_destroy_trace(struct ltt_ust_session
*usess
, struct ust_app
*app
)
2007 struct ust_app_session
*ua_sess
;
2008 struct lttng_ust_object_data obj
;
2009 struct cds_lfht_iter iter
;
2010 struct cds_lfht_node
*node
;
2013 DBG("Destroy tracing for ust app pid %d", app
->key
.pid
);
2017 __lookup_session_by_app(usess
, app
, &iter
);
2018 node
= hashtable_iter_get_node(&iter
);
2020 /* Only malloc can failed so something is really wrong */
2021 goto error_rcu_unlock
;
2023 ua_sess
= caa_container_of(node
, struct ust_app_session
, node
);
2024 ret
= hashtable_del(app
->sessions
, &iter
);
2026 delete_ust_app_session(app
->key
.sock
, ua_sess
);
2027 obj
.handle
= ua_sess
->handle
;
2030 obj
.memory_map_size
= 0;
2031 ustctl_release_object(app
->key
.sock
, &obj
);
2035 /* Quiescent wait after stopping trace */
2036 ustctl_wait_quiescent(app
->key
.sock
);
2046 * Start tracing for the UST session.
2048 int ust_app_start_trace_all(struct ltt_ust_session
*usess
)
2051 struct cds_lfht_iter iter
;
2052 struct ust_app
*app
;
2054 DBG("Starting all UST traces");
2058 cds_lfht_for_each_entry(ust_app_ht
, &iter
, app
, node
) {
2059 ret
= ust_app_start_trace(usess
, app
);
2061 /* Continue to next apps even on error */
2072 * Start tracing for the UST session.
2074 int ust_app_stop_trace_all(struct ltt_ust_session
*usess
)
2077 struct cds_lfht_iter iter
;
2078 struct ust_app
*app
;
2080 DBG("Stopping all UST traces");
2084 cds_lfht_for_each_entry(ust_app_ht
, &iter
, app
, node
) {
2085 ret
= ust_app_stop_trace(usess
, app
);
2087 /* Continue to next apps even on error */
2098 * Destroy app UST session.
2100 int ust_app_destroy_trace_all(struct ltt_ust_session
*usess
)
2103 struct cds_lfht_iter iter
;
2104 struct ust_app
*app
;
2106 DBG("Destroy all UST traces");
2110 cds_lfht_for_each_entry(ust_app_ht
, &iter
, app
, node
) {
2111 ret
= ust_app_destroy_trace(usess
, app
);
2113 /* Continue to next apps even on error */
2124 * Add channels/events from UST global domain to registered apps at sock.
2126 void ust_app_global_update(struct ltt_ust_session
*usess
, int sock
)
2129 struct cds_lfht_iter iter
;
2130 struct ust_app
*app
;
2131 struct ust_app_session
*ua_sess
;
2132 struct ust_app_channel
*ua_chan
;
2133 struct ust_app_event
*ua_event
;
2135 if (usess
== NULL
) {
2136 ERR("No UST session on global update. Returning");
2140 DBG2("UST app global update for app sock %d for session id %d", sock
,
2145 app
= find_app_by_sock(sock
);
2147 ERR("Failed to update app sock %d", sock
);
2151 ua_sess
= create_ust_app_session(usess
, app
);
2152 if (ua_sess
== NULL
) {
2157 * We can iterate safely here over all UST app session sicne the create ust
2158 * app session above made a shadow copy of the UST global domain from the
2161 cds_lfht_for_each_entry(ua_sess
->channels
, &iter
, ua_chan
, node
) {
2162 struct cds_lfht_iter uiter
;
2164 ret
= create_ust_channel(app
, ua_sess
, ua_chan
);
2166 /* FIXME: Should we quit here or continue... */
2170 /* For each events */
2171 cds_lfht_for_each_entry(ua_chan
->events
, &uiter
, ua_event
, node
) {
2172 ret
= create_ust_event(app
, ua_sess
, ua_chan
, ua_event
);
2174 /* FIXME: Should we quit here or continue... */
2180 if (usess
->start_trace
) {
2181 ret
= ust_app_start_trace(usess
, app
);
2186 DBG2("UST trace started for app pid %d", app
->key
.pid
);
2195 * Add context to a specific channel for global UST domain.
2197 int ust_app_add_ctx_channel_glb(struct ltt_ust_session
*usess
,
2198 struct ltt_ust_channel
*uchan
, struct ltt_ust_context
*uctx
)
2201 struct cds_lfht_node
*ua_chan_node
;
2202 struct cds_lfht_iter iter
;
2203 struct ust_app_channel
*ua_chan
= NULL
;
2204 struct ust_app_session
*ua_sess
;
2205 struct ust_app
*app
;
2209 cds_lfht_for_each_entry(ust_app_ht
, &iter
, app
, node
) {
2210 struct cds_lfht_iter uiter
;
2212 ua_sess
= lookup_session_by_app(usess
, app
);
2213 if (ua_sess
== NULL
) {
2217 /* Lookup channel in the ust app session */
2218 ua_chan_node
= hashtable_lookup(ua_sess
->channels
,
2219 (void *)uchan
->name
, strlen(uchan
->name
), &uiter
);
2220 if (ua_chan_node
== NULL
) {
2223 ua_chan
= caa_container_of(ua_chan_node
, struct ust_app_channel
,
2226 ret
= create_ust_app_channel_context(ua_sess
, ua_chan
, &uctx
->ctx
, app
);
2237 * Add context to a specific event in a channel for global UST domain.
2239 int ust_app_add_ctx_event_glb(struct ltt_ust_session
*usess
,
2240 struct ltt_ust_channel
*uchan
, struct ltt_ust_event
*uevent
,
2241 struct ltt_ust_context
*uctx
)
2244 struct cds_lfht_node
*ua_chan_node
, *ua_event_node
;
2245 struct cds_lfht_iter iter
;
2246 struct ust_app_session
*ua_sess
;
2247 struct ust_app_event
*ua_event
;
2248 struct ust_app_channel
*ua_chan
= NULL
;
2249 struct ust_app
*app
;
2253 cds_lfht_for_each_entry(ust_app_ht
, &iter
, app
, node
) {
2254 struct cds_lfht_iter uiter
;
2256 ua_sess
= lookup_session_by_app(usess
, app
);
2257 if (ua_sess
== NULL
) {
2261 /* Lookup channel in the ust app session */
2262 ua_chan_node
= hashtable_lookup(ua_sess
->channels
,
2263 (void *)uchan
->name
, strlen(uchan
->name
), &uiter
);
2264 if (ua_chan_node
== NULL
) {
2267 ua_chan
= caa_container_of(ua_chan_node
, struct ust_app_channel
,
2270 ua_event_node
= hashtable_lookup(ua_chan
->events
,
2271 (void *)uevent
->attr
.name
, strlen(uevent
->attr
.name
), &uiter
);
2272 if (ua_event_node
== NULL
) {
2275 ua_event
= caa_container_of(ua_event_node
, struct ust_app_event
,
2278 ret
= create_ust_app_event_context(ua_sess
, ua_event
, &uctx
->ctx
, app
);
2289 * Enable event for a channel from a UST session for a specific PID.
2291 int ust_app_enable_event_pid(struct ltt_ust_session
*usess
,
2292 struct ltt_ust_channel
*uchan
, struct ltt_ust_event
*uevent
, pid_t pid
)
2295 struct cds_lfht_iter iter
;
2296 struct cds_lfht_node
*ua_chan_node
, *ua_event_node
;
2297 struct ust_app
*app
;
2298 struct ust_app_session
*ua_sess
;
2299 struct ust_app_channel
*ua_chan
;
2300 struct ust_app_event
*ua_event
;
2302 DBG("UST app enabling event %s for PID %d", uevent
->attr
.name
, pid
);
2306 app
= ust_app_find_by_pid(pid
);
2308 ERR("UST app enable event per PID %d not found", pid
);
2313 ua_sess
= lookup_session_by_app(usess
, app
);
2314 /* If ua_sess is NULL, there is a code flow error */
2317 /* Lookup channel in the ust app session */
2318 ua_chan_node
= hashtable_lookup(ua_sess
->channels
, (void *)uchan
->name
,
2319 strlen(uchan
->name
), &iter
);
2320 /* If the channel is not found, there is a code flow error */
2321 assert(ua_chan_node
);
2323 ua_chan
= caa_container_of(ua_chan_node
, struct ust_app_channel
, node
);
2325 ua_event_node
= hashtable_lookup(ua_chan
->events
,
2326 (void*)uevent
->attr
.name
, strlen(uevent
->attr
.name
), &iter
);
2327 if (ua_event_node
== NULL
) {
2328 ret
= create_ust_app_event(ua_sess
, ua_chan
, uevent
, app
);
2333 ua_event
= caa_container_of(ua_event_node
, struct ust_app_event
, node
);
2335 ret
= enable_ust_app_event(ua_sess
, ua_event
, app
);
2347 * Disable event for a channel from a UST session for a specific PID.
2349 int ust_app_disable_event_pid(struct ltt_ust_session
*usess
,
2350 struct ltt_ust_channel
*uchan
, struct ltt_ust_event
*uevent
, pid_t pid
)
2353 struct cds_lfht_iter iter
;
2354 struct cds_lfht_node
*ua_chan_node
, *ua_event_node
;
2355 struct ust_app
*app
;
2356 struct ust_app_session
*ua_sess
;
2357 struct ust_app_channel
*ua_chan
;
2358 struct ust_app_event
*ua_event
;
2360 DBG("UST app disabling event %s for PID %d", uevent
->attr
.name
, pid
);
2364 app
= ust_app_find_by_pid(pid
);
2366 ERR("UST app disable event per PID %d not found", pid
);
2371 ua_sess
= lookup_session_by_app(usess
, app
);
2372 /* If ua_sess is NULL, there is a code flow error */
2375 /* Lookup channel in the ust app session */
2376 ua_chan_node
= hashtable_lookup(ua_sess
->channels
, (void *)uchan
->name
,
2377 strlen(uchan
->name
), &iter
);
2378 if (ua_chan_node
== NULL
) {
2379 /* Channel does not exist, skip disabling */
2382 ua_chan
= caa_container_of(ua_chan_node
, struct ust_app_channel
, node
);
2384 ua_event_node
= hashtable_lookup(ua_chan
->events
,
2385 (void*)uevent
->attr
.name
, strlen(uevent
->attr
.name
), &iter
);
2386 if (ua_event_node
== NULL
) {
2387 /* Event does not exist, skip disabling */
2390 ua_event
= caa_container_of(ua_event_node
, struct ust_app_event
, node
);
2392 ret
= disable_ust_app_event(ua_sess
, ua_event
, app
);