src/common/condition.c

   1 /*
   2  * Copyright (C) 2017 - Jérémie Galarneau <jeremie.galarneau@efficios.com>
   3  *
   4  * This library is free software; you can redistribute it and/or modify it
   5  * under the terms of the GNU Lesser General Public License, version 2.1 only,
   6  * as published by the Free Software Foundation.
   7  *
   8  * This library is distributed in the hope that it will be useful, but WITHOUT
   9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  10  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
  11  * for more details.
  12  *
  13  * You should have received a copy of the GNU Lesser General Public License
  14  * along with this library; if not, write to the Free Software Foundation,
  15  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  16  */
  17
  18 #include <lttng/condition/condition-internal.h>
  19 #include <lttng/condition/buffer-usage-internal.h>
  20 #include <lttng/condition/session-consumed-size-internal.h>
  21 #include <common/macros.h>
  22 #include <common/error.h>
  23 #include <common/dynamic-buffer.h>
  24 #include <common/buffer-view.h>
  25 #include <stdbool.h>
  26 #include <assert.h>
  27
  28 enum lttng_condition_type lttng_condition_get_type(
  29                 const struct lttng_condition *condition)
  30 {
  31         return condition ? condition->type : LTTNG_CONDITION_TYPE_UNKNOWN;
  32 }
  33
  34 void lttng_condition_destroy(struct lttng_condition *condition)
  35 {
  36         if (!condition) {
  37                 return;
  38         }
  39
  40         assert(condition->destroy);
  41         condition->destroy(condition);
  42 }
  43
  44 LTTNG_HIDDEN
  45 bool lttng_condition_validate(const struct lttng_condition *condition)
  46 {
  47         bool valid;
  48
  49         if (!condition) {
  50                 valid = false;
  51                 goto end;
  52         }
  53
  54         if (!condition->validate) {
  55                 /* Sub-class guarantees that it can never be invalid. */
  56                 valid = true;
  57                 goto end;
  58         }
  59
  60         valid = condition->validate(condition);
  61 end:
  62         return valid;
  63 }
  64
  65 LTTNG_HIDDEN
  66 int lttng_condition_serialize(const struct lttng_condition *condition,
  67                 struct lttng_dynamic_buffer *buf)
  68 {
  69         int ret;
  70         struct lttng_condition_comm condition_comm = { 0 };
  71
  72         if (!condition) {
  73                 ret = -1;
  74                 goto end;
  75         }
  76
  77         condition_comm.condition_type = (int8_t) condition->type;
  78
  79         ret = lttng_dynamic_buffer_append(buf, &condition_comm,
  80                         sizeof(condition_comm));
  81         if (ret) {
  82                 goto end;
  83         }
  84
  85         ret = condition->serialize(condition, buf);
  86         if (ret) {
  87                 goto end;
  88         }
  89 end:
  90         return ret;
  91 }
  92
  93 LTTNG_HIDDEN
  94 bool lttng_condition_is_equal(const struct lttng_condition *a,
  95                 const struct lttng_condition *b)
  96 {
  97         bool is_equal = false;
  98
  99         if (!a || !b) {
 100                 goto end;
 101         }
 102
 103         if (a->type != b->type) {
 104                 goto end;
 105         }
 106
 107         if (a == b) {
 108                 is_equal = true;
 109                 goto end;
 110         }
 111
 112         is_equal = a->equal ? a->equal(a, b) : true;
 113 end:
 114         return is_equal;
 115 }
 116
 117 LTTNG_HIDDEN
 118 ssize_t lttng_condition_create_from_buffer(
 119                 const struct lttng_buffer_view *buffer,
 120                 struct lttng_condition **condition)
 121 {
 122         ssize_t ret, condition_size = 0;
 123         const struct lttng_condition_comm *condition_comm;
 124         condition_create_from_buffer_cb create_from_buffer = NULL;
 125
 126         if (!buffer || !condition) {
 127                 ret = -1;
 128                 goto end;
 129         }
 130
 131         DBG("Deserializing condition from buffer");
 132         condition_comm = (const struct lttng_condition_comm *) buffer->data;
 133         condition_size += sizeof(*condition_comm);
 134
 135         switch ((enum lttng_condition_type) condition_comm->condition_type) {
 136         case LTTNG_CONDITION_TYPE_BUFFER_USAGE_LOW:
 137                 create_from_buffer = lttng_condition_buffer_usage_low_create_from_buffer;
 138                 break;
 139         case LTTNG_CONDITION_TYPE_BUFFER_USAGE_HIGH:
 140                 create_from_buffer = lttng_condition_buffer_usage_high_create_from_buffer;
 141                 break;
 142         case LTTNG_CONDITION_TYPE_SESSION_CONSUMED_SIZE:
 143                 create_from_buffer = lttng_condition_session_consumed_size_create_from_buffer;
 144                 break;
 145         default:
 146                 ERR("Attempted to create condition of unknown type (%i)",
 147                                 (int) condition_comm->condition_type);
 148                 ret = -1;
 149                 goto end;
 150         }
 151
 152         if (create_from_buffer) {
 153                 const struct lttng_buffer_view view =
 154                                 lttng_buffer_view_from_view(buffer,
 155                                         sizeof(*condition_comm), -1);
 156
 157                 ret = create_from_buffer(&view, condition);
 158                 if (ret < 0) {
 159                         goto end;
 160                 }
 161                 condition_size += ret;
 162
 163         } else {
 164                 abort();
 165         }
 166
 167         ret = condition_size;
 168 end:
 169         return ret;
 170 }
 171
 172 LTTNG_HIDDEN
 173 void lttng_condition_init(struct lttng_condition *condition,
 174                 enum lttng_condition_type type)
 175 {
 176         condition->type = type;
 177 }