hw/9pfs/virtio-9p.c

   1 /*
   2  * Virtio 9p backend
   3  *
   4  * Copyright IBM, Corp. 2010
   5  *
   6  * Authors:
   7  *  Anthony Liguori   <aliguori@us.ibm.com>
   8  *
   9  * This work is licensed under the terms of the GNU GPL, version 2.  See
  10  * the COPYING file in the top-level directory.
  11  *
  12  */
  13
  14 #include "hw/virtio.h"
  15 #include "hw/pc.h"
  16 #include "qemu_socket.h"
  17 #include "hw/virtio-pci.h"
  18 #include "virtio-9p.h"
  19 #include "fsdev/qemu-fsdev.h"
  20 #include "virtio-9p-debug.h"
  21 #include "virtio-9p-xattr.h"
  22 #include "virtio-9p-coth.h"
  23
  24 int debug_9p_pdu;
  25
  26 enum {
  27     Oread   = 0x00,
  28     Owrite  = 0x01,
  29     Ordwr   = 0x02,
  30     Oexec   = 0x03,
  31     Oexcl   = 0x04,
  32     Otrunc  = 0x10,
  33     Orexec  = 0x20,
  34     Orclose = 0x40,
  35     Oappend = 0x80,
  36 };
  37
  38 static int omode_to_uflags(int8_t mode)
  39 {
  40     int ret = 0;
  41
  42     switch (mode & 3) {
  43     case Oread:
  44         ret = O_RDONLY;
  45         break;
  46     case Ordwr:
  47         ret = O_RDWR;
  48         break;
  49     case Owrite:
  50         ret = O_WRONLY;
  51         break;
  52     case Oexec:
  53         ret = O_RDONLY;
  54         break;
  55     }
  56
  57     if (mode & Otrunc) {
  58         ret |= O_TRUNC;
  59     }
  60
  61     if (mode & Oappend) {
  62         ret |= O_APPEND;
  63     }
  64
  65     if (mode & Oexcl) {
  66         ret |= O_EXCL;
  67     }
  68
  69     return ret;
  70 }
  71
  72 void cred_init(FsCred *credp)
  73 {
  74     credp->fc_uid = -1;
  75     credp->fc_gid = -1;
  76     credp->fc_mode = -1;
  77     credp->fc_rdev = -1;
  78 }
  79
  80 static void v9fs_string_init(V9fsString *str)
  81 {
  82     str->data = NULL;
  83     str->size = 0;
  84 }
  85
  86 static void v9fs_string_free(V9fsString *str)
  87 {
  88     g_free(str->data);
  89     str->data = NULL;
  90     str->size = 0;
  91 }
  92
  93 static void v9fs_string_null(V9fsString *str)
  94 {
  95     v9fs_string_free(str);
  96 }
  97
  98 static int number_to_string(void *arg, char type)
  99 {
 100     unsigned int ret = 0;
 101
 102     switch (type) {
 103     case 'u': {
 104         unsigned int num = *(unsigned int *)arg;
 105
 106         do {
 107             ret++;
 108             num = num/10;
 109         } while (num);
 110         break;
 111     }
 112     case 'U': {
 113         unsigned long num = *(unsigned long *)arg;
 114         do {
 115             ret++;
 116             num = num/10;
 117         } while (num);
 118         break;
 119     }
 120     default:
 121         printf("Number_to_string: Unknown number format\n");
 122         return -1;
 123     }
 124
 125     return ret;
 126 }
 127
 128 static int GCC_FMT_ATTR(2, 0)
 129 v9fs_string_alloc_printf(char **strp, const char *fmt, va_list ap)
 130 {
 131     va_list ap2;
 132     char *iter = (char *)fmt;
 133     int len = 0;
 134     int nr_args = 0;
 135     char *arg_char_ptr;
 136     unsigned int arg_uint;
 137     unsigned long arg_ulong;
 138
 139     /* Find the number of %'s that denotes an argument */
 140     for (iter = strstr(iter, "%"); iter; iter = strstr(iter, "%")) {
 141         nr_args++;
 142         iter++;
 143     }
 144
 145     len = strlen(fmt) - 2*nr_args;
 146
 147     if (!nr_args) {
 148         goto alloc_print;
 149     }
 150
 151     va_copy(ap2, ap);
 152
 153     iter = (char *)fmt;
 154
 155     /* Now parse the format string */
 156     for (iter = strstr(iter, "%"); iter; iter = strstr(iter, "%")) {
 157         iter++;
 158         switch (*iter) {
 159         case 'u':
 160             arg_uint = va_arg(ap2, unsigned int);
 161             len += number_to_string((void *)&arg_uint, 'u');
 162             break;
 163         case 'l':
 164             if (*++iter == 'u') {
 165                 arg_ulong = va_arg(ap2, unsigned long);
 166                 len += number_to_string((void *)&arg_ulong, 'U');
 167             } else {
 168                 return -1;
 169             }
 170             break;
 171         case 's':
 172             arg_char_ptr = va_arg(ap2, char *);
 173             len += strlen(arg_char_ptr);
 174             break;
 175         case 'c':
 176             len += 1;
 177             break;
 178         default:
 179             fprintf(stderr,
 180                     "v9fs_string_alloc_printf:Incorrect format %c", *iter);
 181             return -1;
 182         }
 183         iter++;
 184     }
 185
 186 alloc_print:
 187     *strp = g_malloc((len + 1) * sizeof(**strp));
 188
 189     return vsprintf(*strp, fmt, ap);
 190 }
 191
 192 static void GCC_FMT_ATTR(2, 3)
 193 v9fs_string_sprintf(V9fsString *str, const char *fmt, ...)
 194 {
 195     va_list ap;
 196     int err;
 197
 198     v9fs_string_free(str);
 199
 200     va_start(ap, fmt);
 201     err = v9fs_string_alloc_printf(&str->data, fmt, ap);
 202     BUG_ON(err == -1);
 203     va_end(ap);
 204
 205     str->size = err;
 206 }
 207
 208 static void v9fs_string_copy(V9fsString *lhs, V9fsString *rhs)
 209 {
 210     v9fs_string_free(lhs);
 211     v9fs_string_sprintf(lhs, "%s", rhs->data);
 212 }
 213
 214 /*
 215  * Return TRUE if s1 is an ancestor of s2.
 216  *
 217  * E.g. "a/b" is an ancestor of "a/b/c" but not of "a/bc/d".
 218  * As a special case, We treat s1 as ancestor of s2 if they are same!
 219  */
 220 static int v9fs_path_is_ancestor(V9fsString *s1, V9fsString *s2)
 221 {
 222     if (!strncmp(s1->data, s2->data, s1->size)) {
 223         if (s2->data[s1->size] == '\0' || s2->data[s1->size] == '/') {
 224             return 1;
 225         }
 226     }
 227     return 0;
 228 }
 229
 230 static size_t v9fs_string_size(V9fsString *str)
 231 {
 232     return str->size;
 233 }
 234
 235 static V9fsFidState *lookup_fid(V9fsState *s, int32_t fid)
 236 {
 237     V9fsFidState *f;
 238
 239     for (f = s->fid_list; f; f = f->next) {
 240         if (f->fid == fid) {
 241             return f;
 242         }
 243     }
 244
 245     return NULL;
 246 }
 247
 248 static V9fsFidState *alloc_fid(V9fsState *s, int32_t fid)
 249 {
 250     V9fsFidState *f;
 251
 252     f = lookup_fid(s, fid);
 253     if (f) {
 254         return NULL;
 255     }
 256
 257     f = g_malloc0(sizeof(V9fsFidState));
 258
 259     f->fid = fid;
 260     f->fid_type = P9_FID_NONE;
 261
 262     f->next = s->fid_list;
 263     s->fid_list = f;
 264
 265     return f;
 266 }
 267
 268 static int v9fs_xattr_fid_clunk(V9fsState *s, V9fsFidState *fidp)
 269 {
 270     int retval = 0;
 271
 272     if (fidp->fs.xattr.copied_len == -1) {
 273         /* getxattr/listxattr fid */
 274         goto free_value;
 275     }
 276     /*
 277      * if this is fid for setxattr. clunk should
 278      * result in setxattr localcall
 279      */
 280     if (fidp->fs.xattr.len != fidp->fs.xattr.copied_len) {
 281         /* clunk after partial write */
 282         retval = -EINVAL;
 283         goto free_out;
 284     }
 285     if (fidp->fs.xattr.len) {
 286         retval = v9fs_co_lsetxattr(s, &fidp->path, &fidp->fs.xattr.name,
 287                                    fidp->fs.xattr.value,
 288                                    fidp->fs.xattr.len,
 289                                    fidp->fs.xattr.flags);
 290     } else {
 291         retval = v9fs_co_lremovexattr(s, &fidp->path, &fidp->fs.xattr.name);
 292     }
 293 free_out:
 294     v9fs_string_free(&fidp->fs.xattr.name);
 295 free_value:
 296     if (fidp->fs.xattr.value) {
 297         g_free(fidp->fs.xattr.value);
 298     }
 299     return retval;
 300 }
 301
 302 static int free_fid(V9fsState *s, int32_t fid)
 303 {
 304     int retval = 0;
 305     V9fsFidState **fidpp, *fidp;
 306
 307     for (fidpp = &s->fid_list; *fidpp; fidpp = &(*fidpp)->next) {
 308         if ((*fidpp)->fid == fid) {
 309             break;
 310         }
 311     }
 312
 313     if (*fidpp == NULL) {
 314         return -ENOENT;
 315     }
 316
 317     fidp = *fidpp;
 318     *fidpp = fidp->next;
 319
 320     if (fidp->fid_type == P9_FID_FILE) {
 321         retval = v9fs_co_close(s, fidp);
 322     } else if (fidp->fid_type == P9_FID_DIR) {
 323         retval = v9fs_co_closedir(s, fidp);
 324     } else if (fidp->fid_type == P9_FID_XATTR) {
 325         retval = v9fs_xattr_fid_clunk(s, fidp);
 326     }
 327     v9fs_string_free(&fidp->path);
 328     g_free(fidp);
 329     return retval;
 330 }
 331
 332 #define P9_QID_TYPE_DIR         0x80
 333 #define P9_QID_TYPE_SYMLINK     0x02
 334
 335 #define P9_STAT_MODE_DIR        0x80000000
 336 #define P9_STAT_MODE_APPEND     0x40000000
 337 #define P9_STAT_MODE_EXCL       0x20000000
 338 #define P9_STAT_MODE_MOUNT      0x10000000
 339 #define P9_STAT_MODE_AUTH       0x08000000
 340 #define P9_STAT_MODE_TMP        0x04000000
 341 #define P9_STAT_MODE_SYMLINK    0x02000000
 342 #define P9_STAT_MODE_LINK       0x01000000
 343 #define P9_STAT_MODE_DEVICE     0x00800000
 344 #define P9_STAT_MODE_NAMED_PIPE 0x00200000
 345 #define P9_STAT_MODE_SOCKET     0x00100000
 346 #define P9_STAT_MODE_SETUID     0x00080000
 347 #define P9_STAT_MODE_SETGID     0x00040000
 348 #define P9_STAT_MODE_SETVTX     0x00010000
 349
 350 #define P9_STAT_MODE_TYPE_BITS (P9_STAT_MODE_DIR |          \
 351                                 P9_STAT_MODE_SYMLINK |      \
 352                                 P9_STAT_MODE_LINK |         \
 353                                 P9_STAT_MODE_DEVICE |       \
 354                                 P9_STAT_MODE_NAMED_PIPE |   \
 355                                 P9_STAT_MODE_SOCKET)
 356
 357 /* This is the algorithm from ufs in spfs */
 358 static void stat_to_qid(const struct stat *stbuf, V9fsQID *qidp)
 359 {
 360     size_t size;
 361
 362     size = MIN(sizeof(stbuf->st_ino), sizeof(qidp->path));
 363     memcpy(&qidp->path, &stbuf->st_ino, size);
 364     qidp->version = stbuf->st_mtime ^ (stbuf->st_size << 8);
 365     qidp->type = 0;
 366     if (S_ISDIR(stbuf->st_mode)) {
 367         qidp->type |= P9_QID_TYPE_DIR;
 368     }
 369     if (S_ISLNK(stbuf->st_mode)) {
 370         qidp->type |= P9_QID_TYPE_SYMLINK;
 371     }
 372 }
 373
 374 static int fid_to_qid(V9fsState *s, V9fsFidState *fidp, V9fsQID *qidp)
 375 {
 376     struct stat stbuf;
 377     int err;
 378
 379     err = v9fs_co_lstat(s, &fidp->path, &stbuf);
 380     if (err < 0) {
 381         return err;
 382     }
 383     stat_to_qid(&stbuf, qidp);
 384     return 0;
 385 }
 386
 387 static V9fsPDU *alloc_pdu(V9fsState *s)
 388 {
 389     V9fsPDU *pdu = NULL;
 390
 391     if (!QLIST_EMPTY(&s->free_list)) {
 392         pdu = QLIST_FIRST(&s->free_list);
 393         QLIST_REMOVE(pdu, next);
 394     }
 395     return pdu;
 396 }
 397
 398 static void free_pdu(V9fsState *s, V9fsPDU *pdu)
 399 {
 400     if (pdu) {
 401         if (debug_9p_pdu) {
 402             pprint_pdu(pdu);
 403         }
 404         QLIST_INSERT_HEAD(&s->free_list, pdu, next);
 405     }
 406 }
 407
 408 size_t pdu_packunpack(void *addr, struct iovec *sg, int sg_count,
 409                         size_t offset, size_t size, int pack)
 410 {
 411     int i = 0;
 412     size_t copied = 0;
 413
 414     for (i = 0; size && i < sg_count; i++) {
 415         size_t len;
 416         if (offset >= sg[i].iov_len) {
 417             /* skip this sg */
 418             offset -= sg[i].iov_len;
 419             continue;
 420         } else {
 421             len = MIN(sg[i].iov_len - offset, size);
 422             if (pack) {
 423                 memcpy(sg[i].iov_base + offset, addr, len);
 424             } else {
 425                 memcpy(addr, sg[i].iov_base + offset, len);
 426             }
 427             size -= len;
 428             copied += len;
 429             addr += len;
 430             if (size) {
 431                 offset = 0;
 432                 continue;
 433             }
 434         }
 435     }
 436
 437     return copied;
 438 }
 439
 440 static size_t pdu_unpack(void *dst, V9fsPDU *pdu, size_t offset, size_t size)
 441 {
 442     return pdu_packunpack(dst, pdu->elem.out_sg, pdu->elem.out_num,
 443                          offset, size, 0);
 444 }
 445
 446 static size_t pdu_pack(V9fsPDU *pdu, size_t offset, const void *src,
 447                         size_t size)
 448 {
 449     return pdu_packunpack((void *)src, pdu->elem.in_sg, pdu->elem.in_num,
 450                              offset, size, 1);
 451 }
 452
 453 static int pdu_copy_sg(V9fsPDU *pdu, size_t offset, int rx, struct iovec *sg)
 454 {
 455     size_t pos = 0;
 456     int i, j;
 457     struct iovec *src_sg;
 458     unsigned int num;
 459
 460     if (rx) {
 461         src_sg = pdu->elem.in_sg;
 462         num = pdu->elem.in_num;
 463     } else {
 464         src_sg = pdu->elem.out_sg;
 465         num = pdu->elem.out_num;
 466     }
 467
 468     j = 0;
 469     for (i = 0; i < num; i++) {
 470         if (offset <= pos) {
 471             sg[j].iov_base = src_sg[i].iov_base;
 472             sg[j].iov_len = src_sg[i].iov_len;
 473             j++;
 474         } else if (offset < (src_sg[i].iov_len + pos)) {
 475             sg[j].iov_base = src_sg[i].iov_base;
 476             sg[j].iov_len = src_sg[i].iov_len;
 477             sg[j].iov_base += (offset - pos);
 478             sg[j].iov_len -= (offset - pos);
 479             j++;
 480         }
 481         pos += src_sg[i].iov_len;
 482     }
 483
 484     return j;
 485 }
 486
 487 static size_t pdu_unmarshal(V9fsPDU *pdu, size_t offset, const char *fmt, ...)
 488 {
 489     size_t old_offset = offset;
 490     va_list ap;
 491     int i;
 492
 493     va_start(ap, fmt);
 494     for (i = 0; fmt[i]; i++) {
 495         switch (fmt[i]) {
 496         case 'b': {
 497             uint8_t *valp = va_arg(ap, uint8_t *);
 498             offset += pdu_unpack(valp, pdu, offset, sizeof(*valp));
 499             break;
 500         }
 501         case 'w': {
 502             uint16_t val, *valp;
 503             valp = va_arg(ap, uint16_t *);
 504             offset += pdu_unpack(&val, pdu, offset, sizeof(val));
 505             *valp = le16_to_cpu(val);
 506             break;
 507         }
 508         case 'd': {
 509             uint32_t val, *valp;
 510             valp = va_arg(ap, uint32_t *);
 511             offset += pdu_unpack(&val, pdu, offset, sizeof(val));
 512             *valp = le32_to_cpu(val);
 513             break;
 514         }
 515         case 'q': {
 516             uint64_t val, *valp;
 517             valp = va_arg(ap, uint64_t *);
 518             offset += pdu_unpack(&val, pdu, offset, sizeof(val));
 519             *valp = le64_to_cpu(val);
 520             break;
 521         }
 522         case 'v': {
 523             struct iovec *iov = va_arg(ap, struct iovec *);
 524             int *iovcnt = va_arg(ap, int *);
 525             *iovcnt = pdu_copy_sg(pdu, offset, 0, iov);
 526             break;
 527         }
 528         case 's': {
 529             V9fsString *str = va_arg(ap, V9fsString *);
 530             offset += pdu_unmarshal(pdu, offset, "w", &str->size);
 531             /* FIXME: sanity check str->size */
 532             str->data = g_malloc(str->size + 1);
 533             offset += pdu_unpack(str->data, pdu, offset, str->size);
 534             str->data[str->size] = 0;
 535             break;
 536         }
 537         case 'Q': {
 538             V9fsQID *qidp = va_arg(ap, V9fsQID *);
 539             offset += pdu_unmarshal(pdu, offset, "bdq",
 540                         &qidp->type, &qidp->version, &qidp->path);
 541             break;
 542         }
 543         case 'S': {
 544             V9fsStat *statp = va_arg(ap, V9fsStat *);
 545             offset += pdu_unmarshal(pdu, offset, "wwdQdddqsssssddd",
 546                         &statp->size, &statp->type, &statp->dev,
 547                         &statp->qid, &statp->mode, &statp->atime,
 548                         &statp->mtime, &statp->length,
 549                         &statp->name, &statp->uid, &statp->gid,
 550                         &statp->muid, &statp->extension,
 551                         &statp->n_uid, &statp->n_gid,
 552                         &statp->n_muid);
 553             break;
 554         }
 555         case 'I': {
 556             V9fsIattr *iattr = va_arg(ap, V9fsIattr *);
 557             offset += pdu_unmarshal(pdu, offset, "ddddqqqqq",
 558                         &iattr->valid, &iattr->mode,
 559                         &iattr->uid, &iattr->gid, &iattr->size,
 560                         &iattr->atime_sec, &iattr->atime_nsec,
 561                         &iattr->mtime_sec, &iattr->mtime_nsec);
 562             break;
 563         }
 564         default:
 565             break;
 566         }
 567     }
 568
 569     va_end(ap);
 570
 571     return offset - old_offset;
 572 }
 573
 574 static size_t pdu_marshal(V9fsPDU *pdu, size_t offset, const char *fmt, ...)
 575 {
 576     size_t old_offset = offset;
 577     va_list ap;
 578     int i;
 579
 580     va_start(ap, fmt);
 581     for (i = 0; fmt[i]; i++) {
 582         switch (fmt[i]) {
 583         case 'b': {
 584             uint8_t val = va_arg(ap, int);
 585             offset += pdu_pack(pdu, offset, &val, sizeof(val));
 586             break;
 587         }
 588         case 'w': {
 589             uint16_t val;
 590             cpu_to_le16w(&val, va_arg(ap, int));
 591             offset += pdu_pack(pdu, offset, &val, sizeof(val));
 592             break;
 593         }
 594         case 'd': {
 595             uint32_t val;
 596             cpu_to_le32w(&val, va_arg(ap, uint32_t));
 597             offset += pdu_pack(pdu, offset, &val, sizeof(val));
 598             break;
 599         }
 600         case 'q': {
 601             uint64_t val;
 602             cpu_to_le64w(&val, va_arg(ap, uint64_t));
 603             offset += pdu_pack(pdu, offset, &val, sizeof(val));
 604             break;
 605         }
 606         case 'v': {
 607             struct iovec *iov = va_arg(ap, struct iovec *);
 608             int *iovcnt = va_arg(ap, int *);
 609             *iovcnt = pdu_copy_sg(pdu, offset, 1, iov);
 610             break;
 611         }
 612         case 's': {
 613             V9fsString *str = va_arg(ap, V9fsString *);
 614             offset += pdu_marshal(pdu, offset, "w", str->size);
 615             offset += pdu_pack(pdu, offset, str->data, str->size);
 616             break;
 617         }
 618         case 'Q': {
 619             V9fsQID *qidp = va_arg(ap, V9fsQID *);
 620             offset += pdu_marshal(pdu, offset, "bdq",
 621                         qidp->type, qidp->version, qidp->path);
 622             break;
 623         }
 624         case 'S': {
 625             V9fsStat *statp = va_arg(ap, V9fsStat *);
 626             offset += pdu_marshal(pdu, offset, "wwdQdddqsssssddd",
 627                         statp->size, statp->type, statp->dev,
 628                         &statp->qid, statp->mode, statp->atime,
 629                         statp->mtime, statp->length, &statp->name,
 630                         &statp->uid, &statp->gid, &statp->muid,
 631                         &statp->extension, statp->n_uid,
 632                         statp->n_gid, statp->n_muid);
 633             break;
 634         }
 635         case 'A': {
 636             V9fsStatDotl *statp = va_arg(ap, V9fsStatDotl *);
 637             offset += pdu_marshal(pdu, offset, "qQdddqqqqqqqqqqqqqqq",
 638                         statp->st_result_mask,
 639                         &statp->qid, statp->st_mode,
 640                         statp->st_uid, statp->st_gid,
 641                         statp->st_nlink, statp->st_rdev,
 642                         statp->st_size, statp->st_blksize, statp->st_blocks,
 643                         statp->st_atime_sec, statp->st_atime_nsec,
 644                         statp->st_mtime_sec, statp->st_mtime_nsec,
 645                         statp->st_ctime_sec, statp->st_ctime_nsec,
 646                         statp->st_btime_sec, statp->st_btime_nsec,
 647                         statp->st_gen, statp->st_data_version);
 648             break;
 649         }
 650         default:
 651             break;
 652         }
 653     }
 654     va_end(ap);
 655
 656     return offset - old_offset;
 657 }
 658
 659 static void complete_pdu(V9fsState *s, V9fsPDU *pdu, ssize_t len)
 660 {
 661     int8_t id = pdu->id + 1; /* Response */
 662
 663     if (len < 0) {
 664         int err = -len;
 665         len = 7;
 666
 667         if (s->proto_version != V9FS_PROTO_2000L) {
 668             V9fsString str;
 669
 670             str.data = strerror(err);
 671             str.size = strlen(str.data);
 672
 673             len += pdu_marshal(pdu, len, "s", &str);
 674             id = P9_RERROR;
 675         }
 676
 677         len += pdu_marshal(pdu, len, "d", err);
 678
 679         if (s->proto_version == V9FS_PROTO_2000L) {
 680             id = P9_RLERROR;
 681         }
 682     }
 683
 684     /* fill out the header */
 685     pdu_marshal(pdu, 0, "dbw", (int32_t)len, id, pdu->tag);
 686
 687     /* keep these in sync */
 688     pdu->size = len;
 689     pdu->id = id;
 690
 691     /* push onto queue and notify */
 692     virtqueue_push(s->vq, &pdu->elem, len);
 693
 694     /* FIXME: we should batch these completions */
 695     virtio_notify(&s->vdev, s->vq);
 696
 697     free_pdu(s, pdu);
 698 }
 699
 700 static mode_t v9mode_to_mode(uint32_t mode, V9fsString *extension)
 701 {
 702     mode_t ret;
 703
 704     ret = mode & 0777;
 705     if (mode & P9_STAT_MODE_DIR) {
 706         ret |= S_IFDIR;
 707     }
 708
 709     if (mode & P9_STAT_MODE_SYMLINK) {
 710         ret |= S_IFLNK;
 711     }
 712     if (mode & P9_STAT_MODE_SOCKET) {
 713         ret |= S_IFSOCK;
 714     }
 715     if (mode & P9_STAT_MODE_NAMED_PIPE) {
 716         ret |= S_IFIFO;
 717     }
 718     if (mode & P9_STAT_MODE_DEVICE) {
 719         if (extension && extension->data[0] == 'c') {
 720             ret |= S_IFCHR;
 721         } else {
 722             ret |= S_IFBLK;
 723         }
 724     }
 725
 726     if (!(ret&~0777)) {
 727         ret |= S_IFREG;
 728     }
 729
 730     if (mode & P9_STAT_MODE_SETUID) {
 731         ret |= S_ISUID;
 732     }
 733     if (mode & P9_STAT_MODE_SETGID) {
 734         ret |= S_ISGID;
 735     }
 736     if (mode & P9_STAT_MODE_SETVTX) {
 737         ret |= S_ISVTX;
 738     }
 739
 740     return ret;
 741 }
 742
 743 static int donttouch_stat(V9fsStat *stat)
 744 {
 745     if (stat->type == -1 &&
 746         stat->dev == -1 &&
 747         stat->qid.type == -1 &&
 748         stat->qid.version == -1 &&
 749         stat->qid.path == -1 &&
 750         stat->mode == -1 &&
 751         stat->atime == -1 &&
 752         stat->mtime == -1 &&
 753         stat->length == -1 &&
 754         !stat->name.size &&
 755         !stat->uid.size &&
 756         !stat->gid.size &&
 757         !stat->muid.size &&
 758         stat->n_uid == -1 &&
 759         stat->n_gid == -1 &&
 760         stat->n_muid == -1) {
 761         return 1;
 762     }
 763
 764     return 0;
 765 }
 766
 767 static void v9fs_stat_free(V9fsStat *stat)
 768 {
 769     v9fs_string_free(&stat->name);
 770     v9fs_string_free(&stat->uid);
 771     v9fs_string_free(&stat->gid);
 772     v9fs_string_free(&stat->muid);
 773     v9fs_string_free(&stat->extension);
 774 }
 775
 776 static uint32_t stat_to_v9mode(const struct stat *stbuf)
 777 {
 778     uint32_t mode;
 779
 780     mode = stbuf->st_mode & 0777;
 781     if (S_ISDIR(stbuf->st_mode)) {
 782         mode |= P9_STAT_MODE_DIR;
 783     }
 784
 785     if (S_ISLNK(stbuf->st_mode)) {
 786         mode |= P9_STAT_MODE_SYMLINK;
 787     }
 788
 789     if (S_ISSOCK(stbuf->st_mode)) {
 790         mode |= P9_STAT_MODE_SOCKET;
 791     }
 792
 793     if (S_ISFIFO(stbuf->st_mode)) {
 794         mode |= P9_STAT_MODE_NAMED_PIPE;
 795     }
 796
 797     if (S_ISBLK(stbuf->st_mode) || S_ISCHR(stbuf->st_mode)) {
 798         mode |= P9_STAT_MODE_DEVICE;
 799     }
 800
 801     if (stbuf->st_mode & S_ISUID) {
 802         mode |= P9_STAT_MODE_SETUID;
 803     }
 804
 805     if (stbuf->st_mode & S_ISGID) {
 806         mode |= P9_STAT_MODE_SETGID;
 807     }
 808
 809     if (stbuf->st_mode & S_ISVTX) {
 810         mode |= P9_STAT_MODE_SETVTX;
 811     }
 812
 813     return mode;
 814 }
 815
 816 static int stat_to_v9stat(V9fsState *s, V9fsString *name,
 817                             const struct stat *stbuf,
 818                             V9fsStat *v9stat)
 819 {
 820     int err;
 821     const char *str;
 822
 823     memset(v9stat, 0, sizeof(*v9stat));
 824
 825     stat_to_qid(stbuf, &v9stat->qid);
 826     v9stat->mode = stat_to_v9mode(stbuf);
 827     v9stat->atime = stbuf->st_atime;
 828     v9stat->mtime = stbuf->st_mtime;
 829     v9stat->length = stbuf->st_size;
 830
 831     v9fs_string_null(&v9stat->uid);
 832     v9fs_string_null(&v9stat->gid);
 833     v9fs_string_null(&v9stat->muid);
 834
 835     v9stat->n_uid = stbuf->st_uid;
 836     v9stat->n_gid = stbuf->st_gid;
 837     v9stat->n_muid = 0;
 838
 839     v9fs_string_null(&v9stat->extension);
 840
 841     if (v9stat->mode & P9_STAT_MODE_SYMLINK) {
 842         err = v9fs_co_readlink(s, name, &v9stat->extension);
 843         if (err < 0) {
 844             return err;
 845         }
 846     } else if (v9stat->mode & P9_STAT_MODE_DEVICE) {
 847         v9fs_string_sprintf(&v9stat->extension, "%c %u %u",
 848                 S_ISCHR(stbuf->st_mode) ? 'c' : 'b',
 849                 major(stbuf->st_rdev), minor(stbuf->st_rdev));
 850     } else if (S_ISDIR(stbuf->st_mode) || S_ISREG(stbuf->st_mode)) {
 851         v9fs_string_sprintf(&v9stat->extension, "%s %lu",
 852                 "HARDLINKCOUNT", (unsigned long)stbuf->st_nlink);
 853     }
 854
 855     str = strrchr(name->data, '/');
 856     if (str) {
 857         str += 1;
 858     } else {
 859         str = name->data;
 860     }
 861
 862     v9fs_string_sprintf(&v9stat->name, "%s", str);
 863
 864     v9stat->size = 61 +
 865         v9fs_string_size(&v9stat->name) +
 866         v9fs_string_size(&v9stat->uid) +
 867         v9fs_string_size(&v9stat->gid) +
 868         v9fs_string_size(&v9stat->muid) +
 869         v9fs_string_size(&v9stat->extension);
 870     return 0;
 871 }
 872
 873 #define P9_STATS_MODE          0x00000001ULL
 874 #define P9_STATS_NLINK         0x00000002ULL
 875 #define P9_STATS_UID           0x00000004ULL
 876 #define P9_STATS_GID           0x00000008ULL
 877 #define P9_STATS_RDEV          0x00000010ULL
 878 #define P9_STATS_ATIME         0x00000020ULL
 879 #define P9_STATS_MTIME         0x00000040ULL
 880 #define P9_STATS_CTIME         0x00000080ULL
 881 #define P9_STATS_INO           0x00000100ULL
 882 #define P9_STATS_SIZE          0x00000200ULL
 883 #define P9_STATS_BLOCKS        0x00000400ULL
 884
 885 #define P9_STATS_BTIME         0x00000800ULL
 886 #define P9_STATS_GEN           0x00001000ULL
 887 #define P9_STATS_DATA_VERSION  0x00002000ULL
 888
 889 #define P9_STATS_BASIC         0x000007ffULL /* Mask for fields up to BLOCKS */
 890 #define P9_STATS_ALL           0x00003fffULL /* Mask for All fields above */
 891
 892
 893 static void stat_to_v9stat_dotl(V9fsState *s, const struct stat *stbuf,
 894                                 V9fsStatDotl *v9lstat)
 895 {
 896     memset(v9lstat, 0, sizeof(*v9lstat));
 897
 898     v9lstat->st_mode = stbuf->st_mode;
 899     v9lstat->st_nlink = stbuf->st_nlink;
 900     v9lstat->st_uid = stbuf->st_uid;
 901     v9lstat->st_gid = stbuf->st_gid;
 902     v9lstat->st_rdev = stbuf->st_rdev;
 903     v9lstat->st_size = stbuf->st_size;
 904     v9lstat->st_blksize = stbuf->st_blksize;
 905     v9lstat->st_blocks = stbuf->st_blocks;
 906     v9lstat->st_atime_sec = stbuf->st_atime;
 907     v9lstat->st_atime_nsec = stbuf->st_atim.tv_nsec;
 908     v9lstat->st_mtime_sec = stbuf->st_mtime;
 909     v9lstat->st_mtime_nsec = stbuf->st_mtim.tv_nsec;
 910     v9lstat->st_ctime_sec = stbuf->st_ctime;
 911     v9lstat->st_ctime_nsec = stbuf->st_ctim.tv_nsec;
 912     /* Currently we only support BASIC fields in stat */
 913     v9lstat->st_result_mask = P9_STATS_BASIC;
 914
 915     stat_to_qid(stbuf, &v9lstat->qid);
 916 }
 917
 918 static struct iovec *adjust_sg(struct iovec *sg, int len, int *iovcnt)
 919 {
 920     while (len && *iovcnt) {
 921         if (len < sg->iov_len) {
 922             sg->iov_len -= len;
 923             sg->iov_base += len;
 924             len = 0;
 925         } else {
 926             len -= sg->iov_len;
 927             sg++;
 928             *iovcnt -= 1;
 929         }
 930     }
 931
 932     return sg;
 933 }
 934
 935 static struct iovec *cap_sg(struct iovec *sg, int cap, int *cnt)
 936 {
 937     int i;
 938     int total = 0;
 939
 940     for (i = 0; i < *cnt; i++) {
 941         if ((total + sg[i].iov_len) > cap) {
 942             sg[i].iov_len -= ((total + sg[i].iov_len) - cap);
 943             i++;
 944             break;
 945         }
 946         total += sg[i].iov_len;
 947     }
 948
 949     *cnt = i;
 950
 951     return sg;
 952 }
 953
 954 static void print_sg(struct iovec *sg, int cnt)
 955 {
 956     int i;
 957
 958     printf("sg[%d]: {", cnt);
 959     for (i = 0; i < cnt; i++) {
 960         if (i) {
 961             printf(", ");
 962         }
 963         printf("(%p, %zd)", sg[i].iov_base, sg[i].iov_len);
 964     }
 965     printf("}\n");
 966 }
 967
 968 static void v9fs_fix_path(V9fsString *dst, V9fsString *src, int len)
 969 {
 970     V9fsString str;
 971     v9fs_string_init(&str);
 972     v9fs_string_copy(&str, dst);
 973     v9fs_string_sprintf(dst, "%s%s", src->data, str.data+len);
 974     v9fs_string_free(&str);
 975 }
 976
 977 static void v9fs_version(void *opaque)
 978 {
 979     V9fsPDU *pdu = opaque;
 980     V9fsState *s = pdu->s;
 981     V9fsString version;
 982     size_t offset = 7;
 983
 984     pdu_unmarshal(pdu, offset, "ds", &s->msize, &version);
 985
 986     if (!strcmp(version.data, "9P2000.u")) {
 987         s->proto_version = V9FS_PROTO_2000U;
 988     } else if (!strcmp(version.data, "9P2000.L")) {
 989         s->proto_version = V9FS_PROTO_2000L;
 990     } else {
 991         v9fs_string_sprintf(&version, "unknown");
 992     }
 993
 994     offset += pdu_marshal(pdu, offset, "ds", s->msize, &version);
 995     complete_pdu(s, pdu, offset);
 996
 997     v9fs_string_free(&version);
 998     return;
 999 }
