Skip to content

Commit 12bb21a

Browse files
dhowellsdhowells
committed
fscache: Implement cookie user counting and resource pinning
Provide a pair of functions to count the number of users of a cookie (open files, writeback, invalidation, resizing, reads, writes), to obtain and pin resources for the cookie and to prevent culling for the whilst there are users. The first function marks a cookie as being in use: void fscache_use_cookie(struct fscache_cookie *cookie, bool will_modify); The caller should indicate the cookie to use and whether or not the caller is in a context that may modify the cookie (e.g. a file open O_RDWR). If the cookie is not already resourced, fscache will ask the cache backend in the background to do whatever it needs to look up, create or otherwise obtain the resources necessary to access data. This is pinned to the cookie and may not be culled, though it may be withdrawn if the cache as a whole is withdrawn. The second function removes the in-use mark from a cookie and, optionally, updates the coherency data: void fscache_unuse_cookie(struct fscache_cookie *cookie, const void *aux_data, const loff_t *object_size); If non-NULL, the aux_data buffer and/or the object_size will be saved into the cookie and will be set on the backing store when the object is committed. If this removes the last usage on a cookie, the cookie is placed onto an LRU list from which it will be removed and closed after a couple of seconds if it doesn't get reused. This prevents resource overload in the cache - in particular it prevents it from holding too many files open. Changes ======= ver #2: - Fix fscache_unuse_cookie() to use atomic_dec_and_lock() to avoid a potential race if the cookie gets reused before it completes the unusement. - Added missing transition to LRU_DISCARDING state. 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/163819600612.215744.13678350304176542741.stgit@warthog.procyon.org.uk/ # v1 Link: https://lore.kernel.org/r/163906907567.143852.16979631199380722019.stgit@warthog.procyon.org.uk/ # v2 Link: https://lore.kernel.org/r/163967106467.1823006.6790864931048582667.stgit@warthog.procyon.org.uk/ # v3 Link: https://lore.kernel.org/r/164021511674.640689.10084988363699111860.stgit@warthog.procyon.org.uk/ # v4
1 parent 5d00e42 commit 12bb21a

File tree

5 files changed

+327
-2
lines changed

5 files changed

+327
-2
lines changed

‎fs/fscache/cookie.c

+217-1
Original file line numberDiff line numberDiff line change
@@ -15,14 +15,21 @@
1515

1616
struct kmem_cache *fscache_cookie_jar;
1717

18+
static void fscache_cookie_lru_timed_out(struct timer_list *timer);
19+
static void fscache_cookie_lru_worker(struct work_struct *work);
1820
static void fscache_cookie_worker(struct work_struct *work);
1921
static void fscache_unhash_cookie(struct fscache_cookie *cookie);
2022

2123
#define fscache_cookie_hash_shift 15
2224
static struct hlist_bl_head fscache_cookie_hash[1 << fscache_cookie_hash_shift];
2325
static LIST_HEAD(fscache_cookies);
2426
static DEFINE_RWLOCK(fscache_cookies_lock);
25-
static const char fscache_cookie_states[FSCACHE_COOKIE_STATE__NR] = "-LCAFWRD";
27+
static LIST_HEAD(fscache_cookie_lru);
28+
static DEFINE_SPINLOCK(fscache_cookie_lru_lock);
29+
DEFINE_TIMER(fscache_cookie_lru_timer, fscache_cookie_lru_timed_out);
30+
static DECLARE_WORK(fscache_cookie_lru_work, fscache_cookie_lru_worker);
31+
static const char fscache_cookie_states[FSCACHE_COOKIE_STATE__NR] = "-LCAFUWRD";
32+
unsigned int fscache_lru_cookie_timeout = 10 * HZ;
2633

