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