client.c 52.6 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
 *  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
 *
 */

26 27
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

28 29 30
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/fs.h>
31
#include <linux/poll.h>
32 33
#include <linux/idr.h>
#include <linux/mutex.h>
34
#include <linux/slab.h>
35
#include <linux/sched/signal.h>
36
#include <linux/uaccess.h>
37
#include <linux/uio.h>
38
#include <net/9p/9p.h>
39
#include <linux/parser.h>
D
David Howells 已提交
40
#include <linux/seq_file.h>
41
#include <net/9p/client.h>
42
#include <net/9p/transport.h>
43
#include "protocol.h"
44

45 46 47
#define CREATE_TRACE_POINTS
#include <trace/events/9p.h>

48 49 50 51 52 53 54 55 56
/*
  * Client Option Parsing (code inspired by NFS code)
  *  - a little lazy - parse all client options
  */

enum {
	Opt_msize,
	Opt_trans,
	Opt_legacy,
57
	Opt_version,
58 59 60
	Opt_err,
};

61
static const match_table_t tokens = {
62 63 64
	{Opt_msize, "msize=%u"},
	{Opt_legacy, "noextend"},
	{Opt_trans, "trans=%s"},
65
	{Opt_version, "version=%s"},
66 67 68
	{Opt_err, NULL},
};

69 70
inline int p9_is_proto_dotl(struct p9_client *clnt)
{
E
Eric Dumazet 已提交
71
	return clnt->proto_version == p9_proto_2000L;
72 73 74 75 76
}
EXPORT_SYMBOL(p9_is_proto_dotl);

inline int p9_is_proto_dotu(struct p9_client *clnt)
{
E
Eric Dumazet 已提交
77
	return clnt->proto_version == p9_proto_2000u;
78 79 80
}
EXPORT_SYMBOL(p9_is_proto_dotu);

D
David Howells 已提交
81 82 83 84
int p9_show_client_options(struct seq_file *m, struct p9_client *clnt)
{
	if (clnt->msize != 8192)
		seq_printf(m, ",msize=%u", clnt->msize);
85
	seq_printf(m, ",trans=%s", clnt->trans_mod->name);
D
David Howells 已提交
86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104

	switch (clnt->proto_version) {
	case p9_proto_legacy:
		seq_puts(m, ",noextend");
		break;
	case p9_proto_2000u:
		seq_puts(m, ",version=9p2000.u");
		break;
	case p9_proto_2000L:
		/* Default */
		break;
	}

	if (clnt->trans_mod->show_options)
		return clnt->trans_mod->show_options(m, clnt);
	return 0;
}
EXPORT_SYMBOL(p9_show_client_options);

S
Simon Derr 已提交
105 106 107 108 109 110 111 112 113 114 115 116 117 118
/*
 * Some error codes are taken directly from the server replies,
 * make sure they are valid.
 */
static int safe_errno(int err)
{
	if ((err > 0) || (err < -MAX_ERRNO)) {
		p9_debug(P9_DEBUG_ERROR, "Invalid error code %d\n", err);
		return -EPROTO;
	}
	return err;
}


119
/* Interpret mount option for protocol version */
120
static int get_protocol_version(char *s)
121
{
122 123
	int version = -EINVAL;

124
	if (!strcmp(s, "9p2000")) {
125
		version = p9_proto_legacy;
126
		p9_debug(P9_DEBUG_9P, "Protocol version: Legacy\n");
127
	} else if (!strcmp(s, "9p2000.u")) {
128
		version = p9_proto_2000u;
129
		p9_debug(P9_DEBUG_9P, "Protocol version: 9P2000.u\n");
130
	} else if (!strcmp(s, "9p2000.L")) {
131
		version = p9_proto_2000L;
132
		p9_debug(P9_DEBUG_9P, "Protocol version: 9P2000.L\n");
133
	} else
134
		pr_info("Unknown protocol version %s\n", s);
135

136 137 138
	return version;
}

139
/**
A
Abhishek Kulkarni 已提交
140 141 142
 * parse_options - parse mount options into client structure
 * @opts: options string passed from mount
 * @clnt: existing v9fs client information
143
 *
144
 * Return 0 upon success, -ERRNO upon failure
145 146
 */

147
static int parse_opts(char *opts, struct p9_client *clnt)
148
{
E
Eric Van Hensbergen 已提交
149
	char *options, *tmp_options;
150 151 152
	char *p;
	substring_t args[MAX_OPT_ARGS];
	int option;
153
	char *s;
154
	int ret = 0;
155

156
	clnt->proto_version = p9_proto_2000L;
157 158
	clnt->msize = 8192;

159 160 161
	if (!opts)
		return 0;

E
Eric Van Hensbergen 已提交
162 163
	tmp_options = kstrdup(opts, GFP_KERNEL);
	if (!tmp_options) {
164 165
		p9_debug(P9_DEBUG_ERROR,
			 "failed to allocate copy of option string\n");
166 167
		return -ENOMEM;
	}
E
Eric Van Hensbergen 已提交
168
	options = tmp_options;
169 170

	while ((p = strsep(&options, ",")) != NULL) {
171
		int token, r;
172 173 174
		if (!*p)
			continue;
		token = match_token(p, tokens, args);
175 176 177
		switch (token) {
		case Opt_msize:
			r = match_int(&args[0], &option);
178
			if (r < 0) {
179 180
				p9_debug(P9_DEBUG_ERROR,
					 "integer field, but no integer?\n");
181
				ret = r;
182 183 184 185 186
				continue;
			}
			clnt->msize = option;
			break;
		case Opt_trans:
187 188 189
			s = match_strdup(&args[0]);
			if (!s) {
				ret = -ENOMEM;
190 191
				p9_debug(P9_DEBUG_ERROR,
					 "problem allocating copy of trans arg\n");
192
				goto free_and_return;
193 194 195
			}

			v9fs_put_trans(clnt->trans_mod);
196 197
			clnt->trans_mod = v9fs_get_trans_by_name(s);
			if (clnt->trans_mod == NULL) {
198 199
				pr_info("Could not find request transport: %s\n",
					s);
200
				ret = -EINVAL;
201
				kfree(s);
202 203
				goto free_and_return;
			}
204
			kfree(s);
205 206
			break;
		case Opt_legacy:
207
			clnt->proto_version = p9_proto_legacy;
208
			break;
209
		case Opt_version:
210 211 212
			s = match_strdup(&args[0]);
			if (!s) {
				ret = -ENOMEM;
213 214
				p9_debug(P9_DEBUG_ERROR,
					 "problem allocating copy of version arg\n");
215
				goto free_and_return;
216 217 218 219 220 221 222
			}
			ret = get_protocol_version(s);
			if (ret == -EINVAL) {
				kfree(s);
				goto free_and_return;
			}
			kfree(s);
223 224
			clnt->proto_version = ret;
			break;
225 226 227 228
		default:
			continue;
		}
	}
229

230
free_and_return:
231
	v9fs_put_trans(clnt->trans_mod);
E
Eric Van Hensbergen 已提交
232
	kfree(tmp_options);
233
	return ret;
234 235
}

236
static struct p9_fcall *p9_fcall_alloc(int alloc_msize)
237 238 239 240 241 242 243 244 245 246
{
	struct p9_fcall *fc;
	fc = kmalloc(sizeof(struct p9_fcall) + alloc_msize, GFP_NOFS);
	if (!fc)
		return NULL;
	fc->capacity = alloc_msize;
	fc->sdata = (char *) fc + sizeof(struct p9_fcall);
	return fc;
}

247 248 249 250 251 252
/**
 * 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
L
Lucas De Marchi 已提交
253
 * request_slots as necessary to accommodate transaction
254 255 256 257 258 259 260 261
 * 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.
 *
 */

262 263
static struct p9_req_t *
p9_tag_alloc(struct p9_client *c, u16 tag, unsigned int max_size)
264 265 266
{
	unsigned long flags;
	int row, col;
267
	struct p9_req_t *req;
268
	int alloc_msize = min(c->msize, max_size);
269 270 271 272 273 274 275 276 277 278 279 280 281 282

	/* 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]) {
283
				pr_err("Couldn't grow tag array\n");
E
Eric Van Hensbergen 已提交
284
				spin_unlock_irqrestore(&c->lock, flags);
285
				return ERR_PTR(-ENOMEM);
286 287 288
			}
			for (col = 0; col < P9_ROW_MAXTAG; col++) {
				c->reqs[row][col].status = REQ_STATUS_IDLE;
289
				c->reqs[row][col].tc = NULL;
290 291 292 293 294 295 296 297
			}
			c->max_tag += P9_ROW_MAXTAG;
		}
		spin_unlock_irqrestore(&c->lock, flags);
	}
	row = tag / P9_ROW_MAXTAG;
	col = tag % P9_ROW_MAXTAG;

298
	req = &c->reqs[row][col];
299
	if (!req->wq) {
300
		req->wq = kmalloc(sizeof(wait_queue_head_t), GFP_NOFS);
S
Simon Derr 已提交
301 302
		if (!req->wq)
			goto grow_failed;
303
		init_waitqueue_head(req->wq);
S
Simon Derr 已提交
304 305
	}

306 307 308 309 310 311
	if (!req->tc)
		req->tc = p9_fcall_alloc(alloc_msize);
	if (!req->rc)
		req->rc = p9_fcall_alloc(alloc_msize);
	if (!req->tc || !req->rc)
		goto grow_failed;
312 313 314 315 316 317

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

	req->tc->tag = tag-1;
	req->status = REQ_STATUS_ALLOC;
318

S
Simon Derr 已提交
319 320 321 322 323 324 325 326 327 328
	return req;

grow_failed:
	pr_err("Couldn't grow tag array\n");
	kfree(req->tc);
	kfree(req->rc);
	kfree(req->wq);
	req->tc = req->rc = NULL;
	req->wq = NULL;
	return ERR_PTR(-ENOMEM);
329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345
}

/**
 * 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++;

346 347
	if(tag >= c->max_tag) 
		return NULL;
348 349 350 351 352 353 354 355 356 357

	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
A
Abhishek Kulkarni 已提交
358
 * @c:  v9fs client struct
359 360 361 362 363 364 365 366 367 368 369 370 371 372
 *
 * 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);
		goto error;
	}
373 374 375 376 377
	err = p9_idpool_get(c->tagpool); /* reserve tag 0 */
	if (err < 0) {
		p9_idpool_destroy(c->tagpool);
		goto error;
	}
378 379 380 381 382 383 384
	c->max_tag = 0;
error:
	return err;
}

