2 * linux/fs/nfs/unlink.c
4 * nfs sillydelete handling
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>
16 #include <linux/namei.h>
17 #include <linux/fsnotify.h>
22 #include "delegation.h"
27 * nfs_free_unlinkdata - release data from a sillydelete operation.
28 * @data: pointer to unlink structure.
31 nfs_free_unlinkdata(struct nfs_unlinkdata
*data
)
33 put_rpccred(data
->cred
);
34 kfree(data
->args
.name
.name
);
39 * nfs_async_unlink_done - Sillydelete post-processing
40 * @task: rpc_task of the sillydelete
42 * Do the directory attribute update.
44 static void nfs_async_unlink_done(struct rpc_task
*task
, void *calldata
)
46 struct nfs_unlinkdata
*data
= calldata
;
47 struct inode
*dir
= d_inode(data
->dentry
->d_parent
);
49 trace_nfs_sillyrename_unlink(data
, task
->tk_status
);
50 if (!NFS_PROTO(dir
)->unlink_done(task
, dir
))
51 rpc_restart_call_prepare(task
);
55 * nfs_async_unlink_release - Release the sillydelete data.
56 * @task: rpc_task of the sillydelete
58 * We need to call nfs_put_unlinkdata as a 'tk_release' task since the
59 * rpc_task would be freed too.
61 static void nfs_async_unlink_release(void *calldata
)
63 struct nfs_unlinkdata
*data
= calldata
;
64 struct dentry
*dentry
= data
->dentry
;
65 struct super_block
*sb
= dentry
->d_sb
;
67 up_read_non_owner(&NFS_I(d_inode(dentry
->d_parent
))->rmdir_sem
);
68 d_lookup_done(dentry
);
69 nfs_free_unlinkdata(data
);
74 static void nfs_unlink_prepare(struct rpc_task
*task
, void *calldata
)
76 struct nfs_unlinkdata
*data
= calldata
;
77 struct inode
*dir
= d_inode(data
->dentry
->d_parent
);
78 NFS_PROTO(dir
)->unlink_rpc_prepare(task
, data
);
81 static const struct rpc_call_ops nfs_unlink_ops
= {
82 .rpc_call_done
= nfs_async_unlink_done
,
83 .rpc_release
= nfs_async_unlink_release
,
84 .rpc_call_prepare
= nfs_unlink_prepare
,
87 static void nfs_do_call_unlink(struct nfs_unlinkdata
*data
)
89 struct rpc_message msg
= {
90 .rpc_argp
= &data
->args
,
91 .rpc_resp
= &data
->res
,
92 .rpc_cred
= data
->cred
,
94 struct rpc_task_setup task_setup_data
= {
96 .callback_ops
= &nfs_unlink_ops
,
97 .callback_data
= data
,
98 .workqueue
= nfsiod_workqueue
,
99 .flags
= RPC_TASK_ASYNC
,
101 struct rpc_task
*task
;
102 struct inode
*dir
= d_inode(data
->dentry
->d_parent
);
103 nfs_sb_active(dir
->i_sb
);
104 data
->args
.fh
= NFS_FH(dir
);
105 nfs_fattr_init(data
->res
.dir_attr
);
107 NFS_PROTO(dir
)->unlink_setup(&msg
, dir
);
109 task_setup_data
.rpc_client
= NFS_CLIENT(dir
);
110 task
= rpc_run_task(&task_setup_data
);
112 rpc_put_task_async(task
);
115 static int nfs_call_unlink(struct dentry
*dentry
, struct nfs_unlinkdata
*data
)
117 struct inode
*dir
= d_inode(dentry
->d_parent
);
118 struct dentry
*alias
;
120 down_read_non_owner(&NFS_I(dir
)->rmdir_sem
);
121 alias
= d_alloc_parallel(dentry
->d_parent
, &data
->args
.name
, &data
->wq
);
123 up_read_non_owner(&NFS_I(dir
)->rmdir_sem
);
126 if (!d_in_lookup(alias
)) {
128 void *devname_garbage
= NULL
;
131 * Hey, we raced with lookup... See if we need to transfer
132 * the sillyrename information to the aliased dentry.
134 spin_lock(&alias
->d_lock
);
135 if (d_really_is_positive(alias
) &&
136 !(alias
->d_flags
& DCACHE_NFSFS_RENAMED
)) {
137 devname_garbage
= alias
->d_fsdata
;
138 alias
->d_fsdata
= data
;
139 alias
->d_flags
|= DCACHE_NFSFS_RENAMED
;
143 spin_unlock(&alias
->d_lock
);
145 up_read_non_owner(&NFS_I(dir
)->rmdir_sem
);
147 * If we'd displaced old cached devname, free it. At that
148 * point dentry is definitely not a root, so we won't need
151 kfree(devname_garbage
);
154 data
->dentry
= alias
;
155 nfs_do_call_unlink(data
);
160 * nfs_async_unlink - asynchronous unlinking of a file
161 * @dir: parent directory of dentry
162 * @dentry: dentry to unlink
165 nfs_async_unlink(struct dentry
*dentry
, const struct qstr
*name
)
167 struct nfs_unlinkdata
*data
;
168 int status
= -ENOMEM
;
169 void *devname_garbage
= NULL
;
171 data
= kzalloc(sizeof(*data
), GFP_KERNEL
);
174 data
->args
.name
.name
= kstrdup(name
->name
, GFP_KERNEL
);
175 if (!data
->args
.name
.name
)
177 data
->args
.name
.len
= name
->len
;
179 data
->cred
= rpc_lookup_cred();
180 if (IS_ERR(data
->cred
)) {
181 status
= PTR_ERR(data
->cred
);
184 data
->res
.dir_attr
= &data
->dir_attr
;
185 init_waitqueue_head(&data
->wq
);
188 spin_lock(&dentry
->d_lock
);
189 if (dentry
->d_flags
& DCACHE_NFSFS_RENAMED
)
191 dentry
->d_flags
|= DCACHE_NFSFS_RENAMED
;
192 devname_garbage
= dentry
->d_fsdata
;
193 dentry
->d_fsdata
= data
;
194 spin_unlock(&dentry
->d_lock
);
196 * If we'd displaced old cached devname, free it. At that
197 * point dentry is definitely not a root, so we won't need
200 kfree(devname_garbage
);
203 spin_unlock(&dentry
->d_lock
);
204 put_rpccred(data
->cred
);
206 kfree(data
->args
.name
.name
);
214 * nfs_complete_unlink - Initialize completion of the sillydelete
215 * @dentry: dentry to delete
218 * Since we're most likely to be called by dentry_iput(), we
219 * only use the dentry to find the sillydelete. We then copy the name
223 nfs_complete_unlink(struct dentry
*dentry
, struct inode
*inode
)
225 struct nfs_unlinkdata
*data
;
227 spin_lock(&dentry
->d_lock
);
228 dentry
->d_flags
&= ~DCACHE_NFSFS_RENAMED
;
229 data
= dentry
->d_fsdata
;
230 dentry
->d_fsdata
= NULL
;
231 spin_unlock(&dentry
->d_lock
);
233 if (NFS_STALE(inode
) || !nfs_call_unlink(dentry
, data
))
234 nfs_free_unlinkdata(data
);
237 /* Cancel a queued async unlink. Called when a sillyrename run fails. */
239 nfs_cancel_async_unlink(struct dentry
*dentry
)
241 spin_lock(&dentry
->d_lock
);
242 if (dentry
->d_flags
& DCACHE_NFSFS_RENAMED
) {
243 struct nfs_unlinkdata
*data
= dentry
->d_fsdata
;
245 dentry
->d_flags
&= ~DCACHE_NFSFS_RENAMED
;
246 dentry
->d_fsdata
= NULL
;
247 spin_unlock(&dentry
->d_lock
);
248 nfs_free_unlinkdata(data
);
251 spin_unlock(&dentry
->d_lock
);
255 * nfs_async_rename_done - Sillyrename post-processing
256 * @task: rpc_task of the sillyrename
257 * @calldata: nfs_renamedata for the sillyrename
259 * Do the directory attribute updates and the d_move
261 static void nfs_async_rename_done(struct rpc_task
*task
, void *calldata
)
263 struct nfs_renamedata
*data
= calldata
;
264 struct inode
*old_dir
= data
->old_dir
;
265 struct inode
*new_dir
= data
->new_dir
;
266 struct dentry
*old_dentry
= data
->old_dentry
;
268 trace_nfs_sillyrename_rename(old_dir
, old_dentry
,
269 new_dir
, data
->new_dentry
, task
->tk_status
);
270 if (!NFS_PROTO(old_dir
)->rename_done(task
, old_dir
, new_dir
)) {
271 rpc_restart_call_prepare(task
);
276 data
->complete(task
, data
);
280 * nfs_async_rename_release - Release the sillyrename data.
281 * @calldata: the struct nfs_renamedata to be released
283 static void nfs_async_rename_release(void *calldata
)
285 struct nfs_renamedata
*data
= calldata
;
286 struct super_block
*sb
= data
->old_dir
->i_sb
;
288 if (d_really_is_positive(data
->old_dentry
))
289 nfs_mark_for_revalidate(d_inode(data
->old_dentry
));
291 /* The result of the rename is unknown. Play it safe by
292 * forcing a new lookup */
293 if (data
->cancelled
) {
294 spin_lock(&data
->old_dir
->i_lock
);
295 nfs_force_lookup_revalidate(data
->old_dir
);
296 spin_unlock(&data
->old_dir
->i_lock
);
297 if (data
->new_dir
!= data
->old_dir
) {
298 spin_lock(&data
->new_dir
->i_lock
);
299 nfs_force_lookup_revalidate(data
->new_dir
);
300 spin_unlock(&data
->new_dir
->i_lock
);
304 dput(data
->old_dentry
);
305 dput(data
->new_dentry
);
309 put_rpccred(data
->cred
);
313 static void nfs_rename_prepare(struct rpc_task
*task
, void *calldata
)
315 struct nfs_renamedata
*data
= calldata
;
316 NFS_PROTO(data
->old_dir
)->rename_rpc_prepare(task
, data
);
319 static const struct rpc_call_ops nfs_rename_ops
= {
320 .rpc_call_done
= nfs_async_rename_done
,
321 .rpc_release
= nfs_async_rename_release
,
322 .rpc_call_prepare
= nfs_rename_prepare
,
326 * nfs_async_rename - perform an asynchronous rename operation
327 * @old_dir: directory that currently holds the dentry to be renamed
328 * @new_dir: target directory for the rename
329 * @old_dentry: original dentry to be renamed
330 * @new_dentry: dentry to which the old_dentry should be renamed
332 * It's expected that valid references to the dentries and inodes are held
335 nfs_async_rename(struct inode
*old_dir
, struct inode
*new_dir
,
336 struct dentry
*old_dentry
, struct dentry
*new_dentry
,
337 void (*complete
)(struct rpc_task
*, struct nfs_renamedata
*))
339 struct nfs_renamedata
*data
;
340 struct rpc_message msg
= { };
341 struct rpc_task_setup task_setup_data
= {
343 .callback_ops
= &nfs_rename_ops
,
344 .workqueue
= nfsiod_workqueue
,
345 .rpc_client
= NFS_CLIENT(old_dir
),
346 .flags
= RPC_TASK_ASYNC
,
349 data
= kzalloc(sizeof(*data
), GFP_KERNEL
);
351 return ERR_PTR(-ENOMEM
);
352 task_setup_data
.callback_data
= data
;
354 data
->cred
= rpc_lookup_cred();
355 if (IS_ERR(data
->cred
)) {
356 struct rpc_task
*task
= ERR_CAST(data
->cred
);
361 msg
.rpc_argp
= &data
->args
;
362 msg
.rpc_resp
= &data
->res
;
363 msg
.rpc_cred
= data
->cred
;
365 /* set up nfs_renamedata */
366 data
->old_dir
= old_dir
;
368 data
->new_dir
= new_dir
;
370 data
->old_dentry
= dget(old_dentry
);
371 data
->new_dentry
= dget(new_dentry
);
372 nfs_fattr_init(&data
->old_fattr
);
373 nfs_fattr_init(&data
->new_fattr
);
374 data
->complete
= complete
;
376 /* set up nfs_renameargs */
377 data
->args
.old_dir
= NFS_FH(old_dir
);
378 data
->args
.old_name
= &old_dentry
->d_name
;
379 data
->args
.new_dir
= NFS_FH(new_dir
);
380 data
->args
.new_name
= &new_dentry
->d_name
;
382 /* set up nfs_renameres */
383 data
->res
.old_fattr
= &data
->old_fattr
;
384 data
->res
.new_fattr
= &data
->new_fattr
;
386 nfs_sb_active(old_dir
->i_sb
);
388 NFS_PROTO(data
->old_dir
)->rename_setup(&msg
, old_dir
);
390 return rpc_run_task(&task_setup_data
);
394 * Perform tasks needed when a sillyrename is done such as cancelling the
395 * queued async unlink if it failed.
398 nfs_complete_sillyrename(struct rpc_task
*task
, struct nfs_renamedata
*data
)
400 struct dentry
*dentry
= data
->old_dentry
;
402 if (task
->tk_status
!= 0) {
403 nfs_cancel_async_unlink(dentry
);
408 * vfs_unlink and the like do not issue this when a file is
409 * sillyrenamed, so do it here.
411 fsnotify_nameremove(dentry
, 0);
414 #define SILLYNAME_PREFIX ".nfs"
415 #define SILLYNAME_PREFIX_LEN ((unsigned)sizeof(SILLYNAME_PREFIX) - 1)
416 #define SILLYNAME_FILEID_LEN ((unsigned)sizeof(u64) << 1)
417 #define SILLYNAME_COUNTER_LEN ((unsigned)sizeof(unsigned int) << 1)
418 #define SILLYNAME_LEN (SILLYNAME_PREFIX_LEN + \
419 SILLYNAME_FILEID_LEN + \
420 SILLYNAME_COUNTER_LEN)
423 * nfs_sillyrename - Perform a silly-rename of a dentry
424 * @dir: inode of directory that contains dentry
425 * @dentry: dentry to be sillyrenamed
427 * NFSv2/3 is stateless and the server doesn't know when the client is
428 * holding a file open. To prevent application problems when a file is
429 * unlinked while it's still open, the client performs a "silly-rename".
430 * That is, it renames the file to a hidden file in the same directory,
431 * and only performs the unlink once the last reference to it is put.
433 * The final cleanup is done during dentry_iput.
435 * (Note: NFSv4 is stateful, and has opens, so in theory an NFSv4 server
436 * could take responsibility for keeping open files referenced. The server
437 * would also need to ensure that opened-but-deleted files were kept over
438 * reboots. However, we may not assume a server does so. (RFC 5661
439 * does provide an OPEN4_RESULT_PRESERVE_UNLINKED flag that a server can
440 * use to advertise that it does this; some day we may take advantage of
444 nfs_sillyrename(struct inode
*dir
, struct dentry
*dentry
)
446 static unsigned int sillycounter
;
447 unsigned char silly
[SILLYNAME_LEN
+ 1];
448 unsigned long long fileid
;
449 struct dentry
*sdentry
;
450 struct rpc_task
*task
;
453 dfprintk(VFS
, "NFS: silly-rename(%pd2, ct=%d)\n",
454 dentry
, d_count(dentry
));
455 nfs_inc_stats(dir
, NFSIOS_SILLYRENAME
);
458 * We don't allow a dentry to be silly-renamed twice.
460 if (dentry
->d_flags
& DCACHE_NFSFS_RENAMED
)
463 fileid
= NFS_FILEID(d_inode(dentry
));
465 /* Return delegation in anticipation of the rename */
466 NFS_PROTO(d_inode(dentry
))->return_delegation(d_inode(dentry
));
473 slen
= scnprintf(silly
, sizeof(silly
),
474 SILLYNAME_PREFIX
"%0*llx%0*x",
475 SILLYNAME_FILEID_LEN
, fileid
,
476 SILLYNAME_COUNTER_LEN
, sillycounter
);
478 dfprintk(VFS
, "NFS: trying to rename %pd to %s\n",
481 sdentry
= lookup_one_len(silly
, dentry
->d_parent
, slen
);
483 * N.B. Better to return EBUSY here ... it could be
484 * dangerous to delete the file while it's in use.
488 } while (d_inode(sdentry
) != NULL
); /* need negative lookup */
490 /* queue unlink first. Can't do this from rpc_release as it
491 * has to allocate memory
493 error
= nfs_async_unlink(dentry
, &sdentry
->d_name
);
497 /* run the rename task, undo unlink if it fails */
498 task
= nfs_async_rename(dir
, dir
, dentry
, sdentry
,
499 nfs_complete_sillyrename
);
502 nfs_cancel_async_unlink(dentry
);
506 /* wait for the RPC task to complete, unless a SIGKILL intervenes */
507 error
= rpc_wait_for_completion_task(task
);
509 error
= task
->tk_status
;
512 /* The rename succeeded */
513 nfs_set_verifier(dentry
, nfs_save_change_attribute(dir
));
514 d_move(dentry
, sdentry
);
517 /* The result of the rename is unknown. Play it safe by
518 * forcing a new lookup */