X-Git-Url: http://git.lttng.org./?a=blobdiff_plain;ds=sidebyside;f=libtracectl%2Ftracectl.c;h=2c64c10e420366879d74cdf2330620cc39b1d285;hb=09938485689f3482ec845e52d5bf5e78c1093e27;hp=aca3abc207ae81ad60067778e717a7c11b3ebe92;hpb=68c1021b2136a6aea5dbbe138c5103e30b5d8712;p=lttng-ust.git diff --git a/libtracectl/tracectl.c b/libtracectl/tracectl.c index aca3abc2..2c64c10e 100644 --- a/libtracectl/tracectl.c +++ b/libtracectl/tracectl.c @@ -4,6 +4,10 @@ #include #include #include +#include + +#include "marker.h" + #define UNIX_PATH_MAX 108 //#define SOCKETDIR "/var/run/ust/socks" @@ -16,14 +20,46 @@ #define ERR(fmt, args...) fprintf(stderr, "usertrace: ERROR: " fmt "\n", ## args) #define PERROR(call) perror("usertrace: ERROR: " call) +#define MAX_MSG_SIZE (100) +#define MSG_NOTIF 1 +#define MSG_REGISTER_NOTIF 2 + struct tracecmd { /* no padding */ uint32_t size; uint16_t command; }; +//struct listener_arg { +// int pipe_fd; +//}; + +struct trctl_msg { + /* size: the size of all the fields except size itself */ + uint32_t size; + uint16_t type; + /* Only the necessary part of the payload is transferred. It + * may even be none of it. + */ + char payload[94]; +}; pid_t mypid; char mysocketfile[UNIX_PATH_MAX] = ""; +int pfd = -1; + + +static void print_markers(void) +{ + struct marker_iter iter; + + marker_iter_reset(&iter); + marker_iter_start(&iter); + + while(iter.marker) { + fprintf(stderr, "marker: %s_%s \"%s\"\n", iter.marker->channel, iter.marker->name, iter.marker->format); + marker_iter_next(&iter); + } +} void do_command(struct tracecmd *cmd) { @@ -33,22 +69,144 @@ void receive_commands() { } +int fd_notif = -1; +void notif_cb(void) +{ + int result; + struct trctl_msg msg; + + /* FIXME: fd_notif should probably be protected by a spinlock */ + + if(fd_notif == -1) + return; + + msg.type = MSG_NOTIF; + msg.size = sizeof(msg.type); + + /* FIXME: don't block here */ + result = write(fd_notif, &msg, msg.size+sizeof(msg.size)); + if(result == -1) { + PERROR("write"); + return; + } +} + +char recvbuf[10000]; + +int listener_main(void *p) +{ + int result; + + for(;;) { + uint32_t size; + struct sockaddr_un addr; + socklen_t addrlen = sizeof(addr); + char trace_name[] = "auto"; + char trace_type[] = "ustrelay"; + + for(;;) { + struct trctl_msg msg; + int len; + + result = len = recvfrom(pfd, recvbuf, sizeof(recvbuf), 0, &addr, &addrlen); + if(result == -1) { + PERROR("recvfrom"); + continue; + } + + if(recvbuf[len-1] == '\n') + recvbuf[len-1] = '\0'; + + fprintf(stderr, "received a message! it's: %s\n", recvbuf); + + + if(!strcmp(recvbuf, "print_markers")) { + print_markers(); + } + else if(!strcmp(recvbuf, "trace_setup")) { + DBG("trace setup"); + + result = ltt_trace_setup(trace_name); + if(result < 0) { + ERR("ltt_trace_setup failed"); + return; + } + + result = ltt_trace_set_type(trace_name, trace_type); + if(result < 0) { + ERR("ltt_trace_set_type failed"); + return; + } + } + else if(!strcmp(recvbuf, "trace_alloc")) { + DBG("trace alloc"); + + result = ltt_trace_alloc(trace_name); + if(result < 0) { + ERR("ltt_trace_alloc failed"); + return; + } + } + else if(!strcmp(recvbuf, "trace_start")) { + DBG("trace start"); + + result = ltt_trace_start(trace_name); + if(result < 0) { + ERR("ltt_trace_start failed"); + return; + } + } + else if(!strcmp(recvbuf, "trace_stop")) { + DBG("trace stop"); + + result = ltt_trace_stop(trace_name); + if(result < 0) { + ERR("ltt_trace_stop failed"); + return; + } + } + else if(!strcmp(recvbuf, "trace_destroy")) { + + DBG("trace destroy"); + + result = ltt_trace_destroy(trace_name); + if(result < 0) { + ERR("ltt_trace_destroy failed"); + return; + } + } + } + next_conn:; + } +} + +void create_listener(void) +{ + int result; + static char listener_stack[16384]; + + result = clone(listener_main, listener_stack+sizeof(listener_stack)-1, CLONE_FS | CLONE_FILES | CLONE_VM | CLONE_SIGHAND | CLONE_THREAD, NULL); + if(result == -1) { + perror("clone"); + } +} + /* The signal handler itself. */ void sighandler(int sig) { DBG("sighandler"); - receive_commands(); + create_listener(); } /* Called by the app signal handler to chain it to us. */ -void chain_signal() +void chain_signal(void) { sighandler(USTSIGNAL); } -int init_socket() +static int init_socket(void) { int result; int fd; @@ -57,7 +215,7 @@ int init_socket() struct sockaddr_un addr; - result = fd = socket(PF_UNIX, SOCK_SEQPACKET, 0); + result = fd = socket(PF_UNIX, SOCK_DGRAM, 0); if(result == -1) { PERROR("socket"); return -1; @@ -80,13 +238,16 @@ int init_socket() strcpy(mysocketfile, addr.sun_path); + pfd = fd; + return 0; + close_sock: close(fd); return -1; } -void destroy_socket() +static void destroy_socket(void) { int result; @@ -99,7 +260,7 @@ void destroy_socket() } } -int init_signal_handler(void) +static int init_signal_handler(void) { /* Attempt to handler SIGIO. If the main program wants to * handle it, fine, it'll override us. They it'll have to @@ -130,15 +291,73 @@ int init_signal_handler(void) return 0; } -void __attribute__((constructor)) init() +static void __attribute__((constructor)) init() { int result; mypid = getpid(); - /* if using instead seperate thread, then should create thread */ - result = init_signal_handler(); + if(getenv("UST_TRACE")) { + char trace_name[] = "auto"; + char trace_type[] = "ustrelay"; + + DBG("starting early tracing"); + + /* Ensure marker control is initialized */ + init_marker_control(); + + /* Ensure relay is initialized */ + init_ustrelay_transport(); + + /* Ensure markers are initialized */ + init_markers(); + + result = ltt_marker_connect("foo", "bar", "default"); + if(result) + ERR("ltt_marker_connect"); + + result = ltt_marker_connect("foo", "bar2", "default"); + if(result) + ERR("ltt_marker_connect"); + + result = ltt_trace_setup(trace_name); + if(result < 0) { + ERR("ltt_trace_setup failed"); + return; + } + + result = ltt_trace_set_type(trace_name, trace_type); + if(result < 0) { + ERR("ltt_trace_set_type failed"); + return; + } + + result = ltt_trace_alloc(trace_name); + if(result < 0) { + ERR("ltt_trace_alloc failed"); + return; + } + + result = ltt_trace_start(trace_name); + if(result < 0) { + ERR("ltt_trace_start failed"); + return; + } + } + + /* Must create socket before signal handler to prevent races + * on pfd variable. + */ result = init_socket(); + if(result == -1) { + ERR("init_socket error"); + return; + } + result = init_signal_handler(); + if(result == -1) { + ERR("init_signal_handler error"); + return; + } return; @@ -149,7 +368,7 @@ void __attribute__((constructor)) init() /* This is only called if we terminate normally, not with an unhandled signal, * so we cannot rely on it. */ -void __attribute__((destructor)) fini() +static void __attribute__((destructor)) fini() { destroy_socket(); }