client.c 27.2 KB
Newer Older
1 2 3 4 5
/*
 * net/9p/clnt.c
 *
 * 9P Client
 *
6
 *  Copyright (C) 2008 by Eric Van Hensbergen <ericvh@gmail.com>
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
 *  Copyright (C) 2007 by Latchesar Ionkov <lucho@ionkov.net>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License version 2
 *  as published by the Free Software Foundation.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to:
 *  Free Software Foundation
 *  51 Franklin Street, Fifth Floor
 *  Boston, MA  02111-1301  USA
 *
 */

#include <linux/module.h>
#include <linux/errno.h>
#include <linux/fs.h>
29
#include <linux/poll.h>
30 31 32 33 34
#include <linux/idr.h>
#include <linux/mutex.h>
#include <linux/sched.h>
#include <linux/uaccess.h>
#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 42 43 44 45 46 47 48 49 50 51
/*
  * Client Option Parsing (code inspired by NFS code)
  *  - a little lazy - parse all client options
  */

enum {
	Opt_msize,
	Opt_trans,
	Opt_legacy,
	Opt_err,
};

52
static const match_table_t tokens = {
53 54 55 56 57 58
	{Opt_msize, "msize=%u"},
	{Opt_legacy, "noextend"},
	{Opt_trans, "trans=%s"},
	{Opt_err, NULL},
};

59 60
static struct p9_req_t *
p9_client_rpc(struct p9_client *c, int8_t type, const char *fmt, ...);
61

62 63 64 65 66
/**
 * v9fs_parse_options - parse mount options into session structure
 * @options: options string passed from mount
 * @v9ses: existing v9fs session information
 *
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 74 75
	char *p;
	substring_t args[MAX_OPT_ARGS];
	int option;
76
	int ret = 0;
77 78 79 80

	clnt->dotu = 1;
	clnt->msize = 8192;

81 82 83 84 85 86 87 88 89
	if (!opts)
		return 0;

	options = kstrdup(opts, GFP_KERNEL);
	if (!options) {
		P9_DPRINTK(P9_DEBUG_ERROR,
				"failed to allocate copy of option string\n");
		return -ENOMEM;
	}
90 91 92 93 94 95 96

	while ((p = strsep(&options, ",")) != NULL) {
		int token;
		if (!*p)
			continue;
		token = match_token(p, tokens, args);
		if (token < Opt_trans) {
97 98
			int r = match_int(&args[0], &option);
			if (r < 0) {
99 100
				P9_DPRINTK(P9_DEBUG_ERROR,
					"integer field, but no integer?\n");
101
				ret = r;
102 103 104 105 106 107 108 109
				continue;
			}
		}
		switch (token) {
		case Opt_msize:
			clnt->msize = option;
			break;
		case Opt_trans:
110
			clnt->trans_mod = v9fs_get_trans_by_name(&args[0]);
111 112 113 114 115 116 117 118
			break;
		case Opt_legacy:
			clnt->dotu = 0;
			break;
		default:
			continue;
		}
	}
119

120 121
	kfree(options);
	return ret;
122 123
}

124 125 126 127 128 129 130 131 132 133 134 135 136 137 138
/**
 * p9_tag_alloc - lookup/allocate a request by tag
 * @c: client session to lookup tag within
 * @tag: numeric id for transaction
 *
 * this is a simple array lookup, but will grow the
 * request_slots as necessary to accomodate transaction
 * ids which did not previously have a slot.
 *
 * this code relies on the client spinlock to manage locks, its
 * possible we should switch to something else, but I'd rather
 * stick with something low-overhead for the common case.
 *
 */

