src/common/notification.c

   1 /*
   2  * Copyright (C) 2017 Jérémie Galarneau <jeremie.galarneau@efficios.com>
   3  *
   4  * SPDX-License-Identifier: LGPL-2.1-only
   5  *
   6  */
   7
   8 #include <lttng/notification/notification-internal.h>
   9 #include <lttng/condition/condition-internal.h>
  10 #include <lttng/condition/evaluation-internal.h>
  11 #include <lttng/condition/condition.h>
  12 #include <lttng/condition/evaluation.h>
  13 #include <lttng/trigger/trigger-internal.h>
  14 #include <common/payload.h>
  15 #include <common/payload-view.h>
  16
  17 LTTNG_HIDDEN
  18 struct lttng_notification *lttng_notification_create(
  19                 struct lttng_trigger *trigger,
  20                 struct lttng_evaluation *evaluation)
  21 {
  22         struct lttng_notification *notification = NULL;
  23
  24         if (!trigger || !evaluation) {
  25                 goto end;
  26         }
  27
  28         notification = zmalloc(sizeof(struct lttng_notification));
  29         if (!notification) {
  30                 goto end;
  31         }
  32
  33         notification->trigger = trigger;
  34         notification->evaluation = evaluation;
  35 end:
  36         return notification;
  37 }
  38
  39 LTTNG_HIDDEN
  40 int lttng_notification_serialize(const struct lttng_notification *notification,
  41                 struct lttng_payload *payload)
  42 {
  43         int ret;
  44         size_t header_offset, size_before_payload;
  45         struct lttng_notification_comm notification_comm = { 0 };
  46         struct lttng_notification_comm *header;
  47
  48         header_offset = payload->buffer.size;
  49         ret = lttng_dynamic_buffer_append(&payload->buffer, &notification_comm,
  50                         sizeof(notification_comm));
  51         if (ret) {
  52                 goto end;
  53         }
  54
  55         size_before_payload = payload->buffer.size;
  56         ret = lttng_trigger_serialize(notification->trigger,
  57                         payload);
  58         if (ret) {
  59                 goto end;
  60         }
  61
  62         ret = lttng_evaluation_serialize(notification->evaluation, payload);
  63         if (ret) {
  64                 goto end;
  65         }
  66
  67         /* Update payload size. */
  68         header = (typeof(header)) (payload->buffer.data + header_offset);
  69         header->length = (uint32_t) (payload->buffer.size - size_before_payload);
  70 end:
  71         return ret;
  72
  73 }
  74
  75 LTTNG_HIDDEN
  76 ssize_t lttng_notification_create_from_payload(
  77                 struct lttng_payload_view *src_view,
  78                 struct lttng_notification **notification)
  79 {
  80         ssize_t ret, notification_size = 0, trigger_size, evaluation_size;
  81         struct lttng_trigger *trigger = NULL;
  82         struct lttng_evaluation *evaluation = NULL;
  83         const struct lttng_notification_comm *notification_comm;
  84         const struct lttng_payload_view notification_comm_view =
  85                         lttng_payload_view_from_view(
  86                                         src_view, 0, sizeof(*notification_comm));
  87
  88         if (!src_view || !notification) {
  89                 ret = -1;
  90                 goto error;
  91         }
  92
  93         if (!lttng_payload_view_is_valid(&notification_comm_view)) {
  94                 /* Payload not large enough to contain the header. */
  95                 ret = -1;
  96                 goto error;
  97         }
  98
  99         notification_comm = (typeof(notification_comm)) notification_comm_view.buffer.data;
 100         notification_size += sizeof(*notification_comm);
 101         {
 102                 /* struct lttng_condition */
 103                 struct lttng_payload_view condition_view =
 104                                 lttng_payload_view_from_view(src_view,
 105                                                 notification_size, -1);
 106
 107                 trigger_size = lttng_trigger_create_from_payload(
 108                                 &condition_view, &trigger);
 109         }
 110
 111         if (trigger_size < 0) {
 112                 ret = trigger_size;
 113                 goto error;
 114         }
 115
 116         notification_size += trigger_size;
 117
 118         {
 119                 /* struct lttng_evaluation */
 120                 struct lttng_payload_view evaluation_view =
 121                                 lttng_payload_view_from_view(src_view,
 122                                                 notification_size, -1);
 123
 124                 evaluation_size = lttng_evaluation_create_from_payload(
 125                                 lttng_trigger_get_const_condition(trigger),
 126                                 &evaluation_view, &evaluation);
 127         }
 128
 129         if (evaluation_size < 0) {
 130                 ret = evaluation_size;
 131                 goto error;
 132         }
 133
 134         notification_size += evaluation_size;
 135
 136         /* Unexpected size of inner-elements; the buffer is corrupted. */
 137         if ((ssize_t) notification_comm->length !=
 138                         trigger_size + evaluation_size) {
 139                 ret = -1;
 140                 goto error;
 141         }
 142
 143         *notification = lttng_notification_create(trigger, evaluation);
 144         if (!*notification) {
 145                 ret = -1;
 146                 goto error;
 147         }
 148
 149         ret = notification_size;
 150         return ret;
 151
 152 error:
 153         lttng_trigger_destroy(trigger);
 154         lttng_evaluation_destroy(evaluation);
 155         return ret;
 156 }
 157
 158 void lttng_notification_destroy(struct lttng_notification *notification)
 159 {
 160         if (!notification) {
 161                 return;
 162         }
 163
 164         lttng_trigger_destroy(notification->trigger);
 165         lttng_evaluation_destroy(notification->evaluation);
 166         free(notification);
 167 }
 168
 169 const struct lttng_condition *lttng_notification_get_condition(
 170                 struct lttng_notification *notification)
 171 {
 172         return notification ? lttng_trigger_get_const_condition(notification->trigger) : NULL;
 173 }
 174
 175 const struct lttng_evaluation *lttng_notification_get_evaluation(
 176                 struct lttng_notification *notification)
 177 {
 178         return notification ? notification->evaluation : NULL;
 179 }
 180
 181 const struct lttng_trigger *lttng_notification_get_trigger(
 182                 struct lttng_notification *notification)
 183 {
 184         return notification ? notification->trigger : NULL;
 185 }