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