Aren
/
NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
NetBSD/sys/fs/puffs/puffs_sys.h

263 lines
8.3 KiB
C
Raw Normal View History

Refactor the pnode2vnode translation slightly so that VFS_ROOT can use it directly.
2007-06-21 18:54:49 +04:00
/* $NetBSD: puffs_sys.h,v 1.41 2007/06/21 14:54:49 pooka Exp $ */
kernel portion of puffs - the Pass-to-Userspace Framework File System. It contains the VFS attachment and userspace message-passing interface. This work was initially started and completed for Google SoC 2005 and tweaked to work a bit better in the past few weeks. While being far from complete, it is functional enough to be able and stable to host a fairly general-purpose in-memory file system in userspace. Even so, puffs should be considered experimental and no binary compatibility for interfaces or crash-freedom or zero security implications should be relied upon just yet. The GSoC project was mentored by William Studenmund and the final review for the code was done by Christos.
2006-10-23 02:43:23 +04:00
/*
* Copyright (c) 2005, 2006 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.
*/
#ifndef _PUFFS_SYS_H_
#define _PUFFS_SYS_H_
#include <sys/param.h>
#include <sys/select.h>
#include <sys/kauth.h>
Convert spinlocks & sleep/wakeup to newlock2 locking stuff. Fix a bunch of bugs. * park structures are now always allocated from a pool instead of a mixed stack/malloc allocation * get rid of the whole adjbuf concept, always just alloc the maximal amount of memory to satisfy a request * little regression: don't allow interrupting wait from file system to userspace; this had problems already before, but now the problems really started to shine through. I'll try to make this work again some day. * fix bmap to return a sensible value in runp
2007-03-29 20:04:26 +04:00
#include <sys/mutex.h>
kernel portion of puffs - the Pass-to-Userspace Framework File System. It contains the VFS attachment and userspace message-passing interface. This work was initially started and completed for Google SoC 2005 and tweaked to work a bit better in the past few weeks. While being far from complete, it is functional enough to be able and stable to host a fairly general-purpose in-memory file system in userspace. Even so, puffs should be considered experimental and no binary compatibility for interfaces or crash-freedom or zero security implications should be relied upon just yet. The GSoC project was mentored by William Studenmund and the final review for the code was done by Christos.
2006-10-23 02:43:23 +04:00
#include <sys/queue.h>
make it possible to build & load puffs as an LKM by Lubomir Kundrak, PR kern/35000
2006-11-06 14:44:54 +03:00
#include <sys/pool.h>
kernel portion of puffs - the Pass-to-Userspace Framework File System. It contains the VFS attachment and userspace message-passing interface. This work was initially started and completed for Google SoC 2005 and tweaked to work a bit better in the past few weeks. While being far from complete, it is functional enough to be able and stable to host a fairly general-purpose in-memory file system in userspace. Even so, puffs should be considered experimental and no binary compatibility for interfaces or crash-freedom or zero security implications should be relied upon just yet. The GSoC project was mentored by William Studenmund and the final review for the code was done by Christos.
2006-10-23 02:43:23 +04:00
#include <fs/puffs/puffs_msgif.h>
attach to genfs & support page cache. most noticeable effect is mmap and therefore execution of binaries starting to work, some speed improvements with large file I/O also. caching semantics and error case handling most likely need revisiting.
2006-11-08 01:10:18 +03:00
#include <miscfs/genfs/genfs_node.h>
support specfs
2006-10-27 02:52:47 +04:00
extern int (**puffs_vnodeop_p)(void *);
extern int (**puffs_specop_p)(void *);
support fifos
2006-10-27 16:25:16 +04:00
extern int (**puffs_fifoop_p)(void *);
support specfs
2006-10-27 02:52:47 +04:00
extern const struct vnodeopv_desc puffs_vnodeop_opv_desc;
extern const struct vnodeopv_desc puffs_specop_opv_desc;
support fifos
2006-10-27 16:25:16 +04:00
extern const struct vnodeopv_desc puffs_fifoop_opv_desc;
don't call the fs server for all operations, only those it has told us that it implements
2006-12-01 15:37:41 +03:00
extern const struct vnodeopv_desc puffs_msgop_opv_desc;
support specfs
2006-10-27 02:52:47 +04:00
make it possible to build & load puffs as an LKM by Lubomir Kundrak, PR kern/35000
2006-11-06 14:44:54 +03:00
extern struct pool puffs_pnpool;
* check userspace version and prevent incompatible mount * some general maintenance
2007-01-02 18:51:21 +03:00
#define PUFFS_NAMEPREFIX "puffs:"
kernel portion of puffs - the Pass-to-Userspace Framework File System. It contains the VFS attachment and userspace message-passing interface. This work was initially started and completed for Google SoC 2005 and tweaked to work a bit better in the past few weeks. While being far from complete, it is functional enough to be able and stable to host a fairly general-purpose in-memory file system in userspace. Even so, puffs should be considered experimental and no binary compatibility for interfaces or crash-freedom or zero security implications should be relied upon just yet. The GSoC project was mentored by William Studenmund and the final review for the code was done by Christos.
2006-10-23 02:43:23 +04:00
#define PUFFS_SIZEOPREQ_UIO_IN 1
#define PUFFS_SIZEOPREQ_UIO_OUT 2
#define PUFFS_SIZEOPREQ_BUF_IN 3
#define PUFFS_SIZEOPREQ_BUF_OUT 4
#define PUFFS_SIZEOP_UIO(a) \
(((a)==PUFFS_SIZEOPREQ_UIO_IN)||(a)==PUFFS_SIZEOPREQ_UIO_OUT)
#define PUFFS_SIZEOP_BUF(a) \
(((a)==PUFFS_SIZEOPREQ_BUF_IN)||(a)==PUFFS_SIZEOPREQ_BUF_OUT)
/* XXX: alignment-optimization */
struct puffs_sizepark {
uint64_t pkso_reqid;
uint8_t pkso_reqtype;
struct uio *pkso_uio;
void *pkso_copybuf;
size_t pkso_bufsize;
TAILQ_ENTRY(puffs_sizepark) pkso_entries;
};
Allow multiple requests to be transferred in each GET/PUTOP. For a single request, the performance is still the same.
2006-12-06 02:03:28 +03:00
#ifdef DEBUG
Hide the debug prints behind PUFFSDEBUG instead of DEBUG. Make the latter define the former.
2007-02-15 15:14:34 +03:00
#ifndef PUFFSDEBUG
#define PUFFSDEBUG
#endif
#endif
#ifdef PUFFSDEBUG
Allow multiple requests to be transferred in each GET/PUTOP. For a single request, the performance is still the same.
2006-12-06 02:03:28 +03:00
extern int puffsdebug; /* puffs_subr.c */
#define DPRINTF(x) if (puffsdebug > 0) printf x
#define DPRINTF_VERBOSE(x) if (puffsdebug > 1) printf x
#else
kernel portion of puffs - the Pass-to-Userspace Framework File System. It contains the VFS attachment and userspace message-passing interface. This work was initially started and completed for Google SoC 2005 and tweaked to work a bit better in the past few weeks. While being far from complete, it is functional enough to be able and stable to host a fairly general-purpose in-memory file system in userspace. Even so, puffs should be considered experimental and no binary compatibility for interfaces or crash-freedom or zero security implications should be relied upon just yet. The GSoC project was mentored by William Studenmund and the final review for the code was done by Christos.
2006-10-23 02:43:23 +04:00
#define DPRINTF(x)
don't call the fs server for all operations, only those it has told us that it implements
2006-12-01 15:37:41 +03:00
#define DPRINTF_VERBOSE(x)
Allow multiple requests to be transferred in each GET/PUTOP. For a single request, the performance is still the same.
2006-12-06 02:03:28 +03:00
#endif
kernel portion of puffs - the Pass-to-Userspace Framework File System. It contains the VFS attachment and userspace message-passing interface. This work was initially started and completed for Google SoC 2005 and tweaked to work a bit better in the past few weeks. While being far from complete, it is functional enough to be able and stable to host a fairly general-purpose in-memory file system in userspace. Even so, puffs should be considered experimental and no binary compatibility for interfaces or crash-freedom or zero security implications should be relied upon just yet. The GSoC project was mentored by William Studenmund and the final review for the code was done by Christos.
2006-10-23 02:43:23 +04:00
#define MPTOPUFFSMP(mp) ((struct puffs_mount *)((mp)->mnt_data))
#define PMPTOMP(pmp) (pmp->pmp_mp)
#define VPTOPP(vp) ((struct puffs_node *)(vp)->v_data)
#define VPTOPNC(vp) (((struct puffs_node *)(vp)->v_data)->pn_cookie)
#define VPTOPUFFSMP(vp) ((struct puffs_mount*)((struct puffs_node*)vp->v_data))
#define FPTOPMP(fp) (((struct puffs_instance *)fp->f_data)->pi_pmp)
#define FPTOPI(fp) ((struct puffs_instance *)fp->f_data)
Give the file server the ability to specify the file handle length instead of defining a static length file handle on the framework-level.
2007-04-16 17:03:26 +04:00
/* we don't pass the kernel overlay to userspace */
#define PUFFS_TOFHSIZE(s) ((s)==0 ? (s) : (s)+4)
#define PUFFS_FROMFHSIZE(s) ((s)==0 ? (s) : (s)-4)
Introduce puffs "setbacks", which can be used to set certain flags for nodes upon return from the userspace. Currently it can be used to indicate that the file server should be notified of "inactive" in case the file server has opted to not receive inactive every time the reference count for a vnode drops to zero. (inactive is a common event, almost never requires any action and must be executed sychronously, so it is wasteful). While doing this, cleanup the release-relock nonsense from the vntouser*() arguments. It was never enabled and the whole LOCKEDVP() concept was very broken to begin with.
2007-05-07 21:14:54 +04:00
#define ALLOPS(pmp) (pmp->pmp_flags & PUFFS_KFLAG_ALLOPS)
don't call the fs server for all operations, only those it has told us that it implements
2006-12-01 15:37:41 +03:00
#define EXISTSOP(pmp, op) \
Introduce puffs "setbacks", which can be used to set certain flags for nodes upon return from the userspace. Currently it can be used to indicate that the file server should be notified of "inactive" in case the file server has opted to not receive inactive every time the reference count for a vnode drops to zero. (inactive is a common event, almost never requires any action and must be executed sychronously, so it is wasteful). While doing this, cleanup the release-relock nonsense from the vntouser*() arguments. It was never enabled and the whole LOCKEDVP() concept was very broken to begin with.
2007-05-07 21:14:54 +04:00
(ALLOPS(pmp) || ((pmp)->pmp_vnopmask[PUFFS_VN_##op]))
don't call the fs server for all operations, only those it has told us that it implements
2006-12-01 15:37:41 +03:00
* use PUFFS_KFLAG_NOCACHE to also signal that we don't want the namecache * enter files into the namecache immediately when new nodes are created (if it's a caching mount, of course)
2006-12-30 04:29:03 +03:00
#define PUFFS_DOCACHE(pmp) (((pmp)->pmp_flags & PUFFS_KFLAG_NOCACHE) == 0)
* rework the page cache interaction a bit: cache metadata in the kernel and flush it out all at once instead of continuous updating * add support for delivering notifications to the file server about when a page was written to (but disabled by default for now). the file server can use this to request flushing or invalidating the kernel page cache
2007-03-20 13:21:58 +03:00
#define PUFFS_WCACHEINFO(pmp) 0
kernel portion of puffs - the Pass-to-Userspace Framework File System. It contains the VFS attachment and userspace message-passing interface. This work was initially started and completed for Google SoC 2005 and tweaked to work a bit better in the past few weeks. While being far from complete, it is functional enough to be able and stable to host a fairly general-purpose in-memory file system in userspace. Even so, puffs should be considered experimental and no binary compatibility for interfaces or crash-freedom or zero security implications should be relied upon just yet. The GSoC project was mentored by William Studenmund and the final review for the code was done by Christos.
2006-10-23 02:43:23 +04:00
TAILQ_HEAD(puffs_wq, puffs_park);
Store puffs_node's on lists hashed with the cookie value instead of just one flat list.
2007-01-16 02:29:08 +03:00
LIST_HEAD(puffs_node_hashlist, puffs_node);
kernel portion of puffs - the Pass-to-Userspace Framework File System. It contains the VFS attachment and userspace message-passing interface. This work was initially started and completed for Google SoC 2005 and tweaked to work a bit better in the past few weeks. While being far from complete, it is functional enough to be able and stable to host a fairly general-purpose in-memory file system in userspace. Even so, puffs should be considered experimental and no binary compatibility for interfaces or crash-freedom or zero security implications should be relied upon just yet. The GSoC project was mentored by William Studenmund and the final review for the code was done by Christos.
2006-10-23 02:43:23 +04:00
struct puffs_mount {
Convert spinlocks & sleep/wakeup to newlock2 locking stuff. Fix a bunch of bugs. * park structures are now always allocated from a pool instead of a mixed stack/malloc allocation * get rid of the whole adjbuf concept, always just alloc the maximal amount of memory to satisfy a request * little regression: don't allow interrupting wait from file system to userspace; this had problems already before, but now the problems really started to shine through. I'll try to make this work again some day. * fix bmap to return a sensible value in runp
2007-03-29 20:04:26 +04:00
kmutex_t pmp_lock;
kernel portion of puffs - the Pass-to-Userspace Framework File System. It contains the VFS attachment and userspace message-passing interface. This work was initially started and completed for Google SoC 2005 and tweaked to work a bit better in the past few weeks. While being far from complete, it is functional enough to be able and stable to host a fairly general-purpose in-memory file system in userspace. Even so, puffs should be considered experimental and no binary compatibility for interfaces or crash-freedom or zero security implications should be relied upon just yet. The GSoC project was mentored by William Studenmund and the final review for the code was done by Christos.
2006-10-23 02:43:23 +04:00
* add fhlen to kernel argument structure * rename it to puffs_kargs instead of puffs_args
2007-04-13 17:31:11 +04:00
struct puffs_kargs pmp_args;
don't call the fs server for all operations, only those it has told us that it implements
2006-12-01 15:37:41 +03:00
#define pmp_flags pmp_args.pa_flags
#define pmp_vnopmask pmp_args.pa_vnopmask
kernel portion of puffs - the Pass-to-Userspace Framework File System. It contains the VFS attachment and userspace message-passing interface. This work was initially started and completed for Google SoC 2005 and tweaked to work a bit better in the past few weeks. While being far from complete, it is functional enough to be able and stable to host a fairly general-purpose in-memory file system in userspace. Even so, puffs should be considered experimental and no binary compatibility for interfaces or crash-freedom or zero security implications should be relied upon just yet. The GSoC project was mentored by William Studenmund and the final review for the code was done by Christos.
2006-10-23 02:43:23 +04:00
struct puffs_wq pmp_req_touser;
Fix a problem introduced when I converted puffs to use newlock2: when unmounting the file system in case of a certain timing (and possibly some other conditions), a thread would wait on a condition variable, while another thread broadcast the cv and immediately proceeded to destroy it. The result was a system frozen completely solid shorly after the process waiting for the cv woke up. So introduce reference counting to synchronize destruction of the resources in unmount. I was able to repeat the problem only on my laptop in some special cases, so I do not know how common it was. Ironically, killing the file server process violently instead of unmount() didn't have this problem because it never entered the unmount path from two directions.
2007-05-01 16:18:40 +04:00
int pmp_req_touser_count;
Convert spinlocks & sleep/wakeup to newlock2 locking stuff. Fix a bunch of bugs. * park structures are now always allocated from a pool instead of a mixed stack/malloc allocation * get rid of the whole adjbuf concept, always just alloc the maximal amount of memory to satisfy a request * little regression: don't allow interrupting wait from file system to userspace; this had problems already before, but now the problems really started to shine through. I'll try to make this work again some day. * fix bmap to return a sensible value in runp
2007-03-29 20:04:26 +04:00
kcondvar_t pmp_req_waiter_cv;
kernel portion of puffs - the Pass-to-Userspace Framework File System. It contains the VFS attachment and userspace message-passing interface. This work was initially started and completed for Google SoC 2005 and tweaked to work a bit better in the past few weeks. While being far from complete, it is functional enough to be able and stable to host a fairly general-purpose in-memory file system in userspace. Even so, puffs should be considered experimental and no binary compatibility for interfaces or crash-freedom or zero security implications should be relied upon just yet. The GSoC project was mentored by William Studenmund and the final review for the code was done by Christos.
2006-10-23 02:43:23 +04:00
size_t pmp_req_maxsize;
struct puffs_wq pmp_req_replywait;
TAILQ_HEAD(, puffs_sizepark) pmp_req_sizepark;
Store puffs_node's on lists hashed with the cookie value instead of just one flat list.
2007-01-16 02:29:08 +03:00
struct puffs_node_hashlist *pmp_pnodehash;
Give the file server the ability to specify the file handle length instead of defining a static length file handle on the framework-level.
2007-04-16 17:03:26 +04:00
int pmp_npnodehash;
kernel portion of puffs - the Pass-to-Userspace Framework File System. It contains the VFS attachment and userspace message-passing interface. This work was initially started and completed for Google SoC 2005 and tweaked to work a bit better in the past few weeks. While being far from complete, it is functional enough to be able and stable to host a fairly general-purpose in-memory file system in userspace. Even so, puffs should be considered experimental and no binary compatibility for interfaces or crash-freedom or zero security implications should be relied upon just yet. The GSoC project was mentored by William Studenmund and the final review for the code was done by Christos.
2006-10-23 02:43:23 +04:00
struct mount *pmp_mp;
Make it possible for the file server to specify the root vnode type and other information instead of always using VDIR. To make this possible without races, require all root node information already in puffs_mount() and nuke puffs_start2() and the associated start operation completely. requested/inspired by Tobias Nygren
2007-05-17 17:59:22 +04:00
kernel portion of puffs - the Pass-to-Userspace Framework File System. It contains the VFS attachment and userspace message-passing interface. This work was initially started and completed for Google SoC 2005 and tweaked to work a bit better in the past few weeks. While being far from complete, it is functional enough to be able and stable to host a fairly general-purpose in-memory file system in userspace. Even so, puffs should be considered experimental and no binary compatibility for interfaces or crash-freedom or zero security implications should be relied upon just yet. The GSoC project was mentored by William Studenmund and the final review for the code was done by Christos.
2006-10-23 02:43:23 +04:00
struct vnode *pmp_root;
Make it possible for the file server to specify the root vnode type and other information instead of always using VDIR. To make this possible without races, require all root node information already in puffs_mount() and nuke puffs_start2() and the associated start operation completely. requested/inspired by Tobias Nygren
2007-05-17 17:59:22 +04:00
void *pmp_root_cookie;
enum vtype pmp_root_vtype;
vsize_t pmp_root_vsize;
dev_t pmp_root_rdev;
kernel portion of puffs - the Pass-to-Userspace Framework File System. It contains the VFS attachment and userspace message-passing interface. This work was initially started and completed for Google SoC 2005 and tweaked to work a bit better in the past few weeks. While being far from complete, it is functional enough to be able and stable to host a fairly general-purpose in-memory file system in userspace. Even so, puffs should be considered experimental and no binary compatibility for interfaces or crash-freedom or zero security implications should be relied upon just yet. The GSoC project was mentored by William Studenmund and the final review for the code was done by Christos.
2006-10-23 02:43:23 +04:00
struct selinfo *pmp_sel; /* in puffs_instance */
Fix a problem introduced when I converted puffs to use newlock2: when unmounting the file system in case of a certain timing (and possibly some other conditions), a thread would wait on a condition variable, while another thread broadcast the cv and immediately proceeded to destroy it. The result was a system frozen completely solid shorly after the process waiting for the cv woke up. So introduce reference counting to synchronize destruction of the resources in unmount. I was able to repeat the problem only on my laptop in some special cases, so I do not know how common it was. Ironically, killing the file server process violently instead of unmount() didn't have this problem because it never entered the unmount path from two directions.
2007-05-01 16:18:40 +04:00
unsigned int pmp_refcount;
kcondvar_t pmp_refcount_cv;
Convert spinlocks & sleep/wakeup to newlock2 locking stuff. Fix a bunch of bugs. * park structures are now always allocated from a pool instead of a mixed stack/malloc allocation * get rid of the whole adjbuf concept, always just alloc the maximal amount of memory to satisfy a request * little regression: don't allow interrupting wait from file system to userspace; this had problems already before, but now the problems really started to shine through. I'll try to make this work again some day. * fix bmap to return a sensible value in runp
2007-03-29 20:04:26 +04:00
Fix a problem introduced when I converted puffs to use newlock2: when unmounting the file system in case of a certain timing (and possibly some other conditions), a thread would wait on a condition variable, while another thread broadcast the cv and immediately proceeded to destroy it. The result was a system frozen completely solid shorly after the process waiting for the cv woke up. So introduce reference counting to synchronize destruction of the resources in unmount. I was able to repeat the problem only on my laptop in some special cases, so I do not know how common it was. Ironically, killing the file server process violently instead of unmount() didn't have this problem because it never entered the unmount path from two directions.
2007-05-01 16:18:40 +04:00
kcondvar_t pmp_unmounting_cv;
Fix a race condition that would cause the mountpoint to be cleaned from under someone waiting for the fs server response in puffs_unmount() if the descriptor was closed during the response wait (such as bug leading to a crash in fs implementation unmount()).
2006-12-11 01:33:31 +03:00
uint8_t pmp_unmounting;
Fix a problem introduced when I converted puffs to use newlock2: when unmounting the file system in case of a certain timing (and possibly some other conditions), a thread would wait on a condition variable, while another thread broadcast the cv and immediately proceeded to destroy it. The result was a system frozen completely solid shorly after the process waiting for the cv woke up. So introduce reference counting to synchronize destruction of the resources in unmount. I was able to repeat the problem only on my laptop in some special cases, so I do not know how common it was. Ironically, killing the file server process violently instead of unmount() didn't have this problem because it never entered the unmount path from two directions.
2007-05-01 16:18:40 +04:00
uint8_t pmp_status;
Initial attempt at suspend/snapshot support for userspace file servers. This is still pretty much on the level "if it breaks ...". It should work for single-threaded servers which handle one operation from start to finish in one go. Also, it does not yet totally correctly synchronize metadata and data in some cases. So needless to say, it needs improvement, but it is possible that will have to wait for some lock revampage.
2007-01-27 01:59:49 +03:00
uint8_t pmp_suspend;
Convert spinlocks & sleep/wakeup to newlock2 locking stuff. Fix a bunch of bugs. * park structures are now always allocated from a pool instead of a mixed stack/malloc allocation * get rid of the whole adjbuf concept, always just alloc the maximal amount of memory to satisfy a request * little regression: don't allow interrupting wait from file system to userspace; this had problems already before, but now the problems really started to shine through. I'll try to make this work again some day. * fix bmap to return a sensible value in runp
2007-03-29 20:04:26 +04:00
uint64_t pmp_nextreq;
kernel portion of puffs - the Pass-to-Userspace Framework File System. It contains the VFS attachment and userspace message-passing interface. This work was initially started and completed for Google SoC 2005 and tweaked to work a bit better in the past few weeks. While being far from complete, it is functional enough to be able and stable to host a fairly general-purpose in-memory file system in userspace. Even so, puffs should be considered experimental and no binary compatibility for interfaces or crash-freedom or zero security implications should be relied upon just yet. The GSoC project was mentored by William Studenmund and the final review for the code was done by Christos.
2006-10-23 02:43:23 +04:00
};
Introduce uncached operation, makes sense when the file system backend can be modified from elsewhere than the file system interface
2006-11-17 20:48:02 +03:00
kernel portion of puffs - the Pass-to-Userspace Framework File System. It contains the VFS attachment and userspace message-passing interface. This work was initially started and completed for Google SoC 2005 and tweaked to work a bit better in the past few weeks. While being far from complete, it is functional enough to be able and stable to host a fairly general-purpose in-memory file system in userspace. Even so, puffs should be considered experimental and no binary compatibility for interfaces or crash-freedom or zero security implications should be relied upon just yet. The GSoC project was mentored by William Studenmund and the final review for the code was done by Christos.
2006-10-23 02:43:23 +04:00
#define PUFFSTAT_BEFOREINIT 0
#define PUFFSTAT_MOUNTING 1
#define PUFFSTAT_RUNNING 2
Fix a race condition that would cause the mountpoint to be cleaned from under someone waiting for the fs server response in puffs_unmount() if the descriptor was closed during the response wait (such as bug leading to a crash in fs implementation unmount()).
2006-12-11 01:33:31 +03:00
#define PUFFSTAT_DYING 3 /* Do you want your possessions identified? */
kernel portion of puffs - the Pass-to-Userspace Framework File System. It contains the VFS attachment and userspace message-passing interface. This work was initially started and completed for Google SoC 2005 and tweaked to work a bit better in the past few weeks. While being far from complete, it is functional enough to be able and stable to host a fairly general-purpose in-memory file system in userspace. Even so, puffs should be considered experimental and no binary compatibility for interfaces or crash-freedom or zero security implications should be relied upon just yet. The GSoC project was mentored by William Studenmund and the final review for the code was done by Christos.
2006-10-23 02:43:23 +04:00
* rework the page cache interaction a bit: cache metadata in the kernel and flush it out all at once instead of continuous updating * add support for delivering notifications to the file server about when a page was written to (but disabled by default for now). the file server can use this to request flushing or invalidating the kernel page cache
2007-03-20 13:21:58 +03:00
Introduce noref setbacks, which the file server can use to signal the kernel it has 0 references to the node in question. In other words, this can be used to avoid inactive(), or, if the file server does not implement inactive, prompt reclaim for removed nodes.
2007-05-18 19:46:09 +04:00
#define PNODE_NOREFS 0x01 /* no backend reference */
forgot to commit this with puffs_vnops.c 1.72: Actually, we do need separate "no references in file server" and "noref + inactive" flags if we wish to correctly support unix open file semantics and optimize away pre-reclaim cache flushes. So, add PNODE_DYING which stands for norefs + inactive.
2007-05-19 20:50:49 +04:00
#define PNODE_DYING 0x02 /* NOREF + inactive */
#define PNODE_SUSPEND 0x04 /* issue all operations as FAF */
#define PNODE_DOINACT 0x08 /* if inactive-on-demand, call inactive */
* rework the page cache interaction a bit: cache metadata in the kernel and flush it out all at once instead of continuous updating * add support for delivering notifications to the file server about when a page was written to (but disabled by default for now). the file server can use this to request flushing or invalidating the kernel page cache
2007-03-20 13:21:58 +03:00
#define PNODE_METACACHE_ATIME 0x10 /* cache atime metadata */
#define PNODE_METACACHE_CTIME 0x20 /* cache atime metadata */
#define PNODE_METACACHE_MTIME 0x40 /* cache atime metadata */
#define PNODE_METACACHE_SIZE 0x80 /* cache atime metadata */
#define PNODE_METACACHE_MASK 0xf0
kernel portion of puffs - the Pass-to-Userspace Framework File System. It contains the VFS attachment and userspace message-passing interface. This work was initially started and completed for Google SoC 2005 and tweaked to work a bit better in the past few weeks. While being far from complete, it is functional enough to be able and stable to host a fairly general-purpose in-memory file system in userspace. Even so, puffs should be considered experimental and no binary compatibility for interfaces or crash-freedom or zero security implications should be relied upon just yet. The GSoC project was mentored by William Studenmund and the final review for the code was done by Christos.
2006-10-23 02:43:23 +04:00
struct puffs_node {
attach to genfs & support page cache. most noticeable effect is mmap and therefore execution of binaries starting to work, some speed improvements with large file I/O also. caching semantics and error case handling most likely need revisiting.
2006-11-08 01:10:18 +03:00
struct genfs_node pn_gnode; /* genfs glue */
Support VOP_POLL. This requires some acrobatics on the puffs_node, as we give a reference to userspace for the puffs_node for the duration of the poll call. So reference count puffs_node separately from the parent vnode. vref()/vrele() is not possible due to a possible surprise visit from VOP_INACTIVE.
2007-05-18 17:53:08 +04:00
kmutex_t pn_mtx;
int pn_refcount;
kernel portion of puffs - the Pass-to-Userspace Framework File System. It contains the VFS attachment and userspace message-passing interface. This work was initially started and completed for Google SoC 2005 and tweaked to work a bit better in the past few weeks. While being far from complete, it is functional enough to be able and stable to host a fairly general-purpose in-memory file system in userspace. Even so, puffs should be considered experimental and no binary compatibility for interfaces or crash-freedom or zero security implications should be relied upon just yet. The GSoC project was mentored by William Studenmund and the final review for the code was done by Christos.
2006-10-23 02:43:23 +04:00
void *pn_cookie; /* userspace pnode cookie */
struct vnode *pn_vp; /* backpointer to vnode */
uint32_t pn_stat; /* node status */
Support VOP_POLL. This requires some acrobatics on the puffs_node, as we give a reference to userspace for the puffs_node for the duration of the poll call. So reference count puffs_node separately from the parent vnode. vref()/vrele() is not possible due to a possible surprise visit from VOP_INACTIVE.
2007-05-18 17:53:08 +04:00
struct selinfo pn_sel; /* for selecting on the node */
short pn_revents; /* available events */
* rework the page cache interaction a bit: cache metadata in the kernel and flush it out all at once instead of continuous updating * add support for delivering notifications to the file server about when a page was written to (but disabled by default for now). the file server can use this to request flushing or invalidating the kernel page cache
2007-03-20 13:21:58 +03:00
/* metacache */
struct timespec pn_mc_atime;
struct timespec pn_mc_ctime;
struct timespec pn_mc_mtime;
u_quad_t pn_mc_size;
Store puffs_node's on lists hashed with the cookie value instead of just one flat list.
2007-01-16 02:29:08 +03:00
LIST_ENTRY(puffs_node) pn_hashent;
kernel portion of puffs - the Pass-to-Userspace Framework File System. It contains the VFS attachment and userspace message-passing interface. This work was initially started and completed for Google SoC 2005 and tweaked to work a bit better in the past few weeks. While being far from complete, it is functional enough to be able and stable to host a fairly general-purpose in-memory file system in userspace. Even so, puffs should be considered experimental and no binary compatibility for interfaces or crash-freedom or zero security implications should be relied upon just yet. The GSoC project was mentored by William Studenmund and the final review for the code was done by Christos.
2006-10-23 02:43:23 +04:00
};
* abstract ASYNCBIOREAD and let callers freely issue a callback called from putop. even though there's only one user currently, makes code more readable * move "delta" to a standard parameter in vntouser and get rid of the specialcase vntouser_delta
2007-03-30 21:48:57 +04:00
typedef void (*parkdone_fn)(struct puffs_req *, void *);
Convert spinlocks & sleep/wakeup to newlock2 locking stuff. Fix a bunch of bugs. * park structures are now always allocated from a pool instead of a mixed stack/malloc allocation * get rid of the whole adjbuf concept, always just alloc the maximal amount of memory to satisfy a request * little regression: don't allow interrupting wait from file system to userspace; this had problems already before, but now the problems really started to shine through. I'll try to make this work again some day. * fix bmap to return a sensible value in runp
2007-03-29 20:04:26 +04:00
void puffs_transport_init(void);
void puffs_transport_destroy(void);
void puffs_msgif_init(void);
void puffs_msgif_destroy(void);
Make it possible to interrupt waiters for fs operation completion again. This is useful until locking is further developed and basically any deadlocks can be solved by killing appropriate processes. Thanks especially to Tommi Kyntola and Antti Louko for sitting down with me and discussing resource ownership and locking strategies in implementing this.
2007-04-04 20:13:51 +04:00
void *puffs_park_alloc(int);
void puffs_park_release(void *, int);
Convert spinlocks & sleep/wakeup to newlock2 locking stuff. Fix a bunch of bugs. * park structures are now always allocated from a pool instead of a mixed stack/malloc allocation * get rid of the whole adjbuf concept, always just alloc the maximal amount of memory to satisfy a request * little regression: don't allow interrupting wait from file system to userspace; this had problems already before, but now the problems really started to shine through. I'll try to make this work again some day. * fix bmap to return a sensible value in runp
2007-03-29 20:04:26 +04:00
kernel portion of puffs - the Pass-to-Userspace Framework File System. It contains the VFS attachment and userspace message-passing interface. This work was initially started and completed for Google SoC 2005 and tweaked to work a bit better in the past few weeks. While being far from complete, it is functional enough to be able and stable to host a fairly general-purpose in-memory file system in userspace. Even so, puffs should be considered experimental and no binary compatibility for interfaces or crash-freedom or zero security implications should be relied upon just yet. The GSoC project was mentored by William Studenmund and the final review for the code was done by Christos.
2006-10-23 02:43:23 +04:00
int puffs_vfstouser(struct puffs_mount *, int, void *, size_t);
Initial attempt at suspend/snapshot support for userspace file servers. This is still pretty much on the level "if it breaks ...". It should work for single-threaded servers which handle one operation from start to finish in one go. Also, it does not yet totally correctly synchronize metadata and data in some cases. So needless to say, it needs improvement, but it is possible that will have to wait for some lock revampage.
2007-01-27 01:59:49 +03:00
void puffs_suspendtouser(struct puffs_mount *, int);
* abstract ASYNCBIOREAD and let callers freely issue a callback called from putop. even though there's only one user currently, makes code more readable * move "delta" to a standard parameter in vntouser and get rid of the specialcase vntouser_delta
2007-03-30 21:48:57 +04:00
int puffs_vntouser(struct puffs_mount *, int, void *, size_t, size_t,
Introduce puffs "setbacks", which can be used to set certain flags for nodes upon return from the userspace. Currently it can be used to indicate that the file server should be notified of "inactive" in case the file server has opted to not receive inactive every time the reference count for a vnode drops to zero. (inactive is a common event, almost never requires any action and must be executed sychronously, so it is wasteful). While doing this, cleanup the release-relock nonsense from the vntouser*() arguments. It was never enabled and the whole LOCKEDVP() concept was very broken to begin with.
2007-05-07 21:14:54 +04:00
struct vnode *, struct vnode *);
* abstract ASYNCBIOREAD and let callers freely issue a callback called from putop. even though there's only one user currently, makes code more readable * move "delta" to a standard parameter in vntouser and get rid of the specialcase vntouser_delta
2007-03-30 21:48:57 +04:00
int puffs_vntouser_req(struct puffs_mount *, int, void *, size_t, size_t,
Introduce puffs "setbacks", which can be used to set certain flags for nodes upon return from the userspace. Currently it can be used to indicate that the file server should be notified of "inactive" in case the file server has opted to not receive inactive every time the reference count for a vnode drops to zero. (inactive is a common event, almost never requires any action and must be executed sychronously, so it is wasteful). While doing this, cleanup the release-relock nonsense from the vntouser*() arguments. It was never enabled and the whole LOCKEDVP() concept was very broken to begin with.
2007-05-07 21:14:54 +04:00
uint64_t, struct vnode *, struct vnode *);
* abstract ASYNCBIOREAD and let callers freely issue a callback called from putop. even though there's only one user currently, makes code more readable * move "delta" to a standard parameter in vntouser and get rid of the specialcase vntouser_delta
2007-03-30 21:48:57 +04:00
void puffs_vntouser_call(struct puffs_mount *, int, void *, size_t, size_t,
Introduce puffs "setbacks", which can be used to set certain flags for nodes upon return from the userspace. Currently it can be used to indicate that the file server should be notified of "inactive" in case the file server has opted to not receive inactive every time the reference count for a vnode drops to zero. (inactive is a common event, almost never requires any action and must be executed sychronously, so it is wasteful). While doing this, cleanup the release-relock nonsense from the vntouser*() arguments. It was never enabled and the whole LOCKEDVP() concept was very broken to begin with.
2007-05-07 21:14:54 +04:00
parkdone_fn, void *, struct vnode *, struct vnode*);
void puffs_vntouser_faf(struct puffs_mount *, int, void *, size_t,
struct vnode *);
* rework the page cache interaction a bit: cache metadata in the kernel and flush it out all at once instead of continuous updating * add support for delivering notifications to the file server about when a page was written to (but disabled by default for now). the file server can use this to request flushing or invalidating the kernel page cache
2007-03-20 13:21:58 +03:00
void puffs_cacheop(struct puffs_mount *, struct puffs_park *,
struct puffs_cacheinfo *, size_t, void *);
struct puffs_park *puffs_cacheop_alloc(void);
kernel portion of puffs - the Pass-to-Userspace Framework File System. It contains the VFS attachment and userspace message-passing interface. This work was initially started and completed for Google SoC 2005 and tweaked to work a bit better in the past few weeks. While being far from complete, it is functional enough to be able and stable to host a fairly general-purpose in-memory file system in userspace. Even so, puffs should be considered experimental and no binary compatibility for interfaces or crash-freedom or zero security implications should be relied upon just yet. The GSoC project was mentored by William Studenmund and the final review for the code was done by Christos.
2006-10-23 02:43:23 +04:00
attach to genfs & support page cache. most noticeable effect is mmap and therefore execution of binaries starting to work, some speed improvements with large file I/O also. caching semantics and error case handling most likely need revisiting.
2006-11-08 01:10:18 +03:00
int puffs_getvnode(struct mount *, void *, enum vtype, voff_t, dev_t,
support specfs
2006-10-27 02:52:47 +04:00
struct vnode **);
kernel portion of puffs - the Pass-to-Userspace Framework File System. It contains the VFS attachment and userspace message-passing interface. This work was initially started and completed for Google SoC 2005 and tweaked to work a bit better in the past few weeks. While being far from complete, it is functional enough to be able and stable to host a fairly general-purpose in-memory file system in userspace. Even so, puffs should be considered experimental and no binary compatibility for interfaces or crash-freedom or zero security implications should be relied upon just yet. The GSoC project was mentored by William Studenmund and the final review for the code was done by Christos.
2006-10-23 02:43:23 +04:00
int puffs_newnode(struct mount *, struct vnode *, struct vnode **,
support specfs
2006-10-27 02:52:47 +04:00
void *, struct componentname *, enum vtype, dev_t);
kernel portion of puffs - the Pass-to-Userspace Framework File System. It contains the VFS attachment and userspace message-passing interface. This work was initially started and completed for Google SoC 2005 and tweaked to work a bit better in the past few weeks. While being far from complete, it is functional enough to be able and stable to host a fairly general-purpose in-memory file system in userspace. Even so, puffs should be considered experimental and no binary compatibility for interfaces or crash-freedom or zero security implications should be relied upon just yet. The GSoC project was mentored by William Studenmund and the final review for the code was done by Christos.
2006-10-23 02:43:23 +04:00
void puffs_putvnode(struct vnode *);
Support VOP_POLL. This requires some acrobatics on the puffs_node, as we give a reference to userspace for the puffs_node for the duration of the poll call. So reference count puffs_node separately from the parent vnode. vref()/vrele() is not possible due to a possible surprise visit from VOP_INACTIVE.
2007-05-18 17:53:08 +04:00
void puffs_releasenode(struct puffs_node *);
void puffs_referencenode(struct puffs_node *);
Refactor the pnode2vnode translation slightly so that VFS_ROOT can use it directly.
2007-06-21 18:54:49 +04:00
int puffs_pnode2vnode(struct puffs_mount *, void *, int, struct vnode **);
rename the kernel-provided componentname to puffs_kcn; libpuffs now provides puffs_cn built on top of it
2006-12-29 18:38:37 +03:00
void puffs_makecn(struct puffs_kcn *, const struct componentname *);
kernel portion of puffs - the Pass-to-Userspace Framework File System. It contains the VFS attachment and userspace message-passing interface. This work was initially started and completed for Google SoC 2005 and tweaked to work a bit better in the past few weeks. While being far from complete, it is functional enough to be able and stable to host a fairly general-purpose in-memory file system in userspace. Even so, puffs should be considered experimental and no binary compatibility for interfaces or crash-freedom or zero security implications should be relied upon just yet. The GSoC project was mentored by William Studenmund and the final review for the code was done by Christos.
2006-10-23 02:43:23 +04:00
void puffs_credcvt(struct puffs_cred *, kauth_cred_t);
pid_t puffs_lwp2pid(struct lwp *);
* abstract ASYNCBIOREAD and let callers freely issue a callback called from putop. even though there's only one user currently, makes code more readable * move "delta" to a standard parameter in vntouser and get rid of the specialcase vntouser_delta
2007-03-30 21:48:57 +04:00
void puffs_parkdone_asyncbioread(struct puffs_req *, void *);
Support VOP_POLL. This requires some acrobatics on the puffs_node, as we give a reference to userspace for the puffs_node for the duration of the poll call. So reference count puffs_node separately from the parent vnode. vref()/vrele() is not possible due to a possible surprise visit from VOP_INACTIVE.
2007-05-18 17:53:08 +04:00
void puffs_parkdone_poll(struct puffs_req *, void *);
* abstract ASYNCBIOREAD and let callers freely issue a callback called from putop. even though there's only one user currently, makes code more readable * move "delta" to a standard parameter in vntouser and get rid of the specialcase vntouser_delta
2007-03-30 21:48:57 +04:00
Fix a problem introduced when I converted puffs to use newlock2: when unmounting the file system in case of a certain timing (and possibly some other conditions), a thread would wait on a condition variable, while another thread broadcast the cv and immediately proceeded to destroy it. The result was a system frozen completely solid shorly after the process waiting for the cv woke up. So introduce reference counting to synchronize destruction of the resources in unmount. I was able to repeat the problem only on my laptop in some special cases, so I do not know how common it was. Ironically, killing the file server process violently instead of unmount() didn't have this problem because it never entered the unmount path from two directions.
2007-05-01 16:18:40 +04:00
void puffs_mp_reference(struct puffs_mount *);
void puffs_mp_release(struct puffs_mount *);
attach to genfs & support page cache. most noticeable effect is mmap and therefore execution of binaries starting to work, some speed improvements with large file I/O also. caching semantics and error case handling most likely need revisiting.
2006-11-08 01:10:18 +03:00
void puffs_updatenode(struct vnode *, int);
#define PUFFS_UPDATEATIME 0x01
#define PUFFS_UPDATECTIME 0x02
#define PUFFS_UPDATEMTIME 0x04
#define PUFFS_UPDATESIZE 0x08
As a first generation best-effort hack, use NOCACHE to mean "file size can change without the kernel knowing" and therefore query the file size before invoking read or write operations.
2006-11-18 11:18:24 +03:00
void puffs_updatevpsize(struct vnode *);
attach to genfs & support page cache. most noticeable effect is mmap and therefore execution of binaries starting to work, some speed improvements with large file I/O also. caching semantics and error case handling most likely need revisiting.
2006-11-08 01:10:18 +03:00
kernel portion of puffs - the Pass-to-Userspace Framework File System. It contains the VFS attachment and userspace message-passing interface. This work was initially started and completed for Google SoC 2005 and tweaked to work a bit better in the past few weeks. While being far from complete, it is functional enough to be able and stable to host a fairly general-purpose in-memory file system in userspace. Even so, puffs should be considered experimental and no binary compatibility for interfaces or crash-freedom or zero security implications should be relied upon just yet. The GSoC project was mentored by William Studenmund and the final review for the code was done by Christos.
2006-10-23 02:43:23 +04:00
int puffs_setpmp(pid_t, int, struct puffs_mount *);
void puffs_nukebypmp(struct puffs_mount *);
Convert spinlocks & sleep/wakeup to newlock2 locking stuff. Fix a bunch of bugs. * park structures are now always allocated from a pool instead of a mixed stack/malloc allocation * get rid of the whole adjbuf concept, always just alloc the maximal amount of memory to satisfy a request * little regression: don't allow interrupting wait from file system to userspace; this had problems already before, but now the problems really started to shine through. I'll try to make this work again some day. * fix bmap to return a sensible value in runp
2007-03-29 20:04:26 +04:00
uint64_t puffs_getreqid(struct puffs_mount *);
void puffs_userdead(struct puffs_mount *);
kernel portion of puffs - the Pass-to-Userspace Framework File System. It contains the VFS attachment and userspace message-passing interface. This work was initially started and completed for Google SoC 2005 and tweaked to work a bit better in the past few weeks. While being far from complete, it is functional enough to be able and stable to host a fairly general-purpose in-memory file system in userspace. Even so, puffs should be considered experimental and no binary compatibility for interfaces or crash-freedom or zero security implications should be relied upon just yet. The GSoC project was mentored by William Studenmund and the final review for the code was done by Christos.
2006-10-23 02:43:23 +04:00
shuffle functions around a bit: move the transport (/dev/puffs) to a different file from the messaging (request contents). no functional change
2006-12-06 02:41:24 +03:00
/* get/put called by ioctl handler */
int puffs_getop(struct puffs_mount *, struct puffs_reqh_get *, int);
int puffs_putop(struct puffs_mount *, struct puffs_reqh_put *);
kernel portion of puffs - the Pass-to-Userspace Framework File System. It contains the VFS attachment and userspace message-passing interface. This work was initially started and completed for Google SoC 2005 and tweaked to work a bit better in the past few weeks. While being far from complete, it is functional enough to be able and stable to host a fairly general-purpose in-memory file system in userspace. Even so, puffs should be considered experimental and no binary compatibility for interfaces or crash-freedom or zero security implications should be relied upon just yet. The GSoC project was mentored by William Studenmund and the final review for the code was done by Christos.
2006-10-23 02:43:23 +04:00
extern int (**puffs_vnodeop_p)(void *);
MALLOC_DECLARE(M_PUFFS);
#endif /* _PUFFS_SYS_H_ */