fs/cachefiles/namei.c

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