badec36b33
There is a deadlock vulnerability when there are no worker threads available and all of them blocked on a worker thread that's waiting for a reply from a driver or a reply from an FS that needs to make a back call. In these cases the deadlock resolver thread should kick in, but didn't in all cases. Moreover, POSIX calls from File Servers weren't handled properly anymore, which also could lead to deadlocks.
382 lines
11 KiB
C
382 lines
11 KiB
C
/* This file contains the table with device <-> driver mappings. It also
|
|
* contains some routines to dynamically add and/ or remove device drivers
|
|
* or change mappings.
|
|
*/
|
|
|
|
#include "fs.h"
|
|
#include <assert.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <ctype.h>
|
|
#include <unistd.h>
|
|
#include <minix/com.h>
|
|
#include <minix/ds.h>
|
|
#include "fproc.h"
|
|
#include "dmap.h"
|
|
#include "param.h"
|
|
|
|
/* The order of the entries in the table determines the mapping between major
|
|
* device numbers and device drivers. Character and block devices
|
|
* can be intermixed at random. The ordering determines the device numbers in
|
|
* /dev. Note that the major device numbers used in /dev are NOT the same as
|
|
* the process numbers of the device drivers. See <minix/dmap.h> for mappings.
|
|
*/
|
|
|
|
struct dmap dmap[NR_DEVICES];
|
|
|
|
#define DT_EMPTY { no_dev, no_dev_io, NONE, "", 0, STYLE_NDEV, NULL, NONE, \
|
|
0, NULL, 0}
|
|
|
|
/*===========================================================================*
|
|
* lock_dmap *
|
|
*===========================================================================*/
|
|
void lock_dmap(struct dmap *dp)
|
|
{
|
|
/* Lock a driver */
|
|
struct worker_thread *org_self;
|
|
struct fproc *org_fp;
|
|
int r;
|
|
|
|
assert(dp != NULL);
|
|
assert(dp->dmap_driver != NONE);
|
|
|
|
org_fp = fp;
|
|
org_self = self;
|
|
|
|
if ((r = mutex_lock(dp->dmap_lock_ref)) != 0)
|
|
panic("unable to get a lock on dmap: %d\n", r);
|
|
|
|
fp = org_fp;
|
|
self = org_self;
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* unlock_dmap *
|
|
*===========================================================================*/
|
|
void unlock_dmap(struct dmap *dp)
|
|
{
|
|
/* Unlock a driver */
|
|
int r;
|
|
|
|
assert(dp != NULL);
|
|
|
|
if ((r = mutex_unlock(dp->dmap_lock_ref)) != 0)
|
|
panic("unable to unlock dmap lock: %d\n", r);
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* do_mapdriver *
|
|
*===========================================================================*/
|
|
int do_mapdriver()
|
|
{
|
|
/* Create a device->driver mapping. RS will tell us which major is driven by
|
|
* this driver, what type of device it is (regular, TTY, asynchronous, clone,
|
|
* etc), and its label. This label is registered with DS, and allows us to
|
|
* retrieve the driver's endpoint.
|
|
*/
|
|
int r, flags, major, style;
|
|
endpoint_t endpoint;
|
|
vir_bytes label_vir;
|
|
size_t label_len;
|
|
char label[LABEL_MAX];
|
|
struct fproc *rfp;
|
|
|
|
/* Only RS can map drivers. */
|
|
if (who_e != RS_PROC_NR) return(EPERM);
|
|
|
|
label_vir = (vir_bytes) job_m_in.md_label;
|
|
label_len = (size_t) job_m_in.md_label_len;
|
|
major = job_m_in.md_major;
|
|
flags = job_m_in.md_flags;
|
|
style = job_m_in.md_style;
|
|
|
|
/* Get the label */
|
|
if (label_len+1 > sizeof(label)) { /* Can we store this label? */
|
|
printf("VFS: do_mapdriver: label too long\n");
|
|
return(EINVAL);
|
|
}
|
|
r = sys_vircopy(who_e, label_vir, SELF, (vir_bytes) label, label_len);
|
|
if (r != OK) {
|
|
printf("VFS: do_mapdriver: sys_vircopy failed: %d\n", r);
|
|
return(EINVAL);
|
|
}
|
|
label[label_len] = '\0'; /* Terminate label */
|
|
|
|
/* Now we know how the driver is called, fetch its endpoint */
|
|
r = ds_retrieve_label_endpt(label, &endpoint);
|
|
if (r != OK) {
|
|
printf("VFS: do_mapdriver: label '%s' unknown\n", label);
|
|
return(EINVAL);
|
|
}
|
|
|
|
/* Process is a service */
|
|
rfp = &fproc[_ENDPOINT_P(endpoint)];
|
|
rfp->fp_flags |= FP_SRV_PROC;
|
|
|
|
/* Try to update device mapping. */
|
|
return map_driver(label, major, endpoint, style, flags);
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* map_driver *
|
|
*===========================================================================*/
|
|
int map_driver(label, major, proc_nr_e, style, flags)
|
|
const char label[LABEL_MAX]; /* name of the driver */
|
|
int major; /* major number of the device */
|
|
endpoint_t proc_nr_e; /* process number of the driver */
|
|
int style; /* style of the device */
|
|
int flags; /* device flags */
|
|
{
|
|
/* Add a new device driver mapping in the dmap table. If the proc_nr is set to
|
|
* NONE, we're supposed to unmap it.
|
|
*/
|
|
|
|
int slot, s;
|
|
size_t len;
|
|
struct dmap *dp;
|
|
|
|
/* Get pointer to device entry in the dmap table. */
|
|
if (major < 0 || major >= NR_DEVICES) return(ENODEV);
|
|
dp = &dmap[major];
|
|
|
|
/* Check if we're supposed to unmap it. */
|
|
if (proc_nr_e == NONE) {
|
|
/* Even when a driver is now unmapped and is shortly to be mapped in
|
|
* due to recovery, invalidate associated filps if they're character
|
|
* special files. More sophisticated recovery mechanisms which would
|
|
* reduce the need to invalidate files are possible, but would require
|
|
* cooperation of the driver and more recovery framework between RS,
|
|
* VFS, and DS.
|
|
*/
|
|
invalidate_filp_by_char_major(major);
|
|
dp->dmap_opcl = no_dev;
|
|
dp->dmap_io = no_dev_io;
|
|
dp->dmap_driver = NONE;
|
|
dp->dmap_flags = flags;
|
|
dp->dmap_lock_ref = &dp->dmap_lock;
|
|
return(OK);
|
|
}
|
|
|
|
/* Check process number of new driver if it was alive before mapping */
|
|
s = isokendpt(proc_nr_e, &slot);
|
|
if (s != OK) {
|
|
/* This is not a problem only when we force this driver mapping */
|
|
if (! (flags & DRV_FORCED))
|
|
return(EINVAL);
|
|
}
|
|
|
|
if (label != NULL) {
|
|
len = strlen(label);
|
|
if (len+1 > sizeof(dp->dmap_label))
|
|
panic("VFS: map_driver: label too long: %d", len);
|
|
strlcpy(dp->dmap_label, label, LABEL_MAX);
|
|
}
|
|
|
|
/* Store driver I/O routines based on type of device */
|
|
switch (style) {
|
|
case STYLE_DEV:
|
|
dp->dmap_opcl = gen_opcl;
|
|
dp->dmap_io = gen_io;
|
|
break;
|
|
case STYLE_DEVA:
|
|
dp->dmap_opcl = gen_opcl;
|
|
dp->dmap_io = asyn_io;
|
|
break;
|
|
case STYLE_TTY:
|
|
dp->dmap_opcl = tty_opcl;
|
|
dp->dmap_io = gen_io;
|
|
break;
|
|
case STYLE_CTTY:
|
|
dp->dmap_opcl = ctty_opcl;
|
|
dp->dmap_io = ctty_io;
|
|
break;
|
|
case STYLE_CLONE:
|
|
dp->dmap_opcl = clone_opcl;
|
|
dp->dmap_io = gen_io;
|
|
break;
|
|
case STYLE_CLONE_A:
|
|
dp->dmap_opcl = clone_opcl;
|
|
dp->dmap_io = asyn_io;
|
|
break;
|
|
default:
|
|
return(EINVAL);
|
|
}
|
|
|
|
dp->dmap_driver = proc_nr_e;
|
|
dp->dmap_flags = flags;
|
|
dp->dmap_style = style;
|
|
|
|
return(OK);
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* dmap_unmap_by_endpt *
|
|
*===========================================================================*/
|
|
void dmap_unmap_by_endpt(endpoint_t proc_e)
|
|
{
|
|
/* Lookup driver in dmap table by endpoint and unmap it */
|
|
int major, r;
|
|
|
|
for (major = 0; major < NR_DEVICES; major++) {
|
|
if (dmap_driver_match(proc_e, major)) {
|
|
/* Found driver; overwrite it with a NULL entry */
|
|
if ((r = map_driver(NULL, major, NONE, 0, 0)) != OK) {
|
|
printf("VFS: unmapping driver %d for major %d failed:"
|
|
" %d\n", proc_e, major, r);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* map_service *
|
|
*===========================================================================*/
|
|
int map_service(struct rprocpub *rpub)
|
|
{
|
|
/* Map a new service by storing its device driver properties. */
|
|
int r;
|
|
struct dmap *fdp, *sdp;
|
|
struct fproc *rfp;
|
|
|
|
/* Process is a service */
|
|
rfp = &fproc[_ENDPOINT_P(rpub->endpoint)];
|
|
rfp->fp_flags |= FP_SRV_PROC;
|
|
|
|
/* Not a driver, nothing more to do. */
|
|
if (rpub->dev_nr == NO_DEV) return(OK);
|
|
|
|
/* Map driver. */
|
|
r = map_driver(rpub->label, rpub->dev_nr, rpub->endpoint, rpub->dev_style,
|
|
rpub->dev_flags);
|
|
if(r != OK) return(r);
|
|
|
|
/* If driver has two major numbers associated, also map the other one. */
|
|
if(rpub->dev_style2 != STYLE_NDEV) {
|
|
r = map_driver(rpub->label, rpub->dev_nr+1, rpub->endpoint,
|
|
rpub->dev_style2, rpub->dev_flags);
|
|
if(r != OK) return(r);
|
|
|
|
/* To ensure that future dmap lock attempts always lock the same driver
|
|
* regardless of major number, refer the second dmap lock reference
|
|
* to the first dmap entry.
|
|
*/
|
|
fdp = get_dmap_by_major(rpub->dev_nr);
|
|
sdp = get_dmap_by_major(rpub->dev_nr+1);
|
|
assert(fdp != NULL);
|
|
assert(sdp != NULL);
|
|
assert(fdp != sdp);
|
|
sdp->dmap_lock_ref = &fdp->dmap_lock;
|
|
}
|
|
|
|
return(OK);
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* init_dmap *
|
|
*===========================================================================*/
|
|
void init_dmap()
|
|
{
|
|
/* Initialize the table with empty device <-> driver mappings. */
|
|
int i;
|
|
struct dmap dmap_default = DT_EMPTY;
|
|
|
|
for (i = 0; i < NR_DEVICES; i++)
|
|
dmap[i] = dmap_default;
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* init_dmap_locks *
|
|
*===========================================================================*/
|
|
void init_dmap_locks()
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < NR_DEVICES; i++) {
|
|
if (mutex_init(&dmap[i].dmap_lock, NULL) != 0)
|
|
panic("unable to initialize dmap lock");
|
|
dmap[i].dmap_lock_ref = &dmap[i].dmap_lock;
|
|
}
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* dmap_driver_match *
|
|
*===========================================================================*/
|
|
int dmap_driver_match(endpoint_t proc, int major)
|
|
{
|
|
if (major < 0 || major >= NR_DEVICES) return(0);
|
|
if (dmap[major].dmap_driver != NONE && dmap[major].dmap_driver == proc)
|
|
return(1);
|
|
|
|
return(0);
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* dmap_by_major *
|
|
*===========================================================================*/
|
|
struct dmap *
|
|
get_dmap_by_major(int major)
|
|
{
|
|
if (major < 0 || major >= NR_DEVICES) return(NULL);
|
|
if (dmap[major].dmap_driver == NONE) return(NULL);
|
|
return(&dmap[major]);
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* dmap_endpt_up *
|
|
*===========================================================================*/
|
|
void dmap_endpt_up(endpoint_t proc_e, int is_blk)
|
|
{
|
|
/* A device driver with endpoint proc_e has been restarted. Go tell everyone
|
|
* that might be blocking on it that this device is 'up'.
|
|
*/
|
|
|
|
int major;
|
|
struct dmap *dp;
|
|
struct worker_thread *worker;
|
|
|
|
if (proc_e == NONE) return;
|
|
|
|
for (major = 0; major < NR_DEVICES; major++) {
|
|
if ((dp = get_dmap_by_major(major)) == NULL) continue;
|
|
if (dp->dmap_driver == proc_e) {
|
|
if (is_blk) {
|
|
if (dp->dmap_recovering) {
|
|
printf("VFS: driver recovery failure for"
|
|
" major %d\n", major);
|
|
if (dp->dmap_servicing != NONE) {
|
|
worker = worker_get(dp->dmap_servicing);
|
|
worker_stop(worker);
|
|
}
|
|
dp->dmap_recovering = 0;
|
|
continue;
|
|
}
|
|
dp->dmap_recovering = 1;
|
|
bdev_up(major);
|
|
dp->dmap_recovering = 0;
|
|
} else {
|
|
if (dp->dmap_servicing != NONE) {
|
|
worker = worker_get(dp->dmap_servicing);
|
|
worker_stop(worker);
|
|
}
|
|
cdev_up(major);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* get_dmap *
|
|
*===========================================================================*/
|
|
struct dmap *get_dmap(endpoint_t proc_e)
|
|
{
|
|
/* See if 'proc_e' endpoint belongs to a valid dmap entry. If so, return a
|
|
* pointer */
|
|
|
|
int major;
|
|
for (major = 0; major < NR_DEVICES; major++)
|
|
if (dmap_driver_match(proc_e, major))
|
|
return(&dmap[major]);
|
|
|
|
return(NULL);
|
|
}
|