/**
 * p9_tag_cleanup - cleans up tags structure and reclaims resources
A
Abhishek Kulkarni 已提交
385
 * @c:  v9fs client struct
386 387 388 389 390 391 392 393 394 395 396 397
 *
 * 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) {
398 399 400
				p9_debug(P9_DEBUG_MUX,
					 "Attempting to cleanup non-free tag %d,%d\n",
					 row, col);
401 402 403 404 405 406
				/* TODO: delay execution of cleanup */
				return;
			}
		}
	}

407 408
	if (c->tagpool) {
		p9_idpool_put(0, c->tagpool); /* free reserved tag 0 */
409
		p9_idpool_destroy(c->tagpool);
410
	}
411 412 413

	/* free requests associated with tags */
	for (row = 0; row < (c->max_tag/P9_ROW_MAXTAG); row++) {
414
		for (col = 0; col < P9_ROW_MAXTAG; col++) {
415
			kfree(c->reqs[row][col].wq);
416 417 418
			kfree(c->reqs[row][col].tc);
			kfree(c->reqs[row][col].rc);
		}
419 420 421 422 423
		kfree(c->reqs[row]);
	}
	c->max_tag = 0;
}

424 425 426 427 428 429 430
/**
 * p9_free_req - free a request and clean-up as necessary
 * c: client state
 * r: request to release
 *
 */

431
static void p9_free_req(struct p9_client *c, struct p9_req_t *r)
432
{
433
	int tag = r->tc->tag;
434
	p9_debug(P9_DEBUG_MUX, "clnt %p req %p tag: %d\n", c, r, tag);
435

436
	r->status = REQ_STATUS_IDLE;
437 438
	if (tag != P9_NOTAG && p9_idpool_check(tag, c->tagpool))
		p9_idpool_put(tag, c->tagpool);
439 440
}

441 442 443 444 445 446
/**
 * p9_client_cb - call back from transport to client
 * c: client state
 * req: request received
 *
 */
447
void p9_client_cb(struct p9_client *c, struct p9_req_t *req, int status)
448
{
449
	p9_debug(P9_DEBUG_MUX, " tag %d\n", req->tc->tag);
450 451 452 453 454 455 456 457

	/*
	 * This barrier is needed to make sure any change made to req before
	 * the other thread wakes up will indeed be seen by the waiting side.
	 */
	smp_wmb();
	req->status = status;

458
	wake_up(req->wq);
459
	p9_debug(P9_DEBUG_MUX, "wakeup: %d\n", req->tc->tag);
460 461 462
}
EXPORT_SYMBOL(p9_client_cb);

463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493
/**
 * 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;

494 495
	p9_debug(P9_DEBUG_9P, "<<< size=%d type: %d tag: %d\n",
		 pdu->size, pdu->id, pdu->tag);
496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526

	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;
527
	int ecode;
528 529

	err = p9_parse_header(req->rc, NULL, &type, NULL, 0);
530 531 532 533 534
	/*
	 * dump the response from server
	 * This should be after check errors which poplulate pdu_fcall.
	 */
	trace_9p_protocol_dump(c, req->rc);
535
	if (err) {
536
		p9_debug(P9_DEBUG_ERROR, "couldn't parse header %d\n", err);
537 538
		return err;
	}
539 540
	if (type != P9_RERROR && type != P9_RLERROR)
		return 0;
541

542 543 544
	if (!p9_is_proto_dotl(c)) {
		char *ename;
		err = p9pdu_readf(req->rc, c->proto_version, "s?d",
545
				  &ename, &ecode);
546 547
		if (err)
			goto out_err;
548

549
		if (p9_is_proto_dotu(c) && ecode < 512)
550
			err = -ecode;
551

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

555 556
			p9_debug(P9_DEBUG_9P, "<<< RERROR (%d) %s\n",
				 -ecode, ename);
557
		}
558
		kfree(ename);
559 560 561 562
	} else {
		err = p9pdu_readf(req->rc, c->proto_version, "d", &ecode);
		err = -ecode;

563
		p9_debug(P9_DEBUG_9P, "<<< RLERROR (%d)\n", -ecode);
564
	}
565 566

	return err;
567 568

out_err:
569
	p9_debug(P9_DEBUG_ERROR, "couldn't parse error%d\n", err);
570 571

	return err;
572 573
}

574 575 576 577 578 579 580 581 582 583 584 585 586
/**
 * p9_check_zc_errors - check 9p packet for error return and process it
 * @c: current client instance
 * @req: request to parse and check for error conditions
 * @in_hdrlen: Size of response protocol buffer.
 *
 * 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_zc_errors(struct p9_client *c, struct p9_req_t *req,
587
			      struct iov_iter *uidata, int in_hdrlen)
588 589 590 591 592 593 594
{
	int err;
	int ecode;
	int8_t type;
	char *ename = NULL;

	err = p9_parse_header(req->rc, NULL, &type, NULL, 0);
595 596 597 598 599
	/*
	 * dump the response from server
	 * This should be after parse_header which poplulate pdu_fcall.
	 */
	trace_9p_protocol_dump(c, req->rc);
600
	if (err) {
601
		p9_debug(P9_DEBUG_ERROR, "couldn't parse header %d\n", err);
602 603 604 605 606 607 608 609
		return err;
	}

	if (type != P9_RERROR && type != P9_RLERROR)
		return 0;

	if (!p9_is_proto_dotl(c)) {
		/* Error is reported in string format */
610 611 612
		int len;
		/* 7 = header size for RERROR; */
		int inline_len = in_hdrlen - 7;
613

614 615 616
		len =  req->rc->size - req->rc->offset;
		if (len > (P9_ZC_HDR_SZ - 7)) {
			err = -EFAULT;
617 618 619
			goto out_err;
		}

620 621 622
		ename = &req->rc->sdata[req->rc->offset];
		if (len > inline_len) {
			/* We have error in external buffer */
623 624
			if (!copy_from_iter_full(ename + inline_len,
					     len - inline_len, uidata)) {
625 626
				err = -EFAULT;
				goto out_err;
627 628
			}
		}
629 630 631 632 633 634
		ename = NULL;
		err = p9pdu_readf(req->rc, c->proto_version, "s?d",
				  &ename, &ecode);
		if (err)
			goto out_err;

635
		if (p9_is_proto_dotu(c) && ecode < 512)
636
			err = -ecode;
637

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

641 642
			p9_debug(P9_DEBUG_9P, "<<< RERROR (%d) %s\n",
				 -ecode, ename);
643 644 645 646 647 648
		}
		kfree(ename);
	} else {
		err = p9pdu_readf(req->rc, c->proto_version, "d", &ecode);
		err = -ecode;

649
		p9_debug(P9_DEBUG_9P, "<<< RLERROR (%d)\n", -ecode);
650 651 652 653
	}
	return err;

out_err:
654
	p9_debug(P9_DEBUG_ERROR, "couldn't parse error%d\n", err);
655 656 657
	return err;
}

R
Rob Landley 已提交
658 659 660
static struct p9_req_t *
p9_client_rpc(struct p9_client *c, int8_t type, const char *fmt, ...);

661 662
/**
 * p9_client_flush - flush (cancel) a request
A
Abhishek Kulkarni 已提交
663 664
 * @c: client state
 * @oldreq: request to cancel
665
 *
R
Rob Landley 已提交
666
 * This sents a flush for a particular request and links
667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682
 * 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;

683
	p9_debug(P9_DEBUG_9P, ">>> TFLUSH tag %d\n", oldtag);
684 685 686 687 688

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

689 690
	/*
	 * if we haven't received a response for oldreq,
691
	 * remove it from the list
692
	 */
S
Simon Derr 已提交
693
	if (oldreq->status == REQ_STATUS_SENT)
694 695
		if (c->trans_mod->cancelled)
			c->trans_mod->cancelled(c, oldreq);
696 697

	p9_free_req(c, req);
698 699 700
	return 0;
}

701 702 703
static struct p9_req_t *p9_client_prepare_req(struct p9_client *c,
					      int8_t type, int req_size,
					      const char *fmt, va_list ap)
704
{
705
	int tag, err;
706 707
	struct p9_req_t *req;

708
	p9_debug(P9_DEBUG_MUX, "client %p op %d\n", c, type);
709

710 711 712 713 714 715
	/* we allow for any status other than disconnected */
	if (c->status == Disconnected)
		return ERR_PTR(-EIO);

	/* if status is begin_disconnected we allow only clunk request */
	if ((c->status == BeginDisconnect) && (type != P9_TCLUNK))
716
		return ERR_PTR(-EIO);
717 718

	tag = P9_NOTAG;
719
	if (type != P9_TVERSION) {
720 721
		tag = p9_idpool_get(c->tagpool);
		if (tag < 0)
722
			return ERR_PTR(-ENOMEM);
723 724
	}

725
	req = p9_tag_alloc(c, tag, req_size);
726 727
	if (IS_ERR(req))
		return req;
728

729 730
	/* marshall the data */
	p9pdu_prepare(req->tc, tag, type);
731
	err = p9pdu_vwritef(req->tc, c->proto_version, fmt, ap);
732 733
	if (err)
		goto reterr;
734 735
	p9pdu_finalize(c, req->tc);
	trace_9p_client_req(c, type, tag);
736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769
	return req;
reterr:
	p9_free_req(c, req);
	return ERR_PTR(err);
}

/**
 * p9_client_rpc - issue a request and wait for a response
 * @c: client session
 * @type: type of request
 * @fmt: protocol format string (see protocol.c)
 *
 * Returns request structure (which client must free using p9_free_req)
 */

