← Back to branch summary

~ecryptfs/ecryptfs/trunk

« back to all changes in this revision

Viewing changes to src/jprobes/jprobe-mount.c

  • Committer: Dustin Kirkland
  • Date: 2016-02-27 00:00:23 UTC
  • Revision ID: kirkland@ubuntu.com-20160227000023-h0e4oui5y1vbaurd
opening 112

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/jprobes/jprobe-mount.c
1
 
/**
2
 
 * jprobe module for debugging eCryptfs mount operations
3
 
 */
4
 
 
5
 
#include <linux/module.h>
6
 
#include <linux/init.h>
7
 
#include <linux/kprobes.h>
8
 
#include <linux/kallsyms.h>
9
 
#include <linux/fs.h>
10
 
#include <linux/mount.h>
11
 
 
12
 
struct jprobe_mapping_elem {
13
 
        struct jprobe *jp;
14
 
        char *symbol;
15
 
        void *fp;
16
 
};
17
 
 
18
 
int jp_do_umount(struct vfsmount *mnt, int flags)
19
 
{
20
 
        printk(KERN_INFO "%s: mnt = [0x%p]; flags = [0x%x]\n", __FUNCTION__,
21
 
               mnt, flags);
22
 
        jprobe_return();
23
 
        return 0;
24
 
}
25
 
 
26
 
void jp_ecryptfs_kill_block_super(struct super_block *sb)
27
 
{
28
 
        printk(KERN_INFO "%s: sb = [0x%p]\n", __FUNCTION__, sb);
29
 
        jprobe_return();
30
 
}
31
 
 
32
 
void jp_ecryptfs_put_super(struct super_block *sb)
33
 
{
34
 
        printk(KERN_INFO "%s: sb = [0x%p]\n", __FUNCTION__, sb);
35
 
        jprobe_return();
36
 
}
37
 
 
38
 
void jp_ecryptfs_umount_begin(struct vfsmount *vfsmnt, int flags)
39
 
{
40
 
        printk(KERN_INFO "%s: vfsmnt = [0x%p]; flags = [0x%.8x]\n",
41
 
               __FUNCTION__, vfsmnt, flags);
42
 
        jprobe_return();
43
 
}
44
 
 
45
 
int jp_ecryptfs_get_sb(struct file_system_type *fs_type, int flags,
46
 
                       const char *dev_name, void *raw_data,
47
 
                       struct vfsmount *mnt)
48
 
{
49
 
        printk(KERN_INFO "%s: fs_type = [0x%p]; flags = [0x%.8x], dev_name = "
50
 
               "[%s], raw_data = [0x%p], mnt = [0x%p]\n",
51
 
               __FUNCTION__, fs_type, flags, dev_name, raw_data, mnt);
52
 
        jprobe_return();
53
 
        return 0;
54
 
}
55
 
 
56
 
int jp_get_sb_nodev(struct file_system_type *fs_type,
57
 
                    int flags, void *data,
58
 
                    int (*fill_super)(struct super_block *, void *, int),
59
 
                    struct vfsmount *mnt)
60
 
{
61
 
        printk(KERN_INFO "%s: fs_type = [0x%p]; flags = [0x%.8x], data = "
62
 
               "[0x%p], mnt = [0x%p]\n",
63
 
               __FUNCTION__, fs_type, flags, data, mnt);
64
 
        jprobe_return();
65
 
        return 0;
66
 
}
67
 
 
68
 
int jp_ecryptfs_fill_super(struct super_block *sb, void *raw_data, int silent)
69
 
{
70
 
        printk(KERN_INFO "%s: sb = [0x%p]; raw_data = [0x%p], silent = [%d]\n",
71
 
               __FUNCTION__, sb, raw_data, silent);
72
 
        jprobe_return();
73
 
        return 0;
74
 
}
75
 
 
76
 
int jp_ecryptfs_read_super(struct super_block *sb, const char *dev_name)
77
 
{
78
 
        printk(KERN_INFO "%s: sb = [0x%p]; dev_name = [%s]\n",
79
 
               __FUNCTION__, sb, dev_name);
80
 
        jprobe_return();
81
 
        return 0;
82
 
}
83
 
 
84
 
