X-Git-Url: http://git.liburcu.org/?a=blobdiff_plain;f=liblttng-ust%2Flttng-filter-interpreter.c;h=258c43c9f9769a5adae8280169a6c472a3418ea0;hb=a63d0dc8be804cab34db94489e15dd99fd1f05a2;hp=e6e96dbff9a9bf53cdb346b68cd63a9b4728d457;hpb=9b33aac411033000adafce04f947c7aca892c342;p=lttng-ust.git diff --git a/liblttng-ust/lttng-filter-interpreter.c b/liblttng-ust/lttng-filter-interpreter.c index e6e96dbf..258c43c9 100644 --- a/liblttng-ust/lttng-filter-interpreter.c +++ b/liblttng-ust/lttng-filter-interpreter.c @@ -3,24 +3,32 @@ * * LTTng UST filter interpreter. * - * Copyright (C) 2010-2012 Mathieu Desnoyers + * Copyright (C) 2010-2016 Mathieu Desnoyers * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; only - * version 2.1 of the License. + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. */ +#define _LGPL_SOURCE +#include +#include #include "lttng-filter.h" +#include "string-utils.h" /* * -1: wildcard found. @@ -48,6 +56,42 @@ int parse_char(const char **p) } } +/* + * Returns SIZE_MAX if the string is null-terminated, or the number of + * characters if not. + */ +static +size_t get_str_or_seq_len(const struct estack_entry *entry) +{ + return entry->u.s.seq_len; +} + +static +int stack_star_glob_match(struct estack *stack, int top, const char *cmp_type) +{ + const char *pattern; + const char *candidate; + size_t pattern_len; + size_t candidate_len; + + /* Find out which side is the pattern vs. the candidate. */ + if (estack_ax(stack, top)->u.s.literal_type == ESTACK_STRING_LITERAL_TYPE_STAR_GLOB) { + pattern = estack_ax(stack, top)->u.s.str; + pattern_len = get_str_or_seq_len(estack_ax(stack, top)); + candidate = estack_bx(stack, top)->u.s.str; + candidate_len = get_str_or_seq_len(estack_bx(stack, top)); + } else { + pattern = estack_bx(stack, top)->u.s.str; + pattern_len = get_str_or_seq_len(estack_bx(stack, top)); + candidate = estack_ax(stack, top)->u.s.str; + candidate_len = get_str_or_seq_len(estack_ax(stack, top)); + } + + /* Perform the match. Returns 0 when the result is true. */ + return !strutils_star_glob_match(pattern, pattern_len, candidate, + candidate_len); +} + static int stack_strcmp(struct estack *stack, int top, const char *cmp_type) { @@ -58,21 +102,30 @@ int stack_strcmp(struct estack *stack, int top, const char *cmp_type) for (;;) { int escaped_r0 = 0; - if (unlikely(p - estack_bx(stack, top)->u.s.str > estack_bx(stack, top)->u.s.seq_len || *p == '\0')) { - if (q - estack_ax(stack, top)->u.s.str > estack_ax(stack, top)->u.s.seq_len || *q == '\0') - diff = 0; - else - diff = -1; - break; + if (unlikely(p - estack_bx(stack, top)->u.s.str >= estack_bx(stack, top)->u.s.seq_len || *p == '\0')) { + if (q - estack_ax(stack, top)->u.s.str >= estack_ax(stack, top)->u.s.seq_len || *q == '\0') { + return 0; + } else { + if (estack_ax(stack, top)->u.s.literal_type == + ESTACK_STRING_LITERAL_TYPE_PLAIN) { + ret = parse_char(&q); + if (ret == -1) + return 0; + } + return -1; + } } - if (unlikely(q - estack_ax(stack, top)->u.s.str > estack_ax(stack, top)->u.s.seq_len || *q == '\0')) { - if (p - estack_bx(stack, top)->u.s.str > estack_bx(stack, top)->u.s.seq_len || *p == '\0') - diff = 0; - else - diff = 1; - break; + if (unlikely(q - estack_ax(stack, top)->u.s.str >= estack_ax(stack, top)->u.s.seq_len || *q == '\0')) { + if (estack_bx(stack, top)->u.s.literal_type == + ESTACK_STRING_LITERAL_TYPE_PLAIN) { + ret = parse_char(&p); + if (ret == -1) + return 0; + } + return 1; } - if (estack_bx(stack, top)->u.s.literal) { + if (estack_bx(stack, top)->u.s.literal_type == + ESTACK_STRING_LITERAL_TYPE_PLAIN) { ret = parse_char(&p); if (ret == -1) { return 0; @@ -81,7 +134,8 @@ int stack_strcmp(struct estack *stack, int top, const char *cmp_type) } /* else compare both char */ } - if (estack_ax(stack, top)->u.s.literal) { + if (estack_ax(stack, top)->u.s.literal_type == + ESTACK_STRING_LITERAL_TYPE_PLAIN) { ret = parse_char(&q); if (ret == -1) { return 0; @@ -105,7 +159,7 @@ int stack_strcmp(struct estack *stack, int top, const char *cmp_type) return diff; } -int lttng_filter_false(void *filter_data, +uint64_t lttng_filter_false(void *filter_data, const char *filter_stack_data) { return 0; @@ -126,13 +180,17 @@ int lttng_filter_false(void *filter_data, (unsigned int) *(filter_opcode_t *) pc); \ switch (*(filter_opcode_t *) pc) { -#define OP(name) case name +#define OP(name) jump_target_##name: __attribute__((unused)); \ + case name #define PO break #define END_OP } \ } +#define JUMP_TO(name) \ + goto jump_target_##name + #else /* @@ -155,18 +213,28 @@ LABEL_##name #define END_OP +#define JUMP_TO(name) \ + goto LABEL_##name + #endif -int lttng_filter_interpret_bytecode(void *filter_data, +/* + * Return 0 (discard), or raise the 0x1 flag (log event). + * Currently, other flags are kept for future extensions and have no + * effect. + */ +uint64_t lttng_filter_interpret_bytecode(void *filter_data, const char *filter_stack_data) { struct bytecode_runtime *bytecode = filter_data; + struct lttng_session *session = bytecode->p.session; void *pc, *next_pc, *start_pc; int ret = -EINVAL; - int retval = 0; + uint64_t retval = 0; struct estack _stack; struct estack *stack = &_stack; register int64_t ax = 0, bx = 0; + register enum entry_type ax_t = REG_UNKNOWN, bx_t = REG_UNKNOWN; register int top = FILTER_STACK_EMPTY; #ifndef INTERPRETER_USE_SWITCH static void *dispatch[NR_FILTER_OPS] = { @@ -202,6 +270,10 @@ int lttng_filter_interpret_bytecode(void *filter_data, [ FILTER_OP_GE_STRING ] = &&LABEL_FILTER_OP_GE_STRING, [ FILTER_OP_LE_STRING ] = &&LABEL_FILTER_OP_LE_STRING, + /* globbing pattern binary comparator */ + [ FILTER_OP_EQ_STAR_GLOB_STRING ] = &&LABEL_FILTER_OP_EQ_STAR_GLOB_STRING, + [ FILTER_OP_NE_STAR_GLOB_STRING ] = &&LABEL_FILTER_OP_NE_STAR_GLOB_STRING, + /* s64 binary comparator */ [ FILTER_OP_EQ_S64 ] = &&LABEL_FILTER_OP_EQ_S64, [ FILTER_OP_NE_S64 ] = &&LABEL_FILTER_OP_NE_S64, @@ -248,14 +320,16 @@ int lttng_filter_interpret_bytecode(void *filter_data, [ FILTER_OP_AND ] = &&LABEL_FILTER_OP_AND, [ FILTER_OP_OR ] = &&LABEL_FILTER_OP_OR, - /* load */ + /* load field ref */ [ FILTER_OP_LOAD_FIELD_REF ] = &&LABEL_FILTER_OP_LOAD_FIELD_REF, [ FILTER_OP_LOAD_FIELD_REF_STRING ] = &&LABEL_FILTER_OP_LOAD_FIELD_REF_STRING, [ FILTER_OP_LOAD_FIELD_REF_SEQUENCE ] = &&LABEL_FILTER_OP_LOAD_FIELD_REF_SEQUENCE, [ FILTER_OP_LOAD_FIELD_REF_S64 ] = &&LABEL_FILTER_OP_LOAD_FIELD_REF_S64, [ FILTER_OP_LOAD_FIELD_REF_DOUBLE ] = &&LABEL_FILTER_OP_LOAD_FIELD_REF_DOUBLE, + /* load from immediate operand */ [ FILTER_OP_LOAD_STRING ] = &&LABEL_FILTER_OP_LOAD_STRING, + [ FILTER_OP_LOAD_STAR_GLOB_STRING ] = &&LABEL_FILTER_OP_LOAD_STAR_GLOB_STRING, [ FILTER_OP_LOAD_S64 ] = &&LABEL_FILTER_OP_LOAD_S64, [ FILTER_OP_LOAD_DOUBLE ] = &&LABEL_FILTER_OP_LOAD_DOUBLE, @@ -263,6 +337,12 @@ int lttng_filter_interpret_bytecode(void *filter_data, [ FILTER_OP_CAST_TO_S64 ] = &&LABEL_FILTER_OP_CAST_TO_S64, [ FILTER_OP_CAST_DOUBLE_TO_S64 ] = &&LABEL_FILTER_OP_CAST_DOUBLE_TO_S64, [ FILTER_OP_CAST_NOP ] = &&LABEL_FILTER_OP_CAST_NOP, + + /* get context ref */ + [ FILTER_OP_GET_CONTEXT_REF ] = &&LABEL_FILTER_OP_GET_CONTEXT_REF, + [ FILTER_OP_GET_CONTEXT_REF_STRING ] = &&LABEL_FILTER_OP_GET_CONTEXT_REF_STRING, + [ FILTER_OP_GET_CONTEXT_REF_S64 ] = &&LABEL_FILTER_OP_GET_CONTEXT_REF_S64, + [ FILTER_OP_GET_CONTEXT_REF_DOUBLE ] = &&LABEL_FILTER_OP_GET_CONTEXT_REF_DOUBLE, }; #endif /* #ifndef INTERPRETER_USE_SWITCH */ @@ -279,6 +359,7 @@ int lttng_filter_interpret_bytecode(void *filter_data, goto end; OP(FILTER_OP_RETURN): + /* LTTNG_FILTER_DISCARD or LTTNG_FILTER_RECORD_FLAG */ retval = !!estack_ax_v; ret = 0; goto end; @@ -300,23 +381,418 @@ int lttng_filter_interpret_bytecode(void *filter_data, goto end; OP(FILTER_OP_EQ): + { + /* Dynamic typing. */ + switch (estack_ax_t) { + case REG_S64: + switch (estack_bx_t) { + case REG_S64: + JUMP_TO(FILTER_OP_EQ_S64); + case REG_DOUBLE: + JUMP_TO(FILTER_OP_EQ_DOUBLE_S64); + case REG_STRING: /* Fall-through */ + case REG_STAR_GLOB_STRING: + ret = -EINVAL; + goto end; + default: + ERR("Unknown filter register type (%d)", + (int) estack_bx_t); + ret = -EINVAL; + goto end; + } + break; + case REG_DOUBLE: + switch (estack_bx_t) { + case REG_S64: + JUMP_TO(FILTER_OP_EQ_S64_DOUBLE); + case REG_DOUBLE: + JUMP_TO(FILTER_OP_EQ_DOUBLE); + case REG_STRING: /* Fall-through */ + case REG_STAR_GLOB_STRING: + ret = -EINVAL; + goto end; + default: + ERR("Unknown filter register type (%d)", + (int) estack_bx_t); + ret = -EINVAL; + goto end; + } + break; + case REG_STRING: + switch (estack_bx_t) { + case REG_S64: /* Fall-through */ + case REG_DOUBLE: + ret = -EINVAL; + goto end; + case REG_STRING: + JUMP_TO(FILTER_OP_EQ_STRING); + case REG_STAR_GLOB_STRING: + JUMP_TO(FILTER_OP_EQ_STAR_GLOB_STRING); + default: + ERR("Unknown filter register type (%d)", + (int) estack_bx_t); + ret = -EINVAL; + goto end; + } + break; + case REG_STAR_GLOB_STRING: + switch (estack_bx_t) { + case REG_S64: /* Fall-through */ + case REG_DOUBLE: + ret = -EINVAL; + goto end; + case REG_STRING: + JUMP_TO(FILTER_OP_EQ_STAR_GLOB_STRING); + case REG_STAR_GLOB_STRING: + ret = -EINVAL; + goto end; + default: + ERR("Unknown filter register type (%d)", + (int) estack_bx_t); + ret = -EINVAL; + goto end; + } + break; + default: + ERR("Unknown filter register type (%d)", + (int) estack_ax_t); + ret = -EINVAL; + goto end; + } + } OP(FILTER_OP_NE): + { + /* Dynamic typing. */ + switch (estack_ax_t) { + case REG_S64: + switch (estack_bx_t) { + case REG_S64: + JUMP_TO(FILTER_OP_NE_S64); + case REG_DOUBLE: + JUMP_TO(FILTER_OP_NE_DOUBLE_S64); + case REG_STRING: /* Fall-through */ + case REG_STAR_GLOB_STRING: + ret = -EINVAL; + goto end; + default: + ERR("Unknown filter register type (%d)", + (int) estack_bx_t); + ret = -EINVAL; + goto end; + } + break; + case REG_DOUBLE: + switch (estack_bx_t) { + case REG_S64: + JUMP_TO(FILTER_OP_NE_S64_DOUBLE); + case REG_DOUBLE: + JUMP_TO(FILTER_OP_NE_DOUBLE); + case REG_STRING: /* Fall-through */ + case REG_STAR_GLOB_STRING: + ret = -EINVAL; + goto end; + default: + ERR("Unknown filter register type (%d)", + (int) estack_bx_t); + ret = -EINVAL; + goto end; + } + break; + case REG_STRING: + switch (estack_bx_t) { + case REG_S64: /* Fall-through */ + case REG_DOUBLE: + ret = -EINVAL; + goto end; + case REG_STRING: + JUMP_TO(FILTER_OP_NE_STRING); + case REG_STAR_GLOB_STRING: + JUMP_TO(FILTER_OP_NE_STAR_GLOB_STRING); + default: + ERR("Unknown filter register type (%d)", + (int) estack_bx_t); + ret = -EINVAL; + goto end; + } + break; + case REG_STAR_GLOB_STRING: + switch (estack_bx_t) { + case REG_S64: /* Fall-through */ + case REG_DOUBLE: + ret = -EINVAL; + goto end; + case REG_STRING: + JUMP_TO(FILTER_OP_NE_STAR_GLOB_STRING); + case REG_STAR_GLOB_STRING: + ret = -EINVAL; + goto end; + default: + ERR("Unknown filter register type (%d)", + (int) estack_bx_t); + ret = -EINVAL; + goto end; + } + break; + default: + ERR("Unknown filter register type (%d)", + (int) estack_ax_t); + ret = -EINVAL; + goto end; + } + } OP(FILTER_OP_GT): + { + /* Dynamic typing. */ + switch (estack_ax_t) { + case REG_S64: + switch (estack_bx_t) { + case REG_S64: + JUMP_TO(FILTER_OP_GT_S64); + case REG_DOUBLE: + JUMP_TO(FILTER_OP_GT_DOUBLE_S64); + case REG_STRING: /* Fall-through */ + case REG_STAR_GLOB_STRING: + ret = -EINVAL; + goto end; + default: + ERR("Unknown filter register type (%d)", + (int) estack_bx_t); + ret = -EINVAL; + goto end; + } + break; + case REG_DOUBLE: + switch (estack_bx_t) { + case REG_S64: + JUMP_TO(FILTER_OP_GT_S64_DOUBLE); + case REG_DOUBLE: + JUMP_TO(FILTER_OP_GT_DOUBLE); + case REG_STRING: /* Fall-through */ + case REG_STAR_GLOB_STRING: + ret = -EINVAL; + goto end; + default: + ERR("Unknown filter register type (%d)", + (int) estack_bx_t); + ret = -EINVAL; + goto end; + } + break; + case REG_STRING: + switch (estack_bx_t) { + case REG_S64: /* Fall-through */ + case REG_DOUBLE: /* Fall-through */ + case REG_STAR_GLOB_STRING: + ret = -EINVAL; + goto end; + case REG_STRING: + JUMP_TO(FILTER_OP_GT_STRING); + default: + ERR("Unknown filter register type (%d)", + (int) estack_bx_t); + ret = -EINVAL; + goto end; + } + break; + default: + ERR("Unknown filter register type (%d)", + (int) estack_ax_t); + ret = -EINVAL; + goto end; + } + } OP(FILTER_OP_LT): + { + /* Dynamic typing. */ + switch (estack_ax_t) { + case REG_S64: + switch (estack_bx_t) { + case REG_S64: + JUMP_TO(FILTER_OP_LT_S64); + case REG_DOUBLE: + JUMP_TO(FILTER_OP_LT_DOUBLE_S64); + case REG_STRING: /* Fall-through */ + case REG_STAR_GLOB_STRING: + ret = -EINVAL; + goto end; + default: + ERR("Unknown filter register type (%d)", + (int) estack_bx_t); + ret = -EINVAL; + goto end; + } + break; + case REG_DOUBLE: + switch (estack_bx_t) { + case REG_S64: + JUMP_TO(FILTER_OP_LT_S64_DOUBLE); + case REG_DOUBLE: + JUMP_TO(FILTER_OP_LT_DOUBLE); + case REG_STRING: /* Fall-through */ + case REG_STAR_GLOB_STRING: + ret = -EINVAL; + goto end; + default: + ERR("Unknown filter register type (%d)", + (int) estack_bx_t); + ret = -EINVAL; + goto end; + } + break; + case REG_STRING: + switch (estack_bx_t) { + case REG_S64: /* Fall-through */ + case REG_DOUBLE: /* Fall-through */ + case REG_STAR_GLOB_STRING: + ret = -EINVAL; + goto end; + case REG_STRING: + JUMP_TO(FILTER_OP_LT_STRING); + default: + ERR("Unknown filter register type (%d)", + (int) estack_bx_t); + ret = -EINVAL; + goto end; + } + break; + default: + ERR("Unknown filter register type (%d)", + (int) estack_ax_t); + ret = -EINVAL; + goto end; + } + } OP(FILTER_OP_GE): + { + /* Dynamic typing. */ + switch (estack_ax_t) { + case REG_S64: + switch (estack_bx_t) { + case REG_S64: + JUMP_TO(FILTER_OP_GE_S64); + case REG_DOUBLE: + JUMP_TO(FILTER_OP_GE_DOUBLE_S64); + case REG_STRING: /* Fall-through */ + case REG_STAR_GLOB_STRING: + ret = -EINVAL; + goto end; + default: + ERR("Unknown filter register type (%d)", + (int) estack_bx_t); + ret = -EINVAL; + goto end; + } + break; + case REG_DOUBLE: + switch (estack_bx_t) { + case REG_S64: + JUMP_TO(FILTER_OP_GE_S64_DOUBLE); + case REG_DOUBLE: + JUMP_TO(FILTER_OP_GE_DOUBLE); + case REG_STRING: /* Fall-through */ + case REG_STAR_GLOB_STRING: + ret = -EINVAL; + goto end; + default: + ERR("Unknown filter register type (%d)", + (int) estack_bx_t); + ret = -EINVAL; + goto end; + } + break; + case REG_STRING: + switch (estack_bx_t) { + case REG_S64: /* Fall-through */ + case REG_DOUBLE: /* Fall-through */ + case REG_STAR_GLOB_STRING: + ret = -EINVAL; + goto end; + case REG_STRING: + JUMP_TO(FILTER_OP_GE_STRING); + default: + ERR("Unknown filter register type (%d)", + (int) estack_bx_t); + ret = -EINVAL; + goto end; + } + break; + default: + ERR("Unknown filter register type (%d)", + (int) estack_ax_t); + ret = -EINVAL; + goto end; + } + } OP(FILTER_OP_LE): - ERR("unsupported non-specialized bytecode op %u\n", - (unsigned int) *(filter_opcode_t *) pc); - ret = -EINVAL; - goto end; + { + /* Dynamic typing. */ + switch (estack_ax_t) { + case REG_S64: + switch (estack_bx_t) { + case REG_S64: + JUMP_TO(FILTER_OP_LE_S64); + case REG_DOUBLE: + JUMP_TO(FILTER_OP_LE_DOUBLE_S64); + case REG_STRING: /* Fall-through */ + case REG_STAR_GLOB_STRING: + ret = -EINVAL; + goto end; + default: + ERR("Unknown filter register type (%d)", + (int) estack_bx_t); + ret = -EINVAL; + goto end; + } + break; + case REG_DOUBLE: + switch (estack_bx_t) { + case REG_S64: + JUMP_TO(FILTER_OP_LE_S64_DOUBLE); + case REG_DOUBLE: + JUMP_TO(FILTER_OP_LE_DOUBLE); + case REG_STRING: /* Fall-through */ + case REG_STAR_GLOB_STRING: + ret = -EINVAL; + goto end; + default: + ERR("Unknown filter register type (%d)", + (int) estack_bx_t); + ret = -EINVAL; + goto end; + } + break; + case REG_STRING: + switch (estack_bx_t) { + case REG_S64: /* Fall-through */ + case REG_DOUBLE: /* Fall-through */ + case REG_STAR_GLOB_STRING: + ret = -EINVAL; + goto end; + case REG_STRING: + JUMP_TO(FILTER_OP_LE_STRING); + default: + ERR("Unknown filter register type (%d)", + (int) estack_bx_t); + ret = -EINVAL; + goto end; + } + break; + default: + ERR("Unknown filter register type (%d)", + (int) estack_ax_t); + ret = -EINVAL; + goto end; + } + } OP(FILTER_OP_EQ_STRING): { int res; res = (stack_strcmp(stack, top, "==") == 0); - estack_pop(stack, top, ax, bx); + estack_pop(stack, top, ax, bx, ax_t, bx_t); estack_ax_v = res; + estack_ax_t = REG_S64; next_pc += sizeof(struct binary_op); PO; } @@ -325,8 +801,9 @@ int lttng_filter_interpret_bytecode(void *filter_data, int res; res = (stack_strcmp(stack, top, "!=") != 0); - estack_pop(stack, top, ax, bx); + estack_pop(stack, top, ax, bx, ax_t, bx_t); estack_ax_v = res; + estack_ax_t = REG_S64; next_pc += sizeof(struct binary_op); PO; } @@ -335,8 +812,9 @@ int lttng_filter_interpret_bytecode(void *filter_data, int res; res = (stack_strcmp(stack, top, ">") > 0); - estack_pop(stack, top, ax, bx); + estack_pop(stack, top, ax, bx, ax_t, bx_t); estack_ax_v = res; + estack_ax_t = REG_S64; next_pc += sizeof(struct binary_op); PO; } @@ -345,8 +823,9 @@ int lttng_filter_interpret_bytecode(void *filter_data, int res; res = (stack_strcmp(stack, top, "<") < 0); - estack_pop(stack, top, ax, bx); + estack_pop(stack, top, ax, bx, ax_t, bx_t); estack_ax_v = res; + estack_ax_t = REG_S64; next_pc += sizeof(struct binary_op); PO; } @@ -355,8 +834,9 @@ int lttng_filter_interpret_bytecode(void *filter_data, int res; res = (stack_strcmp(stack, top, ">=") >= 0); - estack_pop(stack, top, ax, bx); + estack_pop(stack, top, ax, bx, ax_t, bx_t); estack_ax_v = res; + estack_ax_t = REG_S64; next_pc += sizeof(struct binary_op); PO; } @@ -365,8 +845,32 @@ int lttng_filter_interpret_bytecode(void *filter_data, int res; res = (stack_strcmp(stack, top, "<=") <= 0); - estack_pop(stack, top, ax, bx); + estack_pop(stack, top, ax, bx, ax_t, bx_t); + estack_ax_v = res; + estack_ax_t = REG_S64; + next_pc += sizeof(struct binary_op); + PO; + } + + OP(FILTER_OP_EQ_STAR_GLOB_STRING): + { + int res; + + res = (stack_star_glob_match(stack, top, "==") == 0); + estack_pop(stack, top, ax, bx, ax_t, bx_t); estack_ax_v = res; + estack_ax_t = REG_S64; + next_pc += sizeof(struct binary_op); + PO; + } + OP(FILTER_OP_NE_STAR_GLOB_STRING): + { + int res; + + res = (stack_star_glob_match(stack, top, "!=") != 0); + estack_pop(stack, top, ax, bx, ax_t, bx_t); + estack_ax_v = res; + estack_ax_t = REG_S64; next_pc += sizeof(struct binary_op); PO; } @@ -376,8 +880,9 @@ int lttng_filter_interpret_bytecode(void *filter_data, int res; res = (estack_bx_v == estack_ax_v); - estack_pop(stack, top, ax, bx); + estack_pop(stack, top, ax, bx, ax_t, bx_t); estack_ax_v = res; + estack_ax_t = REG_S64; next_pc += sizeof(struct binary_op); PO; } @@ -386,8 +891,9 @@ int lttng_filter_interpret_bytecode(void *filter_data, int res; res = (estack_bx_v != estack_ax_v); - estack_pop(stack, top, ax, bx); + estack_pop(stack, top, ax, bx, ax_t, bx_t); estack_ax_v = res; + estack_ax_t = REG_S64; next_pc += sizeof(struct binary_op); PO; } @@ -396,8 +902,9 @@ int lttng_filter_interpret_bytecode(void *filter_data, int res; res = (estack_bx_v > estack_ax_v); - estack_pop(stack, top, ax, bx); + estack_pop(stack, top, ax, bx, ax_t, bx_t); estack_ax_v = res; + estack_ax_t = REG_S64; next_pc += sizeof(struct binary_op); PO; } @@ -406,8 +913,9 @@ int lttng_filter_interpret_bytecode(void *filter_data, int res; res = (estack_bx_v < estack_ax_v); - estack_pop(stack, top, ax, bx); + estack_pop(stack, top, ax, bx, ax_t, bx_t); estack_ax_v = res; + estack_ax_t = REG_S64; next_pc += sizeof(struct binary_op); PO; } @@ -416,8 +924,9 @@ int lttng_filter_interpret_bytecode(void *filter_data, int res; res = (estack_bx_v >= estack_ax_v); - estack_pop(stack, top, ax, bx); + estack_pop(stack, top, ax, bx, ax_t, bx_t); estack_ax_v = res; + estack_ax_t = REG_S64; next_pc += sizeof(struct binary_op); PO; } @@ -426,8 +935,9 @@ int lttng_filter_interpret_bytecode(void *filter_data, int res; res = (estack_bx_v <= estack_ax_v); - estack_pop(stack, top, ax, bx); + estack_pop(stack, top, ax, bx, ax_t, bx_t); estack_ax_v = res; + estack_ax_t = REG_S64; next_pc += sizeof(struct binary_op); PO; } @@ -437,8 +947,9 @@ int lttng_filter_interpret_bytecode(void *filter_data, int res; res = (estack_bx(stack, top)->u.d == estack_ax(stack, top)->u.d); - estack_pop(stack, top, ax, bx); + estack_pop(stack, top, ax, bx, ax_t, bx_t); estack_ax_v = res; + estack_ax_t = REG_S64; next_pc += sizeof(struct binary_op); PO; } @@ -447,8 +958,9 @@ int lttng_filter_interpret_bytecode(void *filter_data, int res; res = (estack_bx(stack, top)->u.d != estack_ax(stack, top)->u.d); - estack_pop(stack, top, ax, bx); + estack_pop(stack, top, ax, bx, ax_t, bx_t); estack_ax_v = res; + estack_ax_t = REG_S64; next_pc += sizeof(struct binary_op); PO; } @@ -457,8 +969,9 @@ int lttng_filter_interpret_bytecode(void *filter_data, int res; res = (estack_bx(stack, top)->u.d > estack_ax(stack, top)->u.d); - estack_pop(stack, top, ax, bx); + estack_pop(stack, top, ax, bx, ax_t, bx_t); estack_ax_v = res; + estack_ax_t = REG_S64; next_pc += sizeof(struct binary_op); PO; } @@ -467,8 +980,9 @@ int lttng_filter_interpret_bytecode(void *filter_data, int res; res = (estack_bx(stack, top)->u.d < estack_ax(stack, top)->u.d); - estack_pop(stack, top, ax, bx); + estack_pop(stack, top, ax, bx, ax_t, bx_t); estack_ax_v = res; + estack_ax_t = REG_S64; next_pc += sizeof(struct binary_op); PO; } @@ -477,8 +991,9 @@ int lttng_filter_interpret_bytecode(void *filter_data, int res; res = (estack_bx(stack, top)->u.d >= estack_ax(stack, top)->u.d); - estack_pop(stack, top, ax, bx); + estack_pop(stack, top, ax, bx, ax_t, bx_t); estack_ax_v = res; + estack_ax_t = REG_S64; next_pc += sizeof(struct binary_op); PO; } @@ -487,8 +1002,9 @@ int lttng_filter_interpret_bytecode(void *filter_data, int res; res = (estack_bx(stack, top)->u.d <= estack_ax(stack, top)->u.d); - estack_pop(stack, top, ax, bx); + estack_pop(stack, top, ax, bx, ax_t, bx_t); estack_ax_v = res; + estack_ax_t = REG_S64; next_pc += sizeof(struct binary_op); PO; } @@ -499,8 +1015,9 @@ int lttng_filter_interpret_bytecode(void *filter_data, int res; res = (estack_bx(stack, top)->u.d == estack_ax_v); - estack_pop(stack, top, ax, bx); + estack_pop(stack, top, ax, bx, ax_t, bx_t); estack_ax_v = res; + estack_ax_t = REG_S64; next_pc += sizeof(struct binary_op); PO; } @@ -509,8 +1026,9 @@ int lttng_filter_interpret_bytecode(void *filter_data, int res; res = (estack_bx(stack, top)->u.d != estack_ax_v); - estack_pop(stack, top, ax, bx); + estack_pop(stack, top, ax, bx, ax_t, bx_t); estack_ax_v = res; + estack_ax_t = REG_S64; next_pc += sizeof(struct binary_op); PO; } @@ -519,8 +1037,9 @@ int lttng_filter_interpret_bytecode(void *filter_data, int res; res = (estack_bx(stack, top)->u.d > estack_ax_v); - estack_pop(stack, top, ax, bx); + estack_pop(stack, top, ax, bx, ax_t, bx_t); estack_ax_v = res; + estack_ax_t = REG_S64; next_pc += sizeof(struct binary_op); PO; } @@ -529,8 +1048,9 @@ int lttng_filter_interpret_bytecode(void *filter_data, int res; res = (estack_bx(stack, top)->u.d < estack_ax_v); - estack_pop(stack, top, ax, bx); + estack_pop(stack, top, ax, bx, ax_t, bx_t); estack_ax_v = res; + estack_ax_t = REG_S64; next_pc += sizeof(struct binary_op); PO; } @@ -539,8 +1059,9 @@ int lttng_filter_interpret_bytecode(void *filter_data, int res; res = (estack_bx(stack, top)->u.d >= estack_ax_v); - estack_pop(stack, top, ax, bx); + estack_pop(stack, top, ax, bx, ax_t, bx_t); estack_ax_v = res; + estack_ax_t = REG_S64; next_pc += sizeof(struct binary_op); PO; } @@ -549,8 +1070,9 @@ int lttng_filter_interpret_bytecode(void *filter_data, int res; res = (estack_bx(stack, top)->u.d <= estack_ax_v); - estack_pop(stack, top, ax, bx); + estack_pop(stack, top, ax, bx, ax_t, bx_t); estack_ax_v = res; + estack_ax_t = REG_S64; next_pc += sizeof(struct binary_op); PO; } @@ -560,8 +1082,9 @@ int lttng_filter_interpret_bytecode(void *filter_data, int res; res = (estack_bx_v == estack_ax(stack, top)->u.d); - estack_pop(stack, top, ax, bx); + estack_pop(stack, top, ax, bx, ax_t, bx_t); estack_ax_v = res; + estack_ax_t = REG_S64; next_pc += sizeof(struct binary_op); PO; } @@ -570,8 +1093,9 @@ int lttng_filter_interpret_bytecode(void *filter_data, int res; res = (estack_bx_v != estack_ax(stack, top)->u.d); - estack_pop(stack, top, ax, bx); + estack_pop(stack, top, ax, bx, ax_t, bx_t); estack_ax_v = res; + estack_ax_t = REG_S64; next_pc += sizeof(struct binary_op); PO; } @@ -580,8 +1104,9 @@ int lttng_filter_interpret_bytecode(void *filter_data, int res; res = (estack_bx_v > estack_ax(stack, top)->u.d); - estack_pop(stack, top, ax, bx); + estack_pop(stack, top, ax, bx, ax_t, bx_t); estack_ax_v = res; + estack_ax_t = REG_S64; next_pc += sizeof(struct binary_op); PO; } @@ -590,8 +1115,9 @@ int lttng_filter_interpret_bytecode(void *filter_data, int res; res = (estack_bx_v < estack_ax(stack, top)->u.d); - estack_pop(stack, top, ax, bx); + estack_pop(stack, top, ax, bx, ax_t, bx_t); estack_ax_v = res; + estack_ax_t = REG_S64; next_pc += sizeof(struct binary_op); PO; } @@ -600,8 +1126,9 @@ int lttng_filter_interpret_bytecode(void *filter_data, int res; res = (estack_bx_v >= estack_ax(stack, top)->u.d); - estack_pop(stack, top, ax, bx); + estack_pop(stack, top, ax, bx, ax_t, bx_t); estack_ax_v = res; + estack_ax_t = REG_S64; next_pc += sizeof(struct binary_op); PO; } @@ -610,21 +1137,73 @@ int lttng_filter_interpret_bytecode(void *filter_data, int res; res = (estack_bx_v <= estack_ax(stack, top)->u.d); - estack_pop(stack, top, ax, bx); + estack_pop(stack, top, ax, bx, ax_t, bx_t); estack_ax_v = res; + estack_ax_t = REG_S64; next_pc += sizeof(struct binary_op); PO; } /* unary */ OP(FILTER_OP_UNARY_PLUS): + { + /* Dynamic typing. */ + switch (estack_ax_t) { + case REG_S64: /* Fall-through. */ + JUMP_TO(FILTER_OP_UNARY_PLUS_S64); + case REG_DOUBLE: + JUMP_TO(FILTER_OP_UNARY_PLUS_DOUBLE); + case REG_STRING: /* Fall-through */ + case REG_STAR_GLOB_STRING: + ret = -EINVAL; + goto end; + default: + ERR("Unknown filter register type (%d)", + (int) estack_ax_t); + ret = -EINVAL; + goto end; + } + } OP(FILTER_OP_UNARY_MINUS): + { + /* Dynamic typing. */ + switch (estack_ax_t) { + case REG_S64: + JUMP_TO(FILTER_OP_UNARY_MINUS_S64); + case REG_DOUBLE: + JUMP_TO(FILTER_OP_UNARY_MINUS_DOUBLE); + case REG_STRING: /* Fall-through */ + case REG_STAR_GLOB_STRING: + ret = -EINVAL; + goto end; + default: + ERR("Unknown filter register type (%d)", + (int) estack_ax_t); + ret = -EINVAL; + goto end; + } + } OP(FILTER_OP_UNARY_NOT): - ERR("unsupported non-specialized bytecode op %u\n", - (unsigned int) *(filter_opcode_t *) pc); - ret = -EINVAL; - goto end; - + { + /* Dynamic typing. */ + switch (estack_ax_t) { + case REG_S64: + JUMP_TO(FILTER_OP_UNARY_NOT_S64); + case REG_DOUBLE: + JUMP_TO(FILTER_OP_UNARY_NOT_DOUBLE); + case REG_STRING: /* Fall-through */ + case REG_STAR_GLOB_STRING: + ret = -EINVAL; + goto end; + default: + ERR("Unknown filter register type (%d)", + (int) estack_ax_t); + ret = -EINVAL; + goto end; + } + next_pc += sizeof(struct unary_op); + PO; + } OP(FILTER_OP_UNARY_PLUS_S64): OP(FILTER_OP_UNARY_PLUS_DOUBLE): @@ -652,7 +1231,8 @@ int lttng_filter_interpret_bytecode(void *filter_data, } OP(FILTER_OP_UNARY_NOT_DOUBLE): { - estack_ax(stack, top)->u.d = !estack_ax(stack, top)->u.d; + estack_ax_v = !estack_ax(stack, top)->u.d; + estack_ax_t = REG_S64; next_pc += sizeof(struct unary_op); PO; } @@ -662,6 +1242,10 @@ int lttng_filter_interpret_bytecode(void *filter_data, { struct logical_op *insn = (struct logical_op *) pc; + if (estack_ax_t != REG_S64) { + ret = -EINVAL; + goto end; + } /* If AX is 0, skip and evaluate to 0 */ if (unlikely(estack_ax_v == 0)) { dbg_printf("Jumping to bytecode offset %u\n", @@ -669,7 +1253,7 @@ int lttng_filter_interpret_bytecode(void *filter_data, next_pc = start_pc + insn->skip_offset; } else { /* Pop 1 when jump not taken */ - estack_pop(stack, top, ax, bx); + estack_pop(stack, top, ax, bx, ax_t, bx_t); next_pc += sizeof(struct logical_op); } PO; @@ -678,8 +1262,11 @@ int lttng_filter_interpret_bytecode(void *filter_data, { struct logical_op *insn = (struct logical_op *) pc; + if (estack_ax_t != REG_S64) { + ret = -EINVAL; + goto end; + } /* If AX is nonzero, skip and evaluate to 1 */ - if (unlikely(estack_ax_v != 0)) { estack_ax_v = 1; dbg_printf("Jumping to bytecode offset %u\n", @@ -687,14 +1274,14 @@ int lttng_filter_interpret_bytecode(void *filter_data, next_pc = start_pc + insn->skip_offset; } else { /* Pop 1 when jump not taken */ - estack_pop(stack, top, ax, bx); + estack_pop(stack, top, ax, bx, ax_t, bx_t); next_pc += sizeof(struct logical_op); } PO; } - /* load */ + /* load field ref */ OP(FILTER_OP_LOAD_FIELD_REF_STRING): { struct load_op *insn = (struct load_op *) pc; @@ -702,7 +1289,7 @@ int lttng_filter_interpret_bytecode(void *filter_data, dbg_printf("load field ref offset %u type string\n", ref->offset); - estack_push(stack, top, ax, bx); + estack_push(stack, top, ax, bx, ax_t, bx_t); estack_ax(stack, top)->u.s.str = *(const char * const *) &filter_stack_data[ref->offset]; if (unlikely(!estack_ax(stack, top)->u.s.str)) { @@ -710,8 +1297,10 @@ int lttng_filter_interpret_bytecode(void *filter_data, ret = -EINVAL; goto end; } - estack_ax(stack, top)->u.s.seq_len = UINT_MAX; - estack_ax(stack, top)->u.s.literal = 0; + estack_ax(stack, top)->u.s.seq_len = SIZE_MAX; + estack_ax(stack, top)->u.s.literal_type = + ESTACK_STRING_LITERAL_TYPE_NONE; + estack_ax_t = REG_STRING; dbg_printf("ref load string %s\n", estack_ax(stack, top)->u.s.str); next_pc += sizeof(struct load_op) + sizeof(struct field_ref); PO; @@ -724,18 +1313,20 @@ int lttng_filter_interpret_bytecode(void *filter_data, dbg_printf("load field ref offset %u type sequence\n", ref->offset); - estack_push(stack, top, ax, bx); + estack_push(stack, top, ax, bx, ax_t, bx_t); estack_ax(stack, top)->u.s.seq_len = *(unsigned long *) &filter_stack_data[ref->offset]; estack_ax(stack, top)->u.s.str = *(const char **) (&filter_stack_data[ref->offset + sizeof(unsigned long)]); + estack_ax_t = REG_STRING; if (unlikely(!estack_ax(stack, top)->u.s.str)) { dbg_printf("Filter warning: loading a NULL sequence.\n"); ret = -EINVAL; goto end; } - estack_ax(stack, top)->u.s.literal = 0; + estack_ax(stack, top)->u.s.literal_type = + ESTACK_STRING_LITERAL_TYPE_NONE; next_pc += sizeof(struct load_op) + sizeof(struct field_ref); PO; } @@ -747,9 +1338,10 @@ int lttng_filter_interpret_bytecode(void *filter_data, dbg_printf("load field ref offset %u type s64\n", ref->offset); - estack_push(stack, top, ax, bx); + estack_push(stack, top, ax, bx, ax_t, bx_t); estack_ax_v = ((struct literal_numeric *) &filter_stack_data[ref->offset])->v; + estack_ax_t = REG_S64; dbg_printf("ref load s64 %" PRIi64 "\n", estack_ax_v); next_pc += sizeof(struct load_op) + sizeof(struct field_ref); PO; @@ -762,23 +1354,42 @@ int lttng_filter_interpret_bytecode(void *filter_data, dbg_printf("load field ref offset %u type double\n", ref->offset); - estack_push(stack, top, ax, bx); + estack_push(stack, top, ax, bx, ax_t, bx_t); memcpy(&estack_ax(stack, top)->u.d, &filter_stack_data[ref->offset], sizeof(struct literal_double)); + estack_ax_t = REG_DOUBLE; dbg_printf("ref load double %g\n", estack_ax(stack, top)->u.d); next_pc += sizeof(struct load_op) + sizeof(struct field_ref); PO; } + /* load from immediate operand */ OP(FILTER_OP_LOAD_STRING): { struct load_op *insn = (struct load_op *) pc; dbg_printf("load string %s\n", insn->data); - estack_push(stack, top, ax, bx); + estack_push(stack, top, ax, bx, ax_t, bx_t); estack_ax(stack, top)->u.s.str = insn->data; - estack_ax(stack, top)->u.s.seq_len = UINT_MAX; - estack_ax(stack, top)->u.s.literal = 1; + estack_ax(stack, top)->u.s.seq_len = SIZE_MAX; + estack_ax(stack, top)->u.s.literal_type = + ESTACK_STRING_LITERAL_TYPE_PLAIN; + estack_ax_t = REG_STRING; + next_pc += sizeof(struct load_op) + strlen(insn->data) + 1; + PO; + } + + OP(FILTER_OP_LOAD_STAR_GLOB_STRING): + { + struct load_op *insn = (struct load_op *) pc; + + dbg_printf("load globbing pattern %s\n", insn->data); + estack_push(stack, top, ax, bx, ax_t, bx_t); + estack_ax(stack, top)->u.s.str = insn->data; + estack_ax(stack, top)->u.s.seq_len = SIZE_MAX; + estack_ax(stack, top)->u.s.literal_type = + ESTACK_STRING_LITERAL_TYPE_STAR_GLOB; + estack_ax_t = REG_STAR_GLOB_STRING; next_pc += sizeof(struct load_op) + strlen(insn->data) + 1; PO; } @@ -787,8 +1398,9 @@ int lttng_filter_interpret_bytecode(void *filter_data, { struct load_op *insn = (struct load_op *) pc; - estack_push(stack, top, ax, bx); + estack_push(stack, top, ax, bx, ax_t, bx_t); estack_ax_v = ((struct literal_numeric *) insn->data)->v; + estack_ax_t = REG_S64; dbg_printf("load s64 %" PRIi64 "\n", estack_ax_v); next_pc += sizeof(struct load_op) + sizeof(struct literal_numeric); @@ -799,10 +1411,11 @@ int lttng_filter_interpret_bytecode(void *filter_data, { struct load_op *insn = (struct load_op *) pc; - estack_push(stack, top, ax, bx); + estack_push(stack, top, ax, bx, ax_t, bx_t); memcpy(&estack_ax(stack, top)->u.d, insn->data, sizeof(struct literal_double)); - dbg_printf("load s64 %g\n", estack_ax(stack, top)->u.d); + estack_ax_t = REG_DOUBLE; + dbg_printf("load double %g\n", estack_ax(stack, top)->u.d); next_pc += sizeof(struct load_op) + sizeof(struct literal_double); PO; @@ -810,14 +1423,29 @@ int lttng_filter_interpret_bytecode(void *filter_data, /* cast */ OP(FILTER_OP_CAST_TO_S64): - ERR("unsupported non-specialized bytecode op %u\n", - (unsigned int) *(filter_opcode_t *) pc); - ret = -EINVAL; - goto end; + { + /* Dynamic typing. */ + switch (estack_ax_t) { + case REG_S64: + JUMP_TO(FILTER_OP_CAST_NOP); + case REG_DOUBLE: + JUMP_TO(FILTER_OP_CAST_DOUBLE_TO_S64); + case REG_STRING: /* Fall-through */ + case REG_STAR_GLOB_STRING: + ret = -EINVAL; + goto end; + default: + ERR("Unknown filter register type (%d)", + (int) estack_ax_t); + ret = -EINVAL; + goto end; + } + } OP(FILTER_OP_CAST_DOUBLE_TO_S64): { estack_ax_v = (int64_t) estack_ax(stack, top)->u.d; + estack_ax_t = REG_S64; next_pc += sizeof(struct cast_op); PO; } @@ -828,6 +1456,128 @@ int lttng_filter_interpret_bytecode(void *filter_data, PO; } + /* get context ref */ + OP(FILTER_OP_GET_CONTEXT_REF): + { + struct load_op *insn = (struct load_op *) pc; + struct field_ref *ref = (struct field_ref *) insn->data; + struct lttng_ctx *ctx; + struct lttng_ctx_field *ctx_field; + struct lttng_ctx_value v; + + dbg_printf("get context ref offset %u type dynamic\n", + ref->offset); + ctx = rcu_dereference(session->ctx); + ctx_field = &ctx->fields[ref->offset]; + ctx_field->get_value(ctx_field, &v); + estack_push(stack, top, ax, bx, ax_t, bx_t); + switch (v.sel) { + case LTTNG_UST_DYNAMIC_TYPE_NONE: + ret = -EINVAL; + goto end; + case LTTNG_UST_DYNAMIC_TYPE_S64: + estack_ax_v = v.u.s64; + estack_ax_t = REG_S64; + dbg_printf("ref get context dynamic s64 %" PRIi64 "\n", estack_ax_v); + break; + case LTTNG_UST_DYNAMIC_TYPE_DOUBLE: + estack_ax(stack, top)->u.d = v.u.d; + estack_ax_t = REG_DOUBLE; + dbg_printf("ref get context dynamic double %g\n", estack_ax(stack, top)->u.d); + break; + case LTTNG_UST_DYNAMIC_TYPE_STRING: + estack_ax(stack, top)->u.s.str = v.u.str; + if (unlikely(!estack_ax(stack, top)->u.s.str)) { + dbg_printf("Filter warning: loading a NULL string.\n"); + ret = -EINVAL; + goto end; + } + estack_ax(stack, top)->u.s.seq_len = SIZE_MAX; + estack_ax(stack, top)->u.s.literal_type = + ESTACK_STRING_LITERAL_TYPE_NONE; + dbg_printf("ref get context dynamic string %s\n", estack_ax(stack, top)->u.s.str); + estack_ax_t = REG_STRING; + break; + default: + dbg_printf("Filter warning: unknown dynamic type (%d).\n", (int) v.sel); + ret = -EINVAL; + goto end; + } + next_pc += sizeof(struct load_op) + sizeof(struct field_ref); + PO; + } + + OP(FILTER_OP_GET_CONTEXT_REF_STRING): + { + struct load_op *insn = (struct load_op *) pc; + struct field_ref *ref = (struct field_ref *) insn->data; + struct lttng_ctx *ctx; + struct lttng_ctx_field *ctx_field; + struct lttng_ctx_value v; + + dbg_printf("get context ref offset %u type string\n", + ref->offset); + ctx = rcu_dereference(session->ctx); + ctx_field = &ctx->fields[ref->offset]; + ctx_field->get_value(ctx_field, &v); + estack_push(stack, top, ax, bx, ax_t, bx_t); + estack_ax(stack, top)->u.s.str = v.u.str; + if (unlikely(!estack_ax(stack, top)->u.s.str)) { + dbg_printf("Filter warning: loading a NULL string.\n"); + ret = -EINVAL; + goto end; + } + estack_ax(stack, top)->u.s.seq_len = SIZE_MAX; + estack_ax(stack, top)->u.s.literal_type = + ESTACK_STRING_LITERAL_TYPE_NONE; + estack_ax_t = REG_STRING; + dbg_printf("ref get context string %s\n", estack_ax(stack, top)->u.s.str); + next_pc += sizeof(struct load_op) + sizeof(struct field_ref); + PO; + } + + OP(FILTER_OP_GET_CONTEXT_REF_S64): + { + struct load_op *insn = (struct load_op *) pc; + struct field_ref *ref = (struct field_ref *) insn->data; + struct lttng_ctx *ctx; + struct lttng_ctx_field *ctx_field; + struct lttng_ctx_value v; + + dbg_printf("get context ref offset %u type s64\n", + ref->offset); + ctx = rcu_dereference(session->ctx); + ctx_field = &ctx->fields[ref->offset]; + ctx_field->get_value(ctx_field, &v); + estack_push(stack, top, ax, bx, ax_t, bx_t); + estack_ax_v = v.u.s64; + estack_ax_t = REG_S64; + dbg_printf("ref get context s64 %" PRIi64 "\n", estack_ax_v); + next_pc += sizeof(struct load_op) + sizeof(struct field_ref); + PO; + } + + OP(FILTER_OP_GET_CONTEXT_REF_DOUBLE): + { + struct load_op *insn = (struct load_op *) pc; + struct field_ref *ref = (struct field_ref *) insn->data; + struct lttng_ctx *ctx; + struct lttng_ctx_field *ctx_field; + struct lttng_ctx_value v; + + dbg_printf("get context ref offset %u type double\n", + ref->offset); + ctx = rcu_dereference(session->ctx); + ctx_field = &ctx->fields[ref->offset]; + ctx_field->get_value(ctx_field, &v); + estack_push(stack, top, ax, bx, ax_t, bx_t); + memcpy(&estack_ax(stack, top)->u.d, &v.u.d, sizeof(struct literal_double)); + estack_ax_t = REG_DOUBLE; + dbg_printf("ref get context double %g\n", estack_ax(stack, top)->u.d); + next_pc += sizeof(struct load_op) + sizeof(struct field_ref); + PO; + } + END_OP end: /* return 0 (discard) on error */