2011-08-17 15:23:45 +02:00
|
|
|
#ifndef __VFS_WORKERS_H__
|
|
|
|
|
#define __VFS_WORKERS_H__
|
|
|
|
|
#include <minix/mthread.h>
|
|
|
|
|
|
|
|
|
|
#define thread_t mthread_thread_t
|
|
|
|
|
#define mutex_t mthread_mutex_t
|
|
|
|
|
#define cond_t mthread_cond_t
|
|
|
|
|
#define attr_t mthread_attr_t
|
|
|
|
|
|
|
|
|
|
#define yield mthread_yield
|
|
|
|
|
#define yield_all mthread_yield_all
|
|
|
|
|
|
|
|
|
|
#define mutex_init mthread_mutex_init
|
|
|
|
|
#define mutex_destroy mthread_mutex_destroy
|
|
|
|
|
#define mutex_lock mthread_mutex_lock
|
|
|
|
|
#define mutex_trylock mthread_mutex_trylock
|
|
|
|
|
#define mutex_unlock mthread_mutex_unlock
|
|
|
|
|
|
|
|
|
|
#define cond_init mthread_cond_init
|
|
|
|
|
#define cond_destroy mthread_cond_destroy
|
|
|
|
|
#define cond_wait mthread_cond_wait
|
|
|
|
|
#define cond_signal mthread_cond_signal
|
|
|
|
|
|
2013-08-30 14:00:50 +02:00
|
|
|
struct fproc;
|
|
|
|
|
|
2011-08-17 15:23:45 +02:00
|
|
|
struct worker_thread {
|
|
|
|
|
thread_t w_tid;
|
|
|
|
|
mutex_t w_event_mutex;
|
|
|
|
|
cond_t w_event;
|
|
|
|
|
struct fproc *w_fp;
|
2013-10-29 23:15:15 +01:00
|
|
|
message w_m_in;
|
|
|
|
|
message w_m_out;
|
2013-08-30 14:00:50 +02:00
|
|
|
int w_err_code;
|
make vfs & filesystems use failable copying
Change the kernel to add features to vircopy and safecopies so that
transparent copy fixing won't happen to avoid deadlocks, and such copies
fail with EFAULT.
Transparently making copying work from filesystems (as normally done by
the kernel & VM when copying fails because of missing/readonly memory)
is problematic as it can happen that, for file-mapped ranges, that that
same filesystem that is blocked on the copy request is needed to satisfy
the memory range, leading to deadlock. Dito for VFS itself, if done with
a blocking call.
This change makes the copying done from a filesystem fail in such cases
with EFAULT by VFS adding the CPF_TRY flag to the grants. If a FS call
fails with EFAULT, VFS will then request the range to be made available
to VM after the FS is unblocked, allowing it to be used to satisfy the
range if need be in another VFS thread.
Similarly, for datacopies that VFS itself does, it uses the failable
vircopy variant and callers use a wrapper that talk to VM if necessary
to get the copy to work.
. kernel: add CPF_TRY flag to safecopies
. kernel: only request writable ranges to VM for the
target buffer when copying fails
. do copying in VFS TRY-first
. some fixes in VM to build SANITYCHECK mode
. add regression test for the cases where
- a FS system call needs memory mapped in a process that the
FS itself must map.
- such a range covers more than one file-mapped region.
. add 'try' mode to vircopy, physcopy
. add flags field to copy kernel call messages
. if CP_FLAG_TRY is set, do not transparently try
to fix memory ranges
. for use by VFS when accessing user buffers to avoid
deadlock
. remove some obsolete backwards compatability assignments
. VFS: let thread scheduling work for VM requests too
Allows VFS to make calls to VM while suspending and resuming
the currently running thread. Does currently not work for the
main thread.
. VM: add fix memory range call for use by VFS
Change-Id: I295794269cea51a3163519a9cfe5901301d90b32
2014-01-16 14:22:13 +01:00
|
|
|
message *w_sendrec;
|
VFS: make all IPC asynchronous
By decoupling synchronous drivers from VFS, we are a big step closer to
supporting driver crashes under all circumstances. That is, VFS can't
become stuck on IPC with a synchronous driver (e.g., INET) and can
recover from crashing block drivers during open/close/ioctl or during
communication with an FS.
In order to maintain serialized communication with a synchronous driver,
the communication is wrapped by a mutex on a per driver basis (not major
numbers as there can be multiple majors with identical endpoints). Majors
that share a driver endpoint point to a single mutex object.
In order to support crashes from block drivers, the file reopen tactic
had to be changed; first reopen files associated with the crashed
driver, then send the new driver endpoint to FSes. This solves a
deadlock between the FS and the block driver;
- VFS would send REQ_NEW_DRIVER to an FS, but he FS only receives it
after retrying the current request to the newly started driver.
- The block driver would refuse the retried request until all files
had been reopened.
- VFS would reopen files only after getting a reply from the initial
REQ_NEW_DRIVER.
When a character special driver crashes, all associated files have to
be marked invalid and closed (or reopened if flagged as such). However,
they can only be closed if a thread holds exclusive access to it. To
obtain exclusive access, the worker thread (which handles the new driver
endpoint event from DS) schedules a new job to garbage collect invalid
files. This way, we can signal the worker thread that was talking to the
crashed driver and will release exclusive access to a file associated
with the crashed driver and prevent the garbage collecting worker thread
from dead locking on that file.
Also, when a character special driver crashes, RS will unmap the driver
and remap it upon restart. During unmapping, associated files are marked
invalid instead of waiting for an endpoint up event from DS, as that
event might come later than new read/write/select requests and thus
cause confusion in the freshly started driver.
When locking a filp, the usage counters are no longer checked. The usage
counter can legally go down to zero during filp invalidation while there
are locks pending.
DS events are handled by a separate worker thread instead of the main
thread as reopening files could lead to another crash and a stuck thread.
An additional worker thread is then necessary to unlock it.
Finally, with everything asynchronous a race condition in do_select
surfaced. A select entry was only marked in use after succesfully sending
initial select requests to drivers and having to wait. When multiple
select() calls were handled there was opportunity that these entries
were overwritten. This had as effect that some select results were
ignored (and select() remained blocking instead if returning) or do_select
tried to access filps that were not present (because thrown away by
secondary select()). This bug manifested itself with sendrecs, but was
very hard to reproduce. However, it became awfully easy to trigger with
asynsends only.
2012-08-28 16:06:51 +02:00
|
|
|
message *w_drv_sendrec;
|
|
|
|
|
endpoint_t w_task;
|
|
|
|
|
struct dmap *w_dmap;
|
2011-08-17 15:23:45 +02:00
|
|
|
struct worker_thread *w_next;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
#endif
|
