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(module: fs->owner); |
41 | return fs; |
42 | } |
43 | |
44 | void put_filesystem(struct file_system_type *fs) |
45 | { |
46 | module_put(module: 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(name: fs->name, desc: 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(name: 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 | struct filename *name; |
136 | int err, index; |
137 | |
138 | name = getname(__name); |
139 | err = PTR_ERR(ptr: name); |
140 | if (IS_ERR(ptr: 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 | |
156 | static 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(module: 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(to: buf, from: tmp->name, n: len) ? -EFAULT : 0; |
172 | put_filesystem(fs: tmp); |
173 | return res; |
174 | } |
175 | |
176 | static 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 | */ |
191 | SYSCALL_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(name: (const char __user *) arg1); |
198 | break; |
199 | |
200 | case 2: |
201 | retval = fs_name(index: arg1, buf: (char __user *) arg2); |
202 | break; |
203 | |
204 | case 3: |
205 | retval = fs_maxindex(); |
206 | break; |
207 | } |
208 | return retval; |
209 | } |
210 | #endif |
211 | |
212 | int __init list_bdev_fs_names(char *buf, size_t size) |
213 | { |
214 | struct file_system_type *p; |
215 | size_t len; |
216 | int count = 0; |
217 | |
218 | read_lock(&file_systems_lock); |
219 | for (p = file_systems; p; p = p->next) { |
220 | if (!(p->fs_flags & FS_REQUIRES_DEV)) |
221 | continue; |
222 | len = strlen(p->name) + 1; |
223 | if (len > size) { |
224 | pr_warn("%s: truncating file system list\n" , __func__); |
225 | break; |
226 | } |
227 | memcpy(buf, p->name, len); |
228 | buf += len; |
229 | size -= len; |
230 | count++; |
231 | } |
232 | read_unlock(&file_systems_lock); |
233 | return count; |
234 | } |
235 | |
236 | #ifdef CONFIG_PROC_FS |
237 | static int filesystems_proc_show(struct seq_file *m, void *v) |
238 | { |
239 | struct file_system_type * tmp; |
240 | |
241 | read_lock(&file_systems_lock); |
242 | tmp = file_systems; |
243 | while (tmp) { |
244 | seq_printf(m, fmt: "%s\t%s\n" , |
245 | (tmp->fs_flags & FS_REQUIRES_DEV) ? "" : "nodev" , |
246 | tmp->name); |
247 | tmp = tmp->next; |
248 | } |
249 | read_unlock(&file_systems_lock); |
250 | return 0; |
251 | } |
252 | |
253 | static int __init proc_filesystems_init(void) |
254 | { |
255 | proc_create_single("filesystems" , 0, NULL, filesystems_proc_show); |
256 | return 0; |
257 | } |
258 | module_init(proc_filesystems_init); |
259 | #endif |
260 | |
261 | static struct file_system_type *__get_fs_type(const char *name, int len) |
262 | { |
263 | struct file_system_type *fs; |
264 | |
265 | read_lock(&file_systems_lock); |
266 | fs = *(find_filesystem(name, len)); |
267 | if (fs && !try_module_get(module: fs->owner)) |
268 | fs = NULL; |
269 | read_unlock(&file_systems_lock); |
270 | return fs; |
271 | } |
272 | |
273 | struct file_system_type *get_fs_type(const char *name) |
274 | { |
275 | struct file_system_type *fs; |
276 | const char *dot = strchr(name, '.'); |
277 | int len = dot ? dot - name : strlen(name); |
278 | |
279 | fs = __get_fs_type(name, len); |
280 | if (!fs && (request_module("fs-%.*s" , len, name) == 0)) { |
281 | fs = __get_fs_type(name, len); |
282 | if (!fs) |
283 | pr_warn_once("request_module fs-%.*s succeeded, but still no fs?\n" , |
284 | len, name); |
285 | } |
286 | |
287 | if (dot && fs && !(fs->fs_flags & FS_HAS_SUBTYPE)) { |
288 | put_filesystem(fs); |
289 | fs = NULL; |
290 | } |
291 | return fs; |
292 | } |
293 | |
294 | EXPORT_SYMBOL(get_fs_type); |
295 | |