static int __init my_init (void)
{
register_jprobe (&jp);
printk (KERN_INFO "plant jprobe at %p, handler addr %p\n", jp.kp.addr,
jp.entry);
return 0;
}
static __init int dccpprobe_init(void)
{
int ret = -ENOMEM;
init_waitqueue_head(&dccpw.wait);
spin_lock_init(&dccpw.lock);
dccpw.fifo = kfifo_alloc(bufsize, GFP_KERNEL, &dccpw.lock);
if (IS_ERR(dccpw.fifo))
return PTR_ERR(dccpw.fifo);
if (!proc_net_fops_create(procname, S_IRUSR, &dccpprobe_fops))
goto err0;
ret = register_jprobe(&dccp_send_probe);
if (ret)
goto err1;
pr_info("DCCP watch registered (port=%d)\n", port);
return 0;
err1:
proc_net_remove(procname);
err0:
kfifo_free(dccpw.fifo);
return ret;
}
int kmemchecker_probes_init(void)
{
int ret;
my_kmalloc_kretprobe.kp.symbol_name = func_name;
ret = register_kretprobe(&my_kmalloc_kretprobe);
if (ret < 0) {
printk(KERN_INFO "kretprobe failed, returned %d\n",
ret);
return -1;
}
printk(KERN_INFO "Planted return probe at %s: %p\n",
my_kmalloc_kretprobe.kp.symbol_name,
my_kmalloc_kretprobe.kp.addr);
ret = register_jprobe(&my_kfree_jprobe);
if (ret < 0) {
unregister_kretprobe(&my_kmalloc_kretprobe);
return -1;
}
printk(KERN_INFO "hook kfree\n");
my_kmem_cache_alloc_kretprobe.kp.symbol_name = "__slab_alloc";
ret = register_kretprobe(&my_kmem_cache_alloc_kretprobe);
if (ret < 0) {
unregister_kretprobe(&my_kmalloc_kretprobe);
unregister_jprobe(&my_kfree_jprobe);
return -1;
}
printk(KERN_INFO "hook __slab_alloc\n");
return 0;
}
static int __init
jprobe_init(void)
{
register_jprobe(&my_jprobe);
printk(KERN_ALERT "plant jprobe at %p, handler addr %p\n",my_jprobe.kp.addr, my_jprobe.entry);
return 0;
}
static __init int init_schk(void)
{
printk("Hello\n");
//
// Settting up kprobes;
//
jp.kp.symbol_name = "fb_set_var";
jp.entry= JPROBE_ENTRY(jp_fb_set_var);
register_jprobe(&jp);
jp0.kp.symbol_name = "fb_ioctl";
jp0.entry= JPROBE_ENTRY(jp_fb_ioctl);
register_jprobe(&jp0);
return 0;
}
static int __init jprobe_sys_mount_init(void)
{
jprobe_sys_mount.kp.symbol_name = "sys_mount";
jprobe_sys_mount.entry = (kprobe_opcode_t *) jprobe_sys_mount_handler;
register_jprobe(&jprobe_sys_mount);
printk(KERN_INFO "Register %s module\n", module_name(THIS_MODULE));
return 0;
}
static int register_hypercall_fi(void)
{
test_count = 0;
my_probe.kp.addr = (kprobe_opcode_t *) 0xc01d2d20; //sys_ioctl
my_probe.entry = (kprobe_opcode_t *)my_handler;
register_jprobe(&my_probe);
return 0;
}
/*
Module entry point
Acquire resources and initialize global variables.
Resources allocated are:
1. Allocate circular log buffer
2. Install hooks on
2.1 On entry call of free_task
2.2 On exit call of do_fork
3. Create a proc file
*/
int probe_processes_init(void)
{
int iRet = 0;
int ijprobe_free_task = -1;
int iret_do_fork = -1;
int iproc_file = -1;
trace(DETAIL_LEVEL, "Entering, init_module(); iMaxLineSize=%d, iMaxNbOfLines=%d, iDebugLevel=%d\n",
iMaxLineSize, iMaxNbOfLines, iDebugLevel);
atomic_set(&s_wrOff, 0);
atomic_set(&s_cnt, 0);
do {
// Create circular log buffer
s_pLog = (char*)kmalloc(iMaxLineSize * iMaxNbOfLines, GFP_KERNEL);
if(s_pLog == NULL) {
iRet = -ENOMEM;
break;
}
memset(s_pLog, 0, iMaxLineSize * iMaxNbOfLines);
// Register hook on the entry of free_task kernel method
if ((ijprobe_free_task = register_jprobe(&jprobe_free_task)) < 0) {
trace(ERROR_LEVEL, "register_jprobe(%s) failed, returned %d\n",
jprobe_free_task.kp.symbol_name, ijprobe_free_task);
iRet = ijprobe_free_task;
break;
}
trace(DETAIL_LEVEL, "On call of %s at %p, handler addr %p\n",
jprobe_free_task.kp.symbol_name, jprobe_free_task.kp.addr, jprobe_free_task.entry);
// Register hook on the exit of do_fork kernel method
if ((iret_do_fork = register_kretprobe(&kret_do_fork)) < 0) {
trace(ERROR_LEVEL, "register_kretprobe(%s) failed, returned %d\n",
kret_do_fork.kp.symbol_name, iret_do_fork);
iRet = iret_do_fork;
break;
}
trace(DETAIL_LEVEL, "On return of %s at %p, handler addr %p\n",
kret_do_fork.kp.symbol_name, kret_do_fork.kp.addr, kret_do_fork.handler);
// Create a /proc/taskinfo file
if((iproc_file = CreateProcFile()) < 0) {
iRet = iproc_file;
break;
}
} while(false);
// Run clean up code if we fail to acquire any resources.
if(iRet < 0) {
ReleaseResources(ijprobe_free_task==0?true:false, iret_do_fork==0?true:false);
}
trace(INFO_LEVEL, "Exiting, %d = init_module();\n", iRet);
return iRet;
}
static int __init kprobe_init(void)
{
int ret;
ret = register_jprobe(&tcp_hook_jp);
if (ret == 0)
printk(KERN_INFO "Register tcp hook OK\n");
return ret;
}
static int __init tp_init(void)
{
int ret;
ret = register_jprobe(&my_jprobe);
if (ret < 0) {
printk(KERN_INFO "TP: register_jprobe failed, returned %d\n", ret);
return -1;
}
pr_info("TP: Locked and loaded.\n");
return 0;
}
static int __init kprobe_init(void)
{
int ret;
jp.kp.symbol_name = (char *)probed_func;
if ((ret = register_jprobe(&jp)) < 0) {
printk("%s: register_jprobe failed, returned %d\n",
__FUNCTION__, ret);
return -1;
}
return 0;
}
int myinit(void)
{
printk("module_inserted\n");
// my_probe.kp.addr = (kprobe_opcode_t *)0xc071c9a9; /*kp.symbol_name = "ip_rcv"; */
// my_probe.entry = (kprobe_opcode_t *)my_handler;
my_probe.kp.symbol_name = "ip_rcv";
my_probe.entry = *my_handler;
printk("registering probe\n");
register_jprobe(&my_probe);
printk("register successful");
//return 0;
}
int init_module(void)
{
hid_register_report_probe.entry=(kprobe_opcode_t*)hijack_hid_register_report;
hid_register_report_probe.kp.addr=(kprobe_opcode_t*)kallsyms_lookup_name("hid_register_report");
register_jprobe(&hid_register_report_probe);
printk("HIDHUNTER :: hid_register_report hooked\n");
hid_add_field_probe.entry=(kprobe_opcode_t*)hijack_hid_add_field;
hid_add_field_probe.kp.addr=(kprobe_opcode_t*)kallsyms_lookup_name("hid_add_field");
register_jprobe(&hid_add_field_probe);
printk("HIDHUNTER :: hid_add_field hooked\n");
hid_parser_main_probe.entry=(kprobe_opcode_t*)hijack_hid_parser_main;
hid_parser_main_probe.kp.addr=(kprobe_opcode_t*)kallsyms_lookup_name("hid_parser_main");
register_jprobe(&hid_parser_main_probe);
printk("HIDHUNTER :: hid_parser_main hooked\n");
hid_parser_global_probe.entry=(kprobe_opcode_t*)hijack_hid_parser_global;
hid_parser_global_probe.kp.addr=(kprobe_opcode_t*)kallsyms_lookup_name("hid_parser_global");
register_jprobe(&hid_parser_global_probe);
printk("HIDHUNTER :: hid_parser_global hooked\n");
hid_parser_local_probe.entry=(kprobe_opcode_t*)hijack_hid_parser_local;
hid_parser_local_probe.kp.addr=(kprobe_opcode_t*)kallsyms_lookup_name("hid_parser_local");
register_jprobe(&hid_parser_local_probe);
printk("HIDHUNTER :: hid_parser_local hooked\n");
hid_parser_reserved_probe.entry=(kprobe_opcode_t*)hijack_hid_parser_reserved;
hid_parser_reserved_probe.kp.addr=(kprobe_opcode_t*)kallsyms_lookup_name("hid_parser_reserved");
register_jprobe(&hid_parser_reserved_probe);
printk("HIDHUNTER :: hid_parser_reserved hooked\n");
return 0;
}
static int __init hybla_cong_avoid_jprobe_init(void)
{
int ret;
ret = register_jprobe(&hybla_cong_avoid_jprobe);
if (ret < 0) {
printk(KERN_INFO "register_jprobe hybla_cong_avoid failed, returned %d\n", ret);
return -1;
}
printk(KERN_INFO "Planted hybla_cong_avoid_jprobe at %p, handler addr %p\n",
hybla_cong_avoid_jprobe.kp.addr, hybla_cong_avoid_jprobe.entry);
return 0;
}
static int __init jprobe_init(void)
{
int ret;
ret = register_jprobe(&my_jprobe);
if (ret < 0) {
printk(KERN_INFO "register_jprobe failed, returned %d\n", ret);
return -1;
}
printk(KERN_INFO "Planted jprobe at %p, handler addr %p\n",
my_jprobe.kp.addr, my_jprobe.entry);
return 0;
}
static int __init tcp_slow_start_jprobe_init(void)
{
int ret;
ret = register_jprobe(&tcp_slow_start_jprobe);
if (ret < 0) {
printk(KERN_INFO "register_jprobe tcp_slow_start failed, returned %d\n", ret);
return -1;
}
printk(KERN_INFO "Planted tcp_slow_start_jprobe at %p, handler addr %p\n",
tcp_slow_start_jprobe.kp.addr, tcp_slow_start_jprobe.entry);
return 0;
}
static int __init jprobe_init(void)
{
int ret;
my_jprobe.kp.symbol_name = "do_fork";
if ((ret = register_jprobe(&my_jprobe)) <0) {
printk("register_jprobe failed, returned %d\n", ret);
/* XXX: Exit code is wrong. */
return -1;
}
printk("Planted jprobe at %p, handler addr %p\n",
my_jprobe.kp.addr, my_jprobe.entry);
return 0;
}
int __init probe_init(struct hook *hooks, struct rhook *rhooks)
{
int err;
struct hook *p;
struct rhook *q;
p = hooks;
while (p->funcname) {
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,19)
p->jp.kp.symbol_name = p->funcname;
#else
p->jp.kp.addr = (void*)kallsyms_lookup_name(p->funcname);
BUG_ON(!p->jp.kp.addr);
#endif
p++;
}
q = rhooks;
while (q->funcname) {
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,19)
q->rp.kp.symbol_name = q->funcname;
#else
q->rp.kp.addr = (void*)kallsyms_lookup_name(q->funcname);
BUG_ON(!q->rp.kp.addr);
#endif
q++;
}
err = 0;
p = hooks;
while (p->funcname && !err) {
err = register_jprobe(&p->jp);
p++;
}
if (!err) {
q = rhooks;
while (q->funcname && !err) {
err = register_kretprobe(&q->rp);
q++;
}
if (!err)
return 0;
while (--q != rhooks)
unregister_kretprobe(&q->rp);
}
while (--p != hooks)
unregister_jprobe(&p->jp);
return err;
}
static int __init lttng_addons_elv_init(void)
{
int ret;
(void) wrapper_lttng_fixup_sig(THIS_MODULE);
ret = register_jprobe(&elv_jprobe);
if (ret < 0) {
printk("register_jprobe failed, returned %d\n", ret);
goto out;
}
printk("lttng-elv loaded\n");
out:
return ret;
}
static int __init addons_lttng_ovs_upcall_end_init(void)
{
int ret;
// (void) wrapper_lttng_fixup_sig(THIS_MODULE);
ret = register_jprobe(<tng_ovs_upcall_end_jprobe);
if (ret < 0) {
printk("register_jprobe failed, returned %d\n", ret);
goto out;
}
printk("lttng-ovs-upcall-end-probe loaded\n");
out:
return ret;
}
int init_module(void)
{
int ret;
my_jprobe.kp.addr = (kprobe_opcode_t *) kallsyms_lookup_name("do_fork");
if (!my_jprobe.kp.addr) {
printk("Couldn't find %s to plant jprobe\n", "do_fork");
return -1;
}
if ((ret = register_jprobe(&my_jprobe)) <0) {
printk("register_jprobe failed, returned %d\n", ret);
return -1;
}
printk("Planted jprobe at %p, handler addr %p\n",
my_jprobe.kp.addr, my_jprobe.entry);
return 0;
}
static int __init my_init(void)
{
/* set the handler functions */
kp.pre_handler = handler_pre;
kp.post_handler = handler_post;
kp.fault_handler = handler_fault;
kp.symbol_name = "mycdrv_generic_open";
if (register_kprobe(&kp)) {
pr_info("Failed to register kprobe, quitting\n");
return -1;
}
register_jprobe(&jp);
pr_info("plant jprobe at %p, handler addr %p\n", jp.kp.addr, jp.entry);
return 0;
}
int init_module(void)
{
int ret;
printk("Entering: %s\n",__FUNCTION__);
nl_sk_udp=netlink_kernel_create(&init_net, NETLINK_USER, 0, nl_recv_msg_udp, NULL, THIS_MODULE);
my_jprobe_udp.kp.addr =
(kprobe_opcode_t *) kallsyms_lookup_name("udp_sendmsg");
if (!my_jprobe_udp.kp.addr) {
printk("Couldn't find %s to plant jprobe\n", "udp_sendmsg");
return -1;
}
if ((ret = register_jprobe(&my_jprobe_udp)) <0) {
printk("register_jprobe failed, returned %d\n", ret);
return -1;
}
printk("Planted jprobe at %p, handler addr %p\n",
my_jprobe_udp.kp.addr, my_jprobe_udp.entry);
return 0;
}
static int __init jprobe_init(void)
{
int ret;
int i;
for (i = 0; i < sizeof(my_jprobes)/sizeof(struct jprobe); ++i) {
ret = register_jprobe(&my_jprobes[i]);
if (ret < 0) {
printk(KERN_INFO "register_jprobe failed, returned %d for probe %d\n", ret, i);
my_jprobes[i].kp.addr = 0;
cleanup();
return -1;
} else {
printk(KERN_INFO "Planted jprobe at %p, handler addr %p\n",
my_jprobes[i].kp.addr, my_jprobes[i].entry);
}
}
return 0;
}
static int test_jprobe(void)
{
int ret;
ret = register_jprobe(&jp);
if (ret < 0) {
printk(KERN_ERR "Kprobe smoke test failed: "
"register_jprobe returned %d\n", ret);
return ret;
}
ret = target(rand1);
unregister_jprobe(&jp);
if (jph_val == 0) {
printk(KERN_ERR "Kprobe smoke test failed: "
"jprobe handler not called\n");
handler_errors++;
}
return 0;
}
_STATIC int __init socket_notify_init(void)
{
int err;
if ((err = install_hook("IPv4", &inet_family_ops, &hooked_inet_family_ops)))
return err;
if ((err = register_jprobe(&inet_sock_destruct_jprobe)) < 0) {
printk(KERN_ERR "error registering inet_sock_destruct_jprobe\n");
sock_unregister(hooked_inet_family_ops.family);
reinstall_family("IPv4", &inet_family_ops);
return err;
}
#if defined(CONFIG_IPV6)
if ((err = install_hook("IPv6", &inet6_family_ops, &hooked_inet6_family_ops))) {
unregister_jprobe(&inet_sock_destruct_jprobe);
sock_unregister(hooked_inet_family_ops.family);
reinstall_family("IPv4", &inet_family_ops);
return err;
}
#endif
return 0;
}
static int __init jprobe_init(void)
{
int ret;
ret = register_jprobe(&my_jprobe);
if (ret < 0) {
printk(KERN_INFO "register_jprobe failed, returned %d\n", ret);
return -1;
}
printk(KERN_INFO "Planted jprobe at %p, handler addr %p\n",
my_jprobe.kp.addr, my_jprobe.entry);
my_kretprobe.kp.symbol_name = "sys_accept4";
ret = register_kretprobe(&my_kretprobe);
if (ret < 0) {
printk(KERN_INFO "register_kretprobe failed, returned %d\n",
ret);
return -1;
}
printk(KERN_INFO "Planted return probe at %s: %p\n",
my_kretprobe.kp.symbol_name, my_kretprobe.kp.addr);
my_socket_kretprobe.kp.symbol_name = "sys_socket";
ret = register_kretprobe(&my_socket_kretprobe);
if (ret < 0) {
printk(KERN_INFO "register_kretprobe failed, returned %d\n",
ret);
return -1;
}
printk(KERN_INFO "Planted return probe at %s: %p\n",
my_socket_kretprobe.kp.symbol_name, my_socket_kretprobe.kp.addr);
return 0;
}
static int minit(void)
{
int err = 0;
init_hash_parameters();
if (0 > (err = init_some_parameters()))
goto out;
if (0 > (err = alloc_percpu_file()))
goto err_alloc_file;
if (0 > (err = alloc_slab()))
goto err_alloc_slab;
if (0 > (err = alloc_bitmap()))
goto err_bitmap;
if (0 > (err = initial_hash_table_cache()))
goto err_hash_table_cache;
printk(KERN_INFO "Start %s.", THIS_MODULE->name);
if (0 > (err = nf_register_hook(&nf_out_ops))) {
printk(KERN_ERR "Failed to register nf_out %s.\n", THIS_MODULE->name);
goto err_nf_reg_out;
}
if (0 > (err = nf_register_hook(&nf_in_ops))) {
printk(KERN_ERR "Failed to register nf_in %s.\n", THIS_MODULE->name);
goto err_nf_reg_in;
}
if (tcp_alloc_sha1sig_pool() == NULL) {
printk(KERN_ERR "Failed to alloc sha1 pool %s.\n", THIS_MODULE->name);
goto err_sha1siq_pool;
}
err = register_jprobe(&jps_netif_receive_skb);
if (err < 0) {
printk(KERN_ERR "Failed to register jprobe netif_receive_skb %s.\n", THIS_MODULE->name);
goto out;
}
kprobe_in_reged = 1;
goto out;
err_sha1siq_pool:
tcp_free_sha1sig_pool();
err_nf_reg_in:
nf_unregister_hook(&nf_in_ops);
err_nf_reg_out:
nf_unregister_hook(&nf_out_ops);
err_hash_table_cache:
release_hash_table_cache();
err_bitmap:
free_bitmap();
err_alloc_slab:
free_slab();
err_alloc_file:
free_percpu_file();
out:
return err;
}
static int lkdtm_register_cpoint(enum cname which)
{
int ret;
cpoint = CN_INVALID;
if (lkdtm.entry != NULL)
unregister_jprobe(&lkdtm);
switch (which) {
case CN_DIRECT:
lkdtm_do_action(cptype);
return 0;
case CN_INT_HARDWARE_ENTRY:
lkdtm.kp.symbol_name = "do_IRQ";
lkdtm.entry = (kprobe_opcode_t*) jp_do_irq;
break;
case CN_INT_HW_IRQ_EN:
lkdtm.kp.symbol_name = "handle_IRQ_event";
lkdtm.entry = (kprobe_opcode_t*) jp_handle_irq_event;
break;
case CN_INT_TASKLET_ENTRY:
lkdtm.kp.symbol_name = "tasklet_action";
lkdtm.entry = (kprobe_opcode_t*) jp_tasklet_action;
break;
case CN_FS_DEVRW:
lkdtm.kp.symbol_name = "ll_rw_block";
lkdtm.entry = (kprobe_opcode_t*) jp_ll_rw_block;
break;
case CN_MEM_SWAPOUT:
lkdtm.kp.symbol_name = "shrink_inactive_list";
lkdtm.entry = (kprobe_opcode_t*) jp_shrink_inactive_list;
break;
case CN_TIMERADD:
lkdtm.kp.symbol_name = "hrtimer_start";
lkdtm.entry = (kprobe_opcode_t*) jp_hrtimer_start;
break;
case CN_SCSI_DISPATCH_CMD:
lkdtm.kp.symbol_name = "scsi_dispatch_cmd";
lkdtm.entry = (kprobe_opcode_t*) jp_scsi_dispatch_cmd;
break;
case CN_IDE_CORE_CP:
#ifdef CONFIG_IDE
lkdtm.kp.symbol_name = "generic_ide_ioctl";
lkdtm.entry = (kprobe_opcode_t*) jp_generic_ide_ioctl;
#else
pr_info("Crash point not available\n");
return -EINVAL;
#endif
break;
default:
pr_info("Invalid Crash Point\n");
return -EINVAL;
}
cpoint = which;
if ((ret = register_jprobe(&lkdtm)) < 0) {
pr_info("Couldn't register jprobe\n");
cpoint = CN_INVALID;
}
return ret;
}
static int linuxdrv_init(void)
{
int i;
jprobes[0].kp.symbol_name = "proc_fork_connector";
jprobes[0].entry = (void*)linuxdrv_finish_fork;
jprobes[1].kp.symbol_name = "proc_exit_connector";
jprobes[1].entry = (void*)linuxdrv_finish_exit;
jprobes[2].kp.symbol_name = "proc_exec_connector";
jprobes[2].entry = (void*)linuxdrv_finish_exec;
jprobes[3].kp.symbol_name = "vma_link";
jprobes[3].entry = (void*)linuxdrv_insert_vma;
jprobes[4].kp.symbol_name = "vma_adjust";
jprobes[4].entry = (void*)linuxdrv_adjust_vma;
jprobes[5].kp.symbol_name = "remove_vma";
jprobes[5].entry = (void*)linuxdrv_remove_vma;
printk(KERN_INFO
"strName = %s\n" /* entry name */
"init_task_addr = %lu\n" /* address of init_task */
"init_task_size = %lu\n" /* size of task_struct */
"ts_tasks = %lu\n" /* offset of tasks */
"ts_pid = %lu\n" /* offset of pid */
"ts_tgid = %lu\n" /* offset of tgid */
"ts_group_leader = %lu\n" /* offset of group_leader */
"ts_thread_group = %lu\n" /* offset of thread_group */
"ts_real_parent = %lu\n" /* offset of real_parent */
"ts_mm = %lu\n" /* offset of mm */
"ts_stack = %lu\n", /* offset of stack */
UTS_RELEASE,
(unsigned long)&init_task,
(unsigned long)sizeof(init_task),
OFFSET_OF(task_struct, tasks),
OFFSET_OF(task_struct, pid),
OFFSET_OF(task_struct, tgid),
OFFSET_OF(task_struct, group_leader),
OFFSET_OF(task_struct, thread_group),
OFFSET_OF(task_struct, real_parent),
OFFSET_OF(task_struct, mm),
OFFSET_OF(task_struct, stack) // TODO: not sure which field of the union should be filled
);
// cred, real_cred and related fields may not exist in Linux kernel 2.6
printk(KERN_INFO
"ts_real_cred = %lu\n" /* offset of real_cred */
"ts_cred = %lu\n" /* offset of cred */
"ts_comm = %lu\n" /* offset of comm */
"cred_uid = %lu\n" /* offset of uid in cred */
"cred_gid = %lu\n" /* offset of gid in cred */
"cred_euid = %lu\n" /* offset of euid in cred */
"cred_egid = %lu\n", /* offset of egid in cred */
OFFSET_OF(task_struct, real_cred),
OFFSET_OF(task_struct, cred),
OFFSET_OF(task_struct, comm),
OFFSET_OF(cred, uid),
OFFSET_OF(cred, gid),
OFFSET_OF(cred, euid),
OFFSET_OF(cred, egid)
);
printk(KERN_INFO
"mm_mmap = %lu\n" /* offset of mmap in mm_struct */
"mm_pgd = %lu\n" /* offset of pgd in mm_struct */
"mm_arg_start = %lu\n" /* offset of arg_start in mm_struct */
"mm_start_brk = %lu\n" /* offset of start_brk in mm_struct */
"mm_brk = %lu\n" /* offset of brk in mm_struct */
"mm_start_stack = %lu\n", /* offset of start_stack in mm_struct */
OFFSET_OF(mm_struct, mmap),
OFFSET_OF(mm_struct, pgd),
OFFSET_OF(mm_struct, arg_start),
OFFSET_OF(mm_struct, start_brk),
OFFSET_OF(mm_struct, brk),
OFFSET_OF(mm_struct, start_stack)
);
printk(KERN_INFO
"vma_vm_start = %lu\n" /* offset of vm_start in vm_area_struct */
"vma_vm_end = %lu\n" /* offset of vm_end in vm_area_struct */
"vma_vm_next = %lu\n" /* offset of vm_next in vm_area_struct */
"vma_vm_file = %lu\n" /* offset of vm_file in vm_area_struct */
"vma_vm_flags = %lu\n" /* offset of vm_flags in vm_area_struct */
"vma_vm_pgoff = %lu\n", /* offset of vm_pgoff in vm_area_struct */
OFFSET_OF(vm_area_struct, vm_start),
OFFSET_OF(vm_area_struct, vm_end),
OFFSET_OF(vm_area_struct, vm_next),
OFFSET_OF(vm_area_struct, vm_file),
OFFSET_OF(vm_area_struct, vm_flags),
OFFSET_OF(vm_area_struct, vm_pgoff)
);
printk(KERN_INFO
"file_dentry = %lu\n" /* offset of f_dentry in file */
"file_inode = %lu\n" /* inode of file struct */
"dentry_d_name = %lu\n" /* offset of d_name in dentry */
"dentry_d_iname = %lu\n" /* offset of d_iname in dentry */
"dentry_d_parent = %lu\n" /* offset of d_parent in dentry */
"ti_task = %lu\n" /* offset of task in thread_info */
"inode_ino = %lu\n", /* offset of inode index in inode struct */
OFFSET_OF(file, f_dentry),
OFFSET_OF(dentry, d_inode),
OFFSET_OF(dentry, d_name),
OFFSET_OF(dentry, d_iname),
OFFSET_OF(dentry, d_parent),
OFFSET_OF(thread_info, task),
OFFSET_OF(inode,i_ino)
);
for(i = 0; i < JPROBE_TOTAL; i++) {
register_jprobe(&jprobes[i]);
}
for(i = 0; i < JPROBE_TOTAL; i++) {
if(jprobes[i].kp.addr != NULL) {
printk(KERN_INFO
"%s = %lu\n",
jprobes[i].kp.symbol_name,
jprobes[i].kp.addr);
}
}
for(i = 0; i < JPROBE_TOTAL; i++) {
unregister_jprobe(&jprobes[i]);
}
return -1;
}
