Fix: zero out data structure before using it

[lttng-tools.git] / src / bin / lttng-sessiond / cmd.c

diff --git a/src/bin/lttng-sessiond/cmd.c b/src/bin/lttng-sessiond/cmd.c
index 8051973ded6cdfa184462f42482ef1857454e0e4..73ba7740fd131863172c53ae9e1cb558fe09f323 100644 (file)
--- a/src/bin/lttng-sessiond/cmd.c
+++ b/src/bin/lttng-sessiond/cmd.c
@@ -182,6 +182,55 @@ static void list_lttng_channels(int domain, struct ltt_session *session,
        }
 }
 
+/*
+ * Create a list of JUL domain events.
+ *
+ * Return number of events in list on success or else a negative value.
+ */
+static int list_lttng_jul_events(struct jul_domain *dom,
+               struct lttng_event **events)
+{
+       int i = 0, ret = 0;
+       unsigned int nb_event = 0;
+       struct jul_event *event;
+       struct lttng_event *tmp_events;
+       struct lttng_ht_iter iter;
+
+       assert(dom);
+       assert(events);
+
+       DBG3("Listing JUL events");
+
+       nb_event = lttng_ht_get_count(dom->events);
+       if (nb_event == 0) {
+               ret = nb_event;
+               goto error;
+       }
+
+       tmp_events = zmalloc(nb_event * sizeof(*tmp_events));
+       if (!tmp_events) {
+               PERROR("zmalloc JUL events session");
+               ret = -LTTNG_ERR_FATAL;
+               goto error;
+       }
+
+       rcu_read_lock();
+       cds_lfht_for_each_entry(dom->events->ht, &iter.iter, event, node.node) {
+               strncpy(tmp_events[i].name, event->name, sizeof(tmp_events[i].name));
+               tmp_events[i].name[sizeof(tmp_events[i].name) - 1] = '\0';
+               tmp_events[i].enabled = event->enabled;
+               i++;
+       }
+       rcu_read_unlock();
+
+       *events = tmp_events;
+       ret = nb_event;
+
+error:
+       assert(nb_event == i);
+       return ret;
+}
+
 /*
  * Create a list of ust global domain events.
  */
@@ -256,6 +305,9 @@ static int list_lttng_ust_global_events(char *channel_name,
                if (uevent->filter) {
                        tmp[i].filter = 1;
                }
+               if (uevent->exclusion) {
+                       tmp[i].exclusion = 1;
+               }
                i++;
        }
 
