Differential D7538 Diff 25879 sys/cddl/contrib/opensolaris/uts/common/fs/zfs/arc.c

Changeset View

Standalone View

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

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
Context not available.
	* the amount of memory that needs to be freed up.	* the amount of memory that needs to be freed up.
	*/	*/
	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.
	}	}
	}	}

		/* 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) {
		kmem_cache_t *prev_data_cache = NULL;
		extern kmem_cache_t *zio_data_buf_cache[];

		for (n = (SPA_MAXBLOCKSIZE >> SPA_MINBLOCKSHIFT) - 1; n >= 0; n--) {
		if (zio_data_buf_cache[n] == prev_data_cache)
		continue;
		prev_data_cache = zio_data_buf_cache[n];
		lowest += uma_zone_get_free_size(zio_data_buf_cache[n]->kc_zone);
		if (lowest >= 0) {
		r = FMR_UNKNOWN;
		break;
		}
		}
		}

	#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.
	extern kmem_cache_t *zio_data_buf_cache[];	extern kmem_cache_t *zio_data_buf_cache[];
	extern kmem_cache_t *range_seg_cache;	extern kmem_cache_t *range_seg_cache;

		static void
		arc_drain_uma_cache(uint64_t target)
		{
		int i;
		kmem_cache_t *prev_data_cache = NULL;

		DTRACE_PROBE(arc__drain_uma_cache_start);
		#ifdef _KERNEL
		for (i = (SPA_MAXBLOCKSIZE >> SPA_MINBLOCKSHIFT) - 1; i >= 0; i--) {
		if(zio_data_buf_cache[i] == prev_data_cache)
		continue;
		prev_data_cache = zio_data_buf_cache[i];
		if(uma_zone_get_free_size(zio_data_buf_cache[i]->kc_zone) == 0)
		continue;
		uma_reclaim_zone_cache(zio_data_buf_cache[i]->kc_zone);
		if((uint64_t)vm_cnt.v_free_count * PAGESIZE >= target)
		return;
		}
		#endif
		DTRACE_PROBE(arc__drain_uma_cache_end);
		}

	static __noinline void	static __noinline void
	arc_kmem_reap_now(void)	arc_kmem_reap_now(void)
	{	{
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);
	if (free_memory < 0) {	if (free_memory < 0) {
		uint64_t free_target =
		(uint64_t)freemem * PAGESIZE - free_memory;

	arc_no_grow = B_TRUE;	arc_no_grow = B_TRUE;
	arc_warm = B_TRUE;	arc_warm = B_TRUE;
Context not available.
	*/	*/
	growtime = gethrtime() + SEC2NSEC(arc_grow_retry);	growtime = gethrtime() + SEC2NSEC(arc_grow_retry);

		arc_drain_uma_cache(free_target);
	arc_kmem_reap_now();	arc_kmem_reap_now();

	/*	/*
Context not available.
	* 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;
Context not available.
	to_free = MAX(to_free, ptob(needfree));	to_free = MAX(to_free, ptob(needfree));
	#endif	#endif
	arc_shrink(to_free);	arc_shrink(to_free);
		arc_drain_uma_cache(free_target);
		arc_kmem_reap_now();
	}	}
	} 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;
		sefUnsubmitted Not Done Inline Actions needfree is a long, but n is int64_t. sef: needfree is a long, but n is int64_t.
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);
	/* XXX: Memory deficit should be passed as argument. */	/* XXX: Memory deficit should be passed as argument. */
	needfree = btoc(arc_c >> arc_shrink_shift);	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_PROBE(arc__needfree);	DTRACE_PROBE(arc__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.