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 =
  63                         LTTNG_LOG_LEVEL_RULE_STATUS_OK;
  64
  65         if (!rule || !level || !is_log_level_rule_exactly_type(rule)) {
  66                 status = LTTNG_LOG_LEVEL_RULE_STATUS_INVALID;
  67                 goto end;
  68         }
  69
  70         *level = rule->level;
  71 end:
  72         return status;
  73 }
  74
  75 struct lttng_log_level_rule *
  76 lttng_log_level_rule_at_least_as_severe_as_create(int level)
  77 {
  78         struct lttng_log_level_rule *rule = NULL;
  79
  80         rule = zmalloc(sizeof(struct lttng_log_level_rule));
  81         if (!rule) {
  82                 goto end;
  83         }
  84
  85         rule->type = LTTNG_LOG_LEVEL_RULE_TYPE_AT_LEAST_AS_SEVERE_AS;
  86         rule->level = level;
  87
  88 end:
  89         return rule;
  90 }
  91
  92 enum lttng_log_level_rule_status
  93 lttng_log_level_rule_at_least_as_severe_as_get_level(
  94                 const struct lttng_log_level_rule *rule, int *level)
  95 {
  96         enum lttng_log_level_rule_status status = LTTNG_LOG_LEVEL_RULE_STATUS_OK;
  97
  98         if (!rule || !level ||
  99                         !is_log_level_rule_at_least_as_severe_type(rule)) {
 100                 status = LTTNG_LOG_LEVEL_RULE_STATUS_INVALID;
 101                 goto end;
 102         }
 103
 104         *level = rule->level;
 105 end:
 106         return status;
 107 }
 108
 109 void lttng_log_level_rule_destroy(struct lttng_log_level_rule *log_level_rule)
 110 {
 111         free(log_level_rule);
 112 }
 113
 114 LTTNG_HIDDEN
 115 ssize_t lttng_log_level_rule_create_from_payload(
 116                 struct lttng_payload_view *view,
 117                 struct lttng_log_level_rule **_rule)
 118 {
 119         ssize_t ret;
 120         size_t offset = 0;
 121         struct lttng_log_level_rule *rule = NULL;
 122         const struct lttng_log_level_rule_comm *comm =
 123                         (const struct lttng_log_level_rule_comm *)
 124                                         view->buffer.data;
 125
 126         offset += sizeof(*comm);
 127
 128         if (!_rule) {
 129                 ret = -1;
 130                 goto end;
 131         }
 132
 133         if (view->buffer.size < sizeof(*comm)) {
 134                 ret = -1;
 135                 goto end;
 136         }
 137
 138         switch (comm->type) {
 139         case LTTNG_LOG_LEVEL_RULE_TYPE_EXACTLY:
 140                 rule = lttng_log_level_rule_exactly_create((int) comm->level);
 141                 break;
 142         case LTTNG_LOG_LEVEL_RULE_TYPE_AT_LEAST_AS_SEVERE_AS:
 143                 rule = lttng_log_level_rule_at_least_as_severe_as_create(
 144                                 (int) comm->level);
 145                 break;
 146         default:
 147                 abort();
 148         }
 149
 150         if (!rule) {
 151                 ret = -1;
 152                 goto end;
 153         }
 154
 155         *_rule = rule;
 156         ret = offset;
 157
 158 end:
 159         return ret;
 160 }
 161
 162 LTTNG_HIDDEN
 163 int lttng_log_level_rule_serialize(const struct lttng_log_level_rule *rule,
 164                 struct lttng_payload *payload)
 165 {
 166         int ret;
 167         struct lttng_log_level_rule_comm comm;
 168
 169
 170         if (!rule) {
 171                 ret = 0;
 172                 goto end;
 173         }
 174
 175         comm.type = (int8_t) rule->type;
 176         comm.level = (int32_t) rule->level;
 177
 178         DBG("Serializing log level rule of type %d", rule->type);
 179         ret = lttng_dynamic_buffer_append(&payload->buffer, &comm,
 180                         sizeof(comm));
 181         if (ret) {
 182                 goto end;
 183         }
 184
 185 end:
 186         return ret;
 187 }
 188
 189 LTTNG_HIDDEN
 190 bool lttng_log_level_rule_is_equal(const struct lttng_log_level_rule *a,
 191                 const struct lttng_log_level_rule *b)
 192 {
 193         bool is_equal = false;
 194
 195         if (a == NULL && b == NULL) {
 196                 /* Both are null. */
 197                 is_equal = true;
 198                 goto end;
 199         }
 200
 201         if (a == NULL || b == NULL) {
 202                 /* One is NULL.*/
 203                 goto end;
 204         }
 205
 206         if (a == b) {
 207                 /* Same object.*/
 208                 is_equal = true;
 209                 goto end;
 210         }
 211
 212         if (a->type != b->type) {
 213                 goto end;
 214         }
 215
 216         if (a->level != b->level) {
 217                 goto end;
 218         }
 219
 220         is_equal = true;
 221
 222 end:
 223         return is_equal;
 224 }
 225
 226 LTTNG_HIDDEN
 227 struct lttng_log_level_rule *lttng_log_level_rule_copy(
 228                 const struct lttng_log_level_rule *source)
 229 {
 230         struct lttng_log_level_rule *copy = NULL;
 231
 232         assert(source);
 233
 234         copy = zmalloc(sizeof(struct lttng_log_level_rule));
 235         if (!copy) {
 236                 goto end;
 237         }
 238
 239         copy->type = source->type;
 240         copy->level = source->level;
 241 end:
 242         return copy;
 243 }
 244
 245 LTTNG_HIDDEN
 246 void lttng_log_level_rule_to_loglevel(
 247                 const struct lttng_log_level_rule *log_level_rule,
 248                 enum lttng_loglevel_type *loglevel_type,
 249                 int *loglevel_value)
 250 {
 251         assert(log_level_rule);
 252
 253         switch (log_level_rule->type) {
 254         case LTTNG_LOG_LEVEL_RULE_TYPE_EXACTLY:
 255                 *loglevel_type = LTTNG_EVENT_LOGLEVEL_SINGLE;
 256                 break;
 257         case LTTNG_LOG_LEVEL_RULE_TYPE_AT_LEAST_AS_SEVERE_AS:
 258                 *loglevel_type = LTTNG_EVENT_LOGLEVEL_RANGE;
 259                 break;
 260         default:
 261                 abort();
 262         }
 263
 264         *loglevel_value = log_level_rule->level;
 265 }
 266
 267 LTTNG_HIDDEN
 268 unsigned long lttng_log_level_rule_hash(
 269                 const struct lttng_log_level_rule *log_level_rule)
 270 {
 271         unsigned long hash;
 272         enum lttng_log_level_rule_status llr_status;
 273         int log_level_value;
 274         enum lttng_log_level_rule_type type;
 275
 276         assert(log_level_rule);
 277
 278         type = lttng_log_level_rule_get_type(log_level_rule);
 279
 280         switch (type) {
 281         case LTTNG_LOG_LEVEL_RULE_TYPE_EXACTLY:
 282                 llr_status = lttng_log_level_rule_exactly_get_level(
 283                                 log_level_rule, &log_level_value);
 284                 break;
 285         case LTTNG_LOG_LEVEL_RULE_TYPE_AT_LEAST_AS_SEVERE_AS:
 286                 llr_status = lttng_log_level_rule_at_least_as_severe_as_get_level(
 287                                 log_level_rule, &log_level_value);
 288                 break;
 289         default:
 290                 abort();
 291                 break;
 292         }
 293
 294         assert(llr_status == LTTNG_LOG_LEVEL_RULE_STATUS_OK);
 295
 296         hash = hash_key_ulong((void *) (unsigned long) type, lttng_ht_seed);
 297
 298         hash ^= hash_key_ulong((void *) (unsigned long) log_level_value,
 299                         lttng_ht_seed);
 300
 301         return hash;
 302 }