blob: 5fd38112a6ca5b2c19ea471620ed678f9609cbce [file] [log] [blame]
Davide Libenzi5dc8bf82007-05-10 22:23:11 -07001/*
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
Alexey Dobriyana99bbaf2009-10-04 16:11:37 +040011#include <linux/cred.h>
Davide Libenzi5dc8bf82007-05-10 22:23:11 -070012#include <linux/file.h>
13#include <linux/poll.h>
Alexey Dobriyana99bbaf2009-10-04 16:11:37 +040014#include <linux/sched.h>
Davide Libenzi5dc8bf82007-05-10 22:23:11 -070015#include <linux/init.h>
16#include <linux/fs.h>
17#include <linux/mount.h>
18#include <linux/module.h>
19#include <linux/kernel.h>
20#include <linux/magic.h>
21#include <linux/anon_inodes.h>
22
23#include <asm/uaccess.h>
24
25static struct vfsmount *anon_inode_mnt __read_mostly;
26static struct inode *anon_inode_inode;
27static const struct file_operations anon_inode_fops;
28
Al Viro51139ad2010-07-25 23:47:46 +040029static struct dentry *anon_inodefs_mount(struct file_system_type *fs_type,
30 int flags, const char *dev_name, void *data)
Davide Libenzi5dc8bf82007-05-10 22:23:11 -070031{
Al Viro51139ad2010-07-25 23:47:46 +040032 return mount_pseudo(fs_type, "anon_inode:", NULL, ANON_INODE_FS_MAGIC);
Davide Libenzi5dc8bf82007-05-10 22:23:11 -070033}
34
Nick Pigginb9aff022009-11-20 14:28:35 -080035/*
36 * anon_inodefs_dname() is called from d_path().
37 */
38static char *anon_inodefs_dname(struct dentry *dentry, char *buffer, int buflen)
39{
40 return dynamic_dname(dentry, buffer, buflen, "anon_inode:%s",
41 dentry->d_name.name);
42}
43
Davide Libenzi5dc8bf82007-05-10 22:23:11 -070044static struct file_system_type anon_inode_fs_type = {
45 .name = "anon_inodefs",
Al Viro51139ad2010-07-25 23:47:46 +040046 .mount = anon_inodefs_mount,
Davide Libenzi5dc8bf82007-05-10 22:23:11 -070047 .kill_sb = kill_anon_super,
48};
Al Viro3ba13d12009-02-20 06:02:22 +000049static const struct dentry_operations anon_inodefs_dentry_operations = {
Nick Pigginb9aff022009-11-20 14:28:35 -080050 .d_dname = anon_inodefs_dname,
Davide Libenzi5dc8bf82007-05-10 22:23:11 -070051};
52
Peter Zijlstrad3a92622009-06-18 12:54:00 +020053/*
54 * nop .set_page_dirty method so that people can use .page_mkwrite on
55 * anon inodes.
56 */
57static int anon_set_page_dirty(struct page *page)
58{
59 return 0;
60};
61
62static const struct address_space_operations anon_aops = {
63 .set_page_dirty = anon_set_page_dirty,
64};
65
Davide Libenzi5dc8bf82007-05-10 22:23:11 -070066/**
J. Bruce Fields4b4e5a12007-07-15 23:41:53 -070067 * anon_inode_getfd - creates a new file instance by hooking it up to an
Davide Libenzi5dc8bf82007-05-10 22:23:11 -070068 * anonymous inode, and a dentry that describe the "class"
69 * of the file
70 *
Davide Libenzi5dc8bf82007-05-10 22:23:11 -070071 * @name: [in] name of the "class" of the new file
Ulrich Drepper7d9dbca2008-07-23 21:29:22 -070072 * @fops: [in] file operations for the new file
73 * @priv: [in] private data for the new file (will be file's private_data)
74 * @flags: [in] flags
Davide Libenzi5dc8bf82007-05-10 22:23:11 -070075 *
76 * Creates a new file by hooking it on a single inode. This is useful for files
77 * that do not need to have a full-fledged inode in order to operate correctly.
Davide Libenzi562787a2009-09-22 16:43:57 -070078 * All the files created with anon_inode_getfile() will share a single inode,
Davide Libenzi5dc8bf82007-05-10 22:23:11 -070079 * hence saving memory and avoiding code duplication for the file/inode/dentry
Davide Libenzi562787a2009-09-22 16:43:57 -070080 * setup. Returns the newly created file* or an error pointer.
Davide Libenzi5dc8bf82007-05-10 22:23:11 -070081 */
Davide Libenzi562787a2009-09-22 16:43:57 -070082struct file *anon_inode_getfile(const char *name,
83 const struct file_operations *fops,
84 void *priv, int flags)
Davide Libenzi5dc8bf82007-05-10 22:23:11 -070085{
86 struct qstr this;
Al Viro2c48b9c2009-08-09 00:52:35 +040087 struct path path;
Davide Libenzi5dc8bf82007-05-10 22:23:11 -070088 struct file *file;
Davide Libenzi562787a2009-09-22 16:43:57 -070089 int error;
Davide Libenzi5dc8bf82007-05-10 22:23:11 -070090
91 if (IS_ERR(anon_inode_inode))
Davide Libenzi562787a2009-09-22 16:43:57 -070092 return ERR_PTR(-ENODEV);
Davide Libenzi5dc8bf82007-05-10 22:23:11 -070093
Christian Borntraegere3a2a0d2008-12-02 11:16:03 +010094 if (fops->owner && !try_module_get(fops->owner))
Davide Libenzi562787a2009-09-22 16:43:57 -070095 return ERR_PTR(-ENOENT);
Davide Libenzi5dc8bf82007-05-10 22:23:11 -070096
97 /*
98 * Link the inode to a directory entry by creating a unique name
99 * using the inode sequence number.
100 */
101 error = -ENOMEM;
102 this.name = name;
103 this.len = strlen(name);
104 this.hash = 0;
Nick Piggin4b936882011-01-07 17:50:07 +1100105 path.dentry = d_alloc_pseudo(anon_inode_mnt->mnt_sb, &this);
Al Viro2c48b9c2009-08-09 00:52:35 +0400106 if (!path.dentry)
Davide Libenzi562787a2009-09-22 16:43:57 -0700107 goto err_module;
Davide Libenzi96fdc722007-10-16 23:30:19 -0700108
Al Viro2c48b9c2009-08-09 00:52:35 +0400109 path.mnt = mntget(anon_inode_mnt);
Davide Libenzi96fdc722007-10-16 23:30:19 -0700110 /*
111 * We know the anon_inode inode count is always greater than zero,
Al Viro7de9c6ee2010-10-23 11:11:40 -0400112 * so ihold() is safe.
Davide Libenzi96fdc722007-10-16 23:30:19 -0700113 */
Al Viro7de9c6ee2010-10-23 11:11:40 -0400114 ihold(anon_inode_inode);
Davide Libenzi96fdc722007-10-16 23:30:19 -0700115
Nick Pigginfb045ad2011-01-07 17:49:55 +1100116 d_set_d_op(path.dentry, &anon_inodefs_dentry_operations);
Al Viro2c48b9c2009-08-09 00:52:35 +0400117 d_instantiate(path.dentry, anon_inode_inode);
Davide Libenzi5dc8bf82007-05-10 22:23:11 -0700118
Dave Hansen430e2852008-02-15 14:37:26 -0800119 error = -ENFILE;
Al Viro53009902009-12-19 10:15:07 -0500120 file = alloc_file(&path, OPEN_FMODE(flags), fops);
Dave Hansen430e2852008-02-15 14:37:26 -0800121 if (!file)
122 goto err_dput;
Davide Libenzi96fdc722007-10-16 23:30:19 -0700123 file->f_mapping = anon_inode_inode->i_mapping;
Davide Libenzi5dc8bf82007-05-10 22:23:11 -0700124
125 file->f_pos = 0;
Roland Dreier628ff7c2009-12-18 09:41:24 -0800126 file->f_flags = flags & (O_ACCMODE | O_NONBLOCK);
Davide Libenzi5dc8bf82007-05-10 22:23:11 -0700127 file->f_version = 0;
128 file->private_data = priv;
129
Davide Libenzi562787a2009-09-22 16:43:57 -0700130 return file;
131
132err_dput:
Al Viro2c48b9c2009-08-09 00:52:35 +0400133 path_put(&path);
Davide Libenzi562787a2009-09-22 16:43:57 -0700134err_module:
135 module_put(fops->owner);
136 return ERR_PTR(error);
137}
138EXPORT_SYMBOL_GPL(anon_inode_getfile);
139
140/**
141 * anon_inode_getfd - creates a new file instance by hooking it up to an
142 * anonymous inode, and a dentry that describe the "class"
143 * of the file
144 *
145 * @name: [in] name of the "class" of the new file
146 * @fops: [in] file operations for the new file
147 * @priv: [in] private data for the new file (will be file's private_data)
148 * @flags: [in] flags
149 *
150 * Creates a new file by hooking it on a single inode. This is useful for files
151 * that do not need to have a full-fledged inode in order to operate correctly.
152 * All the files created with anon_inode_getfd() will share a single inode,
153 * hence saving memory and avoiding code duplication for the file/inode/dentry
154 * setup. Returns new descriptor or an error code.
155 */
156int anon_inode_getfd(const char *name, const struct file_operations *fops,
157 void *priv, int flags)
158{
159 int error, fd;
160 struct file *file;
161
162 error = get_unused_fd_flags(flags);
163 if (error < 0)
164 return error;
165 fd = error;
166
167 file = anon_inode_getfile(name, fops, priv, flags);
168 if (IS_ERR(file)) {
169 error = PTR_ERR(file);
170 goto err_put_unused_fd;
171 }
Davide Libenzi5dc8bf82007-05-10 22:23:11 -0700172 fd_install(fd, file);
173
Al Viro2030a422008-02-23 06:46:49 -0500174 return fd;
Davide Libenzi5dc8bf82007-05-10 22:23:11 -0700175
176err_put_unused_fd:
177 put_unused_fd(fd);
Davide Libenzi5dc8bf82007-05-10 22:23:11 -0700178 return error;
179}
Avi Kivityd6d28162007-06-28 08:38:16 -0400180EXPORT_SYMBOL_GPL(anon_inode_getfd);
Davide Libenzi5dc8bf82007-05-10 22:23:11 -0700181
182/*
J. Bruce Fields4b4e5a12007-07-15 23:41:53 -0700183 * A single inode exists for all anon_inode files. Contrary to pipes,
184 * anon_inode inodes have no associated per-instance data, so we need
185 * only allocate one of them.
Davide Libenzi5dc8bf82007-05-10 22:23:11 -0700186 */
187static struct inode *anon_inode_mkinode(void)
188{
189 struct inode *inode = new_inode(anon_inode_mnt->mnt_sb);
190
191 if (!inode)
192 return ERR_PTR(-ENOMEM);
193
Christoph Hellwig85fe4022010-10-23 11:19:54 -0400194 inode->i_ino = get_next_ino();
Davide Libenzi5dc8bf82007-05-10 22:23:11 -0700195 inode->i_fop = &anon_inode_fops;
196
Peter Zijlstrad3a92622009-06-18 12:54:00 +0200197 inode->i_mapping->a_ops = &anon_aops;
198
Davide Libenzi5dc8bf82007-05-10 22:23:11 -0700199 /*
200 * Mark the inode dirty from the very beginning,
201 * that way it will never be moved to the dirty
202 * list because mark_inode_dirty() will think
203 * that it already _is_ on the dirty list.
204 */
205 inode->i_state = I_DIRTY;
Al Viro1eb2cbb2010-05-27 11:11:06 -0400206 inode->i_mode = S_IRUSR | S_IWUSR;
David Howellsda9592e2008-11-14 10:39:05 +1100207 inode->i_uid = current_fsuid();
208 inode->i_gid = current_fsgid();
Eric Paris3836a032010-03-09 22:23:01 -0500209 inode->i_flags |= S_PRIVATE;
Davide Libenzi5dc8bf82007-05-10 22:23:11 -0700210 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
211 return inode;
212}
213
214static int __init anon_inode_init(void)
215{
216 int error;
217
218 error = register_filesystem(&anon_inode_fs_type);
219 if (error)
220 goto err_exit;
221 anon_inode_mnt = kern_mount(&anon_inode_fs_type);
222 if (IS_ERR(anon_inode_mnt)) {
223 error = PTR_ERR(anon_inode_mnt);
224 goto err_unregister_filesystem;
225 }
226 anon_inode_inode = anon_inode_mkinode();
227 if (IS_ERR(anon_inode_inode)) {
228 error = PTR_ERR(anon_inode_inode);
229 goto err_mntput;
230 }
231
232 return 0;
233
234err_mntput:
Nick Pigginb3e19d92011-01-07 17:50:11 +1100235 mntput_long(anon_inode_mnt);
Davide Libenzi5dc8bf82007-05-10 22:23:11 -0700236err_unregister_filesystem:
237 unregister_filesystem(&anon_inode_fs_type);
238err_exit:
239 panic(KERN_ERR "anon_inode_init() failed (%d)\n", error);
240}
241
242fs_initcall(anon_inode_init);
243