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);
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;
}
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;
}
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;
}
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:
&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;
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;
&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:
}
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;
}
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);
&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);
* 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;
}
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;
}
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:
&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);
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;
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));
}
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) {
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();
* 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;
}
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;
}
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);
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;
}
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);
}
}
}
static
-int handle_notification_thread_command_remove_tracer_event_source(
- struct notification_thread_state *state,
- int tracer_event_source_fd,
- enum lttng_error_code *_cmd_result)
+struct notification_event_tracer_event_source_element *
+find_tracer_event_source_element(struct notification_thread_state *state,
+ int tracer_event_source_fd)
{
- int ret = 0;
- bool found = false;
- enum lttng_error_code cmd_result = LTTNG_OK;
- struct notification_event_tracer_event_source_element *source_element = NULL, *tmp;
+ struct notification_event_tracer_event_source_element *source_element;
- cds_list_for_each_entry_safe(source_element, tmp,
+ cds_list_for_each_entry(source_element,
&state->tracer_event_sources_list, node) {
- if (source_element->fd != tracer_event_source_fd) {
- continue;
+ if (source_element->fd == tracer_event_source_fd) {
+ goto end;
}
-
- DBG("[notification-thread] 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);
- found = true;
- break;
}
- if (!found) {
- /*
- * This is temporarily allowed since the poll activity set is
- * not properly cleaned-up for the moment. This is adressed in
- * an upcoming fix.
- */
- source_element = NULL;
- goto end;
- }
+ source_element = NULL;
+end:
+ return NULL;
+}
- if (!source_element->is_fd_in_poll_set) {
- /* Skip the poll set removal. */
- goto end;
- }
+static
+int remove_tracer_event_source_from_pollset(
+ struct notification_thread_state *state,
+ struct notification_event_tracer_event_source_element *source_element)
+{
+ int ret = 0;
- DBG3("[notification-thread] Removing tracer event source from poll set: tracer_event_source_fd = %d, domain = '%s'",
- tracer_event_source_fd,
+ assert(source_element->is_fd_in_poll_set);
+
+ DBG3("Removing tracer event source from poll set: tracer_event_source_fd = %d, domain = '%s'",
+ source_element->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);
+ ret = lttng_poll_del(&state->events, source_element->fd);
if (ret < 0) {
- ERR("[notification-thread] Failed to remove tracer event source from poll set: tracer_event_source_fd = %d, domain = '%s'",
- tracer_event_source_fd,
+ ERR("Failed to remove tracer event source from poll set: tracer_event_source_fd = %d, domain = '%s'",
+ source_element->fd,
lttng_domain_type_str(source_element->domain));
- cmd_result = LTTNG_ERR_FATAL;
+ ret = -1;
goto end;
}
source_element->is_fd_in_poll_set = false;
- ret = drain_event_notifier_notification_pipe(state, tracer_event_source_fd,
+ ret = drain_event_notifier_notification_pipe(state, source_element->fd,
source_element->domain);
if (ret) {
- ERR("[notification-thread] Error draining event notifier notification: tracer_event_source_fd = %d, domain = %s",
- tracer_event_source_fd,
+ ERR("Error draining event notifier notification: tracer_event_source_fd = %d, domain = %s",
+ source_element->fd,
lttng_domain_type_str(source_element->domain));
- cmd_result = LTTNG_ERR_FATAL;
+ ret = -1;
goto end;
}
- /*
- * The drain_event_notifier_notification_pipe() call might have read
- * data from an fd that we received in event in the latest _poll_wait()
- * call. Make sure the thread call poll_wait() again to ensure we have
- * a clean state.
- */
- state->restart_poll = true;
-
end:
- free(source_element);
- *_cmd_result = cmd_result;
return ret;
}
-int handle_notification_thread_remove_tracer_event_source_no_result(
+int handle_notification_thread_tracer_event_source_died(
struct notification_thread_state *state,
int tracer_event_source_fd)
{
- int ret;
- enum lttng_error_code cmd_result;
+ int ret = 0;
+ struct notification_event_tracer_event_source_element *source_element;
+
+ source_element = find_tracer_event_source_element(state,
+ tracer_event_source_fd);
+
+ assert(source_element);
+
+ ret = remove_tracer_event_source_from_pollset(state, source_element);
+ if (ret) {
+ ERR("Failed to remove dead tracer event source from poll set");
+ }
+
+ return ret;
+}
+
+static
+int handle_notification_thread_command_remove_tracer_event_source(
+ struct notification_thread_state *state,
+ int tracer_event_source_fd,
+ enum lttng_error_code *_cmd_result)
+{
+ int ret = 0;
+ enum lttng_error_code cmd_result = LTTNG_OK;
+ struct notification_event_tracer_event_source_element *source_element = NULL;
+
+ source_element = find_tracer_event_source_element(state,
+ tracer_event_source_fd);
- ret = handle_notification_thread_command_remove_tracer_event_source(
- state, tracer_event_source_fd, &cmd_result);
- (void) cmd_result;
+ assert(source_element);
+
+ /* Remove the tracer source from the list. */
+ cds_list_del(&source_element->node);
+
+ if (!source_element->is_fd_in_poll_set) {
+ /* Skip the poll set removal. */
+ goto end;
+ }
+
+ ret = remove_tracer_event_source_from_pollset(state, source_element);
+ if (ret) {
+ ERR("Failed to remove tracer event source from poll set");
+ cmd_result = LTTNG_ERR_FATAL;
+ }
+
+end:
+ free(source_element);
+ *_cmd_result = cmd_result;
return ret;
}
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;
}
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:
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:
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);
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;
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:
break;
}
default:
- ERR("[notification-thread] Unknown internal command received");
+ ERR("Unknown internal command received");
goto error_unlock;
}
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) {
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;
}
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;
}
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();
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);
}
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;
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;
/* 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);
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;
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;
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) {
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;
break;
default:
ret = -1;
- ERR("[notification-thread] Invalid notification channel message: unexpected message type");
+ ERR("Invalid notification channel message: unexpected message type");
goto end;
}
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;
}
&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",
+ client->is_sessiond = LTTNG_SOCK_GET_PID_CRED(&client->communication.inbound.creds) == getpid();
+ DBG("Received handshake from client: uid = %u, gid = %u, protocol version = %i.%i, client is sessiond = %s",
client->uid, client->gid, (int) client->major,
- (int) client->minor);
+ (int) client->minor,
+ client->is_sessiond ? "true" : "false");
if (handshake_client->major !=
LTTNG_NOTIFICATION_CHANNEL_VERSION_MAJOR) {
&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;
}
/* 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;
}
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;
}
/* 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;
}
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;
}
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);
/*
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);
/*
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;
}
ret = lttng_notification_serialize(¬ification, &msg_payload);
if (ret) {
- ERR("[notification-thread] Failed to serialize notification");
+ ERR("Failed to serialize notification");
ret = -1;
goto end;
}
goto skip_client;
}
+ if (lttng_trigger_is_hidden(trigger) && !client->is_sessiond) {
+ /*
+ * Notifications resulting from an hidden trigger are
+ * only sent to the session daemon.
+ */
+ continue;
+ }
+
if (source_object_creds) {
if (client->uid != lttng_credentials_get_uid(source_object_creds) &&
client->gid != lttng_credentials_get_gid(source_object_creds) &&
* 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)) {
size_t reception_size;
struct lttng_ust_abi_event_notifier_notification ust_notification;
- struct lttng_kernel_event_notifier_notification kernel_notification;
+ struct lttng_kernel_abi_event_notifier_notification kernel_notification;
/* Init lttng_event_notifier_notification */
switch(domain) {
}
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;
}
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 matches evaluation while creating and enqueuing action executor job");
ret = -1;
goto end_unlock;
}
+
client_list = get_client_list_from_condition(state,
lttng_trigger_get_const_condition(element->trigger));
executor_status = action_executor_enqueue_trigger(state->executor,
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;
}
*/
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;
* 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,