1 /* 2 * linux/fs/filesystems.c 3 * 4 * Copyright (C) 1991, 1992 Linus Torvalds 5 * 6 * table of configured filesystems 7 */ 8 9 #include <linux/syscalls.h> 10 #include <linux/fs.h> 11 #include <linux/proc_fs.h> 12 #include <linux/seq_file.h> 13 #include <linux/kmod.h> 14 #include <linux/init.h> 15 #include <linux/module.h> 16 #include <linux/slab.h> 17 #include <linux/uaccess.h> 18 19 /* 20 * Handling of filesystem drivers list. 21 * Rules: 22 * Inclusion to/removals from/scanning of list are protected by spinlock. 23 * During the unload module must call unregister_filesystem(). 24 * We can access the fields of list element if: 25 * 1) spinlock is held or 26 * 2) we hold the reference to the module. 27 * The latter can be guaranteed by call of try_module_get(); if it 28 * returned 0 we must skip the element, otherwise we got the reference. 29 * Once the reference is obtained we can drop the spinlock. 30 */ 31 32 static struct file_system_type *file_systems; 33 static DEFINE_RWLOCK(file_systems_lock); 34 35 /* WARNING: This can be used only if we _already_ own a reference */ 36 struct file_system_type *get_filesystem(struct file_system_type *fs) 37 { 38 __module_get(fs->owner); 39 return fs; 40 } 41 42 void put_filesystem(struct file_system_type *fs) 43 { 44 module_put(fs->owner); 45 } 46 47 static struct file_system_type **find_filesystem(const char *name, unsigned len) 48 { 49 struct file_system_type **p; 50 for (p = &file_systems; *p; p = &(*p)->next) 51 if (strncmp((*p)->name, name, len) == 0 && 52 !(*p)->name[len]) 53 break; 54 return p; 55 } 56 57 /** 58 * register_filesystem - register a new filesystem 59 * @fs: the file system structure 60 * 61 * Adds the file system passed to the list of file systems the kernel 62 * is aware of for mount and other syscalls. Returns 0 on success, 63 * or a negative errno code on an error. 64 * 65 * The &struct file_system_type that is passed is linked into the kernel 66 * structures and must not be freed until the file system has been 67 * unregistered. 68 */ 69 70 int register_filesystem(struct file_system_type * fs) 71 { 72 int res = 0; 73 struct file_system_type ** p; 74 75 BUG_ON(strchr(fs->name, '.')); 76 if (fs->next) 77 return -EBUSY; 78 write_lock(&file_systems_lock); 79 p = find_filesystem(fs->name, strlen(fs->name)); 80 if (*p) 81 res = -EBUSY; 82 else 83 *p = fs; 84 write_unlock(&file_systems_lock); 85 return res; 86 } 87 88 EXPORT_SYMBOL(register_filesystem); 89 90 /** 91 * unregister_filesystem - unregister a file system 92 * @fs: filesystem to unregister 93 * 94 * Remove a file system that was previously successfully registered 95 * with the kernel. An error is returned if the file system is not found. 96 * Zero is returned on a success. 97 * 98 * Once this function has returned the &struct file_system_type structure 99 * may be freed or reused. 100 */ 101 102 int unregister_filesystem(struct file_system_type * fs) 103 { 104 struct file_system_type ** tmp; 105 106 write_lock(&file_systems_lock); 107 tmp = &file_systems; 108 while (*tmp) { 109 if (fs == *tmp) { 110 *tmp = fs->next; 111 fs->next = NULL; 112 write_unlock(&file_systems_lock); 113 synchronize_rcu(); 114 return 0; 115 } 116 tmp = &(*tmp)->next; 117 } 118 write_unlock(&file_systems_lock); 119 120 return -EINVAL; 121 } 122 123 EXPORT_SYMBOL(unregister_filesystem); 124 125 #ifdef CONFIG_SYSFS_SYSCALL 126 static int fs_index(const char __user * __name) 127 { 128 struct file_system_type * tmp; 129 struct filename *name; 130 int err, index; 131 132 name = getname(__name); 133 err = PTR_ERR(name); 134 if (IS_ERR(name)) 135 return err; 136 137 err = -EINVAL; 138 read_lock(&file_systems_lock); 139 for (tmp=file_systems, index=0 ; tmp ; tmp=tmp->next, index++) { 140 if (strcmp(tmp->name, name->name) == 0) { 141 err = index; 142 break; 143 } 144 } 145 read_unlock(&file_systems_lock); 146 putname(name); 147 return err; 148 } 149 150 static int fs_name(unsigned int index, char __user * buf) 151 { 152 struct file_system_type * tmp; 153 int len, res; 154 155 read_lock(&file_systems_lock); 156 for (tmp = file_systems; tmp; tmp = tmp->next, index--) 157 if (index <= 0 && try_module_get(tmp->owner)) 158 break; 159 read_unlock(&file_systems_lock); 160 if (!tmp) 161 return -EINVAL; 162 163 /* OK, we got the reference, so we can safely block */ 164 len = strlen(tmp->name) + 1; 165 res = copy_to_user(buf, tmp->name, len) ? -EFAULT : 0; 166 put_filesystem(tmp); 167 return res; 168 } 169 170 static int fs_maxindex(void) 171 { 172 struct file_system_type * tmp; 173 int index; 174 175 read_lock(&file_systems_lock); 176 for (tmp = file_systems, index = 0 ; tmp ; tmp = tmp->next, index++) 177 ; 178 read_unlock(&file_systems_lock); 179 return index; 180 } 181 182 /* 183 * Whee.. Weird sysv syscall. 184 */ 185 SYSCALL_DEFINE3(sysfs, int, option, unsigned long, arg1, unsigned long, arg2) 186 { 187 int retval = -EINVAL; 188 189 switch (option) { 190 case 1: 191 retval = fs_index((const char __user *) arg1); 192 break; 193 194 case 2: 195 retval = fs_name(arg1, (char __user *) arg2); 196 break; 197 198 case 3: 199 retval = fs_maxindex(); 200 break; 201 } 202 return retval; 203 } 204 #endif 205 206 int __init get_filesystem_list(char *buf) 207 { 208 int len = 0; 209 struct file_system_type * tmp; 210 211 read_lock(&file_systems_lock); 212 tmp = file_systems; 213 while (tmp && len < PAGE_SIZE - 80) { 214 len += sprintf(buf+len, "%s\t%s\n", 215 (tmp->fs_flags & FS_REQUIRES_DEV) ? "" : "nodev", 216 tmp->name); 217 tmp = tmp->next; 218 } 219 read_unlock(&file_systems_lock); 220 return len; 221 } 222 223 #ifdef CONFIG_PROC_FS 224 static int filesystems_proc_show(struct seq_file *m, void *v) 225 { 226 struct file_system_type * tmp; 227 228 read_lock(&file_systems_lock); 229 tmp = file_systems; 230 while (tmp) { 231 seq_printf(m, "%s\t%s\n", 232 (tmp->fs_flags & FS_REQUIRES_DEV) ? "" : "nodev", 233 tmp->name); 234 tmp = tmp->next; 235 } 236 read_unlock(&file_systems_lock); 237 return 0; 238 } 239 240 static int filesystems_proc_open(struct inode *inode, struct file *file) 241 { 242 return single_open(file, filesystems_proc_show, NULL); 243 } 244 245 static const struct file_operations filesystems_proc_fops = { 246 .open = filesystems_proc_open, 247 .read = seq_read, 248 .llseek = seq_lseek, 249 .release = single_release, 250 }; 251 252 static int __init proc_filesystems_init(void) 253 { 254 proc_create("filesystems", 0, NULL, &filesystems_proc_fops); 255 return 0; 256 } 257 module_init(proc_filesystems_init); 258 #endif 259 260 static struct file_system_type *__get_fs_type(const char *name, int len) 261 { 262 struct file_system_type *fs; 263 264 read_lock(&file_systems_lock); 265 fs = *(find_filesystem(name, len)); 266 if (fs && !try_module_get(fs->owner)) 267 fs = NULL; 268 read_unlock(&file_systems_lock); 269 return fs; 270 } 271 272 struct file_system_type *get_fs_type(const char *name) 273 { 274 struct file_system_type *fs; 275 const char *dot = strchr(name, '.'); 276 int len = dot ? dot - name : strlen(name); 277 278 fs = __get_fs_type(name, len); 279 if (!fs && (request_module("fs-%.*s", len, name) == 0)) { 280 fs = __get_fs_type(name, len); 281 WARN_ONCE(!fs, "request_module fs-%.*s succeeded, but still no fs?\n", len, name); 282 } 283 284 if (dot && fs && !(fs->fs_flags & FS_HAS_SUBTYPE)) { 285 put_filesystem(fs); 286 fs = NULL; 287 } 288 return fs; 289 } 290 291 EXPORT_SYMBOL(get_fs_type); 292