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