src/common/log-level-rule.c

   1 /*
   2  * Copyright (C) 2020 Jonathan Rajotte <jonathan.rajotte-julien@efficios.com>
   3  *
   4  * SPDX-License-Identifier: LGPL-2.1-only
   5  *
   6  */
   7
   8 #include <assert.h>
   9 #include <common/dynamic-buffer.h>
  10 #include <common/error.h>
  11 #include <common/macros.h>
  12 #include <common/hashtable/hashtable.h>
  13 #include <common/hashtable/utils.h>
  14 #include <lttng/log-level-rule-internal.h>
  15 #include <lttng/log-level-rule.h>
  16 #include <stdbool.h>
  17 #include <stdlib.h>
  18
  19 static bool is_log_level_rule_exactly_type(const struct lttng_log_level_rule *rule)
  20 {
  21         enum lttng_log_level_rule_type type =
  22                         lttng_log_level_rule_get_type(rule);
  23
  24         return type == LTTNG_LOG_LEVEL_RULE_TYPE_EXACTLY;
  25 }
  26
  27 static bool is_log_level_rule_at_least_as_severe_type(const struct lttng_log_level_rule *rule)
  28 {
  29
  30         enum lttng_log_level_rule_type type =
  31                         lttng_log_level_rule_get_type(rule);
  32
  33         return type == LTTNG_LOG_LEVEL_RULE_TYPE_AT_LEAST_AS_SEVERE_AS;
  34 }
  35
  36 enum lttng_log_level_rule_type lttng_log_level_rule_get_type(
  37                 const struct lttng_log_level_rule *rule)
  38 {
  39         return rule ? rule->type : LTTNG_LOG_LEVEL_RULE_TYPE_UNKNOWN;
  40 }
  41
  42 struct lttng_log_level_rule *lttng_log_level_rule_exactly_create(
  43                 int level)
  44 {
  45         struct lttng_log_level_rule *rule = NULL;
  46
  47         rule = zmalloc(sizeof(struct lttng_log_level_rule));
  48         if (!rule) {
  49                 goto end;
  50         }
  51
  52         rule->type = LTTNG_LOG_LEVEL_RULE_TYPE_EXACTLY;
  53         rule->level = level;
  54
  55 end:
  56         return rule;
  57 }
  58
  59 enum lttng_log_level_rule_status lttng_log_level_rule_exactly_get_level(
  60                 const struct lttng_log_level_rule *rule, int *level)
  61 {
  62         enum lttng_log_level_rule_status status = LTTNG_LOG_LEVEL_RULE_STATUS_OK;
  63         if (!rule || !level || !is_log_level_rule_exactly_type(rule)) {
  64                 status = LTTNG_LOG_LEVEL_RULE_STATUS_INVALID;
  65                 goto end;
  66         }
  67
  68         *level = rule->level;
  69 end:
  70         return status;
  71 }
  72
  73 struct lttng_log_level_rule *
  74 lttng_log_level_rule_at_least_as_severe_as_create(int level)
  75 {
  76         struct lttng_log_level_rule *rule = NULL;
  77
  78         rule = zmalloc(sizeof(struct lttng_log_level_rule));
  79         if (!rule) {
  80                 goto end;
  81         }
  82
  83         rule->type = LTTNG_LOG_LEVEL_RULE_TYPE_AT_LEAST_AS_SEVERE_AS;
  84         rule->level = level;
  85
  86 end:
  87         return rule;
  88 }
  89
  90 enum lttng_log_level_rule_status
  91 lttng_log_level_rule_at_least_as_severe_as_get_level(
  92                 const struct lttng_log_level_rule *rule, int *level)
  93 {
  94         enum lttng_log_level_rule_status status = LTTNG_LOG_LEVEL_RULE_STATUS_OK;
  95         if (!rule || !level || !is_log_level_rule_at_least_as_severe_type(rule)) {
  96                 status = LTTNG_LOG_LEVEL_RULE_STATUS_INVALID;
  97                 goto end;
  98         }
  99
 100         *level = rule->level;
 101 end:
 102         return status;
 103 }
 104
 105 void lttng_log_level_rule_destroy(struct lttng_log_level_rule *log_level_rule)
 106 {
 107         free(log_level_rule);
 108 }
 109
 110 LTTNG_HIDDEN
 111 ssize_t lttng_log_level_rule_create_from_payload(
 112                 struct lttng_payload_view *view,
 113                 struct lttng_log_level_rule **_rule)
 114 {
 115         ssize_t ret;
 116         size_t offset = 0;
 117         struct lttng_log_level_rule *rule = NULL;
 118         const struct lttng_log_level_rule_comm *comm =
 119                         (const struct lttng_log_level_rule_comm *)
 120                                         view->buffer.data;
 121
 122         offset += sizeof(*comm);
 123
 124         if (!_rule) {
 125                 ret = -1;
 126                 goto end;
 127         }
 128
 129         if (view->buffer.size < sizeof(*comm)) {
 130                 ret = -1;
 131                 goto end;
 132         }
 133
 134         switch (comm->type) {
 135         case LTTNG_LOG_LEVEL_RULE_TYPE_EXACTLY:
 136                 rule = lttng_log_level_rule_exactly_create((int) comm->level);
 137                 break;
 138         case LTTNG_LOG_LEVEL_RULE_TYPE_AT_LEAST_AS_SEVERE_AS:
 139                 rule = lttng_log_level_rule_at_least_as_severe_as_create(
 140                                 (int) comm->level);
 141                 break;
 142         default:
 143                 abort();
 144         }
 145
 146         if (!rule) {
 147                 ret = -1;
 148                 goto end;
 149         }
 150
 151         *_rule = rule;
 152         ret = offset;
 153
 154 end:
 155         return ret;
 156 }
 157
 158 LTTNG_HIDDEN
 159 int lttng_log_level_rule_serialize(const struct lttng_log_level_rule *rule,
 160                 struct lttng_payload *payload)
 161 {
 162         int ret;
 163         struct lttng_log_level_rule_comm comm;
 164
 165
 166         if (!rule) {
 167                 ret = 0;
 168                 goto end;
 169         }
 170
 171         comm.type = (int8_t) rule->type;
 172         comm.level = (int32_t) rule->level;
 173
 174         DBG("Serializing log level rule of type %d", rule->type);
 175         ret = lttng_dynamic_buffer_append(&payload->buffer, &comm,
 176                         sizeof(comm));
 177         if (ret) {
 178                 goto end;
 179         }
 180
 181 end:
 182         return ret;
 183 }
 184
 185 LTTNG_HIDDEN
 186 bool lttng_log_level_rule_is_equal(const struct lttng_log_level_rule *a,
 187                 const struct lttng_log_level_rule *b)
 188 {
 189         bool is_equal = false;
 190
 191         if (a == NULL && b == NULL) {
 192                 /* Both are null. */
 193                 is_equal = true;
 194                 goto end;
 195         }
 196
 197         if (a == NULL || b == NULL) {
 198                 /* One is NULL.*/
 199                 goto end;
 200         }
 201
 202         if (a == b) {
 203                 /* Same object.*/
 204                 is_equal = true;
 205                 goto end;
 206         }
 207
 208         if (a->type != b->type) {
 209                 goto end;
 210         }
 211
 212         if (a->level != b->level) {
 213                 goto end;
 214         }
 215
 216         is_equal = true;
 217
 218 end:
 219         return is_equal;
 220 }
 221
 222 LTTNG_HIDDEN
 223 struct lttng_log_level_rule * lttng_log_level_rule_copy(const struct lttng_log_level_rule *source)
 224 {
 225         struct lttng_log_level_rule *copy = NULL;
 226
 227         assert(source);
 228
 229         copy = zmalloc(sizeof(struct lttng_log_level_rule));
 230         if (!copy) {
 231                 goto end;
 232         }
 233
 234         copy->type = source->type;
 235         copy->level = source->level;
 236 end:
 237         return copy;
 238 }
 239
 240 LTTNG_HIDDEN
 241 void lttng_log_level_rule_to_loglevel(
 242                 const struct lttng_log_level_rule *log_level_rule,
 243                 enum lttng_loglevel_type *loglevel_type,
 244                 int *loglevel_value)
 245 {
 246         assert(log_level_rule);
 247
 248         switch(log_level_rule->type)
 249         {
 250         case LTTNG_LOG_LEVEL_RULE_TYPE_EXACTLY:
 251                 *loglevel_type = LTTNG_EVENT_LOGLEVEL_SINGLE;
 252                 break;
 253         case LTTNG_LOG_LEVEL_RULE_TYPE_AT_LEAST_AS_SEVERE_AS:
 254                 *loglevel_type = LTTNG_EVENT_LOGLEVEL_RANGE;
 255                 break;
 256         default:
 257                 abort();
 258         }
 259
 260         *loglevel_value = log_level_rule->level;
 261 }
 262
 263 LTTNG_HIDDEN
 264 unsigned long lttng_log_level_rule_hash(
 265                 const struct lttng_log_level_rule *log_level_rule)
 266 {
 267         unsigned long hash;
 268         enum lttng_log_level_rule_status llr_status;
 269         int log_level_value;
 270         enum lttng_log_level_rule_type type;
 271
 272         assert(log_level_rule);
 273
 274         type = lttng_log_level_rule_get_type(log_level_rule);
 275
 276         switch (type) {
 277         case LTTNG_LOG_LEVEL_RULE_TYPE_EXACTLY:
 278                 llr_status = lttng_log_level_rule_exactly_get_level(
 279                                 log_level_rule, &log_level_value);
 280                 break;
 281         case LTTNG_LOG_LEVEL_RULE_TYPE_AT_LEAST_AS_SEVERE_AS:
 282                 llr_status = lttng_log_level_rule_at_least_as_severe_as_get_level(
 283                                 log_level_rule, &log_level_value);
 284                 break;
 285         default:
 286                 abort();
 287                 break;
 288         }
 289
 290         assert(llr_status == LTTNG_LOG_LEVEL_RULE_STATUS_OK);
 291
 292         hash = hash_key_ulong((void *) (unsigned long) type, lttng_ht_seed);
 293
 294         hash ^= hash_key_ulong((void *) (unsigned long) log_level_value,
 295                         lttng_ht_seed);
 296
 297         return hash;
 298 }