int fuse_loop_mt(struct fuse *f)
{
if (f == NULL)
return -1;
return fuse_session_loop_mt(fuse_get_session(f));
}
static gboolean manage_fuse_st (GIOChannel *source, GIOCondition condition, gpointer data)
{
int res;
char *buf;
gboolean ret;
size_t bufsize;
struct fuse *fuse;
struct fuse_session *se;
struct fuse_chan *ch;
fuse = (struct fuse*) data;
se = fuse_get_session (fuse);
ch = fuse_session_next_chan (se, NULL);
bufsize = fuse_chan_bufsize (ch);
buf = alloca (bufsize);
ret = TRUE;
res = fuse_chan_recv (&ch, buf, bufsize);
if (res == -EINTR)
ret = TRUE;
else if (res <= 0)
ret = FALSE;
else
fuse_session_process (se, buf, res, ch);
return ret;
}
int main(int argc, char** argv) {
struct fuse_args args = FUSE_ARGS_INIT(argc, argv);
char* mountpoint;
int multithreaded;
int foreground;
if (fuse_opt_parse(&args, NULL, tfs_opts, tfs_opt_proc) == -1)
return 1;
if (fuse_parse_cmdline(&args, &mountpoint, &multithreaded, &foreground) == -1)
return 1;
struct fuse_chan *ch = fuse_mount(mountpoint, &args);
if (!ch)
return 1;
struct fuse *fuse = fuse_new(ch, &args, &tfs_oper, sizeof(struct fuse_operations), NULL);
if (!fuse) {
fuse_unmount(mountpoint, ch);
return 1;
}
if (options.debug == 1 || foreground == 1) {
if (fuse_daemonize(foreground) != -1)
return 1;
}
if (fuse_set_signal_handlers(fuse_get_session(fuse)) == -1) {
fuse_unmount(mountpoint, ch);
fuse_destroy(fuse);
return 1;
}
initMultiCastListener();
if (multithreaded)
return fuse_loop_mt(fuse);
if (!options.debug)
fprintf(stderr, "Running single threaded and we are not debugging, your performance may suffer.\n");
return fuse_loop(fuse);
};
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;
#ifdef __APPLE__
if (!*mountpoint) {
fprintf(stderr, "fuse: no mount point\n");
return NULL;
}
#endif
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;
}
static void fuse_teardown_common(struct fuse *fuse, char *mountpoint)
{
struct fuse_session *se = fuse_get_session(fuse);
struct fuse_chan *ch = fuse_session_next_chan(se, NULL);
fuse_remove_signal_handlers(se);
fuse_unmount_common(mountpoint, ch);
fuse_destroy(fuse);
free(mountpoint);
}
void fuse_teardown(struct fuse *fuse, char *mountpoint) {
struct fuse_session *se = fuse_get_session(fuse);
struct fuse_chan *ch = se->ch;
if (fuse->conf.setsignals)
fuse_remove_signal_handlers(se);
fuse_unmount(mountpoint, ch);
fuse_destroy(fuse);
free(mountpoint);
}
/* ----------------------------------------------------- */
int main(int argc,char* argv[])
{
signal(SIGINT, fs_sigint_handler);
fs_set_limit_attr();
if (mpinit(0, 50)) return -1;
voolefs.tc = 10;
voolefs.tpool = threadpool_init(voolefs.tc ,10);
voolefs.cinc = 8;
voolefs.phost = mpcalloc(sizeof(struct host));
voolefs.phost->host = inet_addr("123.125.149.11");
voolefs.phost->port = htons(4869);
voolefs.hostc = 1;
voolefs.semc = 20;
char* pmpoint = fs_create_mountpoint();
struct fuse_args args = FUSE_ARGS_INIT(argc, argv);
char *fsname =(char*)mpcalloc(256);
sprintf(fsname,"-osubtype=%s,fsname=%s",argv[0],pmpoint);
mpfree(pmpoint);
int ret = fuse_opt_parse(&args, NULL,NULL,NULL /*&voolefs, voolefs_opts, fs_opt_proc*/);
int multithreaded = 0;
int foreground = 0;
ret = fuse_opt_insert_arg(&args,1,fsname);
/* if (fuse_is_lib_option("ac_attr_timeout="))
fuse_opt_insert_arg(&args, 1, "-oauto_cache,ac_attr_timeout=0");
*/ ret = fuse_parse_cmdline(&args, &voolefs.mountpoint, &multithreaded, &foreground);
voolefs.ch = fuse_mount(voolefs.mountpoint, &args);
// event_reinit(voolefs.ev_base);
if(voolefs.ch)
{
ret = fcntl(fuse_chan_fd(voolefs.ch), F_SETFD, FD_CLOEXEC);
voolefs.fuse = fuse_new(voolefs.ch,&args,&oper,sizeof(struct fuse_operations),NULL);
if (voolefs.fuse == NULL)
{
fs_cleanup();
abort();
}
fs_daemonize(0);
voole_net_create();
/* if( multithreaded)
ret = fuse_loop_mt(voolefs.fuse);
else
*/ ret = fuse_loop(voolefs.fuse);
}
if( voolefs.fuse )
fuse_remove_signal_handlers(fuse_get_session(voolefs.fuse));
mpfree(fsname);
if( voolefs.peventbase )
{
event_base_free(voolefs.peventbase);
voolefs.peventbase = NULL;
}
return ret;
}
static gboolean manage_fuse_mt (GIOChannel *source, GIOCondition condition, gpointer data)
{
int res;
char *buf;
size_t bufsize;
struct fuse *fuse;
struct fuse_session *se;
struct fuse_chan *ch;
GThreadPool *pool;
GError *error;
ThreadsData *info;
fuse = (struct fuse*) data;
error = NULL;
pool = g_thread_pool_new (manage_request, fuse, -1, FALSE, &error);
if (pool == NULL) {
g_warning ("Unable to start thread pool: %s", error->message);
g_error_free (error);
return NULL;
}
se = fuse_get_session (fuse);
ch = fuse_session_next_chan (se, NULL);
bufsize = fuse_chan_bufsize (ch);
while (1) {
buf = (char*) malloc (bufsize);
res = fuse_chan_recv (&ch, buf, bufsize);
if (res == -EINTR) {
free (buf);
continue;
}
else if (res <= 0) {
free (buf);
break;
}
info = do_threads_data (buf, res);
error = NULL;
g_thread_pool_push (pool, info, &error);
if (error != NULL) {
g_warning ("Unable to start processing request: %s", error->message);
g_error_free (error);
free_threads_data (info);
}
}
g_thread_pool_free (pool, TRUE, TRUE);
return NULL;
}
static void manage_request (gpointer data, gpointer user)
{
struct fuse *fuse;
struct fuse_session *se;
struct fuse_chan *ch;
ThreadsData *info;
fuse = (struct fuse*) user;
info = (ThreadsData*) data;
se = fuse_get_session (fuse);
ch = fuse_session_next_chan (se, NULL);
fuse_session_process (se, info->buf, info->res, ch);
free_threads_data (info);
}
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;
}
/**
* gfuse_loop_run:
* @loop: the #GFuseLoop to run
*
* Runs a #GFuseLoop, mounting it and adding polling of the FUSE channel in
* the mainloop. If multi-thread is required, also allocates all working
* threads
*/
void gfuse_loop_run (GFuseLoop *loop)
{
int thread;
struct fuse_session *se;
struct fuse_chan *ch;
struct fuse *fuse_session;
if (loop->priv->real_ops == NULL) {
g_warning ("Invalid initialization of GFuseLoop, no operations loaded");
return;
}
loop->priv->runtime_data = g_new0 (PrivateDataBlock, 1);
loop->priv->runtime_data->loop = loop;
loop->priv->shadow_ops = g_new0 (struct fuse_operations, 1);
memcpy (loop->priv->shadow_ops, loop->priv->real_ops, sizeof (struct fuse_operations));
loop->priv->shadow_ops->init = internal_init_wrapper;
fuse_session = fuse_setup (loop->priv->startup_argc, loop->priv->startup_argv,
loop->priv->shadow_ops, sizeof (struct fuse_operations),
&loop->priv->mountpoint, &thread, loop->priv->runtime_data);
loop->priv->threads = (thread != 0);
se = fuse_get_session (fuse_session);
ch = fuse_session_next_chan (se, NULL);
loop->priv->fuse_fd = g_io_channel_unix_new (fuse_chan_fd (ch));
/**
TODO Provide implementation also for multi-threads
*/
/*
if (thread)
g_io_add_watch (loop->priv->fuse_fd, G_IO_IN, manage_fuse_mt, fuse_session);
else
g_io_add_watch (loop->priv->fuse_fd, G_IO_IN, manage_fuse_st, fuse_session);
*/
g_io_add_watch (loop->priv->fuse_fd, G_IO_IN, manage_fuse_st, fuse_session);
}
int fuse_loop_mt_proc(struct fuse *f, fuse_processor_t proc, void *data)
{
int res;
struct procdata pd;
struct fuse_session *prevse = fuse_get_session(f);
struct fuse_session *se;
struct fuse_chan *prevch = fuse_session_next_chan(prevse, NULL);
struct fuse_chan *ch;
struct fuse_session_ops sop = {
.exit = mt_session_exit,
.exited = mt_session_exited,
.process = mt_session_proc,
};
struct fuse_chan_ops cop = {
.receive = mt_chan_receive,
.send = mt_chan_send,
};
pd.f = f;
pd.prevch = prevch;
pd.prevse = prevse;
pd.proc = proc;
pd.data = data;
se = fuse_session_new(&sop, &pd);
if (se == NULL)
return -1;
ch = fuse_chan_new(&cop, fuse_chan_fd(prevch), sizeof(struct fuse_cmd *),
&pd);
if (ch == NULL) {
fuse_session_destroy(se);
return -1;
}
fuse_session_add_chan(se, ch);
res = fuse_session_loop_mt(se);
fuse_session_destroy(se);
return res;
}
// run fskit with fuse
int fskit_fuse_main( struct fskit_fuse_state* state, int argc, char** argv ) {
int rc = 0;
// set up FUSE
struct fuse_args args = FUSE_ARGS_INIT(argc, argv);
struct fuse_chan* ch = NULL;
struct fuse* fs = NULL;
int multithreaded = 1;
int foreground = 0;
char* mountpoint = NULL;
// parse command-line...
rc = fuse_parse_cmdline( &args, &mountpoint, &multithreaded, &foreground );
if( rc < 0 ) {
fskit_error("fuse_parse_cmdline rc = %d\n", rc );
fuse_opt_free_args(&args);
return rc;
}
if( mountpoint == NULL ) {
fskit_error("%s", "No mountpoint given\n");
fuse_opt_free_args(&args);
return rc;
}
state->mountpoint = strdup( mountpoint );
// mount
ch = fuse_mount( mountpoint, &args );
if( ch == NULL ) {
rc = -errno;
fskit_error("fuse_mount failed, errno = %d\n", rc );
fuse_opt_free_args(&args);
if( rc == 0 ) {
rc = -EPERM;
}
return rc;
}
// create the filesystem
fs = fuse_new( ch, &args, &state->ops, sizeof(state->ops), state );
fuse_opt_free_args(&args);
if( fs == NULL ) {
// failed
rc = -errno;
fskit_error("fuse_new failed, errno = %d\n", rc );
fuse_unmount( mountpoint, ch );
if( rc == 0 ) {
rc = -EPERM;
}
return rc;
}
// daemonize if running in the background
fskit_debug("FUSE daemonize: foreground=%d\n", foreground);
rc = fuse_daemonize( foreground );
if( rc != 0 ) {
// failed
fskit_error("fuse_daemonize(%d) rc = %d\n", foreground, rc );
fuse_unmount( mountpoint, ch );
fuse_destroy( fs );
return rc;
}
// set up FUSE signal handlers
rc = fuse_set_signal_handlers( fuse_get_session(fs) );
if( rc < 0 ) {
// failed
fskit_error("fuse_set_signal_handlers rc = %d\n", rc );
fuse_unmount( mountpoint, ch );
fuse_destroy( fs );
return rc;
}
// if we have a post-mount callback, call it now, since FUSE is ready to receive requests
if( state->postmount != NULL ) {
rc = (*state->postmount)( state, state->postmount_cls );
if( rc != 0 ) {
fskit_error("fskit postmount callback rc = %d\n", rc );
fuse_unmount( mountpoint, ch );
fuse_destroy( fs );
return rc;
}
}
// run the filesystem--start processing requests
fskit_debug("%s", "FUSE main loop entered\n");
if( multithreaded ) {
rc = fuse_loop_mt( fs );
}
else {
rc = fuse_loop( fs );
}
fskit_debug("%s", "FUSE main loop finished\n");
fuse_teardown( fs, mountpoint );
return rc;
}
int main(int argc, char* argv[])
{
struct fuse_args mount_args = FUSE_ARGS_INIT(0, NULL);
struct fuse_args newfs_args = FUSE_ARGS_INIT(0, NULL);
const char* spec = NULL;
const char* mount_point = NULL;
char* mount_options;
int debug = 0;
struct fuse_chan* fc = NULL;
struct fuse* fh = NULL;
int opt;
printf("FUSE exfat %u.%u.%u\n",
EXFAT_VERSION_MAJOR, EXFAT_VERSION_MINOR, EXFAT_VERSION_PATCH);
mount_options = strdup(default_options);
if (mount_options == NULL)
{
exfat_error("failed to allocate options string");
return 1;
}
while ((opt = getopt(argc, argv, "dno:Vv")) != -1)
{
switch (opt)
{
case 'd':
debug = 1;
break;
case 'n':
break;
case 'o':
mount_options = add_option(mount_options, optarg, NULL);
if (mount_options == NULL)
return 1;
break;
case 'V':
free(mount_options);
puts("Copyright (C) 2010-2014 Andrew Nayenko");
return 0;
case 'v':
break;
default:
free(mount_options);
usage(argv[0]);
break;
}
}
if (argc - optind != 2)
{
free(mount_options);
usage(argv[0]);
}
spec = argv[optind];
mount_point = argv[optind + 1];
if (exfat_mount(&ef, spec, mount_options) != 0)
{
free(mount_options);
return 1;
}
if (ef.ro == -1) /* read-only fallback was used */
{
mount_options = add_option(mount_options, "ro", NULL);
if (mount_options == NULL)
{
exfat_unmount(&ef);
return 1;
}
}
mount_options = add_fuse_options(mount_options, spec);
if (mount_options == NULL)
{
exfat_unmount(&ef);
return 1;
}
/* create arguments for fuse_mount() */
if (fuse_opt_add_arg(&mount_args, "exfat") != 0 ||
fuse_opt_add_arg(&mount_args, "-o") != 0 ||
fuse_opt_add_arg(&mount_args, mount_options) != 0)
{
exfat_unmount(&ef);
free(mount_options);
return 1;
}
free(mount_options);
/* create FUSE mount point */
fc = fuse_mount(mount_point, &mount_args);
fuse_opt_free_args(&mount_args);
if (fc == NULL)
{
exfat_unmount(&ef);
return 1;
}
/* create arguments for fuse_new() */
if (fuse_opt_add_arg(&newfs_args, "") != 0 ||
(debug && fuse_opt_add_arg(&newfs_args, "-d") != 0))
{
fuse_unmount(mount_point, fc);
exfat_unmount(&ef);
return 1;
}
/* create new FUSE file system */
fh = fuse_new(fc, &newfs_args, &fuse_exfat_ops,
sizeof(struct fuse_operations), NULL);
fuse_opt_free_args(&newfs_args);
if (fh == NULL)
{
fuse_unmount(mount_point, fc);
exfat_unmount(&ef);
return 1;
}
/* exit session on HUP, TERM and INT signals and ignore PIPE signal */
if (fuse_set_signal_handlers(fuse_get_session(fh)) != 0)
{
fuse_unmount(mount_point, fc);
fuse_destroy(fh);
exfat_unmount(&ef);
exfat_error("failed to set signal handlers");
return 1;
}
/* go to background (unless "-d" option is passed) and run FUSE
main loop */
if (fuse_daemonize(debug) == 0)
{
if (fuse_loop(fh) != 0)
exfat_error("FUSE loop failure");
}
else
exfat_error("failed to daemonize");
fuse_remove_signal_handlers(fuse_get_session(fh));
/* note that fuse_unmount() must be called BEFORE fuse_destroy() */
fuse_unmount(mount_point, fc);
fuse_destroy(fh);
return 0;
}
int main(int argc, char *argv[])
{
int ret = -1;
int lockfd = -1;
gboolean foreground = FALSE;
gboolean force_local_mode = FALSE;
gboolean wrote_pidfile = FALSE;
memdb_t *memdb = NULL;
dfsm_t *dcdb = NULL;
dfsm_t *status_fsm = NULL;
qb_log_init("pmxcfs", LOG_DAEMON, LOG_DEBUG);
/* remove default filter */
qb_log_filter_ctl(QB_LOG_SYSLOG, QB_LOG_FILTER_REMOVE,
QB_LOG_FILTER_FILE, "*", LOG_DEBUG);
qb_log_tags_stringify_fn_set(log_tags_stringify);
qb_log_ctl(QB_LOG_STDERR, QB_LOG_CONF_ENABLED, QB_TRUE);
update_qb_log_settings();
g_set_print_handler(glib_print_handler);
g_set_printerr_handler(glib_print_handler);
g_log_set_default_handler(glib_log_handler, NULL);
GOptionContext *context;
GOptionEntry entries[] = {
{ "debug", 'd', 0, G_OPTION_ARG_NONE, &cfs.debug, "Turn on debug messages", NULL },
{ "foreground", 'f', 0, G_OPTION_ARG_NONE, &foreground, "Do not daemonize server", NULL },
{ "local", 'l', 0, G_OPTION_ARG_NONE, &force_local_mode,
"Force local mode (ignore cluster.conf, force quorum)", NULL },
{ NULL },
};
context = g_option_context_new ("");
g_option_context_add_main_entries (context, entries, NULL);
GError *err = NULL;
if (!g_option_context_parse (context, &argc, &argv, &err))
{
cfs_critical("option parsing failed: %s", err->message);
g_error_free (err);
qb_log_fini();
exit (1);
}
g_option_context_free(context);
if (optind < argc) {
cfs_critical("too many arguments");
qb_log_fini();
exit(-1);
}
if (cfs.debug) {
update_qb_log_settings();
}
struct utsname utsname;
if (uname(&utsname) != 0) {
cfs_critical("Unable to read local node name");
qb_log_fini();
exit (-1);
}
for (int i=0; i < sizeof(utsname.nodename); i++) {
if (utsname.nodename[i] =='.') utsname.nodename[i] = 0;
}
cfs.nodename = g_strdup(utsname.nodename);
if (!(cfs.ip = lookup_node_ip(cfs.nodename))) {
cfs_critical("Unable to get local IP address");
qb_log_fini();
exit(-1);
}
struct group *www_data = getgrnam("www-data");
if (!www_data) {
cfs_critical("Unable to get www-data group ID");
qb_log_fini();
exit (-1);
}
cfs.gid = www_data->gr_gid;
g_thread_init(NULL);
umask(027);
mkdir(VARLIBDIR, 0755);
if ((lockfd = open(LOCKFILE, O_RDWR|O_CREAT|O_APPEND)) == -1) {
cfs_critical("unable to create lock '%s': %s", LOCKFILE, strerror (errno));
goto err;
}
for (int i = 10; i >= 0; i--) {
if (flock(lockfd, LOCK_EX|LOCK_NB) != 0) {
if (!i) {
cfs_critical("unable to aquire pmxcfs lock: %s", strerror (errno));
goto err;
}
if (i == 10)
cfs_message("unable to aquire pmxcfs lock - trying again");
sleep(1);
}
}
cfs_status_init();
gboolean create = !g_file_test(DBFILENAME, G_FILE_TEST_EXISTS);
if (!(memdb = memdb_open (DBFILENAME))) {
cfs_critical("memdb_open failed - unable to open database '%s'", DBFILENAME);
goto err;
}
// automatically import cluster.conf from host
if (create && !force_local_mode) {
char *cdata = NULL;
gsize clen = 0;
if (g_file_get_contents(HOST_CLUSTER_CONF_FN, &cdata, &clen, NULL)) {
guint32 mtime = time(NULL);
memdb_create(memdb, "/cluster.conf", 0, mtime);
if (memdb_write(memdb, "/cluster.conf", 0, mtime, cdata, clen, 0, 1) < 0) {
cfs_critical("memdb_write failed - unable to import cluster.conf");
goto err;
}
}
}
// does cluster.conf exist?
gpointer conf_data = NULL;
int len = memdb_read(memdb, "cluster.conf", &conf_data);
if (len >= 0) {
if (force_local_mode) {
cfs_message("forcing local mode (althought cluster.conf exists)");
cfs_set_quorate(1, TRUE);
} else {
if (!(dcdb = dcdb_new(memdb)))
goto err;
dcdb_sync_cluster_conf(memdb, 1);
}
} else {
cfs_debug("using local mode (cluster.conf does not exist)");
cfs_set_quorate(1, TRUE);
}
if (conf_data) g_free(conf_data);
cfs_plug_memdb_t *config = cfs_plug_memdb_new("memdb", memdb, dcdb);
cfs_plug_base_t *bplug = cfs_plug_base_new("", (cfs_plug_t *)config);
create_symlinks(bplug, cfs.nodename);
root_plug = (cfs_plug_t *)bplug;
system("umount -f " CFSDIR " >/dev/null 2>&1");
char *fa[] = { "-f", "-odefault_permissions", "-oallow_other", NULL};
struct fuse_args fuse_args = FUSE_ARGS_INIT(sizeof (fa)/sizeof(gpointer) - 1, fa);
struct fuse_chan *fuse_chan = fuse_mount(CFSDIR, &fuse_args);
if (!fuse_chan) {
cfs_critical("fuse_mount error: %s", strerror(errno));
goto err;
}
if (!(fuse = fuse_new(fuse_chan, &fuse_args, &fuse_ops, sizeof(fuse_ops), NULL))) {
cfs_critical("fuse_new error: %s", strerror(errno));
goto err;
}
fuse_set_signal_handlers(fuse_get_session(fuse));
if (!foreground) {
pid_t cpid = fork();
if (cpid == -1) {
cfs_critical("failed to daemonize program - %s", strerror (errno));
goto err;
} else if (cpid) {
write_pidfile(cpid);
qb_log_fini();
_exit (0);
} else {
int nullfd;
chroot("/");
if ((nullfd = open("/dev/null", O_RDWR, 0)) != -1) {
dup2(nullfd, 0);
dup2(nullfd, 1);
dup2(nullfd, 2);
if (nullfd > 2)
close (nullfd);
}
// do not print to the console after this point
qb_log_ctl(QB_LOG_STDERR, QB_LOG_CONF_ENABLED, QB_FALSE);
setsid();
}
} else {
write_pidfile(getpid());
}
wrote_pidfile = TRUE;
cfs_loop_t *corosync_loop = cfs_loop_new(fuse);
cfs_service_t *service_quorum = NULL;
cfs_service_t *service_confdb = NULL;
cfs_service_t *service_dcdb = NULL;
cfs_service_t *service_status = NULL;
if (dcdb) {
service_quorum = service_quorum_new();
cfs_loop_add_service(corosync_loop, service_quorum, QB_LOOP_HIGH);
service_confdb = service_confdb_new();
cfs_loop_add_service(corosync_loop, service_confdb, QB_LOOP_MED);
service_dcdb = service_dfsm_new(dcdb);
cfs_service_set_timer(service_dcdb, DCDB_VERIFY_TIME);
cfs_loop_add_service(corosync_loop, service_dcdb, QB_LOOP_MED);
status_fsm = cfs_status_dfsm_new();
service_status = service_dfsm_new(status_fsm);
cfs_loop_add_service(corosync_loop, service_status, QB_LOOP_LOW);
}
cfs_loop_start_worker(corosync_loop);
server_start(memdb);
ret = fuse_loop_mt(fuse);
cfs_message("teardown filesystem");
server_stop();
fuse_unmount(CFSDIR, fuse_chan);
fuse_destroy(fuse);
cfs_debug("set stop event loop flag");
cfs_loop_stop_worker(corosync_loop);
cfs_loop_destroy(corosync_loop);
cfs_debug("worker finished");
if (service_dcdb)
service_dfsm_destroy(service_dcdb);
if (service_confdb)
service_confdb_destroy(service_confdb);
if (service_quorum)
service_quorum_destroy(service_quorum);
if (service_status)
service_dfsm_destroy(service_status);
sleep(1); /* do not restart too fast */
ret:
if (status_fsm)
dfsm_destroy(status_fsm);
if (dcdb)
dfsm_destroy(dcdb);
if (memdb)
memdb_close(memdb);
if (wrote_pidfile)
unlink(CFS_PID_FN);
cfs_message("exit proxmox configuration filesystem (%d)", ret);
cfs_status_cleanup();
qb_log_fini();
exit(ret);
err:
goto ret;
}
/*
* Class: org_catacombae_jfuse_FUSE
* Method: mountNative26
* Signature: (Lorg/catacombae/jfuse/FUSE26FileSystem;Ljava/lang/String;[Ljava/lang/String;Lorg/catacombae/jfuse/FUSE26Capabilities;Lorg/catacombae/jfuse/MacFUSE20Capabilities;)Z
*/
JNIEXPORT jboolean JNICALL Java_org_catacombae_jfuse_FUSE_mountNative26(
JNIEnv *env, jclass cls, jobject fileSystem, jstring mountPoint,
jobjectArray optionStrings, jobject fuseCapabilities,
jobject macFuseCapabilities) {
#define _FNAME_ "Java_org_catacombae_jfuse_FUSE_mountNative26"
CSLogTraceEnter(_FNAME_ "(%p, %p, %p, %p, %p, %p, %p)", env, cls,
fileSystem, mountPoint, optionStrings, fuseCapabilities,
macFuseCapabilities);
jboolean res = JNI_FALSE;
jFUSEContext *context = new jFUSEContext(env, fileSystem);
if(!fillFUSE26Operations(env, fuseCapabilities, &jfuse_operations))
CSPanicWithMessage("Could not fill FUSE 2.6 operations!");
else
CSLogDebug("Filled FUSE 2.6 operations.");
if(jfuse_operations.init != NULL) {
context->setInitEnabled(true);
}
#if defined(__APPLE__) || defined(__DARWIN__)
#if (__FreeBSD__ >= 10)
if(macFuseCapabilities != NULL) {
if(!fillMacFUSE20Operations(env, macFuseCapabilities,
&jfuse_operations))
CSPanicWithMessage("Could not fill MacFUSE 2.0 operations!");
else {
CSLogDebug("Filled MacFUSE 2.0 operations.");
if(jfuse_operations.getxtimes != NULL ||
jfuse_operations.setbkuptime != NULL ||
jfuse_operations.setcrtime != NULL ||
jfuse_operations.setchgtime != NULL) {
CSLogDebug("Requesting enabling of xtimes.");
context->setXtimesEnabled(true);
if(jfuse_operations.init == NULL) {
CSLogDebug("Adding operation 'init' to fuse_operations for "
"support enabling of xtimes...");
jfuse_operations.init = jfuse_init;
}
}
}
}
else
CSLogDebug("No MacFUSE 2.0 operations to fill.");
#endif /*__FreeBSD__ >= 10 */
#endif /* defined(__APPLE__) || defined(__DARWIN__) */
/* Read mountpoint. */
jboolean isCopy;
const char *utf8MountPoint = env->GetStringUTFChars(mountPoint, &isCopy);
/* Read options. */
struct fuse_args args = FUSE_ARGS_INIT(0, NULL);
if(fuse_opt_add_arg(&args, utf8MountPoint) != 0)
CSPanicWithMessage("fuse_opt_add_arg failed unexpectedly.");
jsize optionStringsLength = env->GetArrayLength(optionStrings);
CSLogDebug("Reading option strings (length=%ld)...", (long)optionStringsLength);
for(int i = 0; i < optionStringsLength; ++i) {
jstring cur = (jstring)env->GetObjectArrayElement(optionStrings, i);
const char *utfChars = env->GetStringUTFChars(cur, NULL);
CSLogDebug(" Adding option %d: \"%s\"", i, utfChars);
int addArgRetval = fuse_opt_add_arg(&args, utfChars);
if(addArgRetval != 0)
CSPanicWithMessage("fuse_opt_add_arg failed unexpectedly with "
"retval=%d, errno: %d (%s)", addArgRetval, errno,
strerror(errno));
env->ReleaseStringUTFChars(cur, utfChars);
env->DeleteLocalRef(cur);
}
if(fuse_parse_cmdline(&args, NULL, NULL, NULL) != 0)
CSLogError("fuse_parse_cmdline didn't return 0.");
else {
/*
* FUSE regular mount procedure:
*
* Init:
* - fuse_mount:
* (char *mountpoint, struct fuse_args *args)-> (struct fuse_chan*)
* - fuse_new:
* (struct fuse_chan *ch, struct fuse_args *args,
* struct fuse_operations *op, size_t op_size, void *user_data)
* ->(struct fuse*)
* Running:
* - fuse_loop / fuse_loop_mt:
* (struct fuse*)->(int)
* Main loop, running until file system is unmounted.
* Cleanup:
* - fuse_unmount:
* (char *mountpoint, struct fuse_chan *ch)->(void)
* - fuse_destroy:
* (struct fuse* f)->(void)
*
*
* FUSE lowlevel mount procedure:
*
* Init:
* - fuse_mount:
* (char *mountpoint, struct fuse_args *args)->(struct fuse_chan*)
* - fuse_lowlevel_new:
* (struct fuse_args *args, struct fuse_lowlevel_ops *op,
* size_t op_size, void *userdata) -> (struct fuse_session*)
* - fuse_session_add_chan:
* (struct fuse_session *se, struct fuse_chan *ch)->(void)
* Running:
* - fuse_session_loop / fuse_session_loop_mt:
* (struct fuse_session *se)->(int)
* Cleanup:
* - fuse_session_remove_chan:
* (struct fuse_chan *ch)->(void)
* - fuse_session_destroy:
* (struct fuse_session *se)->(void)
* - fuse_unmount:
* (char *mountpoint, struct fuse_chan *ch)->(void)
*/
fuse_chan *chan = NULL;
fuse *fh = NULL;
CSLogDebug("Invoking fuse_mount...");
chan = fuse_mount(utf8MountPoint, &args);
CSLogDebug(" done. result=%p", chan);
if(chan != NULL) {
CSLogDebug("Invoking fuse_new...");
fh = fuse_new(chan, &args, &jfuse_operations,
sizeof (jfuse_operations), context);
CSLogDebug(" done. result=%p", fh);
if(fh != NULL) {
#if defined(__NetBSD__)
int sighandler_res = 0;
#else
int sighandler_res =
fuse_set_signal_handlers(fuse_get_session(fh));
#endif /* defined(__NetBSD__) */
if(sighandler_res == 0) {
CSLogDebug("Invoking fuse_loop...");
int fuseLoopRetval = fuse_loop(fh);
CSLogDebug(" done. result=%d", fuseLoopRetval);
if(fuseLoopRetval != 0)
CSLogError("fuse_loop exited with a non-zero value: %d "
"(errno is %d (%s)", fuseLoopRetval, errno,
strerror(errno));
else
res = JNI_TRUE;
#if !defined(__NetBSD__)
fuse_remove_signal_handlers(fuse_get_session(fh));
#endif
}
else
CSLogError("Couldn't set signal handlers!");
}
else
CSLogError("fuse_new exited with an error. (errno is %d (%s))",
errno, strerror(errno));
}
else
CSLogError("fuse_mount exited with an error. (errno is %d (%s))",
errno, strerror(errno));
fuse_opt_free_args(&args);
if(chan != NULL) {
CSLogDebug("Unmounting \"%s\"... (chan=%p)", utf8MountPoint, chan);
fuse_unmount(utf8MountPoint, chan);
}
if(fh != NULL) {
CSLogDebug("Destroying fuse filehandle %p...", fh);
fuse_destroy(fh);
}
delete context;
}
CSLogTraceLeave(_FNAME_ "(%p, %p, %p, %p, %p, %p, %p): %d", env, cls,
fileSystem, mountPoint, optionStrings, fuseCapabilities,
macFuseCapabilities, res);
return res;
#undef _FNAME_
}