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 "qemu/osdep.h" 15 #include <glib/gprintf.h> 16 #include "hw/virtio/virtio.h" 17 #include "qapi/error.h" 18 #include "qemu/error-report.h" 19 #include "qemu/iov.h" 20 #include "qemu/main-loop.h" 21 #include "qemu/sockets.h" 22 #include "virtio-9p.h" 23 #include "fsdev/qemu-fsdev.h" 24 #include "9p-xattr.h" 25 #include "coth.h" 26 #include "trace.h" 27 #include "migration/blocker.h" 28 #include "sysemu/qtest.h" 29 #include "qemu/xxhash.h" 30 #include <math.h> 31 #include <linux/limits.h> 32 33 int open_fd_hw; 34 int total_open_fd; 35 static int open_fd_rc; 36 37 enum { 38 Oread = 0x00, 39 Owrite = 0x01, 40 Ordwr = 0x02, 41 Oexec = 0x03, 42 Oexcl = 0x04, 43 Otrunc = 0x10, 44 Orexec = 0x20, 45 Orclose = 0x40, 46 Oappend = 0x80, 47 }; 48 49 static ssize_t pdu_marshal(V9fsPDU *pdu, size_t offset, const char *fmt, ...) 50 { 51 ssize_t ret; 52 va_list ap; 53 54 va_start(ap, fmt); 55 ret = pdu->s->transport->pdu_vmarshal(pdu, offset, fmt, ap); 56 va_end(ap); 57 58 return ret; 59 } 60 61 static ssize_t pdu_unmarshal(V9fsPDU *pdu, size_t offset, const char *fmt, ...) 62 { 63 ssize_t ret; 64 va_list ap; 65 66 va_start(ap, fmt); 67 ret = pdu->s->transport->pdu_vunmarshal(pdu, offset, fmt, ap); 68 va_end(ap); 69 70 return ret; 71 } 72 73 static int omode_to_uflags(int8_t mode) 74 { 75 int ret = 0; 76 77 switch (mode & 3) { 78 case Oread: 79 ret = O_RDONLY; 80 break; 81 case Ordwr: 82 ret = O_RDWR; 83 break; 84 case Owrite: 85 ret = O_WRONLY; 86 break; 87 case Oexec: 88 ret = O_RDONLY; 89 break; 90 } 91 92 if (mode & Otrunc) { 93 ret |= O_TRUNC; 94 } 95 96 if (mode & Oappend) { 97 ret |= O_APPEND; 98 } 99 100 if (mode & Oexcl) { 101 ret |= O_EXCL; 102 } 103 104 return ret; 105 } 106 107 typedef struct DotlOpenflagMap { 108 int dotl_flag; 109 int open_flag; 110 } DotlOpenflagMap; 111 112 static int dotl_to_open_flags(int flags) 113 { 114 int i; 115 /* 116 * We have same bits for P9_DOTL_READONLY, P9_DOTL_WRONLY 117 * and P9_DOTL_NOACCESS 118 */ 119 int oflags = flags & O_ACCMODE; 120 121 DotlOpenflagMap dotl_oflag_map[] = { 122 { P9_DOTL_CREATE, O_CREAT }, 123 { P9_DOTL_EXCL, O_EXCL }, 124 { P9_DOTL_NOCTTY , O_NOCTTY }, 125 { P9_DOTL_TRUNC, O_TRUNC }, 126 { P9_DOTL_APPEND, O_APPEND }, 127 { P9_DOTL_NONBLOCK, O_NONBLOCK } , 128 { P9_DOTL_DSYNC, O_DSYNC }, 129 { P9_DOTL_FASYNC, FASYNC }, 130 { P9_DOTL_DIRECT, O_DIRECT }, 131 { P9_DOTL_LARGEFILE, O_LARGEFILE }, 132 { P9_DOTL_DIRECTORY, O_DIRECTORY }, 133 { P9_DOTL_NOFOLLOW, O_NOFOLLOW }, 134 { P9_DOTL_NOATIME, O_NOATIME }, 135 { P9_DOTL_SYNC, O_SYNC }, 136 }; 137 138 for (i = 0; i < ARRAY_SIZE(dotl_oflag_map); i++) { 139 if (flags & dotl_oflag_map[i].dotl_flag) { 140 oflags |= dotl_oflag_map[i].open_flag; 141 } 142 } 143 144 return oflags; 145 } 146 147 void cred_init(FsCred *credp) 148 { 149 credp->fc_uid = -1; 150 credp->fc_gid = -1; 151 credp->fc_mode = -1; 152 credp->fc_rdev = -1; 153 } 154 155 static int get_dotl_openflags(V9fsState *s, int oflags) 156 { 157 int flags; 158 /* 159 * Filter the client open flags 160 */ 161 flags = dotl_to_open_flags(oflags); 162 flags &= ~(O_NOCTTY | O_ASYNC | O_CREAT); 163 /* 164 * Ignore direct disk access hint until the server supports it. 165 */ 166 flags &= ~O_DIRECT; 167 return flags; 168 } 169 170 void v9fs_path_init(V9fsPath *path) 171 { 172 path->data = NULL; 173 path->size = 0; 174 } 175 176 void v9fs_path_free(V9fsPath *path) 177 { 178 g_free(path->data); 179 path->data = NULL; 180 path->size = 0; 181 } 182 183 184 void GCC_FMT_ATTR(2, 3) 185 v9fs_path_sprintf(V9fsPath *path, const char *fmt, ...) 186 { 187 va_list ap; 188 189 v9fs_path_free(path); 190 191 va_start(ap, fmt); 192 /* Bump the size for including terminating NULL */ 193 path->size = g_vasprintf(&path->data, fmt, ap) + 1; 194 va_end(ap); 195 } 196 197 void v9fs_path_copy(V9fsPath *dst, const V9fsPath *src) 198 { 199 v9fs_path_free(dst); 200 dst->size = src->size; 201 dst->data = g_memdup(src->data, src->size); 202 } 203 204 int v9fs_name_to_path(V9fsState *s, V9fsPath *dirpath, 205 const char *name, V9fsPath *path) 206 { 207 int err; 208 err = s->ops->name_to_path(&s->ctx, dirpath, name, path); 209 if (err < 0) { 210 err = -errno; 211 } 212 return err; 213 } 214 215 /* 216 * Return TRUE if s1 is an ancestor of s2. 217 * 218 * E.g. "a/b" is an ancestor of "a/b/c" but not of "a/bc/d". 219 * As a special case, We treat s1 as ancestor of s2 if they are same! 220 */ 221 static int v9fs_path_is_ancestor(V9fsPath *s1, V9fsPath *s2) 222 { 223 if (!strncmp(s1->data, s2->data, s1->size - 1)) { 224 if (s2->data[s1->size - 1] == '\0' || s2->data[s1->size - 1] == '/') { 225 return 1; 226 } 227 } 228 return 0; 229 } 230 231 static size_t v9fs_string_size(V9fsString *str) 232 { 233 return str->size; 234 } 235 236 /* 237 * returns 0 if fid got re-opened, 1 if not, < 0 on error */ 238 static int coroutine_fn v9fs_reopen_fid(V9fsPDU *pdu, V9fsFidState *f) 239 { 240 int err = 1; 241 if (f->fid_type == P9_FID_FILE) { 242 if (f->fs.fd == -1) { 243 do { 244 err = v9fs_co_open(pdu, f, f->open_flags); 245 } while (err == -EINTR && !pdu->cancelled); 246 } 247 } else if (f->fid_type == P9_FID_DIR) { 248 if (f->fs.dir.stream == NULL) { 249 do { 250 err = v9fs_co_opendir(pdu, f); 251 } while (err == -EINTR && !pdu->cancelled); 252 } 253 } 254 return err; 255 } 256 257 static V9fsFidState *coroutine_fn get_fid(V9fsPDU *pdu, int32_t fid) 258 { 259 int err; 260 V9fsFidState *f; 261 V9fsState *s = pdu->s; 262 263 for (f = s->fid_list; f; f = f->next) { 264 BUG_ON(f->clunked); 265 if (f->fid == fid) { 266 /* 267 * Update the fid ref upfront so that 268 * we don't get reclaimed when we yield 269 * in open later. 270 */ 271 f->ref++; 272 /* 273 * check whether we need to reopen the 274 * file. We might have closed the fd 275 * while trying to free up some file 276 * descriptors. 277 */ 278 err = v9fs_reopen_fid(pdu, f); 279 if (err < 0) { 280 f->ref--; 281 return NULL; 282 } 283 /* 284 * Mark the fid as referenced so that the LRU 285 * reclaim won't close the file descriptor 286 */ 287 f->flags |= FID_REFERENCED; 288 return f; 289 } 290 } 291 return NULL; 292 } 293 294 static V9fsFidState *alloc_fid(V9fsState *s, int32_t fid) 295 { 296 V9fsFidState *f; 297 298 for (f = s->fid_list; f; f = f->next) { 299 /* If fid is already there return NULL */ 300 BUG_ON(f->clunked); 301 if (f->fid == fid) { 302 return NULL; 303 } 304 } 305 f = g_malloc0(sizeof(V9fsFidState)); 306 f->fid = fid; 307 f->fid_type = P9_FID_NONE; 308 f->ref = 1; 309 /* 310 * Mark the fid as referenced so that the LRU 311 * reclaim won't close the file descriptor 312 */ 313 f->flags |= FID_REFERENCED; 314 f->next = s->fid_list; 315 s->fid_list = f; 316 317 v9fs_readdir_init(&f->fs.dir); 318 v9fs_readdir_init(&f->fs_reclaim.dir); 319 320 return f; 321 } 322 323 static int coroutine_fn v9fs_xattr_fid_clunk(V9fsPDU *pdu, V9fsFidState *fidp) 324 { 325 int retval = 0; 326 327 if (fidp->fs.xattr.xattrwalk_fid) { 328 /* getxattr/listxattr fid */ 329 goto free_value; 330 } 331 /* 332 * if this is fid for setxattr. clunk should 333 * result in setxattr localcall 334 */ 335 if (fidp->fs.xattr.len != fidp->fs.xattr.copied_len) { 336 /* clunk after partial write */ 337 retval = -EINVAL; 338 goto free_out; 339 } 340 if (fidp->fs.xattr.len) { 341 retval = v9fs_co_lsetxattr(pdu, &fidp->path, &fidp->fs.xattr.name, 342 fidp->fs.xattr.value, 343 fidp->fs.xattr.len, 344 fidp->fs.xattr.flags); 345 } else { 346 retval = v9fs_co_lremovexattr(pdu, &fidp->path, &fidp->fs.xattr.name); 347 } 348 free_out: 349 v9fs_string_free(&fidp->fs.xattr.name); 350 free_value: 351 g_free(fidp->fs.xattr.value); 352 return retval; 353 } 354 355 static int coroutine_fn free_fid(V9fsPDU *pdu, V9fsFidState *fidp) 356 { 357 int retval = 0; 358 359 if (fidp->fid_type == P9_FID_FILE) { 360 /* If we reclaimed the fd no need to close */ 361 if (fidp->fs.fd != -1) { 362 retval = v9fs_co_close(pdu, &fidp->fs); 363 } 364 } else if (fidp->fid_type == P9_FID_DIR) { 365 if (fidp->fs.dir.stream != NULL) { 366 retval = v9fs_co_closedir(pdu, &fidp->fs); 367 } 368 } else if (fidp->fid_type == P9_FID_XATTR) { 369 retval = v9fs_xattr_fid_clunk(pdu, fidp); 370 } 371 v9fs_path_free(&fidp->path); 372 g_free(fidp); 373 return retval; 374 } 375 376 static int coroutine_fn put_fid(V9fsPDU *pdu, V9fsFidState *fidp) 377 { 378 BUG_ON(!fidp->ref); 379 fidp->ref--; 380 /* 381 * Don't free the fid if it is in reclaim list 382 */ 383 if (!fidp->ref && fidp->clunked) { 384 if (fidp->fid == pdu->s->root_fid) { 385 /* 386 * if the clunked fid is root fid then we 387 * have unmounted the fs on the client side. 388 * delete the migration blocker. Ideally, this 389 * should be hooked to transport close notification 390 */ 391 if (pdu->s->migration_blocker) { 392 migrate_del_blocker(pdu->s->migration_blocker); 393 error_free(pdu->s->migration_blocker); 394 pdu->s->migration_blocker = NULL; 395 } 396 } 397 return free_fid(pdu, fidp); 398 } 399 return 0; 400 } 401 402 static V9fsFidState *clunk_fid(V9fsState *s, int32_t fid) 403 { 404 V9fsFidState **fidpp, *fidp; 405 406 for (fidpp = &s->fid_list; *fidpp; fidpp = &(*fidpp)->next) { 407 if ((*fidpp)->fid == fid) { 408 break; 409 } 410 } 411 if (*fidpp == NULL) { 412 return NULL; 413 } 414 fidp = *fidpp; 415 *fidpp = fidp->next; 416 fidp->clunked = 1; 417 return fidp; 418 } 419 420 void coroutine_fn v9fs_reclaim_fd(V9fsPDU *pdu) 421 { 422 int reclaim_count = 0; 423 V9fsState *s = pdu->s; 424 V9fsFidState *f, *reclaim_list = NULL; 425 426 for (f = s->fid_list; f; f = f->next) { 427 /* 428 * Unlink fids cannot be reclaimed. Check 429 * for them and skip them. Also skip fids 430 * currently being operated on. 431 */ 432 if (f->ref || f->flags & FID_NON_RECLAIMABLE) { 433 continue; 434 } 435 /* 436 * if it is a recently referenced fid 437 * we leave the fid untouched and clear the 438 * reference bit. We come back to it later 439 * in the next iteration. (a simple LRU without 440 * moving list elements around) 441 */ 442 if (f->flags & FID_REFERENCED) { 443 f->flags &= ~FID_REFERENCED; 444 continue; 445 } 446 /* 447 * Add fids to reclaim list. 448 */ 449 if (f->fid_type == P9_FID_FILE) { 450 if (f->fs.fd != -1) { 451 /* 452 * Up the reference count so that 453 * a clunk request won't free this fid 454 */ 455 f->ref++; 456 f->rclm_lst = reclaim_list; 457 reclaim_list = f; 458 f->fs_reclaim.fd = f->fs.fd; 459 f->fs.fd = -1; 460 reclaim_count++; 461 } 462 } else if (f->fid_type == P9_FID_DIR) { 463 if (f->fs.dir.stream != NULL) { 464 /* 465 * Up the reference count so that 466 * a clunk request won't free this fid 467 */ 468 f->ref++; 469 f->rclm_lst = reclaim_list; 470 reclaim_list = f; 471 f->fs_reclaim.dir.stream = f->fs.dir.stream; 472 f->fs.dir.stream = NULL; 473 reclaim_count++; 474 } 475 } 476 if (reclaim_count >= open_fd_rc) { 477 break; 478 } 479 } 480 /* 481 * Now close the fid in reclaim list. Free them if they 482 * are already clunked. 483 */ 484 while (reclaim_list) { 485 f = reclaim_list; 486 reclaim_list = f->rclm_lst; 487 if (f->fid_type == P9_FID_FILE) { 488 v9fs_co_close(pdu, &f->fs_reclaim); 489 } else if (f->fid_type == P9_FID_DIR) { 490 v9fs_co_closedir(pdu, &f->fs_reclaim); 491 } 492 f->rclm_lst = NULL; 493 /* 494 * Now drop the fid reference, free it 495 * if clunked. 496 */ 497 put_fid(pdu, f); 498 } 499 } 500 501 static int coroutine_fn v9fs_mark_fids_unreclaim(V9fsPDU *pdu, V9fsPath *path) 502 { 503 int err; 504 V9fsState *s = pdu->s; 505 V9fsFidState *fidp, head_fid; 506 507 head_fid.next = s->fid_list; 508 for (fidp = s->fid_list; fidp; fidp = fidp->next) { 509 if (fidp->path.size != path->size) { 510 continue; 511 } 512 if (!memcmp(fidp->path.data, path->data, path->size)) { 513 /* Mark the fid non reclaimable. */ 514 fidp->flags |= FID_NON_RECLAIMABLE; 515 516 /* reopen the file/dir if already closed */ 517 err = v9fs_reopen_fid(pdu, fidp); 518 if (err < 0) { 519 return err; 520 } 521 /* 522 * Go back to head of fid list because 523 * the list could have got updated when 524 * switched to the worker thread 525 */ 526 if (err == 0) { 527 fidp = &head_fid; 528 } 529 } 530 } 531 return 0; 532 } 533 534 static void coroutine_fn virtfs_reset(V9fsPDU *pdu) 535 { 536 V9fsState *s = pdu->s; 537 V9fsFidState *fidp; 538 539 /* Free all fids */ 540 while (s->fid_list) { 541 /* Get fid */ 542 fidp = s->fid_list; 543 fidp->ref++; 544 545 /* Clunk fid */ 546 s->fid_list = fidp->next; 547 fidp->clunked = 1; 548 549 put_fid(pdu, fidp); 550 } 551 } 552 553 #define P9_QID_TYPE_DIR 0x80 554 #define P9_QID_TYPE_SYMLINK 0x02 555 556 #define P9_STAT_MODE_DIR 0x80000000 557 #define P9_STAT_MODE_APPEND 0x40000000 558 #define P9_STAT_MODE_EXCL 0x20000000 559 #define P9_STAT_MODE_MOUNT 0x10000000 560 #define P9_STAT_MODE_AUTH 0x08000000 561 #define P9_STAT_MODE_TMP 0x04000000 562 #define P9_STAT_MODE_SYMLINK 0x02000000 563 #define P9_STAT_MODE_LINK 0x01000000 564 #define P9_STAT_MODE_DEVICE 0x00800000 565 #define P9_STAT_MODE_NAMED_PIPE 0x00200000 566 #define P9_STAT_MODE_SOCKET 0x00100000 567 #define P9_STAT_MODE_SETUID 0x00080000 568 #define P9_STAT_MODE_SETGID 0x00040000 569 #define P9_STAT_MODE_SETVTX 0x00010000 570 571 #define P9_STAT_MODE_TYPE_BITS (P9_STAT_MODE_DIR | \ 572 P9_STAT_MODE_SYMLINK | \ 573 P9_STAT_MODE_LINK | \ 574 P9_STAT_MODE_DEVICE | \ 575 P9_STAT_MODE_NAMED_PIPE | \ 576 P9_STAT_MODE_SOCKET) 577 578 /* Mirrors all bits of a byte. So e.g. binary 10100000 would become 00000101. */ 579 static inline uint8_t mirror8bit(uint8_t byte) 580 { 581 return (byte * 0x0202020202ULL & 0x010884422010ULL) % 1023; 582 } 583 584 /* Same as mirror8bit() just for a 64 bit data type instead for a byte. */ 585 static inline uint64_t mirror64bit(uint64_t value) 586 { 587 return ((uint64_t)mirror8bit(value & 0xff) << 56) | 588 ((uint64_t)mirror8bit((value >> 8) & 0xff) << 48) | 589 ((uint64_t)mirror8bit((value >> 16) & 0xff) << 40) | 590 ((uint64_t)mirror8bit((value >> 24) & 0xff) << 32) | 591 ((uint64_t)mirror8bit((value >> 32) & 0xff) << 24) | 592 ((uint64_t)mirror8bit((value >> 40) & 0xff) << 16) | 593 ((uint64_t)mirror8bit((value >> 48) & 0xff) << 8) | 594 ((uint64_t)mirror8bit((value >> 56) & 0xff)); 595 } 596 597 /** 598 * @brief Parameter k for the Exponential Golomb algorihm to be used. 599 * 600 * The smaller this value, the smaller the minimum bit count for the Exp. 601 * Golomb generated affixes will be (at lowest index) however for the 602 * price of having higher maximum bit count of generated affixes (at highest 603 * index). Likewise increasing this parameter yields in smaller maximum bit 604 * count for the price of having higher minimum bit count. 605 * 606 * In practice that means: a good value for k depends on the expected amount 607 * of devices to be exposed by one export. For a small amount of devices k 608 * should be small, for a large amount of devices k might be increased 609 * instead. The default of k=0 should be fine for most users though. 610 * 611 * @b IMPORTANT: In case this ever becomes a runtime parameter; the value of 612 * k should not change as long as guest is still running! Because that would 613 * cause completely different inode numbers to be generated on guest. 614 */ 615 #define EXP_GOLOMB_K 0 616 617 /** 618 * @brief Exponential Golomb algorithm for arbitrary k (including k=0). 619 * 620 * The Exponential Golomb algorithm generates @b prefixes (@b not suffixes!) 621 * with growing length and with the mathematical property of being 622 * "prefix-free". The latter means the generated prefixes can be prepended 623 * in front of arbitrary numbers and the resulting concatenated numbers are 624 * guaranteed to be always unique. 625 * 626 * This is a minor adjustment to the original Exp. Golomb algorithm in the 627 * sense that lowest allowed index (@param n) starts with 1, not with zero. 628 * 629 * @param n - natural number (or index) of the prefix to be generated 630 * (1, 2, 3, ...) 631 * @param k - parameter k of Exp. Golomb algorithm to be used 632 * (see comment on EXP_GOLOMB_K macro for details about k) 633 */ 634 static VariLenAffix expGolombEncode(uint64_t n, int k) 635 { 636 const uint64_t value = n + (1 << k) - 1; 637 const int bits = (int) log2(value) + 1; 638 return (VariLenAffix) { 639 .type = AffixType_Prefix, 640 .value = value, 641 .bits = bits + MAX((bits - 1 - k), 0) 642 }; 643 } 644 645 /** 646 * @brief Converts a suffix into a prefix, or a prefix into a suffix. 647 * 648 * Simply mirror all bits of the affix value, for the purpose to preserve 649 * respectively the mathematical "prefix-free" or "suffix-free" property 650 * after the conversion. 651 * 652 * If a passed prefix is suitable to create unique numbers, then the 653 * returned suffix is suitable to create unique numbers as well (and vice 654 * versa). 655 */ 656 static VariLenAffix invertAffix(const VariLenAffix *affix) 657 { 658 return (VariLenAffix) { 659 .type = 660 (affix->type == AffixType_Suffix) ? 661 AffixType_Prefix : AffixType_Suffix, 662 .value = 663 mirror64bit(affix->value) >> 664 ((sizeof(affix->value) * 8) - affix->bits), 665 .bits = affix->bits 666 }; 667 } 668 669 /** 670 * @brief Generates suffix numbers with "suffix-free" property. 671 * 672 * This is just a wrapper function on top of the Exp. Golomb algorithm. 673 * 674 * Since the Exp. Golomb algorithm generates prefixes, but we need suffixes, 675 * this function converts the Exp. Golomb prefixes into appropriate suffixes 676 * which are still suitable for generating unique numbers. 677 * 678 * @param n - natural number (or index) of the suffix to be generated 679 * (1, 2, 3, ...) 680 */ 681 static VariLenAffix affixForIndex(uint64_t index) 682 { 683 VariLenAffix prefix; 684 prefix = expGolombEncode(index, EXP_GOLOMB_K); 685 return invertAffix(&prefix); /* convert prefix to suffix */ 686 } 687 688 /* creative abuse of tb_hash_func7, which is based on xxhash */ 689 static uint32_t qpp_hash(QppEntry e) 690 { 691 return qemu_xxhash7(e.ino_prefix, e.dev, 0, 0, 0); 692 } 693 694 static uint32_t qpf_hash(QpfEntry e) 695 { 696 return qemu_xxhash7(e.ino, e.dev, 0, 0, 0); 697 } 698 699 static bool qpd_cmp_func(const void *obj, const void *userp) 700 { 701 const QpdEntry *e1 = obj, *e2 = userp; 702 return e1->dev == e2->dev; 703 } 704 705 static bool qpp_cmp_func(const void *obj, const void *userp) 706 { 707 const QppEntry *e1 = obj, *e2 = userp; 708 return e1->dev == e2->dev && e1->ino_prefix == e2->ino_prefix; 709 } 710 711 static bool qpf_cmp_func(const void *obj, const void *userp) 712 { 713 const QpfEntry *e1 = obj, *e2 = userp; 714 return e1->dev == e2->dev && e1->ino == e2->ino; 715 } 716 717 static void qp_table_remove(void *p, uint32_t h, void *up) 718 { 719 g_free(p); 720 } 721 722 static void qp_table_destroy(struct qht *ht) 723 { 724 if (!ht || !ht->map) { 725 return; 726 } 727 qht_iter(ht, qp_table_remove, NULL); 728 qht_destroy(ht); 729 } 730 731 static void qpd_table_init(struct qht *ht) 732 { 733 qht_init(ht, qpd_cmp_func, 1, QHT_MODE_AUTO_RESIZE); 734 } 735 736 static void qpp_table_init(struct qht *ht) 737 { 738 qht_init(ht, qpp_cmp_func, 1, QHT_MODE_AUTO_RESIZE); 739 } 740 741 static void qpf_table_init(struct qht *ht) 742 { 743 qht_init(ht, qpf_cmp_func, 1 << 16, QHT_MODE_AUTO_RESIZE); 744 } 745 746 /* 747 * Returns how many (high end) bits of inode numbers of the passed fs 748 * device shall be used (in combination with the device number) to 749 * generate hash values for qpp_table entries. 750 * 751 * This function is required if variable length suffixes are used for inode 752 * number mapping on guest level. Since a device may end up having multiple 753 * entries in qpp_table, each entry most probably with a different suffix 754 * length, we thus need this function in conjunction with qpd_table to 755 * "agree" about a fix amount of bits (per device) to be always used for 756 * generating hash values for the purpose of accessing qpp_table in order 757 * get consistent behaviour when accessing qpp_table. 758 */ 759 static int qid_inode_prefix_hash_bits(V9fsPDU *pdu, dev_t dev) 760 { 761 QpdEntry lookup = { 762 .dev = dev 763 }, *val; 764 uint32_t hash = dev; 765 VariLenAffix affix; 766 767 val = qht_lookup(&pdu->s->qpd_table, &lookup, hash); 768 if (!val) { 769 val = g_malloc0(sizeof(QpdEntry)); 770 *val = lookup; 771 affix = affixForIndex(pdu->s->qp_affix_next); 772 val->prefix_bits = affix.bits; 773 qht_insert(&pdu->s->qpd_table, val, hash, NULL); 774 pdu->s->qp_ndevices++; 775 } 776 return val->prefix_bits; 777 } 778 779 /** 780 * @brief Slow / full mapping host inode nr -> guest inode nr. 781 * 782 * This function performs a slower and much more costly remapping of an 783 * original file inode number on host to an appropriate different inode 784 * number on guest. For every (dev, inode) combination on host a new 785 * sequential number is generated, cached and exposed as inode number on 786 * guest. 787 * 788 * This is just a "last resort" fallback solution if the much faster/cheaper 789 * qid_path_suffixmap() failed. In practice this slow / full mapping is not 790 * expected ever to be used at all though. 791 * 792 * @see qid_path_suffixmap() for details 793 * 794 */ 795 static int qid_path_fullmap(V9fsPDU *pdu, const struct stat *stbuf, 796 uint64_t *path) 797 { 798 QpfEntry lookup = { 799 .dev = stbuf->st_dev, 800 .ino = stbuf->st_ino 801 }, *val; 802 uint32_t hash = qpf_hash(lookup); 803 VariLenAffix affix; 804 805 val = qht_lookup(&pdu->s->qpf_table, &lookup, hash); 806 807 if (!val) { 808 if (pdu->s->qp_fullpath_next == 0) { 809 /* no more files can be mapped :'( */ 810 error_report_once( 811 "9p: No more prefixes available for remapping inodes from " 812 "host to guest." 813 ); 814 return -ENFILE; 815 } 816 817 val = g_malloc0(sizeof(QppEntry)); 818 *val = lookup; 819 820 /* new unique inode and device combo */ 821 affix = affixForIndex( 822 1ULL << (sizeof(pdu->s->qp_affix_next) * 8) 823 ); 824 val->path = (pdu->s->qp_fullpath_next++ << affix.bits) | affix.value; 825 pdu->s->qp_fullpath_next &= ((1ULL << (64 - affix.bits)) - 1); 826 qht_insert(&pdu->s->qpf_table, val, hash, NULL); 827 } 828 829 *path = val->path; 830 return 0; 831 } 832 833 /** 834 * @brief Quick mapping host inode nr -> guest inode nr. 835 * 836 * This function performs quick remapping of an original file inode number 837 * on host to an appropriate different inode number on guest. This remapping 838 * of inodes is required to avoid inode nr collisions on guest which would 839 * happen if the 9p export contains more than 1 exported file system (or 840 * more than 1 file system data set), because unlike on host level where the 841 * files would have different device nrs, all files exported by 9p would 842 * share the same device nr on guest (the device nr of the virtual 9p device 843 * that is). 844 * 845 * Inode remapping is performed by chopping off high end bits of the original 846 * inode number from host, shifting the result upwards and then assigning a 847 * generated suffix number for the low end bits, where the same suffix number 848 * will be shared by all inodes with the same device id AND the same high end 849 * bits that have been chopped off. That approach utilizes the fact that inode 850 * numbers very likely share the same high end bits (i.e. due to their common 851 * sequential generation by file systems) and hence we only have to generate 852 * and track a very limited amount of suffixes in practice due to that. 853 * 854 * We generate variable size suffixes for that purpose. The 1st generated 855 * suffix will only have 1 bit and hence we only need to chop off 1 bit from 856 * the original inode number. The subsequent suffixes being generated will 857 * grow in (bit) size subsequently, i.e. the 2nd and 3rd suffix being 858 * generated will have 3 bits and hence we have to chop off 3 bits from their 859 * original inodes, and so on. That approach of using variable length suffixes 860 * (i.e. over fixed size ones) utilizes the fact that in practice only a very 861 * limited amount of devices are shared by the same export (e.g. typically 862 * less than 2 dozen devices per 9p export), so in practice we need to chop 863 * off less bits than with fixed size prefixes and yet are flexible to add 864 * new devices at runtime below host's export directory at any time without 865 * having to reboot guest nor requiring to reconfigure guest for that. And due 866 * to the very limited amount of original high end bits that we chop off that 867 * way, the total amount of suffixes we need to generate is less than by using 868 * fixed size prefixes and hence it also improves performance of the inode 869 * remapping algorithm, and finally has the nice side effect that the inode 870 * numbers on guest will be much smaller & human friendly. ;-) 871 */ 872 static int qid_path_suffixmap(V9fsPDU *pdu, const struct stat *stbuf, 873 uint64_t *path) 874 { 875 const int ino_hash_bits = qid_inode_prefix_hash_bits(pdu, stbuf->st_dev); 876 QppEntry lookup = { 877 .dev = stbuf->st_dev, 878 .ino_prefix = (uint16_t) (stbuf->st_ino >> (64 - ino_hash_bits)) 879 }, *val; 880 uint32_t hash = qpp_hash(lookup); 881 882 val = qht_lookup(&pdu->s->qpp_table, &lookup, hash); 883 884 if (!val) { 885 if (pdu->s->qp_affix_next == 0) { 886 /* we ran out of affixes */ 887 warn_report_once( 888 "9p: Potential degraded performance of inode remapping" 889 ); 890 return -ENFILE; 891 } 892 893 val = g_malloc0(sizeof(QppEntry)); 894 *val = lookup; 895 896 /* new unique inode affix and device combo */ 897 val->qp_affix_index = pdu->s->qp_affix_next++; 898 val->qp_affix = affixForIndex(val->qp_affix_index); 899 qht_insert(&pdu->s->qpp_table, val, hash, NULL); 900 } 901 /* assuming generated affix to be suffix type, not prefix */ 902 *path = (stbuf->st_ino << val->qp_affix.bits) | val->qp_affix.value; 903 return 0; 904 } 905 906 static int stat_to_qid(V9fsPDU *pdu, const struct stat *stbuf, V9fsQID *qidp) 907 { 908 int err; 909 size_t size; 910 911 if (pdu->s->ctx.export_flags & V9FS_REMAP_INODES) { 912 /* map inode+device to qid path (fast path) */ 913 err = qid_path_suffixmap(pdu, stbuf, &qidp->path); 914 if (err == -ENFILE) { 915 /* fast path didn't work, fall back to full map */ 916 err = qid_path_fullmap(pdu, stbuf, &qidp->path); 917 } 918 if (err) { 919 return err; 920 } 921 } else { 922 if (pdu->s->dev_id != stbuf->st_dev) { 923 if (pdu->s->ctx.export_flags & V9FS_FORBID_MULTIDEVS) { 924 error_report_once( 925 "9p: Multiple devices detected in same VirtFS export. " 926 "Access of guest to additional devices is (partly) " 927 "denied due to virtfs option 'multidevs=forbid' being " 928 "effective." 929 ); 930 return -ENODEV; 931 } else { 932 warn_report_once( 933 "9p: Multiple devices detected in same VirtFS export, " 934 "which might lead to file ID collisions and severe " 935 "misbehaviours on guest! You should either use a " 936 "separate export for each device shared from host or " 937 "use virtfs option 'multidevs=remap'!" 938 ); 939 } 940 } 941 memset(&qidp->path, 0, sizeof(qidp->path)); 942 size = MIN(sizeof(stbuf->st_ino), sizeof(qidp->path)); 943 memcpy(&qidp->path, &stbuf->st_ino, size); 944 } 945 946 qidp->version = stbuf->st_mtime ^ (stbuf->st_size << 8); 947 qidp->type = 0; 948 if (S_ISDIR(stbuf->st_mode)) { 949 qidp->type |= P9_QID_TYPE_DIR; 950 } 951 if (S_ISLNK(stbuf->st_mode)) { 952 qidp->type |= P9_QID_TYPE_SYMLINK; 953 } 954 955 return 0; 956 } 957 958 static int coroutine_fn fid_to_qid(V9fsPDU *pdu, V9fsFidState *fidp, 959 V9fsQID *qidp) 960 { 961 struct stat stbuf; 962 int err; 963 964 err = v9fs_co_lstat(pdu, &fidp->path, &stbuf); 965 if (err < 0) { 966 return err; 967 } 968 err = stat_to_qid(pdu, &stbuf, qidp); 969 if (err < 0) { 970 return err; 971 } 972 return 0; 973 } 974 975 static int coroutine_fn dirent_to_qid(V9fsPDU *pdu, V9fsFidState *fidp, 976 struct dirent *dent, V9fsQID *qidp) 977 { 978 struct stat stbuf; 979 V9fsPath path; 980 int err; 981 982 v9fs_path_init(&path); 983 984 err = v9fs_co_name_to_path(pdu, &fidp->path, dent->d_name, &path); 985 if (err < 0) { 986 goto out; 987 } 988 err = v9fs_co_lstat(pdu, &path, &stbuf); 989 if (err < 0) { 990 goto out; 991 } 992 err = stat_to_qid(pdu, &stbuf, qidp); 993 994 out: 995 v9fs_path_free(&path); 996 return err; 997 } 998 999 V9fsPDU *pdu_alloc(V9fsState *s) 1000 { 1001 V9fsPDU *pdu = NULL; 1002 1003 if (!QLIST_EMPTY(&s->free_list)) { 1004 pdu = QLIST_FIRST(&s->free_list); 1005 QLIST_REMOVE(pdu, next); 1006 QLIST_INSERT_HEAD(&s->active_list, pdu, next); 1007 } 1008 return pdu; 1009 } 1010 1011 void pdu_free(V9fsPDU *pdu) 1012 { 1013 V9fsState *s = pdu->s; 1014 1015 g_assert(!pdu->cancelled); 1016 QLIST_REMOVE(pdu, next); 1017 QLIST_INSERT_HEAD(&s->free_list, pdu, next); 1018 } 1019 1020 static void coroutine_fn pdu_complete(V9fsPDU *pdu, ssize_t len) 1021 { 1022 int8_t id = pdu->id + 1; /* Response */ 1023 V9fsState *s = pdu->s; 1024 int ret; 1025 1026 /* 1027 * The 9p spec requires that successfully cancelled pdus receive no reply. 1028 * Sending a reply would confuse clients because they would 1029 * assume that any EINTR is the actual result of the operation, 1030 * rather than a consequence of the cancellation. However, if 1031 * the operation completed (succesfully or with an error other 1032 * than caused be cancellation), we do send out that reply, both 1033 * for efficiency and to avoid confusing the rest of the state machine 1034 * that assumes passing a non-error here will mean a successful 1035 * transmission of the reply. 1036 */ 1037 bool discard = pdu->cancelled && len == -EINTR; 1038 if (discard) { 1039 trace_v9fs_rcancel(pdu->tag, pdu->id); 1040 pdu->size = 0; 1041 goto out_notify; 1042 } 1043 1044 if (len < 0) { 1045 int err = -len; 1046 len = 7; 1047 1048 if (s->proto_version != V9FS_PROTO_2000L) { 1049 V9fsString str; 1050 1051 str.data = strerror(err); 1052 str.size = strlen(str.data); 1053 1054 ret = pdu_marshal(pdu, len, "s", &str); 1055 if (ret < 0) { 1056 goto out_notify; 1057 } 1058 len += ret; 1059 id = P9_RERROR; 1060 } 1061 1062 ret = pdu_marshal(pdu, len, "d", err); 1063 if (ret < 0) { 1064 goto out_notify; 1065 } 1066 len += ret; 1067 1068 if (s->proto_version == V9FS_PROTO_2000L) { 1069 id = P9_RLERROR; 1070 } 1071 trace_v9fs_rerror(pdu->tag, pdu->id, err); /* Trace ERROR */ 1072 } 1073 1074 /* fill out the header */ 1075 if (pdu_marshal(pdu, 0, "dbw", (int32_t)len, id, pdu->tag) < 0) { 1076 goto out_notify; 1077 } 1078 1079 /* keep these in sync */ 1080 pdu->size = len; 1081 pdu->id = id; 1082 1083 out_notify: 1084 pdu->s->transport->push_and_notify(pdu); 1085 1086 /* Now wakeup anybody waiting in flush for this request */ 1087 if (!qemu_co_queue_next(&pdu->complete)) { 1088 pdu_free(pdu); 1089 } 1090 } 1091 1092 static mode_t v9mode_to_mode(uint32_t mode, V9fsString *extension) 1093 { 1094 mode_t ret; 1095 1096 ret = mode & 0777; 1097 if (mode & P9_STAT_MODE_DIR) { 1098 ret |= S_IFDIR; 1099 } 1100 1101 if (mode & P9_STAT_MODE_SYMLINK) { 1102 ret |= S_IFLNK; 1103 } 1104 if (mode & P9_STAT_MODE_SOCKET) { 1105 ret |= S_IFSOCK; 1106 } 1107 if (mode & P9_STAT_MODE_NAMED_PIPE) { 1108 ret |= S_IFIFO; 1109 } 1110 if (mode & P9_STAT_MODE_DEVICE) { 1111 if (extension->size && extension->data[0] == 'c') { 1112 ret |= S_IFCHR; 1113 } else { 1114 ret |= S_IFBLK; 1115 } 1116 } 1117 1118 if (!(ret&~0777)) { 1119 ret |= S_IFREG; 1120 } 1121 1122 if (mode & P9_STAT_MODE_SETUID) { 1123 ret |= S_ISUID; 1124 } 1125 if (mode & P9_STAT_MODE_SETGID) { 1126 ret |= S_ISGID; 1127 } 1128 if (mode & P9_STAT_MODE_SETVTX) { 1129 ret |= S_ISVTX; 1130 } 1131 1132 return ret; 1133 } 1134 1135 static int donttouch_stat(V9fsStat *stat) 1136 { 1137 if (stat->type == -1 && 1138 stat->dev == -1 && 1139 stat->qid.type == 0xff && 1140 stat->qid.version == (uint32_t) -1 && 1141 stat->qid.path == (uint64_t) -1 && 1142 stat->mode == -1 && 1143 stat->atime == -1 && 1144 stat->mtime == -1 && 1145 stat->length == -1 && 1146 !stat->name.size && 1147 !stat->uid.size && 1148 !stat->gid.size && 1149 !stat->muid.size && 1150 stat->n_uid == -1 && 1151 stat->n_gid == -1 && 1152 stat->n_muid == -1) { 1153 return 1; 1154 } 1155 1156 return 0; 1157 } 1158 1159 static void v9fs_stat_init(V9fsStat *stat) 1160 { 1161 v9fs_string_init(&stat->name); 1162 v9fs_string_init(&stat->uid); 1163 v9fs_string_init(&stat->gid); 1164 v9fs_string_init(&stat->muid); 1165 v9fs_string_init(&stat->extension); 1166 } 1167 1168 static void v9fs_stat_free(V9fsStat *stat) 1169 { 1170 v9fs_string_free(&stat->name); 1171 v9fs_string_free(&stat->uid); 1172 v9fs_string_free(&stat->gid); 1173 v9fs_string_free(&stat->muid); 1174 v9fs_string_free(&stat->extension); 1175 } 1176 1177 static uint32_t stat_to_v9mode(const struct stat *stbuf) 1178 { 1179 uint32_t mode; 1180 1181 mode = stbuf->st_mode & 0777; 1182 if (S_ISDIR(stbuf->st_mode)) { 1183 mode |= P9_STAT_MODE_DIR; 1184 } 1185 1186 if (S_ISLNK(stbuf->st_mode)) { 1187 mode |= P9_STAT_MODE_SYMLINK; 1188 } 1189 1190 if (S_ISSOCK(stbuf->st_mode)) { 1191 mode |= P9_STAT_MODE_SOCKET; 1192 } 1193 1194 if (S_ISFIFO(stbuf->st_mode)) { 1195 mode |= P9_STAT_MODE_NAMED_PIPE; 1196 } 1197 1198 if (S_ISBLK(stbuf->st_mode) || S_ISCHR(stbuf->st_mode)) { 1199 mode |= P9_STAT_MODE_DEVICE; 1200 } 1201 1202 if (stbuf->st_mode & S_ISUID) { 1203 mode |= P9_STAT_MODE_SETUID; 1204 } 1205 1206 if (stbuf->st_mode & S_ISGID) { 1207 mode |= P9_STAT_MODE_SETGID; 1208 } 1209 1210 if (stbuf->st_mode & S_ISVTX) { 1211 mode |= P9_STAT_MODE_SETVTX; 1212 } 1213 1214 return mode; 1215 } 1216 1217 static int coroutine_fn stat_to_v9stat(V9fsPDU *pdu, V9fsPath *path, 1218 const char *basename, 1219 const struct stat *stbuf, 1220 V9fsStat *v9stat) 1221 { 1222 int err; 1223 1224 memset(v9stat, 0, sizeof(*v9stat)); 1225 1226 err = stat_to_qid(pdu, stbuf, &v9stat->qid); 1227 if (err < 0) { 1228 return err; 1229 } 1230 v9stat->mode = stat_to_v9mode(stbuf); 1231 v9stat->atime = stbuf->st_atime; 1232 v9stat->mtime = stbuf->st_mtime; 1233 v9stat->length = stbuf->st_size; 1234 1235 v9fs_string_free(&v9stat->uid); 1236 v9fs_string_free(&v9stat->gid); 1237 v9fs_string_free(&v9stat->muid); 1238 1239 v9stat->n_uid = stbuf->st_uid; 1240 v9stat->n_gid = stbuf->st_gid; 1241 v9stat->n_muid = 0; 1242 1243 v9fs_string_free(&v9stat->extension); 1244 1245 if (v9stat->mode & P9_STAT_MODE_SYMLINK) { 1246 err = v9fs_co_readlink(pdu, path, &v9stat->extension); 1247 if (err < 0) { 1248 return err; 1249 } 1250 } else if (v9stat->mode & P9_STAT_MODE_DEVICE) { 1251 v9fs_string_sprintf(&v9stat->extension, "%c %u %u", 1252 S_ISCHR(stbuf->st_mode) ? 'c' : 'b', 1253 major(stbuf->st_rdev), minor(stbuf->st_rdev)); 1254 } else if (S_ISDIR(stbuf->st_mode) || S_ISREG(stbuf->st_mode)) { 1255 v9fs_string_sprintf(&v9stat->extension, "%s %lu", 1256 "HARDLINKCOUNT", (unsigned long)stbuf->st_nlink); 1257 } 1258 1259 v9fs_string_sprintf(&v9stat->name, "%s", basename); 1260 1261 v9stat->size = 61 + 1262 v9fs_string_size(&v9stat->name) + 1263 v9fs_string_size(&v9stat->uid) + 1264 v9fs_string_size(&v9stat->gid) + 1265 v9fs_string_size(&v9stat->muid) + 1266 v9fs_string_size(&v9stat->extension); 1267 return 0; 1268 } 1269 1270 #define P9_STATS_MODE 0x00000001ULL 1271 #define P9_STATS_NLINK 0x00000002ULL 1272 #define P9_STATS_UID 0x00000004ULL 1273 #define P9_STATS_GID 0x00000008ULL 1274 #define P9_STATS_RDEV 0x00000010ULL 1275 #define P9_STATS_ATIME 0x00000020ULL 1276 #define P9_STATS_MTIME 0x00000040ULL 1277 #define P9_STATS_CTIME 0x00000080ULL 1278 #define P9_STATS_INO 0x00000100ULL 1279 #define P9_STATS_SIZE 0x00000200ULL 1280 #define P9_STATS_BLOCKS 0x00000400ULL 1281 1282 #define P9_STATS_BTIME 0x00000800ULL 1283 #define P9_STATS_GEN 0x00001000ULL 1284 #define P9_STATS_DATA_VERSION 0x00002000ULL 1285 1286 #define P9_STATS_BASIC 0x000007ffULL /* Mask for fields up to BLOCKS */ 1287 #define P9_STATS_ALL 0x00003fffULL /* Mask for All fields above */ 1288 1289 1290 static int stat_to_v9stat_dotl(V9fsPDU *pdu, const struct stat *stbuf, 1291 V9fsStatDotl *v9lstat) 1292 { 1293 memset(v9lstat, 0, sizeof(*v9lstat)); 1294 1295 v9lstat->st_mode = stbuf->st_mode; 1296 v9lstat->st_nlink = stbuf->st_nlink; 1297 v9lstat->st_uid = stbuf->st_uid; 1298 v9lstat->st_gid = stbuf->st_gid; 1299 v9lstat->st_rdev = stbuf->st_rdev; 1300 v9lstat->st_size = stbuf->st_size; 1301 v9lstat->st_blksize = stbuf->st_blksize; 1302 v9lstat->st_blocks = stbuf->st_blocks; 1303 v9lstat->st_atime_sec = stbuf->st_atime; 1304 v9lstat->st_atime_nsec = stbuf->st_atim.tv_nsec; 1305 v9lstat->st_mtime_sec = stbuf->st_mtime; 1306 v9lstat->st_mtime_nsec = stbuf->st_mtim.tv_nsec; 1307 v9lstat->st_ctime_sec = stbuf->st_ctime; 1308 v9lstat->st_ctime_nsec = stbuf->st_ctim.tv_nsec; 1309 /* Currently we only support BASIC fields in stat */ 1310 v9lstat->st_result_mask = P9_STATS_BASIC; 1311 1312 return stat_to_qid(pdu, stbuf, &v9lstat->qid); 1313 } 1314 1315 static void print_sg(struct iovec *sg, int cnt) 1316 { 1317 int i; 1318 1319 printf("sg[%d]: {", cnt); 1320 for (i = 0; i < cnt; i++) { 1321 if (i) { 1322 printf(", "); 1323 } 1324 printf("(%p, %zd)", sg[i].iov_base, sg[i].iov_len); 1325 } 1326 printf("}\n"); 1327 } 1328 1329 /* Will call this only for path name based fid */ 1330 static void v9fs_fix_path(V9fsPath *dst, V9fsPath *src, int len) 1331 { 1332 V9fsPath str; 1333 v9fs_path_init(&str); 1334 v9fs_path_copy(&str, dst); 1335 v9fs_path_sprintf(dst, "%s%s", src->data, str.data + len); 1336 v9fs_path_free(&str); 1337 } 1338 1339 static inline bool is_ro_export(FsContext *ctx) 1340 { 1341 return ctx->export_flags & V9FS_RDONLY; 1342 } 1343 1344 static void coroutine_fn v9fs_version(void *opaque) 1345 { 1346 ssize_t err; 1347 V9fsPDU *pdu = opaque; 1348 V9fsState *s = pdu->s; 1349 V9fsString version; 1350 size_t offset = 7; 1351 1352 v9fs_string_init(&version); 1353 err = pdu_unmarshal(pdu, offset, "ds", &s->msize, &version); 1354 if (err < 0) { 1355 goto out; 1356 } 1357 trace_v9fs_version(pdu->tag, pdu->id, s->msize, version.data); 1358 1359 virtfs_reset(pdu); 1360 1361 if (!strcmp(version.data, "9P2000.u")) { 1362 s->proto_version = V9FS_PROTO_2000U; 1363 } else if (!strcmp(version.data, "9P2000.L")) { 1364 s->proto_version = V9FS_PROTO_2000L; 1365 } else { 1366 v9fs_string_sprintf(&version, "unknown"); 1367 /* skip min. msize check, reporting invalid version has priority */ 1368 goto marshal; 1369 } 1370 1371 if (s->msize < P9_MIN_MSIZE) { 1372 err = -EMSGSIZE; 1373 error_report( 1374 "9pfs: Client requested msize < minimum msize (" 1375 stringify(P9_MIN_MSIZE) ") supported by this server." 1376 ); 1377 goto out; 1378 } 1379 1380 marshal: 1381 err = pdu_marshal(pdu, offset, "ds", s->msize, &version); 1382 if (err < 0) { 1383 goto out; 1384 } 1385 err += offset; 1386 trace_v9fs_version_return(pdu->tag, pdu->id, s->msize, version.data); 1387 out: 1388 pdu_complete(pdu, err); 1389 v9fs_string_free(&version); 1390 } 1391 1392 static void coroutine_fn v9fs_attach(void *opaque) 1393 { 1394 V9fsPDU *pdu = opaque; 1395 V9fsState *s = pdu->s; 1396 int32_t fid, afid, n_uname; 1397 V9fsString uname, aname; 1398 V9fsFidState *fidp; 1399 size_t offset = 7; 1400 V9fsQID qid; 1401 ssize_t err; 1402 1403 v9fs_string_init(&uname); 1404 v9fs_string_init(&aname); 1405 err = pdu_unmarshal(pdu, offset, "ddssd", &fid, 1406 &afid, &uname, &aname, &n_uname); 1407 if (err < 0) { 1408 goto out_nofid; 1409 } 1410 trace_v9fs_attach(pdu->tag, pdu->id, fid, afid, uname.data, aname.data); 1411 1412 fidp = alloc_fid(s, fid); 1413 if (fidp == NULL) { 1414 err = -EINVAL; 1415 goto out_nofid; 1416 } 1417 fidp->uid = n_uname; 1418 err = v9fs_co_name_to_path(pdu, NULL, "/", &fidp->path); 1419 if (err < 0) { 1420 err = -EINVAL; 1421 clunk_fid(s, fid); 1422 goto out; 1423 } 1424 err = fid_to_qid(pdu, fidp, &qid); 1425 if (err < 0) { 1426 err = -EINVAL; 1427 clunk_fid(s, fid); 1428 goto out; 1429 } 1430 1431 /* 1432 * disable migration if we haven't done already. 1433 * attach could get called multiple times for the same export. 1434 */ 1435 if (!s->migration_blocker) { 1436 error_setg(&s->migration_blocker, 1437 "Migration is disabled when VirtFS export path '%s' is mounted in the guest using mount_tag '%s'", 1438 s->ctx.fs_root ? s->ctx.fs_root : "NULL", s->tag); 1439 err = migrate_add_blocker(s->migration_blocker, NULL); 1440 if (err < 0) { 1441 error_free(s->migration_blocker); 1442 s->migration_blocker = NULL; 1443 clunk_fid(s, fid); 1444 goto out; 1445 } 1446 s->root_fid = fid; 1447 } 1448 1449 err = pdu_marshal(pdu, offset, "Q", &qid); 1450 if (err < 0) { 1451 clunk_fid(s, fid); 1452 goto out; 1453 } 1454 err += offset; 1455 1456 memcpy(&s->root_qid, &qid, sizeof(qid)); 1457 trace_v9fs_attach_return(pdu->tag, pdu->id, 1458 qid.type, qid.version, qid.path); 1459 out: 1460 put_fid(pdu, fidp); 1461 out_nofid: 1462 pdu_complete(pdu, err); 1463 v9fs_string_free(&uname); 1464 v9fs_string_free(&aname); 1465 } 1466 1467 static void coroutine_fn v9fs_stat(void *opaque) 1468 { 1469 int32_t fid; 1470 V9fsStat v9stat; 1471 ssize_t err = 0; 1472 size_t offset = 7; 1473 struct stat stbuf; 1474 V9fsFidState *fidp; 1475 V9fsPDU *pdu = opaque; 1476 char *basename; 1477 1478 err = pdu_unmarshal(pdu, offset, "d", &fid); 1479 if (err < 0) { 1480 goto out_nofid; 1481 } 1482 trace_v9fs_stat(pdu->tag, pdu->id, fid); 1483 1484 fidp = get_fid(pdu, fid); 1485 if (fidp == NULL) { 1486 err = -ENOENT; 1487 goto out_nofid; 1488 } 1489 err = v9fs_co_lstat(pdu, &fidp->path, &stbuf); 1490 if (err < 0) { 1491 goto out; 1492 } 1493 basename = g_path_get_basename(fidp->path.data); 1494 err = stat_to_v9stat(pdu, &fidp->path, basename, &stbuf, &v9stat); 1495 g_free(basename); 1496 if (err < 0) { 1497 goto out; 1498 } 1499 err = pdu_marshal(pdu, offset, "wS", 0, &v9stat); 1500 if (err < 0) { 1501 v9fs_stat_free(&v9stat); 1502 goto out; 1503 } 1504 trace_v9fs_stat_return(pdu->tag, pdu->id, v9stat.mode, 1505 v9stat.atime, v9stat.mtime, v9stat.length); 1506 err += offset; 1507 v9fs_stat_free(&v9stat); 1508 out: 1509 put_fid(pdu, fidp); 1510 out_nofid: 1511 pdu_complete(pdu, err); 1512 } 1513 1514 static void coroutine_fn v9fs_getattr(void *opaque) 1515 { 1516 int32_t fid; 1517 size_t offset = 7; 1518 ssize_t retval = 0; 1519 struct stat stbuf; 1520 V9fsFidState *fidp; 1521 uint64_t request_mask; 1522 V9fsStatDotl v9stat_dotl; 1523 V9fsPDU *pdu = opaque; 1524 1525 retval = pdu_unmarshal(pdu, offset, "dq", &fid, &request_mask); 1526 if (retval < 0) { 1527 goto out_nofid; 1528 } 1529 trace_v9fs_getattr(pdu->tag, pdu->id, fid, request_mask); 1530 1531 fidp = get_fid(pdu, fid); 1532 if (fidp == NULL) { 1533 retval = -ENOENT; 1534 goto out_nofid; 1535 } 1536 /* 1537 * Currently we only support BASIC fields in stat, so there is no 1538 * need to look at request_mask. 1539 */ 1540 retval = v9fs_co_lstat(pdu, &fidp->path, &stbuf); 1541 if (retval < 0) { 1542 goto out; 1543 } 1544 retval = stat_to_v9stat_dotl(pdu, &stbuf, &v9stat_dotl); 1545 if (retval < 0) { 1546 goto out; 1547 } 1548 1549 /* fill st_gen if requested and supported by underlying fs */ 1550 if (request_mask & P9_STATS_GEN) { 1551 retval = v9fs_co_st_gen(pdu, &fidp->path, stbuf.st_mode, &v9stat_dotl); 1552 switch (retval) { 1553 case 0: 1554 /* we have valid st_gen: update result mask */ 1555 v9stat_dotl.st_result_mask |= P9_STATS_GEN; 1556 break; 1557 case -EINTR: 1558 /* request cancelled, e.g. by Tflush */ 1559 goto out; 1560 default: 1561 /* failed to get st_gen: not fatal, ignore */ 1562 break; 1563 } 1564 } 1565 retval = pdu_marshal(pdu, offset, "A", &v9stat_dotl); 1566 if (retval < 0) { 1567 goto out; 1568 } 1569 retval += offset; 1570 trace_v9fs_getattr_return(pdu->tag, pdu->id, v9stat_dotl.st_result_mask, 1571 v9stat_dotl.st_mode, v9stat_dotl.st_uid, 1572 v9stat_dotl.st_gid); 1573 out: 1574 put_fid(pdu, fidp); 1575 out_nofid: 1576 pdu_complete(pdu, retval); 1577 } 1578 1579 /* Attribute flags */ 1580 #define P9_ATTR_MODE (1 << 0) 1581 #define P9_ATTR_UID (1 << 1) 1582 #define P9_ATTR_GID (1 << 2) 1583 #define P9_ATTR_SIZE (1 << 3) 1584 #define P9_ATTR_ATIME (1 << 4) 1585 #define P9_ATTR_MTIME (1 << 5) 1586 #define P9_ATTR_CTIME (1 << 6) 1587 #define P9_ATTR_ATIME_SET (1 << 7) 1588 #define P9_ATTR_MTIME_SET (1 << 8) 1589 1590 #define P9_ATTR_MASK 127 1591 1592 static void coroutine_fn v9fs_setattr(void *opaque) 1593 { 1594 int err = 0; 1595 int32_t fid; 1596 V9fsFidState *fidp; 1597 size_t offset = 7; 1598 V9fsIattr v9iattr; 1599 V9fsPDU *pdu = opaque; 1600 1601 err = pdu_unmarshal(pdu, offset, "dI", &fid, &v9iattr); 1602 if (err < 0) { 1603 goto out_nofid; 1604 } 1605 1606 trace_v9fs_setattr(pdu->tag, pdu->id, fid, 1607 v9iattr.valid, v9iattr.mode, v9iattr.uid, v9iattr.gid, 1608 v9iattr.size, v9iattr.atime_sec, v9iattr.mtime_sec); 1609 1610 fidp = get_fid(pdu, fid); 1611 if (fidp == NULL) { 1612 err = -EINVAL; 1613 goto out_nofid; 1614 } 1615 if (v9iattr.valid & P9_ATTR_MODE) { 1616 err = v9fs_co_chmod(pdu, &fidp->path, v9iattr.mode); 1617 if (err < 0) { 1618 goto out; 1619 } 1620 } 1621 if (v9iattr.valid & (P9_ATTR_ATIME | P9_ATTR_MTIME)) { 1622 struct timespec times[2]; 1623 if (v9iattr.valid & P9_ATTR_ATIME) { 1624 if (v9iattr.valid & P9_ATTR_ATIME_SET) { 1625 times[0].tv_sec = v9iattr.atime_sec; 1626 times[0].tv_nsec = v9iattr.atime_nsec; 1627 } else { 1628 times[0].tv_nsec = UTIME_NOW; 1629 } 1630 } else { 1631 times[0].tv_nsec = UTIME_OMIT; 1632 } 1633 if (v9iattr.valid & P9_ATTR_MTIME) { 1634 if (v9iattr.valid & P9_ATTR_MTIME_SET) { 1635 times[1].tv_sec = v9iattr.mtime_sec; 1636 times[1].tv_nsec = v9iattr.mtime_nsec; 1637 } else { 1638 times[1].tv_nsec = UTIME_NOW; 1639 } 1640 } else { 1641 times[1].tv_nsec = UTIME_OMIT; 1642 } 1643 err = v9fs_co_utimensat(pdu, &fidp->path, times); 1644 if (err < 0) { 1645 goto out; 1646 } 1647 } 1648 /* 1649 * If the only valid entry in iattr is ctime we can call 1650 * chown(-1,-1) to update the ctime of the file 1651 */ 1652 if ((v9iattr.valid & (P9_ATTR_UID | P9_ATTR_GID)) || 1653 ((v9iattr.valid & P9_ATTR_CTIME) 1654 && !((v9iattr.valid & P9_ATTR_MASK) & ~P9_ATTR_CTIME))) { 1655 if (!(v9iattr.valid & P9_ATTR_UID)) { 1656 v9iattr.uid = -1; 1657 } 1658 if (!(v9iattr.valid & P9_ATTR_GID)) { 1659 v9iattr.gid = -1; 1660 } 1661 err = v9fs_co_chown(pdu, &fidp->path, v9iattr.uid, 1662 v9iattr.gid); 1663 if (err < 0) { 1664 goto out; 1665 } 1666 } 1667 if (v9iattr.valid & (P9_ATTR_SIZE)) { 1668 err = v9fs_co_truncate(pdu, &fidp->path, v9iattr.size); 1669 if (err < 0) { 1670 goto out; 1671 } 1672 } 1673 err = offset; 1674 trace_v9fs_setattr_return(pdu->tag, pdu->id); 1675 out: 1676 put_fid(pdu, fidp); 1677 out_nofid: 1678 pdu_complete(pdu, err); 1679 } 1680 1681 static int v9fs_walk_marshal(V9fsPDU *pdu, uint16_t nwnames, V9fsQID *qids) 1682 { 1683 int i; 1684 ssize_t err; 1685 size_t offset = 7; 1686 1687 err = pdu_marshal(pdu, offset, "w", nwnames); 1688 if (err < 0) { 1689 return err; 1690 } 1691 offset += err; 1692 for (i = 0; i < nwnames; i++) { 1693 err = pdu_marshal(pdu, offset, "Q", &qids[i]); 1694 if (err < 0) { 1695 return err; 1696 } 1697 offset += err; 1698 } 1699 return offset; 1700 } 1701 1702 static bool name_is_illegal(const char *name) 1703 { 1704 return !*name || strchr(name, '/') != NULL; 1705 } 1706 1707 static bool not_same_qid(const V9fsQID *qid1, const V9fsQID *qid2) 1708 { 1709 return 1710 qid1->type != qid2->type || 1711 qid1->version != qid2->version || 1712 qid1->path != qid2->path; 1713 } 1714 1715 static void coroutine_fn v9fs_walk(void *opaque) 1716 { 1717 int name_idx; 1718 V9fsQID *qids = NULL; 1719 int i, err = 0; 1720 V9fsPath dpath, path; 1721 uint16_t nwnames; 1722 struct stat stbuf; 1723 size_t offset = 7; 1724 int32_t fid, newfid; 1725 V9fsString *wnames = NULL; 1726 V9fsFidState *fidp; 1727 V9fsFidState *newfidp = NULL; 1728 V9fsPDU *pdu = opaque; 1729 V9fsState *s = pdu->s; 1730 V9fsQID qid; 1731 1732 err = pdu_unmarshal(pdu, offset, "ddw", &fid, &newfid, &nwnames); 1733 if (err < 0) { 1734 pdu_complete(pdu, err); 1735 return ; 1736 } 1737 offset += err; 1738 1739 trace_v9fs_walk(pdu->tag, pdu->id, fid, newfid, nwnames); 1740 1741 if (nwnames && nwnames <= P9_MAXWELEM) { 1742 wnames = g_new0(V9fsString, nwnames); 1743 qids = g_new0(V9fsQID, nwnames); 1744 for (i = 0; i < nwnames; i++) { 1745 err = pdu_unmarshal(pdu, offset, "s", &wnames[i]); 1746 if (err < 0) { 1747 goto out_nofid; 1748 } 1749 if (name_is_illegal(wnames[i].data)) { 1750 err = -ENOENT; 1751 goto out_nofid; 1752 } 1753 offset += err; 1754 } 1755 } else if (nwnames > P9_MAXWELEM) { 1756 err = -EINVAL; 1757 goto out_nofid; 1758 } 1759 fidp = get_fid(pdu, fid); 1760 if (fidp == NULL) { 1761 err = -ENOENT; 1762 goto out_nofid; 1763 } 1764 1765 v9fs_path_init(&dpath); 1766 v9fs_path_init(&path); 1767 1768 err = fid_to_qid(pdu, fidp, &qid); 1769 if (err < 0) { 1770 goto out; 1771 } 1772 1773 /* 1774 * Both dpath and path initially poin to fidp. 1775 * Needed to handle request with nwnames == 0 1776 */ 1777 v9fs_path_copy(&dpath, &fidp->path); 1778 v9fs_path_copy(&path, &fidp->path); 1779 for (name_idx = 0; name_idx < nwnames; name_idx++) { 1780 if (not_same_qid(&pdu->s->root_qid, &qid) || 1781 strcmp("..", wnames[name_idx].data)) { 1782 err = v9fs_co_name_to_path(pdu, &dpath, wnames[name_idx].data, 1783 &path); 1784 if (err < 0) { 1785 goto out; 1786 } 1787 1788 err = v9fs_co_lstat(pdu, &path, &stbuf); 1789 if (err < 0) { 1790 goto out; 1791 } 1792 err = stat_to_qid(pdu, &stbuf, &qid); 1793 if (err < 0) { 1794 goto out; 1795 } 1796 v9fs_path_copy(&dpath, &path); 1797 } 1798 memcpy(&qids[name_idx], &qid, sizeof(qid)); 1799 } 1800 if (fid == newfid) { 1801 if (fidp->fid_type != P9_FID_NONE) { 1802 err = -EINVAL; 1803 goto out; 1804 } 1805 v9fs_path_write_lock(s); 1806 v9fs_path_copy(&fidp->path, &path); 1807 v9fs_path_unlock(s); 1808 } else { 1809 newfidp = alloc_fid(s, newfid); 1810 if (newfidp == NULL) { 1811 err = -EINVAL; 1812 goto out; 1813 } 1814 newfidp->uid = fidp->uid; 1815 v9fs_path_copy(&newfidp->path, &path); 1816 } 1817 err = v9fs_walk_marshal(pdu, nwnames, qids); 1818 trace_v9fs_walk_return(pdu->tag, pdu->id, nwnames, qids); 1819 out: 1820 put_fid(pdu, fidp); 1821 if (newfidp) { 1822 put_fid(pdu, newfidp); 1823 } 1824 v9fs_path_free(&dpath); 1825 v9fs_path_free(&path); 1826 out_nofid: 1827 pdu_complete(pdu, err); 1828 if (nwnames && nwnames <= P9_MAXWELEM) { 1829 for (name_idx = 0; name_idx < nwnames; name_idx++) { 1830 v9fs_string_free(&wnames[name_idx]); 1831 } 1832 g_free(wnames); 1833 g_free(qids); 1834 } 1835 } 1836 1837 static int32_t coroutine_fn get_iounit(V9fsPDU *pdu, V9fsPath *path) 1838 { 1839 struct statfs stbuf; 1840 int32_t iounit = 0; 1841 V9fsState *s = pdu->s; 1842 1843 /* 1844 * iounit should be multiples of f_bsize (host filesystem block size 1845 * and as well as less than (client msize - P9_IOHDRSZ)) 1846 */ 1847 if (!v9fs_co_statfs(pdu, path, &stbuf)) { 1848 if (stbuf.f_bsize) { 1849 iounit = stbuf.f_bsize; 1850 iounit *= (s->msize - P9_IOHDRSZ) / stbuf.f_bsize; 1851 } 1852 } 1853 if (!iounit) { 1854 iounit = s->msize - P9_IOHDRSZ; 1855 } 1856 return iounit; 1857 } 1858 1859 static void coroutine_fn v9fs_open(void *opaque) 1860 { 1861 int flags; 1862 int32_t fid; 1863 int32_t mode; 1864 V9fsQID qid; 1865 int iounit = 0; 1866 ssize_t err = 0; 1867 size_t offset = 7; 1868 struct stat stbuf; 1869 V9fsFidState *fidp; 1870 V9fsPDU *pdu = opaque; 1871 V9fsState *s = pdu->s; 1872 1873 if (s->proto_version == V9FS_PROTO_2000L) { 1874 err = pdu_unmarshal(pdu, offset, "dd", &fid, &mode); 1875 } else { 1876 uint8_t modebyte; 1877 err = pdu_unmarshal(pdu, offset, "db", &fid, &modebyte); 1878 mode = modebyte; 1879 } 1880 if (err < 0) { 1881 goto out_nofid; 1882 } 1883 trace_v9fs_open(pdu->tag, pdu->id, fid, mode); 1884 1885 fidp = get_fid(pdu, fid); 1886 if (fidp == NULL) { 1887 err = -ENOENT; 1888 goto out_nofid; 1889 } 1890 if (fidp->fid_type != P9_FID_NONE) { 1891 err = -EINVAL; 1892 goto out; 1893 } 1894 1895 err = v9fs_co_lstat(pdu, &fidp->path, &stbuf); 1896 if (err < 0) { 1897 goto out; 1898 } 1899 err = stat_to_qid(pdu, &stbuf, &qid); 1900 if (err < 0) { 1901 goto out; 1902 } 1903 if (S_ISDIR(stbuf.st_mode)) { 1904 err = v9fs_co_opendir(pdu, fidp); 1905 if (err < 0) { 1906 goto out; 1907 } 1908 fidp->fid_type = P9_FID_DIR; 1909 err = pdu_marshal(pdu, offset, "Qd", &qid, 0); 1910 if (err < 0) { 1911 goto out; 1912 } 1913 err += offset; 1914 } else { 1915 if (s->proto_version == V9FS_PROTO_2000L) { 1916 flags = get_dotl_openflags(s, mode); 1917 } else { 1918 flags = omode_to_uflags(mode); 1919 } 1920 if (is_ro_export(&s->ctx)) { 1921 if (mode & O_WRONLY || mode & O_RDWR || 1922 mode & O_APPEND || mode & O_TRUNC) { 1923 err = -EROFS; 1924 goto out; 1925 } 1926 } 1927 err = v9fs_co_open(pdu, fidp, flags); 1928 if (err < 0) { 1929 goto out; 1930 } 1931 fidp->fid_type = P9_FID_FILE; 1932 fidp->open_flags = flags; 1933 if (flags & O_EXCL) { 1934 /* 1935 * We let the host file system do O_EXCL check 1936 * We should not reclaim such fd 1937 */ 1938 fidp->flags |= FID_NON_RECLAIMABLE; 1939 } 1940 iounit = get_iounit(pdu, &fidp->path); 1941 err = pdu_marshal(pdu, offset, "Qd", &qid, iounit); 1942 if (err < 0) { 1943 goto out; 1944 } 1945 err += offset; 1946 } 1947 trace_v9fs_open_return(pdu->tag, pdu->id, 1948 qid.type, qid.version, qid.path, iounit); 1949 out: 1950 put_fid(pdu, fidp); 1951 out_nofid: 1952 pdu_complete(pdu, err); 1953 } 1954 1955 static void coroutine_fn v9fs_lcreate(void *opaque) 1956 { 1957 int32_t dfid, flags, mode; 1958 gid_t gid; 1959 ssize_t err = 0; 1960 ssize_t offset = 7; 1961 V9fsString name; 1962 V9fsFidState *fidp; 1963 struct stat stbuf; 1964 V9fsQID qid; 1965 int32_t iounit; 1966 V9fsPDU *pdu = opaque; 1967 1968 v9fs_string_init(&name); 1969 err = pdu_unmarshal(pdu, offset, "dsddd", &dfid, 1970 &name, &flags, &mode, &gid); 1971 if (err < 0) { 1972 goto out_nofid; 1973 } 1974 trace_v9fs_lcreate(pdu->tag, pdu->id, dfid, flags, mode, gid); 1975 1976 if (name_is_illegal(name.data)) { 1977 err = -ENOENT; 1978 goto out_nofid; 1979 } 1980 1981 if (!strcmp(".", name.data) || !strcmp("..", name.data)) { 1982 err = -EEXIST; 1983 goto out_nofid; 1984 } 1985 1986 fidp = get_fid(pdu, dfid); 1987 if (fidp == NULL) { 1988 err = -ENOENT; 1989 goto out_nofid; 1990 } 1991 if (fidp->fid_type != P9_FID_NONE) { 1992 err = -EINVAL; 1993 goto out; 1994 } 1995 1996 flags = get_dotl_openflags(pdu->s, flags); 1997 err = v9fs_co_open2(pdu, fidp, &name, gid, 1998 flags | O_CREAT, mode, &stbuf); 1999 if (err < 0) { 2000 goto out; 2001 } 2002 fidp->fid_type = P9_FID_FILE; 2003 fidp->open_flags = flags; 2004 if (flags & O_EXCL) { 2005 /* 2006 * We let the host file system do O_EXCL check 2007 * We should not reclaim such fd 2008 */ 2009 fidp->flags |= FID_NON_RECLAIMABLE; 2010 } 2011 iounit = get_iounit(pdu, &fidp->path); 2012 err = stat_to_qid(pdu, &stbuf, &qid); 2013 if (err < 0) { 2014 goto out; 2015 } 2016 err = pdu_marshal(pdu, offset, "Qd", &qid, iounit); 2017 if (err < 0) { 2018 goto out; 2019 } 2020 err += offset; 2021 trace_v9fs_lcreate_return(pdu->tag, pdu->id, 2022 qid.type, qid.version, qid.path, iounit); 2023 out: 2024 put_fid(pdu, fidp); 2025 out_nofid: 2026 pdu_complete(pdu, err); 2027 v9fs_string_free(&name); 2028 } 2029 2030 static void coroutine_fn v9fs_fsync(void *opaque) 2031 { 2032 int err; 2033 int32_t fid; 2034 int datasync; 2035 size_t offset = 7; 2036 V9fsFidState *fidp; 2037 V9fsPDU *pdu = opaque; 2038 2039 err = pdu_unmarshal(pdu, offset, "dd", &fid, &datasync); 2040 if (err < 0) { 2041 goto out_nofid; 2042 } 2043 trace_v9fs_fsync(pdu->tag, pdu->id, fid, datasync); 2044 2045 fidp = get_fid(pdu, fid); 2046 if (fidp == NULL) { 2047 err = -ENOENT; 2048 goto out_nofid; 2049 } 2050 err = v9fs_co_fsync(pdu, fidp, datasync); 2051 if (!err) { 2052 err = offset; 2053 } 2054 put_fid(pdu, fidp); 2055 out_nofid: 2056 pdu_complete(pdu, err); 2057 } 2058 2059 static void coroutine_fn v9fs_clunk(void *opaque) 2060 { 2061 int err; 2062 int32_t fid; 2063 size_t offset = 7; 2064 V9fsFidState *fidp; 2065 V9fsPDU *pdu = opaque; 2066 V9fsState *s = pdu->s; 2067 2068 err = pdu_unmarshal(pdu, offset, "d", &fid); 2069 if (err < 0) { 2070 goto out_nofid; 2071 } 2072 trace_v9fs_clunk(pdu->tag, pdu->id, fid); 2073 2074 fidp = clunk_fid(s, fid); 2075 if (fidp == NULL) { 2076 err = -ENOENT; 2077 goto out_nofid; 2078 } 2079 /* 2080 * Bump the ref so that put_fid will 2081 * free the fid. 2082 */ 2083 fidp->ref++; 2084 err = put_fid(pdu, fidp); 2085 if (!err) { 2086 err = offset; 2087 } 2088 out_nofid: 2089 pdu_complete(pdu, err); 2090 } 2091 2092 /* 2093 * Create a QEMUIOVector for a sub-region of PDU iovecs 2094 * 2095 * @qiov: uninitialized QEMUIOVector 2096 * @skip: number of bytes to skip from beginning of PDU 2097 * @size: number of bytes to include 2098 * @is_write: true - write, false - read 2099 * 2100 * The resulting QEMUIOVector has heap-allocated iovecs and must be cleaned up 2101 * with qemu_iovec_destroy(). 2102 */ 2103 static void v9fs_init_qiov_from_pdu(QEMUIOVector *qiov, V9fsPDU *pdu, 2104 size_t skip, size_t size, 2105 bool is_write) 2106 { 2107 QEMUIOVector elem; 2108 struct iovec *iov; 2109 unsigned int niov; 2110 2111 if (is_write) { 2112 pdu->s->transport->init_out_iov_from_pdu(pdu, &iov, &niov, size + skip); 2113 } else { 2114 pdu->s->transport->init_in_iov_from_pdu(pdu, &iov, &niov, size + skip); 2115 } 2116 2117 qemu_iovec_init_external(&elem, iov, niov); 2118 qemu_iovec_init(qiov, niov); 2119 qemu_iovec_concat(qiov, &elem, skip, size); 2120 } 2121 2122 static int v9fs_xattr_read(V9fsState *s, V9fsPDU *pdu, V9fsFidState *fidp, 2123 uint64_t off, uint32_t max_count) 2124 { 2125 ssize_t err; 2126 size_t offset = 7; 2127 uint64_t read_count; 2128 QEMUIOVector qiov_full; 2129 2130 if (fidp->fs.xattr.len < off) { 2131 read_count = 0; 2132 } else { 2133 read_count = fidp->fs.xattr.len - off; 2134 } 2135 if (read_count > max_count) { 2136 read_count = max_count; 2137 } 2138 err = pdu_marshal(pdu, offset, "d", read_count); 2139 if (err < 0) { 2140 return err; 2141 } 2142 offset += err; 2143 2144 v9fs_init_qiov_from_pdu(&qiov_full, pdu, offset, read_count, false); 2145 err = v9fs_pack(qiov_full.iov, qiov_full.niov, 0, 2146 ((char *)fidp->fs.xattr.value) + off, 2147 read_count); 2148 qemu_iovec_destroy(&qiov_full); 2149 if (err < 0) { 2150 return err; 2151 } 2152 offset += err; 2153 return offset; 2154 } 2155 2156 static int coroutine_fn v9fs_do_readdir_with_stat(V9fsPDU *pdu, 2157 V9fsFidState *fidp, 2158 uint32_t max_count) 2159 { 2160 V9fsPath path; 2161 V9fsStat v9stat; 2162 int len, err = 0; 2163 int32_t count = 0; 2164 struct stat stbuf; 2165 off_t saved_dir_pos; 2166 struct dirent *dent; 2167 2168 /* save the directory position */ 2169 saved_dir_pos = v9fs_co_telldir(pdu, fidp); 2170 if (saved_dir_pos < 0) { 2171 return saved_dir_pos; 2172 } 2173 2174 while (1) { 2175 v9fs_path_init(&path); 2176 2177 v9fs_readdir_lock(&fidp->fs.dir); 2178 2179 err = v9fs_co_readdir(pdu, fidp, &dent); 2180 if (err || !dent) { 2181 break; 2182 } 2183 err = v9fs_co_name_to_path(pdu, &fidp->path, dent->d_name, &path); 2184 if (err < 0) { 2185 break; 2186 } 2187 err = v9fs_co_lstat(pdu, &path, &stbuf); 2188 if (err < 0) { 2189 break; 2190 } 2191 err = stat_to_v9stat(pdu, &path, dent->d_name, &stbuf, &v9stat); 2192 if (err < 0) { 2193 break; 2194 } 2195 if ((count + v9stat.size + 2) > max_count) { 2196 v9fs_readdir_unlock(&fidp->fs.dir); 2197 2198 /* Ran out of buffer. Set dir back to old position and return */ 2199 v9fs_co_seekdir(pdu, fidp, saved_dir_pos); 2200 v9fs_stat_free(&v9stat); 2201 v9fs_path_free(&path); 2202 return count; 2203 } 2204 2205 /* 11 = 7 + 4 (7 = start offset, 4 = space for storing count) */ 2206 len = pdu_marshal(pdu, 11 + count, "S", &v9stat); 2207 2208 v9fs_readdir_unlock(&fidp->fs.dir); 2209 2210 if (len < 0) { 2211 v9fs_co_seekdir(pdu, fidp, saved_dir_pos); 2212 v9fs_stat_free(&v9stat); 2213 v9fs_path_free(&path); 2214 return len; 2215 } 2216 count += len; 2217 v9fs_stat_free(&v9stat); 2218 v9fs_path_free(&path); 2219 saved_dir_pos = dent->d_off; 2220 } 2221 2222 v9fs_readdir_unlock(&fidp->fs.dir); 2223 2224 v9fs_path_free(&path); 2225 if (err < 0) { 2226 return err; 2227 } 2228 return count; 2229 } 2230 2231 static void coroutine_fn v9fs_read(void *opaque) 2232 { 2233 int32_t fid; 2234 uint64_t off; 2235 ssize_t err = 0; 2236 int32_t count = 0; 2237 size_t offset = 7; 2238 uint32_t max_count; 2239 V9fsFidState *fidp; 2240 V9fsPDU *pdu = opaque; 2241 V9fsState *s = pdu->s; 2242 2243 err = pdu_unmarshal(pdu, offset, "dqd", &fid, &off, &max_count); 2244 if (err < 0) { 2245 goto out_nofid; 2246 } 2247 trace_v9fs_read(pdu->tag, pdu->id, fid, off, max_count); 2248 2249 fidp = get_fid(pdu, fid); 2250 if (fidp == NULL) { 2251 err = -EINVAL; 2252 goto out_nofid; 2253 } 2254 if (fidp->fid_type == P9_FID_DIR) { 2255 2256 if (off == 0) { 2257 v9fs_co_rewinddir(pdu, fidp); 2258 } 2259 count = v9fs_do_readdir_with_stat(pdu, fidp, max_count); 2260 if (count < 0) { 2261 err = count; 2262 goto out; 2263 } 2264 err = pdu_marshal(pdu, offset, "d", count); 2265 if (err < 0) { 2266 goto out; 2267 } 2268 err += offset + count; 2269 } else if (fidp->fid_type == P9_FID_FILE) { 2270 QEMUIOVector qiov_full; 2271 QEMUIOVector qiov; 2272 int32_t len; 2273 2274 v9fs_init_qiov_from_pdu(&qiov_full, pdu, offset + 4, max_count, false); 2275 qemu_iovec_init(&qiov, qiov_full.niov); 2276 do { 2277 qemu_iovec_reset(&qiov); 2278 qemu_iovec_concat(&qiov, &qiov_full, count, qiov_full.size - count); 2279 if (0) { 2280 print_sg(qiov.iov, qiov.niov); 2281 } 2282 /* Loop in case of EINTR */ 2283 do { 2284 len = v9fs_co_preadv(pdu, fidp, qiov.iov, qiov.niov, off); 2285 if (len >= 0) { 2286 off += len; 2287 count += len; 2288 } 2289 } while (len == -EINTR && !pdu->cancelled); 2290 if (len < 0) { 2291 /* IO error return the error */ 2292 err = len; 2293 goto out_free_iovec; 2294 } 2295 } while (count < max_count && len > 0); 2296 err = pdu_marshal(pdu, offset, "d", count); 2297 if (err < 0) { 2298 goto out_free_iovec; 2299 } 2300 err += offset + count; 2301 out_free_iovec: 2302 qemu_iovec_destroy(&qiov); 2303 qemu_iovec_destroy(&qiov_full); 2304 } else if (fidp->fid_type == P9_FID_XATTR) { 2305 err = v9fs_xattr_read(s, pdu, fidp, off, max_count); 2306 } else { 2307 err = -EINVAL; 2308 } 2309 trace_v9fs_read_return(pdu->tag, pdu->id, count, err); 2310 out: 2311 put_fid(pdu, fidp); 2312 out_nofid: 2313 pdu_complete(pdu, err); 2314 } 2315 2316 /** 2317 * Returns size required in Rreaddir response for the passed dirent @p name. 2318 * 2319 * @param name - directory entry's name (i.e. file name, directory name) 2320 * @returns required size in bytes 2321 */ 2322 size_t v9fs_readdir_response_size(V9fsString *name) 2323 { 2324 /* 2325 * Size of each dirent on the wire: size of qid (13) + size of offset (8) 2326 * size of type (1) + size of name.size (2) + strlen(name.data) 2327 */ 2328 return 24 + v9fs_string_size(name); 2329 } 2330 2331 static int coroutine_fn v9fs_do_readdir(V9fsPDU *pdu, V9fsFidState *fidp, 2332 int32_t max_count) 2333 { 2334 size_t size; 2335 V9fsQID qid; 2336 V9fsString name; 2337 int len, err = 0; 2338 int32_t count = 0; 2339 off_t saved_dir_pos; 2340 struct dirent *dent; 2341 2342 /* save the directory position */ 2343 saved_dir_pos = v9fs_co_telldir(pdu, fidp); 2344 if (saved_dir_pos < 0) { 2345 return saved_dir_pos; 2346 } 2347 2348 while (1) { 2349 v9fs_readdir_lock(&fidp->fs.dir); 2350 2351 err = v9fs_co_readdir(pdu, fidp, &dent); 2352 if (err || !dent) { 2353 break; 2354 } 2355 v9fs_string_init(&name); 2356 v9fs_string_sprintf(&name, "%s", dent->d_name); 2357 if ((count + v9fs_readdir_response_size(&name)) > max_count) { 2358 v9fs_readdir_unlock(&fidp->fs.dir); 2359 2360 /* Ran out of buffer. Set dir back to old position and return */ 2361 v9fs_co_seekdir(pdu, fidp, saved_dir_pos); 2362 v9fs_string_free(&name); 2363 return count; 2364 } 2365 2366 if (pdu->s->ctx.export_flags & V9FS_REMAP_INODES) { 2367 /* 2368 * dirent_to_qid() implies expensive stat call for each entry, 2369 * we must do that here though since inode remapping requires 2370 * the device id, which in turn might be different for 2371 * different entries; we cannot make any assumption to avoid 2372 * that here. 2373 */ 2374 err = dirent_to_qid(pdu, fidp, dent, &qid); 2375 if (err < 0) { 2376 v9fs_readdir_unlock(&fidp->fs.dir); 2377 v9fs_co_seekdir(pdu, fidp, saved_dir_pos); 2378 v9fs_string_free(&name); 2379 return err; 2380 } 2381 } else { 2382 /* 2383 * Fill up just the path field of qid because the client uses 2384 * only that. To fill the entire qid structure we will have 2385 * to stat each dirent found, which is expensive. For the 2386 * latter reason we don't call dirent_to_qid() here. Only drawback 2387 * is that no multi-device export detection of stat_to_qid() 2388 * would be done and provided as error to the user here. But 2389 * user would get that error anyway when accessing those 2390 * files/dirs through other ways. 2391 */ 2392 size = MIN(sizeof(dent->d_ino), sizeof(qid.path)); 2393 memcpy(&qid.path, &dent->d_ino, size); 2394 /* Fill the other fields with dummy values */ 2395 qid.type = 0; 2396 qid.version = 0; 2397 } 2398 2399 /* 11 = 7 + 4 (7 = start offset, 4 = space for storing count) */ 2400 len = pdu_marshal(pdu, 11 + count, "Qqbs", 2401 &qid, dent->d_off, 2402 dent->d_type, &name); 2403 2404 v9fs_readdir_unlock(&fidp->fs.dir); 2405 2406 if (len < 0) { 2407 v9fs_co_seekdir(pdu, fidp, saved_dir_pos); 2408 v9fs_string_free(&name); 2409 return len; 2410 } 2411 count += len; 2412 v9fs_string_free(&name); 2413 saved_dir_pos = dent->d_off; 2414 } 2415 2416 v9fs_readdir_unlock(&fidp->fs.dir); 2417 2418 if (err < 0) { 2419 return err; 2420 } 2421 return count; 2422 } 2423 2424 static void coroutine_fn v9fs_readdir(void *opaque) 2425 { 2426 int32_t fid; 2427 V9fsFidState *fidp; 2428 ssize_t retval = 0; 2429 size_t offset = 7; 2430 uint64_t initial_offset; 2431 int32_t count; 2432 uint32_t max_count; 2433 V9fsPDU *pdu = opaque; 2434 V9fsState *s = pdu->s; 2435 2436 retval = pdu_unmarshal(pdu, offset, "dqd", &fid, 2437 &initial_offset, &max_count); 2438 if (retval < 0) { 2439 goto out_nofid; 2440 } 2441 trace_v9fs_readdir(pdu->tag, pdu->id, fid, initial_offset, max_count); 2442 2443 /* Enough space for a R_readdir header: size[4] Rreaddir tag[2] count[4] */ 2444 if (max_count > s->msize - 11) { 2445 max_count = s->msize - 11; 2446 warn_report_once( 2447 "9p: bad client: T_readdir with count > msize - 11" 2448 ); 2449 } 2450 2451 fidp = get_fid(pdu, fid); 2452 if (fidp == NULL) { 2453 retval = -EINVAL; 2454 goto out_nofid; 2455 } 2456 if (!fidp->fs.dir.stream) { 2457 retval = -EINVAL; 2458 goto out; 2459 } 2460 if (initial_offset == 0) { 2461 v9fs_co_rewinddir(pdu, fidp); 2462 } else { 2463 v9fs_co_seekdir(pdu, fidp, initial_offset); 2464 } 2465 count = v9fs_do_readdir(pdu, fidp, max_count); 2466 if (count < 0) { 2467 retval = count; 2468 goto out; 2469 } 2470 retval = pdu_marshal(pdu, offset, "d", count); 2471 if (retval < 0) { 2472 goto out; 2473 } 2474 retval += count + offset; 2475 trace_v9fs_readdir_return(pdu->tag, pdu->id, count, retval); 2476 out: 2477 put_fid(pdu, fidp); 2478 out_nofid: 2479 pdu_complete(pdu, retval); 2480 } 2481 2482 static int v9fs_xattr_write(V9fsState *s, V9fsPDU *pdu, V9fsFidState *fidp, 2483 uint64_t off, uint32_t count, 2484 struct iovec *sg, int cnt) 2485 { 2486 int i, to_copy; 2487 ssize_t err = 0; 2488 uint64_t write_count; 2489 size_t offset = 7; 2490 2491 2492 if (fidp->fs.xattr.len < off) { 2493 return -ENOSPC; 2494 } 2495 write_count = fidp->fs.xattr.len - off; 2496 if (write_count > count) { 2497 write_count = count; 2498 } 2499 err = pdu_marshal(pdu, offset, "d", write_count); 2500 if (err < 0) { 2501 return err; 2502 } 2503 err += offset; 2504 fidp->fs.xattr.copied_len += write_count; 2505 /* 2506 * Now copy the content from sg list 2507 */ 2508 for (i = 0; i < cnt; i++) { 2509 if (write_count > sg[i].iov_len) { 2510 to_copy = sg[i].iov_len; 2511 } else { 2512 to_copy = write_count; 2513 } 2514 memcpy((char *)fidp->fs.xattr.value + off, sg[i].iov_base, to_copy); 2515 /* updating vs->off since we are not using below */ 2516 off += to_copy; 2517 write_count -= to_copy; 2518 } 2519 2520 return err; 2521 } 2522 2523 static void coroutine_fn v9fs_write(void *opaque) 2524 { 2525 ssize_t err; 2526 int32_t fid; 2527 uint64_t off; 2528 uint32_t count; 2529 int32_t len = 0; 2530 int32_t total = 0; 2531 size_t offset = 7; 2532 V9fsFidState *fidp; 2533 V9fsPDU *pdu = opaque; 2534 V9fsState *s = pdu->s; 2535 QEMUIOVector qiov_full; 2536 QEMUIOVector qiov; 2537 2538 err = pdu_unmarshal(pdu, offset, "dqd", &fid, &off, &count); 2539 if (err < 0) { 2540 pdu_complete(pdu, err); 2541 return; 2542 } 2543 offset += err; 2544 v9fs_init_qiov_from_pdu(&qiov_full, pdu, offset, count, true); 2545 trace_v9fs_write(pdu->tag, pdu->id, fid, off, count, qiov_full.niov); 2546 2547 fidp = get_fid(pdu, fid); 2548 if (fidp == NULL) { 2549 err = -EINVAL; 2550 goto out_nofid; 2551 } 2552 if (fidp->fid_type == P9_FID_FILE) { 2553 if (fidp->fs.fd == -1) { 2554 err = -EINVAL; 2555 goto out; 2556 } 2557 } else if (fidp->fid_type == P9_FID_XATTR) { 2558 /* 2559 * setxattr operation 2560 */ 2561 err = v9fs_xattr_write(s, pdu, fidp, off, count, 2562 qiov_full.iov, qiov_full.niov); 2563 goto out; 2564 } else { 2565 err = -EINVAL; 2566 goto out; 2567 } 2568 qemu_iovec_init(&qiov, qiov_full.niov); 2569 do { 2570 qemu_iovec_reset(&qiov); 2571 qemu_iovec_concat(&qiov, &qiov_full, total, qiov_full.size - total); 2572 if (0) { 2573 print_sg(qiov.iov, qiov.niov); 2574 } 2575 /* Loop in case of EINTR */ 2576 do { 2577 len = v9fs_co_pwritev(pdu, fidp, qiov.iov, qiov.niov, off); 2578 if (len >= 0) { 2579 off += len; 2580 total += len; 2581 } 2582 } while (len == -EINTR && !pdu->cancelled); 2583 if (len < 0) { 2584 /* IO error return the error */ 2585 err = len; 2586 goto out_qiov; 2587 } 2588 } while (total < count && len > 0); 2589 2590 offset = 7; 2591 err = pdu_marshal(pdu, offset, "d", total); 2592 if (err < 0) { 2593 goto out_qiov; 2594 } 2595 err += offset; 2596 trace_v9fs_write_return(pdu->tag, pdu->id, total, err); 2597 out_qiov: 2598 qemu_iovec_destroy(&qiov); 2599 out: 2600 put_fid(pdu, fidp); 2601 out_nofid: 2602 qemu_iovec_destroy(&qiov_full); 2603 pdu_complete(pdu, err); 2604 } 2605 2606 static void coroutine_fn v9fs_create(void *opaque) 2607 { 2608 int32_t fid; 2609 int err = 0; 2610 size_t offset = 7; 2611 V9fsFidState *fidp; 2612 V9fsQID qid; 2613 int32_t perm; 2614 int8_t mode; 2615 V9fsPath path; 2616 struct stat stbuf; 2617 V9fsString name; 2618 V9fsString extension; 2619 int iounit; 2620 V9fsPDU *pdu = opaque; 2621 V9fsState *s = pdu->s; 2622 2623 v9fs_path_init(&path); 2624 v9fs_string_init(&name); 2625 v9fs_string_init(&extension); 2626 err = pdu_unmarshal(pdu, offset, "dsdbs", &fid, &name, 2627 &perm, &mode, &extension); 2628 if (err < 0) { 2629 goto out_nofid; 2630 } 2631 trace_v9fs_create(pdu->tag, pdu->id, fid, name.data, perm, mode); 2632 2633 if (name_is_illegal(name.data)) { 2634 err = -ENOENT; 2635 goto out_nofid; 2636 } 2637 2638 if (!strcmp(".", name.data) || !strcmp("..", name.data)) { 2639 err = -EEXIST; 2640 goto out_nofid; 2641 } 2642 2643 fidp = get_fid(pdu, fid); 2644 if (fidp == NULL) { 2645 err = -EINVAL; 2646 goto out_nofid; 2647 } 2648 if (fidp->fid_type != P9_FID_NONE) { 2649 err = -EINVAL; 2650 goto out; 2651 } 2652 if (perm & P9_STAT_MODE_DIR) { 2653 err = v9fs_co_mkdir(pdu, fidp, &name, perm & 0777, 2654 fidp->uid, -1, &stbuf); 2655 if (err < 0) { 2656 goto out; 2657 } 2658 err = v9fs_co_name_to_path(pdu, &fidp->path, name.data, &path); 2659 if (err < 0) { 2660 goto out; 2661 } 2662 v9fs_path_write_lock(s); 2663 v9fs_path_copy(&fidp->path, &path); 2664 v9fs_path_unlock(s); 2665 err = v9fs_co_opendir(pdu, fidp); 2666 if (err < 0) { 2667 goto out; 2668 } 2669 fidp->fid_type = P9_FID_DIR; 2670 } else if (perm & P9_STAT_MODE_SYMLINK) { 2671 err = v9fs_co_symlink(pdu, fidp, &name, 2672 extension.data, -1 , &stbuf); 2673 if (err < 0) { 2674 goto out; 2675 } 2676 err = v9fs_co_name_to_path(pdu, &fidp->path, name.data, &path); 2677 if (err < 0) { 2678 goto out; 2679 } 2680 v9fs_path_write_lock(s); 2681 v9fs_path_copy(&fidp->path, &path); 2682 v9fs_path_unlock(s); 2683 } else if (perm & P9_STAT_MODE_LINK) { 2684 int32_t ofid = atoi(extension.data); 2685 V9fsFidState *ofidp = get_fid(pdu, ofid); 2686 if (ofidp == NULL) { 2687 err = -EINVAL; 2688 goto out; 2689 } 2690 err = v9fs_co_link(pdu, ofidp, fidp, &name); 2691 put_fid(pdu, ofidp); 2692 if (err < 0) { 2693 goto out; 2694 } 2695 err = v9fs_co_name_to_path(pdu, &fidp->path, name.data, &path); 2696 if (err < 0) { 2697 fidp->fid_type = P9_FID_NONE; 2698 goto out; 2699 } 2700 v9fs_path_write_lock(s); 2701 v9fs_path_copy(&fidp->path, &path); 2702 v9fs_path_unlock(s); 2703 err = v9fs_co_lstat(pdu, &fidp->path, &stbuf); 2704 if (err < 0) { 2705 fidp->fid_type = P9_FID_NONE; 2706 goto out; 2707 } 2708 } else if (perm & P9_STAT_MODE_DEVICE) { 2709 char ctype; 2710 uint32_t major, minor; 2711 mode_t nmode = 0; 2712 2713 if (sscanf(extension.data, "%c %u %u", &ctype, &major, &minor) != 3) { 2714 err = -errno; 2715 goto out; 2716 } 2717 2718 switch (ctype) { 2719 case 'c': 2720 nmode = S_IFCHR; 2721 break; 2722 case 'b': 2723 nmode = S_IFBLK; 2724 break; 2725 default: 2726 err = -EIO; 2727 goto out; 2728 } 2729 2730 nmode |= perm & 0777; 2731 err = v9fs_co_mknod(pdu, fidp, &name, fidp->uid, -1, 2732 makedev(major, minor), nmode, &stbuf); 2733 if (err < 0) { 2734 goto out; 2735 } 2736 err = v9fs_co_name_to_path(pdu, &fidp->path, name.data, &path); 2737 if (err < 0) { 2738 goto out; 2739 } 2740 v9fs_path_write_lock(s); 2741 v9fs_path_copy(&fidp->path, &path); 2742 v9fs_path_unlock(s); 2743 } else if (perm & P9_STAT_MODE_NAMED_PIPE) { 2744 err = v9fs_co_mknod(pdu, fidp, &name, fidp->uid, -1, 2745 0, S_IFIFO | (perm & 0777), &stbuf); 2746 if (err < 0) { 2747 goto out; 2748 } 2749 err = v9fs_co_name_to_path(pdu, &fidp->path, name.data, &path); 2750 if (err < 0) { 2751 goto out; 2752 } 2753 v9fs_path_write_lock(s); 2754 v9fs_path_copy(&fidp->path, &path); 2755 v9fs_path_unlock(s); 2756 } else if (perm & P9_STAT_MODE_SOCKET) { 2757 err = v9fs_co_mknod(pdu, fidp, &name, fidp->uid, -1, 2758 0, S_IFSOCK | (perm & 0777), &stbuf); 2759 if (err < 0) { 2760 goto out; 2761 } 2762 err = v9fs_co_name_to_path(pdu, &fidp->path, name.data, &path); 2763 if (err < 0) { 2764 goto out; 2765 } 2766 v9fs_path_write_lock(s); 2767 v9fs_path_copy(&fidp->path, &path); 2768 v9fs_path_unlock(s); 2769 } else { 2770 err = v9fs_co_open2(pdu, fidp, &name, -1, 2771 omode_to_uflags(mode)|O_CREAT, perm, &stbuf); 2772 if (err < 0) { 2773 goto out; 2774 } 2775 fidp->fid_type = P9_FID_FILE; 2776 fidp->open_flags = omode_to_uflags(mode); 2777 if (fidp->open_flags & O_EXCL) { 2778 /* 2779 * We let the host file system do O_EXCL check 2780 * We should not reclaim such fd 2781 */ 2782 fidp->flags |= FID_NON_RECLAIMABLE; 2783 } 2784 } 2785 iounit = get_iounit(pdu, &fidp->path); 2786 err = stat_to_qid(pdu, &stbuf, &qid); 2787 if (err < 0) { 2788 goto out; 2789 } 2790 err = pdu_marshal(pdu, offset, "Qd", &qid, iounit); 2791 if (err < 0) { 2792 goto out; 2793 } 2794 err += offset; 2795 trace_v9fs_create_return(pdu->tag, pdu->id, 2796 qid.type, qid.version, qid.path, iounit); 2797 out: 2798 put_fid(pdu, fidp); 2799 out_nofid: 2800 pdu_complete(pdu, err); 2801 v9fs_string_free(&name); 2802 v9fs_string_free(&extension); 2803 v9fs_path_free(&path); 2804 } 2805 2806 static void coroutine_fn v9fs_symlink(void *opaque) 2807 { 2808 V9fsPDU *pdu = opaque; 2809 V9fsString name; 2810 V9fsString symname; 2811 V9fsFidState *dfidp; 2812 V9fsQID qid; 2813 struct stat stbuf; 2814 int32_t dfid; 2815 int err = 0; 2816 gid_t gid; 2817 size_t offset = 7; 2818 2819 v9fs_string_init(&name); 2820 v9fs_string_init(&symname); 2821 err = pdu_unmarshal(pdu, offset, "dssd", &dfid, &name, &symname, &gid); 2822 if (err < 0) { 2823 goto out_nofid; 2824 } 2825 trace_v9fs_symlink(pdu->tag, pdu->id, dfid, name.data, symname.data, gid); 2826 2827 if (name_is_illegal(name.data)) { 2828 err = -ENOENT; 2829 goto out_nofid; 2830 } 2831 2832 if (!strcmp(".", name.data) || !strcmp("..", name.data)) { 2833 err = -EEXIST; 2834 goto out_nofid; 2835 } 2836 2837 dfidp = get_fid(pdu, dfid); 2838 if (dfidp == NULL) { 2839 err = -EINVAL; 2840 goto out_nofid; 2841 } 2842 err = v9fs_co_symlink(pdu, dfidp, &name, symname.data, gid, &stbuf); 2843 if (err < 0) { 2844 goto out; 2845 } 2846 err = stat_to_qid(pdu, &stbuf, &qid); 2847 if (err < 0) { 2848 goto out; 2849 } 2850 err = pdu_marshal(pdu, offset, "Q", &qid); 2851 if (err < 0) { 2852 goto out; 2853 } 2854 err += offset; 2855 trace_v9fs_symlink_return(pdu->tag, pdu->id, 2856 qid.type, qid.version, qid.path); 2857 out: 2858 put_fid(pdu, dfidp); 2859 out_nofid: 2860 pdu_complete(pdu, err); 2861 v9fs_string_free(&name); 2862 v9fs_string_free(&symname); 2863 } 2864 2865 static void coroutine_fn v9fs_flush(void *opaque) 2866 { 2867 ssize_t err; 2868 int16_t tag; 2869 size_t offset = 7; 2870 V9fsPDU *cancel_pdu = NULL; 2871 V9fsPDU *pdu = opaque; 2872 V9fsState *s = pdu->s; 2873 2874 err = pdu_unmarshal(pdu, offset, "w", &tag); 2875 if (err < 0) { 2876 pdu_complete(pdu, err); 2877 return; 2878 } 2879 trace_v9fs_flush(pdu->tag, pdu->id, tag); 2880 2881 if (pdu->tag == tag) { 2882 warn_report("the guest sent a self-referencing 9P flush request"); 2883 } else { 2884 QLIST_FOREACH(cancel_pdu, &s->active_list, next) { 2885 if (cancel_pdu->tag == tag) { 2886 break; 2887 } 2888 } 2889 } 2890 if (cancel_pdu) { 2891 cancel_pdu->cancelled = 1; 2892 /* 2893 * Wait for pdu to complete. 2894 */ 2895 qemu_co_queue_wait(&cancel_pdu->complete, NULL); 2896 if (!qemu_co_queue_next(&cancel_pdu->complete)) { 2897 cancel_pdu->cancelled = 0; 2898 pdu_free(cancel_pdu); 2899 } 2900 } 2901 pdu_complete(pdu, 7); 2902 } 2903 2904 static void coroutine_fn v9fs_link(void *opaque) 2905 { 2906 V9fsPDU *pdu = opaque; 2907 int32_t dfid, oldfid; 2908 V9fsFidState *dfidp, *oldfidp; 2909 V9fsString name; 2910 size_t offset = 7; 2911 int err = 0; 2912 2913 v9fs_string_init(&name); 2914 err = pdu_unmarshal(pdu, offset, "dds", &dfid, &oldfid, &name); 2915 if (err < 0) { 2916 goto out_nofid; 2917 } 2918 trace_v9fs_link(pdu->tag, pdu->id, dfid, oldfid, name.data); 2919 2920 if (name_is_illegal(name.data)) { 2921 err = -ENOENT; 2922 goto out_nofid; 2923 } 2924 2925 if (!strcmp(".", name.data) || !strcmp("..", name.data)) { 2926 err = -EEXIST; 2927 goto out_nofid; 2928 } 2929 2930 dfidp = get_fid(pdu, dfid); 2931 if (dfidp == NULL) { 2932 err = -ENOENT; 2933 goto out_nofid; 2934 } 2935 2936 oldfidp = get_fid(pdu, oldfid); 2937 if (oldfidp == NULL) { 2938 err = -ENOENT; 2939 goto out; 2940 } 2941 err = v9fs_co_link(pdu, oldfidp, dfidp, &name); 2942 if (!err) { 2943 err = offset; 2944 } 2945 put_fid(pdu, oldfidp); 2946 out: 2947 put_fid(pdu, dfidp); 2948 out_nofid: 2949 v9fs_string_free(&name); 2950 pdu_complete(pdu, err); 2951 } 2952 2953 /* Only works with path name based fid */ 2954 static void coroutine_fn v9fs_remove(void *opaque) 2955 { 2956 int32_t fid; 2957 int err = 0; 2958 size_t offset = 7; 2959 V9fsFidState *fidp; 2960 V9fsPDU *pdu = opaque; 2961 2962 err = pdu_unmarshal(pdu, offset, "d", &fid); 2963 if (err < 0) { 2964 goto out_nofid; 2965 } 2966 trace_v9fs_remove(pdu->tag, pdu->id, fid); 2967 2968 fidp = get_fid(pdu, fid); 2969 if (fidp == NULL) { 2970 err = -EINVAL; 2971 goto out_nofid; 2972 } 2973 /* if fs driver is not path based, return EOPNOTSUPP */ 2974 if (!(pdu->s->ctx.export_flags & V9FS_PATHNAME_FSCONTEXT)) { 2975 err = -EOPNOTSUPP; 2976 goto out_err; 2977 } 2978 /* 2979 * IF the file is unlinked, we cannot reopen 2980 * the file later. So don't reclaim fd 2981 */ 2982 err = v9fs_mark_fids_unreclaim(pdu, &fidp->path); 2983 if (err < 0) { 2984 goto out_err; 2985 } 2986 err = v9fs_co_remove(pdu, &fidp->path); 2987 if (!err) { 2988 err = offset; 2989 } 2990 out_err: 2991 /* For TREMOVE we need to clunk the fid even on failed remove */ 2992 clunk_fid(pdu->s, fidp->fid); 2993 put_fid(pdu, fidp); 2994 out_nofid: 2995 pdu_complete(pdu, err); 2996 } 2997 2998 static void coroutine_fn v9fs_unlinkat(void *opaque) 2999 { 3000 int err = 0; 3001 V9fsString name; 3002 int32_t dfid, flags, rflags = 0; 3003 size_t offset = 7; 3004 V9fsPath path; 3005 V9fsFidState *dfidp; 3006 V9fsPDU *pdu = opaque; 3007 3008 v9fs_string_init(&name); 3009 err = pdu_unmarshal(pdu, offset, "dsd", &dfid, &name, &flags); 3010 if (err < 0) { 3011 goto out_nofid; 3012 } 3013 3014 if (name_is_illegal(name.data)) { 3015 err = -ENOENT; 3016 goto out_nofid; 3017 } 3018 3019 if (!strcmp(".", name.data)) { 3020 err = -EINVAL; 3021 goto out_nofid; 3022 } 3023 3024 if (!strcmp("..", name.data)) { 3025 err = -ENOTEMPTY; 3026 goto out_nofid; 3027 } 3028 3029 if (flags & ~P9_DOTL_AT_REMOVEDIR) { 3030 err = -EINVAL; 3031 goto out_nofid; 3032 } 3033 3034 if (flags & P9_DOTL_AT_REMOVEDIR) { 3035 rflags |= AT_REMOVEDIR; 3036 } 3037 3038 dfidp = get_fid(pdu, dfid); 3039 if (dfidp == NULL) { 3040 err = -EINVAL; 3041 goto out_nofid; 3042 } 3043 /* 3044 * IF the file is unlinked, we cannot reopen 3045 * the file later. So don't reclaim fd 3046 */ 3047 v9fs_path_init(&path); 3048 err = v9fs_co_name_to_path(pdu, &dfidp->path, name.data, &path); 3049 if (err < 0) { 3050 goto out_err; 3051 } 3052 err = v9fs_mark_fids_unreclaim(pdu, &path); 3053 if (err < 0) { 3054 goto out_err; 3055 } 3056 err = v9fs_co_unlinkat(pdu, &dfidp->path, &name, rflags); 3057 if (!err) { 3058 err = offset; 3059 } 3060 out_err: 3061 put_fid(pdu, dfidp); 3062 v9fs_path_free(&path); 3063 out_nofid: 3064 pdu_complete(pdu, err); 3065 v9fs_string_free(&name); 3066 } 3067 3068 3069 /* Only works with path name based fid */ 3070 static int coroutine_fn v9fs_complete_rename(V9fsPDU *pdu, V9fsFidState *fidp, 3071 int32_t newdirfid, 3072 V9fsString *name) 3073 { 3074 int err = 0; 3075 V9fsPath new_path; 3076 V9fsFidState *tfidp; 3077 V9fsState *s = pdu->s; 3078 V9fsFidState *dirfidp = NULL; 3079 3080 v9fs_path_init(&new_path); 3081 if (newdirfid != -1) { 3082 dirfidp = get_fid(pdu, newdirfid); 3083 if (dirfidp == NULL) { 3084 return -ENOENT; 3085 } 3086 if (fidp->fid_type != P9_FID_NONE) { 3087 err = -EINVAL; 3088 goto out; 3089 } 3090 err = v9fs_co_name_to_path(pdu, &dirfidp->path, name->data, &new_path); 3091 if (err < 0) { 3092 goto out; 3093 } 3094 } else { 3095 char *dir_name = g_path_get_dirname(fidp->path.data); 3096 V9fsPath dir_path; 3097 3098 v9fs_path_init(&dir_path); 3099 v9fs_path_sprintf(&dir_path, "%s", dir_name); 3100 g_free(dir_name); 3101 3102 err = v9fs_co_name_to_path(pdu, &dir_path, name->data, &new_path); 3103 v9fs_path_free(&dir_path); 3104 if (err < 0) { 3105 goto out; 3106 } 3107 } 3108 err = v9fs_co_rename(pdu, &fidp->path, &new_path); 3109 if (err < 0) { 3110 goto out; 3111 } 3112 /* 3113 * Fixup fid's pointing to the old name to 3114 * start pointing to the new name 3115 */ 3116 for (tfidp = s->fid_list; tfidp; tfidp = tfidp->next) { 3117 if (v9fs_path_is_ancestor(&fidp->path, &tfidp->path)) { 3118 /* replace the name */ 3119 v9fs_fix_path(&tfidp->path, &new_path, strlen(fidp->path.data)); 3120 } 3121 } 3122 out: 3123 if (dirfidp) { 3124 put_fid(pdu, dirfidp); 3125 } 3126 v9fs_path_free(&new_path); 3127 return err; 3128 } 3129 3130 /* Only works with path name based fid */ 3131 static void coroutine_fn v9fs_rename(void *opaque) 3132 { 3133 int32_t fid; 3134 ssize_t err = 0; 3135 size_t offset = 7; 3136 V9fsString name; 3137 int32_t newdirfid; 3138 V9fsFidState *fidp; 3139 V9fsPDU *pdu = opaque; 3140 V9fsState *s = pdu->s; 3141 3142 v9fs_string_init(&name); 3143 err = pdu_unmarshal(pdu, offset, "dds", &fid, &newdirfid, &name); 3144 if (err < 0) { 3145 goto out_nofid; 3146 } 3147 3148 if (name_is_illegal(name.data)) { 3149 err = -ENOENT; 3150 goto out_nofid; 3151 } 3152 3153 if (!strcmp(".", name.data) || !strcmp("..", name.data)) { 3154 err = -EISDIR; 3155 goto out_nofid; 3156 } 3157 3158 fidp = get_fid(pdu, fid); 3159 if (fidp == NULL) { 3160 err = -ENOENT; 3161 goto out_nofid; 3162 } 3163 if (fidp->fid_type != P9_FID_NONE) { 3164 err = -EINVAL; 3165 goto out; 3166 } 3167 /* if fs driver is not path based, return EOPNOTSUPP */ 3168 if (!(pdu->s->ctx.export_flags & V9FS_PATHNAME_FSCONTEXT)) { 3169 err = -EOPNOTSUPP; 3170 goto out; 3171 } 3172 v9fs_path_write_lock(s); 3173 err = v9fs_complete_rename(pdu, fidp, newdirfid, &name); 3174 v9fs_path_unlock(s); 3175 if (!err) { 3176 err = offset; 3177 } 3178 out: 3179 put_fid(pdu, fidp); 3180 out_nofid: 3181 pdu_complete(pdu, err); 3182 v9fs_string_free(&name); 3183 } 3184 3185 static int coroutine_fn v9fs_fix_fid_paths(V9fsPDU *pdu, V9fsPath *olddir, 3186 V9fsString *old_name, 3187 V9fsPath *newdir, 3188 V9fsString *new_name) 3189 { 3190 V9fsFidState *tfidp; 3191 V9fsPath oldpath, newpath; 3192 V9fsState *s = pdu->s; 3193 int err; 3194 3195 v9fs_path_init(&oldpath); 3196 v9fs_path_init(&newpath); 3197 err = v9fs_co_name_to_path(pdu, olddir, old_name->data, &oldpath); 3198 if (err < 0) { 3199 goto out; 3200 } 3201 err = v9fs_co_name_to_path(pdu, newdir, new_name->data, &newpath); 3202 if (err < 0) { 3203 goto out; 3204 } 3205 3206 /* 3207 * Fixup fid's pointing to the old name to 3208 * start pointing to the new name 3209 */ 3210 for (tfidp = s->fid_list; tfidp; tfidp = tfidp->next) { 3211 if (v9fs_path_is_ancestor(&oldpath, &tfidp->path)) { 3212 /* replace the name */ 3213 v9fs_fix_path(&tfidp->path, &newpath, strlen(oldpath.data)); 3214 } 3215 } 3216 out: 3217 v9fs_path_free(&oldpath); 3218 v9fs_path_free(&newpath); 3219 return err; 3220 } 3221 3222 static int coroutine_fn v9fs_complete_renameat(V9fsPDU *pdu, int32_t olddirfid, 3223 V9fsString *old_name, 3224 int32_t newdirfid, 3225 V9fsString *new_name) 3226 { 3227 int err = 0; 3228 V9fsState *s = pdu->s; 3229 V9fsFidState *newdirfidp = NULL, *olddirfidp = NULL; 3230 3231 olddirfidp = get_fid(pdu, olddirfid); 3232 if (olddirfidp == NULL) { 3233 err = -ENOENT; 3234 goto out; 3235 } 3236 if (newdirfid != -1) { 3237 newdirfidp = get_fid(pdu, newdirfid); 3238 if (newdirfidp == NULL) { 3239 err = -ENOENT; 3240 goto out; 3241 } 3242 } else { 3243 newdirfidp = get_fid(pdu, olddirfid); 3244 } 3245 3246 err = v9fs_co_renameat(pdu, &olddirfidp->path, old_name, 3247 &newdirfidp->path, new_name); 3248 if (err < 0) { 3249 goto out; 3250 } 3251 if (s->ctx.export_flags & V9FS_PATHNAME_FSCONTEXT) { 3252 /* Only for path based fid we need to do the below fixup */ 3253 err = v9fs_fix_fid_paths(pdu, &olddirfidp->path, old_name, 3254 &newdirfidp->path, new_name); 3255 } 3256 out: 3257 if (olddirfidp) { 3258 put_fid(pdu, olddirfidp); 3259 } 3260 if (newdirfidp) { 3261 put_fid(pdu, newdirfidp); 3262 } 3263 return err; 3264 } 3265 3266 static void coroutine_fn v9fs_renameat(void *opaque) 3267 { 3268 ssize_t err = 0; 3269 size_t offset = 7; 3270 V9fsPDU *pdu = opaque; 3271 V9fsState *s = pdu->s; 3272 int32_t olddirfid, newdirfid; 3273 V9fsString old_name, new_name; 3274 3275 v9fs_string_init(&old_name); 3276 v9fs_string_init(&new_name); 3277 err = pdu_unmarshal(pdu, offset, "dsds", &olddirfid, 3278 &old_name, &newdirfid, &new_name); 3279 if (err < 0) { 3280 goto out_err; 3281 } 3282 3283 if (name_is_illegal(old_name.data) || name_is_illegal(new_name.data)) { 3284 err = -ENOENT; 3285 goto out_err; 3286 } 3287 3288 if (!strcmp(".", old_name.data) || !strcmp("..", old_name.data) || 3289 !strcmp(".", new_name.data) || !strcmp("..", new_name.data)) { 3290 err = -EISDIR; 3291 goto out_err; 3292 } 3293 3294 v9fs_path_write_lock(s); 3295 err = v9fs_complete_renameat(pdu, olddirfid, 3296 &old_name, newdirfid, &new_name); 3297 v9fs_path_unlock(s); 3298 if (!err) { 3299 err = offset; 3300 } 3301 3302 out_err: 3303 pdu_complete(pdu, err); 3304 v9fs_string_free(&old_name); 3305 v9fs_string_free(&new_name); 3306 } 3307 3308 static void coroutine_fn v9fs_wstat(void *opaque) 3309 { 3310 int32_t fid; 3311 int err = 0; 3312 int16_t unused; 3313 V9fsStat v9stat; 3314 size_t offset = 7; 3315 struct stat stbuf; 3316 V9fsFidState *fidp; 3317 V9fsPDU *pdu = opaque; 3318 V9fsState *s = pdu->s; 3319 3320 v9fs_stat_init(&v9stat); 3321 err = pdu_unmarshal(pdu, offset, "dwS", &fid, &unused, &v9stat); 3322 if (err < 0) { 3323 goto out_nofid; 3324 } 3325 trace_v9fs_wstat(pdu->tag, pdu->id, fid, 3326 v9stat.mode, v9stat.atime, v9stat.mtime); 3327 3328 fidp = get_fid(pdu, fid); 3329 if (fidp == NULL) { 3330 err = -EINVAL; 3331 goto out_nofid; 3332 } 3333 /* do we need to sync the file? */ 3334 if (donttouch_stat(&v9stat)) { 3335 err = v9fs_co_fsync(pdu, fidp, 0); 3336 goto out; 3337 } 3338 if (v9stat.mode != -1) { 3339 uint32_t v9_mode; 3340 err = v9fs_co_lstat(pdu, &fidp->path, &stbuf); 3341 if (err < 0) { 3342 goto out; 3343 } 3344 v9_mode = stat_to_v9mode(&stbuf); 3345 if ((v9stat.mode & P9_STAT_MODE_TYPE_BITS) != 3346 (v9_mode & P9_STAT_MODE_TYPE_BITS)) { 3347 /* Attempting to change the type */ 3348 err = -EIO; 3349 goto out; 3350 } 3351 err = v9fs_co_chmod(pdu, &fidp->path, 3352 v9mode_to_mode(v9stat.mode, 3353 &v9stat.extension)); 3354 if (err < 0) { 3355 goto out; 3356 } 3357 } 3358 if (v9stat.mtime != -1 || v9stat.atime != -1) { 3359 struct timespec times[2]; 3360 if (v9stat.atime != -1) { 3361 times[0].tv_sec = v9stat.atime; 3362 times[0].tv_nsec = 0; 3363 } else { 3364 times[0].tv_nsec = UTIME_OMIT; 3365 } 3366 if (v9stat.mtime != -1) { 3367 times[1].tv_sec = v9stat.mtime; 3368 times[1].tv_nsec = 0; 3369 } else { 3370 times[1].tv_nsec = UTIME_OMIT; 3371 } 3372 err = v9fs_co_utimensat(pdu, &fidp->path, times); 3373 if (err < 0) { 3374 goto out; 3375 } 3376 } 3377 if (v9stat.n_gid != -1 || v9stat.n_uid != -1) { 3378 err = v9fs_co_chown(pdu, &fidp->path, v9stat.n_uid, v9stat.n_gid); 3379 if (err < 0) { 3380 goto out; 3381 } 3382 } 3383 if (v9stat.name.size != 0) { 3384 v9fs_path_write_lock(s); 3385 err = v9fs_complete_rename(pdu, fidp, -1, &v9stat.name); 3386 v9fs_path_unlock(s); 3387 if (err < 0) { 3388 goto out; 3389 } 3390 } 3391 if (v9stat.length != -1) { 3392 err = v9fs_co_truncate(pdu, &fidp->path, v9stat.length); 3393 if (err < 0) { 3394 goto out; 3395 } 3396 } 3397 err = offset; 3398 out: 3399 put_fid(pdu, fidp); 3400 out_nofid: 3401 v9fs_stat_free(&v9stat); 3402 pdu_complete(pdu, err); 3403 } 3404 3405 static int v9fs_fill_statfs(V9fsState *s, V9fsPDU *pdu, struct statfs *stbuf) 3406 { 3407 uint32_t f_type; 3408 uint32_t f_bsize; 3409 uint64_t f_blocks; 3410 uint64_t f_bfree; 3411 uint64_t f_bavail; 3412 uint64_t f_files; 3413 uint64_t f_ffree; 3414 uint64_t fsid_val; 3415 uint32_t f_namelen; 3416 size_t offset = 7; 3417 int32_t bsize_factor; 3418 3419 /* 3420 * compute bsize factor based on host file system block size 3421 * and client msize 3422 */ 3423 bsize_factor = (s->msize - P9_IOHDRSZ)/stbuf->f_bsize; 3424 if (!bsize_factor) { 3425 bsize_factor = 1; 3426 } 3427 f_type = stbuf->f_type; 3428 f_bsize = stbuf->f_bsize; 3429 f_bsize *= bsize_factor; 3430 /* 3431 * f_bsize is adjusted(multiplied) by bsize factor, so we need to 3432 * adjust(divide) the number of blocks, free blocks and available 3433 * blocks by bsize factor 3434 */ 3435 f_blocks = stbuf->f_blocks/bsize_factor; 3436 f_bfree = stbuf->f_bfree/bsize_factor; 3437 f_bavail = stbuf->f_bavail/bsize_factor; 3438 f_files = stbuf->f_files; 3439 f_ffree = stbuf->f_ffree; 3440 fsid_val = (unsigned int) stbuf->f_fsid.__val[0] | 3441 (unsigned long long)stbuf->f_fsid.__val[1] << 32; 3442 f_namelen = stbuf->f_namelen; 3443 3444 return pdu_marshal(pdu, offset, "ddqqqqqqd", 3445 f_type, f_bsize, f_blocks, f_bfree, 3446 f_bavail, f_files, f_ffree, 3447 fsid_val, f_namelen); 3448 } 3449 3450 static void coroutine_fn v9fs_statfs(void *opaque) 3451 { 3452 int32_t fid; 3453 ssize_t retval = 0; 3454 size_t offset = 7; 3455 V9fsFidState *fidp; 3456 struct statfs stbuf; 3457 V9fsPDU *pdu = opaque; 3458 V9fsState *s = pdu->s; 3459 3460 retval = pdu_unmarshal(pdu, offset, "d", &fid); 3461 if (retval < 0) { 3462 goto out_nofid; 3463 } 3464 fidp = get_fid(pdu, fid); 3465 if (fidp == NULL) { 3466 retval = -ENOENT; 3467 goto out_nofid; 3468 } 3469 retval = v9fs_co_statfs(pdu, &fidp->path, &stbuf); 3470 if (retval < 0) { 3471 goto out; 3472 } 3473 retval = v9fs_fill_statfs(s, pdu, &stbuf); 3474 if (retval < 0) { 3475 goto out; 3476 } 3477 retval += offset; 3478 out: 3479 put_fid(pdu, fidp); 3480 out_nofid: 3481 pdu_complete(pdu, retval); 3482 } 3483 3484 static void coroutine_fn v9fs_mknod(void *opaque) 3485 { 3486 3487 int mode; 3488 gid_t gid; 3489 int32_t fid; 3490 V9fsQID qid; 3491 int err = 0; 3492 int major, minor; 3493 size_t offset = 7; 3494 V9fsString name; 3495 struct stat stbuf; 3496 V9fsFidState *fidp; 3497 V9fsPDU *pdu = opaque; 3498 3499 v9fs_string_init(&name); 3500 err = pdu_unmarshal(pdu, offset, "dsdddd", &fid, &name, &mode, 3501 &major, &minor, &gid); 3502 if (err < 0) { 3503 goto out_nofid; 3504 } 3505 trace_v9fs_mknod(pdu->tag, pdu->id, fid, mode, major, minor); 3506 3507 if (name_is_illegal(name.data)) { 3508 err = -ENOENT; 3509 goto out_nofid; 3510 } 3511 3512 if (!strcmp(".", name.data) || !strcmp("..", name.data)) { 3513 err = -EEXIST; 3514 goto out_nofid; 3515 } 3516 3517 fidp = get_fid(pdu, fid); 3518 if (fidp == NULL) { 3519 err = -ENOENT; 3520 goto out_nofid; 3521 } 3522 err = v9fs_co_mknod(pdu, fidp, &name, fidp->uid, gid, 3523 makedev(major, minor), mode, &stbuf); 3524 if (err < 0) { 3525 goto out; 3526 } 3527 err = stat_to_qid(pdu, &stbuf, &qid); 3528 if (err < 0) { 3529 goto out; 3530 } 3531 err = pdu_marshal(pdu, offset, "Q", &qid); 3532 if (err < 0) { 3533 goto out; 3534 } 3535 err += offset; 3536 trace_v9fs_mknod_return(pdu->tag, pdu->id, 3537 qid.type, qid.version, qid.path); 3538 out: 3539 put_fid(pdu, fidp); 3540 out_nofid: 3541 pdu_complete(pdu, err); 3542 v9fs_string_free(&name); 3543 } 3544 3545 /* 3546 * Implement posix byte range locking code 3547 * Server side handling of locking code is very simple, because 9p server in 3548 * QEMU can handle only one client. And most of the lock handling 3549 * (like conflict, merging) etc is done by the VFS layer itself, so no need to 3550 * do any thing in * qemu 9p server side lock code path. 3551 * So when a TLOCK request comes, always return success 3552 */ 3553 static void coroutine_fn v9fs_lock(void *opaque) 3554 { 3555 V9fsFlock flock; 3556 size_t offset = 7; 3557 struct stat stbuf; 3558 V9fsFidState *fidp; 3559 int32_t fid, err = 0; 3560 V9fsPDU *pdu = opaque; 3561 3562 v9fs_string_init(&flock.client_id); 3563 err = pdu_unmarshal(pdu, offset, "dbdqqds", &fid, &flock.type, 3564 &flock.flags, &flock.start, &flock.length, 3565 &flock.proc_id, &flock.client_id); 3566 if (err < 0) { 3567 goto out_nofid; 3568 } 3569 trace_v9fs_lock(pdu->tag, pdu->id, fid, 3570 flock.type, flock.start, flock.length); 3571 3572 3573 /* We support only block flag now (that too ignored currently) */ 3574 if (flock.flags & ~P9_LOCK_FLAGS_BLOCK) { 3575 err = -EINVAL; 3576 goto out_nofid; 3577 } 3578 fidp = get_fid(pdu, fid); 3579 if (fidp == NULL) { 3580 err = -ENOENT; 3581 goto out_nofid; 3582 } 3583 err = v9fs_co_fstat(pdu, fidp, &stbuf); 3584 if (err < 0) { 3585 goto out; 3586 } 3587 err = pdu_marshal(pdu, offset, "b", P9_LOCK_SUCCESS); 3588 if (err < 0) { 3589 goto out; 3590 } 3591 err += offset; 3592 trace_v9fs_lock_return(pdu->tag, pdu->id, P9_LOCK_SUCCESS); 3593 out: 3594 put_fid(pdu, fidp); 3595 out_nofid: 3596 pdu_complete(pdu, err); 3597 v9fs_string_free(&flock.client_id); 3598 } 3599 3600 /* 3601 * When a TGETLOCK request comes, always return success because all lock 3602 * handling is done by client's VFS layer. 3603 */ 3604 static void coroutine_fn v9fs_getlock(void *opaque) 3605 { 3606 size_t offset = 7; 3607 struct stat stbuf; 3608 V9fsFidState *fidp; 3609 V9fsGetlock glock; 3610 int32_t fid, err = 0; 3611 V9fsPDU *pdu = opaque; 3612 3613 v9fs_string_init(&glock.client_id); 3614 err = pdu_unmarshal(pdu, offset, "dbqqds", &fid, &glock.type, 3615 &glock.start, &glock.length, &glock.proc_id, 3616 &glock.client_id); 3617 if (err < 0) { 3618 goto out_nofid; 3619 } 3620 trace_v9fs_getlock(pdu->tag, pdu->id, fid, 3621 glock.type, glock.start, glock.length); 3622 3623 fidp = get_fid(pdu, fid); 3624 if (fidp == NULL) { 3625 err = -ENOENT; 3626 goto out_nofid; 3627 } 3628 err = v9fs_co_fstat(pdu, fidp, &stbuf); 3629 if (err < 0) { 3630 goto out; 3631 } 3632 glock.type = P9_LOCK_TYPE_UNLCK; 3633 err = pdu_marshal(pdu, offset, "bqqds", glock.type, 3634 glock.start, glock.length, glock.proc_id, 3635 &glock.client_id); 3636 if (err < 0) { 3637 goto out; 3638 } 3639 err += offset; 3640 trace_v9fs_getlock_return(pdu->tag, pdu->id, glock.type, glock.start, 3641 glock.length, glock.proc_id); 3642 out: 3643 put_fid(pdu, fidp); 3644 out_nofid: 3645 pdu_complete(pdu, err); 3646 v9fs_string_free(&glock.client_id); 3647 } 3648 3649 static void coroutine_fn v9fs_mkdir(void *opaque) 3650 { 3651 V9fsPDU *pdu = opaque; 3652 size_t offset = 7; 3653 int32_t fid; 3654 struct stat stbuf; 3655 V9fsQID qid; 3656 V9fsString name; 3657 V9fsFidState *fidp; 3658 gid_t gid; 3659 int mode; 3660 int err = 0; 3661 3662 v9fs_string_init(&name); 3663 err = pdu_unmarshal(pdu, offset, "dsdd", &fid, &name, &mode, &gid); 3664 if (err < 0) { 3665 goto out_nofid; 3666 } 3667 trace_v9fs_mkdir(pdu->tag, pdu->id, fid, name.data, mode, gid); 3668 3669 if (name_is_illegal(name.data)) { 3670 err = -ENOENT; 3671 goto out_nofid; 3672 } 3673 3674 if (!strcmp(".", name.data) || !strcmp("..", name.data)) { 3675 err = -EEXIST; 3676 goto out_nofid; 3677 } 3678 3679 fidp = get_fid(pdu, fid); 3680 if (fidp == NULL) { 3681 err = -ENOENT; 3682 goto out_nofid; 3683 } 3684 err = v9fs_co_mkdir(pdu, fidp, &name, mode, fidp->uid, gid, &stbuf); 3685 if (err < 0) { 3686 goto out; 3687 } 3688 err = stat_to_qid(pdu, &stbuf, &qid); 3689 if (err < 0) { 3690 goto out; 3691 } 3692 err = pdu_marshal(pdu, offset, "Q", &qid); 3693 if (err < 0) { 3694 goto out; 3695 } 3696 err += offset; 3697 trace_v9fs_mkdir_return(pdu->tag, pdu->id, 3698 qid.type, qid.version, qid.path, err); 3699 out: 3700 put_fid(pdu, fidp); 3701 out_nofid: 3702 pdu_complete(pdu, err); 3703 v9fs_string_free(&name); 3704 } 3705 3706 static void coroutine_fn v9fs_xattrwalk(void *opaque) 3707 { 3708 int64_t size; 3709 V9fsString name; 3710 ssize_t err = 0; 3711 size_t offset = 7; 3712 int32_t fid, newfid; 3713 V9fsFidState *file_fidp; 3714 V9fsFidState *xattr_fidp = NULL; 3715 V9fsPDU *pdu = opaque; 3716 V9fsState *s = pdu->s; 3717 3718 v9fs_string_init(&name); 3719 err = pdu_unmarshal(pdu, offset, "dds", &fid, &newfid, &name); 3720 if (err < 0) { 3721 goto out_nofid; 3722 } 3723 trace_v9fs_xattrwalk(pdu->tag, pdu->id, fid, newfid, name.data); 3724 3725 file_fidp = get_fid(pdu, fid); 3726 if (file_fidp == NULL) { 3727 err = -ENOENT; 3728 goto out_nofid; 3729 } 3730 xattr_fidp = alloc_fid(s, newfid); 3731 if (xattr_fidp == NULL) { 3732 err = -EINVAL; 3733 goto out; 3734 } 3735 v9fs_path_copy(&xattr_fidp->path, &file_fidp->path); 3736 if (!v9fs_string_size(&name)) { 3737 /* 3738 * listxattr request. Get the size first 3739 */ 3740 size = v9fs_co_llistxattr(pdu, &xattr_fidp->path, NULL, 0); 3741 if (size < 0) { 3742 err = size; 3743 clunk_fid(s, xattr_fidp->fid); 3744 goto out; 3745 } 3746 /* 3747 * Read the xattr value 3748 */ 3749 xattr_fidp->fs.xattr.len = size; 3750 xattr_fidp->fid_type = P9_FID_XATTR; 3751 xattr_fidp->fs.xattr.xattrwalk_fid = true; 3752 xattr_fidp->fs.xattr.value = g_malloc0(size); 3753 if (size) { 3754 err = v9fs_co_llistxattr(pdu, &xattr_fidp->path, 3755 xattr_fidp->fs.xattr.value, 3756 xattr_fidp->fs.xattr.len); 3757 if (err < 0) { 3758 clunk_fid(s, xattr_fidp->fid); 3759 goto out; 3760 } 3761 } 3762 err = pdu_marshal(pdu, offset, "q", size); 3763 if (err < 0) { 3764 goto out; 3765 } 3766 err += offset; 3767 } else { 3768 /* 3769 * specific xattr fid. We check for xattr 3770 * presence also collect the xattr size 3771 */ 3772 size = v9fs_co_lgetxattr(pdu, &xattr_fidp->path, 3773 &name, NULL, 0); 3774 if (size < 0) { 3775 err = size; 3776 clunk_fid(s, xattr_fidp->fid); 3777 goto out; 3778 } 3779 /* 3780 * Read the xattr value 3781 */ 3782 xattr_fidp->fs.xattr.len = size; 3783 xattr_fidp->fid_type = P9_FID_XATTR; 3784 xattr_fidp->fs.xattr.xattrwalk_fid = true; 3785 xattr_fidp->fs.xattr.value = g_malloc0(size); 3786 if (size) { 3787 err = v9fs_co_lgetxattr(pdu, &xattr_fidp->path, 3788 &name, xattr_fidp->fs.xattr.value, 3789 xattr_fidp->fs.xattr.len); 3790 if (err < 0) { 3791 clunk_fid(s, xattr_fidp->fid); 3792 goto out; 3793 } 3794 } 3795 err = pdu_marshal(pdu, offset, "q", size); 3796 if (err < 0) { 3797 goto out; 3798 } 3799 err += offset; 3800 } 3801 trace_v9fs_xattrwalk_return(pdu->tag, pdu->id, size); 3802 out: 3803 put_fid(pdu, file_fidp); 3804 if (xattr_fidp) { 3805 put_fid(pdu, xattr_fidp); 3806 } 3807 out_nofid: 3808 pdu_complete(pdu, err); 3809 v9fs_string_free(&name); 3810 } 3811 3812 static void coroutine_fn v9fs_xattrcreate(void *opaque) 3813 { 3814 int flags, rflags = 0; 3815 int32_t fid; 3816 uint64_t size; 3817 ssize_t err = 0; 3818 V9fsString name; 3819 size_t offset = 7; 3820 V9fsFidState *file_fidp; 3821 V9fsFidState *xattr_fidp; 3822 V9fsPDU *pdu = opaque; 3823 3824 v9fs_string_init(&name); 3825 err = pdu_unmarshal(pdu, offset, "dsqd", &fid, &name, &size, &flags); 3826 if (err < 0) { 3827 goto out_nofid; 3828 } 3829 trace_v9fs_xattrcreate(pdu->tag, pdu->id, fid, name.data, size, flags); 3830 3831 if (flags & ~(P9_XATTR_CREATE | P9_XATTR_REPLACE)) { 3832 err = -EINVAL; 3833 goto out_nofid; 3834 } 3835 3836 if (flags & P9_XATTR_CREATE) { 3837 rflags |= XATTR_CREATE; 3838 } 3839 3840 if (flags & P9_XATTR_REPLACE) { 3841 rflags |= XATTR_REPLACE; 3842 } 3843 3844 if (size > XATTR_SIZE_MAX) { 3845 err = -E2BIG; 3846 goto out_nofid; 3847 } 3848 3849 file_fidp = get_fid(pdu, fid); 3850 if (file_fidp == NULL) { 3851 err = -EINVAL; 3852 goto out_nofid; 3853 } 3854 if (file_fidp->fid_type != P9_FID_NONE) { 3855 err = -EINVAL; 3856 goto out_put_fid; 3857 } 3858 3859 /* Make the file fid point to xattr */ 3860 xattr_fidp = file_fidp; 3861 xattr_fidp->fid_type = P9_FID_XATTR; 3862 xattr_fidp->fs.xattr.copied_len = 0; 3863 xattr_fidp->fs.xattr.xattrwalk_fid = false; 3864 xattr_fidp->fs.xattr.len = size; 3865 xattr_fidp->fs.xattr.flags = rflags; 3866 v9fs_string_init(&xattr_fidp->fs.xattr.name); 3867 v9fs_string_copy(&xattr_fidp->fs.xattr.name, &name); 3868 xattr_fidp->fs.xattr.value = g_malloc0(size); 3869 err = offset; 3870 out_put_fid: 3871 put_fid(pdu, file_fidp); 3872 out_nofid: 3873 pdu_complete(pdu, err); 3874 v9fs_string_free(&name); 3875 } 3876 3877 static void coroutine_fn v9fs_readlink(void *opaque) 3878 { 3879 V9fsPDU *pdu = opaque; 3880 size_t offset = 7; 3881 V9fsString target; 3882 int32_t fid; 3883 int err = 0; 3884 V9fsFidState *fidp; 3885 3886 err = pdu_unmarshal(pdu, offset, "d", &fid); 3887 if (err < 0) { 3888 goto out_nofid; 3889 } 3890 trace_v9fs_readlink(pdu->tag, pdu->id, fid); 3891 fidp = get_fid(pdu, fid); 3892 if (fidp == NULL) { 3893 err = -ENOENT; 3894 goto out_nofid; 3895 } 3896 3897 v9fs_string_init(&target); 3898 err = v9fs_co_readlink(pdu, &fidp->path, &target); 3899 if (err < 0) { 3900 goto out; 3901 } 3902 err = pdu_marshal(pdu, offset, "s", &target); 3903 if (err < 0) { 3904 v9fs_string_free(&target); 3905 goto out; 3906 } 3907 err += offset; 3908 trace_v9fs_readlink_return(pdu->tag, pdu->id, target.data); 3909 v9fs_string_free(&target); 3910 out: 3911 put_fid(pdu, fidp); 3912 out_nofid: 3913 pdu_complete(pdu, err); 3914 } 3915 3916 static CoroutineEntry *pdu_co_handlers[] = { 3917 [P9_TREADDIR] = v9fs_readdir, 3918 [P9_TSTATFS] = v9fs_statfs, 3919 [P9_TGETATTR] = v9fs_getattr, 3920 [P9_TSETATTR] = v9fs_setattr, 3921 [P9_TXATTRWALK] = v9fs_xattrwalk, 3922 [P9_TXATTRCREATE] = v9fs_xattrcreate, 3923 [P9_TMKNOD] = v9fs_mknod, 3924 [P9_TRENAME] = v9fs_rename, 3925 [P9_TLOCK] = v9fs_lock, 3926 [P9_TGETLOCK] = v9fs_getlock, 3927 [P9_TRENAMEAT] = v9fs_renameat, 3928 [P9_TREADLINK] = v9fs_readlink, 3929 [P9_TUNLINKAT] = v9fs_unlinkat, 3930 [P9_TMKDIR] = v9fs_mkdir, 3931 [P9_TVERSION] = v9fs_version, 3932 [P9_TLOPEN] = v9fs_open, 3933 [P9_TATTACH] = v9fs_attach, 3934 [P9_TSTAT] = v9fs_stat, 3935 [P9_TWALK] = v9fs_walk, 3936 [P9_TCLUNK] = v9fs_clunk, 3937 [P9_TFSYNC] = v9fs_fsync, 3938 [P9_TOPEN] = v9fs_open, 3939 [P9_TREAD] = v9fs_read, 3940 #if 0 3941 [P9_TAUTH] = v9fs_auth, 3942 #endif 3943 [P9_TFLUSH] = v9fs_flush, 3944 [P9_TLINK] = v9fs_link, 3945 [P9_TSYMLINK] = v9fs_symlink, 3946 [P9_TCREATE] = v9fs_create, 3947 [P9_TLCREATE] = v9fs_lcreate, 3948 [P9_TWRITE] = v9fs_write, 3949 [P9_TWSTAT] = v9fs_wstat, 3950 [P9_TREMOVE] = v9fs_remove, 3951 }; 3952 3953 static void coroutine_fn v9fs_op_not_supp(void *opaque) 3954 { 3955 V9fsPDU *pdu = opaque; 3956 pdu_complete(pdu, -EOPNOTSUPP); 3957 } 3958 3959 static void coroutine_fn v9fs_fs_ro(void *opaque) 3960 { 3961 V9fsPDU *pdu = opaque; 3962 pdu_complete(pdu, -EROFS); 3963 } 3964 3965 static inline bool is_read_only_op(V9fsPDU *pdu) 3966 { 3967 switch (pdu->id) { 3968 case P9_TREADDIR: 3969 case P9_TSTATFS: 3970 case P9_TGETATTR: 3971 case P9_TXATTRWALK: 3972 case P9_TLOCK: 3973 case P9_TGETLOCK: 3974 case P9_TREADLINK: 3975 case P9_TVERSION: 3976 case P9_TLOPEN: 3977 case P9_TATTACH: 3978 case P9_TSTAT: 3979 case P9_TWALK: 3980 case P9_TCLUNK: 3981 case P9_TFSYNC: 3982 case P9_TOPEN: 3983 case P9_TREAD: 3984 case P9_TAUTH: 3985 case P9_TFLUSH: 3986 return 1; 3987 default: 3988 return 0; 3989 } 3990 } 3991 3992 void pdu_submit(V9fsPDU *pdu, P9MsgHeader *hdr) 3993 { 3994 Coroutine *co; 3995 CoroutineEntry *handler; 3996 V9fsState *s = pdu->s; 3997 3998 pdu->size = le32_to_cpu(hdr->size_le); 3999 pdu->id = hdr->id; 4000 pdu->tag = le16_to_cpu(hdr->tag_le); 4001 4002 if (pdu->id >= ARRAY_SIZE(pdu_co_handlers) || 4003 (pdu_co_handlers[pdu->id] == NULL)) { 4004 handler = v9fs_op_not_supp; 4005 } else if (is_ro_export(&s->ctx) && !is_read_only_op(pdu)) { 4006 handler = v9fs_fs_ro; 4007 } else { 4008 handler = pdu_co_handlers[pdu->id]; 4009 } 4010 4011 qemu_co_queue_init(&pdu->complete); 4012 co = qemu_coroutine_create(handler, pdu); 4013 qemu_coroutine_enter(co); 4014 } 4015 4016 /* Returns 0 on success, 1 on failure. */ 4017 int v9fs_device_realize_common(V9fsState *s, const V9fsTransport *t, 4018 Error **errp) 4019 { 4020 ERRP_GUARD(); 4021 int i, len; 4022 struct stat stat; 4023 FsDriverEntry *fse; 4024 V9fsPath path; 4025 int rc = 1; 4026 4027 assert(!s->transport); 4028 s->transport = t; 4029 4030 /* initialize pdu allocator */ 4031 QLIST_INIT(&s->free_list); 4032 QLIST_INIT(&s->active_list); 4033 for (i = 0; i < MAX_REQ; i++) { 4034 QLIST_INSERT_HEAD(&s->free_list, &s->pdus[i], next); 4035 s->pdus[i].s = s; 4036 s->pdus[i].idx = i; 4037 } 4038 4039 v9fs_path_init(&path); 4040 4041 fse = get_fsdev_fsentry(s->fsconf.fsdev_id); 4042 4043 if (!fse) { 4044 /* We don't have a fsdev identified by fsdev_id */ 4045 error_setg(errp, "9pfs device couldn't find fsdev with the " 4046 "id = %s", 4047 s->fsconf.fsdev_id ? s->fsconf.fsdev_id : "NULL"); 4048 goto out; 4049 } 4050 4051 if (!s->fsconf.tag) { 4052 /* we haven't specified a mount_tag */ 4053 error_setg(errp, "fsdev with id %s needs mount_tag arguments", 4054 s->fsconf.fsdev_id); 4055 goto out; 4056 } 4057 4058 s->ctx.export_flags = fse->export_flags; 4059 s->ctx.fs_root = g_strdup(fse->path); 4060 s->ctx.exops.get_st_gen = NULL; 4061 len = strlen(s->fsconf.tag); 4062 if (len > MAX_TAG_LEN - 1) { 4063 error_setg(errp, "mount tag '%s' (%d bytes) is longer than " 4064 "maximum (%d bytes)", s->fsconf.tag, len, MAX_TAG_LEN - 1); 4065 goto out; 4066 } 4067 4068 s->tag = g_strdup(s->fsconf.tag); 4069 s->ctx.uid = -1; 4070 4071 s->ops = fse->ops; 4072 4073 s->ctx.fmode = fse->fmode; 4074 s->ctx.dmode = fse->dmode; 4075 4076 s->fid_list = NULL; 4077 qemu_co_rwlock_init(&s->rename_lock); 4078 4079 if (s->ops->init(&s->ctx, errp) < 0) { 4080 error_prepend(errp, "cannot initialize fsdev '%s': ", 4081 s->fsconf.fsdev_id); 4082 goto out; 4083 } 4084 4085 /* 4086 * Check details of export path, We need to use fs driver 4087 * call back to do that. Since we are in the init path, we don't 4088 * use co-routines here. 4089 */ 4090 if (s->ops->name_to_path(&s->ctx, NULL, "/", &path) < 0) { 4091 error_setg(errp, 4092 "error in converting name to path %s", strerror(errno)); 4093 goto out; 4094 } 4095 if (s->ops->lstat(&s->ctx, &path, &stat)) { 4096 error_setg(errp, "share path %s does not exist", fse->path); 4097 goto out; 4098 } else if (!S_ISDIR(stat.st_mode)) { 4099 error_setg(errp, "share path %s is not a directory", fse->path); 4100 goto out; 4101 } 4102 4103 s->dev_id = stat.st_dev; 4104 4105 /* init inode remapping : */ 4106 /* hash table for variable length inode suffixes */ 4107 qpd_table_init(&s->qpd_table); 4108 /* hash table for slow/full inode remapping (most users won't need it) */ 4109 qpf_table_init(&s->qpf_table); 4110 /* hash table for quick inode remapping */ 4111 qpp_table_init(&s->qpp_table); 4112 s->qp_ndevices = 0; 4113 s->qp_affix_next = 1; /* reserve 0 to detect overflow */ 4114 s->qp_fullpath_next = 1; 4115 4116 s->ctx.fst = &fse->fst; 4117 fsdev_throttle_init(s->ctx.fst); 4118 4119 rc = 0; 4120 out: 4121 if (rc) { 4122 v9fs_device_unrealize_common(s); 4123 } 4124 v9fs_path_free(&path); 4125 return rc; 4126 } 4127 4128 void v9fs_device_unrealize_common(V9fsState *s) 4129 { 4130 if (s->ops && s->ops->cleanup) { 4131 s->ops->cleanup(&s->ctx); 4132 } 4133 if (s->ctx.fst) { 4134 fsdev_throttle_cleanup(s->ctx.fst); 4135 } 4136 g_free(s->tag); 4137 qp_table_destroy(&s->qpd_table); 4138 qp_table_destroy(&s->qpp_table); 4139 qp_table_destroy(&s->qpf_table); 4140 g_free(s->ctx.fs_root); 4141 } 4142 4143 typedef struct VirtfsCoResetData { 4144 V9fsPDU pdu; 4145 bool done; 4146 } VirtfsCoResetData; 4147 4148 static void coroutine_fn virtfs_co_reset(void *opaque) 4149 { 4150 VirtfsCoResetData *data = opaque; 4151 4152 virtfs_reset(&data->pdu); 4153 data->done = true; 4154 } 4155 4156 void v9fs_reset(V9fsState *s) 4157 { 4158 VirtfsCoResetData data = { .pdu = { .s = s }, .done = false }; 4159 Coroutine *co; 4160 4161 while (!QLIST_EMPTY(&s->active_list)) { 4162 aio_poll(qemu_get_aio_context(), true); 4163 } 4164 4165 co = qemu_coroutine_create(virtfs_co_reset, &data); 4166 qemu_coroutine_enter(co); 4167 4168 while (!data.done) { 4169 aio_poll(qemu_get_aio_context(), true); 4170 } 4171 } 4172 4173 static void __attribute__((__constructor__)) v9fs_set_fd_limit(void) 4174 { 4175 struct rlimit rlim; 4176 if (getrlimit(RLIMIT_NOFILE, &rlim) < 0) { 4177 error_report("Failed to get the resource limit"); 4178 exit(1); 4179 } 4180 open_fd_hw = rlim.rlim_cur - MIN(400, rlim.rlim_cur/3); 4181 open_fd_rc = rlim.rlim_cur/2; 4182 } 4183