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/epoll.h>
31 #include <sys/types.h>
32 #include <sys/socket.h>
36 #include <urcu/uatomic_arch.h>
37 #include <urcu/list.h>
39 #include <ust/marker.h>
40 #include <ust/tracepoint.h>
41 #include <ust/tracectl.h>
46 #include "marker-control.h"
48 /* This should only be accessed by the constructor, before the creation
49 * of the listener, and then only by the listener.
53 /* The process pid is used to detect a non-traceable fork
54 * and allow the non-traceable fork to be ignored
55 * by destructor sequences in libust
57 static pid_t processpid
= 0;
59 static struct ustcomm_header _receive_header
;
60 static struct ustcomm_header
*receive_header
= &_receive_header
;
61 static char receive_buffer
[USTCOMM_BUFFER_SIZE
];
62 static char send_buffer
[USTCOMM_BUFFER_SIZE
];
65 static struct ustcomm_sock
*listen_sock
;
67 extern struct chan_info_struct chan_infos
[];
69 static struct cds_list_head open_buffers_list
= CDS_LIST_HEAD_INIT(open_buffers_list
);
71 static struct cds_list_head ust_socks
= CDS_LIST_HEAD_INIT(ust_socks
);
73 /* volatile because shared between the listener and the main thread */
74 int buffers_to_export
= 0;
76 static long long make_pidunique(void)
81 gettimeofday(&tv
, NULL
);
90 static void print_markers(FILE *fp
)
92 struct marker_iter iter
;
95 marker_iter_reset(&iter
);
96 marker_iter_start(&iter
);
99 fprintf(fp
, "marker: %s/%s %d \"%s\" %p\n",
100 iter
.marker
->channel
,
102 (int)imv_read(iter
.marker
->state
),
104 iter
.marker
->location
);
105 marker_iter_next(&iter
);
110 static void print_trace_events(FILE *fp
)
112 struct trace_event_iter iter
;
115 trace_event_iter_reset(&iter
);
116 trace_event_iter_start(&iter
);
118 while (iter
.trace_event
) {
119 fprintf(fp
, "trace_event: %s\n", iter
.trace_event
->name
);
120 trace_event_iter_next(&iter
);
122 unlock_trace_events();
125 static int connect_ustd(void)
128 char default_daemon_path
[] = SOCK_DIR
"/ustd";
129 char *explicit_daemon_path
, *daemon_path
;
131 explicit_daemon_path
= getenv("UST_DAEMON_SOCKET");
132 if (explicit_daemon_path
) {
133 daemon_path
= explicit_daemon_path
;
135 daemon_path
= default_daemon_path
;
138 DBG("Connecting to daemon_path %s", daemon_path
);
140 result
= ustcomm_connect_path(daemon_path
, &fd
);
142 WARN("connect_ustd failed, daemon_path: %s",
151 static void request_buffer_consumer(int sock
,
156 struct ustcomm_header send_header
, recv_header
;
157 struct ustcomm_buffer_info buf_inf
;
160 result
= ustcomm_pack_buffer_info(&send_header
,
167 ERR("failed to pack buffer info message %s_%d",
172 buf_inf
.pid
= getpid();
173 send_header
.command
= CONSUME_BUFFER
;
175 result
= ustcomm_req(sock
, &send_header
, (char *) &buf_inf
,
178 PERROR("request for buffer consumer failed, is the daemon online?");
184 /* Ask the daemon to collect a trace called trace_name and being
185 * produced by this pid.
187 * The trace must be at least allocated. (It can also be started.)
188 * This is because _ltt_trace_find is used.
191 static void inform_consumer_daemon(const char *trace_name
)
194 struct ust_trace
*trace
;
197 sock
= connect_ustd();
202 DBG("Connected to ustd");
206 trace
= _ltt_trace_find(trace_name
);
208 WARN("inform_consumer_daemon: could not find trace \"%s\"; it is probably already destroyed", trace_name
);
212 for (i
=0; i
< trace
->nr_channels
; i
++) {
213 if (trace
->channels
[i
].request_collection
) {
214 /* iterate on all cpus */
215 for (j
=0; j
<trace
->channels
[i
].n_cpus
; j
++) {
216 ch_name
= trace
->channels
[i
].channel_name
;
217 request_buffer_consumer(sock
, trace_name
,
219 CMM_STORE_SHARED(buffers_to_export
,
220 CMM_LOAD_SHARED(buffers_to_export
)+1);
231 static struct ust_channel
*find_channel(const char *ch_name
,
232 struct ust_trace
*trace
)
236 for (i
=0; i
<trace
->nr_channels
; i
++) {
237 if (!strcmp(trace
->channels
[i
].channel_name
, ch_name
)) {
238 return &trace
->channels
[i
];
245 static int get_buffer_shmid_pipe_fd(const char *trace_name
, const char *ch_name
,
248 int *buf_struct_shmid
,
251 struct ust_trace
*trace
;
252 struct ust_channel
*channel
;
253 struct ust_buffer
*buf
;
255 DBG("get_buffer_shmid_pipe_fd");
258 trace
= _ltt_trace_find(trace_name
);
262 ERR("cannot find trace!");
266 channel
= find_channel(ch_name
, trace
);
268 ERR("cannot find channel %s!", ch_name
);
272 buf
= channel
->buf
[ch_cpu
];
274 *buf_shmid
= buf
->shmid
;
275 *buf_struct_shmid
= channel
->buf_struct_shmids
[ch_cpu
];
276 *buf_pipe_fd
= buf
->data_ready_fd_read
;
281 static int get_subbuf_num_size(const char *trace_name
, const char *ch_name
,
284 struct ust_trace
*trace
;
285 struct ust_channel
*channel
;
287 DBG("get_subbuf_size");
290 trace
= _ltt_trace_find(trace_name
);
294 ERR("cannot find trace!");
298 channel
= find_channel(ch_name
, trace
);
300 ERR("unable to find channel");
304 *num
= channel
->subbuf_cnt
;
305 *size
= channel
->subbuf_size
;
310 /* Return the power of two which is equal or higher to v */
312 static unsigned int pow2_higher_or_eq(unsigned int v
)
315 int retval
= 1<<(hb
-1);
323 static int set_subbuf_size(const char *trace_name
, const char *ch_name
,
328 struct ust_trace
*trace
;
329 struct ust_channel
*channel
;
331 DBG("set_subbuf_size");
333 power
= pow2_higher_or_eq(size
);
334 power
= max_t(unsigned int, 2u, power
);
336 WARN("using the next power of two for buffer size = %u\n", power
);
340 trace
= _ltt_trace_find_setup(trace_name
);
342 ERR("cannot find trace!");
347 channel
= find_channel(ch_name
, trace
);
349 ERR("unable to find channel");
354 channel
->subbuf_size
= power
;
355 DBG("the set_subbuf_size for the requested channel is %u", channel
->subbuf_size
);
363 static int set_subbuf_num(const char *trace_name
, const char *ch_name
,
366 struct ust_trace
*trace
;
367 struct ust_channel
*channel
;
370 DBG("set_subbuf_num");
373 ERR("subbuffer count should be greater than 2");
378 trace
= _ltt_trace_find_setup(trace_name
);
380 ERR("cannot find trace!");
385 channel
= find_channel(ch_name
, trace
);
387 ERR("unable to find channel");
392 channel
->subbuf_cnt
= num
;
393 DBG("the set_subbuf_cnt for the requested channel is %zd", channel
->subbuf_cnt
);
400 static int get_subbuffer(const char *trace_name
, const char *ch_name
,
401 int ch_cpu
, long *consumed_old
)
404 struct ust_trace
*trace
;
405 struct ust_channel
*channel
;
406 struct ust_buffer
*buf
;
413 trace
= _ltt_trace_find(trace_name
);
416 DBG("Cannot find trace. It was likely destroyed by the user.");
421 channel
= find_channel(ch_name
, trace
);
423 ERR("unable to find channel");
428 buf
= channel
->buf
[ch_cpu
];
430 retval
= ust_buffers_get_subbuf(buf
, consumed_old
);
432 WARN("missed buffer?");
442 static int notify_buffer_mapped(const char *trace_name
,
447 struct ust_trace
*trace
;
448 struct ust_channel
*channel
;
449 struct ust_buffer
*buf
;
451 DBG("get_buffer_fd");
454 trace
= _ltt_trace_find(trace_name
);
458 DBG("Cannot find trace. It was likely destroyed by the user.");
462 channel
= find_channel(ch_name
, trace
);
465 ERR("unable to find channel");
469 buf
= channel
->buf
[ch_cpu
];
471 /* Being here is the proof the daemon has mapped the buffer in its
472 * memory. We may now decrement buffers_to_export.
474 if (uatomic_read(&buf
->consumed
) == 0) {
475 DBG("decrementing buffers_to_export");
476 CMM_STORE_SHARED(buffers_to_export
, CMM_LOAD_SHARED(buffers_to_export
)-1);
479 /* The buffer has been exported, ergo, we can add it to the
480 * list of open buffers
482 cds_list_add(&buf
->open_buffers_list
, &open_buffers_list
);
490 static int put_subbuffer(const char *trace_name
, const char *ch_name
,
491 int ch_cpu
, long consumed_old
)
494 struct ust_trace
*trace
;
495 struct ust_channel
*channel
;
496 struct ust_buffer
*buf
;
501 trace
= _ltt_trace_find(trace_name
);
505 DBG("Cannot find trace. It was likely destroyed by the user.");
509 channel
= find_channel(ch_name
, trace
);
512 ERR("unable to find channel");
516 buf
= channel
->buf
[ch_cpu
];
518 retval
= ust_buffers_put_subbuf(buf
, consumed_old
);
520 WARN("ust_buffers_put_subbuf: error (subbuf=%s_%d)",
523 DBG("ust_buffers_put_subbuf: success (subbuf=%s_%d)",
533 static void listener_cleanup(void *ptr
)
535 ustcomm_del_named_sock(listen_sock
, 0);
538 static void force_subbuf_switch()
540 struct ust_buffer
*buf
;
542 cds_list_for_each_entry(buf
, &open_buffers_list
,
544 ltt_force_switch(buf
, FORCE_FLUSH
);
548 /* Simple commands are those which need only respond with a return value. */
549 static int process_simple_client_cmd(int command
, char *recv_buf
)
554 struct ustcomm_sock_path
*sock_msg
;
555 sock_msg
= (struct ustcomm_sock_path
*)recv_buf
;
556 sock_msg
->sock_path
=
557 ustcomm_restore_ptr(sock_msg
->sock_path
,
559 sizeof(sock_msg
->data
));
560 if (!sock_msg
->sock_path
) {
564 return setenv("UST_DAEMON_SOCKET", sock_msg
->sock_path
, 1);
567 case FORCE_SUBBUF_SWITCH
:
568 /* FIXME: return codes? */
569 force_subbuf_switch();
581 static int process_trace_cmd(int command
, char *trace_name
)
584 char trace_type
[] = "ustrelay";
588 /* start is an operation that setups the trace, allocates it and starts it */
589 result
= ltt_trace_setup(trace_name
);
591 ERR("ltt_trace_setup failed");
595 result
= ltt_trace_set_type(trace_name
, trace_type
);
597 ERR("ltt_trace_set_type failed");
601 result
= ltt_trace_alloc(trace_name
);
603 ERR("ltt_trace_alloc failed");
607 inform_consumer_daemon(trace_name
);
609 result
= ltt_trace_start(trace_name
);
611 ERR("ltt_trace_start failed");
619 result
= ltt_trace_setup(trace_name
);
621 ERR("ltt_trace_setup failed");
625 result
= ltt_trace_set_type(trace_name
, trace_type
);
627 ERR("ltt_trace_set_type failed");
635 result
= ltt_trace_alloc(trace_name
);
637 ERR("ltt_trace_alloc failed");
640 inform_consumer_daemon(trace_name
);
647 result
= ltt_trace_setup(trace_name
);
649 ERR("ltt_trace_setup failed");
653 result
= ltt_trace_set_type(trace_name
, trace_type
);
655 ERR("ltt_trace_set_type failed");
663 result
= ltt_trace_alloc(trace_name
);
665 ERR("ltt_trace_alloc failed");
669 inform_consumer_daemon(trace_name
);
672 result
= ltt_trace_start(trace_name
);
674 ERR("ltt_trace_start failed");
682 result
= ltt_trace_stop(trace_name
);
684 ERR("ltt_trace_stop failed");
690 DBG("trace destroy");
692 result
= ltt_trace_destroy(trace_name
, 0);
694 ERR("ltt_trace_destroy failed");
704 static void process_channel_cmd(int sock
, int command
,
705 struct ustcomm_channel_info
*ch_inf
)
707 struct ustcomm_header _reply_header
;
708 struct ustcomm_header
*reply_header
= &_reply_header
;
709 struct ustcomm_channel_info
*reply_msg
=
710 (struct ustcomm_channel_info
*)send_buffer
;
711 int result
, offset
= 0, num
, size
;
713 memset(reply_header
, 0, sizeof(*reply_header
));
716 case GET_SUBBUF_NUM_SIZE
:
717 result
= get_subbuf_num_size(ch_inf
->trace
,
721 reply_header
->result
= result
;
725 reply_msg
->channel
= USTCOMM_POISON_PTR
;
726 reply_msg
->subbuf_num
= num
;
727 reply_msg
->subbuf_size
= size
;
730 reply_header
->size
= COMPUTE_MSG_SIZE(reply_msg
, offset
);
734 reply_header
->result
= set_subbuf_num(ch_inf
->trace
,
739 case SET_SUBBUF_SIZE
:
740 reply_header
->result
= set_subbuf_size(ch_inf
->trace
,
742 ch_inf
->subbuf_size
);
747 if (ustcomm_send(sock
, reply_header
, (char *)reply_msg
) < 0) {
748 ERR("ustcomm_send failed");
752 static void process_buffer_cmd(int sock
, int command
,
753 struct ustcomm_buffer_info
*buf_inf
)
755 struct ustcomm_header _reply_header
;
756 struct ustcomm_header
*reply_header
= &_reply_header
;
757 struct ustcomm_buffer_info
*reply_msg
=
758 (struct ustcomm_buffer_info
*)send_buffer
;
759 int result
, offset
= 0, buf_shmid
, buf_struct_shmid
, buf_pipe_fd
;
762 memset(reply_header
, 0, sizeof(*reply_header
));
765 case GET_BUF_SHMID_PIPE_FD
:
766 result
= get_buffer_shmid_pipe_fd(buf_inf
->trace
,
773 reply_header
->result
= result
;
777 reply_msg
->channel
= USTCOMM_POISON_PTR
;
778 reply_msg
->buf_shmid
= buf_shmid
;
779 reply_msg
->buf_struct_shmid
= buf_struct_shmid
;
781 reply_header
->size
= COMPUTE_MSG_SIZE(reply_msg
, offset
);
782 reply_header
->fd_included
= 1;
784 if (ustcomm_send_fd(sock
, reply_header
, (char *)reply_msg
,
786 ERR("ustcomm_send failed");
790 case NOTIFY_BUF_MAPPED
:
791 reply_header
->result
=
792 notify_buffer_mapped(buf_inf
->trace
,
797 result
= get_subbuffer(buf_inf
->trace
, buf_inf
->channel
,
798 buf_inf
->ch_cpu
, &consumed_old
);
800 reply_header
->result
= result
;
804 reply_msg
->channel
= USTCOMM_POISON_PTR
;
805 reply_msg
->consumed_old
= consumed_old
;
807 reply_header
->size
= COMPUTE_MSG_SIZE(reply_msg
, offset
);
811 result
= put_subbuffer(buf_inf
->trace
, buf_inf
->channel
,
813 buf_inf
->consumed_old
);
814 reply_header
->result
= result
;
819 if (ustcomm_send(sock
, reply_header
, (char *)reply_msg
) < 0) {
820 ERR("ustcomm_send failed");
825 static void process_marker_cmd(int sock
, int command
,
826 struct ustcomm_marker_info
*marker_inf
)
828 struct ustcomm_header _reply_header
;
829 struct ustcomm_header
*reply_header
= &_reply_header
;
832 memset(reply_header
, 0, sizeof(*reply_header
));
837 result
= ltt_marker_connect(marker_inf
->channel
,
841 WARN("could not enable marker; channel=%s,"
849 result
= ltt_marker_disconnect(marker_inf
->channel
,
853 WARN("could not disable marker; channel=%s,"
861 reply_header
->result
= result
;
863 if (ustcomm_send(sock
, reply_header
, NULL
) < 0) {
864 ERR("ustcomm_send failed");
868 static void process_client_cmd(struct ustcomm_header
*recv_header
,
869 char *recv_buf
, int sock
)
872 struct ustcomm_header _reply_header
;
873 struct ustcomm_header
*reply_header
= &_reply_header
;
874 char *send_buf
= send_buffer
;
876 memset(reply_header
, 0, sizeof(*reply_header
));
877 memset(send_buf
, 0, sizeof(send_buffer
));
879 switch(recv_header
->command
) {
880 case GET_SUBBUF_NUM_SIZE
:
882 case SET_SUBBUF_SIZE
:
884 struct ustcomm_channel_info
*ch_inf
;
885 ch_inf
= (struct ustcomm_channel_info
*)recv_buf
;
886 result
= ustcomm_unpack_channel_info(ch_inf
);
888 ERR("couldn't unpack channel info");
889 reply_header
->result
= -EINVAL
;
892 process_channel_cmd(sock
, recv_header
->command
, ch_inf
);
895 case GET_BUF_SHMID_PIPE_FD
:
896 case NOTIFY_BUF_MAPPED
:
900 struct ustcomm_buffer_info
*buf_inf
;
901 buf_inf
= (struct ustcomm_buffer_info
*)recv_buf
;
902 result
= ustcomm_unpack_buffer_info(buf_inf
);
904 ERR("couldn't unpack buffer info");
905 reply_header
->result
= -EINVAL
;
908 process_buffer_cmd(sock
, recv_header
->command
, buf_inf
);
914 struct ustcomm_marker_info
*marker_inf
;
915 marker_inf
= (struct ustcomm_marker_info
*)recv_buf
;
916 result
= ustcomm_unpack_marker_info(marker_inf
);
918 ERR("couldn't unpack marker info");
919 reply_header
->result
= -EINVAL
;
922 process_marker_cmd(sock
, recv_header
->command
, marker_inf
);
931 fp
= open_memstream(&ptr
, &size
);
933 ERR("opening memstream failed");
939 reply_header
->size
= size
;
941 result
= ustcomm_send(sock
, reply_header
, ptr
);
946 PERROR("failed to send markers list");
951 case LIST_TRACE_EVENTS
:
957 fp
= open_memstream(&ptr
, &size
);
959 ERR("opening memstream failed");
962 print_trace_events(fp
);
965 reply_header
->size
= size
;
967 result
= ustcomm_send(sock
, reply_header
, ptr
);
972 ERR("list_trace_events failed");
982 /* FIXME: No functionality at all... */
985 DBG("load_probe_lib loading %s", libfile
);
991 struct ustcomm_pidunique
*pid_msg
;
992 pid_msg
= (struct ustcomm_pidunique
*)send_buf
;
994 pid_msg
->pidunique
= pidunique
;
995 reply_header
->size
= sizeof(pid_msg
);
1002 struct ustcomm_sock_path
*sock_msg
;
1003 char *sock_path_env
;
1005 sock_msg
= (struct ustcomm_sock_path
*)send_buf
;
1007 sock_path_env
= getenv("UST_DAEMON_SOCKET");
1009 if (!sock_path_env
) {
1010 result
= ustcomm_pack_sock_path(reply_header
,
1015 result
= ustcomm_pack_sock_path(reply_header
,
1019 reply_header
->result
= result
;
1031 struct ustcomm_trace_info
*trace_inf
=
1032 (struct ustcomm_trace_info
*)recv_buf
;
1034 result
= ustcomm_unpack_trace_info(trace_inf
);
1036 ERR("couldn't unpack trace info");
1037 reply_header
->result
= -EINVAL
;
1041 reply_header
->result
=
1042 process_trace_cmd(recv_header
->command
,
1048 reply_header
->result
=
1049 process_simple_client_cmd(recv_header
->command
,
1058 ustcomm_send(sock
, reply_header
, send_buf
);
1061 #define MAX_EVENTS 10
1063 void *listener_main(void *p
)
1065 struct ustcomm_sock
*epoll_sock
;
1066 struct epoll_event events
[MAX_EVENTS
];
1067 struct sockaddr addr
;
1068 int accept_fd
, nfds
, result
, i
, addr_size
;
1072 pthread_cleanup_push(listener_cleanup
, NULL
);
1075 nfds
= epoll_wait(epoll_fd
, events
, MAX_EVENTS
, -1);
1077 PERROR("listener_main: epoll_wait failed");
1081 for (i
= 0; i
< nfds
; i
++) {
1082 epoll_sock
= (struct ustcomm_sock
*)events
[i
].data
.ptr
;
1083 if (epoll_sock
== listen_sock
) {
1084 addr_size
= sizeof(struct sockaddr
);
1085 accept_fd
= accept(epoll_sock
->fd
,
1087 (socklen_t
*)&addr_size
);
1088 if (accept_fd
== -1) {
1089 PERROR("listener_main: accept failed");
1092 ustcomm_init_sock(accept_fd
, epoll_fd
,
1095 memset(receive_header
, 0,
1096 sizeof(*receive_header
));
1097 memset(receive_buffer
, 0,
1098 sizeof(receive_buffer
));
1099 result
= ustcomm_recv(epoll_sock
->fd
,
1103 ustcomm_del_sock(epoll_sock
, 0);
1105 process_client_cmd(receive_header
,
1113 pthread_cleanup_pop(1);
1116 /* These should only be accessed in the parent thread,
1119 static volatile sig_atomic_t have_listener
= 0;
1120 static pthread_t listener_thread
;
1122 void create_listener(void)
1125 sigset_t sig_all_blocked
;
1126 sigset_t orig_parent_mask
;
1128 if (have_listener
) {
1129 WARN("not creating listener because we already had one");
1133 /* A new thread created by pthread_create inherits the signal mask
1134 * from the parent. To avoid any signal being received by the
1135 * listener thread, we block all signals temporarily in the parent,
1136 * while we create the listener thread.
1139 sigfillset(&sig_all_blocked
);
1141 result
= pthread_sigmask(SIG_SETMASK
, &sig_all_blocked
, &orig_parent_mask
);
1143 PERROR("pthread_sigmask: %s", strerror(result
));
1146 result
= pthread_create(&listener_thread
, NULL
, listener_main
, NULL
);
1148 PERROR("pthread_create");
1151 /* Restore original signal mask in parent */
1152 result
= pthread_sigmask(SIG_SETMASK
, &orig_parent_mask
, NULL
);
1154 PERROR("pthread_sigmask: %s", strerror(result
));
1160 #define AUTOPROBE_DISABLED 0
1161 #define AUTOPROBE_ENABLE_ALL 1
1162 #define AUTOPROBE_ENABLE_REGEX 2
1163 static int autoprobe_method
= AUTOPROBE_DISABLED
;
1164 static regex_t autoprobe_regex
;
1166 static void auto_probe_connect(struct marker
*m
)
1170 char* concat_name
= NULL
;
1171 const char *probe_name
= "default";
1173 if (autoprobe_method
== AUTOPROBE_DISABLED
) {
1175 } else if (autoprobe_method
== AUTOPROBE_ENABLE_REGEX
) {
1176 result
= asprintf(&concat_name
, "%s/%s", m
->channel
, m
->name
);
1178 ERR("auto_probe_connect: asprintf failed (marker %s/%s)",
1179 m
->channel
, m
->name
);
1182 if (regexec(&autoprobe_regex
, concat_name
, 0, NULL
, 0)) {
1189 result
= ltt_marker_connect(m
->channel
, m
->name
, probe_name
);
1190 if (result
&& result
!= -EEXIST
)
1191 ERR("ltt_marker_connect (marker = %s/%s, errno = %d)", m
->channel
, m
->name
, -result
);
1193 DBG("auto connected marker %s (addr: %p) %s to probe default", m
->channel
, m
, m
->name
);
1197 static struct ustcomm_sock
* init_app_socket(int epoll_fd
)
1201 struct ustcomm_sock
*sock
;
1203 result
= asprintf(&name
, "%s/%d", SOCK_DIR
, (int)getpid());
1205 ERR("string overflow allocating socket name, "
1206 "UST thread bailing");
1210 result
= ensure_dir_exists(SOCK_DIR
);
1212 ERR("Unable to create socket directory %s, UST thread bailing",
1217 sock
= ustcomm_init_named_socket(name
, epoll_fd
);
1219 ERR("Error initializing named socket (%s). Check that directory"
1220 "exists and that it is writable. UST thread bailing", name
);
1232 static void __attribute__((constructor
)) init()
1235 char* autoprobe_val
= NULL
;
1236 char* subbuffer_size_val
= NULL
;
1237 char* subbuffer_count_val
= NULL
;
1238 unsigned int subbuffer_size
;
1239 unsigned int subbuffer_count
;
1242 /* Assign the pidunique, to be able to differentiate the processes with same
1243 * pid, (before and after an exec).
1245 pidunique
= make_pidunique();
1246 processpid
= getpid();
1248 DBG("Tracectl constructor");
1251 epoll_fd
= epoll_create(MAX_EVENTS
);
1252 if (epoll_fd
== -1) {
1253 ERR("epoll_create failed, tracing shutting down");
1257 /* Create the socket */
1258 listen_sock
= init_app_socket(epoll_fd
);
1260 ERR("failed to create application socket,"
1261 " tracing shutting down");
1267 autoprobe_val
= getenv("UST_AUTOPROBE");
1268 if (autoprobe_val
) {
1269 struct marker_iter iter
;
1271 DBG("Autoprobe enabled.");
1273 /* Ensure markers are initialized */
1276 /* Ensure marker control is initialized, for the probe */
1277 init_marker_control();
1279 /* first, set the callback that will connect the
1280 * probe on new markers
1282 if (autoprobe_val
[0] == '/') {
1283 result
= regcomp(&autoprobe_regex
, autoprobe_val
+1, 0);
1287 regerror(result
, &autoprobe_regex
, regexerr
, sizeof(regexerr
));
1288 ERR("cannot parse regex %s (%s), will ignore UST_AUTOPROBE", autoprobe_val
, regexerr
);
1289 /* don't crash the application just for this */
1291 autoprobe_method
= AUTOPROBE_ENABLE_REGEX
;
1294 /* just enable all instrumentation */
1295 autoprobe_method
= AUTOPROBE_ENABLE_ALL
;
1298 marker_set_new_marker_cb(auto_probe_connect
);
1300 /* Now, connect the probes that were already registered. */
1301 marker_iter_reset(&iter
);
1302 marker_iter_start(&iter
);
1304 DBG("now iterating on markers already registered");
1305 while (iter
.marker
) {
1306 DBG("now iterating on marker %s", iter
.marker
->name
);
1307 auto_probe_connect(iter
.marker
);
1308 marker_iter_next(&iter
);
1312 if (getenv("UST_OVERWRITE")) {
1313 int val
= atoi(getenv("UST_OVERWRITE"));
1314 if (val
== 0 || val
== 1) {
1315 CMM_STORE_SHARED(ust_channels_overwrite_by_default
, val
);
1317 WARN("invalid value for UST_OVERWRITE");
1321 if (getenv("UST_AUTOCOLLECT")) {
1322 int val
= atoi(getenv("UST_AUTOCOLLECT"));
1323 if (val
== 0 || val
== 1) {
1324 CMM_STORE_SHARED(ust_channels_request_collection_by_default
, val
);
1326 WARN("invalid value for UST_AUTOCOLLECT");
1330 subbuffer_size_val
= getenv("UST_SUBBUF_SIZE");
1331 if (subbuffer_size_val
) {
1332 sscanf(subbuffer_size_val
, "%u", &subbuffer_size
);
1333 power
= pow2_higher_or_eq(subbuffer_size
);
1334 if (power
!= subbuffer_size
)
1335 WARN("using the next power of two for buffer size = %u\n", power
);
1336 chan_infos
[LTT_CHANNEL_UST
].def_subbufsize
= power
;
1339 subbuffer_count_val
= getenv("UST_SUBBUF_NUM");
1340 if (subbuffer_count_val
) {
1341 sscanf(subbuffer_count_val
, "%u", &subbuffer_count
);
1342 if (subbuffer_count
< 2)
1343 subbuffer_count
= 2;
1344 chan_infos
[LTT_CHANNEL_UST
].def_subbufcount
= subbuffer_count
;
1347 if (getenv("UST_TRACE")) {
1348 char trace_name
[] = "auto";
1349 char trace_type
[] = "ustrelay";
1351 DBG("starting early tracing");
1353 /* Ensure marker control is initialized */
1354 init_marker_control();
1356 /* Ensure markers are initialized */
1359 /* Ensure buffers are initialized, for the transport to be available.
1360 * We are about to set a trace type and it will fail without this.
1362 init_ustrelay_transport();
1364 /* FIXME: When starting early tracing (here), depending on the
1365 * order of constructors, it is very well possible some marker
1366 * sections are not yet registered. Because of this, some
1367 * channels may not be registered. Yet, we are about to ask the
1368 * daemon to collect the channels. Channels which are not yet
1369 * registered will not be collected.
1371 * Currently, in LTTng, there is no way to add a channel after
1372 * trace start. The reason for this is that it induces complex
1373 * concurrency issues on the trace structures, which can only
1374 * be resolved using RCU. This has not been done yet. As a
1375 * workaround, we are forcing the registration of the "ust"
1376 * channel here. This is the only channel (apart from metadata)
1377 * that can be reliably used in early tracing.
1379 * Non-early tracing does not have this problem and can use
1380 * arbitrary channel names.
1382 ltt_channels_register("ust");
1384 result
= ltt_trace_setup(trace_name
);
1386 ERR("ltt_trace_setup failed");
1390 result
= ltt_trace_set_type(trace_name
, trace_type
);
1392 ERR("ltt_trace_set_type failed");
1396 result
= ltt_trace_alloc(trace_name
);
1398 ERR("ltt_trace_alloc failed");
1402 result
= ltt_trace_start(trace_name
);
1404 ERR("ltt_trace_start failed");
1408 /* Do this after the trace is started in order to avoid creating confusion
1409 * if the trace fails to start. */
1410 inform_consumer_daemon(trace_name
);
1415 /* should decrementally destroy stuff if error */
1419 /* This is only called if we terminate normally, not with an unhandled signal,
1420 * so we cannot rely on it. However, for now, LTTV requires that the header of
1421 * the last sub-buffer contain a valid end time for the trace. This is done
1422 * automatically only when the trace is properly stopped.
1424 * If the traced program crashed, it is always possible to manually add the
1425 * right value in the header, or to open the trace in text mode.
1427 * FIXME: Fix LTTV so it doesn't need this.
1430 static void destroy_traces(void)
1434 /* if trace running, finish it */
1436 DBG("destructor stopping traces");
1438 result
= ltt_trace_stop("auto");
1440 ERR("ltt_trace_stop error");
1443 result
= ltt_trace_destroy("auto", 0);
1445 ERR("ltt_trace_destroy error");
1449 static int trace_recording(void)
1452 struct ust_trace
*trace
;
1456 cds_list_for_each_entry(trace
, <t_traces
.head
, list
) {
1457 if (trace
->active
) {
1463 ltt_unlock_traces();
1468 int restarting_usleep(useconds_t usecs
)
1474 tv
.tv_nsec
= usecs
* 1000;
1477 result
= nanosleep(&tv
, &tv
);
1478 } while (result
== -1 && errno
== EINTR
);
1483 static void stop_listener(void)
1490 result
= pthread_cancel(listener_thread
);
1492 ERR("pthread_cancel: %s", strerror(result
));
1494 result
= pthread_join(listener_thread
, NULL
);
1496 ERR("pthread_join: %s", strerror(result
));
1500 /* This destructor keeps the process alive for a few seconds in order
1501 * to leave time to ustd to connect to its buffers. This is necessary
1502 * for programs whose execution is very short. It is also useful in all
1503 * programs when tracing is started close to the end of the program
1506 * FIXME: For now, this only works for the first trace created in a
1510 static void __attribute__((destructor
)) keepalive()
1512 if (processpid
!= getpid()) {
1516 if (trace_recording() && CMM_LOAD_SHARED(buffers_to_export
)) {
1518 DBG("Keeping process alive for consumer daemon...");
1519 while (CMM_LOAD_SHARED(buffers_to_export
)) {
1520 const int interv
= 200000;
1521 restarting_usleep(interv
);
1524 if (total
>= 3000000) {
1525 WARN("non-consumed buffers remaining after wait limit; not waiting anymore");
1529 DBG("Finally dying...");
1534 /* Ask the listener to stop and clean up. */
1538 void ust_potential_exec(void)
1540 trace_mark(ust
, potential_exec
, MARK_NOARGS
);
1547 /* Notify ust that there was a fork. This needs to be called inside
1548 * the new process, anytime a process whose memory is not shared with
1549 * the parent is created. If this function is not called, the events
1550 * of the new process will not be collected.
1552 * Signals should be disabled before the fork and reenabled only after
1553 * this call in order to guarantee tracing is not started before ust_fork()
1554 * sanitizes the new process.
1557 static void ust_fork(void)
1559 struct ust_buffer
*buf
, *buf_tmp
;
1560 struct ustcomm_sock
*sock
, *sock_tmp
;
1563 /* FIXME: technically, the locks could have been taken before the fork */
1564 DBG("ust: forking");
1566 /* Get the pid of the new process */
1567 processpid
= getpid();
1569 /* break lock if necessary */
1570 ltt_unlock_traces();
1572 ltt_trace_stop("auto");
1573 ltt_trace_destroy("auto", 1);
1574 /* Delete all active connections, but leave them in the epoll set */
1575 cds_list_for_each_entry_safe(sock
, sock_tmp
, &ust_socks
, list
) {
1576 ustcomm_del_sock(sock
, 1);
1579 /* Delete all blocked consumers */
1580 cds_list_for_each_entry_safe(buf
, buf_tmp
, &open_buffers_list
,
1581 open_buffers_list
) {
1582 result
= close(buf
->data_ready_fd_read
);
1586 result
= close(buf
->data_ready_fd_write
);
1590 cds_list_del(&buf
->open_buffers_list
);
1593 /* Clean up the listener socket and epoll, keeping the scoket file */
1594 ustcomm_del_named_sock(listen_sock
, 1);
1597 /* Re-start the launch sequence */
1598 CMM_STORE_SHARED(buffers_to_export
, 0);
1602 epoll_fd
= epoll_create(MAX_EVENTS
);
1603 if (epoll_fd
== -1) {
1604 ERR("epoll_create failed, tracing shutting down");
1608 /* Create the socket */
1609 listen_sock
= init_app_socket(epoll_fd
);
1611 ERR("failed to create application socket,"
1612 " tracing shutting down");
1616 ltt_trace_setup("auto");
1617 result
= ltt_trace_set_type("auto", "ustrelay");
1619 ERR("ltt_trace_set_type failed");
1623 ltt_trace_alloc("auto");
1624 ltt_trace_start("auto");
1625 inform_consumer_daemon("auto");
1628 void ust_before_fork(ust_fork_info_t
*fork_info
)
1630 /* Disable signals. This is to avoid that the child
1631 * intervenes before it is properly setup for tracing. It is
1632 * safer to disable all signals, because then we know we are not
1633 * breaking anything by restoring the original mask.
1639 - only do this if tracing is active
1642 /* Disable signals */
1643 sigfillset(&all_sigs
);
1644 result
= sigprocmask(SIG_BLOCK
, &all_sigs
, &fork_info
->orig_sigs
);
1646 PERROR("sigprocmask");
1651 /* Don't call this function directly in a traced program */
1652 static void ust_after_fork_common(ust_fork_info_t
*fork_info
)
1656 /* Restore signals */
1657 result
= sigprocmask(SIG_SETMASK
, &fork_info
->orig_sigs
, NULL
);
1659 PERROR("sigprocmask");
1664 void ust_after_fork_parent(ust_fork_info_t
*fork_info
)
1666 /* Reenable signals */
1667 ust_after_fork_common(fork_info
);
1670 void ust_after_fork_child(ust_fork_info_t
*fork_info
)
1672 /* First sanitize the child */
1675 /* Then reenable interrupts */
1676 ust_after_fork_common(fork_info
);