X-Git-Url: http://git.lttng.org/?a=blobdiff_plain;f=src%2Flttng-events.c;h=9b78ac56f5d43b0fcae0e3d60a38c18965419d04;hb=52cfcdf36dfa58e0b6fb0ac3e1809e5a2538a149;hp=176c38326bc6f8bff15e96e2bf57f14bbcca4676;hpb=8ced8896fe832af52b749d429b8eceb872a83d1b;p=lttng-modules.git diff --git a/src/lttng-events.c b/src/lttng-events.c index 176c3832..9b78ac56 100644 --- a/src/lttng-events.c +++ b/src/lttng-events.c @@ -36,6 +36,7 @@ #include #include #include +#include #include #include #include @@ -343,6 +344,8 @@ void lttng_event_notifier_group_destroy( irq_work_sync(&event_notifier_group->wakeup_pending); + kfree(event_notifier_group->sc_filter); + list_for_each_entry_safe(event_notifier_enabler, tmp_event_notifier_enabler, &event_notifier_group->enablers_head, node) lttng_event_notifier_enabler_destroy(event_notifier_enabler); @@ -817,7 +820,7 @@ struct lttng_event *_lttng_event_create(struct lttng_channel *chan, event->id = chan->free_event_id++; event->instrumentation = itype; event->evtype = LTTNG_TYPE_EVENT; - INIT_LIST_HEAD(&event->bytecode_runtime_head); + INIT_LIST_HEAD(&event->filter_bytecode_runtime_head); INIT_LIST_HEAD(&event->enablers_ref_head); switch (itype) { @@ -1049,7 +1052,7 @@ struct lttng_event_notifier *_lttng_event_notifier_create( event_notifier->instrumentation = itype; event_notifier->evtype = LTTNG_TYPE_EVENT; event_notifier->send_notification = lttng_event_notifier_notification_send; - INIT_LIST_HEAD(&event_notifier->bytecode_runtime_head); + INIT_LIST_HEAD(&event_notifier->filter_bytecode_runtime_head); INIT_LIST_HEAD(&event_notifier->enablers_ref_head); switch (itype) { @@ -1098,6 +1101,29 @@ struct lttng_event_notifier *_lttng_event_notifier_create( event_notifier->enabled = 0; event_notifier->registered = 0; event_notifier->desc = event_desc; + switch (event_notifier_param->event.u.syscall.entryexit) { + case LTTNG_KERNEL_SYSCALL_ENTRYEXIT: + ret = -EINVAL; + goto register_error; + case LTTNG_KERNEL_SYSCALL_ENTRY: + event_notifier->u.syscall.entryexit = LTTNG_SYSCALL_ENTRY; + break; + case LTTNG_KERNEL_SYSCALL_EXIT: + event_notifier->u.syscall.entryexit = LTTNG_SYSCALL_EXIT; + break; + } + switch (event_notifier_param->event.u.syscall.abi) { + case LTTNG_KERNEL_SYSCALL_ABI_ALL: + ret = -EINVAL; + goto register_error; + case LTTNG_KERNEL_SYSCALL_ABI_NATIVE: + event_notifier->u.syscall.abi = LTTNG_SYSCALL_ABI_NATIVE; + break; + case LTTNG_KERNEL_SYSCALL_ABI_COMPAT: + event_notifier->u.syscall.abi = LTTNG_SYSCALL_ABI_COMPAT; + break; + } + if (!event_notifier->desc) { ret = -EINVAL; goto register_error; @@ -1732,7 +1758,7 @@ int lttng_desc_match_enabler(const struct lttng_event_desc *desc, return -EINVAL; } switch (enabler->event_param.u.syscall.match) { - case LTTNG_SYSCALL_MATCH_NAME: + case LTTNG_KERNEL_SYSCALL_MATCH_NAME: switch (enabler->format_type) { case LTTNG_ENABLER_FORMAT_STAR_GLOB: return lttng_match_enabler_star_glob(desc_name, enabler_name); @@ -1742,7 +1768,7 @@ int lttng_desc_match_enabler(const struct lttng_event_desc *desc, return -EINVAL; } break; - case LTTNG_SYSCALL_MATCH_NR: + case LTTNG_KERNEL_SYSCALL_MATCH_NR: return -EINVAL; /* Not implemented. */ default: return -EINVAL; @@ -1968,7 +1994,7 @@ int lttng_event_enabler_ref_events(struct lttng_event_enabler *event_enabler) if (base_enabler->event_param.instrumentation == LTTNG_KERNEL_SYSCALL && base_enabler->event_param.u.syscall.entryexit == LTTNG_KERNEL_SYSCALL_ENTRYEXIT && base_enabler->event_param.u.syscall.abi == LTTNG_KERNEL_SYSCALL_ABI_ALL && - base_enabler->event_param.u.syscall.match == LTTNG_SYSCALL_MATCH_NAME && + base_enabler->event_param.u.syscall.match == LTTNG_KERNEL_SYSCALL_MATCH_NAME && !strcmp(base_enabler->event_param.name, "*")) { if (base_enabler->enabled) WRITE_ONCE(chan->syscall_all, 1); @@ -2005,8 +2031,8 @@ int lttng_event_enabler_ref_events(struct lttng_event_enabler *event_enabler) */ lttng_enabler_link_bytecode(event->desc, lttng_static_ctx, - &event->bytecode_runtime_head, - lttng_event_enabler_as_enabler(event_enabler)); + &event->filter_bytecode_runtime_head, + <tng_event_enabler_as_enabler(event_enabler)->filter_bytecode_head); /* TODO: merge event context. */ } @@ -2038,11 +2064,29 @@ void lttng_create_event_notifier_if_missing(struct lttng_event_notifier_enabler * Create event_notifiers associated with a event_notifier enabler (if not already present). */ static -int lttng_event_notifier_enabler_ref_event_notifiers(struct lttng_event_notifier_enabler *event_notifier_enabler) +int lttng_event_notifier_enabler_ref_event_notifiers( + struct lttng_event_notifier_enabler *event_notifier_enabler) { struct lttng_event_notifier_group *event_notifier_group = event_notifier_enabler->group; + struct lttng_enabler *base_enabler = lttng_event_notifier_enabler_as_enabler(event_notifier_enabler); struct lttng_event_notifier *event_notifier; + if (base_enabler->event_param.instrumentation == LTTNG_KERNEL_SYSCALL && + base_enabler->event_param.u.syscall.abi == LTTNG_KERNEL_SYSCALL_ABI_ALL && + base_enabler->event_param.u.syscall.match == LTTNG_KERNEL_SYSCALL_MATCH_NAME && + !strcmp(base_enabler->event_param.name, "*")) { + + int enabled = base_enabler->enabled; + enum lttng_kernel_syscall_entryexit entryexit = base_enabler->event_param.u.syscall.entryexit; + + if (entryexit == LTTNG_KERNEL_SYSCALL_ENTRY || entryexit == LTTNG_KERNEL_SYSCALL_ENTRYEXIT) + WRITE_ONCE(event_notifier_group->syscall_all_entry, enabled); + + if (entryexit == LTTNG_KERNEL_SYSCALL_EXIT || entryexit == LTTNG_KERNEL_SYSCALL_ENTRYEXIT) + WRITE_ONCE(event_notifier_group->syscall_all_exit, enabled); + + } + /* First ensure that probe event_notifiers are created for this enabler. */ lttng_create_event_notifier_if_missing(event_notifier_enabler); @@ -2074,8 +2118,8 @@ int lttng_event_notifier_enabler_ref_event_notifiers(struct lttng_event_notifier * Link filter bytecodes if not linked yet. */ lttng_enabler_link_bytecode(event_notifier->desc, - lttng_static_ctx, &event_notifier->bytecode_runtime_head, - lttng_event_notifier_enabler_as_enabler(event_notifier_enabler)); + lttng_static_ctx, &event_notifier->filter_bytecode_runtime_head, + <tng_event_notifier_enabler_as_enabler(event_notifier_enabler)->filter_bytecode_head); } return 0; } @@ -2171,17 +2215,17 @@ int lttng_event_enabler_disable(struct lttng_event_enabler *event_enabler) } static -int lttng_enabler_attach_bytecode(struct lttng_enabler *enabler, +int lttng_enabler_attach_filter_bytecode(struct lttng_enabler *enabler, struct lttng_kernel_filter_bytecode __user *bytecode) { - struct lttng_filter_bytecode_node *bytecode_node; + struct lttng_bytecode_node *bytecode_node; uint32_t bytecode_len; int ret; ret = get_user(bytecode_len, &bytecode->len); if (ret) return ret; - bytecode_node = kzalloc(sizeof(*bytecode_node) + bytecode_len, + bytecode_node = lttng_kvzalloc(sizeof(*bytecode_node) + bytecode_len, GFP_KERNEL); if (!bytecode_node) return -ENOMEM; @@ -2190,6 +2234,7 @@ int lttng_enabler_attach_bytecode(struct lttng_enabler *enabler, if (ret) goto error_free; + bytecode_node->type = LTTNG_BYTECODE_NODE_TYPE_FILTER; bytecode_node->enabler = enabler; /* Enforce length based on allocated size */ bytecode_node->bc.len = bytecode_len; @@ -2198,15 +2243,15 @@ int lttng_enabler_attach_bytecode(struct lttng_enabler *enabler, return 0; error_free: - kfree(bytecode_node); + lttng_kvfree(bytecode_node); return ret; } -int lttng_event_enabler_attach_bytecode(struct lttng_event_enabler *event_enabler, +int lttng_event_enabler_attach_filter_bytecode(struct lttng_event_enabler *event_enabler, struct lttng_kernel_filter_bytecode __user *bytecode) { int ret; - ret = lttng_enabler_attach_bytecode( + ret = lttng_enabler_attach_filter_bytecode( lttng_event_enabler_as_enabler(event_enabler), bytecode); if (ret) goto error; @@ -2239,12 +2284,12 @@ int lttng_event_enabler_attach_context(struct lttng_event_enabler *event_enabler static void lttng_enabler_destroy(struct lttng_enabler *enabler) { - struct lttng_filter_bytecode_node *filter_node, *tmp_filter_node; + struct lttng_bytecode_node *filter_node, *tmp_filter_node; /* Destroy filter bytecode */ list_for_each_entry_safe(filter_node, tmp_filter_node, &enabler->filter_bytecode_head, node) { - kfree(filter_node); + lttng_kvfree(filter_node); } } @@ -2274,9 +2319,8 @@ struct lttng_event_notifier_enabler *lttng_event_notifier_enabler_create( event_notifier_enabler->base.format_type = format_type; INIT_LIST_HEAD(&event_notifier_enabler->base.filter_bytecode_head); - memcpy(&event_notifier_enabler->base.event_param.name, event_notifier_param->event.name, - sizeof(event_notifier_enabler->base.event_param.name)); - event_notifier_enabler->base.event_param.instrumentation = event_notifier_param->event.instrumentation; + memcpy(&event_notifier_enabler->base.event_param, &event_notifier_param->event, + sizeof(event_notifier_enabler->base.event_param)); event_notifier_enabler->base.evtype = LTTNG_TYPE_ENABLER; event_notifier_enabler->base.enabled = 0; @@ -2312,13 +2356,13 @@ int lttng_event_notifier_enabler_disable( return 0; } -int lttng_event_notifier_enabler_attach_bytecode( +int lttng_event_notifier_enabler_attach_filter_bytecode( struct lttng_event_notifier_enabler *event_notifier_enabler, struct lttng_kernel_filter_bytecode __user *bytecode) { int ret; - ret = lttng_enabler_attach_bytecode( + ret = lttng_enabler_attach_filter_bytecode( lttng_event_notifier_enabler_as_enabler(event_notifier_enabler), bytecode); if (ret) @@ -2436,8 +2480,8 @@ void lttng_session_sync_event_enablers(struct lttng_session *session) /* Enable filters */ list_for_each_entry(runtime, - &event->bytecode_runtime_head, node) - lttng_filter_sync_state(runtime); + &event->filter_bytecode_runtime_head, node) + lttng_bytecode_filter_sync_state(runtime); } } @@ -2519,8 +2563,8 @@ void lttng_event_notifier_group_sync_enablers(struct lttng_event_notifier_group /* Enable filters */ list_for_each_entry(runtime, - &event_notifier->bytecode_runtime_head, node) - lttng_filter_sync_state(runtime); + &event_notifier->filter_bytecode_runtime_head, node) + lttng_bytecode_filter_sync_state(runtime); } }