Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * linux/fs/nfs/unlink.c | |
3 | * | |
4 | * nfs sillydelete handling | |
5 | * | |
1da177e4 LT |
6 | */ |
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> | |
b35e7041 LT |
14 | #include <linux/sched.h> |
15 | #include <linux/wait.h> | |
1da177e4 | 16 | |
ef818a28 | 17 | #include "internal.h" |
472cfbd9 | 18 | #include "nfs4_fs.h" |
ef818a28 | 19 | |
1da177e4 | 20 | struct nfs_unlinkdata { |
565277f6 | 21 | struct hlist_node list; |
e4eff1a6 TM |
22 | struct nfs_removeargs args; |
23 | struct nfs_removeres res; | |
24 | struct inode *dir; | |
1da177e4 | 25 | struct rpc_cred *cred; |
1da177e4 LT |
26 | }; |
27 | ||
1da177e4 | 28 | /** |
e4eff1a6 | 29 | * nfs_free_unlinkdata - release data from a sillydelete operation. |
1da177e4 LT |
30 | * @data: pointer to unlink structure. |
31 | */ | |
32 | static void | |
e4eff1a6 | 33 | nfs_free_unlinkdata(struct nfs_unlinkdata *data) |
1da177e4 | 34 | { |
e4eff1a6 TM |
35 | iput(data->dir); |
36 | put_rpccred(data->cred); | |
37 | kfree(data->args.name.name); | |
38 | kfree(data); | |
1da177e4 LT |
39 | } |
40 | ||
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 | |
46 | */ | |
e4eff1a6 | 47 | static int nfs_copy_dname(struct dentry *dentry, struct nfs_unlinkdata *data) |
1da177e4 LT |
48 | { |
49 | char *str; | |
50 | int len = dentry->d_name.len; | |
51 | ||
e4eff1a6 | 52 | str = kmemdup(dentry->d_name.name, NAME_ALLOC_LEN(len), GFP_KERNEL); |
1da177e4 | 53 | if (!str) |
e4eff1a6 TM |
54 | return -ENOMEM; |
55 | data->args.name.len = len; | |
56 | data->args.name.name = str; | |
57 | return 0; | |
1da177e4 LT |
58 | } |
59 | ||
565277f6 TM |
60 | static void nfs_free_dname(struct nfs_unlinkdata *data) |
61 | { | |
62 | kfree(data->args.name.name); | |
63 | data->args.name.name = NULL; | |
64 | data->args.name.len = 0; | |
65 | } | |
66 | ||
67 | static void nfs_dec_sillycount(struct inode *dir) | |
68 | { | |
69 | struct nfs_inode *nfsi = NFS_I(dir); | |
70 | if (atomic_dec_return(&nfsi->silly_count) == 1) | |
71 | wake_up(&nfsi->waitqueue); | |
72 | } | |
73 | ||
1da177e4 LT |
74 | /** |
75 | * nfs_async_unlink_done - Sillydelete post-processing | |
76 | * @task: rpc_task of the sillydelete | |
77 | * | |
78 | * Do the directory attribute update. | |
79 | */ | |
963d8fe5 | 80 | static void nfs_async_unlink_done(struct rpc_task *task, void *calldata) |
1da177e4 | 81 | { |
e4eff1a6 TM |
82 | struct nfs_unlinkdata *data = calldata; |
83 | struct inode *dir = data->dir; | |
84 | ||
85 | if (!NFS_PROTO(dir)->unlink_done(task, dir)) | |
eedc020e | 86 | nfs4_restart_rpc(task, NFS_SERVER(dir)->nfs_client); |
1da177e4 LT |
87 | } |
88 | ||
89 | /** | |
90 | * nfs_async_unlink_release - Release the sillydelete data. | |
91 | * @task: rpc_task of the sillydelete | |
92 | * | |
93 | * We need to call nfs_put_unlinkdata as a 'tk_release' task since the | |
94 | * rpc_task would be freed too. | |
95 | */ | |
963d8fe5 | 96 | static void nfs_async_unlink_release(void *calldata) |
1da177e4 | 97 | { |
963d8fe5 | 98 | struct nfs_unlinkdata *data = calldata; |
744d18db | 99 | struct super_block *sb = data->dir->i_sb; |
565277f6 TM |
100 | |
101 | nfs_dec_sillycount(data->dir); | |
e4eff1a6 | 102 | nfs_free_unlinkdata(data); |
1daef0a8 | 103 | nfs_sb_deactive(sb); |
1da177e4 LT |
104 | } |
105 | ||
472cfbd9 AA |
106 | #if defined(CONFIG_NFS_V4_1) |
107 | void nfs_unlink_prepare(struct rpc_task *task, void *calldata) | |
108 | { | |
109 | struct nfs_unlinkdata *data = calldata; | |
110 | struct nfs_server *server = NFS_SERVER(data->dir); | |
111 | ||
112 | if (nfs4_setup_sequence(server->nfs_client, &data->args.seq_args, | |
113 | &data->res.seq_res, 1, task)) | |
114 | return; | |
115 | rpc_call_start(task); | |
116 | } | |
117 | #endif /* CONFIG_NFS_V4_1 */ | |
118 | ||
963d8fe5 TM |
119 | static const struct rpc_call_ops nfs_unlink_ops = { |
120 | .rpc_call_done = nfs_async_unlink_done, | |
121 | .rpc_release = nfs_async_unlink_release, | |
472cfbd9 AA |
122 | #if defined(CONFIG_NFS_V4_1) |
123 | .rpc_call_prepare = nfs_unlink_prepare, | |
124 | #endif /* CONFIG_NFS_V4_1 */ | |
963d8fe5 TM |
125 | }; |
126 | ||
565277f6 | 127 | static int nfs_do_call_unlink(struct dentry *parent, struct inode *dir, struct nfs_unlinkdata *data) |
e4eff1a6 | 128 | { |
5138fde0 TM |
129 | struct rpc_message msg = { |
130 | .rpc_argp = &data->args, | |
131 | .rpc_resp = &data->res, | |
132 | .rpc_cred = data->cred, | |
133 | }; | |
c970aa85 | 134 | struct rpc_task_setup task_setup_data = { |
5138fde0 | 135 | .rpc_message = &msg, |
c970aa85 TM |
136 | .callback_ops = &nfs_unlink_ops, |
137 | .callback_data = data, | |
1daef0a8 | 138 | .workqueue = nfsiod_workqueue, |
c970aa85 TM |
139 | .flags = RPC_TASK_ASYNC, |
140 | }; | |
e4eff1a6 | 141 | struct rpc_task *task; |
565277f6 TM |
142 | struct dentry *alias; |
143 | ||
144 | alias = d_lookup(parent, &data->args.name); | |
145 | if (alias != NULL) { | |
146 | int ret = 0; | |
609005c3 | 147 | |
565277f6 TM |
148 | /* |
149 | * Hey, we raced with lookup... See if we need to transfer | |
150 | * the sillyrename information to the aliased dentry. | |
151 | */ | |
152 | nfs_free_dname(data); | |
153 | spin_lock(&alias->d_lock); | |
609005c3 TM |
154 | if (alias->d_inode != NULL && |
155 | !(alias->d_flags & DCACHE_NFSFS_RENAMED)) { | |
565277f6 | 156 | alias->d_fsdata = data; |
fccca7fc | 157 | alias->d_flags |= DCACHE_NFSFS_RENAMED; |
565277f6 TM |
158 | ret = 1; |
159 | } | |
160 | spin_unlock(&alias->d_lock); | |
161 | nfs_dec_sillycount(dir); | |
162 | dput(alias); | |
163 | return ret; | |
164 | } | |
165 | data->dir = igrab(dir); | |
166 | if (!data->dir) { | |
167 | nfs_dec_sillycount(dir); | |
168 | return 0; | |
169 | } | |
1daef0a8 | 170 | nfs_sb_active(dir->i_sb); |
565277f6 TM |
171 | data->args.fh = NFS_FH(dir); |
172 | nfs_fattr_init(&data->res.dir_attr); | |
173 | ||
5138fde0 | 174 | NFS_PROTO(dir)->unlink_setup(&msg, dir); |
c970aa85 | 175 | |
5138fde0 | 176 | task_setup_data.rpc_client = NFS_CLIENT(dir); |
c970aa85 | 177 | task = rpc_run_task(&task_setup_data); |
565277f6 TM |
178 | if (!IS_ERR(task)) |
179 | rpc_put_task(task); | |
180 | return 1; | |
181 | } | |
182 | ||
183 | static int nfs_call_unlink(struct dentry *dentry, struct nfs_unlinkdata *data) | |
184 | { | |
e4eff1a6 TM |
185 | struct dentry *parent; |
186 | struct inode *dir; | |
565277f6 | 187 | int ret = 0; |
e4eff1a6 | 188 | |
e4eff1a6 TM |
189 | |
190 | parent = dget_parent(dentry); | |
191 | if (parent == NULL) | |
192 | goto out_free; | |
565277f6 | 193 | dir = parent->d_inode; |
55b70a03 | 194 | if (nfs_copy_dname(dentry, data) != 0) |
565277f6 TM |
195 | goto out_dput; |
196 | /* Non-exclusive lock protects against concurrent lookup() calls */ | |
197 | spin_lock(&dir->i_lock); | |
198 | if (atomic_inc_not_zero(&NFS_I(dir)->silly_count) == 0) { | |
199 | /* Deferred delete */ | |
200 | hlist_add_head(&data->list, &NFS_I(dir)->silly_list); | |
201 | spin_unlock(&dir->i_lock); | |
202 | ret = 1; | |
203 | goto out_dput; | |
204 | } | |
205 | spin_unlock(&dir->i_lock); | |
206 | ret = nfs_do_call_unlink(parent, dir, data); | |
207 | out_dput: | |
e4eff1a6 | 208 | dput(parent); |
565277f6 TM |
209 | out_free: |
210 | return ret; | |
211 | } | |
e4eff1a6 | 212 | |
565277f6 TM |
213 | void nfs_block_sillyrename(struct dentry *dentry) |
214 | { | |
215 | struct nfs_inode *nfsi = NFS_I(dentry->d_inode); | |
e4eff1a6 | 216 | |
565277f6 TM |
217 | wait_event(nfsi->waitqueue, atomic_cmpxchg(&nfsi->silly_count, 1, 0) == 1); |
218 | } | |
219 | ||
220 | void nfs_unblock_sillyrename(struct dentry *dentry) | |
221 | { | |
222 | struct inode *dir = dentry->d_inode; | |
223 | struct nfs_inode *nfsi = NFS_I(dir); | |
224 | struct nfs_unlinkdata *data; | |
225 | ||
226 | atomic_inc(&nfsi->silly_count); | |
227 | spin_lock(&dir->i_lock); | |
228 | while (!hlist_empty(&nfsi->silly_list)) { | |
229 | if (!atomic_inc_not_zero(&nfsi->silly_count)) | |
230 | break; | |
231 | data = hlist_entry(nfsi->silly_list.first, struct nfs_unlinkdata, list); | |
232 | hlist_del(&data->list); | |
233 | spin_unlock(&dir->i_lock); | |
234 | if (nfs_do_call_unlink(dentry, dir, data) == 0) | |
235 | nfs_free_unlinkdata(data); | |
236 | spin_lock(&dir->i_lock); | |
237 | } | |
238 | spin_unlock(&dir->i_lock); | |
e4eff1a6 TM |
239 | } |
240 | ||
1da177e4 LT |
241 | /** |
242 | * nfs_async_unlink - asynchronous unlinking of a file | |
e4eff1a6 | 243 | * @dir: parent directory of dentry |
1da177e4 LT |
244 | * @dentry: dentry to unlink |
245 | */ | |
246 | int | |
e4eff1a6 | 247 | nfs_async_unlink(struct inode *dir, struct dentry *dentry) |
1da177e4 | 248 | { |
e4eff1a6 TM |
249 | struct nfs_unlinkdata *data; |
250 | int status = -ENOMEM; | |
1da177e4 | 251 | |
bd647545 | 252 | data = kzalloc(sizeof(*data), GFP_KERNEL); |
e4eff1a6 | 253 | if (data == NULL) |
1da177e4 | 254 | goto out; |
1da177e4 | 255 | |
98a8e323 | 256 | data->cred = rpc_lookup_cred(); |
1da177e4 LT |
257 | if (IS_ERR(data->cred)) { |
258 | status = PTR_ERR(data->cred); | |
259 | goto out_free; | |
260 | } | |
5f7dbd5c | 261 | data->res.seq_res.sr_slotid = NFS4_MAX_SLOT_TABLE; |
1da177e4 | 262 | |
e4eff1a6 | 263 | status = -EBUSY; |
1da177e4 | 264 | spin_lock(&dentry->d_lock); |
e4eff1a6 TM |
265 | if (dentry->d_flags & DCACHE_NFSFS_RENAMED) |
266 | goto out_unlock; | |
1da177e4 | 267 | dentry->d_flags |= DCACHE_NFSFS_RENAMED; |
e4eff1a6 | 268 | dentry->d_fsdata = data; |
1da177e4 | 269 | spin_unlock(&dentry->d_lock); |
e4eff1a6 TM |
270 | return 0; |
271 | out_unlock: | |
272 | spin_unlock(&dentry->d_lock); | |
273 | put_rpccred(data->cred); | |
1da177e4 LT |
274 | out_free: |
275 | kfree(data); | |
e4eff1a6 | 276 | out: |
1da177e4 LT |
277 | return status; |
278 | } | |
279 | ||
280 | /** | |
281 | * nfs_complete_unlink - Initialize completion of the sillydelete | |
282 | * @dentry: dentry to delete | |
e4eff1a6 | 283 | * @inode: inode |
1da177e4 LT |
284 | * |
285 | * Since we're most likely to be called by dentry_iput(), we | |
286 | * only use the dentry to find the sillydelete. We then copy the name | |
287 | * into the qstr. | |
288 | */ | |
289 | void | |
e4eff1a6 | 290 | nfs_complete_unlink(struct dentry *dentry, struct inode *inode) |
1da177e4 | 291 | { |
e4eff1a6 | 292 | struct nfs_unlinkdata *data = NULL; |
1da177e4 | 293 | |
1da177e4 | 294 | spin_lock(&dentry->d_lock); |
e4eff1a6 TM |
295 | if (dentry->d_flags & DCACHE_NFSFS_RENAMED) { |
296 | dentry->d_flags &= ~DCACHE_NFSFS_RENAMED; | |
297 | data = dentry->d_fsdata; | |
298 | } | |
1da177e4 | 299 | spin_unlock(&dentry->d_lock); |
e4eff1a6 TM |
300 | |
301 | if (data != NULL && (NFS_STALE(inode) || !nfs_call_unlink(dentry, data))) | |
302 | nfs_free_unlinkdata(data); | |
1da177e4 | 303 | } |