net/9p/client.c

   1 /*
   2  * net/9p/clnt.c
   3  *
   4  * 9P Client
   5  *
   6  *  Copyright (C) 2007 by Latchesar Ionkov <lucho@ionkov.net>
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License version 2
  10  *  as published by the Free Software Foundation.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program; if not, write to:
  19  *  Free Software Foundation
  20  *  51 Franklin Street, Fifth Floor
  21  *  Boston, MA  02111-1301  USA
  22  *
  23  */
  24
  25 #include <linux/module.h>
  26 #include <linux/errno.h>
  27 #include <linux/fs.h>
  28 #include <linux/idr.h>
  29 #include <linux/mutex.h>
  30 #include <linux/sched.h>
  31 #include <linux/uaccess.h>
  32 #include <net/9p/9p.h>
  33 #include <net/9p/transport.h>
  34 #include <net/9p/conn.h>
  35 #include <net/9p/client.h>
  36
  37 static struct p9_fid *p9_fid_create(struct p9_client *clnt);
  38 static void p9_fid_destroy(struct p9_fid *fid);
  39 static struct p9_stat *p9_clone_stat(struct p9_stat *st, int dotu);
  40
  41 struct p9_client *p9_client_create(struct p9_trans *trans, int msize,
  42                                                                    int dotu)
  43 {
  44         int err, n;
  45         struct p9_client *clnt;
  46         struct p9_fcall *tc, *rc;
  47         struct p9_str *version;
  48
  49         err = 0;
  50         tc = NULL;
  51         rc = NULL;
  52         clnt = kmalloc(sizeof(struct p9_client), GFP_KERNEL);
  53         if (!clnt)
  54                 return ERR_PTR(-ENOMEM);
  55
  56         P9_DPRINTK(P9_DEBUG_9P, "clnt %p trans %p msize %d dotu %d\n",
  57                 clnt, trans, msize, dotu);
  58         spin_lock_init(&clnt->lock);
  59         clnt->trans = trans;
  60         clnt->msize = msize;
  61         clnt->dotu = dotu;
  62         INIT_LIST_HEAD(&clnt->fidlist);
  63         clnt->fidpool = p9_idpool_create();
  64         if (!clnt->fidpool) {
  65                 err = PTR_ERR(clnt->fidpool);
  66                 clnt->fidpool = NULL;
  67                 goto error;
  68         }
  69
  70         clnt->conn = p9_conn_create(clnt->trans, clnt->msize, &clnt->dotu);
  71         if (IS_ERR(clnt->conn)) {
  72                 err = PTR_ERR(clnt->conn);
  73                 clnt->conn = NULL;
  74                 goto error;
  75         }
  76
  77         tc = p9_create_tversion(clnt->msize, clnt->dotu?"9P2000.u":"9P2000");
  78         if (IS_ERR(tc)) {
  79                 err = PTR_ERR(tc);
  80                 tc = NULL;
  81                 goto error;
  82         }
  83
  84         err = p9_conn_rpc(clnt->conn, tc, &rc);
  85         if (err)
  86                 goto error;
  87
  88         version = &rc->params.rversion.version;
  89         if (version->len == 8 && !memcmp(version->str, "9P2000.u", 8))
  90                 clnt->dotu = 1;
  91         else if (version->len == 6 && !memcmp(version->str, "9P2000", 6))
  92                 clnt->dotu = 0;
  93         else {
  94                 err = -EREMOTEIO;
  95                 goto error;
  96         }
  97
  98         n = rc->params.rversion.msize;
  99         if (n < clnt->msize)
 100                 clnt->msize = n;
 101
 102         kfree(tc);
 103         kfree(rc);
 104         return clnt;
 105
 106 error:
 107         kfree(tc);
 108         kfree(rc);
 109         p9_client_destroy(clnt);
 110         return ERR_PTR(err);
 111 }
 112 EXPORT_SYMBOL(p9_client_create);
 113
 114 void p9_client_destroy(struct p9_client *clnt)
 115 {
 116         struct p9_fid *fid, *fidptr;
 117
 118         P9_DPRINTK(P9_DEBUG_9P, "clnt %p\n", clnt);
 119         if (clnt->conn) {
 120                 p9_conn_destroy(clnt->conn);
 121                 clnt->conn = NULL;
 122         }
 123
 124         if (clnt->trans) {
 125                 clnt->trans->close(clnt->trans);
 126                 kfree(clnt->trans);
 127                 clnt->trans = NULL;
 128         }
 129
 130         list_for_each_entry_safe(fid, fidptr, &clnt->fidlist, flist)
 131                 p9_fid_destroy(fid);
 132
 133         if (clnt->fidpool)
 134                 p9_idpool_destroy(clnt->fidpool);
 135
 136         kfree(clnt);
 137 }
 138 EXPORT_SYMBOL(p9_client_destroy);
 139
 140 void p9_client_disconnect(struct p9_client *clnt)
 141 {
 142         P9_DPRINTK(P9_DEBUG_9P, "clnt %p\n", clnt);
 143         clnt->trans->status = Disconnected;
 144         p9_conn_cancel(clnt->conn, -EIO);
 145 }
 146 EXPORT_SYMBOL(p9_client_disconnect);
 147
 148 struct p9_fid *p9_client_attach(struct p9_client *clnt, struct p9_fid *afid,
 149         char *uname, u32 n_uname, char *aname)
 150 {
 151         int err;
 152         struct p9_fcall *tc, *rc;
 153         struct p9_fid *fid;
 154
 155         P9_DPRINTK(P9_DEBUG_9P, "clnt %p afid %d uname %s aname %s\n",
 156                 clnt, afid?afid->fid:-1, uname, aname);
 157         err = 0;
 158         tc = NULL;
 159         rc = NULL;
 160
 161         fid = p9_fid_create(clnt);
 162         if (IS_ERR(fid)) {
 163                 err = PTR_ERR(fid);
 164                 fid = NULL;
 165                 goto error;
 166         }
 167
 168         tc = p9_create_tattach(fid->fid, afid?afid->fid:P9_NOFID, uname, aname,
 169                 n_uname, clnt->dotu);
 170         if (IS_ERR(tc)) {
 171                 err = PTR_ERR(tc);
 172                 tc = NULL;
 173                 goto error;
 174         }
 175
 176         err = p9_conn_rpc(clnt->conn, tc, &rc);
 177         if (err)
 178                 goto error;
 179
 180         memmove(&fid->qid, &rc->params.rattach.qid, sizeof(struct p9_qid));
 181         kfree(tc);
 182         kfree(rc);
 183         return fid;
 184
 185 error:
 186         kfree(tc);
 187         kfree(rc);
 188         if (fid)
 189                 p9_fid_destroy(fid);
 190         return ERR_PTR(err);
 191 }
 192 EXPORT_SYMBOL(p9_client_attach);
 193
 194 struct p9_fid *p9_client_auth(struct p9_client *clnt, char *uname,
 195         u32 n_uname, char *aname)
 196 {
 197         int err;
 198         struct p9_fcall *tc, *rc;
 199         struct p9_fid *fid;
 200
 201         P9_DPRINTK(P9_DEBUG_9P, "clnt %p uname %s aname %s\n", clnt, uname,
 202                                                                         aname);
 203         err = 0;
 204         tc = NULL;
 205         rc = NULL;
 206
 207         fid = p9_fid_create(clnt);
 208         if (IS_ERR(fid)) {
 209                 err = PTR_ERR(fid);
 210                 fid = NULL;
 211                 goto error;
 212         }
 213
 214         tc = p9_create_tauth(fid->fid, uname, aname, n_uname, clnt->dotu);
 215         if (IS_ERR(tc)) {
 216                 err = PTR_ERR(tc);
 217                 tc = NULL;
 218                 goto error;
 219         }
 220
 221         err = p9_conn_rpc(clnt->conn, tc, &rc);
 222         if (err)
 223                 goto error;
 224
 225         memmove(&fid->qid, &rc->params.rauth.qid, sizeof(struct p9_qid));
 226         kfree(tc);
 227         kfree(rc);
 228         return fid;
 229
 230 error:
 231         kfree(tc);
 232         kfree(rc);
 233         if (fid)
 234                 p9_fid_destroy(fid);
 235         return ERR_PTR(err);
 236 }
 237 EXPORT_SYMBOL(p9_client_auth);
 238
 239 struct p9_fid *p9_client_walk(struct p9_fid *oldfid, int nwname, char **wnames,
 240         int clone)
 241 {
 242         int err;
 243         struct p9_fcall *tc, *rc;
 244         struct p9_client *clnt;
 245         struct p9_fid *fid;
 246
 247         P9_DPRINTK(P9_DEBUG_9P, "fid %d nwname %d wname[0] %s\n",
 248                 oldfid->fid, nwname, wnames?wnames[0]:NULL);
 249         err = 0;
 250         tc = NULL;
 251         rc = NULL;
 252         clnt = oldfid->clnt;
 253         if (clone) {
 254                 fid = p9_fid_create(clnt);
 255                 if (IS_ERR(fid)) {
 256                         err = PTR_ERR(fid);
 257                         fid = NULL;
 258                         goto error;
 259                 }
 260
 261                 fid->uid = oldfid->uid;
 262         } else
 263                 fid = oldfid;
 264
 265         tc = p9_create_twalk(oldfid->fid, fid->fid, nwname, wnames);
 266         if (IS_ERR(tc)) {
 267                 err = PTR_ERR(tc);
 268                 tc = NULL;
 269                 goto error;
 270         }
 271
 272         err = p9_conn_rpc(clnt->conn, tc, &rc);
 273         if (err) {
 274                 if (rc && rc->id == P9_RWALK)
 275                         goto clunk_fid;
 276                 else
 277                         goto error;
 278         }
 279
 280         if (rc->params.rwalk.nwqid != nwname) {
 281                 err = -ENOENT;
 282                 goto clunk_fid;
 283         }
 284
 285         if (nwname)
 286                 memmove(&fid->qid,
 287                         &rc->params.rwalk.wqids[rc->params.rwalk.nwqid - 1],
 288                         sizeof(struct p9_qid));
 289         else
 290                 fid->qid = oldfid->qid;
 291
 292         kfree(tc);
 293         kfree(rc);
 294         return fid;
 295
 296 clunk_fid:
 297         kfree(tc);
 298         kfree(rc);
 299         rc = NULL;
 300         tc = p9_create_tclunk(fid->fid);
 301         if (IS_ERR(tc)) {
 302                 err = PTR_ERR(tc);
 303                 tc = NULL;
 304                 goto error;
 305         }
 306
 307         p9_conn_rpc(clnt->conn, tc, &rc);
 308
 309 error:
 310         kfree(tc);
 311         kfree(rc);
 312         if (fid && (fid != oldfid))
 313                 p9_fid_destroy(fid);
 314
 315         return ERR_PTR(err);
 316 }
 317 EXPORT_SYMBOL(p9_client_walk);
 318
 319 int p9_client_open(struct p9_fid *fid, int mode)
 320 {
 321         int err;
 322         struct p9_fcall *tc, *rc;
 323         struct p9_client *clnt;
 324
 325         P9_DPRINTK(P9_DEBUG_9P, "fid %d mode %d\n", fid->fid, mode);
 326         err = 0;
 327         tc = NULL;
 328         rc = NULL;
 329         clnt = fid->clnt;
 330
 331         if (fid->mode != -1)
 332                 return -EINVAL;
 333
 334         tc = p9_create_topen(fid->fid, mode);
 335         if (IS_ERR(tc)) {
 336                 err = PTR_ERR(tc);
 337                 tc = NULL;
 338                 goto done;
 339         }
 340
 341         err = p9_conn_rpc(clnt->conn, tc, &rc);
 342         if (err)
 343                 goto done;
 344
 345         fid->mode = mode;
 346         fid->iounit = rc->params.ropen.iounit;
 347
 348 done:
 349         kfree(tc);
 350         kfree(rc);
 351         return err;
 352 }
 353 EXPORT_SYMBOL(p9_client_open);
 354
 355 int p9_client_fcreate(struct p9_fid *fid, char *name, u32 perm, int mode,
 356                      char *extension)
 357 {
 358         int err;
 359         struct p9_fcall *tc, *rc;
 360         struct p9_client *clnt;
 361
 362         P9_DPRINTK(P9_DEBUG_9P, "fid %d name %s perm %d mode %d\n", fid->fid,
 363                 name, perm, mode);
 364         err = 0;
 365         tc = NULL;
 366         rc = NULL;
 367         clnt = fid->clnt;
 368
 369         if (fid->mode != -1)
 370                 return -EINVAL;
 371
 372         tc = p9_create_tcreate(fid->fid, name, perm, mode, extension,
 373                                                                clnt->dotu);
 374         if (IS_ERR(tc)) {
 375                 err = PTR_ERR(tc);
 376                 tc = NULL;
 377                 goto done;
 378         }
 379
 380         err = p9_conn_rpc(clnt->conn, tc, &rc);
 381         if (err)
 382                 goto done;
 383
 384         fid->mode = mode;
 385         fid->iounit = rc->params.ropen.iounit;
 386
 387 done:
 388         kfree(tc);
 389         kfree(rc);
 390         return err;
 391 }
 392 EXPORT_SYMBOL(p9_client_fcreate);
 393
 394 int p9_client_clunk(struct p9_fid *fid)
 395 {
 396         int err;
 397         struct p9_fcall *tc, *rc;
 398         struct p9_client *clnt;
 399
 400         P9_DPRINTK(P9_DEBUG_9P, "fid %d\n", fid->fid);
 401         err = 0;
 402         tc = NULL;
 403         rc = NULL;
 404         clnt = fid->clnt;
 405
 406         tc = p9_create_tclunk(fid->fid);
 407         if (IS_ERR(tc)) {
 408                 err = PTR_ERR(tc);
 409                 tc = NULL;
 410                 goto done;
 411         }
 412
 413         err = p9_conn_rpc(clnt->conn, tc, &rc);
 414         if (err)
 415                 goto done;
 416
 417         p9_fid_destroy(fid);
 418
 419 done:
 420         kfree(tc);
 421         kfree(rc);
 422         return err;
 423 }
 424 EXPORT_SYMBOL(p9_client_clunk);
 425
 426 int p9_client_remove(struct p9_fid *fid)
 427 {
 428         int err;
 429         struct p9_fcall *tc, *rc;
 430         struct p9_client *clnt;
 431
 432         P9_DPRINTK(P9_DEBUG_9P, "fid %d\n", fid->fid);
 433         err = 0;
 434         tc = NULL;
 435         rc = NULL;
 436         clnt = fid->clnt;
 437
 438         tc = p9_create_tremove(fid->fid);
 439         if (IS_ERR(tc)) {
 440                 err = PTR_ERR(tc);
 441                 tc = NULL;
 442                 goto done;
 443         }
 444
 445         err = p9_conn_rpc(clnt->conn, tc, &rc);
 446         if (err)
 447                 goto done;
 448
 449         p9_fid_destroy(fid);
 450
 451 done:
 452         kfree(tc);
 453         kfree(rc);
 454         return err;
 455 }
 456 EXPORT_SYMBOL(p9_client_remove);
 457
 458 int p9_client_read(struct p9_fid *fid, char *data, u64 offset, u32 count)
 459 {
 460         int err, n, rsize, total;
 461         struct p9_fcall *tc, *rc;
 462         struct p9_client *clnt;
 463
 464         P9_DPRINTK(P9_DEBUG_9P, "fid %d offset %llu %d\n", fid->fid,
 465                                         (long long unsigned) offset, count);
 466         err = 0;
 467         tc = NULL;
 468         rc = NULL;
 469         clnt = fid->clnt;
 470         total = 0;
 471
 472         rsize = fid->iounit;
 473         if (!rsize || rsize > clnt->msize-P9_IOHDRSZ)
 474                 rsize = clnt->msize - P9_IOHDRSZ;
 475
 476         do {
 477                 if (count < rsize)
 478                         rsize = count;
 479
 480                 tc = p9_create_tread(fid->fid, offset, rsize);
 481                 if (IS_ERR(tc)) {
 482                         err = PTR_ERR(tc);
 483                         tc = NULL;
 484                         goto error;
 485                 }
 486
 487                 err = p9_conn_rpc(clnt->conn, tc, &rc);
 488                 if (err)
 489                         goto error;
 490
 491                 n = rc->params.rread.count;
 492                 if (n > count)
 493                         n = count;
 494
 495                 memmove(data, rc->params.rread.data, n);
 496                 count -= n;
 497                 data += n;
 498                 offset += n;
 499                 total += n;
 500                 kfree(tc);
 501                 tc = NULL;
 502                 kfree(rc);
 503                 rc = NULL;
 504         } while (count > 0 && n == rsize);
 505
 506         return total;
 507
 508 error:
 509         kfree(tc);
 510         kfree(rc);
 511         return err;
 512 }
 513 EXPORT_SYMBOL(p9_client_read);
 514
 515 int p9_client_write(struct p9_fid *fid, char *data, u64 offset, u32 count)
 516 {
 517         int err, n, rsize, total;
 518         struct p9_fcall *tc, *rc;
 519         struct p9_client *clnt;
 520
 521         P9_DPRINTK(P9_DEBUG_9P, "fid %d offset %llu count %d\n", fid->fid,
 522                                         (long long unsigned) offset, count);
 523         err = 0;
 524         tc = NULL;
 525         rc = NULL;
 526         clnt = fid->clnt;
 527         total = 0;
 528
 529         rsize = fid->iounit;
 530         if (!rsize || rsize > clnt->msize-P9_IOHDRSZ)
 531                 rsize = clnt->msize - P9_IOHDRSZ;
 532
 533         do {
 534                 if (count < rsize)
 535                         rsize = count;
 536
 537                 tc = p9_create_twrite(fid->fid, offset, rsize, data);
 538                 if (IS_ERR(tc)) {
 539                         err = PTR_ERR(tc);
 540                         tc = NULL;
 541                         goto error;
 542                 }
 543
 544                 err = p9_conn_rpc(clnt->conn, tc, &rc);
 545                 if (err)
 546                         goto error;
 547
 548                 n = rc->params.rread.count;
 549                 count -= n;
 550                 data += n;
 551                 offset += n;
 552                 total += n;
 553                 kfree(tc);
 554                 tc = NULL;
 555                 kfree(rc);
 556                 rc = NULL;
 557         } while (count > 0);
 558
 559         return total;
 560
 561 error:
 562         kfree(tc);
 563         kfree(rc);
 564         return err;
 565 }
 566 EXPORT_SYMBOL(p9_client_write);
 567
 568 int
 569 p9_client_uread(struct p9_fid *fid, char __user *data, u64 offset, u32 count)
 570 {
 571         int err, n, rsize, total;
 572         struct p9_fcall *tc, *rc;
 573         struct p9_client *clnt;
 574
 575         P9_DPRINTK(P9_DEBUG_9P, "fid %d offset %llu count %d\n", fid->fid,
 576                                         (long long unsigned) offset, count);
 577         err = 0;
 578         tc = NULL;
 579         rc = NULL;
 580         clnt = fid->clnt;
 581         total = 0;
 582
 583         rsize = fid->iounit;
 584         if (!rsize || rsize > clnt->msize-P9_IOHDRSZ)
 585                 rsize = clnt->msize - P9_IOHDRSZ;
 586
 587         do {
 588                 if (count < rsize)
 589                         rsize = count;
 590
 591                 tc = p9_create_tread(fid->fid, offset, rsize);
 592                 if (IS_ERR(tc)) {
 593                         err = PTR_ERR(tc);
 594                         tc = NULL;
 595                         goto error;
 596                 }
 597
 598                 err = p9_conn_rpc(clnt->conn, tc, &rc);
 599                 if (err)
 600                         goto error;
 601
 602                 n = rc->params.rread.count;
 603                 if (n > count)
 604                         n = count;
 605
 606                 err = copy_to_user(data, rc->params.rread.data, n);
 607                 if (err) {
 608                         err = -EFAULT;
 609                         goto error;
 610                 }
 611
 612                 count -= n;
 613                 data += n;
 614                 offset += n;
 615                 total += n;
 616                 kfree(tc);
 617                 tc = NULL;
 618                 kfree(rc);
 619                 rc = NULL;
 620         } while (count > 0 && n == rsize);
 621
 622         return total;
 623
 624 error:
 625         kfree(tc);
 626         kfree(rc);
 627         return err;
 628 }
 629 EXPORT_SYMBOL(p9_client_uread);
 630
 631 int
 632 p9_client_uwrite(struct p9_fid *fid, const char __user *data, u64 offset,
 633                                                                    u32 count)
 634 {
 635         int err, n, rsize, total;
 636         struct p9_fcall *tc, *rc;
 637         struct p9_client *clnt;
 638
 639         P9_DPRINTK(P9_DEBUG_9P, "fid %d offset %llu count %d\n", fid->fid,
 640                                         (long long unsigned) offset, count);
 641         err = 0;
 642         tc = NULL;
 643         rc = NULL;
 644         clnt = fid->clnt;
 645         total = 0;
 646
 647         rsize = fid->iounit;
 648         if (!rsize || rsize > clnt->msize-P9_IOHDRSZ)
 649                 rsize = clnt->msize - P9_IOHDRSZ;
 650
 651         do {
 652                 if (count < rsize)
 653                         rsize = count;
 654
 655                 tc = p9_create_twrite_u(fid->fid, offset, rsize, data);
 656                 if (IS_ERR(tc)) {
 657                         err = PTR_ERR(tc);
 658                         tc = NULL;
 659                         goto error;
 660                 }
 661
 662                 err = p9_conn_rpc(clnt->conn, tc, &rc);
 663                 if (err)
 664                         goto error;
 665
 666                 n = rc->params.rread.count;
 667                 count -= n;
 668                 data += n;
 669                 offset += n;
 670                 total += n;
 671                 kfree(tc);
 672                 tc = NULL;
 673                 kfree(rc);
 674                 rc = NULL;
 675         } while (count > 0);
 676
 677         return total;
 678
 679 error:
 680         kfree(tc);
 681         kfree(rc);
 682         return err;
 683 }
 684 EXPORT_SYMBOL(p9_client_uwrite);
 685
 686 int p9_client_readn(struct p9_fid *fid, char *data, u64 offset, u32 count)
 687 {
 688         int n, total;
 689
 690         P9_DPRINTK(P9_DEBUG_9P, "fid %d offset %llu count %d\n", fid->fid,
 691                                         (long long unsigned) offset, count);
 692         n = 0;
 693         total = 0;
 694         while (count) {
 695                 n = p9_client_read(fid, data, offset, count);
 696                 if (n <= 0)
 697                         break;
 698
 699                 data += n;
 700                 offset += n;
 701                 count -= n;
 702                 total += n;
 703         }
 704
 705         if (n < 0)
 706                 total = n;
 707
 708         return total;
 709 }
 710 EXPORT_SYMBOL(p9_client_readn);
 711
 712 struct p9_stat *p9_client_stat(struct p9_fid *fid)
 713 {
 714         int err;
 715         struct p9_fcall *tc, *rc;
 716         struct p9_client *clnt;
 717         struct p9_stat *ret;
 718
 719         P9_DPRINTK(P9_DEBUG_9P, "fid %d\n", fid->fid);
 720         err = 0;
 721         tc = NULL;
 722         rc = NULL;
 723         ret = NULL;
 724         clnt = fid->clnt;
 725
 726         tc = p9_create_tstat(fid->fid);
 727         if (IS_ERR(tc)) {
 728                 err = PTR_ERR(tc);
 729                 tc = NULL;
 730                 goto error;
 731         }
 732
 733         err = p9_conn_rpc(clnt->conn, tc, &rc);
 734         if (err)
 735                 goto error;
 736
 737         ret = p9_clone_stat(&rc->params.rstat.stat, clnt->dotu);
 738         if (IS_ERR(ret)) {
 739                 err = PTR_ERR(ret);
 740                 ret = NULL;
 741                 goto error;
 742         }
 743
 744         kfree(tc);
 745         kfree(rc);
 746         return ret;
 747
 748 error:
 749         kfree(tc);
 750         kfree(rc);
 751         kfree(ret);
 752         return ERR_PTR(err);
 753 }
 754 EXPORT_SYMBOL(p9_client_stat);
 755
 756 int p9_client_wstat(struct p9_fid *fid, struct p9_wstat *wst)
 757 {
 758         int err;
 759         struct p9_fcall *tc, *rc;
 760         struct p9_client *clnt;
 761
 762         P9_DPRINTK(P9_DEBUG_9P, "fid %d\n", fid->fid);
 763         err = 0;
 764         tc = NULL;
 765         rc = NULL;
 766         clnt = fid->clnt;
 767
 768         tc = p9_create_twstat(fid->fid, wst, clnt->dotu);
 769         if (IS_ERR(tc)) {
 770                 err = PTR_ERR(tc);
 771                 tc = NULL;
 772                 goto done;
 773         }
 774
 775         err = p9_conn_rpc(clnt->conn, tc, &rc);
 776
 777 done:
 778         kfree(tc);
 779         kfree(rc);
 780         return err;
 781 }
 782 EXPORT_SYMBOL(p9_client_wstat);
 783
 784 struct p9_stat *p9_client_dirread(struct p9_fid *fid, u64 offset)
 785 {
 786         int err, n, m;
 787         struct p9_fcall *tc, *rc;
 788         struct p9_client *clnt;
 789         struct p9_stat st, *ret;
 790
 791         P9_DPRINTK(P9_DEBUG_9P, "fid %d offset %llu\n", fid->fid,
 792                                                 (long long unsigned) offset);
 793         err = 0;
 794         tc = NULL;
 795         rc = NULL;
 796         ret = NULL;
 797         clnt = fid->clnt;
 798
 799         /* if the offset is below or above the current response, free it */
 800         if (offset < fid->rdir_fpos || (fid->rdir_fcall &&
 801                 offset >= fid->rdir_fpos+fid->rdir_fcall->params.rread.count)) {
 802                 fid->rdir_pos = 0;
 803                 if (fid->rdir_fcall)
 804                         fid->rdir_fpos += fid->rdir_fcall->params.rread.count;
 805
 806                 kfree(fid->rdir_fcall);
 807                 fid->rdir_fcall = NULL;
 808                 if (offset < fid->rdir_fpos)
 809                         fid->rdir_fpos = 0;
 810         }
 811
 812         if (!fid->rdir_fcall) {
 813                 n = fid->iounit;
 814                 if (!n || n > clnt->msize-P9_IOHDRSZ)
 815                         n = clnt->msize - P9_IOHDRSZ;
 816
 817                 while (1) {
 818                         if (fid->rdir_fcall) {
 819                                 fid->rdir_fpos +=
 820                                         fid->rdir_fcall->params.rread.count;
 821                                 kfree(fid->rdir_fcall);
 822                                 fid->rdir_fcall = NULL;
 823                         }
 824
 825                         tc = p9_create_tread(fid->fid, fid->rdir_fpos, n);
 826                         if (IS_ERR(tc)) {
 827                                 err = PTR_ERR(tc);
 828                                 tc = NULL;
 829                                 goto error;
 830                         }
 831
 832                         err = p9_conn_rpc(clnt->conn, tc, &rc);
 833                         if (err)
 834                                 goto error;
 835
 836                         n = rc->params.rread.count;
 837                         if (n == 0)
 838                                 goto done;
 839
 840                         fid->rdir_fcall = rc;
 841                         rc = NULL;
 842                         if (offset >= fid->rdir_fpos &&
 843                                                 offset < fid->rdir_fpos+n)
 844                                 break;
 845                 }
 846
 847                 fid->rdir_pos = 0;
 848         }
 849
 850         m = offset - fid->rdir_fpos;
 851         if (m < 0)
 852                 goto done;
 853
 854         n = p9_deserialize_stat(fid->rdir_fcall->params.rread.data + m,
 855                 fid->rdir_fcall->params.rread.count - m, &st, clnt->dotu);
 856
 857         if (!n) {
 858                 err = -EIO;
 859                 goto error;
 860         }
 861
 862         fid->rdir_pos += n;
 863         st.size = n;
 864         ret = p9_clone_stat(&st, clnt->dotu);
 865         if (IS_ERR(ret)) {
 866                 err = PTR_ERR(ret);
 867                 ret = NULL;
 868                 goto error;
 869         }
 870
 871 done:
 872         kfree(tc);
 873         kfree(rc);
 874         return ret;
 875
 876 error:
 877         kfree(tc);
 878         kfree(rc);
 879         kfree(ret);
 880         return ERR_PTR(err);
 881 }
 882 EXPORT_SYMBOL(p9_client_dirread);
 883
 884 static struct p9_stat *p9_clone_stat(struct p9_stat *st, int dotu)
 885 {
 886         int n;
 887         char *p;
 888         struct p9_stat *ret;
 889
 890         n = sizeof(struct p9_stat) + st->name.len + st->uid.len + st->gid.len +
 891                 st->muid.len;
 892
 893         if (dotu)
 894                 n += st->extension.len;
 895
 896         ret = kmalloc(n, GFP_KERNEL);
 897         if (!ret)
 898                 return ERR_PTR(-ENOMEM);
 899
 900         memmove(ret, st, sizeof(struct p9_stat));
 901         p = ((char *) ret) + sizeof(struct p9_stat);
 902         memmove(p, st->name.str, st->name.len);
 903         p += st->name.len;
 904         memmove(p, st->uid.str, st->uid.len);
 905         p += st->uid.len;
 906         memmove(p, st->gid.str, st->gid.len);
 907         p += st->gid.len;
 908         memmove(p, st->muid.str, st->muid.len);
 909         p += st->muid.len;
 910
 911         if (dotu) {
 912                 memmove(p, st->extension.str, st->extension.len);
 913                 p += st->extension.len;
 914         }
 915
 916         return ret;
 917 }
 918
 919 static struct p9_fid *p9_fid_create(struct p9_client *clnt)
 920 {
 921         int err;
 922         struct p9_fid *fid;
 923
 924         P9_DPRINTK(P9_DEBUG_9P, "clnt %p\n", clnt);
 925         fid = kmalloc(sizeof(struct p9_fid), GFP_KERNEL);
 926         if (!fid)
 927                 return ERR_PTR(-ENOMEM);
 928
 929         fid->fid = p9_idpool_get(clnt->fidpool);
 930         if (fid->fid < 0) {
 931                 err = -ENOSPC;
 932                 goto error;
 933         }
 934
 935         memset(&fid->qid, 0, sizeof(struct p9_qid));
 936         fid->mode = -1;
 937         fid->rdir_fpos = 0;
 938         fid->rdir_pos = 0;
 939         fid->rdir_fcall = NULL;
 940         fid->uid = current->fsuid;
 941         fid->clnt = clnt;
 942         fid->aux = NULL;
 943
 944         spin_lock(&clnt->lock);
 945         list_add(&fid->flist, &clnt->fidlist);
 946         spin_unlock(&clnt->lock);
 947
 948         return fid;
 949
 950 error:
 951         kfree(fid);
 952         return ERR_PTR(err);
 953 }
 954
 955 static void p9_fid_destroy(struct p9_fid *fid)
 956 {
 957         struct p9_client *clnt;
 958
 959         P9_DPRINTK(P9_DEBUG_9P, "fid %d\n", fid->fid);
 960         clnt = fid->clnt;
 961         p9_idpool_put(fid->fid, clnt->fidpool);
 962         spin_lock(&clnt->lock);
 963         list_del(&fid->flist);
 964         spin_unlock(&clnt->lock);
 965         kfree(fid->rdir_fcall);
 966         kfree(fid);
 967 }