#include "ctracer_relay.h"

struct hlist_node;

/* <c04> /home/acme/git/linux-2.6/include/linux/list.h:608 */
struct hlist_node {
	struct hlist_node *        next;                 /*     0     4 */
	struct hlist_node * *      pprev;                /*     4     4 */
}; /* size: 8, cachelines: 1 */
   /* last cacheline: 8 bytes */

struct list_head;

/* <bb8> /home/acme/git/linux-2.6/include/linux/list.h:21 */
struct list_head {
	struct list_head *         next;                 /*     0     4 */
	struct list_head *         prev;                 /*     4     4 */
}; /* size: 8, cachelines: 1 */
   /* last cacheline: 8 bytes */

typedef unsigned char u8;
typedef u8 kprobe_opcode_t;
struct kprobe;
struct pt_regs;

typedef int (*kprobe_pre_handler_t)(struct kprobe *, struct pt_regs *);
typedef void (*kprobe_post_handler_t)(struct kprobe *, struct pt_regs *, long unsigned int);
typedef int (*kprobe_fault_handler_t)(struct kprobe *, struct pt_regs *, int);
typedef int (*kprobe_break_handler_t)(struct kprobe *, struct pt_regs *);
/* <3715> include2/asm/kprobes.h:54 */
struct arch_specific_insn {
	kprobe_opcode_t *          insn;                 /*     0     4 */
	int                        boostable;            /*     4     4 */
}; /* size: 8, cachelines: 1 */
   /* last cacheline: 8 bytes */


/* <3788> include2/asm/kprobes.h:32 */
struct kprobe {
	struct hlist_node          hlist;                /*     0     8 */
	struct list_head           list;                 /*     8     8 */
	unsigned int               mod_refcounted;       /*    16     4 */
	long unsigned int          nmissed;              /*    20     4 */
	kprobe_opcode_t *          addr;                 /*    24     4 */
	char *                     symbol_name;          /*    28     4 */
	unsigned int               offset;               /*    32     4 */
	kprobe_pre_handler_t       pre_handler;          /*    36     4 */
	kprobe_post_handler_t      post_handler;         /*    40     4 */
	kprobe_fault_handler_t     fault_handler;        /*    44     4 */
	kprobe_break_handler_t     break_handler;        /*    48     4 */
	kprobe_opcode_t            opcode;               /*    52     1 */

	/* XXX 3 bytes hole, try to pack */

	struct arch_specific_insn  ainsn;                /*    56     8 */
	/* --- cacheline 1 boundary (64 bytes) --- */
}; /* size: 64, cachelines: 1 */
   /* sum members: 61, holes: 1, sum holes: 3 */


/* <39d8> /home/acme/git/linux-2.6/include/linux/kprobes.h:117 */
struct jprobe {
	struct kprobe              kp;                   /*     0    64 */
	/* --- cacheline 1 boundary (64 bytes) --- */
	kprobe_opcode_t *          entry;                /*    64     4 */
}; /* size: 68, cachelines: 2 */
   /* last cacheline: 4 bytes */

struct kretprobe_instance;

typedef int (*kretprobe_handler_t)(struct kretprobe_instance *, struct pt_regs *);
/* <be7> /home/acme/git/linux-2.6/include/linux/list.h:607 */
struct hlist_head {
	struct hlist_node *        first;                /*     0     4 */
}; /* size: 4, cachelines: 1 */
   /* last cacheline: 4 bytes */


/* <3a00> /home/acme/git/linux-2.6/include/linux/kprobes.h:54 */
struct kretprobe {
	struct kprobe              kp;                   /*     0    64 */
	/* --- cacheline 1 boundary (64 bytes) --- */
	kretprobe_handler_t        handler;              /*    64     4 */
	int                        maxactive;            /*    68     4 */
	int                        nmissed;              /*    72     4 */
	struct hlist_head          free_instances;       /*    76     4 */
	struct hlist_head          used_instances;       /*    80     4 */
}; /* size: 84, cachelines: 2 */
   /* last cacheline: 20 bytes */

/* <53c> include2/asm/ptrace.h:9 */
struct pt_regs {
	long int                   ebx;                  /*     0     4 */
	long int                   ecx;                  /*     4     4 */
	long int                   edx;                  /*     8     4 */
	long int                   esi;                  /*    12     4 */
	long int                   edi;                  /*    16     4 */
	long int                   ebp;                  /*    20     4 */
	long int                   eax;                  /*    24     4 */
	int                        xds;                  /*    28     4 */
	int                        xes;                  /*    32     4 */
	int                        xgs;                  /*    36     4 */
	long int                   orig_eax;             /*    40     4 */
	long int                   eip;                  /*    44     4 */
	int                        xcs;                  /*    48     4 */
	long int                   eflags;               /*    52     4 */
	long int                   esp;                  /*    56     4 */
	int                        xss;                  /*    60     4 */
	/* --- cacheline 1 boundary (64 bytes) --- */
}; /* size: 64, cachelines: 1 */

struct kretprobe;
struct task_struct;

/* <3986> /home/acme/git/linux-2.6/include/linux/kprobes.h:55 */
struct kretprobe_instance {
	struct hlist_node          uflist;               /*     0     8 */
	struct hlist_node          hlist;                /*     8     8 */
	struct kretprobe *         rp;                   /*    16     4 */
	kprobe_opcode_t *          ret_addr;             /*    20     4 */
	struct task_struct *       task;                 /*    24     4 */
}; /* size: 28, cachelines: 1 */
   /* last cacheline: 28 bytes */

/* <d38a> /home/acme/git/linux-2.6/kernel/sched.c:4701 */
void yield(void);

/* <8edf> /home/acme/git/linux-2.6/kernel/printk.c:503 */
int printk(const char  * fmt, ...);

typedef unsigned int __kernel_size_t;
typedef __kernel_size_t size_t;

/* <3b4d> /home/acme/git/linux-2.6/lib/vsprintf.c:537 */
int snprintf(char * buf, size_t size, const char  * fmt, ...);

struct jprobe;

/* <80b5> /home/acme/git/linux-2.6/kernel/kprobes.c:696 */
int register_jprobe(struct jprobe * jp);

/* <852b> /home/acme/git/linux-2.6/kernel/kprobes.c:706 */
void unregister_jprobe(struct jprobe * jp);

struct kretprobe;

/* <8b1a> /home/acme/git/linux-2.6/kernel/kprobes.c:730 */
int register_kretprobe(struct kretprobe * rp);

/* <83e5> /home/acme/git/linux-2.6/kernel/kprobes.c:778 */
void unregister_kretprobe(struct kretprobe * rp);

/* <71c4> /home/acme/git/linux-2.6/arch/i386/kernel/kprobes.c:716 */
void jprobe_return(void);

/* <189f> include2/asm/atomic.h:17 */
typedef struct {
	int                        counter;              /*     0     4 */
} atomic_t; /* size: 4, cachelines: 1 */
   /* last cacheline: 4 bytes */

typedef unsigned int __kernel_uid32_t;
typedef __kernel_uid32_t uid_t;
typedef unsigned int __kernel_gid32_t;
typedef __kernel_gid32_t gid_t;
typedef unsigned int __u32;
typedef __u32 __kernel_dev_t;
typedef __kernel_dev_t dev_t;
typedef long long int __kernel_loff_t;
typedef __kernel_loff_t loff_t;
typedef long int __kernel_time_t;
typedef __kernel_time_t time_t;

/* <1922> /home/acme/git/linux-2.6/include/linux/time.h:12 */
struct timespec {
	time_t                     tv_sec;               /*     0     4 */
	long int                   tv_nsec;              /*     4     4 */
}; /* size: 8, cachelines: 1 */
   /* last cacheline: 8 bytes */

typedef long unsigned int blkcnt_t;
typedef short unsigned int umode_t;
/* <17d1> /home/acme/git/linux-2.6/include/linux/spinlock_types_up.h:18 */
typedef struct {
	volatile unsigned int      slock;                /*     0     4 */
} raw_spinlock_t; /* size: 4, cachelines: 1 */
   /* last cacheline: 4 bytes */


/* <1807> /home/acme/git/linux-2.6/include/linux/spinlock_types.h:20 */
typedef struct {
	raw_spinlock_t             raw_lock;             /*     0     4 */
	unsigned int               magic;                /*     4     4 */
	unsigned int               owner_cpu;            /*     8     4 */
	void *                     owner;                /*    12     4 */
} spinlock_t; /* size: 16, cachelines: 1 */
   /* last cacheline: 16 bytes */


/* <26ec> /home/acme/git/linux-2.6/include/linux/mutex.h:47 */
struct mutex {
	atomic_t                   count;                /*     0     4 */
	spinlock_t                 wait_lock;            /*     4    16 */
	struct list_head           wait_list;            /*    20     8 */
}; /* size: 28, cachelines: 1 */
   /* last cacheline: 28 bytes */


/* <1ae1> /home/acme/git/linux-2.6/include/linux/rwsem.h:19 */
struct rw_semaphore {
	long int                   count;                /*     0     4 */
	spinlock_t                 wait_lock;            /*     4    16 */
	struct list_head           wait_list;            /*    20     8 */
}; /* size: 28, cachelines: 1 */
   /* last cacheline: 28 bytes */

struct inode_operations;
struct file_operations;
struct super_block;
struct file_lock;
struct address_space;
struct inode;
typedef unsigned int gfp_t;
struct radix_tree_node;

/* <4aba> /home/acme/git/linux-2.6/include/linux/radix-tree.h:58 */
struct radix_tree_root {
	unsigned int               height;               /*     0     4 */
	gfp_t                      gfp_mask;             /*     4     4 */
	struct radix_tree_node *   rnode;                /*     8     4 */
}; /* size: 12, cachelines: 1 */
   /* last cacheline: 12 bytes */

/* <17f8> /home/acme/git/linux-2.6/include/linux/spinlock_types_up.h:35 */
typedef struct {
} raw_rwlock_t; /* size: 0, cachelines: 0 */


/* <1853> /home/acme/git/linux-2.6/include/linux/spinlock_types.h:36 */
typedef struct {
	raw_rwlock_t               raw_lock;             /*     0     0 */
	unsigned int               magic;                /*     0     4 */
	unsigned int               owner_cpu;            /*     4     4 */
	void *                     owner;                /*     8     4 */
} rwlock_t; /* size: 12, cachelines: 1 */
   /* last cacheline: 12 bytes */

struct prio_tree_node;

/* <428d> /home/acme/git/linux-2.6/include/linux/prio_tree.h:28 */
struct prio_tree_root {
	struct prio_tree_node *    prio_tree_node;       /*     0     4 */
	short unsigned int         index_bits;           /*     4     2 */
	short unsigned int         raw;                  /*     6     2 */
}; /* size: 8, cachelines: 1 */
   /* last cacheline: 8 bytes */

struct address_space_operations;
struct backing_dev_info;

/* <5605> /home/acme/git/linux-2.6/include/linux/fs.h:395 */
struct address_space {
	struct inode *             host;                 /*     0     4 */
	struct radix_tree_root     page_tree;            /*     4    12 */
	rwlock_t                   tree_lock;            /*    16    12 */
	unsigned int               i_mmap_writable;      /*    28     4 */
	struct prio_tree_root      i_mmap;               /*    32     8 */
	struct list_head           i_mmap_nonlinear;     /*    40     8 */
	spinlock_t                 i_mmap_lock;          /*    48    16 */
	/* --- cacheline 1 boundary (64 bytes) --- */
	unsigned int               truncate_count;       /*    64     4 */
	long unsigned int          nrpages;              /*    68     4 */
	long unsigned int          writeback_index;      /*    72     4 */
	const struct address_space_operations  * a_ops;  /*    76     4 */
	long unsigned int          flags;                /*    80     4 */
	struct backing_dev_info *  backing_dev_info;     /*    84     4 */
	spinlock_t                 private_lock;         /*    88    16 */
	struct list_head           private_list;         /*   104     8 */
	struct address_space *     assoc_mapping;        /*   112     4 */
}; /* size: 116, cachelines: 2 */
   /* last cacheline: 52 bytes */

struct pipe_inode_info;
struct block_device;
struct cdev;

struct dnotify_struct;

/* <4325> /home/acme/git/linux-2.6/include/linux/dcache.h:86 */
struct inode {
	struct hlist_node          i_hash;               /*     0     8 */
	struct list_head           i_list;               /*     8     8 */
	struct list_head           i_sb_list;            /*    16     8 */
	struct list_head           i_dentry;             /*    24     8 */
	long unsigned int          i_ino;                /*    32     4 */
	atomic_t                   i_count;              /*    36     4 */
	unsigned int               i_nlink;              /*    40     4 */
	uid_t                      i_uid;                /*    44     4 */
	gid_t                      i_gid;                /*    48     4 */
	dev_t                      i_rdev;               /*    52     4 */
	long unsigned int          i_version;            /*    56     4 */
	loff_t                     i_size;               /*    60     8 */
	/* --- cacheline 1 boundary (64 bytes) was 4 bytes ago --- */
	struct timespec            i_atime;              /*    68     8 */
	struct timespec            i_mtime;              /*    76     8 */
	struct timespec            i_ctime;              /*    84     8 */
	unsigned int               i_blkbits;            /*    92     4 */
	blkcnt_t                   i_blocks;             /*    96     4 */
	short unsigned int         i_bytes;              /*   100     2 */
	umode_t                    i_mode;               /*   102     2 */
	spinlock_t                 i_lock;               /*   104    16 */
	struct mutex               i_mutex;              /*   120    28 */
	/* --- cacheline 2 boundary (128 bytes) was 20 bytes ago --- */
	struct rw_semaphore        i_alloc_sem;          /*   148    28 */
	struct inode_operations *  i_op;                 /*   176     4 */
	const struct file_operations  * i_fop;           /*   180     4 */
	struct super_block *       i_sb;                 /*   184     4 */
	struct file_lock *         i_flock;              /*   188     4 */
	/* --- cacheline 3 boundary (192 bytes) --- */
	struct address_space *     i_mapping;            /*   192     4 */
	struct address_space       i_data;               /*   196   116 */
	/* --- cacheline 4 boundary (256 bytes) was 56 bytes ago --- */
	struct list_head           i_devices;            /*   312     8 */
	/* --- cacheline 5 boundary (320 bytes) --- */
	union {
		struct pipe_inode_info * i_pipe;         /*           4 */
		struct block_device * i_bdev;            /*           4 */
		struct cdev *      i_cdev;               /*           4 */
	};                                               /*   320     4 */
	int                        i_cindex;             /*   324     4 */
	__u32                      i_generation;         /*   328     4 */
	long unsigned int          i_dnotify_mask;       /*   332     4 */
	struct dnotify_struct *    i_dnotify;            /*   336     4 */
	struct list_head           inotify_watches;      /*   340     8 */
	struct mutex               inotify_mutex;        /*   348    28 */
	long unsigned int          i_state;              /*   376     4 */
	long unsigned int          dirtied_when;         /*   380     4 */
	/* --- cacheline 6 boundary (384 bytes) --- */
	unsigned int               i_flags;              /*   384     4 */
	atomic_t                   i_writecount;         /*   388     4 */
	void *                     i_private;            /*   392     4 */
}; /* size: 396, cachelines: 7 */
   /* last cacheline: 12 bytes */

static int ctracer__class_state(const struct inode *object, char *bf, int len)
{
	return object ?
		snprintf(bf, len,
			 "%u:%u:%u:%u:%u:%u:%u:%u:%u:%u\n",
			 object->i_ino,
			 object->i_nlink,
			 object->i_version,
			 object->i_blkbits,
			 object->i_bytes,
			 object->i_cindex,
			 object->i_dnotify_mask,
			 object->i_state,
			 object->dirtied_when,
			 object->i_flags) :
		snprintf(bf, len, "0:0:0:0:0:0:0:0:0:0\n");
}
struct inode;
struct file;

