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/cred.h> 12 #include <linux/file.h> 13 #include <linux/poll.h> 14 #include <linux/sched.h> 15 #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 25 static struct vfsmount *anon_inode_mnt __read_mostly; 26 static struct inode *anon_inode_inode; 27 static const struct file_operations anon_inode_fops; 28 29 /* 30 * anon_inodefs_dname() is called from d_path(). 31 */ 32 static char *anon_inodefs_dname(struct dentry *dentry, char *buffer, int buflen) 33 { 34 return dynamic_dname(dentry, buffer, buflen, "anon_inode:%s", 35 dentry->d_name.name); 36 } 37 38 static const struct dentry_operations anon_inodefs_dentry_operations = { 39 .d_dname = anon_inodefs_dname, 40 }; 41 42 /* 43 * nop .set_page_dirty method so that people can use .page_mkwrite on 44 * anon inodes. 45 */ 46 static int anon_set_page_dirty(struct page *page) 47 { 48 return 0; 49 }; 50 51 static const struct address_space_operations anon_aops = { 52 .set_page_dirty = anon_set_page_dirty, 53 }; 54 55 /* 56 * A single inode exists for all anon_inode files. Contrary to pipes, 57 * anon_inode inodes have no associated per-instance data, so we need 58 * only allocate one of them. 59 */ 60 static struct inode *anon_inode_mkinode(struct super_block *s) 61 { 62 struct inode *inode = new_inode_pseudo(s); 63 64 if (!inode) 65 return ERR_PTR(-ENOMEM); 66 67 inode->i_ino = get_next_ino(); 68 inode->i_fop = &anon_inode_fops; 69 70 inode->i_mapping->a_ops = &anon_aops; 71 72 /* 73 * Mark the inode dirty from the very beginning, 74 * that way it will never be moved to the dirty 75 * list because mark_inode_dirty() will think 76 * that it already _is_ on the dirty list. 77 */ 78 inode->i_state = I_DIRTY; 79 inode->i_mode = S_IRUSR | S_IWUSR; 80 inode->i_uid = current_fsuid(); 81 inode->i_gid = current_fsgid(); 82 inode->i_flags |= S_PRIVATE; 83 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME; 84 return inode; 85 } 86 87 static struct dentry *anon_inodefs_mount(struct file_system_type *fs_type, 88 int flags, const char *dev_name, void *data) 89 { 90 struct dentry *root; 91 root = mount_pseudo(fs_type, "anon_inode:", NULL, 92 &anon_inodefs_dentry_operations, ANON_INODE_FS_MAGIC); 93 if (!IS_ERR(root)) { 94 struct super_block *s = root->d_sb; 95 anon_inode_inode = anon_inode_mkinode(s); 96 if (IS_ERR(anon_inode_inode)) { 97 dput(root); 98 deactivate_locked_super(s); 99 root = ERR_CAST(anon_inode_inode); 100 } 101 } 102 return root; 103 } 104 105 static struct file_system_type anon_inode_fs_type = { 106 .name = "anon_inodefs", 107 .mount = anon_inodefs_mount, 108 .kill_sb = kill_anon_super, 109 }; 110 111 /** 112 * anon_inode_getfile - creates a new file instance by hooking it up to an 113 * anonymous inode, and a dentry that describe the "class" 114 * of the file 115 * 116 * @name: [in] name of the "class" of the new file 117 * @fops: [in] file operations for the new file 118 * @priv: [in] private data for the new file (will be file's private_data) 119 * @flags: [in] flags 120 * 121 * Creates a new file by hooking it on a single inode. This is useful for files 122 * that do not need to have a full-fledged inode in order to operate correctly. 123 * All the files created with anon_inode_getfile() will share a single inode, 124 * hence saving memory and avoiding code duplication for the file/inode/dentry 125 * setup. Returns the newly created file* or an error pointer. 126 */ 127 struct file *anon_inode_getfile(const char *name, 128 const struct file_operations *fops, 129 void *priv, int flags) 130 { 131 struct qstr this; 132 struct path path; 133 struct file *file; 134 int error; 135 136 if (IS_ERR(anon_inode_inode)) 137 return ERR_PTR(-ENODEV); 138 139 if (fops->owner && !try_module_get(fops->owner)) 140 return ERR_PTR(-ENOENT); 141 142 /* 143 * Link the inode to a directory entry by creating a unique name 144 * using the inode sequence number. 145 */ 146 error = -ENOMEM; 147 this.name = name; 148 this.len = strlen(name); 149 this.hash = 0; 150 path.dentry = d_alloc_pseudo(anon_inode_mnt->mnt_sb, &this); 151 if (!path.dentry) 152 goto err_module; 153 154 path.mnt = mntget(anon_inode_mnt); 155 /* 156 * We know the anon_inode inode count is always greater than zero, 157 * so ihold() is safe. 158 */ 159 ihold(anon_inode_inode); 160 161 d_instantiate(path.dentry, anon_inode_inode); 162 163 error = -ENFILE; 164 file = alloc_file(&path, OPEN_FMODE(flags), fops); 165 if (!file) 166 goto err_dput; 167 file->f_mapping = anon_inode_inode->i_mapping; 168 169 file->f_pos = 0; 170 file->f_flags = flags & (O_ACCMODE | O_NONBLOCK); 171 file->f_version = 0; 172 file->private_data = priv; 173 174 return file; 175 176 err_dput: 177 path_put(&path); 178 err_module: 179 module_put(fops->owner); 180 return ERR_PTR(error); 181 } 182 EXPORT_SYMBOL_GPL(anon_inode_getfile); 183 184 /** 185 * anon_inode_getfd - creates a new file instance by hooking it up to an 186 * anonymous inode, and a dentry that describe the "class" 187 * of the file 188 * 189 * @name: [in] name of the "class" of the new file 190 * @fops: [in] file operations for the new file 191 * @priv: [in] private data for the new file (will be file's private_data) 192 * @flags: [in] flags 193 * 194 * Creates a new file by hooking it on a single inode. This is useful for files 195 * that do not need to have a full-fledged inode in order to operate correctly. 196 * All the files created with anon_inode_getfd() will share a single inode, 197 * hence saving memory and avoiding code duplication for the file/inode/dentry 198 * setup. Returns new descriptor or an error code. 199 */ 200 int anon_inode_getfd(const char *name, const struct file_operations *fops, 201 void *priv, int flags) 202 { 203 int error, fd; 204 struct file *file; 205 206 error = get_unused_fd_flags(flags); 207 if (error < 0) 208 return error; 209 fd = error; 210 211 file = anon_inode_getfile(name, fops, priv, flags); 212 if (IS_ERR(file)) { 213 error = PTR_ERR(file); 214 goto err_put_unused_fd; 215 } 216 fd_install(fd, file); 217 218 return fd; 219 220 err_put_unused_fd: 221 put_unused_fd(fd); 222 return error; 223 } 224 EXPORT_SYMBOL_GPL(anon_inode_getfd); 225 226 static int __init anon_inode_init(void) 227 { 228 int error; 229 230 error = register_filesystem(&anon_inode_fs_type); 231 if (error) 232 goto err_exit; 233 anon_inode_mnt = kern_mount(&anon_inode_fs_type); 234 if (IS_ERR(anon_inode_mnt)) { 235 error = PTR_ERR(anon_inode_mnt); 236 goto err_unregister_filesystem; 237 } 238 return 0; 239 240 err_unregister_filesystem: 241 unregister_filesystem(&anon_inode_fs_type); 242 err_exit: 243 panic(KERN_ERR "anon_inode_init() failed (%d)\n", error); 244 } 245 246 fs_initcall(anon_inode_init); 247 248