static void dir_rmdirdotdot(const atf_tc_t *tc, const char *mp) { char pb[MAXPATHLEN]; int xerrno; USES_DIRS; FSTEST_ENTER(); RL(rump_sys_mkdir("test", 0777)); RL(rump_sys_chdir("test")); RL(rump_sys_mkdir("subtest", 0777)); RL(rump_sys_chdir("subtest")); md(pb, mp, "test/subtest"); RL(rump_sys_rmdir(pb)); md(pb, mp, "test"); RL(rump_sys_rmdir(pb)); if (FSTYPE_NFS(tc)) xerrno = ESTALE; else xerrno = ENOENT; ATF_REQUIRE_ERRNO(xerrno, rump_sys_chdir("..") == -1); FSTEST_EXIT(); }
ATF_TC_BODY(multilayer, tc) { struct union_args unionargs; rump_init(); if (rump_sys_mkdir("/Tunion", 0777) == -1) atf_tc_fail_errno("mkdir mp1"); if (rump_sys_mkdir("/Tunion2", 0777) == -1) atf_tc_fail_errno("mkdir mp2"); if (rump_sys_mkdir("/Tunion2/A", 0777) == -1) atf_tc_fail_errno("mkdir A"); if (rump_sys_mkdir("/Tunion2/B", 0777) == -1) atf_tc_fail_errno("mkdir B"); unionargs.target = __UNCONST("/Tunion2/A"); unionargs.mntflags = UNMNT_BELOW; if (rump_sys_mount(MOUNT_UNION, "/Tunion", 0, &unionargs, sizeof(unionargs)) == -1) atf_tc_fail_errno("union mount"); unionargs.target = __UNCONST("/Tunion2/B"); unionargs.mntflags = UNMNT_BELOW; rump_sys_mount(MOUNT_UNION, "/Tunion", 0,&unionargs,sizeof(unionargs)); }
static void rename_dotdot(const atf_tc_t *tc, const char *mp) { if (FSTYPE_RUMPFS(tc)) atf_tc_skip("rename not supported by file system"); USES_DIRS; if (rump_sys_chdir(mp) == -1) atf_tc_fail_errno("chdir mountpoint"); if (rump_sys_mkdir("dir1", 0777) == -1) atf_tc_fail_errno("mkdir 1"); if (rump_sys_mkdir("dir2", 0777) == -1) atf_tc_fail_errno("mkdir 2"); if (rump_sys_rename("dir1", "dir1/..") != -1 || errno != EINVAL) atf_tc_fail_errno("self-dotdot to"); if (rump_sys_rename("dir1/..", "sometarget") != -1 || errno != EINVAL) atf_tc_fail_errno("self-dotdot from"); if (rump_sys_rename("dir1", "dir2/..") != -1 || errno != EINVAL) atf_tc_fail("other-dotdot"); rump_sys_chdir("/"); }
ATF_TC_BODY(nullrevoke, tc) { char path[MAXPATHLEN]; struct ptmget ptg; int ptm; rump_init(); /* * mount /dev/pts */ mountptyfs("/dev/pts", 0); /* * null mount /dev/pts to /null/dev/pts */ if (rump_sys_mkdir("/null", 0777) == -1) { if (errno != EEXIST) atf_tc_fail_errno("null create /null"); } if (rump_sys_mkdir("/null/dev", 0777) == -1) { if (errno != EEXIST) atf_tc_fail_errno("null create /null/dev"); } mountnull("/dev/pts", "/null/dev/pts", 0); /* * get slave/master pair. */ ptm = rump_sys_open("/dev/ptm", O_RDWR); if (rump_sys_ioctl(ptm, TIOCPTMGET, &ptg) == -1) atf_tc_fail_errno("get pty"); /* * Build nullfs path to slave. */ strcpy(path, "/null"); strcat(path, ptg.sn); /* * Open slave tty via nullfs. */ if (rump_sys_open(path, O_RDWR) == -1) atf_tc_fail_errno("slave null open"); /* * Close slave opened with /dev/ptm. Need purely non-null refs to it. */ rump_sys_close(ptg.sfd); /* revoke slave tty. */ rump_sys_revoke(path); /* done */ }
static void dir_notempty(const atf_tc_t *tc, const char *mountpath) { char pb[MAXPATHLEN], pb2[MAXPATHLEN]; int fd, rv; USES_DIRS; /* check we can create directories */ sprintf(pb, "%s/dir", mountpath); if (rump_sys_mkdir(pb, 0777) == -1) atf_tc_fail_errno("mkdir"); sprintf(pb2, "%s/dir/file", mountpath); fd = rump_sys_open(pb2, O_RDWR | O_CREAT, 0777); if (fd == -1) atf_tc_fail_errno("create file"); rump_sys_close(fd); rv = rump_sys_rmdir(pb); if (FSTYPE_ZFS(tc)) atf_tc_expect_fail("PR kern/47656: Test known to be broken"); if (rv != -1 || errno != ENOTEMPTY) atf_tc_fail("non-empty directory removed succesfully"); if (rump_sys_unlink(pb2) == -1) atf_tc_fail_errno("cannot remove dir/file"); if (rump_sys_rmdir(pb) == -1) atf_tc_fail_errno("remove directory"); }
ATF_TC_BODY(makecn, tc) { struct componentname *cn; char pathstr[MAXPATHLEN] = TESTFILE; struct vnode *vp; extern struct vnode *rumpns_rootvnode; rump_init(); /* * Strategy is to create a componentname, edit the passed * string, and then do a lookup with the componentname. */ RL(rump_sys_mkdir("/" TESTFILE, 0777)); /* need stable lwp for componentname */ RZ(rump_pub_lwproc_rfork(RUMP_RFCFDG)); /* try it once with the right path */ cn = rump_pub_makecn(RUMP_NAMEI_LOOKUP, 0, pathstr, strlen(pathstr), rump_pub_cred_create(0, 0, 0, NULL), rump_pub_lwproc_curlwp()); RZ(RUMP_VOP_LOOKUP(rumpns_rootvnode, &vp, cn)); rump_pub_freecn(cn, RUMPCN_FREECRED); /* and then with modification-in-the-middle */ cn = rump_pub_makecn(RUMP_NAMEI_LOOKUP, 0, pathstr, strlen(pathstr), rump_pub_cred_create(0, 0, 0, NULL), rump_pub_lwproc_curlwp()); strcpy(pathstr, "/muuta"); RZ(RUMP_VOP_LOOKUP(rumpns_rootvnode, &vp, cn)); rump_pub_freecn(cn, RUMPCN_FREECRED); }
ATF_TC_BODY(devnull2, tc) { struct union_args unionargs; int fd, res; rump_init(); if (rump_sys_mkdir("/mp", 0777) == -1) atf_tc_fail_errno("mkdir mp"); unionargs.target = __UNCONST("/dev"); unionargs.mntflags = UNMNT_BELOW; if (rump_sys_mount(MOUNT_UNION, "/mp", 0, &unionargs, sizeof(unionargs)) == -1) atf_tc_fail_errno("union mount"); fd = rump_sys_open("/mp/null", O_WRONLY | O_CREAT | O_APPEND); if (fd == -1) atf_tc_fail_errno("open"); res = rump_sys_write(fd, &fd, sizeof(fd)); if (res != sizeof(fd)) atf_tc_fail("write"); }
int lfs_fstest_mount(const atf_tc_t *tc, void *buf, const char *path, int flags) { struct lfstestargs *args = buf; int res; res = rump_sys_mkdir(path, 0777); if (res == -1) return res; res = rump_sys_mount(MOUNT_LFS, path, flags, &args->ta_uargs, sizeof(args->ta_uargs)); if (res == -1) return res; strcpy(args->ta_mntpath, path); res = pthread_create(&args->ta_cleanerthread, NULL, cleaner, args); if (res) return res; /* wait for cleaner to initialize */ sem_wait(&args->ta_cleanerloop); return 0; }
ATF_TC_BODY(key, tc) { RZ(rump_init()); RL(open("hostfile", O_RDWR | O_CREAT, 0777)); RZ(rump_pub_etfs_register("/key", "hostfile", RUMP_ETFS_REG)); ATF_REQUIRE_EQ(rump_pub_etfs_register("key", "hostfile", RUMP_ETFS_REG), EINVAL); RL(rump_sys_open("/key", O_RDONLY)); RL(rump_sys_open("////////key", O_RDONLY)); RZ(rump_pub_etfs_register("////key//with/slashes", "hostfile", RUMP_ETFS_REG)); RL(rump_sys_open("/key//with/slashes", O_RDONLY)); RL(rump_sys_open("key//with/slashes", O_RDONLY)); ATF_REQUIRE_ERRNO(ENOENT, rump_sys_open("/key/with/slashes", O_RDONLY) == -1); RL(rump_sys_mkdir("/a", 0777)); ATF_REQUIRE_ERRNO(ENOENT, rump_sys_open("/a/key//with/slashes", O_RDONLY) == -1); }
static void lookup_complex(const atf_tc_t *tc, const char *mountpath) { char pb[MAXPATHLEN]; struct stat sb1, sb2; USES_DIRS; if (FSTYPE_UDF(tc)) atf_tc_expect_fail("PR kern/49033"); sprintf(pb, "%s/dir", mountpath); if (rump_sys_mkdir(pb, 0777) == -1) atf_tc_fail_errno("mkdir"); if (rump_sys_stat(pb, &sb1) == -1) atf_tc_fail_errno("stat 1"); sprintf(pb, "%s/./dir/../././dir/.", mountpath); if (rump_sys_stat(pb, &sb2) == -1) atf_tc_fail_errno("stat 2"); if (memcmp(&sb1, &sb2, sizeof(sb1)) != 0) { printf("what\tsb1\t\tsb2\n"); #define FIELD(FN) \ printf(#FN "\t%lld\t%lld\n", \ (long long)sb1.FN, (long long)sb2.FN) #define TIME(FN) \ printf(#FN "\t%lld.%ld\t%lld.%ld\n", \ (long long)sb1.FN.tv_sec, sb1.FN.tv_nsec, \ (long long)sb2.FN.tv_sec, sb2.FN.tv_nsec) FIELD(st_dev); FIELD(st_mode); FIELD(st_ino); FIELD(st_nlink); FIELD(st_uid); FIELD(st_gid); FIELD(st_rdev); TIME(st_atim); TIME(st_mtim); TIME(st_ctim); TIME(st_birthtim); FIELD(st_size); FIELD(st_blocks); FIELD(st_flags); FIELD(st_gen); #undef FIELD #undef TIME atf_tc_fail("stat results differ, see ouput for more details"); } if (FSTYPE_UDF(tc)) atf_tc_fail("random failure of PR kern/49033 " "did not happen this time"); }
static void mountnull(const char *what, const char *mp, int flags) { struct null_args nargs; if (rump_sys_mkdir(what, 0777) == -1) { if (errno != EEXIST) atf_tc_fail_errno("null create %s", what); } if (rump_sys_mkdir(mp, 0777) == -1) { if (errno != EEXIST) atf_tc_fail_errno("null create %s", mp); } memset(&nargs, 0, sizeof(nargs)); nargs.nulla_target = __UNCONST(what); if (rump_sys_mount(MOUNT_NULL, mp, flags, &nargs, sizeof(nargs)) == -1) atf_tc_fail_errno("could not mount nullfs"); }
int msdosfs_fstest_mount(const atf_tc_t *tc, void *buf, const char *path, int flags) { int res; struct msdosfstestargs *args = buf; res = rump_sys_mkdir(path, 0777); if (res == -1) return res; res = rump_sys_mount(MOUNT_MSDOS, path, flags, &args->ta_uargs, sizeof(args->ta_uargs)); return res; }
static void mountptyfs(const char *mp, int flags) { struct ptyfs_args args; if (rump_sys_mkdir(mp, 0777) == -1) { if (errno != EEXIST) atf_tc_fail_errno("null create %s", mp); } memset(&args, 0, sizeof(args)); args.version = PTYFS_ARGSVERSION; args.mode = 0777; if (rump_sys_mount(MOUNT_PTYFS, mp, flags, &args, sizeof(args)) == -1) atf_tc_fail_errno("could not mount ptyfs"); }
int main(int argc, char *argv[]) { struct rump_ufs_args args; char imgpath[MAXPATHLEN+1]; union u u; char buf[8192]; int fd; /* * the driver doesn't support endian swapping, so pick image * with matching endianness. */ u.i = 0x12345678; if (u.c == 0x12) { snprintf(imgpath, sizeof(imgpath), "%s/%s", argv[1], "sysvbfs_be.img"); } else { snprintf(imgpath, sizeof(imgpath), "%s/%s", argv[1], "sysvbfs_le.img"); } rump_init(); #define MYFSDEV "/de-vice" rump_pub_etfs_register(MYFSDEV, imgpath, RUMP_ETFS_BLK); args.fspec = (void *)(uintptr_t)MYFSDEV; if (rump_sys_mkdir("/mnt", 0755) == -1) die("mkdir /mnt"); if (rump_sys_mount(RUMP_MOUNT_SYSVBFS, "/mnt", RUMP_MNT_RDONLY, &args, sizeof(args)) == -1) die("mount"); if ((fd = rump_sys_open("/mnt/README", 0)) == -1) die("open file"); memset(buf, 0, sizeof(buf)); if (rump_sys_read(fd, buf, sizeof(buf)) <= 0) die("read version"); if (strcmp(buf, EXPECTED) != 0) die("got unexpected result"); rump_sys_close(fd); if (rump_sys_unmount("/mnt", 0) == -1) die("unmount failed"); return 0; }
static void dirperms(const atf_tc_t *tc, const char *mp) { char name[] = "dir.test/file.test"; char *dir = dirname(name); int fd; if (FSTYPE_SYSVBFS(tc)) atf_tc_skip("directories not supported by file system"); FSTEST_ENTER(); if (rump_sys_mkdir(dir, 0777) == -1) atf_tc_fail_errno("mkdir"); rump_pub_lwproc_rfork(RUMP_RFCFDG); if (rump_sys_setuid(1) == -1) atf_tc_fail_errno("setuid"); if (FSTYPE_ZFS(tc)) atf_tc_expect_fail("PR kern/47656: Test known to be broken"); if (rump_sys_open(name, O_RDWR|O_CREAT, 0666) != -1 || errno != EACCES) atf_tc_fail_errno("open"); rump_pub_lwproc_releaselwp(); if ((fd = rump_sys_open(name, O_RDWR|O_CREAT, 0666)) == -1) atf_tc_fail_errno("open"); if (rump_sys_close(fd) == -1) atf_tc_fail_errno("close"); rump_pub_lwproc_rfork(RUMP_RFCFDG); if (rump_sys_setuid(1) == -1) atf_tc_fail_errno("setuid"); if (rump_sys_unlink(name) != -1 || errno != EACCES) atf_tc_fail_errno("unlink"); rump_pub_lwproc_releaselwp(); if (rump_sys_unlink(name) == -1) atf_tc_fail_errno("unlink"); if (rump_sys_rmdir(dir) == -1) atf_tc_fail_errno("rmdir"); FSTEST_EXIT(); }
static void lookup_complex(const atf_tc_t *tc, const char *mountpath) { char pb[MAXPATHLEN]; struct stat sb1, sb2; USES_DIRS; sprintf(pb, "%s/dir", mountpath); if (rump_sys_mkdir(pb, 0777) == -1) atf_tc_fail_errno("mkdir"); if (rump_sys_stat(pb, &sb1) == -1) atf_tc_fail_errno("stat 1"); sprintf(pb, "%s/./dir/../././dir/.", mountpath); if (rump_sys_stat(pb, &sb2) == -1) atf_tc_fail_errno("stat 2"); ATF_REQUIRE(memcmp(&sb1, &sb2, sizeof(sb1)) == 0); }
static void dir_simple(const atf_tc_t *tc, const char *mountpath) { char pb[MAXPATHLEN]; struct stat sb; USES_DIRS; /* check we can create directories */ sprintf(pb, "%s/dir", mountpath); if (rump_sys_mkdir(pb, 0777) == -1) atf_tc_fail_errno("mkdir"); if (rump_sys_stat(pb, &sb) == -1) atf_tc_fail_errno("stat new directory"); /* check we can remove then and that it makes them unreachable */ if (rump_sys_rmdir(pb) == -1) atf_tc_fail_errno("rmdir"); if (rump_sys_stat(pb, &sb) != -1 || errno != ENOENT) atf_tc_fail("ENOENT expected from stat"); }
int main() { char buf[8192]; int fd; rump_init(); if (rump_sys_mkdir("/kern", 0755) == -1) die("mkdir /kern"); if (rump_sys_mount("kernfs", "/kern", 0, NULL, 0) == -1) die("mount kernfs"); if ((fd = rump_sys_open("/kern/version", 0)) == -1) die("open /kern/version"); printf("\nReading version info from /kern:\n"); if (rump_sys_read(fd, buf, sizeof(buf)) <= 0) die("read version"); printf("\n%s", buf); rump_sys_reboot(0, NULL); return 0; }
void rumpkern_demo(void) { char buf[256]; ssize_t nn; int fd, rv; printk(KERN_INFO "reading rump kernel version from kernfs/version:\n"); rv = rump_sys_mkdir("/mnt", 0777); BUG_ON(rv == -1); rv = rump_sys_mount("kernfs", "/mnt", 0, NULL, 0); BUG_ON(rv == -1); fd = rump_sys_open("/mnt/version", RUMP_O_RDONLY, 0); BUG_ON(rv == -1); nn = rump_sys_read(fd, buf, sizeof(buf)); BUG_ON(nn < 1); buf[nn] = '\0'; printk(KERN_INFO "%s", buf); }
static void rename_dir(const atf_tc_t *tc, const char *mp) { char pb1[MAXPATHLEN], pb2[MAXPATHLEN], pb3[MAXPATHLEN]; struct stat ref, sb; if (FSTYPE_RUMPFS(tc)) atf_tc_skip("rename not supported by file system"); USES_DIRS; md(pb1, mp, "dir1"); if (rump_sys_mkdir(pb1, 0777) == -1) atf_tc_fail_errno("mkdir 1"); md(pb2, mp, "dir2"); if (rump_sys_mkdir(pb2, 0777) == -1) atf_tc_fail_errno("mkdir 2"); md(pb2, mp, "dir2/subdir"); if (rump_sys_mkdir(pb2, 0777) == -1) atf_tc_fail_errno("mkdir 3"); md(pb3, mp, "dir1/file"); if (rump_sys_mknod(pb3, S_IFREG | 0777, -1) == -1) atf_tc_fail_errno("create file"); if (rump_sys_stat(pb3, &ref) == -1) atf_tc_fail_errno("stat of file"); /* * First try ops which should succeed. */ /* rename within directory */ md(pb3, mp, "dir3"); if (rump_sys_rename(pb1, pb3) == -1) atf_tc_fail_errno("rename 1"); checkfile(pb3, &ref); /* rename directory onto itself (two ways, should fail) */ md(pb1, mp, "dir3/."); if (rump_sys_rename(pb1, pb3) != -1 || errno != EINVAL) atf_tc_fail_errno("rename 2"); if (FSTYPE_ZFS(tc)) atf_tc_expect_fail("PR kern/47656: Test known to be broken"); if (rump_sys_rename(pb3, pb1) != -1 || errno != EISDIR) atf_tc_fail_errno("rename 3"); checkfile(pb3, &ref); /* rename father of directory into directory */ md(pb1, mp, "dir2/dir"); md(pb2, mp, "dir2"); if (rump_sys_rename(pb2, pb1) != -1 || errno != EINVAL) atf_tc_fail_errno("rename 4"); /* same for grandfather */ md(pb1, mp, "dir2/subdir/dir2"); if (rump_sys_rename(pb2, pb1) != -1 || errno != EINVAL) atf_tc_fail("rename 5"); checkfile(pb3, &ref); /* rename directory over a non-empty directory */ if (rump_sys_rename(pb2, pb3) != -1 || errno != ENOTEMPTY) atf_tc_fail("rename 6"); /* cross-directory rename */ md(pb1, mp, "dir3"); md(pb2, mp, "dir2/somedir"); if (rump_sys_rename(pb1, pb2) == -1) atf_tc_fail_errno("rename 7"); checkfile(pb2, &ref); /* move to parent directory */ md(pb1, mp, "dir2/somedir/../../dir3"); if (rump_sys_rename(pb2, pb1) == -1) atf_tc_fail_errno("rename 8"); md(pb1, mp, "dir2/../dir3"); checkfile(pb1, &ref); /* atomic cross-directory rename */ md(pb3, mp, "dir2/subdir"); if (rump_sys_rename(pb1, pb3) == -1) atf_tc_fail_errno("rename 9"); checkfile(pb3, &ref); /* rename directory over an empty directory */ md(pb1, mp, "parent"); md(pb2, mp, "parent/dir1"); md(pb3, mp, "parent/dir2"); RL(rump_sys_mkdir(pb1, 0777)); RL(rump_sys_mkdir(pb2, 0777)); RL(rump_sys_mkdir(pb3, 0777)); RL(rump_sys_rename(pb2, pb3)); RL(rump_sys_stat(pb1, &sb)); if (! FSTYPE_MSDOS(tc)) ATF_CHECK_EQ(sb.st_nlink, 3); RL(rump_sys_rmdir(pb3)); RL(rump_sys_rmdir(pb1)); }
static int mount_struct(_Bool verbose, struct mount_data_s *mntdp) { fsu_fs_t *fs; int rv; fs = mntdp->mntd_fs; /* * Switch the default process to the native syscalls. * The bad thing about this is that it will fail in unobvious * way if programs using this go multithreaded, but worry about * that if it happens. */ rump_i_know_what_i_am_doing_with_sysents = 1; rump_pub_lwproc_sysent_usenative(); rv = fs->fs_parseargs(mntdp->mntd_argc, mntdp->mntd_argv, fs->fs_args, &(mntdp->mntd_flags), mntdp->mntd_canon_dev, mntdp->mntd_canon_dir); if (rv != 0) return -1; if (rump_sys_mkdir(MOUNT_DIRECTORY, 0777) == -1 && errno != EEXIST) err(-1, "mkdir"); strcpy(mntdp->mntd_canon_dir, MOUNT_DIRECTORY); rv = fsu_load_fs(fs->fs_name); if (rv == 0) { rv = rump_sys_mount(fs->fs_name, mntdp->mntd_canon_dir, mntdp->mntd_flags, fs->fs_args, fs->fs_args_size); #if 0 /* * This will result in a lot of spam for fs type autodetection, * so need to come up with a better scheme here. */ if (rv == -1) warn("mount failed"); #endif } if (rv == 0) { /* fork a rump kernel process to chroot() to the mountpoint */ if ((rv = rump_pub_lwproc_rfork(RUMP_RFCFDG)) != 0) { warnx("fork failed!"); rump_sys_unmount(MOUNT_DIRECTORY, 0); } else { atexit(fsu_unmount); rump_sys_chroot(MOUNT_DIRECTORY); } } #ifdef WITH_SMBFS if (strcmp(fs->fs_name, MOUNT_SMBFS) == 0) { extern struct smb_ctx sctx; smb_ctx_done(&sctx); } #endif if (rv != 0 && verbose) { warn(NULL); fprintf(stderr, "%s is not a valid %s image\n", mntdp->mntd_fsdevice, fs->fs_name); } return rv; }
int main(int argc, char *argv[]) { const char *ethername, *ethername_ro; const char *serveraddr, *serveraddr_ro; const char *netmask; const char *exportpath; const char *imagename; char ifname[IFNAMSIZ], ifname_ro[IFNAMSIZ]; void *fsarg; pthread_t t; int rv; /* for netcfg */ noatf = 1; /* use defaults? */ if (argc == 1) { ethername = "etherbus"; ethername_ro = "etherbus_ro"; serveraddr = "10.3.2.1"; serveraddr_ro = "10.4.2.1"; netmask = "255.255.255.0"; exportpath = "/myexport"; imagename = "ffs.img"; } else { ethername = argv[1]; ethername_ro = argv[2]; serveraddr = argv[3]; serveraddr_ro = argv[4]; netmask = argv[5]; exportpath = argv[6]; imagename = argv[7]; } rump_init(); svc_fdset_init(SVC_FDSET_MT); rv = rump_pub_etfs_register("/etc/exports", "./exports", RUMP_ETFS_REG); if (rv) { errx(1, "register /etc/exports: %s", strerror(rv)); } /* mini-mtree for mountd */ static const char *const dirs[] = { "/var", "/var/run", "/var/db" }; for (size_t i = 0; i < __arraycount(dirs); i++) if (rump_sys_mkdir(dirs[i], 0777) == -1) err(1, "can't mkdir `%s'", dirs[i]); if (ffs_fstest_newfs(NULL, &fsarg, imagename, FSTEST_IMGSIZE, NULL) != 0) err(1, "newfs failed"); if (ffs_fstest_mount(NULL, fsarg, exportpath, 0) != 0) err(1, "mount failed"); #if 0 /* * Serve from host instead of dedicated mount? * THIS IS MORE EVIL THAN MURRAY THE DEMONIC TALKING SKULL! */ if (ukfs_modload("/usr/lib/librumpfs_syspuffs.so") < 1) errx(1, "modload"); mount_syspuffs_parseargs(__arraycount(pnullarg), pnullarg, &args, &mntflags, canon_dev, canon_dir); if ((ukfs = ukfs_mount(MOUNT_PUFFS, "/", UKFS_DEFAULTMP, MNT_RDONLY, &args, sizeof(args))) == NULL) err(1, "mount"); if (ukfs_modload("/usr/lib/librumpfs_nfsserver.so") < 1) errx(1, "modload"); #endif if (sem_init(&gensem, 1, 0) == -1) err(1, "gensem init"); /* create interface */ netcfg_rump_makeshmif(ethername, ifname); netcfg_rump_if(ifname, serveraddr, netmask); netcfg_rump_makeshmif(ethername_ro, ifname_ro); netcfg_rump_if(ifname_ro, serveraddr_ro, netmask); /* * No syslogging, thanks. * XXX: "0" does not modify the mask, so pick something * which is unlikely to cause any logging */ setlogmask(0x10000000); if (pthread_create(&t, NULL, rpcbind_main, NULL) == -1) err(1, "rpcbind"); sem_wait(&gensem); if (pthread_create(&t, NULL, mountd_main, NULL) == -1) err(1, "mountd"); sem_wait(&gensem); rv = 0; /* signal the other process we're almost done */ if (write(3, &rv, 4) != 4) errx(1, "magic write failed"); { char *nfsargv[] = { __UNCONST("nfsd"), NULL }; nfsd_main(1, nfsargv); } /*NOTREACHED*/ return 0; }