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