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

   1 /*
   2  * Copyright (C) 2019 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/credentials.h>
  10 #include <common/error.h>
  11 #include <common/hashtable/hashtable.h>
  12 #include <common/hashtable/utils.h>
  13 #include <common/macros.h>
  14 #include <common/mi-lttng.h>
  15 #include <common/optional.h>
  16 #include <common/payload-view.h>
  17 #include <common/payload.h>
  18 #include <common/runas.h>
  19 #include <common/string-utils/string-utils.h>
  20 #include <lttng/event-rule/event-rule-internal.h>
  21 #include <lttng/event-rule/kernel-tracepoint-internal.h>
  22 #include <lttng/event.h>
  23
  24 #define IS_KERNEL_TRACEPOINT_EVENT_RULE(rule) \
  25         (lttng_event_rule_get_type(rule) == LTTNG_EVENT_RULE_TYPE_KERNEL_TRACEPOINT)
  26
  27 static void lttng_event_rule_kernel_tracepoint_destroy(struct lttng_event_rule *rule)
  28 {
  29         struct lttng_event_rule_kernel_tracepoint *tracepoint;
  30
  31         if (rule == NULL) {
  32                 return;
  33         }
  34
  35         tracepoint = container_of(
  36                         rule, struct lttng_event_rule_kernel_tracepoint, parent);
  37
  38         free(tracepoint->pattern);
  39         free(tracepoint->filter_expression);
  40         free(tracepoint->internal_filter.filter);
  41         free(tracepoint->internal_filter.bytecode);
  42         free(tracepoint);
  43 }
  44
  45 static bool lttng_event_rule_kernel_tracepoint_validate(
  46                 const struct lttng_event_rule *rule)
  47 {
  48         bool valid = false;
  49         struct lttng_event_rule_kernel_tracepoint *tracepoint;
  50
  51         if (!rule) {
  52                 goto end;
  53         }
  54
  55         tracepoint = container_of(
  56                         rule, struct lttng_event_rule_kernel_tracepoint, parent);
  57
  58         /* Required field. */
  59         if (!tracepoint->pattern) {
  60                 ERR("Invalid kernel tracepoint event rule: a pattern must be set.");
  61                 goto end;
  62         }
  63
  64         valid = true;
  65 end:
  66         return valid;
  67 }
  68
  69 static int lttng_event_rule_kernel_tracepoint_serialize(
  70                 const struct lttng_event_rule *rule,
  71                 struct lttng_payload *payload)
  72 {
  73         int ret;
  74         size_t pattern_len, filter_expression_len;
  75         struct lttng_event_rule_kernel_tracepoint *tracepoint;
  76         struct lttng_event_rule_kernel_tracepoint_comm tracepoint_comm;
  77
  78         if (!rule || !IS_KERNEL_TRACEPOINT_EVENT_RULE(rule)) {
  79                 ret = -1;
  80                 goto end;
  81         }
  82
  83         DBG("Serializing kernel tracepoint event rule.");
  84         tracepoint = container_of(
  85                         rule, struct lttng_event_rule_kernel_tracepoint, parent);
  86
  87         pattern_len = strlen(tracepoint->pattern) + 1;
  88
  89         if (tracepoint->filter_expression != NULL) {
  90                 filter_expression_len =
  91                                 strlen(tracepoint->filter_expression) + 1;
  92         } else {
  93                 filter_expression_len = 0;
  94         }
  95
  96         tracepoint_comm.pattern_len = pattern_len;
  97         tracepoint_comm.filter_expression_len = filter_expression_len;
  98
  99         ret = lttng_dynamic_buffer_append(&payload->buffer, &tracepoint_comm,
 100                         sizeof(tracepoint_comm));
 101         if (ret) {
 102                 goto end;
 103         }
 104
 105         ret = lttng_dynamic_buffer_append(
 106                         &payload->buffer, tracepoint->pattern, pattern_len);
 107         if (ret) {
 108                 goto end;
 109         }
 110
 111         ret = lttng_dynamic_buffer_append(&payload->buffer, tracepoint->filter_expression,
 112                         filter_expression_len);
 113         if (ret) {
 114                 goto end;
 115         }
 116
 117 end:
 118         return ret;
 119 }
 120
 121 static bool lttng_event_rule_kernel_tracepoint_is_equal(
 122                 const struct lttng_event_rule *_a,
 123                 const struct lttng_event_rule *_b)
 124 {
 125         bool is_equal = false;
 126         struct lttng_event_rule_kernel_tracepoint *a, *b;
 127
 128         a = container_of(_a, struct lttng_event_rule_kernel_tracepoint, parent);
 129         b = container_of(_b, struct lttng_event_rule_kernel_tracepoint, parent);
 130
 131         if (!!a->filter_expression != !!b->filter_expression) {
 132                 goto end;
 133         }
 134
 135         /* Long check. */
 136         assert(a->pattern);
 137         assert(b->pattern);
 138         if (strcmp(a->pattern, b->pattern)) {
 139                 goto end;
 140         }
 141
 142         if (a->filter_expression && b->filter_expression) {
 143                 if (strcmp(a->filter_expression, b->filter_expression)) {
 144                         goto end;
 145                 }
 146         } else if (!!a->filter_expression != !!b->filter_expression) {
 147                 /* One is set; not the other. */
 148                 goto end;
 149         }
 150
 151         is_equal = true;
 152 end:
 153         return is_equal;
 154 }
 155
 156 static enum lttng_error_code
 157 lttng_event_rule_kernel_tracepoint_generate_filter_bytecode(
 158                 struct lttng_event_rule *rule,
 159                 const struct lttng_credentials *creds)
 160 {
 161         int ret;
 162         enum lttng_error_code ret_code;
 163         struct lttng_event_rule_kernel_tracepoint *tracepoint;
 164         enum lttng_event_rule_status status;
 165         const char *filter;
 166         struct lttng_bytecode *bytecode = NULL;
 167
 168         assert(rule);
 169
 170         tracepoint = container_of(
 171                         rule, struct lttng_event_rule_kernel_tracepoint, parent);
 172
 173         status = lttng_event_rule_kernel_tracepoint_get_filter(rule, &filter);
 174         if (status == LTTNG_EVENT_RULE_STATUS_UNSET) {
 175                 filter = NULL;
 176         } else if (status != LTTNG_EVENT_RULE_STATUS_OK) {
 177                 ret_code = LTTNG_ERR_FILTER_INVAL;
 178                 goto end;
 179         }
 180
 181         if (filter && filter[0] == '\0') {
 182                 ret_code = LTTNG_ERR_FILTER_INVAL;
 183                 goto error;
 184         }
 185
 186         if (filter) {
 187                 tracepoint->internal_filter.filter = strdup(filter);
 188                 if (tracepoint->internal_filter.filter == NULL) {
 189                         ret_code = LTTNG_ERR_NOMEM;
 190                         goto error;
 191                 }
 192         } else {
 193                 tracepoint->internal_filter.filter = NULL;
 194         }
 195
 196         if (tracepoint->internal_filter.filter == NULL) {
 197                 ret_code = LTTNG_OK;
 198                 goto end;
 199         }
 200
 201         ret = run_as_generate_filter_bytecode(
 202                         tracepoint->internal_filter.filter, creds,
 203                         &bytecode);
 204         if (ret) {
 205                 ret_code = LTTNG_ERR_FILTER_INVAL;
 206                 goto end;
 207         }
 208
 209         tracepoint->internal_filter.bytecode = bytecode;
 210         bytecode = NULL;
 211         ret_code = LTTNG_OK;
 212
 213 error:
 214 end:
 215         free(bytecode);
 216         return ret_code;
 217 }
 218
 219 static const char *lttng_event_rule_kernel_tracepoint_get_internal_filter(
 220                 const struct lttng_event_rule *rule)
 221 {
 222         struct lttng_event_rule_kernel_tracepoint *tracepoint;
 223
 224         assert(rule);
 225         tracepoint = container_of(
 226                         rule, struct lttng_event_rule_kernel_tracepoint, parent);
 227         return tracepoint->internal_filter.filter;
 228 }
 229
 230 static const struct lttng_bytecode *
 231 lttng_event_rule_kernel_tracepoint_get_internal_filter_bytecode(
 232                 const struct lttng_event_rule *rule)
 233 {
 234         struct lttng_event_rule_kernel_tracepoint *tracepoint;
 235
 236         assert(rule);
 237         tracepoint = container_of(
 238                         rule, struct lttng_event_rule_kernel_tracepoint, parent);
 239         return tracepoint->internal_filter.bytecode;
 240 }
 241
 242 static enum lttng_event_rule_generate_exclusions_status
 243 lttng_event_rule_kernel_tracepoint_generate_exclusions(
 244                 const struct lttng_event_rule *rule,
 245                 struct lttng_event_exclusion **_exclusions)
 246 {
 247         /* Unsupported. */
 248         *_exclusions = NULL;
 249         return LTTNG_EVENT_RULE_GENERATE_EXCLUSIONS_STATUS_NONE;
 250 }
 251
 252 static unsigned long lttng_event_rule_kernel_tracepoint_hash(
 253                 const struct lttng_event_rule *rule)
 254 {
 255         unsigned long hash;
 256         struct lttng_event_rule_kernel_tracepoint *tp_rule =
 257                         container_of(rule, typeof(*tp_rule), parent);
 258
 259         hash = hash_key_ulong((void *) LTTNG_EVENT_RULE_TYPE_KERNEL_TRACEPOINT,
 260                         lttng_ht_seed);
 261         hash ^= hash_key_str(tp_rule->pattern, lttng_ht_seed);
 262
 263         if (tp_rule->filter_expression) {
 264                 hash ^= hash_key_str(tp_rule->filter_expression, lttng_ht_seed);
 265         }
 266
 267         return hash;
 268 }
 269
 270 static enum lttng_error_code lttng_event_rule_kernel_tracepoint_mi_serialize(
 271                 const struct lttng_event_rule *rule, struct mi_writer *writer)
 272 {
 273         int ret;
 274         enum lttng_error_code ret_code;
 275         enum lttng_event_rule_status status;
 276         const char *filter = NULL;
 277         const char *name_pattern = NULL;
 278
 279         assert(rule);
 280         assert(writer);
 281         assert(IS_KERNEL_TRACEPOINT_EVENT_RULE(rule));
 282
 283         status = lttng_event_rule_kernel_tracepoint_get_name_pattern(
 284                         rule, &name_pattern);
 285         assert(status == LTTNG_EVENT_RULE_STATUS_OK);
 286         assert(name_pattern);
 287
 288         status = lttng_event_rule_kernel_tracepoint_get_filter(rule, &filter);
 289         assert(status == LTTNG_EVENT_RULE_STATUS_OK ||
 290                         status == LTTNG_EVENT_RULE_STATUS_UNSET);
 291
 292         /* Open event rule kernel tracepoint element. */
 293         ret = mi_lttng_writer_open_element(
 294                         writer, mi_lttng_element_event_rule_kernel_tracepoint);
 295         if (ret) {
 296                 goto mi_error;
 297         }
 298
 299         /* Name pattern. */
 300         ret = mi_lttng_writer_write_element_string(writer,
 301                         mi_lttng_element_event_rule_name_pattern, name_pattern);
 302         if (ret) {
 303                 goto mi_error;
 304         }
 305
 306         /* Filter. */
 307         if (filter != NULL) {
 308                 ret = mi_lttng_writer_write_element_string(writer,
 309                                 mi_lttng_element_event_rule_filter_expression,
 310                                 filter);
 311                 if (ret) {
 312                         goto mi_error;
 313                 }
 314         }
 315
 316         /* Close event rule kernel tracepoint element. */
 317         ret = mi_lttng_writer_close_element(writer);
 318         if (ret) {
 319                 goto mi_error;
 320         }
 321
 322         ret_code = LTTNG_OK;
 323         goto end;
 324
 325 mi_error:
 326         ret_code = LTTNG_ERR_MI_IO_FAIL;
 327 end:
 328         return ret_code;
 329 }
 330
 331 struct lttng_event_rule *lttng_event_rule_kernel_tracepoint_create(void)
 332 {
 333         struct lttng_event_rule *rule = NULL;
 334         struct lttng_event_rule_kernel_tracepoint *tp_rule;
 335         enum lttng_event_rule_status status;
 336
 337         tp_rule = zmalloc(sizeof(struct lttng_event_rule_kernel_tracepoint));
 338         if (!tp_rule) {
 339                 goto end;
 340         }
 341
 342         rule = &tp_rule->parent;
 343         lttng_event_rule_init(&tp_rule->parent, LTTNG_EVENT_RULE_TYPE_KERNEL_TRACEPOINT);
 344         tp_rule->parent.validate = lttng_event_rule_kernel_tracepoint_validate;
 345         tp_rule->parent.serialize = lttng_event_rule_kernel_tracepoint_serialize;
 346         tp_rule->parent.equal = lttng_event_rule_kernel_tracepoint_is_equal;
 347         tp_rule->parent.destroy = lttng_event_rule_kernel_tracepoint_destroy;
 348         tp_rule->parent.generate_filter_bytecode =
 349                         lttng_event_rule_kernel_tracepoint_generate_filter_bytecode;
 350         tp_rule->parent.get_filter =
 351                         lttng_event_rule_kernel_tracepoint_get_internal_filter;
 352         tp_rule->parent.get_filter_bytecode =
 353                         lttng_event_rule_kernel_tracepoint_get_internal_filter_bytecode;
 354         tp_rule->parent.generate_exclusions =
 355                         lttng_event_rule_kernel_tracepoint_generate_exclusions;
 356         tp_rule->parent.hash = lttng_event_rule_kernel_tracepoint_hash;
 357         tp_rule->parent.mi_serialize = lttng_event_rule_kernel_tracepoint_mi_serialize;
 358
 359         /* Not necessary for now. */
 360         tp_rule->parent.generate_lttng_event = NULL;
 361
 362         /* Default pattern is '*'. */
 363         status = lttng_event_rule_kernel_tracepoint_set_name_pattern(rule, "*");
 364         if (status != LTTNG_EVENT_RULE_STATUS_OK) {
 365                 lttng_event_rule_destroy(rule);
 366                 rule = NULL;
 367         }
 368
 369 end:
 370         return rule;
 371 }
 372
 373 LTTNG_HIDDEN
 374 ssize_t lttng_event_rule_kernel_tracepoint_create_from_payload(
 375                 struct lttng_payload_view *view,
 376                 struct lttng_event_rule **_event_rule)
 377 {
 378         ssize_t ret, offset = 0;
 379         enum lttng_event_rule_status status;
 380         const struct lttng_event_rule_kernel_tracepoint_comm *tracepoint_comm;
 381         const char *pattern;
 382         const char *filter_expression = NULL;
 383         struct lttng_buffer_view current_buffer_view;
 384         struct lttng_event_rule *rule = NULL;
 385
 386         if (!_event_rule) {
 387                 ret = -1;
 388                 goto end;
 389         }
 390
 391         current_buffer_view = lttng_buffer_view_from_view(
 392                         &view->buffer, offset, sizeof(*tracepoint_comm));
 393         if (!lttng_buffer_view_is_valid(&current_buffer_view)) {
 394                 ERR("Failed to initialize from malformed event rule kernel tracepoint: buffer too short to contain header.");
 395                 ret = -1;
 396                 goto end;
 397         }
 398
 399         tracepoint_comm = (typeof(tracepoint_comm)) current_buffer_view.data;
 400
 401         /* Skip to payload. */
 402         offset += current_buffer_view.size;
 403
 404         /* Map the pattern. */
 405         current_buffer_view = lttng_buffer_view_from_view(
 406                         &view->buffer, offset, tracepoint_comm->pattern_len);
 407
 408         if (!lttng_buffer_view_is_valid(&current_buffer_view)) {
 409                 ret = -1;
 410                 goto end;
 411         }
 412
 413         pattern = current_buffer_view.data;
 414         if (!lttng_buffer_view_contains_string(&current_buffer_view, pattern,
 415                         tracepoint_comm->pattern_len)) {
 416                 ret = -1;
 417                 goto end;
 418         }
 419
 420         /* Skip after the pattern. */
 421         offset += tracepoint_comm->pattern_len;
 422
 423         if (!tracepoint_comm->filter_expression_len) {
 424                 goto skip_filter_expression;
 425         }
 426
 427         /* Map the filter_expression. */
 428         current_buffer_view = lttng_buffer_view_from_view(&view->buffer, offset,
 429                         tracepoint_comm->filter_expression_len);
 430         if (!lttng_buffer_view_is_valid(&current_buffer_view)) {
 431                 ret = -1;
 432                 goto end;
 433         }
 434
 435         filter_expression = current_buffer_view.data;
 436         if (!lttng_buffer_view_contains_string(&current_buffer_view,
 437                         filter_expression,
 438                         tracepoint_comm->filter_expression_len)) {
 439                 ret = -1;
 440                 goto end;
 441         }
 442
 443         /* Skip after the pattern. */
 444         offset += tracepoint_comm->filter_expression_len;
 445
 446 skip_filter_expression:
 447
 448         rule = lttng_event_rule_kernel_tracepoint_create();
 449         if (!rule) {
 450                 ERR("Failed to create event rule kernel tracepoint.");
 451                 ret = -1;
 452                 goto end;
 453         }
 454
 455         status = lttng_event_rule_kernel_tracepoint_set_name_pattern(rule, pattern);
 456         if (status != LTTNG_EVENT_RULE_STATUS_OK) {
 457                 ERR("Failed to set event rule kernel tracepoint pattern.");
 458                 ret = -1;
 459                 goto end;
 460         }
 461
 462         if (filter_expression) {
 463                 status = lttng_event_rule_kernel_tracepoint_set_filter(
 464                                 rule, filter_expression);
 465                 if (status != LTTNG_EVENT_RULE_STATUS_OK) {
 466                         ERR("Failed to set event rule kernel tracepoint pattern.");
 467                         ret = -1;
 468                         goto end;
 469                 }
 470         }
 471
 472         *_event_rule = rule;
 473         rule = NULL;
 474         ret = offset;
 475 end:
 476         lttng_event_rule_destroy(rule);
 477         return ret;
 478 }
 479
 480 enum lttng_event_rule_status lttng_event_rule_kernel_tracepoint_set_name_pattern(
 481                 struct lttng_event_rule *rule, const char *pattern)
 482 {
 483         char *pattern_copy = NULL;
 484         struct lttng_event_rule_kernel_tracepoint *tracepoint;
 485         enum lttng_event_rule_status status = LTTNG_EVENT_RULE_STATUS_OK;
 486
 487         if (!rule || !IS_KERNEL_TRACEPOINT_EVENT_RULE(rule) || !pattern ||
 488                         strlen(pattern) == 0) {
 489                 status = LTTNG_EVENT_RULE_STATUS_INVALID;
 490                 goto end;
 491         }
 492
 493         tracepoint = container_of(
 494                         rule, struct lttng_event_rule_kernel_tracepoint, parent);
 495         pattern_copy = strdup(pattern);
 496         if (!pattern_copy) {
 497                 status = LTTNG_EVENT_RULE_STATUS_ERROR;
 498                 goto end;
 499         }
 500
 501         /* Normalize the pattern. */
 502         strutils_normalize_star_glob_pattern(pattern_copy);
 503
 504         free(tracepoint->pattern);
 505
 506         tracepoint->pattern = pattern_copy;
 507         pattern_copy = NULL;
 508 end:
 509         return status;
 510 }
 511
 512 enum lttng_event_rule_status lttng_event_rule_kernel_tracepoint_get_name_pattern(
 513                 const struct lttng_event_rule *rule, const char **pattern)
 514 {
 515         struct lttng_event_rule_kernel_tracepoint *tracepoint;
 516         enum lttng_event_rule_status status = LTTNG_EVENT_RULE_STATUS_OK;
 517
 518         if (!rule || !IS_KERNEL_TRACEPOINT_EVENT_RULE(rule) || !pattern) {
 519                 status = LTTNG_EVENT_RULE_STATUS_INVALID;
 520                 goto end;
 521         }
 522
 523         tracepoint = container_of(
 524                         rule, struct lttng_event_rule_kernel_tracepoint, parent);
 525         if (!tracepoint->pattern) {
 526                 status = LTTNG_EVENT_RULE_STATUS_UNSET;
 527                 goto end;
 528         }
 529
 530         *pattern = tracepoint->pattern;
 531 end:
 532         return status;
 533 }
 534
 535 enum lttng_event_rule_status lttng_event_rule_kernel_tracepoint_set_filter(
 536                 struct lttng_event_rule *rule, const char *expression)
 537 {
 538         char *expression_copy = NULL;
 539         struct lttng_event_rule_kernel_tracepoint *tracepoint;
 540         enum lttng_event_rule_status status = LTTNG_EVENT_RULE_STATUS_OK;
 541
 542         if (!rule || !IS_KERNEL_TRACEPOINT_EVENT_RULE(rule) || !expression ||
 543                         strlen(expression) == 0) {
 544                 status = LTTNG_EVENT_RULE_STATUS_INVALID;
 545                 goto end;
 546         }
 547
 548         tracepoint = container_of(
 549                         rule, struct lttng_event_rule_kernel_tracepoint, parent);
 550         expression_copy = strdup(expression);
 551         if (!expression_copy) {
 552                 PERROR("Failed to copy filter expression");
 553                 status = LTTNG_EVENT_RULE_STATUS_ERROR;
 554                 goto end;
 555         }
 556
 557         if (tracepoint->filter_expression) {
 558                 free(tracepoint->filter_expression);
 559         }
 560
 561         tracepoint->filter_expression = expression_copy;
 562         expression_copy = NULL;
 563 end:
 564         return status;
 565 }
 566
 567 enum lttng_event_rule_status lttng_event_rule_kernel_tracepoint_get_filter(
 568                 const struct lttng_event_rule *rule, const char **expression)
 569 {
 570         struct lttng_event_rule_kernel_tracepoint *tracepoint;
 571         enum lttng_event_rule_status status = LTTNG_EVENT_RULE_STATUS_OK;
 572
 573         if (!rule || !IS_KERNEL_TRACEPOINT_EVENT_RULE(rule) || !expression) {
 574                 status = LTTNG_EVENT_RULE_STATUS_INVALID;
 575                 goto end;
 576         }
 577
 578         tracepoint = container_of(
 579                         rule, struct lttng_event_rule_kernel_tracepoint, parent);
 580         if (!tracepoint->filter_expression) {
 581                 status = LTTNG_EVENT_RULE_STATUS_UNSET;
 582                 goto end;
 583         }
 584
 585         *expression = tracepoint->filter_expression;
 586 end:
 587         return status;
 588 }