const char *field_name,
enum bytecode_op bytecode_op)
{
- const struct lttng_kernel_event_field **fields, *field = NULL;
+ const struct lttng_kernel_event_field * const *fields, *field = NULL;
unsigned int nr_fields, i;
struct load_op *op;
uint32_t field_offset = 0;
/* Lookup event by name */
if (!event_desc)
return -EINVAL;
- fields = event_desc->fields;
+ fields = event_desc->tp_class->fields;
if (!fields)
return -EINVAL;
- nr_fields = event_desc->nr_fields;
+ nr_fields = event_desc->tp_class->nr_fields;
for (i = 0; i < nr_fields; i++) {
if (fields[i]->nofilter)
continue;
{
const struct lttng_kernel_type_array *array_type = lttng_kernel_get_type_array(field->type);
const struct lttng_kernel_type_common *elem_type = array_type->elem_type;
+ const struct lttng_kernel_type_integer *elem_integer_type;
if (!lttng_kernel_type_is_bytewise_integer(elem_type) || array_type->encoding == lttng_kernel_string_encoding_none)
return -EINVAL;
- if (field->user)
+ elem_integer_type = container_of(elem_type, const struct lttng_kernel_type_integer, parent);
+ if (elem_integer_type->user)
op->op = BYTECODE_OP_LOAD_FIELD_REF_USER_SEQUENCE;
else
op->op = BYTECODE_OP_LOAD_FIELD_REF_SEQUENCE;
{
const struct lttng_kernel_type_sequence *sequence_type = lttng_kernel_get_type_sequence(field->type);
const struct lttng_kernel_type_common *elem_type = sequence_type->elem_type;
+ const struct lttng_kernel_type_integer *elem_integer_type;
if (!lttng_kernel_type_is_bytewise_integer(elem_type) || sequence_type->encoding == lttng_kernel_string_encoding_none)
return -EINVAL;
- if (field->user)
+ elem_integer_type = container_of(elem_type, const struct lttng_kernel_type_integer, parent);
+ if (elem_integer_type->user)
op->op = BYTECODE_OP_LOAD_FIELD_REF_USER_SEQUENCE;
else
op->op = BYTECODE_OP_LOAD_FIELD_REF_SEQUENCE;
break;
}
case lttng_kernel_type_string:
- if (field->user)
+ {
+ const struct lttng_kernel_type_string *string_type = lttng_kernel_get_type_string(field->type);
+
+ if (string_type->user)
op->op = BYTECODE_OP_LOAD_FIELD_REF_USER_STRING;
else
op->op = BYTECODE_OP_LOAD_FIELD_REF_STRING;
break;
+ }
case lttng_kernel_type_struct: /* Unsupported. */
case lttng_kernel_type_variant: /* Unsupported. */
default:
break;
/* Sequence and array supported as string */
case lttng_kernel_type_string:
- BUG_ON(ctx_field->event_field->user);
+ {
+ const struct lttng_kernel_type_string *string_type = lttng_kernel_get_type_string(ctx_field->event_field->type);
+
+ BUG_ON(string_type->user);
op->op = BYTECODE_OP_GET_CONTEXT_REF_STRING;
break;
+ }
case lttng_kernel_type_array:
{
const struct lttng_kernel_type_array *array_type = lttng_kernel_get_type_array(ctx_field->event_field->type);
const struct lttng_kernel_type_common *elem_type = array_type->elem_type;
+ const struct lttng_kernel_type_integer *elem_integer_type;
if (!lttng_kernel_type_is_bytewise_integer(elem_type) || array_type->encoding == lttng_kernel_string_encoding_none)
return -EINVAL;
- BUG_ON(ctx_field->event_field->user);
+ elem_integer_type = container_of(elem_type, const struct lttng_kernel_type_integer, parent);
+ BUG_ON(elem_integer_type->user);
op->op = BYTECODE_OP_GET_CONTEXT_REF_STRING;
break;
}
{
const struct lttng_kernel_type_sequence *sequence_type = lttng_kernel_get_type_sequence(ctx_field->event_field->type);
const struct lttng_kernel_type_common *elem_type = sequence_type->elem_type;
+ const struct lttng_kernel_type_integer *elem_integer_type;
if (!lttng_kernel_type_is_bytewise_integer(elem_type) || sequence_type->encoding == lttng_kernel_string_encoding_none)
return -EINVAL;
- BUG_ON(ctx_field->event_field->user);
+ elem_integer_type = container_of(elem_type, const struct lttng_kernel_type_integer, parent);
+ BUG_ON(elem_integer_type->user);
op->op = BYTECODE_OP_GET_CONTEXT_REF_STRING;
break;
}
}
static
-int bytecode_is_linked(struct lttng_bytecode_node *bytecode,
+int bytecode_is_linked(struct lttng_kernel_bytecode_node *bytecode,
struct list_head *bytecode_runtime_head)
{
- struct lttng_bytecode_runtime *bc_runtime;
+ struct lttng_kernel_bytecode_runtime *bc_runtime;
list_for_each_entry(bc_runtime, bytecode_runtime_head, node) {
if (bc_runtime->bc == bytecode)
static
int link_bytecode(const struct lttng_kernel_event_desc *event_desc,
struct lttng_kernel_ctx *ctx,
- struct lttng_bytecode_node *bytecode,
+ struct lttng_kernel_bytecode_node *bytecode,
struct list_head *bytecode_runtime_head,
struct list_head *insert_loc)
{
ret = -ENOMEM;
goto alloc_error;
}
+ runtime->p.type = bytecode->type;
runtime->p.bc = bytecode;
runtime->p.ctx = ctx;
runtime->len = bytecode->bc.reloc_offset;
/* copy original bytecode */
memcpy(runtime->code, bytecode->bc.data, runtime->len);
+ /* Validate bytecode load instructions before relocs. */
+ ret = lttng_bytecode_validate_load(runtime);
+ if (ret) {
+ goto link_error;
+ }
/*
* apply relocs. Those are a uint16_t (offset in bytecode)
* followed by a string (field name).
if (ret) {
goto link_error;
}
-
- switch (bytecode->type) {
- case LTTNG_BYTECODE_NODE_TYPE_FILTER:
- runtime->p.interpreter_funcs.filter = lttng_bytecode_filter_interpret;
- break;
- case LTTNG_BYTECODE_NODE_TYPE_CAPTURE:
- runtime->p.interpreter_funcs.capture = lttng_bytecode_capture_interpret_false;
- break;
- default:
- WARN_ON(1);
- }
-
+ runtime->p.interpreter_func = lttng_bytecode_interpret;
runtime->p.link_failed = 0;
list_add_rcu(&runtime->p.node, insert_loc);
dbg_printk("Linking successful.\n");
link_error:
- switch (bytecode->type) {
- case LTTNG_BYTECODE_NODE_TYPE_FILTER:
- runtime->p.interpreter_funcs.filter = lttng_bytecode_filter_interpret_false;
- break;
- case LTTNG_BYTECODE_NODE_TYPE_CAPTURE:
- runtime->p.interpreter_funcs.capture = lttng_bytecode_capture_interpret_false;
- break;
- default:
- WARN_ON(1);
- }
+ runtime->p.interpreter_func = lttng_bytecode_interpret_error;
runtime->p.link_failed = 1;
list_add_rcu(&runtime->p.node, insert_loc);
alloc_error:
return ret;
}
-void lttng_bytecode_filter_sync_state(struct lttng_bytecode_runtime *runtime)
+void lttng_bytecode_sync_state(struct lttng_kernel_bytecode_runtime *runtime)
{
- struct lttng_bytecode_node *bc = runtime->bc;
+ struct lttng_kernel_bytecode_node *bc = runtime->bc;
if (!bc->enabler->enabled || runtime->link_failed)
- runtime->interpreter_funcs.filter = lttng_bytecode_filter_interpret_false;
+ runtime->interpreter_func = lttng_bytecode_interpret_error;
else
- runtime->interpreter_funcs.filter = lttng_bytecode_filter_interpret;
-}
-
-void lttng_bytecode_capture_sync_state(struct lttng_bytecode_runtime *runtime)
-{
- struct lttng_bytecode_node *bc = runtime->bc;
-
- if (!bc->enabler->enabled || runtime->link_failed)
- runtime->interpreter_funcs.capture = lttng_bytecode_capture_interpret_false;
- else
- runtime->interpreter_funcs.capture = lttng_bytecode_capture_interpret;
+ runtime->interpreter_func = lttng_bytecode_interpret;
}
/*
struct list_head *instance_bytecode_head,
struct list_head *enabler_bytecode_head)
{
- struct lttng_bytecode_node *enabler_bc;
- struct lttng_bytecode_runtime *runtime;
+ struct lttng_kernel_bytecode_node *enabler_bc;
+ struct lttng_kernel_bytecode_runtime *runtime;
WARN_ON_ONCE(!event_desc);
}
}
-/*
- * We own the filter_bytecode if we return success.
- */
-int lttng_filter_enabler_attach_bytecode(struct lttng_enabler *enabler,
- struct lttng_bytecode_node *filter_bytecode)
-{
- list_add(&filter_bytecode->node, &enabler->filter_bytecode_head);
- return 0;
-}
-
-void lttng_free_enabler_filter_bytecode(struct lttng_enabler *enabler)
-{
- struct lttng_bytecode_node *filter_bytecode, *tmp;
-
- list_for_each_entry_safe(filter_bytecode, tmp,
- &enabler->filter_bytecode_head, node) {
- kfree(filter_bytecode);
- }
-}
-
-void lttng_free_event_filter_runtime(struct lttng_event *event)
-{
- struct bytecode_runtime *runtime, *tmp;
-
- list_for_each_entry_safe(runtime, tmp,
- &event->filter_bytecode_runtime_head, p.node) {
- kfree(runtime->data);
- kfree(runtime);
- }
-}
-
-void lttng_free_event_notifier_filter_runtime(struct lttng_event_notifier *event_notifier)
+void lttng_free_event_filter_runtime(struct lttng_kernel_event_common *event)
{
struct bytecode_runtime *runtime, *tmp;
list_for_each_entry_safe(runtime, tmp,
- &event_notifier->filter_bytecode_runtime_head, p.node) {
+ &event->priv->filter_bytecode_runtime_head, p.node) {
kfree(runtime->data);
kfree(runtime);
}
projects / lttng-modules.git / blobdiff