* 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 <stdio.h>
+#include <stdlib.h>
#include <stdint.h>
+#include <pthread.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>
-#include <sched.h>
#include <fcntl.h>
#include <poll.h>
#include <regex.h>
-
-#include <urcu-bp.h>
+#include <urcu/uatomic_arch.h>
#include <ust/marker.h>
+#include <ust/tracepoint.h>
#include <ust/tracectl.h>
#include "tracer.h"
#include "usterr.h"
#include "ustcomm.h"
#include "buffers.h"
#include "marker-control.h"
-
-//#define USE_CLONE
+#include "multipoll.h"
#define USTSIGNAL SIGIO
#define MSG_NOTIF 1
#define MSG_REGISTER_NOTIF 2
-char consumer_stack[10000];
-
/* This should only be accessed by the constructor, before the creation
* of the listener, and then only by the listener.
*/
s64 pidunique = -1LL;
+extern struct chan_info_struct chan_infos[];
+
struct list_head blocked_consumers = LIST_HEAD_INIT(blocked_consumers);
static struct ustcomm_app ustcomm_app;
};
/* volatile because shared between the listener and the main thread */
-volatile sig_atomic_t buffers_to_export = 0;
+int buffers_to_export = 0;
struct trctl_msg {
/* size: the size of all the fields except size itself */
marker_iter_reset(&iter);
marker_iter_start(&iter);
- while(iter.marker) {
+ 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);
-
-/* This needs to be called whenever a new thread is created. It notifies
- * liburcu of the new thread.
- */
-
-void ust_register_thread(void)
+static void print_trace_events(FILE *fp)
{
- rcu_register_thread();
-}
+ struct trace_event_iter iter;
-int fd_notif = -1;
-void notif_cb(void)
-{
- int result;
- struct trctl_msg msg;
-
- /* FIXME: fd_notif should probably be protected by a spinlock */
-
- if(fd_notif == -1)
- return;
+ lock_trace_events();
+ trace_event_iter_reset(&iter);
+ trace_event_iter_start(&iter);
- msg.type = MSG_NOTIF;
- msg.size = sizeof(msg.type);
-
- /* FIXME: don't block here */
- result = write(fd_notif, &msg, msg.size+sizeof(msg.size));
- if(result == -1) {
- PERROR("write");
- return;
+ while (iter.trace_event) {
+ fprintf(fp, "trace_event: %s\n", iter.trace_event->name);
+ trace_event_iter_next(&iter);
}
+ unlock_trace_events();
}
+static int init_socket(void);
+
/* Ask the daemon to collect a trace called trace_name and being
* produced by this pid.
*
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; j<trace->channels[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; j<trace->channels[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++;
}
}
ltt_unlock_traces();
}
-void process_blocked_consumers(void)
+int process_blkd_consumer_act(void *priv, int fd, short events)
{
- int n_fds = 0;
- struct pollfd *fds;
- struct blocked_consumer *bc;
- int idx = 0;
- char inbuf;
int result;
+ long consumed_old = 0;
+ char *reply;
+ struct blocked_consumer *bc = (struct blocked_consumer *) priv;
+ char inbuf;
- list_for_each_entry(bc, &blocked_consumers, list) {
- n_fds++;
- }
-
- fds = (struct pollfd *) malloc(n_fds * sizeof(struct pollfd));
- if(fds == NULL) {
- ERR("malloc returned NULL");
- return;
- }
-
- list_for_each_entry(bc, &blocked_consumers, list) {
- fds[idx].fd = bc->fd_producer;
- fds[idx].events = POLLIN;
- bc->tmp_poll_idx = idx;
- idx++;
+ 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");
- while((result = poll(fds, n_fds, 0)) == -1 && errno == EINTR)
- /* nothing */;
- if(result == -1) {
- PERROR("poll");
- return;
- }
+ res = close(bc->fd_producer);
+ if (res == -1) {
+ PERROR("close");
+ }
- list_for_each_entry(bc, &blocked_consumers, list) {
- if(fds[bc->tmp_poll_idx].revents) {
- long consumed_old = 0;
- char *reply;
+ list_del(&bc->list);
- result = read(bc->fd_producer, &inbuf, 1);
- if(result == -1) {
- PERROR("read");
- continue;
- }
- if(result == 0) {
- DBG("PRODUCER END");
+ result = ustcomm_send_reply(&bc->server, "END", &bc->src);
+ if (result < 0) {
+ ERR("ustcomm_send_reply failed");
+ return -1;
+ }
- close(bc->fd_producer);
+ return 0;
+ }
- list_del(&bc->list);
+ 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));
+ }
+ if (asprintf(&reply, "%s %ld", "OK", consumed_old) < 0) {
+ ERR("process_blkd_consumer_act : asprintf failed (OK %ld)",
+ consumed_old);
+ return -1;
+ }
+ result = ustcomm_send_reply(&bc->server, reply, &bc->src);
+ if (result < 0) {
+ ERR("ustcomm_send_reply failed");
+ free(reply);
+ return -1;
+ }
+ free(reply);
- result = ustcomm_send_reply(&bc->server, "END", &bc->src);
- if(result < 0) {
- ERR("ustcomm_send_reply failed");
- continue;
- }
+ list_del(&bc->list);
- continue;
- }
+ return 0;
+}
- result = ust_buffers_get_subbuf(bc->buf, &consumed_old);
- if(result == -EAGAIN) {
- WARN("missed buffer?");
- continue;
- }
- else if(result < 0) {
- DBG("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);
- continue;
- }
- free(reply);
+void blocked_consumers_add_to_mp(struct mpentries *ent)
+{
+ struct blocked_consumer *bc;
- list_del(&bc->list);
- }
+ list_for_each_entry(bc, &blocked_consumers, list) {
+ multipoll_add(ent, bc->fd_producer, POLLIN, process_blkd_consumer_act, bc, NULL);
}
}
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)
DBG("get_shmid");
channel_and_cpu = nth_token(recvbuf, 1);
- if(channel_and_cpu == NULL) {
- ERR("get_shmid: cannot parse channel");
+ 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");
+ if (ch_cpu == -1) {
+ ERR("problem parsing channel name");
+ retval = -1;
goto free_short_chan_name;
}
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; i<trace->nr_channels; i++) {
+ for (i=0; i<trace->nr_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) {
- ERR("listener: get_shmid: ustcomm_send_reply failed");
+ if (result) {
+ ERR("ustcomm_send_reply failed");
free(reply);
retval = -1;
goto free_short_chan_name;
}
}
- if(found) {
- buffers_to_export--;
- }
- else {
- ERR("get_shmid: channel not found (%s)", channel_and_cpu);
+ if (!found) {
+ ERR("channel not found (%s)", channel_and_cpu);
}
free_short_chan_name:
DBG("get_n_subbufs");
channel_and_cpu = nth_token(recvbuf, 1);
- if(channel_and_cpu == NULL) {
- ERR("get_n_subbufs: cannot parse channel");
+ 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");
+ if (ch_cpu == -1) {
+ ERR("problem parsing channel name");
+ retval = -1;
goto free_short_chan_name;
}
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; 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)) {
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) {
- ERR("listener: get_n_subbufs: ustcomm_send_reply failed");
+ if (result) {
+ ERR("ustcomm_send_reply failed");
free(reply);
retval = -1;
goto free_short_chan_name;
break;
}
}
- if(found == 0) {
- ERR("get_n_subbufs: unable to find channel");
+ if (found == 0) {
+ ERR("unable to find channel");
}
free_short_chan_name:
DBG("get_subbuf_size");
channel_and_cpu = nth_token(recvbuf, 1);
- if(channel_and_cpu == NULL) {
- ERR("get_subbuf_size: cannot parse channel");
+ 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");
+ if (ch_cpu == -1) {
+ ERR("problem parsing channel name");
+ retval = -1;
goto free_short_chan_name;
}
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; 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)) {
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) {
- ERR("listener: get_subbuf_size: ustcomm_send_reply failed");
+ if (result) {
+ ERR("ustcomm_send_reply failed");
free(reply);
retval = -1;
goto free_short_chan_name;
break;
}
}
- if(found == 0) {
- ERR("get_subbuf_size: unable to find channel");
+ if (found == 0) {
+ ERR("unable to find channel");
}
free_short_chan_name:
return retval;
}
+/* Return the power of two which is equal or higher to v */
+
+static unsigned int pow2_higher_or_eq(unsigned int v)
+{
+ int hb = fls(v);
+ int retval = 1<<(hb-1);
+
+ if (v-retval == 0)
+ return retval;
+ else
+ return retval<<1;
+}
+
+static int do_cmd_set_subbuf_size(const char *recvbuf, struct ustcomm_source *src)
+{
+ char *channel_slash_size;
+ char ch_name[256]="";
+ unsigned int size, power;
+ int retval = 0;
+ struct ust_trace *trace;
+ char trace_name[] = "auto";
+ int i;
+ int found = 0;
+
+ DBG("set_subbuf_size");
+
+ channel_slash_size = nth_token(recvbuf, 1);
+ sscanf(channel_slash_size, "%255[^/]/%u", ch_name, &size);
+
+ if (ch_name == NULL) {
+ ERR("cannot parse channel");
+ retval = -1;
+ goto end;
+ }
+
+ 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 = -1;
+ goto end;
+ }
+
+ for (i = 0; i < trace->nr_channels; i++) {
+ struct ust_channel *channel = &trace->channels[i];
+
+ 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);
+
+ found = 1;
+ break;
+ }
+ }
+ if (found == 0) {
+ ERR("unable to find channel");
+ }
+
+ end:
+ ltt_unlock_traces();
+ return retval;
+}
+
+static int do_cmd_set_subbuf_num(const char *recvbuf, struct ustcomm_source *src)
+{
+ char *channel_slash_num;
+ char ch_name[256]="";
+ unsigned int num;
+ int retval = 0;
+ struct ust_trace *trace;
+ char trace_name[] = "auto";
+ int i;
+ int found = 0;
+
+ DBG("set_subbuf_num");
+
+ channel_slash_num = nth_token(recvbuf, 1);
+ sscanf(channel_slash_num, "%255[^/]/%u", ch_name, &num);
+
+ 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) {
+ ERR("cannot find trace!");
+ retval = -1;
+ goto end;
+ }
+
+ for (i = 0; i < trace->nr_channels; i++) {
+ struct ust_channel *channel = &trace->channels[i];
+
+ 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);
+
+ found = 1;
+ break;
+ }
+ }
+ if (found == 0) {
+ ERR("unable to find channel");
+ }
+
+ end:
+ ltt_unlock_traces();
+ return retval;
+}
+
static int do_cmd_get_subbuffer(const char *recvbuf, struct ustcomm_source *src)
{
int retval = 0;
DBG("get_subbuf");
channel_and_cpu = nth_token(recvbuf, 1);
- if(channel_and_cpu == NULL) {
- ERR("get_subbuf: cannot parse channel");
+ 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");
+ 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);
- ltt_unlock_traces();
- if(trace == NULL) {
- char *reply;
+ if (trace == NULL) {
int result;
- WARN("Cannot find trace. It was likely destroyed by the user.");
- asprintf(&reply, "%s", "NOTFOUND");
- result = ustcomm_send_reply(&ustcomm_app.server, reply, src);
- if(result) {
+ DBG("Cannot find trace. It was likely destroyed by the user.");
+ result = ustcomm_send_reply(&ustcomm_app.server, "NOTFOUND", src);
+ if (result) {
ERR("ustcomm_send_reply failed");
- free(reply);
retval = -1;
- goto free_short_chan_name;
+ goto unlock_traces;
}
- free(reply);
- goto free_short_chan_name;
+ goto unlock_traces;
}
- 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)) {
struct ust_buffer *buf = channel->buf[ch_cpu];
struct blocked_consumer *bc;
found = 1;
- bc = (struct blocked_consumer *) malloc(sizeof(struct blocked_consumer));
- if(bc == NULL) {
- ERR("malloc returned NULL");
- goto free_short_chan_name;
+ bc = (struct blocked_consumer *) zmalloc(sizeof(struct blocked_consumer));
+ if (bc == NULL) {
+ ERR("zmalloc returned NULL");
+ goto unlock_traces;
}
bc->fd_consumer = src->fd;
bc->fd_producer = buf->data_ready_fd_read;
list_add(&bc->list, &blocked_consumers);
+ /* 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);
+ }
+
break;
}
}
- if(found == 0) {
- ERR("get_subbuf: unable to find channel");
+ if (found == 0) {
+ ERR("unable to find channel");
}
+ unlock_traces:
+ ltt_unlock_traces();
+
free_short_chan_name:
free(ch_name);
DBG("put_subbuf");
- channel_and_cpu = strdup_malloc(nth_token(recvbuf, 1));
- if(channel_and_cpu == NULL) {
- ERR("put_subbuf_size: cannot parse channel");
+ channel_and_cpu = strdup(nth_token(recvbuf, 1));
+ if (channel_and_cpu == NULL) {
+ ERR("cannot parse channel");
retval = -1;
goto end;
}
- consumed_old_str = strdup_malloc(nth_token(recvbuf, 2));
- if(consumed_old_str == NULL) {
- ERR("put_subbuf: cannot parse consumed_old");
+ consumed_old_str = strdup(nth_token(recvbuf, 2));
+ 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') {
- ERR("put_subbuf: invalid value for consumed_old");
+ 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) {
- ERR("Problem parsing channel name");
+ 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);
- ltt_unlock_traces();
- if(trace == NULL) {
- WARN("Cannot find trace. It was likely destroyed by the user.");
- asprintf(&reply, "%s", "NOTFOUND");
- result = ustcomm_send_reply(&ustcomm_app.server, reply, src);
- if(result) {
+ 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) {
ERR("ustcomm_send_reply failed");
- free(reply);
retval = -1;
- goto free_short_chan_name;
+ goto unlock_traces;
}
- free(reply);
- goto free_short_chan_name;
+ goto unlock_traces;
}
- 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)) {
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) {
- ERR("listener: put_subbuf: ustcomm_send_reply failed");
+ if (result) {
+ ERR("ustcomm_send_reply failed");
free(reply);
retval = -1;
- goto free_channel_and_cpu;
+ goto unlock_traces;
}
free(reply);
break;
}
}
- if(found == 0) {
+ if (found == 0) {
ERR("unable to find channel");
}
+ unlock_traces:
+ ltt_unlock_traces();
free_short_chan_name:
free(ch_name);
free_consumed_old_str:
return retval;
}
-void *listener_main(void *p)
+static void listener_cleanup(void *ptr)
{
- int result;
-
- ust_register_thread();
+ ustcomm_fini_app(&ustcomm_app, 0);
+}
- DBG("LISTENER");
+static void do_cmd_force_switch()
+{
+ struct blocked_consumer *bc;
- for(;;) {
- char trace_name[] = "auto";
- char trace_type[] = "ustrelay";
- char *recvbuf;
- int len;
- struct ustcomm_source src;
+ list_for_each_entry(bc, &blocked_consumers, list) {
+ ltt_force_switch(bc->buf, FORCE_FLUSH);
+ }
+}
- process_blocked_consumers();
+int process_client_cmd(char *recvbuf, struct ustcomm_source *src)
+{
+ 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")) {
+ print_markers(stderr);
+ } else if (!strcmp(recvbuf, "list_markers")) {
+ char *ptr;
+ size_t size;
+ FILE *fp;
+
+ fp = open_memstream(&ptr, &size);
+ print_markers(fp);
+ fclose(fp);
+
+ result = ustcomm_send_reply(&ustcomm_app.server, ptr, src);
+
+ free(ptr);
+ } 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_app_recv_message(&ustcomm_app, &recvbuf, &src, 5);
- if(result < 0) {
- WARN("error in ustcomm_app_recv_message");
- continue;
+ result = ustcomm_send_reply(&ustcomm_app.server, ptr, src);
+ if (result < 0) {
+ ERR("list_trace_events failed");
+ return -1;
}
- else if(result == 0) {
- /* no message */
- continue;
+ 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 -1;
}
- DBG("received a message! it's: %s", recvbuf);
- len = strlen(recvbuf);
-
- if(!strcmp(recvbuf, "print_markers")) {
- print_markers(stderr);
+ result = ltt_trace_set_type(trace_name, trace_type);
+ if (result < 0) {
+ ERR("ltt_trace_set_type failed");
+ return -1;
}
- else if(!strcmp(recvbuf, "list_markers")) {
- char *ptr;
- size_t size;
- FILE *fp;
-
- fp = open_memstream(&ptr, &size);
- print_markers(fp);
- fclose(fp);
- result = ustcomm_send_reply(&ustcomm_app.server, ptr, &src);
-
- free(ptr);
+ result = ltt_trace_alloc(trace_name);
+ if (result < 0) {
+ ERR("ltt_trace_alloc failed");
+ return -1;
}
- 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;
- }
- result = ltt_trace_set_type(trace_name, trace_type);
- if(result < 0) {
- ERR("ltt_trace_set_type failed");
- return (void *)1;
- }
-
- result = ltt_trace_alloc(trace_name);
- if(result < 0) {
- ERR("ltt_trace_alloc failed");
- return (void *)1;
- }
-
- inform_consumer_daemon(trace_name);
+ inform_consumer_daemon(trace_name);
- result = ltt_trace_start(trace_name);
- if(result < 0) {
- ERR("ltt_trace_start failed");
- continue;
- }
+ result = ltt_trace_start(trace_name);
+ if (result < 0) {
+ ERR("ltt_trace_start failed");
+ return -1;
}
- else if(!strcmp(recvbuf, "trace_setup")) {
- DBG("trace setup");
-
- result = ltt_trace_setup(trace_name);
- if(result < 0) {
- ERR("ltt_trace_setup failed");
- return (void *)1;
- }
+ } else if (!strcmp(recvbuf, "trace_setup")) {
+ DBG("trace setup");
- result = ltt_trace_set_type(trace_name, trace_type);
- if(result < 0) {
- ERR("ltt_trace_set_type failed");
- return (void *)1;
- }
+ result = ltt_trace_setup(trace_name);
+ if (result < 0) {
+ ERR("ltt_trace_setup failed");
+ return -1;
}
- 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 -1;
}
- else if(!strcmp(recvbuf, "trace_create")) {
- DBG("trace create");
+ } else if (!strcmp(recvbuf, "trace_alloc")) {
+ DBG("trace alloc");
- result = ltt_trace_setup(trace_name);
- if(result < 0) {
- ERR("ltt_trace_setup failed");
- return (void *)1;
- }
+ result = ltt_trace_alloc(trace_name);
+ if (result < 0) {
+ ERR("ltt_trace_alloc failed");
+ return -1;
+ }
+ inform_consumer_daemon(trace_name);
+ } else if (!strcmp(recvbuf, "trace_create")) {
+ DBG("trace create");
- result = ltt_trace_set_type(trace_name, trace_type);
- if(result < 0) {
- ERR("ltt_trace_set_type failed");
- return (void *)1;
- }
+ result = ltt_trace_setup(trace_name);
+ if (result < 0) {
+ ERR("ltt_trace_setup failed");
+ return -1;
+ }
- 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 -1;
+ }
+ } else if (!strcmp(recvbuf, "trace_start")) {
+ DBG("trace start");
+ result = ltt_trace_alloc(trace_name);
+ if (result < 0) {
+ ERR("ltt_trace_alloc failed");
+ return -1;
+ }
+ if (!result) {
inform_consumer_daemon(trace_name);
}
- 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_start(trace_name);
+ if (result < 0) {
+ ERR("ltt_trace_start failed");
+ return -1;
}
- else if(!strcmp(recvbuf, "trace_stop")) {
- DBG("trace stop");
+ } 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;
- }
+ result = ltt_trace_stop(trace_name);
+ 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");
+ DBG("trace destroy");
- result = ltt_trace_destroy(trace_name);
- if(result < 0) {
- ERR("ltt_trace_destroy failed");
- return (void *)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);
+ result = ltt_trace_destroy(trace_name, 0);
+ if (result < 0) {
+ ERR("ltt_trace_destroy failed");
+ return -1;
}
- else if(nth_token_is(recvbuf, "get_subbuf_size", 0) == 1) {
- do_cmd_get_subbuf_size(recvbuf, &src);
+ } 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) {
+ char *libfile;
+
+ libfile = nth_token(recvbuf, 1);
+
+ DBG("load_probe_lib loading %s", libfile);
+
+ free(libfile);
+ } else if (nth_token_is(recvbuf, "get_subbuffer", 0) == 1) {
+ do_cmd_get_subbuffer(recvbuf, src);
+ } 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) {
+ char *channel_slash_name = nth_token(recvbuf, 1);
+ char channel_name[256]="";
+ char marker_name[256]="";
+
+ result = sscanf(channel_slash_name, "%255[^/]/%255s", channel_name, marker_name);
+
+ if (channel_name == NULL || marker_name == NULL) {
+ WARN("invalid marker name");
+ goto next_cmd;
}
- else if(nth_token_is(recvbuf, "load_probe_lib", 0) == 1) {
- char *libfile;
- libfile = nth_token(recvbuf, 1);
+ 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);
+ }
+ } else if (nth_token_is(recvbuf, "disable_marker", 0) == 1) {
+ char *channel_slash_name = nth_token(recvbuf, 1);
+ char *marker_name;
+ char *channel_name;
- DBG("load_probe_lib loading %s", libfile);
+ result = sscanf(channel_slash_name, "%a[^/]/%as", &channel_name, &marker_name);
- free(libfile);
+ if (channel_name == NULL || marker_name == NULL) {
+ WARN("invalid marker name");
+ goto next_cmd;
}
- else if(nth_token_is(recvbuf, "get_subbuffer", 0) == 1) {
- do_cmd_get_subbuffer(recvbuf, &src);
+
+ 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);
}
- else if(nth_token_is(recvbuf, "put_subbuffer", 0) == 1) {
- do_cmd_put_subbuffer(recvbuf, &src);
+ } else if (nth_token_is(recvbuf, "get_pidunique", 0) == 1) {
+ char *reply;
+
+ if (asprintf(&reply, "%lld", pidunique) < 0) {
+ ERR("process_client_cmd : asprintf failed (%lld)",
+ pidunique);
+ goto next_cmd;
}
- 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]="";
- result = sscanf(channel_slash_name, "%255[^/]/%255s", channel_name, marker_name);
+ result = ustcomm_send_reply(&ustcomm_app.server, reply, src);
+ if (result) {
+ ERR("listener: get_pidunique: ustcomm_send_reply failed");
+ goto next_cmd;
+ }
- if(channel_name == NULL || marker_name == NULL) {
- WARN("invalid marker name");
+ free(reply);
+ } 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 = ltt_marker_connect(channel_name, marker_name, "default");
- if(result < 0) {
- WARN("could not enable marker; channel=%s, name=%s", channel_name, marker_name);
- }
+ result = ustcomm_send_reply(&ustcomm_app.server, reply, src);
+ free(reply);
+ } else {
+ result = ustcomm_send_reply(&ustcomm_app.server, reply, src);
}
- else if(nth_token_is(recvbuf, "disable_marker", 0) == 1) {
- char *channel_slash_name = nth_token(recvbuf, 1);
- char *marker_name;
- char *channel_name;
+ 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);
+ }
- result = sscanf(channel_slash_name, "%a[^/]/%as", &channel_name, &marker_name);
+next_cmd:
- if(marker_name == NULL) {
- }
+ return 0;
+}
- 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);
- }
- }
- else if(nth_token_is(recvbuf, "get_pidunique", 0) == 1) {
- char *reply;
+void *listener_main(void *p)
+{
+ int result;
- asprintf(&reply, "%lld", pidunique);
+ DBG("LISTENER");
- result = ustcomm_send_reply(&ustcomm_app.server, reply, &src);
- if(result) {
- ERR("listener: get_pidunique: ustcomm_send_reply failed");
- goto next_cmd;
- }
+ pthread_cleanup_push(listener_cleanup, NULL);
- free(reply);
- }
-// else if(nth_token_is(recvbuf, "get_notifications", 0) == 1) {
-// struct ust_trace *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; i<trace->nr_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);
+ 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");
}
- next_cmd:
- free(recvbuf);
+ multipoll_destroy(&mpent);
}
+
+ pthread_cleanup_pop(1);
}
-volatile sig_atomic_t have_listener = 0;
+/* 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;
void create_listener(void)
{
-#ifdef USE_CLONE
- static char listener_stack[16384];
int result;
-#else
- pthread_t thread;
-#endif
+ 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;
}
-#ifdef USE_CLONE
- result = clone((int (*)(void *)) 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;
+ /* 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));
}
-#else
- pthread_create(&thread, NULL, listener_main, NULL);
-#endif
+ result = pthread_create(&listener_thread, NULL, listener_main, NULL);
+ if (result == -1) {
+ PERROR("pthread_create");
+ }
- have_listener = 1;
+ /* 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;
+ }
}
static int init_socket(void)
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;
}
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);
{
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();
- /* Initialize RCU in case the constructor order is not good. */
- rcu_init();
-
- /* It is important to do this before events start to be generated. */
- ust_register_thread();
-
DBG("Tracectl constructor");
- /* Must create socket before signal handler to prevent races.
- */
result = init_socket();
- if(result == -1) {
+ if (result == -1) {
ERR("init_socket error");
return;
}
create_listener();
autoprobe_val = getenv("UST_AUTOPROBE");
- if(autoprobe_val) {
+ if (autoprobe_val) {
struct marker_iter iter;
DBG("Autoprobe enabled.");
/* 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];
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;
}
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";
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(trace_name);
}
-
return;
/* should decrementally destroy stuff if error */
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");
}
}
ltt_lock_traces();
list_for_each_entry(trace, <t_traces.head, list) {
- if(trace->active) {
+ if (trace->active) {
retval = 1;
break;
}
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(void)
+{
+ 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 connect to its buffers. This is necessary
* for programs whose execution is very short. It is also useful in all
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;
}
destroy_traces();
- ustcomm_fini_app(&ustcomm_app);
+ /* Ask the listener to stop and clean up. */
+ stop_listener();
}
void ust_potential_exec(void)
struct blocked_consumer *deletable_bc = NULL;
int result;
+ /* FIXME: technically, the locks could have been taken before the fork */
DBG("ust: forking");
+
+ /* break lock if necessary */
+ ltt_unlock_traces();
+
ltt_trace_stop("auto");
- ltt_trace_destroy("auto");
+ ltt_trace_destroy("auto", 1);
/* Delete all active connections */
ustcomm_close_all_connections(&ustcomm_app.server);
/* Delete all blocked consumers */
list_for_each_entry(bc, &blocked_consumers, list) {
- close(bc->fd_producer);
- close(bc->fd_consumer);
+ result = close(bc->fd_producer);
+ if (result == -1) {
+ PERROR("close");
+ }
free(deletable_bc);
deletable_bc = bc;
list_del(&bc->list);
}
+ /* free app, keeping socket file */
+ ustcomm_fini_app(&ustcomm_app, 1);
+
+ STORE_SHARED(buffers_to_export, 0);
have_listener = 0;
- create_listener();
init_socket();
+ 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;
}
/* Disable signals */
sigfillset(&all_sigs);
result = sigprocmask(SIG_BLOCK, &all_sigs, &fork_info->orig_sigs);
- if(result == -1) {
+ if (result == -1) {
PERROR("sigprocmask");
return;
}
/* Restore signals */
result = sigprocmask(SIG_SETMASK, &fork_info->orig_sigs, NULL);
- if(result == -1) {
+ if (result == -1) {
PERROR("sigprocmask");
return;
}
projects / ust.git / blobdiff