rumpfs.c revision 1.79
1 /* $NetBSD: rumpfs.c,v 1.79 2011/01/01 19:47:22 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.79 2011/01/01 19:47: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 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 rumpfs_node *rn = ap->a_vp->v_data; 780 781 memcpy(&rn->rn_va, ap->a_vap, sizeof(struct vattr)); 782 uvm_vnp_setsize(ap->a_vp, ap->a_vap->va_size); 783 return 0; 784 } 785 786 static int 787 rump_vop_mkdir(void *v) 788 { 789 struct vop_mkdir_args /* { 790 struct vnode *a_dvp; 791 struct vnode **a_vpp; 792 struct componentname *a_cnp; 793 struct vattr *a_vap; 794 }; */ *ap = v; 795 struct vnode *dvp = ap->a_dvp; 796 struct vnode **vpp = ap->a_vpp; 797 struct componentname *cnp = ap->a_cnp; 798 struct rumpfs_node *rnd = dvp->v_data, *rn; 799 int rv = 0; 800 801 rn = makeprivate(VDIR, NODEV, DEV_BSIZE, false); 802 rn->rn_parent = rnd; 803 rv = makevnode(dvp->v_mount, rn, vpp); 804 if (rv) 805 goto out; 806 807 makedir(rnd, cnp, rn); 808 809 out: 810 vput(dvp); 811 return rv; 812 } 813 814 static int 815 rump_vop_rmdir(void *v) 816 { 817 struct vop_rmdir_args /* { 818 struct vnode *a_dvp; 819 struct vnode *a_vp; 820 struct componentname *a_cnp; 821 }; */ *ap = v; 822 struct vnode *dvp = ap->a_dvp; 823 struct vnode *vp = ap->a_vp; 824 struct componentname *cnp = ap->a_cnp; 825 struct rumpfs_node *rnd = dvp->v_data; 826 struct rumpfs_node *rn = vp->v_data; 827 int rv = 0; 828 829 if (!LIST_EMPTY(&rn->rn_dir)) { 830 rv = ENOTEMPTY; 831 goto out; 832 } 833 834 freedir(rnd, cnp); 835 rn->rn_flags |= RUMPNODE_CANRECLAIM; 836 837 out: 838 vput(dvp); 839 vput(vp); 840 841 return rv; 842 } 843 844 static int 845 rump_vop_remove(void *v) 846 { 847 struct vop_rmdir_args /* { 848 struct vnode *a_dvp; 849 struct vnode *a_vp; 850 struct componentname *a_cnp; 851 }; */ *ap = v; 852 struct vnode *dvp = ap->a_dvp; 853 struct vnode *vp = ap->a_vp; 854 struct componentname *cnp = ap->a_cnp; 855 struct rumpfs_node *rnd = dvp->v_data; 856 struct rumpfs_node *rn = vp->v_data; 857 int rv = 0; 858 859 if (rn->rn_flags & RUMPNODE_ET_PHONE_HOST) 860 return EOPNOTSUPP; 861 862 if (vp->v_type == VREG) { 863 rump_hyperfree(rn->rn_data, rn->rn_dlen); 864 } 865 866 freedir(rnd, cnp); 867 rn->rn_flags |= RUMPNODE_CANRECLAIM; 868 869 vput(dvp); 870 vput(vp); 871 872 return rv; 873 } 874 875 static int 876 rump_vop_mknod(void *v) 877 { 878 struct vop_mknod_args /* { 879 struct vnode *a_dvp; 880 struct vnode **a_vpp; 881 struct componentname *a_cnp; 882 struct vattr *a_vap; 883 }; */ *ap = v; 884 struct vnode *dvp = ap->a_dvp; 885 struct vnode **vpp = ap->a_vpp; 886 struct componentname *cnp = ap->a_cnp; 887 struct vattr *va = ap->a_vap; 888 struct rumpfs_node *rnd = dvp->v_data, *rn; 889 int rv; 890 891 rn = makeprivate(va->va_type, va->va_rdev, DEV_BSIZE, false); 892 rv = makevnode(dvp->v_mount, rn, vpp); 893 if (rv) 894 goto out; 895 896 makedir(rnd, cnp, rn); 897 898 out: 899 vput(dvp); 900 return rv; 901 } 902 903 static int 904 rump_vop_create(void *v) 905 { 906 struct vop_create_args /* { 907 struct vnode *a_dvp; 908 struct vnode **a_vpp; 909 struct componentname *a_cnp; 910 struct vattr *a_vap; 911 }; */ *ap = v; 912 struct vnode *dvp = ap->a_dvp; 913 struct vnode **vpp = ap->a_vpp; 914 struct componentname *cnp = ap->a_cnp; 915 struct vattr *va = ap->a_vap; 916 struct rumpfs_node *rnd = dvp->v_data, *rn; 917 off_t newsize; 918 int rv; 919 920 newsize = va->va_type == VSOCK ? DEV_BSIZE : 0; 921 rn = makeprivate(va->va_type, NODEV, newsize, false); 922 rv = makevnode(dvp->v_mount, rn, vpp); 923 if (rv) 924 goto out; 925 926 makedir(rnd, cnp, rn); 927 928 out: 929 vput(dvp); 930 return rv; 931 } 932 933 static int 934 rump_vop_symlink(void *v) 935 { 936 struct vop_symlink_args /* { 937 struct vnode *a_dvp; 938 struct vnode **a_vpp; 939 struct componentname *a_cnp; 940 struct vattr *a_vap; 941 char *a_target; 942 }; */ *ap = v; 943 struct vnode *dvp = ap->a_dvp; 944 struct vnode **vpp = ap->a_vpp; 945 struct componentname *cnp = ap->a_cnp; 946 struct rumpfs_node *rnd = dvp->v_data, *rn; 947 const char *target = ap->a_target; 948 size_t linklen; 949 int rv; 950 951 linklen = strlen(target); 952 KASSERT(linklen < MAXPATHLEN); 953 rn = makeprivate(VLNK, NODEV, linklen, false); 954 rv = makevnode(dvp->v_mount, rn, vpp); 955 if (rv) 956 goto out; 957 958 makedir(rnd, cnp, rn); 959 960 KASSERT(linklen < MAXPATHLEN); 961 rn->rn_linktarg = PNBUF_GET(); 962 rn->rn_linklen = linklen; 963 strcpy(rn->rn_linktarg, target); 964 965 out: 966 vput(dvp); 967 return rv; 968 } 969 970 static int 971 rump_vop_readlink(void *v) 972 { 973 struct vop_readlink_args /* { 974 struct vnode *a_vp; 975 struct uio *a_uio; 976 kauth_cred_t a_cred; 977 }; */ *ap = v; 978 struct vnode *vp = ap->a_vp; 979 struct rumpfs_node *rn = vp->v_data; 980 struct uio *uio = ap->a_uio; 981 982 return uiomove(rn->rn_linktarg, rn->rn_linklen, uio); 983 } 984 985 static int 986 rump_vop_whiteout(void *v) 987 { 988 struct vop_whiteout_args /* { 989 struct vnode *a_dvp; 990 struct componentname *a_cnp; 991 int a_flags; 992 } */ *ap = v; 993 struct vnode *dvp = ap->a_dvp; 994 struct rumpfs_node *rnd = dvp->v_data; 995 struct componentname *cnp = ap->a_cnp; 996 int flags = ap->a_flags; 997 998 switch (flags) { 999 case LOOKUP: 1000 break; 1001 case CREATE: 1002 makedir(rnd, cnp, RUMPFS_WHITEOUT); 1003 break; 1004 case DELETE: 1005 cnp->cn_flags &= ~DOWHITEOUT; /* cargo culting never fails ? */ 1006 freedir(rnd, cnp); 1007 break; 1008 default: 1009 panic("unknown whiteout op %d", flags); 1010 } 1011 1012 return 0; 1013 } 1014 1015 static int 1016 rump_vop_open(void *v) 1017 { 1018 struct vop_open_args /* { 1019 struct vnode *a_vp; 1020 int a_mode; 1021 kauth_cred_t a_cred; 1022 } */ *ap = v; 1023 struct vnode *vp = ap->a_vp; 1024 struct rumpfs_node *rn = vp->v_data; 1025 int mode = ap->a_mode; 1026 int error = EINVAL; 1027 1028 if (vp->v_type != VREG || (rn->rn_flags & RUMPNODE_ET_PHONE_HOST) == 0) 1029 return 0; 1030 1031 if (mode & FREAD) { 1032 if (rn->rn_readfd != -1) 1033 return 0; 1034 rn->rn_readfd = rumpuser_open(rn->rn_hostpath, 1035 O_RDONLY, &error); 1036 } 1037 1038 if (mode & FWRITE) { 1039 if (rn->rn_writefd != -1) 1040 return 0; 1041 rn->rn_writefd = rumpuser_open(rn->rn_hostpath, 1042 O_WRONLY, &error); 1043 } 1044 1045 return error; 1046 } 1047 1048 /* simple readdir. event omits dotstuff and periods */ 1049 static int 1050 rump_vop_readdir(void *v) 1051 { 1052 struct vop_readdir_args /* { 1053 struct vnode *a_vp; 1054 struct uio *a_uio; 1055 kauth_cred_t a_cred; 1056 int *a_eofflag; 1057 off_t **a_cookies; 1058 int *a_ncookies; 1059 } */ *ap = v; 1060 struct vnode *vp = ap->a_vp; 1061 struct uio *uio = ap->a_uio; 1062 struct rumpfs_node *rnd = vp->v_data; 1063 struct rumpfs_dent *rdent; 1064 unsigned i; 1065 int rv = 0; 1066 1067 /* seek to current entry */ 1068 for (i = 0, rdent = LIST_FIRST(&rnd->rn_dir); 1069 (i < uio->uio_offset) && rdent; 1070 i++, rdent = LIST_NEXT(rdent, rd_entries)) 1071 continue; 1072 if (!rdent) 1073 goto out; 1074 1075 /* copy entries */ 1076 for (; rdent && uio->uio_resid > 0; 1077 rdent = LIST_NEXT(rdent, rd_entries), i++) { 1078 struct dirent dent; 1079 1080 strlcpy(dent.d_name, rdent->rd_name, sizeof(dent.d_name)); 1081 dent.d_namlen = strlen(dent.d_name); 1082 dent.d_reclen = _DIRENT_RECLEN(&dent, dent.d_namlen); 1083 1084 if (__predict_false(RDENT_ISWHITEOUT(rdent))) { 1085 dent.d_fileno = INO_WHITEOUT; 1086 dent.d_type = DT_WHT; 1087 } else { 1088 dent.d_fileno = rdent->rd_node->rn_va.va_fileid; 1089 dent.d_type = vtype2dt(rdent->rd_node->rn_va.va_type); 1090 } 1091 1092 if (uio->uio_resid < dent.d_reclen) { 1093 i--; 1094 break; 1095 } 1096 1097 rv = uiomove(&dent, dent.d_reclen, uio); 1098 if (rv) { 1099 i--; 1100 break; 1101 } 1102 } 1103 1104 out: 1105 if (ap->a_cookies) { 1106 *ap->a_ncookies = 0; 1107 *ap->a_cookies = NULL; 1108 } 1109 if (rdent) 1110 *ap->a_eofflag = 0; 1111 else 1112 *ap->a_eofflag = 1; 1113 uio->uio_offset = i; 1114 1115 return rv; 1116 } 1117 1118 static int 1119 etread(struct rumpfs_node *rn, struct uio *uio) 1120 { 1121 uint8_t *buf; 1122 size_t bufsize; 1123 ssize_t n; 1124 int error = 0; 1125 1126 bufsize = uio->uio_resid; 1127 buf = kmem_alloc(bufsize, KM_SLEEP); 1128 if ((n = rumpuser_pread(rn->rn_readfd, buf, bufsize, 1129 uio->uio_offset + rn->rn_offset, &error)) == -1) 1130 goto out; 1131 KASSERT(n <= bufsize); 1132 error = uiomove(buf, n, uio); 1133 1134 out: 1135 kmem_free(buf, bufsize); 1136 return error; 1137 1138 } 1139 1140 static int 1141 rump_vop_read(void *v) 1142 { 1143 struct vop_read_args /* { 1144 struct vnode *a_vp; 1145 struct uio *a_uio; 1146 int ioflags a_ioflag; 1147 kauth_cred_t a_cred; 1148 }; */ *ap = v; 1149 struct vnode *vp = ap->a_vp; 1150 struct rumpfs_node *rn = vp->v_data; 1151 struct uio *uio = ap->a_uio; 1152 const int advice = IO_ADV_DECODE(ap->a_ioflag); 1153 off_t chunk; 1154 int error = 0; 1155 1156 /* et op? */ 1157 if (rn->rn_flags & RUMPNODE_ET_PHONE_HOST) 1158 return etread(rn, uio); 1159 1160 /* otherwise, it's off to ubc with us */ 1161 while (uio->uio_resid > 0) { 1162 chunk = MIN(uio->uio_resid, (off_t)rn->rn_dlen-uio->uio_offset); 1163 if (chunk == 0) 1164 break; 1165 error = ubc_uiomove(&vp->v_uobj, uio, chunk, advice, 1166 UBC_READ | UBC_PARTIALOK | UBC_WANT_UNMAP(vp)?UBC_UNMAP:0); 1167 if (error) 1168 break; 1169 } 1170 1171 return error; 1172 } 1173 1174 static int 1175 etwrite(struct rumpfs_node *rn, struct uio *uio) 1176 { 1177 uint8_t *buf; 1178 size_t bufsize; 1179 ssize_t n; 1180 int error = 0; 1181 1182 bufsize = uio->uio_resid; 1183 buf = kmem_alloc(bufsize, KM_SLEEP); 1184 error = uiomove(buf, bufsize, uio); 1185 if (error) 1186 goto out; 1187 KASSERT(uio->uio_resid == 0); 1188 n = rumpuser_pwrite(rn->rn_writefd, buf, bufsize, 1189 (uio->uio_offset-bufsize) + rn->rn_offset, &error); 1190 if (n >= 0) { 1191 KASSERT(n <= bufsize); 1192 uio->uio_resid = bufsize - n; 1193 } 1194 1195 out: 1196 kmem_free(buf, bufsize); 1197 return error; 1198 } 1199 1200 static int 1201 rump_vop_write(void *v) 1202 { 1203 struct vop_read_args /* { 1204 struct vnode *a_vp; 1205 struct uio *a_uio; 1206 int ioflags a_ioflag; 1207 kauth_cred_t a_cred; 1208 }; */ *ap = v; 1209 struct vnode *vp = ap->a_vp; 1210 struct rumpfs_node *rn = vp->v_data; 1211 struct uio *uio = ap->a_uio; 1212 const int advice = IO_ADV_DECODE(ap->a_ioflag); 1213 void *olddata; 1214 size_t oldlen, newlen; 1215 off_t chunk; 1216 int error = 0; 1217 bool allocd = false; 1218 1219 if (ap->a_ioflag & IO_APPEND) 1220 uio->uio_offset = vp->v_size; 1221 1222 /* consult et? */ 1223 if (rn->rn_flags & RUMPNODE_ET_PHONE_HOST) 1224 return etwrite(rn, uio); 1225 1226 /* 1227 * Otherwise, it's a case of ubcmove. 1228 */ 1229 1230 /* 1231 * First, make sure we have enough storage. 1232 * 1233 * No, you don't need to tell me it's not very efficient. 1234 * No, it doesn't really support sparse files, just fakes it. 1235 */ 1236 newlen = uio->uio_offset + uio->uio_resid; 1237 oldlen = 0; /* XXXgcc */ 1238 olddata = NULL; 1239 if (rn->rn_dlen < newlen) { 1240 oldlen = rn->rn_dlen; 1241 olddata = rn->rn_data; 1242 1243 rn->rn_data = rump_hypermalloc(newlen, 0, true, "rumpfs"); 1244 rn->rn_dlen = newlen; 1245 memset(rn->rn_data, 0, newlen); 1246 memcpy(rn->rn_data, olddata, oldlen); 1247 allocd = true; 1248 uvm_vnp_setsize(vp, newlen); 1249 } 1250 1251 /* ok, we have enough stooorage. write */ 1252 while (uio->uio_resid > 0) { 1253 chunk = MIN(uio->uio_resid, (off_t)rn->rn_dlen-uio->uio_offset); 1254 if (chunk == 0) 1255 break; 1256 error = ubc_uiomove(&vp->v_uobj, uio, chunk, advice, 1257 UBC_WRITE | UBC_PARTIALOK | UBC_WANT_UNMAP(vp)?UBC_UNMAP:0); 1258 if (error) 1259 break; 1260 } 1261 1262 if (allocd) { 1263 if (error) { 1264 rump_hyperfree(rn->rn_data, newlen); 1265 rn->rn_data = olddata; 1266 rn->rn_dlen = oldlen; 1267 uvm_vnp_setsize(vp, oldlen); 1268 } else { 1269 rump_hyperfree(olddata, oldlen); 1270 } 1271 } 1272 1273 return error; 1274 } 1275 1276 static int 1277 rump_vop_bmap(void *v) 1278 { 1279 struct vop_bmap_args /* { 1280 struct vnode *a_vp; 1281 daddr_t a_bn; 1282 struct vnode **a_vpp; 1283 daddr_t *a_bnp; 1284 int *a_runp; 1285 } */ *ap = v; 1286 1287 /* 1:1 mapping */ 1288 if (ap->a_vpp) 1289 *ap->a_vpp = ap->a_vp; 1290 if (ap->a_bnp) 1291 *ap->a_bnp = ap->a_bn; 1292 if (ap->a_runp) 1293 *ap->a_runp = 16; 1294 1295 return 0; 1296 } 1297 1298 static int 1299 rump_vop_strategy(void *v) 1300 { 1301 struct vop_strategy_args /* { 1302 struct vnode *a_vp; 1303 struct buf *a_bp; 1304 } */ *ap = v; 1305 struct vnode *vp = ap->a_vp; 1306 struct rumpfs_node *rn = vp->v_data; 1307 struct buf *bp = ap->a_bp; 1308 off_t copylen, copyoff; 1309 int error; 1310 1311 if (vp->v_type != VREG || rn->rn_flags & RUMPNODE_ET_PHONE_HOST) { 1312 error = EINVAL; 1313 goto out; 1314 } 1315 1316 copyoff = bp->b_blkno << DEV_BSHIFT; 1317 copylen = MIN(rn->rn_dlen - copyoff, bp->b_bcount); 1318 if (BUF_ISWRITE(bp)) { 1319 memcpy((uint8_t *)rn->rn_data + copyoff, bp->b_data, copylen); 1320 } else { 1321 memset((uint8_t*)bp->b_data + copylen, 0, bp->b_bcount-copylen); 1322 memcpy(bp->b_data, (uint8_t *)rn->rn_data + copyoff, copylen); 1323 } 1324 bp->b_resid = 0; 1325 error = 0; 1326 1327 out: 1328 bp->b_error = error; 1329 biodone(bp); 1330 return 0; 1331 } 1332 1333 static int 1334 rump_vop_pathconf(void *v) 1335 { 1336 struct vop_pathconf_args /* { 1337 struct vnode *a_vp; 1338 int a_name; 1339 register_t *a_retval; 1340 }; */ *ap = v; 1341 int name = ap->a_name; 1342 register_t *retval = ap->a_retval; 1343 1344 switch (name) { 1345 case _PC_LINK_MAX: 1346 *retval = LINK_MAX; 1347 return 0; 1348 case _PC_NAME_MAX: 1349 *retval = NAME_MAX; 1350 return 0; 1351 case _PC_PATH_MAX: 1352 *retval = PATH_MAX; 1353 return 0; 1354 case _PC_PIPE_BUF: 1355 *retval = PIPE_BUF; 1356 return 0; 1357 case _PC_CHOWN_RESTRICTED: 1358 *retval = 1; 1359 return 0; 1360 case _PC_NO_TRUNC: 1361 *retval = 1; 1362 return 0; 1363 case _PC_SYNC_IO: 1364 *retval = 1; 1365 return 0; 1366 case _PC_FILESIZEBITS: 1367 *retval = 43; /* this one goes to 11 */ 1368 return 0; 1369 case _PC_SYMLINK_MAX: 1370 *retval = MAXPATHLEN; 1371 return 0; 1372 case _PC_2_SYMLINKS: 1373 *retval = 1; 1374 return 0; 1375 default: 1376 return EINVAL; 1377 } 1378 } 1379 1380 static int 1381 rump_vop_success(void *v) 1382 { 1383 1384 return 0; 1385 } 1386 1387 static int 1388 rump_vop_inactive(void *v) 1389 { 1390 struct vop_inactive_args /* { 1391 struct vnode *a_vp; 1392 bool *a_recycle; 1393 } */ *ap = v; 1394 struct vnode *vp = ap->a_vp; 1395 struct rumpfs_node *rn = vp->v_data; 1396 int error; 1397 1398 if (rn->rn_flags & RUMPNODE_ET_PHONE_HOST && vp->v_type == VREG) { 1399 if (rn->rn_readfd != -1) { 1400 rumpuser_close(rn->rn_readfd, &error); 1401 rn->rn_readfd = -1; 1402 } 1403 if (rn->rn_writefd != -1) { 1404 rumpuser_close(rn->rn_writefd, &error); 1405 rn->rn_writefd = -1; 1406 } 1407 } 1408 *ap->a_recycle = (rn->rn_flags & RUMPNODE_CANRECLAIM) ? true : false; 1409 1410 VOP_UNLOCK(vp); 1411 return 0; 1412 } 1413 1414 static int 1415 rump_vop_reclaim(void *v) 1416 { 1417 struct vop_reclaim_args /* { 1418 struct vnode *a_vp; 1419 } */ *ap = v; 1420 struct vnode *vp = ap->a_vp; 1421 struct rumpfs_node *rn = vp->v_data; 1422 1423 mutex_enter(&reclock); 1424 rn->rn_vp = NULL; 1425 mutex_exit(&reclock); 1426 genfs_node_destroy(vp); 1427 vp->v_data = NULL; 1428 1429 if (rn->rn_flags & RUMPNODE_CANRECLAIM) { 1430 if (vp->v_type == VLNK) 1431 PNBUF_PUT(rn->rn_linktarg); 1432 if (rn->rn_hostpath) 1433 free(rn->rn_hostpath, M_TEMP); 1434 kmem_free(rn, sizeof(*rn)); 1435 } 1436 1437 return 0; 1438 } 1439 1440 static int 1441 rump_vop_spec(void *v) 1442 { 1443 struct vop_generic_args *ap = v; 1444 int (**opvec)(void *); 1445 1446 switch (ap->a_desc->vdesc_offset) { 1447 case VOP_ACCESS_DESCOFFSET: 1448 case VOP_GETATTR_DESCOFFSET: 1449 case VOP_SETATTR_DESCOFFSET: 1450 case VOP_LOCK_DESCOFFSET: 1451 case VOP_UNLOCK_DESCOFFSET: 1452 case VOP_ISLOCKED_DESCOFFSET: 1453 case VOP_RECLAIM_DESCOFFSET: 1454 opvec = rump_vnodeop_p; 1455 break; 1456 default: 1457 opvec = spec_vnodeop_p; 1458 break; 1459 } 1460 1461 return VOCALL(opvec, ap->a_desc->vdesc_offset, v); 1462 } 1463 1464 /* 1465 * Begin vfs-level stuff 1466 */ 1467 1468 VFS_PROTOS(rumpfs); 1469 struct vfsops rumpfs_vfsops = { 1470 .vfs_name = MOUNT_RUMPFS, 1471 .vfs_min_mount_data = 0, 1472 .vfs_mount = rumpfs_mount, 1473 .vfs_start = (void *)nullop, 1474 .vfs_unmount = rumpfs_unmount, 1475 .vfs_root = rumpfs_root, 1476 .vfs_quotactl = (void *)eopnotsupp, 1477 .vfs_statvfs = genfs_statvfs, 1478 .vfs_sync = (void *)nullop, 1479 .vfs_vget = rumpfs_vget, 1480 .vfs_fhtovp = (void *)eopnotsupp, 1481 .vfs_vptofh = (void *)eopnotsupp, 1482 .vfs_init = rumpfs_init, 1483 .vfs_reinit = NULL, 1484 .vfs_done = rumpfs_done, 1485 .vfs_mountroot = rumpfs_mountroot, 1486 .vfs_snapshot = (void *)eopnotsupp, 1487 .vfs_extattrctl = (void *)eopnotsupp, 1488 .vfs_suspendctl = (void *)eopnotsupp, 1489 .vfs_renamelock_enter = genfs_renamelock_enter, 1490 .vfs_renamelock_exit = genfs_renamelock_exit, 1491 .vfs_opv_descs = rump_opv_descs, 1492 /* vfs_refcount */ 1493 /* vfs_list */ 1494 }; 1495 1496 static int 1497 rumpfs_mountfs(struct mount *mp) 1498 { 1499 struct rumpfs_mount *rfsmp; 1500 struct rumpfs_node *rn; 1501 int error; 1502 1503 rfsmp = kmem_alloc(sizeof(*rfsmp), KM_SLEEP); 1504 1505 rn = makeprivate(VDIR, NODEV, DEV_BSIZE, false); 1506 rn->rn_parent = rn; 1507 if ((error = makevnode(mp, rn, &rfsmp->rfsmp_rvp)) != 0) 1508 return error; 1509 1510 rfsmp->rfsmp_rvp->v_vflag |= VV_ROOT; 1511 VOP_UNLOCK(rfsmp->rfsmp_rvp); 1512 1513 mp->mnt_data = rfsmp; 1514 mp->mnt_stat.f_namemax = MAXNAMLEN; 1515 mp->mnt_stat.f_iosize = 512; 1516 mp->mnt_flag |= MNT_LOCAL; 1517 mp->mnt_iflag |= IMNT_MPSAFE; 1518 mp->mnt_fs_bshift = DEV_BSHIFT; 1519 vfs_getnewfsid(mp); 1520 1521 return 0; 1522 } 1523 1524 int 1525 rumpfs_mount(struct mount *mp, const char *mntpath, void *arg, size_t *alen) 1526 { 1527 int error; 1528 1529 error = set_statvfs_info(mntpath, UIO_USERSPACE, "rumpfs", UIO_SYSSPACE, 1530 mp->mnt_op->vfs_name, mp, curlwp); 1531 if (error) 1532 return error; 1533 1534 return rumpfs_mountfs(mp); 1535 } 1536 1537 int 1538 rumpfs_unmount(struct mount *mp, int mntflags) 1539 { 1540 struct rumpfs_mount *rfsmp = mp->mnt_data; 1541 int flags = 0, error; 1542 1543 if (panicstr || mntflags & MNT_FORCE) 1544 flags |= FORCECLOSE; 1545 1546 if ((error = vflush(mp, rfsmp->rfsmp_rvp, flags)) != 0) 1547 return error; 1548 vgone(rfsmp->rfsmp_rvp); /* XXX */ 1549 1550 kmem_free(rfsmp, sizeof(*rfsmp)); 1551 1552 return 0; 1553 } 1554 1555 int 1556 rumpfs_root(struct mount *mp, struct vnode **vpp) 1557 { 1558 struct rumpfs_mount *rfsmp = mp->mnt_data; 1559 1560 vref(rfsmp->rfsmp_rvp); 1561 vn_lock(rfsmp->rfsmp_rvp, LK_EXCLUSIVE | LK_RETRY); 1562 *vpp = rfsmp->rfsmp_rvp; 1563 return 0; 1564 } 1565 1566 int 1567 rumpfs_vget(struct mount *mp, ino_t ino, struct vnode **vpp) 1568 { 1569 1570 return EOPNOTSUPP; 1571 } 1572 1573 void 1574 rumpfs_init() 1575 { 1576 1577 CTASSERT(RUMP_ETFS_SIZE_ENDOFF == RUMPBLK_SIZENOTSET); 1578 1579 mutex_init(&reclock, MUTEX_DEFAULT, IPL_NONE); 1580 mutex_init(&etfs_lock, MUTEX_DEFAULT, IPL_NONE); 1581 } 1582 1583 void 1584 rumpfs_done() 1585 { 1586 1587 mutex_destroy(&reclock); 1588 mutex_destroy(&etfs_lock); 1589 } 1590 1591 int 1592 rumpfs_mountroot() 1593 { 1594 struct mount *mp; 1595 int error; 1596 1597 if ((error = vfs_rootmountalloc(MOUNT_RUMPFS, "rootdev", &mp)) != 0) { 1598 vrele(rootvp); 1599 return error; 1600 } 1601 1602 if ((error = rumpfs_mountfs(mp)) != 0) 1603 panic("mounting rootfs failed: %d", error); 1604 1605 mutex_enter(&mountlist_lock); 1606 CIRCLEQ_INSERT_TAIL(&mountlist, mp, mnt_list); 1607 mutex_exit(&mountlist_lock); 1608 1609 error = set_statvfs_info("/", UIO_SYSSPACE, "rumpfs", UIO_SYSSPACE, 1610 mp->mnt_op->vfs_name, mp, curlwp); 1611 if (error) 1612 panic("set_statvfs_info failed for rootfs: %d", error); 1613 1614 vfs_unbusy(mp, false, NULL); 1615 1616 return 0; 1617 } 1618
Indexes created Tue Sep 30 20:09:53 GMT 2025