自学教程：C++ FUSE_ARGS_INIT函数代码示例

void SMTPFileSystem::printVersion() const{    struct fuse_args args = FUSE_ARGS_INIT(0, NULL);    struct fuse_operations tmp_operations;    memset(&tmp_operations, 0, sizeof(tmp_operations));    fuse_opt_add_arg(&args, m_args.argv[0]);    fuse_opt_add_arg(&args, "--version");    std::cout << "simple-mtpfs version " << VERSION << "/n";    fuse_main(args.argc, args.argv, &tmp_operations, nullptr);    fuse_opt_free_args(&args);}

int runfuse(int argc, const char* const* argv){	struct fuse_args fua = FUSE_ARGS_INIT(argc, (char**) argv);	struct cuse_info info;	const char *iav[] = { "DEVNAME=jrandom",NULL };	vzero(info);	info.dev_info_argc = 1;	info.dev_info_argv = iav;	info.flags = CUSE_UNRESTRICTED_IOCTL;	return cuse_lowlevel_main(fua.argc, fua.argv, &info, GET_RNDEV_OPS(), NULL);}

int main(int argc, char *argv[]){    fuse_args args = FUSE_ARGS_INIT(argc, argv);    arg_ctx arg_ctx;    if (fuse_opt_parse(&args, &arg_ctx, fuse_opts, fuse_opt_proc) == -1) {        return EXIT_FAILURE;    }    int fd = -1;    if (!arg_ctx.show_help) {        if (!arg_ctx.source_file) {            fprintf(stderr, "Missing source file/n");            return EXIT_FAILURE;        }        if (!arg_ctx.target_file) {            fprintf(stderr, "Missing target file (mount point) parameter/n");            return EXIT_FAILURE;        }        fd = open(arg_ctx.source_file, O_RDONLY | O_CLOEXEC);        if (fd < 0) {            fprintf(stderr, "%s: Failed to open: %s/n",                    arg_ctx.source_file, strerror(errno));            return EXIT_FAILURE;        }        snprintf(source_fd_path, sizeof(source_fd_path),                 "/proc/self/fd/%d", fd);        if (get_sparse_file_size() < 0) {            close(fd);            return EXIT_FAILURE;        }    }    fuse_operations fuse_oper = {};    fuse_oper.getattr = fuse_getattr;    fuse_oper.open    = fuse_open;    fuse_oper.read    = fuse_read;    fuse_oper.release = fuse_release;    int fuse_ret = fuse_main(args.argc, args.argv, &fuse_oper, nullptr);    if (!arg_ctx.show_help) {        close(fd);    }    fuse_opt_free_args(&args);    free(arg_ctx.source_file);    free(arg_ctx.target_file);    return fuse_ret;}

intmain (int argc, char *argv[]){	struct fuse_args args = FUSE_ARGS_INIT (argc, argv);	g_log_set_always_fatal (G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_ERROR);	if (fuse_opt_parse (&args, NULL, NULL, opt_process) == -1)		g_critical ("usage: %s <query> <mount point>", argv[0]);	return fuse_main (args.argc, args.argv, &beagle_file_ops);}

