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

295 lines
9.1 KiB
C
Raw Normal View History

Make puffs_updatenode() take a puffs_node instead of a vnode. This way we don't need to worry if a vnode has been reclaimed from under us.
2007-11-18 00:55:29 +03:00
/* $NetBSD: puffs_sys.h,v 1.64 2007/11/17 21:55:29 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;
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))
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
Split the NOCACHE option in twain: NOCACHE_NAME & NOCACHE_PAGE.
2007-06-25 02:16:03 +04:00
#define PUFFS_USE_NAMECACHE(pmp) \
(((pmp)->pmp_flags & PUFFS_KFLAG_NOCACHE_NAME) == 0)
#define PUFFS_USE_PAGECACHE(pmp) \
(((pmp)->pmp_flags & PUFFS_KFLAG_NOCACHE_PAGE) == 0)
Give the file server to ability to request the entire pathname buffer under lookup by using PUFFS_KFLAG_LOOKUP_FULLPNBUF instead just the current component.
2007-07-02 02:54:16 +04:00
#define PUFFS_USE_FULLPNBUF(pmp) \
((pmp)->pmp_flags & PUFFS_KFLAG_LOOKUP_FULLPNBUF)
* 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
* 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
Fix a race in how new cookies are checked. Previously the checking was done separate of inserting the cookie into the lookup structure and without any form of interlock. This could lead to the same cookie pointing to two different nodes. Remedy the race by creating a separate "checked and ready to be inserted" cookie list which serves as an interlock without having to hold a fs-global creation lock.
2007-09-27 18:35:14 +04:00
struct puffs_newcookie {
void *pnc_cookie;
LIST_ENTRY(puffs_newcookie) pnc_entries;
};
Part 1/n of some pretty extensive changes to how the kernel module interacts with the userspace file server: * since the kernel-user communication is not purely request-response anymore (hasn't been since 2006), try to rename some "request" to "message". more similar mangling will take place in the future. * completely rework how messages are allocated. previously most of them were borrowed from the stack (originally *all* of them), but now always allocate dynamically. this makes the structure of the code much cleaner. also makes it possible to fix a locking order violation. it enables plenty of future enhancements. * start generalizing the transport interface to be independent of puffs * move transport interface to read/write instead of ioctl. the old one had legacy design problems, and besides, ioctl's suck. implement a very generic version for now; this will be worked on later hopefully some day reaching "highly optimized". * implement libpuffs support behind existing library request interfaces. this will change eventually (I hate those interfaces)
2007-10-11 23:41:13 +04:00
TAILQ_HEAD(puffs_wq, puffs_msgpark);
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
Part 1/n of some pretty extensive changes to how the kernel module interacts with the userspace file server: * since the kernel-user communication is not purely request-response anymore (hasn't been since 2006), try to rename some "request" to "message". more similar mangling will take place in the future. * completely rework how messages are allocated. previously most of them were borrowed from the stack (originally *all* of them), but now always allocate dynamically. this makes the structure of the code much cleaner. also makes it possible to fix a locking order violation. it enables plenty of future enhancements. * start generalizing the transport interface to be independent of puffs * move transport interface to read/write instead of ioctl. the old one had legacy design problems, and besides, ioctl's suck. implement a very generic version for now; this will be worked on later hopefully some day reaching "highly optimized". * implement libpuffs support behind existing library request interfaces. this will change eventually (I hate those interfaces)
2007-10-11 23:41:13 +04:00
struct puffs_wq pmp_msg_touser;
int pmp_msg_touser_count;
kcondvar_t pmp_msg_waiter_cv;
size_t pmp_msg_maxsize;
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
Part 1/n of some pretty extensive changes to how the kernel module interacts with the userspace file server: * since the kernel-user communication is not purely request-response anymore (hasn't been since 2006), try to rename some "request" to "message". more similar mangling will take place in the future. * completely rework how messages are allocated. previously most of them were borrowed from the stack (originally *all* of them), but now always allocate dynamically. this makes the structure of the code much cleaner. also makes it possible to fix a locking order violation. it enables plenty of future enhancements. * start generalizing the transport interface to be independent of puffs * move transport interface to read/write instead of ioctl. the old one had legacy design problems, and besides, ioctl's suck. implement a very generic version for now; this will be worked on later hopefully some day reaching "highly optimized". * implement libpuffs support behind existing library request interfaces. this will change eventually (I hate those interfaces)
2007-10-11 23:41:13 +04:00
struct puffs_wq pmp_msg_replywait;
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
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
Fix a race in how new cookies are checked. Previously the checking was done separate of inserting the cookie into the lookup structure and without any form of interlock. This could lead to the same cookie pointing to two different nodes. Remedy the race by creating a separate "checked and ready to be inserted" cookie list which serves as an interlock without having to hold a fs-global creation lock.
2007-09-27 18:35:14 +04:00
LIST_HEAD(, puffs_newcookie) pmp_newcookie;
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;
Part 2/n of extensive changes to request transport to/from userspace: Rip the transport code completely out of puffs and generalize it into an independent module which will be used for multiple purposes in the future. This module is called the Pass-to-Userspace Transporter (known as "putter" among friends). This is very much work-in-progress and one dependency with puffs remains: the request framing format. The device name is still /dev/puffs, but that will change soon. Users of puffs need the following in their kernel configs now: pseudo-device putter
2007-11-11 00:45:04 +03:00
struct putter_instance *pmp_pi;
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
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
Part 1/n of some pretty extensive changes to how the kernel module interacts with the userspace file server: * since the kernel-user communication is not purely request-response anymore (hasn't been since 2006), try to rename some "request" to "message". more similar mangling will take place in the future. * completely rework how messages are allocated. previously most of them were borrowed from the stack (originally *all* of them), but now always allocate dynamically. this makes the structure of the code much cleaner. also makes it possible to fix a locking order violation. it enables plenty of future enhancements. * start generalizing the transport interface to be independent of puffs * move transport interface to read/write instead of ioctl. the old one had legacy design problems, and besides, ioctl's suck. implement a very generic version for now; this will be worked on later hopefully some day reaching "highly optimized". * implement libpuffs support behind existing library request interfaces. this will change eventually (I hate those interfaces)
2007-10-11 23:41:13 +04:00
uint8_t *pmp_curput;
size_t pmp_curres;
void *pmp_curopaq;
uint64_t pmp_nextmsgid;
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;
Keep track of the maximum size we have supplied the file server (or it has supplied us). If we fault pages which are at offset >= server size, but less than the in-kernel vnode size, inform the file server of the latest developments in file size before issueing the fault. The avoids confusion with files which are not written start to finish. fixes kern/36429 by yamt
2007-07-22 22:22:49 +04:00
voff_t pn_serversize;
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
};
* better error checking: validate error values received from userland to be vaild errno values * include string describing error in PUFFS_ERR * get rid of union in puffs_req, it's nothing but trouble * pass pmp to async i/o callbacks
2007-10-02 01:09:07 +04:00
typedef void (*parkdone_fn)(struct puffs_mount *, 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
Part 1/n of some pretty extensive changes to how the kernel module interacts with the userspace file server: * since the kernel-user communication is not purely request-response anymore (hasn't been since 2006), try to rename some "request" to "message". more similar mangling will take place in the future. * completely rework how messages are allocated. previously most of them were borrowed from the stack (originally *all* of them), but now always allocate dynamically. this makes the structure of the code much cleaner. also makes it possible to fix a locking order violation. it enables plenty of future enhancements. * start generalizing the transport interface to be independent of puffs * move transport interface to read/write instead of ioctl. the old one had legacy design problems, and besides, ioctl's suck. implement a very generic version for now; this will be worked on later hopefully some day reaching "highly optimized". * implement libpuffs support behind existing library request interfaces. this will change eventually (I hate those interfaces)
2007-10-11 23:41:13 +04:00
struct puffs_msgpark;
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_msgif_init(void);
void puffs_msgif_destroy(void);
Part 1/n of some pretty extensive changes to how the kernel module interacts with the userspace file server: * since the kernel-user communication is not purely request-response anymore (hasn't been since 2006), try to rename some "request" to "message". more similar mangling will take place in the future. * completely rework how messages are allocated. previously most of them were borrowed from the stack (originally *all* of them), but now always allocate dynamically. this makes the structure of the code much cleaner. also makes it possible to fix a locking order violation. it enables plenty of future enhancements. * start generalizing the transport interface to be independent of puffs * move transport interface to read/write instead of ioctl. the old one had legacy design problems, and besides, ioctl's suck. implement a very generic version for now; this will be worked on later hopefully some day reaching "highly optimized". * implement libpuffs support behind existing library request interfaces. this will change eventually (I hate those interfaces)
2007-10-11 23:41:13 +04:00
int puffs_msgmem_alloc(size_t, struct puffs_msgpark **, void **, int);
void puffs_msgmem_release(struct puffs_msgpark *);
Restructure the messaging interface a bit more: make all interfacing with the file server happen through puffs_msg_enqueue() and puffs_msg_wait() instead of having a billion different routines. Build the existing system upon these two. Most importantly though, decouple insertation into the op queue from the actual wait. This is useful for a number of reasons coming soon to a cvs repo near you.
2007-11-16 23:32:17 +03:00
Part 1/n of some pretty extensive changes to how the kernel module interacts with the userspace file server: * since the kernel-user communication is not purely request-response anymore (hasn't been since 2006), try to rename some "request" to "message". more similar mangling will take place in the future. * completely rework how messages are allocated. previously most of them were borrowed from the stack (originally *all* of them), but now always allocate dynamically. this makes the structure of the code much cleaner. also makes it possible to fix a locking order violation. it enables plenty of future enhancements. * start generalizing the transport interface to be independent of puffs * move transport interface to read/write instead of ioctl. the old one had legacy design problems, and besides, ioctl's suck. implement a very generic version for now; this will be worked on later hopefully some day reaching "highly optimized". * implement libpuffs support behind existing library request interfaces. this will change eventually (I hate those interfaces)
2007-10-11 23:41:13 +04:00
void puffs_msg_setfaf(struct puffs_msgpark *);
Restructure the messaging interface a bit more: make all interfacing with the file server happen through puffs_msg_enqueue() and puffs_msg_wait() instead of having a billion different routines. Build the existing system upon these two. Most importantly though, decouple insertation into the op queue from the actual wait. This is useful for a number of reasons coming soon to a cvs repo near you.
2007-11-16 23:32:17 +03:00
void puffs_msg_setdelta(struct puffs_msgpark *, size_t);
void puffs_msg_setinfo(struct puffs_msgpark *, int, int, void *);
void puffs_msg_setcall(struct puffs_msgpark *, parkdone_fn, 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
Restructure the messaging interface a bit more: make all interfacing with the file server happen through puffs_msg_enqueue() and puffs_msg_wait() instead of having a billion different routines. Build the existing system upon these two. Most importantly though, decouple insertation into the op queue from the actual wait. This is useful for a number of reasons coming soon to a cvs repo near you.
2007-11-16 23:32:17 +03:00
void puffs_msg_enqueue(struct puffs_mount *, struct puffs_msgpark *);
int puffs_msg_wait(struct puffs_mount *, struct puffs_msgpark *);
int puffs_msg_wait2(struct puffs_mount *, struct puffs_msgpark *,
struct puffs_node *, struct 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
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 *);
Differentiate between cookie2vnode returning an error and return to caller, address unknown: no such cookie, no such node. Make the callers use this info to either create a new vnode or bail.
2007-09-28 01:44:12 +04:00
#define PUFFS_NOSUCHCOOKIE (-1)
Fix a race in how new cookies are checked. Previously the checking was done separate of inserting the cookie into the lookup structure and without any form of interlock. This could lead to the same cookie pointing to two different nodes. Remedy the race by creating a separate "checked and ready to be inserted" cookie list which serves as an interlock without having to hold a fs-global creation lock.
2007-09-27 18:35:14 +04:00
int puffs_cookie2vnode(struct puffs_mount *, void *, int, int,
struct vnode **);
make puffs_cred an opaque type
2007-07-01 19:30:15 +04:00
void puffs_makecn(struct puffs_kcn *, struct puffs_kcred *,
Give the file server to ability to request the entire pathname buffer under lookup by using PUFFS_KFLAG_LOOKUP_FULLPNBUF instead just the current component.
2007-07-02 02:54:16 +04:00
struct puffs_kcid *, const struct componentname *, int);
make puffs_cred an opaque type
2007-07-01 19:30:15 +04:00
void puffs_credcvt(struct puffs_kcred *, kauth_cred_t);
Instead of supplying a plain pid, supply an abstract struct puffs_cid *, which can currently be used to query the pid and lwpid.
2007-07-01 21:22:13 +04:00
void puffs_cidcvt(struct puffs_kcid *, const struct lwp *);
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
* better error checking: validate error values received from userland to be vaild errno values * include string describing error in PUFFS_ERR * get rid of union in puffs_req, it's nothing but trouble * pass pmp to async i/o callbacks
2007-10-02 01:09:07 +04:00
void puffs_parkdone_asyncbioread(struct puffs_mount *,
struct puffs_req *, void *);
Implement a biodone callback for async writes similar to reads and use that when possible.
2007-11-17 21:09:04 +03:00
void puffs_parkdone_asyncbiowrite(struct puffs_mount *,
struct puffs_req *, void *);
* better error checking: validate error values received from userland to be vaild errno values * include string describing error in PUFFS_ERR * get rid of union in puffs_req, it's nothing but trouble * pass pmp to async i/o callbacks
2007-10-02 01:09:07 +04:00
void puffs_parkdone_poll(struct puffs_mount *, 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 *);
Split routines handling nodes from puffs_subr to puffs_node. No functional change.
2007-09-28 03:21:07 +04:00
void puffs_gop_size(struct vnode *, off_t, off_t *, int);
void puffs_gop_markupdate(struct vnode *, int);
Restructure the messaging interface a bit more: make all interfacing with the file server happen through puffs_msg_enqueue() and puffs_msg_wait() instead of having a billion different routines. Build the existing system upon these two. Most importantly though, decouple insertation into the op queue from the actual wait. This is useful for a number of reasons coming soon to a cvs repo near you.
2007-11-16 23:32:17 +03:00
void puffs_senderr(struct puffs_mount *, int, int, const char *, void *);
Make puffs_updatenode() take a puffs_node instead of a vnode. This way we don't need to worry if a vnode has been reclaimed from under us.
2007-11-18 00:55:29 +03:00
void puffs_updatenode(struct puffs_node *, int, voff_t);
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
#define PUFFS_UPDATEATIME 0x01
#define PUFFS_UPDATECTIME 0x02
#define PUFFS_UPDATEMTIME 0x04
#define PUFFS_UPDATESIZE 0x08
Part 2/n of extensive changes to request transport to/from userspace: Rip the transport code completely out of puffs and generalize it into an independent module which will be used for multiple purposes in the future. This module is called the Pass-to-Userspace Transporter (known as "putter" among friends). This is very much work-in-progress and one dependency with puffs remains: the request framing format. The device name is still /dev/puffs, but that will change soon. Users of puffs need the following in their kernel configs now: pseudo-device putter
2007-11-11 00:45:04 +03:00
void puffs_userdead(struct puffs_mount *);
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
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);
Restructure the messaging interface a bit more: make all interfacing with the file server happen through puffs_msg_enqueue() and puffs_msg_wait() instead of having a billion different routines. Build the existing system upon these two. Most importantly though, decouple insertation into the op queue from the actual wait. This is useful for a number of reasons coming soon to a cvs repo near you.
2007-11-16 23:32:17 +03:00
/* for putter */
Part 1/n of some pretty extensive changes to how the kernel module interacts with the userspace file server: * since the kernel-user communication is not purely request-response anymore (hasn't been since 2006), try to rename some "request" to "message". more similar mangling will take place in the future. * completely rework how messages are allocated. previously most of them were borrowed from the stack (originally *all* of them), but now always allocate dynamically. this makes the structure of the code much cleaner. also makes it possible to fix a locking order violation. it enables plenty of future enhancements. * start generalizing the transport interface to be independent of puffs * move transport interface to read/write instead of ioctl. the old one had legacy design problems, and besides, ioctl's suck. implement a very generic version for now; this will be worked on later hopefully some day reaching "highly optimized". * implement libpuffs support behind existing library request interfaces. this will change eventually (I hate those interfaces)
2007-10-11 23:41:13 +04:00
int puffs_msgif_getout(void *, size_t, int, uint8_t **, size_t *, void **);
void puffs_msgif_releaseout(void *, void *, int);
Bounds-check responses from userspace.
2007-11-12 20:42:13 +03:00
int puffs_msgif_dispatch(void *, struct putter_hdr *);
Part 2/n of extensive changes to request transport to/from userspace: Rip the transport code completely out of puffs and generalize it into an independent module which will be used for multiple purposes in the future. This module is called the Pass-to-Userspace Transporter (known as "putter" among friends). This is very much work-in-progress and one dependency with puffs remains: the request framing format. The device name is still /dev/puffs, but that will change soon. Users of puffs need the following in their kernel configs now: pseudo-device putter
2007-11-11 00:45:04 +03:00
size_t puffs_msgif_waitcount(void *);
int puffs_msgif_close(void *);
Part 1/n of some pretty extensive changes to how the kernel module interacts with the userspace file server: * since the kernel-user communication is not purely request-response anymore (hasn't been since 2006), try to rename some "request" to "message". more similar mangling will take place in the future. * completely rework how messages are allocated. previously most of them were borrowed from the stack (originally *all* of them), but now always allocate dynamically. this makes the structure of the code much cleaner. also makes it possible to fix a locking order violation. it enables plenty of future enhancements. * start generalizing the transport interface to be independent of puffs * move transport interface to read/write instead of ioctl. the old one had legacy design problems, and besides, ioctl's suck. implement a very generic version for now; this will be worked on later hopefully some day reaching "highly optimized". * implement libpuffs support behind existing library request interfaces. this will change eventually (I hate those interfaces)
2007-10-11 23:41:13 +04:00
* better error checking: validate error values received from userland to be vaild errno values * include string describing error in PUFFS_ERR * get rid of union in puffs_req, it's nothing but trouble * pass pmp to async i/o callbacks
2007-10-02 01:09:07 +04:00
static __inline int
checkerr(struct puffs_mount *pmp, int error, const char *str)
{
if (error < 0 || error > ELAST) {
Restructure the messaging interface a bit more: make all interfacing with the file server happen through puffs_msg_enqueue() and puffs_msg_wait() instead of having a billion different routines. Build the existing system upon these two. Most importantly though, decouple insertation into the op queue from the actual wait. This is useful for a number of reasons coming soon to a cvs repo near you.
2007-11-16 23:32:17 +03:00
puffs_senderr(pmp, PUFFS_ERR_ERROR, error, str, NULL);
* better error checking: validate error values received from userland to be vaild errno values * include string describing error in PUFFS_ERR * get rid of union in puffs_req, it's nothing but trouble * pass pmp to async i/o callbacks
2007-10-02 01:09:07 +04:00
error = EPROTO;
}
return error;
}
Part 1/n of some pretty extensive changes to how the kernel module interacts with the userspace file server: * since the kernel-user communication is not purely request-response anymore (hasn't been since 2006), try to rename some "request" to "message". more similar mangling will take place in the future. * completely rework how messages are allocated. previously most of them were borrowed from the stack (originally *all* of them), but now always allocate dynamically. this makes the structure of the code much cleaner. also makes it possible to fix a locking order violation. it enables plenty of future enhancements. * start generalizing the transport interface to be independent of puffs * move transport interface to read/write instead of ioctl. the old one had legacy design problems, and besides, ioctl's suck. implement a very generic version for now; this will be worked on later hopefully some day reaching "highly optimized". * implement libpuffs support behind existing library request interfaces. this will change eventually (I hate those interfaces)
2007-10-11 23:41:13 +04:00
#define PUFFS_MSG_VARS(type, a) \
struct puffs_##type##msg_##a *a##_msg; \
struct puffs_msgpark *park_##a = NULL
#define PUFFS_MSG_ALLOC(type, a) \
puffs_msgmem_alloc(sizeof(struct puffs_##type##msg_##a), \
&park_##a, (void **)& a##_msg, 1)
#define PUFFS_MSG_RELEASE(a) \
do { \
if (park_##a) puffs_msgmem_release(park_##a); \
} while (/*CONSTCOND*/0)
Restructure the messaging interface a bit more: make all interfacing with the file server happen through puffs_msg_enqueue() and puffs_msg_wait() instead of having a billion different routines. Build the existing system upon these two. Most importantly though, decouple insertation into the op queue from the actual wait. This is useful for a number of reasons coming soon to a cvs repo near you.
2007-11-16 23:32:17 +03:00
#define PUFFS_MSG_ENQUEUEWAIT(pmp, park, var) \
do { \
puffs_msg_enqueue(pmp, park); \
var = puffs_msg_wait(pmp, park); \
} while (/*CONSTCOND*/0)
#define PUFFS_MSG_ENQUEUEWAIT2(pmp, park, vp1, vp2, var) \
do { \
puffs_msg_enqueue(pmp, park); \
var = puffs_msg_wait2(pmp, park, vp1, vp2); \
} while (/*CONSTCOND*/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
#endif /* _PUFFS_SYS_H_ */