From 0525e9ae15d215943d8187e7f190d5a45e723085 Mon Sep 17 00:00:00 2001 From: David Goulet Date: Tue, 22 Jan 2013 11:38:11 -0500 Subject: [PATCH] Add safety assert() in session daemon Note here that a test has been removed which tested the NULL parameter of the session_destroy() call where now we assert if there is a NULL pointer. It's a code flow error if a NULL pointer gets to this call so the test becomes irrelevant. Signed-off-by: David Goulet --- src/bin/lttng-sessiond/channel.c | 35 ++++++++++++++++++++----- src/bin/lttng-sessiond/context.c | 18 +++++++++++++ src/bin/lttng-sessiond/event.c | 37 +++++++++++++++++++++++++-- src/bin/lttng-sessiond/kernel.c | 36 ++++++++++++++++++++++++++ src/bin/lttng-sessiond/session.c | 15 ++++++++--- src/bin/lttng-sessiond/shm.c | 4 +++ src/bin/lttng-sessiond/trace-kernel.c | 30 ++++++++++++++-------- src/bin/lttng-sessiond/trace-ust.c | 32 ++++++++++++++++++++--- tests/tools/test_sessions.c | 24 ----------------- 9 files changed, 180 insertions(+), 51 deletions(-) diff --git a/src/bin/lttng-sessiond/channel.c b/src/bin/lttng-sessiond/channel.c index 559c3d154..e11d6d11f 100644 --- a/src/bin/lttng-sessiond/channel.c +++ b/src/bin/lttng-sessiond/channel.c @@ -90,11 +90,17 @@ int channel_kernel_disable(struct ltt_kernel_session *ksession, int ret; struct ltt_kernel_channel *kchan; + assert(ksession); + assert(channel_name); + kchan = trace_kernel_get_channel_by_name(channel_name, ksession); if (kchan == NULL) { ret = LTTNG_ERR_KERN_CHAN_NOT_FOUND; goto error; - } else if (kchan->enabled == 1) { + } + + /* Only if channel is enabled disable it. */ + if (kchan->enabled == 1) { ret = kernel_disable_channel(kchan); if (ret < 0 && ret != -EEXIST) { ret = LTTNG_ERR_KERN_CHAN_DISABLE_FAIL; @@ -116,6 +122,9 @@ int channel_kernel_enable(struct ltt_kernel_session *ksession, { int ret; + assert(ksession); + assert(kchan); + if (kchan->enabled == 0) { ret = kernel_enable_channel(kchan); if (ret < 0) { @@ -142,6 +151,8 @@ int channel_kernel_create(struct ltt_kernel_session *ksession, int ret; struct lttng_channel *defattr = NULL; + assert(ksession); + /* Creating channel attributes if needed */ if (attr == NULL) { defattr = channel_new_default_attr(LTTNG_DOMAIN_KERNEL); @@ -180,6 +191,9 @@ int channel_ust_enable(struct ltt_ust_session *usess, int domain, { int ret = LTTNG_OK; + assert(usess); + assert(uchan); + /* If already enabled, everything is OK */ if (uchan->enabled) { DBG3("Channel %s already enabled. Skipping", uchan->name); @@ -229,6 +243,8 @@ int channel_ust_create(struct ltt_ust_session *usess, int domain, struct ltt_ust_channel *uchan = NULL; struct lttng_channel *defattr = NULL; + assert(usess); + /* Creating channel attributes if needed */ if (attr == NULL) { defattr = channel_new_default_attr(domain); @@ -245,16 +261,18 @@ int channel_ust_create(struct ltt_ust_session *usess, int domain, } /* - * Validate UST buffer size and number of buffers: must both be - * power of 2 and nonzero. We validate right here for UST, - * because applications will not report the error to the user - * (unlike kernel tracing). + * Validate UST buffer size and number of buffers: must both be power of 2 + * and nonzero. We validate right here for UST, because applications will + * not report the error to the user (unlike kernel tracing). */ - if (!attr->attr.subbuf_size || (attr->attr.subbuf_size & (attr->attr.subbuf_size - 1))) { + if (!attr->attr.subbuf_size || + (attr->attr.subbuf_size & (attr->attr.subbuf_size - 1))) { ret = LTTNG_ERR_INVALID; goto error; } - if (!attr->attr.num_subbuf || (attr->attr.num_subbuf & (attr->attr.num_subbuf - 1))) { + + if (!attr->attr.num_subbuf || + (attr->attr.num_subbuf & (attr->attr.num_subbuf - 1))) { ret = LTTNG_ERR_INVALID; goto error; } @@ -323,6 +341,9 @@ int channel_ust_disable(struct ltt_ust_session *usess, int domain, { int ret = LTTNG_OK; + assert(usess); + assert(uchan); + /* Already disabled */ if (uchan->enabled == 0) { DBG2("Channel UST %s already disabled", uchan->name); diff --git a/src/bin/lttng-sessiond/context.c b/src/bin/lttng-sessiond/context.c index cee61f764..c1b7410da 100644 --- a/src/bin/lttng-sessiond/context.c +++ b/src/bin/lttng-sessiond/context.c @@ -39,6 +39,9 @@ static int add_kctx_all_channels(struct ltt_kernel_session *ksession, int ret; struct ltt_kernel_channel *kchan; + assert(ksession); + assert(kctx); + DBG("Adding kernel context to all channels"); /* Go over all channels */ @@ -64,6 +67,9 @@ static int add_kctx_to_channel(struct lttng_kernel_context *kctx, { int ret; + assert(kchan); + assert(kctx); + DBG("Add kernel context to channel '%s'", kchan->channel->name); ret = kernel_add_channel_context(kchan, kctx); @@ -89,6 +95,10 @@ static int add_uctx_to_channel(struct ltt_ust_session *usess, int domain, struct lttng_ht_iter iter; struct lttng_ht_node_ulong *uctx_node; + assert(usess); + assert(uchan); + assert(ctx); + /* Create ltt UST context */ uctx = trace_ust_create_context(ctx); if (uctx == NULL) { @@ -142,6 +152,10 @@ int context_kernel_add(struct ltt_kernel_session *ksession, struct ltt_kernel_channel *kchan; struct lttng_kernel_context kctx; + assert(ksession); + assert(ctx); + assert(channel_name); + /* Setup kernel context structure */ switch (ctx->ctx) { case LTTNG_EVENT_CONTEXT_PID: @@ -223,6 +237,10 @@ int context_ust_add(struct ltt_ust_session *usess, int domain, struct lttng_ht *chan_ht; struct ltt_ust_channel *uchan = NULL; + assert(usess); + assert(ctx); + assert(channel_name); + /* * Define which channel's hashtable to use from the domain or quit if * unknown domain. diff --git a/src/bin/lttng-sessiond/event.c b/src/bin/lttng-sessiond/event.c index 0fec563ad..573e5a156 100644 --- a/src/bin/lttng-sessiond/event.c +++ b/src/bin/lttng-sessiond/event.c @@ -60,6 +60,8 @@ static void add_unique_ust_event(struct lttng_ht *ht, */ static void init_syscalls_kernel_event(struct lttng_event *event) { + assert(event); + event->name[0] = '\0'; /* * We use LTTNG_EVENT* here since the trace kernel creation will make the @@ -77,6 +79,8 @@ int event_kernel_disable_tracepoint(struct ltt_kernel_session *ksession, int ret; struct ltt_kernel_event *kevent; + assert(kchan); + kevent = trace_kernel_get_event_by_name(event_name, kchan); if (kevent == NULL) { ret = LTTNG_ERR_NO_EVENT; @@ -107,6 +111,8 @@ int event_kernel_disable_all_tracepoints(struct ltt_kernel_session *ksession, int ret; struct ltt_kernel_event *kevent; + assert(kchan); + /* For each event in the kernel session */ cds_list_for_each_entry(kevent, &kchan->events_list.head, list) { ret = kernel_disable_event(kevent); @@ -137,6 +143,9 @@ int event_kernel_disable_all(struct ltt_kernel_session *ksession, { int ret; + assert(ksession); + assert(kchan); + ret = event_kernel_disable_all_tracepoints(ksession, kchan); if (ret != LTTNG_OK) return ret; @@ -153,6 +162,9 @@ int event_kernel_enable_tracepoint(struct ltt_kernel_session *ksession, int ret; struct ltt_kernel_event *kevent; + assert(kchan); + assert(event); + kevent = trace_kernel_get_event_by_name(event->name, kchan); if (kevent == NULL) { ret = kernel_create_event(event, kchan); @@ -197,6 +209,8 @@ int event_kernel_enable_all_tracepoints(struct ltt_kernel_session *ksession, struct ltt_kernel_event *kevent; struct lttng_event *event_list = NULL; + assert(kchan); + /* For each event in the kernel session */ cds_list_for_each_entry(kevent, &kchan->events_list.head, list) { if (kevent->enabled == 0) { @@ -231,7 +245,6 @@ int event_kernel_enable_all_tracepoints(struct ltt_kernel_session *ksession, ret = LTTNG_OK; end: return ret; - } /* @@ -243,6 +256,8 @@ int event_kernel_enable_all_syscalls(struct ltt_kernel_session *ksession, int ret; struct lttng_event event; + assert(kchan); + init_syscalls_kernel_event(&event); DBG("Enabling all syscall tracing"); @@ -270,7 +285,11 @@ int event_kernel_enable_all(struct ltt_kernel_session *ksession, { int tp_ret; - tp_ret = event_kernel_enable_all_tracepoints(ksession, kchan, kernel_tracer_fd); + assert(ksession); + assert(kchan); + + tp_ret = event_kernel_enable_all_tracepoints(ksession, kchan, + kernel_tracer_fd); if (tp_ret != LTTNG_OK) { goto end; } @@ -307,6 +326,9 @@ int event_ust_enable_all_tracepoints(struct ltt_ust_session *usess, int domain, struct ltt_ust_event *uevent = NULL; struct lttng_event *events = NULL; + assert(usess); + assert(uchan); + rcu_read_lock(); switch (domain) { @@ -412,6 +434,10 @@ int event_ust_enable_tracepoint(struct ltt_ust_session *usess, int domain, int ret = LTTNG_OK, to_create = 0; struct ltt_ust_event *uevent; + assert(usess); + assert(uchan); + assert(event); + rcu_read_lock(); uevent = trace_ust_find_event(uchan->events, event->name, filter, @@ -509,6 +535,10 @@ int event_ust_disable_tracepoint(struct ltt_ust_session *usess, int domain, struct lttng_ht_iter iter; struct lttng_ht *ht; + assert(usess); + assert(uchan); + assert(event_name); + ht = uchan->events; rcu_read_lock(); @@ -583,6 +613,9 @@ int event_ust_disable_all_tracepoints(struct ltt_ust_session *usess, int domain, struct ltt_ust_event *uevent = NULL; struct lttng_event *events = NULL; + assert(usess); + assert(uchan); + rcu_read_lock(); switch (domain) { diff --git a/src/bin/lttng-sessiond/kernel.c b/src/bin/lttng-sessiond/kernel.c index b417cb077..32c40531d 100644 --- a/src/bin/lttng-sessiond/kernel.c +++ b/src/bin/lttng-sessiond/kernel.c @@ -40,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) { @@ -75,6 +78,8 @@ 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); if (lks == NULL) { @@ -118,6 +123,10 @@ int kernel_create_channel(struct ltt_kernel_session *session, int ret; struct ltt_kernel_channel *lkc; + assert(session); + assert(chan); + assert(path); + /* Allocate kernel channel */ lkc = trace_kernel_create_channel(chan, path); if (lkc == NULL) { @@ -168,6 +177,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; @@ -231,6 +243,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"); @@ -254,6 +268,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"); @@ -276,6 +292,8 @@ int kernel_enable_event(struct ltt_kernel_event *event) { int ret; + assert(event); + ret = kernctl_enable(event->fd); if (ret < 0) { switch (errno) { @@ -305,6 +323,8 @@ int kernel_disable_event(struct ltt_kernel_event *event) { int ret; + assert(event); + ret = kernctl_disable(event->fd); if (ret < 0) { switch (errno) { @@ -336,6 +356,8 @@ int kernel_open_metadata(struct ltt_kernel_session *session) int ret; struct ltt_kernel_metadata *lkm; + assert(session); + /* Allocate kernel metadata */ lkm = trace_kernel_create_metadata(); if (lkm == NULL) { @@ -372,6 +394,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"); @@ -409,6 +433,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"); @@ -442,6 +468,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) { @@ -464,6 +492,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; @@ -488,6 +518,8 @@ int kernel_open_channel_stream(struct ltt_kernel_channel *channel) int ret, count = 0; struct ltt_kernel_stream *lks; + assert(channel); + while ((ret = kernctl_create_stream(channel->fd)) >= 0) { lks = trace_kernel_create_stream(channel->channel->name, count); if (lks == NULL) { @@ -529,6 +561,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,6 +594,8 @@ ssize_t kernel_list_events(int tracer_fd, struct lttng_event **events) FILE *fp; struct lttng_event *elist; + assert(events); + fd = kernctl_tracepoint_list(tracer_fd); if (fd < 0) { PERROR("kernel tracepoint list"); diff --git a/src/bin/lttng-sessiond/session.c b/src/bin/lttng-sessiond/session.c index 7d0ee7d4a..65e3145a5 100644 --- a/src/bin/lttng-sessiond/session.c +++ b/src/bin/lttng-sessiond/session.c @@ -56,6 +56,8 @@ static struct ltt_session_list ltt_session_list = { */ static unsigned int add_session_list(struct ltt_session *ls) { + assert(ls); + cds_list_add(&ls->list, <t_session_list.head); return ltt_session_list.next_uuid++; } @@ -67,6 +69,8 @@ static unsigned int add_session_list(struct ltt_session *ls) */ static void del_session_list(struct ltt_session *ls) { + assert(ls); + cds_list_del(&ls->list); } @@ -99,6 +103,8 @@ void session_unlock_list(void) */ void session_lock(struct ltt_session *session) { + assert(session); + pthread_mutex_lock(&session->lock); } @@ -107,6 +113,8 @@ void session_lock(struct ltt_session *session) */ void session_unlock(struct ltt_session *session) { + assert(session); + pthread_mutex_unlock(&session->lock); } @@ -119,6 +127,8 @@ struct ltt_session *session_find_by_name(char *name) { struct ltt_session *iter; + assert(name); + DBG2("Trying to find session by name %s", name); cds_list_for_each_entry(iter, <t_session_list.head, list) { @@ -141,10 +151,7 @@ found: int session_destroy(struct ltt_session *session) { /* Safety check */ - if (session == NULL) { - ERR("Session pointer was null on session destroy"); - return LTTNG_OK; - } + assert(session); DBG("Destroying session %s", session->name); del_session_list(session); diff --git a/src/bin/lttng-sessiond/shm.c b/src/bin/lttng-sessiond/shm.c index 584ae078f..b94f4eb6a 100644 --- a/src/bin/lttng-sessiond/shm.c +++ b/src/bin/lttng-sessiond/shm.c @@ -43,6 +43,8 @@ static int get_wait_shm(char *shm_path, size_t mmap_size, int global) int wait_shm_fd, ret; mode_t mode; + assert(shm_path); + /* Default permissions */ mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP; @@ -138,6 +140,8 @@ char *shm_ust_get_mmap(char *shm_path, int global) int wait_shm_fd, ret; char *wait_shm_mmap; + assert(shm_path); + wait_shm_fd = get_wait_shm(shm_path, mmap_size, global); if (wait_shm_fd < 0) { goto error; diff --git a/src/bin/lttng-sessiond/trace-kernel.c b/src/bin/lttng-sessiond/trace-kernel.c index f38cf3d8d..12189b9ea 100644 --- a/src/bin/lttng-sessiond/trace-kernel.c +++ b/src/bin/lttng-sessiond/trace-kernel.c @@ -35,10 +35,8 @@ struct ltt_kernel_channel *trace_kernel_get_channel_by_name( { struct ltt_kernel_channel *chan; - if (session == NULL) { - ERR("Undefine session"); - goto error; - } + assert(session); + assert(name); DBG("Trying to find channel %s", name); @@ -49,7 +47,6 @@ struct ltt_kernel_channel *trace_kernel_get_channel_by_name( } } -error: return NULL; } @@ -61,10 +58,8 @@ struct ltt_kernel_event *trace_kernel_get_event_by_name( { struct ltt_kernel_event *ev; - if (channel == NULL) { - ERR("Undefine channel"); - goto error; - } + assert(name); + assert(channel); cds_list_for_each_entry(ev, &channel->events_list.head, list) { if (strcmp(name, ev->event->name) == 0) { @@ -74,7 +69,6 @@ struct ltt_kernel_event *trace_kernel_get_event_by_name( } } -error: return NULL; } @@ -153,6 +147,8 @@ struct ltt_kernel_channel *trace_kernel_create_channel( { struct ltt_kernel_channel *lkc; + assert(chan); + lkc = zmalloc(sizeof(struct ltt_kernel_channel)); if (lkc == NULL) { PERROR("ltt_kernel_channel zmalloc"); @@ -191,6 +187,8 @@ struct ltt_kernel_event *trace_kernel_create_event(struct lttng_event *ev) struct ltt_kernel_event *lke; struct lttng_kernel_event *attr; + assert(ev); + lke = zmalloc(sizeof(struct ltt_kernel_event)); attr = zmalloc(sizeof(struct lttng_kernel_event)); if (lke == NULL || attr == NULL) { @@ -302,6 +300,8 @@ struct ltt_kernel_stream *trace_kernel_create_stream(const char *name, int ret; struct ltt_kernel_stream *lks; + assert(name); + lks = zmalloc(sizeof(struct ltt_kernel_stream)); if (lks == NULL) { PERROR("kernel stream zmalloc"); @@ -331,6 +331,8 @@ error: */ void trace_kernel_destroy_stream(struct ltt_kernel_stream *stream) { + assert(stream); + DBG("[trace] Closing stream fd %d", stream->fd); /* Close kernel fd */ if (stream->fd >= 0) { @@ -352,6 +354,8 @@ void trace_kernel_destroy_stream(struct ltt_kernel_stream *stream) */ void trace_kernel_destroy_event(struct ltt_kernel_event *event) { + assert(event); + if (event->fd >= 0) { int ret; @@ -381,6 +385,8 @@ void trace_kernel_destroy_channel(struct ltt_kernel_channel *channel) struct ltt_kernel_event *event, *etmp; int ret; + assert(channel); + DBG("[trace] Closing channel fd %d", channel->fd); /* Close kernel fd */ if (channel->fd >= 0) { @@ -413,6 +419,8 @@ void trace_kernel_destroy_channel(struct ltt_kernel_channel *channel) */ void trace_kernel_destroy_metadata(struct ltt_kernel_metadata *metadata) { + assert(metadata); + DBG("[trace] Closing metadata fd %d", metadata->fd); /* Close kernel fd */ if (metadata->fd >= 0) { @@ -436,6 +444,8 @@ void trace_kernel_destroy_session(struct ltt_kernel_session *session) struct ltt_kernel_channel *channel, *ctmp; int ret; + assert(session); + DBG("[trace] Closing session fd %d", session->fd); /* Close kernel fds */ if (session->fd >= 0) { diff --git a/src/bin/lttng-sessiond/trace-ust.c b/src/bin/lttng-sessiond/trace-ust.c index 3d9390db2..1830763b1 100644 --- a/src/bin/lttng-sessiond/trace-ust.c +++ b/src/bin/lttng-sessiond/trace-ust.c @@ -262,6 +262,9 @@ struct ltt_ust_channel *trace_ust_create_channel(struct lttng_channel *chan, int ret; struct ltt_ust_channel *luc; + assert(chan); + assert(path); + luc = zmalloc(sizeof(struct ltt_ust_channel)); if (luc == NULL) { PERROR("ltt_ust_channel zmalloc"); @@ -322,6 +325,8 @@ struct ltt_ust_event *trace_ust_create_event(struct lttng_event *ev, { struct ltt_ust_event *lue; + assert(ev); + lue = zmalloc(sizeof(struct ltt_ust_event)); if (lue == NULL) { PERROR("ust event zmalloc"); @@ -396,6 +401,8 @@ struct ltt_ust_metadata *trace_ust_create_metadata(char *path) int ret; struct ltt_ust_metadata *lum; + assert(path); + lum = zmalloc(sizeof(struct ltt_ust_metadata)); if (lum == NULL) { PERROR("ust metadata zmalloc"); @@ -437,6 +444,8 @@ struct ltt_ust_context *trace_ust_create_context( struct ltt_ust_context *uctx; enum lttng_ust_context_type utype; + assert(ctx); + switch (ctx->ctx) { case LTTNG_EVENT_CONTEXT_VTID: utype = LTTNG_UST_CONTEXT_VTID; @@ -492,6 +501,8 @@ static void destroy_contexts(struct lttng_ht *ht) struct lttng_ht_node_ulong *node; struct lttng_ht_iter iter; + assert(ht); + cds_lfht_for_each_entry(ht->ht, &iter.iter, node, node) { ret = lttng_ht_del(ht, &iter); if (!ret) { @@ -507,6 +518,8 @@ static void destroy_contexts(struct lttng_ht *ht) */ void trace_ust_destroy_event(struct ltt_ust_event *event) { + assert(event); + DBG2("Trace destroy UST event %s", event->attr.name); free(event->filter); free(event); @@ -534,6 +547,8 @@ static void destroy_events(struct lttng_ht *events) struct lttng_ht_node_str *node; struct lttng_ht_iter iter; + assert(events); + cds_lfht_for_each_entry(events->ht, &iter.iter, node, node) { ret = lttng_ht_del(events, &iter); assert(!ret); @@ -548,6 +563,8 @@ static void destroy_events(struct lttng_ht *events) */ void trace_ust_destroy_channel(struct ltt_ust_channel *channel) { + assert(channel); + DBG2("Trace destroy UST channel %s", channel->name); rcu_read_lock(); @@ -580,6 +597,8 @@ static void destroy_channel_rcu(struct rcu_head *head) */ void trace_ust_destroy_metadata(struct ltt_ust_metadata *metadata) { + assert(metadata); + if (!metadata->handle) { return; } @@ -596,6 +615,8 @@ static void destroy_channels(struct lttng_ht *channels) struct lttng_ht_node_str *node; struct lttng_ht_iter iter; + assert(channels); + rcu_read_lock(); cds_lfht_for_each_entry(channels->ht, &iter.iter, node, node) { @@ -618,6 +639,8 @@ static void destroy_domain_pid(struct lttng_ht *ht) struct lttng_ht_iter iter; struct ltt_ust_domain_pid *dpid; + assert(ht); + cds_lfht_for_each_entry(ht->ht, &iter.iter, dpid, node.node) { ret = lttng_ht_del(ht , &iter); assert(!ret); @@ -636,6 +659,8 @@ static void destroy_domain_exec(struct lttng_ht *ht) struct lttng_ht_iter iter; struct ltt_ust_domain_exec *dexec; + assert(ht); + cds_lfht_for_each_entry(ht->ht, &iter.iter, dexec, node.node) { ret = lttng_ht_del(ht , &iter); assert(!ret); @@ -650,6 +675,8 @@ static void destroy_domain_exec(struct lttng_ht *ht) */ static void destroy_domain_global(struct ltt_ust_domain_global *dom) { + assert(dom); + destroy_channels(dom->channels); } @@ -658,10 +685,7 @@ static void destroy_domain_global(struct ltt_ust_domain_global *dom) */ void trace_ust_destroy_session(struct ltt_ust_session *session) { - /* Extra protection */ - if (session == NULL) { - return; - } + assert(session); rcu_read_lock(); diff --git a/tests/tools/test_sessions.c b/tests/tools/test_sessions.c index efe19ecdc..a6d76c73d 100644 --- a/tests/tools/test_sessions.c +++ b/tests/tools/test_sessions.c @@ -203,22 +203,6 @@ static int fuzzing_create_args(void) return 0; } -static int fuzzing_destroy_args(void) -{ - int ret; - - ret = destroy_one_session(NULL); - if (ret > 0) { - printf("Session destroyed with (null)\n"); - return -1; - } - - /* Session list must be 0 */ - assert(!session_list_count()); - - return 0; -} - /* * This test is supposed to fail at the second create call. If so, return 0 for * test success, else -1. @@ -307,14 +291,6 @@ int main(int argc, char **argv) } PRINT_OK(); - printf("Fuzzing destroy_session argument: "); - fflush(stdout); - ret = fuzzing_destroy_args(); - if (ret < 0) { - return -1; - } - PRINT_OK(); - printf("Creating %d sessions: ", MAX_SESSIONS); fflush(stdout); for (i = 0; i < MAX_SESSIONS; i++) { -- 2.34.1