trace_ust_create_event() now returns an error code

To be consistent with similar changes made to the
trace_kernel_create_event function.

Signed-off-by: Francis Deslauriers <francis.deslauriers@efficios.com>
Signed-off-by: Jérémie Galarneau <jeremie.galarneau@efficios.com>

diff --git a/src/bin/lttng-sessiond/event.c b/src/bin/lttng-sessiond/event.c
index a67941f09757dc3a06d65eb30e7c9afc490834bd..0a46ffb4bc0fb338c7b47af262dc49c14df5ec46 100644 (file)
--- a/src/bin/lttng-sessiond/event.c
+++ b/src/bin/lttng-sessiond/event.c
@@ -162,7 +162,7 @@ int event_ust_enable_tracepoint(struct ltt_ust_session *usess,
                struct lttng_event_exclusion *exclusion,
                bool internal_event)
 {
-       int ret = LTTNG_OK, to_create = 0;
+       int ret, to_create = 0;
        struct ltt_ust_event *uevent;
 
        assert(usess);
@@ -174,14 +174,13 @@ int event_ust_enable_tracepoint(struct ltt_ust_session *usess,
        uevent = trace_ust_find_event(uchan->events, event->name, filter,
                        event->loglevel_type, event->loglevel, exclusion);
        if (!uevent) {
-               uevent = trace_ust_create_event(event, filter_expression,
-                               filter, exclusion, internal_event);
+               ret = trace_ust_create_event(event, filter_expression,
+                               filter, exclusion, internal_event, &uevent);
                /* We have passed ownership */
                filter_expression = NULL;
                filter = NULL;
                exclusion = NULL;
-               if (uevent == NULL) {
-                       ret = LTTNG_ERR_UST_ENABLE_FAIL;
+               if (ret != LTTNG_OK) {
                        goto error;
                }
 

diff --git a/src/bin/lttng-sessiond/trace-ust.c b/src/bin/lttng-sessiond/trace-ust.c
index bcb04fe5733c4b1c8779b023b481fe6875dc4438..45dbec74e174feac9a7aba9932666b87f18e5628 100644 (file)
--- a/src/bin/lttng-sessiond/trace-ust.c
+++ b/src/bin/lttng-sessiond/trace-ust.c
@@ -435,91 +435,99 @@ end:
  * Allocate and initialize a ust event. Set name and event type.
  * We own filter_expression, filter, and exclusion.
  *
- * Return pointer to structure or NULL.
+ * Return an lttng_error_code
  */
-struct ltt_ust_event *trace_ust_create_event(struct lttng_event *ev,
+enum lttng_error_code trace_ust_create_event(struct lttng_event *ev,
                char *filter_expression,
                struct lttng_filter_bytecode *filter,
                struct lttng_event_exclusion *exclusion,
-               bool internal_event)
+               bool internal_event,
+               struct ltt_ust_event **ust_event)
 {
-       struct ltt_ust_event *lue;
+       struct ltt_ust_event *local_ust_event;
+       enum lttng_error_code ret = LTTNG_OK;
 
        assert(ev);
 
        if (exclusion && validate_exclusion(exclusion)) {
+               ret = LTTNG_ERR_INVALID;
                goto error;
        }
 
-       lue = zmalloc(sizeof(struct ltt_ust_event));
-       if (lue == NULL) {
+       local_ust_event = zmalloc(sizeof(struct ltt_ust_event));
+       if (local_ust_event == NULL) {
                PERROR("ust event zmalloc");
+               ret = LTTNG_ERR_NOMEM;
                goto error;
        }
 
-       lue->internal = internal_event;
+       local_ust_event->internal = internal_event;
 
        switch (ev->type) {
        case LTTNG_EVENT_PROBE:
-               lue->attr.instrumentation = LTTNG_UST_PROBE;
+               local_ust_event->attr.instrumentation = LTTNG_UST_PROBE;
                break;
        case LTTNG_EVENT_FUNCTION:
-               lue->attr.instrumentation = LTTNG_UST_FUNCTION;
+               local_ust_event->attr.instrumentation = LTTNG_UST_FUNCTION;
                break;
        case LTTNG_EVENT_FUNCTION_ENTRY:
-               lue->attr.instrumentation = LTTNG_UST_FUNCTION;
+               local_ust_event->attr.instrumentation = LTTNG_UST_FUNCTION;
                break;
        case LTTNG_EVENT_TRACEPOINT:
-               lue->attr.instrumentation = LTTNG_UST_TRACEPOINT;
+               local_ust_event->attr.instrumentation = LTTNG_UST_TRACEPOINT;
                break;
        default:
                ERR("Unknown ust instrumentation type (%d)", ev->type);
+               ret = LTTNG_ERR_INVALID;
                goto error_free_event;
        }
 
        /* Copy event name */
-       strncpy(lue->attr.name, ev->name, LTTNG_UST_SYM_NAME_LEN);
-       lue->attr.name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
+       strncpy(local_ust_event->attr.name, ev->name, LTTNG_UST_SYM_NAME_LEN);
+       local_ust_event->attr.name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
 
        switch (ev->loglevel_type) {
        case LTTNG_EVENT_LOGLEVEL_ALL:
-               lue->attr.loglevel_type = LTTNG_UST_LOGLEVEL_ALL;
-               lue->attr.loglevel = -1;        /* Force to -1 */
+               local_ust_event->attr.loglevel_type = LTTNG_UST_LOGLEVEL_ALL;
+               local_ust_event->attr.loglevel = -1;    /* Force to -1 */
                break;
        case LTTNG_EVENT_LOGLEVEL_RANGE:
-               lue->attr.loglevel_type = LTTNG_UST_LOGLEVEL_RANGE;
-               lue->attr.loglevel = ev->loglevel;
+               local_ust_event->attr.loglevel_type = LTTNG_UST_LOGLEVEL_RANGE;
+               local_ust_event->attr.loglevel = ev->loglevel;
                break;
        case LTTNG_EVENT_LOGLEVEL_SINGLE:
-               lue->attr.loglevel_type = LTTNG_UST_LOGLEVEL_SINGLE;
-               lue->attr.loglevel = ev->loglevel;
+               local_ust_event->attr.loglevel_type = LTTNG_UST_LOGLEVEL_SINGLE;
+               local_ust_event->attr.loglevel = ev->loglevel;
                break;
        default:
                ERR("Unknown ust loglevel type (%d)", ev->loglevel_type);
+               ret = LTTNG_ERR_INVALID;
                goto error_free_event;
        }
 
        /* Same layout. */
-       lue->filter_expression = filter_expression;
-       lue->filter = filter;
-       lue->exclusion = exclusion;
+       local_ust_event->filter_expression = filter_expression;
+       local_ust_event->filter = filter;
+       local_ust_event->exclusion = exclusion;
 
        /* Init node */
-       lttng_ht_node_init_str(&lue->node, lue->attr.name);
+       lttng_ht_node_init_str(&local_ust_event->node, local_ust_event->attr.name);
 
        DBG2("Trace UST event %s, loglevel (%d,%d) created",
-               lue->attr.name, lue->attr.loglevel_type,
-               lue->attr.loglevel);
+               local_ust_event->attr.name, local_ust_event->attr.loglevel_type,
+               local_ust_event->attr.loglevel);
+
+       *ust_event = local_ust_event;
 
-       return lue;
+       return ret;
 
 error_free_event:
-       free(lue);
+       free(local_ust_event);
 error:
        free(filter_expression);
        free(filter);
        free(exclusion);
-       return NULL;
+       return ret;
 }
 
 static

diff --git a/src/bin/lttng-sessiond/trace-ust.h b/src/bin/lttng-sessiond/trace-ust.h
index 33b0a20315fe23b8ac543a43af286c811d54e9e6..5e0b3c51866ef579d5b66b25b8d352cd182f9188 100644 (file)
--- a/src/bin/lttng-sessiond/trace-ust.h
+++ b/src/bin/lttng-sessiond/trace-ust.h
@@ -194,11 +194,11 @@ struct agent *trace_ust_find_agent(struct ltt_ust_session *session,
 struct ltt_ust_session *trace_ust_create_session(uint64_t session_id);
 struct ltt_ust_channel *trace_ust_create_channel(struct lttng_channel *attr,
                enum lttng_domain_type domain);
-struct ltt_ust_event *trace_ust_create_event(struct lttng_event *ev,
+enum lttng_error_code trace_ust_create_event(struct lttng_event *ev,
                char *filter_expression,
                struct lttng_filter_bytecode *filter,
                struct lttng_event_exclusion *exclusion,
-               bool internal_event);
+               bool internal_event, struct ltt_ust_event **ust_event);
 struct ltt_ust_context *trace_ust_create_context(
                struct lttng_event_context *ctx);
 int trace_ust_match_context(struct ltt_ust_context *uctx,
@@ -254,13 +254,13 @@ struct ltt_ust_channel *trace_ust_create_channel(struct lttng_channel *attr,
        return NULL;
 }
 static inline
-struct ltt_ust_event *trace_ust_create_event(struct lttng_event *ev,
+enum lttng_error_code trace_ust_create_event(struct lttng_event *ev,
                const char *filter_expression,
                struct lttng_filter_bytecode *filter,
                struct lttng_event_exclusion *exclusion,
-               bool internal_event)
+               bool internal_event, struct ltt_ust_event **ust_event)
 {
-       return NULL;
+       return LTTNG_ERR_NO_UST;
 }
 static inline
 void trace_ust_destroy_session(struct ltt_ust_session *session)

diff --git a/tests/unit/test_ust_data.c b/tests/unit/test_ust_data.c
index ac3350d796baabe6647d0971b872c3feeeff23fd..b80cb5b5402eeb26ca2f67cb301a96d8b4714343 100644 (file)
--- a/tests/unit/test_ust_data.c
+++ b/tests/unit/test_ust_data.c
@@ -150,6 +150,7 @@ static void test_create_ust_event(void)
 {
        struct ltt_ust_event *event;
        struct lttng_event ev;
+       enum lttng_error_code ret;
 
        memset(&ev, 0, sizeof(ev));
        ok(lttng_strncpy(ev.name, get_random_string(),
@@ -158,9 +159,9 @@ static void test_create_ust_event(void)
        ev.type = LTTNG_EVENT_TRACEPOINT;
        ev.loglevel_type = LTTNG_EVENT_LOGLEVEL_ALL;
 
-       event = trace_ust_create_event(&ev, NULL, NULL, NULL, false);
+       ret = trace_ust_create_event(&ev, NULL, NULL, NULL, false, &event);
 
-       ok(event != NULL, "Create UST event");
+       ok(ret == LTTNG_OK, "Create UST event");
 
        if (!event) {
                skip(1, "UST event is null");
@@ -178,6 +179,7 @@ static void test_create_ust_event(void)
 
 static void test_create_ust_event_exclusion(void)
 {
+       enum lttng_error_code ret;
        struct ltt_ust_event *event;
        struct lttng_event ev;
        char *name;
@@ -212,10 +214,10 @@ static void test_create_ust_event_exclusion(void)
        strncpy(LTTNG_EVENT_EXCLUSION_NAME_AT(exclusion, 1), random_name,
                LTTNG_SYMBOL_NAME_LEN);
 
-       event = trace_ust_create_event(&ev, NULL, NULL, exclusion, false);
+       ret = trace_ust_create_event(&ev, NULL, NULL, exclusion, false, &event);
        exclusion = NULL;
 
-       ok(!event, "Create UST event with identical exclusion names fails");
+       ok(ret != LTTNG_OK, "Create UST event with identical exclusion names fails");
 
        exclusion = zmalloc(sizeof(*exclusion) +
                LTTNG_SYMBOL_NAME_LEN * exclusion_count);
@@ -231,8 +233,8 @@ static void test_create_ust_event_exclusion(void)
        strncpy(LTTNG_EVENT_EXCLUSION_NAME_AT(exclusion, 1),
                get_random_string(), LTTNG_SYMBOL_NAME_LEN);
 
-       event = trace_ust_create_event(&ev, NULL, NULL, exclusion, false);
-       ok(event != NULL, "Create UST event with different exclusion names");
+       ret = trace_ust_create_event(&ev, NULL, NULL, exclusion, false, &event);
+       ok(ret == LTTNG_OK, "Create UST event with different exclusion names");
 
        if (!event) {
                skip(1, "UST event with exclusion is null");