src/common/event-rule/event-rule.c

   1 /*
   2  * Copyright (C) 2019 Jonathan Rajotte
   3  * <jonathan.rajotte-julien@efficios.com>
   4  *
   5  * SPDX-License-Identifier: LGPL-2.1-only
   6  *
   7  */
   8
   9 #include <assert.h>
  10 #include <common/error.h>
  11 #include <common/macros.h>
  12 #include <common/payload.h>
  13 #include <common/payload-view.h>
  14 #include <common/hashtable/hashtable.h>
  15 #include <common/hashtable/utils.h>
  16 #include <lttng/event-rule/event-rule-internal.h>
  17 #include <lttng/event-rule/kernel-kprobe-internal.h>
  18 #include <lttng/event-rule/kernel-syscall-internal.h>
  19 #include <lttng/event-rule/log4j-logging-internal.h>
  20 #include <lttng/event-rule/jul-logging-internal.h>
  21 #include <lttng/event-rule/python-logging-internal.h>
  22 #include <lttng/event-rule/tracepoint-internal.h>
  23 #include <lttng/event-rule/kernel-tracepoint-internal.h>
  24 #include <lttng/event-rule/kernel-uprobe-internal.h>
  25 #include <lttng/event-rule/user-tracepoint-internal.h>
  26 #include <stdbool.h>
  27
  28 enum lttng_event_rule_type lttng_event_rule_get_type(
  29                 const struct lttng_event_rule *event_rule)
  30 {
  31         return event_rule ? event_rule->type : LTTNG_EVENT_RULE_TYPE_UNKNOWN;
  32 }
  33
  34 LTTNG_HIDDEN
  35 enum lttng_domain_type lttng_event_rule_get_domain_type(
  36                 const struct lttng_event_rule *event_rule)
  37 {
  38         enum lttng_domain_type domain_type = LTTNG_DOMAIN_NONE;
  39
  40         switch (lttng_event_rule_get_type(event_rule)) {
  41         case LTTNG_EVENT_RULE_TYPE_TRACEPOINT:
  42         {
  43                 enum lttng_event_rule_status status;
  44                 status = lttng_event_rule_tracepoint_get_domain_type(event_rule, &domain_type);
  45                 assert(status == LTTNG_EVENT_RULE_STATUS_OK);
  46                 break;
  47         }
  48         case LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT:
  49                 domain_type = LTTNG_DOMAIN_UST;
  50                 break;
  51         case LTTNG_EVENT_RULE_TYPE_JUL_LOGGING:
  52                 domain_type = LTTNG_DOMAIN_JUL;
  53                 break;
  54         case LTTNG_EVENT_RULE_TYPE_LOG4J_LOGGING:
  55                 domain_type = LTTNG_DOMAIN_LOG4J;
  56                 break;
  57         case LTTNG_EVENT_RULE_TYPE_PYTHON_LOGGING:
  58                 domain_type = LTTNG_DOMAIN_PYTHON;
  59                 break;
  60         case LTTNG_EVENT_RULE_TYPE_KERNEL_SYSCALL:
  61         case LTTNG_EVENT_RULE_TYPE_KERNEL_KPROBE:
  62         case LTTNG_EVENT_RULE_TYPE_KERNEL_FUNCTION:
  63         case LTTNG_EVENT_RULE_TYPE_KERNEL_UPROBE:
  64         case LTTNG_EVENT_RULE_TYPE_KERNEL_TRACEPOINT:
  65                 domain_type = LTTNG_DOMAIN_KERNEL;
  66                 break;
  67         case LTTNG_EVENT_RULE_TYPE_UNKNOWN:
  68                 domain_type = LTTNG_DOMAIN_NONE;
  69                 break;
  70         }
  71
  72         return domain_type;
  73 }
  74
  75 static void lttng_event_rule_release(struct urcu_ref *ref)
  76 {
  77         struct lttng_event_rule *event_rule =
  78                         container_of(ref, typeof(*event_rule), ref);
  79
  80         assert(event_rule->destroy);
  81         event_rule->destroy(event_rule);
  82 }
  83
  84 void lttng_event_rule_destroy(struct lttng_event_rule *event_rule)
  85 {
  86         lttng_event_rule_put(event_rule);
  87 }
  88
  89 LTTNG_HIDDEN
  90 bool lttng_event_rule_validate(const struct lttng_event_rule *event_rule)
  91 {
  92         bool valid;
  93
  94         if (!event_rule) {
  95                 valid = false;
  96                 goto end;
  97         }
  98
  99         if (!event_rule->validate) {
 100                 /* Sub-class guarantees that it can never be invalid. */
 101                 valid = true;
 102                 goto end;
 103         }
 104
 105         valid = event_rule->validate(event_rule);
 106 end:
 107         return valid;
 108 }
 109
 110 LTTNG_HIDDEN
 111 int lttng_event_rule_serialize(const struct lttng_event_rule *event_rule,
 112                 struct lttng_payload *payload)
 113 {
 114         int ret;
 115         struct lttng_event_rule_comm event_rule_comm = {};
 116
 117         if (!event_rule) {
 118                 ret = -1;
 119                 goto end;
 120         }
 121
 122         event_rule_comm.event_rule_type = (int8_t) event_rule->type;
 123
 124         ret = lttng_dynamic_buffer_append(
 125                         &payload->buffer, &event_rule_comm, sizeof(event_rule_comm));
 126         if (ret) {
 127                 goto end;
 128         }
 129
 130         ret = event_rule->serialize(event_rule, payload);
 131         if (ret) {
 132                 goto end;
 133         }
 134 end:
 135         return ret;
 136 }
 137
 138 LTTNG_HIDDEN
 139 bool lttng_event_rule_is_equal(const struct lttng_event_rule *a,
 140                 const struct lttng_event_rule *b)
 141 {
 142         bool is_equal = false;
 143
 144         if (!a || !b) {
 145                 goto end;
 146         }
 147
 148         if (a->type != b->type) {
 149                 goto end;
 150         }
 151
 152         if (a == b) {
 153                 is_equal = true;
 154                 goto end;
 155         }
 156
 157         is_equal = a->equal ? a->equal(a, b) : true;
 158 end:
 159         return is_equal;
 160 }
 161
 162 LTTNG_HIDDEN
 163 ssize_t lttng_event_rule_create_from_payload(
 164                 struct lttng_payload_view *view,
 165                 struct lttng_event_rule **event_rule)
 166 {
 167         ssize_t ret, consumed = 0;
 168         event_rule_create_from_payload_cb create_from_payload = NULL;
 169         const struct lttng_event_rule_comm *event_rule_comm;
 170         const struct lttng_payload_view event_rule_comm_view =
 171                         lttng_payload_view_from_view(
 172                                         view, 0, sizeof(*event_rule_comm));
 173
 174         if (!view || !event_rule) {
 175                 ret = -1;
 176                 goto end;
 177         }
 178
 179         if (!lttng_payload_view_is_valid(&event_rule_comm_view)) {
 180                 ret = -1;
 181                 goto end;
 182         }
 183
 184         DBG("Deserializing event_rule from payload");
 185         event_rule_comm = (const struct lttng_event_rule_comm *) event_rule_comm_view.buffer.data;
 186         consumed += sizeof(*event_rule_comm);
 187
 188         switch ((enum lttng_event_rule_type) event_rule_comm->event_rule_type) {
 189         case LTTNG_EVENT_RULE_TYPE_TRACEPOINT:
 190                 create_from_payload =
 191                                 lttng_event_rule_tracepoint_create_from_payload;
 192                 break;
 193         case LTTNG_EVENT_RULE_TYPE_KERNEL_KPROBE:
 194                 create_from_payload = lttng_event_rule_kernel_kprobe_create_from_payload;
 195                 break;
 196         case LTTNG_EVENT_RULE_TYPE_KERNEL_FUNCTION:
 197                 /* TODO */
 198                 break;
 199         case LTTNG_EVENT_RULE_TYPE_KERNEL_UPROBE:
 200                 create_from_payload = lttng_event_rule_kernel_uprobe_create_from_payload;
 201                 break;
 202         case LTTNG_EVENT_RULE_TYPE_KERNEL_SYSCALL:
 203                 create_from_payload =
 204                                 lttng_event_rule_kernel_syscall_create_from_payload;
 205                 break;
 206         case LTTNG_EVENT_RULE_TYPE_KERNEL_TRACEPOINT:
 207                 create_from_payload =
 208                                 lttng_event_rule_kernel_tracepoint_create_from_payload;
 209                 break;
 210         case LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT:
 211                 create_from_payload =
 212                                 lttng_event_rule_user_tracepoint_create_from_payload;
 213                 break;
 214         case LTTNG_EVENT_RULE_TYPE_JUL_LOGGING:
 215                 create_from_payload =
 216                                 lttng_event_rule_jul_logging_create_from_payload;
 217                 break;
 218         case LTTNG_EVENT_RULE_TYPE_LOG4J_LOGGING:
 219                 create_from_payload =
 220                                 lttng_event_rule_log4j_logging_create_from_payload;
 221                 break;
 222         case LTTNG_EVENT_RULE_TYPE_PYTHON_LOGGING:
 223                 create_from_payload =
 224                                 lttng_event_rule_python_logging_create_from_payload;
 225                 break;
 226         default:
 227                 ERR("Attempted to create event rule of unknown type (%i)",
 228                                 (int) event_rule_comm->event_rule_type);
 229                 ret = -1;
 230                 goto end;
 231         }
 232
 233         assert(create_from_payload);
 234
 235         {
 236                 struct lttng_payload_view child_view =
 237                                 lttng_payload_view_from_view(
 238                                                 view, consumed, -1);
 239
 240                 ret = create_from_payload(&child_view, event_rule);
 241                 if (ret < 0) {
 242                         goto end;
 243                 }
 244
 245                 consumed += ret;
 246         }
 247
 248         if (!lttng_event_rule_validate(*event_rule)) {
 249                 ret = -1;
 250                 goto end;
 251         }
 252
 253         ret = consumed;
 254 end:
 255         return ret;
 256 }
 257
 258 LTTNG_HIDDEN
 259 void lttng_event_rule_init(struct lttng_event_rule *event_rule,
 260                 enum lttng_event_rule_type type)
 261 {
 262         urcu_ref_init(&event_rule->ref);
 263         event_rule->type = type;
 264 }
 265
 266 LTTNG_HIDDEN
 267 bool lttng_event_rule_get(struct lttng_event_rule *event_rule)
 268 {
 269         return urcu_ref_get_unless_zero(&event_rule->ref);
 270 }
 271
 272 LTTNG_HIDDEN
 273 void lttng_event_rule_put(struct lttng_event_rule *event_rule)
 274 {
 275         if (!event_rule) {
 276                 return;
 277         }
 278
 279         assert(event_rule->ref.refcount);
 280         urcu_ref_put(&event_rule->ref, lttng_event_rule_release);
 281 }
 282
 283 LTTNG_HIDDEN
 284 enum lttng_error_code lttng_event_rule_generate_filter_bytecode(
 285                 struct lttng_event_rule *rule,
 286                 const struct lttng_credentials *creds)
 287 {
 288         assert(rule->generate_filter_bytecode);
 289         return rule->generate_filter_bytecode(rule, creds);
 290 }
 291
 292 LTTNG_HIDDEN
 293 const char *lttng_event_rule_get_filter(const struct lttng_event_rule *rule)
 294 {
 295         assert(rule->get_filter);
 296         return rule->get_filter(rule);
 297 }
 298
 299 LTTNG_HIDDEN
 300 const struct lttng_bytecode *lttng_event_rule_get_filter_bytecode(
 301                 const struct lttng_event_rule *rule)
 302 {
 303         assert(rule->get_filter_bytecode);
 304         return rule->get_filter_bytecode(rule);
 305 }
 306
 307 LTTNG_HIDDEN
 308 enum lttng_event_rule_generate_exclusions_status
 309 lttng_event_rule_generate_exclusions(const struct lttng_event_rule *rule,
 310                 struct lttng_event_exclusion **exclusions)
 311 {
 312         assert(rule->generate_exclusions);
 313         return rule->generate_exclusions(rule, exclusions);
 314 }
 315
 316 LTTNG_HIDDEN
 317 struct lttng_event *lttng_event_rule_generate_lttng_event(
 318                 const struct lttng_event_rule *rule)
 319 {
 320         assert(rule->generate_lttng_event);
 321         return rule->generate_lttng_event(rule);
 322 }
 323
 324 LTTNG_HIDDEN
 325 bool lttng_event_rule_targets_agent_domain(const struct lttng_event_rule *rule)
 326 {
 327         bool targets_agent_domain = false;
 328         enum lttng_domain_type type = lttng_event_rule_get_domain_type(rule);
 329
 330         switch (type) {
 331         case LTTNG_DOMAIN_JUL:
 332         case LTTNG_DOMAIN_LOG4J:
 333         case LTTNG_DOMAIN_PYTHON:
 334                 targets_agent_domain = true;
 335                 break;
 336         case LTTNG_DOMAIN_UST:
 337         case LTTNG_DOMAIN_KERNEL:
 338                 targets_agent_domain = false;
 339                 break;
 340         default:
 341                 abort();
 342         };
 343
 344         return targets_agent_domain;
 345 }
 346
 347 const char *lttng_event_rule_type_str(enum lttng_event_rule_type type)
 348 {
 349         switch (type) {
 350         case LTTNG_EVENT_RULE_TYPE_UNKNOWN:
 351                 return "unknown";
 352         case LTTNG_EVENT_RULE_TYPE_TRACEPOINT:
 353                 return "tracepoint";
 354         case LTTNG_EVENT_RULE_TYPE_KERNEL_SYSCALL:
 355                 return "kernel syscall";
 356         case LTTNG_EVENT_RULE_TYPE_KERNEL_KPROBE:
 357                 return "kernel kprobe";
 358         case LTTNG_EVENT_RULE_TYPE_KERNEL_FUNCTION:
 359                 return "function";
 360         case LTTNG_EVENT_RULE_TYPE_KERNEL_UPROBE:
 361                 return "kernel uprobe";
 362         case LTTNG_EVENT_RULE_TYPE_KERNEL_TRACEPOINT:
 363                 return "kernel tracepoint";
 364         case LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT:
 365                 return "user tracepoint";
 366         case LTTNG_EVENT_RULE_TYPE_JUL_LOGGING:
 367                 return "jul logging";
 368         case LTTNG_EVENT_RULE_TYPE_LOG4J_LOGGING:
 369                 return "log4j logging";
 370         case LTTNG_EVENT_RULE_TYPE_PYTHON_LOGGING:
 371                 return "python logging";
 372
 373         default:
 374                 abort();
 375         }
 376 }
 377
 378 LTTNG_HIDDEN
 379 unsigned long lttng_event_rule_hash(const struct lttng_event_rule *rule)
 380 {
 381         assert(rule->hash);
 382         return rule->hash(rule);
 383 }