Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /* CacheFiles path walking and related routines
0003  *
0004  * Copyright (C) 2021 Red Hat, Inc. All Rights Reserved.
0005  * Written by David Howells (dhowells@redhat.com)
0006  */
0007 
0008 #include <linux/fs.h>
0009 #include <linux/namei.h>
0010 #include "internal.h"
0011 
0012 /*
0013  * Mark the backing file as being a cache file if it's not already in use.  The
0014  * mark tells the culling request command that it's not allowed to cull the
0015  * file or directory.  The caller must hold the inode lock.
0016  */
0017 static bool __cachefiles_mark_inode_in_use(struct cachefiles_object *object,
0018                        struct dentry *dentry)
0019 {
0020     struct inode *inode = d_backing_inode(dentry);
0021     bool can_use = false;
0022 
0023     if (!(inode->i_flags & S_KERNEL_FILE)) {
0024         inode->i_flags |= S_KERNEL_FILE;
0025         trace_cachefiles_mark_active(object, inode);
0026         can_use = true;
0027     } else {
0028         trace_cachefiles_mark_failed(object, inode);
0029         pr_notice("cachefiles: Inode already in use: %pd (B=%lx)\n",
0030               dentry, inode->i_ino);
0031     }
0032 
0033     return can_use;
0034 }
0035 
0036 static bool cachefiles_mark_inode_in_use(struct cachefiles_object *object,
0037                      struct dentry *dentry)
0038 {
0039     struct inode *inode = d_backing_inode(dentry);
0040     bool can_use;
0041 
0042     inode_lock(inode);
0043     can_use = __cachefiles_mark_inode_in_use(object, dentry);
0044     inode_unlock(inode);
0045     return can_use;
0046 }
0047 
0048 /*
0049  * Unmark a backing inode.  The caller must hold the inode lock.
0050  */
0051 static void __cachefiles_unmark_inode_in_use(struct cachefiles_object *object,
0052                          struct dentry *dentry)
0053 {
0054     struct inode *inode = d_backing_inode(dentry);
0055 
0056     inode->i_flags &= ~S_KERNEL_FILE;
0057     trace_cachefiles_mark_inactive(object, inode);
0058 }
0059 
0060 static void cachefiles_do_unmark_inode_in_use(struct cachefiles_object *object,
0061                           struct dentry *dentry)
0062 {
0063     struct inode *inode = d_backing_inode(dentry);
0064 
0065     inode_lock(inode);
0066     __cachefiles_unmark_inode_in_use(object, dentry);
0067     inode_unlock(inode);
0068 }
0069 
0070 /*
0071  * Unmark a backing inode and tell cachefilesd that there's something that can
0072  * be culled.
0073  */
0074 void cachefiles_unmark_inode_in_use(struct cachefiles_object *object,
0075                     struct file *file)
0076 {
0077     struct cachefiles_cache *cache = object->volume->cache;
0078     struct inode *inode = file_inode(file);
0079 
0080     if (inode) {
0081         cachefiles_do_unmark_inode_in_use(object, file->f_path.dentry);
0082 
0083         if (!test_bit(CACHEFILES_OBJECT_USING_TMPFILE, &object->flags)) {
0084             atomic_long_add(inode->i_blocks, &cache->b_released);
0085             if (atomic_inc_return(&cache->f_released))
0086                 cachefiles_state_changed(cache);
0087         }
0088     }
0089 }
0090 
0091 /*
0092  * get a subdirectory
0093  */
0094 struct dentry *cachefiles_get_directory(struct cachefiles_cache *cache,
0095                     struct dentry *dir,
0096                     const char *dirname,
0097                     bool *_is_new)
0098 {
0099     struct dentry *subdir;
0100     struct path path;
0101     int ret;
0102 
0103     _enter(",,%s", dirname);
0104 
0105     /* search the current directory for the element name */
0106     inode_lock_nested(d_inode(dir), I_MUTEX_PARENT);
0107 
0108 retry:
0109     ret = cachefiles_inject_read_error();
0110     if (ret == 0)
0111         subdir = lookup_one_len(dirname, dir, strlen(dirname));
0112     else
0113         subdir = ERR_PTR(ret);
0114     trace_cachefiles_lookup(NULL, dir, subdir);
0115     if (IS_ERR(subdir)) {
0116         trace_cachefiles_vfs_error(NULL, d_backing_inode(dir),
0117                        PTR_ERR(subdir),
0118                        cachefiles_trace_lookup_error);
0119         if (PTR_ERR(subdir) == -ENOMEM)
0120             goto nomem_d_alloc;
0121         goto lookup_error;
0122     }
0123 
0124     _debug("subdir -> %pd %s",
0125            subdir, d_backing_inode(subdir) ? "positive" : "negative");
0126 
0127     /* we need to create the subdir if it doesn't exist yet */
0128     if (d_is_negative(subdir)) {
0129         ret = cachefiles_has_space(cache, 1, 0,
0130                        cachefiles_has_space_for_create);
0131         if (ret < 0)
0132             goto mkdir_error;
0133 
0134         _debug("attempt mkdir");
0135 
0136         path.mnt = cache->mnt;
0137         path.dentry = dir;
0138         ret = security_path_mkdir(&path, subdir, 0700);
0139         if (ret < 0)
0140             goto mkdir_error;
0141         ret = cachefiles_inject_write_error();
0142         if (ret == 0)
0143             ret = vfs_mkdir(&init_user_ns, d_inode(dir), subdir, 0700);
0144         if (ret < 0) {
0145             trace_cachefiles_vfs_error(NULL, d_inode(dir), ret,
0146                            cachefiles_trace_mkdir_error);
0147             goto mkdir_error;
0148         }
0149         trace_cachefiles_mkdir(dir, subdir);
0150 
0151         if (unlikely(d_unhashed(subdir))) {
0152             cachefiles_put_directory(subdir);
0153             goto retry;
0154         }
0155         ASSERT(d_backing_inode(subdir));
0156 
0157         _debug("mkdir -> %pd{ino=%lu}",
0158                subdir, d_backing_inode(subdir)->i_ino);
0159         if (_is_new)
0160             *_is_new = true;
0161     }
0162 
0163     /* Tell rmdir() it's not allowed to delete the subdir */
0164     inode_lock(d_inode(subdir));
0165     inode_unlock(d_inode(dir));
0166 
0167     if (!__cachefiles_mark_inode_in_use(NULL, subdir))
0168         goto mark_error;
0169 
0170     inode_unlock(d_inode(subdir));
0171 
0172     /* we need to make sure the subdir is a directory */
0173     ASSERT(d_backing_inode(subdir));
0174 
0175     if (!d_can_lookup(subdir)) {
0176         pr_err("%s is not a directory\n", dirname);
0177         ret = -EIO;
0178         goto check_error;
0179     }
0180 
0181     ret = -EPERM;
0182     if (!(d_backing_inode(subdir)->i_opflags & IOP_XATTR) ||
0183         !d_backing_inode(subdir)->i_op->lookup ||
0184         !d_backing_inode(subdir)->i_op->mkdir ||
0185         !d_backing_inode(subdir)->i_op->rename ||
0186         !d_backing_inode(subdir)->i_op->rmdir ||
0187         !d_backing_inode(subdir)->i_op->unlink)
0188         goto check_error;
0189 
0190     _leave(" = [%lu]", d_backing_inode(subdir)->i_ino);
0191     return subdir;
0192 
0193 check_error:
0194     cachefiles_put_directory(subdir);
0195     _leave(" = %d [check]", ret);
0196     return ERR_PTR(ret);
0197 
0198 mark_error:
0199     inode_unlock(d_inode(subdir));
0200     dput(subdir);
0201     return ERR_PTR(-EBUSY);
0202 
0203 mkdir_error:
0204     inode_unlock(d_inode(dir));
0205     dput(subdir);
0206     pr_err("mkdir %s failed with error %d\n", dirname, ret);
0207     return ERR_PTR(ret);
0208 
0209 lookup_error:
0210     inode_unlock(d_inode(dir));
0211     ret = PTR_ERR(subdir);
0212     pr_err("Lookup %s failed with error %d\n", dirname, ret);
0213     return ERR_PTR(ret);
0214 
0215 nomem_d_alloc:
0216     inode_unlock(d_inode(dir));
0217     _leave(" = -ENOMEM");
0218     return ERR_PTR(-ENOMEM);
0219 }
0220 
0221 /*
0222  * Put a subdirectory.
0223  */
0224 void cachefiles_put_directory(struct dentry *dir)
0225 {
0226     if (dir) {
0227         inode_lock(dir->d_inode);
0228         __cachefiles_unmark_inode_in_use(NULL, dir);
0229         inode_unlock(dir->d_inode);
0230         dput(dir);
0231     }
0232 }
0233 
0234 /*
0235  * Remove a regular file from the cache.
0236  */
0237 static int cachefiles_unlink(struct cachefiles_cache *cache,
0238                  struct cachefiles_object *object,
0239                  struct dentry *dir, struct dentry *dentry,
0240                  enum fscache_why_object_killed why)
0241 {
0242     struct path path = {
0243         .mnt    = cache->mnt,
0244         .dentry = dir,
0245     };
0246     int ret;
0247 
0248     trace_cachefiles_unlink(object, d_inode(dentry)->i_ino, why);
0249     ret = security_path_unlink(&path, dentry);
0250     if (ret < 0) {
0251         cachefiles_io_error(cache, "Unlink security error");
0252         return ret;
0253     }
0254 
0255     ret = cachefiles_inject_remove_error();
0256     if (ret == 0) {
0257         ret = vfs_unlink(&init_user_ns, d_backing_inode(dir), dentry, NULL);
0258         if (ret == -EIO)
0259             cachefiles_io_error(cache, "Unlink failed");
0260     }
0261     if (ret != 0)
0262         trace_cachefiles_vfs_error(object, d_backing_inode(dir), ret,
0263                        cachefiles_trace_unlink_error);
0264     return ret;
0265 }
0266 
0267 /*
0268  * Delete an object representation from the cache
0269  * - File backed objects are unlinked
0270  * - Directory backed objects are stuffed into the graveyard for userspace to
0271  *   delete
0272  */
0273 int cachefiles_bury_object(struct cachefiles_cache *cache,
0274                struct cachefiles_object *object,
0275                struct dentry *dir,
0276                struct dentry *rep,
0277                enum fscache_why_object_killed why)
0278 {
0279     struct dentry *grave, *trap;
0280     struct path path, path_to_graveyard;
0281     char nbuffer[8 + 8 + 1];
0282     int ret;
0283 
0284     _enter(",'%pd','%pd'", dir, rep);
0285 
0286     if (rep->d_parent != dir) {
0287         inode_unlock(d_inode(dir));
0288         _leave(" = -ESTALE");
0289         return -ESTALE;
0290     }
0291 
0292     /* non-directories can just be unlinked */
0293     if (!d_is_dir(rep)) {
0294         dget(rep); /* Stop the dentry being negated if it's only pinned
0295                 * by a file struct.
0296                 */
0297         ret = cachefiles_unlink(cache, object, dir, rep, why);
0298         dput(rep);
0299 
0300         inode_unlock(d_inode(dir));
0301         _leave(" = %d", ret);
0302         return ret;
0303     }
0304 
0305     /* directories have to be moved to the graveyard */
0306     _debug("move stale object to graveyard");
0307     inode_unlock(d_inode(dir));
0308 
0309 try_again:
0310     /* first step is to make up a grave dentry in the graveyard */
0311     sprintf(nbuffer, "%08x%08x",
0312         (uint32_t) ktime_get_real_seconds(),
0313         (uint32_t) atomic_inc_return(&cache->gravecounter));
0314 
0315     /* do the multiway lock magic */
0316     trap = lock_rename(cache->graveyard, dir);
0317 
0318     /* do some checks before getting the grave dentry */
0319     if (rep->d_parent != dir || IS_DEADDIR(d_inode(rep))) {
0320         /* the entry was probably culled when we dropped the parent dir
0321          * lock */
0322         unlock_rename(cache->graveyard, dir);
0323         _leave(" = 0 [culled?]");
0324         return 0;
0325     }
0326 
0327     if (!d_can_lookup(cache->graveyard)) {
0328         unlock_rename(cache->graveyard, dir);
0329         cachefiles_io_error(cache, "Graveyard no longer a directory");
0330         return -EIO;
0331     }
0332 
0333     if (trap == rep) {
0334         unlock_rename(cache->graveyard, dir);
0335         cachefiles_io_error(cache, "May not make directory loop");
0336         return -EIO;
0337     }
0338 
0339     if (d_mountpoint(rep)) {
0340         unlock_rename(cache->graveyard, dir);
0341         cachefiles_io_error(cache, "Mountpoint in cache");
0342         return -EIO;
0343     }
0344 
0345     grave = lookup_one_len(nbuffer, cache->graveyard, strlen(nbuffer));
0346     if (IS_ERR(grave)) {
0347         unlock_rename(cache->graveyard, dir);
0348         trace_cachefiles_vfs_error(object, d_inode(cache->graveyard),
0349                        PTR_ERR(grave),
0350                        cachefiles_trace_lookup_error);
0351 
0352         if (PTR_ERR(grave) == -ENOMEM) {
0353             _leave(" = -ENOMEM");
0354             return -ENOMEM;
0355         }
0356 
0357         cachefiles_io_error(cache, "Lookup error %ld", PTR_ERR(grave));
0358         return -EIO;
0359     }
0360 
0361     if (d_is_positive(grave)) {
0362         unlock_rename(cache->graveyard, dir);
0363         dput(grave);
0364         grave = NULL;
0365         cond_resched();
0366         goto try_again;
0367     }
0368 
0369     if (d_mountpoint(grave)) {
0370         unlock_rename(cache->graveyard, dir);
0371         dput(grave);
0372         cachefiles_io_error(cache, "Mountpoint in graveyard");
0373         return -EIO;
0374     }
0375 
0376     /* target should not be an ancestor of source */
0377     if (trap == grave) {
0378         unlock_rename(cache->graveyard, dir);
0379         dput(grave);
0380         cachefiles_io_error(cache, "May not make directory loop");
0381         return -EIO;
0382     }
0383 
0384     /* attempt the rename */
0385     path.mnt = cache->mnt;
0386     path.dentry = dir;
0387     path_to_graveyard.mnt = cache->mnt;
0388     path_to_graveyard.dentry = cache->graveyard;
0389     ret = security_path_rename(&path, rep, &path_to_graveyard, grave, 0);
0390     if (ret < 0) {
0391         cachefiles_io_error(cache, "Rename security error %d", ret);
0392     } else {
0393         struct renamedata rd = {
0394             .old_mnt_userns = &init_user_ns,
0395             .old_dir    = d_inode(dir),
0396             .old_dentry = rep,
0397             .new_mnt_userns = &init_user_ns,
0398             .new_dir    = d_inode(cache->graveyard),
0399             .new_dentry = grave,
0400         };
0401         trace_cachefiles_rename(object, d_inode(rep)->i_ino, why);
0402         ret = cachefiles_inject_read_error();
0403         if (ret == 0)
0404             ret = vfs_rename(&rd);
0405         if (ret != 0)
0406             trace_cachefiles_vfs_error(object, d_inode(dir), ret,
0407                            cachefiles_trace_rename_error);
0408         if (ret != 0 && ret != -ENOMEM)
0409             cachefiles_io_error(cache,
0410                         "Rename failed with error %d", ret);
0411     }
0412 
0413     __cachefiles_unmark_inode_in_use(object, rep);
0414     unlock_rename(cache->graveyard, dir);
0415     dput(grave);
0416     _leave(" = 0");
0417     return 0;
0418 }
0419 
0420 /*
0421  * Delete a cache file.
0422  */
0423 int cachefiles_delete_object(struct cachefiles_object *object,
0424                  enum fscache_why_object_killed why)
0425 {
0426     struct cachefiles_volume *volume = object->volume;
0427     struct dentry *dentry = object->file->f_path.dentry;
0428     struct dentry *fan = volume->fanout[(u8)object->cookie->key_hash];
0429     int ret;
0430 
0431     _enter(",OBJ%x{%pD}", object->debug_id, object->file);
0432 
0433     /* Stop the dentry being negated if it's only pinned by a file struct. */
0434     dget(dentry);
0435 
0436     inode_lock_nested(d_backing_inode(fan), I_MUTEX_PARENT);
0437     ret = cachefiles_unlink(volume->cache, object, fan, dentry, why);
0438     inode_unlock(d_backing_inode(fan));
0439     dput(dentry);
0440     return ret;
0441 }
0442 
0443 /*
0444  * Create a temporary file and leave it unattached and un-xattr'd until the
0445  * time comes to discard the object from memory.
0446  */
0447 struct file *cachefiles_create_tmpfile(struct cachefiles_object *object)
0448 {
0449     struct cachefiles_volume *volume = object->volume;
0450     struct cachefiles_cache *cache = volume->cache;
0451     const struct cred *saved_cred;
0452     struct dentry *fan = volume->fanout[(u8)object->cookie->key_hash];
0453     struct file *file;
0454     struct path path;
0455     uint64_t ni_size;
0456     long ret;
0457 
0458 
0459     cachefiles_begin_secure(cache, &saved_cred);
0460 
0461     path.mnt = cache->mnt;
0462     ret = cachefiles_inject_write_error();
0463     if (ret == 0)
0464         path.dentry = vfs_tmpfile(&init_user_ns, fan, S_IFREG, O_RDWR);
0465     else
0466         path.dentry = ERR_PTR(ret);
0467     if (IS_ERR(path.dentry)) {
0468         trace_cachefiles_vfs_error(object, d_inode(fan), PTR_ERR(path.dentry),
0469                        cachefiles_trace_tmpfile_error);
0470         if (PTR_ERR(path.dentry) == -EIO)
0471             cachefiles_io_error_obj(object, "Failed to create tmpfile");
0472         file = ERR_CAST(path.dentry);
0473         goto out;
0474     }
0475 
0476     trace_cachefiles_tmpfile(object, d_backing_inode(path.dentry));
0477 
0478     if (!cachefiles_mark_inode_in_use(object, path.dentry)) {
0479         file = ERR_PTR(-EBUSY);
0480         goto out_dput;
0481     }
0482 
0483     ret = cachefiles_ondemand_init_object(object);
0484     if (ret < 0) {
0485         file = ERR_PTR(ret);
0486         goto out_unuse;
0487     }
0488 
0489     ni_size = object->cookie->object_size;
0490     ni_size = round_up(ni_size, CACHEFILES_DIO_BLOCK_SIZE);
0491 
0492     if (ni_size > 0) {
0493         trace_cachefiles_trunc(object, d_backing_inode(path.dentry), 0, ni_size,
0494                        cachefiles_trunc_expand_tmpfile);
0495         ret = cachefiles_inject_write_error();
0496         if (ret == 0)
0497             ret = vfs_truncate(&path, ni_size);
0498         if (ret < 0) {
0499             trace_cachefiles_vfs_error(
0500                 object, d_backing_inode(path.dentry), ret,
0501                 cachefiles_trace_trunc_error);
0502             file = ERR_PTR(ret);
0503             goto out_unuse;
0504         }
0505     }
0506 
0507     file = open_with_fake_path(&path, O_RDWR | O_LARGEFILE | O_DIRECT,
0508                    d_backing_inode(path.dentry), cache->cache_cred);
0509     if (IS_ERR(file)) {
0510         trace_cachefiles_vfs_error(object, d_backing_inode(path.dentry),
0511                        PTR_ERR(file),
0512                        cachefiles_trace_open_error);
0513         goto out_unuse;
0514     }
0515     if (unlikely(!file->f_op->read_iter) ||
0516         unlikely(!file->f_op->write_iter)) {
0517         fput(file);
0518         pr_notice("Cache does not support read_iter and write_iter\n");
0519         file = ERR_PTR(-EINVAL);
0520         goto out_unuse;
0521     }
0522 
0523     goto out_dput;
0524 
0525 out_unuse:
0526     cachefiles_do_unmark_inode_in_use(object, path.dentry);
0527 out_dput:
0528     dput(path.dentry);
0529 out:
0530     cachefiles_end_secure(cache, saved_cred);
0531     return file;
0532 }
0533 
0534 /*
0535  * Create a new file.
0536  */
0537 static bool cachefiles_create_file(struct cachefiles_object *object)
0538 {
0539     struct file *file;
0540     int ret;
0541 
0542     ret = cachefiles_has_space(object->volume->cache, 1, 0,
0543                    cachefiles_has_space_for_create);
0544     if (ret < 0)
0545         return false;
0546 
0547     file = cachefiles_create_tmpfile(object);
0548     if (IS_ERR(file))
0549         return false;
0550 
0551     set_bit(FSCACHE_COOKIE_NEEDS_UPDATE, &object->cookie->flags);
0552     set_bit(CACHEFILES_OBJECT_USING_TMPFILE, &object->flags);
0553     _debug("create -> %pD{ino=%lu}", file, file_inode(file)->i_ino);
0554     object->file = file;
0555     return true;
0556 }
0557 
0558 /*
0559  * Open an existing file, checking its attributes and replacing it if it is
0560  * stale.
0561  */
0562 static bool cachefiles_open_file(struct cachefiles_object *object,
0563                  struct dentry *dentry)
0564 {
0565     struct cachefiles_cache *cache = object->volume->cache;
0566     struct file *file;
0567     struct path path;
0568     int ret;
0569 
0570     _enter("%pd", dentry);
0571 
0572     if (!cachefiles_mark_inode_in_use(object, dentry))
0573         return false;
0574 
0575     /* We need to open a file interface onto a data file now as we can't do
0576      * it on demand because writeback called from do_exit() sees
0577      * current->fs == NULL - which breaks d_path() called from ext4 open.
0578      */
0579     path.mnt = cache->mnt;
0580     path.dentry = dentry;
0581     file = open_with_fake_path(&path, O_RDWR | O_LARGEFILE | O_DIRECT,
0582                    d_backing_inode(dentry), cache->cache_cred);
0583     if (IS_ERR(file)) {
0584         trace_cachefiles_vfs_error(object, d_backing_inode(dentry),
0585                        PTR_ERR(file),
0586                        cachefiles_trace_open_error);
0587         goto error;
0588     }
0589 
0590     if (unlikely(!file->f_op->read_iter) ||
0591         unlikely(!file->f_op->write_iter)) {
0592         pr_notice("Cache does not support read_iter and write_iter\n");
0593         goto error_fput;
0594     }
0595     _debug("file -> %pd positive", dentry);
0596 
0597     ret = cachefiles_ondemand_init_object(object);
0598     if (ret < 0)
0599         goto error_fput;
0600 
0601     ret = cachefiles_check_auxdata(object, file);
0602     if (ret < 0)
0603         goto check_failed;
0604 
0605     object->file = file;
0606 
0607     /* Always update the atime on an object we've just looked up (this is
0608      * used to keep track of culling, and atimes are only updated by read,
0609      * write and readdir but not lookup or open).
0610      */
0611     touch_atime(&file->f_path);
0612     dput(dentry);
0613     return true;
0614 
0615 check_failed:
0616     fscache_cookie_lookup_negative(object->cookie);
0617     cachefiles_unmark_inode_in_use(object, file);
0618     fput(file);
0619     dput(dentry);
0620     if (ret == -ESTALE)
0621         return cachefiles_create_file(object);
0622     return false;
0623 
0624 error_fput:
0625     fput(file);
0626 error:
0627     cachefiles_do_unmark_inode_in_use(object, dentry);
0628     dput(dentry);
0629     return false;
0630 }
0631 
0632 /*
0633  * walk from the parent object to the child object through the backing
0634  * filesystem, creating directories as we go
0635  */
0636 bool cachefiles_look_up_object(struct cachefiles_object *object)
0637 {
0638     struct cachefiles_volume *volume = object->volume;
0639     struct dentry *dentry, *fan = volume->fanout[(u8)object->cookie->key_hash];
0640     int ret;
0641 
0642     _enter("OBJ%x,%s,", object->debug_id, object->d_name);
0643 
0644     /* Look up path "cache/vol/fanout/file". */
0645     ret = cachefiles_inject_read_error();
0646     if (ret == 0)
0647         dentry = lookup_positive_unlocked(object->d_name, fan,
0648                           object->d_name_len);
0649     else
0650         dentry = ERR_PTR(ret);
0651     trace_cachefiles_lookup(object, fan, dentry);
0652     if (IS_ERR(dentry)) {
0653         if (dentry == ERR_PTR(-ENOENT))
0654             goto new_file;
0655         if (dentry == ERR_PTR(-EIO))
0656             cachefiles_io_error_obj(object, "Lookup failed");
0657         return false;
0658     }
0659 
0660     if (!d_is_reg(dentry)) {
0661         pr_err("%pd is not a file\n", dentry);
0662         inode_lock_nested(d_inode(fan), I_MUTEX_PARENT);
0663         ret = cachefiles_bury_object(volume->cache, object, fan, dentry,
0664                          FSCACHE_OBJECT_IS_WEIRD);
0665         dput(dentry);
0666         if (ret < 0)
0667             return false;
0668         goto new_file;
0669     }
0670 
0671     if (!cachefiles_open_file(object, dentry))
0672         return false;
0673 
0674     _leave(" = t [%lu]", file_inode(object->file)->i_ino);
0675     return true;
0676 
0677 new_file:
0678     fscache_cookie_lookup_negative(object->cookie);
0679     return cachefiles_create_file(object);
0680 }
0681 
0682 /*
0683  * Attempt to link a temporary file into its rightful place in the cache.
0684  */
0685 bool cachefiles_commit_tmpfile(struct cachefiles_cache *cache,
0686                    struct cachefiles_object *object)
0687 {
0688     struct cachefiles_volume *volume = object->volume;
0689     struct dentry *dentry, *fan = volume->fanout[(u8)object->cookie->key_hash];
0690     bool success = false;
0691     int ret;
0692 
0693     _enter(",%pD", object->file);
0694 
0695     inode_lock_nested(d_inode(fan), I_MUTEX_PARENT);
0696     ret = cachefiles_inject_read_error();
0697     if (ret == 0)
0698         dentry = lookup_one_len(object->d_name, fan, object->d_name_len);
0699     else
0700         dentry = ERR_PTR(ret);
0701     if (IS_ERR(dentry)) {
0702         trace_cachefiles_vfs_error(object, d_inode(fan), PTR_ERR(dentry),
0703                        cachefiles_trace_lookup_error);
0704         _debug("lookup fail %ld", PTR_ERR(dentry));
0705         goto out_unlock;
0706     }
0707 
0708     if (!d_is_negative(dentry)) {
0709         if (d_backing_inode(dentry) == file_inode(object->file)) {
0710             success = true;
0711             goto out_dput;
0712         }
0713 
0714         ret = cachefiles_unlink(volume->cache, object, fan, dentry,
0715                     FSCACHE_OBJECT_IS_STALE);
0716         if (ret < 0)
0717             goto out_dput;
0718 
0719         dput(dentry);
0720         ret = cachefiles_inject_read_error();
0721         if (ret == 0)
0722             dentry = lookup_one_len(object->d_name, fan, object->d_name_len);
0723         else
0724             dentry = ERR_PTR(ret);
0725         if (IS_ERR(dentry)) {
0726             trace_cachefiles_vfs_error(object, d_inode(fan), PTR_ERR(dentry),
0727                            cachefiles_trace_lookup_error);
0728             _debug("lookup fail %ld", PTR_ERR(dentry));
0729             goto out_unlock;
0730         }
0731     }
0732 
0733     ret = cachefiles_inject_read_error();
0734     if (ret == 0)
0735         ret = vfs_link(object->file->f_path.dentry, &init_user_ns,
0736                    d_inode(fan), dentry, NULL);
0737     if (ret < 0) {
0738         trace_cachefiles_vfs_error(object, d_inode(fan), ret,
0739                        cachefiles_trace_link_error);
0740         _debug("link fail %d", ret);
0741     } else {
0742         trace_cachefiles_link(object, file_inode(object->file));
0743         spin_lock(&object->lock);
0744         /* TODO: Do we want to switch the file pointer to the new dentry? */
0745         clear_bit(CACHEFILES_OBJECT_USING_TMPFILE, &object->flags);
0746         spin_unlock(&object->lock);
0747         success = true;
0748     }
0749 
0750 out_dput:
0751     dput(dentry);
0752 out_unlock:
0753     inode_unlock(d_inode(fan));
0754     _leave(" = %u", success);
0755     return success;
0756 }
0757 
0758 /*
0759  * Look up an inode to be checked or culled.  Return -EBUSY if the inode is
0760  * marked in use.
0761  */
0762 static struct dentry *cachefiles_lookup_for_cull(struct cachefiles_cache *cache,
0763                          struct dentry *dir,
0764                          char *filename)
0765 {
0766     struct dentry *victim;
0767     int ret = -ENOENT;
0768 
0769     inode_lock_nested(d_inode(dir), I_MUTEX_PARENT);
0770 
0771     victim = lookup_one_len(filename, dir, strlen(filename));
0772     if (IS_ERR(victim))
0773         goto lookup_error;
0774     if (d_is_negative(victim))
0775         goto lookup_put;
0776     if (d_inode(victim)->i_flags & S_KERNEL_FILE)
0777         goto lookup_busy;
0778     return victim;
0779 
0780 lookup_busy:
0781     ret = -EBUSY;
0782 lookup_put:
0783     inode_unlock(d_inode(dir));
0784     dput(victim);
0785     return ERR_PTR(ret);
0786 
0787 lookup_error:
0788     inode_unlock(d_inode(dir));
0789     ret = PTR_ERR(victim);
0790     if (ret == -ENOENT)
0791         return ERR_PTR(-ESTALE); /* Probably got retired by the netfs */
0792 
0793     if (ret == -EIO) {
0794         cachefiles_io_error(cache, "Lookup failed");
0795     } else if (ret != -ENOMEM) {
0796         pr_err("Internal error: %d\n", ret);
0797         ret = -EIO;
0798     }
0799 
0800     return ERR_PTR(ret);
0801 }
0802 
0803 /*
0804  * Cull an object if it's not in use
0805  * - called only by cache manager daemon
0806  */
0807 int cachefiles_cull(struct cachefiles_cache *cache, struct dentry *dir,
0808             char *filename)
0809 {
0810     struct dentry *victim;
0811     struct inode *inode;
0812     int ret;
0813 
0814     _enter(",%pd/,%s", dir, filename);
0815 
0816     victim = cachefiles_lookup_for_cull(cache, dir, filename);
0817     if (IS_ERR(victim))
0818         return PTR_ERR(victim);
0819 
0820     /* check to see if someone is using this object */
0821     inode = d_inode(victim);
0822     inode_lock(inode);
0823     if (inode->i_flags & S_KERNEL_FILE) {
0824         ret = -EBUSY;
0825     } else {
0826         /* Stop the cache from picking it back up */
0827         inode->i_flags |= S_KERNEL_FILE;
0828         ret = 0;
0829     }
0830     inode_unlock(inode);
0831     if (ret < 0)
0832         goto error_unlock;
0833 
0834     ret = cachefiles_bury_object(cache, NULL, dir, victim,
0835                      FSCACHE_OBJECT_WAS_CULLED);
0836     if (ret < 0)
0837         goto error;
0838 
0839     fscache_count_culled();
0840     dput(victim);
0841     _leave(" = 0");
0842     return 0;
0843 
0844 error_unlock:
0845     inode_unlock(d_inode(dir));
0846 error:
0847     dput(victim);
0848     if (ret == -ENOENT)
0849         return -ESTALE; /* Probably got retired by the netfs */
0850 
0851     if (ret != -ENOMEM) {
0852         pr_err("Internal error: %d\n", ret);
0853         ret = -EIO;
0854     }
0855 
0856     _leave(" = %d", ret);
0857     return ret;
0858 }
0859 
0860 /*
0861  * Find out if an object is in use or not
0862  * - called only by cache manager daemon
0863  * - returns -EBUSY or 0 to indicate whether an object is in use or not
0864  */
0865 int cachefiles_check_in_use(struct cachefiles_cache *cache, struct dentry *dir,
0866                 char *filename)
0867 {
0868     struct dentry *victim;
0869     int ret = 0;
0870 
0871     victim = cachefiles_lookup_for_cull(cache, dir, filename);
0872     if (IS_ERR(victim))
0873         return PTR_ERR(victim);
0874 
0875     inode_unlock(d_inode(dir));
0876     dput(victim);
0877     return ret;
0878 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!