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