static struct p9_req_t *
p9_client_rpc(struct p9_client *c, int8_t type, const char *fmt, ...)
{
	va_list ap;
	int sigpending, err;
	unsigned long flags;
	struct p9_req_t *req;

	va_start(ap, fmt);
	req = p9_client_prepare_req(c, type, c->msize, fmt, ap);
	va_end(ap);
	if (IS_ERR(req))
		return req;

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

	err = c->trans_mod->request(c, req);
	if (err < 0) {
773
		if (err != -ERESTARTSYS && err != -EFAULT)
774
			c->status = Disconnected;
775
		goto recalc_sigpending;
776
	}
777
again:
778
	/* Wait for the response */
779
	err = wait_event_killable(*req->wq, req->status >= REQ_STATUS_RCVD);
780

781 782 783 784 785 786
	/*
	 * Make sure our req is coherent with regard to updates in other
	 * threads - echoes to wmb() in the callback
	 */
	smp_rmb();

787 788 789 790 791 792 793
	if ((err == -ERESTARTSYS) && (c->status == Connected)
				  && (type == P9_TFLUSH)) {
		sigpending = 1;
		clear_thread_flag(TIF_SIGPENDING);
		goto again;
	}

794
	if (req->status == REQ_STATUS_ERROR) {
795
		p9_debug(P9_DEBUG_ERROR, "req_status error %d\n", req->t_err);
796 797
		err = req->t_err;
	}
798
	if ((err == -ERESTARTSYS) && (c->status == Connected)) {
799
		p9_debug(P9_DEBUG_MUX, "flushing\n");
800 801 802
		sigpending = 1;
		clear_thread_flag(TIF_SIGPENDING);

803 804 805 806 807 808
		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;
809
	}
810
recalc_sigpending:
811 812 813 814 815 816 817 818
	if (sigpending) {
		spin_lock_irqsave(&current->sighand->siglock, flags);
		recalc_sigpending();
		spin_unlock_irqrestore(&current->sighand->siglock, flags);
	}
	if (err < 0)
		goto reterr;

819
	err = p9_check_errors(c, req);
820 821
	trace_9p_client_res(c, type, req->rc->tag, err);
	if (!err)
822
		return req;
823 824
reterr:
	p9_free_req(c, req);
S
Simon Derr 已提交
825
	return ERR_PTR(safe_errno(err));
826 827 828 829 830 831
}

/**
 * p9_client_zc_rpc - issue a request and wait for a response
 * @c: client session
 * @type: type of request
832 833
 * @uidata: destination for zero copy read
 * @uodata: source for zero copy write
834 835 836 837 838 839 840 841
 * @inlen: read buffer size
 * @olen: write buffer size
 * @hdrlen: reader header size, This is the size of response protocol data
 * @fmt: protocol format string (see protocol.c)
 *
 * Returns request structure (which client must free using p9_free_req)
 */
static struct p9_req_t *p9_client_zc_rpc(struct p9_client *c, int8_t type,
842 843
					 struct iov_iter *uidata,
					 struct iov_iter *uodata,
844
					 int inlen, int olen, int in_hdrlen,
845
					 const char *fmt, ...)
846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868
{
	va_list ap;
	int sigpending, err;
	unsigned long flags;
	struct p9_req_t *req;

	va_start(ap, fmt);
	/*
	 * We allocate a inline protocol data of only 4k bytes.
	 * The actual content is passed in zero-copy fashion.
	 */
	req = p9_client_prepare_req(c, type, P9_ZC_HDR_SZ, fmt, ap);
	va_end(ap);
	if (IS_ERR(req))
		return req;

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

	err = c->trans_mod->zc_request(c, req, uidata, uodata,
869
				       inlen, olen, in_hdrlen);
870 871 872
	if (err < 0) {
		if (err == -EIO)
			c->status = Disconnected;
873
		if (err != -ERESTARTSYS)
874
			goto recalc_sigpending;
875 876
	}
	if (req->status == REQ_STATUS_ERROR) {
877
		p9_debug(P9_DEBUG_ERROR, "req_status error %d\n", req->t_err);
878 879 880
		err = req->t_err;
	}
	if ((err == -ERESTARTSYS) && (c->status == Connected)) {
881
		p9_debug(P9_DEBUG_MUX, "flushing\n");
882 883
		sigpending = 1;
		clear_thread_flag(TIF_SIGPENDING);
884

885 886 887 888 889 890 891
		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;
	}
892
recalc_sigpending:
893 894 895 896 897 898 899 900
	if (sigpending) {
		spin_lock_irqsave(&current->sighand->siglock, flags);
		recalc_sigpending();
		spin_unlock_irqrestore(&current->sighand->siglock, flags);
	}
	if (err < 0)
		goto reterr;

901
	err = p9_check_zc_errors(c, req, uidata, in_hdrlen);
902 903
	trace_9p_client_res(c, type, req->rc->tag, err);
	if (!err)
904
		return req;
905 906
reterr:
	p9_free_req(c, req);
S
Simon Derr 已提交
907
	return ERR_PTR(safe_errno(err));
908 909
}

910 911
static struct p9_fid *p9_fid_create(struct p9_client *clnt)
{
R
Roel Kluin 已提交
912
	int ret;
913
	struct p9_fid *fid;
914
	unsigned long flags;
915

916
	p9_debug(P9_DEBUG_FID, "clnt %p\n", clnt);
917 918 919 920
	fid = kmalloc(sizeof(struct p9_fid), GFP_KERNEL);
	if (!fid)
		return ERR_PTR(-ENOMEM);

R
Roel Kluin 已提交
921
	ret = p9_idpool_get(clnt->fidpool);
922
	if (ret < 0) {
R
Roel Kluin 已提交
923
		ret = -ENOSPC;
924 925
		goto error;
	}
R
Roel Kluin 已提交
926
	fid->fid = ret;
927 928 929

	memset(&fid->qid, 0, sizeof(struct p9_qid));
	fid->mode = -1;
930
	fid->uid = current_fsuid();
931
	fid->clnt = clnt;
E
Eric Van Hensbergen 已提交
932
	fid->rdir = NULL;
933
	spin_lock_irqsave(&clnt->lock, flags);
934
	list_add(&fid->flist, &clnt->fidlist);
935
	spin_unlock_irqrestore(&clnt->lock, flags);
936 937 938 939 940

	return fid;

error:
	kfree(fid);
R
Roel Kluin 已提交
941
	return ERR_PTR(ret);
942 943 944 945 946
}

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

949
	p9_debug(P9_DEBUG_FID, "fid %d\n", fid->fid);
950 951
	clnt = fid->clnt;
	p9_idpool_put(fid->fid, clnt->fidpool);
952
	spin_lock_irqsave(&clnt->lock, flags);
953
	list_del(&fid->flist);
954
	spin_unlock_irqrestore(&clnt->lock, flags);
E
Eric Van Hensbergen 已提交
955
	kfree(fid->rdir);
956 957
	kfree(fid);
}
958

S
stephen hemminger 已提交
959
static int p9_client_version(struct p9_client *c)
960
{
961
	int err = 0;
962 963 964
	struct p9_req_t *req;
	char *version;
	int msize;
965

966 967
	p9_debug(P9_DEBUG_9P, ">>> TVERSION msize %d protocol %d\n",
		 c->msize, c->proto_version);
968 969

	switch (c->proto_version) {
970
	case p9_proto_2000L:
971
		req = p9_client_rpc(c, P9_TVERSION, "ds",
972
					c->msize, "9P2000.L");
973 974 975 976 977 978 979 980 981 982 983 984 985
		break;
	case p9_proto_2000u:
		req = p9_client_rpc(c, P9_TVERSION, "ds",
					c->msize, "9P2000.u");
		break;
	case p9_proto_legacy:
		req = p9_client_rpc(c, P9_TVERSION, "ds",
					c->msize, "9P2000");
		break;
	default:
		return -EINVAL;
	}

986 987
	if (IS_ERR(req))
		return PTR_ERR(req);
988

989
	err = p9pdu_readf(req->rc, c->proto_version, "ds", &msize, &version);
990
	if (err) {
991
		p9_debug(P9_DEBUG_9P, "version error %d\n", err);
992
		trace_9p_protocol_dump(c, req->rc);
993
		goto error;
994
	}
995

996
	p9_debug(P9_DEBUG_9P, "<<< RVERSION msize %d %s\n", msize, version);
997 998
	if (!strncmp(version, "9P2000.L", 8))
		c->proto_version = p9_proto_2000L;
999
	else if (!strncmp(version, "9P2000.u", 8))
1000 1001 1002
		c->proto_version = p9_proto_2000u;
	else if (!strncmp(version, "9P2000", 6))
		c->proto_version = p9_proto_legacy;
1003 1004 1005 1006 1007
	else {
		err = -EREMOTEIO;
		goto error;
	}

1008 1009
	if (msize < c->msize)
		c->msize = msize;
1010 1011

error:
1012 1013
	kfree(version);
	p9_free_req(c, req);
1014 1015 1016 1017 1018 1019 1020 1021

	return err;
}

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

	err = 0;
1025 1026 1027 1028
	clnt = kmalloc(sizeof(struct p9_client), GFP_KERNEL);
	if (!clnt)
		return ERR_PTR(-ENOMEM);

1029
	clnt->trans_mod = NULL;
1030
	clnt->trans = NULL;
1031 1032 1033 1034

	client_id = utsname()->nodename;
	memcpy(clnt->name, client_id, strlen(client_id) + 1);

1035 1036 1037
	spin_lock_init(&clnt->lock);
	INIT_LIST_HEAD(&clnt->fidlist);

1038 1039 1040
	err = p9_tag_init(clnt);
	if (err < 0)
		goto free_client;
1041

1042 1043
	err = parse_opts(options, clnt);
	if (err < 0)
1044
		goto destroy_tagpool;
1045

1046 1047 1048
	if (!clnt->trans_mod)
		clnt->trans_mod = v9fs_get_default_trans();

