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                 .condition_type = (int8_t) (condition ?
  71                                 condition->type : LTTNG_CONDITION_TYPE_UNKNOWN)
  72         };
  73
  74         if (!condition) {
  75                 ret = -1;
  76                 goto end;
  77         }
  78
  79         ret = sizeof(struct lttng_condition_comm);
  80         if (buf) {
  81                 memcpy(buf, &condition_comm, ret);
  82                 buf += ret;
  83         }
  84
  85         condition_size = condition->serialize(condition, buf);
  86         if (condition_size < 0) {
  87                 ret = condition_size;
  88                 goto end;
  89         }
  90         ret += condition_size;
  91 end:
  92         return ret;
  93 }
  94
  95 LTTNG_HIDDEN
  96 bool lttng_condition_is_equal(const struct lttng_condition *a,
  97                 const struct lttng_condition *b)
  98 {
  99         bool is_equal = false;
 100
 101         if (!a || !b) {
 102                 goto end;
 103         }
 104
 105         if (a->type != b->type) {
 106                 goto end;
 107         }
 108
 109         is_equal = a->equal ? a->equal(a, b) : true;
 110 end:
 111         return is_equal;
 112 }
 113
 114 LTTNG_HIDDEN
 115 ssize_t lttng_condition_create_from_buffer(
 116                 const struct lttng_buffer_view *buffer,
 117                 struct lttng_condition **condition)
 118 {
 119         ssize_t ret, condition_size = 0;
 120         const struct lttng_condition_comm *condition_comm;
 121         condition_create_from_buffer_cb create_from_buffer = NULL;
 122
 123         if (!buffer || !condition) {
 124                 ret = -1;
 125                 goto end;
 126         }
 127
 128         DBG("Deserializing condition from buffer");
 129         condition_comm = (const struct lttng_condition_comm *) buffer->data;
 130         condition_size += sizeof(*condition_comm);
 131
 132         switch ((enum lttng_condition_type) condition_comm->condition_type) {
 133         case LTTNG_CONDITION_TYPE_BUFFER_USAGE_LOW:
 134                 create_from_buffer = lttng_condition_buffer_usage_low_create_from_buffer;
 135                 break;
 136         case LTTNG_CONDITION_TYPE_BUFFER_USAGE_HIGH:
 137                 create_from_buffer = lttng_condition_buffer_usage_high_create_from_buffer;
 138                 break;
 139         default:
 140                 ERR("Attempted to create condition of unknown type (%i)",
 141                                 (int) condition_comm->condition_type);
 142                 ret = -1;
 143                 goto end;
 144         }
 145
 146         if (create_from_buffer) {
 147                 const struct lttng_buffer_view view =
 148                                 lttng_buffer_view_from_view(buffer,
 149                                         sizeof(*condition_comm), -1);
 150
 151                 ret = create_from_buffer(&view, condition);
 152                 if (ret < 0) {
 153                         goto end;
 154                 }
 155                 condition_size += ret;
 156
 157         } else {
 158                 abort();
 159         }
 160
 161         ret = condition_size;
 162 end:
 163         return ret;
 164 }
 165
 166 LTTNG_HIDDEN
 167 void lttng_condition_init(struct lttng_condition *condition,
 168                 enum lttng_condition_type type)
 169 {
 170         condition->type = type;
 171 }