path: root/fs/namespace.c (plain)
blob: 6224ff52544b0444505f20fc3ca3d4c4eb590adb

1	/*
2	* linux/fs/namespace.c
3	*
4	* (C) Copyright Al Viro 2000, 2001
5	* Released under GPL v2.
6	*
7	* Based on code from fs/super.c, copyright Linus Torvalds and others.
8	* Heavily rewritten.
9	*/
10
11	#include <linux/syscalls.h>
12	#include <linux/export.h>
13	#include <linux/capability.h>
14	#include <linux/mnt_namespace.h>
15	#include <linux/user_namespace.h>
16	#include <linux/namei.h>
17	#include <linux/security.h>
18	#include <linux/idr.h>
19	#include <linux/init.h> /* init_rootfs */
20	#include <linux/fs_struct.h> /* get_fs_root et.al. */
21	#include <linux/fsnotify.h> /* fsnotify_vfsmount_delete */
22	#include <linux/uaccess.h>
23	#include <linux/proc_ns.h>
24	#include <linux/magic.h>
25	#include <linux/bootmem.h>
26	#include <linux/task_work.h>
27	#include "pnode.h"
28	#include "internal.h"
29
30	/* Maximum number of mounts in a mount namespace */
31	unsigned int sysctl_mount_max __read_mostly = 100000;
32
33	static unsigned int m_hash_mask __read_mostly;
34	static unsigned int m_hash_shift __read_mostly;
35	static unsigned int mp_hash_mask __read_mostly;
36	static unsigned int mp_hash_shift __read_mostly;
37
38	static __initdata unsigned long mhash_entries;
39	static int __init set_mhash_entries(char *str)
40	{
41	if (!str)
42	return 0;
43	mhash_entries = simple_strtoul(str, &str, 0);
44	return 1;
45	}
46	__setup("mhash_entries=", set_mhash_entries);
47
48	static __initdata unsigned long mphash_entries;
49	static int __init set_mphash_entries(char *str)
50	{
51	if (!str)
52	return 0;
53	mphash_entries = simple_strtoul(str, &str, 0);
54	return 1;
55	}
56	__setup("mphash_entries=", set_mphash_entries);
57
58	static u64 event;
59	static DEFINE_IDA(mnt_id_ida);
60	static DEFINE_IDA(mnt_group_ida);
61	static DEFINE_SPINLOCK(mnt_id_lock);
62	static int mnt_id_start = 0;
63	static int mnt_group_start = 1;
64
65	static struct hlist_head *mount_hashtable __read_mostly;
66	static struct hlist_head *mountpoint_hashtable __read_mostly;
67	static struct kmem_cache *mnt_cache __read_mostly;
68	static DECLARE_RWSEM(namespace_sem);
69
70	/* /sys/fs */
71	struct kobject *fs_kobj;
72	EXPORT_SYMBOL_GPL(fs_kobj);
73
74	/*
75	* vfsmount lock may be taken for read to prevent changes to the
76	* vfsmount hash, ie. during mountpoint lookups or walking back
77	* up the tree.
78	*
79	* It should be taken for write in all cases where the vfsmount
80	* tree or hash is modified or when a vfsmount structure is modified.
81	*/
82	__cacheline_aligned_in_smp DEFINE_SEQLOCK(mount_lock);
83
84	static inline struct hlist_head *m_hash(struct vfsmount *mnt, struct dentry *dentry)
85	{
86	unsigned long tmp = ((unsigned long)mnt / L1_CACHE_BYTES);
87	tmp += ((unsigned long)dentry / L1_CACHE_BYTES);
88	tmp = tmp + (tmp >> m_hash_shift);
89	return &mount_hashtable[tmp & m_hash_mask];
90	}
91
92	static inline struct hlist_head *mp_hash(struct dentry *dentry)
93	{
94	unsigned long tmp = ((unsigned long)dentry / L1_CACHE_BYTES);
95	tmp = tmp + (tmp >> mp_hash_shift);
96	return &mountpoint_hashtable[tmp & mp_hash_mask];
97	}
98
99	/*
100	* allocation is serialized by namespace_sem, but we need the spinlock to
101	* serialize with freeing.
102	*/
103	static int mnt_alloc_id(struct mount *mnt)
104	{
105	int res;
106
107	retry:
108	ida_pre_get(&mnt_id_ida, GFP_KERNEL);
109	spin_lock(&mnt_id_lock);
110	res = ida_get_new_above(&mnt_id_ida, mnt_id_start, &mnt->mnt_id);
111	if (!res)
112	mnt_id_start = mnt->mnt_id + 1;
113	spin_unlock(&mnt_id_lock);
114	if (res == -EAGAIN)
115	goto retry;
116
117	return res;
118	}
119
120	static void mnt_free_id(struct mount *mnt)
121	{
122	int id = mnt->mnt_id;
123	spin_lock(&mnt_id_lock);
124	ida_remove(&mnt_id_ida, id);
125	if (mnt_id_start > id)
126	mnt_id_start = id;
127	spin_unlock(&mnt_id_lock);
128	}
129
130	/*
131	* Allocate a new peer group ID
132	*
133	* mnt_group_ida is protected by namespace_sem
134	*/
135	static int mnt_alloc_group_id(struct mount *mnt)
136	{
137	int res;
138
139	if (!ida_pre_get(&mnt_group_ida, GFP_KERNEL))
140	return -ENOMEM;
141
142	res = ida_get_new_above(&mnt_group_ida,
143	mnt_group_start,
144	&mnt->mnt_group_id);
145	if (!res)
146	mnt_group_start = mnt->mnt_group_id + 1;
147
148	return res;
149	}
150
151	/*
152	* Release a peer group ID
153	*/
154	void mnt_release_group_id(struct mount *mnt)
155	{
156	int id = mnt->mnt_group_id;
157	ida_remove(&mnt_group_ida, id);
158	if (mnt_group_start > id)
159	mnt_group_start = id;
160	mnt->mnt_group_id = 0;
161	}
162
163	/*
164	* vfsmount lock must be held for read
165	*/
166	static inline void mnt_add_count(struct mount *mnt, int n)
167	{
168	#ifdef CONFIG_SMP
169	this_cpu_add(mnt->mnt_pcp->mnt_count, n);
170	#else
171	preempt_disable();
172	mnt->mnt_count += n;
173	preempt_enable();
174	#endif
175	}
176
177	/*
178	* vfsmount lock must be held for write
179	*/
180	unsigned int mnt_get_count(struct mount *mnt)
181	{
182	#ifdef CONFIG_SMP
183	unsigned int count = 0;
184	int cpu;
185
186	for_each_possible_cpu(cpu) {
187	count += per_cpu_ptr(mnt->mnt_pcp, cpu)->mnt_count;
188	}
189
190	return count;
191	#else
192	return mnt->mnt_count;
193	#endif
194	}
195
196	static void drop_mountpoint(struct fs_pin *p)
197	{
198	struct mount *m = container_of(p, struct mount, mnt_umount);
199	dput(m->mnt_ex_mountpoint);
200	pin_remove(p);
201	mntput(&m->mnt);
202	}
203
204	static struct mount *alloc_vfsmnt(const char *name)
205	{
206	struct mount *mnt = kmem_cache_zalloc(mnt_cache, GFP_KERNEL);
207	if (mnt) {
208	int err;
209
210	err = mnt_alloc_id(mnt);
211	if (err)
212	goto out_free_cache;
213
214	if (name) {
215	mnt->mnt_devname = kstrdup_const(name, GFP_KERNEL);
216	if (!mnt->mnt_devname)
217	goto out_free_id;
218	}
219
220	#ifdef CONFIG_SMP
221	mnt->mnt_pcp = alloc_percpu(struct mnt_pcp);
222	if (!mnt->mnt_pcp)
223	goto out_free_devname;
224
225	this_cpu_add(mnt->mnt_pcp->mnt_count, 1);
226	#else
227	mnt->mnt_count = 1;
228	mnt->mnt_writers = 0;
229	#endif
230	mnt->mnt.data = NULL;
231
232	INIT_HLIST_NODE(&mnt->mnt_hash);
233	INIT_LIST_HEAD(&mnt->mnt_child);
234	INIT_LIST_HEAD(&mnt->mnt_mounts);
235	INIT_LIST_HEAD(&mnt->mnt_list);
236	INIT_LIST_HEAD(&mnt->mnt_expire);
237	INIT_LIST_HEAD(&mnt->mnt_share);
238	INIT_LIST_HEAD(&mnt->mnt_slave_list);
239	INIT_LIST_HEAD(&mnt->mnt_slave);
240	INIT_HLIST_NODE(&mnt->mnt_mp_list);
241	INIT_LIST_HEAD(&mnt->mnt_umounting);
242	#ifdef CONFIG_FSNOTIFY
243	INIT_HLIST_HEAD(&mnt->mnt_fsnotify_marks);
244	#endif
245	init_fs_pin(&mnt->mnt_umount, drop_mountpoint);
246	}
247	return mnt;
248
249	#ifdef CONFIG_SMP
250	out_free_devname:
251	kfree_const(mnt->mnt_devname);
252	#endif
253	out_free_id:
254	mnt_free_id(mnt);
255	out_free_cache:
256	kmem_cache_free(mnt_cache, mnt);
257	return NULL;
258	}
259
260	/*
261	* Most r/o checks on a fs are for operations that take
262	* discrete amounts of time, like a write() or unlink().
263	* We must keep track of when those operations start
264	* (for permission checks) and when they end, so that
265	* we can determine when writes are able to occur to
266	* a filesystem.
267	*/
268	/*
269	* __mnt_is_readonly: check whether a mount is read-only
270	* @mnt: the mount to check for its write status
271	*
272	* This shouldn't be used directly ouside of the VFS.
273	* It does not guarantee that the filesystem will stay
274	* r/w, just that it is right *now*. This can not and
275	* should not be used in place of IS_RDONLY(inode).
276	* mnt_want/drop_write() will _keep_ the filesystem
277	* r/w.
278	*/
279	int __mnt_is_readonly(struct vfsmount *mnt)
280	{
281	if (mnt->mnt_flags & MNT_READONLY)
282	return 1;
283	if (mnt->mnt_sb->s_flags & MS_RDONLY)
284	return 1;
285	return 0;
286	}
287	EXPORT_SYMBOL_GPL(__mnt_is_readonly);
288
289	static inline void mnt_inc_writers(struct mount *mnt)
290	{
291	#ifdef CONFIG_SMP
292	this_cpu_inc(mnt->mnt_pcp->mnt_writers);
293	#else
294	mnt->mnt_writers++;
295	#endif
296	}
297
298	static inline void mnt_dec_writers(struct mount *mnt)
299	{
300	#ifdef CONFIG_SMP
301	this_cpu_dec(mnt->mnt_pcp->mnt_writers);
302	#else
303	mnt->mnt_writers--;
304	#endif
305	}
306
307	static unsigned int mnt_get_writers(struct mount *mnt)
308	{
309	#ifdef CONFIG_SMP
310	unsigned int count = 0;
311	int cpu;
312
313	for_each_possible_cpu(cpu) {
314	count += per_cpu_ptr(mnt->mnt_pcp, cpu)->mnt_writers;
315	}
316
317	return count;
318	#else
319	return mnt->mnt_writers;
320	#endif
321	}
322
323	static int mnt_is_readonly(struct vfsmount *mnt)
324	{
325	if (mnt->mnt_sb->s_readonly_remount)
326	return 1;
327	/* Order wrt setting s_flags/s_readonly_remount in do_remount() */
328	smp_rmb();
329	return __mnt_is_readonly(mnt);
330	}
331
332	/*
333	* Most r/o & frozen checks on a fs are for operations that take discrete
334	* amounts of time, like a write() or unlink(). We must keep track of when
335	* those operations start (for permission checks) and when they end, so that we
336	* can determine when writes are able to occur to a filesystem.
337	*/
338	/**
339	* __mnt_want_write - get write access to a mount without freeze protection
340	* @m: the mount on which to take a write
341	*
342	* This tells the low-level filesystem that a write is about to be performed to
343	* it, and makes sure that writes are allowed (mnt it read-write) before
344	* returning success. This operation does not protect against filesystem being
345	* frozen. When the write operation is finished, __mnt_drop_write() must be
346	* called. This is effectively a refcount.
347	*/
348	int __mnt_want_write(struct vfsmount *m)
349	{
350	struct mount *mnt = real_mount(m);
351	int ret = 0;
352
353	preempt_disable();
354	mnt_inc_writers(mnt);
355	/*
356	* The store to mnt_inc_writers must be visible before we pass
357	* MNT_WRITE_HOLD loop below, so that the slowpath can see our
358	* incremented count after it has set MNT_WRITE_HOLD.
359	*/
360	smp_mb();
361	while (ACCESS_ONCE(mnt->mnt.mnt_flags) & MNT_WRITE_HOLD)
362	cpu_relax();
363	/*
364	* After the slowpath clears MNT_WRITE_HOLD, mnt_is_readonly will
365	* be set to match its requirements. So we must not load that until
366	* MNT_WRITE_HOLD is cleared.
367	*/
368	smp_rmb();
369	if (mnt_is_readonly(m)) {
370	mnt_dec_writers(mnt);
371	ret = -EROFS;
372	}
373	preempt_enable();
374
375	return ret;
376	}
377
378	/**
379	* mnt_want_write - get write access to a mount
380	* @m: the mount on which to take a write
381	*
382	* This tells the low-level filesystem that a write is about to be performed to
383	* it, and makes sure that writes are allowed (mount is read-write, filesystem
384	* is not frozen) before returning success. When the write operation is
385	* finished, mnt_drop_write() must be called. This is effectively a refcount.
386	*/
387	int mnt_want_write(struct vfsmount *m)
388	{
389	int ret;
390
391	sb_start_write(m->mnt_sb);
392	ret = __mnt_want_write(m);
393	if (ret)
394	sb_end_write(m->mnt_sb);
395	return ret;
396	}
397	EXPORT_SYMBOL_GPL(mnt_want_write);
398
399	/**
400	* mnt_clone_write - get write access to a mount
401	* @mnt: the mount on which to take a write
402	*
403	* This is effectively like mnt_want_write, except
404	* it must only be used to take an extra write reference
405	* on a mountpoint that we already know has a write reference
406	* on it. This allows some optimisation.
407	*
408	* After finished, mnt_drop_write must be called as usual to
409	* drop the reference.
410	*/
411	int mnt_clone_write(struct vfsmount *mnt)
412	{
413	/* superblock may be r/o */
414	if (__mnt_is_readonly(mnt))
415	return -EROFS;
416	preempt_disable();
417	mnt_inc_writers(real_mount(mnt));
418	preempt_enable();
419	return 0;
420	}
421	EXPORT_SYMBOL_GPL(mnt_clone_write);
422
423	/**
424	* __mnt_want_write_file - get write access to a file's mount
425	* @file: the file who's mount on which to take a write
426	*
427	* This is like __mnt_want_write, but it takes a file and can
428	* do some optimisations if the file is open for write already
429	*/
430	int __mnt_want_write_file(struct file *file)
431	{
432	if (!(file->f_mode & FMODE_WRITER))
433	return __mnt_want_write(file->f_path.mnt);
434	else
435	return mnt_clone_write(file->f_path.mnt);
436	}
437
438	/**
439	* mnt_want_write_file - get write access to a file's mount
440	* @file: the file who's mount on which to take a write
441	*
442	* This is like mnt_want_write, but it takes a file and can
443	* do some optimisations if the file is open for write already
444	*/
445	int mnt_want_write_file(struct file *file)
446	{
447	int ret;
448
449	sb_start_write(file->f_path.mnt->mnt_sb);
450	ret = __mnt_want_write_file(file);
451	if (ret)
452	sb_end_write(file->f_path.mnt->mnt_sb);
453	return ret;
454	}
455	EXPORT_SYMBOL_GPL(mnt_want_write_file);
456
457	/**
458	* __mnt_drop_write - give up write access to a mount
459	* @mnt: the mount on which to give up write access
460	*
461	* Tells the low-level filesystem that we are done
462	* performing writes to it. Must be matched with
463	* __mnt_want_write() call above.
464	*/
465	void __mnt_drop_write(struct vfsmount *mnt)
466	{
467	preempt_disable();
468	mnt_dec_writers(real_mount(mnt));
469	preempt_enable();
470	}
471
472	/**
473	* mnt_drop_write - give up write access to a mount
474	* @mnt: the mount on which to give up write access
475	*
476	* Tells the low-level filesystem that we are done performing writes to it and
477	* also allows filesystem to be frozen again. Must be matched with
478	* mnt_want_write() call above.
479	*/
480	void mnt_drop_write(struct vfsmount *mnt)
481	{
482	__mnt_drop_write(mnt);
483	sb_end_write(mnt->mnt_sb);
484	}
485	EXPORT_SYMBOL_GPL(mnt_drop_write);
486
487	void __mnt_drop_write_file(struct file *file)
488	{
489	__mnt_drop_write(file->f_path.mnt);
490	}
491
492	void mnt_drop_write_file(struct file *file)
493	{
494	mnt_drop_write(file->f_path.mnt);
495	}
496	EXPORT_SYMBOL(mnt_drop_write_file);
497
498	static int mnt_make_readonly(struct mount *mnt)
499	{
500	int ret = 0;
501
502	lock_mount_hash();
503	mnt->mnt.mnt_flags |= MNT_WRITE_HOLD;
504	/*
505	* After storing MNT_WRITE_HOLD, we'll read the counters. This store
506	* should be visible before we do.
507	*/
508	smp_mb();
509
510	/*
511	* With writers on hold, if this value is zero, then there are
512	* definitely no active writers (although held writers may subsequently
513	* increment the count, they'll have to wait, and decrement it after
514	* seeing MNT_READONLY).
515	*
516	* It is OK to have counter incremented on one CPU and decremented on
517	* another: the sum will add up correctly. The danger would be when we
518	* sum up each counter, if we read a counter before it is incremented,
519	* but then read another CPU's count which it has been subsequently
520	* decremented from -- we would see more decrements than we should.
521	* MNT_WRITE_HOLD protects against this scenario, because
522	* mnt_want_write first increments count, then smp_mb, then spins on
523	* MNT_WRITE_HOLD, so it can't be decremented by another CPU while
524	* we're counting up here.
525	*/
526	if (mnt_get_writers(mnt) > 0)
527	ret = -EBUSY;
528	else
529	mnt->mnt.mnt_flags |= MNT_READONLY;
530	/*
531	* MNT_READONLY must become visible before ~MNT_WRITE_HOLD, so writers
532	* that become unheld will see MNT_READONLY.
533	*/
534	smp_wmb();
535	mnt->mnt.mnt_flags &= ~MNT_WRITE_HOLD;
536	unlock_mount_hash();
537	return ret;
538	}
539
540	static void __mnt_unmake_readonly(struct mount *mnt)
541	{
542	lock_mount_hash();
543	mnt->mnt.mnt_flags &= ~MNT_READONLY;
544	unlock_mount_hash();
545	}
546
547	int sb_prepare_remount_readonly(struct super_block *sb)
548	{
549	struct mount *mnt;
550	int err = 0;
551
552	/* Racy optimization. Recheck the counter under MNT_WRITE_HOLD */
553	if (atomic_long_read(&sb->s_remove_count))
554	return -EBUSY;
555
556	lock_mount_hash();
557	list_for_each_entry(mnt, &sb->s_mounts, mnt_instance) {
558	if (!(mnt->mnt.mnt_flags & MNT_READONLY)) {
559	mnt->mnt.mnt_flags |= MNT_WRITE_HOLD;
560	smp_mb();
561	if (mnt_get_writers(mnt) > 0) {
562	err = -EBUSY;
563	break;
564	}
565	}
566	}
567	if (!err && atomic_long_read(&sb->s_remove_count))
568	err = -EBUSY;
569
570	if (!err) {
571	sb->s_readonly_remount = 1;
572	smp_wmb();
573	}
574	list_for_each_entry(mnt, &sb->s_mounts, mnt_instance) {
575	if (mnt->mnt.mnt_flags & MNT_WRITE_HOLD)
576	mnt->mnt.mnt_flags &= ~MNT_WRITE_HOLD;
577	}
578	unlock_mount_hash();
579
580	return err;
581	}
582
583	static void free_vfsmnt(struct mount *mnt)
584	{
585	kfree(mnt->mnt.data);
586	kfree_const(mnt->mnt_devname);
587	#ifdef CONFIG_SMP
588	free_percpu(mnt->mnt_pcp);
589	#endif
590	kmem_cache_free(mnt_cache, mnt);
591	}
592
593	static void delayed_free_vfsmnt(struct rcu_head *head)
594	{
595	free_vfsmnt(container_of(head, struct mount, mnt_rcu));
596	}
597
598	/* call under rcu_read_lock */
599	int __legitimize_mnt(struct vfsmount *bastard, unsigned seq)
600	{
601	struct mount *mnt;
602	if (read_seqretry(&mount_lock, seq))
603	return 1;
604	if (bastard == NULL)
605	return 0;
606	mnt = real_mount(bastard);
607	mnt_add_count(mnt, 1);
608	smp_mb(); // see mntput_no_expire()
609	if (likely(!read_seqretry(&mount_lock, seq)))
610	return 0;
611	if (bastard->mnt_flags & MNT_SYNC_UMOUNT) {
612	mnt_add_count(mnt, -1);
613	return 1;
614	}
615	lock_mount_hash();
616	if (unlikely(bastard->mnt_flags & MNT_DOOMED)) {
617	mnt_add_count(mnt, -1);
618	unlock_mount_hash();
619	return 1;
620	}
621	unlock_mount_hash();
622	/* caller will mntput() */
623	return -1;
624	}
625
626	/* call under rcu_read_lock */
627	bool legitimize_mnt(struct vfsmount *bastard, unsigned seq)
628	{
629	int res = __legitimize_mnt(bastard, seq);
630	if (likely(!res))
631	return true;
632	if (unlikely(res < 0)) {
633	rcu_read_unlock();
634	mntput(bastard);
635	rcu_read_lock();
636	}
637	return false;
638	}
639
640	/*
641	* find the first mount at @dentry on vfsmount @mnt.
642	* call under rcu_read_lock()
643	*/
644	struct mount *__lookup_mnt(struct vfsmount *mnt, struct dentry *dentry)
645	{
646	struct hlist_head *head = m_hash(mnt, dentry);
647	struct mount *p;
648
649	hlist_for_each_entry_rcu(p, head, mnt_hash)
650	if (&p->mnt_parent->mnt == mnt && p->mnt_mountpoint == dentry)
651	return p;
652	return NULL;
653	}
654
655	/*
656	* lookup_mnt - Return the first child mount mounted at path
657	*
658	* "First" means first mounted chronologically. If you create the
659	* following mounts:
660	*
661	* mount /dev/sda1 /mnt
662	* mount /dev/sda2 /mnt
663	* mount /dev/sda3 /mnt
664	*
665	* Then lookup_mnt() on the base /mnt dentry in the root mount will
666	* return successively the root dentry and vfsmount of /dev/sda1, then
667	* /dev/sda2, then /dev/sda3, then NULL.
668	*
669	* lookup_mnt takes a reference to the found vfsmount.
670	*/
671	struct vfsmount *lookup_mnt(struct path *path)
672	{
673	struct mount *child_mnt;
674	struct vfsmount *m;
675	unsigned seq;
676
677	rcu_read_lock();
678	do {
679	seq = read_seqbegin(&mount_lock);
680	child_mnt = __lookup_mnt(path->mnt, path->dentry);
681	m = child_mnt ? &child_mnt->mnt : NULL;
682	} while (!legitimize_mnt(m, seq));
683	rcu_read_unlock();
684	return m;
685	}
686
687	/*
688	* __is_local_mountpoint - Test to see if dentry is a mountpoint in the
689	* current mount namespace.
690	*
691	* The common case is dentries are not mountpoints at all and that
692	* test is handled inline. For the slow case when we are actually
693	* dealing with a mountpoint of some kind, walk through all of the
694	* mounts in the current mount namespace and test to see if the dentry
695	* is a mountpoint.
696	*
697	* The mount_hashtable is not usable in the context because we
698	* need to identify all mounts that may be in the current mount
699	* namespace not just a mount that happens to have some specified
700	* parent mount.
701	*/
702	bool __is_local_mountpoint(struct dentry *dentry)
703	{
704	struct mnt_namespace *ns = current->nsproxy->mnt_ns;
705	struct mount *mnt;
706	bool is_covered = false;
707
708	if (!d_mountpoint(dentry))
709	goto out;
710
711	down_read(&namespace_sem);
712	list_for_each_entry(mnt, &ns->list, mnt_list) {
713	is_covered = (mnt->mnt_mountpoint == dentry);
714	if (is_covered)
715	break;
716	}
717	up_read(&namespace_sem);
718	out:
719	return is_covered;
720	}
721
722	static struct mountpoint *lookup_mountpoint(struct dentry *dentry)
723	{
724	struct hlist_head *chain = mp_hash(dentry);
725	struct mountpoint *mp;
726
727	hlist_for_each_entry(mp, chain, m_hash) {
728	if (mp->m_dentry == dentry) {
729	/* might be worth a WARN_ON() */
730	if (d_unlinked(dentry))
731	return ERR_PTR(-ENOENT);
732	mp->m_count++;
733	return mp;
734	}
735	}
736	return NULL;
737	}
738
739	static struct mountpoint *get_mountpoint(struct dentry *dentry)
740	{
741	struct mountpoint *mp, *new = NULL;
742	int ret;
743
744	if (d_mountpoint(dentry)) {
745	mountpoint:
746	read_seqlock_excl(&mount_lock);
747	mp = lookup_mountpoint(dentry);
748	read_sequnlock_excl(&mount_lock);
749	if (mp)
750	goto done;
751	}
752
753	if (!new)
754	new = kmalloc(sizeof(struct mountpoint), GFP_KERNEL);
755	if (!new)
756	return ERR_PTR(-ENOMEM);
757
758
759	/* Exactly one processes may set d_mounted */
760	ret = d_set_mounted(dentry);
761
762	/* Someone else set d_mounted? */
763	if (ret == -EBUSY)
764	goto mountpoint;
765
766	/* The dentry is not available as a mountpoint? */
767	mp = ERR_PTR(ret);
768	if (ret)
769	goto done;
770
771	/* Add the new mountpoint to the hash table */
772	read_seqlock_excl(&mount_lock);
773	new->m_dentry = dentry;
774	new->m_count = 1;
775	hlist_add_head(&new->m_hash, mp_hash(dentry));
776	INIT_HLIST_HEAD(&new->m_list);
777	read_sequnlock_excl(&mount_lock);
778
779	mp = new;
780	new = NULL;
781	done:
782	kfree(new);
783	return mp;
784	}
785
786	static void put_mountpoint(struct mountpoint *mp)
787	{
788	if (!--mp->m_count) {
789	struct dentry *dentry = mp->m_dentry;
790	BUG_ON(!hlist_empty(&mp->m_list));
791	spin_lock(&dentry->d_lock);
792	dentry->d_flags &= ~DCACHE_MOUNTED;
793	spin_unlock(&dentry->d_lock);
794	hlist_del(&mp->m_hash);
795	kfree(mp);
796	}
797	}
798
799	static inline int check_mnt(struct mount *mnt)
800	{
801	return mnt->mnt_ns == current->nsproxy->mnt_ns;
802	}
803
804	/*
805	* vfsmount lock must be held for write
806	*/
807	static void touch_mnt_namespace(struct mnt_namespace *ns)
808	{
809	if (ns) {
810	ns->event = ++event;
811	wake_up_interruptible(&ns->poll);
812	}
813	}
814
815	/*
816	* vfsmount lock must be held for write
817	*/
818	static void __touch_mnt_namespace(struct mnt_namespace *ns)
819	{
820	if (ns && ns->event != event) {
821	ns->event = event;
822	wake_up_interruptible(&ns->poll);
823	}
824	}
825
826	/*
827	* vfsmount lock must be held for write
828	*/
829	static void unhash_mnt(struct mount *mnt)
830	{
831	mnt->mnt_parent = mnt;
832	mnt->mnt_mountpoint = mnt->mnt.mnt_root;
833	list_del_init(&mnt->mnt_child);
834	hlist_del_init_rcu(&mnt->mnt_hash);
835	hlist_del_init(&mnt->mnt_mp_list);
836	put_mountpoint(mnt->mnt_mp);
837	mnt->mnt_mp = NULL;
838	}
839
840	/*
841	* vfsmount lock must be held for write
842	*/
843	static void detach_mnt(struct mount *mnt, struct path *old_path)
844	{
845	old_path->dentry = mnt->mnt_mountpoint;
846	old_path->mnt = &mnt->mnt_parent->mnt;
847	unhash_mnt(mnt);
848	}
849
850	/*
851	* vfsmount lock must be held for write
852	*/
853	static void umount_mnt(struct mount *mnt)
854	{
855	/* old mountpoint will be dropped when we can do that */
856	mnt->mnt_ex_mountpoint = mnt->mnt_mountpoint;
857	unhash_mnt(mnt);
858	}
859
860	/*
861	* vfsmount lock must be held for write
862	*/
863	void mnt_set_mountpoint(struct mount *mnt,
864	struct mountpoint *mp,
865	struct mount *child_mnt)
866	{
867	mp->m_count++;
868	mnt_add_count(mnt, 1); /* essentially, that's mntget */
869	child_mnt->mnt_mountpoint = dget(mp->m_dentry);
870	child_mnt->mnt_parent = mnt;
871	child_mnt->mnt_mp = mp;
872	hlist_add_head(&child_mnt->mnt_mp_list, &mp->m_list);
873	}
874
875	static void __attach_mnt(struct mount *mnt, struct mount *parent)
876	{
877	hlist_add_head_rcu(&mnt->mnt_hash,
878	m_hash(&parent->mnt, mnt->mnt_mountpoint));
879	list_add_tail(&mnt->mnt_child, &parent->mnt_mounts);
880	}
881
882	/*
883	* vfsmount lock must be held for write
884	*/
885	static void attach_mnt(struct mount *mnt,
886	struct mount *parent,
887	struct mountpoint *mp)
888	{
889	mnt_set_mountpoint(parent, mp, mnt);
890	__attach_mnt(mnt, parent);
891	}
892
893	void mnt_change_mountpoint(struct mount *parent, struct mountpoint *mp, struct mount *mnt)
894	{
895	struct mountpoint *old_mp = mnt->mnt_mp;
896	struct dentry *old_mountpoint = mnt->mnt_mountpoint;
897	struct mount *old_parent = mnt->mnt_parent;
898
899	list_del_init(&mnt->mnt_child);
900	hlist_del_init(&mnt->mnt_mp_list);
901	hlist_del_init_rcu(&mnt->mnt_hash);
902
903	attach_mnt(mnt, parent, mp);
904
905	put_mountpoint(old_mp);
906
907	/*
908	* Safely avoid even the suggestion this code might sleep or
909	* lock the mount hash by taking advantage of the knowledge that
910	* mnt_change_mountpoint will not release the final reference
911	* to a mountpoint.
912	*
913	* During mounting, the mount passed in as the parent mount will
914	* continue to use the old mountpoint and during unmounting, the
915	* old mountpoint will continue to exist until namespace_unlock,
916	* which happens well after mnt_change_mountpoint.
917	*/
918	spin_lock(&old_mountpoint->d_lock);
919	old_mountpoint->d_lockref.count--;
920	spin_unlock(&old_mountpoint->d_lock);
921
922	mnt_add_count(old_parent, -1);
923	}
924
925	/*
926	* vfsmount lock must be held for write
927	*/
928	static void commit_tree(struct mount *mnt)
929	{
930	struct mount *parent = mnt->mnt_parent;
931	struct mount *m;
932	LIST_HEAD(head);
933	struct mnt_namespace *n = parent->mnt_ns;
934
935	BUG_ON(parent == mnt);
936
937	list_add_tail(&head, &mnt->mnt_list);
938	list_for_each_entry(m, &head, mnt_list)
939	m->mnt_ns = n;
940
941	list_splice(&head, n->list.prev);
942
943	n->mounts += n->pending_mounts;
944	n->pending_mounts = 0;
945
946	__attach_mnt(mnt, parent);
947	touch_mnt_namespace(n);
948	}
949
950	static struct mount *next_mnt(struct mount *p, struct mount *root)
951	{
952	struct list_head *next = p->mnt_mounts.next;
953	if (next == &p->mnt_mounts) {
954	while (1) {
955	if (p == root)
956	return NULL;
957	next = p->mnt_child.next;
958	if (next != &p->mnt_parent->mnt_mounts)
959	break;
960	p = p->mnt_parent;
961	}
962	}
963	return list_entry(next, struct mount, mnt_child);
964	}
965
966	static struct mount *skip_mnt_tree(struct mount *p)
967	{
968	struct list_head *prev = p->mnt_mounts.prev;
969	while (prev != &p->mnt_mounts) {
970	p = list_entry(prev, struct mount, mnt_child);
971	prev = p->mnt_mounts.prev;
972	}
973	return p;
974	}
975
976	struct vfsmount *
977	vfs_kern_mount(struct file_system_type *type, int flags, const char *name, void *data)
978	{
979	struct mount *mnt;
980	struct dentry *root;
981
982	if (!type)
983	return ERR_PTR(-ENODEV);
984
985	mnt = alloc_vfsmnt(name);
986	if (!mnt)
987	return ERR_PTR(-ENOMEM);
988
989	if (type->alloc_mnt_data) {
990	mnt->mnt.data = type->alloc_mnt_data();
991	if (!mnt->mnt.data) {
992	mnt_free_id(mnt);
993	free_vfsmnt(mnt);
994	return ERR_PTR(-ENOMEM);
995	}
996	}
997	if (flags & MS_KERNMOUNT)
998	mnt->mnt.mnt_flags = MNT_INTERNAL;
999
1000	root = mount_fs(type, flags, name, &mnt->mnt, data);
1001	if (IS_ERR(root)) {
1002	mnt_free_id(mnt);
1003	free_vfsmnt(mnt);
1004	return ERR_CAST(root);
1005	}
1006
1007	mnt->mnt.mnt_root = root;
1008	mnt->mnt.mnt_sb = root->d_sb;
1009	mnt->mnt_mountpoint = mnt->mnt.mnt_root;
1010	mnt->mnt_parent = mnt;
1011	lock_mount_hash();
1012	list_add_tail(&mnt->mnt_instance, &root->d_sb->s_mounts);
1013	unlock_mount_hash();
1014	return &mnt->mnt;
1015	}
1016	EXPORT_SYMBOL_GPL(vfs_kern_mount);
1017
1018	struct vfsmount *
1019	vfs_submount(const struct dentry *mountpoint, struct file_system_type *type,
1020	const char *name, void *data)
1021	{
1022	/* Until it is worked out how to pass the user namespace
1023	* through from the parent mount to the submount don't support
1024	* unprivileged mounts with submounts.
1025	*/
1026	if (mountpoint->d_sb->s_user_ns != &init_user_ns)
1027	return ERR_PTR(-EPERM);
1028
1029	return vfs_kern_mount(type, MS_SUBMOUNT, name, data);
1030	}
1031	EXPORT_SYMBOL_GPL(vfs_submount);
1032
1033	static struct mount *clone_mnt(struct mount *old, struct dentry *root,
1034	int flag)
1035	{
1036	struct super_block *sb = old->mnt.mnt_sb;
1037	struct mount *mnt;
1038	int err;
1039
1040	mnt = alloc_vfsmnt(old->mnt_devname);
1041	if (!mnt)
1042	return ERR_PTR(-ENOMEM);
1043
1044	if (sb->s_op->clone_mnt_data) {
1045	mnt->mnt.data = sb->s_op->clone_mnt_data(old->mnt.data);
1046	if (!mnt->mnt.data) {
1047	err = -ENOMEM;
1048	goto out_free;
1049	}
1050	}
1051
1052	if (flag & (CL_SLAVE | CL_PRIVATE | CL_SHARED_TO_SLAVE))
1053	mnt->mnt_group_id = 0; /* not a peer of original */
1054	else
1055	mnt->mnt_group_id = old->mnt_group_id;
1056
1057	if ((flag & CL_MAKE_SHARED) && !mnt->mnt_group_id) {
1058	err = mnt_alloc_group_id(mnt);
1059	if (err)
1060	goto out_free;
1061	}
1062
1063	mnt->mnt.mnt_flags = old->mnt.mnt_flags;
1064	mnt->mnt.mnt_flags &= ~(MNT_WRITE_HOLD|MNT_MARKED|MNT_INTERNAL);
1065	/* Don't allow unprivileged users to change mount flags */
1066	if (flag & CL_UNPRIVILEGED) {
1067	mnt->mnt.mnt_flags |= MNT_LOCK_ATIME;
1068
1069	if (mnt->mnt.mnt_flags & MNT_READONLY)
1070	mnt->mnt.mnt_flags |= MNT_LOCK_READONLY;
1071
1072	if (mnt->mnt.mnt_flags & MNT_NODEV)
1073	mnt->mnt.mnt_flags |= MNT_LOCK_NODEV;
1074
1075	if (mnt->mnt.mnt_flags & MNT_NOSUID)
1076	mnt->mnt.mnt_flags |= MNT_LOCK_NOSUID;
1077
1078	if (mnt->mnt.mnt_flags & MNT_NOEXEC)
1079	mnt->mnt.mnt_flags |= MNT_LOCK_NOEXEC;
1080	}
1081
1082	/* Don't allow unprivileged users to reveal what is under a mount */
1083	if ((flag & CL_UNPRIVILEGED) &&
1084	(!(flag & CL_EXPIRE) || list_empty(&old->mnt_expire)))
1085	mnt->mnt.mnt_flags |= MNT_LOCKED;
1086
1087	atomic_inc(&sb->s_active);
1088	mnt->mnt.mnt_sb = sb;
1089	mnt->mnt.mnt_root = dget(root);
1090	mnt->mnt_mountpoint = mnt->mnt.mnt_root;
1091	mnt->mnt_parent = mnt;
1092	lock_mount_hash();
1093	list_add_tail(&mnt->mnt_instance, &sb->s_mounts);
1094	unlock_mount_hash();
1095
1096	if ((flag & CL_SLAVE) ||
1097	((flag & CL_SHARED_TO_SLAVE) && IS_MNT_SHARED(old))) {
1098	list_add(&mnt->mnt_slave, &old->mnt_slave_list);
1099	mnt->mnt_master = old;
1100	CLEAR_MNT_SHARED(mnt);
1101	} else if (!(flag & CL_PRIVATE)) {
1102	if ((flag & CL_MAKE_SHARED) || IS_MNT_SHARED(old))
1103	list_add(&mnt->mnt_share, &old->mnt_share);
1104	if (IS_MNT_SLAVE(old))
1105	list_add(&mnt->mnt_slave, &old->mnt_slave);
1106	mnt->mnt_master = old->mnt_master;
1107	}
1108	if (flag & CL_MAKE_SHARED)
1109	set_mnt_shared(mnt);
1110
1111	/* stick the duplicate mount on the same expiry list
1112	* as the original if that was on one */
1113	if (flag & CL_EXPIRE) {
1114	if (!list_empty(&old->mnt_expire))
1115	list_add(&mnt->mnt_expire, &old->mnt_expire);
1116	}
1117
1118	return mnt;
1119
1120	out_free:
1121	mnt_free_id(mnt);
1122	free_vfsmnt(mnt);
1123	return ERR_PTR(err);
1124	}
1125
1126	static void cleanup_mnt(struct mount *mnt)
1127	{
1128	/*
1129	* This probably indicates that somebody messed
1130	* up a mnt_want/drop_write() pair. If this
1131	* happens, the filesystem was probably unable
1132	* to make r/w->r/o transitions.
1133	*/
1134	/*
1135	* The locking used to deal with mnt_count decrement provides barriers,
1136	* so mnt_get_writers() below is safe.
1137	*/
1138	WARN_ON(mnt_get_writers(mnt));
1139	if (unlikely(mnt->mnt_pins.first))
1140	mnt_pin_kill(mnt);
1141	fsnotify_vfsmount_delete(&mnt->mnt);
1142	dput(mnt->mnt.mnt_root);
1143	deactivate_super(mnt->mnt.mnt_sb);
1144	mnt_free_id(mnt);
1145	call_rcu(&mnt->mnt_rcu, delayed_free_vfsmnt);
1146	}
1147
1148	static void __cleanup_mnt(struct rcu_head *head)
1149	{
1150	cleanup_mnt(container_of(head, struct mount, mnt_rcu));
1151	}
1152
1153	static LLIST_HEAD(delayed_mntput_list);
1154	static void delayed_mntput(struct work_struct *unused)
1155	{
1156	struct llist_node *node = llist_del_all(&delayed_mntput_list);
1157	struct llist_node *next;
1158
1159	for (; node; node = next) {
1160	next = llist_next(node);
1161	cleanup_mnt(llist_entry(node, struct mount, mnt_llist));
1162	}
1163	}
1164	static DECLARE_DELAYED_WORK(delayed_mntput_work, delayed_mntput);
1165
1166	static void mntput_no_expire(struct mount *mnt)
1167	{
1168	rcu_read_lock();
1169	if (likely(READ_ONCE(mnt->mnt_ns))) {
1170	/*
1171	* Since we don't do lock_mount_hash() here,
1172	* ->mnt_ns can change under us. However, if it's
1173	* non-NULL, then there's a reference that won't
1174	* be dropped until after an RCU delay done after
1175	* turning ->mnt_ns NULL. So if we observe it
1176	* non-NULL under rcu_read_lock(), the reference
1177	* we are dropping is not the final one.
1178	*/
1179	mnt_add_count(mnt, -1);
1180	rcu_read_unlock();
1181	return;
1182	}
1183	lock_mount_hash();
1184	/*
1185	* make sure that if __legitimize_mnt() has not seen us grab
1186	* mount_lock, we'll see their refcount increment here.
1187	*/
1188	smp_mb();
1189	mnt_add_count(mnt, -1);
1190	if (mnt_get_count(mnt)) {
1191	rcu_read_unlock();
1192	unlock_mount_hash();
1193	return;
1194	}
1195	if (unlikely(mnt->mnt.mnt_flags & MNT_DOOMED)) {
1196	rcu_read_unlock();
1197	unlock_mount_hash();
1198	return;
1199	}
1200	mnt->mnt.mnt_flags |= MNT_DOOMED;
1201	rcu_read_unlock();
1202
1203	list_del(&mnt->mnt_instance);
1204
1205	if (unlikely(!list_empty(&mnt->mnt_mounts))) {
1206	struct mount *p, *tmp;
1207	list_for_each_entry_safe(p, tmp, &mnt->mnt_mounts, mnt_child) {
1208	umount_mnt(p);
1209	}
1210	}
1211	unlock_mount_hash();
1212
1213	if (likely(!(mnt->mnt.mnt_flags & MNT_INTERNAL))) {
1214	struct task_struct *task = current;
1215	if (likely(!(task->flags & PF_KTHREAD))) {
1216	init_task_work(&mnt->mnt_rcu, __cleanup_mnt);
1217	if (!task_work_add(task, &mnt->mnt_rcu, true))
1218	return;
1219	}
1220	if (llist_add(&mnt->mnt_llist, &delayed_mntput_list))
1221	schedule_delayed_work(&delayed_mntput_work, 1);
1222	return;
1223	}
1224	cleanup_mnt(mnt);
1225	}
1226
1227	void mntput(struct vfsmount *mnt)
1228	{
1229	if (mnt) {
1230	struct mount *m = real_mount(mnt);
1231	/* avoid cacheline pingpong, hope gcc doesn't get "smart" */
1232	if (unlikely(m->mnt_expiry_mark))
1233	m->mnt_expiry_mark = 0;
1234	mntput_no_expire(m);
1235	}
1236	}
1237	EXPORT_SYMBOL(mntput);
1238
1239	struct vfsmount *mntget(struct vfsmount *mnt)
1240	{
1241	if (mnt)
1242	mnt_add_count(real_mount(mnt), 1);
1243	return mnt;
1244	}
1245	EXPORT_SYMBOL(mntget);
1246
1247	struct vfsmount *mnt_clone_internal(struct path *path)
1248	{
1249	struct mount *p;
1250	p = clone_mnt(real_mount(path->mnt), path->dentry, CL_PRIVATE);
1251	if (IS_ERR(p))
1252	return ERR_CAST(p);
1253	p->mnt.mnt_flags |= MNT_INTERNAL;
1254	return &p->mnt;
1255	}
1256
1257	static inline void mangle(struct seq_file *m, const char *s)
1258	{
1259	seq_escape(m, s, " \t\n\\");
1260	}
1261
1262	/*
1263	* Simple .show_options callback for filesystems which don't want to
1264	* implement more complex mount option showing.
1265	*
1266	* See also save_mount_options().
1267	*/
1268	int generic_show_options(struct seq_file *m, struct dentry *root)
1269	{
1270	const char *options;
1271
1272	rcu_read_lock();
1273	options = rcu_dereference(root->d_sb->s_options);
1274
1275	if (options != NULL && options[0]) {
1276	seq_putc(m, ',');
1277	mangle(m, options);
1278	}
1279	rcu_read_unlock();
1280
1281	return 0;
1282	}
1283	EXPORT_SYMBOL(generic_show_options);
1284
1285	/*
1286	* If filesystem uses generic_show_options(), this function should be
1287	* called from the fill_super() callback.
1288	*
1289	* The .remount_fs callback usually needs to be handled in a special
1290	* way, to make sure, that previous options are not overwritten if the
1291	* remount fails.
1292	*
1293	* Also note, that if the filesystem's .remount_fs function doesn't
1294	* reset all options to their default value, but changes only newly
1295	* given options, then the displayed options will not reflect reality
1296	* any more.
1297	*/
1298	void save_mount_options(struct super_block *sb, char *options)
1299	{
1300	BUG_ON(sb->s_options);
1301	rcu_assign_pointer(sb->s_options, kstrdup(options, GFP_KERNEL));
1302	}
1303	EXPORT_SYMBOL(save_mount_options);
1304
1305	void replace_mount_options(struct super_block *sb, char *options)
1306	{
1307	char *old = sb->s_options;
1308	rcu_assign_pointer(sb->s_options, options);
1309	if (old) {
1310	synchronize_rcu();
1311	kfree(old);
1312	}
1313	}
1314	EXPORT_SYMBOL(replace_mount_options);
1315
1316	#ifdef CONFIG_PROC_FS
1317	/* iterator; we want it to have access to namespace_sem, thus here... */
1318	static void *m_start(struct seq_file *m, loff_t *pos)
1319	{
1320	struct proc_mounts *p = m->private;
1321
1322	down_read(&namespace_sem);
1323	if (p->cached_event == p->ns->event) {
1324	void *v = p->cached_mount;
1325	if (*pos == p->cached_index)
1326	return v;
1327	if (*pos == p->cached_index + 1) {
1328	v = seq_list_next(v, &p->ns->list, &p->cached_index);
1329	return p->cached_mount = v;
1330	}
1331	}
1332
1333	p->cached_event = p->ns->event;
1334	p->cached_mount = seq_list_start(&p->ns->list, *pos);
1335	p->cached_index = *pos;
1336	return p->cached_mount;
1337	}
1338
1339	static void *m_next(struct seq_file *m, void *v, loff_t *pos)
1340	{
1341	struct proc_mounts *p = m->private;
1342
1343	p->cached_mount = seq_list_next(v, &p->ns->list, pos);
1344	p->cached_index = *pos;
1345	return p->cached_mount;
1346	}
1347
1348	static void m_stop(struct seq_file *m, void *v)
1349	{
1350	up_read(&namespace_sem);
1351	}
1352
1353	static int m_show(struct seq_file *m, void *v)
1354	{
1355	struct proc_mounts *p = m->private;
1356	struct mount *r = list_entry(v, struct mount, mnt_list);
1357	return p->show(m, &r->mnt);
1358	}
1359
1360	const struct seq_operations mounts_op = {
1361	.start = m_start,
1362	.next = m_next,
1363	.stop = m_stop,
1364	.show = m_show,
1365	};
1366	#endif /* CONFIG_PROC_FS */
1367
1368	/**
1369	* may_umount_tree - check if a mount tree is busy
1370	* @mnt: root of mount tree
1371	*
1372	* This is called to check if a tree of mounts has any
1373	* open files, pwds, chroots or sub mounts that are
1374	* busy.
1375	*/
1376	int may_umount_tree(struct vfsmount *m)
1377	{
1378	struct mount *mnt = real_mount(m);
1379	int actual_refs = 0;
1380	int minimum_refs = 0;
1381	struct mount *p;
1382	BUG_ON(!m);
1383
1384	/* write lock needed for mnt_get_count */
1385	lock_mount_hash();
1386	for (p = mnt; p; p = next_mnt(p, mnt)) {
1387	actual_refs += mnt_get_count(p);
1388	minimum_refs += 2;
1389	}
1390	unlock_mount_hash();
1391
1392	if (actual_refs > minimum_refs)
1393	return 0;
1394
1395	return 1;
1396	}
1397
1398	EXPORT_SYMBOL(may_umount_tree);
1399
1400	/**
1401	* may_umount - check if a mount point is busy
1402	* @mnt: root of mount
1403	*
1404	* This is called to check if a mount point has any
1405	* open files, pwds, chroots or sub mounts. If the
1406	* mount has sub mounts this will return busy
1407	* regardless of whether the sub mounts are busy.
1408	*
1409	* Doesn't take quota and stuff into account. IOW, in some cases it will
1410	* give false negatives. The main reason why it's here is that we need
1411	* a non-destructive way to look for easily umountable filesystems.
1412	*/
1413	int may_umount(struct vfsmount *mnt)
1414	{
1415	int ret = 1;
1416	down_read(&namespace_sem);
1417	lock_mount_hash();
1418	if (propagate_mount_busy(real_mount(mnt), 2))
1419	ret = 0;
1420	unlock_mount_hash();
1421	up_read(&namespace_sem);
1422	return ret;
1423	}
1424
1425	EXPORT_SYMBOL(may_umount);
1426
1427	static HLIST_HEAD(unmounted); /* protected by namespace_sem */
1428
1429	static void namespace_unlock(void)
1430	{
1431	struct hlist_head head;
1432
1433	hlist_move_list(&unmounted, &head);
1434
1435	up_write(&namespace_sem);
1436
1437	if (likely(hlist_empty(&head)))
1438	return;
1439
1440	synchronize_rcu();
1441
1442	group_pin_kill(&head);
1443	}
1444
1445	static inline void namespace_lock(void)
1446	{
1447	down_write(&namespace_sem);
1448	}
1449
1450	enum umount_tree_flags {
1451	UMOUNT_SYNC = 1,
1452	UMOUNT_PROPAGATE = 2,
1453	UMOUNT_CONNECTED = 4,
1454	};
1455
1456	static bool disconnect_mount(struct mount *mnt, enum umount_tree_flags how)
1457	{
1458	/* Leaving mounts connected is only valid for lazy umounts */
1459	if (how & UMOUNT_SYNC)
1460	return true;
1461
1462	/* A mount without a parent has nothing to be connected to */
1463	if (!mnt_has_parent(mnt))
1464	return true;
1465
1466	/* Because the reference counting rules change when mounts are
1467	* unmounted and connected, umounted mounts may not be
1468	* connected to mounted mounts.
1469	*/
1470	if (!(mnt->mnt_parent->mnt.mnt_flags & MNT_UMOUNT))
1471	return true;
1472
1473	/* Has it been requested that the mount remain connected? */
1474	if (how & UMOUNT_CONNECTED)
1475	return false;
1476
1477	/* Is the mount locked such that it needs to remain connected? */
1478	if (IS_MNT_LOCKED(mnt))
1479	return false;
1480
1481	/* By default disconnect the mount */
1482	return true;
1483	}
1484
1485	/*
1486	* mount_lock must be held
1487	* namespace_sem must be held for write
1488	*/
1489	static void umount_tree(struct mount *mnt, enum umount_tree_flags how)
1490	{
1491	LIST_HEAD(tmp_list);
1492	struct mount *p;
1493
1494	if (how & UMOUNT_PROPAGATE)
1495	propagate_mount_unlock(mnt);
1496
1497	/* Gather the mounts to umount */
1498	for (p = mnt; p; p = next_mnt(p, mnt)) {
1499	p->mnt.mnt_flags |= MNT_UMOUNT;
1500	list_move(&p->mnt_list, &tmp_list);
1501	}
1502
1503	/* Hide the mounts from mnt_mounts */
1504	list_for_each_entry(p, &tmp_list, mnt_list) {
1505	list_del_init(&p->mnt_child);
1506	}
1507
1508	/* Add propogated mounts to the tmp_list */
1509	if (how & UMOUNT_PROPAGATE)
1510	propagate_umount(&tmp_list);
1511
1512	while (!list_empty(&tmp_list)) {
1513	struct mnt_namespace *ns;
1514	bool disconnect;
1515	p = list_first_entry(&tmp_list, struct mount, mnt_list);
1516	list_del_init(&p->mnt_expire);
1517	list_del_init(&p->mnt_list);
1518	ns = p->mnt_ns;
1519	if (ns) {
1520	ns->mounts--;
1521	__touch_mnt_namespace(ns);
1522	}
1523	p->mnt_ns = NULL;
1524	if (how & UMOUNT_SYNC)
1525	p->mnt.mnt_flags |= MNT_SYNC_UMOUNT;
1526
1527	disconnect = disconnect_mount(p, how);
1528
1529	pin_insert_group(&p->mnt_umount, &p->mnt_parent->mnt,
1530	disconnect ? &unmounted : NULL);
1531	if (mnt_has_parent(p)) {
1532	mnt_add_count(p->mnt_parent, -1);
1533	if (!disconnect) {
1534	/* Don't forget about p */
1535	list_add_tail(&p->mnt_child, &p->mnt_parent->mnt_mounts);
1536	} else {
1537	umount_mnt(p);
1538	}
1539	}
1540	change_mnt_propagation(p, MS_PRIVATE);
1541	}
1542	}
1543
1544	static void shrink_submounts(struct mount *mnt);
1545
1546	static int do_umount(struct mount *mnt, int flags)
1547	{
1548	struct super_block *sb = mnt->mnt.mnt_sb;
1549	int retval;
1550
1551	retval = security_sb_umount(&mnt->mnt, flags);
1552	if (retval)
1553	return retval;
1554
1555	/*
1556	* Allow userspace to request a mountpoint be expired rather than
1557	* unmounting unconditionally. Unmount only happens if:
1558	* (1) the mark is already set (the mark is cleared by mntput())
1559	* (2) the usage count == 1 [parent vfsmount] + 1 [sys_umount]
1560	*/
1561	if (flags & MNT_EXPIRE) {
1562	if (&mnt->mnt == current->fs->root.mnt ||
1563	flags & (MNT_FORCE | MNT_DETACH))
1564	return -EINVAL;
1565
1566	/*
1567	* probably don't strictly need the lock here if we examined
1568	* all race cases, but it's a slowpath.
1569	*/
1570	lock_mount_hash();
1571	if (mnt_get_count(mnt) != 2) {
1572	unlock_mount_hash();
1573	return -EBUSY;
1574	}
1575	unlock_mount_hash();
1576
1577	if (!xchg(&mnt->mnt_expiry_mark, 1))
1578	return -EAGAIN;
1579	}
1580
1581	/*
1582	* If we may have to abort operations to get out of this
1583	* mount, and they will themselves hold resources we must
1584	* allow the fs to do things. In the Unix tradition of
1585	* 'Gee thats tricky lets do it in userspace' the umount_begin
1586	* might fail to complete on the first run through as other tasks
1587	* must return, and the like. Thats for the mount program to worry
1588	* about for the moment.
1589	*/
1590
1591	if (flags & MNT_FORCE && sb->s_op->umount_begin) {
1592	sb->s_op->umount_begin(sb);
1593	}
1594
1595	/*
1596	* No sense to grab the lock for this test, but test itself looks
1597	* somewhat bogus. Suggestions for better replacement?
1598	* Ho-hum... In principle, we might treat that as umount + switch
1599	* to rootfs. GC would eventually take care of the old vfsmount.
1600	* Actually it makes sense, especially if rootfs would contain a
1601	* /reboot - static binary that would close all descriptors and
1602	* call reboot(9). Then init(8) could umount root and exec /reboot.
1603	*/
1604	if (&mnt->mnt == current->fs->root.mnt && !(flags & MNT_DETACH)) {
1605	/*
1606	* Special case for "unmounting" root ...
1607	* we just try to remount it readonly.
1608	*/
1609	if (!capable(CAP_SYS_ADMIN))
1610	return -EPERM;
1611	down_write(&sb->s_umount);
1612	if (!(sb->s_flags & MS_RDONLY))
1613	retval = do_remount_sb(sb, MS_RDONLY, NULL, 0);
1614	up_write(&sb->s_umount);
1615	return retval;
1616	}
1617
1618	namespace_lock();
1619	lock_mount_hash();
1620
1621	/* Recheck MNT_LOCKED with the locks held */
1622	retval = -EINVAL;
1623	if (mnt->mnt.mnt_flags & MNT_LOCKED)
1624	goto out;
1625
1626	event++;
1627	if (flags & MNT_DETACH) {
1628	if (!list_empty(&mnt->mnt_list))
1629	umount_tree(mnt, UMOUNT_PROPAGATE);
1630	retval = 0;
1631	} else {
1632	shrink_submounts(mnt);
1633	retval = -EBUSY;
1634	if (!propagate_mount_busy(mnt, 2)) {
1635	if (!list_empty(&mnt->mnt_list))
1636	umount_tree(mnt, UMOUNT_PROPAGATE|UMOUNT_SYNC);
1637	retval = 0;
1638	}
1639	}
1640	out:
1641	unlock_mount_hash();
1642	namespace_unlock();
1643	return retval;
1644	}
1645
1646	/*
1647	* __detach_mounts - lazily unmount all mounts on the specified dentry
1648	*
1649	* During unlink, rmdir, and d_drop it is possible to loose the path
1650	* to an existing mountpoint, and wind up leaking the mount.
1651	* detach_mounts allows lazily unmounting those mounts instead of
1652	* leaking them.
1653	*
1654	* The caller may hold dentry->d_inode->i_mutex.
1655	*/
1656	void __detach_mounts(struct dentry *dentry)
1657	{
1658	struct mountpoint *mp;
1659	struct mount *mnt;
1660
1661	namespace_lock();
1662	lock_mount_hash();
1663	mp = lookup_mountpoint(dentry);
1664	if (IS_ERR_OR_NULL(mp))
1665	goto out_unlock;
1666
1667	event++;
1668	while (!hlist_empty(&mp->m_list)) {
1669	mnt = hlist_entry(mp->m_list.first, struct mount, mnt_mp_list);
1670	if (mnt->mnt.mnt_flags & MNT_UMOUNT) {
1671	hlist_add_head(&mnt->mnt_umount.s_list, &unmounted);
1672	umount_mnt(mnt);
1673	}
1674	else umount_tree(mnt, UMOUNT_CONNECTED);
1675	}
1676	put_mountpoint(mp);
1677	out_unlock:
1678	unlock_mount_hash();
1679	namespace_unlock();
1680	}
1681
1682	/*
1683	* Is the caller allowed to modify his namespace?
1684	*/
1685	static inline bool may_mount(void)
1686	{
1687	return ns_capable(current->nsproxy->mnt_ns->user_ns, CAP_SYS_ADMIN);
1688	}
1689
1690	static inline bool may_mandlock(void)
1691	{
1692	#ifndef CONFIG_MANDATORY_FILE_LOCKING
1693	return false;
1694	#endif
1695	return capable(CAP_SYS_ADMIN);
1696	}
1697
1698	/*
1699	* Now umount can handle mount points as well as block devices.
1700	* This is important for filesystems which use unnamed block devices.
1701	*
1702	* We now support a flag for forced unmount like the other 'big iron'
1703	* unixes. Our API is identical to OSF/1 to avoid making a mess of AMD
1704	*/
1705
1706	SYSCALL_DEFINE2(umount, char __user *, name, int, flags)
1707	{
1708	struct path path;
1709	struct mount *mnt;
1710	int retval;
1711	int lookup_flags = 0;
1712
1713	if (flags & ~(MNT_FORCE | MNT_DETACH | MNT_EXPIRE | UMOUNT_NOFOLLOW))
1714	return -EINVAL;
1715
1716	if (!may_mount())
1717	return -EPERM;
1718
1719	if (!(flags & UMOUNT_NOFOLLOW))
1720	lookup_flags |= LOOKUP_FOLLOW;
1721
1722	retval = user_path_mountpoint_at(AT_FDCWD, name, lookup_flags, &path);
1723	if (retval)
1724	goto out;
1725	mnt = real_mount(path.mnt);
1726	retval = -EINVAL;
1727	if (path.dentry != path.mnt->mnt_root)
1728	goto dput_and_out;
1729	if (!check_mnt(mnt))
1730	goto dput_and_out;
1731	if (mnt->mnt.mnt_flags & MNT_LOCKED) /* Check optimistically */
1732	goto dput_and_out;
1733	retval = -EPERM;
1734	if (flags & MNT_FORCE && !capable(CAP_SYS_ADMIN))
1735	goto dput_and_out;
1736
1737	retval = do_umount(mnt, flags);
1738	dput_and_out:
1739	/* we mustn't call path_put() as that would clear mnt_expiry_mark */
1740	dput(path.dentry);
1741	mntput_no_expire(mnt);
1742	out:
1743	return retval;
1744	}
1745
1746	#ifdef __ARCH_WANT_SYS_OLDUMOUNT
1747
1748	/*
1749	* The 2.0 compatible umount. No flags.
1750	*/
1751	SYSCALL_DEFINE1(oldumount, char __user *, name)
1752	{
1753	return sys_umount(name, 0);
1754	}
1755
1756	#endif
1757
1758	static bool is_mnt_ns_file(struct dentry *dentry)
1759	{
1760	/* Is this a proxy for a mount namespace? */
1761	return dentry->d_op == &ns_dentry_operations &&
1762	dentry->d_fsdata == &mntns_operations;
1763	}
1764
1765	struct mnt_namespace *to_mnt_ns(struct ns_common *ns)
1766	{
1767	return container_of(ns, struct mnt_namespace, ns);
1768	}
1769
1770	static bool mnt_ns_loop(struct dentry *dentry)
1771	{
1772	/* Could bind mounting the mount namespace inode cause a
1773	* mount namespace loop?
1774	*/
1775	struct mnt_namespace *mnt_ns;
1776	if (!is_mnt_ns_file(dentry))
1777	return false;
1778
1779	mnt_ns = to_mnt_ns(get_proc_ns(dentry->d_inode));
1780	return current->nsproxy->mnt_ns->seq >= mnt_ns->seq;
1781	}
1782
1783	struct mount *copy_tree(struct mount *mnt, struct dentry *dentry,
1784	int flag)
1785	{
1786	struct mount *res, *p, *q, *r, *parent;
1787
1788	if (!(flag & CL_COPY_UNBINDABLE) && IS_MNT_UNBINDABLE(mnt))
1789	return ERR_PTR(-EINVAL);
1790
1791	if (!(flag & CL_COPY_MNT_NS_FILE) && is_mnt_ns_file(dentry))
1792	return ERR_PTR(-EINVAL);
1793
1794	res = q = clone_mnt(mnt, dentry, flag);
1795	if (IS_ERR(q))
1796	return q;
1797
1798	q->mnt_mountpoint = mnt->mnt_mountpoint;
1799
1800	p = mnt;
1801	list_for_each_entry(r, &mnt->mnt_mounts, mnt_child) {
1802	struct mount *s;
1803	if (!is_subdir(r->mnt_mountpoint, dentry))
1804	continue;
1805
1806	for (s = r; s; s = next_mnt(s, r)) {
1807	if (!(flag & CL_COPY_UNBINDABLE) &&
1808	IS_MNT_UNBINDABLE(s)) {
1809	if (s->mnt.mnt_flags & MNT_LOCKED) {
1810	/* Both unbindable and locked. */
1811	q = ERR_PTR(-EPERM);
1812	goto out;
1813	} else {
1814	s = skip_mnt_tree(s);
1815	continue;
1816	}
1817	}
1818	if (!(flag & CL_COPY_MNT_NS_FILE) &&
1819	is_mnt_ns_file(s->mnt.mnt_root)) {
1820	s = skip_mnt_tree(s);
1821	continue;
1822	}
1823	while (p != s->mnt_parent) {
1824	p = p->mnt_parent;
1825	q = q->mnt_parent;
1826	}
1827	p = s;
1828	parent = q;
1829	q = clone_mnt(p, p->mnt.mnt_root, flag);
1830	if (IS_ERR(q))
1831	goto out;
1832	lock_mount_hash();
1833	list_add_tail(&q->mnt_list, &res->mnt_list);
1834	attach_mnt(q, parent, p->mnt_mp);
1835	unlock_mount_hash();
1836	}
1837	}
1838	return res;
1839	out:
1840	if (res) {
1841	lock_mount_hash();
1842	umount_tree(res, UMOUNT_SYNC);
1843	unlock_mount_hash();
1844	}
1845	return q;
1846	}
1847
1848	/* Caller should check returned pointer for errors */
1849
1850	struct vfsmount *collect_mounts(struct path *path)
1851	{
1852	struct mount *tree;
1853	namespace_lock();
1854	if (!check_mnt(real_mount(path->mnt)))
1855	tree = ERR_PTR(-EINVAL);
1856	else
1857	tree = copy_tree(real_mount(path->mnt), path->dentry,
1858	CL_COPY_ALL | CL_PRIVATE);
1859	namespace_unlock();
1860	if (IS_ERR(tree))
1861	return ERR_CAST(tree);
1862	return &tree->mnt;
1863	}
1864
1865	void drop_collected_mounts(struct vfsmount *mnt)
1866	{
1867	namespace_lock();
1868	lock_mount_hash();
1869	umount_tree(real_mount(mnt), 0);
1870	unlock_mount_hash();
1871	namespace_unlock();
1872	}
1873
1874	/**
1875	* clone_private_mount - create a private clone of a path
1876	*
1877	* This creates a new vfsmount, which will be the clone of @path. The new will
1878	* not be attached anywhere in the namespace and will be private (i.e. changes
1879	* to the originating mount won't be propagated into this).
1880	*
1881	* Release with mntput().
1882	*/
1883	struct vfsmount *clone_private_mount(struct path *path)
1884	{
1885	struct mount *old_mnt = real_mount(path->mnt);
1886	struct mount *new_mnt;
1887
1888	if (IS_MNT_UNBINDABLE(old_mnt))
1889	return ERR_PTR(-EINVAL);
1890
1891	down_read(&namespace_sem);
1892	new_mnt = clone_mnt(old_mnt, path->dentry, CL_PRIVATE);
1893	up_read(&namespace_sem);
1894	if (IS_ERR(new_mnt))
1895	return ERR_CAST(new_mnt);
1896
1897	return &new_mnt->mnt;
1898	}
1899	EXPORT_SYMBOL_GPL(clone_private_mount);
1900
1901	int iterate_mounts(int (*f)(struct vfsmount *, void *), void *arg,
1902	struct vfsmount *root)
1903	{
1904	struct mount *mnt;
1905	int res = f(root, arg);
1906	if (res)
1907	return res;
1908	list_for_each_entry(mnt, &real_mount(root)->mnt_list, mnt_list) {
1909	res = f(&mnt->mnt, arg);
1910	if (res)
1911	return res;
1912	}
1913	return 0;
1914	}
1915
1916	static void cleanup_group_ids(struct mount *mnt, struct mount *end)
1917	{
1918	struct mount *p;
1919
1920	for (p = mnt; p != end; p = next_mnt(p, mnt)) {
1921	if (p->mnt_group_id && !IS_MNT_SHARED(p))
1922	mnt_release_group_id(p);
1923	}
1924	}
1925
1926	static int invent_group_ids(struct mount *mnt, bool recurse)
1927	{
1928	struct mount *p;
1929
1930	for (p = mnt; p; p = recurse ? next_mnt(p, mnt) : NULL) {
1931	if (!p->mnt_group_id && !IS_MNT_SHARED(p)) {
1932	int err = mnt_alloc_group_id(p);
1933	if (err) {
1934	cleanup_group_ids(mnt, p);
1935	return err;
1936	}
1937	}
1938	}
1939
1940	return 0;
1941	}
1942
1943	int count_mounts(struct mnt_namespace *ns, struct mount *mnt)
1944	{
1945	unsigned int max = READ_ONCE(sysctl_mount_max);
1946	unsigned int mounts = 0, old, pending, sum;
1947	struct mount *p;
1948
1949	for (p = mnt; p; p = next_mnt(p, mnt))
1950	mounts++;
1951
1952	old = ns->mounts;
1953	pending = ns->pending_mounts;
1954	sum = old + pending;
1955	if ((old > sum) ||
1956	(pending > sum) ||
1957	(max < sum) ||
1958	(mounts > (max - sum)))
1959	return -ENOSPC;
1960
1961	ns->pending_mounts = pending + mounts;
1962	return 0;
1963	}
1964
1965	/*
1966	* @source_mnt : mount tree to be attached
1967	* @nd : place the mount tree @source_mnt is attached
1968	* @parent_nd : if non-null, detach the source_mnt from its parent and
1969	* store the parent mount and mountpoint dentry.
1970	* (done when source_mnt is moved)
1971	*
1972	* NOTE: in the table below explains the semantics when a source mount
1973	* of a given type is attached to a destination mount of a given type.
1974	* ---------------------------------------------------------------------------
1975	* | BIND MOUNT OPERATION |
1976	* |**************************************************************************
1977	* | source-->| shared | private | slave | unbindable |
1978	* | dest | | | | |
1979	* | | | | | | |
1980	* | v | | | | |
1981	* |**************************************************************************
1982	* | shared | shared (++) | shared (+) | shared(+++)| invalid |
1983	* | | | | | |
1984	* |non-shared| shared (+) | private | slave (*) | invalid |
1985	* ***************************************************************************
1986	* A bind operation clones the source mount and mounts the clone on the
1987	* destination mount.
1988	*
1989	* (++) the cloned mount is propagated to all the mounts in the propagation
1990	* tree of the destination mount and the cloned mount is added to
1991	* the peer group of the source mount.
1992	* (+) the cloned mount is created under the destination mount and is marked
1993	* as shared. The cloned mount is added to the peer group of the source
1994	* mount.
1995	* (+++) the mount is propagated to all the mounts in the propagation tree
1996	* of the destination mount and the cloned mount is made slave
1997	* of the same master as that of the source mount. The cloned mount
1998	* is marked as 'shared and slave'.
1999	* (*) the cloned mount is made a slave of the same master as that of the
2000	* source mount.
2001	*
2002	* ---------------------------------------------------------------------------
2003	* | MOVE MOUNT OPERATION |
2004	* |**************************************************************************
2005	* | source-->| shared | private | slave | unbindable |
2006	* | dest | | | | |
2007	* | | | | | | |
2008	* | v | | | | |
2009	* |**************************************************************************
2010	* | shared | shared (+) | shared (+) | shared(+++) | invalid |
2011	* | | | | | |
2012	* |non-shared| shared (+*) | private | slave (*) | unbindable |
2013	* ***************************************************************************
2014	*
2015	* (+) the mount is moved to the destination. And is then propagated to
2016	* all the mounts in the propagation tree of the destination mount.
2017	* (+*) the mount is moved to the destination.
2018	* (+++) the mount is moved to the destination and is then propagated to
2019	* all the mounts belonging to the destination mount's propagation tree.
2020	* the mount is marked as 'shared and slave'.
2021	* (*) the mount continues to be a slave at the new location.
2022	*
2023	* if the source mount is a tree, the operations explained above is
2024	* applied to each mount in the tree.
2025	* Must be called without spinlocks held, since this function can sleep
2026	* in allocations.
2027	*/
2028	static int attach_recursive_mnt(struct mount *source_mnt,
2029	struct mount *dest_mnt,
2030	struct mountpoint *dest_mp,
2031	struct path *parent_path)
2032	{
2033	HLIST_HEAD(tree_list);
2034	struct mnt_namespace *ns = dest_mnt->mnt_ns;
2035	struct mountpoint *smp;
2036	struct mount *child, *p;
2037	struct hlist_node *n;
2038	int err;
2039
2040	/* Preallocate a mountpoint in case the new mounts need
2041	* to be tucked under other mounts.
2042	*/
2043	smp = get_mountpoint(source_mnt->mnt.mnt_root);
2044	if (IS_ERR(smp))
2045	return PTR_ERR(smp);
2046
2047	/* Is there space to add these mounts to the mount namespace? */
2048	if (!parent_path) {
2049	err = count_mounts(ns, source_mnt);
2050	if (err)
2051	goto out;
2052	}
2053
2054	if (IS_MNT_SHARED(dest_mnt)) {
2055	err = invent_group_ids(source_mnt, true);
2056	if (err)
2057	goto out;
2058	err = propagate_mnt(dest_mnt, dest_mp, source_mnt, &tree_list);
2059	lock_mount_hash();
2060	if (err)
2061	goto out_cleanup_ids;
2062	for (p = source_mnt; p; p = next_mnt(p, source_mnt))
2063	set_mnt_shared(p);
2064	} else {
2065	lock_mount_hash();
2066	}
2067	if (parent_path) {
2068	detach_mnt(source_mnt, parent_path);
2069	attach_mnt(source_mnt, dest_mnt, dest_mp);
2070	touch_mnt_namespace(source_mnt->mnt_ns);
2071	} else {
2072	mnt_set_mountpoint(dest_mnt, dest_mp, source_mnt);
2073	commit_tree(source_mnt);
2074	}
2075
2076	hlist_for_each_entry_safe(child, n, &tree_list, mnt_hash) {
2077	struct mount *q;
2078	hlist_del_init(&child->mnt_hash);
2079	q = __lookup_mnt(&child->mnt_parent->mnt,
2080	child->mnt_mountpoint);
2081	if (q)
2082	mnt_change_mountpoint(child, smp, q);
2083	commit_tree(child);
2084	}
2085	put_mountpoint(smp);
2086	unlock_mount_hash();
2087
2088	return 0;
2089
2090	out_cleanup_ids:
2091	while (!hlist_empty(&tree_list)) {
2092	child = hlist_entry(tree_list.first, struct mount, mnt_hash);
2093	child->mnt_parent->mnt_ns->pending_mounts = 0;
2094	umount_tree(child, UMOUNT_SYNC);
2095	}
2096	unlock_mount_hash();
2097	cleanup_group_ids(source_mnt, NULL);
2098	out:
2099	ns->pending_mounts = 0;
2100
2101	read_seqlock_excl(&mount_lock);
2102	put_mountpoint(smp);
2103	read_sequnlock_excl(&mount_lock);
2104
2105	return err;
2106	}
2107
2108	static struct mountpoint *lock_mount(struct path *path)
2109	{
2110	struct vfsmount *mnt;
2111	struct dentry *dentry = path->dentry;
2112	retry:
2113	inode_lock(dentry->d_inode);
2114	if (unlikely(cant_mount(dentry))) {
2115	inode_unlock(dentry->d_inode);
2116	return ERR_PTR(-ENOENT);
2117	}
2118	namespace_lock();
2119	mnt = lookup_mnt(path);
2120	if (likely(!mnt)) {
2121	struct mountpoint *mp = get_mountpoint(dentry);
2122	if (IS_ERR(mp)) {
2123	namespace_unlock();
2124	inode_unlock(dentry->d_inode);
2125	return mp;
2126	}
2127	return mp;
2128	}
2129	namespace_unlock();
2130	inode_unlock(path->dentry->d_inode);
2131	path_put(path);
2132	path->mnt = mnt;
2133	dentry = path->dentry = dget(mnt->mnt_root);
2134	goto retry;
2135	}
2136
2137	static void unlock_mount(struct mountpoint *where)
2138	{
2139	struct dentry *dentry = where->m_dentry;
2140
2141	read_seqlock_excl(&mount_lock);
2142	put_mountpoint(where);
2143	read_sequnlock_excl(&mount_lock);
2144
2145	namespace_unlock();
2146	inode_unlock(dentry->d_inode);
2147	}
2148
2149	static int graft_tree(struct mount *mnt, struct mount *p, struct mountpoint *mp)
2150	{
2151	if (mnt->mnt.mnt_sb->s_flags & MS_NOUSER)
2152	return -EINVAL;
2153
2154	if (d_is_dir(mp->m_dentry) !=
2155	d_is_dir(mnt->mnt.mnt_root))
2156	return -ENOTDIR;
2157
2158	return attach_recursive_mnt(mnt, p, mp, NULL);
2159	}
2160
2161	/*
2162	* Sanity check the flags to change_mnt_propagation.
2163	*/
2164
2165	static int flags_to_propagation_type(int flags)
2166	{
2167	int type = flags & ~(MS_REC | MS_SILENT);
2168
2169	/* Fail if any non-propagation flags are set */
2170	if (type & ~(MS_SHARED | MS_PRIVATE | MS_SLAVE | MS_UNBINDABLE))
2171	return 0;
2172	/* Only one propagation flag should be set */
2173	if (!is_power_of_2(type))
2174	return 0;
2175	return type;
2176	}
2177
2178	/*
2179	* recursively change the type of the mountpoint.
2180	*/
2181	static int do_change_type(struct path *path, int flag)
2182	{
2183	struct mount *m;
2184	struct mount *mnt = real_mount(path->mnt);
2185	int recurse = flag & MS_REC;
2186	int type;
2187	int err = 0;
2188
2189	if (path->dentry != path->mnt->mnt_root)
2190	return -EINVAL;
2191
2192	type = flags_to_propagation_type(flag);
2193	if (!type)
2194	return -EINVAL;
2195
2196	namespace_lock();
2197	if (type == MS_SHARED) {
2198	err = invent_group_ids(mnt, recurse);
2199	if (err)
2200	goto out_unlock;
2201	}
2202
2203	lock_mount_hash();
2204	for (m = mnt; m; m = (recurse ? next_mnt(m, mnt) : NULL))
2205	change_mnt_propagation(m, type);
2206	unlock_mount_hash();
2207
2208	out_unlock:
2209	namespace_unlock();
2210	return err;
2211	}
2212
2213	static bool has_locked_children(struct mount *mnt, struct dentry *dentry)
2214	{
2215	struct mount *child;
2216	list_for_each_entry(child, &mnt->mnt_mounts, mnt_child) {
2217	if (!is_subdir(child->mnt_mountpoint, dentry))
2218	continue;
2219
2220	if (child->mnt.mnt_flags & MNT_LOCKED)
2221	return true;
2222	}
2223	return false;
2224	}
2225
2226	/*
2227	* do loopback mount.
2228	*/
2229	static int do_loopback(struct path *path, const char *old_name,
2230	int recurse)
2231	{
2232	struct path old_path;
2233	struct mount *mnt = NULL, *old, *parent;
2234	struct mountpoint *mp;
2235	int err;
2236	if (!old_name || !*old_name)
2237	return -EINVAL;
2238	err = kern_path(old_name, LOOKUP_FOLLOW|LOOKUP_AUTOMOUNT, &old_path);
2239	if (err)
2240	return err;
2241
2242	err = -EINVAL;
2243	if (mnt_ns_loop(old_path.dentry))
2244	goto out;
2245
2246	mp = lock_mount(path);
2247	err = PTR_ERR(mp);
2248	if (IS_ERR(mp))
2249	goto out;
2250
2251	old = real_mount(old_path.mnt);
2252	parent = real_mount(path->mnt);
2253
2254	err = -EINVAL;
2255	if (IS_MNT_UNBINDABLE(old))
2256	goto out2;
2257
2258	if (!check_mnt(parent))
2259	goto out2;
2260
2261	if (!check_mnt(old) && old_path.dentry->d_op != &ns_dentry_operations)
2262	goto out2;
2263
2264	if (!recurse && has_locked_children(old, old_path.dentry))
2265	goto out2;
2266
2267	if (recurse)
2268	mnt = copy_tree(old, old_path.dentry, CL_COPY_MNT_NS_FILE);
2269	else
2270	mnt = clone_mnt(old, old_path.dentry, 0);
2271
2272	if (IS_ERR(mnt)) {
2273	err = PTR_ERR(mnt);
2274	goto out2;
2275	}
2276
2277	mnt->mnt.mnt_flags &= ~MNT_LOCKED;
2278
2279	err = graft_tree(mnt, parent, mp);
2280	if (err) {
2281	lock_mount_hash();
2282	umount_tree(mnt, UMOUNT_SYNC);
2283	unlock_mount_hash();
2284	}
2285	out2:
2286	unlock_mount(mp);
2287	out:
2288	path_put(&old_path);
2289	return err;
2290	}
2291
2292	static int change_mount_flags(struct vfsmount *mnt, int ms_flags)
2293	{
2294	int error = 0;
2295	int readonly_request = 0;
2296
2297	if (ms_flags & MS_RDONLY)
2298	readonly_request = 1;
2299	if (readonly_request == __mnt_is_readonly(mnt))
2300	return 0;
2301
2302	if (readonly_request)
2303	error = mnt_make_readonly(real_mount(mnt));
2304	else
2305	__mnt_unmake_readonly(real_mount(mnt));
2306	return error;
2307	}
2308
2309	/*
2310	* change filesystem flags. dir should be a physical root of filesystem.
2311	* If you've mounted a non-root directory somewhere and want to do remount
2312	* on it - tough luck.
2313	*/
2314	static int do_remount(struct path *path, int flags, int mnt_flags,
2315	void *data)
2316	{
2317	int err;
2318	struct super_block *sb = path->mnt->mnt_sb;
2319	struct mount *mnt = real_mount(path->mnt);
2320
2321	if (!check_mnt(mnt))
2322	return -EINVAL;
2323
2324	if (path->dentry != path->mnt->mnt_root)
2325	return -EINVAL;
2326
2327	/* Don't allow changing of locked mnt flags.
2328	*
2329	* No locks need to be held here while testing the various
2330	* MNT_LOCK flags because those flags can never be cleared
2331	* once they are set.
2332	*/
2333	if ((mnt->mnt.mnt_flags & MNT_LOCK_READONLY) &&
2334	!(mnt_flags & MNT_READONLY)) {
2335	return -EPERM;
2336	}
2337	if ((mnt->mnt.mnt_flags & MNT_LOCK_NODEV) &&
2338	!(mnt_flags & MNT_NODEV)) {
2339	return -EPERM;
2340	}
2341	if ((mnt->mnt.mnt_flags & MNT_LOCK_NOSUID) &&
2342	!(mnt_flags & MNT_NOSUID)) {
2343	return -EPERM;
2344	}
2345	if ((mnt->mnt.mnt_flags & MNT_LOCK_NOEXEC) &&
2346	!(mnt_flags & MNT_NOEXEC)) {
2347	return -EPERM;
2348	}
2349	if ((mnt->mnt.mnt_flags & MNT_LOCK_ATIME) &&
2350	((mnt->mnt.mnt_flags & MNT_ATIME_MASK) != (mnt_flags & MNT_ATIME_MASK))) {
2351	return -EPERM;
2352	}
2353
2354	err = security_sb_remount(sb, data);
2355	if (err)
2356	return err;
2357
2358	down_write(&sb->s_umount);
2359	if (flags & MS_BIND)
2360	err = change_mount_flags(path->mnt, flags);
2361	else if (!capable(CAP_SYS_ADMIN))
2362	err = -EPERM;
2363	else {
2364	err = do_remount_sb2(path->mnt, sb, flags, data, 0);
2365	namespace_lock();
2366	lock_mount_hash();
2367	propagate_remount(mnt);
2368	unlock_mount_hash();
2369	namespace_unlock();
2370	}
2371	if (!err) {
2372	lock_mount_hash();
2373	mnt_flags |= mnt->mnt.mnt_flags & ~MNT_USER_SETTABLE_MASK;
2374	mnt->mnt.mnt_flags = mnt_flags;
2375	touch_mnt_namespace(mnt->mnt_ns);
2376	unlock_mount_hash();
2377	}
2378	up_write(&sb->s_umount);
2379	return err;
2380	}
2381
2382	static inline int tree_contains_unbindable(struct mount *mnt)
2383	{
2384	struct mount *p;
2385	for (p = mnt; p; p = next_mnt(p, mnt)) {
2386	if (IS_MNT_UNBINDABLE(p))
2387	return 1;
2388	}
2389	return 0;
2390	}
2391
2392	static int do_move_mount(struct path *path, const char *old_name)
2393	{
2394	struct path old_path, parent_path;
2395	struct mount *p;
2396	struct mount *old;
2397	struct mountpoint *mp;
2398	int err;
2399	if (!old_name || !*old_name)
2400	return -EINVAL;
2401	err = kern_path(old_name, LOOKUP_FOLLOW, &old_path);
2402	if (err)
2403	return err;
2404
2405	mp = lock_mount(path);
2406	err = PTR_ERR(mp);
2407	if (IS_ERR(mp))
2408	goto out;
2409
2410	old = real_mount(old_path.mnt);
2411	p = real_mount(path->mnt);
2412
2413	err = -EINVAL;
2414	if (!check_mnt(p) || !check_mnt(old))
2415	goto out1;
2416
2417	if (old->mnt.mnt_flags & MNT_LOCKED)
2418	goto out1;
2419
2420	err = -EINVAL;
2421	if (old_path.dentry != old_path.mnt->mnt_root)
2422	goto out1;
2423
2424	if (!mnt_has_parent(old))
2425	goto out1;
2426
2427	if (d_is_dir(path->dentry) !=
2428	d_is_dir(old_path.dentry))
2429	goto out1;
2430	/*
2431	* Don't move a mount residing in a shared parent.
2432	*/
2433	if (IS_MNT_SHARED(old->mnt_parent))
2434	goto out1;
2435	/*
2436	* Don't move a mount tree containing unbindable mounts to a destination
2437	* mount which is shared.
2438	*/
2439	if (IS_MNT_SHARED(p) && tree_contains_unbindable(old))
2440	goto out1;
2441	err = -ELOOP;
2442	for (; mnt_has_parent(p); p = p->mnt_parent)
2443	if (p == old)
2444	goto out1;
2445
2446	err = attach_recursive_mnt(old, real_mount(path->mnt), mp, &parent_path);
2447	if (err)
2448	goto out1;
2449
2450	/* if the mount is moved, it should no longer be expire
2451	* automatically */
2452	list_del_init(&old->mnt_expire);
2453	out1:
2454	unlock_mount(mp);
2455	out:
2456	if (!err)
2457	path_put(&parent_path);
2458	path_put(&old_path);
2459	return err;
2460	}
2461
2462	static struct vfsmount *fs_set_subtype(struct vfsmount *mnt, const char *fstype)
2463	{
2464	int err;
2465	const char *subtype = strchr(fstype, '.');
2466	if (subtype) {
2467	subtype++;
2468	err = -EINVAL;
2469	if (!subtype[0])
2470	goto err;
2471	} else
2472	subtype = "";
2473
2474	mnt->mnt_sb->s_subtype = kstrdup(subtype, GFP_KERNEL);
2475	err = -ENOMEM;
2476	if (!mnt->mnt_sb->s_subtype)
2477	goto err;
2478	return mnt;
2479
2480	err:
2481	mntput(mnt);
2482	return ERR_PTR(err);
2483	}
2484
2485	/*
2486	* add a mount into a namespace's mount tree
2487	*/
2488	static int do_add_mount(struct mount *newmnt, struct path *path, int mnt_flags)
2489	{
2490	struct mountpoint *mp;
2491	struct mount *parent;
2492	int err;
2493
2494	mnt_flags &= ~MNT_INTERNAL_FLAGS;
2495
2496	mp = lock_mount(path);
2497	if (IS_ERR(mp))
2498	return PTR_ERR(mp);
2499
2500	parent = real_mount(path->mnt);
2501	err = -EINVAL;
2502	if (unlikely(!check_mnt(parent))) {
2503	/* that's acceptable only for automounts done in private ns */
2504	if (!(mnt_flags & MNT_SHRINKABLE))
2505	goto unlock;
2506	/* ... and for those we'd better have mountpoint still alive */
2507	if (!parent->mnt_ns)
2508	goto unlock;
2509	}
2510
2511	/* Refuse the same filesystem on the same mount point */
2512	err = -EBUSY;
2513	if (path->mnt->mnt_sb == newmnt->mnt.mnt_sb &&
2514	path->mnt->mnt_root == path->dentry)
2515	goto unlock;
2516
2517	err = -EINVAL;
2518	if (d_is_symlink(newmnt->mnt.mnt_root))
2519	goto unlock;
2520
2521	newmnt->mnt.mnt_flags = mnt_flags;
2522	err = graft_tree(newmnt, parent, mp);
2523
2524	unlock:
2525	unlock_mount(mp);
2526	return err;
2527	}
2528
2529	static bool mount_too_revealing(struct vfsmount *mnt, int *new_mnt_flags);
2530
2531	/*
2532	* create a new mount for userspace and request it to be added into the
2533	* namespace's tree
2534	*/
2535	static int do_new_mount(struct path *path, const char *fstype, int flags,
2536	int mnt_flags, const char *name, void *data)
2537	{
2538	struct file_system_type *type;
2539	struct vfsmount *mnt;
2540	int err;
2541
2542	if (!fstype)
2543	return -EINVAL;
2544
2545	type = get_fs_type(fstype);
2546	if (!type)
2547	return -ENODEV;
2548
2549	mnt = vfs_kern_mount(type, flags, name, data);
2550	if (!IS_ERR(mnt) && (type->fs_flags & FS_HAS_SUBTYPE) &&
2551	!mnt->mnt_sb->s_subtype)
2552	mnt = fs_set_subtype(mnt, fstype);
2553
2554	put_filesystem(type);
2555	if (IS_ERR(mnt))
2556	return PTR_ERR(mnt);
2557
2558	if (mount_too_revealing(mnt, &mnt_flags)) {
2559	mntput(mnt);
2560	return -EPERM;
2561	}
2562
2563	err = do_add_mount(real_mount(mnt), path, mnt_flags);
2564	if (err)
2565	mntput(mnt);
2566	return err;
2567	}
2568
2569	int finish_automount(struct vfsmount *m, struct path *path)
2570	{
2571	struct mount *mnt = real_mount(m);
2572	int err;
2573	/* The new mount record should have at least 2 refs to prevent it being
2574	* expired before we get a chance to add it
2575	*/
2576	BUG_ON(mnt_get_count(mnt) < 2);
2577
2578	if (m->mnt_sb == path->mnt->mnt_sb &&
2579	m->mnt_root == path->dentry) {
2580	err = -ELOOP;
2581	goto fail;
2582	}
2583
2584	err = do_add_mount(mnt, path, path->mnt->mnt_flags | MNT_SHRINKABLE);
2585	if (!err)
2586	return 0;
2587	fail:
2588	/* remove m from any expiration list it may be on */
2589	if (!list_empty(&mnt->mnt_expire)) {
2590	namespace_lock();
2591	list_del_init(&mnt->mnt_expire);
2592	namespace_unlock();
2593	}
2594	mntput(m);
2595	mntput(m);
2596	return err;
2597	}
2598
2599	/**
2600	* mnt_set_expiry - Put a mount on an expiration list
2601	* @mnt: The mount to list.
2602	* @expiry_list: The list to add the mount to.
2603	*/
2604	void mnt_set_expiry(struct vfsmount *mnt, struct list_head *expiry_list)
2605	{
2606	namespace_lock();
2607
2608	list_add_tail(&real_mount(mnt)->mnt_expire, expiry_list);
2609
2610	namespace_unlock();
2611	}
2612	EXPORT_SYMBOL(mnt_set_expiry);
2613
2614	/*
2615	* process a list of expirable mountpoints with the intent of discarding any
2616	* mountpoints that aren't in use and haven't been touched since last we came
2617	* here
2618	*/
2619	void mark_mounts_for_expiry(struct list_head *mounts)
2620	{
2621	struct mount *mnt, *next;
2622	LIST_HEAD(graveyard);
2623
2624	if (list_empty(mounts))
2625	return;
2626
2627	namespace_lock();
2628	lock_mount_hash();
2629
2630	/* extract from the expiration list every vfsmount that matches the
2631	* following criteria:
2632	* - only referenced by its parent vfsmount
2633	* - still marked for expiry (marked on the last call here; marks are
2634	* cleared by mntput())
2635	*/
2636	list_for_each_entry_safe(mnt, next, mounts, mnt_expire) {
2637	if (!xchg(&mnt->mnt_expiry_mark, 1) ||
2638	propagate_mount_busy(mnt, 1))
2639	continue;
2640	list_move(&mnt->mnt_expire, &graveyard);
2641	}
2642	while (!list_empty(&graveyard)) {
2643	mnt = list_first_entry(&graveyard, struct mount, mnt_expire);
2644	touch_mnt_namespace(mnt->mnt_ns);
2645	umount_tree(mnt, UMOUNT_PROPAGATE|UMOUNT_SYNC);
2646	}
2647	unlock_mount_hash();
2648	namespace_unlock();
2649	}
2650
2651	EXPORT_SYMBOL_GPL(mark_mounts_for_expiry);
2652
2653	/*
2654	* Ripoff of 'select_parent()'
2655	*
2656	* search the list of submounts for a given mountpoint, and move any
2657	* shrinkable submounts to the 'graveyard' list.
2658	*/
2659	static int select_submounts(struct mount *parent, struct list_head *graveyard)
2660	{
2661	struct mount *this_parent = parent;
2662	struct list_head *next;
2663	int found = 0;
2664
2665	repeat:
2666	next = this_parent->mnt_mounts.next;
2667	resume:
2668	while (next != &this_parent->mnt_mounts) {
2669	struct list_head *tmp = next;
2670	struct mount *mnt = list_entry(tmp, struct mount, mnt_child);
2671
2672	next = tmp->next;
2673	if (!(mnt->mnt.mnt_flags & MNT_SHRINKABLE))
2674	continue;
2675	/*
2676	* Descend a level if the d_mounts list is non-empty.
2677	*/
2678	if (!list_empty(&mnt->mnt_mounts)) {
2679	this_parent = mnt;
2680	goto repeat;
2681	}
2682
2683	if (!propagate_mount_busy(mnt, 1)) {
2684	list_move_tail(&mnt->mnt_expire, graveyard);
2685	found++;
2686	}
2687	}
2688	/*
2689	* All done at this level ... ascend and resume the search
2690	*/
2691	if (this_parent != parent) {
2692	next = this_parent->mnt_child.next;
2693	this_parent = this_parent->mnt_parent;
2694	goto resume;
2695	}
2696	return found;
2697	}
2698
2699	/*
2700	* process a list of expirable mountpoints with the intent of discarding any
2701	* submounts of a specific parent mountpoint
2702	*
2703	* mount_lock must be held for write
2704	*/
2705	static void shrink_submounts(struct mount *mnt)
2706	{
2707	LIST_HEAD(graveyard);
2708	struct mount *m;
2709
2710	/* extract submounts of 'mountpoint' from the expiration list */
2711	while (select_submounts(mnt, &graveyard)) {
2712	while (!list_empty(&graveyard)) {
2713	m = list_first_entry(&graveyard, struct mount,
2714	mnt_expire);
2715	touch_mnt_namespace(m->mnt_ns);
2716	umount_tree(m, UMOUNT_PROPAGATE|UMOUNT_SYNC);
2717	}
2718	}
2719	}
2720
2721	/*
2722	* Some copy_from_user() implementations do not return the exact number of
2723	* bytes remaining to copy on a fault. But copy_mount_options() requires that.
2724	* Note that this function differs from copy_from_user() in that it will oops
2725	* on bad values of `to', rather than returning a short copy.
2726	*/
2727	static long exact_copy_from_user(void *to, const void __user * from,
2728	unsigned long n)
2729	{
2730	char *t = to;
2731	const char __user *f = from;
2732	char c;
2733
2734	if (!access_ok(VERIFY_READ, from, n))
2735	return n;
2736
2737	#ifdef CONFIG_AMLOGIC_VMAP
2738	/* addr from kernel space and in vmalloc range, avoid overflow */
2739	if (is_vmalloc_or_module_addr((void *)from)) {
2740	unsigned long old = n;
2741
2742	n = strlen(from) + 1;
2743	pr_info("addr:%p is in kernel, size fix %ld->%ld, data:%s\n",
2744	from, old, n, (char *)from);
2745	}
2746	#endif
2747
2748	while (n) {
2749	if (__get_user(c, f)) {
2750	memset(t, 0, n);
2751	break;
2752	}
2753	*t++ = c;
2754	f++;
2755	n--;
2756	}
2757	return n;
2758	}
2759
2760	void *copy_mount_options(const void __user * data)
2761	{
2762	int i;
2763	unsigned long size;
2764	char *copy;
2765
2766	if (!data)
2767	return NULL;
2768
2769	copy = kmalloc(PAGE_SIZE, GFP_KERNEL);
2770	if (!copy)
2771	return ERR_PTR(-ENOMEM);
2772
2773	/* We only care that *some* data at the address the user
2774	* gave us is valid. Just in case, we'll zero
2775	* the remainder of the page.
2776	*/
2777	/* copy_from_user cannot cross TASK_SIZE ! */
2778	size = TASK_SIZE - (unsigned long)data;
2779	if (size > PAGE_SIZE)
2780	size = PAGE_SIZE;
2781
2782	i = size - exact_copy_from_user(copy, data, size);
2783	if (!i) {
2784	kfree(copy);
2785	return ERR_PTR(-EFAULT);
2786	}
2787	if (i != PAGE_SIZE)
2788	memset(copy + i, 0, PAGE_SIZE - i);
2789	return copy;
2790	}
2791
2792	char *copy_mount_string(const void __user *data)
2793	{
2794	return data ? strndup_user(data, PAGE_SIZE) : NULL;
2795	}
2796
2797	/*
2798	* Flags is a 32-bit value that allows up to 31 non-fs dependent flags to
2799	* be given to the mount() call (ie: read-only, no-dev, no-suid etc).
2800	*
2801	* data is a (void *) that can point to any structure up to
2802	* PAGE_SIZE-1 bytes, which can contain arbitrary fs-dependent
2803	* information (or be NULL).
2804	*
2805	* Pre-0.97 versions of mount() didn't have a flags word.
2806	* When the flags word was introduced its top half was required
2807	* to have the magic value 0xC0ED, and this remained so until 2.4.0-test9.
2808	* Therefore, if this magic number is present, it carries no information
2809	* and must be discarded.
2810	*/
2811	long do_mount(const char *dev_name, const char __user *dir_name,
2812	const char *type_page, unsigned long flags, void *data_page)
2813	{
2814	struct path path;
2815	int retval = 0;
2816	int mnt_flags = 0;
2817
2818	/* Discard magic */
2819	if ((flags & MS_MGC_MSK) == MS_MGC_VAL)
2820	flags &= ~MS_MGC_MSK;
2821
2822	/* Basic sanity checks */
2823	if (data_page)
2824	((char *)data_page)[PAGE_SIZE - 1] = 0;
2825
2826	/* ... and get the mountpoint */
2827	retval = user_path(dir_name, &path);
2828	if (retval)
2829	return retval;
2830
2831	retval = security_sb_mount(dev_name, &path,
2832	type_page, flags, data_page);
2833	if (!retval && !may_mount())
2834	retval = -EPERM;
2835	if (!retval && (flags & MS_MANDLOCK) && !may_mandlock())
2836	retval = -EPERM;
2837	if (retval)
2838	goto dput_out;
2839
2840	/* Default to relatime unless overriden */
2841	if (!(flags & MS_NOATIME))
2842	mnt_flags |= MNT_RELATIME;
2843
2844	/* Separate the per-mountpoint flags */
2845	if (flags & MS_NOSUID)
2846	mnt_flags |= MNT_NOSUID;
2847	if (flags & MS_NODEV)
2848	mnt_flags |= MNT_NODEV;
2849	if (flags & MS_NOEXEC)
2850	mnt_flags |= MNT_NOEXEC;
2851	if (flags & MS_NOATIME)
2852	mnt_flags |= MNT_NOATIME;
2853	if (flags & MS_NODIRATIME)
2854	mnt_flags |= MNT_NODIRATIME;
2855	if (flags & MS_STRICTATIME)
2856	mnt_flags &= ~(MNT_RELATIME | MNT_NOATIME);
2857	if (flags & MS_RDONLY)
2858	mnt_flags |= MNT_READONLY;
2859
2860	/* The default atime for remount is preservation */
2861	if ((flags & MS_REMOUNT) &&
2862	((flags & (MS_NOATIME | MS_NODIRATIME | MS_RELATIME |
2863	MS_STRICTATIME)) == 0)) {
2864	mnt_flags &= ~MNT_ATIME_MASK;
2865	mnt_flags |= path.mnt->mnt_flags & MNT_ATIME_MASK;
2866	}
2867
2868	flags &= ~(MS_NOSUID | MS_NOEXEC | MS_NODEV | MS_ACTIVE | MS_BORN |
2869	MS_NOATIME | MS_NODIRATIME | MS_RELATIME| MS_KERNMOUNT |
2870	MS_STRICTATIME | MS_NOREMOTELOCK | MS_SUBMOUNT);
2871
2872	if (flags & MS_REMOUNT)
2873	retval = do_remount(&path, flags & ~MS_REMOUNT, mnt_flags,
2874	data_page);
2875	else if (flags & MS_BIND)
2876	retval = do_loopback(&path, dev_name, flags & MS_REC);
2877	else if (flags & (MS_SHARED | MS_PRIVATE | MS_SLAVE | MS_UNBINDABLE))
2878	retval = do_change_type(&path, flags);
2879	else if (flags & MS_MOVE)
2880	retval = do_move_mount(&path, dev_name);
2881	else
2882	retval = do_new_mount(&path, type_page, flags, mnt_flags,
2883	dev_name, data_page);
2884	dput_out:
2885	path_put(&path);
2886	return retval;
2887	}
2888
2889	static struct ucounts *inc_mnt_namespaces(struct user_namespace *ns)
2890	{
2891	return inc_ucount(ns, current_euid(), UCOUNT_MNT_NAMESPACES);
2892	}
2893
2894	static void dec_mnt_namespaces(struct ucounts *ucounts)
2895	{
2896	dec_ucount(ucounts, UCOUNT_MNT_NAMESPACES);
2897	}
2898
2899	static void free_mnt_ns(struct mnt_namespace *ns)
2900	{
2901	ns_free_inum(&ns->ns);
2902	dec_mnt_namespaces(ns->ucounts);
2903	put_user_ns(ns->user_ns);
2904	kfree(ns);
2905	}
2906
2907	/*
2908	* Assign a sequence number so we can detect when we attempt to bind
2909	* mount a reference to an older mount namespace into the current
2910	* mount namespace, preventing reference counting loops. A 64bit
2911	* number incrementing at 10Ghz will take 12,427 years to wrap which
2912	* is effectively never, so we can ignore the possibility.
2913	*/
2914	static atomic64_t mnt_ns_seq = ATOMIC64_INIT(1);
2915
2916	static struct mnt_namespace *alloc_mnt_ns(struct user_namespace *user_ns)
2917	{
2918	struct mnt_namespace *new_ns;
2919	struct ucounts *ucounts;
2920	int ret;
2921
2922	ucounts = inc_mnt_namespaces(user_ns);
2923	if (!ucounts)
2924	return ERR_PTR(-ENOSPC);
2925
2926	new_ns = kmalloc(sizeof(struct mnt_namespace), GFP_KERNEL);
2927	if (!new_ns) {
2928	dec_mnt_namespaces(ucounts);
2929	return ERR_PTR(-ENOMEM);
2930	}
2931	ret = ns_alloc_inum(&new_ns->ns);
2932	if (ret) {
2933	kfree(new_ns);
2934	dec_mnt_namespaces(ucounts);
2935	return ERR_PTR(ret);
2936	}
2937	new_ns->ns.ops = &mntns_operations;
2938	new_ns->seq = atomic64_add_return(1, &mnt_ns_seq);
2939	atomic_set(&new_ns->count, 1);
2940	new_ns->root = NULL;
2941	INIT_LIST_HEAD(&new_ns->list);
2942	init_waitqueue_head(&new_ns->poll);
2943	new_ns->event = 0;
2944	new_ns->user_ns = get_user_ns(user_ns);
2945	new_ns->ucounts = ucounts;
2946	new_ns->mounts = 0;
2947	new_ns->pending_mounts = 0;
2948	return new_ns;
2949	}
2950
2951	__latent_entropy
2952	struct mnt_namespace *copy_mnt_ns(unsigned long flags, struct mnt_namespace *ns,
2953	struct user_namespace *user_ns, struct fs_struct *new_fs)
2954	{
2955	struct mnt_namespace *new_ns;
2956	struct vfsmount *rootmnt = NULL, *pwdmnt = NULL;
2957	struct mount *p, *q;
2958	struct mount *old;
2959	struct mount *new;
2960	int copy_flags;
2961
2962	BUG_ON(!ns);
2963
2964	if (likely(!(flags & CLONE_NEWNS))) {
2965	get_mnt_ns(ns);
2966	return ns;
2967	}
2968
2969	old = ns->root;
2970
2971	new_ns = alloc_mnt_ns(user_ns);
2972	if (IS_ERR(new_ns))
2973	return new_ns;
2974
2975	namespace_lock();
2976	/* First pass: copy the tree topology */
2977	copy_flags = CL_COPY_UNBINDABLE | CL_EXPIRE;
2978	if (user_ns != ns->user_ns)
2979	copy_flags |= CL_SHARED_TO_SLAVE | CL_UNPRIVILEGED;
2980	new = copy_tree(old, old->mnt.mnt_root, copy_flags);
2981	if (IS_ERR(new)) {
2982	namespace_unlock();
2983	free_mnt_ns(new_ns);
2984	return ERR_CAST(new);
2985	}
2986	new_ns->root = new;
2987	list_add_tail(&new_ns->list, &new->mnt_list);
2988
2989	/*
2990	* Second pass: switch the tsk->fs->* elements and mark new vfsmounts
2991	* as belonging to new namespace. We have already acquired a private
2992	* fs_struct, so tsk->fs->lock is not needed.
2993	*/
2994	p = old;
2995	q = new;
2996	while (p) {
2997	q->mnt_ns = new_ns;
2998	new_ns->mounts++;
2999	if (new_fs) {
3000	if (&p->mnt == new_fs->root.mnt) {
3001	new_fs->root.mnt = mntget(&q->mnt);
3002	rootmnt = &p->mnt;
3003	}
3004	if (&p->mnt == new_fs->pwd.mnt) {
3005	new_fs->pwd.mnt = mntget(&q->mnt);
3006	pwdmnt = &p->mnt;
3007	}
3008	}
3009	p = next_mnt(p, old);
3010	q = next_mnt(q, new);
3011	if (!q)
3012	break;
3013	while (p->mnt.mnt_root != q->mnt.mnt_root)
3014	p = next_mnt(p, old);
3015	}
3016	namespace_unlock();
3017
3018	if (rootmnt)
3019	mntput(rootmnt);
3020	if (pwdmnt)
3021	mntput(pwdmnt);
3022
3023	return new_ns;
3024	}
3025
3026	/**
3027	* create_mnt_ns - creates a private namespace and adds a root filesystem
3028	* @mnt: pointer to the new root filesystem mountpoint
3029	*/
3030	static struct mnt_namespace *create_mnt_ns(struct vfsmount *m)
3031	{
3032	struct mnt_namespace *new_ns = alloc_mnt_ns(&init_user_ns);
3033	if (!IS_ERR(new_ns)) {
3034	struct mount *mnt = real_mount(m);
3035	mnt->mnt_ns = new_ns;
3036	new_ns->root = mnt;
3037	new_ns->mounts++;
3038	list_add(&mnt->mnt_list, &new_ns->list);
3039	} else {
3040	mntput(m);
3041	}
3042	return new_ns;
3043	}
3044
3045	struct dentry *mount_subtree(struct vfsmount *mnt, const char *name)
3046	{
3047	struct mnt_namespace *ns;
3048	struct super_block *s;
3049	struct path path;
3050	int err;
3051
3052	ns = create_mnt_ns(mnt);
3053	if (IS_ERR(ns))
3054	return ERR_CAST(ns);
3055
3056	err = vfs_path_lookup(mnt->mnt_root, mnt,
3057	name, LOOKUP_FOLLOW|LOOKUP_AUTOMOUNT, &path);
3058
3059	put_mnt_ns(ns);
3060
3061	if (err)
3062	return ERR_PTR(err);
3063
3064	/* trade a vfsmount reference for active sb one */
3065	s = path.mnt->mnt_sb;
3066	atomic_inc(&s->s_active);
3067	mntput(path.mnt);
3068	/* lock the sucker */
3069	down_write(&s->s_umount);
3070	/* ... and return the root of (sub)tree on it */
3071	return path.dentry;
3072	}
3073	EXPORT_SYMBOL(mount_subtree);
3074
3075	SYSCALL_DEFINE5(mount, char __user *, dev_name, char __user *, dir_name,
3076	char __user *, type, unsigned long, flags, void __user *, data)
3077	{
3078	int ret;
3079	char *kernel_type;
3080	char *kernel_dev;
3081	void *options;
3082
3083	kernel_type = copy_mount_string(type);
3084	ret = PTR_ERR(kernel_type);
3085	if (IS_ERR(kernel_type))
3086	goto out_type;
3087
3088	kernel_dev = copy_mount_string(dev_name);
3089	ret = PTR_ERR(kernel_dev);
3090	if (IS_ERR(kernel_dev))
3091	goto out_dev;
3092
3093	options = copy_mount_options(data);
3094	ret = PTR_ERR(options);
3095	if (IS_ERR(options))
3096	goto out_data;
3097
3098	ret = do_mount(kernel_dev, dir_name, kernel_type, flags, options);
3099
3100	kfree(options);
3101	out_data:
3102	kfree(kernel_dev);
3103	out_dev:
3104	kfree(kernel_type);
3105	out_type:
3106	return ret;
3107	}
3108
3109	/*
3110	* Return true if path is reachable from root
3111	*
3112	* namespace_sem or mount_lock is held
3113	*/
3114	bool is_path_reachable(struct mount *mnt, struct dentry *dentry,
3115	const struct path *root)
3116	{
3117	while (&mnt->mnt != root->mnt && mnt_has_parent(mnt)) {
3118	dentry = mnt->mnt_mountpoint;
3119	mnt = mnt->mnt_parent;
3120	}
3121	return &mnt->mnt == root->mnt && is_subdir(dentry, root->dentry);
3122	}
3123
3124	bool path_is_under(struct path *path1, struct path *path2)
3125	{
3126	bool res;
3127	read_seqlock_excl(&mount_lock);
3128	res = is_path_reachable(real_mount(path1->mnt), path1->dentry, path2);
3129	read_sequnlock_excl(&mount_lock);
3130	return res;
3131	}
3132	EXPORT_SYMBOL(path_is_under);
3133
3134	/*
3135	* pivot_root Semantics:
3136	* Moves the root file system of the current process to the directory put_old,
3137	* makes new_root as the new root file system of the current process, and sets
3138	* root/cwd of all processes which had them on the current root to new_root.
3139	*
3140	* Restrictions:
3141	* The new_root and put_old must be directories, and must not be on the
3142	* same file system as the current process root. The put_old must be
3143	* underneath new_root, i.e. adding a non-zero number of /.. to the string
3144	* pointed to by put_old must yield the same directory as new_root. No other
3145	* file system may be mounted on put_old. After all, new_root is a mountpoint.
3146	*
3147	* Also, the current root cannot be on the 'rootfs' (initial ramfs) filesystem.
3148	* See Documentation/filesystems/ramfs-rootfs-initramfs.txt for alternatives
3149	* in this situation.
3150	*
3151	* Notes:
3152	* - we don't move root/cwd if they are not at the root (reason: if something
3153	* cared enough to change them, it's probably wrong to force them elsewhere)
3154	* - it's okay to pick a root that isn't the root of a file system, e.g.
3155	* /nfs/my_root where /nfs is the mount point. It must be a mountpoint,
3156	* though, so you may need to say mount --bind /nfs/my_root /nfs/my_root
3157	* first.
3158	*/
3159	SYSCALL_DEFINE2(pivot_root, const char __user *, new_root,
3160	const char __user *, put_old)
3161	{
3162	struct path new, old, parent_path, root_parent, root;
3163	struct mount *new_mnt, *root_mnt, *old_mnt;
3164	struct mountpoint *old_mp, *root_mp;
3165	int error;
3166
3167	if (!may_mount())
3168	return -EPERM;
3169
3170	error = user_path_dir(new_root, &new);
3171	if (error)
3172	goto out0;
3173
3174	error = user_path_dir(put_old, &old);
3175	if (error)
3176	goto out1;
3177
3178	error = security_sb_pivotroot(&old, &new);
3179	if (error)
3180	goto out2;
3181
3182	get_fs_root(current->fs, &root);
3183	old_mp = lock_mount(&old);
3184	error = PTR_ERR(old_mp);
3185	if (IS_ERR(old_mp))
3186	goto out3;
3187
3188	error = -EINVAL;
3189	new_mnt = real_mount(new.mnt);
3190	root_mnt = real_mount(root.mnt);
3191	old_mnt = real_mount(old.mnt);
3192	if (IS_MNT_SHARED(old_mnt) ||
3193	IS_MNT_SHARED(new_mnt->mnt_parent) ||
3194	IS_MNT_SHARED(root_mnt->mnt_parent))
3195	goto out4;
3196	if (!check_mnt(root_mnt) || !check_mnt(new_mnt))
3197	goto out4;
3198	if (new_mnt->mnt.mnt_flags & MNT_LOCKED)
3199	goto out4;
3200	error = -ENOENT;
3201	if (d_unlinked(new.dentry))
3202	goto out4;
3203	error = -EBUSY;
3204	if (new_mnt == root_mnt || old_mnt == root_mnt)
3205	goto out4; /* loop, on the same file system */
3206	error = -EINVAL;
3207	if (root.mnt->mnt_root != root.dentry)
3208	goto out4; /* not a mountpoint */
3209	if (!mnt_has_parent(root_mnt))
3210	goto out4; /* not attached */
3211	root_mp = root_mnt->mnt_mp;
3212	if (new.mnt->mnt_root != new.dentry)
3213	goto out4; /* not a mountpoint */
3214	if (!mnt_has_parent(new_mnt))
3215	goto out4; /* not attached */
3216	/* make sure we can reach put_old from new_root */
3217	if (!is_path_reachable(old_mnt, old.dentry, &new))
3218	goto out4;
3219	/* make certain new is below the root */
3220	if (!is_path_reachable(new_mnt, new.dentry, &root))
3221	goto out4;
3222	root_mp->m_count++; /* pin it so it won't go away */
3223	lock_mount_hash();
3224	detach_mnt(new_mnt, &parent_path);
3225	detach_mnt(root_mnt, &root_parent);
3226	if (root_mnt->mnt.mnt_flags & MNT_LOCKED) {
3227	new_mnt->mnt.mnt_flags |= MNT_LOCKED;
3228	root_mnt->mnt.mnt_flags &= ~MNT_LOCKED;
3229	}
3230	/* mount old root on put_old */
3231	attach_mnt(root_mnt, old_mnt, old_mp);
3232	/* mount new_root on / */
3233	attach_mnt(new_mnt, real_mount(root_parent.mnt), root_mp);
3234	touch_mnt_namespace(current->nsproxy->mnt_ns);
3235	/* A moved mount should not expire automatically */
3236	list_del_init(&new_mnt->mnt_expire);
3237	put_mountpoint(root_mp);
3238	unlock_mount_hash();
3239	chroot_fs_refs(&root, &new);
3240	error = 0;
3241	out4:
3242	unlock_mount(old_mp);
3243	if (!error) {
3244	path_put(&root_parent);
3245	path_put(&parent_path);
3246	}
3247	out3:
3248	path_put(&root);
3249	out2:
3250	path_put(&old);
3251	out1:
3252	path_put(&new);
3253	out0:
3254	return error;
3255	}
3256
3257	static void __init init_mount_tree(void)
3258	{
3259	struct vfsmount *mnt;
3260	struct mnt_namespace *ns;
3261	struct path root;
3262	struct file_system_type *type;
3263
3264	type = get_fs_type("rootfs");
3265	if (!type)
3266	panic("Can't find rootfs type");
3267	mnt = vfs_kern_mount(type, 0, "rootfs", NULL);
3268	put_filesystem(type);
3269	if (IS_ERR(mnt))
3270	panic("Can't create rootfs");
3271
3272	ns = create_mnt_ns(mnt);
3273	if (IS_ERR(ns))
3274	panic("Can't allocate initial namespace");
3275
3276	init_task.nsproxy->mnt_ns = ns;
3277	get_mnt_ns(ns);
3278
3279	root.mnt = mnt;
3280	root.dentry = mnt->mnt_root;
3281	mnt->mnt_flags |= MNT_LOCKED;
3282
3283	set_fs_pwd(current->fs, &root);
3284	set_fs_root(current->fs, &root);
3285	}
3286
3287	void __init mnt_init(void)
3288	{
3289	unsigned u;
3290	int err;
3291
3292	mnt_cache = kmem_cache_create("mnt_cache", sizeof(struct mount),
3293	0, SLAB_HWCACHE_ALIGN | SLAB_PANIC, NULL);
3294
3295	mount_hashtable = alloc_large_system_hash("Mount-cache",
3296	sizeof(struct hlist_head),
3297	mhash_entries, 19,
3298	0,
3299	&m_hash_shift, &m_hash_mask, 0, 0);
3300	mountpoint_hashtable = alloc_large_system_hash("Mountpoint-cache",
3301	sizeof(struct hlist_head),
3302	mphash_entries, 19,
3303	0,
3304	&mp_hash_shift, &mp_hash_mask, 0, 0);
3305
3306	if (!mount_hashtable || !mountpoint_hashtable)
3307	panic("Failed to allocate mount hash table\n");
3308
3309	for (u = 0; u <= m_hash_mask; u++)
3310	INIT_HLIST_HEAD(&mount_hashtable[u]);
3311	for (u = 0; u <= mp_hash_mask; u++)
3312	INIT_HLIST_HEAD(&mountpoint_hashtable[u]);
3313
3314	kernfs_init();
3315
3316	err = sysfs_init();
3317	if (err)
3318	printk(KERN_WARNING "%s: sysfs_init error: %d\n",
3319	__func__, err);
3320	fs_kobj = kobject_create_and_add("fs", NULL);
3321	if (!fs_kobj)
3322	printk(KERN_WARNING "%s: kobj create error\n", __func__);
3323	init_rootfs();
3324	init_mount_tree();
3325	}
3326
3327	void put_mnt_ns(struct mnt_namespace *ns)
3328	{
3329	if (!atomic_dec_and_test(&ns->count))
3330	return;
3331	drop_collected_mounts(&ns->root->mnt);
3332	free_mnt_ns(ns);
3333	}
3334
3335	struct vfsmount *kern_mount_data(struct file_system_type *type, void *data)
3336	{
3337	struct vfsmount *mnt;
3338	mnt = vfs_kern_mount(type, MS_KERNMOUNT, type->name, data);
3339	if (!IS_ERR(mnt)) {
3340	/*
3341	* it is a longterm mount, don't release mnt until
3342	* we unmount before file sys is unregistered
3343	*/
3344	real_mount(mnt)->mnt_ns = MNT_NS_INTERNAL;
3345	}
3346	return mnt;
3347	}
3348	EXPORT_SYMBOL_GPL(kern_mount_data);
3349
3350	void kern_unmount(struct vfsmount *mnt)
3351	{
3352	/* release long term mount so mount point can be released */
3353	if (!IS_ERR_OR_NULL(mnt)) {
3354	real_mount(mnt)->mnt_ns = NULL;
3355	synchronize_rcu(); /* yecchhh... */
3356	mntput(mnt);
3357	}
3358	}
3359	EXPORT_SYMBOL(kern_unmount);
3360
3361	bool our_mnt(struct vfsmount *mnt)
3362	{
3363	return check_mnt(real_mount(mnt));
3364	}
3365
3366	bool current_chrooted(void)
3367	{
3368	/* Does the current process have a non-standard root */
3369	struct path ns_root;
3370	struct path fs_root;
3371	bool chrooted;
3372
3373	/* Find the namespace root */
3374	ns_root.mnt = &current->nsproxy->mnt_ns->root->mnt;
3375	ns_root.dentry = ns_root.mnt->mnt_root;
3376	path_get(&ns_root);
3377	while (d_mountpoint(ns_root.dentry) && follow_down_one(&ns_root))
3378	;
3379
3380	get_fs_root(current->fs, &fs_root);
3381
3382	chrooted = !path_equal(&fs_root, &ns_root);
3383
3384	path_put(&fs_root);
3385	path_put(&ns_root);
3386
3387	return chrooted;
3388	}
3389
3390	static bool mnt_already_visible(struct mnt_namespace *ns, struct vfsmount *new,
3391	int *new_mnt_flags)
3392	{
3393	int new_flags = *new_mnt_flags;
3394	struct mount *mnt;
3395	bool visible = false;
3396
3397	down_read(&namespace_sem);
3398	list_for_each_entry(mnt, &ns->list, mnt_list) {
3399	struct mount *child;
3400	int mnt_flags;
3401
3402	if (mnt->mnt.mnt_sb->s_type != new->mnt_sb->s_type)
3403	continue;
3404
3405	/* This mount is not fully visible if it's root directory
3406	* is not the root directory of the filesystem.
3407	*/
3408	if (mnt->mnt.mnt_root != mnt->mnt.mnt_sb->s_root)
3409	continue;
3410
3411	/* A local view of the mount flags */
3412	mnt_flags = mnt->mnt.mnt_flags;
3413
3414	/* Don't miss readonly hidden in the superblock flags */
3415	if (mnt->mnt.mnt_sb->s_flags & MS_RDONLY)
3416	mnt_flags |= MNT_LOCK_READONLY;
3417
3418	/* Verify the mount flags are equal to or more permissive
3419	* than the proposed new mount.
3420	*/
3421	if ((mnt_flags & MNT_LOCK_READONLY) &&
3422	!(new_flags & MNT_READONLY))
3423	continue;
3424	if ((mnt_flags & MNT_LOCK_ATIME) &&
3425	((mnt_flags & MNT_ATIME_MASK) != (new_flags & MNT_ATIME_MASK)))
3426	continue;
3427
3428	/* This mount is not fully visible if there are any
3429	* locked child mounts that cover anything except for
3430	* empty directories.
3431	*/
3432	list_for_each_entry(child, &mnt->mnt_mounts, mnt_child) {
3433	struct inode *inode = child->mnt_mountpoint->d_inode;
3434	/* Only worry about locked mounts */
3435	if (!(child->mnt.mnt_flags & MNT_LOCKED))
3436	continue;
3437	/* Is the directory permanetly empty? */
3438	if (!is_empty_dir_inode(inode))
3439	goto next;
3440	}
3441	/* Preserve the locked attributes */
3442	*new_mnt_flags |= mnt_flags & (MNT_LOCK_READONLY | \
3443	MNT_LOCK_ATIME);
3444	visible = true;
3445	goto found;
3446	next: ;
3447	}
3448	found:
3449	up_read(&namespace_sem);
3450	return visible;
3451	}
3452
3453	static bool mount_too_revealing(struct vfsmount *mnt, int *new_mnt_flags)
3454	{
3455	const unsigned long required_iflags = SB_I_NOEXEC | SB_I_NODEV;
3456	struct mnt_namespace *ns = current->nsproxy->mnt_ns;
3457	unsigned long s_iflags;
3458
3459	if (ns->user_ns == &init_user_ns)
3460	return false;
3461
3462	/* Can this filesystem be too revealing? */
3463	s_iflags = mnt->mnt_sb->s_iflags;
3464	if (!(s_iflags & SB_I_USERNS_VISIBLE))
3465	return false;
3466
3467	if ((s_iflags & required_iflags) != required_iflags) {
3468	WARN_ONCE(1, "Expected s_iflags to contain 0x%lx\n",
3469	required_iflags);
3470	return true;
3471	}
3472
3473	return !mnt_already_visible(ns, mnt, new_mnt_flags);
3474	}
3475
3476	bool mnt_may_suid(struct vfsmount *mnt)
3477	{
3478	/*
3479	* Foreign mounts (accessed via fchdir or through /proc
3480	* symlinks) are always treated as if they are nosuid. This
3481	* prevents namespaces from trusting potentially unsafe
3482	* suid/sgid bits, file caps, or security labels that originate
3483	* in other namespaces.
3484	*/
3485	return !(mnt->mnt_flags & MNT_NOSUID) && check_mnt(real_mount(mnt)) &&
3486	current_in_userns(mnt->mnt_sb->s_user_ns);
3487	}
3488
3489	static struct ns_common *mntns_get(struct task_struct *task)
3490	{
3491	struct ns_common *ns = NULL;
3492	struct nsproxy *nsproxy;
3493
3494	task_lock(task);
3495	nsproxy = task->nsproxy;
3496	if (nsproxy) {
3497	ns = &nsproxy->mnt_ns->ns;
3498	get_mnt_ns(to_mnt_ns(ns));
3499	}
3500	task_unlock(task);
3501
3502	return ns;
3503	}
3504
3505	static void mntns_put(struct ns_common *ns)
3506	{
3507	put_mnt_ns(to_mnt_ns(ns));
3508	}
3509
3510	static int mntns_install(struct nsproxy *nsproxy, struct ns_common *ns)
3511	{
3512	struct fs_struct *fs = current->fs;
3513	struct mnt_namespace *mnt_ns = to_mnt_ns(ns);
3514	struct path root;
3515
3516	if (!ns_capable(mnt_ns->user_ns, CAP_SYS_ADMIN) ||
3517	!ns_capable(current_user_ns(), CAP_SYS_CHROOT) ||
3518	!ns_capable(current_user_ns(), CAP_SYS_ADMIN))
3519	return -EPERM;
3520
3521	if (fs->users != 1)
3522	return -EINVAL;
3523
3524	get_mnt_ns(mnt_ns);
3525	put_mnt_ns(nsproxy->mnt_ns);
3526	nsproxy->mnt_ns = mnt_ns;
3527
3528	/* Find the root */
3529	root.mnt = &mnt_ns->root->mnt;
3530	root.dentry = mnt_ns->root->mnt.mnt_root;
3531	path_get(&root);
3532	while(d_mountpoint(root.dentry) && follow_down_one(&root))
3533	;
3534
3535	/* Update the pwd and root */
3536	set_fs_pwd(fs, &root);
3537	set_fs_root(fs, &root);
3538
3539	path_put(&root);
3540	return 0;
3541	}
3542
3543	static struct user_namespace *mntns_owner(struct ns_common *ns)
3544	{
3545	return to_mnt_ns(ns)->user_ns;
3546	}
3547
3548	const struct proc_ns_operations mntns_operations = {
3549	.name = "mnt",
3550	.type = CLONE_NEWNS,
3551	.get = mntns_get,
3552	.put = mntns_put,
3553	.install = mntns_install,
3554	.owner = mntns_owner,
3555	};
3556