139
static struct p9_req_t *p9_tag_alloc(struct p9_client *c, u16 tag)
140 141 142
{
	unsigned long flags;
	int row, col;
143
	struct p9_req_t *req;
144 145 146 147 148 149 150 151 152 153 154 155 156 157 158

	/* This looks up the original request by tag so we know which
	 * buffer to read the data into */
	tag++;

	if (tag >= c->max_tag) {
		spin_lock_irqsave(&c->lock, flags);
		/* check again since original check was outside of lock */
		while (tag >= c->max_tag) {
			row = (tag / P9_ROW_MAXTAG);
			c->reqs[row] = kcalloc(P9_ROW_MAXTAG,
					sizeof(struct p9_req_t), GFP_ATOMIC);

			if (!c->reqs[row]) {
				printk(KERN_ERR "Couldn't grow tag array\n");
Eric Van Hensbergen's avatar
Eric Van Hensbergen committed
159
				spin_unlock_irqrestore(&c->lock, flags);
160
				return ERR_PTR(-ENOMEM);
161 162 163
			}
			for (col = 0; col < P9_ROW_MAXTAG; col++) {
				c->reqs[row][col].status = REQ_STATUS_IDLE;
164
				c->reqs[row][col].tc = NULL;
165 166 167 168 169 170 171 172
			}
			c->max_tag += P9_ROW_MAXTAG;
		}
		spin_unlock_irqrestore(&c->lock, flags);
	}
	row = tag / P9_ROW_MAXTAG;
	col = tag % P9_ROW_MAXTAG;

173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188
	req = &c->reqs[row][col];
	if (!req->tc) {
		req->wq = kmalloc(sizeof(wait_queue_head_t), GFP_KERNEL);
		if (!req->wq) {
			printk(KERN_ERR "Couldn't grow tag array\n");
			return ERR_PTR(-ENOMEM);
		}
		init_waitqueue_head(req->wq);
		req->tc = kmalloc(sizeof(struct p9_fcall)+c->msize,
								GFP_KERNEL);
		req->rc = kmalloc(sizeof(struct p9_fcall)+c->msize,
								GFP_KERNEL);
		if ((!req->tc) || (!req->rc)) {
			printk(KERN_ERR "Couldn't grow tag array\n");
			kfree(req->tc);
			kfree(req->rc);
189 190 191
			kfree(req->wq);
			req->tc = req->rc = NULL;
			req->wq = NULL;
192 193 194 195 196 197 198 199 200 201 202 203 204
			return ERR_PTR(-ENOMEM);
		}
		req->tc->sdata = (char *) req->tc + sizeof(struct p9_fcall);
		req->tc->capacity = c->msize;
		req->rc->sdata = (char *) req->rc + sizeof(struct p9_fcall);
		req->rc->capacity = c->msize;
	}

	p9pdu_reset(req->tc);
	p9pdu_reset(req->rc);

	req->tc->tag = tag-1;
	req->status = REQ_STATUS_ALLOC;
205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287

	return &c->reqs[row][col];
}

/**
 * p9_tag_lookup - lookup a request by tag
 * @c: client session to lookup tag within
 * @tag: numeric id for transaction
 *
 */

struct p9_req_t *p9_tag_lookup(struct p9_client *c, u16 tag)
{
	int row, col;

	/* This looks up the original request by tag so we know which
	 * buffer to read the data into */
	tag++;

	BUG_ON(tag >= c->max_tag);

	row = tag / P9_ROW_MAXTAG;
	col = tag % P9_ROW_MAXTAG;

	return &c->reqs[row][col];
}
EXPORT_SYMBOL(p9_tag_lookup);

/**
 * p9_tag_init - setup tags structure and contents
 * @tags: tags structure from the client struct
 *
 * This initializes the tags structure for each client instance.
 *
 */

static int p9_tag_init(struct p9_client *c)
{
	int err = 0;

	c->tagpool = p9_idpool_create();
	if (IS_ERR(c->tagpool)) {
		err = PTR_ERR(c->tagpool);
		c->tagpool = NULL;
		goto error;
	}

	p9_idpool_get(c->tagpool); /* reserve tag 0 */

	c->max_tag = 0;
error:
	return err;
}

/**
 * p9_tag_cleanup - cleans up tags structure and reclaims resources
 * @tags: tags structure from the client struct
 *
 * This frees resources associated with the tags structure
 *
 */
static void p9_tag_cleanup(struct p9_client *c)
{
	int row, col;

	/* check to insure all requests are idle */
	for (row = 0; row < (c->max_tag/P9_ROW_MAXTAG); row++) {
		for (col = 0; col < P9_ROW_MAXTAG; col++) {
			if (c->reqs[row][col].status != REQ_STATUS_IDLE) {
				P9_DPRINTK(P9_DEBUG_MUX,
				  "Attempting to cleanup non-free tag %d,%d\n",
				  row, col);
				/* TODO: delay execution of cleanup */
				return;
			}
		}
	}

	if (c->tagpool)
		p9_idpool_destroy(c->tagpool);

	/* free requests associated with tags */
	for (row = 0; row < (c->max_tag/P9_ROW_MAXTAG); row++) {
288
		for (col = 0; col < P9_ROW_MAXTAG; col++) {
289
			kfree(c->reqs[row][col].wq);
290 291 292
			kfree(c->reqs[row][col].tc);
			kfree(c->reqs[row][col].rc);
		}
293 294 295 296 297
		kfree(c->reqs[row]);
	}
	c->max_tag = 0;
}

298 299 300 301 302 303 304
/**
 * p9_free_req - free a request and clean-up as necessary
 * c: client state
 * r: request to release
 *
 */

