X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=libust%2Ftracectl.c;h=5f942cd8306a3cdb661c73bb45484782bb6a245d;hb=bc237fab2306223e429c43ff003ac06c3777be99;hp=7c65e3f82119496c6a608283c78c27ab1cc8eff4;hpb=08230db7e2e536bddf0015fa663b6d10abea30f1;p=ust.git diff --git a/libust/tracectl.c b/libust/tracectl.c index 7c65e3f..5f942cd 100644 --- a/libust/tracectl.c +++ b/libust/tracectl.c @@ -15,80 +15,77 @@ * 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 "marker.h" +#include +#include +#include #include "tracer.h" -#include "localerr.h" +#include "usterr.h" #include "ustcomm.h" -#include "relay.h" /* FIXME: remove */ +#include "buffers.h" #include "marker-control.h" -//#define USE_CLONE - -#define USTSIGNAL SIGIO - -#define MAX_MSG_SIZE (100) -#define MSG_NOTIF 1 -#define MSG_REGISTER_NOTIF 2 +/* This should only be accessed by the constructor, before the creation + * of the listener, and then only by the listener. + */ +s64 pidunique = -1LL; -char consumer_stack[10000]; +/* The process pid is used to detect a non-traceable fork + * and allow the non-traceable fork to be ignored + * by destructor sequences in libust + */ +static pid_t processpid = 0; -struct list_head blocked_consumers = LIST_HEAD_INIT(blocked_consumers); +static struct ustcomm_header _receive_header; +static struct ustcomm_header *receive_header = &_receive_header; +static char receive_buffer[USTCOMM_BUFFER_SIZE]; +static char send_buffer[USTCOMM_BUFFER_SIZE]; -static struct ustcomm_app ustcomm_app; +static int epoll_fd; +static struct ustcomm_sock *listen_sock; -struct tracecmd { /* no padding */ - uint32_t size; - uint16_t command; -}; +extern struct chan_info_struct chan_infos[]; -//struct listener_arg { -// int pipe_fd; -//}; +static struct list_head open_buffers_list = LIST_HEAD_INIT(open_buffers_list); -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 struct list_head ust_socks = LIST_HEAD_INIT(ust_socks); -struct consumer_channel { - int fd; - struct ltt_channel_struct *chan; -}; +/* volatile because shared between the listener and the main thread */ +int buffers_to_export = 0; -struct blocked_consumer { - int fd_consumer; - int fd_producer; - int tmp_poll_idx; +static long long make_pidunique(void) +{ + s64 retval; + struct timeval tv; - /* args to ustcomm_send_reply */ - struct ustcomm_server server; - struct ustcomm_source src; + gettimeofday(&tv, NULL); - /* args to ltt_do_get_subbuf */ - struct rchan_buf *rbuf; - struct ltt_channel_buf_struct *lttbuf; + retval = tv.tv_sec; + retval <<= 32; + retval |= tv.tv_usec; - struct list_head list; -}; + return retval; +} static void print_markers(FILE *fp) { @@ -98,713 +95,1030 @@ static void print_markers(FILE *fp) marker_iter_reset(&iter); marker_iter_start(&iter); - while(iter.marker) { - fprintf(fp, "marker: %s_%s %d \"%s\"\n", iter.marker->channel, iter.marker->name, (int)imv_read(iter.marker->state), iter.marker->format); + 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; -/* This needs to be called whenever a new thread is created. It notifies - * liburcu of the new thread. - */ + lock_trace_events(); + trace_event_iter_reset(&iter); + trace_event_iter_start(&iter); -void ust_register_thread(void) -{ - rcu_register_thread(); + while (iter.trace_event) { + fprintf(fp, "trace_event: %s\n", iter.trace_event->name); + trace_event_iter_next(&iter); + } + unlock_trace_events(); } -int fd_notif = -1; -void notif_cb(void) +static int connect_ustd(void) { - int result; - struct trctl_msg msg; + int result, fd; + char default_daemon_path[] = SOCK_DIR "/ustd"; + char *explicit_daemon_path, *daemon_path; + + explicit_daemon_path = getenv("UST_DAEMON_SOCKET"); + if (explicit_daemon_path) { + daemon_path = explicit_daemon_path; + } else { + daemon_path = default_daemon_path; + } + + DBG("Connecting to daemon_path %s", daemon_path); + + result = ustcomm_connect_path(daemon_path, &fd); + if (result < 0) { + WARN("connect_ustd failed, daemon_path: %s", + daemon_path); + return result; + } + + return fd; +} - /* FIXME: fd_notif should probably be protected by a spinlock */ - if(fd_notif == -1) +static void request_buffer_consumer(int sock, + const char *channel, + int cpu) +{ + struct ustcomm_header send_header, recv_header; + struct ustcomm_buffer_info buf_inf; + int result = 0; + + result = ustcomm_pack_buffer_info(&send_header, + &buf_inf, + channel, + cpu); + + if (result < 0) { + ERR("failed to pack buffer info message %s_%d", + channel, cpu); return; + } - msg.type = MSG_NOTIF; - msg.size = sizeof(msg.type); + buf_inf.pid = getpid(); + send_header.command = CONSUME_BUFFER; + + result = ustcomm_req(sock, &send_header, (char *) &buf_inf, + &recv_header, NULL); + if (result <= 0) { + PERROR("request for buffer consumer failed, is the daemon online?"); + } + + return; +} - /* FIXME: don't block here */ - result = write(fd_notif, &msg, msg.size+sizeof(msg.size)); - if(result == -1) { - PERROR("write"); +/* Ask the daemon to collect a trace called trace_name and being + * produced by this pid. + * + * The trace must be at least allocated. (It can also be started.) + * This is because _ltt_trace_find is used. + */ + +static void inform_consumer_daemon(const char *trace_name) +{ + int sock, i,j; + struct ust_trace *trace; + const char *ch_name; + + sock = connect_ustd(); + if (sock < 0) { return; } + + DBG("Connected to ustd"); + + ltt_lock_traces(); + + trace = _ltt_trace_find(trace_name); + if (trace == NULL) { + WARN("inform_consumer_daemon: could not find trace \"%s\"; it is probably already destroyed", trace_name); + goto unlock_traces; + } + + 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++) { + ch_name = trace->channels[i].channel_name; + request_buffer_consumer(sock, ch_name, j); + STORE_SHARED(buffers_to_export, + LOAD_SHARED(buffers_to_export)+1); + } + } + } + +unlock_traces: + ltt_unlock_traces(); + + close(sock); } -static void inform_consumer_daemon(void) +static struct ust_channel *find_channel(const char *ch_name, + struct ust_trace *trace) { - ustcomm_request_consumer(getpid(), "metadata"); - ustcomm_request_consumer(getpid(), "ust"); + int i; + + for (i=0; inr_channels; i++) { + if (!strcmp(trace->channels[i].channel_name, ch_name)) { + return &trace->channels[i]; + } + } + + return NULL; } -void process_blocked_consumers(void) +static int get_buffer_shmid_pipe_fd(const char *trace_name, const char *ch_name, + int ch_cpu, + int *buf_shmid, + int *buf_struct_shmid, + int *buf_pipe_fd) { - int n_fds = 0; - struct pollfd *fds; - struct blocked_consumer *bc; - int idx = 0; - char inbuf; - int result; + struct ust_trace *trace; + struct ust_channel *channel; + struct ust_buffer *buf; + + DBG("get_buffer_shmid_pipe_fd"); - list_for_each_entry(bc, &blocked_consumers, list) { - n_fds++; + ltt_lock_traces(); + trace = _ltt_trace_find(trace_name); + ltt_unlock_traces(); + + if (trace == NULL) { + ERR("cannot find trace!"); + return -ENODATA; } - fds = (struct pollfd *) malloc(n_fds * sizeof(struct pollfd)); - if(fds == NULL) { - ERR("malloc returned NULL"); - return; + channel = find_channel(ch_name, trace); + if (!channel) { + ERR("cannot find channel %s!", ch_name); + return -ENODATA; } - list_for_each_entry(bc, &blocked_consumers, list) { - fds[idx].fd = bc->fd_producer; - fds[idx].events = POLLIN; - bc->tmp_poll_idx = idx; - idx++; + buf = channel->buf[ch_cpu]; + + *buf_shmid = buf->shmid; + *buf_struct_shmid = channel->buf_struct_shmids[ch_cpu]; + *buf_pipe_fd = buf->data_ready_fd_read; + + return 0; +} + +static int get_subbuf_num_size(const char *trace_name, const char *ch_name, + int *num, int *size) +{ + struct ust_trace *trace; + struct ust_channel *channel; + + DBG("get_subbuf_size"); + + ltt_lock_traces(); + trace = _ltt_trace_find(trace_name); + ltt_unlock_traces(); + + if (!trace) { + ERR("cannot find trace!"); + return -ENODATA; } - while((result = poll(fds, n_fds, 0)) == -1 && errno == EINTR) - /* nothing */; - if(result == -1) { - PERROR("poll"); - return; + channel = find_channel(ch_name, trace); + if (!channel) { + ERR("unable to find channel"); + return -ENODATA; } - list_for_each_entry(bc, &blocked_consumers, list) { - if(fds[bc->tmp_poll_idx].revents) { - long consumed_old = 0; - char *reply; + *num = channel->subbuf_cnt; + *size = channel->subbuf_size; - result = read(bc->fd_producer, &inbuf, 1); - if(result == -1) { - PERROR("read"); - continue; - } - if(result == 0) { - DBG("PRODUCER END"); + return 0; +} - close(bc->fd_producer); +/* Return the power of two which is equal or higher to v */ - list_del(&bc->list); +static unsigned int pow2_higher_or_eq(unsigned int v) +{ + int hb = fls(v); + int retval = 1<<(hb-1); - result = ustcomm_send_reply(&bc->server, "END", &bc->src); - if(result < 0) { - ERR("ustcomm_send_reply failed"); - continue; - } + if (v-retval == 0) + return retval; + else + return retval<<1; +} - continue; - } +static int set_subbuf_size(const char *trace_name, const char *ch_name, + unsigned int size) +{ + unsigned int power; + int retval = 0; + struct ust_trace *trace; + struct ust_channel *channel; - result = ltt_do_get_subbuf(bc->rbuf, bc->lttbuf, &consumed_old); - if(result == -EAGAIN) { - WARN("missed buffer?"); - continue; - } - else if(result < 0) { - DBG("ltt_do_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); - continue; - } - free(reply); + DBG("set_subbuf_size"); - list_del(&bc->list); - } + power = pow2_higher_or_eq(size); + power = max_t(unsigned int, 2u, power); + if (power != size) { + 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) { + ERR("cannot find trace!"); + retval = -ENODATA; + goto unlock_traces; } + channel = find_channel(ch_name, trace); + if (!channel) { + ERR("unable to find channel"); + retval = -ENODATA; + goto unlock_traces; + } + + channel->subbuf_size = power; + DBG("the set_subbuf_size for the requested channel is %u", channel->subbuf_size); + +unlock_traces: + ltt_unlock_traces(); + + return retval; } -void *listener_main(void *p) +static int set_subbuf_num(const char *trace_name, const char *ch_name, + unsigned int num) { - int result; + struct ust_trace *trace; + struct ust_channel *channel; + int retval = 0; - ust_register_thread(); + DBG("set_subbuf_num"); - DBG("LISTENER"); + if (num < 2) { + ERR("subbuffer count should be greater than 2"); + return -EINVAL; + } - for(;;) { - char trace_name[] = "auto"; - char trace_type[] = "ustrelay"; - char *recvbuf; - int len; - struct ustcomm_source src; + ltt_lock_traces(); + trace = _ltt_trace_find_setup(trace_name); + if (trace == NULL) { + ERR("cannot find trace!"); + retval = -ENODATA; + goto unlock_traces; + } - process_blocked_consumers(); + channel = find_channel(ch_name, trace); + if (!channel) { + ERR("unable to find channel"); + retval = -ENODATA; + goto unlock_traces; + } - result = ustcomm_app_recv_message(&ustcomm_app, &recvbuf, &src, 5); - if(result < 0) { - WARN("error in ustcomm_app_recv_message"); - continue; - } - else if(result == 0) { - /* no message */ - continue; - } + channel->subbuf_cnt = num; + DBG("the set_subbuf_cnt for the requested channel is %zd", channel->subbuf_cnt); - DBG("received a message! it's: %s", recvbuf); - len = strlen(recvbuf); +unlock_traces: + ltt_unlock_traces(); + return retval; +} - if(!strcmp(recvbuf, "print_markers")) { - print_markers(stderr); - } - else if(!strcmp(recvbuf, "list_markers")) { - char *ptr; - size_t size; - FILE *fp; +static int get_subbuffer(const char *trace_name, const char *ch_name, + int ch_cpu, long *consumed_old) +{ + int retval = 0; + struct ust_trace *trace; + struct ust_channel *channel; + struct ust_buffer *buf; - fp = open_memstream(&ptr, &size); - print_markers(fp); - fclose(fp); + DBG("get_subbuf"); - result = ustcomm_send_reply(&ustcomm_app.server, ptr, &src); + *consumed_old = 0; - 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) { - ERR("ltt_trace_setup failed"); - return (void *)1; - } + ltt_lock_traces(); + trace = _ltt_trace_find(trace_name); - result = ltt_trace_set_type(trace_name, trace_type); - if(result < 0) { - ERR("ltt_trace_set_type failed"); - return (void *)1; - } + if (!trace) { + DBG("Cannot find trace. It was likely destroyed by the user."); + retval = -ENODATA; + goto unlock_traces; + } - result = ltt_trace_alloc(trace_name); - if(result < 0) { - ERR("ltt_trace_alloc failed"); - return (void *)1; - } + channel = find_channel(ch_name, trace); + if (!channel) { + ERR("unable to find channel"); + retval = -ENODATA; + goto unlock_traces; + } - inform_consumer_daemon(); + buf = channel->buf[ch_cpu]; - result = ltt_trace_start(trace_name); - if(result < 0) { - ERR("ltt_trace_start failed"); - continue; - } - } - else if(!strcmp(recvbuf, "trace_setup")) { - DBG("trace setup"); + retval = ust_buffers_get_subbuf(buf, consumed_old); + if (retval < 0) { + WARN("missed buffer?"); + } - result = ltt_trace_setup(trace_name); - if(result < 0) { - ERR("ltt_trace_setup failed"); - return (void *)1; - } +unlock_traces: + ltt_unlock_traces(); - result = ltt_trace_set_type(trace_name, trace_type); - if(result < 0) { - ERR("ltt_trace_set_type failed"); - return (void *)1; - } + return retval; +} + + +static int notify_buffer_mapped(const char *trace_name, + const char *ch_name, + int ch_cpu) +{ + int retval = 0; + struct ust_trace *trace; + struct ust_channel *channel; + struct ust_buffer *buf; + + DBG("get_buffer_fd"); + + ltt_lock_traces(); + trace = _ltt_trace_find(trace_name); + + if (!trace) { + retval = -ENODATA; + DBG("Cannot find trace. It was likely destroyed by the user."); + goto unlock_traces; + } + + channel = find_channel(ch_name, trace); + if (!channel) { + retval = -ENODATA; + ERR("unable to find channel"); + goto unlock_traces; + } + + buf = channel->buf[ch_cpu]; + + /* 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) { + DBG("decrementing 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); + +unlock_traces: + ltt_unlock_traces(); + + return retval; +} + +static int put_subbuffer(const char *trace_name, const char *ch_name, + int ch_cpu, long consumed_old) +{ + int retval = 0; + struct ust_trace *trace; + struct ust_channel *channel; + struct ust_buffer *buf; + + DBG("put_subbuf"); + + ltt_lock_traces(); + trace = _ltt_trace_find(trace_name); + + if (!trace) { + retval = -ENODATA; + DBG("Cannot find trace. It was likely destroyed by the user."); + goto unlock_traces; + } + + channel = find_channel(ch_name, trace); + if (!channel) { + retval = -ENODATA; + ERR("unable to find channel"); + goto unlock_traces; + } + + buf = channel->buf[ch_cpu]; + + retval = ust_buffers_put_subbuf(buf, consumed_old); + if (retval < 0) { + WARN("ust_buffers_put_subbuf: error (subbuf=%s_%d)", + ch_name, ch_cpu); + } else { + DBG("ust_buffers_put_subbuf: success (subbuf=%s_%d)", + ch_name, ch_cpu); + } + +unlock_traces: + ltt_unlock_traces(); + + return retval; +} + +static void listener_cleanup(void *ptr) +{ + ustcomm_del_named_sock(listen_sock, 0); +} + +static void force_subbuf_switch() +{ + struct ust_buffer *buf; + + list_for_each_entry(buf, &open_buffers_list, + open_buffers_list) { + ltt_force_switch(buf, FORCE_FLUSH); + } +} + +/* Simple commands are those which need only respond with a return value. */ +static int process_simple_client_cmd(int command, char *recv_buf) +{ + int result; + char trace_type[] = "ustrelay"; + char trace_name[] = "auto"; + + switch(command) { + case SET_SOCK_PATH: + { + struct ustcomm_sock_path *sock_msg; + sock_msg = (struct ustcomm_sock_path *)recv_buf; + sock_msg->sock_path = + ustcomm_restore_ptr(sock_msg->sock_path, + sock_msg->data, + sizeof(sock_msg->data)); + if (!sock_msg->sock_path) { + + return -EINVAL; + } + return setenv("UST_DAEMON_SOCKET", sock_msg->sock_path, 1); + } + case START: + /* start is an operation that setups the trace, allocates it and starts it */ + result = ltt_trace_setup(trace_name); + if (result < 0) { + ERR("ltt_trace_setup failed"); + return result; } - else if(!strcmp(recvbuf, "trace_alloc")) { - DBG("trace alloc"); - result = ltt_trace_alloc(trace_name); - if(result < 0) { - ERR("ltt_trace_alloc failed"); - return (void *)1; - } + result = ltt_trace_set_type(trace_name, trace_type); + if (result < 0) { + ERR("ltt_trace_set_type failed"); + return result; } - else if(!strcmp(recvbuf, "trace_start")) { - DBG("trace start"); - result = ltt_trace_start(trace_name); - if(result < 0) { - ERR("ltt_trace_start failed"); - continue; - } + result = ltt_trace_alloc(trace_name); + if (result < 0) { + ERR("ltt_trace_alloc failed"); + return result; } - else if(!strcmp(recvbuf, "trace_stop")) { - DBG("trace stop"); - result = ltt_trace_stop(trace_name); - if(result < 0) { - ERR("ltt_trace_stop failed"); - return (void *)1; - } + inform_consumer_daemon(trace_name); + + result = ltt_trace_start(trace_name); + if (result < 0) { + ERR("ltt_trace_start failed"); + return result; } - else if(!strcmp(recvbuf, "trace_destroy")) { - DBG("trace destroy"); + return 0; + case SETUP_TRACE: + DBG("trace setup"); - result = ltt_trace_destroy(trace_name); - if(result < 0) { - ERR("ltt_trace_destroy failed"); - return (void *)1; - } + result = ltt_trace_setup(trace_name); + if (result < 0) { + ERR("ltt_trace_setup failed"); + return result; + } + + result = ltt_trace_set_type(trace_name, trace_type); + if (result < 0) { + ERR("ltt_trace_set_type failed"); + return result; } - 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(); + return 0; + case ALLOC_TRACE: + DBG("trace alloc"); - if(trace == NULL) { - ERR("cannot find trace!"); - return (void *)1; - } + result = ltt_trace_alloc(trace_name); + if (result < 0) { + ERR("ltt_trace_alloc failed"); + return result; + } + inform_consumer_daemon(trace_name); - for(i=0; inr_channels; i++) { - struct rchan *rchan = trace->channels[i].trans_channel_data; - struct rchan_buf *rbuf = rchan->buf; - struct ltt_channel_struct *ltt_channel = (struct ltt_channel_struct *)rchan->private_data; + return 0; - if(!strcmp(trace->channels[i].channel_name, channel_name)) { - char *reply; + case CREATE_TRACE: + DBG("trace create"); - DBG("the shmid for the requested channel is %d", rbuf->shmid); - DBG("the shmid for its buffer structure is %d", ltt_channel->buf_shmid); - asprintf(&reply, "%d %d", rbuf->shmid, ltt_channel->buf_shmid); + result = ltt_trace_setup(trace_name); + if (result < 0) { + ERR("ltt_trace_setup failed"); + return result; + } - result = ustcomm_send_reply(&ustcomm_app.server, reply, &src); - if(result) { - ERR("listener: get_shmid: ustcomm_send_reply failed"); - goto next_cmd; - } + result = ltt_trace_set_type(trace_name, trace_type); + if (result < 0) { + ERR("ltt_trace_set_type failed"); + return result; + } - free(reply); + return 0; + case START_TRACE: + DBG("trace start"); - break; - } - } + result = ltt_trace_alloc(trace_name); + if (result < 0) { + ERR("ltt_trace_alloc failed"); + return result; + } + if (!result) { + inform_consumer_daemon(trace_name); } - 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; - } - ltt_lock_traces(); - trace = _ltt_trace_find(trace_name); - ltt_unlock_traces(); + result = ltt_trace_start(trace_name); + if (result < 0) { + ERR("ltt_trace_start failed"); + return result; + } - if(trace == NULL) { - ERR("cannot find trace!"); - return (void *)1; - } + return 0; + case STOP_TRACE: + DBG("trace stop"); - for(i=0; inr_channels; i++) { - struct rchan *rchan = trace->channels[i].trans_channel_data; + result = ltt_trace_stop(trace_name); + if (result < 0) { + ERR("ltt_trace_stop failed"); + return result; + } - if(!strcmp(trace->channels[i].channel_name, channel_name)) { - char *reply; + return 0; + case DESTROY_TRACE: + DBG("trace destroy"); - DBG("the n_subbufs for the requested channel is %zd", rchan->n_subbufs); - asprintf(&reply, "%zd", rchan->n_subbufs); + result = ltt_trace_destroy(trace_name, 0); + if (result < 0) { + ERR("ltt_trace_destroy failed"); + return result; + } + return 0; + case FORCE_SUBBUF_SWITCH: + /* FIXME: return codes? */ + force_subbuf_switch(); - result = ustcomm_send_reply(&ustcomm_app.server, reply, &src); - if(result) { - ERR("listener: get_n_subbufs: ustcomm_send_reply failed"); - goto next_cmd; - } + break; - free(reply); + default: + return -EINVAL; + } - break; - } - } + return 0; +} + +static void process_channel_cmd(int sock, int command, + struct ustcomm_channel_info *ch_inf) +{ + struct ustcomm_header _reply_header; + struct ustcomm_header *reply_header = &_reply_header; + struct ustcomm_channel_info *reply_msg = + (struct ustcomm_channel_info *)send_buffer; + char trace_name[] = "auto"; + int result, offset = 0, num, size; + + memset(reply_header, 0, sizeof(*reply_header)); + + switch (command) { + case GET_SUBBUF_NUM_SIZE: + result = get_subbuf_num_size(trace_name, + ch_inf->channel, + &num, &size); + if (result < 0) { + reply_header->result = result; + break; } - 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(); + reply_msg->channel = USTCOMM_POISON_PTR; + reply_msg->subbuf_num = num; + reply_msg->subbuf_size = size; - if(trace == NULL) { - ERR("cannot find trace!"); - return (void *)1; - } - for(i=0; inr_channels; i++) { - struct rchan *rchan = trace->channels[i].trans_channel_data; + reply_header->size = COMPUTE_MSG_SIZE(reply_msg, offset); - if(!strcmp(trace->channels[i].channel_name, channel_name)) { - char *reply; + break; + case SET_SUBBUF_NUM: + reply_header->result = set_subbuf_num(trace_name, + ch_inf->channel, + ch_inf->subbuf_num); - DBG("the subbuf_size for the requested channel is %zd", rchan->subbuf_size); - asprintf(&reply, "%zd", rchan->subbuf_size); + break; + case SET_SUBBUF_SIZE: + reply_header->result = set_subbuf_size(trace_name, + ch_inf->channel, + ch_inf->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; + } + if (ustcomm_send(sock, reply_header, (char *)reply_msg) < 0) { + ERR("ustcomm_send failed"); + } +} - break; - } - } +static void process_buffer_cmd(int sock, int command, + struct ustcomm_buffer_info *buf_inf) +{ + struct ustcomm_header _reply_header; + struct ustcomm_header *reply_header = &_reply_header; + struct ustcomm_buffer_info *reply_msg = + (struct ustcomm_buffer_info *)send_buffer; + char trace_name[] = "auto"; + int result, offset = 0, buf_shmid, buf_struct_shmid, buf_pipe_fd; + long consumed_old; + + memset(reply_header, 0, sizeof(*reply_header)); + + switch (command) { + case GET_BUF_SHMID_PIPE_FD: + result = get_buffer_shmid_pipe_fd(trace_name, buf_inf->channel, + buf_inf->ch_cpu, + &buf_shmid, + &buf_struct_shmid, + &buf_pipe_fd); + if (result < 0) { + reply_header->result = result; + break; } - else if(nth_token_is(recvbuf, "load_probe_lib", 0) == 1) { - char *libfile; - libfile = nth_token(recvbuf, 1); + reply_msg->channel = USTCOMM_POISON_PTR; + reply_msg->buf_shmid = buf_shmid; + reply_msg->buf_struct_shmid = buf_struct_shmid; + + reply_header->size = COMPUTE_MSG_SIZE(reply_msg, offset); + reply_header->fd_included = 1; - DBG("load_probe_lib loading %s", libfile); + if (ustcomm_send_fd(sock, reply_header, (char *)reply_msg, + &buf_pipe_fd) < 0) { + ERR("ustcomm_send failed"); } - else if(nth_token_is(recvbuf, "get_subbuffer", 0) == 1) { - struct ltt_trace_struct *trace; - char trace_name[] = "auto"; - int i; - char *channel_name; - - DBG("get_subbuf"); - - channel_name = nth_token(recvbuf, 1); - if(channel_name == NULL) { - ERR("get_subbuf: cannot parse channel"); - goto next_cmd; - } + return; - ltt_lock_traces(); - trace = _ltt_trace_find(trace_name); - ltt_unlock_traces(); + case NOTIFY_BUF_MAPPED: + reply_header->result = + notify_buffer_mapped(trace_name, + buf_inf->channel, + buf_inf->ch_cpu); + break; + case GET_SUBBUFFER: + result = get_subbuffer(trace_name, buf_inf->channel, + buf_inf->ch_cpu, &consumed_old); + if (result < 0) { + reply_header->result = result; + break; + } - if(trace == NULL) { - ERR("cannot find trace!"); - return (void *)1; - } + reply_msg->channel = USTCOMM_POISON_PTR; + reply_msg->consumed_old = consumed_old; - for(i=0; inr_channels; i++) { - struct rchan *rchan = trace->channels[i].trans_channel_data; - - if(!strcmp(trace->channels[i].channel_name, channel_name)) { - struct rchan_buf *rbuf = rchan->buf; - struct ltt_channel_buf_struct *lttbuf = trace->channels[i].buf; - struct blocked_consumer *bc; - - bc = (struct blocked_consumer *) malloc(sizeof(struct blocked_consumer)); - if(bc == NULL) { - ERR("malloc returned NULL"); - goto next_cmd; - } - bc->fd_consumer = src.fd; - bc->fd_producer = lttbuf->data_ready_fd_read; - bc->rbuf = rbuf; - bc->lttbuf = lttbuf; - bc->src = src; - bc->server = ustcomm_app.server; - - list_add(&bc->list, &blocked_consumers); - - break; - } - } - } - else if(nth_token_is(recvbuf, "put_subbuffer", 0) == 1) { - struct ltt_trace_struct *trace; - char trace_name[] = "auto"; - int i; - char *channel_name; - long consumed_old; - char *consumed_old_str; - char *endptr; - - DBG("put_subbuf"); - - channel_name = strdup_malloc(nth_token(recvbuf, 1)); - if(channel_name == NULL) { - ERR("put_subbuf_size: cannot parse channel"); - goto next_cmd; - } + reply_header->size = COMPUTE_MSG_SIZE(reply_msg, offset); - consumed_old_str = strdup_malloc(nth_token(recvbuf, 2)); - if(consumed_old_str == NULL) { - ERR("put_subbuf: cannot parse consumed_old"); - goto next_cmd; - } - consumed_old = strtol(consumed_old_str, &endptr, 10); - if(*endptr != '\0') { - ERR("put_subbuf: invalid value for consumed_old"); - goto next_cmd; - } + break; + case PUT_SUBBUFFER: + result = put_subbuffer(trace_name, buf_inf->channel, + buf_inf->ch_cpu, + buf_inf->consumed_old); + reply_header->result = result; - ltt_lock_traces(); - trace = _ltt_trace_find(trace_name); - ltt_unlock_traces(); + break; + } - if(trace == NULL) { - ERR("cannot find trace!"); - return (void *)1; - } + if (ustcomm_send(sock, reply_header, (char *)reply_msg) < 0) { + ERR("ustcomm_send failed"); + } - for(i=0; inr_channels; i++) { - struct rchan *rchan = trace->channels[i].trans_channel_data; - - if(!strcmp(trace->channels[i].channel_name, channel_name)) { - struct rchan_buf *rbuf = rchan->buf; - struct ltt_channel_buf_struct *lttbuf = trace->channels[i].buf; - char *reply; - long consumed_old=0; - - result = ltt_do_put_subbuf(rbuf, lttbuf, consumed_old); - if(result < 0) { - WARN("ltt_do_put_subbuf: error (subbuf=%s)", channel_name); - asprintf(&reply, "%s", "ERROR"); - } - else { - DBG("ltt_do_put_subbuf: success (subbuf=%s)", channel_name); - asprintf(&reply, "%s", "OK"); - } - - result = ustcomm_send_reply(&ustcomm_app.server, reply, &src); - if(result) { - ERR("listener: put_subbuf: ustcomm_send_reply failed"); - goto next_cmd; - } - - free(reply); - - break; - } - } +} + +static void process_marker_cmd(int sock, int command, + struct ustcomm_marker_info *marker_inf) +{ + struct ustcomm_header _reply_header; + struct ustcomm_header *reply_header = &_reply_header; + int result; + + memset(reply_header, 0, sizeof(*reply_header)); + + switch(command) { + case ENABLE_MARKER: - free(channel_name); - free(consumed_old_str); + result = ltt_marker_connect(marker_inf->channel, + marker_inf->marker, + "default"); + if (result < 0) { + WARN("could not enable marker; channel=%s," + " name=%s", + marker_inf->channel, + marker_inf->marker); + + } + break; + case DISABLE_MARKER: + result = ltt_marker_disconnect(marker_inf->channel, + marker_inf->marker, + "default"); + if (result < 0) { + WARN("could not disable marker; channel=%s," + " name=%s", + marker_inf->channel, + marker_inf->marker); } - 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]=""; + break; + } - result = sscanf(channel_slash_name, "%255[^/]/%255s", channel_name, marker_name); + reply_header->result = result; - if(channel_name == NULL || marker_name == NULL) { - WARN("invalid marker name"); - goto next_cmd; - } - printf("%s %s\n", channel_name, marker_name); + if (ustcomm_send(sock, reply_header, NULL) < 0) { + ERR("ustcomm_send failed"); + } - result = ltt_marker_connect(channel_name, marker_name, "default"); - if(result < 0) { - WARN("could not enable marker; channel=%s, name=%s", channel_name, marker_name); - } +} +static void process_client_cmd(struct ustcomm_header *recv_header, + char *recv_buf, int sock) +{ + int result; + struct ustcomm_header _reply_header; + struct ustcomm_header *reply_header = &_reply_header; + char *send_buf = send_buffer; + + memset(reply_header, 0, sizeof(*reply_header)); + memset(send_buf, 0, sizeof(send_buffer)); + + switch(recv_header->command) { + case GET_SUBBUF_NUM_SIZE: + case SET_SUBBUF_NUM: + case SET_SUBBUF_SIZE: + { + struct ustcomm_channel_info *ch_inf; + ch_inf = (struct ustcomm_channel_info *)recv_buf; + result = ustcomm_unpack_channel_info(ch_inf); + if (result < 0) { + ERR("couldn't unpack channel info"); + reply_header->result = -EINVAL; + goto send_response; + } + process_channel_cmd(sock, recv_header->command, ch_inf); + return; + } + case GET_BUF_SHMID_PIPE_FD: + case NOTIFY_BUF_MAPPED: + case GET_SUBBUFFER: + case PUT_SUBBUFFER: + { + struct ustcomm_buffer_info *buf_inf; + buf_inf = (struct ustcomm_buffer_info *)recv_buf; + result = ustcomm_unpack_buffer_info(buf_inf); + if (result < 0) { + ERR("couldn't unpack buffer info"); + reply_header->result = -EINVAL; + goto send_response; + } + process_buffer_cmd(sock, recv_header->command, buf_inf); + return; + } + case ENABLE_MARKER: + case DISABLE_MARKER: + { + struct ustcomm_marker_info *marker_inf; + marker_inf = (struct ustcomm_marker_info *)recv_buf; + result = ustcomm_unpack_marker_info(marker_inf); + if (result < 0) { + ERR("couldn't unpack marker info"); + reply_header->result = -EINVAL; + goto send_response; } - else if(nth_token_is(recvbuf, "disable_marker", 0) == 1) { - char *channel_slash_name = nth_token(recvbuf, 1); - char *marker_name; - char *channel_name; + process_marker_cmd(sock, recv_header->command, marker_inf); + return; + } + case LIST_MARKERS: + { + char *ptr; + size_t size; + FILE *fp; + + fp = open_memstream(&ptr, &size); + if (fp == NULL) { + ERR("opening memstream failed"); + return; + } + print_markers(fp); + fclose(fp); - result = sscanf(channel_slash_name, "%a[^/]/%as", &channel_name, &marker_name); + reply_header->size = size; - if(marker_name == NULL) { - } - printf("%s %s\n", channel_name, marker_name); + result = ustcomm_send(sock, reply_header, ptr); - result = ltt_marker_disconnect(channel_name, marker_name, "default"); - if(result < 0) { - WARN("could not disable marker; channel=%s, name=%s", channel_name, marker_name); - } + free(ptr); + + if (result < 0) { + PERROR("failed to send markers list"); } -// else if(nth_token_is(recvbuf, "get_notifications", 0) == 1) { -// struct ltt_trace_struct *trace; -// char trace_name[] = "auto"; -// int i; -// char *channel_name; -// -// DBG("get_notifications"); -// -// channel_name = strdup_malloc(nth_token(recvbuf, 1)); -// if(channel_name == NULL) { -// ERR("put_subbuf_size: cannot parse channel"); -// goto next_cmd; -// } -// -// ltt_lock_traces(); -// trace = _ltt_trace_find(trace_name); -// ltt_unlock_traces(); -// -// if(trace == NULL) { -// ERR("cannot find trace!"); -// return (void *)1; -// } -// -// for(i=0; inr_channels; i++) { -// struct rchan *rchan = trace->channels[i].trans_channel_data; -// int fd; -// -// if(!strcmp(trace->channels[i].channel_name, channel_name)) { -// struct rchan_buf *rbuf = rchan->buf; -// struct ltt_channel_buf_struct *lttbuf = trace->channels[i].buf; -// -// result = fd = ustcomm_app_detach_client(&ustcomm_app, &src); -// if(result == -1) { -// ERR("ustcomm_app_detach_client failed"); -// goto next_cmd; -// } -// -// lttbuf->wake_consumer_arg = (void *) fd; -// -// smp_wmb(); -// -// lttbuf->call_wake_consumer = 1; -// -// break; -// } -// } -// -// free(channel_name); -// } - else { - ERR("unable to parse message: %s", recvbuf); + + break; + } + case LIST_TRACE_EVENTS: + { + char *ptr; + size_t size; + FILE *fp; + + fp = open_memstream(&ptr, &size); + if (fp == NULL) { + ERR("opening memstream failed"); + return; + } + print_trace_events(fp); + fclose(fp); + + reply_header->size = size; + + result = ustcomm_send(sock, reply_header, ptr); + + free(ptr); + + if (result < 0) { + ERR("list_trace_events failed"); + return; } - next_cmd: - free(recvbuf); + break; } -} + case LOAD_PROBE_LIB: + { + char *libfile; -int have_listener = 0; + /* FIXME: No functionality at all... */ + libfile = recv_buf; -void create_listener(void) -{ -#ifdef USE_CLONE - static char listener_stack[16384]; -#else - pthread_t thread; -#endif + DBG("load_probe_lib loading %s", libfile); - if(have_listener) - return; + break; + } + case GET_PIDUNIQUE: + { + struct ustcomm_pidunique *pid_msg; + pid_msg = (struct ustcomm_pidunique *)send_buf; + + pid_msg->pidunique = pidunique; + reply_header->size = sizeof(pid_msg); + + goto send_response; -#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"); - return; } -#else + case GET_SOCK_PATH: + { + struct ustcomm_sock_path *sock_msg; + char *sock_path_env; - pthread_create(&thread, NULL, listener_main, NULL); -#endif + sock_msg = (struct ustcomm_sock_path *)send_buf; - have_listener = 1; -} + sock_path_env = getenv("UST_DAEMON_SOCKET"); -/* The signal handler itself. Signals must be setup so there cannot be - nested signals. */ + if (!sock_path_env) { + result = ustcomm_pack_sock_path(reply_header, + sock_msg, + SOCK_DIR "/ustd"); -void sighandler(int sig) -{ - static char have_listener = 0; - DBG("sighandler"); + } else { + result = ustcomm_pack_sock_path(reply_header, + sock_msg, + sock_path_env); + } + reply_header->result = result; - if(!have_listener) { - create_listener(); - have_listener = 1; + goto send_response; } -} + default: + reply_header->result = + process_simple_client_cmd(recv_header->command, + recv_buf); + goto send_response; -/* Called by the app signal handler to chain it to us. */ + } -void chain_signal(void) -{ - sighandler(USTSIGNAL); + return; + +send_response: + ustcomm_send(sock, reply_header, send_buf); } -static int init_socket(void) +#define MAX_EVENTS 10 + +void *listener_main(void *p) { - return ustcomm_init_app(getpid(), &ustcomm_app); + 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(;;) { + nfds = epoll_wait(epoll_fd, events, MAX_EVENTS, -1); + if (nfds == -1) { + PERROR("listener_main: epoll_wait failed"); + continue; + } + + 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 { + memset(receive_header, 0, + sizeof(*receive_header)); + memset(receive_buffer, 0, + sizeof(receive_buffer)); + result = ustcomm_recv(epoll_sock->fd, + receive_header, + receive_buffer); + if (result == 0) { + ustcomm_del_sock(epoll_sock, 0); + } else { + process_client_cmd(receive_header, + receive_buffer, + epoll_sock->fd); + } + } + } + } + + pthread_cleanup_pop(1); } -/* FIXME: reenable this to delete socket file. */ +/* These should only be accessed in the parent thread, + * not the listener. + */ +static volatile sig_atomic_t have_listener = 0; +static pthread_t listener_thread; -#if 0 -static void destroy_socket(void) +void create_listener(void) { int result; + sigset_t sig_all_blocked; + sigset_t orig_parent_mask; - if(mysocketfile[0] == '\0') + if (have_listener) { + WARN("not creating listener because we already had one"); return; - - result = unlink(mysocketfile); - if(result == -1) { - PERROR("unlink"); } -} -#endif -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 - * use the chaining function. + /* 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. */ - int result; - struct sigaction act; + sigfillset(&sig_all_blocked); - result = sigemptyset(&act.sa_mask); - if(result == -1) { - PERROR("sigemptyset"); - return -1; + result = pthread_sigmask(SIG_SETMASK, &sig_all_blocked, &orig_parent_mask); + if (result) { + PERROR("pthread_sigmask: %s", strerror(result)); } - act.sa_handler = sighandler; - act.sa_flags = SA_RESTART; - - /* Only defer ourselves. Also, try to restart interrupted - * syscalls to disturb the traced program as little as possible. - */ - result = sigaction(SIGIO, &act, NULL); - if(result == -1) { - PERROR("sigaction"); - return -1; + result = pthread_create(&listener_thread, NULL, listener_main, NULL); + if (result == -1) { + PERROR("pthread_create"); } - return 0; + /* 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 @@ -820,12 +1134,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; @@ -838,41 +1151,85 @@ 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 %s to probe default", m->channel, m->name); + DBG("auto connected marker %s (addr: %p) %s to probe default", m->channel, m, m->name); } -static void __attribute__((constructor(1000))) init() +static struct ustcomm_sock * init_app_socket(int epoll_fd) { + char *name; int result; - char* autoprobe_val = NULL; + 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; + } - /* Initialize RCU in case the constructor order is not good. */ - urcu_init(); + free(name); + return sock; - /* It is important to do this before events start to be generated. */ - ust_register_thread(); +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). + */ + pidunique = make_pidunique(); + processpid = getpid(); DBG("Tracectl constructor"); - /* Must create socket before signal handler to prevent races. - */ - 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; } - result = init_signal_handler(); - if(result == -1) { - ERR("init_signal_handler error"); + + /* 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."); @@ -886,7 +1243,7 @@ static void __attribute__((constructor(1000))) 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]; @@ -894,12 +1251,10 @@ static void __attribute__((constructor(1000))) 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; } @@ -911,14 +1266,49 @@ static void __attribute__((constructor(1000))) 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"; @@ -927,41 +1317,62 @@ static void __attribute__((constructor(1000))) init() /* Ensure marker control is initialized */ init_marker_control(); - /* Ensure relay is initialized */ - init_ustrelay_transport(); - /* Ensure markers are initialized */ init_markers(); - /* In case. */ + /* Ensure buffers are initialized, for the transport to be available. + * We are about to set a trace type and it will fail without this. + */ + init_ustrelay_transport(); + + /* FIXME: When starting early tracing (here), depending on the + * order of constructors, it is very well possible some marker + * sections are not yet registered. Because of this, some + * channels may not be registered. Yet, we are about to ask the + * daemon to collect the channels. Channels which are not yet + * registered will not be collected. + * + * Currently, in LTTng, there is no way to add a channel after + * trace start. The reason for this is that it induces complex + * concurrency issues on the trace structures, which can only + * be resolved using RCU. This has not been done yet. As a + * workaround, we are forcing the registration of the "ust" + * channel here. This is the only channel (apart from metadata) + * that can be reliably used in early tracing. + * + * Non-early tracing does not have this problem and can use + * arbitrary channel names. + */ 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; } - inform_consumer_daemon(); - } + /* Do this after the trace is started in order to avoid creating confusion + * if the trace fails to start. */ + inform_consumer_daemon(trace_name); + } return; @@ -970,11 +1381,17 @@ static void __attribute__((constructor(1000))) init() } /* This is only called if we terminate normally, not with an unhandled signal, - * so we cannot rely on it. */ + * so we cannot rely on it. However, for now, LTTV requires that the header of + * the last sub-buffer contain a valid end time for the trace. This is done + * automatically only when the trace is properly stopped. + * + * If the traced program crashed, it is always possible to manually add the + * right value in the header, or to open the trace in text mode. + * + * FIXME: Fix LTTV so it doesn't need this. + */ -/* This destructor probably isn't needed, because ustd can do crash recovery. */ -#if 0 -static void __attribute__((destructor)) fini() +static void destroy_traces(void) { int result; @@ -983,29 +1400,25 @@ static void __attribute__((destructor)) fini() 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"); - if(result == -1) { + result = ltt_trace_destroy("auto", 0); + if (result == -1) { ERR("ltt_trace_destroy error"); } - - destroy_socket(); } -#endif -#if 0 static int trace_recording(void) { int retval = 0; - struct ltt_trace_struct *trace; + struct ust_trace *trace; ltt_lock_traces(); list_for_each_entry(trace, <t_traces.head, list) { - if(trace->active) { + if (trace->active) { retval = 1; break; } @@ -1016,92 +1429,214 @@ static int trace_recording(void) return retval; } -static int have_consumer(void) +int restarting_usleep(useconds_t usecs) +{ + struct timespec tv; + int result; + + tv.tv_sec = 0; + tv.tv_nsec = usecs * 1000; + + do { + result = nanosleep(&tv, &tv); + } while (result == -1 && errno == EINTR); + + return result; +} + +static void stop_listener(void) { - return !list_empty(&blocked_consumers); + int result; + + if (!have_listener) + return; + + result = pthread_cancel(listener_thread); + if (result != 0) { + ERR("pthread_cancel: %s", strerror(result)); + } + result = pthread_join(listener_thread, NULL); + if (result != 0) { + ERR("pthread_join: %s", strerror(result)); + } } /* This destructor keeps the process alive for a few seconds in order - * to leave time to ustd to consume its buffers. + * to leave time to ustd to connect to its buffers. This is necessary + * for programs whose execution is very short. It is also useful in all + * programs when tracing is started close to the end of the program + * execution. + * + * FIXME: For now, this only works for the first trace created in a + * process. */ -int restarting_sleep(int secs) +static void __attribute__((destructor)) keepalive() { - struct timespec tv; - int result; - - tv.tv_sec = secs; - tv.tv_nsec = 0; - - do { - result = nanosleep(&tv, &tv); - } while(result == -1 && errno == EINTR); + if (processpid != getpid()) { + return; + } - return result; + if (trace_recording() && LOAD_SHARED(buffers_to_export)) { + int total = 0; + DBG("Keeping process alive for consumer daemon..."); + while (LOAD_SHARED(buffers_to_export)) { + const int interv = 200000; + restarting_usleep(interv); + total += interv; + + if (total >= 3000000) { + WARN("non-consumed buffers remaining after wait limit; not waiting anymore"); + break; + } + } + DBG("Finally dying..."); + } + + destroy_traces(); + + /* Ask the listener to stop and clean up. */ + stop_listener(); } -static void __attribute__((destructor)) keepalive() +void ust_potential_exec(void) { -// struct ustcomm_ustd ustd; -// int result; -// sigset_t sigset; -// -// result = sigemptyset(&sigset); -// if(result == -1) { -// perror("sigemptyset"); -// return; -// } -// result = sigaddset(&sigset, SIGIO); -// if(result == -1) { -// perror("sigaddset"); -// return; -// } -// result = sigprocmask(SIG_BLOCK, &sigset, NULL); -// if(result == -1) { -// perror("sigprocmask"); -// return; -// } -// -// if(trace_recording()) { -// if(!have_consumer()) { -// /* Request listener creation. We've blocked SIGIO's in -// * order to not interrupt sleep(), so we will miss the -// * one sent by the daemon and therefore won't create -// * the listener automatically. -// */ -// create_listener(); -// - printf("Keeping process alive for consumer daemon...\n"); - restarting_sleep(3); - printf("Finally dying...\n"); -// } -// } -// -// result = sigprocmask(SIG_UNBLOCK, &sigset, NULL); -// if(result == -1) { -// perror("sigprocmask"); -// return; -// } + trace_mark(ust, potential_exec, MARK_NOARGS); + + DBG("test"); + + keepalive(); } -#endif /* Notify ust that there was a fork. This needs to be called inside * the new process, anytime a process whose memory is not shared with * the parent is created. If this function is not called, the events * of the new process will not be collected. + * + * Signals should be disabled before the fork and reenabled only after + * this call in order to guarantee tracing is not started before ust_fork() + * sanitizes the new process. */ -void ust_fork(void) +static void ust_fork(void) { + 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 */ DBG("ust: forking"); + + /* Get the pid of the new process */ + processpid = getpid(); + + /* break lock if necessary */ + ltt_unlock_traces(); + ltt_trace_stop("auto"); - ltt_trace_destroy("auto"); - ltt_trace_alloc("auto"); - ltt_trace_start("auto"); - init_socket(); + ltt_trace_destroy("auto", 1); + /* 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_safe(buf, buf_tmp, &open_buffers_list, + open_buffers_list) { + result = close(buf->data_ready_fd_read); + if (result == -1) { + PERROR("close"); + } + result = close(buf->data_ready_fd_write); + if (result == -1) { + PERROR("close"); + } + list_del(&buf->open_buffers_list); + } + + /* Clean up the listener socket and epoll, keeping the scoket file */ + ustcomm_del_named_sock(listen_sock, 1); + close(epoll_fd); + + /* Re-start the launch sequence */ + STORE_SHARED(buffers_to_export, 0); have_listener = 0; + + /* 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(); - ustcomm_request_consumer(getpid(), "metadata"); - ustcomm_request_consumer(getpid(), "ust"); + ltt_trace_setup("auto"); + result = ltt_trace_set_type("auto", "ustrelay"); + if (result < 0) { + ERR("ltt_trace_set_type failed"); + return; + } + + ltt_trace_alloc("auto"); + ltt_trace_start("auto"); + inform_consumer_daemon("auto"); +} + +void ust_before_fork(ust_fork_info_t *fork_info) +{ + /* Disable signals. This is to avoid that the child + * intervenes before it is properly setup for tracing. It is + * safer to disable all signals, because then we know we are not + * breaking anything by restoring the original mask. + */ + sigset_t all_sigs; + int result; + + /* FIXME: + - only do this if tracing is active + */ + + /* Disable signals */ + sigfillset(&all_sigs); + result = sigprocmask(SIG_BLOCK, &all_sigs, &fork_info->orig_sigs); + if (result == -1) { + PERROR("sigprocmask"); + return; + } +} + +/* Don't call this function directly in a traced program */ +static void ust_after_fork_common(ust_fork_info_t *fork_info) +{ + int result; + + /* Restore signals */ + result = sigprocmask(SIG_SETMASK, &fork_info->orig_sigs, NULL); + if (result == -1) { + PERROR("sigprocmask"); + return; + } +} + +void ust_after_fork_parent(ust_fork_info_t *fork_info) +{ + /* Reenable signals */ + ust_after_fork_common(fork_info); +} + +void ust_after_fork_child(ust_fork_info_t *fork_info) +{ + /* First sanitize the child */ + ust_fork(); + + /* Then reenable interrupts */ + ust_after_fork_common(fork_info); }