Fix: pass private data to context callbacks
[lttng-ust.git] / liblttng-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 "ust-events-internal.h"
18 #include "ust-helper.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 **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 }
This page took 0.043497 seconds and 4 git commands to generate.