305
static void p9_free_req(struct p9_client *c, struct p9_req_t *r)
306
{
307 308 309
	int tag = r->tc->tag;
	P9_DPRINTK(P9_DEBUG_MUX, "clnt %p req %p tag: %d\n", c, r, tag);

310
	r->status = REQ_STATUS_IDLE;
311 312
	if (tag != P9_NOTAG && p9_idpool_check(tag, c->tagpool))
		p9_idpool_put(tag, c->tagpool);
313 314
}

315 316 317 318 319 320 321 322
/**
 * p9_client_cb - call back from transport to client
 * c: client state
 * req: request received
 *
 */
void p9_client_cb(struct p9_client *c, struct p9_req_t *req)
{
323
	P9_DPRINTK(P9_DEBUG_MUX, " tag %d\n", req->tc->tag);
324 325
	wake_up(req->wq);
	P9_DPRINTK(P9_DEBUG_MUX, "wakeup: %d\n", req->tc->tag);
326 327 328
}
EXPORT_SYMBOL(p9_client_cb);

329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359
/**
 * p9_parse_header - parse header arguments out of a packet
 * @pdu: packet to parse
 * @size: size of packet
 * @type: type of request
 * @tag: tag of packet
 * @rewind: set if we need to rewind offset afterwards
 */

int
p9_parse_header(struct p9_fcall *pdu, int32_t *size, int8_t *type, int16_t *tag,
								int rewind)
{
	int8_t r_type;
	int16_t r_tag;
	int32_t r_size;
	int offset = pdu->offset;
	int err;

	pdu->offset = 0;
	if (pdu->size == 0)
		pdu->size = 7;

	err = p9pdu_readf(pdu, 0, "dbw", &r_size, &r_type, &r_tag);
	if (err)
		goto rewind_and_exit;

	pdu->size = r_size;
	pdu->id = r_type;
	pdu->tag = r_tag;

360 361
	P9_DPRINTK(P9_DEBUG_9P, "<<< size=%d type: %d tag: %d\n", pdu->size,
							pdu->id, pdu->tag);
362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459

	if (type)
		*type = r_type;
	if (tag)
		*tag = r_tag;
	if (size)
		*size = r_size;


rewind_and_exit:
	if (rewind)
		pdu->offset = offset;
	return err;
}
EXPORT_SYMBOL(p9_parse_header);

/**
 * p9_check_errors - check 9p packet for error return and process it
 * @c: current client instance
 * @req: request to parse and check for error conditions
 *
 * returns error code if one is discovered, otherwise returns 0
 *
 * this will have to be more complicated if we have multiple
 * error packet types
 */

static int p9_check_errors(struct p9_client *c, struct p9_req_t *req)
{
	int8_t type;
	int err;

	err = p9_parse_header(req->rc, NULL, &type, NULL, 0);
	if (err) {
		P9_DPRINTK(P9_DEBUG_ERROR, "couldn't parse header %d\n", err);
		return err;
	}

	if (type == P9_RERROR) {
		int ecode;
		char *ename;

		err = p9pdu_readf(req->rc, c->dotu, "s?d", &ename, &ecode);
		if (err) {
			P9_DPRINTK(P9_DEBUG_ERROR, "couldn't parse error%d\n",
									err);
			return err;
		}

		if (c->dotu)
			err = -ecode;

		if (!err) {
			err = p9_errstr2errno(ename, strlen(ename));

			/* string match failed */
			if (!err)
				err = -ESERVERFAULT;
		}

		P9_DPRINTK(P9_DEBUG_9P, "<<< RERROR (%d) %s\n", -ecode, ename);

		kfree(ename);
	} else
		err = 0;

	return err;
}

/**
 * p9_client_flush - flush (cancel) a request
 * c: client state
 * req: request to cancel
 *
 * This sents a flush for a particular requests and links
 * the flush request to the original request.  The current
 * code only supports a single flush request although the protocol
 * allows for multiple flush requests to be sent for a single request.
 *
 */

static int p9_client_flush(struct p9_client *c, struct p9_req_t *oldreq)
{
	struct p9_req_t *req;
	int16_t oldtag;
	int err;

	err = p9_parse_header(oldreq->tc, NULL, NULL, &oldtag, 1);
	if (err)
		return err;

	P9_DPRINTK(P9_DEBUG_9P, ">>> TFLUSH tag %d\n", oldtag);

	req = p9_client_rpc(c, P9_TFLUSH, "w", oldtag);
	if (IS_ERR(req))
		return PTR_ERR(req);


460 461 462 463 464 465 466 467
	/* if we haven't received a response for oldreq,
	   remove it from the list. */
	spin_lock(&c->lock);
	if (oldreq->status == REQ_STATUS_FLSH)
		list_del(&oldreq->req_list);
	spin_unlock(&c->lock);

	p9_free_req(c, req);
468 469 470
	return 0;
}

