c/mirror_zfs
1
0
Fork 0
mirror of https://git.proxmox.com/git/mirror_zfs.git synced 2024-12-26 19:19:32 +03:00
Code Issues Packages Projects Releases Wiki Activity

Adjust ARC terminology

Browse Source 
The process of evicting data from the ARC is referred to as
`arc_adjust`.

This commit changes the term to `arc_evict`, which is more specific.

Reviewed-by: George Wilson <gwilson@delphix.com>
Reviewed-by: Brian Behlendorf <behlendorf1@llnl.gov>
Reviewed-by: George Melikov <mail@gmelikov.ru>
Signed-off-by: Matthew Ahrens <mahrens@delphix.com>
Closes #10592
This commit is contained in:
Matthew Ahrens 2020-07-22 09:51:47 -07:00 committed by GitHub
parent 317dbea173
commit 5dd92909c6
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
4 changed files with 97 additions and 97 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
include/sys/arc_impl.h
View File

@ -878,10 +878,10 @@ extern hrtime_t arc_growtime;
extern boolean_t arc_warm; extern boolean_t arc_warm;
extern int arc_grow_retry; extern int arc_grow_retry;
extern int arc_shrink_shift; extern int arc_shrink_shift;
extern zthr_t *arc_adjust_zthr; extern zthr_t *arc_evict_zthr;
extern kmutex_t arc_adjust_lock; extern kmutex_t arc_evict_lock;
extern kcondvar_t arc_adjust_waiters_cv; extern kcondvar_t arc_evict_waiters_cv;
extern boolean_t arc_adjust_needed; extern boolean_t arc_evict_needed;
extern kmutex_t arc_prune_mtx; extern kmutex_t arc_prune_mtx;
extern list_t arc_prune_list; extern list_t arc_prune_list;
extern aggsum_t arc_size; extern aggsum_t arc_size;

10
module/os/freebsd/zfs/arc_os.c
View File

@ -223,9 +223,9 @@ arc_lowmem(void *arg __unused, int howto __unused)
DTRACE_PROBE2(arc__needfree, int64_t, free_memory, int64_t, to_free); DTRACE_PROBE2(arc__needfree, int64_t, free_memory, int64_t, to_free);
arc_reduce_target_size(to_free); arc_reduce_target_size(to_free);
mutex_enter(&arc_adjust_lock); mutex_enter(&arc_evict_lock);
arc_adjust_needed = B_TRUE; arc_evict_needed = B_TRUE;
zthr_wakeup(arc_adjust_zthr); zthr_wakeup(arc_evict_zthr);
/* /*
* It is unsafe to block here in arbitrary threads, because we can come * It is unsafe to block here in arbitrary threads, because we can come
@ -233,8 +233,8 @@ arc_lowmem(void *arg __unused, int howto __unused)
* with ARC reclaim thread. * with ARC reclaim thread.
*/ */
if (curproc == pageproc) if (curproc == pageproc)
(void) cv_wait(&arc_adjust_waiters_cv, &arc_adjust_lock); (void) cv_wait(&arc_evict_waiters_cv, &arc_evict_lock);
mutex_exit(&arc_adjust_lock); mutex_exit(&arc_evict_lock);
} }
void void

20
module/os/linux/zfs/arc_os.c
View File

