[REFACTOR] change prefix dbi* -> swap*

Change-Id: I01f9f7bef16c231ac2c7031424174ceba52b9296
Signed-off-by: Vyacheslav Cherkashin <v.cherkashin@samsung.com>

diff --git a/energy/energy.c b/energy/energy.c
index 0918190..f311c7d 100644 (file)
--- a/energy/energy.c
+++ b/energy/energy.c
@@ -30,7 +30,7 @@
 #include <linux/magic.h>
 #include <linux/slab.h>
 #include <linux/spinlock.h>
-#include <kprobe/dbi_kprobes.h>
+#include <kprobe/swap_kprobes.h>
 #include <ksyms/ksyms.h>
 #include <us_manager/sspt/sspt_proc.h>
 #include <us_manager/sspt/sspt_feature.h>
@@ -533,21 +533,22 @@ int do_set_energy(void)
 
        init_data_energy();
 
-       ret = dbi_register_kretprobe(&sys_read_krp);
+       ret = swap_register_kretprobe(&sys_read_krp);
        if (ret) {
-               printk("dbi_register_kretprobe(sys_read) result=%d!\n", ret);
+               printk("swap_register_kretprobe(sys_read) result=%d!\n", ret);
                return ret;
        }
 
-       ret = dbi_register_kretprobe(&sys_write_krp);
+       ret = swap_register_kretprobe(&sys_write_krp);
        if (ret != 0) {
-               printk("dbi_register_kretprobe(sys_write) result=%d!\n", ret);
+               printk("swap_register_kretprobe(sys_write) result=%d!\n", ret);
                goto unregister_sys_read;
        }
 
-       ret = dbi_register_kretprobe(&switch_to_krp);
+       ret = swap_register_kretprobe(&switch_to_krp);
        if (ret) {
-               printk("dbi_register_kretprobe(__switch_to) result=%d!\n", ret);
+               printk("swap_register_kretprobe(__switch_to) result=%d!\n",
+                      ret);
                goto unregister_sys_write;
        }
 
@@ -557,10 +558,10 @@ int do_set_energy(void)
        return ret;
 
 unregister_sys_read:
-       dbi_unregister_kretprobe(&sys_read_krp);
+       swap_unregister_kretprobe(&sys_read_krp);
 
 unregister_sys_write:
-       dbi_unregister_kretprobe(&sys_write_krp);
+       swap_unregister_kretprobe(&sys_write_krp);
 
        return ret;
 }
@@ -569,9 +570,9 @@ void do_unset_energy(void)
 {
        lcd_unset_energy();
 
-       dbi_unregister_kretprobe(&switch_to_krp);
-       dbi_unregister_kretprobe(&sys_write_krp);
-       dbi_unregister_kretprobe(&sys_read_krp);
+       swap_unregister_kretprobe(&switch_to_krp);
+       swap_unregister_kretprobe(&sys_write_krp);
+       swap_unregister_kretprobe(&sys_read_krp);
 
        uninit_data_energy();
 }

diff --git a/energy/lcd/maru.c b/energy/lcd/maru.c
index fb75f88..ebb6e45 100644 (file)
--- a/energy/lcd/maru.c
+++ b/energy/lcd/maru.c
@@ -23,7 +23,7 @@
  */
 
 
-#include <kprobe/dbi_kprobes.h>
+#include <kprobe/swap_kprobes.h>
 #include <linux/backlight.h>
 #include "lcd_base.h"
 
