1 | // SPDX-License-Identifier: GPL-2.0-or-later |
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. |
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 | |
15 | static void afs_silly_rename_success(struct afs_operation *op) |
16 | { |
17 | _enter("op=%08x" , op->debug_id); |
18 | |
19 | afs_check_dir_conflict(op, dvp: &op->file[0]); |
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(inode: d_inode(dentry: op->dentry)); |
28 | struct dentry *old = op->dentry; |
29 | struct dentry *new = op->dentry_2; |
30 | |
31 | spin_lock(lock: &old->d_lock); |
32 | old->d_flags |= DCACHE_NFSFS_RENAMED; |
33 | spin_unlock(lock: &old->d_lock); |
34 | if (dvnode->silly_key != op->key) { |
35 | key_put(key: dvnode->silly_key); |
36 | dvnode->silly_key = key_get(key: op->key); |
37 | } |
38 | |
39 | down_write(sem: &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(sem: &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 | |
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 | { |
64 | struct afs_operation *op; |
65 | |
66 | _enter("%pd,%pd" , old, new); |
67 | |
68 | op = afs_alloc_operation(key, dvnode->volume); |
69 | if (IS_ERR(ptr: op)) |
70 | return PTR_ERR(ptr: op); |
71 | |
72 | afs_op_set_vnode(op, n: 0, vnode: dvnode); |
73 | afs_op_set_vnode(op, n: 1, vnode: dvnode); |
74 | op->file[0].dv_delta = 1; |
75 | op->file[1].dv_delta = 1; |
76 | op->file[0].modification = true; |
77 | op->file[1].modification = true; |
78 | op->file[0].update_ctime = true; |
79 | op->file[1].update_ctime = true; |
80 | |
81 | op->dentry = old; |
82 | op->dentry_2 = new; |
83 | op->ops = &afs_silly_rename_operation; |
84 | |
85 | trace_afs_silly_rename(vnode, done: false); |
86 | return afs_do_sync_operation(op); |
87 | } |
88 | |
89 | /* |
90 | * Perform silly-rename of a dentry. |
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(buf: silly, size: sizeof(silly), fmt: ".__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(ptr: sdentry)) |
131 | goto out; |
132 | } while (!d_is_negative(dentry: sdentry)); |
133 | |
134 | ihold(inode: &vnode->netfs.inode); |
135 | |
136 | ret = afs_do_silly_rename(dvnode, vnode, old: dentry, new: sdentry, key); |
137 | switch (ret) { |
138 | case 0: |
139 | /* The rename succeeded. */ |
140 | set_bit(AFS_VNODE_SILLY_DELETED, addr: &vnode->flags); |
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(dentry: sdentry); |
149 | } |
150 | |
151 | iput(&vnode->netfs.inode); |
152 | dput(sdentry); |
153 | out: |
154 | _leave(" = %d" , ret); |
155 | return ret; |
156 | } |
157 | |
158 | static void afs_silly_unlink_success(struct afs_operation *op) |
159 | { |
160 | _enter("op=%08x" , op->debug_id); |
161 | afs_check_dir_conflict(op, dvp: &op->file[0]); |
162 | afs_vnode_commit_status(op, &op->file[0]); |
163 | afs_vnode_commit_status(op, &op->file[1]); |
164 | afs_update_dentry_version(op, dir_vp: &op->file[0], dentry: op->dentry); |
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(sem: &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(sem: &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, |
185 | .aborted = afs_check_for_remote_deletion, |
186 | .edit_dir = afs_silly_unlink_edit_dir, |
187 | }; |
188 | |
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 | { |
195 | struct afs_operation *op; |
196 | |
197 | _enter("" ); |
198 | |
199 | op = afs_alloc_operation(NULL, dvnode->volume); |
200 | if (IS_ERR(ptr: op)) |
201 | return PTR_ERR(ptr: op); |
202 | |
203 | afs_op_set_vnode(op, n: 0, vnode: dvnode); |
204 | afs_op_set_vnode(op, n: 1, vnode); |
205 | op->file[0].dv_delta = 1; |
206 | op->file[0].modification = true; |
207 | op->file[0].update_ctime = true; |
208 | op->file[1].op_unlinked = true; |
209 | op->file[1].update_ctime = true; |
210 | |
211 | op->dentry = dentry; |
212 | op->ops = &afs_silly_unlink_operation; |
213 | |
214 | trace_afs_silly_rename(vnode, done: true); |
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 | */ |
221 | if (op->cumul_error.error == 0 && (op->flags & AFS_OPERATION_DIR_CONFLICT)) { |
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); |
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(inode: d_inode(dentry: 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(sem: &dvnode->rmdir_lock); |
247 | |
248 | alias = d_alloc_parallel(dentry->d_parent, &dentry->d_name, &wq); |
249 | if (IS_ERR(ptr: alias)) { |
250 | up_read(sem: &dvnode->rmdir_lock); |
251 | return 0; |
252 | } |
253 | |
254 | if (!d_in_lookup(dentry: 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(lock: &alias->d_lock); |
260 | if (d_really_is_positive(dentry: alias) && |
261 | !(alias->d_flags & DCACHE_NFSFS_RENAMED)) { |
262 | alias->d_flags |= DCACHE_NFSFS_RENAMED; |
263 | ret = 1; |
264 | } |
265 | spin_unlock(lock: &alias->d_lock); |
266 | up_read(sem: &dvnode->rmdir_lock); |
267 | dput(alias); |
268 | return ret; |
269 | } |
270 | |
271 | /* Stop lock-release from complaining. */ |
272 | spin_lock(lock: &vnode->lock); |
273 | vnode->lock_state = AFS_VNODE_LOCK_DELETED; |
274 | trace_afs_flock_ev(vnode, NULL, event: afs_flock_silly_delete, error: 0); |
275 | spin_unlock(lock: &vnode->lock); |
276 | |
277 | afs_do_silly_unlink(dvnode, vnode, dentry, key: dvnode->silly_key); |
278 | up_read(sem: &dvnode->rmdir_lock); |
279 | d_lookup_done(dentry: alias); |
280 | dput(alias); |
281 | return 1; |
282 | } |
283 | |