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         clnt = fid->clnt;
1020         P9_DPRINTK(P9_DEBUG_9P, ">>> %s fid %d mode %d\n",
1021                 p9_is_proto_dotl(clnt) ? "TLOPEN" : "TOPEN", fid->fid, mode);
1022         err = 0;
1023
1024         if (fid->mode != -1)
1025                 return -EINVAL;
1026
1027         if (p9_is_proto_dotl(clnt))
1028                 req = p9_client_rpc(clnt, P9_TLOPEN, "dd", fid->fid, mode);
1029         else
1030                 req = p9_client_rpc(clnt, P9_TOPEN, "db", fid->fid, mode);
1031         if (IS_ERR(req)) {
1032                 err = PTR_ERR(req);
1033                 goto error;
1034         }
1035
1036         err = p9pdu_readf(req->rc, clnt->proto_version, "Qd", &qid, &iounit);
1037         if (err) {
1038                 p9pdu_dump(1, req->rc);
1039                 goto free_and_error;
1040         }
1041
1042         P9_DPRINTK(P9_DEBUG_9P, "<<< %s qid %x.%llx.%x iounit %x\n",
1043                 p9_is_proto_dotl(clnt) ? "RLOPEN" : "ROPEN",  qid.type,
1044                 (unsigned long long)qid.path, qid.version, iounit);
1045
1046         fid->mode = mode;
1047         fid->iounit = iounit;
1048
1049 free_and_error:
1050         p9_free_req(clnt, req);
1051 error:
1052         return err;
1053 }
1054 EXPORT_SYMBOL(p9_client_open);
1055
1056 int p9_client_create_dotl(struct p9_fid *ofid, char *name, u32 flags, u32 mode,
1057                 gid_t gid, struct p9_qid *qid)
1058 {
1059         int err = 0;
1060         struct p9_client *clnt;
1061         struct p9_req_t *req;
1062         int iounit;
1063
1064         P9_DPRINTK(P9_DEBUG_9P,
1065                         ">>> TLCREATE fid %d name %s flags %d mode %d gid %d\n",
1066                         ofid->fid, name, flags, mode, gid);
1067         clnt = ofid->clnt;
1068
1069         if (ofid->mode != -1)
1070                 return -EINVAL;
1071
1072         req = p9_client_rpc(clnt, P9_TLCREATE, "dsddd", ofid->fid, name, flags,
1073                         mode, gid);
1074         if (IS_ERR(req)) {
1075                 err = PTR_ERR(req);
1076                 goto error;
1077         }
1078
1079         err = p9pdu_readf(req->rc, clnt->proto_version, "Qd", qid, &iounit);
1080         if (err) {
1081                 p9pdu_dump(1, req->rc);
1082                 goto free_and_error;
1083         }
1084
1085         P9_DPRINTK(P9_DEBUG_9P, "<<< RLCREATE qid %x.%llx.%x iounit %x\n",
1086                         qid->type,
1087                         (unsigned long long)qid->path,
1088                         qid->version, iounit);
1089
1090         ofid->mode = mode;
1091         ofid->iounit = iounit;
1092
1093 free_and_error:
1094         p9_free_req(clnt, req);
1095 error:
1096         return err;
1097 }
1098 EXPORT_SYMBOL(p9_client_create_dotl);
1099
1100 int p9_client_fcreate(struct p9_fid *fid, char *name, u32 perm, int mode,
1101                      char *extension)
1102 {
1103         int err;
1104         struct p9_client *clnt;
1105         struct p9_req_t *req;
1106         struct p9_qid qid;
1107         int iounit;
1108
1109         P9_DPRINTK(P9_DEBUG_9P, ">>> TCREATE fid %d name %s perm %d mode %d\n",
1110                                                 fid->fid, name, perm, mode);
1111         err = 0;
1112         clnt = fid->clnt;
1113
1114         if (fid->mode != -1)
1115                 return -EINVAL;
1116
1117         req = p9_client_rpc(clnt, P9_TCREATE, "dsdb?s", fid->fid, name, perm,
1118                                 mode, extension);
1119         if (IS_ERR(req)) {
1120                 err = PTR_ERR(req);
1121                 goto error;
1122         }
1123
1124         err = p9pdu_readf(req->rc, clnt->proto_version, "Qd", &qid, &iounit);
1125         if (err) {
1126                 p9pdu_dump(1, req->rc);
1127                 goto free_and_error;
1128         }
1129
1130         P9_DPRINTK(P9_DEBUG_9P, "<<< RCREATE qid %x.%llx.%x iounit %x\n",
1131                                 qid.type,
1132                                 (unsigned long long)qid.path,
1133                                 qid.version, iounit);
1134
1135         fid->mode = mode;
1136         fid->iounit = iounit;
1137
1138 free_and_error:
1139         p9_free_req(clnt, req);
1140 error:
1141         return err;
1142 }
1143 EXPORT_SYMBOL(p9_client_fcreate);
1144
1145 int p9_client_symlink(struct p9_fid *dfid, char *name, char *symtgt, gid_t gid,
1146                 struct p9_qid *qid)
1147 {
1148         int err = 0;
1149         struct p9_client *clnt;
1150         struct p9_req_t *req;
1151
1152         P9_DPRINTK(P9_DEBUG_9P, ">>> TSYMLINK dfid %d name %s  symtgt %s\n",
1153                         dfid->fid, name, symtgt);
1154         clnt = dfid->clnt;
1155
1156         req = p9_client_rpc(clnt, P9_TSYMLINK, "dssd", dfid->fid, name, symtgt,
1157                         gid);
1158         if (IS_ERR(req)) {
1159                 err = PTR_ERR(req);
1160                 goto error;
1161         }
1162
1163         err = p9pdu_readf(req->rc, clnt->proto_version, "Q", qid);
1164         if (err) {
1165                 p9pdu_dump(1, req->rc);
1166                 goto free_and_error;
1167         }
1168
1169         P9_DPRINTK(P9_DEBUG_9P, "<<< RSYMLINK qid %x.%llx.%x\n",
1170                         qid->type, (unsigned long long)qid->path, qid->version);
1171
1172 free_and_error:
1173         p9_free_req(clnt, req);
1174 error:
1175         return err;
1176 }
1177 EXPORT_SYMBOL(p9_client_symlink);
1178
1179 int p9_client_link(struct p9_fid *dfid, struct p9_fid *oldfid, char *newname)
1180 {
1181         struct p9_client *clnt;
1182         struct p9_req_t *req;
1183
1184         P9_DPRINTK(P9_DEBUG_9P, ">>> TLINK dfid %d oldfid %d newname %s\n",
1185                         dfid->fid, oldfid->fid, newname);
1186         clnt = dfid->clnt;
1187         req = p9_client_rpc(clnt, P9_TLINK, "dds", dfid->fid, oldfid->fid,
1188                         newname);
1189         if (IS_ERR(req))
1190                 return PTR_ERR(req);
1191
1192         P9_DPRINTK(P9_DEBUG_9P, "<<< RLINK\n");
1193         p9_free_req(clnt, req);
1194         return 0;
1195 }
1196 EXPORT_SYMBOL(p9_client_link);
1197
1198 int p9_client_clunk(struct p9_fid *fid)
1199 {
1200         int err;
1201         struct p9_client *clnt;
1202         struct p9_req_t *req;
1203
1204         P9_DPRINTK(P9_DEBUG_9P, ">>> TCLUNK fid %d\n", fid->fid);
1205         err = 0;
1206         clnt = fid->clnt;
1207
1208         req = p9_client_rpc(clnt, P9_TCLUNK, "d", fid->fid);
1209         if (IS_ERR(req)) {
1210                 err = PTR_ERR(req);
1211                 goto error;
1212         }
1213
1214         P9_DPRINTK(P9_DEBUG_9P, "<<< RCLUNK fid %d\n", fid->fid);
1215
1216         p9_free_req(clnt, req);
1217         p9_fid_destroy(fid);
1218
1219 error:
1220         return err;
1221 }
1222 EXPORT_SYMBOL(p9_client_clunk);
1223
1224 int p9_client_remove(struct p9_fid *fid)
1225 {
1226         int err;
1227         struct p9_client *clnt;
1228         struct p9_req_t *req;
1229
1230         P9_DPRINTK(P9_DEBUG_9P, ">>> TREMOVE fid %d\n", fid->fid);
1231         err = 0;
1232         clnt = fid->clnt;
1233
1234         req = p9_client_rpc(clnt, P9_TREMOVE, "d", fid->fid);
1235         if (IS_ERR(req)) {
1236                 err = PTR_ERR(req);
1237                 goto error;
1238         }
1239
1240         P9_DPRINTK(P9_DEBUG_9P, "<<< RREMOVE fid %d\n", fid->fid);
1241
1242         p9_free_req(clnt, req);
1243 error:
1244         p9_fid_destroy(fid);
1245         return err;
1246 }
1247 EXPORT_SYMBOL(p9_client_remove);
1248
1249 int
1250 p9_client_read(struct p9_fid *fid, char *data, char __user *udata, u64 offset,
1251                                                                 u32 count)
1252 {
1253         int err, rsize, total;
1254         struct p9_client *clnt;
1255         struct p9_req_t *req;
1256         char *dataptr;
1257
1258         P9_DPRINTK(P9_DEBUG_9P, ">>> TREAD fid %d offset %llu %d\n", fid->fid,
1259                                         (long long unsigned) offset, count);
1260         err = 0;
1261         clnt = fid->clnt;
1262         total = 0;
1263
1264         rsize = fid->iounit;
1265         if (!rsize || rsize > clnt->msize-P9_IOHDRSZ)
1266                 rsize = clnt->msize - P9_IOHDRSZ;
1267
1268         if (count < rsize)
1269                 rsize = count;
1270
1271         req = p9_client_rpc(clnt, P9_TREAD, "dqd", fid->fid, offset, rsize);
1272         if (IS_ERR(req)) {
1273                 err = PTR_ERR(req);
1274                 goto error;
1275         }
1276
1277         err = p9pdu_readf(req->rc, clnt->proto_version, "D", &count, &dataptr);
1278         if (err) {
1279                 p9pdu_dump(1, req->rc);
1280                 goto free_and_error;
1281         }
1282
1283         P9_DPRINTK(P9_DEBUG_9P, "<<< RREAD count %d\n", count);
1284
1285         if (data) {
1286                 memmove(data, dataptr, count);
1287         }
1288
1289         if (udata) {
1290                 err = copy_to_user(udata, dataptr, count);
1291                 if (err) {
1292                         err = -EFAULT;
1293                         goto free_and_error;
1294                 }
1295         }
1296
1297         p9_free_req(clnt, req);
1298         return count;
1299
1300 free_and_error:
1301         p9_free_req(clnt, req);
1302 error:
1303         return err;
1304 }
1305 EXPORT_SYMBOL(p9_client_read);
1306
1307 int
1308 p9_client_write(struct p9_fid *fid, char *data, const char __user *udata,
1309                                                         u64 offset, u32 count)
1310 {
1311         int err, rsize, total;
1312         struct p9_client *clnt;
1313         struct p9_req_t *req;
1314
1315         P9_DPRINTK(P9_DEBUG_9P, ">>> TWRITE fid %d offset %llu count %d\n",
1316                                 fid->fid, (long long unsigned) offset, count);
1317         err = 0;
1318         clnt = fid->clnt;
1319         total = 0;
1320
1321         rsize = fid->iounit;
1322         if (!rsize || rsize > clnt->msize-P9_IOHDRSZ)
1323                 rsize = clnt->msize - P9_IOHDRSZ;
1324
1325         if (count < rsize)
1326                 rsize = count;
1327         if (data)
1328                 req = p9_client_rpc(clnt, P9_TWRITE, "dqD", fid->fid, offset,
1329                                                                 rsize, data);
1330         else
1331                 req = p9_client_rpc(clnt, P9_TWRITE, "dqU", fid->fid, offset,
1332                                                                 rsize, udata);
1333         if (IS_ERR(req)) {
1334                 err = PTR_ERR(req);
1335                 goto error;
1336         }
1337
1338         err = p9pdu_readf(req->rc, clnt->proto_version, "d", &count);
1339         if (err) {
1340                 p9pdu_dump(1, req->rc);
1341                 goto free_and_error;
1342         }
1343
1344         P9_DPRINTK(P9_DEBUG_9P, "<<< RWRITE count %d\n", count);
1345
1346         p9_free_req(clnt, req);
1347         return count;
1348
1349 free_and_error:
1350         p9_free_req(clnt, req);
1351 error:
1352         return err;
1353 }
1354 EXPORT_SYMBOL(p9_client_write);
1355
1356 struct p9_wstat *p9_client_stat(struct p9_fid *fid)
1357 {
1358         int err;
1359         struct p9_client *clnt;
1360         struct p9_wstat *ret = kmalloc(sizeof(struct p9_wstat), GFP_KERNEL);
1361         struct p9_req_t *req;
1362         u16 ignored;
1363
1364         P9_DPRINTK(P9_DEBUG_9P, ">>> TSTAT fid %d\n", fid->fid);
1365
1366         if (!ret)
1367                 return ERR_PTR(-ENOMEM);
1368
1369         err = 0;
1370         clnt = fid->clnt;
1371
1372         req = p9_client_rpc(clnt, P9_TSTAT, "d", fid->fid);
1373         if (IS_ERR(req)) {
1374                 err = PTR_ERR(req);
1375                 goto error;
1376         }
1377
1378         err = p9pdu_readf(req->rc, clnt->proto_version, "wS", &ignored, ret);
1379         if (err) {
1380                 p9pdu_dump(1, req->rc);
1381                 p9_free_req(clnt, req);
1382                 goto error;
1383         }
1384
1385         P9_DPRINTK(P9_DEBUG_9P,
1386                 "<<< RSTAT sz=%x type=%x dev=%x qid=%x.%llx.%x\n"
1387                 "<<<    mode=%8.8x atime=%8.8x mtime=%8.8x length=%llx\n"
1388                 "<<<    name=%s uid=%s gid=%s muid=%s extension=(%s)\n"
1389                 "<<<    uid=%d gid=%d n_muid=%d\n",
1390                 ret->size, ret->type, ret->dev, ret->qid.type,
1391                 (unsigned long long)ret->qid.path, ret->qid.version, ret->mode,
1392                 ret->atime, ret->mtime, (unsigned long long)ret->length,
1393                 ret->name, ret->uid, ret->gid, ret->muid, ret->extension,
1394                 ret->n_uid, ret->n_gid, ret->n_muid);
1395
1396         p9_free_req(clnt, req);
1397         return ret;
1398
1399 error:
1400         kfree(ret);
1401         return ERR_PTR(err);
1402 }
1403 EXPORT_SYMBOL(p9_client_stat);
1404
1405 struct p9_stat_dotl *p9_client_getattr_dotl(struct p9_fid *fid,
1406                                                         u64 request_mask)
1407 {
1408         int err;
1409         struct p9_client *clnt;
1410         struct p9_stat_dotl *ret = kmalloc(sizeof(struct p9_stat_dotl),
1411                                                                 GFP_KERNEL);
1412         struct p9_req_t *req;
1413
1414         P9_DPRINTK(P9_DEBUG_9P, ">>> TGETATTR fid %d, request_mask %lld\n",
1415                                                         fid->fid, request_mask);
1416
1417         if (!ret)
1418                 return ERR_PTR(-ENOMEM);
1419
1420         err = 0;
1421         clnt = fid->clnt;
1422
1423         req = p9_client_rpc(clnt, P9_TGETATTR, "dq", fid->fid, request_mask);
1424         if (IS_ERR(req)) {
1425                 err = PTR_ERR(req);
1426                 goto error;
1427         }
1428
1429         err = p9pdu_readf(req->rc, clnt->proto_version, "A", ret);
1430         if (err) {
1431                 p9pdu_dump(1, req->rc);
1432                 p9_free_req(clnt, req);
1433                 goto error;
1434         }
1435
1436         P9_DPRINTK(P9_DEBUG_9P,
1437                 "<<< RGETATTR st_result_mask=%lld\n"
1438                 "<<< qid=%x.%llx.%x\n"
1439                 "<<< st_mode=%8.8x st_nlink=%llu\n"
1440                 "<<< st_uid=%d st_gid=%d\n"
1441                 "<<< st_rdev=%llx st_size=%llx st_blksize=%llu st_blocks=%llu\n"
1442                 "<<< st_atime_sec=%lld st_atime_nsec=%lld\n"
1443                 "<<< st_mtime_sec=%lld st_mtime_nsec=%lld\n"
1444                 "<<< st_ctime_sec=%lld st_ctime_nsec=%lld\n"
1445                 "<<< st_btime_sec=%lld st_btime_nsec=%lld\n"
1446                 "<<< st_gen=%lld st_data_version=%lld",
1447                 ret->st_result_mask, ret->qid.type, ret->qid.path,
1448                 ret->qid.version, ret->st_mode, ret->st_nlink, ret->st_uid,
1449                 ret->st_gid, ret->st_rdev, ret->st_size, ret->st_blksize,
1450                 ret->st_blocks, ret->st_atime_sec, ret->st_atime_nsec,
1451                 ret->st_mtime_sec, ret->st_mtime_nsec, ret->st_ctime_sec,
1452                 ret->st_ctime_nsec, ret->st_btime_sec, ret->st_btime_nsec,
1453                 ret->st_gen, ret->st_data_version);
1454
1455         p9_free_req(clnt, req);
1456         return ret;
1457
1458 error:
1459         kfree(ret);
1460         return ERR_PTR(err);
1461 }
1462 EXPORT_SYMBOL(p9_client_getattr_dotl);
1463
1464 static int p9_client_statsize(struct p9_wstat *wst, int proto_version)
1465 {
1466         int ret;
1467
1468         /* NOTE: size shouldn't include its own length */
1469         /* size[2] type[2] dev[4] qid[13] */
1470         /* mode[4] atime[4] mtime[4] length[8]*/
1471         /* name[s] uid[s] gid[s] muid[s] */
1472         ret = 2+4+13+4+4+4+8+2+2+2+2;
1473
1474         if (wst->name)
1475                 ret += strlen(wst->name);
1476         if (wst->uid)
1477                 ret += strlen(wst->uid);
1478         if (wst->gid)
1479                 ret += strlen(wst->gid);
1480         if (wst->muid)
1481                 ret += strlen(wst->muid);
1482
1483         if ((proto_version == p9_proto_2000u) ||
1484                 (proto_version == p9_proto_2000L)) {
1485                 ret += 2+4+4+4; /* extension[s] n_uid[4] n_gid[4] n_muid[4] */
1486                 if (wst->extension)
1487                         ret += strlen(wst->extension);
1488         }
1489
1490         return ret;
1491 }
1492
1493 int p9_client_wstat(struct p9_fid *fid, struct p9_wstat *wst)
1494 {
1495         int err;
1496         struct p9_req_t *req;
1497         struct p9_client *clnt;
1498
1499         err = 0;
1500         clnt = fid->clnt;
1501         wst->size = p9_client_statsize(wst, clnt->proto_version);
1502         P9_DPRINTK(P9_DEBUG_9P, ">>> TWSTAT fid %d\n", fid->fid);
1503         P9_DPRINTK(P9_DEBUG_9P,
1504                 "     sz=%x type=%x dev=%x qid=%x.%llx.%x\n"
1505                 "     mode=%8.8x atime=%8.8x mtime=%8.8x length=%llx\n"
1506                 "     name=%s uid=%s gid=%s muid=%s extension=(%s)\n"
1507                 "     uid=%d gid=%d n_muid=%d\n",
1508                 wst->size, wst->type, wst->dev, wst->qid.type,
1509                 (unsigned long long)wst->qid.path, wst->qid.version, wst->mode,
1510                 wst->atime, wst->mtime, (unsigned long long)wst->length,
1511                 wst->name, wst->uid, wst->gid, wst->muid, wst->extension,
1512                 wst->n_uid, wst->n_gid, wst->n_muid);
1513
1514         req = p9_client_rpc(clnt, P9_TWSTAT, "dwS", fid->fid, wst->size+2, wst);
1515         if (IS_ERR(req)) {
1516                 err = PTR_ERR(req);
1517                 goto error;
1518         }
1519
1520         P9_DPRINTK(P9_DEBUG_9P, "<<< RWSTAT fid %d\n", fid->fid);
1521
1522         p9_free_req(clnt, req);
1523 error:
1524         return err;
1525 }
1526 EXPORT_SYMBOL(p9_client_wstat);
1527
1528 int p9_client_setattr(struct p9_fid *fid, struct p9_iattr_dotl *p9attr)
1529 {
1530         int err;
1531         struct p9_req_t *req;
1532         struct p9_client *clnt;
1533
1534         err = 0;
1535         clnt = fid->clnt;
1536         P9_DPRINTK(P9_DEBUG_9P, ">>> TSETATTR fid %d\n", fid->fid);
1537         P9_DPRINTK(P9_DEBUG_9P,
1538                 "    valid=%x mode=%x uid=%d gid=%d size=%lld\n"
1539                 "    atime_sec=%lld atime_nsec=%lld\n"
1540                 "    mtime_sec=%lld mtime_nsec=%lld\n",
1541                 p9attr->valid, p9attr->mode, p9attr->uid, p9attr->gid,
1542                 p9attr->size, p9attr->atime_sec, p9attr->atime_nsec,
1543                 p9attr->mtime_sec, p9attr->mtime_nsec);
1544
1545         req = p9_client_rpc(clnt, P9_TSETATTR, "dI", fid->fid, p9attr);
1546
1547         if (IS_ERR(req)) {
1548                 err = PTR_ERR(req);
1549                 goto error;
1550         }
1551         P9_DPRINTK(P9_DEBUG_9P, "<<< RSETATTR fid %d\n", fid->fid);
1552         p9_free_req(clnt, req);
1553 error:
1554         return err;
1555 }
1556 EXPORT_SYMBOL(p9_client_setattr);
1557
1558 int p9_client_statfs(struct p9_fid *fid, struct p9_rstatfs *sb)
1559 {
1560         int err;
1561         struct p9_req_t *req;
1562         struct p9_client *clnt;
1563
1564         err = 0;
1565         clnt = fid->clnt;
1566
1567         P9_DPRINTK(P9_DEBUG_9P, ">>> TSTATFS fid %d\n", fid->fid);
1568
1569         req = p9_client_rpc(clnt, P9_TSTATFS, "d", fid->fid);
1570         if (IS_ERR(req)) {
1571                 err = PTR_ERR(req);
1572                 goto error;
1573         }
1574
1575         err = p9pdu_readf(req->rc, clnt->proto_version, "ddqqqqqqd", &sb->type,
1576                 &sb->bsize, &sb->blocks, &sb->bfree, &sb->bavail,
1577                 &sb->files, &sb->ffree, &sb->fsid, &sb->namelen);
1578         if (err) {
1579                 p9pdu_dump(1, req->rc);
1580                 p9_free_req(clnt, req);
1581                 goto error;
1582         }
1583
1584         P9_DPRINTK(P9_DEBUG_9P, "<<< RSTATFS fid %d type 0x%lx bsize %ld "
1585                 "blocks %llu bfree %llu bavail %llu files %llu ffree %llu "
1586                 "fsid %llu namelen %ld\n",
1587                 fid->fid, (long unsigned int)sb->type, (long int)sb->bsize,
1588                 sb->blocks, sb->bfree, sb->bavail, sb->files,  sb->ffree,
1589                 sb->fsid, (long int)sb->namelen);
1590
1591         p9_free_req(clnt, req);
1592 error:
1593         return err;
1594 }
1595 EXPORT_SYMBOL(p9_client_statfs);
1596
1597 int p9_client_rename(struct p9_fid *fid, struct p9_fid *newdirfid, char *name)
1598 {
1599         int err;
1600         struct p9_req_t *req;
1601         struct p9_client *clnt;
1602
1603         err = 0;
1604         clnt = fid->clnt;
1605
1606         P9_DPRINTK(P9_DEBUG_9P, ">>> TRENAME fid %d newdirfid %d name %s\n",
1607                         fid->fid, newdirfid->fid, name);
1608
1609         req = p9_client_rpc(clnt, P9_TRENAME, "dds", fid->fid,
1610                         newdirfid->fid, name);
1611         if (IS_ERR(req)) {
1612                 err = PTR_ERR(req);
1613                 goto error;
1614         }
1615
1616         P9_DPRINTK(P9_DEBUG_9P, "<<< RRENAME fid %d\n", fid->fid);
1617
1618         p9_free_req(clnt, req);
1619 error:
1620         return err;
1621 }
1622 EXPORT_SYMBOL(p9_client_rename);
1623
1624 /*
1625  * An xattrwalk without @attr_name gives the fid for the lisxattr namespace
1626  */
1627 struct p9_fid *p9_client_xattrwalk(struct p9_fid *file_fid,
1628                                 const char *attr_name, u64 *attr_size)
1629 {
1630         int err;
1631         struct p9_req_t *req;
1632         struct p9_client *clnt;
1633         struct p9_fid *attr_fid;
1634
1635         err = 0;
1636         clnt = file_fid->clnt;
1637         attr_fid = p9_fid_create(clnt);
1638         if (IS_ERR(attr_fid)) {
1639                 err = PTR_ERR(attr_fid);
1640                 attr_fid = NULL;
1641                 goto error;
1642         }
1643         P9_DPRINTK(P9_DEBUG_9P,
1644                 ">>> TXATTRWALK file_fid %d, attr_fid %d name %s\n",
1645                 file_fid->fid, attr_fid->fid, attr_name);
1646
1647         req = p9_client_rpc(clnt, P9_TXATTRWALK, "dds",
1648                         file_fid->fid, attr_fid->fid, attr_name);
1649         if (IS_ERR(req)) {
1650                 err = PTR_ERR(req);
1651                 goto error;
1652         }
1653         err = p9pdu_readf(req->rc, clnt->proto_version, "q", attr_size);
1654         if (err) {
1655                 p9pdu_dump(1, req->rc);
1656                 p9_free_req(clnt, req);
1657                 goto clunk_fid;
1658         }
1659         p9_free_req(clnt, req);
1660         P9_DPRINTK(P9_DEBUG_9P, "<<<  RXATTRWALK fid %d size %llu\n",
1661                 attr_fid->fid, *attr_size);
1662         return attr_fid;
1663 clunk_fid:
1664         p9_client_clunk(attr_fid);
1665         attr_fid = NULL;
1666 error:
1667         if (attr_fid && (attr_fid != file_fid))
1668                 p9_fid_destroy(attr_fid);
1669
1670         return ERR_PTR(err);
1671 }
1672 EXPORT_SYMBOL_GPL(p9_client_xattrwalk);
1673
1674 int p9_client_xattrcreate(struct p9_fid *fid, const char *name,
1675                         u64 attr_size, int flags)
1676 {
1677         int err;
1678         struct p9_req_t *req;
1679         struct p9_client *clnt;
1680
1681         P9_DPRINTK(P9_DEBUG_9P,
1682                 ">>> TXATTRCREATE fid %d name  %s size %lld flag %d\n",
1683                 fid->fid, name, (long long)attr_size, flags);
1684         err = 0;
1685         clnt = fid->clnt;
1686         req = p9_client_rpc(clnt, P9_TXATTRCREATE, "dsqd",
1687                         fid->fid, name, attr_size, flags);
1688         if (IS_ERR(req)) {
1689                 err = PTR_ERR(req);
1690                 goto error;
1691         }
1692         P9_DPRINTK(P9_DEBUG_9P, "<<< RXATTRCREATE fid %d\n", fid->fid);
1693         p9_free_req(clnt, req);
1694 error:
1695         return err;
1696 }
1697 EXPORT_SYMBOL_GPL(p9_client_xattrcreate);
1698
1699 int p9_client_readdir(struct p9_fid *fid, char *data, u32 count, u64 offset)
1700 {
1701         int err, rsize, total;
1702         struct p9_client *clnt;
1703         struct p9_req_t *req;
1704         char *dataptr;
1705
1706         P9_DPRINTK(P9_DEBUG_9P, ">>> TREADDIR fid %d offset %llu count %d\n",
1707                                 fid->fid, (long long unsigned) offset, count);
1708
1709         err = 0;
1710         clnt = fid->clnt;
1711         total = 0;
1712
1713         rsize = fid->iounit;
1714         if (!rsize || rsize > clnt->msize-P9_READDIRHDRSZ)
1715                 rsize = clnt->msize - P9_READDIRHDRSZ;
1716
1717         if (count < rsize)
1718                 rsize = count;
1719
1720         req = p9_client_rpc(clnt, P9_TREADDIR, "dqd", fid->fid, offset, rsize);
1721         if (IS_ERR(req)) {
1722                 err = PTR_ERR(req);
1723                 goto error;
1724         }
1725
1726         err = p9pdu_readf(req->rc, clnt->proto_version, "D", &count, &dataptr);
1727         if (err) {
1728                 p9pdu_dump(1, req->rc);
1729                 goto free_and_error;
1730         }
1731
1732         P9_DPRINTK(P9_DEBUG_9P, "<<< RREADDIR count %d\n", count);
1733
1734         if (data)
1735                 memmove(data, dataptr, count);
1736
1737         p9_free_req(clnt, req);
1738         return count;
1739
1740 free_and_error:
1741         p9_free_req(clnt, req);
1742 error:
1743         return err;
1744 }
1745 EXPORT_SYMBOL(p9_client_readdir);
1746
1747 int p9_client_mknod_dotl(struct p9_fid *fid, char *name, int mode,
1748                         dev_t rdev, gid_t gid, struct p9_qid *qid)
1749 {
1750         int err;
1751         struct p9_client *clnt;
1752         struct p9_req_t *req;
1753
1754         err = 0;
1755         clnt = fid->clnt;
1756         P9_DPRINTK(P9_DEBUG_9P, ">>> TMKNOD fid %d name %s mode %d major %d "
1757                 "minor %d\n", fid->fid, name, mode, MAJOR(rdev), MINOR(rdev));
1758         req = p9_client_rpc(clnt, P9_TMKNOD, "dsdddd", fid->fid, name, mode,
1759                 MAJOR(rdev), MINOR(rdev), gid);
1760         if (IS_ERR(req))
1761                 return PTR_ERR(req);
1762
1763         err = p9pdu_readf(req->rc, clnt->proto_version, "Q", qid);
1764         if (err) {
1765                 p9pdu_dump(1, req->rc);
1766                 goto error;
1767         }
1768         P9_DPRINTK(P9_DEBUG_9P, "<<< RMKNOD qid %x.%llx.%x\n", qid->type,
1769                                 (unsigned long long)qid->path, qid->version);
1770
1771 error:
1772         p9_free_req(clnt, req);
1773         return err;
1774
1775 }
1776 EXPORT_SYMBOL(p9_client_mknod_dotl);
1777
1778 int p9_client_mkdir_dotl(struct p9_fid *fid, char *name, int mode,
1779                                 gid_t gid, struct p9_qid *qid)
1780 {
1781         int err;
1782         struct p9_client *clnt;
1783         struct p9_req_t *req;
1784
1785         err = 0;
1786         clnt = fid->clnt;
1787         P9_DPRINTK(P9_DEBUG_9P, ">>> TMKDIR fid %d name %s mode %d gid %d\n",
1788                  fid->fid, name, mode, gid);
1789         req = p9_client_rpc(clnt, P9_TMKDIR, "dsdd", fid->fid, name, mode,
1790                 gid);
1791         if (IS_ERR(req))
1792                 return PTR_ERR(req);
1793
1794         err = p9pdu_readf(req->rc, clnt->proto_version, "Q", qid);
1795         if (err) {
1796                 p9pdu_dump(1, req->rc);
1797                 goto error;
1798         }
1799         P9_DPRINTK(P9_DEBUG_9P, "<<< RMKDIR qid %x.%llx.%x\n", qid->type,
1800                                 (unsigned long long)qid->path, qid->version);
1801
1802 error:
1803         p9_free_req(clnt, req);
1804         return err;
1805
1806 }
1807 EXPORT_SYMBOL(p9_client_mkdir_dotl);