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