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 static struct dentry *anon_inodefs_mount(struct file_system_type *fs_type, 43 int flags, const char *dev_name, void *data) 44 { 45 return mount_pseudo(fs_type, "anon_inode:", NULL, 46 &anon_inodefs_dentry_operations, ANON_INODE_FS_MAGIC); 47 } 48 49 static struct file_system_type anon_inode_fs_type = { 50 .name = "anon_inodefs", 51 .mount = anon_inodefs_mount, 52 .kill_sb = kill_anon_super, 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_getfile - 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_pseudo(anon_inode_mnt->mnt_sb, &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 ihold() is safe. 115 */ 116 ihold(anon_inode_inode); 117 118 d_instantiate(path.dentry, anon_inode_inode); 119 120 error = -ENFILE; 121 file = alloc_file(&path, OPEN_FMODE(flags), fops); 122 if (!file) 123 goto err_dput; 124 file->f_mapping = anon_inode_inode->i_mapping; 125 126 file->f_pos = 0; 127 file->f_flags = flags & (O_ACCMODE | O_NONBLOCK); 128 file->f_version = 0; 129 file->private_data = priv; 130 131 return file; 132 133 err_dput: 134 path_put(&path); 135 err_module: 136 module_put(fops->owner); 137 return ERR_PTR(error); 138 } 139 EXPORT_SYMBOL_GPL(anon_inode_getfile); 140 141 /** 142 * anon_inode_getfd - creates a new file instance by hooking it up to an 143 * anonymous inode, and a dentry that describe the "class" 144 * of the file 145 * 146 * @name: [in] name of the "class" of the new file 147 * @fops: [in] file operations for the new file 148 * @priv: [in] private data for the new file (will be file's private_data) 149 * @flags: [in] flags 150 * 151 * Creates a new file by hooking it on a single inode. This is useful for files 152 * that do not need to have a full-fledged inode in order to operate correctly. 153 * All the files created with anon_inode_getfd() will share a single inode, 154 * hence saving memory and avoiding code duplication for the file/inode/dentry 155 * setup. Returns new descriptor or an error code. 156 */ 157 int anon_inode_getfd(const char *name, const struct file_operations *fops, 158 void *priv, int flags) 159 { 160 int error, fd; 161 struct file *file; 162 163 error = get_unused_fd_flags(flags); 164 if (error < 0) 165 return error; 166 fd = error; 167 168 file = anon_inode_getfile(name, fops, priv, flags); 169 if (IS_ERR(file)) { 170 error = PTR_ERR(file); 171 goto err_put_unused_fd; 172 } 173 fd_install(fd, file); 174 175 return fd; 176 177 err_put_unused_fd: 178 put_unused_fd(fd); 179 return error; 180 } 181 EXPORT_SYMBOL_GPL(anon_inode_getfd); 182 183 /* 184 * A single inode exists for all anon_inode files. Contrary to pipes, 185 * anon_inode inodes have no associated per-instance data, so we need 186 * only allocate one of them. 187 */ 188 static struct inode *anon_inode_mkinode(void) 189 { 190 struct inode *inode = new_inode(anon_inode_mnt->mnt_sb); 191 192 if (!inode) 193 return ERR_PTR(-ENOMEM); 194 195 inode->i_ino = get_next_ino(); 196 inode->i_fop = &anon_inode_fops; 197 198 inode->i_mapping->a_ops = &anon_aops; 199 200 /* 201 * Mark the inode dirty from the very beginning, 202 * that way it will never be moved to the dirty 203 * list because mark_inode_dirty() will think 204 * that it already _is_ on the dirty list. 205 */ 206 inode->i_state = I_DIRTY; 207 inode->i_mode = S_IRUSR | S_IWUSR; 208 inode->i_uid = current_fsuid(); 209 inode->i_gid = current_fsgid(); 210 inode->i_flags |= S_PRIVATE; 211 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME; 212 return inode; 213 } 214 215 static int __init anon_inode_init(void) 216 { 217 int error; 218 219 error = register_filesystem(&anon_inode_fs_type); 220 if (error) 221 goto err_exit; 222 anon_inode_mnt = kern_mount(&anon_inode_fs_type); 223 if (IS_ERR(anon_inode_mnt)) { 224 error = PTR_ERR(anon_inode_mnt); 225 goto err_unregister_filesystem; 226 } 227 anon_inode_inode = anon_inode_mkinode(); 228 if (IS_ERR(anon_inode_inode)) { 229 error = PTR_ERR(anon_inode_inode); 230 goto err_mntput; 231 } 232 233 return 0; 234 235 err_mntput: 236 mntput(anon_inode_mnt); 237 err_unregister_filesystem: 238 unregister_filesystem(&anon_inode_fs_type); 239 err_exit: 240 panic(KERN_ERR "anon_inode_init() failed (%d)\n", error); 241 } 242 243 fs_initcall(anon_inode_init); 244 245