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 * @options: options string passed from mount 75 * @v9ses: existing v9fs session information 76 * 77 */ 78 79 static void 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; 87 88 /* setup defaults */ 89 v9ses->afid = ~0; 90 v9ses->debug = 0; 91 v9ses->cache = 0; 92 93 if (!v9ses->options) 94 return; 95 96 options = kstrdup(v9ses->options, GFP_KERNEL); 97 while ((p = strsep(&options, ",")) != NULL) { 98 int token; 99 if (!*p) 100 continue; 101 token = match_token(p, tokens, args); 102 if (token < Opt_uname) { 103 ret = match_int(&args[0], &option); 104 if (ret < 0) { 105 P9_DPRINTK(P9_DEBUG_ERROR, 106 "integer field, but no integer?\n"); 107 continue; 108 } 109 } 110 switch (token) { 111 case Opt_debug: 112 v9ses->debug = option; 113 #ifdef CONFIG_NET_9P_DEBUG 114 p9_debug_level = option; 115 #endif 116 break; 117 118 case Opt_dfltuid: 119 v9ses->dfltuid = option; 120 break; 121 case Opt_dfltgid: 122 v9ses->dfltgid = option; 123 break; 124 case Opt_afid: 125 v9ses->afid = option; 126 break; 127 case Opt_uname: 128 match_strcpy(v9ses->uname, &args[0]); 129 break; 130 case Opt_remotename: 131 match_strcpy(v9ses->aname, &args[0]); 132 break; 133 case Opt_nodevmap: 134 v9ses->nodev = 1; 135 break; 136 case Opt_cache_loose: 137 v9ses->cache = CACHE_LOOSE; 138 break; 139 140 case Opt_access: 141 s = match_strdup(&args[0]); 142 v9ses->flags &= ~V9FS_ACCESS_MASK; 143 if (strcmp(s, "user") == 0) 144 v9ses->flags |= V9FS_ACCESS_USER; 145 else if (strcmp(s, "any") == 0) 146 v9ses->flags |= V9FS_ACCESS_ANY; 147 else { 148 v9ses->flags |= V9FS_ACCESS_SINGLE; 149 v9ses->uid = simple_strtol(s, &e, 10); 150 if (*e != '\0') 151 v9ses->uid = ~0; 152 } 153 kfree(s); 154 break; 155 156 default: 157 continue; 158 } 159 } 160 kfree(options); 161 } 162 163 /** 164 * v9fs_session_init - initialize session 165 * @v9ses: session information structure 166 * @dev_name: device being mounted 167 * @data: options 168 * 169 */ 170 171 struct p9_fid *v9fs_session_init(struct v9fs_session_info *v9ses, 172 const char *dev_name, char *data) 173 { 174 int retval = -EINVAL; 175 struct p9_fid *fid; 176 177 v9ses->uname = __getname(); 178 if (!v9ses->uname) 179 return ERR_PTR(-ENOMEM); 180 181 v9ses->aname = __getname(); 182 if (!v9ses->aname) { 183 __putname(v9ses->uname); 184 return ERR_PTR(-ENOMEM); 185 } 186 187 v9ses->flags = V9FS_EXTENDED | V9FS_ACCESS_USER; 188 strcpy(v9ses->uname, V9FS_DEFUSER); 189 strcpy(v9ses->aname, V9FS_DEFANAME); 190 v9ses->uid = ~0; 191 v9ses->dfltuid = V9FS_DEFUID; 192 v9ses->dfltgid = V9FS_DEFGID; 193 v9ses->options = kstrdup(data, GFP_KERNEL); 194 v9fs_parse_options(v9ses); 195 196 v9ses->clnt = p9_client_create(dev_name, v9ses->options); 197 198 if (IS_ERR(v9ses->clnt)) { 199 retval = PTR_ERR(v9ses->clnt); 200 v9ses->clnt = NULL; 201 P9_DPRINTK(P9_DEBUG_ERROR, "problem initializing 9p client\n"); 202 goto error; 203 } 204 205 if (!v9ses->clnt->dotu) 206 v9ses->flags &= ~V9FS_EXTENDED; 207 208 v9ses->maxdata = v9ses->clnt->msize; 209 210 /* for legacy mode, fall back to V9FS_ACCESS_ANY */ 211 if (!v9fs_extended(v9ses) && 212 ((v9ses->flags&V9FS_ACCESS_MASK) == V9FS_ACCESS_USER)) { 213 214 v9ses->flags &= ~V9FS_ACCESS_MASK; 215 v9ses->flags |= V9FS_ACCESS_ANY; 216 v9ses->uid = ~0; 217 } 218 219 fid = p9_client_attach(v9ses->clnt, NULL, v9ses->uname, ~0, 220 v9ses->aname); 221 if (IS_ERR(fid)) { 222 retval = PTR_ERR(fid); 223 fid = NULL; 224 P9_DPRINTK(P9_DEBUG_ERROR, "cannot attach\n"); 225 goto error; 226 } 227 228 if ((v9ses->flags & V9FS_ACCESS_MASK) == V9FS_ACCESS_SINGLE) 229 fid->uid = v9ses->uid; 230 else 231 fid->uid = ~0; 232 233 return fid; 234 235 error: 236 v9fs_session_close(v9ses); 237 return ERR_PTR(retval); 238 } 239 240 /** 241 * v9fs_session_close - shutdown a session 242 * @v9ses: session information structure 243 * 244 */ 245 246 void v9fs_session_close(struct v9fs_session_info *v9ses) 247 { 248 if (v9ses->clnt) { 249 p9_client_destroy(v9ses->clnt); 250 v9ses->clnt = NULL; 251 } 252 253 __putname(v9ses->uname); 254 __putname(v9ses->aname); 255 kfree(v9ses->options); 256 } 257 258 /** 259 * v9fs_session_cancel - mark transport as disconnected 260 * and cancel all pending requests. 261 */ 262 void v9fs_session_cancel(struct v9fs_session_info *v9ses) { 263 P9_DPRINTK(P9_DEBUG_ERROR, "cancel session %p\n", v9ses); 264 p9_client_disconnect(v9ses->clnt); 265 } 266 267 extern int v9fs_error_init(void); 268 269 /** 270 * v9fs_init - Initialize module 271 * 272 */ 273 274 static int __init init_v9fs(void) 275 { 276 printk(KERN_INFO "Installing v9fs 9p2000 file system support\n"); 277 /* TODO: Setup list of registered trasnport modules */ 278 return register_filesystem(&v9fs_fs_type); 279 } 280 281 /** 282 * v9fs_init - shutdown module 283 * 284 */ 285 286 static void __exit exit_v9fs(void) 287 { 288 unregister_filesystem(&v9fs_fs_type); 289 } 290 291 module_init(init_v9fs) 292 module_exit(exit_v9fs) 293 294 MODULE_AUTHOR("Latchesar Ionkov <lucho@ionkov.net>"); 295 MODULE_AUTHOR("Eric Van Hensbergen <ericvh@gmail.com>"); 296 MODULE_AUTHOR("Ron Minnich <rminnich@lanl.gov>"); 297 MODULE_LICENSE("GPL"); 298