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 u8 buf_get_int8(struct cbuf *buf)
 132 {
 133         u8 ret = 0;
 134
 135         if (buf_check_size(buf, 1)) {
 136                 ret = buf->p[0];
 137                 buf->p++;
 138         }
 139
 140         return ret;
 141 }
 142
 143 static u16 buf_get_int16(struct cbuf *buf)
 144 {
 145         u16 ret = 0;
 146
 147         if (buf_check_size(buf, 2)) {
 148                 ret = le16_to_cpu(*(__le16 *)buf->p);
 149                 buf->p += 2;
 150         }
 151
 152         return ret;
 153 }
 154
 155 static u32 buf_get_int32(struct cbuf *buf)
 156 {
 157         u32 ret = 0;
 158
 159         if (buf_check_size(buf, 4)) {
 160                 ret = le32_to_cpu(*(__le32 *)buf->p);
 161                 buf->p += 4;
 162         }
 163
 164         return ret;
 165 }
 166
 167 static u64 buf_get_int64(struct cbuf *buf)
 168 {
 169         u64 ret = 0;
 170
 171         if (buf_check_size(buf, 8)) {
 172                 ret = le64_to_cpu(*(__le64 *)buf->p);
 173                 buf->p += 8;
 174         }
 175
 176         return ret;
 177 }
 178
 179 static void buf_get_str(struct cbuf *buf, struct p9_str *vstr)
 180 {
 181         vstr->len = buf_get_int16(buf);
 182         if (!buf_check_overflow(buf) && buf_check_size(buf, vstr->len)) {
 183                 vstr->str = buf->p;
 184                 buf->p += vstr->len;
 185         } else {
 186                 vstr->len = 0;
 187                 vstr->str = NULL;
 188         }
 189 }
 190
 191 static void buf_get_qid(struct cbuf *bufp, struct p9_qid *qid)
 192 {
 193         qid->type = buf_get_int8(bufp);
 194         qid->version = buf_get_int32(bufp);
 195         qid->path = buf_get_int64(bufp);
 196 }
 197
 198 /**
 199  * p9_size_wstat - calculate the size of a variable length stat struct
 200  * @wstat: metadata (stat) structure
 201  * @dotu: non-zero if 9P2000.u
 202  *
 203  */
 204
 205 static int p9_size_wstat(struct p9_wstat *wstat, int dotu)
 206 {
 207         int size = 0;
 208
 209         if (wstat == NULL) {
 210                 P9_EPRINTK(KERN_ERR, "p9_size_stat: got a NULL stat pointer\n");
 211                 return 0;
 212         }
 213
 214         size =                  /* 2 + *//* size[2] */
 215             2 +                 /* type[2] */
 216             4 +                 /* dev[4] */
 217             1 +                 /* qid.type[1] */
 218             4 +                 /* qid.vers[4] */
 219             8 +                 /* qid.path[8] */
 220             4 +                 /* mode[4] */
 221             4 +                 /* atime[4] */
 222             4 +                 /* mtime[4] */
 223             8 +                 /* length[8] */
 224             8;                  /* minimum sum of string lengths */
 225
 226         if (wstat->name)
 227                 size += strlen(wstat->name);
 228         if (wstat->uid)
 229                 size += strlen(wstat->uid);
 230         if (wstat->gid)
 231                 size += strlen(wstat->gid);
 232         if (wstat->muid)
 233                 size += strlen(wstat->muid);
 234
 235         if (dotu) {
 236                 size += 4 +     /* n_uid[4] */
 237                     4 +         /* n_gid[4] */
 238                     4 +         /* n_muid[4] */
 239                     2;          /* string length of extension[4] */
 240                 if (wstat->extension)
 241                         size += strlen(wstat->extension);
 242         }
 243
 244         return size;
 245 }
 246
 247 /**
 248  * buf_get_stat - safely decode a recieved metadata (stat) structure
 249  * @bufp: buffer to deserialize
 250  * @stat: metadata (stat) structure
 251  * @dotu: non-zero if 9P2000.u
 252  *
 253  */
 254
 255 static void
 256 buf_get_stat(struct cbuf *bufp, struct p9_stat *stat, int dotu)
 257 {
 258         stat->size = buf_get_int16(bufp);
 259         stat->type = buf_get_int16(bufp);
 260         stat->dev = buf_get_int32(bufp);
 261         stat->qid.type = buf_get_int8(bufp);
 262         stat->qid.version = buf_get_int32(bufp);
 263         stat->qid.path = buf_get_int64(bufp);
 264         stat->mode = buf_get_int32(bufp);
 265         stat->atime = buf_get_int32(bufp);
 266         stat->mtime = buf_get_int32(bufp);
 267         stat->length = buf_get_int64(bufp);
 268         buf_get_str(bufp, &stat->name);
 269         buf_get_str(bufp, &stat->uid);
 270         buf_get_str(bufp, &stat->gid);
 271         buf_get_str(bufp, &stat->muid);
 272
 273         if (dotu) {
 274                 buf_get_str(bufp, &stat->extension);
 275                 stat->n_uid = buf_get_int32(bufp);
 276                 stat->n_gid = buf_get_int32(bufp);
 277                 stat->n_muid = buf_get_int32(bufp);
 278         }
 279 }
 280
 281 /**
 282  * p9_deserialize_stat - decode a received metadata structure
 283  * @buf: buffer to deserialize
 284  * @buflen: length of received buffer
 285  * @stat: metadata structure to decode into
 286  * @dotu: non-zero if 9P2000.u
 287  *
 288  * Note: stat will point to the buf region.
 289  */
 290
 291 int
 292 p9_deserialize_stat(void *buf, u32 buflen, struct p9_stat *stat,
 293                 int dotu)
 294 {
 295         struct cbuf buffer;
 296         struct cbuf *bufp = &buffer;
 297         unsigned char *p;
 298
 299         buf_init(bufp, buf, buflen);
 300         p = bufp->p;
 301         buf_get_stat(bufp, stat, dotu);
 302
 303         if (buf_check_overflow(bufp))
 304                 return 0;
 305         else
 306                 return bufp->p - p;
 307 }
 308 EXPORT_SYMBOL(p9_deserialize_stat);
 309
 310 /**
 311  * deserialize_fcall - unmarshal a response
 312  * @buf: recieved buffer
 313  * @buflen: length of received buffer
 314  * @rcall: fcall structure to populate
 315  * @rcalllen: length of fcall structure to populate
 316  * @dotu: non-zero if 9P2000.u
 317  *
 318  */
 319
 320 int
 321 p9_deserialize_fcall(void *buf, u32 buflen, struct p9_fcall *rcall,
 322                        int dotu)
 323 {
 324
 325         struct cbuf buffer;
 326         struct cbuf *bufp = &buffer;
 327         int i = 0;
 328
 329         buf_init(bufp, buf, buflen);
 330
 331         rcall->size = buf_get_int32(bufp);
 332         rcall->id = buf_get_int8(bufp);
 333         rcall->tag = buf_get_int16(bufp);
 334
 335         P9_DPRINTK(P9_DEBUG_CONV, "size %d id %d tag %d\n", rcall->size,
 336                                                         rcall->id, rcall->tag);
 337
 338         switch (rcall->id) {
 339         default:
 340                 P9_EPRINTK(KERN_ERR, "unknown message type: %d\n", rcall->id);
 341                 return -EPROTO;
 342         case P9_RVERSION:
 343                 rcall->params.rversion.msize = buf_get_int32(bufp);
 344                 buf_get_str(bufp, &rcall->params.rversion.version);
 345                 break;
 346         case P9_RFLUSH:
 347                 break;
 348         case P9_RATTACH:
 349                 rcall->params.rattach.qid.type = buf_get_int8(bufp);
 350                 rcall->params.rattach.qid.version = buf_get_int32(bufp);
 351                 rcall->params.rattach.qid.path = buf_get_int64(bufp);
 352                 break;
 353         case P9_RWALK:
 354                 rcall->params.rwalk.nwqid = buf_get_int16(bufp);
 355                 if (rcall->params.rwalk.nwqid > P9_MAXWELEM) {
 356                         P9_EPRINTK(KERN_ERR,
 357                                         "Rwalk with more than %d qids: %d\n",
 358                                         P9_MAXWELEM, rcall->params.rwalk.nwqid);
 359                         return -EPROTO;
 360                 }
 361
 362                 for (i = 0; i < rcall->params.rwalk.nwqid; i++)
 363                         buf_get_qid(bufp, &rcall->params.rwalk.wqids[i]);
 364                 break;
 365         case P9_ROPEN:
 366                 buf_get_qid(bufp, &rcall->params.ropen.qid);
 367                 rcall->params.ropen.iounit = buf_get_int32(bufp);
 368                 break;
 369         case P9_RCREATE:
 370                 buf_get_qid(bufp, &rcall->params.rcreate.qid);
 371                 rcall->params.rcreate.iounit = buf_get_int32(bufp);
 372                 break;
 373         case P9_RREAD:
 374                 rcall->params.rread.count = buf_get_int32(bufp);
 375                 rcall->params.rread.data = bufp->p;
 376                 buf_check_size(bufp, rcall->params.rread.count);
 377                 break;
 378         case P9_RWRITE:
 379                 rcall->params.rwrite.count = buf_get_int32(bufp);
 380                 break;
 381         case P9_RCLUNK:
 382                 break;
 383         case P9_RREMOVE:
 384                 break;
 385         case P9_RSTAT:
 386                 buf_get_int16(bufp);
 387                 buf_get_stat(bufp, &rcall->params.rstat.stat, dotu);
 388                 break;
 389         case P9_RWSTAT:
 390                 break;
 391         case P9_RERROR:
 392                 buf_get_str(bufp, &rcall->params.rerror.error);
 393                 if (dotu)
 394                         rcall->params.rerror.errno = buf_get_int16(bufp);
 395                 break;
 396         }
 397
 398         if (buf_check_overflow(bufp)) {
 399                 P9_DPRINTK(P9_DEBUG_ERROR, "buffer overflow\n");
 400                 return -EIO;
 401         }
 402
 403         return bufp->p - bufp->sp;
 404 }
 405 EXPORT_SYMBOL(p9_deserialize_fcall);
 406
 407 static inline void p9_put_int8(struct cbuf *bufp, u8 val, u8 * p)
 408 {
 409         *p = val;
 410         buf_put_int8(bufp, val);
 411 }
 412
 413 static inline void p9_put_int16(struct cbuf *bufp, u16 val, u16 * p)
 414 {
 415         *p = val;
 416         buf_put_int16(bufp, val);
 417 }
 418
 419 static inline void p9_put_int32(struct cbuf *bufp, u32 val, u32 * p)
 420 {
 421         *p = val;
 422         buf_put_int32(bufp, val);
 423 }
 424
 425 static inline void p9_put_int64(struct cbuf *bufp, u64 val, u64 * p)
 426 {
 427         *p = val;
 428         buf_put_int64(bufp, val);
 429 }
 430
 431 static void
 432 p9_put_str(struct cbuf *bufp, char *data, struct p9_str *str)
 433 {
 434         int len;
 435         char *s;
 436
 437         if (data)
 438                 len = strlen(data);
 439         else
 440                 len = 0;
 441
 442         s = buf_put_stringn(bufp, data, len);
 443         if (str) {
 444                 str->len = len;
 445                 str->str = s;
 446         }
 447 }
 448
 449 static int
 450 p9_put_data(struct cbuf *bufp, const char *data, int count,
 451                    unsigned char **pdata)
 452 {
 453         *pdata = buf_alloc(bufp, count);
 454         if (*pdata == NULL)
 455                 return -ENOMEM;
 456         memmove(*pdata, data, count);
 457         return 0;
 458 }
 459
 460 static int
 461 p9_put_user_data(struct cbuf *bufp, const char __user *data, int count,
 462                    unsigned char **pdata)
 463 {
 464         *pdata = buf_alloc(bufp, count);
 465         if (*pdata == NULL)
 466                 return -ENOMEM;
 467         return copy_from_user(*pdata, data, count);
 468 }
 469
 470 static void
 471 p9_put_wstat(struct cbuf *bufp, struct p9_wstat *wstat,
 472                struct p9_stat *stat, int statsz, int dotu)
 473 {
 474         p9_put_int16(bufp, statsz, &stat->size);
 475         p9_put_int16(bufp, wstat->type, &stat->type);
 476         p9_put_int32(bufp, wstat->dev, &stat->dev);
 477         p9_put_int8(bufp, wstat->qid.type, &stat->qid.type);
 478         p9_put_int32(bufp, wstat->qid.version, &stat->qid.version);
 479         p9_put_int64(bufp, wstat->qid.path, &stat->qid.path);
 480         p9_put_int32(bufp, wstat->mode, &stat->mode);
 481         p9_put_int32(bufp, wstat->atime, &stat->atime);
 482         p9_put_int32(bufp, wstat->mtime, &stat->mtime);
 483         p9_put_int64(bufp, wstat->length, &stat->length);
 484
 485         p9_put_str(bufp, wstat->name, &stat->name);
 486         p9_put_str(bufp, wstat->uid, &stat->uid);
 487         p9_put_str(bufp, wstat->gid, &stat->gid);
 488         p9_put_str(bufp, wstat->muid, &stat->muid);
 489
 490         if (dotu) {
 491                 p9_put_str(bufp, wstat->extension, &stat->extension);
 492                 p9_put_int32(bufp, wstat->n_uid, &stat->n_uid);
 493                 p9_put_int32(bufp, wstat->n_gid, &stat->n_gid);
 494                 p9_put_int32(bufp, wstat->n_muid, &stat->n_muid);
 495         }
 496 }
 497
 498 static struct p9_fcall *
 499 p9_create_common(struct cbuf *bufp, u32 size, u8 id)
 500 {
 501         struct p9_fcall *fc;
 502
 503         size += 4 + 1 + 2;      /* size[4] id[1] tag[2] */
 504         fc = kmalloc(sizeof(struct p9_fcall) + size, GFP_KERNEL);
 505         if (!fc)
 506                 return ERR_PTR(-ENOMEM);
 507
 508         fc->sdata = (char *)fc + sizeof(*fc);
 509
 510         buf_init(bufp, (char *)fc->sdata, size);
 511         p9_put_int32(bufp, size, &fc->size);
 512         p9_put_int8(bufp, id, &fc->id);
 513         p9_put_int16(bufp, P9_NOTAG, &fc->tag);
 514
 515         return fc;
 516 }
 517
 518 /**
 519  * p9_set_tag - set the tag field of an &p9_fcall structure
 520  * @fc: fcall structure to set tag within
 521  * @tag: tag id to set
 522  */
 523
 524 void p9_set_tag(struct p9_fcall *fc, u16 tag)
 525 {
 526         fc->tag = tag;
 527         *(__le16 *) (fc->sdata + 5) = cpu_to_le16(tag);
 528 }
 529 EXPORT_SYMBOL(p9_set_tag);
 530
 531 /**
 532  * p9_create_tversion - allocates and creates a T_VERSION request
 533  * @msize: requested maximum data size
 534  * @version: version string to negotiate
 535  *
 536  */
 537 struct p9_fcall *p9_create_tversion(u32 msize, char *version)
 538 {
 539         int size;
 540         struct p9_fcall *fc;
 541         struct cbuf buffer;
 542         struct cbuf *bufp = &buffer;
 543
 544         size = 4 + 2 + strlen(version); /* msize[4] version[s] */
 545         fc = p9_create_common(bufp, size, P9_TVERSION);
 546         if (IS_ERR(fc))
 547                 goto error;
 548
 549         p9_put_int32(bufp, msize, &fc->params.tversion.msize);
 550         p9_put_str(bufp, version, &fc->params.tversion.version);
 551
 552         if (buf_check_overflow(bufp)) {
 553                 kfree(fc);
 554                 fc = ERR_PTR(-ENOMEM);
 555         }
 556 error:
 557         return fc;
 558 }
 559 EXPORT_SYMBOL(p9_create_tversion);
 560
 561 /**
 562  * p9_create_tauth - allocates and creates a T_AUTH request
 563  * @afid: handle to use for authentication protocol
 564  * @uname: user name attempting to authenticate
 565  * @aname: mount specifier for remote server
 566  * @n_uname: numeric id for user attempting to authneticate
 567  * @dotu: 9P2000.u extension flag
 568  *
 569  */
 570
 571 struct p9_fcall *p9_create_tauth(u32 afid, char *uname, char *aname,
 572         u32 n_uname, int dotu)
 573 {
 574         int size;
 575         struct p9_fcall *fc;
 576         struct cbuf buffer;
 577         struct cbuf *bufp = &buffer;
 578
 579         /* afid[4] uname[s] aname[s] */
 580         size = 4 + 2 + 2;
 581         if (uname)
 582                 size += strlen(uname);
 583
 584         if (aname)
 585                 size += strlen(aname);
 586
 587         if (dotu)
 588                 size += 4;      /* n_uname */
 589
 590         fc = p9_create_common(bufp, size, P9_TAUTH);
 591         if (IS_ERR(fc))
 592                 goto error;
 593
 594         p9_put_int32(bufp, afid, &fc->params.tauth.afid);
 595         p9_put_str(bufp, uname, &fc->params.tauth.uname);
 596         p9_put_str(bufp, aname, &fc->params.tauth.aname);
 597         if (dotu)
 598                 p9_put_int32(bufp, n_uname, &fc->params.tauth.n_uname);
 599
 600         if (buf_check_overflow(bufp)) {
 601                 kfree(fc);
 602                 fc = ERR_PTR(-ENOMEM);
 603         }
 604 error:
 605         return fc;
 606 }
 607 EXPORT_SYMBOL(p9_create_tauth);
 608
 609 /**
 610  * p9_create_tattach - allocates and creates a T_ATTACH request
 611  * @fid: handle to use for the new mount point
 612  * @afid: handle to use for authentication protocol
 613  * @uname: user name attempting to attach
 614  * @aname: mount specifier for remote server
 615  * @n_uname: numeric id for user attempting to attach
 616  * @n_uname: numeric id for user attempting to attach
 617  * @dotu: 9P2000.u extension flag
 618  *
 619  */
 620
 621 struct p9_fcall *
 622 p9_create_tattach(u32 fid, u32 afid, char *uname, char *aname,
 623         u32 n_uname, int dotu)
 624 {
 625         int size;
 626         struct p9_fcall *fc;
 627         struct cbuf buffer;
 628         struct cbuf *bufp = &buffer;
 629
 630         /* fid[4] afid[4] uname[s] aname[s] */
 631         size = 4 + 4 + 2 + 2;
 632         if (uname)
 633                 size += strlen(uname);
 634
 635         if (aname)
 636                 size += strlen(aname);
 637
 638         if (dotu)
 639                 size += 4;      /* n_uname */
 640
 641         fc = p9_create_common(bufp, size, P9_TATTACH);
 642         if (IS_ERR(fc))
 643                 goto error;
 644
 645         p9_put_int32(bufp, fid, &fc->params.tattach.fid);
 646         p9_put_int32(bufp, afid, &fc->params.tattach.afid);
 647         p9_put_str(bufp, uname, &fc->params.tattach.uname);
 648         p9_put_str(bufp, aname, &fc->params.tattach.aname);
 649         if (dotu)
 650                 p9_put_int32(bufp, n_uname, &fc->params.tattach.n_uname);
 651
 652 error:
 653         return fc;
 654 }
 655 EXPORT_SYMBOL(p9_create_tattach);
 656
 657 /**
 658  * p9_create_tflush - allocates and creates a T_FLUSH request
 659  * @oldtag: tag id for the transaction we are attempting to cancel
 660  *
 661  */
 662
 663 struct p9_fcall *p9_create_tflush(u16 oldtag)
 664 {
 665         int size;
 666         struct p9_fcall *fc;
 667         struct cbuf buffer;
 668         struct cbuf *bufp = &buffer;
 669
 670         size = 2;               /* oldtag[2] */
 671         fc = p9_create_common(bufp, size, P9_TFLUSH);
 672         if (IS_ERR(fc))
 673                 goto error;
 674
 675         p9_put_int16(bufp, oldtag, &fc->params.tflush.oldtag);
 676
 677         if (buf_check_overflow(bufp)) {
 678                 kfree(fc);
 679                 fc = ERR_PTR(-ENOMEM);
 680         }
 681 error:
 682         return fc;
 683 }
 684 EXPORT_SYMBOL(p9_create_tflush);
 685
 686 /**
 687  * p9_create_twalk - allocates and creates a T_FLUSH request
 688  * @fid: handle we are traversing from
 689  * @newfid: a new handle for this transaction
 690  * @nwname: number of path elements to traverse
 691  * @wnames: array of path elements
 692  *
 693  */
 694
 695 struct p9_fcall *p9_create_twalk(u32 fid, u32 newfid, u16 nwname,
 696                                      char **wnames)
 697 {
 698         int i, size;
 699         struct p9_fcall *fc;
 700         struct cbuf buffer;
 701         struct cbuf *bufp = &buffer;
 702
 703         if (nwname > P9_MAXWELEM) {
 704                 P9_DPRINTK(P9_DEBUG_ERROR, "nwname > %d\n", P9_MAXWELEM);
 705                 return NULL;
 706         }
 707
 708         size = 4 + 4 + 2;       /* fid[4] newfid[4] nwname[2] ... */
 709         for (i = 0; i < nwname; i++) {
 710                 size += 2 + strlen(wnames[i]);  /* wname[s] */
 711         }
 712
 713         fc = p9_create_common(bufp, size, P9_TWALK);
 714         if (IS_ERR(fc))
 715                 goto error;
 716
 717         p9_put_int32(bufp, fid, &fc->params.twalk.fid);
 718         p9_put_int32(bufp, newfid, &fc->params.twalk.newfid);
 719         p9_put_int16(bufp, nwname, &fc->params.twalk.nwname);
 720         for (i = 0; i < nwname; i++) {
 721                 p9_put_str(bufp, wnames[i], &fc->params.twalk.wnames[i]);
 722         }
 723
 724         if (buf_check_overflow(bufp)) {
 725                 kfree(fc);
 726                 fc = ERR_PTR(-ENOMEM);
 727         }
 728 error:
 729         return fc;
 730 }
 731 EXPORT_SYMBOL(p9_create_twalk);
 732
 733 /**
 734  * p9_create_topen - allocates and creates a T_OPEN request
 735  * @fid: handle we are trying to open
 736  * @mode: what mode we are trying to open the file in
 737  *
 738  */
 739
 740 struct p9_fcall *p9_create_topen(u32 fid, u8 mode)
 741 {
 742         int size;
 743         struct p9_fcall *fc;
 744         struct cbuf buffer;
 745         struct cbuf *bufp = &buffer;
 746
 747         size = 4 + 1;           /* fid[4] mode[1] */
 748         fc = p9_create_common(bufp, size, P9_TOPEN);
 749         if (IS_ERR(fc))
 750                 goto error;
 751
 752         p9_put_int32(bufp, fid, &fc->params.topen.fid);
 753         p9_put_int8(bufp, mode, &fc->params.topen.mode);
 754
 755         if (buf_check_overflow(bufp)) {
 756                 kfree(fc);
 757                 fc = ERR_PTR(-ENOMEM);
 758         }
 759 error:
 760         return fc;
 761 }
 762 EXPORT_SYMBOL(p9_create_topen);
 763
 764 /**
 765  * p9_create_tcreate - allocates and creates a T_CREATE request
 766  * @fid: handle of directory we are trying to create in
 767  * @name: name of the file we are trying to create
 768  * @perm: permissions for the file we are trying to create
 769  * @mode: what mode we are trying to open the file in
 770  * @extension: 9p2000.u extension string (for special files)
 771  * @dotu: 9p2000.u enabled flag
 772  *
 773  * Note: Plan 9 create semantics include opening the resulting file
 774  * which is why mode is included.
 775  */
 776
 777 struct p9_fcall *p9_create_tcreate(u32 fid, char *name, u32 perm, u8 mode,
 778         char *extension, int dotu)
 779 {
 780         int size;
 781         struct p9_fcall *fc;
 782         struct cbuf buffer;
 783         struct cbuf *bufp = &buffer;
 784
 785         /* fid[4] name[s] perm[4] mode[1] */
 786         size = 4 + 2 + strlen(name) + 4 + 1;
 787         if (dotu) {
 788                 size += 2 +                     /* extension[s] */
 789                     (extension == NULL ? 0 : strlen(extension));
 790         }
 791
 792         fc = p9_create_common(bufp, size, P9_TCREATE);
 793         if (IS_ERR(fc))
 794                 goto error;
 795
 796         p9_put_int32(bufp, fid, &fc->params.tcreate.fid);
 797         p9_put_str(bufp, name, &fc->params.tcreate.name);
 798         p9_put_int32(bufp, perm, &fc->params.tcreate.perm);
 799         p9_put_int8(bufp, mode, &fc->params.tcreate.mode);
 800         if (dotu)
 801                 p9_put_str(bufp, extension, &fc->params.tcreate.extension);
 802
 803         if (buf_check_overflow(bufp)) {
 804                 kfree(fc);
 805                 fc = ERR_PTR(-ENOMEM);
 806         }
 807 error:
 808         return fc;
 809 }
 810 EXPORT_SYMBOL(p9_create_tcreate);
 811
 812 /**
 813  * p9_create_tread - allocates and creates a T_READ request
 814  * @fid: handle of the file we are trying to read
 815  * @offset: offset to start reading from
 816  * @count: how many bytes to read
 817  */
 818
 819 struct p9_fcall *p9_create_tread(u32 fid, u64 offset, u32 count)
 820 {
 821         int size;
 822         struct p9_fcall *fc;
 823         struct cbuf buffer;
 824         struct cbuf *bufp = &buffer;
 825
 826         size = 4 + 8 + 4;       /* fid[4] offset[8] count[4] */
 827         fc = p9_create_common(bufp, size, P9_TREAD);
 828         if (IS_ERR(fc))
 829                 goto error;
 830
 831         p9_put_int32(bufp, fid, &fc->params.tread.fid);
 832         p9_put_int64(bufp, offset, &fc->params.tread.offset);
 833         p9_put_int32(bufp, count, &fc->params.tread.count);
 834
 835         if (buf_check_overflow(bufp)) {
 836                 kfree(fc);
 837                 fc = ERR_PTR(-ENOMEM);
 838         }
 839 error:
 840         return fc;
 841 }
 842 EXPORT_SYMBOL(p9_create_tread);
 843
 844 /**
 845  * p9_create_twrite - allocates and creates a T_WRITE request from the kernel
 846  * @fid: handle of the file we are trying to write
 847  * @offset: offset to start writing at
 848  * @count: how many bytes to write
 849  * @data: data to write
 850  *
 851  * This function will create a requst with data buffers from the kernel
 852  * such as the page cache.
 853  */
 854
 855 struct p9_fcall *p9_create_twrite(u32 fid, u64 offset, u32 count,
 856                                       const char *data)
 857 {
 858         int size, err;
 859         struct p9_fcall *fc;
 860         struct cbuf buffer;
 861         struct cbuf *bufp = &buffer;
 862
 863         /* fid[4] offset[8] count[4] data[count] */
 864         size = 4 + 8 + 4 + count;
 865         fc = p9_create_common(bufp, size, P9_TWRITE);
 866         if (IS_ERR(fc))
 867                 goto error;
 868
 869         p9_put_int32(bufp, fid, &fc->params.twrite.fid);
 870         p9_put_int64(bufp, offset, &fc->params.twrite.offset);
 871         p9_put_int32(bufp, count, &fc->params.twrite.count);
 872         err = p9_put_data(bufp, data, count, &fc->params.twrite.data);
 873         if (err) {
 874                 kfree(fc);
 875                 fc = ERR_PTR(err);
 876                 goto error;
 877         }
 878
 879         if (buf_check_overflow(bufp)) {
 880                 kfree(fc);
 881                 fc = ERR_PTR(-ENOMEM);
 882         }
 883 error:
 884         return fc;
 885 }
 886 EXPORT_SYMBOL(p9_create_twrite);
 887
 888 /**
 889  * p9_create_twrite_u - allocates and creates a T_WRITE request from userspace
 890  * @fid: handle of the file we are trying to write
 891  * @offset: offset to start writing at
 892  * @count: how many bytes to write
 893  * @data: data to write
 894  *
 895  * This function will create a request with data buffers from userspace
 896  */
 897
 898 struct p9_fcall *p9_create_twrite_u(u32 fid, u64 offset, u32 count,
 899                                       const char __user *data)
 900 {
 901         int size, err;
 902         struct p9_fcall *fc;
 903         struct cbuf buffer;
 904         struct cbuf *bufp = &buffer;
 905
 906         /* fid[4] offset[8] count[4] data[count] */
 907         size = 4 + 8 + 4 + count;
 908         fc = p9_create_common(bufp, size, P9_TWRITE);
 909         if (IS_ERR(fc))
 910                 goto error;
 911
 912         p9_put_int32(bufp, fid, &fc->params.twrite.fid);
 913         p9_put_int64(bufp, offset, &fc->params.twrite.offset);
 914         p9_put_int32(bufp, count, &fc->params.twrite.count);
 915         err = p9_put_user_data(bufp, data, count, &fc->params.twrite.data);
 916         if (err) {
 917                 kfree(fc);
 918                 fc = ERR_PTR(err);
 919                 goto error;
 920         }
 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_twrite_u);
 930
 931 /**
 932  * p9_create_tclunk - allocate a request to forget about a file handle
 933  * @fid: handle of the file we closing or forgetting about
 934  *
 935  * clunk is used both to close open files and to discard transient handles
 936  * which may be created during meta-data operations and hierarchy traversal.
 937  */
 938
 939 struct p9_fcall *p9_create_tclunk(u32 fid)
 940 {
 941         int size;
 942         struct p9_fcall *fc;
 943         struct cbuf buffer;
 944         struct cbuf *bufp = &buffer;
 945
 946         size = 4;               /* fid[4] */
 947         fc = p9_create_common(bufp, size, P9_TCLUNK);
 948         if (IS_ERR(fc))
 949                 goto error;
 950
 951         p9_put_int32(bufp, fid, &fc->params.tclunk.fid);
 952
 953         if (buf_check_overflow(bufp)) {
 954                 kfree(fc);
 955                 fc = ERR_PTR(-ENOMEM);
 956         }
 957 error:
 958         return fc;
 959 }
 960 EXPORT_SYMBOL(p9_create_tclunk);
 961
 962 /**
 963  * p9_create_tremove - allocate and create a request to remove a file
 964  * @fid: handle of the file or directory we are removing
 965  *
 966  */
 967
 968 struct p9_fcall *p9_create_tremove(u32 fid)
 969 {
 970         int size;
 971         struct p9_fcall *fc;
 972         struct cbuf buffer;
 973         struct cbuf *bufp = &buffer;
 974
 975         size = 4;               /* fid[4] */
 976         fc = p9_create_common(bufp, size, P9_TREMOVE);
 977         if (IS_ERR(fc))
 978                 goto error;
 979
 980         p9_put_int32(bufp, fid, &fc->params.tremove.fid);
 981
 982         if (buf_check_overflow(bufp)) {
 983                 kfree(fc);
 984                 fc = ERR_PTR(-ENOMEM);
 985         }
 986 error:
 987         return fc;
 988 }
 989 EXPORT_SYMBOL(p9_create_tremove);
 990
 991 /**
 992  * p9_create_tstat - allocate and populate a request for attributes
 993  * @fid: handle of the file or directory we are trying to get the attributes of
 994  *
 995  */
 996
 997 struct p9_fcall *p9_create_tstat(u32 fid)
 998 {
 999         int size;
1000         struct p9_fcall *fc;
1001         struct cbuf buffer;
1002         struct cbuf *bufp = &buffer;
1003
1004         size = 4;               /* fid[4] */
1005         fc = p9_create_common(bufp, size, P9_TSTAT);
1006         if (IS_ERR(fc))
1007                 goto error;
1008
1009         p9_put_int32(bufp, fid, &fc->params.tstat.fid);
1010
1011         if (buf_check_overflow(bufp)) {
1012                 kfree(fc);
1013                 fc = ERR_PTR(-ENOMEM);
1014         }
1015 error:
1016         return fc;
1017 }
1018 EXPORT_SYMBOL(p9_create_tstat);
1019
1020 /**
1021  * p9_create_tstat - allocate and populate a request to change attributes
1022  * @fid: handle of the file or directory we are trying to change
1023  * @wstat: &p9_stat structure with attributes we wish to set
1024  * @dotu: 9p2000.u enabled flag
1025  *
1026  */
1027
1028 struct p9_fcall *p9_create_twstat(u32 fid, struct p9_wstat *wstat,
1029                                       int dotu)
1030 {
1031         int size, statsz;
1032         struct p9_fcall *fc;
1033         struct cbuf buffer;
1034         struct cbuf *bufp = &buffer;
1035
1036         statsz = p9_size_wstat(wstat, dotu);
1037         size = 4 + 2 + 2 + statsz;      /* fid[4] stat[n] */
1038         fc = p9_create_common(bufp, size, P9_TWSTAT);
1039         if (IS_ERR(fc))
1040                 goto error;
1041
1042         p9_put_int32(bufp, fid, &fc->params.twstat.fid);
1043         buf_put_int16(bufp, statsz + 2);
1044         p9_put_wstat(bufp, wstat, &fc->params.twstat.stat, statsz, dotu);
1045
1046         if (buf_check_overflow(bufp)) {
1047                 kfree(fc);
1048                 fc = ERR_PTR(-ENOMEM);
1049         }
1050 error:
1051         return fc;
1052 }
1053 EXPORT_SYMBOL(p9_create_twstat);
1054