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