Attachment #146423 for bug #187594

View | Details | Raw Unified | Return to bug 187594 | Differences between

and this patch




}
SYSINIT(kmem_size_init, SI_SUB_KMEM, SI_ORDER_ANY, kmem_size_init, NULL);

/*
 * The return values from kmem_free_* are only valid once the pagedaemon
 * has been initialised, before then they return 0.
 * 
 * To ensure the returns are valid the caller can use a SYSINIT with
 * subsystem set to SI_SUB_KTHREAD_PAGE and an order of at least
 * SI_ORDER_SECOND.
 */
u_int
kmem_free_target(void)
{

	return (vm_cnt.v_free_target);
}

u_int
kmem_free_min(void)
{

	return (vm_cnt.v_free_min);
}

u_int
kmem_free_count(void)
{

	return (vm_cnt.v_free_count);
}

u_int
kmem_page_count(void)
{

	return (vm_cnt.v_page_count);
}

uint64_t
kmem_size(void)
{

	return (kmem_size_val);
}

static int




void *zfs_kmem_alloc(size_t size, int kmflags);
void zfs_kmem_free(void *buf, size_t size);
uint64_t kmem_size(void);
u_int kmem_page_count(void);

/*
 * The return values from kmem_free_* are only valid once the pagedaemon
 * has been initialised, before then they return 0.
 */
u_int kmem_free_count(void);
u_int kmem_free_target(void);
u_int kmem_free_min(void);

kmem_cache_t *kmem_cache_create(char *name, size_t bufsize, size_t align,
    int (*constructor)(void *, void *, int), void (*destructor)(void *, void *),
    void (*reclaim)(void *) __unused, void *private, vmem_t *vmp, int cflags);




 */
static boolean_t arc_warm;

/*
 * These tunables are for performance analysis.
 */
uint64_t zfs_arc_max;
uint64_t zfs_arc_min;
uint64_t zfs_arc_meta_limit = 0;

int zfs_arc_p_min_shift = 0;
int zfs_disable_dup_eviction = 0;
uint64_t zfs_arc_average_blocksize = 8 * 1024; /* 8KB */
u_int zfs_arc_free_target = (1 << 19); /* default before pagedaemon init only */

static int sysctl_vfs_zfs_arc_free_target(SYSCTL_HANDLER_ARGS);

#ifdef _KERNEL
static void
arc_free_target_init(void *unused __unused)
{

	zfs_arc_free_target = kmem_free_target();
}
SYSINIT(arc_free_target_init, SI_SUB_KTHREAD_PAGE, SI_ORDER_ANY,
    arc_free_target_init, NULL);
#endif

TUNABLE_QUAD("vfs.zfs.arc_meta_limit", &zfs_arc_meta_limit);
SYSCTL_DECL(_vfs_zfs);
SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, arc_max, CTLFLAG_RDTUN, &zfs_arc_max, 0,

SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, arc_average_blocksize, CTLFLAG_RDTUN,
    &zfs_arc_average_blocksize, 0,
    "ARC average blocksize");
/*
 * We don't have a tunable for arc_free_target due to the dependency on
 * pagedaemon initialisation.
 */
SYSCTL_PROC(_vfs_zfs, OID_AUTO, arc_free_target,
    CTLTYPE_UINT | CTLFLAG_MPSAFE | CTLFLAG_RW, 0, sizeof(u_int),
    sysctl_vfs_zfs_arc_free_target, "IU",
    "Desired number of free pages below which ARC triggers reclaim");

static int
sysctl_vfs_zfs_arc_free_target(SYSCTL_HANDLER_ARGS)
{
	u_int val;
	int err;

	val = zfs_arc_free_target;
	err = sysctl_handle_int(oidp, &val, 0, req);
	if (err != 0 || req->newptr == NULL)
		return (err);

	if (val < kmem_free_min())
		return (EINVAL);
	if (val > kmem_page_count())
		return (EINVAL);

	zfs_arc_free_target = val;

	return (0);
}

