rumpfs.c revision 1.154
1 /* $NetBSD: rumpfs.c,v 1.154 2020/01/17 20:08:09 ad 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.154 2020/01/17 20:08:09 ad 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 memcpy(newdata, rn->rn_data, copylen); 981 memset((char *)newdata + copylen, 0, newlen - copylen); 982 983 if ((rn->rn_flags & RUMPNODE_EXTSTORAGE) == 0) { 984 rump_hyperfree(rn->rn_data, rn->rn_dlen); 985 } else { 986 rn->rn_flags &= ~RUMPNODE_EXTSTORAGE; 987 } 988 989 rn->rn_data = newdata; 990 rn->rn_dlen = newlen; 991 uvm_vnp_setsize(vp, newlen); 992 } 993 return 0; 994 } 995 996 static int 997 rump_vop_mkdir(void *v) 998 { 999 struct vop_mkdir_v3_args /* { 1000 struct vnode *a_dvp; 1001 struct vnode **a_vpp; 1002 struct componentname *a_cnp; 1003 struct vattr *a_vap; 1004 }; */ *ap = v; 1005 struct vnode *dvp = ap->a_dvp; 1006 struct vnode **vpp = ap->a_vpp; 1007 struct componentname *cnp = ap->a_cnp; 1008 struct vattr *va = ap->a_vap; 1009 struct rumpfs_node *rnd = dvp->v_data, *rn; 1010 int rv = 0; 1011 1012 rn = makeprivate(VDIR, va->va_mode & ALLPERMS, NODEV, DEV_BSIZE, false); 1013 if ((cnp->cn_flags & ISWHITEOUT) != 0) 1014 rn->rn_va.va_flags |= UF_OPAQUE; 1015 rn->rn_parent = rnd; 1016 rv = vcache_get(dvp->v_mount, &rn, sizeof(rn), vpp); 1017 if (rv) { 1018 freeprivate(rn); 1019 return rv; 1020 } 1021 1022 makedir(rnd, cnp, rn); 1023 1024 return rv; 1025 } 1026 1027 static int 1028 rump_vop_rmdir(void *v) 1029 { 1030 struct vop_rmdir_v2_args /* { 1031 struct vnode *a_dvp; 1032 struct vnode *a_vp; 1033 struct componentname *a_cnp; 1034 }; */ *ap = v; 1035 struct vnode *dvp = ap->a_dvp; 1036 struct vnode *vp = ap->a_vp; 1037 struct componentname *cnp = ap->a_cnp; 1038 struct rumpfs_node *rnd = dvp->v_data; 1039 struct rumpfs_node *rn = vp->v_data; 1040 struct rumpfs_dent *rd; 1041 int rv = 0; 1042 1043 LIST_FOREACH(rd, &rn->rn_dir, rd_entries) { 1044 if (rd->rd_node != RUMPFS_WHITEOUT) { 1045 rv = ENOTEMPTY; 1046 goto out; 1047 } 1048 } 1049 while ((rd = LIST_FIRST(&rn->rn_dir)) != NULL) { 1050 KASSERT(rd->rd_node == RUMPFS_WHITEOUT); 1051 LIST_REMOVE(rd, rd_entries); 1052 kmem_free(rd->rd_name, rd->rd_namelen+1); 1053 kmem_free(rd, sizeof(*rd)); 1054 } 1055 1056 freedir(rnd, cnp); 1057 rn->rn_flags |= RUMPNODE_CANRECLAIM; 1058 rn->rn_parent = NULL; 1059 rn->rn_va.va_nlink = 0; 1060 1061 out: 1062 vput(vp); 1063 return rv; 1064 } 1065 1066 static int 1067 rump_vop_remove(void *v) 1068 { 1069 struct vop_remove_v2_args /* { 1070 struct vnode *a_dvp; 1071 struct vnode *a_vp; 1072 struct componentname *a_cnp; 1073 }; */ *ap = v; 1074 struct vnode *dvp = ap->a_dvp; 1075 struct vnode *vp = ap->a_vp; 1076 struct componentname *cnp = ap->a_cnp; 1077 struct rumpfs_node *rnd = dvp->v_data; 1078 struct rumpfs_node *rn = vp->v_data; 1079 int rv = 0; 1080 1081 if (rn->rn_flags & RUMPNODE_ET_PHONE_HOST) 1082 return EOPNOTSUPP; 1083 1084 freedir(rnd, cnp); 1085 rn->rn_flags |= RUMPNODE_CANRECLAIM; 1086 rn->rn_va.va_nlink = 0; 1087 1088 vput(vp); 1089 return rv; 1090 } 1091 1092 static int 1093 rump_vop_mknod(void *v) 1094 { 1095 struct vop_mknod_v3_args /* { 1096 struct vnode *a_dvp; 1097 struct vnode **a_vpp; 1098 struct componentname *a_cnp; 1099 struct vattr *a_vap; 1100 }; */ *ap = v; 1101 struct vnode *dvp = ap->a_dvp; 1102 struct vnode **vpp = ap->a_vpp; 1103 struct componentname *cnp = ap->a_cnp; 1104 struct vattr *va = ap->a_vap; 1105 struct rumpfs_node *rnd = dvp->v_data, *rn; 1106 int rv; 1107 1108 rn = makeprivate(va->va_type, va->va_mode & ALLPERMS, va->va_rdev, 1109 DEV_BSIZE, false); 1110 if ((cnp->cn_flags & ISWHITEOUT) != 0) 1111 rn->rn_va.va_flags |= UF_OPAQUE; 1112 rv = vcache_get(dvp->v_mount, &rn, sizeof(rn), vpp); 1113 if (rv) { 1114 freeprivate(rn); 1115 return rv; 1116 } 1117 1118 makedir(rnd, cnp, rn); 1119 1120 return rv; 1121 } 1122 1123 static int 1124 rump_vop_create(void *v) 1125 { 1126 struct vop_create_v3_args /* { 1127 struct vnode *a_dvp; 1128 struct vnode **a_vpp; 1129 struct componentname *a_cnp; 1130 struct vattr *a_vap; 1131 }; */ *ap = v; 1132 struct vnode *dvp = ap->a_dvp; 1133 struct vnode **vpp = ap->a_vpp; 1134 struct componentname *cnp = ap->a_cnp; 1135 struct vattr *va = ap->a_vap; 1136 struct rumpfs_node *rnd = dvp->v_data, *rn; 1137 off_t newsize; 1138 int rv; 1139 1140 newsize = va->va_type == VSOCK ? DEV_BSIZE : 0; 1141 rn = makeprivate(va->va_type, va->va_mode & ALLPERMS, NODEV, 1142 newsize, false); 1143 if ((cnp->cn_flags & ISWHITEOUT) != 0) 1144 rn->rn_va.va_flags |= UF_OPAQUE; 1145 rv = vcache_get(dvp->v_mount, &rn, sizeof(rn), vpp); 1146 if (rv) { 1147 freeprivate(rn); 1148 return rv; 1149 } 1150 1151 makedir(rnd, cnp, rn); 1152 1153 return rv; 1154 } 1155 1156 static int 1157 rump_vop_symlink(void *v) 1158 { 1159 struct vop_symlink_v3_args /* { 1160 struct vnode *a_dvp; 1161 struct vnode **a_vpp; 1162 struct componentname *a_cnp; 1163 struct vattr *a_vap; 1164 char *a_target; 1165 }; */ *ap = v; 1166 struct vnode *dvp = ap->a_dvp; 1167 struct vnode **vpp = ap->a_vpp; 1168 struct componentname *cnp = ap->a_cnp; 1169 struct vattr *va = ap->a_vap; 1170 struct rumpfs_node *rnd = dvp->v_data, *rn; 1171 const char *target = ap->a_target; 1172 size_t linklen; 1173 int rv; 1174 1175 linklen = strlen(target); 1176 KASSERT(linklen < MAXPATHLEN); 1177 rn = makeprivate(VLNK, va->va_mode & ALLPERMS, NODEV, linklen, false); 1178 if ((cnp->cn_flags & ISWHITEOUT) != 0) 1179 rn->rn_va.va_flags |= UF_OPAQUE; 1180 rv = vcache_get(dvp->v_mount, &rn, sizeof(rn), vpp); 1181 if (rv) { 1182 freeprivate(rn); 1183 return rv; 1184 } 1185 1186 makedir(rnd, cnp, rn); 1187 1188 KASSERT(linklen < MAXPATHLEN); 1189 rn->rn_linktarg = PNBUF_GET(); 1190 rn->rn_linklen = linklen; 1191 strcpy(rn->rn_linktarg, target); 1192 1193 return rv; 1194 } 1195 1196 static int 1197 rump_vop_readlink(void *v) 1198 { 1199 struct vop_readlink_args /* { 1200 struct vnode *a_vp; 1201 struct uio *a_uio; 1202 kauth_cred_t a_cred; 1203 }; */ *ap = v; 1204 struct vnode *vp = ap->a_vp; 1205 struct rumpfs_node *rn = vp->v_data; 1206 struct uio *uio = ap->a_uio; 1207 1208 return uiomove(rn->rn_linktarg, rn->rn_linklen, uio); 1209 } 1210 1211 static int 1212 rump_vop_whiteout(void *v) 1213 { 1214 struct vop_whiteout_args /* { 1215 struct vnode *a_dvp; 1216 struct componentname *a_cnp; 1217 int a_flags; 1218 } */ *ap = v; 1219 struct vnode *dvp = ap->a_dvp; 1220 struct rumpfs_node *rnd = dvp->v_data; 1221 struct componentname *cnp = ap->a_cnp; 1222 int flags = ap->a_flags; 1223 1224 switch (flags) { 1225 case LOOKUP: 1226 break; 1227 case CREATE: 1228 makedir(rnd, cnp, RUMPFS_WHITEOUT); 1229 break; 1230 case DELETE: 1231 cnp->cn_flags &= ~DOWHITEOUT; /* cargo culting never fails ? */ 1232 freedir(rnd, cnp); 1233 break; 1234 default: 1235 panic("unknown whiteout op %d", flags); 1236 } 1237 1238 return 0; 1239 } 1240 1241 static int 1242 rump_vop_open(void *v) 1243 { 1244 struct vop_open_args /* { 1245 struct vnode *a_vp; 1246 int a_mode; 1247 kauth_cred_t a_cred; 1248 } */ *ap = v; 1249 struct vnode *vp = ap->a_vp; 1250 struct rumpfs_node *rn = vp->v_data; 1251 int mode = ap->a_mode; 1252 int error = EINVAL; 1253 1254 if (vp->v_type != VREG || (rn->rn_flags & RUMPNODE_ET_PHONE_HOST) == 0) 1255 return 0; 1256 1257 if (mode & FREAD) { 1258 if (rn->rn_readfd != -1) 1259 return 0; 1260 error = rumpuser_open(rn->rn_hostpath, 1261 RUMPUSER_OPEN_RDONLY, &rn->rn_readfd); 1262 } 1263 1264 if (mode & FWRITE) { 1265 if (rn->rn_writefd != -1) 1266 return 0; 1267 error = rumpuser_open(rn->rn_hostpath, 1268 RUMPUSER_OPEN_WRONLY, &rn->rn_writefd); 1269 } 1270 1271 return error; 1272 } 1273 1274 /* simple readdir. even omits dotstuff and periods */ 1275 static int 1276 rump_vop_readdir(void *v) 1277 { 1278 struct vop_readdir_args /* { 1279 struct vnode *a_vp; 1280 struct uio *a_uio; 1281 kauth_cred_t a_cred; 1282 int *a_eofflag; 1283 off_t **a_cookies; 1284 int *a_ncookies; 1285 } */ *ap = v; 1286 struct vnode *vp = ap->a_vp; 1287 struct uio *uio = ap->a_uio; 1288 struct rumpfs_node *rnd = vp->v_data; 1289 struct rumpfs_dent *rdent; 1290 struct dirent *dentp = NULL; 1291 unsigned i; 1292 int rv = 0; 1293 1294 /* seek to current entry */ 1295 for (i = 0, rdent = LIST_FIRST(&rnd->rn_dir); 1296 (i < uio->uio_offset) && rdent; 1297 i++, rdent = LIST_NEXT(rdent, rd_entries)) 1298 continue; 1299 if (!rdent) 1300 goto out; 1301 1302 /* copy entries */ 1303 dentp = kmem_alloc(sizeof(*dentp), KM_SLEEP); 1304 for (; rdent && uio->uio_resid > 0; 1305 rdent = LIST_NEXT(rdent, rd_entries), i++) { 1306 strlcpy(dentp->d_name, rdent->rd_name, sizeof(dentp->d_name)); 1307 dentp->d_namlen = strlen(dentp->d_name); 1308 dentp->d_reclen = _DIRENT_RECLEN(dentp, dentp->d_namlen); 1309 1310 if (__predict_false(RDENT_ISWHITEOUT(rdent))) { 1311 dentp->d_fileno = INO_WHITEOUT; 1312 dentp->d_type = DT_WHT; 1313 } else { 1314 dentp->d_fileno = rdent->rd_node->rn_va.va_fileid; 1315 dentp->d_type = vtype2dt(rdent->rd_node->rn_va.va_type); 1316 } 1317 1318 if (uio->uio_resid < dentp->d_reclen) { 1319 i--; 1320 break; 1321 } 1322 1323 rv = uiomove(dentp, dentp->d_reclen, uio); 1324 if (rv) { 1325 i--; 1326 break; 1327 } 1328 } 1329 kmem_free(dentp, sizeof(*dentp)); 1330 dentp = NULL; 1331 1332 out: 1333 KASSERT(dentp == NULL); 1334 if (ap->a_cookies) { 1335 *ap->a_ncookies = 0; 1336 *ap->a_cookies = NULL; 1337 } 1338 if (rdent) 1339 *ap->a_eofflag = 0; 1340 else 1341 *ap->a_eofflag = 1; 1342 uio->uio_offset = i; 1343 1344 return rv; 1345 } 1346 1347 static int 1348 etread(struct rumpfs_node *rn, struct uio *uio) 1349 { 1350 struct rumpuser_iovec iov; 1351 uint8_t *buf; 1352 size_t bufsize, n; 1353 int error = 0; 1354 1355 bufsize = uio->uio_resid; 1356 if (bufsize == 0) 1357 return 0; 1358 buf = kmem_alloc(bufsize, KM_SLEEP); 1359 1360 iov.iov_base = buf; 1361 iov.iov_len = bufsize; 1362 if ((error = rumpuser_iovread(rn->rn_readfd, &iov, 1, 1363 uio->uio_offset + rn->rn_offset, &n)) == 0) { 1364 KASSERT(n <= bufsize); 1365 error = uiomove(buf, n, uio); 1366 } 1367 1368 kmem_free(buf, bufsize); 1369 return error; 1370 } 1371 1372 static int 1373 rump_vop_read(void *v) 1374 { 1375 struct vop_read_args /* { 1376 struct vnode *a_vp; 1377 struct uio *a_uio; 1378 int ioflags a_ioflag; 1379 kauth_cred_t a_cred; 1380 }; */ *ap = v; 1381 struct vnode *vp = ap->a_vp; 1382 struct rumpfs_node *rn = vp->v_data; 1383 struct uio *uio = ap->a_uio; 1384 const int advice = IO_ADV_DECODE(ap->a_ioflag); 1385 off_t chunk; 1386 int error = 0; 1387 struct timespec ts; 1388 1389 if (vp->v_type == VDIR) 1390 return EISDIR; 1391 1392 /* et op? */ 1393 if (rn->rn_flags & RUMPNODE_ET_PHONE_HOST) 1394 return etread(rn, uio); 1395 1396 getnanotime(&ts); 1397 (void)rumpfs_update(RUMPFS_ACCESS, vp, &ts, &ts, &ts); 1398 1399 /* otherwise, it's off to ubc with us */ 1400 while (uio->uio_resid > 0) { 1401 chunk = MIN(uio->uio_resid, (off_t)rn->rn_dlen-uio->uio_offset); 1402 if (chunk == 0) 1403 break; 1404 error = ubc_uiomove(&vp->v_uobj, uio, chunk, advice, 1405 UBC_READ | UBC_PARTIALOK | UBC_UNMAP_FLAG(vp)); 1406 if (error) 1407 break; 1408 } 1409 1410 return error; 1411 } 1412 1413 static int 1414 etwrite(struct rumpfs_node *rn, struct uio *uio) 1415 { 1416 struct rumpuser_iovec iov; 1417 uint8_t *buf; 1418 size_t bufsize, n; 1419 int error = 0; 1420 1421 bufsize = uio->uio_resid; 1422 if (bufsize == 0) 1423 return 0; 1424 buf = kmem_alloc(bufsize, KM_SLEEP); 1425 error = uiomove(buf, bufsize, uio); 1426 if (error) 1427 goto out; 1428 1429 KASSERT(uio->uio_resid == 0); 1430 iov.iov_base = buf; 1431 iov.iov_len = bufsize; 1432 if ((error = rumpuser_iovwrite(rn->rn_writefd, &iov, 1, 1433 (uio->uio_offset-bufsize) + rn->rn_offset, &n)) == 0) { 1434 KASSERT(n <= bufsize); 1435 uio->uio_resid = bufsize - n; 1436 } 1437 1438 out: 1439 kmem_free(buf, bufsize); 1440 return error; 1441 } 1442 1443 static int 1444 rump_vop_write(void *v) 1445 { 1446 struct vop_write_args /* { 1447 struct vnode *a_vp; 1448 struct uio *a_uio; 1449 int ioflags a_ioflag; 1450 kauth_cred_t a_cred; 1451 }; */ *ap = v; 1452 struct vnode *vp = ap->a_vp; 1453 struct rumpfs_node *rn = vp->v_data; 1454 struct uio *uio = ap->a_uio; 1455 const int advice = IO_ADV_DECODE(ap->a_ioflag); 1456 void *olddata; 1457 size_t oldlen, newlen; 1458 off_t chunk; 1459 int error = 0; 1460 bool allocd = false; 1461 struct timespec ts; 1462 1463 getnanotime(&ts); 1464 (void)rumpfs_update(RUMPFS_MODIFY, vp, &ts, &ts, &ts); 1465 1466 if (ap->a_ioflag & IO_APPEND) 1467 uio->uio_offset = vp->v_size; 1468 1469 /* consult et? */ 1470 if (rn->rn_flags & RUMPNODE_ET_PHONE_HOST) 1471 return etwrite(rn, uio); 1472 1473 /* 1474 * Otherwise, it's a case of ubcmove. 1475 */ 1476 1477 /* 1478 * First, make sure we have enough storage. 1479 * 1480 * No, you don't need to tell me it's not very efficient. 1481 * No, it doesn't really support sparse files, just fakes it. 1482 */ 1483 newlen = uio->uio_offset + uio->uio_resid; 1484 oldlen = 0; /* XXXgcc */ 1485 olddata = NULL; 1486 if (rn->rn_dlen < newlen) { 1487 oldlen = rn->rn_dlen; 1488 olddata = rn->rn_data; 1489 1490 rn->rn_data = rump_hypermalloc(newlen, 0, false, "rumpfs"); 1491 if (rn->rn_data == NULL) 1492 return ENOSPC; 1493 rn->rn_dlen = newlen; 1494 memset(rn->rn_data, 0, newlen); 1495 memcpy(rn->rn_data, olddata, oldlen); 1496 allocd = true; 1497 uvm_vnp_setsize(vp, newlen); 1498 } 1499 1500 /* ok, we have enough stooorage. write */ 1501 while (uio->uio_resid > 0) { 1502 chunk = MIN(uio->uio_resid, (off_t)rn->rn_dlen-uio->uio_offset); 1503 if (chunk == 0) 1504 break; 1505 error = ubc_uiomove(&vp->v_uobj, uio, chunk, advice, 1506 UBC_WRITE | UBC_PARTIALOK | UBC_UNMAP_FLAG(vp)); 1507 if (error) 1508 break; 1509 } 1510 1511 if (allocd) { 1512 if (error) { 1513 rump_hyperfree(rn->rn_data, newlen); 1514 rn->rn_data = olddata; 1515 rn->rn_dlen = oldlen; 1516 uvm_vnp_setsize(vp, oldlen); 1517 } else { 1518 if ((rn->rn_flags & RUMPNODE_EXTSTORAGE) == 0) { 1519 rump_hyperfree(olddata, oldlen); 1520 } else { 1521 rn->rn_flags &= ~RUMPNODE_EXTSTORAGE; 1522 } 1523 } 1524 } 1525 1526 return error; 1527 } 1528 1529 static int 1530 rump_vop_bmap(void *v) 1531 { 1532 struct vop_bmap_args /* { 1533 struct vnode *a_vp; 1534 daddr_t a_bn; 1535 struct vnode **a_vpp; 1536 daddr_t *a_bnp; 1537 int *a_runp; 1538 } */ *ap = v; 1539 1540 /* 1:1 mapping */ 1541 if (ap->a_vpp) 1542 *ap->a_vpp = ap->a_vp; 1543 if (ap->a_bnp) 1544 *ap->a_bnp = ap->a_bn; 1545 if (ap->a_runp) 1546 *ap->a_runp = 16; 1547 1548 return 0; 1549 } 1550 1551 static int 1552 rump_vop_strategy(void *v) 1553 { 1554 struct vop_strategy_args /* { 1555 struct vnode *a_vp; 1556 struct buf *a_bp; 1557 } */ *ap = v; 1558 struct vnode *vp = ap->a_vp; 1559 struct rumpfs_node *rn = vp->v_data; 1560 struct buf *bp = ap->a_bp; 1561 off_t copylen, copyoff; 1562 int error; 1563 1564 if (vp->v_type != VREG || rn->rn_flags & RUMPNODE_ET_PHONE_HOST) { 1565 error = EINVAL; 1566 goto out; 1567 } 1568 1569 copyoff = bp->b_blkno << DEV_BSHIFT; 1570 copylen = MIN(rn->rn_dlen - copyoff, bp->b_bcount); 1571 if (BUF_ISWRITE(bp)) { 1572 memcpy((uint8_t *)rn->rn_data + copyoff, bp->b_data, copylen); 1573 } else { 1574 memset((uint8_t*)bp->b_data + copylen, 0, bp->b_bcount-copylen); 1575 memcpy(bp->b_data, (uint8_t *)rn->rn_data + copyoff, copylen); 1576 } 1577 bp->b_resid = 0; 1578 error = 0; 1579 1580 out: 1581 bp->b_error = error; 1582 biodone(bp); 1583 return 0; 1584 } 1585 1586 static int 1587 rump_vop_pathconf(void *v) 1588 { 1589 struct vop_pathconf_args /* { 1590 struct vnode *a_vp; 1591 int a_name; 1592 register_t *a_retval; 1593 }; */ *ap = v; 1594 int name = ap->a_name; 1595 register_t *retval = ap->a_retval; 1596 1597 switch (name) { 1598 case _PC_LINK_MAX: 1599 *retval = LINK_MAX; 1600 return 0; 1601 case _PC_NAME_MAX: 1602 *retval = RUMPFS_MAXNAMLEN; 1603 return 0; 1604 case _PC_PATH_MAX: 1605 *retval = PATH_MAX; 1606 return 0; 1607 case _PC_PIPE_BUF: 1608 *retval = PIPE_BUF; 1609 return 0; 1610 case _PC_CHOWN_RESTRICTED: 1611 *retval = 1; 1612 return 0; 1613 case _PC_NO_TRUNC: 1614 *retval = 1; 1615 return 0; 1616 case _PC_SYNC_IO: 1617 *retval = 1; 1618 return 0; 1619 case _PC_FILESIZEBITS: 1620 *retval = 43; /* this one goes to 11 */ 1621 return 0; 1622 case _PC_SYMLINK_MAX: 1623 *retval = MAXPATHLEN; 1624 return 0; 1625 case _PC_2_SYMLINKS: 1626 *retval = 1; 1627 return 0; 1628 default: 1629 return EINVAL; 1630 } 1631 } 1632 1633 static int 1634 rump_vop_success(void *v) 1635 { 1636 1637 return 0; 1638 } 1639 1640 static int 1641 rump_vop_inactive(void *v) 1642 { 1643 struct vop_inactive_v2_args /* { 1644 struct vnode *a_vp; 1645 bool *a_recycle; 1646 } */ *ap = v; 1647 struct vnode *vp = ap->a_vp; 1648 struct rumpfs_node *rn = vp->v_data; 1649 1650 if (rn->rn_flags & RUMPNODE_ET_PHONE_HOST && vp->v_type == VREG) { 1651 if (rn->rn_readfd != -1) { 1652 rumpuser_close(rn->rn_readfd); 1653 rn->rn_readfd = -1; 1654 } 1655 if (rn->rn_writefd != -1) { 1656 rumpuser_close(rn->rn_writefd); 1657 rn->rn_writefd = -1; 1658 } 1659 } 1660 *ap->a_recycle = (rn->rn_flags & RUMPNODE_CANRECLAIM) ? true : false; 1661 1662 return 0; 1663 } 1664 1665 static int 1666 rump_vop_reclaim(void *v) 1667 { 1668 struct vop_reclaim_v2_args /* { 1669 struct vnode *a_vp; 1670 } */ *ap = v; 1671 struct vnode *vp = ap->a_vp; 1672 struct rumpfs_node *rn = vp->v_data; 1673 1674 VOP_UNLOCK(vp); 1675 1676 mutex_enter(&reclock); 1677 rn->rn_vp = NULL; 1678 mutex_exit(&reclock); 1679 genfs_node_destroy(vp); 1680 vp->v_data = NULL; 1681 1682 if (rn->rn_flags & RUMPNODE_CANRECLAIM) { 1683 if (vp->v_type == VREG 1684 && (rn->rn_flags & RUMPNODE_ET_PHONE_HOST) == 0 1685 && rn->rn_data) { 1686 if ((rn->rn_flags & RUMPNODE_EXTSTORAGE) == 0) { 1687 rump_hyperfree(rn->rn_data, rn->rn_dlen); 1688 } else { 1689 rn->rn_flags &= ~RUMPNODE_EXTSTORAGE; 1690 } 1691 rn->rn_data = NULL; 1692 } 1693 1694 if (vp->v_type == VLNK) 1695 PNBUF_PUT(rn->rn_linktarg); 1696 if (rn->rn_hostpath) 1697 free(rn->rn_hostpath, M_TEMP); 1698 freeprivate(rn); 1699 } 1700 1701 return 0; 1702 } 1703 1704 static int 1705 rump_vop_spec(void *v) 1706 { 1707 struct vop_generic_args *ap = v; 1708 int (**opvec)(void *); 1709 1710 switch (ap->a_desc->vdesc_offset) { 1711 case VOP_ACCESS_DESCOFFSET: 1712 case VOP_GETATTR_DESCOFFSET: 1713 case VOP_SETATTR_DESCOFFSET: 1714 case VOP_LOCK_DESCOFFSET: 1715 case VOP_UNLOCK_DESCOFFSET: 1716 case VOP_ISLOCKED_DESCOFFSET: 1717 case VOP_INACTIVE_DESCOFFSET: 1718 case VOP_RECLAIM_DESCOFFSET: 1719 opvec = rump_vnodeop_p; 1720 break; 1721 default: 1722 opvec = spec_vnodeop_p; 1723 break; 1724 } 1725 1726 return VOCALL(opvec, ap->a_desc->vdesc_offset, v); 1727 } 1728 1729 static int 1730 rump_vop_advlock(void *v) 1731 { 1732 struct vop_advlock_args /* { 1733 const struct vnodeop_desc *a_desc; 1734 struct vnode *a_vp; 1735 void *a_id; 1736 int a_op; 1737 struct flock *a_fl; 1738 int a_flags; 1739 } */ *ap = v; 1740 struct vnode *vp = ap->a_vp; 1741 struct rumpfs_node *rn = vp->v_data; 1742 1743 return lf_advlock(ap, &rn->rn_lockf, vp->v_size); 1744 } 1745 1746 static int 1747 rump_vop_fcntl(void *v) 1748 { 1749 struct vop_fcntl_args /* { 1750 struct vnode *a_vp; 1751 u_int a_command; 1752 void *a_data; 1753 int a_fflag; 1754 kauth_cred_t a_cred; 1755 } */ *ap = v; 1756 struct proc *p = curproc; 1757 struct vnode *vp = ap->a_vp; 1758 struct rumpfs_node *rn = vp->v_data; 1759 u_int cmd = ap->a_command; 1760 int fflag = ap->a_fflag; 1761 struct rumpfs_extstorage *rfse = ap->a_data; 1762 int error = 0; 1763 1764 /* none of the current rumpfs fcntlops are defined for remotes */ 1765 if (!RUMP_LOCALPROC_P(p)) 1766 return EINVAL; 1767 1768 switch (cmd) { 1769 case RUMPFS_FCNTL_EXTSTORAGE_ADD: 1770 break; 1771 default: 1772 return EINVAL; 1773 } 1774 1775 if ((fflag & FWRITE) == 0) 1776 return EBADF; 1777 1778 if (vp->v_type != VREG || (rn->rn_flags & RUMPNODE_ET_PHONE_HOST)) 1779 return EINVAL; 1780 1781 if (rfse->rfse_flags != 0) 1782 return EINVAL; 1783 1784 /* 1785 * Ok, we are good to go. Process. 1786 */ 1787 1788 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); 1789 1790 KASSERT(cmd == RUMPFS_FCNTL_EXTSTORAGE_ADD); 1791 if (rn->rn_data && (rn->rn_flags & RUMPNODE_EXTSTORAGE) == 0) { 1792 rump_hyperfree(rn->rn_data, rn->rn_dlen); 1793 } 1794 1795 rn->rn_data = rfse->rfse_data; 1796 rn->rn_dlen = rfse->rfse_dlen; 1797 uvm_vnp_setsize(vp, rn->rn_dlen); 1798 rn->rn_flags |= RUMPNODE_EXTSTORAGE; 1799 1800 VOP_UNLOCK(vp); 1801 1802 return error; 1803 } 1804 1805 /* 1806 * Begin vfs-level stuff 1807 */ 1808 1809 VFS_PROTOS(rumpfs); 1810 struct vfsops rumpfs_vfsops = { 1811 .vfs_name = MOUNT_RUMPFS, 1812 .vfs_min_mount_data = 0, 1813 .vfs_mount = rumpfs_mount, 1814 .vfs_start = (void *)nullop, 1815 .vfs_unmount = rumpfs_unmount, 1816 .vfs_root = rumpfs_root, 1817 .vfs_quotactl = (void *)eopnotsupp, 1818 .vfs_statvfs = genfs_statvfs, 1819 .vfs_sync = (void *)nullop, 1820 .vfs_vget = rumpfs_vget, 1821 .vfs_loadvnode = rumpfs_loadvnode, 1822 .vfs_fhtovp = (void *)eopnotsupp, 1823 .vfs_vptofh = (void *)eopnotsupp, 1824 .vfs_init = rumpfs_init, 1825 .vfs_reinit = NULL, 1826 .vfs_done = rumpfs_done, 1827 .vfs_mountroot = rumpfs_mountroot, 1828 .vfs_snapshot = (void *)eopnotsupp, 1829 .vfs_extattrctl = (void *)eopnotsupp, 1830 .vfs_suspendctl = genfs_suspendctl, 1831 .vfs_renamelock_enter = genfs_renamelock_enter, 1832 .vfs_renamelock_exit = genfs_renamelock_exit, 1833 .vfs_opv_descs = rump_opv_descs, 1834 /* vfs_refcount */ 1835 /* vfs_list */ 1836 }; 1837 1838 static int 1839 rumpfs_mountfs(struct mount *mp) 1840 { 1841 struct rumpfs_mount *rfsmp; 1842 struct rumpfs_node *rn; 1843 int error; 1844 1845 rfsmp = kmem_alloc(sizeof(*rfsmp), KM_SLEEP); 1846 1847 rn = makeprivate(VDIR, RUMPFS_DEFAULTMODE, NODEV, DEV_BSIZE, false); 1848 rn->rn_parent = rn; 1849 if ((error = vcache_get(mp, &rn, sizeof(rn), &rfsmp->rfsmp_rvp)) 1850 != 0) { 1851 freeprivate(rn); 1852 kmem_free(rfsmp, sizeof(*rfsmp)); 1853 return error; 1854 } 1855 1856 rfsmp->rfsmp_rvp->v_vflag |= VV_ROOT; 1857 1858 mp->mnt_data = rfsmp; 1859 mp->mnt_stat.f_namemax = RUMPFS_MAXNAMLEN; 1860 mp->mnt_stat.f_iosize = 512; 1861 mp->mnt_flag |= MNT_LOCAL; 1862 mp->mnt_iflag |= IMNT_MPSAFE | IMNT_CAN_RWTORO; 1863 mp->mnt_fs_bshift = DEV_BSHIFT; 1864 vfs_getnewfsid(mp); 1865 1866 return 0; 1867 } 1868 1869 int 1870 rumpfs_mount(struct mount *mp, const char *mntpath, void *arg, size_t *alen) 1871 { 1872 int error, flags; 1873 1874 if (mp->mnt_flag & MNT_GETARGS) { 1875 return 0; 1876 } 1877 if (mp->mnt_flag & MNT_UPDATE) { 1878 if ((mp->mnt_iflag & IMNT_WANTRDONLY)) { 1879 /* Changing from read/write to read-only. */ 1880 flags = WRITECLOSE; 1881 if ((mp->mnt_flag & MNT_FORCE)) 1882 flags |= FORCECLOSE; 1883 error = vflush(mp, NULL, flags); 1884 if (error) 1885 return error; 1886 } 1887 return 0; 1888 } 1889 1890 error = set_statvfs_info(mntpath, UIO_USERSPACE, "rumpfs", UIO_SYSSPACE, 1891 mp->mnt_op->vfs_name, mp, curlwp); 1892 if (error) 1893 return error; 1894 1895 return rumpfs_mountfs(mp); 1896 } 1897 1898 int 1899 rumpfs_unmount(struct mount *mp, int mntflags) 1900 { 1901 struct rumpfs_mount *rfsmp = mp->mnt_data; 1902 int flags = 0, error; 1903 1904 if (panicstr || mntflags & MNT_FORCE) 1905 flags |= FORCECLOSE; 1906 1907 if (rfsmp->rfsmp_rvp->v_usecount > 1 && (flags & FORCECLOSE) == 0) 1908 return EBUSY; 1909 1910 if ((error = vflush(mp, rfsmp->rfsmp_rvp, flags)) != 0) 1911 return error; 1912 vgone(rfsmp->rfsmp_rvp); 1913 1914 kmem_free(rfsmp, sizeof(*rfsmp)); 1915 1916 return 0; 1917 } 1918 1919 int 1920 rumpfs_root(struct mount *mp, int lktype, struct vnode **vpp) 1921 { 1922 struct rumpfs_mount *rfsmp = mp->mnt_data; 1923 1924 vref(rfsmp->rfsmp_rvp); 1925 vn_lock(rfsmp->rfsmp_rvp, lktype | LK_RETRY); 1926 *vpp = rfsmp->rfsmp_rvp; 1927 return 0; 1928 } 1929 1930 int 1931 rumpfs_vget(struct mount *mp, ino_t ino, int lktype, struct vnode **vpp) 1932 { 1933 1934 return EOPNOTSUPP; 1935 } 1936 1937 int 1938 rumpfs_loadvnode(struct mount *mp, struct vnode *vp, 1939 const void *key, size_t key_len, const void **new_key) 1940 { 1941 struct rumpfs_node *rn; 1942 struct vattr *va; 1943 1944 KASSERT(!mutex_owned(&reclock)); 1945 1946 KASSERT(key_len == sizeof(rn)); 1947 memcpy(&rn, key, key_len); 1948 1949 va = &rn->rn_va; 1950 1951 vp->v_tag = VT_RUMP; 1952 vp->v_type = va->va_type; 1953 switch (vp->v_type) { 1954 case VCHR: 1955 case VBLK: 1956 vp->v_op = rump_specop_p; 1957 spec_node_init(vp, va->va_rdev); 1958 break; 1959 default: 1960 vp->v_op = rump_vnodeop_p; 1961 break; 1962 } 1963 vp->v_size = vp->v_writesize = va->va_size; 1964 vp->v_data = rn; 1965 1966 genfs_node_init(vp, &rumpfs_genfsops); 1967 mutex_enter(&reclock); 1968 rn->rn_vp = vp; 1969 mutex_exit(&reclock); 1970 1971 *new_key = &vp->v_data; 1972 1973 return 0; 1974 } 1975 1976 void 1977 rumpfs_init() 1978 { 1979 extern rump_etfs_register_withsize_fn rump__etfs_register; 1980 extern rump_etfs_remove_fn rump__etfs_remove; 1981 extern struct rump_boot_etfs *ebstart; 1982 struct rump_boot_etfs *eb; 1983 1984 CTASSERT(RUMP_ETFS_SIZE_ENDOFF == RUMPBLK_SIZENOTSET); 1985 1986 mutex_init(&reclock, MUTEX_DEFAULT, IPL_NONE); 1987 mutex_init(&etfs_lock, MUTEX_DEFAULT, IPL_NONE); 1988 1989 rump__etfs_register = etfsregister; 1990 rump__etfs_remove = etfsremove; 1991 1992 for (eb = ebstart; eb; eb = eb->_eb_next) { 1993 eb->eb_status = etfsregister(eb->eb_key, eb->eb_hostpath, 1994 eb->eb_type, eb->eb_begin, eb->eb_size); 1995 } 1996 } 1997 1998 void 1999 rumpfs_done() 2000 { 2001 2002 mutex_destroy(&reclock); 2003 mutex_destroy(&etfs_lock); 2004 } 2005 2006 int 2007 rumpfs_mountroot() 2008 { 2009 struct mount *mp; 2010 int error; 2011 2012 if ((error = vfs_rootmountalloc(MOUNT_RUMPFS, "rootdev", &mp)) != 0) { 2013 vrele(rootvp); 2014 return error; 2015 } 2016 2017 if ((error = rumpfs_mountfs(mp)) != 0) 2018 panic("mounting rootfs failed: %d", error); 2019 2020 mountlist_append(mp); 2021 2022 error = set_statvfs_info("/", UIO_SYSSPACE, "rumpfs", UIO_SYSSPACE, 2023 mp->mnt_op->vfs_name, mp, curlwp); 2024 if (error) 2025 panic("set_statvfs_info failed for rootfs: %d", error); 2026 2027 mp->mnt_flag &= ~MNT_RDONLY; 2028 vfs_unbusy(mp); 2029 2030 return 0; 2031 } 2032
Indexes created Thu Oct 02 10:09:58 GMT 2025