1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * 9P Client 4 * 5 * Copyright (C) 2008 by Eric Van Hensbergen <ericvh@gmail.com> 6 * Copyright (C) 2007 by Latchesar Ionkov <lucho@ionkov.net> 7 */ 8 9 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 10 11 #include <linux/module.h> 12 #include <linux/errno.h> 13 #include <linux/fs.h> 14 #include <linux/poll.h> 15 #include <linux/idr.h> 16 #include <linux/mutex.h> 17 #include <linux/slab.h> 18 #include <linux/sched/signal.h> 19 #include <linux/uaccess.h> 20 #include <linux/uio.h> 21 #include <net/9p/9p.h> 22 #include <linux/parser.h> 23 #include <linux/seq_file.h> 24 #include <net/9p/client.h> 25 #include <net/9p/transport.h> 26 #include "protocol.h" 27 28 #define CREATE_TRACE_POINTS 29 #include <trace/events/9p.h> 30 31 #define DEFAULT_MSIZE (128 * 1024) 32 33 /* Client Option Parsing (code inspired by NFS code) 34 * - a little lazy - parse all client options 35 */ 36 37 enum { 38 Opt_msize, 39 Opt_trans, 40 Opt_legacy, 41 Opt_version, 42 Opt_err, 43 }; 44 45 static const match_table_t tokens = { 46 {Opt_msize, "msize=%u"}, 47 {Opt_legacy, "noextend"}, 48 {Opt_trans, "trans=%s"}, 49 {Opt_version, "version=%s"}, 50 {Opt_err, NULL}, 51 }; 52 53 inline int p9_is_proto_dotl(struct p9_client *clnt) 54 { 55 return clnt->proto_version == p9_proto_2000L; 56 } 57 EXPORT_SYMBOL(p9_is_proto_dotl); 58 59 inline int p9_is_proto_dotu(struct p9_client *clnt) 60 { 61 return clnt->proto_version == p9_proto_2000u; 62 } 63 EXPORT_SYMBOL(p9_is_proto_dotu); 64 65 int p9_show_client_options(struct seq_file *m, struct p9_client *clnt) 66 { 67 if (clnt->msize != DEFAULT_MSIZE) 68 seq_printf(m, ",msize=%u", clnt->msize); 69 seq_printf(m, ",trans=%s", clnt->trans_mod->name); 70 71 switch (clnt->proto_version) { 72 case p9_proto_legacy: 73 seq_puts(m, ",noextend"); 74 break; 75 case p9_proto_2000u: 76 seq_puts(m, ",version=9p2000.u"); 77 break; 78 case p9_proto_2000L: 79 /* Default */ 80 break; 81 } 82 83 if (clnt->trans_mod->show_options) 84 return clnt->trans_mod->show_options(m, clnt); 85 return 0; 86 } 87 EXPORT_SYMBOL(p9_show_client_options); 88 89 /* Some error codes are taken directly from the server replies, 90 * make sure they are valid. 91 */ 92 static int safe_errno(int err) 93 { 94 if (err > 0 || err < -MAX_ERRNO) { 95 p9_debug(P9_DEBUG_ERROR, "Invalid error code %d\n", err); 96 return -EPROTO; 97 } 98 return err; 99 } 100 101 /* Interpret mount option for protocol version */ 102 static int get_protocol_version(char *s) 103 { 104 int version = -EINVAL; 105 106 if (!strcmp(s, "9p2000")) { 107 version = p9_proto_legacy; 108 p9_debug(P9_DEBUG_9P, "Protocol version: Legacy\n"); 109 } else if (!strcmp(s, "9p2000.u")) { 110 version = p9_proto_2000u; 111 p9_debug(P9_DEBUG_9P, "Protocol version: 9P2000.u\n"); 112 } else if (!strcmp(s, "9p2000.L")) { 113 version = p9_proto_2000L; 114 p9_debug(P9_DEBUG_9P, "Protocol version: 9P2000.L\n"); 115 } else { 116 pr_info("Unknown protocol version %s\n", s); 117 } 118 119 return version; 120 } 121 122 /** 123 * parse_opts - parse mount options into client structure 124 * @opts: options string passed from mount 125 * @clnt: existing v9fs client information 126 * 127 * Return 0 upon success, -ERRNO upon failure 128 */ 129 130 static int parse_opts(char *opts, struct p9_client *clnt) 131 { 132 char *options, *tmp_options; 133 char *p; 134 substring_t args[MAX_OPT_ARGS]; 135 int option; 136 char *s; 137 int ret = 0; 138 139 clnt->proto_version = p9_proto_2000L; 140 clnt->msize = DEFAULT_MSIZE; 141 142 if (!opts) 143 return 0; 144 145 tmp_options = kstrdup(opts, GFP_KERNEL); 146 if (!tmp_options) 147 return -ENOMEM; 148 options = tmp_options; 149 150 while ((p = strsep(&options, ",")) != NULL) { 151 int token, r; 152 153 if (!*p) 154 continue; 155 token = match_token(p, tokens, args); 156 switch (token) { 157 case Opt_msize: 158 r = match_int(&args[0], &option); 159 if (r < 0) { 160 p9_debug(P9_DEBUG_ERROR, 161 "integer field, but no integer?\n"); 162 ret = r; 163 continue; 164 } 165 if (option < 4096) { 166 p9_debug(P9_DEBUG_ERROR, 167 "msize should be at least 4k\n"); 168 ret = -EINVAL; 169 continue; 170 } 171 clnt->msize = option; 172 break; 173 case Opt_trans: 174 s = match_strdup(&args[0]); 175 if (!s) { 176 ret = -ENOMEM; 177 p9_debug(P9_DEBUG_ERROR, 178 "problem allocating copy of trans arg\n"); 179 goto free_and_return; 180 } 181 182 v9fs_put_trans(clnt->trans_mod); 183 clnt->trans_mod = v9fs_get_trans_by_name(s); 184 if (!clnt->trans_mod) { 185 pr_info("Could not find request transport: %s\n", 186 s); 187 ret = -EINVAL; 188 } 189 kfree(s); 190 break; 191 case Opt_legacy: 192 clnt->proto_version = p9_proto_legacy; 193 break; 194 case Opt_version: 195 s = match_strdup(&args[0]); 196 if (!s) { 197 ret = -ENOMEM; 198 p9_debug(P9_DEBUG_ERROR, 199 "problem allocating copy of version arg\n"); 200 goto free_and_return; 201 } 202 r = get_protocol_version(s); 203 if (r < 0) 204 ret = r; 205 else 206 clnt->proto_version = r; 207 kfree(s); 208 break; 209 default: 210 continue; 211 } 212 } 213 214 free_and_return: 215 if (ret) 216 v9fs_put_trans(clnt->trans_mod); 217 kfree(tmp_options); 218 return ret; 219 } 220 221 static int p9_fcall_init(struct p9_client *c, struct p9_fcall *fc, 222 int alloc_msize) 223 { 224 if (likely(c->fcall_cache) && alloc_msize == c->msize) { 225 fc->sdata = kmem_cache_alloc(c->fcall_cache, GFP_NOFS); 226 fc->cache = c->fcall_cache; 227 } else { 228 fc->sdata = kmalloc(alloc_msize, GFP_NOFS); 229 fc->cache = NULL; 230 } 231 if (!fc->sdata) 232 return -ENOMEM; 233 fc->capacity = alloc_msize; 234 return 0; 235 } 236 237 void p9_fcall_fini(struct p9_fcall *fc) 238 { 239 /* sdata can be NULL for interrupted requests in trans_rdma, 240 * and kmem_cache_free does not do NULL-check for us 241 */ 242 if (unlikely(!fc->sdata)) 243 return; 244 245 if (fc->cache) 246 kmem_cache_free(fc->cache, fc->sdata); 247 else 248 kfree(fc->sdata); 249 } 250 EXPORT_SYMBOL(p9_fcall_fini); 251 252 static struct kmem_cache *p9_req_cache; 253 254 /** 255 * p9_tag_alloc - Allocate a new request. 256 * @c: Client session. 257 * @type: Transaction type. 258 * @max_size: Maximum packet size for this request. 259 * 260 * Context: Process context. 261 * Return: Pointer to new request. 262 */ 263 static struct p9_req_t * 264 p9_tag_alloc(struct p9_client *c, int8_t type, unsigned int max_size) 265 { 266 struct p9_req_t *req = kmem_cache_alloc(p9_req_cache, GFP_NOFS); 267 int alloc_msize = min(c->msize, max_size); 268 int tag; 269 270 if (!req) 271 return ERR_PTR(-ENOMEM); 272 273 if (p9_fcall_init(c, &req->tc, alloc_msize)) 274 goto free_req; 275 if (p9_fcall_init(c, &req->rc, alloc_msize)) 276 goto free; 277 278 p9pdu_reset(&req->tc); 279 p9pdu_reset(&req->rc); 280 req->t_err = 0; 281 req->status = REQ_STATUS_ALLOC; 282 init_waitqueue_head(&req->wq); 283 INIT_LIST_HEAD(&req->req_list); 284 285 idr_preload(GFP_NOFS); 286 spin_lock_irq(&c->lock); 287 if (type == P9_TVERSION) 288 tag = idr_alloc(&c->reqs, req, P9_NOTAG, P9_NOTAG + 1, 289 GFP_NOWAIT); 290 else 291 tag = idr_alloc(&c->reqs, req, 0, P9_NOTAG, GFP_NOWAIT); 292 req->tc.tag = tag; 293 spin_unlock_irq(&c->lock); 294 idr_preload_end(); 295 if (tag < 0) 296 goto free; 297 298 /* Init ref to two because in the general case there is one ref 299 * that is put asynchronously by a writer thread, one ref 300 * temporarily given by p9_tag_lookup and put by p9_client_cb 301 * in the recv thread, and one ref put by p9_tag_remove in the 302 * main thread. The only exception is virtio that does not use 303 * p9_tag_lookup but does not have a writer thread either 304 * (the write happens synchronously in the request/zc_request 305 * callback), so p9_client_cb eats the second ref there 306 * as the pointer is duplicated directly by virtqueue_add_sgs() 307 */ 308 refcount_set(&req->refcount.refcount, 2); 309 310 return req; 311 312 free: 313 p9_fcall_fini(&req->tc); 314 p9_fcall_fini(&req->rc); 315 free_req: 316 kmem_cache_free(p9_req_cache, req); 317 return ERR_PTR(-ENOMEM); 318 } 319 320 /** 321 * p9_tag_lookup - Look up a request by tag. 322 * @c: Client session. 323 * @tag: Transaction ID. 324 * 325 * Context: Any context. 326 * Return: A request, or %NULL if there is no request with that tag. 327 */ 328 struct p9_req_t *p9_tag_lookup(struct p9_client *c, u16 tag) 329 { 330 struct p9_req_t *req; 331 332 rcu_read_lock(); 333 again: 334 req = idr_find(&c->reqs, tag); 335 if (req) { 336 /* We have to be careful with the req found under rcu_read_lock 337 * Thanks to SLAB_TYPESAFE_BY_RCU we can safely try to get the 338 * ref again without corrupting other data, then check again 339 * that the tag matches once we have the ref 340 */ 341 if (!p9_req_try_get(req)) 342 goto again; 343 if (req->tc.tag != tag) { 344 p9_req_put(req); 345 goto again; 346 } 347 } 348 rcu_read_unlock(); 349 350 return req; 351 } 352 EXPORT_SYMBOL(p9_tag_lookup); 353 354 /** 355 * p9_tag_remove - Remove a tag. 356 * @c: Client session. 357 * @r: Request of reference. 358 * 359 * Context: Any context. 360 */ 361 static int p9_tag_remove(struct p9_client *c, struct p9_req_t *r) 362 { 363 unsigned long flags; 364 u16 tag = r->tc.tag; 365 366 p9_debug(P9_DEBUG_MUX, "clnt %p req %p tag: %d\n", c, r, tag); 367 spin_lock_irqsave(&c->lock, flags); 368 idr_remove(&c->reqs, tag); 369 spin_unlock_irqrestore(&c->lock, flags); 370 return p9_req_put(r); 371 } 372 373 static void p9_req_free(struct kref *ref) 374 { 375 struct p9_req_t *r = container_of(ref, struct p9_req_t, refcount); 376 377 p9_fcall_fini(&r->tc); 378 p9_fcall_fini(&r->rc); 379 kmem_cache_free(p9_req_cache, r); 380 } 381 382 int p9_req_put(struct p9_req_t *r) 383 { 384 return kref_put(&r->refcount, p9_req_free); 385 } 386 EXPORT_SYMBOL(p9_req_put); 387 388 /** 389 * p9_tag_cleanup - cleans up tags structure and reclaims resources 390 * @c: v9fs client struct 391 * 392 * This frees resources associated with the tags structure 393 * 394 */ 395 static void p9_tag_cleanup(struct p9_client *c) 396 { 397 struct p9_req_t *req; 398 int id; 399 400 rcu_read_lock(); 401 idr_for_each_entry(&c->reqs, req, id) { 402 pr_info("Tag %d still in use\n", id); 403 if (p9_tag_remove(c, req) == 0) 404 pr_warn("Packet with tag %d has still references", 405 req->tc.tag); 406 } 407 rcu_read_unlock(); 408 } 409 410 /** 411 * p9_client_cb - call back from transport to client 412 * @c: client state 413 * @req: request received 414 * @status: request status, one of REQ_STATUS_* 415 * 416 */ 417 void p9_client_cb(struct p9_client *c, struct p9_req_t *req, int status) 418 { 419 p9_debug(P9_DEBUG_MUX, " tag %d\n", req->tc.tag); 420 421 /* This barrier is needed to make sure any change made to req before 422 * the status change is visible to another thread 423 */ 424 smp_wmb(); 425 req->status = status; 426 427 wake_up(&req->wq); 428 p9_debug(P9_DEBUG_MUX, "wakeup: %d\n", req->tc.tag); 429 p9_req_put(req); 430 } 431 EXPORT_SYMBOL(p9_client_cb); 432 433 /** 434 * p9_parse_header - parse header arguments out of a packet 435 * @pdu: packet to parse 436 * @size: size of packet 437 * @type: type of request 438 * @tag: tag of packet 439 * @rewind: set if we need to rewind offset afterwards 440 */ 441 442 int 443 p9_parse_header(struct p9_fcall *pdu, int32_t *size, int8_t *type, 444 int16_t *tag, int rewind) 445 { 446 s8 r_type; 447 s16 r_tag; 448 s32 r_size; 449 int offset = pdu->offset; 450 int err; 451 452 pdu->offset = 0; 453 454 err = p9pdu_readf(pdu, 0, "dbw", &r_size, &r_type, &r_tag); 455 if (err) 456 goto rewind_and_exit; 457 458 if (type) 459 *type = r_type; 460 if (tag) 461 *tag = r_tag; 462 if (size) 463 *size = r_size; 464 465 if (pdu->size != r_size || r_size < 7) { 466 err = -EINVAL; 467 goto rewind_and_exit; 468 } 469 470 pdu->id = r_type; 471 pdu->tag = r_tag; 472 473 p9_debug(P9_DEBUG_9P, "<<< size=%d type: %d tag: %d\n", 474 pdu->size, pdu->id, pdu->tag); 475 476 rewind_and_exit: 477 if (rewind) 478 pdu->offset = offset; 479 return err; 480 } 481 EXPORT_SYMBOL(p9_parse_header); 482 483 /** 484 * p9_check_errors - check 9p packet for error return and process it 485 * @c: current client instance 486 * @req: request to parse and check for error conditions 487 * 488 * returns error code if one is discovered, otherwise returns 0 489 * 490 * this will have to be more complicated if we have multiple 491 * error packet types 492 */ 493 494 static int p9_check_errors(struct p9_client *c, struct p9_req_t *req) 495 { 496 s8 type; 497 int err; 498 int ecode; 499 500 err = p9_parse_header(&req->rc, NULL, &type, NULL, 0); 501 if (req->rc.size >= c->msize) { 502 p9_debug(P9_DEBUG_ERROR, 503 "requested packet size too big: %d\n", 504 req->rc.size); 505 return -EIO; 506 } 507 /* dump the response from server 508 * This should be after check errors which poplulate pdu_fcall. 509 */ 510 trace_9p_protocol_dump(c, &req->rc); 511 if (err) { 512 p9_debug(P9_DEBUG_ERROR, "couldn't parse header %d\n", err); 513 return err; 514 } 515 if (type != P9_RERROR && type != P9_RLERROR) 516 return 0; 517 518 if (!p9_is_proto_dotl(c)) { 519 char *ename; 520 521 err = p9pdu_readf(&req->rc, c->proto_version, "s?d", 522 &ename, &ecode); 523 if (err) 524 goto out_err; 525 526 if (p9_is_proto_dotu(c) && ecode < 512) 527 err = -ecode; 528 529 if (!err) { 530 err = p9_errstr2errno(ename, strlen(ename)); 531 532 p9_debug(P9_DEBUG_9P, "<<< RERROR (%d) %s\n", 533 -ecode, ename); 534 } 535 kfree(ename); 536 } else { 537 err = p9pdu_readf(&req->rc, c->proto_version, "d", &ecode); 538 if (err) 539 goto out_err; 540 err = -ecode; 541 542 p9_debug(P9_DEBUG_9P, "<<< RLERROR (%d)\n", -ecode); 543 } 544 545 return err; 546 547 out_err: 548 p9_debug(P9_DEBUG_ERROR, "couldn't parse error%d\n", err); 549 550 return err; 551 } 552 553 static struct p9_req_t * 554 p9_client_rpc(struct p9_client *c, int8_t type, const char *fmt, ...); 555 556 /** 557 * p9_client_flush - flush (cancel) a request 558 * @c: client state 559 * @oldreq: request to cancel 560 * 561 * This sents a flush for a particular request and links 562 * the flush request to the original request. The current 563 * code only supports a single flush request although the protocol 564 * allows for multiple flush requests to be sent for a single request. 565 * 566 */ 567 568 static int p9_client_flush(struct p9_client *c, struct p9_req_t *oldreq) 569 { 570 struct p9_req_t *req; 571 s16 oldtag; 572 int err; 573 574 err = p9_parse_header(&oldreq->tc, NULL, NULL, &oldtag, 1); 575 if (err) 576 return err; 577 578 p9_debug(P9_DEBUG_9P, ">>> TFLUSH tag %d\n", oldtag); 579 580 req = p9_client_rpc(c, P9_TFLUSH, "w", oldtag); 581 if (IS_ERR(req)) 582 return PTR_ERR(req); 583 584 /* if we haven't received a response for oldreq, 585 * remove it from the list 586 */ 587 if (oldreq->status == REQ_STATUS_SENT) { 588 if (c->trans_mod->cancelled) 589 c->trans_mod->cancelled(c, oldreq); 590 } 591 592 p9_tag_remove(c, req); 593 return 0; 594 } 595 596 static struct p9_req_t *p9_client_prepare_req(struct p9_client *c, 597 int8_t type, int req_size, 598 const char *fmt, va_list ap) 599 { 600 int err; 601 struct p9_req_t *req; 602 603 p9_debug(P9_DEBUG_MUX, "client %p op %d\n", c, type); 604 605 /* we allow for any status other than disconnected */ 606 if (c->status == Disconnected) 607 return ERR_PTR(-EIO); 608 609 /* if status is begin_disconnected we allow only clunk request */ 610 if (c->status == BeginDisconnect && type != P9_TCLUNK) 611 return ERR_PTR(-EIO); 612 613 req = p9_tag_alloc(c, type, req_size); 614 if (IS_ERR(req)) 615 return req; 616 617 /* marshall the data */ 618 p9pdu_prepare(&req->tc, req->tc.tag, type); 619 err = p9pdu_vwritef(&req->tc, c->proto_version, fmt, ap); 620 if (err) 621 goto reterr; 622 p9pdu_finalize(c, &req->tc); 623 trace_9p_client_req(c, type, req->tc.tag); 624 return req; 625 reterr: 626 p9_tag_remove(c, req); 627 /* We have to put also the 2nd reference as it won't be used */ 628 p9_req_put(req); 629 return ERR_PTR(err); 630 } 631 632 /** 633 * p9_client_rpc - issue a request and wait for a response 634 * @c: client session 635 * @type: type of request 636 * @fmt: protocol format string (see protocol.c) 637 * 638 * Returns request structure (which client must free using p9_tag_remove) 639 */ 640 641 static struct p9_req_t * 642 p9_client_rpc(struct p9_client *c, int8_t type, const char *fmt, ...) 643 { 644 va_list ap; 645 int sigpending, err; 646 unsigned long flags; 647 struct p9_req_t *req; 648 649 va_start(ap, fmt); 650 req = p9_client_prepare_req(c, type, c->msize, fmt, ap); 651 va_end(ap); 652 if (IS_ERR(req)) 653 return req; 654 655 if (signal_pending(current)) { 656 sigpending = 1; 657 clear_thread_flag(TIF_SIGPENDING); 658 } else { 659 sigpending = 0; 660 } 661 662 err = c->trans_mod->request(c, req); 663 if (err < 0) { 664 /* write won't happen */ 665 p9_req_put(req); 666 if (err != -ERESTARTSYS && err != -EFAULT) 667 c->status = Disconnected; 668 goto recalc_sigpending; 669 } 670 again: 671 /* Wait for the response */ 672 err = wait_event_killable(req->wq, req->status >= REQ_STATUS_RCVD); 673 674 /* Make sure our req is coherent with regard to updates in other 675 * threads - echoes to wmb() in the callback 676 */ 677 smp_rmb(); 678 679 if (err == -ERESTARTSYS && c->status == Connected && 680 type == P9_TFLUSH) { 681 sigpending = 1; 682 clear_thread_flag(TIF_SIGPENDING); 683 goto again; 684 } 685 686 if (req->status == REQ_STATUS_ERROR) { 687 p9_debug(P9_DEBUG_ERROR, "req_status error %d\n", req->t_err); 688 err = req->t_err; 689 } 690 if (err == -ERESTARTSYS && c->status == Connected) { 691 p9_debug(P9_DEBUG_MUX, "flushing\n"); 692 sigpending = 1; 693 clear_thread_flag(TIF_SIGPENDING); 694 695 if (c->trans_mod->cancel(c, req)) 696 p9_client_flush(c, req); 697 698 /* if we received the response anyway, don't signal error */ 699 if (req->status == REQ_STATUS_RCVD) 700 err = 0; 701 } 702 recalc_sigpending: 703 if (sigpending) { 704 spin_lock_irqsave(¤t->sighand->siglock, flags); 705 recalc_sigpending(); 706 spin_unlock_irqrestore(¤t->sighand->siglock, flags); 707 } 708 if (err < 0) 709 goto reterr; 710 711 err = p9_check_errors(c, req); 712 trace_9p_client_res(c, type, req->rc.tag, err); 713 if (!err) 714 return req; 715 reterr: 716 p9_tag_remove(c, req); 717 return ERR_PTR(safe_errno(err)); 718 } 719 720 /** 721 * p9_client_zc_rpc - issue a request and wait for a response 722 * @c: client session 723 * @type: type of request 724 * @uidata: destination for zero copy read 725 * @uodata: source for zero copy write 726 * @inlen: read buffer size 727 * @olen: write buffer size 728 * @in_hdrlen: reader header size, This is the size of response protocol data 729 * @fmt: protocol format string (see protocol.c) 730 * 731 * Returns request structure (which client must free using p9_tag_remove) 732 */ 733 static struct p9_req_t *p9_client_zc_rpc(struct p9_client *c, int8_t type, 734 struct iov_iter *uidata, 735 struct iov_iter *uodata, 736 int inlen, int olen, int in_hdrlen, 737 const char *fmt, ...) 738 { 739 va_list ap; 740 int sigpending, err; 741 unsigned long flags; 742 struct p9_req_t *req; 743 744 va_start(ap, fmt); 745 /* We allocate a inline protocol data of only 4k bytes. 746 * The actual content is passed in zero-copy fashion. 747 */ 748 req = p9_client_prepare_req(c, type, P9_ZC_HDR_SZ, fmt, ap); 749 va_end(ap); 750 if (IS_ERR(req)) 751 return req; 752 753 if (signal_pending(current)) { 754 sigpending = 1; 755 clear_thread_flag(TIF_SIGPENDING); 756 } else { 757 sigpending = 0; 758 } 759 760 err = c->trans_mod->zc_request(c, req, uidata, uodata, 761 inlen, olen, in_hdrlen); 762 if (err < 0) { 763 if (err == -EIO) 764 c->status = Disconnected; 765 if (err != -ERESTARTSYS) 766 goto recalc_sigpending; 767 } 768 if (req->status == REQ_STATUS_ERROR) { 769 p9_debug(P9_DEBUG_ERROR, "req_status error %d\n", req->t_err); 770 err = req->t_err; 771 } 772 if (err == -ERESTARTSYS && c->status == Connected) { 773 p9_debug(P9_DEBUG_MUX, "flushing\n"); 774 sigpending = 1; 775 clear_thread_flag(TIF_SIGPENDING); 776 777 if (c->trans_mod->cancel(c, req)) 778 p9_client_flush(c, req); 779 780 /* if we received the response anyway, don't signal error */ 781 if (req->status == REQ_STATUS_RCVD) 782 err = 0; 783 } 784 recalc_sigpending: 785 if (sigpending) { 786 spin_lock_irqsave(¤t->sighand->siglock, flags); 787 recalc_sigpending(); 788 spin_unlock_irqrestore(¤t->sighand->siglock, flags); 789 } 790 if (err < 0) 791 goto reterr; 792 793 err = p9_check_errors(c, req); 794 trace_9p_client_res(c, type, req->rc.tag, err); 795 if (!err) 796 return req; 797 reterr: 798 p9_tag_remove(c, req); 799 return ERR_PTR(safe_errno(err)); 800 } 801 802 static struct p9_fid *p9_fid_create(struct p9_client *clnt) 803 { 804 int ret; 805 struct p9_fid *fid; 806 807 p9_debug(P9_DEBUG_FID, "clnt %p\n", clnt); 808 fid = kmalloc(sizeof(*fid), GFP_KERNEL); 809 if (!fid) 810 return NULL; 811 812 memset(&fid->qid, 0, sizeof(fid->qid)); 813 fid->mode = -1; 814 fid->uid = current_fsuid(); 815 fid->clnt = clnt; 816 fid->rdir = NULL; 817 fid->fid = 0; 818 refcount_set(&fid->count, 1); 819 820 idr_preload(GFP_KERNEL); 821 spin_lock_irq(&clnt->lock); 822 ret = idr_alloc_u32(&clnt->fids, fid, &fid->fid, P9_NOFID - 1, 823 GFP_NOWAIT); 824 spin_unlock_irq(&clnt->lock); 825 idr_preload_end(); 826 if (!ret) 827 return fid; 828 829 kfree(fid); 830 return NULL; 831 } 832 833 static void p9_fid_destroy(struct p9_fid *fid) 834 { 835 struct p9_client *clnt; 836 unsigned long flags; 837 838 p9_debug(P9_DEBUG_FID, "fid %d\n", fid->fid); 839 clnt = fid->clnt; 840 spin_lock_irqsave(&clnt->lock, flags); 841 idr_remove(&clnt->fids, fid->fid); 842 spin_unlock_irqrestore(&clnt->lock, flags); 843 kfree(fid->rdir); 844 kfree(fid); 845 } 846 847 static int p9_client_version(struct p9_client *c) 848 { 849 int err = 0; 850 struct p9_req_t *req; 851 char *version = NULL; 852 int msize; 853 854 p9_debug(P9_DEBUG_9P, ">>> TVERSION msize %d protocol %d\n", 855 c->msize, c->proto_version); 856 857 switch (c->proto_version) { 858 case p9_proto_2000L: 859 req = p9_client_rpc(c, P9_TVERSION, "ds", 860 c->msize, "9P2000.L"); 861 break; 862 case p9_proto_2000u: 863 req = p9_client_rpc(c, P9_TVERSION, "ds", 864 c->msize, "9P2000.u"); 865 break; 866 case p9_proto_legacy: 867 req = p9_client_rpc(c, P9_TVERSION, "ds", 868 c->msize, "9P2000"); 869 break; 870 default: 871 return -EINVAL; 872 } 873 874 if (IS_ERR(req)) 875 return PTR_ERR(req); 876 877 err = p9pdu_readf(&req->rc, c->proto_version, "ds", &msize, &version); 878 if (err) { 879 p9_debug(P9_DEBUG_9P, "version error %d\n", err); 880 trace_9p_protocol_dump(c, &req->rc); 881 goto error; 882 } 883 884 p9_debug(P9_DEBUG_9P, "<<< RVERSION msize %d %s\n", msize, version); 885 if (!strncmp(version, "9P2000.L", 8)) { 886 c->proto_version = p9_proto_2000L; 887 } else if (!strncmp(version, "9P2000.u", 8)) { 888 c->proto_version = p9_proto_2000u; 889 } else if (!strncmp(version, "9P2000", 6)) { 890 c->proto_version = p9_proto_legacy; 891 } else { 892 p9_debug(P9_DEBUG_ERROR, 893 "server returned an unknown version: %s\n", version); 894 err = -EREMOTEIO; 895 goto error; 896 } 897 898 if (msize < 4096) { 899 p9_debug(P9_DEBUG_ERROR, 900 "server returned a msize < 4096: %d\n", msize); 901 err = -EREMOTEIO; 902 goto error; 903 } 904 if (msize < c->msize) 905 c->msize = msize; 906 907 error: 908 kfree(version); 909 p9_tag_remove(c, req); 910 911 return err; 912 } 913 914 struct p9_client *p9_client_create(const char *dev_name, char *options) 915 { 916 int err; 917 struct p9_client *clnt; 918 char *client_id; 919 920 err = 0; 921 clnt = kmalloc(sizeof(*clnt), GFP_KERNEL); 922 if (!clnt) 923 return ERR_PTR(-ENOMEM); 924 925 clnt->trans_mod = NULL; 926 clnt->trans = NULL; 927 clnt->fcall_cache = NULL; 928 929 client_id = utsname()->nodename; 930 memcpy(clnt->name, client_id, strlen(client_id) + 1); 931 932 spin_lock_init(&clnt->lock); 933 idr_init(&clnt->fids); 934 idr_init(&clnt->reqs); 935 936 err = parse_opts(options, clnt); 937 if (err < 0) 938 goto free_client; 939 940 if (!clnt->trans_mod) 941 clnt->trans_mod = v9fs_get_default_trans(); 942 943 if (!clnt->trans_mod) { 944 err = -EPROTONOSUPPORT; 945 p9_debug(P9_DEBUG_ERROR, 946 "No transport defined or default transport\n"); 947 goto free_client; 948 } 949 950 p9_debug(P9_DEBUG_MUX, "clnt %p trans %p msize %d protocol %d\n", 951 clnt, clnt->trans_mod, clnt->msize, clnt->proto_version); 952 953 err = clnt->trans_mod->create(clnt, dev_name, options); 954 if (err) 955 goto put_trans; 956 957 if (clnt->msize > clnt->trans_mod->maxsize) { 958 clnt->msize = clnt->trans_mod->maxsize; 959 pr_info("Limiting 'msize' to %d as this is the maximum " 960 "supported by transport %s\n", 961 clnt->msize, clnt->trans_mod->name 962 ); 963 } 964 965 if (clnt->msize < 4096) { 966 p9_debug(P9_DEBUG_ERROR, 967 "Please specify a msize of at least 4k\n"); 968 err = -EINVAL; 969 goto close_trans; 970 } 971 972 err = p9_client_version(clnt); 973 if (err) 974 goto close_trans; 975 976 /* P9_HDRSZ + 4 is the smallest packet header we can have that is 977 * followed by data accessed from userspace by read 978 */ 979 clnt->fcall_cache = 980 kmem_cache_create_usercopy("9p-fcall-cache", clnt->msize, 981 0, 0, P9_HDRSZ + 4, 982 clnt->msize - (P9_HDRSZ + 4), 983 NULL); 984 985 return clnt; 986 987 close_trans: 988 clnt->trans_mod->close(clnt); 989 put_trans: 990 v9fs_put_trans(clnt->trans_mod); 991 free_client: 992 kfree(clnt); 993 return ERR_PTR(err); 994 } 995 EXPORT_SYMBOL(p9_client_create); 996 997 void p9_client_destroy(struct p9_client *clnt) 998 { 999 struct p9_fid *fid; 1000 int id; 1001 1002 p9_debug(P9_DEBUG_MUX, "clnt %p\n", clnt); 1003 1004 if (clnt->trans_mod) 1005 clnt->trans_mod->close(clnt); 1006 1007 v9fs_put_trans(clnt->trans_mod); 1008 1009 idr_for_each_entry(&clnt->fids, fid, id) { 1010 pr_info("Found fid %d not clunked\n", fid->fid); 1011 p9_fid_destroy(fid); 1012 } 1013 1014 p9_tag_cleanup(clnt); 1015 1016 kmem_cache_destroy(clnt->fcall_cache); 1017 kfree(clnt); 1018 } 1019 EXPORT_SYMBOL(p9_client_destroy); 1020 1021 void p9_client_disconnect(struct p9_client *clnt) 1022 { 1023 p9_debug(P9_DEBUG_9P, "clnt %p\n", clnt); 1024 clnt->status = Disconnected; 1025 } 1026 EXPORT_SYMBOL(p9_client_disconnect); 1027 1028 void p9_client_begin_disconnect(struct p9_client *clnt) 1029 { 1030 p9_debug(P9_DEBUG_9P, "clnt %p\n", clnt); 1031 clnt->status = BeginDisconnect; 1032 } 1033 EXPORT_SYMBOL(p9_client_begin_disconnect); 1034 1035 struct p9_fid *p9_client_attach(struct p9_client *clnt, struct p9_fid *afid, 1036 const char *uname, kuid_t n_uname, 1037 const char *aname) 1038 { 1039 int err = 0; 1040 struct p9_req_t *req; 1041 struct p9_fid *fid; 1042 struct p9_qid qid; 1043 1044 p9_debug(P9_DEBUG_9P, ">>> TATTACH afid %d uname %s aname %s\n", 1045 afid ? afid->fid : -1, uname, aname); 1046 fid = p9_fid_create(clnt); 1047 if (!fid) { 1048 err = -ENOMEM; 1049 goto error; 1050 } 1051 fid->uid = n_uname; 1052 1053 req = p9_client_rpc(clnt, P9_TATTACH, "ddss?u", fid->fid, 1054 afid ? afid->fid : P9_NOFID, uname, aname, n_uname); 1055 if (IS_ERR(req)) { 1056 err = PTR_ERR(req); 1057 goto error; 1058 } 1059 1060 err = p9pdu_readf(&req->rc, clnt->proto_version, "Q", &qid); 1061 if (err) { 1062 trace_9p_protocol_dump(clnt, &req->rc); 1063 p9_tag_remove(clnt, req); 1064 goto error; 1065 } 1066 1067 p9_debug(P9_DEBUG_9P, "<<< RATTACH qid %x.%llx.%x\n", 1068 qid.type, qid.path, qid.version); 1069 1070 memmove(&fid->qid, &qid, sizeof(struct p9_qid)); 1071 1072 p9_tag_remove(clnt, req); 1073 return fid; 1074 1075 error: 1076 if (fid) 1077 p9_fid_destroy(fid); 1078 return ERR_PTR(err); 1079 } 1080 EXPORT_SYMBOL(p9_client_attach); 1081 1082 struct p9_fid *p9_client_walk(struct p9_fid *oldfid, uint16_t nwname, 1083 const unsigned char * const *wnames, int clone) 1084 { 1085 int err; 1086 struct p9_client *clnt; 1087 struct p9_fid *fid; 1088 struct p9_qid *wqids; 1089 struct p9_req_t *req; 1090 u16 nwqids, count; 1091 1092 err = 0; 1093 wqids = NULL; 1094 clnt = oldfid->clnt; 1095 if (clone) { 1096 fid = p9_fid_create(clnt); 1097 if (!fid) { 1098 err = -ENOMEM; 1099 goto error; 1100 } 1101 1102 fid->uid = oldfid->uid; 1103 } else { 1104 fid = oldfid; 1105 } 1106 1107 p9_debug(P9_DEBUG_9P, ">>> TWALK fids %d,%d nwname %ud wname[0] %s\n", 1108 oldfid->fid, fid->fid, nwname, wnames ? wnames[0] : NULL); 1109 req = p9_client_rpc(clnt, P9_TWALK, "ddT", oldfid->fid, fid->fid, 1110 nwname, wnames); 1111 if (IS_ERR(req)) { 1112 err = PTR_ERR(req); 1113 goto error; 1114 } 1115 1116 err = p9pdu_readf(&req->rc, clnt->proto_version, "R", &nwqids, &wqids); 1117 if (err) { 1118 trace_9p_protocol_dump(clnt, &req->rc); 1119 p9_tag_remove(clnt, req); 1120 goto clunk_fid; 1121 } 1122 p9_tag_remove(clnt, req); 1123 1124 p9_debug(P9_DEBUG_9P, "<<< RWALK nwqid %d:\n", nwqids); 1125 1126 if (nwqids != nwname) { 1127 err = -ENOENT; 1128 goto clunk_fid; 1129 } 1130 1131 for (count = 0; count < nwqids; count++) 1132 p9_debug(P9_DEBUG_9P, "<<< [%d] %x.%llx.%x\n", 1133 count, wqids[count].type, 1134 wqids[count].path, 1135 wqids[count].version); 1136 1137 if (nwname) 1138 memmove(&fid->qid, &wqids[nwqids - 1], sizeof(struct p9_qid)); 1139 else 1140 memmove(&fid->qid, &oldfid->qid, sizeof(struct p9_qid)); 1141 1142 kfree(wqids); 1143 return fid; 1144 1145 clunk_fid: 1146 kfree(wqids); 1147 p9_client_clunk(fid); 1148 fid = NULL; 1149 1150 error: 1151 if (fid && fid != oldfid) 1152 p9_fid_destroy(fid); 1153 1154 return ERR_PTR(err); 1155 } 1156 EXPORT_SYMBOL(p9_client_walk); 1157 1158 int p9_client_open(struct p9_fid *fid, int mode) 1159 { 1160 int err; 1161 struct p9_client *clnt; 1162 struct p9_req_t *req; 1163 struct p9_qid qid; 1164 int iounit; 1165 1166 clnt = fid->clnt; 1167 p9_debug(P9_DEBUG_9P, ">>> %s fid %d mode %d\n", 1168 p9_is_proto_dotl(clnt) ? "TLOPEN" : "TOPEN", fid->fid, mode); 1169 err = 0; 1170 1171 if (fid->mode != -1) 1172 return -EINVAL; 1173 1174 if (p9_is_proto_dotl(clnt)) 1175 req = p9_client_rpc(clnt, P9_TLOPEN, "dd", fid->fid, mode); 1176 else 1177 req = p9_client_rpc(clnt, P9_TOPEN, "db", fid->fid, mode); 1178 if (IS_ERR(req)) { 1179 err = PTR_ERR(req); 1180 goto error; 1181 } 1182 1183 err = p9pdu_readf(&req->rc, clnt->proto_version, "Qd", &qid, &iounit); 1184 if (err) { 1185 trace_9p_protocol_dump(clnt, &req->rc); 1186 goto free_and_error; 1187 } 1188 1189 p9_debug(P9_DEBUG_9P, "<<< %s qid %x.%llx.%x iounit %x\n", 1190 p9_is_proto_dotl(clnt) ? "RLOPEN" : "ROPEN", qid.type, 1191 qid.path, qid.version, iounit); 1192 1193 memmove(&fid->qid, &qid, sizeof(struct p9_qid)); 1194 fid->mode = mode; 1195 fid->iounit = iounit; 1196 1197 free_and_error: 1198 p9_tag_remove(clnt, req); 1199 error: 1200 return err; 1201 } 1202 EXPORT_SYMBOL(p9_client_open); 1203 1204 int p9_client_create_dotl(struct p9_fid *ofid, const char *name, u32 flags, 1205 u32 mode, kgid_t gid, struct p9_qid *qid) 1206 { 1207 int err = 0; 1208 struct p9_client *clnt; 1209 struct p9_req_t *req; 1210 int iounit; 1211 1212 p9_debug(P9_DEBUG_9P, 1213 ">>> TLCREATE fid %d name %s flags %d mode %d gid %d\n", 1214 ofid->fid, name, flags, mode, 1215 from_kgid(&init_user_ns, gid)); 1216 clnt = ofid->clnt; 1217 1218 if (ofid->mode != -1) 1219 return -EINVAL; 1220 1221 req = p9_client_rpc(clnt, P9_TLCREATE, "dsddg", ofid->fid, name, flags, 1222 mode, gid); 1223 if (IS_ERR(req)) { 1224 err = PTR_ERR(req); 1225 goto error; 1226 } 1227 1228 err = p9pdu_readf(&req->rc, clnt->proto_version, "Qd", qid, &iounit); 1229 if (err) { 1230 trace_9p_protocol_dump(clnt, &req->rc); 1231 goto free_and_error; 1232 } 1233 1234 p9_debug(P9_DEBUG_9P, "<<< RLCREATE qid %x.%llx.%x iounit %x\n", 1235 qid->type, qid->path, qid->version, iounit); 1236 1237 memmove(&ofid->qid, qid, sizeof(struct p9_qid)); 1238 ofid->mode = mode; 1239 ofid->iounit = iounit; 1240 1241 free_and_error: 1242 p9_tag_remove(clnt, req); 1243 error: 1244 return err; 1245 } 1246 EXPORT_SYMBOL(p9_client_create_dotl); 1247 1248 int p9_client_fcreate(struct p9_fid *fid, const char *name, u32 perm, int mode, 1249 char *extension) 1250 { 1251 int err; 1252 struct p9_client *clnt; 1253 struct p9_req_t *req; 1254 struct p9_qid qid; 1255 int iounit; 1256 1257 p9_debug(P9_DEBUG_9P, ">>> TCREATE fid %d name %s perm %d mode %d\n", 1258 fid->fid, name, perm, mode); 1259 err = 0; 1260 clnt = fid->clnt; 1261 1262 if (fid->mode != -1) 1263 return -EINVAL; 1264 1265 req = p9_client_rpc(clnt, P9_TCREATE, "dsdb?s", fid->fid, name, perm, 1266 mode, extension); 1267 if (IS_ERR(req)) { 1268 err = PTR_ERR(req); 1269 goto error; 1270 } 1271 1272 err = p9pdu_readf(&req->rc, clnt->proto_version, "Qd", &qid, &iounit); 1273 if (err) { 1274 trace_9p_protocol_dump(clnt, &req->rc); 1275 goto free_and_error; 1276 } 1277 1278 p9_debug(P9_DEBUG_9P, "<<< RCREATE qid %x.%llx.%x iounit %x\n", 1279 qid.type, qid.path, qid.version, iounit); 1280 1281 memmove(&fid->qid, &qid, sizeof(struct p9_qid)); 1282 fid->mode = mode; 1283 fid->iounit = iounit; 1284 1285 free_and_error: 1286 p9_tag_remove(clnt, req); 1287 error: 1288 return err; 1289 } 1290 EXPORT_SYMBOL(p9_client_fcreate); 1291 1292 int p9_client_symlink(struct p9_fid *dfid, const char *name, 1293 const char *symtgt, kgid_t gid, struct p9_qid *qid) 1294 { 1295 int err = 0; 1296 struct p9_client *clnt; 1297 struct p9_req_t *req; 1298 1299 p9_debug(P9_DEBUG_9P, ">>> TSYMLINK dfid %d name %s symtgt %s\n", 1300 dfid->fid, name, symtgt); 1301 clnt = dfid->clnt; 1302 1303 req = p9_client_rpc(clnt, P9_TSYMLINK, "dssg", dfid->fid, name, symtgt, 1304 gid); 1305 if (IS_ERR(req)) { 1306 err = PTR_ERR(req); 1307 goto error; 1308 } 1309 1310 err = p9pdu_readf(&req->rc, clnt->proto_version, "Q", qid); 1311 if (err) { 1312 trace_9p_protocol_dump(clnt, &req->rc); 1313 goto free_and_error; 1314 } 1315 1316 p9_debug(P9_DEBUG_9P, "<<< RSYMLINK qid %x.%llx.%x\n", 1317 qid->type, qid->path, qid->version); 1318 1319 free_and_error: 1320 p9_tag_remove(clnt, req); 1321 error: 1322 return err; 1323 } 1324 EXPORT_SYMBOL(p9_client_symlink); 1325 1326 int p9_client_link(struct p9_fid *dfid, struct p9_fid *oldfid, const char *newname) 1327 { 1328 struct p9_client *clnt; 1329 struct p9_req_t *req; 1330 1331 p9_debug(P9_DEBUG_9P, ">>> TLINK dfid %d oldfid %d newname %s\n", 1332 dfid->fid, oldfid->fid, newname); 1333 clnt = dfid->clnt; 1334 req = p9_client_rpc(clnt, P9_TLINK, "dds", dfid->fid, oldfid->fid, 1335 newname); 1336 if (IS_ERR(req)) 1337 return PTR_ERR(req); 1338 1339 p9_debug(P9_DEBUG_9P, "<<< RLINK\n"); 1340 p9_tag_remove(clnt, req); 1341 return 0; 1342 } 1343 EXPORT_SYMBOL(p9_client_link); 1344 1345 int p9_client_fsync(struct p9_fid *fid, int datasync) 1346 { 1347 int err; 1348 struct p9_client *clnt; 1349 struct p9_req_t *req; 1350 1351 p9_debug(P9_DEBUG_9P, ">>> TFSYNC fid %d datasync:%d\n", 1352 fid->fid, datasync); 1353 err = 0; 1354 clnt = fid->clnt; 1355 1356 req = p9_client_rpc(clnt, P9_TFSYNC, "dd", fid->fid, datasync); 1357 if (IS_ERR(req)) { 1358 err = PTR_ERR(req); 1359 goto error; 1360 } 1361 1362 p9_debug(P9_DEBUG_9P, "<<< RFSYNC fid %d\n", fid->fid); 1363 1364 p9_tag_remove(clnt, req); 1365 1366 error: 1367 return err; 1368 } 1369 EXPORT_SYMBOL(p9_client_fsync); 1370 1371 int p9_client_clunk(struct p9_fid *fid) 1372 { 1373 int err; 1374 struct p9_client *clnt; 1375 struct p9_req_t *req; 1376 int retries = 0; 1377 1378 if (!fid || IS_ERR(fid)) { 1379 pr_warn("%s (%d): Trying to clunk with invalid fid\n", 1380 __func__, task_pid_nr(current)); 1381 dump_stack(); 1382 return 0; 1383 } 1384 if (!refcount_dec_and_test(&fid->count)) 1385 return 0; 1386 1387 again: 1388 p9_debug(P9_DEBUG_9P, ">>> TCLUNK fid %d (try %d)\n", 1389 fid->fid, retries); 1390 err = 0; 1391 clnt = fid->clnt; 1392 1393 req = p9_client_rpc(clnt, P9_TCLUNK, "d", fid->fid); 1394 if (IS_ERR(req)) { 1395 err = PTR_ERR(req); 1396 goto error; 1397 } 1398 1399 p9_debug(P9_DEBUG_9P, "<<< RCLUNK fid %d\n", fid->fid); 1400 1401 p9_tag_remove(clnt, req); 1402 error: 1403 /* Fid is not valid even after a failed clunk 1404 * If interrupted, retry once then give up and 1405 * leak fid until umount. 1406 */ 1407 if (err == -ERESTARTSYS) { 1408 if (retries++ == 0) 1409 goto again; 1410 } else { 1411 p9_fid_destroy(fid); 1412 } 1413 return err; 1414 } 1415 EXPORT_SYMBOL(p9_client_clunk); 1416 1417 int p9_client_remove(struct p9_fid *fid) 1418 { 1419 int err; 1420 struct p9_client *clnt; 1421 struct p9_req_t *req; 1422 1423 p9_debug(P9_DEBUG_9P, ">>> TREMOVE fid %d\n", fid->fid); 1424 err = 0; 1425 clnt = fid->clnt; 1426 1427 req = p9_client_rpc(clnt, P9_TREMOVE, "d", fid->fid); 1428 if (IS_ERR(req)) { 1429 err = PTR_ERR(req); 1430 goto error; 1431 } 1432 1433 p9_debug(P9_DEBUG_9P, "<<< RREMOVE fid %d\n", fid->fid); 1434 1435 p9_tag_remove(clnt, req); 1436 error: 1437 if (err == -ERESTARTSYS) 1438 p9_client_clunk(fid); 1439 else 1440 p9_fid_destroy(fid); 1441 return err; 1442 } 1443 EXPORT_SYMBOL(p9_client_remove); 1444 1445 int p9_client_unlinkat(struct p9_fid *dfid, const char *name, int flags) 1446 { 1447 int err = 0; 1448 struct p9_req_t *req; 1449 struct p9_client *clnt; 1450 1451 p9_debug(P9_DEBUG_9P, ">>> TUNLINKAT fid %d %s %d\n", 1452 dfid->fid, name, flags); 1453 1454 clnt = dfid->clnt; 1455 req = p9_client_rpc(clnt, P9_TUNLINKAT, "dsd", dfid->fid, name, flags); 1456 if (IS_ERR(req)) { 1457 err = PTR_ERR(req); 1458 goto error; 1459 } 1460 p9_debug(P9_DEBUG_9P, "<<< RUNLINKAT fid %d %s\n", dfid->fid, name); 1461 1462 p9_tag_remove(clnt, req); 1463 error: 1464 return err; 1465 } 1466 EXPORT_SYMBOL(p9_client_unlinkat); 1467 1468 int 1469 p9_client_read(struct p9_fid *fid, u64 offset, struct iov_iter *to, int *err) 1470 { 1471 int total = 0; 1472 *err = 0; 1473 1474 while (iov_iter_count(to)) { 1475 int count; 1476 1477 count = p9_client_read_once(fid, offset, to, err); 1478 if (!count || *err) 1479 break; 1480 offset += count; 1481 total += count; 1482 } 1483 return total; 1484 } 1485 EXPORT_SYMBOL(p9_client_read); 1486 1487 int 1488 p9_client_read_once(struct p9_fid *fid, u64 offset, struct iov_iter *to, 1489 int *err) 1490 { 1491 struct p9_client *clnt = fid->clnt; 1492 struct p9_req_t *req; 1493 int count = iov_iter_count(to); 1494 int rsize, non_zc = 0; 1495 char *dataptr; 1496 1497 *err = 0; 1498 p9_debug(P9_DEBUG_9P, ">>> TREAD fid %d offset %llu %zu\n", 1499 fid->fid, offset, iov_iter_count(to)); 1500 1501 rsize = fid->iounit; 1502 if (!rsize || rsize > clnt->msize - P9_IOHDRSZ) 1503 rsize = clnt->msize - P9_IOHDRSZ; 1504 1505 if (count < rsize) 1506 rsize = count; 1507 1508 /* Don't bother zerocopy for small IO (< 1024) */ 1509 if (clnt->trans_mod->zc_request && rsize > 1024) { 1510 /* response header len is 11 1511 * PDU Header(7) + IO Size (4) 1512 */ 1513 req = p9_client_zc_rpc(clnt, P9_TREAD, to, NULL, rsize, 1514 0, 11, "dqd", fid->fid, 1515 offset, rsize); 1516 } else { 1517 non_zc = 1; 1518 req = p9_client_rpc(clnt, P9_TREAD, "dqd", fid->fid, offset, 1519 rsize); 1520 } 1521 if (IS_ERR(req)) { 1522 *err = PTR_ERR(req); 1523 return 0; 1524 } 1525 1526 *err = p9pdu_readf(&req->rc, clnt->proto_version, 1527 "D", &count, &dataptr); 1528 if (*err) { 1529 trace_9p_protocol_dump(clnt, &req->rc); 1530 p9_tag_remove(clnt, req); 1531 return 0; 1532 } 1533 if (rsize < count) { 1534 pr_err("bogus RREAD count (%d > %d)\n", count, rsize); 1535 count = rsize; 1536 } 1537 1538 p9_debug(P9_DEBUG_9P, "<<< RREAD count %d\n", count); 1539 1540 if (non_zc) { 1541 int n = copy_to_iter(dataptr, count, to); 1542 1543 if (n != count) { 1544 *err = -EFAULT; 1545 p9_tag_remove(clnt, req); 1546 return n; 1547 } 1548 } else { 1549 iov_iter_advance(to, count); 1550 } 1551 p9_tag_remove(clnt, req); 1552 return count; 1553 } 1554 EXPORT_SYMBOL(p9_client_read_once); 1555 1556 int 1557 p9_client_write(struct p9_fid *fid, u64 offset, struct iov_iter *from, int *err) 1558 { 1559 struct p9_client *clnt = fid->clnt; 1560 struct p9_req_t *req; 1561 int total = 0; 1562 *err = 0; 1563 1564 p9_debug(P9_DEBUG_9P, ">>> TWRITE fid %d offset %llu count %zd\n", 1565 fid->fid, offset, iov_iter_count(from)); 1566 1567 while (iov_iter_count(from)) { 1568 int count = iov_iter_count(from); 1569 int rsize = fid->iounit; 1570 1571 if (!rsize || rsize > clnt->msize - P9_IOHDRSZ) 1572 rsize = clnt->msize - P9_IOHDRSZ; 1573 1574 if (count < rsize) 1575 rsize = count; 1576 1577 /* Don't bother zerocopy for small IO (< 1024) */ 1578 if (clnt->trans_mod->zc_request && rsize > 1024) { 1579 req = p9_client_zc_rpc(clnt, P9_TWRITE, NULL, from, 0, 1580 rsize, P9_ZC_HDR_SZ, "dqd", 1581 fid->fid, offset, rsize); 1582 } else { 1583 req = p9_client_rpc(clnt, P9_TWRITE, "dqV", fid->fid, 1584 offset, rsize, from); 1585 } 1586 if (IS_ERR(req)) { 1587 *err = PTR_ERR(req); 1588 break; 1589 } 1590 1591 *err = p9pdu_readf(&req->rc, clnt->proto_version, "d", &count); 1592 if (*err) { 1593 trace_9p_protocol_dump(clnt, &req->rc); 1594 p9_tag_remove(clnt, req); 1595 break; 1596 } 1597 if (rsize < count) { 1598 pr_err("bogus RWRITE count (%d > %d)\n", count, rsize); 1599 count = rsize; 1600 } 1601 1602 p9_debug(P9_DEBUG_9P, "<<< RWRITE count %d\n", count); 1603 1604 p9_tag_remove(clnt, req); 1605 iov_iter_advance(from, count); 1606 total += count; 1607 offset += count; 1608 } 1609 return total; 1610 } 1611 EXPORT_SYMBOL(p9_client_write); 1612 1613 struct p9_wstat *p9_client_stat(struct p9_fid *fid) 1614 { 1615 int err; 1616 struct p9_client *clnt; 1617 struct p9_wstat *ret; 1618 struct p9_req_t *req; 1619 u16 ignored; 1620 1621 p9_debug(P9_DEBUG_9P, ">>> TSTAT fid %d\n", fid->fid); 1622 1623 ret = kmalloc(sizeof(*ret), GFP_KERNEL); 1624 if (!ret) 1625 return ERR_PTR(-ENOMEM); 1626 1627 err = 0; 1628 clnt = fid->clnt; 1629 1630 req = p9_client_rpc(clnt, P9_TSTAT, "d", fid->fid); 1631 if (IS_ERR(req)) { 1632 err = PTR_ERR(req); 1633 goto error; 1634 } 1635 1636 err = p9pdu_readf(&req->rc, clnt->proto_version, "wS", &ignored, ret); 1637 if (err) { 1638 trace_9p_protocol_dump(clnt, &req->rc); 1639 p9_tag_remove(clnt, req); 1640 goto error; 1641 } 1642 1643 p9_debug(P9_DEBUG_9P, 1644 "<<< RSTAT sz=%x type=%x dev=%x qid=%x.%llx.%x\n" 1645 "<<< mode=%8.8x atime=%8.8x mtime=%8.8x length=%llx\n" 1646 "<<< name=%s uid=%s gid=%s muid=%s extension=(%s)\n" 1647 "<<< uid=%d gid=%d n_muid=%d\n", 1648 ret->size, ret->type, ret->dev, ret->qid.type, ret->qid.path, 1649 ret->qid.version, ret->mode, 1650 ret->atime, ret->mtime, ret->length, 1651 ret->name, ret->uid, ret->gid, ret->muid, ret->extension, 1652 from_kuid(&init_user_ns, ret->n_uid), 1653 from_kgid(&init_user_ns, ret->n_gid), 1654 from_kuid(&init_user_ns, ret->n_muid)); 1655 1656 p9_tag_remove(clnt, req); 1657 return ret; 1658 1659 error: 1660 kfree(ret); 1661 return ERR_PTR(err); 1662 } 1663 EXPORT_SYMBOL(p9_client_stat); 1664 1665 struct p9_stat_dotl *p9_client_getattr_dotl(struct p9_fid *fid, 1666 u64 request_mask) 1667 { 1668 int err; 1669 struct p9_client *clnt; 1670 struct p9_stat_dotl *ret; 1671 struct p9_req_t *req; 1672 1673 p9_debug(P9_DEBUG_9P, ">>> TGETATTR fid %d, request_mask %lld\n", 1674 fid->fid, request_mask); 1675 1676 ret = kmalloc(sizeof(*ret), GFP_KERNEL); 1677 if (!ret) 1678 return ERR_PTR(-ENOMEM); 1679 1680 err = 0; 1681 clnt = fid->clnt; 1682 1683 req = p9_client_rpc(clnt, P9_TGETATTR, "dq", fid->fid, request_mask); 1684 if (IS_ERR(req)) { 1685 err = PTR_ERR(req); 1686 goto error; 1687 } 1688 1689 err = p9pdu_readf(&req->rc, clnt->proto_version, "A", ret); 1690 if (err) { 1691 trace_9p_protocol_dump(clnt, &req->rc); 1692 p9_tag_remove(clnt, req); 1693 goto error; 1694 } 1695 1696 p9_debug(P9_DEBUG_9P, "<<< RGETATTR st_result_mask=%lld\n" 1697 "<<< qid=%x.%llx.%x\n" 1698 "<<< st_mode=%8.8x st_nlink=%llu\n" 1699 "<<< st_uid=%d st_gid=%d\n" 1700 "<<< st_rdev=%llx st_size=%llx st_blksize=%llu st_blocks=%llu\n" 1701 "<<< st_atime_sec=%lld st_atime_nsec=%lld\n" 1702 "<<< st_mtime_sec=%lld st_mtime_nsec=%lld\n" 1703 "<<< st_ctime_sec=%lld st_ctime_nsec=%lld\n" 1704 "<<< st_btime_sec=%lld st_btime_nsec=%lld\n" 1705 "<<< st_gen=%lld st_data_version=%lld\n", 1706 ret->st_result_mask, 1707 ret->qid.type, ret->qid.path, ret->qid.version, 1708 ret->st_mode, ret->st_nlink, 1709 from_kuid(&init_user_ns, ret->st_uid), 1710 from_kgid(&init_user_ns, ret->st_gid), 1711 ret->st_rdev, ret->st_size, ret->st_blksize, ret->st_blocks, 1712 ret->st_atime_sec, ret->st_atime_nsec, 1713 ret->st_mtime_sec, ret->st_mtime_nsec, 1714 ret->st_ctime_sec, ret->st_ctime_nsec, 1715 ret->st_btime_sec, ret->st_btime_nsec, 1716 ret->st_gen, ret->st_data_version); 1717 1718 p9_tag_remove(clnt, req); 1719 return ret; 1720 1721 error: 1722 kfree(ret); 1723 return ERR_PTR(err); 1724 } 1725 EXPORT_SYMBOL(p9_client_getattr_dotl); 1726 1727 static int p9_client_statsize(struct p9_wstat *wst, int proto_version) 1728 { 1729 int ret; 1730 1731 /* NOTE: size shouldn't include its own length */ 1732 /* size[2] type[2] dev[4] qid[13] */ 1733 /* mode[4] atime[4] mtime[4] length[8]*/ 1734 /* name[s] uid[s] gid[s] muid[s] */ 1735 ret = 2 + 4 + 13 + 4 + 4 + 4 + 8 + 2 + 2 + 2 + 2; 1736 1737 if (wst->name) 1738 ret += strlen(wst->name); 1739 if (wst->uid) 1740 ret += strlen(wst->uid); 1741 if (wst->gid) 1742 ret += strlen(wst->gid); 1743 if (wst->muid) 1744 ret += strlen(wst->muid); 1745 1746 if (proto_version == p9_proto_2000u || 1747 proto_version == p9_proto_2000L) { 1748 /* extension[s] n_uid[4] n_gid[4] n_muid[4] */ 1749 ret += 2 + 4 + 4 + 4; 1750 if (wst->extension) 1751 ret += strlen(wst->extension); 1752 } 1753 1754 return ret; 1755 } 1756 1757 int p9_client_wstat(struct p9_fid *fid, struct p9_wstat *wst) 1758 { 1759 int err; 1760 struct p9_req_t *req; 1761 struct p9_client *clnt; 1762 1763 err = 0; 1764 clnt = fid->clnt; 1765 wst->size = p9_client_statsize(wst, clnt->proto_version); 1766 p9_debug(P9_DEBUG_9P, ">>> TWSTAT fid %d\n", 1767 fid->fid); 1768 p9_debug(P9_DEBUG_9P, 1769 " sz=%x type=%x dev=%x qid=%x.%llx.%x\n" 1770 " mode=%8.8x atime=%8.8x mtime=%8.8x length=%llx\n" 1771 " name=%s uid=%s gid=%s muid=%s extension=(%s)\n" 1772 " uid=%d gid=%d n_muid=%d\n", 1773 wst->size, wst->type, wst->dev, wst->qid.type, 1774 wst->qid.path, wst->qid.version, 1775 wst->mode, wst->atime, wst->mtime, wst->length, 1776 wst->name, wst->uid, wst->gid, wst->muid, wst->extension, 1777 from_kuid(&init_user_ns, wst->n_uid), 1778 from_kgid(&init_user_ns, wst->n_gid), 1779 from_kuid(&init_user_ns, wst->n_muid)); 1780 1781 req = p9_client_rpc(clnt, P9_TWSTAT, "dwS", 1782 fid->fid, wst->size + 2, wst); 1783 if (IS_ERR(req)) { 1784 err = PTR_ERR(req); 1785 goto error; 1786 } 1787 1788 p9_debug(P9_DEBUG_9P, "<<< RWSTAT fid %d\n", fid->fid); 1789 1790 p9_tag_remove(clnt, req); 1791 error: 1792 return err; 1793 } 1794 EXPORT_SYMBOL(p9_client_wstat); 1795 1796 int p9_client_setattr(struct p9_fid *fid, struct p9_iattr_dotl *p9attr) 1797 { 1798 int err; 1799 struct p9_req_t *req; 1800 struct p9_client *clnt; 1801 1802 err = 0; 1803 clnt = fid->clnt; 1804 p9_debug(P9_DEBUG_9P, ">>> TSETATTR fid %d\n", fid->fid); 1805 p9_debug(P9_DEBUG_9P, " valid=%x mode=%x uid=%d gid=%d size=%lld\n", 1806 p9attr->valid, p9attr->mode, 1807 from_kuid(&init_user_ns, p9attr->uid), 1808 from_kgid(&init_user_ns, p9attr->gid), 1809 p9attr->size); 1810 p9_debug(P9_DEBUG_9P, " atime_sec=%lld atime_nsec=%lld\n", 1811 p9attr->atime_sec, p9attr->atime_nsec); 1812 p9_debug(P9_DEBUG_9P, " mtime_sec=%lld mtime_nsec=%lld\n", 1813 p9attr->mtime_sec, p9attr->mtime_nsec); 1814 1815 req = p9_client_rpc(clnt, P9_TSETATTR, "dI", fid->fid, p9attr); 1816 1817 if (IS_ERR(req)) { 1818 err = PTR_ERR(req); 1819 goto error; 1820 } 1821 p9_debug(P9_DEBUG_9P, "<<< RSETATTR fid %d\n", fid->fid); 1822 p9_tag_remove(clnt, req); 1823 error: 1824 return err; 1825 } 1826 EXPORT_SYMBOL(p9_client_setattr); 1827 1828 int p9_client_statfs(struct p9_fid *fid, struct p9_rstatfs *sb) 1829 { 1830 int err; 1831 struct p9_req_t *req; 1832 struct p9_client *clnt; 1833 1834 err = 0; 1835 clnt = fid->clnt; 1836 1837 p9_debug(P9_DEBUG_9P, ">>> TSTATFS fid %d\n", fid->fid); 1838 1839 req = p9_client_rpc(clnt, P9_TSTATFS, "d", fid->fid); 1840 if (IS_ERR(req)) { 1841 err = PTR_ERR(req); 1842 goto error; 1843 } 1844 1845 err = p9pdu_readf(&req->rc, clnt->proto_version, "ddqqqqqqd", &sb->type, 1846 &sb->bsize, &sb->blocks, &sb->bfree, &sb->bavail, 1847 &sb->files, &sb->ffree, &sb->fsid, &sb->namelen); 1848 if (err) { 1849 trace_9p_protocol_dump(clnt, &req->rc); 1850 p9_tag_remove(clnt, req); 1851 goto error; 1852 } 1853 1854 p9_debug(P9_DEBUG_9P, 1855 "<<< RSTATFS fid %d type 0x%x bsize %u blocks %llu bfree %llu bavail %llu files %llu ffree %llu fsid %llu namelen %u\n", 1856 fid->fid, sb->type, sb->bsize, sb->blocks, sb->bfree, 1857 sb->bavail, sb->files, sb->ffree, sb->fsid, sb->namelen); 1858 1859 p9_tag_remove(clnt, req); 1860 error: 1861 return err; 1862 } 1863 EXPORT_SYMBOL(p9_client_statfs); 1864 1865 int p9_client_rename(struct p9_fid *fid, 1866 struct p9_fid *newdirfid, const char *name) 1867 { 1868 int err; 1869 struct p9_req_t *req; 1870 struct p9_client *clnt; 1871 1872 err = 0; 1873 clnt = fid->clnt; 1874 1875 p9_debug(P9_DEBUG_9P, ">>> TRENAME fid %d newdirfid %d name %s\n", 1876 fid->fid, newdirfid->fid, name); 1877 1878 req = p9_client_rpc(clnt, P9_TRENAME, "dds", fid->fid, 1879 newdirfid->fid, name); 1880 if (IS_ERR(req)) { 1881 err = PTR_ERR(req); 1882 goto error; 1883 } 1884 1885 p9_debug(P9_DEBUG_9P, "<<< RRENAME fid %d\n", fid->fid); 1886 1887 p9_tag_remove(clnt, req); 1888 error: 1889 return err; 1890 } 1891 EXPORT_SYMBOL(p9_client_rename); 1892 1893 int p9_client_renameat(struct p9_fid *olddirfid, const char *old_name, 1894 struct p9_fid *newdirfid, const char *new_name) 1895 { 1896 int err; 1897 struct p9_req_t *req; 1898 struct p9_client *clnt; 1899 1900 err = 0; 1901 clnt = olddirfid->clnt; 1902 1903 p9_debug(P9_DEBUG_9P, 1904 ">>> TRENAMEAT olddirfid %d old name %s newdirfid %d new name %s\n", 1905 olddirfid->fid, old_name, newdirfid->fid, new_name); 1906 1907 req = p9_client_rpc(clnt, P9_TRENAMEAT, "dsds", olddirfid->fid, 1908 old_name, newdirfid->fid, new_name); 1909 if (IS_ERR(req)) { 1910 err = PTR_ERR(req); 1911 goto error; 1912 } 1913 1914 p9_debug(P9_DEBUG_9P, "<<< RRENAMEAT newdirfid %d new name %s\n", 1915 newdirfid->fid, new_name); 1916 1917 p9_tag_remove(clnt, req); 1918 error: 1919 return err; 1920 } 1921 EXPORT_SYMBOL(p9_client_renameat); 1922 1923 /* An xattrwalk without @attr_name gives the fid for the lisxattr namespace 1924 */ 1925 struct p9_fid *p9_client_xattrwalk(struct p9_fid *file_fid, 1926 const char *attr_name, u64 *attr_size) 1927 { 1928 int err; 1929 struct p9_req_t *req; 1930 struct p9_client *clnt; 1931 struct p9_fid *attr_fid; 1932 1933 err = 0; 1934 clnt = file_fid->clnt; 1935 attr_fid = p9_fid_create(clnt); 1936 if (!attr_fid) { 1937 err = -ENOMEM; 1938 goto error; 1939 } 1940 p9_debug(P9_DEBUG_9P, 1941 ">>> TXATTRWALK file_fid %d, attr_fid %d name %s\n", 1942 file_fid->fid, attr_fid->fid, attr_name); 1943 1944 req = p9_client_rpc(clnt, P9_TXATTRWALK, "dds", 1945 file_fid->fid, attr_fid->fid, attr_name); 1946 if (IS_ERR(req)) { 1947 err = PTR_ERR(req); 1948 goto error; 1949 } 1950 err = p9pdu_readf(&req->rc, clnt->proto_version, "q", attr_size); 1951 if (err) { 1952 trace_9p_protocol_dump(clnt, &req->rc); 1953 p9_tag_remove(clnt, req); 1954 goto clunk_fid; 1955 } 1956 p9_tag_remove(clnt, req); 1957 p9_debug(P9_DEBUG_9P, "<<< RXATTRWALK fid %d size %llu\n", 1958 attr_fid->fid, *attr_size); 1959 return attr_fid; 1960 clunk_fid: 1961 p9_client_clunk(attr_fid); 1962 attr_fid = NULL; 1963 error: 1964 if (attr_fid && attr_fid != file_fid) 1965 p9_fid_destroy(attr_fid); 1966 1967 return ERR_PTR(err); 1968 } 1969 EXPORT_SYMBOL_GPL(p9_client_xattrwalk); 1970 1971 int p9_client_xattrcreate(struct p9_fid *fid, const char *name, 1972 u64 attr_size, int flags) 1973 { 1974 int err; 1975 struct p9_req_t *req; 1976 struct p9_client *clnt; 1977 1978 p9_debug(P9_DEBUG_9P, 1979 ">>> TXATTRCREATE fid %d name %s size %llu flag %d\n", 1980 fid->fid, name, attr_size, flags); 1981 err = 0; 1982 clnt = fid->clnt; 1983 req = p9_client_rpc(clnt, P9_TXATTRCREATE, "dsqd", 1984 fid->fid, name, attr_size, flags); 1985 if (IS_ERR(req)) { 1986 err = PTR_ERR(req); 1987 goto error; 1988 } 1989 p9_debug(P9_DEBUG_9P, "<<< RXATTRCREATE fid %d\n", fid->fid); 1990 p9_tag_remove(clnt, req); 1991 error: 1992 return err; 1993 } 1994 EXPORT_SYMBOL_GPL(p9_client_xattrcreate); 1995 1996 int p9_client_readdir(struct p9_fid *fid, char *data, u32 count, u64 offset) 1997 { 1998 int err, rsize, non_zc = 0; 1999 struct p9_client *clnt; 2000 struct p9_req_t *req; 2001 char *dataptr; 2002 struct kvec kv = {.iov_base = data, .iov_len = count}; 2003 struct iov_iter to; 2004 2005 iov_iter_kvec(&to, READ, &kv, 1, count); 2006 2007 p9_debug(P9_DEBUG_9P, ">>> TREADDIR fid %d offset %llu count %d\n", 2008 fid->fid, offset, count); 2009 2010 err = 0; 2011 clnt = fid->clnt; 2012 2013 rsize = fid->iounit; 2014 if (!rsize || rsize > clnt->msize - P9_READDIRHDRSZ) 2015 rsize = clnt->msize - P9_READDIRHDRSZ; 2016 2017 if (count < rsize) 2018 rsize = count; 2019 2020 /* Don't bother zerocopy for small IO (< 1024) */ 2021 if (clnt->trans_mod->zc_request && rsize > 1024) { 2022 /* response header len is 11 2023 * PDU Header(7) + IO Size (4) 2024 */ 2025 req = p9_client_zc_rpc(clnt, P9_TREADDIR, &to, NULL, rsize, 0, 2026 11, "dqd", fid->fid, offset, rsize); 2027 } else { 2028 non_zc = 1; 2029 req = p9_client_rpc(clnt, P9_TREADDIR, "dqd", fid->fid, 2030 offset, rsize); 2031 } 2032 if (IS_ERR(req)) { 2033 err = PTR_ERR(req); 2034 goto error; 2035 } 2036 2037 err = p9pdu_readf(&req->rc, clnt->proto_version, "D", &count, &dataptr); 2038 if (err) { 2039 trace_9p_protocol_dump(clnt, &req->rc); 2040 goto free_and_error; 2041 } 2042 if (rsize < count) { 2043 pr_err("bogus RREADDIR count (%d > %d)\n", count, rsize); 2044 count = rsize; 2045 } 2046 2047 p9_debug(P9_DEBUG_9P, "<<< RREADDIR count %d\n", count); 2048 2049 if (non_zc) 2050 memmove(data, dataptr, count); 2051 2052 p9_tag_remove(clnt, req); 2053 return count; 2054 2055 free_and_error: 2056 p9_tag_remove(clnt, req); 2057 error: 2058 return err; 2059 } 2060 EXPORT_SYMBOL(p9_client_readdir); 2061 2062 int p9_client_mknod_dotl(struct p9_fid *fid, const char *name, int mode, 2063 dev_t rdev, kgid_t gid, struct p9_qid *qid) 2064 { 2065 int err; 2066 struct p9_client *clnt; 2067 struct p9_req_t *req; 2068 2069 err = 0; 2070 clnt = fid->clnt; 2071 p9_debug(P9_DEBUG_9P, 2072 ">>> TMKNOD fid %d name %s mode %d major %d minor %d\n", 2073 fid->fid, name, mode, MAJOR(rdev), MINOR(rdev)); 2074 req = p9_client_rpc(clnt, P9_TMKNOD, "dsdddg", fid->fid, name, mode, 2075 MAJOR(rdev), MINOR(rdev), gid); 2076 if (IS_ERR(req)) 2077 return PTR_ERR(req); 2078 2079 err = p9pdu_readf(&req->rc, clnt->proto_version, "Q", qid); 2080 if (err) { 2081 trace_9p_protocol_dump(clnt, &req->rc); 2082 goto error; 2083 } 2084 p9_debug(P9_DEBUG_9P, "<<< RMKNOD qid %x.%llx.%x\n", 2085 qid->type, qid->path, qid->version); 2086 2087 error: 2088 p9_tag_remove(clnt, req); 2089 return err; 2090 } 2091 EXPORT_SYMBOL(p9_client_mknod_dotl); 2092 2093 int p9_client_mkdir_dotl(struct p9_fid *fid, const char *name, int mode, 2094 kgid_t gid, struct p9_qid *qid) 2095 { 2096 int err; 2097 struct p9_client *clnt; 2098 struct p9_req_t *req; 2099 2100 err = 0; 2101 clnt = fid->clnt; 2102 p9_debug(P9_DEBUG_9P, ">>> TMKDIR fid %d name %s mode %d gid %d\n", 2103 fid->fid, name, mode, from_kgid(&init_user_ns, gid)); 2104 req = p9_client_rpc(clnt, P9_TMKDIR, "dsdg", 2105 fid->fid, name, mode, gid); 2106 if (IS_ERR(req)) 2107 return PTR_ERR(req); 2108 2109 err = p9pdu_readf(&req->rc, clnt->proto_version, "Q", qid); 2110 if (err) { 2111 trace_9p_protocol_dump(clnt, &req->rc); 2112 goto error; 2113 } 2114 p9_debug(P9_DEBUG_9P, "<<< RMKDIR qid %x.%llx.%x\n", qid->type, 2115 qid->path, qid->version); 2116 2117 error: 2118 p9_tag_remove(clnt, req); 2119 return err; 2120 } 2121 EXPORT_SYMBOL(p9_client_mkdir_dotl); 2122 2123 int p9_client_lock_dotl(struct p9_fid *fid, struct p9_flock *flock, u8 *status) 2124 { 2125 int err; 2126 struct p9_client *clnt; 2127 struct p9_req_t *req; 2128 2129 err = 0; 2130 clnt = fid->clnt; 2131 p9_debug(P9_DEBUG_9P, 2132 ">>> TLOCK fid %d type %i flags %d start %lld length %lld proc_id %d client_id %s\n", 2133 fid->fid, flock->type, flock->flags, flock->start, 2134 flock->length, flock->proc_id, flock->client_id); 2135 2136 req = p9_client_rpc(clnt, P9_TLOCK, "dbdqqds", fid->fid, flock->type, 2137 flock->flags, flock->start, flock->length, 2138 flock->proc_id, flock->client_id); 2139 2140 if (IS_ERR(req)) 2141 return PTR_ERR(req); 2142 2143 err = p9pdu_readf(&req->rc, clnt->proto_version, "b", status); 2144 if (err) { 2145 trace_9p_protocol_dump(clnt, &req->rc); 2146 goto error; 2147 } 2148 p9_debug(P9_DEBUG_9P, "<<< RLOCK status %i\n", *status); 2149 error: 2150 p9_tag_remove(clnt, req); 2151 return err; 2152 } 2153 EXPORT_SYMBOL(p9_client_lock_dotl); 2154 2155 int p9_client_getlock_dotl(struct p9_fid *fid, struct p9_getlock *glock) 2156 { 2157 int err; 2158 struct p9_client *clnt; 2159 struct p9_req_t *req; 2160 2161 err = 0; 2162 clnt = fid->clnt; 2163 p9_debug(P9_DEBUG_9P, 2164 ">>> TGETLOCK fid %d, type %i start %lld length %lld proc_id %d client_id %s\n", 2165 fid->fid, glock->type, glock->start, glock->length, 2166 glock->proc_id, glock->client_id); 2167 2168 req = p9_client_rpc(clnt, P9_TGETLOCK, "dbqqds", fid->fid, 2169 glock->type, glock->start, glock->length, 2170 glock->proc_id, glock->client_id); 2171 2172 if (IS_ERR(req)) 2173 return PTR_ERR(req); 2174 2175 err = p9pdu_readf(&req->rc, clnt->proto_version, "bqqds", &glock->type, 2176 &glock->start, &glock->length, &glock->proc_id, 2177 &glock->client_id); 2178 if (err) { 2179 trace_9p_protocol_dump(clnt, &req->rc); 2180 goto error; 2181 } 2182 p9_debug(P9_DEBUG_9P, 2183 "<<< RGETLOCK type %i start %lld length %lld proc_id %d client_id %s\n", 2184 glock->type, glock->start, glock->length, 2185 glock->proc_id, glock->client_id); 2186 error: 2187 p9_tag_remove(clnt, req); 2188 return err; 2189 } 2190 EXPORT_SYMBOL(p9_client_getlock_dotl); 2191 2192 int p9_client_readlink(struct p9_fid *fid, char **target) 2193 { 2194 int err; 2195 struct p9_client *clnt; 2196 struct p9_req_t *req; 2197 2198 err = 0; 2199 clnt = fid->clnt; 2200 p9_debug(P9_DEBUG_9P, ">>> TREADLINK fid %d\n", fid->fid); 2201 2202 req = p9_client_rpc(clnt, P9_TREADLINK, "d", fid->fid); 2203 if (IS_ERR(req)) 2204 return PTR_ERR(req); 2205 2206 err = p9pdu_readf(&req->rc, clnt->proto_version, "s", target); 2207 if (err) { 2208 trace_9p_protocol_dump(clnt, &req->rc); 2209 goto error; 2210 } 2211 p9_debug(P9_DEBUG_9P, "<<< RREADLINK target %s\n", *target); 2212 error: 2213 p9_tag_remove(clnt, req); 2214 return err; 2215 } 2216 EXPORT_SYMBOL(p9_client_readlink); 2217 2218 int __init p9_client_init(void) 2219 { 2220 p9_req_cache = KMEM_CACHE(p9_req_t, SLAB_TYPESAFE_BY_RCU); 2221 return p9_req_cache ? 0 : -ENOMEM; 2222 } 2223 2224 void __exit p9_client_exit(void) 2225 { 2226 kmem_cache_destroy(p9_req_cache); 2227 } 2228