1049 1050
	if (clnt->trans_mod == NULL) {
		err = -EPROTONOSUPPORT;
1051 1052
		p9_debug(P9_DEBUG_ERROR,
			 "No transport defined or default transport\n");
1053
		goto destroy_tagpool;
1054 1055 1056 1057 1058 1059
	}

	clnt->fidpool = p9_idpool_create();
	if (IS_ERR(clnt->fidpool)) {
		err = PTR_ERR(clnt->fidpool);
		goto put_trans;
1060 1061
	}

1062 1063
	p9_debug(P9_DEBUG_MUX, "clnt %p trans %p msize %d protocol %d\n",
		 clnt, clnt->trans_mod, clnt->msize, clnt->proto_version);
1064

1065 1066
	err = clnt->trans_mod->create(clnt, dev_name, options);
	if (err)
1067
		goto destroy_fidpool;
1068

1069 1070
	if (clnt->msize > clnt->trans_mod->maxsize)
		clnt->msize = clnt->trans_mod->maxsize;
1071

1072
	err = p9_client_version(clnt);
1073
	if (err)
1074
		goto close_trans;
1075 1076 1077

	return clnt;

1078 1079 1080 1081 1082 1083
close_trans:
	clnt->trans_mod->close(clnt);
destroy_fidpool:
	p9_idpool_destroy(clnt->fidpool);
put_trans:
	v9fs_put_trans(clnt->trans_mod);
1084 1085
destroy_tagpool:
	p9_idpool_destroy(clnt->tagpool);
1086 1087
free_client:
	kfree(clnt);
1088 1089 1090 1091 1092 1093 1094 1095
	return ERR_PTR(err);
}
EXPORT_SYMBOL(p9_client_create);

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

1096
	p9_debug(P9_DEBUG_MUX, "clnt %p\n", clnt);
1097

1098 1099
	if (clnt->trans_mod)
		clnt->trans_mod->close(clnt);
1100

1101 1102
	v9fs_put_trans(clnt->trans_mod);

1103
	list_for_each_entry_safe(fid, fidptr, &clnt->fidlist, flist) {
1104
		pr_info("Found fid %d not clunked\n", fid->fid);
1105
		p9_fid_destroy(fid);
1106
	}
1107

1108 1109 1110
	if (clnt->fidpool)
		p9_idpool_destroy(clnt->fidpool);

1111 1112
	p9_tag_cleanup(clnt);

1113 1114 1115 1116 1117 1118
	kfree(clnt);
}
EXPORT_SYMBOL(p9_client_destroy);

void p9_client_disconnect(struct p9_client *clnt)
{
1119
	p9_debug(P9_DEBUG_9P, "clnt %p\n", clnt);
1120
	clnt->status = Disconnected;
1121 1122 1123
}
EXPORT_SYMBOL(p9_client_disconnect);

1124 1125
void p9_client_begin_disconnect(struct p9_client *clnt)
{
1126
	p9_debug(P9_DEBUG_9P, "clnt %p\n", clnt);
1127 1128 1129 1130
	clnt->status = BeginDisconnect;
}
EXPORT_SYMBOL(p9_client_begin_disconnect);

1131
struct p9_fid *p9_client_attach(struct p9_client *clnt, struct p9_fid *afid,
A
Al Viro 已提交
1132
	const char *uname, kuid_t n_uname, const char *aname)
1133
{
1134
	int err = 0;
1135
	struct p9_req_t *req;
1136
	struct p9_fid *fid;
1137
	struct p9_qid qid;
1138 1139


1140 1141
	p9_debug(P9_DEBUG_9P, ">>> TATTACH afid %d uname %s aname %s\n",
		 afid ? afid->fid : -1, uname, aname);
1142 1143 1144 1145 1146 1147
	fid = p9_fid_create(clnt);
	if (IS_ERR(fid)) {
		err = PTR_ERR(fid);
		fid = NULL;
		goto error;
	}
1148
	fid->uid = n_uname;
1149

1150
	req = p9_client_rpc(clnt, P9_TATTACH, "ddss?u", fid->fid,
1151 1152 1153
			afid ? afid->fid : P9_NOFID, uname, aname, n_uname);
	if (IS_ERR(req)) {
		err = PTR_ERR(req);
1154 1155 1156
		goto error;
	}

1157
	err = p9pdu_readf(req->rc, clnt->proto_version, "Q", &qid);
1158
	if (err) {
1159
		trace_9p_protocol_dump(clnt, req->rc);
1160
		p9_free_req(clnt, req);
1161
		goto error;
1162
	}
1163

1164 1165
	p9_debug(P9_DEBUG_9P, "<<< RATTACH qid %x.%llx.%x\n",
		 qid.type, (unsigned long long)qid.path, qid.version);
1166 1167 1168 1169

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

	p9_free_req(clnt, req);
1170 1171 1172 1173 1174 1175 1176 1177 1178
	return fid;

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

1179
struct p9_fid *p9_client_walk(struct p9_fid *oldfid, uint16_t nwname,
A
Al Viro 已提交
1180
		const unsigned char * const *wnames, int clone)
1181 1182 1183 1184
{
	int err;
	struct p9_client *clnt;
	struct p9_fid *fid;
1185 1186
	struct p9_qid *wqids;
	struct p9_req_t *req;
1187
	uint16_t nwqids, count;
1188 1189

	err = 0;
1190
	wqids = NULL;
1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203
	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;

1204

1205 1206
	p9_debug(P9_DEBUG_9P, ">>> TWALK fids %d,%d nwname %ud wname[0] %s\n",
		 oldfid->fid, fid->fid, nwname, wnames ? wnames[0] : NULL);
1207 1208 1209 1210 1211

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

1215
	err = p9pdu_readf(req->rc, clnt->proto_version, "R", &nwqids, &wqids);
E
Eric Van Hensbergen 已提交
1216
	if (err) {
1217
		trace_9p_protocol_dump(clnt, req->rc);
E
Eric Van Hensbergen 已提交
1218
		p9_free_req(clnt, req);
1219
		goto clunk_fid;
E
Eric Van Hensbergen 已提交
1220 1221
	}
	p9_free_req(clnt, req);
1222

1223
	p9_debug(P9_DEBUG_9P, "<<< RWALK nwqid %d:\n", nwqids);
1224 1225

	if (nwqids != nwname) {
1226 1227 1228 1229
		err = -ENOENT;
		goto clunk_fid;
	}

1230
	for (count = 0; count < nwqids; count++)
1231
		p9_debug(P9_DEBUG_9P, "<<<     [%d] %x.%llx.%x\n",
R
Randy Dunlap 已提交
1232 1233
			count, wqids[count].type,
			(unsigned long long)wqids[count].path,
1234 1235
			wqids[count].version);

1236
	if (nwname)
1237
		memmove(&fid->qid, &wqids[nwqids - 1], sizeof(struct p9_qid));
1238 1239 1240
	else
		fid->qid = oldfid->qid;

1241
	kfree(wqids);
1242 1243 1244
	return fid;

clunk_fid:
1245
	kfree(wqids);
1246 1247
	p9_client_clunk(fid);
	fid = NULL;
1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260

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;
1261 1262 1263
	struct p9_req_t *req;
	struct p9_qid qid;
	int iounit;
1264 1265

	clnt = fid->clnt;
1266
	p9_debug(P9_DEBUG_9P, ">>> %s fid %d mode %d\n",
M
M. Mohan Kumar 已提交
1267 1268
		p9_is_proto_dotl(clnt) ? "TLOPEN" : "TOPEN", fid->fid, mode);
	err = 0;
1269 1270 1271 1272

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

M
M. Mohan Kumar 已提交
1273 1274 1275 1276
	if (p9_is_proto_dotl(clnt))
		req = p9_client_rpc(clnt, P9_TLOPEN, "dd", fid->fid, mode);
	else
		req = p9_client_rpc(clnt, P9_TOPEN, "db", fid->fid, mode);
1277 1278 1279
	if (IS_ERR(req)) {
		err = PTR_ERR(req);
		goto error;
1280 1281
	}

1282
	err = p9pdu_readf(req->rc, clnt->proto_version, "Qd", &qid, &iounit);
E
Eric Van Hensbergen 已提交
1283
	if (err) {
1284
		trace_9p_protocol_dump(clnt, req->rc);
E
Eric Van Hensbergen 已提交
1285 1286
		goto free_and_error;
	}
1287

1288
	p9_debug(P9_DEBUG_9P, "<<< %s qid %x.%llx.%x iounit %x\n",
M
M. Mohan Kumar 已提交
1289 1290
		p9_is_proto_dotl(clnt) ? "RLOPEN" : "ROPEN",  qid.type,
		(unsigned long long)qid.path, qid.version, iounit);
1291 1292

	fid->mode = mode;
1293
	fid->iounit = iounit;
1294

E
Eric Van Hensbergen 已提交
1295 1296
free_and_error:
	p9_free_req(clnt, req);
1297
error:
1298 1299 1300 1301
	return err;
}
EXPORT_SYMBOL(p9_client_open);

A
Al Viro 已提交
1302
int p9_client_create_dotl(struct p9_fid *ofid, const char *name, u32 flags, u32 mode,
1303
		kgid_t gid, struct p9_qid *qid)
1304 1305 1306 1307 1308 1309
{
	int err = 0;
	struct p9_client *clnt;
	struct p9_req_t *req;
	int iounit;

1310
	p9_debug(P9_DEBUG_9P,
1311
			">>> TLCREATE fid %d name %s flags %d mode %d gid %d\n",
1312 1313
			ofid->fid, name, flags, mode,
		 	from_kgid(&init_user_ns, gid));
1314 1315 1316 1317 1318
	clnt = ofid->clnt;

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

1319
	req = p9_client_rpc(clnt, P9_TLCREATE, "dsddg", ofid->fid, name, flags,
1320 1321 1322 1323 1324 1325 1326 1327
			mode, gid);
	if (IS_ERR(req)) {
		err = PTR_ERR(req);
		goto error;
	}

	err = p9pdu_readf(req->rc, clnt->proto_version, "Qd", qid, &iounit);
	if (err) {
1328
		trace_9p_protocol_dump(clnt, req->rc);
1329 1330 1331
		goto free_and_error;
	}

1332
	p9_debug(P9_DEBUG_9P, "<<< RLCREATE qid %x.%llx.%x iounit %x\n",
1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346
			qid->type,
			(unsigned long long)qid->path,
			qid->version, iounit);

	ofid->mode = mode;
	ofid->iounit = iounit;

free_and_error:
	p9_free_req(clnt, req);
error:
	return err;
}
EXPORT_SYMBOL(p9_client_create_dotl);

A
Al Viro 已提交
1347
int p9_client_fcreate(struct p9_fid *fid, const char *name, u32 perm, int mode,
1348 1349 1350 1351
		     char *extension)
{
	int err;
	struct p9_client *clnt;
1352 1353 1354
	struct p9_req_t *req;
	struct p9_qid qid;
	int iounit;
1355

1356
	p9_debug(P9_DEBUG_9P, ">>> TCREATE fid %d name %s perm %d mode %d\n",
1357
						fid->fid, name, perm, mode);
1358 1359 1360 1361 1362 1363
	err = 0;
	clnt = fid->clnt;

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

1364 1365 1366 1367 1368
	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;
1369 1370
	}

1371
	err = p9pdu_readf(req->rc, clnt->proto_version, "Qd", &qid, &iounit);
E
Eric Van Hensbergen 已提交
1372
	if (err) {
1373
		trace_9p_protocol_dump(clnt, req->rc);
E
Eric Van Hensbergen 已提交
1374 1375
		goto free_and_error;
	}
1376

1377
	p9_debug(P9_DEBUG_9P, "<<< RCREATE qid %x.%llx.%x iounit %x\n",
R
Randy Dunlap 已提交
1378 1379 1380
				qid.type,
				(unsigned long long)qid.path,
				qid.version, iounit);
1381 1382

	fid->mode = mode;
1383
	fid->iounit = iounit;
1384

E
Eric Van Hensbergen 已提交
1385 1386
free_and_error:
	p9_free_req(clnt, req);
1387
error:
1388 1389 1390 1391
	return err;
}
EXPORT_SYMBOL(p9_client_fcreate);

