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