Use compiler-agnostic defines to silence warning

[lttng-tools.git] / src / bin / lttng-sessiond / client.cpp

diff --git a/src/bin/lttng-sessiond/client.cpp b/src/bin/lttng-sessiond/client.cpp
index 4c4cdf54092a6212c76a8dbbd0a01e656a743b4f..310b79f8b381dfb8884519049a187ef41dabd697 100644 (file)
--- a/src/bin/lttng-sessiond/client.cpp
+++ b/src/bin/lttng-sessiond/client.cpp
@@ -7,25 +7,42 @@
  *
  */
 
  *
  */
 

-#include "common/buffer-view.hpp"
-#include "common/compat/socket.hpp"
-#include "common/dynamic-array.hpp"
-#include "common/dynamic-buffer.hpp"
-#include "common/fd-handle.hpp"
-#include "common/payload-view.hpp"
-#include "common/payload.hpp"
-#include "common/sessiond-comm/sessiond-comm.hpp"
-#include "lttng/lttng-error.h"
-#include "lttng/tracker.h"
+#include "agent-thread.hpp"
+#include "clear.hpp"
+#include "client.hpp"
+#include "cmd.hpp"
+#include "health-sessiond.hpp"
+#include "kernel.hpp"
+#include "lttng-sessiond.hpp"
+#include "manage-consumer.hpp"
+#include "save.hpp"
+#include "testpoint.hpp"
+#include "utils.hpp"
+
+#include <common/buffer-view.hpp>

 #include <common/compat/getenv.hpp>
 #include <common/compat/getenv.hpp>

+#include <common/compat/socket.hpp>
+#include <common/dynamic-array.hpp>
+#include <common/dynamic-buffer.hpp>
+#include <common/exception.hpp>
+#include <common/fd-handle.hpp>
+#include <common/payload-view.hpp>
+#include <common/payload.hpp>
+#include <common/pthread-lock.hpp>
+#include <common/scope-exit.hpp>
+#include <common/sessiond-comm/sessiond-comm.hpp>

 #include <common/tracker.hpp>
 #include <common/unix.hpp>
 #include <common/utils.hpp>
 #include <common/tracker.hpp>
 #include <common/unix.hpp>
 #include <common/utils.hpp>

+

 #include <lttng/error-query-internal.hpp>
 #include <lttng/event-internal.hpp>
 #include <lttng/error-query-internal.hpp>
 #include <lttng/event-internal.hpp>

+#include <lttng/lttng.h>

 #include <lttng/session-descriptor-internal.hpp>
 #include <lttng/session-internal.hpp>
 #include <lttng/userspace-probe-internal.hpp>
 #include <lttng/session-descriptor-internal.hpp>
 #include <lttng/session-internal.hpp>
 #include <lttng/userspace-probe-internal.hpp>

+
+#include <fcntl.h>

 #include <pthread.h>
 #include <signal.h>
 #include <stddef.h>
 #include <pthread.h>
 #include <signal.h>
 #include <stddef.h>


@@ -33,17 +50,7 @@
 #include <sys/stat.h>
 #include <unistd.h>
 
 #include <sys/stat.h>
 #include <unistd.h>
 

-#include "agent-thread.hpp"
-#include "clear.hpp"
-#include "client.hpp"
-#include "cmd.hpp"
-#include "health-sessiond.hpp"
-#include "kernel.hpp"
-#include "lttng-sessiond.hpp"
-#include "manage-consumer.hpp"
-#include "save.hpp"
-#include "testpoint.hpp"
-#include "utils.hpp"
+namespace ls = lttng::sessiond;

 
 namespace {
 bool is_root;
 
 namespace {
 bool is_root;


@@ -62,7 +69,7 @@ static void set_thread_status(bool running)
        sem_post(&thread_state.ready);
 }
 
        sem_post(&thread_state.ready);
 }
 

-static bool wait_thread_status(void)
+static bool wait_thread_status()

 {
        DBG("Waiting for client thread to be ready");
        sem_wait(&thread_state.ready);
 {
        DBG("Waiting for client thread to be ready");
        sem_wait(&thread_state.ready);


@@ -79,92 +86,77 @@ static bool wait_thread_status(void)
  * Setup the outgoing data buffer for the response (llm) by allocating the
  * right amount of memory and copying the original information from the lsm
  * structure.
  * Setup the outgoing data buffer for the response (llm) by allocating the
  * right amount of memory and copying the original information from the lsm
  * structure.

- *
- * Return 0 on success, negative value on error.

  */
  */

-static int setup_lttng_msg(struct command_ctx *cmd_ctx,
-       const void *payload_buf, size_t payload_len,
-       const void *cmd_header_buf, size_t cmd_header_len)
+static void setup_lttng_msg(struct command_ctx *cmd_ctx,
+                           const void *payload_buf,
+                           size_t payload_len,
+                           const void *cmd_header_buf,
+                           size_t cmd_header_len)

 {
 {

-       int ret = 0;
-       const size_t header_len = sizeof(struct lttcomm_lttng_msg);
-       const size_t total_msg_size = header_len + cmd_header_len + payload_len;
-       lttcomm_lttng_msg llm {};
+       const auto header_len = sizeof(struct lttcomm_lttng_msg);
+       const auto total_msg_size = header_len + cmd_header_len + payload_len;
+       lttcomm_lttng_msg llm{};

 
        llm.cmd_type = cmd_ctx->lsm.cmd_type;
        llm.pid = (uint32_t) cmd_ctx->lsm.domain.attr.pid;
        llm.cmd_header_size = (uint32_t) cmd_header_len;
        llm.data_size = (uint32_t) payload_len;
 
 
        llm.cmd_type = cmd_ctx->lsm.cmd_type;
        llm.pid = (uint32_t) cmd_ctx->lsm.domain.attr.pid;
        llm.cmd_header_size = (uint32_t) cmd_header_len;
        llm.data_size = (uint32_t) payload_len;
 

-       ret = lttng_dynamic_buffer_set_size(&cmd_ctx->reply_payload.buffer, 0);
-       if (ret) {
-               goto end;
-       }
+       const auto zero_ret = lttng_dynamic_buffer_set_size(&cmd_ctx->reply_payload.buffer, 0);
+       LTTNG_ASSERT(zero_ret == 0);

 
        lttng_dynamic_pointer_array_clear(&cmd_ctx->reply_payload._fd_handles);
 
        cmd_ctx->lttng_msg_size = total_msg_size;
 
        /* Append reply header. */
 
        lttng_dynamic_pointer_array_clear(&cmd_ctx->reply_payload._fd_handles);
 
        cmd_ctx->lttng_msg_size = total_msg_size;
 
        /* Append reply header. */

-       ret = lttng_dynamic_buffer_append(
-                       &cmd_ctx->reply_payload.buffer, &llm, sizeof(llm));
-       if (ret) {
-               goto end;
+       if (lttng_dynamic_buffer_append(&cmd_ctx->reply_payload.buffer, &llm, sizeof(llm))) {
+               LTTNG_THROW_ALLOCATION_FAILURE_ERROR(
+                       "Failed to append the reply header to a client reply", sizeof(llm));

        }
 
        /* Append command header. */
        if (cmd_header_len) {
        }
 
        /* Append command header. */
        if (cmd_header_len) {

-               ret = lttng_dynamic_buffer_append(
-                               &cmd_ctx->reply_payload.buffer, cmd_header_buf,
+               if (lttng_dynamic_buffer_append(
+                           &cmd_ctx->reply_payload.buffer, cmd_header_buf, cmd_header_len)) {
+                       LTTNG_THROW_ALLOCATION_FAILURE_ERROR(
+                               "Failed to append the command header to a client reply",

                                cmd_header_len);
                                cmd_header_len);

-               if (ret) {
-                       goto end;

                }
        }
 
        /* Append payload. */
        if (payload_len) {
                }
        }
 
        /* Append payload. */
        if (payload_len) {

-               ret = lttng_dynamic_buffer_append(
-                               &cmd_ctx->reply_payload.buffer, payload_buf,
-                               payload_len);
-               if (ret) {
-                       goto end;
+               if (lttng_dynamic_buffer_append(
+                           &cmd_ctx->reply_payload.buffer, payload_buf, payload_len)) {
+                       LTTNG_THROW_ALLOCATION_FAILURE_ERROR(
+                               "Failed to append the payload to a client reply", payload_len);

                }
        }
                }
        }

-
-end:
-       return ret;

 }
 
 }
 

-static int setup_empty_lttng_msg(struct command_ctx *cmd_ctx)
+static void setup_empty_lttng_msg(struct command_ctx *cmd_ctx)

 {
 {

-       int ret;

        const struct lttcomm_lttng_msg llm = {};
 
        const struct lttcomm_lttng_msg llm = {};
 

-       ret = lttng_dynamic_buffer_set_size(&cmd_ctx->reply_payload.buffer, 0);
-       if (ret) {
-               goto end;
-       }
+       const auto zero_ret = lttng_dynamic_buffer_set_size(&cmd_ctx->reply_payload.buffer, 0);
+       LTTNG_ASSERT(zero_ret == 0);

 
        /* Append place-holder reply header. */
 
        /* Append place-holder reply header. */

-       ret = lttng_dynamic_buffer_append(
-                       &cmd_ctx->reply_payload.buffer, &llm, sizeof(llm));
-       if (ret) {
-               goto end;
+       if (lttng_dynamic_buffer_append(&cmd_ctx->reply_payload.buffer, &llm, sizeof(llm))) {
+               LTTNG_THROW_ALLOCATION_FAILURE_ERROR(
+                       "Failed to append the reply header to a client reply", sizeof(llm));

        }
 
        cmd_ctx->lttng_msg_size = sizeof(llm);
        }
 
        cmd_ctx->lttng_msg_size = sizeof(llm);

-end:
-       return ret;

 }
 
 }
 

-static void update_lttng_msg(struct command_ctx *cmd_ctx, size_t cmd_header_len,
-               size_t payload_len)
+static void update_lttng_msg(struct command_ctx *cmd_ctx, size_t cmd_header_len, size_t payload_len)

 {
        const size_t header_len = sizeof(struct lttcomm_lttng_msg);
        const size_t total_msg_size = header_len + cmd_header_len + payload_len;
        struct lttcomm_lttng_msg *p_llm;
 {
        const size_t header_len = sizeof(struct lttcomm_lttng_msg);
        const size_t total_msg_size = header_len + cmd_header_len + payload_len;
        struct lttcomm_lttng_msg *p_llm;

-       lttcomm_lttng_msg llm {};
+       lttcomm_lttng_msg llm{};

 
        llm.cmd_type = cmd_ctx->lsm.cmd_type;
        llm.pid = (uint32_t) cmd_ctx->lsm.domain.attr.pid;
 
        llm.cmd_type = cmd_ctx->lsm.cmd_type;
        llm.pid = (uint32_t) cmd_ctx->lsm.domain.attr.pid;


@@ -226,9 +218,9 @@ static pid_t spawn_consumerd(struct consumer_data *consumer_data)
                         * fallback on the 32-bit one,
                         */
                        DBG3("Looking for a kernel consumer at these locations:");
                         * fallback on the 32-bit one,
                         */
                        DBG3("Looking for a kernel consumer at these locations:");

-                       DBG3("  1) %s", the_config.consumerd64_bin_path.value ? : "NULL");
+                       DBG3("  1) %s", the_config.consumerd64_bin_path.value ?: "NULL");

                        DBG3("  2) %s/%s", INSTALL_BIN_PATH, DEFAULT_CONSUMERD_FILE);
                        DBG3("  2) %s/%s", INSTALL_BIN_PATH, DEFAULT_CONSUMERD_FILE);

-                       DBG3("  3) %s", the_config.consumerd32_bin_path.value ? : "NULL");
+                       DBG3("  3) %s", the_config.consumerd32_bin_path.value ?: "NULL");

                        if (stat(the_config.consumerd64_bin_path.value, &st) == 0) {
                                DBG3("Found location #1");
                                consumer_to_use = the_config.consumerd64_bin_path.value;
                        if (stat(the_config.consumerd64_bin_path.value, &st) == 0) {
                                DBG3("Found location #1");
                                consumer_to_use = the_config.consumerd64_bin_path.value;


@@ -236,7 +228,7 @@ static pid_t spawn_consumerd(struct consumer_data *consumer_data)
                                DBG3("Found location #2");
                                consumer_to_use = INSTALL_BIN_PATH "/" DEFAULT_CONSUMERD_FILE;
                        } else if (the_config.consumerd32_bin_path.value &&
                                DBG3("Found location #2");
                                consumer_to_use = INSTALL_BIN_PATH "/" DEFAULT_CONSUMERD_FILE;
                        } else if (the_config.consumerd32_bin_path.value &&

-                                       stat(the_config.consumerd32_bin_path.value, &st) == 0) {
+                                  stat(the_config.consumerd32_bin_path.value, &st) == 0) {

                                DBG3("Found location #3");
                                consumer_to_use = the_config.consumerd32_bin_path.value;
                        } else {
                                DBG3("Found location #3");
                                consumer_to_use = the_config.consumerd32_bin_path.value;
                        } else {


@@ -244,15 +236,18 @@ static pid_t spawn_consumerd(struct consumer_data *consumer_data)
                                ret = -EINVAL;
                                goto error;
                        }
                                ret = -EINVAL;
                                goto error;
                        }

-                       DBG("Using kernel consumer at: %s",  consumer_to_use);
-                       (void) execl(consumer_to_use, "lttng-consumerd",
-                                       verbosity, "-k", "--consumerd-cmd-sock",
-                                       consumer_data->cmd_unix_sock_path,
-                                       "--consumerd-err-sock",
-                                       consumer_data->err_unix_sock_path,
-                                       "--group",
-                                       the_config.tracing_group_name.value,
-                                       NULL);
+                       DBG("Using kernel consumer at: %s", consumer_to_use);
+                       (void) execl(consumer_to_use,
+                                    "lttng-consumerd",
+                                    verbosity,
+                                    "-k",
+                                    "--consumerd-cmd-sock",
+                                    consumer_data->cmd_unix_sock_path,
+                                    "--consumerd-err-sock",
+                                    consumer_data->err_unix_sock_path,
+                                    "--group",
+                                    the_config.tracing_group_name.value,
+                                    NULL);

                        break;
                case LTTNG_CONSUMER64_UST:
                {
                        break;
                case LTTNG_CONSUMER64_UST:
                {


@@ -265,7 +260,8 @@ static pid_t spawn_consumerd(struct consumer_data *consumer_data)
                                if (!tmp) {
                                        tmp = "";
                                }
                                if (!tmp) {
                                        tmp = "";
                                }

-                               tmplen = strlen(the_config.consumerd64_lib_dir.value) + 1 /* : */ + strlen(tmp);
+                               tmplen = strlen(the_config.consumerd64_lib_dir.value) + 1 /* : */ +
+                                       strlen(tmp);

                                tmpnew = zmalloc<char>(tmplen + 1 /* \0 */);
                                if (!tmpnew) {
                                        ret = -ENOMEM;
                                tmpnew = zmalloc<char>(tmplen + 1 /* \0 */);
                                if (!tmpnew) {
                                        ret = -ENOMEM;


@@ -284,16 +280,18 @@ static pid_t spawn_consumerd(struct consumer_data *consumer_data)
                                }
                        }
                        DBG("Using 64-bit UST consumer at: %s",
                                }
                        }
                        DBG("Using 64-bit UST consumer at: %s",

-                                       the_config.consumerd64_bin_path.value);
+                           the_config.consumerd64_bin_path.value);

                        (void) execl(the_config.consumerd64_bin_path.value,
                        (void) execl(the_config.consumerd64_bin_path.value,

-                                       "lttng-consumerd", verbosity, "-u",
-                                       "--consumerd-cmd-sock",
-                                       consumer_data->cmd_unix_sock_path,
-                                       "--consumerd-err-sock",
-                                       consumer_data->err_unix_sock_path,
-                                       "--group",
-                                       the_config.tracing_group_name.value,
-                                       NULL);
+                                    "lttng-consumerd",
+                                    verbosity,
+                                    "-u",
+                                    "--consumerd-cmd-sock",
+                                    consumer_data->cmd_unix_sock_path,
+                                    "--consumerd-err-sock",
+                                    consumer_data->err_unix_sock_path,
+                                    "--group",
+                                    the_config.tracing_group_name.value,
+                                    NULL);

                        break;
                }
                case LTTNG_CONSUMER32_UST:
                        break;
                }
                case LTTNG_CONSUMER32_UST:


@@ -307,7 +305,8 @@ static pid_t spawn_consumerd(struct consumer_data *consumer_data)
                                if (!tmp) {
                                        tmp = "";
                                }
                                if (!tmp) {
                                        tmp = "";
                                }

-                               tmplen = strlen(the_config.consumerd32_lib_dir.value) + 1 /* : */ + strlen(tmp);
+                               tmplen = strlen(the_config.consumerd32_lib_dir.value) + 1 /* : */ +
+                                       strlen(tmp);

                                tmpnew = zmalloc<char>(tmplen + 1 /* \0 */);
                                if (!tmpnew) {
                                        ret = -ENOMEM;
                                tmpnew = zmalloc<char>(tmplen + 1 /* \0 */);
                                if (!tmpnew) {
                                        ret = -ENOMEM;


@@ -326,16 +325,18 @@ static pid_t spawn_consumerd(struct consumer_data *consumer_data)
                                }
                        }
                        DBG("Using 32-bit UST consumer at: %s",
                                }
                        }
                        DBG("Using 32-bit UST consumer at: %s",

-                                       the_config.consumerd32_bin_path.value);
+                           the_config.consumerd32_bin_path.value);

                        (void) execl(the_config.consumerd32_bin_path.value,
                        (void) execl(the_config.consumerd32_bin_path.value,

-                                       "lttng-consumerd", verbosity, "-u",
-                                       "--consumerd-cmd-sock",
-                                       consumer_data->cmd_unix_sock_path,
-                                       "--consumerd-err-sock",
-                                       consumer_data->err_unix_sock_path,
-                                       "--group",
-                                       the_config.tracing_group_name.value,
-                                       NULL);
+                                    "lttng-consumerd",
+                                    verbosity,
+                                    "-u",
+                                    "--consumerd-cmd-sock",
+                                    consumer_data->cmd_unix_sock_path,
+                                    "--consumerd-err-sock",
+                                    consumer_data->err_unix_sock_path,
+                                    "--group",
+                                    the_config.tracing_group_name.value,
+                                    NULL);

                        break;
                }
                default:
                        break;
                }
                default:


@@ -420,13 +421,12 @@ error:
  * function also applies the right modification on a per domain basis for the
  * trace files destination directory.
  */
  * function also applies the right modification on a per domain basis for the
  * trace files destination directory.
  */