static int jprobe_entry__ioports_open(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x6f64, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ioports_open = {
	.kp = { .symbol_name = "ioports_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ioports_open,
};

static int jprobe_entry__iomem_open(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x6f07, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__iomem_open = {
	.kp = { .symbol_name = "iomem_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__iomem_open,
};

static int jprobe_entry__proc_opensys(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x78c6, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__proc_opensys = {
	.kp = { .symbol_name = "proc_opensys", },
	.entry = (kprobe_opcode_t *)jprobe_entry__proc_opensys,
};

static int jprobe_entry__futex_close(struct inode * inode, struct file * filp)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7747, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__futex_close = {
	.kp = { .symbol_name = "futex_close", },
	.entry = (kprobe_opcode_t *)jprobe_entry__futex_close,
};

static int jprobe_entry__proc_dma_open(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x6d5c, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__proc_dma_open = {
	.kp = { .symbol_name = "proc_dma_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__proc_dma_open,
};

static int jprobe_entry__kallsyms_open(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x76ee, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__kallsyms_open = {
	.kp = { .symbol_name = "kallsyms_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__kallsyms_open,
};

static int jprobe_entry__kallsyms_release(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7482, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__kallsyms_release = {
	.kp = { .symbol_name = "kallsyms_release", },
	.entry = (kprobe_opcode_t *)jprobe_entry__kallsyms_release,
};

static int jprobe_entry__relay_file_open(struct inode * inode, struct file * filp)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7d05, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__relay_file_open = {
	.kp = { .symbol_name = "relay_file_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__relay_file_open,
};

static int jprobe_entry__relay_file_release(struct inode * inode, struct file * filp)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7cbb, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__relay_file_release = {
	.kp = { .symbol_name = "relay_file_release", },
	.entry = (kprobe_opcode_t *)jprobe_entry__relay_file_release,
};

struct address_space;

static int jprobe_entry__sync_page_range(struct inode * inode, struct address_space * mapping, loff_t pos, loff_t count)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xbb8d, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__sync_page_range = {
	.kp = { .symbol_name = "sync_page_range", },
	.entry = (kprobe_opcode_t *)jprobe_entry__sync_page_range,
};

static int jprobe_entry__sync_page_range_nolock(struct inode * inode, struct address_space * mapping, loff_t pos, loff_t count)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xbb06, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__sync_page_range_nolock = {
	.kp = { .symbol_name = "sync_page_range_nolock", },
	.entry = (kprobe_opcode_t *)jprobe_entry__sync_page_range_nolock,
};

static int jprobe_entry__vmtruncate(struct inode * inode, loff_t offset)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xbf70, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__vmtruncate = {
	.kp = { .symbol_name = "vmtruncate", },
	.entry = (kprobe_opcode_t *)jprobe_entry__vmtruncate,
};

static int jprobe_entry__vmtruncate_range(struct inode * inode, loff_t offset, loff_t end)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xa30f, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__vmtruncate_range = {
	.kp = { .symbol_name = "vmtruncate_range", },
	.entry = (kprobe_opcode_t *)jprobe_entry__vmtruncate_range,
};

static void jprobe_entry__shmem_destroy_inode(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xb868, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__shmem_destroy_inode = {
	.kp = { .symbol_name = "shmem_destroy_inode", },
	.entry = (kprobe_opcode_t *)jprobe_entry__shmem_destroy_inode,
};

static void jprobe_entry__shmem_delete_inode(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xb668, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__shmem_delete_inode = {
	.kp = { .symbol_name = "shmem_delete_inode", },
	.entry = (kprobe_opcode_t *)jprobe_entry__shmem_delete_inode,
};

struct page;
/* <9614> /home/acme/git/linux-2.6/mm/shmem.c:80 */
enum sgp_type {
	SGP_QUICK = 0,
	SGP_READ = 1,
	SGP_CACHE = 2,
	SGP_WRITE = 3,
};

static int jprobe_entry__shmem_getpage(struct inode * inode, long unsigned int idx, struct page * * pagep, enum sgp_type sgp, int * type)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xaaf0, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__shmem_getpage = {
	.kp = { .symbol_name = "shmem_getpage", },
	.entry = (kprobe_opcode_t *)jprobe_entry__shmem_getpage,
};

static void jprobe_entry__shmem_truncate(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xa81c, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__shmem_truncate = {
	.kp = { .symbol_name = "shmem_truncate", },
	.entry = (kprobe_opcode_t *)jprobe_entry__shmem_truncate,
};

static void jprobe_entry__shmem_truncate_range(struct inode * inode, loff_t start, loff_t end)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xa414, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__shmem_truncate_range = {
	.kp = { .symbol_name = "shmem_truncate_range", },
	.entry = (kprobe_opcode_t *)jprobe_entry__shmem_truncate_range,
};

static void jprobe_entry__shmem_recalc_inode(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xa278, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__shmem_recalc_inode = {
	.kp = { .symbol_name = "shmem_recalc_inode", },
	.entry = (kprobe_opcode_t *)jprobe_entry__shmem_recalc_inode,
};

static void jprobe_entry__shmem_free_blocks(struct inode * inode, long int pages)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xa21d, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__shmem_free_blocks = {
	.kp = { .symbol_name = "shmem_free_blocks", },
	.entry = (kprobe_opcode_t *)jprobe_entry__shmem_free_blocks,
};

static int jprobe_entry__nonseekable_open(struct inode * inode, struct file * filp)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x8697, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__nonseekable_open = {
	.kp = { .symbol_name = "nonseekable_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__nonseekable_open,
};

static int jprobe_entry__generic_file_open(struct inode * inode, struct file * filp)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x865a, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__generic_file_open = {
	.kp = { .symbol_name = "generic_file_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__generic_file_open,
};

static int jprobe_entry__chrdev_open(struct inode * inode, struct file * filp)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x73df, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__chrdev_open = {
	.kp = { .symbol_name = "chrdev_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__chrdev_open,
};

static void jprobe_entry__cd_forget(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x70eb, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__cd_forget = {
	.kp = { .symbol_name = "cd_forget", },
	.entry = (kprobe_opcode_t *)jprobe_entry__cd_forget,
};

static void jprobe_entry__inode_add_bytes(struct inode * inode, loff_t bytes)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x76ce, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__inode_add_bytes = {
	.kp = { .symbol_name = "inode_add_bytes", },
	.entry = (kprobe_opcode_t *)jprobe_entry__inode_add_bytes,
};

static void jprobe_entry__inode_sub_bytes(struct inode * inode, loff_t bytes)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7693, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__inode_sub_bytes = {
	.kp = { .symbol_name = "inode_sub_bytes", },
	.entry = (kprobe_opcode_t *)jprobe_entry__inode_sub_bytes,
};

static loff_t jprobe_entry__inode_get_bytes(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7654, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__inode_get_bytes = {
	.kp = { .symbol_name = "inode_get_bytes", },
	.entry = (kprobe_opcode_t *)jprobe_entry__inode_get_bytes,
};

static void jprobe_entry__inode_set_bytes(struct inode * inode, loff_t bytes)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x761b, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__inode_set_bytes = {
	.kp = { .symbol_name = "inode_set_bytes", },
	.entry = (kprobe_opcode_t *)jprobe_entry__inode_set_bytes,
};

struct kstat;

static void jprobe_entry__generic_fillattr(struct inode * inode, struct kstat * stat)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x757c, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__generic_fillattr = {
	.kp = { .symbol_name = "generic_fillattr", },
	.entry = (kprobe_opcode_t *)jprobe_entry__generic_fillattr,
};

static struct pipe_inode_info * jprobe_entry__alloc_pipe_info(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x80e3, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__alloc_pipe_info = {
	.kp = { .symbol_name = "alloc_pipe_info", },
	.entry = (kprobe_opcode_t *)jprobe_entry__alloc_pipe_info,
};

static int jprobe_entry__pipe_read_release(struct inode * inode, struct file * filp)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x80a5, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__pipe_read_release = {
	.kp = { .symbol_name = "pipe_read_release", },
	.entry = (kprobe_opcode_t *)jprobe_entry__pipe_read_release,
};

static int jprobe_entry__pipe_write_release(struct inode * inode, struct file * filp)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x8067, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__pipe_write_release = {
	.kp = { .symbol_name = "pipe_write_release", },
	.entry = (kprobe_opcode_t *)jprobe_entry__pipe_write_release,
};

static int jprobe_entry__pipe_rdwr_release(struct inode * inode, struct file * filp)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x8011, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__pipe_rdwr_release = {
	.kp = { .symbol_name = "pipe_rdwr_release", },
	.entry = (kprobe_opcode_t *)jprobe_entry__pipe_rdwr_release,
};

static int jprobe_entry__pipe_release(struct inode * inode, int decr, int decw)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7fb3, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__pipe_release = {
	.kp = { .symbol_name = "pipe_release", },
	.entry = (kprobe_opcode_t *)jprobe_entry__pipe_release,
};

static void jprobe_entry__free_pipe_info(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7f45, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__free_pipe_info = {
	.kp = { .symbol_name = "free_pipe_info", },
	.entry = (kprobe_opcode_t *)jprobe_entry__free_pipe_info,
};

static int jprobe_entry__pipe_ioctl(struct inode * pino, struct file * filp, unsigned int cmd, long unsigned int arg)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(pino, __ctracer__st__, 256);
	ctracer__method_entry(0x7ca9, pino, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__pipe_ioctl = {
	.kp = { .symbol_name = "pipe_ioctl", },
	.entry = (kprobe_opcode_t *)jprobe_entry__pipe_ioctl,
};

static int jprobe_entry__pipe_read_open(struct inode * inode, struct file * filp)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7b18, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__pipe_read_open = {
	.kp = { .symbol_name = "pipe_read_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__pipe_read_open,
};

static int jprobe_entry__pipe_write_open(struct inode * inode, struct file * filp)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7ada, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__pipe_write_open = {
	.kp = { .symbol_name = "pipe_write_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__pipe_write_open,
};

static int jprobe_entry__pipe_rdwr_open(struct inode * inode, struct file * filp)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7a9c, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__pipe_rdwr_open = {
	.kp = { .symbol_name = "pipe_rdwr_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__pipe_rdwr_open,
};

struct dentry;

static int jprobe_entry__vfs_rmdir(struct inode * dir, struct dentry * dentry)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x92ab, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__vfs_rmdir = {
	.kp = { .symbol_name = "vfs_rmdir", },
	.entry = (kprobe_opcode_t *)jprobe_entry__vfs_rmdir,
};

static int jprobe_entry__vfs_unlink(struct inode * dir, struct dentry * dentry)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x925c, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__vfs_unlink = {
	.kp = { .symbol_name = "vfs_unlink", },
	.entry = (kprobe_opcode_t *)jprobe_entry__vfs_unlink,
};

static int jprobe_entry__vfs_rename(struct inode * old_dir, struct dentry * old_dentry, struct inode * new_dir, struct dentry * new_dentry)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(old_dir, __ctracer__st__, 256);
	ctracer__method_entry(0x9031, old_dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__vfs_rename = {
	.kp = { .symbol_name = "vfs_rename", },
	.entry = (kprobe_opcode_t *)jprobe_entry__vfs_rename,
};

static int jprobe_entry__may_delete(struct inode * dir, struct dentry * victim, int isdir)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x8ed0, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__may_delete = {
	.kp = { .symbol_name = "may_delete", },
	.entry = (kprobe_opcode_t *)jprobe_entry__may_delete,
};

struct nameidata;

static int jprobe_entry__vfs_create(struct inode * dir, struct dentry * dentry, int mode, struct nameidata * nd)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x8e0d, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__vfs_create = {
	.kp = { .symbol_name = "vfs_create", },
	.entry = (kprobe_opcode_t *)jprobe_entry__vfs_create,
};

static int jprobe_entry__vfs_mknod(struct inode * dir, struct dentry * dentry, int mode, dev_t dev)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x8d4d, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__vfs_mknod = {
	.kp = { .symbol_name = "vfs_mknod", },
	.entry = (kprobe_opcode_t *)jprobe_entry__vfs_mknod,
};

static int jprobe_entry__vfs_mkdir(struct inode * dir, struct dentry * dentry, int mode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x8c99, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__vfs_mkdir = {
	.kp = { .symbol_name = "vfs_mkdir", },
	.entry = (kprobe_opcode_t *)jprobe_entry__vfs_mkdir,
};

static int jprobe_entry__vfs_symlink(struct inode * dir, struct dentry * dentry, const char  * oldname, int mode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x8bd6, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__vfs_symlink = {
	.kp = { .symbol_name = "vfs_symlink", },
	.entry = (kprobe_opcode_t *)jprobe_entry__vfs_symlink,
};

static int jprobe_entry__vfs_link(struct dentry * old_dentry, struct inode * dir, struct dentry * new_dentry)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x8b12, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__vfs_link = {
	.kp = { .symbol_name = "vfs_link", },
	.entry = (kprobe_opcode_t *)jprobe_entry__vfs_link,
};

static int jprobe_entry__permission(struct inode * inode, int mask, struct nameidata * nd)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x8a9b, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__permission = {
	.kp = { .symbol_name = "permission", },
	.entry = (kprobe_opcode_t *)jprobe_entry__permission,
};

static int jprobe_entry__generic_permission(struct inode * inode, int mask, int (*check_acl)(struct inode *, int))
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x89f6, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__generic_permission = {
	.kp = { .symbol_name = "generic_permission", },
	.entry = (kprobe_opcode_t *)jprobe_entry__generic_permission,
};

static int jprobe_entry__get_write_access(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x86b8, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__get_write_access = {
	.kp = { .symbol_name = "get_write_access", },
	.entry = (kprobe_opcode_t *)jprobe_entry__get_write_access,
};

static int jprobe_entry__page_symlink(struct inode * inode, const char  * symname, int len)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x813f, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__page_symlink = {
	.kp = { .symbol_name = "page_symlink", },
	.entry = (kprobe_opcode_t *)jprobe_entry__page_symlink,
};

static int jprobe_entry____page_symlink(struct inode * inode, const char  * symname, int len, gfp_t gfp_mask)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7f8a, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe____page_symlink = {
	.kp = { .symbol_name = "__page_symlink", },
	.entry = (kprobe_opcode_t *)jprobe_entry____page_symlink,
};

static int jprobe_entry__fifo_open(struct inode * inode, struct file * filp)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x65ff, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__fifo_open = {
	.kp = { .symbol_name = "fifo_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__fifo_open,
};

static void jprobe_entry__wait_for_partner(struct inode * inode, unsigned int * cnt)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x6527, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__wait_for_partner = {
	.kp = { .symbol_name = "wait_for_partner", },
	.entry = (kprobe_opcode_t *)jprobe_entry__wait_for_partner,
};

static void jprobe_entry__wake_up_partner(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x64ff, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__wake_up_partner = {
	.kp = { .symbol_name = "wake_up_partner", },
	.entry = (kprobe_opcode_t *)jprobe_entry__wake_up_partner,
};

static int jprobe_entry__locks_mandatory_area(int read_write, struct inode * inode, struct file * filp, loff_t offset, size_t count)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x9009, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__locks_mandatory_area = {
	.kp = { .symbol_name = "locks_mandatory_area", },
	.entry = (kprobe_opcode_t *)jprobe_entry__locks_mandatory_area,
};

static int jprobe_entry____break_lease(struct inode * inode, unsigned int mode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x8677, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe____break_lease = {
	.kp = { .symbol_name = "__break_lease", },
	.entry = (kprobe_opcode_t *)jprobe_entry____break_lease,
};

static int jprobe_entry__locks_mandatory_locked(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x84e7, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__locks_mandatory_locked = {
	.kp = { .symbol_name = "locks_mandatory_locked", },
	.entry = (kprobe_opcode_t *)jprobe_entry__locks_mandatory_locked,
};

struct timespec;

static void jprobe_entry__lease_get_mtime(struct inode * inode, struct timespec * time)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x82c3, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__lease_get_mtime = {
	.kp = { .symbol_name = "lease_get_mtime", },
	.entry = (kprobe_opcode_t *)jprobe_entry__lease_get_mtime,
};

static int jprobe_entry____posix_lock_file_conf(struct inode * inode, struct file_lock * request, struct file_lock * conflock)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7e15, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe____posix_lock_file_conf = {
	.kp = { .symbol_name = "__posix_lock_file_conf", },
	.entry = (kprobe_opcode_t *)jprobe_entry____posix_lock_file_conf,
};

static void jprobe_entry__time_out_leases(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7a62, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__time_out_leases = {
	.kp = { .symbol_name = "time_out_leases", },
	.entry = (kprobe_opcode_t *)jprobe_entry__time_out_leases,
};

static int jprobe_entry__lock_may_write(struct inode * inode, loff_t start, long unsigned int len)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x76d8, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__lock_may_write = {
	.kp = { .symbol_name = "lock_may_write", },
	.entry = (kprobe_opcode_t *)jprobe_entry__lock_may_write,
};

static int jprobe_entry__lock_may_read(struct inode * inode, loff_t start, long unsigned int len)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x766c, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__lock_may_read = {
	.kp = { .symbol_name = "lock_may_read", },
	.entry = (kprobe_opcode_t *)jprobe_entry__lock_may_read,
};

static struct dentry * jprobe_entry__d_splice_alias(struct inode * inode, struct dentry * dentry)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xa317, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__d_splice_alias = {
	.kp = { .symbol_name = "d_splice_alias", },
	.entry = (kprobe_opcode_t *)jprobe_entry__d_splice_alias,
};

static struct dentry * jprobe_entry__d_materialise_unique(struct dentry * dentry, struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x9c45, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__d_materialise_unique = {
	.kp = { .symbol_name = "d_materialise_unique", },
	.entry = (kprobe_opcode_t *)jprobe_entry__d_materialise_unique,
};

static void jprobe_entry__d_prune_aliases(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x99c3, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__d_prune_aliases = {
	.kp = { .symbol_name = "d_prune_aliases", },
	.entry = (kprobe_opcode_t *)jprobe_entry__d_prune_aliases,
};

static struct dentry * jprobe_entry__d_instantiate_unique(struct dentry * entry, struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x9974, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__d_instantiate_unique = {
	.kp = { .symbol_name = "d_instantiate_unique", },
	.entry = (kprobe_opcode_t *)jprobe_entry__d_instantiate_unique,
};

static struct dentry * jprobe_entry__d_alloc_anon(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x911b, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__d_alloc_anon = {
	.kp = { .symbol_name = "d_alloc_anon", },
	.entry = (kprobe_opcode_t *)jprobe_entry__d_alloc_anon,
};

static struct dentry * jprobe_entry__d_alloc_root(struct inode * root_inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(root_inode, __ctracer__st__, 256);
	ctracer__method_entry(0x8e6d, root_inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__d_alloc_root = {
	.kp = { .symbol_name = "d_alloc_root", },
	.entry = (kprobe_opcode_t *)jprobe_entry__d_alloc_root,
};

static void jprobe_entry__d_instantiate(struct dentry * entry, struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x8b67, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__d_instantiate = {
	.kp = { .symbol_name = "d_instantiate", },
	.entry = (kprobe_opcode_t *)jprobe_entry__d_instantiate,
};

static struct dentry * jprobe_entry____d_instantiate_unique(struct dentry * entry, struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x8a69, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe____d_instantiate_unique = {
	.kp = { .symbol_name = "__d_instantiate_unique", },
	.entry = (kprobe_opcode_t *)jprobe_entry____d_instantiate_unique,
};

static struct dentry * jprobe_entry__d_find_alias(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7e74, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__d_find_alias = {
	.kp = { .symbol_name = "d_find_alias", },
	.entry = (kprobe_opcode_t *)jprobe_entry__d_find_alias,
};

static struct dentry * jprobe_entry____d_find_alias(struct inode * inode, int want_discon)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7a5f, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe____d_find_alias = {
	.kp = { .symbol_name = "__d_find_alias", },
	.entry = (kprobe_opcode_t *)jprobe_entry____d_find_alias,
};

static void jprobe_entry__inode_init_once(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x9035, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__inode_init_once = {
	.kp = { .symbol_name = "inode_init_once", },
	.entry = (kprobe_opcode_t *)jprobe_entry__inode_init_once,
};

static void jprobe_entry__generic_drop_inode(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x8974, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__generic_drop_inode = {
	.kp = { .symbol_name = "generic_drop_inode", },
	.entry = (kprobe_opcode_t *)jprobe_entry__generic_drop_inode,
};

static void jprobe_entry__generic_delete_inode(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x87a4, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__generic_delete_inode = {
	.kp = { .symbol_name = "generic_delete_inode", },
	.entry = (kprobe_opcode_t *)jprobe_entry__generic_delete_inode,
};

static void jprobe_entry__clear_inode(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x872b, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__clear_inode = {
	.kp = { .symbol_name = "clear_inode", },
	.entry = (kprobe_opcode_t *)jprobe_entry__clear_inode,
};

static void jprobe_entry__destroy_inode(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x824a, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__destroy_inode = {
	.kp = { .symbol_name = "destroy_inode", },
	.entry = (kprobe_opcode_t *)jprobe_entry__destroy_inode,
};

static void jprobe_entry____wait_on_freeing_inode(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7d38, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe____wait_on_freeing_inode = {
	.kp = { .symbol_name = "__wait_on_freeing_inode", },
	.entry = (kprobe_opcode_t *)jprobe_entry____wait_on_freeing_inode,
};

static void jprobe_entry__iput(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7cc6, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__iput = {
	.kp = { .symbol_name = "iput", },
	.entry = (kprobe_opcode_t *)jprobe_entry__iput,
};

static void jprobe_entry__unlock_new_inode(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7c6c, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__unlock_new_inode = {
	.kp = { .symbol_name = "unlock_new_inode", },
	.entry = (kprobe_opcode_t *)jprobe_entry__unlock_new_inode,
};

static void jprobe_entry__wake_up_inode(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7c41, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__wake_up_inode = {
	.kp = { .symbol_name = "wake_up_inode", },
	.entry = (kprobe_opcode_t *)jprobe_entry__wake_up_inode,
};

static struct inode * jprobe_entry__igrab(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7c12, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__igrab = {
	.kp = { .symbol_name = "igrab", },
	.entry = (kprobe_opcode_t *)jprobe_entry__igrab,
};

static void jprobe_entry____iget(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7b76, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe____iget = {
	.kp = { .symbol_name = "__iget", },
	.entry = (kprobe_opcode_t *)jprobe_entry____iget,
};

static void jprobe_entry__inode_double_unlock(struct inode * inode1, struct inode * inode2)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode1, __ctracer__st__, 256);
	ctracer__method_entry(0x7b3b, inode1, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__inode_double_unlock = {
	.kp = { .symbol_name = "inode_double_unlock", },
	.entry = (kprobe_opcode_t *)jprobe_entry__inode_double_unlock,
};

static void jprobe_entry____insert_inode_hash(struct inode * inode, long unsigned int hashval)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7aca, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe____insert_inode_hash = {
	.kp = { .symbol_name = "__insert_inode_hash", },
	.entry = (kprobe_opcode_t *)jprobe_entry____insert_inode_hash,
};

static void jprobe_entry__remove_inode_hash(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7a27, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__remove_inode_hash = {
	.kp = { .symbol_name = "remove_inode_hash", },
	.entry = (kprobe_opcode_t *)jprobe_entry__remove_inode_hash,
};

static void jprobe_entry__inode_double_lock(struct inode * inode1, struct inode * inode2)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode1, __ctracer__st__, 256);
	ctracer__method_entry(0x79ec, inode1, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__inode_double_lock = {
	.kp = { .symbol_name = "inode_double_lock", },
	.entry = (kprobe_opcode_t *)jprobe_entry__inode_double_lock,
};

static void jprobe_entry__init_special_inode(struct inode * inode, umode_t mode, dev_t rdev)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x793d, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__init_special_inode = {
	.kp = { .symbol_name = "init_special_inode", },
	.entry = (kprobe_opcode_t *)jprobe_entry__init_special_inode,
};

static int jprobe_entry__inode_needs_sync(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x78e0, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__inode_needs_sync = {
	.kp = { .symbol_name = "inode_needs_sync", },
	.entry = (kprobe_opcode_t *)jprobe_entry__inode_needs_sync,
};

typedef long long unsigned int u64;
typedef u64 sector_t;

static sector_t jprobe_entry__bmap(struct inode * inode, sector_t block)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7891, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__bmap = {
	.kp = { .symbol_name = "bmap", },
	.entry = (kprobe_opcode_t *)jprobe_entry__bmap,
};

struct iattr;

static int jprobe_entry__inode_setattr(struct inode * inode, struct iattr * attr)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7163, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__inode_setattr = {
	.kp = { .symbol_name = "inode_setattr", },
	.entry = (kprobe_opcode_t *)jprobe_entry__inode_setattr,
};

static int jprobe_entry__inode_change_ok(struct inode * inode, struct iattr * attr)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x705f, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__inode_change_ok = {
	.kp = { .symbol_name = "inode_change_ok", },
	.entry = (kprobe_opcode_t *)jprobe_entry__inode_change_ok,
};

static void jprobe_entry__make_bad_inode(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x76e7, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__make_bad_inode = {
	.kp = { .symbol_name = "make_bad_inode", },
	.entry = (kprobe_opcode_t *)jprobe_entry__make_bad_inode,
};

static int jprobe_entry__is_bad_inode(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x76b8, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__is_bad_inode = {
	.kp = { .symbol_name = "is_bad_inode", },
	.entry = (kprobe_opcode_t *)jprobe_entry__is_bad_inode,
};

static int jprobe_entry__bad_inode_permission(struct inode * inode, int mask, struct nameidata * nd)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x74a5, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__bad_inode_permission = {
	.kp = { .symbol_name = "bad_inode_permission", },
	.entry = (kprobe_opcode_t *)jprobe_entry__bad_inode_permission,
};

static int jprobe_entry__bad_inode_rename(struct inode * old_dir, struct dentry * old_dentry, struct inode * new_dir, struct dentry * new_dentry)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(old_dir, __ctracer__st__, 256);
	ctracer__method_entry(0x740b, old_dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__bad_inode_rename = {
	.kp = { .symbol_name = "bad_inode_rename", },
	.entry = (kprobe_opcode_t *)jprobe_entry__bad_inode_rename,
};

static int jprobe_entry__bad_inode_mknod(struct inode * dir, struct dentry * dentry, int mode, dev_t rdev)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x73b7, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__bad_inode_mknod = {
	.kp = { .symbol_name = "bad_inode_mknod", },
	.entry = (kprobe_opcode_t *)jprobe_entry__bad_inode_mknod,
};

static int jprobe_entry__bad_inode_rmdir(struct inode * dir, struct dentry * dentry)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x737e, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__bad_inode_rmdir = {
	.kp = { .symbol_name = "bad_inode_rmdir", },
	.entry = (kprobe_opcode_t *)jprobe_entry__bad_inode_rmdir,
};

static int jprobe_entry__bad_inode_mkdir(struct inode * dir, struct dentry * dentry, int mode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x7338, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__bad_inode_mkdir = {
	.kp = { .symbol_name = "bad_inode_mkdir", },
	.entry = (kprobe_opcode_t *)jprobe_entry__bad_inode_mkdir,
};

static int jprobe_entry__bad_inode_symlink(struct inode * dir, struct dentry * dentry, const char  * symname)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x72f2, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__bad_inode_symlink = {
	.kp = { .symbol_name = "bad_inode_symlink", },
	.entry = (kprobe_opcode_t *)jprobe_entry__bad_inode_symlink,
};

static int jprobe_entry__bad_inode_unlink(struct inode * dir, struct dentry * dentry)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x72b9, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__bad_inode_unlink = {
	.kp = { .symbol_name = "bad_inode_unlink", },
	.entry = (kprobe_opcode_t *)jprobe_entry__bad_inode_unlink,
};

static int jprobe_entry__bad_inode_link(struct dentry * old_dentry, struct inode * dir, struct dentry * dentry)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x7273, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__bad_inode_link = {
	.kp = { .symbol_name = "bad_inode_link", },
	.entry = (kprobe_opcode_t *)jprobe_entry__bad_inode_link,
};

static struct dentry * jprobe_entry__bad_inode_lookup(struct inode * dir, struct dentry * dentry, struct nameidata * nd)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x722e, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__bad_inode_lookup = {
	.kp = { .symbol_name = "bad_inode_lookup", },
	.entry = (kprobe_opcode_t *)jprobe_entry__bad_inode_lookup,
};

static int jprobe_entry__bad_inode_create(struct inode * dir, struct dentry * dentry, int mode, struct nameidata * nd)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x71be, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__bad_inode_create = {
	.kp = { .symbol_name = "bad_inode_create", },
	.entry = (kprobe_opcode_t *)jprobe_entry__bad_inode_create,
};

static int jprobe_entry__bad_file_release(struct inode * inode, struct file * filp)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x6ddc, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__bad_file_release = {
	.kp = { .symbol_name = "bad_file_release", },
	.entry = (kprobe_opcode_t *)jprobe_entry__bad_file_release,
};

static int jprobe_entry__bad_file_open(struct inode * inode, struct file * filp)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x6d6b, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__bad_file_open = {
	.kp = { .symbol_name = "bad_file_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__bad_file_open,
};

static int jprobe_entry__bad_file_ioctl(struct inode * inode, struct file * filp, unsigned int cmd, long unsigned int arg)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x6c52, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__bad_file_ioctl = {
	.kp = { .symbol_name = "bad_file_ioctl", },
	.entry = (kprobe_opcode_t *)jprobe_entry__bad_file_ioctl,
};

static int jprobe_entry__single_release(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x6f1b, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__single_release = {
	.kp = { .symbol_name = "single_release", },
	.entry = (kprobe_opcode_t *)jprobe_entry__single_release,
};

static int jprobe_entry__seq_release_private(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x6ecc, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__seq_release_private = {
	.kp = { .symbol_name = "seq_release_private", },
	.entry = (kprobe_opcode_t *)jprobe_entry__seq_release_private,
};

static int jprobe_entry__seq_release(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x6e7f, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__seq_release = {
	.kp = { .symbol_name = "seq_release", },
	.entry = (kprobe_opcode_t *)jprobe_entry__seq_release,
};

static int jprobe_entry__xattr_permission(struct inode * inode, const char  * name, int mask)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7625, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__xattr_permission = {
	.kp = { .symbol_name = "xattr_permission", },
	.entry = (kprobe_opcode_t *)jprobe_entry__xattr_permission,
};

static struct dentry * jprobe_entry__simple_lookup(struct inode * dir, struct dentry * dentry, struct nameidata * nd)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x8495, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__simple_lookup = {
	.kp = { .symbol_name = "simple_lookup", },
	.entry = (kprobe_opcode_t *)jprobe_entry__simple_lookup,
};

static int jprobe_entry__simple_rename(struct inode * old_dir, struct dentry * old_dentry, struct inode * new_dir, struct dentry * new_dentry)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(old_dir, __ctracer__st__, 256);
	ctracer__method_entry(0x8128, old_dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__simple_rename = {
	.kp = { .symbol_name = "simple_rename", },
	.entry = (kprobe_opcode_t *)jprobe_entry__simple_rename,
};

static int jprobe_entry__simple_rmdir(struct inode * dir, struct dentry * dentry)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x80b5, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__simple_rmdir = {
	.kp = { .symbol_name = "simple_rmdir", },
	.entry = (kprobe_opcode_t *)jprobe_entry__simple_rmdir,
};

static int jprobe_entry__simple_link(struct dentry * old_dentry, struct inode * dir, struct dentry * dentry)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x8002, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__simple_link = {
	.kp = { .symbol_name = "simple_link", },
	.entry = (kprobe_opcode_t *)jprobe_entry__simple_link,
};

static int jprobe_entry__dcache_dir_open(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7ae9, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__dcache_dir_open = {
	.kp = { .symbol_name = "dcache_dir_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__dcache_dir_open,
};

static int jprobe_entry__dcache_dir_close(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x78fd, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__dcache_dir_close = {
	.kp = { .symbol_name = "dcache_dir_close", },
	.entry = (kprobe_opcode_t *)jprobe_entry__dcache_dir_close,
};

static int jprobe_entry__simple_unlink(struct inode * dir, struct dentry * dentry)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x7898, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__simple_unlink = {
	.kp = { .symbol_name = "simple_unlink", },
	.entry = (kprobe_opcode_t *)jprobe_entry__simple_unlink,
};

static int jprobe_entry__simple_transaction_release(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x753d, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__simple_transaction_release = {
	.kp = { .symbol_name = "simple_transaction_release", },
	.entry = (kprobe_opcode_t *)jprobe_entry__simple_transaction_release,
};

static int jprobe_entry__simple_attr_open(struct inode * inode, struct file * file, u64 (*get)(void *), void (*set)(void *, u64), const char  * fmt)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7492, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__simple_attr_open = {
	.kp = { .symbol_name = "simple_attr_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__simple_attr_open,
};

static int jprobe_entry__simple_attr_close(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7419, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__simple_attr_close = {
	.kp = { .symbol_name = "simple_attr_close", },
	.entry = (kprobe_opcode_t *)jprobe_entry__simple_attr_close,
};

static void jprobe_entry____mark_inode_dirty(struct inode * inode, int flags)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x9d65, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe____mark_inode_dirty = {
	.kp = { .symbol_name = "__mark_inode_dirty", },
	.entry = (kprobe_opcode_t *)jprobe_entry____mark_inode_dirty,
};

static int jprobe_entry__generic_osync_inode(struct inode * inode, struct address_space * mapping, int what)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x982d, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__generic_osync_inode = {
	.kp = { .symbol_name = "generic_osync_inode", },
	.entry = (kprobe_opcode_t *)jprobe_entry__generic_osync_inode,
};

static int jprobe_entry__write_inode_now(struct inode * inode, int sync)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x977a, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__write_inode_now = {
	.kp = { .symbol_name = "write_inode_now", },
	.entry = (kprobe_opcode_t *)jprobe_entry__write_inode_now,
};

struct writeback_control;

static int jprobe_entry__sync_inode(struct inode * inode, struct writeback_control * wbc)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x972b, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__sync_inode = {
	.kp = { .symbol_name = "sync_inode", },
	.entry = (kprobe_opcode_t *)jprobe_entry__sync_inode,
};

static int jprobe_entry____writeback_single_inode(struct inode * inode, struct writeback_control * wbc)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x9465, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe____writeback_single_inode = {
	.kp = { .symbol_name = "__writeback_single_inode", },
	.entry = (kprobe_opcode_t *)jprobe_entry____writeback_single_inode,
};

static void jprobe_entry__fsstack_copy_attr_all(struct inode * dest, const struct inode  * src, int (*get_nlinks)(struct inode *))
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dest, __ctracer__st__, 256);
	ctracer__method_entry(0x6a58, dest, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__fsstack_copy_attr_all = {
	.kp = { .symbol_name = "fsstack_copy_attr_all", },
	.entry = (kprobe_opcode_t *)jprobe_entry__fsstack_copy_attr_all,
};

static void jprobe_entry__fsstack_copy_inode_size(struct inode * dst, const struct inode  * src)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dst, __ctracer__st__, 256);
	ctracer__method_entry(0x6a0c, dst, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__fsstack_copy_inode_size = {
	.kp = { .symbol_name = "fsstack_copy_inode_size", },
	.entry = (kprobe_opcode_t *)jprobe_entry__fsstack_copy_inode_size,
};

static void jprobe_entry__invalidate_inode_buffers(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xee14, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__invalidate_inode_buffers = {
	.kp = { .symbol_name = "invalidate_inode_buffers", },
	.entry = (kprobe_opcode_t *)jprobe_entry__invalidate_inode_buffers,
};

static int jprobe_entry__remove_inode_buffers(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xe2a9, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__remove_inode_buffers = {
	.kp = { .symbol_name = "remove_inode_buffers", },
	.entry = (kprobe_opcode_t *)jprobe_entry__remove_inode_buffers,
};

struct buffer_head;

static void jprobe_entry__mark_buffer_dirty_inode(struct buffer_head * bh, struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xe1f7, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__mark_buffer_dirty_inode = {
	.kp = { .symbol_name = "mark_buffer_dirty_inode", },
	.entry = (kprobe_opcode_t *)jprobe_entry__mark_buffer_dirty_inode,
};

typedef int (get_block_t)(struct inode *, sector_t, struct buffer_head *, int);

static int jprobe_entry____block_write_full_page(struct inode * inode, struct page * page, get_block_t * get_block, struct writeback_control * wbc)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xce32, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe____block_write_full_page = {
	.kp = { .symbol_name = "__block_write_full_page", },
	.entry = (kprobe_opcode_t *)jprobe_entry____block_write_full_page,
};

static int jprobe_entry____block_prepare_write(struct inode * inode, struct page * page, unsigned int from, unsigned int to, get_block_t * get_block)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xc5e3, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe____block_prepare_write = {
	.kp = { .symbol_name = "__block_prepare_write", },
	.entry = (kprobe_opcode_t *)jprobe_entry____block_prepare_write,
};

static int jprobe_entry____block_commit_write(struct inode * inode, struct page * page, unsigned int from, unsigned int to)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xb849, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe____block_commit_write = {
	.kp = { .symbol_name = "__block_commit_write", },
	.entry = (kprobe_opcode_t *)jprobe_entry____block_commit_write,
};

static int jprobe_entry__generic_cont_expand(struct inode * inode, loff_t size)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xab4a, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__generic_cont_expand = {
	.kp = { .symbol_name = "generic_cont_expand", },
	.entry = (kprobe_opcode_t *)jprobe_entry__generic_cont_expand,
};

static int jprobe_entry__generic_cont_expand_simple(struct inode * inode, loff_t size)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xaae3, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__generic_cont_expand_simple = {
	.kp = { .symbol_name = "generic_cont_expand_simple", },
	.entry = (kprobe_opcode_t *)jprobe_entry__generic_cont_expand_simple,
};

static int jprobe_entry____generic_cont_expand(struct inode * inode, loff_t size, long unsigned int index, unsigned int offset)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xa9fb, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe____generic_cont_expand = {
	.kp = { .symbol_name = "__generic_cont_expand", },
	.entry = (kprobe_opcode_t *)jprobe_entry____generic_cont_expand,
};

static int jprobe_entry__inode_has_buffers(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x9e6a, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__inode_has_buffers = {
	.kp = { .symbol_name = "inode_has_buffers", },
	.entry = (kprobe_opcode_t *)jprobe_entry__inode_has_buffers,
};

static void jprobe_entry__bdev_clear_inode(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xad52, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__bdev_clear_inode = {
	.kp = { .symbol_name = "bdev_clear_inode", },
	.entry = (kprobe_opcode_t *)jprobe_entry__bdev_clear_inode,
};

static int jprobe_entry__blkdev_close(struct inode * inode, struct file * filp)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xace1, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__blkdev_close = {
	.kp = { .symbol_name = "blkdev_close", },
	.entry = (kprobe_opcode_t *)jprobe_entry__blkdev_close,
};

static int jprobe_entry__blkdev_get_block(struct inode * inode, sector_t iblock, struct buffer_head * bh, int create)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xab1a, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__blkdev_get_block = {
	.kp = { .symbol_name = "blkdev_get_block", },
	.entry = (kprobe_opcode_t *)jprobe_entry__blkdev_get_block,
};

static int jprobe_entry__bdev_test(struct inode * inode, void * data)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xaa5a, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__bdev_test = {
	.kp = { .symbol_name = "bdev_test", },
	.entry = (kprobe_opcode_t *)jprobe_entry__bdev_test,
};

static void jprobe_entry__bdev_destroy_inode(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xaa0a, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__bdev_destroy_inode = {
	.kp = { .symbol_name = "bdev_destroy_inode", },
	.entry = (kprobe_opcode_t *)jprobe_entry__bdev_destroy_inode,
};

static int jprobe_entry__blkdev_open(struct inode * inode, struct file * filp)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xa481, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__blkdev_open = {
	.kp = { .symbol_name = "blkdev_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__blkdev_open,
};

static struct block_device * jprobe_entry__bd_acquire(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xa391, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__bd_acquire = {
	.kp = { .symbol_name = "bd_acquire", },
	.entry = (kprobe_opcode_t *)jprobe_entry__bd_acquire,
};

static void jprobe_entry__bd_forget(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x9f93, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__bd_forget = {
	.kp = { .symbol_name = "bd_forget", },
	.entry = (kprobe_opcode_t *)jprobe_entry__bd_forget,
};

static int jprobe_entry__bdev_set(struct inode * inode, void * data)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x9411, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__bdev_set = {
	.kp = { .symbol_name = "bdev_set", },
	.entry = (kprobe_opcode_t *)jprobe_entry__bdev_set,
};

typedef int __kernel_ssize_t;
typedef __kernel_ssize_t ssize_t;
struct kiocb;
struct iovec;
typedef void (dio_iodone_t)(struct kiocb *, loff_t, ssize_t, void *);

static ssize_t jprobe_entry____blockdev_direct_IO(int rw, struct kiocb * iocb, struct inode * inode, struct block_device * bdev, const struct iovec  * iov, loff_t offset, long unsigned int nr_segs, get_block_t * get_block, dio_iodone_t * end_io, int dio_lock_type)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x9ffe, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe____blockdev_direct_IO = {
	.kp = { .symbol_name = "__blockdev_direct_IO", },
	.entry = (kprobe_opcode_t *)jprobe_entry____blockdev_direct_IO,
};

static void jprobe_entry__inotify_d_instantiate(struct dentry * entry, struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x78e5, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__inotify_d_instantiate = {
	.kp = { .symbol_name = "inotify_d_instantiate", },
	.entry = (kprobe_opcode_t *)jprobe_entry__inotify_d_instantiate,
};

static void jprobe_entry__inotify_inode_is_dead(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7378, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__inotify_inode_is_dead = {
	.kp = { .symbol_name = "inotify_inode_is_dead", },
	.entry = (kprobe_opcode_t *)jprobe_entry__inotify_inode_is_dead,
};

typedef unsigned int u32;

static void jprobe_entry__inotify_inode_queue_event(struct inode * inode, u32 mask, u32 cookie, const char  * name, struct inode * n_inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7240, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__inotify_inode_queue_event = {
	.kp = { .symbol_name = "inotify_inode_queue_event", },
	.entry = (kprobe_opcode_t *)jprobe_entry__inotify_inode_queue_event,
};

typedef int __s32;
struct inotify_handle;
struct inotify_watch;

static __s32 jprobe_entry__inotify_add_watch(struct inotify_handle * ih, struct inotify_watch * watch, struct inode * inode, u32 mask)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x713f, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__inotify_add_watch = {
	.kp = { .symbol_name = "inotify_add_watch", },
	.entry = (kprobe_opcode_t *)jprobe_entry__inotify_add_watch,
};

static void jprobe_entry__set_dentry_child_flags(struct inode * inode, int watched)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x6fb8, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__set_dentry_child_flags = {
	.kp = { .symbol_name = "set_dentry_child_flags", },
	.entry = (kprobe_opcode_t *)jprobe_entry__set_dentry_child_flags,
};

static __s32 jprobe_entry__inotify_find_watch(struct inotify_handle * ih, struct inode * inode, struct inotify_watch * * watchp)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x6f44, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__inotify_find_watch = {
	.kp = { .symbol_name = "inotify_find_watch", },
	.entry = (kprobe_opcode_t *)jprobe_entry__inotify_find_watch,
};

static __s32 jprobe_entry__inotify_find_update_watch(struct inotify_handle * ih, struct inode * inode, u32 mask)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x6ebe, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__inotify_find_update_watch = {
	.kp = { .symbol_name = "inotify_find_update_watch", },
	.entry = (kprobe_opcode_t *)jprobe_entry__inotify_find_update_watch,
};

static struct inotify_watch * jprobe_entry__inode_find_handle(struct inode * inode, struct inotify_handle * ih)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x6da7, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__inode_find_handle = {
	.kp = { .symbol_name = "inode_find_handle", },
	.entry = (kprobe_opcode_t *)jprobe_entry__inode_find_handle,
};

static void jprobe_entry__inotify_dev_queue_event(struct inotify_watch * w, u32 wd, u32 mask, u32 cookie, const char  * name, struct inode * ignored)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(ignored, __ctracer__st__, 256);
	ctracer__method_entry(0x711f, ignored, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__inotify_dev_queue_event = {
	.kp = { .symbol_name = "inotify_dev_queue_event", },
	.entry = (kprobe_opcode_t *)jprobe_entry__inotify_dev_queue_event,
};

static int jprobe_entry__inotify_release(struct inode * ignored, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(ignored, __ctracer__st__, 256);
	ctracer__method_entry(0x6a86, ignored, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__inotify_release = {
	.kp = { .symbol_name = "inotify_release", },
	.entry = (kprobe_opcode_t *)jprobe_entry__inotify_release,
};

static int jprobe_entry__ep_eventpoll_close(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7d98, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ep_eventpoll_close = {
	.kp = { .symbol_name = "ep_eventpoll_close", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ep_eventpoll_close,
};

static void jprobe_entry____inode_dir_notify(struct inode * inode, long unsigned int event)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x6a94, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe____inode_dir_notify = {
	.kp = { .symbol_name = "__inode_dir_notify", },
	.entry = (kprobe_opcode_t *)jprobe_entry____inode_dir_notify,
};

static void jprobe_entry__redo_inode_mask(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x6a3b, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__redo_inode_mask = {
	.kp = { .symbol_name = "redo_inode_mask", },
	.entry = (kprobe_opcode_t *)jprobe_entry__redo_inode_mask,
};

struct vfsmount;

static int jprobe_entry__proc_exe_link(struct inode * inode, struct dentry * * dentry, struct vfsmount * * mnt)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7712, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__proc_exe_link = {
	.kp = { .symbol_name = "proc_exe_link", },
	.entry = (kprobe_opcode_t *)jprobe_entry__proc_exe_link,
};

static int jprobe_entry__maps_open(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x75da, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__maps_open = {
	.kp = { .symbol_name = "maps_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__maps_open,
};

static int jprobe_entry__smaps_open(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x759c, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__smaps_open = {
	.kp = { .symbol_name = "smaps_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__smaps_open,
};

struct seq_operations;

static int jprobe_entry__do_maps_open(struct inode * inode, struct file * file, struct seq_operations * ops)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x74ca, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__do_maps_open = {
	.kp = { .symbol_name = "do_maps_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__do_maps_open,
};

static void jprobe_entry__proc_delete_inode(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7656, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__proc_delete_inode = {
	.kp = { .symbol_name = "proc_delete_inode", },
	.entry = (kprobe_opcode_t *)jprobe_entry__proc_delete_inode,
};

static void jprobe_entry__proc_destroy_inode(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x73da, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__proc_destroy_inode = {
	.kp = { .symbol_name = "proc_destroy_inode", },
	.entry = (kprobe_opcode_t *)jprobe_entry__proc_destroy_inode,
};

static void jprobe_entry__proc_read_inode(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x73b2, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__proc_read_inode = {
	.kp = { .symbol_name = "proc_read_inode", },
	.entry = (kprobe_opcode_t *)jprobe_entry__proc_read_inode,
};

static struct dentry * jprobe_entry__proc_root_lookup(struct inode * dir, struct dentry * dentry, struct nameidata * nd)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x6e78, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__proc_root_lookup = {
	.kp = { .symbol_name = "proc_root_lookup", },
	.entry = (kprobe_opcode_t *)jprobe_entry__proc_root_lookup,
};

static struct dentry * jprobe_entry__proc_task_lookup(struct inode * dir, struct dentry * dentry, struct nameidata * nd)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0xa7fd, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__proc_task_lookup = {
	.kp = { .symbol_name = "proc_task_lookup", },
	.entry = (kprobe_opcode_t *)jprobe_entry__proc_task_lookup,
};

static struct dentry * jprobe_entry__proc_pid_lookup(struct inode * dir, struct dentry * dentry, struct nameidata * nd)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0xa397, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__proc_pid_lookup = {
	.kp = { .symbol_name = "proc_pid_lookup", },
	.entry = (kprobe_opcode_t *)jprobe_entry__proc_pid_lookup,
};

static struct dentry * jprobe_entry__proc_lookupfd(struct inode * dir, struct dentry * dentry, struct nameidata * nd)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x9e56, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__proc_lookupfd = {
	.kp = { .symbol_name = "proc_lookupfd", },
	.entry = (kprobe_opcode_t *)jprobe_entry__proc_lookupfd,
};

static int jprobe_entry__proc_fd_link(struct inode * inode, struct dentry * * dentry, struct vfsmount * * mnt)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x9c78, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__proc_fd_link = {
	.kp = { .symbol_name = "proc_fd_link", },
	.entry = (kprobe_opcode_t *)jprobe_entry__proc_fd_link,
};

static int jprobe_entry__mountstats_open(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x94a7, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__mountstats_open = {
	.kp = { .symbol_name = "mountstats_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__mountstats_open,
};

static int jprobe_entry__mounts_open(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x9321, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__mounts_open = {
	.kp = { .symbol_name = "mounts_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__mounts_open,
};

static int jprobe_entry__proc_root_link(struct inode * inode, struct dentry * * dentry, struct vfsmount * * mnt)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x9186, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__proc_root_link = {
	.kp = { .symbol_name = "proc_root_link", },
	.entry = (kprobe_opcode_t *)jprobe_entry__proc_root_link,
};

static int jprobe_entry__proc_cwd_link(struct inode * inode, struct dentry * * dentry, struct vfsmount * * mnt)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x903e, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__proc_cwd_link = {
	.kp = { .symbol_name = "proc_cwd_link", },
	.entry = (kprobe_opcode_t *)jprobe_entry__proc_cwd_link,
};

static int jprobe_entry__mem_open(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x8bb8, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__mem_open = {
	.kp = { .symbol_name = "mem_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__mem_open,
};

static int jprobe_entry__proc_fd_access_allowed(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x871a, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__proc_fd_access_allowed = {
	.kp = { .symbol_name = "proc_fd_access_allowed", },
	.entry = (kprobe_opcode_t *)jprobe_entry__proc_fd_access_allowed,
};

static struct dentry * jprobe_entry__proc_tgid_base_lookup(struct inode * dir, struct dentry * dentry, struct nameidata * nd)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x86cd, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__proc_tgid_base_lookup = {
	.kp = { .symbol_name = "proc_tgid_base_lookup", },
	.entry = (kprobe_opcode_t *)jprobe_entry__proc_tgid_base_lookup,
};

static struct dentry * jprobe_entry__proc_tid_base_lookup(struct inode * dir, struct dentry * dentry, struct nameidata * nd)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x8680, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__proc_tid_base_lookup = {
	.kp = { .symbol_name = "proc_tid_base_lookup", },
	.entry = (kprobe_opcode_t *)jprobe_entry__proc_tid_base_lookup,
};

struct pid_entry;

static struct dentry * jprobe_entry__proc_pident_lookup(struct inode * dir, struct dentry * dentry, struct pid_entry * ents, unsigned int nents)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x854b, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__proc_pident_lookup = {
	.kp = { .symbol_name = "proc_pident_lookup", },
	.entry = (kprobe_opcode_t *)jprobe_entry__proc_pident_lookup,
};

static struct dentry * jprobe_entry__proc_pident_instantiate(struct inode * dir, struct dentry * dentry, struct task_struct * task, void * ptr)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x847b, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__proc_pident_instantiate = {
	.kp = { .symbol_name = "proc_pident_instantiate", },
	.entry = (kprobe_opcode_t *)jprobe_entry__proc_pident_instantiate,
};

static struct dentry * jprobe_entry__proc_pid_instantiate(struct inode * dir, struct dentry * dentry, struct task_struct * task, void * ptr)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x83dd, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__proc_pid_instantiate = {
	.kp = { .symbol_name = "proc_pid_instantiate", },
	.entry = (kprobe_opcode_t *)jprobe_entry__proc_pid_instantiate,
};

static struct dentry * jprobe_entry__proc_task_instantiate(struct inode * dir, struct dentry * dentry, struct task_struct * task, void * ptr)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x833f, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__proc_task_instantiate = {
	.kp = { .symbol_name = "proc_task_instantiate", },
	.entry = (kprobe_opcode_t *)jprobe_entry__proc_task_instantiate,
};

static struct dentry * jprobe_entry__proc_fd_instantiate(struct inode * dir, struct dentry * dentry, struct task_struct * task, void * ptr)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x808c, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__proc_fd_instantiate = {
	.kp = { .symbol_name = "proc_fd_instantiate", },
	.entry = (kprobe_opcode_t *)jprobe_entry__proc_fd_instantiate,
};

static int jprobe_entry__mounts_release(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7734, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__mounts_release = {
	.kp = { .symbol_name = "mounts_release", },
	.entry = (kprobe_opcode_t *)jprobe_entry__mounts_release,
};

static struct dentry * jprobe_entry__proc_base_instantiate(struct inode * dir, struct dentry * dentry, struct task_struct * task, void * ptr)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x7637, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__proc_base_instantiate = {
	.kp = { .symbol_name = "proc_base_instantiate", },
	.entry = (kprobe_opcode_t *)jprobe_entry__proc_base_instantiate,
};

static struct dentry * jprobe_entry__proc_lookup(struct inode * dir, struct dentry * dentry, struct nameidata * nd)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x7e45, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__proc_lookup = {
	.kp = { .symbol_name = "proc_lookup", },
	.entry = (kprobe_opcode_t *)jprobe_entry__proc_lookup,
};

static int jprobe_entry__tty_drivers_open(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7a93, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__tty_drivers_open = {
	.kp = { .symbol_name = "tty_drivers_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__tty_drivers_open,
};

static int jprobe_entry__stat_open(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xaae3, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__stat_open = {
	.kp = { .symbol_name = "stat_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__stat_open,
};

static int jprobe_entry__slabstats_open(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xaa1a, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__slabstats_open = {
	.kp = { .symbol_name = "slabstats_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__slabstats_open,
};

static int jprobe_entry__slabstats_release(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xa998, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__slabstats_release = {
	.kp = { .symbol_name = "slabstats_release", },
	.entry = (kprobe_opcode_t *)jprobe_entry__slabstats_release,
};

static int jprobe_entry__fragmentation_open(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xa95d, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__fragmentation_open = {
	.kp = { .symbol_name = "fragmentation_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__fragmentation_open,
};

static int jprobe_entry__zoneinfo_open(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xa922, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__zoneinfo_open = {
	.kp = { .symbol_name = "zoneinfo_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__zoneinfo_open,
};

static int jprobe_entry__cpuinfo_open(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xa8e4, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__cpuinfo_open = {
	.kp = { .symbol_name = "cpuinfo_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__cpuinfo_open,
};

static int jprobe_entry__devinfo_open(struct inode * inode, struct file * filp)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xa8a6, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__devinfo_open = {
	.kp = { .symbol_name = "devinfo_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__devinfo_open,
};

static int jprobe_entry__vmstat_open(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xa868, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__vmstat_open = {
	.kp = { .symbol_name = "vmstat_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__vmstat_open,
};

static int jprobe_entry__partitions_open(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xa82a, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__partitions_open = {
	.kp = { .symbol_name = "partitions_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__partitions_open,
};

static int jprobe_entry__diskstats_open(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xa7ec, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__diskstats_open = {
	.kp = { .symbol_name = "diskstats_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__diskstats_open,
};

static int jprobe_entry__modules_open(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xa7ae, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__modules_open = {
	.kp = { .symbol_name = "modules_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__modules_open,
};

static int jprobe_entry__slabinfo_open(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xa770, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__slabinfo_open = {
	.kp = { .symbol_name = "slabinfo_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__slabinfo_open,
};

static int jprobe_entry__interrupts_open(struct inode * inode, struct file * filp)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xa732, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__interrupts_open = {
	.kp = { .symbol_name = "interrupts_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__interrupts_open,
};

static int jprobe_entry__open_kcore(struct inode * inode, struct file * filp)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x6d73, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__open_kcore = {
	.kp = { .symbol_name = "open_kcore", },
	.entry = (kprobe_opcode_t *)jprobe_entry__open_kcore,
};

static int jprobe_entry__kmsg_open(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x5f51, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__kmsg_open = {
	.kp = { .symbol_name = "kmsg_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__kmsg_open,
};

static int jprobe_entry__kmsg_release(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x5f16, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__kmsg_release = {
	.kp = { .symbol_name = "kmsg_release", },
	.entry = (kprobe_opcode_t *)jprobe_entry__kmsg_release,
};

static int jprobe_entry__sysfs_release(struct inode * inode, struct file * filp)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x77b1, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__sysfs_release = {
	.kp = { .symbol_name = "sysfs_release", },
	.entry = (kprobe_opcode_t *)jprobe_entry__sysfs_release,
};

static int jprobe_entry__sysfs_open_file(struct inode * inode, struct file * filp)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7149, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__sysfs_open_file = {
	.kp = { .symbol_name = "sysfs_open_file", },
	.entry = (kprobe_opcode_t *)jprobe_entry__sysfs_open_file,
};

static void jprobe_entry__sysfs_d_iput(struct dentry * dentry, struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7f9c, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__sysfs_d_iput = {
	.kp = { .symbol_name = "sysfs_d_iput", },
	.entry = (kprobe_opcode_t *)jprobe_entry__sysfs_d_iput,
};

static struct dentry * jprobe_entry__sysfs_lookup(struct inode * dir, struct dentry * dentry, struct nameidata * nd)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x7958, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__sysfs_lookup = {
	.kp = { .symbol_name = "sysfs_lookup", },
	.entry = (kprobe_opcode_t *)jprobe_entry__sysfs_lookup,
};

static int jprobe_entry__sysfs_dir_open(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x71ba, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__sysfs_dir_open = {
	.kp = { .symbol_name = "sysfs_dir_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__sysfs_dir_open,
};

static int jprobe_entry__sysfs_dir_close(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7038, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__sysfs_dir_close = {
	.kp = { .symbol_name = "sysfs_dir_close", },
	.entry = (kprobe_opcode_t *)jprobe_entry__sysfs_dir_close,
};

static int jprobe_entry__init_symlink(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x700c, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__init_symlink = {
	.kp = { .symbol_name = "init_symlink", },
	.entry = (kprobe_opcode_t *)jprobe_entry__init_symlink,
};

static int jprobe_entry__init_file(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x6fe0, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__init_file = {
	.kp = { .symbol_name = "init_file", },
	.entry = (kprobe_opcode_t *)jprobe_entry__init_file,
};

static int jprobe_entry__init_dir(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x6f9f, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__init_dir = {
	.kp = { .symbol_name = "init_dir", },
	.entry = (kprobe_opcode_t *)jprobe_entry__init_dir,
};

static int jprobe_entry__open(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7160, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__open = {
	.kp = { .symbol_name = "open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__open,
};

static int jprobe_entry__release(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x6c0b, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__release = {
	.kp = { .symbol_name = "release", },
	.entry = (kprobe_opcode_t *)jprobe_entry__release,
};

static void jprobe_entry__ext3_discard_reservation(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x9835, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__ext3_discard_reservation = {
	.kp = { .symbol_name = "ext3_discard_reservation", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_discard_reservation,
};

static void jprobe_entry__ext3_init_block_alloc_info(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x9795, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__ext3_init_block_alloc_info = {
	.kp = { .symbol_name = "ext3_init_block_alloc_info", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_init_block_alloc_info,
};

typedef long unsigned int ext3_fsblk_t;
typedef __u32 __be32;

/* <68b8> /home/acme/git/linux-2.6/include/linux/jbd.h:145 */
struct journal_header_s {
	__be32                     h_magic;              /*     0     4 */
	__be32                     h_blocktype;          /*     4     4 */
	__be32                     h_sequence;           /*     8     4 */
}; /* size: 12, cachelines: 1 */
   /* last cacheline: 12 bytes */

typedef struct journal_header_s journal_header_t;
typedef unsigned char __u8;

/* <68fa> /home/acme/git/linux-2.6/include/linux/jbd.h:183 */
struct journal_superblock_s {
	journal_header_t           s_header;             /*     0    12 */
	__be32                     s_blocksize;          /*    12     4 */
	__be32                     s_maxlen;             /*    16     4 */
	__be32                     s_first;              /*    20     4 */
	__be32                     s_sequence;           /*    24     4 */
	__be32                     s_start;              /*    28     4 */
	__be32                     s_errno;              /*    32     4 */
	__be32                     s_feature_compat;     /*    36     4 */
	__be32                     s_feature_incompat;   /*    40     4 */
	__be32                     s_feature_ro_compat;  /*    44     4 */
	__u8                       s_uuid[16];           /*    48    16 */
	/* --- cacheline 1 boundary (64 bytes) --- */
	__be32                     s_nr_users;           /*    64     4 */
	__be32                     s_dynsuper;           /*    68     4 */
	__be32                     s_max_transaction;    /*    72     4 */
	__be32                     s_max_trans_data;     /*    76     4 */
	__u32                      s_padding[44];        /*    80   176 */
	/* --- cacheline 4 boundary (256 bytes) --- */
	__u8                       s_users[768];         /*   256   768 */
	/* --- cacheline 16 boundary (1024 bytes) --- */
}; /* size: 1024, cachelines: 16 */

typedef struct journal_superblock_s journal_superblock_t;
typedef struct transaction_s transaction_t;

/* <1735> /home/acme/git/linux-2.6/include/linux/wait.h:50 */
struct __wait_queue_head {
	spinlock_t                 lock;                 /*     0    16 */
	struct list_head           task_list;            /*    16     8 */
}; /* size: 24, cachelines: 1 */
   /* last cacheline: 24 bytes */

typedef struct __wait_queue_head wait_queue_head_t;
typedef unsigned int tid_t;
struct tvec_t_base_s;

/* <54ee> /home/acme/git/linux-2.6/include/linux/timer.h:10 */
struct timer_list {
	struct list_head           entry;                /*     0     8 */
	long unsigned int          expires;              /*     8     4 */
	void                       (*function)(long unsigned int); /*    12     4 */
	long unsigned int          data;                 /*    16     4 */
	struct tvec_t_base_s *     base;                 /*    20     4 */
}; /* size: 24, cachelines: 1 */
   /* last cacheline: 24 bytes */

struct jbd_revoke_table_s;
typedef int __kernel_pid_t;
typedef __kernel_pid_t pid_t;

/* <65d7> /home/acme/git/linux-2.6/include/linux/jbd.h:118 */
struct journal_s {
	long unsigned int          j_flags;              /*     0     4 */
	int                        j_errno;              /*     4     4 */
	struct buffer_head *       j_sb_buffer;          /*     8     4 */
	journal_superblock_t *     j_superblock;         /*    12     4 */
	int                        j_format_version;     /*    16     4 */
	spinlock_t                 j_state_lock;         /*    20    16 */
	int                        j_barrier_count;      /*    36     4 */
	struct mutex               j_barrier;            /*    40    28 */
	/* --- cacheline 1 boundary (64 bytes) was 4 bytes ago --- */
	transaction_t *            j_running_transaction; /*    68     4 */
	transaction_t *            j_committing_transaction; /*    72     4 */
	transaction_t *            j_checkpoint_transactions; /*    76     4 */
	wait_queue_head_t          j_wait_transaction_locked; /*    80    24 */
	wait_queue_head_t          j_wait_logspace;      /*   104    24 */
	/* --- cacheline 2 boundary (128 bytes) --- */
	wait_queue_head_t          j_wait_done_commit;   /*   128    24 */
	wait_queue_head_t          j_wait_checkpoint;    /*   152    24 */
	wait_queue_head_t          j_wait_commit;        /*   176    24 */
	/* --- cacheline 3 boundary (192 bytes) was 8 bytes ago --- */
	wait_queue_head_t          j_wait_updates;       /*   200    24 */
	struct mutex               j_checkpoint_mutex;   /*   224    28 */
	long unsigned int          j_head;               /*   252     4 */
	/* --- cacheline 4 boundary (256 bytes) --- */
	long unsigned int          j_tail;               /*   256     4 */
	long unsigned int          j_free;               /*   260     4 */
	long unsigned int          j_first;              /*   264     4 */
	long unsigned int          j_last;               /*   268     4 */
	struct block_device *      j_dev;                /*   272     4 */
	int                        j_blocksize;          /*   276     4 */
	long unsigned int          j_blk_offset;         /*   280     4 */
	struct block_device *      j_fs_dev;             /*   284     4 */
	unsigned int               j_maxlen;             /*   288     4 */
	spinlock_t                 j_list_lock;          /*   292    16 */
	struct inode *             j_inode;              /*   308     4 */
	tid_t                      j_tail_sequence;      /*   312     4 */
	tid_t                      j_transaction_sequence; /*   316     4 */
	/* --- cacheline 5 boundary (320 bytes) --- */
	tid_t                      j_commit_sequence;    /*   320     4 */
	tid_t                      j_commit_request;     /*   324     4 */
	__u8                       j_uuid[16];           /*   328    16 */
	struct task_struct *       j_task;               /*   344     4 */
	int                        j_max_transaction_buffers; /*   348     4 */
	long unsigned int          j_commit_interval;    /*   352     4 */
	struct timer_list          j_commit_timer;       /*   356    24 */
	spinlock_t                 j_revoke_lock;        /*   380    16 */
	/* --- cacheline 6 boundary (384 bytes) was 12 bytes ago --- */
	struct jbd_revoke_table_s * j_revoke;            /*   396     4 */
	struct jbd_revoke_table_s * j_revoke_table[2];   /*   400     8 */
	struct buffer_head * *     j_wbuf;               /*   408     4 */
	int                        j_wbufsize;           /*   412     4 */
	pid_t                      j_last_sync_writer;   /*   416     4 */
	void *                     j_private;            /*   420     4 */
}; /* size: 424, cachelines: 7 */
   /* last cacheline: 40 bytes */

typedef struct journal_s journal_t;
struct journal_head;

/* <631c> /home/acme/git/linux-2.6/include/linux/journal-head.h:14 */
struct transaction_s {
	journal_t *                t_journal;            /*     0     4 */
	tid_t                      t_tid;                /*     4     4 */
	enum {
		T_RUNNING = 0,
		T_LOCKED = 1,
		T_RUNDOWN = 2,
		T_FLUSH = 3,
		T_COMMIT = 4,
		T_FINISHED = 5,
	} t_state;                                       /*     8     4 */
	long unsigned int          t_log_start;          /*    12     4 */
	int                        t_nr_buffers;         /*    16     4 */
	struct journal_head *      t_reserved_list;      /*    20     4 */
	struct journal_head *      t_locked_list;        /*    24     4 */
	struct journal_head *      t_buffers;            /*    28     4 */
	struct journal_head *      t_sync_datalist;      /*    32     4 */
	struct journal_head *      t_forget;             /*    36     4 */
	struct journal_head *      t_checkpoint_list;    /*    40     4 */
	struct journal_head *      t_checkpoint_io_list; /*    44     4 */
	struct journal_head *      t_iobuf_list;         /*    48     4 */
	struct journal_head *      t_shadow_list;        /*    52     4 */
	struct journal_head *      t_log_list;           /*    56     4 */
	spinlock_t                 t_handle_lock;        /*    60    16 */
	/* --- cacheline 1 boundary (64 bytes) was 12 bytes ago --- */
	int                        t_updates;            /*    76     4 */
	int                        t_outstanding_credits; /*    80     4 */
	transaction_t *            t_cpnext;             /*    84     4 */
	transaction_t *            t_cpprev;             /*    88     4 */
	long unsigned int          t_expires;            /*    92     4 */
	int                        t_handle_count;       /*    96     4 */
}; /* size: 100, cachelines: 2 */
   /* last cacheline: 36 bytes */

/* <654d> /home/acme/git/linux-2.6/include/linux/jbd.h:104 */
struct handle_s {
	transaction_t *            h_transaction;        /*     0     4 */
	int                        h_buffer_credits;     /*     4     4 */
	int                        h_ref;                /*     8     4 */
	int                        h_err;                /*    12     4 */
	unsigned int               h_sync:1;             /*    16     4 */
	unsigned int               h_jdata:1;            /*    16     4 */
	unsigned int               h_aborted:1;          /*    16     4 */
}; /* size: 20, cachelines: 1 */
   /* bit_padding: 29 bits */
   /* last cacheline: 20 bytes */

typedef struct handle_s handle_t;

static ext3_fsblk_t jprobe_entry__ext3_new_block(handle_t * handle, struct inode * inode, ext3_fsblk_t goal, int * errp)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x94c4, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext3_new_block = {
	.kp = { .symbol_name = "ext3_new_block", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_new_block,
};

static ext3_fsblk_t jprobe_entry__ext3_new_blocks(handle_t * handle, struct inode * inode, ext3_fsblk_t goal, long unsigned int * count, int * errp)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x9114, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext3_new_blocks = {
	.kp = { .symbol_name = "ext3_new_blocks", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_new_blocks,
};

static void jprobe_entry__ext3_free_blocks(handle_t * handle, struct inode * inode, ext3_fsblk_t block, long unsigned int count)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x8a86, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__ext3_free_blocks = {
	.kp = { .symbol_name = "ext3_free_blocks", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_free_blocks,
};

static int jprobe_entry__ext3_release_dir(struct inode * inode, struct file * filp)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7495, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext3_release_dir = {
	.kp = { .symbol_name = "ext3_release_dir", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_release_dir,
};

struct ext3_dir_entry_2;

static int jprobe_entry__ext3_check_dir_entry(const char  * function, struct inode * dir, struct ext3_dir_entry_2 * de, struct buffer_head * bh, long unsigned int offset)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x7367, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext3_check_dir_entry = {
	.kp = { .symbol_name = "ext3_check_dir_entry", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_check_dir_entry,
};

static int jprobe_entry__ext3_release_file(struct inode * inode, struct file * filp)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7355, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext3_release_file = {
	.kp = { .symbol_name = "ext3_release_file", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_release_file,
};

static struct inode * jprobe_entry__ext3_new_inode(handle_t * handle, struct inode * dir, int mode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x7d39, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext3_new_inode = {
	.kp = { .symbol_name = "ext3_new_inode", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_new_inode,
};

static void jprobe_entry__ext3_free_inode(handle_t * handle, struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x77c1, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__ext3_free_inode = {
	.kp = { .symbol_name = "ext3_free_inode", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_free_inode,
};

static void jprobe_entry__ext3_read_inode(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xd199, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__ext3_read_inode = {
	.kp = { .symbol_name = "ext3_read_inode", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_read_inode,
};

static void jprobe_entry__ext3_dirty_inode(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xd075, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__ext3_dirty_inode = {
	.kp = { .symbol_name = "ext3_dirty_inode", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_dirty_inode,
};

static void jprobe_entry__ext3_delete_inode(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xc2e9, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__ext3_delete_inode = {
	.kp = { .symbol_name = "ext3_delete_inode", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_delete_inode,
};

static int jprobe_entry__ext3_write_inode(struct inode * inode, int wait)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xc147, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext3_write_inode = {
	.kp = { .symbol_name = "ext3_write_inode", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_write_inode,
};

static int jprobe_entry__ext3_change_inode_journal_flag(struct inode * inode, int val)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xbd9f, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext3_change_inode_journal_flag = {
	.kp = { .symbol_name = "ext3_change_inode_journal_flag", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_change_inode_journal_flag,
};

static struct buffer_head * jprobe_entry__ext3_bread(handle_t * handle, struct inode * inode, int block, int create, int * err)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xba7a, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext3_bread = {
	.kp = { .symbol_name = "ext3_bread", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_bread,
};

static void jprobe_entry__ext3_truncate(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xb2d5, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__ext3_truncate = {
	.kp = { .symbol_name = "ext3_truncate", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_truncate,
};

typedef __u32 __le32;

static void jprobe_entry__ext3_free_branches(handle_t * handle, struct inode * inode, struct buffer_head * parent_bh, __le32 * first, __le32 * last, int depth)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xaf7c, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__ext3_free_branches = {
	.kp = { .symbol_name = "ext3_free_branches", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_free_branches,
};

static void jprobe_entry__ext3_free_data(handle_t * handle, struct inode * inode, struct buffer_head * this_bh, __le32 * first, __le32 * last)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xaea5, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__ext3_free_data = {
	.kp = { .symbol_name = "ext3_free_data", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_free_data,
};

static void jprobe_entry__ext3_clear_blocks(handle_t * handle, struct inode * inode, struct buffer_head * bh, ext3_fsblk_t block_to_free, long unsigned int count, __le32 * first, __le32 * last)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xadb7, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__ext3_clear_blocks = {
	.kp = { .symbol_name = "ext3_clear_blocks", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_clear_blocks,
};

static int jprobe_entry__ext3_forget(handle_t * handle, int is_metadata, struct inode * inode, struct buffer_head * bh, ext3_fsblk_t blocknr)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xad02, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext3_forget = {
	.kp = { .symbol_name = "ext3_forget", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_forget,
};

static int jprobe_entry__ext3_get_block(struct inode * inode, sector_t iblock, struct buffer_head * bh_result, int create)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xabac, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext3_get_block = {
	.kp = { .symbol_name = "ext3_get_block", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_get_block,
};

static struct buffer_head * jprobe_entry__ext3_getblk(handle_t * handle, struct inode * inode, long int block, int create, int * errp)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xa924, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext3_getblk = {
	.kp = { .symbol_name = "ext3_getblk", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_getblk,
};

static int jprobe_entry__ext3_get_blocks_handle(handle_t * handle, struct inode * inode, sector_t iblock, long unsigned int maxblocks, struct buffer_head * bh_result, int create, int extend_disksize)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xa2ce, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext3_get_blocks_handle = {
	.kp = { .symbol_name = "ext3_get_blocks_handle", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_get_blocks_handle,
};

static int jprobe_entry__ext3_writepage_trans_blocks(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x9d14, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext3_writepage_trans_blocks = {
	.kp = { .symbol_name = "ext3_writepage_trans_blocks", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_writepage_trans_blocks,
};

/* <83b3> /home/acme/git/linux-2.6/fs/ext3/inode.c:237 */
typedef struct {
	__le32 *                   p;                    /*     0     4 */
	__le32                     key;                  /*     4     4 */
	struct buffer_head *       bh;                   /*     8     4 */
} Indirect; /* size: 12, cachelines: 1 */
   /* last cacheline: 12 bytes */


static Indirect * jprobe_entry__ext3_get_branch(struct inode * inode, int depth, int * offsets, Indirect * chain, int * err)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x9b7f, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext3_get_branch = {
	.kp = { .symbol_name = "ext3_get_branch", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_get_branch,
};

static int jprobe_entry__ext3_block_to_path(struct inode * inode, long int i_block, int * offsets, int * boundary)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x9ab7, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext3_block_to_path = {
	.kp = { .symbol_name = "ext3_block_to_path", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_block_to_path,
};

static int jprobe_entry__ext3_journal_test_restart(handle_t * handle, struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x9a62, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext3_journal_test_restart = {
	.kp = { .symbol_name = "ext3_journal_test_restart", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_journal_test_restart,
};

static int jprobe_entry__try_to_extend_transaction(handle_t * handle, struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x9a0d, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__try_to_extend_transaction = {
	.kp = { .symbol_name = "try_to_extend_transaction", },
	.entry = (kprobe_opcode_t *)jprobe_entry__try_to_extend_transaction,
};

static int jprobe_entry__ext3_mark_inode_dirty(handle_t * handle, struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x99af, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext3_mark_inode_dirty = {
	.kp = { .symbol_name = "ext3_mark_inode_dirty", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_mark_inode_dirty,
};

struct ext3_iloc;

static int jprobe_entry__ext3_reserve_inode_write(handle_t * handle, struct inode * inode, struct ext3_iloc * iloc)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x9922, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext3_reserve_inode_write = {
	.kp = { .symbol_name = "ext3_reserve_inode_write", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_reserve_inode_write,
};

static int jprobe_entry__ext3_get_inode_loc(struct inode * inode, struct ext3_iloc * iloc)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x98d1, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext3_get_inode_loc = {
	.kp = { .symbol_name = "ext3_get_inode_loc", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_get_inode_loc,
};

static int jprobe_entry____ext3_get_inode_loc(struct inode * inode, struct ext3_iloc * iloc, int in_mem)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x945e, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe____ext3_get_inode_loc = {
	.kp = { .symbol_name = "__ext3_get_inode_loc", },
	.entry = (kprobe_opcode_t *)jprobe_entry____ext3_get_inode_loc,
};

static int jprobe_entry__ext3_mark_iloc_dirty(handle_t * handle, struct inode * inode, struct ext3_iloc * iloc)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x91f2, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext3_mark_iloc_dirty = {
	.kp = { .symbol_name = "ext3_mark_iloc_dirty", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_mark_iloc_dirty,
};

static handle_t * jprobe_entry__start_transaction(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x8ff6, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__start_transaction = {
	.kp = { .symbol_name = "start_transaction", },
	.entry = (kprobe_opcode_t *)jprobe_entry__start_transaction,
};

static void jprobe_entry__ext3_set_inode_flags(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x8fa9, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__ext3_set_inode_flags = {
	.kp = { .symbol_name = "ext3_set_inode_flags", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_set_inode_flags,
};

static void jprobe_entry__ext3_set_aops(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x8f39, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__ext3_set_aops = {
	.kp = { .symbol_name = "ext3_set_aops", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_set_aops,
};

static long unsigned int jprobe_entry__blocks_for_truncate(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x8cc5, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__blocks_for_truncate = {
	.kp = { .symbol_name = "blocks_for_truncate", },
	.entry = (kprobe_opcode_t *)jprobe_entry__blocks_for_truncate,
};

static int jprobe_entry__ext3_inode_is_fast_symlink(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x8c7b, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext3_inode_is_fast_symlink = {
	.kp = { .symbol_name = "ext3_inode_is_fast_symlink", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_inode_is_fast_symlink,
};

static int jprobe_entry__ext3_ioctl(struct inode * inode, struct file * filp, unsigned int cmd, long unsigned int arg)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7374, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext3_ioctl = {
	.kp = { .symbol_name = "ext3_ioctl", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_ioctl,
};

static struct dentry * jprobe_entry__ext3_lookup(struct inode * dir, struct dentry * dentry, struct nameidata * nd)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0xab7d, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext3_lookup = {
	.kp = { .symbol_name = "ext3_lookup", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_lookup,
};

static int jprobe_entry__ext3_rename(struct inode * old_dir, struct dentry * old_dentry, struct inode * new_dir, struct dentry * new_dentry)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(old_dir, __ctracer__st__, 256);
	ctracer__method_entry(0xa8dc, old_dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext3_rename = {
	.kp = { .symbol_name = "ext3_rename", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_rename,
};

static int jprobe_entry__ext3_unlink(struct inode * dir, struct dentry * dentry)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0xa776, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext3_unlink = {
	.kp = { .symbol_name = "ext3_unlink", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_unlink,
};

static int jprobe_entry__ext3_rmdir(struct inode * dir, struct dentry * dentry)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0xa64d, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext3_rmdir = {
	.kp = { .symbol_name = "ext3_rmdir", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_rmdir,
};

static int jprobe_entry__ext3_orphan_del(handle_t * handle, struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xa46d, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext3_orphan_del = {
	.kp = { .symbol_name = "ext3_orphan_del", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_orphan_del,
};

static int jprobe_entry__ext3_mkdir(struct inode * dir, struct dentry * dentry, int mode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0xa245, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext3_mkdir = {
	.kp = { .symbol_name = "ext3_mkdir", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_mkdir,
};

static int jprobe_entry__ext3_link(struct dentry * old_dentry, struct inode * dir, struct dentry * dentry)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x9f5b, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext3_link = {
	.kp = { .symbol_name = "ext3_link", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_link,
};

static int jprobe_entry__ext3_symlink(struct inode * dir, struct dentry * dentry, const char  * symname)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x9d6a, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext3_symlink = {
	.kp = { .symbol_name = "ext3_symlink", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_symlink,
};

static int jprobe_entry__ext3_mknod(struct inode * dir, struct dentry * dentry, int mode, dev_t rdev)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x9c30, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext3_mknod = {
	.kp = { .symbol_name = "ext3_mknod", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_mknod,
};

static int jprobe_entry__ext3_create(struct inode * dir, struct dentry * dentry, int mode, struct nameidata * nd)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x9b28, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext3_create = {
	.kp = { .symbol_name = "ext3_create", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_create,
};

struct dx_hash_info;

static int jprobe_entry__htree_dirblock_to_tree(struct file * dir_file, struct inode * dir, int block, struct dx_hash_info * hinfo, __u32 start_hash, __u32 start_minor_hash)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x9887, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__htree_dirblock_to_tree = {
	.kp = { .symbol_name = "htree_dirblock_to_tree", },
	.entry = (kprobe_opcode_t *)jprobe_entry__htree_dirblock_to_tree,
};

static int jprobe_entry__ext3_orphan_add(handle_t * handle, struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x97d5, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext3_orphan_add = {
	.kp = { .symbol_name = "ext3_orphan_add", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_orphan_add,
};

static int jprobe_entry__ext3_add_nondir(handle_t * handle, struct dentry * dentry, struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x9746, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext3_add_nondir = {
	.kp = { .symbol_name = "ext3_add_nondir", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_add_nondir,
};

static int jprobe_entry__ext3_add_entry(handle_t * handle, struct dentry * dentry, struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x8c8b, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext3_add_entry = {
	.kp = { .symbol_name = "ext3_add_entry", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_add_entry,
};

struct dx_frame;

static struct dx_frame * jprobe_entry__dx_probe(struct dentry * dentry, struct inode * dir, struct dx_hash_info * hinfo, struct dx_frame * frame_in, int * err)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x872f, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__dx_probe = {
	.kp = { .symbol_name = "dx_probe", },
	.entry = (kprobe_opcode_t *)jprobe_entry__dx_probe,
};

static int jprobe_entry__ext3_htree_next_block(struct inode * dir, __u32 hash, struct dx_frame * frame, struct dx_frame * frames, __u32 * start_hash)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x85e3, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext3_htree_next_block = {
	.kp = { .symbol_name = "ext3_htree_next_block", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_htree_next_block,
};

static struct ext3_dir_entry_2 * jprobe_entry__do_split(handle_t * handle, struct inode * dir, struct buffer_head * * bh, struct dx_frame * frame, struct dx_hash_info * hinfo, int * error)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x829d, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__do_split = {
	.kp = { .symbol_name = "do_split", },
	.entry = (kprobe_opcode_t *)jprobe_entry__do_split,
};

static int jprobe_entry__add_dirent_to_buf(handle_t * handle, struct dentry * dentry, struct inode * inode, struct ext3_dir_entry_2 * de, struct buffer_head * bh)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7ec5, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__add_dirent_to_buf = {
	.kp = { .symbol_name = "add_dirent_to_buf", },
	.entry = (kprobe_opcode_t *)jprobe_entry__add_dirent_to_buf,
};

static int jprobe_entry__empty_dir(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7d43, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__empty_dir = {
	.kp = { .symbol_name = "empty_dir", },
	.entry = (kprobe_opcode_t *)jprobe_entry__empty_dir,
};

static int jprobe_entry__ext3_delete_entry(handle_t * handle, struct inode * dir, struct ext3_dir_entry_2 * de_del, struct buffer_head * bh)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x7bae, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext3_delete_entry = {
	.kp = { .symbol_name = "ext3_delete_entry", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_delete_entry,
};

static struct buffer_head * jprobe_entry__ext3_append(handle_t * handle, struct inode * inode, u32 * block, int * err)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7b22, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext3_append = {
	.kp = { .symbol_name = "ext3_append", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_append,
};

static void jprobe_entry__ext3_update_dx_flag(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7af8, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__ext3_update_dx_flag = {
	.kp = { .symbol_name = "ext3_update_dx_flag", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_update_dx_flag,
};

static void jprobe_entry__ext3_clear_inode(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xb4f3, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__ext3_clear_inode = {
	.kp = { .symbol_name = "ext3_clear_inode", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_clear_inode,
};

static void jprobe_entry__ext3_destroy_inode(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xb4b7, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__ext3_destroy_inode = {
	.kp = { .symbol_name = "ext3_destroy_inode", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_destroy_inode,
};

static void jprobe_entry__ext3_xattr_delete_inode(handle_t * handle, struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x999b, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__ext3_xattr_delete_inode = {
	.kp = { .symbol_name = "ext3_xattr_delete_inode", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_xattr_delete_inode,
};

static int jprobe_entry__ext3_xattr_get(struct inode * inode, int name_index, const char  * name, void * buffer, size_t buffer_size)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x971c, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext3_xattr_get = {
	.kp = { .symbol_name = "ext3_xattr_get", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_xattr_get,
};

static int jprobe_entry__ext3_xattr_list(struct inode * inode, char * buffer, size_t buffer_size)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x9345, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext3_xattr_list = {
	.kp = { .symbol_name = "ext3_xattr_list", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_xattr_list,
};

static int jprobe_entry__ext3_xattr_set(struct inode * inode, int name_index, const char  * name, const void  * value, size_t value_len, int flags)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x90f8, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext3_xattr_set = {
	.kp = { .symbol_name = "ext3_xattr_set", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_xattr_set,
};

static int jprobe_entry__ext3_xattr_set_handle(handle_t * handle, struct inode * inode, int name_index, const char  * name, const void  * value, size_t value_len, int flags)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x8e14, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext3_xattr_set_handle = {
	.kp = { .symbol_name = "ext3_xattr_set_handle", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_xattr_set_handle,
};

struct ext3_xattr_info;
struct ext3_xattr_block_find;

static int jprobe_entry__ext3_xattr_block_set(handle_t * handle, struct inode * inode, struct ext3_xattr_info * i, struct ext3_xattr_block_find * bs)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x874a, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext3_xattr_block_set = {
	.kp = { .symbol_name = "ext3_xattr_block_set", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_xattr_block_set,
};

struct ext3_xattr_ibody_find;

static int jprobe_entry__ext3_xattr_ibody_set(handle_t * handle, struct inode * inode, struct ext3_xattr_info * i, struct ext3_xattr_ibody_find * is)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x8588, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext3_xattr_ibody_set = {
	.kp = { .symbol_name = "ext3_xattr_ibody_set", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_xattr_ibody_set,
};

static void jprobe_entry__ext3_xattr_release_block(handle_t * handle, struct inode * inode, struct buffer_head * bh)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7ff8, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__ext3_xattr_release_block = {
	.kp = { .symbol_name = "ext3_xattr_release_block", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_xattr_release_block,
};

struct ext3_xattr_entry;

static int jprobe_entry__ext3_xattr_list_entries(struct inode * inode, struct ext3_xattr_entry * entry, char * buffer, size_t buffer_size)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7e2e, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext3_xattr_list_entries = {
	.kp = { .symbol_name = "ext3_xattr_list_entries", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_xattr_list_entries,
};

static int jprobe_entry__ext3_xattr_user_get(struct inode * inode, const char  * name, void * buffer, size_t size)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7f71, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext3_xattr_user_get = {
	.kp = { .symbol_name = "ext3_xattr_user_get", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_xattr_user_get,
};

static size_t jprobe_entry__ext3_xattr_user_list(struct inode * inode, char * list, size_t list_size, const char  * name, size_t name_len)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7e80, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext3_xattr_user_list = {
	.kp = { .symbol_name = "ext3_xattr_user_list", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_xattr_user_list,
};

static int jprobe_entry__ext3_xattr_user_set(struct inode * inode, const char  * name, const void  * value, size_t size, int flags)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7d42, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext3_xattr_user_set = {
	.kp = { .symbol_name = "ext3_xattr_user_set", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_xattr_user_set,
};

static size_t jprobe_entry__ext3_xattr_trusted_list(struct inode * inode, char * list, size_t list_size, const char  * name, size_t name_len)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x709d, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext3_xattr_trusted_list = {
	.kp = { .symbol_name = "ext3_xattr_trusted_list", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_xattr_trusted_list,
};

static int jprobe_entry__ext3_xattr_trusted_get(struct inode * inode, const char  * name, void * buffer, size_t size)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x6f6d, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext3_xattr_trusted_get = {
	.kp = { .symbol_name = "ext3_xattr_trusted_get", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_xattr_trusted_get,
};

static int jprobe_entry__ext3_xattr_trusted_set(struct inode * inode, const char  * name, const void  * value, size_t size, int flags)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x6ed0, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext3_xattr_trusted_set = {
	.kp = { .symbol_name = "ext3_xattr_trusted_set", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext3_xattr_trusted_set,
};

static journal_t * jprobe_entry__journal_init_inode(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x95c5, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__journal_init_inode = {
	.kp = { .symbol_name = "journal_init_inode", },
	.entry = (kprobe_opcode_t *)jprobe_entry__journal_init_inode,
};

static int jprobe_entry__journal_blocks_per_page(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7d2e, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__journal_blocks_per_page = {
	.kp = { .symbol_name = "journal_blocks_per_page", },
	.entry = (kprobe_opcode_t *)jprobe_entry__journal_blocks_per_page,
};

static int jprobe_entry__ext2_new_block(struct inode * inode, long unsigned int goal, u32 * prealloc_count, u32 * prealloc_block, int * err)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7495, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext2_new_block = {
	.kp = { .symbol_name = "ext2_new_block", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext2_new_block,
};

static void jprobe_entry__ext2_free_blocks(struct inode * inode, long unsigned int block, long unsigned int count)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x71d6, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__ext2_free_blocks = {
	.kp = { .symbol_name = "ext2_free_blocks", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext2_free_blocks,
};

static int jprobe_entry__ext2_add_link(struct dentry * dentry, struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7cb0, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext2_add_link = {
	.kp = { .symbol_name = "ext2_add_link", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext2_add_link,
};

struct ext2_dir_entry_2;

static void jprobe_entry__ext2_set_link(struct inode * dir, struct ext2_dir_entry_2 * de, struct page * page, struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x7b08, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__ext2_set_link = {
	.kp = { .symbol_name = "ext2_set_link", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext2_set_link,
};

static int jprobe_entry__ext2_empty_dir(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7a0d, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext2_empty_dir = {
	.kp = { .symbol_name = "ext2_empty_dir", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext2_empty_dir,
};

typedef long unsigned int __kernel_ino_t;
typedef __kernel_ino_t ino_t;

static ino_t jprobe_entry__ext2_inode_by_name(struct inode * dir, struct dentry * dentry)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x77be, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext2_inode_by_name = {
	.kp = { .symbol_name = "ext2_inode_by_name", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext2_inode_by_name,
};

static struct ext2_dir_entry_2 * jprobe_entry__ext2_dotdot(struct inode * dir, struct page * * p)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x74f6, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext2_dotdot = {
	.kp = { .symbol_name = "ext2_dotdot", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext2_dotdot,
};

static int jprobe_entry__ext2_make_empty(struct inode * inode, struct inode * parent)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x72c5, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext2_make_empty = {
	.kp = { .symbol_name = "ext2_make_empty", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext2_make_empty,
};

static struct ext2_dir_entry_2 * jprobe_entry__ext2_find_entry(struct inode * dir, struct dentry * dentry, struct page * * res_page)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x6fc0, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext2_find_entry = {
	.kp = { .symbol_name = "ext2_find_entry", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext2_find_entry,
};

static struct page * jprobe_entry__ext2_get_page(struct inode * dir, long unsigned int n)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x6cc6, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext2_get_page = {
	.kp = { .symbol_name = "ext2_get_page", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext2_get_page,
};

static unsigned int jprobe_entry__ext2_last_byte(struct inode * inode, long unsigned int page_nr)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x6bb0, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext2_last_byte = {
	.kp = { .symbol_name = "ext2_last_byte", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext2_last_byte,
};

static int jprobe_entry__ext2_release_file(struct inode * inode, struct file * filp)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x5ea6, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext2_release_file = {
	.kp = { .symbol_name = "ext2_release_file", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext2_release_file,
};

static struct inode * jprobe_entry__ext2_new_inode(struct inode * dir, int mode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x73ed, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext2_new_inode = {
	.kp = { .symbol_name = "ext2_new_inode", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext2_new_inode,
};

static void jprobe_entry__ext2_free_inode(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x6e08, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__ext2_free_inode = {
	.kp = { .symbol_name = "ext2_free_inode", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext2_free_inode,
};

static void jprobe_entry__ext2_read_inode(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x972f, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__ext2_read_inode = {
	.kp = { .symbol_name = "ext2_read_inode", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext2_read_inode,
};

static int jprobe_entry__ext2_get_block(struct inode * inode, sector_t iblock, struct buffer_head * bh_result, int create)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x91e2, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext2_get_block = {
	.kp = { .symbol_name = "ext2_get_block", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext2_get_block,
};

static void jprobe_entry__ext2_delete_inode(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x8ee0, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__ext2_delete_inode = {
	.kp = { .symbol_name = "ext2_delete_inode", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext2_delete_inode,
};

static void jprobe_entry__ext2_put_inode(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x8eaa, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__ext2_put_inode = {
	.kp = { .symbol_name = "ext2_put_inode", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext2_put_inode,
};

static int jprobe_entry__ext2_alloc_block(struct inode * inode, long unsigned int goal, int * err)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x8e32, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext2_alloc_block = {
	.kp = { .symbol_name = "ext2_alloc_block", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext2_alloc_block,
};

static void jprobe_entry__ext2_truncate(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x8b8a, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__ext2_truncate = {
	.kp = { .symbol_name = "ext2_truncate", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext2_truncate,
};

static void jprobe_entry__ext2_free_branches(struct inode * inode, __le32 * p, __le32 * q, int depth)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x898f, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__ext2_free_branches = {
	.kp = { .symbol_name = "ext2_free_branches", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext2_free_branches,
};

static Indirect * jprobe_entry__ext2_get_branch(struct inode * inode, int depth, int * offsets, Indirect * chain, int * err)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x8820, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext2_get_branch = {
	.kp = { .symbol_name = "ext2_get_branch", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext2_get_branch,
};

static void jprobe_entry__ext2_discard_prealloc(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x87ac, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__ext2_discard_prealloc = {
	.kp = { .symbol_name = "ext2_discard_prealloc", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext2_discard_prealloc,
};

static int jprobe_entry__ext2_block_to_path(struct inode * inode, long int i_block, int * offsets, int * boundary)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x86f0, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext2_block_to_path = {
	.kp = { .symbol_name = "ext2_block_to_path", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext2_block_to_path,
};

static int jprobe_entry__ext2_write_inode(struct inode * inode, int wait)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x86b1, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext2_write_inode = {
	.kp = { .symbol_name = "ext2_write_inode", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext2_write_inode,
};

static int jprobe_entry__ext2_update_inode(struct inode * inode, int do_sync)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x8463, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext2_update_inode = {
	.kp = { .symbol_name = "ext2_update_inode", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext2_update_inode,
};

static int jprobe_entry__ext2_sync_inode(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x8332, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext2_sync_inode = {
	.kp = { .symbol_name = "ext2_sync_inode", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext2_sync_inode,
};

static void jprobe_entry__ext2_set_inode_flags(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7ed3, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__ext2_set_inode_flags = {
	.kp = { .symbol_name = "ext2_set_inode_flags", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext2_set_inode_flags,
};

static int jprobe_entry__ext2_ioctl(struct inode * inode, struct file * filp, unsigned int cmd, long unsigned int arg)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x5f6e, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext2_ioctl = {
	.kp = { .symbol_name = "ext2_ioctl", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext2_ioctl,
};

static struct dentry * jprobe_entry__ext2_lookup(struct inode * dir, struct dentry * dentry, struct nameidata * nd)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x7821, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext2_lookup = {
	.kp = { .symbol_name = "ext2_lookup", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext2_lookup,
};

static int jprobe_entry__ext2_symlink(struct inode * dir, struct dentry * dentry, const char  * symname)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x7681, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext2_symlink = {
	.kp = { .symbol_name = "ext2_symlink", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext2_symlink,
};

static int jprobe_entry__ext2_mknod(struct inode * dir, struct dentry * dentry, int mode, dev_t rdev)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x7486, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext2_mknod = {
	.kp = { .symbol_name = "ext2_mknod", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext2_mknod,
};

static int jprobe_entry__ext2_create(struct inode * dir, struct dentry * dentry, int mode, struct nameidata * nd)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x7371, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext2_create = {
	.kp = { .symbol_name = "ext2_create", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext2_create,
};

static int jprobe_entry__ext2_rename(struct inode * old_dir, struct dentry * old_dentry, struct inode * new_dir, struct dentry * new_dentry)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(old_dir, __ctracer__st__, 256);
	ctracer__method_entry(0x7074, old_dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext2_rename = {
	.kp = { .symbol_name = "ext2_rename", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext2_rename,
};

static int jprobe_entry__ext2_mkdir(struct inode * dir, struct dentry * dentry, int mode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x6e92, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext2_mkdir = {
	.kp = { .symbol_name = "ext2_mkdir", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext2_mkdir,
};

static int jprobe_entry__ext2_link(struct dentry * old_dentry, struct inode * dir, struct dentry * dentry)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x6d11, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext2_link = {
	.kp = { .symbol_name = "ext2_link", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext2_link,
};

static int jprobe_entry__ext2_rmdir(struct inode * dir, struct dentry * dentry)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x6bbf, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext2_rmdir = {
	.kp = { .symbol_name = "ext2_rmdir", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext2_rmdir,
};

static int jprobe_entry__ext2_unlink(struct inode * dir, struct dentry * dentry)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x6a16, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ext2_unlink = {
	.kp = { .symbol_name = "ext2_unlink", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext2_unlink,
};

static void jprobe_entry__ext2_destroy_inode(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x9c1f, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__ext2_destroy_inode = {
	.kp = { .symbol_name = "ext2_destroy_inode", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext2_destroy_inode,
};

static void jprobe_entry__ext2_clear_inode(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x9a17, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__ext2_clear_inode = {
	.kp = { .symbol_name = "ext2_clear_inode", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ext2_clear_inode,
};

static int jprobe_entry__ramfs_symlink(struct inode * dir, struct dentry * dentry, const char  * symname)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x7223, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ramfs_symlink = {
	.kp = { .symbol_name = "ramfs_symlink", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ramfs_symlink,
};

static int jprobe_entry__ramfs_mkdir(struct inode * dir, struct dentry * dentry, int mode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x7185, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ramfs_mkdir = {
	.kp = { .symbol_name = "ramfs_mkdir", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ramfs_mkdir,
};

static int jprobe_entry__ramfs_create(struct inode * dir, struct dentry * dentry, int mode, struct nameidata * nd)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x712e, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ramfs_create = {
	.kp = { .symbol_name = "ramfs_create", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ramfs_create,
};

static int jprobe_entry__ramfs_mknod(struct inode * dir, struct dentry * dentry, int mode, dev_t dev)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x7090, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ramfs_mknod = {
	.kp = { .symbol_name = "ramfs_mknod", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ramfs_mknod,
};

static int jprobe_entry__debugfs_mknod(struct inode * dir, struct dentry * dentry, int mode, dev_t dev)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0x72d7, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__debugfs_mknod = {
	.kp = { .symbol_name = "debugfs_mknod", },
	.entry = (kprobe_opcode_t *)jprobe_entry__debugfs_mknod,
};

static int jprobe_entry__fops_u16_open(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x73ed, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__fops_u16_open = {
	.kp = { .symbol_name = "fops_u16_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__fops_u16_open,
};

static int jprobe_entry__fops_u8_open(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x73b2, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__fops_u8_open = {
	.kp = { .symbol_name = "fops_u8_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__fops_u8_open,
};

static int jprobe_entry__fops_u32_open(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7377, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__fops_u32_open = {
	.kp = { .symbol_name = "fops_u32_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__fops_u32_open,
};

static int jprobe_entry__default_open(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x6ebe, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__default_open = {
	.kp = { .symbol_name = "default_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__default_open,
};

static int jprobe_entry__sysvipc_proc_open(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x73ef, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__sysvipc_proc_open = {
	.kp = { .symbol_name = "sysvipc_proc_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__sysvipc_proc_open,
};

static int jprobe_entry__shm_release(struct inode * ino, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(ino, __ctracer__st__, 256);
	ctracer__method_entry(0x719a, ino, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__shm_release = {
	.kp = { .symbol_name = "shm_release", },
	.entry = (kprobe_opcode_t *)jprobe_entry__shm_release,
};

static void jprobe_entry__mqueue_delete_inode(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xc166, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__mqueue_delete_inode = {
	.kp = { .symbol_name = "mqueue_delete_inode", },
	.entry = (kprobe_opcode_t *)jprobe_entry__mqueue_delete_inode,
};

static void jprobe_entry__mqueue_destroy_inode(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xc12d, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__mqueue_destroy_inode = {
	.kp = { .symbol_name = "mqueue_destroy_inode", },
	.entry = (kprobe_opcode_t *)jprobe_entry__mqueue_destroy_inode,
};

static int jprobe_entry__mqueue_create(struct inode * dir, struct dentry * dentry, int mode, struct nameidata * nd)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0xbaf0, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__mqueue_create = {
	.kp = { .symbol_name = "mqueue_create", },
	.entry = (kprobe_opcode_t *)jprobe_entry__mqueue_create,
};

static int jprobe_entry__mqueue_unlink(struct inode * dir, struct dentry * dentry)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(dir, __ctracer__st__, 256);
	ctracer__method_entry(0xb767, dir, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__mqueue_unlink = {
	.kp = { .symbol_name = "mqueue_unlink", },
	.entry = (kprobe_opcode_t *)jprobe_entry__mqueue_unlink,
};

static int jprobe_entry__crypto_info_open(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x7e7c, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__crypto_info_open = {
	.kp = { .symbol_name = "crypto_info_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__crypto_info_open,
};

static int jprobe_entry__blkdev_ioctl(struct inode * inode, struct file * file, unsigned int cmd, long unsigned int arg)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x958d, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__blkdev_ioctl = {
	.kp = { .symbol_name = "blkdev_ioctl", },
	.entry = (kprobe_opcode_t *)jprobe_entry__blkdev_ioctl,
};

struct gendisk;

static int jprobe_entry__blkdev_driver_ioctl(struct inode * inode, struct file * file, struct gendisk * disk, unsigned int cmd, long unsigned int arg)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x9218, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__blkdev_driver_ioctl = {
	.kp = { .symbol_name = "blkdev_driver_ioctl", },
	.entry = (kprobe_opcode_t *)jprobe_entry__blkdev_driver_ioctl,
};

static int jprobe_entry__blk_dropped_open(struct inode * inode, struct file * filp)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x942a, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__blk_dropped_open = {
	.kp = { .symbol_name = "blk_dropped_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__blk_dropped_open,
};

static int jprobe_entry__proc_bus_pci_ioctl(struct inode * inode, struct file * file, unsigned int cmd, long unsigned int arg)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x8ff2, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__proc_bus_pci_ioctl = {
	.kp = { .symbol_name = "proc_bus_pci_ioctl", },
	.entry = (kprobe_opcode_t *)jprobe_entry__proc_bus_pci_ioctl,
};

static int jprobe_entry__proc_bus_pci_open(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x88c0, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__proc_bus_pci_open = {
	.kp = { .symbol_name = "proc_bus_pci_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__proc_bus_pci_open,
};

static int jprobe_entry__proc_bus_pci_release(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x8848, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__proc_bus_pci_release = {
	.kp = { .symbol_name = "proc_bus_pci_release", },
	.entry = (kprobe_opcode_t *)jprobe_entry__proc_bus_pci_release,
};

static int jprobe_entry__proc_bus_pci_dev_open(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x86a9, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__proc_bus_pci_dev_open = {
	.kp = { .symbol_name = "proc_bus_pci_dev_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__proc_bus_pci_dev_open,
};

static int jprobe_entry__open_port(struct inode * inode, struct file * filp)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x9360, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__open_port = {
	.kp = { .symbol_name = "open_port", },
	.entry = (kprobe_opcode_t *)jprobe_entry__open_port,
};

static int jprobe_entry__memory_open(struct inode * inode, struct file * filp)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x8c2a, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__memory_open = {
	.kp = { .symbol_name = "memory_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__memory_open,
};

static int jprobe_entry__random_ioctl(struct inode * inode, struct file * file, unsigned int cmd, long unsigned int arg)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x90f7, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__random_ioctl = {
	.kp = { .symbol_name = "random_ioctl", },
	.entry = (kprobe_opcode_t *)jprobe_entry__random_ioctl,
};

static int jprobe_entry__ptmx_open(struct inode * inode, struct file * filp)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xcf62, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ptmx_open = {
	.kp = { .symbol_name = "ptmx_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ptmx_open,
};

static int jprobe_entry__tty_open(struct inode * inode, struct file * filp)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xcc85, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__tty_open = {
	.kp = { .symbol_name = "tty_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__tty_open,
};

static int jprobe_entry__tty_ioctl(struct inode * inode, struct file * file, unsigned int cmd, long unsigned int arg)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xc2c3, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__tty_ioctl = {
	.kp = { .symbol_name = "tty_ioctl", },
	.entry = (kprobe_opcode_t *)jprobe_entry__tty_ioctl,
};

static int jprobe_entry__tty_release(struct inode * inode, struct file * filp)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xac3d, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__tty_release = {
	.kp = { .symbol_name = "tty_release", },
	.entry = (kprobe_opcode_t *)jprobe_entry__tty_release,
};

struct tty_struct;

static int jprobe_entry__tty_paranoia_check(struct tty_struct * tty, struct inode * inode, const char  * routine)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x977e, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__tty_paranoia_check = {
	.kp = { .symbol_name = "tty_paranoia_check", },
	.entry = (kprobe_opcode_t *)jprobe_entry__tty_paranoia_check,
};

static int jprobe_entry__hung_up_tty_ioctl(struct inode * inode, struct file * file, unsigned int cmd, long unsigned int arg)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x956a, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__hung_up_tty_ioctl = {
	.kp = { .symbol_name = "hung_up_tty_ioctl", },
	.entry = (kprobe_opcode_t *)jprobe_entry__hung_up_tty_ioctl,
};

static int jprobe_entry__misc_open(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x893c, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__misc_open = {
	.kp = { .symbol_name = "misc_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__misc_open,
};

static int jprobe_entry__misc_seq_open(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x8516, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__misc_seq_open = {
	.kp = { .symbol_name = "misc_seq_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__misc_seq_open,
};

static int jprobe_entry__vcs_size(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x9291, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__vcs_size = {
	.kp = { .symbol_name = "vcs_size", },
	.entry = (kprobe_opcode_t *)jprobe_entry__vcs_size,
};

static int jprobe_entry__vcs_open(struct inode * inode, struct file * filp)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x9243, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__vcs_open = {
	.kp = { .symbol_name = "vcs_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__vcs_open,
};

static int jprobe_entry__ide_drivers_open(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xbc57, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__ide_drivers_open = {
	.kp = { .symbol_name = "ide_drivers_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__ide_drivers_open,
};

static int jprobe_entry__idedisk_open(struct inode * inode, struct file * filp)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xcff5, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__idedisk_open = {
	.kp = { .symbol_name = "idedisk_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__idedisk_open,
};

static int jprobe_entry__idedisk_ioctl(struct inode * inode, struct file * file, unsigned int cmd, long unsigned int arg)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xc74f, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__idedisk_ioctl = {
	.kp = { .symbol_name = "idedisk_ioctl", },
	.entry = (kprobe_opcode_t *)jprobe_entry__idedisk_ioctl,
};

static int jprobe_entry__idedisk_release(struct inode * inode, struct file * filp)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xc5a7, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__idedisk_release = {
	.kp = { .symbol_name = "idedisk_release", },
	.entry = (kprobe_opcode_t *)jprobe_entry__idedisk_release,
};

static int jprobe_entry__input_open_file(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xa479, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__input_open_file = {
	.kp = { .symbol_name = "input_open_file", },
	.entry = (kprobe_opcode_t *)jprobe_entry__input_open_file,
};

static int jprobe_entry__input_proc_devices_open(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x8ce0, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__input_proc_devices_open = {
	.kp = { .symbol_name = "input_proc_devices_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__input_proc_devices_open,
};

static int jprobe_entry__input_proc_handlers_open(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x8ca2, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__input_proc_handlers_open = {
	.kp = { .symbol_name = "input_proc_handlers_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__input_proc_handlers_open,
};

static int jprobe_entry__sock_close(struct inode * inode, struct file * filp)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xd120, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__sock_close = {
	.kp = { .symbol_name = "sock_close", },
	.entry = (kprobe_opcode_t *)jprobe_entry__sock_close,
};

static void jprobe_entry__sock_destroy_inode(struct inode * inode)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xb937, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
}

static struct jprobe jprobe__sock_destroy_inode = {
	.kp = { .symbol_name = "sock_destroy_inode", },
	.entry = (kprobe_opcode_t *)jprobe_entry__sock_destroy_inode,
};

static int jprobe_entry__sock_no_open(struct inode * irrelevant, struct file * dontcare)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(irrelevant, __ctracer__st__, 256);
	ctracer__method_entry(0xb5c8, irrelevant, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__sock_no_open = {
	.kp = { .symbol_name = "sock_no_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__sock_no_open,
};

static int jprobe_entry__proto_seq_open(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xd14b, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__proto_seq_open = {
	.kp = { .symbol_name = "proto_seq_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__proto_seq_open,
};

static int jprobe_entry__dev_seq_open(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xd000, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__dev_seq_open = {
	.kp = { .symbol_name = "dev_seq_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__dev_seq_open,
};

static int jprobe_entry__softnet_seq_open(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xcfc2, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__softnet_seq_open = {
	.kp = { .symbol_name = "softnet_seq_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__softnet_seq_open,
};

static int jprobe_entry__dev_mc_seq_open(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xb2eb, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__dev_mc_seq_open = {
	.kp = { .symbol_name = "dev_mc_seq_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__dev_mc_seq_open,
};

static int jprobe_entry__neigh_stat_seq_open(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xd0fc, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__neigh_stat_seq_open = {
	.kp = { .symbol_name = "neigh_stat_seq_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__neigh_stat_seq_open,
};

static int jprobe_entry__netlink_seq_open(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xc9e0, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__netlink_seq_open = {
	.kp = { .symbol_name = "netlink_seq_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__netlink_seq_open,
};

static int jprobe_entry__rt_cache_seq_open(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x11fe3, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__rt_cache_seq_open = {
	.kp = { .symbol_name = "rt_cache_seq_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__rt_cache_seq_open,
};

static int jprobe_entry__rt_cpu_seq_open(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xe9f9, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__rt_cpu_seq_open = {
	.kp = { .symbol_name = "rt_cpu_seq_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__rt_cpu_seq_open,
};

static int jprobe_entry__tcp_seq_open(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0x10915, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__tcp_seq_open = {
	.kp = { .symbol_name = "tcp_seq_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__tcp_seq_open,
};

static int jprobe_entry__raw_seq_open(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xe4ce, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__raw_seq_open = {
	.kp = { .symbol_name = "raw_seq_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__raw_seq_open,
};

static int jprobe_entry__udp_seq_open(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xeb8c, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__udp_seq_open = {
	.kp = { .symbol_name = "udp_seq_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__udp_seq_open,
};

static int jprobe_entry__arp_seq_open(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xc972, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__arp_seq_open = {
	.kp = { .symbol_name = "arp_seq_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__arp_seq_open,
};

static int jprobe_entry__igmp_mc_seq_open(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xffb8, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__igmp_mc_seq_open = {
	.kp = { .symbol_name = "igmp_mc_seq_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__igmp_mc_seq_open,
};

static int jprobe_entry__igmp_mcf_seq_open(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xd6f3, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__igmp_mcf_seq_open = {
	.kp = { .symbol_name = "igmp_mcf_seq_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__igmp_mcf_seq_open,
};

static int jprobe_entry__fib_seq_open(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xc86b, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__fib_seq_open = {
	.kp = { .symbol_name = "fib_seq_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__fib_seq_open,
};

static int jprobe_entry__sockstat_seq_open(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xb7b9, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__sockstat_seq_open = {
	.kp = { .symbol_name = "sockstat_seq_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__sockstat_seq_open,
};

static int jprobe_entry__snmp_seq_open(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xb77b, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__snmp_seq_open = {
	.kp = { .symbol_name = "snmp_seq_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__snmp_seq_open,
};

static int jprobe_entry__netstat_seq_open(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xb73d, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__netstat_seq_open = {
	.kp = { .symbol_name = "netstat_seq_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__netstat_seq_open,
};

static int jprobe_entry__packet_seq_open(struct inode * inode, struct file * file)
{
	char __ctracer__st__[256];
	const int __ctracer__len__ = ctracer__class_state(inode, __ctracer__st__, 256);
	ctracer__method_entry(0xbc11, inode, __ctracer__st__, __ctracer__len__);

	jprobe_return();
	/* NOTREACHED */
	return 0;
}

static struct jprobe jprobe__packet_seq_open = {
	.kp = { .symbol_name = "packet_seq_open", },
	.entry = (kprobe_opcode_t *)jprobe_entry__packet_seq_open,
};

static int kretprobe_handler__ioports_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x6f64);
	return 0;
}

static struct kretprobe kretprobe__ioports_open = {
	.kp = { .symbol_name = "ioports_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ioports_open,
	.maxactive = 64,

};

static int kretprobe_handler__iomem_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x6f07);
	return 0;
}

static struct kretprobe kretprobe__iomem_open = {
	.kp = { .symbol_name = "iomem_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__iomem_open,
	.maxactive = 64,

};

static int kretprobe_handler__proc_opensys(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x78c6);
	return 0;
}

static struct kretprobe kretprobe__proc_opensys = {
	.kp = { .symbol_name = "proc_opensys", },
	.handler = (kretprobe_handler_t)kretprobe_handler__proc_opensys,
	.maxactive = 64,

};

static int kretprobe_handler__futex_close(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7747);
	return 0;
}

static struct kretprobe kretprobe__futex_close = {
	.kp = { .symbol_name = "futex_close", },
	.handler = (kretprobe_handler_t)kretprobe_handler__futex_close,
	.maxactive = 64,

};

static int kretprobe_handler__proc_dma_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x6d5c);
	return 0;
}

static struct kretprobe kretprobe__proc_dma_open = {
	.kp = { .symbol_name = "proc_dma_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__proc_dma_open,
	.maxactive = 64,

};

static int kretprobe_handler__kallsyms_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x76ee);
	return 0;
}

static struct kretprobe kretprobe__kallsyms_open = {
	.kp = { .symbol_name = "kallsyms_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__kallsyms_open,
	.maxactive = 64,

};

static int kretprobe_handler__kallsyms_release(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7482);
	return 0;
}

static struct kretprobe kretprobe__kallsyms_release = {
	.kp = { .symbol_name = "kallsyms_release", },
	.handler = (kretprobe_handler_t)kretprobe_handler__kallsyms_release,
	.maxactive = 64,

};

static int kretprobe_handler__relay_file_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7d05);
	return 0;
}

static struct kretprobe kretprobe__relay_file_open = {
	.kp = { .symbol_name = "relay_file_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__relay_file_open,
	.maxactive = 64,

};

static int kretprobe_handler__relay_file_release(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7cbb);
	return 0;
}

static struct kretprobe kretprobe__relay_file_release = {
	.kp = { .symbol_name = "relay_file_release", },
	.handler = (kretprobe_handler_t)kretprobe_handler__relay_file_release,
	.maxactive = 64,

};

static int kretprobe_handler__sync_page_range(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xbb8d);
	return 0;
}

static struct kretprobe kretprobe__sync_page_range = {
	.kp = { .symbol_name = "sync_page_range", },
	.handler = (kretprobe_handler_t)kretprobe_handler__sync_page_range,
	.maxactive = 64,

};

static int kretprobe_handler__sync_page_range_nolock(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xbb06);
	return 0;
}

static struct kretprobe kretprobe__sync_page_range_nolock = {
	.kp = { .symbol_name = "sync_page_range_nolock", },
	.handler = (kretprobe_handler_t)kretprobe_handler__sync_page_range_nolock,
	.maxactive = 64,

};

static int kretprobe_handler__vmtruncate(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xbf70);
	return 0;
}

static struct kretprobe kretprobe__vmtruncate = {
	.kp = { .symbol_name = "vmtruncate", },
	.handler = (kretprobe_handler_t)kretprobe_handler__vmtruncate,
	.maxactive = 64,

};

static int kretprobe_handler__vmtruncate_range(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xa30f);
	return 0;
}

static struct kretprobe kretprobe__vmtruncate_range = {
	.kp = { .symbol_name = "vmtruncate_range", },
	.handler = (kretprobe_handler_t)kretprobe_handler__vmtruncate_range,
	.maxactive = 64,

};

static int kretprobe_handler__shmem_destroy_inode(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xb868);
	return 0;
}

static struct kretprobe kretprobe__shmem_destroy_inode = {
	.kp = { .symbol_name = "shmem_destroy_inode", },
	.handler = (kretprobe_handler_t)kretprobe_handler__shmem_destroy_inode,
	.maxactive = 64,

};

static int kretprobe_handler__shmem_delete_inode(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xb668);
	return 0;
}

static struct kretprobe kretprobe__shmem_delete_inode = {
	.kp = { .symbol_name = "shmem_delete_inode", },
	.handler = (kretprobe_handler_t)kretprobe_handler__shmem_delete_inode,
	.maxactive = 64,

};

static int kretprobe_handler__shmem_getpage(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xaaf0);
	return 0;
}

static struct kretprobe kretprobe__shmem_getpage = {
	.kp = { .symbol_name = "shmem_getpage", },
	.handler = (kretprobe_handler_t)kretprobe_handler__shmem_getpage,
	.maxactive = 64,

};

static int kretprobe_handler__shmem_truncate(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xa81c);
	return 0;
}

static struct kretprobe kretprobe__shmem_truncate = {
	.kp = { .symbol_name = "shmem_truncate", },
	.handler = (kretprobe_handler_t)kretprobe_handler__shmem_truncate,
	.maxactive = 64,

};

static int kretprobe_handler__shmem_truncate_range(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xa414);
	return 0;
}

static struct kretprobe kretprobe__shmem_truncate_range = {
	.kp = { .symbol_name = "shmem_truncate_range", },
	.handler = (kretprobe_handler_t)kretprobe_handler__shmem_truncate_range,
	.maxactive = 64,

};

static int kretprobe_handler__shmem_recalc_inode(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xa278);
	return 0;
}

static struct kretprobe kretprobe__shmem_recalc_inode = {
	.kp = { .symbol_name = "shmem_recalc_inode", },
	.handler = (kretprobe_handler_t)kretprobe_handler__shmem_recalc_inode,
	.maxactive = 64,

};

static int kretprobe_handler__shmem_free_blocks(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xa21d);
	return 0;
}

static struct kretprobe kretprobe__shmem_free_blocks = {
	.kp = { .symbol_name = "shmem_free_blocks", },
	.handler = (kretprobe_handler_t)kretprobe_handler__shmem_free_blocks,
	.maxactive = 64,

};

static int kretprobe_handler__nonseekable_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x8697);
	return 0;
}

static struct kretprobe kretprobe__nonseekable_open = {
	.kp = { .symbol_name = "nonseekable_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__nonseekable_open,
	.maxactive = 64,

};

static int kretprobe_handler__generic_file_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x865a);
	return 0;
}

static struct kretprobe kretprobe__generic_file_open = {
	.kp = { .symbol_name = "generic_file_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__generic_file_open,
	.maxactive = 64,

};

static int kretprobe_handler__chrdev_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x73df);
	return 0;
}

static struct kretprobe kretprobe__chrdev_open = {
	.kp = { .symbol_name = "chrdev_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__chrdev_open,
	.maxactive = 64,

};

static int kretprobe_handler__cd_forget(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x70eb);
	return 0;
}

static struct kretprobe kretprobe__cd_forget = {
	.kp = { .symbol_name = "cd_forget", },
	.handler = (kretprobe_handler_t)kretprobe_handler__cd_forget,
	.maxactive = 64,

};

static int kretprobe_handler__inode_add_bytes(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x76ce);
	return 0;
}

static struct kretprobe kretprobe__inode_add_bytes = {
	.kp = { .symbol_name = "inode_add_bytes", },
	.handler = (kretprobe_handler_t)kretprobe_handler__inode_add_bytes,
	.maxactive = 64,

};

static int kretprobe_handler__inode_sub_bytes(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7693);
	return 0;
}

static struct kretprobe kretprobe__inode_sub_bytes = {
	.kp = { .symbol_name = "inode_sub_bytes", },
	.handler = (kretprobe_handler_t)kretprobe_handler__inode_sub_bytes,
	.maxactive = 64,

};

static int kretprobe_handler__inode_get_bytes(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7654);
	return 0;
}

static struct kretprobe kretprobe__inode_get_bytes = {
	.kp = { .symbol_name = "inode_get_bytes", },
	.handler = (kretprobe_handler_t)kretprobe_handler__inode_get_bytes,
	.maxactive = 64,

};

static int kretprobe_handler__inode_set_bytes(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x761b);
	return 0;
}

static struct kretprobe kretprobe__inode_set_bytes = {
	.kp = { .symbol_name = "inode_set_bytes", },
	.handler = (kretprobe_handler_t)kretprobe_handler__inode_set_bytes,
	.maxactive = 64,

};

static int kretprobe_handler__generic_fillattr(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x757c);
	return 0;
}

static struct kretprobe kretprobe__generic_fillattr = {
	.kp = { .symbol_name = "generic_fillattr", },
	.handler = (kretprobe_handler_t)kretprobe_handler__generic_fillattr,
	.maxactive = 64,

};

static int kretprobe_handler__alloc_pipe_info(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x80e3);
	return 0;
}

static struct kretprobe kretprobe__alloc_pipe_info = {
	.kp = { .symbol_name = "alloc_pipe_info", },
	.handler = (kretprobe_handler_t)kretprobe_handler__alloc_pipe_info,
	.maxactive = 64,

};

static int kretprobe_handler__pipe_read_release(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x80a5);
	return 0;
}

static struct kretprobe kretprobe__pipe_read_release = {
	.kp = { .symbol_name = "pipe_read_release", },
	.handler = (kretprobe_handler_t)kretprobe_handler__pipe_read_release,
	.maxactive = 64,

};

static int kretprobe_handler__pipe_write_release(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x8067);
	return 0;
}

static struct kretprobe kretprobe__pipe_write_release = {
	.kp = { .symbol_name = "pipe_write_release", },
	.handler = (kretprobe_handler_t)kretprobe_handler__pipe_write_release,
	.maxactive = 64,

};

static int kretprobe_handler__pipe_rdwr_release(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x8011);
	return 0;
}

static struct kretprobe kretprobe__pipe_rdwr_release = {
	.kp = { .symbol_name = "pipe_rdwr_release", },
	.handler = (kretprobe_handler_t)kretprobe_handler__pipe_rdwr_release,
	.maxactive = 64,

};

static int kretprobe_handler__pipe_release(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7fb3);
	return 0;
}

static struct kretprobe kretprobe__pipe_release = {
	.kp = { .symbol_name = "pipe_release", },
	.handler = (kretprobe_handler_t)kretprobe_handler__pipe_release,
	.maxactive = 64,

};

static int kretprobe_handler__free_pipe_info(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7f45);
	return 0;
}

static struct kretprobe kretprobe__free_pipe_info = {
	.kp = { .symbol_name = "free_pipe_info", },
	.handler = (kretprobe_handler_t)kretprobe_handler__free_pipe_info,
	.maxactive = 64,

};

static int kretprobe_handler__pipe_ioctl(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7ca9);
	return 0;
}

static struct kretprobe kretprobe__pipe_ioctl = {
	.kp = { .symbol_name = "pipe_ioctl", },
	.handler = (kretprobe_handler_t)kretprobe_handler__pipe_ioctl,
	.maxactive = 64,

};

static int kretprobe_handler__pipe_read_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7b18);
	return 0;
}

static struct kretprobe kretprobe__pipe_read_open = {
	.kp = { .symbol_name = "pipe_read_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__pipe_read_open,
	.maxactive = 64,

};

static int kretprobe_handler__pipe_write_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7ada);
	return 0;
}

static struct kretprobe kretprobe__pipe_write_open = {
	.kp = { .symbol_name = "pipe_write_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__pipe_write_open,
	.maxactive = 64,

};

static int kretprobe_handler__pipe_rdwr_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7a9c);
	return 0;
}

static struct kretprobe kretprobe__pipe_rdwr_open = {
	.kp = { .symbol_name = "pipe_rdwr_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__pipe_rdwr_open,
	.maxactive = 64,

};

static int kretprobe_handler__vfs_rmdir(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x92ab);
	return 0;
}

static struct kretprobe kretprobe__vfs_rmdir = {
	.kp = { .symbol_name = "vfs_rmdir", },
	.handler = (kretprobe_handler_t)kretprobe_handler__vfs_rmdir,
	.maxactive = 64,

};

static int kretprobe_handler__vfs_unlink(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x925c);
	return 0;
}

static struct kretprobe kretprobe__vfs_unlink = {
	.kp = { .symbol_name = "vfs_unlink", },
	.handler = (kretprobe_handler_t)kretprobe_handler__vfs_unlink,
	.maxactive = 64,

};

static int kretprobe_handler__vfs_rename(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x9031);
	return 0;
}

static struct kretprobe kretprobe__vfs_rename = {
	.kp = { .symbol_name = "vfs_rename", },
	.handler = (kretprobe_handler_t)kretprobe_handler__vfs_rename,
	.maxactive = 64,

};

static int kretprobe_handler__may_delete(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x8ed0);
	return 0;
}

static struct kretprobe kretprobe__may_delete = {
	.kp = { .symbol_name = "may_delete", },
	.handler = (kretprobe_handler_t)kretprobe_handler__may_delete,
	.maxactive = 64,

};

static int kretprobe_handler__vfs_create(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x8e0d);
	return 0;
}

static struct kretprobe kretprobe__vfs_create = {
	.kp = { .symbol_name = "vfs_create", },
	.handler = (kretprobe_handler_t)kretprobe_handler__vfs_create,
	.maxactive = 64,

};

static int kretprobe_handler__vfs_mknod(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x8d4d);
	return 0;
}

static struct kretprobe kretprobe__vfs_mknod = {
	.kp = { .symbol_name = "vfs_mknod", },
	.handler = (kretprobe_handler_t)kretprobe_handler__vfs_mknod,
	.maxactive = 64,

};

static int kretprobe_handler__vfs_mkdir(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x8c99);
	return 0;
}

static struct kretprobe kretprobe__vfs_mkdir = {
	.kp = { .symbol_name = "vfs_mkdir", },
	.handler = (kretprobe_handler_t)kretprobe_handler__vfs_mkdir,
	.maxactive = 64,

};

static int kretprobe_handler__vfs_symlink(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x8bd6);
	return 0;
}

static struct kretprobe kretprobe__vfs_symlink = {
	.kp = { .symbol_name = "vfs_symlink", },
	.handler = (kretprobe_handler_t)kretprobe_handler__vfs_symlink,
	.maxactive = 64,

};

static int kretprobe_handler__vfs_link(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x8b12);
	return 0;
}

static struct kretprobe kretprobe__vfs_link = {
	.kp = { .symbol_name = "vfs_link", },
	.handler = (kretprobe_handler_t)kretprobe_handler__vfs_link,
	.maxactive = 64,

};

static int kretprobe_handler__permission(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x8a9b);
	return 0;
}

static struct kretprobe kretprobe__permission = {
	.kp = { .symbol_name = "permission", },
	.handler = (kretprobe_handler_t)kretprobe_handler__permission,
	.maxactive = 64,

};

static int kretprobe_handler__generic_permission(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x89f6);
	return 0;
}

static struct kretprobe kretprobe__generic_permission = {
	.kp = { .symbol_name = "generic_permission", },
	.handler = (kretprobe_handler_t)kretprobe_handler__generic_permission,
	.maxactive = 64,

};

static int kretprobe_handler__get_write_access(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x86b8);
	return 0;
}

static struct kretprobe kretprobe__get_write_access = {
	.kp = { .symbol_name = "get_write_access", },
	.handler = (kretprobe_handler_t)kretprobe_handler__get_write_access,
	.maxactive = 64,

};

static int kretprobe_handler__page_symlink(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x813f);
	return 0;
}

static struct kretprobe kretprobe__page_symlink = {
	.kp = { .symbol_name = "page_symlink", },
	.handler = (kretprobe_handler_t)kretprobe_handler__page_symlink,
	.maxactive = 64,

};

static int kretprobe_handler____page_symlink(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7f8a);
	return 0;
}

static struct kretprobe kretprobe____page_symlink = {
	.kp = { .symbol_name = "__page_symlink", },
	.handler = (kretprobe_handler_t)kretprobe_handler____page_symlink,
	.maxactive = 64,

};

static int kretprobe_handler__fifo_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x65ff);
	return 0;
}

static struct kretprobe kretprobe__fifo_open = {
	.kp = { .symbol_name = "fifo_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__fifo_open,
	.maxactive = 64,

};

static int kretprobe_handler__wait_for_partner(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x6527);
	return 0;
}

static struct kretprobe kretprobe__wait_for_partner = {
	.kp = { .symbol_name = "wait_for_partner", },
	.handler = (kretprobe_handler_t)kretprobe_handler__wait_for_partner,
	.maxactive = 64,

};

static int kretprobe_handler__wake_up_partner(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x64ff);
	return 0;
}

static struct kretprobe kretprobe__wake_up_partner = {
	.kp = { .symbol_name = "wake_up_partner", },
	.handler = (kretprobe_handler_t)kretprobe_handler__wake_up_partner,
	.maxactive = 64,

};

static int kretprobe_handler__locks_mandatory_area(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x9009);
	return 0;
}

static struct kretprobe kretprobe__locks_mandatory_area = {
	.kp = { .symbol_name = "locks_mandatory_area", },
	.handler = (kretprobe_handler_t)kretprobe_handler__locks_mandatory_area,
	.maxactive = 64,

};

static int kretprobe_handler____break_lease(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x8677);
	return 0;
}

static struct kretprobe kretprobe____break_lease = {
	.kp = { .symbol_name = "__break_lease", },
	.handler = (kretprobe_handler_t)kretprobe_handler____break_lease,
	.maxactive = 64,

};

static int kretprobe_handler__locks_mandatory_locked(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x84e7);
	return 0;
}

static struct kretprobe kretprobe__locks_mandatory_locked = {
	.kp = { .symbol_name = "locks_mandatory_locked", },
	.handler = (kretprobe_handler_t)kretprobe_handler__locks_mandatory_locked,
	.maxactive = 64,

};

static int kretprobe_handler__lease_get_mtime(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x82c3);
	return 0;
}

static struct kretprobe kretprobe__lease_get_mtime = {
	.kp = { .symbol_name = "lease_get_mtime", },
	.handler = (kretprobe_handler_t)kretprobe_handler__lease_get_mtime,
	.maxactive = 64,

};

static int kretprobe_handler____posix_lock_file_conf(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7e15);
	return 0;
}

static struct kretprobe kretprobe____posix_lock_file_conf = {
	.kp = { .symbol_name = "__posix_lock_file_conf", },
	.handler = (kretprobe_handler_t)kretprobe_handler____posix_lock_file_conf,
	.maxactive = 64,

};

static int kretprobe_handler__time_out_leases(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7a62);
	return 0;
}

static struct kretprobe kretprobe__time_out_leases = {
	.kp = { .symbol_name = "time_out_leases", },
	.handler = (kretprobe_handler_t)kretprobe_handler__time_out_leases,
	.maxactive = 64,

};

static int kretprobe_handler__lock_may_write(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x76d8);
	return 0;
}

static struct kretprobe kretprobe__lock_may_write = {
	.kp = { .symbol_name = "lock_may_write", },
	.handler = (kretprobe_handler_t)kretprobe_handler__lock_may_write,
	.maxactive = 64,

};

static int kretprobe_handler__lock_may_read(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x766c);
	return 0;
}

static struct kretprobe kretprobe__lock_may_read = {
	.kp = { .symbol_name = "lock_may_read", },
	.handler = (kretprobe_handler_t)kretprobe_handler__lock_may_read,
	.maxactive = 64,

};

static int kretprobe_handler__d_splice_alias(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xa317);
	return 0;
}

static struct kretprobe kretprobe__d_splice_alias = {
	.kp = { .symbol_name = "d_splice_alias", },
	.handler = (kretprobe_handler_t)kretprobe_handler__d_splice_alias,
	.maxactive = 64,

};

static int kretprobe_handler__d_materialise_unique(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x9c45);
	return 0;
}

static struct kretprobe kretprobe__d_materialise_unique = {
	.kp = { .symbol_name = "d_materialise_unique", },
	.handler = (kretprobe_handler_t)kretprobe_handler__d_materialise_unique,
	.maxactive = 64,

};

static int kretprobe_handler__d_prune_aliases(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x99c3);
	return 0;
}

static struct kretprobe kretprobe__d_prune_aliases = {
	.kp = { .symbol_name = "d_prune_aliases", },
	.handler = (kretprobe_handler_t)kretprobe_handler__d_prune_aliases,
	.maxactive = 64,

};

static int kretprobe_handler__d_instantiate_unique(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x9974);
	return 0;
}

static struct kretprobe kretprobe__d_instantiate_unique = {
	.kp = { .symbol_name = "d_instantiate_unique", },
	.handler = (kretprobe_handler_t)kretprobe_handler__d_instantiate_unique,
	.maxactive = 64,

};

static int kretprobe_handler__d_alloc_anon(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x911b);
	return 0;
}

static struct kretprobe kretprobe__d_alloc_anon = {
	.kp = { .symbol_name = "d_alloc_anon", },
	.handler = (kretprobe_handler_t)kretprobe_handler__d_alloc_anon,
	.maxactive = 64,

};

static int kretprobe_handler__d_alloc_root(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x8e6d);
	return 0;
}

static struct kretprobe kretprobe__d_alloc_root = {
	.kp = { .symbol_name = "d_alloc_root", },
	.handler = (kretprobe_handler_t)kretprobe_handler__d_alloc_root,
	.maxactive = 64,

};

static int kretprobe_handler__d_instantiate(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x8b67);
	return 0;
}

static struct kretprobe kretprobe__d_instantiate = {
	.kp = { .symbol_name = "d_instantiate", },
	.handler = (kretprobe_handler_t)kretprobe_handler__d_instantiate,
	.maxactive = 64,

};

static int kretprobe_handler____d_instantiate_unique(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x8a69);
	return 0;
}

static struct kretprobe kretprobe____d_instantiate_unique = {
	.kp = { .symbol_name = "__d_instantiate_unique", },
	.handler = (kretprobe_handler_t)kretprobe_handler____d_instantiate_unique,
	.maxactive = 64,

};

static int kretprobe_handler__d_find_alias(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7e74);
	return 0;
}

static struct kretprobe kretprobe__d_find_alias = {
	.kp = { .symbol_name = "d_find_alias", },
	.handler = (kretprobe_handler_t)kretprobe_handler__d_find_alias,
	.maxactive = 64,

};

static int kretprobe_handler____d_find_alias(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7a5f);
	return 0;
}

static struct kretprobe kretprobe____d_find_alias = {
	.kp = { .symbol_name = "__d_find_alias", },
	.handler = (kretprobe_handler_t)kretprobe_handler____d_find_alias,
	.maxactive = 64,

};

static int kretprobe_handler__inode_init_once(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x9035);
	return 0;
}

static struct kretprobe kretprobe__inode_init_once = {
	.kp = { .symbol_name = "inode_init_once", },
	.handler = (kretprobe_handler_t)kretprobe_handler__inode_init_once,
	.maxactive = 64,

};

static int kretprobe_handler__generic_drop_inode(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x8974);
	return 0;
}

static struct kretprobe kretprobe__generic_drop_inode = {
	.kp = { .symbol_name = "generic_drop_inode", },
	.handler = (kretprobe_handler_t)kretprobe_handler__generic_drop_inode,
	.maxactive = 64,

};

static int kretprobe_handler__generic_delete_inode(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x87a4);
	return 0;
}

static struct kretprobe kretprobe__generic_delete_inode = {
	.kp = { .symbol_name = "generic_delete_inode", },
	.handler = (kretprobe_handler_t)kretprobe_handler__generic_delete_inode,
	.maxactive = 64,

};

static int kretprobe_handler__clear_inode(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x872b);
	return 0;
}

static struct kretprobe kretprobe__clear_inode = {
	.kp = { .symbol_name = "clear_inode", },
	.handler = (kretprobe_handler_t)kretprobe_handler__clear_inode,
	.maxactive = 64,

};

static int kretprobe_handler__destroy_inode(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x824a);
	return 0;
}

static struct kretprobe kretprobe__destroy_inode = {
	.kp = { .symbol_name = "destroy_inode", },
	.handler = (kretprobe_handler_t)kretprobe_handler__destroy_inode,
	.maxactive = 64,

};

static int kretprobe_handler____wait_on_freeing_inode(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7d38);
	return 0;
}

static struct kretprobe kretprobe____wait_on_freeing_inode = {
	.kp = { .symbol_name = "__wait_on_freeing_inode", },
	.handler = (kretprobe_handler_t)kretprobe_handler____wait_on_freeing_inode,
	.maxactive = 64,

};

static int kretprobe_handler__iput(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7cc6);
	return 0;
}

static struct kretprobe kretprobe__iput = {
	.kp = { .symbol_name = "iput", },
	.handler = (kretprobe_handler_t)kretprobe_handler__iput,
	.maxactive = 64,

};

static int kretprobe_handler__unlock_new_inode(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7c6c);
	return 0;
}

static struct kretprobe kretprobe__unlock_new_inode = {
	.kp = { .symbol_name = "unlock_new_inode", },
	.handler = (kretprobe_handler_t)kretprobe_handler__unlock_new_inode,
	.maxactive = 64,

};

static int kretprobe_handler__wake_up_inode(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7c41);
	return 0;
}

static struct kretprobe kretprobe__wake_up_inode = {
	.kp = { .symbol_name = "wake_up_inode", },
	.handler = (kretprobe_handler_t)kretprobe_handler__wake_up_inode,
	.maxactive = 64,

};

static int kretprobe_handler__igrab(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7c12);
	return 0;
}

static struct kretprobe kretprobe__igrab = {
	.kp = { .symbol_name = "igrab", },
	.handler = (kretprobe_handler_t)kretprobe_handler__igrab,
	.maxactive = 64,

};

static int kretprobe_handler____iget(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7b76);
	return 0;
}

static struct kretprobe kretprobe____iget = {
	.kp = { .symbol_name = "__iget", },
	.handler = (kretprobe_handler_t)kretprobe_handler____iget,
	.maxactive = 64,

};

static int kretprobe_handler__inode_double_unlock(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7b3b);
	return 0;
}

static struct kretprobe kretprobe__inode_double_unlock = {
	.kp = { .symbol_name = "inode_double_unlock", },
	.handler = (kretprobe_handler_t)kretprobe_handler__inode_double_unlock,
	.maxactive = 64,

};

static int kretprobe_handler____insert_inode_hash(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7aca);
	return 0;
}

static struct kretprobe kretprobe____insert_inode_hash = {
	.kp = { .symbol_name = "__insert_inode_hash", },
	.handler = (kretprobe_handler_t)kretprobe_handler____insert_inode_hash,
	.maxactive = 64,

};

static int kretprobe_handler__remove_inode_hash(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7a27);
	return 0;
}

static struct kretprobe kretprobe__remove_inode_hash = {
	.kp = { .symbol_name = "remove_inode_hash", },
	.handler = (kretprobe_handler_t)kretprobe_handler__remove_inode_hash,
	.maxactive = 64,

};

static int kretprobe_handler__inode_double_lock(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x79ec);
	return 0;
}

static struct kretprobe kretprobe__inode_double_lock = {
	.kp = { .symbol_name = "inode_double_lock", },
	.handler = (kretprobe_handler_t)kretprobe_handler__inode_double_lock,
	.maxactive = 64,

};

static int kretprobe_handler__init_special_inode(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x793d);
	return 0;
}

static struct kretprobe kretprobe__init_special_inode = {
	.kp = { .symbol_name = "init_special_inode", },
	.handler = (kretprobe_handler_t)kretprobe_handler__init_special_inode,
	.maxactive = 64,

};

static int kretprobe_handler__inode_needs_sync(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x78e0);
	return 0;
}

static struct kretprobe kretprobe__inode_needs_sync = {
	.kp = { .symbol_name = "inode_needs_sync", },
	.handler = (kretprobe_handler_t)kretprobe_handler__inode_needs_sync,
	.maxactive = 64,

};

static int kretprobe_handler__bmap(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7891);
	return 0;
}

static struct kretprobe kretprobe__bmap = {
	.kp = { .symbol_name = "bmap", },
	.handler = (kretprobe_handler_t)kretprobe_handler__bmap,
	.maxactive = 64,

};

static int kretprobe_handler__inode_setattr(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7163);
	return 0;
}

static struct kretprobe kretprobe__inode_setattr = {
	.kp = { .symbol_name = "inode_setattr", },
	.handler = (kretprobe_handler_t)kretprobe_handler__inode_setattr,
	.maxactive = 64,

};

static int kretprobe_handler__inode_change_ok(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x705f);
	return 0;
}

static struct kretprobe kretprobe__inode_change_ok = {
	.kp = { .symbol_name = "inode_change_ok", },
	.handler = (kretprobe_handler_t)kretprobe_handler__inode_change_ok,
	.maxactive = 64,

};

static int kretprobe_handler__make_bad_inode(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x76e7);
	return 0;
}

static struct kretprobe kretprobe__make_bad_inode = {
	.kp = { .symbol_name = "make_bad_inode", },
	.handler = (kretprobe_handler_t)kretprobe_handler__make_bad_inode,
	.maxactive = 64,

};

static int kretprobe_handler__is_bad_inode(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x76b8);
	return 0;
}

static struct kretprobe kretprobe__is_bad_inode = {
	.kp = { .symbol_name = "is_bad_inode", },
	.handler = (kretprobe_handler_t)kretprobe_handler__is_bad_inode,
	.maxactive = 64,

};

static int kretprobe_handler__bad_inode_permission(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x74a5);
	return 0;
}

static struct kretprobe kretprobe__bad_inode_permission = {
	.kp = { .symbol_name = "bad_inode_permission", },
	.handler = (kretprobe_handler_t)kretprobe_handler__bad_inode_permission,
	.maxactive = 64,

};

static int kretprobe_handler__bad_inode_rename(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x740b);
	return 0;
}

static struct kretprobe kretprobe__bad_inode_rename = {
	.kp = { .symbol_name = "bad_inode_rename", },
	.handler = (kretprobe_handler_t)kretprobe_handler__bad_inode_rename,
	.maxactive = 64,

};

static int kretprobe_handler__bad_inode_mknod(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x73b7);
	return 0;
}

static struct kretprobe kretprobe__bad_inode_mknod = {
	.kp = { .symbol_name = "bad_inode_mknod", },
	.handler = (kretprobe_handler_t)kretprobe_handler__bad_inode_mknod,
	.maxactive = 64,

};

static int kretprobe_handler__bad_inode_rmdir(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x737e);
	return 0;
}

static struct kretprobe kretprobe__bad_inode_rmdir = {
	.kp = { .symbol_name = "bad_inode_rmdir", },
	.handler = (kretprobe_handler_t)kretprobe_handler__bad_inode_rmdir,
	.maxactive = 64,

};

static int kretprobe_handler__bad_inode_mkdir(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7338);
	return 0;
}

static struct kretprobe kretprobe__bad_inode_mkdir = {
	.kp = { .symbol_name = "bad_inode_mkdir", },
	.handler = (kretprobe_handler_t)kretprobe_handler__bad_inode_mkdir,
	.maxactive = 64,

};

static int kretprobe_handler__bad_inode_symlink(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x72f2);
	return 0;
}

static struct kretprobe kretprobe__bad_inode_symlink = {
	.kp = { .symbol_name = "bad_inode_symlink", },
	.handler = (kretprobe_handler_t)kretprobe_handler__bad_inode_symlink,
	.maxactive = 64,

};

static int kretprobe_handler__bad_inode_unlink(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x72b9);
	return 0;
}

static struct kretprobe kretprobe__bad_inode_unlink = {
	.kp = { .symbol_name = "bad_inode_unlink", },
	.handler = (kretprobe_handler_t)kretprobe_handler__bad_inode_unlink,
	.maxactive = 64,

};

static int kretprobe_handler__bad_inode_link(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7273);
	return 0;
}

static struct kretprobe kretprobe__bad_inode_link = {
	.kp = { .symbol_name = "bad_inode_link", },
	.handler = (kretprobe_handler_t)kretprobe_handler__bad_inode_link,
	.maxactive = 64,

};

static int kretprobe_handler__bad_inode_lookup(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x722e);
	return 0;
}

static struct kretprobe kretprobe__bad_inode_lookup = {
	.kp = { .symbol_name = "bad_inode_lookup", },
	.handler = (kretprobe_handler_t)kretprobe_handler__bad_inode_lookup,
	.maxactive = 64,

};

static int kretprobe_handler__bad_inode_create(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x71be);
	return 0;
}

static struct kretprobe kretprobe__bad_inode_create = {
	.kp = { .symbol_name = "bad_inode_create", },
	.handler = (kretprobe_handler_t)kretprobe_handler__bad_inode_create,
	.maxactive = 64,

};

static int kretprobe_handler__bad_file_release(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x6ddc);
	return 0;
}

static struct kretprobe kretprobe__bad_file_release = {
	.kp = { .symbol_name = "bad_file_release", },
	.handler = (kretprobe_handler_t)kretprobe_handler__bad_file_release,
	.maxactive = 64,

};

static int kretprobe_handler__bad_file_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x6d6b);
	return 0;
}

static struct kretprobe kretprobe__bad_file_open = {
	.kp = { .symbol_name = "bad_file_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__bad_file_open,
	.maxactive = 64,

};

static int kretprobe_handler__bad_file_ioctl(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x6c52);
	return 0;
}

static struct kretprobe kretprobe__bad_file_ioctl = {
	.kp = { .symbol_name = "bad_file_ioctl", },
	.handler = (kretprobe_handler_t)kretprobe_handler__bad_file_ioctl,
	.maxactive = 64,

};

static int kretprobe_handler__single_release(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x6f1b);
	return 0;
}

static struct kretprobe kretprobe__single_release = {
	.kp = { .symbol_name = "single_release", },
	.handler = (kretprobe_handler_t)kretprobe_handler__single_release,
	.maxactive = 64,

};

static int kretprobe_handler__seq_release_private(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x6ecc);
	return 0;
}

static struct kretprobe kretprobe__seq_release_private = {
	.kp = { .symbol_name = "seq_release_private", },
	.handler = (kretprobe_handler_t)kretprobe_handler__seq_release_private,
	.maxactive = 64,

};

static int kretprobe_handler__seq_release(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x6e7f);
	return 0;
}

static struct kretprobe kretprobe__seq_release = {
	.kp = { .symbol_name = "seq_release", },
	.handler = (kretprobe_handler_t)kretprobe_handler__seq_release,
	.maxactive = 64,

};

static int kretprobe_handler__xattr_permission(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7625);
	return 0;
}

static struct kretprobe kretprobe__xattr_permission = {
	.kp = { .symbol_name = "xattr_permission", },
	.handler = (kretprobe_handler_t)kretprobe_handler__xattr_permission,
	.maxactive = 64,

};

static int kretprobe_handler__simple_lookup(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x8495);
	return 0;
}

static struct kretprobe kretprobe__simple_lookup = {
	.kp = { .symbol_name = "simple_lookup", },
	.handler = (kretprobe_handler_t)kretprobe_handler__simple_lookup,
	.maxactive = 64,

};

static int kretprobe_handler__simple_rename(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x8128);
	return 0;
}

static struct kretprobe kretprobe__simple_rename = {
	.kp = { .symbol_name = "simple_rename", },
	.handler = (kretprobe_handler_t)kretprobe_handler__simple_rename,
	.maxactive = 64,

};

static int kretprobe_handler__simple_rmdir(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x80b5);
	return 0;
}

static struct kretprobe kretprobe__simple_rmdir = {
	.kp = { .symbol_name = "simple_rmdir", },
	.handler = (kretprobe_handler_t)kretprobe_handler__simple_rmdir,
	.maxactive = 64,

};

static int kretprobe_handler__simple_link(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x8002);
	return 0;
}

static struct kretprobe kretprobe__simple_link = {
	.kp = { .symbol_name = "simple_link", },
	.handler = (kretprobe_handler_t)kretprobe_handler__simple_link,
	.maxactive = 64,

};

static int kretprobe_handler__dcache_dir_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7ae9);
	return 0;
}

static struct kretprobe kretprobe__dcache_dir_open = {
	.kp = { .symbol_name = "dcache_dir_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__dcache_dir_open,
	.maxactive = 64,

};

static int kretprobe_handler__dcache_dir_close(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x78fd);
	return 0;
}

static struct kretprobe kretprobe__dcache_dir_close = {
	.kp = { .symbol_name = "dcache_dir_close", },
	.handler = (kretprobe_handler_t)kretprobe_handler__dcache_dir_close,
	.maxactive = 64,

};

static int kretprobe_handler__simple_unlink(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7898);
	return 0;
}

static struct kretprobe kretprobe__simple_unlink = {
	.kp = { .symbol_name = "simple_unlink", },
	.handler = (kretprobe_handler_t)kretprobe_handler__simple_unlink,
	.maxactive = 64,

};

static int kretprobe_handler__simple_transaction_release(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x753d);
	return 0;
}

static struct kretprobe kretprobe__simple_transaction_release = {
	.kp = { .symbol_name = "simple_transaction_release", },
	.handler = (kretprobe_handler_t)kretprobe_handler__simple_transaction_release,
	.maxactive = 64,

};

static int kretprobe_handler__simple_attr_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7492);
	return 0;
}

static struct kretprobe kretprobe__simple_attr_open = {
	.kp = { .symbol_name = "simple_attr_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__simple_attr_open,
	.maxactive = 64,

};

static int kretprobe_handler__simple_attr_close(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7419);
	return 0;
}

static struct kretprobe kretprobe__simple_attr_close = {
	.kp = { .symbol_name = "simple_attr_close", },
	.handler = (kretprobe_handler_t)kretprobe_handler__simple_attr_close,
	.maxactive = 64,

};

static int kretprobe_handler____mark_inode_dirty(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x9d65);
	return 0;
}

static struct kretprobe kretprobe____mark_inode_dirty = {
	.kp = { .symbol_name = "__mark_inode_dirty", },
	.handler = (kretprobe_handler_t)kretprobe_handler____mark_inode_dirty,
	.maxactive = 64,

};

static int kretprobe_handler__generic_osync_inode(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x982d);
	return 0;
}

static struct kretprobe kretprobe__generic_osync_inode = {
	.kp = { .symbol_name = "generic_osync_inode", },
	.handler = (kretprobe_handler_t)kretprobe_handler__generic_osync_inode,
	.maxactive = 64,

};

static int kretprobe_handler__write_inode_now(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x977a);
	return 0;
}

static struct kretprobe kretprobe__write_inode_now = {
	.kp = { .symbol_name = "write_inode_now", },
	.handler = (kretprobe_handler_t)kretprobe_handler__write_inode_now,
	.maxactive = 64,

};

static int kretprobe_handler__sync_inode(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x972b);
	return 0;
}

static struct kretprobe kretprobe__sync_inode = {
	.kp = { .symbol_name = "sync_inode", },
	.handler = (kretprobe_handler_t)kretprobe_handler__sync_inode,
	.maxactive = 64,

};

static int kretprobe_handler____writeback_single_inode(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x9465);
	return 0;
}

static struct kretprobe kretprobe____writeback_single_inode = {
	.kp = { .symbol_name = "__writeback_single_inode", },
	.handler = (kretprobe_handler_t)kretprobe_handler____writeback_single_inode,
	.maxactive = 64,

};

static int kretprobe_handler__fsstack_copy_attr_all(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x6a58);
	return 0;
}

static struct kretprobe kretprobe__fsstack_copy_attr_all = {
	.kp = { .symbol_name = "fsstack_copy_attr_all", },
	.handler = (kretprobe_handler_t)kretprobe_handler__fsstack_copy_attr_all,
	.maxactive = 64,

};

static int kretprobe_handler__fsstack_copy_inode_size(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x6a0c);
	return 0;
}

static struct kretprobe kretprobe__fsstack_copy_inode_size = {
	.kp = { .symbol_name = "fsstack_copy_inode_size", },
	.handler = (kretprobe_handler_t)kretprobe_handler__fsstack_copy_inode_size,
	.maxactive = 64,

};

static int kretprobe_handler__invalidate_inode_buffers(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xee14);
	return 0;
}

static struct kretprobe kretprobe__invalidate_inode_buffers = {
	.kp = { .symbol_name = "invalidate_inode_buffers", },
	.handler = (kretprobe_handler_t)kretprobe_handler__invalidate_inode_buffers,
	.maxactive = 64,

};

static int kretprobe_handler__remove_inode_buffers(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xe2a9);
	return 0;
}

static struct kretprobe kretprobe__remove_inode_buffers = {
	.kp = { .symbol_name = "remove_inode_buffers", },
	.handler = (kretprobe_handler_t)kretprobe_handler__remove_inode_buffers,
	.maxactive = 64,

};

static int kretprobe_handler__mark_buffer_dirty_inode(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xe1f7);
	return 0;
}

static struct kretprobe kretprobe__mark_buffer_dirty_inode = {
	.kp = { .symbol_name = "mark_buffer_dirty_inode", },
	.handler = (kretprobe_handler_t)kretprobe_handler__mark_buffer_dirty_inode,
	.maxactive = 64,

};

static int kretprobe_handler____block_write_full_page(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xce32);
	return 0;
}

static struct kretprobe kretprobe____block_write_full_page = {
	.kp = { .symbol_name = "__block_write_full_page", },
	.handler = (kretprobe_handler_t)kretprobe_handler____block_write_full_page,
	.maxactive = 64,

};

static int kretprobe_handler____block_prepare_write(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xc5e3);
	return 0;
}

static struct kretprobe kretprobe____block_prepare_write = {
	.kp = { .symbol_name = "__block_prepare_write", },
	.handler = (kretprobe_handler_t)kretprobe_handler____block_prepare_write,
	.maxactive = 64,

};

static int kretprobe_handler____block_commit_write(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xb849);
	return 0;
}

static struct kretprobe kretprobe____block_commit_write = {
	.kp = { .symbol_name = "__block_commit_write", },
	.handler = (kretprobe_handler_t)kretprobe_handler____block_commit_write,
	.maxactive = 64,

};

static int kretprobe_handler__generic_cont_expand(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xab4a);
	return 0;
}

static struct kretprobe kretprobe__generic_cont_expand = {
	.kp = { .symbol_name = "generic_cont_expand", },
	.handler = (kretprobe_handler_t)kretprobe_handler__generic_cont_expand,
	.maxactive = 64,

};

static int kretprobe_handler__generic_cont_expand_simple(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xaae3);
	return 0;
}

static struct kretprobe kretprobe__generic_cont_expand_simple = {
	.kp = { .symbol_name = "generic_cont_expand_simple", },
	.handler = (kretprobe_handler_t)kretprobe_handler__generic_cont_expand_simple,
	.maxactive = 64,

};

static int kretprobe_handler____generic_cont_expand(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xa9fb);
	return 0;
}

static struct kretprobe kretprobe____generic_cont_expand = {
	.kp = { .symbol_name = "__generic_cont_expand", },
	.handler = (kretprobe_handler_t)kretprobe_handler____generic_cont_expand,
	.maxactive = 64,

};

static int kretprobe_handler__inode_has_buffers(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x9e6a);
	return 0;
}

static struct kretprobe kretprobe__inode_has_buffers = {
	.kp = { .symbol_name = "inode_has_buffers", },
	.handler = (kretprobe_handler_t)kretprobe_handler__inode_has_buffers,
	.maxactive = 64,

};

static int kretprobe_handler__bdev_clear_inode(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xad52);
	return 0;
}

static struct kretprobe kretprobe__bdev_clear_inode = {
	.kp = { .symbol_name = "bdev_clear_inode", },
	.handler = (kretprobe_handler_t)kretprobe_handler__bdev_clear_inode,
	.maxactive = 64,

};

static int kretprobe_handler__blkdev_close(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xace1);
	return 0;
}

static struct kretprobe kretprobe__blkdev_close = {
	.kp = { .symbol_name = "blkdev_close", },
	.handler = (kretprobe_handler_t)kretprobe_handler__blkdev_close,
	.maxactive = 64,

};

static int kretprobe_handler__blkdev_get_block(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xab1a);
	return 0;
}

static struct kretprobe kretprobe__blkdev_get_block = {
	.kp = { .symbol_name = "blkdev_get_block", },
	.handler = (kretprobe_handler_t)kretprobe_handler__blkdev_get_block,
	.maxactive = 64,

};

static int kretprobe_handler__bdev_test(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xaa5a);
	return 0;
}

static struct kretprobe kretprobe__bdev_test = {
	.kp = { .symbol_name = "bdev_test", },
	.handler = (kretprobe_handler_t)kretprobe_handler__bdev_test,
	.maxactive = 64,

};

static int kretprobe_handler__bdev_destroy_inode(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xaa0a);
	return 0;
}

static struct kretprobe kretprobe__bdev_destroy_inode = {
	.kp = { .symbol_name = "bdev_destroy_inode", },
	.handler = (kretprobe_handler_t)kretprobe_handler__bdev_destroy_inode,
	.maxactive = 64,

};

static int kretprobe_handler__blkdev_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xa481);
	return 0;
}

static struct kretprobe kretprobe__blkdev_open = {
	.kp = { .symbol_name = "blkdev_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__blkdev_open,
	.maxactive = 64,

};

static int kretprobe_handler__bd_acquire(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xa391);
	return 0;
}

static struct kretprobe kretprobe__bd_acquire = {
	.kp = { .symbol_name = "bd_acquire", },
	.handler = (kretprobe_handler_t)kretprobe_handler__bd_acquire,
	.maxactive = 64,

};

static int kretprobe_handler__bd_forget(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x9f93);
	return 0;
}

static struct kretprobe kretprobe__bd_forget = {
	.kp = { .symbol_name = "bd_forget", },
	.handler = (kretprobe_handler_t)kretprobe_handler__bd_forget,
	.maxactive = 64,

};

static int kretprobe_handler__bdev_set(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x9411);
	return 0;
}

static struct kretprobe kretprobe__bdev_set = {
	.kp = { .symbol_name = "bdev_set", },
	.handler = (kretprobe_handler_t)kretprobe_handler__bdev_set,
	.maxactive = 64,

};

static int kretprobe_handler____blockdev_direct_IO(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x9ffe);
	return 0;
}

static struct kretprobe kretprobe____blockdev_direct_IO = {
	.kp = { .symbol_name = "__blockdev_direct_IO", },
	.handler = (kretprobe_handler_t)kretprobe_handler____blockdev_direct_IO,
	.maxactive = 64,

};

static int kretprobe_handler__inotify_d_instantiate(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x78e5);
	return 0;
}

static struct kretprobe kretprobe__inotify_d_instantiate = {
	.kp = { .symbol_name = "inotify_d_instantiate", },
	.handler = (kretprobe_handler_t)kretprobe_handler__inotify_d_instantiate,
	.maxactive = 64,

};

static int kretprobe_handler__inotify_inode_is_dead(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7378);
	return 0;
}

static struct kretprobe kretprobe__inotify_inode_is_dead = {
	.kp = { .symbol_name = "inotify_inode_is_dead", },
	.handler = (kretprobe_handler_t)kretprobe_handler__inotify_inode_is_dead,
	.maxactive = 64,

};

static int kretprobe_handler__inotify_inode_queue_event(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7240);
	return 0;
}

static struct kretprobe kretprobe__inotify_inode_queue_event = {
	.kp = { .symbol_name = "inotify_inode_queue_event", },
	.handler = (kretprobe_handler_t)kretprobe_handler__inotify_inode_queue_event,
	.maxactive = 64,

};

static int kretprobe_handler__inotify_add_watch(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x713f);
	return 0;
}

static struct kretprobe kretprobe__inotify_add_watch = {
	.kp = { .symbol_name = "inotify_add_watch", },
	.handler = (kretprobe_handler_t)kretprobe_handler__inotify_add_watch,
	.maxactive = 64,

};

static int kretprobe_handler__set_dentry_child_flags(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x6fb8);
	return 0;
}

static struct kretprobe kretprobe__set_dentry_child_flags = {
	.kp = { .symbol_name = "set_dentry_child_flags", },
	.handler = (kretprobe_handler_t)kretprobe_handler__set_dentry_child_flags,
	.maxactive = 64,

};

static int kretprobe_handler__inotify_find_watch(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x6f44);
	return 0;
}

static struct kretprobe kretprobe__inotify_find_watch = {
	.kp = { .symbol_name = "inotify_find_watch", },
	.handler = (kretprobe_handler_t)kretprobe_handler__inotify_find_watch,
	.maxactive = 64,

};

static int kretprobe_handler__inotify_find_update_watch(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x6ebe);
	return 0;
}

static struct kretprobe kretprobe__inotify_find_update_watch = {
	.kp = { .symbol_name = "inotify_find_update_watch", },
	.handler = (kretprobe_handler_t)kretprobe_handler__inotify_find_update_watch,
	.maxactive = 64,

};

static int kretprobe_handler__inode_find_handle(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x6da7);
	return 0;
}

static struct kretprobe kretprobe__inode_find_handle = {
	.kp = { .symbol_name = "inode_find_handle", },
	.handler = (kretprobe_handler_t)kretprobe_handler__inode_find_handle,
	.maxactive = 64,

};

static int kretprobe_handler__inotify_dev_queue_event(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x711f);
	return 0;
}

static struct kretprobe kretprobe__inotify_dev_queue_event = {
	.kp = { .symbol_name = "inotify_dev_queue_event", },
	.handler = (kretprobe_handler_t)kretprobe_handler__inotify_dev_queue_event,
	.maxactive = 64,

};

static int kretprobe_handler__inotify_release(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x6a86);
	return 0;
}

static struct kretprobe kretprobe__inotify_release = {
	.kp = { .symbol_name = "inotify_release", },
	.handler = (kretprobe_handler_t)kretprobe_handler__inotify_release,
	.maxactive = 64,

};

static int kretprobe_handler__ep_eventpoll_close(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7d98);
	return 0;
}

static struct kretprobe kretprobe__ep_eventpoll_close = {
	.kp = { .symbol_name = "ep_eventpoll_close", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ep_eventpoll_close,
	.maxactive = 64,

};

static int kretprobe_handler____inode_dir_notify(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x6a94);
	return 0;
}

static struct kretprobe kretprobe____inode_dir_notify = {
	.kp = { .symbol_name = "__inode_dir_notify", },
	.handler = (kretprobe_handler_t)kretprobe_handler____inode_dir_notify,
	.maxactive = 64,

};

static int kretprobe_handler__redo_inode_mask(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x6a3b);
	return 0;
}

static struct kretprobe kretprobe__redo_inode_mask = {
	.kp = { .symbol_name = "redo_inode_mask", },
	.handler = (kretprobe_handler_t)kretprobe_handler__redo_inode_mask,
	.maxactive = 64,

};

static int kretprobe_handler__proc_exe_link(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7712);
	return 0;
}

static struct kretprobe kretprobe__proc_exe_link = {
	.kp = { .symbol_name = "proc_exe_link", },
	.handler = (kretprobe_handler_t)kretprobe_handler__proc_exe_link,
	.maxactive = 64,

};

static int kretprobe_handler__maps_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x75da);
	return 0;
}

static struct kretprobe kretprobe__maps_open = {
	.kp = { .symbol_name = "maps_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__maps_open,
	.maxactive = 64,

};

static int kretprobe_handler__smaps_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x759c);
	return 0;
}

static struct kretprobe kretprobe__smaps_open = {
	.kp = { .symbol_name = "smaps_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__smaps_open,
	.maxactive = 64,

};

static int kretprobe_handler__do_maps_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x74ca);
	return 0;
}

static struct kretprobe kretprobe__do_maps_open = {
	.kp = { .symbol_name = "do_maps_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__do_maps_open,
	.maxactive = 64,

};

static int kretprobe_handler__proc_delete_inode(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7656);
	return 0;
}

static struct kretprobe kretprobe__proc_delete_inode = {
	.kp = { .symbol_name = "proc_delete_inode", },
	.handler = (kretprobe_handler_t)kretprobe_handler__proc_delete_inode,
	.maxactive = 64,

};

static int kretprobe_handler__proc_destroy_inode(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x73da);
	return 0;
}

static struct kretprobe kretprobe__proc_destroy_inode = {
	.kp = { .symbol_name = "proc_destroy_inode", },
	.handler = (kretprobe_handler_t)kretprobe_handler__proc_destroy_inode,
	.maxactive = 64,

};

static int kretprobe_handler__proc_read_inode(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x73b2);
	return 0;
}

static struct kretprobe kretprobe__proc_read_inode = {
	.kp = { .symbol_name = "proc_read_inode", },
	.handler = (kretprobe_handler_t)kretprobe_handler__proc_read_inode,
	.maxactive = 64,

};

static int kretprobe_handler__proc_root_lookup(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x6e78);
	return 0;
}

static struct kretprobe kretprobe__proc_root_lookup = {
	.kp = { .symbol_name = "proc_root_lookup", },
	.handler = (kretprobe_handler_t)kretprobe_handler__proc_root_lookup,
	.maxactive = 64,

};

static int kretprobe_handler__proc_task_lookup(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xa7fd);
	return 0;
}

static struct kretprobe kretprobe__proc_task_lookup = {
	.kp = { .symbol_name = "proc_task_lookup", },
	.handler = (kretprobe_handler_t)kretprobe_handler__proc_task_lookup,
	.maxactive = 64,

};

static int kretprobe_handler__proc_pid_lookup(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xa397);
	return 0;
}

static struct kretprobe kretprobe__proc_pid_lookup = {
	.kp = { .symbol_name = "proc_pid_lookup", },
	.handler = (kretprobe_handler_t)kretprobe_handler__proc_pid_lookup,
	.maxactive = 64,

};

static int kretprobe_handler__proc_lookupfd(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x9e56);
	return 0;
}

static struct kretprobe kretprobe__proc_lookupfd = {
	.kp = { .symbol_name = "proc_lookupfd", },
	.handler = (kretprobe_handler_t)kretprobe_handler__proc_lookupfd,
	.maxactive = 64,

};

static int kretprobe_handler__proc_fd_link(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x9c78);
	return 0;
}

static struct kretprobe kretprobe__proc_fd_link = {
	.kp = { .symbol_name = "proc_fd_link", },
	.handler = (kretprobe_handler_t)kretprobe_handler__proc_fd_link,
	.maxactive = 64,

};

static int kretprobe_handler__mountstats_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x94a7);
	return 0;
}

static struct kretprobe kretprobe__mountstats_open = {
	.kp = { .symbol_name = "mountstats_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__mountstats_open,
	.maxactive = 64,

};

static int kretprobe_handler__mounts_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x9321);
	return 0;
}

static struct kretprobe kretprobe__mounts_open = {
	.kp = { .symbol_name = "mounts_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__mounts_open,
	.maxactive = 64,

};

static int kretprobe_handler__proc_root_link(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x9186);
	return 0;
}

static struct kretprobe kretprobe__proc_root_link = {
	.kp = { .symbol_name = "proc_root_link", },
	.handler = (kretprobe_handler_t)kretprobe_handler__proc_root_link,
	.maxactive = 64,

};

static int kretprobe_handler__proc_cwd_link(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x903e);
	return 0;
}

static struct kretprobe kretprobe__proc_cwd_link = {
	.kp = { .symbol_name = "proc_cwd_link", },
	.handler = (kretprobe_handler_t)kretprobe_handler__proc_cwd_link,
	.maxactive = 64,

};

static int kretprobe_handler__mem_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x8bb8);
	return 0;
}

static struct kretprobe kretprobe__mem_open = {
	.kp = { .symbol_name = "mem_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__mem_open,
	.maxactive = 64,

};

static int kretprobe_handler__proc_fd_access_allowed(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x871a);
	return 0;
}

static struct kretprobe kretprobe__proc_fd_access_allowed = {
	.kp = { .symbol_name = "proc_fd_access_allowed", },
	.handler = (kretprobe_handler_t)kretprobe_handler__proc_fd_access_allowed,
	.maxactive = 64,

};

static int kretprobe_handler__proc_tgid_base_lookup(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x86cd);
	return 0;
}

static struct kretprobe kretprobe__proc_tgid_base_lookup = {
	.kp = { .symbol_name = "proc_tgid_base_lookup", },
	.handler = (kretprobe_handler_t)kretprobe_handler__proc_tgid_base_lookup,
	.maxactive = 64,

};

static int kretprobe_handler__proc_tid_base_lookup(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x8680);
	return 0;
}

static struct kretprobe kretprobe__proc_tid_base_lookup = {
	.kp = { .symbol_name = "proc_tid_base_lookup", },
	.handler = (kretprobe_handler_t)kretprobe_handler__proc_tid_base_lookup,
	.maxactive = 64,

};

static int kretprobe_handler__proc_pident_lookup(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x854b);
	return 0;
}

static struct kretprobe kretprobe__proc_pident_lookup = {
	.kp = { .symbol_name = "proc_pident_lookup", },
	.handler = (kretprobe_handler_t)kretprobe_handler__proc_pident_lookup,
	.maxactive = 64,

};

static int kretprobe_handler__proc_pident_instantiate(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x847b);
	return 0;
}

static struct kretprobe kretprobe__proc_pident_instantiate = {
	.kp = { .symbol_name = "proc_pident_instantiate", },
	.handler = (kretprobe_handler_t)kretprobe_handler__proc_pident_instantiate,
	.maxactive = 64,

};

static int kretprobe_handler__proc_pid_instantiate(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x83dd);
	return 0;
}

static struct kretprobe kretprobe__proc_pid_instantiate = {
	.kp = { .symbol_name = "proc_pid_instantiate", },
	.handler = (kretprobe_handler_t)kretprobe_handler__proc_pid_instantiate,
	.maxactive = 64,

};

static int kretprobe_handler__proc_task_instantiate(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x833f);
	return 0;
}

static struct kretprobe kretprobe__proc_task_instantiate = {
	.kp = { .symbol_name = "proc_task_instantiate", },
	.handler = (kretprobe_handler_t)kretprobe_handler__proc_task_instantiate,
	.maxactive = 64,

};

static int kretprobe_handler__proc_fd_instantiate(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x808c);
	return 0;
}

static struct kretprobe kretprobe__proc_fd_instantiate = {
	.kp = { .symbol_name = "proc_fd_instantiate", },
	.handler = (kretprobe_handler_t)kretprobe_handler__proc_fd_instantiate,
	.maxactive = 64,

};

static int kretprobe_handler__mounts_release(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7734);
	return 0;
}

static struct kretprobe kretprobe__mounts_release = {
	.kp = { .symbol_name = "mounts_release", },
	.handler = (kretprobe_handler_t)kretprobe_handler__mounts_release,
	.maxactive = 64,

};

static int kretprobe_handler__proc_base_instantiate(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7637);
	return 0;
}

static struct kretprobe kretprobe__proc_base_instantiate = {
	.kp = { .symbol_name = "proc_base_instantiate", },
	.handler = (kretprobe_handler_t)kretprobe_handler__proc_base_instantiate,
	.maxactive = 64,

};

static int kretprobe_handler__proc_lookup(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7e45);
	return 0;
}

static struct kretprobe kretprobe__proc_lookup = {
	.kp = { .symbol_name = "proc_lookup", },
	.handler = (kretprobe_handler_t)kretprobe_handler__proc_lookup,
	.maxactive = 64,

};

static int kretprobe_handler__tty_drivers_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7a93);
	return 0;
}

static struct kretprobe kretprobe__tty_drivers_open = {
	.kp = { .symbol_name = "tty_drivers_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__tty_drivers_open,
	.maxactive = 64,

};

static int kretprobe_handler__stat_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xaae3);
	return 0;
}

static struct kretprobe kretprobe__stat_open = {
	.kp = { .symbol_name = "stat_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__stat_open,
	.maxactive = 64,

};

static int kretprobe_handler__slabstats_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xaa1a);
	return 0;
}

static struct kretprobe kretprobe__slabstats_open = {
	.kp = { .symbol_name = "slabstats_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__slabstats_open,
	.maxactive = 64,

};

static int kretprobe_handler__slabstats_release(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xa998);
	return 0;
}

static struct kretprobe kretprobe__slabstats_release = {
	.kp = { .symbol_name = "slabstats_release", },
	.handler = (kretprobe_handler_t)kretprobe_handler__slabstats_release,
	.maxactive = 64,

};

static int kretprobe_handler__fragmentation_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xa95d);
	return 0;
}

static struct kretprobe kretprobe__fragmentation_open = {
	.kp = { .symbol_name = "fragmentation_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__fragmentation_open,
	.maxactive = 64,

};

static int kretprobe_handler__zoneinfo_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xa922);
	return 0;
}

static struct kretprobe kretprobe__zoneinfo_open = {
	.kp = { .symbol_name = "zoneinfo_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__zoneinfo_open,
	.maxactive = 64,

};

static int kretprobe_handler__cpuinfo_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xa8e4);
	return 0;
}

static struct kretprobe kretprobe__cpuinfo_open = {
	.kp = { .symbol_name = "cpuinfo_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__cpuinfo_open,
	.maxactive = 64,

};

static int kretprobe_handler__devinfo_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xa8a6);
	return 0;
}

static struct kretprobe kretprobe__devinfo_open = {
	.kp = { .symbol_name = "devinfo_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__devinfo_open,
	.maxactive = 64,

};

static int kretprobe_handler__vmstat_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xa868);
	return 0;
}

static struct kretprobe kretprobe__vmstat_open = {
	.kp = { .symbol_name = "vmstat_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__vmstat_open,
	.maxactive = 64,

};

static int kretprobe_handler__partitions_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xa82a);
	return 0;
}

static struct kretprobe kretprobe__partitions_open = {
	.kp = { .symbol_name = "partitions_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__partitions_open,
	.maxactive = 64,

};

static int kretprobe_handler__diskstats_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xa7ec);
	return 0;
}

static struct kretprobe kretprobe__diskstats_open = {
	.kp = { .symbol_name = "diskstats_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__diskstats_open,
	.maxactive = 64,

};

static int kretprobe_handler__modules_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xa7ae);
	return 0;
}

static struct kretprobe kretprobe__modules_open = {
	.kp = { .symbol_name = "modules_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__modules_open,
	.maxactive = 64,

};

static int kretprobe_handler__slabinfo_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xa770);
	return 0;
}

static struct kretprobe kretprobe__slabinfo_open = {
	.kp = { .symbol_name = "slabinfo_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__slabinfo_open,
	.maxactive = 64,

};

static int kretprobe_handler__interrupts_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xa732);
	return 0;
}

static struct kretprobe kretprobe__interrupts_open = {
	.kp = { .symbol_name = "interrupts_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__interrupts_open,
	.maxactive = 64,

};

static int kretprobe_handler__open_kcore(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x6d73);
	return 0;
}

static struct kretprobe kretprobe__open_kcore = {
	.kp = { .symbol_name = "open_kcore", },
	.handler = (kretprobe_handler_t)kretprobe_handler__open_kcore,
	.maxactive = 64,

};

static int kretprobe_handler__kmsg_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x5f51);
	return 0;
}

static struct kretprobe kretprobe__kmsg_open = {
	.kp = { .symbol_name = "kmsg_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__kmsg_open,
	.maxactive = 64,

};

static int kretprobe_handler__kmsg_release(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x5f16);
	return 0;
}

static struct kretprobe kretprobe__kmsg_release = {
	.kp = { .symbol_name = "kmsg_release", },
	.handler = (kretprobe_handler_t)kretprobe_handler__kmsg_release,
	.maxactive = 64,

};

static int kretprobe_handler__sysfs_release(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x77b1);
	return 0;
}

static struct kretprobe kretprobe__sysfs_release = {
	.kp = { .symbol_name = "sysfs_release", },
	.handler = (kretprobe_handler_t)kretprobe_handler__sysfs_release,
	.maxactive = 64,

};

static int kretprobe_handler__sysfs_open_file(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7149);
	return 0;
}

static struct kretprobe kretprobe__sysfs_open_file = {
	.kp = { .symbol_name = "sysfs_open_file", },
	.handler = (kretprobe_handler_t)kretprobe_handler__sysfs_open_file,
	.maxactive = 64,

};

static int kretprobe_handler__sysfs_d_iput(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7f9c);
	return 0;
}

static struct kretprobe kretprobe__sysfs_d_iput = {
	.kp = { .symbol_name = "sysfs_d_iput", },
	.handler = (kretprobe_handler_t)kretprobe_handler__sysfs_d_iput,
	.maxactive = 64,

};

static int kretprobe_handler__sysfs_lookup(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7958);
	return 0;
}

static struct kretprobe kretprobe__sysfs_lookup = {
	.kp = { .symbol_name = "sysfs_lookup", },
	.handler = (kretprobe_handler_t)kretprobe_handler__sysfs_lookup,
	.maxactive = 64,

};

static int kretprobe_handler__sysfs_dir_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x71ba);
	return 0;
}

static struct kretprobe kretprobe__sysfs_dir_open = {
	.kp = { .symbol_name = "sysfs_dir_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__sysfs_dir_open,
	.maxactive = 64,

};

static int kretprobe_handler__sysfs_dir_close(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7038);
	return 0;
}

static struct kretprobe kretprobe__sysfs_dir_close = {
	.kp = { .symbol_name = "sysfs_dir_close", },
	.handler = (kretprobe_handler_t)kretprobe_handler__sysfs_dir_close,
	.maxactive = 64,

};

static int kretprobe_handler__init_symlink(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x700c);
	return 0;
}

static struct kretprobe kretprobe__init_symlink = {
	.kp = { .symbol_name = "init_symlink", },
	.handler = (kretprobe_handler_t)kretprobe_handler__init_symlink,
	.maxactive = 64,

};

static int kretprobe_handler__init_file(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x6fe0);
	return 0;
}

static struct kretprobe kretprobe__init_file = {
	.kp = { .symbol_name = "init_file", },
	.handler = (kretprobe_handler_t)kretprobe_handler__init_file,
	.maxactive = 64,

};

static int kretprobe_handler__init_dir(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x6f9f);
	return 0;
}

static struct kretprobe kretprobe__init_dir = {
	.kp = { .symbol_name = "init_dir", },
	.handler = (kretprobe_handler_t)kretprobe_handler__init_dir,
	.maxactive = 64,

};

static int kretprobe_handler__open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7160);
	return 0;
}

static struct kretprobe kretprobe__open = {
	.kp = { .symbol_name = "open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__open,
	.maxactive = 64,

};

static int kretprobe_handler__release(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x6c0b);
	return 0;
}

static struct kretprobe kretprobe__release = {
	.kp = { .symbol_name = "release", },
	.handler = (kretprobe_handler_t)kretprobe_handler__release,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_discard_reservation(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x9835);
	return 0;
}

static struct kretprobe kretprobe__ext3_discard_reservation = {
	.kp = { .symbol_name = "ext3_discard_reservation", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_discard_reservation,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_init_block_alloc_info(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x9795);
	return 0;
}

static struct kretprobe kretprobe__ext3_init_block_alloc_info = {
	.kp = { .symbol_name = "ext3_init_block_alloc_info", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_init_block_alloc_info,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_new_block(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x94c4);
	return 0;
}

static struct kretprobe kretprobe__ext3_new_block = {
	.kp = { .symbol_name = "ext3_new_block", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_new_block,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_new_blocks(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x9114);
	return 0;
}

static struct kretprobe kretprobe__ext3_new_blocks = {
	.kp = { .symbol_name = "ext3_new_blocks", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_new_blocks,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_free_blocks(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x8a86);
	return 0;
}

static struct kretprobe kretprobe__ext3_free_blocks = {
	.kp = { .symbol_name = "ext3_free_blocks", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_free_blocks,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_release_dir(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7495);
	return 0;
}

static struct kretprobe kretprobe__ext3_release_dir = {
	.kp = { .symbol_name = "ext3_release_dir", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_release_dir,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_check_dir_entry(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7367);
	return 0;
}

static struct kretprobe kretprobe__ext3_check_dir_entry = {
	.kp = { .symbol_name = "ext3_check_dir_entry", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_check_dir_entry,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_release_file(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7355);
	return 0;
}

static struct kretprobe kretprobe__ext3_release_file = {
	.kp = { .symbol_name = "ext3_release_file", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_release_file,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_new_inode(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7d39);
	return 0;
}

static struct kretprobe kretprobe__ext3_new_inode = {
	.kp = { .symbol_name = "ext3_new_inode", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_new_inode,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_free_inode(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x77c1);
	return 0;
}

static struct kretprobe kretprobe__ext3_free_inode = {
	.kp = { .symbol_name = "ext3_free_inode", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_free_inode,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_read_inode(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xd199);
	return 0;
}

static struct kretprobe kretprobe__ext3_read_inode = {
	.kp = { .symbol_name = "ext3_read_inode", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_read_inode,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_dirty_inode(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xd075);
	return 0;
}

static struct kretprobe kretprobe__ext3_dirty_inode = {
	.kp = { .symbol_name = "ext3_dirty_inode", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_dirty_inode,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_delete_inode(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xc2e9);
	return 0;
}

static struct kretprobe kretprobe__ext3_delete_inode = {
	.kp = { .symbol_name = "ext3_delete_inode", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_delete_inode,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_write_inode(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xc147);
	return 0;
}

static struct kretprobe kretprobe__ext3_write_inode = {
	.kp = { .symbol_name = "ext3_write_inode", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_write_inode,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_change_inode_journal_flag(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xbd9f);
	return 0;
}

static struct kretprobe kretprobe__ext3_change_inode_journal_flag = {
	.kp = { .symbol_name = "ext3_change_inode_journal_flag", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_change_inode_journal_flag,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_bread(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xba7a);
	return 0;
}

static struct kretprobe kretprobe__ext3_bread = {
	.kp = { .symbol_name = "ext3_bread", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_bread,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_truncate(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xb2d5);
	return 0;
}

static struct kretprobe kretprobe__ext3_truncate = {
	.kp = { .symbol_name = "ext3_truncate", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_truncate,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_free_branches(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xaf7c);
	return 0;
}

static struct kretprobe kretprobe__ext3_free_branches = {
	.kp = { .symbol_name = "ext3_free_branches", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_free_branches,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_free_data(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xaea5);
	return 0;
}

static struct kretprobe kretprobe__ext3_free_data = {
	.kp = { .symbol_name = "ext3_free_data", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_free_data,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_clear_blocks(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xadb7);
	return 0;
}

static struct kretprobe kretprobe__ext3_clear_blocks = {
	.kp = { .symbol_name = "ext3_clear_blocks", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_clear_blocks,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_forget(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xad02);
	return 0;
}

static struct kretprobe kretprobe__ext3_forget = {
	.kp = { .symbol_name = "ext3_forget", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_forget,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_get_block(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xabac);
	return 0;
}

static struct kretprobe kretprobe__ext3_get_block = {
	.kp = { .symbol_name = "ext3_get_block", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_get_block,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_getblk(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xa924);
	return 0;
}

static struct kretprobe kretprobe__ext3_getblk = {
	.kp = { .symbol_name = "ext3_getblk", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_getblk,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_get_blocks_handle(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xa2ce);
	return 0;
}

static struct kretprobe kretprobe__ext3_get_blocks_handle = {
	.kp = { .symbol_name = "ext3_get_blocks_handle", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_get_blocks_handle,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_writepage_trans_blocks(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x9d14);
	return 0;
}

static struct kretprobe kretprobe__ext3_writepage_trans_blocks = {
	.kp = { .symbol_name = "ext3_writepage_trans_blocks", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_writepage_trans_blocks,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_get_branch(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x9b7f);
	return 0;
}

static struct kretprobe kretprobe__ext3_get_branch = {
	.kp = { .symbol_name = "ext3_get_branch", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_get_branch,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_block_to_path(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x9ab7);
	return 0;
}

static struct kretprobe kretprobe__ext3_block_to_path = {
	.kp = { .symbol_name = "ext3_block_to_path", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_block_to_path,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_journal_test_restart(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x9a62);
	return 0;
}

static struct kretprobe kretprobe__ext3_journal_test_restart = {
	.kp = { .symbol_name = "ext3_journal_test_restart", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_journal_test_restart,
	.maxactive = 64,

};

static int kretprobe_handler__try_to_extend_transaction(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x9a0d);
	return 0;
}

static struct kretprobe kretprobe__try_to_extend_transaction = {
	.kp = { .symbol_name = "try_to_extend_transaction", },
	.handler = (kretprobe_handler_t)kretprobe_handler__try_to_extend_transaction,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_mark_inode_dirty(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x99af);
	return 0;
}

static struct kretprobe kretprobe__ext3_mark_inode_dirty = {
	.kp = { .symbol_name = "ext3_mark_inode_dirty", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_mark_inode_dirty,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_reserve_inode_write(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x9922);
	return 0;
}

static struct kretprobe kretprobe__ext3_reserve_inode_write = {
	.kp = { .symbol_name = "ext3_reserve_inode_write", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_reserve_inode_write,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_get_inode_loc(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x98d1);
	return 0;
}

static struct kretprobe kretprobe__ext3_get_inode_loc = {
	.kp = { .symbol_name = "ext3_get_inode_loc", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_get_inode_loc,
	.maxactive = 64,

};

static int kretprobe_handler____ext3_get_inode_loc(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x945e);
	return 0;
}

static struct kretprobe kretprobe____ext3_get_inode_loc = {
	.kp = { .symbol_name = "__ext3_get_inode_loc", },
	.handler = (kretprobe_handler_t)kretprobe_handler____ext3_get_inode_loc,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_mark_iloc_dirty(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x91f2);
	return 0;
}

static struct kretprobe kretprobe__ext3_mark_iloc_dirty = {
	.kp = { .symbol_name = "ext3_mark_iloc_dirty", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_mark_iloc_dirty,
	.maxactive = 64,

};

static int kretprobe_handler__start_transaction(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x8ff6);
	return 0;
}

static struct kretprobe kretprobe__start_transaction = {
	.kp = { .symbol_name = "start_transaction", },
	.handler = (kretprobe_handler_t)kretprobe_handler__start_transaction,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_set_inode_flags(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x8fa9);
	return 0;
}

static struct kretprobe kretprobe__ext3_set_inode_flags = {
	.kp = { .symbol_name = "ext3_set_inode_flags", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_set_inode_flags,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_set_aops(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x8f39);
	return 0;
}

static struct kretprobe kretprobe__ext3_set_aops = {
	.kp = { .symbol_name = "ext3_set_aops", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_set_aops,
	.maxactive = 64,

};

static int kretprobe_handler__blocks_for_truncate(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x8cc5);
	return 0;
}

static struct kretprobe kretprobe__blocks_for_truncate = {
	.kp = { .symbol_name = "blocks_for_truncate", },
	.handler = (kretprobe_handler_t)kretprobe_handler__blocks_for_truncate,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_inode_is_fast_symlink(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x8c7b);
	return 0;
}

static struct kretprobe kretprobe__ext3_inode_is_fast_symlink = {
	.kp = { .symbol_name = "ext3_inode_is_fast_symlink", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_inode_is_fast_symlink,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_ioctl(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7374);
	return 0;
}

static struct kretprobe kretprobe__ext3_ioctl = {
	.kp = { .symbol_name = "ext3_ioctl", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_ioctl,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_lookup(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xab7d);
	return 0;
}

static struct kretprobe kretprobe__ext3_lookup = {
	.kp = { .symbol_name = "ext3_lookup", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_lookup,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_rename(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xa8dc);
	return 0;
}

static struct kretprobe kretprobe__ext3_rename = {
	.kp = { .symbol_name = "ext3_rename", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_rename,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_unlink(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xa776);
	return 0;
}

static struct kretprobe kretprobe__ext3_unlink = {
	.kp = { .symbol_name = "ext3_unlink", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_unlink,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_rmdir(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xa64d);
	return 0;
}

static struct kretprobe kretprobe__ext3_rmdir = {
	.kp = { .symbol_name = "ext3_rmdir", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_rmdir,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_orphan_del(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xa46d);
	return 0;
}

static struct kretprobe kretprobe__ext3_orphan_del = {
	.kp = { .symbol_name = "ext3_orphan_del", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_orphan_del,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_mkdir(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xa245);
	return 0;
}

static struct kretprobe kretprobe__ext3_mkdir = {
	.kp = { .symbol_name = "ext3_mkdir", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_mkdir,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_link(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x9f5b);
	return 0;
}

static struct kretprobe kretprobe__ext3_link = {
	.kp = { .symbol_name = "ext3_link", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_link,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_symlink(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x9d6a);
	return 0;
}

static struct kretprobe kretprobe__ext3_symlink = {
	.kp = { .symbol_name = "ext3_symlink", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_symlink,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_mknod(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x9c30);
	return 0;
}

static struct kretprobe kretprobe__ext3_mknod = {
	.kp = { .symbol_name = "ext3_mknod", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_mknod,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_create(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x9b28);
	return 0;
}

static struct kretprobe kretprobe__ext3_create = {
	.kp = { .symbol_name = "ext3_create", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_create,
	.maxactive = 64,

};

static int kretprobe_handler__htree_dirblock_to_tree(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x9887);
	return 0;
}

static struct kretprobe kretprobe__htree_dirblock_to_tree = {
	.kp = { .symbol_name = "htree_dirblock_to_tree", },
	.handler = (kretprobe_handler_t)kretprobe_handler__htree_dirblock_to_tree,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_orphan_add(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x97d5);
	return 0;
}

static struct kretprobe kretprobe__ext3_orphan_add = {
	.kp = { .symbol_name = "ext3_orphan_add", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_orphan_add,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_add_nondir(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x9746);
	return 0;
}

static struct kretprobe kretprobe__ext3_add_nondir = {
	.kp = { .symbol_name = "ext3_add_nondir", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_add_nondir,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_add_entry(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x8c8b);
	return 0;
}

static struct kretprobe kretprobe__ext3_add_entry = {
	.kp = { .symbol_name = "ext3_add_entry", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_add_entry,
	.maxactive = 64,

};

static int kretprobe_handler__dx_probe(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x872f);
	return 0;
}

static struct kretprobe kretprobe__dx_probe = {
	.kp = { .symbol_name = "dx_probe", },
	.handler = (kretprobe_handler_t)kretprobe_handler__dx_probe,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_htree_next_block(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x85e3);
	return 0;
}

static struct kretprobe kretprobe__ext3_htree_next_block = {
	.kp = { .symbol_name = "ext3_htree_next_block", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_htree_next_block,
	.maxactive = 64,

};

static int kretprobe_handler__do_split(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x829d);
	return 0;
}

static struct kretprobe kretprobe__do_split = {
	.kp = { .symbol_name = "do_split", },
	.handler = (kretprobe_handler_t)kretprobe_handler__do_split,
	.maxactive = 64,

};

static int kretprobe_handler__add_dirent_to_buf(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7ec5);
	return 0;
}

static struct kretprobe kretprobe__add_dirent_to_buf = {
	.kp = { .symbol_name = "add_dirent_to_buf", },
	.handler = (kretprobe_handler_t)kretprobe_handler__add_dirent_to_buf,
	.maxactive = 64,

};

static int kretprobe_handler__empty_dir(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7d43);
	return 0;
}

static struct kretprobe kretprobe__empty_dir = {
	.kp = { .symbol_name = "empty_dir", },
	.handler = (kretprobe_handler_t)kretprobe_handler__empty_dir,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_delete_entry(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7bae);
	return 0;
}

static struct kretprobe kretprobe__ext3_delete_entry = {
	.kp = { .symbol_name = "ext3_delete_entry", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_delete_entry,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_append(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7b22);
	return 0;
}

static struct kretprobe kretprobe__ext3_append = {
	.kp = { .symbol_name = "ext3_append", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_append,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_update_dx_flag(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7af8);
	return 0;
}

static struct kretprobe kretprobe__ext3_update_dx_flag = {
	.kp = { .symbol_name = "ext3_update_dx_flag", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_update_dx_flag,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_clear_inode(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xb4f3);
	return 0;
}

static struct kretprobe kretprobe__ext3_clear_inode = {
	.kp = { .symbol_name = "ext3_clear_inode", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_clear_inode,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_destroy_inode(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xb4b7);
	return 0;
}

static struct kretprobe kretprobe__ext3_destroy_inode = {
	.kp = { .symbol_name = "ext3_destroy_inode", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_destroy_inode,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_xattr_delete_inode(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x999b);
	return 0;
}

static struct kretprobe kretprobe__ext3_xattr_delete_inode = {
	.kp = { .symbol_name = "ext3_xattr_delete_inode", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_xattr_delete_inode,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_xattr_get(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x971c);
	return 0;
}

static struct kretprobe kretprobe__ext3_xattr_get = {
	.kp = { .symbol_name = "ext3_xattr_get", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_xattr_get,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_xattr_list(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x9345);
	return 0;
}

static struct kretprobe kretprobe__ext3_xattr_list = {
	.kp = { .symbol_name = "ext3_xattr_list", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_xattr_list,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_xattr_set(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x90f8);
	return 0;
}

static struct kretprobe kretprobe__ext3_xattr_set = {
	.kp = { .symbol_name = "ext3_xattr_set", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_xattr_set,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_xattr_set_handle(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x8e14);
	return 0;
}

static struct kretprobe kretprobe__ext3_xattr_set_handle = {
	.kp = { .symbol_name = "ext3_xattr_set_handle", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_xattr_set_handle,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_xattr_block_set(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x874a);
	return 0;
}

static struct kretprobe kretprobe__ext3_xattr_block_set = {
	.kp = { .symbol_name = "ext3_xattr_block_set", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_xattr_block_set,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_xattr_ibody_set(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x8588);
	return 0;
}

static struct kretprobe kretprobe__ext3_xattr_ibody_set = {
	.kp = { .symbol_name = "ext3_xattr_ibody_set", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_xattr_ibody_set,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_xattr_release_block(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7ff8);
	return 0;
}

static struct kretprobe kretprobe__ext3_xattr_release_block = {
	.kp = { .symbol_name = "ext3_xattr_release_block", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_xattr_release_block,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_xattr_list_entries(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7e2e);
	return 0;
}

static struct kretprobe kretprobe__ext3_xattr_list_entries = {
	.kp = { .symbol_name = "ext3_xattr_list_entries", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_xattr_list_entries,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_xattr_user_get(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7f71);
	return 0;
}

static struct kretprobe kretprobe__ext3_xattr_user_get = {
	.kp = { .symbol_name = "ext3_xattr_user_get", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_xattr_user_get,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_xattr_user_list(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7e80);
	return 0;
}

static struct kretprobe kretprobe__ext3_xattr_user_list = {
	.kp = { .symbol_name = "ext3_xattr_user_list", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_xattr_user_list,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_xattr_user_set(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7d42);
	return 0;
}

static struct kretprobe kretprobe__ext3_xattr_user_set = {
	.kp = { .symbol_name = "ext3_xattr_user_set", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_xattr_user_set,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_xattr_trusted_list(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x709d);
	return 0;
}

static struct kretprobe kretprobe__ext3_xattr_trusted_list = {
	.kp = { .symbol_name = "ext3_xattr_trusted_list", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_xattr_trusted_list,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_xattr_trusted_get(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x6f6d);
	return 0;
}

static struct kretprobe kretprobe__ext3_xattr_trusted_get = {
	.kp = { .symbol_name = "ext3_xattr_trusted_get", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_xattr_trusted_get,
	.maxactive = 64,

};

static int kretprobe_handler__ext3_xattr_trusted_set(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x6ed0);
	return 0;
}

static struct kretprobe kretprobe__ext3_xattr_trusted_set = {
	.kp = { .symbol_name = "ext3_xattr_trusted_set", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext3_xattr_trusted_set,
	.maxactive = 64,

};

static int kretprobe_handler__journal_init_inode(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x95c5);
	return 0;
}

static struct kretprobe kretprobe__journal_init_inode = {
	.kp = { .symbol_name = "journal_init_inode", },
	.handler = (kretprobe_handler_t)kretprobe_handler__journal_init_inode,
	.maxactive = 64,

};

static int kretprobe_handler__journal_blocks_per_page(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7d2e);
	return 0;
}

static struct kretprobe kretprobe__journal_blocks_per_page = {
	.kp = { .symbol_name = "journal_blocks_per_page", },
	.handler = (kretprobe_handler_t)kretprobe_handler__journal_blocks_per_page,
	.maxactive = 64,

};

static int kretprobe_handler__ext2_new_block(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7495);
	return 0;
}

static struct kretprobe kretprobe__ext2_new_block = {
	.kp = { .symbol_name = "ext2_new_block", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext2_new_block,
	.maxactive = 64,

};

static int kretprobe_handler__ext2_free_blocks(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x71d6);
	return 0;
}

static struct kretprobe kretprobe__ext2_free_blocks = {
	.kp = { .symbol_name = "ext2_free_blocks", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext2_free_blocks,
	.maxactive = 64,

};

static int kretprobe_handler__ext2_add_link(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7cb0);
	return 0;
}

static struct kretprobe kretprobe__ext2_add_link = {
	.kp = { .symbol_name = "ext2_add_link", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext2_add_link,
	.maxactive = 64,

};

static int kretprobe_handler__ext2_set_link(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7b08);
	return 0;
}

static struct kretprobe kretprobe__ext2_set_link = {
	.kp = { .symbol_name = "ext2_set_link", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext2_set_link,
	.maxactive = 64,

};

static int kretprobe_handler__ext2_empty_dir(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7a0d);
	return 0;
}

static struct kretprobe kretprobe__ext2_empty_dir = {
	.kp = { .symbol_name = "ext2_empty_dir", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext2_empty_dir,
	.maxactive = 64,

};

static int kretprobe_handler__ext2_inode_by_name(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x77be);
	return 0;
}

static struct kretprobe kretprobe__ext2_inode_by_name = {
	.kp = { .symbol_name = "ext2_inode_by_name", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext2_inode_by_name,
	.maxactive = 64,

};

static int kretprobe_handler__ext2_dotdot(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x74f6);
	return 0;
}

static struct kretprobe kretprobe__ext2_dotdot = {
	.kp = { .symbol_name = "ext2_dotdot", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext2_dotdot,
	.maxactive = 64,

};

static int kretprobe_handler__ext2_make_empty(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x72c5);
	return 0;
}

static struct kretprobe kretprobe__ext2_make_empty = {
	.kp = { .symbol_name = "ext2_make_empty", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext2_make_empty,
	.maxactive = 64,

};

static int kretprobe_handler__ext2_find_entry(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x6fc0);
	return 0;
}

static struct kretprobe kretprobe__ext2_find_entry = {
	.kp = { .symbol_name = "ext2_find_entry", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext2_find_entry,
	.maxactive = 64,

};

static int kretprobe_handler__ext2_get_page(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x6cc6);
	return 0;
}

static struct kretprobe kretprobe__ext2_get_page = {
	.kp = { .symbol_name = "ext2_get_page", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext2_get_page,
	.maxactive = 64,

};

static int kretprobe_handler__ext2_last_byte(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x6bb0);
	return 0;
}

static struct kretprobe kretprobe__ext2_last_byte = {
	.kp = { .symbol_name = "ext2_last_byte", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext2_last_byte,
	.maxactive = 64,

};

static int kretprobe_handler__ext2_release_file(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x5ea6);
	return 0;
}

static struct kretprobe kretprobe__ext2_release_file = {
	.kp = { .symbol_name = "ext2_release_file", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext2_release_file,
	.maxactive = 64,

};

static int kretprobe_handler__ext2_new_inode(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x73ed);
	return 0;
}

static struct kretprobe kretprobe__ext2_new_inode = {
	.kp = { .symbol_name = "ext2_new_inode", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext2_new_inode,
	.maxactive = 64,

};

static int kretprobe_handler__ext2_free_inode(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x6e08);
	return 0;
}

static struct kretprobe kretprobe__ext2_free_inode = {
	.kp = { .symbol_name = "ext2_free_inode", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext2_free_inode,
	.maxactive = 64,

};

static int kretprobe_handler__ext2_read_inode(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x972f);
	return 0;
}

static struct kretprobe kretprobe__ext2_read_inode = {
	.kp = { .symbol_name = "ext2_read_inode", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext2_read_inode,
	.maxactive = 64,

};

static int kretprobe_handler__ext2_get_block(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x91e2);
	return 0;
}

static struct kretprobe kretprobe__ext2_get_block = {
	.kp = { .symbol_name = "ext2_get_block", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext2_get_block,
	.maxactive = 64,

};

static int kretprobe_handler__ext2_delete_inode(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x8ee0);
	return 0;
}

static struct kretprobe kretprobe__ext2_delete_inode = {
	.kp = { .symbol_name = "ext2_delete_inode", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext2_delete_inode,
	.maxactive = 64,

};

static int kretprobe_handler__ext2_put_inode(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x8eaa);
	return 0;
}

static struct kretprobe kretprobe__ext2_put_inode = {
	.kp = { .symbol_name = "ext2_put_inode", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext2_put_inode,
	.maxactive = 64,

};

static int kretprobe_handler__ext2_alloc_block(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x8e32);
	return 0;
}

static struct kretprobe kretprobe__ext2_alloc_block = {
	.kp = { .symbol_name = "ext2_alloc_block", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext2_alloc_block,
	.maxactive = 64,

};

static int kretprobe_handler__ext2_truncate(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x8b8a);
	return 0;
}

static struct kretprobe kretprobe__ext2_truncate = {
	.kp = { .symbol_name = "ext2_truncate", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext2_truncate,
	.maxactive = 64,

};

static int kretprobe_handler__ext2_free_branches(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x898f);
	return 0;
}

static struct kretprobe kretprobe__ext2_free_branches = {
	.kp = { .symbol_name = "ext2_free_branches", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext2_free_branches,
	.maxactive = 64,

};

static int kretprobe_handler__ext2_get_branch(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x8820);
	return 0;
}

static struct kretprobe kretprobe__ext2_get_branch = {
	.kp = { .symbol_name = "ext2_get_branch", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext2_get_branch,
	.maxactive = 64,

};

static int kretprobe_handler__ext2_discard_prealloc(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x87ac);
	return 0;
}

static struct kretprobe kretprobe__ext2_discard_prealloc = {
	.kp = { .symbol_name = "ext2_discard_prealloc", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext2_discard_prealloc,
	.maxactive = 64,

};

static int kretprobe_handler__ext2_block_to_path(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x86f0);
	return 0;
}

static struct kretprobe kretprobe__ext2_block_to_path = {
	.kp = { .symbol_name = "ext2_block_to_path", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext2_block_to_path,
	.maxactive = 64,

};

static int kretprobe_handler__ext2_write_inode(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x86b1);
	return 0;
}

static struct kretprobe kretprobe__ext2_write_inode = {
	.kp = { .symbol_name = "ext2_write_inode", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext2_write_inode,
	.maxactive = 64,

};

static int kretprobe_handler__ext2_update_inode(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x8463);
	return 0;
}

static struct kretprobe kretprobe__ext2_update_inode = {
	.kp = { .symbol_name = "ext2_update_inode", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext2_update_inode,
	.maxactive = 64,

};

static int kretprobe_handler__ext2_sync_inode(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x8332);
	return 0;
}

static struct kretprobe kretprobe__ext2_sync_inode = {
	.kp = { .symbol_name = "ext2_sync_inode", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext2_sync_inode,
	.maxactive = 64,

};

static int kretprobe_handler__ext2_set_inode_flags(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7ed3);
	return 0;
}

static struct kretprobe kretprobe__ext2_set_inode_flags = {
	.kp = { .symbol_name = "ext2_set_inode_flags", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext2_set_inode_flags,
	.maxactive = 64,

};

static int kretprobe_handler__ext2_ioctl(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x5f6e);
	return 0;
}

static struct kretprobe kretprobe__ext2_ioctl = {
	.kp = { .symbol_name = "ext2_ioctl", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext2_ioctl,
	.maxactive = 64,

};

static int kretprobe_handler__ext2_lookup(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7821);
	return 0;
}

static struct kretprobe kretprobe__ext2_lookup = {
	.kp = { .symbol_name = "ext2_lookup", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext2_lookup,
	.maxactive = 64,

};

static int kretprobe_handler__ext2_symlink(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7681);
	return 0;
}

static struct kretprobe kretprobe__ext2_symlink = {
	.kp = { .symbol_name = "ext2_symlink", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext2_symlink,
	.maxactive = 64,

};

static int kretprobe_handler__ext2_mknod(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7486);
	return 0;
}

static struct kretprobe kretprobe__ext2_mknod = {
	.kp = { .symbol_name = "ext2_mknod", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext2_mknod,
	.maxactive = 64,

};

static int kretprobe_handler__ext2_create(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7371);
	return 0;
}

static struct kretprobe kretprobe__ext2_create = {
	.kp = { .symbol_name = "ext2_create", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext2_create,
	.maxactive = 64,

};

static int kretprobe_handler__ext2_rename(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7074);
	return 0;
}

static struct kretprobe kretprobe__ext2_rename = {
	.kp = { .symbol_name = "ext2_rename", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext2_rename,
	.maxactive = 64,

};

static int kretprobe_handler__ext2_mkdir(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x6e92);
	return 0;
}

static struct kretprobe kretprobe__ext2_mkdir = {
	.kp = { .symbol_name = "ext2_mkdir", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext2_mkdir,
	.maxactive = 64,

};

static int kretprobe_handler__ext2_link(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x6d11);
	return 0;
}

static struct kretprobe kretprobe__ext2_link = {
	.kp = { .symbol_name = "ext2_link", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext2_link,
	.maxactive = 64,

};

static int kretprobe_handler__ext2_rmdir(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x6bbf);
	return 0;
}

static struct kretprobe kretprobe__ext2_rmdir = {
	.kp = { .symbol_name = "ext2_rmdir", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext2_rmdir,
	.maxactive = 64,

};

static int kretprobe_handler__ext2_unlink(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x6a16);
	return 0;
}

static struct kretprobe kretprobe__ext2_unlink = {
	.kp = { .symbol_name = "ext2_unlink", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext2_unlink,
	.maxactive = 64,

};

static int kretprobe_handler__ext2_destroy_inode(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x9c1f);
	return 0;
}

static struct kretprobe kretprobe__ext2_destroy_inode = {
	.kp = { .symbol_name = "ext2_destroy_inode", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext2_destroy_inode,
	.maxactive = 64,

};

static int kretprobe_handler__ext2_clear_inode(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x9a17);
	return 0;
}

static struct kretprobe kretprobe__ext2_clear_inode = {
	.kp = { .symbol_name = "ext2_clear_inode", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ext2_clear_inode,
	.maxactive = 64,

};

static int kretprobe_handler__ramfs_symlink(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7223);
	return 0;
}

static struct kretprobe kretprobe__ramfs_symlink = {
	.kp = { .symbol_name = "ramfs_symlink", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ramfs_symlink,
	.maxactive = 64,

};

static int kretprobe_handler__ramfs_mkdir(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7185);
	return 0;
}

static struct kretprobe kretprobe__ramfs_mkdir = {
	.kp = { .symbol_name = "ramfs_mkdir", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ramfs_mkdir,
	.maxactive = 64,

};

static int kretprobe_handler__ramfs_create(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x712e);
	return 0;
}

static struct kretprobe kretprobe__ramfs_create = {
	.kp = { .symbol_name = "ramfs_create", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ramfs_create,
	.maxactive = 64,

};

static int kretprobe_handler__ramfs_mknod(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7090);
	return 0;
}

static struct kretprobe kretprobe__ramfs_mknod = {
	.kp = { .symbol_name = "ramfs_mknod", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ramfs_mknod,
	.maxactive = 64,

};

static int kretprobe_handler__debugfs_mknod(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x72d7);
	return 0;
}

static struct kretprobe kretprobe__debugfs_mknod = {
	.kp = { .symbol_name = "debugfs_mknod", },
	.handler = (kretprobe_handler_t)kretprobe_handler__debugfs_mknod,
	.maxactive = 64,

};

static int kretprobe_handler__fops_u16_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x73ed);
	return 0;
}

static struct kretprobe kretprobe__fops_u16_open = {
	.kp = { .symbol_name = "fops_u16_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__fops_u16_open,
	.maxactive = 64,

};

static int kretprobe_handler__fops_u8_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x73b2);
	return 0;
}

static struct kretprobe kretprobe__fops_u8_open = {
	.kp = { .symbol_name = "fops_u8_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__fops_u8_open,
	.maxactive = 64,

};

static int kretprobe_handler__fops_u32_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7377);
	return 0;
}

static struct kretprobe kretprobe__fops_u32_open = {
	.kp = { .symbol_name = "fops_u32_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__fops_u32_open,
	.maxactive = 64,

};

static int kretprobe_handler__default_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x6ebe);
	return 0;
}

static struct kretprobe kretprobe__default_open = {
	.kp = { .symbol_name = "default_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__default_open,
	.maxactive = 64,

};

static int kretprobe_handler__sysvipc_proc_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x73ef);
	return 0;
}

static struct kretprobe kretprobe__sysvipc_proc_open = {
	.kp = { .symbol_name = "sysvipc_proc_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__sysvipc_proc_open,
	.maxactive = 64,

};

static int kretprobe_handler__shm_release(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x719a);
	return 0;
}

static struct kretprobe kretprobe__shm_release = {
	.kp = { .symbol_name = "shm_release", },
	.handler = (kretprobe_handler_t)kretprobe_handler__shm_release,
	.maxactive = 64,

};

static int kretprobe_handler__mqueue_delete_inode(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xc166);
	return 0;
}

static struct kretprobe kretprobe__mqueue_delete_inode = {
	.kp = { .symbol_name = "mqueue_delete_inode", },
	.handler = (kretprobe_handler_t)kretprobe_handler__mqueue_delete_inode,
	.maxactive = 64,

};

static int kretprobe_handler__mqueue_destroy_inode(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xc12d);
	return 0;
}

static struct kretprobe kretprobe__mqueue_destroy_inode = {
	.kp = { .symbol_name = "mqueue_destroy_inode", },
	.handler = (kretprobe_handler_t)kretprobe_handler__mqueue_destroy_inode,
	.maxactive = 64,

};

static int kretprobe_handler__mqueue_create(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xbaf0);
	return 0;
}

static struct kretprobe kretprobe__mqueue_create = {
	.kp = { .symbol_name = "mqueue_create", },
	.handler = (kretprobe_handler_t)kretprobe_handler__mqueue_create,
	.maxactive = 64,

};

static int kretprobe_handler__mqueue_unlink(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xb767);
	return 0;
}

static struct kretprobe kretprobe__mqueue_unlink = {
	.kp = { .symbol_name = "mqueue_unlink", },
	.handler = (kretprobe_handler_t)kretprobe_handler__mqueue_unlink,
	.maxactive = 64,

};

static int kretprobe_handler__crypto_info_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x7e7c);
	return 0;
}

static struct kretprobe kretprobe__crypto_info_open = {
	.kp = { .symbol_name = "crypto_info_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__crypto_info_open,
	.maxactive = 64,

};

static int kretprobe_handler__blkdev_ioctl(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x958d);
	return 0;
}

static struct kretprobe kretprobe__blkdev_ioctl = {
	.kp = { .symbol_name = "blkdev_ioctl", },
	.handler = (kretprobe_handler_t)kretprobe_handler__blkdev_ioctl,
	.maxactive = 64,

};

static int kretprobe_handler__blkdev_driver_ioctl(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x9218);
	return 0;
}

static struct kretprobe kretprobe__blkdev_driver_ioctl = {
	.kp = { .symbol_name = "blkdev_driver_ioctl", },
	.handler = (kretprobe_handler_t)kretprobe_handler__blkdev_driver_ioctl,
	.maxactive = 64,

};

static int kretprobe_handler__blk_dropped_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x942a);
	return 0;
}

static struct kretprobe kretprobe__blk_dropped_open = {
	.kp = { .symbol_name = "blk_dropped_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__blk_dropped_open,
	.maxactive = 64,

};

static int kretprobe_handler__proc_bus_pci_ioctl(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x8ff2);
	return 0;
}

static struct kretprobe kretprobe__proc_bus_pci_ioctl = {
	.kp = { .symbol_name = "proc_bus_pci_ioctl", },
	.handler = (kretprobe_handler_t)kretprobe_handler__proc_bus_pci_ioctl,
	.maxactive = 64,

};

static int kretprobe_handler__proc_bus_pci_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x88c0);
	return 0;
}

static struct kretprobe kretprobe__proc_bus_pci_open = {
	.kp = { .symbol_name = "proc_bus_pci_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__proc_bus_pci_open,
	.maxactive = 64,

};

static int kretprobe_handler__proc_bus_pci_release(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x8848);
	return 0;
}

static struct kretprobe kretprobe__proc_bus_pci_release = {
	.kp = { .symbol_name = "proc_bus_pci_release", },
	.handler = (kretprobe_handler_t)kretprobe_handler__proc_bus_pci_release,
	.maxactive = 64,

};

static int kretprobe_handler__proc_bus_pci_dev_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x86a9);
	return 0;
}

static struct kretprobe kretprobe__proc_bus_pci_dev_open = {
	.kp = { .symbol_name = "proc_bus_pci_dev_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__proc_bus_pci_dev_open,
	.maxactive = 64,

};

static int kretprobe_handler__open_port(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x9360);
	return 0;
}

static struct kretprobe kretprobe__open_port = {
	.kp = { .symbol_name = "open_port", },
	.handler = (kretprobe_handler_t)kretprobe_handler__open_port,
	.maxactive = 64,

};

static int kretprobe_handler__memory_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x8c2a);
	return 0;
}

static struct kretprobe kretprobe__memory_open = {
	.kp = { .symbol_name = "memory_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__memory_open,
	.maxactive = 64,

};

static int kretprobe_handler__random_ioctl(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x90f7);
	return 0;
}

static struct kretprobe kretprobe__random_ioctl = {
	.kp = { .symbol_name = "random_ioctl", },
	.handler = (kretprobe_handler_t)kretprobe_handler__random_ioctl,
	.maxactive = 64,

};

static int kretprobe_handler__ptmx_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xcf62);
	return 0;
}

static struct kretprobe kretprobe__ptmx_open = {
	.kp = { .symbol_name = "ptmx_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ptmx_open,
	.maxactive = 64,

};

static int kretprobe_handler__tty_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xcc85);
	return 0;
}

static struct kretprobe kretprobe__tty_open = {
	.kp = { .symbol_name = "tty_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__tty_open,
	.maxactive = 64,

};

static int kretprobe_handler__tty_ioctl(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xc2c3);
	return 0;
}

static struct kretprobe kretprobe__tty_ioctl = {
	.kp = { .symbol_name = "tty_ioctl", },
	.handler = (kretprobe_handler_t)kretprobe_handler__tty_ioctl,
	.maxactive = 64,

};

static int kretprobe_handler__tty_release(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xac3d);
	return 0;
}

static struct kretprobe kretprobe__tty_release = {
	.kp = { .symbol_name = "tty_release", },
	.handler = (kretprobe_handler_t)kretprobe_handler__tty_release,
	.maxactive = 64,

};

static int kretprobe_handler__tty_paranoia_check(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x977e);
	return 0;
}

static struct kretprobe kretprobe__tty_paranoia_check = {
	.kp = { .symbol_name = "tty_paranoia_check", },
	.handler = (kretprobe_handler_t)kretprobe_handler__tty_paranoia_check,
	.maxactive = 64,

};

static int kretprobe_handler__hung_up_tty_ioctl(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x956a);
	return 0;
}

static struct kretprobe kretprobe__hung_up_tty_ioctl = {
	.kp = { .symbol_name = "hung_up_tty_ioctl", },
	.handler = (kretprobe_handler_t)kretprobe_handler__hung_up_tty_ioctl,
	.maxactive = 64,

};

static int kretprobe_handler__misc_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x893c);
	return 0;
}

static struct kretprobe kretprobe__misc_open = {
	.kp = { .symbol_name = "misc_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__misc_open,
	.maxactive = 64,

};

static int kretprobe_handler__misc_seq_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x8516);
	return 0;
}

static struct kretprobe kretprobe__misc_seq_open = {
	.kp = { .symbol_name = "misc_seq_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__misc_seq_open,
	.maxactive = 64,

};

static int kretprobe_handler__vcs_size(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x9291);
	return 0;
}

static struct kretprobe kretprobe__vcs_size = {
	.kp = { .symbol_name = "vcs_size", },
	.handler = (kretprobe_handler_t)kretprobe_handler__vcs_size,
	.maxactive = 64,

};

static int kretprobe_handler__vcs_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x9243);
	return 0;
}

static struct kretprobe kretprobe__vcs_open = {
	.kp = { .symbol_name = "vcs_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__vcs_open,
	.maxactive = 64,

};

static int kretprobe_handler__ide_drivers_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xbc57);
	return 0;
}

static struct kretprobe kretprobe__ide_drivers_open = {
	.kp = { .symbol_name = "ide_drivers_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__ide_drivers_open,
	.maxactive = 64,

};

static int kretprobe_handler__idedisk_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xcff5);
	return 0;
}

static struct kretprobe kretprobe__idedisk_open = {
	.kp = { .symbol_name = "idedisk_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__idedisk_open,
	.maxactive = 64,

};

static int kretprobe_handler__idedisk_ioctl(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xc74f);
	return 0;
}

static struct kretprobe kretprobe__idedisk_ioctl = {
	.kp = { .symbol_name = "idedisk_ioctl", },
	.handler = (kretprobe_handler_t)kretprobe_handler__idedisk_ioctl,
	.maxactive = 64,

};

static int kretprobe_handler__idedisk_release(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xc5a7);
	return 0;
}

static struct kretprobe kretprobe__idedisk_release = {
	.kp = { .symbol_name = "idedisk_release", },
	.handler = (kretprobe_handler_t)kretprobe_handler__idedisk_release,
	.maxactive = 64,

};

static int kretprobe_handler__input_open_file(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xa479);
	return 0;
}

static struct kretprobe kretprobe__input_open_file = {
	.kp = { .symbol_name = "input_open_file", },
	.handler = (kretprobe_handler_t)kretprobe_handler__input_open_file,
	.maxactive = 64,

};

static int kretprobe_handler__input_proc_devices_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x8ce0);
	return 0;
}

static struct kretprobe kretprobe__input_proc_devices_open = {
	.kp = { .symbol_name = "input_proc_devices_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__input_proc_devices_open,
	.maxactive = 64,

};

static int kretprobe_handler__input_proc_handlers_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x8ca2);
	return 0;
}

static struct kretprobe kretprobe__input_proc_handlers_open = {
	.kp = { .symbol_name = "input_proc_handlers_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__input_proc_handlers_open,
	.maxactive = 64,

};

static int kretprobe_handler__sock_close(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xd120);
	return 0;
}

static struct kretprobe kretprobe__sock_close = {
	.kp = { .symbol_name = "sock_close", },
	.handler = (kretprobe_handler_t)kretprobe_handler__sock_close,
	.maxactive = 64,

};

static int kretprobe_handler__sock_destroy_inode(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xb937);
	return 0;
}

static struct kretprobe kretprobe__sock_destroy_inode = {
	.kp = { .symbol_name = "sock_destroy_inode", },
	.handler = (kretprobe_handler_t)kretprobe_handler__sock_destroy_inode,
	.maxactive = 64,

};

static int kretprobe_handler__sock_no_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xb5c8);
	return 0;
}

static struct kretprobe kretprobe__sock_no_open = {
	.kp = { .symbol_name = "sock_no_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__sock_no_open,
	.maxactive = 64,

};

static int kretprobe_handler__proto_seq_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xd14b);
	return 0;
}

static struct kretprobe kretprobe__proto_seq_open = {
	.kp = { .symbol_name = "proto_seq_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__proto_seq_open,
	.maxactive = 64,

};

static int kretprobe_handler__dev_seq_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xd000);
	return 0;
}

static struct kretprobe kretprobe__dev_seq_open = {
	.kp = { .symbol_name = "dev_seq_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__dev_seq_open,
	.maxactive = 64,

};

static int kretprobe_handler__softnet_seq_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xcfc2);
	return 0;
}

static struct kretprobe kretprobe__softnet_seq_open = {
	.kp = { .symbol_name = "softnet_seq_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__softnet_seq_open,
	.maxactive = 64,

};

static int kretprobe_handler__dev_mc_seq_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xb2eb);
	return 0;
}

static struct kretprobe kretprobe__dev_mc_seq_open = {
	.kp = { .symbol_name = "dev_mc_seq_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__dev_mc_seq_open,
	.maxactive = 64,

};

static int kretprobe_handler__neigh_stat_seq_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xd0fc);
	return 0;
}

static struct kretprobe kretprobe__neigh_stat_seq_open = {
	.kp = { .symbol_name = "neigh_stat_seq_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__neigh_stat_seq_open,
	.maxactive = 64,

};

static int kretprobe_handler__netlink_seq_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xc9e0);
	return 0;
}

static struct kretprobe kretprobe__netlink_seq_open = {
	.kp = { .symbol_name = "netlink_seq_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__netlink_seq_open,
	.maxactive = 64,

};

static int kretprobe_handler__rt_cache_seq_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x11fe3);
	return 0;
}

static struct kretprobe kretprobe__rt_cache_seq_open = {
	.kp = { .symbol_name = "rt_cache_seq_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__rt_cache_seq_open,
	.maxactive = 64,

};

static int kretprobe_handler__rt_cpu_seq_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xe9f9);
	return 0;
}

static struct kretprobe kretprobe__rt_cpu_seq_open = {
	.kp = { .symbol_name = "rt_cpu_seq_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__rt_cpu_seq_open,
	.maxactive = 64,

};

static int kretprobe_handler__tcp_seq_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0x10915);
	return 0;
}

static struct kretprobe kretprobe__tcp_seq_open = {
	.kp = { .symbol_name = "tcp_seq_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__tcp_seq_open,
	.maxactive = 64,

};

static int kretprobe_handler__raw_seq_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xe4ce);
	return 0;
}

static struct kretprobe kretprobe__raw_seq_open = {
	.kp = { .symbol_name = "raw_seq_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__raw_seq_open,
	.maxactive = 64,

};

static int kretprobe_handler__udp_seq_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xeb8c);
	return 0;
}

static struct kretprobe kretprobe__udp_seq_open = {
	.kp = { .symbol_name = "udp_seq_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__udp_seq_open,
	.maxactive = 64,

};

static int kretprobe_handler__arp_seq_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xc972);
	return 0;
}

static struct kretprobe kretprobe__arp_seq_open = {
	.kp = { .symbol_name = "arp_seq_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__arp_seq_open,
	.maxactive = 64,

};

static int kretprobe_handler__igmp_mc_seq_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xffb8);
	return 0;
}

static struct kretprobe kretprobe__igmp_mc_seq_open = {
	.kp = { .symbol_name = "igmp_mc_seq_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__igmp_mc_seq_open,
	.maxactive = 64,

};

static int kretprobe_handler__igmp_mcf_seq_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xd6f3);
	return 0;
}

static struct kretprobe kretprobe__igmp_mcf_seq_open = {
	.kp = { .symbol_name = "igmp_mcf_seq_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__igmp_mcf_seq_open,
	.maxactive = 64,

};

static int kretprobe_handler__fib_seq_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xc86b);
	return 0;
}

static struct kretprobe kretprobe__fib_seq_open = {
	.kp = { .symbol_name = "fib_seq_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__fib_seq_open,
	.maxactive = 64,

};

static int kretprobe_handler__sockstat_seq_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xb7b9);
	return 0;
}

static struct kretprobe kretprobe__sockstat_seq_open = {
	.kp = { .symbol_name = "sockstat_seq_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__sockstat_seq_open,
	.maxactive = 64,

};

static int kretprobe_handler__snmp_seq_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xb77b);
	return 0;
}

static struct kretprobe kretprobe__snmp_seq_open = {
	.kp = { .symbol_name = "snmp_seq_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__snmp_seq_open,
	.maxactive = 64,

};

static int kretprobe_handler__netstat_seq_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xb73d);
	return 0;
}

static struct kretprobe kretprobe__netstat_seq_open = {
	.kp = { .symbol_name = "netstat_seq_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__netstat_seq_open,
	.maxactive = 64,

};

static int kretprobe_handler__packet_seq_open(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	ctracer__method_exit(0xbc11);
	return 0;
}

static struct kretprobe kretprobe__packet_seq_open = {
	.kp = { .symbol_name = "packet_seq_open", },
	.handler = (kretprobe_handler_t)kretprobe_handler__packet_seq_open,
	.maxactive = 64,

};

static struct jprobe *jprobes[] = {
	&jprobe__ioports_open,
	&jprobe__iomem_open,
	&jprobe__proc_opensys,
	&jprobe__futex_close,
	&jprobe__proc_dma_open,
	&jprobe__kallsyms_open,
	&jprobe__kallsyms_release,
	&jprobe__relay_file_open,
	&jprobe__relay_file_release,
	&jprobe__sync_page_range,
	&jprobe__sync_page_range_nolock,
	&jprobe__vmtruncate,
	&jprobe__vmtruncate_range,
	&jprobe__shmem_destroy_inode,
	&jprobe__shmem_delete_inode,
	&jprobe__shmem_getpage,
	&jprobe__shmem_truncate,
	&jprobe__shmem_truncate_range,
	&jprobe__shmem_recalc_inode,
	&jprobe__shmem_free_blocks,
	&jprobe__nonseekable_open,
	&jprobe__generic_file_open,
	&jprobe__chrdev_open,
	&jprobe__cd_forget,
	&jprobe__inode_add_bytes,
	&jprobe__inode_sub_bytes,
	&jprobe__inode_get_bytes,
	&jprobe__inode_set_bytes,
	&jprobe__generic_fillattr,
	&jprobe__alloc_pipe_info,
	&jprobe__pipe_read_release,
	&jprobe__pipe_write_release,
	&jprobe__pipe_rdwr_release,
	&jprobe__pipe_release,
	&jprobe__free_pipe_info,
	&jprobe__pipe_ioctl,
	&jprobe__pipe_read_open,
	&jprobe__pipe_write_open,
	&jprobe__pipe_rdwr_open,
	&jprobe__vfs_rmdir,
	&jprobe__vfs_unlink,
	&jprobe__vfs_rename,
	&jprobe__may_delete,
	&jprobe__vfs_create,
	&jprobe__vfs_mknod,
	&jprobe__vfs_mkdir,
	&jprobe__vfs_symlink,
	&jprobe__vfs_link,
	&jprobe__permission,
	&jprobe__generic_permission,
	&jprobe__get_write_access,
	&jprobe__page_symlink,
	&jprobe____page_symlink,
	&jprobe__fifo_open,
	&jprobe__wait_for_partner,
	&jprobe__wake_up_partner,
	&jprobe__locks_mandatory_area,
	&jprobe____break_lease,
	&jprobe__locks_mandatory_locked,
	&jprobe__lease_get_mtime,
	&jprobe____posix_lock_file_conf,
	&jprobe__time_out_leases,
	&jprobe__lock_may_write,
	&jprobe__lock_may_read,
	&jprobe__d_splice_alias,
	&jprobe__d_materialise_unique,
	&jprobe__d_prune_aliases,
	&jprobe__d_instantiate_unique,
	&jprobe__d_alloc_anon,
	&jprobe__d_alloc_root,
	&jprobe__d_instantiate,
	&jprobe____d_instantiate_unique,
	&jprobe__d_find_alias,
	&jprobe____d_find_alias,
	&jprobe__inode_init_once,
	&jprobe__generic_drop_inode,
	&jprobe__generic_delete_inode,
	&jprobe__clear_inode,
	&jprobe__destroy_inode,
	&jprobe____wait_on_freeing_inode,
	&jprobe__iput,
	&jprobe__unlock_new_inode,
	&jprobe__wake_up_inode,
	&jprobe__igrab,
	&jprobe____iget,
	&jprobe__inode_double_unlock,
	&jprobe____insert_inode_hash,
	&jprobe__remove_inode_hash,
	&jprobe__inode_double_lock,
	&jprobe__init_special_inode,
	&jprobe__inode_needs_sync,
	&jprobe__bmap,
	&jprobe__inode_setattr,
	&jprobe__inode_change_ok,
	&jprobe__make_bad_inode,
	&jprobe__is_bad_inode,
	&jprobe__bad_inode_permission,
	&jprobe__bad_inode_rename,
	&jprobe__bad_inode_mknod,
	&jprobe__bad_inode_rmdir,
	&jprobe__bad_inode_mkdir,
	&jprobe__bad_inode_symlink,
	&jprobe__bad_inode_unlink,
	&jprobe__bad_inode_link,
	&jprobe__bad_inode_lookup,
	&jprobe__bad_inode_create,
	&jprobe__bad_file_release,
	&jprobe__bad_file_open,
	&jprobe__bad_file_ioctl,
	&jprobe__single_release,
	&jprobe__seq_release_private,
	&jprobe__seq_release,
	&jprobe__xattr_permission,
	&jprobe__simple_lookup,
	&jprobe__simple_rename,
	&jprobe__simple_rmdir,
	&jprobe__simple_link,
	&jprobe__dcache_dir_open,
	&jprobe__dcache_dir_close,
	&jprobe__simple_unlink,
	&jprobe__simple_transaction_release,
	&jprobe__simple_attr_open,
	&jprobe__simple_attr_close,
	&jprobe____mark_inode_dirty,
	&jprobe__generic_osync_inode,
	&jprobe__write_inode_now,
	&jprobe__sync_inode,
	&jprobe____writeback_single_inode,
	&jprobe__fsstack_copy_attr_all,
	&jprobe__fsstack_copy_inode_size,
	&jprobe__invalidate_inode_buffers,
	&jprobe__remove_inode_buffers,
	&jprobe__mark_buffer_dirty_inode,
	&jprobe____block_write_full_page,
	&jprobe____block_prepare_write,
	&jprobe____block_commit_write,
	&jprobe__generic_cont_expand,
	&jprobe__generic_cont_expand_simple,
	&jprobe____generic_cont_expand,
	&jprobe__inode_has_buffers,
	&jprobe__bdev_clear_inode,
	&jprobe__blkdev_close,
	&jprobe__blkdev_get_block,
	&jprobe__bdev_test,
	&jprobe__bdev_destroy_inode,
	&jprobe__blkdev_open,
	&jprobe__bd_acquire,
	&jprobe__bd_forget,
	&jprobe__bdev_set,
	&jprobe____blockdev_direct_IO,
	&jprobe__inotify_d_instantiate,
	&jprobe__inotify_inode_is_dead,
	&jprobe__inotify_inode_queue_event,
	&jprobe__inotify_add_watch,
	&jprobe__set_dentry_child_flags,
	&jprobe__inotify_find_watch,
	&jprobe__inotify_find_update_watch,
	&jprobe__inode_find_handle,
	&jprobe__inotify_dev_queue_event,
	&jprobe__inotify_release,
	&jprobe__ep_eventpoll_close,
	&jprobe____inode_dir_notify,
	&jprobe__redo_inode_mask,
	&jprobe__proc_exe_link,
	&jprobe__maps_open,
	&jprobe__smaps_open,
	&jprobe__do_maps_open,
	&jprobe__proc_delete_inode,
	&jprobe__proc_destroy_inode,
	&jprobe__proc_read_inode,
	&jprobe__proc_root_lookup,
	&jprobe__proc_task_lookup,
	&jprobe__proc_pid_lookup,
	&jprobe__proc_lookupfd,
	&jprobe__proc_fd_link,
	&jprobe__mountstats_open,
	&jprobe__mounts_open,
	&jprobe__proc_root_link,
	&jprobe__proc_cwd_link,
	&jprobe__mem_open,
	&jprobe__proc_fd_access_allowed,
	&jprobe__proc_tgid_base_lookup,
	&jprobe__proc_tid_base_lookup,
	&jprobe__proc_pident_lookup,
	&jprobe__proc_pident_instantiate,
	&jprobe__proc_pid_instantiate,
	&jprobe__proc_task_instantiate,
	&jprobe__proc_fd_instantiate,
	&jprobe__mounts_release,
	&jprobe__proc_base_instantiate,
	&jprobe__proc_lookup,
	&jprobe__tty_drivers_open,
	&jprobe__stat_open,
	&jprobe__slabstats_open,
	&jprobe__slabstats_release,
	&jprobe__fragmentation_open,
	&jprobe__zoneinfo_open,
	&jprobe__cpuinfo_open,
	&jprobe__devinfo_open,
	&jprobe__vmstat_open,
	&jprobe__partitions_open,
	&jprobe__diskstats_open,
	&jprobe__modules_open,
	&jprobe__slabinfo_open,
	&jprobe__interrupts_open,
	&jprobe__open_kcore,
	&jprobe__kmsg_open,
	&jprobe__kmsg_release,
	&jprobe__sysfs_release,
	&jprobe__sysfs_open_file,
	&jprobe__sysfs_d_iput,
	&jprobe__sysfs_lookup,
	&jprobe__sysfs_dir_open,
	&jprobe__sysfs_dir_close,
	&jprobe__init_symlink,
	&jprobe__init_file,
	&jprobe__init_dir,
	&jprobe__open,
	&jprobe__release,
	&jprobe__ext3_discard_reservation,
	&jprobe__ext3_init_block_alloc_info,
	&jprobe__ext3_new_block,
	&jprobe__ext3_new_blocks,
	&jprobe__ext3_free_blocks,
	&jprobe__ext3_release_dir,
	&jprobe__ext3_check_dir_entry,
	&jprobe__ext3_release_file,
	&jprobe__ext3_new_inode,
	&jprobe__ext3_free_inode,
	&jprobe__ext3_read_inode,
	&jprobe__ext3_dirty_inode,
	&jprobe__ext3_delete_inode,
	&jprobe__ext3_write_inode,
	&jprobe__ext3_change_inode_journal_flag,
	&jprobe__ext3_bread,
	&jprobe__ext3_truncate,
	&jprobe__ext3_free_branches,
	&jprobe__ext3_free_data,
	&jprobe__ext3_clear_blocks,
	&jprobe__ext3_forget,
	&jprobe__ext3_get_block,
	&jprobe__ext3_getblk,
	&jprobe__ext3_get_blocks_handle,
	&jprobe__ext3_writepage_trans_blocks,
	&jprobe__ext3_get_branch,
	&jprobe__ext3_block_to_path,
	&jprobe__ext3_journal_test_restart,
	&jprobe__try_to_extend_transaction,
	&jprobe__ext3_mark_inode_dirty,
	&jprobe__ext3_reserve_inode_write,
	&jprobe__ext3_get_inode_loc,
	&jprobe____ext3_get_inode_loc,
	&jprobe__ext3_mark_iloc_dirty,
	&jprobe__start_transaction,
	&jprobe__ext3_set_inode_flags,
	&jprobe__ext3_set_aops,
	&jprobe__blocks_for_truncate,
	&jprobe__ext3_inode_is_fast_symlink,
	&jprobe__ext3_ioctl,
	&jprobe__ext3_lookup,
	&jprobe__ext3_rename,
	&jprobe__ext3_unlink,
	&jprobe__ext3_rmdir,
	&jprobe__ext3_orphan_del,
	&jprobe__ext3_mkdir,
	&jprobe__ext3_link,
	&jprobe__ext3_symlink,
	&jprobe__ext3_mknod,
	&jprobe__ext3_create,
	&jprobe__htree_dirblock_to_tree,
	&jprobe__ext3_orphan_add,
	&jprobe__ext3_add_nondir,
	&jprobe__ext3_add_entry,
	&jprobe__dx_probe,
	&jprobe__ext3_htree_next_block,
	&jprobe__do_split,
	&jprobe__add_dirent_to_buf,
	&jprobe__empty_dir,
	&jprobe__ext3_delete_entry,
	&jprobe__ext3_append,
	&jprobe__ext3_update_dx_flag,
	&jprobe__ext3_clear_inode,
	&jprobe__ext3_destroy_inode,
	&jprobe__ext3_xattr_delete_inode,
	&jprobe__ext3_xattr_get,
	&jprobe__ext3_xattr_list,
	&jprobe__ext3_xattr_set,
	&jprobe__ext3_xattr_set_handle,
	&jprobe__ext3_xattr_block_set,
	&jprobe__ext3_xattr_ibody_set,
	&jprobe__ext3_xattr_release_block,
	&jprobe__ext3_xattr_list_entries,
	&jprobe__ext3_xattr_user_get,
	&jprobe__ext3_xattr_user_list,
	&jprobe__ext3_xattr_user_set,
	&jprobe__ext3_xattr_trusted_list,
	&jprobe__ext3_xattr_trusted_get,
	&jprobe__ext3_xattr_trusted_set,
	&jprobe__journal_init_inode,
	&jprobe__journal_blocks_per_page,
	&jprobe__ext2_new_block,
	&jprobe__ext2_free_blocks,
	&jprobe__ext2_add_link,
	&jprobe__ext2_set_link,
	&jprobe__ext2_empty_dir,
	&jprobe__ext2_inode_by_name,
	&jprobe__ext2_dotdot,
	&jprobe__ext2_make_empty,
	&jprobe__ext2_find_entry,
	&jprobe__ext2_get_page,
	&jprobe__ext2_last_byte,
	&jprobe__ext2_release_file,
	&jprobe__ext2_new_inode,
	&jprobe__ext2_free_inode,
	&jprobe__ext2_read_inode,
	&jprobe__ext2_get_block,
	&jprobe__ext2_delete_inode,
	&jprobe__ext2_put_inode,
	&jprobe__ext2_alloc_block,
	&jprobe__ext2_truncate,
	&jprobe__ext2_free_branches,
	&jprobe__ext2_get_branch,
	&jprobe__ext2_discard_prealloc,
	&jprobe__ext2_block_to_path,
	&jprobe__ext2_write_inode,
	&jprobe__ext2_update_inode,
	&jprobe__ext2_sync_inode,
	&jprobe__ext2_set_inode_flags,
	&jprobe__ext2_ioctl,
	&jprobe__ext2_lookup,
	&jprobe__ext2_symlink,
	&jprobe__ext2_mknod,
	&jprobe__ext2_create,
	&jprobe__ext2_rename,
	&jprobe__ext2_mkdir,
	&jprobe__ext2_link,
	&jprobe__ext2_rmdir,
	&jprobe__ext2_unlink,
	&jprobe__ext2_destroy_inode,
	&jprobe__ext2_clear_inode,
	&jprobe__ramfs_symlink,
	&jprobe__ramfs_mkdir,
	&jprobe__ramfs_create,
	&jprobe__ramfs_mknod,
	&jprobe__debugfs_mknod,
	&jprobe__fops_u16_open,
	&jprobe__fops_u8_open,
	&jprobe__fops_u32_open,
	&jprobe__default_open,
	&jprobe__sysvipc_proc_open,
	&jprobe__shm_release,
	&jprobe__mqueue_delete_inode,
	&jprobe__mqueue_destroy_inode,
	&jprobe__mqueue_create,
	&jprobe__mqueue_unlink,
	&jprobe__crypto_info_open,
	&jprobe__blkdev_ioctl,
	&jprobe__blkdev_driver_ioctl,
	&jprobe__blk_dropped_open,
	&jprobe__proc_bus_pci_ioctl,
	&jprobe__proc_bus_pci_open,
	&jprobe__proc_bus_pci_release,
	&jprobe__proc_bus_pci_dev_open,
	&jprobe__open_port,
	&jprobe__memory_open,
	&jprobe__random_ioctl,
	&jprobe__ptmx_open,
	&jprobe__tty_open,
	&jprobe__tty_ioctl,
	&jprobe__tty_release,
	&jprobe__tty_paranoia_check,
	&jprobe__hung_up_tty_ioctl,
	&jprobe__misc_open,
	&jprobe__misc_seq_open,
	&jprobe__vcs_size,
	&jprobe__vcs_open,
	&jprobe__ide_drivers_open,
	&jprobe__idedisk_open,
	&jprobe__idedisk_ioctl,
	&jprobe__idedisk_release,
	&jprobe__input_open_file,
	&jprobe__input_proc_devices_open,
	&jprobe__input_proc_handlers_open,
	&jprobe__sock_close,
	&jprobe__sock_destroy_inode,
	&jprobe__sock_no_open,
	&jprobe__proto_seq_open,
	&jprobe__dev_seq_open,
	&jprobe__softnet_seq_open,
	&jprobe__dev_mc_seq_open,
	&jprobe__neigh_stat_seq_open,
	&jprobe__netlink_seq_open,
	&jprobe__rt_cache_seq_open,
	&jprobe__rt_cpu_seq_open,
	&jprobe__tcp_seq_open,
	&jprobe__raw_seq_open,
	&jprobe__udp_seq_open,
	&jprobe__arp_seq_open,
	&jprobe__igmp_mc_seq_open,
	&jprobe__igmp_mcf_seq_open,
	&jprobe__fib_seq_open,
	&jprobe__sockstat_seq_open,
	&jprobe__snmp_seq_open,
	&jprobe__netstat_seq_open,
	&jprobe__packet_seq_open,
	(void *)0,
};

static struct kretprobe *kretprobes[] = {
	&kretprobe__ioports_open,
	&kretprobe__iomem_open,
	&kretprobe__proc_opensys,
	&kretprobe__futex_close,
	&kretprobe__proc_dma_open,
	&kretprobe__kallsyms_open,
	&kretprobe__kallsyms_release,
	&kretprobe__relay_file_open,
	&kretprobe__relay_file_release,
	&kretprobe__sync_page_range,
	&kretprobe__sync_page_range_nolock,
	&kretprobe__vmtruncate,
	&kretprobe__vmtruncate_range,
	&kretprobe__shmem_destroy_inode,
	&kretprobe__shmem_delete_inode,
	&kretprobe__shmem_getpage,
	&kretprobe__shmem_truncate,
	&kretprobe__shmem_truncate_range,
	&kretprobe__shmem_recalc_inode,
	&kretprobe__shmem_free_blocks,
	&kretprobe__nonseekable_open,
	&kretprobe__generic_file_open,
	&kretprobe__chrdev_open,
	&kretprobe__cd_forget,
	&kretprobe__inode_add_bytes,
	&kretprobe__inode_sub_bytes,
	&kretprobe__inode_get_bytes,
	&kretprobe__inode_set_bytes,
	&kretprobe__generic_fillattr,
	&kretprobe__alloc_pipe_info,
	&kretprobe__pipe_read_release,
	&kretprobe__pipe_write_release,
	&kretprobe__pipe_rdwr_release,
	&kretprobe__pipe_release,
	&kretprobe__free_pipe_info,
	&kretprobe__pipe_ioctl,
	&kretprobe__pipe_read_open,
	&kretprobe__pipe_write_open,
	&kretprobe__pipe_rdwr_open,
	&kretprobe__vfs_rmdir,
	&kretprobe__vfs_unlink,
	&kretprobe__vfs_rename,
	&kretprobe__may_delete,
	&kretprobe__vfs_create,
	&kretprobe__vfs_mknod,
	&kretprobe__vfs_mkdir,
	&kretprobe__vfs_symlink,
	&kretprobe__vfs_link,
	&kretprobe__permission,
	&kretprobe__generic_permission,
	&kretprobe__get_write_access,
	&kretprobe__page_symlink,
	&kretprobe____page_symlink,
	&kretprobe__fifo_open,
	&kretprobe__wait_for_partner,
	&kretprobe__wake_up_partner,
	&kretprobe__locks_mandatory_area,
	&kretprobe____break_lease,
	&kretprobe__locks_mandatory_locked,
	&kretprobe__lease_get_mtime,
	&kretprobe____posix_lock_file_conf,
	&kretprobe__time_out_leases,
	&kretprobe__lock_may_write,
	&kretprobe__lock_may_read,
	&kretprobe__d_splice_alias,
	&kretprobe__d_materialise_unique,
	&kretprobe__d_prune_aliases,
	&kretprobe__d_instantiate_unique,
	&kretprobe__d_alloc_anon,
	&kretprobe__d_alloc_root,
	&kretprobe__d_instantiate,
	&kretprobe____d_instantiate_unique,
	&kretprobe__d_find_alias,
	&kretprobe____d_find_alias,
	&kretprobe__inode_init_once,
	&kretprobe__generic_drop_inode,
	&kretprobe__generic_delete_inode,
	&kretprobe__clear_inode,
	&kretprobe__destroy_inode,
	&kretprobe____wait_on_freeing_inode,
	&kretprobe__iput,
	&kretprobe__unlock_new_inode,
	&kretprobe__wake_up_inode,
	&kretprobe__igrab,
	&kretprobe____iget,
	&kretprobe__inode_double_unlock,
	&kretprobe____insert_inode_hash,
	&kretprobe__remove_inode_hash,
	&kretprobe__inode_double_lock,
	&kretprobe__init_special_inode,
	&kretprobe__inode_needs_sync,
	&kretprobe__bmap,
	&kretprobe__inode_setattr,
	&kretprobe__inode_change_ok,
	&kretprobe__make_bad_inode,
	&kretprobe__is_bad_inode,
	&kretprobe__bad_inode_permission,
	&kretprobe__bad_inode_rename,
	&kretprobe__bad_inode_mknod,
	&kretprobe__bad_inode_rmdir,
	&kretprobe__bad_inode_mkdir,
	&kretprobe__bad_inode_symlink,
	&kretprobe__bad_inode_unlink,
	&kretprobe__bad_inode_link,
	&kretprobe__bad_inode_lookup,
	&kretprobe__bad_inode_create,
	&kretprobe__bad_file_release,
	&kretprobe__bad_file_open,
	&kretprobe__bad_file_ioctl,
	&kretprobe__single_release,
	&kretprobe__seq_release_private,
	&kretprobe__seq_release,
	&kretprobe__xattr_permission,
	&kretprobe__simple_lookup,
	&kretprobe__simple_rename,
	&kretprobe__simple_rmdir,
	&kretprobe__simple_link,
	&kretprobe__dcache_dir_open,
	&kretprobe__dcache_dir_close,
	&kretprobe__simple_unlink,
	&kretprobe__simple_transaction_release,
	&kretprobe__simple_attr_open,
	&kretprobe__simple_attr_close,
	&kretprobe____mark_inode_dirty,
	&kretprobe__generic_osync_inode,
	&kretprobe__write_inode_now,
	&kretprobe__sync_inode,
	&kretprobe____writeback_single_inode,
	&kretprobe__fsstack_copy_attr_all,
	&kretprobe__fsstack_copy_inode_size,
	&kretprobe__invalidate_inode_buffers,
	&kretprobe__remove_inode_buffers,
	&kretprobe__mark_buffer_dirty_inode,
	&kretprobe____block_write_full_page,
	&kretprobe____block_prepare_write,
	&kretprobe____block_commit_write,
	&kretprobe__generic_cont_expand,
	&kretprobe__generic_cont_expand_simple,
	&kretprobe____generic_cont_expand,
	&kretprobe__inode_has_buffers,
	&kretprobe__bdev_clear_inode,
	&kretprobe__blkdev_close,
	&kretprobe__blkdev_get_block,
	&kretprobe__bdev_test,
	&kretprobe__bdev_destroy_inode,
	&kretprobe__blkdev_open,
	&kretprobe__bd_acquire,
	&kretprobe__bd_forget,
	&kretprobe__bdev_set,
	&kretprobe____blockdev_direct_IO,
	&kretprobe__inotify_d_instantiate,
	&kretprobe__inotify_inode_is_dead,
	&kretprobe__inotify_inode_queue_event,
	&kretprobe__inotify_add_watch,
	&kretprobe__set_dentry_child_flags,
	&kretprobe__inotify_find_watch,
	&kretprobe__inotify_find_update_watch,
	&kretprobe__inode_find_handle,
	&kretprobe__inotify_dev_queue_event,
	&kretprobe__inotify_release,
	&kretprobe__ep_eventpoll_close,
	&kretprobe____inode_dir_notify,
	&kretprobe__redo_inode_mask,
	&kretprobe__proc_exe_link,
	&kretprobe__maps_open,
	&kretprobe__smaps_open,
	&kretprobe__do_maps_open,
	&kretprobe__proc_delete_inode,
	&kretprobe__proc_destroy_inode,
	&kretprobe__proc_read_inode,
	&kretprobe__proc_root_lookup,
	&kretprobe__proc_task_lookup,
	&kretprobe__proc_pid_lookup,
	&kretprobe__proc_lookupfd,
	&kretprobe__proc_fd_link,
	&kretprobe__mountstats_open,
	&kretprobe__mounts_open,
	&kretprobe__proc_root_link,
	&kretprobe__proc_cwd_link,
	&kretprobe__mem_open,
	&kretprobe__proc_fd_access_allowed,
	&kretprobe__proc_tgid_base_lookup,
	&kretprobe__proc_tid_base_lookup,
	&kretprobe__proc_pident_lookup,
	&kretprobe__proc_pident_instantiate,
	&kretprobe__proc_pid_instantiate,
	&kretprobe__proc_task_instantiate,
	&kretprobe__proc_fd_instantiate,
	&kretprobe__mounts_release,
	&kretprobe__proc_base_instantiate,
	&kretprobe__proc_lookup,
	&kretprobe__tty_drivers_open,
	&kretprobe__stat_open,
	&kretprobe__slabstats_open,
	&kretprobe__slabstats_release,
	&kretprobe__fragmentation_open,
	&kretprobe__zoneinfo_open,
	&kretprobe__cpuinfo_open,
	&kretprobe__devinfo_open,
	&kretprobe__vmstat_open,
	&kretprobe__partitions_open,
	&kretprobe__diskstats_open,
	&kretprobe__modules_open,
	&kretprobe__slabinfo_open,
	&kretprobe__interrupts_open,
	&kretprobe__open_kcore,
	&kretprobe__kmsg_open,
	&kretprobe__kmsg_release,
	&kretprobe__sysfs_release,
	&kretprobe__sysfs_open_file,
	&kretprobe__sysfs_d_iput,
	&kretprobe__sysfs_lookup,
	&kretprobe__sysfs_dir_open,
	&kretprobe__sysfs_dir_close,
	&kretprobe__init_symlink,
	&kretprobe__init_file,
	&kretprobe__init_dir,
	&kretprobe__open,
	&kretprobe__release,
	&kretprobe__ext3_discard_reservation,
	&kretprobe__ext3_init_block_alloc_info,
	&kretprobe__ext3_new_block,
	&kretprobe__ext3_new_blocks,
	&kretprobe__ext3_free_blocks,
	&kretprobe__ext3_release_dir,
	&kretprobe__ext3_check_dir_entry,
	&kretprobe__ext3_release_file,
	&kretprobe__ext3_new_inode,
	&kretprobe__ext3_free_inode,
	&kretprobe__ext3_read_inode,
	&kretprobe__ext3_dirty_inode,
	&kretprobe__ext3_delete_inode,
	&kretprobe__ext3_write_inode,
	&kretprobe__ext3_change_inode_journal_flag,
	&kretprobe__ext3_bread,
	&kretprobe__ext3_truncate,
	&kretprobe__ext3_free_branches,
	&kretprobe__ext3_free_data,
	&kretprobe__ext3_clear_blocks,
	&kretprobe__ext3_forget,
	&kretprobe__ext3_get_block,
	&kretprobe__ext3_getblk,
	&kretprobe__ext3_get_blocks_handle,
	&kretprobe__ext3_writepage_trans_blocks,
	&kretprobe__ext3_get_branch,
	&kretprobe__ext3_block_to_path,
	&kretprobe__ext3_journal_test_restart,
	&kretprobe__try_to_extend_transaction,
	&kretprobe__ext3_mark_inode_dirty,
	&kretprobe__ext3_reserve_inode_write,
	&kretprobe__ext3_get_inode_loc,
	&kretprobe____ext3_get_inode_loc,
	&kretprobe__ext3_mark_iloc_dirty,
	&kretprobe__start_transaction,
	&kretprobe__ext3_set_inode_flags,
	&kretprobe__ext3_set_aops,
	&kretprobe__blocks_for_truncate,
	&kretprobe__ext3_inode_is_fast_symlink,
	&kretprobe__ext3_ioctl,
	&kretprobe__ext3_lookup,
	&kretprobe__ext3_rename,
	&kretprobe__ext3_unlink,
	&kretprobe__ext3_rmdir,
	&kretprobe__ext3_orphan_del,
	&kretprobe__ext3_mkdir,
	&kretprobe__ext3_link,
	&kretprobe__ext3_symlink,
	&kretprobe__ext3_mknod,
	&kretprobe__ext3_create,
	&kretprobe__htree_dirblock_to_tree,
	&kretprobe__ext3_orphan_add,
	&kretprobe__ext3_add_nondir,
	&kretprobe__ext3_add_entry,
	&kretprobe__dx_probe,
	&kretprobe__ext3_htree_next_block,
	&kretprobe__do_split,
	&kretprobe__add_dirent_to_buf,
	&kretprobe__empty_dir,
	&kretprobe__ext3_delete_entry,
	&kretprobe__ext3_append,
	&kretprobe__ext3_update_dx_flag,
	&kretprobe__ext3_clear_inode,
	&kretprobe__ext3_destroy_inode,
	&kretprobe__ext3_xattr_delete_inode,
	&kretprobe__ext3_xattr_get,
	&kretprobe__ext3_xattr_list,
	&kretprobe__ext3_xattr_set,
	&kretprobe__ext3_xattr_set_handle,
	&kretprobe__ext3_xattr_block_set,
	&kretprobe__ext3_xattr_ibody_set,
	&kretprobe__ext3_xattr_release_block,
	&kretprobe__ext3_xattr_list_entries,
	&kretprobe__ext3_xattr_user_get,
	&kretprobe__ext3_xattr_user_list,
	&kretprobe__ext3_xattr_user_set,
	&kretprobe__ext3_xattr_trusted_list,
	&kretprobe__ext3_xattr_trusted_get,
	&kretprobe__ext3_xattr_trusted_set,
	&kretprobe__journal_init_inode,
	&kretprobe__journal_blocks_per_page,
	&kretprobe__ext2_new_block,
	&kretprobe__ext2_free_blocks,
	&kretprobe__ext2_add_link,
	&kretprobe__ext2_set_link,
	&kretprobe__ext2_empty_dir,
	&kretprobe__ext2_inode_by_name,
	&kretprobe__ext2_dotdot,
	&kretprobe__ext2_make_empty,
	&kretprobe__ext2_find_entry,
	&kretprobe__ext2_get_page,
	&kretprobe__ext2_last_byte,
	&kretprobe__ext2_release_file,
	&kretprobe__ext2_new_inode,
	&kretprobe__ext2_free_inode,
	&kretprobe__ext2_read_inode,
	&kretprobe__ext2_get_block,
	&kretprobe__ext2_delete_inode,
	&kretprobe__ext2_put_inode,
	&kretprobe__ext2_alloc_block,
	&kretprobe__ext2_truncate,
	&kretprobe__ext2_free_branches,
	&kretprobe__ext2_get_branch,
	&kretprobe__ext2_discard_prealloc,
	&kretprobe__ext2_block_to_path,
	&kretprobe__ext2_write_inode,
	&kretprobe__ext2_update_inode,
	&kretprobe__ext2_sync_inode,
	&kretprobe__ext2_set_inode_flags,
	&kretprobe__ext2_ioctl,
	&kretprobe__ext2_lookup,
	&kretprobe__ext2_symlink,
	&kretprobe__ext2_mknod,
	&kretprobe__ext2_create,
	&kretprobe__ext2_rename,
	&kretprobe__ext2_mkdir,
	&kretprobe__ext2_link,
	&kretprobe__ext2_rmdir,
	&kretprobe__ext2_unlink,
	&kretprobe__ext2_destroy_inode,
	&kretprobe__ext2_clear_inode,
	&kretprobe__ramfs_symlink,
	&kretprobe__ramfs_mkdir,
	&kretprobe__ramfs_create,
	&kretprobe__ramfs_mknod,
	&kretprobe__debugfs_mknod,
	&kretprobe__fops_u16_open,
	&kretprobe__fops_u8_open,
	&kretprobe__fops_u32_open,
	&kretprobe__default_open,
	&kretprobe__sysvipc_proc_open,
	&kretprobe__shm_release,
	&kretprobe__mqueue_delete_inode,
	&kretprobe__mqueue_destroy_inode,
	&kretprobe__mqueue_create,
	&kretprobe__mqueue_unlink,
	&kretprobe__crypto_info_open,
	&kretprobe__blkdev_ioctl,
	&kretprobe__blkdev_driver_ioctl,
	&kretprobe__blk_dropped_open,
	&kretprobe__proc_bus_pci_ioctl,
	&kretprobe__proc_bus_pci_open,
	&kretprobe__proc_bus_pci_release,
	&kretprobe__proc_bus_pci_dev_open,
	&kretprobe__open_port,
	&kretprobe__memory_open,
	&kretprobe__random_ioctl,
	&kretprobe__ptmx_open,
	&kretprobe__tty_open,
	&kretprobe__tty_ioctl,
	&kretprobe__tty_release,
	&kretprobe__tty_paranoia_check,
	&kretprobe__hung_up_tty_ioctl,
	&kretprobe__misc_open,
	&kretprobe__misc_seq_open,
	&kretprobe__vcs_size,
	&kretprobe__vcs_open,
	&kretprobe__ide_drivers_open,
	&kretprobe__idedisk_open,
	&kretprobe__idedisk_ioctl,
	&kretprobe__idedisk_release,
	&kretprobe__input_open_file,
	&kretprobe__input_proc_devices_open,
	&kretprobe__input_proc_handlers_open,
	&kretprobe__sock_close,
	&kretprobe__sock_destroy_inode,
	&kretprobe__sock_no_open,
	&kretprobe__proto_seq_open,
	&kretprobe__dev_seq_open,
	&kretprobe__softnet_seq_open,
	&kretprobe__dev_mc_seq_open,
	&kretprobe__neigh_stat_seq_open,
	&kretprobe__netlink_seq_open,
	&kretprobe__rt_cache_seq_open,
	&kretprobe__rt_cpu_seq_open,
	&kretprobe__tcp_seq_open,
	&kretprobe__raw_seq_open,
	&kretprobe__udp_seq_open,
	&kretprobe__arp_seq_open,
	&kretprobe__igmp_mc_seq_open,
	&kretprobe__igmp_mcf_seq_open,
	&kretprobe__fib_seq_open,
	&kretprobe__sockstat_seq_open,
	&kretprobe__snmp_seq_open,
	&kretprobe__netstat_seq_open,
	&kretprobe__packet_seq_open,
	(void *)0,
};


static int __attribute__ ((__section__ (".init.text"))) jprobe_init(void)
{
	unsigned int i = 0, nj = 0, nr = 0;
	if (ctracer__init() != 0)
		return -1;
	while (jprobes[i] != (void *)0) {
		int err = register_jprobe(jprobes[i]);
		if (err != 0)
			printk("register_jprobe(%s) failed, returned %d\n",
			       jprobes[i]->kp.symbol_name, err);
		else
			++nj;
		err = register_kretprobe(kretprobes[i]);
		if (err != 0)
			printk("register_kretprobe(%s) failed, returned %d\n",
			       kretprobes[i]->kp.symbol_name, err);
		else
			++nr;
		++i;
		if ((i % 5) == 0)
			yield();
	}

	printk("ctracer: registered %u entry probes\n", nj);
	printk("ctracer: registered %u exit probes\n", nr);

        return 0;
}

int init_module(void) __attribute__((alias("jprobe_init")));

static void __attribute__ ((__section__ (".exit.text"))) jprobe_exit(void)
{
	int i = 0;
	while (jprobes[i] != (void *)0) {
		if (jprobes[i]->kp.nmissed)
			printk("ctracer: entry: missed %d %s\n",
				jprobes[i]->kp.nmissed,
				jprobes[i]->kp.symbol_name);
		unregister_jprobe(jprobes[i]);
		if (kretprobes[i]->nmissed)
			printk("ctracer: exit: missed %d %s\n",
				kretprobes[i]->nmissed,
				kretprobes[i]->kp.symbol_name);
		unregister_kretprobe(kretprobes[i]);
		++i;
		if ((i % 5) == 0)
			yield();	}

}

int cleanup_module(void) __attribute__((alias("jprobe_exit")));

static const char __mod_license[] __attribute__((__used__)) 
	__attribute__((section(".modinfo"),unused)) = "license=GPL";

