Page MenuHomeFreeBSD
Differential D7538 Diff 42437 sys/cddl/contrib/opensolaris/uts/common/fs/zfs/arc.c

Changeset View

Standalone View

View Options

sys/cddl/contrib/opensolaris/uts/common/fs/zfs/arc.c

Context not available.
} }
} }
static long needfree = 0;
typedef enum free_memory_reason_t { typedef enum free_memory_reason_t {
FMR_UNKNOWN, FMR_UNKNOWN,
FMR_NEEDFREE, FMR_NEEDFREE,
Context not available.
*/ */
int64_t arc_swapfs_reserve = 64; int64_t arc_swapfs_reserve = 64;
typedef enum free_memory_measure_t {
FMM_EXCLUDE_ZONE_CACHE,
FMM_INCLUDE_ZONE_CACHE
} free_memory_measure_t;
/* /*
* Return the amount of memory that can be consumed before reclaim will be * Return the amount of memory that can be consumed before reclaim will be
* needed. Positive if there is sufficient free memory, negative indicates * needed. Positive if there is sufficient free memory, negative indicates
* the amount of memory that needs to be freed up. * the amount of memory that needs to be freed up.
*/ */
static int64_t arc_check_uma_cache(int64_t lowest);
static int64_t static int64_t
arc_available_memory(void) arc_available_memory(free_memory_measure_t zone_measure)
{ {
int64_t lowest = INT64_MAX; int64_t lowest = INT64_MAX;
int64_t n; int64_t n;
Context not available.
#ifdef _KERNEL #ifdef _KERNEL
#ifdef __FreeBSD__ #ifdef __FreeBSD__
/* if (needfree > 0) {
* Cooperate with pagedaemon when it's time for it to scan n = (int64_t)vm_cnt.v_free_target - (int64_t)vm_cnt.v_free_count;
sefUnsubmitted
Not Done
Inline Actions

needfree is a long, but n is int64_t.

sef: needfree is a long, but n is int64_t.
* and reclaim some pages. needfree = n > 0 ? n : 0;
*/ }
n = PAGESIZE * ((int64_t)freemem - zfs_arc_free_target); if (needfree > 0) {
if (n < lowest) { n = PAGESIZE * (-needfree);
lowest = n; if (n < lowest) {
r = FMR_LOTSFREE; lowest = n;
r = FMR_NEEDFREE;
}
} }
#else #else
Context not available.
} }
} }
/* Some memory can be in zone cache elements, for this case
* ARC cache not under memory pressure and can rise.
* zone_measure == FMM_INCLUDE_ZONE_CACHE flaged this
*/
if (lowest < 0 && zone_measure == FMM_INCLUDE_ZONE_CACHE) {
lowest = arc_check_uma_cache(lowest);
if (lowest >= 0)
r = FMR_UNKNOWN;
}
#else /* _KERNEL */ #else /* _KERNEL */
/* Every 100 calls, free a small amount */ /* Every 100 calls, free a small amount */
if (spa_get_random(100) == 0) if (spa_get_random(100) == 0)
Context not available.
static boolean_t static boolean_t
arc_reclaim_needed(void) arc_reclaim_needed(void)
{ {
return (arc_available_memory() < 0); return (arc_available_memory(FMM_INCLUDE_ZONE_CACHE) < 0);
} }
extern kmem_cache_t *zio_buf_cache[]; extern kmem_cache_t *zio_buf_cache[];
Context not available.
DTRACE_PROBE(arc__kmem_reap_end); DTRACE_PROBE(arc__kmem_reap_end);
} }
int sysctl_drain_cache = 1;
SYSCTL_INT(_vfs_zfs, OID_AUTO, drain_uma_cache, CTLFLAG_RW, &sysctl_drain_cache, 0, "drain per-CPU UMA cache");
#ifdef _KERNEL
static int64_t
arc_check_uma_cache(int64_t lowest)
{
int iter = 4;
int step = 1 << (SPA_MAXBLOCKSHIFT - SPA_MINBLOCKSHIFT - 3);
int n = (SPA_MAXBLOCKSIZE >> SPA_MINBLOCKSHIFT) - 1;
while (n >= 0) {
lowest += uma_zone_get_free_size(zio_data_buf_cache[n]->kc_zone);
if (lowest >= 0)
return lowest;
n -= step;
if(--iter == 0) {
if (step > 1) step >>= 1;
iter = 4;
}
}
lowest += uma_zone_get_free_size(abd_chunk_cache->kc_zone);
return lowest;
}
#endif
static void
arc_drain_uma_cache(uint64_t target)
{
int iter = 4;
int step = 1 << (SPA_MAXBLOCKSHIFT - SPA_MINBLOCKSHIFT - 3);
int n = (SPA_MAXBLOCKSIZE >> SPA_MINBLOCKSHIFT) - 1;
size_t free_size;
DTRACE_PROBE2(arc__drain_uma_cache_start, uint64_t, target, uint64_t, (uint64_t)vm_cnt.v_free_count * PAGESIZE);
#ifdef _KERNEL
free_size = (uint64_t)vm_cnt.v_free_count * PAGESIZE;
if (target <= free_size)
return;
while (n >= 0) {
free_size = uma_zone_get_free_size(zio_data_buf_cache[n]->kc_zone);
if (free_size) {
if (sysctl_drain_cache)
uma_reclaim_zone_cache(zio_data_buf_cache[n]->kc_zone);
kmem_cache_reap_soon(zio_data_buf_cache[n]);
DTRACE_PROBE3(arc__drain_uma_cache_zone, char *, zio_data_buf_cache[n]->kc_name, size_t, free_size, uint64_t, (uint64_t)vm_cnt.v_free_count * PAGESIZE);
free_size = (uint64_t)vm_cnt.v_free_count * PAGESIZE;
if (target <= free_size)
break;
}
n -= step;
if(--iter == 0) {
if (step > 1) step >>= 1;
iter = 4;
}
}
if (target > free_size)
kmem_cache_reap_soon(abd_chunk_cache);
#endif
DTRACE_PROBE(arc__drain_uma_cache_end);
}
/* /*
* Threads can block in arc_get_data_impl() waiting for this thread to evict * Threads can block in arc_get_data_impl() waiting for this thread to evict
* enough data and signal them to proceed. When this happens, the threads in * enough data and signal them to proceed. When this happens, the threads in
Context not available.
*/ */
evicted = arc_adjust(); evicted = arc_adjust();
int64_t free_memory = arc_available_memory(); int64_t free_memory = arc_available_memory(FMM_EXCLUDE_ZONE_CACHE);
DTRACE_PROBE2(arc__reclaim_adj, uint64_t, evicted, int64_t, free_memory);
if (free_memory < 0) { if (free_memory < 0) {
hrtime_t curtime = gethrtime(); hrtime_t curtime = gethrtime();
arc_no_grow = B_TRUE; arc_no_grow = B_TRUE;
Context not available.
* reaping caches, while we're near arc_c_min. * reaping caches, while we're near arc_c_min.
*/ */
if (curtime >= kmem_reap_time) { if (curtime >= kmem_reap_time) {
#ifdef _KERNEL
if (arc_check_uma_cache(free_memory) >= 0)
arc_drain_uma_cache((uint64_t)freemem * PAGESIZE - free_memory);
#else
arc_kmem_reap_now(); arc_kmem_reap_now();
#endif
kmem_reap_time = gethrtime() + kmem_reap_time = gethrtime() +
MSEC2NSEC(arc_kmem_cache_reap_retry_ms); MSEC2NSEC(arc_kmem_cache_reap_retry_ms);
} }
/* /*
* If we are still low on memory, shrink the ARC * If we are still low on memory, shrink the ARC
* so that we have arc_shrink_min free space. * so that we have arc_shrink_min free space.
*/ */
free_memory = arc_available_memory(); free_memory = arc_available_memory(FMM_EXCLUDE_ZONE_CACHE);
int64_t to_free = int64_t to_free =
(arc_c >> arc_shrink_shift) - free_memory; (arc_c >> arc_shrink_shift) - free_memory;
DTRACE_PROBE3(arc__reclaim_tst, int64_t, to_free, int64_t, free_memory, long, needfree);
if (to_free > 0) { if (to_free > 0) {
#ifdef _KERNEL #ifdef _KERNEL
#ifdef illumos
to_free = MAX(to_free, ptob(needfree)); to_free = MAX(to_free, ptob(needfree));
#endif uint64_t free_target =
(uint64_t)freemem * PAGESIZE - free_memory;
#endif #endif
arc_shrink(to_free); arc_shrink(to_free);
#ifdef _KERNEL
arc_drain_uma_cache(free_target);
#else
arc_kmem_reap_now();
#endif
DTRACE_PROBE(arc__reclaim_shr);
} }
} else if (free_memory < arc_c >> arc_no_grow_shift) { } else if (free_memory < arc_c >> arc_no_grow_shift) {
arc_no_grow = B_TRUE; arc_no_grow = B_TRUE;
Context not available.
static void static void
arc_lowmem(void *arg __unused, int howto __unused) arc_lowmem(void *arg __unused, int howto __unused)
{ {
int64_t n;
mutex_enter(&arc_reclaim_lock); mutex_enter(&arc_reclaim_lock);
DTRACE_PROBE1(arc__needfree, int64_t, ((int64_t)freemem - zfs_arc_free_target) * PAGESIZE); /* XXX: Memory deficit should be passed as argument. */
n = (int64_t)vm_cnt.v_free_target - (int64_t)vm_cnt.v_free_count;
needfree = (n>0) ? n : vm_cnt.v_free_target >> 8;
DTRACE_PROBE2(arc__needfree, int64_t, ((int64_t)freemem - zfs_arc_free_target) * PAGESIZE, int64_t, needfree);
cv_signal(&arc_reclaim_thread_cv); cv_signal(&arc_reclaim_thread_cv);
/*
* It is unsafe to block here in arbitrary threads, because we can come
* here from ARC itself and may hold ARC locks and thus risk a deadlock
* with ARC reclaim thread.
*/
if (curproc == pageproc)
(void) cv_wait(&arc_reclaim_waiters_cv, &arc_reclaim_lock);
mutex_exit(&arc_reclaim_lock); mutex_exit(&arc_reclaim_lock);
} }
#endif #endif
Context not available.