namespace.c 6.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249
  1. /*
  2. * linux/fs/nfs/namespace.c
  3. *
  4. * Copyright (C) 2005 Trond Myklebust <Trond.Myklebust@netapp.com>
  5. * - Modified by David Howells <dhowells@redhat.com>
  6. *
  7. * NFS namespace
  8. */
  9. #include <linux/dcache.h>
  10. #include <linux/mount.h>
  11. #include <linux/namei.h>
  12. #include <linux/nfs_fs.h>
  13. #include <linux/string.h>
  14. #include <linux/sunrpc/clnt.h>
  15. #include <linux/vfs.h>
  16. #include "internal.h"
  17. #define NFSDBG_FACILITY NFSDBG_VFS
  18. static void nfs_expire_automounts(struct work_struct *work);
  19. LIST_HEAD(nfs_automount_list);
  20. static DECLARE_DELAYED_WORK(nfs_automount_task, nfs_expire_automounts);
  21. int nfs_mountpoint_expiry_timeout = 500 * HZ;
  22. static struct vfsmount *nfs_do_submount(const struct vfsmount *mnt_parent,
  23. const struct dentry *dentry,
  24. struct nfs_fh *fh,
  25. struct nfs_fattr *fattr);
  26. /*
  27. * nfs_path - reconstruct the path given an arbitrary dentry
  28. * @base - arbitrary string to prepend to the path
  29. * @droot - pointer to root dentry for mountpoint
  30. * @dentry - pointer to dentry
  31. * @buffer - result buffer
  32. * @buflen - length of buffer
  33. *
  34. * Helper function for constructing the path from the
  35. * root dentry to an arbitrary hashed dentry.
  36. *
  37. * This is mainly for use in figuring out the path on the
  38. * server side when automounting on top of an existing partition.
  39. */
  40. char *nfs_path(const char *base,
  41. const struct dentry *droot,
  42. const struct dentry *dentry,
  43. char *buffer, ssize_t buflen)
  44. {
  45. char *end = buffer+buflen;
  46. int namelen;
  47. *--end = '\0';
  48. buflen--;
  49. spin_lock(&dcache_lock);
  50. while (!IS_ROOT(dentry) && dentry != droot) {
  51. namelen = dentry->d_name.len;
  52. buflen -= namelen + 1;
  53. if (buflen < 0)
  54. goto Elong_unlock;
  55. end -= namelen;
  56. memcpy(end, dentry->d_name.name, namelen);
  57. *--end = '/';
  58. dentry = dentry->d_parent;
  59. }
  60. spin_unlock(&dcache_lock);
  61. namelen = strlen(base);
  62. /* Strip off excess slashes in base string */
  63. while (namelen > 0 && base[namelen - 1] == '/')
  64. namelen--;
  65. buflen -= namelen;
  66. if (buflen < 0)
  67. goto Elong;
  68. end -= namelen;
  69. memcpy(end, base, namelen);
  70. return end;
  71. Elong_unlock:
  72. spin_unlock(&dcache_lock);
  73. Elong:
  74. return ERR_PTR(-ENAMETOOLONG);
  75. }
  76. /*
  77. * nfs_follow_mountpoint - handle crossing a mountpoint on the server
  78. * @dentry - dentry of mountpoint
  79. * @nd - nameidata info
  80. *
  81. * When we encounter a mountpoint on the server, we want to set up
  82. * a mountpoint on the client too, to prevent inode numbers from
  83. * colliding, and to allow "df" to work properly.
  84. * On NFSv4, we also want to allow for the fact that different
  85. * filesystems may be migrated to different servers in a failover
  86. * situation, and that different filesystems may want to use
  87. * different security flavours.
  88. */
  89. static void * nfs_follow_mountpoint(struct dentry *dentry, struct nameidata *nd)
  90. {
  91. struct vfsmount *mnt;
  92. struct nfs_server *server = NFS_SERVER(dentry->d_inode);
  93. struct dentry *parent;
  94. struct nfs_fh fh;
  95. struct nfs_fattr fattr;
  96. int err;
  97. dprintk("--> nfs_follow_mountpoint()\n");
  98. BUG_ON(IS_ROOT(dentry));
  99. dprintk("%s: enter\n", __FUNCTION__);
  100. dput(nd->dentry);
  101. nd->dentry = dget(dentry);
  102. /* Look it up again */
  103. parent = dget_parent(nd->dentry);
  104. err = server->nfs_client->rpc_ops->lookup(parent->d_inode,
  105. &nd->dentry->d_name,
  106. &fh, &fattr);
  107. dput(parent);
  108. if (err != 0)
  109. goto out_err;
  110. if (fattr.valid & NFS_ATTR_FATTR_V4_REFERRAL)
  111. mnt = nfs_do_refmount(nd->mnt, nd->dentry);
  112. else
  113. mnt = nfs_do_submount(nd->mnt, nd->dentry, &fh, &fattr);
  114. err = PTR_ERR(mnt);
  115. if (IS_ERR(mnt))
  116. goto out_err;
  117. mntget(mnt);
  118. err = do_add_mount(mnt, nd, nd->mnt->mnt_flags|MNT_SHRINKABLE, &nfs_automount_list);
  119. if (err < 0) {
  120. mntput(mnt);
  121. if (err == -EBUSY)
  122. goto out_follow;
  123. goto out_err;
  124. }
  125. mntput(nd->mnt);
  126. dput(nd->dentry);
  127. nd->mnt = mnt;
  128. nd->dentry = dget(mnt->mnt_root);
  129. schedule_delayed_work(&nfs_automount_task, nfs_mountpoint_expiry_timeout);
  130. out:
  131. dprintk("%s: done, returned %d\n", __FUNCTION__, err);
  132. dprintk("<-- nfs_follow_mountpoint() = %d\n", err);
  133. return ERR_PTR(err);
  134. out_err:
  135. path_release(nd);
  136. goto out;
  137. out_follow:
  138. while(d_mountpoint(nd->dentry) && follow_down(&nd->mnt, &nd->dentry))
  139. ;
  140. err = 0;
  141. goto out;
  142. }
  143. const struct inode_operations nfs_mountpoint_inode_operations = {
  144. .follow_link = nfs_follow_mountpoint,
  145. .getattr = nfs_getattr,
  146. };
  147. const struct inode_operations nfs_referral_inode_operations = {
  148. .follow_link = nfs_follow_mountpoint,
  149. };
  150. static void nfs_expire_automounts(struct work_struct *work)
  151. {
  152. struct list_head *list = &nfs_automount_list;
  153. mark_mounts_for_expiry(list);
  154. if (!list_empty(list))
  155. schedule_delayed_work(&nfs_automount_task, nfs_mountpoint_expiry_timeout);
  156. }
  157. void nfs_release_automount_timer(void)
  158. {
  159. if (list_empty(&nfs_automount_list)) {
  160. cancel_delayed_work(&nfs_automount_task);
  161. flush_scheduled_work();
  162. }
  163. }
  164. /*
  165. * Clone a mountpoint of the appropriate type
  166. */
  167. static struct vfsmount *nfs_do_clone_mount(struct nfs_server *server,
  168. const char *devname,
  169. struct nfs_clone_mount *mountdata)
  170. {
  171. #ifdef CONFIG_NFS_V4
  172. struct vfsmount *mnt = NULL;
  173. switch (server->nfs_client->cl_nfsversion) {
  174. case 2:
  175. case 3:
  176. mnt = vfs_kern_mount(&nfs_xdev_fs_type, 0, devname, mountdata);
  177. break;
  178. case 4:
  179. mnt = vfs_kern_mount(&nfs4_xdev_fs_type, 0, devname, mountdata);
  180. }
  181. return mnt;
  182. #else
  183. return vfs_kern_mount(&nfs_xdev_fs_type, 0, devname, mountdata);
  184. #endif
  185. }
  186. /**
  187. * nfs_do_submount - set up mountpoint when crossing a filesystem boundary
  188. * @mnt_parent - mountpoint of parent directory
  189. * @dentry - parent directory
  190. * @fh - filehandle for new root dentry
  191. * @fattr - attributes for new root inode
  192. *
  193. */
  194. static struct vfsmount *nfs_do_submount(const struct vfsmount *mnt_parent,
  195. const struct dentry *dentry,
  196. struct nfs_fh *fh,
  197. struct nfs_fattr *fattr)
  198. {
  199. struct nfs_clone_mount mountdata = {
  200. .sb = mnt_parent->mnt_sb,
  201. .dentry = dentry,
  202. .fh = fh,
  203. .fattr = fattr,
  204. };
  205. struct vfsmount *mnt = ERR_PTR(-ENOMEM);
  206. char *page = (char *) __get_free_page(GFP_USER);
  207. char *devname;
  208. dprintk("--> nfs_do_submount()\n");
  209. dprintk("%s: submounting on %s/%s\n", __FUNCTION__,
  210. dentry->d_parent->d_name.name,
  211. dentry->d_name.name);
  212. if (page == NULL)
  213. goto out;
  214. devname = nfs_devname(mnt_parent, dentry, page, PAGE_SIZE);
  215. mnt = (struct vfsmount *)devname;
  216. if (IS_ERR(devname))
  217. goto free_page;
  218. mnt = nfs_do_clone_mount(NFS_SB(mnt_parent->mnt_sb), devname, &mountdata);
  219. free_page:
  220. free_page((unsigned long)page);
  221. out:
  222. dprintk("%s: done\n", __FUNCTION__);
  223. dprintk("<-- nfs_do_submount() = %p\n", mnt);
  224. return mnt;
  225. }