Import libpuffs and our port of libpuffs. The port was done as part of GSoC 2011 FUSE project, done by Evgeniy Ivanov. The librefuse import did not require any porting efforts. Libpuffs has been modified to understand our VFS-FS protocol and translate between that and PUFFS. As an example that it works, fuse-ntfs-3g from pkgsrc can be compiled and used to mount ntfs partitions: mount -t ntfs-3g <device> <mountpoint> FUSE only works with the asynchronous version of VFS. See <docs/UPDATING> on how to run AVFS. This patch further includes some changes to mount(1) and mount(2) so it's possible to use file systems provided by pkgsrc (note: manual modifications to /etc/system.conf are still needed. There has been made an exception for fuse-ntfs-3g, so it already as an entry).
350 lines
8.1 KiB
C
350 lines
8.1 KiB
C
/* $NetBSD: callcontext.c,v 1.23 2008/08/11 16:23:37 pooka Exp $ */
|
|
|
|
/*
|
|
* Copyright (c) 2006, 2007, 2008 Antti Kantee. All Rights Reserved.
|
|
*
|
|
* Development of this software was supported by the
|
|
* Research Foundation of Helsinki University of Technology
|
|
*
|
|
* 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: callcontext.c,v 1.23 2008/08/11 16:23:37 pooka Exp $");
|
|
#endif /* !lint */
|
|
|
|
#include <sys/types.h>
|
|
#include <sys/mman.h>
|
|
|
|
#include <assert.h>
|
|
#include <errno.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <ucontext.h>
|
|
#include <unistd.h>
|
|
|
|
#include "puffs.h"
|
|
#include "puffs_priv.h"
|
|
|
|
#if 0
|
|
#define DPRINTF(x) printf x
|
|
#else
|
|
#define DPRINTF(x)
|
|
#endif
|
|
|
|
/*
|
|
* Set the following to 1 to not handle each request on a separate
|
|
* stack. This is highly volatile kludge, therefore no external
|
|
* interface.
|
|
*/
|
|
int puffs_fakecc;
|
|
|
|
/*
|
|
* user stuff
|
|
*/
|
|
|
|
/*
|
|
* So, we need to get back to where we came from. This can happen in two
|
|
* different ways:
|
|
* 1) PCC_MLCONT is set, in which case we need to go to the mainloop
|
|
* 2) It is not set, and we simply jump to pcc_uc_ret.
|
|
*/
|
|
void
|
|
puffs_cc_yield(struct puffs_cc *pcc)
|
|
{
|
|
struct puffs_cc *jumpcc;
|
|
int rv;
|
|
|
|
assert(puffs_fakecc == 0);
|
|
|
|
pcc->pcc_flags &= ~PCC_BORROWED;
|
|
|
|
/* romanes eunt domus */
|
|
DPRINTF(("puffs_cc_yield: "));
|
|
if ((pcc->pcc_flags & PCC_MLCONT) == 0) {
|
|
DPRINTF(("no mlcont, pcc %p\n", pcc));
|
|
swapcontext(&pcc->pcc_uc, &pcc->pcc_uc_ret);
|
|
} else {
|
|
DPRINTF(("mlcont, pcc %p\n", pcc));
|
|
pcc->pcc_flags &= ~PCC_MLCONT;
|
|
rv = puffs__cc_create(pcc->pcc_pu, puffs__theloop, &jumpcc);
|
|
if (rv)
|
|
abort(); /* p-p-p-pa-pa-panic (XXX: fixme) */
|
|
swapcontext(&pcc->pcc_uc, &jumpcc->pcc_uc);
|
|
DPRINTF(("puffs_cc_yield: post swap pcc %p\n", pcc));
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Internal continue routine. This has slightly different semantics.
|
|
* We simply make our cc available in the freelist and jump to the
|
|
* indicated pcc.
|
|
*/
|
|
void
|
|
puffs__cc_cont(struct puffs_cc *pcc)
|
|
{
|
|
struct puffs_cc *mycc;
|
|
|
|
mycc = puffs_cc_getcc(pcc->pcc_pu);
|
|
DPRINTF(("puffs__cc_cont: pcc %p, mycc %p\n", pcc, mycc));
|
|
|
|
/*
|
|
* XXX: race between setcontenxt() and recycle if
|
|
* we go multithreaded
|
|
*/
|
|
puffs__cc_destroy(mycc, 1);
|
|
pcc->pcc_flags |= PCC_MLCONT;
|
|
setcontext(&pcc->pcc_uc);
|
|
}
|
|
|
|
void
|
|
puffs_cc_continue(struct puffs_cc *pcc)
|
|
{
|
|
|
|
/* ramble on */
|
|
DPRINTF(("puffs_cc_continue: pcc %p\n", pcc));
|
|
if (puffs_fakecc) {
|
|
pcc->pcc_func(pcc->pcc_farg);
|
|
} else {
|
|
swapcontext(&pcc->pcc_uc_ret, &pcc->pcc_uc);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* "Borrows" pcc, *NOT* called from pcc owner. Acts like continue.
|
|
* So the idea is to use this, give something the context back to
|
|
* run to completion and then jump back to where ever this was called
|
|
* from after the op dispatching is complete (or if the pcc decides to
|
|
* yield again).
|
|
*/
|
|
void
|
|
puffs__goto(struct puffs_cc *loanpcc)
|
|
{
|
|
|
|
loanpcc->pcc_flags |= PCC_BORROWED;
|
|
|
|
swapcontext(&loanpcc->pcc_uc_ret, &loanpcc->pcc_uc);
|
|
}
|
|
|
|
void
|
|
puffs_cc_schedule(struct puffs_cc *pcc)
|
|
{
|
|
struct puffs_usermount *pu = pcc->pcc_pu;
|
|
|
|
assert(pu->pu_state & PU_INLOOP);
|
|
TAILQ_INSERT_TAIL(&pu->pu_sched, pcc, pcc_schedent);
|
|
}
|
|
|
|
int
|
|
puffs_cc_getcaller(struct puffs_cc *pcc, pid_t *pid, lwpid_t *lid)
|
|
{
|
|
|
|
if ((pcc->pcc_flags & PCC_HASCALLER) == 0) {
|
|
errno = ESRCH;
|
|
return -1;
|
|
}
|
|
|
|
if (pid)
|
|
*pid = pcc->pcc_pid;
|
|
if (lid)
|
|
*lid = pcc->pcc_lid;
|
|
return 0;
|
|
}
|
|
|
|
static struct puffs_cc fakecc;
|
|
|
|
static struct puffs_cc *
|
|
slowccalloc(struct puffs_usermount *pu)
|
|
{
|
|
struct puffs_cc *volatile pcc;
|
|
void *sp;
|
|
size_t stacksize = 1<<pu->pu_cc_stackshift;
|
|
|
|
if (puffs_fakecc)
|
|
return &fakecc;
|
|
|
|
sp = minix_mmap(NULL, stacksize, PROT_READ|PROT_WRITE,
|
|
MAP_ANON|MAP_PRIVATE, -1, 0);
|
|
if (sp == MAP_FAILED)
|
|
return NULL;
|
|
|
|
pcc = sp;
|
|
memset(pcc, 0, sizeof(struct puffs_cc));
|
|
|
|
/* initialize both ucontext's */
|
|
if (getcontext(&pcc->pcc_uc) == -1) {
|
|
minix_munmap(pcc, stacksize);
|
|
return NULL;
|
|
}
|
|
if (getcontext(&pcc->pcc_uc_ret) == -1) {
|
|
minix_munmap(pcc, stacksize);
|
|
return NULL;
|
|
}
|
|
|
|
return pcc;
|
|
}
|
|
|
|
int
|
|
puffs__cc_create(struct puffs_usermount *pu, puffs_ccfunc func,
|
|
struct puffs_cc **pccp)
|
|
{
|
|
struct puffs_cc *pcc;
|
|
size_t stacksize = 1<<pu->pu_cc_stackshift;
|
|
stack_t *st;
|
|
|
|
/* Do we have a cached copy? */
|
|
if (pu->pu_cc_nstored == 0) {
|
|
pcc = slowccalloc(pu);
|
|
if (pcc == NULL)
|
|
return -1;
|
|
pcc->pcc_pu = pu;
|
|
DPRINTF(("puffs__cc_create: allocated pcc %p\n", pcc));
|
|
} else {
|
|
pcc = LIST_FIRST(&pu->pu_ccmagazin);
|
|
assert(pcc != NULL);
|
|
|
|
LIST_REMOVE(pcc, pcc_rope);
|
|
pu->pu_cc_nstored--;
|
|
DPRINTF(("puffs__cc_create: magazin pcc %p\n", pcc));
|
|
}
|
|
assert(pcc->pcc_pu == pu);
|
|
|
|
if (puffs_fakecc) {
|
|
pcc->pcc_func = func;
|
|
pcc->pcc_farg = pcc;
|
|
} else {
|
|
/* link context */
|
|
pcc->pcc_uc.uc_link = &pcc->pcc_uc_ret;
|
|
|
|
/* setup stack
|
|
*
|
|
* XXX: I guess this should theoretically be preserved by
|
|
* swapcontext(). However, it gets lost. So reinit it.
|
|
*/
|
|
st = &pcc->pcc_uc.uc_stack;
|
|
st->ss_sp = pcc;
|
|
st->ss_size = stacksize;
|
|
st->ss_flags = 0;
|
|
|
|
/*
|
|
* Give us an initial context to jump to.
|
|
*
|
|
* Our manual page says that portable code shouldn't
|
|
* rely on being able to pass pointers through makecontext().
|
|
* kjk says that NetBSD code doesn't need to worry about this.
|
|
* uwe says it would be like putting a "keep away from
|
|
* children" sign on a box of toys.
|
|
*/
|
|
makecontext(&pcc->pcc_uc, (void *)func, 1, (uintptr_t)pcc);
|
|
}
|
|
|
|
*pccp = pcc;
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
puffs__cc_setcaller(struct puffs_cc *pcc, pid_t pid, lwpid_t lid)
|
|
{
|
|
|
|
pcc->pcc_pid = pid;
|
|
pcc->pcc_lid = lid;
|
|
pcc->pcc_flags |= PCC_HASCALLER;
|
|
}
|
|
|
|
static void
|
|
cc_free(struct puffs_cc *pcc)
|
|
{
|
|
struct puffs_usermount *pu = pcc->pcc_pu;
|
|
size_t stacksize = 1<<pu->pu_cc_stackshift;
|
|
|
|
DPRINTF(("invalidating pcc %p\n", pcc));
|
|
assert(!puffs_fakecc);
|
|
minix_munmap(pcc, stacksize);
|
|
}
|
|
|
|
void
|
|
puffs__cc_destroy(struct puffs_cc *pcc, int nonuke)
|
|
{
|
|
struct puffs_usermount *pu = pcc->pcc_pu;
|
|
|
|
assert(pcc->pcc_flags == 0);
|
|
assert(!puffs_fakecc);
|
|
|
|
/* not over limit? stuff away in the store, otherwise nuke */
|
|
if (nonuke || pu->pu_cc_nstored < PUFFS_CCMAXSTORE) {
|
|
pcc->pcc_pb = NULL;
|
|
DPRINTF(("puffs__cc_destroy: storing pcc %p\n", pcc));
|
|
LIST_INSERT_HEAD(&pu->pu_ccmagazin, pcc, pcc_rope);
|
|
pu->pu_cc_nstored++;
|
|
} else {
|
|
cc_free(pcc);
|
|
}
|
|
}
|
|
|
|
void
|
|
puffs__cc_exit(struct puffs_usermount *pu)
|
|
{
|
|
struct puffs_cc *pcc;
|
|
|
|
while ((pcc = LIST_FIRST(&pu->pu_ccmagazin)) != NULL) {
|
|
LIST_REMOVE(pcc, pcc_rope);
|
|
cc_free(pcc);
|
|
}
|
|
}
|
|
|
|
struct puffs_cc *
|
|
puffs_cc_getcc(struct puffs_usermount *pu)
|
|
{
|
|
size_t stacksize = 1<<pu->pu_cc_stackshift;
|
|
uintptr_t bottom;
|
|
|
|
if (puffs_fakecc)
|
|
return &fakecc;
|
|
|
|
bottom = ((uintptr_t)&bottom) & ~(stacksize-1);
|
|
return (struct puffs_cc *)bottom;
|
|
}
|
|
|
|
int
|
|
puffs__cc_savemain(struct puffs_usermount *pu)
|
|
{
|
|
|
|
if (puffs_fakecc)
|
|
return 0;
|
|
|
|
PU_CLRSFLAG(pu, PU_MAINRESTORE);
|
|
return getcontext(&pu->pu_mainctx);
|
|
}
|
|
|
|
int
|
|
puffs__cc_restoremain(struct puffs_usermount *pu)
|
|
{
|
|
|
|
if (puffs_fakecc)
|
|
return 0;
|
|
|
|
puffs__cc_destroy(puffs_cc_getcc(pu), 1);
|
|
PU_SETSFLAG(pu, PU_MAINRESTORE);
|
|
return setcontext(&pu->pu_mainctx);
|
|
}
|