@@ -1257,7 +1309,9 @@ error:
  */
 int cmd_enable_event(struct ltt_session *session, struct lttng_domain *domain,
                char *channel_name, struct lttng_event *event,
-               struct lttng_filter_bytecode *filter, int wpipe)
+               struct lttng_filter_bytecode *filter,
+               struct lttng_event_exclusion *exclusion,
+               int wpipe)
 {
        int ret, channel_created = 0;
        struct lttng_channel *attr;
@@ -1370,7 +1424,7 @@ int cmd_enable_event(struct ltt_session *session, struct lttng_domain *domain,
                }
 
                /* At this point, the session and channel exist on the tracer */
-               ret = event_ust_enable_tracepoint(usess, uchan, event, filter);
+               ret = event_ust_enable_tracepoint(usess, uchan, event, filter, exclusion);
                if (ret != LTTNG_OK) {
                        goto error;
                }
@@ -1385,6 +1439,7 @@ int cmd_enable_event(struct ltt_session *session, struct lttng_domain *domain,
                assert(usess);
 
                /* Create the default JUL tracepoint. */
+               memset(&uevent, 0, sizeof(uevent));
                uevent.type = LTTNG_EVENT_TRACEPOINT;
                uevent.loglevel_type = LTTNG_EVENT_LOGLEVEL_ALL;
                strncpy(uevent.name, DEFAULT_JUL_EVENT_NAME, sizeof(uevent.name));
@@ -1399,7 +1454,7 @@ int cmd_enable_event(struct ltt_session *session, struct lttng_domain *domain,
                tmp_dom.type = LTTNG_DOMAIN_UST;
 
                ret = cmd_enable_event(session, &tmp_dom, DEFAULT_JUL_CHANNEL_NAME,
-                               &uevent, NULL, wpipe);
+                               &uevent, NULL, NULL, wpipe);
                if (ret != LTTNG_OK && ret != LTTNG_ERR_UST_EVENT_ENABLED) {
                        goto error;
                }
@@ -1611,7 +1666,7 @@ int cmd_enable_event_all(struct ltt_session *session,
                tmp_dom.type = LTTNG_DOMAIN_UST;
 
                ret = cmd_enable_event(session, &tmp_dom, DEFAULT_JUL_CHANNEL_NAME,
-                               &uevent, NULL, wpipe);
+                               &uevent, NULL, NULL, wpipe);
                if (ret != LTTNG_OK && ret != LTTNG_ERR_UST_EVENT_ENABLED) {
                        goto error;
                }
@@ -1664,6 +1719,13 @@ ssize_t cmd_list_tracepoints(int domain, struct lttng_event **events)
                        goto error;
                }
                break;
+       case LTTNG_DOMAIN_JUL:
+               nb_events = jul_list_events(events);
+               if (nb_events < 0) {
+                       ret = LTTNG_ERR_UST_LIST_FAIL;
+                       goto error;
+               }
+               break;
        default:
                ret = LTTNG_ERR_UND;
                goto error;
@@ -2086,7 +2148,14 @@ int cmd_calibrate(int domain, struct lttng_calibrate *calibrate)
        {
                struct lttng_kernel_calibrate kcalibrate;
 
-               kcalibrate.type = calibrate->type;
+               switch (calibrate->type) {
+               case LTTNG_CALIBRATE_FUNCTION:
+               default:
+                       /* Default and only possible calibrate option. */
+                       kcalibrate.type = LTTNG_KERNEL_CALIBRATE_KRETPROBE;
+                       break;
+               }
+
                ret = kernel_calibrate(kernel_tracer_fd, &kcalibrate);
                if (ret < 0) {
                        ret = LTTNG_ERR_KERN_ENABLE_FAIL;
@@ -2098,7 +2167,14 @@ int cmd_calibrate(int domain, struct lttng_calibrate *calibrate)
        {
                struct lttng_ust_calibrate ucalibrate;
 
-               ucalibrate.type = calibrate->type;
+               switch (calibrate->type) {
+               case LTTNG_CALIBRATE_FUNCTION:
+               default:
+                       /* Default and only possible calibrate option. */
+                       ucalibrate.type = LTTNG_UST_CALIBRATE_TRACEPOINT;
+                       break;
+               }
+
                ret = ust_app_calibrate_glb(&ucalibrate);
                if (ret < 0) {
                        ret = LTTNG_ERR_UST_CALIBRATE_FAIL;
@@ -2212,6 +2288,10 @@ ssize_t cmd_list_domains(struct ltt_session *session,
        if (session->ust_session != NULL) {
                DBG3("Listing domains found UST global domain");
                nb_dom++;
+
+               if (session->ust_session->domain_jul.being_used) {
+                       nb_dom++;
+               }
        }
 
        *domains = zmalloc(nb_dom * sizeof(struct lttng_domain));
@@ -2229,6 +2309,12 @@ ssize_t cmd_list_domains(struct ltt_session *session,
                (*domains)[index].type = LTTNG_DOMAIN_UST;
                (*domains)[index].buf_type = session->ust_session->buffer_type;
                index++;
+
+               if (session->ust_session->domain_jul.being_used) {
+                       (*domains)[index].type = LTTNG_DOMAIN_JUL;
+                       (*domains)[index].buf_type = session->ust_session->buffer_type;
+                       index++;
+               }
        }
 
        return nb_dom;
@@ -2319,6 +2405,12 @@ ssize_t cmd_list_events(int domain, struct ltt_session *session,
                }
                break;
        }
+       case LTTNG_DOMAIN_JUL:
+               if (session->ust_session) {
+                       nb_event = list_lttng_jul_events(
+                                       &session->ust_session->domain_jul, events);
+               }
+               break;
        default:
                ret = LTTNG_ERR_UND;
                goto error;
@@ -2666,7 +2758,7 @@ error:
 /*
  * Record a kernel snapshot.
  *
- * Return 0 on success or a LTTNG_ERR code.
+ * Return LTTNG_OK on success or a LTTNG_ERR code.
  */
 static int record_kernel_snapshot(struct ltt_kernel_session *ksess,
                struct snapshot_output *output, struct ltt_session *session,
@@ -2755,12 +2847,17 @@ static int record_ust_snapshot(struct ltt_ust_session *usess,
 
        ret = ust_app_snapshot_record(usess, output, wait, nb_streams);
        if (ret < 0) {
-               if (ret == -EINVAL) {
+               switch (-ret) {
+               case EINVAL:
                        ret = LTTNG_ERR_INVALID;
-                       goto error_snapshot;
+                       break;
+               case ENODATA:
+                       ret = LTTNG_ERR_SNAPSHOT_NODATA;
+                       break;
+               default:
+                       ret = LTTNG_ERR_SNAPSHOT_FAIL;
+                       break;
                }
-
-               ret = LTTNG_ERR_SNAPSHOT_FAIL;
                goto error_snapshot;
        }