sessiond: Remove [.*-thread] logging prefix

The logger now logs the thread name making this prefix useless.

Signed-off-by: Jérémie Galarneau <jeremie.galarneau@efficios.com>
Change-Id: Ie9093e4032d2cf0d3c0e9fa0d7eda28467033931

diff --git a/src/bin/lttng-sessiond/agent-thread.c b/src/bin/lttng-sessiond/agent-thread.c
index 720639efd0b50d0433992c22b113a6be8693b439..e09796e329a173cafc0344a80af85d1564bc6ee4 100644 (file)
--- a/src/bin/lttng-sessiond/agent-thread.c
+++ b/src/bin/lttng-sessiond/agent-thread.c
@@ -120,7 +120,7 @@ static struct lttcomm_sock *init_tcp_socket(void)
        sock = lttcomm_alloc_sock_from_uri(uri);
        uri_free(uri);
        if (sock == NULL) {
-               ERR("[agent-thread] agent allocating TCP socket");
+               ERR("agent allocating TCP socket");
                goto error;
        }
 
@@ -133,11 +133,11 @@ static struct lttcomm_sock *init_tcp_socket(void)
                        port <= the_config.agent_tcp_port.end; port++) {
                ret = lttcomm_sock_set_port(sock, (uint16_t) port);
                if (ret) {
-                       ERR("[agent-thread] Failed to set port %u on socket",
+                       ERR("Failed to set port %u on socket",
                                        port);
                        goto error;
                }
-               DBG3("[agent-thread] Trying to bind on port %u", port);
+               DBG3("Trying to bind on port %u", port);
                ret = sock->ops->bind(sock);
                if (!ret) {
                        bind_succeeded = true;
@@ -174,7 +174,7 @@ static struct lttcomm_sock *init_tcp_socket(void)
                goto error;
        }
 
-       DBG("[agent-thread] Listening on TCP port %u and socket %d",
+       DBG("Listening on TCP port %u and socket %d",
                        port, sock->fd);
 
        return sock;
@@ -198,11 +198,11 @@ static void destroy_tcp_socket(struct lttcomm_sock *sock)
 
        ret = lttcomm_sock_get_port(sock, &port);
        if (ret) {
-               ERR("[agent-thread] Failed to get port of agent TCP socket");
+               ERR("Failed to get port of agent TCP socket");
                port = 0;
        }
 
-       DBG3("[agent-thread] Destroy TCP socket on port %" PRIu16,
+       DBG3("Destroy TCP socket on port %" PRIu16,
                        port);
 
        /* This will return gracefully if fd is invalid. */
@@ -363,7 +363,7 @@ static void *thread_agent_management(void *data)
        const int quit_pipe_read_fd = lttng_pipe_get_readfd(
                        notifiers->quit_pipe);
 
-       DBG("[agent-thread] Manage agent application registration.");
+       DBG("Manage agent application registration.");
 
        rcu_register_thread();
        rcu_thread_online();
@@ -391,7 +391,7 @@ static void *thread_agent_management(void *data)
 
                ret = write_agent_port(port);
                if (ret) {
-                       ERR("[agent-thread] Failed to create agent port file: agent tracing will be unavailable");
+                       ERR("Failed to create agent port file: agent tracing will be unavailable");
                        /* Don't prevent the launch of the sessiond on error. */
                        mark_thread_as_ready(notifiers);
                        goto error;
@@ -417,12 +417,12 @@ static void *thread_agent_management(void *data)
        }
 
        while (1) {
-               DBG3("[agent-thread] Manage agent polling");
+               DBG3("Manage agent polling");
 
                /* Inifinite blocking call, waiting for transmission */
 restart:
                ret = lttng_poll_wait(&events, -1);
-               DBG3("[agent-thread] Manage agent return from poll on %d fds",
+               DBG3("Manage agent return from poll on %d fds",
                                LTTNG_POLL_GETNB(&events));
                if (ret < 0) {
                        /*
@@ -434,7 +434,7 @@ restart:
                        goto error;
                }
                nb_fd = ret;
-               DBG3("[agent-thread] %d fd ready", nb_fd);
+               DBG3("%d fd ready", nb_fd);
 
                for (i = 0; i < nb_fd; i++) {
                        /* Fetch once the poll data */
@@ -542,7 +542,7 @@ error_tcp_socket:
        lttng_poll_clean(&events);
 error_poll_create:
        uatomic_set(&agent_tracing_enabled, 0);
-       DBG("[agent-thread] Cleaning up and stopping.");
+       DBG("Cleaning up and stopping.");
        rcu_thread_offline();
        rcu_unregister_thread();
        return NULL;

diff --git a/src/bin/lttng-sessiond/ht-cleanup.c b/src/bin/lttng-sessiond/ht-cleanup.c
index c670baf49d78b951888a7e220cf6bfb646f32840..c130ce0f29522460366e1c63c04dba56a03c4a2a 100644 (file)
--- a/src/bin/lttng-sessiond/ht-cleanup.c
+++ b/src/bin/lttng-sessiond/ht-cleanup.c
@@ -72,7 +72,7 @@ static int set_pollset(struct lttng_poll_event *events, size_t size)
 
        ret = lttng_poll_add(events, the_ht_cleanup_pipe[0], LPOLLIN | LPOLLERR);
        if (ret < 0) {
-               DBG("[ht-thread] lttng_poll_add error %d.", ret);
+               DBG("lttng_poll_add error %d.", ret);
                goto error;
        }
 
@@ -95,7 +95,7 @@ static void *thread_ht_cleanup(void *data)
        uint32_t revents, nb_fd;
        struct lttng_poll_event events;
 
-       DBG("[ht-thread] startup.");
+       DBG("startup.");
 
        rcu_register_thread();
        rcu_thread_online();
@@ -103,7 +103,7 @@ static void *thread_ht_cleanup(void *data)
        health_register(the_health_sessiond, HEALTH_SESSIOND_TYPE_HT_CLEANUP);
 
        if (testpoint(sessiond_thread_ht_cleanup)) {
-               DBG("[ht-thread] testpoint.");
+               DBG("testpoint.");
                goto error_testpoint;
        }
 
@@ -111,7 +111,7 @@ static void *thread_ht_cleanup(void *data)
 
        ret = set_pollset(&events, 2);
        if (ret < 0) {
-               DBG("[ht-thread] sessiond_set_ht_cleanup_thread_pollset error %d.", ret);
+               DBG("sessiond_set_ht_cleanup_thread_pollset error %d.", ret);
                goto error_poll_create;
        }
 
@@ -119,10 +119,10 @@ static void *thread_ht_cleanup(void *data)
 
        while (1) {
        restart:
-               DBG3("[ht-thread] Polling.");
+               DBG3("Polling.");
                health_poll_entry();
                ret = lttng_poll_wait(&events, -1);
-               DBG3("[ht-thread] Returning from poll on %d fds.",
+               DBG3("Returning from poll on %d fds.",
                        LTTNG_POLL_GETNB(&events));
                health_poll_exit();
                if (ret < 0) {

diff --git a/src/bin/lttng-sessiond/notification-thread-commands.c b/src/bin/lttng-sessiond/notification-thread-commands.c
index 89eb37bb1ae82beba6be84eb765b996b171e2609..f678a0d8d14a1d6d253799c2ef8e01875d1e2ccb 100644 (file)
--- a/src/bin/lttng-sessiond/notification-thread-commands.c
+++ b/src/bin/lttng-sessiond/notification-thread-commands.c
@@ -428,7 +428,7 @@ struct lttng_event_notifier_notification *lttng_event_notifier_notification_crea
 
        notification = zmalloc(sizeof(struct lttng_event_notifier_notification));
        if (notification == NULL) {
-               ERR("[notification-thread] Error allocating notification");
+               ERR("Error allocating notification");
                goto end;
        }
 

diff --git a/src/bin/lttng-sessiond/notification-thread-events.c b/src/bin/lttng-sessiond/notification-thread-events.c
index 2d37af07c6504a1c55eedd2c829418ef16d0a6eb..2772e6fa61b18fdec34a0a507c200e48a5a9e9c8 100644 (file)
--- a/src/bin/lttng-sessiond/notification-thread-events.c
+++ b/src/bin/lttng-sessiond/notification-thread-events.c
@@ -530,7 +530,7 @@ void session_info_destroy(void *_data)
        if (session_info->channel_infos_ht) {
                ret = cds_lfht_destroy(session_info->channel_infos_ht, NULL);
                if (ret) {
-                       ERR("[notification-thread] Failed to destroy channel information hash table");
+                       ERR("Failed to destroy channel information hash table");
                }
        }
        lttng_session_trigger_list_destroy(session_info->trigger_list);
@@ -870,7 +870,7 @@ int evaluate_channel_condition_for_client(
 
        if (!channel_key){
                /* No channel found; normal exit. */
-               DBG("[notification-thread] No known channel associated with newly subscribed-to condition");
+               DBG("No known channel associated with newly subscribed-to condition");
                ret = 0;
                goto end;
        }
@@ -899,7 +899,7 @@ int evaluate_channel_condition_for_client(
                                channel_state_ht_node);
        } else {
                /* Nothing to evaluate, no sample was ever taken. Normal exit */
-               DBG("[notification-thread] No channel sample associated with newly subscribed-to condition");
+               DBG("No channel sample associated with newly subscribed-to condition");
                ret = 0;
                goto end;
        }
@@ -909,7 +909,7 @@ int evaluate_channel_condition_for_client(
                        0, channel_info->session_info->consumed_data_size,
                        channel_info);
        if (ret) {
-               WARN("[notification-thread] Fatal error occurred while evaluating a newly subscribed-to condition");
+               WARN("Fatal error occurred while evaluating a newly subscribed-to condition");
                goto end;
        }
 
@@ -945,7 +945,7 @@ const char *get_condition_session_name(const struct lttng_condition *condition)
                abort();
        }
        if (status != LTTNG_CONDITION_STATUS_OK) {
-               ERR("[notification-thread] Failed to retrieve session rotation condition's session name");
+               ERR("Failed to retrieve session rotation condition's session name");
                goto end;
        }
 end:
@@ -976,7 +976,7 @@ int evaluate_session_condition_for_client(
                        &iter);
        node = cds_lfht_iter_get_node(&iter);
        if (!node) {
-               DBG("[notification-thread] No known session matching name \"%s\"",
+               DBG("No known session matching name \"%s\"",
                                session_name);
                ret = 0;
                goto end;
@@ -1001,7 +1001,7 @@ int evaluate_session_condition_for_client(
                                session_info->rotation.id);
                if (!*evaluation) {
                        /* Fatal error. */
-                       ERR("[notification-thread] Failed to create session rotation ongoing evaluation for session \"%s\"",
+                       ERR("Failed to create session rotation ongoing evaluation for session \"%s\"",
                                        session_info->name);
                        ret = -1;
                        goto end_session_put;
@@ -1053,7 +1053,7 @@ int evaluate_condition_for_client(const struct lttng_trigger *trigger,
                                &evaluation, &object_uid, &object_gid);
                break;
        case LTTNG_OBJECT_TYPE_NONE:
-               DBG("[notification-thread] Newly subscribed-to condition not bound to object, nothing to evaluate");
+               DBG("Newly subscribed-to condition not bound to object, nothing to evaluate");
                ret = 0;
                goto end;
        case LTTNG_OBJECT_TYPE_UNKNOWN:
@@ -1067,7 +1067,7 @@ int evaluate_condition_for_client(const struct lttng_trigger *trigger,
        }
        if (!evaluation) {
                /* Evaluation yielded nothing. Normal exit. */
-               DBG("[notification-thread] Newly subscribed-to condition evaluated to false, nothing to report to client");
+               DBG("Newly subscribed-to condition evaluated to false, nothing to report to client");
                ret = 0;
                goto end;
        }
@@ -1084,7 +1084,7 @@ int evaluate_condition_for_client(const struct lttng_trigger *trigger,
        cds_list_add(&client_list_element.node, &client_list.clients_list);
 
        /* Send evaluation result to the newly-subscribed client. */
-       DBG("[notification-thread] Newly subscribed-to condition evaluated to true, notifying client");
+       DBG("Newly subscribed-to condition evaluated to true, notifying client");
        ret = send_evaluation_to_clients(trigger, evaluation, &client_list,
                        state, object_uid, object_gid);
 
@@ -1164,7 +1164,7 @@ int notification_thread_client_subscribe(struct notification_client *client,
                        &client_list->triggers_list, client_list_trigger_node) {
                if (evaluate_condition_for_client(trigger_ht_element->trigger, condition_list_element->condition,
                                client, state)) {
-                       WARN("[notification-thread] Evaluation of a condition on client subscription failed, aborting.");
+                       WARN("Evaluation of a condition on client subscription failed, aborting.");
                        ret = -1;
                        free(client_list_element);
                        pthread_mutex_unlock(&client_list->lock);
@@ -1469,7 +1469,7 @@ struct lttng_session_trigger_list *get_session_trigger_list(
                 * Not an error, the list of triggers applying to that session
                 * will be initialized when the session is created.
                 */
-               DBG("[notification-thread] No trigger list found for session \"%s\" as it is not yet known to the notification system",
+               DBG("No trigger list found for session \"%s\" as it is not yet known to the notification system",
                                session_name);
                goto end;
        }
@@ -1578,7 +1578,7 @@ bool trigger_applies_to_session(const struct lttng_trigger *trigger,
                condition_status = lttng_condition_session_rotation_get_session_name(
                        condition, &condition_session_name);
                if (condition_status != LTTNG_CONDITION_STATUS_OK) {
-                       ERR("[notification-thread] Failed to retrieve session rotation condition's session name");
+                       ERR("Failed to retrieve session rotation condition's session name");
                        goto end;
                }
 
@@ -1633,7 +1633,7 @@ struct lttng_session_trigger_list *lttng_session_trigger_list_build(
                trigger_count++;
        }
 
-       DBG("[notification-thread] Found %i triggers that apply to newly created session",
+       DBG("Found %i triggers that apply to newly created session",
                        trigger_count);
        return session_trigger_list;
 error:
@@ -1659,7 +1659,7 @@ struct session_info *find_or_create_session_info(
                        &iter);
        node = cds_lfht_iter_get_node(&iter);
        if (node) {
-               DBG("[notification-thread] Found session info of session \"%s\" (uid = %i, gid = %i)",
+               DBG("Found session info of session \"%s\" (uid = %i, gid = %i)",
                                name, uid, gid);
                session = caa_container_of(node, struct session_info,
                                sessions_ht_node);
@@ -1677,7 +1677,7 @@ struct session_info *find_or_create_session_info(
        session = session_info_create(name, uid, gid, trigger_list,
                        state->sessions_ht);
        if (!session) {
-               ERR("[notification-thread] Failed to allocation session info for session \"%s\" (uid = %i, gid = %i)",
+               ERR("Failed to allocation session info for session \"%s\" (uid = %i, gid = %i)",
                                name, uid, gid);
                lttng_session_trigger_list_destroy(trigger_list);
                goto error;
@@ -1715,7 +1715,7 @@ int handle_notification_thread_command_add_channel(
        struct cds_lfht_iter iter;
        struct session_info *session_info = NULL;
 
-       DBG("[notification-thread] Adding channel %s from session %s, channel key = %" PRIu64 " in %s domain",
+       DBG("Adding channel %s from session %s, channel key = %" PRIu64 " in %s domain",
                        channel_name, session_name, channel_key_int,
                        lttng_domain_type_str(channel_domain));
 
@@ -1757,7 +1757,7 @@ int handle_notification_thread_command_add_channel(
        }
        rcu_read_unlock();
 
-       DBG("[notification-thread] Found %i triggers that apply to newly added channel",
+       DBG("Found %i triggers that apply to newly added channel",
                        trigger_count);
        channel_trigger_list = zmalloc(sizeof(*channel_trigger_list));
        if (!channel_trigger_list) {
@@ -1817,7 +1817,7 @@ int handle_notification_thread_command_remove_channel(
        struct channel_key key = { .key = channel_key, .domain = domain };
        struct channel_info *channel_info;
 
-       DBG("[notification-thread] Removing channel key = %" PRIu64 " in %s domain",
+       DBG("Removing channel key = %" PRIu64 " in %s domain",
                        channel_key, lttng_domain_type_str(domain));
 
        rcu_read_lock();
@@ -1833,7 +1833,7 @@ int handle_notification_thread_command_remove_channel(
         * channel that doesn't exist.
         */
        if (!node) {
-               ERR("[notification-thread] Channel being removed is unknown to the notification thread");
+               ERR("Channel being removed is unknown to the notification thread");
                goto end;
        }
 
@@ -1921,7 +1921,7 @@ int handle_notification_thread_command_session_rotation(
        session_info->rotation.id = trace_archive_chunk_id;
        trigger_list = get_session_trigger_list(state, session_name);
        if (!trigger_list) {
-               DBG("[notification-thread] No triggers applying to session \"%s\" found",
+               DBG("No triggers applying to session \"%s\" found",
                                session_name);
                goto end;
        }
@@ -2034,14 +2034,14 @@ int handle_notification_thread_command_add_tracer_event_source(
 
        cds_list_add(&element->node, &state->tracer_event_sources_list);
 
-       DBG3("[notification-thread] Adding tracer event source fd to poll set: tracer_event_source_fd = %d, domain = '%s'",
+       DBG3("Adding tracer event source fd to poll set: tracer_event_source_fd = %d, domain = '%s'",
                        tracer_event_source_fd,
                        lttng_domain_type_str(domain_type));
 
        /* Adding the read side pipe to the event poll. */
        ret = lttng_poll_add(&state->events, tracer_event_source_fd, LPOLLIN | LPOLLERR);
        if (ret < 0) {
-               ERR("[notification-thread] Failed to add tracer event source to poll set: tracer_event_source_fd = %d, domain = '%s'",
+               ERR("Failed to add tracer event source to poll set: tracer_event_source_fd = %d, domain = '%s'",
                                tracer_event_source_fd,
                                lttng_domain_type_str(element->domain));
                cds_list_del(&element->node);
@@ -2066,13 +2066,13 @@ int drain_event_notifier_notification_pipe(
 
        ret = lttng_poll_create(&events, 1, LTTNG_CLOEXEC);
        if (ret < 0) {
-               ERR("[notification-thread] Error creating lttng_poll_event");
+               ERR("Error creating lttng_poll_event");
                goto end;
        }
 
        ret = lttng_poll_add(&events, pipe, LPOLLIN);
        if (ret < 0) {
-               ERR("[notification-thread] Error adding fd event notifier notification pipe to lttng_poll_event: fd = %d",
+               ERR("Error adding fd event notifier notification pipe to lttng_poll_event: fd = %d",
                                pipe);
                goto end;
        }
@@ -2100,7 +2100,7 @@ int drain_event_notifier_notification_pipe(
 
                ret = handle_one_event_notifier_notification(state, pipe, domain);
                if (ret) {
-                       ERR("[notification-thread] Error consuming an event notifier notification from pipe: fd = %d",
+                       ERR("Error consuming an event notifier notification from pipe: fd = %d",
                                        pipe);
                }
        }
@@ -2126,7 +2126,7 @@ int handle_notification_thread_command_remove_tracer_event_source(
                        continue;
                }
 
-               DBG("[notification-thread] Removed tracer event source from poll set: tracer_event_source_fd = %d, domain = '%s'",
+               DBG("Removed tracer event source from poll set: tracer_event_source_fd = %d, domain = '%s'",
                                tracer_event_source_fd,
                                lttng_domain_type_str(source_element->domain));
                cds_list_del(&source_element->node);
@@ -2149,14 +2149,14 @@ int handle_notification_thread_command_remove_tracer_event_source(
                goto end;
        }
 
-       DBG3("[notification-thread] Removing tracer event source from poll set: tracer_event_source_fd = %d, domain = '%s'",
+       DBG3("Removing tracer event source from poll set: tracer_event_source_fd = %d, domain = '%s'",
                        tracer_event_source_fd,
                        lttng_domain_type_str(source_element->domain));
 
        /* Removing the fd from the event poll set. */
        ret = lttng_poll_del(&state->events, tracer_event_source_fd);
        if (ret < 0) {
-               ERR("[notification-thread] Failed to remove tracer event source from poll set: tracer_event_source_fd = %d, domain = '%s'",
+               ERR("Failed to remove tracer event source from poll set: tracer_event_source_fd = %d, domain = '%s'",
                                tracer_event_source_fd,
                                lttng_domain_type_str(source_element->domain));
                cmd_result = LTTNG_ERR_FATAL;
@@ -2168,7 +2168,7 @@ int handle_notification_thread_command_remove_tracer_event_source(
        ret = drain_event_notifier_notification_pipe(state, tracer_event_source_fd,
                        source_element->domain);
        if (ret) {
-               ERR("[notification-thread] Error draining event notifier notification: tracer_event_source_fd = %d, domain = %s",
+               ERR("Error draining event notifier notification: tracer_event_source_fd = %d, domain = %s",
                                tracer_event_source_fd,
                                lttng_domain_type_str(source_element->domain));
                cmd_result = LTTNG_ERR_FATAL;
@@ -2404,7 +2404,7 @@ int bind_trigger_to_matching_session(struct lttng_trigger *trigger,
                status = lttng_condition_session_rotation_get_session_name(
                                condition, &session_name);
                if (status != LTTNG_CONDITION_STATUS_OK) {
-                       ERR("[notification-thread] Failed to bind trigger to session: unable to get 'session_rotation' condition's session name");
+                       ERR("Failed to bind trigger to session: unable to get 'session_rotation' condition's session name");
                        ret = -1;
                        goto end;
                }
@@ -2417,13 +2417,13 @@ int bind_trigger_to_matching_session(struct lttng_trigger *trigger,
 
        trigger_list = get_session_trigger_list(state, session_name);
        if (!trigger_list) {
-               DBG("[notification-thread] Unable to bind trigger applying to session \"%s\" as it is not yet known to the notification system",
+               DBG("Unable to bind trigger applying to session \"%s\" as it is not yet known to the notification system",
                                session_name);
                goto end;
 
        }
 
-       DBG("[notification-thread] Newly registered trigger bound to session \"%s\"",
+       DBG("Newly registered trigger bound to session \"%s\"",
                        session_name);
        ret = lttng_session_trigger_list_add(trigger_list, trigger);
 end:
@@ -2469,7 +2469,7 @@ int bind_trigger_to_matching_channels(struct lttng_trigger *trigger,
                CDS_INIT_LIST_HEAD(&trigger_list_element->node);
                trigger_list_element->trigger = trigger;
                cds_list_add(&trigger_list_element->node, &trigger_list->list);
-               DBG("[notification-thread] Newly registered trigger bound to channel \"%s\"",
+               DBG("Newly registered trigger bound to channel \"%s\"",
                                channel->name);
        }
 end:
@@ -2985,7 +2985,7 @@ void teardown_tracer_notifier(struct notification_thread_state *state,
                                trigger_tokens_ht_element->trigger);
 
                /* TODO talk to all app and remove it */
-               DBG("[notification-thread] Removed trigger from tokens_ht");
+               DBG("Removed trigger from tokens_ht");
                cds_lfht_del(state->trigger_tokens_ht,
                                &trigger_tokens_ht_element->node);
 
@@ -3040,7 +3040,7 @@ int handle_notification_thread_command_unregister_trigger(
                                continue;
                        }
 
-                       DBG("[notification-thread] Removed trigger from channel_triggers_ht");
+                       DBG("Removed trigger from channel_triggers_ht");
                        cds_list_del(&trigger_element->node);
                        /* A trigger can only appear once per channel */
                        break;
@@ -3105,7 +3105,7 @@ int handle_notification_thread_command(
        cds_list_del(&cmd->cmd_list_node);
        pthread_mutex_unlock(&handle->cmd_queue.lock);
 
-       DBG("[notification-thread] Received `%s` command",
+       DBG("Received `%s` command",
                        notification_command_type_str(cmd->type));
        switch (cmd->type) {
        case NOTIFICATION_COMMAND_TYPE_REGISTER_TRIGGER:
@@ -3220,7 +3220,7 @@ int handle_notification_thread_command(
                break;
        }
        default:
-               ERR("[notification-thread] Unknown internal command received");
+               ERR("Unknown internal command received");
                goto error_unlock;
        }
 
@@ -3294,7 +3294,7 @@ int handle_notification_thread_client_connect(
        int ret;
        struct notification_client *client;
 
-       DBG("[notification-thread] Handling new notification channel client connection");
+       DBG("Handling new notification channel client connection");
 
        client = zmalloc(sizeof(*client));
        if (!client) {
@@ -3312,14 +3312,14 @@ int handle_notification_thread_client_connect(
 
        ret = client_reset_inbound_state(client);
        if (ret) {
-               ERR("[notification-thread] Failed to reset client communication's inbound state");
+               ERR("Failed to reset client communication's inbound state");
                ret = 0;
                goto error;
        }
 
        ret = lttcomm_accept_unix_sock(state->notification_channel_socket);
        if (ret < 0) {
-               ERR("[notification-thread] Failed to accept new notification channel client connection");
+               ERR("Failed to accept new notification channel client connection");
                ret = 0;
                goto error;
        }
@@ -3328,13 +3328,13 @@ int handle_notification_thread_client_connect(
 
        ret = socket_set_non_blocking(client->socket);
        if (ret) {
-               ERR("[notification-thread] Failed to set new notification channel client connection socket as non-blocking");
+               ERR("Failed to set new notification channel client connection socket as non-blocking");
                goto error;
        }
 
        ret = lttcomm_setsockopt_creds_unix_sock(client->socket);
        if (ret < 0) {
-               ERR("[notification-thread] Failed to set socket options on new notification channel client socket");
+               ERR("Failed to set socket options on new notification channel client socket");
                ret = 0;
                goto error;
        }
@@ -3343,11 +3343,11 @@ int handle_notification_thread_client_connect(
                        LPOLLIN | LPOLLERR |
                        LPOLLHUP | LPOLLRDHUP);
        if (ret < 0) {
-               ERR("[notification-thread] Failed to add notification channel client socket to poll set");
+               ERR("Failed to add notification channel client socket to poll set");
                ret = 0;
                goto error;
        }
-       DBG("[notification-thread] Added new notification channel client socket (%i) to poll set",
+       DBG("Added new notification channel client socket (%i) to poll set",
                        client->socket);
 
        rcu_read_lock();
@@ -3387,7 +3387,7 @@ int notification_thread_client_disconnect(
 
        ret = lttng_poll_del(&state->events, client->socket);
        if (ret) {
-               ERR("[notification-thread] Failed to remove client socket %d from poll set",
+               ERR("Failed to remove client socket %d from poll set",
                                client->socket);
        }
 
@@ -3413,12 +3413,12 @@ int handle_notification_thread_client_disconnect(
        struct notification_client *client;
 
        rcu_read_lock();
-       DBG("[notification-thread] Closing client connection (socket fd = %i)",
+       DBG("Closing client connection (socket fd = %i)",
                        client_socket);
        client = get_client_from_socket(client_socket, state);
        if (!client) {
                /* Internal state corruption, fatal error. */
-               ERR("[notification-thread] Unable to find client (socket fd = %i)",
+               ERR("Unable to find client (socket fd = %i)",
                                client_socket);
                ret = -1;
                goto end;
@@ -3438,7 +3438,7 @@ int handle_notification_thread_client_disconnect_all(
        bool error_encoutered = false;
 
        rcu_read_lock();
-       DBG("[notification-thread] Closing all client connections");
+       DBG("Closing all client connections");
        cds_lfht_for_each_entry(state->client_socket_ht, &iter, client,
                        client_socket_ht_node) {
                int ret;
@@ -3548,14 +3548,14 @@ enum client_transmission_status client_flush_outgoing_queue(
 
        /* Send data. */
        to_send_count = pv.buffer.size;
-       DBG("[notification-thread] Flushing client (socket fd = %i) outgoing queue",
+       DBG("Flushing client (socket fd = %i) outgoing queue",
                        client->socket);
 
        ret = lttcomm_send_unix_sock_non_block(client->socket,
                        pv.buffer.data,
                        to_send_count);
        if ((ret >= 0 && ret < to_send_count)) {
-               DBG("[notification-thread] Client (socket fd = %i) outgoing queue could not be completely flushed",
+               DBG("Client (socket fd = %i) outgoing queue could not be completely flushed",
                                client->socket);
                to_send_count -= max(ret, 0);
 
@@ -3574,7 +3574,7 @@ enum client_transmission_status client_flush_outgoing_queue(
                goto end;
        } else if (ret < 0) {
                /* Generic error, disable the client's communication. */
-               ERR("[notification-thread] Failed to flush outgoing queue, disconnecting client (socket fd = %i)",
+               ERR("Failed to flush outgoing queue, disconnecting client (socket fd = %i)",
                                client->socket);
                client->communication.active = false;
                status = CLIENT_TRANSMISSION_STATUS_FAIL;
@@ -3606,7 +3606,7 @@ send_fds:
                        client->socket, &pv);
        if (ret < 0) {
                /* Generic error, disable the client's communication. */
-               ERR("[notification-thread] Failed to flush outgoing fds queue, disconnecting client (socket fd = %i)",
+               ERR("Failed to flush outgoing fds queue, disconnecting client (socket fd = %i)",
                                client->socket);
                client->communication.active = false;
                status = CLIENT_TRANSMISSION_STATUS_FAIL;
@@ -3671,7 +3671,7 @@ int client_send_command_reply(struct notification_client *client,
 
        memcpy(buffer, &msg, sizeof(msg));
        memcpy(buffer + sizeof(msg), &reply, sizeof(reply));
-       DBG("[notification-thread] Send command reply (%i)", (int) status);
+       DBG("Send command reply (%i)", (int) status);
 
        pthread_mutex_lock(&client->lock);
        if (client->communication.outbound.queued_command_reply) {
@@ -3726,7 +3726,7 @@ int client_handle_message_unknown(struct notification_client *client,
 
        if (msg->size == 0 ||
                        msg->size > DEFAULT_MAX_NOTIFICATION_CLIENT_MESSAGE_PAYLOAD_SIZE) {
-               ERR("[notification-thread] Invalid notification channel message: length = %u",
+               ERR("Invalid notification channel message: length = %u",
                                msg->size);
                ret = -1;
                goto end;
@@ -3739,7 +3739,7 @@ int client_handle_message_unknown(struct notification_client *client,
                break;
        default:
                ret = -1;
-               ERR("[notification-thread] Invalid notification channel message: unexpected message type");
+               ERR("Invalid notification channel message: unexpected message type");
                goto end;
        }
 
@@ -3785,7 +3785,7 @@ int client_handle_message_handshake(struct notification_client *client,
        client->major = handshake_client->major;
        client->minor = handshake_client->minor;
        if (!client->communication.inbound.creds_received) {
-               ERR("[notification-thread] No credentials received from client");
+               ERR("No credentials received from client");
                ret = -1;
                goto end;
        }
@@ -3794,7 +3794,7 @@ int client_handle_message_handshake(struct notification_client *client,
                        &client->communication.inbound.creds);
        client->gid = LTTNG_SOCK_GET_GID_CRED(
                        &client->communication.inbound.creds);
-       DBG("[notification-thread] Received handshake from client (uid = %u, gid = %u) with version %i.%i",
+       DBG("Received handshake from client (uid = %u, gid = %u) with version %i.%i",
                        client->uid, client->gid, (int) client->major,
                        (int) client->minor);
 
@@ -3809,7 +3809,7 @@ int client_handle_message_handshake(struct notification_client *client,
                        &client->communication.outbound.payload.buffer, send_buffer,
                        sizeof(send_buffer));
        if (ret) {
-               ERR("[notification-thread] Failed to send protocol version to notification channel client");
+               ERR("Failed to send protocol version to notification channel client");
                goto end_unlock;
        }
 
@@ -3820,14 +3820,14 @@ int client_handle_message_handshake(struct notification_client *client,
        /* Set reception state to receive the next message header. */
        ret = client_reset_inbound_state(client);
        if (ret) {
-               ERR("[notification-thread] Failed to reset client communication's inbound state");
+               ERR("Failed to reset client communication's inbound state");
                goto end;
        }
 
        /* Flushes the outgoing queue. */
        ret = client_send_command_reply(client, state, status);
        if (ret) {
-               ERR("[notification-thread] Failed to send reply to notification channel client");
+               ERR("Failed to send reply to notification channel client");
                goto end;
        }
 
@@ -3862,7 +3862,7 @@ int client_handle_message_subscription(
        expected_condition_size = client->communication.inbound.payload.buffer.size;
        ret = lttng_condition_create_from_payload(&condition_view, &condition);
        if (ret != expected_condition_size) {
-               ERR("[notification-thread] Malformed condition received from client");
+               ERR("Malformed condition received from client");
                goto end;
        }
 
@@ -3882,13 +3882,13 @@ int client_handle_message_subscription(
        /* Set reception state to receive the next message header. */
        ret = client_reset_inbound_state(client);
        if (ret) {
-               ERR("[notification-thread] Failed to reset client communication's inbound state");
+               ERR("Failed to reset client communication's inbound state");
                goto end;
        }
 
        ret = client_send_command_reply(client, state, status);
        if (ret) {
-               ERR("[notification-thread] Failed to send reply to notification channel client");
+               ERR("Failed to send reply to notification channel client");
                goto end;
        }
 
@@ -3907,7 +3907,7 @@ int client_dispatch_message(struct notification_client *client,
                        client->communication.inbound.msg_type !=
                                LTTNG_NOTIFICATION_CHANNEL_MESSAGE_TYPE_UNKNOWN &&
                        !client->validated) {
-               WARN("[notification-thread] client attempted a command before handshake");
+               WARN("client attempted a command before handshake");
                ret = -1;
                goto end;
        }
@@ -4102,7 +4102,7 @@ bool evaluate_buffer_usage_condition(const struct lttng_condition *condition,
 
        condition_type = lttng_condition_get_type(condition);
        if (condition_type == LTTNG_CONDITION_TYPE_BUFFER_USAGE_LOW) {
-               DBG("[notification-thread] Low buffer usage condition being evaluated: threshold = %" PRIu64 ", highest usage = %" PRIu64,
+               DBG("Low buffer usage condition being evaluated: threshold = %" PRIu64 ", highest usage = %" PRIu64,
                                threshold, sample->highest_usage);
 
                /*
@@ -4113,7 +4113,7 @@ bool evaluate_buffer_usage_condition(const struct lttng_condition *condition,
                        result = true;
                }
        } else {
-               DBG("[notification-thread] High buffer usage condition being evaluated: threshold = %" PRIu64 ", highest usage = %" PRIu64,
+               DBG("High buffer usage condition being evaluated: threshold = %" PRIu64 ", highest usage = %" PRIu64,
                                threshold, sample->highest_usage);
 
                /*
@@ -4140,7 +4140,7 @@ bool evaluate_session_consumed_size_condition(
                                parent);
 
        threshold = size_condition->consumed_threshold_bytes.value;
-       DBG("[notification-thread] Session consumed size condition being evaluated: threshold = %" PRIu64 ", current size = %" PRIu64,
+       DBG("Session consumed size condition being evaluated: threshold = %" PRIu64 ", current size = %" PRIu64,
                        threshold, session_consumed_size);
        return session_consumed_size >= threshold;
 }
@@ -4356,7 +4356,7 @@ int notification_client_list_send_evaluation(
 
        ret = lttng_notification_serialize(&notification, &msg_payload);
        if (ret) {
-               ERR("[notification-thread] Failed to serialize notification");
+               ERR("Failed to serialize notification");
                ret = -1;
                goto end;
        }
@@ -4402,17 +4402,17 @@ int notification_client_list_send_evaluation(
                                 * Client is not allowed to monitor this
                                 * object.
                                 */
-                               DBG("[notification-thread] Skipping client at it does not have the object permission to receive notification for this trigger");
+                               DBG("Skipping client at it does not have the object permission to receive notification for this trigger");
                                goto skip_client;
                        }
                }
 
                if (client->uid != lttng_credentials_get_uid(trigger_creds)) {
-                       DBG("[notification-thread] Skipping client at it does not have the permission to receive notification for this trigger");
+                       DBG("Skipping client at it does not have the permission to receive notification for this trigger");
                        goto skip_client;
                }
 
-               DBG("[notification-thread] Sending notification to client (fd = %i, %zu bytes)",
+               DBG("Sending notification to client (fd = %i, %zu bytes)",
                                client->socket, msg_payload.buffer.size);
 
                if (client_has_outbound_data_left(client)) {
@@ -4523,21 +4523,21 @@ struct lttng_event_notifier_notification *recv_one_event_notifier_notification(
        }
 
        if (capture_buffer_size > MAX_CAPTURE_SIZE) {
-               ERR("[notification-thread] Event notifier has a capture payload size which exceeds the maximum allowed size: capture_payload_size = %zu bytes, max allowed size = %d bytes",
+               ERR("Event notifier has a capture payload size which exceeds the maximum allowed size: capture_payload_size = %zu bytes, max allowed size = %d bytes",
                                capture_buffer_size, MAX_CAPTURE_SIZE);
                goto end;
        }
 
        capture_buffer = zmalloc(capture_buffer_size);
        if (!capture_buffer) {
-               ERR("[notification-thread] Failed to allocate capture buffer");
+               ERR("Failed to allocate capture buffer");
                goto end;
        }
 
        /* Fetch additional payload (capture). */
        ret = lttng_read(notification_pipe_read_fd, capture_buffer, capture_buffer_size);
        if (ret != capture_buffer_size) {
-               ERR("[notification-thread] Failed to read from event source pipe (fd = %i)",
+               ERR("Failed to read from event source pipe (fd = %i)",
                                notification_pipe_read_fd);
                goto end;
        }
@@ -4616,7 +4616,7 @@ int dispatch_one_event_notifier_notification(struct notification_thread_state *s
                        notification->capture_buf_size, false);
 
        if (evaluation == NULL) {
-               ERR("[notification-thread] Failed to create event rule hit evaluation while creating and enqueuing action executor job");
+               ERR("Failed to create event rule hit evaluation while creating and enqueuing action executor job");
                ret = -1;
                goto end_unlock;
        }
@@ -4706,14 +4706,14 @@ int handle_one_event_notifier_notification(
        notification = recv_one_event_notifier_notification(pipe, domain);
        if (notification == NULL) {
                /* Reception failed, don't consider it fatal. */
-               ERR("[notification-thread] Error receiving an event notifier notification from tracer: fd = %i, domain = %s",
+               ERR("Error receiving an event notifier notification from tracer: fd = %i, domain = %s",
                                pipe, lttng_domain_type_str(domain));
                goto end;
        }
 
        ret = dispatch_one_event_notifier_notification(state, notification);
        if (ret) {
-               ERR("[notification-thread] Error dispatching an event notifier notification from tracer: fd = %i, domain = %s",
+               ERR("Error dispatching an event notifier notification from tracer: fd = %i, domain = %s",
                                pipe, lttng_domain_type_str(domain));
                goto end;
        }
@@ -4751,7 +4751,7 @@ int handle_notification_thread_channel_sample(
         */
        ret = lttng_read(pipe, &sample_msg, sizeof(sample_msg));
        if (ret != sizeof(sample_msg)) {
-               ERR("[notification-thread] Failed to read from monitoring pipe (fd = %i)",
+               ERR("Failed to read from monitoring pipe (fd = %i)",
                                pipe);
                ret = -1;
                goto end;
@@ -4780,14 +4780,14 @@ int handle_notification_thread_channel_sample(
                 * channel's destruction before we get a chance to process that
                 * sample.
                 */
-               DBG("[notification-thread] Received a sample for an unknown channel from consumerd, key = %" PRIu64 " in %s domain",
+               DBG("Received a sample for an unknown channel from consumerd, key = %" PRIu64 " in %s domain",
                                latest_sample.key.key,
                                lttng_domain_type_str(domain));
                goto end_unlock;
        }
        channel_info = caa_container_of(node, struct channel_info,
                        channels_ht_node);
-       DBG("[notification-thread] Handling channel sample for channel %s (key = %" PRIu64 ") in session %s (highest usage = %" PRIu64 ", lowest usage = %" PRIu64", total consumed = %" PRIu64")",
+       DBG("Handling channel sample for channel %s (key = %" PRIu64 ") in session %s (highest usage = %" PRIu64 ", lowest usage = %" PRIu64", total consumed = %" PRIu64")",
                        channel_info->name,
                        latest_sample.key.key,
                        channel_info->session_info->name,

diff --git a/src/bin/lttng-sessiond/notification-thread.c b/src/bin/lttng-sessiond/notification-thread.c
index 56f1124fbfbfbde93c7a1ba9959182221e58095d..d2f5a944129d21e49c9b4a9b2b9ce1ec85952d56 100644 (file)
--- a/src/bin/lttng-sessiond/notification-thread.c
+++ b/src/bin/lttng-sessiond/notification-thread.c
@@ -196,7 +196,7 @@ void notification_channel_socket_destroy(int fd)
        int ret;
        char *sock_path = get_notification_channel_sock_path();
 
-       DBG("[notification-thread] Destroying notification channel socket");
+       DBG("Destroying notification channel socket");
 
        if (sock_path) {
                ret = unlink(sock_path);
@@ -218,12 +218,12 @@ int notification_channel_socket_create(void)
        int fd = -1, ret;
        char *sock_path = get_notification_channel_sock_path();
 
-       DBG("[notification-thread] Creating notification channel UNIX socket at %s",
+       DBG("Creating notification channel UNIX socket at %s",
                        sock_path);
 
        ret = lttcomm_create_unix_sock(sock_path);
        if (ret < 0) {
-               ERR("[notification-thread] Failed to create notification socket");
+               ERR("Failed to create notification socket");
                goto error;
        }
        fd = ret;
@@ -253,7 +253,7 @@ int notification_channel_socket_create(void)
                }
        }
 
-       DBG("[notification-thread] Notification channel UNIX socket created (fd = %i)",
+       DBG("Notification channel UNIX socket created (fd = %i)",
                        fd);
        free(sock_path);
        return fd;
@@ -288,27 +288,27 @@ int init_poll_set(struct lttng_poll_event *poll_set,
        ret = lttng_poll_add(poll_set, notification_channel_socket,
                        LPOLLIN | LPOLLERR | LPOLLHUP | LPOLLRDHUP);
        if (ret < 0) {
-               ERR("[notification-thread] Failed to add notification channel socket to pollset");
+               ERR("Failed to add notification channel socket to pollset");
                goto error;
        }
        ret = lttng_poll_add(poll_set, lttng_pipe_get_readfd(handle->cmd_queue.event_pipe),
                        LPOLLIN | LPOLLERR);
        if (ret < 0) {
-               ERR("[notification-thread] Failed to add notification command queue event fd to pollset");
+               ERR("Failed to add notification command queue event fd to pollset");
                goto error;
        }
        ret = lttng_poll_add(poll_set,
                        handle->channel_monitoring_pipes.ust32_consumer,
                        LPOLLIN | LPOLLERR);
        if (ret < 0) {
-               ERR("[notification-thread] Failed to add ust-32 channel monitoring pipe fd to pollset");
+               ERR("Failed to add ust-32 channel monitoring pipe fd to pollset");
                goto error;
        }
        ret = lttng_poll_add(poll_set,
                        handle->channel_monitoring_pipes.ust64_consumer,
                        LPOLLIN | LPOLLERR);
        if (ret < 0) {
-               ERR("[notification-thread] Failed to add ust-64 channel monitoring pipe fd to pollset");
+               ERR("Failed to add ust-64 channel monitoring pipe fd to pollset");
                goto error;
        }
        if (handle->channel_monitoring_pipes.kernel_consumer < 0) {
@@ -318,7 +318,7 @@ int init_poll_set(struct lttng_poll_event *poll_set,
                        handle->channel_monitoring_pipes.kernel_consumer,
                        LPOLLIN | LPOLLERR);
        if (ret < 0) {
-               ERR("[notification-thread] Failed to add kernel channel monitoring pipe fd to pollset");
+               ERR("Failed to add kernel channel monitoring pipe fd to pollset");
                goto error;
        }
 end:
@@ -437,10 +437,10 @@ int init_thread_state(struct notification_thread_handle *handle,
                goto end;
        }
 
-       DBG("[notification-thread] Listening on notification channel socket");
+       DBG("Listening on notification channel socket");
        ret = lttcomm_listen_unix_sock(state->notification_channel_socket);
        if (ret < 0) {
-               ERR("[notification-thread] Listen failed on notification channel socket");
+               ERR("Listen failed on notification channel socket");
                goto error;
        }
 
@@ -544,7 +544,7 @@ int handle_channel_monitoring_pipe(int fd, uint32_t revents,
        if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) {
                ret = lttng_poll_del(&state->events, fd);
                if (ret) {
-                       ERR("[notification-thread] Failed to remove consumer monitoring pipe from poll set");
+                       ERR("Failed to remove consumer monitoring pipe from poll set");
                }
                goto end;
        }
@@ -552,7 +552,7 @@ int handle_channel_monitoring_pipe(int fd, uint32_t revents,
        ret = handle_notification_thread_channel_sample(
                        state, fd, domain);
        if (ret) {
-               ERR("[notification-thread] Consumer sample handling error occurred");
+               ERR("Consumer sample handling error occurred");
                ret = -1;
                goto end;
        }
@@ -571,7 +571,7 @@ static int handle_event_notification_pipe(int event_source_fd,
                ret = handle_notification_thread_remove_tracer_event_source_no_result(
                                state, event_source_fd);
                if (ret) {
-                       ERR("[notification-thread] Failed to remove event notification pipe from poll set: fd = %d",
+                       ERR("Failed to remove event notification pipe from poll set: fd = %d",
                                        event_source_fd);
                }
                goto end;
@@ -591,7 +591,7 @@ static int handle_event_notification_pipe(int event_source_fd,
        ret = handle_notification_thread_event_notification(
                        state, event_source_fd, domain);
        if (ret) {
-               ERR("[notification-thread] Event notification handling error occurred for fd: %d",
+               ERR("Event notification handling error occurred for fd: %d",
                                event_source_fd);
                ret = -1;
                goto end;
@@ -637,14 +637,14 @@ void *thread_notification(void *data)
        struct notification_thread_state state;
        enum lttng_domain_type domain;
 
-       DBG("[notification-thread] Started notification thread");
+       DBG("Started notification thread");
 
        health_register(the_health_sessiond, HEALTH_SESSIOND_TYPE_NOTIFICATION);
        rcu_register_thread();
        rcu_thread_online();
 
        if (!handle) {
-               ERR("[notification-thread] Invalid thread context provided");
+               ERR("Invalid thread context provided");
                goto end;
        }
 
@@ -663,9 +663,9 @@ void *thread_notification(void *data)
                int fd_count, i;
 
                health_poll_entry();
-               DBG("[notification-thread] Entering poll wait");
+               DBG("Entering poll wait");
                ret = lttng_poll_wait(&state.events, -1);
-               DBG("[notification-thread] Poll wait returned (%i)", ret);
+               DBG("Poll wait returned (%i)", ret);
                health_poll_exit();
                if (ret < 0) {
                        /*
@@ -674,7 +674,7 @@ void *thread_notification(void *data)
                        if (errno == EINTR) {
                                continue;
                        }
-                       ERR("[notification-thread] Error encountered during lttng_poll_wait (%i)", ret);
+                       ERR("Error encountered during lttng_poll_wait (%i)", ret);
                        goto error;
                }
 
@@ -689,7 +689,7 @@ void *thread_notification(void *data)
                        int fd = LTTNG_POLL_GETFD(&state.events, i);
                        uint32_t revents = LTTNG_POLL_GETEV(&state.events, i);
 
-                       DBG("[notification-thread] Handling fd (%i) activity (%u)", fd, revents);
+                       DBG("Handling fd (%i) activity (%u)", fd, revents);
 
                        if (fd == state.notification_channel_socket) {
                                if (revents & LPOLLIN) {
@@ -700,17 +700,17 @@ void *thread_notification(void *data)
                                        }
                                } else if (revents &
                                                (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) {
-                                       ERR("[notification-thread] Notification socket poll error");
+                                       ERR("Notification socket poll error");
                                        goto error;
                                } else {
-                                       ERR("[notification-thread] Unexpected poll events %u for notification socket %i", revents, fd);
+                                       ERR("Unexpected poll events %u for notification socket %i", revents, fd);
                                        goto error;
                                }
                        } else if (fd == lttng_pipe_get_readfd(handle->cmd_queue.event_pipe)) {
                                ret = handle_notification_thread_command(handle,
                                                &state);
                                if (ret < 0) {
-                                       DBG("[notification-thread] Error encountered while servicing command queue");
+                                       DBG("Error encountered while servicing command queue");
                                        goto error;
                                } else if (ret > 0) {
                                        goto exit;

diff --git a/src/bin/lttng-sessiond/rotation-thread.c b/src/bin/lttng-sessiond/rotation-thread.c
index 31e65113654c72258592f0d10bc64fc8f0364f90..89a148a74c2bdd1393bb274afb4ae9f0f545caa1 100644 (file)
--- a/src/bin/lttng-sessiond/rotation-thread.c
+++ b/src/bin/lttng-sessiond/rotation-thread.c
@@ -252,7 +252,7 @@ int init_poll_set(struct lttng_poll_event *poll_set,
                        lttng_pipe_get_readfd(handle->quit_pipe),
                        LPOLLIN | LPOLLERR);
        if (ret < 0) {
-               ERR("[rotation-thread] Failed to add quit pipe read fd to poll set");
+               ERR("Failed to add quit pipe read fd to poll set");
                goto error;
        }
 
@@ -260,7 +260,7 @@ int init_poll_set(struct lttng_poll_event *poll_set,
                        lttng_pipe_get_readfd(handle->rotation_timer_queue->event_pipe),
                        LPOLLIN | LPOLLERR);
        if (ret < 0) {
-               ERR("[rotation-thread] Failed to add rotate_pending fd to poll set");
+               ERR("Failed to add rotate_pending fd to poll set");
                goto error;
        }
 
@@ -290,21 +290,21 @@ int init_thread_state(struct rotation_thread_handle *handle,
 
        ret = init_poll_set(&state->events, handle);
        if (ret) {
-               ERR("[rotation-thread] Failed to initialize rotation thread poll set");
+               ERR("Failed to initialize rotation thread poll set");
                goto end;
        }
 
        rotate_notification_channel = lttng_notification_channel_create(
                        lttng_session_daemon_notification_endpoint);
        if (!rotate_notification_channel) {
-               ERR("[rotation-thread] Could not create notification channel");
+               ERR("Could not create notification channel");
                ret = -1;
                goto end;
        }
        ret = lttng_poll_add(&state->events, rotate_notification_channel->socket,
                        LPOLLIN | LPOLLERR);
        if (ret < 0) {
-               ERR("[rotation-thread] Failed to add notification fd to pollset");
+               ERR("Failed to add notification fd to pollset");
                goto end;
        }
 
@@ -398,7 +398,7 @@ end:
                                session->chunk_being_archived,
                                &chunk_being_archived_id);
                assert(chunk_status == LTTNG_TRACE_CHUNK_STATUS_OK);
-               DBG("[rotation-thread] Rotation of trace archive %" PRIu64 " of session \"%s\" is complete on all consumers",
+               DBG("Rotation of trace archive %" PRIu64 " of session \"%s\" is complete on all consumers",
                                chunk_being_archived_id,
                                session->name);
        }
@@ -438,7 +438,7 @@ int check_session_rotation_pending(struct ltt_session *session,
                        &chunk_being_archived_id);
        assert(chunk_status == LTTNG_TRACE_CHUNK_STATUS_OK);
 
-       DBG("[rotation-thread] Checking for pending rotation on session \"%s\", trace archive %" PRIu64,
+       DBG("Checking for pending rotation on session \"%s\", trace archive %" PRIu64,
                        session->name, chunk_being_archived_id);
 
        /*
@@ -486,7 +486,7 @@ int check_session_rotation_pending(struct ltt_session *session,
                                session->last_archived_chunk_id.value,
                                location);
                if (ret != LTTNG_OK) {
-                       ERR("[rotation-thread] Failed to notify notification thread of completed rotation for session %s",
+                       ERR("Failed to notify notification thread of completed rotation for session %s",
                                        session->name);
                }
        }
@@ -499,7 +499,7 @@ check_ongoing_rotation:
                                &chunk_being_archived_id);
                assert(chunk_status == LTTNG_TRACE_CHUNK_STATUS_OK);
 
-               DBG("[rotation-thread] Rotation of trace archive %" PRIu64 " is still pending for session %s",
+               DBG("Rotation of trace archive %" PRIu64 " is still pending for session %s",
                                chunk_being_archived_id, session->name);
                ret = timer_session_rotation_pending_check_start(session,
                                DEFAULT_ROTATE_PENDING_TIMER);
@@ -521,17 +521,17 @@ int launch_session_rotation(struct ltt_session *session)
        int ret;
        struct lttng_rotate_session_return rotation_return;
 
-       DBG("[rotation-thread] Launching scheduled time-based rotation on session \"%s\"",
+       DBG("Launching scheduled time-based rotation on session \"%s\"",
                        session->name);
 
        ret = cmd_rotate_session(session, &rotation_return, false,
                LTTNG_TRACE_CHUNK_COMMAND_TYPE_MOVE_TO_COMPLETED);
        if (ret == LTTNG_OK) {
-               DBG("[rotation-thread] Scheduled time-based rotation successfully launched on session \"%s\"",
+               DBG("Scheduled time-based rotation successfully launched on session \"%s\"",
                                session->name);
        } else {
                /* Don't consider errors as fatal. */
-               DBG("[rotation-thread] Scheduled time-based rotation aborted for session %s: %s",
+               DBG("Scheduled time-based rotation aborted for session %s: %s",
                                session->name, lttng_strerror(ret));
        }
        return 0;
@@ -582,7 +582,7 @@ int handle_job_queue(struct rotation_thread_handle *handle,
                session_lock_list();
                session = job->session;
                if (!session) {
-                       DBG("[rotation-thread] Session \"%s\" not found",
+                       DBG("Session \"%s\" not found",
                                        session->name);
                        /*
                         * This is a non-fatal error, and we cannot report it to
@@ -635,7 +635,7 @@ int handle_condition(const struct lttng_condition *condition,
 
        if (condition_type != LTTNG_CONDITION_TYPE_SESSION_CONSUMED_SIZE) {
                ret = -1;
-               ERR("[rotation-thread] Condition type and session usage type are not the same");
+               ERR("Condition type and session usage type are not the same");
                goto end;
        }
 
@@ -643,14 +643,14 @@ int handle_condition(const struct lttng_condition *condition,
        condition_status = lttng_condition_session_consumed_size_get_session_name(
                        condition, &condition_session_name);
        if (condition_status != LTTNG_CONDITION_STATUS_OK) {
-               ERR("[rotation-thread] Session name could not be fetched");
+               ERR("Session name could not be fetched");
                ret = -1;
                goto end;
        }
        evaluation_status = lttng_evaluation_session_consumed_size_get_consumed_size(evaluation,
                        &consumed);
        if (evaluation_status != LTTNG_EVALUATION_STATUS_OK) {
-               ERR("[rotation-thread] Failed to get evaluation");
+               ERR("Failed to get evaluation");
                ret = -1;
                goto end;
        }
@@ -660,7 +660,7 @@ int handle_condition(const struct lttng_condition *condition,
        if (!session) {
                ret = -1;
                session_unlock_list();
-               ERR("[rotation-thread] Session \"%s\" not found",
+               ERR("Session \"%s\" not found",
                                condition_session_name);
                goto end;
        }
@@ -677,7 +677,7 @@ int handle_condition(const struct lttng_condition *condition,
        if (ret == -LTTNG_ERR_ROTATION_PENDING) {
                DBG("Rotate already pending, subscribe to the next threshold value");
        } else if (ret != LTTNG_OK) {
-               ERR("[rotation-thread] Failed to rotate on size notification with error: %s",
+               ERR("Failed to rotate on size notification with error: %s",
                                lttng_strerror(ret));
                ret = -1;
                goto end_unlock;
@@ -686,7 +686,7 @@ int handle_condition(const struct lttng_condition *condition,
                        consumed + session->rotate_size,
                        notification_thread_handle);
        if (ret) {
-               ERR("[rotation-thread] Failed to subscribe to session consumed size condition");
+               ERR("Failed to subscribe to session consumed size condition");
                goto end_unlock;
        }
        ret = 0;
@@ -714,7 +714,7 @@ int handle_notification_channel(int fd,
        status = lttng_notification_channel_has_pending_notification(
                        rotate_notification_channel, &notification_pending);
        if (status != LTTNG_NOTIFICATION_CHANNEL_STATUS_OK) {
-               ERR("[rotation-thread] Error occurred while checking for pending notification");
+               ERR("Error occurred while checking for pending notification");
                ret = -1;
                goto end;
        }
@@ -766,14 +766,14 @@ void *thread_rotation(void *data)
        struct rotation_thread thread;
        int queue_pipe_fd;
 
-       DBG("[rotation-thread] Started rotation thread");
+       DBG("Started rotation thread");
        rcu_register_thread();
        rcu_thread_online();
        health_register(the_health_sessiond, HEALTH_SESSIOND_TYPE_ROTATION);
        health_code_update();
 
        if (!handle) {
-               ERR("[rotation-thread] Invalid thread context provided");
+               ERR("Invalid thread context provided");
                goto end;
        }
 
@@ -790,9 +790,9 @@ void *thread_rotation(void *data)
                int fd_count, i;
 
                health_poll_entry();
-               DBG("[rotation-thread] Entering poll wait");
+               DBG("Entering poll wait");
                ret = lttng_poll_wait(&thread.events, -1);
-               DBG("[rotation-thread] Poll wait returned (%i)", ret);
+               DBG("Poll wait returned (%i)", ret);
                health_poll_exit();
                if (ret < 0) {
                        /*
@@ -801,7 +801,7 @@ void *thread_rotation(void *data)
                        if (errno == EINTR) {
                                continue;
                        }
-                       ERR("[rotation-thread] Error encountered during lttng_poll_wait (%i)", ret);
+                       ERR("Error encountered during lttng_poll_wait (%i)", ret);
                        goto error;
                }
 
@@ -810,11 +810,11 @@ void *thread_rotation(void *data)
                        int fd = LTTNG_POLL_GETFD(&thread.events, i);
                        uint32_t revents = LTTNG_POLL_GETEV(&thread.events, i);
 
-                       DBG("[rotation-thread] Handling fd (%i) activity (%u)",
+                       DBG("Handling fd (%i) activity (%u)",
                                        fd, revents);
 
                        if (revents & LPOLLERR) {
-                               ERR("[rotation-thread] Polling returned an error on fd %i", fd);
+                               ERR("Polling returned an error on fd %i", fd);
                                goto error;
                        }
 
@@ -822,7 +822,7 @@ void *thread_rotation(void *data)
                                ret = handle_notification_channel(fd, handle,
                                                &thread);
                                if (ret) {
-                                       ERR("[rotation-thread] Error occurred while handling activity on notification channel socket");
+                                       ERR("Error occurred while handling activity on notification channel socket");
                                        goto error;
                                }
                        } else {
@@ -837,7 +837,7 @@ void *thread_rotation(void *data)
                                ret = handle_job_queue(handle, &thread,
                                                handle->rotation_timer_queue);
                                if (ret) {
-                                       ERR("[rotation-thread] Failed to handle rotation timer pipe event");
+                                       ERR("Failed to handle rotation timer pipe event");
                                        goto error;
                                }
 
@@ -846,11 +846,11 @@ void *thread_rotation(void *data)
 
                                        ret = lttng_read(fd, &buf, 1);
                                        if (ret != 1) {
-                                               ERR("[rotation-thread] Failed to read from wakeup pipe (fd = %i)", fd);
+                                               ERR("Failed to read from wakeup pipe (fd = %i)", fd);
                                                goto error;
                                        }
                                } else {
-                                       DBG("[rotation-thread] Quit pipe activity");
+                                       DBG("Quit pipe activity");
                                        goto exit;
                                }
                        }
@@ -858,7 +858,7 @@ void *thread_rotation(void *data)
        }
 exit:
 error:
-       DBG("[rotation-thread] Exit");
+       DBG("Thread exit");
        fini_thread_state(&thread);
 end:
        health_unregister(the_health_sessiond);

diff --git a/src/bin/lttng-sessiond/timer.c b/src/bin/lttng-sessiond/timer.c
index bf56d9306449634157951ed690aad73bc8c7ba7d..d87b5d2d0d20c247a803c150f900b64aa0ef14e1 100644 (file)
--- a/src/bin/lttng-sessiond/timer.c
+++ b/src/bin/lttng-sessiond/timer.c
@@ -394,12 +394,12 @@ void *thread_timer(void *data)
                         * still fire.
                         */
                } else {
-                       ERR("Unexpected signal %d\n", info.si_signo);
+                       ERR("Unexpected signal %d", info.si_signo);
                }
        }
 
 end:
-       DBG("[timer-thread] Exit");
+       DBG("Thread exit");
        health_unregister(the_health_sessiond);
        rcu_thread_offline();
        rcu_unregister_thread();