← Back to branch summary

~ecryptfs/ecryptfs/trunk

« back to all changes in this revision

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

  • Committer: mhalcrow@us.ibm.com
  • Date: 2007-11-06 22:56:01 UTC
  • Revision ID: git-v1:f8357de9d554b274497b5cce9db4347254b7e7eb
Initial import of eCryptfs filesystem userspace utilities (mount helper, daemon component,
etc.)

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");