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