aleph/lkl_linux
1
0
Fork 0
mirror of https://github.com/lkl/linux.git synced 2025-12-19 16:13:19 +09:00
Code Issues Packages Projects Releases Wiki Activity

fscache: Implement cookie invalidation

Browse Source 
Add a function to invalidate the cache behind a cookie:

	void fscache_invalidate(struct fscache_cookie *cookie,
				const void *aux_data,
				loff_t size,
				unsigned int flags)

This causes any cached data for the specified cookie to be discarded.  If
the cookie is marked as being in use, a new cache object will be created if
possible and future I/O will use that instead.  In-flight I/O should be
abandoned (writes) or reconsidered (reads).  Each time it is called
cookie->inval_counter is incremented and this can be used to detect
invalidation at the end of an I/O operation.

The coherency data attached to the cookie can be updated and the cookie
size should be reset.  One flag is available, FSCACHE_INVAL_DIO_WRITE,
which should be used to indicate invalidation due to a DIO write on a
file.  This will temporarily disable caching for this cookie.

Changes
=======
ver #2:
 - Should only change to inval state if can get access to cache.

Signed-off-by: David Howells <dhowells@redhat.com>
Reviewed-by: Jeff Layton <jlayton@kernel.org>
cc: linux-cachefs@redhat.com
Link: https://lore.kernel.org/r/163819602231.215744.11206598147269491575.stgit@warthog.procyon.org.uk/ # v1
Link: https://lore.kernel.org/r/163906909707.143852.18056070560477964891.stgit@warthog.procyon.org.uk/ # v2
Link: https://lore.kernel.org/r/163967107447.1823006.5945029409592119962.stgit@warthog.procyon.org.uk/ # v3
Link: https://lore.kernel.org/r/164021512640.640689.11418616313147754172.stgit@warthog.procyon.org.uk/ # v4
This commit is contained in:
David Howells
2021-10-20 15:53:34 +01:00
parent 12bb21a29c
commit d24af13e2e
7 changed files with 155 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

88
fs/fscache/cookie.c
View File

