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