1 /* Copyright (C) 2009 Pierre-Marc Fournier
3 * This library is free software; you can redistribute it and/or
4 * modify it under the terms of the GNU Lesser General Public
5 * License as published by the Free Software Foundation; either
6 * version 2.1 of the License, or (at your option) any later version.
8 * This library is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 * Lesser General Public License for more details.
13 * You should have received a copy of the GNU Lesser General Public
14 * License along with this library; if not, write to the Free Software
15 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22 #include <sys/types.h>
23 #include <sys/socket.h>
32 #include <ust/marker.h>
33 #include <ust/tracectl.h>
38 #include "marker-control.h"
42 #define USTSIGNAL SIGIO
44 #define MAX_MSG_SIZE (100)
46 #define MSG_REGISTER_NOTIF 2
48 char consumer_stack
[10000];
50 /* This should only be accessed by the constructor, before the creation
51 * of the listener, and then only by the listener.
55 struct list_head blocked_consumers
= LIST_HEAD_INIT(blocked_consumers
);
57 static struct ustcomm_app ustcomm_app
;
59 struct tracecmd
{ /* no padding */
64 /* volatile because shared between the listener and the main thread */
65 volatile sig_atomic_t buffers_to_export
= 0;
68 /* size: the size of all the fields except size itself */
71 /* Only the necessary part of the payload is transferred. It
72 * may even be none of it.
77 struct consumer_channel
{
79 struct ltt_channel_struct
*chan
;
82 struct blocked_consumer
{
87 /* args to ustcomm_send_reply */
88 struct ustcomm_server server
;
89 struct ustcomm_source src
;
91 /* args to ust_buffers_get_subbuf */
92 struct ust_buffer
*buf
;
94 struct list_head list
;
97 static long long make_pidunique(void)
102 gettimeofday(&tv
, NULL
);
106 retval
|= tv
.tv_usec
;
111 static void print_markers(FILE *fp
)
113 struct marker_iter iter
;
116 marker_iter_reset(&iter
);
117 marker_iter_start(&iter
);
120 fprintf(fp
, "marker: %s/%s %d \"%s\" %p\n", iter
.marker
->channel
, iter
.marker
->name
, (int)imv_read(iter
.marker
->state
), iter
.marker
->format
, iter
.marker
->location
);
121 marker_iter_next(&iter
);
126 static int init_socket(void);
128 /* This needs to be called whenever a new thread is created. It notifies
129 * liburcu of the new thread.
132 void ust_register_thread(void)
134 rcu_register_thread();
141 struct trctl_msg msg
;
143 /* FIXME: fd_notif should probably be protected by a spinlock */
148 msg
.type
= MSG_NOTIF
;
149 msg
.size
= sizeof(msg
.type
);
151 /* FIXME: don't block here */
152 result
= write(fd_notif
, &msg
, msg
.size
+sizeof(msg
.size
));
159 /* Ask the daemon to collect a trace called trace_name and being
160 * produced by this pid.
162 * The trace must be at least allocated. (It can also be started.)
163 * This is because _ltt_trace_find is used.
166 static void inform_consumer_daemon(const char *trace_name
)
169 struct ust_trace
*trace
;
170 pid_t pid
= getpid();
175 trace
= _ltt_trace_find(trace_name
);
177 WARN("inform_consumer_daemon: could not find trace \"%s\"; it is probably already destroyed", trace_name
);
181 for(i
=0; i
< trace
->nr_channels
; i
++) {
182 /* iterate on all cpus */
183 for(j
=0; j
<trace
->channels
[i
].n_cpus
; j
++) {
185 asprintf(&buf
, "%s_%d", trace
->channels
[i
].channel_name
, j
);
186 result
= ustcomm_request_consumer(pid
, buf
);
188 WARN("Failed to request collection for channel %s. Is the daemon available?", trace
->channels
[i
].channel_name
);
189 /* continue even if fail */
200 void process_blocked_consumers(void)
204 struct blocked_consumer
*bc
;
209 list_for_each_entry(bc
, &blocked_consumers
, list
) {
213 fds
= (struct pollfd
*) malloc(n_fds
* sizeof(struct pollfd
));
215 ERR("malloc returned NULL");
219 list_for_each_entry(bc
, &blocked_consumers
, list
) {
220 fds
[idx
].fd
= bc
->fd_producer
;
221 fds
[idx
].events
= POLLIN
;
222 bc
->tmp_poll_idx
= idx
;
226 while((result
= poll(fds
, n_fds
, 0)) == -1 && errno
== EINTR
)
233 list_for_each_entry(bc
, &blocked_consumers
, list
) {
234 if(fds
[bc
->tmp_poll_idx
].revents
) {
235 long consumed_old
= 0;
238 result
= read(bc
->fd_producer
, &inbuf
, 1);
246 close(bc
->fd_producer
);
250 result
= ustcomm_send_reply(&bc
->server
, "END", &bc
->src
);
252 ERR("ustcomm_send_reply failed");
259 result
= ust_buffers_get_subbuf(bc
->buf
, &consumed_old
);
260 if(result
== -EAGAIN
) {
261 WARN("missed buffer?");
264 else if(result
< 0) {
265 DBG("ust_buffers_get_subbuf: error: %s", strerror(-result
));
267 asprintf(&reply
, "%s %ld", "OK", consumed_old
);
268 result
= ustcomm_send_reply(&bc
->server
, reply
, &bc
->src
);
270 ERR("ustcomm_send_reply failed");
282 void seperate_channel_cpu(const char *channel_and_cpu
, char **channel
, int *cpu
)
286 sep
= rindex(channel_and_cpu
, '_');
289 sep
= channel_and_cpu
+ strlen(channel_and_cpu
);
295 asprintf(channel
, "%.*s", (int)(sep
-channel_and_cpu
), channel_and_cpu
);
298 static int do_cmd_get_shmid(const char *recvbuf
, struct ustcomm_source
*src
)
301 struct ust_trace
*trace
;
302 char trace_name
[] = "auto";
304 char *channel_and_cpu
;
312 channel_and_cpu
= nth_token(recvbuf
, 1);
313 if(channel_and_cpu
== NULL
) {
314 ERR("get_shmid: cannot parse channel");
318 seperate_channel_cpu(channel_and_cpu
, &ch_name
, &ch_cpu
);
320 ERR("Problem parsing channel name");
321 goto free_short_chan_name
;
325 trace
= _ltt_trace_find(trace_name
);
329 ERR("cannot find trace!");
331 goto free_short_chan_name
;
334 for(i
=0; i
<trace
->nr_channels
; i
++) {
335 struct ust_channel
*channel
= &trace
->channels
[i
];
336 struct ust_buffer
*buf
= channel
->buf
[ch_cpu
];
338 if(!strcmp(trace
->channels
[i
].channel_name
, ch_name
)) {
341 // DBG("the shmid for the requested channel is %d", buf->shmid);
342 // DBG("the shmid for its buffer structure is %d", channel->buf_struct_shmids);
343 asprintf(&reply
, "%d %d", buf
->shmid
, channel
->buf_struct_shmids
[ch_cpu
]);
345 result
= ustcomm_send_reply(&ustcomm_app
.server
, reply
, src
);
347 ERR("listener: get_shmid: ustcomm_send_reply failed");
350 goto free_short_chan_name
;
364 ERR("get_shmid: channel not found (%s)", channel_and_cpu
);
367 free_short_chan_name
:
374 static int do_cmd_get_n_subbufs(const char *recvbuf
, struct ustcomm_source
*src
)
377 struct ust_trace
*trace
;
378 char trace_name
[] = "auto";
380 char *channel_and_cpu
;
386 DBG("get_n_subbufs");
388 channel_and_cpu
= nth_token(recvbuf
, 1);
389 if(channel_and_cpu
== NULL
) {
390 ERR("get_n_subbufs: cannot parse channel");
394 seperate_channel_cpu(channel_and_cpu
, &ch_name
, &ch_cpu
);
396 ERR("Problem parsing channel name");
397 goto free_short_chan_name
;
401 trace
= _ltt_trace_find(trace_name
);
405 ERR("cannot find trace!");
407 goto free_short_chan_name
;
410 for(i
=0; i
<trace
->nr_channels
; i
++) {
411 struct ust_channel
*channel
= &trace
->channels
[i
];
413 if(!strcmp(trace
->channels
[i
].channel_name
, ch_name
)) {
416 DBG("the n_subbufs for the requested channel is %d", channel
->subbuf_cnt
);
417 asprintf(&reply
, "%d", channel
->subbuf_cnt
);
419 result
= ustcomm_send_reply(&ustcomm_app
.server
, reply
, src
);
421 ERR("listener: get_n_subbufs: ustcomm_send_reply failed");
424 goto free_short_chan_name
;
433 ERR("get_n_subbufs: unable to find channel");
436 free_short_chan_name
:
443 static int do_cmd_get_subbuf_size(const char *recvbuf
, struct ustcomm_source
*src
)
446 struct ust_trace
*trace
;
447 char trace_name
[] = "auto";
449 char *channel_and_cpu
;
455 DBG("get_subbuf_size");
457 channel_and_cpu
= nth_token(recvbuf
, 1);
458 if(channel_and_cpu
== NULL
) {
459 ERR("get_subbuf_size: cannot parse channel");
463 seperate_channel_cpu(channel_and_cpu
, &ch_name
, &ch_cpu
);
465 ERR("Problem parsing channel name");
466 goto free_short_chan_name
;
470 trace
= _ltt_trace_find(trace_name
);
474 ERR("cannot find trace!");
476 goto free_short_chan_name
;
479 for(i
=0; i
<trace
->nr_channels
; i
++) {
480 struct ust_channel
*channel
= &trace
->channels
[i
];
482 if(!strcmp(trace
->channels
[i
].channel_name
, ch_name
)) {
485 DBG("the subbuf_size for the requested channel is %zd", channel
->subbuf_size
);
486 asprintf(&reply
, "%zd", channel
->subbuf_size
);
488 result
= ustcomm_send_reply(&ustcomm_app
.server
, reply
, src
);
490 ERR("listener: get_subbuf_size: ustcomm_send_reply failed");
493 goto free_short_chan_name
;
502 ERR("get_subbuf_size: unable to find channel");
505 free_short_chan_name
:
512 static int do_cmd_get_subbuffer(const char *recvbuf
, struct ustcomm_source
*src
)
515 struct ust_trace
*trace
;
516 char trace_name
[] = "auto";
518 char *channel_and_cpu
;
525 channel_and_cpu
= nth_token(recvbuf
, 1);
526 if(channel_and_cpu
== NULL
) {
527 ERR("get_subbuf: cannot parse channel");
531 seperate_channel_cpu(channel_and_cpu
, &ch_name
, &ch_cpu
);
533 ERR("Problem parsing channel name");
534 goto free_short_chan_name
;
538 trace
= _ltt_trace_find(trace_name
);
545 WARN("Cannot find trace. It was likely destroyed by the user.");
546 asprintf(&reply
, "%s", "NOTFOUND");
547 result
= ustcomm_send_reply(&ustcomm_app
.server
, reply
, src
);
549 ERR("ustcomm_send_reply failed");
552 goto free_short_chan_name
;
556 goto free_short_chan_name
;
559 for(i
=0; i
<trace
->nr_channels
; i
++) {
560 struct ust_channel
*channel
= &trace
->channels
[i
];
562 if(!strcmp(trace
->channels
[i
].channel_name
, ch_name
)) {
563 struct ust_buffer
*buf
= channel
->buf
[ch_cpu
];
564 struct blocked_consumer
*bc
;
568 bc
= (struct blocked_consumer
*) malloc(sizeof(struct blocked_consumer
));
570 ERR("malloc returned NULL");
571 goto free_short_chan_name
;
573 bc
->fd_consumer
= src
->fd
;
574 bc
->fd_producer
= buf
->data_ready_fd_read
;
577 bc
->server
= ustcomm_app
.server
;
579 list_add(&bc
->list
, &blocked_consumers
);
585 ERR("get_subbuf: unable to find channel");
588 free_short_chan_name
:
595 static int do_cmd_put_subbuffer(const char *recvbuf
, struct ustcomm_source
*src
)
598 struct ust_trace
*trace
;
599 char trace_name
[] = "auto";
601 char *channel_and_cpu
;
607 char *consumed_old_str
;
613 channel_and_cpu
= strdup_malloc(nth_token(recvbuf
, 1));
614 if(channel_and_cpu
== NULL
) {
615 ERR("put_subbuf_size: cannot parse channel");
620 consumed_old_str
= strdup_malloc(nth_token(recvbuf
, 2));
621 if(consumed_old_str
== NULL
) {
622 ERR("put_subbuf: cannot parse consumed_old");
624 goto free_channel_and_cpu
;
626 consumed_old
= strtol(consumed_old_str
, &endptr
, 10);
627 if(*endptr
!= '\0') {
628 ERR("put_subbuf: invalid value for consumed_old");
630 goto free_consumed_old_str
;
633 seperate_channel_cpu(channel_and_cpu
, &ch_name
, &ch_cpu
);
635 ERR("Problem parsing channel name");
637 goto free_short_chan_name
;
641 trace
= _ltt_trace_find(trace_name
);
645 WARN("Cannot find trace. It was likely destroyed by the user.");
646 asprintf(&reply
, "%s", "NOTFOUND");
647 result
= ustcomm_send_reply(&ustcomm_app
.server
, reply
, src
);
649 ERR("ustcomm_send_reply failed");
652 goto free_short_chan_name
;
656 goto free_short_chan_name
;
659 for(i
=0; i
<trace
->nr_channels
; i
++) {
660 struct ust_channel
*channel
= &trace
->channels
[i
];
662 if(!strcmp(trace
->channels
[i
].channel_name
, ch_name
)) {
663 struct ust_buffer
*buf
= channel
->buf
[ch_cpu
];
667 result
= ust_buffers_put_subbuf(buf
, consumed_old
);
669 WARN("ust_buffers_put_subbuf: error (subbuf=%s)", channel_and_cpu
);
670 asprintf(&reply
, "%s", "ERROR");
673 DBG("ust_buffers_put_subbuf: success (subbuf=%s)", channel_and_cpu
);
674 asprintf(&reply
, "%s", "OK");
677 result
= ustcomm_send_reply(&ustcomm_app
.server
, reply
, src
);
679 ERR("listener: put_subbuf: ustcomm_send_reply failed");
682 goto free_channel_and_cpu
;
690 ERR("unable to find channel");
693 free_short_chan_name
:
695 free_consumed_old_str
:
696 free(consumed_old_str
);
697 free_channel_and_cpu
:
698 free(channel_and_cpu
);
704 void *listener_main(void *p
)
708 ust_register_thread();
713 char trace_name
[] = "auto";
714 char trace_type
[] = "ustrelay";
717 struct ustcomm_source src
;
719 process_blocked_consumers();
721 result
= ustcomm_app_recv_message(&ustcomm_app
, &recvbuf
, &src
, 5);
723 WARN("error in ustcomm_app_recv_message");
726 else if(result
== 0) {
731 DBG("received a message! it's: %s", recvbuf
);
732 len
= strlen(recvbuf
);
734 if(!strcmp(recvbuf
, "print_markers")) {
735 print_markers(stderr
);
737 else if(!strcmp(recvbuf
, "list_markers")) {
742 fp
= open_memstream(&ptr
, &size
);
746 result
= ustcomm_send_reply(&ustcomm_app
.server
, ptr
, &src
);
750 else if(!strcmp(recvbuf
, "start")) {
751 /* start is an operation that setups the trace, allocates it and starts it */
752 result
= ltt_trace_setup(trace_name
);
754 ERR("ltt_trace_setup failed");
758 result
= ltt_trace_set_type(trace_name
, trace_type
);
760 ERR("ltt_trace_set_type failed");
764 result
= ltt_trace_alloc(trace_name
);
766 ERR("ltt_trace_alloc failed");
770 inform_consumer_daemon(trace_name
);
772 result
= ltt_trace_start(trace_name
);
774 ERR("ltt_trace_start failed");
778 else if(!strcmp(recvbuf
, "trace_setup")) {
781 result
= ltt_trace_setup(trace_name
);
783 ERR("ltt_trace_setup failed");
787 result
= ltt_trace_set_type(trace_name
, trace_type
);
789 ERR("ltt_trace_set_type failed");
793 else if(!strcmp(recvbuf
, "trace_alloc")) {
796 result
= ltt_trace_alloc(trace_name
);
798 ERR("ltt_trace_alloc failed");
802 else if(!strcmp(recvbuf
, "trace_create")) {
805 result
= ltt_trace_setup(trace_name
);
807 ERR("ltt_trace_setup failed");
811 result
= ltt_trace_set_type(trace_name
, trace_type
);
813 ERR("ltt_trace_set_type failed");
817 result
= ltt_trace_alloc(trace_name
);
819 ERR("ltt_trace_alloc failed");
823 inform_consumer_daemon(trace_name
);
825 else if(!strcmp(recvbuf
, "trace_start")) {
828 result
= ltt_trace_start(trace_name
);
830 ERR("ltt_trace_start failed");
834 else if(!strcmp(recvbuf
, "trace_stop")) {
837 result
= ltt_trace_stop(trace_name
);
839 ERR("ltt_trace_stop failed");
843 else if(!strcmp(recvbuf
, "trace_destroy")) {
845 DBG("trace destroy");
847 result
= ltt_trace_destroy(trace_name
);
849 ERR("ltt_trace_destroy failed");
853 else if(nth_token_is(recvbuf
, "get_shmid", 0) == 1) {
854 do_cmd_get_shmid(recvbuf
, &src
);
856 else if(nth_token_is(recvbuf
, "get_n_subbufs", 0) == 1) {
857 do_cmd_get_n_subbufs(recvbuf
, &src
);
859 else if(nth_token_is(recvbuf
, "get_subbuf_size", 0) == 1) {
860 do_cmd_get_subbuf_size(recvbuf
, &src
);
862 else if(nth_token_is(recvbuf
, "load_probe_lib", 0) == 1) {
865 libfile
= nth_token(recvbuf
, 1);
867 DBG("load_probe_lib loading %s", libfile
);
871 else if(nth_token_is(recvbuf
, "get_subbuffer", 0) == 1) {
872 do_cmd_get_subbuffer(recvbuf
, &src
);
874 else if(nth_token_is(recvbuf
, "put_subbuffer", 0) == 1) {
875 do_cmd_put_subbuffer(recvbuf
, &src
);
877 else if(nth_token_is(recvbuf
, "enable_marker", 0) == 1) {
878 char *channel_slash_name
= nth_token(recvbuf
, 1);
879 char channel_name
[256]="";
880 char marker_name
[256]="";
882 result
= sscanf(channel_slash_name
, "%255[^/]/%255s", channel_name
, marker_name
);
884 if(channel_name
== NULL
|| marker_name
== NULL
) {
885 WARN("invalid marker name");
889 result
= ltt_marker_connect(channel_name
, marker_name
, "default");
891 WARN("could not enable marker; channel=%s, name=%s", channel_name
, marker_name
);
894 else if(nth_token_is(recvbuf
, "disable_marker", 0) == 1) {
895 char *channel_slash_name
= nth_token(recvbuf
, 1);
899 result
= sscanf(channel_slash_name
, "%a[^/]/%as", &channel_name
, &marker_name
);
901 if(marker_name
== NULL
) {
904 result
= ltt_marker_disconnect(channel_name
, marker_name
, "default");
906 WARN("could not disable marker; channel=%s, name=%s", channel_name
, marker_name
);
909 else if(nth_token_is(recvbuf
, "get_pidunique", 0) == 1) {
912 asprintf(&reply
, "%lld", pidunique
);
914 result
= ustcomm_send_reply(&ustcomm_app
.server
, reply
, &src
);
916 ERR("listener: get_pidunique: ustcomm_send_reply failed");
922 // else if(nth_token_is(recvbuf, "get_notifications", 0) == 1) {
923 // struct ust_trace *trace;
924 // char trace_name[] = "auto";
926 // char *channel_name;
928 // DBG("get_notifications");
930 // channel_name = strdup_malloc(nth_token(recvbuf, 1));
931 // if(channel_name == NULL) {
932 // ERR("put_subbuf_size: cannot parse channel");
936 // ltt_lock_traces();
937 // trace = _ltt_trace_find(trace_name);
938 // ltt_unlock_traces();
940 // if(trace == NULL) {
941 // ERR("cannot find trace!");
945 // for(i=0; i<trace->nr_channels; i++) {
946 // struct rchan *rchan = trace->channels[i].trans_channel_data;
949 // if(!strcmp(trace->channels[i].channel_name, channel_name)) {
950 // struct rchan_buf *rbuf = rchan->buf;
951 // struct ltt_channel_buf_struct *lttbuf = trace->channels[i].buf;
953 // result = fd = ustcomm_app_detach_client(&ustcomm_app, &src);
954 // if(result == -1) {
955 // ERR("ustcomm_app_detach_client failed");
959 // lttbuf->wake_consumer_arg = (void *) fd;
963 // lttbuf->call_wake_consumer = 1;
969 // free(channel_name);
972 ERR("unable to parse message: %s", recvbuf
);
980 volatile sig_atomic_t have_listener
= 0;
982 void create_listener(void)
985 static char listener_stack
[16384];
992 WARN("not creating listener because we already had one");
997 result
= clone((int (*)(void *)) listener_main
, listener_stack
+sizeof(listener_stack
)-1, CLONE_FS
| CLONE_FILES
| CLONE_VM
| CLONE_SIGHAND
| CLONE_THREAD
, NULL
);
1004 pthread_create(&thread
, NULL
, listener_main
, NULL
);
1010 static int init_socket(void)
1012 return ustcomm_init_app(getpid(), &ustcomm_app
);
1015 #define AUTOPROBE_DISABLED 0
1016 #define AUTOPROBE_ENABLE_ALL 1
1017 #define AUTOPROBE_ENABLE_REGEX 2
1018 static int autoprobe_method
= AUTOPROBE_DISABLED
;
1019 static regex_t autoprobe_regex
;
1021 static void auto_probe_connect(struct marker
*m
)
1025 char* concat_name
= NULL
;
1026 const char *probe_name
= "default";
1028 if(autoprobe_method
== AUTOPROBE_DISABLED
) {
1031 else if(autoprobe_method
== AUTOPROBE_ENABLE_REGEX
) {
1032 result
= asprintf(&concat_name
, "%s/%s", m
->channel
, m
->name
);
1034 ERR("auto_probe_connect: asprintf failed (marker %s/%s)",
1035 m
->channel
, m
->name
);
1038 if (regexec(&autoprobe_regex
, concat_name
, 0, NULL
, 0)) {
1045 result
= ltt_marker_connect(m
->channel
, m
->name
, probe_name
);
1046 if(result
&& result
!= -EEXIST
)
1047 ERR("ltt_marker_connect (marker = %s/%s, errno = %d)", m
->channel
, m
->name
, -result
);
1049 DBG("auto connected marker %s (addr: %p) %s to probe default", m
->channel
, m
, m
->name
);
1053 static void __attribute__((constructor
)) init()
1056 char* autoprobe_val
= NULL
;
1058 /* Assign the pidunique, to be able to differentiate the processes with same
1059 * pid, (before and after an exec).
1061 pidunique
= make_pidunique();
1063 /* Initialize RCU in case the constructor order is not good. */
1066 /* It is important to do this before events start to be generated. */
1067 ust_register_thread();
1069 DBG("Tracectl constructor");
1071 /* Must create socket before signal handler to prevent races.
1073 result
= init_socket();
1075 ERR("init_socket error");
1081 autoprobe_val
= getenv("UST_AUTOPROBE");
1083 struct marker_iter iter
;
1085 DBG("Autoprobe enabled.");
1087 /* Ensure markers are initialized */
1090 /* Ensure marker control is initialized, for the probe */
1091 init_marker_control();
1093 /* first, set the callback that will connect the
1094 * probe on new markers
1096 if(autoprobe_val
[0] == '/') {
1097 result
= regcomp(&autoprobe_regex
, autoprobe_val
+1, 0);
1101 regerror(result
, &autoprobe_regex
, regexerr
, sizeof(regexerr
));
1102 ERR("cannot parse regex %s (%s), will ignore UST_AUTOPROBE", autoprobe_val
, regexerr
);
1103 /* don't crash the application just for this */
1106 autoprobe_method
= AUTOPROBE_ENABLE_REGEX
;
1110 /* just enable all instrumentation */
1111 autoprobe_method
= AUTOPROBE_ENABLE_ALL
;
1114 marker_set_new_marker_cb(auto_probe_connect
);
1116 /* Now, connect the probes that were already registered. */
1117 marker_iter_reset(&iter
);
1118 marker_iter_start(&iter
);
1120 DBG("now iterating on markers already registered");
1121 while(iter
.marker
) {
1122 DBG("now iterating on marker %s", iter
.marker
->name
);
1123 auto_probe_connect(iter
.marker
);
1124 marker_iter_next(&iter
);
1128 if(getenv("UST_TRACE")) {
1129 char trace_name
[] = "auto";
1130 char trace_type
[] = "ustrelay";
1132 DBG("starting early tracing");
1134 /* Ensure marker control is initialized */
1135 init_marker_control();
1137 /* Ensure markers are initialized */
1140 /* Ensure buffers are initialized, for the transport to be available.
1141 * We are about to set a trace type and it will fail without this.
1143 init_ustrelay_transport();
1145 /* FIXME: When starting early tracing (here), depending on the
1146 * order of constructors, it is very well possible some marker
1147 * sections are not yet registered. Because of this, some
1148 * channels may not be registered. Yet, we are about to ask the
1149 * daemon to collect the channels. Channels which are not yet
1150 * registered will not be collected.
1152 * Currently, in LTTng, there is no way to add a channel after
1153 * trace start. The reason for this is that it induces complex
1154 * concurrency issues on the trace structures, which can only
1155 * be resolved using RCU. This has not been done yet. As a
1156 * workaround, we are forcing the registration of the "ust"
1157 * channel here. This is the only channel (apart from metadata)
1158 * that can be reliably used in early tracing.
1160 * Non-early tracing does not have this problem and can use
1161 * arbitrary channel names.
1163 ltt_channels_register("ust");
1165 result
= ltt_trace_setup(trace_name
);
1167 ERR("ltt_trace_setup failed");
1171 result
= ltt_trace_set_type(trace_name
, trace_type
);
1173 ERR("ltt_trace_set_type failed");
1177 result
= ltt_trace_alloc(trace_name
);
1179 ERR("ltt_trace_alloc failed");
1183 result
= ltt_trace_start(trace_name
);
1185 ERR("ltt_trace_start failed");
1189 /* Do this after the trace is started in order to avoid creating confusion
1190 * if the trace fails to start. */
1191 inform_consumer_daemon(trace_name
);
1197 /* should decrementally destroy stuff if error */
1201 /* This is only called if we terminate normally, not with an unhandled signal,
1202 * so we cannot rely on it. However, for now, LTTV requires that the header of
1203 * the last sub-buffer contain a valid end time for the trace. This is done
1204 * automatically only when the trace is properly stopped.
1206 * If the traced program crashed, it is always possible to manually add the
1207 * right value in the header, or to open the trace in text mode.
1209 * FIXME: Fix LTTV so it doesn't need this.
1212 static void destroy_traces(void)
1216 /* if trace running, finish it */
1218 DBG("destructor stopping traces");
1220 result
= ltt_trace_stop("auto");
1222 ERR("ltt_trace_stop error");
1225 result
= ltt_trace_destroy("auto");
1227 ERR("ltt_trace_destroy error");
1231 static int trace_recording(void)
1234 struct ust_trace
*trace
;
1238 list_for_each_entry(trace
, <t_traces
.head
, list
) {
1245 ltt_unlock_traces();
1251 static int have_consumer(void)
1253 return !list_empty(&blocked_consumers
);
1257 int restarting_usleep(useconds_t usecs
)
1263 tv
.tv_nsec
= usecs
* 1000;
1266 result
= nanosleep(&tv
, &tv
);
1267 } while(result
== -1 && errno
== EINTR
);
1272 /* This destructor keeps the process alive for a few seconds in order
1273 * to leave time to ustd to connect to its buffers. This is necessary
1274 * for programs whose execution is very short. It is also useful in all
1275 * programs when tracing is started close to the end of the program
1278 * FIXME: For now, this only works for the first trace created in a
1282 static void __attribute__((destructor
)) keepalive()
1284 if(trace_recording() && buffers_to_export
) {
1286 DBG("Keeping process alive for consumer daemon...");
1287 while(buffers_to_export
) {
1288 const int interv
= 200000;
1289 restarting_usleep(interv
);
1292 if(total
>= 3000000) {
1293 WARN("non-consumed buffers remaining after wait limit; not waiting anymore");
1297 DBG("Finally dying...");
1302 ustcomm_fini_app(&ustcomm_app
);
1305 void ust_potential_exec(void)
1307 trace_mark(ust
, potential_exec
, MARK_NOARGS
);
1314 /* Notify ust that there was a fork. This needs to be called inside
1315 * the new process, anytime a process whose memory is not shared with
1316 * the parent is created. If this function is not called, the events
1317 * of the new process will not be collected.
1319 * Signals should be disabled before the fork and reenabled only after
1320 * this call in order to guarantee tracing is not started before ust_fork()
1321 * sanitizes the new process.
1324 static void ust_fork(void)
1326 struct blocked_consumer
*bc
;
1327 struct blocked_consumer
*deletable_bc
= NULL
;
1330 DBG("ust: forking");
1331 ltt_trace_stop("auto");
1332 ltt_trace_destroy("auto");
1333 /* Delete all active connections */
1334 ustcomm_close_all_connections(&ustcomm_app
.server
);
1336 /* Delete all blocked consumers */
1337 list_for_each_entry(bc
, &blocked_consumers
, list
) {
1338 close(bc
->fd_producer
);
1339 close(bc
->fd_consumer
);
1342 list_del(&bc
->list
);
1348 ltt_trace_setup("auto");
1349 result
= ltt_trace_set_type("auto", "ustrelay");
1351 ERR("ltt_trace_set_type failed");
1355 ltt_trace_alloc("auto");
1356 ltt_trace_start("auto");
1357 inform_consumer_daemon("auto");
1360 void ust_before_fork(ust_fork_info_t
*fork_info
)
1362 /* Disable signals. This is to avoid that the child
1363 * intervenes before it is properly setup for tracing. It is
1364 * safer to disable all signals, because then we know we are not
1365 * breaking anything by restoring the original mask.
1371 - only do this if tracing is active
1374 /* Disable signals */
1375 sigfillset(&all_sigs
);
1376 result
= sigprocmask(SIG_BLOCK
, &all_sigs
, &fork_info
->orig_sigs
);
1378 PERROR("sigprocmask");
1383 /* Don't call this function directly in a traced program */
1384 static void ust_after_fork_common(ust_fork_info_t
*fork_info
)
1388 /* Restore signals */
1389 result
= sigprocmask(SIG_SETMASK
, &fork_info
->orig_sigs
, NULL
);
1391 PERROR("sigprocmask");
1396 void ust_after_fork_parent(ust_fork_info_t
*fork_info
)
1398 /* Reenable signals */
1399 ust_after_fork_common(fork_info
);
1402 void ust_after_fork_child(ust_fork_info_t
*fork_info
)
1404 /* First sanitize the child */
1407 /* Then reenable interrupts */
1408 ust_after_fork_common(fork_info
);