xref: /openbmc/linux/net/9p/client.c (revision 9ac8d3fb)
1 /*
2  * net/9p/clnt.c
3  *
4  * 9P Client
5  *
6  *  Copyright (C) 2008 by Eric Van Hensbergen <ericvh@gmail.com>
7  *  Copyright (C) 2007 by Latchesar Ionkov <lucho@ionkov.net>
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/poll.h>
30 #include <linux/idr.h>
31 #include <linux/mutex.h>
32 #include <linux/sched.h>
33 #include <linux/uaccess.h>
34 #include <net/9p/9p.h>
35 #include <linux/parser.h>
36 #include <net/9p/client.h>
37 #include <net/9p/transport.h>
38 #include "protocol.h"
39 
40 /*
41   * Client Option Parsing (code inspired by NFS code)
42   *  - a little lazy - parse all client options
43   */
44 
45 enum {
46 	Opt_msize,
47 	Opt_trans,
48 	Opt_legacy,
49 	Opt_err,
50 };
51 
52 static const match_table_t tokens = {
53 	{Opt_msize, "msize=%u"},
54 	{Opt_legacy, "noextend"},
55 	{Opt_trans, "trans=%s"},
56 	{Opt_err, NULL},
57 };
58 
59 static struct p9_req_t *
60 p9_client_rpc(struct p9_client *c, int8_t type, const char *fmt, ...);
61 
62 /**
63  * v9fs_parse_options - parse mount options into session structure
64  * @options: options string passed from mount
65  * @v9ses: existing v9fs session information
66  *
67  * Return 0 upon success, -ERRNO upon failure
68  */
69 
70 static int parse_opts(char *opts, struct p9_client *clnt)
71 {
72 	char *options;
73 	char *p;
74 	substring_t args[MAX_OPT_ARGS];
75 	int option;
76 	int ret = 0;
77 
78 	clnt->dotu = 1;
79 	clnt->msize = 8192;
80 
81 	if (!opts)
82 		return 0;
83 
84 	options = kstrdup(opts, GFP_KERNEL);
85 	if (!options) {
86 		P9_DPRINTK(P9_DEBUG_ERROR,
87 				"failed to allocate copy of option string\n");
88 		return -ENOMEM;
89 	}
90 
91 	while ((p = strsep(&options, ",")) != NULL) {
92 		int token;
93 		if (!*p)
94 			continue;
95 		token = match_token(p, tokens, args);
96 		if (token < Opt_trans) {
97 			int r = match_int(&args[0], &option);
98 			if (r < 0) {
99 				P9_DPRINTK(P9_DEBUG_ERROR,
100 					"integer field, but no integer?\n");
101 				ret = r;
102 				continue;
103 			}
104 		}
105 		switch (token) {
106 		case Opt_msize:
107 			clnt->msize = option;
108 			break;
109 		case Opt_trans:
110 			clnt->trans_mod = v9fs_get_trans_by_name(&args[0]);
111 			break;
112 		case Opt_legacy:
113 			clnt->dotu = 0;
114 			break;
115 		default:
116 			continue;
117 		}
118 	}
119 
120 	if (!clnt->trans_mod)
121 		clnt->trans_mod = v9fs_get_default_trans();
122 
123 	kfree(options);
124 	return ret;
125 }
126 
127 /**
128  * p9_tag_alloc - lookup/allocate a request by tag
129  * @c: client session to lookup tag within
130  * @tag: numeric id for transaction
131  *
132  * this is a simple array lookup, but will grow the
133  * request_slots as necessary to accomodate transaction
134  * ids which did not previously have a slot.
135  *
136  * this code relies on the client spinlock to manage locks, its
137  * possible we should switch to something else, but I'd rather
138  * stick with something low-overhead for the common case.
139  *
140  */
141 
142 static struct p9_req_t *p9_tag_alloc(struct p9_client *c, u16 tag)
143 {
144 	unsigned long flags;
145 	int row, col;
146 	struct p9_req_t *req;
147 
148 	/* This looks up the original request by tag so we know which
149 	 * buffer to read the data into */
150 	tag++;
151 
152 	if (tag >= c->max_tag) {
153 		spin_lock_irqsave(&c->lock, flags);
154 		/* check again since original check was outside of lock */
155 		while (tag >= c->max_tag) {
156 			row = (tag / P9_ROW_MAXTAG);
157 			c->reqs[row] = kcalloc(P9_ROW_MAXTAG,
158 					sizeof(struct p9_req_t), GFP_ATOMIC);
159 
160 			if (!c->reqs[row]) {
161 				printk(KERN_ERR "Couldn't grow tag array\n");
162 				spin_unlock_irqrestore(&c->lock, flags);
163 				return ERR_PTR(-ENOMEM);
164 			}
165 			for (col = 0; col < P9_ROW_MAXTAG; col++) {
166 				c->reqs[row][col].status = REQ_STATUS_IDLE;
167 				c->reqs[row][col].tc = NULL;
168 			}
169 			c->max_tag += P9_ROW_MAXTAG;
170 		}
171 		spin_unlock_irqrestore(&c->lock, flags);
172 	}
173 	row = tag / P9_ROW_MAXTAG;
174 	col = tag % P9_ROW_MAXTAG;
175 
176 	req = &c->reqs[row][col];
177 	if (!req->tc) {
178 		req->wq = kmalloc(sizeof(wait_queue_head_t), GFP_KERNEL);
179 		if (!req->wq) {
180 			printk(KERN_ERR "Couldn't grow tag array\n");
181 			return ERR_PTR(-ENOMEM);
182 		}
183 		init_waitqueue_head(req->wq);
184 		req->tc = kmalloc(sizeof(struct p9_fcall)+c->msize,
185 								GFP_KERNEL);
186 		req->rc = kmalloc(sizeof(struct p9_fcall)+c->msize,
187 								GFP_KERNEL);
188 		if ((!req->tc) || (!req->rc)) {
189 			printk(KERN_ERR "Couldn't grow tag array\n");
190 			kfree(req->tc);
191 			kfree(req->rc);
192 			return ERR_PTR(-ENOMEM);
193 		}
194 		req->tc->sdata = (char *) req->tc + sizeof(struct p9_fcall);
195 		req->tc->capacity = c->msize;
196 		req->rc->sdata = (char *) req->rc + sizeof(struct p9_fcall);
197 		req->rc->capacity = c->msize;
198 	}
199 
200 	p9pdu_reset(req->tc);
201 	p9pdu_reset(req->rc);
202 
203 	req->flush_tag = 0;
204 	req->tc->tag = tag-1;
205 	req->status = REQ_STATUS_ALLOC;
206 
207 	return &c->reqs[row][col];
208 }
209 
210 /**
211  * p9_tag_lookup - lookup a request by tag
212  * @c: client session to lookup tag within
213  * @tag: numeric id for transaction
214  *
215  */
216 
217 struct p9_req_t *p9_tag_lookup(struct p9_client *c, u16 tag)
218 {
219 	int row, col;
220 
221 	/* This looks up the original request by tag so we know which
222 	 * buffer to read the data into */
223 	tag++;
224 
225 	BUG_ON(tag >= c->max_tag);
226 
227 	row = tag / P9_ROW_MAXTAG;
228 	col = tag % P9_ROW_MAXTAG;
229 
230 	return &c->reqs[row][col];
231 }
232 EXPORT_SYMBOL(p9_tag_lookup);
233 
234 /**
235  * p9_tag_init - setup tags structure and contents
236  * @tags: tags structure from the client struct
237  *
238  * This initializes the tags structure for each client instance.
239  *
240  */
241 
242 static int p9_tag_init(struct p9_client *c)
243 {
244 	int err = 0;
245 
246 	c->tagpool = p9_idpool_create();
247 	if (IS_ERR(c->tagpool)) {
248 		err = PTR_ERR(c->tagpool);
249 		c->tagpool = NULL;
250 		goto error;
251 	}
252 
253 	p9_idpool_get(c->tagpool); /* reserve tag 0 */
254 
255 	c->max_tag = 0;
256 error:
257 	return err;
258 }
259 
260 /**
261  * p9_tag_cleanup - cleans up tags structure and reclaims resources
262  * @tags: tags structure from the client struct
263  *
264  * This frees resources associated with the tags structure
265  *
266  */
267 static void p9_tag_cleanup(struct p9_client *c)
268 {
269 	int row, col;
270 
271 	/* check to insure all requests are idle */
272 	for (row = 0; row < (c->max_tag/P9_ROW_MAXTAG); row++) {
273 		for (col = 0; col < P9_ROW_MAXTAG; col++) {
274 			if (c->reqs[row][col].status != REQ_STATUS_IDLE) {
275 				P9_DPRINTK(P9_DEBUG_MUX,
276 				  "Attempting to cleanup non-free tag %d,%d\n",
277 				  row, col);
278 				/* TODO: delay execution of cleanup */
279 				return;
280 			}
281 		}
282 	}
283 
284 	if (c->tagpool)
285 		p9_idpool_destroy(c->tagpool);
286 
287 	/* free requests associated with tags */
288 	for (row = 0; row < (c->max_tag/P9_ROW_MAXTAG); row++) {
289 		for (col = 0; col < P9_ROW_MAXTAG; col++) {
290 			kfree(c->reqs[row][col].wq);
291 			kfree(c->reqs[row][col].tc);
292 			kfree(c->reqs[row][col].rc);
293 		}
294 		kfree(c->reqs[row]);
295 	}
296 	c->max_tag = 0;
297 }
298 
299 /**
300  * p9_free_req - free a request and clean-up as necessary
301  * c: client state
302  * r: request to release
303  *
304  */
305 
306 static void p9_free_req(struct p9_client *c, struct p9_req_t *r)
307 {
308 	int tag = r->tc->tag;
309 	P9_DPRINTK(P9_DEBUG_MUX, "clnt %p req %p tag: %d\n", c, r, tag);
310 
311 	r->status = REQ_STATUS_IDLE;
312 	if (tag != P9_NOTAG && p9_idpool_check(tag, c->tagpool))
313 		p9_idpool_put(tag, c->tagpool);
314 
315 	/* if this was a flush request we have to free response fcall */
316 	if (r->rc->id == P9_RFLUSH) {
317 		kfree(r->tc);
318 		kfree(r->rc);
319 	}
320 }
321 
322 /**
323  * p9_client_cb - call back from transport to client
324  * c: client state
325  * req: request received
326  *
327  */
328 void p9_client_cb(struct p9_client *c, struct p9_req_t *req)
329 {
330 	struct p9_req_t *other_req;
331 	unsigned long flags;
332 
333 	P9_DPRINTK(P9_DEBUG_MUX, " tag %d\n", req->tc->tag);
334 
335 	if (req->status == REQ_STATUS_ERROR)
336 		wake_up(req->wq);
337 
338 	if (req->flush_tag) { 			/* flush receive path */
339 		P9_DPRINTK(P9_DEBUG_9P, "<<< RFLUSH %d\n", req->tc->tag);
340 		spin_lock_irqsave(&c->lock, flags);
341 		other_req = p9_tag_lookup(c, req->flush_tag);
342 		if (other_req->status != REQ_STATUS_FLSH) /* stale flush */
343 			spin_unlock_irqrestore(&c->lock, flags);
344 		else {
345 			other_req->status = REQ_STATUS_FLSHD;
346 			spin_unlock_irqrestore(&c->lock, flags);
347 			wake_up(other_req->wq);
348 		}
349 		p9_free_req(c, req);
350 	} else { 				/* normal receive path */
351 		P9_DPRINTK(P9_DEBUG_MUX, "normal: tag %d\n", req->tc->tag);
352 		spin_lock_irqsave(&c->lock, flags);
353 		if (req->status != REQ_STATUS_FLSHD)
354 			req->status = REQ_STATUS_RCVD;
355 		spin_unlock_irqrestore(&c->lock, flags);
356 		wake_up(req->wq);
357 		P9_DPRINTK(P9_DEBUG_MUX, "wakeup: %d\n", req->tc->tag);
358 	}
359 }
360 EXPORT_SYMBOL(p9_client_cb);
361 
362 /**
363  * p9_parse_header - parse header arguments out of a packet
364  * @pdu: packet to parse
365  * @size: size of packet
366  * @type: type of request
367  * @tag: tag of packet
368  * @rewind: set if we need to rewind offset afterwards
369  */
370 
371 int
372 p9_parse_header(struct p9_fcall *pdu, int32_t *size, int8_t *type, int16_t *tag,
373 								int rewind)
374 {
375 	int8_t r_type;
376 	int16_t r_tag;
377 	int32_t r_size;
378 	int offset = pdu->offset;
379 	int err;
380 
381 	pdu->offset = 0;
382 	if (pdu->size == 0)
383 		pdu->size = 7;
384 
385 	err = p9pdu_readf(pdu, 0, "dbw", &r_size, &r_type, &r_tag);
386 	if (err)
387 		goto rewind_and_exit;
388 
389 	pdu->size = r_size;
390 	pdu->id = r_type;
391 	pdu->tag = r_tag;
392 
393 	P9_DPRINTK(P9_DEBUG_9P, "<<< size=%d type: %d tag: %d\n", pdu->size,
394 							pdu->id, pdu->tag);
395 
396 	if (type)
397 		*type = r_type;
398 	if (tag)
399 		*tag = r_tag;
400 	if (size)
401 		*size = r_size;
402 
403 
404 rewind_and_exit:
405 	if (rewind)
406 		pdu->offset = offset;
407 	return err;
408 }
409 EXPORT_SYMBOL(p9_parse_header);
410 
411 /**
412  * p9_check_errors - check 9p packet for error return and process it
413  * @c: current client instance
414  * @req: request to parse and check for error conditions
415  *
416  * returns error code if one is discovered, otherwise returns 0
417  *
418  * this will have to be more complicated if we have multiple
419  * error packet types
420  */
421 
422 static int p9_check_errors(struct p9_client *c, struct p9_req_t *req)
423 {
424 	int8_t type;
425 	int err;
426 
427 	err = p9_parse_header(req->rc, NULL, &type, NULL, 0);
428 	if (err) {
429 		P9_DPRINTK(P9_DEBUG_ERROR, "couldn't parse header %d\n", err);
430 		return err;
431 	}
432 
433 	if (type == P9_RERROR) {
434 		int ecode;
435 		char *ename;
436 
437 		err = p9pdu_readf(req->rc, c->dotu, "s?d", &ename, &ecode);
438 		if (err) {
439 			P9_DPRINTK(P9_DEBUG_ERROR, "couldn't parse error%d\n",
440 									err);
441 			return err;
442 		}
443 
444 		if (c->dotu)
445 			err = -ecode;
446 
447 		if (!err) {
448 			err = p9_errstr2errno(ename, strlen(ename));
449 
450 			/* string match failed */
451 			if (!err)
452 				err = -ESERVERFAULT;
453 		}
454 
455 		P9_DPRINTK(P9_DEBUG_9P, "<<< RERROR (%d) %s\n", -ecode, ename);
456 
457 		kfree(ename);
458 	} else
459 		err = 0;
460 
461 	return err;
462 }
463 
464 /**
465  * p9_client_flush - flush (cancel) a request
466  * c: client state
467  * req: request to cancel
468  *
469  * This sents a flush for a particular requests and links
470  * the flush request to the original request.  The current
471  * code only supports a single flush request although the protocol
472  * allows for multiple flush requests to be sent for a single request.
473  *
474  */
475 
476 static int p9_client_flush(struct p9_client *c, struct p9_req_t *oldreq)
477 {
478 	struct p9_req_t *req;
479 	int16_t oldtag;
480 	int err;
481 
482 	err = p9_parse_header(oldreq->tc, NULL, NULL, &oldtag, 1);
483 	if (err)
484 		return err;
485 
486 	P9_DPRINTK(P9_DEBUG_9P, ">>> TFLUSH tag %d\n", oldtag);
487 
488 	req = p9_client_rpc(c, P9_TFLUSH, "w", oldtag);
489 	if (IS_ERR(req))
490 		return PTR_ERR(req);
491 
492 	req->flush_tag = oldtag;
493 
494 	/* we don't free anything here because RPC isn't complete */
495 	return 0;
496 }
497 
498 /**
499  * p9_client_rpc - issue a request and wait for a response
500  * @c: client session
501  * @type: type of request
502  * @fmt: protocol format string (see protocol.c)
503  *
504  * Returns request structure (which client must free using p9_free_req)
505  */
506 
507 static struct p9_req_t *
508 p9_client_rpc(struct p9_client *c, int8_t type, const char *fmt, ...)
509 {
510 	va_list ap;
511 	int tag, err;
512 	struct p9_req_t *req;
513 	unsigned long flags;
514 	int sigpending;
515 	int flushed = 0;
516 
517 	P9_DPRINTK(P9_DEBUG_MUX, "client %p op %d\n", c, type);
518 
519 	if (c->status != Connected)
520 		return ERR_PTR(-EIO);
521 
522 	if (signal_pending(current)) {
523 		sigpending = 1;
524 		clear_thread_flag(TIF_SIGPENDING);
525 	} else
526 		sigpending = 0;
527 
528 	tag = P9_NOTAG;
529 	if (type != P9_TVERSION) {
530 		tag = p9_idpool_get(c->tagpool);
531 		if (tag < 0)
532 			return ERR_PTR(-ENOMEM);
533 	}
534 
535 	req = p9_tag_alloc(c, tag);
536 	if (IS_ERR(req))
537 		return req;
538 
539 	/* marshall the data */
540 	p9pdu_prepare(req->tc, tag, type);
541 	va_start(ap, fmt);
542 	err = p9pdu_vwritef(req->tc, c->dotu, fmt, ap);
543 	va_end(ap);
544 	p9pdu_finalize(req->tc);
545 
546 	err = c->trans_mod->request(c, req);
547 	if (err < 0) {
548 		c->status = Disconnected;
549 		goto reterr;
550 	}
551 
552 	/* if it was a flush we just transmitted, return our tag */
553 	if (type == P9_TFLUSH)
554 		return req;
555 again:
556 	P9_DPRINTK(P9_DEBUG_MUX, "wait %p tag: %d\n", req->wq, tag);
557 	err = wait_event_interruptible(*req->wq,
558 						req->status >= REQ_STATUS_RCVD);
559 	P9_DPRINTK(P9_DEBUG_MUX, "wait %p tag: %d returned %d (flushed=%d)\n",
560 						req->wq, tag, err, flushed);
561 
562 	if (req->status == REQ_STATUS_ERROR) {
563 		P9_DPRINTK(P9_DEBUG_ERROR, "req_status error %d\n", req->t_err);
564 		err = req->t_err;
565 	} else if (err == -ERESTARTSYS && flushed) {
566 		P9_DPRINTK(P9_DEBUG_MUX, "flushed - going again\n");
567 		goto again;
568 	} else if (req->status == REQ_STATUS_FLSHD) {
569 		P9_DPRINTK(P9_DEBUG_MUX, "flushed - erestartsys\n");
570 		err = -ERESTARTSYS;
571 	}
572 
573 	if ((err == -ERESTARTSYS) && (c->status == Connected) && (!flushed)) {
574 		P9_DPRINTK(P9_DEBUG_MUX, "flushing\n");
575 		spin_lock_irqsave(&c->lock, flags);
576 		if (req->status == REQ_STATUS_SENT)
577 			req->status = REQ_STATUS_FLSH;
578 		spin_unlock_irqrestore(&c->lock, flags);
579 		sigpending = 1;
580 		flushed = 1;
581 		clear_thread_flag(TIF_SIGPENDING);
582 
583 		if (c->trans_mod->cancel(c, req)) {
584 			err = p9_client_flush(c, req);
585 			if (err == 0)
586 				goto again;
587 		}
588 	}
589 
590 	if (sigpending) {
591 		spin_lock_irqsave(&current->sighand->siglock, flags);
592 		recalc_sigpending();
593 		spin_unlock_irqrestore(&current->sighand->siglock, flags);
594 	}
595 
596 	if (err < 0)
597 		goto reterr;
598 
599 	err = p9_check_errors(c, req);
600 	if (!err) {
601 		P9_DPRINTK(P9_DEBUG_MUX, "exit: client %p op %d\n", c, type);
602 		return req;
603 	}
604 
605 reterr:
606 	P9_DPRINTK(P9_DEBUG_MUX, "exit: client %p op %d error: %d\n", c, type,
607 									err);
608 	p9_free_req(c, req);
609 	return ERR_PTR(err);
610 }
611 
612 static struct p9_fid *p9_fid_create(struct p9_client *clnt)
613 {
614 	int err;
615 	struct p9_fid *fid;
616 
617 	P9_DPRINTK(P9_DEBUG_FID, "clnt %p\n", clnt);
618 	fid = kmalloc(sizeof(struct p9_fid), GFP_KERNEL);
619 	if (!fid)
620 		return ERR_PTR(-ENOMEM);
621 
622 	fid->fid = p9_idpool_get(clnt->fidpool);
623 	if (fid->fid < 0) {
624 		err = -ENOSPC;
625 		goto error;
626 	}
627 
628 	memset(&fid->qid, 0, sizeof(struct p9_qid));
629 	fid->mode = -1;
630 	fid->rdir_fpos = 0;
631 	fid->uid = current->fsuid;
632 	fid->clnt = clnt;
633 	fid->aux = NULL;
634 
635 	spin_lock(&clnt->lock);
636 	list_add(&fid->flist, &clnt->fidlist);
637 	spin_unlock(&clnt->lock);
638 
639 	return fid;
640 
641 error:
642 	kfree(fid);
643 	return ERR_PTR(err);
644 }
645 
646 static void p9_fid_destroy(struct p9_fid *fid)
647 {
648 	struct p9_client *clnt;
649 
650 	P9_DPRINTK(P9_DEBUG_FID, "fid %d\n", fid->fid);
651 	clnt = fid->clnt;
652 	p9_idpool_put(fid->fid, clnt->fidpool);
653 	spin_lock(&clnt->lock);
654 	list_del(&fid->flist);
655 	spin_unlock(&clnt->lock);
656 	kfree(fid);
657 }
658 
659 int p9_client_version(struct p9_client *c)
660 {
661 	int err = 0;
662 	struct p9_req_t *req;
663 	char *version;
664 	int msize;
665 
666 	P9_DPRINTK(P9_DEBUG_9P, ">>> TVERSION msize %d extended %d\n",
667 							c->msize, c->dotu);
668 	req = p9_client_rpc(c, P9_TVERSION, "ds", c->msize,
669 				c->dotu ? "9P2000.u" : "9P2000");
670 	if (IS_ERR(req))
671 		return PTR_ERR(req);
672 
673 	err = p9pdu_readf(req->rc, c->dotu, "ds", &msize, &version);
674 	if (err) {
675 		P9_DPRINTK(P9_DEBUG_9P, "version error %d\n", err);
676 		p9pdu_dump(1, req->rc);
677 		goto error;
678 	}
679 
680 	P9_DPRINTK(P9_DEBUG_9P, "<<< RVERSION msize %d %s\n", msize, version);
681 	if (!memcmp(version, "9P2000.u", 8))
682 		c->dotu = 1;
683 	else if (!memcmp(version, "9P2000", 6))
684 		c->dotu = 0;
685 	else {
686 		err = -EREMOTEIO;
687 		goto error;
688 	}
689 
690 	if (msize < c->msize)
691 		c->msize = msize;
692 
693 error:
694 	kfree(version);
695 	p9_free_req(c, req);
696 
697 	return err;
698 }
699 EXPORT_SYMBOL(p9_client_version);
700 
701 struct p9_client *p9_client_create(const char *dev_name, char *options)
702 {
703 	int err;
704 	struct p9_client *clnt;
705 
706 	err = 0;
707 	clnt = kmalloc(sizeof(struct p9_client), GFP_KERNEL);
708 	if (!clnt)
709 		return ERR_PTR(-ENOMEM);
710 
711 	clnt->trans_mod = NULL;
712 	clnt->trans = NULL;
713 	spin_lock_init(&clnt->lock);
714 	INIT_LIST_HEAD(&clnt->fidlist);
715 	clnt->fidpool = p9_idpool_create();
716 	if (IS_ERR(clnt->fidpool)) {
717 		err = PTR_ERR(clnt->fidpool);
718 		clnt->fidpool = NULL;
719 		goto error;
720 	}
721 
722 	p9_tag_init(clnt);
723 
724 	err = parse_opts(options, clnt);
725 	if (err < 0)
726 		goto error;
727 
728 	if (clnt->trans_mod == NULL) {
729 		err = -EPROTONOSUPPORT;
730 		P9_DPRINTK(P9_DEBUG_ERROR,
731 				"No transport defined or default transport\n");
732 		goto error;
733 	}
734 
735 	P9_DPRINTK(P9_DEBUG_MUX, "clnt %p trans %p msize %d dotu %d\n",
736 		clnt, clnt->trans_mod, clnt->msize, clnt->dotu);
737 
738 	err = clnt->trans_mod->create(clnt, dev_name, options);
739 	if (err)
740 		goto error;
741 
742 	if ((clnt->msize+P9_IOHDRSZ) > clnt->trans_mod->maxsize)
743 		clnt->msize = clnt->trans_mod->maxsize-P9_IOHDRSZ;
744 
745 	err = p9_client_version(clnt);
746 	if (err)
747 		goto error;
748 
749 	return clnt;
750 
751 error:
752 	p9_client_destroy(clnt);
753 	return ERR_PTR(err);
754 }
755 EXPORT_SYMBOL(p9_client_create);
756 
757 void p9_client_destroy(struct p9_client *clnt)
758 {
759 	struct p9_fid *fid, *fidptr;
760 
761 	P9_DPRINTK(P9_DEBUG_MUX, "clnt %p\n", clnt);
762 
763 	if (clnt->trans_mod)
764 		clnt->trans_mod->close(clnt);
765 
766 	v9fs_put_trans(clnt->trans_mod);
767 
768 	list_for_each_entry_safe(fid, fidptr, &clnt->fidlist, flist)
769 		p9_fid_destroy(fid);
770 
771 	if (clnt->fidpool)
772 		p9_idpool_destroy(clnt->fidpool);
773 
774 	p9_tag_cleanup(clnt);
775 
776 	kfree(clnt);
777 }
778 EXPORT_SYMBOL(p9_client_destroy);
779 
780 void p9_client_disconnect(struct p9_client *clnt)
781 {
782 	P9_DPRINTK(P9_DEBUG_9P, "clnt %p\n", clnt);
783 	clnt->status = Disconnected;
784 }
785 EXPORT_SYMBOL(p9_client_disconnect);
786 
787 struct p9_fid *p9_client_attach(struct p9_client *clnt, struct p9_fid *afid,
788 	char *uname, u32 n_uname, char *aname)
789 {
790 	int err;
791 	struct p9_req_t *req;
792 	struct p9_fid *fid;
793 	struct p9_qid qid;
794 
795 	P9_DPRINTK(P9_DEBUG_9P, ">>> TATTACH afid %d uname %s aname %s\n",
796 					afid ? afid->fid : -1, uname, aname);
797 	err = 0;
798 
799 	fid = p9_fid_create(clnt);
800 	if (IS_ERR(fid)) {
801 		err = PTR_ERR(fid);
802 		fid = NULL;
803 		goto error;
804 	}
805 
806 	req = p9_client_rpc(clnt, P9_TATTACH, "ddss?d", fid->fid,
807 			afid ? afid->fid : P9_NOFID, uname, aname, n_uname);
808 	if (IS_ERR(req)) {
809 		err = PTR_ERR(req);
810 		goto error;
811 	}
812 
813 	err = p9pdu_readf(req->rc, clnt->dotu, "Q", &qid);
814 	if (err) {
815 		p9pdu_dump(1, req->rc);
816 		p9_free_req(clnt, req);
817 		goto error;
818 	}
819 
820 	P9_DPRINTK(P9_DEBUG_9P, "<<< RATTACH qid %x.%llx.%x\n",
821 					qid.type, qid.path, qid.version);
822 
823 	memmove(&fid->qid, &qid, sizeof(struct p9_qid));
824 
825 	p9_free_req(clnt, req);
826 	return fid;
827 
828 error:
829 	if (fid)
830 		p9_fid_destroy(fid);
831 	return ERR_PTR(err);
832 }
833 EXPORT_SYMBOL(p9_client_attach);
834 
835 struct p9_fid *
836 p9_client_auth(struct p9_client *clnt, char *uname, u32 n_uname, char *aname)
837 {
838 	int err;
839 	struct p9_req_t *req;
840 	struct p9_qid qid;
841 	struct p9_fid *afid;
842 
843 	P9_DPRINTK(P9_DEBUG_9P, ">>> TAUTH uname %s aname %s\n", uname, aname);
844 	err = 0;
845 
846 	afid = p9_fid_create(clnt);
847 	if (IS_ERR(afid)) {
848 		err = PTR_ERR(afid);
849 		afid = NULL;
850 		goto error;
851 	}
852 
853 	req = p9_client_rpc(clnt, P9_TAUTH, "dss?d",
854 			afid ? afid->fid : P9_NOFID, uname, aname, n_uname);
855 	if (IS_ERR(req)) {
856 		err = PTR_ERR(req);
857 		goto error;
858 	}
859 
860 	err = p9pdu_readf(req->rc, clnt->dotu, "Q", &qid);
861 	if (err) {
862 		p9pdu_dump(1, req->rc);
863 		p9_free_req(clnt, req);
864 		goto error;
865 	}
866 
867 	P9_DPRINTK(P9_DEBUG_9P, "<<< RAUTH qid %x.%llx.%x\n",
868 					qid.type, qid.path, qid.version);
869 
870 	memmove(&afid->qid, &qid, sizeof(struct p9_qid));
871 	p9_free_req(clnt, req);
872 	return afid;
873 
874 error:
875 	if (afid)
876 		p9_fid_destroy(afid);
877 	return ERR_PTR(err);
878 }
879 EXPORT_SYMBOL(p9_client_auth);
880 
881 struct p9_fid *p9_client_walk(struct p9_fid *oldfid, int nwname, char **wnames,
882 	int clone)
883 {
884 	int err;
885 	struct p9_client *clnt;
886 	struct p9_fid *fid;
887 	struct p9_qid *wqids;
888 	struct p9_req_t *req;
889 	int16_t nwqids, count;
890 
891 	err = 0;
892 	clnt = oldfid->clnt;
893 	if (clone) {
894 		fid = p9_fid_create(clnt);
895 		if (IS_ERR(fid)) {
896 			err = PTR_ERR(fid);
897 			fid = NULL;
898 			goto error;
899 		}
900 
901 		fid->uid = oldfid->uid;
902 	} else
903 		fid = oldfid;
904 
905 
906 	P9_DPRINTK(P9_DEBUG_9P, ">>> TWALK fids %d,%d nwname %d wname[0] %s\n",
907 		oldfid->fid, fid->fid, nwname, wnames ? wnames[0] : NULL);
908 
909 	req = p9_client_rpc(clnt, P9_TWALK, "ddT", oldfid->fid, fid->fid,
910 								nwname, wnames);
911 	if (IS_ERR(req)) {
912 		err = PTR_ERR(req);
913 		goto error;
914 	}
915 
916 	err = p9pdu_readf(req->rc, clnt->dotu, "R", &nwqids, &wqids);
917 	if (err) {
918 		p9pdu_dump(1, req->rc);
919 		p9_free_req(clnt, req);
920 		goto clunk_fid;
921 	}
922 	p9_free_req(clnt, req);
923 
924 	P9_DPRINTK(P9_DEBUG_9P, "<<< RWALK nwqid %d:\n", nwqids);
925 
926 	if (nwqids != nwname) {
927 		err = -ENOENT;
928 		goto clunk_fid;
929 	}
930 
931 	for (count = 0; count < nwqids; count++)
932 		P9_DPRINTK(P9_DEBUG_9P, "<<<     [%d] %x.%llx.%x\n",
933 			count, wqids[count].type, wqids[count].path,
934 			wqids[count].version);
935 
936 	if (nwname)
937 		memmove(&fid->qid, &wqids[nwqids - 1], sizeof(struct p9_qid));
938 	else
939 		fid->qid = oldfid->qid;
940 
941 	return fid;
942 
943 clunk_fid:
944 	p9_client_clunk(fid);
945 	fid = NULL;
946 
947 error:
948 	if (fid && (fid != oldfid))
949 		p9_fid_destroy(fid);
950 
951 	return ERR_PTR(err);
952 }
953 EXPORT_SYMBOL(p9_client_walk);
954 
955 int p9_client_open(struct p9_fid *fid, int mode)
956 {
957 	int err;
958 	struct p9_client *clnt;
959 	struct p9_req_t *req;
960 	struct p9_qid qid;
961 	int iounit;
962 
963 	P9_DPRINTK(P9_DEBUG_9P, ">>> TOPEN fid %d mode %d\n", fid->fid, mode);
964 	err = 0;
965 	clnt = fid->clnt;
966 
967 	if (fid->mode != -1)
968 		return -EINVAL;
969 
970 	req = p9_client_rpc(clnt, P9_TOPEN, "db", fid->fid, mode);
971 	if (IS_ERR(req)) {
972 		err = PTR_ERR(req);
973 		goto error;
974 	}
975 
976 	err = p9pdu_readf(req->rc, clnt->dotu, "Qd", &qid, &iounit);
977 	if (err) {
978 		p9pdu_dump(1, req->rc);
979 		goto free_and_error;
980 	}
981 
982 	P9_DPRINTK(P9_DEBUG_9P, "<<< ROPEN qid %x.%llx.%x iounit %x\n",
983 				qid.type, qid.path, qid.version, iounit);
984 
985 	fid->mode = mode;
986 	fid->iounit = iounit;
987 
988 free_and_error:
989 	p9_free_req(clnt, req);
990 error:
991 	return err;
992 }
993 EXPORT_SYMBOL(p9_client_open);
994 
995 int p9_client_fcreate(struct p9_fid *fid, char *name, u32 perm, int mode,
996 		     char *extension)
997 {
998 	int err;
999 	struct p9_client *clnt;
1000 	struct p9_req_t *req;
1001 	struct p9_qid qid;
1002 	int iounit;
1003 
1004 	P9_DPRINTK(P9_DEBUG_9P, ">>> TCREATE fid %d name %s perm %d mode %d\n",
1005 						fid->fid, name, perm, mode);
1006 	err = 0;
1007 	clnt = fid->clnt;
1008 
1009 	if (fid->mode != -1)
1010 		return -EINVAL;
1011 
1012 	req = p9_client_rpc(clnt, P9_TCREATE, "dsdb?s", fid->fid, name, perm,
1013 				mode, extension);
1014 	if (IS_ERR(req)) {
1015 		err = PTR_ERR(req);
1016 		goto error;
1017 	}
1018 
1019 	err = p9pdu_readf(req->rc, clnt->dotu, "Qd", &qid, &iounit);
1020 	if (err) {
1021 		p9pdu_dump(1, req->rc);
1022 		goto free_and_error;
1023 	}
1024 
1025 	P9_DPRINTK(P9_DEBUG_9P, "<<< RCREATE qid %x.%llx.%x iounit %x\n",
1026 				qid.type, qid.path, qid.version, iounit);
1027 
1028 	fid->mode = mode;
1029 	fid->iounit = iounit;
1030 
1031 free_and_error:
1032 	p9_free_req(clnt, req);
1033 error:
1034 	return err;
1035 }
1036 EXPORT_SYMBOL(p9_client_fcreate);
1037 
1038 int p9_client_clunk(struct p9_fid *fid)
1039 {
1040 	int err;
1041 	struct p9_client *clnt;
1042 	struct p9_req_t *req;
1043 
1044 	P9_DPRINTK(P9_DEBUG_9P, ">>> TCLUNK fid %d\n", fid->fid);
1045 	err = 0;
1046 	clnt = fid->clnt;
1047 
1048 	req = p9_client_rpc(clnt, P9_TCLUNK, "d", fid->fid);
1049 	if (IS_ERR(req)) {
1050 		err = PTR_ERR(req);
1051 		goto error;
1052 	}
1053 
1054 	P9_DPRINTK(P9_DEBUG_9P, "<<< RCLUNK fid %d\n", fid->fid);
1055 
1056 	p9_free_req(clnt, req);
1057 	p9_fid_destroy(fid);
1058 
1059 error:
1060 	return err;
1061 }
1062 EXPORT_SYMBOL(p9_client_clunk);
1063 
1064 int p9_client_remove(struct p9_fid *fid)
1065 {
1066 	int err;
1067 	struct p9_client *clnt;
1068 	struct p9_req_t *req;
1069 
1070 	P9_DPRINTK(P9_DEBUG_9P, ">>> TREMOVE fid %d\n", fid->fid);
1071 	err = 0;
1072 	clnt = fid->clnt;
1073 
1074 	req = p9_client_rpc(clnt, P9_TREMOVE, "d", fid->fid);
1075 	if (IS_ERR(req)) {
1076 		err = PTR_ERR(req);
1077 		goto error;
1078 	}
1079 
1080 	P9_DPRINTK(P9_DEBUG_9P, "<<< RREMOVE fid %d\n", fid->fid);
1081 
1082 	p9_free_req(clnt, req);
1083 	p9_fid_destroy(fid);
1084 
1085 error:
1086 	return err;
1087 }
1088 EXPORT_SYMBOL(p9_client_remove);
1089 
1090 int
1091 p9_client_read(struct p9_fid *fid, char *data, char __user *udata, u64 offset,
1092 								u32 count)
1093 {
1094 	int err, rsize, total;
1095 	struct p9_client *clnt;
1096 	struct p9_req_t *req;
1097 	char *dataptr;
1098 
1099 	P9_DPRINTK(P9_DEBUG_9P, ">>> TREAD fid %d offset %llu %d\n", fid->fid,
1100 					(long long unsigned) offset, count);
1101 	err = 0;
1102 	clnt = fid->clnt;
1103 	total = 0;
1104 
1105 	rsize = fid->iounit;
1106 	if (!rsize || rsize > clnt->msize-P9_IOHDRSZ)
1107 		rsize = clnt->msize - P9_IOHDRSZ;
1108 
1109 	if (count < rsize)
1110 		rsize = count;
1111 
1112 	req = p9_client_rpc(clnt, P9_TREAD, "dqd", fid->fid, offset, rsize);
1113 	if (IS_ERR(req)) {
1114 		err = PTR_ERR(req);
1115 		goto error;
1116 	}
1117 
1118 	err = p9pdu_readf(req->rc, clnt->dotu, "D", &count, &dataptr);
1119 	if (err) {
1120 		p9pdu_dump(1, req->rc);
1121 		goto free_and_error;
1122 	}
1123 
1124 	P9_DPRINTK(P9_DEBUG_9P, "<<< RREAD count %d\n", count);
1125 
1126 	if (data) {
1127 		memmove(data, dataptr, count);
1128 		data += count;
1129 	}
1130 
1131 	if (udata) {
1132 		err = copy_to_user(udata, dataptr, count);
1133 		if (err) {
1134 			err = -EFAULT;
1135 			goto free_and_error;
1136 		}
1137 	}
1138 
1139 	p9_free_req(clnt, req);
1140 	return count;
1141 
1142 free_and_error:
1143 	p9_free_req(clnt, req);
1144 error:
1145 	return err;
1146 }
1147 EXPORT_SYMBOL(p9_client_read);
1148 
1149 int
1150 p9_client_write(struct p9_fid *fid, char *data, const char __user *udata,
1151 							u64 offset, u32 count)
1152 {
1153 	int err, rsize, total;
1154 	struct p9_client *clnt;
1155 	struct p9_req_t *req;
1156 
1157 	P9_DPRINTK(P9_DEBUG_9P, ">>> TWRITE fid %d offset %llu count %d\n",
1158 				fid->fid, (long long unsigned) offset, count);
1159 	err = 0;
1160 	clnt = fid->clnt;
1161 	total = 0;
1162 
1163 	rsize = fid->iounit;
1164 	if (!rsize || rsize > clnt->msize-P9_IOHDRSZ)
1165 		rsize = clnt->msize - P9_IOHDRSZ;
1166 
1167 	if (count < rsize)
1168 		rsize = count;
1169 	if (data)
1170 		req = p9_client_rpc(clnt, P9_TWRITE, "dqD", fid->fid, offset,
1171 								rsize, data);
1172 	else
1173 		req = p9_client_rpc(clnt, P9_TWRITE, "dqU", fid->fid, offset,
1174 								rsize, udata);
1175 	if (IS_ERR(req)) {
1176 		err = PTR_ERR(req);
1177 		goto error;
1178 	}
1179 
1180 	err = p9pdu_readf(req->rc, clnt->dotu, "d", &count);
1181 	if (err) {
1182 		p9pdu_dump(1, req->rc);
1183 		goto free_and_error;
1184 	}
1185 
1186 	P9_DPRINTK(P9_DEBUG_9P, "<<< RWRITE count %d\n", count);
1187 
1188 	p9_free_req(clnt, req);
1189 	return count;
1190 
1191 free_and_error:
1192 	p9_free_req(clnt, req);
1193 error:
1194 	return err;
1195 }
1196 EXPORT_SYMBOL(p9_client_write);
1197 
1198 struct p9_wstat *p9_client_stat(struct p9_fid *fid)
1199 {
1200 	int err;
1201 	struct p9_client *clnt;
1202 	struct p9_wstat *ret = kmalloc(sizeof(struct p9_wstat), GFP_KERNEL);
1203 	struct p9_req_t *req;
1204 	u16 ignored;
1205 
1206 	P9_DPRINTK(P9_DEBUG_9P, ">>> TSTAT fid %d\n", fid->fid);
1207 
1208 	if (!ret)
1209 		return ERR_PTR(-ENOMEM);
1210 
1211 	err = 0;
1212 	clnt = fid->clnt;
1213 
1214 	req = p9_client_rpc(clnt, P9_TSTAT, "d", fid->fid);
1215 	if (IS_ERR(req)) {
1216 		err = PTR_ERR(req);
1217 		goto error;
1218 	}
1219 
1220 	err = p9pdu_readf(req->rc, clnt->dotu, "wS", &ignored, ret);
1221 	if (err) {
1222 		ret = ERR_PTR(err);
1223 		p9pdu_dump(1, req->rc);
1224 		goto free_and_error;
1225 	}
1226 
1227 	P9_DPRINTK(P9_DEBUG_9P,
1228 		"<<< RSTAT sz=%x type=%x dev=%x qid=%x.%llx.%x\n"
1229 		"<<<    mode=%8.8x atime=%8.8x mtime=%8.8x length=%llx\n"
1230 		"<<<    name=%s uid=%s gid=%s muid=%s extension=(%s)\n"
1231 		"<<<    uid=%d gid=%d n_muid=%d\n",
1232 		ret->size, ret->type, ret->dev, ret->qid.type,
1233 		ret->qid.path, ret->qid.version, ret->mode,
1234 		ret->atime, ret->mtime, ret->length, ret->name,
1235 		ret->uid, ret->gid, ret->muid, ret->extension,
1236 		ret->n_uid, ret->n_gid, ret->n_muid);
1237 
1238 free_and_error:
1239 	p9_free_req(clnt, req);
1240 error:
1241 	return ret;
1242 }
1243 EXPORT_SYMBOL(p9_client_stat);
1244 
1245 int p9_client_wstat(struct p9_fid *fid, struct p9_wstat *wst)
1246 {
1247 	int err;
1248 	struct p9_req_t *req;
1249 	struct p9_client *clnt;
1250 
1251 	P9_DPRINTK(P9_DEBUG_9P, ">>> TWSTAT fid %d\n", fid->fid);
1252 	P9_DPRINTK(P9_DEBUG_9P,
1253 		"     sz=%x type=%x dev=%x qid=%x.%llx.%x\n"
1254 		"     mode=%8.8x atime=%8.8x mtime=%8.8x length=%llx\n"
1255 		"     name=%s uid=%s gid=%s muid=%s extension=(%s)\n"
1256 		"     uid=%d gid=%d n_muid=%d\n",
1257 		wst->size, wst->type, wst->dev, wst->qid.type,
1258 		wst->qid.path, wst->qid.version, wst->mode,
1259 		wst->atime, wst->mtime, wst->length, wst->name,
1260 		wst->uid, wst->gid, wst->muid, wst->extension,
1261 		wst->n_uid, wst->n_gid, wst->n_muid);
1262 	err = 0;
1263 	clnt = fid->clnt;
1264 
1265 	req = p9_client_rpc(clnt, P9_TWSTAT, "dwS", fid->fid, 0, wst);
1266 	if (IS_ERR(req)) {
1267 		err = PTR_ERR(req);
1268 		goto error;
1269 	}
1270 
1271 	P9_DPRINTK(P9_DEBUG_9P, "<<< RWSTAT fid %d\n", fid->fid);
1272 
1273 	p9_free_req(clnt, req);
1274 error:
1275 	return err;
1276 }
1277 EXPORT_SYMBOL(p9_client_wstat);
1278