A
Al Viro 已提交
1392 1393
int p9_client_symlink(struct p9_fid *dfid, const char *name,
		const char *symtgt, kgid_t gid, struct p9_qid *qid)
1394 1395 1396 1397 1398
{
	int err = 0;
	struct p9_client *clnt;
	struct p9_req_t *req;

1399
	p9_debug(P9_DEBUG_9P, ">>> TSYMLINK dfid %d name %s  symtgt %s\n",
1400 1401 1402
			dfid->fid, name, symtgt);
	clnt = dfid->clnt;

1403
	req = p9_client_rpc(clnt, P9_TSYMLINK, "dssg", dfid->fid, name, symtgt,
1404 1405 1406 1407 1408 1409 1410 1411
			gid);
	if (IS_ERR(req)) {
		err = PTR_ERR(req);
		goto error;
	}

	err = p9pdu_readf(req->rc, clnt->proto_version, "Q", qid);
	if (err) {
1412
		trace_9p_protocol_dump(clnt, req->rc);
1413 1414 1415
		goto free_and_error;
	}

1416
	p9_debug(P9_DEBUG_9P, "<<< RSYMLINK qid %x.%llx.%x\n",
1417 1418 1419 1420 1421 1422 1423 1424 1425
			qid->type, (unsigned long long)qid->path, qid->version);

free_and_error:
	p9_free_req(clnt, req);
error:
	return err;
}
EXPORT_SYMBOL(p9_client_symlink);

A
Al Viro 已提交
1426
int p9_client_link(struct p9_fid *dfid, struct p9_fid *oldfid, const char *newname)
1427 1428 1429 1430
{
	struct p9_client *clnt;
	struct p9_req_t *req;

1431
	p9_debug(P9_DEBUG_9P, ">>> TLINK dfid %d oldfid %d newname %s\n",
1432 1433 1434 1435 1436 1437 1438
			dfid->fid, oldfid->fid, newname);
	clnt = dfid->clnt;
	req = p9_client_rpc(clnt, P9_TLINK, "dds", dfid->fid, oldfid->fid,
			newname);
	if (IS_ERR(req))
		return PTR_ERR(req);

1439
	p9_debug(P9_DEBUG_9P, "<<< RLINK\n");
1440 1441 1442 1443 1444
	p9_free_req(clnt, req);
	return 0;
}
EXPORT_SYMBOL(p9_client_link);

1445
int p9_client_fsync(struct p9_fid *fid, int datasync)
1446 1447 1448 1449 1450
{
	int err;
	struct p9_client *clnt;
	struct p9_req_t *req;

1451
	p9_debug(P9_DEBUG_9P, ">>> TFSYNC fid %d datasync:%d\n",
1452
			fid->fid, datasync);
1453 1454 1455
	err = 0;
	clnt = fid->clnt;

1456
	req = p9_client_rpc(clnt, P9_TFSYNC, "dd", fid->fid, datasync);
1457 1458 1459 1460 1461
	if (IS_ERR(req)) {
		err = PTR_ERR(req);
		goto error;
	}

1462
	p9_debug(P9_DEBUG_9P, "<<< RFSYNC fid %d\n", fid->fid);
1463 1464 1465 1466 1467 1468 1469 1470

	p9_free_req(clnt, req);

error:
	return err;
}
EXPORT_SYMBOL(p9_client_fsync);

1471 1472 1473 1474
int p9_client_clunk(struct p9_fid *fid)
{
	int err;
	struct p9_client *clnt;
1475
	struct p9_req_t *req;
1476
	int retries = 0;
1477

1478
	if (!fid) {
1479 1480
		pr_warn("%s (%d): Trying to clunk with NULL fid\n",
			__func__, task_pid_nr(current));
1481 1482 1483 1484
		dump_stack();
		return 0;
	}

1485 1486 1487
again:
	p9_debug(P9_DEBUG_9P, ">>> TCLUNK fid %d (try %d)\n", fid->fid,
								retries);
1488 1489 1490
	err = 0;
	clnt = fid->clnt;

1491 1492 1493 1494
	req = p9_client_rpc(clnt, P9_TCLUNK, "d", fid->fid);
	if (IS_ERR(req)) {
		err = PTR_ERR(req);
		goto error;
1495 1496
	}

1497
	p9_debug(P9_DEBUG_9P, "<<< RCLUNK fid %d\n", fid->fid);
1498

1499 1500
	p9_free_req(clnt, req);
error:
1501 1502
	/*
	 * Fid is not valid even after a failed clunk
1503 1504
	 * If interrupted, retry once then give up and
	 * leak fid until umount.
1505
	 */
1506 1507 1508 1509 1510
	if (err == -ERESTARTSYS) {
		if (retries++ == 0)
			goto again;
	} else
		p9_fid_destroy(fid);
1511 1512 1513 1514 1515 1516 1517 1518
	return err;
}
EXPORT_SYMBOL(p9_client_clunk);

int p9_client_remove(struct p9_fid *fid)
{
	int err;
	struct p9_client *clnt;
1519
	struct p9_req_t *req;
1520

1521
	p9_debug(P9_DEBUG_9P, ">>> TREMOVE fid %d\n", fid->fid);
1522 1523 1524
	err = 0;
	clnt = fid->clnt;

1525 1526 1527 1528
	req = p9_client_rpc(clnt, P9_TREMOVE, "d", fid->fid);
	if (IS_ERR(req)) {
		err = PTR_ERR(req);
		goto error;
1529 1530
	}

1531
	p9_debug(P9_DEBUG_9P, "<<< RREMOVE fid %d\n", fid->fid);
1532

1533 1534
	p9_free_req(clnt, req);
error:
1535 1536 1537 1538
	if (err == -ERESTARTSYS)
		p9_client_clunk(fid);
	else
		p9_fid_destroy(fid);
1539 1540 1541 1542
	return err;
}
EXPORT_SYMBOL(p9_client_remove);

1543 1544 1545 1546 1547 1548
int p9_client_unlinkat(struct p9_fid *dfid, const char *name, int flags)
{
	int err = 0;
	struct p9_req_t *req;
	struct p9_client *clnt;

1549
	p9_debug(P9_DEBUG_9P, ">>> TUNLINKAT fid %d %s %d\n",
1550 1551 1552 1553 1554 1555 1556 1557
		   dfid->fid, name, flags);

	clnt = dfid->clnt;
	req = p9_client_rpc(clnt, P9_TUNLINKAT, "dsd", dfid->fid, name, flags);
	if (IS_ERR(req)) {
		err = PTR_ERR(req);
		goto error;
	}
1558
	p9_debug(P9_DEBUG_9P, "<<< RUNLINKAT fid %d %s\n", dfid->fid, name);
1559 1560 1561 1562 1563 1564 1565

	p9_free_req(clnt, req);
error:
	return err;
}
EXPORT_SYMBOL(p9_client_unlinkat);

1566
int
1567
p9_client_read(struct p9_fid *fid, u64 offset, struct iov_iter *to, int *err)
1568
{
1569
	struct p9_client *clnt = fid->clnt;
1570
	struct p9_req_t *req;
1571
	int total = 0;
1572
	*err = 0;
1573

1574
	p9_debug(P9_DEBUG_9P, ">>> TREAD fid %d offset %llu %d\n",
1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606
		   fid->fid, (unsigned long long) offset, (int)iov_iter_count(to));

	while (iov_iter_count(to)) {
		int count = iov_iter_count(to);
		int rsize, non_zc = 0;
		char *dataptr;
			
		rsize = fid->iounit;
		if (!rsize || rsize > clnt->msize-P9_IOHDRSZ)
			rsize = clnt->msize - P9_IOHDRSZ;

		if (count < rsize)
			rsize = count;

		/* Don't bother zerocopy for small IO (< 1024) */
		if (clnt->trans_mod->zc_request && rsize > 1024) {
			/*
			 * response header len is 11
			 * PDU Header(7) + IO Size (4)
			 */
			req = p9_client_zc_rpc(clnt, P9_TREAD, to, NULL, rsize,
					       0, 11, "dqd", fid->fid,
					       offset, rsize);
		} else {
			non_zc = 1;
			req = p9_client_rpc(clnt, P9_TREAD, "dqd", fid->fid, offset,
					    rsize);
		}
		if (IS_ERR(req)) {
			*err = PTR_ERR(req);
			break;
		}
1607

1608 1609 1610 1611 1612 1613 1614
		*err = p9pdu_readf(req->rc, clnt->proto_version,
				   "D", &count, &dataptr);
		if (*err) {
			trace_9p_protocol_dump(clnt, req->rc);
			p9_free_req(clnt, req);
			break;
		}
1615 1616 1617 1618
		if (rsize < count) {
			pr_err("bogus RREAD count (%d > %d)\n", count, rsize);
			count = rsize;
		}
1619

1620 1621 1622 1623 1624
		p9_debug(P9_DEBUG_9P, "<<< RREAD count %d\n", count);
		if (!count) {
			p9_free_req(clnt, req);
			break;
		}
1625

1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640
		if (non_zc) {
			int n = copy_to_iter(dataptr, count, to);
			total += n;
			offset += n;
			if (n != count) {
				*err = -EFAULT;
				p9_free_req(clnt, req);
				break;
			}
		} else {
			iov_iter_advance(to, count);
			total += count;
			offset += count;
		}
		p9_free_req(clnt, req);
1641
	}
1642
	return total;
1643
}
1644
EXPORT_SYMBOL(p9_client_read);
1645 1646

