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 /* 16 * Actually perform the silly rename step. 17 */ 18 static int afs_do_silly_rename(struct afs_vnode *dvnode, struct afs_vnode *vnode, 19 struct dentry *old, struct dentry *new, 20 struct key *key) 21 { 22 struct afs_fs_cursor fc; 23 struct afs_status_cb *scb; 24 int ret = -ERESTARTSYS; 25 26 _enter("%pd,%pd", old, new); 27 28 scb = kzalloc(sizeof(struct afs_status_cb), GFP_KERNEL); 29 if (!scb) 30 return -ENOMEM; 31 32 trace_afs_silly_rename(vnode, false); 33 if (afs_begin_vnode_operation(&fc, dvnode, key, true)) { 34 afs_dataversion_t dir_data_version = dvnode->status.data_version + 1; 35 36 while (afs_select_fileserver(&fc)) { 37 fc.cb_break = afs_calc_vnode_cb_break(dvnode); 38 afs_fs_rename(&fc, old->d_name.name, 39 dvnode, new->d_name.name, 40 scb, scb); 41 } 42 43 afs_vnode_commit_status(&fc, dvnode, fc.cb_break, 44 &dir_data_version, scb); 45 ret = afs_end_vnode_operation(&fc); 46 } 47 48 if (ret == 0) { 49 spin_lock(&old->d_lock); 50 old->d_flags |= DCACHE_NFSFS_RENAMED; 51 spin_unlock(&old->d_lock); 52 if (dvnode->silly_key != key) { 53 key_put(dvnode->silly_key); 54 dvnode->silly_key = key_get(key); 55 } 56 57 if (test_bit(AFS_VNODE_DIR_VALID, &dvnode->flags)) 58 afs_edit_dir_remove(dvnode, &old->d_name, 59 afs_edit_dir_for_silly_0); 60 if (test_bit(AFS_VNODE_DIR_VALID, &dvnode->flags)) 61 afs_edit_dir_add(dvnode, &new->d_name, 62 &vnode->fid, afs_edit_dir_for_silly_1); 63 64 /* vfs_unlink and the like do not issue this when a file is 65 * sillyrenamed, so do it here. 66 */ 67 fsnotify_nameremove(old, 0); 68 } 69 70 kfree(scb); 71 _leave(" = %d", ret); 72 return ret; 73 } 74 75 /** 76 * afs_sillyrename - Perform a silly-rename of a dentry 77 * 78 * AFS is stateless and the server doesn't know when the client is holding a 79 * file open. To prevent application problems when a file is unlinked while 80 * it's still open, the client performs a "silly-rename". That is, it renames 81 * the file to a hidden file in the same directory, and only performs the 82 * unlink once the last reference to it is put. 83 * 84 * The final cleanup is done during dentry_iput. 85 */ 86 int afs_sillyrename(struct afs_vnode *dvnode, struct afs_vnode *vnode, 87 struct dentry *dentry, struct key *key) 88 { 89 static unsigned int sillycounter; 90 struct dentry *sdentry = NULL; 91 unsigned char silly[16]; 92 int ret = -EBUSY; 93 94 _enter(""); 95 96 /* We don't allow a dentry to be silly-renamed twice. */ 97 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) 98 return -EBUSY; 99 100 sdentry = NULL; 101 do { 102 int slen; 103 104 dput(sdentry); 105 sillycounter++; 106 107 /* Create a silly name. Note that the ".__afs" prefix is 108 * understood by the salvager and must not be changed. 109 */ 110 slen = scnprintf(silly, sizeof(silly), ".__afs%04X", sillycounter); 111 sdentry = lookup_one_len(silly, dentry->d_parent, slen); 112 113 /* N.B. Better to return EBUSY here ... it could be dangerous 114 * to delete the file while it's in use. 115 */ 116 if (IS_ERR(sdentry)) 117 goto out; 118 } while (!d_is_negative(sdentry)); 119 120 ihold(&vnode->vfs_inode); 121 122 ret = afs_do_silly_rename(dvnode, vnode, dentry, sdentry, key); 123 switch (ret) { 124 case 0: 125 /* The rename succeeded. */ 126 d_move(dentry, sdentry); 127 break; 128 case -ERESTARTSYS: 129 /* The result of the rename is unknown. Play it safe by forcing 130 * a new lookup. 131 */ 132 d_drop(dentry); 133 d_drop(sdentry); 134 } 135 136 iput(&vnode->vfs_inode); 137 dput(sdentry); 138 out: 139 _leave(" = %d", ret); 140 return ret; 141 } 142 143 /* 144 * Tell the server to remove a sillyrename file. 145 */ 146 static int afs_do_silly_unlink(struct afs_vnode *dvnode, struct afs_vnode *vnode, 147 struct dentry *dentry, struct key *key) 148 { 149 struct afs_fs_cursor fc; 150 struct afs_status_cb *scb; 151 int ret = -ERESTARTSYS; 152 153 _enter(""); 154 155 scb = kcalloc(2, sizeof(struct afs_status_cb), GFP_KERNEL); 156 if (!scb) 157 return -ENOMEM; 158 159 trace_afs_silly_rename(vnode, true); 160 if (afs_begin_vnode_operation(&fc, dvnode, key, false)) { 161 afs_dataversion_t dir_data_version = dvnode->status.data_version + 1; 162 163 while (afs_select_fileserver(&fc)) { 164 fc.cb_break = afs_calc_vnode_cb_break(dvnode); 165 166 if (test_bit(AFS_SERVER_FL_IS_YFS, &fc.cbi->server->flags) && 167 !test_bit(AFS_SERVER_FL_NO_RM2, &fc.cbi->server->flags)) { 168 yfs_fs_remove_file2(&fc, vnode, dentry->d_name.name, 169 &scb[0], &scb[1]); 170 if (fc.ac.error != -ECONNABORTED || 171 fc.ac.abort_code != RXGEN_OPCODE) 172 continue; 173 set_bit(AFS_SERVER_FL_NO_RM2, &fc.cbi->server->flags); 174 } 175 176 afs_fs_remove(&fc, vnode, dentry->d_name.name, false, &scb[0]); 177 } 178 179 afs_vnode_commit_status(&fc, dvnode, fc.cb_break, 180 &dir_data_version, &scb[0]); 181 ret = afs_end_vnode_operation(&fc); 182 if (ret == 0) { 183 drop_nlink(&vnode->vfs_inode); 184 if (vnode->vfs_inode.i_nlink == 0) { 185 set_bit(AFS_VNODE_DELETED, &vnode->flags); 186 clear_bit(AFS_VNODE_CB_PROMISED, &vnode->flags); 187 } 188 } 189 if (ret == 0 && 190 test_bit(AFS_VNODE_DIR_VALID, &dvnode->flags)) 191 afs_edit_dir_remove(dvnode, &dentry->d_name, 192 afs_edit_dir_for_unlink); 193 } 194 195 kfree(scb); 196 _leave(" = %d", ret); 197 return ret; 198 } 199 200 /* 201 * Remove sillyrename file on iput. 202 */ 203 int afs_silly_iput(struct dentry *dentry, struct inode *inode) 204 { 205 struct afs_vnode *dvnode = AFS_FS_I(d_inode(dentry->d_parent)); 206 struct afs_vnode *vnode = AFS_FS_I(inode); 207 struct dentry *alias; 208 int ret; 209 210 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq); 211 212 _enter("%p{%pd},%llx", dentry, dentry, vnode->fid.vnode); 213 214 down_read(&dvnode->rmdir_lock); 215 216 alias = d_alloc_parallel(dentry->d_parent, &dentry->d_name, &wq); 217 if (IS_ERR(alias)) { 218 up_read(&dvnode->rmdir_lock); 219 return 0; 220 } 221 222 if (!d_in_lookup(alias)) { 223 /* We raced with lookup... See if we need to transfer the 224 * sillyrename information to the aliased dentry. 225 */ 226 ret = 0; 227 spin_lock(&alias->d_lock); 228 if (d_really_is_positive(alias) && 229 !(alias->d_flags & DCACHE_NFSFS_RENAMED)) { 230 alias->d_flags |= DCACHE_NFSFS_RENAMED; 231 ret = 1; 232 } 233 spin_unlock(&alias->d_lock); 234 up_read(&dvnode->rmdir_lock); 235 dput(alias); 236 return ret; 237 } 238 239 /* Stop lock-release from complaining. */ 240 spin_lock(&vnode->lock); 241 vnode->lock_state = AFS_VNODE_LOCK_DELETED; 242 trace_afs_flock_ev(vnode, NULL, afs_flock_silly_delete, 0); 243 spin_unlock(&vnode->lock); 244 245 afs_do_silly_unlink(dvnode, vnode, dentry, dvnode->silly_key); 246 up_read(&dvnode->rmdir_lock); 247 d_lookup_done(alias); 248 dput(alias); 249 return 1; 250 } 251