1000
1001 static void v9fs_attach(void *opaque)
1002 {
1003     V9fsPDU *pdu = opaque;
1004     V9fsState *s = pdu->s;
1005     int32_t fid, afid, n_uname;
1006     V9fsString uname, aname;
1007     V9fsFidState *fidp;
1008     size_t offset = 7;
1009     V9fsQID qid;
1010     ssize_t err;
1011
1012     pdu_unmarshal(pdu, offset, "ddssd", &fid, &afid, &uname, &aname, &n_uname);
1013
1014     fidp = alloc_fid(s, fid);
1015     if (fidp == NULL) {
1016         err = -EINVAL;
1017         goto out;
1018     }
1019     fidp->uid = n_uname;
1020     v9fs_string_sprintf(&fidp->path, "%s", "/");
1021     err = fid_to_qid(s, fidp, &qid);
1022     if (err < 0) {
1023         err = -EINVAL;
1024         free_fid(s, fid);
1025         goto out;
1026     }
1027     offset += pdu_marshal(pdu, offset, "Q", &qid);
1028     err = offset;
1029 out:
1030     complete_pdu(s, pdu, err);
1031     v9fs_string_free(&uname);
1032     v9fs_string_free(&aname);
1033 }
1034
1035 static void v9fs_stat(void *opaque)
1036 {
1037     int32_t fid;
1038     V9fsStat v9stat;
1039     ssize_t err = 0;
1040     size_t offset = 7;
1041     struct stat stbuf;
1042     V9fsFidState *fidp;
1043     V9fsPDU *pdu = opaque;
1044     V9fsState *s = pdu->s;
1045
1046     pdu_unmarshal(pdu, offset, "d", &fid);
1047     fidp = lookup_fid(s, fid);
1048     if (fidp == NULL) {
1049         err = -ENOENT;
1050         goto out;
1051     }
1052     err = v9fs_co_lstat(s, &fidp->path, &stbuf);
1053     if (err < 0) {
1054         goto out;
1055     }
1056     err = stat_to_v9stat(s, &fidp->path, &stbuf, &v9stat);
1057     if (err < 0) {
1058         goto out;
1059     }
1060     offset += pdu_marshal(pdu, offset, "wS", 0, &v9stat);
1061     err = offset;
1062     v9fs_stat_free(&v9stat);
1063 out:
1064     complete_pdu(s, pdu, err);
1065 }
1066
1067 static void v9fs_getattr(void *opaque)
1068 {
1069     int32_t fid;
1070     size_t offset = 7;
1071     ssize_t retval = 0;
1072     struct stat stbuf;
1073     V9fsFidState *fidp;
1074     uint64_t request_mask;
1075     V9fsStatDotl v9stat_dotl;
1076     V9fsPDU *pdu = opaque;
1077     V9fsState *s = pdu->s;
1078
1079     pdu_unmarshal(pdu, offset, "dq", &fid, &request_mask);
1080
1081     fidp = lookup_fid(s, fid);
1082     if (fidp == NULL) {
1083         retval = -ENOENT;
1084         goto out;
1085     }
1086     /*
1087      * Currently we only support BASIC fields in stat, so there is no
1088      * need to look at request_mask.
1089      */
1090     retval = v9fs_co_lstat(s, &fidp->path, &stbuf);
1091     if (retval < 0) {
1092         goto out;
1093     }
1094     stat_to_v9stat_dotl(s, &stbuf, &v9stat_dotl);
1095     retval = offset;
1096     retval += pdu_marshal(pdu, offset, "A", &v9stat_dotl);
1097 out:
1098     complete_pdu(s, pdu, retval);
1099 }
1100
1101 /* From Linux kernel code */
1102 #define ATTR_MODE    (1 << 0)
1103 #define ATTR_UID     (1 << 1)
1104 #define ATTR_GID     (1 << 2)
1105 #define ATTR_SIZE    (1 << 3)
1106 #define ATTR_ATIME   (1 << 4)
1107 #define ATTR_MTIME   (1 << 5)
1108 #define ATTR_CTIME   (1 << 6)
1109 #define ATTR_MASK    127
1110 #define ATTR_ATIME_SET  (1 << 7)
1111 #define ATTR_MTIME_SET  (1 << 8)
1112
1113 static void v9fs_setattr(void *opaque)
1114 {
1115     int err = 0;
1116     int32_t fid;
1117     V9fsFidState *fidp;
1118     size_t offset = 7;
1119     V9fsIattr v9iattr;
1120     V9fsPDU *pdu = opaque;
1121     V9fsState *s = pdu->s;
1122
1123     pdu_unmarshal(pdu, offset, "dI", &fid, &v9iattr);
1124
1125     fidp = lookup_fid(s, fid);
1126     if (fidp == NULL) {
1127         err = -EINVAL;
1128         goto out;
1129     }
1130     if (v9iattr.valid & ATTR_MODE) {
1131         err = v9fs_co_chmod(s, &fidp->path, v9iattr.mode);
1132         if (err < 0) {
1133             goto out;
1134         }
1135     }
1136     if (v9iattr.valid & (ATTR_ATIME | ATTR_MTIME)) {
1137         struct timespec times[2];
1138         if (v9iattr.valid & ATTR_ATIME) {
1139             if (v9iattr.valid & ATTR_ATIME_SET) {
1140                 times[0].tv_sec = v9iattr.atime_sec;
1141                 times[0].tv_nsec = v9iattr.atime_nsec;
1142             } else {
1143                 times[0].tv_nsec = UTIME_NOW;
1144             }
1145         } else {
1146             times[0].tv_nsec = UTIME_OMIT;
1147         }
1148         if (v9iattr.valid & ATTR_MTIME) {
1149             if (v9iattr.valid & ATTR_MTIME_SET) {
1150                 times[1].tv_sec = v9iattr.mtime_sec;
1151                 times[1].tv_nsec = v9iattr.mtime_nsec;
1152             } else {
1153                 times[1].tv_nsec = UTIME_NOW;
1154             }
1155         } else {
1156             times[1].tv_nsec = UTIME_OMIT;
1157         }
1158         err = v9fs_co_utimensat(s, &fidp->path, times);
1159         if (err < 0) {
1160             goto out;
1161         }
1162     }
1163     /*
1164      * If the only valid entry in iattr is ctime we can call
1165      * chown(-1,-1) to update the ctime of the file
1166      */
1167     if ((v9iattr.valid & (ATTR_UID | ATTR_GID)) ||
1168         ((v9iattr.valid & ATTR_CTIME)
1169          && !((v9iattr.valid & ATTR_MASK) & ~ATTR_CTIME))) {
1170         if (!(v9iattr.valid & ATTR_UID)) {
1171             v9iattr.uid = -1;
1172         }
1173         if (!(v9iattr.valid & ATTR_GID)) {
1174             v9iattr.gid = -1;
1175         }
1176         err = v9fs_co_chown(s, &fidp->path, v9iattr.uid,
1177                             v9iattr.gid);
1178         if (err < 0) {
1179             goto out;
1180         }
1181     }
1182     if (v9iattr.valid & (ATTR_SIZE)) {
1183         err = v9fs_co_truncate(s, &fidp->path, v9iattr.size);
1184         if (err < 0) {
1185             goto out;
1186         }
1187     }
1188     err = offset;
1189 out:
1190     complete_pdu(s, pdu, err);
1191 }
1192
1193 static int v9fs_walk_marshal(V9fsPDU *pdu, uint16_t nwnames, V9fsQID *qids)
1194 {
1195     int i;
1196     size_t offset = 7;
1197     offset += pdu_marshal(pdu, offset, "w", nwnames);
1198     for (i = 0; i < nwnames; i++) {
1199         offset += pdu_marshal(pdu, offset, "Q", &qids[i]);
1200     }
1201     return offset;
1202 }
1203
1204 static void v9fs_walk(void *opaque)
1205 {
1206     int name_idx;
1207     V9fsQID *qids = NULL;
1208     int i, err = 0;
1209     V9fsString path;
1210     uint16_t nwnames;
1211     struct stat stbuf;
1212     size_t offset = 7;
1213     int32_t fid, newfid;
1214     V9fsString *wnames = NULL;
1215     V9fsFidState *fidp;
1216     V9fsFidState *newfidp;
1217     V9fsPDU *pdu = opaque;
1218     V9fsState *s = pdu->s;
1219
1220     offset += pdu_unmarshal(pdu, offset, "ddw", &fid,
1221                             &newfid, &nwnames);
1222
1223     if (nwnames && nwnames <= P9_MAXWELEM) {
1224         wnames = g_malloc0(sizeof(wnames[0]) * nwnames);
1225         qids   = g_malloc0(sizeof(qids[0]) * nwnames);
1226         for (i = 0; i < nwnames; i++) {
1227             offset += pdu_unmarshal(pdu, offset, "s", &wnames[i]);
1228         }
1229
1230     } else if (nwnames > P9_MAXWELEM) {
1231         err = -EINVAL;
1232         goto out;
1233     }
1234     fidp = lookup_fid(s, fid);
1235     if (fidp == NULL) {
1236         err = -ENOENT;
1237         goto out;
1238     }
1239     if (fid == newfid) {
1240         BUG_ON(fidp->fid_type != P9_FID_NONE);
1241         v9fs_string_init(&path);
1242         for (name_idx = 0; name_idx < nwnames; name_idx++) {
1243             v9fs_string_sprintf(&path, "%s/%s",
1244                                 fidp->path.data, wnames[name_idx].data);
1245             v9fs_string_copy(&fidp->path, &path);
1246
1247             err = v9fs_co_lstat(s, &fidp->path, &stbuf);
1248             if (err < 0) {
1249                 v9fs_string_free(&path);
1250                 goto out;
1251             }
1252             stat_to_qid(&stbuf, &qids[name_idx]);
1253         }
1254         v9fs_string_free(&path);
1255     } else {
1256         newfidp = alloc_fid(s, newfid);
1257         if (newfidp == NULL) {
1258             err = -EINVAL;
1259             goto out;
1260         }
1261         newfidp->uid = fidp->uid;
1262         v9fs_string_init(&path);
1263         v9fs_string_copy(&newfidp->path, &fidp->path);
1264         for (name_idx = 0; name_idx < nwnames; name_idx++) {
1265             v9fs_string_sprintf(&path, "%s/%s", newfidp->path.data,
1266                                 wnames[name_idx].data);
1267             v9fs_string_copy(&newfidp->path, &path);
1268             err = v9fs_co_lstat(s, &newfidp->path, &stbuf);
1269             if (err < 0) {
1270                 free_fid(s, newfidp->fid);
1271                 v9fs_string_free(&path);
1272                 goto out;
1273             }
1274             stat_to_qid(&stbuf, &qids[name_idx]);
1275         }
1276         v9fs_string_free(&path);
1277     }
1278     err = v9fs_walk_marshal(pdu, nwnames, qids);
1279 out:
1280     complete_pdu(s, pdu, err);
1281     if (nwnames && nwnames <= P9_MAXWELEM) {
1282         for (name_idx = 0; name_idx < nwnames; name_idx++) {
1283             v9fs_string_free(&wnames[name_idx]);
1284         }
1285         g_free(wnames);
1286         g_free(qids);
1287     }
1288 }
1289
1290 static int32_t get_iounit(V9fsState *s, V9fsString *name)
1291 {
1292     struct statfs stbuf;
1293     int32_t iounit = 0;
1294
1295     /*
1296      * iounit should be multiples of f_bsize (host filesystem block size
1297      * and as well as less than (client msize - P9_IOHDRSZ))
1298      */
1299     if (!v9fs_co_statfs(s, name, &stbuf)) {
1300         iounit = stbuf.f_bsize;
1301         iounit *= (s->msize - P9_IOHDRSZ)/stbuf.f_bsize;
1302     }
1303     if (!iounit) {
1304         iounit = s->msize - P9_IOHDRSZ;
1305     }
1306     return iounit;
1307 }
1308
1309 static void v9fs_open(void *opaque)
1310 {
1311     int flags;
1312     int iounit;
1313     int32_t fid;
1314     int32_t mode;
1315     V9fsQID qid;
1316     ssize_t err = 0;
1317     size_t offset = 7;
1318     struct stat stbuf;
1319     V9fsFidState *fidp;
1320     V9fsPDU *pdu = opaque;
1321     V9fsState *s = pdu->s;
1322
1323     if (s->proto_version == V9FS_PROTO_2000L) {
1324         pdu_unmarshal(pdu, offset, "dd", &fid, &mode);
1325     } else {
1326         pdu_unmarshal(pdu, offset, "db", &fid, &mode);
1327     }
1328     fidp = lookup_fid(s, fid);
1329     if (fidp == NULL) {
1330         err = -ENOENT;
1331         goto out;
1332     }
1333     BUG_ON(fidp->fid_type != P9_FID_NONE);
1334
1335     err = v9fs_co_lstat(s, &fidp->path, &stbuf);
1336     if (err < 0) {
1337         goto out;
1338     }
1339     stat_to_qid(&stbuf, &qid);
1340     if (S_ISDIR(stbuf.st_mode)) {
1341         err = v9fs_co_opendir(s, fidp);
1342         if (err < 0) {
1343             goto out;
1344         }
1345         fidp->fid_type = P9_FID_DIR;
1346         offset += pdu_marshal(pdu, offset, "Qd", &qid, 0);
1347         err = offset;
1348     } else {
1349         if (s->proto_version == V9FS_PROTO_2000L) {
1350             flags = mode;
1351             flags &= ~(O_NOCTTY | O_ASYNC | O_CREAT);
1352             /* Ignore direct disk access hint until the server supports it. */
1353             flags &= ~O_DIRECT;
1354         } else {
1355             flags = omode_to_uflags(mode);
1356         }
1357         err = v9fs_co_open(s, fidp, flags);
1358         if (err < 0) {
1359             goto out;
1360         }
1361         fidp->fid_type = P9_FID_FILE;
1362         iounit = get_iounit(s, &fidp->path);
1363         offset += pdu_marshal(pdu, offset, "Qd", &qid, iounit);
1364         err = offset;
1365     }
1366 out:
1367     complete_pdu(s, pdu, err);
1368 }
1369
1370 static void v9fs_lcreate(void *opaque)
1371 {
1372     int32_t dfid, flags, mode;
1373     gid_t gid;
1374     ssize_t err = 0;
1375     ssize_t offset = 7;
1376     V9fsString fullname;
1377     V9fsString name;
1378     V9fsFidState *fidp;
1379     struct stat stbuf;
1380     V9fsQID qid;
1381     int32_t iounit;
1382     V9fsPDU *pdu = opaque;
1383
1384     v9fs_string_init(&fullname);
1385     pdu_unmarshal(pdu, offset, "dsddd", &dfid, &name, &flags,
1386                   &mode, &gid);
1387
1388     fidp = lookup_fid(pdu->s, dfid);
1389     if (fidp == NULL) {
1390         err = -ENOENT;
1391         goto out;
1392     }
1393     v9fs_string_sprintf(&fullname, "%s/%s", fidp->path.data, name.data);
1394
1395     /* Ignore direct disk access hint until the server supports it. */
1396     flags &= ~O_DIRECT;
1397
1398     err = v9fs_co_open2(pdu->s, fidp, fullname.data, gid, flags, mode);
1399     if (err < 0) {
1400         goto out;
1401     }
1402     fidp->fid_type = P9_FID_FILE;
1403     iounit =  get_iounit(pdu->s, &fullname);
1404
1405     err = v9fs_co_lstat(pdu->s, &fullname, &stbuf);
1406     if (err < 0) {
1407         fidp->fid_type = P9_FID_NONE;
1408         if (fidp->fs.fd > 0) {
1409             close(fidp->fs.fd);
1410         }
1411         goto out;
1412     }
1413     v9fs_string_copy(&fidp->path, &fullname);
1414     stat_to_qid(&stbuf, &qid);
1415     offset += pdu_marshal(pdu, offset, "Qd", &qid, iounit);
1416     err = offset;
1417 out:
1418     complete_pdu(pdu->s, pdu, err);
1419     v9fs_string_free(&name);
1420     v9fs_string_free(&fullname);
1421 }
1422
1423 static void v9fs_fsync(void *opaque)
1424 {
1425     int err;
1426     int32_t fid;
1427     int datasync;
1428     size_t offset = 7;
1429     V9fsFidState *fidp;
1430     V9fsPDU *pdu = opaque;
1431     V9fsState *s = pdu->s;
1432
1433     pdu_unmarshal(pdu, offset, "dd", &fid, &datasync);
1434     fidp = lookup_fid(s, fid);
1435     if (fidp == NULL) {
1436         err = -ENOENT;
1437         goto out;
1438     }
1439     err = v9fs_co_fsync(s, fidp, datasync);
1440     if (!err) {
1441         err = offset;
1442     }
1443 out:
1444     complete_pdu(s, pdu, err);
1445 }
1446
1447 static void v9fs_clunk(void *opaque)
1448 {
1449     int err;
1450     int32_t fid;
1451     size_t offset = 7;
1452     V9fsPDU *pdu = opaque;
1453     V9fsState *s = pdu->s;
1454
1455     pdu_unmarshal(pdu, offset, "d", &fid);
1456     err = free_fid(s, fid);
1457     if (err < 0) {
1458         goto out;
1459     }
1460     err = offset;
1461 out:
1462     complete_pdu(s, pdu, err);
1463 }
1464
1465 static int v9fs_xattr_read(V9fsState *s, V9fsPDU *pdu,
1466                            V9fsFidState *fidp, int64_t off, int32_t max_count)
1467 {
1468     size_t offset = 7;
1469     int read_count;
1470     int64_t xattr_len;
1471
1472     xattr_len = fidp->fs.xattr.len;
1473     read_count = xattr_len - off;
1474     if (read_count > max_count) {
1475         read_count = max_count;
1476     } else if (read_count < 0) {
1477         /*
1478          * read beyond XATTR value
1479          */
1480         read_count = 0;
1481     }
1482     offset += pdu_marshal(pdu, offset, "d", read_count);
1483     offset += pdu_pack(pdu, offset,
1484                        ((char *)fidp->fs.xattr.value) + off,
1485                        read_count);
1486     return offset;
1487 }
1488
1489 static int v9fs_do_readdir_with_stat(V9fsState *s, V9fsPDU *pdu,
1490                                      V9fsFidState *fidp, int32_t max_count)
1491 {
1492     V9fsString name;
1493     V9fsStat v9stat;
1494     int len, err = 0;
1495     int32_t count = 0;
1496     struct stat stbuf;
1497     off_t saved_dir_pos;
1498     struct dirent *dent, *result;
1499
1500     /* save the directory position */
1501     saved_dir_pos = v9fs_co_telldir(s, fidp);
1502     if (saved_dir_pos < 0) {
1503         return saved_dir_pos;
1504     }
1505
1506     dent = g_malloc(sizeof(struct dirent));
1507
1508     while (1) {
1509         v9fs_string_init(&name);
1510         err = v9fs_co_readdir_r(s, fidp, dent, &result);
1511         if (err || !result) {
1512             break;
1513         }
1514         v9fs_string_sprintf(&name, "%s/%s", fidp->path.data, dent->d_name);
1515         err = v9fs_co_lstat(s, &name, &stbuf);
1516         if (err < 0) {
1517             goto out;
1518         }
1519         err = stat_to_v9stat(s, &name, &stbuf, &v9stat);
1520         if (err < 0) {
1521             goto out;
1522         }
1523         /* 11 = 7 + 4 (7 = start offset, 4 = space for storing count) */
1524         len = pdu_marshal(pdu, 11 + count, "S", &v9stat);
1525         if ((len != (v9stat.size + 2)) || ((count + len) > max_count)) {
1526             /* Ran out of buffer. Set dir back to old position and return */
1527             v9fs_co_seekdir(s, fidp, saved_dir_pos);
1528             v9fs_stat_free(&v9stat);
1529             v9fs_string_free(&name);
1530             g_free(dent);
1531             return count;
1532         }
1533         count += len;
1534         v9fs_stat_free(&v9stat);
1535         v9fs_string_free(&name);
1536         saved_dir_pos = dent->d_off;
1537     }
1538 out:
1539     g_free(dent);
1540     v9fs_string_free(&name);
1541     if (err < 0) {
1542         return err;
1543     }
1544     return count;
1545 }
1546
1547 static void v9fs_read(void *opaque)
1548 {
1549     int32_t fid;
1550     int64_t off;
1551     ssize_t err = 0;
1552     int32_t count = 0;
1553     size_t offset = 7;
1554     int32_t max_count;
1555     V9fsFidState *fidp;
1556     V9fsPDU *pdu = opaque;
1557     V9fsState *s = pdu->s;
1558
1559     pdu_unmarshal(pdu, offset, "dqd", &fid, &off, &max_count);
1560     fidp = lookup_fid(s, fid);
1561     if (fidp == NULL) {
1562         err = -EINVAL;
1563         goto out;
1564     }
1565     if (fidp->fid_type == P9_FID_DIR) {
1566
1567         if (off == 0) {
1568             v9fs_co_rewinddir(s, fidp);
1569         }
1570         count = v9fs_do_readdir_with_stat(s, pdu, fidp, max_count);
1571         if (count < 0) {
1572             err = count;
1573             goto out;
1574         }
1575         err = offset;
1576         err += pdu_marshal(pdu, offset, "d", count);
1577         err += count;
1578     } else if (fidp->fid_type == P9_FID_FILE) {
1579         int32_t cnt;
1580         int32_t len;
1581         struct iovec *sg;
1582         struct iovec iov[128]; /* FIXME: bad, bad, bad */
1583
1584         sg = iov;
1585         pdu_marshal(pdu, offset + 4, "v", sg, &cnt);
1586         sg = cap_sg(sg, max_count, &cnt);
1587         do {
1588             if (0) {
1589                 print_sg(sg, cnt);
1590             }
1591             /* Loop in case of EINTR */
1592             do {
1593                 len = v9fs_co_preadv(s, fidp, sg, cnt, off);
1594                 if (len >= 0) {
1595                     off   += len;
1596                     count += len;
1597                 }
1598             } while (len == -EINTR);
1599             if (len < 0) {
1600                 /* IO error return the error */
1601                 err = len;
1602                 goto out;
1603             }
1604             sg = adjust_sg(sg, len, &cnt);
1605         } while (count < max_count && len > 0);
1606         err = offset;
1607         err += pdu_marshal(pdu, offset, "d", count);
1608         err += count;
1609     } else if (fidp->fid_type == P9_FID_XATTR) {
1610         err = v9fs_xattr_read(s, pdu, fidp, off, max_count);
1611     } else {
1612         err = -EINVAL;
1613     }
1614 out:
1615     complete_pdu(s, pdu, err);
1616 }
1617
1618 static size_t v9fs_readdir_data_size(V9fsString *name)
1619 {
1620     /*
1621      * Size of each dirent on the wire: size of qid (13) + size of offset (8)
1622      * size of type (1) + size of name.size (2) + strlen(name.data)
1623      */
1624     return 24 + v9fs_string_size(name);
1625 }
1626
1627 static int v9fs_do_readdir(V9fsState *s, V9fsPDU *pdu,
1628                            V9fsFidState *fidp, int32_t max_count)
1629 {
1630     size_t size;
1631     V9fsQID qid;
1632     V9fsString name;
1633     int len, err = 0;
1634     int32_t count = 0;
1635     off_t saved_dir_pos;
1636     struct dirent *dent, *result;
1637
1638     /* save the directory position */
1639     saved_dir_pos = v9fs_co_telldir(s, fidp);
1640     if (saved_dir_pos < 0) {
1641         return saved_dir_pos;
1642     }
1643
1644     dent = g_malloc(sizeof(struct dirent));
1645
1646     while (1) {
1647         err = v9fs_co_readdir_r(s, fidp, dent, &result);
1648         if (err || !result) {
1649             break;
1650         }
1651         v9fs_string_init(&name);
1652         v9fs_string_sprintf(&name, "%s", dent->d_name);
1653         if ((count + v9fs_readdir_data_size(&name)) > max_count) {
1654             /* Ran out of buffer. Set dir back to old position and return */
1655             v9fs_co_seekdir(s, fidp, saved_dir_pos);
1656             v9fs_string_free(&name);
1657             g_free(dent);
1658             return count;
1659         }
1660         /*
1661          * Fill up just the path field of qid because the client uses
1662          * only that. To fill the entire qid structure we will have
1663          * to stat each dirent found, which is expensive
1664          */
1665         size = MIN(sizeof(dent->d_ino), sizeof(qid.path));
1666         memcpy(&qid.path, &dent->d_ino, size);
1667         /* Fill the other fields with dummy values */
1668         qid.type = 0;
1669         qid.version = 0;
1670
1671         /* 11 = 7 + 4 (7 = start offset, 4 = space for storing count) */
1672         len = pdu_marshal(pdu, 11 + count, "Qqbs",
1673                           &qid, dent->d_off,
1674                           dent->d_type, &name);
1675         count += len;
1676         v9fs_string_free(&name);
1677         saved_dir_pos = dent->d_off;
1678     }
1679     g_free(dent);
1680     if (err < 0) {
1681         return err;
1682     }
1683     return count;
1684 }
1685
1686 static void v9fs_readdir(void *opaque)
1687 {
1688     int32_t fid;
1689     V9fsFidState *fidp;
1690     ssize_t retval = 0;
1691     size_t offset = 7;
1692     int64_t initial_offset;
1693     int32_t count, max_count;
1694     V9fsPDU *pdu = opaque;
1695     V9fsState *s = pdu->s;
1696
1697     pdu_unmarshal(pdu, offset, "dqd", &fid, &initial_offset, &max_count);
1698
1699     fidp = lookup_fid(s, fid);
1700     if (fidp == NULL || !fidp->fs.dir) {
1701         retval = -EINVAL;
1702         goto out;
1703     }
1704     if (initial_offset == 0) {
1705         v9fs_co_rewinddir(s, fidp);
1706     } else {
1707         v9fs_co_seekdir(s, fidp, initial_offset);
1708     }
1709     count = v9fs_do_readdir(s, pdu, fidp, max_count);
1710     if (count < 0) {
1711         retval = count;
1712         goto out;
1713     }
1714     retval = offset;
1715     retval += pdu_marshal(pdu, offset, "d", count);
1716     retval += count;
1717 out:
1718     complete_pdu(s, pdu, retval);
1719 }
1720
1721 static int v9fs_xattr_write(V9fsState *s, V9fsPDU *pdu, V9fsFidState *fidp,
1722                             int64_t off, int32_t count,
1723                             struct iovec *sg, int cnt)
1724 {
1725     int i, to_copy;
1726     ssize_t err = 0;
1727     int write_count;
1728     int64_t xattr_len;
1729     size_t offset = 7;
1730
1731
1732     xattr_len = fidp->fs.xattr.len;
1733     write_count = xattr_len - off;
1734     if (write_count > count) {
1735         write_count = count;
1736     } else if (write_count < 0) {
1737         /*
1738          * write beyond XATTR value len specified in
1739          * xattrcreate
1740          */
1741         err = -ENOSPC;
1742         goto out;
1743     }
1744     offset += pdu_marshal(pdu, offset, "d", write_count);
1745     err = offset;
1746     fidp->fs.xattr.copied_len += write_count;
1747     /*
1748      * Now copy the content from sg list
1749      */
1750     for (i = 0; i < cnt; i++) {
1751         if (write_count > sg[i].iov_len) {
1752             to_copy = sg[i].iov_len;
1753         } else {
1754             to_copy = write_count;
1755         }
1756         memcpy((char *)fidp->fs.xattr.value + off, sg[i].iov_base, to_copy);
1757         /* updating vs->off since we are not using below */
1758         off += to_copy;
1759         write_count -= to_copy;
1760     }
1761 out:
1762     return err;
1763 }
1764
1765 static void v9fs_write(void *opaque)
1766 {
1767     int cnt;
1768     ssize_t err;
1769     int32_t fid;
1770     int64_t off;
1771     int32_t count;
1772     int32_t len = 0;
1773     int32_t total = 0;
1774     size_t offset = 7;
1775     V9fsFidState *fidp;
1776     struct iovec iov[128]; /* FIXME: bad, bad, bad */
1777     struct iovec *sg = iov;
1778     V9fsPDU *pdu = opaque;
1779     V9fsState *s = pdu->s;
1780
1781     pdu_unmarshal(pdu, offset, "dqdv", &fid, &off, &count, sg, &cnt);
1782     fidp = lookup_fid(s, fid);
1783     if (fidp == NULL) {
1784         err = -EINVAL;
1785         goto out;
1786     }
1787     if (fidp->fid_type == P9_FID_FILE) {
1788         if (fidp->fs.fd == -1) {
1789             err = -EINVAL;
1790             goto out;
1791         }
1792     } else if (fidp->fid_type == P9_FID_XATTR) {
1793         /*
1794          * setxattr operation
1795          */
1796         err = v9fs_xattr_write(s, pdu, fidp, off, count, sg, cnt);
1797         goto out;
1798     } else {
1799         err = -EINVAL;
1800         goto out;
1801     }
1802     sg = cap_sg(sg, count, &cnt);
1803     do {
1804         if (0) {
1805             print_sg(sg, cnt);
1806         }
1807         /* Loop in case of EINTR */
1808         do {
1809             len = v9fs_co_pwritev(s, fidp, sg, cnt, off);
1810             if (len >= 0) {
1811                 off   += len;
1812                 total += len;
1813             }
1814         } while (len == -EINTR);
1815         if (len < 0) {
1816             /* IO error return the error */
1817             err = len;
1818             goto out;
1819         }
1820         sg = adjust_sg(sg, len, &cnt);
1821     } while (total < count && len > 0);
1822     offset += pdu_marshal(pdu, offset, "d", total);
1823     err = offset;
1824 out:
1825     complete_pdu(s, pdu, err);
1826 }
1827
1828 static void v9fs_create(void *opaque)
1829 {
1830     int32_t fid;
1831     int err = 0;
1832     size_t offset = 7;
1833     V9fsFidState *fidp;
1834     V9fsQID qid;
1835     int32_t perm;
1836     int8_t mode;
1837     struct stat stbuf;
1838     V9fsString name;
1839     V9fsString extension;
1840     V9fsString fullname;
1841     int iounit;
1842     V9fsPDU *pdu = opaque;
1843
1844     v9fs_string_init(&fullname);
1845
1846     pdu_unmarshal(pdu, offset, "dsdbs", &fid, &name,
1847                   &perm, &mode, &extension);
1848
1849     fidp = lookup_fid(pdu->s, fid);
1850     if (fidp == NULL) {
1851         err = -EINVAL;
1852         goto out;
1853     }
1854
1855     v9fs_string_sprintf(&fullname, "%s/%s", fidp->path.data, name.data);
1856     err = v9fs_co_lstat(pdu->s, &fullname, &stbuf);
1857     if (!err) {
1858         err = -EEXIST;
1859         goto out;
1860     } else if (err != -ENOENT) {
1861         goto out;
1862     }
1863     if (perm & P9_STAT_MODE_DIR) {
1864         err = v9fs_co_mkdir(pdu->s, fullname.data, perm & 0777,
1865                             fidp->uid, -1);
1866         if (err < 0) {
1867             goto out;
1868         }
1869         err = v9fs_co_opendir(pdu->s, fidp);
1870         if (err < 0) {
1871             goto out;
1872         }
1873         fidp->fid_type = P9_FID_DIR;
1874     } else if (perm & P9_STAT_MODE_SYMLINK) {
1875         err = v9fs_co_symlink(pdu->s, fidp, extension.data,
1876                               fullname.data, -1);
1877         if (err < 0) {
1878             goto out;
1879         }
1880     } else if (perm & P9_STAT_MODE_LINK) {
1881         int32_t nfid = atoi(extension.data);
1882         V9fsFidState *nfidp = lookup_fid(pdu->s, nfid);
1883         if (nfidp == NULL) {
1884             err = -EINVAL;
1885             goto out;
1886         }
1887         err = v9fs_co_link(pdu->s, &nfidp->path, &fullname);
1888         if (err < 0) {
1889             goto out;
1890         }
1891     } else if (perm & P9_STAT_MODE_DEVICE) {
1892         char ctype;
1893         uint32_t major, minor;
1894         mode_t nmode = 0;
1895
1896         if (sscanf(extension.data, "%c %u %u", &ctype, &major, &minor) != 3) {
1897             err = -errno;
1898             goto out;
1899         }
1900
1901         switch (ctype) {
1902         case 'c':
1903             nmode = S_IFCHR;
1904             break;
1905         case 'b':
1906             nmode = S_IFBLK;
1907             break;
1908         default:
1909             err = -EIO;
1910             goto out;
1911         }
1912
1913         nmode |= perm & 0777;
1914         err = v9fs_co_mknod(pdu->s, &fullname, fidp->uid, -1,
1915                             makedev(major, minor), nmode);
1916         if (err < 0) {
1917             goto out;
1918         }
1919     } else if (perm & P9_STAT_MODE_NAMED_PIPE) {
1920         err = v9fs_co_mknod(pdu->s, &fullname, fidp->uid, -1,
1921                             0, S_IFIFO | (perm & 0777));
1922         if (err < 0) {
1923             goto out;
1924         }
1925     } else if (perm & P9_STAT_MODE_SOCKET) {
1926         err = v9fs_co_mknod(pdu->s, &fullname, fidp->uid, -1,
1927                             0, S_IFSOCK | (perm & 0777));
1928         if (err < 0) {
1929             goto out;
1930         }
1931     } else {
1932         err = v9fs_co_open2(pdu->s, fidp, fullname.data, -1,
1933                             omode_to_uflags(mode)|O_CREAT, perm);
1934         if (err < 0) {
1935             goto out;
1936         }
1937         fidp->fid_type = P9_FID_FILE;
1938     }
1939     err = v9fs_co_lstat(pdu->s, &fullname, &stbuf);
1940     if (err < 0) {
1941         fidp->fid_type = P9_FID_NONE;
1942         if (fidp->fs.fd) {
1943             close(fidp->fs.fd);
1944         }
1945         goto out;
1946     }
1947     iounit = get_iounit(pdu->s, &fidp->path);
1948     v9fs_string_copy(&fidp->path, &fullname);
1949     stat_to_qid(&stbuf, &qid);
1950     offset += pdu_marshal(pdu, offset, "Qd", &qid, iounit);
1951     err = offset;
1952 out:
1953    complete_pdu(pdu->s, pdu, err);
1954    v9fs_string_free(&name);
1955    v9fs_string_free(&extension);
1956    v9fs_string_free(&fullname);
1957 }
1958
1959 static void v9fs_symlink(void *opaque)
1960 {
1961     V9fsPDU *pdu = opaque;
1962     V9fsString name;
1963     V9fsString symname;
1964     V9fsString fullname;
1965     V9fsFidState *dfidp;
1966     V9fsQID qid;
1967     struct stat stbuf;
1968     int32_t dfid;
1969     int err = 0;
1970     gid_t gid;
1971     size_t offset = 7;
1972
1973     v9fs_string_init(&fullname);
1974     pdu_unmarshal(pdu, offset, "dssd", &dfid, &name, &symname, &gid);
1975
1976     dfidp = lookup_fid(pdu->s, dfid);
1977     if (dfidp == NULL) {
1978         err = -EINVAL;
1979         goto out;
1980     }
1981
1982     v9fs_string_sprintf(&fullname, "%s/%s", dfidp->path.data, name.data);
1983     err = v9fs_co_symlink(pdu->s, dfidp, symname.data, fullname.data, gid);
1984     if (err < 0) {
1985         goto out;
1986     }
1987     err = v9fs_co_lstat(pdu->s, &fullname, &stbuf);
1988     if (err < 0) {
1989         goto out;
1990     }
1991     stat_to_qid(&stbuf, &qid);
1992     offset += pdu_marshal(pdu, offset, "Q", &qid);
1993     err = offset;
1994 out:
1995     complete_pdu(pdu->s, pdu, err);
1996     v9fs_string_free(&name);
1997     v9fs_string_free(&symname);
1998     v9fs_string_free(&fullname);
1999 }
2000
2001 static void v9fs_flush(void *opaque)
2002 {
2003     V9fsPDU *pdu = opaque;
2004     V9fsState *s = pdu->s;
2005     /* A nop call with no return */
2006     complete_pdu(s, pdu, 7);
2007     return;
2008 }
2009
2010 static void v9fs_link(void *opaque)
2011 {
2012     V9fsPDU *pdu = opaque;
2013     V9fsState *s = pdu->s;
2014     int32_t dfid, oldfid;
2015     V9fsFidState *dfidp, *oldfidp;
2016     V9fsString name, fullname;
2017     size_t offset = 7;
2018     int err = 0;
2019
2020     v9fs_string_init(&fullname);
2021
2022     pdu_unmarshal(pdu, offset, "dds", &dfid, &oldfid, &name);
2023
2024     dfidp = lookup_fid(s, dfid);
2025     if (dfidp == NULL) {
2026         err = -ENOENT;
2027         goto out;
2028     }
2029
2030     oldfidp = lookup_fid(s, oldfid);
2031     if (oldfidp == NULL) {
2032         err = -ENOENT;
2033         goto out;
2034     }
2035
2036     v9fs_string_sprintf(&fullname, "%s/%s", dfidp->path.data, name.data);
2037     err = v9fs_co_link(s, &oldfidp->path, &fullname);
2038     if (!err) {
2039         err = offset;
2040     }
2041     v9fs_string_free(&fullname);
2042
2043 out:
2044     v9fs_string_free(&name);
2045     complete_pdu(s, pdu, err);
2046 }
2047
2048 static void v9fs_remove(void *opaque)
2049 {
2050     int32_t fid;
2051     int err = 0;
2052     size_t offset = 7;
2053     V9fsFidState *fidp;
2054     V9fsPDU *pdu = opaque;
2055
2056     pdu_unmarshal(pdu, offset, "d", &fid);
2057
2058     fidp = lookup_fid(pdu->s, fid);
2059     if (fidp == NULL) {
2060         err = -EINVAL;
2061         goto out;
2062     }
2063     err = v9fs_co_remove(pdu->s, &fidp->path);
2064     if (!err) {
2065         err = offset;
2066     }
2067
2068     /* For TREMOVE we need to clunk the fid even on failed remove */
2069     free_fid(pdu->s, fidp->fid);
2070 out:
2071     complete_pdu(pdu->s, pdu, err);
2072 }
2073
2074 static int v9fs_complete_rename(V9fsState *s, V9fsFidState *fidp,
2075                                 int32_t newdirfid, V9fsString *name)
2076 {
2077     char *end;
2078     int err = 0;
2079     char *old_name, *new_name;
2080
2081     if (newdirfid != -1) {
2082         V9fsFidState *dirfidp;
2083         dirfidp = lookup_fid(s, newdirfid);
2084         if (dirfidp == NULL) {
2085             err = -ENOENT;
2086             goto out;
2087         }
2088         BUG_ON(dirfidp->fid_type != P9_FID_NONE);
2089
2090         new_name = g_malloc0(dirfidp->path.size + name->size + 2);
2091
2092         strcpy(new_name, dirfidp->path.data);
2093         strcat(new_name, "/");
2094         strcat(new_name + dirfidp->path.size, name->data);
2095     } else {
2096         old_name = fidp->path.data;
2097         end = strrchr(old_name, '/');
2098         if (end) {
2099             end++;
2100         } else {
2101             end = old_name;
2102         }
2103         new_name = g_malloc0(end - old_name + name->size + 1);
2104
2105         strncat(new_name, old_name, end - old_name);
2106         strncat(new_name + (end - old_name), name->data, name->size);
2107     }
2108
2109     v9fs_string_free(name);
2110     name->data = new_name;
2111     name->size = strlen(new_name);
2112
2113     if (strcmp(new_name, fidp->path.data) != 0) {
2114         err = v9fs_co_rename(s, &fidp->path, name);
2115         if (err < 0) {
2116             goto out;
2117         }
2118         V9fsFidState *tfidp;
2119         /*
2120          * Fixup fid's pointing to the old name to
2121          * start pointing to the new name
2122          */
2123         for (tfidp = s->fid_list; tfidp; tfidp = tfidp->next) {
2124             if (fidp == tfidp) {
2125                 /*
2126                  * we replace name of this fid towards the end
2127                  * so that our below strcmp will work
2128                  */
2129                 continue;
2130             }
2131             if (v9fs_path_is_ancestor(&fidp->path, &tfidp->path)) {
2132                 /* replace the name */
2133                 v9fs_fix_path(&tfidp->path, name, strlen(fidp->path.data));
2134             }
2135         }
2136         v9fs_string_copy(&fidp->path, name);
2137     }
2138 out:
2139     return err;
2140 }
2141
2142 static void v9fs_rename(void *opaque)
2143 {
2144     int32_t fid;
2145     ssize_t err = 0;
2146     size_t offset = 7;
2147     V9fsString name;
2148     int32_t newdirfid;
2149     V9fsFidState *fidp;
2150     V9fsPDU *pdu = opaque;
2151     V9fsState *s = pdu->s;
2152
2153     pdu_unmarshal(pdu, offset, "dds", &fid, &newdirfid, &name);
2154
2155     fidp = lookup_fid(s, fid);
2156     if (fidp == NULL) {
2157         err = -ENOENT;
2158         goto out;
2159     }
2160     BUG_ON(fidp->fid_type != P9_FID_NONE);
2161
2162     err = v9fs_complete_rename(s, fidp, newdirfid, &name);
2163     if (!err) {
2164         err = offset;
2165     }
2166 out:
2167     complete_pdu(s, pdu, err);
2168     v9fs_string_free(&name);
2169 }
2170
2171 static void v9fs_wstat(void *opaque)
2172 {
2173     int32_t fid;
2174     int err = 0;
2175     int16_t unused;
2176     V9fsStat v9stat;
2177     size_t offset = 7;
2178     struct stat stbuf;
2179     V9fsFidState *fidp;
2180     V9fsPDU *pdu = opaque;
2181     V9fsState *s = pdu->s;
2182
2183     pdu_unmarshal(pdu, offset, "dwS", &fid, &unused, &v9stat);
2184     fidp = lookup_fid(s, fid);
2185     if (fidp == NULL) {
2186         err = -EINVAL;
2187         goto out;
2188     }
2189     /* do we need to sync the file? */
2190     if (donttouch_stat(&v9stat)) {
2191         err = v9fs_co_fsync(s, fidp, 0);
2192         goto out;
2193     }
2194     if (v9stat.mode != -1) {
2195         uint32_t v9_mode;
2196         err = v9fs_co_lstat(s, &fidp->path, &stbuf);
2197         if (err < 0) {
2198             goto out;
2199         }
2200         v9_mode = stat_to_v9mode(&stbuf);
2201         if ((v9stat.mode & P9_STAT_MODE_TYPE_BITS) !=
2202             (v9_mode & P9_STAT_MODE_TYPE_BITS)) {
2203             /* Attempting to change the type */
2204             err = -EIO;
2205             goto out;
2206         }
2207         err = v9fs_co_chmod(s, &fidp->path,
2208                             v9mode_to_mode(v9stat.mode,
2209                                            &v9stat.extension));
2210         if (err < 0) {
2211             goto out;
2212         }
2213     }
2214     if (v9stat.mtime != -1 || v9stat.atime != -1) {
2215         struct timespec times[2];
2216         if (v9stat.atime != -1) {
2217             times[0].tv_sec = v9stat.atime;
2218             times[0].tv_nsec = 0;
2219         } else {
2220             times[0].tv_nsec = UTIME_OMIT;
2221         }
2222         if (v9stat.mtime != -1) {
2223             times[1].tv_sec = v9stat.mtime;
2224             times[1].tv_nsec = 0;
2225         } else {
2226             times[1].tv_nsec = UTIME_OMIT;
2227         }
2228         err = v9fs_co_utimensat(s, &fidp->path, times);
2229         if (err < 0) {
2230             goto out;
2231         }
2232     }
2233     if (v9stat.n_gid != -1 || v9stat.n_uid != -1) {
2234         err = v9fs_co_chown(s, &fidp->path, v9stat.n_uid, v9stat.n_gid);
2235         if (err < 0) {
2236             goto out;
2237         }
2238     }
2239     if (v9stat.name.size != 0) {
2240         err = v9fs_complete_rename(s, fidp, -1, &v9stat.name);
2241         if (err < 0) {
2242             goto out;
2243         }
2244     }
2245     if (v9stat.length != -1) {
2246         err = v9fs_co_truncate(s, &fidp->path, v9stat.length);
2247         if (err < 0) {
2248             goto out;
2249         }
2250     }
2251     err = offset;
2252 out:
2253     v9fs_stat_free(&v9stat);
2254     complete_pdu(s, pdu, err);
2255 }
2256
2257 static int v9fs_fill_statfs(V9fsState *s, V9fsPDU *pdu, struct statfs *stbuf)
2258 {
2259     uint32_t f_type;
2260     uint32_t f_bsize;
2261     uint64_t f_blocks;
2262     uint64_t f_bfree;
2263     uint64_t f_bavail;
2264     uint64_t f_files;
2265     uint64_t f_ffree;
2266     uint64_t fsid_val;
2267     uint32_t f_namelen;
2268     size_t offset = 7;
2269     int32_t bsize_factor;
2270
2271     /*
2272      * compute bsize factor based on host file system block size
2273      * and client msize
2274      */
2275     bsize_factor = (s->msize - P9_IOHDRSZ)/stbuf->f_bsize;
2276     if (!bsize_factor) {
2277         bsize_factor = 1;
2278     }
2279     f_type  = stbuf->f_type;
2280     f_bsize = stbuf->f_bsize;
2281     f_bsize *= bsize_factor;
2282     /*
2283      * f_bsize is adjusted(multiplied) by bsize factor, so we need to
2284      * adjust(divide) the number of blocks, free blocks and available
2285      * blocks by bsize factor
2286      */
2287     f_blocks = stbuf->f_blocks/bsize_factor;
2288     f_bfree  = stbuf->f_bfree/bsize_factor;
2289     f_bavail = stbuf->f_bavail/bsize_factor;
2290     f_files  = stbuf->f_files;
2291     f_ffree  = stbuf->f_ffree;
2292     fsid_val = (unsigned int) stbuf->f_fsid.__val[0] |
2293                (unsigned long long)stbuf->f_fsid.__val[1] << 32;
2294     f_namelen = stbuf->f_namelen;
2295
2296     return pdu_marshal(pdu, offset, "ddqqqqqqd",
2297                        f_type, f_bsize, f_blocks, f_bfree,
2298                        f_bavail, f_files, f_ffree,
2299                        fsid_val, f_namelen);
2300 }
2301
2302 static void v9fs_statfs(void *opaque)
2303 {
2304     int32_t fid;
2305     ssize_t retval = 0;
2306     size_t offset = 7;
2307     V9fsFidState *fidp;
2308     struct statfs stbuf;
2309     V9fsPDU *pdu = opaque;
2310     V9fsState *s = pdu->s;
2311
2312     pdu_unmarshal(pdu, offset, "d", &fid);
2313     fidp = lookup_fid(s, fid);
2314     if (fidp == NULL) {
2315         retval = -ENOENT;
2316         goto out;
2317     }
2318     retval = v9fs_co_statfs(s, &fidp->path, &stbuf);
2319     if (retval < 0) {
2320         goto out;
2321     }
2322     retval = offset;
2323     retval += v9fs_fill_statfs(s, pdu, &stbuf);
2324 out:
2325     complete_pdu(s, pdu, retval);
2326     return;
2327 }
2328
2329 static void v9fs_mknod(void *opaque)
2330 {
2331
2332     int mode;
2333     gid_t gid;
2334     int32_t fid;
2335     V9fsQID qid;
2336     int err = 0;
2337     int major, minor;
2338     size_t offset = 7;
2339     V9fsString name;
2340     struct stat stbuf;
2341     V9fsString fullname;
2342     V9fsFidState *fidp;
2343     V9fsPDU *pdu = opaque;
2344     V9fsState *s = pdu->s;
2345
2346     v9fs_string_init(&fullname);
2347     pdu_unmarshal(pdu, offset, "dsdddd", &fid, &name, &mode,
2348                   &major, &minor, &gid);
2349
2350     fidp = lookup_fid(s, fid);
2351     if (fidp == NULL) {
2352         err = -ENOENT;
2353         goto out;
2354     }
2355     v9fs_string_sprintf(&fullname, "%s/%s", fidp->path.data, name.data);
2356     err = v9fs_co_mknod(s, &fullname, fidp->uid, gid,
2357                         makedev(major, minor), mode);
2358     if (err < 0) {
2359         goto out;
2360     }
2361     err = v9fs_co_lstat(s, &fullname, &stbuf);
2362     if (err < 0) {
2363         goto out;
2364     }
2365     stat_to_qid(&stbuf, &qid);
2366     err = offset;
2367     err += pdu_marshal(pdu, offset, "Q", &qid);
2368 out:
2369     complete_pdu(s, pdu, err);
2370     v9fs_string_free(&fullname);
2371     v9fs_string_free(&name);
2372 }
2373
2374 /*
2375  * Implement posix byte range locking code
2376  * Server side handling of locking code is very simple, because 9p server in
2377  * QEMU can handle only one client. And most of the lock handling
2378  * (like conflict, merging) etc is done by the VFS layer itself, so no need to
2379  * do any thing in * qemu 9p server side lock code path.
2380  * So when a TLOCK request comes, always return success
2381  */
2382 static void v9fs_lock(void *opaque)
2383 {
2384     int8_t status;
2385     V9fsFlock *flock;
2386     size_t offset = 7;
2387     struct stat stbuf;
2388     V9fsFidState *fidp;
2389     int32_t fid, err = 0;
2390     V9fsPDU *pdu = opaque;
2391     V9fsState *s = pdu->s;
2392
2393     flock = g_malloc(sizeof(*flock));
2394     pdu_unmarshal(pdu, offset, "dbdqqds", &fid, &flock->type,
2395                   &flock->flags, &flock->start, &flock->length,
2396                   &flock->proc_id, &flock->client_id);
2397     status = P9_LOCK_ERROR;
2398
2399     /* We support only block flag now (that too ignored currently) */
2400     if (flock->flags & ~P9_LOCK_FLAGS_BLOCK) {
2401         err = -EINVAL;
2402         goto out;
2403     }
2404     fidp = lookup_fid(s, fid);
2405     if (fidp == NULL) {
2406         err = -ENOENT;
2407         goto out;
2408     }
2409     err = v9fs_co_fstat(s, fidp->fs.fd, &stbuf);
2410     if (err < 0) {
2411         goto out;
2412     }
2413     status = P9_LOCK_SUCCESS;
2414 out:
2415     err = offset;
2416     err += pdu_marshal(pdu, offset, "b", status);
2417     complete_pdu(s, pdu, err);
2418     g_free(flock);
2419 }
2420
2421 /*
2422  * When a TGETLOCK request comes, always return success because all lock
2423  * handling is done by client's VFS layer.
2424  */
2425 static void v9fs_getlock(void *opaque)
2426 {
2427     size_t offset = 7;
2428     struct stat stbuf;
2429     V9fsFidState *fidp;
2430     V9fsGetlock *glock;
2431     int32_t fid, err = 0;
2432     V9fsPDU *pdu = opaque;
2433     V9fsState *s = pdu->s;
2434
2435     glock = g_malloc(sizeof(*glock));
2436     pdu_unmarshal(pdu, offset, "dbqqds", &fid, &glock->type,
2437                   &glock->start, &glock->length, &glock->proc_id,
2438                   &glock->client_id);
2439
2440     fidp = lookup_fid(s, fid);
2441     if (fidp == NULL) {
2442         err = -ENOENT;
2443         goto out;
2444     }
2445     err = v9fs_co_fstat(s, fidp->fs.fd, &stbuf);
2446     if (err < 0) {
2447         goto out;
2448     }
2449     glock->type = F_UNLCK;
2450     offset += pdu_marshal(pdu, offset, "bqqds", glock->type,
2451                           glock->start, glock->length, glock->proc_id,
2452                           &glock->client_id);
2453     err = offset;
2454 out:
2455     complete_pdu(s, pdu, err);
2456     g_free(glock);
2457 }
2458
2459 static void v9fs_mkdir(void *opaque)
2460 {
2461     V9fsPDU *pdu = opaque;
2462     size_t offset = 7;
2463     int32_t fid;
2464     struct stat stbuf;
2465     V9fsString name, fullname;
2466     V9fsQID qid;
2467     V9fsFidState *fidp;
2468     gid_t gid;
2469     int mode;
2470     int err = 0;
2471
2472     v9fs_string_init(&fullname);
2473     pdu_unmarshal(pdu, offset, "dsdd", &fid, &name, &mode, &gid);
2474
2475     fidp = lookup_fid(pdu->s, fid);
2476     if (fidp == NULL) {
2477         err = -ENOENT;
2478         goto out;
2479     }
2480     v9fs_string_sprintf(&fullname, "%s/%s", fidp->path.data, name.data);
2481     err = v9fs_co_mkdir(pdu->s, fullname.data, mode, fidp->uid, gid);
2482     if (err < 0) {
2483         goto out;
2484     }
2485     err = v9fs_co_lstat(pdu->s, &fullname, &stbuf);
2486     if (err < 0) {
2487         goto out;
2488     }
2489     stat_to_qid(&stbuf, &qid);
2490     offset += pdu_marshal(pdu, offset, "Q", &qid);
2491     err = offset;
2492 out:
2493     complete_pdu(pdu->s, pdu, err);
2494     v9fs_string_free(&fullname);
2495     v9fs_string_free(&name);
2496 }
2497
2498 static void v9fs_xattrwalk(void *opaque)
2499 {
2500     int64_t size;
2501     V9fsString name;
2502     ssize_t err = 0;
2503     size_t offset = 7;
2504     int32_t fid, newfid;
2505     V9fsFidState *file_fidp;
2506     V9fsFidState *xattr_fidp;
2507     V9fsPDU *pdu = opaque;
2508     V9fsState *s = pdu->s;
2509
2510     pdu_unmarshal(pdu, offset, "dds", &fid, &newfid, &name);
2511     file_fidp = lookup_fid(s, fid);
2512     if (file_fidp == NULL) {
2513         err = -ENOENT;
2514         goto out;
2515     }
2516     xattr_fidp = alloc_fid(s, newfid);
2517     if (xattr_fidp == NULL) {
2518         err = -EINVAL;
2519         goto out;
2520     }
2521     v9fs_string_copy(&xattr_fidp->path, &file_fidp->path);
2522     if (name.data[0] == 0) {
2523         /*
2524          * listxattr request. Get the size first
2525          */
2526         size = v9fs_co_llistxattr(s, &xattr_fidp->path, NULL, 0);
2527         if (size < 0) {
2528             err = size;
2529             free_fid(s, xattr_fidp->fid);
2530             goto out;
2531         }
2532         /*
2533          * Read the xattr value
2534          */
2535         xattr_fidp->fs.xattr.len = size;
2536         xattr_fidp->fid_type = P9_FID_XATTR;
2537         xattr_fidp->fs.xattr.copied_len = -1;
2538         if (size) {
2539             xattr_fidp->fs.xattr.value = g_malloc(size);
2540             err = v9fs_co_llistxattr(s, &xattr_fidp->path,
2541                                      xattr_fidp->fs.xattr.value,
2542                                      xattr_fidp->fs.xattr.len);
2543             if (err < 0) {
2544                 free_fid(s, xattr_fidp->fid);
2545                 goto out;
2546             }
2547         }
2548         offset += pdu_marshal(pdu, offset, "q", size);
2549         err = offset;
2550     } else {
2551         /*
2552          * specific xattr fid. We check for xattr
2553          * presence also collect the xattr size
2554          */
2555         size = v9fs_co_lgetxattr(s, &xattr_fidp->path,
2556                                  &name, NULL, 0);
2557         if (size < 0) {
2558             err = size;
2559             free_fid(s, xattr_fidp->fid);
2560             goto out;
2561         }
2562         /*
2563          * Read the xattr value
2564          */
2565         xattr_fidp->fs.xattr.len = size;
2566         xattr_fidp->fid_type = P9_FID_XATTR;
2567         xattr_fidp->fs.xattr.copied_len = -1;
2568         if (size) {
2569             xattr_fidp->fs.xattr.value = g_malloc(size);
2570             err = v9fs_co_lgetxattr(s, &xattr_fidp->path,
2571                                     &name, xattr_fidp->fs.xattr.value,
2572                                     xattr_fidp->fs.xattr.len);
2573             if (err < 0) {
2574                 free_fid(s, xattr_fidp->fid);
2575                 goto out;
2576             }
2577         }
2578         offset += pdu_marshal(pdu, offset, "q", size);
2579         err = offset;
2580     }
2581 out:
2582     complete_pdu(s, pdu, err);
2583     v9fs_string_free(&name);
2584 }
2585
2586 static void v9fs_xattrcreate(void *opaque)
2587 {
2588     int flags;
2589     int32_t fid;
2590     int64_t size;
2591     ssize_t err = 0;
2592     V9fsString name;
2593     size_t offset = 7;
2594     V9fsFidState *file_fidp;
2595     V9fsFidState *xattr_fidp;
2596     V9fsPDU *pdu = opaque;
2597     V9fsState *s = pdu->s;
2598
2599     pdu_unmarshal(pdu, offset, "dsqd",
2600                   &fid, &name, &size, &flags);
2601
2602     file_fidp = lookup_fid(s, fid);
2603     if (file_fidp == NULL) {
2604         err = -EINVAL;
2605         goto out;
2606     }
2607     /* Make the file fid point to xattr */
2608     xattr_fidp = file_fidp;
2609     xattr_fidp->fid_type = P9_FID_XATTR;
2610     xattr_fidp->fs.xattr.copied_len = 0;
2611     xattr_fidp->fs.xattr.len = size;
2612     xattr_fidp->fs.xattr.flags = flags;
2613     v9fs_string_init(&xattr_fidp->fs.xattr.name);
2614     v9fs_string_copy(&xattr_fidp->fs.xattr.name, &name);
2615     if (size) {
2616         xattr_fidp->fs.xattr.value = g_malloc(size);
2617     } else {
2618         xattr_fidp->fs.xattr.value = NULL;
2619     }
2620     err = offset;
2621 out:
2622     complete_pdu(s, pdu, err);
2623     v9fs_string_free(&name);
2624 }
2625
2626 static void v9fs_readlink(void *opaque)
2627 {
2628     V9fsPDU *pdu = opaque;
2629     size_t offset = 7;
2630     V9fsString target;
2631     int32_t fid;
2632     int err = 0;
2633     V9fsFidState *fidp;
2634
2635     pdu_unmarshal(pdu, offset, "d", &fid);
2636     fidp = lookup_fid(pdu->s, fid);
2637     if (fidp == NULL) {
2638         err = -ENOENT;
2639         goto out;
2640     }
2641
2642     v9fs_string_init(&target);
2643     err = v9fs_co_readlink(pdu->s, &fidp->path, &target);
2644     if (err < 0) {
2645         goto out;
2646     }
2647     offset += pdu_marshal(pdu, offset, "s", &target);
2648     err = offset;
2649     v9fs_string_free(&target);
2650 out:
2651     complete_pdu(pdu->s, pdu, err);
2652 }
2653
2654 static CoroutineEntry *pdu_co_handlers[] = {
2655     [P9_TREADDIR] = v9fs_readdir,
2656     [P9_TSTATFS] = v9fs_statfs,
2657     [P9_TGETATTR] = v9fs_getattr,
2658     [P9_TSETATTR] = v9fs_setattr,
2659     [P9_TXATTRWALK] = v9fs_xattrwalk,
2660     [P9_TXATTRCREATE] = v9fs_xattrcreate,
2661     [P9_TMKNOD] = v9fs_mknod,
2662     [P9_TRENAME] = v9fs_rename,
2663     [P9_TLOCK] = v9fs_lock,
2664     [P9_TGETLOCK] = v9fs_getlock,
2665     [P9_TREADLINK] = v9fs_readlink,
2666     [P9_TMKDIR] = v9fs_mkdir,
2667     [P9_TVERSION] = v9fs_version,
2668     [P9_TLOPEN] = v9fs_open,
2669     [P9_TATTACH] = v9fs_attach,
2670     [P9_TSTAT] = v9fs_stat,
2671     [P9_TWALK] = v9fs_walk,
2672     [P9_TCLUNK] = v9fs_clunk,
2673     [P9_TFSYNC] = v9fs_fsync,
2674     [P9_TOPEN] = v9fs_open,
2675     [P9_TREAD] = v9fs_read,
2676 #if 0
2677     [P9_TAUTH] = v9fs_auth,
2678 #endif
2679     [P9_TFLUSH] = v9fs_flush,
2680     [P9_TLINK] = v9fs_link,
2681     [P9_TSYMLINK] = v9fs_symlink,
2682     [P9_TCREATE] = v9fs_create,
2683     [P9_TLCREATE] = v9fs_lcreate,
2684     [P9_TWRITE] = v9fs_write,
2685     [P9_TWSTAT] = v9fs_wstat,
2686     [P9_TREMOVE] = v9fs_remove,
2687 };
2688
2689 static void v9fs_op_not_supp(void *opaque)
2690 {
2691     V9fsPDU *pdu = opaque;
2692     complete_pdu(pdu->s, pdu, -EOPNOTSUPP);
2693 }
2694
2695 static void submit_pdu(V9fsState *s, V9fsPDU *pdu)
2696 {
2697     Coroutine *co;
2698     CoroutineEntry *handler;
2699
2700     if (debug_9p_pdu) {
2701         pprint_pdu(pdu);
2702     }
2703     if (pdu->id >= ARRAY_SIZE(pdu_co_handlers) ||
2704         (pdu_co_handlers[pdu->id] == NULL)) {
2705         handler = v9fs_op_not_supp;
2706     } else {
2707         handler = pdu_co_handlers[pdu->id];
2708     }
2709     co = qemu_coroutine_create(handler);
2710     qemu_coroutine_enter(co, pdu);
2711 }
2712
2713 void handle_9p_output(VirtIODevice *vdev, VirtQueue *vq)
2714 {
2715     V9fsState *s = (V9fsState *)vdev;
2716     V9fsPDU *pdu;
2717     ssize_t len;
2718
2719     while ((pdu = alloc_pdu(s)) &&
2720             (len = virtqueue_pop(vq, &pdu->elem)) != 0) {
2721         uint8_t *ptr;
2722         pdu->s = s;
2723         BUG_ON(pdu->elem.out_num == 0 || pdu->elem.in_num == 0);
2724         BUG_ON(pdu->elem.out_sg[0].iov_len < 7);
2725
2726         ptr = pdu->elem.out_sg[0].iov_base;
2727
2728         memcpy(&pdu->size, ptr, 4);
2729         pdu->id = ptr[4];
2730         memcpy(&pdu->tag, ptr + 5, 2);
2731         submit_pdu(s, pdu);
2732     }
2733     free_pdu(s, pdu);
2734 }