int do_remount(const char *dir,int flags,char *data)
{
struct dentry *dentry;
int retval;
dentry = namei(dir);
retval = PTR_ERR(dentry);
if (!IS_ERR(dentry)) {
struct super_block * sb = dentry->d_inode->i_sb;
retval = -ENODEV;
if (sb) {
retval = -EINVAL;
if (dentry == sb->s_root) {
/*
* Shrink the dcache and sync the device.
*/
shrink_dcache_sb(sb);
fsync_dev(sb->s_dev);
if (flags & MS_RDONLY)
acct_auto_close(sb->s_dev);
retval = do_remount_sb(sb, flags, data);
}
}
dput(dentry);
}
return retval;
}
static int do_umount(kdev_t dev,int unmount_root)
{
struct super_block * sb;
int retval;
if (dev==ROOT_DEV && !unmount_root) {
/*
* Special case for "unmounting" root. We just try to remount
* it readonly, and sync() the device.
*/
if (!(sb=get_super(dev)))
return -ENOENT;
if (!(sb->s_flags & MS_RDONLY)) {
/*
* Make sure all quotas are turned off on this device we need to mount
* it readonly so no more writes by the quotasystem.
* If later on the remount fails too bad there are no quotas running
* anymore. Turn them on again by hand.
*/
quota_off(dev, -1);
fsync_dev(dev);
retval = do_remount_sb(sb, MS_RDONLY, 0);
if (retval)
return retval;
}
return 0;
}
if (!(sb=get_super(dev)) || !(sb->s_covered))
return -ENOENT;
if (!sb->s_covered->i_mount)
printk("VFS: umount(%s): mounted inode has i_mount=NULL\n",
kdevname(dev));
/*
* Before checking if the filesystem is still busy make sure the kernel
* doesn't hold any quotafiles open on that device. If the umount fails
* too bad there are no quotas running anymore. Turn them on again by hand.
*/
quota_off(dev, -1);
if (!fs_may_umount(dev, sb->s_mounted))
return -EBUSY;
sb->s_covered->i_mount = NULL;
iput(sb->s_covered);
sb->s_covered = NULL;
iput(sb->s_mounted);
sb->s_mounted = NULL;
if (sb->s_op && sb->s_op->write_super && sb->s_dirt)
sb->s_op->write_super(sb);
put_super(dev);
remove_vfsmnt(dev);
return 0;
}
static int do_remount(char *dir, int flags, char *data)
{
register struct inode *dir_i;
int retval;
if (!(retval = namei(dir, &dir_i, 0, 0))) {
if (dir_i != dir_i->i_sb->s_mounted) {
retval = -EINVAL;
}
else
retval = do_remount_sb(dir_i->i_sb, flags, data);
iput(dir_i);
}
return retval;
}
static int do_remount(const char *dir,int flags,char *data)
{
struct inode *dir_i;
int retval;
retval = namei(dir, &dir_i);
if (retval)
return retval;
if (dir_i != dir_i->i_sb->s_mounted) {
iput(dir_i);
return -EINVAL;
}
retval = do_remount_sb(dir_i->i_sb, flags, data);
iput(dir_i);
return retval;
}
static int do_remount(const char *dir, int flags, const void *data)
{
struct inode *dir_i;
int error;
error = namei(dir,&dir_i);
if (error)
return error;
if (dir_i != dir_i->i_sb->s_mounted) {
iput(dir_i);
return -EINVAL;
}
error = do_remount_sb(dir_i->i_sb, flags, data);
iput(dir_i);
return error;
}
static int do_umount(kdev_t dev)
{
register struct super_block *sb;
register struct super_operations *sop;
int retval = -ENOENT;
if ((sb = get_super(dev))) {
if (dev == ROOT_DEV) {
/* Special case for "unmounting" root. We just try to remount
* it readonly, and sync() the device.
*/
retval = 0;
if (!(sb->s_flags & MS_RDONLY)) {
fsync_dev(dev);
retval = do_remount_sb(sb, MS_RDONLY, 0);
}
}
else if (sb->s_covered) {
if (!sb->s_covered->i_mount)
panic("umount: i_mount=NULL\n");
if (!fs_may_umount(dev, sb->s_mounted))
retval = -EBUSY;
else {
retval = 0;
sb->s_covered->i_mount = NULL;
iput(sb->s_covered);
sb->s_covered = NULL;
iput(sb->s_mounted);
sb->s_mounted = NULL;
sop = sb->s_op;
if (sop && sop->write_super && sb->s_dirt)
sop->write_super(sb);
put_super(dev);
}
}
}
return retval;
}
static int do_umount(kdev_t dev, int unmount_root, int flags)
{
struct super_block * sb;
int retval;
retval = -ENOENT;
sb = get_super(dev);
if (!sb || !sb->s_root)
goto out;
/*
* Before checking whether the filesystem is still busy,
* make sure the kernel doesn't hold any quota files open
* on the device. If the umount fails, too bad -- there
* are no quotas running any more. Just turn them on again.
*/
DQUOT_OFF(dev);
acct_auto_close(dev);
/*
* If we may have to abort operations to get out of this
* mount, and they will themselves hold resources we must
* allow the fs to do things. In the Unix tradition of
* 'Gee thats tricky lets do it in userspace' the umount_begin
* might fail to complete on the first run through as other tasks
* must return, and the like. Thats for the mount program to worry
* about for the moment.
*/
if( (flags&MNT_FORCE) && sb->s_op->umount_begin)
sb->s_op->umount_begin(sb);
/*
* Shrink dcache, then fsync. This guarantees that if the
* filesystem is quiescent at this point, then (a) only the
* root entry should be in use and (b) that root entry is
* clean.
*/
shrink_dcache_sb(sb);
fsync_dev(dev);
if (dev==ROOT_DEV && !unmount_root) {
/*
* Special case for "unmounting" root ...
* we just try to remount it readonly.
*/
retval = 0;
if (!(sb->s_flags & MS_RDONLY))
retval = do_remount_sb(sb, MS_RDONLY, 0);
return retval;
}
retval = d_umount(sb);
if (retval)
goto out;
if (sb->s_op) {
if (sb->s_op->write_super && sb->s_dirt)
sb->s_op->write_super(sb);
}
lock_super(sb);
if (sb->s_op) {
if (sb->s_op->put_super)
sb->s_op->put_super(sb);
}
/* Forget any remaining inodes */
if (invalidate_inodes(sb)) {
printk("VFS: Busy inodes after unmount. "
"Self-destruct in 5 seconds. Have a nice day...\n");
}
sb->s_dev = 0; /* Free the superblock */
unlock_super(sb);
remove_vfsmnt(dev);
out:
return retval;
}
