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>
21 #include "delegation.h"
23 struct nfs_unlinkdata
{
24 struct hlist_node list
;
25 struct nfs_removeargs args
;
26 struct nfs_removeres res
;
28 struct rpc_cred
*cred
;
29 struct nfs_fattr dir_attr
;
33 * nfs_free_unlinkdata - release data from a sillydelete operation.
34 * @data: pointer to unlink structure.
37 nfs_free_unlinkdata(struct nfs_unlinkdata
*data
)
40 put_rpccred(data
->cred
);
41 kfree(data
->args
.name
.name
);
45 #define NAME_ALLOC_LEN(len) ((len+16) & ~15)
47 * nfs_copy_dname - copy dentry name to data structure
48 * @dentry: pointer to dentry
49 * @data: nfs_unlinkdata
51 static int nfs_copy_dname(struct dentry
*dentry
, struct nfs_unlinkdata
*data
)
54 int len
= dentry
->d_name
.len
;
56 str
= kmemdup(dentry
->d_name
.name
, NAME_ALLOC_LEN(len
), GFP_KERNEL
);
59 data
->args
.name
.len
= len
;
60 data
->args
.name
.name
= str
;
64 static void nfs_free_dname(struct nfs_unlinkdata
*data
)
66 kfree(data
->args
.name
.name
);
67 data
->args
.name
.name
= NULL
;
68 data
->args
.name
.len
= 0;
71 static void nfs_dec_sillycount(struct inode
*dir
)
73 struct nfs_inode
*nfsi
= NFS_I(dir
);
74 if (atomic_dec_return(&nfsi
->silly_count
) == 1)
75 wake_up(&nfsi
->waitqueue
);
79 * nfs_async_unlink_done - Sillydelete post-processing
80 * @task: rpc_task of the sillydelete
82 * Do the directory attribute update.
84 static void nfs_async_unlink_done(struct rpc_task
*task
, void *calldata
)
86 struct nfs_unlinkdata
*data
= calldata
;
87 struct inode
*dir
= data
->dir
;
89 if (!NFS_PROTO(dir
)->unlink_done(task
, dir
))
90 nfs_restart_rpc(task
, NFS_SERVER(dir
)->nfs_client
);
94 * nfs_async_unlink_release - Release the sillydelete data.
95 * @task: rpc_task of the sillydelete
97 * We need to call nfs_put_unlinkdata as a 'tk_release' task since the
98 * rpc_task would be freed too.
100 static void nfs_async_unlink_release(void *calldata
)
102 struct nfs_unlinkdata
*data
= calldata
;
103 struct super_block
*sb
= data
->dir
->i_sb
;
105 nfs_dec_sillycount(data
->dir
);
106 nfs_free_unlinkdata(data
);
110 #if defined(CONFIG_NFS_V4_1)
111 void nfs_unlink_prepare(struct rpc_task
*task
, void *calldata
)
113 struct nfs_unlinkdata
*data
= calldata
;
114 struct nfs_server
*server
= NFS_SERVER(data
->dir
);
116 if (nfs4_setup_sequence(server
, &data
->args
.seq_args
,
117 &data
->res
.seq_res
, 1, task
))
119 rpc_call_start(task
);
121 #endif /* CONFIG_NFS_V4_1 */
123 static const struct rpc_call_ops nfs_unlink_ops
= {
124 .rpc_call_done
= nfs_async_unlink_done
,
125 .rpc_release
= nfs_async_unlink_release
,
126 #if defined(CONFIG_NFS_V4_1)
127 .rpc_call_prepare
= nfs_unlink_prepare
,
128 #endif /* CONFIG_NFS_V4_1 */
131 static int nfs_do_call_unlink(struct dentry
*parent
, struct inode
*dir
, struct nfs_unlinkdata
*data
)
133 struct rpc_message msg
= {
134 .rpc_argp
= &data
->args
,
135 .rpc_resp
= &data
->res
,
136 .rpc_cred
= data
->cred
,
138 struct rpc_task_setup task_setup_data
= {
140 .callback_ops
= &nfs_unlink_ops
,
141 .callback_data
= data
,
142 .workqueue
= nfsiod_workqueue
,
143 .flags
= RPC_TASK_ASYNC
,
145 struct rpc_task
*task
;
146 struct dentry
*alias
;
148 alias
= d_lookup(parent
, &data
->args
.name
);
153 * Hey, we raced with lookup... See if we need to transfer
154 * the sillyrename information to the aliased dentry.
156 nfs_free_dname(data
);
157 spin_lock(&alias
->d_lock
);
158 if (alias
->d_inode
!= NULL
&&
159 !(alias
->d_flags
& DCACHE_NFSFS_RENAMED
)) {
160 alias
->d_fsdata
= data
;
161 alias
->d_flags
|= DCACHE_NFSFS_RENAMED
;
164 spin_unlock(&alias
->d_lock
);
165 nfs_dec_sillycount(dir
);
169 data
->dir
= igrab(dir
);
171 nfs_dec_sillycount(dir
);
174 nfs_sb_active(dir
->i_sb
);
175 data
->args
.fh
= NFS_FH(dir
);
176 nfs_fattr_init(data
->res
.dir_attr
);
178 NFS_PROTO(dir
)->unlink_setup(&msg
, dir
);
180 task_setup_data
.rpc_client
= NFS_CLIENT(dir
);
181 task
= rpc_run_task(&task_setup_data
);
187 static int nfs_call_unlink(struct dentry
*dentry
, struct nfs_unlinkdata
*data
)
189 struct dentry
*parent
;
194 parent
= dget_parent(dentry
);
197 dir
= parent
->d_inode
;
198 if (nfs_copy_dname(dentry
, data
) != 0)
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
);
209 spin_unlock(&dir
->i_lock
);
210 ret
= nfs_do_call_unlink(parent
, dir
, data
);
217 void nfs_block_sillyrename(struct dentry
*dentry
)
219 struct nfs_inode
*nfsi
= NFS_I(dentry
->d_inode
);
221 wait_event(nfsi
->waitqueue
, atomic_cmpxchg(&nfsi
->silly_count
, 1, 0) == 1);
224 void nfs_unblock_sillyrename(struct dentry
*dentry
)
226 struct inode
*dir
= dentry
->d_inode
;
227 struct nfs_inode
*nfsi
= NFS_I(dir
);
228 struct nfs_unlinkdata
*data
;
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
))
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
);
242 spin_unlock(&dir
->i_lock
);
246 * nfs_async_unlink - asynchronous unlinking of a file
247 * @dir: parent directory of dentry
248 * @dentry: dentry to unlink
251 nfs_async_unlink(struct inode
*dir
, struct dentry
*dentry
)
253 struct nfs_unlinkdata
*data
;
254 int status
= -ENOMEM
;
256 data
= kzalloc(sizeof(*data
), GFP_KERNEL
);
260 data
->cred
= rpc_lookup_cred();
261 if (IS_ERR(data
->cred
)) {
262 status
= PTR_ERR(data
->cred
);
265 data
->res
.seq_res
.sr_slotid
= NFS4_MAX_SLOT_TABLE
;
266 data
->res
.dir_attr
= &data
->dir_attr
;
269 spin_lock(&dentry
->d_lock
);
270 if (dentry
->d_flags
& DCACHE_NFSFS_RENAMED
)
272 dentry
->d_flags
|= DCACHE_NFSFS_RENAMED
;
273 dentry
->d_fsdata
= data
;
274 spin_unlock(&dentry
->d_lock
);
277 spin_unlock(&dentry
->d_lock
);
278 put_rpccred(data
->cred
);
286 * nfs_complete_unlink - Initialize completion of the sillydelete
287 * @dentry: dentry to delete
290 * Since we're most likely to be called by dentry_iput(), we
291 * only use the dentry to find the sillydelete. We then copy the name
295 nfs_complete_unlink(struct dentry
*dentry
, struct inode
*inode
)
297 struct nfs_unlinkdata
*data
= NULL
;
299 spin_lock(&dentry
->d_lock
);
300 if (dentry
->d_flags
& DCACHE_NFSFS_RENAMED
) {
301 dentry
->d_flags
&= ~DCACHE_NFSFS_RENAMED
;
302 data
= dentry
->d_fsdata
;
304 spin_unlock(&dentry
->d_lock
);
306 if (data
!= NULL
&& (NFS_STALE(inode
) || !nfs_call_unlink(dentry
, data
)))
307 nfs_free_unlinkdata(data
);
311 * nfs_sillyrename - Perform a silly-rename of a dentry
312 * @dir: inode of directory that contains dentry
313 * @dentry: dentry to be sillyrenamed
315 * NFSv2/3 is stateless and the server doesn't know when the client is
316 * holding a file open. To prevent application problems when a file is
317 * unlinked while it's still open, the client performs a "silly-rename".
318 * That is, it renames the file to a hidden file in the same directory,
319 * and only performs the unlink once the last reference to it is put.
321 * The final cleanup is done during dentry_iput.
324 nfs_sillyrename(struct inode
*dir
, struct dentry
*dentry
)
326 static unsigned int sillycounter
;
327 const int fileidsize
= sizeof(NFS_FILEID(dentry
->d_inode
))*2;
328 const int countersize
= sizeof(sillycounter
)*2;
329 const int slen
= sizeof(".nfs")+fileidsize
+countersize
-1;
332 struct dentry
*sdentry
;
335 dfprintk(VFS
, "NFS: silly-rename(%s/%s, ct=%d)\n",
336 dentry
->d_parent
->d_name
.name
, dentry
->d_name
.name
,
337 atomic_read(&dentry
->d_count
));
338 nfs_inc_stats(dir
, NFSIOS_SILLYRENAME
);
341 * We don't allow a dentry to be silly-renamed twice.
344 if (dentry
->d_flags
& DCACHE_NFSFS_RENAMED
)
347 sprintf(silly
, ".nfs%*.*Lx",
348 fileidsize
, fileidsize
,
349 (unsigned long long)NFS_FILEID(dentry
->d_inode
));
351 /* Return delegation in anticipation of the rename */
352 nfs_inode_return_delegation(dentry
->d_inode
);
356 char *suffix
= silly
+ slen
- countersize
;
360 sprintf(suffix
, "%*.*x", countersize
, countersize
, sillycounter
);
362 dfprintk(VFS
, "NFS: trying to rename %s to %s\n",
363 dentry
->d_name
.name
, silly
);
365 sdentry
= lookup_one_len(silly
, dentry
->d_parent
, slen
);
367 * N.B. Better to return EBUSY here ... it could be
368 * dangerous to delete the file while it's in use.
372 } while (sdentry
->d_inode
!= NULL
); /* need negative lookup */
375 qsilly
.len
= strlen(silly
);
376 error
= NFS_PROTO(dir
)->rename(dir
, &dentry
->d_name
, dir
, &qsilly
);
378 nfs_mark_for_revalidate(dentry
->d_inode
);
380 nfs_set_verifier(dentry
, nfs_save_change_attribute(dir
));
381 d_move(dentry
, sdentry
);
382 error
= nfs_async_unlink(dir
, dentry
);
383 /* If we return 0 we don't unlink */