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 #include <linux/namei.h> 17 18 #include "internal.h" 19 #include "nfs4_fs.h" 20 #include "iostat.h" 21 #include "delegation.h" 22 23 /** 24 * nfs_free_unlinkdata - release data from a sillydelete operation. 25 * @data: pointer to unlink structure. 26 */ 27 static void 28 nfs_free_unlinkdata(struct nfs_unlinkdata *data) 29 { 30 iput(data->dir); 31 put_rpccred(data->cred); 32 kfree(data->args.name.name); 33 kfree(data); 34 } 35 36 #define NAME_ALLOC_LEN(len) ((len+16) & ~15) 37 /** 38 * nfs_copy_dname - copy dentry name to data structure 39 * @dentry: pointer to dentry 40 * @data: nfs_unlinkdata 41 */ 42 static int nfs_copy_dname(struct dentry *dentry, struct nfs_unlinkdata *data) 43 { 44 char *str; 45 int len = dentry->d_name.len; 46 47 str = kmemdup(dentry->d_name.name, NAME_ALLOC_LEN(len), GFP_KERNEL); 48 if (!str) 49 return -ENOMEM; 50 data->args.name.len = len; 51 data->args.name.name = str; 52 return 0; 53 } 54 55 static void nfs_free_dname(struct nfs_unlinkdata *data) 56 { 57 kfree(data->args.name.name); 58 data->args.name.name = NULL; 59 data->args.name.len = 0; 60 } 61 62 static void nfs_dec_sillycount(struct inode *dir) 63 { 64 struct nfs_inode *nfsi = NFS_I(dir); 65 if (atomic_dec_return(&nfsi->silly_count) == 1) 66 wake_up(&nfsi->waitqueue); 67 } 68 69 /** 70 * nfs_async_unlink_done - Sillydelete post-processing 71 * @task: rpc_task of the sillydelete 72 * 73 * Do the directory attribute update. 74 */ 75 static void nfs_async_unlink_done(struct rpc_task *task, void *calldata) 76 { 77 struct nfs_unlinkdata *data = calldata; 78 struct inode *dir = data->dir; 79 80 if (!NFS_PROTO(dir)->unlink_done(task, dir)) 81 rpc_restart_call_prepare(task); 82 } 83 84 /** 85 * nfs_async_unlink_release - Release the sillydelete data. 86 * @task: rpc_task of the sillydelete 87 * 88 * We need to call nfs_put_unlinkdata as a 'tk_release' task since the 89 * rpc_task would be freed too. 90 */ 91 static void nfs_async_unlink_release(void *calldata) 92 { 93 struct nfs_unlinkdata *data = calldata; 94 struct super_block *sb = data->dir->i_sb; 95 96 nfs_dec_sillycount(data->dir); 97 nfs_free_unlinkdata(data); 98 nfs_sb_deactive(sb); 99 } 100 101 static void nfs_unlink_prepare(struct rpc_task *task, void *calldata) 102 { 103 struct nfs_unlinkdata *data = calldata; 104 NFS_PROTO(data->dir)->unlink_rpc_prepare(task, data); 105 } 106 107 static const struct rpc_call_ops nfs_unlink_ops = { 108 .rpc_call_done = nfs_async_unlink_done, 109 .rpc_release = nfs_async_unlink_release, 110 .rpc_call_prepare = nfs_unlink_prepare, 111 }; 112 113 static int nfs_do_call_unlink(struct dentry *parent, struct inode *dir, struct nfs_unlinkdata *data) 114 { 115 struct rpc_message msg = { 116 .rpc_argp = &data->args, 117 .rpc_resp = &data->res, 118 .rpc_cred = data->cred, 119 }; 120 struct rpc_task_setup task_setup_data = { 121 .rpc_message = &msg, 122 .callback_ops = &nfs_unlink_ops, 123 .callback_data = data, 124 .workqueue = nfsiod_workqueue, 125 .flags = RPC_TASK_ASYNC, 126 }; 127 struct rpc_task *task; 128 struct dentry *alias; 129 130 alias = d_lookup(parent, &data->args.name); 131 if (alias != NULL) { 132 int ret; 133 void *devname_garbage = NULL; 134 135 /* 136 * Hey, we raced with lookup... See if we need to transfer 137 * the sillyrename information to the aliased dentry. 138 */ 139 nfs_free_dname(data); 140 ret = nfs_copy_dname(alias, data); 141 spin_lock(&alias->d_lock); 142 if (ret == 0 && alias->d_inode != NULL && 143 !(alias->d_flags & DCACHE_NFSFS_RENAMED)) { 144 devname_garbage = alias->d_fsdata; 145 alias->d_fsdata = data; 146 alias->d_flags |= DCACHE_NFSFS_RENAMED; 147 ret = 1; 148 } else 149 ret = 0; 150 spin_unlock(&alias->d_lock); 151 nfs_dec_sillycount(dir); 152 dput(alias); 153 /* 154 * If we'd displaced old cached devname, free it. At that 155 * point dentry is definitely not a root, so we won't need 156 * that anymore. 157 */ 158 kfree(devname_garbage); 159 return ret; 160 } 161 data->dir = igrab(dir); 162 if (!data->dir) { 163 nfs_dec_sillycount(dir); 164 return 0; 165 } 166 nfs_sb_active(dir->i_sb); 167 data->args.fh = NFS_FH(dir); 168 nfs_fattr_init(data->res.dir_attr); 169 170 NFS_PROTO(dir)->unlink_setup(&msg, dir); 171 172 task_setup_data.rpc_client = NFS_CLIENT(dir); 173 task = rpc_run_task(&task_setup_data); 174 if (!IS_ERR(task)) 175 rpc_put_task_async(task); 176 return 1; 177 } 178 179 static int nfs_call_unlink(struct dentry *dentry, struct nfs_unlinkdata *data) 180 { 181 struct dentry *parent; 182 struct inode *dir; 183 int ret = 0; 184 185 186 parent = dget_parent(dentry); 187 if (parent == NULL) 188 goto out_free; 189 dir = parent->d_inode; 190 /* Non-exclusive lock protects against concurrent lookup() calls */ 191 spin_lock(&dir->i_lock); 192 if (atomic_inc_not_zero(&NFS_I(dir)->silly_count) == 0) { 193 /* Deferred delete */ 194 hlist_add_head(&data->list, &NFS_I(dir)->silly_list); 195 spin_unlock(&dir->i_lock); 196 ret = 1; 197 goto out_dput; 198 } 199 spin_unlock(&dir->i_lock); 200 ret = nfs_do_call_unlink(parent, dir, data); 201 out_dput: 202 dput(parent); 203 out_free: 204 return ret; 205 } 206 207 void nfs_block_sillyrename(struct dentry *dentry) 208 { 209 struct nfs_inode *nfsi = NFS_I(dentry->d_inode); 210 211 wait_event(nfsi->waitqueue, atomic_cmpxchg(&nfsi->silly_count, 1, 0) == 1); 212 } 213 214 void nfs_unblock_sillyrename(struct dentry *dentry) 215 { 216 struct inode *dir = dentry->d_inode; 217 struct nfs_inode *nfsi = NFS_I(dir); 218 struct nfs_unlinkdata *data; 219 220 atomic_inc(&nfsi->silly_count); 221 spin_lock(&dir->i_lock); 222 while (!hlist_empty(&nfsi->silly_list)) { 223 if (!atomic_inc_not_zero(&nfsi->silly_count)) 224 break; 225 data = hlist_entry(nfsi->silly_list.first, struct nfs_unlinkdata, list); 226 hlist_del(&data->list); 227 spin_unlock(&dir->i_lock); 228 if (nfs_do_call_unlink(dentry, dir, data) == 0) 229 nfs_free_unlinkdata(data); 230 spin_lock(&dir->i_lock); 231 } 232 spin_unlock(&dir->i_lock); 233 } 234 235 /** 236 * nfs_async_unlink - asynchronous unlinking of a file 237 * @dir: parent directory of dentry 238 * @dentry: dentry to unlink 239 */ 240 static int 241 nfs_async_unlink(struct inode *dir, struct dentry *dentry) 242 { 243 struct nfs_unlinkdata *data; 244 int status = -ENOMEM; 245 void *devname_garbage = NULL; 246 247 data = kzalloc(sizeof(*data), GFP_KERNEL); 248 if (data == NULL) 249 goto out; 250 251 data->cred = rpc_lookup_cred(); 252 if (IS_ERR(data->cred)) { 253 status = PTR_ERR(data->cred); 254 goto out_free; 255 } 256 data->res.dir_attr = &data->dir_attr; 257 258 status = -EBUSY; 259 spin_lock(&dentry->d_lock); 260 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) 261 goto out_unlock; 262 dentry->d_flags |= DCACHE_NFSFS_RENAMED; 263 devname_garbage = dentry->d_fsdata; 264 dentry->d_fsdata = data; 265 spin_unlock(&dentry->d_lock); 266 /* 267 * If we'd displaced old cached devname, free it. At that 268 * point dentry is definitely not a root, so we won't need 269 * that anymore. 270 */ 271 kfree(devname_garbage); 272 return 0; 273 out_unlock: 274 spin_unlock(&dentry->d_lock); 275 put_rpccred(data->cred); 276 out_free: 277 kfree(data); 278 out: 279 return status; 280 } 281 282 /** 283 * nfs_complete_unlink - Initialize completion of the sillydelete 284 * @dentry: dentry to delete 285 * @inode: inode 286 * 287 * Since we're most likely to be called by dentry_iput(), we 288 * only use the dentry to find the sillydelete. We then copy the name 289 * into the qstr. 290 */ 291 void 292 nfs_complete_unlink(struct dentry *dentry, struct inode *inode) 293 { 294 struct nfs_unlinkdata *data = NULL; 295 296 spin_lock(&dentry->d_lock); 297 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) { 298 dentry->d_flags &= ~DCACHE_NFSFS_RENAMED; 299 data = dentry->d_fsdata; 300 dentry->d_fsdata = NULL; 301 } 302 spin_unlock(&dentry->d_lock); 303 304 if (data != NULL && (NFS_STALE(inode) || !nfs_call_unlink(dentry, data))) 305 nfs_free_unlinkdata(data); 306 } 307 308 /* Cancel a queued async unlink. Called when a sillyrename run fails. */ 309 static void 310 nfs_cancel_async_unlink(struct dentry *dentry) 311 { 312 spin_lock(&dentry->d_lock); 313 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) { 314 struct nfs_unlinkdata *data = dentry->d_fsdata; 315 316 dentry->d_flags &= ~DCACHE_NFSFS_RENAMED; 317 dentry->d_fsdata = NULL; 318 spin_unlock(&dentry->d_lock); 319 nfs_free_unlinkdata(data); 320 return; 321 } 322 spin_unlock(&dentry->d_lock); 323 } 324 325 /** 326 * nfs_async_rename_done - Sillyrename post-processing 327 * @task: rpc_task of the sillyrename 328 * @calldata: nfs_renamedata for the sillyrename 329 * 330 * Do the directory attribute updates and the d_move 331 */ 332 static void nfs_async_rename_done(struct rpc_task *task, void *calldata) 333 { 334 struct nfs_renamedata *data = calldata; 335 struct inode *old_dir = data->old_dir; 336 struct inode *new_dir = data->new_dir; 337 struct dentry *old_dentry = data->old_dentry; 338 struct dentry *new_dentry = data->new_dentry; 339 340 if (!NFS_PROTO(old_dir)->rename_done(task, old_dir, new_dir)) { 341 rpc_restart_call_prepare(task); 342 return; 343 } 344 345 if (task->tk_status != 0) { 346 nfs_cancel_async_unlink(old_dentry); 347 return; 348 } 349 350 d_drop(old_dentry); 351 d_drop(new_dentry); 352 } 353 354 /** 355 * nfs_async_rename_release - Release the sillyrename data. 356 * @calldata: the struct nfs_renamedata to be released 357 */ 358 static void nfs_async_rename_release(void *calldata) 359 { 360 struct nfs_renamedata *data = calldata; 361 struct super_block *sb = data->old_dir->i_sb; 362 363 if (data->old_dentry->d_inode) 364 nfs_mark_for_revalidate(data->old_dentry->d_inode); 365 366 dput(data->old_dentry); 367 dput(data->new_dentry); 368 iput(data->old_dir); 369 iput(data->new_dir); 370 nfs_sb_deactive(sb); 371 put_rpccred(data->cred); 372 kfree(data); 373 } 374 375 static void nfs_rename_prepare(struct rpc_task *task, void *calldata) 376 { 377 struct nfs_renamedata *data = calldata; 378 NFS_PROTO(data->old_dir)->rename_rpc_prepare(task, data); 379 } 380 381 static const struct rpc_call_ops nfs_rename_ops = { 382 .rpc_call_done = nfs_async_rename_done, 383 .rpc_release = nfs_async_rename_release, 384 .rpc_call_prepare = nfs_rename_prepare, 385 }; 386 387 /** 388 * nfs_async_rename - perform an asynchronous rename operation 389 * @old_dir: directory that currently holds the dentry to be renamed 390 * @new_dir: target directory for the rename 391 * @old_dentry: original dentry to be renamed 392 * @new_dentry: dentry to which the old_dentry should be renamed 393 * 394 * It's expected that valid references to the dentries and inodes are held 395 */ 396 static struct rpc_task * 397 nfs_async_rename(struct inode *old_dir, struct inode *new_dir, 398 struct dentry *old_dentry, struct dentry *new_dentry) 399 { 400 struct nfs_renamedata *data; 401 struct rpc_message msg = { }; 402 struct rpc_task_setup task_setup_data = { 403 .rpc_message = &msg, 404 .callback_ops = &nfs_rename_ops, 405 .workqueue = nfsiod_workqueue, 406 .rpc_client = NFS_CLIENT(old_dir), 407 .flags = RPC_TASK_ASYNC, 408 }; 409 410 data = kzalloc(sizeof(*data), GFP_KERNEL); 411 if (data == NULL) 412 return ERR_PTR(-ENOMEM); 413 task_setup_data.callback_data = data; 414 415 data->cred = rpc_lookup_cred(); 416 if (IS_ERR(data->cred)) { 417 struct rpc_task *task = ERR_CAST(data->cred); 418 kfree(data); 419 return task; 420 } 421 422 msg.rpc_argp = &data->args; 423 msg.rpc_resp = &data->res; 424 msg.rpc_cred = data->cred; 425 426 /* set up nfs_renamedata */ 427 data->old_dir = old_dir; 428 ihold(old_dir); 429 data->new_dir = new_dir; 430 ihold(new_dir); 431 data->old_dentry = dget(old_dentry); 432 data->new_dentry = dget(new_dentry); 433 nfs_fattr_init(&data->old_fattr); 434 nfs_fattr_init(&data->new_fattr); 435 436 /* set up nfs_renameargs */ 437 data->args.old_dir = NFS_FH(old_dir); 438 data->args.old_name = &old_dentry->d_name; 439 data->args.new_dir = NFS_FH(new_dir); 440 data->args.new_name = &new_dentry->d_name; 441 442 /* set up nfs_renameres */ 443 data->res.old_fattr = &data->old_fattr; 444 data->res.new_fattr = &data->new_fattr; 445 446 nfs_sb_active(old_dir->i_sb); 447 448 NFS_PROTO(data->old_dir)->rename_setup(&msg, old_dir); 449 450 return rpc_run_task(&task_setup_data); 451 } 452 453 /** 454 * nfs_sillyrename - Perform a silly-rename of a dentry 455 * @dir: inode of directory that contains dentry 456 * @dentry: dentry to be sillyrenamed 457 * 458 * NFSv2/3 is stateless and the server doesn't know when the client is 459 * holding a file open. To prevent application problems when a file is 460 * unlinked while it's still open, the client performs a "silly-rename". 461 * That is, it renames the file to a hidden file in the same directory, 462 * and only performs the unlink once the last reference to it is put. 463 * 464 * The final cleanup is done during dentry_iput. 465 * 466 * (Note: NFSv4 is stateful, and has opens, so in theory an NFSv4 server 467 * could take responsibility for keeping open files referenced. The server 468 * would also need to ensure that opened-but-deleted files were kept over 469 * reboots. However, we may not assume a server does so. (RFC 5661 470 * does provide an OPEN4_RESULT_PRESERVE_UNLINKED flag that a server can 471 * use to advertise that it does this; some day we may take advantage of 472 * it.)) 473 */ 474 int 475 nfs_sillyrename(struct inode *dir, struct dentry *dentry) 476 { 477 static unsigned int sillycounter; 478 const int fileidsize = sizeof(NFS_FILEID(dentry->d_inode))*2; 479 const int countersize = sizeof(sillycounter)*2; 480 const int slen = sizeof(".nfs")+fileidsize+countersize-1; 481 char silly[slen+1]; 482 struct dentry *sdentry; 483 struct rpc_task *task; 484 int error = -EIO; 485 486 dfprintk(VFS, "NFS: silly-rename(%s/%s, ct=%d)\n", 487 dentry->d_parent->d_name.name, dentry->d_name.name, 488 dentry->d_count); 489 nfs_inc_stats(dir, NFSIOS_SILLYRENAME); 490 491 /* 492 * We don't allow a dentry to be silly-renamed twice. 493 */ 494 error = -EBUSY; 495 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) 496 goto out; 497 498 sprintf(silly, ".nfs%*.*Lx", 499 fileidsize, fileidsize, 500 (unsigned long long)NFS_FILEID(dentry->d_inode)); 501 502 /* Return delegation in anticipation of the rename */ 503 NFS_PROTO(dentry->d_inode)->return_delegation(dentry->d_inode); 504 505 sdentry = NULL; 506 do { 507 char *suffix = silly + slen - countersize; 508 509 dput(sdentry); 510 sillycounter++; 511 sprintf(suffix, "%*.*x", countersize, countersize, sillycounter); 512 513 dfprintk(VFS, "NFS: trying to rename %s to %s\n", 514 dentry->d_name.name, silly); 515 516 sdentry = lookup_one_len(silly, dentry->d_parent, slen); 517 /* 518 * N.B. Better to return EBUSY here ... it could be 519 * dangerous to delete the file while it's in use. 520 */ 521 if (IS_ERR(sdentry)) 522 goto out; 523 } while (sdentry->d_inode != NULL); /* need negative lookup */ 524 525 /* queue unlink first. Can't do this from rpc_release as it 526 * has to allocate memory 527 */ 528 error = nfs_async_unlink(dir, dentry); 529 if (error) 530 goto out_dput; 531 532 /* populate unlinkdata with the right dname */ 533 error = nfs_copy_dname(sdentry, 534 (struct nfs_unlinkdata *)dentry->d_fsdata); 535 if (error) { 536 nfs_cancel_async_unlink(dentry); 537 goto out_dput; 538 } 539 540 /* run the rename task, undo unlink if it fails */ 541 task = nfs_async_rename(dir, dir, dentry, sdentry); 542 if (IS_ERR(task)) { 543 error = -EBUSY; 544 nfs_cancel_async_unlink(dentry); 545 goto out_dput; 546 } 547 548 /* wait for the RPC task to complete, unless a SIGKILL intervenes */ 549 error = rpc_wait_for_completion_task(task); 550 if (error == 0) 551 error = task->tk_status; 552 rpc_put_task(task); 553 out_dput: 554 dput(sdentry); 555 out: 556 return error; 557 } 558