kprobes: support respawn probes for module probing
RFC PATCH 8/9 kprobes: support respawn probes for module probing
Add module_*probe API's to respawn probes on kernel modules. kprobes which have been registered through register_module_*probe are activated when the target module is loaded, and deactivated when unloading. register_module_*probe require an activate_handler which is called right before activating the probe, and if it returns !0, kprobes will be activated.
Thus, users can check whether the target module is true target or not (e.g. checking build-id) in activate_handler.
--- include/linux/kprobes.h | 39 ++++++++ kernel/kprobes.c | 250 +++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 289 insertions(+), 0 deletions(-)
include/linux/kprobes.h +39 -0
@@ -37,6 +37,7 @@#include <linux/spinlock.h> #include <linux/rcupdate.h> #include <linux/mutex.h> +#include <linux/module.h> #ifdef CONFIG_KPROBES #include <asm/kprobes.h>
@@ -69,6 +70,7 @@ typedef int (*kprobe_fault_handler_t) (struct kprobe *, struct pt_regs *, int trapnr);typedef int (*kretprobe_handler_t ) (struct kretprobe_instance *,struct pt_regs *); +typedef int (*probe_activate_handler_t )(void *,struct module *);struct kprobe {struct hlist_node hlist;
@@ -279,6 +281,16 @@ void unregister_kretprobes(struct kretprobe **rps, int num);void kprobe_flush_task (struct task_struct *tk);void recycle_rp_inst (struct kretprobe_instance *ri,struct hlist_head *head); +int register_module_kprobe (struct kprobe *kp, +probe_activate_handler_t handler,void *data); +int register_module_kretprobe (struct kretprobe *rp, +probe_activate_handler_t handler,void *data); +int register_module_jprobe (struct jprobe *jp, +probe_activate_handler_t handler,void *data); +void unregister_module_kprobe (struct kprobe *kp); +void unregister_module_kretprobe (struct kretprobe *rp); +void unregister_module_jprobe (struct jprobe *jp); +#else /* !CONFIG_KPROBES: */ static inline int kprobes_built_in (void )
@@ -345,5 +357,32 @@ static inline void unregister_kretprobes(struct kretprobe **rps, int num)static inline void kprobe_flush_task (struct task_struct *tk) { } +static inline int register_module_kprobe (struct kprobe *kp, +probe_activate_handler_t handler, +void *data) +{ +return -ENOSYS ; +} +static inline int register_module_kretprobe (struct kretprobe *rp, +probe_activate_handler_t handler, +void *data) +{ +return -ENOSYS ; +} +static inline int register_module_jprobe (struct jprobe *jp, +probe_activate_handler_t handler, +void *data) +{ +return -ENOSYS ; +} +void unregister_module_kprobe (struct kprobe *kp) +{ +} +void unregister_module_kretprobe (struct kretprobe *rp) +{ +} +void unregister_module_jprobe (struct jprobe *jp) +{ +}#endif /* CONFIG_KPROBES */ #endif /* _LINUX_KPROBES_H */
kernel/kprobes.c +250 -0
256 lines not on this page · raw message
Signature · 7 lines
Masami Hiramatsu Software Engineer Hitachi Computer Products (America) Inc. Software Solutions Division e-mail: [email protected]
Quoted 29 lines · Masami Hiramatsu
Add module_*probe API's to respawn probes on kernel modules. kprobes which have been registered through register_module_*probe are activated when the target module is loaded, and deactivated when unloading. register_module_*probe require an
activate_handlerwhich is called right before activating the probe, and if it returns !0, kprobes will be activated.Thus, users can check whether the target module is true target or not (e.g. checking build-id) in
activate_handler.Signed-off-by Masami Hiramatsu <[email protected]>Cc Ananth N Mavinakayanahalli <[email protected]>--- include/linux/kprobes.h | 39 ++++++++ kernel/kprobes.c | 250 +++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 289 insertions(+), 0 deletions(-)include/linux/kprobes.h +1
-0@@ -37,6 +37,7 @@#include <linux/spinlock.h> #include <linux/rcupdate.h> #include <linux/mutex.h> +#include <linux/module.h> #ifdef CONFIG_KPROBES #include <asm/kprobes.h>
include/linux/kprobes.h typedef int (*kprobe_fault_handler_t) (struct kprobe *, struct pt_regs *, · line 73
Quoted 4 lines
include/linux/kprobes.h +1
-0@@ -69,6 +70,7 @@ typedef int (*kprobe_fault_handler_t) (struct kprobe *, struct pt_regs *, int trapnr);typedef int (*kretprobe_handler_t ) (struct kretprobe_instance *,struct pt_regs *); +typedef int (*probe_activate_handler_t )(void *,struct module *);
I guess it could also be useful to call the handler when the module is unloaded. Be using another parameter with a LOAD/UNLOAD enum value.
Quoted 41 lines
include/linux/kprobes.h +27
-0struct kprobe {struct hlist_node hlist;@@ -279,6 +281,16 @@ void unregister_kretprobes(struct kretprobe **rps, int num);void kprobe_flush_task (struct task_struct *tk);void recycle_rp_inst (struct kretprobe_instance *ri,struct hlist_head *head); +int register_module_kprobe (struct kprobe *kp, +probe_activate_handler_t handler,void *data); +int register_module_kretprobe (struct kretprobe *rp, +probe_activate_handler_t handler,void *data); +int register_module_jprobe (struct jprobe *jp, +probe_activate_handler_t handler,void *data); +void unregister_module_kprobe (struct kprobe *kp); +void unregister_module_kretprobe (struct kretprobe *rp); +void unregister_module_jprobe (struct jprobe *jp); +#else /* !CONFIG_KPROBES: */ static inline int kprobes_built_in (void )@@ -345,5 +357,32 @@ static inline void unregister_kretprobes(struct kretprobe **rps, int num)static inline void kprobe_flush_task (struct task_struct *tk) { } +static inline int register_module_kprobe (struct kprobe *kp, +probe_activate_handler_t handler, +void *data) +{ +return -ENOSYS ; +} +static inline int register_module_kretprobe (struct kretprobe *rp, +probe_activate_handler_t handler, +void *data) +{ +return -ENOSYS ; +} +static inline int register_module_jprobe (struct jprobe *jp, +probe_activate_handler_t handler, +void *data) +{ +return -ENOSYS ;
include/linux/kprobes.h static inline void unregister_kretprobes(struct kretprobe **rps, int num) · line 386
Quoted 10 lines
include/linux/kprobes.h +10
-0+} +void unregister_module_kprobe (struct kprobe *kp) +{ +} +void unregister_module_kretprobe (struct kretprobe *rp) +{ +} +void unregister_module_jprobe (struct jprobe *jp) +{ +}
Shouldn't the unregister_* be inlined too?
I think they all could be static inlined too in case of !CONFIG_MODULE
Quoted 20 lines
include/linux/kprobes.h +0
-0#endif /* CONFIG_KPROBES */ #endif /* _LINUX_KPROBES_H */ kernel/kprobes.c +10
-0@@ -1416,6 +1416,256 @@ static int __kprobes debugfs_kprobe_init(void)late_initcall (debugfs_kprobe_init);#endif /* CONFIG_DEBUG_FS */ +/* Kprobes module respawn support */ +enum probe_type { +PROBE_TYPE_KPROBE , +PROBE_TYPE_KRETPROBE , +PROBE_TYPE_JPROBE , +}; + +struct module_probe_client { +struct list_head list; +const char *module;/* including symbol name */
kernel/kprobes.c static int __kprobes debugfs_kprobe_init(void) · line 1438
Quoted 10 lines
kernel/kprobes.c +10
-0+int active; +void *data; +probe_activate_handler_t handler; +enum probe_type type; +union { +struct kprobe *kp; +struct kretprobe *rp; +struct jprobe *jp; + }; +};
#ifdef CONFIG_MODULE ?
Frederic.
Quoted 247 lines
kernel/kprobes.c +229
-0+static DEFINE_MUTEX (module_probe_mutex); +static LIST_HEAD (module_probe_list); + +static int activate_module_probe (struct module_probe_client *pc) +{ +int ret =0 ; +if (pc->active) +return 0 ; +switch (pc->type) { +case PROBE_TYPE_KPROBE : + ret =register_kprobe (pc->kp); +break ; +case PROBE_TYPE_KRETPROBE : + ret =register_kretprobe (pc->rp); +break ; +case PROBE_TYPE_JPROBE : + ret =register_jprobe (pc->jp); +break ; +default : +WARN_ON (1 ); +break ; + } +if (!ret) + pc->active =1 ; +return ret; +} + +static void deactivate_module_probe (struct module_probe_client *pc) +{ +if (!pc->active) +return ; +switch (pc->type) { +case PROBE_TYPE_KPROBE : +unregister_kprobe (pc->kp); +break ; +case PROBE_TYPE_KRETPROBE : +unregister_kretprobe (pc->rp); +break ; +case PROBE_TYPE_JPROBE : +unregister_jprobe (pc->jp); +break ; +default : +WARN_ON (1 ); +break ; + } + pc->active =0 ; +} + +static const char *probed_module_name (struct kprobe *kp) +{ +if ((kp->symbol_name) &&strchr (kp->symbol_name,':' )) +return kp->symbol_name; +return NULL ; +} + +static int module_is_exist (const char *module) +{ +char buf[MODULE_NAME_LEN +8 ]; +snprintf (buf,MODULE_NAME_LEN +8 ,"%s:__stext" , module); +return module_kallsyms_lookup_name (buf) ?1 :0 ; +} + +static int add_module_probe (const char *module,void *p,enum probe_type type, +probe_activate_handler_t handler,void *data) +{ +struct module_probe_client *pc; +int ret =0 ; + +if (!handler) +return -EINVAL ; + + pc =kzalloc (sizeof (struct module_probe_client ),GFP_KERNEL ); + pc->kp = p; + pc->type = type; + pc->module = module; + pc->handler = handler; + pc->data = data; +INIT_LIST_HEAD (&pc->list); + +mutex_lock (&module_probe_mutex); +if (module_is_exist (module)) + ret =activate_module_probe (pc); +if (ret) +kfree (pc); +else +list_add_tail (&pc->list, &module_probe_list); +mutex_unlock (&module_probe_mutex); +return ret; +} + +static void __del_module_probe (struct module_probe_client *pc) +{ +list_del (&pc->list); +deactivate_module_probe (pc); +kfree (pc); +} + +static int del_module_probe (void *p) +{ +struct module_probe_client *pc; +int ret; + +mutex_lock (&module_probe_mutex); +list_for_each_entry (pc, &module_probe_list, list) +if (pc->kp == p) { +/* don't need safe loop, we exit soon */ +__del_module_probe (pc); + goto found; + } + ret = -ENOENT ; +found: +mutex_unlock (&module_probe_mutex); +return ret; +} + +int __kprobes +register_module_kprobe (struct kprobe *kp, +probe_activate_handler_t handler,void *data) +{ +const char *module; + module =probed_module_name (kp); +if (!module) +return register_kprobe (kp); +return add_module_probe (module, kp,PROBE_TYPE_KPROBE , + handler, data); +} +EXPORT_SYMBOL_GPL (register_module_kprobe); + +int __kprobes +register_module_kretprobe (struct kretprobe *rp, +probe_activate_handler_t handler,void *data) +{ +const char *module; + module =probed_module_name (&rp->kp); +if (!module) +return register_kretprobe (rp); +return add_module_probe (module, rp,PROBE_TYPE_KRETPROBE , + handler, data); +} +EXPORT_SYMBOL_GPL (register_module_kretprobe); + +int __kprobes +register_module_jprobe (struct jprobe *jp, +probe_activate_handler_t handler,void *data) +{ +const char *module; + module =probed_module_name (&jp->kp); +if (!module) +return register_jprobe (jp); +return add_module_probe (module, jp,PROBE_TYPE_JPROBE , + handler, data); +} +EXPORT_SYMBOL_GPL (register_module_jprobe); + +void __kprobes unregister_module_kprobe (struct kprobe *kp) +{ +const char *module; + module =probed_module_name (kp); +if (!module) +unregister_kprobe (kp); +else +del_module_probe (kp); +} +EXPORT_SYMBOL_GPL (unregister_module_kprobe); + +void __kprobes unregister_module_kretprobe (struct kretprobe *rp) +{ +const char *module; + module =probed_module_name (&rp->kp); +if (!module) +unregister_kretprobe (rp); +else +del_module_probe (rp); +} +EXPORT_SYMBOL_GPL (unregister_module_kretprobe); + +void __kprobes unregister_module_jprobe (struct jprobe *jp) +{ +const char *module; + module =probed_module_name (&jp->kp); +if (!module) +unregister_jprobe (jp); +else +del_module_probe (jp); +} +EXPORT_SYMBOL_GPL (unregister_module_jprobe); + +static int module_is_probed (const char *mod,const char *sym) +{ +int len =strlen (mod); +return strncmp (mod, sym, len) ==0 && sym[len] ==':' ; +} + +static int module_probe_callback (struct notifier_block *nb, +unsigned long state,void *module) +{ +struct module_probe_client *pc; +struct module *mod = module; +if (state ==MODULE_STATE_LIVE ) +return NOTIFY_DONE ; + +mutex_lock (&module_probe_mutex); +list_for_each_entry (pc, &module_probe_list, list) { +if (!module_is_probed (mod->name, pc->module)) +continue ; +if (state ==MODULE_STATE_COMING && + pc->handler (pc->data, module)) { +activate_module_probe (pc); + }else if (state ==MODULE_STATE_GOING ) +deactivate_module_probe (pc); + } +mutex_unlock (&module_probe_mutex); +return NOTIFY_DONE ; +} + +struct notifier_block module_probe_nb = { + .notifier_call = module_probe_callback +}; + +static int __init init_module_probes (void ) +{ +int ret; + ret =register_module_notifier (&module_probe_nb); +if (ret) +pr_warning ("Failed to register module notifier\n" ); +return ret; +} +module_init (init_module_probes); +module_init (init_kprobes);EXPORT_SYMBOL_GPL (register_kprobe);Signature · 14 lines
Masami Hiramatsu Software Engineer Hitachi Computer Products (America) Inc. Software Solutions Division e-mail: [email protected] -- To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html Please read the FAQ at http://www.tux.org/lkml/
Quoted 312 lines · Masami Hiramatsu
Add module_*probe API's to respawn probes on kernel modules. kprobes which have been registered through register_module_*probe are activated when the target module is loaded, and deactivated when unloading. register_module_*probe require an
activate_handlerwhich is called right before activating the probe, and if it returns !0, kprobes will be activated.Thus, users can check whether the target module is true target or not (e.g. checking build-id) in
activate_handler.Signed-off-by Masami Hiramatsu <[email protected]>Cc Ananth N Mavinakayanahalli <[email protected]>--- include/linux/kprobes.h | 39 ++++++++ kernel/kprobes.c | 250 +++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 289 insertions(+), 0 deletions(-)include/linux/kprobes.h +39
-0@@ -37,6 +37,7 @@#include <linux/spinlock.h> #include <linux/rcupdate.h> #include <linux/mutex.h> +#include <linux/module.h> #ifdef CONFIG_KPROBES #include <asm/kprobes.h> @@ -69,6 +70,7 @@ typedef int (*kprobe_fault_handler_t) (struct kprobe *, struct pt_regs *, int trapnr);typedef int (*kretprobe_handler_t ) (struct kretprobe_instance *,struct pt_regs *); +typedef int (*probe_activate_handler_t )(void *,struct module *);struct kprobe {struct hlist_node hlist;@@ -279,6 +281,16 @@ void unregister_kretprobes(struct kretprobe **rps, int num);void kprobe_flush_task (struct task_struct *tk);void recycle_rp_inst (struct kretprobe_instance *ri,struct hlist_head *head); +int register_module_kprobe (struct kprobe *kp, +probe_activate_handler_t handler,void *data); +int register_module_kretprobe (struct kretprobe *rp, +probe_activate_handler_t handler,void *data); +int register_module_jprobe (struct jprobe *jp, +probe_activate_handler_t handler,void *data); +void unregister_module_kprobe (struct kprobe *kp); +void unregister_module_kretprobe (struct kretprobe *rp); +void unregister_module_jprobe (struct jprobe *jp); +#else /* !CONFIG_KPROBES: */ static inline int kprobes_built_in (void )@@ -345,5 +357,32 @@ static inline void unregister_kretprobes(struct kretprobe **rps, int num)static inline void kprobe_flush_task (struct task_struct *tk) { } +static inline int register_module_kprobe (struct kprobe *kp, +probe_activate_handler_t handler, +void *data) +{ +return -ENOSYS ; +} +static inline int register_module_kretprobe (struct kretprobe *rp, +probe_activate_handler_t handler, +void *data) +{ +return -ENOSYS ; +} +static inline int register_module_jprobe (struct jprobe *jp, +probe_activate_handler_t handler, +void *data) +{ +return -ENOSYS ; +} +void unregister_module_kprobe (struct kprobe *kp) +{ +} +void unregister_module_kretprobe (struct kretprobe *rp) +{ +} +void unregister_module_jprobe (struct jprobe *jp) +{ +}#endif /* CONFIG_KPROBES */ #endif /* _LINUX_KPROBES_H */ kernel/kprobes.c +218
-0@@ -1416,6 +1416,256 @@ static int __kprobes debugfs_kprobe_init(void)late_initcall (debugfs_kprobe_init);#endif /* CONFIG_DEBUG_FS */ +/* Kprobes module respawn support */ +enum probe_type { +PROBE_TYPE_KPROBE , +PROBE_TYPE_KRETPROBE , +PROBE_TYPE_JPROBE , +}; + +struct module_probe_client { +struct list_head list; +const char *module;/* including symbol name */ +int active; +void *data; +probe_activate_handler_t handler; +enum probe_type type; +union { +struct kprobe *kp; +struct kretprobe *rp; +struct jprobe *jp; + }; +}; + +static DEFINE_MUTEX (module_probe_mutex); +static LIST_HEAD (module_probe_list); + +static int activate_module_probe (struct module_probe_client *pc) +{ +int ret =0 ; +if (pc->active) +return 0 ; +switch (pc->type) { +case PROBE_TYPE_KPROBE : + ret =register_kprobe (pc->kp); +break ; +case PROBE_TYPE_KRETPROBE : + ret =register_kretprobe (pc->rp); +break ; +case PROBE_TYPE_JPROBE : + ret =register_jprobe (pc->jp); +break ; +default : +WARN_ON (1 ); +break ; + } +if (!ret) + pc->active =1 ; +return ret; +} + +static void deactivate_module_probe (struct module_probe_client *pc) +{ +if (!pc->active) +return ; +switch (pc->type) { +case PROBE_TYPE_KPROBE : +unregister_kprobe (pc->kp); +break ; +case PROBE_TYPE_KRETPROBE : +unregister_kretprobe (pc->rp); +break ; +case PROBE_TYPE_JPROBE : +unregister_jprobe (pc->jp); +break ; +default : +WARN_ON (1 ); +break ; + } + pc->active =0 ; +} + +static const char *probed_module_name (struct kprobe *kp) +{ +if ((kp->symbol_name) &&strchr (kp->symbol_name,':' )) +return kp->symbol_name; +return NULL ; +} + +static int module_is_exist (const char *module) +{ +char buf[MODULE_NAME_LEN +8 ]; +snprintf (buf,MODULE_NAME_LEN +8 ,"%s:__stext" , module); +return module_kallsyms_lookup_name (buf) ?1 :0 ; +} + +static int add_module_probe (const char *module,void *p,enum probe_type type, +probe_activate_handler_t handler,void *data) +{ +struct module_probe_client *pc; +int ret =0 ; + +if (!handler) +return -EINVAL ; + + pc =kzalloc (sizeof (struct module_probe_client ),GFP_KERNEL ); + pc->kp = p; + pc->type = type; + pc->module = module; + pc->handler = handler; + pc->data = data; +INIT_LIST_HEAD (&pc->list); + +mutex_lock (&module_probe_mutex); +if (module_is_exist (module)) + ret =activate_module_probe (pc); +if (ret) +kfree (pc); +else +list_add_tail (&pc->list, &module_probe_list); +mutex_unlock (&module_probe_mutex); +return ret; +} + +static void __del_module_probe (struct module_probe_client *pc) +{ +list_del (&pc->list); +deactivate_module_probe (pc); +kfree (pc); +} + +static int del_module_probe (void *p) +{ +struct module_probe_client *pc; +int ret; + +mutex_lock (&module_probe_mutex); +list_for_each_entry (pc, &module_probe_list, list) +if (pc->kp == p) { +/* don't need safe loop, we exit soon */ +__del_module_probe (pc); + goto found; + } + ret = -ENOENT ; +found: +mutex_unlock (&module_probe_mutex); +return ret; +} + +int __kprobes +register_module_kprobe (struct kprobe *kp, +probe_activate_handler_t handler,void *data) +{ +const char *module; + module =probed_module_name (kp); +if (!module) +return register_kprobe (kp); +return add_module_probe (module, kp,PROBE_TYPE_KPROBE , + handler, data); +} +EXPORT_SYMBOL_GPL (register_module_kprobe); + +int __kprobes +register_module_kretprobe (struct kretprobe *rp, +probe_activate_handler_t handler,void *data) +{ +const char *module; + module =probed_module_name (&rp->kp); +if (!module) +return register_kretprobe (rp); +return add_module_probe (module, rp,PROBE_TYPE_KRETPROBE , + handler, data); +} +EXPORT_SYMBOL_GPL (register_module_kretprobe); + +int __kprobes +register_module_jprobe (struct jprobe *jp, +probe_activate_handler_t handler,void *data) +{ +const char *module; + module =probed_module_name (&jp->kp); +if (!module) +return register_jprobe (jp); +return add_module_probe (module, jp,PROBE_TYPE_JPROBE , + handler, data); +} +EXPORT_SYMBOL_GPL (register_module_jprobe); + +void __kprobes unregister_module_kprobe (struct kprobe *kp) +{ +const char *module; + module =probed_module_name (kp); +if (!module) +unregister_kprobe (kp); +else +del_module_probe (kp); +} +EXPORT_SYMBOL_GPL (unregister_module_kprobe); + +void __kprobes unregister_module_kretprobe (struct kretprobe *rp) +{ +const char *module; + module =probed_module_name (&rp->kp); +if (!module) +unregister_kretprobe (rp); +else +del_module_probe (rp); +} +EXPORT_SYMBOL_GPL (unregister_module_kretprobe); + +void __kprobes unregister_module_jprobe (struct jprobe *jp) +{ +const char *module; + module =probed_module_name (&jp->kp); +if (!module) +unregister_jprobe (jp); +else +del_module_probe (jp); +} +EXPORT_SYMBOL_GPL (unregister_module_jprobe); + +static int module_is_probed (const char *mod,const char *sym) +{ +int len =strlen (mod); +return strncmp (mod, sym, len) ==0 && sym[len] ==':' ; +} + +static int module_probe_callback (struct notifier_block *nb, +unsigned long state,void *module) +{ +struct module_probe_client *pc;
kernel/kprobes.c static int __kprobes debugfs_kprobe_init(void) · line 1646
Quoted 10 lines
kernel/kprobes.c +10
-0+struct module *mod = module; +if (state ==MODULE_STATE_LIVE ) +return NOTIFY_DONE ; + +mutex_lock (&module_probe_mutex); +list_for_each_entry (pc, &module_probe_list, list) { +if (!module_is_probed (mod->name, pc->module)) +continue ; +if (state ==MODULE_STATE_COMING && + pc->handler (pc->data, module)) {
I don't see a place where you check if pc->handler != NULL May be you could attach a stub in such cases.
Frederic.
Quoted 40 lines
kernel/kprobes.c +22
-0+activate_module_probe (pc); + }else if (state ==MODULE_STATE_GOING ) +deactivate_module_probe (pc); + } +mutex_unlock (&module_probe_mutex); +return NOTIFY_DONE ; +} + +struct notifier_block module_probe_nb = { + .notifier_call = module_probe_callback +}; + +static int __init init_module_probes (void ) +{ +int ret; + ret =register_module_notifier (&module_probe_nb); +if (ret) +pr_warning ("Failed to register module notifier\n" ); +return ret; +} +module_init (init_module_probes); +module_init (init_kprobes);EXPORT_SYMBOL_GPL (register_kprobe);Signature · 14 lines
Masami Hiramatsu Software Engineer Hitachi Computer Products (America) Inc. Software Solutions Division e-mail: [email protected] -- To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html Please read the FAQ at http://www.tux.org/lkml/
Quoted 232 lines · Frederic Weisbecker
Quoted 232 lines
kernel/kprobes.c +224
-0@@ -1416,6 +1416,256 @@ static int __kprobes debugfs_kprobe_init(void)late_initcall (debugfs_kprobe_init);#endif /* CONFIG_DEBUG_FS */ +/* Kprobes module respawn support */ +enum probe_type { +PROBE_TYPE_KPROBE , +PROBE_TYPE_KRETPROBE , +PROBE_TYPE_JPROBE , +}; + +struct module_probe_client { +struct list_head list; +const char *module;/* including symbol name */ +int active; +void *data; +probe_activate_handler_t handler; +enum probe_type type; +union { +struct kprobe *kp; +struct kretprobe *rp; +struct jprobe *jp; + }; +}; + +static DEFINE_MUTEX (module_probe_mutex); +static LIST_HEAD (module_probe_list); + +static int activate_module_probe (struct module_probe_client *pc) +{ +int ret =0 ; +if (pc->active) +return 0 ; +switch (pc->type) { +case PROBE_TYPE_KPROBE : + ret =register_kprobe (pc->kp); +break ; +case PROBE_TYPE_KRETPROBE : + ret =register_kretprobe (pc->rp); +break ; +case PROBE_TYPE_JPROBE : + ret =register_jprobe (pc->jp); +break ; +default : +WARN_ON (1 ); +break ; + } +if (!ret) + pc->active =1 ; +return ret; +} + +static void deactivate_module_probe (struct module_probe_client *pc) +{ +if (!pc->active) +return ; +switch (pc->type) { +case PROBE_TYPE_KPROBE : +unregister_kprobe (pc->kp); +break ; +case PROBE_TYPE_KRETPROBE : +unregister_kretprobe (pc->rp); +break ; +case PROBE_TYPE_JPROBE : +unregister_jprobe (pc->jp); +break ; +default : +WARN_ON (1 ); +break ; + } + pc->active =0 ; +} + +static const char *probed_module_name (struct kprobe *kp) +{ +if ((kp->symbol_name) &&strchr (kp->symbol_name,':' )) +return kp->symbol_name; +return NULL ; +} + +static int module_is_exist (const char *module) +{ +char buf[MODULE_NAME_LEN +8 ]; +snprintf (buf,MODULE_NAME_LEN +8 ,"%s:__stext" , module); +return module_kallsyms_lookup_name (buf) ?1 :0 ; +} + +static int add_module_probe (const char *module,void *p,enum probe_type type, +probe_activate_handler_t handler,void *data) +{ +struct module_probe_client *pc; +int ret =0 ; + +if (!handler) +return -EINVAL ; + + pc =kzalloc (sizeof (struct module_probe_client ),GFP_KERNEL ); + pc->kp = p; + pc->type = type; + pc->module = module; + pc->handler = handler; + pc->data = data; +INIT_LIST_HEAD (&pc->list); + +mutex_lock (&module_probe_mutex); +if (module_is_exist (module)) + ret =activate_module_probe (pc); +if (ret) +kfree (pc); +else +list_add_tail (&pc->list, &module_probe_list); +mutex_unlock (&module_probe_mutex); +return ret; +} + +static void __del_module_probe (struct module_probe_client *pc) +{ +list_del (&pc->list); +deactivate_module_probe (pc); +kfree (pc); +} + +static int del_module_probe (void *p) +{ +struct module_probe_client *pc; +int ret; + +mutex_lock (&module_probe_mutex); +list_for_each_entry (pc, &module_probe_list, list) +if (pc->kp == p) { +/* don't need safe loop, we exit soon */ +__del_module_probe (pc); + goto found; + } + ret = -ENOENT ; +found: +mutex_unlock (&module_probe_mutex); +return ret; +} + +int __kprobes +register_module_kprobe (struct kprobe *kp, +probe_activate_handler_t handler,void *data) +{ +const char *module; + module =probed_module_name (kp); +if (!module) +return register_kprobe (kp); +return add_module_probe (module, kp,PROBE_TYPE_KPROBE , + handler, data); +} +EXPORT_SYMBOL_GPL (register_module_kprobe); + +int __kprobes +register_module_kretprobe (struct kretprobe *rp, +probe_activate_handler_t handler,void *data) +{ +const char *module; + module =probed_module_name (&rp->kp); +if (!module) +return register_kretprobe (rp); +return add_module_probe (module, rp,PROBE_TYPE_KRETPROBE , + handler, data); +} +EXPORT_SYMBOL_GPL (register_module_kretprobe); + +int __kprobes +register_module_jprobe (struct jprobe *jp, +probe_activate_handler_t handler,void *data) +{ +const char *module; + module =probed_module_name (&jp->kp); +if (!module) +return register_jprobe (jp); +return add_module_probe (module, jp,PROBE_TYPE_JPROBE , + handler, data); +} +EXPORT_SYMBOL_GPL (register_module_jprobe); + +void __kprobes unregister_module_kprobe (struct kprobe *kp) +{ +const char *module; + module =probed_module_name (kp); +if (!module) +unregister_kprobe (kp); +else +del_module_probe (kp); +} +EXPORT_SYMBOL_GPL (unregister_module_kprobe); + +void __kprobes unregister_module_kretprobe (struct kretprobe *rp) +{ +const char *module; + module =probed_module_name (&rp->kp); +if (!module) +unregister_kretprobe (rp); +else +del_module_probe (rp); +} +EXPORT_SYMBOL_GPL (unregister_module_kretprobe); + +void __kprobes unregister_module_jprobe (struct jprobe *jp) +{ +const char *module; + module =probed_module_name (&jp->kp); +if (!module) +unregister_jprobe (jp); +else +del_module_probe (jp); +} +EXPORT_SYMBOL_GPL (unregister_module_jprobe); + +static int module_is_probed (const char *mod,const char *sym) +{ +int len =strlen (mod); +return strncmp (mod, sym, len) ==0 && sym[len] ==':' ; +} + +static int module_probe_callback (struct notifier_block *nb, +unsigned long state,void *module) +{ +struct module_probe_client *pc; +struct module *mod = module; +if (state ==MODULE_STATE_LIVE ) +return NOTIFY_DONE ; + +mutex_lock (&module_probe_mutex); +list_for_each_entry (pc, &module_probe_list, list) {
Quoted 8 lines
kernel/kprobes.c static int __kprobes debugfs_kprobe_init(void) · line 1646
Quoted 4 lines
kernel/kprobes.c +4
-0+if (!module_is_probed (mod->name, pc->module)) +continue ; +if (state ==MODULE_STATE_COMING && + pc->handler (pc->data, module)) {I don't see a place where you check if
pc->handler!= NULL May be you could attach a stub in such cases.
Please see add_module_probe(), handler == NULL case returns -EINVAL, and module_probe_list is internal list. So, pc->handler never be NULL.
Thank you,
Signature · 7 lines
Masami Hiramatsu Software Engineer Hitachi Computer Products (America) Inc. Software Solutions Division e-mail: [email protected]
Quoted 27 lines · Frederic Weisbecker
Quoted 26 lines · Masami Hiramatsu
Add module_*probe API's to respawn probes on kernel modules. kprobes which have been registered through register_module_*probe are activated when the target module is loaded, and deactivated when unloading. register_module_*probe require an
activate_handlerwhich is called right before activating the probe, and if it returns !0, kprobes will be activated.Thus, users can check whether the target module is true target or not (e.g. checking build-id) in
activate_handler.Signed-off-by Masami Hiramatsu <[email protected]>Cc Ananth N Mavinakayanahalli <[email protected]>--- include/linux/kprobes.h | 39 ++++++++ kernel/kprobes.c | 250 +++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 289 insertions(+), 0 deletions(-)include/linux/kprobes.h +1
-0@@ -37,6 +37,7 @@#include <linux/spinlock.h> #include <linux/rcupdate.h> #include <linux/mutex.h> +#include <linux/module.h>
Quoted 11 lines
include/linux/kprobes.h typedef int (*kprobe_fault_handler_t) (struct kprobe *, struct pt_regs *, · line 73
Quoted 7 lines
include/linux/kprobes.h +1
-0#ifdef CONFIG_KPROBES #include <asm/kprobes.h> @@ -69,6 +70,7 @@ typedef int (*kprobe_fault_handler_t) (struct kprobe *, struct pt_regs *, int trapnr);typedef int (*kretprobe_handler_t ) (struct kretprobe_instance *,struct pt_regs *); +typedef int (*probe_activate_handler_t )(void *,struct module *);I guess it could also be useful to call the handler when the module is unloaded. Be using another parameter with a LOAD/UNLOAD enum value.
Hmm, when unloading module, kprobes becomes "gone". So I think we don't need to check whether it can be deactivated or not when unloading.
Quoted 46 lines
Quoted 46 lines
include/linux/kprobes.h +33
-0struct kprobe {struct hlist_node hlist;@@ -279,6 +281,16 @@ void unregister_kretprobes(struct kretprobe **rps, int num);void kprobe_flush_task (struct task_struct *tk);void recycle_rp_inst (struct kretprobe_instance *ri,struct hlist_head *head); +int register_module_kprobe (struct kprobe *kp, +probe_activate_handler_t handler,void *data); +int register_module_kretprobe (struct kretprobe *rp, +probe_activate_handler_t handler,void *data); +int register_module_jprobe (struct jprobe *jp, +probe_activate_handler_t handler,void *data); +void unregister_module_kprobe (struct kprobe *kp); +void unregister_module_kretprobe (struct kretprobe *rp); +void unregister_module_jprobe (struct jprobe *jp); +#else /* !CONFIG_KPROBES: */ static inline int kprobes_built_in (void )@@ -345,5 +357,32 @@ static inline void unregister_kretprobes(struct kretprobe **rps, int num)static inline void kprobe_flush_task (struct task_struct *tk) { } +static inline int register_module_kprobe (struct kprobe *kp, +probe_activate_handler_t handler, +void *data) +{ +return -ENOSYS ; +} +static inline int register_module_kretprobe (struct kretprobe *rp, +probe_activate_handler_t handler, +void *data) +{ +return -ENOSYS ; +} +static inline int register_module_jprobe (struct jprobe *jp, +probe_activate_handler_t handler, +void *data) +{ +return -ENOSYS ; +} +void unregister_module_kprobe (struct kprobe *kp) +{ +} +void unregister_module_kretprobe (struct kretprobe *rp) +{
Quoted 8 lines
include/linux/kprobes.h static inline void unregister_kretprobes(struct kretprobe **rps, int num) · line 386
Quoted 4 lines
include/linux/kprobes.h +4
-0+} +void unregister_module_jprobe (struct jprobe *jp) +{ +}Shouldn't the unregister_* be inlined too?
I think they all could be static inlined too in case of !CONFIG_MODULE
Ah, right... it was my mistake.
Quoted 34 lines
Quoted 20 lines
include/linux/kprobes.h +0
-0#endif /* CONFIG_KPROBES */ #endif /* _LINUX_KPROBES_H */ kernel/kprobes.c +10
-0@@ -1416,6 +1416,256 @@ static int __kprobes debugfs_kprobe_init(void)late_initcall (debugfs_kprobe_init);#endif /* CONFIG_DEBUG_FS */ +/* Kprobes module respawn support */ +enum probe_type { +PROBE_TYPE_KPROBE , +PROBE_TYPE_KRETPROBE , +PROBE_TYPE_JPROBE , +}; + +struct module_probe_client { +struct list_head list; +const char *module;/* including symbol name */ kernel/kprobes.c static int __kprobes debugfs_kprobe_init(void) · line 1438
Quoted 10 lines
kernel/kprobes.c +10
-0+int active; +void *data; +probe_activate_handler_t handler; +enum probe_type type; +union { +struct kprobe *kp; +struct kretprobe *rp; +struct jprobe *jp; + }; +};#ifdef
CONFIG_MODULE?
Quoted 1 line
Frederic.
Yes.
Thank you,
Signature · 7 lines
Masami Hiramatsu Software Engineer Hitachi Computer Products (America) Inc. Software Solutions Division e-mail: [email protected]
Quoted 242 lines · Masami Hiramatsu
Quoted 232 lines · Frederic Weisbecker
Quoted 232 lines
kernel/kprobes.c +224
-0@@ -1416,6 +1416,256 @@ static int __kprobes debugfs_kprobe_init(void)late_initcall (debugfs_kprobe_init);#endif /* CONFIG_DEBUG_FS */ +/* Kprobes module respawn support */ +enum probe_type { +PROBE_TYPE_KPROBE , +PROBE_TYPE_KRETPROBE , +PROBE_TYPE_JPROBE , +}; + +struct module_probe_client { +struct list_head list; +const char *module;/* including symbol name */ +int active; +void *data; +probe_activate_handler_t handler; +enum probe_type type; +union { +struct kprobe *kp; +struct kretprobe *rp; +struct jprobe *jp; + }; +}; + +static DEFINE_MUTEX (module_probe_mutex); +static LIST_HEAD (module_probe_list); + +static int activate_module_probe (struct module_probe_client *pc) +{ +int ret =0 ; +if (pc->active) +return 0 ; +switch (pc->type) { +case PROBE_TYPE_KPROBE : + ret =register_kprobe (pc->kp); +break ; +case PROBE_TYPE_KRETPROBE : + ret =register_kretprobe (pc->rp); +break ; +case PROBE_TYPE_JPROBE : + ret =register_jprobe (pc->jp); +break ; +default : +WARN_ON (1 ); +break ; + } +if (!ret) + pc->active =1 ; +return ret; +} + +static void deactivate_module_probe (struct module_probe_client *pc) +{ +if (!pc->active) +return ; +switch (pc->type) { +case PROBE_TYPE_KPROBE : +unregister_kprobe (pc->kp); +break ; +case PROBE_TYPE_KRETPROBE : +unregister_kretprobe (pc->rp); +break ; +case PROBE_TYPE_JPROBE : +unregister_jprobe (pc->jp); +break ; +default : +WARN_ON (1 ); +break ; + } + pc->active =0 ; +} + +static const char *probed_module_name (struct kprobe *kp) +{ +if ((kp->symbol_name) &&strchr (kp->symbol_name,':' )) +return kp->symbol_name; +return NULL ; +} + +static int module_is_exist (const char *module) +{ +char buf[MODULE_NAME_LEN +8 ]; +snprintf (buf,MODULE_NAME_LEN +8 ,"%s:__stext" , module); +return module_kallsyms_lookup_name (buf) ?1 :0 ; +} + +static int add_module_probe (const char *module,void *p,enum probe_type type, +probe_activate_handler_t handler,void *data) +{ +struct module_probe_client *pc; +int ret =0 ; + +if (!handler) +return -EINVAL ; + + pc =kzalloc (sizeof (struct module_probe_client ),GFP_KERNEL ); + pc->kp = p; + pc->type = type; + pc->module = module; + pc->handler = handler; + pc->data = data; +INIT_LIST_HEAD (&pc->list); + +mutex_lock (&module_probe_mutex); +if (module_is_exist (module)) + ret =activate_module_probe (pc); +if (ret) +kfree (pc); +else +list_add_tail (&pc->list, &module_probe_list); +mutex_unlock (&module_probe_mutex); +return ret; +} + +static void __del_module_probe (struct module_probe_client *pc) +{ +list_del (&pc->list); +deactivate_module_probe (pc); +kfree (pc); +} + +static int del_module_probe (void *p) +{ +struct module_probe_client *pc; +int ret; + +mutex_lock (&module_probe_mutex); +list_for_each_entry (pc, &module_probe_list, list) +if (pc->kp == p) { +/* don't need safe loop, we exit soon */ +__del_module_probe (pc); + goto found; + } + ret = -ENOENT ; +found: +mutex_unlock (&module_probe_mutex); +return ret; +} + +int __kprobes +register_module_kprobe (struct kprobe *kp, +probe_activate_handler_t handler,void *data) +{ +const char *module; + module =probed_module_name (kp); +if (!module) +return register_kprobe (kp); +return add_module_probe (module, kp,PROBE_TYPE_KPROBE , + handler, data); +} +EXPORT_SYMBOL_GPL (register_module_kprobe); + +int __kprobes +register_module_kretprobe (struct kretprobe *rp, +probe_activate_handler_t handler,void *data) +{ +const char *module; + module =probed_module_name (&rp->kp); +if (!module) +return register_kretprobe (rp); +return add_module_probe (module, rp,PROBE_TYPE_KRETPROBE , + handler, data); +} +EXPORT_SYMBOL_GPL (register_module_kretprobe); + +int __kprobes +register_module_jprobe (struct jprobe *jp, +probe_activate_handler_t handler,void *data) +{ +const char *module; + module =probed_module_name (&jp->kp); +if (!module) +return register_jprobe (jp); +return add_module_probe (module, jp,PROBE_TYPE_JPROBE , + handler, data); +} +EXPORT_SYMBOL_GPL (register_module_jprobe); + +void __kprobes unregister_module_kprobe (struct kprobe *kp) +{ +const char *module; + module =probed_module_name (kp); +if (!module) +unregister_kprobe (kp); +else +del_module_probe (kp); +} +EXPORT_SYMBOL_GPL (unregister_module_kprobe); + +void __kprobes unregister_module_kretprobe (struct kretprobe *rp) +{ +const char *module; + module =probed_module_name (&rp->kp); +if (!module) +unregister_kretprobe (rp); +else +del_module_probe (rp); +} +EXPORT_SYMBOL_GPL (unregister_module_kretprobe); + +void __kprobes unregister_module_jprobe (struct jprobe *jp) +{ +const char *module; + module =probed_module_name (&jp->kp); +if (!module) +unregister_jprobe (jp); +else +del_module_probe (jp); +} +EXPORT_SYMBOL_GPL (unregister_module_jprobe); + +static int module_is_probed (const char *mod,const char *sym) +{ +int len =strlen (mod); +return strncmp (mod, sym, len) ==0 && sym[len] ==':' ; +} + +static int module_probe_callback (struct notifier_block *nb, +unsigned long state,void *module) +{ +struct module_probe_client *pc; +struct module *mod = module; +if (state ==MODULE_STATE_LIVE ) +return NOTIFY_DONE ; + +mutex_lock (&module_probe_mutex); +list_for_each_entry (pc, &module_probe_list, list) {Quoted 8 lines
kernel/kprobes.c static int __kprobes debugfs_kprobe_init(void) · line 1646
Quoted 4 lines
kernel/kprobes.c +4
-0+if (!module_is_probed (mod->name, pc->module)) +continue ; +if (state ==MODULE_STATE_COMING && + pc->handler (pc->data, module)) {I don't see a place where you check if
pc->handler!= NULL May be you could attach a stub in such cases.
Quoted 2 lines
Please see
add_module_probe(), handler == NULL case returns-EINVAL, andmodule_probe_listis internal list. So,pc->handlernever be NULL.
Ah ok, I missed it.
And indeed if the users don't care about giving a handler, they just have to use the usual kprobe functions.
Quoted 11 lines
Thank you,
Signature · 7 lines
Masami Hiramatsu Software Engineer Hitachi Computer Products (America) Inc. Software Solutions Division e-mail: [email protected]