nfs41: call free slot from nfs4_restart_rpc
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / fs / nfs / unlink.c
blob52f7bdb12c83700b35e28d030f203abae677826f
1 /*
2 * linux/fs/nfs/unlink.c
4 * nfs sillydelete handling
6 */
8 #include <linux/slab.h>
9 #include <linux/string.h>
10 #include <linux/dcache.h>
11 #include <linux/sunrpc/sched.h>
12 #include <linux/sunrpc/clnt.h>
13 #include <linux/nfs_fs.h>
14 #include <linux/sched.h>
15 #include <linux/wait.h>
17 #include "internal.h"
18 #include "nfs4_fs.h"
20 struct nfs_unlinkdata {
21 struct hlist_node list;
22 struct nfs_removeargs args;
23 struct nfs_removeres res;
24 struct inode *dir;
25 struct rpc_cred *cred;
28 /**
29 * nfs_free_unlinkdata - release data from a sillydelete operation.
30 * @data: pointer to unlink structure.
32 static void
33 nfs_free_unlinkdata(struct nfs_unlinkdata *data)
35 iput(data->dir);
36 put_rpccred(data->cred);
37 kfree(data->args.name.name);
38 kfree(data);
41 #define NAME_ALLOC_LEN(len) ((len+16) & ~15)
42 /**
43 * nfs_copy_dname - copy dentry name to data structure
44 * @dentry: pointer to dentry
45 * @data: nfs_unlinkdata
47 static int nfs_copy_dname(struct dentry *dentry, struct nfs_unlinkdata *data)
49 char *str;
50 int len = dentry->d_name.len;
52 str = kmemdup(dentry->d_name.name, NAME_ALLOC_LEN(len), GFP_KERNEL);
53 if (!str)
54 return -ENOMEM;
55 data->args.name.len = len;
56 data->args.name.name = str;
57 return 0;
60 static void nfs_free_dname(struct nfs_unlinkdata *data)
62 kfree(data->args.name.name);
63 data->args.name.name = NULL;
64 data->args.name.len = 0;
67 static void nfs_dec_sillycount(struct inode *dir)
69 struct nfs_inode *nfsi = NFS_I(dir);
70 if (atomic_dec_return(&nfsi->silly_count) == 1)
71 wake_up(&nfsi->waitqueue);
74 /**
75 * nfs_async_unlink_done - Sillydelete post-processing
76 * @task: rpc_task of the sillydelete
78 * Do the directory attribute update.
80 static void nfs_async_unlink_done(struct rpc_task *task, void *calldata)
82 struct nfs_unlinkdata *data = calldata;
83 struct inode *dir = data->dir;
84 struct nfs_removeres *res = task->tk_msg.rpc_resp;
86 if (!NFS_PROTO(dir)->unlink_done(task, dir))
87 nfs4_restart_rpc(task, NFS_SERVER(dir)->nfs_client,
88 &res->seq_res);
91 /**
92 * nfs_async_unlink_release - Release the sillydelete data.
93 * @task: rpc_task of the sillydelete
95 * We need to call nfs_put_unlinkdata as a 'tk_release' task since the
96 * rpc_task would be freed too.
98 static void nfs_async_unlink_release(void *calldata)
100 struct nfs_unlinkdata *data = calldata;
101 struct super_block *sb = data->dir->i_sb;
103 nfs_dec_sillycount(data->dir);
104 nfs_free_unlinkdata(data);
105 nfs_sb_deactive(sb);
108 #if defined(CONFIG_NFS_V4_1)
109 void nfs_unlink_prepare(struct rpc_task *task, void *calldata)
111 struct nfs_unlinkdata *data = calldata;
112 struct nfs_server *server = NFS_SERVER(data->dir);
114 if (nfs4_setup_sequence(server->nfs_client, &data->args.seq_args,
115 &data->res.seq_res, 1, task))
116 return;
117 rpc_call_start(task);
119 #endif /* CONFIG_NFS_V4_1 */
121 static const struct rpc_call_ops nfs_unlink_ops = {
122 .rpc_call_done = nfs_async_unlink_done,
123 .rpc_release = nfs_async_unlink_release,
124 #if defined(CONFIG_NFS_V4_1)
125 .rpc_call_prepare = nfs_unlink_prepare,
126 #endif /* CONFIG_NFS_V4_1 */
129 static int nfs_do_call_unlink(struct dentry *parent, struct inode *dir, struct nfs_unlinkdata *data)
131 struct rpc_message msg = {
132 .rpc_argp = &data->args,
133 .rpc_resp = &data->res,
134 .rpc_cred = data->cred,
136 struct rpc_task_setup task_setup_data = {
137 .rpc_message = &msg,
138 .callback_ops = &nfs_unlink_ops,
139 .callback_data = data,
140 .workqueue = nfsiod_workqueue,
141 .flags = RPC_TASK_ASYNC,
143 struct rpc_task *task;
144 struct dentry *alias;
146 alias = d_lookup(parent, &data->args.name);
147 if (alias != NULL) {
148 int ret = 0;
151 * Hey, we raced with lookup... See if we need to transfer
152 * the sillyrename information to the aliased dentry.
154 nfs_free_dname(data);
155 spin_lock(&alias->d_lock);
156 if (alias->d_inode != NULL &&
157 !(alias->d_flags & DCACHE_NFSFS_RENAMED)) {
158 alias->d_fsdata = data;
159 alias->d_flags |= DCACHE_NFSFS_RENAMED;
160 ret = 1;
162 spin_unlock(&alias->d_lock);
163 nfs_dec_sillycount(dir);
164 dput(alias);
165 return ret;
167 data->dir = igrab(dir);
168 if (!data->dir) {
169 nfs_dec_sillycount(dir);
170 return 0;
172 nfs_sb_active(dir->i_sb);
173 data->args.fh = NFS_FH(dir);
174 nfs_fattr_init(&data->res.dir_attr);
176 NFS_PROTO(dir)->unlink_setup(&msg, dir);
178 task_setup_data.rpc_client = NFS_CLIENT(dir);
179 task = rpc_run_task(&task_setup_data);
180 if (!IS_ERR(task))
181 rpc_put_task(task);
182 return 1;
185 static int nfs_call_unlink(struct dentry *dentry, struct nfs_unlinkdata *data)
187 struct dentry *parent;
188 struct inode *dir;
189 int ret = 0;
192 parent = dget_parent(dentry);
193 if (parent == NULL)
194 goto out_free;
195 dir = parent->d_inode;
196 if (nfs_copy_dname(dentry, data) != 0)
197 goto out_dput;
198 /* Non-exclusive lock protects against concurrent lookup() calls */
199 spin_lock(&dir->i_lock);
200 if (atomic_inc_not_zero(&NFS_I(dir)->silly_count) == 0) {
201 /* Deferred delete */
202 hlist_add_head(&data->list, &NFS_I(dir)->silly_list);
203 spin_unlock(&dir->i_lock);
204 ret = 1;
205 goto out_dput;
207 spin_unlock(&dir->i_lock);
208 ret = nfs_do_call_unlink(parent, dir, data);
209 out_dput:
210 dput(parent);
211 out_free:
212 return ret;
215 void nfs_block_sillyrename(struct dentry *dentry)
217 struct nfs_inode *nfsi = NFS_I(dentry->d_inode);
219 wait_event(nfsi->waitqueue, atomic_cmpxchg(&nfsi->silly_count, 1, 0) == 1);
222 void nfs_unblock_sillyrename(struct dentry *dentry)
224 struct inode *dir = dentry->d_inode;
225 struct nfs_inode *nfsi = NFS_I(dir);
226 struct nfs_unlinkdata *data;
228 atomic_inc(&nfsi->silly_count);
229 spin_lock(&dir->i_lock);
230 while (!hlist_empty(&nfsi->silly_list)) {
231 if (!atomic_inc_not_zero(&nfsi->silly_count))
232 break;
233 data = hlist_entry(nfsi->silly_list.first, struct nfs_unlinkdata, list);
234 hlist_del(&data->list);
235 spin_unlock(&dir->i_lock);
236 if (nfs_do_call_unlink(dentry, dir, data) == 0)
237 nfs_free_unlinkdata(data);
238 spin_lock(&dir->i_lock);
240 spin_unlock(&dir->i_lock);
244 * nfs_async_unlink - asynchronous unlinking of a file
245 * @dir: parent directory of dentry
246 * @dentry: dentry to unlink
249 nfs_async_unlink(struct inode *dir, struct dentry *dentry)
251 struct nfs_unlinkdata *data;
252 int status = -ENOMEM;
254 data = kzalloc(sizeof(*data), GFP_KERNEL);
255 if (data == NULL)
256 goto out;
258 data->cred = rpc_lookup_cred();
259 if (IS_ERR(data->cred)) {
260 status = PTR_ERR(data->cred);
261 goto out_free;
263 data->res.seq_res.sr_slotid = NFS4_MAX_SLOT_TABLE;
265 status = -EBUSY;
266 spin_lock(&dentry->d_lock);
267 if (dentry->d_flags & DCACHE_NFSFS_RENAMED)
268 goto out_unlock;
269 dentry->d_flags |= DCACHE_NFSFS_RENAMED;
270 dentry->d_fsdata = data;
271 spin_unlock(&dentry->d_lock);
272 return 0;
273 out_unlock:
274 spin_unlock(&dentry->d_lock);
275 put_rpccred(data->cred);
276 out_free:
277 kfree(data);
278 out:
279 return status;
283 * nfs_complete_unlink - Initialize completion of the sillydelete
284 * @dentry: dentry to delete
285 * @inode: inode
287 * Since we're most likely to be called by dentry_iput(), we
288 * only use the dentry to find the sillydelete. We then copy the name
289 * into the qstr.
291 void
292 nfs_complete_unlink(struct dentry *dentry, struct inode *inode)
294 struct nfs_unlinkdata *data = NULL;
296 spin_lock(&dentry->d_lock);
297 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
298 dentry->d_flags &= ~DCACHE_NFSFS_RENAMED;
299 data = dentry->d_fsdata;
301 spin_unlock(&dentry->d_lock);
303 if (data != NULL && (NFS_STALE(inode) || !nfs_call_unlink(dentry, data)))
304 nfs_free_unlinkdata(data);