X-Git-Url: http://git.lttng.org/?a=blobdiff_plain;f=libtracectl%2Ftracectl.c;h=176ee6a92bace99333becc45c65d6a117eabc3ad;hb=811e4b93ba6acb72226a9243ae9a525f444e7e80;hp=04de9f39be695194187f7c7b816091990aed67c1;hpb=fbd8191b00521bbe7e52a6d1ff4bb814708f06ba;p=ust.git diff --git a/libtracectl/tracectl.c b/libtracectl/tracectl.c index 04de9f3..176ee6a 100644 --- a/libtracectl/tracectl.c +++ b/libtracectl/tracectl.c @@ -5,25 +5,29 @@ #include #include #include +#include #include "marker.h" +#include "tracer.h" +#include "localerr.h" +#include "ustcomm.h" + +//#define USE_CLONE #define UNIX_PATH_MAX 108 -//#define SOCKETDIR "/var/run/ust/socks" #define SOCKETDIR "/tmp/socks" #define SOCKETDIRLEN sizeof(SOCKETDIR) #define USTSIGNAL SIGIO -#define DBG(fmt, args...) fprintf(stderr, fmt "\n", ## args) -#define WARN(fmt, args...) fprintf(stderr, "usertrace: WARNING: " fmt "\n", ## args) -#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 +char consumer_stack[10000]; + +static struct ustcomm_app ustcomm_app; + struct tracecmd { /* no padding */ uint32_t size; uint16_t command; @@ -43,15 +47,141 @@ struct trctl_msg { char payload[94]; }; -pid_t mypid; char mysocketfile[UNIX_PATH_MAX] = ""; -int pfd = -1; +//int pfd = -1; + +struct consumer_channel { + int fd; + struct ltt_channel_struct *chan; +}; + +int consumer(void *arg) +{ + int result; + int fd; + char str[] = "Hello, this is the consumer.\n"; + struct ltt_trace_struct *trace; + struct consumer_channel *consumer_channels; + int i; + char trace_name[] = "auto"; + + ltt_lock_traces(); + trace = _ltt_trace_find(trace_name); + ltt_unlock_traces(); + + if(trace == NULL) { + CPRINTF("cannot find trace!"); + return 1; + } + + consumer_channels = (struct consumer_channel *) malloc(trace->nr_channels * sizeof(struct consumer_channel)); + if(consumer_channels == NULL) { + ERR("malloc returned NULL"); + return 1; + } + + CPRINTF("opening trace files"); + for(i=0; inr_channels; i++) { + char tmp[100]; + struct ltt_channel_struct *chan = &trace->channels[i]; + + consumer_channels[i].chan = chan; + + snprintf(tmp, sizeof(tmp), "trace/%s_0", chan->channel_name); + result = consumer_channels[i].fd = open(tmp, O_WRONLY | O_CREAT | O_TRUNC, 00644); + if(result == -1) { + perror("open"); + return -1; + } + CPRINTF("\topened trace file %s", tmp); + + } + CPRINTF("done opening trace files"); + + for(;;) { + /*wait*/ + + for(i=0; inr_channels; i++) { + struct rchan *rchan = consumer_channels[i].chan->trans_channel_data; + struct rchan_buf *rbuf = rchan->buf; + struct ltt_channel_buf_struct *lttbuf = consumer_channels[i].chan->buf; + long consumed_old; + + result = ltt_do_get_subbuf(rbuf, lttbuf, &consumed_old); + if(result < 0) { + DBG("ltt_do_get_subbuf: error: %s", strerror(-result)); + } + else { + DBG("success!"); + + result = write(consumer_channels[i].fd, rbuf->buf_data + (consumed_old & (2 * 4096-1)), 4096); + ltt_do_put_subbuf(rbuf, lttbuf, consumed_old); + } + } + + sleep(1); + } + +// CPRINTF("consumer: got a trace: %s with %d channels\n", trace_name, trace->nr_channels); +// +// struct ltt_channel_struct *chan = &trace->channels[0]; +// +// CPRINTF("channel 1 (%s) active=%u", chan->channel_name, chan->active & 1); + +// struct rchan *rchan = chan->trans_channel_data; +// struct rchan_buf *rbuf = rchan->buf; +// struct ltt_channel_buf_struct *lttbuf = chan->buf; +// long consumed_old; +// +// result = fd = open("trace.out", O_WRONLY | O_CREAT | O_TRUNC, 00644); +// if(result == -1) { +// perror("open"); +// return -1; +// } + +// for(;;) { +// write(STDOUT_FILENO, str, sizeof(str)); +// +// result = ltt_do_get_subbuf(rbuf, lttbuf, &consumed_old); +// if(result < 0) { +// CPRINTF("ltt_do_get_subbuf: error: %s", strerror(-result)); +// } +// else { +// CPRINTF("success!"); +// +// result = write(fd, rbuf->buf_data + (consumed_old & (2 * 4096-1)), 4096); +// ltt_do_put_subbuf(rbuf, lttbuf, consumed_old); +// } +// +// //CPRINTF("There seems to be %ld bytes available", SUBBUF_TRUNC(local_read(<tbuf->offset), rbuf->chan) - consumed_old); +// CPRINTF("Commit count %ld", local_read(<tbuf->commit_count[0])); +// +// +// sleep(1); +// } +} + +void start_consumer(void) +{ +#ifdef USE_CLONE + int result; + + result = clone(consumer, consumer_stack+sizeof(consumer_stack)-1, CLONE_FS | CLONE_FILES | CLONE_VM | CLONE_SIGHAND | CLONE_THREAD, NULL); + if(result == -1) { + perror("clone"); + } +#else + pthread_t thread; + pthread_create(&thread, NULL, consumer, NULL); +#endif +} static void print_markers(void) { struct marker_iter iter; + lock_markers(); marker_iter_reset(&iter); marker_iter_start(&iter); @@ -59,6 +189,7 @@ static void print_markers(void) fprintf(stderr, "marker: %s_%s \"%s\"\n", iter.marker->channel, iter.marker->name, iter.marker->format); marker_iter_next(&iter); } + unlock_markers(); } void do_command(struct tracecmd *cmd) @@ -91,70 +222,276 @@ void notif_cb(void) } } -char recvbuf[10000]; +#define CONSUMER_DAEMON_SOCK SOCKETDIR "/ustd" + +static int inform_consumer_daemon(void) +{ + ustcomm_request_consumer(getpid(), "metadata"); + ustcomm_request_consumer(getpid(), "ust"); +} int listener_main(void *p) { int result; + DBG("LISTENER"); + for(;;) { uint32_t size; struct sockaddr_un addr; socklen_t addrlen = sizeof(addr); + char trace_name[] = "auto"; + char trace_type[] = "ustrelay"; + char *recvbuf; + int len; + struct ustcomm_source src; + + result = ustcomm_app_recv_message(&ustcomm_app, &recvbuf, &src); + DBG("HERE"); + if(result) { + WARN("error in ustcomm_app_recv_message"); + continue; + } + + DBG("received a message! it's: %s\n", recvbuf); + len = strlen(recvbuf); + //if(len && recvbuf[len-1] == '\n') { + // recvbuf[len-1] = '\0'; + //} - for(;;) { - struct trctl_msg msg; - int len; + 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 = len = recvfrom(pfd, recvbuf, sizeof(recvbuf), 0, &addr, &addrlen); - if(result == -1) { - PERROR("recvfrom"); + 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"); continue; } + } + 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")) { - if(recvbuf[len-2] == '\n') - recvbuf[len-2] = '\0'; + DBG("trace destroy"); - fprintf(stderr, "received a message! it's: %s\n", recvbuf); + result = ltt_trace_destroy(trace_name); + if(result < 0) { + ERR("ltt_trace_destroy failed"); + return; + } + } + else if(nth_token_is(recvbuf, "get_shmid", 0) == 1) { + struct ltt_trace_struct *trace; + char trace_name[] = "auto"; + int i; + char *channel_name; + + DBG("get_shmid"); + + channel_name = nth_token(recvbuf, 1); + if(channel_name == NULL) { + ERR("get_shmid: cannot parse channel"); + goto next_cmd; + } + ltt_lock_traces(); + trace = _ltt_trace_find(trace_name); + ltt_unlock_traces(); - if(!strcmp(recvbuf, "print_markers")) { - print_markers(); + if(trace == NULL) { + CPRINTF("cannot find trace!"); + return 1; } - else if(!strcmp(recvbuf, "trace_setup")) { - DBG("trace setup"); + + for(i=0; inr_channels; i++) { + struct rchan *rchan = trace->channels[i].trans_channel_data; + struct rchan_buf *rbuf = rchan->buf; + + if(!strcmp(trace->channels[i].channel_name, channel_name)) { + char *reply; + + DBG("the shmid for the requested channel is %d", rbuf->shmid); + asprintf(&reply, "%d", rbuf->shmid); + + result = ustcomm_send_reply(&ustcomm_app.server, reply, &src); + if(result) { + ERR("listener: get_shmid: ustcomm_send_reply failed"); + goto next_cmd; + } + + free(reply); + + break; + } } - else if(!strcmp(recvbuf, "trace_alloc")) { - DBG("trace alloc"); + } + else if(nth_token_is(recvbuf, "get_n_subbufs", 0) == 1) { + struct ltt_trace_struct *trace; + char trace_name[] = "auto"; + int i; + char *channel_name; + + DBG("get_n_subbufs"); + + channel_name = nth_token(recvbuf, 1); + if(channel_name == NULL) { + ERR("get_n_subbufs: cannot parse channel"); + goto next_cmd; } - else if(!strcmp(recvbuf, "trace_start")) { - DBG("trace start"); + + ltt_lock_traces(); + trace = _ltt_trace_find(trace_name); + ltt_unlock_traces(); + + if(trace == NULL) { + CPRINTF("cannot find trace!"); + return 1; } - else if(!strcmp(recvbuf, "trace_stop")) { - DBG("trace stop"); + + for(i=0; inr_channels; i++) { + struct rchan *rchan = trace->channels[i].trans_channel_data; + + if(!strcmp(trace->channels[i].channel_name, channel_name)) { + char *reply; + + DBG("the n_subbufs for the requested channel is %d", rchan->n_subbufs); + asprintf(&reply, "%d", rchan->n_subbufs); + + result = ustcomm_send_reply(&ustcomm_app.server, reply, &src); + if(result) { + ERR("listener: get_n_subbufs: ustcomm_send_reply failed"); + goto next_cmd; + } + + free(reply); + + break; + } } } - next_conn:; + else if(nth_token_is(recvbuf, "get_subbuf_size", 0) == 1) { + struct ltt_trace_struct *trace; + char trace_name[] = "auto"; + int i; + char *channel_name; + + DBG("get_subbuf_size"); + + channel_name = nth_token(recvbuf, 1); + if(channel_name == NULL) { + ERR("get_subbuf_size: cannot parse channel"); + goto next_cmd; + } + + ltt_lock_traces(); + trace = _ltt_trace_find(trace_name); + ltt_unlock_traces(); + + if(trace == NULL) { + CPRINTF("cannot find trace!"); + return 1; + } + + for(i=0; inr_channels; i++) { + struct rchan *rchan = trace->channels[i].trans_channel_data; + + if(!strcmp(trace->channels[i].channel_name, channel_name)) { + char *reply; + + DBG("the subbuf_size for the requested channel is %d", rchan->subbuf_size); + asprintf(&reply, "%d", rchan->subbuf_size); + + result = ustcomm_send_reply(&ustcomm_app.server, reply, &src); + if(result) { + ERR("listener: get_subbuf_size: ustcomm_send_reply failed"); + goto next_cmd; + } + + free(reply); + + break; + } + } + } + else if(nth_token_is(recvbuf, "load_probe_lib", 0) == 1) { + char *libfile; + + libfile = nth_token(recvbuf, 1); + + DBG("load_probe_lib loading %s", libfile); + } + + next_cmd: + free(recvbuf); } } +static char listener_stack[16384]; + void create_listener(void) { int result; static char listener_stack[16384]; + //char *listener_stack = malloc(16384); +#ifdef USE_CLONE 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"); } +#else + pthread_t thread; + + pthread_create(&thread, NULL, listener_main, NULL); +#endif } -/* The signal handler itself. */ +/* The signal handler itself. Signals must be setup so there cannot be + nested signals. */ void sighandler(int sig) { + static char have_listener = 0; DBG("sighandler"); - create_listener(); + + if(!have_listener) { + create_listener(); + have_listener = 1; + } } /* Called by the app signal handler to chain it to us. */ @@ -166,43 +503,7 @@ void chain_signal(void) static int init_socket(void) { - int result; - int fd; - char pidstr[6]; - int pidlen; - - struct sockaddr_un addr; - - result = fd = socket(PF_UNIX, SOCK_DGRAM, 0); - if(result == -1) { - PERROR("socket"); - return -1; - } - - addr.sun_family = AF_UNIX; - - result = snprintf(addr.sun_path, UNIX_PATH_MAX, "%s/%d", SOCKETDIR, mypid); - if(result >= UNIX_PATH_MAX) { - ERR("string overflow allocating socket name"); - goto close_sock; - } - //DBG("opening socket at %s", addr.sun_path); - - result = bind(fd, (struct sockaddr *)&addr, sizeof(addr)); - if(result == -1) { - PERROR("bind"); - goto close_sock; - } - - strcpy(mysocketfile, addr.sun_path); - - pfd = fd; - return 0; - - close_sock: - close(fd); - - return -1; + return ustcomm_init_app(getpid(), &ustcomm_app); } static void destroy_socket(void) @@ -249,14 +550,34 @@ static int init_signal_handler(void) return 0; } -static void __attribute__((constructor)) init() +static void auto_probe_connect(struct marker *m) { int result; - mypid = getpid(); + result = ltt_marker_connect(m->channel, m->name, "default"); + if(result) + ERR("ltt_marker_connect"); - /* Must create socket before signal handler to prevent races - * on pfd variable. + DBG("just auto connected marker %s %s to probe default", m->channel, m->name); +} + +static void __attribute__((constructor(101))) init0() +{ + DBG("UST_AUTOPROBE constructor"); + if(getenv("UST_AUTOPROBE")) { + marker_set_new_marker_cb(auto_probe_connect); + } +} + +static void fini(void); + +static void __attribute__((constructor(1000))) init() +{ + int result; + + DBG("UST_TRACE constructor"); + + /* Must create socket before signal handler to prevent races. */ result = init_socket(); if(result == -1) { @@ -269,6 +590,52 @@ static void __attribute__((constructor)) init() return; } + 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(); + + /* In case. */ + ltt_channels_register("ust"); + + 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; + } + //start_consumer(); + inform_consumer_daemon(); + } + + return; /* should decrementally destroy stuff if error */ @@ -280,5 +647,24 @@ static void __attribute__((constructor)) init() static void __attribute__((destructor)) fini() { + int result; + + /* if trace running, finish it */ + + DBG("destructor stopping traces"); + + result = ltt_trace_stop("auto"); + if(result == -1) { + ERR("ltt_trace_stop error"); + } + + result = ltt_trace_destroy("auto"); + if(result == -1) { + ERR("ltt_trace_destroy error"); + } + + /* FIXME: wait for the consumer to be done */ + sleep(1); + destroy_socket(); }