471 472 473
/**
 * p9_client_rpc - issue a request and wait for a response
 * @c: client session
474 475
 * @type: type of request
 * @fmt: protocol format string (see protocol.c)
476
 *
477
 * Returns request structure (which client must free using p9_free_req)
478 479
 */

480 481
static struct p9_req_t *
p9_client_rpc(struct p9_client *c, int8_t type, const char *fmt, ...)
482
{
483 484
	va_list ap;
	int tag, err;
485 486 487 488
	struct p9_req_t *req;
	unsigned long flags;
	int sigpending;

489
	P9_DPRINTK(P9_DEBUG_MUX, "client %p op %d\n", c, type);
490 491

	if (c->status != Connected)
492
		return ERR_PTR(-EIO);
493 494 495 496 497 498 499 500

	if (signal_pending(current)) {
		sigpending = 1;
		clear_thread_flag(TIF_SIGPENDING);
	} else
		sigpending = 0;

	tag = P9_NOTAG;
501
	if (type != P9_TVERSION) {
502 503
		tag = p9_idpool_get(c->tagpool);
		if (tag < 0)
504
			return ERR_PTR(-ENOMEM);
505 506 507
	}

	req = p9_tag_alloc(c, tag);
508 509
	if (IS_ERR(req))
		return req;
510

511 512 513 514 515 516
	/* marshall the data */
	p9pdu_prepare(req->tc, tag, type);
	va_start(ap, fmt);
	err = p9pdu_vwritef(req->tc, c->dotu, fmt, ap);
	va_end(ap);
	p9pdu_finalize(req->tc);
517 518 519 520 521 522 523

	err = c->trans_mod->request(c, req);
	if (err < 0) {
		c->status = Disconnected;
		goto reterr;
	}

524
	P9_DPRINTK(P9_DEBUG_MUX, "wait %p tag: %d\n", req->wq, tag);
525 526
	err = wait_event_interruptible(*req->wq,
						req->status >= REQ_STATUS_RCVD);
527 528
	P9_DPRINTK(P9_DEBUG_MUX, "wait %p tag: %d returned %d\n",
						req->wq, tag, err);
529 530

	if (req->status == REQ_STATUS_ERROR) {
531
		P9_DPRINTK(P9_DEBUG_ERROR, "req_status error %d\n", req->t_err);
532 533 534
		err = req->t_err;
	}

535
	if ((err == -ERESTARTSYS) && (c->status == Connected)) {
536
		P9_DPRINTK(P9_DEBUG_MUX, "flushing\n");
537 538 539
		sigpending = 1;
		clear_thread_flag(TIF_SIGPENDING);

540 541 542 543 544 545
		if (c->trans_mod->cancel(c, req))
			p9_client_flush(c, req);

		/* if we received the response anyway, don't signal error */
		if (req->status == REQ_STATUS_RCVD)
			err = 0;
546 547 548 549 550 551 552 553 554 555 556
	}

	if (sigpending) {
		spin_lock_irqsave(&current->sighand->siglock, flags);
		recalc_sigpending();
		spin_unlock_irqrestore(&current->sighand->siglock, flags);
	}

	if (err < 0)
		goto reterr;

557 558 559 560
	err = p9_check_errors(c, req);
	if (!err) {
		P9_DPRINTK(P9_DEBUG_MUX, "exit: client %p op %d\n", c, type);
		return req;
561 562 563
	}

reterr:
564 565
	P9_DPRINTK(P9_DEBUG_MUX, "exit: client %p op %d error: %d\n", c, type,
									err);
566
	p9_free_req(c, req);
567
	return ERR_PTR(err);
568 569
}

570 571
static struct p9_fid *p9_fid_create(struct p9_client *clnt)
{
572
	int ret;
573
	struct p9_fid *fid;
574
	unsigned long flags;
575

576
	P9_DPRINTK(P9_DEBUG_FID, "clnt %p\n", clnt);
577 578 579 580
	fid = kmalloc(sizeof(struct p9_fid), GFP_KERNEL);
	if (!fid)
		return ERR_PTR(-ENOMEM);

581
	ret = p9_idpool_get(clnt->fidpool);
582
	if (ret < 0) {
583
		ret = -ENOSPC;
584 585
		goto error;
	}
586
	fid->fid = ret;
587 588 589 590

