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 <common/macros.h>
  21 #include <common/error.h>
  22 #include <common/dynamic-buffer.h>
  23 #include <common/buffer-view.h>
  24 #include <stdbool.h>
  25 #include <assert.h>
  26
  27 enum lttng_condition_type lttng_condition_get_type(
  28                 const struct lttng_condition *condition)
  29 {
  30         return condition ? condition->type : LTTNG_CONDITION_TYPE_UNKNOWN;
  31 }
  32
  33 void lttng_condition_destroy(struct lttng_condition *condition)
  34 {
  35         if (!condition) {
  36                 return;
  37         }
  38
  39         assert(condition->destroy);
  40         condition->destroy(condition);
  41 }
  42
  43 LTTNG_HIDDEN
  44 bool lttng_condition_validate(const struct lttng_condition *condition)
  45 {
  46         bool valid;
  47
  48         if (!condition) {
  49                 valid = false;
  50                 goto end;
  51         }
  52
  53         if (!condition->validate) {
  54                 /* Sub-class guarantees that it can never be invalid. */
  55                 valid = true;
  56                 goto end;
  57         }
  58
  59         valid = condition->validate(condition);
  60 end:
  61         return valid;
  62 }
  63
  64 LTTNG_HIDDEN
  65 ssize_t lttng_condition_serialize(const struct lttng_condition *condition,
  66                 char *buf)
  67 {
  68         ssize_t ret, condition_size;
  69         struct lttng_condition_comm condition_comm;
  70
  71         if (!condition) {
  72                 ret = -1;
  73                 goto end;
  74         }
  75
  76         condition_comm.condition_type = (int8_t) condition->type;
  77         ret = sizeof(struct lttng_condition_comm);
  78         if (buf) {
  79                 memcpy(buf, &condition_comm, ret);
  80                 buf += ret;
  81         }
  82
  83         condition_size = condition->serialize(condition, buf);
  84         if (condition_size < 0) {
  85                 ret = condition_size;
  86                 goto end;
  87         }
  88         ret += condition_size;
  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         is_equal = a->equal ? a->equal(a, b) : true;
 108 end:
 109         return is_equal;
 110 }
 111
 112 LTTNG_HIDDEN
 113 ssize_t lttng_condition_create_from_buffer(
 114                 const struct lttng_buffer_view *buffer,
 115                 struct lttng_condition **condition)
 116 {
 117         ssize_t ret, condition_size = 0;
 118         const struct lttng_condition_comm *condition_comm;
 119         condition_create_from_buffer_cb create_from_buffer = NULL;
 120
 121         if (!buffer || !condition) {
 122                 ret = -1;
 123                 goto end;
 124         }
 125
 126         DBG("Deserializing condition from buffer");
 127         condition_comm = (const struct lttng_condition_comm *) buffer->data;
 128         condition_size += sizeof(*condition_comm);
 129
 130         switch ((enum lttng_condition_type) condition_comm->condition_type) {
 131         case LTTNG_CONDITION_TYPE_BUFFER_USAGE_LOW:
 132                 create_from_buffer = lttng_condition_buffer_usage_low_create_from_buffer;
 133                 break;
 134         case LTTNG_CONDITION_TYPE_BUFFER_USAGE_HIGH:
 135                 create_from_buffer = lttng_condition_buffer_usage_high_create_from_buffer;
 136                 break;
 137         default:
 138                 ERR("Attempted to create condition of unknown type (%i)",
 139                                 (int) condition_comm->condition_type);
 140                 ret = -1;
 141                 goto end;
 142         }
 143
 144         if (create_from_buffer) {
 145                 const struct lttng_buffer_view view =
 146                                 lttng_buffer_view_from_view(buffer,
 147                                         sizeof(*condition_comm), -1);
 148
 149                 ret = create_from_buffer(&view, condition);
 150                 if (ret < 0) {
 151                         goto end;
 152                 }
 153                 condition_size += ret;
 154
 155         } else {
 156                 abort();
 157         }
 158
 159         ret = condition_size;
 160 end:
 161         return ret;
 162 }
 163
 164 LTTNG_HIDDEN
 165 void lttng_condition_init(struct lttng_condition *condition,
 166                 enum lttng_condition_type type)
 167 {
 168         condition->type = type;
 169 }