X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fcommon%2Ftrigger.c;h=2ef77b2360a2bf8ab1ea80cdf513da2b9d46ce2b;hp=a4130ec312ff293460834849a92556680fb2f730;hb=f01d28b41fb941aee87aaf70ed42a5928c784ba6;hpb=9b63a4aa352c184984395c097f86d5e54c295012 diff --git a/src/common/trigger.c b/src/common/trigger.c index a4130ec31..2ef77b236 100644 --- a/src/common/trigger.c +++ b/src/common/trigger.c @@ -1,24 +1,18 @@ /* - * Copyright (C) 2017 - Jérémie Galarneau + * Copyright (C) 2017 Jérémie Galarneau * - * This library is free software; you can redistribute it and/or modify it - * under the terms of the GNU Lesser General Public License, version 2.1 only, - * as published by the Free Software Foundation. + * SPDX-License-Identifier: LGPL-2.1-only * - * This library 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 Lesser General Public License - * for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with this library; if not, write to the Free Software Foundation, - * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include #include #include +#include +#include +#include #include +#include #include LTTNG_HIDDEN @@ -52,12 +46,23 @@ struct lttng_trigger *lttng_trigger_create( goto end; } + urcu_ref_init(&trigger->ref); + + lttng_condition_get(condition); trigger->condition = condition; + + lttng_action_get(action); trigger->action = action; + end: return trigger; } +/* + * Note: the lack of reference counting 'get' on the condition object is normal. + * This API was exposed as such in 2.11. The client is not expected to call + * lttng_condition_destroy on the returned object. + */ struct lttng_condition *lttng_trigger_get_condition( struct lttng_trigger *trigger) { @@ -71,6 +76,12 @@ const struct lttng_condition *lttng_trigger_get_const_condition( return trigger->condition; } + +/* + * Note: the lack of reference counting 'get' on the action object is normal. + * This API was exposed as such in 2.11. The client is not expected to call + * lttng_action_destroy on the returned object. + */ struct lttng_action *lttng_trigger_get_action( struct lttng_trigger *trigger) { @@ -84,26 +95,38 @@ const struct lttng_action *lttng_trigger_get_const_action( return trigger->action; } -void lttng_trigger_destroy(struct lttng_trigger *trigger) +static void trigger_destroy_ref(struct urcu_ref *ref) { - if (!trigger) { - return; - } + struct lttng_trigger *trigger = + container_of(ref, struct lttng_trigger, ref); + struct lttng_action *action = lttng_trigger_get_action(trigger); + struct lttng_condition *condition = + lttng_trigger_get_condition(trigger); + + assert(action); + assert(condition); + + /* Release ownership. */ + lttng_action_put(action); + lttng_condition_put(condition); free(trigger); } +void lttng_trigger_destroy(struct lttng_trigger *trigger) +{ + lttng_trigger_put(trigger); +} + LTTNG_HIDDEN -ssize_t lttng_trigger_create_from_buffer( - const struct lttng_buffer_view *src_view, +ssize_t lttng_trigger_create_from_payload( + struct lttng_payload_view *src_view, struct lttng_trigger **trigger) { ssize_t ret, offset = 0, condition_size, action_size; struct lttng_condition *condition = NULL; struct lttng_action *action = NULL; const struct lttng_trigger_comm *trigger_comm; - struct lttng_buffer_view condition_view; - struct lttng_buffer_view action_view; if (!src_view || !trigger) { ret = -1; @@ -111,23 +134,33 @@ ssize_t lttng_trigger_create_from_buffer( } /* lttng_trigger_comm header */ - trigger_comm = (const struct lttng_trigger_comm *) src_view->data; + trigger_comm = (typeof(trigger_comm)) src_view->buffer.data; offset += sizeof(*trigger_comm); + { + /* struct lttng_condition */ + struct lttng_payload_view condition_view = + lttng_payload_view_from_view( + src_view, offset, -1); - condition_view = lttng_buffer_view_from_view(src_view, offset, -1); + condition_size = lttng_condition_create_from_payload(&condition_view, + &condition); + } - /* struct lttng_condition */ - condition_size = lttng_condition_create_from_buffer(&condition_view, - &condition); if (condition_size < 0) { ret = condition_size; goto end; } + offset += condition_size; + { + /* struct lttng_action */ + struct lttng_payload_view action_view = + lttng_payload_view_from_view( + src_view, offset, -1); + + action_size = lttng_action_create_from_payload(&action_view, &action); + } - /* struct lttng_action */ - action_view = lttng_buffer_view_from_view(src_view, offset, -1); - action_size = lttng_action_create_from_buffer(&action_view, &action); if (action_size < 0) { ret = action_size; goto end; @@ -145,12 +178,23 @@ ssize_t lttng_trigger_create_from_buffer( ret = -1; goto error; } + + /* + * The trigger object owns references to the action and condition + * objects. + */ + lttng_condition_put(condition); + condition = NULL; + + lttng_action_put(action); + action = NULL; + ret = offset; -end: - return ret; + error: lttng_condition_destroy(condition); lttng_action_destroy(action); +end: return ret; } @@ -160,34 +204,66 @@ error: */ LTTNG_HIDDEN int lttng_trigger_serialize(struct lttng_trigger *trigger, - struct lttng_dynamic_buffer *buf) + struct lttng_payload *payload) { int ret; size_t header_offset, size_before_payload; - struct lttng_trigger_comm trigger_comm = { 0 }; + struct lttng_trigger_comm trigger_comm = {}; struct lttng_trigger_comm *header; - header_offset = buf->size; - ret = lttng_dynamic_buffer_append(buf, &trigger_comm, + header_offset = payload->buffer.size; + ret = lttng_dynamic_buffer_append(&payload->buffer, &trigger_comm, sizeof(trigger_comm)); if (ret) { goto end; } - size_before_payload = buf->size; - ret = lttng_condition_serialize(trigger->condition, buf); + size_before_payload = payload->buffer.size; + ret = lttng_condition_serialize(trigger->condition, payload); if (ret) { goto end; } - ret = lttng_action_serialize(trigger->action, buf); + ret = lttng_action_serialize(trigger->action, payload); if (ret) { goto end; } /* Update payload size. */ - header = (struct lttng_trigger_comm *) ((char *) buf->data + header_offset); - header->length = buf->size - size_before_payload; + header = (typeof(header)) (payload->buffer.data + header_offset); + header->length = payload->buffer.size - size_before_payload; end: return ret; } + +LTTNG_HIDDEN +void lttng_trigger_get(struct lttng_trigger *trigger) +{ + urcu_ref_get(&trigger->ref); +} + +LTTNG_HIDDEN +void lttng_trigger_put(struct lttng_trigger *trigger) +{ + if (!trigger) { + return; + } + + urcu_ref_put(&trigger->ref , trigger_destroy_ref); +} + +LTTNG_HIDDEN +const struct lttng_credentials *lttng_trigger_get_credentials( + const struct lttng_trigger *trigger) +{ + return LTTNG_OPTIONAL_GET_PTR(trigger->creds); +} + +LTTNG_HIDDEN +void lttng_trigger_set_credentials( + struct lttng_trigger *trigger, + const struct lttng_credentials *creds) +{ + assert(creds); + LTTNG_OPTIONAL_SET(&trigger->creds, *creds); +}