	memset(&fid->qid, 0, sizeof(struct p9_qid));
	fid->mode = -1;
	fid->rdir_fpos = 0;
591
	fid->uid = current_fsuid();
592 593 594
	fid->clnt = clnt;
	fid->aux = NULL;

595
	spin_lock_irqsave(&clnt->lock, flags);
596
	list_add(&fid->flist, &clnt->fidlist);
597
	spin_unlock_irqrestore(&clnt->lock, flags);
598 599 600 601 602

	return fid;

error:
	kfree(fid);
603
	return ERR_PTR(ret);
604 605 606 607 608
}

static void p9_fid_destroy(struct p9_fid *fid)
{
	struct p9_client *clnt;
609
	unsigned long flags;
610

611
	P9_DPRINTK(P9_DEBUG_FID, "fid %d\n", fid->fid);
612 613
	clnt = fid->clnt;
	p9_idpool_put(fid->fid, clnt->fidpool);
614
	spin_lock_irqsave(&clnt->lock, flags);
615
	list_del(&fid->flist);
616
	spin_unlock_irqrestore(&clnt->lock, flags);
617 618
	kfree(fid);
}
619

620
int p9_client_version(struct p9_client *c)
621
{
622
	int err = 0;
623 624 625
	struct p9_req_t *req;
	char *version;
	int msize;
626

627 628 629 630 631 632
	P9_DPRINTK(P9_DEBUG_9P, ">>> TVERSION msize %d extended %d\n",
							c->msize, c->dotu);
	req = p9_client_rpc(c, P9_TVERSION, "ds", c->msize,
				c->dotu ? "9P2000.u" : "9P2000");
	if (IS_ERR(req))
		return PTR_ERR(req);
633

634 635 636
	err = p9pdu_readf(req->rc, c->dotu, "ds", &msize, &version);
	if (err) {
		P9_DPRINTK(P9_DEBUG_9P, "version error %d\n", err);
637
		p9pdu_dump(1, req->rc);
638
		goto error;
639
	}
640

641 642 643 644 645
	P9_DPRINTK(P9_DEBUG_9P, "<<< RVERSION msize %d %s\n", msize, version);
	if (!memcmp(version, "9P2000.u", 8))
		c->dotu = 1;
	else if (!memcmp(version, "9P2000", 6))
		c->dotu = 0;
646 647 648 649 650
	else {
		err = -EREMOTEIO;
		goto error;
	}

651 652
	if (msize < c->msize)
		c->msize = msize;
653 654

error:
655 656
	kfree(version);
	p9_free_req(c, req);
657 658 659

	return err;
}
660
EXPORT_SYMBOL(p9_client_version);
661 662 663 664 665 666 667

struct p9_client *p9_client_create(const char *dev_name, char *options)
{
	int err;
	struct p9_client *clnt;

	err = 0;
668 669 670 671
	clnt = kmalloc(sizeof(struct p9_client), GFP_KERNEL);
	if (!clnt)
		return ERR_PTR(-ENOMEM);

672
	clnt->trans_mod = NULL;
673
	clnt->trans = NULL;
674 675 676
	spin_lock_init(&clnt->lock);
	INIT_LIST_HEAD(&clnt->fidlist);
	clnt->fidpool = p9_idpool_create();
677
	if (IS_ERR(clnt->fidpool)) {
678 679 680 681 682
		err = PTR_ERR(clnt->fidpool);
		clnt->fidpool = NULL;
		goto error;
	}

683 684
	p9_tag_init(clnt);

685 686 687 688
	err = parse_opts(options, clnt);
	if (err < 0)
		goto error;

689 690 691
	if (!clnt->trans_mod)
		clnt->trans_mod = v9fs_get_default_trans();

692 693 694 695 696 697 698
	if (clnt->trans_mod == NULL) {
		err = -EPROTONOSUPPORT;
		P9_DPRINTK(P9_DEBUG_ERROR,
				"No transport defined or default transport\n");
		goto error;
	}

699
	P9_DPRINTK(P9_DEBUG_MUX, "clnt %p trans %p msize %d dotu %d\n",
700 701
		clnt, clnt->trans_mod, clnt->msize, clnt->dotu);

702 703
	err = clnt->trans_mod->create(clnt, dev_name, options);
	if (err)
704 705
		goto error;

706 707 708
	if ((clnt->msize+P9_IOHDRSZ) > clnt->trans_mod->maxsize)
		clnt->msize = clnt->trans_mod->maxsize-P9_IOHDRSZ;

709
	err = p9_client_version(clnt);
710 711 712 713 714 715 716 717 718 719 720 721 722 723 724
	if (err)
		goto error;

