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