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