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