~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/filesystems.c

Version: ~ [ linux-5.1-rc5 ] ~ [ linux-5.0.7 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.34 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.111 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.168 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.178 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.138 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.65 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 && !fs_validate_description(fs->parameters))
 78                 return -EINVAL;
 79 
 80         BUG_ON(strchr(fs->name, '.'));
 81         if (fs->next)
 82                 return -EBUSY;
 83         write_lock(&file_systems_lock);
 84         p = find_filesystem(fs->name, strlen(fs->name));
 85         if (*p)
 86                 res = -EBUSY;
 87         else
 88                 *p = fs;
 89         write_unlock(&file_systems_lock);
 90         return res;
 91 }
 92 
 93 EXPORT_SYMBOL(register_filesystem);
 94 
 95 /**
 96  *      unregister_filesystem - unregister a file system
 97  *      @fs: filesystem to unregister
 98  *
 99  *      Remove a file system that was previously successfully registered
100  *      with the kernel. An error is returned if the file system is not found.
101  *      Zero is returned on a success.
102  *      
103  *      Once this function has returned the &struct file_system_type structure
104  *      may be freed or reused.
105  */
106  
107 int unregister_filesystem(struct file_system_type * fs)
108 {
109         struct file_system_type ** tmp;
110 
111         write_lock(&file_systems_lock);
112         tmp = &file_systems;
113         while (*tmp) {
114                 if (fs == *tmp) {
115                         *tmp = fs->next;
116                         fs->next = NULL;
117                         write_unlock(&file_systems_lock);
118                         synchronize_rcu();
119                         return 0;
120                 }
121                 tmp = &(*tmp)->next;
122         }
123         write_unlock(&file_systems_lock);
124 
125         return -EINVAL;
126 }
127 
128 EXPORT_SYMBOL(unregister_filesystem);
129 
130 #ifdef CONFIG_SYSFS_SYSCALL
131 static int fs_index(const char __user * __name)
132 {
133         struct file_system_type * tmp;
134         struct filename *name;
135         int err, index;
136 
137         name = getname(__name);
138         err = PTR_ERR(name);
139         if (IS_ERR(name))
140                 return err;
141 
142         err = -EINVAL;
143         read_lock(&file_systems_lock);
144         for (tmp=file_systems, index=0 ; tmp ; tmp=tmp->next, index++) {
145                 if (strcmp(tmp->name, name->name) == 0) {
146                         err = index;
147                         break;
148                 }
149         }
150         read_unlock(&file_systems_lock);
151         putname(name);
152         return err;
153 }
154 
155 static int fs_name(unsigned int index, char __user * buf)
156 {
157         struct file_system_type * tmp;
158         int len, res;
159 
160         read_lock(&file_systems_lock);
161         for (tmp = file_systems; tmp; tmp = tmp->next, index--)
162                 if (index <= 0 && try_module_get(tmp->owner))
163                         break;
164         read_unlock(&file_systems_lock);
165         if (!tmp)
166                 return -EINVAL;
167 
168         /* OK, we got the reference, so we can safely block */
169         len = strlen(tmp->name) + 1;
170         res = copy_to_user(buf, tmp->name, len) ? -EFAULT : 0;
171         put_filesystem(tmp);
172         return res;
173 }
174 
175 static int fs_maxindex(void)
176 {
177         struct file_system_type * tmp;
178         int index;
179 
180         read_lock(&file_systems_lock);
181         for (tmp = file_systems, index = 0 ; tmp ; tmp = tmp->next, index++)
182                 ;
183         read_unlock(&file_systems_lock);
184         return index;
185 }
186 
187 /*
188  * Whee.. Weird sysv syscall. 
189  */
190 SYSCALL_DEFINE3(sysfs, int, option, unsigned long, arg1, unsigned long, arg2)
191 {
192         int retval = -EINVAL;
193 
194         switch (option) {
195                 case 1:
196                         retval = fs_index((const char __user *) arg1);
197                         break;
198 
199                 case 2:
200                         retval = fs_name(arg1, (char __user *) arg2);
201                         break;
202 
203                 case 3:
204                         retval = fs_maxindex();
205                         break;
206         }
207         return retval;
208 }
209 #endif
210 
211 int __init get_filesystem_list(char *buf)
212 {
213         int len = 0;
214         struct file_system_type * tmp;
215 
216         read_lock(&file_systems_lock);
217         tmp = file_systems;
218         while (tmp && len < PAGE_SIZE - 80) {
219                 len += sprintf(buf+len, "%s\t%s\n",
220                         (tmp->fs_flags & FS_REQUIRES_DEV) ? "" : "nodev",
221                         tmp->name);
222                 tmp = tmp->next;
223         }
224         read_unlock(&file_systems_lock);
225         return len;
226 }
227 
228 #ifdef CONFIG_PROC_FS
229 static int filesystems_proc_show(struct seq_file *m, void *v)
230 {
231         struct file_system_type * tmp;
232 
233         read_lock(&file_systems_lock);
234         tmp = file_systems;
235         while (tmp) {
236                 seq_printf(m, "%s\t%s\n",
237                         (tmp->fs_flags & FS_REQUIRES_DEV) ? "" : "nodev",
238                         tmp->name);
239                 tmp = tmp->next;
240         }
241         read_unlock(&file_systems_lock);
242         return 0;
243 }
244 
245 static int __init proc_filesystems_init(void)
246 {
247         proc_create_single("filesystems", 0, NULL, filesystems_proc_show);
248         return 0;
249 }
250 module_init(proc_filesystems_init);
251 #endif
252 
253 static struct file_system_type *__get_fs_type(const char *name, int len)
254 {
255         struct file_system_type *fs;
256 
257         read_lock(&file_systems_lock);
258         fs = *(find_filesystem(name, len));
259         if (fs && !try_module_get(fs->owner))
260                 fs = NULL;
261         read_unlock(&file_systems_lock);
262         return fs;
263 }
264 
265 struct file_system_type *get_fs_type(const char *name)
266 {
267         struct file_system_type *fs;
268         const char *dot = strchr(name, '.');
269         int len = dot ? dot - name : strlen(name);
270 
271         fs = __get_fs_type(name, len);
272         if (!fs && (request_module("fs-%.*s", len, name) == 0)) {
273                 fs = __get_fs_type(name, len);
274                 WARN_ONCE(!fs, "request_module fs-%.*s succeeded, but still no fs?\n", len, name);
275         }
276 
277         if (dot && fs && !(fs->fs_flags & FS_HAS_SUBTYPE)) {
278                 put_filesystem(fs);
279                 fs = NULL;
280         }
281         return fs;
282 }
283 
284 EXPORT_SYMBOL(get_fs_type);
285 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp