X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=src%2Flttng-syscalls.c;h=e8b72573a42131c95b56e4952a11710e5d2e7957;hb=fad51c94f3e3354e7bcecb58029f25405116eabd;hp=4cb3616fac2cceb56356ebb86530242ef14bc49b;hpb=67233a188457d15dc07076989ea1a3fdc114a399;p=lttng-modules.git diff --git a/src/lttng-syscalls.c b/src/lttng-syscalls.c index 4cb3616f..e8b72573 100644 --- a/src/lttng-syscalls.c +++ b/src/lttng-syscalls.c @@ -28,6 +28,7 @@ #include #include #include +#include #include #include #include @@ -130,10 +131,16 @@ struct lttng_syscall_filter { DECLARE_BITMAP(sc_exit, NR_syscalls); DECLARE_BITMAP(sc_compat_entry, NR_compat_syscalls); DECLARE_BITMAP(sc_compat_exit, NR_compat_syscalls); -}; -static -int lttng_syscalls_create_matching_event_notifiers(struct lttng_event_enabler_common *event_enabler); + /* + * Reference counters keeping track of number of events enabled + * for each bit. + */ + u32 sc_entry_refcount_map[NR_syscalls]; + u32 sc_exit_refcount_map[NR_syscalls]; + u32 sc_compat_entry_refcount_map[NR_compat_syscalls]; + u32 sc_compat_exit_refcount_map[NR_compat_syscalls]; +}; static void syscall_entry_event_unknown(struct hlist_head *unknown_action_list_head, struct pt_regs *regs, long id) @@ -529,8 +536,7 @@ struct lttng_kernel_syscall_table *get_syscall_table_from_event(struct lttng_ker static void lttng_syscall_event_enabler_create_event(struct lttng_event_enabler_common *syscall_event_enabler, - const struct lttng_kernel_event_desc *desc, struct hlist_head *dispatch_table, - enum sc_type type, unsigned int syscall_nr) + const struct lttng_kernel_event_desc *desc, enum sc_type type, unsigned int syscall_nr) { struct lttng_kernel_event_common *event; @@ -571,15 +577,13 @@ void lttng_syscall_event_enabler_create_event(struct lttng_event_enabler_common if (!event_recorder_enabler) return; event = _lttng_kernel_event_create(&event_recorder_enabler->parent, desc); - WARN_ON_ONCE(!event || IS_ERR(event)); + WARN_ON_ONCE(IS_ERR(event)); lttng_event_enabler_destroy(&event_recorder_enabler->parent); - if (!event || IS_ERR(event)) { + if (IS_ERR(event)) { printk(KERN_INFO "Unable to create event recorder %s\n", desc->event_name); return; } event->priv->u.syscall.syscall_id = syscall_nr; - if (dispatch_table) - hlist_add_head_rcu(&event->priv->u.syscall.node, dispatch_table); break; } case LTTNG_EVENT_ENABLER_TYPE_NOTIFIER: @@ -621,15 +625,13 @@ void lttng_syscall_event_enabler_create_event(struct lttng_event_enabler_common &event_notifier_param, syscall_event_notifier_enabler->group); WARN_ON_ONCE(!event_notifier_enabler); event = _lttng_kernel_event_create(&event_notifier_enabler->parent, desc); - WARN_ON_ONCE(!event || IS_ERR(event)); + WARN_ON_ONCE(IS_ERR(event)); lttng_event_enabler_destroy(&event_notifier_enabler->parent); - if (!event || IS_ERR(event)) { + if (IS_ERR(event)) { printk(KERN_INFO "Unable to create event notifier %s\n", desc->event_name); return; } event->priv->u.syscall.syscall_id = syscall_nr; - if (dispatch_table) - hlist_add_head_rcu(&event->priv->u.syscall.node, dispatch_table); break; } default: @@ -645,14 +647,15 @@ void lttng_syscall_event_enabler_create_matching_syscall_table_events(struct ltt const struct lttng_kernel_event_desc *desc; unsigned int i; - if (!IS_ENABLED(CONFIG_COMPAT) && (type == SC_TYPE_COMPAT_ENTRY || type == SC_TYPE_COMPAT_EXIT)) +#ifndef CONFIG_COMPAT + if (type == SC_TYPE_COMPAT_ENTRY || type == SC_TYPE_COMPAT_EXIT) return; - +#endif /* iterate over all syscall and create event that match */ for (i = 0; i < table_len; i++) { struct lttng_kernel_event_common_private *event_priv; struct hlist_head *head; - int found = 0; + bool found = false; desc = table[i].desc; if (!desc) { @@ -668,13 +671,15 @@ void lttng_syscall_event_enabler_create_matching_syscall_table_events(struct ltt */ head = utils_borrow_hash_table_bucket(events_ht->table, LTTNG_EVENT_HT_SIZE, desc->event_name); lttng_hlist_for_each_entry(event_priv, head, hlist_node) { - if (lttng_event_enabler_desc_match_event(syscall_event_enabler_common, desc, event_priv->pub)) - found = 1; + if (lttng_event_enabler_desc_match_event(syscall_event_enabler_common, desc, event_priv->pub)) { + found = true; + break; + } } if (found) continue; - lttng_syscall_event_enabler_create_event(syscall_event_enabler_common, desc, NULL, type, i); + lttng_syscall_event_enabler_create_event(syscall_event_enabler_common, desc, type, i); } } @@ -695,17 +700,16 @@ bool lttng_syscall_event_enabler_is_wildcard_all(struct lttng_event_enabler_comm static void create_unknown_syscall_event(struct lttng_event_enabler_common *event_enabler, enum sc_type type) { - struct lttng_kernel_syscall_table *syscall_table = get_syscall_table_from_enabler(event_enabler); struct lttng_event_ht *events_ht = lttng_get_event_ht_from_enabler(event_enabler); struct lttng_kernel_event_common_private *event_priv; const struct lttng_kernel_event_desc *desc; - struct hlist_head *unknown_dispatch_list; bool found = false; struct hlist_head *head; - if (!IS_ENABLED(CONFIG_COMPAT) && (type == SC_TYPE_COMPAT_ENTRY || type == SC_TYPE_COMPAT_EXIT)) +#ifndef CONFIG_COMPAT + if (type == SC_TYPE_COMPAT_ENTRY || type == SC_TYPE_COMPAT_EXIT) return; - +#endif /* * Considering that currently system calls can only be enabled on a per * name basis (or wildcard based on a name), unknown syscall events are @@ -721,19 +725,15 @@ void create_unknown_syscall_event(struct lttng_event_enabler_common *event_enabl switch (type) { case SC_TYPE_ENTRY: desc = &__event_desc___syscall_entry_unknown; - unknown_dispatch_list = &syscall_table->unknown_syscall_dispatch; break; case SC_TYPE_EXIT: desc = &__event_desc___syscall_exit_unknown; - unknown_dispatch_list = &syscall_table->unknown_syscall_exit_dispatch; break; case SC_TYPE_COMPAT_ENTRY: desc = &__event_desc___compat_syscall_entry_unknown; - unknown_dispatch_list = &syscall_table->compat_unknown_syscall_dispatch; break; case SC_TYPE_COMPAT_EXIT: desc = &__event_desc___compat_syscall_exit_unknown; - unknown_dispatch_list = &syscall_table->compat_unknown_syscall_exit_dispatch; break; default: WARN_ON_ONCE(1); @@ -744,36 +744,37 @@ void create_unknown_syscall_event(struct lttng_event_enabler_common *event_enabl */ head = utils_borrow_hash_table_bucket(events_ht->table, LTTNG_EVENT_HT_SIZE, desc->event_name); lttng_hlist_for_each_entry(event_priv, head, hlist_node) { - if (lttng_event_enabler_desc_match_event(event_enabler, desc, event_priv->pub)) + if (lttng_event_enabler_desc_match_event(event_enabler, desc, event_priv->pub)) { found = true; + break; + } } if (!found) - lttng_syscall_event_enabler_create_event(event_enabler, desc, unknown_dispatch_list, type, -1U); + lttng_syscall_event_enabler_create_event(event_enabler, desc, type, -1U); } static -int lttng_syscalls_populate_events(struct lttng_event_enabler_common *syscall_event_enabler) +void lttng_syscall_event_enabler_create_matching_events(struct lttng_event_enabler_common *event_enabler) { - struct lttng_event_recorder_enabler *event_recorder_enabler; - struct lttng_kernel_channel_buffer *chan; - int ret; + enum lttng_kernel_abi_syscall_entryexit entryexit = event_enabler->event_param.u.syscall.entryexit; - if (syscall_event_enabler->enabler_type != LTTNG_EVENT_ENABLER_TYPE_RECORDER) - return 0; - event_recorder_enabler = container_of(syscall_event_enabler, struct lttng_event_recorder_enabler, parent); - chan = event_recorder_enabler->chan; - - lttng_syscall_event_enabler_create_matching_syscall_table_events(&event_recorder_enabler->parent, sc_table.table, sc_table.len, SC_TYPE_ENTRY); - lttng_syscall_event_enabler_create_matching_syscall_table_events(&event_recorder_enabler->parent, sc_exit_table.table, sc_exit_table.len, SC_TYPE_EXIT); - create_unknown_syscall_event(syscall_event_enabler, SC_TYPE_ENTRY); - create_unknown_syscall_event(syscall_event_enabler, SC_TYPE_EXIT); - - lttng_syscall_event_enabler_create_matching_syscall_table_events(&event_recorder_enabler->parent, compat_sc_table.table, compat_sc_table.len, SC_TYPE_COMPAT_ENTRY); - lttng_syscall_event_enabler_create_matching_syscall_table_events(&event_recorder_enabler->parent, compat_sc_exit_table.table, compat_sc_exit_table.len, SC_TYPE_COMPAT_EXIT); - create_unknown_syscall_event(syscall_event_enabler, SC_TYPE_COMPAT_ENTRY); - create_unknown_syscall_event(syscall_event_enabler, SC_TYPE_COMPAT_EXIT); + if (entryexit == LTTNG_KERNEL_ABI_SYSCALL_ENTRY || entryexit == LTTNG_KERNEL_ABI_SYSCALL_ENTRYEXIT) { + lttng_syscall_event_enabler_create_matching_syscall_table_events(event_enabler, + sc_table.table, sc_table.len, SC_TYPE_ENTRY); + lttng_syscall_event_enabler_create_matching_syscall_table_events(event_enabler, + compat_sc_table.table, compat_sc_table.len, SC_TYPE_COMPAT_ENTRY); + create_unknown_syscall_event(event_enabler, SC_TYPE_ENTRY); + create_unknown_syscall_event(event_enabler, SC_TYPE_COMPAT_ENTRY); + } - return ret; + if (entryexit == LTTNG_KERNEL_ABI_SYSCALL_EXIT || entryexit == LTTNG_KERNEL_ABI_SYSCALL_ENTRYEXIT) { + lttng_syscall_event_enabler_create_matching_syscall_table_events(event_enabler, + sc_exit_table.table, sc_exit_table.len, SC_TYPE_EXIT); + lttng_syscall_event_enabler_create_matching_syscall_table_events(event_enabler, + compat_sc_exit_table.table, compat_sc_exit_table.len, SC_TYPE_COMPAT_EXIT); + create_unknown_syscall_event(event_enabler, SC_TYPE_EXIT); + create_unknown_syscall_event(event_enabler, SC_TYPE_COMPAT_EXIT); + } } /* @@ -819,14 +820,6 @@ int lttng_event_enabler_create_syscall_events_if_missing(struct lttng_event_enab return -ENOMEM; } - ret = lttng_syscalls_populate_events(syscall_event_enabler); - if (ret) - return ret; - - ret = lttng_syscalls_create_matching_event_notifiers(syscall_event_enabler); - if (ret) - return ret; - if (!syscall_table->sys_enter_registered) { ret = lttng_wrapper_tracepoint_probe_register("sys_enter", (void *) syscall_entry_event_probe, syscall_table); @@ -845,39 +838,9 @@ int lttng_event_enabler_create_syscall_events_if_missing(struct lttng_event_enab syscall_table->sys_exit_registered = 1; } - return ret; -} - -static -int lttng_syscalls_create_matching_event_notifiers(struct lttng_event_enabler_common *event_enabler) -{ - int ret; - enum lttng_kernel_abi_syscall_entryexit entryexit = - event_enabler->event_param.u.syscall.entryexit; - struct lttng_event_notifier_enabler *event_notifier_enabler; - - if (event_enabler->enabler_type != LTTNG_EVENT_ENABLER_TYPE_NOTIFIER) - return 0; - event_notifier_enabler = container_of(event_enabler, struct lttng_event_notifier_enabler, parent); - - if (entryexit == LTTNG_KERNEL_ABI_SYSCALL_ENTRY || entryexit == LTTNG_KERNEL_ABI_SYSCALL_ENTRYEXIT) { - lttng_syscall_event_enabler_create_matching_syscall_table_events(&event_notifier_enabler->parent, - sc_table.table, sc_table.len, SC_TYPE_ENTRY); - lttng_syscall_event_enabler_create_matching_syscall_table_events(&event_notifier_enabler->parent, - compat_sc_table.table, compat_sc_table.len, SC_TYPE_COMPAT_ENTRY); - create_unknown_syscall_event(event_enabler, SC_TYPE_ENTRY); - create_unknown_syscall_event(event_enabler, SC_TYPE_COMPAT_ENTRY); - } + lttng_syscall_event_enabler_create_matching_events(syscall_event_enabler); - if (entryexit == LTTNG_KERNEL_ABI_SYSCALL_EXIT || entryexit == LTTNG_KERNEL_ABI_SYSCALL_ENTRYEXIT) { - lttng_syscall_event_enabler_create_matching_syscall_table_events(&event_notifier_enabler->parent, - sc_exit_table.table, sc_exit_table.len, SC_TYPE_EXIT); - lttng_syscall_event_enabler_create_matching_syscall_table_events(&event_notifier_enabler->parent, - compat_sc_exit_table.table, compat_sc_exit_table.len, SC_TYPE_COMPAT_EXIT); - create_unknown_syscall_event(event_enabler, SC_TYPE_EXIT); - create_unknown_syscall_event(event_enabler, SC_TYPE_COMPAT_EXIT); - } - return ret; + return 0; } int lttng_syscalls_unregister_syscall_table(struct lttng_kernel_syscall_table *syscall_table) @@ -915,52 +878,6 @@ int lttng_syscalls_destroy_syscall_table(struct lttng_kernel_syscall_table *sysc return 0; } -static -int get_syscall_nr(const char *syscall_name) -{ - int syscall_nr = -1; - int i; - - for (i = 0; i < sc_table.len; i++) { - const struct trace_syscall_entry *entry; - const char *it_name; - - entry = &sc_table.table[i]; - if (!entry->desc) - continue; - it_name = entry->desc->event_name; - it_name += strlen(SYSCALL_ENTRY_STR); - if (!strcmp(syscall_name, it_name)) { - syscall_nr = i; - break; - } - } - return syscall_nr; -} - -static -int get_compat_syscall_nr(const char *syscall_name) -{ - int syscall_nr = -1; - int i; - - for (i = 0; i < compat_sc_table.len; i++) { - const struct trace_syscall_entry *entry; - const char *it_name; - - entry = &compat_sc_table.table[i]; - if (!entry->desc) - continue; - it_name = entry->desc->event_name; - it_name += strlen(COMPAT_SYSCALL_ENTRY_STR); - if (!strcmp(syscall_name, it_name)) { - syscall_nr = i; - break; - } - } - return syscall_nr; -} - static uint32_t get_sc_tables_len(void) { @@ -1005,35 +922,25 @@ static int lttng_syscall_filter_enable( struct lttng_syscall_filter *filter, const char *desc_name, enum lttng_syscall_abi abi, - enum lttng_syscall_entryexit entryexit) + enum lttng_syscall_entryexit entryexit, + unsigned int syscall_id) { const char *syscall_name; unsigned long *bitmap; - int syscall_nr; + u32 *refcount_map; syscall_name = get_syscall_name(desc_name, abi, entryexit); - switch (abi) { - case LTTNG_SYSCALL_ABI_NATIVE: - syscall_nr = get_syscall_nr(syscall_name); - break; - case LTTNG_SYSCALL_ABI_COMPAT: - syscall_nr = get_compat_syscall_nr(syscall_name); - break; - default: - return -EINVAL; - } - if (syscall_nr < 0) - return -ENOENT; - switch (entryexit) { case LTTNG_SYSCALL_ENTRY: switch (abi) { case LTTNG_SYSCALL_ABI_NATIVE: bitmap = filter->sc_entry; + refcount_map = filter->sc_entry_refcount_map; break; case LTTNG_SYSCALL_ABI_COMPAT: bitmap = filter->sc_compat_entry; + refcount_map = filter->sc_compat_entry_refcount_map; break; default: return -EINVAL; @@ -1043,9 +950,11 @@ int lttng_syscall_filter_enable( switch (abi) { case LTTNG_SYSCALL_ABI_NATIVE: bitmap = filter->sc_exit; + refcount_map = filter->sc_exit_refcount_map; break; case LTTNG_SYSCALL_ABI_COMPAT: bitmap = filter->sc_compat_exit; + refcount_map = filter->sc_compat_exit_refcount_map; break; default: return -EINVAL; @@ -1054,9 +963,10 @@ int lttng_syscall_filter_enable( default: return -EINVAL; } - if (test_bit(syscall_nr, bitmap)) - return -EEXIST; - bitmap_set(bitmap, syscall_nr, 1); + if (refcount_map[syscall_id] == U32_MAX) + return -EOVERFLOW; + if (refcount_map[syscall_id]++ == 0) + bitmap_set(bitmap, syscall_id, 1); return 0; } @@ -1065,46 +975,81 @@ int lttng_syscall_filter_enable_event(struct lttng_kernel_event_common *event) struct lttng_kernel_syscall_table *syscall_table = get_syscall_table_from_event(event); unsigned int syscall_id = event->priv->u.syscall.syscall_id; struct hlist_head *dispatch_list; - int ret; + int ret = 0; WARN_ON_ONCE(event->priv->instrumentation != LTTNG_KERNEL_ABI_SYSCALL); - ret = lttng_syscall_filter_enable(syscall_table->sc_filter, - event->priv->desc->event_name, event->priv->u.syscall.abi, - event->priv->u.syscall.entryexit); - if (ret) - return ret; - - switch (event->priv->u.syscall.entryexit) { - case LTTNG_SYSCALL_ENTRY: - switch (event->priv->u.syscall.abi) { - case LTTNG_SYSCALL_ABI_NATIVE: - dispatch_list = &syscall_table->syscall_dispatch[syscall_id]; + /* Unknown syscall */ + if (syscall_id == -1U) { + switch (event->priv->u.syscall.entryexit) { + case LTTNG_SYSCALL_ENTRY: + switch (event->priv->u.syscall.abi) { + case LTTNG_SYSCALL_ABI_NATIVE: + dispatch_list = &syscall_table->unknown_syscall_dispatch; + break; + case LTTNG_SYSCALL_ABI_COMPAT: + dispatch_list = &syscall_table->compat_unknown_syscall_dispatch; + break; + default: + ret = -EINVAL; + goto end; + } break; - case LTTNG_SYSCALL_ABI_COMPAT: - dispatch_list = &syscall_table->compat_syscall_dispatch[syscall_id]; + case LTTNG_SYSCALL_EXIT: + switch (event->priv->u.syscall.abi) { + case LTTNG_SYSCALL_ABI_NATIVE: + dispatch_list = &syscall_table->unknown_syscall_exit_dispatch; + break; + case LTTNG_SYSCALL_ABI_COMPAT: + dispatch_list = &syscall_table->compat_unknown_syscall_exit_dispatch; + break; + default: + ret = -EINVAL; + goto end; + } break; default: ret = -EINVAL; goto end; } - break; - case LTTNG_SYSCALL_EXIT: - switch (event->priv->u.syscall.abi) { - case LTTNG_SYSCALL_ABI_NATIVE: - dispatch_list = &syscall_table->syscall_exit_dispatch[syscall_id]; + } else { + ret = lttng_syscall_filter_enable(syscall_table->sc_filter, + event->priv->desc->event_name, event->priv->u.syscall.abi, + event->priv->u.syscall.entryexit, syscall_id); + if (ret) + return ret; + + switch (event->priv->u.syscall.entryexit) { + case LTTNG_SYSCALL_ENTRY: + switch (event->priv->u.syscall.abi) { + case LTTNG_SYSCALL_ABI_NATIVE: + dispatch_list = &syscall_table->syscall_dispatch[syscall_id]; + break; + case LTTNG_SYSCALL_ABI_COMPAT: + dispatch_list = &syscall_table->compat_syscall_dispatch[syscall_id]; + break; + default: + ret = -EINVAL; + goto end; + } break; - case LTTNG_SYSCALL_ABI_COMPAT: - dispatch_list = &syscall_table->compat_syscall_exit_dispatch[syscall_id]; + case LTTNG_SYSCALL_EXIT: + switch (event->priv->u.syscall.abi) { + case LTTNG_SYSCALL_ABI_NATIVE: + dispatch_list = &syscall_table->syscall_exit_dispatch[syscall_id]; + break; + case LTTNG_SYSCALL_ABI_COMPAT: + dispatch_list = &syscall_table->compat_syscall_exit_dispatch[syscall_id]; + break; + default: + ret = -EINVAL; + goto end; + } break; default: ret = -EINVAL; goto end; } - break; - default: - ret = -EINVAL; - goto end; } hlist_add_head_rcu(&event->priv->u.syscall.node, dispatch_list); @@ -1115,35 +1060,25 @@ end: static int lttng_syscall_filter_disable(struct lttng_syscall_filter *filter, const char *desc_name, enum lttng_syscall_abi abi, - enum lttng_syscall_entryexit entryexit) + enum lttng_syscall_entryexit entryexit, + unsigned int syscall_id) { const char *syscall_name; unsigned long *bitmap; - int syscall_nr; + u32 *refcount_map; syscall_name = get_syscall_name(desc_name, abi, entryexit); - switch (abi) { - case LTTNG_SYSCALL_ABI_NATIVE: - syscall_nr = get_syscall_nr(syscall_name); - break; - case LTTNG_SYSCALL_ABI_COMPAT: - syscall_nr = get_compat_syscall_nr(syscall_name); - break; - default: - return -EINVAL; - } - if (syscall_nr < 0) - return -ENOENT; - switch (entryexit) { case LTTNG_SYSCALL_ENTRY: switch (abi) { case LTTNG_SYSCALL_ABI_NATIVE: bitmap = filter->sc_entry; + refcount_map = filter->sc_entry_refcount_map; break; case LTTNG_SYSCALL_ABI_COMPAT: bitmap = filter->sc_compat_entry; + refcount_map = filter->sc_compat_entry_refcount_map; break; default: return -EINVAL; @@ -1153,9 +1088,11 @@ int lttng_syscall_filter_disable(struct lttng_syscall_filter *filter, switch (abi) { case LTTNG_SYSCALL_ABI_NATIVE: bitmap = filter->sc_exit; + refcount_map = filter->sc_exit_refcount_map; break; case LTTNG_SYSCALL_ABI_COMPAT: bitmap = filter->sc_compat_exit; + refcount_map = filter->sc_compat_exit_refcount_map; break; default: return -EINVAL; @@ -1164,23 +1101,27 @@ int lttng_syscall_filter_disable(struct lttng_syscall_filter *filter, default: return -EINVAL; } - if (!test_bit(syscall_nr, bitmap)) - return -EEXIST; - bitmap_clear(bitmap, syscall_nr, 1); - + if (refcount_map[syscall_id] == 0) + return -ENOENT; + if (--refcount_map[syscall_id] == 0) + bitmap_clear(bitmap, syscall_id, 1); return 0; } int lttng_syscall_filter_disable_event(struct lttng_kernel_event_common *event) { struct lttng_kernel_syscall_table *syscall_table = get_syscall_table_from_event(event); + unsigned int syscall_id = event->priv->u.syscall.syscall_id; int ret; - ret = lttng_syscall_filter_disable(syscall_table->sc_filter, - event->priv->desc->event_name, event->priv->u.syscall.abi, - event->priv->u.syscall.entryexit); - if (ret) - return ret; + /* Except for unknown syscall */ + if (syscall_id != -1U) { + ret = lttng_syscall_filter_disable(syscall_table->sc_filter, + event->priv->desc->event_name, event->priv->u.syscall.abi, + event->priv->u.syscall.entryexit, syscall_id); + if (ret) + return ret; + } hlist_del_rcu(&event->priv->u.syscall.node); return 0; }