lkml.org 
[lkml]   [2021]   [Nov]   [29]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    Subject[PATCH 25/64] fscache: Implement raw I/O interface
    From
    Date
    Provide a pair of functions to perform raw I/O on the cache.  The first
    function allows an arbitrary asynchronous direct-IO read to be made against
    a cache object, though the read should be aligned and sized appropriately
    for the backing device:

    int fscache_read(struct netfs_cache_resources *cres,
    loff_t start_pos,
    struct iov_iter *iter,
    enum netfs_read_from_hole read_hole,
    netfs_io_terminated_t term_func,
    void *term_func_priv);

    The cache resources must have been previously initialised by
    fscache_begin_read_operation(). A read operation is sent to the backing
    filesystem, starting at start_pos within the file. The size of the read is
    specified by the iterator, as is the location of the output buffer.

    If there is a hole in the data it can be ignored and left to the backing
    filesystem to deal with (NETFS_READ_HOLE_IGNORE), a hole at the beginning
    can be skipped over and the buffer padded with zeros
    (NETFS_READ_HOLE_CLEAR) or -ENODATA can be given (NETFS_READ_HOLE_FAIL).

    If term_func is not NULL, the operation may be performed asynchronously.
    Upon completion, successful or otherwise, (*term_func)() will be called and
    passed term_func_priv, along with an error or the amount of data
    transferred. If the op is run asynchronously, fscache_read() will return
    -EIOCBQUEUED.

    The second function allows an arbitrary asynchronous direct-IO write to be
    made against a cache object, though the write should be aligned and sized
    appropriately for the backing device:

    int fscache_write(struct netfs_cache_resources *cres,
    loff_t start_pos,
    struct iov_iter *iter,
    netfs_io_terminated_t term_func,
    void *term_func_priv);

    This works in very similar way to fscache_read(), except that there's no
    need to deal with holes (they're just overwritten).

    The caller is responsible for preventing concurrent overlapping writes.

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

    include/linux/fscache.h | 74 ++++++++++++++++++++++++++++++++++++++++
    include/trace/events/fscache.h | 2 +
    2 files changed, 76 insertions(+)

    diff --git a/include/linux/fscache.h b/include/linux/fscache.h
    index ccdfdfc700cd..f3c78a8859c0 100644
    --- a/include/linux/fscache.h
    +++ b/include/linux/fscache.h
    @@ -421,4 +421,78 @@ int fscache_begin_read_operation(struct netfs_cache_resources *cres,
    return -ENOBUFS;
    }

    +/**
    + * fscache_read - Start a read from the cache.
    + * @cres: The cache resources to use
    + * @start_pos: The beginning file offset in the cache file
    + * @iter: The buffer to fill - and also the length
    + * @read_hole: How to handle a hole in the data.
    + * @term_func: The function to call upon completion
    + * @term_func_priv: The private data for @term_func
    + *
    + * Start a read from the cache. @cres indicates the cache object to read from
    + * and must be obtained by a call to fscache_begin_operation() beforehand.
    + *
    + * The data is read into the iterator, @iter, and that also indicates the size
    + * of the operation. @start_pos is the start position in the file, though if
    + * @seek_data is set appropriately, the cache can use SEEK_DATA to find the
    + * next piece of data, writing zeros for the hole into the iterator.
    + *
    + * Upon termination of the operation, @term_func will be called and supplied
    + * with @term_func_priv plus the amount of data written, if successful, or the
    + * error code otherwise.
    + *
    + * @read_hole indicates how a partially populated region in the cache should be
    + * handled. It can be one of a number of settings:
    + *
    + * NETFS_READ_HOLE_IGNORE - Just try to read (may return a short read).
    + *
    + * NETFS_READ_HOLE_CLEAR - Seek for data, clearing the part of the buffer
    + * skipped over, then do as for IGNORE.
    + *
    + * NETFS_READ_HOLE_FAIL - Give ENODATA if we encounter a hole.
    + */
    +static inline
    +int fscache_read(struct netfs_cache_resources *cres,
    + loff_t start_pos,
    + struct iov_iter *iter,
    + enum netfs_read_from_hole read_hole,
    + netfs_io_terminated_t term_func,
    + void *term_func_priv)
    +{
    + const struct netfs_cache_ops *ops = fscache_operation_valid(cres);
    + return ops->read(cres, start_pos, iter, read_hole,
    + term_func, term_func_priv);
    +}
    +
    +/**
    + * fscache_write - Start a write to the cache.
    + * @cres: The cache resources to use
    + * @start_pos: The beginning file offset in the cache file
    + * @iter: The data to write - and also the length
    + * @term_func: The function to call upon completion
    + * @term_func_priv: The private data for @term_func
    + *
    + * Start a write to the cache. @cres indicates the cache object to write to and
    + * must be obtained by a call to fscache_begin_operation() beforehand.
    + *
    + * The data to be written is obtained from the iterator, @iter, and that also
    + * indicates the size of the operation. @start_pos is the start position in
    + * the file.
    + *
    + * Upon termination of the operation, @term_func will be called and supplied
    + * with @term_func_priv plus the amount of data written, if successful, or the
    + * error code otherwise.
    + */
    +static inline
    +int fscache_write(struct netfs_cache_resources *cres,
    + loff_t start_pos,
    + struct iov_iter *iter,
    + netfs_io_terminated_t term_func,
    + void *term_func_priv)
    +{
    + const struct netfs_cache_ops *ops = fscache_operation_valid(cres);
    + return ops->write(cres, start_pos, iter, term_func, term_func_priv);
    +}
    +
    #endif /* _LINUX_FSCACHE_H */
    diff --git a/include/trace/events/fscache.h b/include/trace/events/fscache.h
    index d8a8c56eb5d6..e8b5a14ecf6c 100644
    --- a/include/trace/events/fscache.h
    +++ b/include/trace/events/fscache.h
    @@ -79,6 +79,7 @@ enum fscache_access_trace {
    fscache_access_io_not_live,
    fscache_access_io_read,
    fscache_access_io_wait,
    + fscache_access_io_write,
    fscache_access_lookup_cookie,
    fscache_access_lookup_cookie_end,
    fscache_access_lookup_cookie_end_failed,
    @@ -149,6 +150,7 @@ enum fscache_access_trace {
    EM(fscache_access_io_not_live, "END io_notl") \
    EM(fscache_access_io_read, "BEGIN io_read") \
    EM(fscache_access_io_wait, "WAIT io ") \
    + EM(fscache_access_io_write, "BEGIN io_writ") \
    EM(fscache_access_lookup_cookie, "BEGIN lookup ") \
    EM(fscache_access_lookup_cookie_end, "END lookup ") \
    EM(fscache_access_lookup_cookie_end_failed,"END lookupf") \

    \
     
     \ /
      Last update: 2021-11-29 15:32    [W:2.289 / U:0.052 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site