695 lines
16 KiB
C
695 lines
16 KiB
C
/* $NetBSD: puffs.c,v 1.117 2011/11/14 01:27:42 chs Exp $ */
|
|
|
|
/*
|
|
* Copyright (c) 2005, 2006, 2007 Antti Kantee. All Rights Reserved.
|
|
*
|
|
* Development of this software was supported by the
|
|
* Google Summer of Code program and the Ulla Tuominen Foundation.
|
|
* The Google SoC project was mentored by Bill Studenmund.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
|
|
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
|
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*/
|
|
|
|
#include <sys/cdefs.h>
|
|
#if !defined(lint)
|
|
__RCSID("$NetBSD: puffs.c,v 1.117 2011/11/14 01:27:42 chs Exp $");
|
|
#endif /* !lint */
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/mount.h>
|
|
|
|
#if defined(__minix)
|
|
#include "fs.h"
|
|
#endif /* defined(__minix) */
|
|
|
|
#include <assert.h>
|
|
#include <err.h>
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <mntopts.h>
|
|
#include <paths.h>
|
|
#include <puffs.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <syslog.h>
|
|
#include <unistd.h>
|
|
|
|
#include "puffs_priv.h"
|
|
|
|
/* Most file systems want this for opts, so just give it to them */
|
|
const struct mntopt puffsmopts[] = {
|
|
MOPT_STDOPTS,
|
|
PUFFSMOPT_STD,
|
|
MOPT_NULL,
|
|
};
|
|
#ifdef PUFFS_WITH_THREADS
|
|
#include <pthread.h>
|
|
pthread_mutex_t pu_lock = PTHREAD_MUTEX_INITIALIZER;
|
|
#endif
|
|
|
|
#if defined(__minix)
|
|
static message fs_msg;
|
|
static int fs_ipc_status;
|
|
#endif
|
|
|
|
/* Declare some local functions. */
|
|
static int get_work(message *msg, int *ipc_status);
|
|
|
|
/* SEF functions and variables. */
|
|
static void sef_local_startup(void);
|
|
static int sef_cb_init_fresh(int type, sef_init_info_t *info);
|
|
static void sef_cb_signal_handler(int signo);
|
|
|
|
EXTERN int env_argc;
|
|
EXTERN char **env_argv;
|
|
|
|
|
|
#define PUFFS_MAX_ARGS 20
|
|
|
|
int __real_main(int argc, char* argv[]);
|
|
int __wrap_main(int argc, char* argv[]);
|
|
|
|
int __wrap_main(int argc, char *argv[])
|
|
{
|
|
int i;
|
|
int new_argc = 0;
|
|
static char* new_argv[PUFFS_MAX_ARGS];
|
|
char *name;
|
|
|
|
/* SEF local startup. */
|
|
env_setargs(argc, argv);
|
|
sef_local_startup();
|
|
|
|
global_kcred.pkcr_type = PUFFCRED_TYPE_INTERNAL;
|
|
|
|
if (argc < 3) {
|
|
panic("Unexpected arguments, use:\
|
|
mount -t fs /dev/ /dir [-o option1,option2]\n");
|
|
}
|
|
|
|
name = argv[0] + strlen(argv[0]);
|
|
while (*name != '/' && name != argv[0])
|
|
name--;
|
|
if (name != argv[0])
|
|
name++;
|
|
strcpy(fs_name, name);
|
|
|
|
new_argv[new_argc] = argv[0];
|
|
new_argc++;
|
|
|
|
for (i = 1; i < argc; i++) {
|
|
if (new_argc >= PUFFS_MAX_ARGS) {
|
|
panic("Too many arguments, change PUFFS_MAX_ARGS");
|
|
}
|
|
new_argv[new_argc] = argv[i];
|
|
new_argc++;
|
|
}
|
|
|
|
assert(new_argc > 0);
|
|
|
|
/* Get the mount request from VFS, so we can deal with it later. */
|
|
(void)get_work(&fs_msg, &fs_ipc_status);
|
|
|
|
return __real_main(new_argc, new_argv);
|
|
}
|
|
|
|
|
|
#define FILLOP(lower, upper) \
|
|
do { \
|
|
if (pops->puffs_node_##lower) \
|
|
opmask[PUFFS_VN_##upper] = 1; \
|
|
} while (/*CONSTCOND*/0)
|
|
static void
|
|
fillvnopmask(struct puffs_ops *pops, struct puffs_kargs *pa)
|
|
{
|
|
uint8_t *opmask = pa->pa_vnopmask;
|
|
|
|
memset(opmask, 0, sizeof(pa->pa_vnopmask));
|
|
|
|
FILLOP(create, CREATE);
|
|
FILLOP(mknod, MKNOD);
|
|
FILLOP(open, OPEN);
|
|
FILLOP(close, CLOSE);
|
|
FILLOP(access, ACCESS);
|
|
FILLOP(getattr, GETATTR);
|
|
FILLOP(setattr, SETATTR);
|
|
FILLOP(poll, POLL);
|
|
FILLOP(mmap, MMAP);
|
|
FILLOP(fsync, FSYNC);
|
|
FILLOP(seek, SEEK);
|
|
FILLOP(remove, REMOVE);
|
|
FILLOP(link, LINK);
|
|
FILLOP(rename, RENAME);
|
|
FILLOP(mkdir, MKDIR);
|
|
FILLOP(rmdir, RMDIR);
|
|
FILLOP(symlink, SYMLINK);
|
|
FILLOP(readdir, READDIR);
|
|
FILLOP(readlink, READLINK);
|
|
FILLOP(reclaim, RECLAIM);
|
|
FILLOP(inactive, INACTIVE);
|
|
FILLOP(print, PRINT);
|
|
FILLOP(read, READ);
|
|
FILLOP(write, WRITE);
|
|
FILLOP(abortop, ABORTOP);
|
|
}
|
|
#undef FILLOP
|
|
|
|
|
|
/*ARGSUSED*/
|
|
__dead static void
|
|
puffs_defaulterror(struct puffs_usermount *pu, uint8_t type,
|
|
int error, const char *str, puffs_cookie_t cookie)
|
|
{
|
|
|
|
lpuffs_debug("abort: type %d, error %d, cookie %p (%s)\n",
|
|
type, error, cookie, str);
|
|
abort();
|
|
}
|
|
|
|
|
|
int
|
|
puffs_getstate(struct puffs_usermount *pu)
|
|
{
|
|
|
|
return pu->pu_state & PU_STATEMASK;
|
|
}
|
|
|
|
void
|
|
puffs_setstacksize(struct puffs_usermount *pu, size_t ss)
|
|
{
|
|
long psize, minsize;
|
|
int stackshift;
|
|
int bonus;
|
|
|
|
assert(puffs_getstate(pu) == PUFFS_STATE_BEFOREMOUNT);
|
|
|
|
psize = sysconf(_SC_PAGESIZE);
|
|
minsize = 4*psize;
|
|
if (ss < (size_t)minsize || ss == PUFFS_STACKSIZE_MIN) {
|
|
if (ss != PUFFS_STACKSIZE_MIN)
|
|
lpuffs_debug("puffs_setstacksize: adjusting "
|
|
"stacksize to minimum %ld\n", minsize);
|
|
ss = 4*psize;
|
|
}
|
|
|
|
stackshift = -1;
|
|
bonus = 0;
|
|
while (ss) {
|
|
if (ss & 0x1)
|
|
bonus++;
|
|
ss >>= 1;
|
|
stackshift++;
|
|
}
|
|
if (bonus > 1) {
|
|
stackshift++;
|
|
lpuffs_debug("puffs_setstacksize: using next power of two: "
|
|
"%d\n", 1<<stackshift);
|
|
}
|
|
|
|
pu->pu_cc_stackshift = stackshift;
|
|
}
|
|
|
|
struct puffs_pathobj *
|
|
puffs_getrootpathobj(struct puffs_usermount *pu)
|
|
{
|
|
struct puffs_node *pnr;
|
|
|
|
pnr = pu->pu_pn_root;
|
|
if (pnr == NULL) {
|
|
errno = ENOENT;
|
|
return NULL;
|
|
}
|
|
|
|
return &pnr->pn_po;
|
|
}
|
|
|
|
void
|
|
puffs_setroot(struct puffs_usermount *pu, struct puffs_node *pn)
|
|
{
|
|
|
|
pu->pu_pn_root = pn;
|
|
}
|
|
|
|
struct puffs_node *
|
|
puffs_getroot(struct puffs_usermount *pu)
|
|
{
|
|
|
|
return pu->pu_pn_root;
|
|
}
|
|
|
|
void
|
|
puffs_setrootinfo(struct puffs_usermount *pu, enum vtype vt,
|
|
vsize_t vsize, dev_t rdev)
|
|
{
|
|
struct puffs_kargs *pargs = pu->pu_kargp;
|
|
|
|
if (puffs_getstate(pu) != PUFFS_STATE_BEFOREMOUNT) {
|
|
warnx("puffs_setrootinfo: call has effect only "
|
|
"before mount\n");
|
|
return;
|
|
}
|
|
|
|
pargs->pa_root_vtype = vt;
|
|
pargs->pa_root_vsize = vsize;
|
|
pargs->pa_root_rdev = rdev;
|
|
}
|
|
|
|
void *
|
|
puffs_getspecific(struct puffs_usermount *pu)
|
|
{
|
|
|
|
return pu->pu_privdata;
|
|
}
|
|
|
|
void
|
|
puffs_setspecific(struct puffs_usermount *pu, void *privdata)
|
|
{
|
|
|
|
pu->pu_privdata = privdata;
|
|
}
|
|
|
|
void
|
|
puffs_setmntinfo(struct puffs_usermount *pu,
|
|
const char *mntfromname, const char *puffsname)
|
|
{
|
|
struct puffs_kargs *pargs = pu->pu_kargp;
|
|
|
|
(void)strlcpy(pargs->pa_mntfromname, mntfromname,
|
|
sizeof(pargs->pa_mntfromname));
|
|
(void)strlcpy(pargs->pa_typename, puffsname,
|
|
sizeof(pargs->pa_typename));
|
|
}
|
|
|
|
size_t
|
|
puffs_getmaxreqlen(struct puffs_usermount *pu)
|
|
{
|
|
|
|
return pu->pu_maxreqlen;
|
|
}
|
|
|
|
void
|
|
puffs_setmaxreqlen(struct puffs_usermount *pu, size_t reqlen)
|
|
{
|
|
|
|
if (puffs_getstate(pu) != PUFFS_STATE_BEFOREMOUNT)
|
|
warnx("puffs_setmaxreqlen: call has effect only "
|
|
"before mount\n");
|
|
|
|
pu->pu_kargp->pa_maxmsglen = reqlen;
|
|
}
|
|
|
|
void
|
|
puffs_setfhsize(struct puffs_usermount *pu, size_t fhsize, int flags)
|
|
{
|
|
|
|
if (puffs_getstate(pu) != PUFFS_STATE_BEFOREMOUNT)
|
|
warnx("puffs_setfhsize: call has effect only before mount\n");
|
|
|
|
pu->pu_kargp->pa_fhsize = fhsize;
|
|
pu->pu_kargp->pa_fhflags = flags;
|
|
}
|
|
|
|
void
|
|
puffs_setncookiehash(struct puffs_usermount *pu, int nhash)
|
|
{
|
|
|
|
if (puffs_getstate(pu) != PUFFS_STATE_BEFOREMOUNT)
|
|
warnx("puffs_setfhsize: call has effect only before mount\n");
|
|
|
|
pu->pu_kargp->pa_nhashbuckets = nhash;
|
|
}
|
|
|
|
void
|
|
puffs_set_pathbuild(struct puffs_usermount *pu, pu_pathbuild_fn fn)
|
|
{
|
|
|
|
pu->pu_pathbuild = fn;
|
|
}
|
|
|
|
void
|
|
puffs_set_pathtransform(struct puffs_usermount *pu, pu_pathtransform_fn fn)
|
|
{
|
|
|
|
pu->pu_pathtransform = fn;
|
|
}
|
|
|
|
void
|
|
puffs_set_pathcmp(struct puffs_usermount *pu, pu_pathcmp_fn fn)
|
|
{
|
|
|
|
pu->pu_pathcmp = fn;
|
|
}
|
|
|
|
void
|
|
puffs_set_pathfree(struct puffs_usermount *pu, pu_pathfree_fn fn)
|
|
{
|
|
|
|
pu->pu_pathfree = fn;
|
|
}
|
|
|
|
void
|
|
puffs_set_namemod(struct puffs_usermount *pu, pu_namemod_fn fn)
|
|
{
|
|
|
|
pu->pu_namemod = fn;
|
|
}
|
|
|
|
void
|
|
puffs_set_errnotify(struct puffs_usermount *pu, pu_errnotify_fn fn)
|
|
{
|
|
|
|
pu->pu_errnotify = fn;
|
|
}
|
|
|
|
void
|
|
puffs_set_cmap(struct puffs_usermount *pu, pu_cmap_fn fn)
|
|
{
|
|
|
|
pu->pu_cmap = fn;
|
|
}
|
|
|
|
void
|
|
puffs_ml_setloopfn(struct puffs_usermount *pu, puffs_ml_loop_fn lfn)
|
|
{
|
|
|
|
pu->pu_ml_lfn = lfn;
|
|
}
|
|
|
|
void
|
|
puffs_ml_settimeout(struct puffs_usermount *pu, struct timespec *ts)
|
|
{
|
|
|
|
if (ts == NULL) {
|
|
pu->pu_ml_timep = NULL;
|
|
} else {
|
|
pu->pu_ml_timeout = *ts;
|
|
pu->pu_ml_timep = &pu->pu_ml_timeout;
|
|
}
|
|
}
|
|
|
|
void
|
|
puffs_set_prepost(struct puffs_usermount *pu,
|
|
pu_prepost_fn pre, pu_prepost_fn pst)
|
|
{
|
|
|
|
pu->pu_oppre = pre;
|
|
pu->pu_oppost = pst;
|
|
}
|
|
|
|
int
|
|
puffs_mount(struct puffs_usermount *pu, const char *dir, int mntflags,
|
|
puffs_cookie_t cookie)
|
|
{
|
|
#if defined(__minix)
|
|
pu->pu_kargp->pa_root_cookie = cookie;
|
|
|
|
/* Process the already-received mount request. */
|
|
fsdriver_process(&puffs_table, &fs_msg, fs_ipc_status, FALSE);
|
|
|
|
if (!mounted) {
|
|
/* This should never happen, unless VFS misbehaves.. */
|
|
free(pu->pu_kargp);
|
|
pu->pu_kargp = NULL;
|
|
errno = -EINVAL;
|
|
return -1;
|
|
}
|
|
|
|
PU_SETSTATE(pu, PUFFS_STATE_RUNNING);
|
|
return 0;
|
|
#endif /* defined(__minix) */
|
|
}
|
|
|
|
/*ARGSUSED*/
|
|
struct puffs_usermount *
|
|
puffs_init(struct puffs_ops *pops, const char *mntfromname,
|
|
const char *puffsname, void *priv, uint32_t pflags)
|
|
{
|
|
struct puffs_usermount *pu;
|
|
struct puffs_kargs *pargs;
|
|
int sverrno;
|
|
|
|
if (puffsname == PUFFS_DEFER)
|
|
puffsname = "n/a";
|
|
if (mntfromname == PUFFS_DEFER)
|
|
mntfromname = "n/a";
|
|
if (priv == PUFFS_DEFER)
|
|
priv = NULL;
|
|
|
|
pu = malloc(sizeof(struct puffs_usermount));
|
|
if (pu == NULL)
|
|
goto failfree;
|
|
memset(pu, 0, sizeof(struct puffs_usermount));
|
|
|
|
pargs = pu->pu_kargp = malloc(sizeof(struct puffs_kargs));
|
|
if (pargs == NULL)
|
|
goto failfree;
|
|
memset(pargs, 0, sizeof(struct puffs_kargs));
|
|
|
|
pargs->pa_vers = PUFFSVERSION;
|
|
pargs->pa_flags = PUFFS_FLAG_KERN(pflags);
|
|
fillvnopmask(pops, pargs);
|
|
puffs_setmntinfo(pu, mntfromname, puffsname);
|
|
|
|
puffs_zerostatvfs(&pargs->pa_svfsb);
|
|
pargs->pa_root_cookie = NULL;
|
|
pargs->pa_root_vtype = VDIR;
|
|
pargs->pa_root_vsize = 0;
|
|
pargs->pa_root_rdev = 0;
|
|
pargs->pa_maxmsglen = 0;
|
|
if (/*CONSTCOND*/ sizeof(time_t) == 4)
|
|
pargs->pa_time32 = 1;
|
|
else
|
|
pargs->pa_time32 = 0;
|
|
|
|
pu->pu_flags = pflags;
|
|
buildpath = pu->pu_flags & PUFFS_FLAG_BUILDPATH; /* XXX */
|
|
pu->pu_ops = *pops;
|
|
free(pops); /* XXX */
|
|
|
|
pu->pu_privdata = priv;
|
|
pu->pu_cc_stackshift = PUFFS_CC_STACKSHIFT_DEFAULT;
|
|
LIST_INIT(&pu->pu_pnodelst);
|
|
LIST_INIT(&pu->pu_pnode_removed_lst);
|
|
LIST_INIT(&pu->pu_ios);
|
|
LIST_INIT(&pu->pu_ios_rmlist);
|
|
LIST_INIT(&pu->pu_ccmagazin);
|
|
TAILQ_INIT(&pu->pu_sched);
|
|
|
|
/* defaults for some user-settable translation functions */
|
|
pu->pu_cmap = NULL; /* identity translation */
|
|
|
|
pu->pu_pathbuild = puffs_stdpath_buildpath;
|
|
pu->pu_pathfree = puffs_stdpath_freepath;
|
|
pu->pu_pathcmp = puffs_stdpath_cmppath;
|
|
pu->pu_pathtransform = NULL;
|
|
pu->pu_namemod = NULL;
|
|
|
|
pu->pu_errnotify = puffs_defaulterror;
|
|
|
|
PU_SETSTATE(pu, PUFFS_STATE_BEFOREMOUNT);
|
|
|
|
global_pu = pu;
|
|
|
|
return pu;
|
|
|
|
failfree:
|
|
/* can't unmount() from here for obvious reasons */
|
|
sverrno = errno;
|
|
free(pu);
|
|
errno = sverrno;
|
|
return NULL;
|
|
}
|
|
|
|
void
|
|
puffs_cancel(struct puffs_usermount *pu, int error)
|
|
{
|
|
|
|
assert(puffs_getstate(pu) < PUFFS_STATE_RUNNING);
|
|
free(pu);
|
|
}
|
|
|
|
/*ARGSUSED1*/
|
|
int
|
|
puffs_exit(struct puffs_usermount *pu, int force)
|
|
{
|
|
struct puffs_node *pn;
|
|
|
|
lpuffs_debug("puffs_exit\n");
|
|
|
|
while ((pn = LIST_FIRST(&pu->pu_pnodelst)) != NULL)
|
|
puffs_pn_put(pn);
|
|
|
|
while ((pn = LIST_FIRST(&pu->pu_pnode_removed_lst)) != NULL)
|
|
puffs_pn_put(pn);
|
|
|
|
puffs__cc_exit(pu);
|
|
if (pu->pu_state & PU_HASKQ)
|
|
close(pu->pu_kq);
|
|
free(pu);
|
|
|
|
return 0; /* always succesful for now, WILL CHANGE */
|
|
}
|
|
|
|
/*
|
|
* Actual mainloop. This is called from a context which can block.
|
|
* It is called either from puffs_mainloop (indirectly, via
|
|
* puffs_cc_continue() or from puffs_cc_yield()).
|
|
*/
|
|
void
|
|
puffs__theloop(struct puffs_cc *pcc)
|
|
{
|
|
struct puffs_usermount *pu = pcc->pcc_pu;
|
|
|
|
while (mounted || !exitsignaled) {
|
|
/*
|
|
* Schedule existing requests.
|
|
*/
|
|
while ((pcc = TAILQ_FIRST(&pu->pu_sched)) != NULL) {
|
|
lpuffs_debug("scheduling existing tasks\n");
|
|
TAILQ_REMOVE(&pu->pu_sched, pcc, pcc_schedent);
|
|
puffs__goto(pcc);
|
|
}
|
|
|
|
if (pu->pu_ml_lfn) {
|
|
lpuffs_debug("Calling user mainloop handler\n");
|
|
pu->pu_ml_lfn(pu);
|
|
}
|
|
|
|
/* Wait for request message. */
|
|
if (get_work(&fs_msg, &fs_ipc_status) != OK)
|
|
continue; /* recheck loop conditions */
|
|
|
|
/* Process it, and send a reply. */
|
|
fsdriver_process(&puffs_table, &fs_msg, fs_ipc_status, FALSE);
|
|
}
|
|
|
|
if (puffs__cc_restoremain(pu) == -1)
|
|
warn("cannot restore main context. impending doom");
|
|
|
|
/* May get here, if puffs_fakecc is set to 1. Currently librefuse sets it.
|
|
* Now we just return to the caller.
|
|
*/
|
|
}
|
|
int
|
|
puffs_mainloop(struct puffs_usermount *pu)
|
|
{
|
|
struct puffs_cc *pcc;
|
|
int sverrno;
|
|
|
|
assert(puffs_getstate(pu) >= PUFFS_STATE_RUNNING);
|
|
|
|
pu->pu_state |= PU_HASKQ | PU_INLOOP;
|
|
|
|
/*
|
|
* Create alternate execution context and jump to it. Note
|
|
* that we come "out" of savemain twice. Where we come out
|
|
* of it depends on the architecture. If the return address is
|
|
* stored on the stack, we jump out from puffs_cc_continue(),
|
|
* for a register return address from puffs__cc_savemain().
|
|
* PU_MAINRESTORE makes sure we DTRT in both cases.
|
|
*/
|
|
if (puffs__cc_create(pu, puffs__theloop, &pcc) == -1) {
|
|
goto out;
|
|
}
|
|
if (puffs__cc_savemain(pu) == -1) {
|
|
goto out;
|
|
}
|
|
if ((pu->pu_state & PU_MAINRESTORE) == 0)
|
|
puffs_cc_continue(pcc);
|
|
|
|
errno = 0;
|
|
|
|
out:
|
|
/* store the real error for a while */
|
|
sverrno = errno;
|
|
|
|
errno = sverrno;
|
|
if (errno)
|
|
return -1;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
#if defined(__minix)
|
|
/*===========================================================================*
|
|
* sef_local_startup *
|
|
*===========================================================================*/
|
|
static void sef_local_startup(void)
|
|
{
|
|
/* Register init callbacks. */
|
|
sef_setcb_init_fresh(sef_cb_init_fresh);
|
|
sef_setcb_init_restart(sef_cb_init_fail);
|
|
|
|
/* No live update support for now. */
|
|
|
|
/* Register signal callbacks. */
|
|
sef_setcb_signal_handler(sef_cb_signal_handler);
|
|
|
|
/* Let SEF perform startup. */
|
|
sef_startup();
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* sef_cb_init_fresh *
|
|
*===========================================================================*/
|
|
static int sef_cb_init_fresh(int type, sef_init_info_t *info)
|
|
{
|
|
/* Initialize the Minix file server. */
|
|
return(OK);
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* sef_cb_signal_handler *
|
|
*===========================================================================*/
|
|
static void sef_cb_signal_handler(int signo)
|
|
{
|
|
/* Only check for termination signal, ignore anything else. */
|
|
if (signo != SIGTERM) return;
|
|
|
|
exitsignaled = 1;
|
|
fs_sync();
|
|
|
|
sef_cancel();
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* get_work *
|
|
*===========================================================================*/
|
|
static int get_work(message *msg, int *ipc_status)
|
|
{
|
|
int r;
|
|
|
|
for (;;) {
|
|
if ((r = sef_receive_status(ANY, msg, ipc_status)) != OK) {
|
|
if (r == EINTR) /* sef_cancel from signal handler? */
|
|
break; /* see if we can exit the main loop */
|
|
panic("sef_receive failed: %d", r);
|
|
}
|
|
if (msg->m_source == VFS_PROC_NR)
|
|
break;
|
|
lpuffs_debug("libpuffs: unexpected source %d\n", msg->m_source);
|
|
}
|
|
|
|
return r;
|
|
}
|
|
#endif /* defined(__minix) */
|