	return clnt;

error:
	p9_client_destroy(clnt);
	return ERR_PTR(err);
}
EXPORT_SYMBOL(p9_client_create);

void p9_client_destroy(struct p9_client *clnt)
{
	struct p9_fid *fid, *fidptr;

725
	P9_DPRINTK(P9_DEBUG_MUX, "clnt %p\n", clnt);
726

727 728
	if (clnt->trans_mod)
		clnt->trans_mod->close(clnt);
729

730 731
	v9fs_put_trans(clnt->trans_mod);

732 733 734
	list_for_each_entry_safe(fid, fidptr, &clnt->fidlist, flist)
		p9_fid_destroy(fid);

735 736 737
	if (clnt->fidpool)
		p9_idpool_destroy(clnt->fidpool);

738 739
	p9_tag_cleanup(clnt);

740 741 742 743 744 745 746
	kfree(clnt);
}
EXPORT_SYMBOL(p9_client_destroy);

void p9_client_disconnect(struct p9_client *clnt)
{
	P9_DPRINTK(P9_DEBUG_9P, "clnt %p\n", clnt);
747
	clnt->status = Disconnected;
748 749 750 751
}
EXPORT_SYMBOL(p9_client_disconnect);

struct p9_fid *p9_client_attach(struct p9_client *clnt, struct p9_fid *afid,
Latchesar Ionkov's avatar
Latchesar Ionkov committed
752
	char *uname, u32 n_uname, char *aname)
753 754
{
	int err;
755
	struct p9_req_t *req;
756
	struct p9_fid *fid;
757
	struct p9_qid qid;
758

759 760
	P9_DPRINTK(P9_DEBUG_9P, ">>> TATTACH afid %d uname %s aname %s\n",
					afid ? afid->fid : -1, uname, aname);
761 762 763 764 765 766 767 768 769
	err = 0;

	fid = p9_fid_create(clnt);
	if (IS_ERR(fid)) {
		err = PTR_ERR(fid);
		fid = NULL;
		goto error;
	}

770 771 772 773
	req = p9_client_rpc(clnt, P9_TATTACH, "ddss?d", fid->fid,
			afid ? afid->fid : P9_NOFID, uname, aname, n_uname);
	if (IS_ERR(req)) {
		err = PTR_ERR(req);
774 775 776
		goto error;
	}

777 778
	err = p9pdu_readf(req->rc, clnt->dotu, "Q", &qid);
	if (err) {
779
		p9pdu_dump(1, req->rc);
780
		p9_free_req(clnt, req);
781
		goto error;
782
	}
783

784
	P9_DPRINTK(P9_DEBUG_9P, "<<< RATTACH qid %x.%llx.%x\n",
785 786 787
					qid.type,
					(unsigned long long)qid.path,
					qid.version);
788 789 790 791

	memmove(&fid->qid, &qid, sizeof(struct p9_qid));

	p9_free_req(clnt, req);
792 793 794 795 796 797 798 799 800
	return fid;

error:
	if (fid)
		p9_fid_destroy(fid);
	return ERR_PTR(err);
}
EXPORT_SYMBOL(p9_client_attach);

801 802
struct p9_fid *
p9_client_auth(struct p9_client *clnt, char *uname, u32 n_uname, char *aname)
803 804
{
	int err;
805 806 807
	struct p9_req_t *req;
	struct p9_qid qid;
	struct p9_fid *afid;
808

809
	P9_DPRINTK(P9_DEBUG_9P, ">>> TAUTH uname %s aname %s\n", uname, aname);
810 811
	err = 0;

812 813 814 815
	afid = p9_fid_create(clnt);
	if (IS_ERR(afid)) {
		err = PTR_ERR(afid);
		afid = NULL;
816 817 818
		goto error;
	}

819 820 821 822
	req = p9_client_rpc(clnt, P9_TAUTH, "dss?d",
			afid ? afid->fid : P9_NOFID, uname, aname, n_uname);
	if (IS_ERR(req)) {
		err = PTR_ERR(req);
823 824 825
		goto error;
	}

826 827
	err = p9pdu_readf(req->rc, clnt->dotu, "Q", &qid);
	if (err) {
828
		p9pdu_dump(1, req->rc);
829
		p9_free_req(clnt, req);
830
		goto error;
831
	}
832

833
	P9_DPRINTK(P9_DEBUG_9P, "<<< RAUTH qid %x.%llx.%x\n",
834 835 836
					qid.type,
					(unsigned long long)qid.path,
					qid.version);
837 838 839 840

	memmove(&afid->qid, &qid, sizeof(struct p9_qid));
	p9_free_req(clnt, req);
	return afid;
841 842

error:
843 844
	if (afid)
		p9_fid_destroy(afid);
845 846 847 848 849 850 851 852 853 854
	return ERR_PTR(err);
}
EXPORT_SYMBOL(p9_client_auth);

