diff options
| -rw-r--r-- | libdiskfs/diskfs.h | 775 |
1 files changed, 775 insertions, 0 deletions
diff --git a/libdiskfs/diskfs.h b/libdiskfs/diskfs.h new file mode 100644 index 00000000..70af633f --- /dev/null +++ b/libdiskfs/diskfs.h @@ -0,0 +1,775 @@ +/* Definitions for fileserver helper functions + Copyright (C) 1994 Free Software Foundation + + This program 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. + + This program 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 _HURD_DISKFS +#define _HURD_DISKFS + +#ifdef MAKING_DISKFS +#include "../machine/diskfs_machdep.h" +#else +#include <hurd/machine/diskfs_machdep.h> +#endif + +/* Each user port referring to a file points to one of these + (with the aid of the ports library. */ +struct protid +{ + struct port_info pi; /* libports info block */ + + /* User identification */ + uid_t *uids, *gids; + int nuids, ngids; + + /* Object this refers to */ + struct peropen *po; + + /* Shared memory I/O information. */ + memory_object_t shared_object; + struct shared_io *mapped; +}; + +/* One of these is created for each node opened by dir_pathtrans. */ +struct peropen +{ + int filepointer; + int lock_status; + int refcnt; + int openstat; + struct node *np; +}; + +/* A unique one of these exists for each node currently in use (and + possibly for some not currently in use, but with links) in the + filesystem. */ +struct node +{ + struct node *next, **prevp; + + struct disknode *dn; + + struct stat dn_stat; + + /* Stat has been modified if one of the following four fields + is nonzero. Also, if one of the dn_set_?time fields is nonzero, + the appropriate dn_stat.st_?time field needs to be updated. */ + int dn_set_ctime; + int dn_set_atime; + int dn_set_mtime; + int dn_stat_dirty; + + struct mutex lock; + + int references; /* hard references */ + int light_references; /* light references */ + + int owner; + + struct trans_link translator; + + struct lock_box userlock; + + struct conch conch; + + off_t allocsize; +}; + +/* Possibly lookup types for diskfs_lookup call */ +enum lookup_type +{ + LOOKUP, + CREATE, + REMOVE, + RENAME, +}; + +/* Special flag for diskfs_lookup. */ +#define SPEC_DOTDOT 0x10000000 + + +/* Declarations of variables the library sets. */ + +extern mach_port_t diskfs_host_priv; /* send right */ +extern mach_port_t diskfs_master_device; /* send right */ +extern mach_port_t diskfs_default_pager; /* send right */ +extern mach_port_t diskfs_exec_ctl; /* send right */ +extern mach_port_t diskfs_exec; /* send right */ +extern auth_t diskfs_auth_server_port; /* send right */ + + +extern struct port_info *diskfs_control_port; + +extern volatile struct mapped_time_value *diskfs_mtime; + +extern int diskfs_bootflags; +extern char *diskfs_bootflagarg; + +extern spin_lock_t diskfs_node_refcnt_lock; + +extern int pager_port_type; + + +struct pager; + + + +/* Declarations of things the user must or may define. */ + +/* The user must define this type. This should hold information + between calls to diskfs_lookup and diskfs_dir{enter,rewrite,rename} + so that those calls work as described below. */ +struct dirstat; + +/* The user must define this variable; it should be the size in bytes + of a struct dirstat. */ +extern size_t diskfs_dirstat_size; + +/* The user must define this variable; it is the maximum number of + links to any one file. The implementation of dir_rename does not know + how to succeed if this is only one; on such formats you need to + reimplement dir_rename yourself. */ +extern int diskfs_link_max; + +/* The user must define this variable; it is the maximum number of + symlinks to be traversed within a single call to dir_pathtrans. + If this is exceeded, dir_pathtrans will return ELOOP. */ +extern int diskfs_maxsymlinks; + +/* The user must define this variable and set it if the filesystem + should be readonly. */ +extern int diskfs_readonly; + +/* The user must define this variable. Set this to be an unauthenticated + port to the directory which should be `..' from root. If this is + *the* root, then set this to MACH_PORT_NULL. */ +extern file_t diskfs_dotdot_file; + +/* The user must define this variable. Set this to be the node + of root of the filesystem. */ +extern struct node *diskfs_root_node; + +/* The user must define this variable. Set this to the name of the + filesystem server. */ +extern char *diskfs_server_name; + +/* The user must define these variables. Set these to be the major, minor, + and edit version numbers. */ +extern int diskfs_major_version; +extern int diskfs_minor_version; +extern int diskfs_edit_version; + +/* The user may define this variable. This should be nonzero iff the + filesystem format supports shortcutting symlink translation. */ +int diskfs_shortcut_symlink; + +/* The user may define this variable. This should be nonzero iff the + filesystem format supports shortcutting chrdev translation. */ +int diskfs_shortcut_chrdev; + +/* The user may define this variable. This should be nonzero iff the + filesystem format supports shortcutting blkdev translation. */ +int diskfs_shortcut_blkdev; + +/* The user may define this variable. This should be nonzero iff the + filesystem format supports shortcutting fifo translation. */ +int diskfs_shortcut_fifo; + +/* The user may define this variable. This should be nonzero iff the + filesystem format supports shortcutting ifsock translation. */ +int diskfs_shortcut_ifsock; + +/* The user must define this function. Set *STATFSBUF with + appropriate values to reflect the current state of the filesystem. */ +error_t diskfs_set_statfs (fsys_statfsbuf_t *statfsbuf); + +/* The user must define this function. Lookup in directory DP (which + is locked) the name NAME. TYPE will either be LOOKUP, CREATE, + RENAME, or REMOVE. CRED identifies the user making the call. + + If the name is found, return zero, and (if NP is nonzero) set *NP + to point to the node for it, locked. If the name is not found, + return ENOENT, and (if NP is nonzero) set *NP to zero. + + If DS is nonzero then: + For LOOKUP: set *DS to be ignored by diskfs_drop_dirstat. + For CREATE: on success, set *DS to be ignored by diskfs_drop_dirstat. + on failure, set *DS for a future call to diskfs_direnter. + For RENAME: on success, set *DS for a future call to diskfs_dirrewrite. + on failure, set *DS for a future call to diskfs_direnter. + For REMOVE: on success, set *DS for a future call to diskfs_dirremove. + on failure, set *DS to be ignored by diskfs_drop_dirstat. + The caller of this function guarantees that if DS is nonzero, then + either the appropriate call listed above or diskfs_drop_dirstat will + be called with DS before the directory DP is unlocked, and guarantees + that no lookup calls will be made on this directory between this + lookup and the use (or descruction) of *DS. + + If you use the library's versions of diskfs_rename_dir, + diskfs_clear_directory, and diskfs_init_dir, then lookups for `..' + might have the flag SPEC_DOTDOT or'd in. This has the following special + meaning: + For LOOKUP: DP should be unlocked and its reference dropped before + returning. + For RENAME and REMOVE: The node being found (*NP) is already held + locked, so don't lock it or add a reference to it. + (SPEC_DOTDOT will not be given with CREATE.) + + Return ENOTDIR if DP is not a directory. + Return EACCES if CRED isn't allowed to search DP. + Return EACCES if completing the operation will require writing + the directory and diskfs_checkdirmod won't allow the modification. + Return ENOENT if NAME isn't in the directory. + Return EAGAIN if NAME refers to the `..' of this filesystem's root. + Return EIO if appropriate. +*/ +error_t diskfs_lookup (struct node *dp, char *name, enum lookup_type type, + struct node **np, struct dirstat *ds, + struct protid *cred); + +/* The user must define this function. Add NP to directory DP + under the name NAME. This will only be called after an + unsuccessful call to diskfs_lookup of type CREATE or RENAME; DP + has been locked continuously since that call and DS is as that call + set it, NP is locked. CRED identifies the user responsible + for the call (to be used only to validate directory growth). */ +error_t diskfs_direnter (struct node *dp, char *name, + struct node *np, struct dirstat *ds, + struct protid *cred); + +/* The user must define this function. This will only be called after + a successful call to diskfs_lookup of type RENAME; this call should change + the name found in directory DP to point to node NP instead of its previous + referent. DP has been locked continuously since the call to diskfs_lookup + and DS is as that call set it; NP is locked. */ +error_t diskfs_dirrewrite (struct node *dp, struct node *np, + struct dirstat *ds); + +/* The user must define this function. This will only be called after a + successful call to diskfs_lookup of type REMOVE; this call should remove + the name found from the directory DS. DP has been locked continuously since + the call to diskfs_lookup and DS is as that call set it. */ +error_t diskfs_dirremove (struct node *dp, struct dirstat *ds); + +/* The user must define this function. DS has been set by a previous + call to diskfs_lookup on directory DP; this function is + guaranteed to be called if none of + diskfs_dir{enter,rename,rewrite} is, and should free any state + retained by a struct dirstat. DP has been locked continuously since + the call to diskfs_lookup. */ +error_t diskfs_drop_dirstat (struct node *dp, struct dirstat *ds); + +/* The user must define this function. For locked node NP, return nonzero + iff there is a translator program defined for the node. */ +int diskfs_node_translated (struct node *np); + +/* The user must define this function. For locked node NP (for which + diskfs_node_translated is true) look up the name of its translator. + If the length is <= *NAMELEN, then store the name into **NAMEP; otherwise + set *NAMEP to newly vm_allocate'd storage holding the name. Set + *NAMELEN to the length of the name. */ +error_t diskfs_get_translator (struct node *np, char **namep, u_int *namelen); + +/* The user must define this function. For locked node NP, set + the name of the translating program to be NAME, length NAMELEN. CRED + identifies the user responsible for the call. */ +error_t diskfs_set_translator (struct node *np, char *name, u_int namelen, + struct protid *cred); + +/* The user must define this function. Truncate locked node NP to be SIZE + bytes long. (If NP is already less than or equal to SIZE bytes + long, do nothing.) */ +error_t diskfs_truncate (struct node *np, off_t size); + +/* The user must define this function. Grow the disk allocated to locked node + NP to be at least SIZE bytes, and set NP->allocsize to the actual + allocated size. (If the allocated size is already SIZE bytes, do + nothing.) CRED identifies the user responsible for the call. */ +error_t diskfs_grow (struct node *np, off_t size, struct protid *cred); + +/* The user must define this function. Write to disk (synchronously + iff WAIT is nonzero) from format-specific buffers any non-paged + metadata. If CLEAN is nonzero, then after this is written the + filesystem will be absolutely clean, and the non-paged metadata can + so indicate. */ +void diskfs_set_hypermetadata (int wait, int clean); + +/* The user must define this function. Allocate a new node to be of + mode MODE in locked directory DP (don't actually set the mode or + modify the dir, that will be done by the caller); the user + responsible for the request can be identified with CRED. Set *NP + to be the newly allocated node. */ +error_t diskfs_alloc_node (struct node *dp, mode_t mode, struct node **np); + +/* Free node NP; the on disk copy has already been synced with + diskfs_node_update (where NP->dn_stat.st_mode was 0). It's + mode used to be MODE. */ +void diskfs_free_node (struct node *np, mode_t mode); + +/* Node NP has no more references; free local state, including *NP + if it isn't to be retained. diskfs_node_refcnt_lock is held. */ +void diskfs_node_norefs (struct node *np); + +/* The user must define this function. Node NP has some light + references, but has just lost its last hard references. Take steps + so that if any light references can be freed, they are. NP might + or might not be locked; this routine should not attempt to gain the lock. */ +void diskfs_lost_hardrefs (struct node *np); + +/* The user must define this function. Node NP has just acquired + a hard reference where it had none previously. It is thus now + OK again to have light references without real users. NP might or + might not be locked; this routine should not attempt to gain the lock. */ +void diskfs_new_hardrefs (struct node *np); + +/* The user must define this function. Return non-zero if locked + directory DP is empty. If the user does not redefine + diskfs_clear_directory and diskfs_init_directory, then `empty' + means `possesses entries labelled . and .. only'. CRED + identifies the user making the call (if this user can't search + the directory, then this routine should fail). */ +int diskfs_dirempty (struct node *dp, struct protid *cred); + +/* The user must define this function. Sync the info in NP->dn_stat + and any associated format-specific information to disk. If WAIT is true, + then return only after the physicial media has been completely updated. */ +void diskfs_write_disknode (struct node *np, int wait); + +/* The user must define this function. Sync the file contents and all + associated meta data of file NP to disk (generally this will involve + calling diskfs_node_update for much of the metadata). If WAIT is true, + then return only after the physical media has been completely updated. */ +void diskfs_file_update (struct node *np, int wait); + +/* The user must define this function. Sync all the pagers and any + data belonging on disk except for the hypermetadata. If WAIT is true, + then return only after the physicial media has been completely updated. */ +void diskfs_sync_everything (int wait); + +/* Shutdown all pagers; this is done when the filesystem is exiting and is + irreversable. */ +void diskfs_shutdown_pager (); + +/* The user must define this function. Return a memory object port (send + right) for the file contents of NP. */ +mach_port_t diskfs_get_filemap (struct node *np); + +/* The user must define this function. Return a `struct pager *' suitable + for use as an argument to diskfs_register_memory_fault_area that + refers to the pager returned by diskfs_get_filemap for node NP. */ +struct pager *diskfs_get_filemap_pager_struct (struct node *np); + +/* The user must define this function if she calls diskfs_start_bootstrap. + It is called by the library after the filesystem has a normal + environment (complete with auth and proc ports). */ +void diskfs_init_completed (); + +/* It is assumed that the user will use the Hurd pager library; if not + you need to redefine ports_demuxer and + diskfs_do_seqnos_mach_notify_no_senders. */ + +/* The library exports the following functions for general use */ + +/* Call this if the bootstrap port is null and you want to support + being a bootstrap filesystem. ARGC and ARGV should be as passed + to main. If the arguments are not in the proper format, an + error message will be printed on stderr and exit called. Otherwise, + diskfs_priv_host, diskfs_master_device, and diskfs_bootflags will be + set and the Mach kernel name of the bootstrap device will be + returned. */ +char *diskfs_parse_bootargs (int argc, char **argv); + +/* Call this after arguments have been parsed to initialize the + library. */ +void diskfs_init_diskfs (void); + +/* Call this after all format-specific initialization is done (except + for setting diskfs_root_node); at this point the pagers should be + ready to go. */ +void diskfs_spawn_first_thread (void); + +/* Once diskfs_root_node is set, call this if we are a bootstrap + filesystem. If you call this, then the library will call + diskfs_init_completed once it has a valid proc and auth port.*/ +void diskfs_start_bootstrap (void); + +/* Last step of init is to call this, which never returns. */ +void diskfs_main_request_loop (void); + +/* Node NP now has no more references; clean all state. The + _diskfs_node_refcnt_lock must be held, and will be released + upon return. NP must be locked. */ +void diskfs_drop_node (struct node *np); + +/* Set on disk fields from NP->dn_stat; update ctime, atime, and mtime + if necessary. If WAIT is true, then return only after the physical + media has been completely updated. */ +void diskfs_node_update (struct node *np, int wait); + +/* Add a hard reference to a node. */ +extern inline void +diskfs_nref (struct node *np) +{ + int new_hardref; + spin_lock (&diskfs_node_refcnt_lock); + np->references++; + new_hardref = (np->references == 1); + spin_unlock (&diskfs_node_refcnt_lock); + if (new_hardref) + diskfs_new_hardrefs (np); +} + +/* Unlock node NP and release a hard reference; if this is the last + hard reference and there are no links to the file then request + soft references to be dropped. */ +extern inline void +diskfs_nput (struct node *np) +{ + int nlinks; + + spin_lock (&diskfs_node_refcnt_lock); + np->references--; + if (np->references + np->light_references == 0) + diskfs_drop_node (np); + else if (np->references == 0) + { + spin_unlock (&diskfs_node_refcnt_lock); + nlinks = np->dn_stat.st_nlink; + mutex_unlock (&np->lock); + if (!nlinks) + diskfs_lost_hardrefs (np); + } + else + { + spin_unlock (&diskfs_node_refcnt_lock); + mutex_unlock (&np->lock); + } +} + +/* Release a hard reference on NP. If NP is locked by anyone, then + this cannot be the last hard reference (because you must hold a + hard reference in order to hold the lock). If this is the last + hard reference and there are no links, then request soft references + to be dropped. */ +extern inline void +diskfs_nrele (struct node *np) +{ + int nlinks; + + spin_lock (&diskfs_node_refcnt_lock); + np->references--; + if (np->references + np->light_references == 0) + { + mutex_lock (&np->lock); + diskfs_drop_node (np); + } + else if (np->references == 0) + { + mutex_lock (&np->lock); + nlinks = np->dn_stat.st_nlink; + mutex_unlock (&np->lock); + spin_unlock (&diskfs_node_refcnt_lock); + if (!nlinks) + diskfs_lost_hardrefs (np); + } + else + spin_unlock (&diskfs_node_refcnt_lock); +} + +/* Add a light reference to a node. */ +extern inline void +diskfs_nref_light (struct node *np) +{ + spin_lock (&diskfs_node_refcnt_lock); + np->light_references++; + spin_unlock (&diskfs_node_refcnt_lock); +} + +/* Unlock node NP and release a light reference */ +extern inline void +diskfs_nput_light (struct node *np) +{ + spin_lock (&diskfs_node_refcnt_lock); + np->light_references--; + if (np->references + np->light_references == 0) + diskfs_drop_node (np); + else + { + spin_unlock (&diskfs_node_refcnt_lock); + mutex_unlock (&np->lock); + } +} + +/* Release a light reference on NP. If NP is locked by anyone, then + this cannot be the last reference (because you must hold a + hard reference in order to hold the lock). */ +extern inline void +diskfs_nrele_light (struct node *np) +{ + spin_lock (&diskfs_node_refcnt_lock); + np->light_references--; + if (np->references + np->light_references == 0) + { + mutex_lock (&np->lock); + diskfs_drop_node (np); + } + else + spin_unlock (&diskfs_node_refcnt_lock); +} + +/* Return nonzero iff the user identified by CRED has uid UID. */ +extern inline int +diskfs_isuid (uid_t uid, struct protid *cred) +{ + int i; + for (i = 0; i < cred->nuids; i++) + if (cred->uids[i] == uid) + return 1; + return 0; +} + +/* Return nonzero iff the user identified by CRED has group GRP. */ +extern inline int +diskfs_groupmember (uid_t grp, struct protid *cred) +{ + int i; + for (i = 0; i < cred->ngids; i++) + if (cred->gids[i] == grp) + return 1; + return 0; +} + +/* Check to see if the user identified by CRED is permitted to do + owner-only operations on node NP; if so, return 0; if not, return + EPERM. */ +extern inline error_t +diskfs_isowner (struct node *np, struct protid *cred) +{ + /* Permitted if the user is the owner, superuser, or if the user + is in the group of the file and has the group ID as their user + ID. (This last is colloquially known as `group leader'.) */ + if (diskfs_isuid (np->dn_stat.st_uid, cred) || diskfs_isuid (0, cred) + || (diskfs_groupmember (np->dn_stat.st_gid, cred) + && diskfs_isuid (np->dn_stat.st_gid, cred))) + return 0; + else + return EPERM; +} + +/* Check to see is the user identified by CRED 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. */ +extern inline error_t +diskfs_access (struct node *np, int op, struct protid *cred) +{ + int gotit; + if (diskfs_isuid (0, cred)) + gotit = 1; + else if (cred->nuids == 0 && (np->dn_stat.st_mode & S_IUSEUNK)) + gotit = np->dn_stat.st_mode & (op << S_IUNKSHIFT); + else if (!diskfs_isowner (np, cred)) + gotit = np->dn_stat.st_mode & op; + else if (diskfs_groupmember (np->dn_stat.st_gid, cred)) + gotit = np->dn_stat.st_mode & (op >> 3); + else + gotit = np->dn_stat.st_mode & (op >> 6); + return gotit ? 0 : EACCES; +} + +/* Check to see if the user identified by CRED is allowed to modify + directory DP with respect to existing file NP. This is the same + as diskfs_access (dp, S_IWRITE, cred), except when the directory + has the sticky bit set. (If there is no existing file NP, then + 0 can be passed.) */ +extern inline error_t +diskfs_checkdirmod (struct node *dp, struct node *np, + struct protid *cred) +{ + /* The user must be able to write the directory, but if the directory + is sticky, then the user must also be either the owner of the directory + or the file. */ + return (diskfs_access (dp, S_IWRITE, cred) + && (!(dp->dn_stat.st_mode & S_ISVTX) || !np || diskfs_isuid (0,cred) + || diskfs_isowner (dp, cred) || diskfs_isowner (np, cred))); +} + +/* Reading and writing of files. this is called by other filesystem + routines and handles extension of files automatically. NP is the + node to be read or written, and must be locked. DATA will be + written or filled. OFF identifies where in thi fel the I/O is to + take place (-1 is not allowed). AMT is the size of DATA and tells + how much to copy. DIR is 1 for writing and 0 for reading. CRED is + the user doing the access (only used to validate attempted file + extension). For reads, *AMTREAD is filled with the amount actually + read. */ +error_t +diskfs_node_rdwr (struct node *np, char *data, off_t off, + int amt, int dir, struct protid *cred, + int *amtread); + + +/* Create a new node structure with DS as its physical disknode. + The new node will have one hard reference and no light references. */ +struct node *diskfs_make_node (struct disknode *dn); + +/* The following two calls are actually macros. */ +/* Begin executing code which might fault. This contains a call + to setjmp and so callers must be careful with register variables. + The first time through, this returns 0. If the code faults + accessing a region of memory registered with + diskfs_register_memory_fault_area, then this routine will return + again with the error number as reported by the pager. */ +/* int diskfs_catch_exception (void); */ + +/* After calling diskfs_catch_exception, this routine must be called + before exiting the function which called diskfs_catch_exception. + It will cancel the fault protection installed by diskfs_catch_exception. */ +/* void diskfs_end_catch_exception (void); */ + +/* Register a region of memory for protected fault status as described + above for diskfs_catch_exception. This should generally be done + for any vm_map of the filesystem's own data. This will mark memory + at ADDR continuing for LEN bytes to be mapped from pager P at offset + OFF. Any memory exceptions in this region will be looked up with + pager_get_error (until the XP interface is fixed); this is the only + use made of arguments P and OFF. */ +void diskfs_register_memory_fault_area (struct pager *p, vm_address_t off, + void *addr, long len); + +/* Remove the registration of a region registered with + diskfs_register_memory_fault_area; the region is that at ADDR + continuing for LEN bytes. */ +void diskfs_unregister_memory_fault_area (void *addr, long len); + + +/* The library also exports the following functions; they are not generally + useful unless you are redefining other functions the library provides. */ + +/* Create a new node. Give it MODE; if that includes IFDIR, also + initialize `.' and `..' in the new directory. Return the node in NPP. + CRED identifies the user responsible for the call. If NAME is nonzero, + then link the new node into DIR with name NAME; DS is the result of a + prior diskfs_lookup for creation (and DIR has been held locked since). + DIR must always be provided as at least a hint for disk allocation + strategies. */ +error_t +diskfs_create_node (struct node *dir, char *name, mode_t mode, + struct node **newnode, struct protid *cred, + struct dirstat *ds); + +/* Start the translator on node IP; the directory we found IP in + is DIP; both are locked. */ +error_t diskfs_start_translator (struct node *np, struct node *dnp); + +/* Create and return a protid for an existing peropen. The uid set is + UID (length NUIDS); the gid set is GID (length NGIDS). The node + PO->np must be locked. */ +struct protid *diskfs_make_protid (struct peropen *cred, uid_t *uids, + int nuids, uid_t *gids, int ngids); + +/* Build and return a protid which has no user identification for + peropen PO. The node PO->np must be locked. */ +struct protid *diskfs_start_protid (struct peropen *po); + +/* Finish building protid CRED started with diskfs_start_protid; + the uid set is UID (length NUIDS); the gid set is GID (length NGIDS). */ +void diskfs_finish_protid (struct protid *cred, uid_t *uids, int nuids, + gid_t *gids, int nguds); + +/* Create and return a new peropen structure on node NP with open + flags FLAGS. */ +struct peropen *diskfs_make_peropen (struct node *np, int flags); + +/* Called when a protid CRED has no more references. (Because references\ + to protids are maintained by the port management library, this is + installed in the clean routines list.) The ports library will + free the structure for us. */ +void diskfs_protid_rele (void *arg); + +/* Decrement the reference count on a peropen structure. */ +void diskfs_release_peropen (struct peropen *po); + +/* Rename directory node FNP (whose parent is FDP, and which has name + FROMNAME in that directory) to have name TONAME inside directory + TDP. None of these nodes are locked, and none should be locked + upon return. This routine is serialized, so it doesn't have to be + reentrant. Directories will never be renamed except by this + routine. FROMCRED and TOCRED are the users responsible for + FDP/FNP and TDP respectively. This routine assumes the usual + convention where `.' and `..' are represented by ordinary links; + if that is not true for your format, you have to redefine this + function.*/ +error_t +diskfs_rename_dir (struct node *fdp, struct node *fnp, char *fromname, + struct node *tdp, char *toname, struct protid *fromcred, + struct protid *tocred); + +/* Clear the `.' and `..' entries from directory DP. Its parent is + PDP, and the user responsible for this is identified by CRED. Both + directories must be locked. This routine assumes the usual + convention where `.' and `..' are represented by ordinary links; if + that is not true for your format, you have to redefine this + function. */ +error_t diskfs_clear_directory (struct node *dp, struct node *pdp, + struct protid *cred); + +/* Locked node DP is a new directory; add whatever links are necessary + to give it structure; its parent is the (locked) node PDP. + This routine may not call diskfs_lookup on PDP. The new directory + must be clear within the meaning of diskfs_dirempty. This routine + assumes the usual convention where `.' and `..' are represented by + ordinary links; if that is not true for your format, you have to + redefine this function. CRED identifies the user making the call. */ +error_t +diskfs_init_dir (struct node *dp, struct node *pdp, struct protid *cred); + +/* Get rid of any translator running on the file NP; FLAGS + (from the set FSYS_GOAWAY_*) describes details of shutting + down the child filesystem. */ +void diskfs_destroy_translator (struct node *np, int flags); + +/* Sync all the running translators. Wait for them to complete if + WAIT is nonzero. */ +void diskfs_sync_translators (int wait); + +/* If NP->dn_set_ctime is set, then modify NP->dn_stat.st_ctime + appropriately; do the analogous operation for atime and mtime as well. */ +void diskfs_set_node_times (struct node *np); + +/* Shutdown the filesystem; flags are as for fsys_shutdown. */ +error_t diskfs_shutdown (int flags); + +/* Called by S_fsys_startup for execserver bootstrap. The execserver + is able to function without a real node, hence this fraud. Arguments + are all as for fsys_startup in <hurd/fsys.defs>. */ +error_t diskfs_execboot_fsys_startup (mach_port_t port, mach_port_t ctl, + mach_port_t *real, + mach_msg_type_name_t *realpoly, + mach_port_t *dotdot_node, + mach_msg_type_name_t *dotdot_node_poly); + +/* The ports library requires the following to be defined; the diskfs + library provides a definition. See <hurd/ports.h> for the + interface description. The library assumes you use the pager + library (and calls pager_demuxer). If you don't, then you need + to redefine this function as well as the no_senders notify stub. */ +int ports_demuxer (mach_msg_header_t *, mach_msg_header_t *); + +/* The diskfs library provides functions to demultiplex the fs, io, fsys, + memory_object, interrupt, and notify interfaces. All the server + routines have the prefix `diskfs_S_'; `in' arguments of type + file_t or io_t appear as `struct protid *' to the stub. */ + +#endif |