X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fkernel.c;h=4bb418949d3ea330b60397ed2352f5541c7fcbdc;hp=2c6d1e8c335c887118711acafaeccf488bdd8cba;hb=ccf10263bcd2ca4667b9e1fc4dab64a3c8d8c4d8;hpb=74024a2182ddbedbbb67fea9dc8b370ff0fd5896 diff --git a/src/bin/lttng-sessiond/kernel.c b/src/bin/lttng-sessiond/kernel.c index 2c6d1e8c3..4bb418949 100644 --- a/src/bin/lttng-sessiond/kernel.c +++ b/src/bin/lttng-sessiond/kernel.c @@ -16,6 +16,7 @@ */ #define _GNU_SOURCE +#define _LGPL_SOURCE #include #include #include @@ -26,17 +27,20 @@ #include #include +#include #include #include "consumer.h" #include "kernel.h" +#include "kernel-consumer.h" #include "kern-modules.h" +#include "utils.h" /* * Add context on a kernel channel. */ int kernel_add_channel_context(struct ltt_kernel_channel *chan, - struct lttng_kernel_context *ctx) + struct ltt_kernel_context *ctx) { int ret; @@ -44,7 +48,7 @@ int kernel_add_channel_context(struct ltt_kernel_channel *chan, assert(ctx); DBG("Adding context to channel %s", chan->channel->name); - ret = kernctl_add_context(chan->fd, ctx); + ret = kernctl_add_context(chan->fd, &ctx->ctx); if (ret < 0) { if (errno != EEXIST) { PERROR("add context ioctl"); @@ -55,13 +59,7 @@ int kernel_add_channel_context(struct ltt_kernel_channel *chan, goto error; } - chan->ctx = zmalloc(sizeof(struct lttng_kernel_context)); - if (chan->ctx == NULL) { - PERROR("zmalloc event context"); - goto error; - } - - memcpy(chan->ctx, ctx, sizeof(struct lttng_kernel_context)); + cds_list_add_tail(&ctx->list, &chan->ctx_list); return 0; @@ -110,6 +108,9 @@ int kernel_create_session(struct ltt_session *session, int tracer_fd) return 0; error: + if (lks) { + trace_kernel_destroy_session(lks); + } return ret; } @@ -132,11 +133,11 @@ int kernel_create_channel(struct ltt_kernel_session *session, goto error; } - DBG3("Kernel create channel %s with attr: %d, %" PRIu64 ", %" PRIu64 ", %u, %u, %d", + DBG3("Kernel create channel %s with attr: %d, %" PRIu64 ", %" PRIu64 ", %u, %u, %d, %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); + lkc->channel->attr.live_timer_interval, lkc->channel->attr.output); /* Kernel tracer channel creation */ ret = kernctl_create_channel(session->fd, &lkc->channel->attr); @@ -163,12 +164,17 @@ int kernel_create_channel(struct ltt_kernel_session *session, return 0; error: + if (lkc) { + free(lkc->channel); + free(lkc); + } return -1; } /* * Create a kernel event, enable it to the kernel tracer and add it to the * channel event list of the kernel session. + * We own filter_expression and filter. */ int kernel_create_event(struct lttng_event *ev, struct ltt_kernel_channel *channel) @@ -193,6 +199,9 @@ int kernel_create_event(struct lttng_event *ev, case ENOSYS: WARN("Event type not implemented"); break; + case ENOENT: + WARN("Event %s not found!", ev->name); + break; default: PERROR("create event ioctl"); } @@ -346,6 +355,32 @@ error: return ret; } +int kernel_enable_syscall(const char *syscall_name, + struct ltt_kernel_channel *channel) +{ + return kernctl_enable_syscall(channel->fd, syscall_name); +} + +int kernel_disable_syscall(const char *syscall_name, + struct ltt_kernel_channel *channel) +{ + return kernctl_disable_syscall(channel->fd, syscall_name); +} + +int kernel_track_pid(struct ltt_kernel_session *session, int pid) +{ + DBG("Kernel track PID %d for session id %" PRIu64 ".", + pid, session->id); + return kernctl_track_pid(session->fd, pid); +} + +int kernel_untrack_pid(struct ltt_kernel_session *session, int pid) +{ + DBG("Kernel untrack PID %d for session id %" PRIu64 ".", + pid, session->id); + return kernctl_untrack_pid(session->fd, pid); +} + /* * Create kernel metadata, open from the kernel tracer and add it to the * kernel session. @@ -453,6 +488,8 @@ 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); @@ -592,7 +629,7 @@ error: */ ssize_t kernel_list_events(int tracer_fd, struct lttng_event **events) { - int fd, pos, ret; + int fd, ret; char *event; size_t nbmem, count = 0; FILE *fp; @@ -624,15 +661,15 @@ ssize_t kernel_list_events(int tracer_fd, struct lttng_event **events) goto end; } - while (fscanf(fp, "event { name = %m[^;]; };%n\n", &event, &pos) == 1) { + while (fscanf(fp, "event { name = %m[^;]; };\n", &event) == 1) { if (count >= nbmem) { struct lttng_event *new_elist; + size_t new_nbmem; - DBG("Reallocating event list from %zu to %zu bytes", nbmem, - nbmem * 2); - /* Double the size */ - nbmem <<= 1; - new_elist = realloc(elist, nbmem * sizeof(struct lttng_event)); + new_nbmem = nbmem << 1; + DBG("Reallocating event list from %zu to %zu bytes", + nbmem, new_nbmem); + new_elist = realloc(elist, new_nbmem * sizeof(struct lttng_event)); if (new_elist == NULL) { PERROR("realloc list events"); free(event); @@ -640,6 +677,10 @@ ssize_t kernel_list_events(int tracer_fd, struct lttng_event **events) count = -ENOMEM; goto end; } + /* Zero the new memory */ + memset(new_elist + nbmem, 0, + (new_nbmem - nbmem) * sizeof(struct lttng_event)); + nbmem = new_nbmem; elist = new_elist; } strncpy(elist[count].name, event, LTTNG_SYMBOL_NAME_LEN); @@ -674,6 +715,7 @@ int kernel_validate_version(int tracer_fd) { int ret; struct lttng_kernel_tracer_version version; + struct lttng_kernel_tracer_abi_version abi_version; ret = kernctl_tracer_version(tracer_fd, &version); if (ret < 0) { @@ -682,17 +724,28 @@ int kernel_validate_version(int tracer_fd) } /* Validate version */ - if (version.major != KERN_MODULES_PRE_MAJOR - && version.major != KERN_MODULES_MAJOR) { + if (version.major != VERSION_MAJOR) { + ERR("Kernel tracer major version (%d) is not compatible with lttng-tools major version (%d)", + version.major, VERSION_MAJOR); goto error_version; } - - DBG2("Kernel tracer version validated (major version %d)", version.major); + ret = kernctl_tracer_abi_version(tracer_fd, &abi_version); + if (ret < 0) { + ERR("Failed at getting lttng-modules ABI version"); + goto error; + } + if (abi_version.major != LTTNG_MODULES_ABI_MAJOR_VERSION) { + ERR("Kernel tracer ABI version (%d.%d) is not compatible with expected ABI major version (%d.*)", + abi_version.major, abi_version.minor, + LTTNG_MODULES_ABI_MAJOR_VERSION); + goto error; + } + DBG2("Kernel tracer version validated (%d.%d, ABI %d.%d)", + version.major, version.minor, + abi_version.major, abi_version.minor); return 0; error_version: - ERR("Kernel major version %d is not compatible (supporting <= %d)", - version.major, KERN_MODULES_MAJOR) ret = -1; error: @@ -744,6 +797,34 @@ void kernel_destroy_session(struct ltt_kernel_session *ksess) DBG("Tearing down kernel session"); + /* + * Destroy channels on the consumer if at least one FD has been sent and we + * are in no output mode because the streams are in *no* monitor mode so we + * have to send a command to clean them up or else they leaked. + */ + if (!ksess->output_traces && ksess->consumer_fds_sent) { + int ret; + struct consumer_socket *socket; + struct lttng_ht_iter iter; + + /* For each consumer socket. */ + rcu_read_lock(); + cds_lfht_for_each_entry(ksess->consumer->socks->ht, &iter.iter, + socket, node.node) { + struct ltt_kernel_channel *chan; + + /* For each channel, ask the consumer to destroy it. */ + cds_list_for_each_entry(chan, &ksess->channel_list.head, list) { + ret = kernel_consumer_destroy_channel(socket, chan); + if (ret < 0) { + /* Consumer is probably dead. Use next socket. */ + continue; + } + } + } + rcu_read_unlock(); + } + /* Close any relayd session */ consumer_output_send_destroy_relayd(ksess->consumer); @@ -779,3 +860,133 @@ void kernel_destroy_channel(struct ltt_kernel_channel *kchan) ksess->channel_count--; } } + +/* + * Take a snapshot for a given kernel session. + * + * Return 0 on success or else return a LTTNG_ERR code. + */ +int kernel_snapshot_record(struct ltt_kernel_session *ksess, + struct snapshot_output *output, int wait, + uint64_t nb_packets_per_stream) +{ + int err, ret, saved_metadata_fd; + struct consumer_socket *socket; + struct lttng_ht_iter iter; + struct ltt_kernel_metadata *saved_metadata; + + assert(ksess); + assert(ksess->consumer); + assert(output); + + DBG("Kernel snapshot record started"); + + /* Save current metadata since the following calls will change it. */ + saved_metadata = ksess->metadata; + saved_metadata_fd = ksess->metadata_stream_fd; + + rcu_read_lock(); + + ret = kernel_open_metadata(ksess); + if (ret < 0) { + ret = LTTNG_ERR_KERN_META_FAIL; + goto error; + } + + ret = kernel_open_metadata_stream(ksess); + if (ret < 0) { + ret = LTTNG_ERR_KERN_META_FAIL; + goto error_open_stream; + } + + /* Send metadata to consumer and snapshot everything. */ + cds_lfht_for_each_entry(ksess->consumer->socks->ht, &iter.iter, + socket, node.node) { + struct consumer_output *saved_output; + struct ltt_kernel_channel *chan; + + /* + * Temporarly switch consumer output for our snapshot output. As long + * as the session lock is taken, this is safe. + */ + saved_output = ksess->consumer; + ksess->consumer = output->consumer; + + pthread_mutex_lock(socket->lock); + /* This stream must not be monitored by the consumer. */ + ret = kernel_consumer_add_metadata(socket, ksess, 0); + pthread_mutex_unlock(socket->lock); + /* Put back the saved consumer output into the session. */ + ksess->consumer = saved_output; + if (ret < 0) { + ret = LTTNG_ERR_KERN_CONSUMER_FAIL; + goto error_consumer; + } + + /* For each channel, ask the consumer to snapshot it. */ + cds_list_for_each_entry(chan, &ksess->channel_list.head, list) { + pthread_mutex_lock(socket->lock); + ret = consumer_snapshot_channel(socket, chan->fd, output, 0, + ksess->uid, ksess->gid, + DEFAULT_KERNEL_TRACE_DIR, wait, + nb_packets_per_stream); + pthread_mutex_unlock(socket->lock); + if (ret < 0) { + ret = LTTNG_ERR_KERN_CONSUMER_FAIL; + (void) kernel_consumer_destroy_metadata(socket, + ksess->metadata); + goto error_consumer; + } + } + + /* Snapshot metadata, */ + pthread_mutex_lock(socket->lock); + ret = consumer_snapshot_channel(socket, ksess->metadata->fd, output, + 1, ksess->uid, ksess->gid, + DEFAULT_KERNEL_TRACE_DIR, wait, 0); + pthread_mutex_unlock(socket->lock); + if (ret < 0) { + ret = LTTNG_ERR_KERN_CONSUMER_FAIL; + goto error_consumer; + } + + /* + * The metadata snapshot is done, ask the consumer to destroy it since + * it's not monitored on the consumer side. + */ + (void) kernel_consumer_destroy_metadata(socket, ksess->metadata); + } + + ret = LTTNG_OK; + +error_consumer: + /* Close newly opened metadata stream. It's now on the consumer side. */ + err = close(ksess->metadata_stream_fd); + if (err < 0) { + PERROR("close snapshot kernel"); + } + +error_open_stream: + trace_kernel_destroy_metadata(ksess->metadata); +error: + /* Restore metadata state.*/ + ksess->metadata = saved_metadata; + ksess->metadata_stream_fd = saved_metadata_fd; + + rcu_read_unlock(); + return ret; +} + +/* + * Get the syscall mask array from the kernel tracer. + * + * Return 0 on success else a negative value. In both case, syscall_mask should + * be freed. + */ +int kernel_syscall_mask(int chan_fd, char **syscall_mask, uint32_t *nr_bits) +{ + assert(syscall_mask); + assert(nr_bits); + + return kernctl_syscall_mask(chan_fd, syscall_mask, nr_bits); +}