diff options
-rw-r--r-- | fs/9p/v9fs.c | 448 | ||||
-rw-r--r-- | fs/9p/v9fs.h | 105 | ||||
-rw-r--r-- | fs/9p/v9fs_vfs.h | 53 | ||||
-rw-r--r-- | fs/9p/vfs_super.c | 271 |
4 files changed, 877 insertions, 0 deletions
diff --git a/fs/9p/v9fs.c b/fs/9p/v9fs.c new file mode 100644 index 000000000000..14d663ebfcbc --- /dev/null +++ b/fs/9p/v9fs.c | |||
@@ -0,0 +1,448 @@ | |||
1 | /* | ||
2 | * linux/fs/9p/v9fs.c | ||
3 | * | ||
4 | * This file contains functions assisting in mapping VFS to 9P2000 | ||
5 | * | ||
6 | * Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com> | ||
7 | * Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov> | ||
8 | * | ||
9 | * This program is free software; you can redistribute it and/or modify | ||
10 | * it under the terms of the GNU General Public License as published by | ||
11 | * the Free Software Foundation; either version 2 of the License, or | ||
12 | * (at your option) any later version. | ||
13 | * | ||
14 | * This program is distributed in the hope that it will be useful, | ||
15 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
16 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
17 | * GNU General Public License for more details. | ||
18 | * | ||
19 | * You should have received a copy of the GNU General Public License | ||
20 | * along with this program; if not, write to: | ||
21 | * Free Software Foundation | ||
22 | * 51 Franklin Street, Fifth Floor | ||
23 | * Boston, MA 02111-1301 USA | ||
24 | * | ||
25 | */ | ||
26 | |||
27 | #include <linux/config.h> | ||
28 | #include <linux/module.h> | ||
29 | #include <linux/errno.h> | ||
30 | #include <linux/fs.h> | ||
31 | #include <linux/parser.h> | ||
32 | #include <linux/idr.h> | ||
33 | |||
34 | #include "debug.h" | ||
35 | #include "v9fs.h" | ||
36 | #include "9p.h" | ||
37 | #include "v9fs_vfs.h" | ||
38 | #include "transport.h" | ||
39 | #include "mux.h" | ||
40 | #include "conv.h" | ||
41 | |||
42 | /* TODO: sysfs or debugfs interface */ | ||
43 | int v9fs_debug_level = 0; /* feature-rific global debug level */ | ||
44 | |||
45 | /* | ||
46 | * Option Parsing (code inspired by NFS code) | ||
47 | * | ||
48 | */ | ||
49 | |||
50 | enum { | ||
51 | /* Options that take integer arguments */ | ||
52 | Opt_port, Opt_msize, Opt_uid, Opt_gid, Opt_afid, Opt_debug, | ||
53 | Opt_rfdno, Opt_wfdno, | ||
54 | /* String options */ | ||
55 | Opt_name, Opt_remotename, | ||
56 | /* Options that take no arguments */ | ||
57 | Opt_legacy, Opt_nodevmap, Opt_unix, Opt_tcp, Opt_fd, | ||
58 | /* Error token */ | ||
59 | Opt_err | ||
60 | }; | ||
61 | |||
62 | static match_table_t tokens = { | ||
63 | {Opt_port, "port=%u"}, | ||
64 | {Opt_msize, "msize=%u"}, | ||
65 | {Opt_uid, "uid=%u"}, | ||
66 | {Opt_gid, "gid=%u"}, | ||
67 | {Opt_afid, "afid=%u"}, | ||
68 | {Opt_rfdno, "rfdno=%u"}, | ||
69 | {Opt_wfdno, "wfdno=%u"}, | ||
70 | {Opt_debug, "debug=%u"}, | ||
71 | {Opt_name, "name=%s"}, | ||
72 | {Opt_remotename, "aname=%s"}, | ||
73 | {Opt_unix, "proto=unix"}, | ||
74 | {Opt_tcp, "proto=tcp"}, | ||
75 | {Opt_fd, "proto=fd"}, | ||
76 | {Opt_tcp, "tcp"}, | ||
77 | {Opt_unix, "unix"}, | ||
78 | {Opt_fd, "fd"}, | ||
79 | {Opt_legacy, "noextend"}, | ||
80 | {Opt_nodevmap, "nodevmap"}, | ||
81 | {Opt_err, NULL} | ||
82 | }; | ||
83 | |||
84 | /* | ||
85 | * Parse option string. | ||
86 | */ | ||
87 | |||
88 | /** | ||
89 | * v9fs_parse_options - parse mount options into session structure | ||
90 | * @options: options string passed from mount | ||
91 | * @v9ses: existing v9fs session information | ||
92 | * | ||
93 | */ | ||
94 | |||
95 | static void v9fs_parse_options(char *options, struct v9fs_session_info *v9ses) | ||
96 | { | ||
97 | char *p; | ||
98 | substring_t args[MAX_OPT_ARGS]; | ||
99 | int option; | ||
100 | int ret; | ||
101 | |||
102 | /* setup defaults */ | ||
103 | v9ses->port = V9FS_PORT; | ||
104 | v9ses->maxdata = 9000; | ||
105 | v9ses->proto = PROTO_TCP; | ||
106 | v9ses->extended = 1; | ||
107 | v9ses->afid = ~0; | ||
108 | v9ses->debug = 0; | ||
109 | v9ses->rfdno = ~0; | ||
110 | v9ses->wfdno = ~0; | ||
111 | |||
112 | if (!options) | ||
113 | return; | ||
114 | |||
115 | while ((p = strsep(&options, ",")) != NULL) { | ||
116 | int token; | ||
117 | if (!*p) | ||
118 | continue; | ||
119 | token = match_token(p, tokens, args); | ||
120 | if (token < Opt_name) { | ||
121 | if ((ret = match_int(&args[0], &option)) < 0) { | ||
122 | dprintk(DEBUG_ERROR, | ||
123 | "integer field, but no integer?\n"); | ||
124 | continue; | ||
125 | } | ||
126 | |||
127 | } | ||
128 | switch (token) { | ||
129 | case Opt_port: | ||
130 | v9ses->port = option; | ||
131 | break; | ||
132 | case Opt_msize: | ||
133 | v9ses->maxdata = option; | ||
134 | break; | ||
135 | case Opt_uid: | ||
136 | v9ses->uid = option; | ||
137 | break; | ||
138 | case Opt_gid: | ||
139 | v9ses->gid = option; | ||
140 | break; | ||
141 | case Opt_afid: | ||
142 | v9ses->afid = option; | ||
143 | break; | ||
144 | case Opt_rfdno: | ||
145 | v9ses->rfdno = option; | ||
146 | break; | ||
147 | case Opt_wfdno: | ||
148 | v9ses->wfdno = option; | ||
149 | break; | ||
150 | case Opt_debug: | ||
151 | v9ses->debug = option; | ||
152 | break; | ||
153 | case Opt_tcp: | ||
154 | v9ses->proto = PROTO_TCP; | ||
155 | break; | ||
156 | case Opt_unix: | ||
157 | v9ses->proto = PROTO_UNIX; | ||
158 | break; | ||
159 | case Opt_fd: | ||
160 | v9ses->proto = PROTO_FD; | ||
161 | break; | ||
162 | case Opt_name: | ||
163 | match_strcpy(v9ses->name, &args[0]); | ||
164 | break; | ||
165 | case Opt_remotename: | ||
166 | match_strcpy(v9ses->remotename, &args[0]); | ||
167 | break; | ||
168 | case Opt_legacy: | ||
169 | v9ses->extended = 0; | ||
170 | break; | ||
171 | case Opt_nodevmap: | ||
172 | v9ses->nodev = 1; | ||
173 | break; | ||
174 | default: | ||
175 | continue; | ||
176 | } | ||
177 | } | ||
178 | } | ||
179 | |||
180 | /** | ||
181 | * v9fs_inode2v9ses - safely extract v9fs session info from super block | ||
182 | * @inode: inode to extract information from | ||
183 | * | ||
184 | * Paranoid function to extract v9ses information from superblock, | ||
185 | * if anything is missing it will report an error. | ||
186 | * | ||
187 | */ | ||
188 | |||
189 | struct v9fs_session_info *v9fs_inode2v9ses(struct inode *inode) | ||
190 | { | ||
191 | return (inode->i_sb->s_fs_info); | ||
192 | } | ||
193 | |||
194 | /** | ||
195 | * v9fs_get_idpool - allocate numeric id from pool | ||
196 | * @p - pool to allocate from | ||
197 | * | ||
198 | * XXX - This seems to be an awful generic function, should it be in idr.c with | ||
199 | * the lock included in struct idr? | ||
200 | */ | ||
201 | |||
202 | int v9fs_get_idpool(struct v9fs_idpool *p) | ||
203 | { | ||
204 | int i = 0; | ||
205 | int error; | ||
206 | |||
207 | retry: | ||
208 | if (idr_pre_get(&p->pool, GFP_KERNEL) == 0) | ||
209 | return 0; | ||
210 | |||
211 | if (down_interruptible(&p->lock) == -EINTR) { | ||
212 | eprintk(KERN_WARNING, "Interrupted while locking\n"); | ||
213 | return -1; | ||
214 | } | ||
215 | |||
216 | error = idr_get_new(&p->pool, NULL, &i); | ||
217 | up(&p->lock); | ||
218 | |||
219 | if (error == -EAGAIN) | ||
220 | goto retry; | ||
221 | else if (error) | ||
222 | return -1; | ||
223 | |||
224 | return i; | ||
225 | } | ||
226 | |||
227 | /** | ||
228 | * v9fs_put_idpool - release numeric id from pool | ||
229 | * @p - pool to allocate from | ||
230 | * | ||
231 | * XXX - This seems to be an awful generic function, should it be in idr.c with | ||
232 | * the lock included in struct idr? | ||
233 | */ | ||
234 | |||
235 | void v9fs_put_idpool(int id, struct v9fs_idpool *p) | ||
236 | { | ||
237 | if (down_interruptible(&p->lock) == -EINTR) { | ||
238 | eprintk(KERN_WARNING, "Interrupted while locking\n"); | ||
239 | return; | ||
240 | } | ||
241 | idr_remove(&p->pool, id); | ||
242 | up(&p->lock); | ||
243 | } | ||
244 | |||
245 | /** | ||
246 | * v9fs_session_init - initialize session | ||
247 | * @v9ses: session information structure | ||
248 | * @dev_name: device being mounted | ||
249 | * @data: options | ||
250 | * | ||
251 | */ | ||
252 | |||
253 | int | ||
254 | v9fs_session_init(struct v9fs_session_info *v9ses, | ||
255 | const char *dev_name, char *data) | ||
256 | { | ||
257 | struct v9fs_fcall *fcall = NULL; | ||
258 | struct v9fs_transport *trans_proto; | ||
259 | int n = 0; | ||
260 | int newfid = -1; | ||
261 | int retval = -EINVAL; | ||
262 | |||
263 | v9ses->name = __getname(); | ||
264 | if (!v9ses->name) | ||
265 | return -ENOMEM; | ||
266 | |||
267 | v9ses->remotename = __getname(); | ||
268 | if (!v9ses->remotename) { | ||
269 | putname(v9ses->name); | ||
270 | return -ENOMEM; | ||
271 | } | ||
272 | |||
273 | strcpy(v9ses->name, V9FS_DEFUSER); | ||
274 | strcpy(v9ses->remotename, V9FS_DEFANAME); | ||
275 | |||
276 | v9fs_parse_options(data, v9ses); | ||
277 | |||
278 | /* set global debug level */ | ||
279 | v9fs_debug_level = v9ses->debug; | ||
280 | |||
281 | /* id pools that are session-dependent: FIDs and TIDs */ | ||
282 | idr_init(&v9ses->fidpool.pool); | ||
283 | init_MUTEX(&v9ses->fidpool.lock); | ||
284 | idr_init(&v9ses->tidpool.pool); | ||
285 | init_MUTEX(&v9ses->tidpool.lock); | ||
286 | |||
287 | |||
288 | switch (v9ses->proto) { | ||
289 | case PROTO_TCP: | ||
290 | trans_proto = &v9fs_trans_tcp; | ||
291 | break; | ||
292 | case PROTO_UNIX: | ||
293 | trans_proto = &v9fs_trans_unix; | ||
294 | *v9ses->remotename = 0; | ||
295 | break; | ||
296 | case PROTO_FD: | ||
297 | trans_proto = &v9fs_trans_fd; | ||
298 | *v9ses->remotename = 0; | ||
299 | if((v9ses->wfdno == ~0) || (v9ses->rfdno == ~0)) { | ||
300 | printk(KERN_ERR "v9fs: Insufficient options for proto=fd\n"); | ||
301 | retval = -ENOPROTOOPT; | ||
302 | goto SessCleanUp; | ||
303 | } | ||
304 | break; | ||
305 | default: | ||
306 | printk(KERN_ERR "v9fs: Bad mount protocol %d\n", v9ses->proto); | ||
307 | retval = -ENOPROTOOPT; | ||
308 | goto SessCleanUp; | ||
309 | }; | ||
310 | |||
311 | v9ses->transport = trans_proto; | ||
312 | |||
313 | if ((retval = v9ses->transport->init(v9ses, dev_name, data)) < 0) { | ||
314 | eprintk(KERN_ERR, "problem initializing transport\n"); | ||
315 | goto SessCleanUp; | ||
316 | } | ||
317 | |||
318 | v9ses->inprogress = 0; | ||
319 | v9ses->shutdown = 0; | ||
320 | v9ses->session_hung = 0; | ||
321 | |||
322 | if ((retval = v9fs_mux_init(v9ses, dev_name)) < 0) { | ||
323 | dprintk(DEBUG_ERROR, "problem initializing mux\n"); | ||
324 | goto SessCleanUp; | ||
325 | } | ||
326 | |||
327 | if (v9ses->afid == ~0) { | ||
328 | if (v9ses->extended) | ||
329 | retval = | ||
330 | v9fs_t_version(v9ses, v9ses->maxdata, "9P2000.u", | ||
331 | &fcall); | ||
332 | else | ||
333 | retval = v9fs_t_version(v9ses, v9ses->maxdata, "9P2000", | ||
334 | &fcall); | ||
335 | |||
336 | if (retval < 0) { | ||
337 | dprintk(DEBUG_ERROR, "v9fs_t_version failed\n"); | ||
338 | goto FreeFcall; | ||
339 | } | ||
340 | |||
341 | /* Really should check for 9P1 and report error */ | ||
342 | if (!strcmp(fcall->params.rversion.version, "9P2000.u")) { | ||
343 | dprintk(DEBUG_9P, "9P2000 UNIX extensions enabled\n"); | ||
344 | v9ses->extended = 1; | ||
345 | } else { | ||
346 | dprintk(DEBUG_9P, "9P2000 legacy mode enabled\n"); | ||
347 | v9ses->extended = 0; | ||
348 | } | ||
349 | |||
350 | n = fcall->params.rversion.msize; | ||
351 | kfree(fcall); | ||
352 | |||
353 | if (n < v9ses->maxdata) | ||
354 | v9ses->maxdata = n; | ||
355 | } | ||
356 | |||
357 | newfid = v9fs_get_idpool(&v9ses->fidpool); | ||
358 | if (newfid < 0) { | ||
359 | eprintk(KERN_WARNING, "couldn't allocate FID\n"); | ||
360 | retval = -ENOMEM; | ||
361 | goto SessCleanUp; | ||
362 | } | ||
363 | /* it is a little bit ugly, but we have to prevent newfid */ | ||
364 | /* being the same as afid, so if it is, get a new fid */ | ||
365 | if (v9ses->afid != ~0 && newfid == v9ses->afid) { | ||
366 | newfid = v9fs_get_idpool(&v9ses->fidpool); | ||
367 | if (newfid < 0) { | ||
368 | eprintk(KERN_WARNING, "couldn't allocate FID\n"); | ||
369 | retval = -ENOMEM; | ||
370 | goto SessCleanUp; | ||
371 | } | ||
372 | } | ||
373 | |||
374 | if ((retval = | ||
375 | v9fs_t_attach(v9ses, v9ses->name, v9ses->remotename, newfid, | ||
376 | v9ses->afid, NULL)) | ||
377 | < 0) { | ||
378 | dprintk(DEBUG_ERROR, "cannot attach\n"); | ||
379 | goto SessCleanUp; | ||
380 | } | ||
381 | |||
382 | if (v9ses->afid != ~0) { | ||
383 | if (v9fs_t_clunk(v9ses, v9ses->afid, NULL)) | ||
384 | dprintk(DEBUG_ERROR, "clunk failed\n"); | ||
385 | } | ||
386 | |||
387 | return newfid; | ||
388 | |||
389 | FreeFcall: | ||
390 | kfree(fcall); | ||
391 | |||
392 | SessCleanUp: | ||
393 | v9fs_session_close(v9ses); | ||
394 | return retval; | ||
395 | } | ||
396 | |||
397 | /** | ||
398 | * v9fs_session_close - shutdown a session | ||
399 | * @v9ses: session information structure | ||
400 | * | ||
401 | */ | ||
402 | |||
403 | void v9fs_session_close(struct v9fs_session_info *v9ses) | ||
404 | { | ||
405 | if (v9ses->recvproc) { | ||
406 | send_sig(SIGKILL, v9ses->recvproc, 1); | ||
407 | wait_for_completion(&v9ses->proccmpl); | ||
408 | } | ||
409 | |||
410 | if (v9ses->transport) | ||
411 | v9ses->transport->close(v9ses->transport); | ||
412 | |||
413 | putname(v9ses->name); | ||
414 | putname(v9ses->remotename); | ||
415 | } | ||
416 | |||
417 | extern int v9fs_error_init(void); | ||
418 | |||
419 | /** | ||
420 | * v9fs_init - Initialize module | ||
421 | * | ||
422 | */ | ||
423 | |||
424 | static int __init init_v9fs(void) | ||
425 | { | ||
426 | v9fs_error_init(); | ||
427 | |||
428 | printk(KERN_INFO "Installing v9fs 9P2000 file system support\n"); | ||
429 | |||
430 | return register_filesystem(&v9fs_fs_type); | ||
431 | } | ||
432 | |||
433 | /** | ||
434 | * v9fs_init - shutdown module | ||
435 | * | ||
436 | */ | ||
437 | |||
438 | static void __exit exit_v9fs(void) | ||
439 | { | ||
440 | unregister_filesystem(&v9fs_fs_type); | ||
441 | } | ||
442 | |||
443 | module_init(init_v9fs) | ||
444 | module_exit(exit_v9fs) | ||
445 | |||
446 | MODULE_AUTHOR("Eric Van Hensbergen <ericvh@gmail.com>"); | ||
447 | MODULE_AUTHOR("Ron Minnich <rminnich@lanl.gov>"); | ||
448 | MODULE_LICENSE("GPL"); | ||
diff --git a/fs/9p/v9fs.h b/fs/9p/v9fs.h new file mode 100644 index 000000000000..52203027b158 --- /dev/null +++ b/fs/9p/v9fs.h | |||
@@ -0,0 +1,105 @@ | |||
1 | /* | ||
2 | * V9FS definitions. | ||
3 | * | ||
4 | * Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com> | ||
5 | * Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov> | ||
6 | * | ||
7 | * This program is free software; you can redistribute it and/or modify | ||
8 | * it under the terms of the GNU General Public License as published by | ||
9 | * the Free Software Foundation; either version 2 of the License, or | ||
10 | * (at your option) any later version. | ||
11 | * | ||
12 | * This program is distributed in the hope that it will be useful, | ||
13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
15 | * GNU General Public License for more details. | ||
16 | * | ||
17 | * You should have received a copy of the GNU General Public License | ||
18 | * along with this program; if not, write to: | ||
19 | * Free Software Foundation | ||
20 | * 51 Franklin Street, Fifth Floor | ||
21 | * Boston, MA 02111-1301 USA | ||
22 | * | ||
23 | */ | ||
24 | |||
25 | /* | ||
26 | * Idpool structure provides lock and id management | ||
27 | * | ||
28 | */ | ||
29 | |||
30 | struct v9fs_idpool { | ||
31 | struct semaphore lock; | ||
32 | struct idr pool; | ||
33 | }; | ||
34 | |||
35 | /* | ||
36 | * Session structure provides information for an opened session | ||
37 | * | ||
38 | */ | ||
39 | |||
40 | struct v9fs_session_info { | ||
41 | /* options */ | ||
42 | unsigned int maxdata; | ||
43 | unsigned char extended; /* set to 1 if we are using UNIX extensions */ | ||
44 | unsigned char nodev; /* set to 1 if no disable device mapping */ | ||
45 | unsigned short port; /* port to connect to */ | ||
46 | unsigned short debug; /* debug level */ | ||
47 | unsigned short proto; /* protocol to use */ | ||
48 | unsigned int afid; /* authentication fid */ | ||
49 | unsigned int rfdno; /* read file descriptor number */ | ||
50 | unsigned int wfdno; /* write file descriptor number */ | ||
51 | |||
52 | |||
53 | char *name; /* user name to mount as */ | ||
54 | char *remotename; /* name of remote hierarchy being mounted */ | ||
55 | unsigned int uid; /* default uid/muid for legacy support */ | ||
56 | unsigned int gid; /* default gid for legacy support */ | ||
57 | |||
58 | /* book keeping */ | ||
59 | struct v9fs_idpool fidpool; /* The FID pool for file descriptors */ | ||
60 | struct v9fs_idpool tidpool; /* The TID pool for transactions ids */ | ||
61 | |||
62 | /* transport information */ | ||
63 | struct v9fs_transport *transport; | ||
64 | |||
65 | int inprogress; /* session in progress => true */ | ||
66 | int shutdown; /* session shutting down. no more attaches. */ | ||
67 | unsigned char session_hung; | ||
68 | |||
69 | /* mux private data */ | ||
70 | struct v9fs_fcall *curfcall; | ||
71 | wait_queue_head_t read_wait; | ||
72 | struct completion fcread; | ||
73 | struct completion proccmpl; | ||
74 | struct task_struct *recvproc; | ||
75 | |||
76 | spinlock_t muxlock; | ||
77 | struct list_head mux_fcalls; | ||
78 | }; | ||
79 | |||
80 | /* possible values of ->proto */ | ||
81 | enum { | ||
82 | PROTO_TCP, | ||
83 | PROTO_UNIX, | ||
84 | PROTO_FD, | ||
85 | }; | ||
86 | |||
87 | int v9fs_session_init(struct v9fs_session_info *, const char *, char *); | ||
88 | struct v9fs_session_info *v9fs_inode2v9ses(struct inode *); | ||
89 | void v9fs_session_close(struct v9fs_session_info *v9ses); | ||
90 | int v9fs_get_idpool(struct v9fs_idpool *p); | ||
91 | void v9fs_put_idpool(int id, struct v9fs_idpool *p); | ||
92 | int v9fs_get_option(char *opts, char *name, char *buf, int buflen); | ||
93 | long long v9fs_get_int_option(char *opts, char *name, long long dflt); | ||
94 | int v9fs_parse_tcp_devname(const char *devname, char **addr, char **remotename); | ||
95 | |||
96 | #define V9FS_MAGIC 0x01021997 | ||
97 | |||
98 | /* other default globals */ | ||
99 | #define V9FS_PORT 564 | ||
100 | #define V9FS_DEFUSER "nobody" | ||
101 | #define V9FS_DEFANAME "" | ||
102 | |||
103 | /* inital pool sizes for fids and tags */ | ||
104 | #define V9FS_START_FIDS 8192 | ||
105 | #define V9FS_START_TIDS 256 | ||
diff --git a/fs/9p/v9fs_vfs.h b/fs/9p/v9fs_vfs.h new file mode 100644 index 000000000000..2f2cea7ee3e7 --- /dev/null +++ b/fs/9p/v9fs_vfs.h | |||
@@ -0,0 +1,53 @@ | |||
1 | /* | ||
2 | * V9FS VFS extensions. | ||
3 | * | ||
4 | * Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com> | ||
5 | * Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov> | ||
6 | * | ||
7 | * This program is free software; you can redistribute it and/or modify | ||
8 | * it under the terms of the GNU General Public License as published by | ||
9 | * the Free Software Foundation; either version 2 of the License, or | ||
10 | * (at your option) any later version. | ||
11 | * | ||
12 | * This program is distributed in the hope that it will be useful, | ||
13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
15 | * GNU General Public License for more details. | ||
16 | * | ||
17 | * You should have received a copy of the GNU General Public License | ||
18 | * along with this program; if not, write to: | ||
19 | * Free Software Foundation | ||
20 | * 51 Franklin Street, Fifth Floor | ||
21 | * Boston, MA 02111-1301 USA | ||
22 | * | ||
23 | */ | ||
24 | |||
25 | /* plan9 semantics are that created files are implicitly opened. | ||
26 | * But linux semantics are that you call create, then open. | ||
27 | * the plan9 approach is superior as it provides an atomic | ||
28 | * open. | ||
29 | * we track the create fid here. When the file is opened, if fidopen is | ||
30 | * non-zero, we use the fid and can skip some steps. | ||
31 | * there may be a better way to do this, but I don't know it. | ||
32 | * one BAD way is to clunk the fid on create, then open it again: | ||
33 | * you lose the atomicity of file open | ||
34 | */ | ||
35 | |||
36 | /* special case: | ||
37 | * unlink calls remove, which is an implicit clunk. So we have to track | ||
38 | * that kind of thing so that we don't try to clunk a dead fid. | ||
39 | */ | ||
40 | |||
41 | extern struct file_system_type v9fs_fs_type; | ||
42 | extern struct file_operations v9fs_file_operations; | ||
43 | extern struct file_operations v9fs_dir_operations; | ||
44 | extern struct dentry_operations v9fs_dentry_operations; | ||
45 | |||
46 | struct inode *v9fs_get_inode(struct super_block *sb, int mode); | ||
47 | ino_t v9fs_qid2ino(struct v9fs_qid *qid); | ||
48 | void v9fs_mistat2inode(struct v9fs_stat *, struct inode *, | ||
49 | struct super_block *); | ||
50 | int v9fs_dir_release(struct inode *inode, struct file *filp); | ||
51 | int v9fs_file_open(struct inode *inode, struct file *file); | ||
52 | void v9fs_inode2mistat(struct inode *inode, struct v9fs_stat *mistat); | ||
53 | void v9fs_dentry_release(struct dentry *); | ||
diff --git a/fs/9p/vfs_super.c b/fs/9p/vfs_super.c new file mode 100644 index 000000000000..ce0778acc90a --- /dev/null +++ b/fs/9p/vfs_super.c | |||
@@ -0,0 +1,271 @@ | |||
1 | /* | ||
2 | * linux/fs/9p/vfs_super.c | ||
3 | * | ||
4 | * This file contians superblock ops for 9P2000. It is intended that | ||
5 | * you mount this file system on directories. | ||
6 | * | ||
7 | * Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com> | ||
8 | * Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov> | ||
9 | * | ||
10 | * This program is free software; you can redistribute it and/or modify | ||
11 | * it under the terms of the GNU General Public License as published by | ||
12 | * the Free Software Foundation; either version 2 of the License, or | ||
13 | * (at your option) any later version. | ||
14 | * | ||
15 | * This program is distributed in the hope that it will be useful, | ||
16 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
17 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
18 | * GNU General Public License for more details. | ||
19 | * | ||
20 | * You should have received a copy of the GNU General Public License | ||
21 | * along with this program; if not, write to: | ||
22 | * Free Software Foundation | ||
23 | * 51 Franklin Street, Fifth Floor | ||
24 | * Boston, MA 02111-1301 USA | ||
25 | * | ||
26 | */ | ||
27 | |||
28 | #include <linux/kernel.h> | ||
29 | #include <linux/config.h> | ||
30 | #include <linux/module.h> | ||
31 | #include <linux/errno.h> | ||
32 | #include <linux/fs.h> | ||
33 | #include <linux/file.h> | ||
34 | #include <linux/stat.h> | ||
35 | #include <linux/string.h> | ||
36 | #include <linux/smp_lock.h> | ||
37 | #include <linux/inet.h> | ||
38 | #include <linux/pagemap.h> | ||
39 | #include <linux/seq_file.h> | ||
40 | #include <linux/mount.h> | ||
41 | #include <linux/idr.h> | ||
42 | |||
43 | #include "debug.h" | ||
44 | #include "v9fs.h" | ||
45 | #include "9p.h" | ||
46 | #include "v9fs_vfs.h" | ||
47 | #include "conv.h" | ||
48 | #include "fid.h" | ||
49 | |||
50 | static void v9fs_clear_inode(struct inode *); | ||
51 | static struct super_operations v9fs_super_ops; | ||
52 | |||
53 | /** | ||
54 | * v9fs_clear_inode - release an inode | ||
55 | * @inode: inode to release | ||
56 | * | ||
57 | */ | ||
58 | |||
59 | static void v9fs_clear_inode(struct inode *inode) | ||
60 | { | ||
61 | filemap_fdatawrite(inode->i_mapping); | ||
62 | } | ||
63 | |||
64 | /** | ||
65 | * v9fs_set_super - set the superblock | ||
66 | * @s: super block | ||
67 | * @data: file system specific data | ||
68 | * | ||
69 | */ | ||
70 | |||
71 | static int v9fs_set_super(struct super_block *s, void *data) | ||
72 | { | ||
73 | s->s_fs_info = data; | ||
74 | return set_anon_super(s, data); | ||
75 | } | ||
76 | |||
77 | /** | ||
78 | * v9fs_fill_super - populate superblock with info | ||
79 | * @sb: superblock | ||
80 | * @v9ses: session information | ||
81 | * | ||
82 | */ | ||
83 | |||
84 | static void | ||
85 | v9fs_fill_super(struct super_block *sb, struct v9fs_session_info *v9ses, | ||
86 | int flags) | ||
87 | { | ||
88 | sb->s_maxbytes = MAX_LFS_FILESIZE; | ||
89 | sb->s_blocksize_bits = fls(v9ses->maxdata - 1); | ||
90 | sb->s_blocksize = 1 << sb->s_blocksize_bits; | ||
91 | sb->s_magic = V9FS_MAGIC; | ||
92 | sb->s_op = &v9fs_super_ops; | ||
93 | |||
94 | sb->s_flags = flags | MS_ACTIVE | MS_SYNCHRONOUS | MS_DIRSYNC | | ||
95 | MS_NODIRATIME | MS_NOATIME; | ||
96 | } | ||
97 | |||
98 | /** | ||
99 | * v9fs_get_sb - mount a superblock | ||
100 | * @fs_type: file system type | ||
101 | * @flags: mount flags | ||
102 | * @dev_name: device name that was mounted | ||
103 | * @data: mount options | ||
104 | * | ||
105 | */ | ||
106 | |||
107 | static struct super_block *v9fs_get_sb(struct file_system_type | ||
108 | *fs_type, int flags, | ||
109 | const char *dev_name, void *data) | ||
110 | { | ||
111 | struct super_block *sb = NULL; | ||
112 | struct v9fs_fcall *fcall = NULL; | ||
113 | struct inode *inode = NULL; | ||
114 | struct dentry *root = NULL; | ||
115 | struct v9fs_session_info *v9ses = NULL; | ||
116 | struct v9fs_fid *root_fid = NULL; | ||
117 | int mode = S_IRWXUGO | S_ISVTX; | ||
118 | uid_t uid = current->fsuid; | ||
119 | gid_t gid = current->fsgid; | ||
120 | int stat_result = 0; | ||
121 | int newfid = 0; | ||
122 | int retval = 0; | ||
123 | |||
124 | dprintk(DEBUG_VFS, " \n"); | ||
125 | |||
126 | v9ses = kcalloc(1, sizeof(struct v9fs_session_info), GFP_KERNEL); | ||
127 | if (!v9ses) | ||
128 | return ERR_PTR(-ENOMEM); | ||
129 | |||
130 | if ((newfid = v9fs_session_init(v9ses, dev_name, data)) < 0) { | ||
131 | dprintk(DEBUG_ERROR, "problem initiating session\n"); | ||
132 | retval = newfid; | ||
133 | goto free_session; | ||
134 | } | ||
135 | |||
136 | sb = sget(fs_type, NULL, v9fs_set_super, v9ses); | ||
137 | |||
138 | v9fs_fill_super(sb, v9ses, flags); | ||
139 | |||
140 | inode = v9fs_get_inode(sb, S_IFDIR | mode); | ||
141 | if (IS_ERR(inode)) { | ||
142 | retval = PTR_ERR(inode); | ||
143 | goto put_back_sb; | ||
144 | } | ||
145 | |||
146 | inode->i_uid = uid; | ||
147 | inode->i_gid = gid; | ||
148 | |||
149 | root = d_alloc_root(inode); | ||
150 | |||
151 | if (!root) { | ||
152 | retval = -ENOMEM; | ||
153 | goto release_inode; | ||
154 | } | ||
155 | |||
156 | sb->s_root = root; | ||
157 | |||
158 | /* Setup the Root Inode */ | ||
159 | root_fid = v9fs_fid_create(root); | ||
160 | if (root_fid == NULL) { | ||
161 | retval = -ENOMEM; | ||
162 | goto release_dentry; | ||
163 | } | ||
164 | |||
165 | root_fid->fidopen = 0; | ||
166 | root_fid->v9ses = v9ses; | ||
167 | |||
168 | stat_result = v9fs_t_stat(v9ses, newfid, &fcall); | ||
169 | if (stat_result < 0) { | ||
170 | dprintk(DEBUG_ERROR, "stat error\n"); | ||
171 | v9fs_t_clunk(v9ses, newfid, NULL); | ||
172 | v9fs_put_idpool(newfid, &v9ses->fidpool); | ||
173 | } else { | ||
174 | root_fid->fid = newfid; | ||
175 | root_fid->qid = fcall->params.rstat.stat->qid; | ||
176 | root->d_inode->i_ino = | ||
177 | v9fs_qid2ino(&fcall->params.rstat.stat->qid); | ||
178 | v9fs_mistat2inode(fcall->params.rstat.stat, root->d_inode, sb); | ||
179 | } | ||
180 | |||
181 | kfree(fcall); | ||
182 | |||
183 | if (stat_result < 0) { | ||
184 | retval = stat_result; | ||
185 | goto release_dentry; | ||
186 | } | ||
187 | |||
188 | return sb; | ||
189 | |||
190 | release_dentry: | ||
191 | dput(sb->s_root); | ||
192 | |||
193 | release_inode: | ||
194 | iput(inode); | ||
195 | |||
196 | put_back_sb: | ||
197 | up_write(&sb->s_umount); | ||
198 | deactivate_super(sb); | ||
199 | v9fs_session_close(v9ses); | ||
200 | |||
201 | free_session: | ||
202 | kfree(v9ses); | ||
203 | |||
204 | return ERR_PTR(retval); | ||
205 | } | ||
206 | |||
207 | /** | ||
208 | * v9fs_kill_super - Kill Superblock | ||
209 | * @s: superblock | ||
210 | * | ||
211 | */ | ||
212 | |||
213 | static void v9fs_kill_super(struct super_block *s) | ||
214 | { | ||
215 | struct v9fs_session_info *v9ses = s->s_fs_info; | ||
216 | |||
217 | dprintk(DEBUG_VFS, " %p\n", s); | ||
218 | |||
219 | v9fs_dentry_release(s->s_root); /* clunk root */ | ||
220 | |||
221 | kill_anon_super(s); | ||
222 | |||
223 | v9fs_session_close(v9ses); | ||
224 | kfree(v9ses); | ||
225 | dprintk(DEBUG_VFS, "exiting kill_super\n"); | ||
226 | } | ||
227 | |||
228 | /** | ||
229 | * v9fs_show_options - Show mount options in /proc/mounts | ||
230 | * @m: seq_file to write to | ||
231 | * @mnt: mount descriptor | ||
232 | * | ||
233 | */ | ||
234 | |||
235 | static int v9fs_show_options(struct seq_file *m, struct vfsmount *mnt) | ||
236 | { | ||
237 | struct v9fs_session_info *v9ses = mnt->mnt_sb->s_fs_info; | ||
238 | |||
239 | if (v9ses->debug != 0) | ||
240 | seq_printf(m, ",debug=%u", v9ses->debug); | ||
241 | if (v9ses->port != V9FS_PORT) | ||
242 | seq_printf(m, ",port=%u", v9ses->port); | ||
243 | if (v9ses->maxdata != 9000) | ||
244 | seq_printf(m, ",msize=%u", v9ses->maxdata); | ||
245 | if (v9ses->afid != ~0) | ||
246 | seq_printf(m, ",afid=%u", v9ses->afid); | ||
247 | if (v9ses->proto == PROTO_UNIX) | ||
248 | seq_puts(m, ",proto=unix"); | ||
249 | if (v9ses->extended == 0) | ||
250 | seq_puts(m, ",noextend"); | ||
251 | if (v9ses->nodev == 1) | ||
252 | seq_puts(m, ",nodevmap"); | ||
253 | seq_printf(m, ",name=%s", v9ses->name); | ||
254 | seq_printf(m, ",aname=%s", v9ses->remotename); | ||
255 | seq_printf(m, ",uid=%u", v9ses->uid); | ||
256 | seq_printf(m, ",gid=%u", v9ses->gid); | ||
257 | return 0; | ||
258 | } | ||
259 | |||
260 | static struct super_operations v9fs_super_ops = { | ||
261 | .statfs = simple_statfs, | ||
262 | .clear_inode = v9fs_clear_inode, | ||
263 | .show_options = v9fs_show_options, | ||
264 | }; | ||
265 | |||
266 | struct file_system_type v9fs_fs_type = { | ||
267 | .name = "9P", | ||
268 | .get_sb = v9fs_get_sb, | ||
269 | .kill_sb = v9fs_kill_super, | ||
270 | .owner = THIS_MODULE, | ||
271 | }; | ||