blob: e313a51acdd18cd090427365fcf7dd209847be81 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/fs/nfs/unlink.c
3 *
4 * nfs sillydelete handling
5 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07006 */
7
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>
Linus Torvaldsb35e7042007-10-19 19:59:18 -070014#include <linux/sched.h>
15#include <linux/wait.h>
Jeff Layton779c5172010-09-17 17:31:30 -040016#include <linux/namei.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070017
Steve Dicksonef818a22007-11-08 04:05:04 -050018#include "internal.h"
Andy Adamson472cfbd2009-04-01 09:22:24 -040019#include "nfs4_fs.h"
Jeff Layton779c5172010-09-17 17:31:30 -040020#include "iostat.h"
21#include "delegation.h"
Steve Dicksonef818a22007-11-08 04:05:04 -050022
Linus Torvalds1da177e2005-04-16 15:20:36 -070023struct nfs_unlinkdata {
Trond Myklebust565277f2007-10-15 18:17:53 -040024 struct hlist_node list;
Trond Myklebuste4eff1a2007-07-14 15:39:58 -040025 struct nfs_removeargs args;
26 struct nfs_removeres res;
27 struct inode *dir;
Linus Torvalds1da177e2005-04-16 15:20:36 -070028 struct rpc_cred *cred;
Trond Myklebustd3468902010-04-16 16:22:50 -040029 struct nfs_fattr dir_attr;
Linus Torvalds1da177e2005-04-16 15:20:36 -070030};
31
Linus Torvalds1da177e2005-04-16 15:20:36 -070032/**
Trond Myklebuste4eff1a2007-07-14 15:39:58 -040033 * nfs_free_unlinkdata - release data from a sillydelete operation.
Linus Torvalds1da177e2005-04-16 15:20:36 -070034 * @data: pointer to unlink structure.
35 */
36static void
Trond Myklebuste4eff1a2007-07-14 15:39:58 -040037nfs_free_unlinkdata(struct nfs_unlinkdata *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -070038{
Trond Myklebuste4eff1a2007-07-14 15:39:58 -040039 iput(data->dir);
40 put_rpccred(data->cred);
41 kfree(data->args.name.name);
42 kfree(data);
Linus Torvalds1da177e2005-04-16 15:20:36 -070043}
44
45#define NAME_ALLOC_LEN(len) ((len+16) & ~15)
46/**
47 * nfs_copy_dname - copy dentry name to data structure
48 * @dentry: pointer to dentry
49 * @data: nfs_unlinkdata
50 */
Trond Myklebuste4eff1a2007-07-14 15:39:58 -040051static int nfs_copy_dname(struct dentry *dentry, struct nfs_unlinkdata *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -070052{
53 char *str;
54 int len = dentry->d_name.len;
55
Trond Myklebuste4eff1a2007-07-14 15:39:58 -040056 str = kmemdup(dentry->d_name.name, NAME_ALLOC_LEN(len), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -070057 if (!str)
Trond Myklebuste4eff1a2007-07-14 15:39:58 -040058 return -ENOMEM;
59 data->args.name.len = len;
60 data->args.name.name = str;
61 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070062}
63
Trond Myklebust565277f2007-10-15 18:17:53 -040064static void nfs_free_dname(struct nfs_unlinkdata *data)
65{
66 kfree(data->args.name.name);
67 data->args.name.name = NULL;
68 data->args.name.len = 0;
69}
70
71static void nfs_dec_sillycount(struct inode *dir)
72{
73 struct nfs_inode *nfsi = NFS_I(dir);
74 if (atomic_dec_return(&nfsi->silly_count) == 1)
75 wake_up(&nfsi->waitqueue);
76}
77
Linus Torvalds1da177e2005-04-16 15:20:36 -070078/**
Linus Torvalds1da177e2005-04-16 15:20:36 -070079 * nfs_async_unlink_done - Sillydelete post-processing
80 * @task: rpc_task of the sillydelete
81 *
82 * Do the directory attribute update.
83 */
Trond Myklebust963d8fe2006-01-03 09:55:04 +010084static void nfs_async_unlink_done(struct rpc_task *task, void *calldata)
Linus Torvalds1da177e2005-04-16 15:20:36 -070085{
Trond Myklebuste4eff1a2007-07-14 15:39:58 -040086 struct nfs_unlinkdata *data = calldata;
87 struct inode *dir = data->dir;
Linus Torvalds1da177e2005-04-16 15:20:36 -070088
Trond Myklebuste4eff1a2007-07-14 15:39:58 -040089 if (!NFS_PROTO(dir)->unlink_done(task, dir))
Trond Myklebust0110ee12009-12-07 09:00:24 -050090 nfs_restart_rpc(task, NFS_SERVER(dir)->nfs_client);
Linus Torvalds1da177e2005-04-16 15:20:36 -070091}
92
93/**
94 * nfs_async_unlink_release - Release the sillydelete data.
95 * @task: rpc_task of the sillydelete
96 *
97 * We need to call nfs_put_unlinkdata as a 'tk_release' task since the
98 * rpc_task would be freed too.
99 */
Trond Myklebust963d8fe2006-01-03 09:55:04 +0100100static void nfs_async_unlink_release(void *calldata)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101{
Trond Myklebust963d8fe2006-01-03 09:55:04 +0100102 struct nfs_unlinkdata *data = calldata;
Trond Myklebust744d18d2008-07-27 18:03:19 -0400103 struct super_block *sb = data->dir->i_sb;
Trond Myklebust565277f2007-10-15 18:17:53 -0400104
105 nfs_dec_sillycount(data->dir);
Trond Myklebuste4eff1a2007-07-14 15:39:58 -0400106 nfs_free_unlinkdata(data);
Trond Myklebust1daef0a2008-07-27 18:19:01 -0400107 nfs_sb_deactive(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108}
109
Andy Adamson472cfbd2009-04-01 09:22:24 -0400110#if defined(CONFIG_NFS_V4_1)
111void nfs_unlink_prepare(struct rpc_task *task, void *calldata)
112{
113 struct nfs_unlinkdata *data = calldata;
114 struct nfs_server *server = NFS_SERVER(data->dir);
115
Trond Myklebust035168a2010-06-16 09:52:26 -0400116 if (nfs4_setup_sequence(server, &data->args.seq_args,
Andy Adamson472cfbd2009-04-01 09:22:24 -0400117 &data->res.seq_res, 1, task))
118 return;
119 rpc_call_start(task);
120}
121#endif /* CONFIG_NFS_V4_1 */
122
Trond Myklebust963d8fe2006-01-03 09:55:04 +0100123static const struct rpc_call_ops nfs_unlink_ops = {
124 .rpc_call_done = nfs_async_unlink_done,
125 .rpc_release = nfs_async_unlink_release,
Andy Adamson472cfbd2009-04-01 09:22:24 -0400126#if defined(CONFIG_NFS_V4_1)
127 .rpc_call_prepare = nfs_unlink_prepare,
128#endif /* CONFIG_NFS_V4_1 */
Trond Myklebust963d8fe2006-01-03 09:55:04 +0100129};
130
Trond Myklebust565277f2007-10-15 18:17:53 -0400131static int nfs_do_call_unlink(struct dentry *parent, struct inode *dir, struct nfs_unlinkdata *data)
Trond Myklebuste4eff1a2007-07-14 15:39:58 -0400132{
Trond Myklebust5138fde2007-07-14 15:40:01 -0400133 struct rpc_message msg = {
134 .rpc_argp = &data->args,
135 .rpc_resp = &data->res,
136 .rpc_cred = data->cred,
137 };
Trond Myklebustc970aa82007-07-14 15:39:59 -0400138 struct rpc_task_setup task_setup_data = {
Trond Myklebust5138fde2007-07-14 15:40:01 -0400139 .rpc_message = &msg,
Trond Myklebustc970aa82007-07-14 15:39:59 -0400140 .callback_ops = &nfs_unlink_ops,
141 .callback_data = data,
Trond Myklebust1daef0a2008-07-27 18:19:01 -0400142 .workqueue = nfsiod_workqueue,
Trond Myklebustc970aa82007-07-14 15:39:59 -0400143 .flags = RPC_TASK_ASYNC,
144 };
Trond Myklebuste4eff1a2007-07-14 15:39:58 -0400145 struct rpc_task *task;
Trond Myklebust565277f2007-10-15 18:17:53 -0400146 struct dentry *alias;
Trond Myklebuste4eff1a2007-07-14 15:39:58 -0400147
Trond Myklebust565277f2007-10-15 18:17:53 -0400148 alias = d_lookup(parent, &data->args.name);
149 if (alias != NULL) {
150 int ret = 0;
Trond Myklebust609005c32008-01-28 19:42:59 -0500151
Trond Myklebust565277f2007-10-15 18:17:53 -0400152 /*
153 * Hey, we raced with lookup... See if we need to transfer
154 * the sillyrename information to the aliased dentry.
155 */
156 nfs_free_dname(data);
157 spin_lock(&alias->d_lock);
Trond Myklebust609005c32008-01-28 19:42:59 -0500158 if (alias->d_inode != NULL &&
159 !(alias->d_flags & DCACHE_NFSFS_RENAMED)) {
Trond Myklebust565277f2007-10-15 18:17:53 -0400160 alias->d_fsdata = data;
Trond Myklebustfccca7f2008-01-26 17:37:47 -0500161 alias->d_flags |= DCACHE_NFSFS_RENAMED;
Trond Myklebust565277f2007-10-15 18:17:53 -0400162 ret = 1;
163 }
164 spin_unlock(&alias->d_lock);
165 nfs_dec_sillycount(dir);
166 dput(alias);
167 return ret;
168 }
169 data->dir = igrab(dir);
170 if (!data->dir) {
171 nfs_dec_sillycount(dir);
172 return 0;
173 }
Trond Myklebust1daef0a2008-07-27 18:19:01 -0400174 nfs_sb_active(dir->i_sb);
Trond Myklebuste4eff1a2007-07-14 15:39:58 -0400175 data->args.fh = NFS_FH(dir);
Trond Myklebustd3468902010-04-16 16:22:50 -0400176 nfs_fattr_init(data->res.dir_attr);
Trond Myklebuste4eff1a2007-07-14 15:39:58 -0400177
Trond Myklebust5138fde2007-07-14 15:40:01 -0400178 NFS_PROTO(dir)->unlink_setup(&msg, dir);
Trond Myklebustc970aa82007-07-14 15:39:59 -0400179
Trond Myklebust5138fde2007-07-14 15:40:01 -0400180 task_setup_data.rpc_client = NFS_CLIENT(dir);
Trond Myklebustc970aa82007-07-14 15:39:59 -0400181 task = rpc_run_task(&task_setup_data);
Trond Myklebuste4eff1a2007-07-14 15:39:58 -0400182 if (!IS_ERR(task))
183 rpc_put_task(task);
184 return 1;
Trond Myklebust565277f2007-10-15 18:17:53 -0400185}
186
187static int nfs_call_unlink(struct dentry *dentry, struct nfs_unlinkdata *data)
188{
189 struct dentry *parent;
190 struct inode *dir;
191 int ret = 0;
192
193
194 parent = dget_parent(dentry);
195 if (parent == NULL)
196 goto out_free;
197 dir = parent->d_inode;
Trond Myklebust55b70a02007-10-21 12:02:22 -0400198 if (nfs_copy_dname(dentry, data) != 0)
Trond Myklebust565277f2007-10-15 18:17:53 -0400199 goto out_dput;
200 /* Non-exclusive lock protects against concurrent lookup() calls */
201 spin_lock(&dir->i_lock);
202 if (atomic_inc_not_zero(&NFS_I(dir)->silly_count) == 0) {
203 /* Deferred delete */
204 hlist_add_head(&data->list, &NFS_I(dir)->silly_list);
205 spin_unlock(&dir->i_lock);
206 ret = 1;
207 goto out_dput;
208 }
209 spin_unlock(&dir->i_lock);
210 ret = nfs_do_call_unlink(parent, dir, data);
211out_dput:
212 dput(parent);
Trond Myklebuste4eff1a2007-07-14 15:39:58 -0400213out_free:
Trond Myklebust565277f2007-10-15 18:17:53 -0400214 return ret;
215}
216
217void nfs_block_sillyrename(struct dentry *dentry)
218{
219 struct nfs_inode *nfsi = NFS_I(dentry->d_inode);
220
221 wait_event(nfsi->waitqueue, atomic_cmpxchg(&nfsi->silly_count, 1, 0) == 1);
222}
223
224void nfs_unblock_sillyrename(struct dentry *dentry)
225{
226 struct inode *dir = dentry->d_inode;
227 struct nfs_inode *nfsi = NFS_I(dir);
228 struct nfs_unlinkdata *data;
229
230 atomic_inc(&nfsi->silly_count);
231 spin_lock(&dir->i_lock);
232 while (!hlist_empty(&nfsi->silly_list)) {
233 if (!atomic_inc_not_zero(&nfsi->silly_count))
234 break;
235 data = hlist_entry(nfsi->silly_list.first, struct nfs_unlinkdata, list);
236 hlist_del(&data->list);
237 spin_unlock(&dir->i_lock);
238 if (nfs_do_call_unlink(dentry, dir, data) == 0)
239 nfs_free_unlinkdata(data);
240 spin_lock(&dir->i_lock);
241 }
242 spin_unlock(&dir->i_lock);
Trond Myklebuste4eff1a2007-07-14 15:39:58 -0400243}
244
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245/**
246 * nfs_async_unlink - asynchronous unlinking of a file
Trond Myklebuste4eff1a2007-07-14 15:39:58 -0400247 * @dir: parent directory of dentry
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248 * @dentry: dentry to unlink
249 */
Jeff Layton779c5172010-09-17 17:31:30 -0400250static int
Trond Myklebuste4eff1a2007-07-14 15:39:58 -0400251nfs_async_unlink(struct inode *dir, struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252{
Trond Myklebuste4eff1a2007-07-14 15:39:58 -0400253 struct nfs_unlinkdata *data;
254 int status = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255
Eric Sesterhennbd647542006-03-20 13:44:10 -0500256 data = kzalloc(sizeof(*data), GFP_KERNEL);
Trond Myklebuste4eff1a2007-07-14 15:39:58 -0400257 if (data == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259
Trond Myklebust98a8e322008-03-12 12:25:28 -0400260 data->cred = rpc_lookup_cred();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261 if (IS_ERR(data->cred)) {
262 status = PTR_ERR(data->cred);
263 goto out_free;
264 }
Trond Myklebustd3468902010-04-16 16:22:50 -0400265 data->res.dir_attr = &data->dir_attr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266
Trond Myklebuste4eff1a2007-07-14 15:39:58 -0400267 status = -EBUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268 spin_lock(&dentry->d_lock);
Trond Myklebuste4eff1a2007-07-14 15:39:58 -0400269 if (dentry->d_flags & DCACHE_NFSFS_RENAMED)
270 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271 dentry->d_flags |= DCACHE_NFSFS_RENAMED;
Trond Myklebuste4eff1a2007-07-14 15:39:58 -0400272 dentry->d_fsdata = data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273 spin_unlock(&dentry->d_lock);
Trond Myklebuste4eff1a2007-07-14 15:39:58 -0400274 return 0;
275out_unlock:
276 spin_unlock(&dentry->d_lock);
277 put_rpccred(data->cred);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278out_free:
279 kfree(data);
Trond Myklebuste4eff1a2007-07-14 15:39:58 -0400280out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281 return status;
282}
283
284/**
285 * nfs_complete_unlink - Initialize completion of the sillydelete
286 * @dentry: dentry to delete
Trond Myklebuste4eff1a2007-07-14 15:39:58 -0400287 * @inode: inode
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288 *
289 * Since we're most likely to be called by dentry_iput(), we
290 * only use the dentry to find the sillydelete. We then copy the name
291 * into the qstr.
292 */
293void
Trond Myklebuste4eff1a2007-07-14 15:39:58 -0400294nfs_complete_unlink(struct dentry *dentry, struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295{
Trond Myklebuste4eff1a2007-07-14 15:39:58 -0400296 struct nfs_unlinkdata *data = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298 spin_lock(&dentry->d_lock);
Trond Myklebuste4eff1a2007-07-14 15:39:58 -0400299 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
300 dentry->d_flags &= ~DCACHE_NFSFS_RENAMED;
301 data = dentry->d_fsdata;
302 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303 spin_unlock(&dentry->d_lock);
Trond Myklebuste4eff1a2007-07-14 15:39:58 -0400304
305 if (data != NULL && (NFS_STALE(inode) || !nfs_call_unlink(dentry, data)))
306 nfs_free_unlinkdata(data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307}
Jeff Layton779c5172010-09-17 17:31:30 -0400308
Jeff Laytond3d41522010-09-17 17:31:57 -0400309/* Cancel a queued async unlink. Called when a sillyrename run fails. */
310static void
311nfs_cancel_async_unlink(struct dentry *dentry)
312{
313 spin_lock(&dentry->d_lock);
314 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
315 struct nfs_unlinkdata *data = dentry->d_fsdata;
316
317 dentry->d_flags &= ~DCACHE_NFSFS_RENAMED;
318 spin_unlock(&dentry->d_lock);
319 nfs_free_unlinkdata(data);
320 return;
321 }
322 spin_unlock(&dentry->d_lock);
323}
324
325struct nfs_renamedata {
326 struct nfs_renameargs args;
327 struct nfs_renameres res;
328 struct rpc_cred *cred;
329 struct inode *old_dir;
330 struct dentry *old_dentry;
331 struct nfs_fattr old_fattr;
332 struct inode *new_dir;
333 struct dentry *new_dentry;
334 struct nfs_fattr new_fattr;
335};
336
337/**
338 * nfs_async_rename_done - Sillyrename post-processing
339 * @task: rpc_task of the sillyrename
340 * @calldata: nfs_renamedata for the sillyrename
341 *
342 * Do the directory attribute updates and the d_move
343 */
344static void nfs_async_rename_done(struct rpc_task *task, void *calldata)
345{
346 struct nfs_renamedata *data = calldata;
347 struct inode *old_dir = data->old_dir;
348 struct inode *new_dir = data->new_dir;
349
350 if (!NFS_PROTO(old_dir)->rename_done(task, old_dir, new_dir)) {
351 nfs_restart_rpc(task, NFS_SERVER(old_dir)->nfs_client);
352 return;
353 }
354
355 if (task->tk_status != 0) {
356 nfs_cancel_async_unlink(data->old_dentry);
357 return;
358 }
359
360 nfs_set_verifier(data->old_dentry, nfs_save_change_attribute(old_dir));
361 d_move(data->old_dentry, data->new_dentry);
362}
363
364/**
365 * nfs_async_rename_release - Release the sillyrename data.
366 * @calldata: the struct nfs_renamedata to be released
367 */
368static void nfs_async_rename_release(void *calldata)
369{
370 struct nfs_renamedata *data = calldata;
371 struct super_block *sb = data->old_dir->i_sb;
372
373 if (data->old_dentry->d_inode)
374 nfs_mark_for_revalidate(data->old_dentry->d_inode);
375
376 dput(data->old_dentry);
377 dput(data->new_dentry);
378 iput(data->old_dir);
379 iput(data->new_dir);
380 nfs_sb_deactive(sb);
381 put_rpccred(data->cred);
382 kfree(data);
383}
384
385#if defined(CONFIG_NFS_V4_1)
386static void nfs_rename_prepare(struct rpc_task *task, void *calldata)
387{
388 struct nfs_renamedata *data = calldata;
389 struct nfs_server *server = NFS_SERVER(data->old_dir);
390
391 if (nfs4_setup_sequence(server, &data->args.seq_args,
392 &data->res.seq_res, 1, task))
393 return;
394 rpc_call_start(task);
395}
396#endif /* CONFIG_NFS_V4_1 */
397
398static const struct rpc_call_ops nfs_rename_ops = {
399 .rpc_call_done = nfs_async_rename_done,
400 .rpc_release = nfs_async_rename_release,
401#if defined(CONFIG_NFS_V4_1)
402 .rpc_call_prepare = nfs_rename_prepare,
403#endif /* CONFIG_NFS_V4_1 */
404};
405
406/**
407 * nfs_async_rename - perform an asynchronous rename operation
408 * @old_dir: directory that currently holds the dentry to be renamed
409 * @new_dir: target directory for the rename
410 * @old_dentry: original dentry to be renamed
411 * @new_dentry: dentry to which the old_dentry should be renamed
412 *
413 * It's expected that valid references to the dentries and inodes are held
414 */
415static struct rpc_task *
416nfs_async_rename(struct inode *old_dir, struct inode *new_dir,
417 struct dentry *old_dentry, struct dentry *new_dentry)
418{
419 struct nfs_renamedata *data;
420 struct rpc_message msg = { };
421 struct rpc_task_setup task_setup_data = {
422 .rpc_message = &msg,
423 .callback_ops = &nfs_rename_ops,
424 .workqueue = nfsiod_workqueue,
425 .rpc_client = NFS_CLIENT(old_dir),
426 .flags = RPC_TASK_ASYNC,
427 };
Jeff Laytond3d41522010-09-17 17:31:57 -0400428
Benny Halevydfb4f3092010-09-24 09:17:01 -0400429 data = kzalloc(sizeof(*data), GFP_KERNEL);
Jeff Laytond3d41522010-09-17 17:31:57 -0400430 if (data == NULL)
431 return ERR_PTR(-ENOMEM);
Trond Myklebust1174dd12010-12-21 10:52:24 -0500432 task_setup_data.callback_data = data;
Jeff Laytond3d41522010-09-17 17:31:57 -0400433
434 data->cred = rpc_lookup_cred();
435 if (IS_ERR(data->cred)) {
Trond Myklebustf7732d62010-09-21 16:52:40 -0400436 struct rpc_task *task = ERR_CAST(data->cred);
Jeff Laytond3d41522010-09-17 17:31:57 -0400437 kfree(data);
438 return task;
439 }
440
441 msg.rpc_argp = &data->args;
442 msg.rpc_resp = &data->res;
443 msg.rpc_cred = data->cred;
444
445 /* set up nfs_renamedata */
446 data->old_dir = old_dir;
Al Viroa4118ee2010-10-27 11:00:08 -0400447 ihold(old_dir);
Jeff Laytond3d41522010-09-17 17:31:57 -0400448 data->new_dir = new_dir;
Al Viroa4118ee2010-10-27 11:00:08 -0400449 ihold(new_dir);
Jeff Laytond3d41522010-09-17 17:31:57 -0400450 data->old_dentry = dget(old_dentry);
451 data->new_dentry = dget(new_dentry);
452 nfs_fattr_init(&data->old_fattr);
453 nfs_fattr_init(&data->new_fattr);
454
455 /* set up nfs_renameargs */
456 data->args.old_dir = NFS_FH(old_dir);
457 data->args.old_name = &old_dentry->d_name;
458 data->args.new_dir = NFS_FH(new_dir);
459 data->args.new_name = &new_dentry->d_name;
460
461 /* set up nfs_renameres */
462 data->res.old_fattr = &data->old_fattr;
463 data->res.new_fattr = &data->new_fattr;
464
465 nfs_sb_active(old_dir->i_sb);
466
467 NFS_PROTO(data->old_dir)->rename_setup(&msg, old_dir);
468
Trond Myklebustf7732d62010-09-21 16:52:40 -0400469 return rpc_run_task(&task_setup_data);
Jeff Laytond3d41522010-09-17 17:31:57 -0400470}
471
Jeff Layton779c5172010-09-17 17:31:30 -0400472/**
473 * nfs_sillyrename - Perform a silly-rename of a dentry
474 * @dir: inode of directory that contains dentry
475 * @dentry: dentry to be sillyrenamed
476 *
477 * NFSv2/3 is stateless and the server doesn't know when the client is
478 * holding a file open. To prevent application problems when a file is
479 * unlinked while it's still open, the client performs a "silly-rename".
480 * That is, it renames the file to a hidden file in the same directory,
481 * and only performs the unlink once the last reference to it is put.
482 *
483 * The final cleanup is done during dentry_iput.
484 */
485int
486nfs_sillyrename(struct inode *dir, struct dentry *dentry)
487{
488 static unsigned int sillycounter;
489 const int fileidsize = sizeof(NFS_FILEID(dentry->d_inode))*2;
490 const int countersize = sizeof(sillycounter)*2;
491 const int slen = sizeof(".nfs")+fileidsize+countersize-1;
492 char silly[slen+1];
Jeff Layton779c5172010-09-17 17:31:30 -0400493 struct dentry *sdentry;
Jeff Laytond3d41522010-09-17 17:31:57 -0400494 struct rpc_task *task;
Jeff Layton779c5172010-09-17 17:31:30 -0400495 int error = -EIO;
496
497 dfprintk(VFS, "NFS: silly-rename(%s/%s, ct=%d)\n",
498 dentry->d_parent->d_name.name, dentry->d_name.name,
Nick Pigginb7ab39f2011-01-07 17:49:32 +1100499 dentry->d_count);
Jeff Layton779c5172010-09-17 17:31:30 -0400500 nfs_inc_stats(dir, NFSIOS_SILLYRENAME);
501
502 /*
503 * We don't allow a dentry to be silly-renamed twice.
504 */
505 error = -EBUSY;
506 if (dentry->d_flags & DCACHE_NFSFS_RENAMED)
507 goto out;
508
509 sprintf(silly, ".nfs%*.*Lx",
510 fileidsize, fileidsize,
511 (unsigned long long)NFS_FILEID(dentry->d_inode));
512
513 /* Return delegation in anticipation of the rename */
514 nfs_inode_return_delegation(dentry->d_inode);
515
516 sdentry = NULL;
517 do {
518 char *suffix = silly + slen - countersize;
519
520 dput(sdentry);
521 sillycounter++;
522 sprintf(suffix, "%*.*x", countersize, countersize, sillycounter);
523
524 dfprintk(VFS, "NFS: trying to rename %s to %s\n",
525 dentry->d_name.name, silly);
526
527 sdentry = lookup_one_len(silly, dentry->d_parent, slen);
528 /*
529 * N.B. Better to return EBUSY here ... it could be
530 * dangerous to delete the file while it's in use.
531 */
532 if (IS_ERR(sdentry))
533 goto out;
534 } while (sdentry->d_inode != NULL); /* need negative lookup */
535
Jeff Laytond3d41522010-09-17 17:31:57 -0400536 /* queue unlink first. Can't do this from rpc_release as it
537 * has to allocate memory
538 */
539 error = nfs_async_unlink(dir, dentry);
540 if (error)
541 goto out_dput;
542
543 /* run the rename task, undo unlink if it fails */
544 task = nfs_async_rename(dir, dir, dentry, sdentry);
545 if (IS_ERR(task)) {
546 error = -EBUSY;
547 nfs_cancel_async_unlink(dentry);
548 goto out_dput;
Jeff Layton779c5172010-09-17 17:31:30 -0400549 }
Jeff Laytond3d41522010-09-17 17:31:57 -0400550
551 /* wait for the RPC task to complete, unless a SIGKILL intervenes */
552 error = rpc_wait_for_completion_task(task);
553 if (error == 0)
554 error = task->tk_status;
555 rpc_put_task(task);
556out_dput:
Jeff Layton779c5172010-09-17 17:31:30 -0400557 dput(sdentry);
558out:
559 return error;
560}