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
18 /* This file contains the implementation of the UST listener thread, which
19 * receives trace control commands. It also coordinates the initialization of
29 #include <sys/types.h>
30 #include <sys/socket.h>
35 #include <urcu/uatomic_arch.h>
37 #include <ust/marker.h>
38 #include <ust/tracectl.h>
43 #include "marker-control.h"
44 #include "multipoll.h"
46 #define USTSIGNAL SIGIO
48 #define MAX_MSG_SIZE (100)
50 #define MSG_REGISTER_NOTIF 2
52 /* This should only be accessed by the constructor, before the creation
53 * of the listener, and then only by the listener.
57 extern struct chan_info_struct chan_infos
[];
59 struct list_head blocked_consumers
= LIST_HEAD_INIT(blocked_consumers
);
61 static struct ustcomm_app ustcomm_app
;
63 struct tracecmd
{ /* no padding */
68 /* volatile because shared between the listener and the main thread */
69 int buffers_to_export
= 0;
72 /* size: the size of all the fields except size itself */
75 /* Only the necessary part of the payload is transferred. It
76 * may even be none of it.
81 struct consumer_channel
{
83 struct ltt_channel_struct
*chan
;
86 struct blocked_consumer
{
91 /* args to ustcomm_send_reply */
92 struct ustcomm_server server
;
93 struct ustcomm_source src
;
95 /* args to ust_buffers_get_subbuf */
96 struct ust_buffer
*buf
;
98 struct list_head list
;
101 static long long make_pidunique(void)
106 gettimeofday(&tv
, NULL
);
110 retval
|= tv
.tv_usec
;
115 static void print_markers(FILE *fp
)
117 struct marker_iter iter
;
120 marker_iter_reset(&iter
);
121 marker_iter_start(&iter
);
124 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
);
125 marker_iter_next(&iter
);
130 static int init_socket(void);
132 /* Ask the daemon to collect a trace called trace_name and being
133 * produced by this pid.
135 * The trace must be at least allocated. (It can also be started.)
136 * This is because _ltt_trace_find is used.
139 static void inform_consumer_daemon(const char *trace_name
)
142 struct ust_trace
*trace
;
143 pid_t pid
= getpid();
148 trace
= _ltt_trace_find(trace_name
);
150 WARN("inform_consumer_daemon: could not find trace \"%s\"; it is probably already destroyed", trace_name
);
154 for(i
=0; i
< trace
->nr_channels
; i
++) {
155 if(trace
->channels
[i
].request_collection
) {
156 /* iterate on all cpus */
157 for(j
=0; j
<trace
->channels
[i
].n_cpus
; j
++) {
159 asprintf(&buf
, "%s_%d", trace
->channels
[i
].channel_name
, j
);
160 result
= ustcomm_request_consumer(pid
, buf
);
162 WARN("Failed to request collection for channel %s. Is the daemon available?", trace
->channels
[i
].channel_name
);
163 /* continue even if fail */
166 STORE_SHARED(buffers_to_export
, LOAD_SHARED(buffers_to_export
)+1);
175 int process_blkd_consumer_act(void *priv
, int fd
, short events
)
178 long consumed_old
= 0;
180 struct blocked_consumer
*bc
= (struct blocked_consumer
*) priv
;
183 result
= read(bc
->fd_producer
, &inbuf
, 1);
190 DBG("listener: got messsage that a buffer ended");
192 res
= close(bc
->fd_producer
);
199 result
= ustcomm_send_reply(&bc
->server
, "END", &bc
->src
);
201 ERR("ustcomm_send_reply failed");
208 result
= ust_buffers_get_subbuf(bc
->buf
, &consumed_old
);
209 if(result
== -EAGAIN
) {
210 WARN("missed buffer?");
213 else if(result
< 0) {
214 ERR("ust_buffers_get_subbuf: error: %s", strerror(-result
));
216 asprintf(&reply
, "%s %ld", "OK", consumed_old
);
217 result
= ustcomm_send_reply(&bc
->server
, reply
, &bc
->src
);
219 ERR("ustcomm_send_reply failed");
230 void blocked_consumers_add_to_mp(struct mpentries
*ent
)
232 struct blocked_consumer
*bc
;
234 list_for_each_entry(bc
, &blocked_consumers
, list
) {
235 multipoll_add(ent
, bc
->fd_producer
, POLLIN
, process_blkd_consumer_act
, bc
, NULL
);
240 void seperate_channel_cpu(const char *channel_and_cpu
, char **channel
, int *cpu
)
244 sep
= rindex(channel_and_cpu
, '_');
247 sep
= channel_and_cpu
+ strlen(channel_and_cpu
);
253 asprintf(channel
, "%.*s", (int)(sep
-channel_and_cpu
), channel_and_cpu
);
256 static int do_cmd_get_shmid(const char *recvbuf
, struct ustcomm_source
*src
)
259 struct ust_trace
*trace
;
260 char trace_name
[] = "auto";
262 char *channel_and_cpu
;
270 channel_and_cpu
= nth_token(recvbuf
, 1);
271 if(channel_and_cpu
== NULL
) {
272 ERR("cannot parse channel");
276 seperate_channel_cpu(channel_and_cpu
, &ch_name
, &ch_cpu
);
278 ERR("problem parsing channel name");
279 goto free_short_chan_name
;
283 trace
= _ltt_trace_find(trace_name
);
287 ERR("cannot find trace!");
289 goto free_short_chan_name
;
292 for(i
=0; i
<trace
->nr_channels
; i
++) {
293 struct ust_channel
*channel
= &trace
->channels
[i
];
294 struct ust_buffer
*buf
= channel
->buf
[ch_cpu
];
296 if(!strcmp(trace
->channels
[i
].channel_name
, ch_name
)) {
299 // DBG("the shmid for the requested channel is %d", buf->shmid);
300 // DBG("the shmid for its buffer structure is %d", channel->buf_struct_shmids);
301 asprintf(&reply
, "%d %d", buf
->shmid
, channel
->buf_struct_shmids
[ch_cpu
]);
303 result
= ustcomm_send_reply(&ustcomm_app
.server
, reply
, src
);
305 ERR("ustcomm_send_reply failed");
308 goto free_short_chan_name
;
319 ERR("channel not found (%s)", channel_and_cpu
);
322 free_short_chan_name
:
329 static int do_cmd_get_n_subbufs(const char *recvbuf
, struct ustcomm_source
*src
)
332 struct ust_trace
*trace
;
333 char trace_name
[] = "auto";
335 char *channel_and_cpu
;
341 DBG("get_n_subbufs");
343 channel_and_cpu
= nth_token(recvbuf
, 1);
344 if(channel_and_cpu
== NULL
) {
345 ERR("cannot parse channel");
349 seperate_channel_cpu(channel_and_cpu
, &ch_name
, &ch_cpu
);
351 ERR("problem parsing channel name");
352 goto free_short_chan_name
;
356 trace
= _ltt_trace_find(trace_name
);
360 ERR("cannot find trace!");
362 goto free_short_chan_name
;
365 for(i
=0; i
<trace
->nr_channels
; i
++) {
366 struct ust_channel
*channel
= &trace
->channels
[i
];
368 if(!strcmp(trace
->channels
[i
].channel_name
, ch_name
)) {
371 DBG("the n_subbufs for the requested channel is %d", channel
->subbuf_cnt
);
372 asprintf(&reply
, "%d", channel
->subbuf_cnt
);
374 result
= ustcomm_send_reply(&ustcomm_app
.server
, reply
, src
);
376 ERR("ustcomm_send_reply failed");
379 goto free_short_chan_name
;
388 ERR("unable to find channel");
391 free_short_chan_name
:
398 static int do_cmd_get_subbuf_size(const char *recvbuf
, struct ustcomm_source
*src
)
401 struct ust_trace
*trace
;
402 char trace_name
[] = "auto";
404 char *channel_and_cpu
;
410 DBG("get_subbuf_size");
412 channel_and_cpu
= nth_token(recvbuf
, 1);
413 if(channel_and_cpu
== NULL
) {
414 ERR("cannot parse channel");
418 seperate_channel_cpu(channel_and_cpu
, &ch_name
, &ch_cpu
);
420 ERR("problem parsing channel name");
421 goto free_short_chan_name
;
425 trace
= _ltt_trace_find(trace_name
);
429 ERR("cannot find trace!");
431 goto free_short_chan_name
;
434 for(i
=0; i
<trace
->nr_channels
; i
++) {
435 struct ust_channel
*channel
= &trace
->channels
[i
];
437 if(!strcmp(trace
->channels
[i
].channel_name
, ch_name
)) {
440 DBG("the subbuf_size for the requested channel is %zd", channel
->subbuf_size
);
441 asprintf(&reply
, "%zd", channel
->subbuf_size
);
443 result
= ustcomm_send_reply(&ustcomm_app
.server
, reply
, src
);
445 ERR("ustcomm_send_reply failed");
448 goto free_short_chan_name
;
457 ERR("unable to find channel");
460 free_short_chan_name
:
467 /* Return the power of two which is equal or higher to v */
469 static unsigned int pow2_higher_or_eq(unsigned int v
)
473 int retval
= 1<<(hb
-1);
481 static int do_cmd_set_subbuf_size(const char *recvbuf
, struct ustcomm_source
*src
)
483 char *channel_slash_size
;
484 char ch_name
[256]="";
485 unsigned int size
, power
;
487 struct ust_trace
*trace
;
488 char trace_name
[] = "auto";
492 DBG("set_subbuf_size");
494 channel_slash_size
= nth_token(recvbuf
, 1);
495 sscanf(channel_slash_size
, "%255[^/]/%u", ch_name
, &size
);
497 if(ch_name
== NULL
) {
498 ERR("cannot parse channel");
502 power
= pow2_higher_or_eq(size
);
503 power
= max_t(unsigned int, 2u, power
);
505 WARN("using the next power of two for buffer size = %u\n", power
);
508 trace
= _ltt_trace_find_setup(trace_name
);
510 ERR("cannot find trace!");
515 for(i
= 0; i
< trace
->nr_channels
; i
++) {
516 struct ust_channel
*channel
= &trace
->channels
[i
];
518 if(!strcmp(trace
->channels
[i
].channel_name
, ch_name
)) {
520 channel
->subbuf_size
= power
;
521 DBG("the set_subbuf_size for the requested channel is %zd", channel
->subbuf_size
);
528 ERR("unable to find channel");
536 static int do_cmd_set_subbuf_num(const char *recvbuf
, struct ustcomm_source
*src
)
538 char *channel_slash_num
;
539 char ch_name
[256]="";
542 struct ust_trace
*trace
;
543 char trace_name
[] = "auto";
547 DBG("set_subbuf_num");
549 channel_slash_num
= nth_token(recvbuf
, 1);
550 sscanf(channel_slash_num
, "%255[^/]/%u", ch_name
, &num
);
552 if(ch_name
== NULL
) {
553 ERR("cannot parse channel");
557 ERR("subbuffer count should be greater than 2");
562 trace
= _ltt_trace_find_setup(trace_name
);
564 ERR("cannot find trace!");
569 for(i
= 0; i
< trace
->nr_channels
; i
++) {
570 struct ust_channel
*channel
= &trace
->channels
[i
];
572 if(!strcmp(trace
->channels
[i
].channel_name
, ch_name
)) {
574 channel
->subbuf_cnt
= num
;
575 DBG("the set_subbuf_cnt for the requested channel is %zd", channel
->subbuf_cnt
);
582 ERR("unable to find channel");
590 static int do_cmd_get_subbuffer(const char *recvbuf
, struct ustcomm_source
*src
)
593 struct ust_trace
*trace
;
594 char trace_name
[] = "auto";
596 char *channel_and_cpu
;
603 channel_and_cpu
= nth_token(recvbuf
, 1);
604 if(channel_and_cpu
== NULL
) {
605 ERR("cannot parse channel");
609 seperate_channel_cpu(channel_and_cpu
, &ch_name
, &ch_cpu
);
611 ERR("problem parsing channel name");
612 goto free_short_chan_name
;
616 trace
= _ltt_trace_find(trace_name
);
621 DBG("Cannot find trace. It was likely destroyed by the user.");
622 result
= ustcomm_send_reply(&ustcomm_app
.server
, "NOTFOUND", src
);
624 ERR("ustcomm_send_reply failed");
632 for(i
=0; i
<trace
->nr_channels
; i
++) {
633 struct ust_channel
*channel
= &trace
->channels
[i
];
635 if(!strcmp(trace
->channels
[i
].channel_name
, ch_name
)) {
636 struct ust_buffer
*buf
= channel
->buf
[ch_cpu
];
637 struct blocked_consumer
*bc
;
641 bc
= (struct blocked_consumer
*) malloc(sizeof(struct blocked_consumer
));
643 ERR("malloc returned NULL");
646 bc
->fd_consumer
= src
->fd
;
647 bc
->fd_producer
= buf
->data_ready_fd_read
;
650 bc
->server
= ustcomm_app
.server
;
652 list_add(&bc
->list
, &blocked_consumers
);
654 /* Being here is the proof the daemon has mapped the buffer in its
655 * memory. We may now decrement buffers_to_export.
657 if(uatomic_read(&buf
->consumed
) == 0) {
658 DBG("decrementing buffers_to_export");
659 STORE_SHARED(buffers_to_export
, LOAD_SHARED(buffers_to_export
)-1);
666 ERR("unable to find channel");
672 free_short_chan_name
:
679 static int do_cmd_put_subbuffer(const char *recvbuf
, struct ustcomm_source
*src
)
682 struct ust_trace
*trace
;
683 char trace_name
[] = "auto";
685 char *channel_and_cpu
;
691 char *consumed_old_str
;
697 channel_and_cpu
= strdup(nth_token(recvbuf
, 1));
698 if(channel_and_cpu
== NULL
) {
699 ERR("cannot parse channel");
704 consumed_old_str
= strdup(nth_token(recvbuf
, 2));
705 if(consumed_old_str
== NULL
) {
706 ERR("cannot parse consumed_old");
708 goto free_channel_and_cpu
;
710 consumed_old
= strtol(consumed_old_str
, &endptr
, 10);
711 if(*endptr
!= '\0') {
712 ERR("invalid value for consumed_old");
714 goto free_consumed_old_str
;
717 seperate_channel_cpu(channel_and_cpu
, &ch_name
, &ch_cpu
);
719 ERR("problem parsing channel name");
721 goto free_short_chan_name
;
725 trace
= _ltt_trace_find(trace_name
);
728 DBG("Cannot find trace. It was likely destroyed by the user.");
729 result
= ustcomm_send_reply(&ustcomm_app
.server
, "NOTFOUND", src
);
731 ERR("ustcomm_send_reply failed");
739 for(i
=0; i
<trace
->nr_channels
; i
++) {
740 struct ust_channel
*channel
= &trace
->channels
[i
];
742 if(!strcmp(trace
->channels
[i
].channel_name
, ch_name
)) {
743 struct ust_buffer
*buf
= channel
->buf
[ch_cpu
];
747 result
= ust_buffers_put_subbuf(buf
, consumed_old
);
749 WARN("ust_buffers_put_subbuf: error (subbuf=%s)", channel_and_cpu
);
750 asprintf(&reply
, "%s", "ERROR");
753 DBG("ust_buffers_put_subbuf: success (subbuf=%s)", channel_and_cpu
);
754 asprintf(&reply
, "%s", "OK");
757 result
= ustcomm_send_reply(&ustcomm_app
.server
, reply
, src
);
759 ERR("ustcomm_send_reply failed");
770 ERR("unable to find channel");
775 free_short_chan_name
:
777 free_consumed_old_str
:
778 free(consumed_old_str
);
779 free_channel_and_cpu
:
780 free(channel_and_cpu
);
786 static void listener_cleanup(void *ptr
)
788 ustcomm_fini_app(&ustcomm_app
, 0);
791 static void do_cmd_force_switch()
793 struct blocked_consumer
*bc
;
795 list_for_each_entry(bc
, &blocked_consumers
, list
) {
796 ltt_force_switch(bc
->buf
, FORCE_FLUSH
);
800 int process_client_cmd(char *recvbuf
, struct ustcomm_source
*src
)
803 char trace_name
[] = "auto";
804 char trace_type
[] = "ustrelay";
807 DBG("received a message! it's: %s", recvbuf
);
808 len
= strlen(recvbuf
);
810 if(!strcmp(recvbuf
, "print_markers")) {
811 print_markers(stderr
);
813 else if(!strcmp(recvbuf
, "list_markers")) {
818 fp
= open_memstream(&ptr
, &size
);
822 result
= ustcomm_send_reply(&ustcomm_app
.server
, ptr
, src
);
826 else if(!strcmp(recvbuf
, "start")) {
827 /* start is an operation that setups the trace, allocates it and starts it */
828 result
= ltt_trace_setup(trace_name
);
830 ERR("ltt_trace_setup failed");
834 result
= ltt_trace_set_type(trace_name
, trace_type
);
836 ERR("ltt_trace_set_type failed");
840 result
= ltt_trace_alloc(trace_name
);
842 ERR("ltt_trace_alloc failed");
846 inform_consumer_daemon(trace_name
);
848 result
= ltt_trace_start(trace_name
);
850 ERR("ltt_trace_start failed");
854 else if(!strcmp(recvbuf
, "trace_setup")) {
857 result
= ltt_trace_setup(trace_name
);
859 ERR("ltt_trace_setup failed");
863 result
= ltt_trace_set_type(trace_name
, trace_type
);
865 ERR("ltt_trace_set_type failed");
869 else if(!strcmp(recvbuf
, "trace_alloc")) {
872 result
= ltt_trace_alloc(trace_name
);
874 ERR("ltt_trace_alloc failed");
877 inform_consumer_daemon(trace_name
);
879 else if(!strcmp(recvbuf
, "trace_create")) {
882 result
= ltt_trace_setup(trace_name
);
884 ERR("ltt_trace_setup failed");
888 result
= ltt_trace_set_type(trace_name
, trace_type
);
890 ERR("ltt_trace_set_type failed");
894 else if(!strcmp(recvbuf
, "trace_start")) {
897 result
= ltt_trace_alloc(trace_name
);
899 ERR("ltt_trace_alloc failed");
903 inform_consumer_daemon(trace_name
);
906 result
= ltt_trace_start(trace_name
);
908 ERR("ltt_trace_start failed");
912 else if(!strcmp(recvbuf
, "trace_stop")) {
915 result
= ltt_trace_stop(trace_name
);
917 ERR("ltt_trace_stop failed");
921 else if(!strcmp(recvbuf
, "trace_destroy")) {
923 DBG("trace destroy");
925 result
= ltt_trace_destroy(trace_name
, 0);
927 ERR("ltt_trace_destroy failed");
931 else if(nth_token_is(recvbuf
, "get_shmid", 0) == 1) {
932 do_cmd_get_shmid(recvbuf
, src
);
934 else if(nth_token_is(recvbuf
, "get_n_subbufs", 0) == 1) {
935 do_cmd_get_n_subbufs(recvbuf
, src
);
937 else if(nth_token_is(recvbuf
, "get_subbuf_size", 0) == 1) {
938 do_cmd_get_subbuf_size(recvbuf
, src
);
940 else if(nth_token_is(recvbuf
, "load_probe_lib", 0) == 1) {
943 libfile
= nth_token(recvbuf
, 1);
945 DBG("load_probe_lib loading %s", libfile
);
949 else if(nth_token_is(recvbuf
, "get_subbuffer", 0) == 1) {
950 do_cmd_get_subbuffer(recvbuf
, src
);
952 else if(nth_token_is(recvbuf
, "put_subbuffer", 0) == 1) {
953 do_cmd_put_subbuffer(recvbuf
, src
);
955 else if(nth_token_is(recvbuf
, "set_subbuf_size", 0) == 1) {
956 do_cmd_set_subbuf_size(recvbuf
, src
);
958 else if(nth_token_is(recvbuf
, "set_subbuf_num", 0) == 1) {
959 do_cmd_set_subbuf_num(recvbuf
, src
);
961 else if(nth_token_is(recvbuf
, "enable_marker", 0) == 1) {
962 char *channel_slash_name
= nth_token(recvbuf
, 1);
963 char channel_name
[256]="";
964 char marker_name
[256]="";
966 result
= sscanf(channel_slash_name
, "%255[^/]/%255s", channel_name
, marker_name
);
968 if(channel_name
== NULL
|| marker_name
== NULL
) {
969 WARN("invalid marker name");
973 result
= ltt_marker_connect(channel_name
, marker_name
, "default");
975 WARN("could not enable marker; channel=%s, name=%s", channel_name
, marker_name
);
978 else if(nth_token_is(recvbuf
, "disable_marker", 0) == 1) {
979 char *channel_slash_name
= nth_token(recvbuf
, 1);
983 result
= sscanf(channel_slash_name
, "%a[^/]/%as", &channel_name
, &marker_name
);
985 if(marker_name
== NULL
) {
988 result
= ltt_marker_disconnect(channel_name
, marker_name
, "default");
990 WARN("could not disable marker; channel=%s, name=%s", channel_name
, marker_name
);
993 else if(nth_token_is(recvbuf
, "get_pidunique", 0) == 1) {
996 asprintf(&reply
, "%lld", pidunique
);
998 result
= ustcomm_send_reply(&ustcomm_app
.server
, reply
, src
);
1000 ERR("listener: get_pidunique: ustcomm_send_reply failed");
1006 else if(nth_token_is(recvbuf
, "get_sock_path", 0) == 1) {
1007 char *reply
= getenv("UST_DAEMON_SOCKET");
1009 asprintf(&reply
, "%s/%s", SOCK_DIR
, "ustd");
1010 result
= ustcomm_send_reply(&ustcomm_app
.server
, reply
, src
);
1014 result
= ustcomm_send_reply(&ustcomm_app
.server
, reply
, src
);
1017 ERR("ustcomm_send_reply failed");
1019 else if(nth_token_is(recvbuf
, "set_sock_path", 0) == 1) {
1020 char *sock_path
= nth_token(recvbuf
, 1);
1021 result
= setenv("UST_DAEMON_SOCKET", sock_path
, 1);
1023 ERR("cannot set UST_DAEMON_SOCKET environment variable");
1025 else if(nth_token_is(recvbuf
, "force_switch", 0) == 1) {
1026 do_cmd_force_switch();
1029 ERR("unable to parse message: %s", recvbuf
);
1037 void *listener_main(void *p
)
1043 pthread_cleanup_push(listener_cleanup
, NULL
);
1046 struct mpentries mpent
;
1048 multipoll_init(&mpent
);
1050 blocked_consumers_add_to_mp(&mpent
);
1051 ustcomm_mp_add_app_clients(&mpent
, &ustcomm_app
, process_client_cmd
);
1053 result
= multipoll_poll(&mpent
, -1);
1055 ERR("error in multipoll_poll");
1058 multipoll_destroy(&mpent
);
1061 pthread_cleanup_pop(1);
1064 /* These should only be accessed in the parent thread,
1067 static volatile sig_atomic_t have_listener
= 0;
1068 static pthread_t listener_thread
;
1070 void create_listener(void)
1073 sigset_t sig_all_blocked
;
1074 sigset_t orig_parent_mask
;
1077 WARN("not creating listener because we already had one");
1081 /* A new thread created by pthread_create inherits the signal mask
1082 * from the parent. To avoid any signal being received by the
1083 * listener thread, we block all signals temporarily in the parent,
1084 * while we create the listener thread.
1087 sigfillset(&sig_all_blocked
);
1089 result
= pthread_sigmask(SIG_SETMASK
, &sig_all_blocked
, &orig_parent_mask
);
1091 PERROR("pthread_sigmask: %s", strerror(result
));
1094 result
= pthread_create(&listener_thread
, NULL
, listener_main
, NULL
);
1096 PERROR("pthread_create");
1099 /* Restore original signal mask in parent */
1100 result
= pthread_sigmask(SIG_SETMASK
, &orig_parent_mask
, NULL
);
1102 PERROR("pthread_sigmask: %s", strerror(result
));
1109 static int init_socket(void)
1111 return ustcomm_init_app(getpid(), &ustcomm_app
);
1114 #define AUTOPROBE_DISABLED 0
1115 #define AUTOPROBE_ENABLE_ALL 1
1116 #define AUTOPROBE_ENABLE_REGEX 2
1117 static int autoprobe_method
= AUTOPROBE_DISABLED
;
1118 static regex_t autoprobe_regex
;
1120 static void auto_probe_connect(struct marker
*m
)
1124 char* concat_name
= NULL
;
1125 const char *probe_name
= "default";
1127 if(autoprobe_method
== AUTOPROBE_DISABLED
) {
1130 else if(autoprobe_method
== AUTOPROBE_ENABLE_REGEX
) {
1131 result
= asprintf(&concat_name
, "%s/%s", m
->channel
, m
->name
);
1133 ERR("auto_probe_connect: asprintf failed (marker %s/%s)",
1134 m
->channel
, m
->name
);
1137 if (regexec(&autoprobe_regex
, concat_name
, 0, NULL
, 0)) {
1144 result
= ltt_marker_connect(m
->channel
, m
->name
, probe_name
);
1145 if(result
&& result
!= -EEXIST
)
1146 ERR("ltt_marker_connect (marker = %s/%s, errno = %d)", m
->channel
, m
->name
, -result
);
1148 DBG("auto connected marker %s (addr: %p) %s to probe default", m
->channel
, m
, m
->name
);
1152 static void __attribute__((constructor
)) init()
1155 char* autoprobe_val
= NULL
;
1156 char* subbuffer_size_val
= NULL
;
1157 char* subbuffer_count_val
= NULL
;
1158 unsigned int subbuffer_size
;
1159 unsigned int subbuffer_count
;
1162 /* Assign the pidunique, to be able to differentiate the processes with same
1163 * pid, (before and after an exec).
1165 pidunique
= make_pidunique();
1167 DBG("Tracectl constructor");
1169 result
= init_socket();
1171 ERR("init_socket error");
1177 autoprobe_val
= getenv("UST_AUTOPROBE");
1179 struct marker_iter iter
;
1181 DBG("Autoprobe enabled.");
1183 /* Ensure markers are initialized */
1186 /* Ensure marker control is initialized, for the probe */
1187 init_marker_control();
1189 /* first, set the callback that will connect the
1190 * probe on new markers
1192 if(autoprobe_val
[0] == '/') {
1193 result
= regcomp(&autoprobe_regex
, autoprobe_val
+1, 0);
1197 regerror(result
, &autoprobe_regex
, regexerr
, sizeof(regexerr
));
1198 ERR("cannot parse regex %s (%s), will ignore UST_AUTOPROBE", autoprobe_val
, regexerr
);
1199 /* don't crash the application just for this */
1202 autoprobe_method
= AUTOPROBE_ENABLE_REGEX
;
1206 /* just enable all instrumentation */
1207 autoprobe_method
= AUTOPROBE_ENABLE_ALL
;
1210 marker_set_new_marker_cb(auto_probe_connect
);
1212 /* Now, connect the probes that were already registered. */
1213 marker_iter_reset(&iter
);
1214 marker_iter_start(&iter
);
1216 DBG("now iterating on markers already registered");
1217 while(iter
.marker
) {
1218 DBG("now iterating on marker %s", iter
.marker
->name
);
1219 auto_probe_connect(iter
.marker
);
1220 marker_iter_next(&iter
);
1224 if(getenv("UST_OVERWRITE")) {
1225 int val
= atoi(getenv("UST_OVERWRITE"));
1226 if(val
== 0 || val
== 1) {
1227 STORE_SHARED(ust_channels_overwrite_by_default
, val
);
1230 WARN("invalid value for UST_OVERWRITE");
1234 if(getenv("UST_AUTOCOLLECT")) {
1235 int val
= atoi(getenv("UST_AUTOCOLLECT"));
1236 if(val
== 0 || val
== 1) {
1237 STORE_SHARED(ust_channels_request_collection_by_default
, val
);
1240 WARN("invalid value for UST_AUTOCOLLECT");
1244 subbuffer_size_val
= getenv("UST_SUBBUF_SIZE");
1245 if(subbuffer_size_val
) {
1246 sscanf(subbuffer_size_val
, "%u", &subbuffer_size
);
1247 power
= pow2_higher_or_eq(subbuffer_size
);
1248 if(power
!= subbuffer_size
)
1249 WARN("using the next power of two for buffer size = %u\n", power
);
1250 chan_infos
[LTT_CHANNEL_UST
].def_subbufsize
= power
;
1253 subbuffer_count_val
= getenv("UST_SUBBUF_NUM");
1254 if(subbuffer_count_val
) {
1255 sscanf(subbuffer_count_val
, "%u", &subbuffer_count
);
1256 if(subbuffer_count
< 2)
1257 subbuffer_count
= 2;
1258 chan_infos
[LTT_CHANNEL_UST
].def_subbufcount
= subbuffer_count
;
1261 if(getenv("UST_TRACE")) {
1262 char trace_name
[] = "auto";
1263 char trace_type
[] = "ustrelay";
1265 DBG("starting early tracing");
1267 /* Ensure marker control is initialized */
1268 init_marker_control();
1270 /* Ensure markers are initialized */
1273 /* Ensure buffers are initialized, for the transport to be available.
1274 * We are about to set a trace type and it will fail without this.
1276 init_ustrelay_transport();
1278 /* FIXME: When starting early tracing (here), depending on the
1279 * order of constructors, it is very well possible some marker
1280 * sections are not yet registered. Because of this, some
1281 * channels may not be registered. Yet, we are about to ask the
1282 * daemon to collect the channels. Channels which are not yet
1283 * registered will not be collected.
1285 * Currently, in LTTng, there is no way to add a channel after
1286 * trace start. The reason for this is that it induces complex
1287 * concurrency issues on the trace structures, which can only
1288 * be resolved using RCU. This has not been done yet. As a
1289 * workaround, we are forcing the registration of the "ust"
1290 * channel here. This is the only channel (apart from metadata)
1291 * that can be reliably used in early tracing.
1293 * Non-early tracing does not have this problem and can use
1294 * arbitrary channel names.
1296 ltt_channels_register("ust");
1298 result
= ltt_trace_setup(trace_name
);
1300 ERR("ltt_trace_setup failed");
1304 result
= ltt_trace_set_type(trace_name
, trace_type
);
1306 ERR("ltt_trace_set_type failed");
1310 result
= ltt_trace_alloc(trace_name
);
1312 ERR("ltt_trace_alloc failed");
1316 result
= ltt_trace_start(trace_name
);
1318 ERR("ltt_trace_start failed");
1322 /* Do this after the trace is started in order to avoid creating confusion
1323 * if the trace fails to start. */
1324 inform_consumer_daemon(trace_name
);
1329 /* should decrementally destroy stuff if error */
1333 /* This is only called if we terminate normally, not with an unhandled signal,
1334 * so we cannot rely on it. However, for now, LTTV requires that the header of
1335 * the last sub-buffer contain a valid end time for the trace. This is done
1336 * automatically only when the trace is properly stopped.
1338 * If the traced program crashed, it is always possible to manually add the
1339 * right value in the header, or to open the trace in text mode.
1341 * FIXME: Fix LTTV so it doesn't need this.
1344 static void destroy_traces(void)
1348 /* if trace running, finish it */
1350 DBG("destructor stopping traces");
1352 result
= ltt_trace_stop("auto");
1354 ERR("ltt_trace_stop error");
1357 result
= ltt_trace_destroy("auto", 0);
1359 ERR("ltt_trace_destroy error");
1363 static int trace_recording(void)
1366 struct ust_trace
*trace
;
1370 list_for_each_entry(trace
, <t_traces
.head
, list
) {
1377 ltt_unlock_traces();
1383 static int have_consumer(void)
1385 return !list_empty(&blocked_consumers
);
1389 int restarting_usleep(useconds_t usecs
)
1395 tv
.tv_nsec
= usecs
* 1000;
1398 result
= nanosleep(&tv
, &tv
);
1399 } while(result
== -1 && errno
== EINTR
);
1404 static void stop_listener(void)
1411 result
= pthread_cancel(listener_thread
);
1413 ERR("pthread_cancel: %s", strerror(result
));
1415 result
= pthread_join(listener_thread
, NULL
);
1417 ERR("pthread_join: %s", strerror(result
));
1421 /* This destructor keeps the process alive for a few seconds in order
1422 * to leave time to ustd to connect to its buffers. This is necessary
1423 * for programs whose execution is very short. It is also useful in all
1424 * programs when tracing is started close to the end of the program
1427 * FIXME: For now, this only works for the first trace created in a
1431 static void __attribute__((destructor
)) keepalive()
1433 if(trace_recording() && LOAD_SHARED(buffers_to_export
)) {
1435 DBG("Keeping process alive for consumer daemon...");
1436 while(LOAD_SHARED(buffers_to_export
)) {
1437 const int interv
= 200000;
1438 restarting_usleep(interv
);
1441 if(total
>= 3000000) {
1442 WARN("non-consumed buffers remaining after wait limit; not waiting anymore");
1446 DBG("Finally dying...");
1451 /* Ask the listener to stop and clean up. */
1455 void ust_potential_exec(void)
1457 trace_mark(ust
, potential_exec
, MARK_NOARGS
);
1464 /* Notify ust that there was a fork. This needs to be called inside
1465 * the new process, anytime a process whose memory is not shared with
1466 * the parent is created. If this function is not called, the events
1467 * of the new process will not be collected.
1469 * Signals should be disabled before the fork and reenabled only after
1470 * this call in order to guarantee tracing is not started before ust_fork()
1471 * sanitizes the new process.
1474 static void ust_fork(void)
1476 struct blocked_consumer
*bc
;
1477 struct blocked_consumer
*deletable_bc
= NULL
;
1480 /* FIXME: technically, the locks could have been taken before the fork */
1481 DBG("ust: forking");
1483 /* break lock if necessary */
1484 ltt_unlock_traces();
1486 ltt_trace_stop("auto");
1487 ltt_trace_destroy("auto", 1);
1488 /* Delete all active connections */
1489 ustcomm_close_all_connections(&ustcomm_app
.server
);
1491 /* Delete all blocked consumers */
1492 list_for_each_entry(bc
, &blocked_consumers
, list
) {
1493 result
= close(bc
->fd_producer
);
1499 list_del(&bc
->list
);
1502 /* free app, keeping socket file */
1503 ustcomm_fini_app(&ustcomm_app
, 1);
1505 STORE_SHARED(buffers_to_export
, 0);
1509 ltt_trace_setup("auto");
1510 result
= ltt_trace_set_type("auto", "ustrelay");
1512 ERR("ltt_trace_set_type failed");
1516 ltt_trace_alloc("auto");
1517 ltt_trace_start("auto");
1518 inform_consumer_daemon("auto");
1521 void ust_before_fork(ust_fork_info_t
*fork_info
)
1523 /* Disable signals. This is to avoid that the child
1524 * intervenes before it is properly setup for tracing. It is
1525 * safer to disable all signals, because then we know we are not
1526 * breaking anything by restoring the original mask.
1532 - only do this if tracing is active
1535 /* Disable signals */
1536 sigfillset(&all_sigs
);
1537 result
= sigprocmask(SIG_BLOCK
, &all_sigs
, &fork_info
->orig_sigs
);
1539 PERROR("sigprocmask");
1544 /* Don't call this function directly in a traced program */
1545 static void ust_after_fork_common(ust_fork_info_t
*fork_info
)
1549 /* Restore signals */
1550 result
= sigprocmask(SIG_SETMASK
, &fork_info
->orig_sigs
, NULL
);
1552 PERROR("sigprocmask");
1557 void ust_after_fork_parent(ust_fork_info_t
*fork_info
)
1559 /* Reenable signals */
1560 ust_after_fork_common(fork_info
);
1563 void ust_after_fork_child(ust_fork_info_t
*fork_info
)
1565 /* First sanitize the child */
1568 /* Then reenable interrupts */
1569 ust_after_fork_common(fork_info
);