lkml.org 
[lkml]   [2021]   [Oct]   [18]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    Subject[PATCH 34/67] cachefiles: Make cachefiles_write_prepare() check for space
    From
    Date
    Make the cachefiles_write_prepare() function check that there's sufficient
    space to fully satisfy a proposed write.

    If we already checked for allocated data during read preparation, then this
    fact can be used to skip the more thorough checks here.

    If there's enough space in the cache, we just allow the write.

    If we're uncertain, then we use SEEK_DATA/SEEK_HOLE to check if the block
    is already fully allocated - and if it is, we just allow the write.

    However, if there's insufficient space for the whole write and there's
    partially allocated data in the file, we punch out that data and disallow
    the write. This frees up some space and removes old data from the cache.

    Signed-off-by: David Howells <dhowells@redhat.com>
    ---

    fs/cachefiles/io.c | 82 ++++++++++++++++++++++++++++++++++++++++++++----
    fs/netfs/read_helper.c | 2 +
    include/linux/netfs.h | 3 +-
    3 files changed, 79 insertions(+), 8 deletions(-)

    diff --git a/fs/cachefiles/io.c b/fs/cachefiles/io.c
    index c05f64cdfd0e..350243b45dd5 100644
    --- a/fs/cachefiles/io.c
    +++ b/fs/cachefiles/io.c
    @@ -9,6 +9,7 @@
    #include <linux/slab.h>
    #include <linux/file.h>
    #include <linux/uio.h>
    +#include <linux/falloc.h>
    #include <linux/sched/mm.h>
    #include <trace/events/fscache.h>
    #include "internal.h"
    @@ -385,8 +386,7 @@ static enum netfs_read_source cachefiles_prepare_read(struct netfs_read_subreque
    goto out;

    download_and_store:
    - if (cachefiles_has_space(cache, 0, (subreq->len + PAGE_SIZE - 1) / PAGE_SIZE) == 0)
    - __set_bit(NETFS_SREQ_WRITE_TO_CACHE, &subreq->flags);
    + __set_bit(NETFS_SREQ_WRITE_TO_CACHE, &subreq->flags);
    out:
    cachefiles_end_secure(cache, saved_cred);
    out_no_object:
    @@ -397,17 +397,87 @@ static enum netfs_read_source cachefiles_prepare_read(struct netfs_read_subreque
    /*
    * Prepare for a write to occur.
    */
    -static int cachefiles_prepare_write(struct netfs_cache_resources *cres,
    - loff_t *_start, size_t *_len, loff_t i_size)
    +static int __cachefiles_prepare_write(struct netfs_cache_resources *cres,
    + loff_t *_start, size_t *_len, loff_t i_size,
    + bool no_space_allocated_yet)
    {
    - loff_t start = *_start;
    + struct cachefiles_object *object = cachefiles_cres_object(cres);
    + struct cachefiles_cache *cache = object->volume->cache;
    + struct file *file = cachefiles_cres_file(cres);
    + loff_t start = *_start, pos;
    size_t len = *_len, down;
    + int ret;

    /* Round to DIO size */
    down = start - round_down(start, PAGE_SIZE);
    *_start = start - down;
    *_len = round_up(down + len, PAGE_SIZE);
    - return 0;
    +
    + /* We need to work out whether there's sufficient disk space to perform
    + * the write - but we can skip that check if we have space already
    + * allocated.
    + */
    + if (no_space_allocated_yet)
    + goto check_space;
    +
    + pos = vfs_llseek(file, *_start, SEEK_DATA);
    + if (pos < 0 && pos >= (loff_t)-MAX_ERRNO) {
    + if (pos == -ENXIO)
    + goto check_space; /* Unallocated tail */
    + return pos;
    + }
    + if ((u64)pos >= (u64)*_start + *_len)
    + goto check_space; /* Unallocated region */
    +
    + /* We have a block that's at least partially filled - if we're low on
    + * space, we need to see if it's fully allocated. If it's not, we may
    + * want to cull it.
    + */
    + if (cachefiles_has_space(cache, 0, *_len / PAGE_SIZE) == 0)
    + return 0; /* Enough space to simply overwrite the whole block */
    +
    + pos = vfs_llseek(file, *_start, SEEK_HOLE);
    + if (pos < 0 && pos >= (loff_t)-MAX_ERRNO)
    + return pos;
    + if ((u64)pos >= (u64)*_start + *_len)
    + return 0; /* Fully allocated */
    +
    + /* Partially allocated, but insufficient space: cull. */
    + ret = vfs_fallocate(file, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
    + *_start, *_len);
    + if (ret < 0) {
    + cachefiles_io_error_obj(object,
    + "CacheFiles: fallocate failed (%d)\n", ret);
    + ret = -EIO;
    + }
    +
    + return ret;
    +
    +check_space:
    + return cachefiles_has_space(cache, 0, *_len / PAGE_SIZE);
    +}
    +
    +static int cachefiles_prepare_write(struct netfs_cache_resources *cres,
    + loff_t *_start, size_t *_len, loff_t i_size,
    + bool no_space_allocated_yet)
    +{
    + struct cachefiles_object *object = cachefiles_cres_object(cres);
    + struct cachefiles_cache *cache = object->volume->cache;
    + const struct cred *saved_cred;
    + int ret;
    +
    + if (!cachefiles_cres_file(cres)) {
    + if (!fscache_wait_for_operation(cres, FSCACHE_WANT_WRITE))
    + return -ENOBUFS;
    + if (!cachefiles_cres_file(cres))
    + return -ENOBUFS;
    + }
    +
    + cachefiles_begin_secure(cache, &saved_cred);
    + ret = __cachefiles_prepare_write(cres, _start, _len, i_size,
    + no_space_allocated_yet);
    + cachefiles_end_secure(cache, saved_cred);
    + return ret;
    }

    /*
    diff --git a/fs/netfs/read_helper.c b/fs/netfs/read_helper.c
    index dfc60c79a9f3..80f8e334371d 100644
    --- a/fs/netfs/read_helper.c
    +++ b/fs/netfs/read_helper.c
    @@ -323,7 +323,7 @@ static void netfs_rreq_do_write_to_cache(struct netfs_read_request *rreq)
    }

    ret = cres->ops->prepare_write(cres, &subreq->start, &subreq->len,
    - rreq->i_size);
    + rreq->i_size, true);
    if (ret < 0) {
    trace_netfs_failure(rreq, subreq, ret, netfs_fail_prepare_write);
    trace_netfs_sreq(subreq, netfs_sreq_trace_write_skip);
    diff --git a/include/linux/netfs.h b/include/linux/netfs.h
    index 014fb502fd91..99137486d351 100644
    --- a/include/linux/netfs.h
    +++ b/include/linux/netfs.h
    @@ -220,7 +220,8 @@ struct netfs_cache_ops {
    * actually do.
    */
    int (*prepare_write)(struct netfs_cache_resources *cres,
    - loff_t *_start, size_t *_len, loff_t i_size);
    + loff_t *_start, size_t *_len, loff_t i_size,
    + bool no_space_allocated_yet);

    /* Prepare a write operation for the fallback fscache API, working out
    * whether we can cache a page or not.

    \
     
     \ /
      Last update: 2021-10-18 17:01    [W:2.161 / U:0.016 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site