Root/
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 <asm/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 | void get_filesystem(struct file_system_type *fs) |
37 | { |
38 | __module_get(fs->owner); |
39 | } |
40 | |
41 | void put_filesystem(struct file_system_type *fs) |
42 | { |
43 | module_put(fs->owner); |
44 | } |
45 | |
46 | static struct file_system_type **find_filesystem(const char *name, unsigned len) |
47 | { |
48 | struct file_system_type **p; |
49 | for (p=&file_systems; *p; p=&(*p)->next) |
50 | if (strlen((*p)->name) == len && |
51 | strncmp((*p)->name, name, len) == 0) |
52 | break; |
53 | return p; |
54 | } |
55 | |
56 | /** |
57 | * register_filesystem - register a new filesystem |
58 | * @fs: the file system structure |
59 | * |
60 | * Adds the file system passed to the list of file systems the kernel |
61 | * is aware of for mount and other syscalls. Returns 0 on success, |
62 | * or a negative errno code on an error. |
63 | * |
64 | * The &struct file_system_type that is passed is linked into the kernel |
65 | * structures and must not be freed until the file system has been |
66 | * unregistered. |
67 | */ |
68 | |
69 | int register_filesystem(struct file_system_type * fs) |
70 | { |
71 | int res = 0; |
72 | struct file_system_type ** p; |
73 | |
74 | BUG_ON(strchr(fs->name, '.')); |
75 | if (fs->next) |
76 | return -EBUSY; |
77 | INIT_LIST_HEAD(&fs->fs_supers); |
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 | return 0; |
114 | } |
115 | tmp = &(*tmp)->next; |
116 | } |
117 | write_unlock(&file_systems_lock); |
118 | |
119 | synchronize_rcu(); |
120 | |
121 | return -EINVAL; |
122 | } |
123 | |
124 | EXPORT_SYMBOL(unregister_filesystem); |
125 | |
126 | static int fs_index(const char __user * __name) |
127 | { |
128 | struct file_system_type * tmp; |
129 | char * 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) == 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 | |
205 | int __init get_filesystem_list(char *buf) |
206 | { |
207 | int len = 0; |
208 | struct file_system_type * tmp; |
209 | |
210 | read_lock(&file_systems_lock); |
211 | tmp = file_systems; |
212 | while (tmp && len < PAGE_SIZE - 80) { |
213 | len += sprintf(buf+len, "%s\t%s\n", |
214 | (tmp->fs_flags & FS_REQUIRES_DEV) ? "" : "nodev", |
215 | tmp->name); |
216 | tmp = tmp->next; |
217 | } |
218 | read_unlock(&file_systems_lock); |
219 | return len; |
220 | } |
221 | |
222 | #ifdef CONFIG_PROC_FS |
223 | static int filesystems_proc_show(struct seq_file *m, void *v) |
224 | { |
225 | struct file_system_type * tmp; |
226 | |
227 | read_lock(&file_systems_lock); |
228 | tmp = file_systems; |
229 | while (tmp) { |
230 | seq_printf(m, "%s\t%s\n", |
231 | (tmp->fs_flags & FS_REQUIRES_DEV) ? "" : "nodev", |
232 | tmp->name); |
233 | tmp = tmp->next; |
234 | } |
235 | read_unlock(&file_systems_lock); |
236 | return 0; |
237 | } |
238 | |
239 | static int filesystems_proc_open(struct inode *inode, struct file *file) |
240 | { |
241 | return single_open(file, filesystems_proc_show, NULL); |
242 | } |
243 | |
244 | static const struct file_operations filesystems_proc_fops = { |
245 | .open = filesystems_proc_open, |
246 | .read = seq_read, |
247 | .llseek = seq_lseek, |
248 | .release = single_release, |
249 | }; |
250 | |
251 | static int __init proc_filesystems_init(void) |
252 | { |
253 | proc_create("filesystems", 0, NULL, &filesystems_proc_fops); |
254 | return 0; |
255 | } |
256 | module_init(proc_filesystems_init); |
257 | #endif |
258 | |
259 | static struct file_system_type *__get_fs_type(const char *name, int len) |
260 | { |
261 | struct file_system_type *fs; |
262 | |
263 | read_lock(&file_systems_lock); |
264 | fs = *(find_filesystem(name, len)); |
265 | if (fs && !try_module_get(fs->owner)) |
266 | fs = NULL; |
267 | read_unlock(&file_systems_lock); |
268 | return fs; |
269 | } |
270 | |
271 | struct file_system_type *get_fs_type(const char *name) |
272 | { |
273 | struct file_system_type *fs; |
274 | const char *dot = strchr(name, '.'); |
275 | int len = dot ? dot - name : strlen(name); |
276 | |
277 | fs = __get_fs_type(name, len); |
278 | if (!fs && (request_module("%.*s", len, name) == 0)) |
279 | fs = __get_fs_type(name, len); |
280 | |
281 | if (dot && fs && !(fs->fs_flags & FS_HAS_SUBTYPE)) { |
282 | put_filesystem(fs); |
283 | fs = NULL; |
284 | } |
285 | return fs; |
286 | } |
287 | |
288 | EXPORT_SYMBOL(get_fs_type); |
289 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9