@ -194,12 +194,12 @@ arc_shrinker_scan(struct shrinker *shrink, struct shrink_control *sc)
return (SHRINK_STOP); return (SHRINK_STOP);
/* Reclaim in progress */ /* Reclaim in progress */
if (mutex_tryenter(&arc_adjust_lock) == 0) { if (mutex_tryenter(&arc_evict_lock) == 0) {
ARCSTAT_INCR(arcstat_need_free, ptob(sc->nr_to_scan)); ARCSTAT_INCR(arcstat_need_free, ptob(sc->nr_to_scan));
return (0); return (0);
} }
mutex_exit(&arc_adjust_lock); mutex_exit(&arc_evict_lock);
/* /*
* Evict the requested number of pages by shrinking arc_c the * Evict the requested number of pages by shrinking arc_c the
@ -213,17 +213,17 @@ arc_shrinker_scan(struct shrinker *shrink, struct shrink_control *sc)
* drastically, potentially all the way to arc_c_min. While * drastically, potentially all the way to arc_c_min. While
* arc_c is below arc_size, ZFS can't process read/write * arc_c is below arc_size, ZFS can't process read/write
* requests, because arc_get_data_impl() will block. To * requests, because arc_get_data_impl() will block. To
* ensure that arc_c doesn't shrink faster than the adjust * ensure that arc_c doesn't shrink faster than the evict
* thread can keep up, we wait for eviction here. * thread can keep up, we wait for eviction here.
*/ */
mutex_enter(&arc_adjust_lock); mutex_enter(&arc_evict_lock);
if (arc_is_overflowing()) { if (arc_is_overflowing()) {
arc_adjust_needed = B_TRUE; arc_evict_needed = B_TRUE;
zthr_wakeup(arc_adjust_zthr); zthr_wakeup(arc_evict_zthr);
(void) cv_wait(&arc_adjust_waiters_cv, (void) cv_wait(&arc_evict_waiters_cv,
&arc_adjust_lock); &arc_evict_lock);
} }
mutex_exit(&arc_adjust_lock); mutex_exit(&arc_evict_lock);
if (current_is_kswapd()) if (current_is_kswapd())
arc_kmem_reap_soon(); arc_kmem_reap_soon();
@ -232,7 +232,7 @@ arc_shrinker_scan(struct shrinker *shrink, struct shrink_control *sc)
/* /*
* We've shrunk what we can, wake up threads. * We've shrunk what we can, wake up threads.
*/ */
cv_broadcast(&arc_adjust_waiters_cv); cv_broadcast(&arc_evict_waiters_cv);
} else } else
pages = SHRINK_STOP; pages = SHRINK_STOP;

156
module/zfs/arc.c
View File

