1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* CacheFiles path walking and related routines 3 * 4 * Copyright (C) 2021 Red Hat, Inc. All Rights Reserved. 5 * Written by David Howells (dhowells@redhat.com) 6 */ 7 8 #include <linux/fs.h> 9 #include <linux/namei.h> 10 #include "internal.h" 11 12 /* 13 * Mark the backing file as being a cache file if it's not already in use. The 14 * mark tells the culling request command that it's not allowed to cull the 15 * file or directory. The caller must hold the inode lock. 16 */ 17 static bool __cachefiles_mark_inode_in_use(struct cachefiles_object *object, 18 struct dentry *dentry) 19 { 20 struct inode *inode = d_backing_inode(dentry); 21 bool can_use = false; 22 23 if (!(inode->i_flags & S_KERNEL_FILE)) { 24 inode->i_flags |= S_KERNEL_FILE; 25 trace_cachefiles_mark_active(object, inode); 26 can_use = true; 27 } else { 28 pr_notice("cachefiles: Inode already in use: %pd\n", dentry); 29 } 30 31 return can_use; 32 } 33 34 static bool cachefiles_mark_inode_in_use(struct cachefiles_object *object, 35 struct dentry *dentry) 36 { 37 struct inode *inode = d_backing_inode(dentry); 38 bool can_use; 39 40 inode_lock(inode); 41 can_use = __cachefiles_mark_inode_in_use(object, dentry); 42 inode_unlock(inode); 43 return can_use; 44 } 45 46 /* 47 * Unmark a backing inode. The caller must hold the inode lock. 48 */ 49 static void __cachefiles_unmark_inode_in_use(struct cachefiles_object *object, 50 struct dentry *dentry) 51 { 52 struct inode *inode = d_backing_inode(dentry); 53 54 inode->i_flags &= ~S_KERNEL_FILE; 55 trace_cachefiles_mark_inactive(object, inode); 56 } 57 58 /* 59 * Unmark a backing inode and tell cachefilesd that there's something that can 60 * be culled. 61 */ 62 void cachefiles_unmark_inode_in_use(struct cachefiles_object *object, 63 struct file *file) 64 { 65 struct cachefiles_cache *cache = object->volume->cache; 66 struct inode *inode = file_inode(file); 67 68 if (inode) { 69 inode_lock(inode); 70 __cachefiles_unmark_inode_in_use(object, file->f_path.dentry); 71 inode_unlock(inode); 72 73 if (!test_bit(CACHEFILES_OBJECT_USING_TMPFILE, &object->flags)) { 74 atomic_long_add(inode->i_blocks, &cache->b_released); 75 if (atomic_inc_return(&cache->f_released)) 76 cachefiles_state_changed(cache); 77 } 78 } 79 } 80 81 /* 82 * get a subdirectory 83 */ 84 struct dentry *cachefiles_get_directory(struct cachefiles_cache *cache, 85 struct dentry *dir, 86 const char *dirname, 87 bool *_is_new) 88 { 89 struct dentry *subdir; 90 struct path path; 91 int ret; 92 93 _enter(",,%s", dirname); 94 95 /* search the current directory for the element name */ 96 inode_lock_nested(d_inode(dir), I_MUTEX_PARENT); 97 98 retry: 99 ret = cachefiles_inject_read_error(); 100 if (ret == 0) 101 subdir = lookup_one_len(dirname, dir, strlen(dirname)); 102 else 103 subdir = ERR_PTR(ret); 104 trace_cachefiles_lookup(NULL, dir, subdir); 105 if (IS_ERR(subdir)) { 106 trace_cachefiles_vfs_error(NULL, d_backing_inode(dir), 107 PTR_ERR(subdir), 108 cachefiles_trace_lookup_error); 109 if (PTR_ERR(subdir) == -ENOMEM) 110 goto nomem_d_alloc; 111 goto lookup_error; 112 } 113 114 _debug("subdir -> %pd %s", 115 subdir, d_backing_inode(subdir) ? "positive" : "negative"); 116 117 /* we need to create the subdir if it doesn't exist yet */ 118 if (d_is_negative(subdir)) { 119 ret = cachefiles_has_space(cache, 1, 0, 120 cachefiles_has_space_for_create); 121 if (ret < 0) 122 goto mkdir_error; 123 124 _debug("attempt mkdir"); 125 126 path.mnt = cache->mnt; 127 path.dentry = dir; 128 ret = security_path_mkdir(&path, subdir, 0700); 129 if (ret < 0) 130 goto mkdir_error; 131 ret = cachefiles_inject_write_error(); 132 if (ret == 0) 133 ret = vfs_mkdir(&init_user_ns, d_inode(dir), subdir, 0700); 134 if (ret < 0) { 135 trace_cachefiles_vfs_error(NULL, d_inode(dir), ret, 136 cachefiles_trace_mkdir_error); 137 goto mkdir_error; 138 } 139 trace_cachefiles_mkdir(dir, subdir); 140 141 if (unlikely(d_unhashed(subdir))) { 142 cachefiles_put_directory(subdir); 143 goto retry; 144 } 145 ASSERT(d_backing_inode(subdir)); 146 147 _debug("mkdir -> %pd{ino=%lu}", 148 subdir, d_backing_inode(subdir)->i_ino); 149 if (_is_new) 150 *_is_new = true; 151 } 152 153 /* Tell rmdir() it's not allowed to delete the subdir */ 154 inode_lock(d_inode(subdir)); 155 inode_unlock(d_inode(dir)); 156 157 if (!__cachefiles_mark_inode_in_use(NULL, subdir)) 158 goto mark_error; 159 160 inode_unlock(d_inode(subdir)); 161 162 /* we need to make sure the subdir is a directory */ 163 ASSERT(d_backing_inode(subdir)); 164 165 if (!d_can_lookup(subdir)) { 166 pr_err("%s is not a directory\n", dirname); 167 ret = -EIO; 168 goto check_error; 169 } 170 171 ret = -EPERM; 172 if (!(d_backing_inode(subdir)->i_opflags & IOP_XATTR) || 173 !d_backing_inode(subdir)->i_op->lookup || 174 !d_backing_inode(subdir)->i_op->mkdir || 175 !d_backing_inode(subdir)->i_op->rename || 176 !d_backing_inode(subdir)->i_op->rmdir || 177 !d_backing_inode(subdir)->i_op->unlink) 178 goto check_error; 179 180 _leave(" = [%lu]", d_backing_inode(subdir)->i_ino); 181 return subdir; 182 183 check_error: 184 cachefiles_put_directory(subdir); 185 _leave(" = %d [check]", ret); 186 return ERR_PTR(ret); 187 188 mark_error: 189 inode_unlock(d_inode(subdir)); 190 dput(subdir); 191 return ERR_PTR(-EBUSY); 192 193 mkdir_error: 194 inode_unlock(d_inode(dir)); 195 dput(subdir); 196 pr_err("mkdir %s failed with error %d\n", dirname, ret); 197 return ERR_PTR(ret); 198 199 lookup_error: 200 inode_unlock(d_inode(dir)); 201 ret = PTR_ERR(subdir); 202 pr_err("Lookup %s failed with error %d\n", dirname, ret); 203 return ERR_PTR(ret); 204 205 nomem_d_alloc: 206 inode_unlock(d_inode(dir)); 207 _leave(" = -ENOMEM"); 208 return ERR_PTR(-ENOMEM); 209 } 210 211 /* 212 * Put a subdirectory. 213 */ 214 void cachefiles_put_directory(struct dentry *dir) 215 { 216 if (dir) { 217 inode_lock(dir->d_inode); 218 __cachefiles_unmark_inode_in_use(NULL, dir); 219 inode_unlock(dir->d_inode); 220 dput(dir); 221 } 222 } 223 224 /* 225 * Remove a regular file from the cache. 226 */ 227 static int cachefiles_unlink(struct cachefiles_cache *cache, 228 struct cachefiles_object *object, 229 struct dentry *dir, struct dentry *dentry, 230 enum fscache_why_object_killed why) 231 { 232 struct path path = { 233 .mnt = cache->mnt, 234 .dentry = dir, 235 }; 236 int ret; 237 238 trace_cachefiles_unlink(object, d_inode(dentry)->i_ino, why); 239 ret = security_path_unlink(&path, dentry); 240 if (ret < 0) { 241 cachefiles_io_error(cache, "Unlink security error"); 242 return ret; 243 } 244 245 ret = cachefiles_inject_remove_error(); 246 if (ret == 0) { 247 ret = vfs_unlink(&init_user_ns, d_backing_inode(dir), dentry, NULL); 248 if (ret == -EIO) 249 cachefiles_io_error(cache, "Unlink failed"); 250 } 251 if (ret != 0) 252 trace_cachefiles_vfs_error(object, d_backing_inode(dir), ret, 253 cachefiles_trace_unlink_error); 254 return ret; 255 } 256 257 /* 258 * Delete an object representation from the cache 259 * - File backed objects are unlinked 260 * - Directory backed objects are stuffed into the graveyard for userspace to 261 * delete 262 */ 263 int cachefiles_bury_object(struct cachefiles_cache *cache, 264 struct cachefiles_object *object, 265 struct dentry *dir, 266 struct dentry *rep, 267 enum fscache_why_object_killed why) 268 { 269 struct dentry *grave, *trap; 270 struct path path, path_to_graveyard; 271 char nbuffer[8 + 8 + 1]; 272 int ret; 273 274 _enter(",'%pd','%pd'", dir, rep); 275 276 if (rep->d_parent != dir) { 277 inode_unlock(d_inode(dir)); 278 _leave(" = -ESTALE"); 279 return -ESTALE; 280 } 281 282 /* non-directories can just be unlinked */ 283 if (!d_is_dir(rep)) { 284 dget(rep); /* Stop the dentry being negated if it's only pinned 285 * by a file struct. 286 */ 287 ret = cachefiles_unlink(cache, object, dir, rep, why); 288 dput(rep); 289 290 inode_unlock(d_inode(dir)); 291 _leave(" = %d", ret); 292 return ret; 293 } 294 295 /* directories have to be moved to the graveyard */ 296 _debug("move stale object to graveyard"); 297 inode_unlock(d_inode(dir)); 298 299 try_again: 300 /* first step is to make up a grave dentry in the graveyard */ 301 sprintf(nbuffer, "%08x%08x", 302 (uint32_t) ktime_get_real_seconds(), 303 (uint32_t) atomic_inc_return(&cache->gravecounter)); 304 305 /* do the multiway lock magic */ 306 trap = lock_rename(cache->graveyard, dir); 307 308 /* do some checks before getting the grave dentry */ 309 if (rep->d_parent != dir || IS_DEADDIR(d_inode(rep))) { 310 /* the entry was probably culled when we dropped the parent dir 311 * lock */ 312 unlock_rename(cache->graveyard, dir); 313 _leave(" = 0 [culled?]"); 314 return 0; 315 } 316 317 if (!d_can_lookup(cache->graveyard)) { 318 unlock_rename(cache->graveyard, dir); 319 cachefiles_io_error(cache, "Graveyard no longer a directory"); 320 return -EIO; 321 } 322 323 if (trap == rep) { 324 unlock_rename(cache->graveyard, dir); 325 cachefiles_io_error(cache, "May not make directory loop"); 326 return -EIO; 327 } 328 329 if (d_mountpoint(rep)) { 330 unlock_rename(cache->graveyard, dir); 331 cachefiles_io_error(cache, "Mountpoint in cache"); 332 return -EIO; 333 } 334 335 grave = lookup_one_len(nbuffer, cache->graveyard, strlen(nbuffer)); 336 if (IS_ERR(grave)) { 337 unlock_rename(cache->graveyard, dir); 338 trace_cachefiles_vfs_error(object, d_inode(cache->graveyard), 339 PTR_ERR(grave), 340 cachefiles_trace_lookup_error); 341 342 if (PTR_ERR(grave) == -ENOMEM) { 343 _leave(" = -ENOMEM"); 344 return -ENOMEM; 345 } 346 347 cachefiles_io_error(cache, "Lookup error %ld", PTR_ERR(grave)); 348 return -EIO; 349 } 350 351 if (d_is_positive(grave)) { 352 unlock_rename(cache->graveyard, dir); 353 dput(grave); 354 grave = NULL; 355 cond_resched(); 356 goto try_again; 357 } 358 359 if (d_mountpoint(grave)) { 360 unlock_rename(cache->graveyard, dir); 361 dput(grave); 362 cachefiles_io_error(cache, "Mountpoint in graveyard"); 363 return -EIO; 364 } 365 366 /* target should not be an ancestor of source */ 367 if (trap == grave) { 368 unlock_rename(cache->graveyard, dir); 369 dput(grave); 370 cachefiles_io_error(cache, "May not make directory loop"); 371 return -EIO; 372 } 373 374 /* attempt the rename */ 375 path.mnt = cache->mnt; 376 path.dentry = dir; 377 path_to_graveyard.mnt = cache->mnt; 378 path_to_graveyard.dentry = cache->graveyard; 379 ret = security_path_rename(&path, rep, &path_to_graveyard, grave, 0); 380 if (ret < 0) { 381 cachefiles_io_error(cache, "Rename security error %d", ret); 382 } else { 383 struct renamedata rd = { 384 .old_mnt_userns = &init_user_ns, 385 .old_dir = d_inode(dir), 386 .old_dentry = rep, 387 .new_mnt_userns = &init_user_ns, 388 .new_dir = d_inode(cache->graveyard), 389 .new_dentry = grave, 390 }; 391 trace_cachefiles_rename(object, d_inode(rep)->i_ino, why); 392 ret = cachefiles_inject_read_error(); 393 if (ret == 0) 394 ret = vfs_rename(&rd); 395 if (ret != 0) 396 trace_cachefiles_vfs_error(object, d_inode(dir), ret, 397 cachefiles_trace_rename_error); 398 if (ret != 0 && ret != -ENOMEM) 399 cachefiles_io_error(cache, 400 "Rename failed with error %d", ret); 401 } 402 403 __cachefiles_unmark_inode_in_use(object, rep); 404 unlock_rename(cache->graveyard, dir); 405 dput(grave); 406 _leave(" = 0"); 407 return 0; 408 } 409 410 /* 411 * Delete a cache file. 412 */ 413 int cachefiles_delete_object(struct cachefiles_object *object, 414 enum fscache_why_object_killed why) 415 { 416 struct cachefiles_volume *volume = object->volume; 417 struct dentry *dentry = object->file->f_path.dentry; 418 struct dentry *fan = volume->fanout[(u8)object->cookie->key_hash]; 419 int ret; 420 421 _enter(",OBJ%x{%pD}", object->debug_id, object->file); 422 423 /* Stop the dentry being negated if it's only pinned by a file struct. */ 424 dget(dentry); 425 426 inode_lock_nested(d_backing_inode(fan), I_MUTEX_PARENT); 427 ret = cachefiles_unlink(volume->cache, object, fan, dentry, why); 428 inode_unlock(d_backing_inode(fan)); 429 dput(dentry); 430 return ret; 431 } 432 433 /* 434 * Create a temporary file and leave it unattached and un-xattr'd until the 435 * time comes to discard the object from memory. 436 */ 437 struct file *cachefiles_create_tmpfile(struct cachefiles_object *object) 438 { 439 struct cachefiles_volume *volume = object->volume; 440 struct cachefiles_cache *cache = volume->cache; 441 const struct cred *saved_cred; 442 struct dentry *fan = volume->fanout[(u8)object->cookie->key_hash]; 443 struct file *file; 444 struct path path; 445 uint64_t ni_size = object->cookie->object_size; 446 long ret; 447 448 ni_size = round_up(ni_size, CACHEFILES_DIO_BLOCK_SIZE); 449 450 cachefiles_begin_secure(cache, &saved_cred); 451 452 path.mnt = cache->mnt; 453 ret = cachefiles_inject_write_error(); 454 if (ret == 0) 455 path.dentry = vfs_tmpfile(&init_user_ns, fan, S_IFREG, O_RDWR); 456 else 457 path.dentry = ERR_PTR(ret); 458 if (IS_ERR(path.dentry)) { 459 trace_cachefiles_vfs_error(object, d_inode(fan), PTR_ERR(path.dentry), 460 cachefiles_trace_tmpfile_error); 461 if (PTR_ERR(path.dentry) == -EIO) 462 cachefiles_io_error_obj(object, "Failed to create tmpfile"); 463 file = ERR_CAST(path.dentry); 464 goto out; 465 } 466 467 trace_cachefiles_tmpfile(object, d_backing_inode(path.dentry)); 468 469 if (!cachefiles_mark_inode_in_use(object, path.dentry)) { 470 file = ERR_PTR(-EBUSY); 471 goto out_dput; 472 } 473 474 if (ni_size > 0) { 475 trace_cachefiles_trunc(object, d_backing_inode(path.dentry), 0, ni_size, 476 cachefiles_trunc_expand_tmpfile); 477 ret = cachefiles_inject_write_error(); 478 if (ret == 0) 479 ret = vfs_truncate(&path, ni_size); 480 if (ret < 0) { 481 trace_cachefiles_vfs_error( 482 object, d_backing_inode(path.dentry), ret, 483 cachefiles_trace_trunc_error); 484 file = ERR_PTR(ret); 485 goto out_dput; 486 } 487 } 488 489 file = open_with_fake_path(&path, O_RDWR | O_LARGEFILE | O_DIRECT, 490 d_backing_inode(path.dentry), cache->cache_cred); 491 if (IS_ERR(file)) { 492 trace_cachefiles_vfs_error(object, d_backing_inode(path.dentry), 493 PTR_ERR(file), 494 cachefiles_trace_open_error); 495 goto out_dput; 496 } 497 if (unlikely(!file->f_op->read_iter) || 498 unlikely(!file->f_op->write_iter)) { 499 fput(file); 500 pr_notice("Cache does not support read_iter and write_iter\n"); 501 file = ERR_PTR(-EINVAL); 502 } 503 504 out_dput: 505 dput(path.dentry); 506 out: 507 cachefiles_end_secure(cache, saved_cred); 508 return file; 509 } 510 511 /* 512 * Create a new file. 513 */ 514 static bool cachefiles_create_file(struct cachefiles_object *object) 515 { 516 struct file *file; 517 int ret; 518 519 ret = cachefiles_has_space(object->volume->cache, 1, 0, 520 cachefiles_has_space_for_create); 521 if (ret < 0) 522 return false; 523 524 file = cachefiles_create_tmpfile(object); 525 if (IS_ERR(file)) 526 return false; 527 528 set_bit(FSCACHE_COOKIE_NEEDS_UPDATE, &object->cookie->flags); 529 set_bit(CACHEFILES_OBJECT_USING_TMPFILE, &object->flags); 530 _debug("create -> %pD{ino=%lu}", file, file_inode(file)->i_ino); 531 object->file = file; 532 return true; 533 } 534 535 /* 536 * Open an existing file, checking its attributes and replacing it if it is 537 * stale. 538 */ 539 static bool cachefiles_open_file(struct cachefiles_object *object, 540 struct dentry *dentry) 541 { 542 struct cachefiles_cache *cache = object->volume->cache; 543 struct file *file; 544 struct path path; 545 int ret; 546 547 _enter("%pd", dentry); 548 549 if (!cachefiles_mark_inode_in_use(object, dentry)) 550 return false; 551 552 /* We need to open a file interface onto a data file now as we can't do 553 * it on demand because writeback called from do_exit() sees 554 * current->fs == NULL - which breaks d_path() called from ext4 open. 555 */ 556 path.mnt = cache->mnt; 557 path.dentry = dentry; 558 file = open_with_fake_path(&path, O_RDWR | O_LARGEFILE | O_DIRECT, 559 d_backing_inode(dentry), cache->cache_cred); 560 if (IS_ERR(file)) { 561 trace_cachefiles_vfs_error(object, d_backing_inode(dentry), 562 PTR_ERR(file), 563 cachefiles_trace_open_error); 564 goto error; 565 } 566 567 if (unlikely(!file->f_op->read_iter) || 568 unlikely(!file->f_op->write_iter)) { 569 pr_notice("Cache does not support read_iter and write_iter\n"); 570 goto error_fput; 571 } 572 _debug("file -> %pd positive", dentry); 573 574 ret = cachefiles_check_auxdata(object, file); 575 if (ret < 0) 576 goto check_failed; 577 578 object->file = file; 579 580 /* Always update the atime on an object we've just looked up (this is 581 * used to keep track of culling, and atimes are only updated by read, 582 * write and readdir but not lookup or open). 583 */ 584 touch_atime(&file->f_path); 585 dput(dentry); 586 return true; 587 588 check_failed: 589 fscache_cookie_lookup_negative(object->cookie); 590 cachefiles_unmark_inode_in_use(object, file); 591 if (ret == -ESTALE) { 592 fput(file); 593 dput(dentry); 594 return cachefiles_create_file(object); 595 } 596 error_fput: 597 fput(file); 598 error: 599 dput(dentry); 600 return false; 601 } 602 603 /* 604 * walk from the parent object to the child object through the backing 605 * filesystem, creating directories as we go 606 */ 607 bool cachefiles_look_up_object(struct cachefiles_object *object) 608 { 609 struct cachefiles_volume *volume = object->volume; 610 struct dentry *dentry, *fan = volume->fanout[(u8)object->cookie->key_hash]; 611 int ret; 612 613 _enter("OBJ%x,%s,", object->debug_id, object->d_name); 614 615 /* Look up path "cache/vol/fanout/file". */ 616 ret = cachefiles_inject_read_error(); 617 if (ret == 0) 618 dentry = lookup_positive_unlocked(object->d_name, fan, 619 object->d_name_len); 620 else 621 dentry = ERR_PTR(ret); 622 trace_cachefiles_lookup(object, fan, dentry); 623 if (IS_ERR(dentry)) { 624 if (dentry == ERR_PTR(-ENOENT)) 625 goto new_file; 626 if (dentry == ERR_PTR(-EIO)) 627 cachefiles_io_error_obj(object, "Lookup failed"); 628 return false; 629 } 630 631 if (!d_is_reg(dentry)) { 632 pr_err("%pd is not a file\n", dentry); 633 inode_lock_nested(d_inode(fan), I_MUTEX_PARENT); 634 ret = cachefiles_bury_object(volume->cache, object, fan, dentry, 635 FSCACHE_OBJECT_IS_WEIRD); 636 dput(dentry); 637 if (ret < 0) 638 return false; 639 goto new_file; 640 } 641 642 if (!cachefiles_open_file(object, dentry)) 643 return false; 644 645 _leave(" = t [%lu]", file_inode(object->file)->i_ino); 646 return true; 647 648 new_file: 649 fscache_cookie_lookup_negative(object->cookie); 650 return cachefiles_create_file(object); 651 } 652 653 /* 654 * Attempt to link a temporary file into its rightful place in the cache. 655 */ 656 bool cachefiles_commit_tmpfile(struct cachefiles_cache *cache, 657 struct cachefiles_object *object) 658 { 659 struct cachefiles_volume *volume = object->volume; 660 struct dentry *dentry, *fan = volume->fanout[(u8)object->cookie->key_hash]; 661 bool success = false; 662 int ret; 663 664 _enter(",%pD", object->file); 665 666 inode_lock_nested(d_inode(fan), I_MUTEX_PARENT); 667 ret = cachefiles_inject_read_error(); 668 if (ret == 0) 669 dentry = lookup_one_len(object->d_name, fan, object->d_name_len); 670 else 671 dentry = ERR_PTR(ret); 672 if (IS_ERR(dentry)) { 673 trace_cachefiles_vfs_error(object, d_inode(fan), PTR_ERR(dentry), 674 cachefiles_trace_lookup_error); 675 _debug("lookup fail %ld", PTR_ERR(dentry)); 676 goto out_unlock; 677 } 678 679 if (!d_is_negative(dentry)) { 680 if (d_backing_inode(dentry) == file_inode(object->file)) { 681 success = true; 682 goto out_dput; 683 } 684 685 ret = cachefiles_unlink(volume->cache, object, fan, dentry, 686 FSCACHE_OBJECT_IS_STALE); 687 if (ret < 0) 688 goto out_dput; 689 690 dput(dentry); 691 ret = cachefiles_inject_read_error(); 692 if (ret == 0) 693 dentry = lookup_one_len(object->d_name, fan, object->d_name_len); 694 else 695 dentry = ERR_PTR(ret); 696 if (IS_ERR(dentry)) { 697 trace_cachefiles_vfs_error(object, d_inode(fan), PTR_ERR(dentry), 698 cachefiles_trace_lookup_error); 699 _debug("lookup fail %ld", PTR_ERR(dentry)); 700 goto out_unlock; 701 } 702 } 703 704 ret = cachefiles_inject_read_error(); 705 if (ret == 0) 706 ret = vfs_link(object->file->f_path.dentry, &init_user_ns, 707 d_inode(fan), dentry, NULL); 708 if (ret < 0) { 709 trace_cachefiles_vfs_error(object, d_inode(fan), ret, 710 cachefiles_trace_link_error); 711 _debug("link fail %d", ret); 712 } else { 713 trace_cachefiles_link(object, file_inode(object->file)); 714 spin_lock(&object->lock); 715 /* TODO: Do we want to switch the file pointer to the new dentry? */ 716 clear_bit(CACHEFILES_OBJECT_USING_TMPFILE, &object->flags); 717 spin_unlock(&object->lock); 718 success = true; 719 } 720 721 out_dput: 722 dput(dentry); 723 out_unlock: 724 inode_unlock(d_inode(fan)); 725 _leave(" = %u", success); 726 return success; 727 } 728 729 /* 730 * Look up an inode to be checked or culled. Return -EBUSY if the inode is 731 * marked in use. 732 */ 733 static struct dentry *cachefiles_lookup_for_cull(struct cachefiles_cache *cache, 734 struct dentry *dir, 735 char *filename) 736 { 737 struct dentry *victim; 738 int ret = -ENOENT; 739 740 inode_lock_nested(d_inode(dir), I_MUTEX_PARENT); 741 742 victim = lookup_one_len(filename, dir, strlen(filename)); 743 if (IS_ERR(victim)) 744 goto lookup_error; 745 if (d_is_negative(victim)) 746 goto lookup_put; 747 if (d_inode(victim)->i_flags & S_KERNEL_FILE) 748 goto lookup_busy; 749 return victim; 750 751 lookup_busy: 752 ret = -EBUSY; 753 lookup_put: 754 inode_unlock(d_inode(dir)); 755 dput(victim); 756 return ERR_PTR(ret); 757 758 lookup_error: 759 inode_unlock(d_inode(dir)); 760 ret = PTR_ERR(victim); 761 if (ret == -ENOENT) 762 return ERR_PTR(-ESTALE); /* Probably got retired by the netfs */ 763 764 if (ret == -EIO) { 765 cachefiles_io_error(cache, "Lookup failed"); 766 } else if (ret != -ENOMEM) { 767 pr_err("Internal error: %d\n", ret); 768 ret = -EIO; 769 } 770 771 return ERR_PTR(ret); 772 } 773 774 /* 775 * Cull an object if it's not in use 776 * - called only by cache manager daemon 777 */ 778 int cachefiles_cull(struct cachefiles_cache *cache, struct dentry *dir, 779 char *filename) 780 { 781 struct dentry *victim; 782 struct inode *inode; 783 int ret; 784 785 _enter(",%pd/,%s", dir, filename); 786 787 victim = cachefiles_lookup_for_cull(cache, dir, filename); 788 if (IS_ERR(victim)) 789 return PTR_ERR(victim); 790 791 /* check to see if someone is using this object */ 792 inode = d_inode(victim); 793 inode_lock(inode); 794 if (inode->i_flags & S_KERNEL_FILE) { 795 ret = -EBUSY; 796 } else { 797 /* Stop the cache from picking it back up */ 798 inode->i_flags |= S_KERNEL_FILE; 799 ret = 0; 800 } 801 inode_unlock(inode); 802 if (ret < 0) 803 goto error_unlock; 804 805 ret = cachefiles_bury_object(cache, NULL, dir, victim, 806 FSCACHE_OBJECT_WAS_CULLED); 807 if (ret < 0) 808 goto error; 809 810 fscache_count_culled(); 811 dput(victim); 812 _leave(" = 0"); 813 return 0; 814 815 error_unlock: 816 inode_unlock(d_inode(dir)); 817 error: 818 dput(victim); 819 if (ret == -ENOENT) 820 return -ESTALE; /* Probably got retired by the netfs */ 821 822 if (ret != -ENOMEM) { 823 pr_err("Internal error: %d\n", ret); 824 ret = -EIO; 825 } 826 827 _leave(" = %d", ret); 828 return ret; 829 } 830 831 /* 832 * Find out if an object is in use or not 833 * - called only by cache manager daemon 834 * - returns -EBUSY or 0 to indicate whether an object is in use or not 835 */ 836 int cachefiles_check_in_use(struct cachefiles_cache *cache, struct dentry *dir, 837 char *filename) 838 { 839 struct dentry *victim; 840 int ret = 0; 841 842 victim = cachefiles_lookup_for_cull(cache, dir, filename); 843 if (IS_ERR(victim)) 844 return PTR_ERR(victim); 845 846 inode_unlock(d_inode(dir)); 847 dput(victim); 848 return ret; 849 } 850