minix/servers/vfs/mount.c

641 lines
18 KiB
C
Raw Normal View History

/* This file performs the MOUNT and UMOUNT system calls.
*
* The entry points into this file are
* do_mount: perform the MOUNT system call
* do_umount: perform the UMOUNT system call
* unmount: unmount a file system
*/
#include "fs.h"
#include <fcntl.h>
#include <string.h>
#include <minix/callnr.h>
#include <minix/com.h>
#include <minix/const.h>
#include <minix/endpoint.h>
#include <minix/syslib.h>
#include <minix/bitmap.h>
#include <minix/ds.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/mount.h>
#include <sys/dirent.h>
2012-02-13 16:28:04 +01:00
#include <assert.h>
#include "file.h"
#include <minix/vfsif.h>
#include "vnode.h"
#include "vmnt.h"
2012-02-13 16:28:04 +01:00
#include "path.h"
/* Allow the root to be replaced before the first 'real' mount. */
2012-03-25 20:25:53 +02:00
static int have_root = 0;
/* Bitmap of in-use "none" pseudo devices. */
2012-03-25 20:25:53 +02:00
static bitchunk_t nonedev[BITMAP_CHUNKS(NR_NONEDEVS)] = { 0 };
#define alloc_nonedev(dev) SET_BIT(nonedev, minor(dev) - 1)
#define free_nonedev(dev) UNSET_BIT(nonedev, minor(dev) - 1)
2012-03-25 20:25:53 +02:00
static dev_t name_to_dev(int allow_mountpt, char path[PATH_MAX]);
static dev_t find_free_nonedev(void);
static void update_bspec(dev_t dev, endpoint_t fs_e, int send_drv_e);
/*===========================================================================*
* update_bspec *
*===========================================================================*/
2012-03-25 20:25:53 +02:00
static void update_bspec(dev_t dev, endpoint_t fs_e, int send_drv_e)
{
/* Update all block special files for a certain device, to use a new FS endpt
* to route raw block I/O requests through.
*/
struct vnode *vp;
2012-02-13 16:28:04 +01:00
struct dmap *dp;
int r, major;
for (vp = &vnode[0]; vp < &vnode[NR_VNODES]; ++vp)
2012-02-13 16:28:04 +01:00
if (vp->v_ref_count > 0 && S_ISBLK(vp->v_mode) && vp->v_sdev == dev) {
vp->v_bfs_e = fs_e;
2012-02-13 16:28:04 +01:00
if (send_drv_e) {
major = major(dev);
if (major < 0 || major >= NR_DEVICES) {
/* Can't update for out-of-range major */
continue;
}
dp = &dmap[major(dev)];
if (dp->dmap_driver == NONE) {
/* Can't update for vanished driver */
printf("VFS: can't send new driver label\n");
continue;
}
if ((r = req_newdriver(fs_e, vp->v_sdev,
dp->dmap_label)) != OK) {
printf("VFS: Failed to send new driver label"
" for moved block special file to %d\n",
fs_e);
}
}
}
}
/*===========================================================================*
* do_mount *
*===========================================================================*/
int do_mount(void)
{
2012-02-13 16:28:04 +01:00
/* Perform the mount(name, mfile, mount_flags) system call. */
Driver refactory for live update and crash recovery. SYSLIB CHANGES: - DS calls to publish / retrieve labels consider endpoints instead of u32_t. VFS CHANGES: - mapdriver() only adds an entry in the dmap table in VFS. - dev_up() is only executed upon reception of a driver up event. INET CHANGES: - INET no longer searches for existing drivers instances at startup. - A newtwork driver is (re)initialized upon reception of a driver up event. - Networking startup is now race-free by design. No need to waste 5 seconds at startup any more. DRIVER CHANGES: - Every driver publishes driver up events when starting for the first time or in case of restart when recovery actions must be taken in the upper layers. - Driver up events are published by drivers through DS. - For regular drivers, VFS is normally the only subscriber, but not necessarily. For instance, when the filter driver is in use, it must subscribe to driver up events to initiate recovery. - For network drivers, inet is the only subscriber for now. - Every VFS driver is statically linked with libdriver, every network driver is statically linked with libnetdriver. DRIVER LIBRARIES CHANGES: - Libdriver is extended to provide generic receive() and ds_publish() interfaces for VFS drivers. - driver_receive() is a wrapper for sef_receive() also used in driver_task() to discard spurious messages that were meant to be delivered to a previous version of the driver. - driver_receive_mq() is the same as driver_receive() but integrates support for queued messages. - driver_announce() publishes a driver up event for VFS drivers and marks the driver as initialized and expecting a DEV_OPEN message. - Libnetdriver is introduced to provide similar receive() and ds_publish() interfaces for network drivers (netdriver_announce() and netdriver_receive()). - Network drivers all support live update with no state transfer now. KERNEL CHANGES: - Added kernel call statectl for state management. Used by driver_announce() to unblock eventual callers sendrecing to the driver.
2010-04-08 15:41:35 +02:00
endpoint_t fs_e;
int r, slot, nodev;
char mount_path[PATH_MAX], mount_dev[PATH_MAX];
char mount_label[LABEL_MAX], mount_type[FSTYPE_MAX];
2012-02-13 16:28:04 +01:00
dev_t dev;
int mflags;
vir_bytes label, type, vname1, vname2;
size_t vname1_length, vname2_length, label_len, type_len;
mflags = job_m_in.VFS_MOUNT_FLAGS;
label = (vir_bytes) job_m_in.VFS_MOUNT_LABEL;
label_len = (size_t) job_m_in.VFS_MOUNT_LABELLEN;
vname1 = (vir_bytes) job_m_in.VFS_MOUNT_DEV;
vname1_length = (size_t) job_m_in.VFS_MOUNT_DEVLEN;
vname2 = (vir_bytes) job_m_in.VFS_MOUNT_PATH;
vname2_length = (size_t) job_m_in.VFS_MOUNT_PATHLEN;
type = (vir_bytes) job_m_in.VFS_MOUNT_TYPE;
type_len = (size_t) job_m_in.VFS_MOUNT_TYPELEN;
/* Only the super-user may do MOUNT. */
if (!super_user) return(EPERM);
2012-02-13 16:28:04 +01:00
/* Get the label from the caller, and ask DS for the endpoint of the FS. */
if (label_len > sizeof(mount_label))
return EINVAL;
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
r = sys_datacopy_wrapper(who_e, label, SELF, (vir_bytes) mount_label,
sizeof(mount_label));
if (r != OK) return(r);
mount_label[sizeof(mount_label)-1] = 0;
r = ds_retrieve_label_endpt(mount_label, &fs_e);
if (r != OK) return(r);
/* Sanity check on process number. */
2012-02-13 16:28:04 +01:00
if (isokendpt(fs_e, &slot) != OK) return(EINVAL);
2009-01-20 14:43:00 +01:00
/* A null string for block special device means don't use a device at all. */
nodev = (vname1_length == 0);
if (!nodev) {
/* If 'name' is not for a block special file, return error. */
if (fetch_name(vname1, vname1_length, mount_dev) != OK)
return(err_code);
if ((dev = name_to_dev(FALSE /*allow_mountpt*/, mount_dev)) == NO_DEV)
return(err_code);
} else {
/* Find a free pseudo-device as substitute for an actual device. */
if ((dev = find_free_nonedev()) == NO_DEV)
return(err_code);
strlcpy(mount_dev, "none", sizeof(mount_dev));
}
2012-02-13 16:28:04 +01:00
/* Fetch the name of the mountpoint */
if (fetch_name(vname2, vname2_length, mount_path) != OK) return(err_code);
2012-02-13 16:28:04 +01:00
/* Fetch the type of the file system. */
if (type_len > sizeof(mount_type)) return(ENAMETOOLONG);
if (fetch_name(type, type_len, mount_type) != OK) return(err_code);
2012-02-13 16:28:04 +01:00
/* Do the actual job */
return mount_fs(dev, mount_dev, mount_path, fs_e, mflags, mount_type,
mount_label);
2012-02-13 16:28:04 +01:00
}
/*===========================================================================*
* mount_fs *
*===========================================================================*/
2012-03-25 20:25:53 +02:00
int mount_fs(
2012-02-13 16:28:04 +01:00
dev_t dev,
char mount_dev[PATH_MAX],
char mount_path[PATH_MAX],
2012-02-13 16:28:04 +01:00
endpoint_t fs_e,
int flags,
char mount_type[FSTYPE_MAX],
2012-02-13 16:28:04 +01:00
char mount_label[LABEL_MAX] )
{
int i, r = OK, found, isroot, mount_root, slot;
2012-02-13 16:28:04 +01:00
struct fproc *tfp, *rfp;
struct dmap *dp;
struct vnode *root_node, *vp = NULL;
struct vmnt *new_vmp, *parent_vmp;
char *label;
struct node_details res;
struct lookup resolve;
struct statvfs statvfs_buf;
unsigned int fs_flags;
2012-02-13 16:28:04 +01:00
/* Look up block device driver label when dev is not a pseudo-device */
label = "";
if (!is_nonedev(dev)) {
/* Get driver process' endpoint */
dp = &dmap[major(dev)];
if (dp->dmap_driver == NONE) {
printf("VFS: no driver for dev %llx\n", dev);
2012-02-13 16:28:04 +01:00
return(EINVAL);
}
2012-02-13 16:28:04 +01:00
label = dp->dmap_label;
assert(strlen(label) > 0);
}
2012-02-13 16:28:04 +01:00
/* Scan vmnt table to see if dev already mounted. If not, find a free slot.*/
2012-02-13 16:28:04 +01:00
found = FALSE;
for (i = 0; i < NR_MNTS; ++i) {
2012-02-13 16:28:04 +01:00
if (vmnt[i].m_dev == dev) found = TRUE;
}
if (found) {
2012-02-13 16:28:04 +01:00
return(EBUSY);
} else if ((new_vmp = get_free_vmnt()) == NULL) {
return(ENOMEM);
}
if ((r = lock_vmnt(new_vmp, VMNT_EXCL)) != OK) return(r);
strlcpy(new_vmp->m_mount_path, mount_path, PATH_MAX);
strlcpy(new_vmp->m_mount_dev, mount_dev, PATH_MAX);
strlcpy(new_vmp->m_fstype, mount_type, sizeof(new_vmp->m_fstype));
isroot = (strcmp(mount_path, "/") == 0);
2012-02-13 16:28:04 +01:00
mount_root = (isroot && have_root < 2); /* Root can be mounted twice:
* 1: ramdisk
* 2: boot disk (e.g., harddisk)
*/
if (!mount_root) {
/* Get vnode of mountpoint */
lookup_init(&resolve, mount_path, PATH_NOFLAGS, &parent_vmp, &vp);
2012-02-13 16:28:04 +01:00
resolve.l_vmnt_lock = VMNT_EXCL;
resolve.l_vnode_lock = VNODE_WRITE;
if ((vp = eat_path(&resolve, fp)) == NULL)
r = err_code;
else if (vp->v_ref_count == 1) {
/*Tell FS on which vnode it is mounted (glue into mount tree)*/
r = req_mountpoint(vp->v_fs_e, vp->v_inode_nr);
} else
r = EBUSY;
if (vp != NULL) {
/* Quickly unlock to allow back calls (from e.g. FUSE) to
* relock */
unlock_vmnt(parent_vmp);
2007-08-07 14:52:47 +02:00
}
if (r != OK) {
2012-02-13 16:28:04 +01:00
if (vp != NULL) {
unlock_vnode(vp);
put_vnode(vp);
}
unlock_vmnt(new_vmp);
2007-08-07 14:52:47 +02:00
return(r);
}
}
2012-02-13 16:28:04 +01:00
/* We'll need a vnode for the root inode */
if ((root_node = get_free_vnode()) == NULL) {
if (vp != NULL) {
unlock_vnode(vp);
put_vnode(vp);
}
2012-02-13 16:28:04 +01:00
unlock_vmnt(new_vmp);
return(err_code);
}
lock_vnode(root_node, VNODE_OPCL);
2012-02-13 16:28:04 +01:00
/* Record process as a system process */
if (isokendpt(fs_e, &slot) != OK) {
if (vp != NULL) {
unlock_vnode(vp);
put_vnode(vp);
2007-08-07 14:52:47 +02:00
}
2012-02-13 16:28:04 +01:00
unlock_vnode(root_node);
unlock_vmnt(new_vmp);
return(EINVAL);
}
2012-02-13 16:28:04 +01:00
rfp = &fproc[slot];
rfp->fp_flags |= FP_SRV_PROC; /* File Servers are also services */
2012-02-13 16:28:04 +01:00
/* Store some essential vmnt data first */
new_vmp->m_fs_e = fs_e;
new_vmp->m_dev = dev;
if (flags & MNT_RDONLY) new_vmp->m_flags |= VMNT_READONLY;
2012-02-13 16:28:04 +01:00
else new_vmp->m_flags &= ~VMNT_READONLY;
/* Tell FS which device to mount */
2012-02-13 16:28:04 +01:00
new_vmp->m_flags |= VMNT_MOUNTING;
r = req_readsuper(new_vmp, label, dev, !!(flags & MNT_RDONLY), isroot, &res,
&fs_flags);
2012-02-13 16:28:04 +01:00
new_vmp->m_flags &= ~VMNT_MOUNTING;
new_vmp->m_fs_flags = fs_flags;
/* Fill the statvfs cache with initial values. */
if (r == OK)
r = update_statvfs(new_vmp, &statvfs_buf);
2012-02-13 16:28:04 +01:00
if (r != OK) {
mark_vmnt_free(new_vmp);
2012-02-13 16:28:04 +01:00
unlock_vnode(root_node);
if (vp != NULL) {
unlock_vnode(vp);
put_vnode(vp);
}
unlock_vmnt(new_vmp);
return(r);
}
2012-02-13 16:28:04 +01:00
lock_bsf();
/* Fill in root node's fields */
root_node->v_fs_e = res.fs_e;
root_node->v_inode_nr = res.inode_nr;
root_node->v_mode = res.fmode;
root_node->v_uid = res.uid;
root_node->v_gid = res.gid;
root_node->v_size = res.fsize;
root_node->v_sdev = NO_DEV;
2007-08-07 14:52:47 +02:00
root_node->v_fs_count = 1;
2007-01-05 17:36:55 +01:00
root_node->v_ref_count = 1;
2012-02-13 16:28:04 +01:00
/* Root node is indeed on the partition */
2012-02-13 16:28:04 +01:00
root_node->v_vmnt = new_vmp;
root_node->v_dev = new_vmp->m_dev;
if (!(new_vmp->m_fs_flags & RES_THREADED))
new_vmp->m_comm.c_max_reqs = 1;
2012-02-13 16:28:04 +01:00
else
new_vmp->m_comm.c_max_reqs = NR_WTHREADS;
2012-02-13 16:28:04 +01:00
new_vmp->m_comm.c_cur_reqs = 0;
/* No more blocking operations, so we can now report on this file system. */
new_vmp->m_flags |= VMNT_CANSTAT;
2012-02-13 16:28:04 +01:00
if (mount_root) {
/* Superblock and root node already read.
* Nothing else can go wrong. Perform the mount. */
2012-02-13 16:28:04 +01:00
new_vmp->m_root_node = root_node;
new_vmp->m_mounted_on = NULL;
2012-07-13 18:08:06 +02:00
strlcpy(new_vmp->m_label, mount_label, LABEL_MAX);
2012-02-13 16:28:04 +01:00
if (is_nonedev(dev)) alloc_nonedev(dev);
update_bspec(dev, fs_e, 0 /* Don't send new driver endpoint */);
2012-02-13 16:28:04 +01:00
ROOT_DEV = dev;
ROOT_FS_E = fs_e;
/* Replace all root and working directories */
2012-02-13 16:28:04 +01:00
for (i = 0, tfp = fproc; i < NR_PROCS; i++, tfp++) {
if (tfp->fp_pid == PID_FREE)
continue;
2012-02-13 16:28:04 +01:00
#define MAKEROOT(what) { \
if (what) put_vnode(what); \
dup_vnode(root_node); \
what = root_node; \
}
2012-02-13 16:28:04 +01:00
MAKEROOT(tfp->fp_rd);
MAKEROOT(tfp->fp_wd);
}
2012-02-13 16:28:04 +01:00
unlock_vnode(root_node);
unlock_vmnt(new_vmp);
have_root++; /* We have a (new) root */
unlock_bsf();
return(OK);
}
2012-02-13 16:28:04 +01:00
/* File types may not conflict. */
2012-04-25 14:44:42 +02:00
if (!S_ISDIR(vp->v_mode) && S_ISDIR(root_node->v_mode)) r = EISDIR;
/* If error, return the super block and both inodes; release the vmnt. */
if (r != OK) {
2012-02-13 16:28:04 +01:00
unlock_vnode(vp);
unlock_vnode(root_node);
mark_vmnt_free(new_vmp);
2012-02-13 16:28:04 +01:00
unlock_vmnt(new_vmp);
put_vnode(vp);
put_vnode(root_node);
2012-02-13 16:28:04 +01:00
unlock_bsf();
return(r);
}
/* Nothing else can go wrong. Perform the mount. */
2012-02-13 16:28:04 +01:00
new_vmp->m_mounted_on = vp;
new_vmp->m_root_node = root_node;
2012-07-13 18:08:06 +02:00
strlcpy(new_vmp->m_label, mount_label, LABEL_MAX);
/* Allocate the pseudo device that was found, if not using a real device. */
2012-02-13 16:28:04 +01:00
if (is_nonedev(dev)) alloc_nonedev(dev);
/* The new FS will handle block I/O requests for its device now. */
2012-02-13 16:28:04 +01:00
if (!(new_vmp->m_flags & VMNT_FORCEROOTBSF))
update_bspec(dev, fs_e, 0 /* Don't send new driver endpoint */);
unlock_vnode(vp);
unlock_vnode(root_node);
unlock_vmnt(new_vmp);
unlock_bsf();
return(OK);
}
2012-02-13 16:28:04 +01:00
/*===========================================================================*
* mount_pfs *
*===========================================================================*/
2012-03-25 20:25:53 +02:00
void mount_pfs(void)
2012-02-13 16:28:04 +01:00
{
/* Mount the Pipe File Server. It's not really mounted onto the file system,
but it's necessary it has a vmnt entry to make locking easier */
dev_t dev;
struct vmnt *vmp;
if ((dev = find_free_nonedev()) == NO_DEV)
panic("VFS: no nonedev to initialize PFS");
if ((vmp = get_free_vmnt()) == NULL)
panic("VFS: no vmnt to initialize PFS");
alloc_nonedev(dev);
vmp->m_dev = dev;
vmp->m_fs_e = PFS_PROC_NR;
vmp->m_fs_flags = 0;
2012-07-13 18:08:06 +02:00
strlcpy(vmp->m_label, "pfs", LABEL_MAX);
strlcpy(vmp->m_mount_path, "pipe", PATH_MAX);
strlcpy(vmp->m_mount_dev, "none", PATH_MAX);
2012-02-13 16:28:04 +01:00
}
/*===========================================================================*
* do_umount *
*===========================================================================*/
int do_umount(void)
{
/* Perform the umount(name) system call. Return the label of the FS service.
*/
char label[LABEL_MAX];
dev_t dev;
int r;
2012-02-13 16:28:04 +01:00
char fullpath[PATH_MAX];
vir_bytes vname, label_addr;
size_t vname_length, label_len;
vname = (vir_bytes) job_m_in.VFS_UMOUNT_NAME;
vname_length = (size_t) job_m_in.VFS_UMOUNT_NAMELEN;
label_addr = (vir_bytes) job_m_in.VFS_UMOUNT_LABEL;
label_len = (size_t) job_m_in.VFS_UMOUNT_LABELLEN;
2012-02-13 16:28:04 +01:00
/* Only the super-user may do umount. */
if (!super_user) return(EPERM);
2012-02-13 16:28:04 +01:00
/* If 'name' is not for a block special file or mountpoint, return error. */
if (fetch_name(vname, vname_length, fullpath) != OK)
return(err_code);
2012-02-13 16:28:04 +01:00
if ((dev = name_to_dev(TRUE /*allow_mountpt*/, fullpath)) == NO_DEV)
return(err_code);
2012-02-13 16:28:04 +01:00
if ((r = unmount(dev, label)) != OK) return(r);
/* Return the label of the mounted file system, so that the caller
* can shut down the corresponding server process.
*/
if (strlen(label) >= label_len)
label[label_len-1] = 0;
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
return sys_datacopy_wrapper(SELF, (vir_bytes) label, who_e, label_addr,
strlen(label) + 1);
}
/*===========================================================================*
2012-09-04 14:11:54 +02:00
* unmount *
*===========================================================================*/
2012-03-25 20:25:53 +02:00
int unmount(
dev_t dev, /* block-special device */
2012-07-13 18:08:06 +02:00
char label[LABEL_MAX] /* buffer to retrieve label, or NULL */
)
{
struct vnode *vp;
struct vmnt *vmp_i = NULL, *vmp = NULL;
2012-02-13 16:28:04 +01:00
int count, locks, r;
/* Find vmnt that is to be unmounted */
2012-02-13 16:28:04 +01:00
for (vmp_i = &vmnt[0]; vmp_i < &vmnt[NR_MNTS]; ++vmp_i) {
if (vmp_i->m_dev == dev) {
if(vmp) panic("device mounted more than once: %llx", dev);
vmp = vmp_i;
}
}
/* Did we find the vmnt (i.e., was dev a mounted device)? */
if(!vmp) return(EINVAL);
2012-02-13 16:28:04 +01:00
if ((r = lock_vmnt(vmp, VMNT_EXCL)) != OK) return(r);
/* See if the mounted device is busy. Only 1 vnode using it should be
* open -- the root vnode -- and that inode only 1 time. */
2012-02-13 16:28:04 +01:00
locks = count = 0;
for (vp = &vnode[0]; vp < &vnode[NR_VNODES]; vp++)
if (vp->v_ref_count > 0 && vp->v_dev == dev) {
count += vp->v_ref_count;
if (is_vnode_locked(vp)) locks++;
}
if (count > 1 || locks > 1 || tll_haspendinglock(&vmp->m_lock)) {
unlock_vmnt(vmp);
return(EBUSY); /* can't umount a busy file system */
}
/* This FS will now disappear, so stop listing it in statistics. */
vmp->m_flags &= ~VMNT_CANSTAT;
/* Tell FS to drop all inode references for root inode except 1. */
2007-01-05 17:36:55 +01:00
vnode_clean_refs(vmp->m_root_node);
if (vmp->m_mounted_on) {
put_vnode(vmp->m_mounted_on);
vmp->m_mounted_on = NULL;
}
2012-02-13 16:28:04 +01:00
vmp->m_comm.c_max_reqs = 1; /* Force max concurrent reqs to just one, so
* we won't send any messages after the
* unmount request */
2012-02-13 16:28:04 +01:00
/* Tell FS to unmount */
if ((r = req_unmount(vmp->m_fs_e)) != OK) /* Not recoverable. */
2012-02-13 16:28:04 +01:00
printf("VFS: ignoring failed umount attempt FS endpoint: %d (%d)\n",
vmp->m_fs_e, r);
if (is_nonedev(vmp->m_dev)) free_nonedev(vmp->m_dev);
2012-07-13 18:08:06 +02:00
if (label != NULL) strlcpy(label, vmp->m_label, LABEL_MAX);
2012-02-13 16:28:04 +01:00
if (vmp->m_root_node) { /* PFS lacks a root node */
vmp->m_root_node->v_ref_count = 0;
vmp->m_root_node->v_fs_count = 0;
vmp->m_root_node->v_sdev = NO_DEV;
vmp->m_root_node = NULL;
}
mark_vmnt_free(vmp);
2012-02-13 16:28:04 +01:00
unlock_vmnt(vmp);
/* The root FS will handle block I/O requests for this device now. */
lock_bsf();
update_bspec(dev, ROOT_FS_E, 1 /* send new driver endpoint */);
unlock_bsf();
return(OK);
}
2012-02-13 16:28:04 +01:00
/*===========================================================================*
* unmount_all *
*===========================================================================*/
void unmount_all(int force)
2012-02-13 16:28:04 +01:00
{
/* Unmount all filesystems. File systems are mounted on other file systems,
* so you have to pull off the loose bits repeatedly to get it all undone.
*/
int i;
struct vmnt *vmp;
/* Now unmount the rest */
for (i = 0; i < NR_MNTS; i++) {
/* Unmount at least one. */
for (vmp = &vmnt[0]; vmp < &vmnt[NR_MNTS]; vmp++) {
if (vmp->m_dev != NO_DEV)
unmount(vmp->m_dev, NULL);
}
}
2012-09-04 14:11:54 +02:00
if (!force) return;
2012-09-04 14:11:54 +02:00
/* Verify nothing is locked anymore */
2012-02-13 16:28:04 +01:00
check_vnode_locks();
check_vmnt_locks();
check_filp_locks();
check_bsf_lock();
2012-09-04 14:11:54 +02:00
/* Verify we succesfully unmounted all file systems */
for (vmp = &vmnt[0]; vmp < &vmnt[NR_MNTS]; vmp++) {
if (vmp->m_dev != NO_DEV) {
panic("vmp still mounted: %s %d %llx\n", vmp->m_label,
2012-09-04 14:11:54 +02:00
vmp->m_fs_e, vmp->m_dev);
}
}
2012-02-13 16:28:04 +01:00
}
/*===========================================================================*
* name_to_dev *
*===========================================================================*/
2012-03-25 20:25:53 +02:00
static dev_t name_to_dev(int allow_mountpt, char path[PATH_MAX])
{
/* Convert the block special file in 'user_fullpath' to a device number.
* If the given path is not a block special file, but 'allow_mountpt' is set
* and the path is the root node of a mounted file system, return that device
* number. In all other cases, return NO_DEV and an error code in 'err_code'.
*/
2007-08-07 14:52:47 +02:00
dev_t dev;
struct vnode *vp;
2012-02-13 16:28:04 +01:00
struct vmnt *vmp;
struct lookup resolve;
lookup_init(&resolve, path, PATH_NOFLAGS, &vmp, &vp);
resolve.l_vmnt_lock = VMNT_READ;
resolve.l_vnode_lock = VNODE_READ;
/* Request lookup */
2012-02-13 16:28:04 +01:00
if ((vp = eat_path(&resolve, fp)) == NULL) return(NO_DEV);
2012-04-25 14:44:42 +02:00
if (S_ISBLK(vp->v_mode)) {
dev = vp->v_sdev;
} else if (allow_mountpt && vp->v_vmnt->m_root_node == vp) {
dev = vp->v_dev;
} else {
2012-02-13 16:28:04 +01:00
err_code = ENOTBLK;
dev = NO_DEV;
}
2007-08-07 14:52:47 +02:00
2012-02-13 16:28:04 +01:00
unlock_vnode(vp);
unlock_vmnt(vmp);
2007-08-07 14:52:47 +02:00
put_vnode(vp);
return(dev);
}
/*===========================================================================*
* is_nonedev *
*===========================================================================*/
2012-03-25 20:25:53 +02:00
int is_nonedev(dev_t dev)
{
/* Return whether the given device is a "none" pseudo device.
*/
return (major(dev) == NONE_MAJOR &&
minor(dev) > 0 && minor(dev) <= NR_NONEDEVS);
}
/*===========================================================================*
* find_free_nonedev *
*===========================================================================*/
2012-03-25 20:25:53 +02:00
static dev_t find_free_nonedev(void)
{
/* Find a free "none" pseudo device. Do not allocate it yet.
*/
int i;
for (i = 0; i < NR_NONEDEVS; i++)
if (!GET_BIT(nonedev, i))
return makedev(NONE_MAJOR, i + 1);
err_code = EMFILE;
return NO_DEV;
}