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 <linux/uaccess.h> 24 25 static struct vfsmount *anon_inode_mnt __read_mostly; 26 static struct inode *anon_inode_inode; 27 28 /* 29 * anon_inodefs_dname() is called from d_path(). 30 */ 31 static char *anon_inodefs_dname(struct dentry *dentry, char *buffer, int buflen) 32 { 33 return dynamic_dname(dentry, buffer, buflen, "anon_inode:%s", 34 dentry->d_name.name); 35 } 36 37 static const struct dentry_operations anon_inodefs_dentry_operations = { 38 .d_dname = anon_inodefs_dname, 39 }; 40 41 static struct dentry *anon_inodefs_mount(struct file_system_type *fs_type, 42 int flags, const char *dev_name, void *data) 43 { 44 return mount_pseudo(fs_type, "anon_inode:", NULL, 45 &anon_inodefs_dentry_operations, ANON_INODE_FS_MAGIC); 46 } 47 48 static struct file_system_type anon_inode_fs_type = { 49 .name = "anon_inodefs", 50 .mount = anon_inodefs_mount, 51 .kill_sb = kill_anon_super, 52 }; 53 54 /** 55 * anon_inode_getfile - creates a new file instance by hooking it up to an 56 * anonymous inode, and a dentry that describe the "class" 57 * of the file 58 * 59 * @name: [in] name of the "class" of the new file 60 * @fops: [in] file operations for the new file 61 * @priv: [in] private data for the new file (will be file's private_data) 62 * @flags: [in] flags 63 * 64 * Creates a new file by hooking it on a single inode. This is useful for files 65 * that do not need to have a full-fledged inode in order to operate correctly. 66 * All the files created with anon_inode_getfile() will share a single inode, 67 * hence saving memory and avoiding code duplication for the file/inode/dentry 68 * setup. Returns the newly created file* or an error pointer. 69 */ 70 struct file *anon_inode_getfile(const char *name, 71 const struct file_operations *fops, 72 void *priv, int flags) 73 { 74 struct file *file; 75 76 if (IS_ERR(anon_inode_inode)) 77 return ERR_PTR(-ENODEV); 78 79 if (fops->owner && !try_module_get(fops->owner)) 80 return ERR_PTR(-ENOENT); 81 82 /* 83 * We know the anon_inode inode count is always greater than zero, 84 * so ihold() is safe. 85 */ 86 ihold(anon_inode_inode); 87 file = alloc_file_pseudo(anon_inode_inode, anon_inode_mnt, name, 88 flags & (O_ACCMODE | O_NONBLOCK), fops); 89 if (IS_ERR(file)) 90 goto err; 91 92 file->f_mapping = anon_inode_inode->i_mapping; 93 94 file->private_data = priv; 95 96 return file; 97 98 err: 99 iput(anon_inode_inode); 100 module_put(fops->owner); 101 return file; 102 } 103 EXPORT_SYMBOL_GPL(anon_inode_getfile); 104 105 /** 106 * anon_inode_getfd - creates a new file instance by hooking it up to an 107 * anonymous inode, and a dentry that describe the "class" 108 * of the file 109 * 110 * @name: [in] name of the "class" of the new file 111 * @fops: [in] file operations for the new file 112 * @priv: [in] private data for the new file (will be file's private_data) 113 * @flags: [in] flags 114 * 115 * Creates a new file by hooking it on a single inode. This is useful for files 116 * that do not need to have a full-fledged inode in order to operate correctly. 117 * All the files created with anon_inode_getfd() will share a single inode, 118 * hence saving memory and avoiding code duplication for the file/inode/dentry 119 * setup. Returns new descriptor or an error code. 120 */ 121 int anon_inode_getfd(const char *name, const struct file_operations *fops, 122 void *priv, int flags) 123 { 124 int error, fd; 125 struct file *file; 126 127 error = get_unused_fd_flags(flags); 128 if (error < 0) 129 return error; 130 fd = error; 131 132 file = anon_inode_getfile(name, fops, priv, flags); 133 if (IS_ERR(file)) { 134 error = PTR_ERR(file); 135 goto err_put_unused_fd; 136 } 137 fd_install(fd, file); 138 139 return fd; 140 141 err_put_unused_fd: 142 put_unused_fd(fd); 143 return error; 144 } 145 EXPORT_SYMBOL_GPL(anon_inode_getfd); 146 147 static int __init anon_inode_init(void) 148 { 149 anon_inode_mnt = kern_mount(&anon_inode_fs_type); 150 if (IS_ERR(anon_inode_mnt)) 151 panic("anon_inode_init() kernel mount failed (%ld)\n", PTR_ERR(anon_inode_mnt)); 152 153 anon_inode_inode = alloc_anon_inode(anon_inode_mnt->mnt_sb); 154 if (IS_ERR(anon_inode_inode)) 155 panic("anon_inode_init() inode allocation failed (%ld)\n", PTR_ERR(anon_inode_inode)); 156 157 return 0; 158 } 159 160 fs_initcall(anon_inode_init); 161 162