* allocation is serialized by namespace_sem, but we need the spinlock to
* serialize with freeing.
*/
-static int mnt_alloc_id(struct vfsmount *mnt)
+static int mnt_alloc_id(struct mount *mnt)
{
int res;
retry:
ida_pre_get(&mnt_id_ida, GFP_KERNEL);
spin_lock(&mnt_id_lock);
- res = ida_get_new_above(&mnt_id_ida, mnt_id_start, &mnt->mnt_id);
+ res = ida_get_new_above(&mnt_id_ida, mnt_id_start, &mnt->mnt.mnt_id);
if (!res)
- mnt_id_start = mnt->mnt_id + 1;
+ mnt_id_start = mnt->mnt.mnt_id + 1;
spin_unlock(&mnt_id_lock);
if (res == -EAGAIN)
goto retry;
return res;
}
-static void mnt_free_id(struct vfsmount *mnt)
+static void mnt_free_id(struct mount *mnt)
{
- int id = mnt->mnt_id;
+ int id = mnt->mnt.mnt_id;
spin_lock(&mnt_id_lock);
ida_remove(&mnt_id_ida, id);
if (mnt_id_start > id)
*
* mnt_group_ida is protected by namespace_sem
*/
-static int mnt_alloc_group_id(struct vfsmount *mnt)
+static int mnt_alloc_group_id(struct mount *mnt)
{
int res;
res = ida_get_new_above(&mnt_group_ida,
mnt_group_start,
- &mnt->mnt_group_id);
+ &mnt->mnt.mnt_group_id);
if (!res)
- mnt_group_start = mnt->mnt_group_id + 1;
+ mnt_group_start = mnt->mnt.mnt_group_id + 1;
return res;
}
/*
* Release a peer group ID
*/
-void mnt_release_group_id(struct vfsmount *mnt)
+void mnt_release_group_id(struct mount *mnt)
{
- int id = mnt->mnt_group_id;
+ int id = mnt->mnt.mnt_group_id;
ida_remove(&mnt_group_ida, id);
if (mnt_group_start > id)
mnt_group_start = id;
- mnt->mnt_group_id = 0;
+ mnt->mnt.mnt_group_id = 0;
}
/*
* 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;
#endif
}
-static struct vfsmount *alloc_vfsmnt(const char *name)
+static struct mount *alloc_vfsmnt(const char *name)
{
struct mount *p = kmem_cache_zalloc(mnt_cache, GFP_KERNEL);
if (p) {
struct vfsmount *mnt = &p->mnt;
int err;
- err = mnt_alloc_id(mnt);
+ err = mnt_alloc_id(p);
if (err)
goto out_free_cache;
}
#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(&mnt->mnt_hash);
- INIT_LIST_HEAD(&mnt->mnt_child);
- INIT_LIST_HEAD(&mnt->mnt_mounts);
+ INIT_LIST_HEAD(&p->mnt_hash);
+ 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_HLIST_HEAD(&mnt->mnt_fsnotify_marks);
#endif
}
- return &p->mnt;
+ return p;
#ifdef CONFIG_SMP
out_free_devname:
kfree(p->mnt.mnt_devname);
#endif
out_free_id:
- mnt_free_id(&p->mnt);
+ mnt_free_id(p);
out_free_cache:
kmem_cache_free(mnt_cache, p);
return NULL;
}
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);
}
-static void free_vfsmnt(struct vfsmount *mnt)
+static void free_vfsmnt(struct mount *mnt)
{
- struct mount *p = real_mount(mnt);
- kfree(mnt->mnt_devname);
+ kfree(mnt->mnt.mnt_devname);
mnt_free_id(mnt);
#ifdef CONFIG_SMP
free_percpu(mnt->mnt_pcp);
#endif
- kmem_cache_free(mnt_cache, p);
+ kmem_cache_free(mnt_cache, mnt);
}
/*
p = NULL;
if (tmp == head)
break;
- p = list_entry(tmp, struct mount, mnt.mnt_hash);
- if (p->mnt.mnt_parent == mnt && p->mnt.mnt_mountpoint == dentry) {
+ p = list_entry(tmp, struct mount, mnt_hash);
+ if (&p->mnt_parent->mnt == mnt && p->mnt_mountpoint == dentry) {
found = p;
break;
}
unsigned u;
for (u = 0; u < HASH_SIZE; u++) {
- struct vfsmount *p;
+ struct mount *p;
list_for_each_entry(p, &mount_hashtable[u], mnt_hash) {
if (p->mnt_mountpoint == dentry)
*/
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);
- list_del_init(&mnt->mnt.mnt_hash);
+ 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);
}
* vfsmount lock must be held for write
*/
void mnt_set_mountpoint(struct vfsmount *mnt, struct dentry *dentry,
- struct vfsmount *child_mnt)
+ struct mount *child_mnt)
{
- child_mnt->mnt_parent = mntget(mnt);
+ child_mnt->mnt_parent = real_mount(mntget(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);
- list_add_tail(&mnt->mnt.mnt_hash, mount_hashtable +
+ 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.mnt_hash, mount_hashtable +
- hash(parent, mnt->mnt.mnt_mountpoint));
- list_add_tail(&mnt->mnt.mnt_child, &parent->mnt_mounts);
+ list_add_tail(&mnt->mnt_hash, mount_hashtable +
+ 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;
}
struct vfsmount *
vfs_kern_mount(struct file_system_type *type, int flags, const char *name, void *data)
{
- struct vfsmount *mnt;
+ struct mount *mnt;
struct dentry *root;
if (!type)
return ERR_PTR(-ENOMEM);
if (flags & MS_KERNMOUNT)
- mnt->mnt_flags = MNT_INTERNAL;
+ mnt->mnt.mnt_flags = MNT_INTERNAL;
root = mount_fs(type, flags, name, data);
if (IS_ERR(root)) {
return ERR_CAST(root);
}
- mnt->mnt_root = root;
- mnt->mnt_sb = root->d_sb;
- mnt->mnt_mountpoint = mnt->mnt_root;
+ mnt->mnt.mnt_root = root;
+ mnt->mnt.mnt_sb = root->d_sb;
+ mnt->mnt_mountpoint = mnt->mnt.mnt_root;
mnt->mnt_parent = mnt;
- return mnt;
+ return &mnt->mnt;
}
EXPORT_SYMBOL_GPL(vfs_kern_mount);
-static struct vfsmount *clone_mnt(struct vfsmount *old, struct dentry *root,
+static struct mount *clone_mnt(struct mount *old, struct dentry *root,
int flag)
{
- struct super_block *sb = old->mnt_sb;
- struct vfsmount *mnt = alloc_vfsmnt(old->mnt_devname);
+ struct super_block *sb = old->mnt.mnt_sb;
+ struct mount *mnt = alloc_vfsmnt(old->mnt.mnt_devname);
if (mnt) {
if (flag & (CL_SLAVE | CL_PRIVATE))
- mnt->mnt_group_id = 0; /* not a peer of original */
+ mnt->mnt.mnt_group_id = 0; /* not a peer of original */
else
- mnt->mnt_group_id = old->mnt_group_id;
+ mnt->mnt.mnt_group_id = old->mnt.mnt_group_id;
- if ((flag & CL_MAKE_SHARED) && !mnt->mnt_group_id) {
+ if ((flag & CL_MAKE_SHARED) && !mnt->mnt.mnt_group_id) {
int err = mnt_alloc_group_id(mnt);
if (err)
goto out_free;
}
- mnt->mnt_flags = old->mnt_flags & ~MNT_WRITE_HOLD;
+ mnt->mnt.mnt_flags = old->mnt.mnt_flags & ~MNT_WRITE_HOLD;
atomic_inc(&sb->s_active);
- mnt->mnt_sb = sb;
- mnt->mnt_root = dget(root);
- mnt->mnt_mountpoint = mnt->mnt_root;
+ mnt->mnt.mnt_sb = sb;
+ mnt->mnt.mnt_root = dget(root);
+ mnt->mnt_mountpoint = mnt->mnt.mnt_root;
mnt->mnt_parent = mnt;
if (flag & CL_SLAVE) {
- list_add(&mnt->mnt_slave, &old->mnt_slave_list);
- mnt->mnt_master = old;
- CLEAR_MNT_SHARED(mnt);
+ list_add(&mnt->mnt.mnt_slave, &old->mnt.mnt_slave_list);
+ mnt->mnt.mnt_master = &old->mnt;
+ CLEAR_MNT_SHARED(&mnt->mnt);
} else if (!(flag & CL_PRIVATE)) {
- if ((flag & CL_MAKE_SHARED) || IS_MNT_SHARED(old))
- 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) || 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;
}
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_expire))
- list_add(&mnt->mnt_expire, &old->mnt_expire);
+ if (!list_empty(&old->mnt.mnt_expire))
+ list_add(&mnt->mnt.mnt_expire, &old->mnt.mnt_expire);
}
}
return mnt;
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);
+ 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);
int ret = 1;
down_read(&namespace_sem);
br_write_lock(vfsmount_lock);
- if (propagate_mount_busy(mnt, 2))
+ if (propagate_mount_busy(real_mount(mnt), 2))
ret = 0;
br_write_unlock(vfsmount_lock);
up_read(&namespace_sem);
void release_mounts(struct list_head *head)
{
- struct vfsmount *mnt;
+ struct mount *mnt;
while (!list_empty(head)) {
- mnt = list_first_entry(head, struct vfsmount, mnt_hash);
+ mnt = list_first_entry(head, struct mount, mnt_hash);
list_del_init(&mnt->mnt_hash);
if (mnt_has_parent(mnt)) {
struct dentry *dentry;
br_write_lock(vfsmount_lock);
dentry = mnt->mnt_mountpoint;
- m = mnt->mnt_parent;
- mnt->mnt_mountpoint = mnt->mnt_root;
+ 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);
mntput(m);
}
- mntput(mnt);
+ mntput(&mnt->mnt);
}
}
* vfsmount lock must be held for write
* namespace_sem must be held for write
*/
-void umount_tree(struct vfsmount *mnt, int propagate, struct list_head *kill)
+void umount_tree(struct mount *mnt, int propagate, struct list_head *kill)
{
LIST_HEAD(tmp_list);
struct mount *p;
- for (p = real_mount(mnt); p; p = next_mnt(p, mnt))
- list_move(&p->mnt.mnt_hash, &tmp_list);
+ for (p = mnt; p; p = next_mnt(p, &mnt->mnt))
+ list_move(&p->mnt_hash, &tmp_list);
if (propagate)
propagate_umount(&tmp_list);
- list_for_each_entry(p, &tmp_list, mnt.mnt_hash) {
+ list_for_each_entry(p, &tmp_list, mnt_hash) {
list_del_init(&p->mnt.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->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->mnt, MS_PRIVATE);
+ change_mnt_propagation(p, MS_PRIVATE);
}
list_splice(&tmp_list, kill);
}
-static void shrink_submounts(struct vfsmount *mnt, struct list_head *umounts);
+static void shrink_submounts(struct mount *mnt, struct list_head *umounts);
-static int do_umount(struct vfsmount *mnt, int flags)
+static int do_umount(struct mount *mnt, int flags)
{
- struct super_block *sb = mnt->mnt_sb;
+ struct super_block *sb = mnt->mnt.mnt_sb;
int retval;
LIST_HEAD(umount_list);
- retval = security_sb_umount(mnt, flags);
+ retval = security_sb_umount(&mnt->mnt, flags);
if (retval)
return retval;
* (2) the usage count == 1 [parent vfsmount] + 1 [sys_umount]
*/
if (flags & MNT_EXPIRE) {
- if (mnt == current->fs->root.mnt ||
+ if (&mnt->mnt == current->fs->root.mnt ||
flags & (MNT_FORCE | MNT_DETACH))
return -EINVAL;
}
br_write_unlock(vfsmount_lock);
- if (!xchg(&mnt->mnt_expiry_mark, 1))
+ if (!xchg(&mnt->mnt.mnt_expiry_mark, 1))
return -EAGAIN;
}
* /reboot - static binary that would close all descriptors and
* call reboot(9). Then init(8) could umount root and exec /reboot.
*/
- if (mnt == current->fs->root.mnt && !(flags & MNT_DETACH)) {
+ if (&mnt->mnt == current->fs->root.mnt && !(flags & MNT_DETACH)) {
/*
* Special case for "unmounting" root ...
* we just try to remount it readonly.
retval = -EBUSY;
if (flags & MNT_DETACH || !propagate_mount_busy(mnt, 2)) {
- if (!list_empty(&mnt->mnt_list))
+ if (!list_empty(&mnt->mnt.mnt_list))
umount_tree(mnt, 1, &umount_list);
retval = 0;
}
if (!capable(CAP_SYS_ADMIN))
goto dput_and_out;
- retval = do_umount(path.mnt, flags);
+ retval = do_umount(real_mount(path.mnt), flags);
dput_and_out:
/* we mustn't call path_put() as that would clear mnt_expiry_mark */
dput(path.dentry);
#endif
}
-struct vfsmount *copy_tree(struct vfsmount *mnt, struct dentry *dentry,
+struct mount *copy_tree(struct mount *mnt, struct dentry *dentry,
int flag)
{
- struct vfsmount *res, *p, *q, *r;
+ struct mount *res, *p, *q, *r;
struct path path;
- if (!(flag & CL_COPY_ALL) && IS_MNT_UNBINDABLE(mnt))
+ if (!(flag & CL_COPY_ALL) && IS_MNT_UNBINDABLE(&mnt->mnt))
return NULL;
res = q = clone_mnt(mnt, dentry, flag);
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 != s->mnt.mnt_parent) {
+ while (p != s->mnt_parent) {
p = p->mnt_parent;
q = q->mnt_parent;
}
- p = &s->mnt;
- path.mnt = q;
+ p = s;
+ path.mnt = &q->mnt;
path.dentry = p->mnt_mountpoint;
- q = clone_mnt(p, p->mnt_root, flag);
+ q = clone_mnt(p, p->mnt.mnt_root, flag);
if (!q)
goto Enomem;
br_write_lock(vfsmount_lock);
- list_add_tail(&q->mnt_list, &res->mnt_list);
- attach_mnt(real_mount(q), &path);
+ list_add_tail(&q->mnt.mnt_list, &res->mnt.mnt_list);
+ attach_mnt(q, &path);
br_write_unlock(vfsmount_lock);
}
}
struct vfsmount *collect_mounts(struct path *path)
{
- struct vfsmount *tree;
+ struct mount *tree;
down_write(&namespace_sem);
- tree = copy_tree(path->mnt, path->dentry, CL_COPY_ALL | CL_PRIVATE);
+ tree = copy_tree(real_mount(path->mnt), path->dentry,
+ CL_COPY_ALL | CL_PRIVATE);
up_write(&namespace_sem);
- return tree;
+ return tree ? &tree->mnt : NULL;
}
void drop_collected_mounts(struct vfsmount *mnt)
LIST_HEAD(umount_list);
down_write(&namespace_sem);
br_write_lock(vfsmount_lock);
- umount_tree(mnt, 0, &umount_list);
+ umount_tree(real_mount(mnt), 0, &umount_list);
br_write_unlock(vfsmount_lock);
up_write(&namespace_sem);
release_mounts(&umount_list);
return 0;
}
-static void cleanup_group_ids(struct vfsmount *mnt, struct vfsmount *end)
+static void cleanup_group_ids(struct mount *mnt, struct mount *end)
{
struct mount *p;
- for (p = real_mount(mnt); &p->mnt != end; p = next_mnt(p, mnt)) {
+ for (p = mnt; p != end; p = next_mnt(p, &mnt->mnt)) {
if (p->mnt.mnt_group_id && !IS_MNT_SHARED(&p->mnt))
- mnt_release_group_id(&p->mnt);
+ mnt_release_group_id(p);
}
}
-static int invent_group_ids(struct vfsmount *mnt, bool recurse)
+static int invent_group_ids(struct mount *mnt, bool recurse)
{
struct mount *p;
- for (p = real_mount(mnt); p; p = recurse ? next_mnt(p, mnt) : NULL) {
+ for (p = mnt; p; p = recurse ? next_mnt(p, &mnt->mnt) : NULL) {
if (!p->mnt.mnt_group_id && !IS_MNT_SHARED(&p->mnt)) {
- int err = mnt_alloc_group_id(&p->mnt);
+ int err = mnt_alloc_group_id(p);
if (err) {
- cleanup_group_ids(mnt, &p->mnt);
+ cleanup_group_ids(mnt, p);
return err;
}
}
* Must be called without spinlocks held, since this function can sleep
* in allocations.
*/
-static int attach_recursive_mnt(struct vfsmount *source_mnt,
+static int attach_recursive_mnt(struct mount *source_mnt,
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;
br_write_lock(vfsmount_lock);
- if (IS_MNT_SHARED(dest_mnt)) {
- for (p = real_mount(source_mnt); p; p = next_mnt(p, source_mnt))
- set_mnt_shared(&p->mnt);
+ if (IS_MNT_SHARED(&dest_mnt->mnt)) {
+ for (p = source_mnt; p; p = next_mnt(p, &source_mnt->mnt))
+ set_mnt_shared(p);
}
if (parent_path) {
- detach_mnt(real_mount(source_mnt), parent_path);
- attach_mnt(real_mount(source_mnt), path);
+ detach_mnt(source_mnt, parent_path);
+ attach_mnt(source_mnt, path);
touch_mnt_namespace(parent_path->mnt->mnt_ns);
} else {
- mnt_set_mountpoint(dest_mnt, dest_dentry, source_mnt);
- commit_tree(real_mount(source_mnt));
+ mnt_set_mountpoint(&dest_mnt->mnt, dest_dentry, source_mnt);
+ commit_tree(source_mnt);
}
- list_for_each_entry_safe(child, p, &tree_list, mnt.mnt_hash) {
- list_del_init(&child->mnt.mnt_hash);
+ list_for_each_entry_safe(child, p, &tree_list, mnt_hash) {
+ list_del_init(&child->mnt_hash);
commit_tree(child);
}
br_write_unlock(vfsmount_lock);
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;
if (d_unlinked(path->dentry))
return -ENOENT;
- return attach_recursive_mnt(mnt, path, NULL);
+ return attach_recursive_mnt(real_mount(mnt), path, NULL);
}
/*
static int do_change_type(struct path *path, int flag)
{
struct mount *m;
- struct vfsmount *mnt = path->mnt;
+ struct mount *mnt = real_mount(path->mnt);
int recurse = flag & MS_REC;
int type;
int err = 0;
}
br_write_lock(vfsmount_lock);
- for (m = real_mount(mnt); m; m = (recurse ? next_mnt(m, mnt) : NULL))
- change_mnt_propagation(&m->mnt, type);
+ for (m = mnt; m; m = (recurse ? next_mnt(m, &mnt->mnt) : NULL))
+ change_mnt_propagation(m, type);
br_write_unlock(vfsmount_lock);
out_unlock:
{
LIST_HEAD(umount_list);
struct path old_path;
- struct vfsmount *mnt = NULL;
+ struct mount *mnt = NULL, *old;
int err = mount_is_safe(path);
if (err)
return err;
if (err)
goto out;
+ old = real_mount(old_path.mnt);
+
err = -EINVAL;
if (IS_MNT_UNBINDABLE(old_path.mnt))
goto out2;
err = -ENOMEM;
if (recurse)
- mnt = copy_tree(old_path.mnt, old_path.dentry, 0);
+ mnt = copy_tree(old, old_path.dentry, 0);
else
- mnt = clone_mnt(old_path.mnt, old_path.dentry, 0);
+ mnt = clone_mnt(old, old_path.dentry, 0);
if (!mnt)
goto out2;
- err = graft_tree(mnt, path);
+ err = graft_tree(&mnt->mnt, path);
if (err) {
br_write_lock(vfsmount_lock);
umount_tree(mnt, 0, &umount_list);
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;
}
return err;
}
-static inline int tree_contains_unbindable(struct vfsmount *mnt)
+static inline int tree_contains_unbindable(struct mount *mnt)
{
struct mount *p;
- for (p = real_mount(mnt); p; p = next_mnt(p, mnt)) {
+ for (p = mnt; p; p = next_mnt(p, &mnt->mnt)) {
if (IS_MNT_UNBINDABLE(&p->mnt))
return 1;
}
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))
return -EPERM;
if (old_path.dentry != old_path.mnt->mnt_root)
goto out1;
- if (!mnt_has_parent(old_path.mnt))
+ old = real_mount(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
* mount which is shared.
*/
if (IS_MNT_SHARED(path->mnt) &&
- tree_contains_unbindable(old_path.mnt))
+ 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.mnt, path, &parent_path);
+ err = attach_recursive_mnt(old, path, &parent_path);
if (err)
goto out1;
/* 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) {
*/
void mark_mounts_for_expiry(struct list_head *mounts)
{
- struct vfsmount *mnt, *next;
+ struct mount *mnt, *next;
LIST_HEAD(graveyard);
LIST_HEAD(umounts);
* - still marked for expiry (marked on the last call here; marks are
* cleared by mntput())
*/
- list_for_each_entry_safe(mnt, next, mounts, mnt_expire) {
- if (!xchg(&mnt->mnt_expiry_mark, 1) ||
+ list_for_each_entry_safe(mnt, next, mounts, mnt.mnt_expire) {
+ if (!xchg(&mnt->mnt.mnt_expiry_mark, 1) ||
propagate_mount_busy(mnt, 1))
continue;
- list_move(&mnt->mnt_expire, &graveyard);
+ list_move(&mnt->mnt.mnt_expire, &graveyard);
}
while (!list_empty(&graveyard)) {
- mnt = list_first_entry(&graveyard, struct vfsmount, mnt_expire);
- touch_mnt_namespace(mnt->mnt_ns);
+ mnt = list_first_entry(&graveyard, struct mount, mnt.mnt_expire);
+ touch_mnt_namespace(mnt->mnt.mnt_ns);
umount_tree(mnt, 1, &umounts);
}
br_write_unlock(vfsmount_lock);
* search the list of submounts for a given mountpoint, and move any
* shrinkable submounts to the 'graveyard' list.
*/
-static int select_submounts(struct vfsmount *parent, struct list_head *graveyard)
+static int select_submounts(struct mount *parent, struct list_head *graveyard)
{
- struct vfsmount *this_parent = parent;
+ struct mount *this_parent = parent;
struct list_head *next;
int found = 0;
resume:
while (next != &this_parent->mnt_mounts) {
struct list_head *tmp = next;
- struct vfsmount *mnt = list_entry(tmp, struct vfsmount, mnt_child);
+ struct mount *mnt = list_entry(tmp, struct mount, mnt_child);
next = tmp->next;
- if (!(mnt->mnt_flags & MNT_SHRINKABLE))
+ if (!(mnt->mnt.mnt_flags & MNT_SHRINKABLE))
continue;
/*
* Descend a level if the d_mounts list is non-empty.
}
if (!propagate_mount_busy(mnt, 1)) {
- list_move_tail(&mnt->mnt_expire, graveyard);
+ list_move_tail(&mnt->mnt.mnt_expire, graveyard);
found++;
}
}
*
* vfsmount_lock must be held for write
*/
-static void shrink_submounts(struct vfsmount *mnt, struct list_head *umounts)
+static void shrink_submounts(struct mount *mnt, struct list_head *umounts)
{
LIST_HEAD(graveyard);
- struct vfsmount *m;
+ struct mount *m;
/* extract submounts of 'mountpoint' from the expiration list */
while (select_submounts(mnt, &graveyard)) {
while (!list_empty(&graveyard)) {
- m = list_first_entry(&graveyard, struct vfsmount,
- mnt_expire);
- touch_mnt_namespace(m->mnt_ns);
+ m = list_first_entry(&graveyard, struct mount,
+ mnt.mnt_expire);
+ touch_mnt_namespace(m->mnt.mnt_ns);
umount_tree(m, 1, umounts);
}
}
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);
struct mnt_namespace *new_ns;
struct vfsmount *rootmnt = NULL, *pwdmnt = NULL;
struct mount *p, *q;
+ struct mount *new;
new_ns = alloc_mnt_ns();
if (IS_ERR(new_ns))
down_write(&namespace_sem);
/* First pass: copy the tree topology */
- new_ns->root = copy_tree(mnt_ns->root, mnt_ns->root->mnt_root,
+ new = copy_tree(real_mount(mnt_ns->root), mnt_ns->root->mnt_root,
CL_COPY_ALL | CL_EXPIRE);
- if (!new_ns->root) {
+ if (!new) {
up_write(&namespace_sem);
kfree(new_ns);
return ERR_PTR(-ENOMEM);
}
+ new_ns->root = &new->mnt;
br_write_lock(vfsmount_lock);
list_add_tail(&new_ns->list, &new_ns->root->mnt_list);
br_write_unlock(vfsmount_lock);
* fs_struct, so tsk->fs->lock is not needed.
*/
p = real_mount(mnt_ns->root);
- q = real_mount(new_ns->root);
+ 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);
return;
down_write(&namespace_sem);
br_write_lock(vfsmount_lock);
- umount_tree(ns->root, 0, &umount_list);
+ umount_tree(real_mount(ns->root), 0, &umount_list);
br_write_unlock(vfsmount_lock);
up_write(&namespace_sem);
release_mounts(&umount_list);
projects / linux-block.git / blobdiff