int main(int argc, char *argv[]) { struct fuse_args args = FUSE_ARGS_INIT(argc, argv); char *mountpoint; int err = -1; int fd; if (fuse_parse_cmdline(&args, &mountpoint, NULL, NULL) != -1 && (fd = fuse_mount(mountpoint, &args)) != -1) { struct fuse_session *se; se = fuse_lowlevel_new(&args, &hello_ll_oper, sizeof(hello_ll_oper), NULL); if (se != NULL) { if (fuse_set_signal_handlers(se) != -1) { struct fuse_chan *ch = fuse_kern_chan_new(fd); if (ch != NULL) { fuse_session_add_chan(se, ch); err = fuse_session_loop(se); } fuse_remove_signal_handlers(se); } fuse_session_destroy(se); } close(fd); } fuse_unmount(mountpoint); fuse_opt_free_args(&args); return err ? 1 : 0; }
int zfsslash2_init(void) { struct pscfs_args args = PSCFS_ARGS_INIT(0, NULL); extern struct fuse_lowlevel_ops pscfs_fuse_ops; extern struct fuse_session *fuse_session; extern struct pollfd pflfs_fds[]; extern int newfs_fd[2], pflfs_nfds; extern char *fuse_mount_options; int rc; if (pfl_systemf("umount %s", _PATH_KSTAT) == -1) psclog_warn("umount %s", _PATH_KSTAT); if (pipe(newfs_fd) == -1) psc_fatal("pipe"); pflfs_fds[0].fd = newfs_fd[0]; pflfs_fds[0].events = POLLIN; pflfs_nfds = 1; fuse_session = fuse_lowlevel_new(&args.pfa_av, &pscfs_fuse_ops, sizeof(pscfs_fuse_ops), NULL); pscthr_init(SLMTHRT_ZFS_KSTAT, slmzfskstatmthr_main, 0, "slmzfskstatmthr"); fuse_mount_options = ""; rc = libzfs_init_fusesocket(); if (rc == 0) rc = libzfs_init(); atexit(slm_unmount_kstat); return (rc); }
// Do a mount for helper_thread() static void helper_thread_mount(mount_t * m) { Dprintf("%s(\"%s\")\n", __FUNCTION__, m->fstitch_path); if ((m->channel_fd = fuse_mount(m->mountpoint, &m->args)) == -1) { fprintf(stderr, "%s(): fuse_mount(\"%s\") failed. (Does the mountpoint exist?)\n", __FUNCTION__, m->mountpoint); return; } if (!(m->session = fuse_lowlevel_new(&m->args, ops, ops_len, m))) { fprintf(stderr, "%s(): fuse_lowlevel_new() failed\n", __FUNCTION__); return; } if (!(m->channel = fuse_kern_chan_new(m->channel_fd))) { fprintf(stderr, "%s(): fuse_kern_chan_new() failed\n", __FUNCTION__); return; } fuse_session_add_chan(m->session, m->channel); if (fuse_chan_bufsize(m->channel) != fuse_serve_mount_chan_bufsize()) fprintf(stderr, "bufsizes differ!\n"); m->mounted = 1; printf("Mounted \"%s\" from %s\n", m->fstitch_path, modman_name_cfs(m->cfs)); }
int cdfs_options_output_proc(void *data, const char *arg, int key, struct fuse_args *outargs) { (void) arg; (void) data; switch (key) { case KEY_HELP: usage(outargs->argv[0], stdout); printf( "General options:\n" " -o opt,[opt...] mount options\n" " -h --help print help\n" " -V --version print version\n" " -d -o debug enable debug output (implies -f)\n" " -f foreground operation\n" "\n" "cdfs options:\n" " -o device=DEVICE device to use (like /dev/sr0)\n" " -o cache-directory=DIR directory to store cached files\n" " -o progressfifo=FILE fifo ro write cdrom read progress to\n" " -o logging=NUMBER set loglevel (0=no logging)\n" " -o cachebackend=none[default],sqlite backend to store cache info\n" " -o readaheadpolicy=none/piece/whole policy for readahead\n" " -o hashprogram=md5sum/sha1sum/.. program to compute hash, default md5sum\n" " -o discid path write the discid to, default cache-directory\n" "\n" "FUSE options:\n"); fflush(stdout); dup2(1, 2); fuse_opt_add_arg(outargs, "--help"); fuse_mount(NULL, outargs); fuse_lowlevel_new(outargs, NULL, 0, NULL); exit(0); case KEY_VERSION: printf("xmpfs version %s\n", PACKAGE_VERSION); fflush(stdout); dup2(1, 2); fuse_opt_add_arg(outargs, "--version"); fuse_parse_cmdline(outargs, NULL, NULL, NULL); fuse_lowlevel_new(outargs, NULL, 0, NULL); exit(0); } return 1; }
int main(int argc, char *argv[]){ // Initialize an empty argument list struct fuse_args mountpt = FUSE_ARGS_INIT(0, NULL); // add program and mountpoint fuse_opt_add_arg(&mountpt, argv[0]); fuse_opt_add_arg(&mountpt, argv[1]); //fuse_opt_add_arg(&mountpt, argv[2]);// for debug //fuse_opt_add_arg(&mountpt, argv[3]);// for debug log_file_path= argv[2]; fs_size=atoi(argv[3])*1000000; num_blocks=fs_size/block_size; if(num_blocks < 1000){ free_space =block_size; }else free_space=block_size*4; dictionary= malloc(num_blocks*sizeof(int)); log_fp = fopen (log_file_path,"a+"); if (log_fp == NULL) { printf ("Data file could not be opened\n"); return 1; } initialize_dictionary(); mount=time(NULL); struct fuse_args args = FUSE_ARGS_INIT(mountpt.argc, mountpt.argv); struct fuse_chan *ch; char *mountpoint; int err = -1; if (fuse_parse_cmdline(&args, &mountpoint, NULL, NULL) != -1 && (ch = fuse_mount(mountpoint, &args)) != NULL) { struct fuse_session *se; se = fuse_lowlevel_new(&args, &lfs_ll_oper, sizeof(lfs_ll_oper), NULL); if (se != NULL) { if (fuse_set_signal_handlers(se) != -1) { fuse_session_add_chan(se, ch); /* Block until ctrl+c or fusermount -u */ err = fuse_session_loop(se); fuse_remove_signal_handlers(se); fuse_session_remove_chan(ch); } fuse_session_destroy(se); unmount=time(NULL); write_stats(); } fuse_unmount(mountpoint, ch); } fuse_opt_free_args(&args); free(dictionary); fclose(log_fp); return err ? 1 : 0; }
static int mount_root(int argc, char ** argv) { Dprintf("%s()\n", __FUNCTION__); if (!(root = calloc(1, sizeof(*root)))) return -ENOMEM; // We can't use FUSE_ARGS_INIT() here so assert we are initing the // whole structure static_assert(sizeof(root->args) == sizeof(argc) + sizeof(argv) + sizeof(int)); root->args.argc = argc; root->args.argv = argv; root->args.allocated = 0; if (!(root->fstitch_path = strdup(""))) return -ENOMEM; if (!(root->parents = hash_map_create())) return -ENOMEM; root->cfs = NULL; // set later via fuse_serve_mount_set_root() if (fuse_parse_cmdline(&root->args, &root->mountpoint, NULL, NULL) == -1) { fprintf(stderr, "%s(): fuse_parse_cmdline() failed\n", __FUNCTION__); return -1; } if ((root->channel_fd = fuse_mount(root->mountpoint, &root->args)) == -1) { fprintf(stderr, "%s():%d: fuse_mount(\"%s\") failed\n", __FUNCTION__, __LINE__, root->mountpoint); return -1; } if (!(root->session = fuse_lowlevel_new(&root->args, ops, ops_len, root))) { fprintf(stderr, "%s(): fuse_lowlevel_new() failed\n", __FUNCTION__); return -1; } if (!(root->channel = fuse_kern_chan_new(root->channel_fd))) { fprintf(stderr, "%s(): fuse_kern_chan_new() failed\n", __FUNCTION__); return -1; } fuse_session_add_chan(root->session, root->channel); mounts_insert(root); root->mounted = 1; return 0; }
static Bool fuseInitDisplay(CompPlugin *p, CompDisplay *d) { FuseDisplay *fd; struct sigaction sa; if (!checkPluginABI("core", CORE_ABIVERSION)) return FALSE; memset(&sa, 0, sizeof (struct sigaction)); sa.sa_handler = SIG_IGN; sigemptyset(&sa.sa_mask); sa.sa_flags = 0; if (sigaction(SIGPIPE, &sa, NULL) == -1) return FALSE; fd = malloc(sizeof (FuseDisplay)); if (!fd) return FALSE; if (!compInitDisplayOptionsFromMetadata(d, &fuseMetadata, fuseDisplayOptionInfo, fd->opt, FUSE_DISPLAY_OPTION_NUM)) { free(fd); return FALSE; } fd->session = fuse_lowlevel_new(NULL, &compiz_ll_oper, sizeof (compiz_ll_oper), (void *)d); if (!fd->session) { compFiniDisplayOptions(d, fd->opt, FUSE_DISPLAY_OPTION_NUM); free(fd); return FALSE; } fd->watchFdHandle = 0; fd->channel = NULL; fd->buffer = NULL; fd->mountPoint = NULL; d->base.privates[displayPrivateIndex].ptr = fd; fuseMount(d); return TRUE; }
struct fuse_session *fuse_lowlevel_new_compat(const char *opts, const struct fuse_lowlevel_ops_compat *op, size_t op_size, void *userdata) { struct fuse_session *se; struct fuse_args args = FUSE_ARGS_INIT(0, NULL); if (opts && (fuse_opt_add_arg(&args, "") == -1 || fuse_opt_add_arg(&args, "-o") == -1 || fuse_opt_add_arg(&args, opts) == -1)) { fuse_opt_free_args(&args); return NULL; } se = fuse_lowlevel_new(&args, (const struct fuse_lowlevel_ops *) op, op_size, userdata); fuse_opt_free_args(&args); return se; }
int zfsslash2_init(void) { struct pscfs_args args = PSCFS_ARGS_INIT(0, NULL); extern struct fuse_lowlevel_ops pscfs_fuse_ops; extern struct fuse_session *fuse_session; extern struct pollfd pscfs_fds[]; extern int newfs_fd[2], pscfs_nfds; extern char *fuse_mount_options; char buf[BUFSIZ]; int rc; rc = snprintf(buf, sizeof(buf), "umount %s", _PATH_KSTAT); if (rc == -1) psc_fatal("snprintf: umount %s", _PATH_KSTAT); if (rc >= (int)sizeof(buf)) psc_fatalx("snprintf: umount %s: too long", _PATH_KSTAT); if (system(buf) == -1) psclog_warn("system(%s)", buf); if (pipe(newfs_fd) == -1) psc_fatal("pipe"); pscfs_fds[0].fd = newfs_fd[0]; pscfs_fds[0].events = POLLIN; pscfs_nfds = 1; fuse_session = fuse_lowlevel_new(&args.pfa_av, &pscfs_fuse_ops, sizeof(pscfs_fuse_ops), NULL); pscthr_init(SLMTHRT_ZFS_KSTAT, slmzfskstatmthr_main, NULL, 0, "slmzfskstatmthr"); fuse_mount_options = ""; rc = libzfs_init_fusesocket(); if (rc == 0) rc = libzfs_init(); atexit(slm_unmount_kstat); return (rc); }
int main(int argc, char *argv[]) { struct fuse_args args = FUSE_ARGS_INIT(argc, argv); struct fuse_chan *ch; char *mountpoint; int ret = -1; struct lo_data lo = { .debug = 0 }; if (fuse_opt_parse(&args, &lo, lo_opts, NULL) == -1) exit(1); lo.root.next = lo.root.prev = &lo.root; lo.root.fd = open("/", O_PATH); lo.root.nlookup = 2; if (lo.root.fd == -1) err(1, "open(\"/\", O_PATH)"); if (fuse_parse_cmdline(&args, &mountpoint, NULL, NULL) != -1 && (ch = fuse_mount(mountpoint, &args)) != NULL) { struct fuse_session *se; se = fuse_lowlevel_new(&args, &lo_oper, sizeof(lo_oper), &lo); if (se != NULL) { if (fuse_set_signal_handlers(se) != -1) { fuse_session_add_chan(se, ch); ret = fuse_session_loop(se); fuse_remove_signal_handlers(se); fuse_session_remove_chan(ch); } fuse_session_destroy(se); } fuse_unmount(mountpoint, ch); free(mountpoint); } fuse_opt_free_args(&args); while (lo.root.next != &lo.root) lo_free(lo.root.next); return ret ? 1 : 0; }
int mainloop(struct fuse_args *args,const char* mp,int mt,int fg) { struct fuse_session *se; struct fuse_chan *ch; struct rlimit rls; int piped[2]; char s; int err; int i; md5ctx ctx; uint8_t md5pass[16]; if (mfsopts.passwordask && mfsopts.password==NULL && mfsopts.md5pass==NULL) { mfsopts.password = getpass("MFS Password:"******"bad md5 definition (md5 should be given as 32 hex digits)\n"); return 1; } p++; if (*p>='0' && *p<='9') { md5pass[i]+=(*p-'0'); } else if (*p>='a' && *p<='f') { md5pass[i]+=(*p-'a'+10); } else if (*p>='A' && *p<='F') { md5pass[i]+=(*p-'A'+10); } else { fprintf(stderr,"bad md5 definition (md5 should be given as 32 hex digits)\n"); return 1; } p++; } if (*p) { fprintf(stderr,"bad md5 definition (md5 should be given as 32 hex digits)\n"); return 1; } memset(mfsopts.md5pass,0,strlen(mfsopts.md5pass)); } if (mfsopts.delayedinit) { fs_init_master_connection(mfsopts.bindhost,mfsopts.masterhost,mfsopts.masterport,mfsopts.meta,mp,mfsopts.subfolder,(mfsopts.password||mfsopts.md5pass)?md5pass:NULL,mfsopts.donotrememberpassword,1); } else { if (fs_init_master_connection(mfsopts.bindhost,mfsopts.masterhost,mfsopts.masterport,mfsopts.meta,mp,mfsopts.subfolder,(mfsopts.password||mfsopts.md5pass)?md5pass:NULL,mfsopts.donotrememberpassword,0)<0) { return 1; } } memset(md5pass,0,16); if (fg==0) { openlog(STR(APPNAME), LOG_PID | LOG_NDELAY , LOG_DAEMON); } else { #if defined(LOG_PERROR) openlog(STR(APPNAME), LOG_PID | LOG_NDELAY | LOG_PERROR, LOG_USER); #else openlog(STR(APPNAME), LOG_PID | LOG_NDELAY, LOG_USER); #endif } i = mfsopts.nofile; while (1) { rls.rlim_cur = i; rls.rlim_max = i; if (setrlimit(RLIMIT_NOFILE,&rls)<0) { i /= 2; if (i<1000) { break; } } else { break; } } if (i != (int)(mfsopts.nofile)) { fprintf(stderr,"can't set open file limit to %d\n",mfsopts.nofile); if (i>=1000) { fprintf(stderr,"open file limit set to: %d\n",i); } } setpriority(PRIO_PROCESS,getpid(),mfsopts.nice); #ifdef MFS_USE_MEMLOCK if (mfsopts.memlock) { rls.rlim_cur = RLIM_INFINITY; rls.rlim_max = RLIM_INFINITY; if (setrlimit(RLIMIT_MEMLOCK,&rls)<0) { mfsopts.memlock=0; } } #endif piped[0] = piped[1] = -1; if (fg==0) { if (pipe(piped)<0) { fprintf(stderr,"pipe error\n"); return 1; } err = fork(); if (err<0) { fprintf(stderr,"fork error\n"); return 1; } else if (err>0) { close(piped[1]); err = read(piped[0],&s,1); if (err==0) { s=1; } return s; } close(piped[0]); s=1; } #ifdef MFS_USE_MEMLOCK if (mfsopts.memlock) { if (mlockall(MCL_CURRENT|MCL_FUTURE)==0) { syslog(LOG_NOTICE,"process memory was successfully locked in RAM"); } } #endif /* glibc malloc tuning */ #ifdef MFS_USE_MALLOPT if (mfsopts.limitarenas) { if (!getenv("MALLOC_ARENA_MAX")) { syslog(LOG_NOTICE,"setting glibc malloc arena max to 8"); mallopt(M_ARENA_MAX, mfsopts.limitarenas); } if (!getenv("MALLOC_ARENA_TEST")) { syslog(LOG_NOTICE,"setting glibc malloc arena test to 1"); mallopt(M_ARENA_TEST, 1); } } else { syslog(LOG_NOTICE,"setting glibc malloc arenas turned off"); } #endif /* glibc malloc tuning */ syslog(LOG_NOTICE,"monotonic clock function: %s",monotonic_method()); syslog(LOG_NOTICE,"monotonic clock speed: %"PRIu32" ops / 10 mili seconds",monotonic_speed()); conncache_init(200); chunkloc_cache_init(); symlink_cache_init(); negentry_cache_init(mfsopts.negentrycacheto); // dir_cache_init(); fs_init_threads(mfsopts.ioretries); if (masterproxy_init(mfsopts.proxyhost)<0) { fs_term(); // dir_cache_term(); negentry_cache_term(); symlink_cache_term(); chunkloc_cache_term(); return 1; } // fs_term(); // negentry_cache_term(); // symlink_cache_term(); // chunkloc_cache_term(); // return 1; if (mfsopts.meta==0) { csdb_init(); delay_init(); read_data_init(mfsopts.readaheadsize*1024*1024,mfsopts.readaheadleng,mfsopts.readaheadtrigger,mfsopts.ioretries); write_data_init(mfsopts.writecachesize*1024*1024,mfsopts.ioretries); } ch = fuse_mount(mp, args); if (ch==NULL) { fprintf(stderr,"error in fuse_mount\n"); if (piped[1]>=0) { if (write(piped[1],&s,1)!=1) { fprintf(stderr,"pipe write error\n"); } close(piped[1]); } if (mfsopts.meta==0) { write_data_term(); read_data_term(); delay_term(); csdb_term(); } masterproxy_term(); fs_term(); // dir_cache_term(); negentry_cache_term(); symlink_cache_term(); chunkloc_cache_term(); return 1; } if (mfsopts.meta) { mfs_meta_init(mfsopts.debug,mfsopts.entrycacheto,mfsopts.attrcacheto); se = fuse_lowlevel_new(args, &mfs_meta_oper, sizeof(mfs_meta_oper), (void*)piped); } else { mfs_init(mfsopts.debug,mfsopts.keepcache,mfsopts.direntrycacheto,mfsopts.entrycacheto,mfsopts.attrcacheto,mfsopts.xattrcacheto,mfsopts.groupscacheto,mfsopts.mkdircopysgid,mfsopts.sugidclearmode,1,mfsopts.fsyncbeforeclose,mfsopts.noxattrs,mfsopts.noposixlocks,mfsopts.nobsdlocks); //mfsopts.xattraclsupport); se = fuse_lowlevel_new(args, &mfs_oper, sizeof(mfs_oper), (void*)piped); } if (se==NULL) { fuse_unmount(mp,ch); fprintf(stderr,"error in fuse_lowlevel_new\n"); portable_usleep(100000); // time for print other error messages by FUSE if (piped[1]>=0) { if (write(piped[1],&s,1)!=1) { fprintf(stderr,"pipe write error\n"); } close(piped[1]); } if (mfsopts.meta==0) { write_data_term(); read_data_term(); delay_term(); csdb_term(); } masterproxy_term(); fs_term(); // dir_cache_term(); negentry_cache_term(); symlink_cache_term(); chunkloc_cache_term(); return 1; } // fprintf(stderr,"check\n"); fuse_session_add_chan(se, ch); if (fuse_set_signal_handlers(se)<0) { fprintf(stderr,"error in fuse_set_signal_handlers\n"); fuse_session_remove_chan(ch); fuse_session_destroy(se); fuse_unmount(mp,ch); if (piped[1]>=0) { if (write(piped[1],&s,1)!=1) { fprintf(stderr,"pipe write error\n"); } close(piped[1]); } if (mfsopts.meta==0) { write_data_term(); read_data_term(); delay_term(); csdb_term(); } masterproxy_term(); fs_term(); // dir_cache_term(); negentry_cache_term(); symlink_cache_term(); chunkloc_cache_term(); return 1; } if (mfsopts.debug==0 && fg==0) { setsid(); setpgid(0,getpid()); if ((i = open("/dev/null", O_RDWR, 0)) != -1) { (void)dup2(i, STDIN_FILENO); (void)dup2(i, STDOUT_FILENO); (void)dup2(i, STDERR_FILENO); if (i>2) close (i); } } if (mt) { err = fuse_session_loop_mt(se); } else { err = fuse_session_loop(se); } if (err) { if (piped[1]>=0) { if (write(piped[1],&s,1)!=1) { syslog(LOG_ERR,"pipe write error: %s",strerr(errno)); } close(piped[1]); } } fuse_remove_signal_handlers(se); fuse_session_remove_chan(ch); fuse_session_destroy(se); fuse_unmount(mp,ch); if (mfsopts.meta==0) { write_data_term(); read_data_term(); delay_term(); csdb_term(); } masterproxy_term(); fs_term(); // dir_cache_term(); negentry_cache_term(); symlink_cache_term(); chunkloc_cache_term(); return err ? 1 : 0; }
int main(int argc, char **argv) { extern void init_ops(fuse_lowlevel_ops *ops); struct options options; std::memset(&options, 0, sizeof(options)); struct fuse_args args = FUSE_ARGS_INIT(argc, argv); struct fuse_chan *ch; char *mountpoint = NULL; int err = -1; std::string mountPath; unsigned format = 0; int foreground = false; int multithread = false; Pascal::VolumeEntryPointer volume; init_ops(&pascal_ops); // scan the argument list, looking for the name of the disk image. if (fuse_opt_parse(&args, &options ,pascal_options, pascal_option_proc) == -1) exit(1); if (fDiskImage.empty()) { usage(); exit(1); } // default prodos-order disk image. if (options.format) { format = Device::BlockDevice::ImageType(options.format); if (!format) std::fprintf(stderr, "Warning: Unknown image type ``%s''\n", options.format); } try { Device::BlockDevicePointer device; device = Device::BlockDevice::Open(fDiskImage.c_str(), File::ReadOnly, format); if (!device.get()) { std::fprintf(stderr, "Error: Unknown or unsupported device type.\n"); exit(1); } volume = Pascal::VolumeEntry::Open(device); } catch (::Exception &e) { std::fprintf(stderr, "%s\n", e.what()); std::fprintf(stderr, "%s\n", std::strerror(e.error())); return -1; } #ifdef __APPLE__ { // Macfuse supports custom volume names (displayed in Finder) std::string str("-ovolname="); str += volume->name(); fuse_opt_add_arg(&args, str.c_str()); // 512 byte blocksize. fuse_opt_add_arg(&args, "-oiosize=512"); } #endif fuse_opt_add_arg(&args, "-ofsname=PascalFS"); if (!options.readOnly) fuse_opt_add_arg(&args, "-ordonly"); if (options.readWrite) { std::fprintf(stderr, "Warning: write support is not yet enabled.\n"); } if (fuse_parse_cmdline(&args, &mountpoint, &multithread, &foreground) == -1) { usage(); return -1; } #ifdef __APPLE__ if (mountpoint == NULL || *mountpoint == 0) { if (make_mount_dir(volume->name(), mountPath)) mountpoint = (char *)mountPath.c_str(); } #endif if ((ch = fuse_mount(mountpoint, &args)) != NULL) { struct fuse_session* se; std::printf("Mounting ``%s'' on ``%s''\n", volume->name(), mountpoint); se = fuse_lowlevel_new(&args, &pascal_ops, sizeof(pascal_ops), volume.get()); if (se) do { err = fuse_daemonize(foreground); if (err < 0 ) break; err = fuse_set_signal_handlers(se); if (err < 0) break; fuse_session_add_chan(se, ch); if (multithread) err = fuse_session_loop_mt(se); else err = fuse_session_loop(se); fuse_remove_signal_handlers(se); fuse_session_remove_chan(ch); } while (false); if (se) fuse_session_destroy(se); fuse_unmount(mountpoint, ch); } fuse_opt_free_args(&args); #ifdef __APPLE__ if (!mountPath.empty()) rmdir(mountPath.c_str()); #endif return err ? 1 : 0; }
int do_mount(char *spec, char *dir, int mflag, char *opt) { // VERIFY(mflag == 0); vfs_t *vfs = kmem_zalloc(sizeof(vfs_t), KM_SLEEP); if(vfs == NULL) return ENOMEM; VFS_INIT(vfs, zfs_vfsops, 0); VFS_HOLD(vfs); struct mounta uap = { .spec = spec, .dir = dir, .flags = mflag | MS_SYSSPACE, .fstype = "zfs-fuse", .dataptr = "", .datalen = 0, .optptr = opt, .optlen = strlen(opt) }; int ret; if ((ret = VFS_MOUNT(vfs, rootdir, &uap, kcred)) != 0) { kmem_free(vfs, sizeof(vfs_t)); return ret; } /* Actually, optptr is totally ignored by VFS_MOUNT. * So we are going to pass this with fuse_mount_options if possible */ if (fuse_mount_options == NULL) fuse_mount_options = ""; char real_opts[1024]; *real_opts = 0; if (*fuse_mount_options) strcat(real_opts,fuse_mount_options); // comes with a starting , if (*opt) sprintf(&real_opts[strlen(real_opts)],",%s",opt); #ifdef DEBUG atomic_inc_32(&mounted);; fprintf(stderr, "mounting %s\n", dir); #endif char *fuse_opts = NULL; int has_default_perm = 0; if (fuse_version() <= 27) { if(asprintf(&fuse_opts, FUSE_OPTIONS, spec, real_opts) == -1) { VERIFY(do_umount(vfs, B_FALSE) == 0); return ENOMEM; } } else { if(asprintf(&fuse_opts, FUSE_OPTIONS ",big_writes", spec, real_opts) == -1) { VERIFY(do_umount(vfs, B_FALSE) == 0); return ENOMEM; } } struct fuse_args args = FUSE_ARGS_INIT(0, NULL); if(fuse_opt_add_arg(&args, "") == -1 || fuse_opt_add_arg(&args, "-o") == -1 || fuse_opt_add_arg(&args, fuse_opts) == -1) { fuse_opt_free_args(&args); free(fuse_opts); VERIFY(do_umount(vfs, B_FALSE) == 0); return ENOMEM; } has_default_perm = detect_fuseoption(fuse_opts,"default_permissions"); free(fuse_opts); struct fuse_chan *ch = fuse_mount(dir, &args); if(ch == NULL) { VERIFY(do_umount(vfs, B_FALSE) == 0); return EIO; } if (has_default_perm) vfs->fuse_attribute = FUSE_VFS_HAS_DEFAULT_PERM; struct fuse_session *se = fuse_lowlevel_new(&args, &zfs_operations, sizeof(zfs_operations), vfs); fuse_opt_free_args(&args); if(se == NULL) { VERIFY(do_umount(vfs, B_FALSE) == 0); /* ZFSFUSE: FIXME?? */ fuse_unmount(dir,ch); return EIO; } fuse_session_add_chan(se, ch); if(zfsfuse_newfs(dir, ch) != 0) { fuse_session_destroy(se); fuse_unmount(dir,ch); return EIO; } return 0; }
int main(int argc, char *argv[]) { struct fuse_args args; sqfs_opts opts; char *mountpoint = NULL; int mt, fg; int err; sqfs_ll *ll; struct fuse_lowlevel_ops sqfs_ll_ops; memset(&sqfs_ll_ops, 0, sizeof(sqfs_ll_ops)); sqfs_ll_ops.getattr = sqfs_ll_op_getattr; sqfs_ll_ops.opendir = sqfs_ll_op_opendir; sqfs_ll_ops.releasedir = sqfs_ll_op_releasedir; sqfs_ll_ops.readdir = sqfs_ll_op_readdir; sqfs_ll_ops.lookup = sqfs_ll_op_lookup; sqfs_ll_ops.open = sqfs_ll_op_open; sqfs_ll_ops.release = sqfs_ll_op_release; sqfs_ll_ops.read = sqfs_ll_op_read; sqfs_ll_ops.readlink = sqfs_ll_op_readlink; sqfs_ll_ops.listxattr = sqfs_ll_op_listxattr; sqfs_ll_ops.getxattr = sqfs_ll_op_getxattr; sqfs_ll_ops.forget = sqfs_ll_op_forget; /* PARSE ARGS */ args.argc = argc; args.argv = argv; args.allocated = 0; opts.progname = argv[0]; opts.image = NULL; opts.mountpoint = 0; if (fuse_opt_parse(&args, &opts, NULL, sqfs_opt_proc) == -1) sqfs_usage(argv[0], true); if (fuse_parse_cmdline(&args, &mountpoint, &mt, &fg) == -1) sqfs_usage(argv[0], true); if (mountpoint == NULL) sqfs_usage(argv[0], true); /* OPEN FS */ err = !(ll = sqfs_ll_open(opts.image)); /* STARTUP FUSE */ if (!err) { sqfs_ll_chan ch; err = -1; if (sqfs_ll_mount(&ch, mountpoint, &args) == SQFS_OK) { struct fuse_session *se = fuse_lowlevel_new(&args, &sqfs_ll_ops, sizeof(sqfs_ll_ops), ll); if (se != NULL) { if (sqfs_ll_daemonize(fg) != -1) { if (fuse_set_signal_handlers(se) != -1) { fuse_session_add_chan(se, ch.ch); /* FIXME: multithreading */ err = fuse_session_loop(se); fuse_remove_signal_handlers(se); #if HAVE_DECL_FUSE_SESSION_REMOVE_CHAN fuse_session_remove_chan(ch.ch); #endif } } fuse_session_destroy(se); } sqfs_ll_destroy(ll); sqfs_ll_unmount(&ch, mountpoint); } } fuse_opt_free_args(&args); free(ll); free(mountpoint); return -err; }