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
23 #include <sys/types.h>
24 #include <sys/socket.h>
29 #include <urcu/uatomic_arch.h>
31 #include <ust/marker.h>
32 #include <ust/tracectl.h>
37 #include "marker-control.h"
38 #include "multipoll.h"
40 #define USTSIGNAL SIGIO
42 #define MAX_MSG_SIZE (100)
44 #define MSG_REGISTER_NOTIF 2
46 /* This should only be accessed by the constructor, before the creation
47 * of the listener, and then only by the listener.
51 struct list_head blocked_consumers
= LIST_HEAD_INIT(blocked_consumers
);
53 static struct ustcomm_app ustcomm_app
;
55 struct tracecmd
{ /* no padding */
60 /* volatile because shared between the listener and the main thread */
61 int buffers_to_export
= 0;
64 /* size: the size of all the fields except size itself */
67 /* Only the necessary part of the payload is transferred. It
68 * may even be none of it.
73 struct consumer_channel
{
75 struct ltt_channel_struct
*chan
;
78 struct blocked_consumer
{
83 /* args to ustcomm_send_reply */
84 struct ustcomm_server server
;
85 struct ustcomm_source src
;
87 /* args to ust_buffers_get_subbuf */
88 struct ust_buffer
*buf
;
90 struct list_head list
;
93 static long long make_pidunique(void)
98 gettimeofday(&tv
, NULL
);
102 retval
|= tv
.tv_usec
;
107 static void print_markers(FILE *fp
)
109 struct marker_iter iter
;
112 marker_iter_reset(&iter
);
113 marker_iter_start(&iter
);
116 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
);
117 marker_iter_next(&iter
);
122 static int init_socket(void);
124 /* Ask the daemon to collect a trace called trace_name and being
125 * produced by this pid.
127 * The trace must be at least allocated. (It can also be started.)
128 * This is because _ltt_trace_find is used.
131 static void inform_consumer_daemon(const char *trace_name
)
134 struct ust_trace
*trace
;
135 pid_t pid
= getpid();
140 trace
= _ltt_trace_find(trace_name
);
142 WARN("inform_consumer_daemon: could not find trace \"%s\"; it is probably already destroyed", trace_name
);
146 for(i
=0; i
< trace
->nr_channels
; i
++) {
147 if(trace
->channels
[i
].request_collection
) {
148 /* iterate on all cpus */
149 for(j
=0; j
<trace
->channels
[i
].n_cpus
; j
++) {
151 asprintf(&buf
, "%s_%d", trace
->channels
[i
].channel_name
, j
);
152 result
= ustcomm_request_consumer(pid
, buf
);
154 WARN("Failed to request collection for channel %s. Is the daemon available?", trace
->channels
[i
].channel_name
);
155 /* continue even if fail */
158 STORE_SHARED(buffers_to_export
, LOAD_SHARED(buffers_to_export
)+1);
167 int process_blkd_consumer_act(void *priv
, int fd
, short events
)
170 long consumed_old
= 0;
172 struct blocked_consumer
*bc
= (struct blocked_consumer
*) priv
;
175 result
= read(bc
->fd_producer
, &inbuf
, 1);
182 DBG("listener: got messsage that a buffer ended");
184 res
= close(bc
->fd_producer
);
191 result
= ustcomm_send_reply(&bc
->server
, "END", &bc
->src
);
193 ERR("ustcomm_send_reply failed");
200 result
= ust_buffers_get_subbuf(bc
->buf
, &consumed_old
);
201 if(result
== -EAGAIN
) {
202 WARN("missed buffer?");
205 else if(result
< 0) {
206 ERR("ust_buffers_get_subbuf: error: %s", strerror(-result
));
208 asprintf(&reply
, "%s %ld", "OK", consumed_old
);
209 result
= ustcomm_send_reply(&bc
->server
, reply
, &bc
->src
);
211 ERR("ustcomm_send_reply failed");
222 void blocked_consumers_add_to_mp(struct mpentries
*ent
)
224 struct blocked_consumer
*bc
;
226 list_for_each_entry(bc
, &blocked_consumers
, list
) {
227 multipoll_add(ent
, bc
->fd_producer
, POLLIN
, process_blkd_consumer_act
, bc
, NULL
);
232 void seperate_channel_cpu(const char *channel_and_cpu
, char **channel
, int *cpu
)
236 sep
= rindex(channel_and_cpu
, '_');
239 sep
= channel_and_cpu
+ strlen(channel_and_cpu
);
245 asprintf(channel
, "%.*s", (int)(sep
-channel_and_cpu
), channel_and_cpu
);
248 static int do_cmd_get_shmid(const char *recvbuf
, struct ustcomm_source
*src
)
251 struct ust_trace
*trace
;
252 char trace_name
[] = "auto";
254 char *channel_and_cpu
;
262 channel_and_cpu
= nth_token(recvbuf
, 1);
263 if(channel_and_cpu
== NULL
) {
264 ERR("cannot parse channel");
268 seperate_channel_cpu(channel_and_cpu
, &ch_name
, &ch_cpu
);
270 ERR("problem parsing channel name");
271 goto free_short_chan_name
;
275 trace
= _ltt_trace_find(trace_name
);
279 ERR("cannot find trace!");
281 goto free_short_chan_name
;
284 for(i
=0; i
<trace
->nr_channels
; i
++) {
285 struct ust_channel
*channel
= &trace
->channels
[i
];
286 struct ust_buffer
*buf
= channel
->buf
[ch_cpu
];
288 if(!strcmp(trace
->channels
[i
].channel_name
, ch_name
)) {
291 // DBG("the shmid for the requested channel is %d", buf->shmid);
292 // DBG("the shmid for its buffer structure is %d", channel->buf_struct_shmids);
293 asprintf(&reply
, "%d %d", buf
->shmid
, channel
->buf_struct_shmids
[ch_cpu
]);
295 result
= ustcomm_send_reply(&ustcomm_app
.server
, reply
, src
);
297 ERR("ustcomm_send_reply failed");
300 goto free_short_chan_name
;
311 ERR("channel not found (%s)", channel_and_cpu
);
314 free_short_chan_name
:
321 static int do_cmd_get_n_subbufs(const char *recvbuf
, struct ustcomm_source
*src
)
324 struct ust_trace
*trace
;
325 char trace_name
[] = "auto";
327 char *channel_and_cpu
;
333 DBG("get_n_subbufs");
335 channel_and_cpu
= nth_token(recvbuf
, 1);
336 if(channel_and_cpu
== NULL
) {
337 ERR("cannot parse channel");
341 seperate_channel_cpu(channel_and_cpu
, &ch_name
, &ch_cpu
);
343 ERR("problem parsing channel name");
344 goto free_short_chan_name
;
348 trace
= _ltt_trace_find(trace_name
);
352 ERR("cannot find trace!");
354 goto free_short_chan_name
;
357 for(i
=0; i
<trace
->nr_channels
; i
++) {
358 struct ust_channel
*channel
= &trace
->channels
[i
];
360 if(!strcmp(trace
->channels
[i
].channel_name
, ch_name
)) {
363 DBG("the n_subbufs for the requested channel is %d", channel
->subbuf_cnt
);
364 asprintf(&reply
, "%d", channel
->subbuf_cnt
);
366 result
= ustcomm_send_reply(&ustcomm_app
.server
, reply
, src
);
368 ERR("ustcomm_send_reply failed");
371 goto free_short_chan_name
;
380 ERR("unable to find channel");
383 free_short_chan_name
:
390 static int do_cmd_get_subbuf_size(const char *recvbuf
, struct ustcomm_source
*src
)
393 struct ust_trace
*trace
;
394 char trace_name
[] = "auto";
396 char *channel_and_cpu
;
402 DBG("get_subbuf_size");
404 channel_and_cpu
= nth_token(recvbuf
, 1);
405 if(channel_and_cpu
== NULL
) {
406 ERR("cannot parse channel");
410 seperate_channel_cpu(channel_and_cpu
, &ch_name
, &ch_cpu
);
412 ERR("problem parsing channel name");
413 goto free_short_chan_name
;
417 trace
= _ltt_trace_find(trace_name
);
421 ERR("cannot find trace!");
423 goto free_short_chan_name
;
426 for(i
=0; i
<trace
->nr_channels
; i
++) {
427 struct ust_channel
*channel
= &trace
->channels
[i
];
429 if(!strcmp(trace
->channels
[i
].channel_name
, ch_name
)) {
432 DBG("the subbuf_size for the requested channel is %zd", channel
->subbuf_size
);
433 asprintf(&reply
, "%zd", channel
->subbuf_size
);
435 result
= ustcomm_send_reply(&ustcomm_app
.server
, reply
, src
);
437 ERR("ustcomm_send_reply failed");
440 goto free_short_chan_name
;
449 ERR("unable to find channel");
452 free_short_chan_name
:
459 /* Return the power of two which is equal or higher to v */
461 static unsigned int pow2_higher_or_eq(unsigned int v
)
465 int retval
= 1<<(hb
-1);
473 static int do_cmd_set_subbuf_size(const char *recvbuf
, struct ustcomm_source
*src
)
475 char *channel_slash_size
;
476 char ch_name
[256]="";
477 unsigned int size
, power
;
479 struct ust_trace
*trace
;
480 char trace_name
[] = "auto";
484 DBG("set_subbuf_size");
486 channel_slash_size
= nth_token(recvbuf
, 1);
487 sscanf(channel_slash_size
, "%255[^/]/%u", ch_name
, &size
);
489 if(ch_name
== NULL
) {
490 ERR("cannot parse channel");
494 power
= pow2_higher_or_eq(size
);
495 power
= max_t(unsigned int, 2u, power
);
497 WARN("using the next power of two for buffer size = %u\n", power
);
500 trace
= _ltt_trace_find_setup(trace_name
);
502 ERR("cannot find trace!");
507 for(i
= 0; i
< trace
->nr_channels
; i
++) {
508 struct ust_channel
*channel
= &trace
->channels
[i
];
510 if(!strcmp(trace
->channels
[i
].channel_name
, ch_name
)) {
512 channel
->subbuf_size
= power
;
513 DBG("the set_subbuf_size for the requested channel is %zd", channel
->subbuf_size
);
520 ERR("unable to find channel");
528 static int do_cmd_set_subbuf_num(const char *recvbuf
, struct ustcomm_source
*src
)
530 char *channel_slash_num
;
531 char ch_name
[256]="";
534 struct ust_trace
*trace
;
535 char trace_name
[] = "auto";
539 DBG("set_subbuf_num");
541 channel_slash_num
= nth_token(recvbuf
, 1);
542 sscanf(channel_slash_num
, "%255[^/]/%u", ch_name
, &num
);
544 if(ch_name
== NULL
) {
545 ERR("cannot parse channel");
549 ERR("subbuffer count should be greater than 2");
554 trace
= _ltt_trace_find_setup(trace_name
);
556 ERR("cannot find trace!");
561 for(i
= 0; i
< trace
->nr_channels
; i
++) {
562 struct ust_channel
*channel
= &trace
->channels
[i
];
564 if(!strcmp(trace
->channels
[i
].channel_name
, ch_name
)) {
566 channel
->subbuf_cnt
= num
;
567 DBG("the set_subbuf_cnt for the requested channel is %zd", channel
->subbuf_cnt
);
574 ERR("unable to find channel");
582 static int do_cmd_get_subbuffer(const char *recvbuf
, struct ustcomm_source
*src
)
585 struct ust_trace
*trace
;
586 char trace_name
[] = "auto";
588 char *channel_and_cpu
;
595 channel_and_cpu
= nth_token(recvbuf
, 1);
596 if(channel_and_cpu
== NULL
) {
597 ERR("cannot parse channel");
601 seperate_channel_cpu(channel_and_cpu
, &ch_name
, &ch_cpu
);
603 ERR("problem parsing channel name");
604 goto free_short_chan_name
;
608 trace
= _ltt_trace_find(trace_name
);
613 DBG("Cannot find trace. It was likely destroyed by the user.");
614 result
= ustcomm_send_reply(&ustcomm_app
.server
, "NOTFOUND", src
);
616 ERR("ustcomm_send_reply failed");
624 for(i
=0; i
<trace
->nr_channels
; i
++) {
625 struct ust_channel
*channel
= &trace
->channels
[i
];
627 if(!strcmp(trace
->channels
[i
].channel_name
, ch_name
)) {
628 struct ust_buffer
*buf
= channel
->buf
[ch_cpu
];
629 struct blocked_consumer
*bc
;
633 bc
= (struct blocked_consumer
*) malloc(sizeof(struct blocked_consumer
));
635 ERR("malloc returned NULL");
638 bc
->fd_consumer
= src
->fd
;
639 bc
->fd_producer
= buf
->data_ready_fd_read
;
642 bc
->server
= ustcomm_app
.server
;
644 list_add(&bc
->list
, &blocked_consumers
);
646 /* Being here is the proof the daemon has mapped the buffer in its
647 * memory. We may now decrement buffers_to_export.
649 if(uatomic_read(&buf
->consumed
) == 0) {
650 DBG("decrementing buffers_to_export");
651 STORE_SHARED(buffers_to_export
, LOAD_SHARED(buffers_to_export
)-1);
658 ERR("unable to find channel");
664 free_short_chan_name
:
671 static int do_cmd_put_subbuffer(const char *recvbuf
, struct ustcomm_source
*src
)
674 struct ust_trace
*trace
;
675 char trace_name
[] = "auto";
677 char *channel_and_cpu
;
683 char *consumed_old_str
;
689 channel_and_cpu
= strdup(nth_token(recvbuf
, 1));
690 if(channel_and_cpu
== NULL
) {
691 ERR("cannot parse channel");
696 consumed_old_str
= strdup(nth_token(recvbuf
, 2));
697 if(consumed_old_str
== NULL
) {
698 ERR("cannot parse consumed_old");
700 goto free_channel_and_cpu
;
702 consumed_old
= strtol(consumed_old_str
, &endptr
, 10);
703 if(*endptr
!= '\0') {
704 ERR("invalid value for consumed_old");
706 goto free_consumed_old_str
;
709 seperate_channel_cpu(channel_and_cpu
, &ch_name
, &ch_cpu
);
711 ERR("problem parsing channel name");
713 goto free_short_chan_name
;
717 trace
= _ltt_trace_find(trace_name
);
720 DBG("Cannot find trace. It was likely destroyed by the user.");
721 result
= ustcomm_send_reply(&ustcomm_app
.server
, "NOTFOUND", src
);
723 ERR("ustcomm_send_reply failed");
731 for(i
=0; i
<trace
->nr_channels
; i
++) {
732 struct ust_channel
*channel
= &trace
->channels
[i
];
734 if(!strcmp(trace
->channels
[i
].channel_name
, ch_name
)) {
735 struct ust_buffer
*buf
= channel
->buf
[ch_cpu
];
739 result
= ust_buffers_put_subbuf(buf
, consumed_old
);
741 WARN("ust_buffers_put_subbuf: error (subbuf=%s)", channel_and_cpu
);
742 asprintf(&reply
, "%s", "ERROR");
745 DBG("ust_buffers_put_subbuf: success (subbuf=%s)", channel_and_cpu
);
746 asprintf(&reply
, "%s", "OK");
749 result
= ustcomm_send_reply(&ustcomm_app
.server
, reply
, src
);
751 ERR("ustcomm_send_reply failed");
762 ERR("unable to find channel");
767 free_short_chan_name
:
769 free_consumed_old_str
:
770 free(consumed_old_str
);
771 free_channel_and_cpu
:
772 free(channel_and_cpu
);
778 static void listener_cleanup(void *ptr
)
780 ustcomm_fini_app(&ustcomm_app
, 0);
783 int process_client_cmd(char *recvbuf
, struct ustcomm_source
*src
)
786 char trace_name
[] = "auto";
787 char trace_type
[] = "ustrelay";
790 DBG("received a message! it's: %s", recvbuf
);
791 len
= strlen(recvbuf
);
793 if(!strcmp(recvbuf
, "print_markers")) {
794 print_markers(stderr
);
796 else if(!strcmp(recvbuf
, "list_markers")) {
801 fp
= open_memstream(&ptr
, &size
);
805 result
= ustcomm_send_reply(&ustcomm_app
.server
, ptr
, src
);
809 else if(!strcmp(recvbuf
, "start")) {
810 /* start is an operation that setups the trace, allocates it and starts it */
811 result
= ltt_trace_setup(trace_name
);
813 ERR("ltt_trace_setup failed");
817 result
= ltt_trace_set_type(trace_name
, trace_type
);
819 ERR("ltt_trace_set_type failed");
823 result
= ltt_trace_alloc(trace_name
);
825 ERR("ltt_trace_alloc failed");
829 inform_consumer_daemon(trace_name
);
831 result
= ltt_trace_start(trace_name
);
833 ERR("ltt_trace_start failed");
837 else if(!strcmp(recvbuf
, "trace_setup")) {
840 result
= ltt_trace_setup(trace_name
);
842 ERR("ltt_trace_setup failed");
846 result
= ltt_trace_set_type(trace_name
, trace_type
);
848 ERR("ltt_trace_set_type failed");
852 else if(!strcmp(recvbuf
, "trace_alloc")) {
855 result
= ltt_trace_alloc(trace_name
);
857 ERR("ltt_trace_alloc failed");
860 inform_consumer_daemon(trace_name
);
862 else if(!strcmp(recvbuf
, "trace_create")) {
865 result
= ltt_trace_setup(trace_name
);
867 ERR("ltt_trace_setup failed");
871 result
= ltt_trace_set_type(trace_name
, trace_type
);
873 ERR("ltt_trace_set_type failed");
877 else if(!strcmp(recvbuf
, "trace_start")) {
880 result
= ltt_trace_alloc(trace_name
);
882 ERR("ltt_trace_alloc failed");
886 inform_consumer_daemon(trace_name
);
889 result
= ltt_trace_start(trace_name
);
891 ERR("ltt_trace_start failed");
895 else if(!strcmp(recvbuf
, "trace_stop")) {
898 result
= ltt_trace_stop(trace_name
);
900 ERR("ltt_trace_stop failed");
904 else if(!strcmp(recvbuf
, "trace_destroy")) {
906 DBG("trace destroy");
908 result
= ltt_trace_destroy(trace_name
, 0);
910 ERR("ltt_trace_destroy failed");
914 else if(nth_token_is(recvbuf
, "get_shmid", 0) == 1) {
915 do_cmd_get_shmid(recvbuf
, src
);
917 else if(nth_token_is(recvbuf
, "get_n_subbufs", 0) == 1) {
918 do_cmd_get_n_subbufs(recvbuf
, src
);
920 else if(nth_token_is(recvbuf
, "get_subbuf_size", 0) == 1) {
921 do_cmd_get_subbuf_size(recvbuf
, src
);
923 else if(nth_token_is(recvbuf
, "load_probe_lib", 0) == 1) {
926 libfile
= nth_token(recvbuf
, 1);
928 DBG("load_probe_lib loading %s", libfile
);
932 else if(nth_token_is(recvbuf
, "get_subbuffer", 0) == 1) {
933 do_cmd_get_subbuffer(recvbuf
, src
);
935 else if(nth_token_is(recvbuf
, "put_subbuffer", 0) == 1) {
936 do_cmd_put_subbuffer(recvbuf
, src
);
938 else if(nth_token_is(recvbuf
, "set_subbuf_size", 0) == 1) {
939 do_cmd_set_subbuf_size(recvbuf
, src
);
941 else if(nth_token_is(recvbuf
, "set_subbuf_num", 0) == 1) {
942 do_cmd_set_subbuf_num(recvbuf
, src
);
944 else if(nth_token_is(recvbuf
, "enable_marker", 0) == 1) {
945 char *channel_slash_name
= nth_token(recvbuf
, 1);
946 char channel_name
[256]="";
947 char marker_name
[256]="";
949 result
= sscanf(channel_slash_name
, "%255[^/]/%255s", channel_name
, marker_name
);
951 if(channel_name
== NULL
|| marker_name
== NULL
) {
952 WARN("invalid marker name");
956 result
= ltt_marker_connect(channel_name
, marker_name
, "default");
958 WARN("could not enable marker; channel=%s, name=%s", channel_name
, marker_name
);
961 else if(nth_token_is(recvbuf
, "disable_marker", 0) == 1) {
962 char *channel_slash_name
= nth_token(recvbuf
, 1);
966 result
= sscanf(channel_slash_name
, "%a[^/]/%as", &channel_name
, &marker_name
);
968 if(marker_name
== NULL
) {
971 result
= ltt_marker_disconnect(channel_name
, marker_name
, "default");
973 WARN("could not disable marker; channel=%s, name=%s", channel_name
, marker_name
);
976 else if(nth_token_is(recvbuf
, "get_pidunique", 0) == 1) {
979 asprintf(&reply
, "%lld", pidunique
);
981 result
= ustcomm_send_reply(&ustcomm_app
.server
, reply
, src
);
983 ERR("listener: get_pidunique: ustcomm_send_reply failed");
990 ERR("unable to parse message: %s", recvbuf
);
998 void *listener_main(void *p
)
1004 pthread_cleanup_push(listener_cleanup
, NULL
);
1007 struct mpentries mpent
;
1009 multipoll_init(&mpent
);
1011 blocked_consumers_add_to_mp(&mpent
);
1012 ustcomm_mp_add_app_clients(&mpent
, &ustcomm_app
, process_client_cmd
);
1014 result
= multipoll_poll(&mpent
, -1);
1016 ERR("error in multipoll_poll");
1019 multipoll_destroy(&mpent
);
1022 pthread_cleanup_pop(1);
1025 /* These should only be accessed in the parent thread,
1028 static volatile sig_atomic_t have_listener
= 0;
1029 static pthread_t listener_thread
;
1031 void create_listener(void)
1036 WARN("not creating listener because we already had one");
1040 result
= pthread_create(&listener_thread
, NULL
, listener_main
, NULL
);
1042 PERROR("pthread_create");
1048 static int init_socket(void)
1050 return ustcomm_init_app(getpid(), &ustcomm_app
);
1053 #define AUTOPROBE_DISABLED 0
1054 #define AUTOPROBE_ENABLE_ALL 1
1055 #define AUTOPROBE_ENABLE_REGEX 2
1056 static int autoprobe_method
= AUTOPROBE_DISABLED
;
1057 static regex_t autoprobe_regex
;
1059 static void auto_probe_connect(struct marker
*m
)
1063 char* concat_name
= NULL
;
1064 const char *probe_name
= "default";
1066 if(autoprobe_method
== AUTOPROBE_DISABLED
) {
1069 else if(autoprobe_method
== AUTOPROBE_ENABLE_REGEX
) {
1070 result
= asprintf(&concat_name
, "%s/%s", m
->channel
, m
->name
);
1072 ERR("auto_probe_connect: asprintf failed (marker %s/%s)",
1073 m
->channel
, m
->name
);
1076 if (regexec(&autoprobe_regex
, concat_name
, 0, NULL
, 0)) {
1083 result
= ltt_marker_connect(m
->channel
, m
->name
, probe_name
);
1084 if(result
&& result
!= -EEXIST
)
1085 ERR("ltt_marker_connect (marker = %s/%s, errno = %d)", m
->channel
, m
->name
, -result
);
1087 DBG("auto connected marker %s (addr: %p) %s to probe default", m
->channel
, m
, m
->name
);
1091 static void __attribute__((constructor
)) init()
1094 char* autoprobe_val
= NULL
;
1096 /* Assign the pidunique, to be able to differentiate the processes with same
1097 * pid, (before and after an exec).
1099 pidunique
= make_pidunique();
1101 DBG("Tracectl constructor");
1103 result
= init_socket();
1105 ERR("init_socket error");
1111 autoprobe_val
= getenv("UST_AUTOPROBE");
1113 struct marker_iter iter
;
1115 DBG("Autoprobe enabled.");
1117 /* Ensure markers are initialized */
1120 /* Ensure marker control is initialized, for the probe */
1121 init_marker_control();
1123 /* first, set the callback that will connect the
1124 * probe on new markers
1126 if(autoprobe_val
[0] == '/') {
1127 result
= regcomp(&autoprobe_regex
, autoprobe_val
+1, 0);
1131 regerror(result
, &autoprobe_regex
, regexerr
, sizeof(regexerr
));
1132 ERR("cannot parse regex %s (%s), will ignore UST_AUTOPROBE", autoprobe_val
, regexerr
);
1133 /* don't crash the application just for this */
1136 autoprobe_method
= AUTOPROBE_ENABLE_REGEX
;
1140 /* just enable all instrumentation */
1141 autoprobe_method
= AUTOPROBE_ENABLE_ALL
;
1144 marker_set_new_marker_cb(auto_probe_connect
);
1146 /* Now, connect the probes that were already registered. */
1147 marker_iter_reset(&iter
);
1148 marker_iter_start(&iter
);
1150 DBG("now iterating on markers already registered");
1151 while(iter
.marker
) {
1152 DBG("now iterating on marker %s", iter
.marker
->name
);
1153 auto_probe_connect(iter
.marker
);
1154 marker_iter_next(&iter
);
1158 if(getenv("UST_OVERWRITE")) {
1159 int val
= atoi(getenv("UST_OVERWRITE"));
1160 if(val
== 0 || val
== 1) {
1161 STORE_SHARED(ust_channels_overwrite_by_default
, val
);
1164 WARN("invalid value for UST_OVERWRITE");
1168 if(getenv("UST_AUTOCOLLECT")) {
1169 int val
= atoi(getenv("UST_AUTOCOLLECT"));
1170 if(val
== 0 || val
== 1) {
1171 STORE_SHARED(ust_channels_request_collection_by_default
, val
);
1174 WARN("invalid value for UST_AUTOCOLLECT");
1178 if(getenv("UST_TRACE")) {
1179 char trace_name
[] = "auto";
1180 char trace_type
[] = "ustrelay";
1182 DBG("starting early tracing");
1184 /* Ensure marker control is initialized */
1185 init_marker_control();
1187 /* Ensure markers are initialized */
1190 /* Ensure buffers are initialized, for the transport to be available.
1191 * We are about to set a trace type and it will fail without this.
1193 init_ustrelay_transport();
1195 /* FIXME: When starting early tracing (here), depending on the
1196 * order of constructors, it is very well possible some marker
1197 * sections are not yet registered. Because of this, some
1198 * channels may not be registered. Yet, we are about to ask the
1199 * daemon to collect the channels. Channels which are not yet
1200 * registered will not be collected.
1202 * Currently, in LTTng, there is no way to add a channel after
1203 * trace start. The reason for this is that it induces complex
1204 * concurrency issues on the trace structures, which can only
1205 * be resolved using RCU. This has not been done yet. As a
1206 * workaround, we are forcing the registration of the "ust"
1207 * channel here. This is the only channel (apart from metadata)
1208 * that can be reliably used in early tracing.
1210 * Non-early tracing does not have this problem and can use
1211 * arbitrary channel names.
1213 ltt_channels_register("ust");
1215 result
= ltt_trace_setup(trace_name
);
1217 ERR("ltt_trace_setup failed");
1221 result
= ltt_trace_set_type(trace_name
, trace_type
);
1223 ERR("ltt_trace_set_type failed");
1227 result
= ltt_trace_alloc(trace_name
);
1229 ERR("ltt_trace_alloc failed");
1233 result
= ltt_trace_start(trace_name
);
1235 ERR("ltt_trace_start failed");
1239 /* Do this after the trace is started in order to avoid creating confusion
1240 * if the trace fails to start. */
1241 inform_consumer_daemon(trace_name
);
1247 /* should decrementally destroy stuff if error */
1251 /* This is only called if we terminate normally, not with an unhandled signal,
1252 * so we cannot rely on it. However, for now, LTTV requires that the header of
1253 * the last sub-buffer contain a valid end time for the trace. This is done
1254 * automatically only when the trace is properly stopped.
1256 * If the traced program crashed, it is always possible to manually add the
1257 * right value in the header, or to open the trace in text mode.
1259 * FIXME: Fix LTTV so it doesn't need this.
1262 static void destroy_traces(void)
1266 /* if trace running, finish it */
1268 DBG("destructor stopping traces");
1270 result
= ltt_trace_stop("auto");
1272 ERR("ltt_trace_stop error");
1275 result
= ltt_trace_destroy("auto", 0);
1277 ERR("ltt_trace_destroy error");
1281 static int trace_recording(void)
1284 struct ust_trace
*trace
;
1288 list_for_each_entry(trace
, <t_traces
.head
, list
) {
1295 ltt_unlock_traces();
1301 static int have_consumer(void)
1303 return !list_empty(&blocked_consumers
);
1307 int restarting_usleep(useconds_t usecs
)
1313 tv
.tv_nsec
= usecs
* 1000;
1316 result
= nanosleep(&tv
, &tv
);
1317 } while(result
== -1 && errno
== EINTR
);
1322 static void stop_listener()
1326 result
= pthread_cancel(listener_thread
);
1328 ERR("pthread_cancel: %s", strerror(result
));
1330 result
= pthread_join(listener_thread
, NULL
);
1332 ERR("pthread_join: %s", strerror(result
));
1336 /* This destructor keeps the process alive for a few seconds in order
1337 * to leave time to ustd to connect to its buffers. This is necessary
1338 * for programs whose execution is very short. It is also useful in all
1339 * programs when tracing is started close to the end of the program
1342 * FIXME: For now, this only works for the first trace created in a
1346 static void __attribute__((destructor
)) keepalive()
1348 if(trace_recording() && LOAD_SHARED(buffers_to_export
)) {
1350 DBG("Keeping process alive for consumer daemon...");
1351 while(LOAD_SHARED(buffers_to_export
)) {
1352 const int interv
= 200000;
1353 restarting_usleep(interv
);
1356 if(total
>= 3000000) {
1357 WARN("non-consumed buffers remaining after wait limit; not waiting anymore");
1361 DBG("Finally dying...");
1366 /* Ask the listener to stop and clean up. */
1370 void ust_potential_exec(void)
1372 trace_mark(ust
, potential_exec
, MARK_NOARGS
);
1379 /* Notify ust that there was a fork. This needs to be called inside
1380 * the new process, anytime a process whose memory is not shared with
1381 * the parent is created. If this function is not called, the events
1382 * of the new process will not be collected.
1384 * Signals should be disabled before the fork and reenabled only after
1385 * this call in order to guarantee tracing is not started before ust_fork()
1386 * sanitizes the new process.
1389 static void ust_fork(void)
1391 struct blocked_consumer
*bc
;
1392 struct blocked_consumer
*deletable_bc
= NULL
;
1395 /* FIXME: technically, the locks could have been taken before the fork */
1396 DBG("ust: forking");
1398 /* break lock if necessary */
1399 ltt_unlock_traces();
1401 ltt_trace_stop("auto");
1402 ltt_trace_destroy("auto", 1);
1403 /* Delete all active connections */
1404 ustcomm_close_all_connections(&ustcomm_app
.server
);
1406 /* Delete all blocked consumers */
1407 list_for_each_entry(bc
, &blocked_consumers
, list
) {
1408 result
= close(bc
->fd_producer
);
1414 list_del(&bc
->list
);
1417 /* free app, keeping socket file */
1418 ustcomm_fini_app(&ustcomm_app
, 1);
1420 STORE_SHARED(buffers_to_export
, 0);
1424 ltt_trace_setup("auto");
1425 result
= ltt_trace_set_type("auto", "ustrelay");
1427 ERR("ltt_trace_set_type failed");
1431 ltt_trace_alloc("auto");
1432 ltt_trace_start("auto");
1433 inform_consumer_daemon("auto");
1436 void ust_before_fork(ust_fork_info_t
*fork_info
)
1438 /* Disable signals. This is to avoid that the child
1439 * intervenes before it is properly setup for tracing. It is
1440 * safer to disable all signals, because then we know we are not
1441 * breaking anything by restoring the original mask.
1447 - only do this if tracing is active
1450 /* Disable signals */
1451 sigfillset(&all_sigs
);
1452 result
= sigprocmask(SIG_BLOCK
, &all_sigs
, &fork_info
->orig_sigs
);
1454 PERROR("sigprocmask");
1459 /* Don't call this function directly in a traced program */
1460 static void ust_after_fork_common(ust_fork_info_t
*fork_info
)
1464 /* Restore signals */
1465 result
= sigprocmask(SIG_SETMASK
, &fork_info
->orig_sigs
, NULL
);
1467 PERROR("sigprocmask");
1472 void ust_after_fork_parent(ust_fork_info_t
*fork_info
)
1474 /* Reenable signals */
1475 ust_after_fork_common(fork_info
);
1478 void ust_after_fork_child(ust_fork_info_t
*fork_info
)
1480 /* First sanitize the child */
1483 /* Then reenable interrupts */
1484 ust_after_fork_common(fork_info
);