Commit | Line | Data |
---|---|---|
b4d0d230 | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
79ddbfa5 DH |
2 | /* AFS silly rename handling |
3 | * | |
4 | * Copyright (C) 2019 Red Hat, Inc. All Rights Reserved. | |
5 | * Written by David Howells (dhowells@redhat.com) | |
6 | * - Derived from NFS's sillyrename. | |
79ddbfa5 DH |
7 | */ |
8 | ||
9 | #include <linux/kernel.h> | |
10 | #include <linux/fs.h> | |
11 | #include <linux/namei.h> | |
12 | #include <linux/fsnotify.h> | |
13 | #include "internal.h" | |
14 | ||
e49c7b2f DH |
15 | static void afs_silly_rename_success(struct afs_operation *op) |
16 | { | |
17 | _enter("op=%08x", op->debug_id); | |
18 | ||
b6489a49 | 19 | afs_check_dir_conflict(op, &op->file[0]); |
e49c7b2f DH |
20 | afs_vnode_commit_status(op, &op->file[0]); |
21 | } | |
22 | ||
23 | static void afs_silly_rename_edit_dir(struct afs_operation *op) | |
24 | { | |
25 | struct afs_vnode_param *dvp = &op->file[0]; | |
26 | struct afs_vnode *dvnode = dvp->vnode; | |
27 | struct afs_vnode *vnode = AFS_FS_I(d_inode(op->dentry)); | |
28 | struct dentry *old = op->dentry; | |
29 | struct dentry *new = op->dentry_2; | |
30 | ||
31 | spin_lock(&old->d_lock); | |
32 | old->d_flags |= DCACHE_NFSFS_RENAMED; | |
33 | spin_unlock(&old->d_lock); | |
34 | if (dvnode->silly_key != op->key) { | |
35 | key_put(dvnode->silly_key); | |
36 | dvnode->silly_key = key_get(op->key); | |
37 | } | |
38 | ||
39 | down_write(&dvnode->validate_lock); | |
40 | if (test_bit(AFS_VNODE_DIR_VALID, &dvnode->flags) && | |
41 | dvnode->status.data_version == dvp->dv_before + dvp->dv_delta) { | |
42 | afs_edit_dir_remove(dvnode, &old->d_name, | |
43 | afs_edit_dir_for_silly_0); | |
44 | afs_edit_dir_add(dvnode, &new->d_name, | |
45 | &vnode->fid, afs_edit_dir_for_silly_1); | |
46 | } | |
47 | up_write(&dvnode->validate_lock); | |
48 | } | |
49 | ||
50 | static const struct afs_operation_ops afs_silly_rename_operation = { | |
51 | .issue_afs_rpc = afs_fs_rename, | |
52 | .issue_yfs_rpc = yfs_fs_rename, | |
53 | .success = afs_silly_rename_success, | |
54 | .edit_dir = afs_silly_rename_edit_dir, | |
55 | }; | |
56 | ||
79ddbfa5 DH |
57 | /* |
58 | * Actually perform the silly rename step. | |
59 | */ | |
60 | static int afs_do_silly_rename(struct afs_vnode *dvnode, struct afs_vnode *vnode, | |
61 | struct dentry *old, struct dentry *new, | |
62 | struct key *key) | |
63 | { | |
e49c7b2f | 64 | struct afs_operation *op; |
79ddbfa5 DH |
65 | |
66 | _enter("%pd,%pd", old, new); | |
67 | ||
e49c7b2f DH |
68 | op = afs_alloc_operation(key, dvnode->volume); |
69 | if (IS_ERR(op)) | |
70 | return PTR_ERR(op); | |
a58823ac | 71 | |
e49c7b2f | 72 | afs_op_set_vnode(op, 0, dvnode); |
b6489a49 DH |
73 | afs_op_set_vnode(op, 1, dvnode); |
74 | op->file[0].dv_delta = 1; | |
75 | op->file[1].dv_delta = 1; | |
22650f14 DH |
76 | op->file[0].modification = true; |
77 | op->file[1].modification = true; | |
b6489a49 DH |
78 | op->file[0].update_ctime = true; |
79 | op->file[1].update_ctime = true; | |
79ddbfa5 | 80 | |
e49c7b2f DH |
81 | op->dentry = old; |
82 | op->dentry_2 = new; | |
83 | op->ops = &afs_silly_rename_operation; | |
79ddbfa5 | 84 | |
e49c7b2f DH |
85 | trace_afs_silly_rename(vnode, false); |
86 | return afs_do_sync_operation(op); | |
79ddbfa5 DH |
87 | } |
88 | ||
dcb442b1 DH |
89 | /* |
90 | * Perform silly-rename of a dentry. | |
79ddbfa5 DH |
91 | * |
92 | * AFS is stateless and the server doesn't know when the client is holding a | |
93 | * file open. To prevent application problems when a file is unlinked while | |
94 | * it's still open, the client performs a "silly-rename". That is, it renames | |
95 | * the file to a hidden file in the same directory, and only performs the | |
96 | * unlink once the last reference to it is put. | |
97 | * | |
98 | * The final cleanup is done during dentry_iput. | |
99 | */ | |
100 | int afs_sillyrename(struct afs_vnode *dvnode, struct afs_vnode *vnode, | |
101 | struct dentry *dentry, struct key *key) | |
102 | { | |
103 | static unsigned int sillycounter; | |
104 | struct dentry *sdentry = NULL; | |
105 | unsigned char silly[16]; | |
106 | int ret = -EBUSY; | |
107 | ||
108 | _enter(""); | |
109 | ||
110 | /* We don't allow a dentry to be silly-renamed twice. */ | |
111 | if (dentry->d_flags & DCACHE_NFSFS_RENAMED) | |
112 | return -EBUSY; | |
113 | ||
114 | sdentry = NULL; | |
115 | do { | |
116 | int slen; | |
117 | ||
118 | dput(sdentry); | |
119 | sillycounter++; | |
120 | ||
121 | /* Create a silly name. Note that the ".__afs" prefix is | |
122 | * understood by the salvager and must not be changed. | |
123 | */ | |
124 | slen = scnprintf(silly, sizeof(silly), ".__afs%04X", sillycounter); | |
125 | sdentry = lookup_one_len(silly, dentry->d_parent, slen); | |
126 | ||
127 | /* N.B. Better to return EBUSY here ... it could be dangerous | |
128 | * to delete the file while it's in use. | |
129 | */ | |
130 | if (IS_ERR(sdentry)) | |
131 | goto out; | |
132 | } while (!d_is_negative(sdentry)); | |
133 | ||
874c8ca1 | 134 | ihold(&vnode->netfs.inode); |
79ddbfa5 DH |
135 | |
136 | ret = afs_do_silly_rename(dvnode, vnode, dentry, sdentry, key); | |
137 | switch (ret) { | |
138 | case 0: | |
139 | /* The rename succeeded. */ | |
b6489a49 | 140 | set_bit(AFS_VNODE_SILLY_DELETED, &vnode->flags); |
79ddbfa5 DH |
141 | d_move(dentry, sdentry); |
142 | break; | |
143 | case -ERESTARTSYS: | |
144 | /* The result of the rename is unknown. Play it safe by forcing | |
145 | * a new lookup. | |
146 | */ | |
147 | d_drop(dentry); | |
148 | d_drop(sdentry); | |
149 | } | |
150 | ||
874c8ca1 | 151 | iput(&vnode->netfs.inode); |
79ddbfa5 DH |
152 | dput(sdentry); |
153 | out: | |
154 | _leave(" = %d", ret); | |
155 | return ret; | |
156 | } | |
157 | ||
e49c7b2f DH |
158 | static void afs_silly_unlink_success(struct afs_operation *op) |
159 | { | |
e49c7b2f | 160 | _enter("op=%08x", op->debug_id); |
b6489a49 | 161 | afs_check_dir_conflict(op, &op->file[0]); |
e49c7b2f DH |
162 | afs_vnode_commit_status(op, &op->file[0]); |
163 | afs_vnode_commit_status(op, &op->file[1]); | |
164 | afs_update_dentry_version(op, &op->file[0], op->dentry); | |
e49c7b2f DH |
165 | } |
166 | ||
167 | static void afs_silly_unlink_edit_dir(struct afs_operation *op) | |
168 | { | |
169 | struct afs_vnode_param *dvp = &op->file[0]; | |
170 | struct afs_vnode *dvnode = dvp->vnode; | |
171 | ||
172 | _enter("op=%08x", op->debug_id); | |
173 | down_write(&dvnode->validate_lock); | |
174 | if (test_bit(AFS_VNODE_DIR_VALID, &dvnode->flags) && | |
175 | dvnode->status.data_version == dvp->dv_before + dvp->dv_delta) | |
176 | afs_edit_dir_remove(dvnode, &op->dentry->d_name, | |
177 | afs_edit_dir_for_unlink); | |
178 | up_write(&dvnode->validate_lock); | |
179 | } | |
180 | ||
181 | static const struct afs_operation_ops afs_silly_unlink_operation = { | |
182 | .issue_afs_rpc = afs_fs_remove_file, | |
183 | .issue_yfs_rpc = yfs_fs_remove_file, | |
184 | .success = afs_silly_unlink_success, | |
728279a5 | 185 | .aborted = afs_check_for_remote_deletion, |
e49c7b2f DH |
186 | .edit_dir = afs_silly_unlink_edit_dir, |
187 | }; | |
188 | ||
79ddbfa5 DH |
189 | /* |
190 | * Tell the server to remove a sillyrename file. | |
191 | */ | |
192 | static int afs_do_silly_unlink(struct afs_vnode *dvnode, struct afs_vnode *vnode, | |
193 | struct dentry *dentry, struct key *key) | |
194 | { | |
e49c7b2f | 195 | struct afs_operation *op; |
79ddbfa5 DH |
196 | |
197 | _enter(""); | |
198 | ||
e49c7b2f DH |
199 | op = afs_alloc_operation(NULL, dvnode->volume); |
200 | if (IS_ERR(op)) | |
201 | return PTR_ERR(op); | |
a58823ac | 202 | |
e49c7b2f DH |
203 | afs_op_set_vnode(op, 0, dvnode); |
204 | afs_op_set_vnode(op, 1, vnode); | |
b6489a49 | 205 | op->file[0].dv_delta = 1; |
22650f14 | 206 | op->file[0].modification = true; |
b6489a49 DH |
207 | op->file[0].update_ctime = true; |
208 | op->file[1].op_unlinked = true; | |
209 | op->file[1].update_ctime = true; | |
79ddbfa5 | 210 | |
e49c7b2f DH |
211 | op->dentry = dentry; |
212 | op->ops = &afs_silly_unlink_operation; | |
213 | ||
214 | trace_afs_silly_rename(vnode, true); | |
b6489a49 DH |
215 | afs_begin_vnode_operation(op); |
216 | afs_wait_for_operation(op); | |
217 | ||
218 | /* If there was a conflict with a third party, check the status of the | |
219 | * unlinked vnode. | |
220 | */ | |
aa453bec | 221 | if (op->cumul_error.error == 0 && (op->flags & AFS_OPERATION_DIR_CONFLICT)) { |
b6489a49 DH |
222 | op->file[1].update_ctime = false; |
223 | op->fetch_status.which = 1; | |
224 | op->ops = &afs_fetch_status_operation; | |
225 | afs_begin_vnode_operation(op); | |
226 | afs_wait_for_operation(op); | |
227 | } | |
228 | ||
229 | return afs_put_operation(op); | |
79ddbfa5 DH |
230 | } |
231 | ||
232 | /* | |
233 | * Remove sillyrename file on iput. | |
234 | */ | |
235 | int afs_silly_iput(struct dentry *dentry, struct inode *inode) | |
236 | { | |
237 | struct afs_vnode *dvnode = AFS_FS_I(d_inode(dentry->d_parent)); | |
238 | struct afs_vnode *vnode = AFS_FS_I(inode); | |
239 | struct dentry *alias; | |
240 | int ret; | |
241 | ||
242 | DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq); | |
243 | ||
244 | _enter("%p{%pd},%llx", dentry, dentry, vnode->fid.vnode); | |
245 | ||
246 | down_read(&dvnode->rmdir_lock); | |
247 | ||
248 | alias = d_alloc_parallel(dentry->d_parent, &dentry->d_name, &wq); | |
249 | if (IS_ERR(alias)) { | |
250 | up_read(&dvnode->rmdir_lock); | |
251 | return 0; | |
252 | } | |
253 | ||
254 | if (!d_in_lookup(alias)) { | |
255 | /* We raced with lookup... See if we need to transfer the | |
256 | * sillyrename information to the aliased dentry. | |
257 | */ | |
258 | ret = 0; | |
259 | spin_lock(&alias->d_lock); | |
260 | if (d_really_is_positive(alias) && | |
261 | !(alias->d_flags & DCACHE_NFSFS_RENAMED)) { | |
262 | alias->d_flags |= DCACHE_NFSFS_RENAMED; | |
263 | ret = 1; | |
264 | } | |
265 | spin_unlock(&alias->d_lock); | |
266 | up_read(&dvnode->rmdir_lock); | |
267 | dput(alias); | |
268 | return ret; | |
269 | } | |
270 | ||
271 | /* Stop lock-release from complaining. */ | |
272 | spin_lock(&vnode->lock); | |
273 | vnode->lock_state = AFS_VNODE_LOCK_DELETED; | |
274 | trace_afs_flock_ev(vnode, NULL, afs_flock_silly_delete, 0); | |
275 | spin_unlock(&vnode->lock); | |
276 | ||
277 | afs_do_silly_unlink(dvnode, vnode, dentry, dvnode->silly_key); | |
278 | up_read(&dvnode->rmdir_lock); | |
279 | d_lookup_done(alias); | |
280 | dput(alias); | |
281 | return 1; | |
282 | } |