-static int copy_session_consumer(int domain, struct ltt_session *session)
+static int copy_session_consumer(int domain, const ltt_session::locked_ref& session)

 {
        int ret;
        const char *dir_name;
        struct consumer_output *consumer;
 
 {
        int ret;
        const char *dir_name;
        struct consumer_output *consumer;
 

-       LTTNG_ASSERT(session);

        LTTNG_ASSERT(session->consumer);
 
        switch (domain) {
        LTTNG_ASSERT(session->consumer);
 
        switch (domain) {


@@ -441,22 +441,21 @@ static int copy_session_consumer(int domain, struct ltt_session *session)
                if (session->kernel_session->consumer) {
                        consumer_output_put(session->kernel_session->consumer);
                }
                if (session->kernel_session->consumer) {
                        consumer_output_put(session->kernel_session->consumer);
                }

-               session->kernel_session->consumer =
-                       consumer_copy_output(session->consumer);
+               session->kernel_session->consumer = consumer_copy_output(session->consumer);

                /* Ease our life a bit for the next part */
                consumer = session->kernel_session->consumer;
                dir_name = DEFAULT_KERNEL_TRACE_DIR;
                break;
        case LTTNG_DOMAIN_JUL:
        case LTTNG_DOMAIN_LOG4J:
                /* Ease our life a bit for the next part */
                consumer = session->kernel_session->consumer;
                dir_name = DEFAULT_KERNEL_TRACE_DIR;
                break;
        case LTTNG_DOMAIN_JUL:
        case LTTNG_DOMAIN_LOG4J:

+       case LTTNG_DOMAIN_LOG4J2:

        case LTTNG_DOMAIN_PYTHON:
        case LTTNG_DOMAIN_UST:
                DBG3("Copying tracing session consumer output in UST session");
                if (session->ust_session->consumer) {
                        consumer_output_put(session->ust_session->consumer);
                }
        case LTTNG_DOMAIN_PYTHON:
        case LTTNG_DOMAIN_UST:
                DBG3("Copying tracing session consumer output in UST session");
                if (session->ust_session->consumer) {
                        consumer_output_put(session->ust_session->consumer);
                }

-               session->ust_session->consumer =
-                       consumer_copy_output(session->consumer);
+               session->ust_session->consumer = consumer_copy_output(session->consumer);

                /* Ease our life a bit for the next part */
                consumer = session->ust_session->consumer;
                dir_name = DEFAULT_UST_TRACE_DIR;
                /* Ease our life a bit for the next part */
                consumer = session->ust_session->consumer;
                dir_name = DEFAULT_UST_TRACE_DIR;


@@ -467,8 +466,7 @@ static int copy_session_consumer(int domain, struct ltt_session *session)
        }
 
        /* Append correct directory to subdir */
        }
 
        /* Append correct directory to subdir */

-       ret = lttng_strncpy(consumer->domain_subdir, dir_name,
-                       sizeof(consumer->domain_subdir));
+       ret = lttng_strncpy(consumer->domain_subdir, dir_name, sizeof(consumer->domain_subdir));

        if (ret) {
                ret = LTTNG_ERR_UNK;
                goto error;
        if (ret) {
                ret = LTTNG_ERR_UNK;
                goto error;


@@ -483,19 +481,19 @@ error:
 /*
  * Create an UST session and add it to the session ust list.
  */
 /*
  * Create an UST session and add it to the session ust list.
  */

-static int create_ust_session(struct ltt_session *session,
-               const struct lttng_domain *domain)
+static int create_ust_session(const ltt_session::locked_ref& session,
+                             const struct lttng_domain *domain)

 {
        int ret;
 {
        int ret;

-       struct ltt_ust_session *lus = NULL;
+       struct ltt_ust_session *lus = nullptr;

 
 

-       LTTNG_ASSERT(session);

        LTTNG_ASSERT(domain);
        LTTNG_ASSERT(session->consumer);
 
        switch (domain->type) {
        case LTTNG_DOMAIN_JUL:
        case LTTNG_DOMAIN_LOG4J:
        LTTNG_ASSERT(domain);
        LTTNG_ASSERT(session->consumer);
 
        switch (domain->type) {
        case LTTNG_DOMAIN_JUL:
        case LTTNG_DOMAIN_LOG4J:

+       case LTTNG_DOMAIN_LOG4J2:

        case LTTNG_DOMAIN_PYTHON:
        case LTTNG_DOMAIN_UST:
                break;
        case LTTNG_DOMAIN_PYTHON:
        case LTTNG_DOMAIN_UST:
                break;


@@ -508,7 +506,7 @@ static int create_ust_session(struct ltt_session *session,
        DBG("Creating UST session");
 
        lus = trace_ust_create_session(session->id);
        DBG("Creating UST session");
 
        lus = trace_ust_create_session(session->id);

-       if (lus == NULL) {
+       if (lus == nullptr) {

                ret = LTTNG_ERR_UST_SESS_FAIL;
                goto error;
        }
                ret = LTTNG_ERR_UST_SESS_FAIL;
                goto error;
        }


@@ -520,14 +518,11 @@ static int create_ust_session(struct ltt_session *session,
        lus->live_timer_interval = session->live_timer;
        session->ust_session = lus;
        if (session->shm_path[0]) {
        lus->live_timer_interval = session->live_timer;
        session->ust_session = lus;
        if (session->shm_path[0]) {

-               strncpy(lus->root_shm_path, session->shm_path,
-                       sizeof(lus->root_shm_path));
+               strncpy(lus->root_shm_path, session->shm_path, sizeof(lus->root_shm_path));

                lus->root_shm_path[sizeof(lus->root_shm_path) - 1] = '\0';
                lus->root_shm_path[sizeof(lus->root_shm_path) - 1] = '\0';

-               strncpy(lus->shm_path, session->shm_path,
-                       sizeof(lus->shm_path));
+               strncpy(lus->shm_path, session->shm_path, sizeof(lus->shm_path));

                lus->shm_path[sizeof(lus->shm_path) - 1] = '\0';
                lus->shm_path[sizeof(lus->shm_path) - 1] = '\0';

-               strncat(lus->shm_path, "/ust",
-                       sizeof(lus->shm_path) - strlen(lus->shm_path) - 1);
+               strncat(lus->shm_path, "/ust", sizeof(lus->shm_path) - strlen(lus->shm_path) - 1);

        }
        /* Copy session output to the newly created UST session */
        ret = copy_session_consumer(domain->type, session);
        }
        /* Copy session output to the newly created UST session */
        ret = copy_session_consumer(domain->type, session);


@@ -539,14 +534,14 @@ static int create_ust_session(struct ltt_session *session,
 
 error:
        free(lus);
 
 error:
        free(lus);

-       session->ust_session = NULL;
+       session->ust_session = nullptr;

        return ret;
 }
 
 /*
  * Create a kernel tracer session then create the default channel.
  */
        return ret;
 }
 
 /*
  * Create a kernel tracer session then create the default channel.
  */

-static int create_kernel_session(struct ltt_session *session)
+static int create_kernel_session(const ltt_session::locked_ref& session)

 {
        int ret;
 
 {
        int ret;
 


@@ -577,7 +572,7 @@ static int create_kernel_session(struct ltt_session *session)
 
 error:
        trace_kernel_destroy_session(session->kernel_session);
 
 error:
        trace_kernel_destroy_session(session->kernel_session);

-       session->kernel_session = NULL;
+       session->kernel_session = nullptr;

 error_create:
        return ret;
 }
 error_create:
        return ret;
 }


@@ -585,114 +580,106 @@ error_create:
 /*
  * Count number of session permitted by uid/gid.
  */
 /*
  * Count number of session permitted by uid/gid.
  */

-static unsigned int lttng_sessions_count(uid_t uid,
-               gid_t gid __attribute__((unused)))
+static unsigned int lttng_sessions_count(uid_t uid, gid_t gid __attribute__((unused)))

 {
        unsigned int i = 0;
 {
        unsigned int i = 0;

-       struct ltt_session *session;

        const struct ltt_session_list *session_list = session_get_list();
 
        DBG("Counting number of available session for UID %d", uid);
        const struct ltt_session_list *session_list = session_get_list();
 
        DBG("Counting number of available session for UID %d", uid);

-       cds_list_for_each_entry(session, &session_list->head, list) {
-               if (!session_get(session)) {
-                       continue;
-               }
-               session_lock(session);
+       for (auto *raw_session_ptr :
+            lttng::urcu::list_iteration_adapter<ltt_session, &ltt_session::list>(
+                    session_list->head)) {
+               auto session = [raw_session_ptr]() {
+                       session_get(raw_session_ptr);
+                       raw_session_ptr->lock();
+                       return ltt_session::make_locked_ref(*raw_session_ptr);
+               }();
+

                /* Only count the sessions the user can control. */
                /* Only count the sessions the user can control. */

-               if (session_access_ok(session, uid) &&
-                               !session->destroyed) {
+               if (session_access_ok(session, uid) && !session->destroyed) {

                        i++;
                }
                        i++;
                }

-               session_unlock(session);
-               session_put(session);

        }
        }

+

        return i;
 }
 
        return i;
 }
 

-static enum lttng_error_code receive_lttng_trigger(struct command_ctx *cmd_ctx,
-               int sock,
-               int *sock_error,
-               struct lttng_trigger **_trigger)
+static lttng::ctl::trigger
+receive_lttng_trigger(struct command_ctx *cmd_ctx, int sock, int *sock_error)

 {
        int ret;
        size_t trigger_len;
        ssize_t sock_recv_len;
 {
        int ret;
        size_t trigger_len;
        ssize_t sock_recv_len;

-       enum lttng_error_code ret_code;

        struct lttng_payload trigger_payload;
        struct lttng_payload trigger_payload;

-       struct lttng_trigger *trigger = NULL;
+       struct lttng_trigger *trigger = nullptr;

 
        lttng_payload_init(&trigger_payload);
 
        lttng_payload_init(&trigger_payload);

+       const auto reset_payload_on_exit = lttng::make_scope_exit(
+               [&trigger_payload]() noexcept { lttng_payload_reset(&trigger_payload); });
+

        trigger_len = (size_t) cmd_ctx->lsm.u.trigger.length;
        trigger_len = (size_t) cmd_ctx->lsm.u.trigger.length;

-       ret = lttng_dynamic_buffer_set_size(
-                       &trigger_payload.buffer, trigger_len);
+       ret = lttng_dynamic_buffer_set_size(&trigger_payload.buffer, trigger_len);

        if (ret) {
        if (ret) {

-               ret_code = LTTNG_ERR_NOMEM;
-               goto end;
+               LTTNG_THROW_CTL("Failed to allocate buffer for trigger receptio", LTTNG_ERR_NOMEM);

        }
 
        }
 

-       sock_recv_len = lttcomm_recv_unix_sock(
-                       sock, trigger_payload.buffer.data, trigger_len);
+       sock_recv_len = lttcomm_recv_unix_sock(sock, trigger_payload.buffer.data, trigger_len);

        if (sock_recv_len < 0 || sock_recv_len != trigger_len) {
        if (sock_recv_len < 0 || sock_recv_len != trigger_len) {

-               ERR("Failed to receive trigger in command payload");

                *sock_error = 1;
                *sock_error = 1;

-               ret_code = LTTNG_ERR_INVALID_PROTOCOL;
-               goto end;
+               LTTNG_THROW_PROTOCOL_ERROR("Failed to receive trigger in command payload");

        }
 
        /* Receive fds, if any. */
        if (cmd_ctx->lsm.fd_count > 0) {
                sock_recv_len = lttcomm_recv_payload_fds_unix_sock(
        }
 
        /* Receive fds, if any. */
        if (cmd_ctx->lsm.fd_count > 0) {
                sock_recv_len = lttcomm_recv_payload_fds_unix_sock(

-                               sock, cmd_ctx->lsm.fd_count, &trigger_payload);
-               if (sock_recv_len > 0 &&
-                               sock_recv_len != cmd_ctx->lsm.fd_count * sizeof(int)) {
-                       ERR("Failed to receive all file descriptors for trigger in command payload: expected fd count = %u, ret = %d",
-                                       cmd_ctx->lsm.fd_count, (int) ret);
-                       ret_code = LTTNG_ERR_INVALID_PROTOCOL;
+                       sock, cmd_ctx->lsm.fd_count, &trigger_payload);
+               if (sock_recv_len > 0 && sock_recv_len != cmd_ctx->lsm.fd_count * sizeof(int)) {

                        *sock_error = 1;
                        *sock_error = 1;

-                       goto end;
+                       LTTNG_THROW_PROTOCOL_ERROR(fmt::format(
+                               "Failed to receive all file descriptors for trigger in command payload: expected_fd_count={}, ret={}",
+                               [cmd_ctx]() { return cmd_ctx->lsm.fd_count; }(),
+                               sock_recv_len));

                } else if (sock_recv_len <= 0) {
                } else if (sock_recv_len <= 0) {

-                       ERR("Failed to receive file descriptors for trigger in command payload: expected fd count = %u, ret = %d",
-                                       cmd_ctx->lsm.fd_count, (int) ret);
-                       ret_code = LTTNG_ERR_FATAL;

                        *sock_error = 1;
                        *sock_error = 1;

-                       goto end;
+                       LTTNG_THROW_PROTOCOL_ERROR(fmt::format(
+                               "Failed to receive file descriptors for trigger in command payload: expected_fd_count={}, ret={}",
+                               [cmd_ctx]() { return cmd_ctx->lsm.fd_count; }(),
+                               sock_recv_len));

                }
        }
 
        /* Deserialize trigger. */
        {
                struct lttng_payload_view view =
                }
        }
 
        /* Deserialize trigger. */
        {
                struct lttng_payload_view view =

-                               lttng_payload_view_from_payload(
-                                               &trigger_payload, 0, -1);
+                       lttng_payload_view_from_payload(&trigger_payload, 0, -1);

 
 

-               if (lttng_trigger_create_from_payload(&view, &trigger) !=
-                               trigger_len) {
-                       ERR("Invalid trigger received as part of command payload");
-                       ret_code = LTTNG_ERR_INVALID_TRIGGER;
+               const auto trigger_create_ret = lttng_trigger_create_from_payload(&view, &trigger);
+
+               if (trigger_create_ret != trigger_len) {

                        lttng_trigger_put(trigger);
                        lttng_trigger_put(trigger);

-                       goto end;
+                       LTTNG_THROW_PROTOCOL_ERROR(fmt::format(
+                               "Trigger of unexpected size received as part of command payload: expected_size={}, actual_size={}",
+                               trigger_len,
+                               trigger_create_ret));
+               } else if (trigger_create_ret < 0) {
+                       LTTNG_THROW_CTL("Failed to allocate trigger", LTTNG_ERR_NOMEM);

                }
        }
 
                }
        }
 

-       *_trigger = trigger;
-       ret_code = LTTNG_OK;
-
-end:
-       lttng_payload_reset(&trigger_payload);
-       return ret_code;
+       return lttng::ctl::trigger(trigger);

 }
 
 static enum lttng_error_code receive_lttng_error_query(struct command_ctx *cmd_ctx,
 }
 
 static enum lttng_error_code receive_lttng_error_query(struct command_ctx *cmd_ctx,

-               int sock,
-               int *sock_error,
-               struct lttng_error_query **_query)
+                                                      int sock,
+                                                      int *sock_error,
+                                                      struct lttng_error_query **_query)

 {
        int ret;
        size_t query_len;
        ssize_t sock_recv_len;
        enum lttng_error_code ret_code;
        struct lttng_payload query_payload;
 {
        int ret;
        size_t query_len;
        ssize_t sock_recv_len;
        enum lttng_error_code ret_code;
        struct lttng_payload query_payload;

-       struct lttng_error_query *query = NULL;
+       struct lttng_error_query *query = nullptr;

 
        lttng_payload_init(&query_payload);
        query_len = (size_t) cmd_ctx->lsm.u.error_query.length;
 
        lttng_payload_init(&query_payload);
        query_len = (size_t) cmd_ctx->lsm.u.error_query.length;


@@ -702,8 +689,7 @@ static enum lttng_error_code receive_lttng_error_query(struct command_ctx *cmd_c
                goto end;
        }
 
                goto end;
        }
 

-       sock_recv_len = lttcomm_recv_unix_sock(
-                       sock, query_payload.buffer.data, query_len);
+       sock_recv_len = lttcomm_recv_unix_sock(sock, query_payload.buffer.data, query_len);

        if (sock_recv_len < 0 || sock_recv_len != query_len) {
                ERR("Failed to receive error query in command payload");
                *sock_error = 1;
        if (sock_recv_len < 0 || sock_recv_len != query_len) {
                ERR("Failed to receive error query in command payload");
                *sock_error = 1;


@@ -714,17 +700,18 @@ static enum lttng_error_code receive_lttng_error_query(struct command_ctx *cmd_c
        /* Receive fds, if any. */
        if (cmd_ctx->lsm.fd_count > 0) {
                sock_recv_len = lttcomm_recv_payload_fds_unix_sock(
        /* Receive fds, if any. */
        if (cmd_ctx->lsm.fd_count > 0) {
                sock_recv_len = lttcomm_recv_payload_fds_unix_sock(

-                               sock, cmd_ctx->lsm.fd_count, &query_payload);
-               if (sock_recv_len > 0 &&
-                               sock_recv_len != cmd_ctx->lsm.fd_count * sizeof(int)) {
+                       sock, cmd_ctx->lsm.fd_count, &query_payload);
+               if (sock_recv_len > 0 && sock_recv_len != cmd_ctx->lsm.fd_count * sizeof(int)) {

                        ERR("Failed to receive all file descriptors for error query in command payload: expected fd count = %u, ret = %d",
                        ERR("Failed to receive all file descriptors for error query in command payload: expected fd count = %u, ret = %d",

-                                       cmd_ctx->lsm.fd_count, (int) ret);
+                           cmd_ctx->lsm.fd_count,
+                           (int) ret);

                        ret_code = LTTNG_ERR_INVALID_PROTOCOL;
                        *sock_error = 1;
                        goto end;
                } else if (sock_recv_len <= 0) {
                        ERR("Failed to receive file descriptors for error query in command payload: expected fd count = %u, ret = %d",
                        ret_code = LTTNG_ERR_INVALID_PROTOCOL;
                        *sock_error = 1;
                        goto end;
                } else if (sock_recv_len <= 0) {
                        ERR("Failed to receive file descriptors for error query in command payload: expected fd count = %u, ret = %d",

-                                       cmd_ctx->lsm.fd_count, (int) ret);
+                           cmd_ctx->lsm.fd_count,
+                           (int) ret);

                        ret_code = LTTNG_ERR_FATAL;
                        *sock_error = 1;
                        goto end;
                        ret_code = LTTNG_ERR_FATAL;
                        *sock_error = 1;
                        goto end;


@@ -734,11 +721,9 @@ static enum lttng_error_code receive_lttng_error_query(struct command_ctx *cmd_c
        /* Deserialize error query. */
        {
                struct lttng_payload_view view =
        /* Deserialize error query. */
        {
                struct lttng_payload_view view =

-                               lttng_payload_view_from_payload(
-                                               &query_payload, 0, -1);
+                       lttng_payload_view_from_payload(&query_payload, 0, -1);

 
 

-               if (lttng_error_query_create_from_payload(&view, &query) !=
-                               query_len) {
+               if (lttng_error_query_create_from_payload(&view, &query) != query_len) {

                        ERR("Invalid error query received as part of command payload");
                        ret_code = LTTNG_ERR_INVALID_PROTOCOL;
                        goto end;
                        ERR("Invalid error query received as part of command payload");
                        ret_code = LTTNG_ERR_INVALID_PROTOCOL;
                        goto end;


@@ -754,22 +739,22 @@ end:
 }
 
 static enum lttng_error_code receive_lttng_event(struct command_ctx *cmd_ctx,
 }
 
 static enum lttng_error_code receive_lttng_event(struct command_ctx *cmd_ctx,

-               int sock,
-               int *sock_error,
-               struct lttng_event **out_event,
-               char **out_filter_expression,
-               struct lttng_bytecode **out_bytecode,
-               struct lttng_event_exclusion **out_exclusion)
+                                                int sock,
+                                                int *sock_error,
+                                                struct lttng_event **out_event,
+                                                char **out_filter_expression,
+                                                struct lttng_bytecode **out_bytecode,
+                                                struct lttng_event_exclusion **out_exclusion)

 {
        int ret;
        size_t event_len;
        ssize_t sock_recv_len;
        enum lttng_error_code ret_code;
        struct lttng_payload event_payload;
 {
        int ret;
        size_t event_len;
        ssize_t sock_recv_len;
        enum lttng_error_code ret_code;
        struct lttng_payload event_payload;

-       struct lttng_event *local_event = NULL;
-       char *local_filter_expression = NULL;
-       struct lttng_bytecode *local_bytecode = NULL;
-       struct lttng_event_exclusion *local_exclusion = NULL;
+       struct lttng_event *local_event = nullptr;
+       char *local_filter_expression = nullptr;
+       struct lttng_bytecode *local_bytecode = nullptr;
+       struct lttng_event_exclusion *local_exclusion = nullptr;

 
        lttng_payload_init(&event_payload);
        if (cmd_ctx->lsm.cmd_type == LTTCOMM_SESSIOND_COMMAND_ENABLE_EVENT) {
 
        lttng_payload_init(&event_payload);
        if (cmd_ctx->lsm.cmd_type == LTTCOMM_SESSIOND_COMMAND_ENABLE_EVENT) {


@@ -786,8 +771,7 @@ static enum lttng_error_code receive_lttng_event(struct command_ctx *cmd_ctx,
                goto end;
        }
 
                goto end;
        }
 

-       sock_recv_len = lttcomm_recv_unix_sock(
-                       sock, event_payload.buffer.data, event_len);
+       sock_recv_len = lttcomm_recv_unix_sock(sock, event_payload.buffer.data, event_len);

        if (sock_recv_len < 0 || sock_recv_len != event_len) {
                ERR("Failed to receive event in command payload");
                *sock_error = 1;
        if (sock_recv_len < 0 || sock_recv_len != event_len) {
                ERR("Failed to receive event in command payload");
                *sock_error = 1;


@@ -798,17 +782,18 @@ static enum lttng_error_code receive_lttng_event(struct command_ctx *cmd_ctx,
        /* Receive fds, if any. */
        if (cmd_ctx->lsm.fd_count > 0) {
                sock_recv_len = lttcomm_recv_payload_fds_unix_sock(
        /* Receive fds, if any. */
        if (cmd_ctx->lsm.fd_count > 0) {
                sock_recv_len = lttcomm_recv_payload_fds_unix_sock(

-                               sock, cmd_ctx->lsm.fd_count, &event_payload);
-               if (sock_recv_len > 0 &&
-                               sock_recv_len != cmd_ctx->lsm.fd_count * sizeof(int)) {
+                       sock, cmd_ctx->lsm.fd_count, &event_payload);
+               if (sock_recv_len > 0 && sock_recv_len != cmd_ctx->lsm.fd_count * sizeof(int)) {

                        ERR("Failed to receive all file descriptors for event in command payload: expected fd count = %u, ret = %d",
                        ERR("Failed to receive all file descriptors for event in command payload: expected fd count = %u, ret = %d",

-                                       cmd_ctx->lsm.fd_count, (int) ret);
+                           cmd_ctx->lsm.fd_count,
+                           (int) ret);

                        ret_code = LTTNG_ERR_INVALID_PROTOCOL;
                        *sock_error = 1;
                        goto end;
                } else if (sock_recv_len <= 0) {
                        ERR("Failed to receive file descriptors for event in command payload: expected fd count = %u, ret = %d",
                        ret_code = LTTNG_ERR_INVALID_PROTOCOL;
                        *sock_error = 1;
                        goto end;
                } else if (sock_recv_len <= 0) {
                        ERR("Failed to receive file descriptors for event in command payload: expected fd count = %u, ret = %d",

-                                       cmd_ctx->lsm.fd_count, (int) ret);
+                           cmd_ctx->lsm.fd_count,
+                           (int) ret);

                        ret_code = LTTNG_ERR_FATAL;
                        *sock_error = 1;
                        goto end;
                        ret_code = LTTNG_ERR_FATAL;
                        *sock_error = 1;
                        goto end;


@@ -819,12 +804,13 @@ static enum lttng_error_code receive_lttng_event(struct command_ctx *cmd_ctx,
        {
                ssize_t len;
                struct lttng_payload_view event_view =
        {
                ssize_t len;
                struct lttng_payload_view event_view =

-                               lttng_payload_view_from_payload(
-                                               &event_payload, 0, -1);
+                       lttng_payload_view_from_payload(&event_payload, 0, -1);

 
 

-               len = lttng_event_create_from_payload(&event_view, &local_event,
-                                   &local_exclusion, &local_filter_expression,
-                                   &local_bytecode);
+               len = lttng_event_create_from_payload(&event_view,
+                                                     &local_event,
+                                                     &local_exclusion,
+                                                     &local_filter_expression,
+                                                     &local_bytecode);

 
                if (len < 0) {
                        ERR("Failed to create an event from the received buffer");
 
                if (len < 0) {
                        ERR("Failed to create an event from the received buffer");


@@ -833,7 +819,10 @@ static enum lttng_error_code receive_lttng_event(struct command_ctx *cmd_ctx,
                }
 
                if (len != event_len) {
                }
 
                if (len != event_len) {

-                       ERR("Userspace probe location from the received buffer is not the advertised length: header length = %zu" PRIu32 ", payload length = %zd", event_len, len);
+                       ERR("Userspace probe location from the received buffer is not the advertised length: header length = %zu" PRIu32
+                           ", payload length = %zd",
+                           event_len,
+                           len);

                        ret_code = LTTNG_ERR_INVALID_PROTOCOL;
                        goto end;
                }
                        ret_code = LTTNG_ERR_INVALID_PROTOCOL;
                        goto end;
                }


@@ -843,10 +832,10 @@ static enum lttng_error_code receive_lttng_event(struct command_ctx *cmd_ctx,
        *out_exclusion = local_exclusion;
        *out_filter_expression = local_filter_expression;
        *out_bytecode = local_bytecode;
        *out_exclusion = local_exclusion;
        *out_filter_expression = local_filter_expression;
        *out_bytecode = local_bytecode;

-       local_event = NULL;
-       local_exclusion = NULL;
-       local_filter_expression = NULL;
-       local_bytecode = NULL;
+       local_event = nullptr;
+       local_exclusion = nullptr;
+       local_filter_expression = nullptr;
+       local_bytecode = nullptr;

 
        ret_code = LTTNG_OK;
 
 
        ret_code = LTTNG_OK;
 


@@ -859,32 +848,29 @@ end:
        return ret_code;
 }
 
        return ret_code;
 }
 

-static enum lttng_error_code receive_lttng_event_context(
-               const struct command_ctx *cmd_ctx,
-               int sock,
-               int *sock_error,
-               struct lttng_event_context **out_event_context)
+static enum lttng_error_code
+receive_lttng_event_context(const struct command_ctx *cmd_ctx,
+                           int sock,
+                           int *sock_error,
+                           struct lttng_event_context **out_event_context)

 {
        int ret;
 {
        int ret;

-       const size_t event_context_len =
-                       (size_t) cmd_ctx->lsm.u.context.length;
+       const size_t event_context_len = (size_t) cmd_ctx->lsm.u.context.length;

        ssize_t sock_recv_len;
        enum lttng_error_code ret_code;
        struct lttng_payload event_context_payload;
        ssize_t sock_recv_len;
        enum lttng_error_code ret_code;
        struct lttng_payload event_context_payload;

-       struct lttng_event_context *context = NULL;
+       struct lttng_event_context *context = nullptr;

 
        lttng_payload_init(&event_context_payload);
 
 
        lttng_payload_init(&event_context_payload);
 

-       ret = lttng_dynamic_buffer_set_size(&event_context_payload.buffer,
-                       event_context_len);
+       ret = lttng_dynamic_buffer_set_size(&event_context_payload.buffer, event_context_len);

        if (ret) {
                ret_code = LTTNG_ERR_NOMEM;
                goto end;
        }
 
        if (ret) {
                ret_code = LTTNG_ERR_NOMEM;
                goto end;
        }
 

-       sock_recv_len = lttcomm_recv_unix_sock(
-                       sock, event_context_payload.buffer.data,
-                       event_context_len);
+       sock_recv_len =
+               lttcomm_recv_unix_sock(sock, event_context_payload.buffer.data, event_context_len);

        if (sock_recv_len < 0 || sock_recv_len != event_context_len) {
                ERR("Failed to receive event context in command payload");
                *sock_error = 1;
        if (sock_recv_len < 0 || sock_recv_len != event_context_len) {
                ERR("Failed to receive event context in command payload");
                *sock_error = 1;


@@ -896,11 +882,9 @@ static enum lttng_error_code receive_lttng_event_context(
        {
                ssize_t len;
                struct lttng_payload_view event_context_view =
        {
                ssize_t len;
                struct lttng_payload_view event_context_view =

-                               lttng_payload_view_from_payload(
-                                               &event_context_payload, 0, -1);
+                       lttng_payload_view_from_payload(&event_context_payload, 0, -1);

 
 

-               len = lttng_event_context_create_from_payload(
-                               &event_context_view, &context);
+               len = lttng_event_context_create_from_payload(&event_context_view, &context);

 
                if (len < 0) {
                        ERR("Failed to create a event context from the received buffer");
 
                if (len < 0) {
                        ERR("Failed to create a event context from the received buffer");


@@ -909,14 +893,16 @@ static enum lttng_error_code receive_lttng_event_context(
                }
 
                if (len != event_context_len) {
                }
 
                if (len != event_context_len) {

-                       ERR("Event context from the received buffer is not the advertised length: expected length = %zu, payload length = %zd", event_context_len, len);
+                       ERR("Event context from the received buffer is not the advertised length: expected length = %zu, payload length = %zd",
+                           event_context_len,
+                           len);

                        ret_code = LTTNG_ERR_INVALID_PROTOCOL;
                        goto end;
                }
        }
 
        *out_event_context = context;
                        ret_code = LTTNG_ERR_INVALID_PROTOCOL;
                        goto end;
                }
        }
 
        *out_event_context = context;

-       context = NULL;
+       context = nullptr;

        ret_code = LTTNG_OK;
 
 end:
        ret_code = LTTNG_OK;
 
 end:


@@ -928,22 +914,21 @@ end:
 /*
  * Version of setup_lttng_msg() without command header.
  */
 /*
  * Version of setup_lttng_msg() without command header.
  */

-static int setup_lttng_msg_no_cmd_header(struct command_ctx *cmd_ctx,
-       void *payload_buf, size_t payload_len)
+static void
+setup_lttng_msg_no_cmd_header(struct command_ctx *cmd_ctx, void *payload_buf, size_t payload_len)

 {
 {

-       return setup_lttng_msg(cmd_ctx, payload_buf, payload_len, NULL, 0);
+       setup_lttng_msg(cmd_ctx, payload_buf, payload_len, nullptr, 0);

 }
 
 /*
  * Check if the current kernel tracer supports the session rotation feature.
  * Return 1 if it does, 0 otherwise.
  */
 }
 
 /*
  * Check if the current kernel tracer supports the session rotation feature.
  * Return 1 if it does, 0 otherwise.
  */

-static int check_rotate_compatible(void)
+static int check_rotate_compatible()

 {
        int ret = 1;
 
 {
        int ret = 1;
 

-       if (the_kernel_tracer_version.major != 2 ||
-                       the_kernel_tracer_version.minor < 11) {
+       if (the_kernel_tracer_version.major != 2 || the_kernel_tracer_version.minor < 11) {

                DBG("Kernel tracer version is not compatible with the rotation feature");
                ret = 0;
        }
                DBG("Kernel tracer version is not compatible with the rotation feature");
                ret = 0;
        }


@@ -967,8 +952,7 @@ static int send_unix_sock(int sock, struct lttng_payload_view *view)
                goto end;
        }
 
                goto end;
        }
 

-       ret = lttcomm_send_unix_sock(
-                       sock, view->buffer.data, view->buffer.size);
+       ret = lttcomm_send_unix_sock(sock, view->buffer.data, view->buffer.size);

        if (ret < 0) {
                goto end;
        }
        if (ret < 0) {
                goto end;
        }


@@ -984,6 +968,12 @@ end:
        return ret;
 }
 
        return ret;
 }
 

+static void command_ctx_set_status_code(command_ctx& cmd_ctx, enum lttng_error_code status_code)
+{
+       LTTNG_ASSERT(cmd_ctx.reply_payload.buffer.size >= sizeof(lttcomm_lttng_msg));
+       ((struct lttcomm_lttng_msg *) (cmd_ctx.reply_payload.buffer.data))->ret_code = status_code;
+}
+

 /*
  * Process the command requested by the lttng client within the command
  * context structure. This function make sure that the return structure (llm)
 /*
  * Process the command requested by the lttng client within the command
  * context structure. This function make sure that the return structure (llm)


@@ -995,8 +985,7 @@ end:
  * A command may assume the ownership of the socket, in which case its value
  * should be set to -1.
  */
  * A command may assume the ownership of the socket, in which case its value
  * should be set to -1.
  */

-static int process_client_msg(struct command_ctx *cmd_ctx, int *sock,
-               int *sock_error)
+static int process_client_msg(struct command_ctx *cmd_ctx, int *sock, int *sock_error)

 {
        int ret = LTTNG_OK;
        bool need_tracing_session = true;
 {
        int ret = LTTNG_OK;
        bool need_tracing_session = true;


@@ -1004,15 +993,15 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock,
        bool need_consumerd;
 
        if (!lttcomm_sessiond_command_is_valid((lttcomm_sessiond_command) cmd_ctx->lsm.cmd_type)) {
        bool need_consumerd;
 
        if (!lttcomm_sessiond_command_is_valid((lttcomm_sessiond_command) cmd_ctx->lsm.cmd_type)) {

-               ERR("Unknown client command received: command id = %" PRIu32,
-                               cmd_ctx->lsm.cmd_type);
-               ret = LTTNG_ERR_UND;
-               goto error;
+               /* The lambda is used since fmt can't bind a packed field. */
+               LTTNG_THROW_CTL(fmt::format("Unknown client command: command_id={}",
+                                           [&cmd_ctx]() { return cmd_ctx->lsm.cmd_type; }()),
+                               LTTNG_ERR_UND);

        }
 
        }
 

-       DBG("Processing client command '%s\' (%d)",
+       DBG_FMT("Processing client command: name=`{}`, id={}",

                lttcomm_sessiond_command_str((lttcomm_sessiond_command) cmd_ctx->lsm.cmd_type),
                lttcomm_sessiond_command_str((lttcomm_sessiond_command) cmd_ctx->lsm.cmd_type),

-               cmd_ctx->lsm.cmd_type);
+               [&cmd_ctx]() { return cmd_ctx->lsm.cmd_type; }());

 
        *sock_error = 0;
 
 
        *sock_error = 0;
 


@@ -1039,6 +1028,7 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock,
        case LTTCOMM_SESSIOND_COMMAND_CLEAR_SESSION:
        case LTTCOMM_SESSIOND_COMMAND_LIST_TRIGGERS:
        case LTTCOMM_SESSIOND_COMMAND_EXECUTE_ERROR_QUERY:
        case LTTCOMM_SESSIOND_COMMAND_CLEAR_SESSION:
        case LTTCOMM_SESSIOND_COMMAND_LIST_TRIGGERS:
        case LTTCOMM_SESSIOND_COMMAND_EXECUTE_ERROR_QUERY:

+       case LTTCOMM_SESSIOND_COMMAND_KERNEL_TRACER_STATUS:

                need_domain = false;
                break;
        default:
                need_domain = false;
                break;
        default:


@@ -1058,24 +1048,27 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock,
        }
 
        if (the_config.no_kernel && need_domain &&
        }
 
        if (the_config.no_kernel && need_domain &&

-                       cmd_ctx->lsm.domain.type == LTTNG_DOMAIN_KERNEL) {
+           cmd_ctx->lsm.domain.type == LTTNG_DOMAIN_KERNEL) {

                if (!is_root) {
                if (!is_root) {

-                       ret = LTTNG_ERR_NEED_ROOT_SESSIOND;
+                       LTTNG_THROW_CTL(
+                               "Can't run a kernel-domain command since the session daemon is not running as root",
+                               LTTNG_ERR_NEED_ROOT_SESSIOND);

                } else {
                } else {

-                       ret = LTTNG_ERR_KERN_NA;
+                       LTTNG_THROW_CTL(
+                               "Can't run a kernel-domain command since kernel tracing is disabled",
+                               LTTNG_ERR_KERN_NA);

                }
                }

-               goto error;

        }
 
        /* Deny register consumer if we already have a spawned consumer. */
        if (cmd_ctx->lsm.cmd_type == LTTCOMM_SESSIOND_COMMAND_REGISTER_CONSUMER) {
        }
 
        /* Deny register consumer if we already have a spawned consumer. */
        if (cmd_ctx->lsm.cmd_type == LTTCOMM_SESSIOND_COMMAND_REGISTER_CONSUMER) {

-               pthread_mutex_lock(&the_kconsumer_data.pid_mutex);
+               const lttng::pthread::lock_guard kconsumer_lock(the_kconsumer_data.pid_mutex);
+

                if (the_kconsumer_data.pid > 0) {
                if (the_kconsumer_data.pid > 0) {

-                       ret = LTTNG_ERR_KERN_CONSUMER_FAIL;
-                       pthread_mutex_unlock(&the_kconsumer_data.pid_mutex);
-                       goto error;
+                       LTTNG_THROW_CTL(
+                               "Can't register a consumer since a kernel-domain consumer was already launched",
+                               LTTNG_ERR_KERN_CONSUMER_FAIL);

                }
                }

-               pthread_mutex_unlock(&the_kconsumer_data.pid_mutex);

        }
 
        /*
        }
 
        /*


@@ -1083,7 +1076,7 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock,
         * this here so we don't have to make the call for no payload at each
         * command.
         */
         * this here so we don't have to make the call for no payload at each
         * command.
         */

-       switch(cmd_ctx->lsm.cmd_type) {
+       switch (cmd_ctx->lsm.cmd_type) {

        case LTTCOMM_SESSIOND_COMMAND_LIST_SESSIONS:
        case LTTCOMM_SESSIOND_COMMAND_LIST_TRACEPOINTS:
        case LTTCOMM_SESSIOND_COMMAND_LIST_TRACEPOINT_FIELDS:
        case LTTCOMM_SESSIOND_COMMAND_LIST_SESSIONS:
        case LTTCOMM_SESSIOND_COMMAND_LIST_TRACEPOINTS:
        case LTTCOMM_SESSIOND_COMMAND_LIST_TRACEPOINT_FIELDS:


@@ -1103,13 +1096,29 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock,
                break;
        default:
                /* Setup lttng message with no payload */
                break;
        default:
                /* Setup lttng message with no payload */

-               ret = setup_lttng_msg_no_cmd_header(cmd_ctx, NULL, 0);
-               if (ret < 0) {
-                       /* This label does not try to unlock the session */
-                       goto init_setup_error;
-               }
+               setup_lttng_msg_no_cmd_header(cmd_ctx, nullptr, 0);

        }
 
        }
 

+       /*
+        * The list lock is only acquired when processing a command that is applied
+        * against a session. As such, a unique_lock that holds the list lock is move()'d to
+        * list_lock during the execution of those commands. The list lock is then released
+        * as the instance leaves this scope.
+        *
+        * Mind the order of the declaration of list_lock vs target_session:
+        * the session list lock must always be released _after_ the release of
+        * a session's reference (the destruction of a ref/locked_ref) to ensure
+        * since the reference's release may unpublish the session from the list of
+        * sessions.
+        */
+       std::unique_lock<std::mutex> list_lock;
+       /*
+        * A locked_ref is typically "never null" (hence its name). However, due to the
+        * structure of this function, target_session remains unset for commands that don't
+        * have a target session.
+        */
+       nonstd::optional<ltt_session::locked_ref> target_session;
+

        /* Commands that DO NOT need a session. */
        switch (cmd_ctx->lsm.cmd_type) {
        case LTTCOMM_SESSIOND_COMMAND_CREATE_SESSION_EXT:
        /* Commands that DO NOT need a session. */
        switch (cmd_ctx->lsm.cmd_type) {
        case LTTCOMM_SESSIOND_COMMAND_CREATE_SESSION_EXT:


@@ -1122,24 +1131,37 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock,
        case LTTCOMM_SESSIOND_COMMAND_UNREGISTER_TRIGGER:
        case LTTCOMM_SESSIOND_COMMAND_LIST_TRIGGERS:
        case LTTCOMM_SESSIOND_COMMAND_EXECUTE_ERROR_QUERY:
        case LTTCOMM_SESSIOND_COMMAND_UNREGISTER_TRIGGER:
        case LTTCOMM_SESSIOND_COMMAND_LIST_TRIGGERS:
        case LTTCOMM_SESSIOND_COMMAND_EXECUTE_ERROR_QUERY:

+       case LTTCOMM_SESSIOND_COMMAND_KERNEL_TRACER_STATUS:

                need_tracing_session = false;
                break;
        default:
                need_tracing_session = false;
                break;
        default:

+               if (strnlen(cmd_ctx->lsm.session.name, sizeof(cmd_ctx->lsm.session.name)) ==
+                   sizeof(cmd_ctx->lsm.session.name)) {
+                       LTTNG_THROW_INVALID_ARGUMENT_ERROR(
+                               "Session name received from lttng-ctl client is not null-terminated");
+               }
+

                DBG("Getting session %s by name", cmd_ctx->lsm.session.name);
                /*
                 * We keep the session list lock across _all_ commands
                 * for now, because the per-session lock does not
                 * handle teardown properly.
                 */
                DBG("Getting session %s by name", cmd_ctx->lsm.session.name);
                /*
                 * We keep the session list lock across _all_ commands
                 * for now, because the per-session lock does not
                 * handle teardown properly.
                 */

-               session_lock_list();
-               cmd_ctx->session = session_find_by_name(cmd_ctx->lsm.session.name);
-               if (cmd_ctx->session == NULL) {
-                       ret = LTTNG_ERR_SESS_NOT_FOUND;
-                       goto error;
-               } else {
-                       /* Acquire lock for the session */
-                       session_lock(cmd_ctx->session);
-               }
+               list_lock = lttng::sessiond::lock_session_list();
+               try {
+                       target_session.emplace(
+                               ltt_session::find_locked_session(cmd_ctx->lsm.session.name));
+               } catch (...) {
+                       std::throw_with_nested(lttng::ctl::error(
+                               fmt::format(
+                                       "Target session of command doesn't exist: command='{}'",
+                                       lttcomm_sessiond_command_str(
+                                               (lttcomm_sessiond_command) cmd_ctx->lsm.cmd_type)),
+                               LTTNG_ERR_SESS_NOT_FOUND,
+                               LTTNG_SOURCE_LOCATION()));
+               }
+
+               LTTNG_ASSERT(target_session);

                break;
        }
 
                break;
        }
 


@@ -1154,17 +1176,17 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock,
        case LTTCOMM_SESSIOND_COMMAND_DISABLE_EVENT:
                switch (cmd_ctx->lsm.domain.type) {
                case LTTNG_DOMAIN_KERNEL:
        case LTTCOMM_SESSIOND_COMMAND_DISABLE_EVENT:
                switch (cmd_ctx->lsm.domain.type) {
                case LTTNG_DOMAIN_KERNEL:

-                       if (!cmd_ctx->session->kernel_session) {
-                               ret = LTTNG_ERR_NO_CHANNEL;
-                               goto error;
+                       if (!(*target_session)->kernel_session) {
+                               return LTTNG_ERR_NO_CHANNEL;

                        }
                        break;
                case LTTNG_DOMAIN_JUL:
                case LTTNG_DOMAIN_LOG4J:
                        }
                        break;
                case LTTNG_DOMAIN_JUL:
                case LTTNG_DOMAIN_LOG4J:

+               case LTTNG_DOMAIN_LOG4J2:

                case LTTNG_DOMAIN_PYTHON:
                case LTTNG_DOMAIN_UST:
                case LTTNG_DOMAIN_PYTHON:
                case LTTNG_DOMAIN_UST:

-                       if (!cmd_ctx->session->ust_session) {
-                               ret = LTTNG_ERR_NO_CHANNEL;
+                       if (!(*target_session)->ust_session) {
+                               return LTTNG_ERR_NO_CHANNEL;

                                goto error;
                        }
                        break;
                                goto error;
                        }
                        break;


@@ -1200,16 +1222,15 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock,
                }
 
                /* Consumer is in an ERROR state. Report back to client */
                }
 
                /* Consumer is in an ERROR state. Report back to client */

-               if (need_consumerd && uatomic_read(&the_kernel_consumerd_state) ==
-                                               CONSUMER_ERROR) {
+               if (need_consumerd && uatomic_read(&the_kernel_consumerd_state) == CONSUMER_ERROR) {

                        ret = LTTNG_ERR_NO_KERNCONSUMERD;
                        goto error;
                }
 
                /* Need a session for kernel command */
                if (need_tracing_session) {
                        ret = LTTNG_ERR_NO_KERNCONSUMERD;
                        goto error;
                }
 
                /* Need a session for kernel command */
                if (need_tracing_session) {

-                       if (cmd_ctx->session->kernel_session == NULL) {
-                               ret = create_kernel_session(cmd_ctx->session);
+                       if ((*target_session)->kernel_session == nullptr) {
+                               ret = create_kernel_session(*target_session);

                                if (ret != LTTNG_OK) {
                                        ret = LTTNG_ERR_KERN_SESS_FAIL;
                                        goto error;
                                if (ret != LTTNG_OK) {
                                        ret = LTTNG_ERR_KERN_SESS_FAIL;
                                        goto error;


@@ -1219,7 +1240,7 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock,
                        /* Start the kernel consumer daemon */
                        pthread_mutex_lock(&the_kconsumer_data.pid_mutex);
                        if (the_kconsumer_data.pid == 0 &&
                        /* Start the kernel consumer daemon */
                        pthread_mutex_lock(&the_kconsumer_data.pid_mutex);
                        if (the_kconsumer_data.pid == 0 &&

-                                       cmd_ctx->lsm.cmd_type != LTTCOMM_SESSIOND_COMMAND_REGISTER_CONSUMER) {
+                           cmd_ctx->lsm.cmd_type != LTTCOMM_SESSIOND_COMMAND_REGISTER_CONSUMER) {

                                pthread_mutex_unlock(&the_kconsumer_data.pid_mutex);
                                ret = start_consumerd(&the_kconsumer_data);
                                if (ret < 0) {
                                pthread_mutex_unlock(&the_kconsumer_data.pid_mutex);
                                ret = start_consumerd(&the_kconsumer_data);
                                if (ret < 0) {


@@ -1236,7 +1257,7 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock,
                         * the consumer output of the session if exist.
                         */
                        ret = consumer_create_socket(&the_kconsumer_data,
                         * the consumer output of the session if exist.
                         */
                        ret = consumer_create_socket(&the_kconsumer_data,

-                                       cmd_ctx->session->kernel_session->consumer);
+                                                    (*target_session)->kernel_session->consumer);

                        if (ret < 0) {
                                goto error;
                        }
                        if (ret < 0) {
                                goto error;
                        }


@@ -1245,6 +1266,7 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock,
                break;
        case LTTNG_DOMAIN_JUL:
        case LTTNG_DOMAIN_LOG4J:
                break;
        case LTTNG_DOMAIN_JUL:
        case LTTNG_DOMAIN_LOG4J:

+       case LTTNG_DOMAIN_LOG4J2:

        case LTTNG_DOMAIN_PYTHON:
                if (!agent_tracing_is_enabled()) {
                        ret = LTTNG_ERR_AGENT_TRACING_DISABLED;
        case LTTNG_DOMAIN_PYTHON:
                if (!agent_tracing_is_enabled()) {
                        ret = LTTNG_ERR_AGENT_TRACING_DISABLED;


@@ -1259,18 +1281,16 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock,
                }
 
                /* Consumer is in an ERROR state. Report back to client */
                }
 
                /* Consumer is in an ERROR state. Report back to client */

-               if (need_consumerd &&
-                               uatomic_read(&the_ust_consumerd_state) ==
-                                               CONSUMER_ERROR) {
+               if (need_consumerd && uatomic_read(&the_ust_consumerd_state) == CONSUMER_ERROR) {

                        ret = LTTNG_ERR_NO_USTCONSUMERD;
                        goto error;
                }
 
                if (need_tracing_session) {
                        /* Create UST session if none exist. */
                        ret = LTTNG_ERR_NO_USTCONSUMERD;
                        goto error;
                }
 
                if (need_tracing_session) {
                        /* Create UST session if none exist. */

-                       if (cmd_ctx->session->ust_session == NULL) {
-                               lttng_domain domain = cmd_ctx->lsm.domain;
-                               ret = create_ust_session(cmd_ctx->session, &domain);
+                       if ((*target_session)->ust_session == nullptr) {
+                               const lttng_domain domain = cmd_ctx->lsm.domain;
+                               ret = create_ust_session(*target_session, &domain);

                                if (ret != LTTNG_OK) {
                                        goto error;
                                }
                                if (ret != LTTNG_OK) {
                                        goto error;
                                }


@@ -1280,8 +1300,8 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock,
                        /* 64-bit */
                        pthread_mutex_lock(&the_ustconsumer64_data.pid_mutex);
                        if (the_config.consumerd64_bin_path.value &&
                        /* 64-bit */
                        pthread_mutex_lock(&the_ustconsumer64_data.pid_mutex);
                        if (the_config.consumerd64_bin_path.value &&

-                                       the_ustconsumer64_data.pid == 0 &&
-                                       cmd_ctx->lsm.cmd_type != LTTCOMM_SESSIOND_COMMAND_REGISTER_CONSUMER) {
+                           the_ustconsumer64_data.pid == 0 &&
+                           cmd_ctx->lsm.cmd_type != LTTCOMM_SESSIOND_COMMAND_REGISTER_CONSUMER) {

                                pthread_mutex_unlock(&the_ustconsumer64_data.pid_mutex);
                                ret = start_consumerd(&the_ustconsumer64_data);
                                if (ret < 0) {
                                pthread_mutex_unlock(&the_ustconsumer64_data.pid_mutex);
                                ret = start_consumerd(&the_ustconsumer64_data);
                                if (ret < 0) {


@@ -1290,7 +1310,8 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock,
                                        goto error;
                                }
 
                                        goto error;
                                }
 

-                               uatomic_set(&the_ust_consumerd64_fd, the_ustconsumer64_data.cmd_sock);
+                               uatomic_set(&the_ust_consumerd64_fd,
+                                           the_ustconsumer64_data.cmd_sock);

                                uatomic_set(&the_ust_consumerd_state, CONSUMER_STARTED);
                        } else {
                                pthread_mutex_unlock(&the_ustconsumer64_data.pid_mutex);
                                uatomic_set(&the_ust_consumerd_state, CONSUMER_STARTED);
                        } else {
                                pthread_mutex_unlock(&the_ustconsumer64_data.pid_mutex);


@@ -1301,7 +1322,7 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock,
                         * since it was set above and can ONLY be set in this thread.
                         */
                        ret = consumer_create_socket(&the_ustconsumer64_data,
                         * since it was set above and can ONLY be set in this thread.
                         */
                        ret = consumer_create_socket(&the_ustconsumer64_data,

-                                       cmd_ctx->session->ust_session->consumer);
+                                                    (*target_session)->ust_session->consumer);

                        if (ret < 0) {
                                goto error;
                        }
                        if (ret < 0) {
                                goto error;
                        }


@@ -1309,8 +1330,8 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock,
                        /* 32-bit */
                        pthread_mutex_lock(&the_ustconsumer32_data.pid_mutex);
                        if (the_config.consumerd32_bin_path.value &&
                        /* 32-bit */
                        pthread_mutex_lock(&the_ustconsumer32_data.pid_mutex);
                        if (the_config.consumerd32_bin_path.value &&

-                                       the_ustconsumer32_data.pid == 0 &&
-                                       cmd_ctx->lsm.cmd_type != LTTCOMM_SESSIOND_COMMAND_REGISTER_CONSUMER) {
+                           the_ustconsumer32_data.pid == 0 &&
+                           cmd_ctx->lsm.cmd_type != LTTCOMM_SESSIOND_COMMAND_REGISTER_CONSUMER) {

                                pthread_mutex_unlock(&the_ustconsumer32_data.pid_mutex);
                                ret = start_consumerd(&the_ustconsumer32_data);
                                if (ret < 0) {
                                pthread_mutex_unlock(&the_ustconsumer32_data.pid_mutex);
                                ret = start_consumerd(&the_ustconsumer32_data);
                                if (ret < 0) {


@@ -1319,7 +1340,8 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock,
                                        goto error;
                                }
 
                                        goto error;
                                }
 

-                               uatomic_set(&the_ust_consumerd32_fd, the_ustconsumer32_data.cmd_sock);
+                               uatomic_set(&the_ust_consumerd32_fd,
+                                           the_ustconsumer32_data.cmd_sock);

                                uatomic_set(&the_ust_consumerd_state, CONSUMER_STARTED);
                        } else {
                                pthread_mutex_unlock(&the_ustconsumer32_data.pid_mutex);
                                uatomic_set(&the_ust_consumerd_state, CONSUMER_STARTED);
                        } else {
                                pthread_mutex_unlock(&the_ustconsumer32_data.pid_mutex);


@@ -1330,7 +1352,7 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock,
                         * since it was set above and can ONLY be set in this thread.
                         */
                        ret = consumer_create_socket(&the_ustconsumer32_data,
                         * since it was set above and can ONLY be set in this thread.
                         */
                        ret = consumer_create_socket(&the_ustconsumer32_data,

-                                       cmd_ctx->session->ust_session->consumer);
+                                                    (*target_session)->ust_session->consumer);

                        if (ret < 0) {
                                goto error;
                        }
                        if (ret < 0) {
                                goto error;
                        }


@@ -1344,12 +1366,13 @@ skip_domain:
 
        /* Validate consumer daemon state when start/stop trace command */
        if (cmd_ctx->lsm.cmd_type == LTTCOMM_SESSIOND_COMMAND_START_TRACE ||
 
        /* Validate consumer daemon state when start/stop trace command */
        if (cmd_ctx->lsm.cmd_type == LTTCOMM_SESSIOND_COMMAND_START_TRACE ||

-                       cmd_ctx->lsm.cmd_type == LTTCOMM_SESSIOND_COMMAND_STOP_TRACE) {
+           cmd_ctx->lsm.cmd_type == LTTCOMM_SESSIOND_COMMAND_STOP_TRACE) {

                switch (cmd_ctx->lsm.domain.type) {
                case LTTNG_DOMAIN_NONE:
                        break;
                case LTTNG_DOMAIN_JUL:
                case LTTNG_DOMAIN_LOG4J:
                switch (cmd_ctx->lsm.domain.type) {
                case LTTNG_DOMAIN_NONE:
                        break;
                case LTTNG_DOMAIN_JUL:
                case LTTNG_DOMAIN_LOG4J:

+               case LTTNG_DOMAIN_LOG4J2:

                case LTTNG_DOMAIN_PYTHON:
                case LTTNG_DOMAIN_UST:
                        if (uatomic_read(&the_ust_consumerd_state) != CONSUMER_STARTED) {
                case LTTNG_DOMAIN_PYTHON:
                case LTTNG_DOMAIN_UST:
                        if (uatomic_read(&the_ust_consumerd_state) != CONSUMER_STARTED) {


@@ -1374,9 +1397,8 @@ skip_domain:
         * The root user can interact with all sessions.
         */
        if (need_tracing_session) {
         * The root user can interact with all sessions.
         */
        if (need_tracing_session) {

-               if (!session_access_ok(cmd_ctx->session,
-                               LTTNG_SOCK_GET_UID_CRED(&cmd_ctx->creds)) ||
-                               cmd_ctx->session->destroyed) {
+               if (!session_access_ok(*target_session, LTTNG_SOCK_GET_UID_CRED(&cmd_ctx->creds)) ||
+                   (*target_session)->destroyed) {

                        ret = LTTNG_ERR_EPERM;
                        goto error;
                }
                        ret = LTTNG_ERR_EPERM;
                        goto error;
                }


@@ -1386,12 +1408,12 @@ skip_domain:
         * Send relayd information to consumer as soon as we have a domain and a
         * session defined.
         */
         * Send relayd information to consumer as soon as we have a domain and a
         * session defined.
         */

-       if (cmd_ctx->session && need_domain) {
+       if (target_session && need_domain) {

                /*
                 * Setup relayd if not done yet. If the relayd information was already
                 * sent to the consumer, this call will gracefully return.
                 */
                /*
                 * Setup relayd if not done yet. If the relayd information was already
                 * sent to the consumer, this call will gracefully return.
                 */

-               ret = cmd_setup_relayd(cmd_ctx->session);
+               ret = cmd_setup_relayd(*target_session);

                if (ret != LTTNG_OK) {
                        goto error;
                }
                if (ret != LTTNG_OK) {
                        goto error;
                }


@@ -1401,30 +1423,30 @@ skip_domain:
        switch (cmd_ctx->lsm.cmd_type) {
        case LTTCOMM_SESSIOND_COMMAND_ADD_CONTEXT:
        {
        switch (cmd_ctx->lsm.cmd_type) {
        case LTTCOMM_SESSIOND_COMMAND_ADD_CONTEXT:
        {

-               struct lttng_event_context *event_context = NULL;
+               struct lttng_event_context *event_context = nullptr;

                const enum lttng_error_code ret_code =
                const enum lttng_error_code ret_code =

-                       receive_lttng_event_context(
-                               cmd_ctx, *sock, sock_error, &event_context);
+                       receive_lttng_event_context(cmd_ctx, *sock, sock_error, &event_context);

 
                if (ret_code != LTTNG_OK) {
                        ret = (int) ret_code;
                        goto error;
                }
 
 
                if (ret_code != LTTNG_OK) {
                        ret = (int) ret_code;
                        goto error;
                }
 

-               ret = cmd_add_context(cmd_ctx, event_context, the_kernel_poll_pipe[1]);
+               ret = cmd_add_context(
+                       cmd_ctx, *target_session, event_context, the_kernel_poll_pipe[1]);

                lttng_event_context_destroy(event_context);
                break;
        }
        case LTTCOMM_SESSIOND_COMMAND_DISABLE_CHANNEL:
        {
                lttng_event_context_destroy(event_context);
                break;
        }
        case LTTCOMM_SESSIOND_COMMAND_DISABLE_CHANNEL:
        {

-               ret = cmd_disable_channel(cmd_ctx->session, cmd_ctx->lsm.domain.type,
-                               cmd_ctx->lsm.u.disable.channel_name);
+               ret = cmd_disable_channel(*target_session,
+                                         cmd_ctx->lsm.domain.type,
+                                         cmd_ctx->lsm.u.disable.channel_name);

                break;
        }
        case LTTCOMM_SESSIOND_COMMAND_ENABLE_CHANNEL:
        {
                break;
        }
        case LTTCOMM_SESSIOND_COMMAND_ENABLE_CHANNEL:
        {

-               ret = cmd_enable_channel(
-                               cmd_ctx, *sock, the_kernel_poll_pipe[1]);
+               ret = cmd_enable_channel(cmd_ctx, *target_session, *sock, the_kernel_poll_pipe[1]);

                break;
        }
        case LTTCOMM_SESSIOND_COMMAND_PROCESS_ATTR_TRACKER_ADD_INCLUDE_VALUE:
                break;
        }
        case LTTCOMM_SESSIOND_COMMAND_PROCESS_ATTR_TRACKER_ADD_INCLUDE_VALUE:


@@ -1432,24 +1454,18 @@ skip_domain:
        {
                struct lttng_dynamic_buffer payload;
                struct lttng_buffer_view payload_view;
        {
                struct lttng_dynamic_buffer payload;
                struct lttng_buffer_view payload_view;

-               const bool add_value =
-                               cmd_ctx->lsm.cmd_type ==
-                               LTTCOMM_SESSIOND_COMMAND_PROCESS_ATTR_TRACKER_ADD_INCLUDE_VALUE;
+               const bool add_value = cmd_ctx->lsm.cmd_type ==
+                       LTTCOMM_SESSIOND_COMMAND_PROCESS_ATTR_TRACKER_ADD_INCLUDE_VALUE;

                const size_t name_len =
                const size_t name_len =

-                               cmd_ctx->lsm.u.process_attr_tracker_add_remove_include_value
-                                               .name_len;
+                       cmd_ctx->lsm.u.process_attr_tracker_add_remove_include_value.name_len;

                const enum lttng_domain_type domain_type =
                const enum lttng_domain_type domain_type =

-                               (enum lttng_domain_type)
-                                               cmd_ctx->lsm.domain.type;
+                       (enum lttng_domain_type) cmd_ctx->lsm.domain.type;

                const enum lttng_process_attr process_attr =
                const enum lttng_process_attr process_attr =

-                               (enum lttng_process_attr) cmd_ctx->lsm.u
-                                               .process_attr_tracker_add_remove_include_value
-                                               .process_attr;
+                       (enum lttng_process_attr) cmd_ctx->lsm.u
+                               .process_attr_tracker_add_remove_include_value.process_attr;

                const enum lttng_process_attr_value_type value_type =
                const enum lttng_process_attr_value_type value_type =

-                               (enum lttng_process_attr_value_type) cmd_ctx
-                                               ->lsm.u
-                                               .process_attr_tracker_add_remove_include_value
-                                               .value_type;
+                       (enum lttng_process_attr_value_type) cmd_ctx->lsm.u
+                               .process_attr_tracker_add_remove_include_value.value_type;

                struct process_attr_value *value;
                enum lttng_error_code ret_code;
                long login_name_max;
                struct process_attr_value *value;
                enum lttng_error_code ret_code;
                long login_name_max;


@@ -1471,8 +1487,9 @@ skip_domain:
                         * LOGIN_NAME_MAX is defined to 256.
                         */
                        ERR("Rejecting process attribute tracker value %s as the provided exceeds the maximal allowed length: argument length = %zu, maximal length = %ld",
                         * LOGIN_NAME_MAX is defined to 256.
                         */
                        ERR("Rejecting process attribute tracker value %s as the provided exceeds the maximal allowed length: argument length = %zu, maximal length = %ld",

-                                       add_value ? "addition" : "removal",
-                                       name_len, login_name_max);
+                           add_value ? "addition" : "removal",
+                           name_len,
+                           login_name_max);

                        ret = LTTNG_ERR_INVALID;
                        goto error;
                }
                        ret = LTTNG_ERR_INVALID;
                        goto error;
                }


@@ -1486,24 +1503,22 @@ skip_domain:
                        ret = lttng_dynamic_buffer_set_size(&payload, name_len);
                        if (ret) {
                                ERR("Failed to allocate buffer to receive payload of %s process attribute tracker value argument",
                        ret = lttng_dynamic_buffer_set_size(&payload, name_len);
                        if (ret) {
                                ERR("Failed to allocate buffer to receive payload of %s process attribute tracker value argument",

-                                               add_value ? "add" : "remove");
+                                   add_value ? "add" : "remove");

                                ret = LTTNG_ERR_NOMEM;
                                goto error_add_remove_tracker_value;
                        }
 
                                ret = LTTNG_ERR_NOMEM;
                                goto error_add_remove_tracker_value;
                        }
 

-                       ret = lttcomm_recv_unix_sock(
-                                       *sock, payload.data, name_len);
+                       ret = lttcomm_recv_unix_sock(*sock, payload.data, name_len);

                        if (ret <= 0) {
                                ERR("Failed to receive payload of %s process attribute tracker value argument",
                        if (ret <= 0) {
                                ERR("Failed to receive payload of %s process attribute tracker value argument",

-                                               add_value ? "add" : "remove");
+                                   add_value ? "add" : "remove");

                                *sock_error = 1;
                                ret = LTTNG_ERR_INVALID_PROTOCOL;
                                goto error_add_remove_tracker_value;
                        }
                }
 
                                *sock_error = 1;
                                ret = LTTNG_ERR_INVALID_PROTOCOL;
                                goto error_add_remove_tracker_value;
                        }
                }
 

-               payload_view = lttng_buffer_view_from_dynamic_buffer(
-                               &payload, 0, name_len);
+               payload_view = lttng_buffer_view_from_dynamic_buffer(&payload, 0, name_len);

                if (name_len > 0 && !lttng_buffer_view_is_valid(&payload_view)) {
                        ret = LTTNG_ERR_INVALID_PROTOCOL;
                        goto error_add_remove_tracker_value;
                if (name_len > 0 && !lttng_buffer_view_is_valid(&payload_view)) {
                        ret = LTTNG_ERR_INVALID_PROTOCOL;
                        goto error_add_remove_tracker_value;


@@ -1514,11 +1529,13 @@ skip_domain:
                 * attribute tracker that is specified and convert the value to
                 * add/remove to the internal sessiond representation.
                 */
                 * attribute tracker that is specified and convert the value to
                 * add/remove to the internal sessiond representation.
                 */

-               ret_code = process_attr_value_from_comm(domain_type,
-                               process_attr, value_type,
-                               &cmd_ctx->lsm.u.process_attr_tracker_add_remove_include_value
-                                                .integral_value,
-                               &payload_view, &value);
+               ret_code = process_attr_value_from_comm(
+                       domain_type,
+                       process_attr,
+                       value_type,
+                       &cmd_ctx->lsm.u.process_attr_tracker_add_remove_include_value.integral_value,
+                       &payload_view,
+                       &value);

                if (ret_code != LTTNG_OK) {
                        ret = ret_code;
                        goto error_add_remove_tracker_value;
                if (ret_code != LTTNG_OK) {
                        ret = ret_code;
                        goto error_add_remove_tracker_value;


@@ -1526,12 +1543,10 @@ skip_domain:
 
                if (add_value) {
                        ret = cmd_process_attr_tracker_inclusion_set_add_value(
 
                if (add_value) {
                        ret = cmd_process_attr_tracker_inclusion_set_add_value(

-                                       cmd_ctx->session, domain_type,
-                                       process_attr, value);
+                               *target_session, domain_type, process_attr, value);

                } else {
                        ret = cmd_process_attr_tracker_inclusion_set_remove_value(
                } else {
                        ret = cmd_process_attr_tracker_inclusion_set_remove_value(

-                                       cmd_ctx->session, domain_type,
-                                       process_attr, value);
+                               *target_session, domain_type, process_attr, value);

                }
                process_attr_value_destroy(value);
        error_add_remove_tracker_value:
                }
                process_attr_value_destroy(value);
        error_add_remove_tracker_value:


@@ -1542,47 +1557,36 @@ skip_domain:
        {
                enum lttng_tracking_policy tracking_policy;
                const enum lttng_domain_type domain_type =
        {
                enum lttng_tracking_policy tracking_policy;
                const enum lttng_domain_type domain_type =

-                               (enum lttng_domain_type)
-                                               cmd_ctx->lsm.domain.type;
+                       (enum lttng_domain_type) cmd_ctx->lsm.domain.type;

                const enum lttng_process_attr process_attr =
                const enum lttng_process_attr process_attr =

-                               (enum lttng_process_attr) cmd_ctx->lsm.u
-                                               .process_attr_tracker_get_tracking_policy
-                                               .process_attr;
+                       (enum lttng_process_attr) cmd_ctx->lsm.u
+                               .process_attr_tracker_get_tracking_policy.process_attr;

 
                ret = cmd_process_attr_tracker_get_tracking_policy(
 
                ret = cmd_process_attr_tracker_get_tracking_policy(

-                               cmd_ctx->session, domain_type, process_attr,
-                               &tracking_policy);
+                       *target_session, domain_type, process_attr, &tracking_policy);

                if (ret != LTTNG_OK) {
                        goto error;
                }
 
                uint32_t tracking_policy_u32 = tracking_policy;
                if (ret != LTTNG_OK) {
                        goto error;
                }
 
                uint32_t tracking_policy_u32 = tracking_policy;

-               ret = setup_lttng_msg_no_cmd_header(cmd_ctx,
-                               &tracking_policy_u32, sizeof(uint32_t));
-               if (ret < 0) {
-                       ret = LTTNG_ERR_NOMEM;
-                       goto error;
-               }
+               setup_lttng_msg_no_cmd_header(cmd_ctx, &tracking_policy_u32, sizeof(uint32_t));
+

                ret = LTTNG_OK;
                break;
        }
        case LTTCOMM_SESSIOND_COMMAND_PROCESS_ATTR_TRACKER_SET_POLICY:
        {
                const enum lttng_tracking_policy tracking_policy =
                ret = LTTNG_OK;
                break;
        }
        case LTTCOMM_SESSIOND_COMMAND_PROCESS_ATTR_TRACKER_SET_POLICY:
        {
                const enum lttng_tracking_policy tracking_policy =

-                               (enum lttng_tracking_policy) cmd_ctx->lsm.u
-                                               .process_attr_tracker_set_tracking_policy
-                                               .tracking_policy;
+                       (enum lttng_tracking_policy) cmd_ctx->lsm.u
+                               .process_attr_tracker_set_tracking_policy.tracking_policy;

                const enum lttng_domain_type domain_type =
                const enum lttng_domain_type domain_type =

-                               (enum lttng_domain_type)
-                                               cmd_ctx->lsm.domain.type;
+                       (enum lttng_domain_type) cmd_ctx->lsm.domain.type;

                const enum lttng_process_attr process_attr =
                const enum lttng_process_attr process_attr =

-                               (enum lttng_process_attr) cmd_ctx->lsm.u
-                                               .process_attr_tracker_set_tracking_policy
-                                               .process_attr;
+                       (enum lttng_process_attr) cmd_ctx->lsm.u
+                               .process_attr_tracker_set_tracking_policy.process_attr;

 
                ret = cmd_process_attr_tracker_set_tracking_policy(
 
                ret = cmd_process_attr_tracker_set_tracking_policy(

-                               cmd_ctx->session, domain_type, process_attr,
-                               tracking_policy);
+                       *target_session, domain_type, process_attr, tracking_policy);

                if (ret != LTTNG_OK) {
                        goto error;
                }
                if (ret != LTTNG_OK) {
                        goto error;
                }


@@ -1593,16 +1597,13 @@ skip_domain:
                struct lttng_process_attr_values *values;
                struct lttng_dynamic_buffer reply;
                const enum lttng_domain_type domain_type =
                struct lttng_process_attr_values *values;
                struct lttng_dynamic_buffer reply;
                const enum lttng_domain_type domain_type =

-                               (enum lttng_domain_type)
-                                               cmd_ctx->lsm.domain.type;
+                       (enum lttng_domain_type) cmd_ctx->lsm.domain.type;

                const enum lttng_process_attr process_attr =
                const enum lttng_process_attr process_attr =

-                               (enum lttng_process_attr) cmd_ctx->lsm.u
-                                               .process_attr_tracker_get_inclusion_set
-                                               .process_attr;
+                       (enum lttng_process_attr)
+                               cmd_ctx->lsm.u.process_attr_tracker_get_inclusion_set.process_attr;

 
                ret = cmd_process_attr_tracker_get_inclusion_set(
 
                ret = cmd_process_attr_tracker_get_inclusion_set(

-                               cmd_ctx->session, domain_type, process_attr,
-                               &values);
+                       *target_session, domain_type, process_attr, &values);

                if (ret != LTTNG_OK) {
                        goto error;
                }
                if (ret != LTTNG_OK) {
                        goto error;
                }


@@ -1613,12 +1614,7 @@ skip_domain:
                        goto error_tracker_get_inclusion_set;
                }
 
                        goto error_tracker_get_inclusion_set;
                }
 

-               ret = setup_lttng_msg_no_cmd_header(
-                               cmd_ctx, reply.data, reply.size);
-               if (ret < 0) {
-                       ret = LTTNG_ERR_NOMEM;
-                       goto error_tracker_get_inclusion_set;
-               }
+               setup_lttng_msg_no_cmd_header(cmd_ctx, reply.data, reply.size);

                ret = LTTNG_OK;
 
        error_tracker_get_inclusion_set:
                ret = LTTNG_OK;
 
        error_tracker_get_inclusion_set:


@@ -1633,9 +1629,13 @@ skip_domain:
                char *filter_expression;
                struct lttng_event_exclusion *exclusions;
                struct lttng_bytecode *bytecode;
                char *filter_expression;
                struct lttng_event_exclusion *exclusions;
                struct lttng_bytecode *bytecode;

-               const enum lttng_error_code ret_code = receive_lttng_event(
-                               cmd_ctx, *sock, sock_error, &event,
-                               &filter_expression, &bytecode, &exclusions);
+               const enum lttng_error_code ret_code = receive_lttng_event(cmd_ctx,
+                                                                          *sock,
+                                                                          sock_error,
+                                                                          &event,
+                                                                          &filter_expression,
+                                                                          &bytecode,
+                                                                          &exclusions);

 
                if (ret_code != LTTNG_OK) {
                        ret = (int) ret_code;
 
                if (ret_code != LTTNG_OK) {
                        ret = (int) ret_code;


@@ -1647,13 +1647,19 @@ skip_domain:
                 * always transferred.
                 */
                ret = cmd_ctx->lsm.cmd_type == LTTCOMM_SESSIOND_COMMAND_ENABLE_EVENT ?
                 * always transferred.
                 */
                ret = cmd_ctx->lsm.cmd_type == LTTCOMM_SESSIOND_COMMAND_ENABLE_EVENT ?

-                               cmd_enable_event(cmd_ctx, event,
-                                               filter_expression, exclusions,
-                                               bytecode,
-                                               the_kernel_poll_pipe[1]) :
-                               cmd_disable_event(cmd_ctx, event,
-                                               filter_expression, bytecode,
-                                               exclusions);
+                       cmd_enable_event(cmd_ctx,
+                                        *target_session,
+                                        event,
+                                        filter_expression,
+                                        exclusions,
+                                        bytecode,
+                                        the_kernel_poll_pipe[1]) :
+                       cmd_disable_event(cmd_ctx,
+                                         *target_session,
+                                         event,
+                                         filter_expression,
+                                         bytecode,
+                                         exclusions);

                lttng_event_destroy(event);
                break;
        }
                lttng_event_destroy(event);
                break;
        }


@@ -1664,25 +1670,19 @@ skip_domain:
                size_t payload_size;
                const size_t command_header_size = sizeof(struct lttcomm_list_command_header);
 
                size_t payload_size;
                const size_t command_header_size = sizeof(struct lttcomm_list_command_header);
 

-               ret = setup_empty_lttng_msg(cmd_ctx);
-               if (ret) {
-                       ret = LTTNG_ERR_NOMEM;
-                       goto setup_error;
-               }
+               setup_empty_lttng_msg(cmd_ctx);

 
                original_payload_size = cmd_ctx->reply_payload.buffer.size;
 
 
                original_payload_size = cmd_ctx->reply_payload.buffer.size;
 

-               session_lock_list();
-               ret_code = cmd_list_tracepoints(cmd_ctx->lsm.domain.type,
-                               &cmd_ctx->reply_payload);
-               session_unlock_list();
+               list_lock = lttng::sessiond::lock_session_list();
+               ret_code = cmd_list_tracepoints(cmd_ctx->lsm.domain.type, &cmd_ctx->reply_payload);

                if (ret_code != LTTNG_OK) {
                        ret = (int) ret_code;
                        goto error;
                }
 
                if (ret_code != LTTNG_OK) {
                        ret = (int) ret_code;
                        goto error;
                }
 

-               payload_size = cmd_ctx->reply_payload.buffer.size -
-                               command_header_size - original_payload_size;
+               payload_size = cmd_ctx->reply_payload.buffer.size - command_header_size -
+                       original_payload_size;

                update_lttng_msg(cmd_ctx, command_header_size, payload_size);
 
                ret = LTTNG_OK;
                update_lttng_msg(cmd_ctx, command_header_size, payload_size);
 
                ret = LTTNG_OK;


@@ -1695,25 +1695,21 @@ skip_domain:
                size_t payload_size;
                const size_t command_header_size = sizeof(struct lttcomm_list_command_header);
 
                size_t payload_size;
                const size_t command_header_size = sizeof(struct lttcomm_list_command_header);
 

-               ret = setup_empty_lttng_msg(cmd_ctx);
-               if (ret) {
-                       ret = LTTNG_ERR_NOMEM;
-                       goto setup_error;
-               }
+               setup_empty_lttng_msg(cmd_ctx);

 
                original_payload_size = cmd_ctx->reply_payload.buffer.size;
 
 
                original_payload_size = cmd_ctx->reply_payload.buffer.size;
 

-               session_lock_list();
-               ret_code = cmd_list_tracepoint_fields(
-                               cmd_ctx->lsm.domain.type, &cmd_ctx->reply_payload);
-               session_unlock_list();
+               list_lock = lttng::sessiond::lock_session_list();
+               ret_code = cmd_list_tracepoint_fields(cmd_ctx->lsm.domain.type,
+                                                     &cmd_ctx->reply_payload);
+

                if (ret_code != LTTNG_OK) {
                        ret = (int) ret_code;
                        goto error;
                }
 
                if (ret_code != LTTNG_OK) {
                        ret = (int) ret_code;
                        goto error;
                }
 

-               payload_size = cmd_ctx->reply_payload.buffer.size -
-                               command_header_size - original_payload_size;
+               payload_size = cmd_ctx->reply_payload.buffer.size - command_header_size -
+                       original_payload_size;

                update_lttng_msg(cmd_ctx, command_header_size, payload_size);
 
                ret = LTTNG_OK;
                update_lttng_msg(cmd_ctx, command_header_size, payload_size);
 
                ret = LTTNG_OK;


@@ -1726,11 +1722,7 @@ skip_domain:
                size_t payload_size;
                const size_t command_header_size = sizeof(struct lttcomm_list_command_header);
 
                size_t payload_size;
                const size_t command_header_size = sizeof(struct lttcomm_list_command_header);
 

-               ret = setup_empty_lttng_msg(cmd_ctx);
-               if (ret) {
-                       ret = LTTNG_ERR_NOMEM;
-                       goto setup_error;
-               }
+               setup_empty_lttng_msg(cmd_ctx);

 
                original_payload_size = cmd_ctx->reply_payload.buffer.size;
 
 
                original_payload_size = cmd_ctx->reply_payload.buffer.size;
 


@@ -1740,8 +1732,8 @@ skip_domain:
                        goto error;
                }
 
                        goto error;
                }
 

-               payload_size = cmd_ctx->reply_payload.buffer.size -
-                               command_header_size - original_payload_size;
+               payload_size = cmd_ctx->reply_payload.buffer.size - command_header_size -
+                       original_payload_size;

                update_lttng_msg(cmd_ctx, command_header_size, payload_size);
 
                ret = LTTNG_OK;
                update_lttng_msg(cmd_ctx, command_header_size, payload_size);
 
                ret = LTTNG_OK;


@@ -1761,7 +1753,7 @@ skip_domain:
                }
 
                uris = calloc<lttng_uri>(nb_uri);
                }
 
                uris = calloc<lttng_uri>(nb_uri);

-               if (uris == NULL) {
+               if (uris == nullptr) {

                        ret = LTTNG_ERR_FATAL;
                        goto error;
                }
                        ret = LTTNG_ERR_FATAL;
                        goto error;
                }


@@ -1777,13 +1769,12 @@ skip_domain:
                        goto error;
                }
 
                        goto error;
                }
 

-               ret = cmd_set_consumer_uri(cmd_ctx->session, nb_uri, uris);
+               ret = cmd_set_consumer_uri(*target_session, nb_uri, uris);

                free(uris);
                if (ret != LTTNG_OK) {
                        goto error;
                }
 
                free(uris);
                if (ret != LTTNG_OK) {
                        goto error;
                }
 

-

                break;
        }
        case LTTCOMM_SESSIOND_COMMAND_START_TRACE:
                break;
        }
        case LTTCOMM_SESSIOND_COMMAND_START_TRACE:


@@ -1793,49 +1784,42 @@ skip_domain:
                 * enabled time or size-based rotations, we have to make sure
                 * the kernel tracer supports it.
                 */
                 * enabled time or size-based rotations, we have to make sure
                 * the kernel tracer supports it.
                 */

-               if (!cmd_ctx->session->has_been_started && \
-                               cmd_ctx->session->kernel_session && \
-                               (cmd_ctx->session->rotate_timer_period || \
-                                       cmd_ctx->session->rotate_size) && \
-                               !check_rotate_compatible()) {
+               if (!(*target_session)->has_been_started && (*target_session)->kernel_session &&
+                   ((*target_session)->rotate_timer_period || (*target_session)->rotate_size) &&
+                   !check_rotate_compatible()) {

                        DBG("Kernel tracer version is not compatible with the rotation feature");
                        ret = LTTNG_ERR_ROTATION_WRONG_VERSION;
                        goto error;
                }
                        DBG("Kernel tracer version is not compatible with the rotation feature");
                        ret = LTTNG_ERR_ROTATION_WRONG_VERSION;
                        goto error;
                }

-               ret = cmd_start_trace(cmd_ctx->session);
+               ret = cmd_start_trace(*target_session);

                break;
        }
        case LTTCOMM_SESSIOND_COMMAND_STOP_TRACE:
        {
                break;
        }
        case LTTCOMM_SESSIOND_COMMAND_STOP_TRACE:
        {

-               ret = cmd_stop_trace(cmd_ctx->session);
+               ret = cmd_stop_trace(*target_session);

                break;
        }
        case LTTCOMM_SESSIOND_COMMAND_DESTROY_SESSION:
        {
                break;
        }
        case LTTCOMM_SESSIOND_COMMAND_DESTROY_SESSION:
        {

-               ret = cmd_destroy_session(cmd_ctx->session,
-                               the_notification_thread_handle, sock);
+               ret = cmd_destroy_session(*target_session, sock);

                break;
        }
        case LTTCOMM_SESSIOND_COMMAND_LIST_DOMAINS:
        {
                ssize_t nb_dom;
                break;
        }
        case LTTCOMM_SESSIOND_COMMAND_LIST_DOMAINS:
        {
                ssize_t nb_dom;

-               struct lttng_domain *domains = NULL;
+               struct lttng_domain *domains = nullptr;

 
 

-               nb_dom = cmd_list_domains(cmd_ctx->session, &domains);
+               nb_dom = cmd_list_domains(*target_session, &domains);

                if (nb_dom < 0) {
                        /* Return value is a negative lttng_error_code. */
                        ret = -nb_dom;
                        goto error;
                }
 
                if (nb_dom < 0) {
                        /* Return value is a negative lttng_error_code. */
                        ret = -nb_dom;
                        goto error;
                }
 

-               ret = setup_lttng_msg_no_cmd_header(cmd_ctx, domains,
-                       nb_dom * sizeof(struct lttng_domain));
+               setup_lttng_msg_no_cmd_header(
+                       cmd_ctx, domains, nb_dom * sizeof(struct lttng_domain));

                free(domains);
 
                free(domains);
 

-               if (ret < 0) {
-                       goto setup_error;
-               }
-

                ret = LTTNG_OK;
                break;
        }
                ret = LTTNG_OK;
                break;
        }


@@ -1846,23 +1830,19 @@ skip_domain:
                size_t payload_size;
                const size_t command_header_size = sizeof(struct lttcomm_list_command_header);
 
                size_t payload_size;
                const size_t command_header_size = sizeof(struct lttcomm_list_command_header);
 

-               ret = setup_empty_lttng_msg(cmd_ctx);
-               if (ret) {
-                       ret = LTTNG_ERR_NOMEM;
-                       goto setup_error;
-               }
+               setup_empty_lttng_msg(cmd_ctx);

 
                original_payload_size = cmd_ctx->reply_payload.buffer.size;
 
 
                original_payload_size = cmd_ctx->reply_payload.buffer.size;
 

-               ret_code = cmd_list_channels(cmd_ctx->lsm.domain.type,
-                               cmd_ctx->session, &cmd_ctx->reply_payload);
+               ret_code = cmd_list_channels(
+                       cmd_ctx->lsm.domain.type, *target_session, &cmd_ctx->reply_payload);

                if (ret_code != LTTNG_OK) {
                        ret = (int) ret_code;
                        goto error;
                }
 
                if (ret_code != LTTNG_OK) {
                        ret = (int) ret_code;
                        goto error;
                }
 

-               payload_size = cmd_ctx->reply_payload.buffer.size -
-                               command_header_size - original_payload_size;
+               payload_size = cmd_ctx->reply_payload.buffer.size - command_header_size -
+                       original_payload_size;

                update_lttng_msg(cmd_ctx, command_header_size, payload_size);
 
                ret = LTTNG_OK;
                update_lttng_msg(cmd_ctx, command_header_size, payload_size);
 
                ret = LTTNG_OK;


@@ -1875,24 +1855,21 @@ skip_domain:
                size_t payload_size;
                const size_t command_header_size = sizeof(struct lttcomm_list_command_header);
 
                size_t payload_size;
                const size_t command_header_size = sizeof(struct lttcomm_list_command_header);
 

-               ret = setup_empty_lttng_msg(cmd_ctx);
-               if (ret) {
-                       ret = LTTNG_ERR_NOMEM;
-                       goto setup_error;
-               }
+               setup_empty_lttng_msg(cmd_ctx);

 
                original_payload_size = cmd_ctx->reply_payload.buffer.size;
 
                ret_code = cmd_list_events(cmd_ctx->lsm.domain.type,
 
                original_payload_size = cmd_ctx->reply_payload.buffer.size;
 
                ret_code = cmd_list_events(cmd_ctx->lsm.domain.type,

-                               cmd_ctx->session,
-                               cmd_ctx->lsm.u.list.channel_name, &cmd_ctx->reply_payload);
+                                          *target_session,
+                                          cmd_ctx->lsm.u.list.channel_name,
+                                          &cmd_ctx->reply_payload);

                if (ret_code != LTTNG_OK) {
                        ret = (int) ret_code;
                        goto error;
                }
 
                if (ret_code != LTTNG_OK) {
                        ret = (int) ret_code;
                        goto error;
                }
 

-               payload_size = cmd_ctx->reply_payload.buffer.size -
-                               command_header_size - original_payload_size;
+               payload_size = cmd_ctx->reply_payload.buffer.size - command_header_size -
+                       original_payload_size;

                update_lttng_msg(cmd_ctx, command_header_size, payload_size);
 
                ret = LTTNG_OK;
                update_lttng_msg(cmd_ctx, command_header_size, payload_size);
 
                ret = LTTNG_OK;


@@ -1904,38 +1881,29 @@ skip_domain:
                lttng_session *sessions_payload = nullptr;
                size_t payload_len = 0;
 
                lttng_session *sessions_payload = nullptr;
                size_t payload_len = 0;
 

-               session_lock_list();
-               nr_sessions = lttng_sessions_count(
-                               LTTNG_SOCK_GET_UID_CRED(&cmd_ctx->creds),
-                               LTTNG_SOCK_GET_GID_CRED(&cmd_ctx->creds));
+               list_lock = lttng::sessiond::lock_session_list();
+               nr_sessions = lttng_sessions_count(LTTNG_SOCK_GET_UID_CRED(&cmd_ctx->creds),
+                                                  LTTNG_SOCK_GET_GID_CRED(&cmd_ctx->creds));

 
                if (nr_sessions > 0) {
 
                if (nr_sessions > 0) {

-                       payload_len = (sizeof(struct lttng_session) *
-                                                     nr_sessions) +
-                                       (sizeof(struct lttng_session_extended) *
-                                                       nr_sessions);
+                       payload_len = (sizeof(struct lttng_session) * nr_sessions) +
+                               (sizeof(struct lttng_session_extended) * nr_sessions);

                        sessions_payload = zmalloc<lttng_session>(payload_len);
                        if (!sessions_payload) {
                        sessions_payload = zmalloc<lttng_session>(payload_len);
                        if (!sessions_payload) {

-                               session_unlock_list();
-                               ret = -ENOMEM;
-                               goto setup_error;
+                               LTTNG_THROW_ALLOCATION_FAILURE_ERROR(
+                                       "Failed to allocate session list reply payload",
+                                       payload_len);

                        }
 
                        }
 

-                       cmd_list_lttng_sessions(sessions_payload, nr_sessions,
-                                       LTTNG_SOCK_GET_UID_CRED(&cmd_ctx->creds),
-                                       LTTNG_SOCK_GET_GID_CRED(&cmd_ctx->creds));
+                       cmd_list_lttng_sessions(sessions_payload,
+                                               nr_sessions,
+                                               LTTNG_SOCK_GET_UID_CRED(&cmd_ctx->creds),
+                                               LTTNG_SOCK_GET_GID_CRED(&cmd_ctx->creds));

                }
 
                }
 

-               session_unlock_list();
-
-               ret = setup_lttng_msg_no_cmd_header(
-                               cmd_ctx, sessions_payload, payload_len);
+               setup_lttng_msg_no_cmd_header(cmd_ctx, sessions_payload, payload_len);

                free(sessions_payload);
 
                free(sessions_payload);
 

-               if (ret < 0) {
-                       goto setup_error;
-               }
-

                ret = LTTNG_OK;
                break;
        }
                ret = LTTNG_OK;
                break;
        }


@@ -1952,8 +1920,24 @@ skip_domain:
                        goto error;
                }
 
                        goto error;
                }
 

-               ret = cmd_register_consumer(cmd_ctx->session, cmd_ctx->lsm.domain.type,
-                               cmd_ctx->lsm.u.reg.path, cdata);
+               ret = cmd_register_consumer(
+                       *target_session, cmd_ctx->lsm.domain.type, cmd_ctx->lsm.u.reg.path, cdata);
+               break;
+       }
+       case LTTCOMM_SESSIOND_COMMAND_KERNEL_TRACER_STATUS:
+       {
+               uint32_t u_status;
+               enum lttng_kernel_tracer_status status;
+
+               ret = cmd_kernel_tracer_status(&status);
+               if (ret != LTTNG_OK) {
+                       goto error;
+               }
+
+               u_status = (uint32_t) status;
+               setup_lttng_msg_no_cmd_header(cmd_ctx, &u_status, 4);
+
+               ret = LTTNG_OK;

                break;
        }
        case LTTCOMM_SESSIOND_COMMAND_DATA_PENDING:
                break;
        }
        case LTTCOMM_SESSIOND_COMMAND_DATA_PENDING:


@@ -1961,7 +1945,7 @@ skip_domain:
                int pending_ret;
                uint8_t pending_ret_byte;
 
                int pending_ret;
                uint8_t pending_ret_byte;
 

-               pending_ret = cmd_data_pending(cmd_ctx->session);
+               pending_ret = cmd_data_pending(*target_session);

 
                /*
                 * FIXME
 
                /*
                 * FIXME


@@ -1977,23 +1961,18 @@ skip_domain:
                         * ret will be set to LTTNG_OK at the end of
                         * this function.
                         */
                         * ret will be set to LTTNG_OK at the end of
                         * this function.
                         */

-               } else if (pending_ret < 0) {
+               } else if (pending_ret <= LTTNG_OK || pending_ret >= LTTNG_ERR_NR) {

                        ret = LTTNG_ERR_UNK;
                        ret = LTTNG_ERR_UNK;

-                       goto setup_error;
+                       goto error;

                } else {
                        ret = pending_ret;
                } else {
                        ret = pending_ret;

-                       goto setup_error;
+                       goto error;

                }
 
                pending_ret_byte = (uint8_t) pending_ret;
 
                /* 1 byte to return whether or not data is pending */
                }
 
                pending_ret_byte = (uint8_t) pending_ret;
 
                /* 1 byte to return whether or not data is pending */

-               ret = setup_lttng_msg_no_cmd_header(cmd_ctx,
-                       &pending_ret_byte, 1);
-
-               if (ret < 0) {
-                       goto setup_error;
-               }
+               setup_lttng_msg_no_cmd_header(cmd_ctx, &pending_ret_byte, 1);

 
                ret = LTTNG_OK;
                break;
 
                ret = LTTNG_OK;
                break;


@@ -2002,21 +1981,15 @@ skip_domain:
        {
                uint32_t snapshot_id;
                struct lttcomm_lttng_output_id reply;
        {
                uint32_t snapshot_id;
                struct lttcomm_lttng_output_id reply;

-               lttng_snapshot_output output = cmd_ctx->lsm.u.snapshot_output.output;
+               const lttng_snapshot_output output = cmd_ctx->lsm.u.snapshot_output.output;

 
 

-               ret = cmd_snapshot_add_output(cmd_ctx->session,
-                               &output,
-                               &snapshot_id);
+               ret = cmd_snapshot_add_output(*target_session, &output, &snapshot_id);

                if (ret != LTTNG_OK) {
                        goto error;
                }
                reply.id = snapshot_id;
 
                if (ret != LTTNG_OK) {
                        goto error;
                }
                reply.id = snapshot_id;
 

-               ret = setup_lttng_msg_no_cmd_header(cmd_ctx, &reply,
-                       sizeof(reply));
-               if (ret < 0) {
-                       goto setup_error;
-               }
+               setup_lttng_msg_no_cmd_header(cmd_ctx, &reply, sizeof(reply));

 
                /* Copy output list into message payload */
                ret = LTTNG_OK;
 
                /* Copy output list into message payload */
                ret = LTTNG_OK;


@@ -2024,97 +1997,90 @@ skip_domain:
        }
        case LTTCOMM_SESSIOND_COMMAND_SNAPSHOT_DEL_OUTPUT:
        {
        }
        case LTTCOMM_SESSIOND_COMMAND_SNAPSHOT_DEL_OUTPUT:
        {

-               lttng_snapshot_output output = cmd_ctx->lsm.u.snapshot_output.output;
-               ret = cmd_snapshot_del_output(cmd_ctx->session, &output);
+               const lttng_snapshot_output output = cmd_ctx->lsm.u.snapshot_output.output;
+               ret = cmd_snapshot_del_output(*target_session, &output);

                break;
        }
        case LTTCOMM_SESSIOND_COMMAND_SNAPSHOT_LIST_OUTPUT:
        {
                ssize_t nb_output;
                break;
        }
        case LTTCOMM_SESSIOND_COMMAND_SNAPSHOT_LIST_OUTPUT:
        {
                ssize_t nb_output;

-               struct lttng_snapshot_output *outputs = NULL;
+               struct lttng_snapshot_output *outputs = nullptr;

 
 

-               nb_output = cmd_snapshot_list_outputs(cmd_ctx->session, &outputs);
+               nb_output = cmd_snapshot_list_outputs(*target_session, &outputs);

                if (nb_output < 0) {
                        ret = -nb_output;
                        goto error;
                }
 
                LTTNG_ASSERT((nb_output > 0 && outputs) || nb_output == 0);
                if (nb_output < 0) {
                        ret = -nb_output;
                        goto error;
                }
 
                LTTNG_ASSERT((nb_output > 0 && outputs) || nb_output == 0);

-               ret = setup_lttng_msg_no_cmd_header(cmd_ctx, outputs,
-                               nb_output * sizeof(struct lttng_snapshot_output));
+               setup_lttng_msg_no_cmd_header(
+                       cmd_ctx, outputs, nb_output * sizeof(struct lttng_snapshot_output));

                free(outputs);
 
                free(outputs);
 

-               if (ret < 0) {
-                       goto setup_error;
-               }
-

                ret = LTTNG_OK;
                break;
        }
        case LTTCOMM_SESSIOND_COMMAND_SNAPSHOT_RECORD:
        {
                ret = LTTNG_OK;
                break;
        }
        case LTTCOMM_SESSIOND_COMMAND_SNAPSHOT_RECORD:
        {

-               lttng_snapshot_output output = cmd_ctx->lsm.u.snapshot_record.output;
-               ret = cmd_snapshot_record(cmd_ctx->session,
-                               &output, 0); // RFC: set to zero since it's ignored by cmd_snapshot_record
+               const lttng_snapshot_output output = cmd_ctx->lsm.u.snapshot_record.output;
+               ret = cmd_snapshot_record(*target_session, &output, 0); // RFC: set to zero
+                                                                       // since it's ignored
+                                                                       // by
+                                                                       // cmd_snapshot_record

                break;
        }
        case LTTCOMM_SESSIOND_COMMAND_CREATE_SESSION_EXT:
        {
                struct lttng_dynamic_buffer payload;
                break;
        }
        case LTTCOMM_SESSIOND_COMMAND_CREATE_SESSION_EXT:
        {
                struct lttng_dynamic_buffer payload;

-               struct lttng_session_descriptor *return_descriptor = NULL;

 
                lttng_dynamic_buffer_init(&payload);
 
                lttng_dynamic_buffer_init(&payload);

-               ret = cmd_create_session(cmd_ctx, *sock, &return_descriptor);
-               if (ret != LTTNG_OK) {
-                       goto error;
-               }

 
 

-               ret = lttng_session_descriptor_serialize(return_descriptor,
-                               &payload);
-               if (ret) {
-                       ERR("Failed to serialize session descriptor in reply to \"create session\" command");
-                       lttng_session_descriptor_destroy(return_descriptor);
-                       ret = LTTNG_ERR_NOMEM;
-                       goto error;
-               }
-               ret = setup_lttng_msg_no_cmd_header(cmd_ctx, payload.data,
-                               payload.size);
+               const lttng::ctl::session_descriptor reply_session_descriptor = [cmd_ctx, sock]() {
+                       lttng_session_descriptor *raw_descriptor;
+                       const auto create_ret = cmd_create_session(cmd_ctx, *sock, &raw_descriptor);
+                       if (create_ret != LTTNG_OK) {
+                               LTTNG_THROW_CTL("Failed to create session", create_ret);
+                       }
+
+                       return lttng::ctl::session_descriptor(raw_descriptor);
+               }();
+
+               ret = lttng_session_descriptor_serialize(reply_session_descriptor.get(), &payload);

                if (ret) {
                if (ret) {

-                       lttng_session_descriptor_destroy(return_descriptor);
-                       ret = LTTNG_ERR_NOMEM;
-                       goto error;
+                       LTTNG_THROW_CTL(
+                               "Failed to serialize session descriptor in reply to \"create session\" command",
+                               LTTNG_ERR_NOMEM);

                }
                }

+
+               setup_lttng_msg_no_cmd_header(cmd_ctx, payload.data, payload.size);
+

                lttng_dynamic_buffer_reset(&payload);
                lttng_dynamic_buffer_reset(&payload);

-               lttng_session_descriptor_destroy(return_descriptor);

                ret = LTTNG_OK;
                break;
        }
        case LTTCOMM_SESSIOND_COMMAND_SAVE_SESSION:
        {
                ret = LTTNG_OK;
                break;
        }
        case LTTCOMM_SESSIOND_COMMAND_SAVE_SESSION:
        {

-               ret = cmd_save_sessions(&cmd_ctx->lsm.u.save_session.attr,
-                       &cmd_ctx->creds);
+               ret = cmd_save_sessions(&cmd_ctx->lsm.u.save_session.attr, &cmd_ctx->creds);

                break;
        }
        case LTTCOMM_SESSIOND_COMMAND_SET_SESSION_SHM_PATH:
        {
                break;
        }
        case LTTCOMM_SESSIOND_COMMAND_SET_SESSION_SHM_PATH:
        {

-               ret = cmd_set_session_shm_path(cmd_ctx->session,
-                               cmd_ctx->lsm.u.set_shm_path.shm_path);
+               ret = cmd_set_session_shm_path(*target_session,
+                                              cmd_ctx->lsm.u.set_shm_path.shm_path);

                break;
        }
        case LTTCOMM_SESSIOND_COMMAND_REGENERATE_METADATA:
        {
                break;
        }
        case LTTCOMM_SESSIOND_COMMAND_REGENERATE_METADATA:
        {

-               ret = cmd_regenerate_metadata(cmd_ctx->session);
+               ret = cmd_regenerate_metadata(*target_session);

                break;
        }
        case LTTCOMM_SESSIOND_COMMAND_REGENERATE_STATEDUMP:
        {
                break;
        }
        case LTTCOMM_SESSIOND_COMMAND_REGENERATE_STATEDUMP:
        {

-               ret = cmd_regenerate_statedump(cmd_ctx->session);
+               ret = cmd_regenerate_statedump(*target_session);

                break;
        }
        case LTTCOMM_SESSIOND_COMMAND_REGISTER_TRIGGER:
        {
                break;
        }
        case LTTCOMM_SESSIOND_COMMAND_REGISTER_TRIGGER:
        {

-               struct lttng_trigger *payload_trigger;
-               struct lttng_trigger *return_trigger;

                size_t original_reply_payload_size;
                size_t reply_payload_size;
                const struct lttng_credentials cmd_creds = {
                size_t original_reply_payload_size;
                size_t reply_payload_size;
                const struct lttng_credentials cmd_creds = {


@@ -2122,40 +2088,30 @@ skip_domain:
                        .gid = LTTNG_OPTIONAL_INIT_VALUE(cmd_ctx->creds.gid),
                };
 
                        .gid = LTTNG_OPTIONAL_INIT_VALUE(cmd_ctx->creds.gid),
                };
 

-               ret = setup_empty_lttng_msg(cmd_ctx);
-               if (ret) {
-                       ret = LTTNG_ERR_NOMEM;
-                       goto setup_error;
-               }
+               setup_empty_lttng_msg(cmd_ctx);

 
 

-               ret = receive_lttng_trigger(
-                               cmd_ctx, *sock, sock_error, &payload_trigger);
+               auto payload_trigger = receive_lttng_trigger(cmd_ctx, *sock, sock_error);

                if (ret != LTTNG_OK) {
                        goto error;
                }
 
                original_reply_payload_size = cmd_ctx->reply_payload.buffer.size;
 
                if (ret != LTTNG_OK) {
                        goto error;
                }
 
                original_reply_payload_size = cmd_ctx->reply_payload.buffer.size;
 

-               ret = cmd_register_trigger(&cmd_creds, payload_trigger,
-                               cmd_ctx->lsm.u.trigger.is_trigger_anonymous,
-                               the_notification_thread_handle,
-                               &return_trigger);
-               if (ret != LTTNG_OK) {
-                       lttng_trigger_put(payload_trigger);
-                       goto error;
-               }
+               auto return_trigger =
+                       cmd_register_trigger(&cmd_creds,
+                                            payload_trigger.get(),
+                                            cmd_ctx->lsm.u.trigger.is_trigger_anonymous,
+                                            the_notification_thread_handle);

 
 

-               ret = lttng_trigger_serialize(return_trigger, &cmd_ctx->reply_payload);
-               lttng_trigger_put(payload_trigger);
-               lttng_trigger_put(return_trigger);
+               ret = lttng_trigger_serialize(return_trigger.get(), &cmd_ctx->reply_payload);

                if (ret) {
                if (ret) {

-                       ERR("Failed to serialize trigger in reply to \"register trigger\" command");
-                       ret = LTTNG_ERR_NOMEM;
-                       goto error;
+                       LTTNG_THROW_CTL(
+                               "Failed to serialize trigger in reply to \"register trigger\" command",
+                               LTTNG_ERR_NOMEM);

                }
 
                }
 

-               reply_payload_size = cmd_ctx->reply_payload.buffer.size -
-                       original_reply_payload_size;
+               reply_payload_size =
+                       cmd_ctx->reply_payload.buffer.size - original_reply_payload_size;

 
                update_lttng_msg(cmd_ctx, 0, reply_payload_size);
 
 
                update_lttng_msg(cmd_ctx, 0, reply_payload_size);
 


@@ -2164,50 +2120,40 @@ skip_domain:
        }
        case LTTCOMM_SESSIOND_COMMAND_UNREGISTER_TRIGGER:
        {
        }
        case LTTCOMM_SESSIOND_COMMAND_UNREGISTER_TRIGGER:
        {

-               struct lttng_trigger *payload_trigger;

                const struct lttng_credentials cmd_creds = {
                        .uid = LTTNG_OPTIONAL_INIT_VALUE(cmd_ctx->creds.uid),
                        .gid = LTTNG_OPTIONAL_INIT_VALUE(cmd_ctx->creds.gid),
                };
 
                const struct lttng_credentials cmd_creds = {
                        .uid = LTTNG_OPTIONAL_INIT_VALUE(cmd_ctx->creds.uid),
                        .gid = LTTNG_OPTIONAL_INIT_VALUE(cmd_ctx->creds.gid),
                };
 

-               ret = receive_lttng_trigger(
-                               cmd_ctx, *sock, sock_error, &payload_trigger);
-               if (ret != LTTNG_OK) {
-                       goto error;
-               }
+               auto payload_trigger = receive_lttng_trigger(cmd_ctx, *sock, sock_error);

 
 

-               ret = cmd_unregister_trigger(&cmd_creds, payload_trigger,
-                               the_notification_thread_handle);
-               lttng_trigger_put(payload_trigger);
+               ret = cmd_unregister_trigger(
+                       &cmd_creds, payload_trigger.get(), the_notification_thread_handle);

                break;
        }
        case LTTCOMM_SESSIOND_COMMAND_ROTATE_SESSION:
        {
                struct lttng_rotate_session_return rotate_return;
 
                break;
        }
        case LTTCOMM_SESSIOND_COMMAND_ROTATE_SESSION:
        {
                struct lttng_rotate_session_return rotate_return;
 

-               DBG("Client rotate session \"%s\"", cmd_ctx->session->name);
+               DBG("Client rotate session \"%s\"", (*target_session)->name);

 
                memset(&rotate_return, 0, sizeof(rotate_return));
 
                memset(&rotate_return, 0, sizeof(rotate_return));

-               if (cmd_ctx->session->kernel_session && !check_rotate_compatible()) {
+               if ((*target_session)->kernel_session && !check_rotate_compatible()) {

                        DBG("Kernel tracer version is not compatible with the rotation feature");
                        ret = LTTNG_ERR_ROTATION_WRONG_VERSION;
                        goto error;
                }
 
                        DBG("Kernel tracer version is not compatible with the rotation feature");
                        ret = LTTNG_ERR_ROTATION_WRONG_VERSION;
                        goto error;
                }
 

-               ret = cmd_rotate_session(cmd_ctx->session, &rotate_return,
-                       false,
-                       LTTNG_TRACE_CHUNK_COMMAND_TYPE_MOVE_TO_COMPLETED);
+               ret = cmd_rotate_session(*target_session,
+                                        &rotate_return,
+                                        false,
+                                        LTTNG_TRACE_CHUNK_COMMAND_TYPE_MOVE_TO_COMPLETED);

                if (ret < 0) {
                        ret = -ret;
                        goto error;
                }
 
                if (ret < 0) {
                        ret = -ret;
                        goto error;
                }
 

-               ret = setup_lttng_msg_no_cmd_header(cmd_ctx, &rotate_return,
-                               sizeof(rotate_return));
-               if (ret < 0) {
-                       ret = -ret;
-                       goto error;
-               }
+               setup_lttng_msg_no_cmd_header(cmd_ctx, &rotate_return, sizeof(rotate_return));

 
                ret = LTTNG_OK;
                break;
 
                ret = LTTNG_OK;
                break;


@@ -2217,19 +2163,15 @@ skip_domain:
                struct lttng_rotation_get_info_return get_info_return;
 
                memset(&get_info_return, 0, sizeof(get_info_return));
                struct lttng_rotation_get_info_return get_info_return;
 
                memset(&get_info_return, 0, sizeof(get_info_return));

-               ret = cmd_rotate_get_info(cmd_ctx->session, &get_info_return,
-                               cmd_ctx->lsm.u.get_rotation_info.rotation_id);
+               ret = cmd_rotate_get_info(*target_session,
+                                         &get_info_return,
+                                         cmd_ctx->lsm.u.get_rotation_info.rotation_id);

                if (ret < 0) {
                        ret = -ret;
                        goto error;
                }
 
                if (ret < 0) {
                        ret = -ret;
                        goto error;
                }
 

-               ret = setup_lttng_msg_no_cmd_header(cmd_ctx, &get_info_return,
-                               sizeof(get_info_return));
-               if (ret < 0) {
-                       ret = -ret;
-                       goto error;
-               }
+               setup_lttng_msg_no_cmd_header(cmd_ctx, &get_info_return, sizeof(get_info_return));

 
                ret = LTTNG_OK;
                break;
 
                ret = LTTNG_OK;
                break;


@@ -2240,19 +2182,19 @@ skip_domain:
                enum lttng_rotation_schedule_type schedule_type;
                uint64_t value;
 
                enum lttng_rotation_schedule_type schedule_type;
                uint64_t value;
 

-               if (cmd_ctx->session->kernel_session && !check_rotate_compatible()) {
+               if ((*target_session)->kernel_session && !check_rotate_compatible()) {

                        DBG("Kernel tracer version does not support session rotations");
                        ret = LTTNG_ERR_ROTATION_WRONG_VERSION;
                        goto error;
                }
 
                set_schedule = cmd_ctx->lsm.u.rotation_set_schedule.set == 1;
                        DBG("Kernel tracer version does not support session rotations");
                        ret = LTTNG_ERR_ROTATION_WRONG_VERSION;
                        goto error;
                }
 
                set_schedule = cmd_ctx->lsm.u.rotation_set_schedule.set == 1;

-               schedule_type = (enum lttng_rotation_schedule_type) cmd_ctx->lsm.u.rotation_set_schedule.type;
+               schedule_type = (enum lttng_rotation_schedule_type)
+                                       cmd_ctx->lsm.u.rotation_set_schedule.type;

                value = cmd_ctx->lsm.u.rotation_set_schedule.value;
 
                value = cmd_ctx->lsm.u.rotation_set_schedule.value;
 

-               ret = cmd_rotation_set_schedule(cmd_ctx->session, set_schedule,
-                               schedule_type, value,
-                               the_notification_thread_handle);
+               ret = cmd_rotation_set_schedule(
+                       *target_session, set_schedule, schedule_type, value);

                if (ret != LTTNG_OK) {
                        goto error;
                }
                if (ret != LTTNG_OK) {
                        goto error;
                }


@@ -2263,49 +2205,38 @@ skip_domain:
        {
                lttng_session_list_schedules_return schedules;
 
        {
                lttng_session_list_schedules_return schedules;
 

-               schedules.periodic.set = !!cmd_ctx->session->rotate_timer_period;
-               schedules.periodic.value = cmd_ctx->session->rotate_timer_period;
-               schedules.size.set = !!cmd_ctx->session->rotate_size;
-               schedules.size.value = cmd_ctx->session->rotate_size;
+               schedules.periodic.set = !!(*target_session)->rotate_timer_period;
+               schedules.periodic.value = (*target_session)->rotate_timer_period;
+               schedules.size.set = !!(*target_session)->rotate_size;
+               schedules.size.value = (*target_session)->rotate_size;

 
 

-               ret = setup_lttng_msg_no_cmd_header(cmd_ctx, &schedules,
-                               sizeof(schedules));
-               if (ret < 0) {
-                       ret = -ret;
-                       goto error;
-               }
+               setup_lttng_msg_no_cmd_header(cmd_ctx, &schedules, sizeof(schedules));

 
                ret = LTTNG_OK;
                break;
        }
        case LTTCOMM_SESSIOND_COMMAND_CLEAR_SESSION:
        {
 
                ret = LTTNG_OK;
                break;
        }
        case LTTCOMM_SESSIOND_COMMAND_CLEAR_SESSION:
        {

-               ret = cmd_clear_session(cmd_ctx->session, sock);
+               ret = cmd_clear_session(*target_session, sock);

                break;
        }
        case LTTCOMM_SESSIOND_COMMAND_LIST_TRIGGERS:
        {
                break;
        }
        case LTTCOMM_SESSIOND_COMMAND_LIST_TRIGGERS:
        {

-               struct lttng_triggers *return_triggers = NULL;
+               struct lttng_triggers *return_triggers = nullptr;

                size_t original_payload_size;
                size_t payload_size;
 
                size_t original_payload_size;
                size_t payload_size;
 

-               ret = setup_empty_lttng_msg(cmd_ctx);
-               if (ret) {
-                       ret = LTTNG_ERR_NOMEM;
-                       goto setup_error;
-               }
+               setup_empty_lttng_msg(cmd_ctx);

 
                original_payload_size = cmd_ctx->reply_payload.buffer.size;
 
 
                original_payload_size = cmd_ctx->reply_payload.buffer.size;
 

-               ret = cmd_list_triggers(cmd_ctx, the_notification_thread_handle,
-                               &return_triggers);
+               ret = cmd_list_triggers(cmd_ctx, the_notification_thread_handle, &return_triggers);

                if (ret != LTTNG_OK) {
                        goto error;
                }
 
                LTTNG_ASSERT(return_triggers);
                if (ret != LTTNG_OK) {
                        goto error;
                }
 
                LTTNG_ASSERT(return_triggers);

-               ret = lttng_triggers_serialize(
-                               return_triggers, &cmd_ctx->reply_payload);
+               ret = lttng_triggers_serialize(return_triggers, &cmd_ctx->reply_payload);

                lttng_triggers_destroy(return_triggers);
                if (ret) {
                        ERR("Failed to serialize triggers in reply to `list triggers` command");
                lttng_triggers_destroy(return_triggers);
                if (ret) {
                        ERR("Failed to serialize triggers in reply to `list triggers` command");


@@ -2313,8 +2244,7 @@ skip_domain:
                        goto error;
                }
 
                        goto error;
                }
 

-               payload_size = cmd_ctx->reply_payload.buffer.size -
-                       original_payload_size;
+               payload_size = cmd_ctx->reply_payload.buffer.size - original_payload_size;

 
                update_lttng_msg(cmd_ctx, 0, payload_size);
 
 
                update_lttng_msg(cmd_ctx, 0, payload_size);
 


@@ -2328,34 +2258,28 @@ skip_domain:
                        .uid = LTTNG_OPTIONAL_INIT_VALUE(cmd_ctx->creds.uid),
                        .gid = LTTNG_OPTIONAL_INIT_VALUE(cmd_ctx->creds.gid),
                };
                        .uid = LTTNG_OPTIONAL_INIT_VALUE(cmd_ctx->creds.uid),
                        .gid = LTTNG_OPTIONAL_INIT_VALUE(cmd_ctx->creds.gid),
                };

-               struct lttng_error_query_results *results = NULL;
+               struct lttng_error_query_results *results = nullptr;

                size_t original_payload_size;
                size_t payload_size;
 
                size_t original_payload_size;
                size_t payload_size;
 

-               ret = setup_empty_lttng_msg(cmd_ctx);
-               if (ret) {
-                       ret = LTTNG_ERR_NOMEM;
-                       goto setup_error;
-               }
+               setup_empty_lttng_msg(cmd_ctx);

 
                original_payload_size = cmd_ctx->reply_payload.buffer.size;
 
 
                original_payload_size = cmd_ctx->reply_payload.buffer.size;
 

-               ret = receive_lttng_error_query(
-                               cmd_ctx, *sock, sock_error, &query);
+               ret = receive_lttng_error_query(cmd_ctx, *sock, sock_error, &query);

                if (ret != LTTNG_OK) {
                        goto error;
                }
 
                if (ret != LTTNG_OK) {
                        goto error;
                }
 

-               ret = cmd_execute_error_query(&cmd_creds, query, &results,
-                               the_notification_thread_handle);
+               ret = cmd_execute_error_query(
+                       &cmd_creds, query, &results, the_notification_thread_handle);

                lttng_error_query_destroy(query);
                if (ret != LTTNG_OK) {
                        goto error;
                }
 
                LTTNG_ASSERT(results);
                lttng_error_query_destroy(query);
                if (ret != LTTNG_OK) {
                        goto error;
                }
 
                LTTNG_ASSERT(results);

-               ret = lttng_error_query_results_serialize(
-                               results, &cmd_ctx->reply_payload);
+               ret = lttng_error_query_results_serialize(results, &cmd_ctx->reply_payload);

                lttng_error_query_results_destroy(results);
                if (ret) {
                        ERR("Failed to serialize error query result set in reply to `execute error query` command");
                lttng_error_query_results_destroy(results);
                if (ret) {
                        ERR("Failed to serialize error query result set in reply to `execute error query` command");


@@ -2363,8 +2287,7 @@ skip_domain:
                        goto error;
                }
 
                        goto error;
                }
 

-               payload_size = cmd_ctx->reply_payload.buffer.size -
-                       original_payload_size;
+               payload_size = cmd_ctx->reply_payload.buffer.size - original_payload_size;

 
                update_lttng_msg(cmd_ctx, 0, payload_size);
 
 
                update_lttng_msg(cmd_ctx, 0, payload_size);
 


@@ -2380,36 +2303,22 @@ skip_domain:
 error:
        if (cmd_ctx->reply_payload.buffer.size == 0) {
                DBG("Missing llm header, creating one.");
 error:
        if (cmd_ctx->reply_payload.buffer.size == 0) {
                DBG("Missing llm header, creating one.");

-               if (setup_lttng_msg_no_cmd_header(cmd_ctx, NULL, 0) < 0) {
-                       goto setup_error;
-               }
-       }
-       /* Set return code */
-       ((struct lttcomm_lttng_msg *) (cmd_ctx->reply_payload.buffer.data))->ret_code = ret;
-setup_error:
-       if (cmd_ctx->session) {
-               session_unlock(cmd_ctx->session);
-               session_put(cmd_ctx->session);
-               cmd_ctx->session = NULL;
+               setup_lttng_msg_no_cmd_header(cmd_ctx, nullptr, 0);

        }
        }

-       if (need_tracing_session) {
-               session_unlock_list();
-       }
-init_setup_error:
+
+       command_ctx_set_status_code(*cmd_ctx, static_cast<lttng_error_code>(ret));

        LTTNG_ASSERT(!rcu_read_ongoing());
        return ret;
 }
 
        LTTNG_ASSERT(!rcu_read_ongoing());
        return ret;
 }
 

-static int create_client_sock(void)
+static int create_client_sock()

 {
        int ret, client_sock;
 
        /* Create client tool unix socket */
 {
        int ret, client_sock;
 
        /* Create client tool unix socket */

-       client_sock = lttcomm_create_unix_sock(
-                       the_config.client_unix_sock_path.value);
+       client_sock = lttcomm_create_unix_sock(the_config.client_unix_sock_path.value);

        if (client_sock < 0) {
        if (client_sock < 0) {

-               ERR("Create unix sock failed: %s",
-                               the_config.client_unix_sock_path.value);
+               ERR("Create unix sock failed: %s", the_config.client_unix_sock_path.value);

                ret = -1;
                goto end;
        }
                ret = -1;
                goto end;
        }


@@ -2418,16 +2327,15 @@ static int create_client_sock(void)
        ret = utils_set_fd_cloexec(client_sock);
        if (ret < 0) {
                ERR("Unable to set CLOEXEC flag to the client Unix socket (fd: %d). "
        ret = utils_set_fd_cloexec(client_sock);
        if (ret < 0) {
                ERR("Unable to set CLOEXEC flag to the client Unix socket (fd: %d). "

-                               "Continuing but note that the consumer daemon will have a "
-                               "reference to this socket on exec()", client_sock);
+                   "Continuing but note that the consumer daemon will have a "
+                   "reference to this socket on exec()",
+                   client_sock);

        }
 
        /* File permission MUST be 660 */
        }
 
        /* File permission MUST be 660 */

-       ret = chmod(the_config.client_unix_sock_path.value,
-                       S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
+       ret = chmod(the_config.client_unix_sock_path.value, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);

        if (ret < 0) {
        if (ret < 0) {

-               ERR("Set file permissions failed: %s",
-                               the_config.client_unix_sock_path.value);
+               ERR("Set file permissions failed: %s", the_config.client_unix_sock_path.value);

                PERROR("chmod");
                (void) lttcomm_close_unix_sock(client_sock);
                ret = -1;
                PERROR("chmod");
                (void) lttcomm_close_unix_sock(client_sock);
                ret = -1;


@@ -2451,6 +2359,51 @@ static void thread_init_cleanup(void *data __attribute__((unused)))
        set_thread_status(false);
 }
 
        set_thread_status(false);
 }
 

+// Helper function to log the source_location if the exception is derived from lttng::runtime_error
+template <typename ExceptionType>
+typename std::enable_if<std::is_base_of<lttng::runtime_error, ExceptionType>::value,
+                       std::string>::type
+formatted_source_location(const ExceptionType& ex)
+{
+       return fmt::format("{}", ex.source_location);
+}
+
+template <typename ExceptionType>
+typename std::enable_if<!std::is_base_of<lttng::runtime_error, ExceptionType>::value,
+                       std::string>::type
+formatted_source_location(const ExceptionType&)
+{
+       return "";
+}
+
+template <class ExceptionType>
+static void log_nested_exceptions(const ExceptionType& ex, unsigned int level = 0)
+{
+       const auto location = formatted_source_location(ex);
+
+       if (level == 0) {
+               if (location.size()) {
+                       WARN_FMT("Client request failed: {}, location='{}'", ex.what(), location);
+               } else {
+                       WARN_FMT("Client request failed: {}", ex.what());
+               }
+       } else {
+               if (location.size()) {
+                       WARN_FMT("\t{}, location='{}'", ex.what(), location);
+               } else {
+                       WARN_FMT("\t{}", ex.what());
+               }
+       }
+
+       try {
+               std::rethrow_if_nested(ex);
+       } catch (const lttng::runtime_error& nested_ex) {
+               log_nested_exceptions(nested_ex, level + 1);
+       } catch (const std::exception& nested_ex) {
+               log_nested_exceptions(nested_ex, level + 1);
+       }
+}
+

 /*
  * This thread manage all clients request using the unix client socket for
  * communication.
 /*
  * This thread manage all clients request using the unix client socket for
  * communication.


@@ -2472,7 +2425,7 @@ static void *thread_manage_clients(void *data)
 
        is_root = (getuid() == 0);
 
 
        is_root = (getuid() == 0);
 

-       pthread_cleanup_push(thread_init_cleanup, NULL);
+       pthread_cleanup_push(thread_init_cleanup, nullptr);

 
        rcu_register_thread();
 
 
        rcu_register_thread();
 


@@ -2501,7 +2454,7 @@ static void *thread_manage_clients(void *data)
        }
 
        /* Add thread quit pipe */
        }
 
        /* Add thread quit pipe */

-       ret = lttng_poll_add(&events, thread_quit_pipe_fd, LPOLLIN | LPOLLERR);
+       ret = lttng_poll_add(&events, thread_quit_pipe_fd, LPOLLIN);

        if (ret < 0) {
                goto error;
        }
        if (ret < 0) {
                goto error;
        }


@@ -2521,13 +2474,12 @@ static void *thread_manage_clients(void *data)
 
        health_code_update();
 
 
        health_code_update();
 

-       while (1) {
+       while (true) {

                const struct cmd_completion_handler *cmd_completion_handler;
 
                cmd_ctx.creds.uid = UINT32_MAX;
                cmd_ctx.creds.gid = UINT32_MAX;
                cmd_ctx.creds.pid = 0;
                const struct cmd_completion_handler *cmd_completion_handler;
 
                cmd_ctx.creds.uid = UINT32_MAX;
                cmd_ctx.creds.gid = UINT32_MAX;
                cmd_ctx.creds.pid = 0;

-               cmd_ctx.session = NULL;

                lttng_payload_clear(&cmd_ctx.reply_payload);
                cmd_ctx.lttng_msg_size = 0;
 
                lttng_payload_clear(&cmd_ctx.reply_payload);
                cmd_ctx.lttng_msg_size = 0;
 


@@ -2605,8 +2557,8 @@ static void *thread_manage_clients(void *data)
                 * the client.
                 */
                DBG("Receiving data from client ...");
                 * the client.
                 */
                DBG("Receiving data from client ...");

-               ret = lttcomm_recv_creds_unix_sock(sock, &cmd_ctx.lsm,
-                               sizeof(struct lttcomm_session_msg), &cmd_ctx.creds);
+               ret = lttcomm_recv_creds_unix_sock(
+                       sock, &cmd_ctx.lsm, sizeof(struct lttcomm_session_msg), &cmd_ctx.creds);

                if (ret != sizeof(struct lttcomm_session_msg)) {
                        DBG("Incomplete recv() from client... continuing");
                        ret = close(sock);
                if (ret != sizeof(struct lttcomm_session_msg)) {
                        DBG("Incomplete recv() from client... continuing");
                        ret = close(sock);


@@ -2629,40 +2581,54 @@ static void *thread_manage_clients(void *data)
                 * informations for the client. The command context struct contains
                 * everything this function may needs.
                 */
                 * informations for the client. The command context struct contains
                 * everything this function may needs.
                 */

-               ret = process_client_msg(&cmd_ctx, &sock, &sock_error);
-               rcu_thread_offline();
-               if (ret < 0) {
-                       if (sock >= 0) {
-                               ret = close(sock);
-                               if (ret) {
-                                       PERROR("close");
-                               }
-                       }
-                       sock = -1;
-                       /*
-                        * TODO: Inform client somehow of the fatal error. At
-                        * this point, ret < 0 means that a zmalloc failed
-                        * (ENOMEM). Error detected but still accept
-                        * command, unless a socket error has been
-                        * detected.
-                        */
-                       continue;
+               try {
+                       ret = process_client_msg(&cmd_ctx, &sock, &sock_error);
+                       rcu_thread_offline();
+               } catch (const std::bad_alloc& ex) {
+                       log_nested_exceptions(ex);
+                       ret = LTTNG_ERR_NOMEM;
+               } catch (const lttng::ctl::error& ex) {
+                       log_nested_exceptions(ex);
+                       ret = ex.code();
+               } catch (const lttng::invalid_argument_error& ex) {
+                       log_nested_exceptions(ex);
+                       ret = LTTNG_ERR_INVALID;
+               } catch (const lttng::sessiond::exceptions::session_not_found_error& ex) {
+                       log_nested_exceptions(ex);
+                       ret = LTTNG_ERR_SESS_NOT_FOUND;
+               } catch (const lttng::runtime_error& ex) {
+                       log_nested_exceptions(ex);
+                       ret = LTTNG_ERR_UNK;
+               } catch (const std::exception& ex) {
+                       log_nested_exceptions(ex);
+                       ret = LTTNG_ERR_UNK;

                }
 
                if (ret < LTTNG_OK || ret >= LTTNG_ERR_NR) {
                        WARN("Command returned an invalid status code, returning unknown error: "
                }
 
                if (ret < LTTNG_OK || ret >= LTTNG_ERR_NR) {
                        WARN("Command returned an invalid status code, returning unknown error: "

-                                       "command type = %s (%d), ret = %d",
-                                       lttcomm_sessiond_command_str((lttcomm_sessiond_command) cmd_ctx.lsm.cmd_type),
-                                       cmd_ctx.lsm.cmd_type, ret);
+                            "command type = %s (%d), ret = %d",
+                            lttcomm_sessiond_command_str(
+                                    (lttcomm_sessiond_command) cmd_ctx.lsm.cmd_type),
+                            cmd_ctx.lsm.cmd_type,
+                            ret);

                        ret = LTTNG_ERR_UNK;
                }
 
                        ret = LTTNG_ERR_UNK;
                }
 

+               if (ret != LTTNG_OK) {
+                       /*
+                        * Reset the payload contents as the command may have left them in an
+                        * inconsistent state.
+                        */
+                       setup_empty_lttng_msg(&cmd_ctx);
+               }
+
+               command_ctx_set_status_code(cmd_ctx, static_cast<lttng_error_code>(ret));
+

                cmd_completion_handler = cmd_pop_completion_handler();
                if (cmd_completion_handler) {
                        enum lttng_error_code completion_code;
 
                cmd_completion_handler = cmd_pop_completion_handler();
                if (cmd_completion_handler) {
                        enum lttng_error_code completion_code;
 

-                       completion_code = cmd_completion_handler->run(
-                                       cmd_completion_handler->data);
+                       completion_code = cmd_completion_handler->run(cmd_completion_handler->data);

                        if (completion_code != LTTNG_OK) {
                                continue;
                        }
                        if (completion_code != LTTNG_OK) {
                                continue;
                        }


@@ -2672,11 +2638,9 @@ static void *thread_manage_clients(void *data)
 
                if (sock >= 0) {
                        struct lttng_payload_view view =
 
                if (sock >= 0) {
                        struct lttng_payload_view view =

-                                       lttng_payload_view_from_payload(
-                                                       &cmd_ctx.reply_payload,
-                                                       0, -1);
-                       struct lttcomm_lttng_msg *llm = (typeof(
-                                       llm)) cmd_ctx.reply_payload.buffer.data;
+                               lttng_payload_view_from_payload(&cmd_ctx.reply_payload, 0, -1);
+                       struct lttcomm_lttng_msg *llm =
+                               (typeof(llm)) cmd_ctx.reply_payload.buffer.data;

 
                        LTTNG_ASSERT(cmd_ctx.reply_payload.buffer.size >= sizeof(*llm));
                        LTTNG_ASSERT(cmd_ctx.lttng_msg_size == cmd_ctx.reply_payload.buffer.size);
 
                        LTTNG_ASSERT(cmd_ctx.reply_payload.buffer.size >= sizeof(*llm));
                        LTTNG_ASSERT(cmd_ctx.lttng_msg_size == cmd_ctx.reply_payload.buffer.size);


@@ -2684,9 +2648,9 @@ static void *thread_manage_clients(void *data)
                        llm->fd_count = lttng_payload_view_get_fd_handle_count(&view);
 
                        DBG("Sending response (size: %d, retcode: %s (%d))",
                        llm->fd_count = lttng_payload_view_get_fd_handle_count(&view);
 
                        DBG("Sending response (size: %d, retcode: %s (%d))",

-                                       cmd_ctx.lttng_msg_size,
-                                       lttng_strerror(-llm->ret_code),
-                                       llm->ret_code);
+                           cmd_ctx.lttng_msg_size,
+                           lttng_strerror(-llm->ret_code),
+                           llm->ret_code);

                        ret = send_unix_sock(sock, &view);
                        if (ret < 0) {
                                ERR("Failed to send data back to client");
                        ret = send_unix_sock(sock, &view);
                        if (ret < 0) {
                                ERR("Failed to send data back to client");


@@ -2732,11 +2696,10 @@ error_create_poll:
        DBG("Client thread dying");
        lttng_payload_reset(&cmd_ctx.reply_payload);
        rcu_unregister_thread();
        DBG("Client thread dying");
        lttng_payload_reset(&cmd_ctx.reply_payload);
        rcu_unregister_thread();

-       return NULL;
+       return nullptr;

 }
 
 }
 

-static
-bool shutdown_client_thread(void *thread_data)
+static bool shutdown_client_thread(void *thread_data)

 {
        struct lttng_pipe *client_quit_pipe = (lttng_pipe *) thread_data;
        const int write_fd = lttng_pipe_get_writefd(client_quit_pipe);
 {
        struct lttng_pipe *client_quit_pipe = (lttng_pipe *) thread_data;
        const int write_fd = lttng_pipe_get_writefd(client_quit_pipe);


@@ -2744,11 +2707,11 @@ bool shutdown_client_thread(void *thread_data)
        return notify_thread_pipe(write_fd) == 1;
 }
 
        return notify_thread_pipe(write_fd) == 1;
 }
 

-struct lttng_thread *launch_client_thread(void)
+struct lttng_thread *launch_client_thread()

 {
        bool thread_running;
        struct lttng_pipe *client_quit_pipe;
 {
        bool thread_running;
        struct lttng_pipe *client_quit_pipe;

-       struct lttng_thread *thread = NULL;
+       struct lttng_thread *thread = nullptr;

        int client_sock_fd = -1;
 
        sem_init(&thread_state.ready, 0, 0);
        int client_sock_fd = -1;
 
        sem_init(&thread_state.ready, 0, 0);


@@ -2764,16 +2727,16 @@ struct lttng_thread *launch_client_thread(void)
 
        thread_state.client_sock = client_sock_fd;
        thread = lttng_thread_create("Client management",
 
        thread_state.client_sock = client_sock_fd;
        thread = lttng_thread_create("Client management",

-                       thread_manage_clients,
-                       shutdown_client_thread,
-                       cleanup_client_thread,
-                       client_quit_pipe);
+                                    thread_manage_clients,
+                                    shutdown_client_thread,
+                                    cleanup_client_thread,
+                                    client_quit_pipe);

        if (!thread) {
                goto error;
        }
        /* The client thread now owns the client sock fd and the quit pipe. */
        client_sock_fd = -1;
        if (!thread) {
                goto error;
        }
        /* The client thread now owns the client sock fd and the quit pipe. */
        client_sock_fd = -1;

-       client_quit_pipe = NULL;
+       client_quit_pipe = nullptr;

 
        /*
         * This thread is part of the threads that need to be fully
 
        /*
         * This thread is part of the threads that need to be fully


@@ -2792,5 +2755,5 @@ error:
        }
        lttng_thread_put(thread);
        cleanup_client_thread(client_quit_pipe);
        }
        lttng_thread_put(thread);
        cleanup_client_thread(client_quit_pipe);

-       return NULL;
+       return nullptr;

 }
 }