pnode.c 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * linux/fs/pnode.c
  4. *
  5. * (C) Copyright IBM Corporation 2005.
  6. * Author : Ram Pai (linuxram@us.ibm.com)
  7. */
  8. #include <linux/mnt_namespace.h>
  9. #include <linux/mount.h>
  10. #include <linux/fs.h>
  11. #include <linux/nsproxy.h>
  12. #include <uapi/linux/mount.h>
  13. #include "internal.h"
  14. #include "pnode.h"
  15. /* return the next shared peer mount of @p */
  16. static inline struct mount *next_peer(struct mount *p)
  17. {
  18. return list_entry(p->mnt_share.next, struct mount, mnt_share);
  19. }
  20. static inline struct mount *first_slave(struct mount *p)
  21. {
  22. return list_entry(p->mnt_slave_list.next, struct mount, mnt_slave);
  23. }
  24. static inline struct mount *last_slave(struct mount *p)
  25. {
  26. return list_entry(p->mnt_slave_list.prev, struct mount, mnt_slave);
  27. }
  28. static inline struct mount *next_slave(struct mount *p)
  29. {
  30. return list_entry(p->mnt_slave.next, struct mount, mnt_slave);
  31. }
  32. static struct mount *get_peer_under_root(struct mount *mnt,
  33. struct mnt_namespace *ns,
  34. const struct path *root)
  35. {
  36. struct mount *m = mnt;
  37. do {
  38. /* Check the namespace first for optimization */
  39. if (m->mnt_ns == ns && is_path_reachable(m, m->mnt.mnt_root, root))
  40. return m;
  41. m = next_peer(m);
  42. } while (m != mnt);
  43. return NULL;
  44. }
  45. /*
  46. * Get ID of closest dominating peer group having a representative
  47. * under the given root.
  48. *
  49. * Caller must hold namespace_sem
  50. */
  51. int get_dominating_id(struct mount *mnt, const struct path *root)
  52. {
  53. struct mount *m;
  54. for (m = mnt->mnt_master; m != NULL; m = m->mnt_master) {
  55. struct mount *d = get_peer_under_root(m, mnt->mnt_ns, root);
  56. if (d)
  57. return d->mnt_group_id;
  58. }
  59. return 0;
  60. }
  61. static int do_make_slave(struct mount *mnt)
  62. {
  63. struct mount *master, *slave_mnt;
  64. if (list_empty(&mnt->mnt_share)) {
  65. if (IS_MNT_SHARED(mnt)) {
  66. mnt_release_group_id(mnt);
  67. CLEAR_MNT_SHARED(mnt);
  68. }
  69. master = mnt->mnt_master;
  70. if (!master) {
  71. struct list_head *p = &mnt->mnt_slave_list;
  72. while (!list_empty(p)) {
  73. slave_mnt = list_first_entry(p,
  74. struct mount, mnt_slave);
  75. list_del_init(&slave_mnt->mnt_slave);
  76. slave_mnt->mnt_master = NULL;
  77. }
  78. return 0;
  79. }
  80. } else {
  81. struct mount *m;
  82. /*
  83. * slave 'mnt' to a peer mount that has the
  84. * same root dentry. If none is available then
  85. * slave it to anything that is available.
  86. */
  87. for (m = master = next_peer(mnt); m != mnt; m = next_peer(m)) {
  88. if (m->mnt.mnt_root == mnt->mnt.mnt_root) {
  89. master = m;
  90. break;
  91. }
  92. }
  93. list_del_init(&mnt->mnt_share);
  94. mnt->mnt_group_id = 0;
  95. CLEAR_MNT_SHARED(mnt);
  96. }
  97. list_for_each_entry(slave_mnt, &mnt->mnt_slave_list, mnt_slave)
  98. slave_mnt->mnt_master = master;
  99. list_move(&mnt->mnt_slave, &master->mnt_slave_list);
  100. list_splice(&mnt->mnt_slave_list, master->mnt_slave_list.prev);
  101. INIT_LIST_HEAD(&mnt->mnt_slave_list);
  102. mnt->mnt_master = master;
  103. return 0;
  104. }
  105. /*
  106. * vfsmount lock must be held for write
  107. */
  108. void change_mnt_propagation(struct mount *mnt, int type)
  109. {
  110. if (type == MS_SHARED) {
  111. set_mnt_shared(mnt);
  112. return;
  113. }
  114. do_make_slave(mnt);
  115. if (type != MS_SLAVE) {
  116. list_del_init(&mnt->mnt_slave);
  117. mnt->mnt_master = NULL;
  118. if (type == MS_UNBINDABLE)
  119. mnt->mnt.mnt_flags |= MNT_UNBINDABLE;
  120. else
  121. mnt->mnt.mnt_flags &= ~MNT_UNBINDABLE;
  122. }
  123. }
  124. /*
  125. * get the next mount in the propagation tree.
  126. * @m: the mount seen last
  127. * @origin: the original mount from where the tree walk initiated
  128. *
  129. * Note that peer groups form contiguous segments of slave lists.
  130. * We rely on that in get_source() to be able to find out if
  131. * vfsmount found while iterating with propagation_next() is
  132. * a peer of one we'd found earlier.
  133. */
  134. static struct mount *propagation_next(struct mount *m,
  135. struct mount *origin)
  136. {
  137. /* are there any slaves of this mount? */
  138. if (!IS_MNT_NEW(m) && !list_empty(&m->mnt_slave_list))
  139. return first_slave(m);
  140. while (1) {
  141. struct mount *master = m->mnt_master;
  142. if (master == origin->mnt_master) {
  143. struct mount *next = next_peer(m);
  144. return (next == origin) ? NULL : next;
  145. } else if (m->mnt_slave.next != &master->mnt_slave_list)
  146. return next_slave(m);
  147. /* back at master */
  148. m = master;
  149. }
  150. }
  151. static struct mount *skip_propagation_subtree(struct mount *m,
  152. struct mount *origin)
  153. {
  154. /*
  155. * Advance m such that propagation_next will not return
  156. * the slaves of m.
  157. */
  158. if (!IS_MNT_NEW(m) && !list_empty(&m->mnt_slave_list))
  159. m = last_slave(m);
  160. return m;
  161. }
  162. static struct mount *next_group(struct mount *m, struct mount *origin)
  163. {
  164. while (1) {
  165. while (1) {
  166. struct mount *next;
  167. if (!IS_MNT_NEW(m) && !list_empty(&m->mnt_slave_list))
  168. return first_slave(m);
  169. next = next_peer(m);
  170. if (m->mnt_group_id == origin->mnt_group_id) {
  171. if (next == origin)
  172. return NULL;
  173. } else if (m->mnt_slave.next != &next->mnt_slave)
  174. break;
  175. m = next;
  176. }
  177. /* m is the last peer */
  178. while (1) {
  179. struct mount *master = m->mnt_master;
  180. if (m->mnt_slave.next != &master->mnt_slave_list)
  181. return next_slave(m);
  182. m = next_peer(master);
  183. if (master->mnt_group_id == origin->mnt_group_id)
  184. break;
  185. if (master->mnt_slave.next == &m->mnt_slave)
  186. break;
  187. m = master;
  188. }
  189. if (m == origin)
  190. return NULL;
  191. }
  192. }
  193. /* all accesses are serialized by namespace_sem */
  194. static struct mount *last_dest, *first_source, *last_source, *dest_master;
  195. static struct mountpoint *mp;
  196. static struct hlist_head *list;
  197. static inline bool peers(struct mount *m1, struct mount *m2)
  198. {
  199. return m1->mnt_group_id == m2->mnt_group_id && m1->mnt_group_id;
  200. }
  201. static int propagate_one(struct mount *m)
  202. {
  203. struct mount *child;
  204. int type;
  205. /* skip ones added by this propagate_mnt() */
  206. if (IS_MNT_NEW(m))
  207. return 0;
  208. /* skip if mountpoint isn't covered by it */
  209. if (!is_subdir(mp->m_dentry, m->mnt.mnt_root))
  210. return 0;
  211. if (peers(m, last_dest)) {
  212. type = CL_MAKE_SHARED;
  213. } else {
  214. struct mount *n, *p;
  215. bool done;
  216. for (n = m; ; n = p) {
  217. p = n->mnt_master;
  218. if (p == dest_master || IS_MNT_MARKED(p))
  219. break;
  220. }
  221. do {
  222. struct mount *parent = last_source->mnt_parent;
  223. if (last_source == first_source)
  224. break;
  225. done = parent->mnt_master == p;
  226. if (done && peers(n, parent))
  227. break;
  228. last_source = last_source->mnt_master;
  229. } while (!done);
  230. type = CL_SLAVE;
  231. /* beginning of peer group among the slaves? */
  232. if (IS_MNT_SHARED(m))
  233. type |= CL_MAKE_SHARED;
  234. }
  235. child = copy_tree(last_source, last_source->mnt.mnt_root, type);
  236. if (IS_ERR(child))
  237. return PTR_ERR(child);
  238. read_seqlock_excl(&mount_lock);
  239. mnt_set_mountpoint(m, mp, child);
  240. if (m->mnt_master != dest_master)
  241. SET_MNT_MARK(m->mnt_master);
  242. read_sequnlock_excl(&mount_lock);
  243. last_dest = m;
  244. last_source = child;
  245. hlist_add_head(&child->mnt_hash, list);
  246. return count_mounts(m->mnt_ns, child);
  247. }
  248. /*
  249. * mount 'source_mnt' under the destination 'dest_mnt' at
  250. * dentry 'dest_dentry'. And propagate that mount to
  251. * all the peer and slave mounts of 'dest_mnt'.
  252. * Link all the new mounts into a propagation tree headed at
  253. * source_mnt. Also link all the new mounts using ->mnt_list
  254. * headed at source_mnt's ->mnt_list
  255. *
  256. * @dest_mnt: destination mount.
  257. * @dest_dentry: destination dentry.
  258. * @source_mnt: source mount.
  259. * @tree_list : list of heads of trees to be attached.
  260. */
  261. int propagate_mnt(struct mount *dest_mnt, struct mountpoint *dest_mp,
  262. struct mount *source_mnt, struct hlist_head *tree_list)
  263. {
  264. struct mount *m, *n;
  265. int ret = 0;
  266. /*
  267. * we don't want to bother passing tons of arguments to
  268. * propagate_one(); everything is serialized by namespace_sem,
  269. * so globals will do just fine.
  270. */
  271. last_dest = dest_mnt;
  272. first_source = source_mnt;
  273. last_source = source_mnt;
  274. mp = dest_mp;
  275. list = tree_list;
  276. dest_master = dest_mnt->mnt_master;
  277. /* all peers of dest_mnt, except dest_mnt itself */
  278. for (n = next_peer(dest_mnt); n != dest_mnt; n = next_peer(n)) {
  279. ret = propagate_one(n);
  280. if (ret)
  281. goto out;
  282. }
  283. /* all slave groups */
  284. for (m = next_group(dest_mnt, dest_mnt); m;
  285. m = next_group(m, dest_mnt)) {
  286. /* everything in that slave group */
  287. n = m;
  288. do {
  289. ret = propagate_one(n);
  290. if (ret)
  291. goto out;
  292. n = next_peer(n);
  293. } while (n != m);
  294. }
  295. out:
  296. read_seqlock_excl(&mount_lock);
  297. hlist_for_each_entry(n, tree_list, mnt_hash) {
  298. m = n->mnt_parent;
  299. if (m->mnt_master != dest_mnt->mnt_master)
  300. CLEAR_MNT_MARK(m->mnt_master);
  301. }
  302. read_sequnlock_excl(&mount_lock);
  303. return ret;
  304. }
  305. static struct mount *find_topper(struct mount *mnt)
  306. {
  307. /* If there is exactly one mount covering mnt completely return it. */
  308. struct mount *child;
  309. if (!list_is_singular(&mnt->mnt_mounts))
  310. return NULL;
  311. child = list_first_entry(&mnt->mnt_mounts, struct mount, mnt_child);
  312. if (child->mnt_mountpoint != mnt->mnt.mnt_root)
  313. return NULL;
  314. return child;
  315. }
  316. /*
  317. * return true if the refcount is greater than count
  318. */
  319. static inline int do_refcount_check(struct mount *mnt, int count)
  320. {
  321. return mnt_get_count(mnt) > count;
  322. }
  323. /*
  324. * check if the mount 'mnt' can be unmounted successfully.
  325. * @mnt: the mount to be checked for unmount
  326. * NOTE: unmounting 'mnt' would naturally propagate to all
  327. * other mounts its parent propagates to.
  328. * Check if any of these mounts that **do not have submounts**
  329. * have more references than 'refcnt'. If so return busy.
  330. *
  331. * vfsmount lock must be held for write
  332. */
  333. int propagate_mount_busy(struct mount *mnt, int refcnt)
  334. {
  335. struct mount *m, *child, *topper;
  336. struct mount *parent = mnt->mnt_parent;
  337. if (mnt == parent)
  338. return do_refcount_check(mnt, refcnt);
  339. /*
  340. * quickly check if the current mount can be unmounted.
  341. * If not, we don't have to go checking for all other
  342. * mounts
  343. */
  344. if (!list_empty(&mnt->mnt_mounts) || do_refcount_check(mnt, refcnt))
  345. return 1;
  346. for (m = propagation_next(parent, parent); m;
  347. m = propagation_next(m, parent)) {
  348. int count = 1;
  349. child = __lookup_mnt(&m->mnt, mnt->mnt_mountpoint);
  350. if (!child)
  351. continue;
  352. /* Is there exactly one mount on the child that covers
  353. * it completely whose reference should be ignored?
  354. */
  355. topper = find_topper(child);
  356. if (topper)
  357. count += 1;
  358. else if (!list_empty(&child->mnt_mounts))
  359. continue;
  360. if (do_refcount_check(child, count))
  361. return 1;
  362. }
  363. return 0;
  364. }
  365. /*
  366. * Clear MNT_LOCKED when it can be shown to be safe.
  367. *
  368. * mount_lock lock must be held for write
  369. */
  370. void propagate_mount_unlock(struct mount *mnt)
  371. {
  372. struct mount *parent = mnt->mnt_parent;
  373. struct mount *m, *child;
  374. BUG_ON(parent == mnt);
  375. for (m = propagation_next(parent, parent); m;
  376. m = propagation_next(m, parent)) {
  377. child = __lookup_mnt(&m->mnt, mnt->mnt_mountpoint);
  378. if (child)
  379. child->mnt.mnt_flags &= ~MNT_LOCKED;
  380. }
  381. }
  382. static void umount_one(struct mount *mnt, struct list_head *to_umount)
  383. {
  384. CLEAR_MNT_MARK(mnt);
  385. mnt->mnt.mnt_flags |= MNT_UMOUNT;
  386. list_del_init(&mnt->mnt_child);
  387. list_del_init(&mnt->mnt_umounting);
  388. list_move_tail(&mnt->mnt_list, to_umount);
  389. }
  390. /*
  391. * NOTE: unmounting 'mnt' naturally propagates to all other mounts its
  392. * parent propagates to.
  393. */
  394. static bool __propagate_umount(struct mount *mnt,
  395. struct list_head *to_umount,
  396. struct list_head *to_restore)
  397. {
  398. bool progress = false;
  399. struct mount *child;
  400. /*
  401. * The state of the parent won't change if this mount is
  402. * already unmounted or marked as without children.
  403. */
  404. if (mnt->mnt.mnt_flags & (MNT_UMOUNT | MNT_MARKED))
  405. goto out;
  406. /* Verify topper is the only grandchild that has not been
  407. * speculatively unmounted.
  408. */
  409. list_for_each_entry(child, &mnt->mnt_mounts, mnt_child) {
  410. if (child->mnt_mountpoint == mnt->mnt.mnt_root)
  411. continue;
  412. if (!list_empty(&child->mnt_umounting) && IS_MNT_MARKED(child))
  413. continue;
  414. /* Found a mounted child */
  415. goto children;
  416. }
  417. /* Mark mounts that can be unmounted if not locked */
  418. SET_MNT_MARK(mnt);
  419. progress = true;
  420. /* If a mount is without children and not locked umount it. */
  421. if (!IS_MNT_LOCKED(mnt)) {
  422. umount_one(mnt, to_umount);
  423. } else {
  424. children:
  425. list_move_tail(&mnt->mnt_umounting, to_restore);
  426. }
  427. out:
  428. return progress;
  429. }
  430. static void umount_list(struct list_head *to_umount,
  431. struct list_head *to_restore)
  432. {
  433. struct mount *mnt, *child, *tmp;
  434. list_for_each_entry(mnt, to_umount, mnt_list) {
  435. list_for_each_entry_safe(child, tmp, &mnt->mnt_mounts, mnt_child) {
  436. /* topper? */
  437. if (child->mnt_mountpoint == mnt->mnt.mnt_root)
  438. list_move_tail(&child->mnt_umounting, to_restore);
  439. else
  440. umount_one(child, to_umount);
  441. }
  442. }
  443. }
  444. static void restore_mounts(struct list_head *to_restore)
  445. {
  446. /* Restore mounts to a clean working state */
  447. while (!list_empty(to_restore)) {
  448. struct mount *mnt, *parent;
  449. struct mountpoint *mp;
  450. mnt = list_first_entry(to_restore, struct mount, mnt_umounting);
  451. CLEAR_MNT_MARK(mnt);
  452. list_del_init(&mnt->mnt_umounting);
  453. /* Should this mount be reparented? */
  454. mp = mnt->mnt_mp;
  455. parent = mnt->mnt_parent;
  456. while (parent->mnt.mnt_flags & MNT_UMOUNT) {
  457. mp = parent->mnt_mp;
  458. parent = parent->mnt_parent;
  459. }
  460. if (parent != mnt->mnt_parent)
  461. mnt_change_mountpoint(parent, mp, mnt);
  462. }
  463. }
  464. static void cleanup_umount_visitations(struct list_head *visited)
  465. {
  466. while (!list_empty(visited)) {
  467. struct mount *mnt =
  468. list_first_entry(visited, struct mount, mnt_umounting);
  469. list_del_init(&mnt->mnt_umounting);
  470. }
  471. }
  472. /*
  473. * collect all mounts that receive propagation from the mount in @list,
  474. * and return these additional mounts in the same list.
  475. * @list: the list of mounts to be unmounted.
  476. *
  477. * vfsmount lock must be held for write
  478. */
  479. int propagate_umount(struct list_head *list)
  480. {
  481. struct mount *mnt;
  482. LIST_HEAD(to_restore);
  483. LIST_HEAD(to_umount);
  484. LIST_HEAD(visited);
  485. /* Find candidates for unmounting */
  486. list_for_each_entry_reverse(mnt, list, mnt_list) {
  487. struct mount *parent = mnt->mnt_parent;
  488. struct mount *m;
  489. /*
  490. * If this mount has already been visited it is known that it's
  491. * entire peer group and all of their slaves in the propagation
  492. * tree for the mountpoint has already been visited and there is
  493. * no need to visit them again.
  494. */
  495. if (!list_empty(&mnt->mnt_umounting))
  496. continue;
  497. list_add_tail(&mnt->mnt_umounting, &visited);
  498. for (m = propagation_next(parent, parent); m;
  499. m = propagation_next(m, parent)) {
  500. struct mount *child = __lookup_mnt(&m->mnt,
  501. mnt->mnt_mountpoint);
  502. if (!child)
  503. continue;
  504. if (!list_empty(&child->mnt_umounting)) {
  505. /*
  506. * If the child has already been visited it is
  507. * know that it's entire peer group and all of
  508. * their slaves in the propgation tree for the
  509. * mountpoint has already been visited and there
  510. * is no need to visit this subtree again.
  511. */
  512. m = skip_propagation_subtree(m, parent);
  513. continue;
  514. } else if (child->mnt.mnt_flags & MNT_UMOUNT) {
  515. /*
  516. * We have come accross an partially unmounted
  517. * mount in list that has not been visited yet.
  518. * Remember it has been visited and continue
  519. * about our merry way.
  520. */
  521. list_add_tail(&child->mnt_umounting, &visited);
  522. continue;
  523. }
  524. /* Check the child and parents while progress is made */
  525. while (__propagate_umount(child,
  526. &to_umount, &to_restore)) {
  527. /* Is the parent a umount candidate? */
  528. child = child->mnt_parent;
  529. if (list_empty(&child->mnt_umounting))
  530. break;
  531. }
  532. }
  533. }
  534. umount_list(&to_umount, &to_restore);
  535. restore_mounts(&to_restore);
  536. cleanup_umount_visitations(&visited);
  537. list_splice_tail(&to_umount, list);
  538. return 0;
  539. }