struct p9_fid *p9_client_walk(struct p9_fid *oldfid, int nwname, char **wnames,
	int clone)
{
	int err;
	struct p9_client *clnt;
	struct p9_fid *fid;
855 856 857
	struct p9_qid *wqids;
	struct p9_req_t *req;
	int16_t nwqids, count;
858 859 860 861 862 863 864 865 866 867 868 869 870 871 872

	err = 0;
	clnt = oldfid->clnt;
	if (clone) {
		fid = p9_fid_create(clnt);
		if (IS_ERR(fid)) {
			err = PTR_ERR(fid);
			fid = NULL;
			goto error;
		}

		fid->uid = oldfid->uid;
	} else
		fid = oldfid;

873 874 875 876 877 878 879 880

	P9_DPRINTK(P9_DEBUG_9P, ">>> TWALK fids %d,%d nwname %d wname[0] %s\n",
		oldfid->fid, fid->fid, nwname, wnames ? wnames[0] : NULL);

	req = p9_client_rpc(clnt, P9_TWALK, "ddT", oldfid->fid, fid->fid,
								nwname, wnames);
	if (IS_ERR(req)) {
		err = PTR_ERR(req);
881 882 883
		goto error;
	}

884
	err = p9pdu_readf(req->rc, clnt->dotu, "R", &nwqids, &wqids);
885 886 887
	if (err) {
		p9pdu_dump(1, req->rc);
		p9_free_req(clnt, req);
888
		goto clunk_fid;
889 890
	}
	p9_free_req(clnt, req);
891

892 893 894
	P9_DPRINTK(P9_DEBUG_9P, "<<< RWALK nwqid %d:\n", nwqids);

	if (nwqids != nwname) {
895 896 897 898
		err = -ENOENT;
		goto clunk_fid;
	}

899 900
	for (count = 0; count < nwqids; count++)
		P9_DPRINTK(P9_DEBUG_9P, "<<<     [%d] %x.%llx.%x\n",
901 902
			count, wqids[count].type,
			(unsigned long long)wqids[count].path,
903 904
			wqids[count].version);

905
	if (nwname)
906
		memmove(&fid->qid, &wqids[nwqids - 1], sizeof(struct p9_qid));
907 908 909 910 911 912
	else
		fid->qid = oldfid->qid;

	return fid;

clunk_fid:
913 914
	p9_client_clunk(fid);
	fid = NULL;
915 916 917 918 919 920 921 922 923 924 925 926 927

error:
	if (fid && (fid != oldfid))
		p9_fid_destroy(fid);

	return ERR_PTR(err);
}
EXPORT_SYMBOL(p9_client_walk);

int p9_client_open(struct p9_fid *fid, int mode)
{
	int err;
	struct p9_client *clnt;
928 929 930
	struct p9_req_t *req;
	struct p9_qid qid;
	int iounit;
931

932
	P9_DPRINTK(P9_DEBUG_9P, ">>> TOPEN fid %d mode %d\n", fid->fid, mode);
933 934 935 936 937 938
	err = 0;
	clnt = fid->clnt;

	if (fid->mode != -1)
		return -EINVAL;

939 940 941 942
	req = p9_client_rpc(clnt, P9_TOPEN, "db", fid->fid, mode);
	if (IS_ERR(req)) {
		err = PTR_ERR(req);
		goto error;
943 944
	}

945
	err = p9pdu_readf(req->rc, clnt->dotu, "Qd", &qid, &iounit);
946 947 948 949
	if (err) {
		p9pdu_dump(1, req->rc);
		goto free_and_error;
	}
950 951

	P9_DPRINTK(P9_DEBUG_9P, "<<< ROPEN qid %x.%llx.%x iounit %x\n",
952 953 954
				qid.type,
				(unsigned long long)qid.path,
				qid.version, iounit);
955 956

	fid->mode = mode;
957
	fid->iounit = iounit;
958

959 960
free_and_error:
	p9_free_req(clnt, req);
961
error:
962 963 964 965 966 967 968 969 970
	return err;
}
EXPORT_SYMBOL(p9_client_open);

