rumpfs.c revision 1.155
1 /* $NetBSD: rumpfs.c,v 1.155 2020/04/04 19:24:51 kamil Exp $ */ 2 3 /* 4 * Copyright (c) 2009, 2010, 2011 Antti Kantee. All Rights Reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS 16 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 17 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 18 * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 21 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 25 * SUCH DAMAGE. 26 */ 27 28 #include <sys/cdefs.h> 29 __KERNEL_RCSID(0, "$NetBSD: rumpfs.c,v 1.155 2020/04/04 19:24:51 kamil Exp $"); 30 31 #include <sys/param.h> 32 #include <sys/atomic.h> 33 #include <sys/buf.h> 34 #include <sys/dirent.h> 35 #include <sys/errno.h> 36 #include <sys/filedesc.h> 37 #include <sys/fcntl.h> 38 #include <sys/kauth.h> 39 #include <sys/malloc.h> 40 #include <sys/module.h> 41 #include <sys/mount.h> 42 #include <sys/namei.h> 43 #include <sys/lock.h> 44 #include <sys/lockf.h> 45 #include <sys/queue.h> 46 #include <sys/stat.h> 47 #include <sys/syscallargs.h> 48 #include <sys/vnode.h> 49 #include <sys/fstrans.h> 50 #include <sys/unistd.h> 51 52 #include <miscfs/fifofs/fifo.h> 53 #include <miscfs/specfs/specdev.h> 54 #include <miscfs/genfs/genfs.h> 55 #include <miscfs/genfs/genfs_node.h> 56 57 #include <uvm/uvm_extern.h> 58 59 #include <rump-sys/kern.h> 60 #include <rump-sys/vfs.h> 61 62 #include <rump/rumpfs.h> 63 #include <rump/rumpuser.h> 64 65 static int rump_vop_lookup(void *); 66 static int rump_vop_getattr(void *); 67 static int rump_vop_setattr(void *); 68 static int rump_vop_mkdir(void *); 69 static int rump_vop_rmdir(void *); 70 static int rump_vop_remove(void *); 71 static int rump_vop_mknod(void *); 72 static int rump_vop_create(void *); 73 static int rump_vop_inactive(void *); 74 static int rump_vop_reclaim(void *); 75 static int rump_vop_success(void *); 76 static int rump_vop_readdir(void *); 77 static int rump_vop_spec(void *); 78 static int rump_vop_read(void *); 79 static int rump_vop_write(void *); 80 static int rump_vop_open(void *); 81 static int rump_vop_symlink(void *); 82 static int rump_vop_readlink(void *); 83 static int rump_vop_whiteout(void *); 84 static int rump_vop_pathconf(void *); 85 static int rump_vop_bmap(void *); 86 static int rump_vop_strategy(void *); 87 static int rump_vop_advlock(void *); 88 static int rump_vop_access(void *); 89 static int rump_vop_fcntl(void *); 90 91 int (**fifo_vnodeop_p)(void *); 92 const struct vnodeopv_entry_desc fifo_vnodeop_entries[] = { 93 { &vop_default_desc, vn_default_error }, 94 { &vop_putpages_desc, genfs_null_putpages }, 95 { NULL, NULL } 96 }; 97 const struct vnodeopv_desc fifo_vnodeop_opv_desc = 98 { &fifo_vnodeop_p, fifo_vnodeop_entries }; 99 100 int (**rump_vnodeop_p)(void *); 101 const struct vnodeopv_entry_desc rump_vnodeop_entries[] = { 102 { &vop_default_desc, vn_default_error }, 103 { &vop_lookup_desc, rump_vop_lookup }, 104 { &vop_getattr_desc, rump_vop_getattr }, 105 { &vop_setattr_desc, rump_vop_setattr }, 106 { &vop_mkdir_desc, rump_vop_mkdir }, 107 { &vop_rmdir_desc, rump_vop_rmdir }, 108 { &vop_remove_desc, rump_vop_remove }, 109 { &vop_mknod_desc, rump_vop_mknod }, 110 { &vop_create_desc, rump_vop_create }, 111 { &vop_symlink_desc, rump_vop_symlink }, 112 { &vop_readlink_desc, rump_vop_readlink }, 113 { &vop_access_desc, rump_vop_access }, 114 { &vop_readdir_desc, rump_vop_readdir }, 115 { &vop_read_desc, rump_vop_read }, 116 { &vop_write_desc, rump_vop_write }, 117 { &vop_open_desc, rump_vop_open }, 118 { &vop_close_desc, genfs_nullop }, 119 { &vop_seek_desc, genfs_seek }, 120 { &vop_getpages_desc, genfs_getpages }, 121 { &vop_putpages_desc, genfs_putpages }, 122 { &vop_whiteout_desc, rump_vop_whiteout }, 123 { &vop_fsync_desc, rump_vop_success }, 124 { &vop_lock_desc, genfs_lock }, 125 { &vop_unlock_desc, genfs_unlock }, 126 { &vop_islocked_desc, genfs_islocked }, 127 { &vop_inactive_desc, rump_vop_inactive }, 128 { &vop_reclaim_desc, rump_vop_reclaim }, 129 { &vop_link_desc, genfs_eopnotsupp }, 130 { &vop_pathconf_desc, rump_vop_pathconf }, 131 { &vop_bmap_desc, rump_vop_bmap }, 132 { &vop_strategy_desc, rump_vop_strategy }, 133 { &vop_advlock_desc, rump_vop_advlock }, 134 { &vop_fcntl_desc, rump_vop_fcntl }, 135 { NULL, NULL } 136 }; 137 const struct vnodeopv_desc rump_vnodeop_opv_desc = 138 { &rump_vnodeop_p, rump_vnodeop_entries }; 139 140 int (**rump_specop_p)(void *); 141 const struct vnodeopv_entry_desc rump_specop_entries[] = { 142 { &vop_default_desc, rump_vop_spec }, 143 { NULL, NULL } 144 }; 145 const struct vnodeopv_desc rump_specop_opv_desc = 146 { &rump_specop_p, rump_specop_entries }; 147 148 const struct vnodeopv_desc * const rump_opv_descs[] = { 149 &rump_vnodeop_opv_desc, 150 &rump_specop_opv_desc, 151 NULL 152 }; 153 154 #define RUMPFS_WHITEOUT ((void *)-1) 155 #define RDENT_ISWHITEOUT(rdp) (rdp->rd_node == RUMPFS_WHITEOUT) 156 struct rumpfs_dent { 157 char *rd_name; 158 int rd_namelen; 159 struct rumpfs_node *rd_node; 160 161 LIST_ENTRY(rumpfs_dent) rd_entries; 162 }; 163 164 struct genfs_ops rumpfs_genfsops = { 165 .gop_size = genfs_size, 166 .gop_write = genfs_gop_write, 167 .gop_putrange = genfs_gop_putrange, 168 169 /* optional */ 170 .gop_alloc = NULL, 171 .gop_markupdate = NULL, 172 }; 173 174 struct rumpfs_node { 175 struct genfs_node rn_gn; 176 struct vattr rn_va; 177 struct vnode *rn_vp; 178 char *rn_hostpath; 179 int rn_flags; 180 struct lockf *rn_lockf; 181 182 union { 183 struct { /* VREG */ 184 int readfd; 185 int writefd; 186 uint64_t offset; 187 } reg; 188 struct { 189 void *data; 190 size_t dlen; 191 } reg_noet; 192 struct { /* VDIR */ 193 LIST_HEAD(, rumpfs_dent) dents; 194 struct rumpfs_node *parent; 195 int flags; 196 } dir; 197 struct { 198 char *target; 199 size_t len; 200 } link; 201 } rn_u; 202 }; 203 #define rn_readfd rn_u.reg.readfd 204 #define rn_writefd rn_u.reg.writefd 205 #define rn_offset rn_u.reg.offset 206 #define rn_data rn_u.reg_noet.data 207 #define rn_dlen rn_u.reg_noet.dlen 208 #define rn_dir rn_u.dir.dents 209 #define rn_parent rn_u.dir.parent 210 #define rn_linktarg rn_u.link.target 211 #define rn_linklen rn_u.link.len 212 213 #define RUMPNODE_CANRECLAIM 0x01 214 #define RUMPNODE_DIR_ET 0x02 215 #define RUMPNODE_DIR_ETSUBS 0x04 216 #define RUMPNODE_ET_PHONE_HOST 0x10 217 #define RUMPNODE_EXTSTORAGE 0x20 218 219 struct rumpfs_mount { 220 struct vnode *rfsmp_rvp; 221 }; 222 223 #define INO_WHITEOUT 1 224 static int lastino = 2; 225 static kmutex_t reclock; 226 227 #define RUMPFS_DEFAULTMODE 0755 228 static void freedir(struct rumpfs_node *, struct componentname *); 229 static struct rumpfs_node *makeprivate(enum vtype, mode_t, dev_t, off_t, bool); 230 static void freeprivate(struct rumpfs_node *); 231 232 /* 233 * Extra Terrestrial stuff. We map a given key (pathname) to a file on 234 * the host FS. ET phones home only from the root node of rumpfs. 235 * 236 * When an etfs node is removed, a vnode potentially behind it is not 237 * immediately recycled. 238 */ 239 240 struct etfs { 241 char et_key[MAXPATHLEN]; 242 size_t et_keylen; 243 bool et_prefixkey; 244 bool et_removing; 245 devminor_t et_blkmin; 246 247 LIST_ENTRY(etfs) et_entries; 248 249 struct rumpfs_node *et_rn; 250 }; 251 static kmutex_t etfs_lock; 252 static LIST_HEAD(, etfs) etfs_list = LIST_HEAD_INITIALIZER(etfs_list); 253 254 static enum vtype 255 ettype_to_vtype(enum rump_etfs_type et) 256 { 257 enum vtype vt; 258 259 switch (et) { 260 case RUMP_ETFS_REG: 261 vt = VREG; 262 break; 263 case RUMP_ETFS_BLK: 264 vt = VBLK; 265 break; 266 case RUMP_ETFS_CHR: 267 vt = VCHR; 268 break; 269 case RUMP_ETFS_DIR: 270 vt = VDIR; 271 break; 272 case RUMP_ETFS_DIR_SUBDIRS: 273 vt = VDIR; 274 break; 275 default: 276 panic("invalid et type: %d", et); 277 } 278 279 return vt; 280 } 281 282 static enum vtype 283 hft_to_vtype(int hft) 284 { 285 enum vtype vt; 286 287 switch (hft) { 288 case RUMPUSER_FT_OTHER: 289 vt = VNON; 290 break; 291 case RUMPUSER_FT_DIR: 292 vt = VDIR; 293 break; 294 case RUMPUSER_FT_REG: 295 vt = VREG; 296 break; 297 case RUMPUSER_FT_BLK: 298 vt = VBLK; 299 break; 300 case RUMPUSER_FT_CHR: 301 vt = VCHR; 302 break; 303 default: 304 vt = VNON; 305 break; 306 } 307 308 return vt; 309 } 310 311 static bool 312 etfs_find(const char *key, struct etfs **etp, bool forceprefix) 313 { 314 struct etfs *et; 315 size_t keylen = strlen(key); 316 317 KASSERT(mutex_owned(&etfs_lock)); 318 319 LIST_FOREACH(et, &etfs_list, et_entries) { 320 if ((keylen == et->et_keylen || et->et_prefixkey || forceprefix) 321 && strncmp(key, et->et_key, et->et_keylen) == 0) { 322 if (etp) 323 *etp = et; 324 return true; 325 } 326 } 327 328 return false; 329 } 330 331 #define REGDIR(ftype) \ 332 ((ftype) == RUMP_ETFS_DIR || (ftype) == RUMP_ETFS_DIR_SUBDIRS) 333 static int 334 etfsregister(const char *key, const char *hostpath, 335 enum rump_etfs_type ftype, uint64_t begin, uint64_t size) 336 { 337 char buf[9]; 338 struct etfs *et; 339 struct rumpfs_node *rn; 340 uint64_t fsize; 341 dev_t rdev = NODEV; 342 devminor_t dmin = -1; 343 int hft, error; 344 345 if (key[0] != '/') { 346 return EINVAL; 347 } 348 while (key[0] == '/') { 349 key++; 350 } 351 352 if ((error = rumpuser_getfileinfo(hostpath, &fsize, &hft)) != 0) 353 return error; 354 355 /* etfs directory requires a directory on the host */ 356 if (REGDIR(ftype)) { 357 if (hft != RUMPUSER_FT_DIR) 358 return ENOTDIR; 359 if (begin != 0) 360 return EISDIR; 361 if (size != RUMP_ETFS_SIZE_ENDOFF) 362 return EISDIR; 363 size = fsize; 364 } else { 365 if (begin > fsize) 366 return EINVAL; 367 if (size == RUMP_ETFS_SIZE_ENDOFF) 368 size = fsize - begin; 369 if (begin + size > fsize) 370 return EINVAL; 371 } 372 373 if (ftype == RUMP_ETFS_BLK || ftype == RUMP_ETFS_CHR) { 374 error = rumpblk_register(hostpath, &dmin, begin, size); 375 if (error != 0) { 376 return error; 377 } 378 rdev = makedev(RUMPBLK_DEVMAJOR, dmin); 379 } 380 381 et = kmem_alloc(sizeof(*et), KM_SLEEP); 382 strcpy(et->et_key, key); 383 et->et_keylen = strlen(et->et_key); 384 et->et_rn = rn = makeprivate(ettype_to_vtype(ftype), RUMPFS_DEFAULTMODE, 385 rdev, size, true); 386 et->et_removing = false; 387 et->et_blkmin = dmin; 388 389 rn->rn_flags |= RUMPNODE_ET_PHONE_HOST; 390 391 if (ftype == RUMP_ETFS_REG || REGDIR(ftype) || et->et_blkmin != -1) { 392 size_t len = strlen(hostpath)+1; 393 394 rn->rn_hostpath = malloc(len, M_TEMP, M_WAITOK | M_ZERO); 395 memcpy(rn->rn_hostpath, hostpath, len); 396 rn->rn_offset = begin; 397 } 398 399 if (REGDIR(ftype)) { 400 rn->rn_flags |= RUMPNODE_DIR_ET; 401 et->et_prefixkey = true; 402 } else { 403 et->et_prefixkey = false; 404 } 405 406 if (ftype == RUMP_ETFS_DIR_SUBDIRS) 407 rn->rn_flags |= RUMPNODE_DIR_ETSUBS; 408 409 mutex_enter(&etfs_lock); 410 if (etfs_find(key, NULL, REGDIR(ftype))) { 411 mutex_exit(&etfs_lock); 412 if (et->et_blkmin != -1) 413 rumpblk_deregister(hostpath); 414 if (et->et_rn->rn_hostpath != NULL) 415 free(et->et_rn->rn_hostpath, M_TEMP); 416 freeprivate(et->et_rn); 417 kmem_free(et, sizeof(*et)); 418 return EEXIST; 419 } 420 LIST_INSERT_HEAD(&etfs_list, et, et_entries); 421 mutex_exit(&etfs_lock); 422 423 if (ftype == RUMP_ETFS_BLK) { 424 format_bytes(buf, sizeof(buf), size); 425 aprint_verbose("/%s: hostpath %s (%s)\n", key, hostpath, buf); 426 } 427 428 return 0; 429 } 430 #undef REGDIR 431 432 /* remove etfs mapping. caller's responsibility to make sure it's not in use */ 433 static int 434 etfsremove(const char *key) 435 { 436 struct etfs *et; 437 size_t keylen; 438 int rv __diagused; 439 440 if (key[0] != '/') { 441 return EINVAL; 442 } 443 while (key[0] == '/') { 444 key++; 445 } 446 447 keylen = strlen(key); 448 449 mutex_enter(&etfs_lock); 450 LIST_FOREACH(et, &etfs_list, et_entries) { 451 if (keylen == et->et_keylen && strcmp(et->et_key, key) == 0) { 452 if (et->et_removing) 453 et = NULL; 454 else 455 et->et_removing = true; 456 break; 457 } 458 } 459 mutex_exit(&etfs_lock); 460 if (!et) 461 return ENOENT; 462 463 /* 464 * ok, we know what we want to remove and have signalled there 465 * actually are men at work. first, unregister from rumpblk 466 */ 467 if (et->et_blkmin != -1) { 468 rv = rumpblk_deregister(et->et_rn->rn_hostpath); 469 } else { 470 rv = 0; 471 } 472 KASSERT(rv == 0); 473 474 /* then do the actual removal */ 475 mutex_enter(&etfs_lock); 476 LIST_REMOVE(et, et_entries); 477 mutex_exit(&etfs_lock); 478 479 /* node is unreachable, safe to nuke all device copies */ 480 if (et->et_blkmin != -1) { 481 vdevgone(RUMPBLK_DEVMAJOR, et->et_blkmin, et->et_blkmin, VBLK); 482 } else { 483 struct vnode *vp; 484 struct mount *mp; 485 struct rumpfs_node *rn; 486 487 mutex_enter(&reclock); 488 if ((vp = et->et_rn->rn_vp) != NULL) { 489 mp = vp->v_mount; 490 rn = vp->v_data; 491 KASSERT(rn == et->et_rn); 492 } else { 493 mp = NULL; 494 } 495 mutex_exit(&reclock); 496 if (mp && vcache_get(mp, &rn, sizeof(rn), &vp) == 0) { 497 rv = vfs_suspend(mp, 0); 498 KASSERT(rv == 0); 499 vgone(vp); 500 vfs_resume(mp); 501 } 502 } 503 504 if (et->et_rn->rn_hostpath != NULL) 505 free(et->et_rn->rn_hostpath, M_TEMP); 506 freeprivate(et->et_rn); 507 kmem_free(et, sizeof(*et)); 508 509 return 0; 510 } 511 512 /* 513 * rumpfs 514 */ 515 516 static struct rumpfs_node * 517 makeprivate(enum vtype vt, mode_t mode, dev_t rdev, off_t size, bool et) 518 { 519 struct rumpfs_node *rn; 520 struct vattr *va; 521 struct timespec ts; 522 523 KASSERT((mode & ~ALLPERMS) == 0); 524 rn = kmem_zalloc(sizeof(*rn), KM_SLEEP); 525 526 switch (vt) { 527 case VDIR: 528 LIST_INIT(&rn->rn_dir); 529 break; 530 case VREG: 531 if (et) { 532 rn->rn_readfd = -1; 533 rn->rn_writefd = -1; 534 } 535 break; 536 default: 537 break; 538 } 539 540 nanotime(&ts); 541 542 va = &rn->rn_va; 543 va->va_type = vt; 544 va->va_mode = mode; 545 if (vt == VDIR) 546 va->va_nlink = 2; 547 else 548 va->va_nlink = 1; 549 va->va_uid = 0; 550 va->va_gid = 0; 551 va->va_fsid = 552 va->va_fileid = atomic_inc_uint_nv(&lastino); 553 va->va_size = size; 554 va->va_blocksize = 512; 555 va->va_atime = ts; 556 va->va_mtime = ts; 557 va->va_ctime = ts; 558 va->va_birthtime = ts; 559 va->va_gen = 0; 560 va->va_flags = 0; 561 va->va_rdev = rdev; 562 va->va_bytes = 512; 563 va->va_filerev = 0; 564 va->va_vaflags = 0; 565 566 return rn; 567 } 568 569 static void 570 freeprivate(struct rumpfs_node *rn) 571 { 572 573 kmem_free(rn, sizeof(*rn)); 574 } 575 576 static void 577 makedir(struct rumpfs_node *rnd, 578 struct componentname *cnp, struct rumpfs_node *rn) 579 { 580 struct rumpfs_dent *rdent; 581 582 rdent = kmem_alloc(sizeof(*rdent), KM_SLEEP); 583 rdent->rd_name = kmem_alloc(cnp->cn_namelen+1, KM_SLEEP); 584 rdent->rd_node = rn; 585 strlcpy(rdent->rd_name, cnp->cn_nameptr, cnp->cn_namelen+1); 586 rdent->rd_namelen = strlen(rdent->rd_name); 587 588 if ((cnp->cn_flags & ISWHITEOUT) != 0) { 589 KASSERT((cnp->cn_flags & DOWHITEOUT) == 0); 590 freedir(rnd, cnp); 591 } 592 LIST_INSERT_HEAD(&rnd->rn_dir, rdent, rd_entries); 593 } 594 595 static void 596 freedir(struct rumpfs_node *rnd, struct componentname *cnp) 597 { 598 struct rumpfs_dent *rd = NULL; 599 600 LIST_FOREACH(rd, &rnd->rn_dir, rd_entries) { 601 if (rd->rd_namelen == cnp->cn_namelen && 602 strncmp(rd->rd_name, cnp->cn_nameptr, 603 cnp->cn_namelen) == 0) 604 break; 605 } 606 if (rd == NULL) 607 panic("could not find directory entry: %s", cnp->cn_nameptr); 608 609 if (cnp->cn_flags & DOWHITEOUT) { 610 rd->rd_node = RUMPFS_WHITEOUT; 611 } else { 612 LIST_REMOVE(rd, rd_entries); 613 kmem_free(rd->rd_name, rd->rd_namelen+1); 614 kmem_free(rd, sizeof(*rd)); 615 } 616 } 617 618 #define RUMPFS_ACCESS 1 619 #define RUMPFS_MODIFY 2 620 #define RUMPFS_CHANGE 4 621 622 static int 623 rumpfs_update(int flags, struct vnode *vp, const struct timespec *acc, 624 const struct timespec *mod, const struct timespec *chg) 625 { 626 struct rumpfs_node *rn = vp->v_data; 627 628 if (flags == 0) 629 return 0; 630 631 if (vp->v_mount->mnt_flag & MNT_RDONLY) 632 return EROFS; 633 634 if (flags & RUMPFS_ACCESS) 635 rn->rn_va.va_atime = *acc; 636 if (flags & RUMPFS_MODIFY) 637 rn->rn_va.va_mtime = *mod; 638 if (flags & RUMPFS_CHANGE) 639 rn->rn_va.va_ctime = *chg; 640 641 return 0; 642 } 643 644 /* 645 * Simple lookup for rump file systems. 646 * 647 * uhm, this is twisted. C F C C, hope of C C F C looming 648 */ 649 static int 650 rump_vop_lookup(void *v) 651 { 652 struct vop_lookup_v2_args /* { 653 struct vnode *a_dvp; 654 struct vnode **a_vpp; 655 struct componentname *a_cnp; 656 }; */ *ap = v; 657 struct componentname *cnp = ap->a_cnp; 658 struct vnode *dvp = ap->a_dvp; 659 struct vnode **vpp = ap->a_vpp; 660 struct rumpfs_node *rnd = dvp->v_data, *rn; 661 struct rumpfs_dent *rd = NULL; 662 struct etfs *et; 663 bool dotdot = (cnp->cn_flags & ISDOTDOT) != 0; 664 int rv = 0; 665 const char *cp; 666 667 *vpp = NULL; 668 669 rv = VOP_ACCESS(dvp, VEXEC, cnp->cn_cred); 670 if (rv) 671 return rv; 672 673 if ((cnp->cn_flags & ISLASTCN) 674 && (dvp->v_mount->mnt_flag & MNT_RDONLY) 675 && (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)) 676 return EROFS; 677 678 /* check for dot, return directly if the case */ 679 if (cnp->cn_namelen == 1 && cnp->cn_nameptr[0] == '.') { 680 vref(dvp); 681 *vpp = dvp; 682 return 0; 683 } 684 685 /* we don't do rename */ 686 if (!(((cnp->cn_flags & ISLASTCN) == 0) || (cnp->cn_nameiop != RENAME))) 687 return EOPNOTSUPP; 688 689 /* check for etfs */ 690 if (dvp == rootvnode && 691 (cnp->cn_nameiop == LOOKUP || cnp->cn_nameiop == CREATE)) { 692 bool found; 693 mutex_enter(&etfs_lock); 694 found = etfs_find(cnp->cn_nameptr, &et, false); 695 mutex_exit(&etfs_lock); 696 697 if (found) { 698 rn = et->et_rn; 699 cnp->cn_consume += et->et_keylen - cnp->cn_namelen; 700 /* 701 * consume trailing slashes if any and clear 702 * REQUIREDIR if we consumed the full path. 703 */ 704 cp = &cnp->cn_nameptr[cnp->cn_namelen]; 705 cp += cnp->cn_consume; 706 KASSERT(*cp == '\0' || *cp == '/'); 707 if (*cp == '\0' && rn->rn_va.va_type != VDIR) 708 cnp->cn_flags &= ~REQUIREDIR; 709 while (*cp++ == '/') 710 cnp->cn_consume++; 711 goto getvnode; 712 } 713 } 714 715 if (rnd->rn_flags & RUMPNODE_DIR_ET) { 716 uint64_t fsize; 717 char *newpath; 718 size_t newpathlen; 719 int hft, error; 720 721 if (dotdot) 722 return EOPNOTSUPP; 723 724 newpathlen = strlen(rnd->rn_hostpath) + 1 + cnp->cn_namelen + 1; 725 newpath = malloc(newpathlen, M_TEMP, M_WAITOK); 726 727 strlcpy(newpath, rnd->rn_hostpath, newpathlen); 728 strlcat(newpath, "/", newpathlen); 729 strlcat(newpath, cnp->cn_nameptr, newpathlen); 730 731 if ((error = rumpuser_getfileinfo(newpath, &fsize, &hft)) != 0){ 732 free(newpath, M_TEMP); 733 return error; 734 } 735 736 /* allow only dirs and regular files */ 737 if (hft != RUMPUSER_FT_REG && hft != RUMPUSER_FT_DIR) { 738 free(newpath, M_TEMP); 739 return ENOENT; 740 } 741 742 rn = makeprivate(hft_to_vtype(hft), RUMPFS_DEFAULTMODE, 743 NODEV, fsize, true); 744 rn->rn_flags |= RUMPNODE_CANRECLAIM; 745 if (rnd->rn_flags & RUMPNODE_DIR_ETSUBS) { 746 rn->rn_flags |= RUMPNODE_DIR_ET | RUMPNODE_DIR_ETSUBS; 747 rn->rn_flags |= RUMPNODE_ET_PHONE_HOST; 748 } 749 rn->rn_hostpath = newpath; 750 751 goto getvnode; 752 } else { 753 if (dotdot) { 754 if ((rn = rnd->rn_parent) != NULL) 755 goto getvnode; 756 } else { 757 LIST_FOREACH(rd, &rnd->rn_dir, rd_entries) { 758 if (rd->rd_namelen == cnp->cn_namelen && 759 strncmp(rd->rd_name, cnp->cn_nameptr, 760 cnp->cn_namelen) == 0) 761 break; 762 } 763 } 764 } 765 766 if (!rd && ((cnp->cn_flags & ISLASTCN) == 0||cnp->cn_nameiop != CREATE)) 767 return ENOENT; 768 769 if (!rd && (cnp->cn_flags & ISLASTCN) && cnp->cn_nameiop == CREATE) { 770 if (dvp->v_mount->mnt_flag & MNT_RDONLY) 771 return EROFS; 772 rv = VOP_ACCESS(dvp, VWRITE, cnp->cn_cred); 773 if (rv) 774 return rv; 775 return EJUSTRETURN; 776 } 777 778 if ((cnp->cn_flags & ISLASTCN) && cnp->cn_nameiop == DELETE) { 779 rv = VOP_ACCESS(dvp, VWRITE, cnp->cn_cred); 780 if (rv) 781 return rv; 782 } 783 784 if (RDENT_ISWHITEOUT(rd)) { 785 cnp->cn_flags |= ISWHITEOUT; 786 if ((cnp->cn_flags & ISLASTCN) && cnp->cn_nameiop == CREATE) 787 return EJUSTRETURN; 788 return ENOENT; 789 } 790 791 rn = rd->rd_node; 792 793 getvnode: 794 KASSERT(rn); 795 rv = vcache_get(dvp->v_mount, &rn, sizeof(rn), vpp); 796 if (rv) { 797 if (rnd->rn_flags & RUMPNODE_DIR_ET) 798 freeprivate(rn); 799 return rv; 800 } 801 802 return 0; 803 } 804 805 static int 806 rump_check_possible(struct vnode *vp, struct rumpfs_node *rnode, 807 mode_t mode) 808 { 809 810 if ((mode & VWRITE) == 0) 811 return 0; 812 813 switch (vp->v_type) { 814 case VDIR: 815 case VLNK: 816 case VREG: 817 break; 818 default: 819 /* special file is always writable. */ 820 return 0; 821 } 822 823 return vp->v_mount->mnt_flag & MNT_RDONLY ? EROFS : 0; 824 } 825 826 static int 827 rump_check_permitted(struct vnode *vp, struct rumpfs_node *rnode, 828 mode_t mode, kauth_cred_t cred) 829 { 830 struct vattr *attr = &rnode->rn_va; 831 832 return kauth_authorize_vnode(cred, KAUTH_ACCESS_ACTION(mode, 833 vp->v_type, attr->va_mode), vp, NULL, genfs_can_access(vp->v_type, 834 attr->va_mode, attr->va_uid, attr->va_gid, mode, cred)); 835 } 836 837 int 838 rump_vop_access(void *v) 839 { 840 struct vop_access_args /* { 841 const struct vnodeop_desc *a_desc; 842 struct vnode *a_vp; 843 int a_mode; 844 kauth_cred_t a_cred; 845 } */ *ap = v; 846 struct vnode *vp = ap->a_vp; 847 struct rumpfs_node *rn = vp->v_data; 848 int error; 849 850 error = rump_check_possible(vp, rn, ap->a_mode); 851 if (error) 852 return error; 853 854 error = rump_check_permitted(vp, rn, ap->a_mode, ap->a_cred); 855 856 return error; 857 } 858 859 static int 860 rump_vop_getattr(void *v) 861 { 862 struct vop_getattr_args /* { 863 struct vnode *a_vp; 864 struct vattr *a_vap; 865 kauth_cred_t a_cred; 866 } */ *ap = v; 867 struct vnode *vp = ap->a_vp; 868 struct rumpfs_node *rn = vp->v_data; 869 struct vattr *vap = ap->a_vap; 870 871 memcpy(vap, &rn->rn_va, sizeof(struct vattr)); 872 vap->va_size = vp->v_size; 873 return 0; 874 } 875 876 static int 877 rump_vop_setattr(void *v) 878 { 879 struct vop_setattr_args /* { 880 struct vnode *a_vp; 881 struct vattr *a_vap; 882 kauth_cred_t a_cred; 883 } */ *ap = v; 884 struct vnode *vp = ap->a_vp; 885 struct vattr *vap = ap->a_vap; 886 struct rumpfs_node *rn = vp->v_data; 887 struct vattr *attr = &rn->rn_va; 888 struct timespec now; 889 kauth_cred_t cred = ap->a_cred; 890 int error; 891 892 #define CHANGED(a, t) (vap->a != (t)VNOVAL) 893 #define SETIFVAL(a,t) if (CHANGED(a, t)) rn->rn_va.a = vap->a 894 if (CHANGED(va_atime.tv_sec, time_t) || 895 CHANGED(va_ctime.tv_sec, time_t) || 896 CHANGED(va_mtime.tv_sec, time_t) || 897 CHANGED(va_birthtime.tv_sec, time_t) || 898 CHANGED(va_atime.tv_nsec, long) || 899 CHANGED(va_ctime.tv_nsec, long) || 900 CHANGED(va_mtime.tv_nsec, long) || 901 CHANGED(va_birthtime.tv_nsec, long)) { 902 error = kauth_authorize_vnode(cred, KAUTH_VNODE_WRITE_TIMES, vp, 903 NULL, genfs_can_chtimes(vp, vap->va_vaflags, attr->va_uid, 904 cred)); 905 if (error) 906 return error; 907 } 908 909 int flags = 0; 910 getnanotime(&now); 911 if (vap->va_atime.tv_sec != VNOVAL) 912 if (!(vp->v_mount->mnt_flag & MNT_NOATIME)) 913 flags |= RUMPFS_ACCESS; 914 if (vap->va_mtime.tv_sec != VNOVAL) { 915 flags |= RUMPFS_CHANGE | RUMPFS_MODIFY; 916 if (vp->v_mount->mnt_flag & MNT_RELATIME) 917 flags |= RUMPFS_ACCESS; 918 } else if (vap->va_size == 0) { 919 flags |= RUMPFS_MODIFY; 920 vap->va_mtime = now; 921 } 922 SETIFVAL(va_birthtime.tv_sec, time_t); 923 SETIFVAL(va_birthtime.tv_nsec, long); 924 flags |= RUMPFS_CHANGE; 925 error = rumpfs_update(flags, vp, &vap->va_atime, &vap->va_mtime, &now); 926 if (error) 927 return error; 928 929 if (CHANGED(va_flags, u_long)) { 930 /* XXX Can we handle system flags here...? */ 931 error = kauth_authorize_vnode(cred, KAUTH_VNODE_WRITE_FLAGS, vp, 932 NULL, genfs_can_chflags(cred, vp->v_type, attr->va_uid, 933 false)); 934 if (error) 935 return error; 936 } 937 938 SETIFVAL(va_flags, u_long); 939 #undef SETIFVAL 940 #undef CHANGED 941 942 if (vap->va_uid != (uid_t)VNOVAL || vap->va_gid != (uid_t)VNOVAL) { 943 uid_t uid = 944 (vap->va_uid != (uid_t)VNOVAL) ? vap->va_uid : attr->va_uid; 945 gid_t gid = 946 (vap->va_gid != (gid_t)VNOVAL) ? vap->va_gid : attr->va_gid; 947 error = kauth_authorize_vnode(cred, 948 KAUTH_VNODE_CHANGE_OWNERSHIP, vp, NULL, 949 genfs_can_chown(cred, attr->va_uid, attr->va_gid, uid, 950 gid)); 951 if (error) 952 return error; 953 attr->va_uid = uid; 954 attr->va_gid = gid; 955 } 956 957 if (vap->va_mode != (mode_t)VNOVAL) { 958 mode_t mode = vap->va_mode; 959 error = kauth_authorize_vnode(cred, KAUTH_VNODE_WRITE_SECURITY, 960 vp, NULL, genfs_can_chmod(vp->v_type, cred, attr->va_uid, 961 attr->va_gid, mode)); 962 if (error) 963 return error; 964 attr->va_mode = mode; 965 } 966 967 if (vp->v_type == VREG && 968 vap->va_size != VSIZENOTSET && 969 vap->va_size != rn->rn_dlen && 970 (rn->rn_flags & RUMPNODE_ET_PHONE_HOST) == 0) { 971 void *newdata; 972 size_t copylen, newlen; 973 974 newlen = vap->va_size; 975 newdata = rump_hypermalloc(newlen, 0, false, "rumpfs"); 976 if (newdata == NULL) 977 return ENOSPC; 978 979 copylen = MIN(rn->rn_dlen, newlen); 980 if (copylen > 0) 981 memcpy(newdata, rn->rn_data, copylen); 982 memset((char *)newdata + copylen, 0, newlen - copylen); 983 984 if ((rn->rn_flags & RUMPNODE_EXTSTORAGE) == 0) { 985 rump_hyperfree(rn->rn_data, rn->rn_dlen); 986 } else { 987 rn->rn_flags &= ~RUMPNODE_EXTSTORAGE; 988 } 989 990 rn->rn_data = newdata; 991 rn->rn_dlen = newlen; 992 uvm_vnp_setsize(vp, newlen); 993 } 994 return 0; 995 } 996 997 static int 998 rump_vop_mkdir(void *v) 999 { 1000 struct vop_mkdir_v3_args /* { 1001 struct vnode *a_dvp; 1002 struct vnode **a_vpp; 1003 struct componentname *a_cnp; 1004 struct vattr *a_vap; 1005 }; */ *ap = v; 1006 struct vnode *dvp = ap->a_dvp; 1007 struct vnode **vpp = ap->a_vpp; 1008 struct componentname *cnp = ap->a_cnp; 1009 struct vattr *va = ap->a_vap; 1010 struct rumpfs_node *rnd = dvp->v_data, *rn; 1011 int rv = 0; 1012 1013 rn = makeprivate(VDIR, va->va_mode & ALLPERMS, NODEV, DEV_BSIZE, false); 1014 if ((cnp->cn_flags & ISWHITEOUT) != 0) 1015 rn->rn_va.va_flags |= UF_OPAQUE; 1016 rn->rn_parent = rnd; 1017 rv = vcache_get(dvp->v_mount, &rn, sizeof(rn), vpp); 1018 if (rv) { 1019 freeprivate(rn); 1020 return rv; 1021 } 1022 1023 makedir(rnd, cnp, rn); 1024 1025 return rv; 1026 } 1027 1028 static int 1029 rump_vop_rmdir(void *v) 1030 { 1031 struct vop_rmdir_v2_args /* { 1032 struct vnode *a_dvp; 1033 struct vnode *a_vp; 1034 struct componentname *a_cnp; 1035 }; */ *ap = v; 1036 struct vnode *dvp = ap->a_dvp; 1037 struct vnode *vp = ap->a_vp; 1038 struct componentname *cnp = ap->a_cnp; 1039 struct rumpfs_node *rnd = dvp->v_data; 1040 struct rumpfs_node *rn = vp->v_data; 1041 struct rumpfs_dent *rd; 1042 int rv = 0; 1043 1044 LIST_FOREACH(rd, &rn->rn_dir, rd_entries) { 1045 if (rd->rd_node != RUMPFS_WHITEOUT) { 1046 rv = ENOTEMPTY; 1047 goto out; 1048 } 1049 } 1050 while ((rd = LIST_FIRST(&rn->rn_dir)) != NULL) { 1051 KASSERT(rd->rd_node == RUMPFS_WHITEOUT); 1052 LIST_REMOVE(rd, rd_entries); 1053 kmem_free(rd->rd_name, rd->rd_namelen+1); 1054 kmem_free(rd, sizeof(*rd)); 1055 } 1056 1057 freedir(rnd, cnp); 1058 rn->rn_flags |= RUMPNODE_CANRECLAIM; 1059 rn->rn_parent = NULL; 1060 rn->rn_va.va_nlink = 0; 1061 1062 out: 1063 vput(vp); 1064 return rv; 1065 } 1066 1067 static int 1068 rump_vop_remove(void *v) 1069 { 1070 struct vop_remove_v2_args /* { 1071 struct vnode *a_dvp; 1072 struct vnode *a_vp; 1073 struct componentname *a_cnp; 1074 }; */ *ap = v; 1075 struct vnode *dvp = ap->a_dvp; 1076 struct vnode *vp = ap->a_vp; 1077 struct componentname *cnp = ap->a_cnp; 1078 struct rumpfs_node *rnd = dvp->v_data; 1079 struct rumpfs_node *rn = vp->v_data; 1080 int rv = 0; 1081 1082 if (rn->rn_flags & RUMPNODE_ET_PHONE_HOST) 1083 return EOPNOTSUPP; 1084 1085 freedir(rnd, cnp); 1086 rn->rn_flags |= RUMPNODE_CANRECLAIM; 1087 rn->rn_va.va_nlink = 0; 1088 1089 vput(vp); 1090 return rv; 1091 } 1092 1093 static int 1094 rump_vop_mknod(void *v) 1095 { 1096 struct vop_mknod_v3_args /* { 1097 struct vnode *a_dvp; 1098 struct vnode **a_vpp; 1099 struct componentname *a_cnp; 1100 struct vattr *a_vap; 1101 }; */ *ap = v; 1102 struct vnode *dvp = ap->a_dvp; 1103 struct vnode **vpp = ap->a_vpp; 1104 struct componentname *cnp = ap->a_cnp; 1105 struct vattr *va = ap->a_vap; 1106 struct rumpfs_node *rnd = dvp->v_data, *rn; 1107 int rv; 1108 1109 rn = makeprivate(va->va_type, va->va_mode & ALLPERMS, va->va_rdev, 1110 DEV_BSIZE, false); 1111 if ((cnp->cn_flags & ISWHITEOUT) != 0) 1112 rn->rn_va.va_flags |= UF_OPAQUE; 1113 rv = vcache_get(dvp->v_mount, &rn, sizeof(rn), vpp); 1114 if (rv) { 1115 freeprivate(rn); 1116 return rv; 1117 } 1118 1119 makedir(rnd, cnp, rn); 1120 1121 return rv; 1122 } 1123 1124 static int 1125 rump_vop_create(void *v) 1126 { 1127 struct vop_create_v3_args /* { 1128 struct vnode *a_dvp; 1129 struct vnode **a_vpp; 1130 struct componentname *a_cnp; 1131 struct vattr *a_vap; 1132 }; */ *ap = v; 1133 struct vnode *dvp = ap->a_dvp; 1134 struct vnode **vpp = ap->a_vpp; 1135 struct componentname *cnp = ap->a_cnp; 1136 struct vattr *va = ap->a_vap; 1137 struct rumpfs_node *rnd = dvp->v_data, *rn; 1138 off_t newsize; 1139 int rv; 1140 1141 newsize = va->va_type == VSOCK ? DEV_BSIZE : 0; 1142 rn = makeprivate(va->va_type, va->va_mode & ALLPERMS, NODEV, 1143 newsize, false); 1144 if ((cnp->cn_flags & ISWHITEOUT) != 0) 1145 rn->rn_va.va_flags |= UF_OPAQUE; 1146 rv = vcache_get(dvp->v_mount, &rn, sizeof(rn), vpp); 1147 if (rv) { 1148 freeprivate(rn); 1149 return rv; 1150 } 1151 1152 makedir(rnd, cnp, rn); 1153 1154 return rv; 1155 } 1156 1157 static int 1158 rump_vop_symlink(void *v) 1159 { 1160 struct vop_symlink_v3_args /* { 1161 struct vnode *a_dvp; 1162 struct vnode **a_vpp; 1163 struct componentname *a_cnp; 1164 struct vattr *a_vap; 1165 char *a_target; 1166 }; */ *ap = v; 1167 struct vnode *dvp = ap->a_dvp; 1168 struct vnode **vpp = ap->a_vpp; 1169 struct componentname *cnp = ap->a_cnp; 1170 struct vattr *va = ap->a_vap; 1171 struct rumpfs_node *rnd = dvp->v_data, *rn; 1172 const char *target = ap->a_target; 1173 size_t linklen; 1174 int rv; 1175 1176 linklen = strlen(target); 1177 KASSERT(linklen < MAXPATHLEN); 1178 rn = makeprivate(VLNK, va->va_mode & ALLPERMS, NODEV, linklen, false); 1179 if ((cnp->cn_flags & ISWHITEOUT) != 0) 1180 rn->rn_va.va_flags |= UF_OPAQUE; 1181 rv = vcache_get(dvp->v_mount, &rn, sizeof(rn), vpp); 1182 if (rv) { 1183 freeprivate(rn); 1184 return rv; 1185 } 1186 1187 makedir(rnd, cnp, rn); 1188 1189 KASSERT(linklen < MAXPATHLEN); 1190 rn->rn_linktarg = PNBUF_GET(); 1191 rn->rn_linklen = linklen; 1192 strcpy(rn->rn_linktarg, target); 1193 1194 return rv; 1195 } 1196 1197 static int 1198 rump_vop_readlink(void *v) 1199 { 1200 struct vop_readlink_args /* { 1201 struct vnode *a_vp; 1202 struct uio *a_uio; 1203 kauth_cred_t a_cred; 1204 }; */ *ap = v; 1205 struct vnode *vp = ap->a_vp; 1206 struct rumpfs_node *rn = vp->v_data; 1207 struct uio *uio = ap->a_uio; 1208 1209 return uiomove(rn->rn_linktarg, rn->rn_linklen, uio); 1210 } 1211 1212 static int 1213 rump_vop_whiteout(void *v) 1214 { 1215 struct vop_whiteout_args /* { 1216 struct vnode *a_dvp; 1217 struct componentname *a_cnp; 1218 int a_flags; 1219 } */ *ap = v; 1220 struct vnode *dvp = ap->a_dvp; 1221 struct rumpfs_node *rnd = dvp->v_data; 1222 struct componentname *cnp = ap->a_cnp; 1223 int flags = ap->a_flags; 1224 1225 switch (flags) { 1226 case LOOKUP: 1227 break; 1228 case CREATE: 1229 makedir(rnd, cnp, RUMPFS_WHITEOUT); 1230 break; 1231 case DELETE: 1232 cnp->cn_flags &= ~DOWHITEOUT; /* cargo culting never fails ? */ 1233 freedir(rnd, cnp); 1234 break; 1235 default: 1236 panic("unknown whiteout op %d", flags); 1237 } 1238 1239 return 0; 1240 } 1241 1242 static int 1243 rump_vop_open(void *v) 1244 { 1245 struct vop_open_args /* { 1246 struct vnode *a_vp; 1247 int a_mode; 1248 kauth_cred_t a_cred; 1249 } */ *ap = v; 1250 struct vnode *vp = ap->a_vp; 1251 struct rumpfs_node *rn = vp->v_data; 1252 int mode = ap->a_mode; 1253 int error = EINVAL; 1254 1255 if (vp->v_type != VREG || (rn->rn_flags & RUMPNODE_ET_PHONE_HOST) == 0) 1256 return 0; 1257 1258 if (mode & FREAD) { 1259 if (rn->rn_readfd != -1) 1260 return 0; 1261 error = rumpuser_open(rn->rn_hostpath, 1262 RUMPUSER_OPEN_RDONLY, &rn->rn_readfd); 1263 } 1264 1265 if (mode & FWRITE) { 1266 if (rn->rn_writefd != -1) 1267 return 0; 1268 error = rumpuser_open(rn->rn_hostpath, 1269 RUMPUSER_OPEN_WRONLY, &rn->rn_writefd); 1270 } 1271 1272 return error; 1273 } 1274 1275 /* simple readdir. even omits dotstuff and periods */ 1276 static int 1277 rump_vop_readdir(void *v) 1278 { 1279 struct vop_readdir_args /* { 1280 struct vnode *a_vp; 1281 struct uio *a_uio; 1282 kauth_cred_t a_cred; 1283 int *a_eofflag; 1284 off_t **a_cookies; 1285 int *a_ncookies; 1286 } */ *ap = v; 1287 struct vnode *vp = ap->a_vp; 1288 struct uio *uio = ap->a_uio; 1289 struct rumpfs_node *rnd = vp->v_data; 1290 struct rumpfs_dent *rdent; 1291 struct dirent *dentp = NULL; 1292 unsigned i; 1293 int rv = 0; 1294 1295 /* seek to current entry */ 1296 for (i = 0, rdent = LIST_FIRST(&rnd->rn_dir); 1297 (i < uio->uio_offset) && rdent; 1298 i++, rdent = LIST_NEXT(rdent, rd_entries)) 1299 continue; 1300 if (!rdent) 1301 goto out; 1302 1303 /* copy entries */ 1304 dentp = kmem_alloc(sizeof(*dentp), KM_SLEEP); 1305 for (; rdent && uio->uio_resid > 0; 1306 rdent = LIST_NEXT(rdent, rd_entries), i++) { 1307 strlcpy(dentp->d_name, rdent->rd_name, sizeof(dentp->d_name)); 1308 dentp->d_namlen = strlen(dentp->d_name); 1309 dentp->d_reclen = _DIRENT_RECLEN(dentp, dentp->d_namlen); 1310 1311 if (__predict_false(RDENT_ISWHITEOUT(rdent))) { 1312 dentp->d_fileno = INO_WHITEOUT; 1313 dentp->d_type = DT_WHT; 1314 } else { 1315 dentp->d_fileno = rdent->rd_node->rn_va.va_fileid; 1316 dentp->d_type = vtype2dt(rdent->rd_node->rn_va.va_type); 1317 } 1318 1319 if (uio->uio_resid < dentp->d_reclen) { 1320 i--; 1321 break; 1322 } 1323 1324 rv = uiomove(dentp, dentp->d_reclen, uio); 1325 if (rv) { 1326 i--; 1327 break; 1328 } 1329 } 1330 kmem_free(dentp, sizeof(*dentp)); 1331 dentp = NULL; 1332 1333 out: 1334 KASSERT(dentp == NULL); 1335 if (ap->a_cookies) { 1336 *ap->a_ncookies = 0; 1337 *ap->a_cookies = NULL; 1338 } 1339 if (rdent) 1340 *ap->a_eofflag = 0; 1341 else 1342 *ap->a_eofflag = 1; 1343 uio->uio_offset = i; 1344 1345 return rv; 1346 } 1347 1348 static int 1349 etread(struct rumpfs_node *rn, struct uio *uio) 1350 { 1351 struct rumpuser_iovec iov; 1352 uint8_t *buf; 1353 size_t bufsize, n; 1354 int error = 0; 1355 1356 bufsize = uio->uio_resid; 1357 if (bufsize == 0) 1358 return 0; 1359 buf = kmem_alloc(bufsize, KM_SLEEP); 1360 1361 iov.iov_base = buf; 1362 iov.iov_len = bufsize; 1363 if ((error = rumpuser_iovread(rn->rn_readfd, &iov, 1, 1364 uio->uio_offset + rn->rn_offset, &n)) == 0) { 1365 KASSERT(n <= bufsize); 1366 error = uiomove(buf, n, uio); 1367 } 1368 1369 kmem_free(buf, bufsize); 1370 return error; 1371 } 1372 1373 static int 1374 rump_vop_read(void *v) 1375 { 1376 struct vop_read_args /* { 1377 struct vnode *a_vp; 1378 struct uio *a_uio; 1379 int ioflags a_ioflag; 1380 kauth_cred_t a_cred; 1381 }; */ *ap = v; 1382 struct vnode *vp = ap->a_vp; 1383 struct rumpfs_node *rn = vp->v_data; 1384 struct uio *uio = ap->a_uio; 1385 const int advice = IO_ADV_DECODE(ap->a_ioflag); 1386 off_t chunk; 1387 int error = 0; 1388 struct timespec ts; 1389 1390 if (vp->v_type == VDIR) 1391 return EISDIR; 1392 1393 /* et op? */ 1394 if (rn->rn_flags & RUMPNODE_ET_PHONE_HOST) 1395 return etread(rn, uio); 1396 1397 getnanotime(&ts); 1398 (void)rumpfs_update(RUMPFS_ACCESS, vp, &ts, &ts, &ts); 1399 1400 /* otherwise, it's off to ubc with us */ 1401 while (uio->uio_resid > 0) { 1402 chunk = MIN(uio->uio_resid, (off_t)rn->rn_dlen-uio->uio_offset); 1403 if (chunk == 0) 1404 break; 1405 error = ubc_uiomove(&vp->v_uobj, uio, chunk, advice, 1406 UBC_READ | UBC_PARTIALOK | UBC_UNMAP_FLAG(vp)); 1407 if (error) 1408 break; 1409 } 1410 1411 return error; 1412 } 1413 1414 static int 1415 etwrite(struct rumpfs_node *rn, struct uio *uio) 1416 { 1417 struct rumpuser_iovec iov; 1418 uint8_t *buf; 1419 size_t bufsize, n; 1420 int error = 0; 1421 1422 bufsize = uio->uio_resid; 1423 if (bufsize == 0) 1424 return 0; 1425 buf = kmem_alloc(bufsize, KM_SLEEP); 1426 error = uiomove(buf, bufsize, uio); 1427 if (error) 1428 goto out; 1429 1430 KASSERT(uio->uio_resid == 0); 1431 iov.iov_base = buf; 1432 iov.iov_len = bufsize; 1433 if ((error = rumpuser_iovwrite(rn->rn_writefd, &iov, 1, 1434 (uio->uio_offset-bufsize) + rn->rn_offset, &n)) == 0) { 1435 KASSERT(n <= bufsize); 1436 uio->uio_resid = bufsize - n; 1437 } 1438 1439 out: 1440 kmem_free(buf, bufsize); 1441 return error; 1442 } 1443 1444 static int 1445 rump_vop_write(void *v) 1446 { 1447 struct vop_write_args /* { 1448 struct vnode *a_vp; 1449 struct uio *a_uio; 1450 int ioflags a_ioflag; 1451 kauth_cred_t a_cred; 1452 }; */ *ap = v; 1453 struct vnode *vp = ap->a_vp; 1454 struct rumpfs_node *rn = vp->v_data; 1455 struct uio *uio = ap->a_uio; 1456 const int advice = IO_ADV_DECODE(ap->a_ioflag); 1457 void *olddata; 1458 size_t oldlen, newlen; 1459 off_t chunk; 1460 int error = 0; 1461 bool allocd = false; 1462 struct timespec ts; 1463 1464 getnanotime(&ts); 1465 (void)rumpfs_update(RUMPFS_MODIFY, vp, &ts, &ts, &ts); 1466 1467 if (ap->a_ioflag & IO_APPEND) 1468 uio->uio_offset = vp->v_size; 1469 1470 /* consult et? */ 1471 if (rn->rn_flags & RUMPNODE_ET_PHONE_HOST) 1472 return etwrite(rn, uio); 1473 1474 /* 1475 * Otherwise, it's a case of ubcmove. 1476 */ 1477 1478 /* 1479 * First, make sure we have enough storage. 1480 * 1481 * No, you don't need to tell me it's not very efficient. 1482 * No, it doesn't really support sparse files, just fakes it. 1483 */ 1484 newlen = uio->uio_offset + uio->uio_resid; 1485 oldlen = 0; /* XXXgcc */ 1486 olddata = NULL; 1487 if (rn->rn_dlen < newlen) { 1488 oldlen = rn->rn_dlen; 1489 olddata = rn->rn_data; 1490 1491 rn->rn_data = rump_hypermalloc(newlen, 0, false, "rumpfs"); 1492 if (rn->rn_data == NULL) 1493 return ENOSPC; 1494 rn->rn_dlen = newlen; 1495 memset(rn->rn_data, 0, newlen); 1496 if (oldlen > 0) 1497 memcpy(rn->rn_data, olddata, oldlen); 1498 allocd = true; 1499 uvm_vnp_setsize(vp, newlen); 1500 } 1501 1502 /* ok, we have enough stooorage. write */ 1503 while (uio->uio_resid > 0) { 1504 chunk = MIN(uio->uio_resid, (off_t)rn->rn_dlen-uio->uio_offset); 1505 if (chunk == 0) 1506 break; 1507 error = ubc_uiomove(&vp->v_uobj, uio, chunk, advice, 1508 UBC_WRITE | UBC_PARTIALOK | UBC_UNMAP_FLAG(vp)); 1509 if (error) 1510 break; 1511 } 1512 1513 if (allocd) { 1514 if (error) { 1515 rump_hyperfree(rn->rn_data, newlen); 1516 rn->rn_data = olddata; 1517 rn->rn_dlen = oldlen; 1518 uvm_vnp_setsize(vp, oldlen); 1519 } else { 1520 if ((rn->rn_flags & RUMPNODE_EXTSTORAGE) == 0) { 1521 rump_hyperfree(olddata, oldlen); 1522 } else { 1523 rn->rn_flags &= ~RUMPNODE_EXTSTORAGE; 1524 } 1525 } 1526 } 1527 1528 return error; 1529 } 1530 1531 static int 1532 rump_vop_bmap(void *v) 1533 { 1534 struct vop_bmap_args /* { 1535 struct vnode *a_vp; 1536 daddr_t a_bn; 1537 struct vnode **a_vpp; 1538 daddr_t *a_bnp; 1539 int *a_runp; 1540 } */ *ap = v; 1541 1542 /* 1:1 mapping */ 1543 if (ap->a_vpp) 1544 *ap->a_vpp = ap->a_vp; 1545 if (ap->a_bnp) 1546 *ap->a_bnp = ap->a_bn; 1547 if (ap->a_runp) 1548 *ap->a_runp = 16; 1549 1550 return 0; 1551 } 1552 1553 static int 1554 rump_vop_strategy(void *v) 1555 { 1556 struct vop_strategy_args /* { 1557 struct vnode *a_vp; 1558 struct buf *a_bp; 1559 } */ *ap = v; 1560 struct vnode *vp = ap->a_vp; 1561 struct rumpfs_node *rn = vp->v_data; 1562 struct buf *bp = ap->a_bp; 1563 off_t copylen, copyoff; 1564 int error; 1565 1566 if (vp->v_type != VREG || rn->rn_flags & RUMPNODE_ET_PHONE_HOST) { 1567 error = EINVAL; 1568 goto out; 1569 } 1570 1571 copyoff = bp->b_blkno << DEV_BSHIFT; 1572 copylen = MIN(rn->rn_dlen - copyoff, bp->b_bcount); 1573 if (BUF_ISWRITE(bp)) { 1574 memcpy((uint8_t *)rn->rn_data + copyoff, bp->b_data, copylen); 1575 } else { 1576 memset((uint8_t*)bp->b_data + copylen, 0, bp->b_bcount-copylen); 1577 memcpy(bp->b_data, (uint8_t *)rn->rn_data + copyoff, copylen); 1578 } 1579 bp->b_resid = 0; 1580 error = 0; 1581 1582 out: 1583 bp->b_error = error; 1584 biodone(bp); 1585 return 0; 1586 } 1587 1588 static int 1589 rump_vop_pathconf(void *v) 1590 { 1591 struct vop_pathconf_args /* { 1592 struct vnode *a_vp; 1593 int a_name; 1594 register_t *a_retval; 1595 }; */ *ap = v; 1596 int name = ap->a_name; 1597 register_t *retval = ap->a_retval; 1598 1599 switch (name) { 1600 case _PC_LINK_MAX: 1601 *retval = LINK_MAX; 1602 return 0; 1603 case _PC_NAME_MAX: 1604 *retval = RUMPFS_MAXNAMLEN; 1605 return 0; 1606 case _PC_PATH_MAX: 1607 *retval = PATH_MAX; 1608 return 0; 1609 case _PC_PIPE_BUF: 1610 *retval = PIPE_BUF; 1611 return 0; 1612 case _PC_CHOWN_RESTRICTED: 1613 *retval = 1; 1614 return 0; 1615 case _PC_NO_TRUNC: 1616 *retval = 1; 1617 return 0; 1618 case _PC_SYNC_IO: 1619 *retval = 1; 1620 return 0; 1621 case _PC_FILESIZEBITS: 1622 *retval = 43; /* this one goes to 11 */ 1623 return 0; 1624 case _PC_SYMLINK_MAX: 1625 *retval = MAXPATHLEN; 1626 return 0; 1627 case _PC_2_SYMLINKS: 1628 *retval = 1; 1629 return 0; 1630 default: 1631 return EINVAL; 1632 } 1633 } 1634 1635 static int 1636 rump_vop_success(void *v) 1637 { 1638 1639 return 0; 1640 } 1641 1642 static int 1643 rump_vop_inactive(void *v) 1644 { 1645 struct vop_inactive_v2_args /* { 1646 struct vnode *a_vp; 1647 bool *a_recycle; 1648 } */ *ap = v; 1649 struct vnode *vp = ap->a_vp; 1650 struct rumpfs_node *rn = vp->v_data; 1651 1652 if (rn->rn_flags & RUMPNODE_ET_PHONE_HOST && vp->v_type == VREG) { 1653 if (rn->rn_readfd != -1) { 1654 rumpuser_close(rn->rn_readfd); 1655 rn->rn_readfd = -1; 1656 } 1657 if (rn->rn_writefd != -1) { 1658 rumpuser_close(rn->rn_writefd); 1659 rn->rn_writefd = -1; 1660 } 1661 } 1662 *ap->a_recycle = (rn->rn_flags & RUMPNODE_CANRECLAIM) ? true : false; 1663 1664 return 0; 1665 } 1666 1667 static int 1668 rump_vop_reclaim(void *v) 1669 { 1670 struct vop_reclaim_v2_args /* { 1671 struct vnode *a_vp; 1672 } */ *ap = v; 1673 struct vnode *vp = ap->a_vp; 1674 struct rumpfs_node *rn = vp->v_data; 1675 1676 VOP_UNLOCK(vp); 1677 1678 mutex_enter(&reclock); 1679 rn->rn_vp = NULL; 1680 mutex_exit(&reclock); 1681 genfs_node_destroy(vp); 1682 vp->v_data = NULL; 1683 1684 if (rn->rn_flags & RUMPNODE_CANRECLAIM) { 1685 if (vp->v_type == VREG 1686 && (rn->rn_flags & RUMPNODE_ET_PHONE_HOST) == 0 1687 && rn->rn_data) { 1688 if ((rn->rn_flags & RUMPNODE_EXTSTORAGE) == 0) { 1689 rump_hyperfree(rn->rn_data, rn->rn_dlen); 1690 } else { 1691 rn->rn_flags &= ~RUMPNODE_EXTSTORAGE; 1692 } 1693 rn->rn_data = NULL; 1694 } 1695 1696 if (vp->v_type == VLNK) 1697 PNBUF_PUT(rn->rn_linktarg); 1698 if (rn->rn_hostpath) 1699 free(rn->rn_hostpath, M_TEMP); 1700 freeprivate(rn); 1701 } 1702 1703 return 0; 1704 } 1705 1706 static int 1707 rump_vop_spec(void *v) 1708 { 1709 struct vop_generic_args *ap = v; 1710 int (**opvec)(void *); 1711 1712 switch (ap->a_desc->vdesc_offset) { 1713 case VOP_ACCESS_DESCOFFSET: 1714 case VOP_GETATTR_DESCOFFSET: 1715 case VOP_SETATTR_DESCOFFSET: 1716 case VOP_LOCK_DESCOFFSET: 1717 case VOP_UNLOCK_DESCOFFSET: 1718 case VOP_ISLOCKED_DESCOFFSET: 1719 case VOP_INACTIVE_DESCOFFSET: 1720 case VOP_RECLAIM_DESCOFFSET: 1721 opvec = rump_vnodeop_p; 1722 break; 1723 default: 1724 opvec = spec_vnodeop_p; 1725 break; 1726 } 1727 1728 return VOCALL(opvec, ap->a_desc->vdesc_offset, v); 1729 } 1730 1731 static int 1732 rump_vop_advlock(void *v) 1733 { 1734 struct vop_advlock_args /* { 1735 const struct vnodeop_desc *a_desc; 1736 struct vnode *a_vp; 1737 void *a_id; 1738 int a_op; 1739 struct flock *a_fl; 1740 int a_flags; 1741 } */ *ap = v; 1742 struct vnode *vp = ap->a_vp; 1743 struct rumpfs_node *rn = vp->v_data; 1744 1745 return lf_advlock(ap, &rn->rn_lockf, vp->v_size); 1746 } 1747 1748 static int 1749 rump_vop_fcntl(void *v) 1750 { 1751 struct vop_fcntl_args /* { 1752 struct vnode *a_vp; 1753 u_int a_command; 1754 void *a_data; 1755 int a_fflag; 1756 kauth_cred_t a_cred; 1757 } */ *ap = v; 1758 struct proc *p = curproc; 1759 struct vnode *vp = ap->a_vp; 1760 struct rumpfs_node *rn = vp->v_data; 1761 u_int cmd = ap->a_command; 1762 int fflag = ap->a_fflag; 1763 struct rumpfs_extstorage *rfse = ap->a_data; 1764 int error = 0; 1765 1766 /* none of the current rumpfs fcntlops are defined for remotes */ 1767 if (!RUMP_LOCALPROC_P(p)) 1768 return EINVAL; 1769 1770 switch (cmd) { 1771 case RUMPFS_FCNTL_EXTSTORAGE_ADD: 1772 break; 1773 default: 1774 return EINVAL; 1775 } 1776 1777 if ((fflag & FWRITE) == 0) 1778 return EBADF; 1779 1780 if (vp->v_type != VREG || (rn->rn_flags & RUMPNODE_ET_PHONE_HOST)) 1781 return EINVAL; 1782 1783 if (rfse->rfse_flags != 0) 1784 return EINVAL; 1785 1786 /* 1787 * Ok, we are good to go. Process. 1788 */ 1789 1790 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); 1791 1792 KASSERT(cmd == RUMPFS_FCNTL_EXTSTORAGE_ADD); 1793 if (rn->rn_data && (rn->rn_flags & RUMPNODE_EXTSTORAGE) == 0) { 1794 rump_hyperfree(rn->rn_data, rn->rn_dlen); 1795 } 1796 1797 rn->rn_data = rfse->rfse_data; 1798 rn->rn_dlen = rfse->rfse_dlen; 1799 uvm_vnp_setsize(vp, rn->rn_dlen); 1800 rn->rn_flags |= RUMPNODE_EXTSTORAGE; 1801 1802 VOP_UNLOCK(vp); 1803 1804 return error; 1805 } 1806 1807 /* 1808 * Begin vfs-level stuff 1809 */ 1810 1811 VFS_PROTOS(rumpfs); 1812 struct vfsops rumpfs_vfsops = { 1813 .vfs_name = MOUNT_RUMPFS, 1814 .vfs_min_mount_data = 0, 1815 .vfs_mount = rumpfs_mount, 1816 .vfs_start = (void *)nullop, 1817 .vfs_unmount = rumpfs_unmount, 1818 .vfs_root = rumpfs_root, 1819 .vfs_quotactl = (void *)eopnotsupp, 1820 .vfs_statvfs = genfs_statvfs, 1821 .vfs_sync = (void *)nullop, 1822 .vfs_vget = rumpfs_vget, 1823 .vfs_loadvnode = rumpfs_loadvnode, 1824 .vfs_fhtovp = (void *)eopnotsupp, 1825 .vfs_vptofh = (void *)eopnotsupp, 1826 .vfs_init = rumpfs_init, 1827 .vfs_reinit = NULL, 1828 .vfs_done = rumpfs_done, 1829 .vfs_mountroot = rumpfs_mountroot, 1830 .vfs_snapshot = (void *)eopnotsupp, 1831 .vfs_extattrctl = (void *)eopnotsupp, 1832 .vfs_suspendctl = genfs_suspendctl, 1833 .vfs_renamelock_enter = genfs_renamelock_enter, 1834 .vfs_renamelock_exit = genfs_renamelock_exit, 1835 .vfs_opv_descs = rump_opv_descs, 1836 /* vfs_refcount */ 1837 /* vfs_list */ 1838 }; 1839 1840 static int 1841 rumpfs_mountfs(struct mount *mp) 1842 { 1843 struct rumpfs_mount *rfsmp; 1844 struct rumpfs_node *rn; 1845 int error; 1846 1847 rfsmp = kmem_alloc(sizeof(*rfsmp), KM_SLEEP); 1848 1849 rn = makeprivate(VDIR, RUMPFS_DEFAULTMODE, NODEV, DEV_BSIZE, false); 1850 rn->rn_parent = rn; 1851 if ((error = vcache_get(mp, &rn, sizeof(rn), &rfsmp->rfsmp_rvp)) 1852 != 0) { 1853 freeprivate(rn); 1854 kmem_free(rfsmp, sizeof(*rfsmp)); 1855 return error; 1856 } 1857 1858 rfsmp->rfsmp_rvp->v_vflag |= VV_ROOT; 1859 1860 mp->mnt_data = rfsmp; 1861 mp->mnt_stat.f_namemax = RUMPFS_MAXNAMLEN; 1862 mp->mnt_stat.f_iosize = 512; 1863 mp->mnt_flag |= MNT_LOCAL; 1864 mp->mnt_iflag |= IMNT_MPSAFE | IMNT_CAN_RWTORO; 1865 mp->mnt_fs_bshift = DEV_BSHIFT; 1866 vfs_getnewfsid(mp); 1867 1868 return 0; 1869 } 1870 1871 int 1872 rumpfs_mount(struct mount *mp, const char *mntpath, void *arg, size_t *alen) 1873 { 1874 int error, flags; 1875 1876 if (mp->mnt_flag & MNT_GETARGS) { 1877 return 0; 1878 } 1879 if (mp->mnt_flag & MNT_UPDATE) { 1880 if ((mp->mnt_iflag & IMNT_WANTRDONLY)) { 1881 /* Changing from read/write to read-only. */ 1882 flags = WRITECLOSE; 1883 if ((mp->mnt_flag & MNT_FORCE)) 1884 flags |= FORCECLOSE; 1885 error = vflush(mp, NULL, flags); 1886 if (error) 1887 return error; 1888 } 1889 return 0; 1890 } 1891 1892 error = set_statvfs_info(mntpath, UIO_USERSPACE, "rumpfs", UIO_SYSSPACE, 1893 mp->mnt_op->vfs_name, mp, curlwp); 1894 if (error) 1895 return error; 1896 1897 return rumpfs_mountfs(mp); 1898 } 1899 1900 int 1901 rumpfs_unmount(struct mount *mp, int mntflags) 1902 { 1903 struct rumpfs_mount *rfsmp = mp->mnt_data; 1904 int flags = 0, error; 1905 1906 if (panicstr || mntflags & MNT_FORCE) 1907 flags |= FORCECLOSE; 1908 1909 if (rfsmp->rfsmp_rvp->v_usecount > 1 && (flags & FORCECLOSE) == 0) 1910 return EBUSY; 1911 1912 if ((error = vflush(mp, rfsmp->rfsmp_rvp, flags)) != 0) 1913 return error; 1914 vgone(rfsmp->rfsmp_rvp); 1915 1916 kmem_free(rfsmp, sizeof(*rfsmp)); 1917 1918 return 0; 1919 } 1920 1921 int 1922 rumpfs_root(struct mount *mp, int lktype, struct vnode **vpp) 1923 { 1924 struct rumpfs_mount *rfsmp = mp->mnt_data; 1925 1926 vref(rfsmp->rfsmp_rvp); 1927 vn_lock(rfsmp->rfsmp_rvp, lktype | LK_RETRY); 1928 *vpp = rfsmp->rfsmp_rvp; 1929 return 0; 1930 } 1931 1932 int 1933 rumpfs_vget(struct mount *mp, ino_t ino, int lktype, struct vnode **vpp) 1934 { 1935 1936 return EOPNOTSUPP; 1937 } 1938 1939 int 1940 rumpfs_loadvnode(struct mount *mp, struct vnode *vp, 1941 const void *key, size_t key_len, const void **new_key) 1942 { 1943 struct rumpfs_node *rn; 1944 struct vattr *va; 1945 1946 KASSERT(!mutex_owned(&reclock)); 1947 1948 KASSERT(key_len == sizeof(rn)); 1949 memcpy(&rn, key, key_len); 1950 1951 va = &rn->rn_va; 1952 1953 vp->v_tag = VT_RUMP; 1954 vp->v_type = va->va_type; 1955 switch (vp->v_type) { 1956 case VCHR: 1957 case VBLK: 1958 vp->v_op = rump_specop_p; 1959 spec_node_init(vp, va->va_rdev); 1960 break; 1961 default: 1962 vp->v_op = rump_vnodeop_p; 1963 break; 1964 } 1965 vp->v_size = vp->v_writesize = va->va_size; 1966 vp->v_data = rn; 1967 1968 genfs_node_init(vp, &rumpfs_genfsops); 1969 mutex_enter(&reclock); 1970 rn->rn_vp = vp; 1971 mutex_exit(&reclock); 1972 1973 *new_key = &vp->v_data; 1974 1975 return 0; 1976 } 1977 1978 void 1979 rumpfs_init() 1980 { 1981 extern rump_etfs_register_withsize_fn rump__etfs_register; 1982 extern rump_etfs_remove_fn rump__etfs_remove; 1983 extern struct rump_boot_etfs *ebstart; 1984 struct rump_boot_etfs *eb; 1985 1986 CTASSERT(RUMP_ETFS_SIZE_ENDOFF == RUMPBLK_SIZENOTSET); 1987 1988 mutex_init(&reclock, MUTEX_DEFAULT, IPL_NONE); 1989 mutex_init(&etfs_lock, MUTEX_DEFAULT, IPL_NONE); 1990 1991 rump__etfs_register = etfsregister; 1992 rump__etfs_remove = etfsremove; 1993 1994 for (eb = ebstart; eb; eb = eb->_eb_next) { 1995 eb->eb_status = etfsregister(eb->eb_key, eb->eb_hostpath, 1996 eb->eb_type, eb->eb_begin, eb->eb_size); 1997 } 1998 } 1999 2000 void 2001 rumpfs_done() 2002 { 2003 2004 mutex_destroy(&reclock); 2005 mutex_destroy(&etfs_lock); 2006 } 2007 2008 int 2009 rumpfs_mountroot() 2010 { 2011 struct mount *mp; 2012 int error; 2013 2014 if ((error = vfs_rootmountalloc(MOUNT_RUMPFS, "rootdev", &mp)) != 0) { 2015 vrele(rootvp); 2016 return error; 2017 } 2018 2019 if ((error = rumpfs_mountfs(mp)) != 0) 2020 panic("mounting rootfs failed: %d", error); 2021 2022 mountlist_append(mp); 2023 2024 error = set_statvfs_info("/", UIO_SYSSPACE, "rumpfs", UIO_SYSSPACE, 2025 mp->mnt_op->vfs_name, mp, curlwp); 2026 if (error) 2027 panic("set_statvfs_info failed for rootfs: %d", error); 2028 2029 mp->mnt_flag &= ~MNT_RDONLY; 2030 vfs_unbusy(mp); 2031 2032 return 0; 2033 } 2034
Indexes created Mon Sep 29 13:09:55 GMT 2025