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