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