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

721 lines
28 KiB
C
Raw Normal View History

Fix regression that has been introduced when the lookup/reclaim race condition was addressed in libpuffs by counting lookups. The fix assumes that cookies map to struct puffs_cookie, which has not been documented as a requirement for filesystems using libpuffs. As an example, we got burnt by this assumption in libp2k (kern/46734), and we fixed bit by actually mapping libp2k cookies to struct puffs_node. It is unlikely, but there may be third party filesystems that use cookies unmapped to struct puffs_node, and they were left broken for now. - we introduce a puffs_init() flag PUFFS_FLAG_PNCOOKIE that let filesystems inform libpuffs that they map cookies to struct puffs_node. Is that flag is used, the lookup/reclaim race condition fix is enabled. We enable the flag for libp2k. - filesystems that use puffs_pn_new() obviouslty use struct puffs_node and gain PUFFS_FLAG_PNCOOKIE automatically even if they did not specify it in puffs_init(). This include all our PUFFS filesystem in-tree except libp2k. - for filesystems not willing to use struct puffs_node, we introduce a reclaim2 vnop, which is reclaim with an additionnal lookup count argument. This vnop let the filesystem implement the lookup/reclaim race fix on its own.
2012-08-16 13:25:43 +04:00
/* $NetBSD: puffs.h,v 1.124 2012/08/16 09:25:44 manu Exp $ */
add libpuffs - the userspace programming interface for puffs 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:52:21 +04:00
/*
Introduce PUFFS_FLAG_HASHPATH, which for PUFFS_FLAG_BUILDPATH file servers creates a hash of the node's path into po->po_hash to avoid a full pathcmp every time.
2007-05-01 19:58:00 +04:00
* Copyright (c) 2005, 2006, 2007 Antti Kantee. All Rights Reserved.
add libpuffs - the userspace programming interface for puffs 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:52:21 +04:00
*
* 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.
*/
rototill the operation callbacks: unify the ops under struct puffs_ops and namespace them
2006-12-07 13:53:21 +03:00
#ifndef _PUFFS_H_
#define _PUFFS_H_
add libpuffs - the userspace programming interface for puffs 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:52:21 +04:00
#include <sys/param.h>
* get rid of the holy kernel-given ISDOTDOT, and instead define a macro which does strcmp against ".." and (the untranslated) componentname * make PUFFS_FLAG_BUILDPATH build paths also if dotdot is the case, and adapt the regular path objects to this * make nullfs lookup readable because we can now get rid of dotdot processing there
2007-02-15 15:51:45 +03:00
#include <sys/types.h>
add libpuffs - the userspace programming interface for puffs 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:52:21 +04:00
#include <sys/mount.h>
Nuke PUFFSLOOKUP_FOO and move to NAMEI_FOO
2007-08-15 18:19:19 +04:00
#include <sys/namei.h>
Add preliminary code for a nullfs layer, which can be used to mount a directory hierarchy to another point, just like with the kernel nullfs. This is not really a layering scheme yet, but it should evolve into one. Currently it can just be used to do 1:1 mapping.
2007-01-11 04:01:55 +03:00
#include <sys/stat.h>
add libpuffs - the userspace programming interface for puffs 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:52:21 +04:00
#include <sys/statvfs.h>
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
#include <sys/time.h>
add libpuffs - the userspace programming interface for puffs 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:52:21 +04:00
#include <sys/vnode.h>
#include <fs/puffs/puffs_msgif.h>
* get rid of the mount callback; it's no great surprise to the server that it needs to mount the file system backend if it wants to call mount * provide some options for getmntopts(), assume that callers will parse command line (or fstab) args * reorganize the puffs_cc interface just a bit, preparing for a bigger revamp later
2007-01-06 21:22:09 +03:00
#include <mntopts.h>
* Change type of boolean functions to, well, boolean instead of int. * add puffs_cid_isequal() which can be used to test if the two caller id's refer to the same process/lwp.
2007-10-18 17:48:04 +04:00
#include <stdbool.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 <string.h>
/* forwards */
struct puffs_cc;
struct puffs_getreq;
make puffs_cred an opaque type
2007-07-01 19:30:15 +04:00
struct puffs_cred;
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;
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
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
/* paths */
struct puffs_pathobj {
Introduce PUFFS_FLAG_HASHPATH, which for PUFFS_FLAG_BUILDPATH file servers creates a hash of the node's path into po->po_hash to avoid a full pathcmp every time.
2007-05-01 19:58:00 +04:00
void *po_path;
size_t po_len;
uint32_t po_hash;
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
};
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
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
/* for prefix rename */
struct puffs_pathinfo {
struct puffs_pathobj *pi_old;
struct puffs_pathobj *pi_new;
};
initial support for cacheops
2007-03-20 13:22:22 +03:00
/* describes one segment cached in the kernel */
struct puffs_kcache {
off_t pkc_start;
off_t pkc_end;
LIST_ENTRY(puffs_kcache) pkc_entries;
};
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
/* XXX: might disappear from here into a private header */
struct puffs_node {
off_t pn_size;
Introduce puffs_pn_remove() to signal that a node has been deleted and destroyed, but not yet reclaimed. This prevents puffs_pn_nodewalk() from returning stale entries. Make nullfs use this (some file systems are a bit too happy with recycling inode numbers).
2007-06-24 21:55:07 +04:00
int pn_flags;
- Improve PUFFS_KFLAG_CACHE_FS_TTL by reclaiming older inactive nodes. The normal kernel behavior is to retain inactive nodes in the freelist until it runs out of vnodes. This has some merit for local filesystems, where the cost of an allocation is about the same as the cost of a lookup. But that situation is not true for distributed filesystems. On the other hand, keeping inactive nodes for a long time hold memory in the file server process, and when the kernel runs out of vnodes, it produce reclaim avalanches that increase lattency for other operations. We do not reclaim inactive vnodes immediatly either, as they may be looked up again shortly. Instead we introduce a grace time and we reclaim nodes that have been inactive beyond the grace time. - Fix lookup/reclaim race condition. The above improvement undercovered a race condition between lookup and reclaim. If we reclaimed a vnode associated with a userland cookie while a lookup returning that same cookiewas inprogress, then the kernel ends up with a vnode associated with a cookie that has been reclaimed in userland. Next operation on the cookie will crash (or at least confuse) the filesystem. We fix this by introducing a lookup count in kernel and userland. On reclaim, the kernel sends the count, which enable userland to detect situation where it initiated a lookup that is not completed in kernel. In such a situation, the reclaim must be ignored, as the node is about to be looked up again.
2012-07-21 09:17:10 +04:00
int pn_nlookup;
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
struct vattr pn_va;
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
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
void *pn_data; /* private data */
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
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
struct puffs_pathobj pn_po; /* PUFFS_FLAG_BUILDPATH */
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
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
struct puffs_usermount *pn_mnt;
LIST_ENTRY(puffs_node) pn_entries;
initial support for cacheops
2007-03-20 13:22:22 +03:00
LIST_HEAD(,puffs_kcache)pn_cacheinfo; /* PUFFS_KFLAG_CACHE */
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
};
Introduce puffs_pn_remove() to signal that a node has been deleted and destroyed, but not yet reclaimed. This prevents puffs_pn_nodewalk() from returning stale entries. Make nullfs use this (some file systems are a bit too happy with recycling inode numbers).
2007-06-24 21:55:07 +04:00
#define PUFFS_NODE_REMOVED 0x01 /* not on entry list */
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_usermount;
add libpuffs - the userspace programming interface for puffs 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:52:21 +04:00
/*
* megaXXX: these are values from inside _KERNEL
* need to work on the translation for ALL the necessary values.
*/
#define PUFFS_VNOVAL (-1)
add IO_NDELAY
2007-07-09 13:28:48 +04:00
#define PUFFS_IO_APPEND 0x020
#define PUFFS_IO_NDELAY 0x100
implement counterpart of vaccess()
2007-03-20 21:28:08 +03:00
#define PUFFS_VEXEC 01
#define PUFFS_VWRITE 02
#define PUFFS_VREAD 04
add libpuffs - the userspace programming interface for puffs 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:52:21 +04:00
implement fsync
2007-01-11 20:48:21 +03:00
#define PUFFS_FSYNC_DATAONLY 0x0002
#define PUFFS_FSYNC_CACHE 0x0100
Pass the FAF flag to handlers: - setattr_ttl is updated to add a flag argument. Since it was not present in a previous release, we can change its API - write2 is introduced, this is write with an extra flag for FAF. - fsync already has the FAF information in a flag and needs no change - for other operations, FAF is unconditional
2012-06-27 17:25:23 +04:00
/*
* xflags for setattr_ttl and write2
*/
#define PUFFS_SETATTR_FAF 0x1
#define PUFFS_WRITE_FAF 0x1
Add a flag to VOP_LISTEXTATTR(9) so that the vnode interface can tell the filesystem in which format extended attribute shall be listed. There are currently two formats: - NUL-terminated strings, used for listxattr(2), this is the default. - one byte length-pprefixed, non NUL-terminated strings, used for extattr_list_file(2), which is obtanined by setting the EXTATTR_LIST_PREFIXLEN flag to VOP_LISTEXTATTR(9) This approach avoid the need for converting the list back and forth, except in libperfuse, since FUSE uses NUL-terminated strings, and the kernel may have requested EXTATTR_LIST_PREFIXLEN.
2011-07-04 12:07:29 +04:00
#define PUFFS_EXTATTR_LIST_LENPREFIX 1
add libpuffs - the userspace programming interface for puffs 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:52:21 +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
* Magic constants
add libpuffs - the userspace programming interface for puffs 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:52:21 +04:00
*/
mmap stacks, makes it possible to align them
2007-10-26 17:51:14 +04:00
#define PUFFS_CC_STACKSHIFT_DEFAULT 18
add libpuffs - the userspace programming interface for puffs 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:52:21 +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
struct puffs_cn {
struct puffs_kcn *pcn_pkcnp; /* kernel input */
make puffs_cred an opaque type
2007-07-01 19:30:15 +04:00
struct puffs_cred *pcn_cred; /* cred used for lookup */
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
struct puffs_pathobj pcn_po_full; /* PUFFS_FLAG_BUILDPATH */
add libpuffs - the userspace programming interface for puffs 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:52:21 +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
#define pcn_nameiop pcn_pkcnp->pkcn_nameiop
#define pcn_flags pcn_pkcnp->pkcn_flags
#define pcn_name pcn_pkcnp->pkcn_name
#define pcn_namelen pcn_pkcnp->pkcn_namelen
Get rid of the "int *refs" parameter to inactive: the same can be accomplished now with puffs_setbacks.
2007-07-02 14:24:17 +04:00
#define pcn_consume pcn_pkcnp->pkcn_consume
add libpuffs - the userspace programming interface for puffs 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:52:21 +04:00
* get rid of the mount callback; it's no great surprise to the server that it needs to mount the file system backend if it wants to call mount * provide some options for getmntopts(), assume that callers will parse command line (or fstab) args * reorganize the puffs_cc interface just a bit, preparing for a bigger revamp later
2007-01-06 21:22:09 +03:00
/*
* Puffs options to mount
*/
/* kernel */
PUFFS_KFLAG_NOCACHE became two, so introduce the command line options -o nonamecache and -o nopagecache and adapt file systems where necessary.
2007-06-25 02:18:38 +04:00
#define PUFFSMOPT_NAMECACHE { "namecache", 1, PUFFS_KFLAG_NOCACHE_NAME, 1 }
#define PUFFSMOPT_PAGECACHE { "pagecache", 1, PUFFS_KFLAG_NOCACHE_PAGE, 1 }
add option string for no attribute cache (foreseeing the odd event I might actually implement one some day)
2010-05-21 15:29:42 +04:00
#define PUFFSMOPT_ATTRCACHE { "attrcache", 1, PUFFS_KFLAG_NOCACHE_ATTR, 1 }
Actually, keep PUFFS_KFLAG_NOCACHE and -o cache around as shorthand to neither page- nor namecache.
2007-06-25 02:25:49 +04:00
#define PUFFSMOPT_CACHE { "cache", 1, PUFFS_KFLAG_NOCACHE, 1 }
* get rid of the mount callback; it's no great surprise to the server that it needs to mount the file system backend if it wants to call mount * provide some options for getmntopts(), assume that callers will parse command line (or fstab) args * reorganize the puffs_cc interface just a bit, preparing for a bigger revamp later
2007-01-06 21:22:09 +03:00
#define PUFFSMOPT_ALLOPS { "allops", 0, PUFFS_KFLAG_ALLOPS, 1 }
/* libpuffs */
#define PUFFSMOPT_DUMP { "dump", 0, PUFFS_FLAG_OPDUMP, 1 }
#define PUFFSMOPT_STD \
PUFFS_KFLAG_NOCACHE became two, so introduce the command line options -o nonamecache and -o nopagecache and adapt file systems where necessary.
2007-06-25 02:18:38 +04:00
PUFFSMOPT_NAMECACHE, \
PUFFSMOPT_PAGECACHE, \
add option string for no attribute cache (foreseeing the odd event I might actually implement one some day)
2010-05-21 15:29:42 +04:00
PUFFSMOPT_ATTRCACHE, \
Actually, keep PUFFS_KFLAG_NOCACHE and -o cache around as shorthand to neither page- nor namecache.
2007-06-25 02:25:49 +04:00
PUFFSMOPT_CACHE, \
* get rid of the mount callback; it's no great surprise to the server that it needs to mount the file system backend if it wants to call mount * provide some options for getmntopts(), assume that callers will parse command line (or fstab) args * reorganize the puffs_cc interface just a bit, preparing for a bigger revamp later
2007-01-06 21:22:09 +03:00
PUFFSMOPT_ALLOPS, \
PUFFSMOPT_DUMP
extern const struct mntopt puffsmopts[]; /* puffs.c */
add libpuffs - the userspace programming interface for puffs 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:52:21 +04:00
/* callbacks for operations */
rototill the operation callbacks: unify the ops under struct puffs_ops and namespace them
2006-12-07 13:53:21 +03:00
struct puffs_ops {
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
int (*puffs_fs_unmount)(struct puffs_usermount *, int);
int (*puffs_fs_statvfs)(struct puffs_usermount *, struct statvfs *);
int (*puffs_fs_sync)(struct puffs_usermount *, int,
Remove "puffs_cid" from the puffs interface following l-removal from the kernel vfs interfaces. puffs_cc_getcaller(pcc) can be used now should the same information be desired.
2007-11-27 14:31:17 +03:00
const struct puffs_cred *);
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
int (*puffs_fs_fhtonode)(struct puffs_usermount *, void *, size_t,
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 *);
Replace void * by puffs_cookie_t where appropriate. No functional change.
2008-08-12 23:44:39 +04:00
int (*puffs_fs_nodetofh)(struct puffs_usermount *, puffs_cookie_t,
* support nodetofh and fhtonode callbacks * use new signature of node_readdir
2007-04-12 01:04:51 +04:00
void *, size_t *);
* support extended attributes * bump major due to structure growth * add some spare space * remove ABI sillyness
2010-05-21 14:50:52 +04:00
int (*puffs_fs_extattrctl)(struct puffs_usermount *, int,
puffs_cookie_t, int, int, const char *);
add libpuffs - the userspace programming interface for puffs 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:52:21 +04:00
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
int (*puffs_node_lookup)(struct puffs_usermount *,
Replace void * by puffs_cookie_t where appropriate. No functional change.
2008-08-12 23:44:39 +04:00
puffs_cookie_t, struct puffs_newinfo *, const struct puffs_cn *);
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
int (*puffs_node_create)(struct puffs_usermount *,
Replace void * by puffs_cookie_t where appropriate. No functional change.
2008-08-12 23:44:39 +04:00
puffs_cookie_t, struct puffs_newinfo *, const struct puffs_cn *,
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
const struct vattr *);
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
int (*puffs_node_mknod)(struct puffs_usermount *,
Replace void * by puffs_cookie_t where appropriate. No functional change.
2008-08-12 23:44:39 +04:00
puffs_cookie_t, struct puffs_newinfo *, const struct puffs_cn *,
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
const struct vattr *);
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
int (*puffs_node_open)(struct puffs_usermount *,
Replace void * by puffs_cookie_t where appropriate. No functional change.
2008-08-12 23:44:39 +04:00
puffs_cookie_t, int, const struct puffs_cred *);
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
int (*puffs_node_close)(struct puffs_usermount *,
Replace void * by puffs_cookie_t where appropriate. No functional change.
2008-08-12 23:44:39 +04:00
puffs_cookie_t, int, const struct puffs_cred *);
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
int (*puffs_node_access)(struct puffs_usermount *,
Replace void * by puffs_cookie_t where appropriate. No functional change.
2008-08-12 23:44:39 +04:00
puffs_cookie_t, int, const struct puffs_cred *);
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
int (*puffs_node_getattr)(struct puffs_usermount *,
Replace void * by puffs_cookie_t where appropriate. No functional change.
2008-08-12 23:44:39 +04:00
puffs_cookie_t, struct vattr *, const struct puffs_cred *);
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
int (*puffs_node_setattr)(struct puffs_usermount *,
Replace void * by puffs_cookie_t where appropriate. No functional change.
2008-08-12 23:44:39 +04:00
puffs_cookie_t, const struct vattr *, const struct puffs_cred *);
int (*puffs_node_poll)(struct puffs_usermount *, puffs_cookie_t, int *);
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
int (*puffs_node_mmap)(struct puffs_usermount *,
Replace void * by puffs_cookie_t where appropriate. No functional change.
2008-08-12 23:44:39 +04:00
puffs_cookie_t, vm_prot_t, const struct puffs_cred *);
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
int (*puffs_node_fsync)(struct puffs_usermount *,
Replace void * by puffs_cookie_t where appropriate. No functional change.
2008-08-12 23:44:39 +04:00
puffs_cookie_t, const struct puffs_cred *, int, off_t, off_t);
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
int (*puffs_node_seek)(struct puffs_usermount *,
Replace void * by puffs_cookie_t where appropriate. No functional change.
2008-08-12 23:44:39 +04:00
puffs_cookie_t, off_t, off_t, const struct puffs_cred *);
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
int (*puffs_node_remove)(struct puffs_usermount *,
Replace void * by puffs_cookie_t where appropriate. No functional change.
2008-08-12 23:44:39 +04:00
puffs_cookie_t, puffs_cookie_t, const struct puffs_cn *);
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
int (*puffs_node_link)(struct puffs_usermount *,
Replace void * by puffs_cookie_t where appropriate. No functional change.
2008-08-12 23:44:39 +04:00
puffs_cookie_t, puffs_cookie_t, const struct puffs_cn *);
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
int (*puffs_node_rename)(struct puffs_usermount *,
Replace void * by puffs_cookie_t where appropriate. No functional change.
2008-08-12 23:44:39 +04:00
puffs_cookie_t, puffs_cookie_t, const struct puffs_cn *,
puffs_cookie_t, puffs_cookie_t, const struct puffs_cn *);
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
int (*puffs_node_mkdir)(struct puffs_usermount *,
Replace void * by puffs_cookie_t where appropriate. No functional change.
2008-08-12 23:44:39 +04:00
puffs_cookie_t, struct puffs_newinfo *, const struct puffs_cn *,
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
const struct vattr *);
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
int (*puffs_node_rmdir)(struct puffs_usermount *,
Replace void * by puffs_cookie_t where appropriate. No functional change.
2008-08-12 23:44:39 +04:00
puffs_cookie_t, puffs_cookie_t, const struct puffs_cn *);
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
int (*puffs_node_symlink)(struct puffs_usermount *,
Replace void * by puffs_cookie_t where appropriate. No functional change.
2008-08-12 23:44:39 +04:00
puffs_cookie_t, struct puffs_newinfo *, const struct puffs_cn *,
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
const struct vattr *,
add libpuffs - the userspace programming interface for puffs 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:52:21 +04:00
const char *);
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
int (*puffs_node_readdir)(struct puffs_usermount *,
Replace void * by puffs_cookie_t where appropriate. No functional change.
2008-08-12 23:44:39 +04:00
puffs_cookie_t, struct dirent *, off_t *, size_t *,
* support nodetofh and fhtonode callbacks * use new signature of node_readdir
2007-04-12 01:04:51 +04:00
const struct puffs_cred *, int *, off_t *, size_t *);
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
int (*puffs_node_readlink)(struct puffs_usermount *,
Replace void * by puffs_cookie_t where appropriate. No functional change.
2008-08-12 23:44:39 +04:00
puffs_cookie_t, const struct puffs_cred *, char *, size_t *);
int (*puffs_node_reclaim)(struct puffs_usermount *, puffs_cookie_t);
int (*puffs_node_inactive)(struct puffs_usermount *, puffs_cookie_t);
int (*puffs_node_print)(struct puffs_usermount *, puffs_cookie_t);
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
int (*puffs_node_pathconf)(struct puffs_usermount *,
Make retval argument for pathconf a register_t to match VOP_PATHCONF. This makes the size the same on 64bit archs. Don't bother bumping any version, since you'd have explicitly had to jump through some hoops to use pathconf before.
2010-06-07 15:21:31 +04:00
puffs_cookie_t, int, register_t *);
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
int (*puffs_node_advlock)(struct puffs_usermount *,
Replace void * by puffs_cookie_t where appropriate. No functional change.
2008-08-12 23:44:39 +04:00
puffs_cookie_t, void *, int, struct flock *, int);
int (*puffs_node_read)(struct puffs_usermount *, puffs_cookie_t,
add libpuffs - the userspace programming interface for puffs 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:52:21 +04:00
uint8_t *, off_t, size_t *, const struct puffs_cred *, int);
Replace void * by puffs_cookie_t where appropriate. No functional change.
2008-08-12 23:44:39 +04:00
int (*puffs_node_write)(struct puffs_usermount *, puffs_cookie_t,
add libpuffs - the userspace programming interface for puffs 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:52:21 +04:00
uint8_t *, off_t, size_t *, const struct puffs_cred *, int);
Dispatch puffs_node_abortop(). Note: We use the storage of puffs_cache_write from puffs_ops for this purpose. It's not issued by the kernel and hence currently unused, and this saves us from the trouble of bumping the lib major version.
2009-10-18 03:19:52 +04:00
int (*puffs_node_abortop)(struct puffs_usermount *, puffs_cookie_t,
const struct puffs_cn *);
* support extended attributes * bump major due to structure growth * add some spare space * remove ABI sillyness
2010-05-21 14:50:52 +04:00
int (*puffs_node_getextattr)(struct puffs_usermount *, puffs_cookie_t,
int, const char *, size_t *, uint8_t *, size_t *,
const struct puffs_cred *);
int (*puffs_node_setextattr)(struct puffs_usermount *, puffs_cookie_t,
int, const char *, uint8_t *, size_t *, const struct puffs_cred *);
int (*puffs_node_listextattr)(struct puffs_usermount *, puffs_cookie_t,
Add a flag to VOP_LISTEXTATTR(9) so that the vnode interface can tell the filesystem in which format extended attribute shall be listed. There are currently two formats: - NUL-terminated strings, used for listxattr(2), this is the default. - one byte length-pprefixed, non NUL-terminated strings, used for extattr_list_file(2), which is obtanined by setting the EXTATTR_LIST_PREFIXLEN flag to VOP_LISTEXTATTR(9) This approach avoid the need for converting the list back and forth, except in libperfuse, since FUSE uses NUL-terminated strings, and the kernel may have requested EXTATTR_LIST_PREFIXLEN.
2011-07-04 12:07:29 +04:00
int, size_t *, uint8_t *, size_t *, int, const struct puffs_cred *);
* support extended attributes * bump major due to structure growth * add some spare space * remove ABI sillyness
2010-05-21 14:50:52 +04:00
int (*puffs_node_deleteextattr)(struct puffs_usermount *,
puffs_cookie_t, int, const char *, const struct puffs_cred *);
- When using PUFFS_KFLAG_CACHE_FS_TTL, do not use puffs_node to carry attribute and TTL fora newly created node. Instead extend puffs_newinfo and add puffs_newinfo_setva() and puffs_newinfo_setttl() - Remove node_mk_common_final in libperfuse. It used to set uid/gid for a newly created vnode but has been made redundant along time ago since uid and gid are properly set in FUSE header. - In libperfuse, check for corner case where opc = 0 on INACTIVE and RECLAIM (how is it possible? Check for it to avoid a crash anyway) - In libperfuse, make sure we unlimit RLIMIT_AS and RLIMIT_DATA so that we do notrun out of memory because the kernel is lazy at reclaiming vnodes. - In libperfuse, cleanup style of perfuse_destroy_pn()
2012-04-18 04:57:21 +04:00
int (*puffs_node_getattr_ttl)(struct puffs_usermount *,
puffs_cookie_t, struct vattr *, const struct puffs_cred *,
struct timespec *);
int (*puffs_node_setattr_ttl)(struct puffs_usermount *,
puffs_cookie_t, struct vattr *, const struct puffs_cred *,
Pass the FAF flag to handlers: - setattr_ttl is updated to add a flag argument. Since it was not present in a previous release, we can change its API - write2 is introduced, this is write with an extra flag for FAF. - fsync already has the FAF information in a flag and needs no change - for other operations, FAF is unconditional
2012-06-27 17:25:23 +04:00
struct timespec *, int);
int (*puffs_node_write2)(struct puffs_usermount *, puffs_cookie_t,
uint8_t *, off_t, size_t *, const struct puffs_cred *, int, int);
Fix regression that has been introduced when the lookup/reclaim race condition was addressed in libpuffs by counting lookups. The fix assumes that cookies map to struct puffs_cookie, which has not been documented as a requirement for filesystems using libpuffs. As an example, we got burnt by this assumption in libp2k (kern/46734), and we fixed bit by actually mapping libp2k cookies to struct puffs_node. It is unlikely, but there may be third party filesystems that use cookies unmapped to struct puffs_node, and they were left broken for now. - we introduce a puffs_init() flag PUFFS_FLAG_PNCOOKIE that let filesystems inform libpuffs that they map cookies to struct puffs_node. Is that flag is used, the lookup/reclaim race condition fix is enabled. We enable the flag for libp2k. - filesystems that use puffs_pn_new() obviouslty use struct puffs_node and gain PUFFS_FLAG_PNCOOKIE automatically even if they did not specify it in puffs_init(). This include all our PUFFS filesystem in-tree except libp2k. - for filesystems not willing to use struct puffs_node, we introduce a reclaim2 vnop, which is reclaim with an additionnal lookup count argument. This vnop let the filesystem implement the lookup/reclaim race fix on its own.
2012-08-16 13:25:43 +04:00
int (*puffs_node_reclaim2)(struct puffs_usermount *,
puffs_cookie_t, int);
- When using PUFFS_KFLAG_CACHE_FS_TTL, do not use puffs_node to carry attribute and TTL fora newly created node. Instead extend puffs_newinfo and add puffs_newinfo_setva() and puffs_newinfo_setttl() - Remove node_mk_common_final in libperfuse. It used to set uid/gid for a newly created vnode but has been made redundant along time ago since uid and gid are properly set in FUSE header. - In libperfuse, check for corner case where opc = 0 on INACTIVE and RECLAIM (how is it possible? Check for it to avoid a crash anyway) - In libperfuse, make sure we unlimit RLIMIT_AS and RLIMIT_DATA so that we do notrun out of memory because the kernel is lazy at reclaiming vnodes. - In libperfuse, cleanup style of perfuse_destroy_pn()
2012-04-18 04:57:21 +04:00
Fix regression that has been introduced when the lookup/reclaim race condition was addressed in libpuffs by counting lookups. The fix assumes that cookies map to struct puffs_cookie, which has not been documented as a requirement for filesystems using libpuffs. As an example, we got burnt by this assumption in libp2k (kern/46734), and we fixed bit by actually mapping libp2k cookies to struct puffs_node. It is unlikely, but there may be third party filesystems that use cookies unmapped to struct puffs_node, and they were left broken for now. - we introduce a puffs_init() flag PUFFS_FLAG_PNCOOKIE that let filesystems inform libpuffs that they map cookies to struct puffs_node. Is that flag is used, the lookup/reclaim race condition fix is enabled. We enable the flag for libp2k. - filesystems that use puffs_pn_new() obviouslty use struct puffs_node and gain PUFFS_FLAG_PNCOOKIE automatically even if they did not specify it in puffs_init(). This include all our PUFFS filesystem in-tree except libp2k. - for filesystems not willing to use struct puffs_node, we introduce a reclaim2 vnop, which is reclaim with an additionnal lookup count argument. This vnop let the filesystem implement the lookup/reclaim race fix on its own.
2012-08-16 13:25:43 +04:00
void *puffs_ops_spare[28];
add libpuffs - the userspace programming interface for puffs 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:52:21 +04:00
};
* get rid of the holy kernel-given ISDOTDOT, and instead define a macro which does strcmp against ".." and (the untranslated) componentname * make PUFFS_FLAG_BUILDPATH build paths also if dotdot is the case, and adapt the regular path objects to this * make nullfs lookup readable because we can now get rid of dotdot processing there
2007-02-15 15:51:45 +03:00
typedef int (*pu_pathbuild_fn)(struct puffs_usermount *,
const struct puffs_pathobj *,
const struct puffs_pathobj *, size_t,
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
struct puffs_pathobj *);
typedef int (*pu_pathtransform_fn)(struct puffs_usermount *,
* get rid of the holy kernel-given ISDOTDOT, and instead define a macro which does strcmp against ".." and (the untranslated) componentname * make PUFFS_FLAG_BUILDPATH build paths also if dotdot is the case, and adapt the regular path objects to this * make nullfs lookup readable because we can now get rid of dotdot processing there
2007-02-15 15:51:45 +03:00
const struct puffs_pathobj *,
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
const struct puffs_cn *,
struct puffs_pathobj *);
typedef int (*pu_pathcmp_fn)(struct puffs_usermount *, struct puffs_pathobj *,
Introduce puffs_path_walkcmp(), which is to be called from nodewalk and compares the path of the node against the given pathobject. Also make comparison method take a flag to indicate if it should check if the second path is a true prefix of the first. plus some namespace cleanup
2007-02-15 20:04:46 +03:00
struct puffs_pathobj *, size_t, int);
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
typedef void (*pu_pathfree_fn)(struct puffs_usermount *,
struct puffs_pathobj *);
typedef int (*pu_namemod_fn)(struct puffs_usermount *,
struct puffs_pathobj *, struct puffs_cn *);
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
typedef void (*pu_errnotify_fn)(struct puffs_usermount *,
Replace void * by puffs_cookie_t where appropriate. No functional change.
2008-08-12 23:44:39 +04:00
uint8_t, int, const char *, puffs_cookie_t);
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
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
typedef void (*pu_prepost_fn)(struct puffs_usermount *);
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
Replace void * by puffs_cookie_t where appropriate. No functional change.
2008-08-12 23:44:39 +04:00
typedef struct puffs_node *(*pu_cmap_fn)(struct puffs_usermount *,
puffs_cookie_t);
Add a public interface for setting a cookie mapper.
2007-12-25 23:38:01 +03: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
enum {
Reflect kernel changes for supplying root node information in mount instead of puffs_start(). Get completely rid of puffs_start(), as everything it used to do is now handled by the mount routine. Introduce an optional pre-mount call puffs_setrootinfo() for setting non-default root node information. As the old puffs_mount() is now virtually useless, say byebye to it and rename the old puffs_domount() to puffs_mount(), but add a root cookie parameter to compensate for the late puffs_start().
2007-05-17 18:03:13 +04:00
PUFFS_STATE_BEFOREMOUNT, PUFFS_STATE_RUNNING,
Instead of keeping on adding parameters to puffs_mount(), make it only take the bare essentials, which currently means removing "maxreqlen" from the argument list (all current callers I'm aware of set it as 0 anyway). Introduce puffs_init(), which provides a context for setting various parameters and puffs_domount(), which can be used to mount the file system. Keep puffs_mount() as a shortcut for the above two for simple file systems. Bump development ABI version to 13. After all, it's Friday the 13th. Watch out! Bad things can happen on Friday the 13th. --No carrier--
2007-04-13 17:35:46 +04:00
PUFFS_STATE_UNMOUNTING, PUFFS_STATE_UNMOUNTED
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
};
* get rid of the mount callback; it's no great surprise to the server that it needs to mount the file system backend if it wants to call mount * provide some options for getmntopts(), assume that callers will parse command line (or fstab) args * reorganize the puffs_cc interface just a bit, preparing for a bigger revamp later
2007-01-06 21:22:09 +03:00
#define PUFFS_FLAG_BUILDPATH 0x80000000 /* node paths in pnode */
#define PUFFS_FLAG_OPDUMP 0x40000000 /* dump all operations */
Introduce PUFFS_FLAG_HASHPATH, which for PUFFS_FLAG_BUILDPATH file servers creates a hash of the node's path into po->po_hash to avoid a full pathcmp every time.
2007-05-01 19:58:00 +04:00
#define PUFFS_FLAG_HASHPATH 0x20000000 /* speedup: hash paths */
Fix regression that has been introduced when the lookup/reclaim race condition was addressed in libpuffs by counting lookups. The fix assumes that cookies map to struct puffs_cookie, which has not been documented as a requirement for filesystems using libpuffs. As an example, we got burnt by this assumption in libp2k (kern/46734), and we fixed bit by actually mapping libp2k cookies to struct puffs_node. It is unlikely, but there may be third party filesystems that use cookies unmapped to struct puffs_node, and they were left broken for now. - we introduce a puffs_init() flag PUFFS_FLAG_PNCOOKIE that let filesystems inform libpuffs that they map cookies to struct puffs_node. Is that flag is used, the lookup/reclaim race condition fix is enabled. We enable the flag for libp2k. - filesystems that use puffs_pn_new() obviouslty use struct puffs_node and gain PUFFS_FLAG_PNCOOKIE automatically even if they did not specify it in puffs_init(). This include all our PUFFS filesystem in-tree except libp2k. - for filesystems not willing to use struct puffs_node, we introduce a reclaim2 vnop, which is reclaim with an additionnal lookup count argument. This vnop let the filesystem implement the lookup/reclaim race fix on its own.
2012-08-16 13:25:43 +04:00
#define PUFFS_FLAG_PNCOOKIE 0x10000000 /* cookies are pnodes */
#define PUFFS_FLAG_MASK 0xf0000000
use more accurate flag masking
2007-04-22 22:02:44 +04:00
#define PUFFS_FLAG_KERN(a) ((a) & PUFFS_KFLAG_MASK)
#define PUFFS_FLAG_LIB(a) ((a) & PUFFS_FLAG_MASK)
add libpuffs - the userspace programming interface for puffs 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:52:21 +04:00
summon daemon(3) in mainloop unless the nodaemon flag is given
2006-11-30 08:37:48 +03:00
/* blocking mode argument */
* catch up with kernel changes * better error handling when mounting
2006-11-09 16:11:01 +03:00
#define PUFFSDEV_BLOCK 0
#define PUFFSDEV_NONBLOCK 1
Introduce PUFFS_STACKSIZE_MIN to avoid overloading 0 and getting a warning from the library when really wanting to say "just the minimum, please".
2008-01-14 16:57:26 +03:00
#define PUFFS_STACKSIZE_DEFAULT (1<<PUFFS_CC_STACKSHIFT_DEFAULT)
#define PUFFS_STACKSIZE_MIN ((size_t)-1)
add libpuffs - the userspace programming interface for puffs 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:52:21 +04:00
#define DENT_DOT 0
#define DENT_DOTDOT 1
#define DENT_ADJ(a) ((a)-2) /* nth request means dir's n-2th */
outline & export code for interfacing with kernel GET/PUT requests
2006-12-08 02:15:20 +03: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
* protos
outline & export code for interfacing with kernel GET/PUT requests
2006-12-08 02:15:20 +03:00
*/
rototill the operation callbacks: unify the ops under struct puffs_ops and namespace them
2006-12-07 13:53:21 +03:00
#define PUFFSOP_PROTOS(fsname) \
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
int fsname##_fs_unmount(struct puffs_usermount *, int); \
int fsname##_fs_statvfs(struct puffs_usermount *, \
struct statvfs *); \
int fsname##_fs_sync(struct puffs_usermount *, int, \
Remove "puffs_cid" from the puffs interface following l-removal from the kernel vfs interfaces. puffs_cc_getcaller(pcc) can be used now should the same information be desired.
2007-11-27 14:31:17 +03:00
const struct puffs_cred *cred); \
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
int fsname##_fs_fhtonode(struct puffs_usermount *, void *, \
size_t, struct puffs_newinfo *); \
Replace void * by puffs_cookie_t where appropriate. No functional change.
2008-08-12 23:44:39 +04:00
int fsname##_fs_nodetofh(struct puffs_usermount *, \
puffs_cookie_t, void *, size_t *); \
* support extended attributes * bump major due to structure growth * add some spare space * remove ABI sillyness
2010-05-21 14:50:52 +04:00
int fsname##_fs_extattrctl(struct puffs_usermount *, int, \
puffs_cookie_t, int, int, const char *); \
rototill the operation callbacks: unify the ops under struct puffs_ops and namespace them
2006-12-07 13:53:21 +03:00
\
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
int fsname##_node_lookup(struct puffs_usermount *, \
Replace void * by puffs_cookie_t where appropriate. No functional change.
2008-08-12 23:44:39 +04:00
puffs_cookie_t, struct puffs_newinfo *, \
const struct puffs_cn *); \
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
int fsname##_node_create(struct puffs_usermount *, \
Replace void * by puffs_cookie_t where appropriate. No functional change.
2008-08-12 23:44:39 +04:00
puffs_cookie_t, struct puffs_newinfo *, \
const struct puffs_cn *, const struct vattr *); \
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
int fsname##_node_mknod(struct puffs_usermount *, \
Replace void * by puffs_cookie_t where appropriate. No functional change.
2008-08-12 23:44:39 +04:00
puffs_cookie_t, struct puffs_newinfo *, \
const struct puffs_cn *, const struct vattr *); \
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
int fsname##_node_open(struct puffs_usermount *, \
Replace void * by puffs_cookie_t where appropriate. No functional change.
2008-08-12 23:44:39 +04:00
puffs_cookie_t, int, const struct puffs_cred *); \
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
int fsname##_node_close(struct puffs_usermount *, \
Replace void * by puffs_cookie_t where appropriate. No functional change.
2008-08-12 23:44:39 +04:00
puffs_cookie_t, int, const struct puffs_cred *); \
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
int fsname##_node_access(struct puffs_usermount *, \
Replace void * by puffs_cookie_t where appropriate. No functional change.
2008-08-12 23:44:39 +04:00
puffs_cookie_t, int, const struct puffs_cred *); \
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
int fsname##_node_getattr(struct puffs_usermount *, \
Replace void * by puffs_cookie_t where appropriate. No functional change.
2008-08-12 23:44:39 +04:00
puffs_cookie_t, struct vattr *, const struct puffs_cred *); \
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
int fsname##_node_setattr(struct puffs_usermount *, \
Replace void * by puffs_cookie_t where appropriate. No functional change.
2008-08-12 23:44:39 +04:00
puffs_cookie_t, const struct vattr *, \
const struct puffs_cred *); \
int fsname##_node_poll(struct puffs_usermount *, \
puffs_cookie_t, int *); \
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
int fsname##_node_mmap(struct puffs_usermount *, \
Replace void * by puffs_cookie_t where appropriate. No functional change.
2008-08-12 23:44:39 +04:00
puffs_cookie_t, vm_prot_t, const struct puffs_cred *); \
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
int fsname##_node_fsync(struct puffs_usermount *, \
Replace void * by puffs_cookie_t where appropriate. No functional change.
2008-08-12 23:44:39 +04:00
puffs_cookie_t, const struct puffs_cred *, int, \
off_t, off_t); \
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
int fsname##_node_seek(struct puffs_usermount *, \
Replace void * by puffs_cookie_t where appropriate. No functional change.
2008-08-12 23:44:39 +04:00
puffs_cookie_t, off_t, off_t, const struct puffs_cred *); \
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
int fsname##_node_remove(struct puffs_usermount *, \
Replace void * by puffs_cookie_t where appropriate. No functional change.
2008-08-12 23:44:39 +04:00
puffs_cookie_t, puffs_cookie_t, const struct puffs_cn *); \
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
int fsname##_node_link(struct puffs_usermount *, \
Replace void * by puffs_cookie_t where appropriate. No functional change.
2008-08-12 23:44:39 +04:00
puffs_cookie_t, puffs_cookie_t, const struct puffs_cn *); \
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
int fsname##_node_rename(struct puffs_usermount *, \
Replace void * by puffs_cookie_t where appropriate. No functional change.
2008-08-12 23:44:39 +04:00
puffs_cookie_t, puffs_cookie_t, const struct puffs_cn *, \
puffs_cookie_t, puffs_cookie_t, const struct puffs_cn *); \
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
int fsname##_node_mkdir(struct puffs_usermount *, \
Replace void * by puffs_cookie_t where appropriate. No functional change.
2008-08-12 23:44:39 +04:00
puffs_cookie_t, struct puffs_newinfo *, \
const struct puffs_cn *, const struct vattr *); \
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
int fsname##_node_rmdir(struct puffs_usermount *, \
Replace void * by puffs_cookie_t where appropriate. No functional change.
2008-08-12 23:44:39 +04:00
puffs_cookie_t, puffs_cookie_t, const struct puffs_cn *); \
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
int fsname##_node_symlink(struct puffs_usermount *, \
Replace void * by puffs_cookie_t where appropriate. No functional change.
2008-08-12 23:44:39 +04:00
puffs_cookie_t, struct puffs_newinfo *, \
const struct puffs_cn *, const struct vattr *, \
const char *); \
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
int fsname##_node_readdir(struct puffs_usermount *, \
Replace void * by puffs_cookie_t where appropriate. No functional change.
2008-08-12 23:44:39 +04:00
puffs_cookie_t, struct dirent *, off_t *, size_t *, \
* support nodetofh and fhtonode callbacks * use new signature of node_readdir
2007-04-12 01:04:51 +04:00
const struct puffs_cred *, int *, off_t *, size_t *); \
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
int fsname##_node_readlink(struct puffs_usermount *, \
Replace void * by puffs_cookie_t where appropriate. No functional change.
2008-08-12 23:44:39 +04:00
puffs_cookie_t, const struct puffs_cred *, char *, \
size_t *); \
int fsname##_node_reclaim(struct puffs_usermount *, \
puffs_cookie_t); \
int fsname##_node_inactive(struct puffs_usermount *, \
puffs_cookie_t); \
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
int fsname##_node_print(struct puffs_usermount *, \
Replace void * by puffs_cookie_t where appropriate. No functional change.
2008-08-12 23:44:39 +04:00
puffs_cookie_t); \
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
int fsname##_node_pathconf(struct puffs_usermount *, \
Make retval argument for pathconf a register_t to match VOP_PATHCONF. This makes the size the same on 64bit archs. Don't bother bumping any version, since you'd have explicitly had to jump through some hoops to use pathconf before.
2010-06-07 15:21:31 +04:00
puffs_cookie_t, int, register_t *); \
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
int fsname##_node_advlock(struct puffs_usermount *, \
Replace void * by puffs_cookie_t where appropriate. No functional change.
2008-08-12 23:44:39 +04:00
puffs_cookie_t, void *, int, struct flock *, int); \
int fsname##_node_read(struct puffs_usermount *, puffs_cookie_t,\
add libpuffs - the userspace programming interface for puffs 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:52:21 +04:00
uint8_t *, off_t, size_t *, const struct puffs_cred *, int);\
Replace void * by puffs_cookie_t where appropriate. No functional change.
2008-08-12 23:44:39 +04:00
int fsname##_node_write(struct puffs_usermount *, \
puffs_cookie_t, uint8_t *, off_t, size_t *, \
const struct puffs_cred *, int); \
Dispatch puffs_node_abortop(). Note: We use the storage of puffs_cache_write from puffs_ops for this purpose. It's not issued by the kernel and hence currently unused, and this saves us from the trouble of bumping the lib major version.
2009-10-18 03:19:52 +04:00
int fsname##_node_abortop(struct puffs_usermount *, \
* support extended attributes * bump major due to structure growth * add some spare space * remove ABI sillyness
2010-05-21 14:50:52 +04:00
puffs_cookie_t, const struct puffs_cn *); \
int fsname##_node_getextattr(struct puffs_usermount *, \
puffs_cookie_t, int, const char *, size_t *, uint8_t *, \
size_t *, const struct puffs_cred *); \
int fsname##_node_setextattr(struct puffs_usermount *, \
puffs_cookie_t, int, const char *, uint8_t *, size_t *, \
const struct puffs_cred *); \
int fsname##_node_listextattr(struct puffs_usermount *, \
puffs_cookie_t, int, size_t *, uint8_t *, size_t *, \
Add a flag to VOP_LISTEXTATTR(9) so that the vnode interface can tell the filesystem in which format extended attribute shall be listed. There are currently two formats: - NUL-terminated strings, used for listxattr(2), this is the default. - one byte length-pprefixed, non NUL-terminated strings, used for extattr_list_file(2), which is obtanined by setting the EXTATTR_LIST_PREFIXLEN flag to VOP_LISTEXTATTR(9) This approach avoid the need for converting the list back and forth, except in libperfuse, since FUSE uses NUL-terminated strings, and the kernel may have requested EXTATTR_LIST_PREFIXLEN.
2011-07-04 12:07:29 +04:00
int, const struct puffs_cred *); \
* support extended attributes * bump major due to structure growth * add some spare space * remove ABI sillyness
2010-05-21 14:50:52 +04:00
int fsname##_node_deleteextattr(struct puffs_usermount *, \
puffs_cookie_t, int, const char *, \
- When using PUFFS_KFLAG_CACHE_FS_TTL, do not use puffs_node to carry attribute and TTL fora newly created node. Instead extend puffs_newinfo and add puffs_newinfo_setva() and puffs_newinfo_setttl() - Remove node_mk_common_final in libperfuse. It used to set uid/gid for a newly created vnode but has been made redundant along time ago since uid and gid are properly set in FUSE header. - In libperfuse, check for corner case where opc = 0 on INACTIVE and RECLAIM (how is it possible? Check for it to avoid a crash anyway) - In libperfuse, make sure we unlimit RLIMIT_AS and RLIMIT_DATA so that we do notrun out of memory because the kernel is lazy at reclaiming vnodes. - In libperfuse, cleanup style of perfuse_destroy_pn()
2012-04-18 04:57:21 +04:00
const struct puffs_cred *); \
int fsname##_node_getattr_ttl(struct puffs_usermount *, \
puffs_cookie_t, struct vattr *, const struct puffs_cred *, \
struct timespec *); \
int fsname##_node_setattr_ttl(struct puffs_usermount *, \
puffs_cookie_t, struct vattr *, const struct puffs_cred *, \
Pass the FAF flag to handlers: - setattr_ttl is updated to add a flag argument. Since it was not present in a previous release, we can change its API - write2 is introduced, this is write with an extra flag for FAF. - fsync already has the FAF information in a flag and needs no change - for other operations, FAF is unconditional
2012-06-27 17:25:23 +04:00
struct timespec *, int); \
int fsname##_node_write2(struct puffs_usermount *, \
puffs_cookie_t, uint8_t *, off_t, size_t *, \
Fix regression that has been introduced when the lookup/reclaim race condition was addressed in libpuffs by counting lookups. The fix assumes that cookies map to struct puffs_cookie, which has not been documented as a requirement for filesystems using libpuffs. As an example, we got burnt by this assumption in libp2k (kern/46734), and we fixed bit by actually mapping libp2k cookies to struct puffs_node. It is unlikely, but there may be third party filesystems that use cookies unmapped to struct puffs_node, and they were left broken for now. - we introduce a puffs_init() flag PUFFS_FLAG_PNCOOKIE that let filesystems inform libpuffs that they map cookies to struct puffs_node. Is that flag is used, the lookup/reclaim race condition fix is enabled. We enable the flag for libp2k. - filesystems that use puffs_pn_new() obviouslty use struct puffs_node and gain PUFFS_FLAG_PNCOOKIE automatically even if they did not specify it in puffs_init(). This include all our PUFFS filesystem in-tree except libp2k. - for filesystems not willing to use struct puffs_node, we introduce a reclaim2 vnop, which is reclaim with an additionnal lookup count argument. This vnop let the filesystem implement the lookup/reclaim race fix on its own.
2012-08-16 13:25:43 +04:00
const struct puffs_cred *, int, int); \
int fsname##_node_reclaim2(struct puffs_usermount *, \
puffs_cookie_t, int);
- When using PUFFS_KFLAG_CACHE_FS_TTL, do not use puffs_node to carry attribute and TTL fora newly created node. Instead extend puffs_newinfo and add puffs_newinfo_setva() and puffs_newinfo_setttl() - Remove node_mk_common_final in libperfuse. It used to set uid/gid for a newly created vnode but has been made redundant along time ago since uid and gid are properly set in FUSE header. - In libperfuse, check for corner case where opc = 0 on INACTIVE and RECLAIM (how is it possible? Check for it to avoid a crash anyway) - In libperfuse, make sure we unlimit RLIMIT_AS and RLIMIT_DATA so that we do notrun out of memory because the kernel is lazy at reclaiming vnodes. - In libperfuse, cleanup style of perfuse_destroy_pn()
2012-04-18 04:57:21 +04:00
add libpuffs - the userspace programming interface for puffs 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:52:21 +04:00
rototill the operation callbacks: unify the ops under struct puffs_ops and namespace them
2006-12-07 13:53:21 +03:00
#define PUFFSOP_INIT(ops) \
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
ops = malloc(sizeof(struct puffs_ops)); \
rototill the operation callbacks: unify the ops under struct puffs_ops and namespace them
2006-12-07 13:53:21 +03:00
memset(ops, 0, sizeof(struct puffs_ops))
#define PUFFSOP_SET(ops, fsname, fsornode, opname) \
(ops)->puffs_##fsornode##_##opname = fsname##_##fsornode##_##opname
#define PUFFSOP_SETFSNOP(ops, opname) \
(ops)->puffs_fs_##opname = puffs_fsnop_##opname
Introduce puffs_null_setops(), which initializes the ops vector with puffs nullfs ops.
2007-06-24 22:42:25 +04:00
PUFFSOP_PROTOS(puffs_null) /* XXX */
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
#define PNPATH(pnode) ((pnode)->pn_po.po_path)
#define PNPLEN(pnode) ((pnode)->pn_po.po_len)
#define PCNPATH(pcnode) ((pcnode)->pcn_po_full.po_path)
#define PCNPLEN(pcnode) ((pcnode)->pcn_po_full.po_len)
* get rid of the holy kernel-given ISDOTDOT, and instead define a macro which does strcmp against ".." and (the untranslated) componentname * make PUFFS_FLAG_BUILDPATH build paths also if dotdot is the case, and adapt the regular path objects to this * make nullfs lookup readable because we can now get rid of dotdot processing there
2007-02-15 15:51:45 +03:00
#define PCNISDOTDOT(pcnode) \
((pcnode)->pcn_namelen == 2 && strcmp((pcnode)->pcn_name, "..") == 0)
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
Introduce PUFFS_STORE_DCOOKIE, which stores a directory cookie for a given offset iff the directory read in question wants cookies.
2007-04-17 15:42:14 +04:00
#define PUFFS_STORE_DCOOKIE(cp, ncp, off) \
if (cp) { \
*((cp)++) = off; \
(*(ncp))++; \
}
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
/* mainloop */
typedef void (*puffs_ml_loop_fn)(struct puffs_usermount *);
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
/* framebuf stuff */
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
typedef int (*puffs_framev_readframe_fn)(struct puffs_usermount *,
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
struct puffs_framebuf *,
int, int *);
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
typedef int (*puffs_framev_writeframe_fn)(struct puffs_usermount *,
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
struct puffs_framebuf *,
int, int *);
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
typedef int (*puffs_framev_cmpframe_fn)(struct puffs_usermount *,
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
struct puffs_framebuf *,
Give cmpframe() the ability to shortcircuit the comparison loop by signalling back that the buffer under examination is not a response at all.
2007-09-06 20:08:55 +04:00
struct puffs_framebuf *,
int *);
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
typedef void (*puffs_framev_fdnotify_fn)(struct puffs_usermount *, int, int);
Add gotframe callback, which is called if an incoming frame matches no outstanding request.
2007-09-01 20:42:42 +04:00
typedef void (*puffs_framev_gotframe_fn)(struct puffs_usermount *,
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
typedef void (*puffs_framev_cb)(struct puffs_usermount *,
struct puffs_framebuf *,
Add error parameter to puffs_framev_cb to signal if there is a result of if the function should just do resource cleanup.
2007-05-16 14:04:08 +04:00
void *, int);
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 PUFFS_FBIO_READ 0x01
#define PUFFS_FBIO_WRITE 0x02
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 PUFFS_FBIO_ERROR 0x04
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 PUFFS_FBQUEUE_URGENT 0x01
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
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
Make it possible to supply parameters to puffs_init() later (but before puffs_mount()).
2009-10-18 23:09:20 +04:00
#define PUFFS_DEFER ((void *)-1)
* support extended attributes * bump major due to structure growth * add some spare space * remove ABI sillyness
2010-05-21 14:50:52 +04:00
struct puffs_usermount *puffs_init(struct puffs_ops *, const char *,
* add mntfromname parameter to puffs_init() * set it in file servers
2007-07-17 15:34:51 +04:00
const char *, void *, uint32_t);
Reflect kernel changes for supplying root node information in mount instead of puffs_start(). Get completely rid of puffs_start(), as everything it used to do is now handled by the mount routine. Introduce an optional pre-mount call puffs_setrootinfo() for setting non-default root node information. As the old puffs_mount() is now virtually useless, say byebye to it and rename the old puffs_domount() to puffs_mount(), but add a root cookie parameter to compensate for the late puffs_start().
2007-05-17 18:03:13 +04:00
int puffs_mount(struct puffs_usermount *, const char *, int, void*);
* get rid of the mount callback; it's no great surprise to the server that it needs to mount the file system backend if it wants to call mount * provide some options for getmntopts(), assume that callers will parse command line (or fstab) args * reorganize the puffs_cc interface just a bit, preparing for a bigger revamp later
2007-01-06 21:22:09 +03:00
int puffs_exit(struct puffs_usermount *, int);
Add puffs_cancel(), which allows to back down after puffs_init() and before puffs_mount(). (this should actually be integrated with puffs_exit(), but that routine is currently so non-sensible that I didn't bother now)
2008-12-12 22:45:16 +03:00
void puffs_cancel(struct puffs_usermount *, int);
Pull the daemonizing code out of the library mainloop into the file servers. Calling daemon() (i.e. fork()ing) inside a library can cause nice surprises for e.g. threaded programs. As discussed with Greg Oster & others.
2007-11-05 20:48:17 +03:00
int puffs_mainloop(struct puffs_usermount *);
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 puffs_daemon(struct puffs_usermount *, int, int);
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
Add convenience routine puffs_unmountonsignal(), which does exactly that.
2010-01-12 21:42:38 +03:00
int puffs_unmountonsignal(int, bool);
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 puffs_getselectable(struct puffs_usermount *);
int puffs_setblockingmode(struct puffs_usermount *, int);
int puffs_getstate(struct puffs_usermount *);
void puffs_setstacksize(struct puffs_usermount *, size_t);
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 puffs_ml_setloopfn(struct puffs_usermount *, puffs_ml_loop_fn);
void puffs_ml_settimeout(struct puffs_usermount *, struct timespec *);
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
void puffs_setroot(struct puffs_usermount *,
struct puffs_node *);
struct puffs_node *puffs_getroot(struct puffs_usermount *);
Reflect kernel changes for supplying root node information in mount instead of puffs_start(). Get completely rid of puffs_start(), as everything it used to do is now handled by the mount routine. Introduce an optional pre-mount call puffs_setrootinfo() for setting non-default root node information. As the old puffs_mount() is now virtually useless, say byebye to it and rename the old puffs_domount() to puffs_mount(), but add a root cookie parameter to compensate for the late puffs_start().
2007-05-17 18:03:13 +04:00
void puffs_setrootinfo(struct puffs_usermount *,
enum vtype, vsize_t, dev_t);
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
void *puffs_getspecific(struct puffs_usermount *);
add: puffs_setspecific(pu, private) Can be used to set the specific data after the call to puffs_init().
2008-12-12 21:59:53 +03:00
void puffs_setspecific(struct puffs_usermount *, void *);
some routines for setting mount parameters
2007-04-16 12:28:55 +04:00
void puffs_setmaxreqlen(struct puffs_usermount *, size_t);
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
size_t puffs_getmaxreqlen(struct puffs_usermount *);
alloc to set flags when setting fhsize
2007-04-16 17:04:49 +04:00
void puffs_setfhsize(struct puffs_usermount *, size_t, int);
Make it possible to supply parameters to puffs_init() later (but before puffs_mount()).
2009-10-18 23:09:20 +04:00
void puffs_setmntinfo(struct puffs_usermount *,
const char *, const char *);
some routines for setting mount parameters
2007-04-16 12:28:55 +04:00
void puffs_setncookiehash(struct puffs_usermount *, int);
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 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
struct puffs_pathobj *puffs_getrootpathobj(struct puffs_usermount *);
Add puffs_setback(), which can be used to set setbacks for nodes before the call returns to the kernel. Currently it can be called only from open(), mmap(), remove() and rmdir(). (But that might change)
2007-05-07 21:16:07 +04:00
void puffs_setback(struct puffs_cc *, int);
Add preliminary code for a nullfs layer, which can be used to mount a directory hierarchy to another point, just like with the kernel nullfs. This is not really a layering scheme yet, but it should evolve into one. Currently it can just be used to do 1:1 mapping.
2007-01-11 04:01:55 +03:00
struct puffs_node *puffs_pn_new(struct puffs_usermount *, void *);
Introduce puffs_pn_remove() to signal that a node has been deleted and destroyed, but not yet reclaimed. This prevents puffs_pn_nodewalk() from returning stale entries. Make nullfs use this (some file systems are a bit too happy with recycling inode numbers).
2007-06-24 21:55:07 +04:00
void puffs_pn_remove(struct puffs_node *);
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
void puffs_pn_put(struct puffs_node *);
Add accessors for struct puffs_node to prepare for removal from exported headers.
2007-08-17 21:25:31 +04:00
struct vattr *puffs_pn_getvap(struct puffs_node *);
void * puffs_pn_getpriv(struct puffs_node *);
void puffs_pn_setpriv(struct puffs_node *, void *);
struct puffs_pathobj *puffs_pn_getpo(struct puffs_node *);
struct puffs_usermount *puffs_pn_getmnt(struct puffs_node *);
Add PUFFS_KFLAG_CACHE_FS_TTL flag to puffs_init(3) to use name and attribute cache with filesystem provided TTL. lookup, create, mknod, mkdir, symlink, getattr and setattr messages have been extended so that attributes and their TTL can be provided by the filesytem. lookup, create, mknod, mkdir, and symlink messages are also extended so that the filesystem can provide name TTL. The filesystem updates attributes and TTL using puffs_pn_getvap(3), puffs_pn_getvattl(3), and puffs_pn_getcnttl(3)
2012-04-08 19:07:45 +04:00
struct timespec *puffs_pn_getvattl(struct puffs_node *);
struct timespec *puffs_pn_getcnttl(struct puffs_node *);
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
Replace void * by puffs_cookie_t where appropriate. No functional change.
2008-08-12 23:44:39 +04:00
void puffs_newinfo_setcookie(struct puffs_newinfo *, puffs_cookie_t);
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
void puffs_newinfo_setvtype(struct puffs_newinfo *, enum vtype);
void puffs_newinfo_setsize(struct puffs_newinfo *, voff_t);
void puffs_newinfo_setrdev(struct puffs_newinfo *, dev_t);
- When using PUFFS_KFLAG_CACHE_FS_TTL, do not use puffs_node to carry attribute and TTL fora newly created node. Instead extend puffs_newinfo and add puffs_newinfo_setva() and puffs_newinfo_setttl() - Remove node_mk_common_final in libperfuse. It used to set uid/gid for a newly created vnode but has been made redundant along time ago since uid and gid are properly set in FUSE header. - In libperfuse, check for corner case where opc = 0 on INACTIVE and RECLAIM (how is it possible? Check for it to avoid a crash anyway) - In libperfuse, make sure we unlimit RLIMIT_AS and RLIMIT_DATA so that we do notrun out of memory because the kernel is lazy at reclaiming vnodes. - In libperfuse, cleanup style of perfuse_destroy_pn()
2012-04-18 04:57:21 +04:00
void puffs_newinfo_setva(struct puffs_newinfo *, struct vattr *);
void puffs_newinfo_setvattl(struct puffs_newinfo *, struct timespec *);
void puffs_newinfo_setcnttl(struct puffs_newinfo *, struct timespec *);
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
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
void *puffs_pn_getmntspecific(struct puffs_node *);
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
typedef void * (*puffs_nodewalk_fn)(struct puffs_usermount *,
struct puffs_node *, void *);
void *puffs_pn_nodewalk(struct puffs_usermount *,
puffs_nodewalk_fn, void *);
Add preliminary code for a nullfs layer, which can be used to mount a directory hierarchy to another point, just like with the kernel nullfs. This is not really a layering scheme yet, but it should evolve into one. Currently it can just be used to do 1:1 mapping.
2007-01-11 04:01:55 +03: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
void puffs_setvattr(struct vattr *, const struct vattr *);
void puffs_vattr_null(struct vattr *);
Introduce puffs_null_setops(), which initializes the ops vector with puffs nullfs ops.
2007-06-24 22:42:25 +04:00
void puffs_null_setops(struct puffs_ops *);
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_dispatch_create(struct puffs_usermount *,
struct puffs_framebuf *,
struct puffs_cc **);
int puffs_dispatch_exec(struct puffs_cc *,
struct puffs_framebuf **);
* nuke puffs_cc_get{specific,usermount} for good * move prototypes for puffs_docc and puffs_dopufbuf into the public header, as they are should be exposed
2007-12-16 23:02:57 +03:00
* get rid of the holy kernel-given ISDOTDOT, and instead define a macro which does strcmp against ".." and (the untranslated) componentname * make PUFFS_FLAG_BUILDPATH build paths also if dotdot is the case, and adapt the regular path objects to this * make nullfs lookup readable because we can now get rid of dotdot processing there
2007-02-15 15:51:45 +03:00
/*
* generic/dummy routines applicable for some file systems
*/
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
int puffs_fsnop_unmount(struct puffs_usermount *, int);
int puffs_fsnop_statvfs(struct puffs_usermount *, struct statvfs *);
* get rid of the holy kernel-given ISDOTDOT, and instead define a macro which does strcmp against ".." and (the untranslated) componentname * make PUFFS_FLAG_BUILDPATH build paths also if dotdot is the case, and adapt the regular path objects to this * make nullfs lookup readable because we can now get rid of dotdot processing there
2007-02-15 15:51:45 +03:00
void puffs_zerostatvfs(struct statvfs *);
Rototill. Ok, ok, a few more words about it: stop holding puffs_cc as a holy value and passing it around to almost every possible place (popquiz: which kernel variable does this remind you of?). Instead, pass the natural choice, puffs_usermount, and fetch puffs_cc via puffs_cc_getcc() only in routines which actually need it. This not only simplifies code, but (thanks to the introduction of puffs_cc_getcc()) enables constructs which weren't previously sanely possible, say layering as a curious example. There's still a little to do on this front, but this was the major fs interface blast.
2007-11-30 22:02:28 +03:00
int puffs_fsnop_sync(struct puffs_usermount *, int waitfor,
Remove "puffs_cid" from the puffs interface following l-removal from the kernel vfs interfaces. puffs_cc_getcaller(pcc) can be used now should the same information be desired.
2007-11-27 14:31:17 +03:00
const struct puffs_cred *);
Add generic getattr routine.
2007-12-19 17:01:16 +03:00
Replace void * by puffs_cookie_t where appropriate. No functional change.
2008-08-12 23:44:39 +04:00
int puffs_genfs_node_getattr(struct puffs_usermount *, puffs_cookie_t,
Add generic getattr routine.
2007-12-19 17:01:16 +03:00
struct vattr *, const struct puffs_cred *);
Replace void * by puffs_cookie_t where appropriate. No functional change.
2008-08-12 23:44:39 +04:00
int puffs_genfs_node_reclaim(struct puffs_usermount *, puffs_cookie_t);
* get rid of the holy kernel-given ISDOTDOT, and instead define a macro which does strcmp against ".." and (the untranslated) componentname * make PUFFS_FLAG_BUILDPATH build paths also if dotdot is the case, and adapt the regular path objects to this * make nullfs lookup readable because we can now get rid of dotdot processing there
2007-02-15 15:51:45 +03:00
Add preliminary code for a nullfs layer, which can be used to mount a directory hierarchy to another point, just like with the kernel nullfs. This is not really a layering scheme yet, but it should evolve into one. Currently it can just be used to do 1:1 mapping.
2007-01-11 04:01:55 +03:00
/*
* Subroutine stuff
*/
int puffs_gendotdent(struct dirent **, ino_t, int, size_t *);
int puffs_nextdent(struct dirent **, const char *, ino_t,
uint8_t, size_t *);
int puffs_vtype2dt(enum vtype);
enum vtype puffs_mode2vt(mode_t);
void puffs_stat2vattr(struct vattr *va, const struct stat *);
va->va_mode doesn't contain the full argument to the mknod() system call, so introduce puffs_addvtype2mode() and use that in null.c to generate the proper syscall argument
2007-03-16 11:14:49 +03:00
mode_t puffs_addvtype2mode(mode_t, enum vtype);
add routiens which check against ufs semantics for permission to chown, chmod and change a/mtime
2007-03-21 22:55:55 +03:00
/*
* credentials & permissions
*/
/* Credential fetch */
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
int puffs_cred_getuid(const struct puffs_cred *, uid_t *);
int puffs_cred_getgid(const struct puffs_cred *, gid_t *);
int puffs_cred_getgroups(const struct puffs_cred *, gid_t *, short *);
add routiens which check against ufs semantics for permission to chown, chmod and change a/mtime
2007-03-21 22:55:55 +03:00
/* Credential check */
* Change type of boolean functions to, well, boolean instead of int. * add puffs_cid_isequal() which can be used to test if the two caller id's refer to the same process/lwp.
2007-10-18 17:48:04 +04:00
bool puffs_cred_isuid(const struct puffs_cred *, uid_t);
bool puffs_cred_hasgroup(const struct puffs_cred *, gid_t);
bool puffs_cred_isregular(const struct puffs_cred *);
bool puffs_cred_iskernel(const struct puffs_cred *);
bool puffs_cred_isfs(const struct puffs_cred *);
bool puffs_cred_isjuggernaut(const struct puffs_cred *);
add routiens which check against ufs semantics for permission to chown, chmod and change a/mtime
2007-03-21 22:55:55 +03:00
/* misc */
int puffs_access(enum vtype, mode_t, uid_t, gid_t, mode_t,
const struct puffs_cred *);
unify the location of *pcr in puffs_access_*
2007-03-22 19:57:27 +03:00
int puffs_access_chown(uid_t, gid_t, uid_t, gid_t,
const struct puffs_cred *);
int puffs_access_chmod(uid_t, gid_t, enum vtype, mode_t,
const struct puffs_cred *);
int puffs_access_times(uid_t, gid_t, mode_t, int,
const struct puffs_cred *);
add routiens which check against ufs semantics for permission to chown, chmod and change a/mtime
2007-03-21 22:55:55 +03:00
Add preliminary code for a nullfs layer, which can be used to mount a directory hierarchy to another point, just like with the kernel nullfs. This is not really a layering scheme yet, but it should evolve into one. Currently it can just be used to do 1:1 mapping.
2007-01-11 04:01:55 +03: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 interfaces relevant for user.
*/
void puffs_cc_yield(struct puffs_cc *);
void puffs_cc_continue(struct puffs_cc *);
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
void puffs_cc_schedule(struct puffs_cc *);
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
int puffs_cc_getcaller(struct puffs_cc *,pid_t *,lwpid_t *);
* allocate pcc as a slice from the stack instead of allocating it separately * provide puffs_cc_getcc() This is in preparation for the removal of you-should-guess-what as an argument to routines here and there and everywhere.
2007-11-29 20:47:54 +03:00
struct puffs_cc *puffs_cc_getcc(struct puffs_usermount *);
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
lib interface for invalidation routines
2007-01-09 21:15:08 +03:00
/*
* Flushing / invalidation routines
*/
Replace void * by puffs_cookie_t where appropriate. No functional change.
2008-08-12 23:44:39 +04:00
int puffs_inval_namecache_dir(struct puffs_usermount *, puffs_cookie_t);
rename name cache invalidation interface to be in sync with the kernel operation names, i.e. contain "namecache" instead of just "name"
2007-01-09 21:19:01 +03:00
int puffs_inval_namecache_all(struct puffs_usermount *);
lib interface for invalidation routines
2007-01-09 21:15:08 +03:00
Replace void * by puffs_cookie_t where appropriate. No functional change.
2008-08-12 23:44:39 +04:00
int puffs_inval_pagecache_node(struct puffs_usermount *, puffs_cookie_t);
int puffs_inval_pagecache_node_range(struct puffs_usermount *,
puffs_cookie_t, off_t, off_t);
int puffs_flush_pagecache_node(struct puffs_usermount *, puffs_cookie_t);
int puffs_flush_pagecache_node_range(struct puffs_usermount *,
puffs_cookie_t, off_t, off_t);
initial support for cacheops
2007-03-20 13:22:22 +03:00
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
/*
* Path constructicons
*/
Introduce puffs_path_walkcmp(), which is to be called from nodewalk and compares the path of the node against the given pathobject. Also make comparison method take a flag to indicate if it should check if the second path is a true prefix of the first. plus some namespace cleanup
2007-02-15 20:04:46 +03:00
int puffs_stdpath_buildpath(struct puffs_usermount *,
* get rid of the holy kernel-given ISDOTDOT, and instead define a macro which does strcmp against ".." and (the untranslated) componentname * make PUFFS_FLAG_BUILDPATH build paths also if dotdot is the case, and adapt the regular path objects to this * make nullfs lookup readable because we can now get rid of dotdot processing there
2007-02-15 15:51:45 +03:00
const struct puffs_pathobj *,
const struct puffs_pathobj *, size_t,
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
struct puffs_pathobj *);
Introduce puffs_path_walkcmp(), which is to be called from nodewalk and compares the path of the node against the given pathobject. Also make comparison method take a flag to indicate if it should check if the second path is a true prefix of the first. plus some namespace cleanup
2007-02-15 20:04:46 +03:00
int puffs_stdpath_cmppath(struct puffs_usermount *, struct puffs_pathobj *,
struct puffs_pathobj *, size_t, int);
void puffs_stdpath_freepath(struct puffs_usermount *,struct puffs_pathobj *);
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
Introduce puffs_path_walkcmp(), which is to be called from nodewalk and compares the path of the node against the given pathobject. Also make comparison method take a flag to indicate if it should check if the second path is a true prefix of the first. plus some namespace cleanup
2007-02-15 20:04:46 +03:00
void *puffs_path_walkcmp(struct puffs_usermount *,
struct puffs_node *, void *);
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
void *puffs_path_prefixadj(struct puffs_usermount *,
struct puffs_node *, void *);
int puffs_path_pcnbuild(struct puffs_usermount *,
struct puffs_cn *, void *);
Introduce PUFFS_FLAG_HASHPATH, which for PUFFS_FLAG_BUILDPATH file servers creates a hash of the node's path into po->po_hash to avoid a full pathcmp every time.
2007-05-01 19:58:00 +04:00
void puffs_path_buildhash(struct puffs_usermount *, struct puffs_pathobj *);
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_set_pathbuild(struct puffs_usermount *, pu_pathbuild_fn); void puffs_set_pathtransform(struct puffs_usermount *, pu_pathtransform_fn);
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
void puffs_set_pathcmp(struct puffs_usermount *, pu_pathcmp_fn);
void puffs_set_pathfree(struct puffs_usermount *, pu_pathfree_fn);
void puffs_set_namemod(struct puffs_usermount *, pu_namemod_fn);
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
void puffs_set_errnotify(struct puffs_usermount *, pu_errnotify_fn);
Add an error handler which syslogs but does not abort() and make it the default. Most servers just shovel bits from their backend to the kernel without checking the contents and dumping core in case the backend gives garbage is a bit harsh.
2009-12-05 23:54:10 +03:00
void puffs_kernerr_log(struct puffs_usermount *, uint8_t, int,
const char *, puffs_cookie_t);
Use __dead
2011-08-30 00:41:06 +04:00
__dead void puffs_kernerr_abort(struct puffs_usermount *, uint8_t, int,
Add an error handler which syslogs but does not abort() and make it the default. Most servers just shovel bits from their backend to the kernel without checking the contents and dumping core in case the backend gives garbage is a bit harsh.
2009-12-05 23:54:10 +03:00
const char *, puffs_cookie_t);
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
void puffs_set_prepost(struct puffs_usermount *,
pu_prepost_fn, pu_prepost_fn);
Add a public interface for setting a cookie mapper.
2007-12-25 23:38:01 +03:00
void puffs_set_cmap(struct puffs_usermount *, pu_cmap_fn);
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
add interfaces for suspending the file system
2007-01-27 02:00:33 +03:00
/*
* Suspension
*/
int puffs_fs_suspend(struct puffs_usermount *);
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
/*
* Frame buffering
*/
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 puffs_framev_init(struct puffs_usermount *,
puffs_framev_readframe_fn,
puffs_framev_writeframe_fn,
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,
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,
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);
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 "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
struct puffs_framebuf *puffs_framebuf_make(void);
void puffs_framebuf_destroy(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
int puffs_framebuf_dup(struct puffs_framebuf *,
struct puffs_framebuf **);
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
void puffs_framebuf_recycle(struct puffs_framebuf *);
int puffs_framebuf_reserve_space(struct puffs_framebuf *,
size_t);
int puffs_framebuf_putdata(struct puffs_framebuf *, const void *, size_t);
int puffs_framebuf_putdata_atoff(struct puffs_framebuf *, size_t,
const void *, size_t);
int puffs_framebuf_getdata(struct puffs_framebuf *, void *, size_t);
int puffs_framebuf_getdata_atoff(struct puffs_framebuf *, size_t,
void *, size_t);
size_t puffs_framebuf_telloff(struct puffs_framebuf *);
size_t puffs_framebuf_tellsize(struct puffs_framebuf *);
size_t puffs_framebuf_remaining(struct puffs_framebuf *);
int puffs_framebuf_seekset(struct puffs_framebuf *, size_t);
int puffs_framebuf_getwindow(struct puffs_framebuf *, size_t,
void **, size_t *);
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 puffs_framev_enqueue_cc(struct puffs_cc *, int,
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
struct puffs_framebuf *, int);
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 puffs_framev_enqueue_cb(struct puffs_usermount *, int,
struct puffs_framebuf *,
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
puffs_framev_cb, void *, int);
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 puffs_framev_enqueue_justsend(struct puffs_usermount *, int,
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
struct puffs_framebuf *, int, int);
int puffs_framev_enqueue_directreceive(struct puffs_cc *, int,
struct puffs_framebuf *, int);
int puffs_framev_enqueue_directsend(struct puffs_cc *, int,
struct puffs_framebuf *, int);
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 puffs_framev_enqueue_waitevent(struct puffs_cc *, int, int *);
Introduce puffs_framev_framebuf_ccpromote, which can be used to turn a reference to puffs_framebuf in the file system from a cb/justsend operation to a cc wait, should the file system find itself desiring the result.
2007-05-20 23:56:56 +04:00
int puffs_framev_framebuf_ccpromote(struct puffs_framebuf *,
struct puffs_cc *);
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
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
int puffs_framev_addfd(struct puffs_usermount *, int, int);
int puffs_framev_enablefd(struct puffs_usermount *, int, int);
int puffs_framev_disablefd(struct puffs_usermount *, int, int);
int puffs_framev_removefd(struct puffs_usermount *, int, int);
make notifyfunction optional and do not call removeonclose() if none is given.
2007-07-08 15:24:58 +04:00
void puffs_framev_removeonclose(struct puffs_usermount *, int, int);
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
void puffs_framev_unmountonclose(struct puffs_usermount *, int, int);
Step 1 in moving towards a general-purpose eventloop: allow the framebuf event loop to take n i/o fd's as parameters and also allow dynamic add/remove of fd's. (not tested except for one fd, but more changes coming soon)
2007-05-11 20:22:38 +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
__END_DECLS
rototill the operation callbacks: unify the ops under struct puffs_ops and namespace them
2006-12-07 13:53:21 +03:00
#endif /* _PUFFS_H_ */
Reference in New Issue Copy Permalink