@@ -99,12 +99,12 @@ static struct kretprobe set_backlight_krp = {
 
 static int maru_set(struct lcd_ops *ops)
 {
-       return dbi_register_kretprobe(&set_backlight_krp);
+       return swap_register_kretprobe(&set_backlight_krp);
 }
 
 static int maru_unset(struct lcd_ops *ops)
 {
-       dbi_unregister_kretprobe(&set_backlight_krp);
+       swap_unregister_kretprobe(&set_backlight_krp);
        return 0;
 }
 

diff --git a/energy/lcd/s6e8aa0.c b/energy/lcd/s6e8aa0.c
index b607557..c02016d 100644 (file)
--- a/energy/lcd/s6e8aa0.c
+++ b/energy/lcd/s6e8aa0.c
@@ -1,4 +1,4 @@
-#include <kprobe/dbi_kprobes.h>
+#include <kprobe/swap_kprobes.h>
 #include "lcd_base.h"
 
 
@@ -82,21 +82,21 @@ int s6e8aa0_set(struct lcd_ops *ops)
 {
        int ret;
 
-       ret = dbi_register_kretprobe(&set_power_krp);
+       ret = swap_register_kretprobe(&set_power_krp);
        if (ret)
                return ret;
 
-       ret = dbi_register_kretprobe(&set_backlight_krp);
+       ret = swap_register_kretprobe(&set_backlight_krp);
        if (ret)
-               dbi_unregister_kretprobe(&set_power_krp);
+               swap_unregister_kretprobe(&set_power_krp);
 
        return ret;
 }
 
 int s6e8aa0_unset(struct lcd_ops *ops)
 {
-       dbi_unregister_kretprobe(&set_backlight_krp);
-       dbi_unregister_kretprobe(&set_power_krp);
+       swap_unregister_kretprobe(&set_backlight_krp);
+       swap_unregister_kretprobe(&set_power_krp);
 
        return 0;
 }

diff --git a/energy/lcd/s6e8aa0_panel.c b/energy/lcd/s6e8aa0_panel.c
index 1b5abfa..ccd0d49 100644 (file)
--- a/energy/lcd/s6e8aa0_panel.c
+++ b/energy/lcd/s6e8aa0_panel.c
@@ -1,4 +1,4 @@
-#include <kprobe/dbi_kprobes.h>
+#include <kprobe/swap_kprobes.h>
 #include <linux/backlight.h>
 #include "lcd_base.h"
 
@@ -81,21 +81,21 @@ int s6e8aa0_set(struct lcd_ops *ops)
 {
        int ret;
 
-       ret = dbi_register_kretprobe(&set_power_krp);
+       ret = swap_register_kretprobe(&set_power_krp);
        if (ret)
                return ret;
 
-       ret = dbi_register_kretprobe(&set_backlight_krp);
+       ret = swap_register_kretprobe(&set_backlight_krp);
        if (ret)
-               dbi_unregister_kretprobe(&set_power_krp);
+               swap_unregister_kretprobe(&set_power_krp);
 
        return ret;
 }
 
 int s6e8aa0_unset(struct lcd_ops *ops)
 {
-       dbi_unregister_kretprobe(&set_backlight_krp);
-       dbi_unregister_kretprobe(&set_power_krp);
+       swap_unregister_kretprobe(&set_backlight_krp);
+       swap_unregister_kretprobe(&set_power_krp);
 
        return 0;
 }

diff --git a/kprobe/Kbuild b/kprobe/Kbuild
index a9994fb..b5a9a09 100644 (file)
--- a/kprobe/Kbuild
+++ b/kprobe/Kbuild
@@ -1,8 +1,8 @@
 EXTRA_CFLAGS := $(extra_cflags)
 
 obj-m := swap_kprobe.o
-swap_kprobe-y := dbi_kprobes.o \
-                 dbi_kprobes_deps.o \
-                 arch/asm/dbi_kprobes.o \
+swap_kprobe-y := swap_kprobes.o \
+                 swap_kprobes_deps.o \
+                 arch/asm/swap_kprobes.o \
                  swap_slots.o
 swap_kprobe-$(CONFIG_ARM) += arch/asm/trampoline_arm.o

diff --git a/kprobe/arch/asm-arm/dbi_kprobes.c b/kprobe/arch/asm-arm/swap_kprobes.c
similarity index 98%
rename from kprobe/arch/asm-arm/dbi_kprobes.c
rename to kprobe/arch/asm-arm/swap_kprobes.c
index 313bd06..751accb 100644 (file)
--- a/kprobe/arch/asm-arm/dbi_kprobes.c
+++ b/kprobe/arch/asm-arm/swap_kprobes.c
@@ -1,6 +1,6 @@
 /*
  *  Dynamic Binary Instrumentation Module based on KProbes
- *  modules/kprobe/arch/asm-arm/dbi_kprobes.c
+ *  modules/kprobe/arch/asm-arm/swap_kprobes.c
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -32,13 +32,13 @@
 #include <linux/module.h>
 #include <linux/mm.h>
 
-#include "dbi_kprobes.h"
+#include "swap_kprobes.h"
 #include "trampoline_arm.h"
-#include <kprobe/dbi_kprobes.h>
+#include <kprobe/swap_kprobes.h>
 
-#include <kprobe/dbi_kdebug.h>
+#include <kprobe/swap_kdebug.h>
 #include <kprobe/swap_slots.h>
-#include <kprobe/dbi_kprobes_deps.h>
+#include <kprobe/swap_kprobes_deps.h>
 #include <ksyms/ksyms.h>
 
 #include <asm/cacheflush.h>
@@ -440,15 +440,16 @@ int setjmp_pre_handler(struct kprobe *p, struct pt_regs *regs)
                entry(regs->ARM_r0, regs->ARM_r1, regs->ARM_r2,
                      regs->ARM_r3, regs->ARM_r4, regs->ARM_r5);
        } else {
-               dbi_jprobe_return();
+               swap_jprobe_return();
        }
 
        return 0;
 }
 
-void dbi_jprobe_return (void)
+void swap_jprobe_return(void)
 {
 }
+EXPORT_SYMBOL_GPL(swap_jprobe_return);
 
 int longjmp_break_handler (struct kprobe *p, struct pt_regs *regs)
 {
@@ -604,7 +605,7 @@ static int kjump_init(void)
 {
        int ret;
 
-       ret = dbi_register_kprobe(&kjump_kprobe);
+       ret = swap_register_kprobe(&kjump_kprobe);
        if (ret)
                printk("ERROR: kjump_init(), ret=%d\n", ret);
 
@@ -613,7 +614,7 @@ static int kjump_init(void)
 
 static void kjump_exit(void)
 {
-       dbi_unregister_kprobe(&kjump_kprobe);
+       swap_unregister_kprobe(&kjump_kprobe);
 }
 
 

diff --git a/kprobe/arch/asm-arm/dbi_kprobes.h b/kprobe/arch/asm-arm/swap_kprobes.h
similarity index 96%
rename from kprobe/arch/asm-arm/dbi_kprobes.h
rename to kprobe/arch/asm-arm/swap_kprobes.h
index efc2679..6b624a2 100644 (file)
--- a/kprobe/arch/asm-arm/dbi_kprobes.h
+++ b/kprobe/arch/asm-arm/swap_kprobes.h
@@ -1,9 +1,9 @@
-#ifndef _DBI_ASM_ARM_KPROBES_H
-#define _DBI_ASM_ARM_KPROBES_H
+#ifndef _SWAP_ASM_ARM_KPROBES_H
+#define _SWAP_ASM_ARM_KPROBES_H
 
 /*
  *  Dynamic Binary Instrumentation Module based on KProbes
- *  modules/kprobe/arch/asm-arm/dbi_kprobes.h
+ *  modules/kprobe/arch/asm-arm/swap_kprobes.h
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -80,42 +80,43 @@ static inline void arch_set_task_pc(struct task_struct *p, unsigned long val)
        task_thread_info(p)->cpu_context.pc = val;
 }
 
-static inline struct pt_regs *dbi_get_syscall_uregs(unsigned long sp)
+static inline struct pt_regs *swap_get_syscall_uregs(unsigned long sp)
 {
        return (struct pt_regs *)(sp + UREGS_OFFSET);
 }
 
-static inline unsigned long dbi_get_stack_ptr(struct pt_regs *regs)
+static inline unsigned long swap_get_stack_ptr(struct pt_regs *regs)
 {
        return regs->ARM_sp;
 }
 
-static inline unsigned long dbi_get_instr_ptr(struct pt_regs *regs)
+static inline unsigned long swap_get_instr_ptr(struct pt_regs *regs)
 {
        return regs->ARM_pc;
 }
 
-static inline void dbi_set_instr_ptr(struct pt_regs *regs, unsigned long val)
+static inline void swap_set_instr_ptr(struct pt_regs *regs, unsigned long val)
 {
        regs->ARM_pc = val;
 }
 
-static inline unsigned long dbi_get_ret_addr(struct pt_regs *regs)
+static inline unsigned long swap_get_ret_addr(struct pt_regs *regs)
 {
        return regs->ARM_lr;
 }
 
-static inline void dbi_set_ret_addr(struct pt_regs *regs, unsigned long val)
+static inline void swap_set_ret_addr(struct pt_regs *regs, unsigned long val)
 {
        regs->ARM_lr = val;
 }
 
-static inline unsigned long dbi_get_arg(struct pt_regs *regs, int num)
+static inline unsigned long swap_get_arg(struct pt_regs *regs, int num)
 {
        return regs->uregs[num];
 }
 
-static inline void dbi_set_arg(struct pt_regs *regs, int num, unsigned long val)
+static inline void swap_set_arg(struct pt_regs *regs, int num,
+                               unsigned long val)
 {
        regs->uregs[num] = val;
 }
@@ -549,4 +550,4 @@ void arch_exit_kprobes(void);
 //void gen_insn_execbuf_holder (void);
 //void pc_dep_insn_execbuf_holder (void);
 
-#endif /* _DBI_ASM_ARM_KPROBES_H */
+#endif /* _SWAP_ASM_ARM_KPROBES_H */

diff --git a/kprobe/arch/asm-x86/dbi_kprobes.c b/kprobe/arch/asm-x86/swap_kprobes.c
similarity index 98%
rename from kprobe/arch/asm-x86/dbi_kprobes.c
rename to kprobe/arch/asm-x86/swap_kprobes.c
index c69a831..0c8b605 100644 (file)
--- a/kprobe/arch/asm-x86/dbi_kprobes.c
+++ b/kprobe/arch/asm-x86/swap_kprobes.c
@@ -21,7 +21,7 @@
 
 /*
  *  Dynamic Binary Instrumentation Module based on KProbes
- *  modules/kprobe/arch/asm-x86/dbi_kprobes.c
+ *  modules/kprobe/arch/asm-x86/swap_kprobes.c
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -48,12 +48,12 @@
 #include<linux/module.h>
 #include <linux/kdebug.h>
 
-#include "dbi_kprobes.h"
-#include <kprobe/dbi_kprobes.h>
+#include "swap_kprobes.h"
+#include <kprobe/swap_kprobes.h>
 
-#include <kprobe/dbi_kdebug.h>
+#include <kprobe/swap_kdebug.h>
 #include <kprobe/swap_slots.h>
-#include <kprobe/dbi_kprobes_deps.h>
+#include <kprobe/swap_kprobes_deps.h>
 #define SUPRESS_BUG_MESSAGES
 
 extern struct kprobe * per_cpu__current_kprobe;
@@ -489,18 +489,19 @@ int setjmp_pre_handler (struct kprobe *p, struct pt_regs *regs)
        return 1;
 }
 
-void dbi_jprobe_return_end(void);
+void swap_jprobe_return_end(void);
 
-void dbi_jprobe_return (void)
+void swap_jprobe_return(void)
 {
        struct kprobe_ctlblk *kcb = get_kprobe_ctlblk ();
 
        asm volatile("       xchgl   %%ebx,%%esp     \n"
                        "       int3                    \n"
-                       "       .globl dbi_jprobe_return_end    \n"
-                       "       dbi_jprobe_return_end:  \n"
+                       "       .globl swap_jprobe_return_end   \n"
+                       "       swap_jprobe_return_end: \n"
                        "       nop                     \n"::"b" (kcb->jprobe_saved_esp):"memory");
 }
+EXPORT_SYMBOL_GPL(swap_jprobe_return);
 
 void arch_ujprobe_return(void)
 {
@@ -771,8 +772,8 @@ int longjmp_break_handler (struct kprobe *p, struct pt_regs *regs)
 
        DBPRINTF ("p = %p\n", p);
 
-       if ((addr > (u8 *) dbi_jprobe_return) && (addr < (u8 *) dbi_jprobe_return_end))
-       {
+       if ((addr > (u8 *)swap_jprobe_return) && 
+           (addr < (u8 *)swap_jprobe_return_end)) {
                if (stack_addr(regs) != kcb->jprobe_saved_esp) {
                        struct pt_regs *saved_regs = &kcb->jprobe_saved_regs;
                        printk("current esp %p does not match saved esp %p\n",

diff --git a/kprobe/arch/asm-x86/dbi_kprobes.h b/kprobe/arch/asm-x86/swap_kprobes.h
similarity index 87%
rename from kprobe/arch/asm-x86/dbi_kprobes.h
rename to kprobe/arch/asm-x86/swap_kprobes.h
index 6850c24..421ca28 100644 (file)
--- a/kprobe/arch/asm-x86/dbi_kprobes.h
+++ b/kprobe/arch/asm-x86/swap_kprobes.h
@@ -1,5 +1,5 @@
-#ifndef _SRC_ASM_X86_KPROBES_H
-#define _SRC_ASM_X86_KPROBES_H
+#ifndef _SWAP_ASM_X86_KPROBES_H
+#define _SWAP_ASM_X86_KPROBES_H
 
 /*
  *  Kernel Probes (KProbes)
@@ -24,7 +24,7 @@
 
 /*
  *  Dynamic Binary Instrumentation Module based on KProbes
- *  modules/kprobe/arch/asm-x86/dbi_kprobes.c
+ *  modules/kprobe/arch/asm-x86/swap_kprobes.c
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -50,7 +50,7 @@
  */
 
 #include <linux/version.h>
-#include <kprobe/dbi_kprobes_deps.h>
+#include <kprobe/swap_kprobes_deps.h>
 
 typedef u8 kprobe_opcode_t;
 
@@ -103,39 +103,39 @@ static inline void arch_set_task_pc(struct task_struct *p, unsigned long val)
        /* FIXME: Not implemented yet */
 }
 
-static inline struct pt_regs *dbi_get_syscall_uregs(unsigned long sp)
+static inline struct pt_regs *swap_get_syscall_uregs(unsigned long sp)
 {
        return NULL; //FIXME currently not implemented for x86
 }
 
-static inline unsigned long dbi_get_stack_ptr(struct pt_regs *regs)
+static inline unsigned long swap_get_stack_ptr(struct pt_regs *regs)
 {
        return regs->EREG(sp);
 }
 
-static inline unsigned long dbi_get_instr_ptr(struct pt_regs *regs)
+static inline unsigned long swap_get_instr_ptr(struct pt_regs *regs)
 {
        return regs->EREG(ip);
 }
 
-static inline void dbi_set_instr_ptr(struct pt_regs *regs, unsigned long val)
+static inline void swap_set_instr_ptr(struct pt_regs *regs, unsigned long val)
 {
        regs->EREG(ip) = val;
 }
 
-static inline unsigned long dbi_get_ret_addr(struct pt_regs *regs)
+static inline unsigned long swap_get_ret_addr(struct pt_regs *regs)
 {
        unsigned long addr = 0;
        read_proc_vm_atomic(current, regs->EREG(sp), &addr, sizeof(addr));
        return addr;
 }
 
-static inline void dbi_set_ret_addr(struct pt_regs *regs, unsigned long val)
+static inline void swap_set_ret_addr(struct pt_regs *regs, unsigned long val)
 {
        write_proc_vm_atomic(current, regs->EREG(sp), &val, sizeof(val));
 }
 
