hw/virtio-9p.c

   1 /*
   2  * Virtio 9p backend
   3  *
   4  * Copyright IBM, Corp. 2010
   5  *
   6  * Authors:
   7  *  Anthony Liguori   <aliguori@us.ibm.com>
   8  *
   9  * This work is licensed under the terms of the GNU GPL, version 2.  See
  10  * the COPYING file in the top-level directory.
  11  *
  12  */
  13
  14 #include "virtio.h"
  15 #include "pc.h"
  16 #include "qemu_socket.h"
  17 #include "virtio-9p.h"
  18 #include "fsdev/qemu-fsdev.h"
  19 #include "virtio-9p-debug.h"
  20
  21 int dotu = 1;
  22 int debug_9p_pdu;
  23
  24 static int v9fs_do_lstat(V9fsState *s, V9fsString *path, struct stat *stbuf)
  25 {
  26     return s->ops->lstat(&s->ctx, path->data, stbuf);
  27 }
  28
  29 static int v9fs_do_setuid(V9fsState *s, uid_t uid)
  30 {
  31     return s->ops->setuid(&s->ctx, uid);
  32 }
  33
  34 static ssize_t v9fs_do_readlink(V9fsState *s, V9fsString *path, V9fsString *buf)
  35 {
  36     ssize_t len;
  37
  38     buf->data = qemu_malloc(1024);
  39
  40     len = s->ops->readlink(&s->ctx, path->data, buf->data, 1024 - 1);
  41     if (len > -1) {
  42         buf->size = len;
  43         buf->data[len] = 0;
  44     }
  45
  46     return len;
  47 }
  48
  49 static int v9fs_do_close(V9fsState *s, int fd)
  50 {
  51     return s->ops->close(&s->ctx, fd);
  52 }
  53
  54 static int v9fs_do_closedir(V9fsState *s, DIR *dir)
  55 {
  56     return s->ops->closedir(&s->ctx, dir);
  57 }
  58
  59 static int v9fs_do_open(V9fsState *s, V9fsString *path, int flags)
  60 {
  61     return s->ops->open(&s->ctx, path->data, flags);
  62 }
  63
  64 static DIR *v9fs_do_opendir(V9fsState *s, V9fsString *path)
  65 {
  66     return s->ops->opendir(&s->ctx, path->data);
  67 }
  68
  69 static void v9fs_do_rewinddir(V9fsState *s, DIR *dir)
  70 {
  71     return s->ops->rewinddir(&s->ctx, dir);
  72 }
  73
  74 static off_t v9fs_do_telldir(V9fsState *s, DIR *dir)
  75 {
  76     return s->ops->telldir(&s->ctx, dir);
  77 }
  78
  79 static struct dirent *v9fs_do_readdir(V9fsState *s, DIR *dir)
  80 {
  81     return s->ops->readdir(&s->ctx, dir);
  82 }
  83
  84 static void v9fs_do_seekdir(V9fsState *s, DIR *dir, off_t off)
  85 {
  86     return s->ops->seekdir(&s->ctx, dir, off);
  87 }
  88
  89 static int v9fs_do_readv(V9fsState *s, int fd, const struct iovec *iov,
  90                             int iovcnt)
  91 {
  92     return s->ops->readv(&s->ctx, fd, iov, iovcnt);
  93 }
  94
  95 static off_t v9fs_do_lseek(V9fsState *s, int fd, off_t offset, int whence)
  96 {
  97     return s->ops->lseek(&s->ctx, fd, offset, whence);
  98 }
  99
 100 static int v9fs_do_writev(V9fsState *s, int fd, const struct iovec *iov,
 101                        int iovcnt)
 102 {
 103     return s->ops->writev(&s->ctx, fd, iov, iovcnt);
 104 }
 105
 106 static int v9fs_do_chmod(V9fsState *s, V9fsString *path, mode_t mode)
 107 {
 108     return s->ops->chmod(&s->ctx, path->data, mode);
 109 }
 110
 111 static int v9fs_do_mknod(V9fsState *s, V9fsString *path, mode_t mode, dev_t dev)
 112 {
 113     return s->ops->mknod(&s->ctx, path->data, mode, dev);
 114 }
 115
 116 static int v9fs_do_mksock(V9fsState *s, V9fsString *path)
 117 {
 118     return s->ops->mksock(&s->ctx, path->data);
 119 }
 120
 121 static int v9fs_do_mkdir(V9fsState *s, V9fsString *path, mode_t mode)
 122 {
 123     return s->ops->mkdir(&s->ctx, path->data, mode);
 124 }
 125
 126 static int v9fs_do_fstat(V9fsState *s, int fd, struct stat *stbuf)
 127 {
 128     return s->ops->fstat(&s->ctx, fd, stbuf);
 129 }
 130
 131 static int v9fs_do_open2(V9fsState *s, V9fsString *path, int flags, mode_t mode)
 132 {
 133     return s->ops->open2(&s->ctx, path->data, flags, mode);
 134 }
 135
 136 static int v9fs_do_symlink(V9fsState *s, V9fsString *oldpath,
 137                             V9fsString *newpath)
 138 {
 139     return s->ops->symlink(&s->ctx, oldpath->data, newpath->data);
 140 }
 141
 142 static int v9fs_do_link(V9fsState *s, V9fsString *oldpath, V9fsString *newpath)
 143 {
 144     return s->ops->link(&s->ctx, oldpath->data, newpath->data);
 145 }
 146
 147 static int v9fs_do_truncate(V9fsState *s, V9fsString *path, off_t size)
 148 {
 149     return s->ops->truncate(&s->ctx, path->data, size);
 150 }
 151
 152 static int v9fs_do_rename(V9fsState *s, V9fsString *oldpath,
 153                             V9fsString *newpath)
 154 {
 155     return s->ops->rename(&s->ctx, oldpath->data, newpath->data);
 156 }
 157
 158 static int v9fs_do_chown(V9fsState *s, V9fsString *path, uid_t uid, gid_t gid)
 159 {
 160     return s->ops->chown(&s->ctx, path->data, uid, gid);
 161 }
 162
 163 static int v9fs_do_utime(V9fsState *s, V9fsString *path,
 164                             const struct utimbuf *buf)
 165 {
 166     return s->ops->utime(&s->ctx, path->data, buf);
 167 }
 168
 169 static int v9fs_do_fsync(V9fsState *s, int fd)
 170 {
 171     return s->ops->fsync(&s->ctx, fd);
 172 }
 173
 174 static void v9fs_string_init(V9fsString *str)
 175 {
 176     str->data = NULL;
 177     str->size = 0;
 178 }
 179
 180 static void v9fs_string_free(V9fsString *str)
 181 {
 182     qemu_free(str->data);
 183     str->data = NULL;
 184     str->size = 0;
 185 }
 186
 187 static void v9fs_string_null(V9fsString *str)
 188 {
 189     v9fs_string_free(str);
 190 }
 191
 192 static int number_to_string(void *arg, char type)
 193 {
 194     unsigned int ret = 0;
 195
 196     switch (type) {
 197     case 'u': {
 198         unsigned int num = *(unsigned int *)arg;
 199
 200         do {
 201             ret++;
 202             num = num/10;
 203         } while (num);
 204         break;
 205     }
 206     default:
 207         printf("Number_to_string: Unknown number format\n");
 208         return -1;
 209     }
 210
 211     return ret;
 212 }
 213
 214 static int v9fs_string_alloc_printf(char **strp, const char *fmt, va_list ap)
 215 {
 216     va_list ap2;
 217     char *iter = (char *)fmt;
 218     int len = 0;
 219     int nr_args = 0;
 220     char *arg_char_ptr;
 221     unsigned int arg_uint;
 222
 223     /* Find the number of %'s that denotes an argument */
 224     for (iter = strstr(iter, "%"); iter; iter = strstr(iter, "%")) {
 225         nr_args++;
 226         iter++;
 227     }
 228
 229     len = strlen(fmt) - 2*nr_args;
 230
 231     if (!nr_args) {
 232         goto alloc_print;
 233     }
 234
 235     va_copy(ap2, ap);
 236
 237     iter = (char *)fmt;
 238
 239     /* Now parse the format string */
 240     for (iter = strstr(iter, "%"); iter; iter = strstr(iter, "%")) {
 241         iter++;
 242         switch (*iter) {
 243         case 'u':
 244             arg_uint = va_arg(ap2, unsigned int);
 245             len += number_to_string((void *)&arg_uint, 'u');
 246             break;
 247         case 's':
 248             arg_char_ptr = va_arg(ap2, char *);
 249             len += strlen(arg_char_ptr);
 250             break;
 251         case 'c':
 252             len += 1;
 253             break;
 254         default:
 255             fprintf(stderr,
 256                     "v9fs_string_alloc_printf:Incorrect format %c", *iter);
 257             return -1;
 258         }
 259         iter++;
 260     }
 261
 262 alloc_print:
 263     *strp = qemu_malloc((len + 1) * sizeof(**strp));
 264
 265     return vsprintf(*strp, fmt, ap);
 266 }
 267
 268 static void v9fs_string_sprintf(V9fsString *str, const char *fmt, ...)
 269 {
 270     va_list ap;
 271     int err;
 272
 273     v9fs_string_free(str);
 274
 275     va_start(ap, fmt);
 276     err = v9fs_string_alloc_printf(&str->data, fmt, ap);
 277     BUG_ON(err == -1);
 278     va_end(ap);
 279
 280     str->size = err;
 281 }
 282
 283 static void v9fs_string_copy(V9fsString *lhs, V9fsString *rhs)
 284 {
 285     v9fs_string_free(lhs);
 286     v9fs_string_sprintf(lhs, "%s", rhs->data);
 287 }
 288
 289 static size_t v9fs_string_size(V9fsString *str)
 290 {
 291     return str->size;
 292 }
 293
 294 static V9fsFidState *lookup_fid(V9fsState *s, int32_t fid)
 295 {
 296     V9fsFidState *f;
 297
 298     for (f = s->fid_list; f; f = f->next) {
 299         if (f->fid == fid) {
 300             v9fs_do_setuid(s, f->uid);
 301             return f;
 302         }
 303     }
 304
 305     return NULL;
 306 }
 307
 308 static V9fsFidState *alloc_fid(V9fsState *s, int32_t fid)
 309 {
 310     V9fsFidState *f;
 311
 312     f = lookup_fid(s, fid);
 313     if (f) {
 314         return NULL;
 315     }
 316
 317     f = qemu_mallocz(sizeof(V9fsFidState));
 318
 319     f->fid = fid;
 320     f->fd = -1;
 321     f->dir = NULL;
 322
 323     f->next = s->fid_list;
 324     s->fid_list = f;
 325
 326     return f;
 327 }
 328
 329 static int free_fid(V9fsState *s, int32_t fid)
 330 {
 331     V9fsFidState **fidpp, *fidp;
 332
 333     for (fidpp = &s->fid_list; *fidpp; fidpp = &(*fidpp)->next) {
 334         if ((*fidpp)->fid == fid) {
 335             break;
 336         }
 337     }
 338
 339     if (*fidpp == NULL) {
 340         return -ENOENT;
 341     }
 342
 343     fidp = *fidpp;
 344     *fidpp = fidp->next;
 345
 346     if (fidp->fd != -1) {
 347         v9fs_do_close(s, fidp->fd);
 348     }
 349     if (fidp->dir) {
 350         v9fs_do_closedir(s, fidp->dir);
 351     }
 352     v9fs_string_free(&fidp->path);
 353     qemu_free(fidp);
 354
 355     return 0;
 356 }
 357
 358 #define P9_QID_TYPE_DIR         0x80
 359 #define P9_QID_TYPE_SYMLINK     0x02
 360
 361 #define P9_STAT_MODE_DIR        0x80000000
 362 #define P9_STAT_MODE_APPEND     0x40000000
 363 #define P9_STAT_MODE_EXCL       0x20000000
 364 #define P9_STAT_MODE_MOUNT      0x10000000
 365 #define P9_STAT_MODE_AUTH       0x08000000
 366 #define P9_STAT_MODE_TMP        0x04000000
 367 #define P9_STAT_MODE_SYMLINK    0x02000000
 368 #define P9_STAT_MODE_LINK       0x01000000
 369 #define P9_STAT_MODE_DEVICE     0x00800000
 370 #define P9_STAT_MODE_NAMED_PIPE 0x00200000
 371 #define P9_STAT_MODE_SOCKET     0x00100000
 372 #define P9_STAT_MODE_SETUID     0x00080000
 373 #define P9_STAT_MODE_SETGID     0x00040000
 374 #define P9_STAT_MODE_SETVTX     0x00010000
 375
 376 #define P9_STAT_MODE_TYPE_BITS (P9_STAT_MODE_DIR |          \
 377                                 P9_STAT_MODE_SYMLINK |      \
 378                                 P9_STAT_MODE_LINK |         \
 379                                 P9_STAT_MODE_DEVICE |       \
 380                                 P9_STAT_MODE_NAMED_PIPE |   \
 381                                 P9_STAT_MODE_SOCKET)
 382
 383 /* This is the algorithm from ufs in spfs */
 384 static void stat_to_qid(const struct stat *stbuf, V9fsQID *qidp)
 385 {
 386     size_t size;
 387
 388     size = MIN(sizeof(stbuf->st_ino), sizeof(qidp->path));
 389     memcpy(&qidp->path, &stbuf->st_ino, size);
 390     qidp->version = stbuf->st_mtime ^ (stbuf->st_size << 8);
 391     qidp->type = 0;
 392     if (S_ISDIR(stbuf->st_mode)) {
 393         qidp->type |= P9_QID_TYPE_DIR;
 394     }
 395     if (S_ISLNK(stbuf->st_mode)) {
 396         qidp->type |= P9_QID_TYPE_SYMLINK;
 397     }
 398 }
 399
 400 static int fid_to_qid(V9fsState *s, V9fsFidState *fidp, V9fsQID *qidp)
 401 {
 402     struct stat stbuf;
 403     int err;
 404
 405     err = v9fs_do_lstat(s, &fidp->path, &stbuf);
 406     if (err) {
 407         return err;
 408     }
 409
 410     stat_to_qid(&stbuf, qidp);
 411     return 0;
 412 }
 413
 414 static V9fsPDU *alloc_pdu(V9fsState *s)
 415 {
 416     V9fsPDU *pdu = NULL;
 417
 418     if (!QLIST_EMPTY(&s->free_list)) {
 419         pdu = QLIST_FIRST(&s->free_list);
 420         QLIST_REMOVE(pdu, next);
 421     }
 422     return pdu;
 423 }
 424
 425 static void free_pdu(V9fsState *s, V9fsPDU *pdu)
 426 {
 427     if (pdu) {
 428         QLIST_INSERT_HEAD(&s->free_list, pdu, next);
 429     }
 430 }
 431
 432 size_t pdu_packunpack(void *addr, struct iovec *sg, int sg_count,
 433                         size_t offset, size_t size, int pack)
 434 {
 435     int i = 0;
 436     size_t copied = 0;
 437
 438     for (i = 0; size && i < sg_count; i++) {
 439         size_t len;
 440         if (offset >= sg[i].iov_len) {
 441             /* skip this sg */
 442             offset -= sg[i].iov_len;
 443             continue;
 444         } else {
 445             len = MIN(sg[i].iov_len - offset, size);
 446             if (pack) {
 447                 memcpy(sg[i].iov_base + offset, addr, len);
 448             } else {
 449                 memcpy(addr, sg[i].iov_base + offset, len);
 450             }
 451             size -= len;
 452             copied += len;
 453             addr += len;
 454             if (size) {
 455                 offset = 0;
 456                 continue;
 457             }
 458         }
 459     }
 460
 461     return copied;
 462 }
 463
 464 static size_t pdu_unpack(void *dst, V9fsPDU *pdu, size_t offset, size_t size)
 465 {
 466     return pdu_packunpack(dst, pdu->elem.out_sg, pdu->elem.out_num,
 467                          offset, size, 0);
 468 }
 469
 470 static size_t pdu_pack(V9fsPDU *pdu, size_t offset, const void *src,
 471                         size_t size)
 472 {
 473     return pdu_packunpack((void *)src, pdu->elem.in_sg, pdu->elem.in_num,
 474                              offset, size, 1);
 475 }
 476
 477 static int pdu_copy_sg(V9fsPDU *pdu, size_t offset, int rx, struct iovec *sg)
 478 {
 479     size_t pos = 0;
 480     int i, j;
 481     struct iovec *src_sg;
 482     unsigned int num;
 483
 484     if (rx) {
 485         src_sg = pdu->elem.in_sg;
 486         num = pdu->elem.in_num;
 487     } else {
 488         src_sg = pdu->elem.out_sg;
 489         num = pdu->elem.out_num;
 490     }
 491
 492     j = 0;
 493     for (i = 0; i < num; i++) {
 494         if (offset <= pos) {
 495             sg[j].iov_base = src_sg[i].iov_base;
 496             sg[j].iov_len = src_sg[i].iov_len;
 497             j++;
 498         } else if (offset < (src_sg[i].iov_len + pos)) {
 499             sg[j].iov_base = src_sg[i].iov_base;
 500             sg[j].iov_len = src_sg[i].iov_len;
 501             sg[j].iov_base += (offset - pos);
 502             sg[j].iov_len -= (offset - pos);
 503             j++;
 504         }
 505         pos += src_sg[i].iov_len;
 506     }
 507
 508     return j;
 509 }
 510
 511 static size_t pdu_unmarshal(V9fsPDU *pdu, size_t offset, const char *fmt, ...)
 512 {
 513     size_t old_offset = offset;
 514     va_list ap;
 515     int i;
 516
 517     va_start(ap, fmt);
 518     for (i = 0; fmt[i]; i++) {
 519         switch (fmt[i]) {
 520         case 'b': {
 521             uint8_t *valp = va_arg(ap, uint8_t *);
 522             offset += pdu_unpack(valp, pdu, offset, sizeof(*valp));
 523             break;
 524         }
 525         case 'w': {
 526             uint16_t val, *valp;
 527             valp = va_arg(ap, uint16_t *);
 528             val = le16_to_cpupu(valp);
 529             offset += pdu_unpack(&val, pdu, offset, sizeof(val));
 530             *valp = val;
 531             break;
 532         }
 533         case 'd': {
 534             uint32_t val, *valp;
 535             valp = va_arg(ap, uint32_t *);
 536             val = le32_to_cpupu(valp);
 537             offset += pdu_unpack(&val, pdu, offset, sizeof(val));
 538             *valp = val;
 539             break;
 540         }
 541         case 'q': {
 542             uint64_t val, *valp;
 543             valp = va_arg(ap, uint64_t *);
 544             val = le64_to_cpup(valp);
 545             offset += pdu_unpack(&val, pdu, offset, sizeof(val));
 546             *valp = val;
 547             break;
 548         }
 549         case 'v': {
 550             struct iovec *iov = va_arg(ap, struct iovec *);
 551             int *iovcnt = va_arg(ap, int *);
 552             *iovcnt = pdu_copy_sg(pdu, offset, 0, iov);
 553             break;
 554         }
 555         case 's': {
 556             V9fsString *str = va_arg(ap, V9fsString *);
 557             offset += pdu_unmarshal(pdu, offset, "w", &str->size);
 558             /* FIXME: sanity check str->size */
 559             str->data = qemu_malloc(str->size + 1);
 560             offset += pdu_unpack(str->data, pdu, offset, str->size);
 561             str->data[str->size] = 0;
 562             break;
 563         }
 564         case 'Q': {
 565             V9fsQID *qidp = va_arg(ap, V9fsQID *);
 566             offset += pdu_unmarshal(pdu, offset, "bdq",
 567                         &qidp->type, &qidp->version, &qidp->path);
 568             break;
 569         }
 570         case 'S': {
 571             V9fsStat *statp = va_arg(ap, V9fsStat *);
 572             offset += pdu_unmarshal(pdu, offset, "wwdQdddqsssssddd",
 573                         &statp->size, &statp->type, &statp->dev,
 574                         &statp->qid, &statp->mode, &statp->atime,
 575                         &statp->mtime, &statp->length,
 576                         &statp->name, &statp->uid, &statp->gid,
 577                         &statp->muid, &statp->extension,
 578                         &statp->n_uid, &statp->n_gid,
 579                         &statp->n_muid);
 580             break;
 581         }
 582         default:
 583             break;
 584         }
 585     }
 586
 587     va_end(ap);
 588
 589     return offset - old_offset;
 590 }
 591
 592 static size_t pdu_marshal(V9fsPDU *pdu, size_t offset, const char *fmt, ...)
 593 {
 594     size_t old_offset = offset;
 595     va_list ap;
 596     int i;
 597
 598     va_start(ap, fmt);
 599     for (i = 0; fmt[i]; i++) {
 600         switch (fmt[i]) {
 601         case 'b': {
 602             uint8_t val = va_arg(ap, int);
 603             offset += pdu_pack(pdu, offset, &val, sizeof(val));
 604             break;
 605         }
 606         case 'w': {
 607             uint16_t val;
 608             cpu_to_le16w(&val, va_arg(ap, int));
 609             offset += pdu_pack(pdu, offset, &val, sizeof(val));
 610             break;
 611         }
 612         case 'd': {
 613             uint32_t val;
 614             cpu_to_le32w(&val, va_arg(ap, uint32_t));
 615             offset += pdu_pack(pdu, offset, &val, sizeof(val));
 616             break;
 617         }
 618         case 'q': {
 619             uint64_t val;
 620             cpu_to_le64w(&val, va_arg(ap, uint64_t));
 621             offset += pdu_pack(pdu, offset, &val, sizeof(val));
 622             break;
 623         }
 624         case 'v': {
 625             struct iovec *iov = va_arg(ap, struct iovec *);
 626             int *iovcnt = va_arg(ap, int *);
 627             *iovcnt = pdu_copy_sg(pdu, offset, 1, iov);
 628             break;
 629         }
 630         case 's': {
 631             V9fsString *str = va_arg(ap, V9fsString *);
 632             offset += pdu_marshal(pdu, offset, "w", str->size);
 633             offset += pdu_pack(pdu, offset, str->data, str->size);
 634             break;
 635         }
 636         case 'Q': {
 637             V9fsQID *qidp = va_arg(ap, V9fsQID *);
 638             offset += pdu_marshal(pdu, offset, "bdq",
 639                         qidp->type, qidp->version, qidp->path);
 640             break;
 641         }
 642         case 'S': {
 643             V9fsStat *statp = va_arg(ap, V9fsStat *);
 644             offset += pdu_marshal(pdu, offset, "wwdQdddqsssssddd",
 645                         statp->size, statp->type, statp->dev,
 646                         &statp->qid, statp->mode, statp->atime,
 647                         statp->mtime, statp->length, &statp->name,
 648                         &statp->uid, &statp->gid, &statp->muid,
 649                         &statp->extension, statp->n_uid,
 650                         statp->n_gid, statp->n_muid);
 651             break;
 652         }
 653         default:
 654             break;
 655         }
 656     }
 657     va_end(ap);
 658
 659     return offset - old_offset;
 660 }
 661
 662 static void complete_pdu(V9fsState *s, V9fsPDU *pdu, ssize_t len)
 663 {
 664     int8_t id = pdu->id + 1; /* Response */
 665
 666     if (len < 0) {
 667         V9fsString str;
 668         int err = -len;
 669
 670         str.data = strerror(err);
 671         str.size = strlen(str.data);
 672
 673         len = 7;
 674         len += pdu_marshal(pdu, len, "s", &str);
 675         if (dotu) {
 676             len += pdu_marshal(pdu, len, "d", err);
 677         }
 678
 679         id = P9_RERROR;
 680     }
 681
 682     /* fill out the header */
 683     pdu_marshal(pdu, 0, "dbw", (int32_t)len, id, pdu->tag);
 684
 685     /* keep these in sync */
 686     pdu->size = len;
 687     pdu->id = id;
 688
 689     /* push onto queue and notify */
 690     virtqueue_push(s->vq, &pdu->elem, len);
 691
 692     /* FIXME: we should batch these completions */
 693     virtio_notify(&s->vdev, s->vq);
 694
 695     free_pdu(s, pdu);
 696 }
 697
 698 static mode_t v9mode_to_mode(uint32_t mode, V9fsString *extension)
 699 {
 700     mode_t ret;
 701
 702     ret = mode & 0777;
 703     if (mode & P9_STAT_MODE_DIR) {
 704         ret |= S_IFDIR;
 705     }
 706
 707     if (dotu) {
 708         if (mode & P9_STAT_MODE_SYMLINK) {
 709             ret |= S_IFLNK;
 710         }
 711         if (mode & P9_STAT_MODE_SOCKET) {
 712             ret |= S_IFSOCK;
 713         }
 714         if (mode & P9_STAT_MODE_NAMED_PIPE) {
 715             ret |= S_IFIFO;
 716         }
 717         if (mode & P9_STAT_MODE_DEVICE) {
 718             if (extension && extension->data[0] == 'c') {
 719                 ret |= S_IFCHR;
 720             } else {
 721                 ret |= S_IFBLK;
 722             }
 723         }
 724     }
 725
 726     if (!(ret&~0777)) {
 727         ret |= S_IFREG;
 728     }
 729
 730     if (mode & P9_STAT_MODE_SETUID) {
 731         ret |= S_ISUID;
 732     }
 733     if (mode & P9_STAT_MODE_SETGID) {
 734         ret |= S_ISGID;
 735     }
 736     if (mode & P9_STAT_MODE_SETVTX) {
 737         ret |= S_ISVTX;
 738     }
 739
 740     return ret;
 741 }
 742
 743 static int donttouch_stat(V9fsStat *stat)
 744 {
 745     if (stat->type == -1 &&
 746         stat->dev == -1 &&
 747         stat->qid.type == -1 &&
 748         stat->qid.version == -1 &&
 749         stat->qid.path == -1 &&
 750         stat->mode == -1 &&
 751         stat->atime == -1 &&
 752         stat->mtime == -1 &&
 753         stat->length == -1 &&
 754         !stat->name.size &&
 755         !stat->uid.size &&
 756         !stat->gid.size &&
 757         !stat->muid.size &&
 758         stat->n_uid == -1 &&
 759         stat->n_gid == -1 &&
 760         stat->n_muid == -1) {
 761         return 1;
 762     }
 763
 764     return 0;
 765 }
 766
 767 static void v9fs_stat_free(V9fsStat *stat)
 768 {
 769     v9fs_string_free(&stat->name);
 770     v9fs_string_free(&stat->uid);
 771     v9fs_string_free(&stat->gid);
 772     v9fs_string_free(&stat->muid);
 773     v9fs_string_free(&stat->extension);
 774 }
 775
 776 static uint32_t stat_to_v9mode(const struct stat *stbuf)
 777 {
 778     uint32_t mode;
 779
 780     mode = stbuf->st_mode & 0777;
 781     if (S_ISDIR(stbuf->st_mode)) {
 782         mode |= P9_STAT_MODE_DIR;
 783     }
 784
 785     if (dotu) {
 786         if (S_ISLNK(stbuf->st_mode)) {
 787             mode |= P9_STAT_MODE_SYMLINK;
 788         }
 789
 790         if (S_ISSOCK(stbuf->st_mode)) {
 791             mode |= P9_STAT_MODE_SOCKET;
 792         }
 793
 794         if (S_ISFIFO(stbuf->st_mode)) {
 795             mode |= P9_STAT_MODE_NAMED_PIPE;
 796         }
 797
 798         if (S_ISBLK(stbuf->st_mode) || S_ISCHR(stbuf->st_mode)) {
 799             mode |= P9_STAT_MODE_DEVICE;
 800         }
 801
 802         if (stbuf->st_mode & S_ISUID) {
 803             mode |= P9_STAT_MODE_SETUID;
 804         }
 805
 806         if (stbuf->st_mode & S_ISGID) {
 807             mode |= P9_STAT_MODE_SETGID;
 808         }
 809
 810         if (stbuf->st_mode & S_ISVTX) {
 811             mode |= P9_STAT_MODE_SETVTX;
 812         }
 813     }
 814
 815     return mode;
 816 }
 817
 818 static int stat_to_v9stat(V9fsState *s, V9fsString *name,
 819                             const struct stat *stbuf,
 820                             V9fsStat *v9stat)
 821 {
 822     int err;
 823     const char *str;
 824
 825     memset(v9stat, 0, sizeof(*v9stat));
 826
 827     stat_to_qid(stbuf, &v9stat->qid);
 828     v9stat->mode = stat_to_v9mode(stbuf);
 829     v9stat->atime = stbuf->st_atime;
 830     v9stat->mtime = stbuf->st_mtime;
 831     v9stat->length = stbuf->st_size;
 832
 833     v9fs_string_null(&v9stat->uid);
 834     v9fs_string_null(&v9stat->gid);
 835     v9fs_string_null(&v9stat->muid);
 836
 837     if (dotu) {
 838         v9stat->n_uid = stbuf->st_uid;
 839         v9stat->n_gid = stbuf->st_gid;
 840         v9stat->n_muid = 0;
 841
 842         v9fs_string_null(&v9stat->extension);
 843
 844         if (v9stat->mode & P9_STAT_MODE_SYMLINK) {
 845             err = v9fs_do_readlink(s, name, &v9stat->extension);
 846             if (err == -1) {
 847                 err = -errno;
 848                 return err;
 849             }
 850             v9stat->extension.data[err] = 0;
 851             v9stat->extension.size = err;
 852         } else if (v9stat->mode & P9_STAT_MODE_DEVICE) {
 853             v9fs_string_sprintf(&v9stat->extension, "%c %u %u",
 854                     S_ISCHR(stbuf->st_mode) ? 'c' : 'b',
 855                     major(stbuf->st_rdev), minor(stbuf->st_rdev));
 856         } else if (S_ISDIR(stbuf->st_mode) || S_ISREG(stbuf->st_mode)) {
 857             v9fs_string_sprintf(&v9stat->extension, "%s %u",
 858                     "HARDLINKCOUNT", stbuf->st_nlink);
 859         }
 860     }
 861
 862     str = strrchr(name->data, '/');
 863     if (str) {
 864         str += 1;
 865     } else {
 866         str = name->data;
 867     }
 868
 869     v9fs_string_sprintf(&v9stat->name, "%s", str);
 870
 871     v9stat->size = 61 +
 872         v9fs_string_size(&v9stat->name) +
 873         v9fs_string_size(&v9stat->uid) +
 874         v9fs_string_size(&v9stat->gid) +
 875         v9fs_string_size(&v9stat->muid) +
 876         v9fs_string_size(&v9stat->extension);
 877     return 0;
 878 }
 879
 880 static struct iovec *adjust_sg(struct iovec *sg, int len, int *iovcnt)
 881 {
 882     while (len && *iovcnt) {
 883         if (len < sg->iov_len) {
 884             sg->iov_len -= len;
 885             sg->iov_base += len;
 886             len = 0;
 887         } else {
 888             len -= sg->iov_len;
 889             sg++;
 890             *iovcnt -= 1;
 891         }
 892     }
 893
 894     return sg;
 895 }
 896
 897 static struct iovec *cap_sg(struct iovec *sg, int cap, int *cnt)
 898 {
 899     int i;
 900     int total = 0;
 901
 902     for (i = 0; i < *cnt; i++) {
 903         if ((total + sg[i].iov_len) > cap) {
 904             sg[i].iov_len -= ((total + sg[i].iov_len) - cap);
 905             i++;
 906             break;
 907         }
 908         total += sg[i].iov_len;
 909     }
 910
 911     *cnt = i;
 912
 913     return sg;
 914 }
 915
 916 static void print_sg(struct iovec *sg, int cnt)
 917 {
 918     int i;
 919
 920     printf("sg[%d]: {", cnt);
 921     for (i = 0; i < cnt; i++) {
 922         if (i) {
 923             printf(", ");
 924         }
 925         printf("(%p, %zd)", sg[i].iov_base, sg[i].iov_len);
 926     }
 927     printf("}\n");
 928 }
 929
 930 static void v9fs_dummy(V9fsState *s, V9fsPDU *pdu)
 931 {
 932     /* Note: The following have been added to prevent GCC from complaining
 933      * They will be removed in the subsequent patches */
 934     (void)pdu_unmarshal;
 935     (void) complete_pdu;
 936     (void) v9fs_string_init;
 937     (void) v9fs_string_free;
 938     (void) v9fs_string_null;
 939     (void) v9fs_string_sprintf;
 940     (void) v9fs_string_copy;
 941     (void) v9fs_string_size;
 942     (void) v9fs_do_lstat;
 943     (void) v9fs_do_setuid;
 944     (void) v9fs_do_readlink;
 945     (void) v9fs_do_close;
 946     (void) v9fs_do_closedir;
 947     (void) alloc_fid;
 948     (void) free_fid;
 949     (void) fid_to_qid;
 950     (void) v9mode_to_mode;
 951     (void) donttouch_stat;
 952     (void) v9fs_stat_free;
 953     (void) stat_to_v9stat;
 954     (void) adjust_sg;
 955     (void) cap_sg;
 956     (void) print_sg;
 957 }
 958
 959 static void v9fs_fix_path(V9fsString *dst, V9fsString *src, int len)
 960 {
 961     V9fsString str;
 962     v9fs_string_init(&str);
 963     v9fs_string_copy(&str, dst);
 964     v9fs_string_sprintf(dst, "%s%s", src->data, str.data+len);
 965     v9fs_string_free(&str);
 966 }
 967
 968 static void v9fs_version(V9fsState *s, V9fsPDU *pdu)
 969 {
 970     int32_t msize;
 971     V9fsString version;
 972     size_t offset = 7;
 973
 974     pdu_unmarshal(pdu, offset, "ds", &msize, &version);
 975
 976     if (strcmp(version.data, "9P2000.u")) {
 977         v9fs_string_sprintf(&version, "unknown");
 978     }
 979
 980     offset += pdu_marshal(pdu, offset, "ds", msize, &version);
 981     complete_pdu(s, pdu, offset);
 982
 983     v9fs_string_free(&version);
 984 }
 985
 986 static void v9fs_attach(V9fsState *s, V9fsPDU *pdu)
 987 {
 988     int32_t fid, afid, n_uname;
 989     V9fsString uname, aname;
 990     V9fsFidState *fidp;
 991     V9fsQID qid;
 992     size_t offset = 7;
 993     ssize_t err;
 994
 995     pdu_unmarshal(pdu, offset, "ddssd", &fid, &afid, &uname, &aname, &n_uname);
 996
 997     fidp = alloc_fid(s, fid);
 998     if (fidp == NULL) {
 999         err = -EINVAL;
1000         goto out;
1001     }
1002
1003     fidp->uid = n_uname;
1004
1005     v9fs_string_sprintf(&fidp->path, "%s", "/");
1006     err = fid_to_qid(s, fidp, &qid);
1007     if (err) {
1008         err = -EINVAL;
1009         free_fid(s, fid);
1010         goto out;
1011     }
1012
1013     offset += pdu_marshal(pdu, offset, "Q", &qid);
1014
1015     err = offset;
1016 out:
1017     complete_pdu(s, pdu, err);
1018     v9fs_string_free(&uname);
1019     v9fs_string_free(&aname);
1020 }
1021
1022 typedef struct V9fsStatState {
1023     V9fsPDU *pdu;
1024     size_t offset;
1025     V9fsStat v9stat;
1026     V9fsFidState *fidp;
1027     struct stat stbuf;
1028 } V9fsStatState;
1029
1030 static void v9fs_stat_post_lstat(V9fsState *s, V9fsStatState *vs, int err)
1031 {
1032     if (err == -1) {
1033         err = -errno;
1034         goto out;
1035     }
1036
1037     err = stat_to_v9stat(s, &vs->fidp->path, &vs->stbuf, &vs->v9stat);
1038     if (err) {
1039         goto out;
1040     }
1041     vs->offset += pdu_marshal(vs->pdu, vs->offset, "wS", 0, &vs->v9stat);
1042     err = vs->offset;
1043
1044 out:
1045     complete_pdu(s, vs->pdu, err);
1046     v9fs_stat_free(&vs->v9stat);
1047     qemu_free(vs);
1048 }
1049
1050 static void v9fs_stat(V9fsState *s, V9fsPDU *pdu)
1051 {
1052     int32_t fid;
1053     V9fsStatState *vs;
1054     ssize_t err = 0;
1055
1056     vs = qemu_malloc(sizeof(*vs));
1057     vs->pdu = pdu;
1058     vs->offset = 7;
1059
1060     memset(&vs->v9stat, 0, sizeof(vs->v9stat));
1061
1062     pdu_unmarshal(vs->pdu, vs->offset, "d", &fid);
1063
1064     vs->fidp = lookup_fid(s, fid);
1065     if (vs->fidp == NULL) {
1066         err = -ENOENT;
1067         goto out;
1068     }
1069
1070     err = v9fs_do_lstat(s, &vs->fidp->path, &vs->stbuf);
1071     v9fs_stat_post_lstat(s, vs, err);
1072     return;
1073
1074 out:
1075     complete_pdu(s, vs->pdu, err);
1076     v9fs_stat_free(&vs->v9stat);
1077     qemu_free(vs);
1078 }
1079
1080 typedef struct V9fsWalkState {
1081     V9fsPDU *pdu;
1082     size_t offset;
1083     int16_t nwnames;
1084     int name_idx;
1085     V9fsQID *qids;
1086     V9fsFidState *fidp;
1087     V9fsFidState *newfidp;
1088     V9fsString path;
1089     V9fsString *wnames;
1090     struct stat stbuf;
1091 } V9fsWalkState;
1092
1093 static void v9fs_walk_complete(V9fsState *s, V9fsWalkState *vs, int err)
1094 {
1095     complete_pdu(s, vs->pdu, err);
1096
1097     if (vs->nwnames) {
1098         for (vs->name_idx = 0; vs->name_idx < vs->nwnames; vs->name_idx++) {
1099             v9fs_string_free(&vs->wnames[vs->name_idx]);
1100         }
1101
1102         qemu_free(vs->wnames);
1103         qemu_free(vs->qids);
1104     }
1105 }
1106
1107 static void v9fs_walk_marshal(V9fsWalkState *vs)
1108 {
1109     int i;
1110     vs->offset = 7;
1111     vs->offset += pdu_marshal(vs->pdu, vs->offset, "w", vs->nwnames);
1112
1113     for (i = 0; i < vs->nwnames; i++) {
1114         vs->offset += pdu_marshal(vs->pdu, vs->offset, "Q", &vs->qids[i]);
1115     }
1116 }
1117
1118 static void v9fs_walk_post_newfid_lstat(V9fsState *s, V9fsWalkState *vs,
1119                                                                 int err)
1120 {
1121     if (err == -1) {
1122         free_fid(s, vs->newfidp->fid);
1123         v9fs_string_free(&vs->path);
1124         err = -ENOENT;
1125         goto out;
1126     }
1127
1128     stat_to_qid(&vs->stbuf, &vs->qids[vs->name_idx]);
1129
1130     vs->name_idx++;
1131     if (vs->name_idx < vs->nwnames) {
1132         v9fs_string_sprintf(&vs->path, "%s/%s", vs->newfidp->path.data,
1133                                             vs->wnames[vs->name_idx].data);
1134         v9fs_string_copy(&vs->newfidp->path, &vs->path);
1135
1136         err = v9fs_do_lstat(s, &vs->newfidp->path, &vs->stbuf);
1137         v9fs_walk_post_newfid_lstat(s, vs, err);
1138         return;
1139     }
1140
1141     v9fs_string_free(&vs->path);
1142     v9fs_walk_marshal(vs);
1143     err = vs->offset;
1144 out:
1145     v9fs_walk_complete(s, vs, err);
1146 }
1147
1148 static void v9fs_walk_post_oldfid_lstat(V9fsState *s, V9fsWalkState *vs,
1149         int err)
1150 {
1151     if (err == -1) {
1152         v9fs_string_free(&vs->path);
1153         err = -ENOENT;
1154         goto out;
1155     }
1156
1157     stat_to_qid(&vs->stbuf, &vs->qids[vs->name_idx]);
1158     vs->name_idx++;
1159     if (vs->name_idx < vs->nwnames) {
1160
1161         v9fs_string_sprintf(&vs->path, "%s/%s",
1162                 vs->fidp->path.data, vs->wnames[vs->name_idx].data);
1163         v9fs_string_copy(&vs->fidp->path, &vs->path);
1164
1165         err = v9fs_do_lstat(s, &vs->fidp->path, &vs->stbuf);
1166         v9fs_walk_post_oldfid_lstat(s, vs, err);
1167         return;
1168     }
1169
1170     v9fs_string_free(&vs->path);
1171     v9fs_walk_marshal(vs);
1172     err = vs->offset;
1173 out:
1174     v9fs_walk_complete(s, vs, err);
1175 }
1176
1177 static void v9fs_walk(V9fsState *s, V9fsPDU *pdu)
1178 {
1179     int32_t fid, newfid;
1180     V9fsWalkState *vs;
1181     int err = 0;
1182     int i;
1183
1184     vs = qemu_malloc(sizeof(*vs));
1185     vs->pdu = pdu;
1186     vs->wnames = NULL;
1187     vs->qids = NULL;
1188     vs->offset = 7;
1189
1190     vs->offset += pdu_unmarshal(vs->pdu, vs->offset, "ddw", &fid,
1191                                             &newfid, &vs->nwnames);
1192
1193     if (vs->nwnames) {
1194         vs->wnames = qemu_mallocz(sizeof(vs->wnames[0]) * vs->nwnames);
1195
1196         vs->qids = qemu_mallocz(sizeof(vs->qids[0]) * vs->nwnames);
1197
1198         for (i = 0; i < vs->nwnames; i++) {
1199             vs->offset += pdu_unmarshal(vs->pdu, vs->offset, "s",
1200                                             &vs->wnames[i]);
1201         }
1202     }
1203
1204     vs->fidp = lookup_fid(s, fid);
1205     if (vs->fidp == NULL) {
1206         err = -ENOENT;
1207         goto out;
1208     }
1209
1210     /* FIXME: is this really valid? */
1211     if (fid == newfid) {
1212
1213         BUG_ON(vs->fidp->fd != -1);
1214         BUG_ON(vs->fidp->dir);
1215         v9fs_string_init(&vs->path);
1216         vs->name_idx = 0;
1217
1218         if (vs->name_idx < vs->nwnames) {
1219             v9fs_string_sprintf(&vs->path, "%s/%s",
1220                 vs->fidp->path.data, vs->wnames[vs->name_idx].data);
1221             v9fs_string_copy(&vs->fidp->path, &vs->path);
1222
1223             err = v9fs_do_lstat(s, &vs->fidp->path, &vs->stbuf);
1224             v9fs_walk_post_oldfid_lstat(s, vs, err);
1225             return;
1226         }
1227     } else {
1228         vs->newfidp = alloc_fid(s, newfid);
1229         if (vs->newfidp == NULL) {
1230             err = -EINVAL;
1231             goto out;
1232         }
1233
1234         vs->newfidp->uid = vs->fidp->uid;
1235         v9fs_string_init(&vs->path);
1236         vs->name_idx = 0;
1237         v9fs_string_copy(&vs->newfidp->path, &vs->fidp->path);
1238
1239         if (vs->name_idx < vs->nwnames) {
1240             v9fs_string_sprintf(&vs->path, "%s/%s", vs->newfidp->path.data,
1241                                 vs->wnames[vs->name_idx].data);
1242             v9fs_string_copy(&vs->newfidp->path, &vs->path);
1243
1244             err = v9fs_do_lstat(s, &vs->newfidp->path, &vs->stbuf);
1245             v9fs_walk_post_newfid_lstat(s, vs, err);
1246             return;
1247         }
1248     }
1249
1250     v9fs_walk_marshal(vs);
1251     err = vs->offset;
1252 out:
1253     v9fs_walk_complete(s, vs, err);
1254 }
1255
1256 typedef struct V9fsOpenState {
1257     V9fsPDU *pdu;
1258     size_t offset;
1259     int8_t mode;
1260     V9fsFidState *fidp;
1261     V9fsQID qid;
1262     struct stat stbuf;
1263
1264 } V9fsOpenState;
1265
1266 enum {
1267     Oread   = 0x00,
1268     Owrite  = 0x01,
1269     Ordwr   = 0x02,
1270     Oexec   = 0x03,
1271     Oexcl   = 0x04,
1272     Otrunc  = 0x10,
1273     Orexec  = 0x20,
1274     Orclose = 0x40,
1275     Oappend = 0x80,
1276 };
1277
1278 static int omode_to_uflags(int8_t mode)
1279 {
1280     int ret = 0;
1281
1282     switch (mode & 3) {
1283     case Oread:
1284         ret = O_RDONLY;
1285         break;
1286     case Ordwr:
1287         ret = O_RDWR;
1288         break;
1289     case Owrite:
1290         ret = O_WRONLY;
1291         break;
1292     case Oexec:
1293         ret = O_RDONLY;
1294         break;
1295     }
1296
1297     if (mode & Otrunc) {
1298         ret |= O_TRUNC;
1299     }
1300
1301     if (mode & Oappend) {
1302         ret |= O_APPEND;
1303     }
1304
1305     if (mode & Oexcl) {
1306         ret |= O_EXCL;
1307     }
1308
1309     return ret;
1310 }
1311
1312 static void v9fs_open_post_opendir(V9fsState *s, V9fsOpenState *vs, int err)
1313 {
1314     if (vs->fidp->dir == NULL) {
1315         err = -errno;
1316         goto out;
1317     }
1318
1319     vs->offset += pdu_marshal(vs->pdu, vs->offset, "Qd", &vs->qid, 0);
1320     err = vs->offset;
1321 out:
1322     complete_pdu(s, vs->pdu, err);
1323     qemu_free(vs);
1324
1325 }
1326
1327 static void v9fs_open_post_open(V9fsState *s, V9fsOpenState *vs, int err)
1328 {
1329     if (vs->fidp->fd == -1) {
1330         err = -errno;
1331         goto out;
1332     }
1333
1334     vs->offset += pdu_marshal(vs->pdu, vs->offset, "Qd", &vs->qid, 0);
1335     err = vs->offset;
1336 out:
1337     complete_pdu(s, vs->pdu, err);
1338     qemu_free(vs);
1339 }
1340
1341 static void v9fs_open_post_lstat(V9fsState *s, V9fsOpenState *vs, int err)
1342 {
1343     if (err) {
1344         err = -errno;
1345         goto out;
1346     }
1347
1348     stat_to_qid(&vs->stbuf, &vs->qid);
1349
1350     if (S_ISDIR(vs->stbuf.st_mode)) {
1351         vs->fidp->dir = v9fs_do_opendir(s, &vs->fidp->path);
1352         v9fs_open_post_opendir(s, vs, err);
1353     } else {
1354         vs->fidp->fd = v9fs_do_open(s, &vs->fidp->path,
1355                                     omode_to_uflags(vs->mode));
1356         v9fs_open_post_open(s, vs, err);
1357     }
1358     return;
1359 out:
1360     complete_pdu(s, vs->pdu, err);
1361     qemu_free(vs);
1362 }
1363
1364 static void v9fs_open(V9fsState *s, V9fsPDU *pdu)
1365 {
1366     int32_t fid;
1367     V9fsOpenState *vs;
1368     ssize_t err = 0;
1369
1370
1371     vs = qemu_malloc(sizeof(*vs));
1372     vs->pdu = pdu;
1373     vs->offset = 7;
1374
1375     pdu_unmarshal(vs->pdu, vs->offset, "db", &fid, &vs->mode);
1376
1377     vs->fidp = lookup_fid(s, fid);
1378     if (vs->fidp == NULL) {
1379         err = -ENOENT;
1380         goto out;
1381     }
1382
1383     BUG_ON(vs->fidp->fd != -1);
1384     BUG_ON(vs->fidp->dir);
1385
1386     err = v9fs_do_lstat(s, &vs->fidp->path, &vs->stbuf);
1387
1388     v9fs_open_post_lstat(s, vs, err);
1389     return;
1390 out:
1391     complete_pdu(s, pdu, err);
1392     qemu_free(vs);
1393 }
1394
1395 static void v9fs_clunk(V9fsState *s, V9fsPDU *pdu)
1396 {
1397     int32_t fid;
1398     size_t offset = 7;
1399     int err;
1400
1401     pdu_unmarshal(pdu, offset, "d", &fid);
1402
1403     err = free_fid(s, fid);
1404     if (err < 0) {
1405         goto out;
1406     }
1407
1408     offset = 7;
1409     err = offset;
1410 out:
1411     complete_pdu(s, pdu, err);
1412 }
1413
1414 typedef struct V9fsReadState {
1415     V9fsPDU *pdu;
1416     size_t offset;
1417     int32_t count;
1418     int32_t total;
1419     int64_t off;
1420     V9fsFidState *fidp;
1421     struct iovec iov[128]; /* FIXME: bad, bad, bad */
1422     struct iovec *sg;
1423     off_t dir_pos;
1424     struct dirent *dent;
1425     struct stat stbuf;
1426     V9fsString name;
1427     V9fsStat v9stat;
1428     int32_t len;
1429     int32_t cnt;
1430     int32_t max_count;
1431 } V9fsReadState;
1432
1433 static void v9fs_read_post_readdir(V9fsState *, V9fsReadState *, ssize_t);
1434
1435 static void v9fs_read_post_seekdir(V9fsState *s, V9fsReadState *vs, ssize_t err)
1436 {
1437     if (err) {
1438         goto out;
1439     }
1440     v9fs_stat_free(&vs->v9stat);
1441     v9fs_string_free(&vs->name);
1442     vs->offset += pdu_marshal(vs->pdu, vs->offset, "d", vs->count);
1443     vs->offset += vs->count;
1444     err = vs->offset;
1445 out:
1446     complete_pdu(s, vs->pdu, err);
1447     qemu_free(vs);
1448     return;
1449 }
1450
1451 static void v9fs_read_post_dir_lstat(V9fsState *s, V9fsReadState *vs,
1452                                     ssize_t err)
1453 {
1454     if (err) {
1455         err = -errno;
1456         goto out;
1457     }
1458     err = stat_to_v9stat(s, &vs->name, &vs->stbuf, &vs->v9stat);
1459     if (err) {
1460         goto out;
1461     }
1462
1463     vs->len = pdu_marshal(vs->pdu, vs->offset + 4 + vs->count, "S",
1464                             &vs->v9stat);
1465     if ((vs->len != (vs->v9stat.size + 2)) ||
1466             ((vs->count + vs->len) > vs->max_count)) {
1467         v9fs_do_seekdir(s, vs->fidp->dir, vs->dir_pos);
1468         v9fs_read_post_seekdir(s, vs, err);
1469         return;
1470     }
1471     vs->count += vs->len;
1472     v9fs_stat_free(&vs->v9stat);
1473     v9fs_string_free(&vs->name);
1474     vs->dir_pos = vs->dent->d_off;
1475     vs->dent = v9fs_do_readdir(s, vs->fidp->dir);
1476     v9fs_read_post_readdir(s, vs, err);
1477     return;
1478 out:
1479     v9fs_do_seekdir(s, vs->fidp->dir, vs->dir_pos);
1480     v9fs_read_post_seekdir(s, vs, err);
1481     return;
1482
1483 }
1484
1485 static void v9fs_read_post_readdir(V9fsState *s, V9fsReadState *vs, ssize_t err)
1486 {
1487     if (vs->dent) {
1488         memset(&vs->v9stat, 0, sizeof(vs->v9stat));
1489         v9fs_string_init(&vs->name);
1490         v9fs_string_sprintf(&vs->name, "%s/%s", vs->fidp->path.data,
1491                             vs->dent->d_name);
1492         err = v9fs_do_lstat(s, &vs->name, &vs->stbuf);
1493         v9fs_read_post_dir_lstat(s, vs, err);
1494         return;
1495     }
1496
1497     vs->offset += pdu_marshal(vs->pdu, vs->offset, "d", vs->count);
1498     vs->offset += vs->count;
1499     err = vs->offset;
1500     complete_pdu(s, vs->pdu, err);
1501     qemu_free(vs);
1502     return;
1503 }
1504
1505 static void v9fs_read_post_telldir(V9fsState *s, V9fsReadState *vs, ssize_t err)
1506 {
1507     vs->dent = v9fs_do_readdir(s, vs->fidp->dir);
1508     v9fs_read_post_readdir(s, vs, err);
1509     return;
1510 }
1511
1512 static void v9fs_read_post_rewinddir(V9fsState *s, V9fsReadState *vs,
1513                                        ssize_t err)
1514 {
1515     vs->dir_pos = v9fs_do_telldir(s, vs->fidp->dir);
1516     v9fs_read_post_telldir(s, vs, err);
1517     return;
1518 }
1519
1520 static void v9fs_read_post_readv(V9fsState *s, V9fsReadState *vs, ssize_t err)
1521 {
1522     if (err  < 0) {
1523         /* IO error return the error */
1524         err = -errno;
1525         goto out;
1526     }
1527     vs->total += vs->len;
1528     vs->sg = adjust_sg(vs->sg, vs->len, &vs->cnt);
1529     if (vs->total < vs->count && vs->len > 0) {
1530         do {
1531             if (0) {
1532                 print_sg(vs->sg, vs->cnt);
1533             }
1534             vs->len = v9fs_do_readv(s, vs->fidp->fd, vs->sg, vs->cnt);
1535         } while (vs->len == -1 && errno == EINTR);
1536         if (vs->len == -1) {
1537             err  = -errno;
1538         }
1539         v9fs_read_post_readv(s, vs, err);
1540         return;
1541     }
1542     vs->offset += pdu_marshal(vs->pdu, vs->offset, "d", vs->total);
1543     vs->offset += vs->count;
1544     err = vs->offset;
1545
1546 out:
1547     complete_pdu(s, vs->pdu, err);
1548     qemu_free(vs);
1549 }
1550
1551 static void v9fs_read_post_lseek(V9fsState *s, V9fsReadState *vs, ssize_t err)
1552 {
1553     if (err == -1) {
1554         err = -errno;
1555         goto out;
1556     }
1557     vs->sg = cap_sg(vs->sg, vs->count, &vs->cnt);
1558
1559     if (vs->total < vs->count) {
1560         do {
1561             if (0) {
1562                 print_sg(vs->sg, vs->cnt);
1563             }
1564             vs->len = v9fs_do_readv(s, vs->fidp->fd, vs->sg, vs->cnt);
1565         } while (vs->len == -1 && errno == EINTR);
1566         if (vs->len == -1) {
1567             err  = -errno;
1568         }
1569         v9fs_read_post_readv(s, vs, err);
1570         return;
1571     }
1572 out:
1573     complete_pdu(s, vs->pdu, err);
1574     qemu_free(vs);
1575 }
1576
1577 static void v9fs_read(V9fsState *s, V9fsPDU *pdu)
1578 {
1579     int32_t fid;
1580     V9fsReadState *vs;
1581     ssize_t err = 0;
1582
1583     vs = qemu_malloc(sizeof(*vs));
1584     vs->pdu = pdu;
1585     vs->offset = 7;
1586     vs->total = 0;
1587     vs->len = 0;
1588     vs->count = 0;
1589
1590     pdu_unmarshal(vs->pdu, vs->offset, "dqd", &fid, &vs->off, &vs->count);
1591
1592     vs->fidp = lookup_fid(s, fid);
1593     if (vs->fidp == NULL) {
1594         err = -EINVAL;
1595         goto out;
1596     }
1597
1598     if (vs->fidp->dir) {
1599         vs->max_count = vs->count;
1600         vs->count = 0;
1601         if (vs->off == 0) {
1602             v9fs_do_rewinddir(s, vs->fidp->dir);
1603         }
1604         v9fs_read_post_rewinddir(s, vs, err);
1605         return;
1606     } else if (vs->fidp->fd != -1) {
1607         vs->sg = vs->iov;
1608         pdu_marshal(vs->pdu, vs->offset + 4, "v", vs->sg, &vs->cnt);
1609         err = v9fs_do_lseek(s, vs->fidp->fd, vs->off, SEEK_SET);
1610         v9fs_read_post_lseek(s, vs, err);
1611         return;
1612     } else {
1613         err = -EINVAL;
1614     }
1615 out:
1616     complete_pdu(s, pdu, err);
1617     qemu_free(vs);
1618 }
1619
1620 typedef struct V9fsWriteState {
1621     V9fsPDU *pdu;
1622     size_t offset;
1623     int32_t len;
1624     int32_t count;
1625     int32_t total;
1626     int64_t off;
1627     V9fsFidState *fidp;
1628     struct iovec iov[128]; /* FIXME: bad, bad, bad */
1629     struct iovec *sg;
1630     int cnt;
1631 } V9fsWriteState;
1632
1633 static void v9fs_write_post_writev(V9fsState *s, V9fsWriteState *vs,
1634                                    ssize_t err)
1635 {
1636     if (err  < 0) {
1637         /* IO error return the error */
1638         err = -errno;
1639         goto out;
1640     }
1641     vs->total += vs->len;
1642     vs->sg = adjust_sg(vs->sg, vs->len, &vs->cnt);
1643     if (vs->total < vs->count && vs->len > 0) {
1644         do {
1645             if (0) {
1646                 print_sg(vs->sg, vs->cnt);
1647             }
1648             vs->len =  v9fs_do_writev(s, vs->fidp->fd, vs->sg, vs->cnt);
1649         } while (vs->len == -1 && errno == EINTR);
1650         if (vs->len == -1) {
1651             err  = -errno;
1652         }
1653         v9fs_write_post_writev(s, vs, err);
1654         return;
1655     }
1656     vs->offset += pdu_marshal(vs->pdu, vs->offset, "d", vs->total);
1657
1658     err = vs->offset;
1659 out:
1660     complete_pdu(s, vs->pdu, err);
1661     qemu_free(vs);
1662 }
1663
1664 static void v9fs_write_post_lseek(V9fsState *s, V9fsWriteState *vs, ssize_t err)
1665 {
1666     if (err == -1) {
1667         err = -errno;
1668         goto out;
1669     }
1670     vs->sg = cap_sg(vs->sg, vs->count, &vs->cnt);
1671
1672     if (vs->total < vs->count) {
1673         do {
1674             if (0) {
1675                 print_sg(vs->sg, vs->cnt);
1676             }
1677             vs->len = v9fs_do_writev(s, vs->fidp->fd, vs->sg, vs->cnt);
1678         } while (vs->len == -1 && errno == EINTR);
1679         if (vs->len == -1) {
1680             err  = -errno;
1681         }
1682         v9fs_write_post_writev(s, vs, err);
1683         return;
1684     }
1685
1686 out:
1687     complete_pdu(s, vs->pdu, err);
1688     qemu_free(vs);
1689 }
1690
1691 static void v9fs_write(V9fsState *s, V9fsPDU *pdu)
1692 {
1693     int32_t fid;
1694     V9fsWriteState *vs;
1695     ssize_t err;
1696
1697     vs = qemu_malloc(sizeof(*vs));
1698
1699     vs->pdu = pdu;
1700     vs->offset = 7;
1701     vs->sg = vs->iov;
1702     vs->total = 0;
1703     vs->len = 0;
1704
1705     pdu_unmarshal(vs->pdu, vs->offset, "dqdv", &fid, &vs->off, &vs->count,
1706                     vs->sg, &vs->cnt);
1707
1708     vs->fidp = lookup_fid(s, fid);
1709     if (vs->fidp == NULL) {
1710         err = -EINVAL;
1711         goto out;
1712     }
1713
1714     if (vs->fidp->fd == -1) {
1715         err = -EINVAL;
1716         goto out;
1717     }
1718
1719     err = v9fs_do_lseek(s, vs->fidp->fd, vs->off, SEEK_SET);
1720
1721     v9fs_write_post_lseek(s, vs, err);
1722     return;
1723
1724 out:
1725     complete_pdu(s, vs->pdu, err);
1726     qemu_free(vs);
1727 }
1728
1729 typedef struct V9fsCreateState {
1730     V9fsPDU *pdu;
1731     size_t offset;
1732     V9fsFidState *fidp;
1733     V9fsQID qid;
1734     int32_t perm;
1735     int8_t mode;
1736     struct stat stbuf;
1737     V9fsString name;
1738     V9fsString extension;
1739     V9fsString fullname;
1740 } V9fsCreateState;
1741
1742 static void v9fs_post_create(V9fsState *s, V9fsCreateState *vs, int err)
1743 {
1744     if (err == 0) {
1745         v9fs_string_copy(&vs->fidp->path, &vs->fullname);
1746         stat_to_qid(&vs->stbuf, &vs->qid);
1747
1748         vs->offset += pdu_marshal(vs->pdu, vs->offset, "Qd", &vs->qid, 0);
1749
1750         err = vs->offset;
1751     }
1752
1753     complete_pdu(s, vs->pdu, err);
1754     v9fs_string_free(&vs->name);
1755     v9fs_string_free(&vs->extension);
1756     v9fs_string_free(&vs->fullname);
1757     qemu_free(vs);
1758 }
1759
1760 static void v9fs_create_post_perms(V9fsState *s, V9fsCreateState *vs, int err)
1761 {
1762     if (err) {
1763         err = -errno;
1764     }
1765     v9fs_post_create(s, vs, err);
1766 }
1767
1768 static void v9fs_create_post_opendir(V9fsState *s, V9fsCreateState *vs,
1769                                                                     int err)
1770 {
1771     if (!vs->fidp->dir) {
1772         err = -errno;
1773     }
1774     v9fs_post_create(s, vs, err);
1775 }
1776
1777 static void v9fs_create_post_dir_lstat(V9fsState *s, V9fsCreateState *vs,
1778                                                                     int err)
1779 {
1780     if (err) {
1781         err = -errno;
1782         goto out;
1783     }
1784
1785     vs->fidp->dir = v9fs_do_opendir(s, &vs->fullname);
1786     v9fs_create_post_opendir(s, vs, err);
1787     return;
1788
1789 out:
1790     v9fs_post_create(s, vs, err);
1791 }
1792
1793 static void v9fs_create_post_mkdir(V9fsState *s, V9fsCreateState *vs, int err)
1794 {
1795     if (err) {
1796         err = -errno;
1797         goto out;
1798     }
1799
1800     err = v9fs_do_lstat(s, &vs->fullname, &vs->stbuf);
1801     v9fs_create_post_dir_lstat(s, vs, err);
1802     return;
1803
1804 out:
1805     v9fs_post_create(s, vs, err);
1806 }
1807
1808 static void v9fs_create_post_mksock(V9fsState *s, V9fsCreateState *vs,
1809                                                                 int err)
1810 {
1811     if (err) {
1812         err = -errno;
1813         goto out;
1814     }
1815
1816     err = v9fs_do_chmod(s, &vs->fullname, vs->perm & 0777);
1817     v9fs_create_post_perms(s, vs, err);
1818     return;
1819
1820 out:
1821     v9fs_post_create(s, vs, err);
1822 }
1823
1824 static void v9fs_create_post_fstat(V9fsState *s, V9fsCreateState *vs, int err)
1825 {
1826     if (err) {
1827         vs->fidp->fd = -1;
1828         err = -errno;
1829     }
1830
1831     v9fs_post_create(s, vs, err);
1832     return;
1833 }
1834
1835 static void v9fs_create_post_open2(V9fsState *s, V9fsCreateState *vs, int err)
1836 {
1837     if (vs->fidp->fd == -1) {
1838         err = -errno;
1839         goto out;
1840     }
1841
1842     err = v9fs_do_fstat(s, vs->fidp->fd, &vs->stbuf);
1843     v9fs_create_post_fstat(s, vs, err);
1844
1845     return;
1846
1847 out:
1848     v9fs_post_create(s, vs, err);
1849
1850 }
1851
1852 static void v9fs_create_post_lstat(V9fsState *s, V9fsCreateState *vs, int err)
1853 {
1854
1855     if (err == 0 || errno != ENOENT) {
1856         err = -errno;
1857         goto out;
1858     }
1859
1860     if (vs->perm & P9_STAT_MODE_DIR) {
1861         err = v9fs_do_mkdir(s, &vs->fullname, vs->perm & 0777);
1862         v9fs_create_post_mkdir(s, vs, err);
1863     } else if (vs->perm & P9_STAT_MODE_SYMLINK) {
1864         err = v9fs_do_symlink(s, &vs->extension, &vs->fullname);
1865         v9fs_create_post_perms(s, vs, err);
1866     } else if (vs->perm & P9_STAT_MODE_LINK) {
1867         int32_t nfid = atoi(vs->extension.data);
1868         V9fsFidState *nfidp = lookup_fid(s, nfid);
1869         if (nfidp == NULL) {
1870             err = -errno;
1871             v9fs_post_create(s, vs, err);
1872         }
1873         err = v9fs_do_link(s, &nfidp->path, &vs->fullname);
1874         v9fs_create_post_perms(s, vs, err);
1875     } else if (vs->perm & P9_STAT_MODE_DEVICE) {
1876         char ctype;
1877         uint32_t major, minor;
1878         mode_t nmode = 0;
1879
1880         if (sscanf(vs->extension.data, "%c %u %u", &ctype, &major,
1881                                         &minor) != 3) {
1882             err = -errno;
1883             v9fs_post_create(s, vs, err);
1884         }
1885
1886         switch (ctype) {
1887         case 'c':
1888             nmode = S_IFCHR;
1889             break;
1890         case 'b':
1891             nmode = S_IFBLK;
1892             break;
1893         default:
1894             err = -EIO;
1895             v9fs_post_create(s, vs, err);
1896         }
1897
1898         nmode |= vs->perm & 0777;
1899         err = v9fs_do_mknod(s, &vs->fullname, nmode, makedev(major, minor));
1900         v9fs_create_post_perms(s, vs, err);
1901     } else if (vs->perm & P9_STAT_MODE_NAMED_PIPE) {
1902         err = v9fs_do_mknod(s, &vs->fullname, S_IFIFO | (vs->mode & 0777), 0);
1903         v9fs_post_create(s, vs, err);
1904     } else if (vs->perm & P9_STAT_MODE_SOCKET) {
1905         err = v9fs_do_mksock(s, &vs->fullname);
1906         v9fs_create_post_mksock(s, vs, err);
1907     } else {
1908         vs->fidp->fd = v9fs_do_open2(s, &vs->fullname,
1909                                 omode_to_uflags(vs->mode) | O_CREAT,
1910                                 vs->perm & 0777);
1911         v9fs_create_post_open2(s, vs, err);
1912     }
1913
1914     return;
1915
1916 out:
1917     v9fs_post_create(s, vs, err);
1918 }
1919
1920 static void v9fs_create(V9fsState *s, V9fsPDU *pdu)
1921 {
1922     int32_t fid;
1923     V9fsCreateState *vs;
1924     int err = 0;
1925
1926     vs = qemu_malloc(sizeof(*vs));
1927     vs->pdu = pdu;
1928     vs->offset = 7;
1929
1930     v9fs_string_init(&vs->fullname);
1931
1932     pdu_unmarshal(vs->pdu, vs->offset, "dsdbs", &fid, &vs->name,
1933                                 &vs->perm, &vs->mode, &vs->extension);
1934
1935     vs->fidp = lookup_fid(s, fid);
1936     if (vs->fidp == NULL) {
1937         err = -EINVAL;
1938         goto out;
1939     }
1940
1941     v9fs_string_sprintf(&vs->fullname, "%s/%s", vs->fidp->path.data,
1942                                                         vs->name.data);
1943
1944     err = v9fs_do_lstat(s, &vs->fullname, &vs->stbuf);
1945     v9fs_create_post_lstat(s, vs, err);
1946     return;
1947
1948 out:
1949     complete_pdu(s, vs->pdu, err);
1950     v9fs_string_free(&vs->name);
1951     v9fs_string_free(&vs->extension);
1952     qemu_free(vs);
1953 }
1954
1955 static void v9fs_flush(V9fsState *s, V9fsPDU *pdu)
1956 {
1957     v9fs_dummy(s, pdu);
1958     if (debug_9p_pdu) {
1959         pprint_pdu(pdu);
1960     }
1961 }
1962
1963 static void v9fs_remove(V9fsState *s, V9fsPDU *pdu)
1964 {
1965     if (debug_9p_pdu) {
1966         pprint_pdu(pdu);
1967     }
1968 }
1969
1970 typedef struct V9fsWstatState
1971 {
1972     V9fsPDU *pdu;
1973     size_t offset;
1974     int16_t unused;
1975     V9fsStat v9stat;
1976     V9fsFidState *fidp;
1977     struct stat stbuf;
1978     V9fsString nname;
1979 } V9fsWstatState;
1980
1981 static void v9fs_wstat_post_truncate(V9fsState *s, V9fsWstatState *vs, int err)
1982 {
1983     if (err < 0) {
1984         goto out;
1985     }
1986
1987     err = vs->offset;
1988
1989 out:
1990     v9fs_stat_free(&vs->v9stat);
1991     complete_pdu(s, vs->pdu, err);
1992     qemu_free(vs);
1993 }
1994
1995 static void v9fs_wstat_post_rename(V9fsState *s, V9fsWstatState *vs, int err)
1996 {
1997     if (err < 0) {
1998         goto out;
1999     }
2000
2001     if (vs->v9stat.name.size != 0) {
2002         v9fs_string_free(&vs->nname);
2003     }
2004
2005     if (vs->v9stat.length != -1) {
2006         if (v9fs_do_truncate(s, &vs->fidp->path, vs->v9stat.length) < 0) {
2007             err = -errno;
2008         }
2009     }
2010     v9fs_wstat_post_truncate(s, vs, err);
2011     return;
2012
2013 out:
2014     v9fs_stat_free(&vs->v9stat);
2015     complete_pdu(s, vs->pdu, err);
2016     qemu_free(vs);
2017 }
2018
2019 static void v9fs_wstat_post_chown(V9fsState *s, V9fsWstatState *vs, int err)
2020 {
2021     V9fsFidState *fidp;
2022     if (err < 0) {
2023         goto out;
2024     }
2025
2026     if (vs->v9stat.name.size != 0) {
2027         char *old_name, *new_name;
2028         char *end;
2029
2030         old_name = vs->fidp->path.data;
2031         end = strrchr(old_name, '/');
2032         if (end) {
2033             end++;
2034         } else {
2035             end = old_name;
2036         }
2037
2038         new_name = qemu_malloc(end - old_name + vs->v9stat.name.size + 1);
2039
2040         memset(new_name, 0, end - old_name + vs->v9stat.name.size + 1);
2041         memcpy(new_name, old_name, end - old_name);
2042         memcpy(new_name + (end - old_name), vs->v9stat.name.data,
2043                 vs->v9stat.name.size);
2044         vs->nname.data = new_name;
2045         vs->nname.size = strlen(new_name);
2046
2047         if (strcmp(new_name, vs->fidp->path.data) != 0) {
2048             if (v9fs_do_rename(s, &vs->fidp->path, &vs->nname)) {
2049                 err = -errno;
2050             } else {
2051                 /*
2052                  * Fixup fid's pointing to the old name to
2053                  * start pointing to the new name
2054                  */
2055                 for (fidp = s->fid_list; fidp; fidp = fidp->next) {
2056
2057                     if (vs->fidp == fidp) {
2058                         /*
2059                          * we replace name of this fid towards the end
2060                          * so that our below strcmp will work
2061                          */
2062                         continue;
2063                     }
2064                     if (!strncmp(vs->fidp->path.data, fidp->path.data,
2065                                  strlen(vs->fidp->path.data))) {
2066                         /* replace the name */
2067                         v9fs_fix_path(&fidp->path, &vs->nname,
2068                                       strlen(vs->fidp->path.data));
2069                     }
2070                 }
2071                 v9fs_string_copy(&vs->fidp->path, &vs->nname);
2072             }
2073         }
2074     }
2075     v9fs_wstat_post_rename(s, vs, err);
2076     return;
2077
2078 out:
2079     v9fs_stat_free(&vs->v9stat);
2080     complete_pdu(s, vs->pdu, err);
2081     qemu_free(vs);
2082 }
2083
2084 static void v9fs_wstat_post_utime(V9fsState *s, V9fsWstatState *vs, int err)
2085 {
2086     if (err < 0) {
2087         goto out;
2088     }
2089
2090     if (vs->v9stat.n_gid != -1) {
2091         if (v9fs_do_chown(s, &vs->fidp->path, vs->v9stat.n_uid,
2092                     vs->v9stat.n_gid)) {
2093             err = -errno;
2094         }
2095     }
2096     v9fs_wstat_post_chown(s, vs, err);
2097     return;
2098
2099 out:
2100     v9fs_stat_free(&vs->v9stat);
2101     complete_pdu(s, vs->pdu, err);
2102     qemu_free(vs);
2103 }
2104
2105 static void v9fs_wstat_post_chmod(V9fsState *s, V9fsWstatState *vs, int err)
2106 {
2107     if (err < 0) {
2108         goto out;
2109     }
2110
2111     if (vs->v9stat.mtime != -1) {
2112         struct utimbuf tb;
2113         tb.actime = 0;
2114         tb.modtime = vs->v9stat.mtime;
2115         if (v9fs_do_utime(s, &vs->fidp->path, &tb)) {
2116             err = -errno;
2117         }
2118     }
2119
2120     v9fs_wstat_post_utime(s, vs, err);
2121     return;
2122
2123 out:
2124     v9fs_stat_free(&vs->v9stat);
2125     complete_pdu(s, vs->pdu, err);
2126     qemu_free(vs);
2127 }
2128
2129 static void v9fs_wstat_post_fsync(V9fsState *s, V9fsWstatState *vs, int err)
2130 {
2131     if (err == -1) {
2132         err = -errno;
2133     }
2134     v9fs_stat_free(&vs->v9stat);
2135     complete_pdu(s, vs->pdu, err);
2136     qemu_free(vs);
2137 }
2138
2139 static void v9fs_wstat_post_lstat(V9fsState *s, V9fsWstatState *vs, int err)
2140 {
2141     uint32_t v9_mode;
2142
2143     if (err == -1) {
2144         err = -errno;
2145         goto out;
2146     }
2147
2148     v9_mode = stat_to_v9mode(&vs->stbuf);
2149
2150     if ((vs->v9stat.mode & P9_STAT_MODE_TYPE_BITS) !=
2151         (v9_mode & P9_STAT_MODE_TYPE_BITS)) {
2152             /* Attempting to change the type */
2153             err = -EIO;
2154             goto out;
2155     }
2156
2157     if (v9fs_do_chmod(s, &vs->fidp->path, v9mode_to_mode(vs->v9stat.mode,
2158                     &vs->v9stat.extension))) {
2159             err = -errno;
2160      }
2161     v9fs_wstat_post_chmod(s, vs, err);
2162     return;
2163
2164 out:
2165     v9fs_stat_free(&vs->v9stat);
2166     complete_pdu(s, vs->pdu, err);
2167     qemu_free(vs);
2168 }
2169
2170 static void v9fs_wstat(V9fsState *s, V9fsPDU *pdu)
2171 {
2172     int32_t fid;
2173     V9fsWstatState *vs;
2174     int err = 0;
2175
2176     vs = qemu_malloc(sizeof(*vs));
2177     vs->pdu = pdu;
2178     vs->offset = 7;
2179
2180     pdu_unmarshal(pdu, vs->offset, "dwS", &fid, &vs->unused, &vs->v9stat);
2181
2182     vs->fidp = lookup_fid(s, fid);
2183     if (vs->fidp == NULL) {
2184         err = -EINVAL;
2185         goto out;
2186     }
2187
2188     /* do we need to sync the file? */
2189     if (donttouch_stat(&vs->v9stat)) {
2190         err = v9fs_do_fsync(s, vs->fidp->fd);
2191         v9fs_wstat_post_fsync(s, vs, err);
2192         return;
2193     }
2194
2195     if (vs->v9stat.mode != -1) {
2196         err = v9fs_do_lstat(s, &vs->fidp->path, &vs->stbuf);
2197         v9fs_wstat_post_lstat(s, vs, err);
2198         return;
2199     }
2200
2201     v9fs_wstat_post_chmod(s, vs, err);
2202     return;
2203
2204 out:
2205     v9fs_stat_free(&vs->v9stat);
2206     complete_pdu(s, vs->pdu, err);
2207     qemu_free(vs);
2208 }
2209
2210 typedef void (pdu_handler_t)(V9fsState *s, V9fsPDU *pdu);
2211
2212 static pdu_handler_t *pdu_handlers[] = {
2213     [P9_TVERSION] = v9fs_version,
2214     [P9_TATTACH] = v9fs_attach,
2215     [P9_TSTAT] = v9fs_stat,
2216     [P9_TWALK] = v9fs_walk,
2217     [P9_TCLUNK] = v9fs_clunk,
2218     [P9_TOPEN] = v9fs_open,
2219     [P9_TREAD] = v9fs_read,
2220 #if 0
2221     [P9_TAUTH] = v9fs_auth,
2222 #endif
2223     [P9_TFLUSH] = v9fs_flush,
2224     [P9_TCREATE] = v9fs_create,
2225     [P9_TWRITE] = v9fs_write,
2226     [P9_TWSTAT] = v9fs_wstat,
2227     [P9_TREMOVE] = v9fs_remove,
2228 };
2229
2230 static void submit_pdu(V9fsState *s, V9fsPDU *pdu)
2231 {
2232     pdu_handler_t *handler;
2233
2234     if (debug_9p_pdu) {
2235         pprint_pdu(pdu);
2236     }
2237
2238     BUG_ON(pdu->id >= ARRAY_SIZE(pdu_handlers));
2239
2240     handler = pdu_handlers[pdu->id];
2241     BUG_ON(handler == NULL);
2242
2243     handler(s, pdu);
2244 }
2245
2246 static void handle_9p_output(VirtIODevice *vdev, VirtQueue *vq)
2247 {
2248     V9fsState *s = (V9fsState *)vdev;
2249     V9fsPDU *pdu;
2250     ssize_t len;
2251
2252     while ((pdu = alloc_pdu(s)) &&
2253             (len = virtqueue_pop(vq, &pdu->elem)) != 0) {
2254         uint8_t *ptr;
2255
2256         BUG_ON(pdu->elem.out_num == 0 || pdu->elem.in_num == 0);
2257         BUG_ON(pdu->elem.out_sg[0].iov_len < 7);
2258
2259         ptr = pdu->elem.out_sg[0].iov_base;
2260
2261         memcpy(&pdu->size, ptr, 4);
2262         pdu->id = ptr[4];
2263         memcpy(&pdu->tag, ptr + 5, 2);
2264
2265         submit_pdu(s, pdu);
2266     }
2267
2268     free_pdu(s, pdu);
2269 }
2270
2271 static uint32_t virtio_9p_get_features(VirtIODevice *vdev, uint32_t features)
2272 {
2273     features |= 1 << VIRTIO_9P_MOUNT_TAG;
2274     return features;
2275 }
2276
2277 static V9fsState *to_virtio_9p(VirtIODevice *vdev)
2278 {
2279     return (V9fsState *)vdev;
2280 }
2281
2282 static void virtio_9p_get_config(VirtIODevice *vdev, uint8_t *config)
2283 {
2284     struct virtio_9p_config *cfg;
2285     V9fsState *s = to_virtio_9p(vdev);
2286
2287     cfg = qemu_mallocz(sizeof(struct virtio_9p_config) +
2288                         s->tag_len);
2289     stw_raw(&cfg->tag_len, s->tag_len);
2290     memcpy(cfg->tag, s->tag, s->tag_len);
2291     memcpy(config, cfg, s->config_size);
2292     qemu_free(cfg);
2293 }
2294
2295 VirtIODevice *virtio_9p_init(DeviceState *dev, V9fsConf *conf)
2296  {
2297     V9fsState *s;
2298     int i, len;
2299     struct stat stat;
2300     FsTypeEntry *fse;
2301
2302
2303     s = (V9fsState *)virtio_common_init("virtio-9p",
2304                                     VIRTIO_ID_9P,
2305                                     sizeof(struct virtio_9p_config)+
2306                                     MAX_TAG_LEN,
2307                                     sizeof(V9fsState));
2308
2309     /* initialize pdu allocator */
2310     QLIST_INIT(&s->free_list);
2311     for (i = 0; i < (MAX_REQ - 1); i++) {
2312         QLIST_INSERT_HEAD(&s->free_list, &s->pdus[i], next);
2313     }
2314
2315     s->vq = virtio_add_queue(&s->vdev, MAX_REQ, handle_9p_output);
2316
2317     fse = get_fsdev_fsentry(conf->fsdev_id);
2318
2319     if (!fse) {
2320         /* We don't have a fsdev identified by fsdev_id */
2321         fprintf(stderr, "Virtio-9p device couldn't find fsdev "
2322                     "with the id %s\n", conf->fsdev_id);
2323         exit(1);
2324     }
2325
2326     if (!fse->path || !conf->tag) {
2327         /* we haven't specified a mount_tag or the path */
2328         fprintf(stderr, "fsdev with id %s needs path "
2329                 "and Virtio-9p device needs mount_tag arguments\n",
2330                 conf->fsdev_id);
2331         exit(1);
2332     }
2333
2334     if (lstat(fse->path, &stat)) {
2335         fprintf(stderr, "share path %s does not exist\n", fse->path);
2336         exit(1);
2337     } else if (!S_ISDIR(stat.st_mode)) {
2338         fprintf(stderr, "share path %s is not a directory \n", fse->path);
2339         exit(1);
2340     }
2341
2342     s->ctx.fs_root = qemu_strdup(fse->path);
2343     len = strlen(conf->tag);
2344     if (len > MAX_TAG_LEN) {
2345         len = MAX_TAG_LEN;
2346     }
2347     /* s->tag is non-NULL terminated string */
2348     s->tag = qemu_malloc(len);
2349     memcpy(s->tag, conf->tag, len);
2350     s->tag_len = len;
2351     s->ctx.uid = -1;
2352
2353     s->ops = fse->ops;
2354     s->vdev.get_features = virtio_9p_get_features;
2355     s->config_size = sizeof(struct virtio_9p_config) +
2356                         s->tag_len;
2357     s->vdev.get_config = virtio_9p_get_config;
2358
2359     return &s->vdev;
2360 }