#endif
INIT_LIST_HEAD(&p->mnt_hash);
- INIT_LIST_HEAD(&mnt->mnt_child);
- INIT_LIST_HEAD(&mnt->mnt_mounts);
+ INIT_LIST_HEAD(&p->mnt_child);
+ INIT_LIST_HEAD(&p->mnt_mounts);
INIT_LIST_HEAD(&mnt->mnt_list);
- INIT_LIST_HEAD(&mnt->mnt_expire);
- INIT_LIST_HEAD(&mnt->mnt_share);
- INIT_LIST_HEAD(&mnt->mnt_slave_list);
- INIT_LIST_HEAD(&mnt->mnt_slave);
+ INIT_LIST_HEAD(&p->mnt_expire);
+ INIT_LIST_HEAD(&p->mnt_share);
+ INIT_LIST_HEAD(&p->mnt_slave_list);
+ INIT_LIST_HEAD(&p->mnt_slave);
#ifdef CONFIG_FSNOTIFY
INIT_HLIST_HEAD(&mnt->mnt_fsnotify_marks);
#endif
old_path->mnt = &mnt->mnt_parent->mnt;
mnt->mnt_parent = mnt;
mnt->mnt_mountpoint = mnt->mnt.mnt_root;
- list_del_init(&mnt->mnt.mnt_child);
+ list_del_init(&mnt->mnt_child);
list_del_init(&mnt->mnt_hash);
dentry_reset_mounted(old_path->dentry);
}
/*
* vfsmount lock must be held for write
*/
-void mnt_set_mountpoint(struct vfsmount *mnt, struct dentry *dentry,
+void mnt_set_mountpoint(struct mount *mnt, struct dentry *dentry,
struct mount *child_mnt)
{
- child_mnt->mnt_parent = real_mount(mntget(mnt));
+ child_mnt->mnt_parent = real_mount(mntget(&mnt->mnt));
child_mnt->mnt_mountpoint = dget(dentry);
spin_lock(&dentry->d_lock);
dentry->d_flags |= DCACHE_MOUNTED;
*/
static void attach_mnt(struct mount *mnt, struct path *path)
{
- mnt_set_mountpoint(path->mnt, path->dentry, mnt);
+ mnt_set_mountpoint(real_mount(path->mnt), path->dentry, mnt);
list_add_tail(&mnt->mnt_hash, mount_hashtable +
hash(path->mnt, path->dentry));
- list_add_tail(&mnt->mnt.mnt_child, &path->mnt->mnt_mounts);
+ list_add_tail(&mnt->mnt_child, &real_mount(path->mnt)->mnt_mounts);
}
static inline void __mnt_make_longterm(struct mount *mnt)
list_add_tail(&mnt->mnt_hash, mount_hashtable +
hash(&parent->mnt, mnt->mnt_mountpoint));
- list_add_tail(&mnt->mnt.mnt_child, &parent->mnt.mnt_mounts);
+ list_add_tail(&mnt->mnt_child, &parent->mnt_mounts);
touch_mnt_namespace(n);
}
static struct mount *next_mnt(struct mount *p, struct vfsmount *root)
{
- struct list_head *next = p->mnt.mnt_mounts.next;
- if (next == &p->mnt.mnt_mounts) {
+ struct list_head *next = p->mnt_mounts.next;
+ if (next == &p->mnt_mounts) {
while (1) {
if (&p->mnt == root)
return NULL;
- next = p->mnt.mnt_child.next;
- if (next != &p->mnt_parent->mnt.mnt_mounts)
+ next = p->mnt_child.next;
+ if (next != &p->mnt_parent->mnt_mounts)
break;
p = p->mnt_parent;
}
}
- return list_entry(next, struct mount, mnt.mnt_child);
+ return list_entry(next, struct mount, mnt_child);
}
static struct mount *skip_mnt_tree(struct mount *p)
{
- struct list_head *prev = p->mnt.mnt_mounts.prev;
- while (prev != &p->mnt.mnt_mounts) {
- p = list_entry(prev, struct mount, mnt.mnt_child);
- prev = p->mnt.mnt_mounts.prev;
+ struct list_head *prev = p->mnt_mounts.prev;
+ while (prev != &p->mnt_mounts) {
+ p = list_entry(prev, struct mount, mnt_child);
+ prev = p->mnt_mounts.prev;
}
return p;
}
mnt->mnt_parent = mnt;
if (flag & CL_SLAVE) {
- list_add(&mnt->mnt.mnt_slave, &old->mnt.mnt_slave_list);
- mnt->mnt.mnt_master = &old->mnt;
+ list_add(&mnt->mnt_slave, &old->mnt_slave_list);
+ mnt->mnt_master = old;
CLEAR_MNT_SHARED(&mnt->mnt);
} else if (!(flag & CL_PRIVATE)) {
if ((flag & CL_MAKE_SHARED) || IS_MNT_SHARED(&old->mnt))
- list_add(&mnt->mnt.mnt_share, &old->mnt.mnt_share);
- if (IS_MNT_SLAVE(&old->mnt))
- list_add(&mnt->mnt.mnt_slave, &old->mnt.mnt_slave);
- mnt->mnt.mnt_master = old->mnt.mnt_master;
+ list_add(&mnt->mnt_share, &old->mnt_share);
+ if (IS_MNT_SLAVE(old))
+ list_add(&mnt->mnt_slave, &old->mnt_slave);
+ mnt->mnt_master = old->mnt_master;
}
if (flag & CL_MAKE_SHARED)
set_mnt_shared(mnt);
/* stick the duplicate mount on the same expiry list
* as the original if that was on one */
if (flag & CL_EXPIRE) {
- if (!list_empty(&old->mnt.mnt_expire))
- list_add(&mnt->mnt.mnt_expire, &old->mnt.mnt_expire);
+ if (!list_empty(&old->mnt_expire))
+ list_add(&mnt->mnt_expire, &old->mnt_expire);
}
}
return mnt;
deactivate_super(sb);
}
-static void mntput_no_expire(struct vfsmount *m)
+static void mntput_no_expire(struct mount *mnt)
{
- struct mount *mnt = real_mount(m);
put_again:
#ifdef CONFIG_SMP
br_read_lock(vfsmount_lock);
mnt_add_count(mnt, mnt->mnt.mnt_pinned + 1);
mnt->mnt.mnt_pinned = 0;
br_write_unlock(vfsmount_lock);
- acct_auto_close_mnt(m);
+ acct_auto_close_mnt(&mnt->mnt);
goto put_again;
}
br_write_unlock(vfsmount_lock);
/* avoid cacheline pingpong, hope gcc doesn't get "smart" */
if (unlikely(mnt->mnt_expiry_mark))
mnt->mnt_expiry_mark = 0;
- mntput_no_expire(mnt);
+ mntput_no_expire(real_mount(mnt));
}
}
EXPORT_SYMBOL(mntput);
/* Tagged fields ("foo:X" or "bar") */
if (IS_MNT_SHARED(mnt))
seq_printf(m, " shared:%i", mnt->mnt_group_id);
- if (IS_MNT_SLAVE(mnt)) {
- int master = mnt->mnt_master->mnt_group_id;
- int dom = get_dominating_id(mnt, &p->root);
+ if (IS_MNT_SLAVE(r)) {
+ int master = r->mnt_master->mnt.mnt_group_id;
+ int dom = get_dominating_id(r, &p->root);
seq_printf(m, " master:%i", master);
if (dom && dom != master)
seq_printf(m, " propagate_from:%i", dom);
propagate_umount(&tmp_list);
list_for_each_entry(p, &tmp_list, mnt_hash) {
- list_del_init(&p->mnt.mnt_expire);
+ list_del_init(&p->mnt_expire);
list_del_init(&p->mnt.mnt_list);
__touch_mnt_namespace(p->mnt.mnt_ns);
p->mnt.mnt_ns = NULL;
__mnt_make_shortterm(p);
- list_del_init(&p->mnt.mnt_child);
+ list_del_init(&p->mnt_child);
if (mnt_has_parent(p)) {
p->mnt_parent->mnt.mnt_ghosts++;
dentry_reset_mounted(p->mnt_mountpoint);
SYSCALL_DEFINE2(umount, char __user *, name, int, flags)
{
struct path path;
+ struct mount *mnt;
int retval;
int lookup_flags = 0;
retval = user_path_at(AT_FDCWD, name, lookup_flags, &path);
if (retval)
goto out;
+ mnt = real_mount(path.mnt);
retval = -EINVAL;
if (path.dentry != path.mnt->mnt_root)
goto dput_and_out;
if (!capable(CAP_SYS_ADMIN))
goto dput_and_out;
- retval = do_umount(real_mount(path.mnt), flags);
+ retval = do_umount(mnt, flags);
dput_and_out:
/* we mustn't call path_put() as that would clear mnt_expiry_mark */
dput(path.dentry);
- mntput_no_expire(path.mnt);
+ mntput_no_expire(mnt);
out:
return retval;
}
q->mnt_mountpoint = mnt->mnt_mountpoint;
p = mnt;
- list_for_each_entry(r, &mnt->mnt.mnt_mounts, mnt.mnt_child) {
+ list_for_each_entry(r, &mnt->mnt_mounts, mnt_child) {
struct mount *s;
if (!is_subdir(r->mnt_mountpoint, dentry))
continue;
struct path *path, struct path *parent_path)
{
LIST_HEAD(tree_list);
- struct vfsmount *dest_mnt = path->mnt;
+ struct mount *dest_mnt = real_mount(path->mnt);
struct dentry *dest_dentry = path->dentry;
struct mount *child, *p;
int err;
- if (IS_MNT_SHARED(dest_mnt)) {
+ if (IS_MNT_SHARED(&dest_mnt->mnt)) {
err = invent_group_ids(source_mnt, true);
if (err)
goto out;
}
- err = propagate_mnt(dest_mnt, dest_dentry, &source_mnt->mnt, &tree_list);
+ err = propagate_mnt(dest_mnt, dest_dentry, source_mnt, &tree_list);
if (err)
goto out_cleanup_ids;
br_write_lock(vfsmount_lock);
- if (IS_MNT_SHARED(dest_mnt)) {
+ if (IS_MNT_SHARED(&dest_mnt->mnt)) {
for (p = source_mnt; p; p = next_mnt(p, &source_mnt->mnt))
set_mnt_shared(p);
}
return 0;
out_cleanup_ids:
- if (IS_MNT_SHARED(dest_mnt))
+ if (IS_MNT_SHARED(&dest_mnt->mnt))
cleanup_group_ids(source_mnt, NULL);
out:
return err;
mutex_unlock(&path->dentry->d_inode->i_mutex);
}
-static int graft_tree(struct vfsmount *mnt, struct path *path)
+static int graft_tree(struct mount *mnt, struct path *path)
{
- if (mnt->mnt_sb->s_flags & MS_NOUSER)
+ if (mnt->mnt.mnt_sb->s_flags & MS_NOUSER)
return -EINVAL;
if (S_ISDIR(path->dentry->d_inode->i_mode) !=
- S_ISDIR(mnt->mnt_root->d_inode->i_mode))
+ S_ISDIR(mnt->mnt.mnt_root->d_inode->i_mode))
return -ENOTDIR;
if (d_unlinked(path->dentry))
return -ENOENT;
- return attach_recursive_mnt(real_mount(mnt), path, NULL);
+ return attach_recursive_mnt(mnt, path, NULL);
}
/*
if (!mnt)
goto out2;
- err = graft_tree(&mnt->mnt, path);
+ err = graft_tree(mnt, path);
if (err) {
br_write_lock(vfsmount_lock);
umount_tree(mnt, 0, &umount_list);
/* if the mount is moved, it should no longer be expire
* automatically */
- list_del_init(&old_path.mnt->mnt_expire);
+ list_del_init(&old->mnt_expire);
out1:
unlock_mount(path);
out:
/*
* add a mount into a namespace's mount tree
*/
-static int do_add_mount(struct vfsmount *newmnt, struct path *path, int mnt_flags)
+static int do_add_mount(struct mount *newmnt, struct path *path, int mnt_flags)
{
int err;
/* Refuse the same filesystem on the same mount point */
err = -EBUSY;
- if (path->mnt->mnt_sb == newmnt->mnt_sb &&
+ if (path->mnt->mnt_sb == newmnt->mnt.mnt_sb &&
path->mnt->mnt_root == path->dentry)
goto unlock;
err = -EINVAL;
- if (S_ISLNK(newmnt->mnt_root->d_inode->i_mode))
+ if (S_ISLNK(newmnt->mnt.mnt_root->d_inode->i_mode))
goto unlock;
- newmnt->mnt_flags = mnt_flags;
+ newmnt->mnt.mnt_flags = mnt_flags;
err = graft_tree(newmnt, path);
unlock:
if (IS_ERR(mnt))
return PTR_ERR(mnt);
- err = do_add_mount(mnt, path, mnt_flags);
+ err = do_add_mount(real_mount(mnt), path, mnt_flags);
if (err)
mntput(mnt);
return err;
int finish_automount(struct vfsmount *m, struct path *path)
{
+ struct mount *mnt = real_mount(m);
int err;
/* The new mount record should have at least 2 refs to prevent it being
* expired before we get a chance to add it
*/
- BUG_ON(mnt_get_count(real_mount(m)) < 2);
+ BUG_ON(mnt_get_count(mnt) < 2);
if (m->mnt_sb == path->mnt->mnt_sb &&
m->mnt_root == path->dentry) {
goto fail;
}
- err = do_add_mount(m, path, path->mnt->mnt_flags | MNT_SHRINKABLE);
+ err = do_add_mount(mnt, path, path->mnt->mnt_flags | MNT_SHRINKABLE);
if (!err)
return 0;
fail:
/* remove m from any expiration list it may be on */
- if (!list_empty(&m->mnt_expire)) {
+ if (!list_empty(&mnt->mnt_expire)) {
down_write(&namespace_sem);
br_write_lock(vfsmount_lock);
- list_del_init(&m->mnt_expire);
+ list_del_init(&mnt->mnt_expire);
br_write_unlock(vfsmount_lock);
up_write(&namespace_sem);
}
down_write(&namespace_sem);
br_write_lock(vfsmount_lock);
- list_add_tail(&mnt->mnt_expire, expiry_list);
+ list_add_tail(&real_mount(mnt)->mnt_expire, expiry_list);
br_write_unlock(vfsmount_lock);
up_write(&namespace_sem);
* - still marked for expiry (marked on the last call here; marks are
* cleared by mntput())
*/
- list_for_each_entry_safe(mnt, next, mounts, mnt.mnt_expire) {
+ list_for_each_entry_safe(mnt, next, mounts, mnt_expire) {
if (!xchg(&mnt->mnt.mnt_expiry_mark, 1) ||
propagate_mount_busy(mnt, 1))
continue;
- list_move(&mnt->mnt.mnt_expire, &graveyard);
+ list_move(&mnt->mnt_expire, &graveyard);
}
while (!list_empty(&graveyard)) {
- mnt = list_first_entry(&graveyard, struct mount, mnt.mnt_expire);
+ mnt = list_first_entry(&graveyard, struct mount, mnt_expire);
touch_mnt_namespace(mnt->mnt.mnt_ns);
umount_tree(mnt, 1, &umounts);
}
int found = 0;
repeat:
- next = this_parent->mnt.mnt_mounts.next;
+ next = this_parent->mnt_mounts.next;
resume:
- while (next != &this_parent->mnt.mnt_mounts) {
+ while (next != &this_parent->mnt_mounts) {
struct list_head *tmp = next;
- struct mount *mnt = list_entry(tmp, struct mount, mnt.mnt_child);
+ struct mount *mnt = list_entry(tmp, struct mount, mnt_child);
next = tmp->next;
if (!(mnt->mnt.mnt_flags & MNT_SHRINKABLE))
/*
* Descend a level if the d_mounts list is non-empty.
*/
- if (!list_empty(&mnt->mnt.mnt_mounts)) {
+ if (!list_empty(&mnt->mnt_mounts)) {
this_parent = mnt;
goto repeat;
}
if (!propagate_mount_busy(mnt, 1)) {
- list_move_tail(&mnt->mnt.mnt_expire, graveyard);
+ list_move_tail(&mnt->mnt_expire, graveyard);
found++;
}
}
* All done at this level ... ascend and resume the search
*/
if (this_parent != parent) {
- next = this_parent->mnt.mnt_child.next;
+ next = this_parent->mnt_child.next;
this_parent = this_parent->mnt_parent;
goto resume;
}
while (select_submounts(mnt, &graveyard)) {
while (!list_empty(&graveyard)) {
m = list_first_entry(&graveyard, struct mount,
- mnt.mnt_expire);
+ mnt_expire);
touch_mnt_namespace(m->mnt.mnt_ns);
umount_tree(m, 1, umounts);
}