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 135 if (IS_ERR(anon_inode_inode)) 136 return ERR_PTR(-ENODEV); 137 138 if (fops->owner && !try_module_get(fops->owner)) 139 return ERR_PTR(-ENOENT); 140 141 /* 142 * Link the inode to a directory entry by creating a unique name 143 * using the inode sequence number. 144 */ 145 file = ERR_PTR(-ENOMEM); 146 this.name = name; 147 this.len = strlen(name); 148 this.hash = 0; 149 path.dentry = d_alloc_pseudo(anon_inode_mnt->mnt_sb, &this); 150 if (!path.dentry) 151 goto err_module; 152 153 path.mnt = mntget(anon_inode_mnt); 154 /* 155 * We know the anon_inode inode count is always greater than zero, 156 * so ihold() is safe. 157 */ 158 ihold(anon_inode_inode); 159 160 d_instantiate(path.dentry, anon_inode_inode); 161 162 file = alloc_file(&path, OPEN_FMODE(flags), fops); 163 if (IS_ERR(file)) 164 goto err_dput; 165 file->f_mapping = anon_inode_inode->i_mapping; 166 167 file->f_flags = flags & (O_ACCMODE | O_NONBLOCK); 168 file->private_data = priv; 169 170 return file; 171 172 err_dput: 173 path_put(&path); 174 err_module: 175 module_put(fops->owner); 176 return file; 177 } 178 EXPORT_SYMBOL_GPL(anon_inode_getfile); 179 180 /** 181 * anon_inode_getfd - creates a new file instance by hooking it up to an 182 * anonymous inode, and a dentry that describe the "class" 183 * of the file 184 * 185 * @name: [in] name of the "class" of the new file 186 * @fops: [in] file operations for the new file 187 * @priv: [in] private data for the new file (will be file's private_data) 188 * @flags: [in] flags 189 * 190 * Creates a new file by hooking it on a single inode. This is useful for files 191 * that do not need to have a full-fledged inode in order to operate correctly. 192 * All the files created with anon_inode_getfd() will share a single inode, 193 * hence saving memory and avoiding code duplication for the file/inode/dentry 194 * setup. Returns new descriptor or an error code. 195 */ 196 int anon_inode_getfd(const char *name, const struct file_operations *fops, 197 void *priv, int flags) 198 { 199 int error, fd; 200 struct file *file; 201 202 error = get_unused_fd_flags(flags); 203 if (error < 0) 204 return error; 205 fd = error; 206 207 file = anon_inode_getfile(name, fops, priv, flags); 208 if (IS_ERR(file)) { 209 error = PTR_ERR(file); 210 goto err_put_unused_fd; 211 } 212 fd_install(fd, file); 213 214 return fd; 215 216 err_put_unused_fd: 217 put_unused_fd(fd); 218 return error; 219 } 220 EXPORT_SYMBOL_GPL(anon_inode_getfd); 221 222 static int __init anon_inode_init(void) 223 { 224 int error; 225 226 error = register_filesystem(&anon_inode_fs_type); 227 if (error) 228 goto err_exit; 229 anon_inode_mnt = kern_mount(&anon_inode_fs_type); 230 if (IS_ERR(anon_inode_mnt)) { 231 error = PTR_ERR(anon_inode_mnt); 232 goto err_unregister_filesystem; 233 } 234 return 0; 235 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