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/transport.h> 34 #include <net/9p/client.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 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) 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 (!v9ses->options) 94 return 0; 95 96 options = kstrdup(v9ses->options, 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_strtol(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 if (data) { 210 v9ses->options = kstrdup(data, GFP_KERNEL); 211 if (!v9ses->options) { 212 P9_DPRINTK(P9_DEBUG_ERROR, 213 "failed to allocate copy of option string\n"); 214 retval = -ENOMEM; 215 goto error; 216 } 217 } 218 219 rc = v9fs_parse_options(v9ses); 220 if (rc < 0) { 221 retval = rc; 222 goto error; 223 } 224 225 v9ses->clnt = p9_client_create(dev_name, v9ses->options); 226 227 if (IS_ERR(v9ses->clnt)) { 228 retval = PTR_ERR(v9ses->clnt); 229 v9ses->clnt = NULL; 230 P9_DPRINTK(P9_DEBUG_ERROR, "problem initializing 9p client\n"); 231 goto error; 232 } 233 234 if (!v9ses->clnt->dotu) 235 v9ses->flags &= ~V9FS_EXTENDED; 236 237 v9ses->maxdata = v9ses->clnt->msize; 238 239 /* for legacy mode, fall back to V9FS_ACCESS_ANY */ 240 if (!v9fs_extended(v9ses) && 241 ((v9ses->flags&V9FS_ACCESS_MASK) == V9FS_ACCESS_USER)) { 242 243 v9ses->flags &= ~V9FS_ACCESS_MASK; 244 v9ses->flags |= V9FS_ACCESS_ANY; 245 v9ses->uid = ~0; 246 } 247 248 fid = p9_client_attach(v9ses->clnt, NULL, v9ses->uname, ~0, 249 v9ses->aname); 250 if (IS_ERR(fid)) { 251 retval = PTR_ERR(fid); 252 fid = NULL; 253 P9_DPRINTK(P9_DEBUG_ERROR, "cannot attach\n"); 254 goto error; 255 } 256 257 if ((v9ses->flags & V9FS_ACCESS_MASK) == V9FS_ACCESS_SINGLE) 258 fid->uid = v9ses->uid; 259 else 260 fid->uid = ~0; 261 262 return fid; 263 264 error: 265 return ERR_PTR(retval); 266 } 267 268 /** 269 * v9fs_session_close - shutdown a session 270 * @v9ses: session information structure 271 * 272 */ 273 274 void v9fs_session_close(struct v9fs_session_info *v9ses) 275 { 276 if (v9ses->clnt) { 277 p9_client_destroy(v9ses->clnt); 278 v9ses->clnt = NULL; 279 } 280 281 __putname(v9ses->uname); 282 __putname(v9ses->aname); 283 kfree(v9ses->options); 284 } 285 286 /** 287 * v9fs_session_cancel - terminate a session 288 * @v9ses: session to terminate 289 * 290 * mark transport as disconnected and cancel all pending requests. 291 */ 292 293 void v9fs_session_cancel(struct v9fs_session_info *v9ses) { 294 P9_DPRINTK(P9_DEBUG_ERROR, "cancel session %p\n", v9ses); 295 p9_client_disconnect(v9ses->clnt); 296 } 297 298 extern int v9fs_error_init(void); 299 300 /** 301 * v9fs_init - Initialize module 302 * 303 */ 304 305 static int __init init_v9fs(void) 306 { 307 printk(KERN_INFO "Installing v9fs 9p2000 file system support\n"); 308 /* TODO: Setup list of registered trasnport modules */ 309 return register_filesystem(&v9fs_fs_type); 310 } 311 312 /** 313 * v9fs_init - shutdown module 314 * 315 */ 316 317 static void __exit exit_v9fs(void) 318 { 319 unregister_filesystem(&v9fs_fs_type); 320 } 321 322 module_init(init_v9fs) 323 module_exit(exit_v9fs) 324 325 MODULE_AUTHOR("Latchesar Ionkov <lucho@ionkov.net>"); 326 MODULE_AUTHOR("Eric Van Hensbergen <ericvh@gmail.com>"); 327 MODULE_AUTHOR("Ron Minnich <rminnich@lanl.gov>"); 328 MODULE_LICENSE("GPL"); 329