qemu/hw/9pfs/virtio-9p.c

   1 /*
   2  * Virtio 9p backend
   3  *
   4  * Copyright IBM, Corp. 2010
   5  *
   6  * Authors:
   7  *  Anthony Liguori   <aliguori@us.ibm.com>
   8  *
   9  * This work is licensed under the terms of the GNU GPL, version 2.  See
  10  * the COPYING file in the top-level directory.
  11  *
  12  */
  13
  14 #include "hw/virtio/virtio.h"
  15 #include "hw/i386/pc.h"
  16 #include "qemu/error-report.h"
  17 #include "qemu/iov.h"
  18 #include "qemu/sockets.h"
  19 #include "virtio-9p.h"
  20 #include "fsdev/qemu-fsdev.h"
  21 #include "virtio-9p-xattr.h"
  22 #include "virtio-9p-coth.h"
  23 #include "trace.h"
  24 #include "migration/migration.h"
  25
  26 int open_fd_hw;
  27 int total_open_fd;
  28 static int open_fd_rc;
  29
  30 enum {
  31     Oread   = 0x00,
  32     Owrite  = 0x01,
  33     Ordwr   = 0x02,
  34     Oexec   = 0x03,
  35     Oexcl   = 0x04,
  36     Otrunc  = 0x10,
  37     Orexec  = 0x20,
  38     Orclose = 0x40,
  39     Oappend = 0x80,
  40 };
  41
  42 static int omode_to_uflags(int8_t mode)
  43 {
  44     int ret = 0;
  45
  46     switch (mode & 3) {
  47     case Oread:
  48         ret = O_RDONLY;
  49         break;
  50     case Ordwr:
  51         ret = O_RDWR;
  52         break;
  53     case Owrite:
  54         ret = O_WRONLY;
  55         break;
  56     case Oexec:
  57         ret = O_RDONLY;
  58         break;
  59     }
  60
  61     if (mode & Otrunc) {
  62         ret |= O_TRUNC;
  63     }
  64
  65     if (mode & Oappend) {
  66         ret |= O_APPEND;
  67     }
  68
  69     if (mode & Oexcl) {
  70         ret |= O_EXCL;
  71     }
  72
  73     return ret;
  74 }
  75
  76 struct dotl_openflag_map {
  77     int dotl_flag;
  78     int open_flag;
  79 };
  80
  81 static int dotl_to_open_flags(int flags)
  82 {
  83     int i;
  84     /*
  85      * We have same bits for P9_DOTL_READONLY, P9_DOTL_WRONLY
  86      * and P9_DOTL_NOACCESS
  87      */
  88     int oflags = flags & O_ACCMODE;
  89
  90     struct dotl_openflag_map dotl_oflag_map[] = {
  91         { P9_DOTL_CREATE, O_CREAT },
  92         { P9_DOTL_EXCL, O_EXCL },
  93         { P9_DOTL_NOCTTY , O_NOCTTY },
  94         { P9_DOTL_TRUNC, O_TRUNC },
  95         { P9_DOTL_APPEND, O_APPEND },
  96         { P9_DOTL_NONBLOCK, O_NONBLOCK } ,
  97         { P9_DOTL_DSYNC, O_DSYNC },
  98         { P9_DOTL_FASYNC, FASYNC },
  99         { P9_DOTL_DIRECT, O_DIRECT },
 100         { P9_DOTL_LARGEFILE, O_LARGEFILE },
 101         { P9_DOTL_DIRECTORY, O_DIRECTORY },
 102         { P9_DOTL_NOFOLLOW, O_NOFOLLOW },
 103         { P9_DOTL_NOATIME, O_NOATIME },
 104         { P9_DOTL_SYNC, O_SYNC },
 105     };
 106
 107     for (i = 0; i < ARRAY_SIZE(dotl_oflag_map); i++) {
 108         if (flags & dotl_oflag_map[i].dotl_flag) {
 109             oflags |= dotl_oflag_map[i].open_flag;
 110         }
 111     }
 112
 113     return oflags;
 114 }
 115
 116 void cred_init(FsCred *credp)
 117 {
 118     credp->fc_uid = -1;
 119     credp->fc_gid = -1;
 120     credp->fc_mode = -1;
 121     credp->fc_rdev = -1;
 122 }
 123
 124 static int get_dotl_openflags(V9fsState *s, int oflags)
 125 {
 126     int flags;
 127     /*
 128      * Filter the client open flags
 129      */
 130     flags = dotl_to_open_flags(oflags);
 131     flags &= ~(O_NOCTTY | O_ASYNC | O_CREAT);
 132     /*
 133      * Ignore direct disk access hint until the server supports it.
 134      */
 135     flags &= ~O_DIRECT;
 136     return flags;
 137 }
 138
 139 void v9fs_path_init(V9fsPath *path)
 140 {
 141     path->data = NULL;
 142     path->size = 0;
 143 }
 144
 145 void v9fs_path_free(V9fsPath *path)
 146 {
 147     g_free(path->data);
 148     path->data = NULL;
 149     path->size = 0;
 150 }
 151
 152 void v9fs_path_copy(V9fsPath *lhs, V9fsPath *rhs)
 153 {
 154     v9fs_path_free(lhs);
 155     lhs->data = g_malloc(rhs->size);
 156     memcpy(lhs->data, rhs->data, rhs->size);
 157     lhs->size = rhs->size;
 158 }
 159
 160 int v9fs_name_to_path(V9fsState *s, V9fsPath *dirpath,
 161                       const char *name, V9fsPath *path)
 162 {
 163     int err;
 164     err = s->ops->name_to_path(&s->ctx, dirpath, name, path);
 165     if (err < 0) {
 166         err = -errno;
 167     }
 168     return err;
 169 }
 170
 171 /*
 172  * Return TRUE if s1 is an ancestor of s2.
 173  *
 174  * E.g. "a/b" is an ancestor of "a/b/c" but not of "a/bc/d".
 175  * As a special case, We treat s1 as ancestor of s2 if they are same!
 176  */
 177 static int v9fs_path_is_ancestor(V9fsPath *s1, V9fsPath *s2)
 178 {
 179     if (!strncmp(s1->data, s2->data, s1->size - 1)) {
 180         if (s2->data[s1->size - 1] == '\0' || s2->data[s1->size - 1] == '/') {
 181             return 1;
 182         }
 183     }
 184     return 0;
 185 }
 186
 187 static size_t v9fs_string_size(V9fsString *str)
 188 {
 189     return str->size;
 190 }
 191
 192 /*
 193  * returns 0 if fid got re-opened, 1 if not, < 0 on error */
 194 static int v9fs_reopen_fid(V9fsPDU *pdu, V9fsFidState *f)
 195 {
 196     int err = 1;
 197     if (f->fid_type == P9_FID_FILE) {
 198         if (f->fs.fd == -1) {
 199             do {
 200                 err = v9fs_co_open(pdu, f, f->open_flags);
 201             } while (err == -EINTR && !pdu->cancelled);
 202         }
 203     } else if (f->fid_type == P9_FID_DIR) {
 204         if (f->fs.dir == NULL) {
 205             do {
 206                 err = v9fs_co_opendir(pdu, f);
 207             } while (err == -EINTR && !pdu->cancelled);
 208         }
 209     }
 210     return err;
 211 }
 212
 213 static V9fsFidState *get_fid(V9fsPDU *pdu, int32_t fid)
 214 {
 215     int err;
 216     V9fsFidState *f;
 217     V9fsState *s = pdu->s;
 218
 219     for (f = s->fid_list; f; f = f->next) {
 220         BUG_ON(f->clunked);
 221         if (f->fid == fid) {
 222             /*
 223              * Update the fid ref upfront so that
 224              * we don't get reclaimed when we yield
 225              * in open later.
 226              */
 227             f->ref++;
 228             /*
 229              * check whether we need to reopen the
 230              * file. We might have closed the fd
 231              * while trying to free up some file
 232              * descriptors.
 233              */
 234             err = v9fs_reopen_fid(pdu, f);
 235             if (err < 0) {
 236                 f->ref--;
 237                 return NULL;
 238             }
 239             /*
 240              * Mark the fid as referenced so that the LRU
 241              * reclaim won't close the file descriptor
 242              */
 243             f->flags |= FID_REFERENCED;
 244             return f;
 245         }
 246     }
 247     return NULL;
 248 }
 249
 250 static V9fsFidState *alloc_fid(V9fsState *s, int32_t fid)
 251 {
 252     V9fsFidState *f;
 253
 254     for (f = s->fid_list; f; f = f->next) {
 255         /* If fid is already there return NULL */
 256         BUG_ON(f->clunked);
 257         if (f->fid == fid) {
 258             return NULL;
 259         }
 260     }
 261     f = g_malloc0(sizeof(V9fsFidState));
 262     f->fid = fid;
 263     f->fid_type = P9_FID_NONE;
 264     f->ref = 1;
 265     /*
 266      * Mark the fid as referenced so that the LRU
 267      * reclaim won't close the file descriptor
 268      */
 269     f->flags |= FID_REFERENCED;
 270     f->next = s->fid_list;
 271     s->fid_list = f;
 272
 273     return f;
 274 }
 275
 276 static int v9fs_xattr_fid_clunk(V9fsPDU *pdu, V9fsFidState *fidp)
 277 {
 278     int retval = 0;
 279
 280     if (fidp->fs.xattr.copied_len == -1) {
 281         /* getxattr/listxattr fid */
 282         goto free_value;
 283     }
 284     /*
 285      * if this is fid for setxattr. clunk should
 286      * result in setxattr localcall
 287      */
 288     if (fidp->fs.xattr.len != fidp->fs.xattr.copied_len) {
 289         /* clunk after partial write */
 290         retval = -EINVAL;
 291         goto free_out;
 292     }
 293     if (fidp->fs.xattr.len) {
 294         retval = v9fs_co_lsetxattr(pdu, &fidp->path, &fidp->fs.xattr.name,
 295                                    fidp->fs.xattr.value,
 296                                    fidp->fs.xattr.len,
 297                                    fidp->fs.xattr.flags);
 298     } else {
 299         retval = v9fs_co_lremovexattr(pdu, &fidp->path, &fidp->fs.xattr.name);
 300     }
 301 free_out:
 302     v9fs_string_free(&fidp->fs.xattr.name);
 303 free_value:
 304     g_free(fidp->fs.xattr.value);
 305     return retval;
 306 }
 307
 308 static int free_fid(V9fsPDU *pdu, V9fsFidState *fidp)
 309 {
 310     int retval = 0;
 311
 312     if (fidp->fid_type == P9_FID_FILE) {
 313         /* If we reclaimed the fd no need to close */
 314         if (fidp->fs.fd != -1) {
 315             retval = v9fs_co_close(pdu, &fidp->fs);
 316         }
 317     } else if (fidp->fid_type == P9_FID_DIR) {
 318         if (fidp->fs.dir != NULL) {
 319             retval = v9fs_co_closedir(pdu, &fidp->fs);
 320         }
 321     } else if (fidp->fid_type == P9_FID_XATTR) {
 322         retval = v9fs_xattr_fid_clunk(pdu, fidp);
 323     }
 324     v9fs_path_free(&fidp->path);
 325     g_free(fidp);
 326     return retval;
 327 }
 328
 329 static int put_fid(V9fsPDU *pdu, V9fsFidState *fidp)
 330 {
 331     BUG_ON(!fidp->ref);
 332     fidp->ref--;
 333     /*
 334      * Don't free the fid if it is in reclaim list
 335      */
 336     if (!fidp->ref && fidp->clunked) {
 337         if (fidp->fid == pdu->s->root_fid) {
 338             /*
 339              * if the clunked fid is root fid then we
 340              * have unmounted the fs on the client side.
 341              * delete the migration blocker. Ideally, this
 342              * should be hooked to transport close notification
 343              */
 344             if (pdu->s->migration_blocker) {
 345                 migrate_del_blocker(pdu->s->migration_blocker);
 346                 error_free(pdu->s->migration_blocker);
 347                 pdu->s->migration_blocker = NULL;
 348             }
 349         }
 350         return free_fid(pdu, fidp);
 351     }
 352     return 0;
 353 }
 354
 355 static V9fsFidState *clunk_fid(V9fsState *s, int32_t fid)
 356 {
 357     V9fsFidState **fidpp, *fidp;
 358
 359     for (fidpp = &s->fid_list; *fidpp; fidpp = &(*fidpp)->next) {
 360         if ((*fidpp)->fid == fid) {
 361             break;
 362         }
 363     }
 364     if (*fidpp == NULL) {
 365         return NULL;
 366     }
 367     fidp = *fidpp;
 368     *fidpp = fidp->next;
 369     fidp->clunked = 1;
 370     return fidp;
 371 }
 372
 373 void v9fs_reclaim_fd(V9fsPDU *pdu)
 374 {
 375     int reclaim_count = 0;
 376     V9fsState *s = pdu->s;
 377     V9fsFidState *f, *reclaim_list = NULL;
 378
 379     for (f = s->fid_list; f; f = f->next) {
 380         /*
 381          * Unlink fids cannot be reclaimed. Check
 382          * for them and skip them. Also skip fids
 383          * currently being operated on.
 384          */
 385         if (f->ref || f->flags & FID_NON_RECLAIMABLE) {
 386             continue;
 387         }
 388         /*
 389          * if it is a recently referenced fid
 390          * we leave the fid untouched and clear the
 391          * reference bit. We come back to it later
 392          * in the next iteration. (a simple LRU without
 393          * moving list elements around)
 394          */
 395         if (f->flags & FID_REFERENCED) {
 396             f->flags &= ~FID_REFERENCED;
 397             continue;
 398         }
 399         /*
 400          * Add fids to reclaim list.
 401          */
 402         if (f->fid_type == P9_FID_FILE) {
 403             if (f->fs.fd != -1) {
 404                 /*
 405                  * Up the reference count so that
 406                  * a clunk request won't free this fid
 407                  */
 408                 f->ref++;
 409                 f->rclm_lst = reclaim_list;
 410                 reclaim_list = f;
 411                 f->fs_reclaim.fd = f->fs.fd;
 412                 f->fs.fd = -1;
 413                 reclaim_count++;
 414             }
 415         } else if (f->fid_type == P9_FID_DIR) {
 416             if (f->fs.dir != NULL) {
 417                 /*
 418                  * Up the reference count so that
 419                  * a clunk request won't free this fid
 420                  */
 421                 f->ref++;
 422                 f->rclm_lst = reclaim_list;
 423                 reclaim_list = f;
 424                 f->fs_reclaim.dir = f->fs.dir;
 425                 f->fs.dir = NULL;
 426                 reclaim_count++;
 427             }
 428         }
 429         if (reclaim_count >= open_fd_rc) {
 430             break;
 431         }
 432     }
 433     /*
 434      * Now close the fid in reclaim list. Free them if they
 435      * are already clunked.
 436      */
 437     while (reclaim_list) {
 438         f = reclaim_list;
 439         reclaim_list = f->rclm_lst;
 440         if (f->fid_type == P9_FID_FILE) {
 441             v9fs_co_close(pdu, &f->fs_reclaim);
 442         } else if (f->fid_type == P9_FID_DIR) {
 443             v9fs_co_closedir(pdu, &f->fs_reclaim);
 444         }
 445         f->rclm_lst = NULL;
 446         /*
 447          * Now drop the fid reference, free it
 448          * if clunked.
 449          */
 450         put_fid(pdu, f);
 451     }
 452 }
 453
 454 static int v9fs_mark_fids_unreclaim(V9fsPDU *pdu, V9fsPath *path)
 455 {
 456     int err;
 457     V9fsState *s = pdu->s;
 458     V9fsFidState *fidp, head_fid;
 459
 460     head_fid.next = s->fid_list;
 461     for (fidp = s->fid_list; fidp; fidp = fidp->next) {
 462         if (fidp->path.size != path->size) {
 463             continue;
 464         }
 465         if (!memcmp(fidp->path.data, path->data, path->size)) {
 466             /* Mark the fid non reclaimable. */
 467             fidp->flags |= FID_NON_RECLAIMABLE;
 468
 469             /* reopen the file/dir if already closed */
 470             err = v9fs_reopen_fid(pdu, fidp);
 471             if (err < 0) {
 472                 return -1;
 473             }
 474             /*
 475              * Go back to head of fid list because
 476              * the list could have got updated when
 477              * switched to the worker thread
 478              */
 479             if (err == 0) {
 480                 fidp = &head_fid;
 481             }
 482         }
 483     }
 484     return 0;
 485 }
 486
 487 static void virtfs_reset(V9fsPDU *pdu)
 488 {
 489     V9fsState *s = pdu->s;
 490     V9fsFidState *fidp = NULL;
 491
 492     /* Free all fids */
 493     while (s->fid_list) {
 494         fidp = s->fid_list;
 495         s->fid_list = fidp->next;
 496
 497         if (fidp->ref) {
 498             fidp->clunked = 1;
 499         } else {
 500             free_fid(pdu, fidp);
 501         }
 502     }
 503     if (fidp) {
 504         /* One or more unclunked fids found... */
 505         error_report("9pfs:%s: One or more uncluncked fids "
 506                      "found during reset", __func__);
 507     }
 508 }
 509
 510 #define P9_QID_TYPE_DIR         0x80
 511 #define P9_QID_TYPE_SYMLINK     0x02
 512
 513 #define P9_STAT_MODE_DIR        0x80000000
 514 #define P9_STAT_MODE_APPEND     0x40000000
 515 #define P9_STAT_MODE_EXCL       0x20000000
 516 #define P9_STAT_MODE_MOUNT      0x10000000
 517 #define P9_STAT_MODE_AUTH       0x08000000
 518 #define P9_STAT_MODE_TMP        0x04000000
 519 #define P9_STAT_MODE_SYMLINK    0x02000000
 520 #define P9_STAT_MODE_LINK       0x01000000
 521 #define P9_STAT_MODE_DEVICE     0x00800000
 522 #define P9_STAT_MODE_NAMED_PIPE 0x00200000
 523 #define P9_STAT_MODE_SOCKET     0x00100000
 524 #define P9_STAT_MODE_SETUID     0x00080000
 525 #define P9_STAT_MODE_SETGID     0x00040000
 526 #define P9_STAT_MODE_SETVTX     0x00010000
 527
 528 #define P9_STAT_MODE_TYPE_BITS (P9_STAT_MODE_DIR |          \
 529                                 P9_STAT_MODE_SYMLINK |      \
 530                                 P9_STAT_MODE_LINK |         \
 531                                 P9_STAT_MODE_DEVICE |       \
 532                                 P9_STAT_MODE_NAMED_PIPE |   \
 533                                 P9_STAT_MODE_SOCKET)
 534
 535 /* This is the algorithm from ufs in spfs */
 536 static void stat_to_qid(const struct stat *stbuf, V9fsQID *qidp)
 537 {
 538     size_t size;
 539
 540     memset(&qidp->path, 0, sizeof(qidp->path));
 541     size = MIN(sizeof(stbuf->st_ino), sizeof(qidp->path));
 542     memcpy(&qidp->path, &stbuf->st_ino, size);
 543     qidp->version = stbuf->st_mtime ^ (stbuf->st_size << 8);
 544     qidp->type = 0;
 545     if (S_ISDIR(stbuf->st_mode)) {
 546         qidp->type |= P9_QID_TYPE_DIR;
 547     }
 548     if (S_ISLNK(stbuf->st_mode)) {
 549         qidp->type |= P9_QID_TYPE_SYMLINK;
 550     }
 551 }
 552
 553 static int fid_to_qid(V9fsPDU *pdu, V9fsFidState *fidp, V9fsQID *qidp)
 554 {
 555     struct stat stbuf;
 556     int err;
 557
 558     err = v9fs_co_lstat(pdu, &fidp->path, &stbuf);
 559     if (err < 0) {
 560         return err;
 561     }
 562     stat_to_qid(&stbuf, qidp);
 563     return 0;
 564 }
 565
 566 static V9fsPDU *alloc_pdu(V9fsState *s)
 567 {
 568     V9fsPDU *pdu = NULL;
 569
 570     if (!QLIST_EMPTY(&s->free_list)) {
 571         pdu = QLIST_FIRST(&s->free_list);
 572         QLIST_REMOVE(pdu, next);
 573         QLIST_INSERT_HEAD(&s->active_list, pdu, next);
 574     }
 575     return pdu;
 576 }
 577
 578 static void free_pdu(V9fsState *s, V9fsPDU *pdu)
 579 {
 580     if (pdu) {
 581         /*
 582          * Cancelled pdu are added back to the freelist
 583          * by flush request .
 584          */
 585         if (!pdu->cancelled) {
 586             QLIST_REMOVE(pdu, next);
 587             QLIST_INSERT_HEAD(&s->free_list, pdu, next);
 588         }
 589     }
 590 }
 591
 592 /*
 593  * We don't do error checking for pdu_marshal/unmarshal here
 594  * because we always expect to have enough space to encode
 595  * error details
 596  */
 597 static void complete_pdu(V9fsState *s, V9fsPDU *pdu, ssize_t len)
 598 {
 599     int8_t id = pdu->id + 1; /* Response */
 600
 601     if (len < 0) {
 602         int err = -len;
 603         len = 7;
 604
 605         if (s->proto_version != V9FS_PROTO_2000L) {
 606             V9fsString str;
 607
 608             str.data = strerror(err);
 609             str.size = strlen(str.data);
 610
 611             len += pdu_marshal(pdu, len, "s", &str);
 612             id = P9_RERROR;
 613         }
 614
 615         len += pdu_marshal(pdu, len, "d", err);
 616
 617         if (s->proto_version == V9FS_PROTO_2000L) {
 618             id = P9_RLERROR;
 619         }
 620         trace_v9fs_rerror(pdu->tag, pdu->id, err); /* Trace ERROR */
 621     }
 622
 623     /* fill out the header */
 624     pdu_marshal(pdu, 0, "dbw", (int32_t)len, id, pdu->tag);
 625
 626     /* keep these in sync */
 627     pdu->size = len;
 628     pdu->id = id;
 629
 630     /* push onto queue and notify */
 631     virtqueue_push(s->vq, &pdu->elem, len);
 632
 633     /* FIXME: we should batch these completions */
 634     virtio_notify(VIRTIO_DEVICE(s), s->vq);
 635
 636     /* Now wakeup anybody waiting in flush for this request */
 637     qemu_co_queue_next(&pdu->complete);
 638
 639     free_pdu(s, pdu);
 640 }
 641
 642 static mode_t v9mode_to_mode(uint32_t mode, V9fsString *extension)
 643 {
 644     mode_t ret;
 645
 646     ret = mode & 0777;
 647     if (mode & P9_STAT_MODE_DIR) {
 648         ret |= S_IFDIR;
 649     }
 650
 651     if (mode & P9_STAT_MODE_SYMLINK) {
 652         ret |= S_IFLNK;
 653     }
 654     if (mode & P9_STAT_MODE_SOCKET) {
 655         ret |= S_IFSOCK;
 656     }
 657     if (mode & P9_STAT_MODE_NAMED_PIPE) {
 658         ret |= S_IFIFO;
 659     }
 660     if (mode & P9_STAT_MODE_DEVICE) {
 661         if (extension->size && extension->data[0] == 'c') {
 662             ret |= S_IFCHR;
 663         } else {
 664             ret |= S_IFBLK;
 665         }
 666     }
 667
 668     if (!(ret&~0777)) {
 669         ret |= S_IFREG;
 670     }
 671
 672     if (mode & P9_STAT_MODE_SETUID) {
 673         ret |= S_ISUID;
 674     }
 675     if (mode & P9_STAT_MODE_SETGID) {
 676         ret |= S_ISGID;
 677     }
 678     if (mode & P9_STAT_MODE_SETVTX) {
 679         ret |= S_ISVTX;
 680     }
 681
 682     return ret;
 683 }
 684
 685 static int donttouch_stat(V9fsStat *stat)
 686 {
 687     if (stat->type == -1 &&
 688         stat->dev == -1 &&
 689         stat->qid.type == -1 &&
 690         stat->qid.version == -1 &&
 691         stat->qid.path == -1 &&
 692         stat->mode == -1 &&
 693         stat->atime == -1 &&
 694         stat->mtime == -1 &&
 695         stat->length == -1 &&
 696         !stat->name.size &&
 697         !stat->uid.size &&
 698         !stat->gid.size &&
 699         !stat->muid.size &&
 700         stat->n_uid == -1 &&
 701         stat->n_gid == -1 &&
 702         stat->n_muid == -1) {
 703         return 1;
 704     }
 705
 706     return 0;
 707 }
 708
 709 static void v9fs_stat_init(V9fsStat *stat)
 710 {
 711     v9fs_string_init(&stat->name);
 712     v9fs_string_init(&stat->uid);
 713     v9fs_string_init(&stat->gid);
 714     v9fs_string_init(&stat->muid);
 715     v9fs_string_init(&stat->extension);
 716 }
 717
 718 static void v9fs_stat_free(V9fsStat *stat)
 719 {
 720     v9fs_string_free(&stat->name);
 721     v9fs_string_free(&stat->uid);
 722     v9fs_string_free(&stat->gid);
 723     v9fs_string_free(&stat->muid);
 724     v9fs_string_free(&stat->extension);
 725 }
 726
 727 static uint32_t stat_to_v9mode(const struct stat *stbuf)
 728 {
 729     uint32_t mode;
 730
 731     mode = stbuf->st_mode & 0777;
 732     if (S_ISDIR(stbuf->st_mode)) {
 733         mode |= P9_STAT_MODE_DIR;
 734     }
 735
 736     if (S_ISLNK(stbuf->st_mode)) {
 737         mode |= P9_STAT_MODE_SYMLINK;
 738     }
 739
 740     if (S_ISSOCK(stbuf->st_mode)) {
 741         mode |= P9_STAT_MODE_SOCKET;
 742     }
 743
 744     if (S_ISFIFO(stbuf->st_mode)) {
 745         mode |= P9_STAT_MODE_NAMED_PIPE;
 746     }
 747
 748     if (S_ISBLK(stbuf->st_mode) || S_ISCHR(stbuf->st_mode)) {
 749         mode |= P9_STAT_MODE_DEVICE;
 750     }
 751
 752     if (stbuf->st_mode & S_ISUID) {
 753         mode |= P9_STAT_MODE_SETUID;
 754     }
 755
 756     if (stbuf->st_mode & S_ISGID) {
 757         mode |= P9_STAT_MODE_SETGID;
 758     }
 759
 760     if (stbuf->st_mode & S_ISVTX) {
 761         mode |= P9_STAT_MODE_SETVTX;
 762     }
 763
 764     return mode;
 765 }
 766
 767 static int stat_to_v9stat(V9fsPDU *pdu, V9fsPath *name,
 768                             const struct stat *stbuf,
 769                             V9fsStat *v9stat)
 770 {
 771     int err;
 772     const char *str;
 773
 774     memset(v9stat, 0, sizeof(*v9stat));
 775
 776     stat_to_qid(stbuf, &v9stat->qid);
 777     v9stat->mode = stat_to_v9mode(stbuf);
 778     v9stat->atime = stbuf->st_atime;
 779     v9stat->mtime = stbuf->st_mtime;
 780     v9stat->length = stbuf->st_size;
 781
 782     v9fs_string_null(&v9stat->uid);
 783     v9fs_string_null(&v9stat->gid);
 784     v9fs_string_null(&v9stat->muid);
 785
 786     v9stat->n_uid = stbuf->st_uid;
 787     v9stat->n_gid = stbuf->st_gid;
 788     v9stat->n_muid = 0;
 789
 790     v9fs_string_null(&v9stat->extension);
 791
 792     if (v9stat->mode & P9_STAT_MODE_SYMLINK) {
 793         err = v9fs_co_readlink(pdu, name, &v9stat->extension);
 794         if (err < 0) {
 795             return err;
 796         }
 797     } else if (v9stat->mode & P9_STAT_MODE_DEVICE) {
 798         v9fs_string_sprintf(&v9stat->extension, "%c %u %u",
 799                 S_ISCHR(stbuf->st_mode) ? 'c' : 'b',
 800                 major(stbuf->st_rdev), minor(stbuf->st_rdev));
 801     } else if (S_ISDIR(stbuf->st_mode) || S_ISREG(stbuf->st_mode)) {
 802         v9fs_string_sprintf(&v9stat->extension, "%s %lu",
 803                 "HARDLINKCOUNT", (unsigned long)stbuf->st_nlink);
 804     }
 805
 806     str = strrchr(name->data, '/');
 807     if (str) {
 808         str += 1;
 809     } else {
 810         str = name->data;
 811     }
 812
 813     v9fs_string_sprintf(&v9stat->name, "%s", str);
 814
 815     v9stat->size = 61 +
 816         v9fs_string_size(&v9stat->name) +
 817         v9fs_string_size(&v9stat->uid) +
 818         v9fs_string_size(&v9stat->gid) +
 819         v9fs_string_size(&v9stat->muid) +
 820         v9fs_string_size(&v9stat->extension);
 821     return 0;
 822 }
 823
 824 #define P9_STATS_MODE          0x00000001ULL
 825 #define P9_STATS_NLINK         0x00000002ULL
 826 #define P9_STATS_UID           0x00000004ULL
 827 #define P9_STATS_GID           0x00000008ULL
 828 #define P9_STATS_RDEV          0x00000010ULL
 829 #define P9_STATS_ATIME         0x00000020ULL
 830 #define P9_STATS_MTIME         0x00000040ULL
 831 #define P9_STATS_CTIME         0x00000080ULL
 832 #define P9_STATS_INO           0x00000100ULL
 833 #define P9_STATS_SIZE          0x00000200ULL
 834 #define P9_STATS_BLOCKS        0x00000400ULL
 835
 836 #define P9_STATS_BTIME         0x00000800ULL
 837 #define P9_STATS_GEN           0x00001000ULL
 838 #define P9_STATS_DATA_VERSION  0x00002000ULL
 839
 840 #define P9_STATS_BASIC         0x000007ffULL /* Mask for fields up to BLOCKS */
 841 #define P9_STATS_ALL           0x00003fffULL /* Mask for All fields above */
 842
 843
 844 static void stat_to_v9stat_dotl(V9fsState *s, const struct stat *stbuf,
 845                                 V9fsStatDotl *v9lstat)
 846 {
 847     memset(v9lstat, 0, sizeof(*v9lstat));
 848
 849     v9lstat->st_mode = stbuf->st_mode;
 850     v9lstat->st_nlink = stbuf->st_nlink;
 851     v9lstat->st_uid = stbuf->st_uid;
 852     v9lstat->st_gid = stbuf->st_gid;
 853     v9lstat->st_rdev = stbuf->st_rdev;
 854     v9lstat->st_size = stbuf->st_size;
 855     v9lstat->st_blksize = stbuf->st_blksize;
 856     v9lstat->st_blocks = stbuf->st_blocks;
 857     v9lstat->st_atime_sec = stbuf->st_atime;
 858     v9lstat->st_atime_nsec = stbuf->st_atim.tv_nsec;
 859     v9lstat->st_mtime_sec = stbuf->st_mtime;
 860     v9lstat->st_mtime_nsec = stbuf->st_mtim.tv_nsec;
 861     v9lstat->st_ctime_sec = stbuf->st_ctime;
 862     v9lstat->st_ctime_nsec = stbuf->st_ctim.tv_nsec;
 863     /* Currently we only support BASIC fields in stat */
 864     v9lstat->st_result_mask = P9_STATS_BASIC;
 865
 866     stat_to_qid(stbuf, &v9lstat->qid);
 867 }
 868
 869 static void print_sg(struct iovec *sg, int cnt)
 870 {
 871     int i;
 872
 873     printf("sg[%d]: {", cnt);
 874     for (i = 0; i < cnt; i++) {
 875         if (i) {
 876             printf(", ");
 877         }
 878         printf("(%p, %zd)", sg[i].iov_base, sg[i].iov_len);
 879     }
 880     printf("}\n");
 881 }
 882
 883 /* Will call this only for path name based fid */
 884 static void v9fs_fix_path(V9fsPath *dst, V9fsPath *src, int len)
 885 {
 886     V9fsPath str;
 887     v9fs_path_init(&str);
 888     v9fs_path_copy(&str, dst);
 889     v9fs_string_sprintf((V9fsString *)dst, "%s%s", src->data, str.data+len);
 890     v9fs_path_free(&str);
 891     /* +1 to include terminating NULL */
 892     dst->size++;
 893 }
 894
 895 static inline bool is_ro_export(FsContext *ctx)
 896 {
 897     return ctx->export_flags & V9FS_RDONLY;
 898 }
 899
 900 static void v9fs_version(void *opaque)
 901 {
 902     ssize_t err;
 903     V9fsPDU *pdu = opaque;
 904     V9fsState *s = pdu->s;
 905     V9fsString version;
 906     size_t offset = 7;
 907
 908     v9fs_string_init(&version);
 909     err = pdu_unmarshal(pdu, offset, "ds", &s->msize, &version);
 910     if (err < 0) {
 911         offset = err;
 912         goto out;
 913     }
 914     trace_v9fs_version(pdu->tag, pdu->id, s->msize, version.data);
 915
 916     virtfs_reset(pdu);
 917
 918     if (!strcmp(version.data, "9P2000.u")) {
 919         s->proto_version = V9FS_PROTO_2000U;
 920     } else if (!strcmp(version.data, "9P2000.L")) {
 921         s->proto_version = V9FS_PROTO_2000L;
 922     } else {
 923         v9fs_string_sprintf(&version, "unknown");
 924     }
 925
 926     err = pdu_marshal(pdu, offset, "ds", s->msize, &version);
 927     if (err < 0) {
 928         offset = err;
 929         goto out;
 930     }
 931     offset += err;
 932     trace_v9fs_version_return(pdu->tag, pdu->id, s->msize, version.data);
 933 out:
 934     complete_pdu(s, pdu, offset);
 935     v9fs_string_free(&version);
 936 }
 937
 938 static void v9fs_attach(void *opaque)
 939 {
 940     V9fsPDU *pdu = opaque;
 941     V9fsState *s = pdu->s;
 942     int32_t fid, afid, n_uname;
 943     V9fsString uname, aname;
 944     V9fsFidState *fidp;
 945     size_t offset = 7;
 946     V9fsQID qid;
 947     ssize_t err;
 948
 949     v9fs_string_init(&uname);
 950     v9fs_string_init(&aname);
 951     err = pdu_unmarshal(pdu, offset, "ddssd", &fid,
 952                         &afid, &uname, &aname, &n_uname);
 953     if (err < 0) {
 954         goto out_nofid;
 955     }
 956     trace_v9fs_attach(pdu->tag, pdu->id, fid, afid, uname.data, aname.data);
 957
 958     fidp = alloc_fid(s, fid);
 959     if (fidp == NULL) {
 960         err = -EINVAL;
 961         goto out_nofid;
 962     }
 963     fidp->uid = n_uname;
 964     err = v9fs_co_name_to_path(pdu, NULL, "/", &fidp->path);
 965     if (err < 0) {
 966         err = -EINVAL;
 967         clunk_fid(s, fid);
 968         goto out;
 969     }
 970     err = fid_to_qid(pdu, fidp, &qid);
 971     if (err < 0) {
 972         err = -EINVAL;
 973         clunk_fid(s, fid);
 974         goto out;
 975     }
 976     err = pdu_marshal(pdu, offset, "Q", &qid);
 977     if (err < 0) {
 978         clunk_fid(s, fid);
 979         goto out;
 980     }
 981     err += offset;
 982     trace_v9fs_attach_return(pdu->tag, pdu->id,
 983                              qid.type, qid.version, qid.path);
 984     /*
 985      * disable migration if we haven't done already.
 986      * attach could get called multiple times for the same export.
 987      */
 988     if (!s->migration_blocker) {
 989         s->root_fid = fid;
 990         error_setg(&s->migration_blocker,
 991                    "Migration is disabled when VirtFS export path '%s' is mounted in the guest using mount_tag '%s'",
 992                    s->ctx.fs_root ? s->ctx.fs_root : "NULL", s->tag);
 993         migrate_add_blocker(s->migration_blocker);
 994     }
 995 out:
 996     put_fid(pdu, fidp);
 997 out_nofid:
 998     complete_pdu(s, pdu, err);
 999     v9fs_string_free(&uname);
1000     v9fs_string_free(&aname);
1001 }
1002
1003 static void v9fs_stat(void *opaque)
1004 {
1005     int32_t fid;
1006     V9fsStat v9stat;
1007     ssize_t err = 0;
1008     size_t offset = 7;
1009     struct stat stbuf;
1010     V9fsFidState *fidp;
1011     V9fsPDU *pdu = opaque;
1012     V9fsState *s = pdu->s;
1013
1014     err = pdu_unmarshal(pdu, offset, "d", &fid);
1015     if (err < 0) {
1016         goto out_nofid;
1017     }
1018     trace_v9fs_stat(pdu->tag, pdu->id, fid);
1019
1020     fidp = get_fid(pdu, fid);
1021     if (fidp == NULL) {
1022         err = -ENOENT;
1023         goto out_nofid;
1024     }
1025     err = v9fs_co_lstat(pdu, &fidp->path, &stbuf);
1026     if (err < 0) {
1027         goto out;
1028     }
1029     err = stat_to_v9stat(pdu, &fidp->path, &stbuf, &v9stat);
1030     if (err < 0) {
1031         goto out;
1032     }
1033     err = pdu_marshal(pdu, offset, "wS", 0, &v9stat);
1034     if (err < 0) {
1035         v9fs_stat_free(&v9stat);
1036         goto out;
1037     }
1038     trace_v9fs_stat_return(pdu->tag, pdu->id, v9stat.mode,
1039                            v9stat.atime, v9stat.mtime, v9stat.length);
1040     err += offset;
1041     v9fs_stat_free(&v9stat);
1042 out:
1043     put_fid(pdu, fidp);
1044 out_nofid:
1045     complete_pdu(s, pdu, err);
1046 }
1047
1048 static void v9fs_getattr(void *opaque)
1049 {
1050     int32_t fid;
1051     size_t offset = 7;
1052     ssize_t retval = 0;
1053     struct stat stbuf;
1054     V9fsFidState *fidp;
1055     uint64_t request_mask;
1056     V9fsStatDotl v9stat_dotl;
1057     V9fsPDU *pdu = opaque;
1058     V9fsState *s = pdu->s;
1059
1060     retval = pdu_unmarshal(pdu, offset, "dq", &fid, &request_mask);
1061     if (retval < 0) {
1062         goto out_nofid;
1063     }
1064     trace_v9fs_getattr(pdu->tag, pdu->id, fid, request_mask);
1065
1066     fidp = get_fid(pdu, fid);
1067     if (fidp == NULL) {
1068         retval = -ENOENT;
1069         goto out_nofid;
1070     }
1071     /*
1072      * Currently we only support BASIC fields in stat, so there is no
1073      * need to look at request_mask.
1074      */
1075     retval = v9fs_co_lstat(pdu, &fidp->path, &stbuf);
1076     if (retval < 0) {
1077         goto out;
1078     }
1079     stat_to_v9stat_dotl(s, &stbuf, &v9stat_dotl);
1080
1081     /*  fill st_gen if requested and supported by underlying fs */
1082     if (request_mask & P9_STATS_GEN) {
1083         retval = v9fs_co_st_gen(pdu, &fidp->path, stbuf.st_mode, &v9stat_dotl);
1084         switch (retval) {
1085         case 0:
1086             /* we have valid st_gen: update result mask */
1087             v9stat_dotl.st_result_mask |= P9_STATS_GEN;
1088             break;
1089         case -EINTR:
1090             /* request cancelled, e.g. by Tflush */
1091             goto out;
1092         default:
1093             /* failed to get st_gen: not fatal, ignore */
1094             break;
1095         }
1096     }
1097     retval = pdu_marshal(pdu, offset, "A", &v9stat_dotl);
1098     if (retval < 0) {
1099         goto out;
1100     }
1101     retval += offset;
1102     trace_v9fs_getattr_return(pdu->tag, pdu->id, v9stat_dotl.st_result_mask,
1103                               v9stat_dotl.st_mode, v9stat_dotl.st_uid,
1104                               v9stat_dotl.st_gid);
1105 out:
1106     put_fid(pdu, fidp);
1107 out_nofid:
1108     complete_pdu(s, pdu, retval);
1109 }
1110
1111 /* Attribute flags */
1112 #define P9_ATTR_MODE       (1 << 0)
1113 #define P9_ATTR_UID        (1 << 1)
1114 #define P9_ATTR_GID        (1 << 2)
1115 #define P9_ATTR_SIZE       (1 << 3)
1116 #define P9_ATTR_ATIME      (1 << 4)
1117 #define P9_ATTR_MTIME      (1 << 5)
1118 #define P9_ATTR_CTIME      (1 << 6)
1119 #define P9_ATTR_ATIME_SET  (1 << 7)
1120 #define P9_ATTR_MTIME_SET  (1 << 8)
1121
1122 #define P9_ATTR_MASK    127
1123
1124 static void v9fs_setattr(void *opaque)
1125 {
1126     int err = 0;
1127     int32_t fid;
1128     V9fsFidState *fidp;
1129     size_t offset = 7;
1130     V9fsIattr v9iattr;
1131     V9fsPDU *pdu = opaque;
1132     V9fsState *s = pdu->s;
1133
1134     err = pdu_unmarshal(pdu, offset, "dI", &fid, &v9iattr);
1135     if (err < 0) {
1136         goto out_nofid;
1137     }
1138
1139     fidp = get_fid(pdu, fid);
1140     if (fidp == NULL) {
1141         err = -EINVAL;
1142         goto out_nofid;
1143     }
1144     if (v9iattr.valid & P9_ATTR_MODE) {
1145         err = v9fs_co_chmod(pdu, &fidp->path, v9iattr.mode);
1146         if (err < 0) {
1147             goto out;
1148         }
1149     }
1150     if (v9iattr.valid & (P9_ATTR_ATIME | P9_ATTR_MTIME)) {
1151         struct timespec times[2];
1152         if (v9iattr.valid & P9_ATTR_ATIME) {
1153             if (v9iattr.valid & P9_ATTR_ATIME_SET) {
1154                 times[0].tv_sec = v9iattr.atime_sec;
1155                 times[0].tv_nsec = v9iattr.atime_nsec;
1156             } else {
1157                 times[0].tv_nsec = UTIME_NOW;
1158             }
1159         } else {
1160             times[0].tv_nsec = UTIME_OMIT;
1161         }
1162         if (v9iattr.valid & P9_ATTR_MTIME) {
1163             if (v9iattr.valid & P9_ATTR_MTIME_SET) {
1164                 times[1].tv_sec = v9iattr.mtime_sec;
1165                 times[1].tv_nsec = v9iattr.mtime_nsec;
1166             } else {
1167                 times[1].tv_nsec = UTIME_NOW;
1168             }
1169         } else {
1170             times[1].tv_nsec = UTIME_OMIT;
1171         }
1172         err = v9fs_co_utimensat(pdu, &fidp->path, times);
1173         if (err < 0) {
1174             goto out;
1175         }
1176     }
1177     /*
1178      * If the only valid entry in iattr is ctime we can call
1179      * chown(-1,-1) to update the ctime of the file
1180      */
1181     if ((v9iattr.valid & (P9_ATTR_UID | P9_ATTR_GID)) ||
1182         ((v9iattr.valid & P9_ATTR_CTIME)
1183          && !((v9iattr.valid & P9_ATTR_MASK) & ~P9_ATTR_CTIME))) {
1184         if (!(v9iattr.valid & P9_ATTR_UID)) {
1185             v9iattr.uid = -1;
1186         }
1187         if (!(v9iattr.valid & P9_ATTR_GID)) {
1188             v9iattr.gid = -1;
1189         }
1190         err = v9fs_co_chown(pdu, &fidp->path, v9iattr.uid,
1191                             v9iattr.gid);
1192         if (err < 0) {
1193             goto out;
1194         }
1195     }
1196     if (v9iattr.valid & (P9_ATTR_SIZE)) {
1197         err = v9fs_co_truncate(pdu, &fidp->path, v9iattr.size);
1198         if (err < 0) {
1199             goto out;
1200         }
1201     }
1202     err = offset;
1203 out:
1204     put_fid(pdu, fidp);
1205 out_nofid:
1206     complete_pdu(s, pdu, err);
1207 }
1208
1209 static int v9fs_walk_marshal(V9fsPDU *pdu, uint16_t nwnames, V9fsQID *qids)
1210 {
1211     int i;
1212     ssize_t err;
1213     size_t offset = 7;
1214
1215     err = pdu_marshal(pdu, offset, "w", nwnames);
1216     if (err < 0) {
1217         return err;
1218     }
1219     offset += err;
1220     for (i = 0; i < nwnames; i++) {
1221         err = pdu_marshal(pdu, offset, "Q", &qids[i]);
1222         if (err < 0) {
1223             return err;
1224         }
1225         offset += err;
1226     }
1227     return offset;
1228 }
1229
1230 static void v9fs_walk(void *opaque)
1231 {
1232     int name_idx;
1233     V9fsQID *qids = NULL;
1234     int i, err = 0;
1235     V9fsPath dpath, path;
1236     uint16_t nwnames;
1237     struct stat stbuf;
1238     size_t offset = 7;
1239     int32_t fid, newfid;
1240     V9fsString *wnames = NULL;
1241     V9fsFidState *fidp;
1242     V9fsFidState *newfidp = NULL;
1243     V9fsPDU *pdu = opaque;
1244     V9fsState *s = pdu->s;
1245
1246     err = pdu_unmarshal(pdu, offset, "ddw", &fid, &newfid, &nwnames);
1247     if (err < 0) {
1248         complete_pdu(s, pdu, err);
1249         return ;
1250     }
1251     offset += err;
1252
1253     trace_v9fs_walk(pdu->tag, pdu->id, fid, newfid, nwnames);
1254
1255     if (nwnames && nwnames <= P9_MAXWELEM) {
1256         wnames = g_malloc0(sizeof(wnames[0]) * nwnames);
1257         qids   = g_malloc0(sizeof(qids[0]) * nwnames);
1258         for (i = 0; i < nwnames; i++) {
1259             err = pdu_unmarshal(pdu, offset, "s", &wnames[i]);
1260             if (err < 0) {
1261                 goto out_nofid;
1262             }
1263             offset += err;
1264         }
1265     } else if (nwnames > P9_MAXWELEM) {
1266         err = -EINVAL;
1267         goto out_nofid;
1268     }
1269     fidp = get_fid(pdu, fid);
1270     if (fidp == NULL) {
1271         err = -ENOENT;
1272         goto out_nofid;
1273     }
1274     v9fs_path_init(&dpath);
1275     v9fs_path_init(&path);
1276     /*
1277      * Both dpath and path initially poin to fidp.
1278      * Needed to handle request with nwnames == 0
1279      */
1280     v9fs_path_copy(&dpath, &fidp->path);
1281     v9fs_path_copy(&path, &fidp->path);
1282     for (name_idx = 0; name_idx < nwnames; name_idx++) {
1283         err = v9fs_co_name_to_path(pdu, &dpath, wnames[name_idx].data, &path);
1284         if (err < 0) {
1285             goto out;
1286         }
1287         err = v9fs_co_lstat(pdu, &path, &stbuf);
1288         if (err < 0) {
1289             goto out;
1290         }
1291         stat_to_qid(&stbuf, &qids[name_idx]);
1292         v9fs_path_copy(&dpath, &path);
1293     }
1294     if (fid == newfid) {
1295         BUG_ON(fidp->fid_type != P9_FID_NONE);
1296         v9fs_path_copy(&fidp->path, &path);
1297     } else {
1298         newfidp = alloc_fid(s, newfid);
1299         if (newfidp == NULL) {
1300             err = -EINVAL;
1301             goto out;
1302         }
1303         newfidp->uid = fidp->uid;
1304         v9fs_path_copy(&newfidp->path, &path);
1305     }
1306     err = v9fs_walk_marshal(pdu, nwnames, qids);
1307     trace_v9fs_walk_return(pdu->tag, pdu->id, nwnames, qids);
1308 out:
1309     put_fid(pdu, fidp);
1310     if (newfidp) {
1311         put_fid(pdu, newfidp);
1312     }
1313     v9fs_path_free(&dpath);
1314     v9fs_path_free(&path);
1315 out_nofid:
1316     complete_pdu(s, pdu, err);
1317     if (nwnames && nwnames <= P9_MAXWELEM) {
1318         for (name_idx = 0; name_idx < nwnames; name_idx++) {
1319             v9fs_string_free(&wnames[name_idx]);
1320         }
1321         g_free(wnames);
1322         g_free(qids);
1323     }
1324 }
1325
1326 static int32_t get_iounit(V9fsPDU *pdu, V9fsPath *path)
1327 {
1328     struct statfs stbuf;
1329     int32_t iounit = 0;
1330     V9fsState *s = pdu->s;
1331
1332     /*
1333      * iounit should be multiples of f_bsize (host filesystem block size
1334      * and as well as less than (client msize - P9_IOHDRSZ))
1335      */
1336     if (!v9fs_co_statfs(pdu, path, &stbuf)) {
1337         iounit = stbuf.f_bsize;
1338         iounit *= (s->msize - P9_IOHDRSZ)/stbuf.f_bsize;
1339     }
1340     if (!iounit) {
1341         iounit = s->msize - P9_IOHDRSZ;
1342     }
1343     return iounit;
1344 }
1345
1346 static void v9fs_open(void *opaque)
1347 {
1348     int flags;
1349     int32_t fid;
1350     int32_t mode;
1351     V9fsQID qid;
1352     int iounit = 0;
1353     ssize_t err = 0;
1354     size_t offset = 7;
1355     struct stat stbuf;
1356     V9fsFidState *fidp;
1357     V9fsPDU *pdu = opaque;
1358     V9fsState *s = pdu->s;
1359
1360     if (s->proto_version == V9FS_PROTO_2000L) {
1361         err = pdu_unmarshal(pdu, offset, "dd", &fid, &mode);
1362     } else {
1363         uint8_t modebyte;
1364         err = pdu_unmarshal(pdu, offset, "db", &fid, &modebyte);
1365         mode = modebyte;
1366     }
1367     if (err < 0) {
1368         goto out_nofid;
1369     }
1370     trace_v9fs_open(pdu->tag, pdu->id, fid, mode);
1371
1372     fidp = get_fid(pdu, fid);
1373     if (fidp == NULL) {
1374         err = -ENOENT;
1375         goto out_nofid;
1376     }
1377     BUG_ON(fidp->fid_type != P9_FID_NONE);
1378
1379     err = v9fs_co_lstat(pdu, &fidp->path, &stbuf);
1380     if (err < 0) {
1381         goto out;
1382     }
1383     stat_to_qid(&stbuf, &qid);
1384     if (S_ISDIR(stbuf.st_mode)) {
1385         err = v9fs_co_opendir(pdu, fidp);
1386         if (err < 0) {
1387             goto out;
1388         }
1389         fidp->fid_type = P9_FID_DIR;
1390         err = pdu_marshal(pdu, offset, "Qd", &qid, 0);
1391         if (err < 0) {
1392             goto out;
1393         }
1394         err += offset;
1395     } else {
1396         if (s->proto_version == V9FS_PROTO_2000L) {
1397             flags = get_dotl_openflags(s, mode);
1398         } else {
1399             flags = omode_to_uflags(mode);
1400         }
1401         if (is_ro_export(&s->ctx)) {
1402             if (mode & O_WRONLY || mode & O_RDWR ||
1403                 mode & O_APPEND || mode & O_TRUNC) {
1404                 err = -EROFS;
1405                 goto out;
1406             }
1407         }
1408         err = v9fs_co_open(pdu, fidp, flags);
1409         if (err < 0) {
1410             goto out;
1411         }
1412         fidp->fid_type = P9_FID_FILE;
1413         fidp->open_flags = flags;
1414         if (flags & O_EXCL) {
1415             /*
1416              * We let the host file system do O_EXCL check
1417              * We should not reclaim such fd
1418              */
1419             fidp->flags |= FID_NON_RECLAIMABLE;
1420         }
1421         iounit = get_iounit(pdu, &fidp->path);
1422         err = pdu_marshal(pdu, offset, "Qd", &qid, iounit);
1423         if (err < 0) {
1424             goto out;
1425         }
1426         err += offset;
1427     }
1428     trace_v9fs_open_return(pdu->tag, pdu->id,
1429                            qid.type, qid.version, qid.path, iounit);
1430 out:
1431     put_fid(pdu, fidp);
1432 out_nofid:
1433     complete_pdu(s, pdu, err);
1434 }
1435
1436 static void v9fs_lcreate(void *opaque)
1437 {
1438     int32_t dfid, flags, mode;
1439     gid_t gid;
1440     ssize_t err = 0;
1441     ssize_t offset = 7;
1442     V9fsString name;
1443     V9fsFidState *fidp;
1444     struct stat stbuf;
1445     V9fsQID qid;
1446     int32_t iounit;
1447     V9fsPDU *pdu = opaque;
1448
1449     v9fs_string_init(&name);
1450     err = pdu_unmarshal(pdu, offset, "dsddd", &dfid,
1451                         &name, &flags, &mode, &gid);
1452     if (err < 0) {
1453         goto out_nofid;
1454     }
1455     trace_v9fs_lcreate(pdu->tag, pdu->id, dfid, flags, mode, gid);
1456
1457     fidp = get_fid(pdu, dfid);
1458     if (fidp == NULL) {
1459         err = -ENOENT;
1460         goto out_nofid;
1461     }
1462
1463     flags = get_dotl_openflags(pdu->s, flags);
1464     err = v9fs_co_open2(pdu, fidp, &name, gid,
1465                         flags | O_CREAT, mode, &stbuf);
1466     if (err < 0) {
1467         goto out;
1468     }
1469     fidp->fid_type = P9_FID_FILE;
1470     fidp->open_flags = flags;
1471     if (flags & O_EXCL) {
1472         /*
1473          * We let the host file system do O_EXCL check
1474          * We should not reclaim such fd
1475          */
1476         fidp->flags |= FID_NON_RECLAIMABLE;
1477     }
1478     iounit =  get_iounit(pdu, &fidp->path);
1479     stat_to_qid(&stbuf, &qid);
1480     err = pdu_marshal(pdu, offset, "Qd", &qid, iounit);
1481     if (err < 0) {
1482         goto out;
1483     }
1484     err += offset;
1485     trace_v9fs_lcreate_return(pdu->tag, pdu->id,
1486                               qid.type, qid.version, qid.path, iounit);
1487 out:
1488     put_fid(pdu, fidp);
1489 out_nofid:
1490     complete_pdu(pdu->s, pdu, err);
1491     v9fs_string_free(&name);
1492 }
1493
1494 static void v9fs_fsync(void *opaque)
1495 {
1496     int err;
1497     int32_t fid;
1498     int datasync;
1499     size_t offset = 7;
1500     V9fsFidState *fidp;
1501     V9fsPDU *pdu = opaque;
1502     V9fsState *s = pdu->s;
1503
1504     err = pdu_unmarshal(pdu, offset, "dd", &fid, &datasync);
1505     if (err < 0) {
1506         goto out_nofid;
1507     }
1508     trace_v9fs_fsync(pdu->tag, pdu->id, fid, datasync);
1509
1510     fidp = get_fid(pdu, fid);
1511     if (fidp == NULL) {
1512         err = -ENOENT;
1513         goto out_nofid;
1514     }
1515     err = v9fs_co_fsync(pdu, fidp, datasync);
1516     if (!err) {
1517         err = offset;
1518     }
1519     put_fid(pdu, fidp);
1520 out_nofid:
1521     complete_pdu(s, pdu, err);
1522 }
1523
1524 static void v9fs_clunk(void *opaque)
1525 {
1526     int err;
1527     int32_t fid;
1528     size_t offset = 7;
1529     V9fsFidState *fidp;
1530     V9fsPDU *pdu = opaque;
1531     V9fsState *s = pdu->s;
1532
1533     err = pdu_unmarshal(pdu, offset, "d", &fid);
1534     if (err < 0) {
1535         goto out_nofid;
1536     }
1537     trace_v9fs_clunk(pdu->tag, pdu->id, fid);
1538
1539     fidp = clunk_fid(s, fid);
1540     if (fidp == NULL) {
1541         err = -ENOENT;
1542         goto out_nofid;
1543     }
1544     /*
1545      * Bump the ref so that put_fid will
1546      * free the fid.
1547      */
1548     fidp->ref++;
1549     err = put_fid(pdu, fidp);
1550     if (!err) {
1551         err = offset;
1552     }
1553 out_nofid:
1554     complete_pdu(s, pdu, err);
1555 }
1556
1557 static int v9fs_xattr_read(V9fsState *s, V9fsPDU *pdu, V9fsFidState *fidp,
1558                            uint64_t off, uint32_t max_count)
1559 {
1560     ssize_t err;
1561     size_t offset = 7;
1562     int read_count;
1563     int64_t xattr_len;
1564
1565     xattr_len = fidp->fs.xattr.len;
1566     read_count = xattr_len - off;
1567     if (read_count > max_count) {
1568         read_count = max_count;
1569     } else if (read_count < 0) {
1570         /*
1571          * read beyond XATTR value
1572          */
1573         read_count = 0;
1574     }
1575     err = pdu_marshal(pdu, offset, "d", read_count);
1576     if (err < 0) {
1577         return err;
1578     }
1579     offset += err;
1580     err = v9fs_pack(pdu->elem.in_sg, pdu->elem.in_num, offset,
1581                     ((char *)fidp->fs.xattr.value) + off,
1582                     read_count);
1583     if (err < 0) {
1584         return err;
1585     }
1586     offset += err;
1587     return offset;
1588 }
1589
1590 static int v9fs_do_readdir_with_stat(V9fsPDU *pdu,
1591                                      V9fsFidState *fidp, uint32_t max_count)
1592 {
1593     V9fsPath path;
1594     V9fsStat v9stat;
1595     int len, err = 0;
1596     int32_t count = 0;
1597     struct stat stbuf;
1598     off_t saved_dir_pos;
1599     struct dirent *dent, *result;
1600
1601     /* save the directory position */
1602     saved_dir_pos = v9fs_co_telldir(pdu, fidp);
1603     if (saved_dir_pos < 0) {
1604         return saved_dir_pos;
1605     }
1606
1607     dent = g_malloc(sizeof(struct dirent));
1608
1609     while (1) {
1610         v9fs_path_init(&path);
1611         err = v9fs_co_readdir_r(pdu, fidp, dent, &result);
1612         if (err || !result) {
1613             break;
1614         }
1615         err = v9fs_co_name_to_path(pdu, &fidp->path, dent->d_name, &path);
1616         if (err < 0) {
1617             goto out;
1618         }
1619         err = v9fs_co_lstat(pdu, &path, &stbuf);
1620         if (err < 0) {
1621             goto out;
1622         }
1623         err = stat_to_v9stat(pdu, &path, &stbuf, &v9stat);
1624         if (err < 0) {
1625             goto out;
1626         }
1627         /* 11 = 7 + 4 (7 = start offset, 4 = space for storing count) */
1628         len = pdu_marshal(pdu, 11 + count, "S", &v9stat);
1629         if ((len != (v9stat.size + 2)) || ((count + len) > max_count)) {
1630             /* Ran out of buffer. Set dir back to old position and return */
1631             v9fs_co_seekdir(pdu, fidp, saved_dir_pos);
1632             v9fs_stat_free(&v9stat);
1633             v9fs_path_free(&path);
1634             g_free(dent);
1635             return count;
1636         }
1637         count += len;
1638         v9fs_stat_free(&v9stat);
1639         v9fs_path_free(&path);
1640         saved_dir_pos = dent->d_off;
1641     }
1642 out:
1643     g_free(dent);
1644     v9fs_path_free(&path);
1645     if (err < 0) {
1646         return err;
1647     }
1648     return count;
1649 }
1650
1651 /*
1652  * Create a QEMUIOVector for a sub-region of PDU iovecs
1653  *
1654  * @qiov:       uninitialized QEMUIOVector
1655  * @skip:       number of bytes to skip from beginning of PDU
1656  * @size:       number of bytes to include
1657  * @is_write:   true - write, false - read
1658  *
1659  * The resulting QEMUIOVector has heap-allocated iovecs and must be cleaned up
1660  * with qemu_iovec_destroy().
1661  */
1662 static void v9fs_init_qiov_from_pdu(QEMUIOVector *qiov, V9fsPDU *pdu,
1663                                     size_t skip, size_t size,
1664                                     bool is_write)
1665 {
1666     QEMUIOVector elem;
1667     struct iovec *iov;
1668     unsigned int niov;
1669
1670     if (is_write) {
1671         iov = pdu->elem.out_sg;
1672         niov = pdu->elem.out_num;
1673     } else {
1674         iov = pdu->elem.in_sg;
1675         niov = pdu->elem.in_num;
1676     }
1677
1678     qemu_iovec_init_external(&elem, iov, niov);
1679     qemu_iovec_init(qiov, niov);
1680     qemu_iovec_concat(qiov, &elem, skip, size);
1681 }
1682
1683 static void v9fs_read(void *opaque)
1684 {
1685     int32_t fid;
1686     uint64_t off;
1687     ssize_t err = 0;
1688     int32_t count = 0;
1689     size_t offset = 7;
1690     uint32_t max_count;
1691     V9fsFidState *fidp;
1692     V9fsPDU *pdu = opaque;
1693     V9fsState *s = pdu->s;
1694
1695     err = pdu_unmarshal(pdu, offset, "dqd", &fid, &off, &max_count);
1696     if (err < 0) {
1697         goto out_nofid;
1698     }
1699     trace_v9fs_read(pdu->tag, pdu->id, fid, off, max_count);
1700
1701     fidp = get_fid(pdu, fid);
1702     if (fidp == NULL) {
1703         err = -EINVAL;
1704         goto out_nofid;
1705     }
1706     if (fidp->fid_type == P9_FID_DIR) {
1707
1708         if (off == 0) {
1709             v9fs_co_rewinddir(pdu, fidp);
1710         }
1711         count = v9fs_do_readdir_with_stat(pdu, fidp, max_count);
1712         if (count < 0) {
1713             err = count;
1714             goto out;
1715         }
1716         err = pdu_marshal(pdu, offset, "d", count);
1717         if (err < 0) {
1718             goto out;
1719         }
1720         err += offset + count;
1721     } else if (fidp->fid_type == P9_FID_FILE) {
1722         QEMUIOVector qiov_full;
1723         QEMUIOVector qiov;
1724         int32_t len;
1725
1726         v9fs_init_qiov_from_pdu(&qiov_full, pdu, offset + 4, max_count, false);
1727         qemu_iovec_init(&qiov, qiov_full.niov);
1728         do {
1729             qemu_iovec_reset(&qiov);
1730             qemu_iovec_concat(&qiov, &qiov_full, count, qiov_full.size - count);
1731             if (0) {
1732                 print_sg(qiov.iov, qiov.niov);
1733             }
1734             /* Loop in case of EINTR */
1735             do {
1736                 len = v9fs_co_preadv(pdu, fidp, qiov.iov, qiov.niov, off);
1737                 if (len >= 0) {
1738                     off   += len;
1739                     count += len;
1740                 }
1741             } while (len == -EINTR && !pdu->cancelled);
1742             if (len < 0) {
1743                 /* IO error return the error */
1744                 err = len;
1745                 goto out;
1746             }
1747         } while (count < max_count && len > 0);
1748         err = pdu_marshal(pdu, offset, "d", count);
1749         if (err < 0) {
1750             goto out;
1751         }
1752         err += offset + count;
1753         qemu_iovec_destroy(&qiov);
1754         qemu_iovec_destroy(&qiov_full);
1755     } else if (fidp->fid_type == P9_FID_XATTR) {
1756         err = v9fs_xattr_read(s, pdu, fidp, off, max_count);
1757     } else {
1758         err = -EINVAL;
1759     }
1760     trace_v9fs_read_return(pdu->tag, pdu->id, count, err);
1761 out:
1762     put_fid(pdu, fidp);
1763 out_nofid:
1764     complete_pdu(s, pdu, err);
1765 }
1766
1767 static size_t v9fs_readdir_data_size(V9fsString *name)
1768 {
1769     /*
1770      * Size of each dirent on the wire: size of qid (13) + size of offset (8)
1771      * size of type (1) + size of name.size (2) + strlen(name.data)
1772      */
1773     return 24 + v9fs_string_size(name);
1774 }
1775
1776 static int v9fs_do_readdir(V9fsPDU *pdu,
1777                            V9fsFidState *fidp, int32_t max_count)
1778 {
1779     size_t size;
1780     V9fsQID qid;
1781     V9fsString name;
1782     int len, err = 0;
1783     int32_t count = 0;
1784     off_t saved_dir_pos;
1785     struct dirent *dent, *result;
1786
1787     /* save the directory position */
1788     saved_dir_pos = v9fs_co_telldir(pdu, fidp);
1789     if (saved_dir_pos < 0) {
1790         return saved_dir_pos;
1791     }
1792
1793     dent = g_malloc(sizeof(struct dirent));
1794
1795     while (1) {
1796         err = v9fs_co_readdir_r(pdu, fidp, dent, &result);
1797         if (err || !result) {
1798             break;
1799         }
1800         v9fs_string_init(&name);
1801         v9fs_string_sprintf(&name, "%s", dent->d_name);
1802         if ((count + v9fs_readdir_data_size(&name)) > max_count) {
1803             /* Ran out of buffer. Set dir back to old position and return */
1804             v9fs_co_seekdir(pdu, fidp, saved_dir_pos);
1805             v9fs_string_free(&name);
1806             g_free(dent);
1807             return count;
1808         }
1809         /*
1810          * Fill up just the path field of qid because the client uses
1811          * only that. To fill the entire qid structure we will have
1812          * to stat each dirent found, which is expensive
1813          */
1814         size = MIN(sizeof(dent->d_ino), sizeof(qid.path));
1815         memcpy(&qid.path, &dent->d_ino, size);
1816         /* Fill the other fields with dummy values */
1817         qid.type = 0;
1818         qid.version = 0;
1819
1820         /* 11 = 7 + 4 (7 = start offset, 4 = space for storing count) */
1821         len = pdu_marshal(pdu, 11 + count, "Qqbs",
1822                           &qid, dent->d_off,
1823                           dent->d_type, &name);
1824         if (len < 0) {
1825             v9fs_co_seekdir(pdu, fidp, saved_dir_pos);
1826             v9fs_string_free(&name);
1827             g_free(dent);
1828             return len;
1829         }
1830         count += len;
1831         v9fs_string_free(&name);
1832         saved_dir_pos = dent->d_off;
1833     }
1834     g_free(dent);
1835     if (err < 0) {
1836         return err;
1837     }
1838     return count;
1839 }
1840
1841 static void v9fs_readdir(void *opaque)
1842 {
1843     int32_t fid;
1844     V9fsFidState *fidp;
1845     ssize_t retval = 0;
1846     size_t offset = 7;
1847     uint64_t initial_offset;
1848     int32_t count;
1849     uint32_t max_count;
1850     V9fsPDU *pdu = opaque;
1851     V9fsState *s = pdu->s;
1852
1853     retval = pdu_unmarshal(pdu, offset, "dqd", &fid,
1854                            &initial_offset, &max_count);
1855     if (retval < 0) {
1856         goto out_nofid;
1857     }
1858     trace_v9fs_readdir(pdu->tag, pdu->id, fid, initial_offset, max_count);
1859
1860     fidp = get_fid(pdu, fid);
1861     if (fidp == NULL) {
1862         retval = -EINVAL;
1863         goto out_nofid;
1864     }
1865     if (!fidp->fs.dir) {
1866         retval = -EINVAL;
1867         goto out;
1868     }
1869     if (initial_offset == 0) {
1870         v9fs_co_rewinddir(pdu, fidp);
1871     } else {
1872         v9fs_co_seekdir(pdu, fidp, initial_offset);
1873     }
1874     count = v9fs_do_readdir(pdu, fidp, max_count);
1875     if (count < 0) {
1876         retval = count;
1877         goto out;
1878     }
1879     retval = pdu_marshal(pdu, offset, "d", count);
1880     if (retval < 0) {
1881         goto out;
1882     }
1883     retval += count + offset;
1884     trace_v9fs_readdir_return(pdu->tag, pdu->id, count, retval);
1885 out:
1886     put_fid(pdu, fidp);
1887 out_nofid:
1888     complete_pdu(s, pdu, retval);
1889 }
1890
1891 static int v9fs_xattr_write(V9fsState *s, V9fsPDU *pdu, V9fsFidState *fidp,
1892                             uint64_t off, uint32_t count,
1893                             struct iovec *sg, int cnt)
1894 {
1895     int i, to_copy;
1896     ssize_t err = 0;
1897     int write_count;
1898     int64_t xattr_len;
1899     size_t offset = 7;
1900
1901
1902     xattr_len = fidp->fs.xattr.len;
1903     write_count = xattr_len - off;
1904     if (write_count > count) {
1905         write_count = count;
1906     } else if (write_count < 0) {
1907         /*
1908          * write beyond XATTR value len specified in
1909          * xattrcreate
1910          */
1911         err = -ENOSPC;
1912         goto out;
1913     }
1914     err = pdu_marshal(pdu, offset, "d", write_count);
1915     if (err < 0) {
1916         return err;
1917     }
1918     err += offset;
1919     fidp->fs.xattr.copied_len += write_count;
1920     /*
1921      * Now copy the content from sg list
1922      */
1923     for (i = 0; i < cnt; i++) {
1924         if (write_count > sg[i].iov_len) {
1925             to_copy = sg[i].iov_len;
1926         } else {
1927             to_copy = write_count;
1928         }
1929         memcpy((char *)fidp->fs.xattr.value + off, sg[i].iov_base, to_copy);
1930         /* updating vs->off since we are not using below */
1931         off += to_copy;
1932         write_count -= to_copy;
1933     }
1934 out:
1935     return err;
1936 }
1937
1938 static void v9fs_write(void *opaque)
1939 {
1940     ssize_t err;
1941     int32_t fid;
1942     uint64_t off;
1943     uint32_t count;
1944     int32_t len = 0;
1945     int32_t total = 0;
1946     size_t offset = 7;
1947     V9fsFidState *fidp;
1948     V9fsPDU *pdu = opaque;
1949     V9fsState *s = pdu->s;
1950     QEMUIOVector qiov_full;
1951     QEMUIOVector qiov;
1952
1953     err = pdu_unmarshal(pdu, offset, "dqd", &fid, &off, &count);
1954     if (err < 0) {
1955         complete_pdu(s, pdu, err);
1956         return;
1957     }
1958     offset += err;
1959     v9fs_init_qiov_from_pdu(&qiov_full, pdu, offset, count, true);
1960     trace_v9fs_write(pdu->tag, pdu->id, fid, off, count, qiov_full.niov);
1961
1962     fidp = get_fid(pdu, fid);
1963     if (fidp == NULL) {
1964         err = -EINVAL;
1965         goto out_nofid;
1966     }
1967     if (fidp->fid_type == P9_FID_FILE) {
1968         if (fidp->fs.fd == -1) {
1969             err = -EINVAL;
1970             goto out;
1971         }
1972     } else if (fidp->fid_type == P9_FID_XATTR) {
1973         /*
1974          * setxattr operation
1975          */
1976         err = v9fs_xattr_write(s, pdu, fidp, off, count,
1977                                qiov_full.iov, qiov_full.niov);
1978         goto out;
1979     } else {
1980         err = -EINVAL;
1981         goto out;
1982     }
1983     qemu_iovec_init(&qiov, qiov_full.niov);
1984     do {
1985         qemu_iovec_reset(&qiov);
1986         qemu_iovec_concat(&qiov, &qiov_full, total, qiov_full.size - total);
1987         if (0) {
1988             print_sg(qiov.iov, qiov.niov);
1989         }
1990         /* Loop in case of EINTR */
1991         do {
1992             len = v9fs_co_pwritev(pdu, fidp, qiov.iov, qiov.niov, off);
1993             if (len >= 0) {
1994                 off   += len;
1995                 total += len;
1996             }
1997         } while (len == -EINTR && !pdu->cancelled);
1998         if (len < 0) {
1999             /* IO error return the error */
2000             err = len;
2001             goto out_qiov;
2002         }
2003     } while (total < count && len > 0);
2004
2005     offset = 7;
2006     err = pdu_marshal(pdu, offset, "d", total);
2007     if (err < 0) {
2008         goto out;
2009     }
2010     err += offset;
2011     trace_v9fs_write_return(pdu->tag, pdu->id, total, err);
2012 out_qiov:
2013     qemu_iovec_destroy(&qiov);
2014 out:
2015     put_fid(pdu, fidp);
2016 out_nofid:
2017     qemu_iovec_destroy(&qiov_full);
2018     complete_pdu(s, pdu, err);
2019 }
2020
2021 static void v9fs_create(void *opaque)
2022 {
2023     int32_t fid;
2024     int err = 0;
2025     size_t offset = 7;
2026     V9fsFidState *fidp;
2027     V9fsQID qid;
2028     int32_t perm;
2029     int8_t mode;
2030     V9fsPath path;
2031     struct stat stbuf;
2032     V9fsString name;
2033     V9fsString extension;
2034     int iounit;
2035     V9fsPDU *pdu = opaque;
2036
2037     v9fs_path_init(&path);
2038     v9fs_string_init(&name);
2039     v9fs_string_init(&extension);
2040     err = pdu_unmarshal(pdu, offset, "dsdbs", &fid, &name,
2041                         &perm, &mode, &extension);
2042     if (err < 0) {
2043         goto out_nofid;
2044     }
2045     trace_v9fs_create(pdu->tag, pdu->id, fid, name.data, perm, mode);
2046
2047     fidp = get_fid(pdu, fid);
2048     if (fidp == NULL) {
2049         err = -EINVAL;
2050         goto out_nofid;
2051     }
2052     if (perm & P9_STAT_MODE_DIR) {
2053         err = v9fs_co_mkdir(pdu, fidp, &name, perm & 0777,
2054                             fidp->uid, -1, &stbuf);
2055         if (err < 0) {
2056             goto out;
2057         }
2058         err = v9fs_co_name_to_path(pdu, &fidp->path, name.data, &path);
2059         if (err < 0) {
2060             goto out;
2061         }
2062         v9fs_path_copy(&fidp->path, &path);
2063         err = v9fs_co_opendir(pdu, fidp);
2064         if (err < 0) {
2065             goto out;
2066         }
2067         fidp->fid_type = P9_FID_DIR;
2068     } else if (perm & P9_STAT_MODE_SYMLINK) {
2069         err = v9fs_co_symlink(pdu, fidp, &name,
2070                               extension.data, -1 , &stbuf);
2071         if (err < 0) {
2072             goto out;
2073         }
2074         err = v9fs_co_name_to_path(pdu, &fidp->path, name.data, &path);
2075         if (err < 0) {
2076             goto out;
2077         }
2078         v9fs_path_copy(&fidp->path, &path);
2079     } else if (perm & P9_STAT_MODE_LINK) {
2080         int32_t ofid = atoi(extension.data);
2081         V9fsFidState *ofidp = get_fid(pdu, ofid);
2082         if (ofidp == NULL) {
2083             err = -EINVAL;
2084             goto out;
2085         }
2086         err = v9fs_co_link(pdu, ofidp, fidp, &name);
2087         put_fid(pdu, ofidp);
2088         if (err < 0) {
2089             goto out;
2090         }
2091         err = v9fs_co_name_to_path(pdu, &fidp->path, name.data, &path);
2092         if (err < 0) {
2093             fidp->fid_type = P9_FID_NONE;
2094             goto out;
2095         }
2096         v9fs_path_copy(&fidp->path, &path);
2097         err = v9fs_co_lstat(pdu, &fidp->path, &stbuf);
2098         if (err < 0) {
2099             fidp->fid_type = P9_FID_NONE;
2100             goto out;
2101         }
2102     } else if (perm & P9_STAT_MODE_DEVICE) {
2103         char ctype;
2104         uint32_t major, minor;
2105         mode_t nmode = 0;
2106
2107         if (sscanf(extension.data, "%c %u %u", &ctype, &major, &minor) != 3) {
2108             err = -errno;
2109             goto out;
2110         }
2111
2112         switch (ctype) {
2113         case 'c':
2114             nmode = S_IFCHR;
2115             break;
2116         case 'b':
2117             nmode = S_IFBLK;
2118             break;
2119         default:
2120             err = -EIO;
2121             goto out;
2122         }
2123
2124         nmode |= perm & 0777;
2125         err = v9fs_co_mknod(pdu, fidp, &name, fidp->uid, -1,
2126                             makedev(major, minor), nmode, &stbuf);
2127         if (err < 0) {
2128             goto out;
2129         }
2130         err = v9fs_co_name_to_path(pdu, &fidp->path, name.data, &path);
2131         if (err < 0) {
2132             goto out;
2133         }
2134         v9fs_path_copy(&fidp->path, &path);
2135     } else if (perm & P9_STAT_MODE_NAMED_PIPE) {
2136         err = v9fs_co_mknod(pdu, fidp, &name, fidp->uid, -1,
2137                             0, S_IFIFO | (perm & 0777), &stbuf);
2138         if (err < 0) {
2139             goto out;
2140         }
2141         err = v9fs_co_name_to_path(pdu, &fidp->path, name.data, &path);
2142         if (err < 0) {
2143             goto out;
2144         }
2145         v9fs_path_copy(&fidp->path, &path);
2146     } else if (perm & P9_STAT_MODE_SOCKET) {
2147         err = v9fs_co_mknod(pdu, fidp, &name, fidp->uid, -1,
2148                             0, S_IFSOCK | (perm & 0777), &stbuf);
2149         if (err < 0) {
2150             goto out;
2151         }
2152         err = v9fs_co_name_to_path(pdu, &fidp->path, name.data, &path);
2153         if (err < 0) {
2154             goto out;
2155         }
2156         v9fs_path_copy(&fidp->path, &path);
2157     } else {
2158         err = v9fs_co_open2(pdu, fidp, &name, -1,
2159                             omode_to_uflags(mode)|O_CREAT, perm, &stbuf);
2160         if (err < 0) {
2161             goto out;
2162         }
2163         fidp->fid_type = P9_FID_FILE;
2164         fidp->open_flags = omode_to_uflags(mode);
2165         if (fidp->open_flags & O_EXCL) {
2166             /*
2167              * We let the host file system do O_EXCL check
2168              * We should not reclaim such fd
2169              */
2170             fidp->flags |= FID_NON_RECLAIMABLE;
2171         }
2172     }
2173     iounit = get_iounit(pdu, &fidp->path);
2174     stat_to_qid(&stbuf, &qid);
2175     err = pdu_marshal(pdu, offset, "Qd", &qid, iounit);
2176     if (err < 0) {
2177         goto out;
2178     }
2179     err += offset;
2180     trace_v9fs_create_return(pdu->tag, pdu->id,
2181                              qid.type, qid.version, qid.path, iounit);
2182 out:
2183     put_fid(pdu, fidp);
2184 out_nofid:
2185    complete_pdu(pdu->s, pdu, err);
2186    v9fs_string_free(&name);
2187    v9fs_string_free(&extension);
2188    v9fs_path_free(&path);
2189 }
2190
2191 static void v9fs_symlink(void *opaque)
2192 {
2193     V9fsPDU *pdu = opaque;
2194     V9fsString name;
2195     V9fsString symname;
2196     V9fsFidState *dfidp;
2197     V9fsQID qid;
2198     struct stat stbuf;
2199     int32_t dfid;
2200     int err = 0;
2201     gid_t gid;
2202     size_t offset = 7;
2203
2204     v9fs_string_init(&name);
2205     v9fs_string_init(&symname);
2206     err = pdu_unmarshal(pdu, offset, "dssd", &dfid, &name, &symname, &gid);
2207     if (err < 0) {
2208         goto out_nofid;
2209     }
2210     trace_v9fs_symlink(pdu->tag, pdu->id, dfid, name.data, symname.data, gid);
2211
2212     dfidp = get_fid(pdu, dfid);
2213     if (dfidp == NULL) {
2214         err = -EINVAL;
2215         goto out_nofid;
2216     }
2217     err = v9fs_co_symlink(pdu, dfidp, &name, symname.data, gid, &stbuf);
2218     if (err < 0) {
2219         goto out;
2220     }
2221     stat_to_qid(&stbuf, &qid);
2222     err =  pdu_marshal(pdu, offset, "Q", &qid);
2223     if (err < 0) {
2224         goto out;
2225     }
2226     err += offset;
2227     trace_v9fs_symlink_return(pdu->tag, pdu->id,
2228                               qid.type, qid.version, qid.path);
2229 out:
2230     put_fid(pdu, dfidp);
2231 out_nofid:
2232     complete_pdu(pdu->s, pdu, err);
2233     v9fs_string_free(&name);
2234     v9fs_string_free(&symname);
2235 }
2236
2237 static void v9fs_flush(void *opaque)
2238 {
2239     ssize_t err;
2240     int16_t tag;
2241     size_t offset = 7;
2242     V9fsPDU *cancel_pdu;
2243     V9fsPDU *pdu = opaque;
2244     V9fsState *s = pdu->s;
2245
2246     err = pdu_unmarshal(pdu, offset, "w", &tag);
2247     if (err < 0) {
2248         complete_pdu(s, pdu, err);
2249         return;
2250     }
2251     trace_v9fs_flush(pdu->tag, pdu->id, tag);
2252
2253     QLIST_FOREACH(cancel_pdu, &s->active_list, next) {
2254         if (cancel_pdu->tag == tag) {
2255             break;
2256         }
2257     }
2258     if (cancel_pdu) {
2259         cancel_pdu->cancelled = 1;
2260         /*
2261          * Wait for pdu to complete.
2262          */
2263         qemu_co_queue_wait(&cancel_pdu->complete);
2264         cancel_pdu->cancelled = 0;
2265         free_pdu(pdu->s, cancel_pdu);
2266     }
2267     complete_pdu(s, pdu, 7);
2268 }
2269
2270 static void v9fs_link(void *opaque)
2271 {
2272     V9fsPDU *pdu = opaque;
2273     V9fsState *s = pdu->s;
2274     int32_t dfid, oldfid;
2275     V9fsFidState *dfidp, *oldfidp;
2276     V9fsString name;
2277     size_t offset = 7;
2278     int err = 0;
2279
2280     v9fs_string_init(&name);
2281     err = pdu_unmarshal(pdu, offset, "dds", &dfid, &oldfid, &name);
2282     if (err < 0) {
2283         goto out_nofid;
2284     }
2285     trace_v9fs_link(pdu->tag, pdu->id, dfid, oldfid, name.data);
2286
2287     dfidp = get_fid(pdu, dfid);
2288     if (dfidp == NULL) {
2289         err = -ENOENT;
2290         goto out_nofid;
2291     }
2292
2293     oldfidp = get_fid(pdu, oldfid);
2294     if (oldfidp == NULL) {
2295         err = -ENOENT;
2296         goto out;
2297     }
2298     err = v9fs_co_link(pdu, oldfidp, dfidp, &name);
2299     if (!err) {
2300         err = offset;
2301     }
2302 out:
2303     put_fid(pdu, dfidp);
2304 out_nofid:
2305     v9fs_string_free(&name);
2306     complete_pdu(s, pdu, err);
2307 }
2308
2309 /* Only works with path name based fid */
2310 static void v9fs_remove(void *opaque)
2311 {
2312     int32_t fid;
2313     int err = 0;
2314     size_t offset = 7;
2315     V9fsFidState *fidp;
2316     V9fsPDU *pdu = opaque;
2317
2318     err = pdu_unmarshal(pdu, offset, "d", &fid);
2319     if (err < 0) {
2320         goto out_nofid;
2321     }
2322     trace_v9fs_remove(pdu->tag, pdu->id, fid);
2323
2324     fidp = get_fid(pdu, fid);
2325     if (fidp == NULL) {
2326         err = -EINVAL;
2327         goto out_nofid;
2328     }
2329     /* if fs driver is not path based, return EOPNOTSUPP */
2330     if (!(pdu->s->ctx.export_flags & V9FS_PATHNAME_FSCONTEXT)) {
2331         err = -EOPNOTSUPP;
2332         goto out_err;
2333     }
2334     /*
2335      * IF the file is unlinked, we cannot reopen
2336      * the file later. So don't reclaim fd
2337      */
2338     err = v9fs_mark_fids_unreclaim(pdu, &fidp->path);
2339     if (err < 0) {
2340         goto out_err;
2341     }
2342     err = v9fs_co_remove(pdu, &fidp->path);
2343     if (!err) {
2344         err = offset;
2345     }
2346 out_err:
2347     /* For TREMOVE we need to clunk the fid even on failed remove */
2348     clunk_fid(pdu->s, fidp->fid);
2349     put_fid(pdu, fidp);
2350 out_nofid:
2351     complete_pdu(pdu->s, pdu, err);
2352 }
2353
2354 static void v9fs_unlinkat(void *opaque)
2355 {
2356     int err = 0;
2357     V9fsString name;
2358     int32_t dfid, flags;
2359     size_t offset = 7;
2360     V9fsPath path;
2361     V9fsFidState *dfidp;
2362     V9fsPDU *pdu = opaque;
2363
2364     v9fs_string_init(&name);
2365     err = pdu_unmarshal(pdu, offset, "dsd", &dfid, &name, &flags);
2366     if (err < 0) {
2367         goto out_nofid;
2368     }
2369     dfidp = get_fid(pdu, dfid);
2370     if (dfidp == NULL) {
2371         err = -EINVAL;
2372         goto out_nofid;
2373     }
2374     /*
2375      * IF the file is unlinked, we cannot reopen
2376      * the file later. So don't reclaim fd
2377      */
2378     v9fs_path_init(&path);
2379     err = v9fs_co_name_to_path(pdu, &dfidp->path, name.data, &path);
2380     if (err < 0) {
2381         goto out_err;
2382     }
2383     err = v9fs_mark_fids_unreclaim(pdu, &path);
2384     if (err < 0) {
2385         goto out_err;
2386     }
2387     err = v9fs_co_unlinkat(pdu, &dfidp->path, &name, flags);
2388     if (!err) {
2389         err = offset;
2390     }
2391 out_err:
2392     put_fid(pdu, dfidp);
2393     v9fs_path_free(&path);
2394 out_nofid:
2395     complete_pdu(pdu->s, pdu, err);
2396     v9fs_string_free(&name);
2397 }
2398
2399
2400 /* Only works with path name based fid */
2401 static int v9fs_complete_rename(V9fsPDU *pdu, V9fsFidState *fidp,
2402                                 int32_t newdirfid, V9fsString *name)
2403 {
2404     char *end;
2405     int err = 0;
2406     V9fsPath new_path;
2407     V9fsFidState *tfidp;
2408     V9fsState *s = pdu->s;
2409     V9fsFidState *dirfidp = NULL;
2410     char *old_name, *new_name;
2411
2412     v9fs_path_init(&new_path);
2413     if (newdirfid != -1) {
2414         dirfidp = get_fid(pdu, newdirfid);
2415         if (dirfidp == NULL) {
2416             err = -ENOENT;
2417             goto out_nofid;
2418         }
2419         BUG_ON(dirfidp->fid_type != P9_FID_NONE);
2420         v9fs_co_name_to_path(pdu, &dirfidp->path, name->data, &new_path);
2421     } else {
2422         old_name = fidp->path.data;
2423         end = strrchr(old_name, '/');
2424         if (end) {
2425             end++;
2426         } else {
2427             end = old_name;
2428         }
2429         new_name = g_malloc0(end - old_name + name->size + 1);
2430         strncat(new_name, old_name, end - old_name);
2431         strncat(new_name + (end - old_name), name->data, name->size);
2432         v9fs_co_name_to_path(pdu, NULL, new_name, &new_path);
2433         g_free(new_name);
2434     }
2435     err = v9fs_co_rename(pdu, &fidp->path, &new_path);
2436     if (err < 0) {
2437         goto out;
2438     }
2439     /*
2440      * Fixup fid's pointing to the old name to
2441      * start pointing to the new name
2442      */
2443     for (tfidp = s->fid_list; tfidp; tfidp = tfidp->next) {
2444         if (v9fs_path_is_ancestor(&fidp->path, &tfidp->path)) {
2445             /* replace the name */
2446             v9fs_fix_path(&tfidp->path, &new_path, strlen(fidp->path.data));
2447         }
2448     }
2449 out:
2450     if (dirfidp) {
2451         put_fid(pdu, dirfidp);
2452     }
2453     v9fs_path_free(&new_path);
2454 out_nofid:
2455     return err;
2456 }
2457
2458 /* Only works with path name based fid */
2459 static void v9fs_rename(void *opaque)
2460 {
2461     int32_t fid;
2462     ssize_t err = 0;
2463     size_t offset = 7;
2464     V9fsString name;
2465     int32_t newdirfid;
2466     V9fsFidState *fidp;
2467     V9fsPDU *pdu = opaque;
2468     V9fsState *s = pdu->s;
2469
2470     v9fs_string_init(&name);
2471     err = pdu_unmarshal(pdu, offset, "dds", &fid, &newdirfid, &name);
2472     if (err < 0) {
2473         goto out_nofid;
2474     }
2475     fidp = get_fid(pdu, fid);
2476     if (fidp == NULL) {
2477         err = -ENOENT;
2478         goto out_nofid;
2479     }
2480     BUG_ON(fidp->fid_type != P9_FID_NONE);
2481     /* if fs driver is not path based, return EOPNOTSUPP */
2482     if (!(pdu->s->ctx.export_flags & V9FS_PATHNAME_FSCONTEXT)) {
2483         err = -EOPNOTSUPP;
2484         goto out;
2485     }
2486     v9fs_path_write_lock(s);
2487     err = v9fs_complete_rename(pdu, fidp, newdirfid, &name);
2488     v9fs_path_unlock(s);
2489     if (!err) {
2490         err = offset;
2491     }
2492 out:
2493     put_fid(pdu, fidp);
2494 out_nofid:
2495     complete_pdu(s, pdu, err);
2496     v9fs_string_free(&name);
2497 }
2498
2499 static void v9fs_fix_fid_paths(V9fsPDU *pdu, V9fsPath *olddir,
2500                                V9fsString *old_name, V9fsPath *newdir,
2501                                V9fsString *new_name)
2502 {
2503     V9fsFidState *tfidp;
2504     V9fsPath oldpath, newpath;
2505     V9fsState *s = pdu->s;
2506
2507
2508     v9fs_path_init(&oldpath);
2509     v9fs_path_init(&newpath);
2510     v9fs_co_name_to_path(pdu, olddir, old_name->data, &oldpath);
2511     v9fs_co_name_to_path(pdu, newdir, new_name->data, &newpath);
2512
2513     /*
2514      * Fixup fid's pointing to the old name to
2515      * start pointing to the new name
2516      */
2517     for (tfidp = s->fid_list; tfidp; tfidp = tfidp->next) {
2518         if (v9fs_path_is_ancestor(&oldpath, &tfidp->path)) {
2519             /* replace the name */
2520             v9fs_fix_path(&tfidp->path, &newpath, strlen(oldpath.data));
2521         }
2522     }
2523     v9fs_path_free(&oldpath);
2524     v9fs_path_free(&newpath);
2525 }
2526
2527 static int v9fs_complete_renameat(V9fsPDU *pdu, int32_t olddirfid,
2528                                   V9fsString *old_name, int32_t newdirfid,
2529                                   V9fsString *new_name)
2530 {
2531     int err = 0;
2532     V9fsState *s = pdu->s;
2533     V9fsFidState *newdirfidp = NULL, *olddirfidp = NULL;
2534
2535     olddirfidp = get_fid(pdu, olddirfid);
2536     if (olddirfidp == NULL) {
2537         err = -ENOENT;
2538         goto out;
2539     }
2540     if (newdirfid != -1) {
2541         newdirfidp = get_fid(pdu, newdirfid);
2542         if (newdirfidp == NULL) {
2543             err = -ENOENT;
2544             goto out;
2545         }
2546     } else {
2547         newdirfidp = get_fid(pdu, olddirfid);
2548     }
2549
2550     err = v9fs_co_renameat(pdu, &olddirfidp->path, old_name,
2551                            &newdirfidp->path, new_name);
2552     if (err < 0) {
2553         goto out;
2554     }
2555     if (s->ctx.export_flags & V9FS_PATHNAME_FSCONTEXT) {
2556         /* Only for path based fid  we need to do the below fixup */
2557         v9fs_fix_fid_paths(pdu, &olddirfidp->path, old_name,
2558                            &newdirfidp->path, new_name);
2559     }
2560 out:
2561     if (olddirfidp) {
2562         put_fid(pdu, olddirfidp);
2563     }
2564     if (newdirfidp) {
2565         put_fid(pdu, newdirfidp);
2566     }
2567     return err;
2568 }
2569
2570 static void v9fs_renameat(void *opaque)
2571 {
2572     ssize_t err = 0;
2573     size_t offset = 7;
2574     V9fsPDU *pdu = opaque;
2575     V9fsState *s = pdu->s;
2576     int32_t olddirfid, newdirfid;
2577     V9fsString old_name, new_name;
2578
2579     v9fs_string_init(&old_name);
2580     v9fs_string_init(&new_name);
2581     err = pdu_unmarshal(pdu, offset, "dsds", &olddirfid,
2582                         &old_name, &newdirfid, &new_name);
2583     if (err < 0) {
2584         goto out_err;
2585     }
2586
2587     v9fs_path_write_lock(s);
2588     err = v9fs_complete_renameat(pdu, olddirfid,
2589                                  &old_name, newdirfid, &new_name);
2590     v9fs_path_unlock(s);
2591     if (!err) {
2592         err = offset;
2593     }
2594
2595 out_err:
2596     complete_pdu(s, pdu, err);
2597     v9fs_string_free(&old_name);
2598     v9fs_string_free(&new_name);
2599 }
2600
2601 static void v9fs_wstat(void *opaque)
2602 {
2603     int32_t fid;
2604     int err = 0;
2605     int16_t unused;
2606     V9fsStat v9stat;
2607     size_t offset = 7;
2608     struct stat stbuf;
2609     V9fsFidState *fidp;
2610     V9fsPDU *pdu = opaque;
2611     V9fsState *s = pdu->s;
2612
2613     v9fs_stat_init(&v9stat);
2614     err = pdu_unmarshal(pdu, offset, "dwS", &fid, &unused, &v9stat);
2615     if (err < 0) {
2616         goto out_nofid;
2617     }
2618     trace_v9fs_wstat(pdu->tag, pdu->id, fid,
2619                      v9stat.mode, v9stat.atime, v9stat.mtime);
2620
2621     fidp = get_fid(pdu, fid);
2622     if (fidp == NULL) {
2623         err = -EINVAL;
2624         goto out_nofid;
2625     }
2626     /* do we need to sync the file? */
2627     if (donttouch_stat(&v9stat)) {
2628         err = v9fs_co_fsync(pdu, fidp, 0);
2629         goto out;
2630     }
2631     if (v9stat.mode != -1) {
2632         uint32_t v9_mode;
2633         err = v9fs_co_lstat(pdu, &fidp->path, &stbuf);
2634         if (err < 0) {
2635             goto out;
2636         }
2637         v9_mode = stat_to_v9mode(&stbuf);
2638         if ((v9stat.mode & P9_STAT_MODE_TYPE_BITS) !=
2639             (v9_mode & P9_STAT_MODE_TYPE_BITS)) {
2640             /* Attempting to change the type */
2641             err = -EIO;
2642             goto out;
2643         }
2644         err = v9fs_co_chmod(pdu, &fidp->path,
2645                             v9mode_to_mode(v9stat.mode,
2646                                            &v9stat.extension));
2647         if (err < 0) {
2648             goto out;
2649         }
2650     }
2651     if (v9stat.mtime != -1 || v9stat.atime != -1) {
2652         struct timespec times[2];
2653         if (v9stat.atime != -1) {
2654             times[0].tv_sec = v9stat.atime;
2655             times[0].tv_nsec = 0;
2656         } else {
2657             times[0].tv_nsec = UTIME_OMIT;
2658         }
2659         if (v9stat.mtime != -1) {
2660             times[1].tv_sec = v9stat.mtime;
2661             times[1].tv_nsec = 0;
2662         } else {
2663             times[1].tv_nsec = UTIME_OMIT;
2664         }
2665         err = v9fs_co_utimensat(pdu, &fidp->path, times);
2666         if (err < 0) {
2667             goto out;
2668         }
2669     }
2670     if (v9stat.n_gid != -1 || v9stat.n_uid != -1) {
2671         err = v9fs_co_chown(pdu, &fidp->path, v9stat.n_uid, v9stat.n_gid);
2672         if (err < 0) {
2673             goto out;
2674         }
2675     }
2676     if (v9stat.name.size != 0) {
2677         err = v9fs_complete_rename(pdu, fidp, -1, &v9stat.name);
2678         if (err < 0) {
2679             goto out;
2680         }
2681     }
2682     if (v9stat.length != -1) {
2683         err = v9fs_co_truncate(pdu, &fidp->path, v9stat.length);
2684         if (err < 0) {
2685             goto out;
2686         }
2687     }
2688     err = offset;
2689 out:
2690     put_fid(pdu, fidp);
2691 out_nofid:
2692     v9fs_stat_free(&v9stat);
2693     complete_pdu(s, pdu, err);
2694 }
2695
2696 static int v9fs_fill_statfs(V9fsState *s, V9fsPDU *pdu, struct statfs *stbuf)
2697 {
2698     uint32_t f_type;
2699     uint32_t f_bsize;
2700     uint64_t f_blocks;
2701     uint64_t f_bfree;
2702     uint64_t f_bavail;
2703     uint64_t f_files;
2704     uint64_t f_ffree;
2705     uint64_t fsid_val;
2706     uint32_t f_namelen;
2707     size_t offset = 7;
2708     int32_t bsize_factor;
2709
2710     /*
2711      * compute bsize factor based on host file system block size
2712      * and client msize
2713      */
2714     bsize_factor = (s->msize - P9_IOHDRSZ)/stbuf->f_bsize;
2715     if (!bsize_factor) {
2716         bsize_factor = 1;
2717     }
2718     f_type  = stbuf->f_type;
2719     f_bsize = stbuf->f_bsize;
2720     f_bsize *= bsize_factor;
2721     /*
2722      * f_bsize is adjusted(multiplied) by bsize factor, so we need to
2723      * adjust(divide) the number of blocks, free blocks and available
2724      * blocks by bsize factor
2725      */
2726     f_blocks = stbuf->f_blocks/bsize_factor;
2727     f_bfree  = stbuf->f_bfree/bsize_factor;
2728     f_bavail = stbuf->f_bavail/bsize_factor;
2729     f_files  = stbuf->f_files;
2730     f_ffree  = stbuf->f_ffree;
2731     fsid_val = (unsigned int) stbuf->f_fsid.__val[0] |
2732                (unsigned long long)stbuf->f_fsid.__val[1] << 32;
2733     f_namelen = stbuf->f_namelen;
2734
2735     return pdu_marshal(pdu, offset, "ddqqqqqqd",
2736                        f_type, f_bsize, f_blocks, f_bfree,
2737                        f_bavail, f_files, f_ffree,
2738                        fsid_val, f_namelen);
2739 }
2740
2741 static void v9fs_statfs(void *opaque)
2742 {
2743     int32_t fid;
2744     ssize_t retval = 0;
2745     size_t offset = 7;
2746     V9fsFidState *fidp;
2747     struct statfs stbuf;
2748     V9fsPDU *pdu = opaque;
2749     V9fsState *s = pdu->s;
2750
2751     retval = pdu_unmarshal(pdu, offset, "d", &fid);
2752     if (retval < 0) {
2753         goto out_nofid;
2754     }
2755     fidp = get_fid(pdu, fid);
2756     if (fidp == NULL) {
2757         retval = -ENOENT;
2758         goto out_nofid;
2759     }
2760     retval = v9fs_co_statfs(pdu, &fidp->path, &stbuf);
2761     if (retval < 0) {
2762         goto out;
2763     }
2764     retval = v9fs_fill_statfs(s, pdu, &stbuf);
2765     if (retval < 0) {
2766         goto out;
2767     }
2768     retval += offset;
2769 out:
2770     put_fid(pdu, fidp);
2771 out_nofid:
2772     complete_pdu(s, pdu, retval);
2773 }
2774
2775 static void v9fs_mknod(void *opaque)
2776 {
2777
2778     int mode;
2779     gid_t gid;
2780     int32_t fid;
2781     V9fsQID qid;
2782     int err = 0;
2783     int major, minor;
2784     size_t offset = 7;
2785     V9fsString name;
2786     struct stat stbuf;
2787     V9fsFidState *fidp;
2788     V9fsPDU *pdu = opaque;
2789     V9fsState *s = pdu->s;
2790
2791     v9fs_string_init(&name);
2792     err = pdu_unmarshal(pdu, offset, "dsdddd", &fid, &name, &mode,
2793                         &major, &minor, &gid);
2794     if (err < 0) {
2795         goto out_nofid;
2796     }
2797     trace_v9fs_mknod(pdu->tag, pdu->id, fid, mode, major, minor);
2798
2799     fidp = get_fid(pdu, fid);
2800     if (fidp == NULL) {
2801         err = -ENOENT;
2802         goto out_nofid;
2803     }
2804     err = v9fs_co_mknod(pdu, fidp, &name, fidp->uid, gid,
2805                         makedev(major, minor), mode, &stbuf);
2806     if (err < 0) {
2807         goto out;
2808     }
2809     stat_to_qid(&stbuf, &qid);
2810     err = pdu_marshal(pdu, offset, "Q", &qid);
2811     if (err < 0) {
2812         goto out;
2813     }
2814     err += offset;
2815     trace_v9fs_mknod_return(pdu->tag, pdu->id,
2816                             qid.type, qid.version, qid.path);
2817 out:
2818     put_fid(pdu, fidp);
2819 out_nofid:
2820     complete_pdu(s, pdu, err);
2821     v9fs_string_free(&name);
2822 }
2823
2824 /*
2825  * Implement posix byte range locking code
2826  * Server side handling of locking code is very simple, because 9p server in
2827  * QEMU can handle only one client. And most of the lock handling
2828  * (like conflict, merging) etc is done by the VFS layer itself, so no need to
2829  * do any thing in * qemu 9p server side lock code path.
2830  * So when a TLOCK request comes, always return success
2831  */
2832 static void v9fs_lock(void *opaque)
2833 {
2834     int8_t status;
2835     V9fsFlock flock;
2836     size_t offset = 7;
2837     struct stat stbuf;
2838     V9fsFidState *fidp;
2839     int32_t fid, err = 0;
2840     V9fsPDU *pdu = opaque;
2841     V9fsState *s = pdu->s;
2842
2843     status = P9_LOCK_ERROR;
2844     v9fs_string_init(&flock.client_id);
2845     err = pdu_unmarshal(pdu, offset, "dbdqqds", &fid, &flock.type,
2846                         &flock.flags, &flock.start, &flock.length,
2847                         &flock.proc_id, &flock.client_id);
2848     if (err < 0) {
2849         goto out_nofid;
2850     }
2851     trace_v9fs_lock(pdu->tag, pdu->id, fid,
2852                     flock.type, flock.start, flock.length);
2853
2854
2855     /* We support only block flag now (that too ignored currently) */
2856     if (flock.flags & ~P9_LOCK_FLAGS_BLOCK) {
2857         err = -EINVAL;
2858         goto out_nofid;
2859     }
2860     fidp = get_fid(pdu, fid);
2861     if (fidp == NULL) {
2862         err = -ENOENT;
2863         goto out_nofid;
2864     }
2865     err = v9fs_co_fstat(pdu, fidp, &stbuf);
2866     if (err < 0) {
2867         goto out;
2868     }
2869     status = P9_LOCK_SUCCESS;
2870 out:
2871     put_fid(pdu, fidp);
2872 out_nofid:
2873     err = pdu_marshal(pdu, offset, "b", status);
2874     if (err > 0) {
2875         err += offset;
2876     }
2877     trace_v9fs_lock_return(pdu->tag, pdu->id, status);
2878     complete_pdu(s, pdu, err);
2879     v9fs_string_free(&flock.client_id);
2880 }
2881
2882 /*
2883  * When a TGETLOCK request comes, always return success because all lock
2884  * handling is done by client's VFS layer.
2885  */
2886 static void v9fs_getlock(void *opaque)
2887 {
2888     size_t offset = 7;
2889     struct stat stbuf;
2890     V9fsFidState *fidp;
2891     V9fsGetlock glock;
2892     int32_t fid, err = 0;
2893     V9fsPDU *pdu = opaque;
2894     V9fsState *s = pdu->s;
2895
2896     v9fs_string_init(&glock.client_id);
2897     err = pdu_unmarshal(pdu, offset, "dbqqds", &fid, &glock.type,
2898                         &glock.start, &glock.length, &glock.proc_id,
2899                         &glock.client_id);
2900     if (err < 0) {
2901         goto out_nofid;
2902     }
2903     trace_v9fs_getlock(pdu->tag, pdu->id, fid,
2904                        glock.type, glock.start, glock.length);
2905
2906     fidp = get_fid(pdu, fid);
2907     if (fidp == NULL) {
2908         err = -ENOENT;
2909         goto out_nofid;
2910     }
2911     err = v9fs_co_fstat(pdu, fidp, &stbuf);
2912     if (err < 0) {
2913         goto out;
2914     }
2915     glock.type = P9_LOCK_TYPE_UNLCK;
2916     err = pdu_marshal(pdu, offset, "bqqds", glock.type,
2917                           glock.start, glock.length, glock.proc_id,
2918                           &glock.client_id);
2919     if (err < 0) {
2920         goto out;
2921     }
2922     err += offset;
2923     trace_v9fs_getlock_return(pdu->tag, pdu->id, glock.type, glock.start,
2924                               glock.length, glock.proc_id);
2925 out:
2926     put_fid(pdu, fidp);
2927 out_nofid:
2928     complete_pdu(s, pdu, err);
2929     v9fs_string_free(&glock.client_id);
2930 }
2931
2932 static void v9fs_mkdir(void *opaque)
2933 {
2934     V9fsPDU *pdu = opaque;
2935     size_t offset = 7;
2936     int32_t fid;
2937     struct stat stbuf;
2938     V9fsQID qid;
2939     V9fsString name;
2940     V9fsFidState *fidp;
2941     gid_t gid;
2942     int mode;
2943     int err = 0;
2944
2945     v9fs_string_init(&name);
2946     err = pdu_unmarshal(pdu, offset, "dsdd", &fid, &name, &mode, &gid);
2947     if (err < 0) {
2948         goto out_nofid;
2949     }
2950     trace_v9fs_mkdir(pdu->tag, pdu->id, fid, name.data, mode, gid);
2951
2952     fidp = get_fid(pdu, fid);
2953     if (fidp == NULL) {
2954         err = -ENOENT;
2955         goto out_nofid;
2956     }
2957     err = v9fs_co_mkdir(pdu, fidp, &name, mode, fidp->uid, gid, &stbuf);
2958     if (err < 0) {
2959         goto out;
2960     }
2961     stat_to_qid(&stbuf, &qid);
2962     err = pdu_marshal(pdu, offset, "Q", &qid);
2963     if (err < 0) {
2964         goto out;
2965     }
2966     err += offset;
2967     trace_v9fs_mkdir_return(pdu->tag, pdu->id,
2968                             qid.type, qid.version, qid.path, err);
2969 out:
2970     put_fid(pdu, fidp);
2971 out_nofid:
2972     complete_pdu(pdu->s, pdu, err);
2973     v9fs_string_free(&name);
2974 }
2975
2976 static void v9fs_xattrwalk(void *opaque)
2977 {
2978     int64_t size;
2979     V9fsString name;
2980     ssize_t err = 0;
2981     size_t offset = 7;
2982     int32_t fid, newfid;
2983     V9fsFidState *file_fidp;
2984     V9fsFidState *xattr_fidp = NULL;
2985     V9fsPDU *pdu = opaque;
2986     V9fsState *s = pdu->s;
2987
2988     v9fs_string_init(&name);
2989     err = pdu_unmarshal(pdu, offset, "dds", &fid, &newfid, &name);
2990     if (err < 0) {
2991         goto out_nofid;
2992     }
2993     trace_v9fs_xattrwalk(pdu->tag, pdu->id, fid, newfid, name.data);
2994
2995     file_fidp = get_fid(pdu, fid);
2996     if (file_fidp == NULL) {
2997         err = -ENOENT;
2998         goto out_nofid;
2999     }
3000     xattr_fidp = alloc_fid(s, newfid);
3001     if (xattr_fidp == NULL) {
3002         err = -EINVAL;
3003         goto out;
3004     }
3005     v9fs_path_copy(&xattr_fidp->path, &file_fidp->path);
3006     if (name.data == NULL) {
3007         /*
3008          * listxattr request. Get the size first
3009          */
3010         size = v9fs_co_llistxattr(pdu, &xattr_fidp->path, NULL, 0);
3011         if (size < 0) {
3012             err = size;
3013             clunk_fid(s, xattr_fidp->fid);
3014             goto out;
3015         }
3016         /*
3017          * Read the xattr value
3018          */
3019         xattr_fidp->fs.xattr.len = size;
3020         xattr_fidp->fid_type = P9_FID_XATTR;
3021         xattr_fidp->fs.xattr.copied_len = -1;
3022         if (size) {
3023             xattr_fidp->fs.xattr.value = g_malloc(size);
3024             err = v9fs_co_llistxattr(pdu, &xattr_fidp->path,
3025                                      xattr_fidp->fs.xattr.value,
3026                                      xattr_fidp->fs.xattr.len);
3027             if (err < 0) {
3028                 clunk_fid(s, xattr_fidp->fid);
3029                 goto out;
3030             }
3031         }
3032         err = pdu_marshal(pdu, offset, "q", size);
3033         if (err < 0) {
3034             goto out;
3035         }
3036         err += offset;
3037     } else {
3038         /*
3039          * specific xattr fid. We check for xattr
3040          * presence also collect the xattr size
3041          */
3042         size = v9fs_co_lgetxattr(pdu, &xattr_fidp->path,
3043                                  &name, NULL, 0);
3044         if (size < 0) {
3045             err = size;
3046             clunk_fid(s, xattr_fidp->fid);
3047             goto out;
3048         }
3049         /*
3050          * Read the xattr value
3051          */
3052         xattr_fidp->fs.xattr.len = size;
3053         xattr_fidp->fid_type = P9_FID_XATTR;
3054         xattr_fidp->fs.xattr.copied_len = -1;
3055         if (size) {
3056             xattr_fidp->fs.xattr.value = g_malloc(size);
3057             err = v9fs_co_lgetxattr(pdu, &xattr_fidp->path,
3058                                     &name, xattr_fidp->fs.xattr.value,
3059                                     xattr_fidp->fs.xattr.len);
3060             if (err < 0) {
3061                 clunk_fid(s, xattr_fidp->fid);
3062                 goto out;
3063             }
3064         }
3065         err = pdu_marshal(pdu, offset, "q", size);
3066         if (err < 0) {
3067             goto out;
3068         }
3069         err += offset;
3070     }
3071     trace_v9fs_xattrwalk_return(pdu->tag, pdu->id, size);
3072 out:
3073     put_fid(pdu, file_fidp);
3074     if (xattr_fidp) {
3075         put_fid(pdu, xattr_fidp);
3076     }
3077 out_nofid:
3078     complete_pdu(s, pdu, err);
3079     v9fs_string_free(&name);
3080 }
3081
3082 static void v9fs_xattrcreate(void *opaque)
3083 {
3084     int flags;
3085     int32_t fid;
3086     int64_t size;
3087     ssize_t err = 0;
3088     V9fsString name;
3089     size_t offset = 7;
3090     V9fsFidState *file_fidp;
3091     V9fsFidState *xattr_fidp;
3092     V9fsPDU *pdu = opaque;
3093     V9fsState *s = pdu->s;
3094
3095     v9fs_string_init(&name);
3096     err = pdu_unmarshal(pdu, offset, "dsqd", &fid, &name, &size, &flags);
3097     if (err < 0) {
3098         goto out_nofid;
3099     }
3100     trace_v9fs_xattrcreate(pdu->tag, pdu->id, fid, name.data, size, flags);
3101
3102     file_fidp = get_fid(pdu, fid);
3103     if (file_fidp == NULL) {
3104         err = -EINVAL;
3105         goto out_nofid;
3106     }
3107     /* Make the file fid point to xattr */
3108     xattr_fidp = file_fidp;
3109     xattr_fidp->fid_type = P9_FID_XATTR;
3110     xattr_fidp->fs.xattr.copied_len = 0;
3111     xattr_fidp->fs.xattr.len = size;
3112     xattr_fidp->fs.xattr.flags = flags;
3113     v9fs_string_init(&xattr_fidp->fs.xattr.name);
3114     v9fs_string_copy(&xattr_fidp->fs.xattr.name, &name);
3115     xattr_fidp->fs.xattr.value = g_malloc(size);
3116     err = offset;
3117     put_fid(pdu, file_fidp);
3118 out_nofid:
3119     complete_pdu(s, pdu, err);
3120     v9fs_string_free(&name);
3121 }
3122
3123 static void v9fs_readlink(void *opaque)
3124 {
3125     V9fsPDU *pdu = opaque;
3126     size_t offset = 7;
3127     V9fsString target;
3128     int32_t fid;
3129     int err = 0;
3130     V9fsFidState *fidp;
3131
3132     err = pdu_unmarshal(pdu, offset, "d", &fid);
3133     if (err < 0) {
3134         goto out_nofid;
3135     }
3136     trace_v9fs_readlink(pdu->tag, pdu->id, fid);
3137     fidp = get_fid(pdu, fid);
3138     if (fidp == NULL) {
3139         err = -ENOENT;
3140         goto out_nofid;
3141     }
3142
3143     v9fs_string_init(&target);
3144     err = v9fs_co_readlink(pdu, &fidp->path, &target);
3145     if (err < 0) {
3146         goto out;
3147     }
3148     err = pdu_marshal(pdu, offset, "s", &target);
3149     if (err < 0) {
3150         v9fs_string_free(&target);
3151         goto out;
3152     }
3153     err += offset;
3154     trace_v9fs_readlink_return(pdu->tag, pdu->id, target.data);
3155     v9fs_string_free(&target);
3156 out:
3157     put_fid(pdu, fidp);
3158 out_nofid:
3159     complete_pdu(pdu->s, pdu, err);
3160 }
3161
3162 static CoroutineEntry *pdu_co_handlers[] = {
3163     [P9_TREADDIR] = v9fs_readdir,
3164     [P9_TSTATFS] = v9fs_statfs,
3165     [P9_TGETATTR] = v9fs_getattr,
3166     [P9_TSETATTR] = v9fs_setattr,
3167     [P9_TXATTRWALK] = v9fs_xattrwalk,
3168     [P9_TXATTRCREATE] = v9fs_xattrcreate,
3169     [P9_TMKNOD] = v9fs_mknod,
3170     [P9_TRENAME] = v9fs_rename,
3171     [P9_TLOCK] = v9fs_lock,
3172     [P9_TGETLOCK] = v9fs_getlock,
3173     [P9_TRENAMEAT] = v9fs_renameat,
3174     [P9_TREADLINK] = v9fs_readlink,
3175     [P9_TUNLINKAT] = v9fs_unlinkat,
3176     [P9_TMKDIR] = v9fs_mkdir,
3177     [P9_TVERSION] = v9fs_version,
3178     [P9_TLOPEN] = v9fs_open,
3179     [P9_TATTACH] = v9fs_attach,
3180     [P9_TSTAT] = v9fs_stat,
3181     [P9_TWALK] = v9fs_walk,
3182     [P9_TCLUNK] = v9fs_clunk,
3183     [P9_TFSYNC] = v9fs_fsync,
3184     [P9_TOPEN] = v9fs_open,
3185     [P9_TREAD] = v9fs_read,
3186 #if 0
3187     [P9_TAUTH] = v9fs_auth,
3188 #endif
3189     [P9_TFLUSH] = v9fs_flush,
3190     [P9_TLINK] = v9fs_link,
3191     [P9_TSYMLINK] = v9fs_symlink,
3192     [P9_TCREATE] = v9fs_create,
3193     [P9_TLCREATE] = v9fs_lcreate,
3194     [P9_TWRITE] = v9fs_write,
3195     [P9_TWSTAT] = v9fs_wstat,
3196     [P9_TREMOVE] = v9fs_remove,
3197 };
3198
3199 static void v9fs_op_not_supp(void *opaque)
3200 {
3201     V9fsPDU *pdu = opaque;
3202     complete_pdu(pdu->s, pdu, -EOPNOTSUPP);
3203 }
3204
3205 static void v9fs_fs_ro(void *opaque)
3206 {
3207     V9fsPDU *pdu = opaque;
3208     complete_pdu(pdu->s, pdu, -EROFS);
3209 }
3210
3211 static inline bool is_read_only_op(V9fsPDU *pdu)
3212 {
3213     switch (pdu->id) {
3214     case P9_TREADDIR:
3215     case P9_TSTATFS:
3216     case P9_TGETATTR:
3217     case P9_TXATTRWALK:
3218     case P9_TLOCK:
3219     case P9_TGETLOCK:
3220     case P9_TREADLINK:
3221     case P9_TVERSION:
3222     case P9_TLOPEN:
3223     case P9_TATTACH:
3224     case P9_TSTAT:
3225     case P9_TWALK:
3226     case P9_TCLUNK:
3227     case P9_TFSYNC:
3228     case P9_TOPEN:
3229     case P9_TREAD:
3230     case P9_TAUTH:
3231     case P9_TFLUSH:
3232         return 1;
3233     default:
3234         return 0;
3235     }
3236 }
3237
3238 static void submit_pdu(V9fsState *s, V9fsPDU *pdu)
3239 {
3240     Coroutine *co;
3241     CoroutineEntry *handler;
3242
3243     if (pdu->id >= ARRAY_SIZE(pdu_co_handlers) ||
3244         (pdu_co_handlers[pdu->id] == NULL)) {
3245         handler = v9fs_op_not_supp;
3246     } else {
3247         handler = pdu_co_handlers[pdu->id];
3248     }
3249
3250     if (is_ro_export(&s->ctx) && !is_read_only_op(pdu)) {
3251         handler = v9fs_fs_ro;
3252     }
3253     co = qemu_coroutine_create(handler);
3254     qemu_coroutine_enter(co, pdu);
3255 }
3256
3257 void handle_9p_output(VirtIODevice *vdev, VirtQueue *vq)
3258 {
3259     V9fsState *s = (V9fsState *)vdev;
3260     V9fsPDU *pdu;
3261     ssize_t len;
3262
3263     while ((pdu = alloc_pdu(s)) &&
3264             (len = virtqueue_pop(vq, &pdu->elem)) != 0) {
3265         struct {
3266             uint32_t size_le;
3267             uint8_t id;
3268             uint16_t tag_le;
3269         } QEMU_PACKED out;
3270         int len;
3271
3272         pdu->s = s;
3273         BUG_ON(pdu->elem.out_num == 0 || pdu->elem.in_num == 0);
3274         QEMU_BUILD_BUG_ON(sizeof out != 7);
3275
3276         len = iov_to_buf(pdu->elem.out_sg, pdu->elem.out_num, 0,
3277                          &out, sizeof out);
3278         BUG_ON(len != sizeof out);
3279
3280         pdu->size = le32_to_cpu(out.size_le);
3281
3282         pdu->id = out.id;
3283         pdu->tag = le16_to_cpu(out.tag_le);
3284
3285         qemu_co_queue_init(&pdu->complete);
3286         submit_pdu(s, pdu);
3287     }
3288     free_pdu(s, pdu);
3289 }
3290
3291 static void __attribute__((__constructor__)) virtio_9p_set_fd_limit(void)
3292 {
3293     struct rlimit rlim;
3294     if (getrlimit(RLIMIT_NOFILE, &rlim) < 0) {
3295         fprintf(stderr, "Failed to get the resource limit\n");
3296         exit(1);
3297     }
3298     open_fd_hw = rlim.rlim_cur - MIN(400, rlim.rlim_cur/3);
3299     open_fd_rc = rlim.rlim_cur/2;
3300 }