X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fkernel.c;h=2aeef263d6bd38c7238db96b0c99de4d230bdee2;hp=6f2604c607d2c1bc5fe4c24a53a2cf0458a4053d;hb=834978fd9e2392f20867351ca99bf7bdf31b4f56;hpb=ee91bab210156bd9a4ec23eac93aa563556f2803 diff --git a/src/bin/lttng-sessiond/kernel.c b/src/bin/lttng-sessiond/kernel.c index 6f2604c60..2aeef263d 100644 --- a/src/bin/lttng-sessiond/kernel.c +++ b/src/bin/lttng-sessiond/kernel.c @@ -32,12 +32,13 @@ #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; @@ -45,7 +46,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"); @@ -56,13 +57,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; @@ -136,11 +131,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); @@ -201,6 +196,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"); } @@ -354,6 +352,18 @@ 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); +} + /* * Create kernel metadata, open from the kernel tracer and add it to the * kernel session. @@ -602,7 +612,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; @@ -634,15 +644,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); @@ -650,6 +660,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); @@ -755,11 +769,11 @@ void kernel_destroy_session(struct ltt_kernel_session *ksess) DBG("Tearing down kernel session"); /* - * Destroy channels on the consumer if 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. + * 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) { + if (!ksess->output_traces && ksess->consumer_fds_sent) { int ret; struct consumer_socket *socket; struct lttng_ht_iter iter; @@ -819,12 +833,12 @@ void kernel_destroy_channel(struct ltt_kernel_channel *kchan) /* * Take a snapshot for a given kernel session. * - * Return 0 on success or else a negative value. + * 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) + struct snapshot_output *output, int wait, uint64_t max_size_per_stream) { - int ret, saved_metadata_fd; + int err, ret, saved_metadata_fd; struct consumer_socket *socket; struct lttng_ht_iter iter; struct ltt_kernel_metadata *saved_metadata; @@ -858,8 +872,6 @@ int kernel_snapshot_record(struct ltt_kernel_session *ksess, socket, node.node) { struct consumer_output *saved_output; struct ltt_kernel_channel *chan; - /* Code flow error */ - assert(socket->fd >= 0); /* * Temporarly switch consumer output for our snapshot output. As long @@ -883,10 +895,14 @@ int kernel_snapshot_record(struct ltt_kernel_session *ksess, 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); + ksess->uid, ksess->gid, + DEFAULT_KERNEL_TRACE_DIR, wait, + max_size_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; } } @@ -894,7 +910,8 @@ int kernel_snapshot_record(struct ltt_kernel_session *ksess, /* 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); + 1, ksess->uid, ksess->gid, + DEFAULT_KERNEL_TRACE_DIR, wait, max_size_per_stream); pthread_mutex_unlock(socket->lock); if (ret < 0) { ret = LTTNG_ERR_KERN_CONSUMER_FAIL; @@ -908,10 +925,12 @@ int kernel_snapshot_record(struct ltt_kernel_session *ksess, (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. */ - ret = close(ksess->metadata_stream_fd); - if (ret < 0) { + err = close(ksess->metadata_stream_fd); + if (err < 0) { PERROR("close snapshot kernel"); } @@ -925,3 +944,17 @@ error: 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); +}