*** empty log message ***

1 files changed, 401 insertions, 0 deletions

diff --git a/libtreefs/treefs-hooks.h b/libtreefs/treefs-hooks.h
new file mode 100644
index 00000000..3af4a546
--- /dev/null
+++ b/libtreefs/treefs-hooks.h
@@ -0,0 +1,401 @@
+/* Hooks in libtreefs (also see "treefs-s-hooks.h")
+
+   Copyright (C) 1995 Free Software Foundation, Inc.
+
+   Written by Miles Bader <miles@gnu.ai.mit.edu>
+
+   This file is part of the GNU Hurd.
+
+   The GNU Hurd is free software; you can redistribute it and/or
+   modify it under the terms of the GNU General Public License as
+   published by the Free Software Foundation; either version 2, or (at
+   your option) any later version.
+
+   The GNU Hurd is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+#ifndef __TREEFS_HOOKS_H__
+#define __TREEFS_HOOKS_H__
+
+#include "treefs.h"
+
+/* ---------------------------------------------------------------- */
+
+/* Hook indices */
+enum
+{
+  /* file rpcs */
+  TREEFS_HOOK_S_FILE_EXEC, TREEFS_HOOK_S_FILE_CHOWN,
+  TREEFS_HOOK_S_FILE_CHAUTHOR, TREEFS_HOOK_S_FILE_CHMOD,
+  TREEFS_HOOK_S_FILE_CHFLAGS, TREEFS_HOOK_S_FILE_UTIMES,
+  TREEFS_HOOK_S_FILE_SET_SIZE, TREEFS_HOOK_S_FILE_LOCK,
+  TREEFS_HOOK_S_FILE_LOCK_STAT, TREEFS_HOOK_S_FILE_ACCESS,
+  TREEFS_HOOK_S_FILE_NOTICE, TREEFS_HOOK_S_FILE_SYNC,
+  TREEFS_HOOK_S_FILE_GET_LINK_NODE,
+
+  /* io rpcs */
+  TREEFS_HOOK_S_IO_WRITE, TREEFS_HOOK_S_IO_READ, TREEFS_HOOK_S_IO_SEEK,
+  TREEFS_HOOK_S_IO_READABLE, TREEFS_HOOK_S_IO_SET_ALL_OPENMODES,
+  TREEFS_HOOK_S_IO_GET_OPENMODES, TREEFS_HOOK_S_IO_SET_SOME_OPENMODES,
+  TREEFS_HOOK_S_IO_CLEAR_SOME_OPENMODES, TREEFS_HOOK_S_IO_ASYNC,
+  TREEFS_HOOK_S_IO_MOD_OWNER, TREEFS_HOOK_S_IO_GET_OWNER,
+  TREEFS_HOOK_S_IO_GET_ICKY_ASYNC_ID, TREEFS_HOOK_S_IO_SELECT,
+  TREEFS_HOOK_S_IO_STAT, TREEFS_HOOK_S_IO_REAUTHENTICATE,
+  TREEFS_HOOK_S_IO_RESTRICT_AUTH, TREEFS_HOOK_S_IO_DUPLICATE,
+  TREEFS_HOOK_S_IO_SERVER_VERSION, TREEFS_HOOK_S_IO_MAP,
+  TREEFS_HOOK_S_IO_MAP_CNTL, TREEFS_HOOK_S_IO_RELEASE_CONCH,
+  TREEFS_HOOK_S_IO_EOFNOTIFY, TREEFS_HOOK_S_IO_PRENOTIFY,
+  TREEFS_HOOK_S_IO_POSTNOTIFY, TREEFS_HOOK_S_IO_READNOTIFY,
+  TREEFS_HOOK_S_IO_READSLEEP, TREEFS_HOOK_S_IO_SIGIO,
+
+  /* directory rpcs */
+  TREEFS_HOOK_S_DIR_LOOKUP, TREEFS_HOOK_S_DIR_READDIR, TREEFS_HOOK_S_DIR_MKDIR,
+  TREEFS_HOOK_S_DIR_RMDIR, TREEFS_HOOK_S_DIR_UNLINK, TREEFS_HOOK_S_DIR_LINK,
+  TREEFS_HOOK_S_DIR_RENAME, TREEFS_HOOK_S_DIR_MKFILE,
+  TREEFS_HOOK_S_DIR_NOTICE_CHANGES,
+
+  /* filesystem rpcs */
+  TREEFS_HOOK_S_FSYS_GETROOT, TREEFS_HOOK_S_FSYS_SET_OPTIONS,
+  TREEFS_HOOK_S_FSYS_SYNCFS, TREEFS_HOOK_S_FSYS_GETFILE, TREEFS_S_FSYS_GOAWAY,
+
+  /* Non-rpc fsys hooks */
+  TREEFS_HOOK_FSYS_CREATE_NODE, TREEFS_HOOK_FSYS_DESTROY_NODE,
+  TREEFS_HOOK_FSYS_GET_ROOT,
+
+  /* Node hooks */
+  TREEFS_HOOK_NODE_TYPE,
+  TREEFS_HOOK_NODE_UNLINKED, TREEFS_HOOK_NODE_MOD_LINK_COUNT,
+  TREEFS_HOOK_DIR_LOOKUP, TREEFS_HOOK_DIR_NOENT,
+  TREEFS_HOOK_DIR_CREATE_CHILD, TREEFS_HOOK_DIR_LINK, TREEFS_HOOK_DIR_UNLINK,
+  TREEFS_HOOK_NODE_OWNED, TREEFS_HOOK_NODE_ACCESS,
+  TREEFS_HOOK_NODE_GET_SYMLINK, TREEFS_HOOK_NODE_GET_PASSIVE_TRANS,
+  TREEFS_HOOK_NODE_START_TRANSLATOR, TREEFS_HOOK_NODE_GET_TRANS_AUTH,
+  TREEFS_HOOK_NODE_DROP, TREEFS_HOOK_NODE_INIT, TREEFS_HOOK_DIR_INIT,
+  TREEFS_HOOK_NODE_INIT_PEROPEN, TREEFS_HOOK_NODE_INIT_HANDLE,
+  TREEFS_HOOK_NODE_FINALIZE, TREEFS_HOOK_DIR_FINALIZE,
+  TREEFS_HOOK_NODE_FINALIZE_PEROPEN, TREEFS_HOOK_NODE_FINALIZE_HANDLE,
+
+  /* Reference counting support */
+  TREEFS_HOOK_NODE_NEW_REFS, TREEFS_HOOK_NODE_LOST_REFS,
+  TREEFS_HOOK_NODE_TRY_DROPPING_WEAK_REFS,
+
+  TREEFS_NUM_HOOKS
+};
+
+/* ---------------------------------------------------------------- */
+/* Hook calling/defining macros */
+
+/* Call the hook number HOOK in the hook vector HOOKS, whose function is of
+   type TYPE, with the args ARGS (my this is a useful comment).  */
+#define TREEFS_CALL_HOOK(hooks, hook, type, args...) \
+  ((type *)(hooks)[hook])(args)
+#define TREEFS_CALL_HANDLE_HOOK(h, hook, type, args...) \
+  ({struct treefs_handle *_tfs_cn_h = (h); \
+    TREEFS_CALL_HOOK(_tfs_cn_h->po->node->hooks,hook,type, \
+		     _tfs_cn_h , ##args);})
+#define TREEFS_CALL_NODE_HOOK(node, hook, type, args...) \
+  ({struct treefs_node *_tfs_cn_node = (node); \
+    TREEFS_CALL_HOOK(_tfs_cn_node->hooks,hook,type, _tfs_cn_node , ##args);})
+#define TREEFS_CALL_FSYS_HOOK(fsys, hook, type, args...) \
+  ({struct treefs_fsys *_tfs_cn_fsys = (fsys); \
+    TREEFS_CALL_HOOK(_tfs_cn_fsys->hooks,hook,type, _tfs_cn_fsys , ##args);})
+
+/* Shorthand form of TREEFS_CALL_*_HOOK (only used here).  */
+#define _TREEFS_CHH(h, hook_id, type_id, args...) \
+  TREEFS_CALL_HANDLE_HOOK(h, TREEFS_HOOK_##hook_id, treefs_##type_id##_t , ##args)
+#define _TREEFS_CNH(node, hook_id, type_id, args...) \
+  TREEFS_CALL_NODE_HOOK(node, TREEFS_HOOK_##hook_id, treefs_##type_id##_t , ##args)
+#define _TREEFS_CFH(fsys, hook_id, type_id, args...) \
+  TREEFS_CALL_FSYS_HOOK(fsys, TREEFS_HOOK_##hook_id, treefs_##type_id##_t , ##args)
+
+/* Forward declare some structures used before definition.  */
+struct treefs_node;
+struct treefs_fsys;
+struct treefs_auth;
+struct treefs_handle;
+struct treefs_peropen;
+
+/* Shorthand for declaring the various hook types (each hook has an
+   associated type so that a user can type-check his hook routine).  */
+#define DNH(name_sym, ret_type, argtypes...) \
+  typedef ret_type treefs_##name_sym##_t (struct treefs_node * , ##argtypes);
+#define DFH(name_sym, ret_type, argtypes...) \
+  typedef ret_type treefs_##name_sym##_t (struct treefs_fsys * , ##argtypes);
+
+/* ---------------------------------------------------------------- */
+/* Non RPC hooks */
+
+/* Called to get the root node of the a filesystem, with a reference,
+   returning it in ROOT, or return an error if it can't be had.  The default
+   hook just returns FSYS->root or an error if it's NULL.  Note that despite
+   the similar name, this is very different from fsys_s_getroot!  FSYS must
+   not be locked.  */
+DFH(fsys_get_root, error_t, struct treefs_node **root)
+#define treefs_fsys_get_root(fsys, args...) \
+  _TREEFS_CFH(fsys, FSYS_GET_ROOT, fsys_get_root , ##args)
+
+/* Called on a filesystem to create a new node in that filesystem, returning
+   it, with one reference, in NODE.  DIR, if non-NULL, is the nominal parent
+   directory, and MODE and AUTH are the desired mode and user info
+   respectively.  This hook should also call node_init_stat & node_init to
+   initialize the various user bits.  */
+DFH(fsys_create_node, error_t,
+    struct treefs_node *dir, mode_t mode, struct treefs_auth *auth,
+    struct treefs_node **node)
+#define treefs_fsys_create_node(fsys, args...) \
+  _TREEFS_CFH(fsys, FSYS_CREATE_NODE, fsys_create_node , ##args)
+
+/* Called on a filesystem to destroy a node in that filesystem.  This call
+   should *really* destroy it -- i.e., it's only called once all references
+   are gone.  */
+DFH(fsys_destroy_node, void, struct treefs_node *node)
+#define treefs_fsys_destroy_node(fsys, node) \
+  _TREEFS_CFH(fsys, FSYS_DESTROY_NODE, fsys_destroy_node , ##args)
+
+/* Returns the type of NODE, as an S_IFMT value (e.g., S_IFDIR).  The
+   default routine just looks at NODE's stat mode.  */
+DNH(node_type, int);
+#define treefs_node_type(node, args...)					      \
+  _TREEFS_CNH(node, NODE_TYPE, node_type , ##args)
+
+#define treefs_node_isdir(node) (treefs_node_type(node) == S_IFDIR)
+#define treefs_node_isreg(node) (treefs_node_type(node) == S_IFREG)
+
+/* Return TRUE if NODE is `unlinked' -- that is, can be deleted when all
+   (in-memory) references go away.  */
+DNH(node_unlinked, int);
+#define treefs_node_unlinked(node, args...)				      \
+  _TREEFS_CNH(node, NODE_UNLINKED, node_unlinked , ##args)
+
+/* Changes the link count of NODE by CHANGE; if any error is returned, the
+   operation trying to change the link count will fail, so filesystems that
+   don't support real links can restrict it to 1 or 0.  This is mostly used
+   by the in-core directory code when it makes a link.  The default hook uses
+   the link field of NODE's stat entry.  */
+DNH(node_mod_link_count, error_t, int change);
+#define treefs_node_mod_link_count(node, args...) \
+  _TREEFS_CNH(node, NODE_MOD_LINK_COUNT, node_mod_link_count , ##args)
+
+/* Lookup NAME in NODE, returning the result in CHILD; AUTH should be used to
+   do authentication.  If FLAGS contains O_CREAT, and NAME is not found, then
+   an entry should be created with a mode of CREATE_MODE (which includes the
+   S_IFMT bits, e.g., S_IFREG means a normal file), unless O_EXCL is also
+   set, in which case EEXIST should be returned.  Possible special errors
+   returned include: EAGAIN -- result would be the parent of our filesystem
+   root.  Note that is a single-level lookup, unlike treefs_s_dir_lookup.  */
+DNH(dir_lookup, error_t,
+    char *name, struct treefs_auth *auth, int flags, int create_mode,
+    struct treefs_node **child)
+#define treefs_dir_lookup(dir, args...)				      \
+  _TREEFS_CNH(dir, DIR_LOOKUP, dir_lookup , ##args)
+
+/* Called by the default implementation of treefs_dir_lookup (and possibly
+   user-versions as well) when a directory lookup returns ENOENT, before a
+   new node is created.  This hook may return the desire node in CHILD and
+   return 0, or return an error code.  Note that a returned node need not
+   actually be in the directory DIR, and indeed may be anonymous.  */
+DNH(dir_noent, error_t,
+    char *name, struct treefs_auth *auth, int flags, int create_mode,
+    struct treefs_node **child);
+#define treefs_dir_noent(dir, args...)				      \
+  _TREEFS_CNH(dir, DIR_NOENT, dir_noent , ##args)
+
+/* Return in CHILD a new node with one reference, presumably a possible child
+   of DIR, with a mode MODE.  All attempts to create a new node go through
+   this hook, so it may be overridden to easily control creation (e.g.,
+   replacing it with a hook that always returns EPERM).  Note that this
+   routine doesn't actually enter the child into the directory, or give the
+   node a non-zero link count, that should be done by the caller.  */
+DNH(dir_create_child, error_t,
+    mode_t mode, struct treefs_auth *auth, struct treefs_node **child);
+#define treefs_dir_create_child(dir, args...)				      \
+  _TREEFS_CNH(dir, DIR_CREATE_CHILD, dir_create_child , ##args)
+
+/* Link the node CHILD into DIR as NAME, using AUTH to check authentication.
+   DIR should be locked and CHILD shouldn't be.  The default hook puts it
+   into DIR's in-core directory, and uses a reference to CHILD (this way, a
+   node can be linked to both in-core and out-of-core directories and the
+   permanent link-count will be right).  */
+DNH(dir_link, error_t,
+    char *name, struct treefs_node *child, struct treefs_auth *auth)
+#define treefs_dir_link(dir, args...) \
+  _TREEFS_CNH(dir, DIR_LINK, dir_link , ##args)
+
+/* Remove the entry NAME from DIR, using AUTH to check authentication.  DIR
+   should be locked.  The default hook removes NAME from DIR's in-core
+   directory.  */
+DNH(dir_unlink, error_t, char *name, struct treefs_auth *auth)
+#define treefs_dir_unlink(dir, args...) \
+  _TREEFS_CNH(dir, DIR_UNLINK, dir_unlink , ##args)
+
+/* Check to see if the user identified by AUTH is permitted to do owner-only
+   operations on node NP; if so, return 0; if not, return EPERM. */
+DNH(node_owned, error_t, struct treefs_auth *auth)
+#define treefs_node_owned(node, args...) \
+  _TREEFS_CNH(node, NODE_OWNED, node_owned , ##args)
+
+/* Check to see is the user identified by AUTH is permitted to do 
+   operation OP on node NP.  Op is one of S_IREAD, S_IWRITE, or S_IEXEC.
+   Return 0 if the operation is permitted and EACCES if not. */
+DNH(node_access, error_t, int opt, struct treefs_auth *auth)
+#define treefs_node_access(node, args...) \
+  _TREEFS_CNH(node, NODE_ACCESS, node_access , ##args)
+
+/* NODE now has no more references; clean all state.  The
+   _treefs_node_refcnt_lock must be held, and will be released upon return.
+   NODE must be locked.  */
+DNH(node_drop, error_t);
+#define treefs_node_drop(node, args...)					      \
+  _TREEFS_CNH(node, NODE_DROP, node_drop , ##args)
+
+/* Called when a new directory is created, after trees_node_init.  If this
+   routine returns an error, the new node will be destroyed and the create
+   will fail.  */
+DNH(dir_init, error_t)
+#define treefs_dir_init(dir, args...)					      \
+  _TREEFS_CNH(dir, DIR_INIT, dir_init , ##args)
+
+/* If NODE is a symlink, copies the contents into BUF, which should have at
+   least *LEN bytes available, and returns 0; if the symlink is too big,
+   E2BIG is returned.  Either way, the actual length of the symlink is
+   returned in *LEN (so if it's too big, you can allocate an appropiately
+   sized buffer and try again).  If NODE is not a symlink, EINVAL is
+   returned.  */
+DNH(node_get_symlink, error_t, char *buf, int *len)
+#define treefs_node_get_symlink(node, args...)				      \
+  _TREEFS_CNH(node, NODE_GET_SYMLINK, node_get_symlink , ##args)
+
+/* If NODE has a passive translator, copies the contents into BUF, which
+   should have at least *LEN bytes available, and returns 0; if the string is
+   too big, E2BIG is returned.  Either way, the actual length of the
+   translator string is returned in *LEN (so if it's too big, you can
+   allocate an appropiately sized buffer and try again).  If NODE has no
+   passive translator, EINVAL is returned.  */
+DNH(node_get_passive_trans, error_t, char *buf, int *len)
+#define treefs_node_get_passive_trans(node, args...)			      \
+  _TREEFS_CNH(node, NODE_GET_PASSIVE_TRANS, node_get_passive_trans , ##args)
+
+/* Returns the user and group that a newly started translator should be
+   authenticated as.  The default just returns the owner/group of NODE.  */
+DNH(node_get_trans_auth, error_t, uid_t *uid, gid_t *gid)
+#define treefs_node_get_trans_auth(node, args...)			      \
+  _TREEFS_CNH(node, NODE_GET_TRANS_AUTH, node_get_trans_auth , ##args)
+
+/* Start the translator TRANS (of length TRANS_LEN) on NODE, which should be
+   locked, and will be unlocked during the execution of this function.
+   PARENT_PORT should be a send right to use as the parent port passed to the
+   translator.  */
+DNH(node_start_translator, error_t,
+    char *trans, unsigned trans_len, file_t parent_port)
+#define treefs_node_start_translator(node, args...)			      \
+  _TREEFS_CNH(node, NODE_START_TRANSLATOR, node_start_translator , ##args)
+
+/* Called to initialize a new node's stat entry, after all default fields are
+   filled in (but before node_init is called).  */ 
+DNH(node_init_stat, error_t, 
+    struct treefs_node *dir, mode_t mode, struct treefs_auth *auth)
+#define treefs_node_init_stat(node, args...) \
+  _TREEFS_CNH(node, NODE_INIT_STAT, node_init_stat , ##args)
+
+/* Called to initialize a new node, after all default fields are filled in.
+   If this routine returns an error, the new node will be destroyed and the
+   create will fail.  */
+DNH(node_init, error_t, 
+    struct treefs_node *dir, mode_t mode, struct treefs_auth *auth)
+#define treefs_node_init(node, args...) \
+  _TREEFS_CNH(node, NODE_INIT, node_init , ##args)
+
+/* Called to cleanup node-specific info in a node about to be destroyed.  */
+DNH(node_finalize, void)
+#define treefs_node_finalize(node, args...) \
+  _TREEFS_CNH(node, NODE_FINALIZE, node_finalize , ##args)
+
+/* Called to cleanup node-specific directory info in a node about to be
+   destroyed.  Called before node_finalize.  */
+DNH(dir_finalize, void)
+#define treefs_dir_finalize(dir, args...) \
+  _TREEFS_CNH(dir, DIR_FINALIZE, dir_finalize , ##args)
+
+/* Called when the new peropen structure PO is made for NODE, with the
+   authorization in AUTH, opened with the flags FLAGS (note that this a copy
+   of PO->flags, which the hook may modify).  If an error is returned, the
+   open will fail with that error.  The default hook does explicit checks
+   against AUTH using treefs_node_access, and otherwise does nothing.  */
+DNH(node_init_peropen, error_t,
+    struct treefs_peropen *po, int flags, struct treefs_auth *auth)
+#define treefs_node_init_peropen(node, args...) 			      \
+  _TREEFS_CNH(node, NODE_INIT_PEROPEN, node_init_peropen , ##args)
+
+/* Called the peropen structure PO for NODE is being destroyed.  */
+DNH(node_finalize_peropen, void, struct treefs_peropen *po)
+#define treefs_node_finalize_peropen(node, args...) 			      \
+  _TREEFS_CNH(node, NODE_FINALIZE_PEROPEN, node_finalize_peropen , ##args)
+
+/* Called when a new handle structure is made for a node.  The default does
+   nothing.  */
+DNH(node_init_handle, void, struct treefs_handle *handle)
+#define treefs_node_init_handle(node, args...)				      \
+  _TREEFS_CNH(node, NODE_INIT_HANDLE, node_init_handle , ##args)
+
+/* Called when the handle HANDLE for NODE is being destroyed.  */
+DNH(node_finalize_handle, void, struct treefs_handle *handle)
+#define treefs_node_finalize_handle(node, args...) 			      \
+  _TREEFS_CNH(node, NODE_FINALIZE_HANDLE, node_finalize_handle , ##args)
+
+/* ---------------------------------------------------------------- */
+/* Ref counting stuff */
+
+/* NODE has just acquired a hard reference where it had none previously.  It
+   is thus now OK again to have weak references without real users.  NODE is
+   locked. */
+DNH(node_new_refs, void);
+#define treefs_node_new_refs(node, args...)				      \
+  _TREEFS_CNH(node, NODE_NEW_REFS, node_new_refs , ##args)
+
+/* NODE has some weak references but has just lost its last hard reference.
+   NP is locked.  */
+DNH(node_lost_refs, void);
+#define treefs_node_lost_refs(node, args...)				      \
+  _TREEFS_CNH(node, NODE_LOST_REFS, node_lost_refs , ##args)
+
+/* NODE has some weak references, but has just lost its last hard references.
+   Take steps so that if any weak references can be freed, they are.  NP is
+   locked as is the pager refcount lock.  This function will be called after
+   treefs_node_lost_refs.  */
+DNH(node_try_dropping_weak_refs, void);
+#define treefs_node_try_dropping_weak_refs(node, args...)		      \
+  _TREEFS_CNH(node, NODE_TRY_DROPPING_WEAK_REFS, node_try_dropping_weak_refs , ##args)
+
+/* Turn off our shorthand notation.  */
+#undef DNH
+#undef DFH
+
+/* ---------------------------------------------------------------- */
+/* Default routines for some hooks (each is the default value for the hook
+   with the same name minus the leading underscore).  When you add something
+   here, you should also add it to the initialize code in defhooks.c.  */
+
+treefs_fsys_create_node_t _treefs_fsys_create_node;
+treefs_fsys_destroy_node_t _treefs_fsys_destroy_node;
+treefs_fsys_get_root_t _treefs_fsys_get_root;
+treefs_node_type_t _treefs_node_type;
+treefs_node_unlinked_t _treefs_node_unlinked;
+treefs_node_mod_link_count_t _treefs_node_mod_link_count;
+treefs_node_mod_link_count_t _treefs_mod_link_count;
+treefs_dir_lookup_t _treefs_dir_lookup;
+treefs_dir_noent_t _treefs_dir_noent;
+treefs_dir_create_child_t _treefs_dir_create_child;
+treefs_dir_link_t _treefs_dir_link;
+treefs_dir_unlink_t _treefs_dir_unlink;
+treefs_node_owned_t _treefs_node_owned;
+treefs_node_access_t _treefs_node_access;
+treefs_node_start_translator_t _treefs_node_start_translator;
+treefs_node_get_trans_auth_t _treefs_node_get_trans_auth;
+
+#endif /* __TREEFS_HOOKS_H__ */