Commit | Line | Data |
---|---|---|
5dc8bf81 DL |
1 | /* |
2 | * fs/anon_inodes.c | |
3 | * | |
4 | * Copyright (C) 2007 Davide Libenzi <davidel@xmailserver.org> | |
5 | * | |
6 | * Thanks to Arnd Bergmann for code review and suggestions. | |
7 | * More changes for Thomas Gleixner suggestions. | |
8 | * | |
9 | */ | |
10 | ||
11 | #include <linux/file.h> | |
12 | #include <linux/poll.h> | |
13 | #include <linux/slab.h> | |
14 | #include <linux/init.h> | |
15 | #include <linux/fs.h> | |
16 | #include <linux/mount.h> | |
17 | #include <linux/module.h> | |
18 | #include <linux/kernel.h> | |
19 | #include <linux/magic.h> | |
20 | #include <linux/anon_inodes.h> | |
21 | ||
22 | #include <asm/uaccess.h> | |
23 | ||
24 | static struct vfsmount *anon_inode_mnt __read_mostly; | |
25 | static struct inode *anon_inode_inode; | |
26 | static const struct file_operations anon_inode_fops; | |
27 | ||
28 | static int anon_inodefs_get_sb(struct file_system_type *fs_type, int flags, | |
29 | const char *dev_name, void *data, | |
30 | struct vfsmount *mnt) | |
31 | { | |
32 | return get_sb_pseudo(fs_type, "anon_inode:", NULL, ANON_INODE_FS_MAGIC, | |
33 | mnt); | |
34 | } | |
35 | ||
36 | static int anon_inodefs_delete_dentry(struct dentry *dentry) | |
37 | { | |
38 | /* | |
39 | * We faked vfs to believe the dentry was hashed when we created it. | |
40 | * Now we restore the flag so that dput() will work correctly. | |
41 | */ | |
42 | dentry->d_flags |= DCACHE_UNHASHED; | |
43 | return 1; | |
44 | } | |
45 | ||
46 | static struct file_system_type anon_inode_fs_type = { | |
47 | .name = "anon_inodefs", | |
48 | .get_sb = anon_inodefs_get_sb, | |
49 | .kill_sb = kill_anon_super, | |
50 | }; | |
51 | static struct dentry_operations anon_inodefs_dentry_operations = { | |
52 | .d_delete = anon_inodefs_delete_dentry, | |
53 | }; | |
54 | ||
55 | /** | |
4b4e5a14 | 56 | * anon_inode_getfd - creates a new file instance by hooking it up to an |
5dc8bf81 DL |
57 | * anonymous inode, and a dentry that describe the "class" |
58 | * of the file | |
59 | * | |
60 | * @pfd: [out] pointer to the file descriptor | |
61 | * @dpinode: [out] pointer to the inode | |
62 | * @pfile: [out] pointer to the file struct | |
63 | * @name: [in] name of the "class" of the new file | |
64 | * @fops [in] file operations for the new file | |
65 | * @priv [in] private data for the new file (will be file's private_data) | |
66 | * | |
67 | * Creates a new file by hooking it on a single inode. This is useful for files | |
68 | * that do not need to have a full-fledged inode in order to operate correctly. | |
4b4e5a14 | 69 | * All the files created with anon_inode_getfd() will share a single inode, |
5dc8bf81 DL |
70 | * hence saving memory and avoiding code duplication for the file/inode/dentry |
71 | * setup. | |
72 | */ | |
73 | int anon_inode_getfd(int *pfd, struct inode **pinode, struct file **pfile, | |
74 | const char *name, const struct file_operations *fops, | |
75 | void *priv) | |
76 | { | |
77 | struct qstr this; | |
78 | struct dentry *dentry; | |
79 | struct inode *inode; | |
80 | struct file *file; | |
81 | int error, fd; | |
82 | ||
83 | if (IS_ERR(anon_inode_inode)) | |
84 | return -ENODEV; | |
85 | file = get_empty_filp(); | |
86 | if (!file) | |
87 | return -ENFILE; | |
88 | ||
89 | inode = igrab(anon_inode_inode); | |
90 | if (IS_ERR(inode)) { | |
91 | error = PTR_ERR(inode); | |
92 | goto err_put_filp; | |
93 | } | |
94 | ||
95 | error = get_unused_fd(); | |
96 | if (error < 0) | |
97 | goto err_iput; | |
98 | fd = error; | |
99 | ||
100 | /* | |
101 | * Link the inode to a directory entry by creating a unique name | |
102 | * using the inode sequence number. | |
103 | */ | |
104 | error = -ENOMEM; | |
105 | this.name = name; | |
106 | this.len = strlen(name); | |
107 | this.hash = 0; | |
108 | dentry = d_alloc(anon_inode_mnt->mnt_sb->s_root, &this); | |
109 | if (!dentry) | |
110 | goto err_put_unused_fd; | |
111 | dentry->d_op = &anon_inodefs_dentry_operations; | |
112 | /* Do not publish this dentry inside the global dentry hash table */ | |
113 | dentry->d_flags &= ~DCACHE_UNHASHED; | |
114 | d_instantiate(dentry, inode); | |
115 | ||
116 | file->f_path.mnt = mntget(anon_inode_mnt); | |
117 | file->f_path.dentry = dentry; | |
118 | file->f_mapping = inode->i_mapping; | |
119 | ||
120 | file->f_pos = 0; | |
121 | file->f_flags = O_RDWR; | |
122 | file->f_op = fops; | |
123 | file->f_mode = FMODE_READ | FMODE_WRITE; | |
124 | file->f_version = 0; | |
125 | file->private_data = priv; | |
126 | ||
127 | fd_install(fd, file); | |
128 | ||
129 | *pfd = fd; | |
130 | *pinode = inode; | |
131 | *pfile = file; | |
132 | return 0; | |
133 | ||
134 | err_put_unused_fd: | |
135 | put_unused_fd(fd); | |
136 | err_iput: | |
137 | iput(inode); | |
138 | err_put_filp: | |
139 | put_filp(file); | |
140 | return error; | |
141 | } | |
d6d28168 | 142 | EXPORT_SYMBOL_GPL(anon_inode_getfd); |
5dc8bf81 DL |
143 | |
144 | /* | |
4b4e5a14 BF |
145 | * A single inode exists for all anon_inode files. Contrary to pipes, |
146 | * anon_inode inodes have no associated per-instance data, so we need | |
147 | * only allocate one of them. | |
5dc8bf81 DL |
148 | */ |
149 | static struct inode *anon_inode_mkinode(void) | |
150 | { | |
151 | struct inode *inode = new_inode(anon_inode_mnt->mnt_sb); | |
152 | ||
153 | if (!inode) | |
154 | return ERR_PTR(-ENOMEM); | |
155 | ||
156 | inode->i_fop = &anon_inode_fops; | |
157 | ||
158 | /* | |
159 | * Mark the inode dirty from the very beginning, | |
160 | * that way it will never be moved to the dirty | |
161 | * list because mark_inode_dirty() will think | |
162 | * that it already _is_ on the dirty list. | |
163 | */ | |
164 | inode->i_state = I_DIRTY; | |
165 | inode->i_mode = S_IRUSR | S_IWUSR; | |
166 | inode->i_uid = current->fsuid; | |
167 | inode->i_gid = current->fsgid; | |
168 | inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME; | |
169 | return inode; | |
170 | } | |
171 | ||
172 | static int __init anon_inode_init(void) | |
173 | { | |
174 | int error; | |
175 | ||
176 | error = register_filesystem(&anon_inode_fs_type); | |
177 | if (error) | |
178 | goto err_exit; | |
179 | anon_inode_mnt = kern_mount(&anon_inode_fs_type); | |
180 | if (IS_ERR(anon_inode_mnt)) { | |
181 | error = PTR_ERR(anon_inode_mnt); | |
182 | goto err_unregister_filesystem; | |
183 | } | |
184 | anon_inode_inode = anon_inode_mkinode(); | |
185 | if (IS_ERR(anon_inode_inode)) { | |
186 | error = PTR_ERR(anon_inode_inode); | |
187 | goto err_mntput; | |
188 | } | |
189 | ||
190 | return 0; | |
191 | ||
192 | err_mntput: | |
193 | mntput(anon_inode_mnt); | |
194 | err_unregister_filesystem: | |
195 | unregister_filesystem(&anon_inode_fs_type); | |
196 | err_exit: | |
197 | panic(KERN_ERR "anon_inode_init() failed (%d)\n", error); | |
198 | } | |
199 | ||
200 | fs_initcall(anon_inode_init); | |
201 |