linux/fs/filesystems.c
<<
>>
Prefs
   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
  34static struct file_system_type *file_systems;
  35static DEFINE_RWLOCK(file_systems_lock);
  36
  37/* WARNING: This can be used only if we _already_ own a reference */
  38struct file_system_type *get_filesystem(struct file_system_type *fs)
  39{
  40        __module_get(fs->owner);
  41        return fs;
  42}
  43
  44void put_filesystem(struct file_system_type *fs)
  45{
  46        module_put(fs->owner);
  47}
  48
  49static 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 
  72int 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
  94EXPORT_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 
 108int 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
 129EXPORT_SYMBOL(unregister_filesystem);
 130
 131#ifdef CONFIG_SYSFS_SYSCALL
 132static int fs_index(const char __user * __name)
 133{
 134        struct file_system_type * tmp;
 135        struct filename *name;
 136        int err, index;
 137
 138        name = getname(__name);
 139        err = PTR_ERR(name);
 140        if (IS_ERR(name))
 141                return err;
 142
 143        err = -EINVAL;
 144        read_lock(&file_systems_lock);
 145        for (tmp=file_systems, index=0 ; tmp ; tmp=tmp->next, index++) {
 146                if (strcmp(tmp->name, name->name) == 0) {
 147                        err = index;
 148                        break;
 149                }
 150        }
 151        read_unlock(&file_systems_lock);
 152        putname(name);
 153        return err;
 154}
 155
 156static int fs_name(unsigned int index, char __user * buf)
 157{
 158        struct file_system_type * tmp;
 159        int len, res;
 160
 161        read_lock(&file_systems_lock);
 162        for (tmp = file_systems; tmp; tmp = tmp->next, index--)
 163                if (index <= 0 && try_module_get(tmp->owner))
 164                        break;
 165        read_unlock(&file_systems_lock);
 166        if (!tmp)
 167                return -EINVAL;
 168
 169        /* OK, we got the reference, so we can safely block */
 170        len = strlen(tmp->name) + 1;
 171        res = copy_to_user(buf, tmp->name, len) ? -EFAULT : 0;
 172        put_filesystem(tmp);
 173        return res;
 174}
 175
 176static int fs_maxindex(void)
 177{
 178        struct file_system_type * tmp;
 179        int index;
 180
 181        read_lock(&file_systems_lock);
 182        for (tmp = file_systems, index = 0 ; tmp ; tmp = tmp->next, index++)
 183                ;
 184        read_unlock(&file_systems_lock);
 185        return index;
 186}
 187
 188/*
 189 * Whee.. Weird sysv syscall. 
 190 */
 191SYSCALL_DEFINE3(sysfs, int, option, unsigned long, arg1, unsigned long, arg2)
 192{
 193        int retval = -EINVAL;
 194
 195        switch (option) {
 196                case 1:
 197                        retval = fs_index((const char __user *) arg1);
 198                        break;
 199
 200                case 2:
 201                        retval = fs_name(arg1, (char __user *) arg2);
 202                        break;
 203
 204                case 3:
 205                        retval = fs_maxindex();
 206                        break;
 207        }
 208        return retval;
 209}
 210#endif
 211
 212int __init get_filesystem_list(char *buf)
 213{
 214        int len = 0;
 215        struct file_system_type * tmp;
 216
 217        read_lock(&file_systems_lock);
 218        tmp = file_systems;
 219        while (tmp && len < PAGE_SIZE - 80) {
 220                len += sprintf(buf+len, "%s\t%s\n",
 221                        (tmp->fs_flags & FS_REQUIRES_DEV) ? "" : "nodev",
 222                        tmp->name);
 223                tmp = tmp->next;
 224        }
 225        read_unlock(&file_systems_lock);
 226        return len;
 227}
 228
 229#ifdef CONFIG_PROC_FS
 230static int filesystems_proc_show(struct seq_file *m, void *v)
 231{
 232        struct file_system_type * tmp;
 233
 234        read_lock(&file_systems_lock);
 235        tmp = file_systems;
 236        while (tmp) {
 237                seq_printf(m, "%s\t%s\n",
 238                        (tmp->fs_flags & FS_REQUIRES_DEV) ? "" : "nodev",
 239                        tmp->name);
 240                tmp = tmp->next;
 241        }
 242        read_unlock(&file_systems_lock);
 243        return 0;
 244}
 245
 246static int __init proc_filesystems_init(void)
 247{
 248        proc_create_single("filesystems", 0, NULL, filesystems_proc_show);
 249        return 0;
 250}
 251module_init(proc_filesystems_init);
 252#endif
 253
 254static struct file_system_type *__get_fs_type(const char *name, int len)
 255{
 256        struct file_system_type *fs;
 257
 258        read_lock(&file_systems_lock);
 259        fs = *(find_filesystem(name, len));
 260        if (fs && !try_module_get(fs->owner))
 261                fs = NULL;
 262        read_unlock(&file_systems_lock);
 263        return fs;
 264}
 265
 266struct file_system_type *get_fs_type(const char *name)
 267{
 268        struct file_system_type *fs;
 269        const char *dot = strchr(name, '.');
 270        int len = dot ? dot - name : strlen(name);
 271
 272        fs = __get_fs_type(name, len);
 273        if (!fs && (request_module("fs-%.*s", len, name) == 0)) {
 274                fs = __get_fs_type(name, len);
 275                if (!fs)
 276                        pr_warn_once("request_module fs-%.*s succeeded, but still no fs?\n",
 277                                     len, name);
 278        }
 279
 280        if (dot && fs && !(fs->fs_flags & FS_HAS_SUBTYPE)) {
 281                put_filesystem(fs);
 282                fs = NULL;
 283        }
 284        return fs;
 285}
 286
 287EXPORT_SYMBOL(get_fs_type);
 288