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 if (devname_garbage) 272 kfree(devname_garbage); 273 return 0; 274 out_unlock: 275 spin_unlock(&dentry->d_lock); 276 put_rpccred(data->cred); 277 out_free: 278 kfree(data); 279 out: 280 return status; 281 } 282 283 /** 284 * nfs_complete_unlink - Initialize completion of the sillydelete 285 * @dentry: dentry to delete 286 * @inode: inode 287 * 288 * Since we're most likely to be called by dentry_iput(), we 289 * only use the dentry to find the sillydelete. We then copy the name 290 * into the qstr. 291 */ 292 void 293 nfs_complete_unlink(struct dentry *dentry, struct inode *inode) 294 { 295 struct nfs_unlinkdata *data = NULL; 296 297 spin_lock(&dentry->d_lock); 298 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) { 299 dentry->d_flags &= ~DCACHE_NFSFS_RENAMED; 300 data = dentry->d_fsdata; 301 dentry->d_fsdata = NULL; 302 } 303 spin_unlock(&dentry->d_lock); 304 305 if (data != NULL && (NFS_STALE(inode) || !nfs_call_unlink(dentry, data))) 306 nfs_free_unlinkdata(data); 307 } 308 309 /* Cancel a queued async unlink. Called when a sillyrename run fails. */ 310 static void 311 nfs_cancel_async_unlink(struct dentry *dentry) 312 { 313 spin_lock(&dentry->d_lock); 314 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) { 315 struct nfs_unlinkdata *data = dentry->d_fsdata; 316 317 dentry->d_flags &= ~DCACHE_NFSFS_RENAMED; 318 dentry->d_fsdata = NULL; 319 spin_unlock(&dentry->d_lock); 320 nfs_free_unlinkdata(data); 321 return; 322 } 323 spin_unlock(&dentry->d_lock); 324 } 325 326 struct nfs_renamedata { 327 struct nfs_renameargs args; 328 struct nfs_renameres res; 329 struct rpc_cred *cred; 330 struct inode *old_dir; 331 struct dentry *old_dentry; 332 struct nfs_fattr old_fattr; 333 struct inode *new_dir; 334 struct dentry *new_dentry; 335 struct nfs_fattr new_fattr; 336 }; 337 338 /** 339 * nfs_async_rename_done - Sillyrename post-processing 340 * @task: rpc_task of the sillyrename 341 * @calldata: nfs_renamedata for the sillyrename 342 * 343 * Do the directory attribute updates and the d_move 344 */ 345 static void nfs_async_rename_done(struct rpc_task *task, void *calldata) 346 { 347 struct nfs_renamedata *data = calldata; 348 struct inode *old_dir = data->old_dir; 349 struct inode *new_dir = data->new_dir; 350 struct dentry *old_dentry = data->old_dentry; 351 struct dentry *new_dentry = data->new_dentry; 352 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 (task->tk_status != 0) { 359 nfs_cancel_async_unlink(old_dentry); 360 return; 361 } 362 363 d_drop(old_dentry); 364 d_drop(new_dentry); 365 } 366 367 /** 368 * nfs_async_rename_release - Release the sillyrename data. 369 * @calldata: the struct nfs_renamedata to be released 370 */ 371 static void nfs_async_rename_release(void *calldata) 372 { 373 struct nfs_renamedata *data = calldata; 374 struct super_block *sb = data->old_dir->i_sb; 375 376 if (data->old_dentry->d_inode) 377 nfs_mark_for_revalidate(data->old_dentry->d_inode); 378 379 dput(data->old_dentry); 380 dput(data->new_dentry); 381 iput(data->old_dir); 382 iput(data->new_dir); 383 nfs_sb_deactive(sb); 384 put_rpccred(data->cred); 385 kfree(data); 386 } 387 388 #if defined(CONFIG_NFS_V4_1) 389 static void nfs_rename_prepare(struct rpc_task *task, void *calldata) 390 { 391 struct nfs_renamedata *data = calldata; 392 struct nfs_server *server = NFS_SERVER(data->old_dir); 393 394 if (nfs4_setup_sequence(server, &data->args.seq_args, 395 &data->res.seq_res, task)) 396 return; 397 rpc_call_start(task); 398 } 399 #endif /* CONFIG_NFS_V4_1 */ 400 401 static const struct rpc_call_ops nfs_rename_ops = { 402 .rpc_call_done = nfs_async_rename_done, 403 .rpc_release = nfs_async_rename_release, 404 #if defined(CONFIG_NFS_V4_1) 405 .rpc_call_prepare = nfs_rename_prepare, 406 #endif /* CONFIG_NFS_V4_1 */ 407 }; 408 409 /** 410 * nfs_async_rename - perform an asynchronous rename operation 411 * @old_dir: directory that currently holds the dentry to be renamed 412 * @new_dir: target directory for the rename 413 * @old_dentry: original dentry to be renamed 414 * @new_dentry: dentry to which the old_dentry should be renamed 415 * 416 * It's expected that valid references to the dentries and inodes are held 417 */ 418 static struct rpc_task * 419 nfs_async_rename(struct inode *old_dir, struct inode *new_dir, 420 struct dentry *old_dentry, struct dentry *new_dentry) 421 { 422 struct nfs_renamedata *data; 423 struct rpc_message msg = { }; 424 struct rpc_task_setup task_setup_data = { 425 .rpc_message = &msg, 426 .callback_ops = &nfs_rename_ops, 427 .workqueue = nfsiod_workqueue, 428 .rpc_client = NFS_CLIENT(old_dir), 429 .flags = RPC_TASK_ASYNC, 430 }; 431 432 data = kzalloc(sizeof(*data), GFP_KERNEL); 433 if (data == NULL) 434 return ERR_PTR(-ENOMEM); 435 task_setup_data.callback_data = data; 436 437 data->cred = rpc_lookup_cred(); 438 if (IS_ERR(data->cred)) { 439 struct rpc_task *task = ERR_CAST(data->cred); 440 kfree(data); 441 return task; 442 } 443 444 msg.rpc_argp = &data->args; 445 msg.rpc_resp = &data->res; 446 msg.rpc_cred = data->cred; 447 448 /* set up nfs_renamedata */ 449 data->old_dir = old_dir; 450 ihold(old_dir); 451 data->new_dir = new_dir; 452 ihold(new_dir); 453 data->old_dentry = dget(old_dentry); 454 data->new_dentry = dget(new_dentry); 455 nfs_fattr_init(&data->old_fattr); 456 nfs_fattr_init(&data->new_fattr); 457 458 /* set up nfs_renameargs */ 459 data->args.old_dir = NFS_FH(old_dir); 460 data->args.old_name = &old_dentry->d_name; 461 data->args.new_dir = NFS_FH(new_dir); 462 data->args.new_name = &new_dentry->d_name; 463 464 /* set up nfs_renameres */ 465 data->res.old_fattr = &data->old_fattr; 466 data->res.new_fattr = &data->new_fattr; 467 468 nfs_sb_active(old_dir->i_sb); 469 470 NFS_PROTO(data->old_dir)->rename_setup(&msg, old_dir); 471 472 return rpc_run_task(&task_setup_data); 473 } 474 475 /** 476 * nfs_sillyrename - Perform a silly-rename of a dentry 477 * @dir: inode of directory that contains dentry 478 * @dentry: dentry to be sillyrenamed 479 * 480 * NFSv2/3 is stateless and the server doesn't know when the client is 481 * holding a file open. To prevent application problems when a file is 482 * unlinked while it's still open, the client performs a "silly-rename". 483 * That is, it renames the file to a hidden file in the same directory, 484 * and only performs the unlink once the last reference to it is put. 485 * 486 * The final cleanup is done during dentry_iput. 487 * 488 * (Note: NFSv4 is stateful, and has opens, so in theory an NFSv4 server 489 * could take responsibility for keeping open files referenced. The server 490 * would also need to ensure that opened-but-deleted files were kept over 491 * reboots. However, we may not assume a server does so. (RFC 5661 492 * does provide an OPEN4_RESULT_PRESERVE_UNLINKED flag that a server can 493 * use to advertise that it does this; some day we may take advantage of 494 * it.)) 495 */ 496 int 497 nfs_sillyrename(struct inode *dir, struct dentry *dentry) 498 { 499 static unsigned int sillycounter; 500 const int fileidsize = sizeof(NFS_FILEID(dentry->d_inode))*2; 501 const int countersize = sizeof(sillycounter)*2; 502 const int slen = sizeof(".nfs")+fileidsize+countersize-1; 503 char silly[slen+1]; 504 struct dentry *sdentry; 505 struct rpc_task *task; 506 int error = -EIO; 507 508 dfprintk(VFS, "NFS: silly-rename(%s/%s, ct=%d)\n", 509 dentry->d_parent->d_name.name, dentry->d_name.name, 510 dentry->d_count); 511 nfs_inc_stats(dir, NFSIOS_SILLYRENAME); 512 513 /* 514 * We don't allow a dentry to be silly-renamed twice. 515 */ 516 error = -EBUSY; 517 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) 518 goto out; 519 520 sprintf(silly, ".nfs%*.*Lx", 521 fileidsize, fileidsize, 522 (unsigned long long)NFS_FILEID(dentry->d_inode)); 523 524 /* Return delegation in anticipation of the rename */ 525 nfs_inode_return_delegation(dentry->d_inode); 526 527 sdentry = NULL; 528 do { 529 char *suffix = silly + slen - countersize; 530 531 dput(sdentry); 532 sillycounter++; 533 sprintf(suffix, "%*.*x", countersize, countersize, sillycounter); 534 535 dfprintk(VFS, "NFS: trying to rename %s to %s\n", 536 dentry->d_name.name, silly); 537 538 sdentry = lookup_one_len(silly, dentry->d_parent, slen); 539 /* 540 * N.B. Better to return EBUSY here ... it could be 541 * dangerous to delete the file while it's in use. 542 */ 543 if (IS_ERR(sdentry)) 544 goto out; 545 } while (sdentry->d_inode != NULL); /* need negative lookup */ 546 547 /* queue unlink first. Can't do this from rpc_release as it 548 * has to allocate memory 549 */ 550 error = nfs_async_unlink(dir, dentry); 551 if (error) 552 goto out_dput; 553 554 /* populate unlinkdata with the right dname */ 555 error = nfs_copy_dname(sdentry, 556 (struct nfs_unlinkdata *)dentry->d_fsdata); 557 if (error) { 558 nfs_cancel_async_unlink(dentry); 559 goto out_dput; 560 } 561 562 /* run the rename task, undo unlink if it fails */ 563 task = nfs_async_rename(dir, dir, dentry, sdentry); 564 if (IS_ERR(task)) { 565 error = -EBUSY; 566 nfs_cancel_async_unlink(dentry); 567 goto out_dput; 568 } 569 570 /* wait for the RPC task to complete, unless a SIGKILL intervenes */ 571 error = rpc_wait_for_completion_task(task); 572 if (error == 0) 573 error = task->tk_status; 574 rpc_put_task(task); 575 out_dput: 576 dput(sdentry); 577 out: 578 return error; 579 } 580