/*
- * Copyright (C) 2017 - Jérémie Galarneau <jeremie.galarneau@efficios.com>
+ * Copyright (C) 2017 Jérémie Galarneau <jeremie.galarneau@efficios.com>
*
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License, version 2 only, as
- * published by the Free Software Foundation.
+ * SPDX-License-Identifier: GPL-2.0-only
*
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License along with
- * this program; if not, write to the Free Software Foundation, Inc., 51
- * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#define _LGPL_SOURCE
struct cds_list_head list;
/* Node in the channel_triggers_ht */
struct cds_lfht_node channel_triggers_ht_node;
+ /* call_rcu delayed reclaim. */
+ struct rcu_head rcu_node;
};
/*
struct lttng_trigger_ht_element {
struct lttng_trigger *trigger;
struct cds_lfht_node node;
+ /* call_rcu delayed reclaim. */
+ struct rcu_head rcu_node;
};
struct lttng_condition_list_element {
const struct lttng_trigger *trigger;
struct cds_list_head list;
struct cds_lfht_node notification_trigger_ht_node;
+ /* call_rcu delayed reclaim. */
+ struct rcu_head rcu_node;
};
struct notification_client {
struct lttng_dynamic_buffer buffer;
} outbound;
} communication;
+ /* call_rcu delayed reclaim. */
+ struct rcu_head rcu_node;
};
struct channel_state_sample {
uint64_t highest_usage;
uint64_t lowest_usage;
uint64_t channel_total_consumed;
+ /* call_rcu delayed reclaim. */
+ struct rcu_head rcu_node;
};
static unsigned long hash_channel_key(struct channel_key *key);
}
}
+static
+void free_channel_info_rcu(struct rcu_head *node)
+{
+ free(caa_container_of(node, struct channel_info, rcu_node));
+}
+
static
void channel_info_destroy(struct channel_info *channel_info)
{
if (channel_info->name) {
free(channel_info->name);
}
- free(channel_info);
+ call_rcu(&channel_info->rcu_node, free_channel_info_rcu);
+}
+
+static
+void free_session_info_rcu(struct rcu_head *node)
+{
+ free(caa_container_of(node, struct session_info, rcu_node));
}
/* Don't call directly, use the ref-counting mechanism. */
&session_info->sessions_ht_node);
rcu_read_unlock();
free(session_info->name);
- free(session_info);
+ call_rcu(&session_info->rcu_node, free_session_info_rcu);
}
static
ret = -1;
goto end;
}
-
+ if (ret) {
+ /* Fatal error. */
+ goto end;
+ }
if (!evaluation) {
/* Evaluation yielded nothing. Normal exit. */
DBG("[notification-thread] Newly subscribed-to condition evaluated to false, nothing to report to client");
return 0;
}
+static
+void free_notification_client_rcu(struct rcu_head *node)
+{
+ free(caa_container_of(node, struct notification_client, rcu_node));
+}
+
static
void notification_client_destroy(struct notification_client *client,
struct notification_thread_state *state)
}
lttng_dynamic_buffer_reset(&client->communication.inbound.buffer);
lttng_dynamic_buffer_reset(&client->communication.outbound.buffer);
- free(client);
+ call_rcu(&client->rcu_node, free_notification_client_rcu);
}
/*
if (!session) {
ERR("[notification-thread] Failed to allocation session info for session \"%s\" (uid = %i, gid = %i)",
name, uid, gid);
+ lttng_session_trigger_list_destroy(trigger_list);
goto error;
}
trigger_list = NULL;
goto error;
}
+ rcu_read_lock();
/* Build a list of all triggers applying to the new channel. */
cds_lfht_for_each_entry(state->triggers_ht, &iter, trigger_ht_element,
node) {
new_element = zmalloc(sizeof(*new_element));
if (!new_element) {
+ rcu_read_unlock();
goto error;
}
CDS_INIT_LIST_HEAD(&new_element->node);
cds_list_add(&new_element->node, &trigger_list);
trigger_count++;
}
+ rcu_read_unlock();
DBG("[notification-thread] Found %i triggers that apply to newly added channel",
trigger_count);
return 1;
}
+static
+void free_channel_trigger_list_rcu(struct rcu_head *node)
+{
+ free(caa_container_of(node, struct lttng_channel_trigger_list,
+ rcu_node));
+}
+
+static
+void free_channel_state_sample_rcu(struct rcu_head *node)
+{
+ free(caa_container_of(node, struct channel_state_sample,
+ rcu_node));
+}
+
static
int handle_notification_thread_command_remove_channel(
struct notification_thread_state *state,
free(trigger_list_element);
}
cds_lfht_del(state->channel_triggers_ht, node);
- free(trigger_list);
+ call_rcu(&trigger_list->rcu_node, free_channel_trigger_list_rcu);
/* Free sampled channel state. */
cds_lfht_lookup(state->channel_state_ht,
channel_state_ht_node);
cds_lfht_del(state->channel_state_ht, node);
- free(sample);
+ call_rcu(&sample->rcu_node, free_channel_state_sample_rcu);
}
/* Remove the channel from the channels_ht and free it. */
* buffers. Therefore, we reject triggers that require that
* mechanism to be available to be evaluated.
*/
- ret = kernel_supports_ring_buffer_snapshot_sample_positions(
- kernel_tracer_fd);
+ ret = kernel_supports_ring_buffer_snapshot_sample_positions();
break;
}
default:
channels_ht_node) {
struct lttng_trigger_list_element *trigger_list_element;
struct lttng_channel_trigger_list *trigger_list;
+ struct cds_lfht_iter lookup_iter;
if (!trigger_applies_to_channel(trigger, channel)) {
continue;
hash_channel_key(&channel->key),
match_channel_trigger_list,
&channel->key,
- &iter);
- node = cds_lfht_iter_get_node(&iter);
+ &lookup_iter);
+ node = cds_lfht_iter_get_node(&lookup_iter);
assert(node);
trigger_list = caa_container_of(node,
struct lttng_channel_trigger_list,
return ret;
}
+static
+void free_notification_client_list_rcu(struct rcu_head *node)
+{
+ free(caa_container_of(node, struct notification_client_list,
+ rcu_node));
+}
+
+static
+void free_lttng_trigger_ht_element_rcu(struct rcu_head *node)
+{
+ free(caa_container_of(node, struct lttng_trigger_ht_element,
+ rcu_node));
+}
+
static
int handle_notification_thread_command_unregister_trigger(
struct notification_thread_state *state,
}
cds_lfht_del(state->notification_trigger_clients_ht,
&client_list->notification_trigger_ht_node);
- free(client_list);
+ call_rcu(&client_list->rcu_node, free_notification_client_list_rcu);
/* Remove trigger from triggers_ht. */
trigger_ht_element = caa_container_of(triggers_ht_node,
action = lttng_trigger_get_action(trigger_ht_element->trigger);
lttng_action_destroy(action);
lttng_trigger_destroy(trigger_ht_element->trigger);
- free(trigger_ht_element);
+ call_rcu(&trigger_ht_element->rcu_node, free_lttng_trigger_ht_element_rcu);
end:
rcu_read_unlock();
if (_cmd_reply) {
struct notification_thread_command *cmd;
/* Read the event pipe to put it back into a quiescent state. */
- ret = read(lttng_pipe_get_readfd(handle->cmd_queue.event_pipe), &counter,
+ ret = lttng_read(lttng_pipe_get_readfd(handle->cmd_queue.event_pipe), &counter,
sizeof(counter));
- if (ret == -1) {
+ if (ret != sizeof(counter)) {
goto error;
}
struct cds_lfht_iter iter;
struct lttng_trigger_ht_element *trigger_ht_element;
+ rcu_read_lock();
cds_lfht_for_each_entry(state->triggers_ht, &iter, trigger_ht_element,
node) {
int ret = handle_notification_thread_command_unregister_trigger(
error_occurred = true;
}
}
+ rcu_read_unlock();
return error_occurred ? -1 : 0;
}
ret = lttcomm_send_unix_sock_non_block(client->socket,
client->communication.outbound.buffer.data,
to_send_count);
- if ((ret < 0 && (errno == EAGAIN || errno == EWOULDBLOCK)) ||
- (ret > 0 && ret < to_send_count)) {
+ if ((ret >= 0 && ret < to_send_count)) {
DBG("[notification-thread] Client (socket fd = %i) outgoing queue could not be completely flushed",
client->socket);
to_send_count -= max(ret, 0);
struct lttng_condition *condition;
enum lttng_notification_channel_status status =
LTTNG_NOTIFICATION_CHANNEL_STATUS_OK;
- const struct lttng_buffer_view condition_view =
- lttng_buffer_view_from_dynamic_buffer(
+ struct lttng_payload_view condition_view =
+ lttng_payload_view_from_dynamic_buffer(
&client->communication.inbound.buffer,
0, -1);
size_t expected_condition_size =
client->communication.inbound.buffer.size;
- ret = lttng_condition_create_from_buffer(&condition_view,
+ ret = lttng_condition_create_from_payload(&condition_view,
&condition);
if (ret != expected_condition_size) {
ERR("[notification-thread] Malformed condition received from client");
* forego this double-multiplication or it could be performed
* as fixed-point math.
*
- * Note that caching should accomodate the case where the
+ * Note that caching should accommodates the case where the
* condition applies to multiple channels (i.e. don't assume
* that all channels matching my_chann* have the same size...)
*/
}
static
-int client_enqueue_dropped_notification(struct notification_client *client,
- struct notification_thread_state *state)
+int client_enqueue_dropped_notification(struct notification_client *client)
{
int ret;
struct lttng_notification_channel_message msg = {
uid_t channel_uid, gid_t channel_gid)
{
int ret = 0;
- struct lttng_dynamic_buffer msg_buffer;
+ struct lttng_payload msg_payload;
struct notification_client_list_element *client_list_element, *tmp;
const struct lttng_notification notification = {
.condition = (struct lttng_condition *) lttng_trigger_get_const_condition(trigger),
.type = (int8_t) LTTNG_NOTIFICATION_CHANNEL_MESSAGE_TYPE_NOTIFICATION,
};
- lttng_dynamic_buffer_init(&msg_buffer);
+ lttng_payload_init(&msg_payload);
- ret = lttng_dynamic_buffer_append(&msg_buffer, &msg_header,
+ ret = lttng_dynamic_buffer_append(&msg_payload.buffer, &msg_header,
sizeof(msg_header));
if (ret) {
goto end;
}
- ret = lttng_notification_serialize(¬ification, &msg_buffer);
+ ret = lttng_notification_serialize(¬ification, &msg_payload);
if (ret) {
ERR("[notification-thread] Failed to serialize notification");
ret = -1;
}
/* Update payload size. */
- ((struct lttng_notification_channel_message * ) msg_buffer.data)->size =
- (uint32_t) (msg_buffer.size - sizeof(msg_header));
+ ((struct lttng_notification_channel_message * ) msg_payload.buffer.data)->size =
+ (uint32_t) (msg_payload.buffer.size - sizeof(msg_header));
cds_list_for_each_entry_safe(client_list_element, tmp,
&client_list->list, node) {
}
DBG("[notification-thread] Sending notification to client (fd = %i, %zu bytes)",
- client->socket, msg_buffer.size);
+ client->socket, msg_payload.buffer.size);
if (client->communication.outbound.buffer.size) {
/*
* Outgoing data is already buffered for this client;
if (!client->communication.outbound.dropped_notification) {
client->communication.outbound.dropped_notification = true;
ret = client_enqueue_dropped_notification(
- client, state);
+ client);
if (ret) {
goto end;
}
ret = lttng_dynamic_buffer_append_buffer(
&client->communication.outbound.buffer,
- &msg_buffer);
+ &msg_payload.buffer);
if (ret) {
goto end;
}
}
ret = 0;
end:
- lttng_dynamic_buffer_reset(&msg_buffer);
+ lttng_payload_reset(&msg_payload);
return ret;
}
projects / lttng-tools.git / blobdiff