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); }
ATF_TC_BODY(reregister_reg, tc) { char buf[1024]; int localfd, etcfd; ssize_t n; int tfd; etcfd = open("/etc/passwd", O_RDONLY); ATF_REQUIRE(etcfd != -1); localfd = open("./testfile", O_RDWR | O_CREAT, 0666); ATF_REQUIRE(localfd != -1); ATF_REQUIRE_EQ(write(localfd, TESTSTR1, TESTSTR1SZ), TESTSTR1SZ); /* testfile now contains test string */ rump_init(); ATF_REQUIRE_EQ(rump_pub_etfs_register(TESTPATH1, "/etc/passwd", RUMP_ETFS_REG), 0); tfd = rump_sys_open(TESTPATH1, O_RDONLY); ATF_REQUIRE(tfd != -1); ATF_REQUIRE(rump_sys_read(tfd, buf, sizeof(buf)) > 0); rump_sys_close(tfd); rump_pub_etfs_remove(TESTPATH1); ATF_REQUIRE_EQ(rump_pub_etfs_register(TESTPATH2, "./testfile", RUMP_ETFS_REG), 0); tfd = rump_sys_open(TESTPATH2, O_RDWR); ATF_REQUIRE(tfd != -1); memset(buf, 0, sizeof(buf)); ATF_REQUIRE((n = rump_sys_read(tfd, buf, sizeof(buf))) > 0); /* check that we have what we expected */ ATF_REQUIRE_STREQ(buf, TESTSTR1); /* ... while here, check that writing works too */ ATF_REQUIRE_EQ(rump_sys_lseek(tfd, 0, SEEK_SET), 0); ATF_REQUIRE(TESTSTR1SZ <= TESTSTR2SZ); ATF_REQUIRE_EQ(rump_sys_write(tfd, TESTSTR2, TESTSTR2SZ), TESTSTR2SZ); memset(buf, 0, sizeof(buf)); ATF_REQUIRE_EQ(lseek(localfd, 0, SEEK_SET), 0); ATF_REQUIRE(read(localfd, buf, sizeof(buf)) > 0); ATF_REQUIRE_STREQ(buf, TESTSTR2); close(etcfd); close(localfd); }
ATF_TC_BODY(large_blk, tc) { char buf[128]; char cmpbuf[128]; ssize_t n; int rv, tfd; /* * mount mfs. it would be nice if this would not be required, * but a) tmpfs doesn't "support" sparse files b) we don't really * know what fs atf workdir is on anyway. */ if (mkdir("mfsdir", 0777) == -1) atf_tc_fail_errno("mkdir failed"); if (system("mount_mfs -s 64m -o nosuid,nodev mfs mfsdir") != 0) atf_tc_skip("could not mount mfs"); /* create a 8TB sparse file */ rv = system("dd if=/dev/zero of=" IMG_ON_MFS " bs=1 count=1 seek=8t"); ATF_REQUIRE_EQ(rv, 0); /* * map it and issue write at 6TB, then unmap+remap and check * we get the same stuff back */ rump_init(); ATF_REQUIRE_EQ(rump_pub_etfs_register(TESTPATH1, IMG_ON_MFS, RUMP_ETFS_BLK), 0); tfd = rump_sys_open(TESTPATH1, O_RDWR); ATF_REQUIRE(tfd != -1); memset(buf, 12, sizeof(buf)); n = rump_sys_pwrite(tfd, buf, sizeof(buf), 6*1024*1024*1024ULL*1024ULL); ATF_REQUIRE_EQ(n, sizeof(buf)); ATF_REQUIRE_EQ(rump_sys_close(tfd), 0); ATF_REQUIRE_EQ(rump_pub_etfs_remove(TESTPATH1), 0); ATF_REQUIRE_EQ(rump_pub_etfs_register(TESTPATH2, IMG_ON_MFS, RUMP_ETFS_BLK), 0); tfd = rump_sys_open(TESTPATH2, O_RDWR); ATF_REQUIRE(tfd != -1); memset(buf, 0, sizeof(buf)); n = rump_sys_pread(tfd, buf, sizeof(buf), 6*1024*1024*1024ULL*1024ULL); ATF_REQUIRE_EQ(n, sizeof(buf)); memset(cmpbuf, 12, sizeof(cmpbuf)); ATF_REQUIRE_EQ(memcmp(cmpbuf, buf, 128), 0); }
static void * cleaner(void *arg) { char thepath[MAXPATHLEN]; struct lfstestargs *args = arg; const char *the_argv[7]; char buf[64]; /* this inspired by the cleaner code. fixme */ sprintf(thepath, "/dev/r%s", args->ta_devpath+5); rump_pub_etfs_register(thepath, args->ta_hostpath, RUMP_ETFS_CHR); sprintf(buf, "%p", &args->ta_cleanerloop); the_argv[0] = "megamaid"; the_argv[1] = "-D"; /* don't fork() & detach */ the_argv[2] = "-S"; the_argv[3] = buf; the_argv[4] = args->ta_mntpath; the_argv[5] = NULL; /* xxxatf */ optind = 1; opterr = 1; lfs_cleaner_main(5, __UNCONST(the_argv)); return NULL; }
ATF_TC_BODY(reregister_blk, tc) { char buf[512 * 128]; char cmpbuf[512 * 128]; int rv, tfd; /* first, create some image files */ rv = system("dd if=/dev/zero bs=512 count=64 " "| tr '\\0' '\\1' > disk1.img"); ATF_REQUIRE_EQ(rv, 0); rv = system("dd if=/dev/zero bs=512 count=128 " "| tr '\\0' '\\2' > disk2.img"); ATF_REQUIRE_EQ(rv, 0); rump_init(); ATF_REQUIRE_EQ(rump_pub_etfs_register(TESTPATH1, "./disk1.img", RUMP_ETFS_BLK), 0); tfd = rump_sys_open(TESTPATH1, O_RDONLY); ATF_REQUIRE(tfd != -1); ATF_REQUIRE_EQ(rump_sys_read(tfd, buf, sizeof(buf)), 64*512); memset(cmpbuf, 1, sizeof(cmpbuf)); ATF_REQUIRE_EQ(memcmp(buf, cmpbuf, 64*512), 0); ATF_REQUIRE_EQ(rump_sys_close(tfd), 0); ATF_REQUIRE_EQ(rump_pub_etfs_remove(TESTPATH1), 0); ATF_REQUIRE_EQ(rump_pub_etfs_register(TESTPATH2, "./disk2.img", RUMP_ETFS_BLK), 0); tfd = rump_sys_open(TESTPATH2, O_RDONLY); ATF_REQUIRE(tfd != -1); ATF_REQUIRE_EQ(rump_sys_read(tfd, buf, sizeof(buf)), 128*512); memset(cmpbuf, 2, sizeof(cmpbuf)); ATF_REQUIRE_EQ(memcmp(buf, cmpbuf, 128*512), 0); ATF_REQUIRE_EQ(rump_sys_close(tfd), 0); ATF_REQUIRE_EQ(rump_pub_etfs_remove(TESTPATH2), 0); }
static void rumprun_config_blk(const char *blk_index) { char *blk_type = NULL; char *blk_mountpoint = NULL; char *blk_fstype = NULL; int rv; char key[32], hostpath[32]; rv = xs_read_blkconfig(blk_index, &blk_type, &blk_mountpoint, &blk_fstype); if (rv != 0) return; snprintf(key, sizeof key, "/dev/xenblk%s", blk_index); snprintf(hostpath, sizeof hostpath, "blk%s", blk_index); /* XXX: will "leak" etfs registration if later step fails */ if ((rv = rump_pub_etfs_register(key, hostpath, RUMP_ETFS_BLK)) != 0) { warnx("rumprun_config: etfs_register failed: %d", rv); goto out; } if (blk_mountpoint == NULL) goto out; if ((strcmp(blk_fstype, "ffs") != 0) && (strcmp(blk_fstype, "cd9660") != 0)) { warnx("rumprun_config: xenblk%s: unsupported fstype %s", blk_index, blk_fstype); goto out; } printf("rumprun_config: mounting xenblk%s on %s as %s\n", blk_index, blk_mountpoint, blk_fstype); if ((rv = mkdir(blk_mountpoint, 0777)) != 0) { warn("rumprun_config: mkdir failed"); goto out; } if (strcmp(blk_fstype, "ffs") == 0) { struct ufs_args mntargs = { .fspec = key }; if (mount(MOUNT_FFS, blk_mountpoint, 0, &mntargs, sizeof(mntargs)) != 0) { warn("rumprun_config: mount_ffs failed"); goto out; } } else if(strcmp(blk_fstype, "cd9660") == 0) {
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; }
int lfs_fstest_newfs(const atf_tc_t *tc, void **buf, const char *image, off_t size, void *fspriv) { char cmd[1024]; int res; static unsigned int num = 0; struct lfstestargs *args; size /= 512; snprintf(cmd, 1024, "newfs_lfs -D -F -s %"PRId64" ./%s >/dev/null", size, image); res = system(cmd); if (res != 0) return res; res = rump_init(); if (res != 0) return res; args = calloc(1, sizeof(*args)); if (args == NULL) return -1; strcpy(args->ta_hostpath, image); snprintf(args->ta_devpath, MAXPATHLEN, "/dev/device%d.lfs", num); snprintf(args->ta_imgpath, MAXPATHLEN, "%s", image); args->ta_uargs.fspec = args->ta_devpath; sem_init(&args->ta_cleanerloop, 0, 0); res = rump_pub_etfs_register(args->ta_devpath, image, RUMP_ETFS_BLK); if (res != 0) { free(args); return res; } *buf = args; num++; return 0; }
static char * configetfs(const char *path, int hard) { char buf[32]; char epath[32]; char *p; int rv; snprintf(epath, sizeof(epath), "XENBLK_%s", path); snprintf(buf, sizeof(buf), "/dev/%s", path); rv = rump_pub_etfs_register(buf, epath, RUMP_ETFS_BLK); if (rv != 0) { if (!hard) return NULL; errx(1, "etfs register for \"%s\" failed: %d", path, rv); } if ((p = strdup(buf)) == NULL) err(1, "failed to allocate pathbuf"); return p; }
int msdosfs_fstest_newfs(const atf_tc_t *tc, void **buf, const char *image, off_t size, void *fspriv) { char cmd[1024]; int res; static unsigned int num = 0; struct msdosfstestargs *args; size /= 512; size -= (size % 63); snprintf(cmd, 1024, "newfs_msdos -C %"PRId64"s %s >/dev/null", size, image); res = system(cmd); if (res != 0) return res; res = rump_init(); if (res != 0) return res; args = calloc(1, sizeof(*args)); if (args == NULL) return -1; snprintf(args->ta_devpath, MAXPATHLEN, "/dev/device%d.msdosfs", num); snprintf(args->ta_imgpath, MAXPATHLEN, "%s", image); args->ta_uargs.fspec = args->ta_devpath; args->ta_uargs.mask = 0755; res = rump_pub_etfs_register(args->ta_devpath, image, RUMP_ETFS_BLK); if (res != 0) { free(args); return res; } *buf = args; num++; return 0; }
int main(int argc, char *argv[]) { struct ulfs_args args; char canon_dev[UKFS_DEVICE_MAXPATHLEN], canon_dir[MAXPATHLEN]; char rawdev[MAXPATHLEN]; struct p2k_mount *p2m; pthread_t cleanerthread; struct ukfs_part *part; int mntflags; int rv; setprogname(argv[0]); puffs_unmountonsignal(SIGINT, true); puffs_unmountonsignal(SIGTERM, true); if (argc >= 3) { UKFS_DEVICE_ARGVPROBE(&part); if (part != ukfs_part_none) { errx(1, "lfs does not currently support " "embedded partitions"); } } mount_lfs_parseargs(argc, argv, &args, &mntflags, canon_dev, canon_dir); /* Reset getopt for lfs_cleaner_main. */ optreset = 1; optind = 1; p2m = p2k_init(0); if (!p2m) err(1, "init p2k"); /* * XXX: this particular piece inspired by the cleaner code. * obviously FIXXXME along with the cleaner. */ sprintf(rawdev, "/dev/r%s", canon_dev+5); rump_pub_etfs_register(rawdev, canon_dev, RUMP_ETFS_CHR); /* * We basically have two choices: * 1) run the cleaner in another process and do rump ipc syscalls * 2) run it off a thread in this process and do rump syscalls * as function calls. * * opt for "2" for now */ #ifdef CLEANER_TESTING ukfs_mount(MOUNT_LFS, canon_dev, canon_dir, mntflags, &args, sizeof(args)); cleaner(canon_dir); #endif if (p2k_setup_diskfs(p2m, MOUNT_LFS, canon_dev, part, canon_dir, mntflags, &args, sizeof(args)) == -1) err(1, "mount"); ukfs_part_release(part); #ifndef CLEANER_TESTING if ((mntflags & MNT_RDONLY) == 0) { if (pthread_create(&cleanerthread, NULL, cleaner, canon_dir) == -1) err(1, "cannot start cleaner"); } #endif rv = p2k_mainloop(p2m); if (rv == -1) err(1, "fs service"); return 0; }
void __franken_fdinit_create() { int fd, ret, flags; int root = 0; char key[16], rkey[16], num[16]; int n_reg = 0, n_block = 0; struct ufs_args ufs; if (__franken_fd[0].valid) { mkkey(key, num, "/dev/vfile", n_reg++, 0); rump_pub_etfs_register(key, num, RUMP_ETFS_REG); fd = rump___sysimpl_open(key, O_RDONLY); if (fd != -1) { rump___sysimpl_dup2(fd, 0); rump___sysimpl_close(fd); } } if (__franken_fd[1].valid) { mkkey(key, num, "/dev/vfile", n_reg++, 1); rump_pub_etfs_register(key, num, RUMP_ETFS_REG); fd = rump___sysimpl_open(key, O_WRONLY); if (fd != -1) { rump___sysimpl_dup2(fd, 1); rump___sysimpl_close(fd); } } if (__franken_fd[2].valid) { mkkey(key, num, "/dev/vfile", n_reg++, 2); rump_pub_etfs_register(key, num, RUMP_ETFS_REG); fd = rump___sysimpl_open(key, O_WRONLY); if (fd != -1) { rump___sysimpl_dup2(fd, 2); rump___sysimpl_close(fd); } } for (fd = 3; fd < MAXFD; fd++) { if (__franken_fd[fd].valid == 0) break; switch (__franken_fd[fd].st.st_mode & S_IFMT) { case S_IFREG: mkkey(key, num, "/dev/vfile", n_reg++, fd); rump_pub_etfs_register(key, num, RUMP_ETFS_REG); flags = __franken_fd[fd].flags & O_ACCMODE; rump___sysimpl_open(key, flags); break; case S_IFBLK: mkkey(key, num, "/dev/block", n_block, fd); mkkey(rkey, num, "/dev/rblock", n_block, fd); n_block++; rump_pub_etfs_register_withsize(key, num, RUMP_ETFS_BLK, 0, __franken_fd[fd].st.st_size); rump_pub_etfs_register_withsize(rkey, num, RUMP_ETFS_CHR, 0, __franken_fd[fd].st.st_size); if (root == 0) { ufs.fspec = key; flags = __franken_fd[fd].flags & O_ACCMODE; if (flags == O_RDWR) flags = MNT_LOG; else flags = MNT_RDONLY; ret = rump___sysimpl_mount50("ffs", "/", flags, &ufs, sizeof(struct ufs_args)); if (ret == 0) { root = 1; } else { if (flags == MNT_LOG) flags = 0; ret = rump___sysimpl_mount50("ext2fs", "/", flags, &ufs, sizeof(struct ufs_args)); if (ret == 0) { root = 1; } } if (root == 1) atexit(unmount_atexit); } break; case S_IFSOCK: mkkey(key, num, "virt", fd, fd); ret = rump_pub_netconfig_ifcreate(key); if (ret == 0) { ret = rump___sysimpl_socket30(AF_INET6, SOCK_STREAM, 0); if (ret != -1) { rump_pub_netconfig_auto_ipv6(key); rump___sysimpl_close(ret); } ret = rump___sysimpl_socket30(AF_INET, SOCK_STREAM, 0); if (ret != -1) { rump_pub_netconfig_dhcp_ipv4_oneshot(key); rump___sysimpl_close(ret); } } break; } } }
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; }
/* * Tries to mount an image. * if the fstype is not given try every supported types. */ int fsu_mount(int *argc, char **argv[], int mode) { fsu_fs_t *fst; struct fsu_fsalias_s *alias; struct mount_data_s mntd; int idx, fflag, rv, verbose; int ch, stopopts; char *mntopts, afsdev[PATH_MAX], *puffsexec, *specopts; char *tmp; char *fsdevice, *fstype; struct stat sb; #ifdef WITH_SYSPUFFS const char options[] = GETOPT_PREFIX"f:o:p:s:t:v"; #else const char options[] = GETOPT_PREFIX"f:o:s:t:v"; #endif alias = NULL; fsdevice = fstype = mntopts = puffsexec = specopts = NULL; fst = NULL; verbose = fflag = 0; stopopts = 0; memset(&mntd, 0, sizeof(mntd)); mntd.mntd_fsdevice = mntd.mntd_canon_dev; rump_init(); opterr = 0; /* * [-o mnt_args] [-t fstype] [-p puffsexec] fsdevice */ while ((ch = getopt(*argc, *argv, options)) != -1) { switch (ch) { case 'f': if (fsdevice == NULL) fsdevice = optarg; fflag = 1; break; case 'o': if (mntopts == NULL) mntopts = optarg; break; #ifdef WITH_SYSPUFFS case 'p': if (puffsexec == NULL) { puffsexec = optarg; for (fst = fslist; fst->fs_name != NULL; ++fst) if (fst->fs_name == MOUNT_PUFFS) break; if (fstype == NULL) fstype = MOUNT_PUFFS; else if (strcmp(fstype, MOUNT_PUFFS) != 0) { warnx("-p is only for puffs"); return -1; } } break; #endif case 's': if (specopts == NULL) specopts = optarg; break; case 't': if (fstype == NULL) fstype = optarg; break; case 'v': ++verbose; break; case '?': default: --optind; stopopts = 1; break; } if (stopopts) break; } idx = optind; optind = 1; #ifdef HAVE_GETOPT_OPTRESET optreset = 1; #endif if (mntopts == NULL) mntopts = getenv("FSU_MNTOPTS"); if (mode == MOUNT_READONLY) { if (mntopts == NULL) mntopts = __UNCONST("ro"); else { tmp = malloc(strlen(mntopts) + 4); if (tmp == NULL) { warn(NULL); opterr = 1; return -1; } snprintf(tmp, strlen(mntopts) + 4, "%s,ro", mntopts); mntopts = tmp; } } if (fstype == NULL) fstype = getenv("FSU_TYPE"); if (fstype != NULL && fst == NULL) { for (fst = fslist; fst->fs_name != NULL; ++fst) if (strcmp(fstype, fst->fs_name) == 0) break; if (fst->fs_name == NULL) { fprintf(stderr, "%s: filesystem not supported\n", fstype); opterr = 1; return -1; } } if (fsdevice == NULL) { fsdevice = getenv("FSU_DEVICE"); if (fsdevice == NULL) { if (idx < *argc && strcmp((*argv)[idx], "--") != 0) fsdevice = (*argv)[idx++]; else { errno = 0; opterr = 1; return -1; } } } rv = 0; if (!fflag) { rv = -1; build_alias_list(); alias = get_alias(fsdevice); if (alias != NULL) rv = mount_alias(alias, mntopts, specopts, &mntd, verbose); free_alias_list(); } if (fflag || alias == NULL) { if (realpath(fsdevice, afsdev) != NULL) fsdevice = afsdev; rv = stat(fsdevice, &sb); if (rv == -1) warn("%s", fsdevice); else if (!(S_ISREG(sb.st_mode) || S_ISBLK(sb.st_mode))) { warnx("%s: Not a regular file or block device", fsdevice); rv = -1; } else { rv = rump_pub_etfs_register(RUMPFSDEV, fsdevice, RUMP_ETFS_BLK); if (rv != 0) { warnx("%s: rump_pub_etfs_register failed " "(error=%d)", fsdevice, rv); } else { mntd.mntd_fsdevice = fsdevice; fsdevice = strdup(RUMPFSDEV); rv = mount_fstype(fst, fsdevice, mntopts, puffsexec, specopts, &mntd, verbose); if (rv == -1) { warnx("%s: " "Invalid or unknown filesystem type" ", retry with -v for details", mntd.mntd_fsdevice); } } } } free(mntd.mntd_argv); mntd.mntd_argv = NULL; mntd.mntd_argv_size = 0; /* Remove the arguments used by fsu_mount and reset getopt*/ if ((*argv)[idx] != NULL && strcmp((*argv)[idx], "--") == 0) ++idx; if (--idx > 0) { (*argv)[idx] = (*argv)[0]; *argv += idx; *argc -= idx; optind = 1; #ifdef HAVE_GETOPT_OPTRESET optreset = 1; #endif } optind = 1; #ifdef HAVE_GETOPT_OPTRESET optreset = 1; #endif opterr = 1; return rv; }