/*
* vfsmount lock must be held for read
*/
-static inline void mnt_add_count(struct vfsmount *mnt, int n)
+static inline void mnt_add_count(struct mount *mnt, int n)
{
#ifdef CONFIG_SMP
this_cpu_add(mnt->mnt_pcp->mnt_count, n);
/*
* vfsmount lock must be held for write
*/
-unsigned int mnt_get_count(struct vfsmount *mnt)
+unsigned int mnt_get_count(struct mount *mnt)
{
#ifdef CONFIG_SMP
unsigned int count = 0;
}
#ifdef CONFIG_SMP
- mnt->mnt_pcp = alloc_percpu(struct mnt_pcp);
- if (!mnt->mnt_pcp)
+ p->mnt_pcp = alloc_percpu(struct mnt_pcp);
+ if (!p->mnt_pcp)
goto out_free_devname;
- this_cpu_add(mnt->mnt_pcp->mnt_count, 1);
+ this_cpu_add(p->mnt_pcp->mnt_count, 1);
#else
- mnt->mnt_count = 1;
- mnt->mnt_writers = 0;
+ p->mnt_count = 1;
+ p->mnt_writers = 0;
#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);
}
EXPORT_SYMBOL_GPL(__mnt_is_readonly);
-static inline void mnt_inc_writers(struct vfsmount *mnt)
+static inline void mnt_inc_writers(struct mount *mnt)
{
#ifdef CONFIG_SMP
this_cpu_inc(mnt->mnt_pcp->mnt_writers);
#endif
}
-static inline void mnt_dec_writers(struct vfsmount *mnt)
+static inline void mnt_dec_writers(struct mount *mnt)
{
#ifdef CONFIG_SMP
this_cpu_dec(mnt->mnt_pcp->mnt_writers);
#endif
}
-static unsigned int mnt_get_writers(struct vfsmount *mnt)
+static unsigned int mnt_get_writers(struct mount *mnt)
{
#ifdef CONFIG_SMP
unsigned int count = 0;
*/
/**
* mnt_want_write - get write access to a mount
- * @mnt: the mount on which to take a write
+ * @m: the mount on which to take a write
*
* This tells the low-level filesystem that a write is
* about to be performed to it, and makes sure that
* the write operation is finished, mnt_drop_write()
* must be called. This is effectively a refcount.
*/
-int mnt_want_write(struct vfsmount *mnt)
+int mnt_want_write(struct vfsmount *m)
{
+ struct mount *mnt = real_mount(m);
int ret = 0;
preempt_disable();
* incremented count after it has set MNT_WRITE_HOLD.
*/
smp_mb();
- while (mnt->mnt_flags & MNT_WRITE_HOLD)
+ while (mnt->mnt.mnt_flags & MNT_WRITE_HOLD)
cpu_relax();
/*
* After the slowpath clears MNT_WRITE_HOLD, mnt_is_readonly will
* MNT_WRITE_HOLD is cleared.
*/
smp_rmb();
- if (__mnt_is_readonly(mnt)) {
+ if (__mnt_is_readonly(m)) {
mnt_dec_writers(mnt);
ret = -EROFS;
goto out;
if (__mnt_is_readonly(mnt))
return -EROFS;
preempt_disable();
- mnt_inc_writers(mnt);
+ mnt_inc_writers(real_mount(mnt));
preempt_enable();
return 0;
}
void mnt_drop_write(struct vfsmount *mnt)
{
preempt_disable();
- mnt_dec_writers(mnt);
+ mnt_dec_writers(real_mount(mnt));
preempt_enable();
}
EXPORT_SYMBOL_GPL(mnt_drop_write);
}
EXPORT_SYMBOL(mnt_drop_write_file);
-static int mnt_make_readonly(struct vfsmount *mnt)
+static int mnt_make_readonly(struct mount *mnt)
{
int ret = 0;
br_write_lock(vfsmount_lock);
- mnt->mnt_flags |= MNT_WRITE_HOLD;
+ mnt->mnt.mnt_flags |= MNT_WRITE_HOLD;
/*
* After storing MNT_WRITE_HOLD, we'll read the counters. This store
* should be visible before we do.
if (mnt_get_writers(mnt) > 0)
ret = -EBUSY;
else
- mnt->mnt_flags |= MNT_READONLY;
+ mnt->mnt.mnt_flags |= MNT_READONLY;
/*
* MNT_READONLY must become visible before ~MNT_WRITE_HOLD, so writers
* that become unheld will see MNT_READONLY.
*/
smp_wmb();
- mnt->mnt_flags &= ~MNT_WRITE_HOLD;
+ mnt->mnt.mnt_flags &= ~MNT_WRITE_HOLD;
br_write_unlock(vfsmount_lock);
return ret;
}
-static void __mnt_unmake_readonly(struct vfsmount *mnt)
+static void __mnt_unmake_readonly(struct mount *mnt)
{
br_write_lock(vfsmount_lock);
- mnt->mnt_flags &= ~MNT_READONLY;
+ mnt->mnt.mnt_flags &= ~MNT_READONLY;
br_write_unlock(vfsmount_lock);
}
kfree(mnt->mnt.mnt_devname);
mnt_free_id(mnt);
#ifdef CONFIG_SMP
- free_percpu(mnt->mnt.mnt_pcp);
+ free_percpu(mnt->mnt_pcp);
#endif
kmem_cache_free(mnt_cache, mnt);
}
if (tmp == head)
break;
p = list_entry(tmp, struct mount, mnt_hash);
- if (p->mnt.mnt_parent == mnt && p->mnt.mnt_mountpoint == dentry) {
+ if (&p->mnt_parent->mnt == mnt && p->mnt_mountpoint == dentry) {
found = p;
break;
}
struct mount *p;
list_for_each_entry(p, &mount_hashtable[u], mnt_hash) {
- if (p->mnt.mnt_mountpoint == dentry)
+ if (p->mnt_mountpoint == dentry)
return;
}
}
*/
static void detach_mnt(struct mount *mnt, struct path *old_path)
{
- old_path->dentry = mnt->mnt.mnt_mountpoint;
- old_path->mnt = mnt->mnt.mnt_parent;
- mnt->mnt.mnt_parent = &mnt->mnt;
- mnt->mnt.mnt_mountpoint = mnt->mnt.mnt_root;
- list_del_init(&mnt->mnt.mnt_child);
+ old_path->dentry = mnt->mnt_mountpoint;
+ old_path->mnt = &mnt->mnt_parent->mnt;
+ mnt->mnt_parent = mnt;
+ mnt->mnt_mountpoint = mnt->mnt.mnt_root;
+ list_del_init(&mnt->mnt_child);
list_del_init(&mnt->mnt_hash);
dentry_reset_mounted(old_path->dentry);
}
void mnt_set_mountpoint(struct vfsmount *mnt, struct dentry *dentry,
struct mount *child_mnt)
{
- child_mnt->mnt.mnt_parent = mntget(mnt);
- child_mnt->mnt.mnt_mountpoint = dget(dentry);
+ child_mnt->mnt_parent = real_mount(mntget(mnt));
+ child_mnt->mnt_mountpoint = dget(dentry);
spin_lock(&dentry->d_lock);
dentry->d_flags |= DCACHE_MOUNTED;
spin_unlock(&dentry->d_lock);
mnt_set_mountpoint(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 vfsmount *mnt)
+static inline void __mnt_make_longterm(struct mount *mnt)
{
#ifdef CONFIG_SMP
atomic_inc(&mnt->mnt_longterm);
}
/* needs vfsmount lock for write */
-static inline void __mnt_make_shortterm(struct vfsmount *mnt)
+static inline void __mnt_make_shortterm(struct mount *mnt)
{
#ifdef CONFIG_SMP
atomic_dec(&mnt->mnt_longterm);
*/
static void commit_tree(struct mount *mnt)
{
- struct vfsmount *parent = mnt->mnt.mnt_parent;
- struct vfsmount *m;
+ struct mount *parent = mnt->mnt_parent;
+ struct mount *m;
LIST_HEAD(head);
- struct mnt_namespace *n = parent->mnt_ns;
+ struct mnt_namespace *n = parent->mnt.mnt_ns;
- BUG_ON(parent == &mnt->mnt);
+ BUG_ON(parent == mnt);
list_add_tail(&head, &mnt->mnt.mnt_list);
- list_for_each_entry(m, &head, mnt_list) {
- m->mnt_ns = n;
+ list_for_each_entry(m, &head, mnt.mnt_list) {
+ m->mnt.mnt_ns = n;
__mnt_make_longterm(m);
}
list_splice(&head, n->list.prev);
list_add_tail(&mnt->mnt_hash, mount_hashtable +
- hash(parent, mnt->mnt.mnt_mountpoint));
- list_add_tail(&mnt->mnt.mnt_child, &parent->mnt_mounts);
+ hash(&parent->mnt, mnt->mnt_mountpoint));
+ 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.mnt_parent->mnt_mounts)
+ next = p->mnt_child.next;
+ if (next != &p->mnt_parent->mnt_mounts)
break;
- p = real_mount(p->mnt.mnt_parent);
+ 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.mnt_root = root;
mnt->mnt.mnt_sb = root->d_sb;
- mnt->mnt.mnt_mountpoint = mnt->mnt.mnt_root;
- mnt->mnt.mnt_parent = &mnt->mnt;
+ mnt->mnt_mountpoint = mnt->mnt.mnt_root;
+ mnt->mnt_parent = mnt;
return &mnt->mnt;
}
EXPORT_SYMBOL_GPL(vfs_kern_mount);
atomic_inc(&sb->s_active);
mnt->mnt.mnt_sb = sb;
mnt->mnt.mnt_root = dget(root);
- mnt->mnt.mnt_mountpoint = mnt->mnt.mnt_root;
- mnt->mnt.mnt_parent = &mnt->mnt;
+ mnt->mnt_mountpoint = mnt->mnt.mnt_root;
+ mnt->mnt_parent = mnt;
if (flag & CL_SLAVE) {
list_add(&mnt->mnt.mnt_slave, &old->mnt.mnt_slave_list);
return NULL;
}
-static inline void mntfree(struct vfsmount *mnt)
+static inline void mntfree(struct mount *mnt)
{
- struct super_block *sb = mnt->mnt_sb;
+ struct vfsmount *m = &mnt->mnt;
+ struct super_block *sb = m->mnt_sb;
/*
* This probably indicates that somebody messed
* so mnt_get_writers() below is safe.
*/
WARN_ON(mnt_get_writers(mnt));
- fsnotify_vfsmount_delete(mnt);
- dput(mnt->mnt_root);
- free_vfsmnt(real_mount(mnt));
+ fsnotify_vfsmount_delete(m);
+ dput(m->mnt_root);
+ free_vfsmnt(mnt);
deactivate_super(sb);
}
-static void mntput_no_expire(struct vfsmount *mnt)
+static void mntput_no_expire(struct vfsmount *m)
{
+ struct mount *mnt = real_mount(m);
put_again:
#ifdef CONFIG_SMP
br_read_lock(vfsmount_lock);
return;
br_write_lock(vfsmount_lock);
#endif
- if (unlikely(mnt->mnt_pinned)) {
- mnt_add_count(mnt, mnt->mnt_pinned + 1);
- mnt->mnt_pinned = 0;
+ if (unlikely(mnt->mnt.mnt_pinned)) {
+ mnt_add_count(mnt, mnt->mnt.mnt_pinned + 1);
+ mnt->mnt.mnt_pinned = 0;
br_write_unlock(vfsmount_lock);
- acct_auto_close_mnt(mnt);
+ acct_auto_close_mnt(m);
goto put_again;
}
br_write_unlock(vfsmount_lock);
struct vfsmount *mntget(struct vfsmount *mnt)
{
if (mnt)
- mnt_add_count(mnt, 1);
+ mnt_add_count(real_mount(mnt), 1);
return mnt;
}
EXPORT_SYMBOL(mntget);
{
br_write_lock(vfsmount_lock);
if (mnt->mnt_pinned) {
- mnt_add_count(mnt, 1);
+ mnt_add_count(real_mount(mnt), 1);
mnt->mnt_pinned--;
}
br_write_unlock(vfsmount_lock);
{
struct proc_mounts *p = m->private;
struct vfsmount *mnt = list_entry(v, struct vfsmount, mnt_list);
+ struct mount *r = real_mount(mnt);
struct super_block *sb = mnt->mnt_sb;
struct path mnt_path = { .dentry = mnt->mnt_root, .mnt = mnt };
struct path root = p->root;
int err = 0;
- seq_printf(m, "%i %i %u:%u ", mnt->mnt_id, mnt->mnt_parent->mnt_id,
+ seq_printf(m, "%i %i %u:%u ", mnt->mnt_id, r->mnt_parent->mnt.mnt_id,
MAJOR(sb->s_dev), MINOR(sb->s_dev));
if (sb->s_op->show_path)
err = sb->s_op->show_path(m, 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);
+ 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);
/* write lock needed for mnt_get_count */
br_write_lock(vfsmount_lock);
for (p = real_mount(mnt); p; p = next_mnt(p, mnt)) {
- actual_refs += mnt_get_count(&p->mnt);
+ actual_refs += mnt_get_count(p);
minimum_refs += 2;
}
br_write_unlock(vfsmount_lock);
while (!list_empty(head)) {
mnt = list_first_entry(head, struct mount, mnt_hash);
list_del_init(&mnt->mnt_hash);
- if (mnt_has_parent(&mnt->mnt)) {
+ if (mnt_has_parent(mnt)) {
struct dentry *dentry;
struct vfsmount *m;
br_write_lock(vfsmount_lock);
- dentry = mnt->mnt.mnt_mountpoint;
- m = mnt->mnt.mnt_parent;
- mnt->mnt.mnt_mountpoint = mnt->mnt.mnt_root;
- mnt->mnt.mnt_parent = &mnt->mnt;
+ dentry = mnt->mnt_mountpoint;
+ m = &mnt->mnt_parent->mnt;
+ mnt->mnt_mountpoint = mnt->mnt.mnt_root;
+ mnt->mnt_parent = mnt;
m->mnt_ghosts--;
br_write_unlock(vfsmount_lock);
dput(dentry);
list_del_init(&p->mnt.mnt_list);
__touch_mnt_namespace(p->mnt.mnt_ns);
p->mnt.mnt_ns = NULL;
- __mnt_make_shortterm(&p->mnt);
- list_del_init(&p->mnt.mnt_child);
- if (mnt_has_parent(&p->mnt)) {
- p->mnt.mnt_parent->mnt_ghosts++;
- dentry_reset_mounted(p->mnt.mnt_mountpoint);
+ __mnt_make_shortterm(p);
+ list_del_init(&p->mnt_child);
+ if (mnt_has_parent(p)) {
+ p->mnt_parent->mnt.mnt_ghosts++;
+ dentry_reset_mounted(p->mnt_mountpoint);
}
change_mnt_propagation(p, MS_PRIVATE);
}
* all race cases, but it's a slowpath.
*/
br_write_lock(vfsmount_lock);
- if (mnt_get_count(&mnt->mnt) != 2) {
+ if (mnt_get_count(mnt) != 2) {
br_write_unlock(vfsmount_lock);
return -EBUSY;
}
struct mount *copy_tree(struct mount *mnt, struct dentry *dentry,
int flag)
{
- struct mount *res, *p, *q;
- struct vfsmount *r;
+ struct mount *res, *p, *q, *r;
struct path path;
if (!(flag & CL_COPY_ALL) && IS_MNT_UNBINDABLE(&mnt->mnt))
res = q = clone_mnt(mnt, dentry, flag);
if (!q)
goto Enomem;
- q->mnt.mnt_mountpoint = mnt->mnt.mnt_mountpoint;
+ q->mnt_mountpoint = mnt->mnt_mountpoint;
p = mnt;
- list_for_each_entry(r, &mnt->mnt.mnt_mounts, mnt_child) {
+ list_for_each_entry(r, &mnt->mnt_mounts, mnt_child) {
struct mount *s;
if (!is_subdir(r->mnt_mountpoint, dentry))
continue;
- for (s = real_mount(r); s; s = next_mnt(s, r)) {
+ for (s = r; s; s = next_mnt(s, &r->mnt)) {
if (!(flag & CL_COPY_ALL) && IS_MNT_UNBINDABLE(&s->mnt)) {
s = skip_mnt_tree(s);
continue;
}
- while (p != real_mount(s->mnt.mnt_parent)) {
- p = real_mount(p->mnt.mnt_parent);
- q = real_mount(q->mnt.mnt_parent);
+ while (p != s->mnt_parent) {
+ p = p->mnt_parent;
+ q = q->mnt_parent;
}
p = s;
path.mnt = &q->mnt;
- path.dentry = p->mnt.mnt_mountpoint;
+ path.dentry = p->mnt_mountpoint;
q = clone_mnt(p, p->mnt.mnt_root, flag);
if (!q)
goto Enomem;
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);
}
attach_mnt(source_mnt, path);
touch_mnt_namespace(parent_path->mnt->mnt_ns);
} else {
- mnt_set_mountpoint(dest_mnt, dest_dentry, source_mnt);
+ mnt_set_mountpoint(&dest_mnt->mnt, dest_dentry, source_mnt);
commit_tree(source_mnt);
}
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;
return 0;
if (readonly_request)
- error = mnt_make_readonly(mnt);
+ error = mnt_make_readonly(real_mount(mnt));
else
- __mnt_unmake_readonly(mnt);
+ __mnt_unmake_readonly(real_mount(mnt));
return error;
}
static int do_move_mount(struct path *path, char *old_name)
{
struct path old_path, parent_path;
- struct vfsmount *p;
+ struct mount *p;
struct mount *old;
int err = 0;
if (!capable(CAP_SYS_ADMIN))
old = real_mount(old_path.mnt);
- if (!mnt_has_parent(old_path.mnt))
+ if (!mnt_has_parent(old))
goto out1;
if (S_ISDIR(path->dentry->d_inode->i_mode) !=
/*
* Don't move a mount residing in a shared parent.
*/
- if (IS_MNT_SHARED(old_path.mnt->mnt_parent))
+ if (IS_MNT_SHARED(&old->mnt_parent->mnt))
goto out1;
/*
* Don't move a mount tree containing unbindable mounts to a destination
tree_contains_unbindable(old))
goto out1;
err = -ELOOP;
- for (p = path->mnt; mnt_has_parent(p); p = p->mnt_parent)
- if (p == old_path.mnt)
+ for (p = real_mount(path->mnt); mnt_has_parent(p); p = p->mnt_parent)
+ if (p == old)
goto out1;
err = attach_recursive_mnt(old, path, &parent_path);
/* 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(m) < 2);
+ BUG_ON(mnt_get_count(real_mount(m)) < 2);
if (m->mnt_sb == path->mnt->mnt_sb &&
m->mnt_root == path->dentry) {
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;
}
* All done at this level ... ascend and resume the search
*/
if (this_parent != parent) {
- next = this_parent->mnt.mnt_child.next;
- this_parent = real_mount(this_parent->mnt.mnt_parent);
+ next = this_parent->mnt_child.next;
+ this_parent = this_parent->mnt_parent;
goto resume;
}
return found;
void mnt_make_longterm(struct vfsmount *mnt)
{
- __mnt_make_longterm(mnt);
+ __mnt_make_longterm(real_mount(mnt));
}
-void mnt_make_shortterm(struct vfsmount *mnt)
+void mnt_make_shortterm(struct vfsmount *m)
{
#ifdef CONFIG_SMP
+ struct mount *mnt = real_mount(m);
if (atomic_add_unless(&mnt->mnt_longterm, -1, 1))
return;
br_write_lock(vfsmount_lock);
q = new;
while (p) {
q->mnt.mnt_ns = new_ns;
- __mnt_make_longterm(&q->mnt);
+ __mnt_make_longterm(q);
if (fs) {
if (&p->mnt == fs->root.mnt) {
fs->root.mnt = mntget(&q->mnt);
- __mnt_make_longterm(&q->mnt);
+ __mnt_make_longterm(q);
mnt_make_shortterm(&p->mnt);
rootmnt = &p->mnt;
}
if (&p->mnt == fs->pwd.mnt) {
fs->pwd.mnt = mntget(&q->mnt);
- __mnt_make_longterm(&q->mnt);
+ __mnt_make_longterm(q);
mnt_make_shortterm(&p->mnt);
pwdmnt = &p->mnt;
}
new_ns = alloc_mnt_ns();
if (!IS_ERR(new_ns)) {
mnt->mnt_ns = new_ns;
- __mnt_make_longterm(mnt);
+ __mnt_make_longterm(real_mount(mnt));
new_ns->root = mnt;
list_add(&new_ns->list, &new_ns->root->mnt_list);
} else {
*
* namespace_sem or vfsmount_lock is held
*/
-bool is_path_reachable(struct vfsmount *mnt, struct dentry *dentry,
+bool is_path_reachable(struct mount *mnt, struct dentry *dentry,
const struct path *root)
{
- while (mnt != root->mnt && mnt_has_parent(mnt)) {
+ while (&mnt->mnt != root->mnt && mnt_has_parent(mnt)) {
dentry = mnt->mnt_mountpoint;
mnt = mnt->mnt_parent;
}
- return mnt == root->mnt && is_subdir(dentry, root->dentry);
+ return &mnt->mnt == root->mnt && is_subdir(dentry, root->dentry);
}
int path_is_under(struct path *path1, struct path *path2)
{
int res;
br_read_lock(vfsmount_lock);
- res = is_path_reachable(path1->mnt, path1->dentry, path2);
+ res = is_path_reachable(real_mount(path1->mnt), path1->dentry, path2);
br_read_unlock(vfsmount_lock);
return res;
}
new_mnt = real_mount(new.mnt);
root_mnt = real_mount(root.mnt);
if (IS_MNT_SHARED(old.mnt) ||
- IS_MNT_SHARED(new.mnt->mnt_parent) ||
- IS_MNT_SHARED(root.mnt->mnt_parent))
+ IS_MNT_SHARED(&new_mnt->mnt_parent->mnt) ||
+ IS_MNT_SHARED(&root_mnt->mnt_parent->mnt))
goto out4;
if (!check_mnt(root.mnt) || !check_mnt(new.mnt))
goto out4;
error = -EINVAL;
if (root.mnt->mnt_root != root.dentry)
goto out4; /* not a mountpoint */
- if (!mnt_has_parent(root.mnt))
+ if (!mnt_has_parent(root_mnt))
goto out4; /* not attached */
if (new.mnt->mnt_root != new.dentry)
goto out4; /* not a mountpoint */
- if (!mnt_has_parent(new.mnt))
+ if (!mnt_has_parent(new_mnt))
goto out4; /* not attached */
/* make sure we can reach put_old from new_root */
- if (!is_path_reachable(old.mnt, old.dentry, &new))
+ if (!is_path_reachable(real_mount(old.mnt), old.dentry, &new))
goto out4;
br_write_lock(vfsmount_lock);
detach_mnt(new_mnt, &parent_path);
projects / linux-block.git / blobdiff