/*
 * Note that buffers can be in one of 6 states:
 *	ARC_anon	- anonymous (discussed below)

void
arc_shrink(void)
{

	if (arc_c > arc_c_min) {
		uint64_t to_free;

		DTRACE_PROBE2(arc__shrink, uint64_t, arc_c, uint64_t,
			arc_c_min);
#ifdef _KERNEL
		to_free = arc_c >> arc_shrink_shift;
#else

		ASSERT((int64_t)arc_p >= 0);
	}

	if (arc_size > arc_c) {
		DTRACE_PROBE2(arc__shrink_adjust, uint64_t, arc_size,
			uint64_t, arc_c);
		arc_adjust();
	}
}

static int needfree = 0;


#ifdef _KERNEL

	if (needfree) {
		DTRACE_PROBE(arc__reclaim_needfree);
		return (1);
	}

	if (kmem_free_count() < zfs_arc_free_target) {
		DTRACE_PROBE2(arc__reclaim_freetarget, uint64_t,
		    kmem_free_count(), uint64_t, zfs_arc_free_target);
		return (1);
	}

	/*
	 * Cooperate with pagedaemon when it's time for it to scan
	 * and reclaim some pages.
	 */
	if (vm_paging_needed()) {
		DTRACE_PROBE(arc__reclaim_paging);
		return (1);
	}

#ifdef sun
	/*

	    (btop(vmem_size(heap_arena, VMEM_FREE | VMEM_ALLOC)) >> 2))
		return (1);
#endif
#else	/* !sun */
	if (kmem_used() > (kmem_size() * 3) / 4)
		return (1);
#endif	/* sun */

#else

	if (spa_get_random(100) == 0)
		return (1);
#endif
	DTRACE_PROBE(arc__reclaim_no);

	return (0);
}


Lines 115-124 __FBSDID("$FreeBSD$"); Link Here

(-)sys/vm/vm_pageout.c (-7 / +18 lines)
115		115
116	/* the kernel process "vm_pageout"*/	116	/* the kernel process "vm_pageout"*/
117	static void vm_pageout(void);	117	static void vm_pageout(void);
		118	static void vm_pageout_init(void);
118	static int vm_pageout_clean(vm_page_t);	119	static int vm_pageout_clean(vm_page_t);
119	static void vm_pageout_scan(struct vm_domain *vmd, int pass);	120	static void vm_pageout_scan(struct vm_domain *vmd, int pass);
120	static void vm_pageout_mightbe_oom(struct vm_domain *vmd, int pass);	121	static void vm_pageout_mightbe_oom(struct vm_domain *vmd, int pass);
121		122
		123	SYSINIT(pagedaemon_init, SI_SUB_KTHREAD_PAGE, SI_ORDER_FIRST, vm_pageout_init,
		124	NULL);
		125
