X-Git-Url: http://git.liburcu.org/?a=blobdiff_plain;f=liblttng-ust%2Flttng-filter.h;h=cc15c1546fa469ae1f32871d8a74092662f990bf;hb=91ad51185170d7a782e11ef8e06643f4543ad1cd;hp=7b7213c988162b20398acb0309b63575d17a47c6;hpb=f488575f3420027d33050e779e1e3916e3b91c8c;p=lttng-ust.git diff --git a/liblttng-ust/lttng-filter.h b/liblttng-ust/lttng-filter.h index 7b7213c9..cc15c154 100644 --- a/liblttng-ust/lttng-filter.h +++ b/liblttng-ust/lttng-filter.h @@ -6,27 +6,33 @@ * * LTTng UST filter header. * - * 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. */ #include #include +#include #include #include +#include #include #include #include @@ -40,6 +46,8 @@ #define FILTER_STACK_LEN 10 /* includes 2 dummy */ #define FILTER_STACK_EMPTY 1 +#define FILTER_MAX_DATA_LEN 65536 + #ifndef min_t #define min_t(type, a, b) \ ((type) (a) < (type) (b) ? (type) (a) : (type) (b)) @@ -70,20 +78,73 @@ do { \ /* Linked bytecode. Child of struct lttng_bytecode_runtime. */ struct bytecode_runtime { struct lttng_bytecode_runtime p; + size_t data_len; + size_t data_alloc_len; + char *data; uint16_t len; - char data[0]; + char code[0]; }; enum entry_type { REG_S64, REG_DOUBLE, REG_STRING, - REG_TYPE_UNKNOWN, + REG_STAR_GLOB_STRING, + REG_UNKNOWN, + REG_PTR, +}; + +enum load_type { + LOAD_ROOT_CONTEXT, + LOAD_ROOT_APP_CONTEXT, + LOAD_ROOT_PAYLOAD, + LOAD_OBJECT, +}; + +enum object_type { + OBJECT_TYPE_S8, + OBJECT_TYPE_S16, + OBJECT_TYPE_S32, + OBJECT_TYPE_S64, + OBJECT_TYPE_U8, + OBJECT_TYPE_U16, + OBJECT_TYPE_U32, + OBJECT_TYPE_U64, + + OBJECT_TYPE_DOUBLE, + OBJECT_TYPE_STRING, + OBJECT_TYPE_STRING_SEQUENCE, + + OBJECT_TYPE_SEQUENCE, + OBJECT_TYPE_ARRAY, + OBJECT_TYPE_STRUCT, + OBJECT_TYPE_VARIANT, + + OBJECT_TYPE_DYNAMIC, +}; + +struct filter_get_index_data { + uint64_t offset; /* in bytes */ + size_t ctx_index; + size_t array_len; + struct { + size_t len; + enum object_type type; + bool rev_bo; /* reverse byte order */ + } elem; }; /* Validation stack */ +struct vstack_load { + enum load_type type; + enum object_type object_type; + const struct lttng_event_field *field; + bool rev_bo; /* reverse byte order */ +}; + struct vstack_entry { enum entry_type type; + struct vstack_load load; }; struct vstack { @@ -136,7 +197,32 @@ int vstack_pop(struct vstack *stack) } /* Execution stack */ +enum estack_string_literal_type { + ESTACK_STRING_LITERAL_TYPE_NONE, + ESTACK_STRING_LITERAL_TYPE_PLAIN, + ESTACK_STRING_LITERAL_TYPE_STAR_GLOB, +}; + +struct load_ptr { + enum load_type type; + enum object_type object_type; + const void *ptr; + bool rev_bo; + /* Temporary place-holders for contexts. */ + union { + int64_t s64; + uint64_t u64; + double d; + } u; + /* + * "field" is only needed when nested under a variant, in which + * case we cannot specialize the nested operations. + */ + const struct lttng_event_field *field; +}; + struct estack_entry { + enum entry_type type; /* For dynamic typing. */ union { int64_t v; double d; @@ -144,8 +230,9 @@ struct estack_entry { struct { const char *str; size_t seq_len; - int literal; /* is string literal ? */ + enum estack_string_literal_type literal_type; } s; + struct load_ptr ptr; } u; }; @@ -154,9 +241,18 @@ struct estack { struct estack_entry e[FILTER_STACK_LEN]; }; +/* + * Always use aliased type for ax/bx (top of stack). + * When ax/bx are S64, use aliased value. + */ #define estack_ax_v ax #define estack_bx_v bx +#define estack_ax_t ax_t +#define estack_bx_t bx_t +/* + * ax and bx registers can hold either integer, double or string. + */ #define estack_ax(stack, top) \ ({ \ assert((top) > FILTER_STACK_EMPTY); \ @@ -169,30 +265,38 @@ struct estack { &(stack)->e[(top) - 1]; \ }) -#define estack_push(stack, top, ax, bx) \ +/* + * Currently, only integers (REG_S64) can be pushed into the stack. + */ +#define estack_push(stack, top, ax, bx, ax_t, bx_t) \ do { \ assert((top) < FILTER_STACK_LEN - 1); \ (stack)->e[(top) - 1].u.v = (bx); \ + (stack)->e[(top) - 1].type = (bx_t); \ (bx) = (ax); \ + (bx_t) = (ax_t); \ ++(top); \ } while (0) -#define estack_pop(stack, top, ax, bx) \ +#define estack_pop(stack, top, ax, bx, ax_t, bx_t) \ do { \ assert((top) > FILTER_STACK_EMPTY); \ (ax) = (bx); \ + (ax_t) = (bx_t); \ (bx) = (stack)->e[(top) - 2].u.v; \ + (bx_t) = (stack)->e[(top) - 2].type; \ (top)--; \ } while (0) const char *print_op(enum filter_op op); int lttng_filter_validate_bytecode(struct bytecode_runtime *bytecode); -int lttng_filter_specialize_bytecode(struct bytecode_runtime *bytecode); +int lttng_filter_specialize_bytecode(struct lttng_event *event, + struct bytecode_runtime *bytecode); -int lttng_filter_false(void *filter_data, +uint64_t lttng_filter_false(void *filter_data, const char *filter_stack_data); -int lttng_filter_interpret_bytecode(void *filter_data, +uint64_t lttng_filter_interpret_bytecode(void *filter_data, const char *filter_stack_data); #endif /* _LTTNG_FILTER_H */