*/
#define _LGPL_SOURCE
-#include <urcu-pointer.h>
+#include <stddef.h>
#include <stdint.h>
-#include <byteswap.h>
+#include <urcu-pointer.h>
+#include <lttng/ust-endian.h>
#include "lttng-filter.h"
#include "string-utils.h"
uint64_t lttng_filter_false(void *filter_data,
const char *filter_stack_data)
{
- return 0;
+ return LTTNG_FILTER_DISCARD;
}
#ifdef INTERPRETER_USE_SWITCH
switch (field->type.atype) {
case atype_integer:
ctx_field->get_value(ctx_field, &v);
- if (field->type.u.basic.integer.signedness) {
+ if (field->type.u.integer.signedness) {
ptr->object_type = OBJECT_TYPE_S64;
ptr->u.s64 = v.u.s64;
ptr->ptr = &ptr->u.s64;
ptr->ptr = &ptr->u.u64;
}
break;
- case atype_enum:
+ case atype_enum: /* Fall-through */
+ case atype_enum_nestable:
{
- const struct lttng_integer_type *itype =
- &field->type.u.basic.enumeration.container_type;
+ const struct lttng_integer_type *itype;
+ if (field->type.atype == atype_enum) {
+ itype = &field->type.u.legacy.basic.enumeration.container_type;
+ } else {
+ itype = &field->type.u.enum_nestable.container_type->u.integer;
+ }
ctx_field->get_value(ctx_field, &v);
if (itype->signedness) {
ptr->object_type = OBJECT_TYPE_S64;
break;
}
case atype_array:
- if (field->type.u.array.elem_type.atype != atype_integer) {
+ if (field->type.u.legacy.array.elem_type.atype != atype_integer) {
+ ERR("Array nesting only supports integer types.");
+ return -EINVAL;
+ }
+ if (field->type.u.legacy.array.elem_type.u.basic.integer.encoding == lttng_encode_none) {
+ ERR("Only string arrays are supported for contexts.");
+ return -EINVAL;
+ }
+ ptr->object_type = OBJECT_TYPE_STRING;
+ ctx_field->get_value(ctx_field, &v);
+ ptr->ptr = v.u.str;
+ break;
+ case atype_array_nestable:
+ if (field->type.u.array_nestable.elem_type->atype != atype_integer) {
ERR("Array nesting only supports integer types.");
return -EINVAL;
}
- if (field->type.u.array.elem_type.u.basic.integer.encoding == lttng_encode_none) {
+ if (field->type.u.array_nestable.elem_type->u.integer.encoding == lttng_encode_none) {
ERR("Only string arrays are supported for contexts.");
return -EINVAL;
}
ptr->ptr = v.u.str;
break;
case atype_sequence:
- if (field->type.u.sequence.elem_type.atype != atype_integer) {
+ if (field->type.u.legacy.sequence.elem_type.atype != atype_integer) {
ERR("Sequence nesting only supports integer types.");
return -EINVAL;
}
- if (field->type.u.sequence.elem_type.u.basic.integer.encoding == lttng_encode_none) {
+ if (field->type.u.legacy.sequence.elem_type.u.basic.integer.encoding == lttng_encode_none) {
+ ERR("Only string sequences are supported for contexts.");
+ return -EINVAL;
+ }
+ ptr->object_type = OBJECT_TYPE_STRING;
+ ctx_field->get_value(ctx_field, &v);
+ ptr->ptr = v.u.str;
+ break;
+ case atype_sequence_nestable:
+ if (field->type.u.sequence_nestable.elem_type->atype != atype_integer) {
+ ERR("Sequence nesting only supports integer types.");
+ return -EINVAL;
+ }
+ if (field->type.u.sequence_nestable.elem_type->u.integer.encoding == lttng_encode_none) {
ERR("Only string sequences are supported for contexts.");
return -EINVAL;
}
break;
case atype_float:
ptr->object_type = OBJECT_TYPE_DOUBLE;
+ ctx_field->get_value(ctx_field, &v);
ptr->u.d = v.u.d;
ptr->ptr = &ptr->u.d;
break;
{
uint16_t tmp;
- dbg_printf("op load field s16\n");
+ dbg_printf("op load field u16\n");
tmp = *(uint16_t *) stack_top->u.ptr.ptr;
if (stack_top->u.ptr.rev_bo)
tmp = bswap_16(tmp);
[ FILTER_OP_MOD ] = &&LABEL_FILTER_OP_MOD,
[ FILTER_OP_PLUS ] = &&LABEL_FILTER_OP_PLUS,
[ FILTER_OP_MINUS ] = &&LABEL_FILTER_OP_MINUS,
- [ FILTER_OP_RSHIFT ] = &&LABEL_FILTER_OP_RSHIFT,
- [ FILTER_OP_LSHIFT ] = &&LABEL_FILTER_OP_LSHIFT,
+ [ FILTER_OP_BIT_RSHIFT ] = &&LABEL_FILTER_OP_BIT_RSHIFT,
+ [ FILTER_OP_BIT_LSHIFT ] = &&LABEL_FILTER_OP_BIT_LSHIFT,
[ FILTER_OP_BIT_AND ] = &&LABEL_FILTER_OP_BIT_AND,
[ FILTER_OP_BIT_OR ] = &&LABEL_FILTER_OP_BIT_OR,
[ FILTER_OP_BIT_XOR ] = &&LABEL_FILTER_OP_BIT_XOR,
[ FILTER_OP_LOAD_FIELD_STRING ] = &&LABEL_FILTER_OP_LOAD_FIELD_STRING,
[ FILTER_OP_LOAD_FIELD_SEQUENCE ] = &&LABEL_FILTER_OP_LOAD_FIELD_SEQUENCE,
[ FILTER_OP_LOAD_FIELD_DOUBLE ] = &&LABEL_FILTER_OP_LOAD_FIELD_DOUBLE,
+
+ [ FILTER_OP_UNARY_BIT_NOT ] = &&LABEL_FILTER_OP_UNARY_BIT_NOT,
+
+ [ FILTER_OP_RETURN_S64 ] = &&LABEL_FILTER_OP_RETURN_S64,
};
#endif /* #ifndef INTERPRETER_USE_SWITCH */
goto end;
OP(FILTER_OP_RETURN):
- /* LTTNG_FILTER_DISCARD or LTTNG_FILTER_RECORD_FLAG */
+ /* LTTNG_FILTER_DISCARD or LTTNG_FILTER_RECORD_FLAG */
/* Handle dynamic typing. */
switch (estack_ax_t) {
case REG_S64:
ret = 0;
goto end;
+ OP(FILTER_OP_RETURN_S64):
+ /* LTTNG_FILTER_DISCARD or LTTNG_FILTER_RECORD_FLAG */
+ retval = !!estack_ax_v;
+ ret = 0;
+ goto end;
+
/* binary */
OP(FILTER_OP_MUL):
OP(FILTER_OP_DIV):
OP(FILTER_OP_MOD):
OP(FILTER_OP_PLUS):
OP(FILTER_OP_MINUS):
- OP(FILTER_OP_RSHIFT):
- OP(FILTER_OP_LSHIFT):
ERR("unsupported bytecode op %u",
(unsigned int) *(filter_opcode_t *) pc);
ret = -EINVAL;
next_pc += sizeof(struct binary_op);
PO;
}
+ OP(FILTER_OP_BIT_RSHIFT):
+ {
+ int64_t res;
+
+ /* Dynamic typing. */
+ if (estack_ax_t != REG_S64 || estack_bx_t != REG_S64) {
+ ret = -EINVAL;
+ goto end;
+ }
+ /* Catch undefined behavior. */
+ if (caa_unlikely(estack_ax_v < 0 || estack_ax_v >= 64)) {
+ ret = -EINVAL;
+ goto end;
+ }
+ res = ((uint64_t) estack_bx_v >> (uint32_t) estack_ax_v);
+ 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_BIT_LSHIFT):
+ {
+ int64_t res;
+
+ /* Dynamic typing. */
+ if (estack_ax_t != REG_S64 || estack_bx_t != REG_S64) {
+ ret = -EINVAL;
+ goto end;
+ }
+ /* Catch undefined behavior. */
+ if (caa_unlikely(estack_ax_v < 0 || estack_ax_v >= 64)) {
+ ret = -EINVAL;
+ goto end;
+ }
+ res = ((uint64_t) estack_bx_v << (uint32_t) estack_ax_v);
+ 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_BIT_AND):
{
int64_t res;
goto end;
}
- res = (estack_bx_v & estack_ax_v);
+ res = ((uint64_t) estack_bx_v & (uint64_t) estack_ax_v);
estack_pop(stack, top, ax, bx, ax_t, bx_t);
estack_ax_v = res;
estack_ax_t = REG_S64;
goto end;
}
- res = (estack_bx_v | estack_ax_v);
+ res = ((uint64_t) estack_bx_v | (uint64_t) estack_ax_v);
estack_pop(stack, top, ax, bx, ax_t, bx_t);
estack_ax_v = res;
estack_ax_t = REG_S64;
goto end;
}
- res = (estack_bx_v ^ estack_ax_v);
+ res = ((uint64_t) estack_bx_v ^ (uint64_t) estack_ax_v);
estack_pop(stack, top, ax, bx, ax_t, bx_t);
estack_ax_v = res;
estack_ax_t = REG_S64;
PO;
}
+ OP(FILTER_OP_UNARY_BIT_NOT):
+ {
+ /* Dynamic typing. */
+ if (estack_ax_t != REG_S64) {
+ ret = -EINVAL;
+ goto end;
+ }
+
+ estack_ax_v = ~(uint64_t) estack_ax_v;
+ next_pc += sizeof(struct unary_op);
+ PO;
+ }
+
OP(FILTER_OP_UNARY_PLUS_S64):
OP(FILTER_OP_UNARY_PLUS_DOUBLE):
{
END_OP
end:
- /* return 0 (discard) on error */
+ /* Return _DISCARD on error. */
if (ret)
- return 0;
+ return LTTNG_FILTER_DISCARD;
return retval;
}