122	struct proc *pageproc;	126	struct proc *pageproc;
123		127
124	static struct kproc_desc page_kp = {	128	static struct kproc_desc page_kp = {
Lines 126-132 static struct kproc_desc page_kp = { Link Here
126	vm_pageout,	130	vm_pageout,
127	&pageproc	131	&pageproc
128	};	132	};
129	SYSINIT(pagedaemon, SI_SUB_KTHREAD_PAGE, SI_ORDER_FIRST, kproc_start,	133	SYSINIT(pagedaemon, SI_SUB_KTHREAD_PAGE, SI_ORDER_SECOND, kproc_start,
130	&page_kp);	134	&page_kp);
131		135
132	#if !defined(NO_SWAPPING)	136	#if !defined(NO_SWAPPING)
Lines 1637-1651 vm_pageout_worker(void *arg) Link Here
1637	}	1641	}
1638		1642
1639	/*	1643	/*
1640	* vm_pageout is the high level pageout daemon.	1644	* vm_pageout_init initialises basic pageout daemon settings.
1641	*/	1645	*/
1642	static void	1646	static void
1643	vm_pageout(void)	1647	vm_pageout_init(void)
1644	{	1648	{
1645	#if MAXMEMDOM > 1
1646	int error, i;
1647	#endif
1648
1649	/*	1649	/*
1650	* Initialize some paging parameters.	1650	* Initialize some paging parameters.
1651	*/	1651	*/
Lines 1691-1697 static void Link Here
1691	/* XXX does not really belong here */	1691	/* XXX does not really belong here */
1692	if (vm_page_max_wired == 0)	1692	if (vm_page_max_wired == 0)
1693	vm_page_max_wired = vm_cnt.v_free_count / 3;	1693	vm_page_max_wired = vm_cnt.v_free_count / 3;
		1694	}
1694		1695
		1696	/*
		1697	* vm_pageout is the high level pageout daemon.
		1698	*/
		1699	static void
		1700	vm_pageout(void)
		1701	{
		1702	#if MAXMEMDOM > 1
		1703	int error, i;
		1704	#endif
		1705
1695	swap_pager_swap_init();	1706	swap_pager_swap_init();
1696	#if MAXMEMDOM > 1	1707	#if MAXMEMDOM > 1
1697	for (i = 1; i < vm_ndomains; i++) {	1708	for (i = 1; i < vm_ndomains; i++) {

Return to bug 187594

Lines 193-201 extern int zfs_prefetch_disable; Link Here

(-)sys/cddl/contrib/opensolaris/uts/common/fs/zfs/arc.c (-9 / +64 lines)
193	*/	193	*/
194	static boolean_t arc_warm;	194	static boolean_t arc_warm;
195		195
196	/*
197	* These tunables are for performance analysis.
198	*/
199	uint64_t zfs_arc_max;	196	uint64_t zfs_arc_max;
200	uint64_t zfs_arc_min;	197	uint64_t zfs_arc_min;
201	uint64_t zfs_arc_meta_limit = 0;	198	uint64_t zfs_arc_meta_limit = 0;
Lines 204-210 int zfs_arc_shrink_shift = 0; Link Here
204	int zfs_arc_p_min_shift = 0;	201	int zfs_arc_p_min_shift = 0;
205	int zfs_disable_dup_eviction = 0;	202	int zfs_disable_dup_eviction = 0;
206	uint64_t zfs_arc_average_blocksize = 8 * 1024; /* 8KB */	203	uint64_t zfs_arc_average_blocksize = 8 * 1024; /* 8KB */
		204	u_int zfs_arc_free_target = (1 << 19); /* default before pagedaemon init only */
207		205
		206	static int sysctl_vfs_zfs_arc_free_target(SYSCTL_HANDLER_ARGS);
		207
		208	#ifdef _KERNEL
		209	static void
		210	arc_free_target_init(void *unused __unused)
		211	{
		212
		213	zfs_arc_free_target = kmem_free_target();
		214	}
		215	SYSINIT(arc_free_target_init, SI_SUB_KTHREAD_PAGE, SI_ORDER_ANY,
		216	arc_free_target_init, NULL);
		217	#endif
		218
208	TUNABLE_QUAD("vfs.zfs.arc_meta_limit", &zfs_arc_meta_limit);	219	TUNABLE_QUAD("vfs.zfs.arc_meta_limit", &zfs_arc_meta_limit);
209	SYSCTL_DECL(_vfs_zfs);	220	SYSCTL_DECL(_vfs_zfs);
210	SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, arc_max, CTLFLAG_RDTUN, &zfs_arc_max, 0,	221	SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, arc_max, CTLFLAG_RDTUN, &zfs_arc_max, 0,
Lines 214-220 SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, arc_min, CTLFLAG_ Link Here
214	SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, arc_average_blocksize, CTLFLAG_RDTUN,	225	SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, arc_average_blocksize, CTLFLAG_RDTUN,
215	&zfs_arc_average_blocksize, 0,	226	&zfs_arc_average_blocksize, 0,
216	"ARC average blocksize");	227	"ARC average blocksize");
		228	/*
		229	* We don't have a tunable for arc_free_target due to the dependency on
		230	* pagedaemon initialisation.
		231	*/
		232	SYSCTL_PROC(_vfs_zfs, OID_AUTO, arc_free_target,
		233	CTLTYPE_UINT \| CTLFLAG_MPSAFE \| CTLFLAG_RW, 0, sizeof(u_int),
		234	sysctl_vfs_zfs_arc_free_target, "IU",
		235	"Desired number of free pages below which ARC triggers reclaim");
217		236
		237	static int
		238	sysctl_vfs_zfs_arc_free_target(SYSCTL_HANDLER_ARGS)
		239	{
		240	u_int val;
		241	int err;
		242
		243	val = zfs_arc_free_target;
		244	err = sysctl_handle_int(oidp, &val, 0, req);
		245	if (err != 0 \|\| req->newptr == NULL)
		246	return (err);
		247
		248	if (val < kmem_free_min())
		249	return (EINVAL);
		250	if (val > kmem_page_count())
		251	return (EINVAL);
		252
		253	zfs_arc_free_target = val;
		254
		255	return (0);
		256	}
		257
218	/*	258	/*
219	* Note that buffers can be in one of 6 states:	259	* Note that buffers can be in one of 6 states:
220	* ARC_anon - anonymous (discussed below)	260	* ARC_anon - anonymous (discussed below)
Lines 2418-2426 arc_flush(spa_t *spa) Link Here
2418	void	2458	void
2419	arc_shrink(void)	2459	arc_shrink(void)
2420	{	2460	{
		2461
2421	if (arc_c > arc_c_min) {	2462	if (arc_c > arc_c_min) {
2422	uint64_t to_free;	2463	uint64_t to_free;
2423		2464
		2465	DTRACE_PROBE2(arc__shrink, uint64_t, arc_c, uint64_t,
		2466	arc_c_min);
2424	#ifdef _KERNEL	2467	#ifdef _KERNEL
2425	to_free = arc_c >> arc_shrink_shift;	2468	to_free = arc_c >> arc_shrink_shift;
2426	#else	2469	#else
Lines 2440-2447 arc_shrink(void) Link Here
2440	ASSERT((int64_t)arc_p >= 0);	2483	ASSERT((int64_t)arc_p >= 0);
2441	}	2484	}
2442		2485
2443	if (arc_size > arc_c)	2486	if (arc_size > arc_c) {
		2487	DTRACE_PROBE2(arc__shrink_adjust, uint64_t, arc_size,
		2488	uint64_t, arc_c);
2444	arc_adjust();	2489	arc_adjust();
		2490	}
2445	}	2491	}
2446		2492
2447	static int needfree = 0;	2493	static int needfree = 0;
Lines 2452-2466 arc_reclaim_needed(void) Link Here
2452		2498
2453	#ifdef _KERNEL	2499	#ifdef _KERNEL
2454		2500
2455	if (needfree)	2501	if (needfree) {
		2502	DTRACE_PROBE(arc__reclaim_needfree);
2456	return (1);	2503	return (1);
		2504	}
2457		2505
		2506	if (kmem_free_count() < zfs_arc_free_target) {
		2507	DTRACE_PROBE2(arc__reclaim_freetarget, uint64_t,
		2508	kmem_free_count(), uint64_t, zfs_arc_free_target);
		2509	return (1);
		2510	}
		2511
2458	/*	2512	/*
2459	* Cooperate with pagedaemon when it's time for it to scan	2513	* Cooperate with pagedaemon when it's time for it to scan
2460	* and reclaim some pages.	2514	* and reclaim some pages.
2461	*/	2515	*/
2462	if (vm_paging_needed())	2516	if (vm_paging_needed()) {
		2517	DTRACE_PROBE(arc__reclaim_paging);
2463	return (1);	2518	return (1);
		2519	}
2464		2520
2465	#ifdef sun	2521	#ifdef sun
2466	/*	2522	/*
Lines 2504-2512 arc_reclaim_needed(void) Link Here
2504	(btop(vmem_size(heap_arena, VMEM_FREE \| VMEM_ALLOC)) >> 2))	2560	(btop(vmem_size(heap_arena, VMEM_FREE \| VMEM_ALLOC)) >> 2))
2505	return (1);	2561	return (1);
2506	#endif	2562	#endif
2507	#else /* !sun */
2508	if (kmem_used() > (kmem_size() * 3) / 4)
2509	return (1);
2510	#endif /* sun */	2563	#endif /* sun */
2511		2564
2512	#else	2565	#else
Lines 2513-2518 arc_reclaim_needed(void) Link Here
2513	if (spa_get_random(100) == 0)	2566	if (spa_get_random(100) == 0)
2514	return (1);	2567	return (1);
2515	#endif	2568	#endif
		2569	DTRACE_PROBE(arc__reclaim_no);
		2570
2516	return (0);	2571	return (0);
2517	}	2572	}
2518		2573

