src/common/event-rule/python-logging.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/python-logging-internal.h>
  22 #include <lttng/event.h>
  23 #include <lttng/log-level-rule.h>
  24
  25 #define IS_PYTHON_LOGGING_EVENT_RULE(rule) \
  26         (lttng_event_rule_get_type(rule) == LTTNG_EVENT_RULE_TYPE_PYTHON_LOGGING)
  27
  28 static void lttng_event_rule_python_logging_destroy(struct lttng_event_rule *rule)
  29 {
  30         struct lttng_event_rule_python_logging *python_logging;
  31
  32         if (rule == NULL) {
  33                 return;
  34         }
  35
  36         python_logging = container_of(
  37                         rule, struct lttng_event_rule_python_logging, parent);
  38
  39         lttng_log_level_rule_destroy(python_logging->log_level_rule);
  40         free(python_logging->pattern);
  41         free(python_logging->filter_expression);
  42         free(python_logging->internal_filter.filter);
  43         free(python_logging->internal_filter.bytecode);
  44         free(python_logging);
  45 }
  46
  47 static bool lttng_event_rule_python_logging_validate(
  48                 const struct lttng_event_rule *rule)
  49 {
  50         bool valid = false;
  51         struct lttng_event_rule_python_logging *python_logging;
  52
  53         if (!rule) {
  54                 goto end;
  55         }
  56
  57         python_logging = container_of(
  58                         rule, struct lttng_event_rule_python_logging, parent);
  59
  60         /* Required field. */
  61         if (!python_logging->pattern) {
  62                 ERR("Invalid python_logging event rule: a pattern must be set.");
  63                 goto end;
  64         }
  65
  66         valid = true;
  67 end:
  68         return valid;
  69 }
  70
  71 static int lttng_event_rule_python_logging_serialize(
  72                 const struct lttng_event_rule *rule,
  73                 struct lttng_payload *payload)
  74 {
  75         int ret;
  76         size_t pattern_len, filter_expression_len, header_offset;
  77         size_t size_before_log_level_rule;
  78         struct lttng_event_rule_python_logging *python_logging;
  79         struct lttng_event_rule_python_logging_comm python_logging_comm;
  80         struct lttng_event_rule_python_logging_comm *header;
  81
  82         if (!rule || !IS_PYTHON_LOGGING_EVENT_RULE(rule)) {
  83                 ret = -1;
  84                 goto end;
  85         }
  86
  87         header_offset = payload->buffer.size;
  88
  89         DBG("Serializing python_logging event rule.");
  90         python_logging = container_of(
  91                         rule, struct lttng_event_rule_python_logging, parent);
  92
  93         pattern_len = strlen(python_logging->pattern) + 1;
  94
  95         if (python_logging->filter_expression != NULL) {
  96                 filter_expression_len =
  97                                 strlen(python_logging->filter_expression) + 1;
  98         } else {
  99                 filter_expression_len = 0;
 100         }
 101
 102         python_logging_comm.pattern_len = pattern_len;
 103         python_logging_comm.filter_expression_len = filter_expression_len;
 104
 105         ret = lttng_dynamic_buffer_append(&payload->buffer, &python_logging_comm,
 106                         sizeof(python_logging_comm));
 107         if (ret) {
 108                 goto end;
 109         }
 110
 111         ret = lttng_dynamic_buffer_append(
 112                         &payload->buffer, python_logging->pattern, pattern_len);
 113         if (ret) {
 114                 goto end;
 115         }
 116
 117         ret = lttng_dynamic_buffer_append(&payload->buffer, python_logging->filter_expression,
 118                         filter_expression_len);
 119         if (ret) {
 120                 goto end;
 121         }
 122
 123         size_before_log_level_rule = payload->buffer.size;
 124
 125         ret = lttng_log_level_rule_serialize(python_logging->log_level_rule, payload);
 126         if (ret < 0) {
 127                 goto end;
 128         }
 129
 130         header = (typeof(header)) ((char *) payload->buffer.data + header_offset);
 131         header->log_level_rule_len =
 132                         payload->buffer.size - size_before_log_level_rule;
 133
 134 end:
 135         return ret;
 136 }
 137
 138 static bool lttng_event_rule_python_logging_is_equal(
 139                 const struct lttng_event_rule *_a,
 140                 const struct lttng_event_rule *_b)
 141 {
 142         bool is_equal = false;
 143         struct lttng_event_rule_python_logging *a, *b;
 144
 145         a = container_of(_a, struct lttng_event_rule_python_logging, parent);
 146         b = container_of(_b, struct lttng_event_rule_python_logging, parent);
 147
 148         /* Quick checks. */
 149
 150         if (!!a->filter_expression != !!b->filter_expression) {
 151                 goto end;
 152         }
 153
 154         /* Long check. */
 155         assert(a->pattern);
 156         assert(b->pattern);
 157         if (strcmp(a->pattern, b->pattern)) {
 158                 goto end;
 159         }
 160
 161         if (a->filter_expression && b->filter_expression) {
 162                 if (strcmp(a->filter_expression, b->filter_expression)) {
 163                         goto end;
 164                 }
 165         } else if (!!a->filter_expression != !!b->filter_expression) {
 166                 /* One is set; not the other. */
 167                 goto end;
 168         }
 169
 170         if (!lttng_log_level_rule_is_equal(
 171                                 a->log_level_rule, b->log_level_rule)) {
 172                 goto end;
 173         }
 174
 175         is_equal = true;
 176 end:
 177         return is_equal;
 178 }
 179
 180 /*
 181  * On success ret is 0;
 182  *
 183  * On error ret is negative.
 184  *
 185  * An event with NO loglevel and the name is * will return NULL.
 186  */
 187 static int generate_agent_filter(
 188                 const struct lttng_event_rule *rule, char **_agent_filter)
 189 {
 190         int err;
 191         int ret = 0;
 192         char *agent_filter = NULL;
 193         const char *pattern;
 194         const char *filter;
 195         const struct lttng_log_level_rule *log_level_rule = NULL;
 196         enum lttng_event_rule_status status;
 197
 198         assert(rule);
 199         assert(_agent_filter);
 200
 201         status = lttng_event_rule_python_logging_get_name_pattern(rule, &pattern);
 202         if (status != LTTNG_EVENT_RULE_STATUS_OK) {
 203                 ret = -1;
 204                 goto end;
 205         }
 206
 207         status = lttng_event_rule_python_logging_get_filter(rule, &filter);
 208         if (status == LTTNG_EVENT_RULE_STATUS_UNSET) {
 209                 filter = NULL;
 210         } else if (status != LTTNG_EVENT_RULE_STATUS_OK) {
 211                 ret = -1;
 212                 goto end;
 213         }
 214
 215
 216         /* Don't add filter for the '*' event. */
 217         if (strcmp(pattern, "*") != 0) {
 218                 if (filter) {
 219                         err = asprintf(&agent_filter,
 220                                         "(%s) && (logger_name == \"%s\")",
 221                                         filter, pattern);
 222                 } else {
 223                         err = asprintf(&agent_filter, "logger_name == \"%s\"",
 224                                         pattern);
 225                 }
 226
 227                 if (err < 0) {
 228                         PERROR("Failed to format agent filter string");
 229                         ret = -1;
 230                         goto end;
 231                 }
 232         }
 233
 234         status = lttng_event_rule_python_logging_get_log_level_rule(
 235                         rule, &log_level_rule);
 236         if (status == LTTNG_EVENT_RULE_STATUS_OK) {
 237                 enum lttng_log_level_rule_status llr_status;
 238                 const char *op;
 239                 int level;
 240
 241                 switch (lttng_log_level_rule_get_type(log_level_rule))
 242                 {
 243                 case LTTNG_LOG_LEVEL_RULE_TYPE_EXACTLY:
 244                         llr_status = lttng_log_level_rule_exactly_get_level(
 245                                         log_level_rule, &level);
 246                         op = "==";
 247                         break;
 248                 case LTTNG_LOG_LEVEL_RULE_TYPE_AT_LEAST_AS_SEVERE_AS:
 249                         llr_status = lttng_log_level_rule_at_least_as_severe_as_get_level(
 250                                         log_level_rule, &level);
 251                         op = ">=";
 252                         break;
 253                 default:
 254                         abort();
 255                 }
 256
 257                 if (llr_status != LTTNG_LOG_LEVEL_RULE_STATUS_OK) {
 258                         ret = -1;
 259                         goto end;
 260                 }
 261
 262                 if (filter || agent_filter) {
 263                         char *new_filter;
 264
 265                         err = asprintf(&new_filter,
 266                                         "(%s) && (int_loglevel %s %d)",
 267                                         agent_filter ? agent_filter : filter,
 268                                         op, level);
 269                         if (agent_filter) {
 270                                 free(agent_filter);
 271                         }
 272                         agent_filter = new_filter;
 273                 } else {
 274                         err = asprintf(&agent_filter, "int_loglevel %s %d", op,
 275                                         level);
 276                 }
 277
 278                 if (err < 0) {
 279                         PERROR("Failed to format agent filter string");
 280                         ret = -1;
 281                         goto end;
 282                 }
 283         }
 284
 285         *_agent_filter = agent_filter;
 286         agent_filter = NULL;
 287
 288 end:
 289         free(agent_filter);
 290         return ret;
 291 }
 292
 293 static enum lttng_error_code
 294 lttng_event_rule_python_logging_generate_filter_bytecode(
 295                 struct lttng_event_rule *rule,
 296                 const struct lttng_credentials *creds)
 297 {
 298         int ret;
 299         enum lttng_error_code ret_code;
 300         struct lttng_event_rule_python_logging *python_logging;
 301         enum lttng_event_rule_status status;
 302         const char *filter;
 303         struct lttng_bytecode *bytecode = NULL;
 304         char *agent_filter;
 305
 306         assert(rule);
 307
 308         python_logging = container_of(
 309                         rule, struct lttng_event_rule_python_logging, parent);
 310
 311         status = lttng_event_rule_python_logging_get_filter(rule, &filter);
 312         if (status == LTTNG_EVENT_RULE_STATUS_UNSET) {
 313                 filter = NULL;
 314         } else if (status != LTTNG_EVENT_RULE_STATUS_OK) {
 315                 ret_code = LTTNG_ERR_FILTER_INVAL;
 316                 goto end;
 317         }
 318
 319         if (filter && filter[0] == '\0') {
 320                 ret_code = LTTNG_ERR_FILTER_INVAL;
 321                 goto error;
 322         }
 323
 324         ret = generate_agent_filter(rule, &agent_filter);
 325         if (ret) {
 326                 ret_code = LTTNG_ERR_FILTER_INVAL;
 327                 goto error;
 328         }
 329
 330         python_logging->internal_filter.filter = agent_filter;
 331
 332         if (python_logging->internal_filter.filter == NULL) {
 333                 ret_code = LTTNG_OK;
 334                 goto end;
 335         }
 336
 337         ret = run_as_generate_filter_bytecode(
 338                         python_logging->internal_filter.filter, creds,
 339                         &bytecode);
 340         if (ret) {
 341                 ret_code = LTTNG_ERR_FILTER_INVAL;
 342                 goto end;
 343         }
 344
 345         python_logging->internal_filter.bytecode = bytecode;
 346         bytecode = NULL;
 347         ret_code = LTTNG_OK;
 348
 349 error:
 350 end:
 351         free(bytecode);
 352         return ret_code;
 353 }
 354
 355 static const char *lttng_event_rule_python_logging_get_internal_filter(
 356                 const struct lttng_event_rule *rule)
 357 {
 358         struct lttng_event_rule_python_logging *python_logging;
 359
 360         assert(rule);
 361         python_logging = container_of(
 362                         rule, struct lttng_event_rule_python_logging, parent);
 363         return python_logging->internal_filter.filter;
 364 }
 365
 366 static const struct lttng_bytecode *
 367 lttng_event_rule_python_logging_get_internal_filter_bytecode(
 368                 const struct lttng_event_rule *rule)
 369 {
 370         struct lttng_event_rule_python_logging *python_logging;
 371
 372         assert(rule);
 373         python_logging = container_of(
 374                         rule, struct lttng_event_rule_python_logging, parent);
 375         return python_logging->internal_filter.bytecode;
 376 }
 377
 378 static enum lttng_event_rule_generate_exclusions_status
 379 lttng_event_rule_python_logging_generate_exclusions(
 380                 const struct lttng_event_rule *rule,
 381                 struct lttng_event_exclusion **_exclusions)
 382 {
 383         /* Unsupported. */
 384         *_exclusions = NULL;
 385         return LTTNG_EVENT_RULE_GENERATE_EXCLUSIONS_STATUS_NONE;
 386 }
 387
 388 static unsigned long lttng_event_rule_python_logging_hash(
 389                 const struct lttng_event_rule *rule)
 390 {
 391         unsigned long hash;
 392         struct lttng_event_rule_python_logging *tp_rule =
 393                         container_of(rule, typeof(*tp_rule), parent);
 394
 395         hash = hash_key_ulong((void *) LTTNG_EVENT_RULE_TYPE_PYTHON_LOGGING,
 396                         lttng_ht_seed);
 397         hash ^= hash_key_str(tp_rule->pattern, lttng_ht_seed);
 398
 399         if (tp_rule->filter_expression) {
 400                 hash ^= hash_key_str(tp_rule->filter_expression, lttng_ht_seed);
 401         }
 402
 403         if (tp_rule->log_level_rule) {
 404                 hash ^= lttng_log_level_rule_hash(tp_rule->log_level_rule);
 405         }
 406
 407         return hash;
 408 }
 409
 410 static struct lttng_event *lttng_event_rule_python_logging_generate_lttng_event(
 411                 const struct lttng_event_rule *rule)
 412 {
 413         int ret;
 414         const struct lttng_event_rule_python_logging *python_logging;
 415         struct lttng_event *local_event = NULL;
 416         struct lttng_event *event = NULL;
 417         enum lttng_loglevel_type loglevel_type;
 418         int loglevel_value = 0;
 419         enum lttng_event_rule_status status;
 420         const struct lttng_log_level_rule *log_level_rule;
 421
 422         python_logging = container_of(
 423                         rule, const struct lttng_event_rule_python_logging, parent);
 424
 425         local_event = zmalloc(sizeof(*local_event));
 426         if (!local_event) {
 427                 goto error;
 428         }
 429
 430         local_event->type = LTTNG_EVENT_TRACEPOINT;
 431         ret = lttng_strncpy(local_event->name, python_logging->pattern,
 432                             sizeof(local_event->name));
 433         if (ret) {
 434                 ERR("Truncation occurred when copying event rule pattern to `lttng_event` structure: pattern = '%s'",
 435                                 python_logging->pattern);
 436                 goto error;
 437         }
 438
 439
 440         /* Map the log level rule to an equivalent lttng_loglevel. */
 441         status = lttng_event_rule_python_logging_get_log_level_rule(
 442                         rule, &log_level_rule);
 443         if (status == LTTNG_EVENT_RULE_STATUS_UNSET) {
 444                 loglevel_type = LTTNG_EVENT_LOGLEVEL_ALL;
 445                 loglevel_value = 0;
 446         } else if (status == LTTNG_EVENT_RULE_STATUS_OK) {
 447                 enum lttng_log_level_rule_status llr_status;
 448
 449                 switch (lttng_log_level_rule_get_type(log_level_rule)) {
 450                 case LTTNG_LOG_LEVEL_RULE_TYPE_EXACTLY:
 451                         llr_status = lttng_log_level_rule_exactly_get_level(
 452                                         log_level_rule, &loglevel_value);
 453                         loglevel_type = LTTNG_EVENT_LOGLEVEL_SINGLE;
 454                         break;
 455                 case LTTNG_LOG_LEVEL_RULE_TYPE_AT_LEAST_AS_SEVERE_AS:
 456                         llr_status = lttng_log_level_rule_at_least_as_severe_as_get_level(
 457                                         log_level_rule, &loglevel_value);
 458                         loglevel_type = LTTNG_EVENT_LOGLEVEL_RANGE;
 459                         break;
 460                 default:
 461                         abort();
 462                         break;
 463                 }
 464
 465                 if (llr_status != LTTNG_LOG_LEVEL_RULE_STATUS_OK) {
 466                         goto error;
 467                 }
 468         } else {
 469                 goto error;
 470         }
 471
 472         local_event->loglevel_type = loglevel_type;
 473         local_event->loglevel = loglevel_value;
 474
 475         event = local_event;
 476         local_event = NULL;
 477 error:
 478         free(local_event);
 479         return event;
 480 }
 481
 482 static enum lttng_error_code lttng_event_rule_python_logging_mi_serialize(
 483                 const struct lttng_event_rule *rule, struct mi_writer *writer)
 484 {
 485         int ret;
 486         enum lttng_error_code ret_code;
 487         enum lttng_event_rule_status status;
 488         const char *filter = NULL;
 489         const char *name_pattern = NULL;
 490         const struct lttng_log_level_rule *log_level_rule = NULL;
 491
 492         assert(rule);
 493         assert(writer);
 494         assert(IS_PYTHON_LOGGING_EVENT_RULE(rule));
 495
 496         status = lttng_event_rule_python_logging_get_name_pattern(
 497                         rule, &name_pattern);
 498         assert(status == LTTNG_EVENT_RULE_STATUS_OK);
 499         assert(name_pattern);
 500
 501         status = lttng_event_rule_python_logging_get_filter(rule, &filter);
 502         assert(status == LTTNG_EVENT_RULE_STATUS_OK ||
 503                         status == LTTNG_EVENT_RULE_STATUS_UNSET);
 504
 505         status = lttng_event_rule_python_logging_get_log_level_rule(
 506                         rule, &log_level_rule);
 507         assert(status == LTTNG_EVENT_RULE_STATUS_OK ||
 508                         status == LTTNG_EVENT_RULE_STATUS_UNSET);
 509
 510         /* Open event rule python logging element. */
 511         ret = mi_lttng_writer_open_element(
 512                         writer, mi_lttng_element_event_rule_python_logging);
 513         if (ret) {
 514                 goto mi_error;
 515         }
 516
 517         /* Name pattern. */
 518         ret = mi_lttng_writer_write_element_string(writer,
 519                         mi_lttng_element_event_rule_name_pattern, name_pattern);
 520         if (ret) {
 521                 goto mi_error;
 522         }
 523
 524         /* Filter expression. */
 525         if (filter != NULL) {
 526                 ret = mi_lttng_writer_write_element_string(writer,
 527                                 mi_lttng_element_event_rule_filter_expression,
 528                                 filter);
 529                 if (ret) {
 530                         goto mi_error;
 531                 }
 532         }
 533
 534         /* Log level rule. */
 535         if (log_level_rule) {
 536                 ret_code = lttng_log_level_rule_mi_serialize(
 537                                 log_level_rule, writer);
 538                 if (ret_code != LTTNG_OK) {
 539                         goto end;
 540                 }
 541         }
 542
 543         /* Close event rule python logging element. */
 544         ret = mi_lttng_writer_close_element(writer);
 545         if (ret) {
 546                 goto mi_error;
 547         }
 548
 549         ret_code = LTTNG_OK;
 550         goto end;
 551
 552 mi_error:
 553         ret_code = LTTNG_ERR_MI_IO_FAIL;
 554 end:
 555         return ret_code;
 556 }
 557
 558 struct lttng_event_rule *lttng_event_rule_python_logging_create(void)
 559 {
 560         struct lttng_event_rule *rule = NULL;
 561         struct lttng_event_rule_python_logging *tp_rule;
 562         enum lttng_event_rule_status status;
 563
 564         tp_rule = zmalloc(sizeof(struct lttng_event_rule_python_logging));
 565         if (!tp_rule) {
 566                 goto end;
 567         }
 568
 569         rule = &tp_rule->parent;
 570         lttng_event_rule_init(&tp_rule->parent, LTTNG_EVENT_RULE_TYPE_PYTHON_LOGGING);
 571         tp_rule->parent.validate = lttng_event_rule_python_logging_validate;
 572         tp_rule->parent.serialize = lttng_event_rule_python_logging_serialize;
 573         tp_rule->parent.equal = lttng_event_rule_python_logging_is_equal;
 574         tp_rule->parent.destroy = lttng_event_rule_python_logging_destroy;
 575         tp_rule->parent.generate_filter_bytecode =
 576                         lttng_event_rule_python_logging_generate_filter_bytecode;
 577         tp_rule->parent.get_filter =
 578                         lttng_event_rule_python_logging_get_internal_filter;
 579         tp_rule->parent.get_filter_bytecode =
 580                         lttng_event_rule_python_logging_get_internal_filter_bytecode;
 581         tp_rule->parent.generate_exclusions =
 582                         lttng_event_rule_python_logging_generate_exclusions;
 583         tp_rule->parent.hash = lttng_event_rule_python_logging_hash;
 584         tp_rule->parent.generate_lttng_event =
 585                         lttng_event_rule_python_logging_generate_lttng_event;
 586         tp_rule->parent.mi_serialize = lttng_event_rule_python_logging_mi_serialize;
 587
 588         tp_rule->log_level_rule = NULL;
 589
 590         /* Default pattern is '*'. */
 591         status = lttng_event_rule_python_logging_set_name_pattern(rule, "*");
 592         if (status != LTTNG_EVENT_RULE_STATUS_OK) {
 593                 lttng_event_rule_destroy(rule);
 594                 rule = NULL;
 595         }
 596
 597 end:
 598         return rule;
 599 }
 600
 601 LTTNG_HIDDEN
 602 ssize_t lttng_event_rule_python_logging_create_from_payload(
 603                 struct lttng_payload_view *view,
 604                 struct lttng_event_rule **_event_rule)
 605 {
 606         ssize_t ret, offset = 0;
 607         enum lttng_event_rule_status status;
 608         const struct lttng_event_rule_python_logging_comm *python_logging_comm;
 609         const char *pattern;
 610         const char *filter_expression = NULL;
 611         struct lttng_buffer_view current_buffer_view;
 612         struct lttng_event_rule *rule = NULL;
 613         struct lttng_log_level_rule *log_level_rule = NULL;
 614
 615         if (!_event_rule) {
 616                 ret = -1;
 617                 goto end;
 618         }
 619
 620         current_buffer_view = lttng_buffer_view_from_view(
 621                         &view->buffer, offset, sizeof(*python_logging_comm));
 622         if (!lttng_buffer_view_is_valid(&current_buffer_view)) {
 623                 ERR("Failed to initialize from malformed event rule python_logging: buffer too short to contain header.");
 624                 ret = -1;
 625                 goto end;
 626         }
 627
 628         python_logging_comm = (typeof(python_logging_comm)) current_buffer_view.data;
 629
 630         rule = lttng_event_rule_python_logging_create();
 631         if (!rule) {
 632                 ERR("Failed to create event rule python_logging.");
 633                 ret = -1;
 634                 goto end;
 635         }
 636
 637         /* Skip to payload. */
 638         offset += current_buffer_view.size;
 639
 640         /* Map the pattern. */
 641         current_buffer_view = lttng_buffer_view_from_view(
 642                         &view->buffer, offset, python_logging_comm->pattern_len);
 643
 644         if (!lttng_buffer_view_is_valid(&current_buffer_view)) {
 645                 ret = -1;
 646                 goto end;
 647         }
 648
 649         pattern = current_buffer_view.data;
 650         if (!lttng_buffer_view_contains_string(&current_buffer_view, pattern,
 651                         python_logging_comm->pattern_len)) {
 652                 ret = -1;
 653                 goto end;
 654         }
 655
 656         /* Skip after the pattern. */
 657         offset += python_logging_comm->pattern_len;
 658
 659         if (!python_logging_comm->filter_expression_len) {
 660                 goto skip_filter_expression;
 661         }
 662
 663         /* Map the filter_expression. */
 664         current_buffer_view = lttng_buffer_view_from_view(&view->buffer, offset,
 665                         python_logging_comm->filter_expression_len);
 666         if (!lttng_buffer_view_is_valid(&current_buffer_view)) {
 667                 ret = -1;
 668                 goto end;
 669         }
 670
 671         filter_expression = current_buffer_view.data;
 672         if (!lttng_buffer_view_contains_string(&current_buffer_view,
 673                         filter_expression,
 674                         python_logging_comm->filter_expression_len)) {
 675                 ret = -1;
 676                 goto end;
 677         }
 678
 679         /* Skip after the pattern. */
 680         offset += python_logging_comm->filter_expression_len;
 681
 682 skip_filter_expression:
 683         if (!python_logging_comm->log_level_rule_len) {
 684                 goto skip_log_level_rule;
 685         }
 686
 687         {
 688                 /* Map the log level rule. */
 689                 struct lttng_payload_view current_payload_view =
 690                                 lttng_payload_view_from_view(view, offset,
 691                                                 python_logging_comm->log_level_rule_len);
 692
 693                 ret = lttng_log_level_rule_create_from_payload(
 694                                 &current_payload_view, &log_level_rule);
 695                 if (ret < 0) {
 696                         ret = -1;
 697                         goto end;
 698                 }
 699
 700                 assert(ret == python_logging_comm->log_level_rule_len);
 701         }
 702
 703         /* Skip after the log level rule. */
 704         offset += python_logging_comm->log_level_rule_len;
 705
 706 skip_log_level_rule:
 707
 708         status = lttng_event_rule_python_logging_set_name_pattern(rule, pattern);
 709         if (status != LTTNG_EVENT_RULE_STATUS_OK) {
 710                 ERR("Failed to set event rule python_logging pattern.");
 711                 ret = -1;
 712                 goto end;
 713         }
 714
 715         if (filter_expression) {
 716                 status = lttng_event_rule_python_logging_set_filter(
 717                                 rule, filter_expression);
 718                 if (status != LTTNG_EVENT_RULE_STATUS_OK) {
 719                         ERR("Failed to set event rule python_logging pattern.");
 720                         ret = -1;
 721                         goto end;
 722                 }
 723         }
 724
 725         if (log_level_rule) {
 726                 status = lttng_event_rule_python_logging_set_log_level_rule(
 727                                 rule, log_level_rule);
 728                 if (status != LTTNG_EVENT_RULE_STATUS_OK) {
 729                         ERR("Failed to set event rule python_logging log level rule.");
 730                         ret = -1;
 731                         goto end;
 732                 }
 733         }
 734
 735         *_event_rule = rule;
 736         rule = NULL;
 737         ret = offset;
 738 end:
 739         lttng_log_level_rule_destroy(log_level_rule);
 740         lttng_event_rule_destroy(rule);
 741         return ret;
 742 }
 743
 744 enum lttng_event_rule_status lttng_event_rule_python_logging_set_name_pattern(
 745                 struct lttng_event_rule *rule, const char *pattern)
 746 {
 747         char *pattern_copy = NULL;
 748         struct lttng_event_rule_python_logging *python_logging;
 749         enum lttng_event_rule_status status = LTTNG_EVENT_RULE_STATUS_OK;
 750
 751         if (!rule || !IS_PYTHON_LOGGING_EVENT_RULE(rule) || !pattern ||
 752                         strlen(pattern) == 0) {
 753                 status = LTTNG_EVENT_RULE_STATUS_INVALID;
 754                 goto end;
 755         }
 756
 757         python_logging = container_of(
 758                         rule, struct lttng_event_rule_python_logging, parent);
 759         pattern_copy = strdup(pattern);
 760         if (!pattern_copy) {
 761                 status = LTTNG_EVENT_RULE_STATUS_ERROR;
 762                 goto end;
 763         }
 764
 765         /* Normalize the pattern. */
 766         strutils_normalize_star_glob_pattern(pattern_copy);
 767
 768         free(python_logging->pattern);
 769
 770         python_logging->pattern = pattern_copy;
 771         pattern_copy = NULL;
 772 end:
 773         return status;
 774 }
 775
 776 enum lttng_event_rule_status lttng_event_rule_python_logging_get_name_pattern(
 777                 const struct lttng_event_rule *rule, const char **pattern)
 778 {
 779         struct lttng_event_rule_python_logging *python_logging;
 780         enum lttng_event_rule_status status = LTTNG_EVENT_RULE_STATUS_OK;
 781
 782         if (!rule || !IS_PYTHON_LOGGING_EVENT_RULE(rule) || !pattern) {
 783                 status = LTTNG_EVENT_RULE_STATUS_INVALID;
 784                 goto end;
 785         }
 786
 787         python_logging = container_of(
 788                         rule, struct lttng_event_rule_python_logging, parent);
 789         if (!python_logging->pattern) {
 790                 status = LTTNG_EVENT_RULE_STATUS_UNSET;
 791                 goto end;
 792         }
 793
 794         *pattern = python_logging->pattern;
 795 end:
 796         return status;
 797 }
 798
 799 enum lttng_event_rule_status lttng_event_rule_python_logging_set_filter(
 800                 struct lttng_event_rule *rule, const char *expression)
 801 {
 802         char *expression_copy = NULL;
 803         struct lttng_event_rule_python_logging *python_logging;
 804         enum lttng_event_rule_status status = LTTNG_EVENT_RULE_STATUS_OK;
 805
 806         if (!rule || !IS_PYTHON_LOGGING_EVENT_RULE(rule) || !expression ||
 807                         strlen(expression) == 0) {
 808                 status = LTTNG_EVENT_RULE_STATUS_INVALID;
 809                 goto end;
 810         }
 811
 812         python_logging = container_of(
 813                         rule, struct lttng_event_rule_python_logging, parent);
 814         expression_copy = strdup(expression);
 815         if (!expression_copy) {
 816                 PERROR("Failed to copy filter expression");
 817                 status = LTTNG_EVENT_RULE_STATUS_ERROR;
 818                 goto end;
 819         }
 820
 821         if (python_logging->filter_expression) {
 822                 free(python_logging->filter_expression);
 823         }
 824
 825         python_logging->filter_expression = expression_copy;
 826         expression_copy = NULL;
 827 end:
 828         return status;
 829 }
 830
 831 enum lttng_event_rule_status lttng_event_rule_python_logging_get_filter(
 832                 const struct lttng_event_rule *rule, const char **expression)
 833 {
 834         struct lttng_event_rule_python_logging *python_logging;
 835         enum lttng_event_rule_status status = LTTNG_EVENT_RULE_STATUS_OK;
 836
 837         if (!rule || !IS_PYTHON_LOGGING_EVENT_RULE(rule) || !expression) {
 838                 status = LTTNG_EVENT_RULE_STATUS_INVALID;
 839                 goto end;
 840         }
 841
 842         python_logging = container_of(
 843                         rule, struct lttng_event_rule_python_logging, parent);
 844         if (!python_logging->filter_expression) {
 845                 status = LTTNG_EVENT_RULE_STATUS_UNSET;
 846                 goto end;
 847         }
 848
 849         *expression = python_logging->filter_expression;
 850 end:
 851         return status;
 852 }
 853
 854 static bool log_level_rule_valid(const struct lttng_log_level_rule *rule)
 855 {
 856         /*
 857          * For python, custom log level are possible, it is not clear if
 858          * negative value are accepted (NOTSET == 0) but the source code
 859          * validates against the int type implying that negative values
 860          * are accepted.
 861          */
 862         return true;
 863 }
 864
 865 enum lttng_event_rule_status lttng_event_rule_python_logging_set_log_level_rule(
 866                 struct lttng_event_rule *rule,
 867                 const struct lttng_log_level_rule *log_level_rule)
 868 {
 869         struct lttng_event_rule_python_logging *python_logging;
 870         enum lttng_event_rule_status status = LTTNG_EVENT_RULE_STATUS_OK;
 871         struct lttng_log_level_rule *copy = NULL;
 872
 873         if (!rule || !IS_PYTHON_LOGGING_EVENT_RULE(rule)) {
 874                 status = LTTNG_EVENT_RULE_STATUS_INVALID;
 875                 goto end;
 876         }
 877
 878         python_logging = container_of(
 879                         rule, struct lttng_event_rule_python_logging, parent);
 880
 881         if (!log_level_rule_valid(log_level_rule)) {
 882                 status = LTTNG_EVENT_RULE_STATUS_INVALID;
 883                 goto end;
 884         }
 885
 886         copy = lttng_log_level_rule_copy(log_level_rule);
 887         if (copy == NULL) {
 888                 status = LTTNG_EVENT_RULE_STATUS_ERROR;
 889                 goto end;
 890         }
 891
 892         if (python_logging->log_level_rule) {
 893                 lttng_log_level_rule_destroy(python_logging->log_level_rule);
 894         }
 895
 896         python_logging->log_level_rule = copy;
 897
 898 end:
 899         return status;
 900 }
 901
 902 enum lttng_event_rule_status lttng_event_rule_python_logging_get_log_level_rule(
 903                 const struct lttng_event_rule *rule,
 904                 const struct lttng_log_level_rule **log_level_rule
 905                 )
 906 {
 907         struct lttng_event_rule_python_logging *python_logging;
 908         enum lttng_event_rule_status status = LTTNG_EVENT_RULE_STATUS_OK;
 909
 910         if (!rule || !IS_PYTHON_LOGGING_EVENT_RULE(rule) || !log_level_rule) {
 911                 status = LTTNG_EVENT_RULE_STATUS_INVALID;
 912                 goto end;
 913         }
 914
 915         python_logging = container_of(
 916                         rule, struct lttng_event_rule_python_logging, parent);
 917         if (python_logging->log_level_rule == NULL) {
 918                 status = LTTNG_EVENT_RULE_STATUS_UNSET;
 919                 goto end;
 920         }
 921
 922         *log_level_rule = python_logging->log_level_rule;
 923 end:
 924         return status;
 925 }