开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
namespace.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：27k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

namespace.c：源码内容
  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.  */
  11. #include <linux/config.h>
  12. #include <linux/slab.h>
  13. #include <linux/smp_lock.h>
  14. #include <linux/init.h>
  15. #include <linux/quotaops.h>
  16. #include <linux/acct.h>
  17. #include <linux/module.h>
  18. #include <linux/devfs_fs_kernel.h>
  20. #include <asm/uaccess.h>
  22. #include <linux/seq_file.h>
  24. struct vfsmount *do_kern_mount(char *type, int flags, char *name, void *data);
  25. int do_remount_sb(struct super_block *sb, int flags, void * data);
  26. void kill_super(struct super_block *sb);
  28. static struct list_head *mount_hashtable;
  29. static int hash_mask, hash_bits;
  30. static kmem_cache_t *mnt_cache; 
  32. static LIST_HEAD(vfsmntlist);
  33. static DECLARE_MUTEX(mount_sem);
  35. /* Will be static */
  36. struct vfsmount *root_vfsmnt;
  38. static inline unsigned long hash(struct vfsmount *mnt, struct dentry *dentry)
  39. {
  40. unsigned long tmp = ((unsigned long) mnt / L1_CACHE_BYTES);
  41. tmp += ((unsigned long) dentry / L1_CACHE_BYTES);
  42. tmp = tmp + (tmp >> hash_bits);
  43. return tmp & hash_mask;
  44. }
  46. struct vfsmount *alloc_vfsmnt(void)
  47. {
  48. struct vfsmount *mnt = kmem_cache_alloc(mnt_cache, GFP_KERNEL); 
  49. if (mnt) {
  50. memset(mnt, 0, sizeof(struct vfsmount));
  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. }
  57. return mnt;
  58. }
  60. void free_vfsmnt(struct vfsmount *mnt)
  61. {
  62. if (mnt->mnt_devname)
  63. kfree(mnt->mnt_devname);
  64. kmem_cache_free(mnt_cache, mnt);
  65. }
  67. void set_devname(struct vfsmount *mnt, const char *name)
  68. {
  69. if (name) {
  70. int size = strlen(name)+1;
  71. char * newname = kmalloc(size, GFP_KERNEL);
  72. if (newname) {
  73. memcpy(newname, name, size);
  74. mnt->mnt_devname = newname;
  75. }
  76. }
  77. }
  79. struct vfsmount *lookup_mnt(struct vfsmount *mnt, struct dentry *dentry)
  80. {
  81. struct list_head * head = mount_hashtable + hash(mnt, dentry);
  82. struct list_head * tmp = head;
  83. struct vfsmount *p;
  85. for (;;) {
  86. tmp = tmp->next;
  87. p = NULL;
  88. if (tmp == head)
  89. break;
  90. p = list_entry(tmp, struct vfsmount, mnt_hash);
  91. if (p->mnt_parent == mnt && p->mnt_mountpoint == dentry)
  92. break;
  93. }
  94. return p;
  95. }
  97. static int check_mnt(struct vfsmount *mnt)
  98. {
  99. spin_lock(&dcache_lock);
  100. while (mnt->mnt_parent != mnt)
  101. mnt = mnt->mnt_parent;
  102. spin_unlock(&dcache_lock);
  103. return mnt == root_vfsmnt;
  104. }
  106. static void detach_mnt(struct vfsmount *mnt, struct nameidata *old_nd)
  107. {
  108. old_nd->dentry = mnt->mnt_mountpoint;
  109. old_nd->mnt = mnt->mnt_parent;
  110. mnt->mnt_parent = mnt;
  111. mnt->mnt_mountpoint = mnt->mnt_root;
  112. list_del_init(&mnt->mnt_child);
  113. list_del_init(&mnt->mnt_hash);
  114. old_nd->dentry->d_mounted--;
  115. }
  117. static void attach_mnt(struct vfsmount *mnt, struct nameidata *nd)
  118. {
  119. mnt->mnt_parent = mntget(nd->mnt);
  120. mnt->mnt_mountpoint = dget(nd->dentry);
  121. list_add(&mnt->mnt_hash, mount_hashtable+hash(nd->mnt, nd->dentry));
  122. list_add(&mnt->mnt_child, &nd->mnt->mnt_mounts);
  123. nd->dentry->d_mounted++;
  124. }
  126. static struct vfsmount *next_mnt(struct vfsmount *p, struct vfsmount *root)
  127. {
  128. struct list_head *next = p->mnt_mounts.next;
  129. if (next == &p->mnt_mounts) {
  130. while (1) {
  131. if (p == root)
  132. return NULL;
  133. next = p->mnt_child.next;
  134. if (next != &p->mnt_parent->mnt_mounts)
  135. break;
  136. p = p->mnt_parent;
  137. }
  138. }
  139. return list_entry(next, struct vfsmount, mnt_child);
  140. }
  142. static struct vfsmount *
  143. clone_mnt(struct vfsmount *old, struct dentry *root)
  144. {
  145. struct super_block *sb = old->mnt_sb;
  146. struct vfsmount *mnt = alloc_vfsmnt();
  148. if (mnt) {
  149. mnt->mnt_flags = old->mnt_flags;
  150. set_devname(mnt, old->mnt_devname);
  151. atomic_inc(&sb->s_active);
  152. mnt->mnt_sb = sb;
  153. mnt->mnt_root = dget(root);
  154. mnt->mnt_mountpoint = mnt->mnt_root;
  155. mnt->mnt_parent = mnt;
  156. }
  157. return mnt;
  158. }
  160. void __mntput(struct vfsmount *mnt)
  161. {
  162. struct super_block *sb = mnt->mnt_sb;
  163. dput(mnt->mnt_root);
  164. free_vfsmnt(mnt);
  165. kill_super(sb);
  166. }
  168. /* iterator */
  169. static void *m_start(struct seq_file *m, loff_t *pos)
  170. {
  171. struct list_head *p;
  172. loff_t n = *pos;
  174. down(&mount_sem);
  175. list_for_each(p, &vfsmntlist)
  176. if (!n--)
  177. return list_entry(p, struct vfsmount, mnt_list);
  178. return NULL;
  179. }
  181. static void *m_next(struct seq_file *m, void *v, loff_t *pos)
  182. {
  183. struct list_head *p = ((struct vfsmount *)v)->mnt_list.next;
  184. (*pos)++;
  185. return p==&vfsmntlist ? NULL : list_entry(p, struct vfsmount, mnt_list);
  186. }
  188. static void m_stop(struct seq_file *m, void *v)
  189. {
  190. up(&mount_sem);
  191. }
  193. static inline void mangle(struct seq_file *m, const char *s)
  194. {
  195. seq_escape(m, s, " tn\");
  196. }
  198. static int show_vfsmnt(struct seq_file *m, void *v)
  199. {
  200. struct vfsmount *mnt = v;
  201. int err = 0;
  202. static struct proc_fs_info {
  203. int flag;
  204. char *str;
  205. } fs_info[] = {
  206. { MS_SYNCHRONOUS, ",sync" },
  207. { MS_MANDLOCK, ",mand" },
  208. { MS_NOATIME, ",noatime" },
  209. { MS_NODIRATIME, ",nodiratime" },
  210. { 0, NULL }
  211. };
  212. static struct proc_fs_info mnt_info[] = {
  213. { MNT_NOSUID, ",nosuid" },
  214. { MNT_NODEV, ",nodev" },
  215. { MNT_NOEXEC, ",noexec" },
  216. { 0, NULL }
  217. };
  218. struct proc_fs_info *fs_infop;
  219. char *path_buf, *path;
  221. path_buf = (char *) __get_free_page(GFP_KERNEL);
  222. if (!path_buf)
  223. return -ENOMEM;
  224. path = d_path(mnt->mnt_root, mnt, path_buf, PAGE_SIZE);
  226. mangle(m, mnt->mnt_devname ? mnt->mnt_devname : "none");
  227. seq_putc(m, ' ');
  228. mangle(m, path);
  229. free_page((unsigned long) path_buf);
  230. seq_putc(m, ' ');
  231. mangle(m, mnt->mnt_sb->s_type->name);
  232. seq_puts(m, mnt->mnt_sb->s_flags & MS_RDONLY ? " ro" : " rw");
  233. for (fs_infop = fs_info; fs_infop->flag; fs_infop++) {
  234. if (mnt->mnt_sb->s_flags & fs_infop->flag)
  235. seq_puts(m, fs_infop->str);
  236. }
  237. for (fs_infop = mnt_info; fs_infop->flag; fs_infop++) {
  238. if (mnt->mnt_flags & fs_infop->flag)
  239. seq_puts(m, fs_infop->str);
  240. }
  241. if (mnt->mnt_sb->s_op->show_options)
  242. err = mnt->mnt_sb->s_op->show_options(m, mnt);
  243. seq_puts(m, " 0 0n");
  244. return err;
  245. }
  247. struct seq_operations mounts_op = {
  248. start: m_start,
  249. next: m_next,
  250. stop: m_stop,
  251. show: show_vfsmnt
  252. };
  254. /*
  255.  * Doesn't take quota and stuff into account. IOW, in some cases it will
  256.  * give false negatives. The main reason why it's here is that we need
  257.  * a non-destructive way to look for easily umountable filesystems.
  258.  */
  259. int may_umount(struct vfsmount *mnt)
  260. {
  261. if (atomic_read(&mnt->mnt_count) > 2)
  262. return -EBUSY;
  263. return 0;
  264. }
  266. void umount_tree(struct vfsmount *mnt)
  267. {
  268. struct vfsmount *p;
  269. LIST_HEAD(kill);
  271. for (p = mnt; p; p = next_mnt(p, mnt)) {
  272. list_del(&p->mnt_list);
  273. list_add(&p->mnt_list, &kill);
  274. }
  276. while (!list_empty(&kill)) {
  277. mnt = list_entry(kill.next, struct vfsmount, mnt_list);
  278. list_del_init(&mnt->mnt_list);
  279. if (mnt->mnt_parent == mnt) {
  280. spin_unlock(&dcache_lock);
  281. } else {
  282. struct nameidata old_nd;
  283. detach_mnt(mnt, &old_nd);
  284. spin_unlock(&dcache_lock);
  285. path_release(&old_nd);
  286. }
  287. mntput(mnt);
  288. spin_lock(&dcache_lock);
  289. }
  290. }
  292. static int do_umount(struct vfsmount *mnt, int flags)
  293. {
  294. struct super_block * sb = mnt->mnt_sb;
  295. int retval = 0;
  297. /*
  298.  * If we may have to abort operations to get out of this
  299.  * mount, and they will themselves hold resources we must
  300.  * allow the fs to do things. In the Unix tradition of
  301.  * 'Gee thats tricky lets do it in userspace' the umount_begin
  302.  * might fail to complete on the first run through as other tasks
  303.  * must return, and the like. Thats for the mount program to worry
  304.  * about for the moment.
  305.  */
  307. lock_kernel();
  308. if( (flags&MNT_FORCE) && sb->s_op->umount_begin)
  309. sb->s_op->umount_begin(sb);
  310. unlock_kernel();
  312. /*
  313.  * No sense to grab the lock for this test, but test itself looks
  314.  * somewhat bogus. Suggestions for better replacement?
  315.  * Ho-hum... In principle, we might treat that as umount + switch
  316.  * to rootfs. GC would eventually take care of the old vfsmount.
  317.  * Actually it makes sense, especially if rootfs would contain a
  318.  * /reboot - static binary that would close all descriptors and
  319.  * call reboot(9). Then init(8) could umount root and exec /reboot.
  320.  */
  321. if (mnt == current->fs->rootmnt && !(flags & MNT_DETACH)) {
  322. /*
  323.  * Special case for "unmounting" root ...
  324.  * we just try to remount it readonly.
  325.  */
  326. down_write(&sb->s_umount);
  327. if (!(sb->s_flags & MS_RDONLY)) {
  328. lock_kernel();
  329. retval = do_remount_sb(sb, MS_RDONLY, 0);
  330. unlock_kernel();
  331. }
  332. up_write(&sb->s_umount);
  333. return retval;
  334. }
  336. down(&mount_sem);
  337. spin_lock(&dcache_lock);
  339. if (atomic_read(&sb->s_active) == 1) {
  340. /* last instance - try to be smart */
  341. spin_unlock(&dcache_lock);
  342. lock_kernel();
  343. DQUOT_OFF(sb);
  344. acct_auto_close(sb->s_dev);
  345. unlock_kernel();
  346. spin_lock(&dcache_lock);
  347. }
  348. retval = -EBUSY;
  349. if (atomic_read(&mnt->mnt_count) == 2 || flags & MNT_DETACH) {
  350. if (!list_empty(&mnt->mnt_list))
  351. umount_tree(mnt);
  352. retval = 0;
  353. }
  354. spin_unlock(&dcache_lock);
  355. up(&mount_sem);
  356. return retval;
  357. }
  359. /*
  360.  * Now umount can handle mount points as well as block devices.
  361.  * This is important for filesystems which use unnamed block devices.
  362.  *
  363.  * We now support a flag for forced unmount like the other 'big iron'
  364.  * unixes. Our API is identical to OSF/1 to avoid making a mess of AMD
  365.  */
  367. asmlinkage long sys_umount(char * name, int flags)
  368. {
  369. struct nameidata nd;
  370. char *kname;
  371. int retval;
  373. kname = getname(name);
  374. retval = PTR_ERR(kname);
  375. if (IS_ERR(kname))
  376. goto out;
  377. retval = 0;
  378. if (path_init(kname, LOOKUP_POSITIVE|LOOKUP_FOLLOW, &nd))
  379. retval = path_walk(kname, &nd);
  380. putname(kname);
  381. if (retval)
  382. goto out;
  383. retval = -EINVAL;
  384. if (nd.dentry != nd.mnt->mnt_root)
  385. goto dput_and_out;
  386. if (!check_mnt(nd.mnt))
  387. goto dput_and_out;
  389. retval = -EPERM;
  390. if (!capable(CAP_SYS_ADMIN))
  391. goto dput_and_out;
  393. retval = do_umount(nd.mnt, flags);
  394. dput_and_out:
  395. path_release(&nd);
  396. out:
  397. return retval;
  398. }
  400. /*
  401.  * The 2.0 compatible umount. No flags. 
  402.  */
  403.  
  404. asmlinkage long sys_oldumount(char * name)
  405. {
  406. return sys_umount(name,0);
  407. }
  409. static int mount_is_safe(struct nameidata *nd)
  410. {
  411. if (capable(CAP_SYS_ADMIN))
  412. return 0;
  413. return -EPERM;
  414. #ifdef notyet
  415. if (S_ISLNK(nd->dentry->d_inode->i_mode))
  416. return -EPERM;
  417. if (nd->dentry->d_inode->i_mode & S_ISVTX) {
  418. if (current->uid != nd->dentry->d_inode->i_uid)
  419. return -EPERM;
  420. }
  421. if (permission(nd->dentry->d_inode, MAY_WRITE))
  422. return -EPERM;
  423. return 0;
  424. #endif
  425. }
  427. static struct vfsmount *copy_tree(struct vfsmount *mnt, struct dentry *dentry)
  428. {
  429. struct vfsmount *p, *next, *q, *res;
  430. struct nameidata nd;
  432. p = mnt;
  433. res = nd.mnt = q = clone_mnt(p, dentry);
  434. if (!q)
  435. goto Enomem;
  436. q->mnt_parent = q;
  437. q->mnt_mountpoint = p->mnt_mountpoint;
  439. while ( (next = next_mnt(p, mnt)) != NULL) {
  440. while (p != next->mnt_parent) {
  441. p = p->mnt_parent;
  442. q = q->mnt_parent;
  443. }
  444. p = next;
  445. nd.mnt = q;
  446. nd.dentry = p->mnt_mountpoint;
  447. q = clone_mnt(p, p->mnt_root);
  448. if (!q)
  449. goto Enomem;
  450. spin_lock(&dcache_lock);
  451. list_add_tail(&q->mnt_list, &res->mnt_list);
  452. attach_mnt(q, &nd);
  453. spin_unlock(&dcache_lock);
  454. }
  455. return res;
  456. Enomem:
  457. if (res) {
  458. spin_lock(&dcache_lock);
  459. umount_tree(res);
  460. spin_unlock(&dcache_lock);
  461. }
  462. return NULL;
  463. }
  465. /* Will become static */
  466. int graft_tree(struct vfsmount *mnt, struct nameidata *nd)
  467. {
  468. int err;
  469. if (mnt->mnt_sb->s_flags & MS_NOUSER)
  470. return -EINVAL;
  472. if (S_ISDIR(nd->dentry->d_inode->i_mode) !=
  473.       S_ISDIR(mnt->mnt_root->d_inode->i_mode))
  474. return -ENOTDIR;
  476. err = -ENOENT;
  477. down(&nd->dentry->d_inode->i_zombie);
  478. if (IS_DEADDIR(nd->dentry->d_inode))
  479. goto out_unlock;
  481. spin_lock(&dcache_lock);
  482. if (IS_ROOT(nd->dentry) || !d_unhashed(nd->dentry)) {
  483. struct list_head head;
  484. attach_mnt(mnt, nd);
  485. list_add_tail(&head, &mnt->mnt_list);
  486. list_splice(&head, vfsmntlist.prev);
  487. mntget(mnt);
  488. err = 0;
  489. }
  490. spin_unlock(&dcache_lock);
  491. out_unlock:
  492. up(&nd->dentry->d_inode->i_zombie);
  493. return err;
  494. }
  496. /*
  497.  * do loopback mount.
  498.  */
  499. static int do_loopback(struct nameidata *nd, char *old_name, int recurse)
  500. {
  501. struct nameidata old_nd;
  502. struct vfsmount *mnt = NULL;
  503. int err = mount_is_safe(nd);
  504. if (err)
  505. return err;
  506. if (!old_name || !*old_name)
  507. return -EINVAL;
  508. if (path_init(old_name, LOOKUP_POSITIVE|LOOKUP_FOLLOW, &old_nd))
  509. err = path_walk(old_name, &old_nd);
  510. if (err)
  511. return err;
  513. down(&mount_sem);
  514. err = -EINVAL;
  515. if (check_mnt(nd->mnt) && (!recurse || check_mnt(old_nd.mnt))) {
  516. err = -ENOMEM;
  517. if (recurse)
  518. mnt = copy_tree(old_nd.mnt, old_nd.dentry);
  519. else
  520. mnt = clone_mnt(old_nd.mnt, old_nd.dentry);
  521. }
  523. if (mnt) {
  524. err = graft_tree(mnt, nd);
  525. if (err) {
  526. spin_lock(&dcache_lock);
  527. umount_tree(mnt);
  528. spin_unlock(&dcache_lock);
  529. } else
  530. mntput(mnt);
  531. }
  533. up(&mount_sem);
  534. path_release(&old_nd);
  535. return err;
  536. }
  538. /*
  539.  * change filesystem flags. dir should be a physical root of filesystem.
  540.  * If you've mounted a non-root directory somewhere and want to do remount
  541.  * on it - tough luck.
  542.  */
  544. static int do_remount(struct nameidata *nd,int flags,int mnt_flags,void *data)
  545. {
  546. int err;
  547. struct super_block * sb = nd->mnt->mnt_sb;
  549. if (!capable(CAP_SYS_ADMIN))
  550. return -EPERM;
  552. if (!check_mnt(nd->mnt))
  553. return -EINVAL;
  555. if (nd->dentry != nd->mnt->mnt_root)
  556. return -EINVAL;
  558. down_write(&sb->s_umount);
  559. err = do_remount_sb(sb, flags, data);
  560. if (!err)
  561. nd->mnt->mnt_flags=mnt_flags;
  562. up_write(&sb->s_umount);
  563. return err;
  564. }
  566. static int do_move_mount(struct nameidata *nd, char *old_name)
  567. {
  568. struct nameidata old_nd, parent_nd;
  569. struct vfsmount *p;
  570. int err = 0;
  571. if (!capable(CAP_SYS_ADMIN))
  572. return -EPERM;
  573. if (!old_name || !*old_name)
  574. return -EINVAL;
  575. if (path_init(old_name, LOOKUP_POSITIVE|LOOKUP_FOLLOW, &old_nd))
  576. err = path_walk(old_name, &old_nd);
  577. if (err)
  578. return err;
  580. down(&mount_sem);
  581. while(d_mountpoint(nd->dentry) && follow_down(&nd->mnt, &nd->dentry))
  582. ;
  583. err = -EINVAL;
  584. if (!check_mnt(nd->mnt) || !check_mnt(old_nd.mnt))
  585. goto out;
  587. err = -ENOENT;
  588. down(&nd->dentry->d_inode->i_zombie);
  589. if (IS_DEADDIR(nd->dentry->d_inode))
  590. goto out1;
  592. spin_lock(&dcache_lock);
  593. if (!IS_ROOT(nd->dentry) && d_unhashed(nd->dentry))
  594. goto out2;
  596. err = -EINVAL;
  597. if (old_nd.dentry != old_nd.mnt->mnt_root)
  598. goto out2;
  600. if (old_nd.mnt == old_nd.mnt->mnt_parent)
  601. goto out2;
  603. if (S_ISDIR(nd->dentry->d_inode->i_mode) !=
  604.       S_ISDIR(old_nd.dentry->d_inode->i_mode))
  605. goto out2;
  607. err = -ELOOP;
  608. for (p = nd->mnt; p->mnt_parent!=p; p = p->mnt_parent)
  609. if (p == old_nd.mnt)
  610. goto out2;
  611. err = 0;
  613. detach_mnt(old_nd.mnt, &parent_nd);
  614. attach_mnt(old_nd.mnt, nd);
  615. out2:
  616. spin_unlock(&dcache_lock);
  617. out1:
  618. up(&nd->dentry->d_inode->i_zombie);
  619. out:
  620. up(&mount_sem);
  621. if (!err)
  622. path_release(&parent_nd);
  623. path_release(&old_nd);
  624. return err;
  625. }
  627. static int do_add_mount(struct nameidata *nd, char *type, int flags,
  628. int mnt_flags, char *name, void *data)
  629. {
  630. struct vfsmount *mnt = do_kern_mount(type, flags, name, data);
  631. int err = PTR_ERR(mnt);
  633. if (IS_ERR(mnt))
  634. goto out;
  636. down(&mount_sem);
  637. /* Something was mounted here while we slept */
  638. while(d_mountpoint(nd->dentry) && follow_down(&nd->mnt, &nd->dentry))
  639. ;
  640. err = -EINVAL;
  641. if (!check_mnt(nd->mnt))
  642. goto unlock;
  644. /* Refuse the same filesystem on the same mount point */
  645. err = -EBUSY;
  646. if (nd->mnt->mnt_sb == mnt->mnt_sb && nd->mnt->mnt_root == nd->dentry)
  647. goto unlock;
  649. mnt->mnt_flags = mnt_flags;
  650. err = graft_tree(mnt, nd);
  651. unlock:
  652. up(&mount_sem);
  653. mntput(mnt);
  654. out:
  655. return err;
  656. }
  658. static int copy_mount_options (const void *data, unsigned long *where)
  659. {
  660. int i;
  661. unsigned long page;
  662. unsigned long size;
  664. *where = 0;
  665. if (!data)
  666. return 0;
  668. if (!(page = __get_free_page(GFP_KERNEL)))
  669. return -ENOMEM;
  671. /* We only care that *some* data at the address the user
  672.  * gave us is valid.  Just in case, we'll zero
  673.  * the remainder of the page.
  674.  */
  675. /* copy_from_user cannot cross TASK_SIZE ! */
  676. size = TASK_SIZE - (unsigned long)data;
  677. if (size > PAGE_SIZE)
  678. size = PAGE_SIZE;
  680. i = size - copy_from_user((void *)page, data, size);
  681. if (!i) {
  682. free_page(page); 
  683. return -EFAULT;
  684. }
  685. if (i != PAGE_SIZE)
  686. memset((char *)page + i, 0, PAGE_SIZE - i);
  687. *where = page;
  688. return 0;
  689. }
  691. /*
  692.  * Flags is a 32-bit value that allows up to 31 non-fs dependent flags to
  693.  * be given to the mount() call (ie: read-only, no-dev, no-suid etc).
  694.  *
  695.  * data is a (void *) that can point to any structure up to
  696.  * PAGE_SIZE-1 bytes, which can contain arbitrary fs-dependent
  697.  * information (or be NULL).
  698.  *
  699.  * Pre-0.97 versions of mount() didn't have a flags word.
  700.  * When the flags word was introduced its top half was required
  701.  * to have the magic value 0xC0ED, and this remained so until 2.4.0-test9.
  702.  * Therefore, if this magic number is present, it carries no information
  703.  * and must be discarded.
  704.  */
  705. long do_mount(char * dev_name, char * dir_name, char *type_page,
  706.   unsigned long flags, void *data_page)
  707. {
  708. struct nameidata nd;
  709. int retval = 0;
  710. int mnt_flags = 0;
  712. /* Discard magic */
  713. if ((flags & MS_MGC_MSK) == MS_MGC_VAL)
  714. flags &= ~MS_MGC_MSK;
  716. /* Basic sanity checks */
  718. if (!dir_name || !*dir_name || !memchr(dir_name, 0, PAGE_SIZE))
  719. return -EINVAL;
  720. if (dev_name && !memchr(dev_name, 0, PAGE_SIZE))
  721. return -EINVAL;
  723. /* Separate the per-mountpoint flags */
  724. if (flags & MS_NOSUID)
  725. mnt_flags |= MNT_NOSUID;
  726. if (flags & MS_NODEV)
  727. mnt_flags |= MNT_NODEV;
  728. if (flags & MS_NOEXEC)
  729. mnt_flags |= MNT_NOEXEC;
  730. flags &= ~(MS_NOSUID|MS_NOEXEC|MS_NODEV);
  732. /* ... and get the mountpoint */
  733. if (path_init(dir_name, LOOKUP_FOLLOW|LOOKUP_POSITIVE, &nd))
  734. retval = path_walk(dir_name, &nd);
  735. if (retval)
  736. return retval;
  738. if (flags & MS_REMOUNT)
  739. retval = do_remount(&nd, flags & ~MS_REMOUNT, mnt_flags,
  740.     data_page);
  741. else if (flags & MS_BIND)
  742. retval = do_loopback(&nd, dev_name, flags & MS_REC);
  743. else if (flags & MS_MOVE)
  744. retval = do_move_mount(&nd, dev_name);
  745. else
  746. retval = do_add_mount(&nd, type_page, flags, mnt_flags,
  747.       dev_name, data_page);
  748. path_release(&nd);
  749. return retval;
  750. }
  752. asmlinkage long sys_mount(char * dev_name, char * dir_name, char * type,
  753.   unsigned long flags, void * data)
  754. {
  755. int retval;
  756. unsigned long data_page;
  757. unsigned long type_page;
  758. unsigned long dev_page;
  759. char *dir_page;
  761. retval = copy_mount_options (type, &type_page);
  762. if (retval < 0)
  763. return retval;
  765. dir_page = getname(dir_name);
  766. retval = PTR_ERR(dir_page);
  767. if (IS_ERR(dir_page))
  768. goto out1;
  770. retval = copy_mount_options (dev_name, &dev_page);
  771. if (retval < 0)
  772. goto out2;
  774. retval = copy_mount_options (data, &data_page);
  775. if (retval < 0)
  776. goto out3;
  778. lock_kernel();
  779. retval = do_mount((char*)dev_page, dir_page, (char*)type_page,
  780.   flags, (void*)data_page);
  781. unlock_kernel();
  782. free_page(data_page);
  784. out3:
  785. free_page(dev_page);
  786. out2:
  787. putname(dir_page);
  788. out1:
  789. free_page(type_page);
  790. return retval;
  791. }
  793. static void chroot_fs_refs(struct nameidata *old_nd, struct nameidata *new_nd)
  794. {
  795. struct task_struct *p;
  796. struct fs_struct *fs;
  798. read_lock(&tasklist_lock);
  799. for_each_task(p) {
  800. task_lock(p);
  801. fs = p->fs;
  802. if (fs) {
  803. atomic_inc(&fs->count);
  804. task_unlock(p);
  805. if (fs->root==old_nd->dentry&&fs->rootmnt==old_nd->mnt)
  806. set_fs_root(fs, new_nd->mnt, new_nd->dentry);
  807. if (fs->pwd==old_nd->dentry&&fs->pwdmnt==old_nd->mnt)
  808. set_fs_pwd(fs, new_nd->mnt, new_nd->dentry);
  809. put_fs_struct(fs);
  810. } else
  811. task_unlock(p);
  812. }
  813. read_unlock(&tasklist_lock);
  814. }
  816. /*
  817.  * Moves the current root to put_root, and sets root/cwd of all processes
  818.  * which had them on the old root to new_root.
  819.  *
  820.  * Note:
  821.  *  - we don't move root/cwd if they are not at the root (reason: if something
  822.  *    cared enough to change them, it's probably wrong to force them elsewhere)
  823.  *  - it's okay to pick a root that isn't the root of a file system, e.g.
  824.  *    /nfs/my_root where /nfs is the mount point. It must be a mountpoint,
  825.  *    though, so you may need to say mount --bind /nfs/my_root /nfs/my_root
  826.  *    first.
  827.  */
  829. asmlinkage long sys_pivot_root(const char *new_root, const char *put_old)
  830. {
  831. struct vfsmount *tmp;
  832. struct nameidata new_nd, old_nd, parent_nd, root_parent, user_nd;
  833. char *name;
  834. int error;
  836. if (!capable(CAP_SYS_ADMIN))
  837. return -EPERM;
  839. lock_kernel();
  841. name = getname(new_root);
  842. error = PTR_ERR(name);
  843. if (IS_ERR(name))
  844. goto out0;
  845. error = 0;
  846. if (path_init(name, LOOKUP_POSITIVE|LOOKUP_FOLLOW|LOOKUP_DIRECTORY, &new_nd))
  847. error = path_walk(name, &new_nd);
  848. putname(name);
  849. if (error)
  850. goto out0;
  851. error = -EINVAL;
  852. if (!check_mnt(new_nd.mnt))
  853. goto out1;
  855. name = getname(put_old);
  856. error = PTR_ERR(name);
  857. if (IS_ERR(name))
  858. goto out1;
  859. error = 0;
  860. if (path_init(name, LOOKUP_POSITIVE|LOOKUP_FOLLOW|LOOKUP_DIRECTORY, &old_nd))
  861. error = path_walk(name, &old_nd);
  862. putname(name);
  863. if (error)
  864. goto out1;
  866. read_lock(&current->fs->lock);
  867. user_nd.mnt = mntget(current->fs->rootmnt);
  868. user_nd.dentry = dget(current->fs->root);
  869. read_unlock(&current->fs->lock);
  870. down(&mount_sem);
  871. down(&old_nd.dentry->d_inode->i_zombie);
  872. error = -EINVAL;
  873. if (!check_mnt(user_nd.mnt))
  874. goto out2;
  875. error = -ENOENT;
  876. if (IS_DEADDIR(new_nd.dentry->d_inode))
  877. goto out2;
  878. if (d_unhashed(new_nd.dentry) && !IS_ROOT(new_nd.dentry))
  879. goto out2;
  880. if (d_unhashed(old_nd.dentry) && !IS_ROOT(old_nd.dentry))
  881. goto out2;
  882. error = -EBUSY;
  883. if (new_nd.mnt == user_nd.mnt || old_nd.mnt == user_nd.mnt)
  884. goto out2; /* loop */
  885. error = -EINVAL;
  886. if (user_nd.mnt->mnt_root != user_nd.dentry)
  887. goto out2;
  888. if (new_nd.mnt->mnt_root != new_nd.dentry)
  889. goto out2; /* not a mountpoint */
  890. tmp = old_nd.mnt; /* make sure we can reach put_old from new_root */
  891. spin_lock(&dcache_lock);
  892. if (tmp != new_nd.mnt) {
  893. for (;;) {
  894. if (tmp->mnt_parent == tmp)
  895. goto out3;
  896. if (tmp->mnt_parent == new_nd.mnt)
  897. break;
  898. tmp = tmp->mnt_parent;
  899. }
  900. if (!is_subdir(tmp->mnt_mountpoint, new_nd.dentry))
  901. goto out3;
  902. } else if (!is_subdir(old_nd.dentry, new_nd.dentry))
  903. goto out3;
  904. detach_mnt(new_nd.mnt, &parent_nd);
  905. detach_mnt(user_nd.mnt, &root_parent);
  906. attach_mnt(user_nd.mnt, &old_nd);
  907. attach_mnt(new_nd.mnt, &root_parent);
  908. spin_unlock(&dcache_lock);
  909. chroot_fs_refs(&user_nd, &new_nd);
  910. error = 0;
  911. path_release(&root_parent);
  912. path_release(&parent_nd);
  913. out2:
  914. up(&old_nd.dentry->d_inode->i_zombie);
  915. up(&mount_sem);
  916. path_release(&user_nd);
  917. path_release(&old_nd);
  918. out1:
  919. path_release(&new_nd);
  920. out0:
  921. unlock_kernel();
  922. return error;
  923. out3:
  924. spin_unlock(&dcache_lock);
  925. goto out2;
  926. }
  928. /*
  929.  * Absolutely minimal fake fs - only empty root directory and nothing else.
  930.  * In 2.5 we'll use ramfs or tmpfs, but for now it's all we need - just
  931.  * something to go with root vfsmount.
  932.  */
  933. static struct dentry *rootfs_lookup(struct inode *dir, struct dentry *dentry)
  934. {
  935. d_add(dentry, NULL);
  936. return NULL;
  937. }
  938. static struct file_operations rootfs_dir_operations = {
  939. read: generic_read_dir,
  940. readdir: dcache_readdir,
  941. };
  942. static struct inode_operations rootfs_dir_inode_operations = {
  943. lookup: rootfs_lookup,
  944. };
  945. static struct super_block *rootfs_read_super(struct super_block * sb, void * data, int silent)
  946. {
  947. struct inode * inode;
  948. struct dentry * root;
  949. static struct super_operations s_ops = {};
  950. sb->s_op = &s_ops;
  951. inode = new_inode(sb);
  952. if (!inode)
  953. return NULL;
  954. inode->i_mode = S_IFDIR|0555;
  955. inode->i_uid = inode->i_gid = 0;
  956. inode->i_op = &rootfs_dir_inode_operations;
  957. inode->i_fop = &rootfs_dir_operations;
  958. root = d_alloc_root(inode);
  959. if (!root) {
  960. iput(inode);
  961. return NULL;
  962. }
  963. sb->s_root = root;
  964. return sb;
  965. }
  966. static DECLARE_FSTYPE(root_fs_type, "rootfs", rootfs_read_super, FS_NOMOUNT);
  968. static void __init init_mount_tree(void)
  969. {
  970. register_filesystem(&root_fs_type);
  971. root_vfsmnt = do_kern_mount("rootfs", 0, "rootfs", NULL);
  972. if (IS_ERR(root_vfsmnt))
  973. panic("can't allocate root vfsmount");
  974. }
  976. void __init mnt_init(unsigned long mempages)
  977. {
  978. struct list_head *d;
  979. unsigned long order;
  980. unsigned int nr_hash;
  981. int i;
  983. mnt_cache = kmem_cache_create("mnt_cache", sizeof(struct vfsmount),
  984. 0, SLAB_HWCACHE_ALIGN, NULL, NULL);
  985. if (!mnt_cache)
  986. panic("Cannot create vfsmount cache");
  988. mempages >>= (16 - PAGE_SHIFT);
  989. mempages *= sizeof(struct list_head);
  990. for (order = 0; ((1UL << order) << PAGE_SHIFT) < mempages; order++)
  991. ;
  993. do {
  994. mount_hashtable = (struct list_head *)
  995. __get_free_pages(GFP_ATOMIC, order);
  996. } while (mount_hashtable == NULL && --order >= 0);
  998. if (!mount_hashtable)
  999. panic("Failed to allocate mount hash tablen");
  1001. /*
  1002.  * Find the power-of-two list-heads that can fit into the allocation..
  1003.  * We don't guarantee that "sizeof(struct list_head)" is necessarily
  1004.  * a power-of-two.
  1005.  */
  1006. nr_hash = (1UL << order) * PAGE_SIZE / sizeof(struct list_head);
  1007. hash_bits = 0;
  1008. do {
  1009. hash_bits++;
  1010. } while ((nr_hash >> hash_bits) != 0);
  1011. hash_bits--;
  1013. /*
  1014.  * Re-calculate the actual number of entries and the mask
  1015.  * from the number of bits we can fit.
  1016.  */
  1017. nr_hash = 1UL << hash_bits;
  1018. hash_mask = nr_hash-1;
  1020. printk("Mount-cache hash table entries: %d (order: %ld, %ld bytes)n",
  1021. nr_hash, order, (PAGE_SIZE << order));
  1023. /* And initialize the newly allocated array */
  1024. d = mount_hashtable;
  1025. i = nr_hash;
  1026. do {
  1027. INIT_LIST_HEAD(d);
  1028. d++;
  1029. i--;
  1030. } while (i);
  1031. init_mount_tree();
  1032. }
  1034. #ifdef CONFIG_BLK_DEV_INITRD
  1036. int __init change_root(kdev_t new_root_dev,const char *put_old)
  1037. {
  1038. struct vfsmount *old_rootmnt;
  1039. struct nameidata devfs_nd, nd;
  1040. struct nameidata parent_nd;
  1041. char *new_devname = kmalloc(strlen("/dev/root.old")+1, GFP_KERNEL);
  1042. int error = 0;
  1044. if (new_devname)
  1045. strcpy(new_devname, "/dev/root.old");
  1047. read_lock(&current->fs->lock);
  1048. old_rootmnt = mntget(current->fs->rootmnt);
  1049. read_unlock(&current->fs->lock);
  1050. /*  First unmount devfs if mounted  */
  1051. if (path_init("/dev", LOOKUP_FOLLOW|LOOKUP_POSITIVE, &devfs_nd))
  1052. error = path_walk("/dev", &devfs_nd);
  1053. if (!error) {
  1054. if (devfs_nd.mnt->mnt_sb->s_magic == DEVFS_SUPER_MAGIC &&
  1055.     devfs_nd.dentry == devfs_nd.mnt->mnt_root) {
  1056. do_umount(devfs_nd.mnt, 0);
  1057. }
  1058. path_release(&devfs_nd);
  1059. }
  1060. spin_lock(&dcache_lock);
  1061. detach_mnt(old_rootmnt, &parent_nd);
  1062. spin_unlock(&dcache_lock);
  1063. ROOT_DEV = new_root_dev;
  1064. mount_root();
  1065. #if 1
  1066. shrink_dcache();
  1067. printk("change_root: old root has d_count=%dn", 
  1068.        atomic_read(&old_rootmnt->mnt_root->d_count));
  1069. #endif
  1070. mount_devfs_fs ();
  1071. /*
  1072.  * Get the new mount directory
  1073.  */
  1074. error = 0;
  1075. if (path_init(put_old, LOOKUP_FOLLOW|LOOKUP_POSITIVE|LOOKUP_DIRECTORY, &nd))
  1076. error = path_walk(put_old, &nd);
  1077. if (error) {
  1078. int blivet;
  1079. struct block_device *ramdisk = old_rootmnt->mnt_sb->s_bdev;
  1081. atomic_inc(&ramdisk->bd_count);
  1082. blivet = blkdev_get(ramdisk, FMODE_READ, 0, BDEV_FS);
  1083. printk(KERN_NOTICE "Trying to unmount old root ... ");
  1084. if (!blivet) {
  1085. spin_lock(&dcache_lock);
  1086. list_del_init(&old_rootmnt->mnt_list);
  1087.   spin_unlock(&dcache_lock);
  1088.   mntput(old_rootmnt);
  1089. mntput(old_rootmnt);
  1090. blivet = ioctl_by_bdev(ramdisk, BLKFLSBUF, 0);
  1091. path_release(&parent_nd);
  1092. blkdev_put(ramdisk, BDEV_FS);
  1093. }
  1094. if (blivet) {
  1095. printk(KERN_ERR "error %dn", blivet);
  1096. } else {
  1097. printk("okayn");
  1098. error = 0;
  1099. }
  1100. kfree(new_devname);
  1101. return error;
  1102. }
  1104. spin_lock(&dcache_lock);
  1105. attach_mnt(old_rootmnt, &nd);
  1106. if (new_devname) {
  1107. if (old_rootmnt->mnt_devname)
  1108. kfree(old_rootmnt->mnt_devname);
  1109. old_rootmnt->mnt_devname = new_devname;
  1110. }
  1111. spin_unlock(&dcache_lock);
  1113. /* put the old stuff */
  1114. path_release(&parent_nd);
  1115. mntput(old_rootmnt);
  1116. path_release(&nd);
  1117. return 0;
  1118. }
  1120. #endif