Lines 126-143 kmem_size_init(void *unused __unused) Link Here

(-)sys/cddl/compat/opensolaris/kern/opensolaris_kmem.c (-5 / +34 lines)
126	}	126	}
127	SYSINIT(kmem_size_init, SI_SUB_KMEM, SI_ORDER_ANY, kmem_size_init, NULL);	127	SYSINIT(kmem_size_init, SI_SUB_KMEM, SI_ORDER_ANY, kmem_size_init, NULL);
128		128
129	uint64_t	129	/*
130	kmem_size(void)	130	* The return values from kmem_free_* are only valid once the pagedaemon
		131	* has been initialised, before then they return 0.
		132	*
		133	* To ensure the returns are valid the caller can use a SYSINIT with
		134	* subsystem set to SI_SUB_KTHREAD_PAGE and an order of at least
		135	* SI_ORDER_SECOND.
		136	*/
		137	u_int
		138	kmem_free_target(void)
131	{	139	{
132		140
133	return (kmem_size_val);	141	return (vm_cnt.v_free_target);
134	}	142	}
135		143
		144	u_int
		145	kmem_free_min(void)
		146	{
		147
		148	return (vm_cnt.v_free_min);
		149	}
		150
		151	u_int
		152	kmem_free_count(void)
		153	{
		154
		155	return (vm_cnt.v_free_count);
		156	}
		157
		158	u_int
		159	kmem_page_count(void)
		160	{
		161
		162	return (vm_cnt.v_page_count);
		163	}
		164
