hw/9pfs/virtio-9p.c

   1 /*
   2  * Virtio 9p backend
   3  *
   4  * Copyright IBM, Corp. 2010
   5  *
   6  * Authors:
   7  *  Anthony Liguori   <[email protected]>
   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 "virtio.h"
  15 #include "pc.h"
  16 #include "qemu_socket.h"
  17 #include "virtio-9p.h"
  18 #include "fsdev/qemu-fsdev.h"
  19 #include "virtio-9p-debug.h"
  20 #include "virtio-9p-xattr.h"
  21
  22 int debug_9p_pdu;
  23
  24 enum {
  25     Oread   = 0x00,
  26     Owrite  = 0x01,
  27     Ordwr   = 0x02,
  28     Oexec   = 0x03,
  29     Oexcl   = 0x04,
  30     Otrunc  = 0x10,
  31     Orexec  = 0x20,
  32     Orclose = 0x40,
  33     Oappend = 0x80,
  34 };
  35
  36 static int omode_to_uflags(int8_t mode)
  37 {
  38     int ret = 0;
  39
  40     switch (mode & 3) {
  41     case Oread:
  42         ret = O_RDONLY;
  43         break;
  44     case Ordwr:
  45         ret = O_RDWR;
  46         break;
  47     case Owrite:
  48         ret = O_WRONLY;
  49         break;
  50     case Oexec:
  51         ret = O_RDONLY;
  52         break;
  53     }
  54
  55     if (mode & Otrunc) {
  56         ret |= O_TRUNC;
  57     }
  58
  59     if (mode & Oappend) {
  60         ret |= O_APPEND;
  61     }
  62
  63     if (mode & Oexcl) {
  64         ret |= O_EXCL;
  65     }
  66
  67     return ret;
  68 }
  69
  70 void cred_init(FsCred *credp)
  71 {
  72     credp->fc_uid = -1;
  73     credp->fc_gid = -1;
  74     credp->fc_mode = -1;
  75     credp->fc_rdev = -1;
  76 }
  77
  78 static int v9fs_do_lstat(V9fsState *s, V9fsString *path, struct stat *stbuf)
  79 {
  80     return s->ops->lstat(&s->ctx, path->data, stbuf);
  81 }
  82
  83 static ssize_t v9fs_do_readlink(V9fsState *s, V9fsString *path, V9fsString *buf)
  84 {
  85     ssize_t len;
  86
  87     buf->data = qemu_malloc(1024);
  88
  89     len = s->ops->readlink(&s->ctx, path->data, buf->data, 1024 - 1);
  90     if (len > -1) {
  91         buf->size = len;
  92         buf->data[len] = 0;
  93     }
  94
  95     return len;
  96 }
  97
  98 static int v9fs_do_close(V9fsState *s, int fd)
  99 {
 100     return s->ops->close(&s->ctx, fd);
 101 }
 102
 103 static int v9fs_do_closedir(V9fsState *s, DIR *dir)
 104 {
 105     return s->ops->closedir(&s->ctx, dir);
 106 }
 107
 108 static int v9fs_do_open(V9fsState *s, V9fsString *path, int flags)
 109 {
 110     return s->ops->open(&s->ctx, path->data, flags);
 111 }
 112
 113 static DIR *v9fs_do_opendir(V9fsState *s, V9fsString *path)
 114 {
 115     return s->ops->opendir(&s->ctx, path->data);
 116 }
 117
 118 static void v9fs_do_rewinddir(V9fsState *s, DIR *dir)
 119 {
 120     return s->ops->rewinddir(&s->ctx, dir);
 121 }
 122
 123 static off_t v9fs_do_telldir(V9fsState *s, DIR *dir)
 124 {
 125     return s->ops->telldir(&s->ctx, dir);
 126 }
 127
 128 static struct dirent *v9fs_do_readdir(V9fsState *s, DIR *dir)
 129 {
 130     return s->ops->readdir(&s->ctx, dir);
 131 }
 132
 133 static void v9fs_do_seekdir(V9fsState *s, DIR *dir, off_t off)
 134 {
 135     return s->ops->seekdir(&s->ctx, dir, off);
 136 }
 137
 138 static int v9fs_do_preadv(V9fsState *s, int fd, const struct iovec *iov,
 139                             int iovcnt, int64_t offset)
 140 {
 141     return s->ops->preadv(&s->ctx, fd, iov, iovcnt, offset);
 142 }
 143
 144 static int v9fs_do_pwritev(V9fsState *s, int fd, const struct iovec *iov,
 145                        int iovcnt, int64_t offset)
 146 {
 147     return s->ops->pwritev(&s->ctx, fd, iov, iovcnt, offset);
 148 }
 149
 150 static int v9fs_do_chmod(V9fsState *s, V9fsString *path, mode_t mode)
 151 {
 152     FsCred cred;
 153     cred_init(&cred);
 154     cred.fc_mode = mode;
 155     return s->ops->chmod(&s->ctx, path->data, &cred);
 156 }
 157
 158 static int v9fs_do_mknod(V9fsState *s, char *name,
 159         mode_t mode, dev_t dev, uid_t uid, gid_t gid)
 160 {
 161     FsCred cred;
 162     cred_init(&cred);
 163     cred.fc_uid = uid;
 164     cred.fc_gid = gid;
 165     cred.fc_mode = mode;
 166     cred.fc_rdev = dev;
 167     return s->ops->mknod(&s->ctx, name, &cred);
 168 }
 169
 170 static int v9fs_do_mkdir(V9fsState *s, char *name, mode_t mode,
 171                 uid_t uid, gid_t gid)
 172 {
 173     FsCred cred;
 174
 175     cred_init(&cred);
 176     cred.fc_uid = uid;
 177     cred.fc_gid = gid;
 178     cred.fc_mode = mode;
 179
 180     return s->ops->mkdir(&s->ctx, name, &cred);
 181 }
 182
 183 static int v9fs_do_fstat(V9fsState *s, int fd, struct stat *stbuf)
 184 {
 185     return s->ops->fstat(&s->ctx, fd, stbuf);
 186 }
 187
 188 static int v9fs_do_open2(V9fsState *s, char *fullname, uid_t uid, gid_t gid,
 189         int flags, int mode)
 190 {
 191     FsCred cred;
 192
 193     cred_init(&cred);
 194     cred.fc_uid = uid;
 195     cred.fc_gid = gid;
 196     cred.fc_mode = mode & 07777;
 197     flags = flags;
 198
 199     return s->ops->open2(&s->ctx, fullname, flags, &cred);
 200 }
 201
 202 static int v9fs_do_symlink(V9fsState *s, V9fsFidState *fidp,
 203         const char *oldpath, const char *newpath, gid_t gid)
 204 {
 205     FsCred cred;
 206     cred_init(&cred);
 207     cred.fc_uid = fidp->uid;
 208     cred.fc_gid = gid;
 209     cred.fc_mode = 0777;
 210
 211     return s->ops->symlink(&s->ctx, oldpath, newpath, &cred);
 212 }
 213
 214 static int v9fs_do_link(V9fsState *s, V9fsString *oldpath, V9fsString *newpath)
 215 {
 216     return s->ops->link(&s->ctx, oldpath->data, newpath->data);
 217 }
 218
 219 static int v9fs_do_truncate(V9fsState *s, V9fsString *path, off_t size)
 220 {
 221     return s->ops->truncate(&s->ctx, path->data, size);
 222 }
 223
 224 static int v9fs_do_rename(V9fsState *s, V9fsString *oldpath,
 225                             V9fsString *newpath)
 226 {
 227     return s->ops->rename(&s->ctx, oldpath->data, newpath->data);
 228 }
 229
 230 static int v9fs_do_chown(V9fsState *s, V9fsString *path, uid_t uid, gid_t gid)
 231 {
 232     FsCred cred;
 233     cred_init(&cred);
 234     cred.fc_uid = uid;
 235     cred.fc_gid = gid;
 236
 237     return s->ops->chown(&s->ctx, path->data, &cred);
 238 }
 239
 240 static int v9fs_do_utimensat(V9fsState *s, V9fsString *path,
 241                                            const struct timespec times[2])
 242 {
 243     return s->ops->utimensat(&s->ctx, path->data, times);
 244 }
 245
 246 static int v9fs_do_remove(V9fsState *s, V9fsString *path)
 247 {
 248     return s->ops->remove(&s->ctx, path->data);
 249 }
 250
 251 static int v9fs_do_fsync(V9fsState *s, int fd, int datasync)
 252 {
 253     return s->ops->fsync(&s->ctx, fd, datasync);
 254 }
 255
 256 static int v9fs_do_statfs(V9fsState *s, V9fsString *path, struct statfs *stbuf)
 257 {
 258     return s->ops->statfs(&s->ctx, path->data, stbuf);
 259 }
 260
 261 static ssize_t v9fs_do_lgetxattr(V9fsState *s, V9fsString *path,
 262                              V9fsString *xattr_name,
 263                              void *value, size_t size)
 264 {
 265     return s->ops->lgetxattr(&s->ctx, path->data,
 266                              xattr_name->data, value, size);
 267 }
 268
 269 static ssize_t v9fs_do_llistxattr(V9fsState *s, V9fsString *path,
 270                               void *value, size_t size)
 271 {
 272     return s->ops->llistxattr(&s->ctx, path->data,
 273                               value, size);
 274 }
 275
 276 static int v9fs_do_lsetxattr(V9fsState *s, V9fsString *path,
 277                              V9fsString *xattr_name,
 278                              void *value, size_t size, int flags)
 279 {
 280     return s->ops->lsetxattr(&s->ctx, path->data,
 281                              xattr_name->data, value, size, flags);
 282 }
 283
 284 static int v9fs_do_lremovexattr(V9fsState *s, V9fsString *path,
 285                                 V9fsString *xattr_name)
 286 {
 287     return s->ops->lremovexattr(&s->ctx, path->data,
 288                                 xattr_name->data);
 289 }
 290
 291
 292 static void v9fs_string_init(V9fsString *str)
 293 {
 294     str->data = NULL;
 295     str->size = 0;
 296 }
 297
 298 static void v9fs_string_free(V9fsString *str)
 299 {
 300     qemu_free(str->data);
 301     str->data = NULL;
 302     str->size = 0;
 303 }
 304
 305 static void v9fs_string_null(V9fsString *str)
 306 {
 307     v9fs_string_free(str);
 308 }
 309
 310 static int number_to_string(void *arg, char type)
 311 {
 312     unsigned int ret = 0;
 313
 314     switch (type) {
 315     case 'u': {
 316         unsigned int num = *(unsigned int *)arg;
 317
 318         do {
 319             ret++;
 320             num = num/10;
 321         } while (num);
 322         break;
 323     }
 324     case 'U': {
 325         unsigned long num = *(unsigned long *)arg;
 326         do {
 327             ret++;
 328             num = num/10;
 329         } while (num);
 330         break;
 331     }
 332     default:
 333         printf("Number_to_string: Unknown number format\n");
 334         return -1;
 335     }
 336
 337     return ret;
 338 }
 339
 340 static int GCC_FMT_ATTR(2, 0)
 341 v9fs_string_alloc_printf(char **strp, const char *fmt, va_list ap)
 342 {
 343     va_list ap2;
 344     char *iter = (char *)fmt;
 345     int len = 0;
 346     int nr_args = 0;
 347     char *arg_char_ptr;
 348     unsigned int arg_uint;
 349     unsigned long arg_ulong;
 350
 351     /* Find the number of %'s that denotes an argument */
 352     for (iter = strstr(iter, "%"); iter; iter = strstr(iter, "%")) {
 353         nr_args++;
 354         iter++;
 355     }
 356
 357     len = strlen(fmt) - 2*nr_args;
 358
 359     if (!nr_args) {
 360         goto alloc_print;
 361     }
 362
 363     va_copy(ap2, ap);
 364
 365     iter = (char *)fmt;
 366
 367     /* Now parse the format string */
 368     for (iter = strstr(iter, "%"); iter; iter = strstr(iter, "%")) {
 369         iter++;
 370         switch (*iter) {
 371         case 'u':
 372             arg_uint = va_arg(ap2, unsigned int);
 373             len += number_to_string((void *)&arg_uint, 'u');
 374             break;
 375         case 'l':
 376             if (*++iter == 'u') {
 377                 arg_ulong = va_arg(ap2, unsigned long);
 378                 len += number_to_string((void *)&arg_ulong, 'U');
 379             } else {
 380                 return -1;
 381             }
 382             break;
 383         case 's':
 384             arg_char_ptr = va_arg(ap2, char *);
 385             len += strlen(arg_char_ptr);
 386             break;
 387         case 'c':
 388             len += 1;
 389             break;
 390         default:
 391             fprintf(stderr,
 392                     "v9fs_string_alloc_printf:Incorrect format %c", *iter);
 393             return -1;
 394         }
 395         iter++;
 396     }
 397
 398 alloc_print:
 399     *strp = qemu_malloc((len + 1) * sizeof(**strp));
 400
 401     return vsprintf(*strp, fmt, ap);
 402 }
 403
 404 static void GCC_FMT_ATTR(2, 3)
 405 v9fs_string_sprintf(V9fsString *str, const char *fmt, ...)
 406 {
 407     va_list ap;
 408     int err;
 409
 410     v9fs_string_free(str);
 411
 412     va_start(ap, fmt);
 413     err = v9fs_string_alloc_printf(&str->data, fmt, ap);
 414     BUG_ON(err == -1);
 415     va_end(ap);
 416
 417     str->size = err;
 418 }
 419
 420 static void v9fs_string_copy(V9fsString *lhs, V9fsString *rhs)
 421 {
 422     v9fs_string_free(lhs);
 423     v9fs_string_sprintf(lhs, "%s", rhs->data);
 424 }
 425
 426 static size_t v9fs_string_size(V9fsString *str)
 427 {
 428     return str->size;
 429 }
 430
 431 static V9fsFidState *lookup_fid(V9fsState *s, int32_t fid)
 432 {
 433     V9fsFidState *f;
 434
 435     for (f = s->fid_list; f; f = f->next) {
 436         if (f->fid == fid) {
 437             return f;
 438         }
 439     }
 440
 441     return NULL;
 442 }
 443
 444 static V9fsFidState *alloc_fid(V9fsState *s, int32_t fid)
 445 {
 446     V9fsFidState *f;
 447
 448     f = lookup_fid(s, fid);
 449     if (f) {
 450         return NULL;
 451     }
 452
 453     f = qemu_mallocz(sizeof(V9fsFidState));
 454
 455     f->fid = fid;
 456     f->fid_type = P9_FID_NONE;
 457
 458     f->next = s->fid_list;
 459     s->fid_list = f;
 460
 461     return f;
 462 }
 463
 464 static int v9fs_xattr_fid_clunk(V9fsState *s, V9fsFidState *fidp)
 465 {
 466     int retval = 0;
 467
 468     if (fidp->fs.xattr.copied_len == -1) {
 469         /* getxattr/listxattr fid */
 470         goto free_value;
 471     }
 472     /*
 473      * if this is fid for setxattr. clunk should
 474      * result in setxattr localcall
 475      */
 476     if (fidp->fs.xattr.len != fidp->fs.xattr.copied_len) {
 477         /* clunk after partial write */
 478         retval = -EINVAL;
 479         goto free_out;
 480     }
 481     if (fidp->fs.xattr.len) {
 482         retval = v9fs_do_lsetxattr(s, &fidp->path, &fidp->fs.xattr.name,
 483                                    fidp->fs.xattr.value,
 484                                    fidp->fs.xattr.len,
 485                                    fidp->fs.xattr.flags);
 486     } else {
 487         retval = v9fs_do_lremovexattr(s, &fidp->path, &fidp->fs.xattr.name);
 488     }
 489 free_out:
 490     v9fs_string_free(&fidp->fs.xattr.name);
 491 free_value:
 492     if (fidp->fs.xattr.value) {
 493         qemu_free(fidp->fs.xattr.value);
 494     }
 495     return retval;
 496 }
 497
 498 static int free_fid(V9fsState *s, int32_t fid)
 499 {
 500     int retval = 0;
 501     V9fsFidState **fidpp, *fidp;
 502
 503     for (fidpp = &s->fid_list; *fidpp; fidpp = &(*fidpp)->next) {
 504         if ((*fidpp)->fid == fid) {
 505             break;
 506         }
 507     }
 508
 509     if (*fidpp == NULL) {
 510         return -ENOENT;
 511     }
 512
 513     fidp = *fidpp;
 514     *fidpp = fidp->next;
 515
 516     if (fidp->fid_type == P9_FID_FILE) {
 517         v9fs_do_close(s, fidp->fs.fd);
 518     } else if (fidp->fid_type == P9_FID_DIR) {
 519         v9fs_do_closedir(s, fidp->fs.dir);
 520     } else if (fidp->fid_type == P9_FID_XATTR) {
 521         retval = v9fs_xattr_fid_clunk(s, fidp);
 522     }
 523     v9fs_string_free(&fidp->path);
 524     qemu_free(fidp);
 525
 526     return retval;
 527 }
 528
 529 #define P9_QID_TYPE_DIR         0x80
 530 #define P9_QID_TYPE_SYMLINK     0x02
 531
 532 #define P9_STAT_MODE_DIR        0x80000000
 533 #define P9_STAT_MODE_APPEND     0x40000000
 534 #define P9_STAT_MODE_EXCL       0x20000000
 535 #define P9_STAT_MODE_MOUNT      0x10000000
 536 #define P9_STAT_MODE_AUTH       0x08000000
 537 #define P9_STAT_MODE_TMP        0x04000000
 538 #define P9_STAT_MODE_SYMLINK    0x02000000
 539 #define P9_STAT_MODE_LINK       0x01000000
 540 #define P9_STAT_MODE_DEVICE     0x00800000
 541 #define P9_STAT_MODE_NAMED_PIPE 0x00200000
 542 #define P9_STAT_MODE_SOCKET     0x00100000
 543 #define P9_STAT_MODE_SETUID     0x00080000
 544 #define P9_STAT_MODE_SETGID     0x00040000
 545 #define P9_STAT_MODE_SETVTX     0x00010000
 546
 547 #define P9_STAT_MODE_TYPE_BITS (P9_STAT_MODE_DIR |          \
 548                                 P9_STAT_MODE_SYMLINK |      \
 549                                 P9_STAT_MODE_LINK |         \
 550                                 P9_STAT_MODE_DEVICE |       \
 551                                 P9_STAT_MODE_NAMED_PIPE |   \
 552                                 P9_STAT_MODE_SOCKET)
 553
 554 /* This is the algorithm from ufs in spfs */
 555 static void stat_to_qid(const struct stat *stbuf, V9fsQID *qidp)
 556 {
 557     size_t size;
 558
 559     size = MIN(sizeof(stbuf->st_ino), sizeof(qidp->path));
 560     memcpy(&qidp->path, &stbuf->st_ino, size);
 561     qidp->version = stbuf->st_mtime ^ (stbuf->st_size << 8);
 562     qidp->type = 0;
 563     if (S_ISDIR(stbuf->st_mode)) {
 564         qidp->type |= P9_QID_TYPE_DIR;
 565     }
 566     if (S_ISLNK(stbuf->st_mode)) {
 567         qidp->type |= P9_QID_TYPE_SYMLINK;
 568     }
 569 }
 570
 571 static int fid_to_qid(V9fsState *s, V9fsFidState *fidp, V9fsQID *qidp)
 572 {
 573     struct stat stbuf;
 574     int err;
 575
 576     err = v9fs_do_lstat(s, &fidp->path, &stbuf);
 577     if (err) {
 578         return err;
 579     }
 580
 581     stat_to_qid(&stbuf, qidp);
 582     return 0;
 583 }
 584
 585 static V9fsPDU *alloc_pdu(V9fsState *s)
 586 {
 587     V9fsPDU *pdu = NULL;
 588
 589     if (!QLIST_EMPTY(&s->free_list)) {
 590         pdu = QLIST_FIRST(&s->free_list);
 591         QLIST_REMOVE(pdu, next);
 592     }
 593     return pdu;
 594 }
 595
 596 static void free_pdu(V9fsState *s, V9fsPDU *pdu)
 597 {
 598     if (pdu) {
 599         if (debug_9p_pdu) {
 600             pprint_pdu(pdu);
 601         }
 602         QLIST_INSERT_HEAD(&s->free_list, pdu, next);
 603     }
 604 }
 605
 606 size_t pdu_packunpack(void *addr, struct iovec *sg, int sg_count,
 607                         size_t offset, size_t size, int pack)
 608 {
 609     int i = 0;
 610     size_t copied = 0;
 611
 612     for (i = 0; size && i < sg_count; i++) {
 613         size_t len;
 614         if (offset >= sg[i].iov_len) {
 615             /* skip this sg */
 616             offset -= sg[i].iov_len;
 617             continue;
 618         } else {
 619             len = MIN(sg[i].iov_len - offset, size);
 620             if (pack) {
 621                 memcpy(sg[i].iov_base + offset, addr, len);
 622             } else {
 623                 memcpy(addr, sg[i].iov_base + offset, len);
 624             }
 625             size -= len;
 626             copied += len;
 627             addr += len;
 628             if (size) {
 629                 offset = 0;
 630                 continue;
 631             }
 632         }
 633     }
 634
 635     return copied;
 636 }
 637
 638 static size_t pdu_unpack(void *dst, V9fsPDU *pdu, size_t offset, size_t size)
 639 {
 640     return pdu_packunpack(dst, pdu->elem.out_sg, pdu->elem.out_num,
 641                          offset, size, 0);
 642 }
 643
 644 static size_t pdu_pack(V9fsPDU *pdu, size_t offset, const void *src,
 645                         size_t size)
 646 {
 647     return pdu_packunpack((void *)src, pdu->elem.in_sg, pdu->elem.in_num,
 648                              offset, size, 1);
 649 }
 650
 651 static int pdu_copy_sg(V9fsPDU *pdu, size_t offset, int rx, struct iovec *sg)
 652 {
 653     size_t pos = 0;
 654     int i, j;
 655     struct iovec *src_sg;
 656     unsigned int num;
 657
 658     if (rx) {
 659         src_sg = pdu->elem.in_sg;
 660         num = pdu->elem.in_num;
 661     } else {
 662         src_sg = pdu->elem.out_sg;
 663         num = pdu->elem.out_num;
 664     }
 665
 666     j = 0;
 667     for (i = 0; i < num; i++) {
 668         if (offset <= pos) {
 669             sg[j].iov_base = src_sg[i].iov_base;
 670             sg[j].iov_len = src_sg[i].iov_len;
 671             j++;
 672         } else if (offset < (src_sg[i].iov_len + pos)) {
 673             sg[j].iov_base = src_sg[i].iov_base;
 674             sg[j].iov_len = src_sg[i].iov_len;
 675             sg[j].iov_base += (offset - pos);
 676             sg[j].iov_len -= (offset - pos);
 677             j++;
 678         }
 679         pos += src_sg[i].iov_len;
 680     }
 681
 682     return j;
 683 }
 684
 685 static size_t pdu_unmarshal(V9fsPDU *pdu, size_t offset, const char *fmt, ...)
 686 {
 687     size_t old_offset = offset;
 688     va_list ap;
 689     int i;
 690
 691     va_start(ap, fmt);
 692     for (i = 0; fmt[i]; i++) {
 693         switch (fmt[i]) {
 694         case 'b': {
 695             uint8_t *valp = va_arg(ap, uint8_t *);
 696             offset += pdu_unpack(valp, pdu, offset, sizeof(*valp));
 697             break;
 698         }
 699         case 'w': {
 700             uint16_t val, *valp;
 701             valp = va_arg(ap, uint16_t *);
 702             offset += pdu_unpack(&val, pdu, offset, sizeof(val));
 703             *valp = le16_to_cpu(val);
 704             break;
 705         }
 706         case 'd': {
 707             uint32_t val, *valp;
 708             valp = va_arg(ap, uint32_t *);
 709             offset += pdu_unpack(&val, pdu, offset, sizeof(val));
 710             *valp = le32_to_cpu(val);
 711             break;
 712         }
 713         case 'q': {
 714             uint64_t val, *valp;
 715             valp = va_arg(ap, uint64_t *);
 716             offset += pdu_unpack(&val, pdu, offset, sizeof(val));
 717             *valp = le64_to_cpu(val);
 718             break;
 719         }
 720         case 'v': {
 721             struct iovec *iov = va_arg(ap, struct iovec *);
 722             int *iovcnt = va_arg(ap, int *);
 723             *iovcnt = pdu_copy_sg(pdu, offset, 0, iov);
 724             break;
 725         }
 726         case 's': {
 727             V9fsString *str = va_arg(ap, V9fsString *);
 728             offset += pdu_unmarshal(pdu, offset, "w", &str->size);
 729             /* FIXME: sanity check str->size */
 730             str->data = qemu_malloc(str->size + 1);
 731             offset += pdu_unpack(str->data, pdu, offset, str->size);
 732             str->data[str->size] = 0;
 733             break;
 734         }
 735         case 'Q': {
 736             V9fsQID *qidp = va_arg(ap, V9fsQID *);
 737             offset += pdu_unmarshal(pdu, offset, "bdq",
 738                         &qidp->type, &qidp->version, &qidp->path);
 739             break;
 740         }
 741         case 'S': {
 742             V9fsStat *statp = va_arg(ap, V9fsStat *);
 743             offset += pdu_unmarshal(pdu, offset, "wwdQdddqsssssddd",
 744                         &statp->size, &statp->type, &statp->dev,
 745                         &statp->qid, &statp->mode, &statp->atime,
 746                         &statp->mtime, &statp->length,
 747                         &statp->name, &statp->uid, &statp->gid,
 748                         &statp->muid, &statp->extension,
 749                         &statp->n_uid, &statp->n_gid,
 750                         &statp->n_muid);
 751             break;
 752         }
 753         case 'I': {
 754             V9fsIattr *iattr = va_arg(ap, V9fsIattr *);
 755             offset += pdu_unmarshal(pdu, offset, "ddddqqqqq",
 756                         &iattr->valid, &iattr->mode,
 757                         &iattr->uid, &iattr->gid, &iattr->size,
 758                         &iattr->atime_sec, &iattr->atime_nsec,
 759                         &iattr->mtime_sec, &iattr->mtime_nsec);
 760             break;
 761         }
 762         default:
 763             break;
 764         }
 765     }
 766
 767     va_end(ap);
 768
 769     return offset - old_offset;
 770 }
 771
 772 static size_t pdu_marshal(V9fsPDU *pdu, size_t offset, const char *fmt, ...)
 773 {
 774     size_t old_offset = offset;
 775     va_list ap;
 776     int i;
 777
 778     va_start(ap, fmt);
 779     for (i = 0; fmt[i]; i++) {
 780         switch (fmt[i]) {
 781         case 'b': {
 782             uint8_t val = va_arg(ap, int);
 783             offset += pdu_pack(pdu, offset, &val, sizeof(val));
 784             break;
 785         }
 786         case 'w': {
 787             uint16_t val;
 788             cpu_to_le16w(&val, va_arg(ap, int));
 789             offset += pdu_pack(pdu, offset, &val, sizeof(val));
 790             break;
 791         }
 792         case 'd': {
 793             uint32_t val;
 794             cpu_to_le32w(&val, va_arg(ap, uint32_t));
 795             offset += pdu_pack(pdu, offset, &val, sizeof(val));
 796             break;
 797         }
 798         case 'q': {
 799             uint64_t val;
 800             cpu_to_le64w(&val, va_arg(ap, uint64_t));
 801             offset += pdu_pack(pdu, offset, &val, sizeof(val));
 802             break;
 803         }
 804         case 'v': {
 805             struct iovec *iov = va_arg(ap, struct iovec *);
 806             int *iovcnt = va_arg(ap, int *);
 807             *iovcnt = pdu_copy_sg(pdu, offset, 1, iov);
 808             break;
 809         }
 810         case 's': {
 811             V9fsString *str = va_arg(ap, V9fsString *);
 812             offset += pdu_marshal(pdu, offset, "w", str->size);
 813             offset += pdu_pack(pdu, offset, str->data, str->size);
 814             break;
 815         }
 816         case 'Q': {
 817             V9fsQID *qidp = va_arg(ap, V9fsQID *);
 818             offset += pdu_marshal(pdu, offset, "bdq",
 819                         qidp->type, qidp->version, qidp->path);
 820             break;
 821         }
 822         case 'S': {
 823             V9fsStat *statp = va_arg(ap, V9fsStat *);
 824             offset += pdu_marshal(pdu, offset, "wwdQdddqsssssddd",
 825                         statp->size, statp->type, statp->dev,
 826                         &statp->qid, statp->mode, statp->atime,
 827                         statp->mtime, statp->length, &statp->name,
 828                         &statp->uid, &statp->gid, &statp->muid,
 829                         &statp->extension, statp->n_uid,
 830                         statp->n_gid, statp->n_muid);
 831             break;
 832         }
 833         case 'A': {
 834             V9fsStatDotl *statp = va_arg(ap, V9fsStatDotl *);
 835             offset += pdu_marshal(pdu, offset, "qQdddqqqqqqqqqqqqqqq",
 836                         statp->st_result_mask,
 837                         &statp->qid, statp->st_mode,
 838                         statp->st_uid, statp->st_gid,
 839                         statp->st_nlink, statp->st_rdev,
 840                         statp->st_size, statp->st_blksize, statp->st_blocks,
 841                         statp->st_atime_sec, statp->st_atime_nsec,
 842                         statp->st_mtime_sec, statp->st_mtime_nsec,
 843                         statp->st_ctime_sec, statp->st_ctime_nsec,
 844                         statp->st_btime_sec, statp->st_btime_nsec,
 845                         statp->st_gen, statp->st_data_version);
 846             break;
 847         }
 848         default:
 849             break;
 850         }
 851     }
 852     va_end(ap);
 853
 854     return offset - old_offset;
 855 }
 856
 857 static void complete_pdu(V9fsState *s, V9fsPDU *pdu, ssize_t len)
 858 {
 859     int8_t id = pdu->id + 1; /* Response */
 860
 861     if (len < 0) {
 862         int err = -len;
 863         len = 7;
 864
 865         if (s->proto_version != V9FS_PROTO_2000L) {
 866             V9fsString str;
 867
 868             str.data = strerror(err);
 869             str.size = strlen(str.data);
 870
 871             len += pdu_marshal(pdu, len, "s", &str);
 872             id = P9_RERROR;
 873         }
 874
 875         len += pdu_marshal(pdu, len, "d", err);
 876
 877         if (s->proto_version == V9FS_PROTO_2000L) {
 878             id = P9_RLERROR;
 879         }
 880     }
 881
 882     /* fill out the header */
 883     pdu_marshal(pdu, 0, "dbw", (int32_t)len, id, pdu->tag);
 884
 885     /* keep these in sync */
 886     pdu->size = len;
 887     pdu->id = id;
 888
 889     /* push onto queue and notify */
 890     virtqueue_push(s->vq, &pdu->elem, len);
 891
 892     /* FIXME: we should batch these completions */
 893     virtio_notify(&s->vdev, s->vq);
 894
 895     free_pdu(s, pdu);
 896 }
 897
 898 static mode_t v9mode_to_mode(uint32_t mode, V9fsString *extension)
 899 {
 900     mode_t ret;
 901
 902     ret = mode & 0777;
 903     if (mode & P9_STAT_MODE_DIR) {
 904         ret |= S_IFDIR;
 905     }
 906
 907     if (mode & P9_STAT_MODE_SYMLINK) {
 908         ret |= S_IFLNK;
 909     }
 910     if (mode & P9_STAT_MODE_SOCKET) {
 911         ret |= S_IFSOCK;
 912     }
 913     if (mode & P9_STAT_MODE_NAMED_PIPE) {
 914         ret |= S_IFIFO;
 915     }
 916     if (mode & P9_STAT_MODE_DEVICE) {
 917         if (extension && extension->data[0] == 'c') {
 918             ret |= S_IFCHR;
 919         } else {
 920             ret |= S_IFBLK;
 921         }
 922     }
 923
 924     if (!(ret&~0777)) {
 925         ret |= S_IFREG;
 926     }
 927
 928     if (mode & P9_STAT_MODE_SETUID) {
 929         ret |= S_ISUID;
 930     }
 931     if (mode & P9_STAT_MODE_SETGID) {
 932         ret |= S_ISGID;
 933     }
 934     if (mode & P9_STAT_MODE_SETVTX) {
 935         ret |= S_ISVTX;
 936     }
 937
 938     return ret;
 939 }
 940
 941 static int donttouch_stat(V9fsStat *stat)
 942 {
 943     if (stat->type == -1 &&
 944         stat->dev == -1 &&
 945         stat->qid.type == -1 &&
 946         stat->qid.version == -1 &&
 947         stat->qid.path == -1 &&
 948         stat->mode == -1 &&
 949         stat->atime == -1 &&
 950         stat->mtime == -1 &&
 951         stat->length == -1 &&
 952         !stat->name.size &&
 953         !stat->uid.size &&
 954         !stat->gid.size &&
 955         !stat->muid.size &&
 956         stat->n_uid == -1 &&
 957         stat->n_gid == -1 &&
 958         stat->n_muid == -1) {
 959         return 1;
 960     }
 961
 962     return 0;
 963 }
 964
 965 static void v9fs_stat_free(V9fsStat *stat)
 966 {
 967     v9fs_string_free(&stat->name);
 968     v9fs_string_free(&stat->uid);
 969     v9fs_string_free(&stat->gid);
 970     v9fs_string_free(&stat->muid);
 971     v9fs_string_free(&stat->extension);
 972 }
 973
 974 static uint32_t stat_to_v9mode(const struct stat *stbuf)
 975 {
 976     uint32_t mode;
 977
 978     mode = stbuf->st_mode & 0777;
 979     if (S_ISDIR(stbuf->st_mode)) {
 980         mode |= P9_STAT_MODE_DIR;
 981     }
 982
 983     if (S_ISLNK(stbuf->st_mode)) {
 984         mode |= P9_STAT_MODE_SYMLINK;
 985     }
 986
 987     if (S_ISSOCK(stbuf->st_mode)) {
 988         mode |= P9_STAT_MODE_SOCKET;
 989     }
 990
 991     if (S_ISFIFO(stbuf->st_mode)) {
 992         mode |= P9_STAT_MODE_NAMED_PIPE;
 993     }
 994
 995     if (S_ISBLK(stbuf->st_mode) || S_ISCHR(stbuf->st_mode)) {
 996         mode |= P9_STAT_MODE_DEVICE;
 997     }
 998
 999     if (stbuf->st_mode & S_ISUID) {
1000         mode |= P9_STAT_MODE_SETUID;
1001     }
1002
1003     if (stbuf->st_mode & S_ISGID) {
1004         mode |= P9_STAT_MODE_SETGID;
1005     }
1006
1007     if (stbuf->st_mode & S_ISVTX) {
1008         mode |= P9_STAT_MODE_SETVTX;
1009     }
1010
1011     return mode;
1012 }
1013
1014 static int stat_to_v9stat(V9fsState *s, V9fsString *name,
1015                             const struct stat *stbuf,
1016                             V9fsStat *v9stat)
1017 {
1018     int err;
1019     const char *str;
1020
1021     memset(v9stat, 0, sizeof(*v9stat));
1022
1023     stat_to_qid(stbuf, &v9stat->qid);
1024     v9stat->mode = stat_to_v9mode(stbuf);
1025     v9stat->atime = stbuf->st_atime;
1026     v9stat->mtime = stbuf->st_mtime;
1027     v9stat->length = stbuf->st_size;
1028
1029     v9fs_string_null(&v9stat->uid);
1030     v9fs_string_null(&v9stat->gid);
1031     v9fs_string_null(&v9stat->muid);
1032
1033     v9stat->n_uid = stbuf->st_uid;
1034     v9stat->n_gid = stbuf->st_gid;
1035     v9stat->n_muid = 0;
1036
1037     v9fs_string_null(&v9stat->extension);
1038
1039     if (v9stat->mode & P9_STAT_MODE_SYMLINK) {
1040         err = v9fs_do_readlink(s, name, &v9stat->extension);
1041         if (err == -1) {
1042             err = -errno;
1043             return err;
1044         }
1045         v9stat->extension.data[err] = 0;
1046         v9stat->extension.size = err;
1047     } else if (v9stat->mode & P9_STAT_MODE_DEVICE) {
1048         v9fs_string_sprintf(&v9stat->extension, "%c %u %u",
1049                 S_ISCHR(stbuf->st_mode) ? 'c' : 'b',
1050                 major(stbuf->st_rdev), minor(stbuf->st_rdev));
1051     } else if (S_ISDIR(stbuf->st_mode) || S_ISREG(stbuf->st_mode)) {
1052         v9fs_string_sprintf(&v9stat->extension, "%s %lu",
1053                 "HARDLINKCOUNT", (unsigned long)stbuf->st_nlink);
1054     }
1055
1056     str = strrchr(name->data, '/');
1057     if (str) {
1058         str += 1;
1059     } else {
1060         str = name->data;
1061     }
1062
1063     v9fs_string_sprintf(&v9stat->name, "%s", str);
1064
1065     v9stat->size = 61 +
1066         v9fs_string_size(&v9stat->name) +
1067         v9fs_string_size(&v9stat->uid) +
1068         v9fs_string_size(&v9stat->gid) +
1069         v9fs_string_size(&v9stat->muid) +
1070         v9fs_string_size(&v9stat->extension);
1071     return 0;
1072 }
1073
1074 #define P9_STATS_MODE          0x00000001ULL
1075 #define P9_STATS_NLINK         0x00000002ULL
1076 #define P9_STATS_UID           0x00000004ULL
1077 #define P9_STATS_GID           0x00000008ULL
1078 #define P9_STATS_RDEV          0x00000010ULL
1079 #define P9_STATS_ATIME         0x00000020ULL
1080 #define P9_STATS_MTIME         0x00000040ULL
1081 #define P9_STATS_CTIME         0x00000080ULL
1082 #define P9_STATS_INO           0x00000100ULL
1083 #define P9_STATS_SIZE          0x00000200ULL
1084 #define P9_STATS_BLOCKS        0x00000400ULL
1085
1086 #define P9_STATS_BTIME         0x00000800ULL
1087 #define P9_STATS_GEN           0x00001000ULL
1088 #define P9_STATS_DATA_VERSION  0x00002000ULL
1089
1090 #define P9_STATS_BASIC         0x000007ffULL /* Mask for fields up to BLOCKS */
1091 #define P9_STATS_ALL           0x00003fffULL /* Mask for All fields above */
1092
1093
1094 static void stat_to_v9stat_dotl(V9fsState *s, const struct stat *stbuf,
1095                             V9fsStatDotl *v9lstat)
1096 {
1097     memset(v9lstat, 0, sizeof(*v9lstat));
1098
1099     v9lstat->st_mode = stbuf->st_mode;
1100     v9lstat->st_nlink = stbuf->st_nlink;
1101     v9lstat->st_uid = stbuf->st_uid;
1102     v9lstat->st_gid = stbuf->st_gid;
1103     v9lstat->st_rdev = stbuf->st_rdev;
1104     v9lstat->st_size = stbuf->st_size;
1105     v9lstat->st_blksize = stbuf->st_blksize;
1106     v9lstat->st_blocks = stbuf->st_blocks;
1107     v9lstat->st_atime_sec = stbuf->st_atime;
1108     v9lstat->st_atime_nsec = stbuf->st_atim.tv_nsec;
1109     v9lstat->st_mtime_sec = stbuf->st_mtime;
1110     v9lstat->st_mtime_nsec = stbuf->st_mtim.tv_nsec;
1111     v9lstat->st_ctime_sec = stbuf->st_ctime;
1112     v9lstat->st_ctime_nsec = stbuf->st_ctim.tv_nsec;
1113     /* Currently we only support BASIC fields in stat */
1114     v9lstat->st_result_mask = P9_STATS_BASIC;
1115
1116     stat_to_qid(stbuf, &v9lstat->qid);
1117 }
1118
1119 static struct iovec *adjust_sg(struct iovec *sg, int len, int *iovcnt)
1120 {
1121     while (len && *iovcnt) {
1122         if (len < sg->iov_len) {
1123             sg->iov_len -= len;
1124             sg->iov_base += len;
1125             len = 0;
1126         } else {
1127             len -= sg->iov_len;
1128             sg++;
1129             *iovcnt -= 1;
1130         }
1131     }
1132
1133     return sg;
1134 }
1135
1136 static struct iovec *cap_sg(struct iovec *sg, int cap, int *cnt)
1137 {
1138     int i;
1139     int total = 0;
1140
1141     for (i = 0; i < *cnt; i++) {
1142         if ((total + sg[i].iov_len) > cap) {
1143             sg[i].iov_len -= ((total + sg[i].iov_len) - cap);
1144             i++;
1145             break;
1146         }
1147         total += sg[i].iov_len;
1148     }
1149
1150     *cnt = i;
1151
1152     return sg;
1153 }
1154
1155 static void print_sg(struct iovec *sg, int cnt)
1156 {
1157     int i;
1158
1159     printf("sg[%d]: {", cnt);
1160     for (i = 0; i < cnt; i++) {
1161         if (i) {
1162             printf(", ");
1163         }
1164         printf("(%p, %zd)", sg[i].iov_base, sg[i].iov_len);
1165     }
1166     printf("}\n");
1167 }
1168
1169 static void v9fs_fix_path(V9fsString *dst, V9fsString *src, int len)
1170 {
1171     V9fsString str;
1172     v9fs_string_init(&str);
1173     v9fs_string_copy(&str, dst);
1174     v9fs_string_sprintf(dst, "%s%s", src->data, str.data+len);
1175     v9fs_string_free(&str);
1176 }
1177
1178 static void v9fs_version(V9fsState *s, V9fsPDU *pdu)
1179 {
1180     V9fsString version;
1181     size_t offset = 7;
1182
1183     pdu_unmarshal(pdu, offset, "ds", &s->msize, &version);
1184
1185     if (!strcmp(version.data, "9P2000.u")) {
1186         s->proto_version = V9FS_PROTO_2000U;
1187     } else if (!strcmp(version.data, "9P2000.L")) {
1188         s->proto_version = V9FS_PROTO_2000L;
1189     } else {
1190         v9fs_string_sprintf(&version, "unknown");
1191     }
1192
1193     offset += pdu_marshal(pdu, offset, "ds", s->msize, &version);
1194     complete_pdu(s, pdu, offset);
1195
1196     v9fs_string_free(&version);
1197 }
1198
1199 static void v9fs_attach(V9fsState *s, V9fsPDU *pdu)
1200 {
1201     int32_t fid, afid, n_uname;
1202     V9fsString uname, aname;
1203     V9fsFidState *fidp;
1204     V9fsQID qid;
1205     size_t offset = 7;
1206     ssize_t err;
1207
1208     pdu_unmarshal(pdu, offset, "ddssd", &fid, &afid, &uname, &aname, &n_uname);
1209
1210     fidp = alloc_fid(s, fid);
1211     if (fidp == NULL) {
1212         err = -EINVAL;
1213         goto out;
1214     }
1215
1216     fidp->uid = n_uname;
1217
1218     v9fs_string_sprintf(&fidp->path, "%s", "/");
1219     err = fid_to_qid(s, fidp, &qid);
1220     if (err) {
1221         err = -EINVAL;
1222         free_fid(s, fid);
1223         goto out;
1224     }
1225
1226     offset += pdu_marshal(pdu, offset, "Q", &qid);
1227
1228     err = offset;
1229 out:
1230     complete_pdu(s, pdu, err);
1231     v9fs_string_free(&uname);
1232     v9fs_string_free(&aname);
1233 }
1234
1235 static void v9fs_stat_post_lstat(V9fsState *s, V9fsStatState *vs, int err)
1236 {
1237     if (err == -1) {
1238         err = -errno;
1239         goto out;
1240     }
1241
1242     err = stat_to_v9stat(s, &vs->fidp->path, &vs->stbuf, &vs->v9stat);
1243     if (err) {
1244         goto out;
1245     }
1246     vs->offset += pdu_marshal(vs->pdu, vs->offset, "wS", 0, &vs->v9stat);
1247     err = vs->offset;
1248
1249 out:
1250     complete_pdu(s, vs->pdu, err);
1251     v9fs_stat_free(&vs->v9stat);
1252     qemu_free(vs);
1253 }
1254
1255 static void v9fs_stat(V9fsState *s, V9fsPDU *pdu)
1256 {
1257     int32_t fid;
1258     V9fsStatState *vs;
1259     ssize_t err = 0;
1260
1261     vs = qemu_malloc(sizeof(*vs));
1262     vs->pdu = pdu;
1263     vs->offset = 7;
1264
1265     memset(&vs->v9stat, 0, sizeof(vs->v9stat));
1266
1267     pdu_unmarshal(vs->pdu, vs->offset, "d", &fid);
1268
1269     vs->fidp = lookup_fid(s, fid);
1270     if (vs->fidp == NULL) {
1271         err = -ENOENT;
1272         goto out;
1273     }
1274
1275     err = v9fs_do_lstat(s, &vs->fidp->path, &vs->stbuf);
1276     v9fs_stat_post_lstat(s, vs, err);
1277     return;
1278
1279 out:
1280     complete_pdu(s, vs->pdu, err);
1281     v9fs_stat_free(&vs->v9stat);
1282     qemu_free(vs);
1283 }
1284
1285 static void v9fs_getattr_post_lstat(V9fsState *s, V9fsStatStateDotl *vs,
1286                                                                 int err)
1287 {
1288     if (err == -1) {
1289         err = -errno;
1290         goto out;
1291     }
1292
1293     stat_to_v9stat_dotl(s, &vs->stbuf, &vs->v9stat_dotl);
1294     vs->offset += pdu_marshal(vs->pdu, vs->offset, "A", &vs->v9stat_dotl);
1295     err = vs->offset;
1296
1297 out:
1298     complete_pdu(s, vs->pdu, err);
1299     qemu_free(vs);
1300 }
1301
1302 static void v9fs_getattr(V9fsState *s, V9fsPDU *pdu)
1303 {
1304     int32_t fid;
1305     V9fsStatStateDotl *vs;
1306     ssize_t err = 0;
1307     V9fsFidState *fidp;
1308     uint64_t request_mask;
1309
1310     vs = qemu_malloc(sizeof(*vs));
1311     vs->pdu = pdu;
1312     vs->offset = 7;
1313
1314     memset(&vs->v9stat_dotl, 0, sizeof(vs->v9stat_dotl));
1315
1316     pdu_unmarshal(vs->pdu, vs->offset, "dq", &fid, &request_mask);
1317
1318     fidp = lookup_fid(s, fid);
1319     if (fidp == NULL) {
1320         err = -ENOENT;
1321         goto out;
1322     }
1323
1324     /* Currently we only support BASIC fields in stat, so there is no
1325      * need to look at request_mask.
1326      */
1327     err = v9fs_do_lstat(s, &fidp->path, &vs->stbuf);
1328     v9fs_getattr_post_lstat(s, vs, err);
1329     return;
1330
1331 out:
1332     complete_pdu(s, vs->pdu, err);
1333     qemu_free(vs);
1334 }
1335
1336 /* From Linux kernel code */
1337 #define ATTR_MODE    (1 << 0)
1338 #define ATTR_UID     (1 << 1)
1339 #define ATTR_GID     (1 << 2)
1340 #define ATTR_SIZE    (1 << 3)
1341 #define ATTR_ATIME   (1 << 4)
1342 #define ATTR_MTIME   (1 << 5)
1343 #define ATTR_CTIME   (1 << 6)
1344 #define ATTR_MASK    127
1345 #define ATTR_ATIME_SET  (1 << 7)
1346 #define ATTR_MTIME_SET  (1 << 8)
1347
1348 static void v9fs_setattr_post_truncate(V9fsState *s, V9fsSetattrState *vs,
1349                                                                   int err)
1350 {
1351     if (err == -1) {
1352         err = -errno;
1353         goto out;
1354     }
1355     err = vs->offset;
1356
1357 out:
1358     complete_pdu(s, vs->pdu, err);
1359     qemu_free(vs);
1360 }
1361
1362 static void v9fs_setattr_post_chown(V9fsState *s, V9fsSetattrState *vs, int err)
1363 {
1364     if (err == -1) {
1365         err = -errno;
1366         goto out;
1367     }
1368
1369     if (vs->v9iattr.valid & (ATTR_SIZE)) {
1370         err = v9fs_do_truncate(s, &vs->fidp->path, vs->v9iattr.size);
1371     }
1372     v9fs_setattr_post_truncate(s, vs, err);
1373     return;
1374
1375 out:
1376     complete_pdu(s, vs->pdu, err);
1377     qemu_free(vs);
1378 }
1379
1380 static void v9fs_setattr_post_utimensat(V9fsState *s, V9fsSetattrState *vs,
1381                                                                    int err)
1382 {
1383     if (err == -1) {
1384         err = -errno;
1385         goto out;
1386     }
1387
1388     /* If the only valid entry in iattr is ctime we can call
1389      * chown(-1,-1) to update the ctime of the file
1390      */
1391     if ((vs->v9iattr.valid & (ATTR_UID | ATTR_GID)) ||
1392             ((vs->v9iattr.valid & ATTR_CTIME)
1393             && !((vs->v9iattr.valid & ATTR_MASK) & ~ATTR_CTIME))) {
1394         if (!(vs->v9iattr.valid & ATTR_UID)) {
1395             vs->v9iattr.uid = -1;
1396         }
1397         if (!(vs->v9iattr.valid & ATTR_GID)) {
1398             vs->v9iattr.gid = -1;
1399         }
1400         err = v9fs_do_chown(s, &vs->fidp->path, vs->v9iattr.uid,
1401                                                 vs->v9iattr.gid);
1402     }
1403     v9fs_setattr_post_chown(s, vs, err);
1404     return;
1405
1406 out:
1407     complete_pdu(s, vs->pdu, err);
1408     qemu_free(vs);
1409 }
1410
1411 static void v9fs_setattr_post_chmod(V9fsState *s, V9fsSetattrState *vs, int err)
1412 {
1413     if (err == -1) {
1414         err = -errno;
1415         goto out;
1416     }
1417
1418     if (vs->v9iattr.valid & (ATTR_ATIME | ATTR_MTIME)) {
1419         struct timespec times[2];
1420         if (vs->v9iattr.valid & ATTR_ATIME) {
1421             if (vs->v9iattr.valid & ATTR_ATIME_SET) {
1422                 times[0].tv_sec = vs->v9iattr.atime_sec;
1423                 times[0].tv_nsec = vs->v9iattr.atime_nsec;
1424             } else {
1425                 times[0].tv_nsec = UTIME_NOW;
1426             }
1427         } else {
1428             times[0].tv_nsec = UTIME_OMIT;
1429         }
1430
1431         if (vs->v9iattr.valid & ATTR_MTIME) {
1432             if (vs->v9iattr.valid & ATTR_MTIME_SET) {
1433                 times[1].tv_sec = vs->v9iattr.mtime_sec;
1434                 times[1].tv_nsec = vs->v9iattr.mtime_nsec;
1435             } else {
1436                 times[1].tv_nsec = UTIME_NOW;
1437             }
1438         } else {
1439             times[1].tv_nsec = UTIME_OMIT;
1440         }
1441         err = v9fs_do_utimensat(s, &vs->fidp->path, times);
1442     }
1443     v9fs_setattr_post_utimensat(s, vs, err);
1444     return;
1445
1446 out:
1447     complete_pdu(s, vs->pdu, err);
1448     qemu_free(vs);
1449 }
1450
1451 static void v9fs_setattr(V9fsState *s, V9fsPDU *pdu)
1452 {
1453     int32_t fid;
1454     V9fsSetattrState *vs;
1455     int err = 0;
1456
1457     vs = qemu_malloc(sizeof(*vs));
1458     vs->pdu = pdu;
1459     vs->offset = 7;
1460
1461     pdu_unmarshal(pdu, vs->offset, "dI", &fid, &vs->v9iattr);
1462
1463     vs->fidp = lookup_fid(s, fid);
1464     if (vs->fidp == NULL) {
1465         err = -EINVAL;
1466         goto out;
1467     }
1468
1469     if (vs->v9iattr.valid & ATTR_MODE) {
1470         err = v9fs_do_chmod(s, &vs->fidp->path, vs->v9iattr.mode);
1471     }
1472
1473     v9fs_setattr_post_chmod(s, vs, err);
1474     return;
1475
1476 out:
1477     complete_pdu(s, vs->pdu, err);
1478     qemu_free(vs);
1479 }
1480
1481 static void v9fs_walk_complete(V9fsState *s, V9fsWalkState *vs, int err)
1482 {
1483     complete_pdu(s, vs->pdu, err);
1484
1485     if (vs->nwnames && vs->nwnames <= P9_MAXWELEM) {
1486         for (vs->name_idx = 0; vs->name_idx < vs->nwnames; vs->name_idx++) {
1487             v9fs_string_free(&vs->wnames[vs->name_idx]);
1488         }
1489
1490         qemu_free(vs->wnames);
1491         qemu_free(vs->qids);
1492     }
1493 }
1494
1495 static void v9fs_walk_marshal(V9fsWalkState *vs)
1496 {
1497     int i;
1498     vs->offset = 7;
1499     vs->offset += pdu_marshal(vs->pdu, vs->offset, "w", vs->nwnames);
1500
1501     for (i = 0; i < vs->nwnames; i++) {
1502         vs->offset += pdu_marshal(vs->pdu, vs->offset, "Q", &vs->qids[i]);
1503     }
1504 }
1505
1506 static void v9fs_walk_post_newfid_lstat(V9fsState *s, V9fsWalkState *vs,
1507                                                                 int err)
1508 {
1509     if (err == -1) {
1510         free_fid(s, vs->newfidp->fid);
1511         v9fs_string_free(&vs->path);
1512         err = -ENOENT;
1513         goto out;
1514     }
1515
1516     stat_to_qid(&vs->stbuf, &vs->qids[vs->name_idx]);
1517
1518     vs->name_idx++;
1519     if (vs->name_idx < vs->nwnames) {
1520         v9fs_string_sprintf(&vs->path, "%s/%s", vs->newfidp->path.data,
1521                                             vs->wnames[vs->name_idx].data);
1522         v9fs_string_copy(&vs->newfidp->path, &vs->path);
1523
1524         err = v9fs_do_lstat(s, &vs->newfidp->path, &vs->stbuf);
1525         v9fs_walk_post_newfid_lstat(s, vs, err);
1526         return;
1527     }
1528
1529     v9fs_string_free(&vs->path);
1530     v9fs_walk_marshal(vs);
1531     err = vs->offset;
1532 out:
1533     v9fs_walk_complete(s, vs, err);
1534 }
1535
1536 static void v9fs_walk_post_oldfid_lstat(V9fsState *s, V9fsWalkState *vs,
1537         int err)
1538 {
1539     if (err == -1) {
1540         v9fs_string_free(&vs->path);
1541         err = -ENOENT;
1542         goto out;
1543     }
1544
1545     stat_to_qid(&vs->stbuf, &vs->qids[vs->name_idx]);
1546     vs->name_idx++;
1547     if (vs->name_idx < vs->nwnames) {
1548
1549         v9fs_string_sprintf(&vs->path, "%s/%s",
1550                 vs->fidp->path.data, vs->wnames[vs->name_idx].data);
1551         v9fs_string_copy(&vs->fidp->path, &vs->path);
1552
1553         err = v9fs_do_lstat(s, &vs->fidp->path, &vs->stbuf);
1554         v9fs_walk_post_oldfid_lstat(s, vs, err);
1555         return;
1556     }
1557
1558     v9fs_string_free(&vs->path);
1559     v9fs_walk_marshal(vs);
1560     err = vs->offset;
1561 out:
1562     v9fs_walk_complete(s, vs, err);
1563 }
1564
1565 static void v9fs_walk(V9fsState *s, V9fsPDU *pdu)
1566 {
1567     int32_t fid, newfid;
1568     V9fsWalkState *vs;
1569     int err = 0;
1570     int i;
1571
1572     vs = qemu_malloc(sizeof(*vs));
1573     vs->pdu = pdu;
1574     vs->wnames = NULL;
1575     vs->qids = NULL;
1576     vs->offset = 7;
1577
1578     vs->offset += pdu_unmarshal(vs->pdu, vs->offset, "ddw", &fid,
1579                                             &newfid, &vs->nwnames);
1580
1581     if (vs->nwnames && vs->nwnames <= P9_MAXWELEM) {
1582         vs->wnames = qemu_mallocz(sizeof(vs->wnames[0]) * vs->nwnames);
1583
1584         vs->qids = qemu_mallocz(sizeof(vs->qids[0]) * vs->nwnames);
1585
1586         for (i = 0; i < vs->nwnames; i++) {
1587             vs->offset += pdu_unmarshal(vs->pdu, vs->offset, "s",
1588                                             &vs->wnames[i]);
1589         }
1590     } else if (vs->nwnames > P9_MAXWELEM) {
1591         err = -EINVAL;
1592         goto out;
1593     }
1594
1595     vs->fidp = lookup_fid(s, fid);
1596     if (vs->fidp == NULL) {
1597         err = -ENOENT;
1598         goto out;
1599     }
1600
1601     /* FIXME: is this really valid? */
1602     if (fid == newfid) {
1603
1604         BUG_ON(vs->fidp->fid_type != P9_FID_NONE);
1605         v9fs_string_init(&vs->path);
1606         vs->name_idx = 0;
1607
1608         if (vs->name_idx < vs->nwnames) {
1609             v9fs_string_sprintf(&vs->path, "%s/%s",
1610                 vs->fidp->path.data, vs->wnames[vs->name_idx].data);
1611             v9fs_string_copy(&vs->fidp->path, &vs->path);
1612
1613             err = v9fs_do_lstat(s, &vs->fidp->path, &vs->stbuf);
1614             v9fs_walk_post_oldfid_lstat(s, vs, err);
1615             return;
1616         }
1617     } else {
1618         vs->newfidp = alloc_fid(s, newfid);
1619         if (vs->newfidp == NULL) {
1620             err = -EINVAL;
1621             goto out;
1622         }
1623
1624         vs->newfidp->uid = vs->fidp->uid;
1625         v9fs_string_init(&vs->path);
1626         vs->name_idx = 0;
1627         v9fs_string_copy(&vs->newfidp->path, &vs->fidp->path);
1628
1629         if (vs->name_idx < vs->nwnames) {
1630             v9fs_string_sprintf(&vs->path, "%s/%s", vs->newfidp->path.data,
1631                                 vs->wnames[vs->name_idx].data);
1632             v9fs_string_copy(&vs->newfidp->path, &vs->path);
1633
1634             err = v9fs_do_lstat(s, &vs->newfidp->path, &vs->stbuf);
1635             v9fs_walk_post_newfid_lstat(s, vs, err);
1636             return;
1637         }
1638     }
1639
1640     v9fs_walk_marshal(vs);
1641     err = vs->offset;
1642 out:
1643     v9fs_walk_complete(s, vs, err);
1644 }
1645
1646 static int32_t get_iounit(V9fsState *s, V9fsString *name)
1647 {
1648     struct statfs stbuf;
1649     int32_t iounit = 0;
1650
1651     /*
1652      * iounit should be multiples of f_bsize (host filesystem block size
1653      * and as well as less than (client msize - P9_IOHDRSZ))
1654      */
1655     if (!v9fs_do_statfs(s, name, &stbuf)) {
1656         iounit = stbuf.f_bsize;
1657         iounit *= (s->msize - P9_IOHDRSZ)/stbuf.f_bsize;
1658     }
1659
1660     if (!iounit) {
1661         iounit = s->msize - P9_IOHDRSZ;
1662     }
1663     return iounit;
1664 }
1665
1666 static void v9fs_open_post_opendir(V9fsState *s, V9fsOpenState *vs, int err)
1667 {
1668     if (vs->fidp->fs.dir == NULL) {
1669         err = -errno;
1670         goto out;
1671     }
1672     vs->fidp->fid_type = P9_FID_DIR;
1673     vs->offset += pdu_marshal(vs->pdu, vs->offset, "Qd", &vs->qid, 0);
1674     err = vs->offset;
1675 out:
1676     complete_pdu(s, vs->pdu, err);
1677     qemu_free(vs);
1678
1679 }
1680
1681 static void v9fs_open_post_getiounit(V9fsState *s, V9fsOpenState *vs)
1682 {
1683     int err;
1684     vs->offset += pdu_marshal(vs->pdu, vs->offset, "Qd", &vs->qid, vs->iounit);
1685     err = vs->offset;
1686     complete_pdu(s, vs->pdu, err);
1687     qemu_free(vs);
1688 }
1689
1690 static void v9fs_open_post_open(V9fsState *s, V9fsOpenState *vs, int err)
1691 {
1692     if (vs->fidp->fs.fd == -1) {
1693         err = -errno;
1694         goto out;
1695     }
1696     vs->fidp->fid_type = P9_FID_FILE;
1697     vs->iounit = get_iounit(s, &vs->fidp->path);
1698     v9fs_open_post_getiounit(s, vs);
1699     return;
1700 out:
1701     complete_pdu(s, vs->pdu, err);
1702     qemu_free(vs);
1703 }
1704
1705 static void v9fs_open_post_lstat(V9fsState *s, V9fsOpenState *vs, int err)
1706 {
1707     int flags;
1708
1709     if (err) {
1710         err = -errno;
1711         goto out;
1712     }
1713
1714     stat_to_qid(&vs->stbuf, &vs->qid);
1715
1716     if (S_ISDIR(vs->stbuf.st_mode)) {
1717         vs->fidp->fs.dir = v9fs_do_opendir(s, &vs->fidp->path);
1718         v9fs_open_post_opendir(s, vs, err);
1719     } else {
1720         if (s->proto_version == V9FS_PROTO_2000L) {
1721             flags = vs->mode;
1722             flags &= ~(O_NOCTTY | O_ASYNC | O_CREAT);
1723             /* Ignore direct disk access hint until the server supports it. */
1724             flags &= ~O_DIRECT;
1725         } else {
1726             flags = omode_to_uflags(vs->mode);
1727         }
1728         vs->fidp->fs.fd = v9fs_do_open(s, &vs->fidp->path, flags);
1729         v9fs_open_post_open(s, vs, err);
1730     }
1731     return;
1732 out:
1733     complete_pdu(s, vs->pdu, err);
1734     qemu_free(vs);
1735 }
1736
1737 static void v9fs_open(V9fsState *s, V9fsPDU *pdu)
1738 {
1739     int32_t fid;
1740     V9fsOpenState *vs;
1741     ssize_t err = 0;
1742
1743     vs = qemu_malloc(sizeof(*vs));
1744     vs->pdu = pdu;
1745     vs->offset = 7;
1746     vs->mode = 0;
1747
1748     if (s->proto_version == V9FS_PROTO_2000L) {
1749         pdu_unmarshal(vs->pdu, vs->offset, "dd", &fid, &vs->mode);
1750     } else {
1751         pdu_unmarshal(vs->pdu, vs->offset, "db", &fid, &vs->mode);
1752     }
1753
1754     vs->fidp = lookup_fid(s, fid);
1755     if (vs->fidp == NULL) {
1756         err = -ENOENT;
1757         goto out;
1758     }
1759
1760     BUG_ON(vs->fidp->fid_type != P9_FID_NONE);
1761
1762     err = v9fs_do_lstat(s, &vs->fidp->path, &vs->stbuf);
1763
1764     v9fs_open_post_lstat(s, vs, err);
1765     return;
1766 out:
1767     complete_pdu(s, pdu, err);
1768     qemu_free(vs);
1769 }
1770
1771 static void v9fs_post_lcreate(V9fsState *s, V9fsLcreateState *vs, int err)
1772 {
1773     if (err == 0) {
1774         v9fs_string_copy(&vs->fidp->path, &vs->fullname);
1775         stat_to_qid(&vs->stbuf, &vs->qid);
1776         vs->offset += pdu_marshal(vs->pdu, vs->offset, "Qd", &vs->qid,
1777                 vs->iounit);
1778         err = vs->offset;
1779     } else {
1780         vs->fidp->fid_type = P9_FID_NONE;
1781         err = -errno;
1782         if (vs->fidp->fs.fd > 0) {
1783             close(vs->fidp->fs.fd);
1784         }
1785     }
1786
1787     complete_pdu(s, vs->pdu, err);
1788     v9fs_string_free(&vs->name);
1789     v9fs_string_free(&vs->fullname);
1790     qemu_free(vs);
1791 }
1792
1793 static void v9fs_lcreate_post_get_iounit(V9fsState *s, V9fsLcreateState *vs,
1794         int err)
1795 {
1796     if (err) {
1797         err = -errno;
1798         goto out;
1799     }
1800     err = v9fs_do_lstat(s, &vs->fullname, &vs->stbuf);
1801
1802 out:
1803     v9fs_post_lcreate(s, vs, err);
1804 }
1805
1806 static void v9fs_lcreate_post_do_open2(V9fsState *s, V9fsLcreateState *vs,
1807         int err)
1808 {
1809     if (vs->fidp->fs.fd == -1) {
1810         err = -errno;
1811         goto out;
1812     }
1813     vs->fidp->fid_type = P9_FID_FILE;
1814     vs->iounit =  get_iounit(s, &vs->fullname);
1815     v9fs_lcreate_post_get_iounit(s, vs, err);
1816     return;
1817
1818 out:
1819     v9fs_post_lcreate(s, vs, err);
1820 }
1821
1822 static void v9fs_lcreate(V9fsState *s, V9fsPDU *pdu)
1823 {
1824     int32_t dfid, flags, mode;
1825     gid_t gid;
1826     V9fsLcreateState *vs;
1827     ssize_t err = 0;
1828
1829     vs = qemu_malloc(sizeof(*vs));
1830     vs->pdu = pdu;
1831     vs->offset = 7;
1832
1833     v9fs_string_init(&vs->fullname);
1834
1835     pdu_unmarshal(vs->pdu, vs->offset, "dsddd", &dfid, &vs->name, &flags,
1836             &mode, &gid);
1837
1838     vs->fidp = lookup_fid(s, dfid);
1839     if (vs->fidp == NULL) {
1840         err = -ENOENT;
1841         goto out;
1842     }
1843
1844     v9fs_string_sprintf(&vs->fullname, "%s/%s", vs->fidp->path.data,
1845              vs->name.data);
1846
1847     /* Ignore direct disk access hint until the server supports it. */
1848     flags &= ~O_DIRECT;
1849
1850     vs->fidp->fs.fd = v9fs_do_open2(s, vs->fullname.data, vs->fidp->uid,
1851             gid, flags, mode);
1852     v9fs_lcreate_post_do_open2(s, vs, err);
1853     return;
1854
1855 out:
1856     complete_pdu(s, vs->pdu, err);
1857     v9fs_string_free(&vs->name);
1858     qemu_free(vs);
1859 }
1860
1861 static void v9fs_post_do_fsync(V9fsState *s, V9fsPDU *pdu, int err)
1862 {
1863     if (err == -1) {
1864         err = -errno;
1865     }
1866     complete_pdu(s, pdu, err);
1867 }
1868
1869 static void v9fs_fsync(V9fsState *s, V9fsPDU *pdu)
1870 {
1871     int32_t fid;
1872     size_t offset = 7;
1873     V9fsFidState *fidp;
1874     int datasync;
1875     int err;
1876
1877     pdu_unmarshal(pdu, offset, "dd", &fid, &datasync);
1878     fidp = lookup_fid(s, fid);
1879     if (fidp == NULL) {
1880         err = -ENOENT;
1881         v9fs_post_do_fsync(s, pdu, err);
1882         return;
1883     }
1884     err = v9fs_do_fsync(s, fidp->fs.fd, datasync);
1885     v9fs_post_do_fsync(s, pdu, err);
1886 }
1887
1888 static void v9fs_clunk(V9fsState *s, V9fsPDU *pdu)
1889 {
1890     int32_t fid;
1891     size_t offset = 7;
1892     int err;
1893
1894     pdu_unmarshal(pdu, offset, "d", &fid);
1895
1896     err = free_fid(s, fid);
1897     if (err < 0) {
1898         goto out;
1899     }
1900
1901     offset = 7;
1902     err = offset;
1903 out:
1904     complete_pdu(s, pdu, err);
1905 }
1906
1907 static void v9fs_read_post_readdir(V9fsState *, V9fsReadState *, ssize_t);
1908
1909 static void v9fs_read_post_seekdir(V9fsState *s, V9fsReadState *vs, ssize_t err)
1910 {
1911     if (err) {
1912         goto out;
1913     }
1914     v9fs_stat_free(&vs->v9stat);
1915     v9fs_string_free(&vs->name);
1916     vs->offset += pdu_marshal(vs->pdu, vs->offset, "d", vs->count);
1917     vs->offset += vs->count;
1918     err = vs->offset;
1919 out:
1920     complete_pdu(s, vs->pdu, err);
1921     qemu_free(vs);
1922     return;
1923 }
1924
1925 static void v9fs_read_post_dir_lstat(V9fsState *s, V9fsReadState *vs,
1926                                     ssize_t err)
1927 {
1928     if (err) {
1929         err = -errno;
1930         goto out;
1931     }
1932     err = stat_to_v9stat(s, &vs->name, &vs->stbuf, &vs->v9stat);
1933     if (err) {
1934         goto out;
1935     }
1936
1937     vs->len = pdu_marshal(vs->pdu, vs->offset + 4 + vs->count, "S",
1938                             &vs->v9stat);
1939     if ((vs->len != (vs->v9stat.size + 2)) ||
1940             ((vs->count + vs->len) > vs->max_count)) {
1941         v9fs_do_seekdir(s, vs->fidp->fs.dir, vs->dir_pos);
1942         v9fs_read_post_seekdir(s, vs, err);
1943         return;
1944     }
1945     vs->count += vs->len;
1946     v9fs_stat_free(&vs->v9stat);
1947     v9fs_string_free(&vs->name);
1948     vs->dir_pos = vs->dent->d_off;
1949     vs->dent = v9fs_do_readdir(s, vs->fidp->fs.dir);
1950     v9fs_read_post_readdir(s, vs, err);
1951     return;
1952 out:
1953     v9fs_do_seekdir(s, vs->fidp->fs.dir, vs->dir_pos);
1954     v9fs_read_post_seekdir(s, vs, err);
1955     return;
1956
1957 }
1958
1959 static void v9fs_read_post_readdir(V9fsState *s, V9fsReadState *vs, ssize_t err)
1960 {
1961     if (vs->dent) {
1962         memset(&vs->v9stat, 0, sizeof(vs->v9stat));
1963         v9fs_string_init(&vs->name);
1964         v9fs_string_sprintf(&vs->name, "%s/%s", vs->fidp->path.data,
1965                             vs->dent->d_name);
1966         err = v9fs_do_lstat(s, &vs->name, &vs->stbuf);
1967         v9fs_read_post_dir_lstat(s, vs, err);
1968         return;
1969     }
1970
1971     vs->offset += pdu_marshal(vs->pdu, vs->offset, "d", vs->count);
1972     vs->offset += vs->count;
1973     err = vs->offset;
1974     complete_pdu(s, vs->pdu, err);
1975     qemu_free(vs);
1976     return;
1977 }
1978
1979 static void v9fs_read_post_telldir(V9fsState *s, V9fsReadState *vs, ssize_t err)
1980 {
1981     vs->dent = v9fs_do_readdir(s, vs->fidp->fs.dir);
1982     v9fs_read_post_readdir(s, vs, err);
1983     return;
1984 }
1985
1986 static void v9fs_read_post_rewinddir(V9fsState *s, V9fsReadState *vs,
1987                                        ssize_t err)
1988 {
1989     vs->dir_pos = v9fs_do_telldir(s, vs->fidp->fs.dir);
1990     v9fs_read_post_telldir(s, vs, err);
1991     return;
1992 }
1993
1994 static void v9fs_read_post_preadv(V9fsState *s, V9fsReadState *vs, ssize_t err)
1995 {
1996     if (err  < 0) {
1997         /* IO error return the error */
1998         err = -errno;
1999         goto out;
2000     }
2001     vs->total += vs->len;
2002     vs->sg = adjust_sg(vs->sg, vs->len, &vs->cnt);
2003     if (vs->total < vs->count && vs->len > 0) {
2004         do {
2005             if (0) {
2006                 print_sg(vs->sg, vs->cnt);
2007             }
2008             vs->len = v9fs_do_preadv(s, vs->fidp->fs.fd, vs->sg, vs->cnt,
2009                       vs->off);
2010             if (vs->len > 0) {
2011                 vs->off += vs->len;
2012             }
2013         } while (vs->len == -1 && errno == EINTR);
2014         if (vs->len == -1) {
2015             err  = -errno;
2016         }
2017         v9fs_read_post_preadv(s, vs, err);
2018         return;
2019     }
2020     vs->offset += pdu_marshal(vs->pdu, vs->offset, "d", vs->total);
2021     vs->offset += vs->count;
2022     err = vs->offset;
2023
2024 out:
2025     complete_pdu(s, vs->pdu, err);
2026     qemu_free(vs);
2027 }
2028
2029 static void v9fs_xattr_read(V9fsState *s, V9fsReadState *vs)
2030 {
2031     ssize_t err = 0;
2032     int read_count;
2033     int64_t xattr_len;
2034
2035     xattr_len = vs->fidp->fs.xattr.len;
2036     read_count = xattr_len - vs->off;
2037     if (read_count > vs->count) {
2038         read_count = vs->count;
2039     } else if (read_count < 0) {
2040         /*
2041          * read beyond XATTR value
2042          */
2043         read_count = 0;
2044     }
2045     vs->offset += pdu_marshal(vs->pdu, vs->offset, "d", read_count);
2046     vs->offset += pdu_pack(vs->pdu, vs->offset,
2047                            ((char *)vs->fidp->fs.xattr.value) + vs->off,
2048                            read_count);
2049     err = vs->offset;
2050     complete_pdu(s, vs->pdu, err);
2051     qemu_free(vs);
2052 }
2053
2054 static void v9fs_read(V9fsState *s, V9fsPDU *pdu)
2055 {
2056     int32_t fid;
2057     V9fsReadState *vs;
2058     ssize_t err = 0;
2059
2060     vs = qemu_malloc(sizeof(*vs));
2061     vs->pdu = pdu;
2062     vs->offset = 7;
2063     vs->total = 0;
2064     vs->len = 0;
2065     vs->count = 0;
2066
2067     pdu_unmarshal(vs->pdu, vs->offset, "dqd", &fid, &vs->off, &vs->count);
2068
2069     vs->fidp = lookup_fid(s, fid);
2070     if (vs->fidp == NULL) {
2071         err = -EINVAL;
2072         goto out;
2073     }
2074
2075     if (vs->fidp->fid_type == P9_FID_DIR) {
2076         vs->max_count = vs->count;
2077         vs->count = 0;
2078         if (vs->off == 0) {
2079             v9fs_do_rewinddir(s, vs->fidp->fs.dir);
2080         }
2081         v9fs_read_post_rewinddir(s, vs, err);
2082         return;
2083     } else if (vs->fidp->fid_type == P9_FID_FILE) {
2084         vs->sg = vs->iov;
2085         pdu_marshal(vs->pdu, vs->offset + 4, "v", vs->sg, &vs->cnt);
2086         vs->sg = cap_sg(vs->sg, vs->count, &vs->cnt);
2087         if (vs->total <= vs->count) {
2088             vs->len = v9fs_do_preadv(s, vs->fidp->fs.fd, vs->sg, vs->cnt,
2089                                     vs->off);
2090             if (vs->len > 0) {
2091                 vs->off += vs->len;
2092             }
2093             err = vs->len;
2094             v9fs_read_post_preadv(s, vs, err);
2095         }
2096         return;
2097     } else if (vs->fidp->fid_type == P9_FID_XATTR) {
2098         v9fs_xattr_read(s, vs);
2099         return;
2100     } else {
2101         err = -EINVAL;
2102     }
2103 out:
2104     complete_pdu(s, pdu, err);
2105     qemu_free(vs);
2106 }
2107
2108 typedef struct V9fsReadDirState {
2109     V9fsPDU *pdu;
2110     V9fsFidState *fidp;
2111     V9fsQID qid;
2112     off_t saved_dir_pos;
2113     struct dirent *dent;
2114     int32_t count;
2115     int32_t max_count;
2116     size_t offset;
2117     int64_t initial_offset;
2118     V9fsString name;
2119 } V9fsReadDirState;
2120
2121 static void v9fs_readdir_post_seekdir(V9fsState *s, V9fsReadDirState *vs)
2122 {
2123     vs->offset += pdu_marshal(vs->pdu, vs->offset, "d", vs->count);
2124     vs->offset += vs->count;
2125     complete_pdu(s, vs->pdu, vs->offset);
2126     qemu_free(vs);
2127     return;
2128 }
2129
2130 /* Size of each dirent on the wire: size of qid (13) + size of offset (8)
2131  * size of type (1) + size of name.size (2) + strlen(name.data)
2132  */
2133 #define V9_READDIR_DATA_SZ (24 + strlen(vs->name.data))
2134
2135 static void v9fs_readdir_post_readdir(V9fsState *s, V9fsReadDirState *vs)
2136 {
2137     int len;
2138     size_t size;
2139
2140     if (vs->dent) {
2141         v9fs_string_init(&vs->name);
2142         v9fs_string_sprintf(&vs->name, "%s", vs->dent->d_name);
2143
2144         if ((vs->count + V9_READDIR_DATA_SZ) > vs->max_count) {
2145             /* Ran out of buffer. Set dir back to old position and return */
2146             v9fs_do_seekdir(s, vs->fidp->fs.dir, vs->saved_dir_pos);
2147             v9fs_readdir_post_seekdir(s, vs);
2148             return;
2149         }
2150
2151         /* Fill up just the path field of qid because the client uses
2152          * only that. To fill the entire qid structure we will have
2153          * to stat each dirent found, which is expensive
2154          */
2155         size = MIN(sizeof(vs->dent->d_ino), sizeof(vs->qid.path));
2156         memcpy(&vs->qid.path, &vs->dent->d_ino, size);
2157         /* Fill the other fields with dummy values */
2158         vs->qid.type = 0;
2159         vs->qid.version = 0;
2160
2161         len = pdu_marshal(vs->pdu, vs->offset+4+vs->count, "Qqbs",
2162                               &vs->qid, vs->dent->d_off,
2163                               vs->dent->d_type, &vs->name);
2164         vs->count += len;
2165         v9fs_string_free(&vs->name);
2166         vs->saved_dir_pos = vs->dent->d_off;
2167         vs->dent = v9fs_do_readdir(s, vs->fidp->fs.dir);
2168         v9fs_readdir_post_readdir(s, vs);
2169         return;
2170     }
2171
2172     vs->offset += pdu_marshal(vs->pdu, vs->offset, "d", vs->count);
2173     vs->offset += vs->count;
2174     complete_pdu(s, vs->pdu, vs->offset);
2175     qemu_free(vs);
2176     return;
2177 }
2178
2179 static void v9fs_readdir_post_telldir(V9fsState *s, V9fsReadDirState *vs)
2180 {
2181     vs->dent = v9fs_do_readdir(s, vs->fidp->fs.dir);
2182     v9fs_readdir_post_readdir(s, vs);
2183     return;
2184 }
2185
2186 static void v9fs_readdir_post_setdir(V9fsState *s, V9fsReadDirState *vs)
2187 {
2188     vs->saved_dir_pos = v9fs_do_telldir(s, vs->fidp->fs.dir);
2189     v9fs_readdir_post_telldir(s, vs);
2190     return;
2191 }
2192
2193 static void v9fs_readdir(V9fsState *s, V9fsPDU *pdu)
2194 {
2195     int32_t fid;
2196     V9fsReadDirState *vs;
2197     ssize_t err = 0;
2198     size_t offset = 7;
2199
2200     vs = qemu_malloc(sizeof(*vs));
2201     vs->pdu = pdu;
2202     vs->offset = 7;
2203     vs->count = 0;
2204
2205     pdu_unmarshal(vs->pdu, offset, "dqd", &fid, &vs->initial_offset,
2206                                                         &vs->max_count);
2207
2208     vs->fidp = lookup_fid(s, fid);
2209     if (vs->fidp == NULL || !(vs->fidp->fs.dir)) {
2210         err = -EINVAL;
2211         goto out;
2212     }
2213
2214     if (vs->initial_offset == 0) {
2215         v9fs_do_rewinddir(s, vs->fidp->fs.dir);
2216     } else {
2217         v9fs_do_seekdir(s, vs->fidp->fs.dir, vs->initial_offset);
2218     }
2219
2220     v9fs_readdir_post_setdir(s, vs);
2221     return;
2222
2223 out:
2224     complete_pdu(s, pdu, err);
2225     qemu_free(vs);
2226     return;
2227 }
2228
2229 static void v9fs_write_post_pwritev(V9fsState *s, V9fsWriteState *vs,
2230                                    ssize_t err)
2231 {
2232     if (err  < 0) {
2233         /* IO error return the error */
2234         err = -errno;
2235         goto out;
2236     }
2237     vs->total += vs->len;
2238     vs->sg = adjust_sg(vs->sg, vs->len, &vs->cnt);
2239     if (vs->total < vs->count && vs->len > 0) {
2240         do {
2241             if (0) {
2242                 print_sg(vs->sg, vs->cnt);
2243             }
2244             vs->len = v9fs_do_pwritev(s, vs->fidp->fs.fd, vs->sg, vs->cnt,
2245                       vs->off);
2246             if (vs->len > 0) {
2247                 vs->off += vs->len;
2248             }
2249         } while (vs->len == -1 && errno == EINTR);
2250         if (vs->len == -1) {
2251             err  = -errno;
2252         }
2253         v9fs_write_post_pwritev(s, vs, err);
2254         return;
2255     }
2256     vs->offset += pdu_marshal(vs->pdu, vs->offset, "d", vs->total);
2257     err = vs->offset;
2258 out:
2259     complete_pdu(s, vs->pdu, err);
2260     qemu_free(vs);
2261 }
2262
2263 static void v9fs_xattr_write(V9fsState *s, V9fsWriteState *vs)
2264 {
2265     int i, to_copy;
2266     ssize_t err = 0;
2267     int write_count;
2268     int64_t xattr_len;
2269
2270     xattr_len = vs->fidp->fs.xattr.len;
2271     write_count = xattr_len - vs->off;
2272     if (write_count > vs->count) {
2273         write_count = vs->count;
2274     } else if (write_count < 0) {
2275         /*
2276          * write beyond XATTR value len specified in
2277          * xattrcreate
2278          */
2279         err = -ENOSPC;
2280         goto out;
2281     }
2282     vs->offset += pdu_marshal(vs->pdu, vs->offset, "d", write_count);
2283     err = vs->offset;
2284     vs->fidp->fs.xattr.copied_len += write_count;
2285     /*
2286      * Now copy the content from sg list
2287      */
2288     for (i = 0; i < vs->cnt; i++) {
2289         if (write_count > vs->sg[i].iov_len) {
2290             to_copy = vs->sg[i].iov_len;
2291         } else {
2292             to_copy = write_count;
2293         }
2294         memcpy((char *)vs->fidp->fs.xattr.value + vs->off,
2295                vs->sg[i].iov_base, to_copy);
2296         /* updating vs->off since we are not using below */
2297         vs->off += to_copy;
2298         write_count -= to_copy;
2299     }
2300 out:
2301     complete_pdu(s, vs->pdu, err);
2302     qemu_free(vs);
2303 }
2304
2305 static void v9fs_write(V9fsState *s, V9fsPDU *pdu)
2306 {
2307     int32_t fid;
2308     V9fsWriteState *vs;
2309     ssize_t err;
2310
2311     vs = qemu_malloc(sizeof(*vs));
2312
2313     vs->pdu = pdu;
2314     vs->offset = 7;
2315     vs->sg = vs->iov;
2316     vs->total = 0;
2317     vs->len = 0;
2318
2319     pdu_unmarshal(vs->pdu, vs->offset, "dqdv", &fid, &vs->off, &vs->count,
2320                   vs->sg, &vs->cnt);
2321
2322     vs->fidp = lookup_fid(s, fid);
2323     if (vs->fidp == NULL) {
2324         err = -EINVAL;
2325         goto out;
2326     }
2327
2328     if (vs->fidp->fid_type == P9_FID_FILE) {
2329         if (vs->fidp->fs.fd == -1) {
2330             err = -EINVAL;
2331             goto out;
2332         }
2333     } else if (vs->fidp->fid_type == P9_FID_XATTR) {
2334         /*
2335          * setxattr operation
2336          */
2337         v9fs_xattr_write(s, vs);
2338         return;
2339     } else {
2340         err = -EINVAL;
2341         goto out;
2342     }
2343     vs->sg = cap_sg(vs->sg, vs->count, &vs->cnt);
2344     if (vs->total <= vs->count) {
2345         vs->len = v9fs_do_pwritev(s, vs->fidp->fs.fd, vs->sg, vs->cnt, vs->off);
2346         if (vs->len > 0) {
2347             vs->off += vs->len;
2348         }
2349         err = vs->len;
2350         v9fs_write_post_pwritev(s, vs, err);
2351     }
2352     return;
2353 out:
2354     complete_pdu(s, vs->pdu, err);
2355     qemu_free(vs);
2356 }
2357
2358 static void v9fs_create_post_getiounit(V9fsState *s, V9fsCreateState *vs)
2359 {
2360     int err;
2361     v9fs_string_copy(&vs->fidp->path, &vs->fullname);
2362     stat_to_qid(&vs->stbuf, &vs->qid);
2363
2364     vs->offset += pdu_marshal(vs->pdu, vs->offset, "Qd", &vs->qid, vs->iounit);
2365     err = vs->offset;
2366
2367     complete_pdu(s, vs->pdu, err);
2368     v9fs_string_free(&vs->name);
2369     v9fs_string_free(&vs->extension);
2370     v9fs_string_free(&vs->fullname);
2371     qemu_free(vs);
2372 }
2373
2374 static void v9fs_post_create(V9fsState *s, V9fsCreateState *vs, int err)
2375 {
2376     if (err == 0) {
2377         vs->iounit = get_iounit(s, &vs->fidp->path);
2378         v9fs_create_post_getiounit(s, vs);
2379         return;
2380     }
2381
2382     complete_pdu(s, vs->pdu, err);
2383     v9fs_string_free(&vs->name);
2384     v9fs_string_free(&vs->extension);
2385     v9fs_string_free(&vs->fullname);
2386     qemu_free(vs);
2387 }
2388
2389 static void v9fs_create_post_perms(V9fsState *s, V9fsCreateState *vs, int err)
2390 {
2391     if (err) {
2392         err = -errno;
2393     }
2394     v9fs_post_create(s, vs, err);
2395 }
2396
2397 static void v9fs_create_post_opendir(V9fsState *s, V9fsCreateState *vs,
2398                                                                     int err)
2399 {
2400     if (!vs->fidp->fs.dir) {
2401         err = -errno;
2402     }
2403     vs->fidp->fid_type = P9_FID_DIR;
2404     v9fs_post_create(s, vs, err);
2405 }
2406
2407 static void v9fs_create_post_dir_lstat(V9fsState *s, V9fsCreateState *vs,
2408                                                                     int err)
2409 {
2410     if (err) {
2411         err = -errno;
2412         goto out;
2413     }
2414
2415     vs->fidp->fs.dir = v9fs_do_opendir(s, &vs->fullname);
2416     v9fs_create_post_opendir(s, vs, err);
2417     return;
2418
2419 out:
2420     v9fs_post_create(s, vs, err);
2421 }
2422
2423 static void v9fs_create_post_mkdir(V9fsState *s, V9fsCreateState *vs, int err)
2424 {
2425     if (err) {
2426         err = -errno;
2427         goto out;
2428     }
2429
2430     err = v9fs_do_lstat(s, &vs->fullname, &vs->stbuf);
2431     v9fs_create_post_dir_lstat(s, vs, err);
2432     return;
2433
2434 out:
2435     v9fs_post_create(s, vs, err);
2436 }
2437
2438 static void v9fs_create_post_fstat(V9fsState *s, V9fsCreateState *vs, int err)
2439 {
2440     if (err) {
2441         vs->fidp->fid_type = P9_FID_NONE;
2442         close(vs->fidp->fs.fd);
2443         err = -errno;
2444     }
2445     v9fs_post_create(s, vs, err);
2446     return;
2447 }
2448
2449 static void v9fs_create_post_open2(V9fsState *s, V9fsCreateState *vs, int err)
2450 {
2451     if (vs->fidp->fs.fd == -1) {
2452         err = -errno;
2453         goto out;
2454     }
2455     vs->fidp->fid_type = P9_FID_FILE;
2456     err = v9fs_do_fstat(s, vs->fidp->fs.fd, &vs->stbuf);
2457     v9fs_create_post_fstat(s, vs, err);
2458
2459     return;
2460
2461 out:
2462     v9fs_post_create(s, vs, err);
2463
2464 }
2465
2466 static void v9fs_create_post_lstat(V9fsState *s, V9fsCreateState *vs, int err)
2467 {
2468
2469     if (err == 0 || errno != ENOENT) {
2470         err = -errno;
2471         goto out;
2472     }
2473
2474     if (vs->perm & P9_STAT_MODE_DIR) {
2475         err = v9fs_do_mkdir(s, vs->fullname.data, vs->perm & 0777,
2476                 vs->fidp->uid, -1);
2477         v9fs_create_post_mkdir(s, vs, err);
2478     } else if (vs->perm & P9_STAT_MODE_SYMLINK) {
2479         err = v9fs_do_symlink(s, vs->fidp, vs->extension.data,
2480                 vs->fullname.data, -1);
2481         v9fs_create_post_perms(s, vs, err);
2482     } else if (vs->perm & P9_STAT_MODE_LINK) {
2483         int32_t nfid = atoi(vs->extension.data);
2484         V9fsFidState *nfidp = lookup_fid(s, nfid);
2485         if (nfidp == NULL) {
2486             err = -errno;
2487             v9fs_post_create(s, vs, err);
2488         }
2489         err = v9fs_do_link(s, &nfidp->path, &vs->fullname);
2490         v9fs_create_post_perms(s, vs, err);
2491     } else if (vs->perm & P9_STAT_MODE_DEVICE) {
2492         char ctype;
2493         uint32_t major, minor;
2494         mode_t nmode = 0;
2495
2496         if (sscanf(vs->extension.data, "%c %u %u", &ctype, &major,
2497                                         &minor) != 3) {
2498             err = -errno;
2499             v9fs_post_create(s, vs, err);
2500         }
2501
2502         switch (ctype) {
2503         case 'c':
2504             nmode = S_IFCHR;
2505             break;
2506         case 'b':
2507             nmode = S_IFBLK;
2508             break;
2509         default:
2510             err = -EIO;
2511             v9fs_post_create(s, vs, err);
2512         }
2513
2514         nmode |= vs->perm & 0777;
2515         err = v9fs_do_mknod(s, vs->fullname.data, nmode,
2516                 makedev(major, minor), vs->fidp->uid, -1);
2517         v9fs_create_post_perms(s, vs, err);
2518     } else if (vs->perm & P9_STAT_MODE_NAMED_PIPE) {
2519         err = v9fs_do_mknod(s, vs->fullname.data, S_IFIFO | (vs->perm & 0777),
2520                 0, vs->fidp->uid, -1);
2521         v9fs_post_create(s, vs, err);
2522     } else if (vs->perm & P9_STAT_MODE_SOCKET) {
2523         err = v9fs_do_mknod(s, vs->fullname.data, S_IFSOCK | (vs->perm & 0777),
2524                 0, vs->fidp->uid, -1);
2525         v9fs_post_create(s, vs, err);
2526     } else {
2527         vs->fidp->fs.fd = v9fs_do_open2(s, vs->fullname.data, vs->fidp->uid,
2528                 -1, omode_to_uflags(vs->mode)|O_CREAT, vs->perm);
2529
2530         v9fs_create_post_open2(s, vs, err);
2531     }
2532
2533     return;
2534
2535 out:
2536     v9fs_post_create(s, vs, err);
2537 }
2538
2539 static void v9fs_create(V9fsState *s, V9fsPDU *pdu)
2540 {
2541     int32_t fid;
2542     V9fsCreateState *vs;
2543     int err = 0;
2544
2545     vs = qemu_malloc(sizeof(*vs));
2546     vs->pdu = pdu;
2547     vs->offset = 7;
2548
2549     v9fs_string_init(&vs->fullname);
2550
2551     pdu_unmarshal(vs->pdu, vs->offset, "dsdbs", &fid, &vs->name,
2552                                 &vs->perm, &vs->mode, &vs->extension);
2553
2554     vs->fidp = lookup_fid(s, fid);
2555     if (vs->fidp == NULL) {
2556         err = -EINVAL;
2557         goto out;
2558     }
2559
2560     v9fs_string_sprintf(&vs->fullname, "%s/%s", vs->fidp->path.data,
2561                                                         vs->name.data);
2562
2563     err = v9fs_do_lstat(s, &vs->fullname, &vs->stbuf);
2564     v9fs_create_post_lstat(s, vs, err);
2565     return;
2566
2567 out:
2568     complete_pdu(s, vs->pdu, err);
2569     v9fs_string_free(&vs->name);
2570     v9fs_string_free(&vs->extension);
2571     qemu_free(vs);
2572 }
2573
2574 static void v9fs_post_symlink(V9fsState *s, V9fsSymlinkState *vs, int err)
2575 {
2576     if (err == 0) {
2577         stat_to_qid(&vs->stbuf, &vs->qid);
2578         vs->offset += pdu_marshal(vs->pdu, vs->offset, "Q", &vs->qid);
2579         err = vs->offset;
2580     } else {
2581         err = -errno;
2582     }
2583     complete_pdu(s, vs->pdu, err);
2584     v9fs_string_free(&vs->name);
2585     v9fs_string_free(&vs->symname);
2586     v9fs_string_free(&vs->fullname);
2587     qemu_free(vs);
2588 }
2589
2590 static void v9fs_symlink_post_do_symlink(V9fsState *s, V9fsSymlinkState *vs,
2591         int err)
2592 {
2593     if (err) {
2594         goto out;
2595     }
2596     err = v9fs_do_lstat(s, &vs->fullname, &vs->stbuf);
2597 out:
2598     v9fs_post_symlink(s, vs, err);
2599 }
2600
2601 static void v9fs_symlink(V9fsState *s, V9fsPDU *pdu)
2602 {
2603     int32_t dfid;
2604     V9fsSymlinkState *vs;
2605     int err = 0;
2606     gid_t gid;
2607
2608     vs = qemu_malloc(sizeof(*vs));
2609     vs->pdu = pdu;
2610     vs->offset = 7;
2611
2612     v9fs_string_init(&vs->fullname);
2613
2614     pdu_unmarshal(vs->pdu, vs->offset, "dssd", &dfid, &vs->name,
2615             &vs->symname, &gid);
2616
2617     vs->dfidp = lookup_fid(s, dfid);
2618     if (vs->dfidp == NULL) {
2619         err = -EINVAL;
2620         goto out;
2621     }
2622
2623     v9fs_string_sprintf(&vs->fullname, "%s/%s", vs->dfidp->path.data,
2624             vs->name.data);
2625     err = v9fs_do_symlink(s, vs->dfidp, vs->symname.data,
2626             vs->fullname.data, gid);
2627     v9fs_symlink_post_do_symlink(s, vs, err);
2628     return;
2629
2630 out:
2631     complete_pdu(s, vs->pdu, err);
2632     v9fs_string_free(&vs->name);
2633     v9fs_string_free(&vs->symname);
2634     qemu_free(vs);
2635 }
2636
2637 static void v9fs_flush(V9fsState *s, V9fsPDU *pdu)
2638 {
2639     /* A nop call with no return */
2640     complete_pdu(s, pdu, 7);
2641 }
2642
2643 static void v9fs_link(V9fsState *s, V9fsPDU *pdu)
2644 {
2645     int32_t dfid, oldfid;
2646     V9fsFidState *dfidp, *oldfidp;
2647     V9fsString name, fullname;
2648     size_t offset = 7;
2649     int err = 0;
2650
2651     v9fs_string_init(&fullname);
2652
2653     pdu_unmarshal(pdu, offset, "dds", &dfid, &oldfid, &name);
2654
2655     dfidp = lookup_fid(s, dfid);
2656     if (dfidp == NULL) {
2657         err = -errno;
2658         goto out;
2659     }
2660
2661     oldfidp = lookup_fid(s, oldfid);
2662     if (oldfidp == NULL) {
2663         err = -errno;
2664         goto out;
2665     }
2666
2667     v9fs_string_sprintf(&fullname, "%s/%s", dfidp->path.data, name.data);
2668     err = offset;
2669     err = v9fs_do_link(s, &oldfidp->path, &fullname);
2670     if (err) {
2671         err = -errno;
2672     }
2673     v9fs_string_free(&fullname);
2674
2675 out:
2676     v9fs_string_free(&name);
2677     complete_pdu(s, pdu, err);
2678 }
2679
2680 static void v9fs_remove_post_remove(V9fsState *s, V9fsRemoveState *vs,
2681                                                                 int err)
2682 {
2683     if (err < 0) {
2684         err = -errno;
2685     } else {
2686         err = vs->offset;
2687     }
2688
2689     /* For TREMOVE we need to clunk the fid even on failed remove */
2690     free_fid(s, vs->fidp->fid);
2691
2692     complete_pdu(s, vs->pdu, err);
2693     qemu_free(vs);
2694 }
2695
2696 static void v9fs_remove(V9fsState *s, V9fsPDU *pdu)
2697 {
2698     int32_t fid;
2699     V9fsRemoveState *vs;
2700     int err = 0;
2701
2702     vs = qemu_malloc(sizeof(*vs));
2703     vs->pdu = pdu;
2704     vs->offset = 7;
2705
2706     pdu_unmarshal(vs->pdu, vs->offset, "d", &fid);
2707
2708     vs->fidp = lookup_fid(s, fid);
2709     if (vs->fidp == NULL) {
2710         err = -EINVAL;
2711         goto out;
2712     }
2713
2714     err = v9fs_do_remove(s, &vs->fidp->path);
2715     v9fs_remove_post_remove(s, vs, err);
2716     return;
2717
2718 out:
2719     complete_pdu(s, pdu, err);
2720     qemu_free(vs);
2721 }
2722
2723 static void v9fs_wstat_post_truncate(V9fsState *s, V9fsWstatState *vs, int err)
2724 {
2725     if (err < 0) {
2726         goto out;
2727     }
2728
2729     err = vs->offset;
2730
2731 out:
2732     v9fs_stat_free(&vs->v9stat);
2733     complete_pdu(s, vs->pdu, err);
2734     qemu_free(vs);
2735 }
2736
2737 static void v9fs_wstat_post_rename(V9fsState *s, V9fsWstatState *vs, int err)
2738 {
2739     if (err < 0) {
2740         goto out;
2741     }
2742     if (vs->v9stat.length != -1) {
2743         if (v9fs_do_truncate(s, &vs->fidp->path, vs->v9stat.length) < 0) {
2744             err = -errno;
2745         }
2746     }
2747     v9fs_wstat_post_truncate(s, vs, err);
2748     return;
2749
2750 out:
2751     v9fs_stat_free(&vs->v9stat);
2752     complete_pdu(s, vs->pdu, err);
2753     qemu_free(vs);
2754 }
2755
2756 static int v9fs_complete_rename(V9fsState *s, V9fsRenameState *vs)
2757 {
2758     int err = 0;
2759     char *old_name, *new_name;
2760     char *end;
2761
2762     if (vs->newdirfid != -1) {
2763         V9fsFidState *dirfidp;
2764         dirfidp = lookup_fid(s, vs->newdirfid);
2765
2766         if (dirfidp == NULL) {
2767             err = -ENOENT;
2768             goto out;
2769         }
2770
2771         BUG_ON(dirfidp->fid_type != P9_FID_NONE);
2772
2773         new_name = qemu_mallocz(dirfidp->path.size + vs->name.size + 2);
2774
2775         strcpy(new_name, dirfidp->path.data);
2776         strcat(new_name, "/");
2777         strcat(new_name + dirfidp->path.size, vs->name.data);
2778     } else {
2779         old_name = vs->fidp->path.data;
2780         end = strrchr(old_name, '/');
2781         if (end) {
2782             end++;
2783         } else {
2784             end = old_name;
2785         }
2786         new_name = qemu_mallocz(end - old_name + vs->name.size + 1);
2787
2788         strncat(new_name, old_name, end - old_name);
2789         strncat(new_name + (end - old_name), vs->name.data, vs->name.size);
2790     }
2791
2792     v9fs_string_free(&vs->name);
2793     vs->name.data = qemu_strdup(new_name);
2794     vs->name.size = strlen(new_name);
2795
2796     if (strcmp(new_name, vs->fidp->path.data) != 0) {
2797         if (v9fs_do_rename(s, &vs->fidp->path, &vs->name)) {
2798             err = -errno;
2799         } else {
2800             V9fsFidState *fidp;
2801             /*
2802             * Fixup fid's pointing to the old name to
2803             * start pointing to the new name
2804             */
2805             for (fidp = s->fid_list; fidp; fidp = fidp->next) {
2806                 if (vs->fidp == fidp) {
2807                     /*
2808                     * we replace name of this fid towards the end
2809                     * so that our below strcmp will work
2810                     */
2811                     continue;
2812                 }
2813                 if (!strncmp(vs->fidp->path.data, fidp->path.data,
2814                     strlen(vs->fidp->path.data))) {
2815                     /* replace the name */
2816                     v9fs_fix_path(&fidp->path, &vs->name,
2817                                   strlen(vs->fidp->path.data));
2818                 }
2819             }
2820             v9fs_string_copy(&vs->fidp->path, &vs->name);
2821         }
2822     }
2823 out:
2824     v9fs_string_free(&vs->name);
2825     return err;
2826 }
2827
2828 static void v9fs_rename_post_rename(V9fsState *s, V9fsRenameState *vs, int err)
2829 {
2830     complete_pdu(s, vs->pdu, err);
2831     qemu_free(vs);
2832 }
2833
2834 static void v9fs_wstat_post_chown(V9fsState *s, V9fsWstatState *vs, int err)
2835 {
2836     if (err < 0) {
2837         goto out;
2838     }
2839
2840     if (vs->v9stat.name.size != 0) {
2841         V9fsRenameState *vr;
2842
2843         vr = qemu_mallocz(sizeof(V9fsRenameState));
2844         vr->newdirfid = -1;
2845         vr->pdu = vs->pdu;
2846         vr->fidp = vs->fidp;
2847         vr->offset = vs->offset;
2848         vr->name.size = vs->v9stat.name.size;
2849         vr->name.data = qemu_strdup(vs->v9stat.name.data);
2850
2851         err = v9fs_complete_rename(s, vr);
2852         qemu_free(vr);
2853     }
2854     v9fs_wstat_post_rename(s, vs, err);
2855     return;
2856
2857 out:
2858     v9fs_stat_free(&vs->v9stat);
2859     complete_pdu(s, vs->pdu, err);
2860     qemu_free(vs);
2861 }
2862
2863 static void v9fs_rename(V9fsState *s, V9fsPDU *pdu)
2864 {
2865     int32_t fid;
2866     V9fsRenameState *vs;
2867     ssize_t err = 0;
2868
2869     vs = qemu_malloc(sizeof(*vs));
2870     vs->pdu = pdu;
2871     vs->offset = 7;
2872
2873     pdu_unmarshal(vs->pdu, vs->offset, "dds", &fid, &vs->newdirfid, &vs->name);
2874
2875     vs->fidp = lookup_fid(s, fid);
2876     if (vs->fidp == NULL) {
2877         err = -ENOENT;
2878         goto out;
2879     }
2880
2881     BUG_ON(vs->fidp->fid_type != P9_FID_NONE);
2882
2883     err = v9fs_complete_rename(s, vs);
2884     v9fs_rename_post_rename(s, vs, err);
2885     return;
2886 out:
2887     complete_pdu(s, vs->pdu, err);
2888     qemu_free(vs);
2889 }
2890
2891 static void v9fs_wstat_post_utime(V9fsState *s, V9fsWstatState *vs, int err)
2892 {
2893     if (err < 0) {
2894         goto out;
2895     }
2896
2897     if (vs->v9stat.n_gid != -1 || vs->v9stat.n_uid != -1) {
2898         if (v9fs_do_chown(s, &vs->fidp->path, vs->v9stat.n_uid,
2899                     vs->v9stat.n_gid)) {
2900             err = -errno;
2901         }
2902     }
2903     v9fs_wstat_post_chown(s, vs, err);
2904     return;
2905
2906 out:
2907     v9fs_stat_free(&vs->v9stat);
2908     complete_pdu(s, vs->pdu, err);
2909     qemu_free(vs);
2910 }
2911
2912 static void v9fs_wstat_post_chmod(V9fsState *s, V9fsWstatState *vs, int err)
2913 {
2914     if (err < 0) {
2915         goto out;
2916     }
2917
2918     if (vs->v9stat.mtime != -1 || vs->v9stat.atime != -1) {
2919         struct timespec times[2];
2920         if (vs->v9stat.atime != -1) {
2921             times[0].tv_sec = vs->v9stat.atime;
2922             times[0].tv_nsec = 0;
2923         } else {
2924             times[0].tv_nsec = UTIME_OMIT;
2925         }
2926         if (vs->v9stat.mtime != -1) {
2927             times[1].tv_sec = vs->v9stat.mtime;
2928             times[1].tv_nsec = 0;
2929         } else {
2930             times[1].tv_nsec = UTIME_OMIT;
2931         }
2932
2933         if (v9fs_do_utimensat(s, &vs->fidp->path, times)) {
2934             err = -errno;
2935         }
2936     }
2937
2938     v9fs_wstat_post_utime(s, vs, err);
2939     return;
2940
2941 out:
2942     v9fs_stat_free(&vs->v9stat);
2943     complete_pdu(s, vs->pdu, err);
2944     qemu_free(vs);
2945 }
2946
2947 static void v9fs_wstat_post_fsync(V9fsState *s, V9fsWstatState *vs, int err)
2948 {
2949     if (err == -1) {
2950         err = -errno;
2951     }
2952     v9fs_stat_free(&vs->v9stat);
2953     complete_pdu(s, vs->pdu, err);
2954     qemu_free(vs);
2955 }
2956
2957 static void v9fs_wstat_post_lstat(V9fsState *s, V9fsWstatState *vs, int err)
2958 {
2959     uint32_t v9_mode;
2960
2961     if (err == -1) {
2962         err = -errno;
2963         goto out;
2964     }
2965
2966     v9_mode = stat_to_v9mode(&vs->stbuf);
2967
2968     if ((vs->v9stat.mode & P9_STAT_MODE_TYPE_BITS) !=
2969         (v9_mode & P9_STAT_MODE_TYPE_BITS)) {
2970             /* Attempting to change the type */
2971             err = -EIO;
2972             goto out;
2973     }
2974
2975     if (v9fs_do_chmod(s, &vs->fidp->path, v9mode_to_mode(vs->v9stat.mode,
2976                     &vs->v9stat.extension))) {
2977             err = -errno;
2978      }
2979     v9fs_wstat_post_chmod(s, vs, err);
2980     return;
2981
2982 out:
2983     v9fs_stat_free(&vs->v9stat);
2984     complete_pdu(s, vs->pdu, err);
2985     qemu_free(vs);
2986 }
2987
2988 static void v9fs_wstat(V9fsState *s, V9fsPDU *pdu)
2989 {
2990     int32_t fid;
2991     V9fsWstatState *vs;
2992     int err = 0;
2993
2994     vs = qemu_malloc(sizeof(*vs));
2995     vs->pdu = pdu;
2996     vs->offset = 7;
2997
2998     pdu_unmarshal(pdu, vs->offset, "dwS", &fid, &vs->unused, &vs->v9stat);
2999
3000     vs->fidp = lookup_fid(s, fid);
3001     if (vs->fidp == NULL) {
3002         err = -EINVAL;
3003         goto out;
3004     }
3005
3006     /* do we need to sync the file? */
3007     if (donttouch_stat(&vs->v9stat)) {
3008         err = v9fs_do_fsync(s, vs->fidp->fs.fd, 0);
3009         v9fs_wstat_post_fsync(s, vs, err);
3010         return;
3011     }
3012
3013     if (vs->v9stat.mode != -1) {
3014         err = v9fs_do_lstat(s, &vs->fidp->path, &vs->stbuf);
3015         v9fs_wstat_post_lstat(s, vs, err);
3016         return;
3017     }
3018
3019     v9fs_wstat_post_chmod(s, vs, err);
3020     return;
3021
3022 out:
3023     v9fs_stat_free(&vs->v9stat);
3024     complete_pdu(s, vs->pdu, err);
3025     qemu_free(vs);
3026 }
3027
3028 static void v9fs_statfs_post_statfs(V9fsState *s, V9fsStatfsState *vs, int err)
3029 {
3030     int32_t bsize_factor;
3031
3032     if (err) {
3033         err = -errno;
3034         goto out;
3035     }
3036
3037     /*
3038      * compute bsize factor based on host file system block size
3039      * and client msize
3040      */
3041     bsize_factor = (s->msize - P9_IOHDRSZ)/vs->stbuf.f_bsize;
3042     if (!bsize_factor) {
3043         bsize_factor = 1;
3044     }
3045     vs->v9statfs.f_type = vs->stbuf.f_type;
3046     vs->v9statfs.f_bsize = vs->stbuf.f_bsize;
3047     vs->v9statfs.f_bsize *= bsize_factor;
3048     /*
3049      * f_bsize is adjusted(multiplied) by bsize factor, so we need to
3050      * adjust(divide) the number of blocks, free blocks and available
3051      * blocks by bsize factor
3052      */
3053     vs->v9statfs.f_blocks = vs->stbuf.f_blocks/bsize_factor;
3054     vs->v9statfs.f_bfree = vs->stbuf.f_bfree/bsize_factor;
3055     vs->v9statfs.f_bavail = vs->stbuf.f_bavail/bsize_factor;
3056     vs->v9statfs.f_files = vs->stbuf.f_files;
3057     vs->v9statfs.f_ffree = vs->stbuf.f_ffree;
3058     vs->v9statfs.fsid_val = (unsigned int) vs->stbuf.f_fsid.__val[0] |
3059                         (unsigned long long)vs->stbuf.f_fsid.__val[1] << 32;
3060     vs->v9statfs.f_namelen = vs->stbuf.f_namelen;
3061
3062     vs->offset += pdu_marshal(vs->pdu, vs->offset, "ddqqqqqqd",
3063          vs->v9statfs.f_type, vs->v9statfs.f_bsize, vs->v9statfs.f_blocks,
3064          vs->v9statfs.f_bfree, vs->v9statfs.f_bavail, vs->v9statfs.f_files,
3065          vs->v9statfs.f_ffree, vs->v9statfs.fsid_val,
3066          vs->v9statfs.f_namelen);
3067
3068 out:
3069     complete_pdu(s, vs->pdu, vs->offset);
3070     qemu_free(vs);
3071 }
3072
3073 static void v9fs_statfs(V9fsState *s, V9fsPDU *pdu)
3074 {
3075     V9fsStatfsState *vs;
3076     ssize_t err = 0;
3077
3078     vs = qemu_malloc(sizeof(*vs));
3079     vs->pdu = pdu;
3080     vs->offset = 7;
3081
3082     memset(&vs->v9statfs, 0, sizeof(vs->v9statfs));
3083
3084     pdu_unmarshal(vs->pdu, vs->offset, "d", &vs->fid);
3085
3086     vs->fidp = lookup_fid(s, vs->fid);
3087     if (vs->fidp == NULL) {
3088         err = -ENOENT;
3089         goto out;
3090     }
3091
3092     err = v9fs_do_statfs(s, &vs->fidp->path, &vs->stbuf);
3093     v9fs_statfs_post_statfs(s, vs, err);
3094     return;
3095
3096 out:
3097     complete_pdu(s, vs->pdu, err);
3098     qemu_free(vs);
3099 }
3100
3101 static void v9fs_mknod_post_lstat(V9fsState *s, V9fsMkState *vs, int err)
3102 {
3103     if (err == -1) {
3104         err = -errno;
3105         goto out;
3106     }
3107
3108     stat_to_qid(&vs->stbuf, &vs->qid);
3109     vs->offset += pdu_marshal(vs->pdu, vs->offset, "Q", &vs->qid);
3110     err = vs->offset;
3111 out:
3112     complete_pdu(s, vs->pdu, err);
3113     v9fs_string_free(&vs->fullname);
3114     v9fs_string_free(&vs->name);
3115     qemu_free(vs);
3116 }
3117
3118 static void v9fs_mknod_post_mknod(V9fsState *s, V9fsMkState *vs, int err)
3119 {
3120     if (err == -1) {
3121         err = -errno;
3122         goto out;
3123     }
3124
3125     err = v9fs_do_lstat(s, &vs->fullname, &vs->stbuf);
3126     v9fs_mknod_post_lstat(s, vs, err);
3127     return;
3128 out:
3129     complete_pdu(s, vs->pdu, err);
3130     v9fs_string_free(&vs->fullname);
3131     v9fs_string_free(&vs->name);
3132     qemu_free(vs);
3133 }
3134
3135 static void v9fs_mknod(V9fsState *s, V9fsPDU *pdu)
3136 {
3137     int32_t fid;
3138     V9fsMkState *vs;
3139     int err = 0;
3140     V9fsFidState *fidp;
3141     gid_t gid;
3142     int mode;
3143     int major, minor;
3144
3145     vs = qemu_malloc(sizeof(*vs));
3146     vs->pdu = pdu;
3147     vs->offset = 7;
3148
3149     v9fs_string_init(&vs->fullname);
3150     pdu_unmarshal(vs->pdu, vs->offset, "dsdddd", &fid, &vs->name, &mode,
3151         &major, &minor, &gid);
3152
3153     fidp = lookup_fid(s, fid);
3154     if (fidp == NULL) {
3155         err = -ENOENT;
3156         goto out;
3157     }
3158
3159     v9fs_string_sprintf(&vs->fullname, "%s/%s", fidp->path.data, vs->name.data);
3160     err = v9fs_do_mknod(s, vs->fullname.data, mode, makedev(major, minor),
3161         fidp->uid, gid);
3162     v9fs_mknod_post_mknod(s, vs, err);
3163     return;
3164
3165 out:
3166     complete_pdu(s, vs->pdu, err);
3167     v9fs_string_free(&vs->fullname);
3168     v9fs_string_free(&vs->name);
3169     qemu_free(vs);
3170 }
3171
3172 /*
3173  * Implement posix byte range locking code
3174  * Server side handling of locking code is very simple, because 9p server in
3175  * QEMU can handle only one client. And most of the lock handling
3176  * (like conflict, merging) etc is done by the VFS layer itself, so no need to
3177  * do any thing in * qemu 9p server side lock code path.
3178  * So when a TLOCK request comes, always return success
3179  */
3180
3181 static void v9fs_lock(V9fsState *s, V9fsPDU *pdu)
3182 {
3183     int32_t fid, err = 0;
3184     V9fsLockState *vs;
3185
3186     vs = qemu_mallocz(sizeof(*vs));
3187     vs->pdu = pdu;
3188     vs->offset = 7;
3189
3190     vs->flock = qemu_malloc(sizeof(*vs->flock));
3191     pdu_unmarshal(vs->pdu, vs->offset, "dbdqqds", &fid, &vs->flock->type,
3192                 &vs->flock->flags, &vs->flock->start, &vs->flock->length,
3193                             &vs->flock->proc_id, &vs->flock->client_id);
3194
3195     vs->status = P9_LOCK_ERROR;
3196
3197     /* We support only block flag now (that too ignored currently) */
3198     if (vs->flock->flags & ~P9_LOCK_FLAGS_BLOCK) {
3199         err = -EINVAL;
3200         goto out;
3201     }
3202     vs->fidp = lookup_fid(s, fid);
3203     if (vs->fidp == NULL) {
3204         err = -ENOENT;
3205         goto out;
3206     }
3207
3208     err = v9fs_do_fstat(s, vs->fidp->fs.fd, &vs->stbuf);
3209     if (err < 0) {
3210         err = -errno;
3211         goto out;
3212     }
3213     vs->status = P9_LOCK_SUCCESS;
3214 out:
3215     vs->offset += pdu_marshal(vs->pdu, vs->offset, "b", vs->status);
3216     complete_pdu(s, vs->pdu, err);
3217     qemu_free(vs->flock);
3218     qemu_free(vs);
3219 }
3220
3221 /*
3222  * When a TGETLOCK request comes, always return success because all lock
3223  * handling is done by client's VFS layer.
3224  */
3225
3226 static void v9fs_getlock(V9fsState *s, V9fsPDU *pdu)
3227 {
3228     int32_t fid, err = 0;
3229     V9fsGetlockState *vs;
3230
3231     vs = qemu_mallocz(sizeof(*vs));
3232     vs->pdu = pdu;
3233     vs->offset = 7;
3234
3235     vs->glock = qemu_malloc(sizeof(*vs->glock));
3236     pdu_unmarshal(vs->pdu, vs->offset, "dbqqds", &fid, &vs->glock->type,
3237                 &vs->glock->start, &vs->glock->length, &vs->glock->proc_id,
3238                 &vs->glock->client_id);
3239
3240     vs->fidp = lookup_fid(s, fid);
3241     if (vs->fidp == NULL) {
3242         err = -ENOENT;
3243         goto out;
3244     }
3245
3246     err = v9fs_do_fstat(s, vs->fidp->fs.fd, &vs->stbuf);
3247     if (err < 0) {
3248         err = -errno;
3249         goto out;
3250     }
3251     vs->glock->type = F_UNLCK;
3252     vs->offset += pdu_marshal(vs->pdu, vs->offset, "bqqds", vs->glock->type,
3253                 vs->glock->start, vs->glock->length, vs->glock->proc_id,
3254                 &vs->glock->client_id);
3255 out:
3256     complete_pdu(s, vs->pdu, err);
3257     qemu_free(vs->glock);
3258     qemu_free(vs);
3259 }
3260
3261 static void v9fs_mkdir_post_lstat(V9fsState *s, V9fsMkState *vs, int err)
3262 {
3263     if (err == -1) {
3264         err = -errno;
3265         goto out;
3266     }
3267
3268     stat_to_qid(&vs->stbuf, &vs->qid);
3269     vs->offset += pdu_marshal(vs->pdu, vs->offset, "Q", &vs->qid);
3270     err = vs->offset;
3271 out:
3272     complete_pdu(s, vs->pdu, err);
3273     v9fs_string_free(&vs->fullname);
3274     v9fs_string_free(&vs->name);
3275     qemu_free(vs);
3276 }
3277
3278 static void v9fs_mkdir_post_mkdir(V9fsState *s, V9fsMkState *vs, int err)
3279 {
3280     if (err == -1) {
3281         err = -errno;
3282         goto out;
3283     }
3284
3285     err = v9fs_do_lstat(s, &vs->fullname, &vs->stbuf);
3286     v9fs_mkdir_post_lstat(s, vs, err);
3287     return;
3288 out:
3289     complete_pdu(s, vs->pdu, err);
3290     v9fs_string_free(&vs->fullname);
3291     v9fs_string_free(&vs->name);
3292     qemu_free(vs);
3293 }
3294
3295 static void v9fs_mkdir(V9fsState *s, V9fsPDU *pdu)
3296 {
3297     int32_t fid;
3298     V9fsMkState *vs;
3299     int err = 0;
3300     V9fsFidState *fidp;
3301     gid_t gid;
3302     int mode;
3303
3304     vs = qemu_malloc(sizeof(*vs));
3305     vs->pdu = pdu;
3306     vs->offset = 7;
3307
3308     v9fs_string_init(&vs->fullname);
3309     pdu_unmarshal(vs->pdu, vs->offset, "dsdd", &fid, &vs->name, &mode,
3310         &gid);
3311
3312     fidp = lookup_fid(s, fid);
3313     if (fidp == NULL) {
3314         err = -ENOENT;
3315         goto out;
3316     }
3317
3318     v9fs_string_sprintf(&vs->fullname, "%s/%s", fidp->path.data, vs->name.data);
3319     err = v9fs_do_mkdir(s, vs->fullname.data, mode, fidp->uid, gid);
3320     v9fs_mkdir_post_mkdir(s, vs, err);
3321     return;
3322
3323 out:
3324     complete_pdu(s, vs->pdu, err);
3325     v9fs_string_free(&vs->fullname);
3326     v9fs_string_free(&vs->name);
3327     qemu_free(vs);
3328 }
3329
3330 static void v9fs_post_xattr_getvalue(V9fsState *s, V9fsXattrState *vs, int err)
3331 {
3332
3333     if (err < 0) {
3334         err = -errno;
3335         free_fid(s, vs->xattr_fidp->fid);
3336         goto out;
3337     }
3338     vs->offset += pdu_marshal(vs->pdu, vs->offset, "q", vs->size);
3339     err = vs->offset;
3340 out:
3341     complete_pdu(s, vs->pdu, err);
3342     v9fs_string_free(&vs->name);
3343     qemu_free(vs);
3344     return;
3345 }
3346
3347 static void v9fs_post_xattr_check(V9fsState *s, V9fsXattrState *vs, ssize_t err)
3348 {
3349     if (err < 0) {
3350         err = -errno;
3351         free_fid(s, vs->xattr_fidp->fid);
3352         goto out;
3353     }
3354     /*
3355      * Read the xattr value
3356      */
3357     vs->xattr_fidp->fs.xattr.len = vs->size;
3358     vs->xattr_fidp->fid_type = P9_FID_XATTR;
3359     vs->xattr_fidp->fs.xattr.copied_len = -1;
3360     if (vs->size) {
3361         vs->xattr_fidp->fs.xattr.value = qemu_malloc(vs->size);
3362         err = v9fs_do_lgetxattr(s, &vs->xattr_fidp->path,
3363                                 &vs->name, vs->xattr_fidp->fs.xattr.value,
3364                                 vs->xattr_fidp->fs.xattr.len);
3365     }
3366     v9fs_post_xattr_getvalue(s, vs, err);
3367     return;
3368 out:
3369     complete_pdu(s, vs->pdu, err);
3370     v9fs_string_free(&vs->name);
3371     qemu_free(vs);
3372 }
3373
3374 static void v9fs_post_lxattr_getvalue(V9fsState *s,
3375                                       V9fsXattrState *vs, int err)
3376 {
3377     if (err < 0) {
3378         err = -errno;
3379         free_fid(s, vs->xattr_fidp->fid);
3380         goto out;
3381     }
3382     vs->offset += pdu_marshal(vs->pdu, vs->offset, "q", vs->size);
3383     err = vs->offset;
3384 out:
3385     complete_pdu(s, vs->pdu, err);
3386     v9fs_string_free(&vs->name);
3387     qemu_free(vs);
3388     return;
3389 }
3390
3391 static void v9fs_post_lxattr_check(V9fsState *s,
3392                                    V9fsXattrState *vs, ssize_t err)
3393 {
3394     if (err < 0) {
3395         err = -errno;
3396         free_fid(s, vs->xattr_fidp->fid);
3397         goto out;
3398     }
3399     /*
3400      * Read the xattr value
3401      */
3402     vs->xattr_fidp->fs.xattr.len = vs->size;
3403     vs->xattr_fidp->fid_type = P9_FID_XATTR;
3404     vs->xattr_fidp->fs.xattr.copied_len = -1;
3405     if (vs->size) {
3406         vs->xattr_fidp->fs.xattr.value = qemu_malloc(vs->size);
3407         err = v9fs_do_llistxattr(s, &vs->xattr_fidp->path,
3408                                  vs->xattr_fidp->fs.xattr.value,
3409                                  vs->xattr_fidp->fs.xattr.len);
3410     }
3411     v9fs_post_lxattr_getvalue(s, vs, err);
3412     return;
3413 out:
3414     complete_pdu(s, vs->pdu, err);
3415     v9fs_string_free(&vs->name);
3416     qemu_free(vs);
3417 }
3418
3419 static void v9fs_xattrwalk(V9fsState *s, V9fsPDU *pdu)
3420 {
3421     ssize_t err = 0;
3422     V9fsXattrState *vs;
3423     int32_t fid, newfid;
3424
3425     vs = qemu_malloc(sizeof(*vs));
3426     vs->pdu = pdu;
3427     vs->offset = 7;
3428
3429     pdu_unmarshal(vs->pdu, vs->offset, "dds", &fid, &newfid, &vs->name);
3430     vs->file_fidp = lookup_fid(s, fid);
3431     if (vs->file_fidp == NULL) {
3432         err = -ENOENT;
3433         goto out;
3434     }
3435
3436     vs->xattr_fidp = alloc_fid(s, newfid);
3437     if (vs->xattr_fidp == NULL) {
3438         err = -EINVAL;
3439         goto out;
3440     }
3441
3442     v9fs_string_copy(&vs->xattr_fidp->path, &vs->file_fidp->path);
3443     if (vs->name.data[0] == 0) {
3444         /*
3445          * listxattr request. Get the size first
3446          */
3447         vs->size = v9fs_do_llistxattr(s, &vs->xattr_fidp->path,
3448                                       NULL, 0);
3449         if (vs->size < 0) {
3450             err = vs->size;
3451         }
3452         v9fs_post_lxattr_check(s, vs, err);
3453         return;
3454     } else {
3455         /*
3456          * specific xattr fid. We check for xattr
3457          * presence also collect the xattr size
3458          */
3459         vs->size = v9fs_do_lgetxattr(s, &vs->xattr_fidp->path,
3460                                      &vs->name, NULL, 0);
3461         if (vs->size < 0) {
3462             err = vs->size;
3463         }
3464         v9fs_post_xattr_check(s, vs, err);
3465         return;
3466     }
3467 out:
3468     complete_pdu(s, vs->pdu, err);
3469     v9fs_string_free(&vs->name);
3470     qemu_free(vs);
3471 }
3472
3473 static void v9fs_xattrcreate(V9fsState *s, V9fsPDU *pdu)
3474 {
3475     int flags;
3476     int32_t fid;
3477     ssize_t err = 0;
3478     V9fsXattrState *vs;
3479
3480     vs = qemu_malloc(sizeof(*vs));
3481     vs->pdu = pdu;
3482     vs->offset = 7;
3483
3484     pdu_unmarshal(vs->pdu, vs->offset, "dsqd",
3485                   &fid, &vs->name, &vs->size, &flags);
3486
3487     vs->file_fidp = lookup_fid(s, fid);
3488     if (vs->file_fidp == NULL) {
3489         err = -EINVAL;
3490         goto out;
3491     }
3492
3493     /* Make the file fid point to xattr */
3494     vs->xattr_fidp = vs->file_fidp;
3495     vs->xattr_fidp->fid_type = P9_FID_XATTR;
3496     vs->xattr_fidp->fs.xattr.copied_len = 0;
3497     vs->xattr_fidp->fs.xattr.len = vs->size;
3498     vs->xattr_fidp->fs.xattr.flags = flags;
3499     v9fs_string_init(&vs->xattr_fidp->fs.xattr.name);
3500     v9fs_string_copy(&vs->xattr_fidp->fs.xattr.name, &vs->name);
3501     if (vs->size)
3502         vs->xattr_fidp->fs.xattr.value = qemu_malloc(vs->size);
3503     else
3504         vs->xattr_fidp->fs.xattr.value = NULL;
3505
3506 out:
3507     complete_pdu(s, vs->pdu, err);
3508     v9fs_string_free(&vs->name);
3509     qemu_free(vs);
3510 }
3511
3512 static void v9fs_readlink_post_readlink(V9fsState *s, V9fsReadLinkState *vs,
3513                                                     int err)
3514 {
3515     if (err < 0) {
3516         err = -errno;
3517         goto out;
3518     }
3519     vs->offset += pdu_marshal(vs->pdu, vs->offset, "s", &vs->target);
3520     err = vs->offset;
3521 out:
3522     complete_pdu(s, vs->pdu, err);
3523     v9fs_string_free(&vs->target);
3524     qemu_free(vs);
3525 }
3526
3527 static void v9fs_readlink(V9fsState *s, V9fsPDU *pdu)
3528 {
3529     int32_t fid;
3530     V9fsReadLinkState *vs;
3531     int err = 0;
3532     V9fsFidState *fidp;
3533
3534     vs = qemu_malloc(sizeof(*vs));
3535     vs->pdu = pdu;
3536     vs->offset = 7;
3537
3538     pdu_unmarshal(vs->pdu, vs->offset, "d", &fid);
3539
3540     fidp = lookup_fid(s, fid);
3541     if (fidp == NULL) {
3542         err = -ENOENT;
3543         goto out;
3544     }
3545
3546     v9fs_string_init(&vs->target);
3547     err = v9fs_do_readlink(s, &fidp->path, &vs->target);
3548     v9fs_readlink_post_readlink(s, vs, err);
3549     return;
3550 out:
3551     complete_pdu(s, vs->pdu, err);
3552     qemu_free(vs);
3553 }
3554
3555 typedef void (pdu_handler_t)(V9fsState *s, V9fsPDU *pdu);
3556
3557 static pdu_handler_t *pdu_handlers[] = {
3558     [P9_TREADDIR] = v9fs_readdir,
3559     [P9_TSTATFS] = v9fs_statfs,
3560     [P9_TGETATTR] = v9fs_getattr,
3561     [P9_TSETATTR] = v9fs_setattr,
3562     [P9_TXATTRWALK] = v9fs_xattrwalk,
3563     [P9_TXATTRCREATE] = v9fs_xattrcreate,
3564     [P9_TMKNOD] = v9fs_mknod,
3565     [P9_TRENAME] = v9fs_rename,
3566     [P9_TLOCK] = v9fs_lock,
3567     [P9_TGETLOCK] = v9fs_getlock,
3568     [P9_TREADLINK] = v9fs_readlink,
3569     [P9_TMKDIR] = v9fs_mkdir,
3570     [P9_TVERSION] = v9fs_version,
3571     [P9_TLOPEN] = v9fs_open,
3572     [P9_TATTACH] = v9fs_attach,
3573     [P9_TSTAT] = v9fs_stat,
3574     [P9_TWALK] = v9fs_walk,
3575     [P9_TCLUNK] = v9fs_clunk,
3576     [P9_TFSYNC] = v9fs_fsync,
3577     [P9_TOPEN] = v9fs_open,
3578     [P9_TREAD] = v9fs_read,
3579 #if 0
3580     [P9_TAUTH] = v9fs_auth,
3581 #endif
3582     [P9_TFLUSH] = v9fs_flush,
3583     [P9_TLINK] = v9fs_link,
3584     [P9_TSYMLINK] = v9fs_symlink,
3585     [P9_TCREATE] = v9fs_create,
3586     [P9_TLCREATE] = v9fs_lcreate,
3587     [P9_TWRITE] = v9fs_write,
3588     [P9_TWSTAT] = v9fs_wstat,
3589     [P9_TREMOVE] = v9fs_remove,
3590 };
3591
3592 static void submit_pdu(V9fsState *s, V9fsPDU *pdu)
3593 {
3594     pdu_handler_t *handler;
3595
3596     if (debug_9p_pdu) {
3597         pprint_pdu(pdu);
3598     }
3599
3600     BUG_ON(pdu->id >= ARRAY_SIZE(pdu_handlers));
3601
3602     handler = pdu_handlers[pdu->id];
3603     BUG_ON(handler == NULL);
3604
3605     handler(s, pdu);
3606 }
3607
3608 static void handle_9p_output(VirtIODevice *vdev, VirtQueue *vq)
3609 {
3610     V9fsState *s = (V9fsState *)vdev;
3611     V9fsPDU *pdu;
3612     ssize_t len;
3613
3614     while ((pdu = alloc_pdu(s)) &&
3615             (len = virtqueue_pop(vq, &pdu->elem)) != 0) {
3616         uint8_t *ptr;
3617
3618         BUG_ON(pdu->elem.out_num == 0 || pdu->elem.in_num == 0);
3619         BUG_ON(pdu->elem.out_sg[0].iov_len < 7);
3620
3621         ptr = pdu->elem.out_sg[0].iov_base;
3622
3623         memcpy(&pdu->size, ptr, 4);
3624         pdu->id = ptr[4];
3625         memcpy(&pdu->tag, ptr + 5, 2);
3626
3627         submit_pdu(s, pdu);
3628     }
3629
3630     free_pdu(s, pdu);
3631 }
3632
3633 static uint32_t virtio_9p_get_features(VirtIODevice *vdev, uint32_t features)
3634 {
3635     features |= 1 << VIRTIO_9P_MOUNT_TAG;
3636     return features;
3637 }
3638
3639 static V9fsState *to_virtio_9p(VirtIODevice *vdev)
3640 {
3641     return (V9fsState *)vdev;
3642 }
3643
3644 static void virtio_9p_get_config(VirtIODevice *vdev, uint8_t *config)
3645 {
3646     struct virtio_9p_config *cfg;
3647     V9fsState *s = to_virtio_9p(vdev);
3648
3649     cfg = qemu_mallocz(sizeof(struct virtio_9p_config) +
3650                         s->tag_len);
3651     stw_raw(&cfg->tag_len, s->tag_len);
3652     memcpy(cfg->tag, s->tag, s->tag_len);
3653     memcpy(config, cfg, s->config_size);
3654     qemu_free(cfg);
3655 }
3656
3657 VirtIODevice *virtio_9p_init(DeviceState *dev, V9fsConf *conf)
3658  {
3659     V9fsState *s;
3660     int i, len;
3661     struct stat stat;
3662     FsTypeEntry *fse;
3663
3664
3665     s = (V9fsState *)virtio_common_init("virtio-9p",
3666                                     VIRTIO_ID_9P,
3667                                     sizeof(struct virtio_9p_config)+
3668                                     MAX_TAG_LEN,
3669                                     sizeof(V9fsState));
3670
3671     /* initialize pdu allocator */
3672     QLIST_INIT(&s->free_list);
3673     for (i = 0; i < (MAX_REQ - 1); i++) {
3674         QLIST_INSERT_HEAD(&s->free_list, &s->pdus[i], next);
3675     }
3676
3677     s->vq = virtio_add_queue(&s->vdev, MAX_REQ, handle_9p_output);
3678
3679     fse = get_fsdev_fsentry(conf->fsdev_id);
3680
3681     if (!fse) {
3682         /* We don't have a fsdev identified by fsdev_id */
3683         fprintf(stderr, "Virtio-9p device couldn't find fsdev with the "
3684                 "id = %s\n", conf->fsdev_id ? conf->fsdev_id : "NULL");
3685         exit(1);
3686     }
3687
3688     if (!fse->path || !conf->tag) {
3689         /* we haven't specified a mount_tag or the path */
3690         fprintf(stderr, "fsdev with id %s needs path "
3691                 "and Virtio-9p device needs mount_tag arguments\n",
3692                 conf->fsdev_id);
3693         exit(1);
3694     }
3695
3696     if (!strcmp(fse->security_model, "passthrough")) {
3697         /* Files on the Fileserver set to client user credentials */
3698         s->ctx.fs_sm = SM_PASSTHROUGH;
3699         s->ctx.xops = passthrough_xattr_ops;
3700     } else if (!strcmp(fse->security_model, "mapped")) {
3701         /* Files on the fileserver are set to QEMU credentials.
3702          * Client user credentials are saved in extended attributes.
3703          */
3704         s->ctx.fs_sm = SM_MAPPED;
3705         s->ctx.xops = mapped_xattr_ops;
3706     } else if (!strcmp(fse->security_model, "none")) {
3707         /*
3708          * Files on the fileserver are set to QEMU credentials.
3709          */
3710         s->ctx.fs_sm = SM_NONE;
3711         s->ctx.xops = none_xattr_ops;
3712     } else {
3713         fprintf(stderr, "Default to security_model=none. You may want"
3714                 " enable advanced security model using "
3715                 "security option:\n\t security_model=passthrough \n\t "
3716                 "security_model=mapped\n");
3717         s->ctx.fs_sm = SM_NONE;
3718         s->ctx.xops = none_xattr_ops;
3719     }
3720
3721     if (lstat(fse->path, &stat)) {
3722         fprintf(stderr, "share path %s does not exist\n", fse->path);
3723         exit(1);
3724     } else if (!S_ISDIR(stat.st_mode)) {
3725         fprintf(stderr, "share path %s is not a directory \n", fse->path);
3726         exit(1);
3727     }
3728
3729     s->ctx.fs_root = qemu_strdup(fse->path);
3730     len = strlen(conf->tag);
3731     if (len > MAX_TAG_LEN) {
3732         len = MAX_TAG_LEN;
3733     }
3734     /* s->tag is non-NULL terminated string */
3735     s->tag = qemu_malloc(len);
3736     memcpy(s->tag, conf->tag, len);
3737     s->tag_len = len;
3738     s->ctx.uid = -1;
3739
3740     s->ops = fse->ops;
3741     s->vdev.get_features = virtio_9p_get_features;
3742     s->config_size = sizeof(struct virtio_9p_config) +
3743                         s->tag_len;
3744     s->vdev.get_config = virtio_9p_get_config;
3745
3746     return &s->vdev;
3747 }