net/9p/client.c

   1 /*
   2  * net/9p/clnt.c
   3  *
   4  * 9P Client
   5  *
   6  *  Copyright (C) 2008 by Eric Van Hensbergen <ericvh@gmail.com>
   7  *  Copyright (C) 2007 by Latchesar Ionkov <lucho@ionkov.net>
   8  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License version 2
  11  *  as published by the Free Software Foundation.
  12  *
  13  *  This program is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *  GNU General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU General Public License
  19  *  along with this program; if not, write to:
  20  *  Free Software Foundation
  21  *  51 Franklin Street, Fifth Floor
  22  *  Boston, MA  02111-1301  USA
  23  *
  24  */
  25
  26 #include <linux/module.h>
  27 #include <linux/errno.h>
  28 #include <linux/fs.h>
  29 #include <linux/poll.h>
  30 #include <linux/idr.h>
  31 #include <linux/mutex.h>
  32 #include <linux/slab.h>
  33 #include <linux/sched.h>
  34 #include <linux/uaccess.h>
  35 #include <net/9p/9p.h>
  36 #include <linux/parser.h>
  37 #include <net/9p/client.h>
  38 #include <net/9p/transport.h>
  39 #include "protocol.h"
  40
  41 /*
  42   * Client Option Parsing (code inspired by NFS code)
  43   *  - a little lazy - parse all client options
  44   */
  45
  46 enum {
  47         Opt_msize,
  48         Opt_trans,
  49         Opt_legacy,
  50         Opt_version,
  51         Opt_err,
  52 };
  53
  54 static const match_table_t tokens = {
  55         {Opt_msize, "msize=%u"},
  56         {Opt_legacy, "noextend"},
  57         {Opt_trans, "trans=%s"},
  58         {Opt_version, "version=%s"},
  59         {Opt_err, NULL},
  60 };
  61
  62 inline int p9_is_proto_dotl(struct p9_client *clnt)
  63 {
  64         return (clnt->proto_version == p9_proto_2000L);
  65 }
  66 EXPORT_SYMBOL(p9_is_proto_dotl);
  67
  68 inline int p9_is_proto_dotu(struct p9_client *clnt)
  69 {
  70         return (clnt->proto_version == p9_proto_2000u);
  71 }
  72 EXPORT_SYMBOL(p9_is_proto_dotu);
  73
  74 /* Interpret mount option for protocol version */
  75 static int get_protocol_version(const substring_t *name)
  76 {
  77         int version = -EINVAL;
  78
  79         if (!strncmp("9p2000", name->from, name->to-name->from)) {
  80                 version = p9_proto_legacy;
  81                 P9_DPRINTK(P9_DEBUG_9P, "Protocol version: Legacy\n");
  82         } else if (!strncmp("9p2000.u", name->from, name->to-name->from)) {
  83                 version = p9_proto_2000u;
  84                 P9_DPRINTK(P9_DEBUG_9P, "Protocol version: 9P2000.u\n");
  85         } else if (!strncmp("9p2000.L", name->from, name->to-name->from)) {
  86                 version = p9_proto_2000L;
  87                 P9_DPRINTK(P9_DEBUG_9P, "Protocol version: 9P2000.L\n");
  88         } else {
  89                 P9_DPRINTK(P9_DEBUG_ERROR, "Unknown protocol version %s. ",
  90                                                         name->from);
  91         }
  92         return version;
  93 }
  94
  95 static struct p9_req_t *
  96 p9_client_rpc(struct p9_client *c, int8_t type, const char *fmt, ...);
  97
  98 /**
  99  * parse_options - parse mount options into client structure
 100  * @opts: options string passed from mount
 101  * @clnt: existing v9fs client information
 102  *
 103  * Return 0 upon success, -ERRNO upon failure
 104  */
 105
 106 static int parse_opts(char *opts, struct p9_client *clnt)
 107 {
 108         char *options, *tmp_options;
 109         char *p;
 110         substring_t args[MAX_OPT_ARGS];
 111         int option;
 112         int ret = 0;
 113
 114         clnt->proto_version = p9_proto_2000u;
 115         clnt->msize = 8192;
 116
 117         if (!opts)
 118                 return 0;
 119
 120         tmp_options = kstrdup(opts, GFP_KERNEL);
 121         if (!tmp_options) {
 122                 P9_DPRINTK(P9_DEBUG_ERROR,
 123                                 "failed to allocate copy of option string\n");
 124                 return -ENOMEM;
 125         }
 126         options = tmp_options;
 127
 128         while ((p = strsep(&options, ",")) != NULL) {
 129                 int token;
 130                 if (!*p)
 131                         continue;
 132                 token = match_token(p, tokens, args);
 133                 if (token < Opt_trans) {
 134                         int r = match_int(&args[0], &option);
 135                         if (r < 0) {
 136                                 P9_DPRINTK(P9_DEBUG_ERROR,
 137                                         "integer field, but no integer?\n");
 138                                 ret = r;
 139                                 continue;
 140                         }
 141                 }
 142                 switch (token) {
 143                 case Opt_msize:
 144                         clnt->msize = option;
 145                         break;
 146                 case Opt_trans:
 147                         clnt->trans_mod = v9fs_get_trans_by_name(&args[0]);
 148                         if(clnt->trans_mod == NULL) {
 149                                 P9_DPRINTK(P9_DEBUG_ERROR,
 150                                    "Could not find request transport: %s\n",
 151                                    (char *) &args[0]);
 152                                 ret = -EINVAL;
 153                                 goto free_and_return;
 154                         }
 155                         break;
 156                 case Opt_legacy:
 157                         clnt->proto_version = p9_proto_legacy;
 158                         break;
 159                 case Opt_version:
 160                         ret = get_protocol_version(&args[0]);
 161                         if (ret == -EINVAL)
 162                                 goto free_and_return;
 163                         clnt->proto_version = ret;
 164                         break;
 165                 default:
 166                         continue;
 167                 }
 168         }
 169
 170 free_and_return:
 171         kfree(tmp_options);
 172         return ret;
 173 }
 174
 175 /**
 176  * p9_tag_alloc - lookup/allocate a request by tag
 177  * @c: client session to lookup tag within
 178  * @tag: numeric id for transaction
 179  *
 180  * this is a simple array lookup, but will grow the
 181  * request_slots as necessary to accomodate transaction
 182  * ids which did not previously have a slot.
 183  *
 184  * this code relies on the client spinlock to manage locks, its
 185  * possible we should switch to something else, but I'd rather
 186  * stick with something low-overhead for the common case.
 187  *
 188  */
 189
 190 static struct p9_req_t *p9_tag_alloc(struct p9_client *c, u16 tag)
 191 {
 192         unsigned long flags;
 193         int row, col;
 194         struct p9_req_t *req;
 195
 196         /* This looks up the original request by tag so we know which
 197          * buffer to read the data into */
 198         tag++;
 199
 200         if (tag >= c->max_tag) {
 201                 spin_lock_irqsave(&c->lock, flags);
 202                 /* check again since original check was outside of lock */
 203                 while (tag >= c->max_tag) {
 204                         row = (tag / P9_ROW_MAXTAG);
 205                         c->reqs[row] = kcalloc(P9_ROW_MAXTAG,
 206                                         sizeof(struct p9_req_t), GFP_ATOMIC);
 207
 208                         if (!c->reqs[row]) {
 209                                 printk(KERN_ERR "Couldn't grow tag array\n");
 210                                 spin_unlock_irqrestore(&c->lock, flags);
 211                                 return ERR_PTR(-ENOMEM);
 212                         }
 213                         for (col = 0; col < P9_ROW_MAXTAG; col++) {
 214                                 c->reqs[row][col].status = REQ_STATUS_IDLE;
 215                                 c->reqs[row][col].tc = NULL;
 216                         }
 217                         c->max_tag += P9_ROW_MAXTAG;
 218                 }
 219                 spin_unlock_irqrestore(&c->lock, flags);
 220         }
 221         row = tag / P9_ROW_MAXTAG;
 222         col = tag % P9_ROW_MAXTAG;
 223
 224         req = &c->reqs[row][col];
 225         if (!req->tc) {
 226                 req->wq = kmalloc(sizeof(wait_queue_head_t), GFP_KERNEL);
 227                 if (!req->wq) {
 228                         printk(KERN_ERR "Couldn't grow tag array\n");
 229                         return ERR_PTR(-ENOMEM);
 230                 }
 231                 init_waitqueue_head(req->wq);
 232                 req->tc = kmalloc(sizeof(struct p9_fcall)+c->msize,
 233                                                                 GFP_KERNEL);
 234                 req->rc = kmalloc(sizeof(struct p9_fcall)+c->msize,
 235                                                                 GFP_KERNEL);
 236                 if ((!req->tc) || (!req->rc)) {
 237                         printk(KERN_ERR "Couldn't grow tag array\n");
 238                         kfree(req->tc);
 239                         kfree(req->rc);
 240                         kfree(req->wq);
 241                         req->tc = req->rc = NULL;
 242                         req->wq = NULL;
 243                         return ERR_PTR(-ENOMEM);
 244                 }
 245                 req->tc->sdata = (char *) req->tc + sizeof(struct p9_fcall);
 246                 req->tc->capacity = c->msize;
 247                 req->rc->sdata = (char *) req->rc + sizeof(struct p9_fcall);
 248                 req->rc->capacity = c->msize;
 249         }
 250
 251         p9pdu_reset(req->tc);
 252         p9pdu_reset(req->rc);
 253
 254         req->tc->tag = tag-1;
 255         req->status = REQ_STATUS_ALLOC;
 256
 257         return &c->reqs[row][col];
 258 }
 259
 260 /**
 261  * p9_tag_lookup - lookup a request by tag
 262  * @c: client session to lookup tag within
 263  * @tag: numeric id for transaction
 264  *
 265  */
 266
 267 struct p9_req_t *p9_tag_lookup(struct p9_client *c, u16 tag)
 268 {
 269         int row, col;
 270
 271         /* This looks up the original request by tag so we know which
 272          * buffer to read the data into */
 273         tag++;
 274
 275         BUG_ON(tag >= c->max_tag);
 276
 277         row = tag / P9_ROW_MAXTAG;
 278         col = tag % P9_ROW_MAXTAG;
 279
 280         return &c->reqs[row][col];
 281 }
 282 EXPORT_SYMBOL(p9_tag_lookup);
 283
 284 /**
 285  * p9_tag_init - setup tags structure and contents
 286  * @c:  v9fs client struct
 287  *
 288  * This initializes the tags structure for each client instance.
 289  *
 290  */
 291
 292 static int p9_tag_init(struct p9_client *c)
 293 {
 294         int err = 0;
 295
 296         c->tagpool = p9_idpool_create();
 297         if (IS_ERR(c->tagpool)) {
 298                 err = PTR_ERR(c->tagpool);
 299                 c->tagpool = NULL;
 300                 goto error;
 301         }
 302
 303         p9_idpool_get(c->tagpool); /* reserve tag 0 */
 304
 305         c->max_tag = 0;
 306 error:
 307         return err;
 308 }
 309
 310 /**
 311  * p9_tag_cleanup - cleans up tags structure and reclaims resources
 312  * @c:  v9fs client struct
 313  *
 314  * This frees resources associated with the tags structure
 315  *
 316  */
 317 static void p9_tag_cleanup(struct p9_client *c)
 318 {
 319         int row, col;
 320
 321         /* check to insure all requests are idle */
 322         for (row = 0; row < (c->max_tag/P9_ROW_MAXTAG); row++) {
 323                 for (col = 0; col < P9_ROW_MAXTAG; col++) {
 324                         if (c->reqs[row][col].status != REQ_STATUS_IDLE) {
 325                                 P9_DPRINTK(P9_DEBUG_MUX,
 326                                   "Attempting to cleanup non-free tag %d,%d\n",
 327                                   row, col);
 328                                 /* TODO: delay execution of cleanup */
 329                                 return;
 330                         }
 331                 }
 332         }
 333
 334         if (c->tagpool)
 335                 p9_idpool_destroy(c->tagpool);
 336
 337         /* free requests associated with tags */
 338         for (row = 0; row < (c->max_tag/P9_ROW_MAXTAG); row++) {
 339                 for (col = 0; col < P9_ROW_MAXTAG; col++) {
 340                         kfree(c->reqs[row][col].wq);
 341                         kfree(c->reqs[row][col].tc);
 342                         kfree(c->reqs[row][col].rc);
 343                 }
 344                 kfree(c->reqs[row]);
 345         }
 346         c->max_tag = 0;
 347 }
 348
 349 /**
 350  * p9_free_req - free a request and clean-up as necessary
 351  * c: client state
 352  * r: request to release
 353  *
 354  */
 355
 356 static void p9_free_req(struct p9_client *c, struct p9_req_t *r)
 357 {
 358         int tag = r->tc->tag;
 359         P9_DPRINTK(P9_DEBUG_MUX, "clnt %p req %p tag: %d\n", c, r, tag);
 360
 361         r->status = REQ_STATUS_IDLE;
 362         if (tag != P9_NOTAG && p9_idpool_check(tag, c->tagpool))
 363                 p9_idpool_put(tag, c->tagpool);
 364 }
 365
 366 /**
 367  * p9_client_cb - call back from transport to client
 368  * c: client state
 369  * req: request received
 370  *
 371  */
 372 void p9_client_cb(struct p9_client *c, struct p9_req_t *req)
 373 {
 374         P9_DPRINTK(P9_DEBUG_MUX, " tag %d\n", req->tc->tag);
 375         wake_up(req->wq);
 376         P9_DPRINTK(P9_DEBUG_MUX, "wakeup: %d\n", req->tc->tag);
 377 }
 378 EXPORT_SYMBOL(p9_client_cb);
 379
 380 /**
 381  * p9_parse_header - parse header arguments out of a packet
 382  * @pdu: packet to parse
 383  * @size: size of packet
 384  * @type: type of request
 385  * @tag: tag of packet
 386  * @rewind: set if we need to rewind offset afterwards
 387  */
 388
 389 int
 390 p9_parse_header(struct p9_fcall *pdu, int32_t *size, int8_t *type, int16_t *tag,
 391                                                                 int rewind)
 392 {
 393         int8_t r_type;
 394         int16_t r_tag;
 395         int32_t r_size;
 396         int offset = pdu->offset;
 397         int err;
 398
 399         pdu->offset = 0;
 400         if (pdu->size == 0)
 401                 pdu->size = 7;
 402
 403         err = p9pdu_readf(pdu, 0, "dbw", &r_size, &r_type, &r_tag);
 404         if (err)
 405                 goto rewind_and_exit;
 406
 407         pdu->size = r_size;
 408         pdu->id = r_type;
 409         pdu->tag = r_tag;
 410
 411         P9_DPRINTK(P9_DEBUG_9P, "<<< size=%d type: %d tag: %d\n", pdu->size,
 412                                                         pdu->id, pdu->tag);
 413
 414         if (type)
 415                 *type = r_type;
 416         if (tag)
 417                 *tag = r_tag;
 418         if (size)
 419                 *size = r_size;
 420
 421
 422 rewind_and_exit:
 423         if (rewind)
 424                 pdu->offset = offset;
 425         return err;
 426 }
 427 EXPORT_SYMBOL(p9_parse_header);
 428
 429 /**
 430  * p9_check_errors - check 9p packet for error return and process it
 431  * @c: current client instance
 432  * @req: request to parse and check for error conditions
 433  *
 434  * returns error code if one is discovered, otherwise returns 0
 435  *
 436  * this will have to be more complicated if we have multiple
 437  * error packet types
 438  */
 439
 440 static int p9_check_errors(struct p9_client *c, struct p9_req_t *req)
 441 {
 442         int8_t type;
 443         int err;
 444
 445         err = p9_parse_header(req->rc, NULL, &type, NULL, 0);
 446         if (err) {
 447                 P9_DPRINTK(P9_DEBUG_ERROR, "couldn't parse header %d\n", err);
 448                 return err;
 449         }
 450
 451         if (type == P9_RERROR) {
 452                 int ecode;
 453                 char *ename;
 454
 455                 err = p9pdu_readf(req->rc, c->proto_version, "s?d",
 456                                                         &ename, &ecode);
 457                 if (err) {
 458                         P9_DPRINTK(P9_DEBUG_ERROR, "couldn't parse error%d\n",
 459                                                                         err);
 460                         return err;
 461                 }
 462
 463                 if (p9_is_proto_dotu(c) ||
 464                         p9_is_proto_dotl(c))
 465                         err = -ecode;
 466
 467                 if (!err || !IS_ERR_VALUE(err))
 468                         err = p9_errstr2errno(ename, strlen(ename));
 469
 470                 P9_DPRINTK(P9_DEBUG_9P, "<<< RERROR (%d) %s\n", -ecode, ename);
 471
 472                 kfree(ename);
 473         } else
 474                 err = 0;
 475
 476         return err;
 477 }
 478
 479 /**
 480  * p9_client_flush - flush (cancel) a request
 481  * @c: client state
 482  * @oldreq: request to cancel
 483  *
 484  * This sents a flush for a particular requests and links
 485  * the flush request to the original request.  The current
 486  * code only supports a single flush request although the protocol
 487  * allows for multiple flush requests to be sent for a single request.
 488  *
 489  */
 490
 491 static int p9_client_flush(struct p9_client *c, struct p9_req_t *oldreq)
 492 {
 493         struct p9_req_t *req;
 494         int16_t oldtag;
 495         int err;
 496
 497         err = p9_parse_header(oldreq->tc, NULL, NULL, &oldtag, 1);
 498         if (err)
 499                 return err;
 500
 501         P9_DPRINTK(P9_DEBUG_9P, ">>> TFLUSH tag %d\n", oldtag);
 502
 503         req = p9_client_rpc(c, P9_TFLUSH, "w", oldtag);
 504         if (IS_ERR(req))
 505                 return PTR_ERR(req);
 506
 507
 508         /* if we haven't received a response for oldreq,
 509            remove it from the list. */
 510         spin_lock(&c->lock);
 511         if (oldreq->status == REQ_STATUS_FLSH)
 512                 list_del(&oldreq->req_list);
 513         spin_unlock(&c->lock);
 514
 515         p9_free_req(c, req);
 516         return 0;
 517 }
 518
 519 /**
 520  * p9_client_rpc - issue a request and wait for a response
 521  * @c: client session
 522  * @type: type of request
 523  * @fmt: protocol format string (see protocol.c)
 524  *
 525  * Returns request structure (which client must free using p9_free_req)
 526  */
 527
 528 static struct p9_req_t *
 529 p9_client_rpc(struct p9_client *c, int8_t type, const char *fmt, ...)
 530 {
 531         va_list ap;
 532         int tag, err;
 533         struct p9_req_t *req;
 534         unsigned long flags;
 535         int sigpending;
 536
 537         P9_DPRINTK(P9_DEBUG_MUX, "client %p op %d\n", c, type);
 538
 539         /* we allow for any status other than disconnected */
 540         if (c->status == Disconnected)
 541                 return ERR_PTR(-EIO);
 542
 543         /* if status is begin_disconnected we allow only clunk request */
 544         if ((c->status == BeginDisconnect) && (type != P9_TCLUNK))
 545                 return ERR_PTR(-EIO);
 546
 547         if (signal_pending(current)) {
 548                 sigpending = 1;
 549                 clear_thread_flag(TIF_SIGPENDING);
 550         } else
 551                 sigpending = 0;
 552
 553         tag = P9_NOTAG;
 554         if (type != P9_TVERSION) {
 555                 tag = p9_idpool_get(c->tagpool);
 556                 if (tag < 0)
 557                         return ERR_PTR(-ENOMEM);
 558         }
 559
 560         req = p9_tag_alloc(c, tag);
 561         if (IS_ERR(req))
 562                 return req;
 563
 564         /* marshall the data */
 565         p9pdu_prepare(req->tc, tag, type);
 566         va_start(ap, fmt);
 567         err = p9pdu_vwritef(req->tc, c->proto_version, fmt, ap);
 568         va_end(ap);
 569         p9pdu_finalize(req->tc);
 570
 571         err = c->trans_mod->request(c, req);
 572         if (err < 0) {
 573                 c->status = Disconnected;
 574                 goto reterr;
 575         }
 576
 577         P9_DPRINTK(P9_DEBUG_MUX, "wait %p tag: %d\n", req->wq, tag);
 578         err = wait_event_interruptible(*req->wq,
 579                                                 req->status >= REQ_STATUS_RCVD);
 580         P9_DPRINTK(P9_DEBUG_MUX, "wait %p tag: %d returned %d\n",
 581                                                 req->wq, tag, err);
 582
 583         if (req->status == REQ_STATUS_ERROR) {
 584                 P9_DPRINTK(P9_DEBUG_ERROR, "req_status error %d\n", req->t_err);
 585                 err = req->t_err;
 586         }
 587
 588         if ((err == -ERESTARTSYS) && (c->status == Connected)) {
 589                 P9_DPRINTK(P9_DEBUG_MUX, "flushing\n");
 590                 sigpending = 1;
 591                 clear_thread_flag(TIF_SIGPENDING);
 592
 593                 if (c->trans_mod->cancel(c, req))
 594                         p9_client_flush(c, req);
 595
 596                 /* if we received the response anyway, don't signal error */
 597                 if (req->status == REQ_STATUS_RCVD)
 598                         err = 0;
 599         }
 600
 601         if (sigpending) {
 602                 spin_lock_irqsave(&current->sighand->siglock, flags);
 603                 recalc_sigpending();
 604                 spin_unlock_irqrestore(&current->sighand->siglock, flags);
 605         }
 606
 607         if (err < 0)
 608                 goto reterr;
 609
 610         err = p9_check_errors(c, req);
 611         if (!err) {
 612                 P9_DPRINTK(P9_DEBUG_MUX, "exit: client %p op %d\n", c, type);
 613                 return req;
 614         }
 615
 616 reterr:
 617         P9_DPRINTK(P9_DEBUG_MUX, "exit: client %p op %d error: %d\n", c, type,
 618                                                                         err);
 619         p9_free_req(c, req);
 620         return ERR_PTR(err);
 621 }
 622
 623 static struct p9_fid *p9_fid_create(struct p9_client *clnt)
 624 {
 625         int ret;
 626         struct p9_fid *fid;
 627         unsigned long flags;
 628
 629         P9_DPRINTK(P9_DEBUG_FID, "clnt %p\n", clnt);
 630         fid = kmalloc(sizeof(struct p9_fid), GFP_KERNEL);
 631         if (!fid)
 632                 return ERR_PTR(-ENOMEM);
 633
 634         ret = p9_idpool_get(clnt->fidpool);
 635         if (ret < 0) {
 636                 ret = -ENOSPC;
 637                 goto error;
 638         }
 639         fid->fid = ret;
 640
 641         memset(&fid->qid, 0, sizeof(struct p9_qid));
 642         fid->mode = -1;
 643         fid->uid = current_fsuid();
 644         fid->clnt = clnt;
 645         fid->rdir = NULL;
 646         spin_lock_irqsave(&clnt->lock, flags);
 647         list_add(&fid->flist, &clnt->fidlist);
 648         spin_unlock_irqrestore(&clnt->lock, flags);
 649
 650         return fid;
 651
 652 error:
 653         kfree(fid);
 654         return ERR_PTR(ret);
 655 }
 656
 657 static void p9_fid_destroy(struct p9_fid *fid)
 658 {
 659         struct p9_client *clnt;
 660         unsigned long flags;
 661
 662         P9_DPRINTK(P9_DEBUG_FID, "fid %d\n", fid->fid);
 663         clnt = fid->clnt;
 664         p9_idpool_put(fid->fid, clnt->fidpool);
 665         spin_lock_irqsave(&clnt->lock, flags);
 666         list_del(&fid->flist);
 667         spin_unlock_irqrestore(&clnt->lock, flags);
 668         kfree(fid->rdir);
 669         kfree(fid);
 670 }
 671
 672 int p9_client_version(struct p9_client *c)
 673 {
 674         int err = 0;
 675         struct p9_req_t *req;
 676         char *version;
 677         int msize;
 678
 679         P9_DPRINTK(P9_DEBUG_9P, ">>> TVERSION msize %d protocol %d\n",
 680                                                 c->msize, c->proto_version);
 681
 682         switch (c->proto_version) {
 683         case p9_proto_2000L:
 684                 req = p9_client_rpc(c, P9_TVERSION, "ds",
 685                                         c->msize, "9P2000.L");
 686                 break;
 687         case p9_proto_2000u:
 688                 req = p9_client_rpc(c, P9_TVERSION, "ds",
 689                                         c->msize, "9P2000.u");
 690                 break;
 691         case p9_proto_legacy:
 692                 req = p9_client_rpc(c, P9_TVERSION, "ds",
 693                                         c->msize, "9P2000");
 694                 break;
 695         default:
 696                 return -EINVAL;
 697                 break;
 698         }
 699
 700         if (IS_ERR(req))
 701                 return PTR_ERR(req);
 702
 703         err = p9pdu_readf(req->rc, c->proto_version, "ds", &msize, &version);
 704         if (err) {
 705                 P9_DPRINTK(P9_DEBUG_9P, "version error %d\n", err);
 706                 p9pdu_dump(1, req->rc);
 707                 goto error;
 708         }
 709
 710         P9_DPRINTK(P9_DEBUG_9P, "<<< RVERSION msize %d %s\n", msize, version);
 711         if (!strncmp(version, "9P2000.L", 8))
 712                 c->proto_version = p9_proto_2000L;
 713         else if (!strncmp(version, "9P2000.u", 8))
 714                 c->proto_version = p9_proto_2000u;
 715         else if (!strncmp(version, "9P2000", 6))
 716                 c->proto_version = p9_proto_legacy;
 717         else {
 718                 err = -EREMOTEIO;
 719                 goto error;
 720         }
 721
 722         if (msize < c->msize)
 723                 c->msize = msize;
 724
 725 error:
 726         kfree(version);
 727         p9_free_req(c, req);
 728
 729         return err;
 730 }
 731 EXPORT_SYMBOL(p9_client_version);
 732
 733 struct p9_client *p9_client_create(const char *dev_name, char *options)
 734 {
 735         int err;
 736         struct p9_client *clnt;
 737
 738         err = 0;
 739         clnt = kmalloc(sizeof(struct p9_client), GFP_KERNEL);
 740         if (!clnt)
 741                 return ERR_PTR(-ENOMEM);
 742
 743         clnt->trans_mod = NULL;
 744         clnt->trans = NULL;
 745         spin_lock_init(&clnt->lock);
 746         INIT_LIST_HEAD(&clnt->fidlist);
 747
 748         p9_tag_init(clnt);
 749
 750         err = parse_opts(options, clnt);
 751         if (err < 0)
 752                 goto free_client;
 753
 754         if (!clnt->trans_mod)
 755                 clnt->trans_mod = v9fs_get_default_trans();
 756
 757         if (clnt->trans_mod == NULL) {
 758                 err = -EPROTONOSUPPORT;
 759                 P9_DPRINTK(P9_DEBUG_ERROR,
 760                                 "No transport defined or default transport\n");
 761                 goto free_client;
 762         }
 763
 764         clnt->fidpool = p9_idpool_create();
 765         if (IS_ERR(clnt->fidpool)) {
 766                 err = PTR_ERR(clnt->fidpool);
 767                 clnt->fidpool = NULL;
 768                 goto put_trans;
 769         }
 770
 771         P9_DPRINTK(P9_DEBUG_MUX, "clnt %p trans %p msize %d protocol %d\n",
 772                 clnt, clnt->trans_mod, clnt->msize, clnt->proto_version);
 773
 774         err = clnt->trans_mod->create(clnt, dev_name, options);
 775         if (err)
 776                 goto destroy_fidpool;
 777
 778         if ((clnt->msize+P9_IOHDRSZ) > clnt->trans_mod->maxsize)
 779                 clnt->msize = clnt->trans_mod->maxsize-P9_IOHDRSZ;
 780
 781         err = p9_client_version(clnt);
 782         if (err)
 783                 goto close_trans;
 784
 785         return clnt;
 786
 787 close_trans:
 788         clnt->trans_mod->close(clnt);
 789 destroy_fidpool:
 790         p9_idpool_destroy(clnt->fidpool);
 791 put_trans:
 792         v9fs_put_trans(clnt->trans_mod);
 793 free_client:
 794         kfree(clnt);
 795         return ERR_PTR(err);
 796 }
 797 EXPORT_SYMBOL(p9_client_create);
 798
 799 void p9_client_destroy(struct p9_client *clnt)
 800 {
 801         struct p9_fid *fid, *fidptr;
 802
 803         P9_DPRINTK(P9_DEBUG_MUX, "clnt %p\n", clnt);
 804
 805         if (clnt->trans_mod)
 806                 clnt->trans_mod->close(clnt);
 807
 808         v9fs_put_trans(clnt->trans_mod);
 809
 810         list_for_each_entry_safe(fid, fidptr, &clnt->fidlist, flist) {
 811                 printk(KERN_INFO "Found fid %d not clunked\n", fid->fid);
 812                 p9_fid_destroy(fid);
 813         }
 814
 815         if (clnt->fidpool)
 816                 p9_idpool_destroy(clnt->fidpool);
 817
 818         p9_tag_cleanup(clnt);
 819
 820         kfree(clnt);
 821 }
 822 EXPORT_SYMBOL(p9_client_destroy);
 823
 824 void p9_client_disconnect(struct p9_client *clnt)
 825 {
 826         P9_DPRINTK(P9_DEBUG_9P, "clnt %p\n", clnt);
 827         clnt->status = Disconnected;
 828 }
 829 EXPORT_SYMBOL(p9_client_disconnect);
 830
 831 void p9_client_begin_disconnect(struct p9_client *clnt)
 832 {
 833         P9_DPRINTK(P9_DEBUG_9P, "clnt %p\n", clnt);
 834         clnt->status = BeginDisconnect;
 835 }
 836 EXPORT_SYMBOL(p9_client_begin_disconnect);
 837
 838 struct p9_fid *p9_client_attach(struct p9_client *clnt, struct p9_fid *afid,
 839         char *uname, u32 n_uname, char *aname)
 840 {
 841         int err;
 842         struct p9_req_t *req;
 843         struct p9_fid *fid;
 844         struct p9_qid qid;
 845
 846         P9_DPRINTK(P9_DEBUG_9P, ">>> TATTACH afid %d uname %s aname %s\n",
 847                                         afid ? afid->fid : -1, uname, aname);
 848         err = 0;
 849
 850         fid = p9_fid_create(clnt);
 851         if (IS_ERR(fid)) {
 852                 err = PTR_ERR(fid);
 853                 fid = NULL;
 854                 goto error;
 855         }
 856
 857         req = p9_client_rpc(clnt, P9_TATTACH, "ddss?d", fid->fid,
 858                         afid ? afid->fid : P9_NOFID, uname, aname, n_uname);
 859         if (IS_ERR(req)) {
 860                 err = PTR_ERR(req);
 861                 goto error;
 862         }
 863
 864         err = p9pdu_readf(req->rc, clnt->proto_version, "Q", &qid);
 865         if (err) {
 866                 p9pdu_dump(1, req->rc);
 867                 p9_free_req(clnt, req);
 868                 goto error;
 869         }
 870
 871         P9_DPRINTK(P9_DEBUG_9P, "<<< RATTACH qid %x.%llx.%x\n",
 872                                         qid.type,
 873                                         (unsigned long long)qid.path,
 874                                         qid.version);
 875
 876         memmove(&fid->qid, &qid, sizeof(struct p9_qid));
 877
 878         p9_free_req(clnt, req);
 879         return fid;
 880
 881 error:
 882         if (fid)
 883                 p9_fid_destroy(fid);
 884         return ERR_PTR(err);
 885 }
 886 EXPORT_SYMBOL(p9_client_attach);
 887
 888 struct p9_fid *
 889 p9_client_auth(struct p9_client *clnt, char *uname, u32 n_uname, char *aname)
 890 {
 891         int err;
 892         struct p9_req_t *req;
 893         struct p9_qid qid;
 894         struct p9_fid *afid;
 895
 896         P9_DPRINTK(P9_DEBUG_9P, ">>> TAUTH uname %s aname %s\n", uname, aname);
 897         err = 0;
 898
 899         afid = p9_fid_create(clnt);
 900         if (IS_ERR(afid)) {
 901                 err = PTR_ERR(afid);
 902                 afid = NULL;
 903                 goto error;
 904         }
 905
 906         req = p9_client_rpc(clnt, P9_TAUTH, "dss?d",
 907                         afid ? afid->fid : P9_NOFID, uname, aname, n_uname);
 908         if (IS_ERR(req)) {
 909                 err = PTR_ERR(req);
 910                 goto error;
 911         }
 912
 913         err = p9pdu_readf(req->rc, clnt->proto_version, "Q", &qid);
 914         if (err) {
 915                 p9pdu_dump(1, req->rc);
 916                 p9_free_req(clnt, req);
 917                 goto error;
 918         }
 919
 920         P9_DPRINTK(P9_DEBUG_9P, "<<< RAUTH qid %x.%llx.%x\n",
 921                                         qid.type,
 922                                         (unsigned long long)qid.path,
 923                                         qid.version);
 924
 925         memmove(&afid->qid, &qid, sizeof(struct p9_qid));
 926         p9_free_req(clnt, req);
 927         return afid;
 928
 929 error:
 930         if (afid)
 931                 p9_fid_destroy(afid);
 932         return ERR_PTR(err);
 933 }
 934 EXPORT_SYMBOL(p9_client_auth);
 935
 936 struct p9_fid *p9_client_walk(struct p9_fid *oldfid, int nwname, char **wnames,
 937         int clone)
 938 {
 939         int err;
 940         struct p9_client *clnt;
 941         struct p9_fid *fid;
 942         struct p9_qid *wqids;
 943         struct p9_req_t *req;
 944         int16_t nwqids, count;
 945
 946         err = 0;
 947         clnt = oldfid->clnt;
 948         if (clone) {
 949                 fid = p9_fid_create(clnt);
 950                 if (IS_ERR(fid)) {
 951                         err = PTR_ERR(fid);
 952                         fid = NULL;
 953                         goto error;
 954                 }
 955
 956                 fid->uid = oldfid->uid;
 957         } else
 958                 fid = oldfid;
 959
 960
 961         P9_DPRINTK(P9_DEBUG_9P, ">>> TWALK fids %d,%d nwname %d wname[0] %s\n",
 962                 oldfid->fid, fid->fid, nwname, wnames ? wnames[0] : NULL);
 963
 964         req = p9_client_rpc(clnt, P9_TWALK, "ddT", oldfid->fid, fid->fid,
 965                                                                 nwname, wnames);
 966         if (IS_ERR(req)) {
 967                 err = PTR_ERR(req);
 968                 goto error;
 969         }
 970
 971         err = p9pdu_readf(req->rc, clnt->proto_version, "R", &nwqids, &wqids);
 972         if (err) {
 973                 p9pdu_dump(1, req->rc);
 974                 p9_free_req(clnt, req);
 975                 goto clunk_fid;
 976         }
 977         p9_free_req(clnt, req);
 978
 979         P9_DPRINTK(P9_DEBUG_9P, "<<< RWALK nwqid %d:\n", nwqids);
 980
 981         if (nwqids != nwname) {
 982                 err = -ENOENT;
 983                 goto clunk_fid;
 984         }
 985
 986         for (count = 0; count < nwqids; count++)
 987                 P9_DPRINTK(P9_DEBUG_9P, "<<<     [%d] %x.%llx.%x\n",
 988                         count, wqids[count].type,
 989                         (unsigned long long)wqids[count].path,
 990                         wqids[count].version);
 991
 992         if (nwname)
 993                 memmove(&fid->qid, &wqids[nwqids - 1], sizeof(struct p9_qid));
 994         else
 995                 fid->qid = oldfid->qid;
 996
 997         return fid;
 998
 999 clunk_fid:
1000         p9_client_clunk(fid);
1001         fid = NULL;
1002
1003 error:
1004         if (fid && (fid != oldfid))
1005                 p9_fid_destroy(fid);
1006
1007         return ERR_PTR(err);
1008 }
1009 EXPORT_SYMBOL(p9_client_walk);
1010
1011 int p9_client_open(struct p9_fid *fid, int mode)
1012 {
1013         int err;
1014         struct p9_client *clnt;
1015         struct p9_req_t *req;
1016         struct p9_qid qid;
1017         int iounit;
1018
1019         P9_DPRINTK(P9_DEBUG_9P, ">>> TOPEN fid %d mode %d\n", fid->fid, mode);
1020         err = 0;
1021         clnt = fid->clnt;
1022
1023         if (fid->mode != -1)
1024                 return -EINVAL;
1025
1026         req = p9_client_rpc(clnt, P9_TOPEN, "db", fid->fid, mode);
1027         if (IS_ERR(req)) {
1028                 err = PTR_ERR(req);
1029                 goto error;
1030         }
1031
1032         err = p9pdu_readf(req->rc, clnt->proto_version, "Qd", &qid, &iounit);
1033         if (err) {
1034                 p9pdu_dump(1, req->rc);
1035                 goto free_and_error;
1036         }
1037
1038         P9_DPRINTK(P9_DEBUG_9P, "<<< ROPEN qid %x.%llx.%x iounit %x\n",
1039                                 qid.type,
1040                                 (unsigned long long)qid.path,
1041                                 qid.version, iounit);
1042
1043         fid->mode = mode;
1044         fid->iounit = iounit;
1045
1046 free_and_error:
1047         p9_free_req(clnt, req);
1048 error:
1049         return err;
1050 }
1051 EXPORT_SYMBOL(p9_client_open);
1052
1053 int p9_client_fcreate(struct p9_fid *fid, char *name, u32 perm, int mode,
1054                      char *extension)
1055 {
1056         int err;
1057         struct p9_client *clnt;
1058         struct p9_req_t *req;
1059         struct p9_qid qid;
1060         int iounit;
1061
1062         P9_DPRINTK(P9_DEBUG_9P, ">>> TCREATE fid %d name %s perm %d mode %d\n",
1063                                                 fid->fid, name, perm, mode);
1064         err = 0;
1065         clnt = fid->clnt;
1066
1067         if (fid->mode != -1)
1068                 return -EINVAL;
1069
1070         req = p9_client_rpc(clnt, P9_TCREATE, "dsdb?s", fid->fid, name, perm,
1071                                 mode, extension);
1072         if (IS_ERR(req)) {
1073                 err = PTR_ERR(req);
1074                 goto error;
1075         }
1076
1077         err = p9pdu_readf(req->rc, clnt->proto_version, "Qd", &qid, &iounit);
1078         if (err) {
1079                 p9pdu_dump(1, req->rc);
1080                 goto free_and_error;
1081         }
1082
1083         P9_DPRINTK(P9_DEBUG_9P, "<<< RCREATE qid %x.%llx.%x iounit %x\n",
1084                                 qid.type,
1085                                 (unsigned long long)qid.path,
1086                                 qid.version, iounit);
1087
1088         fid->mode = mode;
1089         fid->iounit = iounit;
1090
1091 free_and_error:
1092         p9_free_req(clnt, req);
1093 error:
1094         return err;
1095 }
1096 EXPORT_SYMBOL(p9_client_fcreate);
1097
1098 int p9_client_symlink(struct p9_fid *dfid, char *name, char *symtgt, gid_t gid,
1099                 struct p9_qid *qid)
1100 {
1101         int err = 0;
1102         struct p9_client *clnt;
1103         struct p9_req_t *req;
1104
1105         P9_DPRINTK(P9_DEBUG_9P, ">>> TSYMLINK dfid %d name %s  symtgt %s\n",
1106                         dfid->fid, name, symtgt);
1107         clnt = dfid->clnt;
1108
1109         req = p9_client_rpc(clnt, P9_TSYMLINK, "dssd", dfid->fid, name, symtgt,
1110                         gid);
1111         if (IS_ERR(req)) {
1112                 err = PTR_ERR(req);
1113                 goto error;
1114         }
1115
1116         err = p9pdu_readf(req->rc, clnt->proto_version, "Q", qid);
1117         if (err) {
1118                 p9pdu_dump(1, req->rc);
1119                 goto free_and_error;
1120         }
1121
1122         P9_DPRINTK(P9_DEBUG_9P, "<<< RSYMLINK qid %x.%llx.%x\n",
1123                         qid->type, (unsigned long long)qid->path, qid->version);
1124
1125 free_and_error:
1126         p9_free_req(clnt, req);
1127 error:
1128         return err;
1129 }
1130 EXPORT_SYMBOL(p9_client_symlink);
1131
1132 int p9_client_link(struct p9_fid *dfid, struct p9_fid *oldfid, char *newname)
1133 {
1134         struct p9_client *clnt;
1135         struct p9_req_t *req;
1136
1137         P9_DPRINTK(P9_DEBUG_9P, ">>> TLINK dfid %d oldfid %d newname %s\n",
1138                         dfid->fid, oldfid->fid, newname);
1139         clnt = dfid->clnt;
1140         req = p9_client_rpc(clnt, P9_TLINK, "dds", dfid->fid, oldfid->fid,
1141                         newname);
1142         if (IS_ERR(req))
1143                 return PTR_ERR(req);
1144
1145         P9_DPRINTK(P9_DEBUG_9P, "<<< RLINK\n");
1146         p9_free_req(clnt, req);
1147         return 0;
1148 }
1149 EXPORT_SYMBOL(p9_client_link);
1150
1151 int p9_client_clunk(struct p9_fid *fid)
1152 {
1153         int err;
1154         struct p9_client *clnt;
1155         struct p9_req_t *req;
1156
1157         P9_DPRINTK(P9_DEBUG_9P, ">>> TCLUNK fid %d\n", fid->fid);
1158         err = 0;
1159         clnt = fid->clnt;
1160
1161         req = p9_client_rpc(clnt, P9_TCLUNK, "d", fid->fid);
1162         if (IS_ERR(req)) {
1163                 err = PTR_ERR(req);
1164                 goto error;
1165         }
1166
1167         P9_DPRINTK(P9_DEBUG_9P, "<<< RCLUNK fid %d\n", fid->fid);
1168
1169         p9_free_req(clnt, req);
1170         p9_fid_destroy(fid);
1171
1172 error:
1173         return err;
1174 }
1175 EXPORT_SYMBOL(p9_client_clunk);
1176
1177 int p9_client_remove(struct p9_fid *fid)
1178 {
1179         int err;
1180         struct p9_client *clnt;
1181         struct p9_req_t *req;
1182
1183         P9_DPRINTK(P9_DEBUG_9P, ">>> TREMOVE fid %d\n", fid->fid);
1184         err = 0;
1185         clnt = fid->clnt;
1186
1187         req = p9_client_rpc(clnt, P9_TREMOVE, "d", fid->fid);
1188         if (IS_ERR(req)) {
1189                 err = PTR_ERR(req);
1190                 goto error;
1191         }
1192
1193         P9_DPRINTK(P9_DEBUG_9P, "<<< RREMOVE fid %d\n", fid->fid);
1194
1195         p9_free_req(clnt, req);
1196         p9_fid_destroy(fid);
1197
1198 error:
1199         return err;
1200 }
1201 EXPORT_SYMBOL(p9_client_remove);
1202
1203 int
1204 p9_client_read(struct p9_fid *fid, char *data, char __user *udata, u64 offset,
1205                                                                 u32 count)
1206 {
1207         int err, rsize, total;
1208         struct p9_client *clnt;
1209         struct p9_req_t *req;
1210         char *dataptr;
1211
1212         P9_DPRINTK(P9_DEBUG_9P, ">>> TREAD fid %d offset %llu %d\n", fid->fid,
1213                                         (long long unsigned) offset, count);
1214         err = 0;
1215         clnt = fid->clnt;
1216         total = 0;
1217
1218         rsize = fid->iounit;
1219         if (!rsize || rsize > clnt->msize-P9_IOHDRSZ)
1220                 rsize = clnt->msize - P9_IOHDRSZ;
1221
1222         if (count < rsize)
1223                 rsize = count;
1224
1225         req = p9_client_rpc(clnt, P9_TREAD, "dqd", fid->fid, offset, rsize);
1226         if (IS_ERR(req)) {
1227                 err = PTR_ERR(req);
1228                 goto error;
1229         }
1230
1231         err = p9pdu_readf(req->rc, clnt->proto_version, "D", &count, &dataptr);
1232         if (err) {
1233                 p9pdu_dump(1, req->rc);
1234                 goto free_and_error;
1235         }
1236
1237         P9_DPRINTK(P9_DEBUG_9P, "<<< RREAD count %d\n", count);
1238
1239         if (data) {
1240                 memmove(data, dataptr, count);
1241         }
1242
1243         if (udata) {
1244                 err = copy_to_user(udata, dataptr, count);
1245                 if (err) {
1246                         err = -EFAULT;
1247                         goto free_and_error;
1248                 }
1249         }
1250
1251         p9_free_req(clnt, req);
1252         return count;
1253
1254 free_and_error:
1255         p9_free_req(clnt, req);
1256 error:
1257         return err;
1258 }
1259 EXPORT_SYMBOL(p9_client_read);
1260
1261 int
1262 p9_client_write(struct p9_fid *fid, char *data, const char __user *udata,
1263                                                         u64 offset, u32 count)
1264 {
1265         int err, rsize, total;
1266         struct p9_client *clnt;
1267         struct p9_req_t *req;
1268
1269         P9_DPRINTK(P9_DEBUG_9P, ">>> TWRITE fid %d offset %llu count %d\n",
1270                                 fid->fid, (long long unsigned) offset, count);
1271         err = 0;
1272         clnt = fid->clnt;
1273         total = 0;
1274
1275         rsize = fid->iounit;
1276         if (!rsize || rsize > clnt->msize-P9_IOHDRSZ)
1277                 rsize = clnt->msize - P9_IOHDRSZ;
1278
1279         if (count < rsize)
1280                 rsize = count;
1281         if (data)
1282                 req = p9_client_rpc(clnt, P9_TWRITE, "dqD", fid->fid, offset,
1283                                                                 rsize, data);
1284         else
1285                 req = p9_client_rpc(clnt, P9_TWRITE, "dqU", fid->fid, offset,
1286                                                                 rsize, udata);
1287         if (IS_ERR(req)) {
1288                 err = PTR_ERR(req);
1289                 goto error;
1290         }
1291
1292         err = p9pdu_readf(req->rc, clnt->proto_version, "d", &count);
1293         if (err) {
1294                 p9pdu_dump(1, req->rc);
1295                 goto free_and_error;
1296         }
1297
1298         P9_DPRINTK(P9_DEBUG_9P, "<<< RWRITE count %d\n", count);
1299
1300         p9_free_req(clnt, req);
1301         return count;
1302
1303 free_and_error:
1304         p9_free_req(clnt, req);
1305 error:
1306         return err;
1307 }
1308 EXPORT_SYMBOL(p9_client_write);
1309
1310 struct p9_wstat *p9_client_stat(struct p9_fid *fid)
1311 {
1312         int err;
1313         struct p9_client *clnt;
1314         struct p9_wstat *ret = kmalloc(sizeof(struct p9_wstat), GFP_KERNEL);
1315         struct p9_req_t *req;
1316         u16 ignored;
1317
1318         P9_DPRINTK(P9_DEBUG_9P, ">>> TSTAT fid %d\n", fid->fid);
1319
1320         if (!ret)
1321                 return ERR_PTR(-ENOMEM);
1322
1323         err = 0;
1324         clnt = fid->clnt;
1325
1326         req = p9_client_rpc(clnt, P9_TSTAT, "d", fid->fid);
1327         if (IS_ERR(req)) {
1328                 err = PTR_ERR(req);
1329                 goto error;
1330         }
1331
1332         err = p9pdu_readf(req->rc, clnt->proto_version, "wS", &ignored, ret);
1333         if (err) {
1334                 p9pdu_dump(1, req->rc);
1335                 p9_free_req(clnt, req);
1336                 goto error;
1337         }
1338
1339         P9_DPRINTK(P9_DEBUG_9P,
1340                 "<<< RSTAT sz=%x type=%x dev=%x qid=%x.%llx.%x\n"
1341                 "<<<    mode=%8.8x atime=%8.8x mtime=%8.8x length=%llx\n"
1342                 "<<<    name=%s uid=%s gid=%s muid=%s extension=(%s)\n"
1343                 "<<<    uid=%d gid=%d n_muid=%d\n",
1344                 ret->size, ret->type, ret->dev, ret->qid.type,
1345                 (unsigned long long)ret->qid.path, ret->qid.version, ret->mode,
1346                 ret->atime, ret->mtime, (unsigned long long)ret->length,
1347                 ret->name, ret->uid, ret->gid, ret->muid, ret->extension,
1348                 ret->n_uid, ret->n_gid, ret->n_muid);
1349
1350         p9_free_req(clnt, req);
1351         return ret;
1352
1353 error:
1354         kfree(ret);
1355         return ERR_PTR(err);
1356 }
1357 EXPORT_SYMBOL(p9_client_stat);
1358
1359 struct p9_stat_dotl *p9_client_getattr_dotl(struct p9_fid *fid,
1360                                                         u64 request_mask)
1361 {
1362         int err;
1363         struct p9_client *clnt;
1364         struct p9_stat_dotl *ret = kmalloc(sizeof(struct p9_stat_dotl),
1365                                                                 GFP_KERNEL);
1366         struct p9_req_t *req;
1367
1368         P9_DPRINTK(P9_DEBUG_9P, ">>> TGETATTR fid %d, request_mask %lld\n",
1369                                                         fid->fid, request_mask);
1370
1371         if (!ret)
1372                 return ERR_PTR(-ENOMEM);
1373
1374         err = 0;
1375         clnt = fid->clnt;
1376
1377         req = p9_client_rpc(clnt, P9_TGETATTR, "dq", fid->fid, request_mask);
1378         if (IS_ERR(req)) {
1379                 err = PTR_ERR(req);
1380                 goto error;
1381         }
1382
1383         err = p9pdu_readf(req->rc, clnt->proto_version, "A", ret);
1384         if (err) {
1385                 p9pdu_dump(1, req->rc);
1386                 p9_free_req(clnt, req);
1387                 goto error;
1388         }
1389
1390         P9_DPRINTK(P9_DEBUG_9P,
1391                 "<<< RGETATTR st_result_mask=%lld\n"
1392                 "<<< qid=%x.%llx.%x\n"
1393                 "<<< st_mode=%8.8x st_nlink=%llu\n"
1394                 "<<< st_uid=%d st_gid=%d\n"
1395                 "<<< st_rdev=%llx st_size=%llx st_blksize=%llu st_blocks=%llu\n"
1396                 "<<< st_atime_sec=%lld st_atime_nsec=%lld\n"
1397                 "<<< st_mtime_sec=%lld st_mtime_nsec=%lld\n"
1398                 "<<< st_ctime_sec=%lld st_ctime_nsec=%lld\n"
1399                 "<<< st_btime_sec=%lld st_btime_nsec=%lld\n"
1400                 "<<< st_gen=%lld st_data_version=%lld",
1401                 ret->st_result_mask, ret->qid.type, ret->qid.path,
1402                 ret->qid.version, ret->st_mode, ret->st_nlink, ret->st_uid,
1403                 ret->st_gid, ret->st_rdev, ret->st_size, ret->st_blksize,
1404                 ret->st_blocks, ret->st_atime_sec, ret->st_atime_nsec,
1405                 ret->st_mtime_sec, ret->st_mtime_nsec, ret->st_ctime_sec,
1406                 ret->st_ctime_nsec, ret->st_btime_sec, ret->st_btime_nsec,
1407                 ret->st_gen, ret->st_data_version);
1408
1409         p9_free_req(clnt, req);
1410         return ret;
1411
1412 error:
1413         kfree(ret);
1414         return ERR_PTR(err);
1415 }
1416 EXPORT_SYMBOL(p9_client_getattr_dotl);
1417
1418 static int p9_client_statsize(struct p9_wstat *wst, int proto_version)
1419 {
1420         int ret;
1421
1422         /* NOTE: size shouldn't include its own length */
1423         /* size[2] type[2] dev[4] qid[13] */
1424         /* mode[4] atime[4] mtime[4] length[8]*/
1425         /* name[s] uid[s] gid[s] muid[s] */
1426         ret = 2+4+13+4+4+4+8+2+2+2+2;
1427
1428         if (wst->name)
1429                 ret += strlen(wst->name);
1430         if (wst->uid)
1431                 ret += strlen(wst->uid);
1432         if (wst->gid)
1433                 ret += strlen(wst->gid);
1434         if (wst->muid)
1435                 ret += strlen(wst->muid);
1436
1437         if ((proto_version == p9_proto_2000u) ||
1438                 (proto_version == p9_proto_2000L)) {
1439                 ret += 2+4+4+4; /* extension[s] n_uid[4] n_gid[4] n_muid[4] */
1440                 if (wst->extension)
1441                         ret += strlen(wst->extension);
1442         }
1443
1444         return ret;
1445 }
1446
1447 int p9_client_wstat(struct p9_fid *fid, struct p9_wstat *wst)
1448 {
1449         int err;
1450         struct p9_req_t *req;
1451         struct p9_client *clnt;
1452
1453         err = 0;
1454         clnt = fid->clnt;
1455         wst->size = p9_client_statsize(wst, clnt->proto_version);
1456         P9_DPRINTK(P9_DEBUG_9P, ">>> TWSTAT fid %d\n", fid->fid);
1457         P9_DPRINTK(P9_DEBUG_9P,
1458                 "     sz=%x type=%x dev=%x qid=%x.%llx.%x\n"
1459                 "     mode=%8.8x atime=%8.8x mtime=%8.8x length=%llx\n"
1460                 "     name=%s uid=%s gid=%s muid=%s extension=(%s)\n"
1461                 "     uid=%d gid=%d n_muid=%d\n",
1462                 wst->size, wst->type, wst->dev, wst->qid.type,
1463                 (unsigned long long)wst->qid.path, wst->qid.version, wst->mode,
1464                 wst->atime, wst->mtime, (unsigned long long)wst->length,
1465                 wst->name, wst->uid, wst->gid, wst->muid, wst->extension,
1466                 wst->n_uid, wst->n_gid, wst->n_muid);
1467
1468         req = p9_client_rpc(clnt, P9_TWSTAT, "dwS", fid->fid, wst->size+2, wst);
1469         if (IS_ERR(req)) {
1470                 err = PTR_ERR(req);
1471                 goto error;
1472         }
1473
1474         P9_DPRINTK(P9_DEBUG_9P, "<<< RWSTAT fid %d\n", fid->fid);
1475
1476         p9_free_req(clnt, req);
1477 error:
1478         return err;
1479 }
1480 EXPORT_SYMBOL(p9_client_wstat);
1481
1482 int p9_client_setattr(struct p9_fid *fid, struct p9_iattr_dotl *p9attr)
1483 {
1484         int err;
1485         struct p9_req_t *req;
1486         struct p9_client *clnt;
1487
1488         err = 0;
1489         clnt = fid->clnt;
1490         P9_DPRINTK(P9_DEBUG_9P, ">>> TSETATTR fid %d\n", fid->fid);
1491         P9_DPRINTK(P9_DEBUG_9P,
1492                 "    valid=%x mode=%x uid=%d gid=%d size=%lld\n"
1493                 "    atime_sec=%lld atime_nsec=%lld\n"
1494                 "    mtime_sec=%lld mtime_nsec=%lld\n",
1495                 p9attr->valid, p9attr->mode, p9attr->uid, p9attr->gid,
1496                 p9attr->size, p9attr->atime_sec, p9attr->atime_nsec,
1497                 p9attr->mtime_sec, p9attr->mtime_nsec);
1498
1499         req = p9_client_rpc(clnt, P9_TSETATTR, "dI", fid->fid, p9attr);
1500
1501         if (IS_ERR(req)) {
1502                 err = PTR_ERR(req);
1503                 goto error;
1504         }
1505         P9_DPRINTK(P9_DEBUG_9P, "<<< RSETATTR fid %d\n", fid->fid);
1506         p9_free_req(clnt, req);
1507 error:
1508         return err;
1509 }
1510 EXPORT_SYMBOL(p9_client_setattr);
1511
1512 int p9_client_statfs(struct p9_fid *fid, struct p9_rstatfs *sb)
1513 {
1514         int err;
1515         struct p9_req_t *req;
1516         struct p9_client *clnt;
1517
1518         err = 0;
1519         clnt = fid->clnt;
1520
1521         P9_DPRINTK(P9_DEBUG_9P, ">>> TSTATFS fid %d\n", fid->fid);
1522
1523         req = p9_client_rpc(clnt, P9_TSTATFS, "d", fid->fid);
1524         if (IS_ERR(req)) {
1525                 err = PTR_ERR(req);
1526                 goto error;
1527         }
1528
1529         err = p9pdu_readf(req->rc, clnt->proto_version, "ddqqqqqqd", &sb->type,
1530                 &sb->bsize, &sb->blocks, &sb->bfree, &sb->bavail,
1531                 &sb->files, &sb->ffree, &sb->fsid, &sb->namelen);
1532         if (err) {
1533                 p9pdu_dump(1, req->rc);
1534                 p9_free_req(clnt, req);
1535                 goto error;
1536         }
1537
1538         P9_DPRINTK(P9_DEBUG_9P, "<<< RSTATFS fid %d type 0x%lx bsize %ld "
1539                 "blocks %llu bfree %llu bavail %llu files %llu ffree %llu "
1540                 "fsid %llu namelen %ld\n",
1541                 fid->fid, (long unsigned int)sb->type, (long int)sb->bsize,
1542                 sb->blocks, sb->bfree, sb->bavail, sb->files,  sb->ffree,
1543                 sb->fsid, (long int)sb->namelen);
1544
1545         p9_free_req(clnt, req);
1546 error:
1547         return err;
1548 }
1549 EXPORT_SYMBOL(p9_client_statfs);
1550
1551 int p9_client_rename(struct p9_fid *fid, struct p9_fid *newdirfid, char *name)
1552 {
1553         int err;
1554         struct p9_req_t *req;
1555         struct p9_client *clnt;
1556
1557         err = 0;
1558         clnt = fid->clnt;
1559
1560         P9_DPRINTK(P9_DEBUG_9P, ">>> TRENAME fid %d newdirfid %d name %s\n",
1561                         fid->fid, newdirfid->fid, name);
1562
1563         req = p9_client_rpc(clnt, P9_TRENAME, "dds", fid->fid,
1564                         newdirfid->fid, name);
1565         if (IS_ERR(req)) {
1566                 err = PTR_ERR(req);
1567                 goto error;
1568         }
1569
1570         P9_DPRINTK(P9_DEBUG_9P, "<<< RRENAME fid %d\n", fid->fid);
1571
1572         p9_free_req(clnt, req);
1573 error:
1574         return err;
1575 }
1576 EXPORT_SYMBOL(p9_client_rename);
1577
1578 int p9_client_readdir(struct p9_fid *fid, char *data, u32 count, u64 offset)
1579 {
1580         int err, rsize, total;
1581         struct p9_client *clnt;
1582         struct p9_req_t *req;
1583         char *dataptr;
1584
1585         P9_DPRINTK(P9_DEBUG_9P, ">>> TREADDIR fid %d offset %llu count %d\n",
1586                                 fid->fid, (long long unsigned) offset, count);
1587
1588         err = 0;
1589         clnt = fid->clnt;
1590         total = 0;
1591
1592         rsize = fid->iounit;
1593         if (!rsize || rsize > clnt->msize-P9_READDIRHDRSZ)
1594                 rsize = clnt->msize - P9_READDIRHDRSZ;
1595
1596         if (count < rsize)
1597                 rsize = count;
1598
1599         req = p9_client_rpc(clnt, P9_TREADDIR, "dqd", fid->fid, offset, rsize);
1600         if (IS_ERR(req)) {
1601                 err = PTR_ERR(req);
1602                 goto error;
1603         }
1604
1605         err = p9pdu_readf(req->rc, clnt->proto_version, "D", &count, &dataptr);
1606         if (err) {
1607                 p9pdu_dump(1, req->rc);
1608                 goto free_and_error;
1609         }
1610
1611         P9_DPRINTK(P9_DEBUG_9P, "<<< RREADDIR count %d\n", count);
1612
1613         if (data)
1614                 memmove(data, dataptr, count);
1615
1616         p9_free_req(clnt, req);
1617         return count;
1618
1619 free_and_error:
1620         p9_free_req(clnt, req);
1621 error:
1622         return err;
1623 }
1624 EXPORT_SYMBOL(p9_client_readdir);