136	uint64_t	165	uint64_t
137	kmem_used(void)	166	kmem_size(void)
138	{	167	{
139		168
140	return (vmem_size(kmem_arena, VMEM_ALLOC));	169	return (kmem_size_val);
141	}	170	}
142		171
143	static int	172	static int

Lines 66-72 typedef struct kmem_cache { Link Here

(-)sys/cddl/compat/opensolaris/sys/kmem.h (-1 / +10 lines)
66	void *zfs_kmem_alloc(size_t size, int kmflags);	66	void *zfs_kmem_alloc(size_t size, int kmflags);
67	void zfs_kmem_free(void *buf, size_t size);	67	void zfs_kmem_free(void *buf, size_t size);
68	uint64_t kmem_size(void);	68	uint64_t kmem_size(void);
69	uint64_t kmem_used(void);	69	u_int kmem_page_count(void);
		70
		71	/*
		72	* The return values from kmem_free_* are only valid once the pagedaemon
		73	* has been initialised, before then they return 0.
		74	*/
		75	u_int kmem_free_count(void);
		76	u_int kmem_free_target(void);
		77	u_int kmem_free_min(void);
		78
70	kmem_cache_t kmem_cache_create(char name, size_t bufsize, size_t align,	79	kmem_cache_t kmem_cache_create(char name, size_t bufsize, size_t align,
71	int (constructor)(void , void , int), void (destructor)(void , void ),	80	int (constructor)(void , void , int), void (destructor)(void , void ),
72	void (reclaim)(void ) __unused, void private, vmem_t vmp, int cflags);	81	void (reclaim)(void ) __unused, void private, vmem_t vmp, int cflags);