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 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/conn.h> 35 #include <net/9p/client.h> 36 #include "v9fs.h" 37 #include "v9fs_vfs.h" 38 39 /* 40 * Option Parsing (code inspired by NFS code) 41 * NOTE: each transport will parse its own options 42 */ 43 44 enum { 45 /* Options that take integer arguments */ 46 Opt_debug, Opt_msize, Opt_dfltuid, Opt_dfltgid, Opt_afid, 47 /* String options */ 48 Opt_uname, Opt_remotename, Opt_trans, 49 /* Options that take no arguments */ 50 Opt_legacy, Opt_nodevmap, 51 /* Cache options */ 52 Opt_cache_loose, 53 /* Access options */ 54 Opt_access, 55 /* Error token */ 56 Opt_err 57 }; 58 59 static match_table_t tokens = { 60 {Opt_debug, "debug=%x"}, 61 {Opt_msize, "msize=%u"}, 62 {Opt_dfltuid, "dfltuid=%u"}, 63 {Opt_dfltgid, "dfltgid=%u"}, 64 {Opt_afid, "afid=%u"}, 65 {Opt_uname, "uname=%s"}, 66 {Opt_remotename, "aname=%s"}, 67 {Opt_trans, "trans=%s"}, 68 {Opt_legacy, "noextend"}, 69 {Opt_nodevmap, "nodevmap"}, 70 {Opt_cache_loose, "cache=loose"}, 71 {Opt_cache_loose, "loose"}, 72 {Opt_access, "access=%s"}, 73 {Opt_err, NULL} 74 }; 75 76 /** 77 * v9fs_parse_options - parse mount options into session structure 78 * @options: options string passed from mount 79 * @v9ses: existing v9fs session information 80 * 81 */ 82 83 static void v9fs_parse_options(struct v9fs_session_info *v9ses) 84 { 85 char *options; 86 substring_t args[MAX_OPT_ARGS]; 87 char *p; 88 int option; 89 int ret; 90 char *s, *e; 91 92 /* setup defaults */ 93 v9ses->maxdata = 8192; 94 v9ses->afid = ~0; 95 v9ses->debug = 0; 96 v9ses->cache = 0; 97 v9ses->trans = v9fs_default_trans(); 98 99 if (!v9ses->options) 100 return; 101 102 options = kstrdup(v9ses->options, GFP_KERNEL); 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 if ((ret = match_int(&args[0], &option)) < 0) { 110 P9_DPRINTK(P9_DEBUG_ERROR, 111 "integer field, but no integer?\n"); 112 continue; 113 } 114 } 115 switch (token) { 116 case Opt_debug: 117 v9ses->debug = option; 118 #ifdef CONFIG_NET_9P_DEBUG 119 p9_debug_level = option; 120 #endif 121 break; 122 case Opt_msize: 123 v9ses->maxdata = option; 124 break; 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_trans: 135 v9ses->trans = v9fs_match_trans(&args[0]); 136 break; 137 case Opt_uname: 138 match_strcpy(v9ses->uname, &args[0]); 139 break; 140 case Opt_remotename: 141 match_strcpy(v9ses->aname, &args[0]); 142 break; 143 case Opt_legacy: 144 v9ses->flags &= ~V9FS_EXTENDED; 145 break; 146 case Opt_nodevmap: 147 v9ses->nodev = 1; 148 break; 149 case Opt_cache_loose: 150 v9ses->cache = CACHE_LOOSE; 151 break; 152 153 case Opt_access: 154 s = match_strdup(&args[0]); 155 v9ses->flags &= ~V9FS_ACCESS_MASK; 156 if (strcmp(s, "user") == 0) 157 v9ses->flags |= V9FS_ACCESS_USER; 158 else if (strcmp(s, "any") == 0) 159 v9ses->flags |= V9FS_ACCESS_ANY; 160 else { 161 v9ses->flags |= V9FS_ACCESS_SINGLE; 162 v9ses->uid = simple_strtol(s, &e, 10); 163 if (*e != '\0') 164 v9ses->uid = ~0; 165 } 166 kfree(s); 167 break; 168 169 default: 170 continue; 171 } 172 } 173 kfree(options); 174 } 175 176 /** 177 * v9fs_session_init - initialize session 178 * @v9ses: session information structure 179 * @dev_name: device being mounted 180 * @data: options 181 * 182 */ 183 184 struct p9_fid *v9fs_session_init(struct v9fs_session_info *v9ses, 185 const char *dev_name, char *data) 186 { 187 int retval = -EINVAL; 188 struct p9_trans *trans = NULL; 189 struct p9_fid *fid; 190 191 v9ses->uname = __getname(); 192 if (!v9ses->uname) 193 return ERR_PTR(-ENOMEM); 194 195 v9ses->aname = __getname(); 196 if (!v9ses->aname) { 197 __putname(v9ses->uname); 198 return ERR_PTR(-ENOMEM); 199 } 200 201 v9ses->flags = V9FS_EXTENDED | V9FS_ACCESS_USER; 202 strcpy(v9ses->uname, V9FS_DEFUSER); 203 strcpy(v9ses->aname, V9FS_DEFANAME); 204 v9ses->uid = ~0; 205 v9ses->dfltuid = V9FS_DEFUID; 206 v9ses->dfltgid = V9FS_DEFGID; 207 v9ses->options = kstrdup(data, GFP_KERNEL); 208 v9fs_parse_options(v9ses); 209 210 if (v9ses->trans == NULL) { 211 retval = -EPROTONOSUPPORT; 212 P9_DPRINTK(P9_DEBUG_ERROR, 213 "No transport defined or default transport\n"); 214 goto error; 215 } 216 217 trans = v9ses->trans->create(dev_name, v9ses->options); 218 if (IS_ERR(trans)) { 219 retval = PTR_ERR(trans); 220 trans = NULL; 221 goto error; 222 } 223 if ((v9ses->maxdata+P9_IOHDRSZ) > v9ses->trans->maxsize) 224 v9ses->maxdata = v9ses->trans->maxsize-P9_IOHDRSZ; 225 226 v9ses->clnt = p9_client_create(trans, v9ses->maxdata+P9_IOHDRSZ, 227 v9fs_extended(v9ses)); 228 229 if (IS_ERR(v9ses->clnt)) { 230 retval = PTR_ERR(v9ses->clnt); 231 v9ses->clnt = NULL; 232 P9_DPRINTK(P9_DEBUG_ERROR, "problem initializing 9p client\n"); 233 goto error; 234 } 235 236 if (!v9ses->clnt->dotu) 237 v9ses->flags &= ~V9FS_EXTENDED; 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 v9fs_session_close(v9ses); 266 return ERR_PTR(retval); 267 } 268 269 /** 270 * v9fs_session_close - shutdown a session 271 * @v9ses: session information structure 272 * 273 */ 274 275 void v9fs_session_close(struct v9fs_session_info *v9ses) 276 { 277 if (v9ses->clnt) { 278 p9_client_destroy(v9ses->clnt); 279 v9ses->clnt = NULL; 280 } 281 282 __putname(v9ses->uname); 283 __putname(v9ses->aname); 284 kfree(v9ses->options); 285 } 286 287 /** 288 * v9fs_session_cancel - mark transport as disconnected 289 * and cancel all pending requests. 290 */ 291 void v9fs_session_cancel(struct v9fs_session_info *v9ses) { 292 P9_DPRINTK(P9_DEBUG_ERROR, "cancel session %p\n", v9ses); 293 p9_client_disconnect(v9ses->clnt); 294 } 295 296 extern int v9fs_error_init(void); 297 298 /** 299 * v9fs_init - Initialize module 300 * 301 */ 302 303 static int __init init_v9fs(void) 304 { 305 printk(KERN_INFO "Installing v9fs 9p2000 file system support\n"); 306 /* TODO: Setup list of registered trasnport modules */ 307 return register_filesystem(&v9fs_fs_type); 308 } 309 310 /** 311 * v9fs_init - shutdown module 312 * 313 */ 314 315 static void __exit exit_v9fs(void) 316 { 317 unregister_filesystem(&v9fs_fs_type); 318 } 319 320 module_init(init_v9fs) 321 module_exit(exit_v9fs) 322 323 MODULE_AUTHOR("Latchesar Ionkov <lucho@ionkov.net>"); 324 MODULE_AUTHOR("Eric Van Hensbergen <ericvh@gmail.com>"); 325 MODULE_AUTHOR("Ron Minnich <rminnich@lanl.gov>"); 326 MODULE_LICENSE("GPL"); 327