int
1647
p9_client_write(struct p9_fid *fid, u64 offset, struct iov_iter *from, int *err)
1648
{
1649
	struct p9_client *clnt = fid->clnt;
1650
	struct p9_req_t *req;
1651
	int total = 0;
1652
	*err = 0;
1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679

	p9_debug(P9_DEBUG_9P, ">>> TWRITE fid %d offset %llu count %zd\n",
				fid->fid, (unsigned long long) offset,
				iov_iter_count(from));

	while (iov_iter_count(from)) {
		int count = iov_iter_count(from);
		int rsize = fid->iounit;
		if (!rsize || rsize > clnt->msize-P9_IOHDRSZ)
			rsize = clnt->msize - P9_IOHDRSZ;

		if (count < rsize)
			rsize = count;

		/* Don't bother zerocopy for small IO (< 1024) */
		if (clnt->trans_mod->zc_request && rsize > 1024) {
			req = p9_client_zc_rpc(clnt, P9_TWRITE, NULL, from, 0,
					       rsize, P9_ZC_HDR_SZ, "dqd",
					       fid->fid, offset, rsize);
		} else {
			req = p9_client_rpc(clnt, P9_TWRITE, "dqV", fid->fid,
						    offset, rsize, from);
		}
		if (IS_ERR(req)) {
			*err = PTR_ERR(req);
			break;
		}
1680

1681 1682 1683 1684
		*err = p9pdu_readf(req->rc, clnt->proto_version, "d", &count);
		if (*err) {
			trace_9p_protocol_dump(clnt, req->rc);
			p9_free_req(clnt, req);
1685
			break;
1686
		}
1687 1688 1689 1690
		if (rsize < count) {
			pr_err("bogus RWRITE count (%d > %d)\n", count, rsize);
			count = rsize;
		}
1691

1692
		p9_debug(P9_DEBUG_9P, "<<< RWRITE count %d\n", count);
1693

1694 1695 1696 1697
		p9_free_req(clnt, req);
		iov_iter_advance(from, count);
		total += count;
		offset += count;
E
Eric Van Hensbergen 已提交
1698
	}
1699
	return total;
1700
}
1701
EXPORT_SYMBOL(p9_client_write);
1702

1703
struct p9_wstat *p9_client_stat(struct p9_fid *fid)
1704
{
1705 1706 1707 1708 1709
	int err;
	struct p9_client *clnt;
	struct p9_wstat *ret = kmalloc(sizeof(struct p9_wstat), GFP_KERNEL);
	struct p9_req_t *req;
	u16 ignored;
1710

1711
	p9_debug(P9_DEBUG_9P, ">>> TSTAT fid %d\n", fid->fid);
1712 1713 1714 1715

	if (!ret)
		return ERR_PTR(-ENOMEM);

1716 1717 1718
	err = 0;
	clnt = fid->clnt;

1719 1720 1721
	req = p9_client_rpc(clnt, P9_TSTAT, "d", fid->fid);
	if (IS_ERR(req)) {
		err = PTR_ERR(req);
1722 1723 1724
		goto error;
	}

1725
	err = p9pdu_readf(req->rc, clnt->proto_version, "wS", &ignored, ret);
E
Eric Van Hensbergen 已提交
1726
	if (err) {
1727
		trace_9p_protocol_dump(clnt, req->rc);
1728 1729
		p9_free_req(clnt, req);
		goto error;
E
Eric Van Hensbergen 已提交
1730
	}
1731

1732
	p9_debug(P9_DEBUG_9P,
E
Eric Van Hensbergen 已提交
1733 1734 1735 1736
		"<<< RSTAT sz=%x type=%x dev=%x qid=%x.%llx.%x\n"
		"<<<    mode=%8.8x atime=%8.8x mtime=%8.8x length=%llx\n"
		"<<<    name=%s uid=%s gid=%s muid=%s extension=(%s)\n"
		"<<<    uid=%d gid=%d n_muid=%d\n",
1737
		ret->size, ret->type, ret->dev, ret->qid.type,
R
Randy Dunlap 已提交
1738 1739 1740
		(unsigned long long)ret->qid.path, ret->qid.version, ret->mode,
		ret->atime, ret->mtime, (unsigned long long)ret->length,
		ret->name, ret->uid, ret->gid, ret->muid, ret->extension,
1741 1742 1743
		from_kuid(&init_user_ns, ret->n_uid),
		from_kgid(&init_user_ns, ret->n_gid),
		from_kuid(&init_user_ns, ret->n_muid));
1744

1745 1746 1747
	p9_free_req(clnt, req);
	return ret;

1748
error:
1749 1750
	kfree(ret);
	return ERR_PTR(err);
1751 1752 1753
}
EXPORT_SYMBOL(p9_client_stat);

1754 1755 1756 1757 1758 1759 1760 1761 1762
struct p9_stat_dotl *p9_client_getattr_dotl(struct p9_fid *fid,
							u64 request_mask)
{
	int err;
	struct p9_client *clnt;
	struct p9_stat_dotl *ret = kmalloc(sizeof(struct p9_stat_dotl),
								GFP_KERNEL);
	struct p9_req_t *req;

1763
	p9_debug(P9_DEBUG_9P, ">>> TGETATTR fid %d, request_mask %lld\n",
1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779
							fid->fid, request_mask);

	if (!ret)
		return ERR_PTR(-ENOMEM);

	err = 0;
	clnt = fid->clnt;

	req = p9_client_rpc(clnt, P9_TGETATTR, "dq", fid->fid, request_mask);
	if (IS_ERR(req)) {
		err = PTR_ERR(req);
		goto error;
	}

	err = p9pdu_readf(req->rc, clnt->proto_version, "A", ret);
	if (err) {
1780
		trace_9p_protocol_dump(clnt, req->rc);
1781 1782 1783 1784
		p9_free_req(clnt, req);
		goto error;
	}

1785
	p9_debug(P9_DEBUG_9P,
1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796
		"<<< RGETATTR st_result_mask=%lld\n"
		"<<< qid=%x.%llx.%x\n"
		"<<< st_mode=%8.8x st_nlink=%llu\n"
		"<<< st_uid=%d st_gid=%d\n"
		"<<< st_rdev=%llx st_size=%llx st_blksize=%llu st_blocks=%llu\n"
		"<<< st_atime_sec=%lld st_atime_nsec=%lld\n"
		"<<< st_mtime_sec=%lld st_mtime_nsec=%lld\n"
		"<<< st_ctime_sec=%lld st_ctime_nsec=%lld\n"
		"<<< st_btime_sec=%lld st_btime_nsec=%lld\n"
		"<<< st_gen=%lld st_data_version=%lld",
		ret->st_result_mask, ret->qid.type, ret->qid.path,
1797 1798 1799 1800
		ret->qid.version, ret->st_mode, ret->st_nlink,
		from_kuid(&init_user_ns, ret->st_uid),
		from_kgid(&init_user_ns, ret->st_gid),
		ret->st_rdev, ret->st_size, ret->st_blksize,
1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814
		ret->st_blocks, ret->st_atime_sec, ret->st_atime_nsec,
		ret->st_mtime_sec, ret->st_mtime_nsec, ret->st_ctime_sec,
		ret->st_ctime_nsec, ret->st_btime_sec, ret->st_btime_nsec,
		ret->st_gen, ret->st_data_version);

	p9_free_req(clnt, req);
	return ret;

error:
	kfree(ret);
	return ERR_PTR(err);
}
EXPORT_SYMBOL(p9_client_getattr_dotl);

1815
static int p9_client_statsize(struct p9_wstat *wst, int proto_version)
1816 1817 1818
{
	int ret;

1819
	/* NOTE: size shouldn't include its own length */
1820 1821 1822
	/* size[2] type[2] dev[4] qid[13] */
	/* mode[4] atime[4] mtime[4] length[8]*/
	/* name[s] uid[s] gid[s] muid[s] */
1823
	ret = 2+4+13+4+4+4+8+2+2+2+2;
1824 1825 1826 1827 1828 1829 1830 1831 1832 1833

	if (wst->name)
		ret += strlen(wst->name);
	if (wst->uid)
		ret += strlen(wst->uid);
	if (wst->gid)
		ret += strlen(wst->gid);
	if (wst->muid)
		ret += strlen(wst->muid);

1834 1835
	if ((proto_version == p9_proto_2000u) ||
		(proto_version == p9_proto_2000L)) {
1836 1837 1838 1839 1840 1841 1842 1843
		ret += 2+4+4+4;	/* extension[s] n_uid[4] n_gid[4] n_muid[4] */
		if (wst->extension)
			ret += strlen(wst->extension);
	}

	return ret;
}

