src/lib/lttng-ust/lttng-bytecode.c

   1 /*
   2  * SPDX-License-Identifier: MIT
   3  *
   4  * Copyright (C) 2010-2016 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   5  *
   6  * LTTng UST bytecode code.
   7  */
   8
   9 #define _LGPL_SOURCE
  10 #include <stddef.h>
  11 #include <stdint.h>
  12
  13 #include <urcu/rculist.h>
  14
  15 #include "context-internal.h"
  16 #include "lttng-bytecode.h"
  17 #include "lib/lttng-ust/events.h"
  18 #include "common/macros.h"
  19
  20 static const char *opnames[] = {
  21         [ BYTECODE_OP_UNKNOWN ] = "UNKNOWN",
  22
  23         [ BYTECODE_OP_RETURN ] = "RETURN",
  24
  25         /* binary */
  26         [ BYTECODE_OP_MUL ] = "MUL",
  27         [ BYTECODE_OP_DIV ] = "DIV",
  28         [ BYTECODE_OP_MOD ] = "MOD",
  29         [ BYTECODE_OP_PLUS ] = "PLUS",
  30         [ BYTECODE_OP_MINUS ] = "MINUS",
  31         [ BYTECODE_OP_BIT_RSHIFT ] = "BIT_RSHIFT",
  32         [ BYTECODE_OP_BIT_LSHIFT ] = "BIT_LSHIFT",
  33         [ BYTECODE_OP_BIT_AND ] = "BIT_AND",
  34         [ BYTECODE_OP_BIT_OR ] = "BIT_OR",
  35         [ BYTECODE_OP_BIT_XOR ] = "BIT_XOR",
  36
  37         /* binary comparators */
  38         [ BYTECODE_OP_EQ ] = "EQ",
  39         [ BYTECODE_OP_NE ] = "NE",
  40         [ BYTECODE_OP_GT ] = "GT",
  41         [ BYTECODE_OP_LT ] = "LT",
  42         [ BYTECODE_OP_GE ] = "GE",
  43         [ BYTECODE_OP_LE ] = "LE",
  44
  45         /* string binary comparators */
  46         [ BYTECODE_OP_EQ_STRING ] = "EQ_STRING",
  47         [ BYTECODE_OP_NE_STRING ] = "NE_STRING",
  48         [ BYTECODE_OP_GT_STRING ] = "GT_STRING",
  49         [ BYTECODE_OP_LT_STRING ] = "LT_STRING",
  50         [ BYTECODE_OP_GE_STRING ] = "GE_STRING",
  51         [ BYTECODE_OP_LE_STRING ] = "LE_STRING",
  52
  53         /* s64 binary comparators */
  54         [ BYTECODE_OP_EQ_S64 ] = "EQ_S64",
  55         [ BYTECODE_OP_NE_S64 ] = "NE_S64",
  56         [ BYTECODE_OP_GT_S64 ] = "GT_S64",
  57         [ BYTECODE_OP_LT_S64 ] = "LT_S64",
  58         [ BYTECODE_OP_GE_S64 ] = "GE_S64",
  59         [ BYTECODE_OP_LE_S64 ] = "LE_S64",
  60
  61         /* double binary comparators */
  62         [ BYTECODE_OP_EQ_DOUBLE ] = "EQ_DOUBLE",
  63         [ BYTECODE_OP_NE_DOUBLE ] = "NE_DOUBLE",
  64         [ BYTECODE_OP_GT_DOUBLE ] = "GT_DOUBLE",
  65         [ BYTECODE_OP_LT_DOUBLE ] = "LT_DOUBLE",
  66         [ BYTECODE_OP_GE_DOUBLE ] = "GE_DOUBLE",
  67         [ BYTECODE_OP_LE_DOUBLE ] = "LE_DOUBLE",
  68
  69         /* Mixed S64-double binary comparators */
  70         [ BYTECODE_OP_EQ_DOUBLE_S64 ] = "EQ_DOUBLE_S64",
  71         [ BYTECODE_OP_NE_DOUBLE_S64 ] = "NE_DOUBLE_S64",
  72         [ BYTECODE_OP_GT_DOUBLE_S64 ] = "GT_DOUBLE_S64",
  73         [ BYTECODE_OP_LT_DOUBLE_S64 ] = "LT_DOUBLE_S64",
  74         [ BYTECODE_OP_GE_DOUBLE_S64 ] = "GE_DOUBLE_S64",
  75         [ BYTECODE_OP_LE_DOUBLE_S64 ] = "LE_DOUBLE_S64",
  76
  77         [ BYTECODE_OP_EQ_S64_DOUBLE ] = "EQ_S64_DOUBLE",
  78         [ BYTECODE_OP_NE_S64_DOUBLE ] = "NE_S64_DOUBLE",
  79         [ BYTECODE_OP_GT_S64_DOUBLE ] = "GT_S64_DOUBLE",
  80         [ BYTECODE_OP_LT_S64_DOUBLE ] = "LT_S64_DOUBLE",
  81         [ BYTECODE_OP_GE_S64_DOUBLE ] = "GE_S64_DOUBLE",
  82         [ BYTECODE_OP_LE_S64_DOUBLE ] = "LE_S64_DOUBLE",
  83
  84         /* unary */
  85         [ BYTECODE_OP_UNARY_PLUS ] = "UNARY_PLUS",
  86         [ BYTECODE_OP_UNARY_MINUS ] = "UNARY_MINUS",
  87         [ BYTECODE_OP_UNARY_NOT ] = "UNARY_NOT",
  88         [ BYTECODE_OP_UNARY_PLUS_S64 ] = "UNARY_PLUS_S64",
  89         [ BYTECODE_OP_UNARY_MINUS_S64 ] = "UNARY_MINUS_S64",
  90         [ BYTECODE_OP_UNARY_NOT_S64 ] = "UNARY_NOT_S64",
  91         [ BYTECODE_OP_UNARY_PLUS_DOUBLE ] = "UNARY_PLUS_DOUBLE",
  92         [ BYTECODE_OP_UNARY_MINUS_DOUBLE ] = "UNARY_MINUS_DOUBLE",
  93         [ BYTECODE_OP_UNARY_NOT_DOUBLE ] = "UNARY_NOT_DOUBLE",
  94
  95         /* logical */
  96         [ BYTECODE_OP_AND ] = "AND",
  97         [ BYTECODE_OP_OR ] = "OR",
  98
  99         /* load field ref */
 100         [ BYTECODE_OP_LOAD_FIELD_REF ] = "LOAD_FIELD_REF",
 101         [ BYTECODE_OP_LOAD_FIELD_REF_STRING ] = "LOAD_FIELD_REF_STRING",
 102         [ BYTECODE_OP_LOAD_FIELD_REF_SEQUENCE ] = "LOAD_FIELD_REF_SEQUENCE",
 103         [ BYTECODE_OP_LOAD_FIELD_REF_S64 ] = "LOAD_FIELD_REF_S64",
 104         [ BYTECODE_OP_LOAD_FIELD_REF_DOUBLE ] = "LOAD_FIELD_REF_DOUBLE",
 105
 106         /* load from immediate operand */
 107         [ BYTECODE_OP_LOAD_STRING ] = "LOAD_STRING",
 108         [ BYTECODE_OP_LOAD_S64 ] = "LOAD_S64",
 109         [ BYTECODE_OP_LOAD_DOUBLE ] = "LOAD_DOUBLE",
 110
 111         /* cast */
 112         [ BYTECODE_OP_CAST_TO_S64 ] = "CAST_TO_S64",
 113         [ BYTECODE_OP_CAST_DOUBLE_TO_S64 ] = "CAST_DOUBLE_TO_S64",
 114         [ BYTECODE_OP_CAST_NOP ] = "CAST_NOP",
 115
 116         /* get context ref */
 117         [ BYTECODE_OP_GET_CONTEXT_REF ] = "GET_CONTEXT_REF",
 118         [ BYTECODE_OP_GET_CONTEXT_REF_STRING ] = "GET_CONTEXT_REF_STRING",
 119         [ BYTECODE_OP_GET_CONTEXT_REF_S64 ] = "GET_CONTEXT_REF_S64",
 120         [ BYTECODE_OP_GET_CONTEXT_REF_DOUBLE ] = "GET_CONTEXT_REF_DOUBLE",
 121
 122         /* load userspace field ref */
 123         [ BYTECODE_OP_LOAD_FIELD_REF_USER_STRING ] = "LOAD_FIELD_REF_USER_STRING",
 124         [ BYTECODE_OP_LOAD_FIELD_REF_USER_SEQUENCE ] = "LOAD_FIELD_REF_USER_SEQUENCE",
 125
 126         /*
 127          * load immediate star globbing pattern (literal string)
 128          * from immediate.
 129          */
 130         [ BYTECODE_OP_LOAD_STAR_GLOB_STRING ] = "LOAD_STAR_GLOB_STRING",
 131
 132         /* globbing pattern binary operator: apply to */
 133         [ BYTECODE_OP_EQ_STAR_GLOB_STRING ] = "EQ_STAR_GLOB_STRING",
 134         [ BYTECODE_OP_NE_STAR_GLOB_STRING ] = "NE_STAR_GLOB_STRING",
 135
 136         /*
 137          * Instructions for recursive traversal through composed types.
 138          */
 139         [ BYTECODE_OP_GET_CONTEXT_ROOT ] = "GET_CONTEXT_ROOT",
 140         [ BYTECODE_OP_GET_APP_CONTEXT_ROOT ] = "GET_APP_CONTEXT_ROOT",
 141         [ BYTECODE_OP_GET_PAYLOAD_ROOT ] = "GET_PAYLOAD_ROOT",
 142
 143         [ BYTECODE_OP_GET_SYMBOL ] = "GET_SYMBOL",
 144         [ BYTECODE_OP_GET_SYMBOL_FIELD ] = "GET_SYMBOL_FIELD",
 145         [ BYTECODE_OP_GET_INDEX_U16 ] = "GET_INDEX_U16",
 146         [ BYTECODE_OP_GET_INDEX_U64 ] = "GET_INDEX_U64",
 147
 148         [ BYTECODE_OP_LOAD_FIELD ] = "LOAD_FIELD",
 149         [ BYTECODE_OP_LOAD_FIELD_S8 ] = "LOAD_FIELD_S8",
 150         [ BYTECODE_OP_LOAD_FIELD_S16 ] = "LOAD_FIELD_S16",
 151         [ BYTECODE_OP_LOAD_FIELD_S32 ] = "LOAD_FIELD_S32",
 152         [ BYTECODE_OP_LOAD_FIELD_S64 ] = "LOAD_FIELD_S64",
 153         [ BYTECODE_OP_LOAD_FIELD_U8 ] = "LOAD_FIELD_U8",
 154         [ BYTECODE_OP_LOAD_FIELD_U16 ] = "LOAD_FIELD_U16",
 155         [ BYTECODE_OP_LOAD_FIELD_U32 ] = "LOAD_FIELD_U32",
 156         [ BYTECODE_OP_LOAD_FIELD_U64 ] = "LOAD_FIELD_U64",
 157         [ BYTECODE_OP_LOAD_FIELD_STRING ] = "LOAD_FIELD_STRING",
 158         [ BYTECODE_OP_LOAD_FIELD_SEQUENCE ] = "LOAD_FIELD_SEQUENCE",
 159         [ BYTECODE_OP_LOAD_FIELD_DOUBLE ] = "LOAD_FIELD_DOUBLE",
 160
 161         [ BYTECODE_OP_UNARY_BIT_NOT ] = "UNARY_BIT_NOT",
 162
 163         [ BYTECODE_OP_RETURN_S64 ] = "RETURN_S64",
 164 };
 165
 166 const char *lttng_bytecode_print_op(enum bytecode_op op)
 167 {
 168         if (op >= NR_BYTECODE_OPS)
 169                 return "UNKNOWN";
 170         else
 171                 return opnames[op];
 172 }
 173
 174 static
 175 int apply_field_reloc(const struct lttng_ust_event_desc *event_desc,
 176                 struct bytecode_runtime *runtime,
 177                 uint32_t runtime_len __attribute__((unused)),
 178                 uint32_t reloc_offset,
 179                 const char *field_name,
 180                 enum bytecode_op bytecode_op)
 181 {
 182         const struct lttng_ust_event_field * const *fields, *field = NULL;
 183         unsigned int nr_fields, i;
 184         struct load_op *op;
 185         uint32_t field_offset = 0;
 186
 187         dbg_printf("Apply field reloc: %u %s\n", reloc_offset, field_name);
 188
 189         /* Lookup event by name */
 190         if (!event_desc)
 191                 return -EINVAL;
 192         fields = event_desc->fields;
 193         if (!fields)
 194                 return -EINVAL;
 195         nr_fields = event_desc->nr_fields;
 196         for (i = 0; i < nr_fields; i++) {
 197                 if (fields[i]->nofilter) {
 198                         continue;
 199                 }
 200                 if (!strcmp(fields[i]->name, field_name)) {
 201                         field = fields[i];
 202                         break;
 203                 }
 204                 /* compute field offset */
 205                 switch (fields[i]->type->type) {
 206                 case lttng_ust_type_integer:
 207                 case lttng_ust_type_enum:
 208                         field_offset += sizeof(int64_t);
 209                         break;
 210                 case lttng_ust_type_array:
 211                 case lttng_ust_type_sequence:
 212                         field_offset += sizeof(unsigned long);
 213                         field_offset += sizeof(void *);
 214                         break;
 215                 case lttng_ust_type_string:
 216                         field_offset += sizeof(void *);
 217                         break;
 218                 case lttng_ust_type_float:
 219                         field_offset += sizeof(double);
 220                         break;
 221                 default:
 222                         return -EINVAL;
 223                 }
 224         }
 225         if (!field)
 226                 return -EINVAL;
 227
 228         /* Check if field offset is too large for 16-bit offset */
 229         if (field_offset > LTTNG_UST_ABI_FILTER_BYTECODE_MAX_LEN - 1)
 230                 return -EINVAL;
 231
 232         /* set type */
 233         op = (struct load_op *) &runtime->code[reloc_offset];
 234
 235         switch (bytecode_op) {
 236         case BYTECODE_OP_LOAD_FIELD_REF:
 237         {
 238                 struct field_ref *field_ref;
 239
 240                 field_ref = (struct field_ref *) op->data;
 241                 switch (field->type->type) {
 242                 case lttng_ust_type_integer:
 243                 case lttng_ust_type_enum:
 244                         op->op = BYTECODE_OP_LOAD_FIELD_REF_S64;
 245                         break;
 246                 case lttng_ust_type_array:
 247                 {
 248                         struct lttng_ust_type_array *array = (struct lttng_ust_type_array *) field->type;
 249
 250                         if (array->encoding == lttng_ust_string_encoding_none)
 251                                 return -EINVAL;
 252                         op->op = BYTECODE_OP_LOAD_FIELD_REF_SEQUENCE;
 253                         break;
 254                 }
 255                 case lttng_ust_type_sequence:
 256                 {
 257                         struct lttng_ust_type_sequence *sequence = (struct lttng_ust_type_sequence *) field->type;
 258
 259                         if (sequence->encoding == lttng_ust_string_encoding_none)
 260                                 return -EINVAL;
 261                         op->op = BYTECODE_OP_LOAD_FIELD_REF_SEQUENCE;
 262                         break;
 263                 }
 264                 case lttng_ust_type_string:
 265                         op->op = BYTECODE_OP_LOAD_FIELD_REF_STRING;
 266                         break;
 267                 case lttng_ust_type_float:
 268                         op->op = BYTECODE_OP_LOAD_FIELD_REF_DOUBLE;
 269                         break;
 270                 default:
 271                         return -EINVAL;
 272                 }
 273                 /* set offset */
 274                 field_ref->offset = (uint16_t) field_offset;
 275                 break;
 276         }
 277         default:
 278                 return -EINVAL;
 279         }
 280         return 0;
 281 }
 282
 283 static
 284 int apply_context_reloc(struct bytecode_runtime *runtime,
 285                 uint32_t runtime_len __attribute__((unused)),
 286                 uint32_t reloc_offset,
 287                 const char *context_name,
 288                 enum bytecode_op bytecode_op)
 289 {
 290         struct load_op *op;
 291         const struct lttng_ust_ctx_field *ctx_field;
 292         int idx;
 293         struct lttng_ust_ctx **pctx = runtime->p.pctx;
 294
 295         dbg_printf("Apply context reloc: %u %s\n", reloc_offset, context_name);
 296
 297         /* Get context index */
 298         idx = lttng_get_context_index(*pctx, context_name);
 299         if (idx < 0) {
 300                 if (lttng_context_is_app(context_name)) {
 301                         int ret;
 302
 303                         ret = lttng_ust_add_app_context_to_ctx_rcu(context_name,
 304                                         pctx);
 305                         if (ret)
 306                                 return ret;
 307                         idx = lttng_get_context_index(*pctx, context_name);
 308                         if (idx < 0)
 309                                 return -ENOENT;
 310                 } else {
 311                         return -ENOENT;
 312                 }
 313         }
 314         /* Check if idx is too large for 16-bit offset */
 315         if (idx > LTTNG_UST_ABI_FILTER_BYTECODE_MAX_LEN - 1)
 316                 return -EINVAL;
 317
 318         /* Get context return type */
 319         ctx_field = &(*pctx)->fields[idx];
 320         op = (struct load_op *) &runtime->code[reloc_offset];
 321
 322         switch (bytecode_op) {
 323         case BYTECODE_OP_GET_CONTEXT_REF:
 324         {
 325                 struct field_ref *field_ref;
 326
 327                 field_ref = (struct field_ref *) op->data;
 328                 switch (ctx_field->event_field->type->type) {
 329                 case lttng_ust_type_integer:
 330                 case lttng_ust_type_enum:
 331                         op->op = BYTECODE_OP_GET_CONTEXT_REF_S64;
 332                         break;
 333                         /* Sequence and array supported only as string */
 334                 case lttng_ust_type_array:
 335                 {
 336                         struct lttng_ust_type_array *array = (struct lttng_ust_type_array *) ctx_field->event_field->type;
 337
 338                         if (array->encoding == lttng_ust_string_encoding_none)
 339                                 return -EINVAL;
 340                         op->op = BYTECODE_OP_GET_CONTEXT_REF_STRING;
 341                         break;
 342                 }
 343                 case lttng_ust_type_sequence:
 344                 {
 345                         struct lttng_ust_type_sequence *sequence = (struct lttng_ust_type_sequence *) ctx_field->event_field->type;
 346
 347                         if (sequence->encoding == lttng_ust_string_encoding_none)
 348                                 return -EINVAL;
 349                         op->op = BYTECODE_OP_GET_CONTEXT_REF_STRING;
 350                         break;
 351                 }
 352                 case lttng_ust_type_string:
 353                         op->op = BYTECODE_OP_GET_CONTEXT_REF_STRING;
 354                         break;
 355                 case lttng_ust_type_float:
 356                         op->op = BYTECODE_OP_GET_CONTEXT_REF_DOUBLE;
 357                         break;
 358                 case lttng_ust_type_dynamic:
 359                         op->op = BYTECODE_OP_GET_CONTEXT_REF;
 360                         break;
 361                 default:
 362                         return -EINVAL;
 363                 }
 364                 /* set offset to context index within channel contexts */
 365                 field_ref->offset = (uint16_t) idx;
 366                 break;
 367         }
 368         default:
 369                 return -EINVAL;
 370         }
 371         return 0;
 372 }
 373
 374 static
 375 int apply_reloc(const struct lttng_ust_event_desc *event_desc,
 376                 struct bytecode_runtime *runtime,
 377                 uint32_t runtime_len,
 378                 uint32_t reloc_offset,
 379                 const char *name)
 380 {
 381         struct load_op *op;
 382
 383         dbg_printf("Apply reloc: %u %s\n", reloc_offset, name);
 384
 385         /* Ensure that the reloc is within the code */
 386         if (runtime_len - reloc_offset < sizeof(uint16_t))
 387                 return -EINVAL;
 388
 389         op = (struct load_op *) &runtime->code[reloc_offset];
 390         switch (op->op) {
 391         case BYTECODE_OP_LOAD_FIELD_REF:
 392                 return apply_field_reloc(event_desc, runtime, runtime_len,
 393                         reloc_offset, name, op->op);
 394         case BYTECODE_OP_GET_CONTEXT_REF:
 395                 return apply_context_reloc(runtime, runtime_len,
 396                         reloc_offset, name, op->op);
 397         case BYTECODE_OP_GET_SYMBOL:
 398         case BYTECODE_OP_GET_SYMBOL_FIELD:
 399                 /*
 400                  * Will be handled by load specialize phase or
 401                  * dynamically by interpreter.
 402                  */
 403                 return 0;
 404         default:
 405                 ERR("Unknown reloc op type %u\n", op->op);
 406                 return -EINVAL;
 407         }
 408         return 0;
 409 }
 410
 411 static
 412 int bytecode_is_linked(struct lttng_ust_bytecode_node *bytecode,
 413                 struct cds_list_head *bytecode_runtime_head)
 414 {
 415         struct lttng_ust_bytecode_runtime *bc_runtime;
 416
 417         cds_list_for_each_entry(bc_runtime, bytecode_runtime_head, node) {
 418                 if (bc_runtime->bc == bytecode)
 419                         return 1;
 420         }
 421         return 0;
 422 }
 423
 424 /*
 425  * Take a bytecode with reloc table and link it to an event to create a
 426  * bytecode runtime.
 427  */
 428 static
 429 int link_bytecode(const struct lttng_ust_event_desc *event_desc,
 430                 struct lttng_ust_ctx **ctx,
 431                 struct lttng_ust_bytecode_node *bytecode,
 432                 struct cds_list_head *bytecode_runtime_head,
 433                 struct cds_list_head *insert_loc)
 434 {
 435         int ret, offset, next_offset;
 436         struct bytecode_runtime *runtime = NULL;
 437         size_t runtime_alloc_len;
 438
 439         if (!bytecode)
 440                 return 0;
 441         /* Bytecode already linked */
 442         if (bytecode_is_linked(bytecode, bytecode_runtime_head))
 443                 return 0;
 444
 445         dbg_printf("Linking...\n");
 446
 447         /* We don't need the reloc table in the runtime */
 448         runtime_alloc_len = sizeof(*runtime) + bytecode->bc.reloc_offset;
 449         runtime = zmalloc(runtime_alloc_len);
 450         if (!runtime) {
 451                 ret = -ENOMEM;
 452                 goto alloc_error;
 453         }
 454         runtime->p.type = bytecode->type;
 455         runtime->p.bc = bytecode;
 456         runtime->p.pctx = ctx;
 457         runtime->len = bytecode->bc.reloc_offset;
 458         /* copy original bytecode */
 459         memcpy(runtime->code, bytecode->bc.data, runtime->len);
 460         /*
 461          * apply relocs. Those are a uint16_t (offset in bytecode)
 462          * followed by a string (field name).
 463          */
 464         for (offset = bytecode->bc.reloc_offset;
 465                         offset < bytecode->bc.len;
 466                         offset = next_offset) {
 467                 uint16_t reloc_offset =
 468                         *(uint16_t *) &bytecode->bc.data[offset];
 469                 const char *name =
 470                         (const char *) &bytecode->bc.data[offset + sizeof(uint16_t)];
 471
 472                 ret = apply_reloc(event_desc, runtime, runtime->len, reloc_offset, name);
 473                 if (ret) {
 474                         goto link_error;
 475                 }
 476                 next_offset = offset + sizeof(uint16_t) + strlen(name) + 1;
 477         }
 478         /* Validate bytecode */
 479         ret = lttng_bytecode_validate(runtime);
 480         if (ret) {
 481                 goto link_error;
 482         }
 483         /* Specialize bytecode */
 484         ret = lttng_bytecode_specialize(event_desc, runtime);
 485         if (ret) {
 486                 goto link_error;
 487         }
 488
 489         runtime->p.interpreter_func = lttng_bytecode_interpret;
 490         runtime->p.link_failed = 0;
 491         cds_list_add_rcu(&runtime->p.node, insert_loc);
 492         dbg_printf("Linking successful.\n");
 493         return 0;
 494
 495 link_error:
 496         runtime->p.interpreter_func = lttng_bytecode_interpret_error;
 497         runtime->p.link_failed = 1;
 498         cds_list_add_rcu(&runtime->p.node, insert_loc);
 499 alloc_error:
 500         dbg_printf("Linking failed.\n");
 501         return ret;
 502 }
 503
 504 void lttng_bytecode_sync_state(struct lttng_ust_bytecode_runtime *runtime)
 505 {
 506         struct lttng_ust_bytecode_node *bc = runtime->bc;
 507
 508         if (!bc->enabler->enabled || runtime->link_failed)
 509                 runtime->interpreter_func = lttng_bytecode_interpret_error;
 510         else
 511                 runtime->interpreter_func = lttng_bytecode_interpret;
 512 }
 513
 514 /*
 515  * Given the lists of bytecode programs of an instance (trigger or event) and
 516  * of a matching enabler, try to link all the enabler's bytecode programs with
 517  * the instance.
 518  *
 519  * This function is called after we confirmed that name enabler and the
 520  * instance are name matching (or glob pattern matching).
 521  */
 522 void lttng_enabler_link_bytecode(const struct lttng_ust_event_desc *event_desc,
 523                 struct lttng_ust_ctx **ctx,
 524                 struct cds_list_head *instance_bytecode_head,
 525                 struct cds_list_head *enabler_bytecode_head)
 526 {
 527         struct lttng_ust_bytecode_node *enabler_bc;
 528         struct lttng_ust_bytecode_runtime *runtime;
 529
 530         assert(event_desc);
 531
 532         /* Go over all the bytecode programs of the enabler. */
 533         cds_list_for_each_entry(enabler_bc, enabler_bytecode_head, node) {
 534                 int found = 0, ret;
 535                 struct cds_list_head *insert_loc;
 536
 537                 /*
 538                  * Check if the current enabler bytecode program is already
 539                  * linked with the instance.
 540                  */
 541                 cds_list_for_each_entry(runtime, instance_bytecode_head, node) {
 542                         if (runtime->bc == enabler_bc) {
 543                                 found = 1;
 544                                 break;
 545                         }
 546                 }
 547
 548                 /*
 549                  * Skip bytecode already linked, go to the next enabler
 550                  * bytecode program.
 551                  */
 552                 if (found)
 553                         continue;
 554
 555                 /*
 556                  * Insert at specified priority (seqnum) in increasing
 557                  * order. If there already is a bytecode of the same priority,
 558                  * insert the new bytecode right after it.
 559                  */
 560                 cds_list_for_each_entry_reverse(runtime,
 561                                 instance_bytecode_head, node) {
 562                         if (runtime->bc->bc.seqnum <= enabler_bc->bc.seqnum) {
 563                                 /* insert here */
 564                                 insert_loc = &runtime->node;
 565                                 goto add_within;
 566                         }
 567                 }
 568
 569                 /* Add to head to list */
 570                 insert_loc = instance_bytecode_head;
 571         add_within:
 572                 dbg_printf("linking bytecode\n");
 573                 ret = link_bytecode(event_desc, ctx, enabler_bc, instance_bytecode_head, insert_loc);
 574                 if (ret) {
 575                         dbg_printf("[lttng filter] warning: cannot link event bytecode\n");
 576                 }
 577         }
 578 }
 579
 580 static
 581 void free_filter_runtime(struct cds_list_head *bytecode_runtime_head)
 582 {
 583         struct bytecode_runtime *runtime, *tmp;
 584
 585         cds_list_for_each_entry_safe(runtime, tmp, bytecode_runtime_head,
 586                         p.node) {
 587                 free(runtime->data);
 588                 free(runtime);
 589         }
 590 }
 591
 592 void lttng_free_event_filter_runtime(struct lttng_ust_event_common *event)
 593 {
 594         free_filter_runtime(&event->priv->filter_bytecode_runtime_head);
 595 }