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 static struct dentry *anon_inodefs_mount(struct file_system_type *fs_type, 30 int flags, const char *dev_name, void *data) 31 { 32 return mount_pseudo(fs_type, "anon_inode:", NULL, ANON_INODE_FS_MAGIC); 33 } 34 35 /* 36 * anon_inodefs_dname() is called from d_path(). 37 */ 38 static 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 44 static struct file_system_type anon_inode_fs_type = { 45 .name = "anon_inodefs", 46 .mount = anon_inodefs_mount, 47 .kill_sb = kill_anon_super, 48 }; 49 static const struct dentry_operations anon_inodefs_dentry_operations = { 50 .d_dname = anon_inodefs_dname, 51 }; 52 53 /* 54 * nop .set_page_dirty method so that people can use .page_mkwrite on 55 * anon inodes. 56 */ 57 static int anon_set_page_dirty(struct page *page) 58 { 59 return 0; 60 }; 61 62 static const struct address_space_operations anon_aops = { 63 .set_page_dirty = anon_set_page_dirty, 64 }; 65 66 /** 67 * anon_inode_getfd - creates a new file instance by hooking it up to an 68 * anonymous inode, and a dentry that describe the "class" 69 * of the file 70 * 71 * @name: [in] name of the "class" of the new file 72 * @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 75 * 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. 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 struct file *anon_inode_getfile(const char *name, 83 const struct file_operations *fops, 84 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 * 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; 105 path.dentry = d_alloc_pseudo(anon_inode_mnt->mnt_sb, &this); 106 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, 112 * so ihold() is safe. 113 */ 114 ihold(anon_inode_inode); 115 116 d_set_d_op(path.dentry, &anon_inodefs_dentry_operations); 117 d_instantiate(path.dentry, anon_inode_inode); 118 119 error = -ENFILE; 120 file = alloc_file(&path, OPEN_FMODE(flags), fops); 121 if (!file) 122 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 file->f_version = 0; 128 file->private_data = priv; 129 130 return file; 131 132 err_dput: 133 path_put(&path); 134 err_module: 135 module_put(fops->owner); 136 return ERR_PTR(error); 137 } 138 EXPORT_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 */ 156 int 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 } 172 fd_install(fd, file); 173 174 return fd; 175 176 err_put_unused_fd: 177 put_unused_fd(fd); 178 return error; 179 } 180 EXPORT_SYMBOL_GPL(anon_inode_getfd); 181 182 /* 183 * 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. 186 */ 187 static 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 194 inode->i_ino = get_next_ino(); 195 inode->i_fop = &anon_inode_fops; 196 197 inode->i_mapping->a_ops = &anon_aops; 198 199 /* 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; 206 inode->i_mode = S_IRUSR | S_IWUSR; 207 inode->i_uid = current_fsuid(); 208 inode->i_gid = current_fsgid(); 209 inode->i_flags |= S_PRIVATE; 210 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME; 211 return inode; 212 } 213 214 static 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 234 err_mntput: 235 mntput_long(anon_inode_mnt); 236 err_unregister_filesystem: 237 unregister_filesystem(&anon_inode_fs_type); 238 err_exit: 239 panic(KERN_ERR "anon_inode_init() failed (%d)\n", error); 240 } 241 242 fs_initcall(anon_inode_init); 243 244