X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fcommon%2Fnotification.c;h=d1403574b1c2401a4941ae0fe389eaac7bbfcdcf;hp=e32737dce89ce94d5c4e7c58e06ef16fee92a063;hb=3afa94aeca5a0daae40fd7b6cc96b7e4c150c7d8;hpb=28cff59fb9ef4a4cdef7252708cc967b4e7a4f72 diff --git a/src/common/notification.c b/src/common/notification.c index e32737dce..d1403574b 100644 --- a/src/common/notification.c +++ b/src/common/notification.c @@ -1,18 +1,8 @@ /* - * 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 @@ -20,16 +10,17 @@ #include #include #include -#include +#include +#include +#include -LTTNG_HIDDEN struct lttng_notification *lttng_notification_create( - struct lttng_condition *condition, + struct lttng_trigger *trigger, struct lttng_evaluation *evaluation) { struct lttng_notification *notification = NULL; - if (!condition || !evaluation) { + if (!trigger || !evaluation) { goto end; } @@ -38,108 +29,125 @@ struct lttng_notification *lttng_notification_create( goto end; } - notification->condition = condition; + notification->trigger = trigger; notification->evaluation = evaluation; end: return notification; } -LTTNG_HIDDEN int lttng_notification_serialize(const struct lttng_notification *notification, - struct lttng_dynamic_buffer *buf) + struct lttng_payload *payload) { int ret; size_t header_offset, size_before_payload; struct lttng_notification_comm notification_comm = { 0 }; struct lttng_notification_comm *header; - header_offset = buf->size; - ret = lttng_dynamic_buffer_append(buf, ¬ification_comm, + header_offset = payload->buffer.size; + ret = lttng_dynamic_buffer_append(&payload->buffer, ¬ification_comm, sizeof(notification_comm)); if (ret) { goto end; } - size_before_payload = buf->size; - ret = lttng_condition_serialize(notification->condition, - buf); + size_before_payload = payload->buffer.size; + ret = lttng_trigger_serialize(notification->trigger, + payload); if (ret) { goto end; } - ret = lttng_evaluation_serialize(notification->evaluation, buf); + ret = lttng_evaluation_serialize(notification->evaluation, payload); if (ret) { goto end; } /* Update payload size. */ - header = (struct lttng_notification_comm *) ((char *) buf->data + header_offset); - header->length = (uint32_t) (buf->size - size_before_payload); + header = (typeof(header)) (payload->buffer.data + header_offset); + header->length = (uint32_t) (payload->buffer.size - size_before_payload); end: return ret; } -LTTNG_HIDDEN -ssize_t lttng_notification_create_from_buffer( - const struct lttng_buffer_view *src_view, +ssize_t lttng_notification_create_from_payload( + struct lttng_payload_view *src_view, struct lttng_notification **notification) { - ssize_t ret, notification_size = 0, condition_size, evaluation_size; + ssize_t ret, notification_size = 0, trigger_size, evaluation_size; + struct lttng_trigger *trigger = NULL; + struct lttng_evaluation *evaluation = NULL; const struct lttng_notification_comm *notification_comm; - struct lttng_condition *condition; - struct lttng_evaluation *evaluation; - struct lttng_buffer_view condition_view; - struct lttng_buffer_view evaluation_view; + const struct lttng_payload_view notification_comm_view = + lttng_payload_view_from_view( + src_view, 0, sizeof(*notification_comm)); if (!src_view || !notification) { ret = -1; - goto end; + goto error; + } + + if (!lttng_payload_view_is_valid(¬ification_comm_view)) { + /* Payload not large enough to contain the header. */ + ret = -1; + goto error; } - notification_comm = - (const struct lttng_notification_comm *) src_view->data; + notification_comm = (typeof(notification_comm)) notification_comm_view.buffer.data; notification_size += sizeof(*notification_comm); + { + /* struct lttng_condition */ + struct lttng_payload_view condition_view = + lttng_payload_view_from_view(src_view, + notification_size, -1); + + trigger_size = lttng_trigger_create_from_payload( + &condition_view, &trigger); + } - /* struct lttng_condition */ - condition_view = lttng_buffer_view_from_view(src_view, - sizeof(*notification_comm), -1); - condition_size = lttng_condition_create_from_buffer(&condition_view, - &condition); - if (condition_size < 0) { - ret = condition_size; - goto end; + if (trigger_size < 0) { + ret = trigger_size; + goto error; + } + + notification_size += trigger_size; + + { + /* struct lttng_evaluation */ + struct lttng_payload_view evaluation_view = + lttng_payload_view_from_view(src_view, + notification_size, -1); + + evaluation_size = lttng_evaluation_create_from_payload( + lttng_trigger_get_const_condition(trigger), + &evaluation_view, &evaluation); } - notification_size += condition_size; - /* struct lttng_evaluation */ - evaluation_view = lttng_buffer_view_from_view(&condition_view, - condition_size, -1); - evaluation_size = lttng_evaluation_create_from_buffer(&evaluation_view, - &evaluation); if (evaluation_size < 0) { ret = evaluation_size; - goto end; + goto error; } + notification_size += evaluation_size; /* Unexpected size of inner-elements; the buffer is corrupted. */ if ((ssize_t) notification_comm->length != - condition_size + evaluation_size) { + trigger_size + evaluation_size) { ret = -1; goto error; } - *notification = lttng_notification_create(condition, evaluation); + *notification = lttng_notification_create(trigger, evaluation); if (!*notification) { ret = -1; goto error; } + ret = notification_size; -end: return ret; + error: - lttng_condition_destroy(condition); + lttng_trigger_destroy(trigger); lttng_evaluation_destroy(evaluation); return ret; } @@ -150,7 +158,7 @@ void lttng_notification_destroy(struct lttng_notification *notification) return; } - lttng_condition_destroy(notification->condition); + lttng_trigger_destroy(notification->trigger); lttng_evaluation_destroy(notification->evaluation); free(notification); } @@ -158,7 +166,7 @@ void lttng_notification_destroy(struct lttng_notification *notification) const struct lttng_condition *lttng_notification_get_condition( struct lttng_notification *notification) { - return notification ? notification->condition : NULL; + return notification ? lttng_trigger_get_const_condition(notification->trigger) : NULL; } const struct lttng_evaluation *lttng_notification_get_evaluation( @@ -166,3 +174,9 @@ const struct lttng_evaluation *lttng_notification_get_evaluation( { return notification ? notification->evaluation : NULL; } + +const struct lttng_trigger *lttng_notification_get_trigger( + struct lttng_notification *notification) +{ + return notification ? notification->trigger : NULL; +}