namespace.c 47 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879
  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. #include <linux/syscalls.h>
  11. #include <linux/slab.h>
  12. #include <linux/sched.h>
  13. #include <linux/smp_lock.h>
  14. #include <linux/init.h>
  15. #include <linux/kernel.h>
  16. #include <linux/quotaops.h>
  17. #include <linux/acct.h>
  18. #include <linux/capability.h>
  19. #include <linux/module.h>
  20. #include <linux/sysfs.h>
  21. #include <linux/seq_file.h>
  22. #include <linux/mnt_namespace.h>
  23. #include <linux/namei.h>
  24. #include <linux/security.h>
  25. #include <linux/mount.h>
  26. #include <linux/ramfs.h>
  27. #include <asm/uaccess.h>
  28. #include <asm/unistd.h>
  29. #include "pnode.h"
  30. /* spinlock for vfsmount related operations, inplace of dcache_lock */
  31. __cacheline_aligned_in_smp DEFINE_SPINLOCK(vfsmount_lock);
  32. static int event;
  33. static struct list_head *mount_hashtable __read_mostly;
  34. static int hash_mask __read_mostly, hash_bits __read_mostly;
  35. static struct kmem_cache *mnt_cache __read_mostly;
  36. static struct rw_semaphore namespace_sem;
  37. /* /sys/fs */
  38. decl_subsys(fs, NULL, NULL);
  39. EXPORT_SYMBOL_GPL(fs_subsys);
  40. static inline unsigned long hash(struct vfsmount *mnt, struct dentry *dentry)
  41. {
  42. unsigned long tmp = ((unsigned long)mnt / L1_CACHE_BYTES);
  43. tmp += ((unsigned long)dentry / L1_CACHE_BYTES);
  44. tmp = tmp + (tmp >> hash_bits);
  45. return tmp & hash_mask;
  46. }
  47. struct vfsmount *alloc_vfsmnt(const char *name)
  48. {
  49. struct vfsmount *mnt = kmem_cache_zalloc(mnt_cache, GFP_KERNEL);
  50. if (mnt) {
  51. atomic_set(&mnt->mnt_count, 1);
  52. INIT_LIST_HEAD(&mnt->mnt_hash);
  53. INIT_LIST_HEAD(&mnt->mnt_child);
  54. INIT_LIST_HEAD(&mnt->mnt_mounts);
  55. INIT_LIST_HEAD(&mnt->mnt_list);
  56. INIT_LIST_HEAD(&mnt->mnt_expire);
  57. INIT_LIST_HEAD(&mnt->mnt_share);
  58. INIT_LIST_HEAD(&mnt->mnt_slave_list);
  59. INIT_LIST_HEAD(&mnt->mnt_slave);
  60. if (name) {
  61. int size = strlen(name) + 1;
  62. char *newname = kmalloc(size, GFP_KERNEL);
  63. if (newname) {
  64. memcpy(newname, name, size);
  65. mnt->mnt_devname = newname;
  66. }
  67. }
  68. }
  69. return mnt;
  70. }
  71. int simple_set_mnt(struct vfsmount *mnt, struct super_block *sb)
  72. {
  73. mnt->mnt_sb = sb;
  74. mnt->mnt_root = dget(sb->s_root);
  75. return 0;
  76. }
  77. EXPORT_SYMBOL(simple_set_mnt);
  78. void free_vfsmnt(struct vfsmount *mnt)
  79. {
  80. kfree(mnt->mnt_devname);
  81. kmem_cache_free(mnt_cache, mnt);
  82. }
  83. /*
  84. * find the first or last mount at @dentry on vfsmount @mnt depending on
  85. * @dir. If @dir is set return the first mount else return the last mount.
  86. */
  87. struct vfsmount *__lookup_mnt(struct vfsmount *mnt, struct dentry *dentry,
  88. int dir)
  89. {
  90. struct list_head *head = mount_hashtable + hash(mnt, dentry);
  91. struct list_head *tmp = head;
  92. struct vfsmount *p, *found = NULL;
  93. for (;;) {
  94. tmp = dir ? tmp->next : tmp->prev;
  95. p = NULL;
  96. if (tmp == head)
  97. break;
  98. p = list_entry(tmp, struct vfsmount, mnt_hash);
  99. if (p->mnt_parent == mnt && p->mnt_mountpoint == dentry) {
  100. found = p;
  101. break;
  102. }
  103. }
  104. return found;
  105. }
  106. /*
  107. * lookup_mnt increments the ref count before returning
  108. * the vfsmount struct.
  109. */
  110. struct vfsmount *lookup_mnt(struct vfsmount *mnt, struct dentry *dentry)
  111. {
  112. struct vfsmount *child_mnt;
  113. spin_lock(&vfsmount_lock);
  114. if ((child_mnt = __lookup_mnt(mnt, dentry, 1)))
  115. mntget(child_mnt);
  116. spin_unlock(&vfsmount_lock);
  117. return child_mnt;
  118. }
  119. static inline int check_mnt(struct vfsmount *mnt)
  120. {
  121. return mnt->mnt_ns == current->nsproxy->mnt_ns;
  122. }
  123. static void touch_mnt_namespace(struct mnt_namespace *ns)
  124. {
  125. if (ns) {
  126. ns->event = ++event;
  127. wake_up_interruptible(&ns->poll);
  128. }
  129. }
  130. static void __touch_mnt_namespace(struct mnt_namespace *ns)
  131. {
  132. if (ns && ns->event != event) {
  133. ns->event = event;
  134. wake_up_interruptible(&ns->poll);
  135. }
  136. }
  137. static void detach_mnt(struct vfsmount *mnt, struct nameidata *old_nd)
  138. {
  139. old_nd->dentry = mnt->mnt_mountpoint;
  140. old_nd->mnt = mnt->mnt_parent;
  141. mnt->mnt_parent = mnt;
  142. mnt->mnt_mountpoint = mnt->mnt_root;
  143. list_del_init(&mnt->mnt_child);
  144. list_del_init(&mnt->mnt_hash);
  145. old_nd->dentry->d_mounted--;
  146. }
  147. void mnt_set_mountpoint(struct vfsmount *mnt, struct dentry *dentry,
  148. struct vfsmount *child_mnt)
  149. {
  150. child_mnt->mnt_parent = mntget(mnt);
  151. child_mnt->mnt_mountpoint = dget(dentry);
  152. dentry->d_mounted++;
  153. }
  154. static void attach_mnt(struct vfsmount *mnt, struct nameidata *nd)
  155. {
  156. mnt_set_mountpoint(nd->mnt, nd->dentry, mnt);
  157. list_add_tail(&mnt->mnt_hash, mount_hashtable +
  158. hash(nd->mnt, nd->dentry));
  159. list_add_tail(&mnt->mnt_child, &nd->mnt->mnt_mounts);
  160. }
  161. /*
  162. * the caller must hold vfsmount_lock
  163. */
  164. static void commit_tree(struct vfsmount *mnt)
  165. {
  166. struct vfsmount *parent = mnt->mnt_parent;
  167. struct vfsmount *m;
  168. LIST_HEAD(head);
  169. struct mnt_namespace *n = parent->mnt_ns;
  170. BUG_ON(parent == mnt);
  171. list_add_tail(&head, &mnt->mnt_list);
  172. list_for_each_entry(m, &head, mnt_list)
  173. m->mnt_ns = n;
  174. list_splice(&head, n->list.prev);
  175. list_add_tail(&mnt->mnt_hash, mount_hashtable +
  176. hash(parent, mnt->mnt_mountpoint));
  177. list_add_tail(&mnt->mnt_child, &parent->mnt_mounts);
  178. touch_mnt_namespace(n);
  179. }
  180. static struct vfsmount *next_mnt(struct vfsmount *p, struct vfsmount *root)
  181. {
  182. struct list_head *next = p->mnt_mounts.next;
  183. if (next == &p->mnt_mounts) {
  184. while (1) {
  185. if (p == root)
  186. return NULL;
  187. next = p->mnt_child.next;
  188. if (next != &p->mnt_parent->mnt_mounts)
  189. break;
  190. p = p->mnt_parent;
  191. }
  192. }
  193. return list_entry(next, struct vfsmount, mnt_child);
  194. }
  195. static struct vfsmount *skip_mnt_tree(struct vfsmount *p)
  196. {
  197. struct list_head *prev = p->mnt_mounts.prev;
  198. while (prev != &p->mnt_mounts) {
  199. p = list_entry(prev, struct vfsmount, mnt_child);
  200. prev = p->mnt_mounts.prev;
  201. }
  202. return p;
  203. }
  204. static struct vfsmount *clone_mnt(struct vfsmount *old, struct dentry *root,
  205. int flag)
  206. {
  207. struct super_block *sb = old->mnt_sb;
  208. struct vfsmount *mnt = alloc_vfsmnt(old->mnt_devname);
  209. if (mnt) {
  210. mnt->mnt_flags = old->mnt_flags;
  211. atomic_inc(&sb->s_active);
  212. mnt->mnt_sb = sb;
  213. mnt->mnt_root = dget(root);
  214. mnt->mnt_mountpoint = mnt->mnt_root;
  215. mnt->mnt_parent = mnt;
  216. if (flag & CL_SLAVE) {
  217. list_add(&mnt->mnt_slave, &old->mnt_slave_list);
  218. mnt->mnt_master = old;
  219. CLEAR_MNT_SHARED(mnt);
  220. } else {
  221. if ((flag & CL_PROPAGATION) || IS_MNT_SHARED(old))
  222. list_add(&mnt->mnt_share, &old->mnt_share);
  223. if (IS_MNT_SLAVE(old))
  224. list_add(&mnt->mnt_slave, &old->mnt_slave);
  225. mnt->mnt_master = old->mnt_master;
  226. }
  227. if (flag & CL_MAKE_SHARED)
  228. set_mnt_shared(mnt);
  229. /* stick the duplicate mount on the same expiry list
  230. * as the original if that was on one */
  231. if (flag & CL_EXPIRE) {
  232. spin_lock(&vfsmount_lock);
  233. if (!list_empty(&old->mnt_expire))
  234. list_add(&mnt->mnt_expire, &old->mnt_expire);
  235. spin_unlock(&vfsmount_lock);
  236. }
  237. }
  238. return mnt;
  239. }
  240. static inline void __mntput(struct vfsmount *mnt)
  241. {
  242. struct super_block *sb = mnt->mnt_sb;
  243. dput(mnt->mnt_root);
  244. free_vfsmnt(mnt);
  245. deactivate_super(sb);
  246. }
  247. void mntput_no_expire(struct vfsmount *mnt)
  248. {
  249. repeat:
  250. if (atomic_dec_and_lock(&mnt->mnt_count, &vfsmount_lock)) {
  251. if (likely(!mnt->mnt_pinned)) {
  252. spin_unlock(&vfsmount_lock);
  253. __mntput(mnt);
  254. return;
  255. }
  256. atomic_add(mnt->mnt_pinned + 1, &mnt->mnt_count);
  257. mnt->mnt_pinned = 0;
  258. spin_unlock(&vfsmount_lock);
  259. acct_auto_close_mnt(mnt);
  260. security_sb_umount_close(mnt);
  261. goto repeat;
  262. }
  263. }
  264. EXPORT_SYMBOL(mntput_no_expire);
  265. void mnt_pin(struct vfsmount *mnt)
  266. {
  267. spin_lock(&vfsmount_lock);
  268. mnt->mnt_pinned++;
  269. spin_unlock(&vfsmount_lock);
  270. }
  271. EXPORT_SYMBOL(mnt_pin);
  272. void mnt_unpin(struct vfsmount *mnt)
  273. {
  274. spin_lock(&vfsmount_lock);
  275. if (mnt->mnt_pinned) {
  276. atomic_inc(&mnt->mnt_count);
  277. mnt->mnt_pinned--;
  278. }
  279. spin_unlock(&vfsmount_lock);
  280. }
  281. EXPORT_SYMBOL(mnt_unpin);
  282. /* iterator */
  283. static void *m_start(struct seq_file *m, loff_t *pos)
  284. {
  285. struct mnt_namespace *n = m->private;
  286. struct list_head *p;
  287. loff_t l = *pos;
  288. down_read(&namespace_sem);
  289. list_for_each(p, &n->list)
  290. if (!l--)
  291. return list_entry(p, struct vfsmount, mnt_list);
  292. return NULL;
  293. }
  294. static void *m_next(struct seq_file *m, void *v, loff_t *pos)
  295. {
  296. struct mnt_namespace *n = m->private;
  297. struct list_head *p = ((struct vfsmount *)v)->mnt_list.next;
  298. (*pos)++;
  299. return p == &n->list ? NULL : list_entry(p, struct vfsmount, mnt_list);
  300. }
  301. static void m_stop(struct seq_file *m, void *v)
  302. {
  303. up_read(&namespace_sem);
  304. }
  305. static inline void mangle(struct seq_file *m, const char *s)
  306. {
  307. seq_escape(m, s, " \t\n\\");
  308. }
  309. static int show_vfsmnt(struct seq_file *m, void *v)
  310. {
  311. struct vfsmount *mnt = v;
  312. int err = 0;
  313. static struct proc_fs_info {
  314. int flag;
  315. char *str;
  316. } fs_info[] = {
  317. { MS_SYNCHRONOUS, ",sync" },
  318. { MS_DIRSYNC, ",dirsync" },
  319. { MS_MANDLOCK, ",mand" },
  320. { 0, NULL }
  321. };
  322. static struct proc_fs_info mnt_info[] = {
  323. { MNT_NOSUID, ",nosuid" },
  324. { MNT_NODEV, ",nodev" },
  325. { MNT_NOEXEC, ",noexec" },
  326. { MNT_NOATIME, ",noatime" },
  327. { MNT_NODIRATIME, ",nodiratime" },
  328. { MNT_RELATIME, ",relatime" },
  329. { 0, NULL }
  330. };
  331. struct proc_fs_info *fs_infop;
  332. mangle(m, mnt->mnt_devname ? mnt->mnt_devname : "none");
  333. seq_putc(m, ' ');
  334. seq_path(m, mnt, mnt->mnt_root, " \t\n\\");
  335. seq_putc(m, ' ');
  336. mangle(m, mnt->mnt_sb->s_type->name);
  337. seq_puts(m, mnt->mnt_sb->s_flags & MS_RDONLY ? " ro" : " rw");
  338. for (fs_infop = fs_info; fs_infop->flag; fs_infop++) {
  339. if (mnt->mnt_sb->s_flags & fs_infop->flag)
  340. seq_puts(m, fs_infop->str);
  341. }
  342. for (fs_infop = mnt_info; fs_infop->flag; fs_infop++) {
  343. if (mnt->mnt_flags & fs_infop->flag)
  344. seq_puts(m, fs_infop->str);
  345. }
  346. if (mnt->mnt_sb->s_op->show_options)
  347. err = mnt->mnt_sb->s_op->show_options(m, mnt);
  348. seq_puts(m, " 0 0\n");
  349. return err;
  350. }
  351. struct seq_operations mounts_op = {
  352. .start = m_start,
  353. .next = m_next,
  354. .stop = m_stop,
  355. .show = show_vfsmnt
  356. };
  357. static int show_vfsstat(struct seq_file *m, void *v)
  358. {
  359. struct vfsmount *mnt = v;
  360. int err = 0;
  361. /* device */
  362. if (mnt->mnt_devname) {
  363. seq_puts(m, "device ");
  364. mangle(m, mnt->mnt_devname);
  365. } else
  366. seq_puts(m, "no device");
  367. /* mount point */
  368. seq_puts(m, " mounted on ");
  369. seq_path(m, mnt, mnt->mnt_root, " \t\n\\");
  370. seq_putc(m, ' ');
  371. /* file system type */
  372. seq_puts(m, "with fstype ");
  373. mangle(m, mnt->mnt_sb->s_type->name);
  374. /* optional statistics */
  375. if (mnt->mnt_sb->s_op->show_stats) {
  376. seq_putc(m, ' ');
  377. err = mnt->mnt_sb->s_op->show_stats(m, mnt);
  378. }
  379. seq_putc(m, '\n');
  380. return err;
  381. }
  382. struct seq_operations mountstats_op = {
  383. .start = m_start,
  384. .next = m_next,
  385. .stop = m_stop,
  386. .show = show_vfsstat,
  387. };
  388. /**
  389. * may_umount_tree - check if a mount tree is busy
  390. * @mnt: root of mount tree
  391. *
  392. * This is called to check if a tree of mounts has any
  393. * open files, pwds, chroots or sub mounts that are
  394. * busy.
  395. */
  396. int may_umount_tree(struct vfsmount *mnt)
  397. {
  398. int actual_refs = 0;
  399. int minimum_refs = 0;
  400. struct vfsmount *p;
  401. spin_lock(&vfsmount_lock);
  402. for (p = mnt; p; p = next_mnt(p, mnt)) {
  403. actual_refs += atomic_read(&p->mnt_count);
  404. minimum_refs += 2;
  405. }
  406. spin_unlock(&vfsmount_lock);
  407. if (actual_refs > minimum_refs)
  408. return 0;
  409. return 1;
  410. }
  411. EXPORT_SYMBOL(may_umount_tree);
  412. /**
  413. * may_umount - check if a mount point is busy
  414. * @mnt: root of mount
  415. *
  416. * This is called to check if a mount point has any
  417. * open files, pwds, chroots or sub mounts. If the
  418. * mount has sub mounts this will return busy
  419. * regardless of whether the sub mounts are busy.
  420. *
  421. * Doesn't take quota and stuff into account. IOW, in some cases it will
  422. * give false negatives. The main reason why it's here is that we need
  423. * a non-destructive way to look for easily umountable filesystems.
  424. */
  425. int may_umount(struct vfsmount *mnt)
  426. {
  427. int ret = 1;
  428. spin_lock(&vfsmount_lock);
  429. if (propagate_mount_busy(mnt, 2))
  430. ret = 0;
  431. spin_unlock(&vfsmount_lock);
  432. return ret;
  433. }
  434. EXPORT_SYMBOL(may_umount);
  435. void release_mounts(struct list_head *head)
  436. {
  437. struct vfsmount *mnt;
  438. while (!list_empty(head)) {
  439. mnt = list_entry(head->next, struct vfsmount, mnt_hash);
  440. list_del_init(&mnt->mnt_hash);
  441. if (mnt->mnt_parent != mnt) {
  442. struct dentry *dentry;
  443. struct vfsmount *m;
  444. spin_lock(&vfsmount_lock);
  445. dentry = mnt->mnt_mountpoint;
  446. m = mnt->mnt_parent;
  447. mnt->mnt_mountpoint = mnt->mnt_root;
  448. mnt->mnt_parent = mnt;
  449. spin_unlock(&vfsmount_lock);
  450. dput(dentry);
  451. mntput(m);
  452. }
  453. mntput(mnt);
  454. }
  455. }
  456. void umount_tree(struct vfsmount *mnt, int propagate, struct list_head *kill)
  457. {
  458. struct vfsmount *p;
  459. for (p = mnt; p; p = next_mnt(p, mnt))
  460. list_move(&p->mnt_hash, kill);
  461. if (propagate)
  462. propagate_umount(kill);
  463. list_for_each_entry(p, kill, mnt_hash) {
  464. list_del_init(&p->mnt_expire);
  465. list_del_init(&p->mnt_list);
  466. __touch_mnt_namespace(p->mnt_ns);
  467. p->mnt_ns = NULL;
  468. list_del_init(&p->mnt_child);
  469. if (p->mnt_parent != p)
  470. p->mnt_mountpoint->d_mounted--;
  471. change_mnt_propagation(p, MS_PRIVATE);
  472. }
  473. }
  474. static int do_umount(struct vfsmount *mnt, int flags)
  475. {
  476. struct super_block *sb = mnt->mnt_sb;
  477. int retval;
  478. LIST_HEAD(umount_list);
  479. retval = security_sb_umount(mnt, flags);
  480. if (retval)
  481. return retval;
  482. /*
  483. * Allow userspace to request a mountpoint be expired rather than
  484. * unmounting unconditionally. Unmount only happens if:
  485. * (1) the mark is already set (the mark is cleared by mntput())
  486. * (2) the usage count == 1 [parent vfsmount] + 1 [sys_umount]
  487. */
  488. if (flags & MNT_EXPIRE) {
  489. if (mnt == current->fs->rootmnt ||
  490. flags & (MNT_FORCE | MNT_DETACH))
  491. return -EINVAL;
  492. if (atomic_read(&mnt->mnt_count) != 2)
  493. return -EBUSY;
  494. if (!xchg(&mnt->mnt_expiry_mark, 1))
  495. return -EAGAIN;
  496. }
  497. /*
  498. * If we may have to abort operations to get out of this
  499. * mount, and they will themselves hold resources we must
  500. * allow the fs to do things. In the Unix tradition of
  501. * 'Gee thats tricky lets do it in userspace' the umount_begin
  502. * might fail to complete on the first run through as other tasks
  503. * must return, and the like. Thats for the mount program to worry
  504. * about for the moment.
  505. */
  506. lock_kernel();
  507. if (sb->s_op->umount_begin)
  508. sb->s_op->umount_begin(mnt, flags);
  509. unlock_kernel();
  510. /*
  511. * No sense to grab the lock for this test, but test itself looks
  512. * somewhat bogus. Suggestions for better replacement?
  513. * Ho-hum... In principle, we might treat that as umount + switch
  514. * to rootfs. GC would eventually take care of the old vfsmount.
  515. * Actually it makes sense, especially if rootfs would contain a
  516. * /reboot - static binary that would close all descriptors and
  517. * call reboot(9). Then init(8) could umount root and exec /reboot.
  518. */
  519. if (mnt == current->fs->rootmnt && !(flags & MNT_DETACH)) {
  520. /*
  521. * Special case for "unmounting" root ...
  522. * we just try to remount it readonly.
  523. */
  524. down_write(&sb->s_umount);
  525. if (!(sb->s_flags & MS_RDONLY)) {
  526. lock_kernel();
  527. DQUOT_OFF(sb);
  528. retval = do_remount_sb(sb, MS_RDONLY, NULL, 0);
  529. unlock_kernel();
  530. }
  531. up_write(&sb->s_umount);
  532. return retval;
  533. }
  534. down_write(&namespace_sem);
  535. spin_lock(&vfsmount_lock);
  536. event++;
  537. retval = -EBUSY;
  538. if (flags & MNT_DETACH || !propagate_mount_busy(mnt, 2)) {
  539. if (!list_empty(&mnt->mnt_list))
  540. umount_tree(mnt, 1, &umount_list);
  541. retval = 0;
  542. }
  543. spin_unlock(&vfsmount_lock);
  544. if (retval)
  545. security_sb_umount_busy(mnt);
  546. up_write(&namespace_sem);
  547. release_mounts(&umount_list);
  548. return retval;
  549. }
  550. /*
  551. * Now umount can handle mount points as well as block devices.
  552. * This is important for filesystems which use unnamed block devices.
  553. *
  554. * We now support a flag for forced unmount like the other 'big iron'
  555. * unixes. Our API is identical to OSF/1 to avoid making a mess of AMD
  556. */
  557. asmlinkage long sys_umount(char __user * name, int flags)
  558. {
  559. struct nameidata nd;
  560. int retval;
  561. retval = __user_walk(name, LOOKUP_FOLLOW, &nd);
  562. if (retval)
  563. goto out;
  564. retval = -EINVAL;
  565. if (nd.dentry != nd.mnt->mnt_root)
  566. goto dput_and_out;
  567. if (!check_mnt(nd.mnt))
  568. goto dput_and_out;
  569. retval = -EPERM;
  570. if (!capable(CAP_SYS_ADMIN))
  571. goto dput_and_out;
  572. retval = do_umount(nd.mnt, flags);
  573. dput_and_out:
  574. path_release_on_umount(&nd);
  575. out:
  576. return retval;
  577. }
  578. #ifdef __ARCH_WANT_SYS_OLDUMOUNT
  579. /*
  580. * The 2.0 compatible umount. No flags.
  581. */
  582. asmlinkage long sys_oldumount(char __user * name)
  583. {
  584. return sys_umount(name, 0);
  585. }
  586. #endif
  587. static int mount_is_safe(struct nameidata *nd)
  588. {
  589. if (capable(CAP_SYS_ADMIN))
  590. return 0;
  591. return -EPERM;
  592. #ifdef notyet
  593. if (S_ISLNK(nd->dentry->d_inode->i_mode))
  594. return -EPERM;
  595. if (nd->dentry->d_inode->i_mode & S_ISVTX) {
  596. if (current->uid != nd->dentry->d_inode->i_uid)
  597. return -EPERM;
  598. }
  599. if (vfs_permission(nd, MAY_WRITE))
  600. return -EPERM;
  601. return 0;
  602. #endif
  603. }
  604. static int lives_below_in_same_fs(struct dentry *d, struct dentry *dentry)
  605. {
  606. while (1) {
  607. if (d == dentry)
  608. return 1;
  609. if (d == NULL || d == d->d_parent)
  610. return 0;
  611. d = d->d_parent;
  612. }
  613. }
  614. struct vfsmount *copy_tree(struct vfsmount *mnt, struct dentry *dentry,
  615. int flag)
  616. {
  617. struct vfsmount *res, *p, *q, *r, *s;
  618. struct nameidata nd;
  619. if (!(flag & CL_COPY_ALL) && IS_MNT_UNBINDABLE(mnt))
  620. return NULL;
  621. res = q = clone_mnt(mnt, dentry, flag);
  622. if (!q)
  623. goto Enomem;
  624. q->mnt_mountpoint = mnt->mnt_mountpoint;
  625. p = mnt;
  626. list_for_each_entry(r, &mnt->mnt_mounts, mnt_child) {
  627. if (!lives_below_in_same_fs(r->mnt_mountpoint, dentry))
  628. continue;
  629. for (s = r; s; s = next_mnt(s, r)) {
  630. if (!(flag & CL_COPY_ALL) && IS_MNT_UNBINDABLE(s)) {
  631. s = skip_mnt_tree(s);
  632. continue;
  633. }
  634. while (p != s->mnt_parent) {
  635. p = p->mnt_parent;
  636. q = q->mnt_parent;
  637. }
  638. p = s;
  639. nd.mnt = q;
  640. nd.dentry = p->mnt_mountpoint;
  641. q = clone_mnt(p, p->mnt_root, flag);
  642. if (!q)
  643. goto Enomem;
  644. spin_lock(&vfsmount_lock);
  645. list_add_tail(&q->mnt_list, &res->mnt_list);
  646. attach_mnt(q, &nd);
  647. spin_unlock(&vfsmount_lock);
  648. }
  649. }
  650. return res;
  651. Enomem:
  652. if (res) {
  653. LIST_HEAD(umount_list);
  654. spin_lock(&vfsmount_lock);
  655. umount_tree(res, 0, &umount_list);
  656. spin_unlock(&vfsmount_lock);
  657. release_mounts(&umount_list);
  658. }
  659. return NULL;
  660. }
  661. /*
  662. * @source_mnt : mount tree to be attached
  663. * @nd : place the mount tree @source_mnt is attached
  664. * @parent_nd : if non-null, detach the source_mnt from its parent and
  665. * store the parent mount and mountpoint dentry.
  666. * (done when source_mnt is moved)
  667. *
  668. * NOTE: in the table below explains the semantics when a source mount
  669. * of a given type is attached to a destination mount of a given type.
  670. * ---------------------------------------------------------------------------
  671. * | BIND MOUNT OPERATION |
  672. * |**************************************************************************
  673. * | source-->| shared | private | slave | unbindable |
  674. * | dest | | | | |
  675. * | | | | | | |
  676. * | v | | | | |
  677. * |**************************************************************************
  678. * | shared | shared (++) | shared (+) | shared(+++)| invalid |
  679. * | | | | | |
  680. * |non-shared| shared (+) | private | slave (*) | invalid |
  681. * ***************************************************************************
  682. * A bind operation clones the source mount and mounts the clone on the
  683. * destination mount.
  684. *
  685. * (++) the cloned mount is propagated to all the mounts in the propagation
  686. * tree of the destination mount and the cloned mount is added to
  687. * the peer group of the source mount.
  688. * (+) the cloned mount is created under the destination mount and is marked
  689. * as shared. The cloned mount is added to the peer group of the source
  690. * mount.
  691. * (+++) the mount is propagated to all the mounts in the propagation tree
  692. * of the destination mount and the cloned mount is made slave
  693. * of the same master as that of the source mount. The cloned mount
  694. * is marked as 'shared and slave'.
  695. * (*) the cloned mount is made a slave of the same master as that of the
  696. * source mount.
  697. *
  698. * ---------------------------------------------------------------------------
  699. * | MOVE MOUNT OPERATION |
  700. * |**************************************************************************
  701. * | source-->| shared | private | slave | unbindable |
  702. * | dest | | | | |
  703. * | | | | | | |
  704. * | v | | | | |
  705. * |**************************************************************************
  706. * | shared | shared (+) | shared (+) | shared(+++) | invalid |
  707. * | | | | | |
  708. * |non-shared| shared (+*) | private | slave (*) | unbindable |
  709. * ***************************************************************************
  710. *
  711. * (+) the mount is moved to the destination. And is then propagated to
  712. * all the mounts in the propagation tree of the destination mount.
  713. * (+*) the mount is moved to the destination.
  714. * (+++) the mount is moved to the destination and is then propagated to
  715. * all the mounts belonging to the destination mount's propagation tree.
  716. * the mount is marked as 'shared and slave'.
  717. * (*) the mount continues to be a slave at the new location.
  718. *
  719. * if the source mount is a tree, the operations explained above is
  720. * applied to each mount in the tree.
  721. * Must be called without spinlocks held, since this function can sleep
  722. * in allocations.
  723. */
  724. static int attach_recursive_mnt(struct vfsmount *source_mnt,
  725. struct nameidata *nd, struct nameidata *parent_nd)
  726. {
  727. LIST_HEAD(tree_list);
  728. struct vfsmount *dest_mnt = nd->mnt;
  729. struct dentry *dest_dentry = nd->dentry;
  730. struct vfsmount *child, *p;
  731. if (propagate_mnt(dest_mnt, dest_dentry, source_mnt, &tree_list))
  732. return -EINVAL;
  733. if (IS_MNT_SHARED(dest_mnt)) {
  734. for (p = source_mnt; p; p = next_mnt(p, source_mnt))
  735. set_mnt_shared(p);
  736. }
  737. spin_lock(&vfsmount_lock);
  738. if (parent_nd) {
  739. detach_mnt(source_mnt, parent_nd);
  740. attach_mnt(source_mnt, nd);
  741. touch_mnt_namespace(current->nsproxy->mnt_ns);
  742. } else {
  743. mnt_set_mountpoint(dest_mnt, dest_dentry, source_mnt);
  744. commit_tree(source_mnt);
  745. }
  746. list_for_each_entry_safe(child, p, &tree_list, mnt_hash) {
  747. list_del_init(&child->mnt_hash);
  748. commit_tree(child);
  749. }
  750. spin_unlock(&vfsmount_lock);
  751. return 0;
  752. }
  753. static int graft_tree(struct vfsmount *mnt, struct nameidata *nd)
  754. {
  755. int err;
  756. if (mnt->mnt_sb->s_flags & MS_NOUSER)
  757. return -EINVAL;
  758. if (S_ISDIR(nd->dentry->d_inode->i_mode) !=
  759. S_ISDIR(mnt->mnt_root->d_inode->i_mode))
  760. return -ENOTDIR;
  761. err = -ENOENT;
  762. mutex_lock(&nd->dentry->d_inode->i_mutex);
  763. if (IS_DEADDIR(nd->dentry->d_inode))
  764. goto out_unlock;
  765. err = security_sb_check_sb(mnt, nd);
  766. if (err)
  767. goto out_unlock;
  768. err = -ENOENT;
  769. if (IS_ROOT(nd->dentry) || !d_unhashed(nd->dentry))
  770. err = attach_recursive_mnt(mnt, nd, NULL);
  771. out_unlock:
  772. mutex_unlock(&nd->dentry->d_inode->i_mutex);
  773. if (!err)
  774. security_sb_post_addmount(mnt, nd);
  775. return err;
  776. }
  777. /*
  778. * recursively change the type of the mountpoint.
  779. */
  780. static int do_change_type(struct nameidata *nd, int flag)
  781. {
  782. struct vfsmount *m, *mnt = nd->mnt;
  783. int recurse = flag & MS_REC;
  784. int type = flag & ~MS_REC;
  785. if (nd->dentry != nd->mnt->mnt_root)
  786. return -EINVAL;
  787. down_write(&namespace_sem);
  788. spin_lock(&vfsmount_lock);
  789. for (m = mnt; m; m = (recurse ? next_mnt(m, mnt) : NULL))
  790. change_mnt_propagation(m, type);
  791. spin_unlock(&vfsmount_lock);
  792. up_write(&namespace_sem);
  793. return 0;
  794. }
  795. /*
  796. * do loopback mount.
  797. */
  798. static int do_loopback(struct nameidata *nd, char *old_name, int recurse)
  799. {
  800. struct nameidata old_nd;
  801. struct vfsmount *mnt = NULL;
  802. int err = mount_is_safe(nd);
  803. if (err)
  804. return err;
  805. if (!old_name || !*old_name)
  806. return -EINVAL;
  807. err = path_lookup(old_name, LOOKUP_FOLLOW, &old_nd);
  808. if (err)
  809. return err;
  810. down_write(&namespace_sem);
  811. err = -EINVAL;
  812. if (IS_MNT_UNBINDABLE(old_nd.mnt))
  813. goto out;
  814. if (!check_mnt(nd->mnt) || !check_mnt(old_nd.mnt))
  815. goto out;
  816. err = -ENOMEM;
  817. if (recurse)
  818. mnt = copy_tree(old_nd.mnt, old_nd.dentry, 0);
  819. else
  820. mnt = clone_mnt(old_nd.mnt, old_nd.dentry, 0);
  821. if (!mnt)
  822. goto out;
  823. err = graft_tree(mnt, nd);
  824. if (err) {
  825. LIST_HEAD(umount_list);
  826. spin_lock(&vfsmount_lock);
  827. umount_tree(mnt, 0, &umount_list);
  828. spin_unlock(&vfsmount_lock);
  829. release_mounts(&umount_list);
  830. }
  831. out:
  832. up_write(&namespace_sem);
  833. path_release(&old_nd);
  834. return err;
  835. }
  836. /*
  837. * change filesystem flags. dir should be a physical root of filesystem.
  838. * If you've mounted a non-root directory somewhere and want to do remount
  839. * on it - tough luck.
  840. */
  841. static int do_remount(struct nameidata *nd, int flags, int mnt_flags,
  842. void *data)
  843. {
  844. int err;
  845. struct super_block *sb = nd->mnt->mnt_sb;
  846. if (!capable(CAP_SYS_ADMIN))
  847. return -EPERM;
  848. if (!check_mnt(nd->mnt))
  849. return -EINVAL;
  850. if (nd->dentry != nd->mnt->mnt_root)
  851. return -EINVAL;
  852. down_write(&sb->s_umount);
  853. err = do_remount_sb(sb, flags, data, 0);
  854. if (!err)
  855. nd->mnt->mnt_flags = mnt_flags;
  856. up_write(&sb->s_umount);
  857. if (!err)
  858. security_sb_post_remount(nd->mnt, flags, data);
  859. return err;
  860. }
  861. static inline int tree_contains_unbindable(struct vfsmount *mnt)
  862. {
  863. struct vfsmount *p;
  864. for (p = mnt; p; p = next_mnt(p, mnt)) {
  865. if (IS_MNT_UNBINDABLE(p))
  866. return 1;
  867. }
  868. return 0;
  869. }
  870. static int do_move_mount(struct nameidata *nd, char *old_name)
  871. {
  872. struct nameidata old_nd, parent_nd;
  873. struct vfsmount *p;
  874. int err = 0;
  875. if (!capable(CAP_SYS_ADMIN))
  876. return -EPERM;
  877. if (!old_name || !*old_name)
  878. return -EINVAL;
  879. err = path_lookup(old_name, LOOKUP_FOLLOW, &old_nd);
  880. if (err)
  881. return err;
  882. down_write(&namespace_sem);
  883. while (d_mountpoint(nd->dentry) && follow_down(&nd->mnt, &nd->dentry))
  884. ;
  885. err = -EINVAL;
  886. if (!check_mnt(nd->mnt) || !check_mnt(old_nd.mnt))
  887. goto out;
  888. err = -ENOENT;
  889. mutex_lock(&nd->dentry->d_inode->i_mutex);
  890. if (IS_DEADDIR(nd->dentry->d_inode))
  891. goto out1;
  892. if (!IS_ROOT(nd->dentry) && d_unhashed(nd->dentry))
  893. goto out1;
  894. err = -EINVAL;
  895. if (old_nd.dentry != old_nd.mnt->mnt_root)
  896. goto out1;
  897. if (old_nd.mnt == old_nd.mnt->mnt_parent)
  898. goto out1;
  899. if (S_ISDIR(nd->dentry->d_inode->i_mode) !=
  900. S_ISDIR(old_nd.dentry->d_inode->i_mode))
  901. goto out1;
  902. /*
  903. * Don't move a mount residing in a shared parent.
  904. */
  905. if (old_nd.mnt->mnt_parent && IS_MNT_SHARED(old_nd.mnt->mnt_parent))
  906. goto out1;
  907. /*
  908. * Don't move a mount tree containing unbindable mounts to a destination
  909. * mount which is shared.
  910. */
  911. if (IS_MNT_SHARED(nd->mnt) && tree_contains_unbindable(old_nd.mnt))
  912. goto out1;
  913. err = -ELOOP;
  914. for (p = nd->mnt; p->mnt_parent != p; p = p->mnt_parent)
  915. if (p == old_nd.mnt)
  916. goto out1;
  917. if ((err = attach_recursive_mnt(old_nd.mnt, nd, &parent_nd)))
  918. goto out1;
  919. spin_lock(&vfsmount_lock);
  920. /* if the mount is moved, it should no longer be expire
  921. * automatically */
  922. list_del_init(&old_nd.mnt->mnt_expire);
  923. spin_unlock(&vfsmount_lock);
  924. out1:
  925. mutex_unlock(&nd->dentry->d_inode->i_mutex);
  926. out:
  927. up_write(&namespace_sem);
  928. if (!err)
  929. path_release(&parent_nd);
  930. path_release(&old_nd);
  931. return err;
  932. }
  933. /*
  934. * create a new mount for userspace and request it to be added into the
  935. * namespace's tree
  936. */
  937. static int do_new_mount(struct nameidata *nd, char *type, int flags,
  938. int mnt_flags, char *name, void *data)
  939. {
  940. struct vfsmount *mnt;
  941. if (!type || !memchr(type, 0, PAGE_SIZE))
  942. return -EINVAL;
  943. /* we need capabilities... */
  944. if (!capable(CAP_SYS_ADMIN))
  945. return -EPERM;
  946. mnt = do_kern_mount(type, flags, name, data);
  947. if (IS_ERR(mnt))
  948. return PTR_ERR(mnt);
  949. return do_add_mount(mnt, nd, mnt_flags, NULL);
  950. }
  951. /*
  952. * add a mount into a namespace's mount tree
  953. * - provide the option of adding the new mount to an expiration list
  954. */
  955. int do_add_mount(struct vfsmount *newmnt, struct nameidata *nd,
  956. int mnt_flags, struct list_head *fslist)
  957. {
  958. int err;
  959. down_write(&namespace_sem);
  960. /* Something was mounted here while we slept */
  961. while (d_mountpoint(nd->dentry) && follow_down(&nd->mnt, &nd->dentry))
  962. ;
  963. err = -EINVAL;
  964. if (!check_mnt(nd->mnt))
  965. goto unlock;
  966. /* Refuse the same filesystem on the same mount point */
  967. err = -EBUSY;
  968. if (nd->mnt->mnt_sb == newmnt->mnt_sb &&
  969. nd->mnt->mnt_root == nd->dentry)
  970. goto unlock;
  971. err = -EINVAL;
  972. if (S_ISLNK(newmnt->mnt_root->d_inode->i_mode))
  973. goto unlock;
  974. newmnt->mnt_flags = mnt_flags;
  975. if ((err = graft_tree(newmnt, nd)))
  976. goto unlock;
  977. if (fslist) {
  978. /* add to the specified expiration list */
  979. spin_lock(&vfsmount_lock);
  980. list_add_tail(&newmnt->mnt_expire, fslist);
  981. spin_unlock(&vfsmount_lock);
  982. }
  983. up_write(&namespace_sem);
  984. return 0;
  985. unlock:
  986. up_write(&namespace_sem);
  987. mntput(newmnt);
  988. return err;
  989. }
  990. EXPORT_SYMBOL_GPL(do_add_mount);
  991. static void expire_mount(struct vfsmount *mnt, struct list_head *mounts,
  992. struct list_head *umounts)
  993. {
  994. spin_lock(&vfsmount_lock);
  995. /*
  996. * Check if mount is still attached, if not, let whoever holds it deal
  997. * with the sucker
  998. */
  999. if (mnt->mnt_parent == mnt) {
  1000. spin_unlock(&vfsmount_lock);
  1001. return;
  1002. }
  1003. /*
  1004. * Check that it is still dead: the count should now be 2 - as
  1005. * contributed by the vfsmount parent and the mntget above
  1006. */
  1007. if (!propagate_mount_busy(mnt, 2)) {
  1008. /* delete from the namespace */
  1009. touch_mnt_namespace(mnt->mnt_ns);
  1010. list_del_init(&mnt->mnt_list);
  1011. mnt->mnt_ns = NULL;
  1012. umount_tree(mnt, 1, umounts);
  1013. spin_unlock(&vfsmount_lock);
  1014. } else {
  1015. /*
  1016. * Someone brought it back to life whilst we didn't have any
  1017. * locks held so return it to the expiration list
  1018. */
  1019. list_add_tail(&mnt->mnt_expire, mounts);
  1020. spin_unlock(&vfsmount_lock);
  1021. }
  1022. }
  1023. /*
  1024. * go through the vfsmounts we've just consigned to the graveyard to
  1025. * - check that they're still dead
  1026. * - delete the vfsmount from the appropriate namespace under lock
  1027. * - dispose of the corpse
  1028. */
  1029. static void expire_mount_list(struct list_head *graveyard, struct list_head *mounts)
  1030. {
  1031. struct mnt_namespace *ns;
  1032. struct vfsmount *mnt;
  1033. while (!list_empty(graveyard)) {
  1034. LIST_HEAD(umounts);
  1035. mnt = list_entry(graveyard->next, struct vfsmount, mnt_expire);
  1036. list_del_init(&mnt->mnt_expire);
  1037. /* don't do anything if the namespace is dead - all the
  1038. * vfsmounts from it are going away anyway */
  1039. ns = mnt->mnt_ns;
  1040. if (!ns || !ns->root)
  1041. continue;
  1042. get_mnt_ns(ns);
  1043. spin_unlock(&vfsmount_lock);
  1044. down_write(&namespace_sem);
  1045. expire_mount(mnt, mounts, &umounts);
  1046. up_write(&namespace_sem);
  1047. release_mounts(&umounts);
  1048. mntput(mnt);
  1049. put_mnt_ns(ns);
  1050. spin_lock(&vfsmount_lock);
  1051. }
  1052. }
  1053. /*
  1054. * process a list of expirable mountpoints with the intent of discarding any
  1055. * mountpoints that aren't in use and haven't been touched since last we came
  1056. * here
  1057. */
  1058. void mark_mounts_for_expiry(struct list_head *mounts)
  1059. {
  1060. struct vfsmount *mnt, *next;
  1061. LIST_HEAD(graveyard);
  1062. if (list_empty(mounts))
  1063. return;
  1064. spin_lock(&vfsmount_lock);
  1065. /* extract from the expiration list every vfsmount that matches the
  1066. * following criteria:
  1067. * - only referenced by its parent vfsmount
  1068. * - still marked for expiry (marked on the last call here; marks are
  1069. * cleared by mntput())
  1070. */
  1071. list_for_each_entry_safe(mnt, next, mounts, mnt_expire) {
  1072. if (!xchg(&mnt->mnt_expiry_mark, 1) ||
  1073. atomic_read(&mnt->mnt_count) != 1)
  1074. continue;
  1075. mntget(mnt);
  1076. list_move(&mnt->mnt_expire, &graveyard);
  1077. }
  1078. expire_mount_list(&graveyard, mounts);
  1079. spin_unlock(&vfsmount_lock);
  1080. }
  1081. EXPORT_SYMBOL_GPL(mark_mounts_for_expiry);
  1082. /*
  1083. * Ripoff of 'select_parent()'
  1084. *
  1085. * search the list of submounts for a given mountpoint, and move any
  1086. * shrinkable submounts to the 'graveyard' list.
  1087. */
  1088. static int select_submounts(struct vfsmount *parent, struct list_head *graveyard)
  1089. {
  1090. struct vfsmount *this_parent = parent;
  1091. struct list_head *next;
  1092. int found = 0;
  1093. repeat:
  1094. next = this_parent->mnt_mounts.next;
  1095. resume:
  1096. while (next != &this_parent->mnt_mounts) {
  1097. struct list_head *tmp = next;
  1098. struct vfsmount *mnt = list_entry(tmp, struct vfsmount, mnt_child);
  1099. next = tmp->next;
  1100. if (!(mnt->mnt_flags & MNT_SHRINKABLE))
  1101. continue;
  1102. /*
  1103. * Descend a level if the d_mounts list is non-empty.
  1104. */
  1105. if (!list_empty(&mnt->mnt_mounts)) {
  1106. this_parent = mnt;
  1107. goto repeat;
  1108. }
  1109. if (!propagate_mount_busy(mnt, 1)) {
  1110. mntget(mnt);
  1111. list_move_tail(&mnt->mnt_expire, graveyard);
  1112. found++;
  1113. }
  1114. }
  1115. /*
  1116. * All done at this level ... ascend and resume the search
  1117. */
  1118. if (this_parent != parent) {
  1119. next = this_parent->mnt_child.next;
  1120. this_parent = this_parent->mnt_parent;
  1121. goto resume;
  1122. }
  1123. return found;
  1124. }
  1125. /*
  1126. * process a list of expirable mountpoints with the intent of discarding any
  1127. * submounts of a specific parent mountpoint
  1128. */
  1129. void shrink_submounts(struct vfsmount *mountpoint, struct list_head *mounts)
  1130. {
  1131. LIST_HEAD(graveyard);
  1132. int found;
  1133. spin_lock(&vfsmount_lock);
  1134. /* extract submounts of 'mountpoint' from the expiration list */
  1135. while ((found = select_submounts(mountpoint, &graveyard)) != 0)
  1136. expire_mount_list(&graveyard, mounts);
  1137. spin_unlock(&vfsmount_lock);
  1138. }
  1139. EXPORT_SYMBOL_GPL(shrink_submounts);
  1140. /*
  1141. * Some copy_from_user() implementations do not return the exact number of
  1142. * bytes remaining to copy on a fault. But copy_mount_options() requires that.
  1143. * Note that this function differs from copy_from_user() in that it will oops
  1144. * on bad values of `to', rather than returning a short copy.
  1145. */
  1146. static long exact_copy_from_user(void *to, const void __user * from,
  1147. unsigned long n)
  1148. {
  1149. char *t = to;
  1150. const char __user *f = from;
  1151. char c;
  1152. if (!access_ok(VERIFY_READ, from, n))
  1153. return n;
  1154. while (n) {
  1155. if (__get_user(c, f)) {
  1156. memset(t, 0, n);
  1157. break;
  1158. }
  1159. *t++ = c;
  1160. f++;
  1161. n--;
  1162. }
  1163. return n;
  1164. }
  1165. int copy_mount_options(const void __user * data, unsigned long *where)
  1166. {
  1167. int i;
  1168. unsigned long page;
  1169. unsigned long size;
  1170. *where = 0;
  1171. if (!data)
  1172. return 0;
  1173. if (!(page = __get_free_page(GFP_KERNEL)))
  1174. return -ENOMEM;
  1175. /* We only care that *some* data at the address the user
  1176. * gave us is valid. Just in case, we'll zero
  1177. * the remainder of the page.
  1178. */
  1179. /* copy_from_user cannot cross TASK_SIZE ! */
  1180. size = TASK_SIZE - (unsigned long)data;
  1181. if (size > PAGE_SIZE)
  1182. size = PAGE_SIZE;
  1183. i = size - exact_copy_from_user((void *)page, data, size);
  1184. if (!i) {
  1185. free_page(page);
  1186. return -EFAULT;
  1187. }
  1188. if (i != PAGE_SIZE)
  1189. memset((char *)page + i, 0, PAGE_SIZE - i);
  1190. *where = page;
  1191. return 0;
  1192. }
  1193. /*
  1194. * Flags is a 32-bit value that allows up to 31 non-fs dependent flags to
  1195. * be given to the mount() call (ie: read-only, no-dev, no-suid etc).
  1196. *
  1197. * data is a (void *) that can point to any structure up to
  1198. * PAGE_SIZE-1 bytes, which can contain arbitrary fs-dependent
  1199. * information (or be NULL).
  1200. *
  1201. * Pre-0.97 versions of mount() didn't have a flags word.
  1202. * When the flags word was introduced its top half was required
  1203. * to have the magic value 0xC0ED, and this remained so until 2.4.0-test9.
  1204. * Therefore, if this magic number is present, it carries no information
  1205. * and must be discarded.
  1206. */
  1207. long do_mount(char *dev_name, char *dir_name, char *type_page,
  1208. unsigned long flags, void *data_page)
  1209. {
  1210. struct nameidata nd;
  1211. int retval = 0;
  1212. int mnt_flags = 0;
  1213. /* Discard magic */
  1214. if ((flags & MS_MGC_MSK) == MS_MGC_VAL)
  1215. flags &= ~MS_MGC_MSK;
  1216. /* Basic sanity checks */
  1217. if (!dir_name || !*dir_name || !memchr(dir_name, 0, PAGE_SIZE))
  1218. return -EINVAL;
  1219. if (dev_name && !memchr(dev_name, 0, PAGE_SIZE))
  1220. return -EINVAL;
  1221. if (data_page)
  1222. ((char *)data_page)[PAGE_SIZE - 1] = 0;
  1223. /* Separate the per-mountpoint flags */
  1224. if (flags & MS_NOSUID)
  1225. mnt_flags |= MNT_NOSUID;
  1226. if (flags & MS_NODEV)
  1227. mnt_flags |= MNT_NODEV;
  1228. if (flags & MS_NOEXEC)
  1229. mnt_flags |= MNT_NOEXEC;
  1230. if (flags & MS_NOATIME)
  1231. mnt_flags |= MNT_NOATIME;
  1232. if (flags & MS_NODIRATIME)
  1233. mnt_flags |= MNT_NODIRATIME;
  1234. if (flags & MS_RELATIME)
  1235. mnt_flags |= MNT_RELATIME;
  1236. flags &= ~(MS_NOSUID | MS_NOEXEC | MS_NODEV | MS_ACTIVE |
  1237. MS_NOATIME | MS_NODIRATIME | MS_RELATIME);
  1238. /* ... and get the mountpoint */
  1239. retval = path_lookup(dir_name, LOOKUP_FOLLOW, &nd);
  1240. if (retval)
  1241. return retval;
  1242. retval = security_sb_mount(dev_name, &nd, type_page, flags, data_page);
  1243. if (retval)
  1244. goto dput_out;
  1245. if (flags & MS_REMOUNT)
  1246. retval = do_remount(&nd, flags & ~MS_REMOUNT, mnt_flags,
  1247. data_page);
  1248. else if (flags & MS_BIND)
  1249. retval = do_loopback(&nd, dev_name, flags & MS_REC);
  1250. else if (flags & (MS_SHARED | MS_PRIVATE | MS_SLAVE | MS_UNBINDABLE))
  1251. retval = do_change_type(&nd, flags);
  1252. else if (flags & MS_MOVE)
  1253. retval = do_move_mount(&nd, dev_name);
  1254. else
  1255. retval = do_new_mount(&nd, type_page, flags, mnt_flags,
  1256. dev_name, data_page);
  1257. dput_out:
  1258. path_release(&nd);
  1259. return retval;
  1260. }
  1261. /*
  1262. * Allocate a new namespace structure and populate it with contents
  1263. * copied from the namespace of the passed in task structure.
  1264. */
  1265. struct mnt_namespace *dup_mnt_ns(struct task_struct *tsk,
  1266. struct fs_struct *fs)
  1267. {
  1268. struct mnt_namespace *mnt_ns = tsk->nsproxy->mnt_ns;
  1269. struct mnt_namespace *new_ns;
  1270. struct vfsmount *rootmnt = NULL, *pwdmnt = NULL, *altrootmnt = NULL;
  1271. struct vfsmount *p, *q;
  1272. new_ns = kmalloc(sizeof(struct mnt_namespace), GFP_KERNEL);
  1273. if (!new_ns)
  1274. return NULL;
  1275. atomic_set(&new_ns->count, 1);
  1276. INIT_LIST_HEAD(&new_ns->list);
  1277. init_waitqueue_head(&new_ns->poll);
  1278. new_ns->event = 0;
  1279. down_write(&namespace_sem);
  1280. /* First pass: copy the tree topology */
  1281. new_ns->root = copy_tree(mnt_ns->root, mnt_ns->root->mnt_root,
  1282. CL_COPY_ALL | CL_EXPIRE);
  1283. if (!new_ns->root) {
  1284. up_write(&namespace_sem);
  1285. kfree(new_ns);
  1286. return NULL;
  1287. }
  1288. spin_lock(&vfsmount_lock);
  1289. list_add_tail(&new_ns->list, &new_ns->root->mnt_list);
  1290. spin_unlock(&vfsmount_lock);
  1291. /*
  1292. * Second pass: switch the tsk->fs->* elements and mark new vfsmounts
  1293. * as belonging to new namespace. We have already acquired a private
  1294. * fs_struct, so tsk->fs->lock is not needed.
  1295. */
  1296. p = mnt_ns->root;
  1297. q = new_ns->root;
  1298. while (p) {
  1299. q->mnt_ns = new_ns;
  1300. if (fs) {
  1301. if (p == fs->rootmnt) {
  1302. rootmnt = p;
  1303. fs->rootmnt = mntget(q);
  1304. }
  1305. if (p == fs->pwdmnt) {
  1306. pwdmnt = p;
  1307. fs->pwdmnt = mntget(q);
  1308. }
  1309. if (p == fs->altrootmnt) {
  1310. altrootmnt = p;
  1311. fs->altrootmnt = mntget(q);
  1312. }
  1313. }
  1314. p = next_mnt(p, mnt_ns->root);
  1315. q = next_mnt(q, new_ns->root);
  1316. }
  1317. up_write(&namespace_sem);
  1318. if (rootmnt)
  1319. mntput(rootmnt);
  1320. if (pwdmnt)
  1321. mntput(pwdmnt);
  1322. if (altrootmnt)
  1323. mntput(altrootmnt);
  1324. return new_ns;
  1325. }
  1326. int copy_mnt_ns(int flags, struct task_struct *tsk)
  1327. {
  1328. struct mnt_namespace *ns = tsk->nsproxy->mnt_ns;
  1329. struct mnt_namespace *new_ns;
  1330. int err = 0;
  1331. if (!ns)
  1332. return 0;
  1333. get_mnt_ns(ns);
  1334. if (!(flags & CLONE_NEWNS))
  1335. return 0;
  1336. if (!capable(CAP_SYS_ADMIN)) {
  1337. err = -EPERM;
  1338. goto out;
  1339. }
  1340. new_ns = dup_mnt_ns(tsk, tsk->fs);
  1341. if (!new_ns) {
  1342. err = -ENOMEM;
  1343. goto out;
  1344. }
  1345. tsk->nsproxy->mnt_ns = new_ns;
  1346. out:
  1347. put_mnt_ns(ns);
  1348. return err;
  1349. }
  1350. asmlinkage long sys_mount(char __user * dev_name, char __user * dir_name,
  1351. char __user * type, unsigned long flags,
  1352. void __user * data)
  1353. {
  1354. int retval;
  1355. unsigned long data_page;
  1356. unsigned long type_page;
  1357. unsigned long dev_page;
  1358. char *dir_page;
  1359. retval = copy_mount_options(type, &type_page);
  1360. if (retval < 0)
  1361. return retval;
  1362. dir_page = getname(dir_name);
  1363. retval = PTR_ERR(dir_page);
  1364. if (IS_ERR(dir_page))
  1365. goto out1;
  1366. retval = copy_mount_options(dev_name, &dev_page);
  1367. if (retval < 0)
  1368. goto out2;
  1369. retval = copy_mount_options(data, &data_page);
  1370. if (retval < 0)
  1371. goto out3;
  1372. lock_kernel();
  1373. retval = do_mount((char *)dev_page, dir_page, (char *)type_page,
  1374. flags, (void *)data_page);
  1375. unlock_kernel();
  1376. free_page(data_page);
  1377. out3:
  1378. free_page(dev_page);
  1379. out2:
  1380. putname(dir_page);
  1381. out1:
  1382. free_page(type_page);
  1383. return retval;
  1384. }
  1385. /*
  1386. * Replace the fs->{rootmnt,root} with {mnt,dentry}. Put the old values.
  1387. * It can block. Requires the big lock held.
  1388. */
  1389. void set_fs_root(struct fs_struct *fs, struct vfsmount *mnt,
  1390. struct dentry *dentry)
  1391. {
  1392. struct dentry *old_root;
  1393. struct vfsmount *old_rootmnt;
  1394. write_lock(&fs->lock);
  1395. old_root = fs->root;
  1396. old_rootmnt = fs->rootmnt;
  1397. fs->rootmnt = mntget(mnt);
  1398. fs->root = dget(dentry);
  1399. write_unlock(&fs->lock);
  1400. if (old_root) {
  1401. dput(old_root);
  1402. mntput(old_rootmnt);
  1403. }
  1404. }
  1405. /*
  1406. * Replace the fs->{pwdmnt,pwd} with {mnt,dentry}. Put the old values.
  1407. * It can block. Requires the big lock held.
  1408. */
  1409. void set_fs_pwd(struct fs_struct *fs, struct vfsmount *mnt,
  1410. struct dentry *dentry)
  1411. {
  1412. struct dentry *old_pwd;
  1413. struct vfsmount *old_pwdmnt;
  1414. write_lock(&fs->lock);
  1415. old_pwd = fs->pwd;
  1416. old_pwdmnt = fs->pwdmnt;
  1417. fs->pwdmnt = mntget(mnt);
  1418. fs->pwd = dget(dentry);
  1419. write_unlock(&fs->lock);
  1420. if (old_pwd) {
  1421. dput(old_pwd);
  1422. mntput(old_pwdmnt);
  1423. }
  1424. }
  1425. static void chroot_fs_refs(struct nameidata *old_nd, struct nameidata *new_nd)
  1426. {
  1427. struct task_struct *g, *p;
  1428. struct fs_struct *fs;
  1429. read_lock(&tasklist_lock);
  1430. do_each_thread(g, p) {
  1431. task_lock(p);
  1432. fs = p->fs;
  1433. if (fs) {
  1434. atomic_inc(&fs->count);
  1435. task_unlock(p);
  1436. if (fs->root == old_nd->dentry
  1437. && fs->rootmnt == old_nd->mnt)
  1438. set_fs_root(fs, new_nd->mnt, new_nd->dentry);
  1439. if (fs->pwd == old_nd->dentry
  1440. && fs->pwdmnt == old_nd->mnt)
  1441. set_fs_pwd(fs, new_nd->mnt, new_nd->dentry);
  1442. put_fs_struct(fs);
  1443. } else
  1444. task_unlock(p);
  1445. } while_each_thread(g, p);
  1446. read_unlock(&tasklist_lock);
  1447. }
  1448. /*
  1449. * pivot_root Semantics:
  1450. * Moves the root file system of the current process to the directory put_old,
  1451. * makes new_root as the new root file system of the current process, and sets
  1452. * root/cwd of all processes which had them on the current root to new_root.
  1453. *
  1454. * Restrictions:
  1455. * The new_root and put_old must be directories, and must not be on the
  1456. * same file system as the current process root. The put_old must be
  1457. * underneath new_root, i.e. adding a non-zero number of /.. to the string
  1458. * pointed to by put_old must yield the same directory as new_root. No other
  1459. * file system may be mounted on put_old. After all, new_root is a mountpoint.
  1460. *
  1461. * Also, the current root cannot be on the 'rootfs' (initial ramfs) filesystem.
  1462. * See Documentation/filesystems/ramfs-rootfs-initramfs.txt for alternatives
  1463. * in this situation.
  1464. *
  1465. * Notes:
  1466. * - we don't move root/cwd if they are not at the root (reason: if something
  1467. * cared enough to change them, it's probably wrong to force them elsewhere)
  1468. * - it's okay to pick a root that isn't the root of a file system, e.g.
  1469. * /nfs/my_root where /nfs is the mount point. It must be a mountpoint,
  1470. * though, so you may need to say mount --bind /nfs/my_root /nfs/my_root
  1471. * first.
  1472. */
  1473. asmlinkage long sys_pivot_root(const char __user * new_root,
  1474. const char __user * put_old)
  1475. {
  1476. struct vfsmount *tmp;
  1477. struct nameidata new_nd, old_nd, parent_nd, root_parent, user_nd;
  1478. int error;
  1479. if (!capable(CAP_SYS_ADMIN))
  1480. return -EPERM;
  1481. lock_kernel();
  1482. error = __user_walk(new_root, LOOKUP_FOLLOW | LOOKUP_DIRECTORY,
  1483. &new_nd);
  1484. if (error)
  1485. goto out0;
  1486. error = -EINVAL;
  1487. if (!check_mnt(new_nd.mnt))
  1488. goto out1;
  1489. error = __user_walk(put_old, LOOKUP_FOLLOW | LOOKUP_DIRECTORY, &old_nd);
  1490. if (error)
  1491. goto out1;
  1492. error = security_sb_pivotroot(&old_nd, &new_nd);
  1493. if (error) {
  1494. path_release(&old_nd);
  1495. goto out1;
  1496. }
  1497. read_lock(&current->fs->lock);
  1498. user_nd.mnt = mntget(current->fs->rootmnt);
  1499. user_nd.dentry = dget(current->fs->root);
  1500. read_unlock(&current->fs->lock);
  1501. down_write(&namespace_sem);
  1502. mutex_lock(&old_nd.dentry->d_inode->i_mutex);
  1503. error = -EINVAL;
  1504. if (IS_MNT_SHARED(old_nd.mnt) ||
  1505. IS_MNT_SHARED(new_nd.mnt->mnt_parent) ||
  1506. IS_MNT_SHARED(user_nd.mnt->mnt_parent))
  1507. goto out2;
  1508. if (!check_mnt(user_nd.mnt))
  1509. goto out2;
  1510. error = -ENOENT;
  1511. if (IS_DEADDIR(new_nd.dentry->d_inode))
  1512. goto out2;
  1513. if (d_unhashed(new_nd.dentry) && !IS_ROOT(new_nd.dentry))
  1514. goto out2;
  1515. if (d_unhashed(old_nd.dentry) && !IS_ROOT(old_nd.dentry))
  1516. goto out2;
  1517. error = -EBUSY;
  1518. if (new_nd.mnt == user_nd.mnt || old_nd.mnt == user_nd.mnt)
  1519. goto out2; /* loop, on the same file system */
  1520. error = -EINVAL;
  1521. if (user_nd.mnt->mnt_root != user_nd.dentry)
  1522. goto out2; /* not a mountpoint */
  1523. if (user_nd.mnt->mnt_parent == user_nd.mnt)
  1524. goto out2; /* not attached */
  1525. if (new_nd.mnt->mnt_root != new_nd.dentry)
  1526. goto out2; /* not a mountpoint */
  1527. if (new_nd.mnt->mnt_parent == new_nd.mnt)
  1528. goto out2; /* not attached */
  1529. tmp = old_nd.mnt; /* make sure we can reach put_old from new_root */
  1530. spin_lock(&vfsmount_lock);
  1531. if (tmp != new_nd.mnt) {
  1532. for (;;) {
  1533. if (tmp->mnt_parent == tmp)
  1534. goto out3; /* already mounted on put_old */
  1535. if (tmp->mnt_parent == new_nd.mnt)
  1536. break;
  1537. tmp = tmp->mnt_parent;
  1538. }
  1539. if (!is_subdir(tmp->mnt_mountpoint, new_nd.dentry))
  1540. goto out3;
  1541. } else if (!is_subdir(old_nd.dentry, new_nd.dentry))
  1542. goto out3;
  1543. detach_mnt(new_nd.mnt, &parent_nd);
  1544. detach_mnt(user_nd.mnt, &root_parent);
  1545. attach_mnt(user_nd.mnt, &old_nd); /* mount old root on put_old */
  1546. attach_mnt(new_nd.mnt, &root_parent); /* mount new_root on / */
  1547. touch_mnt_namespace(current->nsproxy->mnt_ns);
  1548. spin_unlock(&vfsmount_lock);
  1549. chroot_fs_refs(&user_nd, &new_nd);
  1550. security_sb_post_pivotroot(&user_nd, &new_nd);
  1551. error = 0;
  1552. path_release(&root_parent);
  1553. path_release(&parent_nd);
  1554. out2:
  1555. mutex_unlock(&old_nd.dentry->d_inode->i_mutex);
  1556. up_write(&namespace_sem);
  1557. path_release(&user_nd);
  1558. path_release(&old_nd);
  1559. out1:
  1560. path_release(&new_nd);
  1561. out0:
  1562. unlock_kernel();
  1563. return error;
  1564. out3:
  1565. spin_unlock(&vfsmount_lock);
  1566. goto out2;
  1567. }
  1568. static void __init init_mount_tree(void)
  1569. {
  1570. struct vfsmount *mnt;
  1571. struct mnt_namespace *ns;
  1572. mnt = do_kern_mount("rootfs", 0, "rootfs", NULL);
  1573. if (IS_ERR(mnt))
  1574. panic("Can't create rootfs");
  1575. ns = kmalloc(sizeof(*ns), GFP_KERNEL);
  1576. if (!ns)
  1577. panic("Can't allocate initial namespace");
  1578. atomic_set(&ns->count, 1);
  1579. INIT_LIST_HEAD(&ns->list);
  1580. init_waitqueue_head(&ns->poll);
  1581. ns->event = 0;
  1582. list_add(&mnt->mnt_list, &ns->list);
  1583. ns->root = mnt;
  1584. mnt->mnt_ns = ns;
  1585. init_task.nsproxy->mnt_ns = ns;
  1586. get_mnt_ns(ns);
  1587. set_fs_pwd(current->fs, ns->root, ns->root->mnt_root);
  1588. set_fs_root(current->fs, ns->root, ns->root->mnt_root);
  1589. }
  1590. void __init mnt_init(unsigned long mempages)
  1591. {
  1592. struct list_head *d;
  1593. unsigned int nr_hash;
  1594. int i;
  1595. int err;
  1596. init_rwsem(&namespace_sem);
  1597. mnt_cache = kmem_cache_create("mnt_cache", sizeof(struct vfsmount),
  1598. 0, SLAB_HWCACHE_ALIGN | SLAB_PANIC, NULL, NULL);
  1599. mount_hashtable = (struct list_head *)__get_free_page(GFP_ATOMIC);
  1600. if (!mount_hashtable)
  1601. panic("Failed to allocate mount hash table\n");
  1602. /*
  1603. * Find the power-of-two list-heads that can fit into the allocation..
  1604. * We don't guarantee that "sizeof(struct list_head)" is necessarily
  1605. * a power-of-two.
  1606. */
  1607. nr_hash = PAGE_SIZE / sizeof(struct list_head);
  1608. hash_bits = 0;
  1609. do {
  1610. hash_bits++;
  1611. } while ((nr_hash >> hash_bits) != 0);
  1612. hash_bits--;
  1613. /*
  1614. * Re-calculate the actual number of entries and the mask
  1615. * from the number of bits we can fit.
  1616. */
  1617. nr_hash = 1UL << hash_bits;
  1618. hash_mask = nr_hash - 1;
  1619. printk("Mount-cache hash table entries: %d\n", nr_hash);
  1620. /* And initialize the newly allocated array */
  1621. d = mount_hashtable;
  1622. i = nr_hash;
  1623. do {
  1624. INIT_LIST_HEAD(d);
  1625. d++;
  1626. i--;
  1627. } while (i);
  1628. err = sysfs_init();
  1629. if (err)
  1630. printk(KERN_WARNING "%s: sysfs_init error: %d\n",
  1631. __FUNCTION__, err);
  1632. err = subsystem_register(&fs_subsys);
  1633. if (err)
  1634. printk(KERN_WARNING "%s: subsystem_register error: %d\n",
  1635. __FUNCTION__, err);
  1636. init_rootfs();
  1637. init_mount_tree();
  1638. }
  1639. void __put_mnt_ns(struct mnt_namespace *ns)
  1640. {
  1641. struct vfsmount *root = ns->root;
  1642. LIST_HEAD(umount_list);
  1643. ns->root = NULL;
  1644. spin_unlock(&vfsmount_lock);
  1645. down_write(&namespace_sem);
  1646. spin_lock(&vfsmount_lock);
  1647. umount_tree(root, 0, &umount_list);
  1648. spin_unlock(&vfsmount_lock);
  1649. up_write(&namespace_sem);
  1650. release_mounts(&umount_list);
  1651. kfree(ns);
  1652. }