anon_inodes.c 6.36 KB
Newer Older
1 2 3 4 5 6 7 8 9 10
/*
 *  fs/anon_inodes.c
 *
 *  Copyright (C) 2007  Davide Libenzi <davidel@xmailserver.org>
 *
 *  Thanks to Arnd Bergmann for code review and suggestions.
 *  More changes for Thomas Gleixner suggestions.
 *
 */

11
#include <linux/cred.h>
12 13
#include <linux/file.h>
#include <linux/poll.h>
14
#include <linux/sched.h>
15 16 17 18 19 20 21 22 23 24 25 26 27 28
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/mount.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/magic.h>
#include <linux/anon_inodes.h>

#include <asm/uaccess.h>

static struct vfsmount *anon_inode_mnt __read_mostly;
static struct inode *anon_inode_inode;
static const struct file_operations anon_inode_fops;

Al Viro's avatar
Al Viro committed
29 30
static struct dentry *anon_inodefs_mount(struct file_system_type *fs_type,
				int flags, const char *dev_name, void *data)
31
{
Al Viro's avatar
Al Viro committed
32
	return mount_pseudo(fs_type, "anon_inode:", NULL, ANON_INODE_FS_MAGIC);
33 34
}

Nick Piggin's avatar
Nick Piggin committed
35 36 37 38 39 40 41 42 43
/*
 * anon_inodefs_dname() is called from d_path().
 */
static char *anon_inodefs_dname(struct dentry *dentry, char *buffer, int buflen)
{
	return dynamic_dname(dentry, buffer, buflen, "anon_inode:%s",
				dentry->d_name.name);
}

44 45
static struct file_system_type anon_inode_fs_type = {
	.name		= "anon_inodefs",
Al Viro's avatar
Al Viro committed
46
	.mount		= anon_inodefs_mount,
47 48
	.kill_sb	= kill_anon_super,
};
Al Viro's avatar
Al Viro committed
49
static const struct dentry_operations anon_inodefs_dentry_operations = {
Nick Piggin's avatar
Nick Piggin committed
50
	.d_dname	= anon_inodefs_dname,
51 52
};

53 54 55 56 57 58 59 60 61 62 63 64 65
/*
 * nop .set_page_dirty method so that people can use .page_mkwrite on
 * anon inodes.
 */
static int anon_set_page_dirty(struct page *page)
{
	return 0;
};

static const struct address_space_operations anon_aops = {
	.set_page_dirty = anon_set_page_dirty,
};

66
/**
67 68 69
 * anon_inode_getfile - creates a new file instance by hooking it up to an
 *                      anonymous inode, and a dentry that describe the "class"
 *                      of the file
70 71
 *
 * @name:    [in]    name of the "class" of the new file
72 73 74
 * @fops:    [in]    file operations for the new file
 * @priv:    [in]    private data for the new file (will be file's private_data)
 * @flags:   [in]    flags
75 76 77
 *
 * Creates a new file by hooking it on a single inode. This is useful for files
 * that do not need to have a full-fledged inode in order to operate correctly.
78
 * All the files created with anon_inode_getfile() will share a single inode,
79
 * hence saving memory and avoiding code duplication for the file/inode/dentry
80
 * setup.  Returns the newly created file* or an error pointer.
81
 */
82 83 84
struct file *anon_inode_getfile(const char *name,
				const struct file_operations *fops,
				void *priv, int flags)
85 86
{
	struct qstr this;
87
	struct path path;
88
	struct file *file;
89
	int error;
90 91

	if (IS_ERR(anon_inode_inode))
92
		return ERR_PTR(-ENODEV);
93

94
	if (fops->owner && !try_module_get(fops->owner))
95
		return ERR_PTR(-ENOENT);
96 97 98 99 100 101 102 103 104

	/*
	 * Link the inode to a directory entry by creating a unique name
	 * using the inode sequence number.
	 */
	error = -ENOMEM;
	this.name = name;
	this.len = strlen(name);
	this.hash = 0;
105 106
	path.dentry = d_alloc(anon_inode_mnt->mnt_sb->s_root, &this);
	if (!path.dentry)
107
		goto err_module;
108

109
	path.mnt = mntget(anon_inode_mnt);
110 111
	/*
	 * We know the anon_inode inode count is always greater than zero,
Al Viro's avatar
Al Viro committed
112
	 * so ihold() is safe.
113
	 */
Al Viro's avatar
Al Viro committed
114
	ihold(anon_inode_inode);
115

116 117
	path.dentry->d_op = &anon_inodefs_dentry_operations;
	d_instantiate(path.dentry, anon_inode_inode);
118

119
	error = -ENFILE;
Al Viro's avatar
Al Viro committed
120
	file = alloc_file(&path, OPEN_FMODE(flags), fops);
121 122
	if (!file)
		goto err_dput;
123
	file->f_mapping = anon_inode_inode->i_mapping;
124 125

	file->f_pos = 0;
126
	file->f_flags = flags & (O_ACCMODE | O_NONBLOCK);
127 128 129
	file->f_version = 0;
	file->private_data = priv;

130 131 132
	return file;

err_dput:
133
	path_put(&path);
134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171
err_module:
	module_put(fops->owner);
	return ERR_PTR(error);
}
EXPORT_SYMBOL_GPL(anon_inode_getfile);

