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