@ -317,13 +317,13 @@ static zthr_t *arc_reap_zthr;
/* /*
* This thread's job is to keep arc_size under arc_c, by calling * This thread's job is to keep arc_size under arc_c, by calling
* arc_adjust(), which improves arc_is_overflowing(). * arc_evict(), which improves arc_is_overflowing().
*/ */
zthr_t *arc_adjust_zthr; zthr_t *arc_evict_zthr;
kmutex_t arc_adjust_lock; kmutex_t arc_evict_lock;
kcondvar_t arc_adjust_waiters_cv; kcondvar_t arc_evict_waiters_cv;
boolean_t arc_adjust_needed = B_FALSE; boolean_t arc_evict_needed = B_FALSE;
/* /*
* The number of headers to evict in arc_evict_state_impl() before * The number of headers to evict in arc_evict_state_impl() before
@ -3954,13 +3954,13 @@ arc_evict_state_impl(multilist_t *ml, int idx, arc_buf_hdr_t *marker,
* *
* If threads are left sleeping, due to not * If threads are left sleeping, due to not
* using cv_broadcast here, they will be woken * using cv_broadcast here, they will be woken
* up via cv_broadcast in arc_adjust_cb() just * up via cv_broadcast in arc_evict_cb() just
* before arc_adjust_zthr sleeps. * before arc_evict_zthr sleeps.
*/ */
mutex_enter(&arc_adjust_lock); mutex_enter(&arc_evict_lock);
if (!arc_is_overflowing()) if (!arc_is_overflowing())
cv_signal(&arc_adjust_waiters_cv); cv_signal(&arc_evict_waiters_cv);
mutex_exit(&arc_adjust_lock); mutex_exit(&arc_evict_lock);
} else { } else {
ARCSTAT_BUMP(arcstat_mutex_miss); ARCSTAT_BUMP(arcstat_mutex_miss);
} }
@ -4021,7 +4021,7 @@ arc_evict_state(arc_state_t *state, uint64_t spa, int64_t bytes,
/* /*
* A b_spa of 0 is used to indicate that this header is * A b_spa of 0 is used to indicate that this header is
* a marker. This fact is used in arc_adjust_type() and * a marker. This fact is used in arc_evict_type() and
* arc_evict_state_impl(). * arc_evict_state_impl().
*/ */
markers[i]->b_spa = 0; markers[i]->b_spa = 0;
@ -4156,7 +4156,7 @@ arc_flush_state(arc_state_t *state, uint64_t spa, arc_buf_contents_t type,
* evict everything it can, when passed a negative value for "bytes". * evict everything it can, when passed a negative value for "bytes".
*/ */
static uint64_t static uint64_t
arc_adjust_impl(arc_state_t *state, uint64_t spa, int64_t bytes, arc_evict_impl(arc_state_t *state, uint64_t spa, int64_t bytes,
arc_buf_contents_t type) arc_buf_contents_t type)
{ {
int64_t delta; int64_t delta;
@ -4188,7 +4188,7 @@ arc_adjust_impl(arc_state_t *state, uint64_t spa, int64_t bytes,
* available for reclaim. * available for reclaim.
*/ */
static uint64_t static uint64_t
arc_adjust_meta_balanced(uint64_t meta_used) arc_evict_meta_balanced(uint64_t meta_used)
{ {
int64_t delta, prune = 0, adjustmnt; int64_t delta, prune = 0, adjustmnt;
uint64_t total_evicted = 0; uint64_t total_evicted = 0;
@ -4198,7 +4198,7 @@ arc_adjust_meta_balanced(uint64_t meta_used)
restart: restart:
/* /*
* This slightly differs than the way we evict from the mru in * This slightly differs than the way we evict from the mru in
* arc_adjust because we don't have a "target" value (i.e. no * arc_evict because we don't have a "target" value (i.e. no
* "meta" arc_p). As a result, I think we can completely * "meta" arc_p). As a result, I think we can completely
* cannibalize the metadata in the MRU before we evict the * cannibalize the metadata in the MRU before we evict the
* metadata from the MFU. I think we probably need to implement a * metadata from the MFU. I think we probably need to implement a
@ -4210,7 +4210,7 @@ restart:
zfs_refcount_count(&arc_mru->arcs_esize[type]) > 0) { zfs_refcount_count(&arc_mru->arcs_esize[type]) > 0) {
delta = MIN(zfs_refcount_count(&arc_mru->arcs_esize[type]), delta = MIN(zfs_refcount_count(&arc_mru->arcs_esize[type]),
adjustmnt); adjustmnt);
total_evicted += arc_adjust_impl(arc_mru, 0, delta, type); total_evicted += arc_evict_impl(arc_mru, 0, delta, type);
adjustmnt -= delta; adjustmnt -= delta;
} }
@ -4228,7 +4228,7 @@ restart:
zfs_refcount_count(&arc_mfu->arcs_esize[type]) > 0) { zfs_refcount_count(&arc_mfu->arcs_esize[type]) > 0) {
delta = MIN(zfs_refcount_count(&arc_mfu->arcs_esize[type]), delta = MIN(zfs_refcount_count(&arc_mfu->arcs_esize[type]),
adjustmnt); adjustmnt);
total_evicted += arc_adjust_impl(arc_mfu, 0, delta, type); total_evicted += arc_evict_impl(arc_mfu, 0, delta, type);
} }
adjustmnt = meta_used - arc_meta_limit; adjustmnt = meta_used - arc_meta_limit;
@ -4237,7 +4237,7 @@ restart:
zfs_refcount_count(&arc_mru_ghost->arcs_esize[type]) > 0) { zfs_refcount_count(&arc_mru_ghost->arcs_esize[type]) > 0) {
delta = MIN(adjustmnt, delta = MIN(adjustmnt,
zfs_refcount_count(&arc_mru_ghost->arcs_esize[type])); zfs_refcount_count(&arc_mru_ghost->arcs_esize[type]));
total_evicted += arc_adjust_impl(arc_mru_ghost, 0, delta, type); total_evicted += arc_evict_impl(arc_mru_ghost, 0, delta, type);
adjustmnt -= delta; adjustmnt -= delta;
} }
@ -4245,7 +4245,7 @@ restart:
zfs_refcount_count(&arc_mfu_ghost->arcs_esize[type]) > 0) { zfs_refcount_count(&arc_mfu_ghost->arcs_esize[type]) > 0) {
delta = MIN(adjustmnt, delta = MIN(adjustmnt,
zfs_refcount_count(&arc_mfu_ghost->arcs_esize[type])); zfs_refcount_count(&arc_mfu_ghost->arcs_esize[type]));
total_evicted += arc_adjust_impl(arc_mfu_ghost, 0, delta, type); total_evicted += arc_evict_impl(arc_mfu_ghost, 0, delta, type);
} }
/* /*
@ -4280,7 +4280,7 @@ restart:
* capped by the arc_meta_limit tunable. * capped by the arc_meta_limit tunable.
*/ */
static uint64_t static uint64_t
arc_adjust_meta_only(uint64_t meta_used) arc_evict_meta_only(uint64_t meta_used)
{ {
uint64_t total_evicted = 0; uint64_t total_evicted = 0;
int64_t target; int64_t target;
@ -4296,7 +4296,7 @@ arc_adjust_meta_only(uint64_t meta_used)
(int64_t)(zfs_refcount_count(&arc_anon->arcs_size) + (int64_t)(zfs_refcount_count(&arc_anon->arcs_size) +
zfs_refcount_count(&arc_mru->arcs_size) - arc_p)); zfs_refcount_count(&arc_mru->arcs_size) - arc_p));
total_evicted += arc_adjust_impl(arc_mru, 0, target, ARC_BUFC_METADATA); total_evicted += arc_evict_impl(arc_mru, 0, target, ARC_BUFC_METADATA);
/* /*
* Similar to the above, we want to evict enough bytes to get us * Similar to the above, we want to evict enough bytes to get us
@ -4307,18 +4307,18 @@ arc_adjust_meta_only(uint64_t meta_used)
(int64_t)(zfs_refcount_count(&arc_mfu->arcs_size) - (int64_t)(zfs_refcount_count(&arc_mfu->arcs_size) -
(arc_c - arc_p))); (arc_c - arc_p)));
total_evicted += arc_adjust_impl(arc_mfu, 0, target, ARC_BUFC_METADATA); total_evicted += arc_evict_impl(arc_mfu, 0, target, ARC_BUFC_METADATA);
return (total_evicted); return (total_evicted);
} }
static uint64_t static uint64_t
arc_adjust_meta(uint64_t meta_used) arc_evict_meta(uint64_t meta_used)
{ {
if (zfs_arc_meta_strategy == ARC_STRATEGY_META_ONLY) if (zfs_arc_meta_strategy == ARC_STRATEGY_META_ONLY)
return (arc_adjust_meta_only(meta_used)); return (arc_evict_meta_only(meta_used));
else else
return (arc_adjust_meta_balanced(meta_used)); return (arc_evict_meta_balanced(meta_used));
} }
/* /*
@ -4330,7 +4330,7 @@ arc_adjust_meta(uint64_t meta_used)
* returned. * returned.
*/ */
static arc_buf_contents_t static arc_buf_contents_t
arc_adjust_type(arc_state_t *state) arc_evict_type(arc_state_t *state)
{ {
multilist_t *data_ml = state->arcs_list[ARC_BUFC_DATA]; multilist_t *data_ml = state->arcs_list[ARC_BUFC_DATA];
multilist_t *meta_ml = state->arcs_list[ARC_BUFC_METADATA]; multilist_t *meta_ml = state->arcs_list[ARC_BUFC_METADATA];
@ -4400,7 +4400,7 @@ arc_adjust_type(arc_state_t *state)
* Evict buffers from the cache, such that arc_size is capped by arc_c. * Evict buffers from the cache, such that arc_size is capped by arc_c.
*/ */
static uint64_t static uint64_t
arc_adjust(void) arc_evict(void)
{ {
uint64_t total_evicted = 0; uint64_t total_evicted = 0;
uint64_t bytes; uint64_t bytes;
@ -4412,7 +4412,7 @@ arc_adjust(void)
* If we're over arc_meta_limit, we want to correct that before * If we're over arc_meta_limit, we want to correct that before
* potentially evicting data buffers below. * potentially evicting data buffers below.
*/ */
total_evicted += arc_adjust_meta(ameta); total_evicted += arc_evict_meta(ameta);
/* /*
* Adjust MRU size * Adjust MRU size
@ -4436,9 +4436,9 @@ arc_adjust(void)
* type. If we cannot satisfy the number of bytes from this * type. If we cannot satisfy the number of bytes from this
* type, spill over into the next type. * type, spill over into the next type.
*/ */
if (arc_adjust_type(arc_mru) == ARC_BUFC_METADATA && if (arc_evict_type(arc_mru) == ARC_BUFC_METADATA &&
ameta > arc_meta_min) { ameta > arc_meta_min) {
bytes = arc_adjust_impl(arc_mru, 0, target, ARC_BUFC_METADATA); bytes = arc_evict_impl(arc_mru, 0, target, ARC_BUFC_METADATA);
total_evicted += bytes; total_evicted += bytes;
/* /*
@ -4448,9 +4448,9 @@ arc_adjust(void)
target -= bytes; target -= bytes;
total_evicted += total_evicted +=
arc_adjust_impl(arc_mru, 0, target, ARC_BUFC_DATA); arc_evict_impl(arc_mru, 0, target, ARC_BUFC_DATA);
} else { } else {
bytes = arc_adjust_impl(arc_mru, 0, target, ARC_BUFC_DATA); bytes = arc_evict_impl(arc_mru, 0, target, ARC_BUFC_DATA);
total_evicted += bytes; total_evicted += bytes;
/* /*
@ -4460,7 +4460,7 @@ arc_adjust(void)
target -= bytes; target -= bytes;
total_evicted += total_evicted +=
arc_adjust_impl(arc_mru, 0, target, ARC_BUFC_METADATA); arc_evict_impl(arc_mru, 0, target, ARC_BUFC_METADATA);
} }
/* /*
@ -4479,9 +4479,9 @@ arc_adjust(void)
*/ */
target = asize - arc_c; target = asize - arc_c;
if (arc_adjust_type(arc_mfu) == ARC_BUFC_METADATA && if (arc_evict_type(arc_mfu) == ARC_BUFC_METADATA &&
ameta > arc_meta_min) { ameta > arc_meta_min) {
bytes = arc_adjust_impl(arc_mfu, 0, target, ARC_BUFC_METADATA); bytes = arc_evict_impl(arc_mfu, 0, target, ARC_BUFC_METADATA);
total_evicted += bytes; total_evicted += bytes;
/* /*
@ -4491,9 +4491,9 @@ arc_adjust(void)
target -= bytes; target -= bytes;
total_evicted += total_evicted +=
arc_adjust_impl(arc_mfu, 0, target, ARC_BUFC_DATA); arc_evict_impl(arc_mfu, 0, target, ARC_BUFC_DATA);
} else { } else {
bytes = arc_adjust_impl(arc_mfu, 0, target, ARC_BUFC_DATA); bytes = arc_evict_impl(arc_mfu, 0, target, ARC_BUFC_DATA);
total_evicted += bytes; total_evicted += bytes;
/* /*
@ -4503,7 +4503,7 @@ arc_adjust(void)
target -= bytes; target -= bytes;
total_evicted += total_evicted +=
arc_adjust_impl(arc_mfu, 0, target, ARC_BUFC_METADATA); arc_evict_impl(arc_mfu, 0, target, ARC_BUFC_METADATA);
} }
/* /*
@ -4520,13 +4520,13 @@ arc_adjust(void)
target = zfs_refcount_count(&arc_mru->arcs_size) + target = zfs_refcount_count(&arc_mru->arcs_size) +
zfs_refcount_count(&arc_mru_ghost->arcs_size) - arc_c; zfs_refcount_count(&arc_mru_ghost->arcs_size) - arc_c;
bytes = arc_adjust_impl(arc_mru_ghost, 0, target, ARC_BUFC_DATA); bytes = arc_evict_impl(arc_mru_ghost, 0, target, ARC_BUFC_DATA);
total_evicted += bytes; total_evicted += bytes;
target -= bytes; target -= bytes;
total_evicted += total_evicted +=
arc_adjust_impl(arc_mru_ghost, 0, target, ARC_BUFC_METADATA); arc_evict_impl(arc_mru_ghost, 0, target, ARC_BUFC_METADATA);
/* /*
* We assume the sum of the mru list and mfu list is less than * We assume the sum of the mru list and mfu list is less than
@ -4539,13 +4539,13 @@ arc_adjust(void)
target = zfs_refcount_count(&arc_mru_ghost->arcs_size) + target = zfs_refcount_count(&arc_mru_ghost->arcs_size) +
zfs_refcount_count(&arc_mfu_ghost->arcs_size) - arc_c; zfs_refcount_count(&arc_mfu_ghost->arcs_size) - arc_c;
bytes = arc_adjust_impl(arc_mfu_ghost, 0, target, ARC_BUFC_DATA); bytes = arc_evict_impl(arc_mfu_ghost, 0, target, ARC_BUFC_DATA);
total_evicted += bytes; total_evicted += bytes;
target -= bytes; target -= bytes;
total_evicted += total_evicted +=
arc_adjust_impl(arc_mfu_ghost, 0, target, ARC_BUFC_METADATA); arc_evict_impl(arc_mfu_ghost, 0, target, ARC_BUFC_METADATA);
return (total_evicted); return (total_evicted);
} }
@ -4596,11 +4596,11 @@ arc_reduce_target_size(int64_t to_free)
} }
if (asize > arc_c) { if (asize > arc_c) {
/* See comment in arc_adjust_cb_check() on why lock+flag */ /* See comment in arc_evict_cb_check() on why lock+flag */
mutex_enter(&arc_adjust_lock); mutex_enter(&arc_evict_lock);
arc_adjust_needed = B_TRUE; arc_evict_needed = B_TRUE;
mutex_exit(&arc_adjust_lock); mutex_exit(&arc_evict_lock);
zthr_wakeup(arc_adjust_zthr); zthr_wakeup(arc_evict_zthr);
} }
} }
@ -4665,7 +4665,7 @@ arc_kmem_reap_soon(void)
/* ARGSUSED */ /* ARGSUSED */
static boolean_t static boolean_t
arc_adjust_cb_check(void *arg, zthr_t *zthr) arc_evict_cb_check(void *arg, zthr_t *zthr)
{ {
/* /*
* This is necessary so that any changes which may have been made to * This is necessary so that any changes which may have been made to
@ -4684,7 +4684,7 @@ arc_adjust_cb_check(void *arg, zthr_t *zthr)
* this call, these commands may show stale stats for the * this call, these commands may show stale stats for the
* anon, mru, mru_ghost, mfu, and mfu_ghost lists. Even * anon, mru, mru_ghost, mfu, and mfu_ghost lists. Even
* with this change, the data might be up to 1 second * with this change, the data might be up to 1 second
* out of date(the arc_adjust_zthr has a maximum sleep * out of date(the arc_evict_zthr has a maximum sleep
* time of 1 second); but that should suffice. The * time of 1 second); but that should suffice. The
* arc_state_t structures can be queried directly if more * arc_state_t structures can be queried directly if more
* accurate information is needed. * accurate information is needed.
@ -4693,60 +4693,60 @@ arc_adjust_cb_check(void *arg, zthr_t *zthr)
arc_ksp->ks_update(arc_ksp, KSTAT_READ); arc_ksp->ks_update(arc_ksp, KSTAT_READ);
/* /*
* We have to rely on arc_get_data_impl() to tell us when to adjust, * We have to rely on arc_get_data_impl() to tell us when to evict,
* rather than checking if we are overflowing here, so that we are * rather than checking if we are overflowing here, so that we are
* sure to not leave arc_get_data_impl() waiting on * sure to not leave arc_get_data_impl() waiting on
* arc_adjust_waiters_cv. If we have become "not overflowing" since * arc_evict_waiters_cv. If we have become "not overflowing" since
* arc_get_data_impl() checked, we need to wake it up. We could * arc_get_data_impl() checked, we need to wake it up. We could
* broadcast the CV here, but arc_get_data_impl() may have not yet * broadcast the CV here, but arc_get_data_impl() may have not yet
* gone to sleep. We would need to use a mutex to ensure that this * gone to sleep. We would need to use a mutex to ensure that this
* function doesn't broadcast until arc_get_data_impl() has gone to * function doesn't broadcast until arc_get_data_impl() has gone to
* sleep (e.g. the arc_adjust_lock). However, the lock ordering of * sleep (e.g. the arc_evict_lock). However, the lock ordering of
* such a lock would necessarily be incorrect with respect to the * such a lock would necessarily be incorrect with respect to the
* zthr_lock, which is held before this function is called, and is * zthr_lock, which is held before this function is called, and is
* held by arc_get_data_impl() when it calls zthr_wakeup(). * held by arc_get_data_impl() when it calls zthr_wakeup().
*/ */
return (arc_adjust_needed); return (arc_evict_needed);
} }
/* /*
* Keep arc_size under arc_c by running arc_adjust which evicts data * Keep arc_size under arc_c by running arc_evict which evicts data
* from the ARC. * from the ARC.
*/ */
/* ARGSUSED */ /* ARGSUSED */
static void static void
arc_adjust_cb(void *arg, zthr_t *zthr) arc_evict_cb(void *arg, zthr_t *zthr)
{ {
uint64_t evicted = 0; uint64_t evicted = 0;
fstrans_cookie_t cookie = spl_fstrans_mark(); fstrans_cookie_t cookie = spl_fstrans_mark();
/* Evict from cache */ /* Evict from cache */
evicted = arc_adjust(); evicted = arc_evict();
/* /*
* If evicted is zero, we couldn't evict anything * If evicted is zero, we couldn't evict anything
* via arc_adjust(). This could be due to hash lock * via arc_evict(). This could be due to hash lock
* collisions, but more likely due to the majority of * collisions, but more likely due to the majority of
* arc buffers being unevictable. Therefore, even if * arc buffers being unevictable. Therefore, even if
* arc_size is above arc_c, another pass is unlikely to * arc_size is above arc_c, another pass is unlikely to
* be helpful and could potentially cause us to enter an * be helpful and could potentially cause us to enter an
* infinite loop. Additionally, zthr_iscancelled() is * infinite loop. Additionally, zthr_iscancelled() is
* checked here so that if the arc is shutting down, the * checked here so that if the arc is shutting down, the
* broadcast will wake any remaining arc adjust waiters. * broadcast will wake any remaining arc evict waiters.
*/ */
mutex_enter(&arc_adjust_lock); mutex_enter(&arc_evict_lock);
arc_adjust_needed = !zthr_iscancelled(arc_adjust_zthr) && arc_evict_needed = !zthr_iscancelled(arc_evict_zthr) &&
evicted > 0 && aggsum_compare(&arc_size, arc_c) > 0; evicted > 0 && aggsum_compare(&arc_size, arc_c) > 0;
if (!arc_adjust_needed) { if (!arc_evict_needed) {
/* /*
* We're either no longer overflowing, or we * We're either no longer overflowing, or we
* can't evict anything more, so we should wake * can't evict anything more, so we should wake
* arc_get_data_impl() sooner. * arc_get_data_impl() sooner.
*/ */
cv_broadcast(&arc_adjust_waiters_cv); cv_broadcast(&arc_evict_waiters_cv);
arc_need_free = 0; arc_need_free = 0;
} }
mutex_exit(&arc_adjust_lock); mutex_exit(&arc_evict_lock);
spl_fstrans_unmark(cookie); spl_fstrans_unmark(cookie);
} }
@ -4785,7 +4785,7 @@ arc_reap_cb_check(void *arg, zthr_t *zthr)
/* /*
* Keep enough free memory in the system by reaping the ARC's kmem * Keep enough free memory in the system by reaping the ARC's kmem
* caches. To cause more slabs to be reapable, we may reduce the * caches. To cause more slabs to be reapable, we may reduce the
* target size of the cache (arc_c), causing the arc_adjust_cb() * target size of the cache (arc_c), causing the arc_evict_cb()
* to free more buffers. * to free more buffers.
*/ */
/* ARGSUSED */ /* ARGSUSED */
@ -5036,7 +5036,7 @@ arc_get_data_impl(arc_buf_hdr_t *hdr, uint64_t size, void *tag)
* overflowing; thus we don't use a while loop here. * overflowing; thus we don't use a while loop here.
*/ */
if (arc_is_overflowing()) { if (arc_is_overflowing()) {
mutex_enter(&arc_adjust_lock); mutex_enter(&arc_evict_lock);
/* /*
* Now that we've acquired the lock, we may no longer be * Now that we've acquired the lock, we may no longer be
@ -5050,12 +5050,12 @@ arc_get_data_impl(arc_buf_hdr_t *hdr, uint64_t size, void *tag)
* shouldn't cause any harm. * shouldn't cause any harm.
*/ */
if (arc_is_overflowing()) { if (arc_is_overflowing()) {
arc_adjust_needed = B_TRUE; arc_evict_needed = B_TRUE;
zthr_wakeup(arc_adjust_zthr); zthr_wakeup(arc_evict_zthr);
(void) cv_wait(&arc_adjust_waiters_cv, (void) cv_wait(&arc_evict_waiters_cv,
&arc_adjust_lock); &arc_evict_lock);
} }
mutex_exit(&arc_adjust_lock); mutex_exit(&arc_evict_lock);
} }
VERIFY3U(hdr->b_type, ==, type); VERIFY3U(hdr->b_type, ==, type);
@ -7268,8 +7268,8 @@ void
arc_init(void) arc_init(void)
{ {
uint64_t percent, allmem = arc_all_memory(); uint64_t percent, allmem = arc_all_memory();
mutex_init(&arc_adjust_lock, NULL, MUTEX_DEFAULT, NULL); mutex_init(&arc_evict_lock, NULL, MUTEX_DEFAULT, NULL);
cv_init(&arc_adjust_waiters_cv, NULL, CV_DEFAULT, NULL); cv_init(&arc_evict_waiters_cv, NULL, CV_DEFAULT, NULL);
arc_min_prefetch_ms = 1000; arc_min_prefetch_ms = 1000;
arc_min_prescient_prefetch_ms = 6000; arc_min_prescient_prefetch_ms = 6000;
@ -7339,8 +7339,8 @@ arc_init(void)
kstat_install(arc_ksp); kstat_install(arc_ksp);
} }
arc_adjust_zthr = zthr_create_timer(arc_adjust_cb_check, arc_evict_zthr = zthr_create_timer(arc_evict_cb_check,
arc_adjust_cb, NULL, SEC2NSEC(1)); arc_evict_cb, NULL, SEC2NSEC(1));
arc_reap_zthr = zthr_create_timer(arc_reap_cb_check, arc_reap_zthr = zthr_create_timer(arc_reap_cb_check,
arc_reap_cb, NULL, SEC2NSEC(1)); arc_reap_cb, NULL, SEC2NSEC(1));
@ -7398,11 +7398,11 @@ arc_fini(void)
list_destroy(&arc_prune_list); list_destroy(&arc_prune_list);
mutex_destroy(&arc_prune_mtx); mutex_destroy(&arc_prune_mtx);
(void) zthr_cancel(arc_adjust_zthr); (void) zthr_cancel(arc_evict_zthr);
(void) zthr_cancel(arc_reap_zthr); (void) zthr_cancel(arc_reap_zthr);
mutex_destroy(&arc_adjust_lock); mutex_destroy(&arc_evict_lock);
cv_destroy(&arc_adjust_waiters_cv); cv_destroy(&arc_evict_waiters_cv);
/* /*
* buf_fini() must proceed arc_state_fini() because buf_fin() may * buf_fini() must proceed arc_state_fini() because buf_fin() may
@ -7417,7 +7417,7 @@ arc_fini(void)
* torn down to avoid the case of them receiving any * torn down to avoid the case of them receiving any
* wakeup() signals after they are destroyed. * wakeup() signals after they are destroyed.
*/ */
zthr_destroy(arc_adjust_zthr); zthr_destroy(arc_evict_zthr);
zthr_destroy(arc_reap_zthr); zthr_destroy(arc_reap_zthr);
ASSERT0(arc_loaned_bytes); ASSERT0(arc_loaned_bytes);
@ -10273,7 +10273,7 @@ ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, meta_prune, INT, ZMOD_RW,
"Meta objects to scan for prune"); "Meta objects to scan for prune");
ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, meta_adjust_restarts, INT, ZMOD_RW, ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, meta_adjust_restarts, INT, ZMOD_RW,
"Limit number of restarts in arc_adjust_meta"); "Limit number of restarts in arc_evict_meta");
ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, meta_strategy, INT, ZMOD_RW, ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, meta_strategy, INT, ZMOD_RW,
"Meta reclaim strategy"); "Meta reclaim strategy");