net/9p/protocol.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * 9P Protocol Support Code
   4  *
   5  *  Copyright (C) 2008 by Eric Van Hensbergen <[email protected]>
   6  *
   7  *  Base on code from Anthony Liguori <[email protected]>
   8  *  Copyright (C) 2008 by IBM, Corp.
   9  */
  10
  11 #include <linux/module.h>
  12 #include <linux/errno.h>
  13 #include <linux/kernel.h>
  14 #include <linux/uaccess.h>
  15 #include <linux/slab.h>
  16 #include <linux/sched.h>
  17 #include <linux/stddef.h>
  18 #include <linux/types.h>
  19 #include <linux/uio.h>
  20 #include <net/9p/9p.h>
  21 #include <net/9p/client.h>
  22 #include "protocol.h"
  23
  24 #include <trace/events/9p.h>
  25
  26 /* len[2] text[len] */
  27 #define P9_STRLEN(s) \
  28         (2 + min_t(size_t, s ? strlen(s) : 0, USHRT_MAX))
  29
  30 /**
  31  * p9_msg_buf_size - Returns a buffer size sufficiently large to hold the
  32  * intended 9p message.
  33  * @c: client
  34  * @type: message type
  35  * @fmt: format template for assembling request message
  36  * (see p9pdu_vwritef)
  37  * @ap: variable arguments to be fed to passed format template
  38  * (see p9pdu_vwritef)
  39  *
  40  * Note: Even for response types (P9_R*) the format template and variable
  41  * arguments must always be for the originating request type (P9_T*).
  42  */
  43 size_t p9_msg_buf_size(struct p9_client *c, enum p9_msg_t type,
  44                         const char *fmt, va_list ap)
  45 {
  46         /* size[4] type[1] tag[2] */
  47         const int hdr = 4 + 1 + 2;
  48         /* ename[s] errno[4] */
  49         const int rerror_size = hdr + P9_ERRMAX + 4;
  50         /* ecode[4] */
  51         const int rlerror_size = hdr + 4;
  52         const int err_size =
  53                 c->proto_version == p9_proto_2000L ? rlerror_size : rerror_size;
  54
  55         static_assert(NAME_MAX <= 4*1024, "p9_msg_buf_size() currently assumes "
  56                                   "a max. allowed directory entry name length of 4k");
  57
  58         switch (type) {
  59
  60         /* message types not used at all */
  61         case P9_TERROR:
  62         case P9_TLERROR:
  63         case P9_TAUTH:
  64         case P9_RAUTH:
  65                 BUG();
  66
  67         /* variable length & potentially large message types */
  68         case P9_TATTACH:
  69                 BUG_ON(strcmp("ddss?u", fmt));
  70                 va_arg(ap, int32_t);
  71                 va_arg(ap, int32_t);
  72                 {
  73                         const char *uname = va_arg(ap, const char *);
  74                         const char *aname = va_arg(ap, const char *);
  75                         /* fid[4] afid[4] uname[s] aname[s] n_uname[4] */
  76                         return hdr + 4 + 4 + P9_STRLEN(uname) + P9_STRLEN(aname) + 4;
  77                 }
  78         case P9_TWALK:
  79                 BUG_ON(strcmp("ddT", fmt));
  80                 va_arg(ap, int32_t);
  81                 va_arg(ap, int32_t);
  82                 {
  83                         uint i, nwname = va_arg(ap, int);
  84                         size_t wname_all;
  85                         const char **wnames = va_arg(ap, const char **);
  86                         for (i = 0, wname_all = 0; i < nwname; ++i) {
  87                                 wname_all += P9_STRLEN(wnames[i]);
  88                         }
  89                         /* fid[4] newfid[4] nwname[2] nwname*(wname[s]) */
  90                         return hdr + 4 + 4 + 2 + wname_all;
  91                 }
  92         case P9_RWALK:
  93                 BUG_ON(strcmp("ddT", fmt));
  94                 va_arg(ap, int32_t);
  95                 va_arg(ap, int32_t);
  96                 {
  97                         uint nwname = va_arg(ap, int);
  98                         /* nwqid[2] nwqid*(wqid[13]) */
  99                         return max_t(size_t, hdr + 2 + nwname * 13, err_size);
 100                 }
 101         case P9_TCREATE:
 102                 BUG_ON(strcmp("dsdb?s", fmt));
 103                 va_arg(ap, int32_t);
 104                 {
 105                         const char *name = va_arg(ap, const char *);
 106                         if (c->proto_version == p9_proto_legacy) {
 107                                 /* fid[4] name[s] perm[4] mode[1] */
 108                                 return hdr + 4 + P9_STRLEN(name) + 4 + 1;
 109                         } else {
 110                                 va_arg(ap, int32_t);
 111                                 va_arg(ap, int);
 112                                 {
 113                                         const char *ext = va_arg(ap, const char *);
 114                                         /* fid[4] name[s] perm[4] mode[1] extension[s] */
 115                                         return hdr + 4 + P9_STRLEN(name) + 4 + 1 + P9_STRLEN(ext);
 116                                 }
 117                         }
 118                 }
 119         case P9_TLCREATE:
 120                 BUG_ON(strcmp("dsddg", fmt));
 121                 va_arg(ap, int32_t);
 122                 {
 123                         const char *name = va_arg(ap, const char *);
 124                         /* fid[4] name[s] flags[4] mode[4] gid[4] */
 125                         return hdr + 4 + P9_STRLEN(name) + 4 + 4 + 4;
 126                 }
 127         case P9_RREAD:
 128         case P9_RREADDIR:
 129                 BUG_ON(strcmp("dqd", fmt));
 130                 va_arg(ap, int32_t);
 131                 va_arg(ap, int64_t);
 132                 {
 133                         const int32_t count = va_arg(ap, int32_t);
 134                         /* count[4] data[count] */
 135                         return max_t(size_t, hdr + 4 + count, err_size);
 136                 }
 137         case P9_TWRITE:
 138                 BUG_ON(strcmp("dqV", fmt));
 139                 va_arg(ap, int32_t);
 140                 va_arg(ap, int64_t);
 141                 {
 142                         const int32_t count = va_arg(ap, int32_t);
 143                         /* fid[4] offset[8] count[4] data[count] */
 144                         return hdr + 4 + 8 + 4 + count;
 145                 }
 146         case P9_TRENAMEAT:
 147                 BUG_ON(strcmp("dsds", fmt));
 148                 va_arg(ap, int32_t);
 149                 {
 150                         const char *oldname, *newname;
 151                         oldname = va_arg(ap, const char *);
 152                         va_arg(ap, int32_t);
 153                         newname = va_arg(ap, const char *);
 154                         /* olddirfid[4] oldname[s] newdirfid[4] newname[s] */
 155                         return hdr + 4 + P9_STRLEN(oldname) + 4 + P9_STRLEN(newname);
 156                 }
 157         case P9_TSYMLINK:
 158                 BUG_ON(strcmp("dssg", fmt));
 159                 va_arg(ap, int32_t);
 160                 {
 161                         const char *name = va_arg(ap, const char *);
 162                         const char *symtgt = va_arg(ap, const char *);
 163                         /* fid[4] name[s] symtgt[s] gid[4] */
 164                         return hdr + 4 + P9_STRLEN(name) + P9_STRLEN(symtgt) + 4;
 165                 }
 166
 167         case P9_RERROR:
 168                 return rerror_size;
 169         case P9_RLERROR:
 170                 return rlerror_size;
 171
 172         /* small message types */
 173         case P9_TWSTAT:
 174         case P9_RSTAT:
 175         case P9_RREADLINK:
 176         case P9_TXATTRWALK:
 177         case P9_TXATTRCREATE:
 178         case P9_TLINK:
 179         case P9_TMKDIR:
 180         case P9_TMKNOD:
 181         case P9_TRENAME:
 182         case P9_TUNLINKAT:
 183         case P9_TLOCK:
 184                 return 8 * 1024;
 185
 186         /* tiny message types */
 187         default:
 188                 return 4 * 1024;
 189
 190         }
 191 }
 192
 193 static int
 194 p9pdu_writef(struct p9_fcall *pdu, int proto_version, const char *fmt, ...);
 195
 196 void p9stat_free(struct p9_wstat *stbuf)
 197 {
 198         kfree(stbuf->name);
 199         stbuf->name = NULL;
 200         kfree(stbuf->uid);
 201         stbuf->uid = NULL;
 202         kfree(stbuf->gid);
 203         stbuf->gid = NULL;
 204         kfree(stbuf->muid);
 205         stbuf->muid = NULL;
 206         kfree(stbuf->extension);
 207         stbuf->extension = NULL;
 208 }
 209 EXPORT_SYMBOL(p9stat_free);
 210
 211 size_t pdu_read(struct p9_fcall *pdu, void *data, size_t size)
 212 {
 213         size_t len = min(pdu->size - pdu->offset, size);
 214
 215         memcpy(data, &pdu->sdata[pdu->offset], len);
 216         pdu->offset += len;
 217         return size - len;
 218 }
 219
 220 static size_t pdu_write(struct p9_fcall *pdu, const void *data, size_t size)
 221 {
 222         size_t len = min(pdu->capacity - pdu->size, size);
 223
 224         memcpy(&pdu->sdata[pdu->size], data, len);
 225         pdu->size += len;
 226         return size - len;
 227 }
 228
 229 static size_t
 230 pdu_write_u(struct p9_fcall *pdu, struct iov_iter *from, size_t size)
 231 {
 232         size_t len = min(pdu->capacity - pdu->size, size);
 233
 234         if (!copy_from_iter_full(&pdu->sdata[pdu->size], len, from))
 235                 len = 0;
 236
 237         pdu->size += len;
 238         return size - len;
 239 }
 240
 241 /*      b - int8_t
 242  *      w - int16_t
 243  *      d - int32_t
 244  *      q - int64_t
 245  *      s - string
 246  *      u - numeric uid
 247  *      g - numeric gid
 248  *      S - stat
 249  *      Q - qid
 250  *      D - data blob (int32_t size followed by void *, results are not freed)
 251  *      T - array of strings (int16_t count, followed by strings)
 252  *      R - array of qids (int16_t count, followed by qids)
 253  *      A - stat for 9p2000.L (p9_stat_dotl)
 254  *      ? - if optional = 1, continue parsing
 255  */
 256
 257 static int
 258 p9pdu_vreadf(struct p9_fcall *pdu, int proto_version, const char *fmt,
 259              va_list ap)
 260 {
 261         const char *ptr;
 262         int errcode = 0;
 263
 264         for (ptr = fmt; *ptr; ptr++) {
 265                 switch (*ptr) {
 266                 case 'b':{
 267                                 int8_t *val = va_arg(ap, int8_t *);
 268                                 if (pdu_read(pdu, val, sizeof(*val))) {
 269                                         errcode = -EFAULT;
 270                                         break;
 271                                 }
 272                         }
 273                         break;
 274                 case 'w':{
 275                                 int16_t *val = va_arg(ap, int16_t *);
 276                                 __le16 le_val;
 277                                 if (pdu_read(pdu, &le_val, sizeof(le_val))) {
 278                                         errcode = -EFAULT;
 279                                         break;
 280                                 }
 281                                 *val = le16_to_cpu(le_val);
 282                         }
 283                         break;
 284                 case 'd':{
 285                                 int32_t *val = va_arg(ap, int32_t *);
 286                                 __le32 le_val;
 287                                 if (pdu_read(pdu, &le_val, sizeof(le_val))) {
 288                                         errcode = -EFAULT;
 289                                         break;
 290                                 }
 291                                 *val = le32_to_cpu(le_val);
 292                         }
 293                         break;
 294                 case 'q':{
 295                                 int64_t *val = va_arg(ap, int64_t *);
 296                                 __le64 le_val;
 297                                 if (pdu_read(pdu, &le_val, sizeof(le_val))) {
 298                                         errcode = -EFAULT;
 299                                         break;
 300                                 }
 301                                 *val = le64_to_cpu(le_val);
 302                         }
 303                         break;
 304                 case 's':{
 305                                 char **sptr = va_arg(ap, char **);
 306                                 uint16_t len;
 307
 308                                 errcode = p9pdu_readf(pdu, proto_version,
 309                                                                 "w", &len);
 310                                 if (errcode)
 311                                         break;
 312
 313                                 *sptr = kmalloc(len + 1, GFP_NOFS);
 314                                 if (*sptr == NULL) {
 315                                         errcode = -ENOMEM;
 316                                         break;
 317                                 }
 318                                 if (pdu_read(pdu, *sptr, len)) {
 319                                         errcode = -EFAULT;
 320                                         kfree(*sptr);
 321                                         *sptr = NULL;
 322                                 } else
 323                                         (*sptr)[len] = 0;
 324                         }
 325                         break;
 326                 case 'u': {
 327                                 kuid_t *uid = va_arg(ap, kuid_t *);
 328                                 __le32 le_val;
 329                                 if (pdu_read(pdu, &le_val, sizeof(le_val))) {
 330                                         errcode = -EFAULT;
 331                                         break;
 332                                 }
 333                                 *uid = make_kuid(&init_user_ns,
 334                                                  le32_to_cpu(le_val));
 335                         } break;
 336                 case 'g': {
 337                                 kgid_t *gid = va_arg(ap, kgid_t *);
 338                                 __le32 le_val;
 339                                 if (pdu_read(pdu, &le_val, sizeof(le_val))) {
 340                                         errcode = -EFAULT;
 341                                         break;
 342                                 }
 343                                 *gid = make_kgid(&init_user_ns,
 344                                                  le32_to_cpu(le_val));
 345                         } break;
 346                 case 'Q':{
 347                                 struct p9_qid *qid =
 348                                     va_arg(ap, struct p9_qid *);
 349
 350                                 errcode = p9pdu_readf(pdu, proto_version, "bdq",
 351                                                       &qid->type, &qid->version,
 352                                                       &qid->path);
 353                         }
 354                         break;
 355                 case 'S':{
 356                                 struct p9_wstat *stbuf =
 357                                     va_arg(ap, struct p9_wstat *);
 358
 359                                 memset(stbuf, 0, sizeof(struct p9_wstat));
 360                                 stbuf->n_uid = stbuf->n_muid = INVALID_UID;
 361                                 stbuf->n_gid = INVALID_GID;
 362
 363                                 errcode =
 364                                     p9pdu_readf(pdu, proto_version,
 365                                                 "wwdQdddqssss?sugu",
 366                                                 &stbuf->size, &stbuf->type,
 367                                                 &stbuf->dev, &stbuf->qid,
 368                                                 &stbuf->mode, &stbuf->atime,
 369                                                 &stbuf->mtime, &stbuf->length,
 370                                                 &stbuf->name, &stbuf->uid,
 371                                                 &stbuf->gid, &stbuf->muid,
 372                                                 &stbuf->extension,
 373                                                 &stbuf->n_uid, &stbuf->n_gid,
 374                                                 &stbuf->n_muid);
 375                                 if (errcode)
 376                                         p9stat_free(stbuf);
 377                         }
 378                         break;
 379                 case 'D':{
 380                                 uint32_t *count = va_arg(ap, uint32_t *);
 381                                 void **data = va_arg(ap, void **);
 382
 383                                 errcode =
 384                                     p9pdu_readf(pdu, proto_version, "d", count);
 385                                 if (!errcode) {
 386                                         *count =
 387                                             min_t(uint32_t, *count,
 388                                                   pdu->size - pdu->offset);
 389                                         *data = &pdu->sdata[pdu->offset];
 390                                 }
 391                         }
 392                         break;
 393                 case 'T':{
 394                                 uint16_t *nwname = va_arg(ap, uint16_t *);
 395                                 char ***wnames = va_arg(ap, char ***);
 396
 397                                 errcode = p9pdu_readf(pdu, proto_version,
 398                                                                 "w", nwname);
 399                                 if (!errcode) {
 400                                         *wnames =
 401                                             kmalloc_array(*nwname,
 402                                                           sizeof(char *),
 403                                                           GFP_NOFS);
 404                                         if (!*wnames)
 405                                                 errcode = -ENOMEM;
 406                                 }
 407
 408                                 if (!errcode) {
 409                                         int i;
 410
 411                                         for (i = 0; i < *nwname; i++) {
 412                                                 errcode =
 413                                                     p9pdu_readf(pdu,
 414                                                                 proto_version,
 415                                                                 "s",
 416                                                                 &(*wnames)[i]);
 417                                                 if (errcode)
 418                                                         break;
 419                                         }
 420                                 }
 421
 422                                 if (errcode) {
 423                                         if (*wnames) {
 424                                                 int i;
 425
 426                                                 for (i = 0; i < *nwname; i++)
 427                                                         kfree((*wnames)[i]);
 428                                         }
 429                                         kfree(*wnames);
 430                                         *wnames = NULL;
 431                                 }
 432                         }
 433                         break;
 434                 case 'R':{
 435                                 uint16_t *nwqid = va_arg(ap, uint16_t *);
 436                                 struct p9_qid **wqids =
 437                                     va_arg(ap, struct p9_qid **);
 438
 439                                 *wqids = NULL;
 440
 441                                 errcode =
 442                                     p9pdu_readf(pdu, proto_version, "w", nwqid);
 443                                 if (!errcode) {
 444                                         *wqids =
 445                                             kmalloc_array(*nwqid,
 446                                                           sizeof(struct p9_qid),
 447                                                           GFP_NOFS);
 448                                         if (*wqids == NULL)
 449                                                 errcode = -ENOMEM;
 450                                 }
 451
 452                                 if (!errcode) {
 453                                         int i;
 454
 455                                         for (i = 0; i < *nwqid; i++) {
 456                                                 errcode =
 457                                                     p9pdu_readf(pdu,
 458                                                                 proto_version,
 459                                                                 "Q",
 460                                                                 &(*wqids)[i]);
 461                                                 if (errcode)
 462                                                         break;
 463                                         }
 464                                 }
 465
 466                                 if (errcode) {
 467                                         kfree(*wqids);
 468                                         *wqids = NULL;
 469                                 }
 470                         }
 471                         break;
 472                 case 'A': {
 473                                 struct p9_stat_dotl *stbuf =
 474                                     va_arg(ap, struct p9_stat_dotl *);
 475
 476                                 memset(stbuf, 0, sizeof(struct p9_stat_dotl));
 477                                 errcode =
 478                                     p9pdu_readf(pdu, proto_version,
 479                                         "qQdugqqqqqqqqqqqqqqq",
 480                                         &stbuf->st_result_mask,
 481                                         &stbuf->qid,
 482                                         &stbuf->st_mode,
 483                                         &stbuf->st_uid, &stbuf->st_gid,
 484                                         &stbuf->st_nlink,
 485                                         &stbuf->st_rdev, &stbuf->st_size,
 486                                         &stbuf->st_blksize, &stbuf->st_blocks,
 487                                         &stbuf->st_atime_sec,
 488                                         &stbuf->st_atime_nsec,
 489                                         &stbuf->st_mtime_sec,
 490                                         &stbuf->st_mtime_nsec,
 491                                         &stbuf->st_ctime_sec,
 492                                         &stbuf->st_ctime_nsec,
 493                                         &stbuf->st_btime_sec,
 494                                         &stbuf->st_btime_nsec,
 495                                         &stbuf->st_gen,
 496                                         &stbuf->st_data_version);
 497                         }
 498                         break;
 499                 case '?':
 500                         if ((proto_version != p9_proto_2000u) &&
 501                                 (proto_version != p9_proto_2000L))
 502                                 return 0;
 503                         break;
 504                 default:
 505                         BUG();
 506                         break;
 507                 }
 508
 509                 if (errcode)
 510                         break;
 511         }
 512
 513         return errcode;
 514 }
 515
 516 int
 517 p9pdu_vwritef(struct p9_fcall *pdu, int proto_version, const char *fmt,
 518         va_list ap)
 519 {
 520         const char *ptr;
 521         int errcode = 0;
 522
 523         for (ptr = fmt; *ptr; ptr++) {
 524                 switch (*ptr) {
 525                 case 'b':{
 526                                 int8_t val = va_arg(ap, int);
 527                                 if (pdu_write(pdu, &val, sizeof(val)))
 528                                         errcode = -EFAULT;
 529                         }
 530                         break;
 531                 case 'w':{
 532                                 __le16 val = cpu_to_le16(va_arg(ap, int));
 533                                 if (pdu_write(pdu, &val, sizeof(val)))
 534                                         errcode = -EFAULT;
 535                         }
 536                         break;
 537                 case 'd':{
 538                                 __le32 val = cpu_to_le32(va_arg(ap, int32_t));
 539                                 if (pdu_write(pdu, &val, sizeof(val)))
 540                                         errcode = -EFAULT;
 541                         }
 542                         break;
 543                 case 'q':{
 544                                 __le64 val = cpu_to_le64(va_arg(ap, int64_t));
 545                                 if (pdu_write(pdu, &val, sizeof(val)))
 546                                         errcode = -EFAULT;
 547                         }
 548                         break;
 549                 case 's':{
 550                                 const char *sptr = va_arg(ap, const char *);
 551                                 uint16_t len = 0;
 552                                 if (sptr)
 553                                         len = min_t(size_t, strlen(sptr),
 554                                                                 USHRT_MAX);
 555
 556                                 errcode = p9pdu_writef(pdu, proto_version,
 557                                                                 "w", len);
 558                                 if (!errcode && pdu_write(pdu, sptr, len))
 559                                         errcode = -EFAULT;
 560                         }
 561                         break;
 562                 case 'u': {
 563                                 kuid_t uid = va_arg(ap, kuid_t);
 564                                 __le32 val = cpu_to_le32(
 565                                                 from_kuid(&init_user_ns, uid));
 566                                 if (pdu_write(pdu, &val, sizeof(val)))
 567                                         errcode = -EFAULT;
 568                         } break;
 569                 case 'g': {
 570                                 kgid_t gid = va_arg(ap, kgid_t);
 571                                 __le32 val = cpu_to_le32(
 572                                                 from_kgid(&init_user_ns, gid));
 573                                 if (pdu_write(pdu, &val, sizeof(val)))
 574                                         errcode = -EFAULT;
 575                         } break;
 576                 case 'Q':{
 577                                 const struct p9_qid *qid =
 578                                     va_arg(ap, const struct p9_qid *);
 579                                 errcode =
 580                                     p9pdu_writef(pdu, proto_version, "bdq",
 581                                                  qid->type, qid->version,
 582                                                  qid->path);
 583                         } break;
 584                 case 'S':{
 585                                 const struct p9_wstat *stbuf =
 586                                     va_arg(ap, const struct p9_wstat *);
 587                                 errcode =
 588                                     p9pdu_writef(pdu, proto_version,
 589                                                  "wwdQdddqssss?sugu",
 590                                                  stbuf->size, stbuf->type,
 591                                                  stbuf->dev, &stbuf->qid,
 592                                                  stbuf->mode, stbuf->atime,
 593                                                  stbuf->mtime, stbuf->length,
 594                                                  stbuf->name, stbuf->uid,
 595                                                  stbuf->gid, stbuf->muid,
 596                                                  stbuf->extension, stbuf->n_uid,
 597                                                  stbuf->n_gid, stbuf->n_muid);
 598                         } break;
 599                 case 'V':{
 600                                 uint32_t count = va_arg(ap, uint32_t);
 601                                 struct iov_iter *from =
 602                                                 va_arg(ap, struct iov_iter *);
 603                                 errcode = p9pdu_writef(pdu, proto_version, "d",
 604                                                                         count);
 605                                 if (!errcode && pdu_write_u(pdu, from, count))
 606                                         errcode = -EFAULT;
 607                         }
 608                         break;
 609                 case 'T':{
 610                                 uint16_t nwname = va_arg(ap, int);
 611                                 const char **wnames = va_arg(ap, const char **);
 612
 613                                 errcode = p9pdu_writef(pdu, proto_version, "w",
 614                                                                         nwname);
 615                                 if (!errcode) {
 616                                         int i;
 617
 618                                         for (i = 0; i < nwname; i++) {
 619                                                 errcode =
 620                                                     p9pdu_writef(pdu,
 621                                                                 proto_version,
 622                                                                  "s",
 623                                                                  wnames[i]);
 624                                                 if (errcode)
 625                                                         break;
 626                                         }
 627                                 }
 628                         }
 629                         break;
 630                 case 'R':{
 631                                 uint16_t nwqid = va_arg(ap, int);
 632                                 struct p9_qid *wqids =
 633                                     va_arg(ap, struct p9_qid *);
 634
 635                                 errcode = p9pdu_writef(pdu, proto_version, "w",
 636                                                                         nwqid);
 637                                 if (!errcode) {
 638                                         int i;
 639
 640                                         for (i = 0; i < nwqid; i++) {
 641                                                 errcode =
 642                                                     p9pdu_writef(pdu,
 643                                                                 proto_version,
 644                                                                  "Q",
 645                                                                  &wqids[i]);
 646                                                 if (errcode)
 647                                                         break;
 648                                         }
 649                                 }
 650                         }
 651                         break;
 652                 case 'I':{
 653                                 struct p9_iattr_dotl *p9attr = va_arg(ap,
 654                                                         struct p9_iattr_dotl *);
 655
 656                                 errcode = p9pdu_writef(pdu, proto_version,
 657                                                         "ddugqqqqq",
 658                                                         p9attr->valid,
 659                                                         p9attr->mode,
 660                                                         p9attr->uid,
 661                                                         p9attr->gid,
 662                                                         p9attr->size,
 663                                                         p9attr->atime_sec,
 664                                                         p9attr->atime_nsec,
 665                                                         p9attr->mtime_sec,
 666                                                         p9attr->mtime_nsec);
 667                         }
 668                         break;
 669                 case '?':
 670                         if ((proto_version != p9_proto_2000u) &&
 671                                 (proto_version != p9_proto_2000L))
 672                                 return 0;
 673                         break;
 674                 default:
 675                         BUG();
 676                         break;
 677                 }
 678
 679                 if (errcode)
 680                         break;
 681         }
 682
 683         return errcode;
 684 }
 685
 686 int p9pdu_readf(struct p9_fcall *pdu, int proto_version, const char *fmt, ...)
 687 {
 688         va_list ap;
 689         int ret;
 690
 691         va_start(ap, fmt);
 692         ret = p9pdu_vreadf(pdu, proto_version, fmt, ap);
 693         va_end(ap);
 694
 695         return ret;
 696 }
 697
 698 static int
 699 p9pdu_writef(struct p9_fcall *pdu, int proto_version, const char *fmt, ...)
 700 {
 701         va_list ap;
 702         int ret;
 703
 704         va_start(ap, fmt);
 705         ret = p9pdu_vwritef(pdu, proto_version, fmt, ap);
 706         va_end(ap);
 707
 708         return ret;
 709 }
 710
 711 int p9stat_read(struct p9_client *clnt, char *buf, int len, struct p9_wstat *st)
 712 {
 713         struct p9_fcall fake_pdu;
 714         int ret;
 715
 716         fake_pdu.size = len;
 717         fake_pdu.capacity = len;
 718         fake_pdu.sdata = buf;
 719         fake_pdu.offset = 0;
 720
 721         ret = p9pdu_readf(&fake_pdu, clnt->proto_version, "S", st);
 722         if (ret) {
 723                 p9_debug(P9_DEBUG_9P, "<<< p9stat_read failed: %d\n", ret);
 724                 trace_9p_protocol_dump(clnt, &fake_pdu);
 725                 return ret;
 726         }
 727
 728         return fake_pdu.offset;
 729 }
 730 EXPORT_SYMBOL(p9stat_read);
 731
 732 int p9pdu_prepare(struct p9_fcall *pdu, int16_t tag, int8_t type)
 733 {
 734         pdu->id = type;
 735         return p9pdu_writef(pdu, 0, "dbw", 0, type, tag);
 736 }
 737
 738 int p9pdu_finalize(struct p9_client *clnt, struct p9_fcall *pdu)
 739 {
 740         int size = pdu->size;
 741         int err;
 742
 743         pdu->size = 0;
 744         err = p9pdu_writef(pdu, 0, "d", size);
 745         pdu->size = size;
 746
 747         trace_9p_protocol_dump(clnt, pdu);
 748         p9_debug(P9_DEBUG_9P, ">>> size=%d type: %d tag: %d\n",
 749                  pdu->size, pdu->id, pdu->tag);
 750
 751         return err;
 752 }
 753
 754 void p9pdu_reset(struct p9_fcall *pdu)
 755 {
 756         pdu->offset = 0;
 757         pdu->size = 0;
 758 }
 759
 760 int p9dirent_read(struct p9_client *clnt, char *buf, int len,
 761                   struct p9_dirent *dirent)
 762 {
 763         struct p9_fcall fake_pdu;
 764         int ret;
 765         char *nameptr;
 766
 767         fake_pdu.size = len;
 768         fake_pdu.capacity = len;
 769         fake_pdu.sdata = buf;
 770         fake_pdu.offset = 0;
 771
 772         ret = p9pdu_readf(&fake_pdu, clnt->proto_version, "Qqbs", &dirent->qid,
 773                           &dirent->d_off, &dirent->d_type, &nameptr);
 774         if (ret) {
 775                 p9_debug(P9_DEBUG_9P, "<<< p9dirent_read failed: %d\n", ret);
 776                 trace_9p_protocol_dump(clnt, &fake_pdu);
 777                 return ret;
 778         }
 779
 780         ret = strscpy(dirent->d_name, nameptr, sizeof(dirent->d_name));
 781         if (ret < 0) {
 782                 p9_debug(P9_DEBUG_ERROR,
 783                          "On the wire dirent name too long: %s\n",
 784                          nameptr);
 785                 kfree(nameptr);
 786                 return ret;
 787         }
 788         kfree(nameptr);
 789
 790         return fake_pdu.offset;
 791 }
 792 EXPORT_SYMBOL(p9dirent_read);