X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fkernel.c;h=69665058a0e098c0b7a2bbd9dc1042d6f7b25f0a;hb=a1dcaf0fdbfbaf02ef38886b556c3d37e4458fdc;hp=1aad5263e0b8ae63a75c2a9b9fb0c3a3d4db5906;hpb=3b870559a62e8f74a8793a6a23b9445346fe9fdf;p=lttng-tools.git diff --git a/src/bin/lttng-sessiond/kernel.c b/src/bin/lttng-sessiond/kernel.c index 1aad5263e..69665058a 100644 --- a/src/bin/lttng-sessiond/kernel.c +++ b/src/bin/lttng-sessiond/kernel.c @@ -22,10 +22,13 @@ #include #include #include +#include #include #include +#include +#include "consumer.h" #include "kernel.h" #include "kern-modules.h" @@ -37,6 +40,9 @@ int kernel_add_channel_context(struct ltt_kernel_channel *chan, { int ret; + assert(chan); + assert(ctx); + DBG("Adding context to channel %s", chan->channel->name); ret = kernctl_add_context(chan->fd, ctx); if (ret < 0) { @@ -63,35 +69,6 @@ error: return ret; } -/* - * Add context on a kernel event. - */ -int kernel_add_event_context(struct ltt_kernel_event *event, - struct lttng_kernel_context *ctx) -{ - int ret; - - DBG("Adding context to event %s", event->event->name); - ret = kernctl_add_context(event->fd, ctx); - if (ret < 0) { - PERROR("add context ioctl"); - goto error; - } - - event->ctx = zmalloc(sizeof(struct lttng_kernel_context)); - if (event->ctx == NULL) { - PERROR("zmalloc event context"); - goto error; - } - - memcpy(event->ctx, ctx, sizeof(struct lttng_kernel_context)); - - return 0; - -error: - return ret; -} - /* * Create a new kernel session, register it to the kernel tracer and add it to * the session daemon session. @@ -101,8 +78,10 @@ int kernel_create_session(struct ltt_session *session, int tracer_fd) int ret; struct ltt_kernel_session *lks; + assert(session); + /* Allocate data structure */ - lks = trace_kernel_create_session(session->path); + lks = trace_kernel_create_session(); if (lks == NULL) { ret = -1; goto error; @@ -122,6 +101,7 @@ int kernel_create_session(struct ltt_session *session, int tracer_fd) PERROR("fcntl session fd"); } + lks->id = session->id; lks->consumer_fds_sent = 0; session->kernel_session = lks; @@ -130,6 +110,9 @@ int kernel_create_session(struct ltt_session *session, int tracer_fd) return 0; error: + if (lks) { + trace_kernel_destroy_session(lks); + } return ret; } @@ -138,17 +121,26 @@ error: * kernel session. */ int kernel_create_channel(struct ltt_kernel_session *session, - struct lttng_channel *chan, char *path) + struct lttng_channel *chan) { int ret; struct ltt_kernel_channel *lkc; + assert(session); + assert(chan); + /* Allocate kernel channel */ - lkc = trace_kernel_create_channel(chan, path); + lkc = trace_kernel_create_channel(chan); if (lkc == NULL) { goto error; } + DBG3("Kernel create channel %s with attr: %d, %" PRIu64 ", %" PRIu64 ", %u, %u, %d", + chan->name, lkc->channel->attr.overwrite, + lkc->channel->attr.subbuf_size, lkc->channel->attr.num_subbuf, + lkc->channel->attr.switch_timer_interval, lkc->channel->attr.read_timer_interval, + lkc->channel->attr.output); + /* Kernel tracer channel creation */ ret = kernctl_create_channel(session->fd, &lkc->channel->attr); if (ret < 0) { @@ -167,13 +159,17 @@ int kernel_create_channel(struct ltt_kernel_session *session, /* Add channel to session */ cds_list_add(&lkc->list, &session->channel_list.head); session->channel_count++; + lkc->session = session; - DBG("Kernel channel %s created (fd: %d and path: %s)", - lkc->channel->name, lkc->fd, lkc->pathname); + DBG("Kernel channel %s created (fd: %d)", lkc->channel->name, lkc->fd); return 0; error: + if (lkc) { + free(lkc->channel); + free(lkc); + } return -1; } @@ -187,6 +183,9 @@ int kernel_create_event(struct lttng_event *ev, int ret; struct ltt_kernel_event *event; + assert(ev); + assert(channel); + event = trace_kernel_create_event(ev); if (event == NULL) { ret = -1; @@ -195,7 +194,13 @@ int kernel_create_event(struct lttng_event *ev, ret = kernctl_create_event(channel->fd, event->event); if (ret < 0) { - if (errno != EEXIST) { + switch (errno) { + case EEXIST: + break; + case ENOSYS: + WARN("Event type not implemented"); + break; + default: PERROR("create event ioctl"); } ret = -errno; @@ -244,6 +249,8 @@ int kernel_disable_channel(struct ltt_kernel_channel *chan) { int ret; + assert(chan); + ret = kernctl_disable(chan->fd); if (ret < 0) { PERROR("disable chan ioctl"); @@ -267,6 +274,8 @@ int kernel_enable_channel(struct ltt_kernel_channel *chan) { int ret; + assert(chan); + ret = kernctl_enable(chan->fd); if (ret < 0 && errno != EEXIST) { PERROR("Enable kernel chan"); @@ -289,9 +298,18 @@ int kernel_enable_event(struct ltt_kernel_event *event) { int ret; + assert(event); + ret = kernctl_enable(event->fd); - if (ret < 0 && errno != EEXIST) { - PERROR("enable kernel event"); + if (ret < 0) { + switch (errno) { + case EEXIST: + ret = LTTNG_ERR_KERN_EVENT_EXIST; + break; + default: + PERROR("enable kernel event"); + break; + } goto error; } @@ -311,9 +329,18 @@ int kernel_disable_event(struct ltt_kernel_event *event) { int ret; + assert(event); + ret = kernctl_disable(event->fd); - if (ret < 0 && errno != EEXIST) { - PERROR("disable kernel event"); + if (ret < 0) { + switch (errno) { + case EEXIST: + ret = LTTNG_ERR_KERN_EVENT_EXIST; + break; + default: + PERROR("disable kernel event"); + break; + } goto error; } @@ -330,13 +357,15 @@ error: * Create kernel metadata, open from the kernel tracer and add it to the * kernel session. */ -int kernel_open_metadata(struct ltt_kernel_session *session, char *path) +int kernel_open_metadata(struct ltt_kernel_session *session) { int ret; - struct ltt_kernel_metadata *lkm; + struct ltt_kernel_metadata *lkm = NULL; + + assert(session); /* Allocate kernel metadata */ - lkm = trace_kernel_create_metadata(path); + lkm = trace_kernel_create_metadata(); if (lkm == NULL) { goto error; } @@ -344,7 +373,7 @@ int kernel_open_metadata(struct ltt_kernel_session *session, char *path) /* Kernel tracer metadata creation */ ret = kernctl_open_metadata(session->fd, &lkm->conf->attr); if (ret < 0) { - goto error; + goto error_open; } lkm->fd = ret; @@ -356,10 +385,12 @@ int kernel_open_metadata(struct ltt_kernel_session *session, char *path) session->metadata = lkm; - DBG("Kernel metadata opened (fd: %d and path: %s)", lkm->fd, lkm->pathname); + DBG("Kernel metadata opened (fd: %d)", lkm->fd); return 0; +error_open: + trace_kernel_destroy_metadata(lkm); error: return -1; } @@ -371,6 +402,8 @@ int kernel_start_session(struct ltt_kernel_session *session) { int ret; + assert(session); + ret = kernctl_start_session(session->fd); if (ret < 0) { PERROR("ioctl start session"); @@ -408,6 +441,8 @@ int kernel_calibrate(int fd, struct lttng_kernel_calibrate *calibrate) { int ret; + assert(calibrate); + ret = kernctl_calibrate(fd, calibrate); if (ret < 0) { PERROR("calibrate ioctl"); @@ -425,9 +460,11 @@ int kernel_metadata_flush_buffer(int fd) { int ret; + DBG("Kernel flushing metadata buffer on fd %d", fd); + ret = kernctl_buffer_flush(fd); if (ret < 0) { - ERR("Fail to flush metadata buffers %d (ret: %d", fd, ret); + ERR("Fail to flush metadata buffers %d (ret: %d)", fd, ret); } return 0; @@ -441,6 +478,8 @@ int kernel_flush_buffer(struct ltt_kernel_channel *channel) int ret; struct ltt_kernel_stream *stream; + assert(channel); + DBG("Flush buffer for channel %s", channel->channel->name); cds_list_for_each_entry(stream, &channel->stream_list.head, list) { @@ -463,6 +502,8 @@ int kernel_stop_session(struct ltt_kernel_session *session) { int ret; + assert(session); + ret = kernctl_stop_session(session->fd); if (ret < 0) { goto error; @@ -484,11 +525,13 @@ error: */ int kernel_open_channel_stream(struct ltt_kernel_channel *channel) { - int ret; + int ret, count = 0; struct ltt_kernel_stream *lks; + assert(channel); + while ((ret = kernctl_create_stream(channel->fd)) >= 0) { - lks = trace_kernel_create_stream(); + lks = trace_kernel_create_stream(channel->channel->name, count); if (lks == NULL) { ret = close(ret); if (ret) { @@ -504,19 +547,18 @@ int kernel_open_channel_stream(struct ltt_kernel_channel *channel) PERROR("fcntl session fd"); } - ret = asprintf(&lks->pathname, "%s/%s_%d", - channel->pathname, channel->channel->name, channel->stream_count); - if (ret < 0) { - PERROR("asprintf kernel create stream"); - goto error; - } + lks->tracefile_size = channel->channel->attr.tracefile_size; + lks->tracefile_count = channel->channel->attr.tracefile_count; /* Add stream to channe stream list */ cds_list_add(&lks->list, &channel->stream_list.head); channel->stream_count++; - DBG("Kernel stream %d created (fd: %d, state: %d, path: %s)", - channel->stream_count, lks->fd, lks->state, lks->pathname); + /* Increment counter which represent CPU number. */ + count++; + + DBG("Kernel stream %s created (fd: %d, state: %d)", lks->name, lks->fd, + lks->state); } return channel->stream_count; @@ -532,6 +574,8 @@ int kernel_open_metadata_stream(struct ltt_kernel_session *session) { int ret; + assert(session); + ret = kernctl_create_stream(session->metadata->fd); if (ret < 0) { PERROR("kernel create metadata stream"); @@ -560,10 +604,11 @@ ssize_t kernel_list_events(int tracer_fd, struct lttng_event **events) int fd, pos, ret; char *event; size_t nbmem, count = 0; - ssize_t size; FILE *fp; struct lttng_event *elist; + assert(events); + fd = kernctl_tracepoint_list(tracer_fd); if (fd < 0) { PERROR("kernel tracepoint list"); @@ -588,7 +633,7 @@ ssize_t kernel_list_events(int tracer_fd, struct lttng_event **events) goto end; } - while ((size = fscanf(fp, "event { name = %m[^;]; };%n\n", &event, &pos)) == 1) { + while (fscanf(fp, "event { name = %m[^;]; };%n\n", &event, &pos) == 1) { if (count >= nbmem) { struct lttng_event *new_elist; @@ -695,3 +740,51 @@ int init_kernel_workarounds(void) end_boot_id: return 0; } + +/* + * Complete teardown of a kernel session. + */ +void kernel_destroy_session(struct ltt_kernel_session *ksess) +{ + if (ksess == NULL) { + DBG3("No kernel session when tearing down session"); + return; + } + + DBG("Tearing down kernel session"); + + /* Close any relayd session */ + consumer_output_send_destroy_relayd(ksess->consumer); + + trace_kernel_destroy_session(ksess); +} + +/* + * Destroy a kernel channel object. It does not do anything on the tracer side. + */ +void kernel_destroy_channel(struct ltt_kernel_channel *kchan) +{ + struct ltt_kernel_session *ksess = NULL; + + assert(kchan); + assert(kchan->channel); + + DBG3("Kernel destroy channel %s", kchan->channel->name); + + /* Update channel count of associated session. */ + if (kchan->session) { + /* Keep pointer reference so we can update it after the destroy. */ + ksess = kchan->session; + } + + trace_kernel_destroy_channel(kchan); + + /* + * At this point the kernel channel is not visible anymore. This is safe + * since in order to work on a visible kernel session, the tracing session + * lock (ltt_session.lock) MUST be acquired. + */ + if (ksess) { + ksess->channel_count--; + } +}