/**
 * anon_inode_getfd - creates a new file instance by hooking it up to an
 *                    anonymous inode, and a dentry that describe the "class"
 *                    of the file
 *
 * @name:    [in]    name of the "class" of the new file
 * @fops:    [in]    file operations for the new file
 * @priv:    [in]    private data for the new file (will be file's private_data)
 * @flags:   [in]    flags
 *
 * Creates a new file by hooking it on a single inode. This is useful for files
 * that do not need to have a full-fledged inode in order to operate correctly.
 * All the files created with anon_inode_getfd() will share a single inode,
 * hence saving memory and avoiding code duplication for the file/inode/dentry
 * setup.  Returns new descriptor or an error code.
 */
int anon_inode_getfd(const char *name, const struct file_operations *fops,
		     void *priv, int flags)
{
	int error, fd;
	struct file *file;

	error = get_unused_fd_flags(flags);
	if (error < 0)
		return error;
	fd = error;

	file = anon_inode_getfile(name, fops, priv, flags);
	if (IS_ERR(file)) {
		error = PTR_ERR(file);
		goto err_put_unused_fd;
	}
172 173
	fd_install(fd, file);

Al Viro's avatar
Al Viro committed
174
	return fd;
175 176 177 178 179

err_put_unused_fd:
	put_unused_fd(fd);
	return error;
}
180
EXPORT_SYMBOL_GPL(anon_inode_getfd);
181 182

/*
183 184 185
 * A single inode exists for all anon_inode files. Contrary to pipes,
 * anon_inode inodes have no associated per-instance data, so we need
 * only allocate one of them.
186 187 188 189 190 191 192 193
 */
static struct inode *anon_inode_mkinode(void)
{
	struct inode *inode = new_inode(anon_inode_mnt->mnt_sb);

	if (!inode)
		return ERR_PTR(-ENOMEM);

194
	inode->i_ino = get_next_ino();
195 196
	inode->i_fop = &anon_inode_fops;

197 198
	inode->i_mapping->a_ops = &anon_aops;

199 200 201 202 203 204 205
	/*
	 * Mark the inode dirty from the very beginning,
	 * that way it will never be moved to the dirty
	 * list because mark_inode_dirty() will think
	 * that it already _is_ on the dirty list.
	 */
	inode->i_state = I_DIRTY;
206
	inode->i_mode = S_IRUSR | S_IWUSR;
207 208
	inode->i_uid = current_fsuid();
	inode->i_gid = current_fsgid();
209
	inode->i_flags |= S_PRIVATE;
210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243
	inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
	return inode;
}

static int __init anon_inode_init(void)
{
	int error;

	error = register_filesystem(&anon_inode_fs_type);
	if (error)
		goto err_exit;
	anon_inode_mnt = kern_mount(&anon_inode_fs_type);
	if (IS_ERR(anon_inode_mnt)) {
		error = PTR_ERR(anon_inode_mnt);
		goto err_unregister_filesystem;
	}
	anon_inode_inode = anon_inode_mkinode();
	if (IS_ERR(anon_inode_inode)) {
		error = PTR_ERR(anon_inode_inode);
		goto err_mntput;
	}

	return 0;

err_mntput:
	mntput(anon_inode_mnt);
err_unregister_filesystem:
	unregister_filesystem(&anon_inode_fs_type);
err_exit:
	panic(KERN_ERR "anon_inode_init() failed (%d)\n", error);
}

fs_initcall(anon_inode_init);