system/linux
system/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux synced 2024-09-29 16:00:27 +00:00
Code Issues Packages Projects Releases Wiki Activity

lkdtm: Convert from jprobe to kprobe

Browse source 
The jprobe subsystem is being removed, so convert to using kprobe instead.

Cc: Masami Hiramatsu <mhiramat@kernel.org>
Signed-off-by: Kees Cook <keescook@chromium.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
This commit is contained in:
Kees Cook 2017-10-20 06:31:27 -07:00 committed by Greg Kroah-Hartman
parent 8caef1fa91
commit 31c5c870a1
1 changed files with 45 additions and 109 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

154
drivers/misc/lkdtm_core.c
View file

@ -56,122 +56,54 @@ static ssize_t direct_entry(struct file *f, const char __user *user_buf,
size_t count, loff_t *off); size_t count, loff_t *off);
#ifdef CONFIG_KPROBES #ifdef CONFIG_KPROBES
static void lkdtm_handler(void); static int lkdtm_kprobe_handler(struct kprobe *kp, struct pt_regs *regs);
static ssize_t lkdtm_debugfs_entry(struct file *f, static ssize_t lkdtm_debugfs_entry(struct file *f,
const char __user *user_buf, const char __user *user_buf,
size_t count, loff_t *off); size_t count, loff_t *off);
# define CRASHPOINT_KPROBE(_symbol) \
.kprobe = { \
/* jprobe entry point handlers. */ .symbol_name = (_symbol), \
static unsigned int jp_do_irq(unsigned int irq) .pre_handler = lkdtm_kprobe_handler, \
{ },
lkdtm_handler(); # define CRASHPOINT_WRITE(_symbol) \
jprobe_return(); (_symbol) ? lkdtm_debugfs_entry : direct_entry
return 0; #else
} # define CRASHPOINT_KPROBE(_symbol)
# define CRASHPOINT_WRITE(_symbol) direct_entry
static irqreturn_t jp_handle_irq_event(unsigned int irq,
struct irqaction *action)
{
lkdtm_handler();
jprobe_return();
return 0;
}
static void jp_tasklet_action(struct softirq_action *a)
{
lkdtm_handler();
jprobe_return();
}
static void jp_ll_rw_block(int rw, int nr, struct buffer_head *bhs[])
{
lkdtm_handler();
jprobe_return();
}
struct scan_control;
static unsigned long jp_shrink_inactive_list(unsigned long max_scan,
struct zone *zone,
struct scan_control *sc)
{
lkdtm_handler();
jprobe_return();
return 0;
}
static int jp_hrtimer_start(struct hrtimer *timer, ktime_t tim,
const enum hrtimer_mode mode)
{
lkdtm_handler();
jprobe_return();
return 0;
}
static int jp_scsi_dispatch_cmd(struct scsi_cmnd *cmd)
{
lkdtm_handler();
jprobe_return();
return 0;
}
# ifdef CONFIG_IDE
static int jp_generic_ide_ioctl(ide_drive_t *drive, struct file *file,
struct block_device *bdev, unsigned int cmd,
unsigned long arg)
{
lkdtm_handler();
jprobe_return();
return 0;
}
# endif
#endif #endif
/* Crash points */ /* Crash points */
struct crashpoint { struct crashpoint {
const char *name; const char *name;
const struct file_operations fops; const struct file_operations fops;
struct jprobe jprobe; struct kprobe kprobe;
}; };
#define CRASHPOINT(_name, _write, _symbol, _entry) \ #define CRASHPOINT(_name, _symbol) \
{ \ { \
.name = _name, \ .name = _name, \
.fops = { \ .fops = { \
.read = lkdtm_debugfs_read, \ .read = lkdtm_debugfs_read, \
.llseek = generic_file_llseek, \ .llseek = generic_file_llseek, \
.open = lkdtm_debugfs_open, \ .open = lkdtm_debugfs_open, \
.write = _write, \ .write = CRASHPOINT_WRITE(_symbol) \
}, \
.jprobe = { \
.kp.symbol_name = _symbol, \
.entry = (kprobe_opcode_t *)_entry, \
}, \ }, \
CRASHPOINT_KPROBE(_symbol) \
} }
/* Define the possible places where we can trigger a crash point. */ /* Define the possible places where we can trigger a crash point. */
struct crashpoint crashpoints[] = { static struct crashpoint crashpoints[] = {
CRASHPOINT("DIRECT", direct_entry, CRASHPOINT("DIRECT", NULL),
NULL, NULL),
#ifdef CONFIG_KPROBES #ifdef CONFIG_KPROBES
CRASHPOINT("INT_HARDWARE_ENTRY", lkdtm_debugfs_entry, CRASHPOINT("INT_HARDWARE_ENTRY", "do_IRQ"),
"do_IRQ", jp_do_irq), CRASHPOINT("INT_HW_IRQ_EN", "handle_IRQ_event"),
CRASHPOINT("INT_HW_IRQ_EN", lkdtm_debugfs_entry, CRASHPOINT("INT_TASKLET_ENTRY", "tasklet_action"),
"handle_IRQ_event", jp_handle_irq_event), CRASHPOINT("FS_DEVRW", "ll_rw_block"),
CRASHPOINT("INT_TASKLET_ENTRY", lkdtm_debugfs_entry, CRASHPOINT("MEM_SWAPOUT", "shrink_inactive_list"),
"tasklet_action", jp_tasklet_action), CRASHPOINT("TIMERADD", "hrtimer_start"),
CRASHPOINT("FS_DEVRW", lkdtm_debugfs_entry, CRASHPOINT("SCSI_DISPATCH_CMD", "scsi_dispatch_cmd"),
"ll_rw_block", jp_ll_rw_block),
CRASHPOINT("MEM_SWAPOUT", lkdtm_debugfs_entry,
"shrink_inactive_list", jp_shrink_inactive_list),
CRASHPOINT("TIMERADD", lkdtm_debugfs_entry,
"hrtimer_start", jp_hrtimer_start),
CRASHPOINT("SCSI_DISPATCH_CMD", lkdtm_debugfs_entry,
"scsi_dispatch_cmd", jp_scsi_dispatch_cmd),
# ifdef CONFIG_IDE # ifdef CONFIG_IDE
CRASHPOINT("IDE_CORE_CP", lkdtm_debugfs_entry, CRASHPOINT("IDE_CORE_CP", "generic_ide_ioctl"),
"generic_ide_ioctl", jp_generic_ide_ioctl),
# endif # endif
#endif #endif
}; };
@ -254,8 +186,8 @@ struct crashtype crashtypes[] = {
}; };
/* Global jprobe entry and crashtype. */ /* Global kprobe entry and crashtype. */
static struct jprobe *lkdtm_jprobe; static struct kprobe *lkdtm_kprobe;
struct crashpoint *lkdtm_crashpoint; struct crashpoint *lkdtm_crashpoint;
struct crashtype *lkdtm_crashtype; struct crashtype *lkdtm_crashtype;
@ -298,7 +230,8 @@ static struct crashtype *find_crashtype(const char *name)
*/ */
static noinline void lkdtm_do_action(struct crashtype *crashtype) static noinline void lkdtm_do_action(struct crashtype *crashtype)
{ {
BUG_ON(!crashtype || !crashtype->func); if (WARN_ON(!crashtype || !crashtype->func))
return;
crashtype->func(); crashtype->func();
} }
@ -308,22 +241,22 @@ static int lkdtm_register_cpoint(struct crashpoint *crashpoint,
int ret; int ret;
/* If this doesn't have a symbol, just call immediately. */ /* If this doesn't have a symbol, just call immediately. */
if (!crashpoint->jprobe.kp.symbol_name) { if (!crashpoint->kprobe.symbol_name) {
lkdtm_do_action(crashtype); lkdtm_do_action(crashtype);
return 0; return 0;
} }
if (lkdtm_jprobe != NULL) if (lkdtm_kprobe != NULL)
unregister_jprobe(lkdtm_jprobe); unregister_kprobe(lkdtm_kprobe);
lkdtm_crashpoint = crashpoint; lkdtm_crashpoint = crashpoint;
lkdtm_crashtype = crashtype; lkdtm_crashtype = crashtype;
lkdtm_jprobe = &crashpoint->jprobe; lkdtm_kprobe = &crashpoint->kprobe;
ret = register_jprobe(lkdtm_jprobe); ret = register_kprobe(lkdtm_kprobe);
if (ret < 0) { if (ret < 0) {
pr_info("Couldn't register jprobe %s\n", pr_info("Couldn't register kprobe %s\n",
crashpoint->jprobe.kp.symbol_name); crashpoint->kprobe.symbol_name);
lkdtm_jprobe = NULL; lkdtm_kprobe = NULL;
lkdtm_crashpoint = NULL; lkdtm_crashpoint = NULL;
lkdtm_crashtype = NULL; lkdtm_crashtype = NULL;
} }
@ -336,13 +269,14 @@ static int lkdtm_register_cpoint(struct crashpoint *crashpoint,
static int crash_count = DEFAULT_COUNT; static int crash_count = DEFAULT_COUNT;
static DEFINE_SPINLOCK(crash_count_lock); static DEFINE_SPINLOCK(crash_count_lock);
/* Called by jprobe entry points. */ /* Called by kprobe entry points. */
static void lkdtm_handler(void) static int lkdtm_kprobe_handler(struct kprobe *kp, struct pt_regs *regs)
{ {
unsigned long flags; unsigned long flags;
bool do_it = false; bool do_it = false;
BUG_ON(!lkdtm_crashpoint || !lkdtm_crashtype); if (WARN_ON(!lkdtm_crashpoint || !lkdtm_crashtype))
return 0;
spin_lock_irqsave(&crash_count_lock, flags); spin_lock_irqsave(&crash_count_lock, flags);
crash_count--; crash_count--;
@ -357,6 +291,8 @@ static void lkdtm_handler(void)
if (do_it) if (do_it)
lkdtm_do_action(lkdtm_crashtype); lkdtm_do_action(lkdtm_crashtype);
return 0;
} }
static ssize_t lkdtm_debugfs_entry(struct file *f, static ssize_t lkdtm_debugfs_entry(struct file *f,
@ -556,8 +492,8 @@ static void __exit lkdtm_module_exit(void)
/* Handle test-specific clean-up. */ /* Handle test-specific clean-up. */
lkdtm_usercopy_exit(); lkdtm_usercopy_exit();
if (lkdtm_jprobe != NULL) if (lkdtm_kprobe != NULL)
unregister_jprobe(lkdtm_jprobe); unregister_kprobe(lkdtm_kprobe);
pr_info("Crash point unregistered\n"); pr_info("Crash point unregistered\n");
} }