Fix: handle the registration done command for JUL

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

diff --git a/src/bin/lttng-sessiond/jul.c b/src/bin/lttng-sessiond/jul.c
index 183081dc04bc942df9363eabc2d70f2e03d4517c..40730bb4fdf188cbc97f8daabd5c6b5025f2dfd4 100644 (file)
--- a/src/bin/lttng-sessiond/jul.c
+++ b/src/bin/lttng-sessiond/jul.c
@@ -67,6 +67,7 @@ static int send_header(struct lttcomm_sock *sock, uint64_t data_size,
 
        assert(sock);
 
+       memset(&msg, 0, sizeof(msg));
        msg.data_size = htobe64(data_size);
        msg.cmd = htobe32(cmd);
        msg.cmd_version = htobe32(cmd_version);
@@ -248,6 +249,9 @@ static int enable_event(struct jul_app *app, struct jul_event *event)
                goto error_io;
        }
 
+       memset(&msg, 0, sizeof(msg));
+       msg.loglevel = event->loglevel;
+       msg.loglevel_type = event->loglevel_type;
        strncpy(msg.name, event->name, sizeof(msg.name));
        ret = send_payload(app->sock, &msg, sizeof(msg));
        if (ret < 0) {
@@ -307,6 +311,7 @@ static int disable_event(struct jul_app *app, struct jul_event *event)
                goto error_io;
        }
 
+       memset(&msg, 0, sizeof(msg));
        strncpy(msg.name, event->name, sizeof(msg.name));
        ret = send_payload(app->sock, &msg, sizeof(msg));
        if (ret < 0) {
@@ -339,6 +344,21 @@ error:
        return ret;
 }
 
+/*
+ * Send back the registration DONE command to a given JUL application.
+ *
+ * Return 0 on success or else a negative value.
+ */
+int jul_send_registration_done(struct jul_app *app)
+{
+       assert(app);
+       assert(app->sock);
+
+       DBG("JUL sending registration done to app socket %d", app->sock->fd);
+
+       return send_header(app->sock, 0, JUL_CMD_REG_DONE, 0);
+}
+
 /*
  * Enable JUL event on every JUL applications registered with the session
  * daemon.
@@ -441,24 +461,30 @@ int jul_list_events(struct lttng_event **events)
                        goto error_unlock;
                }
 
-               if (count >= nbmem) {
+               if (count + nb_ev > nbmem) {
                        /* In case the realloc fails, we free the memory */
-                       void *ptr;
-
-                       DBG2("Reallocating JUL event list from %zu to %zu entries", nbmem,
-                                       2 * nbmem);
-                       nbmem *= 2;
-                       ptr = realloc(tmp_events, nbmem * sizeof(*tmp_events));
-                       if (!ptr) {
+                       struct lttng_event *new_tmp_events;
+                       size_t new_nbmem;
+
+                       new_nbmem = max_t(size_t, count + nb_ev, nbmem << 1);
+                       DBG2("Reallocating JUL event list from %zu to %zu entries",
+                                       nbmem, new_nbmem);
+                       new_tmp_events = realloc(tmp_events,
+                               new_nbmem * sizeof(*new_tmp_events));
+                       if (!new_tmp_events) {
                                PERROR("realloc JUL events");
                                ret = -ENOMEM;
                                free(jul_events);
                                goto error_unlock;
                        }
-                       tmp_events = ptr;
+                       /* Zero the new memory */
+                       memset(new_tmp_events + nbmem, 0,
+                               (new_nbmem - nbmem) * sizeof(*new_tmp_events));
+                       nbmem = new_nbmem;
+                       tmp_events = new_tmp_events;
                }
-               memcpy(tmp_events + (count * sizeof(*tmp_events)), jul_events,
-                               nb_ev * sizeof(*tmp_events));
+               memcpy(tmp_events + count, jul_events,
+                       nb_ev * sizeof(*tmp_events));
                free(jul_events);
                count += nb_ev;
        }
@@ -677,27 +703,6 @@ error:
        return NULL;
 }
 
-/*
- * Delete JUL event from given domain. Events hash table MUST be initialized.
- */
-void jul_delete_event(struct jul_event *event, struct jul_domain *dom)
-{
-       int ret;
-       struct lttng_ht_iter iter;
-
-       assert(event);
-       assert(dom);
-       assert(dom->events);
-
-       DBG3("JUL deleting event %s from domain", event->name);
-
-       iter.iter.node = &event->node.node;
-       rcu_read_lock();
-       ret = lttng_ht_del(dom->events, &iter);
-       rcu_read_unlock();
-       assert(!ret);
-}
-
 /*
  * Free given JUL event. This event must not be globally visible at this
  * point (only expected to be used on failure just after event