]>
git.proxmox.com Git - mirror_ubuntu-eoan-kernel.git/blob - fs/pnode.c
4 * (C) Copyright IBM Corporation 2005.
5 * Released under GPL v2.
6 * Author : Ram Pai (linuxram@us.ibm.com)
9 #include <linux/mnt_namespace.h>
10 #include <linux/mount.h>
12 #include <linux/nsproxy.h>
16 /* return the next shared peer mount of @p */
17 static inline struct mount
*next_peer(struct mount
*p
)
19 return list_entry(p
->mnt_share
.next
, struct mount
, mnt_share
);
22 static inline struct mount
*first_slave(struct mount
*p
)
24 return list_entry(p
->mnt_slave_list
.next
, struct mount
, mnt_slave
);
27 static inline struct mount
*last_slave(struct mount
*p
)
29 return list_entry(p
->mnt_slave_list
.prev
, struct mount
, mnt_slave
);
32 static inline struct mount
*next_slave(struct mount
*p
)
34 return list_entry(p
->mnt_slave
.next
, struct mount
, mnt_slave
);
37 static struct mount
*get_peer_under_root(struct mount
*mnt
,
38 struct mnt_namespace
*ns
,
39 const struct path
*root
)
41 struct mount
*m
= mnt
;
44 /* Check the namespace first for optimization */
45 if (m
->mnt_ns
== ns
&& is_path_reachable(m
, m
->mnt
.mnt_root
, root
))
55 * Get ID of closest dominating peer group having a representative
56 * under the given root.
58 * Caller must hold namespace_sem
60 int get_dominating_id(struct mount
*mnt
, const struct path
*root
)
64 for (m
= mnt
->mnt_master
; m
!= NULL
; m
= m
->mnt_master
) {
65 struct mount
*d
= get_peer_under_root(m
, mnt
->mnt_ns
, root
);
67 return d
->mnt_group_id
;
73 static int do_make_slave(struct mount
*mnt
)
75 struct mount
*master
, *slave_mnt
;
77 if (list_empty(&mnt
->mnt_share
)) {
78 if (IS_MNT_SHARED(mnt
)) {
79 mnt_release_group_id(mnt
);
80 CLEAR_MNT_SHARED(mnt
);
82 master
= mnt
->mnt_master
;
84 struct list_head
*p
= &mnt
->mnt_slave_list
;
85 while (!list_empty(p
)) {
86 slave_mnt
= list_first_entry(p
,
87 struct mount
, mnt_slave
);
88 list_del_init(&slave_mnt
->mnt_slave
);
89 slave_mnt
->mnt_master
= NULL
;
96 * slave 'mnt' to a peer mount that has the
97 * same root dentry. If none is available then
98 * slave it to anything that is available.
100 for (m
= master
= next_peer(mnt
); m
!= mnt
; m
= next_peer(m
)) {
101 if (m
->mnt
.mnt_root
== mnt
->mnt
.mnt_root
) {
106 list_del_init(&mnt
->mnt_share
);
107 mnt
->mnt_group_id
= 0;
108 CLEAR_MNT_SHARED(mnt
);
110 list_for_each_entry(slave_mnt
, &mnt
->mnt_slave_list
, mnt_slave
)
111 slave_mnt
->mnt_master
= master
;
112 list_move(&mnt
->mnt_slave
, &master
->mnt_slave_list
);
113 list_splice(&mnt
->mnt_slave_list
, master
->mnt_slave_list
.prev
);
114 INIT_LIST_HEAD(&mnt
->mnt_slave_list
);
115 mnt
->mnt_master
= master
;
120 * vfsmount lock must be held for write
122 void change_mnt_propagation(struct mount
*mnt
, int type
)
124 if (type
== MS_SHARED
) {
129 if (type
!= MS_SLAVE
) {
130 list_del_init(&mnt
->mnt_slave
);
131 mnt
->mnt_master
= NULL
;
132 if (type
== MS_UNBINDABLE
)
133 mnt
->mnt
.mnt_flags
|= MNT_UNBINDABLE
;
135 mnt
->mnt
.mnt_flags
&= ~MNT_UNBINDABLE
;
140 * get the next mount in the propagation tree.
141 * @m: the mount seen last
142 * @origin: the original mount from where the tree walk initiated
144 * Note that peer groups form contiguous segments of slave lists.
145 * We rely on that in get_source() to be able to find out if
146 * vfsmount found while iterating with propagation_next() is
147 * a peer of one we'd found earlier.
149 static struct mount
*propagation_next(struct mount
*m
,
150 struct mount
*origin
)
152 /* are there any slaves of this mount? */
153 if (!IS_MNT_NEW(m
) && !list_empty(&m
->mnt_slave_list
))
154 return first_slave(m
);
157 struct mount
*master
= m
->mnt_master
;
159 if (master
== origin
->mnt_master
) {
160 struct mount
*next
= next_peer(m
);
161 return (next
== origin
) ? NULL
: next
;
162 } else if (m
->mnt_slave
.next
!= &master
->mnt_slave_list
)
163 return next_slave(m
);
170 static struct mount
*skip_propagation_subtree(struct mount
*m
,
171 struct mount
*origin
)
174 * Advance m such that propagation_next will not return
177 if (!IS_MNT_NEW(m
) && !list_empty(&m
->mnt_slave_list
))
183 static struct mount
*next_group(struct mount
*m
, struct mount
*origin
)
188 if (!IS_MNT_NEW(m
) && !list_empty(&m
->mnt_slave_list
))
189 return first_slave(m
);
191 if (m
->mnt_group_id
== origin
->mnt_group_id
) {
194 } else if (m
->mnt_slave
.next
!= &next
->mnt_slave
)
198 /* m is the last peer */
200 struct mount
*master
= m
->mnt_master
;
201 if (m
->mnt_slave
.next
!= &master
->mnt_slave_list
)
202 return next_slave(m
);
203 m
= next_peer(master
);
204 if (master
->mnt_group_id
== origin
->mnt_group_id
)
206 if (master
->mnt_slave
.next
== &m
->mnt_slave
)
215 /* all accesses are serialized by namespace_sem */
216 static struct user_namespace
*user_ns
;
217 static struct mount
*last_dest
, *first_source
, *last_source
, *dest_master
;
218 static struct mountpoint
*mp
;
219 static struct hlist_head
*list
;
221 static inline bool peers(struct mount
*m1
, struct mount
*m2
)
223 return m1
->mnt_group_id
== m2
->mnt_group_id
&& m1
->mnt_group_id
;
226 static int propagate_one(struct mount
*m
)
230 /* skip ones added by this propagate_mnt() */
233 /* skip if mountpoint isn't covered by it */
234 if (!is_subdir(mp
->m_dentry
, m
->mnt
.mnt_root
))
236 if (peers(m
, last_dest
)) {
237 type
= CL_MAKE_SHARED
;
241 for (n
= m
; ; n
= p
) {
243 if (p
== dest_master
|| IS_MNT_MARKED(p
))
247 struct mount
*parent
= last_source
->mnt_parent
;
248 if (last_source
== first_source
)
250 done
= parent
->mnt_master
== p
;
251 if (done
&& peers(n
, parent
))
253 last_source
= last_source
->mnt_master
;
257 /* beginning of peer group among the slaves? */
258 if (IS_MNT_SHARED(m
))
259 type
|= CL_MAKE_SHARED
;
262 /* Notice when we are propagating across user namespaces */
263 if (m
->mnt_ns
->user_ns
!= user_ns
)
264 type
|= CL_UNPRIVILEGED
;
265 child
= copy_tree(last_source
, last_source
->mnt
.mnt_root
, type
);
267 return PTR_ERR(child
);
268 child
->mnt
.mnt_flags
&= ~MNT_LOCKED
;
269 mnt_set_mountpoint(m
, mp
, child
);
272 if (m
->mnt_master
!= dest_master
) {
273 read_seqlock_excl(&mount_lock
);
274 SET_MNT_MARK(m
->mnt_master
);
275 read_sequnlock_excl(&mount_lock
);
277 hlist_add_head(&child
->mnt_hash
, list
);
278 return count_mounts(m
->mnt_ns
, child
);
282 * mount 'source_mnt' under the destination 'dest_mnt' at
283 * dentry 'dest_dentry'. And propagate that mount to
284 * all the peer and slave mounts of 'dest_mnt'.
285 * Link all the new mounts into a propagation tree headed at
286 * source_mnt. Also link all the new mounts using ->mnt_list
287 * headed at source_mnt's ->mnt_list
289 * @dest_mnt: destination mount.
290 * @dest_dentry: destination dentry.
291 * @source_mnt: source mount.
292 * @tree_list : list of heads of trees to be attached.
294 int propagate_mnt(struct mount
*dest_mnt
, struct mountpoint
*dest_mp
,
295 struct mount
*source_mnt
, struct hlist_head
*tree_list
)
301 * we don't want to bother passing tons of arguments to
302 * propagate_one(); everything is serialized by namespace_sem,
303 * so globals will do just fine.
305 user_ns
= current
->nsproxy
->mnt_ns
->user_ns
;
306 last_dest
= dest_mnt
;
307 first_source
= source_mnt
;
308 last_source
= source_mnt
;
311 dest_master
= dest_mnt
->mnt_master
;
313 /* all peers of dest_mnt, except dest_mnt itself */
314 for (n
= next_peer(dest_mnt
); n
!= dest_mnt
; n
= next_peer(n
)) {
315 ret
= propagate_one(n
);
320 /* all slave groups */
321 for (m
= next_group(dest_mnt
, dest_mnt
); m
;
322 m
= next_group(m
, dest_mnt
)) {
323 /* everything in that slave group */
326 ret
= propagate_one(n
);
333 read_seqlock_excl(&mount_lock
);
334 hlist_for_each_entry(n
, tree_list
, mnt_hash
) {
336 if (m
->mnt_master
!= dest_mnt
->mnt_master
)
337 CLEAR_MNT_MARK(m
->mnt_master
);
339 read_sequnlock_excl(&mount_lock
);
343 static struct mount
*find_topper(struct mount
*mnt
)
345 /* If there is exactly one mount covering mnt completely return it. */
348 if (!list_is_singular(&mnt
->mnt_mounts
))
351 child
= list_first_entry(&mnt
->mnt_mounts
, struct mount
, mnt_child
);
352 if (child
->mnt_mountpoint
!= mnt
->mnt
.mnt_root
)
359 * return true if the refcount is greater than count
361 static inline int do_refcount_check(struct mount
*mnt
, int count
)
363 return mnt_get_count(mnt
) > count
;
367 * check if the mount 'mnt' can be unmounted successfully.
368 * @mnt: the mount to be checked for unmount
369 * NOTE: unmounting 'mnt' would naturally propagate to all
370 * other mounts its parent propagates to.
371 * Check if any of these mounts that **do not have submounts**
372 * have more references than 'refcnt'. If so return busy.
374 * vfsmount lock must be held for write
376 int propagate_mount_busy(struct mount
*mnt
, int refcnt
)
378 struct mount
*m
, *child
, *topper
;
379 struct mount
*parent
= mnt
->mnt_parent
;
382 return do_refcount_check(mnt
, refcnt
);
385 * quickly check if the current mount can be unmounted.
386 * If not, we don't have to go checking for all other
389 if (!list_empty(&mnt
->mnt_mounts
) || do_refcount_check(mnt
, refcnt
))
392 for (m
= propagation_next(parent
, parent
); m
;
393 m
= propagation_next(m
, parent
)) {
395 child
= __lookup_mnt(&m
->mnt
, mnt
->mnt_mountpoint
);
399 /* Is there exactly one mount on the child that covers
400 * it completely whose reference should be ignored?
402 topper
= find_topper(child
);
405 else if (!list_empty(&child
->mnt_mounts
))
408 if (do_refcount_check(child
, count
))
415 * Clear MNT_LOCKED when it can be shown to be safe.
417 * mount_lock lock must be held for write
419 void propagate_mount_unlock(struct mount
*mnt
)
421 struct mount
*parent
= mnt
->mnt_parent
;
422 struct mount
*m
, *child
;
424 BUG_ON(parent
== mnt
);
426 for (m
= propagation_next(parent
, parent
); m
;
427 m
= propagation_next(m
, parent
)) {
428 child
= __lookup_mnt(&m
->mnt
, mnt
->mnt_mountpoint
);
430 child
->mnt
.mnt_flags
&= ~MNT_LOCKED
;
434 static void umount_one(struct mount
*mnt
, struct list_head
*to_umount
)
437 mnt
->mnt
.mnt_flags
|= MNT_UMOUNT
;
438 list_del_init(&mnt
->mnt_child
);
439 list_del_init(&mnt
->mnt_umounting
);
440 list_move_tail(&mnt
->mnt_list
, to_umount
);
444 * NOTE: unmounting 'mnt' naturally propagates to all other mounts its
445 * parent propagates to.
447 static bool __propagate_umount(struct mount
*mnt
,
448 struct list_head
*to_umount
,
449 struct list_head
*to_restore
)
451 bool progress
= false;
455 * The state of the parent won't change if this mount is
456 * already unmounted or marked as without children.
458 if (mnt
->mnt
.mnt_flags
& (MNT_UMOUNT
| MNT_MARKED
))
461 /* Verify topper is the only grandchild that has not been
462 * speculatively unmounted.
464 list_for_each_entry(child
, &mnt
->mnt_mounts
, mnt_child
) {
465 if (child
->mnt_mountpoint
== mnt
->mnt
.mnt_root
)
467 if (!list_empty(&child
->mnt_umounting
) && IS_MNT_MARKED(child
))
469 /* Found a mounted child */
473 /* Mark mounts that can be unmounted if not locked */
477 /* If a mount is without children and not locked umount it. */
478 if (!IS_MNT_LOCKED(mnt
)) {
479 umount_one(mnt
, to_umount
);
482 list_move_tail(&mnt
->mnt_umounting
, to_restore
);
488 static void umount_list(struct list_head
*to_umount
,
489 struct list_head
*to_restore
)
491 struct mount
*mnt
, *child
, *tmp
;
492 list_for_each_entry(mnt
, to_umount
, mnt_list
) {
493 list_for_each_entry_safe(child
, tmp
, &mnt
->mnt_mounts
, mnt_child
) {
495 if (child
->mnt_mountpoint
== mnt
->mnt
.mnt_root
)
496 list_move_tail(&child
->mnt_umounting
, to_restore
);
498 umount_one(child
, to_umount
);
503 static void restore_mounts(struct list_head
*to_restore
)
505 /* Restore mounts to a clean working state */
506 while (!list_empty(to_restore
)) {
507 struct mount
*mnt
, *parent
;
508 struct mountpoint
*mp
;
510 mnt
= list_first_entry(to_restore
, struct mount
, mnt_umounting
);
512 list_del_init(&mnt
->mnt_umounting
);
514 /* Should this mount be reparented? */
516 parent
= mnt
->mnt_parent
;
517 while (parent
->mnt
.mnt_flags
& MNT_UMOUNT
) {
519 parent
= parent
->mnt_parent
;
521 if (parent
!= mnt
->mnt_parent
)
522 mnt_change_mountpoint(parent
, mp
, mnt
);
526 static void cleanup_umount_visitations(struct list_head
*visited
)
528 while (!list_empty(visited
)) {
530 list_first_entry(visited
, struct mount
, mnt_umounting
);
531 list_del_init(&mnt
->mnt_umounting
);
536 * collect all mounts that receive propagation from the mount in @list,
537 * and return these additional mounts in the same list.
538 * @list: the list of mounts to be unmounted.
540 * vfsmount lock must be held for write
542 int propagate_umount(struct list_head
*list
)
545 LIST_HEAD(to_restore
);
546 LIST_HEAD(to_umount
);
549 /* Find candidates for unmounting */
550 list_for_each_entry_reverse(mnt
, list
, mnt_list
) {
551 struct mount
*parent
= mnt
->mnt_parent
;
555 * If this mount has already been visited it is known that it's
556 * entire peer group and all of their slaves in the propagation
557 * tree for the mountpoint has already been visited and there is
558 * no need to visit them again.
560 if (!list_empty(&mnt
->mnt_umounting
))
563 list_add_tail(&mnt
->mnt_umounting
, &visited
);
564 for (m
= propagation_next(parent
, parent
); m
;
565 m
= propagation_next(m
, parent
)) {
566 struct mount
*child
= __lookup_mnt(&m
->mnt
,
567 mnt
->mnt_mountpoint
);
571 if (!list_empty(&child
->mnt_umounting
)) {
573 * If the child has already been visited it is
574 * know that it's entire peer group and all of
575 * their slaves in the propgation tree for the
576 * mountpoint has already been visited and there
577 * is no need to visit this subtree again.
579 m
= skip_propagation_subtree(m
, parent
);
581 } else if (child
->mnt
.mnt_flags
& MNT_UMOUNT
) {
583 * We have come accross an partially unmounted
584 * mount in list that has not been visited yet.
585 * Remember it has been visited and continue
586 * about our merry way.
588 list_add_tail(&child
->mnt_umounting
, &visited
);
592 /* Check the child and parents while progress is made */
593 while (__propagate_umount(child
,
594 &to_umount
, &to_restore
)) {
595 /* Is the parent a umount candidate? */
596 child
= child
->mnt_parent
;
597 if (list_empty(&child
->mnt_umounting
))
603 umount_list(&to_umount
, &to_restore
);
604 restore_mounts(&to_restore
);
605 cleanup_umount_visitations(&visited
);
606 list_splice_tail(&to_umount
, list
);