int jp_ecryptfs_interpose(struct dentry *lower_dentry, struct dentry *dentry,
85
 
                          struct super_block *sb, int flag)
86
 
{
87
 
        printk(KERN_INFO "%s: lower_dentry = [0x%p]; dentry = [0x%p]; sb = "
88
 
               "[0x%p]; flag = [0x%.8x]\n", __FUNCTION__, lower_dentry, dentry,
89
 
               sb, flag);
90
 
        if (flag)
91
 
                printk(KERN_INFO "%s: d_add() will be called\n", __FUNCTION__);
92
 
        else
93
 
                printk(KERN_INFO "%s: d_instantiate() will be called\n",
94
 
                       __FUNCTION__);
95
 
        jprobe_return();
96
 
        return 0;
97
 
}
98
 
 
99
 
asmlinkage long jp_sys_umount(char __user * name, int flags)
100
 
{
101
 
        char *tmp = getname(name);
102
 
 
103
 
        if (!IS_ERR(tmp)) {
104
 
                printk(KERN_INFO "%s: name = [%s]; flags = [0x%x]\n",
105
 
                       __FUNCTION__, tmp, flags);
106
 
                putname(tmp);
107
 
        } else 
108
 
                printk(KERN_INFO "%s: (getname failed); flags = [0x%x]\n",
109
 
                       __FUNCTION__, flags);
110
 
        jprobe_return();
111
 
        return 0;       
112
 
}
113
 
 
114
 
struct jprobe_mapping_elem jprobe_mapping[] = {
115
 
        {NULL, "ecryptfs_kill_block_super", jp_ecryptfs_kill_block_super},
116
 
        {NULL, "ecryptfs_put_super", jp_ecryptfs_put_super},
117
 
        {NULL, "ecryptfs_umount_begin", jp_ecryptfs_umount_begin},
118
 
        {NULL, "ecryptfs_get_sb", jp_ecryptfs_get_sb},
119
 
        {NULL, "get_sb_nodev", jp_get_sb_nodev},
120
 
        {NULL, "ecryptfs_fill_super", jp_ecryptfs_fill_super},
121
 
        {NULL, "ecryptfs_read_super", jp_ecryptfs_read_super},
122
 
        {NULL, "sys_umount", jp_sys_umount},
123
 
        {NULL, "do_umount", jp_do_umount},
124
 
/*      {NULL, "ecryptfs_interpose", jp_ecryptfs_interpose} */
125
 
};
126
 
 
127
 
static int __init jprobe_mount_init(void)
128
 
{
129
 
        int i;
130
 
 
131
 
        for (i = 0; i < ARRAY_SIZE(jprobe_mapping); i++) {
132
 
                jprobe_mapping[i].jp = kmalloc(sizeof(struct jprobe),
133
 
                                               GFP_KERNEL);
134
 
                jprobe_mapping[i].jp->entry = jprobe_mapping[i].fp;
135
 
                jprobe_mapping[i].jp->kp.addr = (kprobe_opcode_t *)
136
 
                        kallsyms_lookup_name(jprobe_mapping[i].symbol);
137
 
                if (jprobe_mapping[i].jp->kp.addr == NULL) {
138
 
                        int j;
139
 
 
140
 
                        printk(KERN_NOTICE "Unable to find symbol [%s]\n",
141
 
                               jprobe_mapping[i].symbol);
142
 
                        for (j = 0; j < i; j++) {
143
 
                                unregister_jprobe(jprobe_mapping[j].jp);
144
 
                                kfree(jprobe_mapping[j].jp);
145
 
                        }
146
 
                        return -EINVAL;
147
 
                }
148
 
                register_jprobe(jprobe_mapping[i].jp);
149
 
        }
150
 
        return 0;
151
 
}
152
 
 
153
 
static void __exit jprobe_mount_exit(void)
154
 
{
155
 
        int i;
156
 
 
157
 
        for (i = 0; i < ARRAY_SIZE(jprobe_mapping); i++) {
158
 
                unregister_jprobe(jprobe_mapping[i].jp);
159
 
                kfree(jprobe_mapping[i].jp);
160
 
        }
161
 
}
162
 
 
163
 
module_init(jprobe_mount_init);
164
 
module_exit(jprobe_mount_exit);
165
 
MODULE_LICENSE("GPL");