int main(int argc, char *argv[]){     struct fuse_args args = FUSE_ARGS_INIT(argc, argv);     memset(current_buffer, 0, sizeof(current_buffer));     memset(display_buffer, 0, sizeof(display_buffer));     fuse_opt_parse(&args, NULL, display_options, option_processor);     // run fuse     return fuse_main(args.argc, args.argv, &display_operations, NULL);}

int main(int argc, char *argv[]) {	struct fuse_args args = FUSE_ARGS_INIT(argc, argv);	init_syslog();	uopt_init();	if (fuse_opt_parse(&args, NULL, unionfs_opts, unionfs_opt_proc) == -1) RETURN(1);	if (uopt.debug)	debug_init();	if (!uopt.doexit) {		if (uopt.nbranches == 0) {			printf("You need to specify at least one branch!/n");			RETURN(1);		}	}	// enable fuse permission checks, we need to set this, even we we are	// not root, since we don't have our own access() function	int uid = getuid();	int gid = getgid();	bool default_permissions = true;		if (uid != 0 && gid != 0 && uopt.relaxed_permissions) {		default_permissions = false;	} else if (uopt.relaxed_permissions) {		// protec the user of a very critical security issue		fprintf(stderr, "Relaxed permissions disallowed for root!/n");		exit(1);	}		if (default_permissions) {		if (fuse_opt_add_arg(&args, "-odefault_permissions")) {			fprintf(stderr, "Severe failure, can't enable permssion checks, aborting!/n");			exit(1);		}	}	unionfs_post_opts();#ifdef FUSE_CAP_BIG_WRITES	/* libfuse > 0.8 supports large IO, also for reads, to increase performance 	 * We support any IO sizes, so lets enable that option */	if (fuse_opt_add_arg(&args, "-obig_writes")) {		fprintf(stderr, "Failed to enable big writes!/n");		exit(1);	}#endif	umask(0);	int res = fuse_main(args.argc, args.argv, &unionfs_oper, NULL);	RETURN(uopt.doexit ? uopt.retval : res);}

void sqfs_usage(char *progname, bool fuse_usage) {	fprintf(stderr, "%s (c) 2012 Dave Vasilevsky/n/n", PACKAGE_STRING);	fprintf(stderr, "Usage: %s [options] ARCHIVE MOUNTPOINT/n",		progname ? progname : PACKAGE_NAME);	if (fuse_usage) {		struct fuse_args args = FUSE_ARGS_INIT(0, NULL);		fuse_opt_add_arg(&args, ""); /* progname */		fuse_opt_add_arg(&args, "-ho");		fprintf(stderr, "/n");		fuse_parse_cmdline(&args, NULL, NULL, NULL);	}	exit(-2);}

int main(int argc, char *argv[]){    struct fuse_args args = FUSE_ARGS_INIT(argc, argv);    if (fuse_opt_parse(&args, &rbd_options, rbdfs_opts, rbdfs_opt_proc)            == -1) {        exit(1);    }    pthread_mutex_init(&readdir_lock, NULL);    return fuse_main(args.argc, args.argv, &rbdfs_oper, NULL);}

struct fuse *fuse_setup_common(int argc, char *argv[],			       const struct fuse_operations *op,			       size_t op_size,			       char **mountpoint,			       int *multithreaded,			       int *fd,			       void *user_data,			       int compat){	struct fuse_args args = FUSE_ARGS_INIT(argc, argv);	struct fuse_chan *ch;	struct fuse *fuse;	int foreground;	int res;	res = fuse_parse_cmdline(&args, mountpoint, multithreaded, &foreground);	if (res == -1)		return NULL;	ch = fuse_mount_common(*mountpoint, &args);	if (!ch) {		fuse_opt_free_args(&args);		goto err_free;	}	fuse = fuse_new_common(ch, &args, op, op_size, user_data, compat);	fuse_opt_free_args(&args);	if (fuse == NULL)		goto err_unmount;	res = fuse_daemonize(foreground);	if (res == -1)		goto err_unmount;	res = fuse_set_signal_handlers(fuse_get_session(fuse));	if (res == -1)		goto err_unmount;	if (fd)		*fd = fuse_chan_fd(ch);	return fuse;err_unmount:	fuse_unmount_common(*mountpoint, ch);	if (fuse)		fuse_destroy(fuse);err_free:	free(*mountpoint);	return NULL;}

int main(int argc, char *argv[]){    struct fuse_args args = FUSE_ARGS_INIT(argc, argv);    opts.config = "pipefs.conf";    if(fuse_opt_parse(&args, &opts, pipefs_opts, pipefs_opt_proc) == -1) {        exit(1);    }    pipefs_read_config();    return fuse_main(args.argc, args.argv, &pipefs_oper, NULL);}

int main(int argc, char *argv[]){    struct fuse_args args = FUSE_ARGS_INIT(argc, argv);    uid = getuid();    gid = getgid();    now = time(NULL);    opts.host = "localhost";    opts.port = CC_XSTREAM_DEFAULT_PORT;    opts.user = "user";    opts.pass = "";    opts.root = "";    if(fuse_opt_parse(&args, &opts, ccx_opts, ccx_opt_proc) == -1) {        exit(1);    }    /* normalize to non-abs */    if(opts.root[0] == '/') {        opts.root++;    }    /* not multithreaded */    fuse_opt_add_arg(&args, "-s");       /* 0x20000 (131072) hardcoded max ccx packet size (ccxclient.c)     * set max read to max ccx packet - 100 (headers) */    fuse_opt_add_arg(&args, "-omax_readahead=130972");    if(cc_xstream_client_connect(opts.host, opts.port, &ccxconn)        != CC_XSTREAM_CLIENT_OK) {        fprintf(stderr, "Can't connect to host %s:%d./n", opts.host, opts.port);        exit(1);    }    if (cc_xstream_client_version_handshake(ccxconn)        != CC_XSTREAM_CLIENT_OK) {        fprintf(stderr, "Version handshake failed./n");        exit(1);    }        if(cc_xstream_client_password_authenticate(ccxconn, opts.user, opts.pass)       != CC_XSTREAM_CLIENT_OK) {        fprintf(stderr, "Auth failed./n");        exit(1);    }    return fuse_main(args.argc, args.argv, &ccx_oper, NULL);}

intmain(int argc, char **argv){	struct fuse_args args = FUSE_ARGS_INIT(0, NULL);	const char *imgname = NULL, *mntpoint = NULL;	char fsname_buf[17 + PATH_MAX];	int r, fd;	fuse_opt_add_arg(&args, argv[0]);	if (argc < 2)		panic("missing image or mountpoint parameter, see help");	for (r = 1; r < argc; r++) {		if (imgname == NULL && argv[r][0] != '-' && strcmp(argv[r - 1], "-o") != 0) {			imgname = argv[r];		} else if(mntpoint == NULL && argv[r][0] != '-' && strcmp(argv[r - 1], "-o") != 0) {			mntpoint = argv[r];			fuse_opt_add_arg(&args, argv[r]);		} else {			fuse_opt_add_arg(&args, argv[r]);		}	}	// Use a fsname (which shows up in df) in the style of sshfs, another	// FUSE-based file system, with format "fsname#fslocation".	snprintf(fsname_buf, sizeof(fsname_buf), "-ofsname=CS202fs#%s", imgname);	fuse_opt_add_arg(&args, "-s"); // Always run single-threaded.	fuse_opt_add_arg(&args, "-odefault_permissions"); // Kernel handles access.	fuse_opt_add_arg(&args, fsname_buf); // Set the filesystem name.	if (imgname == NULL) {		fuse_opt_parse(&args, NULL, fs_opts, fs_parse_opt);		return -1;	} else {		struct inode *dirroot;		map_disk_image(imgname, mntpoint);		// Make sure the superblock fields are sane.		assert(super->s_magic == FS_MAGIC);		assert(super->s_root != 0);		// Guarantee that the root directory has proper permissions.		// This is vital so that we can unmount the disk.		dirroot = diskaddr(super->s_root);		dirroot->i_mode = S_IFDIR | 0777;		fuse_opt_parse(&args, NULL, fs_opts, fs_parse_opt);		return fuse_main(args.argc, args.argv, &fs_oper, NULL);	}}

intmain (int argc, char **argv){  int ret;  struct fuse_args args = FUSE_ARGS_INIT (argc, argv);  get_mount_point (argc, argv);  memset (&options, 0, sizeof (struct options));  if (-1 == fuse_opt_parse (&args, &options, arsenal_opts, NULL))    return -1;  ret = fuse_main (args.argc, args.argv, &arsenal_oper, NULL);  fuse_opt_free_args (&args);  return ret;}

int main(int argc, char *argv[]){	int ret;	struct fuse_args args = FUSE_ARGS_INIT(argc, argv);		fuse_opt_parse(&args, NULL, NULL, darfs_opt_proc);	ret = fuse_main(args.argc, args.argv, &hello_oper, NULL);		/** free arguments */  fuse_opt_free_args(&args);  	return ret;}

int main(int argc, char* argv[]) {  umask(0);	struct fuse_args args = FUSE_ARGS_INIT(argc, argv);	fuse_opt_parse(&args, NULL, NULL, &diskfile_opt_proc);	// Need at least a	if (diskfile_entries_count < 2)		usage(&args);	// put the mountpoint back	fuse_opt_add_arg(&args, diskfile_entries[--diskfile_entries_count].source);	return fuse_main(args.argc, args.argv, &diskfile_operations, NULL);}

/* * First we divide the given arguments into FUSE and cmd arguments, pass the * FUSE arguments to FUSE, and call cmd_Dispatch in the FUSE init function. */intmain(int argc, char **argv){	int code;	struct fuse_args args = FUSE_ARGS_INIT(argc-1, &argv[1]);	fuse_opt_add_arg(&afsd_args, argv[0]);#ifdef AFS_SUN511_ENV	/* for some reason, Solaris 11 FUSE takes the filesystem name from	 * argv[0], and ignores the -ofsname option */	fuse_opt_add_arg(&fuse_args, "AFS");#else	fuse_opt_add_arg(&fuse_args, argv[0]);#endif	/* let us determine file inode numbers, not FUSE. also make "AFS" appear	 * in df/mount/mnttab/etc output. */	fuse_opt_add_arg(&fuse_args, "-ouse_ino,fsname=AFS");	if (getuid() == 0) {	    /* allow other users to access the mountpoint. only do this for	     * root, since non-root may or may not be able to do this */	    fuse_opt_add_arg(&fuse_args, "-oallow_other");	}	code = uafs_Setup("/afs");	if (code) {		errno = code;		perror("libuafs");		return 1;	}	split_args(&args);	uafs_ParseArgs(afsd_args.argc, afsd_args.argv);	/* pass "-- /mount/dir" to fuse to specify dir to mount; "--" is	 * just to make sure fuse doesn't interpret the mount dir as a flag	 */#ifndef AFS_SUN511_ENV	/* This seems to screw up option parsing on Solaris 11 FUSE, so just	 * don't do it. This makes it slightly more annoying to mount on a dir	 * called -foo or something, but oh well. */	fuse_opt_add_arg(&fuse_args, "--");#endif	fuse_opt_add_arg(&fuse_args, uafs_MountDir());	return fuse_main(fuse_args.argc, fuse_args.argv, &fuafsd_oper, NULL);}

/** * main */int main(int argc, char *argv[]){    struct fuse_args args = FUSE_ARGS_INIT(argc, argv);    struct mysqlfs_opt opt = {	.init_conns	= 1,	.max_idling_conns = 5,	.mycnf_group	= "mysqlfs",#ifdef DEBUG	.logfile	= "mysqlfs.log",#endif    };    log_file = stderr;    /** theopts kludge is used for both statusdir (if configured at build) and for osxnospotlight */    theopts = &opt;    fuse_opt_parse(&args, &opt, mysqlfs_opts, mysqlfs_opt_proc);    if (pool_init(&opt) < 0) {        log_printf(LOG_ERROR, "Error: pool_init() failed/n");        fuse_opt_free_args(&args);        return EXIT_FAILURE;            }    /*     * I found that -- running from a script (ie no term?) -- the MySQLfs would not background, so the terminal is held; this makes automated testing difficult.     *     * I (allanc) put this into here to allow for AUTOTEST, but then autotest has to seek-and-destroy the app.  This isn't quite perfect yet, I get some flakiness here, othertines the pid is 4 more than the parent, which is odd.     */    if (0 < opt.bg)    {        if (0 < fork())            return EXIT_SUCCESS;        //else        //    fprintf (stderr, "forked %d/n", getpid());    }    /* only create a log file if we have a logfile set; note that --enable-debug sets a default above */    if (NULL != opt.logfile)        log_file = log_init(opt.logfile, 1);    fuse_main(args.argc, args.argv, &mysqlfs_oper);    fuse_opt_free_args(&args);    pool_cleanup();    return EXIT_SUCCESS;}

int main(int argc, char *argv[]){	struct fuse_args args = FUSE_ARGS_INIT(argc, argv);	fuse_opt_parse(&args, &dirname, ciopfs_opts, ciopfs_opt_parse);	if (single_threaded) {		fuse_opt_add_arg(&args, "-s");		log_print("disabling multithreaded mode for root mounted "		          "filesystem that is accessible for other users "		          "via the `-o allow_other' option/n");	}	umask(0);	return fuse_main(args.argc, args.argv, &ciopfs_operations, NULL);}

int main(int argc, char *argv[]){  umask(0);  struct fuse_args args = FUSE_ARGS_INIT(argc, argv);  fuse_opt_parse(&args, &the_config, cow_opts, cow_opt_proc);  if (the_config.src_dir == NULL || the_config.cow_dir == NULL) {    fprintf(stderr,            "You must specify -o src_dir=... and a -o cow_dir=.../n");    exit(1);  }  return fuse_main(args.argc, args.argv, &cow_oper, NULL);}

struct fuse_args * parse_options(int argc, char *argv[]){     struct fuse_args * args=calloc(1, sizeof(struct fuse_args));     struct cow_config *conf = cow_getConfig();     int pathmaxcnt = 0;     do{         pathmaxcnt++;         conf->cwd = calloc(PATH_MAX*pathmaxcnt, sizeof(char));         if(getcwd(conf->cwd, PATH_MAX*pathmaxcnt)==NULL){             free(conf->cwd);             conf->cwd = NULL;         }     }while(conf->cwd==NULL && errno == ERANGE);     if(conf->cwd==NULL){         fprintf(stderr, "ERROR: couldnt allocate current working directory buffer (%d)/n", errno);         exit(-1);     }     {         struct fuse_args tmp=FUSE_ARGS_INIT(argc, argv);         memcpy(args, &tmp, sizeof(struct fuse_args));     }     if (fuse_opt_parse(args, cow_getConfig(), cow_opts, cow_opt_proc)==-1)         exit(-1);     char *cliopt = NULL;     int clilen = strlen(FUSE_MP_OPT_STR)+strlen(conf->srcdir)+1;     int i = 0;     for(i=0;i<conf->dstdircnt;i++){         if(i) clilen++; /* separator character */         clilen += strlen(conf->dstdirs[i]);     }     clilen++; /* null byte */     cliopt = calloc(clilen, sizeof(char));     sprintf(cliopt, "%s%s=", FUSE_MP_OPT_STR, conf->srcdir);     for(i=0;i<conf->dstdircnt;i++){         if(i) strcat(cliopt, ";");         strcat(cliopt, conf->dstdirs[i]);     }     fuse_opt_insert_arg(args, 1, cliopt);     fuse_opt_insert_arg(args, 1, conf->mountpt);     return args;}

int main(int argc, char** argv){	try	{		struct fuse_operations ops;		struct fuse_args args = FUSE_ARGS_INIT(0, NULL);			if (argc < 3)		{			showHelp(argv[0]);			return 1;		}			openDisk(argv[1]);			memset(&ops, 0, sizeof(ops));			ops.getattr = hfs_getattr;		ops.open = hfs_open;		ops.read = hfs_read;		ops.release = hfs_release;		//ops.opendir = hfs_opendir;		ops.readdir = hfs_readdir;		ops.readlink = hfs_readlink;		//ops.releasedir = hfs_releasedir;		ops.getxattr = hfs_getxattr;		ops.listxattr = hfs_listxattr;			for (int i = 0; i < argc; i++)		{			if (i == 1)				;			else				fuse_opt_add_arg(&args, argv[i]);		}		fuse_opt_add_arg(&args, "-oro");		fuse_opt_add_arg(&args, "-s");			std::cout << "Everything looks OK, disk mounted/n";		return fuse_main(args.argc, args.argv, &ops, 0);	}	catch (const std::exception& e)	{		std::cerr << "Error: " << e.what() << std::endl;		return 1;	}}

int main(int argc, char *argv[]){	struct fuse_args args = FUSE_ARGS_INIT(0, NULL);	guint8 *key; #ifdef ENABLE_NLS	bindtextdomain(GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR);	bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");	textdomain(GETTEXT_PACKAGE);#endif	if (argc < 3 || argc > 4) {		goto usage;	}	if (!g_file_test(argv[1], G_FILE_TEST_EXISTS)) {		printf("%s doesn't exist./n", argv[1]);		return 1;	}	if (!g_file_test(argv[2], G_FILE_TEST_EXISTS)) {		printf("%s doesn't exist./n", argv[2]);		return 1;	}	if (argc == 4) {		if (!mdsfs_lockmgr_check_key(argv[3]))			return 1;		/* Initializing blowfish */		key = mdsfs_misc_hexstrings_to_binary(argv[3]);	}	/* args */	fuse_opt_add_arg(&args, argv[0]);	fuse_opt_add_arg(&args, argv[2]);	/* Initiallizing */	mdsfs = mdsfs_core_open(argv[1], key);	/* main of FUSE */	return fuse_main(args.argc, args.argv, &mdsfs_op, NULL);usage:	printf("Usage: mdsfs [image file] [mount point] {key}/n");	return 1;}

int main(int argc, char* argv[]) {	if (argc < 4){		printf("%s url count mnt {else fuse params}/n", argv[0]); 		return 1;	}		curl_global_init(CURL_GLOBAL_ALL);	strncpy(url, argv[1], sizeof(url) - 1);		char *err_strpol;	parts =  strtol(argv[2] ,&err_strpol, 0);	if (*err_strpol != '/0' && parts <= 0){		printf("bad parts %s/n", argv[2]);		return 1;	}		char tmp[NAME_SIZE];	snprintf(tmp, NAME_SIZE, url, parts - 1);	file_size = part_size = get_size(tmp);	if (part_size == -1){		printf("bad size %s/n", tmp);		return 1;	}		if (parts > 1){		snprintf(tmp, NAME_SIZE, url, 0);		part_size = get_size(tmp);		if (part_size == -1){			printf("bad size %s/n", tmp);			return 1;		}		file_size += (parts - 1) * part_size;	}		printf("size = %llu, parts = %d, part = %llu, last = %llu/n", file_size, parts, part_size, file_size - (parts - 1) * part_size);		struct fuse_args args = FUSE_ARGS_INIT(0, NULL);	fuse_opt_add_arg(&args, argv[0]);	fuse_opt_add_arg(&args, "-s"); // single, not need blocking	int i;	for (i = 3; i < argc; ++i)		fuse_opt_add_arg(&args, argv[i]);			int res = fuse_main(args.argc, args.argv, &my_operations, NULL);	curl_global_cleanup();	return res;}

intmain(int argc, char *argv[]){    int res = 0;    struct fuse_args args = FUSE_ARGS_INIT(argc, argv);    loopback.case_insensitive = 0;    if (fuse_opt_parse(&args, &loopback, loopback_opts, NULL) == -1) {		exit(1);    }    umask(0);    res = fuse_main(args.argc, args.argv, &loopback_oper, NULL);    fuse_opt_free_args(&args);    return res;}

int main(int argc, char **argv){    struct fuse_args args = FUSE_ARGS_INIT(argc, argv);    fuse_opt_parse(&args, NULL, NULL, fuse_ext2_opt_args);    if(ext2_dev) {        if(fuse_ext2_init(ext2_dev) == -1) {            fs_printf("unable to initialize disk device./n");            return -1;        }            } else {        // TODO    }    return (fuse_main(args.argc, args.argv, &fuse_ext2_ops, NULL)); }

void process_arguments(int argc, char **argv){	struct zfs_opts zopts;	main_args = (struct fuse_args)FUSE_ARGS_INIT(argc, argv);	memset(&zopts, 0, sizeof(zopts));	if (fuse_opt_parse		(&main_args, &zopts, main_options, handle_one_argument) != 0)	{		usage();		exit(EXIT_FAILURE);	}	if (zopts.config)	{		set_local_config_path(zopts.config);	}	set_log_level(&syplogger, zopts.loglevel);	// start zfsd on background or foreground	int foreground;	int rv;	char * mountpoint;	rv = fuse_parse_cmdline(&main_args, &mountpoint, NULL, &foreground);	if (rv == -1)	{		message(LOG_INFO, FACILITY_ZFSD, "Failed to parse fuse cmdline options./n");		exit(EXIT_FAILURE);	}	set_mountpoint(mountpoint);	free(mountpoint);#ifndef ENABLE_CLI_CONSOLE //cli use console, don't daemonize	rv = fuse_daemonize(foreground);	if (rv == -1)	{		message(LOG_INFO, FACILITY_ZFSD, "Failed to daemonize zfsd./n");		exit(EXIT_FAILURE);	}#endif}

static voidfuseMount(CompDisplay *d){   char *mountPoint;   struct fuse_args args = FUSE_ARGS_INIT(0, NULL);   FUSE_DISPLAY(d);   mountPoint = strdup(fd->opt[FUSE_DISPLAY_OPTION_MOUNT_POINT].value.s);   if (!mountPoint)     return;   fuse_opt_add_arg(&args, "");   fuse_opt_add_arg(&args, "-o");   fuse_opt_add_arg(&args, "allow_root");   fd->channel = fuse_mount(mountPoint, &args);   if (!fd->channel)     {        fuse_opt_free_args(&args);        free(mountPoint);        return;     }   fuse_opt_free_args(&args);   fd->buffer = malloc(fuse_chan_bufsize(fd->channel));   if (!fd->buffer)     {        fuse_unmount(mountPoint, fd->channel);        free(mountPoint);        fd->channel = NULL;        return;     }   fd->mountPoint = mountPoint;   fuse_session_add_chan(fd->session, fd->channel);   fd->watchFdHandle = compAddWatchFd(fuse_chan_fd(fd->channel),                                      POLLIN | POLLPRI | POLLHUP | POLLERR,                                      fuseProcessMessages,                                      d);}

struct fuse *fuse_setup(int argc, char *argv[],		const struct fuse_operations *op, size_t op_size,		char **mountpoint, int *multithreaded, void *user_data){	struct fuse_args args = FUSE_ARGS_INIT(argc, argv);	struct fuse_chan *ch=NULL;	struct fuse *fuse;	int foreground;	int res;	res = fuse_parse_cmdline(&args, mountpoint, multithreaded, &foreground);	rDebug("res=%i", res);	if (res == -1)		return NULL;	ch = fuse_mount(*mountpoint, &args);	fuse = fuse_new(ch, &args, op, op_size, user_data);	fuse_opt_free_args(&args);	if (fuse == NULL || ch==NULL)		goto err_unmount;	res = fuse_daemonize(foreground);	rDebug("res=%i", res);	if (res == -1)		goto err_unmount;	if (fuse->conf.setsignals)	{		res = fuse_set_signal_handlers(fuse_get_session(fuse));		rDebug("res=%i", res);		if (res == -1)			goto err_unmount;	}	return fuse;err_unmount:	fuse_unmount(*mountpoint, ch);	if (fuse)		fuse_destroy(fuse);	free(*mountpoint);	return NULL;}

int main(int argc, char *argv[]){	struct fuse_args args = FUSE_ARGS_INIT(argc, argv);	int rc;	bzero(&zdsfsinfo, sizeof(zdsfsinfo));	zdsfsinfo.keepRDW = 0;	zdsfsinfo.allow_inclomplete_multi_volume = 0;	zdsfsinfo.tracks_per_frame = 128;	zdsfsinfo.seek_buffer_size = 1048576;	rc = lzds_zdsroot_alloc(&zdsfsinfo.zdsroot);	if (rc) {		fprintf(stderr, "Could not allocate internal structures/n");		exit(1);	}	if (fuse_opt_parse(&args, &zdsfsinfo, zdsfs_opts,			   zdsfs_process_args) == -1) {		fprintf(stderr, "Failed to parse option/n");		exit(1);	}	if (!zdsfsinfo.devcount) {		fprintf(stderr, "Please specify a block device/n");		fprintf(stderr, "Try '%s --help' for more information/n",			argv[0]);		exit(1);	}	rc = zdsfs_verify_datasets();	if (rc)		goto cleanup;	rc = zdsfs_create_meta_data_buffer(&zdsfsinfo);	if (rc)		goto cleanup;	rc = fuse_main(args.argc, args.argv, &rdf_oper, NULL);cleanup:	lzds_zdsroot_free(zdsfsinfo.zdsroot);	fuse_opt_free_args(&args);	return rc;}