#include <poll.h>
#include <regex.h>
-#include <urcu-bp.h>
-
#include <ust/marker.h>
+#include <ust/tracectl.h>
#include "tracer.h"
#include "usterr.h"
#include "ustcomm.h"
-#include "buffers.h" /* FIXME: remove */
+#include "buffers.h"
#include "marker-control.h"
//#define USE_CLONE
struct ustcomm_server server;
struct ustcomm_source src;
- /* args to ust_buffers_do_get_subbuf */
+ /* args to ust_buffers_get_subbuf */
struct ust_buffer *buf;
struct list_head list;
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)
-{
- rcu_register_thread();
-}
-
int fd_notif = -1;
void notif_cb(void)
{
static void inform_consumer_daemon(const char *trace_name)
{
- int i;
- struct ltt_trace_struct *trace;
+ int i,j;
+ struct ust_trace *trace;
pid_t pid = getpid();
int result;
}
for(i=0; i < trace->nr_channels; i++) {
- result = ustcomm_request_consumer(pid, trace->channels[i].channel_name);
- if(result == -1) {
- WARN("Failed to request collection for channel %s. Is the daemon available?", trace->channels[i].channel_name);
- /* continue even if fail */
+ /* 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 */
+ }
+ free(buf);
+ buffers_to_export++;
}
- buffers_to_export++;
}
finish:
continue;
}
- result = ust_buffers_do_get_subbuf(bc->buf, &consumed_old);
+ result = ust_buffers_get_subbuf(bc->buf, &consumed_old);
if(result == -EAGAIN) {
WARN("missed buffer?");
continue;
}
else if(result < 0) {
- DBG("ust_buffers_do_get_subbuf: error: %s", strerror(-result));
+ 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);
}
-void *listener_main(void *p)
+void seperate_channel_cpu(const char *channel_and_cpu, char **channel, int *cpu)
+{
+ const char *sep;
+
+ sep = rindex(channel_and_cpu, '_');
+ if(sep == NULL) {
+ *cpu = -1;
+ sep = channel_and_cpu + strlen(channel_and_cpu);
+ }
+ else {
+ *cpu = atoi(sep+1);
+ }
+
+ asprintf(channel, "%.*s", (int)(sep-channel_and_cpu), channel_and_cpu);
+}
+
+static int do_cmd_get_shmid(const char *recvbuf, struct ustcomm_source *src)
+{
+ int retval = 0;
+ struct ust_trace *trace;
+ char trace_name[] = "auto";
+ int i;
+ char *channel_and_cpu;
+ int found = 0;
+ int result;
+ char *ch_name;
+ int ch_cpu;
+
+ DBG("get_shmid");
+
+ channel_and_cpu = nth_token(recvbuf, 1);
+ if(channel_and_cpu == NULL) {
+ ERR("cannot parse channel");
+ goto end;
+ }
+
+ seperate_channel_cpu(channel_and_cpu, &ch_name, &ch_cpu);
+ if(ch_cpu == -1) {
+ ERR("problem parsing channel name");
+ goto free_short_chan_name;
+ }
+
+ ltt_lock_traces();
+ trace = _ltt_trace_find(trace_name);
+ ltt_unlock_traces();
+
+ if(trace == NULL) {
+ ERR("cannot find trace!");
+ retval = -1;
+ goto free_short_chan_name;
+ }
+
+ 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)) {
+ 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]);
+
+ result = ustcomm_send_reply(&ustcomm_app.server, reply, src);
+ if(result) {
+ ERR("ustcomm_send_reply failed");
+ free(reply);
+ retval = -1;
+ goto free_short_chan_name;
+ }
+
+ free(reply);
+
+ found = 1;
+ break;
+ }
+ }
+
+ if(!found) {
+ ERR("channel not found (%s)", channel_and_cpu);
+ }
+
+ free_short_chan_name:
+ free(ch_name);
+
+ end:
+ return retval;
+}
+
+static int do_cmd_get_n_subbufs(const char *recvbuf, struct ustcomm_source *src)
+{
+ int retval = 0;
+ struct ust_trace *trace;
+ char trace_name[] = "auto";
+ int i;
+ char *channel_and_cpu;
+ int found = 0;
+ int result;
+ char *ch_name;
+ int ch_cpu;
+
+ DBG("get_n_subbufs");
+
+ channel_and_cpu = nth_token(recvbuf, 1);
+ if(channel_and_cpu == NULL) {
+ ERR("cannot parse channel");
+ goto end;
+ }
+
+ seperate_channel_cpu(channel_and_cpu, &ch_name, &ch_cpu);
+ if(ch_cpu == -1) {
+ ERR("problem parsing channel name");
+ goto free_short_chan_name;
+ }
+
+ ltt_lock_traces();
+ trace = _ltt_trace_find(trace_name);
+ ltt_unlock_traces();
+
+ if(trace == NULL) {
+ ERR("cannot find trace!");
+ retval = -1;
+ goto free_short_chan_name;
+ }
+
+ for(i=0; i<trace->nr_channels; i++) {
+ struct ust_channel *channel = &trace->channels[i];
+
+ 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);
+
+ result = ustcomm_send_reply(&ustcomm_app.server, reply, src);
+ if(result) {
+ ERR("ustcomm_send_reply failed");
+ free(reply);
+ retval = -1;
+ goto free_short_chan_name;
+ }
+
+ free(reply);
+ found = 1;
+ break;
+ }
+ }
+ if(found == 0) {
+ ERR("unable to find channel");
+ }
+
+ free_short_chan_name:
+ free(ch_name);
+
+ end:
+ return retval;
+}
+
+static int do_cmd_get_subbuf_size(const char *recvbuf, struct ustcomm_source *src)
+{
+ int retval = 0;
+ struct ust_trace *trace;
+ char trace_name[] = "auto";
+ int i;
+ char *channel_and_cpu;
+ int found = 0;
+ int result;
+ char *ch_name;
+ int ch_cpu;
+
+ DBG("get_subbuf_size");
+
+ channel_and_cpu = nth_token(recvbuf, 1);
+ if(channel_and_cpu == NULL) {
+ ERR("cannot parse channel");
+ goto end;
+ }
+
+ seperate_channel_cpu(channel_and_cpu, &ch_name, &ch_cpu);
+ if(ch_cpu == -1) {
+ ERR("problem parsing channel name");
+ goto free_short_chan_name;
+ }
+
+ ltt_lock_traces();
+ trace = _ltt_trace_find(trace_name);
+ ltt_unlock_traces();
+
+ if(trace == NULL) {
+ ERR("cannot find trace!");
+ retval = -1;
+ goto free_short_chan_name;
+ }
+
+ for(i=0; i<trace->nr_channels; i++) {
+ struct ust_channel *channel = &trace->channels[i];
+
+ 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);
+
+ result = ustcomm_send_reply(&ustcomm_app.server, reply, src);
+ if(result) {
+ ERR("ustcomm_send_reply failed");
+ free(reply);
+ retval = -1;
+ goto free_short_chan_name;
+ }
+
+ free(reply);
+ found = 1;
+ break;
+ }
+ }
+ if(found == 0) {
+ ERR("unable to find channel");
+ }
+
+ free_short_chan_name:
+ free(ch_name);
+
+ end:
+ return retval;
+}
+
+static unsigned int poweroftwo(unsigned int x)
+{
+ unsigned int power2 = 1;
+ unsigned int hardcoded = 2147483648; /* FIX max 2^31 */
+
+ if (x < 2)
+ return 2;
+
+ while (power2 < x && power2 < hardcoded)
+ power2 *= 2;
+
+ return power2;
+}
+
+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");
+ goto end;
+ }
+
+ power = poweroftwo(size);
+ if (power != size)
+ WARN("using the next 2^n = %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");
+ goto end;
+ }
+ if (num < 2) {
+ ERR("subbuffer count should be greater than 2");
+ 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;
+ struct ust_trace *trace;
+ char trace_name[] = "auto";
+ int i;
+ char *channel_and_cpu;
+ int found = 0;
+ char *ch_name;
+ int ch_cpu;
+
+ DBG("get_subbuf");
+
+ channel_and_cpu = nth_token(recvbuf, 1);
+ if(channel_and_cpu == NULL) {
+ ERR("cannot parse channel");
+ goto end;
+ }
+
+ seperate_channel_cpu(channel_and_cpu, &ch_name, &ch_cpu);
+ if(ch_cpu == -1) {
+ ERR("problem parsing channel name");
+ goto free_short_chan_name;
+ }
+
+ ltt_lock_traces();
+ trace = _ltt_trace_find(trace_name);
+
+ if(trace == NULL) {
+ int result;
+
+ WARN("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");
+ retval = -1;
+ goto unlock_traces;
+ }
+
+ goto unlock_traces;
+ }
+
+ for(i=0; i<trace->nr_channels; i++) {
+ struct ust_channel *channel = &trace->channels[i];
+
+ if(!strcmp(trace->channels[i].channel_name, ch_name)) {
+ struct ust_buffer *buf = channel->buf[ch_cpu];
+ struct blocked_consumer *bc;
+
+ found = 1;
+
+ bc = (struct blocked_consumer *) malloc(sizeof(struct blocked_consumer));
+ if(bc == NULL) {
+ ERR("malloc returned NULL");
+ goto unlock_traces;
+ }
+ bc->fd_consumer = src->fd;
+ bc->fd_producer = buf->data_ready_fd_read;
+ bc->buf = buf;
+ bc->src = *src;
+ bc->server = ustcomm_app.server;
+
+ 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(atomic_long_read(&buf->consumed) == 0) {
+ DBG("decrementing buffers_to_export");
+ buffers_to_export--;
+ }
+
+ break;
+ }
+ }
+ if(found == 0) {
+ ERR("unable to find channel");
+ }
+
+ unlock_traces:
+ ltt_unlock_traces();
+
+ free_short_chan_name:
+ free(ch_name);
+
+ end:
+ return retval;
+}
+
+static int do_cmd_put_subbuffer(const char *recvbuf, struct ustcomm_source *src)
{
+ int retval = 0;
+ struct ust_trace *trace;
+ char trace_name[] = "auto";
+ int i;
+ char *channel_and_cpu;
+ int found = 0;
int result;
+ char *ch_name;
+ int ch_cpu;
+ long consumed_old;
+ char *consumed_old_str;
+ char *endptr;
+ char *reply = NULL;
+
+ DBG("put_subbuf");
+
+ channel_and_cpu = strdup_malloc(nth_token(recvbuf, 1));
+ if(channel_and_cpu == NULL) {
+ ERR("cannot parse channel");
+ retval = -1;
+ goto end;
+ }
- ust_register_thread();
+ consumed_old_str = strdup_malloc(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("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");
+ retval = -1;
+ goto free_short_chan_name;
+ }
+
+ ltt_lock_traces();
+ trace = _ltt_trace_find(trace_name);
+
+ if(trace == NULL) {
+ WARN("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");
+ retval = -1;
+ goto unlock_traces;
+ }
+
+ goto unlock_traces;
+ }
+
+ for(i=0; i<trace->nr_channels; i++) {
+ struct ust_channel *channel = &trace->channels[i];
+
+ if(!strcmp(trace->channels[i].channel_name, ch_name)) {
+ struct ust_buffer *buf = channel->buf[ch_cpu];
+
+ found = 1;
+
+ result = ust_buffers_put_subbuf(buf, consumed_old);
+ if(result < 0) {
+ WARN("ust_buffers_put_subbuf: error (subbuf=%s)", channel_and_cpu);
+ asprintf(&reply, "%s", "ERROR");
+ }
+ else {
+ DBG("ust_buffers_put_subbuf: success (subbuf=%s)", channel_and_cpu);
+ asprintf(&reply, "%s", "OK");
+ }
+
+ result = ustcomm_send_reply(&ustcomm_app.server, reply, src);
+ if(result) {
+ ERR("ustcomm_send_reply failed");
+ free(reply);
+ retval = -1;
+ goto unlock_traces;
+ }
+
+ free(reply);
+ break;
+ }
+ }
+ if(found == 0) {
+ ERR("unable to find channel");
+ }
+
+ unlock_traces:
+ ltt_unlock_traces();
+ free_short_chan_name:
+ free(ch_name);
+ free_consumed_old_str:
+ free(consumed_old_str);
+ free_channel_and_cpu:
+ free(channel_and_cpu);
+
+ end:
+ return retval;
+}
+
+void *listener_main(void *p)
+{
+ int result;
DBG("LISTENER");
ERR("ltt_trace_alloc failed");
return (void *)1;
}
+ inform_consumer_daemon(trace_name);
+ }
+ else if(!strcmp(recvbuf, "trace_create")) {
+ DBG("trace create");
+
+ 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;
+ }
}
else if(!strcmp(recvbuf, "trace_start")) {
DBG("trace start");
+ result = ltt_trace_alloc(trace_name);
+ if(result < 0) {
+ ERR("ltt_trace_alloc failed");
+ return (void *)1;
+ }
+ if(!result) {
+ inform_consumer_daemon(trace_name);
+ }
+
result = ltt_trace_start(trace_name);
if(result < 0) {
ERR("ltt_trace_start failed");
DBG("trace destroy");
- result = ltt_trace_destroy(trace_name);
+ result = ltt_trace_destroy(trace_name, 0);
if(result < 0) {
ERR("ltt_trace_destroy failed");
return (void *)1;
}
}
else if(nth_token_is(recvbuf, "get_shmid", 0) == 1) {
- struct ltt_trace_struct *trace;
- char trace_name[] = "auto";
- int i;
- char *channel_name;
-
- DBG("get_shmid");
-
- channel_name = nth_token(recvbuf, 1);
- if(channel_name == NULL) {
- ERR("get_shmid: cannot parse channel");
- goto next_cmd;
- }
-
- ltt_lock_traces();
- trace = _ltt_trace_find(trace_name);
- ltt_unlock_traces();
-
- if(trace == NULL) {
- ERR("cannot find trace!");
- return (void *)1;
- }
-
- for(i=0; i<trace->nr_channels; i++) {
- struct ust_channel *channel = &trace->channels[i];
- struct ust_buffer *buf = channel->buf;
-
- if(!strcmp(trace->channels[i].channel_name, channel_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_shmid);
- asprintf(&reply, "%d %d", buf->shmid, channel->buf_shmid);
-
- result = ustcomm_send_reply(&ustcomm_app.server, reply, &src);
- if(result) {
- ERR("listener: get_shmid: ustcomm_send_reply failed");
- goto next_cmd;
- }
-
- free(reply);
-
- break;
- }
- }
-
- buffers_to_export--;
+ do_cmd_get_shmid(recvbuf, &src);
}
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();
-
- if(trace == NULL) {
- ERR("cannot find trace!");
- return (void *)1;
- }
-
- for(i=0; i<trace->nr_channels; i++) {
- struct ust_channel *channel = &trace->channels[i];
-
- if(!strcmp(trace->channels[i].channel_name, channel_name)) {
- char *reply;
-
- DBG("the n_subbufs for the requested channel is %d", channel->subbuf_cnt);
- asprintf(&reply, "%d", channel->subbuf_cnt);
-
- result = ustcomm_send_reply(&ustcomm_app.server, reply, &src);
- if(result) {
- ERR("listener: get_n_subbufs: ustcomm_send_reply failed");
- goto next_cmd;
- }
-
- free(reply);
-
- break;
- }
- }
+ do_cmd_get_n_subbufs(recvbuf, &src);
}
else if(nth_token_is(recvbuf, "get_subbuf_size", 0) == 1) {
- struct ltt_trace_struct *trace;
- char trace_name[] = "auto";
- int i;
- char *channel_name;
-
- DBG("get_subbuf_size");
-
- channel_name = nth_token(recvbuf, 1);
- if(channel_name == NULL) {
- ERR("get_subbuf_size: cannot parse channel");
- goto next_cmd;
- }
-
- ltt_lock_traces();
- trace = _ltt_trace_find(trace_name);
- ltt_unlock_traces();
-
- if(trace == NULL) {
- ERR("cannot find trace!");
- return (void *)1;
- }
-
- for(i=0; i<trace->nr_channels; i++) {
- struct ust_channel *channel = &trace->channels[i];
-
- if(!strcmp(trace->channels[i].channel_name, channel_name)) {
- char *reply;
-
- DBG("the subbuf_size for the requested channel is %zd", channel->subbuf_size);
- asprintf(&reply, "%zd", channel->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;
- }
- }
+ 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) {
- 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;
- }
-
- 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 ust_channel *channel = &trace->channels[i];
-
- if(!strcmp(trace->channels[i].channel_name, channel_name)) {
- struct ust_buffer *buf = channel->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 = buf->data_ready_fd_read;
- bc->buf = buf;
- bc->src = src;
- bc->server = ustcomm_app.server;
-
- list_add(&bc->list, &blocked_consumers);
-
- break;
- }
- }
+ do_cmd_get_subbuffer(recvbuf, &src);
}
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;
- }
-
- 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;
- }
-
- 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 ust_channel *channel = &trace->channels[i];
-
- if(!strcmp(trace->channels[i].channel_name, channel_name)) {
- struct ust_buffer *buf = channel->buf;
- char *reply;
- long consumed_old=0;
-
- result = ust_buffers_do_put_subbuf(buf, consumed_old);
- if(result < 0) {
- WARN("ust_buffers_do_put_subbuf: error (subbuf=%s)", channel_name);
- asprintf(&reply, "%s", "ERROR");
- }
- else {
- DBG("ust_buffers_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;
- }
- }
-
- free(channel_name);
- free(consumed_old_str);
+ 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);
WARN("invalid marker name");
goto next_cmd;
}
- printf("%s %s\n", channel_name, marker_name);
result = ltt_marker_connect(channel_name, marker_name, "default");
if(result < 0) {
if(marker_name == NULL) {
}
- printf("%s %s\n", channel_name, marker_name);
result = ltt_marker_disconnect(channel_name, marker_name, "default");
if(result < 0) {
free(reply);
}
// else if(nth_token_is(recvbuf, "get_notifications", 0) == 1) {
-// struct ltt_trace_struct *trace;
+// struct ust_trace *trace;
// char trace_name[] = "auto";
// int i;
// char *channel_name;
*/
pidunique = make_pidunique();
- /* Initialize RCU in case the constructor order is not good. */
- urcu_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) {
ERR("init_socket error");
/* 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);
ERR("ltt_trace_stop error");
}
- result = ltt_trace_destroy("auto");
+ result = ltt_trace_destroy("auto", 0);
if(result == -1) {
ERR("ltt_trace_destroy error");
}
static int trace_recording(void)
{
int retval = 0;
- struct ltt_trace_struct *trace;
+ struct ust_trace *trace;
ltt_lock_traces();
* 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 blocked_consumer *bc;
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);
list_del(&bc->list);
}
+ ustcomm_free_app(&ustcomm_app);
+
+ 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) {
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);
+}
+
projects / ust.git / blobdiff