@@ -19,6 +19,7 @@ static void fscache_cookie_lru_timed_out(struct timer_list *timer);
static void fscache_cookie_lru_worker(struct work_struct *work);
static void fscache_cookie_worker(struct work_struct *work);
static void fscache_unhash_cookie(struct fscache_cookie *cookie);
static void fscache_perform_invalidation(struct fscache_cookie *cookie);
#define fscache_cookie_hash_shift 15
static struct hlist_bl_head fscache_cookie_hash[1 << fscache_cookie_hash_shift];
@@ -28,7 +29,7 @@ static LIST_HEAD(fscache_cookie_lru);
static DEFINE_SPINLOCK(fscache_cookie_lru_lock);
DEFINE_TIMER(fscache_cookie_lru_timer, fscache_cookie_lru_timed_out);
static DECLARE_WORK(fscache_cookie_lru_work, fscache_cookie_lru_worker);
static const char fscache_cookie_states[FSCACHE_COOKIE_STATE__NR] = "-LCAFUWRD";
static const char fscache_cookie_states[FSCACHE_COOKIE_STATE__NR] = "-LCAIFUWRD";
unsigned int fscache_lru_cookie_timeout = 10 * HZ;
void fscache_print_cookie(struct fscache_cookie *cookie, char prefix)
@@ -236,6 +237,19 @@ void fscache_cookie_lookup_negative(struct fscache_cookie *cookie)
}
EXPORT_SYMBOL(fscache_cookie_lookup_negative);
/**
* fscache_resume_after_invalidation - Allow I/O to resume after invalidation
* @cookie: The cookie that was invalidated
*
* Tell fscache that invalidation is sufficiently complete that I/O can be
* allowed again.
*/
void fscache_resume_after_invalidation(struct fscache_cookie *cookie)
{
fscache_set_cookie_state(cookie, FSCACHE_COOKIE_STATE_ACTIVE);
}
EXPORT_SYMBOL(fscache_resume_after_invalidation);
/**
* fscache_caching_failed - Report that a failure stopped caching on a cookie
* @cookie: The cookie that was affected
@@ -566,6 +580,7 @@ again:
set_bit(FSCACHE_COOKIE_LOCAL_WRITE, &cookie->flags);
break;
case FSCACHE_COOKIE_STATE_ACTIVE:
case FSCACHE_COOKIE_STATE_INVALIDATING:
if (will_modify &&
!test_and_set_bit(FSCACHE_COOKIE_LOCAL_WRITE, &cookie->flags)) {
set_bit(FSCACHE_COOKIE_DO_PREP_TO_WRITE, &cookie->flags);
@@ -671,6 +686,11 @@ again_locked:
fscache_perform_lookup(cookie);
goto again;
case FSCACHE_COOKIE_STATE_INVALIDATING:
spin_unlock(&cookie->lock);
fscache_perform_invalidation(cookie);
goto again;
case FSCACHE_COOKIE_STATE_ACTIVE:
if (test_and_clear_bit(FSCACHE_COOKIE_DO_PREP_TO_WRITE, &cookie->flags)) {
spin_unlock(&cookie->lock);
@@ -962,6 +982,72 @@ struct fscache_cookie *fscache_get_cookie(struct fscache_cookie *cookie,
}
EXPORT_SYMBOL(fscache_get_cookie);
/*
* Ask the cache to effect invalidation of a cookie.
*/
static void fscache_perform_invalidation(struct fscache_cookie *cookie)
{
if (!cookie->volume->cache->ops->invalidate_cookie(cookie))
fscache_caching_failed(cookie);
fscache_end_cookie_access(cookie, fscache_access_invalidate_cookie_end);
}
/*
* Invalidate an object.
*/
void __fscache_invalidate(struct fscache_cookie *cookie,
const void *aux_data, loff_t new_size,
unsigned int flags)
{
bool is_caching;
_enter("c=%x", cookie->debug_id);
fscache_stat(&fscache_n_invalidates);
if (WARN(test_bit(FSCACHE_COOKIE_RELINQUISHED, &cookie->flags),
"Trying to invalidate relinquished cookie\n"))
return;
if ((flags & FSCACHE_INVAL_DIO_WRITE) &&
test_and_set_bit(FSCACHE_COOKIE_DISABLED, &cookie->flags))
return;
spin_lock(&cookie->lock);
set_bit(FSCACHE_COOKIE_NO_DATA_TO_READ, &cookie->flags);
fscache_update_aux(cookie, aux_data, &new_size);
cookie->inval_counter++;
trace_fscache_invalidate(cookie, new_size);
switch (cookie->state) {
case FSCACHE_COOKIE_STATE_INVALIDATING: /* is_still_valid will catch it */
default:
spin_unlock(&cookie->lock);
_leave(" [no %u]", cookie->state);
return;
case FSCACHE_COOKIE_STATE_LOOKING_UP:
case FSCACHE_COOKIE_STATE_CREATING:
spin_unlock(&cookie->lock);
_leave(" [look %x]", cookie->inval_counter);
return;
case FSCACHE_COOKIE_STATE_ACTIVE:
is_caching = fscache_begin_cookie_access(
cookie, fscache_access_invalidate_cookie);
if (is_caching)
__fscache_set_cookie_state(cookie, FSCACHE_COOKIE_STATE_INVALIDATING);
spin_unlock(&cookie->lock);
wake_up_cookie_state(cookie);
if (is_caching)
fscache_queue_cookie(cookie, fscache_cookie_get_inval_work);
_leave(" [inv]");
return;
}
}
EXPORT_SYMBOL(__fscache_invalidate);
/*
* Generate a list of extant cookies in /proc/fs/fscache/cookies
*/

2
fs/fscache/internal.h
View File

@@ -105,6 +105,8 @@ extern atomic_t fscache_n_acquires;
extern atomic_t fscache_n_acquires_ok;
extern atomic_t fscache_n_acquires_oom;
extern atomic_t fscache_n_invalidates;
extern atomic_t fscache_n_relinquishes;
extern atomic_t fscache_n_relinquishes_retire;
extern atomic_t fscache_n_relinquishes_dropped;

5
fs/fscache/stats.c
View File

@@ -26,6 +26,8 @@ atomic_t fscache_n_acquires;
atomic_t fscache_n_acquires_ok;
atomic_t fscache_n_acquires_oom;
atomic_t fscache_n_invalidates;
atomic_t fscache_n_updates;
EXPORT_SYMBOL(fscache_n_updates);
@@ -59,6 +61,9 @@ int fscache_stats_show(struct seq_file *m, void *v)
timer_pending(&fscache_cookie_lru_timer) ?
fscache_cookie_lru_timer.expires - jiffies : 0);
seq_printf(m, "Invals : n=%u\n",
atomic_read(&fscache_n_invalidates));
seq_printf(m, "Updates: n=%u\n",
atomic_read(&fscache_n_updates));