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