sanchayanmaity/minix
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
minix/servers/avfs/proto.h

391 lines
16 KiB
C
Raw Normal View History

Merge AVFS and APFS
2011-08-17 15:23:45 +02:00
#ifndef __VFS_PROTO_H__
#define __VFS_PROTO_H__
/* Function prototypes. */
#include "timers.h"
#include "request.h"
#include "tll.h"
#include "threads.h"
#include <minix/rs.h>
/* Structs used in prototypes must be declared as such first. */
struct filp;
struct fproc;
struct vmnt;
struct vnode;
struct lookup;
struct worker_thread;
struct job;
typedef struct filp * filp_id_t;
/* comm.c */
Add support for survival of crashed FSs When an FS crashes, VFS will clean up resources tied to that FS: - Pending requests to the FS are canceled (i.e., fail with EIO) - Threads waiting for a reply are stopped (i.e., fail with EIO) - Open files are marked invalid. Future operations on a file descriptor will cause EBADF errors. - vmnt entry is cleared, so in-flight system calls that got past the file descriptor check but not yet talking to the crashed FS, will fail with EIO. - The reference counter of the mount point is decreased, effectively removing the crashed FS from the file system tree. Descendants of this part of the tree are unreachable by means of a path, but can still be unmounted by feeding the block special file to unmount(2). This patch also gets rid of the "not a known driver endpoint" messages during shutdown.
2012-01-19 15:21:46 +01:00
_PROTOTYPE(void fs_cancel, (struct vmnt *vmp) );
Merge AVFS and APFS
2011-08-17 15:23:45 +02:00
_PROTOTYPE(int fs_sendrec, (endpoint_t fs_e, message *reqm) );
_PROTOTYPE(void fs_sendmore, (struct vmnt *vmp) );
_PROTOTYPE(void send_work, (void) );
/* device.c */
_PROTOTYPE( int dev_open, (dev_t dev, endpoint_t proc_e, int flags) );
_PROTOTYPE( int dev_reopen, (dev_t dev, int filp_no, int flags) );
_PROTOTYPE( int dev_close, (dev_t dev, int filp_no) );
Split block/character protocols and libdriver This patch separates the character and block driver communication protocols. The old character protocol remains the same, but a new block protocol is introduced. The libdriver library is replaced by two new libraries: libchardriver and libblockdriver. Their exposed API, and drivers that use them, have been updated accordingly. Together, libbdev and libblockdriver now completely abstract away the message format used by the block protocol. As the memory driver is both a character and a block device driver, it now implements its own message loop. The most important semantic change made to the block protocol is that it is no longer possible to return both partial results and an error for a single transfer. This simplifies the interaction between the caller and the driver, as the I/O vector no longer needs to be copied back. Also, drivers are now no longer supposed to decide based on the layout of the I/O vector when a transfer should be cut short. Put simply, transfers are now supposed to either succeed completely, or result in an error. After this patch, the state of the various pieces is as follows: - block protocol: stable - libbdev API: stable for synchronous communication - libblockdriver API: needs slight revision (the drvlib/partition API in particular; the threading API will also change shortly) - character protocol: needs cleanup - libchardriver API: needs cleanup accordingly - driver restarts: largely unsupported until endpoint changes are reintroduced As a side effect, this patch eliminates several bugs, hacks, and gcc -Wall and -W warnings all over the place. It probably introduces a few new ones, too. Update warning: this patch changes the protocol between MFS and disk drivers, so in order to use old/new images, the MFS from the ramdisk must be used to mount all file systems.
2011-11-22 13:27:53 +01:00
_PROTOTYPE( int bdev_open, (dev_t dev, int access) );
_PROTOTYPE( int bdev_close, (dev_t dev) );
Merge AVFS and APFS
2011-08-17 15:23:45 +02:00
_PROTOTYPE( int dev_io, (int op, dev_t dev, endpoint_t proc_e, void *buf,
u64_t pos, size_t bytes, int flags, int suspend_reopen) );
_PROTOTYPE( int gen_opcl, (int op, dev_t dev, endpoint_t task_nr, int flags));
Unmap drivers upon exit
2011-09-13 15:02:47 +02:00
_PROTOTYPE( int gen_io, (endpoint_t driver_e, message *mess_ptr) );
Merge AVFS and APFS
2011-08-17 15:23:45 +02:00
_PROTOTYPE( int asyn_io, (int task_nr, message *mess_ptr) );
_PROTOTYPE( int no_dev, (int op, dev_t dev, int proc, int flags) );
_PROTOTYPE( int no_dev_io, (int, message *) );
_PROTOTYPE( int tty_opcl, (int op, dev_t dev, endpoint_t proc, int flags));
_PROTOTYPE( int ctty_opcl, (int op, dev_t dev, endpoint_t proc, int flags));
_PROTOTYPE( int clone_opcl, (int op, dev_t dev, int proc, int flags) );
_PROTOTYPE( int ctty_io, (int task_nr, message *mess_ptr) );
_PROTOTYPE( int do_ioctl, (void) );
_PROTOTYPE( void pm_setsid, (int proc_e) );
_PROTOTYPE( void dev_status, (message *) );
Split block/character protocols and libdriver This patch separates the character and block driver communication protocols. The old character protocol remains the same, but a new block protocol is introduced. The libdriver library is replaced by two new libraries: libchardriver and libblockdriver. Their exposed API, and drivers that use them, have been updated accordingly. Together, libbdev and libblockdriver now completely abstract away the message format used by the block protocol. As the memory driver is both a character and a block device driver, it now implements its own message loop. The most important semantic change made to the block protocol is that it is no longer possible to return both partial results and an error for a single transfer. This simplifies the interaction between the caller and the driver, as the I/O vector no longer needs to be copied back. Also, drivers are now no longer supposed to decide based on the layout of the I/O vector when a transfer should be cut short. Put simply, transfers are now supposed to either succeed completely, or result in an error. After this patch, the state of the various pieces is as follows: - block protocol: stable - libbdev API: stable for synchronous communication - libblockdriver API: needs slight revision (the drvlib/partition API in particular; the threading API will also change shortly) - character protocol: needs cleanup - libchardriver API: needs cleanup accordingly - driver restarts: largely unsupported until endpoint changes are reintroduced As a side effect, this patch eliminates several bugs, hacks, and gcc -Wall and -W warnings all over the place. It probably introduces a few new ones, too. Update warning: this patch changes the protocol between MFS and disk drivers, so in order to use old/new images, the MFS from the ramdisk must be used to mount all file systems.
2011-11-22 13:27:53 +01:00
_PROTOTYPE( void bdev_up, (int major) );
_PROTOTYPE( void cdev_up, (int major) );
Merge AVFS and APFS
2011-08-17 15:23:45 +02:00
_PROTOTYPE( endpoint_t find_suspended_ep, (endpoint_t driver,
cp_grant_id_t g) );
_PROTOTYPE( void reopen_reply, (void) );
_PROTOTYPE( void open_reply, (void) );
/* dmap.c */
_PROTOTYPE( int do_mapdriver, (void) );
_PROTOTYPE( void init_dmap, (void) );
_PROTOTYPE( int dmap_driver_match, (endpoint_t proc, int major) );
Split block/character protocols and libdriver This patch separates the character and block driver communication protocols. The old character protocol remains the same, but a new block protocol is introduced. The libdriver library is replaced by two new libraries: libchardriver and libblockdriver. Their exposed API, and drivers that use them, have been updated accordingly. Together, libbdev and libblockdriver now completely abstract away the message format used by the block protocol. As the memory driver is both a character and a block device driver, it now implements its own message loop. The most important semantic change made to the block protocol is that it is no longer possible to return both partial results and an error for a single transfer. This simplifies the interaction between the caller and the driver, as the I/O vector no longer needs to be copied back. Also, drivers are now no longer supposed to decide based on the layout of the I/O vector when a transfer should be cut short. Put simply, transfers are now supposed to either succeed completely, or result in an error. After this patch, the state of the various pieces is as follows: - block protocol: stable - libbdev API: stable for synchronous communication - libblockdriver API: needs slight revision (the drvlib/partition API in particular; the threading API will also change shortly) - character protocol: needs cleanup - libchardriver API: needs cleanup accordingly - driver restarts: largely unsupported until endpoint changes are reintroduced As a side effect, this patch eliminates several bugs, hacks, and gcc -Wall and -W warnings all over the place. It probably introduces a few new ones, too. Update warning: this patch changes the protocol between MFS and disk drivers, so in order to use old/new images, the MFS from the ramdisk must be used to mount all file systems.
2011-11-22 13:27:53 +01:00
_PROTOTYPE( void dmap_endpt_up, (int proc_nr, int is_blk) );
Merge AVFS and APFS
2011-08-17 15:23:45 +02:00
_PROTOTYPE( void dmap_unmap_by_endpt, (int proc_nr) );
_PROTOTYPE( struct dmap *get_dmap, (endpoint_t proc_e) );
_PROTOTYPE( int do_mapdriver, (void) );
_PROTOTYPE( int map_service, (struct rprocpub *rpub) );
_PROTOTYPE( void dmap_unmap_by_endpt, (int proc_nr) );
_PROTOTYPE( struct dmap *get_dmap, (endpoint_t proc_e) );
_PROTOTYPE( int map_driver, (const char *label, int major, endpoint_t proc_nr,
int dev_style, int flags) );
_PROTOTYPE( int map_service, (struct rprocpub *rpub) );
Provide core dumping support for AVFS
2011-12-08 11:47:11 +01:00
/* elf_core_dump.c */
_PROTOTYPE( void write_elf_core_file, (struct filp *f, int csig,
char *exe_name) );
Merge AVFS and APFS
2011-08-17 15:23:45 +02:00
/* exec.c */
_PROTOTYPE( int pm_exec, (int proc_e, char *path, vir_bytes path_len,
char *frame, vir_bytes frame_len, vir_bytes *pc));
#define check_bsf_lock() do { \
assert(mutex_trylock(&bsf_lock) == 0); \
unlock_bsf(); \
} while(0)
/* filedes.c */
_PROTOTYPE( void check_filp_locks, (void) );
_PROTOTYPE( void check_filp_locks_by_me, (void) );
_PROTOTYPE( void init_filps, (void) );
_PROTOTYPE( struct filp *find_filp, (struct vnode *vp, mode_t bits) );
_PROTOTYPE( int get_fd, (int start, mode_t bits, int *k,
struct filp **fpt) );
_PROTOTYPE( struct filp *get_filp, (int fild, tll_access_t locktype) );
_PROTOTYPE( struct filp *get_filp2, (struct fproc *rfp, int fild,
tll_access_t locktype) );
_PROTOTYPE( void lock_filp, (struct filp *filp, tll_access_t locktype) );
_PROTOTYPE( void unlock_filp, (struct filp *filp) );
_PROTOTYPE( void unlock_filps, (struct filp *filp1, struct filp *filp2) );
Add support for survival of crashed FSs When an FS crashes, VFS will clean up resources tied to that FS: - Pending requests to the FS are canceled (i.e., fail with EIO) - Threads waiting for a reply are stopped (i.e., fail with EIO) - Open files are marked invalid. Future operations on a file descriptor will cause EBADF errors. - vmnt entry is cleared, so in-flight system calls that got past the file descriptor check but not yet talking to the crashed FS, will fail with EIO. - The reference counter of the mount point is decreased, effectively removing the crashed FS from the file system tree. Descendants of this part of the tree are unreachable by means of a path, but can still be unmounted by feeding the block special file to unmount(2). This patch also gets rid of the "not a known driver endpoint" messages during shutdown.
2012-01-19 15:21:46 +01:00
_PROTOTYPE( int invalidate_filp, (struct filp *) );
_PROTOTYPE( void invalidate_filp_by_endpt, (endpoint_t proc_e) );
Merge AVFS and APFS
2011-08-17 15:23:45 +02:00
_PROTOTYPE( int do_verify_fd, (void) );
_PROTOTYPE( int set_filp, (filp_id_t sfilp) );
_PROTOTYPE( int do_set_filp, (void) );
_PROTOTYPE( int copy_filp, (endpoint_t to_ep, filp_id_t cfilp) );
_PROTOTYPE( int do_copy_filp, (void) );
_PROTOTYPE( int put_filp, (filp_id_t pfilp) );
_PROTOTYPE( int do_put_filp, (void) );
_PROTOTYPE( int cancel_fd, (endpoint_t ep, int fd) );
_PROTOTYPE( int do_cancel_fd, (void) );
_PROTOTYPE( void close_filp, (struct filp *fp) );
/* fscall.c */
_PROTOTYPE( void nested_fs_call, (message *m) );
/* link.c */
_PROTOTYPE( int do_link, (void) );
_PROTOTYPE( int do_unlink, (void) );
_PROTOTYPE( int do_rename, (void) );
_PROTOTYPE( int do_truncate, (void) );
_PROTOTYPE( int do_ftruncate, (void) );
_PROTOTYPE( int truncate_vnode, (struct vnode *vp, off_t newsize) );
_PROTOTYPE( int rdlink_direct, (char *orig_path, char *link_path,
struct fproc *rfp) );
/* lock.c */
_PROTOTYPE( int lock_op, (struct filp *f, int req) );
_PROTOTYPE( void lock_revive, (void) );
/* main.c */
_PROTOTYPE( int main, (void) );
Cleanup more resources upon exit
2011-09-15 17:39:13 +02:00
_PROTOTYPE( void reply, (int whom, int result) );
Merge AVFS and APFS
2011-08-17 15:23:45 +02:00
_PROTOTYPE( void lock_proc, (struct fproc *rfp, int force_lock) );
_PROTOTYPE( void unlock_proc, (struct fproc *rfp) );
_PROTOTYPE( void *do_dummy, (void *arg) );
/* misc.c */
_PROTOTYPE( int do_dup, (void) );
_PROTOTYPE( void pm_exit, (int proc) );
_PROTOTYPE( int do_fcntl, (void) );
_PROTOTYPE( void pm_fork, (int pproc, int cproc, int cpid) );
_PROTOTYPE( void pm_setgid, (int proc_e, int egid, int rgid) );
_PROTOTYPE( void pm_setuid, (int proc_e, int euid, int ruid) );
_PROTOTYPE( void pm_setgroups, (int proc_e, int ngroups, gid_t *addr) );
_PROTOTYPE( int do_sync, (void) );
_PROTOTYPE( int do_fsync, (void) );
_PROTOTYPE( void pm_reboot, (void) );
_PROTOTYPE( int do_svrctl, (void) );
_PROTOTYPE( int do_getsysinfo, (void) );
Provide core dumping support for AVFS
2011-12-08 11:47:11 +01:00
_PROTOTYPE( int pm_dumpcore, (endpoint_t proc_e, int sig,
vir_bytes exe_name) );
Merge AVFS and APFS
2011-08-17 15:23:45 +02:00
_PROTOTYPE( void ds_event, (void) );
/* mount.c */
_PROTOTYPE( int do_fsready, (void) );
_PROTOTYPE( int do_mount, (void) );
_PROTOTYPE( int do_umount, (void) );
Fix locking issues with back calls from FSes
2011-08-19 16:12:07 +02:00
_PROTOTYPE( int is_nonedev, (dev_t dev) );
Merge AVFS and APFS
2011-08-17 15:23:45 +02:00
_PROTOTYPE( void mount_pfs, (void) );
_PROTOTYPE( int mount_fs, (dev_t dev, char fullpath[PATH_MAX+1],
endpoint_t fs_e, int rdonly,
char mount_label[LABEL_MAX]) );
_PROTOTYPE( int unmount, (dev_t dev, char *label) );
_PROTOTYPE( void unmount_all, (void) );
/* open.c */
_PROTOTYPE( int do_close, (void) );
_PROTOTYPE( int close_fd, (struct fproc *rfp, int fd_nr) );
_PROTOTYPE( void close_reply, (void) );
Provide core dumping support for AVFS
2011-12-08 11:47:11 +01:00
_PROTOTYPE( int common_open, (char path[PATH_MAX], int oflags,
mode_t omode) );
Merge AVFS and APFS
2011-08-17 15:23:45 +02:00
_PROTOTYPE( int do_creat, (void) );
_PROTOTYPE( int do_lseek, (void) );
_PROTOTYPE( int do_llseek, (void) );
_PROTOTYPE( int do_mknod, (void) );
_PROTOTYPE( int do_mkdir, (void) );
_PROTOTYPE( int do_open, (void) );
_PROTOTYPE( int do_slink, (void) );
_PROTOTYPE( int do_vm_open, (void) );
_PROTOTYPE( int do_vm_close, (void) );
/* path.c */
_PROTOTYPE( struct vnode *advance, (struct vnode *dirp, struct lookup *resolve,
struct fproc *rfp) );
_PROTOTYPE( struct vnode *eat_path, (struct lookup *resolve,
struct fproc *rfp) );
_PROTOTYPE( struct vnode *last_dir, (struct lookup *resolve,
struct fproc *rfp) );
_PROTOTYPE( void lookup_init, (struct lookup *resolve, char *path, int flags,
struct vmnt **vmp, struct vnode **vp) );
_PROTOTYPE( int get_name, (struct vnode *dirp, struct vnode *entry,
char *_name) );
Fix off-by-one errors and increase PATH_MAX to 1024 In some places it was assumed that PATH_MAX does not include a terminating null character. Increases PATH_MAX to 1024 to get in sync with NetBSD. Required some rewriting in AVFS to keep memory usage low (the stack in use by a thread is very small).
2011-09-12 11:00:24 +02:00
_PROTOTYPE( int canonical_path, (char *orig_path, struct fproc *rfp) );
Merge AVFS and APFS
2011-08-17 15:23:45 +02:00
_PROTOTYPE( int do_check_perms, (void) );
/* pipe.c */
_PROTOTYPE( int do_pipe, (void) );
_PROTOTYPE( int map_vnode, (struct vnode *vp, endpoint_t fs_e) );
_PROTOTYPE( void unpause, (int proc_nr_e) );
_PROTOTYPE( int pipe_check, (struct vnode *vp, int rw_flag,
int oflags, int bytes, u64_t position, int notouch) );
_PROTOTYPE( void release, (struct vnode *vp, int call_nr, int count) );
_PROTOTYPE( void revive, (int proc_nr, int bytes) );
_PROTOTYPE( void suspend, (int task) );
AVFS: Use scratchpad instead of m_in to pass around file descriptors Some code relies on having the file descriptor in m_in.fd. Consequently, m_in is not only used to provide syscall parameters from user space to VFS, but also as a global variable to store temporary data within VFS. This has the ugly side effect that m_in gets overwritten during core dumping.* To work around this problem VFS now uses a so called "scratchpad" to store temporary data that has to be globally accessible. This is a simple table indexed by process number, just like fproc. The scratchpad allows us to store the buffer pointer and buffer size for suspended system calls (i.e., read, write, open, lock) instead of using fproc. This makes fproc a bit smaller and fproc iterators a bit faster. Moreover, suspension of processes becomes simpler altogether and suspended operations on pipes are now less of a special case. * This patch fixes a bug where due to unexpected m_in overwriting a coredump would fail, and consequently resources are leaked. The coredump was triggered with: $ a() { a; } $ a
2011-12-21 11:52:51 +01:00
_PROTOTYPE( void pipe_suspend, (struct filp *rfilp, char *buf, size_t size));
Merge AVFS and APFS
2011-08-17 15:23:45 +02:00
_PROTOTYPE( void unsuspend_by_endpt, (endpoint_t) );
_PROTOTYPE( void wait_for, (endpoint_t) );
#if DO_SANITYCHECKS
_PROTOTYPE( int check_pipe, (void) );
#endif
/* protect.c */
_PROTOTYPE( int do_access, (void) );
_PROTOTYPE( int do_chmod, (void) );
_PROTOTYPE( int do_chown, (void) );
_PROTOTYPE( int do_umask, (void) );
AVFS: make forbidden check for specific proc instead of fp
2012-01-27 14:54:35 +01:00
_PROTOTYPE( int forbidden, (struct fproc *rfp, struct vnode *vp,
mode_t access_desired) );
Merge AVFS and APFS
2011-08-17 15:23:45 +02:00
_PROTOTYPE( int read_only, (struct vnode *vp) );
/* read.c */
_PROTOTYPE( int do_read, (void) );
_PROTOTYPE( int do_getdents, (void) );
_PROTOTYPE( void lock_bsf, (void) );
_PROTOTYPE( void unlock_bsf, (void) );
Provide core dumping support for AVFS
2011-12-08 11:47:11 +01:00
_PROTOTYPE( int do_read_write, (int rw_flag) );
_PROTOTYPE( int read_write, (int rw_flag, struct filp *f, char *buffer,
size_t nbytes, endpoint_t for_e) );
_PROTOTYPE( int rw_pipe, (int rw_flag, endpoint_t usr, struct filp *f,
char *buf, size_t req_size) );
Merge AVFS and APFS
2011-08-17 15:23:45 +02:00
/* request.c */
_PROTOTYPE( int req_breadwrite, (endpoint_t fs_e, endpoint_t user_e,
dev_t dev, u64_t pos, unsigned int num_of_bytes,
char *user_addr, int rw_flag,
u64_t *new_posp, unsigned int *cum_iop) );
_PROTOTYPE( int req_chmod, (int fs_e, ino_t inode_nr, mode_t rmode,
mode_t *new_modep) );
_PROTOTYPE( int req_chown, (endpoint_t fs_e, ino_t inode_nr,
uid_t newuid, gid_t newgid, mode_t *new_modep) );
_PROTOTYPE( int req_create, (int fs_e, ino_t inode_nr, int omode,
uid_t uid, gid_t gid, char *path, node_details_t *res) );
_PROTOTYPE( int req_flush, (endpoint_t fs_e, dev_t dev) );
_PROTOTYPE( int req_fstatfs, (int fs_e, int who_e, char *buf) );
_PROTOTYPE( int req_statvfs, (int fs_e, int who_e, char *buf) );
_PROTOTYPE( int req_ftrunc, (endpoint_t fs_e, ino_t inode_nr,
off_t start, off_t end) );
_PROTOTYPE( int req_getdents, (endpoint_t fs_e, ino_t inode_nr,
u64_t pos, char *buf, size_t size,
u64_t *new_pos, int direct) );
_PROTOTYPE( int req_inhibread, (endpoint_t fs_e, ino_t inode_nr) );
_PROTOTYPE( int req_link, (endpoint_t fs_e, ino_t link_parent,
char *lastc, ino_t linked_file) );
_PROTOTYPE( int req_lookup, (endpoint_t fs_e, ino_t dir_ino, ino_t root_ino,
uid_t uid, gid_t gid, struct lookup *resolve,
lookup_res_t *res, struct fproc *rfp) );
_PROTOTYPE( int req_mkdir, (endpoint_t fs_e, ino_t inode_nr,
char *lastc, uid_t uid, gid_t gid, mode_t dmode) );
_PROTOTYPE( int req_mknod, (endpoint_t fs_e, ino_t inode_nr,
char *lastc, uid_t uid, gid_t gid,
mode_t dmode, dev_t dev) );
_PROTOTYPE( int req_mountpoint, (endpoint_t fs_e, ino_t inode_nr) );
_PROTOTYPE( int req_newnode, (endpoint_t fs_e, uid_t uid,
gid_t gid, mode_t dmode,
dev_t dev, struct node_details *res) );
_PROTOTYPE( int req_putnode, (int fs_e, ino_t inode_nr, int count) );
_PROTOTYPE( int req_rdlink, (endpoint_t fs_e, ino_t inode_nr,
endpoint_t who_e, char *buf, size_t len,
int direct) );
_PROTOTYPE( int req_readsuper, (endpoint_t fs_e, char *driver_name,
dev_t dev, int readonly, int isroot,
Store and use max concurrent requests
2011-08-22 18:24:29 +02:00
struct node_details *res_nodep,
int *con_reqs) );
Merge AVFS and APFS
2011-08-17 15:23:45 +02:00
_PROTOTYPE( int req_readwrite, (endpoint_t fs_e, ino_t inode_nr,
u64_t pos, int rw_flag,
endpoint_t user_e, char *user_addr,
unsigned int num_of_bytes, u64_t *new_posp,
unsigned int *cum_iop) );
_PROTOTYPE( int req_rename, (endpoint_t fs_e, ino_t old_dir,
char *old_name, ino_t new_dir, char *new_name) );
_PROTOTYPE( int req_rmdir, (endpoint_t fs_e, ino_t inode_nr,
char *lastc) );
_PROTOTYPE(int req_slink, (endpoint_t fs_e, ino_t inode_nr, char *lastc,
endpoint_t who_e, char *path_addr,
unsigned short path_length, uid_t uid, gid_t gid) );
_PROTOTYPE( int req_stat, (int fs_e, ino_t inode_nr, int who_e,
char *buf, int pos, int stat_version) );
_PROTOTYPE( int req_sync, (endpoint_t fs_e) );
_PROTOTYPE( int req_unlink, (endpoint_t fs_e, ino_t inode_nr,
char *lastc) );
_PROTOTYPE( int req_unmount, (endpoint_t fs_e) );
_PROTOTYPE( int req_utime, (endpoint_t fs_e, ino_t inode_nr,
time_t actime, time_t modtime) );
_PROTOTYPE( int req_newdriver, (endpoint_t fs_e, dev_t dev,
VFS/FS: REQ_NEW_DRIVER now provides a label
2011-11-30 19:05:26 +01:00
char *label) );
Merge AVFS and APFS
2011-08-17 15:23:45 +02:00
/* stadir.c */
_PROTOTYPE( int do_chdir, (void) );
_PROTOTYPE( int do_fchdir, (void) );
_PROTOTYPE( int do_chroot, (void) );
_PROTOTYPE( int do_fstat, (void) );
_PROTOTYPE( int do_stat, (void) );
_PROTOTYPE( int do_fstatfs, (void) );
_PROTOTYPE( int do_statvfs, (void) );
_PROTOTYPE( int do_fstatvfs, (void) );
_PROTOTYPE( int do_rdlink, (void) );
_PROTOTYPE( int do_lstat, (void) );
/* time.c */
_PROTOTYPE( int do_utime, (void) );
/* tll.c */
_PROTOTYPE( void tll_downgrade, (tll_t *tllp) );
_PROTOTYPE( int tll_haspendinglock, (tll_t *tllp) );
_PROTOTYPE( void tll_init, (tll_t *tllp) );
_PROTOTYPE( int tll_islocked, (tll_t *tllp) );
_PROTOTYPE( int tll_lock, (tll_t *tllp, tll_access_t locktype) );
_PROTOTYPE( int tll_locked_by_me, (tll_t *tllp) );
_PROTOTYPE( void tll_lockstat, (tll_t *tllp) );
_PROTOTYPE( int tll_unlock, (tll_t *tllp) );
_PROTOTYPE( void tll_upgrade, (tll_t *tllp) );
/* utility.c */
_PROTOTYPE( time_t clock_time, (void) );
_PROTOTYPE( unsigned conv2, (int norm, int w) );
_PROTOTYPE( long conv4, (int norm, long x) );
_PROTOTYPE( int fetch_name, (char *path, int len, int flag, char *dest) );
_PROTOTYPE( int no_sys, (void) );
_PROTOTYPE( int isokendpt_f, (char *f, int l, endpoint_t e, int *p, int ft));
_PROTOTYPE( int in_group, (struct fproc *rfp, gid_t grp) );
#define okendpt(e, p) isokendpt_f(__FILE__, __LINE__, (e), (p), 1)
#define isokendpt(e, p) isokendpt_f(__FILE__, __LINE__, (e), (p), 0)
/* vmnt.c */
_PROTOTYPE( void check_vmnt_locks, (void) );
_PROTOTYPE( void check_vmnt_locks_by_me, (struct fproc *rfp) );
_PROTOTYPE( struct vmnt *get_free_vmnt, (void) );
_PROTOTYPE( struct vmnt *find_vmnt, (endpoint_t fs_e) );
_PROTOTYPE( struct vmnt *get_locked_vmnt, (struct fproc *rfp) );
_PROTOTYPE( void init_vmnts, (void) );
_PROTOTYPE( int lock_vmnt, (struct vmnt *vp, tll_access_t locktype) );
_PROTOTYPE( void unlock_vmnt, (struct vmnt *vp) );
Add support for survival of crashed FSs When an FS crashes, VFS will clean up resources tied to that FS: - Pending requests to the FS are canceled (i.e., fail with EIO) - Threads waiting for a reply are stopped (i.e., fail with EIO) - Open files are marked invalid. Future operations on a file descriptor will cause EBADF errors. - vmnt entry is cleared, so in-flight system calls that got past the file descriptor check but not yet talking to the crashed FS, will fail with EIO. - The reference counter of the mount point is decreased, effectively removing the crashed FS from the file system tree. Descendants of this part of the tree are unreachable by means of a path, but can still be unmounted by feeding the block special file to unmount(2). This patch also gets rid of the "not a known driver endpoint" messages during shutdown.
2012-01-19 15:21:46 +01:00
_PROTOTYPE( void vmnt_unmap_by_endpt, (endpoint_t proc_e) );
Merge AVFS and APFS
2011-08-17 15:23:45 +02:00
/* vnode.c */
_PROTOTYPE( void check_vnode_locks, (void) );
_PROTOTYPE( void check_vnode_locks_by_me, (struct fproc *rfp) );
_PROTOTYPE( struct vnode *get_free_vnode, (void) );
_PROTOTYPE( struct vnode *find_vnode, (int fs_e, int numb) );
_PROTOTYPE( void init_vnodes, (void) );
_PROTOTYPE( int is_vnode_locked, (struct vnode *vp) );
_PROTOTYPE( int lock_vnode, (struct vnode *vp, tll_access_t locktype) );
_PROTOTYPE( void unlock_vnode, (struct vnode *vp) );
_PROTOTYPE( void dup_vnode, (struct vnode *vp) );
_PROTOTYPE( void put_vnode, (struct vnode *vp) );
_PROTOTYPE( void vnode_clean_refs, (struct vnode *vp) );
#if DO_SANITYCHECKS
_PROTOTYPE( int check_vrefs, (void) );
#endif
/* write.c */
_PROTOTYPE( int do_write, (void) );
/* gcov.c */
_PROTOTYPE( int do_gcov_flush, (void) );
#if ! USE_COVERAGE
#define do_gcov_flush no_sys
#endif
/* select.c */
_PROTOTYPE( int do_select, (void) );
_PROTOTYPE( void init_select, (void) );
_PROTOTYPE( void select_callback, (struct filp *, int ops) );
_PROTOTYPE( void select_forget, (endpoint_t proc_e) );
_PROTOTYPE( void select_reply1, (endpoint_t driver_e, int minor, int status));
_PROTOTYPE( void select_reply2, (endpoint_t driver_e, int minor, int status));
_PROTOTYPE( void select_timeout_check, (timer_t *) );
_PROTOTYPE( void select_unsuspend_by_endpt, (endpoint_t proc) );
/* worker.c */
_PROTOTYPE( int worker_available, (void) );
_PROTOTYPE( struct worker_thread *worker_get, (thread_t worker_tid) );
_PROTOTYPE( struct job *worker_getjob, (thread_t worker_tid) );
_PROTOTYPE( void worker_init, (struct worker_thread *worker) );
_PROTOTYPE( struct worker_thread *worker_self, (void) );
_PROTOTYPE( void worker_signal, (struct worker_thread *worker) );
Make AVFS resilient against failing back calls
2011-09-06 12:11:18 +02:00
_PROTOTYPE( void worker_start, (void *(*func)(void *arg)) );
_PROTOTYPE( void worker_stop, (struct worker_thread *worker) );
Provide core dumping support for AVFS
2011-12-08 11:47:11 +01:00
_PROTOTYPE( void worker_stop_by_endpt, (endpoint_t proc_e) );
Merge AVFS and APFS
2011-08-17 15:23:45 +02:00
_PROTOTYPE( void worker_wait, (void) );
_PROTOTYPE( void sys_worker_start, (void *(*func)(void *arg)) );
_PROTOTYPE( void dl_worker_start, (void *(*func)(void *arg)) );
#endif
Reference in a new issue Copy permalink