Root/
1 | /* |
2 | * linux/fs/9p/v9fs.c |
3 | * |
4 | * This file contains functions assisting in mapping VFS to 9P2000 |
5 | * |
6 | * Copyright (C) 2004-2008 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 version 2 |
11 | * as published by the Free Software Foundation. |
12 | * |
13 | * This program is distributed in the hope that it will be useful, |
14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
16 | * GNU General Public License for more details. |
17 | * |
18 | * You should have received a copy of the GNU General Public License |
19 | * along with this program; if not, write to: |
20 | * Free Software Foundation |
21 | * 51 Franklin Street, Fifth Floor |
22 | * Boston, MA 02111-1301 USA |
23 | * |
24 | */ |
25 | |
26 | #include <linux/module.h> |
27 | #include <linux/errno.h> |
28 | #include <linux/fs.h> |
29 | #include <linux/sched.h> |
30 | #include <linux/parser.h> |
31 | #include <linux/idr.h> |
32 | #include <net/9p/9p.h> |
33 | #include <net/9p/client.h> |
34 | #include <net/9p/transport.h> |
35 | #include "v9fs.h" |
36 | #include "v9fs_vfs.h" |
37 | |
38 | /* |
39 | * Option Parsing (code inspired by NFS code) |
40 | * NOTE: each transport will parse its own options |
41 | */ |
42 | |
43 | enum { |
44 | /* Options that take integer arguments */ |
45 | Opt_debug, Opt_dfltuid, Opt_dfltgid, Opt_afid, |
46 | /* String options */ |
47 | Opt_uname, Opt_remotename, Opt_trans, |
48 | /* Options that take no arguments */ |
49 | Opt_nodevmap, |
50 | /* Cache options */ |
51 | Opt_cache_loose, |
52 | /* Access options */ |
53 | Opt_access, |
54 | /* Error token */ |
55 | Opt_err |
56 | }; |
57 | |
58 | static const match_table_t tokens = { |
59 | {Opt_debug, "debug=%x"}, |
60 | {Opt_dfltuid, "dfltuid=%u"}, |
61 | {Opt_dfltgid, "dfltgid=%u"}, |
62 | {Opt_afid, "afid=%u"}, |
63 | {Opt_uname, "uname=%s"}, |
64 | {Opt_remotename, "aname=%s"}, |
65 | {Opt_nodevmap, "nodevmap"}, |
66 | {Opt_cache_loose, "cache=loose"}, |
67 | {Opt_cache_loose, "loose"}, |
68 | {Opt_access, "access=%s"}, |
69 | {Opt_err, NULL} |
70 | }; |
71 | |
72 | /** |
73 | * v9fs_parse_options - parse mount options into session structure |
74 | * @v9ses: existing v9fs session information |
75 | * |
76 | * Return 0 upon success, -ERRNO upon failure. |
77 | */ |
78 | |
79 | static int v9fs_parse_options(struct v9fs_session_info *v9ses, char *opts) |
80 | { |
81 | char *options; |
82 | substring_t args[MAX_OPT_ARGS]; |
83 | char *p; |
84 | int option = 0; |
85 | char *s, *e; |
86 | int ret = 0; |
87 | |
88 | /* setup defaults */ |
89 | v9ses->afid = ~0; |
90 | v9ses->debug = 0; |
91 | v9ses->cache = 0; |
92 | |
93 | if (!opts) |
94 | return 0; |
95 | |
96 | options = kstrdup(opts, GFP_KERNEL); |
97 | if (!options) { |
98 | P9_DPRINTK(P9_DEBUG_ERROR, |
99 | "failed to allocate copy of option string\n"); |
100 | return -ENOMEM; |
101 | } |
102 | |
103 | while ((p = strsep(&options, ",")) != NULL) { |
104 | int token; |
105 | if (!*p) |
106 | continue; |
107 | token = match_token(p, tokens, args); |
108 | if (token < Opt_uname) { |
109 | int r = match_int(&args[0], &option); |
110 | if (r < 0) { |
111 | P9_DPRINTK(P9_DEBUG_ERROR, |
112 | "integer field, but no integer?\n"); |
113 | ret = r; |
114 | continue; |
115 | } |
116 | } |
117 | switch (token) { |
118 | case Opt_debug: |
119 | v9ses->debug = option; |
120 | #ifdef CONFIG_NET_9P_DEBUG |
121 | p9_debug_level = option; |
122 | #endif |
123 | break; |
124 | |
125 | case Opt_dfltuid: |
126 | v9ses->dfltuid = option; |
127 | break; |
128 | case Opt_dfltgid: |
129 | v9ses->dfltgid = option; |
130 | break; |
131 | case Opt_afid: |
132 | v9ses->afid = option; |
133 | break; |
134 | case Opt_uname: |
135 | match_strlcpy(v9ses->uname, &args[0], PATH_MAX); |
136 | break; |
137 | case Opt_remotename: |
138 | match_strlcpy(v9ses->aname, &args[0], PATH_MAX); |
139 | break; |
140 | case Opt_nodevmap: |
141 | v9ses->nodev = 1; |
142 | break; |
143 | case Opt_cache_loose: |
144 | v9ses->cache = CACHE_LOOSE; |
145 | break; |
146 | |
147 | case Opt_access: |
148 | s = match_strdup(&args[0]); |
149 | if (!s) { |
150 | P9_DPRINTK(P9_DEBUG_ERROR, |
151 | "failed to allocate copy" |
152 | " of option argument\n"); |
153 | ret = -ENOMEM; |
154 | break; |
155 | } |
156 | v9ses->flags &= ~V9FS_ACCESS_MASK; |
157 | if (strcmp(s, "user") == 0) |
158 | v9ses->flags |= V9FS_ACCESS_USER; |
159 | else if (strcmp(s, "any") == 0) |
160 | v9ses->flags |= V9FS_ACCESS_ANY; |
161 | else { |
162 | v9ses->flags |= V9FS_ACCESS_SINGLE; |
163 | v9ses->uid = simple_strtoul(s, &e, 10); |
164 | if (*e != '\0') |
165 | v9ses->uid = ~0; |
166 | } |
167 | kfree(s); |
168 | break; |
169 | |
170 | default: |
171 | continue; |
172 | } |
173 | } |
174 | kfree(options); |
175 | return ret; |
176 | } |
177 | |
178 | /** |
179 | * v9fs_session_init - initialize session |
180 | * @v9ses: session information structure |
181 | * @dev_name: device being mounted |
182 | * @data: options |
183 | * |
184 | */ |
185 | |
186 | struct p9_fid *v9fs_session_init(struct v9fs_session_info *v9ses, |
187 | const char *dev_name, char *data) |
188 | { |
189 | int retval = -EINVAL; |
190 | struct p9_fid *fid; |
191 | int rc; |
192 | |
193 | v9ses->uname = __getname(); |
194 | if (!v9ses->uname) |
195 | return ERR_PTR(-ENOMEM); |
196 | |
197 | v9ses->aname = __getname(); |
198 | if (!v9ses->aname) { |
199 | __putname(v9ses->uname); |
200 | return ERR_PTR(-ENOMEM); |
201 | } |
202 | |
203 | v9ses->flags = V9FS_EXTENDED | V9FS_ACCESS_USER; |
204 | strcpy(v9ses->uname, V9FS_DEFUSER); |
205 | strcpy(v9ses->aname, V9FS_DEFANAME); |
206 | v9ses->uid = ~0; |
207 | v9ses->dfltuid = V9FS_DEFUID; |
208 | v9ses->dfltgid = V9FS_DEFGID; |
209 | |
210 | rc = v9fs_parse_options(v9ses, data); |
211 | if (rc < 0) { |
212 | retval = rc; |
213 | goto error; |
214 | } |
215 | |
216 | v9ses->clnt = p9_client_create(dev_name, data); |
217 | if (IS_ERR(v9ses->clnt)) { |
218 | retval = PTR_ERR(v9ses->clnt); |
219 | v9ses->clnt = NULL; |
220 | P9_DPRINTK(P9_DEBUG_ERROR, "problem initializing 9p client\n"); |
221 | goto error; |
222 | } |
223 | |
224 | if (!v9ses->clnt->dotu) |
225 | v9ses->flags &= ~V9FS_EXTENDED; |
226 | |
227 | v9ses->maxdata = v9ses->clnt->msize - P9_IOHDRSZ; |
228 | |
229 | /* for legacy mode, fall back to V9FS_ACCESS_ANY */ |
230 | if (!v9fs_extended(v9ses) && |
231 | ((v9ses->flags&V9FS_ACCESS_MASK) == V9FS_ACCESS_USER)) { |
232 | |
233 | v9ses->flags &= ~V9FS_ACCESS_MASK; |
234 | v9ses->flags |= V9FS_ACCESS_ANY; |
235 | v9ses->uid = ~0; |
236 | } |
237 | |
238 | fid = p9_client_attach(v9ses->clnt, NULL, v9ses->uname, ~0, |
239 | v9ses->aname); |
240 | if (IS_ERR(fid)) { |
241 | retval = PTR_ERR(fid); |
242 | fid = NULL; |
243 | P9_DPRINTK(P9_DEBUG_ERROR, "cannot attach\n"); |
244 | goto error; |
245 | } |
246 | |
247 | if ((v9ses->flags & V9FS_ACCESS_MASK) == V9FS_ACCESS_SINGLE) |
248 | fid->uid = v9ses->uid; |
249 | else |
250 | fid->uid = ~0; |
251 | |
252 | return fid; |
253 | |
254 | error: |
255 | return ERR_PTR(retval); |
256 | } |
257 | |
258 | /** |
259 | * v9fs_session_close - shutdown a session |
260 | * @v9ses: session information structure |
261 | * |
262 | */ |
263 | |
264 | void v9fs_session_close(struct v9fs_session_info *v9ses) |
265 | { |
266 | if (v9ses->clnt) { |
267 | p9_client_destroy(v9ses->clnt); |
268 | v9ses->clnt = NULL; |
269 | } |
270 | |
271 | __putname(v9ses->uname); |
272 | __putname(v9ses->aname); |
273 | } |
274 | |
275 | /** |
276 | * v9fs_session_cancel - terminate a session |
277 | * @v9ses: session to terminate |
278 | * |
279 | * mark transport as disconnected and cancel all pending requests. |
280 | */ |
281 | |
282 | void v9fs_session_cancel(struct v9fs_session_info *v9ses) { |
283 | P9_DPRINTK(P9_DEBUG_ERROR, "cancel session %p\n", v9ses); |
284 | p9_client_disconnect(v9ses->clnt); |
285 | } |
286 | |
287 | extern int v9fs_error_init(void); |
288 | |
289 | /** |
290 | * v9fs_init - Initialize module |
291 | * |
292 | */ |
293 | |
294 | static int __init init_v9fs(void) |
295 | { |
296 | printk(KERN_INFO "Installing v9fs 9p2000 file system support\n"); |
297 | /* TODO: Setup list of registered trasnport modules */ |
298 | return register_filesystem(&v9fs_fs_type); |
299 | } |
300 | |
301 | /** |
302 | * v9fs_init - shutdown module |
303 | * |
304 | */ |
305 | |
306 | static void __exit exit_v9fs(void) |
307 | { |
308 | unregister_filesystem(&v9fs_fs_type); |
309 | } |
310 | |
311 | module_init(init_v9fs) |
312 | module_exit(exit_v9fs) |
313 | |
314 | MODULE_AUTHOR("Latchesar Ionkov <lucho@ionkov.net>"); |
315 | MODULE_AUTHOR("Eric Van Hensbergen <ericvh@gmail.com>"); |
316 | MODULE_AUTHOR("Ron Minnich <rminnich@lanl.gov>"); |
317 | MODULE_LICENSE("GPL"); |
318 |
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