-static inline unsigned long dbi_get_arg(struct pt_regs *regs, int num)
+static inline unsigned long swap_get_arg(struct pt_regs *regs, int num)
 {
        unsigned long arg = 0;
        read_proc_vm_atomic(current, regs->EREG(sp) + (1 + num) * 4,
@@ -143,14 +143,15 @@ static inline unsigned long dbi_get_arg(struct pt_regs *regs, int num)
        return arg;
 }
 
-static inline void dbi_set_arg(struct pt_regs *regs, int num, unsigned long val)
+static inline void swap_set_arg(struct pt_regs *regs, int num,
+                               unsigned long val)
 {
        write_proc_vm_atomic(current, regs->EREG(sp) + (1 + num) * 4,
                        &val, sizeof(val));
 }
 
-static inline int dbi_fp_backtrace(struct task_struct *task, unsigned long *buf,
-               int max_cnt)
+static inline int swap_fp_backtrace(struct task_struct *task,
+                                   unsigned long *buf, int max_cnt)
 {
        int i = 0;
        struct pt_regs *regs;
@@ -163,7 +164,7 @@ static inline int dbi_fp_backtrace(struct task_struct *task, unsigned long *buf,
 
        regs = task_pt_regs(task);
        frame.next = regs->EREG(bp);
-       frame.raddr = dbi_get_ret_addr(regs);
+       frame.raddr = swap_get_ret_addr(regs);
 
        while (frame.next && i < max_cnt) {
                if (read_proc_vm_atomic(task, frame.next, &frame, sizeof(frame))
@@ -256,4 +257,4 @@ static inline unsigned long swap_get_sarg(struct pt_regs *regs, unsigned long n)
 int arch_init_kprobes(void);
 void arch_exit_kprobes(void);
 
-#endif /* _SRC_ASM_X86_KPROBES_H */
+#endif /* _SWAP_ASM_X86_KPROBES_H */

diff --git a/kprobe/dbi_kdebug.h b/kprobe/swap_kdebug.h
similarity index 91%
rename from kprobe/dbi_kdebug.h
rename to kprobe/swap_kdebug.h
index ffc6f96..8c7b3ff 100644 (file)
--- a/kprobe/dbi_kdebug.h
+++ b/kprobe/swap_kdebug.h
@@ -1,9 +1,9 @@
-#ifndef _DBI_KPROBE_DEBUG_H
-#define _DBI_KPROBE_DEBUG_H
+#ifndef _SWAP_KPROBE_DEBUG_H
+#define _SWAP_KPROBE_DEBUG_H
 
 /*
  *  Dynamic Binary Instrumentation Module based on KProbes
- *  modules/kprobe/dbi_kdebug.h
+ *  modules/kprobe/swap_kdebug.h
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -42,4 +42,4 @@
 #endif
 
 
-#endif /* _DBI_KPROBE_DEBUG_H */
+#endif /* _SWAP_KPROBE_DEBUG_H */

diff --git a/kprobe/dbi_kprobes.c b/kprobe/swap_kprobes.c
similarity index 91%
rename from kprobe/dbi_kprobes.c
rename to kprobe/swap_kprobes.c
index 35e321e..2b46adc 100644 (file)
--- a/kprobe/dbi_kprobes.c
+++ b/kprobe/swap_kprobes.c
@@ -21,7 +21,7 @@
 
 /*
  *  Dynamic Binary Instrumentation Module based on KProbes
- *  modules/kprobe/dbi_kprobes.h
+ *  modules/kprobe/swap_kprobes.h
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -46,13 +46,6 @@
  *
  */
 
-#include "dbi_kprobes.h"
-#include <kprobe/arch/asm/dbi_kprobes.h>
-
-#include "dbi_kdebug.h"
-#include "dbi_kprobes_deps.h"
-#include "swap_slots.h"
-#include <ksyms/ksyms.h>
 
 #include <linux/version.h>
 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19)
@@ -64,6 +57,15 @@
 #include <linux/mm.h>
 #include <linux/pagemap.h>
 
+#include <ksyms/ksyms.h>
+#include <kprobe/arch/asm/swap_kprobes.h>
+
+#include "swap_slots.h"
+#include "swap_kdebug.h"
+#include "swap_kprobes.h"
+#include "swap_kprobes_deps.h"
+
+
 unsigned long sched_addr;
 static unsigned long exit_addr;
 static unsigned long do_group_exit_addr;
@@ -289,7 +291,8 @@ static struct kretprobe_instance *get_free_rp_inst(struct kretprobe *rp)
        }
 
        if (!alloc_nodes_kretprobe(rp)) {
-               swap_hlist_for_each_entry(ri, node, &rp->free_instances, uflist) {
+               swap_hlist_for_each_entry(ri, node, &rp->free_instances,
+                                         uflist) {
                        return ri;
                }
        }
@@ -414,7 +417,8 @@ static int add_new_kprobe(struct kprobe *old_p, struct kprobe *p)
  *
  * The @old entry will be replaced with the @new entry atomically.
  */
-inline void dbi_hlist_replace_rcu(struct hlist_node *old, struct hlist_node *new)
+inline void swap_hlist_replace_rcu(struct hlist_node *old,
+                                  struct hlist_node *new)
 {
        struct hlist_node *next = old->next;
 
@@ -446,7 +450,7 @@ static inline void add_aggr_kprobe(struct kprobe *ap, struct kprobe *p)
        INIT_LIST_HEAD(&ap->list);
        list_add_rcu(&p->list, &ap->list);
 
-       dbi_hlist_replace_rcu(&p->hlist, &ap->hlist);
+       swap_hlist_replace_rcu(&p->hlist, &ap->hlist);
 }
 
 /*
@@ -491,7 +495,7 @@ static void remove_kprobe(struct kprobe *p)
        swap_slot_free(&sm, p->ainsn.insn);
 }
 
-int dbi_register_kprobe(struct kprobe *p)
+int swap_register_kprobe(struct kprobe *p)
 {
        struct kprobe *old_p;
        int ret = 0;
@@ -541,8 +545,9 @@ out:
        DBPRINTF ("out ret = 0x%x\n", ret);
        return ret;
 }
+EXPORT_SYMBOL_GPL(swap_register_kprobe);
 
-static void dbi_unregister_valid_kprobe(struct kprobe *p, struct kprobe *old_p)
+static void swap_unregister_valid_kprobe(struct kprobe *p, struct kprobe *old_p)
 {
        struct kprobe *list_p;
 
@@ -573,7 +578,7 @@ static void dbi_unregister_valid_kprobe(struct kprobe *p, struct kprobe *old_p)
                p->addr = NULL;
 }
 
-void dbi_unregister_kprobe(struct kprobe *kp)
+void swap_unregister_kprobe(struct kprobe *kp)
 {
        struct kprobe *old_p, *list_p;
 
@@ -585,26 +590,29 @@ void dbi_unregister_kprobe(struct kprobe *kp)
                list_for_each_entry_rcu(list_p, &old_p->list, list)
                        if (list_p == kp)
                                /* kprobe p is a valid probe */
-                               dbi_unregister_valid_kprobe(kp, old_p);
+                               swap_unregister_valid_kprobe(kp, old_p);
                return;
        }
 
-       dbi_unregister_valid_kprobe(kp, old_p);
+       swap_unregister_valid_kprobe(kp, old_p);
 }
+EXPORT_SYMBOL_GPL(swap_unregister_kprobe);
 
-int dbi_register_jprobe(struct jprobe *jp)
+int swap_register_jprobe(struct jprobe *jp)
 {
        /* Todo: Verify probepoint is a function entry point */
        jp->kp.pre_handler = setjmp_pre_handler;
        jp->kp.break_handler = longjmp_break_handler;
 
-       return dbi_register_kprobe(&jp->kp);
+       return swap_register_kprobe(&jp->kp);
 }
+EXPORT_SYMBOL_GPL(swap_register_jprobe);
 
-void dbi_unregister_jprobe(struct jprobe *jp)
+void swap_unregister_jprobe(struct jprobe *jp)
 {
-       dbi_unregister_kprobe(&jp->kp);
+       swap_unregister_kprobe(&jp->kp);
 }
+EXPORT_SYMBOL_GPL(swap_unregister_jprobe);
 
 /*
  * This kprobe pre_handler is registered with every kretprobe. When probe
@@ -762,7 +770,7 @@ static int alloc_nodes_kretprobe(struct kretprobe *rp)
        return 0;
 }
 
-int dbi_register_kretprobe(struct kretprobe *rp)
+int swap_register_kretprobe(struct kretprobe *rp)
 {
        int ret = 0;
        struct kretprobe_instance *inst;
@@ -809,23 +817,24 @@ int dbi_register_kretprobe(struct kretprobe *rp)
        DBPRINTF ("addr=%p, *addr=[%lx %lx %lx]", rp->kp.addr, (unsigned long) (*(rp->kp.addr)), (unsigned long) (*(rp->kp.addr + 1)), (unsigned long) (*(rp->kp.addr + 2)));
        rp->nmissed = 0;
        /* Establish function entry probe point */
-       if ((ret = dbi_register_kprobe(&rp->kp)) != 0)
+       if ((ret = swap_register_kprobe(&rp->kp)) != 0)
                free_rp_inst(rp);
 
        DBPRINTF ("addr=%p, *addr=[%lx %lx %lx]", rp->kp.addr, (unsigned long) (*(rp->kp.addr)), (unsigned long) (*(rp->kp.addr + 1)), (unsigned long) (*(rp->kp.addr + 2)));
 
        return ret;
 }
+EXPORT_SYMBOL_GPL(swap_register_kretprobe);
 
-static int dbi_disarm_krp_inst(struct kretprobe_instance *ri);
+static int swap_disarm_krp_inst(struct kretprobe_instance *ri);
 
-static void dbi_disarm_krp(struct kretprobe *rp)
+static void swap_disarm_krp(struct kretprobe *rp)
 {
        struct kretprobe_instance *ri;
        DECLARE_NODE_PTR_FOR_HLIST(node);
 
        swap_hlist_for_each_entry(ri, node, &rp->used_instances, uflist) {
-               if (dbi_disarm_krp_inst(ri) != 0) {
+               if (swap_disarm_krp_inst(ri) != 0) {
                        printk("%s (%d/%d): cannot disarm krp instance (%08lx)\n",
                                        ri->task->comm, ri->task->tgid, ri->task->pid,
                                        (unsigned long)rp->kp.addr);
@@ -833,7 +842,7 @@ static void dbi_disarm_krp(struct kretprobe *rp)
        }
 }
 
-void dbi_unregister_kretprobes_top(struct kretprobe **rps, size_t size,
+void swap_unregister_kretprobes_top(struct kretprobe **rps, size_t size,
                                   int rp_disarm)
 {
        unsigned long flags;
@@ -841,21 +850,21 @@ void dbi_unregister_kretprobes_top(struct kretprobe **rps, size_t size,
 
        spin_lock_irqsave(&kretprobe_lock, flags);
        for (--size; size != end; --size) {
-               dbi_unregister_kprobe(&rps[size]->kp);
+               swap_unregister_kprobe(&rps[size]->kp);
                if (rp_disarm)
-                       dbi_disarm_krp(rps[size]);
+                       swap_disarm_krp(rps[size]);
        }
        spin_unlock_irqrestore(&kretprobe_lock, flags);
 }
-EXPORT_SYMBOL_GPL(dbi_unregister_kretprobes_top);
+EXPORT_SYMBOL_GPL(swap_unregister_kretprobes_top);
 
-void dbi_unregister_kretprobe_top(struct kretprobe *rp, int rp_disarm)
+void swap_unregister_kretprobe_top(struct kretprobe *rp, int rp_disarm)
 {
-       dbi_unregister_kretprobes_top(&rp, 1, rp_disarm);
+       swap_unregister_kretprobes_top(&rp, 1, rp_disarm);
 }
-EXPORT_SYMBOL_GPL(dbi_unregister_kretprobe_top);
+EXPORT_SYMBOL_GPL(swap_unregister_kretprobe_top);
 
-void dbi_unregister_kretprobe_bottom(struct kretprobe *rp)
+void swap_unregister_kretprobe_bottom(struct kretprobe *rp)
 {
        unsigned long flags;
        struct kretprobe_instance *ri;
@@ -872,38 +881,40 @@ void dbi_unregister_kretprobe_bottom(struct kretprobe *rp)
 
        spin_unlock_irqrestore(&kretprobe_lock, flags);
 }
-EXPORT_SYMBOL_GPL(dbi_unregister_kretprobe_bottom);
+EXPORT_SYMBOL_GPL(swap_unregister_kretprobe_bottom);
 
-void dbi_unregister_kretprobes_bottom(struct kretprobe **rps, size_t size)
+void swap_unregister_kretprobes_bottom(struct kretprobe **rps, size_t size)
 {
        const size_t end = ((size_t) 0) - 1;
 
        for (--size; size != end; --size)
-               dbi_unregister_kretprobe_bottom(rps[size]);
+               swap_unregister_kretprobe_bottom(rps[size]);
 }
-EXPORT_SYMBOL_GPL(dbi_unregister_kretprobes_bottom);
+EXPORT_SYMBOL_GPL(swap_unregister_kretprobes_bottom);
 
-void dbi_unregister_kretprobes(struct kretprobe **rpp, size_t size)
+void swap_unregister_kretprobes(struct kretprobe **rpp, size_t size)
 {
-       dbi_unregister_kretprobes_top(rpp, size, 1);
+       swap_unregister_kretprobes_top(rpp, size, 1);
 
        if (!in_atomic())
                synchronize_sched();
 
-       dbi_unregister_kretprobes_bottom(rpp, size);
+       swap_unregister_kretprobes_bottom(rpp, size);
 }
+EXPORT_SYMBOL_GPL(swap_unregister_kretprobes);
 
-void dbi_unregister_kretprobe(struct kretprobe *rp)
+void swap_unregister_kretprobe(struct kretprobe *rp)
 {
-       dbi_unregister_kretprobes(&rp, 1);
+       swap_unregister_kretprobes(&rp, 1);
 }
+EXPORT_SYMBOL_GPL(swap_unregister_kretprobe);
 
 static void inline rm_task_trampoline(struct task_struct *p, struct kretprobe_instance *ri)
 {
        arch_set_task_pc(p, (unsigned long)ri->ret_addr);
 }
 
-static int dbi_disarm_krp_inst(struct kretprobe_instance *ri)
+static int swap_disarm_krp_inst(struct kretprobe_instance *ri)
 {
        unsigned long *tramp = (unsigned long *)&kretprobe_trampoline;
        unsigned long *sp = ri->sp;
@@ -1029,13 +1040,4 @@ static void __exit exit_kprobes(void)
 module_init(init_kprobes);
 module_exit(exit_kprobes);
 
-EXPORT_SYMBOL_GPL(dbi_register_kprobe);
-EXPORT_SYMBOL_GPL(dbi_unregister_kprobe);
-EXPORT_SYMBOL_GPL(dbi_register_jprobe);
-EXPORT_SYMBOL_GPL(dbi_unregister_jprobe);
-EXPORT_SYMBOL_GPL(dbi_jprobe_return);
-EXPORT_SYMBOL_GPL(dbi_register_kretprobe);
-EXPORT_SYMBOL_GPL(dbi_unregister_kretprobes);
-EXPORT_SYMBOL_GPL(dbi_unregister_kretprobe);
-
 MODULE_LICENSE("Dual BSD/GPL");

diff --git a/kprobe/dbi_kprobes.h b/kprobe/swap_kprobes.h
similarity index 89%
rename from kprobe/dbi_kprobes.h
rename to kprobe/swap_kprobes.h
index 89c67db..aa29f08 100644 (file)
--- a/kprobe/dbi_kprobes.h
+++ b/kprobe/swap_kprobes.h
@@ -1,5 +1,5 @@
-#ifndef _DBI_KPROBES_H
-#define _DBI_KPROBES_H
+#ifndef _SWAP_KPROBES_H
+#define _SWAP_KPROBES_H
 
 /*
  *  Kernel Probes (KProbes)
@@ -24,7 +24,7 @@
 
 /*
  *  Dynamic Binary Instrumentation Module based on KProbes
- *  modules/kprobe/dbi_kprobes.h
+ *  modules/kprobe/swap_kprobes.h
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -58,7 +58,7 @@
 #include <linux/sched.h>
 #include <linux/pagemap.h>
 
-#include <kprobe/arch/asm/dbi_kprobes.h>
+#include <kprobe/arch/asm/swap_kprobes.h>
 
 
 #ifdef CONFIG_ARM
@@ -232,37 +232,37 @@ extern void kprobes_inc_nmissed_count (struct kprobe *p);
 struct kprobe *get_kprobe(void *addr);
 
 
-int dbi_register_kprobe (struct kprobe *p);
-void dbi_unregister_kprobe(struct kprobe *p);
+int swap_register_kprobe(struct kprobe *p);
+void swap_unregister_kprobe(struct kprobe *p);
 
 int setjmp_pre_handler (struct kprobe *, struct pt_regs *);
 int longjmp_break_handler (struct kprobe *, struct pt_regs *);
 
-int dbi_register_jprobe (struct jprobe *p);
-void dbi_unregister_jprobe (struct jprobe *p);
-void dbi_jprobe_return (void);
+int swap_register_jprobe(struct jprobe *p);
+void swap_unregister_jprobe(struct jprobe *p);
+void swap_jprobe_return(void);
 
 
-int dbi_register_kretprobe (struct kretprobe *rp);
-void dbi_unregister_kretprobe (struct kretprobe *rp);
-void dbi_unregister_kretprobes(struct kretprobe **rpp, size_t size);
+int swap_register_kretprobe(struct kretprobe *rp);
+void swap_unregister_kretprobe(struct kretprobe *rp);
+void swap_unregister_kretprobes(struct kretprobe **rpp, size_t size);
 
 /*
  * use:
- *     dbi_unregister_kretprobe[s]_top();
+ *     swap_unregister_kretprobe[s]_top();
  *     synchronize_sched();
- *     dbi_unregister_kretprobe[s]_bottom();
+ *     swap_unregister_kretprobe[s]_bottom();
  *
  * rp_disarm - indicates the need for restoration of the return address
  */
-void dbi_unregister_kretprobe_top(struct kretprobe *rp, int rp_disarm);
-void dbi_unregister_kretprobes_top(struct kretprobe **rps, size_t size,
+void swap_unregister_kretprobe_top(struct kretprobe *rp, int rp_disarm);
+void swap_unregister_kretprobes_top(struct kretprobe **rps, size_t size,
                                   int rp_disarm);
-void dbi_unregister_kretprobe_bottom(struct kretprobe *rp);
-void dbi_unregister_kretprobes_bottom(struct kretprobe **rps, size_t size);
+void swap_unregister_kretprobe_bottom(struct kretprobe *rp);
+void swap_unregister_kretprobes_bottom(struct kretprobe **rps, size_t size);
 
 
-int dbi_disarm_urp_inst_for_task(struct task_struct *parent, struct task_struct *task);
+int swap_disarm_urp_inst_for_task(struct task_struct *parent, struct task_struct *task);
 
 int trampoline_probe_handler (struct kprobe *p, struct pt_regs *regs);
 
@@ -279,5 +279,5 @@ struct kprobe_ctlblk *get_kprobe_ctlblk (void);
 
 void prepare_singlestep(struct kprobe *p, struct pt_regs *regs);
 
-#endif /* _DBI_KPROBES_H */
+#endif /* _SWAP_KPROBES_H */
 

diff --git a/kprobe/dbi_kprobes_deps.c b/kprobe/swap_kprobes_deps.c
similarity index 97%
rename from kprobe/dbi_kprobes_deps.c
rename to kprobe/swap_kprobes_deps.c
index 4c7fd36..008910c 100644 (file)
--- a/kprobe/dbi_kprobes_deps.c
+++ b/kprobe/swap_kprobes_deps.c
@@ -1,6 +1,6 @@
 /*
  *  Dynamic Binary Instrumentation Module based on KProbes
- *  modules/kprobe/dbi_kprobes_deps.h
+ *  modules/kprobe/swap_kprobes_deps.h
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -29,8 +29,8 @@
 
 #include <asm/pgtable.h>
 
-#include "dbi_kprobes_deps.h"
-#include "dbi_kdebug.h"
+#include "swap_kprobes_deps.h"
+#include "swap_kdebug.h"
 
 
 #include <linux/slab.h>
@@ -51,21 +51,21 @@ static unsigned long swap_zero_pfn = 0;
 #endif /* (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 38)) */
 
 #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 36)
-static inline void *dbi_kmap_atomic(struct page *page)
+static inline void *swap_kmap_atomic(struct page *page)
 {
        return kmap_atomic(page);
 }
-static inline void dbi_kunmap_atomic(void *kvaddr)
+static inline void swap_kunmap_atomic(void *kvaddr)
 {
        kunmap_atomic(kvaddr);
 }
 #else /* LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 36) */
-static inline void *dbi_kmap_atomic(struct page *page)
+static inline void *swap_kmap_atomic(struct page *page)
 {
        return kmap_atomic(page, KM_USER0);
 }
 
-static inline void dbi_kunmap_atomic(void *kvaddr)
+static inline void swap_kunmap_atomic(void *kvaddr)
 {
        kunmap_atomic(kvaddr, KM_USER0);
 }
@@ -227,7 +227,7 @@ DECLARE_MOD_DEP_WRAPPER(swap_follow_hugetlb_page,
 #define swap_follow_hugetlb_page follow_hugetlb_page
 #endif /* CONFIG_HUGETLB_PAGE */
 
-static inline int dbi_in_gate_area(struct task_struct *task, unsigned long addr)
+static inline int swap_in_gate_area(struct task_struct *task, unsigned long addr)
 {
 #ifdef __HAVE_ARCH_GATE_AREA
 #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 38)
@@ -250,7 +250,7 @@ DECLARE_MOD_DEP_WRAPPER(swap_in_gate_area_no_task, int, unsigned long addr)
 IMP_MOD_DEP_WRAPPER(in_gate_area_no_task, addr)
 #endif /* LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 38) */
 
-static inline int dbi_in_gate_area_no_xxx(unsigned long addr)
+static inline int swap_in_gate_area_no_xxx(unsigned long addr)
 {
 #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 38)
        return swap_in_gate_area_no_mm(addr);
@@ -454,7 +454,7 @@ long __get_user_pages_uprobe(struct task_struct *tsk, struct mm_struct *mm,
                struct vm_area_struct *vma;
 
                vma = swap_find_extend_vma(mm, start);
-               if (!vma && dbi_in_gate_area(tsk, start)) {
+               if (!vma && swap_in_gate_area(tsk, start)) {
                        unsigned long pg = start & PAGE_MASK;
                        pgd_t *pgd;
                        pud_t *pud;
@@ -649,7 +649,7 @@ static int __get_user_pages_uprobe(struct task_struct *tsk, struct mm_struct *mm
                struct vm_area_struct *vma;
 
                vma = swap_find_extend_vma(mm, start);
-               if (!vma && dbi_in_gate_area_no_xxx(start)) {
+               if (!vma && swap_in_gate_area_no_xxx(start)) {
                        unsigned long pg = start & PAGE_MASK;
                        pgd_t *pgd;
                        pud_t *pud;
@@ -845,7 +845,7 @@ static int __get_user_pages_uprobe(struct task_struct *tsk, struct mm_struct *mm
                unsigned int foll_flags;
 
                vma = find_vma(mm, start);
-               if (!vma && dbi_in_gate_area(tsk, start)) {
+               if (!vma && swap_in_gate_area(tsk, start)) {
                        unsigned long pg = start & PAGE_MASK;
                        struct vm_area_struct *gate_vma = swap_get_gate_vma(tsk);
                        pgd_t *pgd;
@@ -1152,7 +1152,7 @@ int access_process_vm_atomic(struct task_struct *tsk, unsigned long addr, void *
                        if (bytes > PAGE_SIZE-offset)
                                bytes = PAGE_SIZE-offset;
 
-                       maddr = atomic ? dbi_kmap_atomic(page) : kmap(page);
+                       maddr = atomic ? swap_kmap_atomic(page) : kmap(page);
 
                        if (write) {
                                swap_copy_to_user_page(vma, page, addr,
@@ -1163,7 +1163,7 @@ int access_process_vm_atomic(struct task_struct *tsk, unsigned long addr, void *
                                                        buf, maddr + offset, bytes);
                        }
 
-                       atomic ? dbi_kunmap_atomic(maddr) : kunmap(page);
+                       atomic ? swap_kunmap_atomic(maddr) : kunmap(page);
                        page_cache_release(page);
                }
                len -= bytes;

diff --git a/kprobe/dbi_kprobes_deps.h b/kprobe/swap_kprobes_deps.h
similarity index 96%
rename from kprobe/dbi_kprobes_deps.h
rename to kprobe/swap_kprobes_deps.h
index f505756..da58074 100644 (file)
--- a/kprobe/dbi_kprobes_deps.h
+++ b/kprobe/swap_kprobes_deps.h
@@ -1,9 +1,9 @@
-#ifndef _DBI_KPROBES_DEPS_H
-#define _DBI_KPROBES_DEPS_H
+#ifndef _SWAP_KPROBES_DEPS_H
+#define _SWAP_KPROBES_DEPS_H
 
 /*
  *  Dynamic Binary Instrumentation Module based on KProbes
- *  modules/kprobe/dbi_kprobes_deps.h
+ *  modules/kprobe/swap_kprobes_deps.h
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -97,4 +97,4 @@ int access_process_vm_atomic(struct task_struct *tsk, unsigned long addr, void *
 int page_present (struct mm_struct *mm, unsigned long addr);
 
 
-#endif /* _DBI_KPROBES_DEPS_H */
+#endif /* _SWAP_KPROBES_DEPS_H */

diff --git a/kprobe/swap_slots.c b/kprobe/swap_slots.c
index e1d7e4a..a54ec5d 100644 (file)
--- a/kprobe/swap_slots.c
+++ b/kprobe/swap_slots.c
@@ -52,7 +52,7 @@
 #include <linux/spinlock.h>
 
 #include "swap_slots.h"
-#include "dbi_kprobes_deps.h"
+#include "swap_kprobes_deps.h"
 
 
 struct chunk {

diff --git a/ks_features/ks_features.c b/ks_features/ks_features.c
index de4f05e..05fd8f5 100644 (file)
--- a/ks_features/ks_features.c
+++ b/ks_features/ks_features.c
@@ -28,7 +28,7 @@
 
 #include <asm/errno.h>
 #include <ksyms/ksyms.h>
-#include <kprobe/dbi_kprobes.h>
+#include <kprobe/swap_kprobes.h>
 #include <writer/swap_writer_module.h>
 #include "ks_features.h"
 #include "syscall_list.h"
@@ -167,7 +167,7 @@ int init_switch_context(void)
 void exit_switch_context(void)
 {
        if (sc_enable)
-               dbi_unregister_kretprobe(&switch_rp);
+               swap_unregister_kretprobe(&switch_rp);
 }
 
 static int register_switch_context(void)
@@ -180,7 +180,7 @@ static int register_switch_context(void)
                goto unlock;
        }
 
-       ret = dbi_register_kretprobe(&switch_rp);
+       ret = swap_register_kretprobe(&switch_rp);
        if (ret == 0)
                sc_enable = 1;
 
@@ -201,7 +201,7 @@ static int unregister_switch_context(void)
                goto unlock;
        }
 
-       dbi_unregister_kretprobe(&switch_rp);
+       swap_unregister_kretprobe(&switch_rp);
 
        sc_enable = 0;
 unlock:
@@ -226,7 +226,7 @@ static int register_syscall(size_t id)
        ksp[id].rp.entry_handler = entry_handler;
        ksp[id].rp.handler = ret_handler;
 
-       ret = dbi_register_kretprobe(&ksp[id].rp);
+       ret = swap_register_kretprobe(&ksp[id].rp);
 
        return ret;
 }
@@ -239,7 +239,7 @@ static int unregister_syscall(size_t id)
        if (ksp[id].rp.kp.addr == NULL)
                return 0;
 
-       dbi_unregister_kretprobe(&ksp[id].rp);
+       swap_unregister_kretprobe(&ksp[id].rp);
 
        return 0;
 }
@@ -274,7 +274,7 @@ static int unregister_multiple_syscalls(size_t *id_p, size_t cnt)
                }
        }
 
-       dbi_unregister_kretprobes(rpp, i);
+       swap_unregister_kretprobes(rpp, i);
        kfree(rpp);
 
        return 0;

diff --git a/ks_manager/ks_manager.c b/ks_manager/ks_manager.c
index da12c50..e183a79 100644 (file)
--- a/ks_manager/ks_manager.c
+++ b/ks_manager/ks_manager.c
@@ -24,8 +24,8 @@
 
 #include <linux/module.h>
 #include <linux/slab.h>
-#include <kprobe/dbi_kprobes.h>
-#include <kprobe/dbi_kprobes_deps.h>
+#include <kprobe/swap_kprobes.h>
+#include <kprobe/swap_kprobes_deps.h>
 #include "ks_manager.h"
 
 struct probe {
@@ -87,11 +87,11 @@ int ksm_register_probe(unsigned long addr, void *pre_handler,
        if (!p)
                return -ENOMEM;
 
-       ret = dbi_register_jprobe(&p->p.jp);
+       ret = swap_register_jprobe(&p->p.jp);
        if (ret)
                goto free;
 
-       ret = dbi_register_kretprobe(&p->p.rp);
+       ret = swap_register_kretprobe(&p->p.rp);
        if (ret)
                goto unregister_jprobe;
 
@@ -99,7 +99,7 @@ int ksm_register_probe(unsigned long addr, void *pre_handler,
        return 0;
 
 unregister_jprobe:
-       dbi_unregister_jprobe(&p->p.jp);
+       swap_unregister_jprobe(&p->p.jp);
 free:
        free_probe(p);
        return ret;
@@ -109,8 +109,8 @@ EXPORT_SYMBOL_GPL(ksm_register_probe);
 static void do_ksm_unregister_probe(struct probe *p)
 {
        remove_probe_to_list(p);
-       dbi_unregister_kretprobe(&p->p.rp);
-       dbi_unregister_jprobe(&p->p.jp);
+       swap_unregister_kretprobe(&p->p.rp);
+       swap_unregister_jprobe(&p->p.jp);
        free_probe(p);
 }
 

diff --git a/ks_manager/ks_manager.h b/ks_manager/ks_manager.h
index 9b87d8a..42ca724 100644 (file)
--- a/ks_manager/ks_manager.h
+++ b/ks_manager/ks_manager.h
@@ -25,7 +25,7 @@
  *
  */
 
-#include <kprobe/dbi_kprobes.h>
+#include <kprobe/swap_kprobes.h>
 
 struct kern_probe {
        struct jprobe jp;

diff --git a/sampler/sampler_hrtimer.c b/sampler/sampler_hrtimer.c
index 1e3af8e..31b6987 100644 (file)
--- a/sampler/sampler_hrtimer.c
+++ b/sampler/sampler_hrtimer.c
@@ -29,8 +29,8 @@
 
 
 static u64 sampler_timer_quantum = 0;
-static DEFINE_PER_CPU(struct hrtimer, dbi_hrtimer);
-static int dbi_hrtimer_running;
+static DEFINE_PER_CPU(struct hrtimer, swap_hrtimer);
+static int swap_hrtimer_running;
 
 restart_ret sampler_timers_restart(swap_timer *timer)
 {
@@ -45,21 +45,21 @@ restart_ret sampler_timers_restart(swap_timer *timer)
 
 void sampler_timers_set_run(void)
 {
-       dbi_hrtimer_running = 1;
+       swap_hrtimer_running = 1;
 }
 
 
 void sampler_timers_set_stop(void)
 {
-       dbi_hrtimer_running = 0;
+       swap_hrtimer_running = 0;
 }
 
 
 void sampler_timers_start(void *restart_func)
 {
-       struct hrtimer *hrtimer = &__get_cpu_var(dbi_hrtimer);
+       struct hrtimer *hrtimer = &__get_cpu_var(swap_hrtimer);
 
-       if (!dbi_hrtimer_running)
+       if (!swap_hrtimer_running)
                return;
 
        hrtimer_init(hrtimer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
@@ -71,9 +71,9 @@ void sampler_timers_start(void *restart_func)
 
 void sampler_timers_stop(int cpu)
 {
-       struct hrtimer *hrtimer = &per_cpu(dbi_hrtimer, cpu);
+       struct hrtimer *hrtimer = &per_cpu(swap_hrtimer, cpu);
 
-       if (!dbi_hrtimer_running)
+       if (!swap_hrtimer_running)
                return;
 
        hrtimer_cancel(hrtimer);

diff --git a/sampler/sampler_timer.c b/sampler/sampler_timer.c
index db70445..025cedb 100644 (file)
--- a/sampler/sampler_timer.c
+++ b/sampler/sampler_timer.c
@@ -29,8 +29,8 @@
 
 
 static unsigned long sampler_timer_quantum = 0;
-static DEFINE_PER_CPU(struct timer_list, dbi_timer);
-static int dbi_timer_running;
+static DEFINE_PER_CPU(struct timer_list, swap_timer);
+static int swap_timer_running;
 
 
 restart_ret sampler_timers_restart(swap_timer *timer)
@@ -47,21 +47,21 @@ restart_ret sampler_timers_restart(swap_timer *timer)
 
 void sampler_timers_set_run(void)
 {
-       dbi_timer_running = 1;
+       swap_timer_running = 1;
 }
 
 
 void sampler_timers_set_stop(void)
 {
-       dbi_timer_running = 0;
+       swap_timer_running = 0;
 }
 
 
 void sampler_timers_start(void *restart_func)
 {
-       struct timer_list *timer = &__get_cpu_var(dbi_timer);
+       struct timer_list *timer = &__get_cpu_var(swap_timer);
 
-       if (!dbi_timer_running)
+       if (!swap_timer_running)
                return;
 
        init_timer(timer);
@@ -74,9 +74,9 @@ void sampler_timers_start(void *restart_func)
 
 void sampler_timers_stop(int cpu)
 {
-       struct timer_list *timer = &per_cpu(dbi_timer, cpu);
+       struct timer_list *timer = &per_cpu(swap_timer, cpu);
 
-       if (!dbi_timer_running)
+       if (!swap_timer_running)
                return;
        del_timer_sync(timer);
 }

diff --git a/sampler/swap_sampler_module.c b/sampler/swap_sampler_module.c
index fd54e61..1407f28 100644 (file)
--- a/sampler/swap_sampler_module.c
+++ b/sampler/swap_sampler_module.c
@@ -40,7 +40,7 @@
 
 static BLOCKING_NOTIFIER_HEAD(swap_sampler_notifier_list);
 
-static restart_ret dbi_timer_restart(swap_timer *timer)
+static restart_ret swap_timer_restart(swap_timer *timer)
 {
        if (current)
                sample_msg(task_pt_regs(current));
@@ -48,18 +48,18 @@ static restart_ret dbi_timer_restart(swap_timer *timer)
        return sampler_timers_restart(timer);
 }
 
-static int dbi_timer_start(void)
+static int swap_timer_start(void)
 {
        get_online_cpus();
        sampler_timers_set_run();
 
-       on_each_cpu(sampler_timers_start, dbi_timer_restart, 1);
+       on_each_cpu(sampler_timers_start, swap_timer_restart, 1);
        put_online_cpus();
 
        return E_SS_SUCCESS;
 }
 
-static void dbi_timer_stop(void)
+static void swap_timer_stop(void)
 {
        int cpu;
 
@@ -71,7 +71,7 @@ static void dbi_timer_stop(void)
        put_online_cpus();
 }
 
-static int __cpuinit dbi_cpu_notify(struct notifier_block *self,
+static int __cpuinit swap_cpu_notify(struct notifier_block *self,
                                    unsigned long action, void *hcpu)
 {
        long cpu = (long) hcpu;
@@ -80,7 +80,7 @@ static int __cpuinit dbi_cpu_notify(struct notifier_block *self,
        case CPU_ONLINE:
        case CPU_ONLINE_FROZEN:
                smp_call_function_single(cpu, sampler_timers_start,
-                                dbi_timer_restart, 1);
+                                swap_timer_restart, 1);
                break;
        case CPU_DEAD:
        case CPU_DEAD_FROZEN:
@@ -91,8 +91,8 @@ static int __cpuinit dbi_cpu_notify(struct notifier_block *self,
        return NOTIFY_OK;
 }
 
-static struct notifier_block __refdata dbi_cpu_notifier = {
-       .notifier_call = dbi_cpu_notify,
+static struct notifier_block __refdata swap_cpu_notifier = {
+       .notifier_call = swap_cpu_notify,
 };
 
 static int do_swap_sampler_start(unsigned int timer_quantum)
@@ -101,14 +101,14 @@ static int do_swap_sampler_start(unsigned int timer_quantum)
                return -EINVAL;
 
        sampler_timers_set_quantum(timer_quantum);
-       dbi_timer_start();
+       swap_timer_start();
 
        return 0;
 }
 
 static void do_swap_sampler_stop(void)
 {
-       dbi_timer_stop();
+       swap_timer_stop();
 }
 
 static DEFINE_MUTEX(mutex_run);
@@ -160,7 +160,7 @@ static int __init sampler_init(void)
 {
        int retval;
 
-       retval = register_hotcpu_notifier(&dbi_cpu_notifier);
+       retval = register_hotcpu_notifier(&swap_cpu_notifier);
        if (retval) {
                print_err("Error of register_hotcpu_notifier()\n");
                return retval;
@@ -176,7 +176,7 @@ static void __exit sampler_exit(void)
        if (sampler_run)
                do_swap_sampler_stop();
 
-       unregister_hotcpu_notifier(&dbi_cpu_notifier);
+       unregister_hotcpu_notifier(&swap_cpu_notifier);
 
        print_msg("Sampler uninitialized\n");
 }

diff --git a/uprobe/arch/asm-arm/swap_uprobes.c b/uprobe/arch/asm-arm/swap_uprobes.c
index dfb1288..8a39906 100644 (file)
--- a/uprobe/arch/asm-arm/swap_uprobes.c
+++ b/uprobe/arch/asm-arm/swap_uprobes.c
@@ -24,18 +24,18 @@
  *
  */
 
-#include <kprobe/dbi_kprobes.h>
-#include <kprobe/arch/asm/dbi_kprobes.h>
+#include <kprobe/swap_kprobes.h>
+#include <kprobe/arch/asm/swap_kprobes.h>
 #include <kprobe/arch/asm/trampoline_arm.h>
 #include <asm/traps.h>
 #include <uprobe/swap_uprobes.h>
 #include <uprobe/arch/asm/swap_uprobes.h>
 #include <kprobe/swap_slots.h>
-#include <kprobe/dbi_kprobes_deps.h>
+#include <kprobe/swap_kprobes_deps.h>
 #include "trampoline_thumb.h"
 
 // FIXME:
-#include <kprobe/dbi_kdebug.h>
+#include <kprobe/swap_kdebug.h>
 
 
 #define flush_insns(addr, size)                                        \
@@ -600,7 +600,7 @@ int arch_disarm_urp_inst(struct uretprobe_instance *ri,
                         struct task_struct *task)
 {
        struct pt_regs *uregs = task_pt_regs(ri->task);
-       unsigned long ra = dbi_get_ret_addr(uregs);
+       unsigned long ra = swap_get_ret_addr(uregs);
        unsigned long *tramp;
        unsigned long *sp = (unsigned long *)((long)ri->sp & ~1);
        unsigned long *stack = sp - RETPROBE_STACK_DEPTH + 1;
@@ -663,7 +663,7 @@ check_lr: /* check lr anyway */
                       "lr = %08lx - %p\n",
                       task->comm, task->tgid, task->pid,
                       ra, ri->rp->up.kp.addr);
-               dbi_set_ret_addr(uregs, (unsigned long)ri->ret_addr);
+               swap_set_ret_addr(uregs, (unsigned long)ri->ret_addr);
                retval = 0;
        } else if (retval) {
                printk("---> %s (%d/%d): trampoline NOT found at "

diff --git a/uprobe/arch/asm-arm/swap_uprobes.h b/uprobe/arch/asm-arm/swap_uprobes.h
index 3ba1869..8efb0e7 100644 (file)
--- a/uprobe/arch/asm-arm/swap_uprobes.h
+++ b/uprobe/arch/asm-arm/swap_uprobes.h
@@ -29,9 +29,6 @@
 #define _ARM_SWAP_UPROBES_H
 
 
-#include <kprobe/arch/asm/dbi_kprobes.h>
-
-
 struct kprobe;
 struct task_struct;
 struct uprobe;

diff --git a/uprobe/arch/asm-x86/swap_uprobes.c b/uprobe/arch/asm-x86/swap_uprobes.c
index b542d9a..e312431 100644 (file)
--- a/uprobe/arch/asm-x86/swap_uprobes.c
+++ b/uprobe/arch/asm-x86/swap_uprobes.c
@@ -25,7 +25,6 @@
  */
 
 #include <linux/kdebug.h>
-#include <kprobe/arch/asm/dbi_kprobes.h>
 #include <uprobe/swap_uprobes.h>
 #include <uprobe/arch/asm/swap_uprobes.h>
 #include <kprobe/swap_slots.h>

diff --git a/uprobe/arch/asm-x86/swap_uprobes.h b/uprobe/arch/asm-x86/swap_uprobes.h
index f51ab2a..100f263 100644 (file)
--- a/uprobe/arch/asm-x86/swap_uprobes.h
+++ b/uprobe/arch/asm-x86/swap_uprobes.h
@@ -24,11 +24,8 @@
  *
  */
 
-#ifndef _ARM_SWAP_UPROBES_H
-#define _ARM_SWAP_UPROBES_H
-
-
-#include <kprobe/arch/asm/dbi_kprobes.h>
+#ifndef _X86_SWAP_UPROBES_H
+#define _X86_SWAP_UPROBES_H
 
 
 struct uprobe;
@@ -96,4 +93,4 @@ static inline unsigned long swap_get_uarg(struct pt_regs *regs, unsigned long n)
 int swap_arch_init_uprobes(void);
 void swap_arch_exit_uprobes(void);
 
-#endif /* _ARM_SWAP_UPROBES_H */
+#endif /* _X86_SWAP_UPROBES_H */

diff --git a/uprobe/swap_uprobes.c b/uprobe/swap_uprobes.c
index 21d4a28..2d22754 100644 (file)
--- a/uprobe/swap_uprobes.c
+++ b/uprobe/swap_uprobes.c
@@ -26,7 +26,7 @@
 
 
 #include "swap_uprobes.h"
-#include <kprobe/dbi_kdebug.h>
+#include <kprobe/swap_kdebug.h>
 
 #include <uprobe/arch/asm/swap_uprobes.h>
 
@@ -34,7 +34,7 @@
 #include <linux/mempolicy.h>
 #include <linux/module.h>
 #include <kprobe/swap_slots.h>
-#include <kprobe/dbi_kprobes_deps.h>
+#include <kprobe/swap_kprobes_deps.h>
 
 enum {
        UPROBE_HASH_BITS  = 10,
@@ -448,7 +448,7 @@ static struct uretprobe_instance *get_free_urp_inst(struct uretprobe *rp)
 }
 // ===================================================================
 
-int dbi_register_uprobe(struct uprobe *up)
+int swap_register_uprobe(struct uprobe *up)
 {
        int ret = 0;
        struct kprobe *p, *old_p;
@@ -508,7 +508,7 @@ out:
        return ret;
 }
 
-void __dbi_unregister_uprobe(struct uprobe *up, int disarm)
+void __swap_unregister_uprobe(struct uprobe *up, int disarm)
 {
        struct kprobe *p, *old_p, *list_p;
        int cleanup_p;
@@ -574,14 +574,14 @@ valid_p:
                }
        }
 }
-EXPORT_SYMBOL_GPL(__dbi_unregister_uprobe);
+EXPORT_SYMBOL_GPL(__swap_unregister_uprobe);
 
-void dbi_unregister_uprobe(struct uprobe *up)
+void swap_unregister_uprobe(struct uprobe *up)
 {
-       __dbi_unregister_uprobe(up, 1);
+       __swap_unregister_uprobe(up, 1);
 }
 
-int dbi_register_ujprobe(struct ujprobe *jp)
+int swap_register_ujprobe(struct ujprobe *jp)
 {
        int ret = 0;
 
@@ -589,14 +589,15 @@ int dbi_register_ujprobe(struct ujprobe *jp)
        jp->up.kp.pre_handler = setjmp_upre_handler;
        jp->up.kp.break_handler = longjmp_break_uhandler;
 
-       ret = dbi_register_uprobe(&jp->up);
+       ret = swap_register_uprobe(&jp->up);
 
        return ret;
 }
+EXPORT_SYMBOL_GPL(swap_register_ujprobe);
 
-void __dbi_unregister_ujprobe(struct ujprobe *jp, int disarm)
+void __swap_unregister_ujprobe(struct ujprobe *jp, int disarm)
 {
-       __dbi_unregister_uprobe(&jp->up, disarm);
+       __swap_unregister_uprobe(&jp->up, disarm);
        /*
         * Here is an attempt to unregister even those probes that have not been
         * installed (hence not added to the hlist).
@@ -608,12 +609,13 @@ void __dbi_unregister_ujprobe(struct ujprobe *jp, int disarm)
                hlist_del_rcu(&jp->up.kp.is_hlist);
        }
 }
-EXPORT_SYMBOL_GPL(__dbi_unregister_ujprobe);
+EXPORT_SYMBOL_GPL(__swap_unregister_ujprobe);
 
-void dbi_unregister_ujprobe(struct ujprobe *jp)
+void swap_unregister_ujprobe(struct ujprobe *jp)
 {
-       __dbi_unregister_ujprobe(jp, 1);
+       __swap_unregister_ujprobe(jp, 1);
 }
+EXPORT_SYMBOL_GPL(swap_unregister_ujprobe);
 
 int trampoline_uprobe_handler(struct kprobe *p, struct pt_regs *regs)
 {
@@ -713,7 +715,7 @@ static int pre_handler_uretprobe(struct kprobe *p, struct pt_regs *regs)
        return 0;
 }
 
-int dbi_register_uretprobe(struct uretprobe *rp)
+int swap_register_uretprobe(struct uretprobe *rp)
 {
        int i, ret = 0;
        struct uretprobe_instance *inst;
@@ -751,7 +753,7 @@ int dbi_register_uretprobe(struct uretprobe *rp)
        rp->nmissed = 0;
 
        /* Establish function entry probe point */
-       ret = dbi_register_uprobe(&rp->up);
+       ret = swap_register_uprobe(&rp->up);
        if (ret)
                return ret;
 
@@ -759,8 +761,9 @@ int dbi_register_uretprobe(struct uretprobe *rp)
 
        return 0;
 }
+EXPORT_SYMBOL_GPL(swap_register_uretprobe);
 
-int dbi_disarm_urp_inst_for_task(struct task_struct *parent, struct task_struct *task)
+int swap_disarm_urp_inst_for_task(struct task_struct *parent, struct task_struct *task)
 {
        unsigned long flags;
        struct uretprobe_instance *ri;
@@ -781,9 +784,9 @@ int dbi_disarm_urp_inst_for_task(struct task_struct *parent, struct task_struct
 
        return 0;
 }
-EXPORT_SYMBOL_GPL(dbi_disarm_urp_inst_for_task);
+EXPORT_SYMBOL_GPL(swap_disarm_urp_inst_for_task);
 
-void dbi_discard_pending_uretprobes(struct task_struct *task)
+void swap_discard_pending_uretprobes(struct task_struct *task)
 {
        unsigned long flags;
        struct uretprobe_instance *ri;
@@ -806,14 +809,14 @@ void dbi_discard_pending_uretprobes(struct task_struct *task)
 
        spin_unlock_irqrestore(&uretprobe_lock, flags);
 }
-EXPORT_SYMBOL_GPL(dbi_discard_pending_uretprobes);
+EXPORT_SYMBOL_GPL(swap_discard_pending_uretprobes);
 
-void __dbi_unregister_uretprobe(struct uretprobe *rp, int disarm)
+void __swap_unregister_uretprobe(struct uretprobe *rp, int disarm)
 {
        unsigned long flags;
        struct uretprobe_instance *ri;
 
-       __dbi_unregister_uprobe(&rp->up, disarm);
+       __swap_unregister_uprobe(&rp->up, disarm);
        spin_lock_irqsave (&uretprobe_lock, flags);
 
        while ((ri = get_used_urp_inst(rp)) != NULL) {
@@ -840,14 +843,15 @@ void __dbi_unregister_uretprobe(struct uretprobe *rp, int disarm)
        spin_unlock_irqrestore(&uretprobe_lock, flags);
        free_urp_inst(rp);
 }
-EXPORT_SYMBOL_GPL(__dbi_unregister_uretprobe);
+EXPORT_SYMBOL_GPL(__swap_unregister_uretprobe);
 
-void dbi_unregister_uretprobe(struct uretprobe *rp)
+void swap_unregister_uretprobe(struct uretprobe *rp)
 {
-       __dbi_unregister_uretprobe(rp, 1);
+       __swap_unregister_uretprobe(rp, 1);
 }
+EXPORT_SYMBOL_GPL(swap_unregister_uretprobe);
 
-void dbi_unregister_all_uprobes(struct task_struct *task)
+void swap_unregister_all_uprobes(struct task_struct *task)
 {
        struct hlist_head *head;
        struct kprobe *p;
@@ -860,13 +864,16 @@ void dbi_unregister_all_uprobes(struct task_struct *task)
                swap_hlist_for_each_entry_safe(p, node, tnode, head, hlist) {
                        if (kp2up(p)->task->tgid == task->tgid) {
                                struct uprobe *up = container_of(p, struct uprobe, kp);
-                               printk("dbi_unregister_all_uprobes: delete uprobe at %p[%lx] for %s/%d\n",
-                                               p->addr, (unsigned long)p->opcode, task->comm, task->pid);
-                               dbi_unregister_uprobe(up);
+                               printk("%s: delete uprobe at %p[%lx] for "
+                                      "%s/%d\n", __func__, p->addr,
+                                      (unsigned long)p->opcode,
+                                      task->comm, task->pid);
+                               swap_unregister_uprobe(up);
                        }
                }
        }
 }
+EXPORT_SYMBOL_GPL(swap_unregister_all_uprobes);
 
 void swap_ujprobe_return(void)
 {
@@ -888,12 +895,6 @@ static void __exit exit_uprobes(void)
        swap_arch_exit_uprobes();
 }
 
-EXPORT_SYMBOL_GPL(dbi_register_ujprobe);
-EXPORT_SYMBOL_GPL(dbi_unregister_ujprobe);
-EXPORT_SYMBOL_GPL(dbi_register_uretprobe);
-EXPORT_SYMBOL_GPL(dbi_unregister_uretprobe);
-EXPORT_SYMBOL_GPL(dbi_unregister_all_uprobes);
-
 module_init(init_uprobes);
 module_exit(exit_uprobes);
 

diff --git a/uprobe/swap_uprobes.h b/uprobe/swap_uprobes.h
index c5e0e3d..bd83064 100644 (file)
--- a/uprobe/swap_uprobes.h
+++ b/uprobe/swap_uprobes.h
@@ -1,5 +1,5 @@
-#ifndef _DBI_UPROBES_H
-#define _DBI_UPROBES_H
+#ifndef _SWAP_UPROBES_H
+#define _SWAP_UPROBES_H
 
 /*
  *  Dynamic Binary Instrumentation Module based on KProbes
@@ -27,7 +27,7 @@
  *
  */
 
-#include <kprobe/dbi_kprobes.h>
+#include <kprobe/swap_kprobes.h>
 #include <uprobe/arch/asm/swap_uprobes.h>
 
 
@@ -90,20 +90,20 @@ struct uretprobe_instance {
        struct task_struct *task;
 };
 
-int dbi_register_uprobe(struct uprobe *p);
-void dbi_unregister_uprobe(struct uprobe *p);
-void __dbi_unregister_uprobe(struct uprobe *up, int disarm);
+int swap_register_uprobe(struct uprobe *p);
+void swap_unregister_uprobe(struct uprobe *p);
+void __swap_unregister_uprobe(struct uprobe *up, int disarm);
 
-int dbi_register_ujprobe(struct ujprobe *jp);
-void dbi_unregister_ujprobe(struct ujprobe *jp);
-void __dbi_unregister_ujprobe(struct ujprobe *jp, int disarm);
+int swap_register_ujprobe(struct ujprobe *jp);
+void swap_unregister_ujprobe(struct ujprobe *jp);
+void __swap_unregister_ujprobe(struct ujprobe *jp, int disarm);
 
-int dbi_register_uretprobe(struct uretprobe *rp);
-void dbi_unregister_uretprobe(struct uretprobe *rp);
-void __dbi_unregister_uretprobe(struct uretprobe *rp, int disarm);
+int swap_register_uretprobe(struct uretprobe *rp);
+void swap_unregister_uretprobe(struct uretprobe *rp);
+void __swap_unregister_uretprobe(struct uretprobe *rp, int disarm);
 
-void dbi_unregister_all_uprobes(struct task_struct *task);
-void dbi_discard_pending_uretprobes(struct task_struct *task);
+void swap_unregister_all_uprobes(struct task_struct *task);
+void swap_discard_pending_uretprobes(struct task_struct *task);
 
 void swap_ujprobe_return(void);
 struct kprobe *get_ukprobe(void *addr, pid_t tgid);
@@ -125,4 +125,4 @@ int trampoline_uprobe_handler(struct kprobe *p, struct pt_regs *regs);
 
 void add_uprobe_table(struct kprobe *p);
 
-#endif /*  _DBI_UPROBES_H */
+#endif /*  _SWAP_UPROBES_H */

diff --git a/us_manager/helper.c b/us_manager/helper.c
index 64246da..eae924c 100644 (file)
--- a/us_manager/helper.c
+++ b/us_manager/helper.c
@@ -23,8 +23,8 @@
  */
 
 
-#include <kprobe/dbi_kprobes.h>
-#include <kprobe/dbi_kprobes_deps.h>
+#include <kprobe/swap_kprobes.h>
+#include <kprobe/swap_kprobes_deps.h>
 #include <ksyms/ksyms.h>
 #include <writer/kernel_operations.h>
 #include <writer/swap_writer_module.h>
@@ -106,9 +106,9 @@ static int register_mf(void)
 {
        int ret;
 
-       ret = dbi_register_kretprobe(&mf_kretprobe);
+       ret = swap_register_kretprobe(&mf_kretprobe);
        if (ret)
-               printk("dbi_register_kretprobe(handle_mm_fault) ret=%d!\n",
+               printk("swap_register_kretprobe(handle_mm_fault) ret=%d!\n",
                       ret);
 
        return ret;
@@ -116,7 +116,7 @@ static int register_mf(void)
 
 static void unregister_mf(void)
 {
-       dbi_unregister_kretprobe(&mf_kretprobe);
+       swap_unregister_kretprobe(&mf_kretprobe);
 }
 
 
@@ -160,16 +160,16 @@ static int register_ctx_task(void)
 {
        int ret = 0;
 
-       ret = dbi_register_kprobe(&ctx_task_kprobe);
+       ret = swap_register_kprobe(&ctx_task_kprobe);
        if (ret)
-               printk("dbi_register_kprobe(workaround) ret=%d!\n", ret);
+               printk("swap_register_kprobe(workaround) ret=%d!\n", ret);
 
        return ret;
 }
 
 static void unregister_ctx_task(void)
 {
-       dbi_unregister_kprobe(&ctx_task_kprobe);
+       swap_unregister_kprobe(&ctx_task_kprobe);
 }
 #endif /* CONFIG_ARM */
 
@@ -187,7 +187,7 @@ static atomic_t copy_process_cnt = ATOMIC_INIT(0);
 static void recover_child(struct task_struct *child_task, struct sspt_proc *proc)
 {
        sspt_proc_uninstall(proc, child_task, US_DISARM);
-       dbi_disarm_urp_inst_for_task(current, child_task);
+       swap_disarm_urp_inst_for_task(current, child_task);
 }
 
 static void rm_uprobes_child(struct task_struct *task)
@@ -239,20 +239,20 @@ static int register_cp(void)
 {
        int ret;
 
-       ret = dbi_register_kretprobe(&cp_kretprobe);
+       ret = swap_register_kretprobe(&cp_kretprobe);
        if (ret)
-               printk("dbi_register_kretprobe(copy_process) ret=%d!\n", ret);
+               printk("swap_register_kretprobe(copy_process) ret=%d!\n", ret);
 
        return ret;
 }
 
 static void unregister_cp(void)
 {
-       dbi_unregister_kretprobe_top(&cp_kretprobe, 0);
+       swap_unregister_kretprobe_top(&cp_kretprobe, 0);
        do {
                synchronize_sched();
        } while (atomic_read(&copy_process_cnt));
-       dbi_unregister_kretprobe_bottom(&cp_kretprobe);
+       swap_unregister_kretprobe_bottom(&cp_kretprobe);
 }
 
 
@@ -276,7 +276,7 @@ static int mr_pre_handler(struct kprobe *p, struct pt_regs *regs)
        if (task->tgid != task->pid) {
                /* if the thread is killed we need to discard pending
                 * uretprobe instances which have not triggered yet */
-               dbi_discard_pending_uretprobes(task);
+               swap_discard_pending_uretprobes(task);
                goto out;
        }
 
@@ -293,16 +293,16 @@ static int register_mr(void)
 {
        int ret;
 
-       ret = dbi_register_kprobe(&mr_kprobe);
+       ret = swap_register_kprobe(&mr_kprobe);
        if (ret)
-               printk("dbi_register_kprobe(mm_release) ret=%d!\n", ret);
+               printk("swap_register_kprobe(mm_release) ret=%d!\n", ret);
 
        return ret;
 }
 
 static void unregister_mr(void)
 {
-       dbi_unregister_kprobe(&mr_kprobe);
+       swap_unregister_kprobe(&mr_kprobe);
 }
 
 
@@ -408,20 +408,20 @@ static int register_unmap(void)
 {
        int ret;
 
-       ret = dbi_register_kretprobe(&unmap_kretprobe);
+       ret = swap_register_kretprobe(&unmap_kretprobe);
        if (ret)
-               printk("dbi_register_kprobe(do_munmap) ret=%d!\n", ret);
+               printk("swap_register_kprobe(do_munmap) ret=%d!\n", ret);
 
        return ret;
 }
 
 static void unregister_unmap(void)
 {
-       dbi_unregister_kretprobe_top(&unmap_kretprobe, 0);
+       swap_unregister_kretprobe_top(&unmap_kretprobe, 0);
        do {
                synchronize_sched();
        } while (atomic_read(&unmap_cnt));
-       dbi_unregister_kretprobe_bottom(&unmap_kretprobe);
+       swap_unregister_kretprobe_bottom(&unmap_kretprobe);
 }
 
 
@@ -468,16 +468,16 @@ static int register_mmap(void)
 {
        int ret;
 
-       ret = dbi_register_kretprobe(&mmap_kretprobe);
+       ret = swap_register_kretprobe(&mmap_kretprobe);
        if (ret)
-               printk("dbi_register_kretprobe(do_mmap_pgoff) ret=%d!\n", ret);
+               printk("swap_register_kretprobe(do_mmap_pgoff) ret=%d!\n", ret);
 
        return ret;
 }
 
 static void unregister_mmap(void)
 {
-       dbi_unregister_kretprobe(&mmap_kretprobe);
+       swap_unregister_kretprobe(&mmap_kretprobe);
 }
 
 

diff --git a/us_manager/sspt/sspt.h b/us_manager/sspt/sspt.h
index 2a94072..5cff091 100644 (file)
--- a/us_manager/sspt/sspt.h
+++ b/us_manager/sspt/sspt.h
@@ -53,14 +53,14 @@ static inline int sspt_register_usprobe(struct us_ip *ip)
        ip->retprobe.up.task = ip->page->file->proc->task;
        ip->retprobe.up.sm = ip->page->file->proc->sm;
 
-       ret = dbi_register_uretprobe(&ip->retprobe);
+       ret = swap_register_uretprobe(&ip->retprobe);
        if (ret) {
                struct sspt_file *file = ip->page->file;
                char *name = file->dentry->d_iname;
                unsigned long addr = (unsigned long)ip->retprobe.up.kp.addr;
                unsigned long offset = addr - file->vm_start;
 
-               printk("dbi_register_uretprobe() failure %d (%s:%lx|%lx)\n",
+               printk("swap_register_uretprobe() failure %d (%s:%lx|%lx)\n",
                       ret, name, offset, (unsigned long)ip->retprobe.up.kp.opcode);
        }
 
@@ -69,7 +69,7 @@ static inline int sspt_register_usprobe(struct us_ip *ip)
 
 static inline int do_unregister_usprobe(struct us_ip *ip, int disarm)
 {
-       __dbi_unregister_uretprobe(&ip->retprobe, disarm);
+       __swap_unregister_uretprobe(&ip->retprobe, disarm);
 
        return 0;
 }

diff --git a/us_manager/sspt/sspt_debug.h b/us_manager/sspt/sspt_debug.h
index d51581f..26f69ce 100644 (file)
--- a/us_manager/sspt/sspt_debug.h
+++ b/us_manager/sspt/sspt_debug.h
@@ -25,7 +25,7 @@
  *
  */
 
-#include <kprobe/dbi_kprobes_deps.h>
+#include <kprobe/swap_kprobes_deps.h>
 
 static inline void print_jprobe(struct jprobe *jp)
 {

diff --git a/us_manager/sspt/sspt_file.c b/us_manager/sspt/sspt_file.c
index 72f3af8..9539844 100644 (file)
--- a/us_manager/sspt/sspt_file.c
+++ b/us_manager/sspt/sspt_file.c
@@ -30,7 +30,7 @@
 #include <linux/list.h>
 #include <linux/hash.h>
 #include <linux/sched.h>
-#include <kprobe/dbi_kprobes_deps.h>
+#include <kprobe/swap_kprobes_deps.h>
 
 static int calculation_hash_bits(int cnt)
 {

diff --git a/us_manager/us_slot_manager.c b/us_manager/us_slot_manager.c
index 0b2e2b7..002a052 100644 (file)
--- a/us_manager/us_slot_manager.c
+++ b/us_manager/us_slot_manager.c
@@ -30,7 +30,7 @@
 #include <linux/mman.h>
 #include <linux/list.h>
 #include <kprobe/swap_slots.h>
-#include <kprobe/arch/asm/dbi_kprobes.h>
+#include <kprobe/arch/asm/swap_kprobes.h>
 #include "us_manager_common.h"
 
 

diff --git a/writer/swap_writer_module.c b/writer/swap_writer_module.c
index 7bd1c0b..c4e864e 100644 (file)
--- a/writer/swap_writer_module.c
+++ b/writer/swap_writer_module.c
@@ -34,7 +34,7 @@
 #include <linux/module.h>
 #include <linux/slab.h>
 #include <asm/uaccess.h>
-#include <kprobe/arch/asm/dbi_kprobes.h>
+#include <kprobe/arch/asm/swap_kprobes.h>
 #include <uprobe/arch/asm/swap_uprobes.h>
 
 #include <buffer/swap_buffer_module.h>