int p9_client_fcreate(struct p9_fid *fid, char *name, u32 perm, int mode,
		     char *extension)
{
	int err;
	struct p9_client *clnt;
971 972 973
	struct p9_req_t *req;
	struct p9_qid qid;
	int iounit;
974

975 976
	P9_DPRINTK(P9_DEBUG_9P, ">>> TCREATE fid %d name %s perm %d mode %d\n",
						fid->fid, name, perm, mode);
977 978 979 980 981 982
	err = 0;
	clnt = fid->clnt;

	if (fid->mode != -1)
		return -EINVAL;

983 984 985 986 987
	req = p9_client_rpc(clnt, P9_TCREATE, "dsdb?s", fid->fid, name, perm,
				mode, extension);
	if (IS_ERR(req)) {
		err = PTR_ERR(req);
		goto error;
988 989
	}

990
	err = p9pdu_readf(req->rc, clnt->dotu, "Qd", &qid, &iounit);
991 992 993 994
	if (err) {
		p9pdu_dump(1, req->rc);
		goto free_and_error;
	}
995 996

	P9_DPRINTK(P9_DEBUG_9P, "<<< RCREATE qid %x.%llx.%x iounit %x\n",
997 998 999
				qid.type,
				(unsigned long long)qid.path,
				qid.version, iounit);
1000 1001

	fid->mode = mode;
1002
	fid->iounit = iounit;
1003

1004 1005
free_and_error:
	p9_free_req(clnt, req);
1006
error:
1007 1008 1009 1010 1011 1012 1013 1014
	return err;
}
EXPORT_SYMBOL(p9_client_fcreate);

int p9_client_clunk(struct p9_fid *fid)
{
	int err;
	struct p9_client *clnt;
1015
	struct p9_req_t *req;
1016

1017
	P9_DPRINTK(P9_DEBUG_9P, ">>> TCLUNK fid %d\n", fid->fid);
1018 1019 1020
	err = 0;
	clnt = fid->clnt;

1021 1022 1023 1024
	req = p9_client_rpc(clnt, P9_TCLUNK, "d", fid->fid);
	if (IS_ERR(req)) {
		err = PTR_ERR(req);
		goto error;
1025 1026
	}

1027
	P9_DPRINTK(P9_DEBUG_9P, "<<< RCLUNK fid %d\n", fid->fid);
1028

1029
	p9_free_req(clnt, req);
1030 1031
	p9_fid_destroy(fid);

1032
error:
1033 1034 1035 1036 1037 1038 1039 1040
	return err;
}
EXPORT_SYMBOL(p9_client_clunk);

int p9_client_remove(struct p9_fid *fid)
{
	int err;
	struct p9_client *clnt;
1041
	struct p9_req_t *req;
1042

1043
	P9_DPRINTK(P9_DEBUG_9P, ">>> TREMOVE fid %d\n", fid->fid);
1044 1045 1046
	err = 0;
	clnt = fid->clnt;

1047 1048 1049 1050
	req = p9_client_rpc(clnt, P9_TREMOVE, "d", fid->fid);
	if (IS_ERR(req)) {
		err = PTR_ERR(req);
		goto error;
1051 1052
	}

1053
	P9_DPRINTK(P9_DEBUG_9P, "<<< RREMOVE fid %d\n", fid->fid);
1054

1055
	p9_free_req(clnt, req);
1056 1057
	p9_fid_destroy(fid);

1058
error:
1059 1060 1061 1062
	return err;
}
EXPORT_SYMBOL(p9_client_remove);

1063 1064 1065
int
p9_client_read(struct p9_fid *fid, char *data, char __user *udata, u64 offset,
								u32 count)
1066
{
1067
	int err, rsize, total;
1068
	struct p9_client *clnt;
1069 1070
	struct p9_req_t *req;
	char *dataptr;
1071

1072
	P9_DPRINTK(P9_DEBUG_9P, ">>> TREAD fid %d offset %llu %d\n", fid->fid,
1073 1074 1075 1076 1077 1078 1079 1080 1081
					(long long unsigned) offset, count);
	err = 0;
	clnt = fid->clnt;
	total = 0;

	rsize = fid->iounit;
	if (!rsize || rsize > clnt->msize-P9_IOHDRSZ)
		rsize = clnt->msize - P9_IOHDRSZ;

1082 1083
	if (count < rsize)
		rsize = count;
1084

1085 1086 1087 1088 1089
	req = p9_client_rpc(clnt, P9_TREAD, "dqd", fid->fid, offset, rsize);
	if (IS_ERR(req)) {
		err = PTR_ERR(req);
		goto error;
	}
1090

1091
	err = p9pdu_readf(req->rc, clnt->dotu, "D", &count, &dataptr);
1092 1093
	if (err) {
		p9pdu_dump(1, req->rc);
1094
		goto free_and_error;
1095
	}
1096