328 lines
8.9 KiB
C
328 lines
8.9 KiB
C
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
/* Cache data I/O routines
|
|
*
|
|
* Copyright (C) 2021 Red Hat, Inc. All Rights Reserved.
|
|
* Written by David Howells (dhowells@redhat.com)
|
|
*/
|
|
#define FSCACHE_DEBUG_LEVEL OPERATION
|
|
#include <linux/fscache-cache.h>
|
|
#include <linux/uio.h>
|
|
#include <linux/bvec.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/uio.h>
|
|
#include "internal.h"
|
|
|
|
/**
|
|
* fscache_wait_for_operation - Wait for an object become accessible
|
|
* @cres: The cache resources for the operation being performed
|
|
* @want_state: The minimum state the object must be at
|
|
*
|
|
* See if the target cache object is at the specified minimum state of
|
|
* accessibility yet, and if not, wait for it.
|
|
*/
|
|
bool fscache_wait_for_operation(struct netfs_cache_resources *cres,
|
|
enum fscache_want_state want_state)
|
|
{
|
|
struct fscache_cookie *cookie = fscache_cres_cookie(cres);
|
|
enum fscache_cookie_state state;
|
|
|
|
again:
|
|
if (!fscache_cache_is_live(cookie->volume->cache)) {
|
|
_leave(" [broken]");
|
|
return false;
|
|
}
|
|
|
|
state = fscache_cookie_state(cookie);
|
|
_enter("c=%08x{%u},%x", cookie->debug_id, state, want_state);
|
|
|
|
switch (state) {
|
|
case FSCACHE_COOKIE_STATE_CREATING:
|
|
case FSCACHE_COOKIE_STATE_INVALIDATING:
|
|
if (want_state == FSCACHE_WANT_PARAMS)
|
|
goto ready; /* There can be no content */
|
|
fallthrough;
|
|
case FSCACHE_COOKIE_STATE_LOOKING_UP:
|
|
case FSCACHE_COOKIE_STATE_LRU_DISCARDING:
|
|
wait_var_event(&cookie->state,
|
|
fscache_cookie_state(cookie) != state);
|
|
goto again;
|
|
|
|
case FSCACHE_COOKIE_STATE_ACTIVE:
|
|
goto ready;
|
|
case FSCACHE_COOKIE_STATE_DROPPED:
|
|
case FSCACHE_COOKIE_STATE_RELINQUISHING:
|
|
default:
|
|
_leave(" [not live]");
|
|
return false;
|
|
}
|
|
|
|
ready:
|
|
if (!cres->cache_priv2)
|
|
return cookie->volume->cache->ops->begin_operation(cres, want_state);
|
|
return true;
|
|
}
|
|
EXPORT_SYMBOL(fscache_wait_for_operation);
|
|
|
|
/*
|
|
* Begin an I/O operation on the cache, waiting till we reach the right state.
|
|
*
|
|
* Attaches the resources required to the operation resources record.
|
|
*/
|
|
static int fscache_begin_operation(struct netfs_cache_resources *cres,
|
|
struct fscache_cookie *cookie,
|
|
enum fscache_want_state want_state,
|
|
enum fscache_access_trace why)
|
|
{
|
|
enum fscache_cookie_state state;
|
|
long timeo;
|
|
bool once_only = false;
|
|
|
|
cres->ops = NULL;
|
|
cres->cache_priv = cookie;
|
|
cres->cache_priv2 = NULL;
|
|
cres->debug_id = cookie->debug_id;
|
|
cres->inval_counter = cookie->inval_counter;
|
|
|
|
if (!fscache_begin_cookie_access(cookie, why))
|
|
return -ENOBUFS;
|
|
|
|
again:
|
|
spin_lock(&cookie->lock);
|
|
|
|
state = fscache_cookie_state(cookie);
|
|
_enter("c=%08x{%u},%x", cookie->debug_id, state, want_state);
|
|
|
|
switch (state) {
|
|
case FSCACHE_COOKIE_STATE_LOOKING_UP:
|
|
case FSCACHE_COOKIE_STATE_LRU_DISCARDING:
|
|
case FSCACHE_COOKIE_STATE_INVALIDATING:
|
|
goto wait_for_file_wrangling;
|
|
case FSCACHE_COOKIE_STATE_CREATING:
|
|
if (want_state == FSCACHE_WANT_PARAMS)
|
|
goto ready; /* There can be no content */
|
|
goto wait_for_file_wrangling;
|
|
case FSCACHE_COOKIE_STATE_ACTIVE:
|
|
goto ready;
|
|
case FSCACHE_COOKIE_STATE_DROPPED:
|
|
case FSCACHE_COOKIE_STATE_RELINQUISHING:
|
|
WARN(1, "Can't use cookie in state %u\n", cookie->state);
|
|
goto not_live;
|
|
default:
|
|
goto not_live;
|
|
}
|
|
|
|
ready:
|
|
spin_unlock(&cookie->lock);
|
|
if (!cookie->volume->cache->ops->begin_operation(cres, want_state))
|
|
goto failed;
|
|
return 0;
|
|
|
|
wait_for_file_wrangling:
|
|
spin_unlock(&cookie->lock);
|
|
trace_fscache_access(cookie->debug_id, refcount_read(&cookie->ref),
|
|
atomic_read(&cookie->n_accesses),
|
|
fscache_access_io_wait);
|
|
timeo = wait_var_event_timeout(&cookie->state,
|
|
fscache_cookie_state(cookie) != state, 20 * HZ);
|
|
if (timeo <= 1 && !once_only) {
|
|
pr_warn("%s: cookie state change wait timed out: cookie->state=%u state=%u",
|
|
__func__, fscache_cookie_state(cookie), state);
|
|
fscache_print_cookie(cookie, 'O');
|
|
once_only = true;
|
|
}
|
|
goto again;
|
|
|
|
not_live:
|
|
spin_unlock(&cookie->lock);
|
|
failed:
|
|
cres->cache_priv = NULL;
|
|
cres->ops = NULL;
|
|
fscache_end_cookie_access(cookie, fscache_access_io_not_live);
|
|
_leave(" = -ENOBUFS");
|
|
return -ENOBUFS;
|
|
}
|
|
|
|
int __fscache_begin_read_operation(struct netfs_cache_resources *cres,
|
|
struct fscache_cookie *cookie)
|
|
{
|
|
return fscache_begin_operation(cres, cookie, FSCACHE_WANT_PARAMS,
|
|
fscache_access_io_read);
|
|
}
|
|
EXPORT_SYMBOL(__fscache_begin_read_operation);
|
|
|
|
int __fscache_begin_write_operation(struct netfs_cache_resources *cres,
|
|
struct fscache_cookie *cookie)
|
|
{
|
|
return fscache_begin_operation(cres, cookie, FSCACHE_WANT_PARAMS,
|
|
fscache_access_io_write);
|
|
}
|
|
EXPORT_SYMBOL(__fscache_begin_write_operation);
|
|
|
|
/**
|
|
* fscache_dirty_folio - Mark folio dirty and pin a cache object for writeback
|
|
* @mapping: The mapping the folio belongs to.
|
|
* @folio: The folio being dirtied.
|
|
* @cookie: The cookie referring to the cache object
|
|
*
|
|
* Set the dirty flag on a folio and pin an in-use cache object in memory
|
|
* so that writeback can later write to it. This is intended
|
|
* to be called from the filesystem's ->dirty_folio() method.
|
|
*
|
|
* Return: true if the dirty flag was set on the folio, false otherwise.
|
|
*/
|
|
bool fscache_dirty_folio(struct address_space *mapping, struct folio *folio,
|
|
struct fscache_cookie *cookie)
|
|
{
|
|
struct inode *inode = mapping->host;
|
|
bool need_use = false;
|
|
|
|
_enter("");
|
|
|
|
if (!filemap_dirty_folio(mapping, folio))
|
|
return false;
|
|
if (!fscache_cookie_valid(cookie))
|
|
return true;
|
|
|
|
if (!(inode->i_state & I_PINNING_FSCACHE_WB)) {
|
|
spin_lock(&inode->i_lock);
|
|
if (!(inode->i_state & I_PINNING_FSCACHE_WB)) {
|
|
inode->i_state |= I_PINNING_FSCACHE_WB;
|
|
need_use = true;
|
|
}
|
|
spin_unlock(&inode->i_lock);
|
|
|
|
if (need_use)
|
|
fscache_use_cookie(cookie, true);
|
|
}
|
|
return true;
|
|
}
|
|
EXPORT_SYMBOL(fscache_dirty_folio);
|
|
|
|
struct fscache_write_request {
|
|
struct netfs_cache_resources cache_resources;
|
|
struct address_space *mapping;
|
|
loff_t start;
|
|
size_t len;
|
|
bool set_bits;
|
|
netfs_io_terminated_t term_func;
|
|
void *term_func_priv;
|
|
};
|
|
|
|
void __fscache_clear_page_bits(struct address_space *mapping,
|
|
loff_t start, size_t len)
|
|
{
|
|
pgoff_t first = start / PAGE_SIZE;
|
|
pgoff_t last = (start + len - 1) / PAGE_SIZE;
|
|
struct page *page;
|
|
|
|
if (len) {
|
|
XA_STATE(xas, &mapping->i_pages, first);
|
|
|
|
rcu_read_lock();
|
|
xas_for_each(&xas, page, last) {
|
|
end_page_fscache(page);
|
|
}
|
|
rcu_read_unlock();
|
|
}
|
|
}
|
|
EXPORT_SYMBOL(__fscache_clear_page_bits);
|
|
|
|
/*
|
|
* Deal with the completion of writing the data to the cache.
|
|
*/
|
|
static void fscache_wreq_done(void *priv, ssize_t transferred_or_error,
|
|
bool was_async)
|
|
{
|
|
struct fscache_write_request *wreq = priv;
|
|
|
|
fscache_clear_page_bits(wreq->mapping, wreq->start, wreq->len,
|
|
wreq->set_bits);
|
|
|
|
if (wreq->term_func)
|
|
wreq->term_func(wreq->term_func_priv, transferred_or_error,
|
|
was_async);
|
|
fscache_end_operation(&wreq->cache_resources);
|
|
kfree(wreq);
|
|
}
|
|
|
|
void __fscache_write_to_cache(struct fscache_cookie *cookie,
|
|
struct address_space *mapping,
|
|
loff_t start, size_t len, loff_t i_size,
|
|
netfs_io_terminated_t term_func,
|
|
void *term_func_priv,
|
|
bool cond)
|
|
{
|
|
struct fscache_write_request *wreq;
|
|
struct netfs_cache_resources *cres;
|
|
struct iov_iter iter;
|
|
int ret = -ENOBUFS;
|
|
|
|
if (len == 0)
|
|
goto abandon;
|
|
|
|
_enter("%llx,%zx", start, len);
|
|
|
|
wreq = kzalloc(sizeof(struct fscache_write_request), GFP_NOFS);
|
|
if (!wreq)
|
|
goto abandon;
|
|
wreq->mapping = mapping;
|
|
wreq->start = start;
|
|
wreq->len = len;
|
|
wreq->set_bits = cond;
|
|
wreq->term_func = term_func;
|
|
wreq->term_func_priv = term_func_priv;
|
|
|
|
cres = &wreq->cache_resources;
|
|
if (fscache_begin_operation(cres, cookie, FSCACHE_WANT_WRITE,
|
|
fscache_access_io_write) < 0)
|
|
goto abandon_free;
|
|
|
|
ret = cres->ops->prepare_write(cres, &start, &len, i_size, false);
|
|
if (ret < 0)
|
|
goto abandon_end;
|
|
|
|
/* TODO: Consider clearing page bits now for space the write isn't
|
|
* covering. This is more complicated than it appears when THPs are
|
|
* taken into account.
|
|
*/
|
|
|
|
iov_iter_xarray(&iter, WRITE, &mapping->i_pages, start, len);
|
|
fscache_write(cres, start, &iter, fscache_wreq_done, wreq);
|
|
return;
|
|
|
|
abandon_end:
|
|
return fscache_wreq_done(wreq, ret, false);
|
|
abandon_free:
|
|
kfree(wreq);
|
|
abandon:
|
|
fscache_clear_page_bits(mapping, start, len, cond);
|
|
if (term_func)
|
|
term_func(term_func_priv, ret, false);
|
|
}
|
|
EXPORT_SYMBOL(__fscache_write_to_cache);
|
|
|
|
/*
|
|
* Change the size of a backing object.
|
|
*/
|
|
void __fscache_resize_cookie(struct fscache_cookie *cookie, loff_t new_size)
|
|
{
|
|
struct netfs_cache_resources cres;
|
|
|
|
trace_fscache_resize(cookie, new_size);
|
|
if (fscache_begin_operation(&cres, cookie, FSCACHE_WANT_WRITE,
|
|
fscache_access_io_resize) == 0) {
|
|
fscache_stat(&fscache_n_resizes);
|
|
set_bit(FSCACHE_COOKIE_NEEDS_UPDATE, &cookie->flags);
|
|
|
|
/* We cannot defer a resize as we need to do it inside the
|
|
* netfs's inode lock so that we're serialised with respect to
|
|
* writes.
|
|
*/
|
|
cookie->volume->cache->ops->resize_cookie(&cres, new_size);
|
|
fscache_end_operation(&cres);
|
|
} else {
|
|
fscache_stat(&fscache_n_resizes_null);
|
|
}
|
|
}
|
|
EXPORT_SYMBOL(__fscache_resize_cookie);
|