1844 1845 1846
int p9_client_wstat(struct p9_fid *fid, struct p9_wstat *wst)
{
	int err;
1847
	struct p9_req_t *req;
1848 1849
	struct p9_client *clnt;

1850 1851
	err = 0;
	clnt = fid->clnt;
1852
	wst->size = p9_client_statsize(wst, clnt->proto_version);
1853 1854
	p9_debug(P9_DEBUG_9P, ">>> TWSTAT fid %d\n", fid->fid);
	p9_debug(P9_DEBUG_9P,
E
Eric Van Hensbergen 已提交
1855 1856 1857 1858 1859
		"     sz=%x type=%x dev=%x qid=%x.%llx.%x\n"
		"     mode=%8.8x atime=%8.8x mtime=%8.8x length=%llx\n"
		"     name=%s uid=%s gid=%s muid=%s extension=(%s)\n"
		"     uid=%d gid=%d n_muid=%d\n",
		wst->size, wst->type, wst->dev, wst->qid.type,
R
Randy Dunlap 已提交
1860 1861 1862
		(unsigned long long)wst->qid.path, wst->qid.version, wst->mode,
		wst->atime, wst->mtime, (unsigned long long)wst->length,
		wst->name, wst->uid, wst->gid, wst->muid, wst->extension,
1863 1864 1865
		from_kuid(&init_user_ns, wst->n_uid),
		from_kgid(&init_user_ns, wst->n_gid),
		from_kuid(&init_user_ns, wst->n_muid));
1866

1867
	req = p9_client_rpc(clnt, P9_TWSTAT, "dwS", fid->fid, wst->size+2, wst);
1868 1869 1870
	if (IS_ERR(req)) {
		err = PTR_ERR(req);
		goto error;
1871 1872
	}

1873
	p9_debug(P9_DEBUG_9P, "<<< RWSTAT fid %d\n", fid->fid);
1874

1875 1876
	p9_free_req(clnt, req);
error:
1877 1878 1879
	return err;
}
EXPORT_SYMBOL(p9_client_wstat);
1880

1881 1882 1883 1884 1885 1886 1887 1888
int p9_client_setattr(struct p9_fid *fid, struct p9_iattr_dotl *p9attr)
{
	int err;
	struct p9_req_t *req;
	struct p9_client *clnt;

	err = 0;
	clnt = fid->clnt;
1889 1890
	p9_debug(P9_DEBUG_9P, ">>> TSETATTR fid %d\n", fid->fid);
	p9_debug(P9_DEBUG_9P,
1891 1892 1893
		"    valid=%x mode=%x uid=%d gid=%d size=%lld\n"
		"    atime_sec=%lld atime_nsec=%lld\n"
		"    mtime_sec=%lld mtime_nsec=%lld\n",
1894 1895 1896
		p9attr->valid, p9attr->mode,
		from_kuid(&init_user_ns, p9attr->uid),
		from_kgid(&init_user_ns, p9attr->gid),
1897 1898 1899 1900 1901 1902 1903 1904 1905
		p9attr->size, p9attr->atime_sec, p9attr->atime_nsec,
		p9attr->mtime_sec, p9attr->mtime_nsec);

	req = p9_client_rpc(clnt, P9_TSETATTR, "dI", fid->fid, p9attr);

	if (IS_ERR(req)) {
		err = PTR_ERR(req);
		goto error;
	}
1906
	p9_debug(P9_DEBUG_9P, "<<< RSETATTR fid %d\n", fid->fid);
1907 1908 1909 1910 1911 1912
	p9_free_req(clnt, req);
error:
	return err;
}
EXPORT_SYMBOL(p9_client_setattr);

1913 1914 1915 1916 1917 1918 1919 1920 1921
int p9_client_statfs(struct p9_fid *fid, struct p9_rstatfs *sb)
{
	int err;
	struct p9_req_t *req;
	struct p9_client *clnt;

	err = 0;
	clnt = fid->clnt;

1922
	p9_debug(P9_DEBUG_9P, ">>> TSTATFS fid %d\n", fid->fid);
1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933

	req = p9_client_rpc(clnt, P9_TSTATFS, "d", fid->fid);
	if (IS_ERR(req)) {
		err = PTR_ERR(req);
		goto error;
	}

	err = p9pdu_readf(req->rc, clnt->proto_version, "ddqqqqqqd", &sb->type,
		&sb->bsize, &sb->blocks, &sb->bfree, &sb->bavail,
		&sb->files, &sb->ffree, &sb->fsid, &sb->namelen);
	if (err) {
1934
		trace_9p_protocol_dump(clnt, req->rc);
1935 1936 1937 1938
		p9_free_req(clnt, req);
		goto error;
	}

1939
	p9_debug(P9_DEBUG_9P, "<<< RSTATFS fid %d type 0x%lx bsize %ld "
1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950
		"blocks %llu bfree %llu bavail %llu files %llu ffree %llu "
		"fsid %llu namelen %ld\n",
		fid->fid, (long unsigned int)sb->type, (long int)sb->bsize,
		sb->blocks, sb->bfree, sb->bavail, sb->files,  sb->ffree,
		sb->fsid, (long int)sb->namelen);

	p9_free_req(clnt, req);
error:
	return err;
}
EXPORT_SYMBOL(p9_client_statfs);
1951

1952 1953
int p9_client_rename(struct p9_fid *fid,
		     struct p9_fid *newdirfid, const char *name)
1954 1955 1956 1957 1958 1959 1960 1961
{
	int err;
	struct p9_req_t *req;
	struct p9_client *clnt;

	err = 0;
	clnt = fid->clnt;

1962
	p9_debug(P9_DEBUG_9P, ">>> TRENAME fid %d newdirfid %d name %s\n",
1963 1964 1965 1966 1967 1968 1969 1970 1971
			fid->fid, newdirfid->fid, name);

	req = p9_client_rpc(clnt, P9_TRENAME, "dds", fid->fid,
			newdirfid->fid, name);
	if (IS_ERR(req)) {
		err = PTR_ERR(req);
		goto error;
	}

1972
	p9_debug(P9_DEBUG_9P, "<<< RRENAME fid %d\n", fid->fid);
1973 1974 1975 1976 1977 1978 1979

	p9_free_req(clnt, req);
error:
	return err;
}
EXPORT_SYMBOL(p9_client_rename);

1980 1981 1982 1983 1984 1985 1986 1987 1988 1989
int p9_client_renameat(struct p9_fid *olddirfid, const char *old_name,
		       struct p9_fid *newdirfid, const char *new_name)
{
	int err;
	struct p9_req_t *req;
	struct p9_client *clnt;

	err = 0;
	clnt = olddirfid->clnt;

1990
	p9_debug(P9_DEBUG_9P, ">>> TRENAMEAT olddirfid %d old name %s"
1991 1992 1993 1994 1995 1996 1997 1998 1999 2000
		   " newdirfid %d new name %s\n", olddirfid->fid, old_name,
		   newdirfid->fid, new_name);

	req = p9_client_rpc(clnt, P9_TRENAMEAT, "dsds", olddirfid->fid,
			    old_name, newdirfid->fid, new_name);
	if (IS_ERR(req)) {
		err = PTR_ERR(req);
		goto error;
	}

2001
	p9_debug(P9_DEBUG_9P, "<<< RRENAMEAT newdirfid %d new name %s\n",
2002 2003 2004 2005 2006 2007 2008 2009
		   newdirfid->fid, new_name);

	p9_free_req(clnt, req);
error:
	return err;
}
EXPORT_SYMBOL(p9_client_renameat);

2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028
/*
 * An xattrwalk without @attr_name gives the fid for the lisxattr namespace
 */
struct p9_fid *p9_client_xattrwalk(struct p9_fid *file_fid,
				const char *attr_name, u64 *attr_size)
{
	int err;
	struct p9_req_t *req;
	struct p9_client *clnt;
	struct p9_fid *attr_fid;

	err = 0;
	clnt = file_fid->clnt;
	attr_fid = p9_fid_create(clnt);
	if (IS_ERR(attr_fid)) {
		err = PTR_ERR(attr_fid);
		attr_fid = NULL;
		goto error;
	}
2029
	p9_debug(P9_DEBUG_9P,
2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040
		">>> TXATTRWALK file_fid %d, attr_fid %d name %s\n",
		file_fid->fid, attr_fid->fid, attr_name);

	req = p9_client_rpc(clnt, P9_TXATTRWALK, "dds",
			file_fid->fid, attr_fid->fid, attr_name);
	if (IS_ERR(req)) {
		err = PTR_ERR(req);
		goto error;
	}
	err = p9pdu_readf(req->rc, clnt->proto_version, "q", attr_size);
	if (err) {
2041
		trace_9p_protocol_dump(clnt, req->rc);
2042 2043 2044 2045
		p9_free_req(clnt, req);
		goto clunk_fid;
	}
	p9_free_req(clnt, req);
2046
	p9_debug(P9_DEBUG_9P, "<<<  RXATTRWALK fid %d size %llu\n",
2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059
		attr_fid->fid, *attr_size);
	return attr_fid;
clunk_fid:
	p9_client_clunk(attr_fid);
	attr_fid = NULL;
error:
	if (attr_fid && (attr_fid != file_fid))
		p9_fid_destroy(attr_fid);

	return ERR_PTR(err);
}
EXPORT_SYMBOL_GPL(p9_client_xattrwalk);

2060 2061 2062 2063 2064 2065 2066
int p9_client_xattrcreate(struct p9_fid *fid, const char *name,
			u64 attr_size, int flags)
{
	int err;
	struct p9_req_t *req;
	struct p9_client *clnt;

2067
	p9_debug(P9_DEBUG_9P,
2068 2069 2070 2071 2072 2073 2074 2075 2076 2077
		">>> TXATTRCREATE fid %d name  %s size %lld flag %d\n",
		fid->fid, name, (long long)attr_size, flags);
	err = 0;
	clnt = fid->clnt;
	req = p9_client_rpc(clnt, P9_TXATTRCREATE, "dsqd",
			fid->fid, name, attr_size, flags);
	if (IS_ERR(req)) {
		err = PTR_ERR(req);
		goto error;
	}
2078
	p9_debug(P9_DEBUG_9P, "<<< RXATTRCREATE fid %d\n", fid->fid);
2079 2080 2081 2082 2083 2084
	p9_free_req(clnt, req);
error:
	return err;
}
EXPORT_SYMBOL_GPL(p9_client_xattrcreate);

