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

539 lines
18 KiB
C
Raw Normal View History

initial support for cacheops
2007-03-20 13:22:22 +03:00
/* $NetBSD: puffs.h,v 1.33 2007/03/20 10:22:23 pooka 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
/*
* Copyright (c) 2005, 2006 Antti Kantee. All Rights Reserved.
*
* Development of this software was supported by the
* Google Summer of Code program and the Ulla Tuominen Foundation.
* The Google SoC project was mentored by Bill Studenmund.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. The name of the company nor the name of the author may be used to
* endorse or promote products derived from this software without specific
* prior written permission.
*
* 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>
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>
#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>
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;
struct puffs_putreq;
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 {
void *po_path;
size_t po_len;
};
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;
int pn_flag;
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
};
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)
#define PUFFS_IO_APPEND 0x20
implement fsync
2007-01-11 20:48:21 +03:00
#define PUFFS_FSYNC_DATAONLY 0x0002
#define PUFFS_FSYNC_CACHE 0x0100
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
*/
Be less shy about the default stack size, it's a only virtual memory space. TODO: put a guard page at the end
2007-01-10 23:11:04 +03:00
#define PUFFS_CC_STACKSIZE_DEFAULT (1024*1024)
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 */
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_pid pcn_pkcnp->pkcn_pid
#define pcn_cred pcn_pkcnp->pkcn_cred
#define pcn_name pcn_pkcnp->pkcn_name
#define pcn_namelen pcn_pkcnp->pkcn_namelen
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 */
#define PUFFSMOPT_CACHE { "cache", 1, PUFFS_KFLAG_NOCACHE, 1 }
#define PUFFSMOPT_ALLOPS { "allops", 0, PUFFS_KFLAG_ALLOPS, 1 }
/* libpuffs */
#define PUFFSMOPT_DUMP { "dump", 0, PUFFS_FLAG_OPDUMP, 1 }
#define PUFFSMOPT_STD \
PUFFSMOPT_CACHE, \
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 {
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_fs_unmount)(struct puffs_cc *, int, pid_t);
int (*puffs_fs_statvfs)(struct puffs_cc *,
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
struct statvfs *, pid_t);
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_fs_sync)(struct puffs_cc *, int,
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 struct puffs_cred *, pid_t);
add interfaces for suspending the file system
2007-01-27 02:00:33 +03:00
void (*puffs_fs_suspend)(struct puffs_cc *, int);
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
int (*puffs_node_lookup)(struct puffs_cc *,
* support FAF (Fire-And-Forget) class operations * adapt to new lookup
2006-11-08 01:10:53 +03:00
void *, void **, enum vtype *, voff_t *, dev_t *,
pass rdev for specfs support
2006-10-27 02:53:01 +04:00
const struct puffs_cn *);
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_node_create)(struct puffs_cc *,
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
void *, void **, const struct puffs_cn *, const struct vattr *);
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_node_mknod)(struct puffs_cc *,
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
void *, void **, const struct puffs_cn *, const struct vattr *);
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_node_open)(struct puffs_cc *,
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
void *, int, const struct puffs_cred *, pid_t);
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_node_close)(struct puffs_cc *,
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
void *, int, const struct puffs_cred *, pid_t);
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_node_access)(struct puffs_cc *,
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
void *, int, const struct puffs_cred *, pid_t);
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_node_getattr)(struct puffs_cc *,
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
void *, struct vattr *, const struct puffs_cred *, pid_t);
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_node_setattr)(struct puffs_cc *,
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
void *, const struct vattr *, const struct puffs_cred *, pid_t);
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_node_poll)(struct puffs_cc *,
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
void *, struct puffs_vnreq_poll *);
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_node_mmap)(struct puffs_cc *,
support mmap
2006-12-07 19:59:14 +03:00
void *, int, const struct puffs_cred *, pid_t);
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_node_fsync)(struct puffs_cc *,
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
void *, const struct puffs_cred *, int, off_t, off_t, pid_t);
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_node_seek)(struct puffs_cc *,
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
void *, off_t, off_t, const struct puffs_cred *);
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_node_remove)(struct puffs_cc *,
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
void *, void *, const struct puffs_cn *);
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_node_link)(struct puffs_cc *,
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
void *, void *, const struct puffs_cn *);
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_node_rename)(struct puffs_cc *,
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
void *, void *, const struct puffs_cn *, void *, void *,
const struct puffs_cn *);
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_node_mkdir)(struct puffs_cc *,
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
void *, void **, const struct puffs_cn *, const struct vattr *);
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_node_rmdir)(struct puffs_cc *,
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
void *, void *, const struct puffs_cn *);
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_node_symlink)(struct puffs_cc *,
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
void *, void **, const struct puffs_cn *, const struct vattr *,
const char *);
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_node_readdir)(struct puffs_cc *,
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
void *, struct dirent *, const struct puffs_cred *,
off_t *, size_t *);
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_node_readlink)(struct puffs_cc *,
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
void *, const struct puffs_cred *, char *, size_t *);
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_node_reclaim)(struct puffs_cc *,
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
void *, pid_t);
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_node_inactive)(struct puffs_cc *,
handle PUFFS_VN_INACTIVE
2006-10-25 22:15:50 +04:00
void *, pid_t, 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
int (*puffs_node_print)(struct puffs_cc *,
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
void *);
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_node_pathconf)(struct puffs_cc *,
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
void *, 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
int (*puffs_node_advlock)(struct puffs_cc *,
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
void *, void *, int, struct flock *, 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
int (*puffs_node_getextattr)(struct puffs_cc *,
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
void *, struct puffs_vnreq_getextattr *);
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_node_setextattr)(struct puffs_cc *,
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
void *, struct puffs_vnreq_setextattr *);
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_node_listextattr)(struct puffs_cc *,
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
void *, struct puffs_vnreq_listextattr *);
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_node_read)(struct puffs_cc *, void *,
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);
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_node_write)(struct puffs_cc *, void *,
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);
initial support for cacheops
2007-03-20 13:22:22 +03:00
int (*puffs_cache_write)(struct puffs_usermount *,
void *, size_t, struct puffs_cacherun *);
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 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
struct puffs_usermount {
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 pu_ops;
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
int pu_fd;
uint32_t pu_flags;
size_t pu_maxreqlen;
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
size_t pu_cc_stacksize;
int pu_state;
struct puffs_node *pu_pn_root;
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
LIST_HEAD(, puffs_node) pu_pnodelst;
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_node *(*pu_cmap)(void *);
pu_pathbuild_fn pu_pathbuild;
pu_pathtransform_fn pu_pathtransform;
pu_pathcmp_fn pu_pathcmp;
pu_pathfree_fn pu_pathfree;
pu_namemod_fn pu_namemod;
add 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
void *pu_privdata;
};
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 {
PUFFS_STATE_MOUNTING, PUFFS_STATE_RUNNING,
PUFFS_STATE_UNMOUNTING, PUFFS_STATE_UNMOUNTED
};
PUFFSFLAG -> PUFFS_FLAG to be consistent with the kernel
2006-12-01 15:50:06 +03:00
#define PUFFS_FLAG_KERN(a) ((a) & 0x0000ffff)
#define PUFFS_FLAG_LIB(a) ((a) & 0xffff0000)
summon daemon(3) in mainloop unless the nodaemon flag is given
2006-11-30 08:37:48 +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 */
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
summon daemon(3) in mainloop unless the nodaemon flag is given
2006-11-30 08:37:48 +03:00
/* mainloop flags */
#define PUFFSLOOP_NODAEMON 0x01
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 */
/*
* Operation credentials
*/
/* Credential fetch */
int puffs_cred_getuid(const struct puffs_cred *pcr, uid_t *);
int puffs_cred_getgid(const struct puffs_cred *pcr, gid_t *);
int puffs_cred_getgroups(const struct puffs_cred *pcr, gid_t *, short *);
/* Credential check */
int puffs_cred_isuid(const struct puffs_cred *pcr, uid_t);
int puffs_cred_hasgroup(const struct puffs_cred *pcr, gid_t);
/* kernel internal NOCRED */
int puffs_cred_iskernel(const struct puffs_cred *pcr);
/* kernel internal FSCRED */
int puffs_cred_isfs(const struct puffs_cred *pcr);
/* root || NOCRED || FSCRED */
int puffs_cred_isjuggernaut(const struct puffs_cred *pcr);
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) \
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 fsname##_fs_mount(struct puffs_usermount *, void **, \
struct statvfs *); \
int fsname##_fs_unmount(struct puffs_cc *, int, pid_t); \
int fsname##_fs_statvfs(struct puffs_cc *, \
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
struct statvfs *, pid_t); \
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 fsname##_fs_sync(struct puffs_cc *, int, \
rototill the operation callbacks: unify the ops under struct puffs_ops and namespace them
2006-12-07 13:53:21 +03:00
const struct puffs_cred *cred, pid_t); \
add interfaces for suspending the file system
2007-01-27 02:00:33 +03:00
void fsname##_fs_suspend(struct puffs_cc *, int); \
rototill the operation callbacks: unify the ops under struct puffs_ops and namespace them
2006-12-07 13:53:21 +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
int fsname##_node_lookup(struct puffs_cc *, \
* support FAF (Fire-And-Forget) class operations * adapt to new lookup
2006-11-08 01:10:53 +03:00
void *, void **, enum vtype *, voff_t *, dev_t *, \
pass rdev for specfs support
2006-10-27 02:53:01 +04:00
const struct puffs_cn *); \
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 fsname##_node_create(struct puffs_cc *, \
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
void *, void **, const struct puffs_cn *, \
const struct vattr *); \
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 fsname##_node_mknod(struct puffs_cc *, \
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
void *, void **, const struct puffs_cn *, \
const struct vattr *); \
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 fsname##_node_open(struct puffs_cc *, \
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
void *, int, const struct puffs_cred *, pid_t); \
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 fsname##_node_close(struct puffs_cc *, \
const coherence
2006-11-23 19:44:28 +03:00
void *, int, const struct puffs_cred *, pid_t); \
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 fsname##_node_access(struct puffs_cc *, \
const coherence
2006-11-23 19:44:28 +03:00
void *, int, const struct puffs_cred *, pid_t); \
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 fsname##_node_getattr(struct puffs_cc *, \
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
void *, struct vattr *, const struct puffs_cred *, pid_t); \
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 fsname##_node_setattr(struct puffs_cc *, \
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
void *, const struct vattr *, const struct puffs_cred *, \
pid_t); \
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 fsname##_node_poll(struct puffs_cc *, \
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
void *, struct puffs_vnreq_poll *); \
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 fsname##_node_mmap(struct puffs_cc *, \
support mmap
2006-12-07 19:59:14 +03:00
void *, int, const struct puffs_cred *, pid_t); \
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 fsname##_node_fsync(struct puffs_cc *, \
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
void *, const struct puffs_cred *, int, off_t, off_t, \
pid_t); \
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 fsname##_node_seek(struct puffs_cc *, \
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
void *, off_t, off_t, const struct puffs_cred *); \
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 fsname##_node_remove(struct puffs_cc *, \
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
void *, void *, const struct puffs_cn *); \
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 fsname##_node_link(struct puffs_cc *, \
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
void *, void *, const struct puffs_cn *); \
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 fsname##_node_rename(struct puffs_cc *, \
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
void *, void *, const struct puffs_cn *, void *, void *, \
const struct puffs_cn *); \
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 fsname##_node_mkdir(struct puffs_cc *, \
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
void *, void **, const struct puffs_cn *, \
const struct vattr *); \
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 fsname##_node_rmdir(struct puffs_cc *, \
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
void *, void *, const struct puffs_cn *); \
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 fsname##_node_symlink(struct puffs_cc *, \
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
void *, void **, const struct puffs_cn *, \
const struct vattr *, const char *); \
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 fsname##_node_readdir(struct puffs_cc *, \
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
void *, struct dirent *, const struct puffs_cred *, \
off_t *, size_t *); \
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 fsname##_node_readlink(struct puffs_cc *, \
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
void *, const struct puffs_cred *, char *, size_t *); \
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 fsname##_node_reclaim(struct puffs_cc *, \
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
void *, pid_t); \
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 fsname##_node_inactive(struct puffs_cc *, \
handle PUFFS_VN_INACTIVE
2006-10-25 22:15:50 +04:00
void *, pid_t, 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
int fsname##_node_print(struct puffs_cc *, \
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
void *); \
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 fsname##_node_pathconf(struct puffs_cc *, \
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
void *, 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
int fsname##_node_advlock(struct puffs_cc *, \
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
void *, void *, int, struct flock *, 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
int fsname##_node_getextattr(struct puffs_cc *, \
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
void *, struct puffs_vnreq_getextattr *); \
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 fsname##_node_setextattr(struct puffs_cc *, \
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
void *, struct puffs_vnreq_setextattr *); \
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 fsname##_node_listextattr(struct puffs_cc *, \
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
void *, struct puffs_vnreq_listextattr *); \
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 fsname##_node_read(struct puffs_cc *, void *, \
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);\
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 fsname##_node_write(struct puffs_cc *, void *, \
initial support for cacheops
2007-03-20 13:22:22 +03:00
uint8_t *, off_t, size_t *, const struct puffs_cred *, int);\
\
int fsname##_cache_write(struct puffs_usermount *, void *, \
size_t, struct puffs_cacheinfo *);
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
initial support for cacheops
2007-03-20 13:22:22 +03:00
#define PUFFS_DEVEL_LIBVERSION 9
* inform kernel of our version * homegrown lib ABI check (to avoid bumping major a ludicrillion times before reaching stability)
2007-01-02 18:53:05 +03:00
#define puffs_mount(a,b,c,d,e,f,g) \
_puffs_mount(PUFFS_DEVEL_LIBVERSION,a,b,c,d,e,f,g)
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
#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
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
* inform kernel of our version * homegrown lib ABI check (to avoid bumping major a ludicrillion times before reaching stability)
2007-01-02 18:53:05 +03:00
struct puffs_usermount *_puffs_mount(int, struct puffs_ops *, const char *, 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
const char *, void *, uint32_t, size_t);
* 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_start(struct puffs_usermount *, void *, struct statvfs *);
int puffs_exit(struct puffs_usermount *, 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
int puffs_mainloop(struct puffs_usermount *, int);
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);
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 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 *);
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 *);
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 *);
* 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
*/
int puffs_fsnop_unmount(struct puffs_cc *, int, pid_t);
int puffs_fsnop_statvfs(struct puffs_cc *, struct statvfs *, pid_t);
void puffs_zerostatvfs(struct statvfs *);
int puffs_fsnop_sync(struct puffs_cc *, int waitfor,
const struct puffs_cred *, pid_t);
int puffs_genfs_node_reclaim(struct puffs_cc *, void *, pid_t);
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 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
/*
* Requests
*/
be consistent in naming request handlers
2007-01-20 16:52:14 +03:00
struct puffs_getreq *puffs_req_makeget(struct puffs_usermount *,
size_t, int);
int puffs_req_loadget(struct puffs_getreq *);
struct puffs_req *puffs_req_get(struct puffs_getreq *);
int puffs_req_remainingget(struct puffs_getreq *);
void puffs_req_setmaxget(struct puffs_getreq *, int);
void puffs_req_destroyget(struct puffs_getreq *);
struct puffs_putreq *puffs_req_makeput(struct puffs_usermount *);
void puffs_req_put(struct puffs_putreq *,struct puffs_req *);
void puffs_req_putcc(struct puffs_putreq *,struct puffs_cc*);
int puffs_req_putput(struct puffs_putreq *);
void puffs_req_resetput(struct puffs_putreq *);
void puffs_req_destroyput(struct puffs_putreq *);
int puffs_req_handle(struct puffs_usermount *,
struct puffs_getreq *,
struct puffs_putreq *, 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
/*
* Call Context interfaces relevant for user.
*/
void puffs_cc_yield(struct puffs_cc *);
void puffs_cc_continue(struct puffs_cc *);
struct puffs_usermount *puffs_cc_getusermount(struct puffs_cc *);
* 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
struct puffs_cc *puffs_cc_create(struct puffs_usermount *);
void puffs_cc_destroy(struct puffs_cc *);
checkpoint some experimental work-in-progress, namely: Add support for having multiple outstanding operations. This is done by exposing enough interfaces so that it is convenient to have the main event loop in the implementation itself and by providing a continuation framework for convinient blocking and rescheduling. works fine, but will undergo further cleanup & development
2006-12-29 18:28:11 +03:00
/*
* Execute or continue a request
*/
Be consistent with the rest of the framework about the argument order of puffs_docc and puffs_dopreq
2007-01-20 17:37:06 +03:00
int puffs_dopreq(struct puffs_usermount *, struct puffs_req *,
struct puffs_putreq *);
int puffs_docc(struct puffs_cc *, struct puffs_putreq *);
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
*/
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_dir(struct puffs_usermount *, void *);
int puffs_inval_namecache_all(struct puffs_usermount *);
lib interface for invalidation routines
2007-01-09 21:15:08 +03:00
initial support for cacheops
2007-03-20 13:22:22 +03:00
int puffs_inval_pagecache_node(struct puffs_usermount *, 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
/*
* 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 *);
void puffs_set_pathbuild(struct puffs_usermount *, pu_pathbuild_fn);
void puffs_set_pathtransform(struct puffs_usermount *, pu_pathtransform_fn);
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 interfaces for suspending the file system
2007-01-27 02:00:33 +03:00
/*
* Suspension
*/
int puffs_fs_suspend(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
__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_ */