2734
void fscache_print_cookie(struct fscache_cookie *cookie, char prefix)
2835
{
@@ -47,6 +54,14 @@ void fscache_print_cookie(struct fscache_cookie *cookie, char prefix)
4754

4855
static void fscache_free_cookie(struct fscache_cookie *cookie)
4956
{
57+
if (WARN_ON_ONCE(!list_empty(&cookie->commit_link))) {
58+
spin_lock(&fscache_cookie_lru_lock);
59+
list_del_init(&cookie->commit_link);
60+
spin_unlock(&fscache_cookie_lru_lock);
61+
fscache_stat_d(&fscache_n_cookies_lru);
62+
fscache_stat(&fscache_n_cookies_lru_removed);
63+
}
64+
5065
if (WARN_ON_ONCE(test_bit(FSCACHE_COOKIE_IS_HASHED, &cookie->flags))) {
5166
fscache_print_cookie(cookie, 'F');
5267
return;
@@ -498,6 +513,126 @@ static void fscache_perform_lookup(struct fscache_cookie *cookie)
498513
fscache_end_volume_access(cookie->volume, cookie, trace);
499514
}
500515

516+
/*
517+
* Begin the process of looking up a cookie. We offload the actual process to
518+
* a worker thread.
519+
*/
520+
static bool fscache_begin_lookup(struct fscache_cookie *cookie, bool will_modify)
521+
{
522+
if (will_modify) {
523+
set_bit(FSCACHE_COOKIE_LOCAL_WRITE, &cookie->flags);
524+
set_bit(FSCACHE_COOKIE_DO_PREP_TO_WRITE, &cookie->flags);
525+
}
526+
if (!fscache_begin_volume_access(cookie->volume, cookie,
527+
fscache_access_lookup_cookie))
528+
return false;
529+
530+
__fscache_begin_cookie_access(cookie, fscache_access_lookup_cookie);
531+
__fscache_set_cookie_state(cookie, FSCACHE_COOKIE_STATE_LOOKING_UP);
532+
set_bit(FSCACHE_COOKIE_IS_CACHING, &cookie->flags);
533+
set_bit(FSCACHE_COOKIE_HAS_BEEN_CACHED, &cookie->flags);
534+
return true;
535+
}
536+
537+
/*
538+
* Start using the cookie for I/O. This prevents the backing object from being
539+
* reaped by VM pressure.
540+
*/
541+
void __fscache_use_cookie(struct fscache_cookie *cookie, bool will_modify)
542+
{
543+
enum fscache_cookie_state state;
544+
bool queue = false;
545+
546+
_enter("c=%08x", cookie->debug_id);
547+
548+
if (WARN(test_bit(FSCACHE_COOKIE_RELINQUISHED, &cookie->flags),
549+
"Trying to use relinquished cookie\n"))
550+
return;
551+
552+
spin_lock(&cookie->lock);
553+
554+
atomic_inc(&cookie->n_active);
555+
556+
again:
557+
state = fscache_cookie_state(cookie);
558+
switch (state) {
559+
case FSCACHE_COOKIE_STATE_QUIESCENT:
560+
queue = fscache_begin_lookup(cookie, will_modify);
561+
break;
562+
563+
case FSCACHE_COOKIE_STATE_LOOKING_UP:
564+
case FSCACHE_COOKIE_STATE_CREATING:
565+
if (will_modify)
566+
set_bit(FSCACHE_COOKIE_LOCAL_WRITE, &cookie->flags);
567+
break;
568+
case FSCACHE_COOKIE_STATE_ACTIVE:
569+
if (will_modify &&
570+
!test_and_set_bit(FSCACHE_COOKIE_LOCAL_WRITE, &cookie->flags)) {
571+
set_bit(FSCACHE_COOKIE_DO_PREP_TO_WRITE, &cookie->flags);
572+
queue = true;
573+
}
574+
break;
575+
576+
case FSCACHE_COOKIE_STATE_FAILED:
577+
case FSCACHE_COOKIE_STATE_WITHDRAWING:
578+
break;
579+
580+
case FSCACHE_COOKIE_STATE_LRU_DISCARDING:
581+
spin_unlock(&cookie->lock);
582+
wait_var_event(&cookie->state,
583+
fscache_cookie_state(cookie) !=
584+
FSCACHE_COOKIE_STATE_LRU_DISCARDING);
585+
spin_lock(&cookie->lock);
586+
goto again;
587+
588+
case FSCACHE_COOKIE_STATE_DROPPED:
589+
case FSCACHE_COOKIE_STATE_RELINQUISHING:
590+
WARN(1, "Can't use cookie in state %u\n", state);
591+
break;
592+
}
593+
594+
spin_unlock(&cookie->lock);
595+
if (queue)
596+
fscache_queue_cookie(cookie, fscache_cookie_get_use_work);
597+
_leave("");
598+
}
599+
EXPORT_SYMBOL(__fscache_use_cookie);
600+
601+
static void fscache_unuse_cookie_locked(struct fscache_cookie *cookie)
602+
{
603+
clear_bit(FSCACHE_COOKIE_DISABLED, &cookie->flags);
604+
if (!test_bit(FSCACHE_COOKIE_IS_CACHING, &cookie->flags))
605+
return;
606+
607+
cookie->unused_at = jiffies;
608+
spin_lock(&fscache_cookie_lru_lock);
609+
if (list_empty(&cookie->commit_link)) {
610+
fscache_get_cookie(cookie, fscache_cookie_get_lru);
611+
fscache_stat(&fscache_n_cookies_lru);
612+
}
613+
list_move_tail(&cookie->commit_link, &fscache_cookie_lru);
614+
615+
spin_unlock(&fscache_cookie_lru_lock);
616+
timer_reduce(&fscache_cookie_lru_timer,
617+
jiffies + fscache_lru_cookie_timeout);
618+
}
619+
620+
/*
621+
* Stop using the cookie for I/O.
622+
*/
623+
void __fscache_unuse_cookie(struct fscache_cookie *cookie,
624+
const void *aux_data, const loff_t *object_size)
625+
{
626+
if (aux_data || object_size)
627+
__fscache_update_cookie(cookie, aux_data, object_size);
628+
629+
if (atomic_dec_and_lock(&cookie->n_active, &cookie->lock)) {
630+
fscache_unuse_cookie_locked(cookie);
631+
spin_unlock(&cookie->lock);
632+
}
633+
}
634+
EXPORT_SYMBOL(__fscache_unuse_cookie);
635+
501636
/*
502637
* Perform work upon the cookie, such as committing its cache state,
503638
* relinquishing it or withdrawing the backing cache. We're protected from the
@@ -542,6 +677,12 @@ static void fscache_cookie_state_machine(struct fscache_cookie *cookie)
542677
fscache_prepare_to_write(cookie);
543678
spin_lock(&cookie->lock);
544679
}
680+
if (test_bit(FSCACHE_COOKIE_DO_LRU_DISCARD, &cookie->flags)) {
681+
__fscache_set_cookie_state(cookie,
682+
FSCACHE_COOKIE_STATE_LRU_DISCARDING);
683+
wake = true;
684+
goto again_locked;
685+
}
545686
fallthrough;
546687

547688
case FSCACHE_COOKIE_STATE_FAILED:
@@ -561,6 +702,7 @@ static void fscache_cookie_state_machine(struct fscache_cookie *cookie)
561702
}
562703
break;
563704

705+
case FSCACHE_COOKIE_STATE_LRU_DISCARDING:
564706
case FSCACHE_COOKIE_STATE_RELINQUISHING:
565707
case FSCACHE_COOKIE_STATE_WITHDRAWING:
566708
if (cookie->cache_priv) {
@@ -577,6 +719,9 @@ static void fscache_cookie_state_machine(struct fscache_cookie *cookie)
577719
FSCACHE_COOKIE_STATE_DROPPED);
578720
wake = true;
579721
goto out;
722+
case FSCACHE_COOKIE_STATE_LRU_DISCARDING:
723+
fscache_see_cookie(cookie, fscache_cookie_see_lru_discard);
724+
break;
580725
case FSCACHE_COOKIE_STATE_WITHDRAWING:
581726
fscache_see_cookie(cookie, fscache_cookie_see_withdraw);
582727
break;
@@ -639,6 +784,76 @@ static void __fscache_withdraw_cookie(struct fscache_cookie *cookie)
639784
fscache_queue_cookie(cookie, fscache_cookie_get_end_access);
640785
}
641786

787+
static void fscache_cookie_lru_do_one(struct fscache_cookie *cookie)
788+
{
789+
fscache_see_cookie(cookie, fscache_cookie_see_lru_do_one);
790+
791+
spin_lock(&cookie->lock);
792+
if (cookie->state != FSCACHE_COOKIE_STATE_ACTIVE ||
793+
time_before(jiffies, cookie->unused_at + fscache_lru_cookie_timeout) ||
794+
atomic_read(&cookie->n_active) > 0) {
795+
spin_unlock(&cookie->lock);
796+
fscache_stat(&fscache_n_cookies_lru_removed);
797+
} else {
798+
set_bit(FSCACHE_COOKIE_DO_LRU_DISCARD, &cookie->flags);
799+
spin_unlock(&cookie->lock);
800+
fscache_stat(&fscache_n_cookies_lru_expired);
801+
_debug("lru c=%x", cookie->debug_id);
802+
__fscache_withdraw_cookie(cookie);
803+
}
804+
805+
fscache_put_cookie(cookie, fscache_cookie_put_lru);
806+
}
807+
808+
static void fscache_cookie_lru_worker(struct work_struct *work)
809+
{
810+
struct fscache_cookie *cookie;
811+
unsigned long unused_at;
812+
813+
spin_lock(&fscache_cookie_lru_lock);
814+
815+
while (!list_empty(&fscache_cookie_lru)) {
816+
cookie = list_first_entry(&fscache_cookie_lru,
817+
struct fscache_cookie, commit_link);
818+
unused_at = cookie->unused_at + fscache_lru_cookie_timeout;
819+
if (time_before(jiffies, unused_at)) {
820+
timer_reduce(&fscache_cookie_lru_timer, unused_at);
821+
break;
822+
}
823+
824+
list_del_init(&cookie->commit_link);
825+
fscache_stat_d(&fscache_n_cookies_lru);
826+
spin_unlock(&fscache_cookie_lru_lock);
827+
fscache_cookie_lru_do_one(cookie);
828+
spin_lock(&fscache_cookie_lru_lock);
829+
}
830+
831+
spin_unlock(&fscache_cookie_lru_lock);
832+
}
833+
834+
static void fscache_cookie_lru_timed_out(struct timer_list *timer)
835+
{
836+
queue_work(fscache_wq, &fscache_cookie_lru_work);
837+
}
838+
839+
static void fscache_cookie_drop_from_lru(struct fscache_cookie *cookie)
840+
{
841+
bool need_put = false;
842+
843+
if (!list_empty(&cookie->commit_link)) {
844+
spin_lock(&fscache_cookie_lru_lock);
845+
if (!list_empty(&cookie->commit_link)) {
846+
list_del_init(&cookie->commit_link);
847+
fscache_stat_d(&fscache_n_cookies_lru);
848+
fscache_stat(&fscache_n_cookies_lru_dropped);
849+
need_put = true;
850+
}
851+
spin_unlock(&fscache_cookie_lru_lock);
852+
if (need_put)
853+
fscache_put_cookie(cookie, fscache_cookie_put_lru);
854+
}
855+
}
856+
642857
/*
643858
* Remove a cookie from the hash table.
644859
*/
@@ -659,6 +874,7 @@ static void fscache_unhash_cookie(struct fscache_cookie *cookie)
659874

660875
static void fscache_drop_withdraw_cookie(struct fscache_cookie *cookie)
661876
{
877+
fscache_cookie_drop_from_lru(cookie);
662878
__fscache_withdraw_cookie(cookie);
663879
}
664880

‎fs/fscache/internal.h

+5
Original file line numberDiff line numberDiff line change
@@ -57,6 +57,7 @@ static inline bool fscache_set_cache_state_maybe(struct fscache_cache *cache,
5757
*/
5858
extern struct kmem_cache *fscache_cookie_jar;
5959
extern const struct seq_operations fscache_cookies_seq_ops;
60+
extern struct timer_list fscache_cookie_lru_timer;
6061

6162
extern void fscache_print_cookie(struct fscache_cookie *cookie, char prefix);
6263
extern bool fscache_begin_cookie_access(struct fscache_cookie *cookie,
@@ -95,6 +96,10 @@ extern atomic_t fscache_n_volumes;
9596
extern atomic_t fscache_n_volumes_collision;
9697
extern atomic_t fscache_n_volumes_nomem;
9798
extern atomic_t fscache_n_cookies;
99+
extern atomic_t fscache_n_cookies_lru;
100+
extern atomic_t fscache_n_cookies_lru_expired;
101+
extern atomic_t fscache_n_cookies_lru_removed;
102+
extern atomic_t fscache_n_cookies_lru_dropped;
98103

99104
extern atomic_t fscache_n_acquires;
100105
extern atomic_t fscache_n_acquires_ok;

‎fs/fscache/stats.c

+12
Original file line numberDiff line numberDiff line change
@@ -17,6 +17,10 @@ atomic_t fscache_n_volumes;
1717
atomic_t fscache_n_volumes_collision;
1818
atomic_t fscache_n_volumes_nomem;
1919
atomic_t fscache_n_cookies;
20+
atomic_t fscache_n_cookies_lru;
21+
atomic_t fscache_n_cookies_lru_expired;
22+
atomic_t fscache_n_cookies_lru_removed;
23+
atomic_t fscache_n_cookies_lru_dropped;
2024

2125
atomic_t fscache_n_acquires;
2226
atomic_t fscache_n_acquires_ok;
@@ -47,6 +51,14 @@ int fscache_stats_show(struct seq_file *m, void *v)
4751
atomic_read(&fscache_n_acquires_ok),
4852
atomic_read(&fscache_n_acquires_oom));
4953

54+
seq_printf(m, "LRU : n=%u exp=%u rmv=%u drp=%u at=%ld\n",
55+
atomic_read(&fscache_n_cookies_lru),
56+
atomic_read(&fscache_n_cookies_lru_expired),
57+
atomic_read(&fscache_n_cookies_lru_removed),
58+
atomic_read(&fscache_n_cookies_lru_dropped),
59+
timer_pending(&fscache_cookie_lru_timer) ?
60+
fscache_cookie_lru_timer.expires - jiffies : 0);
61+
5062
seq_printf(m, "Updates: n=%u\n",
5163
atomic_read(&fscache_n_updates));
5264

0 commit comments

Comments
 (0)