2 * linux/fs/nfs/unlink.c
4 * nfs sillydelete handling
6 * NOTE: we rely on holding the BKL for list manipulation protection.
9 #include <linux/slab.h>
10 #include <linux/string.h>
11 #include <linux/dcache.h>
12 #include <linux/sunrpc/sched.h>
13 #include <linux/sunrpc/clnt.h>
14 #include <linux/nfs_fs.h>
17 struct nfs_unlinkdata {
18 struct nfs_unlinkdata *next;
19 struct dentry *dir, *dentry;
22 struct rpc_cred *cred;
26 static struct nfs_unlinkdata *nfs_deletes;
27 static RPC_WAITQ(nfs_delete_queue, "nfs_delete_queue");
30 * nfs_detach_unlinkdata - Remove asynchronous unlink from global list
31 * @data: pointer to descriptor
34 nfs_detach_unlinkdata(struct nfs_unlinkdata *data)
36 struct nfs_unlinkdata **q;
38 for (q = &nfs_deletes; *q != NULL; q = &((*q)->next)) {
47 * nfs_put_unlinkdata - release data from a sillydelete operation.
48 * @data: pointer to unlink structure.
51 nfs_put_unlinkdata(struct nfs_unlinkdata *data)
53 if (--data->count == 0) {
54 nfs_detach_unlinkdata(data);
55 kfree(data->name.name);
60 #define NAME_ALLOC_LEN(len) ((len+16) & ~15)
62 * nfs_copy_dname - copy dentry name to data structure
63 * @dentry: pointer to dentry
64 * @data: nfs_unlinkdata
67 nfs_copy_dname(struct dentry *dentry, struct nfs_unlinkdata *data)
70 int len = dentry->d_name.len;
72 str = kmalloc(NAME_ALLOC_LEN(len), GFP_KERNEL);
75 memcpy(str, dentry->d_name.name, len);
76 if (!data->name.len) {
78 data->name.name = str;
84 * nfs_async_unlink_init - Initialize the RPC info
85 * @task: rpc_task of the sillydelete
87 * We delay initializing RPC info until after the call to dentry_iput()
88 * in order to minimize races against rename().
91 nfs_async_unlink_init(struct rpc_task *task)
93 struct nfs_unlinkdata *data = (struct nfs_unlinkdata *)task->tk_calldata;
94 struct dentry *dir = data->dir;
95 struct rpc_message msg = {
96 .rpc_cred = data->cred,
103 status = NFS_PROTO(dir->d_inode)->unlink_setup(&msg, dir, &data->name);
106 nfs_begin_data_update(dir->d_inode);
107 rpc_call_setup(task, &msg, 0);
110 rpc_exit(task, status);
114 * nfs_async_unlink_done - Sillydelete post-processing
115 * @task: rpc_task of the sillydelete
117 * Do the directory attribute update.
119 static void nfs_async_unlink_done(struct rpc_task *task, void *calldata)
121 struct nfs_unlinkdata *data = calldata;
122 struct dentry *dir = data->dir;
127 dir_i = dir->d_inode;
128 nfs_end_data_update(dir_i);
129 if (NFS_PROTO(dir_i)->unlink_done(dir, task))
131 put_rpccred(data->cred);
137 * nfs_async_unlink_release - Release the sillydelete data.
138 * @task: rpc_task of the sillydelete
140 * We need to call nfs_put_unlinkdata as a 'tk_release' task since the
141 * rpc_task would be freed too.
143 static void nfs_async_unlink_release(void *calldata)
145 struct nfs_unlinkdata *data = calldata;
146 nfs_put_unlinkdata(data);
149 static const struct rpc_call_ops nfs_unlink_ops = {
150 .rpc_call_done = nfs_async_unlink_done,
151 .rpc_release = nfs_async_unlink_release,
155 * nfs_async_unlink - asynchronous unlinking of a file
156 * @dentry: dentry to unlink
159 nfs_async_unlink(struct dentry *dentry)
161 struct dentry *dir = dentry->d_parent;
162 struct nfs_unlinkdata *data;
163 struct rpc_task *task;
164 struct rpc_clnt *clnt = NFS_CLIENT(dir->d_inode);
165 int status = -ENOMEM;
167 data = kmalloc(sizeof(*data), GFP_KERNEL);
170 memset(data, 0, sizeof(*data));
172 data->cred = rpcauth_lookupcred(clnt->cl_auth, 0);
173 if (IS_ERR(data->cred)) {
174 status = PTR_ERR(data->cred);
177 data->dir = dget(dir);
178 data->dentry = dentry;
180 data->next = nfs_deletes;
185 rpc_init_task(task, clnt, RPC_TASK_ASYNC, &nfs_unlink_ops, data);
186 task->tk_action = nfs_async_unlink_init;
188 spin_lock(&dentry->d_lock);
189 dentry->d_flags |= DCACHE_NFSFS_RENAMED;
190 spin_unlock(&dentry->d_lock);
192 rpc_sleep_on(&nfs_delete_queue, task, NULL, NULL);
202 * nfs_complete_unlink - Initialize completion of the sillydelete
203 * @dentry: dentry to delete
205 * Since we're most likely to be called by dentry_iput(), we
206 * only use the dentry to find the sillydelete. We then copy the name
210 nfs_complete_unlink(struct dentry *dentry)
212 struct nfs_unlinkdata *data;
214 for(data = nfs_deletes; data != NULL; data = data->next) {
215 if (dentry == data->dentry)
221 nfs_copy_dname(dentry, data);
222 spin_lock(&dentry->d_lock);
223 dentry->d_flags &= ~DCACHE_NFSFS_RENAMED;
224 spin_unlock(&dentry->d_lock);
225 rpc_wake_up_task(&data->task);
226 nfs_put_unlinkdata(data);