Aren
/
NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
NetBSD/lib/libpuffs/puffs_priv.h

257 lines
7.0 KiB
C
Raw Normal View History

Implement lazy contexts for file systems using puffs_mainloop(). Previously each request was executed on its own callcontext and switched to every time the request was being processed. Now requests borrow the mainloop context and switch only if/when they yield. This takes two context switches away from a file system request bringing down the typical amounts 2->0 (e.g. dtfs) and 4->2 (e.g. psshfs). The interfaces for manually executing requests changed a bit: puffs_dispatch_create() and puffs_dispatch_exec() must now be used. They are not tested, as nothing in-tree wants them and I doubt anyone else is really interested in them either. Also do some misc code cleanup related to execution contexts. The "work-in-progress checkpoint" committed over a year ago was starting to look slightly weed-infested.
2008-01-28 21:35:49 +03:00
/* $NetBSD: puffs_priv.h,v 1.39 2008/01/28 18:35:50 pooka Exp $ */
outline & export code for interfacing with kernel GET/PUT requests
2006-12-08 02:15:20 +03:00
/*
Cache a number of execution contexts instead of re-initializing them every time. Speeds up pure in-memory file systems such as sysctlfs or dtfs quite a bit. For actual I/O-workhorses the result is of course less tasty.
2008-01-17 00:29:59 +03:00
* Copyright (c) 2006, 2007, 2008 Antti Kantee. All Rights Reserved.
outline & export code for interfacing with kernel GET/PUT requests
2006-12-08 02:15:20 +03:00
*
* 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_PRIVATE_H_
#define _PUFFS_PRIVATE_H_
#include <sys/types.h>
#include <fs/puffs/puffs_msgif.h>
#include <puffs.h>
checkpoint some experimental work-in-progress, namely: Add support for having multiple outstanding operations. This is done by exposing enough interfaces so that it is convenient to have the main event loop in the implementation itself and by providing a continuation framework for convinient blocking and rescheduling. works fine, but will undergo further cleanup & development
2006-12-29 18:28:11 +03:00
#include <ucontext.h>
Sprinkle some hackish locks here and there, just enough to allow libp2k & rump to run multithreaded.
2007-10-29 18:52:44 +03:00
#ifdef PUFFS_WITH_THREADS
#include <pthread.h>
extern pthread_mutex_t pu_lock;
Fix a few bugs and memleaks with the threading code.
2007-10-31 19:09:09 +03:00
#define PU_LOCK() pthread_mutex_lock(&pu_lock)
#define PU_UNLOCK() pthread_mutex_unlock(&pu_lock)
Sprinkle some hackish locks here and there, just enough to allow libp2k & rump to run multithreaded.
2007-10-29 18:52:44 +03:00
#else
#define PU_LOCK()
#define PU_UNLOCK()
#endif
Add a public interface for setting a cookie mapper.
2007-12-25 23:38:01 +03:00
#define PU_CMAP(pu, c) (pu->pu_cmap ? pu->pu_cmap(pu,c) : (struct puffs_node*)c)
Checkpoint some more work in progress: for the benefit those file system backends which operate purely based on paths, push out more path management into the library and make path management more abstract: enable a file system to define a bunch of path management callbacks, which are used by the framework. Management of normal /this/is/a/path type paths is provided by the library.
2007-01-15 03:39:02 +03:00
Step 2 of general-purpose eventloop: get rid of puffs_framebuf_eventloop(). puffs_mainloop() now handles that functionality as well.
2007-05-12 01:27:13 +04:00
struct puffs_framectrl {
Step 3 and currently final step of a more general purpose event loop: support removal and addition of i/o file descriptors on the fly. * detect closed file descriptors * automatically free waiters of a dead file descriptor * give the file server the possibility to specify a callback which notifies of a dead file descriptor * move loop function to be a property of the mainloop instead of framebuf (doesn't change effective behaviour) * add the possibility to configure a timespec parameter which attempts to call the loop function periodically * move the event loop functions from the puffs_framebuf namespace to puffs_framev to differential between pure memory management functions
2007-05-15 17:44:46 +04:00
puffs_framev_readframe_fn rfb;
puffs_framev_writeframe_fn wfb;
Change the signature of puffs_respcmp to return -1,0,1 for smaller, equal, larger, respectively instead of 0/1 for non/equal. This will allow sorting the buffers for faster matching in libpuffs. While here, change the name from respcmp to framecmp, as that better reflects the purpose. NOTE! there is no obvious way to make compilation fail for file systems which may already be using this feature (although I don't think there are any outside our tree, as the feature is two weeks old). Nevertheless, non-updated file systems will fail very quickly.
2007-05-20 20:24:37 +04:00
puffs_framev_cmpframe_fn cmpfb;
Add gotframe callback, which is called if an incoming frame matches no outstanding request.
2007-09-01 20:42:42 +04:00
puffs_framev_gotframe_fn gotfb;
Step 3 and currently final step of a more general purpose event loop: support removal and addition of i/o file descriptors on the fly. * detect closed file descriptors * automatically free waiters of a dead file descriptor * give the file server the possibility to specify a callback which notifies of a dead file descriptor * move loop function to be a property of the mainloop instead of framebuf (doesn't change effective behaviour) * add the possibility to configure a timespec parameter which attempts to call the loop function periodically * move the event loop functions from the puffs_framebuf namespace to puffs_framev to differential between pure memory management functions
2007-05-15 17:44:46 +04:00
puffs_framev_fdnotify_fn fdnotfn;
Step 2 of general-purpose eventloop: get rid of puffs_framebuf_eventloop(). puffs_mainloop() now handles that functionality as well.
2007-05-12 01:27:13 +04:00
};
struct puffs_fctrl_io {
Part 3/n of extensive changes to message handling: Get rid of the original puffs_req(3) framework and use puffs_framebuf(3) instead for file system requests. It has the advantage of being suitable for transporting a distributed message passing protocol and therefore us being able to run the file system server on any host. Ok, puffs is not quite here yet: libpuffs needs to grow request routing support and the message contents need to be munged into a host independent format. Saying which format would be telling, but it might begin with an X, end in an L and have the 13th character in the middle. Keep an eye out for the sequels: Parts 3+m/n.
2007-12-05 00:24:10 +03:00
struct puffs_framectrl *fctrl;
Step 2 of general-purpose eventloop: get rid of puffs_framebuf_eventloop(). puffs_mainloop() now handles that functionality as well.
2007-05-12 01:27:13 +04:00
int io_fd;
Step 3 and currently final step of a more general purpose event loop: support removal and addition of i/o file descriptors on the fly. * detect closed file descriptors * automatically free waiters of a dead file descriptor * give the file server the possibility to specify a callback which notifies of a dead file descriptor * move loop function to be a property of the mainloop instead of framebuf (doesn't change effective behaviour) * add the possibility to configure a timespec parameter which attempts to call the loop function periodically * move the event loop functions from the puffs_framebuf namespace to puffs_framev to differential between pure memory management functions
2007-05-15 17:44:46 +04:00
int stat;
Step 2 of general-purpose eventloop: get rid of puffs_framebuf_eventloop(). puffs_mainloop() now handles that functionality as well.
2007-05-12 01:27:13 +04:00
Add puffs_framev_enqueue_waitevent, which waits for read/write/error events from an i/o descriptor. It yields until an event happens and continues execution when the event loop notices the event has happened.
2007-07-20 17:14:55 +04:00
int rwait;
int wwait;
Step 2 of general-purpose eventloop: get rid of puffs_framebuf_eventloop(). puffs_mainloop() now handles that functionality as well.
2007-05-12 01:27:13 +04:00
struct puffs_framebuf *cur_in;
TAILQ_HEAD(, puffs_framebuf) snd_qing; /* queueing to be sent */
TAILQ_HEAD(, puffs_framebuf) res_qing; /* q'ing for rescue */
Add puffs_framev_enqueue_waitevent, which waits for read/write/error events from an i/o descriptor. It yields until an event happens and continues execution when the event loop notices the event has happened.
2007-07-20 17:14:55 +04:00
LIST_HEAD(, puffs_fbevent) ev_qing; /* q'ing for events */
Step 2 of general-purpose eventloop: get rid of puffs_framebuf_eventloop(). puffs_mainloop() now handles that functionality as well.
2007-05-12 01:27:13 +04:00
LIST_ENTRY(puffs_fctrl_io) fio_entries;
};
Step 3 and currently final step of a more general purpose event loop: support removal and addition of i/o file descriptors on the fly. * detect closed file descriptors * automatically free waiters of a dead file descriptor * give the file server the possibility to specify a callback which notifies of a dead file descriptor * move loop function to be a property of the mainloop instead of framebuf (doesn't change effective behaviour) * add the possibility to configure a timespec parameter which attempts to call the loop function periodically * move the event loop functions from the puffs_framebuf namespace to puffs_framev to differential between pure memory management functions
2007-05-15 17:44:46 +04:00
#define FIO_WR 0x01
#define FIO_WRGONE 0x02
#define FIO_RDGONE 0x04
#define FIO_DEAD 0x08
Make puffs_framebuf better suited from environments with multiple sources: * in addition add/remove, allow enable/disable, which can be used to control events for descriptors without having to remove all the data associated with them * add directsend/receive, which can be used to pass the same buffer from the caller to read/writeframe and back again * add flags to enqueue functions and allow urgent buffers to be processed as the next PDU
2007-07-08 01:13:41 +04:00
#define FIO_ENABLE_R 0x10
#define FIO_ENABLE_W 0x20
Step 3 and currently final step of a more general purpose event loop: support removal and addition of i/o file descriptors on the fly. * detect closed file descriptors * automatically free waiters of a dead file descriptor * give the file server the possibility to specify a callback which notifies of a dead file descriptor * move loop function to be a property of the mainloop instead of framebuf (doesn't change effective behaviour) * add the possibility to configure a timespec parameter which attempts to call the loop function periodically * move the event loop functions from the puffs_framebuf namespace to puffs_framev to differential between pure memory management functions
2007-05-15 17:44:46 +04:00
Add puffs_framev_enqueue_waitevent, which waits for read/write/error events from an i/o descriptor. It yields until an event happens and continues execution when the event loop notices the event has happened.
2007-07-20 17:14:55 +04:00
#define FIO_EN_WRITE(fio) \
(!(fio->stat & FIO_WR) \
&& ((!TAILQ_EMPTY(&fio->snd_qing) \
&& (fio->stat & FIO_ENABLE_W)) \
|| fio->wwait))
Make puffs_framebuf better suited from environments with multiple sources: * in addition add/remove, allow enable/disable, which can be used to control events for descriptors without having to remove all the data associated with them * add directsend/receive, which can be used to pass the same buffer from the caller to read/writeframe and back again * add flags to enqueue functions and allow urgent buffers to be processed as the next PDU
2007-07-08 01:13:41 +04:00
#define FIO_RM_WRITE(fio) \
((fio->stat & FIO_WR) \
Add puffs_framev_enqueue_waitevent, which waits for read/write/error events from an i/o descriptor. It yields until an event happens and continues execution when the event loop notices the event has happened.
2007-07-20 17:14:55 +04:00
&& (((TAILQ_EMPTY(&fio->snd_qing) \
|| (fio->stat & FIO_ENABLE_W) == 0)) \
&& (fio->wwait == 0)))
Add puffs "frame buffers", which are an abstraction of the buffering and event handling mechanisms required in file servers with blocking I/O backends. puffs_framebuf is built on the concept of puffs_cc and uses those to multiplex execution where needed. File systems are required to implement three methods: * read frame * write frame * compare if frame is a response to the given one Memory management is provided by puffs_framebuf, but the file systems must still, of course, interpret the protocol and do e.g. byte order conversion. As always, puffs_framebuf is work in progress. Current users are mount_psshfs and mount_9p.
2007-05-05 19:48:18 +04:00
Add some very initial support for a threading worker model as an alternative to the (vastly superior ;) continuation model. This is very preliminary stuff and not compiled by default (which it even won't do without some other patches I cannot commit yet). The raison d'commit of the patch is a snippet which ensures proper in-order dispatching of all operations, including those which don't require a response. Previously many of them would be dispatched simultaneosly, e.g. fsync and reclaim on the same node, which obviously isn't all that nice for correct operation.
2007-10-26 21:35:01 +04:00
Hide struct puffs_usermount from the rest of the world and provide accessors for interesting data in it. Namely, you can now get pu->pu_privdata with puffs_getspecific(), pu->pu_pn_root with puffs_set/getroot() and pu->pu_maxreqlen with puffs_getmaxreqlen().
2007-04-12 19:09:00 +04:00
/*
* usermount: describes one file system instance
*/
struct puffs_usermount {
struct puffs_ops pu_ops;
Don't float puffs_kargs needlessly around after mount, saves a couple k of memory (and there was much rejoycing!)
2007-07-19 16:52:28 +04:00
int pu_fd;
size_t pu_maxreqlen;
Hide struct puffs_usermount from the rest of the world and provide accessors for interesting data in it. Namely, you can now get pu->pu_privdata with puffs_getspecific(), pu->pu_pn_root with puffs_set/getroot() and pu->pu_maxreqlen with puffs_getmaxreqlen().
2007-04-12 19:09:00 +04:00
uint32_t pu_flags;
mmap stacks, makes it possible to align them
2007-10-26 17:51:14 +04:00
int pu_cc_stackshift;
Hide struct puffs_usermount from the rest of the world and provide accessors for interesting data in it. Namely, you can now get pu->pu_privdata with puffs_getspecific(), pu->pu_pn_root with puffs_set/getroot() and pu->pu_maxreqlen with puffs_getmaxreqlen().
2007-04-12 19:09:00 +04:00
Implement lazy contexts for file systems using puffs_mainloop(). Previously each request was executed on its own callcontext and switched to every time the request was being processed. Now requests borrow the mainloop context and switch only if/when they yield. This takes two context switches away from a file system request bringing down the typical amounts 2->0 (e.g. dtfs) and 4->2 (e.g. psshfs). The interfaces for manually executing requests changed a bit: puffs_dispatch_create() and puffs_dispatch_exec() must now be used. They are not tested, as nothing in-tree wants them and I doubt anyone else is really interested in them either. Also do some misc code cleanup related to execution contexts. The "work-in-progress checkpoint" committed over a year ago was starting to look slightly weed-infested.
2008-01-28 21:35:49 +03:00
struct puffs_cc *pu_cc_main;
Cache a number of execution contexts instead of re-initializing them every time. Speeds up pure in-memory file systems such as sysctlfs or dtfs quite a bit. For actual I/O-workhorses the result is of course less tasty.
2008-01-17 00:29:59 +03:00
#define PUFFS_CCMAXSTORE 32
int pu_cc_nstored;
Step 2 of general-purpose eventloop: get rid of puffs_framebuf_eventloop(). puffs_mainloop() now handles that functionality as well.
2007-05-12 01:27:13 +04:00
int pu_kq;
Hide struct puffs_usermount from the rest of the world and provide accessors for interesting data in it. Namely, you can now get pu->pu_privdata with puffs_getspecific(), pu->pu_pn_root with puffs_set/getroot() and pu->pu_maxreqlen with puffs_getmaxreqlen().
2007-04-12 19:09:00 +04:00
int pu_state;
Step 2 of general-purpose eventloop: get rid of puffs_framebuf_eventloop(). puffs_mainloop() now handles that functionality as well.
2007-05-12 01:27:13 +04:00
#define PU_STATEMASK 0xff
#define PU_INLOOP 0x100
Step 3 and currently final step of a more general purpose event loop: support removal and addition of i/o file descriptors on the fly. * detect closed file descriptors * automatically free waiters of a dead file descriptor * give the file server the possibility to specify a callback which notifies of a dead file descriptor * move loop function to be a property of the mainloop instead of framebuf (doesn't change effective behaviour) * add the possibility to configure a timespec parameter which attempts to call the loop function periodically * move the event loop functions from the puffs_framebuf namespace to puffs_framev to differential between pure memory management functions
2007-05-15 17:44:46 +04:00
#define PU_ASYNCFD 0x200
Make pu_haskq a flag instead of its own variable.
2007-10-25 14:59:45 +04:00
#define PU_HASKQ 0x400
Introduce puffs_daemon(), which works like daemon(3) except that it also synchronizes with puffs_mount() and does not return (exit) in the parent process until the file system has been mounted. This makes it possible to reliably run e.g. mount_foo jippi /kai ; cd /kai/ee
2007-11-16 21:35:10 +03:00
#define PU_PUFFSDAEMON 0x800
Step 2 of general-purpose eventloop: get rid of puffs_framebuf_eventloop(). puffs_mainloop() now handles that functionality as well.
2007-05-12 01:27:13 +04:00
#define PU_SETSTATE(pu, s) (pu->pu_state = (s) | (pu->pu_state & ~PU_STATEMASK))
Introduce puffs_daemon(), which works like daemon(3) except that it also synchronizes with puffs_mount() and does not return (exit) in the parent process until the file system has been mounted. This makes it possible to reliably run e.g. mount_foo jippi /kai ; cd /kai/ee
2007-11-16 21:35:10 +03:00
int pu_dpipe[2];
Hide struct puffs_usermount from the rest of the world and provide accessors for interesting data in it. Namely, you can now get pu->pu_privdata with puffs_getspecific(), pu->pu_pn_root with puffs_set/getroot() and pu->pu_maxreqlen with puffs_getmaxreqlen().
2007-04-12 19:09:00 +04:00
struct puffs_node *pu_pn_root;
LIST_HEAD(, puffs_node) pu_pnodelst;
Cache a number of execution contexts instead of re-initializing them every time. Speeds up pure in-memory file systems such as sysctlfs or dtfs quite a bit. For actual I/O-workhorses the result is of course less tasty.
2008-01-17 00:29:59 +03:00
LIST_HEAD(, puffs_cc) pu_ccmagazin;
Implement lazy contexts for file systems using puffs_mainloop(). Previously each request was executed on its own callcontext and switched to every time the request was being processed. Now requests borrow the mainloop context and switch only if/when they yield. This takes two context switches away from a file system request bringing down the typical amounts 2->0 (e.g. dtfs) and 4->2 (e.g. psshfs). The interfaces for manually executing requests changed a bit: puffs_dispatch_create() and puffs_dispatch_exec() must now be used. They are not tested, as nothing in-tree wants them and I doubt anyone else is really interested in them either. Also do some misc code cleanup related to execution contexts. The "work-in-progress checkpoint" committed over a year ago was starting to look slightly weed-infested.
2008-01-28 21:35:49 +03:00
TAILQ_HEAD(, puffs_cc) pu_lazyctx;
Add puffs_cc_schedule() which marks a pcc runnable and will pass execution to it when in the main loop the next time.
2007-10-21 23:25:58 +04:00
TAILQ_HEAD(, puffs_cc) pu_sched;
Hide struct puffs_usermount from the rest of the world and provide accessors for interesting data in it. Namely, you can now get pu->pu_privdata with puffs_getspecific(), pu->pu_pn_root with puffs_set/getroot() and pu->pu_maxreqlen with puffs_getmaxreqlen().
2007-04-12 19:09:00 +04:00
Add a public interface for setting a cookie mapper.
2007-12-25 23:38:01 +03:00
pu_cmap_fn pu_cmap;
Hide struct puffs_usermount from the rest of the world and provide accessors for interesting data in it. Namely, you can now get pu->pu_privdata with puffs_getspecific(), pu->pu_pn_root with puffs_set/getroot() and pu->pu_maxreqlen with puffs_getmaxreqlen().
2007-04-12 19:09:00 +04:00
pu_pathbuild_fn pu_pathbuild;
pu_pathtransform_fn pu_pathtransform;
pu_pathcmp_fn pu_pathcmp;
pu_pathfree_fn pu_pathfree;
pu_namemod_fn pu_namemod;
Add error notifications, which are used to deliver errors from the kernel to the file server for silly things the file server did, e.g. attempting to create a file with size VSIZENOTSET. The file server can handle these as it chooses, but the default action is for it to throw its hands in the air and sing "goodbye, cruel world, it's over, walk on by".
2007-09-28 01:14:49 +04:00
pu_errnotify_fn pu_errnotify;
Add possibility to set pre- and post callbacks which will be called for all operations before or after executing the specific callback (the api is not be final yet, though).
2007-10-28 21:40:30 +03:00
pu_prepost_fn pu_oppre;
pu_prepost_fn pu_oppost;
Part 3/n of extensive changes to message handling: Get rid of the original puffs_req(3) framework and use puffs_framebuf(3) instead for file system requests. It has the advantage of being suitable for transporting a distributed message passing protocol and therefore us being able to run the file system server on any host. Ok, puffs is not quite here yet: libpuffs needs to grow request routing support and the message contents need to be munged into a host independent format. Saying which format would be telling, but it might begin with an X, end in an L and have the 13th character in the middle. Keep an eye out for the sequels: Parts 3+m/n.
2007-12-05 00:24:10 +03:00
struct puffs_framectrl pu_framectrl[2];
#define PU_FRAMECTRL_FS 0
#define PU_FRAMECTRL_USER 1
LIST_HEAD(, puffs_fctrl_io) pu_ios;
LIST_HEAD(, puffs_fctrl_io) pu_ios_rmlist;
struct kevent *pu_evs;
size_t pu_nfds;
Add puffs "frame buffers", which are an abstraction of the buffering and event handling mechanisms required in file servers with blocking I/O backends. puffs_framebuf is built on the concept of puffs_cc and uses those to multiplex execution where needed. File systems are required to implement three methods: * read frame * write frame * compare if frame is a response to the given one Memory management is provided by puffs_framebuf, but the file systems must still, of course, interpret the protocol and do e.g. byte order conversion. As always, puffs_framebuf is work in progress. Current users are mount_psshfs and mount_9p.
2007-05-05 19:48:18 +04:00
Step 3 and currently final step of a more general purpose event loop: support removal and addition of i/o file descriptors on the fly. * detect closed file descriptors * automatically free waiters of a dead file descriptor * give the file server the possibility to specify a callback which notifies of a dead file descriptor * move loop function to be a property of the mainloop instead of framebuf (doesn't change effective behaviour) * add the possibility to configure a timespec parameter which attempts to call the loop function periodically * move the event loop functions from the puffs_framebuf namespace to puffs_framev to differential between pure memory management functions
2007-05-15 17:44:46 +04:00
puffs_ml_loop_fn pu_ml_lfn;
struct timespec pu_ml_timeout;
struct timespec *pu_ml_timep;
Don't float puffs_kargs needlessly around after mount, saves a couple k of memory (and there was much rejoycing!)
2007-07-19 16:52:28 +04:00
struct puffs_kargs *pu_kargp;
Send a response message for flush operations from the kernel instead of abusing the return value of write(2).
2007-12-05 15:11:56 +03:00
uint64_t pu_nextreq;
Step 3 and currently final step of a more general purpose event loop: support removal and addition of i/o file descriptors on the fly. * detect closed file descriptors * automatically free waiters of a dead file descriptor * give the file server the possibility to specify a callback which notifies of a dead file descriptor * move loop function to be a property of the mainloop instead of framebuf (doesn't change effective behaviour) * add the possibility to configure a timespec parameter which attempts to call the loop function periodically * move the event loop functions from the puffs_framebuf namespace to puffs_framev to differential between pure memory management functions
2007-05-15 17:44:46 +04:00
void *pu_privdata;
Hide struct puffs_usermount from the rest of the world and provide accessors for interesting data in it. Namely, you can now get pu->pu_privdata with puffs_getspecific(), pu->pu_pn_root with puffs_set/getroot() and pu->pu_maxreqlen with puffs_getmaxreqlen().
2007-04-12 19:09:00 +04:00
};
checkpoint some experimental work-in-progress, namely: Add support for having multiple outstanding operations. This is done by exposing enough interfaces so that it is convenient to have the main event loop in the implementation itself and by providing a continuation framework for convinient blocking and rescheduling. works fine, but will undergo further cleanup & development
2006-12-29 18:28:11 +03:00
/* call context */
Implement lazy contexts for file systems using puffs_mainloop(). Previously each request was executed on its own callcontext and switched to every time the request was being processed. Now requests borrow the mainloop context and switch only if/when they yield. This takes two context switches away from a file system request bringing down the typical amounts 2->0 (e.g. dtfs) and 4->2 (e.g. psshfs). The interfaces for manually executing requests changed a bit: puffs_dispatch_create() and puffs_dispatch_exec() must now be used. They are not tested, as nothing in-tree wants them and I doubt anyone else is really interested in them either. Also do some misc code cleanup related to execution contexts. The "work-in-progress checkpoint" committed over a year ago was starting to look slightly weed-infested.
2008-01-28 21:35:49 +03:00
struct puffs_cc;
typedef void (*puffs_ccfunc)(struct puffs_cc *);
checkpoint some experimental work-in-progress, namely: Add support for having multiple outstanding operations. This is done by exposing enough interfaces so that it is convenient to have the main event loop in the implementation itself and by providing a continuation framework for convinient blocking and rescheduling. works fine, but will undergo further cleanup & development
2006-12-29 18:28:11 +03:00
struct puffs_cc {
struct puffs_usermount *pcc_pu;
Part 3/n of extensive changes to message handling: Get rid of the original puffs_req(3) framework and use puffs_framebuf(3) instead for file system requests. It has the advantage of being suitable for transporting a distributed message passing protocol and therefore us being able to run the file system server on any host. Ok, puffs is not quite here yet: libpuffs needs to grow request routing support and the message contents need to be munged into a host independent format. Saying which format would be telling, but it might begin with an X, end in an L and have the 13th character in the middle. Keep an eye out for the sequels: Parts 3+m/n.
2007-12-05 00:24:10 +03:00
struct puffs_framebuf *pcc_pb;
checkpoint some experimental work-in-progress, namely: Add support for having multiple outstanding operations. This is done by exposing enough interfaces so that it is convenient to have the main event loop in the implementation itself and by providing a continuation framework for convinient blocking and rescheduling. works fine, but will undergo further cleanup & development
2006-12-29 18:28:11 +03:00
Implement lazy contexts for file systems using puffs_mainloop(). Previously each request was executed on its own callcontext and switched to every time the request was being processed. Now requests borrow the mainloop context and switch only if/when they yield. This takes two context switches away from a file system request bringing down the typical amounts 2->0 (e.g. dtfs) and 4->2 (e.g. psshfs). The interfaces for manually executing requests changed a bit: puffs_dispatch_create() and puffs_dispatch_exec() must now be used. They are not tested, as nothing in-tree wants them and I doubt anyone else is really interested in them either. Also do some misc code cleanup related to execution contexts. The "work-in-progress checkpoint" committed over a year ago was starting to look slightly weed-infested.
2008-01-28 21:35:49 +03:00
/* real cc */
union {
struct {
ucontext_t uc; /* "continue" */
ucontext_t uc_ret; /* "yield" */
} real;
struct {
puffs_ccfunc func;
void *farg;
} fake;
} pcc_u;
checkpoint some experimental work-in-progress, namely: Add support for having multiple outstanding operations. This is done by exposing enough interfaces so that it is convenient to have the main event loop in the implementation itself and by providing a continuation framework for convinient blocking and rescheduling. works fine, but will undergo further cleanup & development
2006-12-29 18:28:11 +03:00
Always provide caller information from the kernel based on curlwp. (but don't deprecate the old puffs_cid interface just yet)
2007-10-21 18:28:05 +04:00
pid_t pcc_pid;
lwpid_t pcc_lid;
checkpoint some experimental work-in-progress, namely: Add support for having multiple outstanding operations. This is done by exposing enough interfaces so that it is convenient to have the main event loop in the implementation itself and by providing a continuation framework for convinient blocking and rescheduling. works fine, but will undergo further cleanup & development
2006-12-29 18:28:11 +03:00
int pcc_flags;
Cache a number of execution contexts instead of re-initializing them every time. Speeds up pure in-memory file systems such as sysctlfs or dtfs quite a bit. For actual I/O-workhorses the result is of course less tasty.
2008-01-17 00:29:59 +03:00
TAILQ_ENTRY(puffs_cc) pcc_schedent;
LIST_ENTRY(puffs_cc) pcc_rope;
checkpoint some experimental work-in-progress, namely: Add support for having multiple outstanding operations. This is done by exposing enough interfaces so that it is convenient to have the main event loop in the implementation itself and by providing a continuation framework for convinient blocking and rescheduling. works fine, but will undergo further cleanup & development
2006-12-29 18:28:11 +03:00
};
Implement lazy contexts for file systems using puffs_mainloop(). Previously each request was executed on its own callcontext and switched to every time the request was being processed. Now requests borrow the mainloop context and switch only if/when they yield. This takes two context switches away from a file system request bringing down the typical amounts 2->0 (e.g. dtfs) and 4->2 (e.g. psshfs). The interfaces for manually executing requests changed a bit: puffs_dispatch_create() and puffs_dispatch_exec() must now be used. They are not tested, as nothing in-tree wants them and I doubt anyone else is really interested in them either. Also do some misc code cleanup related to execution contexts. The "work-in-progress checkpoint" committed over a year ago was starting to look slightly weed-infested.
2008-01-28 21:35:49 +03:00
#define pcc_uc pcc_u.real.uc
#define pcc_uc_ret pcc_u.real.uc_ret
#define pcc_func pcc_u.fake.func
#define pcc_farg pcc_u.fake.farg
#define PCC_DONE 0x01
#define PCC_BORROWED 0x02
#define PCC_HASCALLER 0x04
#define PCC_MLCONT 0x08
checkpoint some experimental work-in-progress, namely: Add support for having multiple outstanding operations. This is done by exposing enough interfaces so that it is convenient to have the main event loop in the implementation itself and by providing a continuation framework for convinient blocking and rescheduling. works fine, but will undergo further cleanup & development
2006-12-29 18:28:11 +03:00
Instead of requesting various pieces of information from node-creating methods using "please fill me"-pointers, pass "struct puffs_newinfo *" and provide methods to fill in new node info.
2007-07-01 22:39:39 +04:00
struct puffs_newinfo {
void **pni_cookie;
enum vtype *pni_vtype;
voff_t *pni_size;
dev_t *pni_rdev;
};
make puffs_cred an opaque type
2007-07-01 19:30:15 +04:00
#define PUFFS_MAKEKCRED(to, from) \
/*LINTED: tnilxnaht, the cast is ok */ \
cast to void * instead of actual (albeit incomplete) type to silence gcc about type punning with -fstrict-alias
2007-07-01 21:42:19 +04:00
const struct puffs_kcred *to = (const void *)from
make puffs_cred an opaque type
2007-07-01 19:30:15 +04:00
#define PUFFS_MAKECRED(to, from) \
/*LINTED: tnilxnaht, the cast is ok */ \
cast to void * instead of actual (albeit incomplete) type to silence gcc about type punning with -fstrict-alias
2007-07-01 21:42:19 +04:00
const struct puffs_cred *to = (const void *)from
make puffs_cred an opaque type
2007-07-01 19:30:15 +04:00
#define PUFFS_KCREDTOCRED(to, from) \
/*LINTED: tnilxnaht, the cast is ok */ \
cast to void * instead of actual (albeit incomplete) type to silence gcc about type punning with -fstrict-alias
2007-07-01 21:42:19 +04:00
to = (void *)from
Step 2 of general-purpose eventloop: get rid of puffs_framebuf_eventloop(). puffs_mainloop() now handles that functionality as well.
2007-05-12 01:27:13 +04:00
checkpoint some experimental work-in-progress, namely: Add support for having multiple outstanding operations. This is done by exposing enough interfaces so that it is convenient to have the main event loop in the implementation itself and by providing a continuation framework for convinient blocking and rescheduling. works fine, but will undergo further cleanup & development
2006-12-29 18:28:11 +03:00
__BEGIN_DECLS
Implement lazy contexts for file systems using puffs_mainloop(). Previously each request was executed on its own callcontext and switched to every time the request was being processed. Now requests borrow the mainloop context and switch only if/when they yield. This takes two context switches away from a file system request bringing down the typical amounts 2->0 (e.g. dtfs) and 4->2 (e.g. psshfs). The interfaces for manually executing requests changed a bit: puffs_dispatch_create() and puffs_dispatch_exec() must now be used. They are not tested, as nothing in-tree wants them and I doubt anyone else is really interested in them either. Also do some misc code cleanup related to execution contexts. The "work-in-progress checkpoint" committed over a year ago was starting to look slightly weed-infested.
2008-01-28 21:35:49 +03:00
void puffs__framev_input(struct puffs_usermount *, struct puffs_framectrl *,
Part 3/n of extensive changes to message handling: Get rid of the original puffs_req(3) framework and use puffs_framebuf(3) instead for file system requests. It has the advantage of being suitable for transporting a distributed message passing protocol and therefore us being able to run the file system server on any host. Ok, puffs is not quite here yet: libpuffs needs to grow request routing support and the message contents need to be munged into a host independent format. Saying which format would be telling, but it might begin with an X, end in an L and have the 13th character in the middle. Keep an eye out for the sequels: Parts 3+m/n.
2007-12-05 00:24:10 +03:00
struct puffs_fctrl_io *);
Implement lazy contexts for file systems using puffs_mainloop(). Previously each request was executed on its own callcontext and switched to every time the request was being processed. Now requests borrow the mainloop context and switch only if/when they yield. This takes two context switches away from a file system request bringing down the typical amounts 2->0 (e.g. dtfs) and 4->2 (e.g. psshfs). The interfaces for manually executing requests changed a bit: puffs_dispatch_create() and puffs_dispatch_exec() must now be used. They are not tested, as nothing in-tree wants them and I doubt anyone else is really interested in them either. Also do some misc code cleanup related to execution contexts. The "work-in-progress checkpoint" committed over a year ago was starting to look slightly weed-infested.
2008-01-28 21:35:49 +03:00
int puffs__framev_output(struct puffs_usermount *, struct puffs_framectrl*,
Part 3/n of extensive changes to message handling: Get rid of the original puffs_req(3) framework and use puffs_framebuf(3) instead for file system requests. It has the advantage of being suitable for transporting a distributed message passing protocol and therefore us being able to run the file system server on any host. Ok, puffs is not quite here yet: libpuffs needs to grow request routing support and the message contents need to be munged into a host independent format. Saying which format would be telling, but it might begin with an X, end in an L and have the 13th character in the middle. Keep an eye out for the sequels: Parts 3+m/n.
2007-12-05 00:24:10 +03:00
struct puffs_fctrl_io *);
Implement lazy contexts for file systems using puffs_mainloop(). Previously each request was executed on its own callcontext and switched to every time the request was being processed. Now requests borrow the mainloop context and switch only if/when they yield. This takes two context switches away from a file system request bringing down the typical amounts 2->0 (e.g. dtfs) and 4->2 (e.g. psshfs). The interfaces for manually executing requests changed a bit: puffs_dispatch_create() and puffs_dispatch_exec() must now be used. They are not tested, as nothing in-tree wants them and I doubt anyone else is really interested in them either. Also do some misc code cleanup related to execution contexts. The "work-in-progress checkpoint" committed over a year ago was starting to look slightly weed-infested.
2008-01-28 21:35:49 +03:00
void puffs__framev_exit(struct puffs_usermount *);
void puffs__framev_readclose(struct puffs_usermount *,
Step 3 and currently final step of a more general purpose event loop: support removal and addition of i/o file descriptors on the fly. * detect closed file descriptors * automatically free waiters of a dead file descriptor * give the file server the possibility to specify a callback which notifies of a dead file descriptor * move loop function to be a property of the mainloop instead of framebuf (doesn't change effective behaviour) * add the possibility to configure a timespec parameter which attempts to call the loop function periodically * move the event loop functions from the puffs_framebuf namespace to puffs_framev to differential between pure memory management functions
2007-05-15 17:44:46 +04:00
struct puffs_fctrl_io *, int);
Implement lazy contexts for file systems using puffs_mainloop(). Previously each request was executed on its own callcontext and switched to every time the request was being processed. Now requests borrow the mainloop context and switch only if/when they yield. This takes two context switches away from a file system request bringing down the typical amounts 2->0 (e.g. dtfs) and 4->2 (e.g. psshfs). The interfaces for manually executing requests changed a bit: puffs_dispatch_create() and puffs_dispatch_exec() must now be used. They are not tested, as nothing in-tree wants them and I doubt anyone else is really interested in them either. Also do some misc code cleanup related to execution contexts. The "work-in-progress checkpoint" committed over a year ago was starting to look slightly weed-infested.
2008-01-28 21:35:49 +03:00
void puffs__framev_writeclose(struct puffs_usermount *,
Step 3 and currently final step of a more general purpose event loop: support removal and addition of i/o file descriptors on the fly. * detect closed file descriptors * automatically free waiters of a dead file descriptor * give the file server the possibility to specify a callback which notifies of a dead file descriptor * move loop function to be a property of the mainloop instead of framebuf (doesn't change effective behaviour) * add the possibility to configure a timespec parameter which attempts to call the loop function periodically * move the event loop functions from the puffs_framebuf namespace to puffs_framev to differential between pure memory management functions
2007-05-15 17:44:46 +04:00
struct puffs_fctrl_io *, int);
Implement lazy contexts for file systems using puffs_mainloop(). Previously each request was executed on its own callcontext and switched to every time the request was being processed. Now requests borrow the mainloop context and switch only if/when they yield. This takes two context switches away from a file system request bringing down the typical amounts 2->0 (e.g. dtfs) and 4->2 (e.g. psshfs). The interfaces for manually executing requests changed a bit: puffs_dispatch_create() and puffs_dispatch_exec() must now be used. They are not tested, as nothing in-tree wants them and I doubt anyone else is really interested in them either. Also do some misc code cleanup related to execution contexts. The "work-in-progress checkpoint" committed over a year ago was starting to look slightly weed-infested.
2008-01-28 21:35:49 +03:00
void puffs__framev_notify(struct puffs_fctrl_io *, int);
Part 3/n of extensive changes to message handling: Get rid of the original puffs_req(3) framework and use puffs_framebuf(3) instead for file system requests. It has the advantage of being suitable for transporting a distributed message passing protocol and therefore us being able to run the file system server on any host. Ok, puffs is not quite here yet: libpuffs needs to grow request routing support and the message contents need to be munged into a host independent format. Saying which format would be telling, but it might begin with an X, end in an L and have the 13th character in the middle. Keep an eye out for the sequels: Parts 3+m/n.
2007-12-05 00:24:10 +03:00
void *puffs__framebuf_getdataptr(struct puffs_framebuf *);
int puffs__framev_addfd_ctrl(struct puffs_usermount *, int, int,
struct puffs_framectrl *);
void puffs__framebuf_moveinfo(struct puffs_framebuf *,
struct puffs_framebuf *);
Step 3 and currently final step of a more general purpose event loop: support removal and addition of i/o file descriptors on the fly. * detect closed file descriptors * automatically free waiters of a dead file descriptor * give the file server the possibility to specify a callback which notifies of a dead file descriptor * move loop function to be a property of the mainloop instead of framebuf (doesn't change effective behaviour) * add the possibility to configure a timespec parameter which attempts to call the loop function periodically * move the event loop functions from the puffs_framebuf namespace to puffs_framev to differential between pure memory management functions
2007-05-15 17:44:46 +04:00
Implement lazy contexts for file systems using puffs_mainloop(). Previously each request was executed on its own callcontext and switched to every time the request was being processed. Now requests borrow the mainloop context and switch only if/when they yield. This takes two context switches away from a file system request bringing down the typical amounts 2->0 (e.g. dtfs) and 4->2 (e.g. psshfs). The interfaces for manually executing requests changed a bit: puffs_dispatch_create() and puffs_dispatch_exec() must now be used. They are not tested, as nothing in-tree wants them and I doubt anyone else is really interested in them either. Also do some misc code cleanup related to execution contexts. The "work-in-progress checkpoint" committed over a year ago was starting to look slightly weed-infested.
2008-01-28 21:35:49 +03:00
void puffs__theloop(struct puffs_cc *);
void puffs__ml_dispatch(struct puffs_usermount *, struct puffs_framebuf *);
int puffs__cc_create(struct puffs_usermount *, puffs_ccfunc,
struct puffs_cc **);
void puffs__cc_cont(struct puffs_cc *);
void puffs__cc_destroy(struct puffs_cc *, int);
void puffs__cc_setcaller(struct puffs_cc *, pid_t, lwpid_t);
void puffs__goto(struct puffs_cc *);
int puffs__fsframe_read(struct puffs_usermount *, struct puffs_framebuf *,
int, int *);
int puffs__fsframe_write(struct puffs_usermount *, struct puffs_framebuf *,
int, int *);
int puffs__fsframe_cmp(struct puffs_usermount *, struct puffs_framebuf *,
struct puffs_framebuf *, int *);
void puffs__fsframe_gotframe(struct puffs_usermount *,
struct puffs_framebuf *);
Part 3/n of extensive changes to message handling: Get rid of the original puffs_req(3) framework and use puffs_framebuf(3) instead for file system requests. It has the advantage of being suitable for transporting a distributed message passing protocol and therefore us being able to run the file system server on any host. Ok, puffs is not quite here yet: libpuffs needs to grow request routing support and the message contents need to be munged into a host independent format. Saying which format would be telling, but it might begin with an X, end in an L and have the 13th character in the middle. Keep an eye out for the sequels: Parts 3+m/n.
2007-12-05 00:24:10 +03:00
Send a response message for flush operations from the kernel instead of abusing the return value of write(2).
2007-12-05 15:11:56 +03:00
uint64_t puffs__nextreq(struct puffs_usermount *pu);
checkpoint some experimental work-in-progress, namely: Add support for having multiple outstanding operations. This is done by exposing enough interfaces so that it is convenient to have the main event loop in the implementation itself and by providing a continuation framework for convinient blocking and rescheduling. works fine, but will undergo further cleanup & development
2006-12-29 18:28:11 +03:00
__END_DECLS
outline & export code for interfacing with kernel GET/PUT requests
2006-12-08 02:15:20 +03:00
#endif /* _PUFFS_PRIVATE_H_ */