net/9p/conv.c

   1 /*
   2  * net/9p/conv.c
   3  *
   4  * 9P protocol conversion functions
   5  *
   6  *  Copyright (C) 2004, 2005 by Latchesar Ionkov <lucho@ionkov.net>
   7  *  Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
   8  *  Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
   9  *
  10  *  This program is free software; you can redistribute it and/or modify
  11  *  it under the terms of the GNU General Public License version 2
  12  *  as published by the Free Software Foundation.
  13  *
  14  *  This program is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program; if not, write to:
  21  *  Free Software Foundation
  22  *  51 Franklin Street, Fifth Floor
  23  *  Boston, MA  02111-1301  USA
  24  *
  25  */
  26
  27 #include <linux/module.h>
  28 #include <linux/errno.h>
  29 #include <linux/fs.h>
  30 #include <linux/sched.h>
  31 #include <linux/idr.h>
  32 #include <linux/uaccess.h>
  33 #include <net/9p/9p.h>
  34
  35 /*
  36  * Buffer to help with string parsing
  37  */
  38 struct cbuf {
  39         unsigned char *sp;
  40         unsigned char *p;
  41         unsigned char *ep;
  42 };
  43
  44 static inline void buf_init(struct cbuf *buf, void *data, int datalen)
  45 {
  46         buf->sp = buf->p = data;
  47         buf->ep = data + datalen;
  48 }
  49
  50 static inline int buf_check_overflow(struct cbuf *buf)
  51 {
  52         return buf->p > buf->ep;
  53 }
  54
  55 static int buf_check_size(struct cbuf *buf, int len)
  56 {
  57         if (buf->p + len > buf->ep) {
  58                 if (buf->p < buf->ep) {
  59                         P9_EPRINTK(KERN_ERR,
  60                                 "buffer overflow: want %d has %d\n", len,
  61                                 (int)(buf->ep - buf->p));
  62                         dump_stack();
  63                         buf->p = buf->ep + 1;
  64                 }
  65
  66                 return 0;
  67         }
  68
  69         return 1;
  70 }
  71
  72 static void *buf_alloc(struct cbuf *buf, int len)
  73 {
  74         void *ret = NULL;
  75
  76         if (buf_check_size(buf, len)) {
  77                 ret = buf->p;
  78                 buf->p += len;
  79         }
  80
  81         return ret;
  82 }
  83
  84 static void buf_put_int8(struct cbuf *buf, u8 val)
  85 {
  86         if (buf_check_size(buf, 1)) {
  87                 buf->p[0] = val;
  88                 buf->p++;
  89         }
  90 }
  91
  92 static void buf_put_int16(struct cbuf *buf, u16 val)
  93 {
  94         if (buf_check_size(buf, 2)) {
  95                 *(__le16 *) buf->p = cpu_to_le16(val);
  96                 buf->p += 2;
  97         }
  98 }
  99
 100 static void buf_put_int32(struct cbuf *buf, u32 val)
 101 {
 102         if (buf_check_size(buf, 4)) {
 103                 *(__le32 *)buf->p = cpu_to_le32(val);
 104                 buf->p += 4;
 105         }
 106 }
 107
 108 static void buf_put_int64(struct cbuf *buf, u64 val)
 109 {
 110         if (buf_check_size(buf, 8)) {
 111                 *(__le64 *)buf->p = cpu_to_le64(val);
 112                 buf->p += 8;
 113         }
 114 }
 115
 116 static char *buf_put_stringn(struct cbuf *buf, const char *s, u16 slen)
 117 {
 118         char *ret;
 119
 120         ret = NULL;
 121         if (buf_check_size(buf, slen + 2)) {
 122                 buf_put_int16(buf, slen);
 123                 ret = buf->p;
 124                 memcpy(buf->p, s, slen);
 125                 buf->p += slen;
 126         }
 127
 128         return ret;
 129 }
 130
 131 static inline void buf_put_string(struct cbuf *buf, const char *s)
 132 {
 133         buf_put_stringn(buf, s, strlen(s));
 134 }
 135
 136 static u8 buf_get_int8(struct cbuf *buf)
 137 {
 138         u8 ret = 0;
 139
 140         if (buf_check_size(buf, 1)) {
 141                 ret = buf->p[0];
 142                 buf->p++;
 143         }
 144
 145         return ret;
 146 }
 147
 148 static u16 buf_get_int16(struct cbuf *buf)
 149 {
 150         u16 ret = 0;
 151
 152         if (buf_check_size(buf, 2)) {
 153                 ret = le16_to_cpu(*(__le16 *)buf->p);
 154                 buf->p += 2;
 155         }
 156
 157         return ret;
 158 }
 159
 160 static u32 buf_get_int32(struct cbuf *buf)
 161 {
 162         u32 ret = 0;
 163
 164         if (buf_check_size(buf, 4)) {
 165                 ret = le32_to_cpu(*(__le32 *)buf->p);
 166                 buf->p += 4;
 167         }
 168
 169         return ret;
 170 }
 171
 172 static u64 buf_get_int64(struct cbuf *buf)
 173 {
 174         u64 ret = 0;
 175
 176         if (buf_check_size(buf, 8)) {
 177                 ret = le64_to_cpu(*(__le64 *)buf->p);
 178                 buf->p += 8;
 179         }
 180
 181         return ret;
 182 }
 183
 184 static void buf_get_str(struct cbuf *buf, struct p9_str *vstr)
 185 {
 186         vstr->len = buf_get_int16(buf);
 187         if (!buf_check_overflow(buf) && buf_check_size(buf, vstr->len)) {
 188                 vstr->str = buf->p;
 189                 buf->p += vstr->len;
 190         } else {
 191                 vstr->len = 0;
 192                 vstr->str = NULL;
 193         }
 194 }
 195
 196 static void buf_get_qid(struct cbuf *bufp, struct p9_qid *qid)
 197 {
 198         qid->type = buf_get_int8(bufp);
 199         qid->version = buf_get_int32(bufp);
 200         qid->path = buf_get_int64(bufp);
 201 }
 202
 203 /**
 204  * p9_size_wstat - calculate the size of a variable length stat struct
 205  * @stat: metadata (stat) structure
 206  * @dotu: non-zero if 9P2000.u
 207  *
 208  */
 209
 210 static int p9_size_wstat(struct p9_wstat *wstat, int dotu)
 211 {
 212         int size = 0;
 213
 214         if (wstat == NULL) {
 215                 P9_EPRINTK(KERN_ERR, "p9_size_stat: got a NULL stat pointer\n");
 216                 return 0;
 217         }
 218
 219         size =                  /* 2 + *//* size[2] */
 220             2 +                 /* type[2] */
 221             4 +                 /* dev[4] */
 222             1 +                 /* qid.type[1] */
 223             4 +                 /* qid.vers[4] */
 224             8 +                 /* qid.path[8] */
 225             4 +                 /* mode[4] */
 226             4 +                 /* atime[4] */
 227             4 +                 /* mtime[4] */
 228             8 +                 /* length[8] */
 229             8;                  /* minimum sum of string lengths */
 230
 231         if (wstat->name)
 232                 size += strlen(wstat->name);
 233         if (wstat->uid)
 234                 size += strlen(wstat->uid);
 235         if (wstat->gid)
 236                 size += strlen(wstat->gid);
 237         if (wstat->muid)
 238                 size += strlen(wstat->muid);
 239
 240         if (dotu) {
 241                 size += 4 +     /* n_uid[4] */
 242                     4 +         /* n_gid[4] */
 243                     4 +         /* n_muid[4] */
 244                     2;          /* string length of extension[4] */
 245                 if (wstat->extension)
 246                         size += strlen(wstat->extension);
 247         }
 248
 249         return size;
 250 }
 251
 252 /**
 253  * buf_get_stat - safely decode a recieved metadata (stat) structure
 254  * @bufp: buffer to deserialize
 255  * @stat: metadata (stat) structure
 256  * @dotu: non-zero if 9P2000.u
 257  *
 258  */
 259
 260 static void
 261 buf_get_stat(struct cbuf *bufp, struct p9_stat *stat, int dotu)
 262 {
 263         stat->size = buf_get_int16(bufp);
 264         stat->type = buf_get_int16(bufp);
 265         stat->dev = buf_get_int32(bufp);
 266         stat->qid.type = buf_get_int8(bufp);
 267         stat->qid.version = buf_get_int32(bufp);
 268         stat->qid.path = buf_get_int64(bufp);
 269         stat->mode = buf_get_int32(bufp);
 270         stat->atime = buf_get_int32(bufp);
 271         stat->mtime = buf_get_int32(bufp);
 272         stat->length = buf_get_int64(bufp);
 273         buf_get_str(bufp, &stat->name);
 274         buf_get_str(bufp, &stat->uid);
 275         buf_get_str(bufp, &stat->gid);
 276         buf_get_str(bufp, &stat->muid);
 277
 278         if (dotu) {
 279                 buf_get_str(bufp, &stat->extension);
 280                 stat->n_uid = buf_get_int32(bufp);
 281                 stat->n_gid = buf_get_int32(bufp);
 282                 stat->n_muid = buf_get_int32(bufp);
 283         }
 284 }
 285
 286 /**
 287  * p9_deserialize_stat - decode a received metadata structure
 288  * @buf: buffer to deserialize
 289  * @buflen: length of received buffer
 290  * @stat: metadata structure to decode into
 291  * @dotu: non-zero if 9P2000.u
 292  *
 293  * Note: stat will point to the buf region.
 294  */
 295
 296 int
 297 p9_deserialize_stat(void *buf, u32 buflen, struct p9_stat *stat,
 298                 int dotu)
 299 {
 300         struct cbuf buffer;
 301         struct cbuf *bufp = &buffer;
 302         unsigned char *p;
 303
 304         buf_init(bufp, buf, buflen);
 305         p = bufp->p;
 306         buf_get_stat(bufp, stat, dotu);
 307
 308         if (buf_check_overflow(bufp))
 309                 return 0;
 310         else
 311                 return bufp->p - p;
 312 }
 313 EXPORT_SYMBOL(p9_deserialize_stat);
 314
 315 /**
 316  * deserialize_fcall - unmarshal a response
 317  * @buf: recieved buffer
 318  * @buflen: length of received buffer
 319  * @rcall: fcall structure to populate
 320  * @rcalllen: length of fcall structure to populate
 321  * @dotu: non-zero if 9P2000.u
 322  *
 323  */
 324
 325 int
 326 p9_deserialize_fcall(void *buf, u32 buflen, struct p9_fcall *rcall,
 327                        int dotu)
 328 {
 329
 330         struct cbuf buffer;
 331         struct cbuf *bufp = &buffer;
 332         int i = 0;
 333
 334         buf_init(bufp, buf, buflen);
 335
 336         rcall->size = buf_get_int32(bufp);
 337         rcall->id = buf_get_int8(bufp);
 338         rcall->tag = buf_get_int16(bufp);
 339
 340         P9_DPRINTK(P9_DEBUG_CONV, "size %d id %d tag %d\n", rcall->size,
 341                                                         rcall->id, rcall->tag);
 342
 343         switch (rcall->id) {
 344         default:
 345                 P9_EPRINTK(KERN_ERR, "unknown message type: %d\n", rcall->id);
 346                 return -EPROTO;
 347         case P9_RVERSION:
 348                 rcall->params.rversion.msize = buf_get_int32(bufp);
 349                 buf_get_str(bufp, &rcall->params.rversion.version);
 350                 break;
 351         case P9_RFLUSH:
 352                 break;
 353         case P9_RATTACH:
 354                 rcall->params.rattach.qid.type = buf_get_int8(bufp);
 355                 rcall->params.rattach.qid.version = buf_get_int32(bufp);
 356                 rcall->params.rattach.qid.path = buf_get_int64(bufp);
 357                 break;
 358         case P9_RWALK:
 359                 rcall->params.rwalk.nwqid = buf_get_int16(bufp);
 360                 if (rcall->params.rwalk.nwqid > P9_MAXWELEM) {
 361                         P9_EPRINTK(KERN_ERR,
 362                                         "Rwalk with more than %d qids: %d\n",
 363                                         P9_MAXWELEM, rcall->params.rwalk.nwqid);
 364                         return -EPROTO;
 365                 }
 366
 367                 for (i = 0; i < rcall->params.rwalk.nwqid; i++)
 368                         buf_get_qid(bufp, &rcall->params.rwalk.wqids[i]);
 369                 break;
 370         case P9_ROPEN:
 371                 buf_get_qid(bufp, &rcall->params.ropen.qid);
 372                 rcall->params.ropen.iounit = buf_get_int32(bufp);
 373                 break;
 374         case P9_RCREATE:
 375                 buf_get_qid(bufp, &rcall->params.rcreate.qid);
 376                 rcall->params.rcreate.iounit = buf_get_int32(bufp);
 377                 break;
 378         case P9_RREAD:
 379                 rcall->params.rread.count = buf_get_int32(bufp);
 380                 rcall->params.rread.data = bufp->p;
 381                 buf_check_size(bufp, rcall->params.rread.count);
 382                 break;
 383         case P9_RWRITE:
 384                 rcall->params.rwrite.count = buf_get_int32(bufp);
 385                 break;
 386         case P9_RCLUNK:
 387                 break;
 388         case P9_RREMOVE:
 389                 break;
 390         case P9_RSTAT:
 391                 buf_get_int16(bufp);
 392                 buf_get_stat(bufp, &rcall->params.rstat.stat, dotu);
 393                 break;
 394         case P9_RWSTAT:
 395                 break;
 396         case P9_RERROR:
 397                 buf_get_str(bufp, &rcall->params.rerror.error);
 398                 if (dotu)
 399                         rcall->params.rerror.errno = buf_get_int16(bufp);
 400                 break;
 401         }
 402
 403         if (buf_check_overflow(bufp)) {
 404                 P9_DPRINTK(P9_DEBUG_ERROR, "buffer overflow\n");
 405                 return -EIO;
 406         }
 407
 408         return bufp->p - bufp->sp;
 409 }
 410 EXPORT_SYMBOL(p9_deserialize_fcall);
 411
 412 static inline void p9_put_int8(struct cbuf *bufp, u8 val, u8 * p)
 413 {
 414         *p = val;
 415         buf_put_int8(bufp, val);
 416 }
 417
 418 static inline void p9_put_int16(struct cbuf *bufp, u16 val, u16 * p)
 419 {
 420         *p = val;
 421         buf_put_int16(bufp, val);
 422 }
 423
 424 static inline void p9_put_int32(struct cbuf *bufp, u32 val, u32 * p)
 425 {
 426         *p = val;
 427         buf_put_int32(bufp, val);
 428 }
 429
 430 static inline void p9_put_int64(struct cbuf *bufp, u64 val, u64 * p)
 431 {
 432         *p = val;
 433         buf_put_int64(bufp, val);
 434 }
 435
 436 static void
 437 p9_put_str(struct cbuf *bufp, char *data, struct p9_str *str)
 438 {
 439         int len;
 440         char *s;
 441
 442         if (data)
 443                 len = strlen(data);
 444         else
 445                 len = 0;
 446
 447         s = buf_put_stringn(bufp, data, len);
 448         if (str) {
 449                 str->len = len;
 450                 str->str = s;
 451         }
 452 }
 453
 454 static int
 455 p9_put_data(struct cbuf *bufp, const char *data, int count,
 456                    unsigned char **pdata)
 457 {
 458         *pdata = buf_alloc(bufp, count);
 459         memmove(*pdata, data, count);
 460         return count;
 461 }
 462
 463 static int
 464 p9_put_user_data(struct cbuf *bufp, const char __user *data, int count,
 465                    unsigned char **pdata)
 466 {
 467         *pdata = buf_alloc(bufp, count);
 468         return copy_from_user(*pdata, data, count);
 469 }
 470
 471 static void
 472 p9_put_wstat(struct cbuf *bufp, struct p9_wstat *wstat,
 473                struct p9_stat *stat, int statsz, int dotu)
 474 {
 475         p9_put_int16(bufp, statsz, &stat->size);
 476         p9_put_int16(bufp, wstat->type, &stat->type);
 477         p9_put_int32(bufp, wstat->dev, &stat->dev);
 478         p9_put_int8(bufp, wstat->qid.type, &stat->qid.type);
 479         p9_put_int32(bufp, wstat->qid.version, &stat->qid.version);
 480         p9_put_int64(bufp, wstat->qid.path, &stat->qid.path);
 481         p9_put_int32(bufp, wstat->mode, &stat->mode);
 482         p9_put_int32(bufp, wstat->atime, &stat->atime);
 483         p9_put_int32(bufp, wstat->mtime, &stat->mtime);
 484         p9_put_int64(bufp, wstat->length, &stat->length);
 485
 486         p9_put_str(bufp, wstat->name, &stat->name);
 487         p9_put_str(bufp, wstat->uid, &stat->uid);
 488         p9_put_str(bufp, wstat->gid, &stat->gid);
 489         p9_put_str(bufp, wstat->muid, &stat->muid);
 490
 491         if (dotu) {
 492                 p9_put_str(bufp, wstat->extension, &stat->extension);
 493                 p9_put_int32(bufp, wstat->n_uid, &stat->n_uid);
 494                 p9_put_int32(bufp, wstat->n_gid, &stat->n_gid);
 495                 p9_put_int32(bufp, wstat->n_muid, &stat->n_muid);
 496         }
 497 }
 498
 499 static struct p9_fcall *
 500 p9_create_common(struct cbuf *bufp, u32 size, u8 id)
 501 {
 502         struct p9_fcall *fc;
 503
 504         size += 4 + 1 + 2;      /* size[4] id[1] tag[2] */
 505         fc = kmalloc(sizeof(struct p9_fcall) + size, GFP_KERNEL);
 506         if (!fc)
 507                 return ERR_PTR(-ENOMEM);
 508
 509         fc->sdata = (char *)fc + sizeof(*fc);
 510
 511         buf_init(bufp, (char *)fc->sdata, size);
 512         p9_put_int32(bufp, size, &fc->size);
 513         p9_put_int8(bufp, id, &fc->id);
 514         p9_put_int16(bufp, P9_NOTAG, &fc->tag);
 515
 516         return fc;
 517 }
 518
 519 void p9_set_tag(struct p9_fcall *fc, u16 tag)
 520 {
 521         fc->tag = tag;
 522         *(__le16 *) (fc->sdata + 5) = cpu_to_le16(tag);
 523 }
 524 EXPORT_SYMBOL(p9_set_tag);
 525
 526 struct p9_fcall *p9_create_tversion(u32 msize, char *version)
 527 {
 528         int size;
 529         struct p9_fcall *fc;
 530         struct cbuf buffer;
 531         struct cbuf *bufp = &buffer;
 532
 533         size = 4 + 2 + strlen(version); /* msize[4] version[s] */
 534         fc = p9_create_common(bufp, size, P9_TVERSION);
 535         if (IS_ERR(fc))
 536                 goto error;
 537
 538         p9_put_int32(bufp, msize, &fc->params.tversion.msize);
 539         p9_put_str(bufp, version, &fc->params.tversion.version);
 540
 541         if (buf_check_overflow(bufp)) {
 542                 kfree(fc);
 543                 fc = ERR_PTR(-ENOMEM);
 544         }
 545 error:
 546         return fc;
 547 }
 548 EXPORT_SYMBOL(p9_create_tversion);
 549
 550 struct p9_fcall *p9_create_tauth(u32 afid, char *uname, char *aname,
 551         u32 n_uname, int dotu)
 552 {
 553         int size;
 554         struct p9_fcall *fc;
 555         struct cbuf buffer;
 556         struct cbuf *bufp = &buffer;
 557
 558         /* afid[4] uname[s] aname[s] */
 559         size = 4 + 2 + 2;
 560         if (uname)
 561                 size += strlen(uname);
 562
 563         if (aname)
 564                 size += strlen(aname);
 565
 566         if (dotu)
 567                 size += 4;      /* n_uname */
 568
 569         fc = p9_create_common(bufp, size, P9_TAUTH);
 570         if (IS_ERR(fc))
 571                 goto error;
 572
 573         p9_put_int32(bufp, afid, &fc->params.tauth.afid);
 574         p9_put_str(bufp, uname, &fc->params.tauth.uname);
 575         p9_put_str(bufp, aname, &fc->params.tauth.aname);
 576         if (dotu)
 577                 p9_put_int32(bufp, n_uname, &fc->params.tauth.n_uname);
 578
 579         if (buf_check_overflow(bufp)) {
 580                 kfree(fc);
 581                 fc = ERR_PTR(-ENOMEM);
 582         }
 583 error:
 584         return fc;
 585 }
 586 EXPORT_SYMBOL(p9_create_tauth);
 587
 588 struct p9_fcall *
 589 p9_create_tattach(u32 fid, u32 afid, char *uname, char *aname,
 590         u32 n_uname, int dotu)
 591 {
 592         int size;
 593         struct p9_fcall *fc;
 594         struct cbuf buffer;
 595         struct cbuf *bufp = &buffer;
 596
 597         /* fid[4] afid[4] uname[s] aname[s] */
 598         size = 4 + 4 + 2 + 2;
 599         if (uname)
 600                 size += strlen(uname);
 601
 602         if (aname)
 603                 size += strlen(aname);
 604
 605         if (dotu)
 606                 size += 4;      /* n_uname */
 607
 608         fc = p9_create_common(bufp, size, P9_TATTACH);
 609         if (IS_ERR(fc))
 610                 goto error;
 611
 612         p9_put_int32(bufp, fid, &fc->params.tattach.fid);
 613         p9_put_int32(bufp, afid, &fc->params.tattach.afid);
 614         p9_put_str(bufp, uname, &fc->params.tattach.uname);
 615         p9_put_str(bufp, aname, &fc->params.tattach.aname);
 616         if (dotu)
 617                 p9_put_int32(bufp, n_uname, &fc->params.tattach.n_uname);
 618
 619 error:
 620         return fc;
 621 }
 622 EXPORT_SYMBOL(p9_create_tattach);
 623
 624 struct p9_fcall *p9_create_tflush(u16 oldtag)
 625 {
 626         int size;
 627         struct p9_fcall *fc;
 628         struct cbuf buffer;
 629         struct cbuf *bufp = &buffer;
 630
 631         size = 2;               /* oldtag[2] */
 632         fc = p9_create_common(bufp, size, P9_TFLUSH);
 633         if (IS_ERR(fc))
 634                 goto error;
 635
 636         p9_put_int16(bufp, oldtag, &fc->params.tflush.oldtag);
 637
 638         if (buf_check_overflow(bufp)) {
 639                 kfree(fc);
 640                 fc = ERR_PTR(-ENOMEM);
 641         }
 642 error:
 643         return fc;
 644 }
 645 EXPORT_SYMBOL(p9_create_tflush);
 646
 647 struct p9_fcall *p9_create_twalk(u32 fid, u32 newfid, u16 nwname,
 648                                      char **wnames)
 649 {
 650         int i, size;
 651         struct p9_fcall *fc;
 652         struct cbuf buffer;
 653         struct cbuf *bufp = &buffer;
 654
 655         if (nwname > P9_MAXWELEM) {
 656                 P9_DPRINTK(P9_DEBUG_ERROR, "nwname > %d\n", P9_MAXWELEM);
 657                 return NULL;
 658         }
 659
 660         size = 4 + 4 + 2;       /* fid[4] newfid[4] nwname[2] ... */
 661         for (i = 0; i < nwname; i++) {
 662                 size += 2 + strlen(wnames[i]);  /* wname[s] */
 663         }
 664
 665         fc = p9_create_common(bufp, size, P9_TWALK);
 666         if (IS_ERR(fc))
 667                 goto error;
 668
 669         p9_put_int32(bufp, fid, &fc->params.twalk.fid);
 670         p9_put_int32(bufp, newfid, &fc->params.twalk.newfid);
 671         p9_put_int16(bufp, nwname, &fc->params.twalk.nwname);
 672         for (i = 0; i < nwname; i++) {
 673                 p9_put_str(bufp, wnames[i], &fc->params.twalk.wnames[i]);
 674         }
 675
 676         if (buf_check_overflow(bufp)) {
 677                 kfree(fc);
 678                 fc = ERR_PTR(-ENOMEM);
 679         }
 680 error:
 681         return fc;
 682 }
 683 EXPORT_SYMBOL(p9_create_twalk);
 684
 685 struct p9_fcall *p9_create_topen(u32 fid, u8 mode)
 686 {
 687         int size;
 688         struct p9_fcall *fc;
 689         struct cbuf buffer;
 690         struct cbuf *bufp = &buffer;
 691
 692         size = 4 + 1;           /* fid[4] mode[1] */
 693         fc = p9_create_common(bufp, size, P9_TOPEN);
 694         if (IS_ERR(fc))
 695                 goto error;
 696
 697         p9_put_int32(bufp, fid, &fc->params.topen.fid);
 698         p9_put_int8(bufp, mode, &fc->params.topen.mode);
 699
 700         if (buf_check_overflow(bufp)) {
 701                 kfree(fc);
 702                 fc = ERR_PTR(-ENOMEM);
 703         }
 704 error:
 705         return fc;
 706 }
 707 EXPORT_SYMBOL(p9_create_topen);
 708
 709 struct p9_fcall *p9_create_tcreate(u32 fid, char *name, u32 perm, u8 mode,
 710         char *extension, int dotu)
 711 {
 712         int size;
 713         struct p9_fcall *fc;
 714         struct cbuf buffer;
 715         struct cbuf *bufp = &buffer;
 716
 717         /* fid[4] name[s] perm[4] mode[1] */
 718         size = 4 + 2 + strlen(name) + 4 + 1;
 719         if (dotu) {
 720                 size += 2 +                     /* extension[s] */
 721                     (extension == NULL ? 0 : strlen(extension));
 722         }
 723
 724         fc = p9_create_common(bufp, size, P9_TCREATE);
 725         if (IS_ERR(fc))
 726                 goto error;
 727
 728         p9_put_int32(bufp, fid, &fc->params.tcreate.fid);
 729         p9_put_str(bufp, name, &fc->params.tcreate.name);
 730         p9_put_int32(bufp, perm, &fc->params.tcreate.perm);
 731         p9_put_int8(bufp, mode, &fc->params.tcreate.mode);
 732         if (dotu)
 733                 p9_put_str(bufp, extension, &fc->params.tcreate.extension);
 734
 735         if (buf_check_overflow(bufp)) {
 736                 kfree(fc);
 737                 fc = ERR_PTR(-ENOMEM);
 738         }
 739 error:
 740         return fc;
 741 }
 742 EXPORT_SYMBOL(p9_create_tcreate);
 743
 744 struct p9_fcall *p9_create_tread(u32 fid, u64 offset, u32 count)
 745 {
 746         int size;
 747         struct p9_fcall *fc;
 748         struct cbuf buffer;
 749         struct cbuf *bufp = &buffer;
 750
 751         size = 4 + 8 + 4;       /* fid[4] offset[8] count[4] */
 752         fc = p9_create_common(bufp, size, P9_TREAD);
 753         if (IS_ERR(fc))
 754                 goto error;
 755
 756         p9_put_int32(bufp, fid, &fc->params.tread.fid);
 757         p9_put_int64(bufp, offset, &fc->params.tread.offset);
 758         p9_put_int32(bufp, count, &fc->params.tread.count);
 759
 760         if (buf_check_overflow(bufp)) {
 761                 kfree(fc);
 762                 fc = ERR_PTR(-ENOMEM);
 763         }
 764 error:
 765         return fc;
 766 }
 767 EXPORT_SYMBOL(p9_create_tread);
 768
 769 struct p9_fcall *p9_create_twrite(u32 fid, u64 offset, u32 count,
 770                                       const char *data)
 771 {
 772         int size, err;
 773         struct p9_fcall *fc;
 774         struct cbuf buffer;
 775         struct cbuf *bufp = &buffer;
 776
 777         /* fid[4] offset[8] count[4] data[count] */
 778         size = 4 + 8 + 4 + count;
 779         fc = p9_create_common(bufp, size, P9_TWRITE);
 780         if (IS_ERR(fc))
 781                 goto error;
 782
 783         p9_put_int32(bufp, fid, &fc->params.twrite.fid);
 784         p9_put_int64(bufp, offset, &fc->params.twrite.offset);
 785         p9_put_int32(bufp, count, &fc->params.twrite.count);
 786         err = p9_put_data(bufp, data, count, &fc->params.twrite.data);
 787         if (err) {
 788                 kfree(fc);
 789                 fc = ERR_PTR(err);
 790                 goto error;
 791         }
 792
 793         if (buf_check_overflow(bufp)) {
 794                 kfree(fc);
 795                 fc = ERR_PTR(-ENOMEM);
 796         }
 797 error:
 798         return fc;
 799 }
 800 EXPORT_SYMBOL(p9_create_twrite);
 801
 802 struct p9_fcall *p9_create_twrite_u(u32 fid, u64 offset, u32 count,
 803                                       const char __user *data)
 804 {
 805         int size, err;
 806         struct p9_fcall *fc;
 807         struct cbuf buffer;
 808         struct cbuf *bufp = &buffer;
 809
 810         /* fid[4] offset[8] count[4] data[count] */
 811         size = 4 + 8 + 4 + count;
 812         fc = p9_create_common(bufp, size, P9_TWRITE);
 813         if (IS_ERR(fc))
 814                 goto error;
 815
 816         p9_put_int32(bufp, fid, &fc->params.twrite.fid);
 817         p9_put_int64(bufp, offset, &fc->params.twrite.offset);
 818         p9_put_int32(bufp, count, &fc->params.twrite.count);
 819         err = p9_put_user_data(bufp, data, count, &fc->params.twrite.data);
 820         if (err) {
 821                 kfree(fc);
 822                 fc = ERR_PTR(err);
 823                 goto error;
 824         }
 825
 826         if (buf_check_overflow(bufp)) {
 827                 kfree(fc);
 828                 fc = ERR_PTR(-ENOMEM);
 829         }
 830 error:
 831         return fc;
 832 }
 833 EXPORT_SYMBOL(p9_create_twrite_u);
 834
 835 struct p9_fcall *p9_create_tclunk(u32 fid)
 836 {
 837         int size;
 838         struct p9_fcall *fc;
 839         struct cbuf buffer;
 840         struct cbuf *bufp = &buffer;
 841
 842         size = 4;               /* fid[4] */
 843         fc = p9_create_common(bufp, size, P9_TCLUNK);
 844         if (IS_ERR(fc))
 845                 goto error;
 846
 847         p9_put_int32(bufp, fid, &fc->params.tclunk.fid);
 848
 849         if (buf_check_overflow(bufp)) {
 850                 kfree(fc);
 851                 fc = ERR_PTR(-ENOMEM);
 852         }
 853 error:
 854         return fc;
 855 }
 856 EXPORT_SYMBOL(p9_create_tclunk);
 857
 858 struct p9_fcall *p9_create_tremove(u32 fid)
 859 {
 860         int size;
 861         struct p9_fcall *fc;
 862         struct cbuf buffer;
 863         struct cbuf *bufp = &buffer;
 864
 865         size = 4;               /* fid[4] */
 866         fc = p9_create_common(bufp, size, P9_TREMOVE);
 867         if (IS_ERR(fc))
 868                 goto error;
 869
 870         p9_put_int32(bufp, fid, &fc->params.tremove.fid);
 871
 872         if (buf_check_overflow(bufp)) {
 873                 kfree(fc);
 874                 fc = ERR_PTR(-ENOMEM);
 875         }
 876 error:
 877         return fc;
 878 }
 879 EXPORT_SYMBOL(p9_create_tremove);
 880
 881 struct p9_fcall *p9_create_tstat(u32 fid)
 882 {
 883         int size;
 884         struct p9_fcall *fc;
 885         struct cbuf buffer;
 886         struct cbuf *bufp = &buffer;
 887
 888         size = 4;               /* fid[4] */
 889         fc = p9_create_common(bufp, size, P9_TSTAT);
 890         if (IS_ERR(fc))
 891                 goto error;
 892
 893         p9_put_int32(bufp, fid, &fc->params.tstat.fid);
 894
 895         if (buf_check_overflow(bufp)) {
 896                 kfree(fc);
 897                 fc = ERR_PTR(-ENOMEM);
 898         }
 899 error:
 900         return fc;
 901 }
 902 EXPORT_SYMBOL(p9_create_tstat);
 903
 904 struct p9_fcall *p9_create_twstat(u32 fid, struct p9_wstat *wstat,
 905                                       int dotu)
 906 {
 907         int size, statsz;
 908         struct p9_fcall *fc;
 909         struct cbuf buffer;
 910         struct cbuf *bufp = &buffer;
 911
 912         statsz = p9_size_wstat(wstat, dotu);
 913         size = 4 + 2 + 2 + statsz;      /* fid[4] stat[n] */
 914         fc = p9_create_common(bufp, size, P9_TWSTAT);
 915         if (IS_ERR(fc))
 916                 goto error;
 917
 918         p9_put_int32(bufp, fid, &fc->params.twstat.fid);
 919         buf_put_int16(bufp, statsz + 2);
 920         p9_put_wstat(bufp, wstat, &fc->params.twstat.stat, statsz, dotu);
 921
 922         if (buf_check_overflow(bufp)) {
 923                 kfree(fc);
 924                 fc = ERR_PTR(-ENOMEM);
 925         }
 926 error:
 927         return fc;
 928 }
 929 EXPORT_SYMBOL(p9_create_twstat);