X-Git-Url: http://git.lttng.org/?a=blobdiff_plain;f=libust%2Ftracectl.c;h=2e9436520e099947817825741928192958a7d9d3;hb=86699c2035dd69428706ade2d6dfb150ada757cb;hp=bb03447d6fabdad5cea31cde8ec5e3bc888a35ac;hpb=a4a71875833fd9cbae660c0d36997331710862dd;p=ust.git diff --git a/libust/tracectl.c b/libust/tracectl.c index bb03447..2e94365 100644 --- a/libust/tracectl.c +++ b/libust/tracectl.c @@ -15,27 +15,35 @@ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ +/* This file contains the implementation of the UST listener thread, which + * receives trace control commands. It also coordinates the initialization of + * libust. + */ + #define _GNU_SOURCE #include #include #include +#include #include +#include +#include #include #include -#include #include #include #include #include +#include #include +#include #include #include "tracer.h" #include "usterr.h" #include "ustcomm.h" #include "buffers.h" #include "marker-control.h" -#include "multipoll.h" #define USTSIGNAL SIGIO @@ -48,47 +56,17 @@ */ s64 pidunique = -1LL; -struct list_head blocked_consumers = LIST_HEAD_INIT(blocked_consumers); - -static struct ustcomm_app ustcomm_app; - -struct tracecmd { /* no padding */ - uint32_t size; - uint16_t command; -}; - -/* volatile because shared between the listener and the main thread */ -volatile sig_atomic_t buffers_to_export = 0; - -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]; -}; +static int epoll_fd; +static struct ustcomm_sock *listen_sock; -struct consumer_channel { - int fd; - struct ltt_channel_struct *chan; -}; +extern struct chan_info_struct chan_infos[]; -struct blocked_consumer { - int fd_consumer; - int fd_producer; - int tmp_poll_idx; +static struct list_head open_buffers_list = LIST_HEAD_INIT(open_buffers_list); - /* args to ustcomm_send_reply */ - struct ustcomm_server server; - struct ustcomm_source src; +static struct list_head ust_socks = LIST_HEAD_INIT(ust_socks); - /* args to ust_buffers_get_subbuf */ - struct ust_buffer *buf; - - struct list_head list; -}; +/* volatile because shared between the listener and the main thread */ +int buffers_to_export = 0; static long long make_pidunique(void) { @@ -112,14 +90,32 @@ static void print_markers(FILE *fp) marker_iter_reset(&iter); marker_iter_start(&iter); - while(iter.marker) { - 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); + while (iter.marker) { + 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); marker_iter_next(&iter); } unlock_markers(); } -static int init_socket(void); +static void print_trace_events(FILE *fp) +{ + struct trace_event_iter iter; + + lock_trace_events(); + trace_event_iter_reset(&iter); + trace_event_iter_start(&iter); + + while (iter.trace_event) { + fprintf(fp, "trace_event: %s\n", iter.trace_event->name); + trace_event_iter_next(&iter); + } + unlock_trace_events(); +} /* Ask the daemon to collect a trace called trace_name and being * produced by this pid. @@ -138,23 +134,30 @@ static void inform_consumer_daemon(const char *trace_name) ltt_lock_traces(); trace = _ltt_trace_find(trace_name); - if(trace == NULL) { + if (trace == NULL) { WARN("inform_consumer_daemon: could not find trace \"%s\"; it is probably already destroyed", trace_name); goto finish; } - for(i=0; i < trace->nr_channels; i++) { - /* iterate on all cpus */ - for(j=0; jchannels[i].n_cpus; j++) { - char *buf; - asprintf(&buf, "%s_%d", trace->channels[i].channel_name, j); - result = ustcomm_request_consumer(pid, buf); - if(result == -1) { - WARN("Failed to request collection for channel %s. Is the daemon available?", trace->channels[i].channel_name); - /* continue even if fail */ + for (i=0; i < trace->nr_channels; i++) { + if (trace->channels[i].request_collection) { + /* iterate on all cpus */ + for (j=0; jchannels[i].n_cpus; j++) { + char *buf; + if (asprintf(&buf, "%s_%d", trace->channels[i].channel_name, j) < 0) { + ERR("inform_consumer_daemon : asprintf failed (%s_%d)", + trace->channels[i].channel_name, j); + goto finish; + } + result = ustcomm_request_consumer(pid, buf); + if (result == -1) { + WARN("Failed to request collection for channel %s. Is the daemon available?", + trace->channels[i].channel_name); + /* continue even if fail */ + } + free(buf); + STORE_SHARED(buffers_to_export, LOAD_SHARED(buffers_to_export)+1); } - free(buf); - buffers_to_export++; } } @@ -162,88 +165,26 @@ static void inform_consumer_daemon(const char *trace_name) ltt_unlock_traces(); } -int process_blkd_consumer_act(void *priv, int fd, short events) -{ - int result; - long consumed_old = 0; - char *reply; - struct blocked_consumer *bc = (struct blocked_consumer *) priv; - char inbuf; - - result = read(bc->fd_producer, &inbuf, 1); - if(result == -1) { - PERROR("read"); - return -1; - } - if(result == 0) { - int res; - DBG("listener: got messsage that a buffer ended"); - - res = close(bc->fd_producer); - if(res == -1) { - PERROR("close"); - } - - list_del(&bc->list); - - result = ustcomm_send_reply(&bc->server, "END", &bc->src); - if(result < 0) { - ERR("ustcomm_send_reply failed"); - return -1; - } - - return 0; - } - - result = ust_buffers_get_subbuf(bc->buf, &consumed_old); - if(result == -EAGAIN) { - WARN("missed buffer?"); - return 0; - } - else if(result < 0) { - ERR("ust_buffers_get_subbuf: error: %s", strerror(-result)); - } - asprintf(&reply, "%s %ld", "OK", consumed_old); - result = ustcomm_send_reply(&bc->server, reply, &bc->src); - if(result < 0) { - ERR("ustcomm_send_reply failed"); - free(reply); - return -1; - } - free(reply); - - list_del(&bc->list); - - return 0; -} - -void blocked_consumers_add_to_mp(struct mpentries *ent) -{ - struct blocked_consumer *bc; - - list_for_each_entry(bc, &blocked_consumers, list) { - multipoll_add(ent, bc->fd_producer, POLLIN, process_blkd_consumer_act, bc, NULL); - } - -} - void seperate_channel_cpu(const char *channel_and_cpu, char **channel, int *cpu) { const char *sep; sep = rindex(channel_and_cpu, '_'); - if(sep == NULL) { + if (sep == NULL) { *cpu = -1; sep = channel_and_cpu + strlen(channel_and_cpu); - } - else { + } else { *cpu = atoi(sep+1); } - asprintf(channel, "%.*s", (int)(sep-channel_and_cpu), channel_and_cpu); + if (asprintf(channel, "%.*s", (int)(sep-channel_and_cpu), channel_and_cpu) < 0) { + ERR("seperate_channel_cpu : asprintf failed (%.*s)", + (int)(sep-channel_and_cpu), channel_and_cpu); + return; + } } -static int do_cmd_get_shmid(const char *recvbuf, struct ustcomm_source *src) +static int do_cmd_get_shmid(const char *recvbuf, int sock) { int retval = 0; struct ust_trace *trace; @@ -258,14 +199,16 @@ static int do_cmd_get_shmid(const char *recvbuf, struct ustcomm_source *src) DBG("get_shmid"); channel_and_cpu = nth_token(recvbuf, 1); - if(channel_and_cpu == NULL) { + if (channel_and_cpu == NULL) { ERR("cannot parse channel"); + retval = -1; goto end; } seperate_channel_cpu(channel_and_cpu, &ch_name, &ch_cpu); - if(ch_cpu == -1) { + if (ch_cpu == -1) { ERR("problem parsing channel name"); + retval = -1; goto free_short_chan_name; } @@ -273,25 +216,30 @@ static int do_cmd_get_shmid(const char *recvbuf, struct ustcomm_source *src) trace = _ltt_trace_find(trace_name); ltt_unlock_traces(); - if(trace == NULL) { + if (trace == NULL) { ERR("cannot find trace!"); retval = -1; goto free_short_chan_name; } - for(i=0; inr_channels; i++) { + for (i=0; inr_channels; i++) { struct ust_channel *channel = &trace->channels[i]; struct ust_buffer *buf = channel->buf[ch_cpu]; - if(!strcmp(trace->channels[i].channel_name, ch_name)) { + if (!strcmp(trace->channels[i].channel_name, ch_name)) { char *reply; // DBG("the shmid for the requested channel is %d", buf->shmid); // DBG("the shmid for its buffer structure is %d", channel->buf_struct_shmids); - asprintf(&reply, "%d %d", buf->shmid, channel->buf_struct_shmids[ch_cpu]); + if (asprintf(&reply, "%d %d", buf->shmid, channel->buf_struct_shmids[ch_cpu]) < 0) { + ERR("do_cmd_get_shmid : asprintf failed (%d %d)", + buf->shmid, channel->buf_struct_shmids[ch_cpu]); + retval = -1; + goto free_short_chan_name; + } - result = ustcomm_send_reply(&ustcomm_app.server, reply, src); - if(result) { + result = ustcomm_send_reply(reply, sock); + if (result) { ERR("ustcomm_send_reply failed"); free(reply); retval = -1; @@ -305,7 +253,7 @@ static int do_cmd_get_shmid(const char *recvbuf, struct ustcomm_source *src) } } - if(!found) { + if (!found) { ERR("channel not found (%s)", channel_and_cpu); } @@ -316,7 +264,7 @@ static int do_cmd_get_shmid(const char *recvbuf, struct ustcomm_source *src) return retval; } -static int do_cmd_get_n_subbufs(const char *recvbuf, struct ustcomm_source *src) +static int do_cmd_get_n_subbufs(const char *recvbuf, int sock) { int retval = 0; struct ust_trace *trace; @@ -331,14 +279,16 @@ static int do_cmd_get_n_subbufs(const char *recvbuf, struct ustcomm_source *src) DBG("get_n_subbufs"); channel_and_cpu = nth_token(recvbuf, 1); - if(channel_and_cpu == NULL) { + if (channel_and_cpu == NULL) { ERR("cannot parse channel"); + retval = -1; goto end; } seperate_channel_cpu(channel_and_cpu, &ch_name, &ch_cpu); - if(ch_cpu == -1) { + if (ch_cpu == -1) { ERR("problem parsing channel name"); + retval = -1; goto free_short_chan_name; } @@ -346,23 +296,28 @@ static int do_cmd_get_n_subbufs(const char *recvbuf, struct ustcomm_source *src) trace = _ltt_trace_find(trace_name); ltt_unlock_traces(); - if(trace == NULL) { + if (trace == NULL) { ERR("cannot find trace!"); retval = -1; goto free_short_chan_name; } - for(i=0; inr_channels; i++) { + for (i=0; inr_channels; i++) { struct ust_channel *channel = &trace->channels[i]; - if(!strcmp(trace->channels[i].channel_name, ch_name)) { + if (!strcmp(trace->channels[i].channel_name, ch_name)) { char *reply; DBG("the n_subbufs for the requested channel is %d", channel->subbuf_cnt); - asprintf(&reply, "%d", channel->subbuf_cnt); + if (asprintf(&reply, "%d", channel->subbuf_cnt) < 0) { + ERR("do_cmd_get_n_subbufs : asprintf failed (%d)", + channel->subbuf_cnt); + retval = -1; + goto free_short_chan_name; + } - result = ustcomm_send_reply(&ustcomm_app.server, reply, src); - if(result) { + result = ustcomm_send_reply(reply, sock); + if (result) { ERR("ustcomm_send_reply failed"); free(reply); retval = -1; @@ -374,7 +329,7 @@ static int do_cmd_get_n_subbufs(const char *recvbuf, struct ustcomm_source *src) break; } } - if(found == 0) { + if (found == 0) { ERR("unable to find channel"); } @@ -385,7 +340,7 @@ static int do_cmd_get_n_subbufs(const char *recvbuf, struct ustcomm_source *src) return retval; } -static int do_cmd_get_subbuf_size(const char *recvbuf, struct ustcomm_source *src) +static int do_cmd_get_subbuf_size(const char *recvbuf, int sock) { int retval = 0; struct ust_trace *trace; @@ -400,14 +355,16 @@ static int do_cmd_get_subbuf_size(const char *recvbuf, struct ustcomm_source *sr DBG("get_subbuf_size"); channel_and_cpu = nth_token(recvbuf, 1); - if(channel_and_cpu == NULL) { + if (channel_and_cpu == NULL) { ERR("cannot parse channel"); + retval = -1; goto end; } seperate_channel_cpu(channel_and_cpu, &ch_name, &ch_cpu); - if(ch_cpu == -1) { + if (ch_cpu == -1) { ERR("problem parsing channel name"); + retval = -1; goto free_short_chan_name; } @@ -415,23 +372,28 @@ static int do_cmd_get_subbuf_size(const char *recvbuf, struct ustcomm_source *sr trace = _ltt_trace_find(trace_name); ltt_unlock_traces(); - if(trace == NULL) { + if (trace == NULL) { ERR("cannot find trace!"); retval = -1; goto free_short_chan_name; } - for(i=0; inr_channels; i++) { + for (i=0; inr_channels; i++) { struct ust_channel *channel = &trace->channels[i]; - if(!strcmp(trace->channels[i].channel_name, ch_name)) { + if (!strcmp(trace->channels[i].channel_name, ch_name)) { char *reply; DBG("the subbuf_size for the requested channel is %zd", channel->subbuf_size); - asprintf(&reply, "%zd", channel->subbuf_size); + if (asprintf(&reply, "%zd", channel->subbuf_size) < 0) { + ERR("do_cmd_get_subbuf_size : asprintf failed (%zd)", + channel->subbuf_size); + retval = -1; + goto free_short_chan_name; + } - result = ustcomm_send_reply(&ustcomm_app.server, reply, src); - if(result) { + result = ustcomm_send_reply(reply, sock); + if (result) { ERR("ustcomm_send_reply failed"); free(reply); retval = -1; @@ -443,7 +405,7 @@ static int do_cmd_get_subbuf_size(const char *recvbuf, struct ustcomm_source *sr break; } } - if(found == 0) { + if (found == 0) { ERR("unable to find channel"); } @@ -454,24 +416,23 @@ static int do_cmd_get_subbuf_size(const char *recvbuf, struct ustcomm_source *sr return retval; } -static unsigned int poweroftwo(unsigned int x) -{ - unsigned int power2 = 1; - unsigned int hardcoded = 2147483648; /* FIX max 2^31 */ +/* Return the power of two which is equal or higher to v */ - if (x < 2) - return 2; - - while (power2 < x && power2 < hardcoded) - power2 *= 2; +static unsigned int pow2_higher_or_eq(unsigned int v) +{ + int hb = fls(v); + int retval = 1<<(hb-1); - return power2; + if (v-retval == 0) + return retval; + else + return retval<<1; } -static int do_cmd_set_subbuf_size(const char *recvbuf, struct ustcomm_source *src) +static int do_cmd_set_subbuf_size(const char *recvbuf, int sock) { char *channel_slash_size; - char ch_name[256]=""; + char *ch_name = NULL; unsigned int size, power; int retval = 0; struct ust_trace *trace; @@ -482,29 +443,31 @@ static int do_cmd_set_subbuf_size(const char *recvbuf, struct ustcomm_source *sr DBG("set_subbuf_size"); channel_slash_size = nth_token(recvbuf, 1); - sscanf(channel_slash_size, "%255[^/]/%u", ch_name, &size); + sscanf(channel_slash_size, "%a[^/]/%u", &ch_name, &size); - if(ch_name == NULL) { + if (ch_name == NULL) { ERR("cannot parse channel"); + retval = -1; goto end; } - power = poweroftwo(size); + power = pow2_higher_or_eq(size); + power = max_t(unsigned int, 2u, power); if (power != size) - WARN("using the next 2^n = %u\n", power); + WARN("using the next power of two for buffer size = %u\n", power); ltt_lock_traces(); trace = _ltt_trace_find_setup(trace_name); - if(trace == NULL) { + if (trace == NULL) { ERR("cannot find trace!"); retval = -1; goto end; } - for(i = 0; i < trace->nr_channels; i++) { + for (i = 0; i < trace->nr_channels; i++) { struct ust_channel *channel = &trace->channels[i]; - if(!strcmp(trace->channels[i].channel_name, ch_name)) { + if (!strcmp(trace->channels[i].channel_name, ch_name)) { channel->subbuf_size = power; DBG("the set_subbuf_size for the requested channel is %zd", channel->subbuf_size); @@ -513,19 +476,20 @@ static int do_cmd_set_subbuf_size(const char *recvbuf, struct ustcomm_source *sr break; } } - if(found == 0) { + if (found == 0) { ERR("unable to find channel"); } end: ltt_unlock_traces(); + free(ch_name); return retval; } -static int do_cmd_set_subbuf_num(const char *recvbuf, struct ustcomm_source *src) +static int do_cmd_set_subbuf_num(const char *recvbuf, int sock) { char *channel_slash_num; - char ch_name[256]=""; + char *ch_name = NULL; unsigned int num; int retval = 0; struct ust_trace *trace; @@ -536,29 +500,31 @@ static int do_cmd_set_subbuf_num(const char *recvbuf, struct ustcomm_source *src DBG("set_subbuf_num"); channel_slash_num = nth_token(recvbuf, 1); - sscanf(channel_slash_num, "%255[^/]/%u", ch_name, &num); + sscanf(channel_slash_num, "%a[^/]/%u", &ch_name, &num); - if(ch_name == NULL) { + if (ch_name == NULL) { ERR("cannot parse channel"); + retval = -1; goto end; } if (num < 2) { ERR("subbuffer count should be greater than 2"); + retval = -1; goto end; } ltt_lock_traces(); trace = _ltt_trace_find_setup(trace_name); - if(trace == NULL) { + if (trace == NULL) { ERR("cannot find trace!"); retval = -1; goto end; } - for(i = 0; i < trace->nr_channels; i++) { + for (i = 0; i < trace->nr_channels; i++) { struct ust_channel *channel = &trace->channels[i]; - if(!strcmp(trace->channels[i].channel_name, ch_name)) { + if (!strcmp(trace->channels[i].channel_name, ch_name)) { channel->subbuf_cnt = num; DBG("the set_subbuf_cnt for the requested channel is %zd", channel->subbuf_cnt); @@ -567,37 +533,39 @@ static int do_cmd_set_subbuf_num(const char *recvbuf, struct ustcomm_source *src break; } } - if(found == 0) { + if (found == 0) { ERR("unable to find channel"); } end: ltt_unlock_traces(); + free(ch_name); return retval; } -static int do_cmd_get_subbuffer(const char *recvbuf, struct ustcomm_source *src) +static int do_cmd_get_subbuffer(const char *recvbuf, int sock) { - int retval = 0; + int retval = 0, found = 0;; + int i, ch_cpu, result; + long consumed_old = 0; struct ust_trace *trace; char trace_name[] = "auto"; - int i; char *channel_and_cpu; - int found = 0; char *ch_name; - int ch_cpu; DBG("get_subbuf"); channel_and_cpu = nth_token(recvbuf, 1); if(channel_and_cpu == NULL) { ERR("cannot parse channel"); + retval = -1; goto end; } seperate_channel_cpu(channel_and_cpu, &ch_name, &ch_cpu); if(ch_cpu == -1) { ERR("problem parsing channel name"); + retval = -1; goto free_short_chan_name; } @@ -608,7 +576,7 @@ static int do_cmd_get_subbuffer(const char *recvbuf, struct ustcomm_source *src) int result; DBG("Cannot find trace. It was likely destroyed by the user."); - result = ustcomm_send_reply(&ustcomm_app.server, "NOTFOUND", src); + result = ustcomm_send_reply("NOTFOUND", sock); if(result) { ERR("ustcomm_send_reply failed"); retval = -1; @@ -623,35 +591,141 @@ static int do_cmd_get_subbuffer(const char *recvbuf, struct ustcomm_source *src) if(!strcmp(trace->channels[i].channel_name, ch_name)) { struct ust_buffer *buf = channel->buf[ch_cpu]; - struct blocked_consumer *bc; + char *reply; found = 1; - bc = (struct blocked_consumer *) malloc(sizeof(struct blocked_consumer)); - if(bc == NULL) { - ERR("malloc returned NULL"); + result = ust_buffers_get_subbuf(buf, &consumed_old); + if(result == -EAGAIN) { + WARN("missed buffer?"); + retval = 0; + + goto unlock_traces; + } else if (result < 0) { + ERR("ust_buffers_get_subbuf: error: %s", strerror(-result)); + retval = -1; + + goto unlock_traces; + } + if (asprintf(&reply, "%s %ld", "OK", consumed_old) < 0) { + ERR("do_cmd_get_subbuffer: asprintf failed (OK %ld)", + consumed_old); + retval = -1; + + goto unlock_traces; + } + result = ustcomm_send_reply(reply, sock); + if (result < 0) { + ERR("ustcomm_send_reply failed"); + free(reply); + retval = -1; + goto unlock_traces; } - bc->fd_consumer = src->fd; - bc->fd_producer = buf->data_ready_fd_read; - bc->buf = buf; - bc->src = *src; - bc->server = ustcomm_app.server; + free(reply); + + break; + } + } + if(found == 0) { + result = ustcomm_send_reply("NOTFOUND", sock); + if (result <= 0) { + ERR("ustcomm_send_reply failed"); + retval = -1; + + goto unlock_traces; + } + ERR("unable to find channel"); + } + + unlock_traces: + ltt_unlock_traces(); + + free_short_chan_name: + free(ch_name); + + end: + return retval; +} + + +static int do_cmd_get_buffer_fd(const char *recvbuf, int sock) +{ + int retval = 0; + struct ust_trace *trace; + char trace_name[] = "auto"; + int i; + char *channel_and_cpu; + int found = 0; + char *ch_name; + int ch_cpu; + struct ustcomm_header header; + + DBG("get_buffer_fd"); - list_add(&bc->list, &blocked_consumers); + channel_and_cpu = nth_token(recvbuf, 1); + if (channel_and_cpu == NULL) { + ERR("cannot parse channel"); + retval = -1; + goto end; + } + + seperate_channel_cpu(channel_and_cpu, &ch_name, &ch_cpu); + if (ch_cpu == -1) { + ERR("problem parsing channel name"); + retval = -1; + goto free_short_chan_name; + } + + ltt_lock_traces(); + trace = _ltt_trace_find(trace_name); + + if (trace == NULL) { + int result; + + DBG("Cannot find trace. It was likely destroyed by the user."); + result = ustcomm_send_reply("NOTFOUND", sock); + if (result) { + ERR("ustcomm_send_reply failed"); + retval = -1; + goto unlock_traces; + } + + goto unlock_traces; + } + + for (i=0; inr_channels; i++) { + struct ust_channel *channel = &trace->channels[i]; + + if (!strcmp(trace->channels[i].channel_name, ch_name)) { + struct ust_buffer *buf = channel->buf[ch_cpu]; + + found = 1; + + header.size = 0; + header.fd_included = 1; + if (ustcomm_send_fd(sock, &header, NULL, + &buf->data_ready_fd_read) <= 0) { + ERR("ustcomm_send_fd failed\n"); + goto unlock_traces; + } /* Being here is the proof the daemon has mapped the buffer in its * memory. We may now decrement buffers_to_export. */ - if(uatomic_read(&buf->consumed) == 0) { + if (uatomic_read(&buf->consumed) == 0) { DBG("decrementing buffers_to_export"); - buffers_to_export--; + STORE_SHARED(buffers_to_export, LOAD_SHARED(buffers_to_export)-1); } + /* The buffer has been exported, ergo, we can add it to the + * list of open buffers + */ + list_add(&buf->open_buffers_list, &open_buffers_list); break; } } - if(found == 0) { + if (found == 0) { ERR("unable to find channel"); } @@ -665,7 +739,7 @@ static int do_cmd_get_subbuffer(const char *recvbuf, struct ustcomm_source *src) return retval; } -static int do_cmd_put_subbuffer(const char *recvbuf, struct ustcomm_source *src) +static int do_cmd_put_subbuffer(const char *recvbuf, int sock) { int retval = 0; struct ust_trace *trace; @@ -684,27 +758,27 @@ static int do_cmd_put_subbuffer(const char *recvbuf, struct ustcomm_source *src) DBG("put_subbuf"); channel_and_cpu = strdup(nth_token(recvbuf, 1)); - if(channel_and_cpu == NULL) { + if (channel_and_cpu == NULL) { ERR("cannot parse channel"); retval = -1; goto end; } consumed_old_str = strdup(nth_token(recvbuf, 2)); - if(consumed_old_str == NULL) { + if (consumed_old_str == NULL) { ERR("cannot parse consumed_old"); retval = -1; goto free_channel_and_cpu; } consumed_old = strtol(consumed_old_str, &endptr, 10); - if(*endptr != '\0') { + if (*endptr != '\0') { ERR("invalid value for consumed_old"); retval = -1; goto free_consumed_old_str; } seperate_channel_cpu(channel_and_cpu, &ch_name, &ch_cpu); - if(ch_cpu == -1) { + if (ch_cpu == -1) { ERR("problem parsing channel name"); retval = -1; goto free_short_chan_name; @@ -713,10 +787,10 @@ static int do_cmd_put_subbuffer(const char *recvbuf, struct ustcomm_source *src) ltt_lock_traces(); trace = _ltt_trace_find(trace_name); - if(trace == NULL) { + if (trace == NULL) { DBG("Cannot find trace. It was likely destroyed by the user."); - result = ustcomm_send_reply(&ustcomm_app.server, "NOTFOUND", src); - if(result) { + result = ustcomm_send_reply("NOTFOUND", sock); + if (result) { ERR("ustcomm_send_reply failed"); retval = -1; goto unlock_traces; @@ -725,26 +799,33 @@ static int do_cmd_put_subbuffer(const char *recvbuf, struct ustcomm_source *src) goto unlock_traces; } - for(i=0; inr_channels; i++) { + for (i=0; inr_channels; i++) { struct ust_channel *channel = &trace->channels[i]; - if(!strcmp(trace->channels[i].channel_name, ch_name)) { + if (!strcmp(trace->channels[i].channel_name, ch_name)) { struct ust_buffer *buf = channel->buf[ch_cpu]; found = 1; result = ust_buffers_put_subbuf(buf, consumed_old); - if(result < 0) { + if (result < 0) { WARN("ust_buffers_put_subbuf: error (subbuf=%s)", channel_and_cpu); - asprintf(&reply, "%s", "ERROR"); - } - else { + if (asprintf(&reply, "%s", "ERROR") < 0) { + ERR("do_cmd_put_subbuffer : asprintf failed (ERROR)"); + retval = -1; + goto unlock_traces; + } + } else { DBG("ust_buffers_put_subbuf: success (subbuf=%s)", channel_and_cpu); - asprintf(&reply, "%s", "OK"); + if (asprintf(&reply, "%s", "OK") < 0) { + ERR("do_cmd_put_subbuffer : asprintf failed (OK)"); + retval = -1; + goto unlock_traces; + } } - result = ustcomm_send_reply(&ustcomm_app.server, reply, src); - if(result) { + result = ustcomm_send_reply(reply, sock); + if (result) { ERR("ustcomm_send_reply failed"); free(reply); retval = -1; @@ -755,7 +836,7 @@ static int do_cmd_put_subbuffer(const char *recvbuf, struct ustcomm_source *src) break; } } - if(found == 0) { + if (found == 0) { ERR("unable to find channel"); } @@ -774,23 +855,31 @@ static int do_cmd_put_subbuffer(const char *recvbuf, struct ustcomm_source *src) static void listener_cleanup(void *ptr) { - ustcomm_fini_app(&ustcomm_app, 0); + ustcomm_del_named_sock(listen_sock, 0); +} + +static void do_cmd_force_switch() +{ + struct ust_buffer *buf; + + list_for_each_entry(buf, &open_buffers_list, + open_buffers_list) { + ltt_force_switch(buf, FORCE_FLUSH); + } } -int process_client_cmd(char *recvbuf, struct ustcomm_source *src) +static int process_client_cmd(char *recvbuf, int sock) { int result; char trace_name[] = "auto"; char trace_type[] = "ustrelay"; int len; - DBG("received a message! it's: %s", recvbuf); len = strlen(recvbuf); - if(!strcmp(recvbuf, "print_markers")) { + if (!strcmp(recvbuf, "print_markers")) { print_markers(stderr); - } - else if(!strcmp(recvbuf, "list_markers")) { + } else if (!strcmp(recvbuf, "list_markers")) { char *ptr; size_t size; FILE *fp; @@ -799,26 +888,47 @@ int process_client_cmd(char *recvbuf, struct ustcomm_source *src) print_markers(fp); fclose(fp); - result = ustcomm_send_reply(&ustcomm_app.server, ptr, src); + result = ustcomm_send_reply(ptr, sock); free(ptr); - } - else if(!strcmp(recvbuf, "start")) { + } else if (!strcmp(recvbuf, "print_trace_events")) { + print_trace_events(stderr); + + } else if (!strcmp(recvbuf, "list_trace_events")) { + char *ptr; + size_t size; + FILE *fp; + + fp = open_memstream(&ptr, &size); + if (fp == NULL) { + ERR("opening memstream failed"); + return -1; + } + print_trace_events(fp); + fclose(fp); + + result = ustcomm_send_reply(ptr, sock); + if (result < 0) { + ERR("list_trace_events failed"); + return -1; + } + free(ptr); + } else if (!strcmp(recvbuf, "start")) { /* start is an operation that setups the trace, allocates it and starts it */ result = ltt_trace_setup(trace_name); - if(result < 0) { + if (result < 0) { ERR("ltt_trace_setup failed"); return -1; } result = ltt_trace_set_type(trace_name, trace_type); - if(result < 0) { + if (result < 0) { ERR("ltt_trace_set_type failed"); return -1; } result = ltt_trace_alloc(trace_name); - if(result < 0) { + if (result < 0) { ERR("ltt_trace_alloc failed"); return -1; } @@ -826,98 +936,88 @@ int process_client_cmd(char *recvbuf, struct ustcomm_source *src) inform_consumer_daemon(trace_name); result = ltt_trace_start(trace_name); - if(result < 0) { + if (result < 0) { ERR("ltt_trace_start failed"); return -1; } - } - else if(!strcmp(recvbuf, "trace_setup")) { + } else if (!strcmp(recvbuf, "trace_setup")) { DBG("trace setup"); result = ltt_trace_setup(trace_name); - if(result < 0) { + if (result < 0) { ERR("ltt_trace_setup failed"); return -1; } result = ltt_trace_set_type(trace_name, trace_type); - if(result < 0) { + if (result < 0) { ERR("ltt_trace_set_type failed"); return -1; } - } - else if(!strcmp(recvbuf, "trace_alloc")) { + } else if (!strcmp(recvbuf, "trace_alloc")) { DBG("trace alloc"); result = ltt_trace_alloc(trace_name); - if(result < 0) { + if (result < 0) { ERR("ltt_trace_alloc failed"); return -1; } inform_consumer_daemon(trace_name); - } - else if(!strcmp(recvbuf, "trace_create")) { + } else if (!strcmp(recvbuf, "trace_create")) { DBG("trace create"); result = ltt_trace_setup(trace_name); - if(result < 0) { + if (result < 0) { ERR("ltt_trace_setup failed"); return -1; } result = ltt_trace_set_type(trace_name, trace_type); - if(result < 0) { + if (result < 0) { ERR("ltt_trace_set_type failed"); return -1; } - } - else if(!strcmp(recvbuf, "trace_start")) { + } else if (!strcmp(recvbuf, "trace_start")) { DBG("trace start"); result = ltt_trace_alloc(trace_name); - if(result < 0) { + if (result < 0) { ERR("ltt_trace_alloc failed"); return -1; } - if(!result) { + if (!result) { inform_consumer_daemon(trace_name); } result = ltt_trace_start(trace_name); - if(result < 0) { + if (result < 0) { ERR("ltt_trace_start failed"); return -1; } - } - else if(!strcmp(recvbuf, "trace_stop")) { + } else if (!strcmp(recvbuf, "trace_stop")) { DBG("trace stop"); result = ltt_trace_stop(trace_name); - if(result < 0) { + if (result < 0) { ERR("ltt_trace_stop failed"); return -1; } - } - else if(!strcmp(recvbuf, "trace_destroy")) { + } else if (!strcmp(recvbuf, "trace_destroy")) { DBG("trace destroy"); result = ltt_trace_destroy(trace_name, 0); - if(result < 0) { + if (result < 0) { ERR("ltt_trace_destroy failed"); return -1; } - } - else if(nth_token_is(recvbuf, "get_shmid", 0) == 1) { - do_cmd_get_shmid(recvbuf, src); - } - else if(nth_token_is(recvbuf, "get_n_subbufs", 0) == 1) { - do_cmd_get_n_subbufs(recvbuf, src); - } - else if(nth_token_is(recvbuf, "get_subbuf_size", 0) == 1) { - do_cmd_get_subbuf_size(recvbuf, src); - } - else if(nth_token_is(recvbuf, "load_probe_lib", 0) == 1) { + } else if (nth_token_is(recvbuf, "get_shmid", 0) == 1) { + do_cmd_get_shmid(recvbuf, sock); + } else if (nth_token_is(recvbuf, "get_n_subbufs", 0) == 1) { + do_cmd_get_n_subbufs(recvbuf, sock); + } else if (nth_token_is(recvbuf, "get_subbuf_size", 0) == 1) { + do_cmd_get_subbuf_size(recvbuf, sock); + } else if (nth_token_is(recvbuf, "load_probe_lib", 0) == 1) { char *libfile; libfile = nth_token(recvbuf, 1); @@ -925,65 +1025,99 @@ int process_client_cmd(char *recvbuf, struct ustcomm_source *src) DBG("load_probe_lib loading %s", libfile); free(libfile); + } else if (nth_token_is(recvbuf, "get_subbuffer", 0) == 1) { + do_cmd_get_subbuffer(recvbuf, sock); } - else if(nth_token_is(recvbuf, "get_subbuffer", 0) == 1) { - do_cmd_get_subbuffer(recvbuf, src); + else if(nth_token_is(recvbuf, "get_buffer_fd", 0) == 1) { + do_cmd_get_buffer_fd(recvbuf, sock); } else if(nth_token_is(recvbuf, "put_subbuffer", 0) == 1) { - do_cmd_put_subbuffer(recvbuf, src); - } - else if(nth_token_is(recvbuf, "set_subbuf_size", 0) == 1) { - do_cmd_set_subbuf_size(recvbuf, src); - } - else if(nth_token_is(recvbuf, "set_subbuf_num", 0) == 1) { - do_cmd_set_subbuf_num(recvbuf, src); - } - else if(nth_token_is(recvbuf, "enable_marker", 0) == 1) { + do_cmd_put_subbuffer(recvbuf, sock); + } else if (nth_token_is(recvbuf, "set_subbuf_size", 0) == 1) { + do_cmd_set_subbuf_size(recvbuf, sock); + } else if (nth_token_is(recvbuf, "set_subbuf_num", 0) == 1) { + do_cmd_set_subbuf_num(recvbuf, sock); + } else if (nth_token_is(recvbuf, "enable_marker", 0) == 1) { char *channel_slash_name = nth_token(recvbuf, 1); - char channel_name[256]=""; - char marker_name[256]=""; + char *channel_name = NULL; + char *marker_name = NULL; - result = sscanf(channel_slash_name, "%255[^/]/%255s", channel_name, marker_name); + result = sscanf(channel_slash_name, "%a[^/]/%as", &channel_name, &marker_name); - if(channel_name == NULL || marker_name == NULL) { + if (channel_name == NULL || marker_name == NULL) { WARN("invalid marker name"); + free(channel_name); + free(marker_name); goto next_cmd; } result = ltt_marker_connect(channel_name, marker_name, "default"); - if(result < 0) { + if (result < 0) { WARN("could not enable marker; channel=%s, name=%s", channel_name, marker_name); } - } - else if(nth_token_is(recvbuf, "disable_marker", 0) == 1) { + + free(channel_name); + free(marker_name); + } else if (nth_token_is(recvbuf, "disable_marker", 0) == 1) { char *channel_slash_name = nth_token(recvbuf, 1); - char *marker_name; - char *channel_name; + char *marker_name = NULL; + char *channel_name = NULL; result = sscanf(channel_slash_name, "%a[^/]/%as", &channel_name, &marker_name); - if(marker_name == NULL) { + if (channel_name == NULL || marker_name == NULL) { + WARN("invalid marker name"); + free(channel_name); + free(marker_name); + goto next_cmd; } result = ltt_marker_disconnect(channel_name, marker_name, "default"); - if(result < 0) { + if (result < 0) { WARN("could not disable marker; channel=%s, name=%s", channel_name, marker_name); } - } - else if(nth_token_is(recvbuf, "get_pidunique", 0) == 1) { + + free(channel_name); + free(marker_name); + } else if (nth_token_is(recvbuf, "get_pidunique", 0) == 1) { char *reply; - asprintf(&reply, "%lld", pidunique); + if (asprintf(&reply, "%lld", pidunique) < 0) { + ERR("process_client_cmd : asprintf failed (%lld)", + pidunique); + goto next_cmd; + } - result = ustcomm_send_reply(&ustcomm_app.server, reply, src); - if(result) { + result = ustcomm_send_reply(reply, sock); + if (result) { ERR("listener: get_pidunique: ustcomm_send_reply failed"); goto next_cmd; } free(reply); - } - else { + } else if (nth_token_is(recvbuf, "get_sock_path", 0) == 1) { + char *reply = getenv("UST_DAEMON_SOCKET"); + if (!reply) { + if (asprintf(&reply, "%s/%s", SOCK_DIR, "ustd") < 0) { + ERR("process_client_cmd : asprintf failed (%s/ustd)", + SOCK_DIR); + goto next_cmd; + } + result = ustcomm_send_reply(reply, sock); + free(reply); + } else { + result = ustcomm_send_reply(reply, sock); + } + if (result) + ERR("ustcomm_send_reply failed"); + } else if (nth_token_is(recvbuf, "set_sock_path", 0) == 1) { + char *sock_path = nth_token(recvbuf, 1); + result = setenv("UST_DAEMON_SOCKET", sock_path, 1); + if (result) + ERR("cannot set UST_DAEMON_SOCKET environment variable"); + } else if (nth_token_is(recvbuf, "force_switch", 0) == 1) { + do_cmd_force_switch(); + } else { ERR("unable to parse message: %s", recvbuf); } @@ -992,28 +1126,50 @@ next_cmd: return 0; } +#define MAX_EVENTS 10 + void *listener_main(void *p) { - int result; + struct ustcomm_sock *epoll_sock; + struct epoll_event events[MAX_EVENTS]; + struct sockaddr addr; + int accept_fd, nfds, result, i, addr_size; DBG("LISTENER"); pthread_cleanup_push(listener_cleanup, NULL); for(;;) { - struct mpentries mpent; - - multipoll_init(&mpent); - - blocked_consumers_add_to_mp(&mpent); - ustcomm_mp_add_app_clients(&mpent, &ustcomm_app, process_client_cmd); - - result = multipoll_poll(&mpent, -1); - if(result == -1) { - ERR("error in multipoll_poll"); + nfds = epoll_wait(epoll_fd, events, MAX_EVENTS, -1); + if (nfds == -1) { + PERROR("listener_main: epoll_wait failed"); + continue; } - multipoll_destroy(&mpent); + for (i = 0; i < nfds; i++) { + epoll_sock = (struct ustcomm_sock *)events[i].data.ptr; + if (epoll_sock == listen_sock) { + addr_size = sizeof(struct sockaddr); + accept_fd = accept(epoll_sock->fd, + &addr, + (socklen_t *)&addr_size); + if (accept_fd == -1) { + PERROR("listener_main: accept failed"); + continue; + } + ustcomm_init_sock(accept_fd, epoll_fd, + &ust_socks); + } else { + char *msg = NULL; + result = recv_message_conn(epoll_sock->fd, &msg); + if (result == 0) { + ustcomm_del_sock(epoll_sock, 0); + } else if (msg) { + process_client_cmd(msg, epoll_sock->fd); + free(msg); + } + } + } } pthread_cleanup_pop(1); @@ -1028,23 +1184,39 @@ static pthread_t listener_thread; void create_listener(void) { int result; + sigset_t sig_all_blocked; + sigset_t orig_parent_mask; - if(have_listener) { + if (have_listener) { WARN("not creating listener because we already had one"); return; } + /* A new thread created by pthread_create inherits the signal mask + * from the parent. To avoid any signal being received by the + * listener thread, we block all signals temporarily in the parent, + * while we create the listener thread. + */ + + sigfillset(&sig_all_blocked); + + result = pthread_sigmask(SIG_SETMASK, &sig_all_blocked, &orig_parent_mask); + if (result) { + PERROR("pthread_sigmask: %s", strerror(result)); + } + result = pthread_create(&listener_thread, NULL, listener_main, NULL); - if(result == -1) { + if (result == -1) { PERROR("pthread_create"); } - have_listener = 1; -} - -static int init_socket(void) -{ - return ustcomm_init_app(getpid(), &ustcomm_app); + /* Restore original signal mask in parent */ + result = pthread_sigmask(SIG_SETMASK, &orig_parent_mask, NULL); + if (result) { + PERROR("pthread_sigmask: %s", strerror(result)); + } else { + have_listener = 1; + } } #define AUTOPROBE_DISABLED 0 @@ -1060,12 +1232,11 @@ static void auto_probe_connect(struct marker *m) char* concat_name = NULL; const char *probe_name = "default"; - if(autoprobe_method == AUTOPROBE_DISABLED) { + if (autoprobe_method == AUTOPROBE_DISABLED) { return; - } - else if(autoprobe_method == AUTOPROBE_ENABLE_REGEX) { + } else if (autoprobe_method == AUTOPROBE_ENABLE_REGEX) { result = asprintf(&concat_name, "%s/%s", m->channel, m->name); - if(result == -1) { + if (result == -1) { ERR("auto_probe_connect: asprintf failed (marker %s/%s)", m->channel, m->name); return; @@ -1078,17 +1249,57 @@ static void auto_probe_connect(struct marker *m) } result = ltt_marker_connect(m->channel, m->name, probe_name); - if(result && result != -EEXIST) + if (result && result != -EEXIST) ERR("ltt_marker_connect (marker = %s/%s, errno = %d)", m->channel, m->name, -result); DBG("auto connected marker %s (addr: %p) %s to probe default", m->channel, m, m->name); } +static struct ustcomm_sock * init_app_socket(int epoll_fd) +{ + char *name; + int result; + struct ustcomm_sock *sock; + + result = asprintf(&name, "%s/%d", SOCK_DIR, (int)getpid()); + if (result < 0) { + ERR("string overflow allocating socket name, " + "UST thread bailing"); + return NULL; + } + + result = ensure_dir_exists(SOCK_DIR); + if (result == -1) { + ERR("Unable to create socket directory %s, UST thread bailing", + SOCK_DIR); + goto free_name; + } + + sock = ustcomm_init_named_socket(name, epoll_fd); + if (!sock) { + ERR("Error initializing named socket (%s). Check that directory" + "exists and that it is writable. UST thread bailing", name); + goto free_name; + } + + free(name); + return sock; + +free_name: + free(name); + return NULL; +} + static void __attribute__((constructor)) init() { int result; char* autoprobe_val = NULL; + char* subbuffer_size_val = NULL; + char* subbuffer_count_val = NULL; + unsigned int subbuffer_size; + unsigned int subbuffer_count; + unsigned int power; /* Assign the pidunique, to be able to differentiate the processes with same * pid, (before and after an exec). @@ -1097,16 +1308,25 @@ static void __attribute__((constructor)) init() DBG("Tracectl constructor"); - result = init_socket(); - if(result == -1) { - ERR("init_socket error"); + /* Set up epoll */ + epoll_fd = epoll_create(MAX_EVENTS); + if (epoll_fd == -1) { + ERR("epoll_create failed, tracing shutting down"); + return; + } + + /* Create the socket */ + listen_sock = init_app_socket(epoll_fd); + if (!listen_sock) { + ERR("failed to create application socket," + " tracing shutting down"); return; } create_listener(); autoprobe_val = getenv("UST_AUTOPROBE"); - if(autoprobe_val) { + if (autoprobe_val) { struct marker_iter iter; DBG("Autoprobe enabled."); @@ -1120,7 +1340,7 @@ static void __attribute__((constructor)) init() /* first, set the callback that will connect the * probe on new markers */ - if(autoprobe_val[0] == '/') { + if (autoprobe_val[0] == '/') { result = regcomp(&autoprobe_regex, autoprobe_val+1, 0); if (result) { char regexerr[150]; @@ -1128,12 +1348,10 @@ static void __attribute__((constructor)) init() regerror(result, &autoprobe_regex, regexerr, sizeof(regexerr)); ERR("cannot parse regex %s (%s), will ignore UST_AUTOPROBE", autoprobe_val, regexerr); /* don't crash the application just for this */ - } - else { + } else { autoprobe_method = AUTOPROBE_ENABLE_REGEX; } - } - else { + } else { /* just enable all instrumentation */ autoprobe_method = AUTOPROBE_ENABLE_ALL; } @@ -1145,14 +1363,49 @@ static void __attribute__((constructor)) init() marker_iter_start(&iter); DBG("now iterating on markers already registered"); - while(iter.marker) { + while (iter.marker) { DBG("now iterating on marker %s", iter.marker->name); auto_probe_connect(iter.marker); marker_iter_next(&iter); } } - if(getenv("UST_TRACE")) { + if (getenv("UST_OVERWRITE")) { + int val = atoi(getenv("UST_OVERWRITE")); + if (val == 0 || val == 1) { + STORE_SHARED(ust_channels_overwrite_by_default, val); + } else { + WARN("invalid value for UST_OVERWRITE"); + } + } + + if (getenv("UST_AUTOCOLLECT")) { + int val = atoi(getenv("UST_AUTOCOLLECT")); + if (val == 0 || val == 1) { + STORE_SHARED(ust_channels_request_collection_by_default, val); + } else { + WARN("invalid value for UST_AUTOCOLLECT"); + } + } + + subbuffer_size_val = getenv("UST_SUBBUF_SIZE"); + if (subbuffer_size_val) { + sscanf(subbuffer_size_val, "%u", &subbuffer_size); + power = pow2_higher_or_eq(subbuffer_size); + if (power != subbuffer_size) + WARN("using the next power of two for buffer size = %u\n", power); + chan_infos[LTT_CHANNEL_UST].def_subbufsize = power; + } + + subbuffer_count_val = getenv("UST_SUBBUF_NUM"); + if (subbuffer_count_val) { + sscanf(subbuffer_count_val, "%u", &subbuffer_count); + if (subbuffer_count < 2) + subbuffer_count = 2; + chan_infos[LTT_CHANNEL_UST].def_subbufcount = subbuffer_count; + } + + if (getenv("UST_TRACE")) { char trace_name[] = "auto"; char trace_type[] = "ustrelay"; @@ -1190,25 +1443,25 @@ static void __attribute__((constructor)) init() ltt_channels_register("ust"); result = ltt_trace_setup(trace_name); - if(result < 0) { + if (result < 0) { ERR("ltt_trace_setup failed"); return; } result = ltt_trace_set_type(trace_name, trace_type); - if(result < 0) { + if (result < 0) { ERR("ltt_trace_set_type failed"); return; } result = ltt_trace_alloc(trace_name); - if(result < 0) { + if (result < 0) { ERR("ltt_trace_alloc failed"); return; } result = ltt_trace_start(trace_name); - if(result < 0) { + if (result < 0) { ERR("ltt_trace_start failed"); return; } @@ -1218,7 +1471,6 @@ static void __attribute__((constructor)) init() inform_consumer_daemon(trace_name); } - return; /* should decrementally destroy stuff if error */ @@ -1245,12 +1497,12 @@ static void destroy_traces(void) DBG("destructor stopping traces"); result = ltt_trace_stop("auto"); - if(result == -1) { + if (result == -1) { ERR("ltt_trace_stop error"); } result = ltt_trace_destroy("auto", 0); - if(result == -1) { + if (result == -1) { ERR("ltt_trace_destroy error"); } } @@ -1263,7 +1515,7 @@ static int trace_recording(void) ltt_lock_traces(); list_for_each_entry(trace, <t_traces.head, list) { - if(trace->active) { + if (trace->active) { retval = 1; break; } @@ -1274,13 +1526,6 @@ static int trace_recording(void) return retval; } -#if 0 -static int have_consumer(void) -{ - return !list_empty(&blocked_consumers); -} -#endif - int restarting_usleep(useconds_t usecs) { struct timespec tv; @@ -1290,22 +1535,25 @@ int restarting_usleep(useconds_t usecs) tv.tv_nsec = usecs * 1000; do { - result = nanosleep(&tv, &tv); - } while(result == -1 && errno == EINTR); + result = nanosleep(&tv, &tv); + } while (result == -1 && errno == EINTR); return result; } -static void stop_listener() +static void stop_listener(void) { int result; + if (!have_listener) + return; + result = pthread_cancel(listener_thread); - if(result != 0) { + if (result != 0) { ERR("pthread_cancel: %s", strerror(result)); } result = pthread_join(listener_thread, NULL); - if(result != 0) { + if (result != 0) { ERR("pthread_join: %s", strerror(result)); } } @@ -1322,15 +1570,15 @@ static void stop_listener() static void __attribute__((destructor)) keepalive() { - if(trace_recording() && buffers_to_export) { + if (trace_recording() && LOAD_SHARED(buffers_to_export)) { int total = 0; DBG("Keeping process alive for consumer daemon..."); - while(buffers_to_export) { + while (LOAD_SHARED(buffers_to_export)) { const int interv = 200000; restarting_usleep(interv); total += interv; - if(total >= 3000000) { + if (total >= 3000000) { WARN("non-consumed buffers remaining after wait limit; not waiting anymore"); break; } @@ -1365,8 +1613,8 @@ void ust_potential_exec(void) static void ust_fork(void) { - struct blocked_consumer *bc; - struct blocked_consumer *deletable_bc = NULL; + struct ust_buffer *buf, *buf_tmp; + struct ustcomm_sock *sock, *sock_tmp; int result; /* FIXME: technically, the locks could have been taken before the fork */ @@ -1377,30 +1625,51 @@ static void ust_fork(void) ltt_trace_stop("auto"); ltt_trace_destroy("auto", 1); - /* Delete all active connections */ - ustcomm_close_all_connections(&ustcomm_app.server); + /* Delete all active connections, but leave them in the epoll set */ + list_for_each_entry_safe(sock, sock_tmp, &ust_socks, list) { + ustcomm_del_sock(sock, 1); + } /* Delete all blocked consumers */ - list_for_each_entry(bc, &blocked_consumers, list) { - result = close(bc->fd_producer); + list_for_each_entry_safe(buf, buf_tmp, &open_buffers_list, + open_buffers_list) { + result = close(buf->data_ready_fd_read); if(result == -1) { PERROR("close"); } - free(deletable_bc); - deletable_bc = bc; - list_del(&bc->list); + result = close(buf->data_ready_fd_write); + if(result == -1) { + PERROR("close"); + } + list_del(&buf->open_buffers_list); } - /* free app, keeping socket file */ - ustcomm_fini_app(&ustcomm_app, 1); + /* Clean up the listener socket and epoll, keeping the scoket file */ + ustcomm_del_named_sock(listen_sock, 1); + close(epoll_fd); - buffers_to_export = 0; + /* Re-start the launch sequence */ + STORE_SHARED(buffers_to_export, 0); have_listener = 0; - init_socket(); + + /* Set up epoll */ + epoll_fd = epoll_create(MAX_EVENTS); + if (epoll_fd == -1) { + ERR("epoll_create failed, tracing shutting down"); + return; + } + + /* Create the socket */ + listen_sock = init_app_socket(epoll_fd); + if (!listen_sock) { + ERR("failed to create application socket," + " tracing shutting down"); + return; + } create_listener(); ltt_trace_setup("auto"); result = ltt_trace_set_type("auto", "ustrelay"); - if(result < 0) { + if (result < 0) { ERR("ltt_trace_set_type failed"); return; } @@ -1427,7 +1696,7 @@ void ust_before_fork(ust_fork_info_t *fork_info) /* Disable signals */ sigfillset(&all_sigs); result = sigprocmask(SIG_BLOCK, &all_sigs, &fork_info->orig_sigs); - if(result == -1) { + if (result == -1) { PERROR("sigprocmask"); return; } @@ -1440,7 +1709,7 @@ static void ust_after_fork_common(ust_fork_info_t *fork_info) /* Restore signals */ result = sigprocmask(SIG_SETMASK, &fork_info->orig_sigs, NULL); - if(result == -1) { + if (result == -1) { PERROR("sigprocmask"); return; }