X-Git-Url: http://git.lttng.org/?a=blobdiff_plain;f=liblttng-ust%2Flttng-filter-validator.c;h=d24f1d80bcabac8efdd2cfa73883d6035c06a2e2;hb=3151a51df2b93554f3e4559a2e7ec08541e8674d;hp=6cdfd8c164764e075bab11a5cb8234c51765890f;hpb=77aa5901fd3f09001fb7e78f3533cf58c6d345e5;p=lttng-ust.git diff --git a/liblttng-ust/lttng-filter-validator.c b/liblttng-ust/lttng-filter-validator.c index 6cdfd8c1..d24f1d80 100644 --- a/liblttng-ust/lttng-filter-validator.c +++ b/liblttng-ust/lttng-filter-validator.c @@ -3,21 +3,25 @@ * * LTTng UST filter bytecode validator. * - * 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 @@ -27,6 +31,7 @@ #include #include "lttng-hash-helper.h" +#include "string-utils.h" /* * Number of merge points for hash table size. Hash table initialized to @@ -74,7 +79,9 @@ int merge_points_compare(const struct vstack *stacka, len = stacka->top + 1; assert(len >= 0); for (i = 0; i < len; i++) { - if (stacka->e[i].type != stackb->e[i].type) + if (stacka->e[i].type != REG_UNKNOWN + && stackb->e[i].type != REG_UNKNOWN + && stacka->e[i].type != stackb->e[i].type) return 1; } return 0; @@ -85,7 +92,7 @@ int merge_point_add_check(struct cds_lfht *ht, unsigned long target_pc, const struct vstack *stack) { struct lfht_mp_node *node; - unsigned long hash = lttng_hash_mix((const void *) target_pc, + unsigned long hash = lttng_hash_mix((const char *) target_pc, sizeof(target_pc), lttng_hash_seed); struct cds_lfht_node *ret; @@ -98,7 +105,7 @@ int merge_point_add_check(struct cds_lfht *ht, unsigned long target_pc, node->target_pc = target_pc; memcpy(&node->stack, stack, sizeof(node->stack)); ret = cds_lfht_add_unique(ht, hash, lttng_hash_match, - (const void *) target_pc, &node->node); + (const char *) target_pc, &node->node); if (ret != &node->node) { struct lfht_mp_node *ret_mp = caa_container_of(ret, struct lfht_mp_node, node); @@ -118,24 +125,54 @@ int merge_point_add_check(struct cds_lfht *ht, unsigned long target_pc, /* * Binary comparators use top of stack and top of stack -1. + * Return 0 if typing is known to match, 1 if typing is dynamic + * (unknown), negative error value on error. */ static -int bin_op_compare_check(struct vstack *stack, const char *str) +int bin_op_compare_check(struct vstack *stack, filter_opcode_t opcode, + const char *str) { if (unlikely(!vstack_ax(stack) || !vstack_bx(stack))) - goto error_unknown; + goto error_empty; switch (vstack_ax(stack)->type) { default: - goto error_unknown; + goto error_type; + case REG_UNKNOWN: + goto unknown; case REG_STRING: switch (vstack_bx(stack)->type) { default: - goto error_unknown; + goto error_type; + case REG_UNKNOWN: + goto unknown; case REG_STRING: break; + case REG_STAR_GLOB_STRING: + if (opcode != FILTER_OP_EQ && opcode != FILTER_OP_NE) { + goto error_mismatch; + } + break; + case REG_S64: + case REG_DOUBLE: + goto error_mismatch; + } + break; + case REG_STAR_GLOB_STRING: + switch (vstack_bx(stack)->type) { + default: + goto error_type; + + case REG_UNKNOWN: + goto unknown; + case REG_STRING: + if (opcode != FILTER_OP_EQ && opcode != FILTER_OP_NE) { + goto error_mismatch; + } + break; + case REG_STAR_GLOB_STRING: case REG_S64: case REG_DOUBLE: goto error_mismatch; @@ -145,11 +182,13 @@ int bin_op_compare_check(struct vstack *stack, const char *str) case REG_DOUBLE: switch (vstack_bx(stack)->type) { default: - goto error_unknown; + goto error_type; + case REG_UNKNOWN: + goto unknown; case REG_STRING: + case REG_STAR_GLOB_STRING: goto error_mismatch; - case REG_S64: case REG_DOUBLE: break; @@ -158,12 +197,20 @@ int bin_op_compare_check(struct vstack *stack, const char *str) } return 0; -error_unknown: - return -EINVAL; +unknown: + return 1; error_mismatch: ERR("type mismatch for '%s' binary operator\n", str); return -EINVAL; + +error_empty: + ERR("empty stack for '%s' binary operator\n", str); + return -EINVAL; + +error_type: + ERR("unknown type for '%s' binary operator\n", str); + return -EINVAL; } /* @@ -172,7 +219,7 @@ error_mismatch: */ static int bytecode_validate_overflow(struct bytecode_runtime *bytecode, - void *start_pc, void *pc) + char *start_pc, char *pc) { int ret = 0; @@ -225,6 +272,8 @@ int bytecode_validate_overflow(struct bytecode_runtime *bytecode, case FILTER_OP_LT_STRING: case FILTER_OP_GE_STRING: case FILTER_OP_LE_STRING: + case FILTER_OP_EQ_STAR_GLOB_STRING: + case FILTER_OP_NE_STAR_GLOB_STRING: case FILTER_OP_EQ_S64: case FILTER_OP_NE_S64: case FILTER_OP_GT_S64: @@ -295,11 +344,6 @@ int bytecode_validate_overflow(struct bytecode_runtime *bytecode, } /* get context ref */ case FILTER_OP_GET_CONTEXT_REF: - { - ERR("Unknown field ref type\n"); - ret = -EINVAL; - break; - } case FILTER_OP_LOAD_FIELD_REF_STRING: case FILTER_OP_LOAD_FIELD_REF_SEQUENCE: case FILTER_OP_LOAD_FIELD_REF_S64: @@ -317,6 +361,7 @@ int bytecode_validate_overflow(struct bytecode_runtime *bytecode, /* load from immediate operand */ case FILTER_OP_LOAD_STRING: + case FILTER_OP_LOAD_STAR_GLOB_STRING: { struct load_op *insn = (struct load_op *) pc; uint32_t str_len, maxlen; @@ -391,18 +436,19 @@ unsigned long delete_all_nodes(struct cds_lfht *ht) /* * Return value: - * 0: success + * >=0: success * <0: error */ static int validate_instruction_context(struct bytecode_runtime *bytecode, struct vstack *stack, - void *start_pc, - void *pc) + char *start_pc, + char *pc) { int ret = 0; + const filter_opcode_t opcode = *(filter_opcode_t *) pc; - switch (*(filter_opcode_t *) pc) { + switch (opcode) { case FILTER_OP_UNKNOWN: default: { @@ -430,50 +476,50 @@ int validate_instruction_context(struct bytecode_runtime *bytecode, case FILTER_OP_BIN_XOR: { ERR("unsupported bytecode op %u\n", - (unsigned int) *(filter_opcode_t *) pc); + (unsigned int) opcode); ret = -EINVAL; goto end; } case FILTER_OP_EQ: { - ret = bin_op_compare_check(stack, "=="); - if (ret) + ret = bin_op_compare_check(stack, opcode, "=="); + if (ret < 0) goto end; break; } case FILTER_OP_NE: { - ret = bin_op_compare_check(stack, "!="); - if (ret) + ret = bin_op_compare_check(stack, opcode, "!="); + if (ret < 0) goto end; break; } case FILTER_OP_GT: { - ret = bin_op_compare_check(stack, ">"); - if (ret) + ret = bin_op_compare_check(stack, opcode, ">"); + if (ret < 0) goto end; break; } case FILTER_OP_LT: { - ret = bin_op_compare_check(stack, "<"); - if (ret) + ret = bin_op_compare_check(stack, opcode, "<"); + if (ret < 0) goto end; break; } case FILTER_OP_GE: { - ret = bin_op_compare_check(stack, ">="); - if (ret) + ret = bin_op_compare_check(stack, opcode, ">="); + if (ret < 0) goto end; break; } case FILTER_OP_LE: { - ret = bin_op_compare_check(stack, "<="); - if (ret) + ret = bin_op_compare_check(stack, opcode, "<="); + if (ret < 0) goto end; break; } @@ -499,6 +545,23 @@ int validate_instruction_context(struct bytecode_runtime *bytecode, break; } + case FILTER_OP_EQ_STAR_GLOB_STRING: + case FILTER_OP_NE_STAR_GLOB_STRING: + { + if (!vstack_ax(stack) || !vstack_bx(stack)) { + ERR("Empty stack\n"); + ret = -EINVAL; + goto end; + } + if (vstack_ax(stack)->type != REG_STAR_GLOB_STRING + && vstack_bx(stack)->type != REG_STAR_GLOB_STRING) { + ERR("Unexpected register type for globbing pattern comparator\n"); + ret = -EINVAL; + goto end; + } + break; + } + case FILTER_OP_EQ_S64: case FILTER_OP_NE_S64: case FILTER_OP_GT_S64: @@ -597,6 +660,7 @@ int validate_instruction_context(struct bytecode_runtime *bytecode, goto end; case REG_STRING: + case REG_STAR_GLOB_STRING: ERR("Unary op can only be applied to numeric or floating point registers\n"); ret = -EINVAL; goto end; @@ -604,6 +668,8 @@ int validate_instruction_context(struct bytecode_runtime *bytecode, break; case REG_DOUBLE: break; + case REG_UNKNOWN: + break; } break; } @@ -653,8 +719,9 @@ int validate_instruction_context(struct bytecode_runtime *bytecode, ret = -EINVAL; goto end; } - if (vstack_ax(stack)->type != REG_S64) { - ERR("Logical comparator expects S64 register\n"); + if (vstack_ax(stack)->type != REG_S64 + && vstack_ax(stack)->type != REG_UNKNOWN) { + ERR("Logical comparator expects S64 or dynamic register\n"); ret = -EINVAL; goto end; } @@ -707,6 +774,7 @@ int validate_instruction_context(struct bytecode_runtime *bytecode, /* load from immediate operand */ case FILTER_OP_LOAD_STRING: + case FILTER_OP_LOAD_STAR_GLOB_STRING: { break; } @@ -738,6 +806,7 @@ int validate_instruction_context(struct bytecode_runtime *bytecode, goto end; case REG_STRING: + case REG_STAR_GLOB_STRING: ERR("Cast op can only be applied to numeric or floating point registers\n"); ret = -EINVAL; goto end; @@ -745,6 +814,8 @@ int validate_instruction_context(struct bytecode_runtime *bytecode, break; case REG_DOUBLE: break; + case REG_UNKNOWN: + break; } if (insn->op == FILTER_OP_CAST_DOUBLE_TO_S64) { if (vstack_ax(stack)->type != REG_DOUBLE) { @@ -763,9 +834,12 @@ int validate_instruction_context(struct bytecode_runtime *bytecode, /* get context ref */ case FILTER_OP_GET_CONTEXT_REF: { - ERR("Unknown get context ref type\n"); - ret = -EINVAL; - goto end; + struct load_op *insn = (struct load_op *) pc; + struct field_ref *ref = (struct field_ref *) insn->data; + + dbg_printf("Validate get context ref offset %u type dynamic\n", + ref->offset); + break; } case FILTER_OP_GET_CONTEXT_REF_STRING: { @@ -809,8 +883,8 @@ static int validate_instruction_all_contexts(struct bytecode_runtime *bytecode, struct cds_lfht *merge_points, struct vstack *stack, - void *start_pc, - void *pc) + char *start_pc, + char *pc) { int ret; unsigned long target_pc = pc - start_pc; @@ -821,18 +895,18 @@ int validate_instruction_all_contexts(struct bytecode_runtime *bytecode, /* Validate the context resulting from the previous instruction */ ret = validate_instruction_context(bytecode, stack, start_pc, pc); - if (ret) + if (ret < 0) return ret; /* Validate merge points */ - hash = lttng_hash_mix((const void *) target_pc, sizeof(target_pc), + hash = lttng_hash_mix((const char *) target_pc, sizeof(target_pc), lttng_hash_seed); cds_lfht_lookup(merge_points, hash, lttng_hash_match, - (const void *) target_pc, &iter); + (const char *) target_pc, &iter); node = cds_lfht_iter_get_node(&iter); if (node) { mp_node = caa_container_of(node, struct lfht_mp_node, node); - + dbg_printf("Filter: validate merge point at offset %lu\n", target_pc); if (merge_points_compare(stack, &mp_node->stack)) { @@ -859,11 +933,11 @@ static int exec_insn(struct bytecode_runtime *bytecode, struct cds_lfht *merge_points, struct vstack *stack, - void **_next_pc, - void *pc) + char **_next_pc, + char *pc) { int ret = 1; - void *next_pc = *_next_pc; + char *next_pc = *_next_pc; switch (*(filter_opcode_t *) pc) { case FILTER_OP_UNKNOWN: @@ -916,6 +990,8 @@ int exec_insn(struct bytecode_runtime *bytecode, case FILTER_OP_LT_STRING: case FILTER_OP_GE_STRING: case FILTER_OP_LE_STRING: + case FILTER_OP_EQ_STAR_GLOB_STRING: + case FILTER_OP_NE_STAR_GLOB_STRING: case FILTER_OP_EQ_S64: case FILTER_OP_NE_S64: case FILTER_OP_GT_S64: @@ -959,10 +1035,23 @@ int exec_insn(struct bytecode_runtime *bytecode, /* unary */ case FILTER_OP_UNARY_PLUS: case FILTER_OP_UNARY_MINUS: - case FILTER_OP_UNARY_NOT: + { + /* Pop 1, push 1 */ + if (!vstack_ax(stack)) { + ERR("Empty stack\n"); + ret = -EINVAL; + goto end; + } + vstack_ax(stack)->type = REG_UNKNOWN; + next_pc += sizeof(struct unary_op); + break; + } + case FILTER_OP_UNARY_PLUS_S64: case FILTER_OP_UNARY_MINUS_S64: + case FILTER_OP_UNARY_NOT: case FILTER_OP_UNARY_NOT_S64: + case FILTER_OP_UNARY_NOT_DOUBLE: { /* Pop 1, push 1 */ if (!vstack_ax(stack)) { @@ -977,7 +1066,6 @@ int exec_insn(struct bytecode_runtime *bytecode, case FILTER_OP_UNARY_PLUS_DOUBLE: case FILTER_OP_UNARY_MINUS_DOUBLE: - case FILTER_OP_UNARY_NOT_DOUBLE: { /* Pop 1, push 1 */ if (!vstack_ax(stack)) { @@ -1024,9 +1112,13 @@ int exec_insn(struct bytecode_runtime *bytecode, /* get context ref */ case FILTER_OP_GET_CONTEXT_REF: { - ERR("Unknown get context ref type\n"); - ret = -EINVAL; - goto end; + if (vstack_push(stack)) { + ret = -EINVAL; + goto end; + } + vstack_ax(stack)->type = REG_UNKNOWN; + next_pc += sizeof(struct load_op) + sizeof(struct field_ref); + break; } case FILTER_OP_LOAD_FIELD_REF_STRING: case FILTER_OP_LOAD_FIELD_REF_SEQUENCE: @@ -1077,6 +1169,19 @@ int exec_insn(struct bytecode_runtime *bytecode, break; } + case FILTER_OP_LOAD_STAR_GLOB_STRING: + { + struct load_op *insn = (struct load_op *) pc; + + if (vstack_push(stack)) { + ret = -EINVAL; + goto end; + } + vstack_ax(stack)->type = REG_STAR_GLOB_STRING; + next_pc += sizeof(struct load_op) + strlen(insn->data) + 1; + break; + } + case FILTER_OP_LOAD_S64: { if (vstack_push(stack)) { @@ -1132,7 +1237,7 @@ end: int lttng_filter_validate_bytecode(struct bytecode_runtime *bytecode) { struct cds_lfht *merge_points; - void *pc, *next_pc, *start_pc; + char *pc, *next_pc, *start_pc; int ret = -EINVAL; struct vstack stack; @@ -1171,7 +1276,7 @@ int lttng_filter_validate_bytecode(struct bytecode_runtime *bytecode) /* * For each instruction, validate the current context * (traversal of entire execution flow), and validate - * all merge points targeting this instruction. + * all merge points targeting this instruction. */ ret = validate_instruction_all_contexts(bytecode, merge_points, &stack, start_pc, pc);