2085 2086
int p9_client_readdir(struct p9_fid *fid, char *data, u32 count, u64 offset)
{
2087
	int err, rsize, non_zc = 0;
2088 2089 2090
	struct p9_client *clnt;
	struct p9_req_t *req;
	char *dataptr;
2091 2092 2093 2094
	struct kvec kv = {.iov_base = data, .iov_len = count};
	struct iov_iter to;

	iov_iter_kvec(&to, READ | ITER_KVEC, &kv, 1, count);
2095

2096
	p9_debug(P9_DEBUG_9P, ">>> TREADDIR fid %d offset %llu count %d\n",
2097
				fid->fid, (unsigned long long) offset, count);
2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108

	err = 0;
	clnt = fid->clnt;

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

	if (count < rsize)
		rsize = count;

2109 2110 2111 2112 2113 2114
	/* Don't bother zerocopy for small IO (< 1024) */
	if (clnt->trans_mod->zc_request && rsize > 1024) {
		/*
		 * response header len is 11
		 * PDU Header(7) + IO Size (4)
		 */
2115 2116
		req = p9_client_zc_rpc(clnt, P9_TREADDIR, &to, NULL, rsize, 0,
				       11, "dqd", fid->fid, offset, rsize);
2117
	} else {
2118
		non_zc = 1;
2119
		req = p9_client_rpc(clnt, P9_TREADDIR, "dqd", fid->fid,
2120
				    offset, rsize);
2121
	}
2122 2123 2124 2125 2126 2127 2128
	if (IS_ERR(req)) {
		err = PTR_ERR(req);
		goto error;
	}

	err = p9pdu_readf(req->rc, clnt->proto_version, "D", &count, &dataptr);
	if (err) {
2129
		trace_9p_protocol_dump(clnt, req->rc);
2130 2131
		goto free_and_error;
	}
A
Al Viro 已提交
2132 2133 2134 2135
	if (rsize < count) {
		pr_err("bogus RREADDIR count (%d > %d)\n", count, rsize);
		count = rsize;
	}
2136

2137
	p9_debug(P9_DEBUG_9P, "<<< RREADDIR count %d\n", count);
2138

2139
	if (non_zc)
2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150
		memmove(data, dataptr, count);

	p9_free_req(clnt, req);
	return count;

free_and_error:
	p9_free_req(clnt, req);
error:
	return err;
}
EXPORT_SYMBOL(p9_client_readdir);
M
M. Mohan Kumar 已提交
2151

A
Al Viro 已提交
2152
int p9_client_mknod_dotl(struct p9_fid *fid, const char *name, int mode,
2153
			dev_t rdev, kgid_t gid, struct p9_qid *qid)
M
M. Mohan Kumar 已提交
2154 2155 2156 2157 2158 2159 2160
{
	int err;
	struct p9_client *clnt;
	struct p9_req_t *req;

	err = 0;
	clnt = fid->clnt;
2161
	p9_debug(P9_DEBUG_9P, ">>> TMKNOD fid %d name %s mode %d major %d "
M
M. Mohan Kumar 已提交
2162
		"minor %d\n", fid->fid, name, mode, MAJOR(rdev), MINOR(rdev));
2163
	req = p9_client_rpc(clnt, P9_TMKNOD, "dsdddg", fid->fid, name, mode,
M
M. Mohan Kumar 已提交
2164 2165 2166 2167 2168 2169
		MAJOR(rdev), MINOR(rdev), gid);
	if (IS_ERR(req))
		return PTR_ERR(req);

	err = p9pdu_readf(req->rc, clnt->proto_version, "Q", qid);
	if (err) {
2170
		trace_9p_protocol_dump(clnt, req->rc);
M
M. Mohan Kumar 已提交
2171 2172
		goto error;
	}
2173
	p9_debug(P9_DEBUG_9P, "<<< RMKNOD qid %x.%llx.%x\n", qid->type,
M
M. Mohan Kumar 已提交
2174 2175 2176 2177 2178 2179 2180 2181
				(unsigned long long)qid->path, qid->version);

error:
	p9_free_req(clnt, req);
	return err;

}
EXPORT_SYMBOL(p9_client_mknod_dotl);
M
M. Mohan Kumar 已提交
2182

A
Al Viro 已提交
2183
int p9_client_mkdir_dotl(struct p9_fid *fid, const char *name, int mode,
2184
				kgid_t gid, struct p9_qid *qid)
M
M. Mohan Kumar 已提交
2185 2186 2187 2188 2189 2190 2191
{
	int err;
	struct p9_client *clnt;
	struct p9_req_t *req;

	err = 0;
	clnt = fid->clnt;
2192
	p9_debug(P9_DEBUG_9P, ">>> TMKDIR fid %d name %s mode %d gid %d\n",
2193 2194
		 fid->fid, name, mode, from_kgid(&init_user_ns, gid));
	req = p9_client_rpc(clnt, P9_TMKDIR, "dsdg", fid->fid, name, mode,
M
M. Mohan Kumar 已提交
2195 2196 2197 2198 2199 2200
		gid);
	if (IS_ERR(req))
		return PTR_ERR(req);

	err = p9pdu_readf(req->rc, clnt->proto_version, "Q", qid);
	if (err) {
2201
		trace_9p_protocol_dump(clnt, req->rc);
M
M. Mohan Kumar 已提交
2202 2203
		goto error;
	}
2204
	p9_debug(P9_DEBUG_9P, "<<< RMKDIR qid %x.%llx.%x\n", qid->type,
M
M. Mohan Kumar 已提交
2205 2206 2207 2208 2209 2210 2211 2212
				(unsigned long long)qid->path, qid->version);

error:
	p9_free_req(clnt, req);
	return err;

}
EXPORT_SYMBOL(p9_client_mkdir_dotl);
M
M. Mohan Kumar 已提交
2213 2214 2215 2216 2217 2218 2219 2220 2221

int p9_client_lock_dotl(struct p9_fid *fid, struct p9_flock *flock, u8 *status)
{
	int err;
	struct p9_client *clnt;
	struct p9_req_t *req;

	err = 0;
	clnt = fid->clnt;
2222
	p9_debug(P9_DEBUG_9P, ">>> TLOCK fid %d type %i flags %d "
M
M. Mohan Kumar 已提交
2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235
			"start %lld length %lld proc_id %d client_id %s\n",
			fid->fid, flock->type, flock->flags, flock->start,
			flock->length, flock->proc_id, flock->client_id);

	req = p9_client_rpc(clnt, P9_TLOCK, "dbdqqds", fid->fid, flock->type,
				flock->flags, flock->start, flock->length,
					flock->proc_id, flock->client_id);

	if (IS_ERR(req))
		return PTR_ERR(req);

	err = p9pdu_readf(req->rc, clnt->proto_version, "b", status);
	if (err) {
2236
		trace_9p_protocol_dump(clnt, req->rc);
M
M. Mohan Kumar 已提交
2237 2238
		goto error;
	}
2239
	p9_debug(P9_DEBUG_9P, "<<< RLOCK status %i\n", *status);
M
M. Mohan Kumar 已提交
2240 2241 2242 2243 2244 2245
error:
	p9_free_req(clnt, req);
	return err;

}
EXPORT_SYMBOL(p9_client_lock_dotl);
M
M. Mohan Kumar 已提交
2246 2247 2248 2249 2250 2251 2252 2253 2254

int p9_client_getlock_dotl(struct p9_fid *fid, struct p9_getlock *glock)
{
	int err;
	struct p9_client *clnt;
	struct p9_req_t *req;

	err = 0;
	clnt = fid->clnt;
2255
	p9_debug(P9_DEBUG_9P, ">>> TGETLOCK fid %d, type %i start %lld "
M
M. Mohan Kumar 已提交
2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268
		"length %lld proc_id %d client_id %s\n", fid->fid, glock->type,
		glock->start, glock->length, glock->proc_id, glock->client_id);

	req = p9_client_rpc(clnt, P9_TGETLOCK, "dbqqds", fid->fid,  glock->type,
		glock->start, glock->length, glock->proc_id, glock->client_id);

	if (IS_ERR(req))
		return PTR_ERR(req);

	err = p9pdu_readf(req->rc, clnt->proto_version, "bqqds", &glock->type,
			&glock->start, &glock->length, &glock->proc_id,
			&glock->client_id);
	if (err) {
2269
		trace_9p_protocol_dump(clnt, req->rc);
M
M. Mohan Kumar 已提交
2270 2271
		goto error;
	}
2272
	p9_debug(P9_DEBUG_9P, "<<< RGETLOCK type %i start %lld length %lld "
M
M. Mohan Kumar 已提交
2273 2274 2275 2276 2277 2278 2279
		"proc_id %d client_id %s\n", glock->type, glock->start,
		glock->length, glock->proc_id, glock->client_id);
error:
	p9_free_req(clnt, req);
	return err;
}
EXPORT_SYMBOL(p9_client_getlock_dotl);
2280 2281 2282 2283 2284 2285 2286 2287 2288

int p9_client_readlink(struct p9_fid *fid, char **target)
{
	int err;
	struct p9_client *clnt;
	struct p9_req_t *req;

	err = 0;
	clnt = fid->clnt;
2289
	p9_debug(P9_DEBUG_9P, ">>> TREADLINK fid %d\n", fid->fid);
2290 2291 2292 2293 2294 2295 2296

	req = p9_client_rpc(clnt, P9_TREADLINK, "d", fid->fid);
	if (IS_ERR(req))
		return PTR_ERR(req);

	err = p9pdu_readf(req->rc, clnt->proto_version, "s", target);
	if (err) {
2297
		trace_9p_protocol_dump(clnt, req->rc);
2298 2299
		goto error;
	}
2300
	p9_debug(P9_DEBUG_9P, "<<< RREADLINK target %s\n", *target);
2301 2302 2303 2304 2305
error:
	p9_free_req(clnt, req);
	return err;
}
EXPORT_SYMBOL(p9_client_readlink);