Attachment #245664 for bug #274252

View | Details | Raw Unified | Return to bug 274252
Collapse All | Expand All

Lines 95-101 tegra_bo_alloc_contig(size_t npages, u_long alignment, vm_memattr_t memattr, Link Here

(-)b/sys/arm/nvidia/drm2/tegra_bo.c (-3 / +6 lines)
95	vm_page_t **ret_page)	95	vm_page_t **ret_page)
96	{	96	{
97	vm_page_t m;	97	vm_page_t m;
98	int tries, i;	98	int err, i, tries;
99	vm_paddr_t low, high, boundary;	99	vm_paddr_t low, high, boundary;
100		100
101	low = 0;	101	low = 0;
Lines 107-115 tegra_bo_alloc_contig(size_t npages, u_long alignment, vm_memattr_t memattr, Link Here
107	low, high, alignment, boundary, memattr);	107	low, high, alignment, boundary, memattr);
108	if (m == NULL) {	108	if (m == NULL) {
109	if (tries < 3) {	109	if (tries < 3) {
110	if (!vm_page_reclaim_contig(0, npages, low, high,	110	err = vm_page_reclaim_contig(0, npages, low, high,
111	alignment, boundary))	111	alignment, boundary);
		112	if (err == ENOMEM)
112	vm_wait(NULL);	113	vm_wait(NULL);
		114	else if (err != 0)
		115	return (ENOMEM);
113	tries++;	116	tries++;
114	goto retry;	117	goto retry;
115	}	118	}




linux_alloc_pages(gfp_t flags, unsigned int order)
{
	struct page *page;
	int err;

	if (PMAP_HAS_DMAP) {
		unsigned long npages = 1UL << order;

			    PAGE_SIZE, 0, VM_MEMATTR_DEFAULT);
			if (page == NULL) {
				if (flags & M_WAITOK) {
					err = vm_page_reclaim_contig(req,
					    npages, 0, pmax, PAGE_SIZE, 0);
					if (err == ENOMEM)
						vm_wait(NULL);
					else if (err != 0)
						return (NULL);
					flags &= ~M_WAITOK;
					goto retry;
				}

Lines 1498-1505 int ttm_bo_global_init(struct drm_global_reference *ref) Link Here

(-)b/sys/dev/drm2/ttm/ttm_bo.c (-2 / +2 lines)
1498	VM_MAX_ADDRESS, PAGE_SIZE, 0, VM_MEMATTR_UNCACHEABLE);	1498	VM_MAX_ADDRESS, PAGE_SIZE, 0, VM_MEMATTR_UNCACHEABLE);
1499		1499
1500	if (unlikely(glob->dummy_read_page == NULL)) {	1500	if (unlikely(glob->dummy_read_page == NULL)) {
1501	if (tries < 1 && vm_page_reclaim_contig(0, 1, 0,	1501	if (tries < 1 && (vm_page_reclaim_contig(0, 1, 0,
1502	VM_MAX_ADDRESS, PAGE_SIZE, 0)) {	1502	VM_MAX_ADDRESS, PAGE_SIZE, 0) == 0)) {
1503	tries++;	1503	tries++;
1504	goto retry;	1504	goto retry;
1505	}	1505	}




ttm_vm_page_alloc_dma32(int req, vm_memattr_t memattr)
{
	vm_page_t p;
	int err, tries;

	for (tries = 0; ; tries++) {
		p = vm_page_alloc_noobj_contig(req, 1, 0, 0xffffffff, PAGE_SIZE,
		    0, memattr);
		if (p != NULL || tries > 2)
			return (p);
		err = vm_page_reclaim_contig(req, 1, 0, 0xffffffff,
		    PAGE_SIZE, 0);
		if (err == ENOMEM)
			vm_wait(NULL);
		else if (err != 0)
			return (NULL);
	}
}


Lines 3161-3168 ktls_reclaim_thread(void *ctx) Link Here

(-)b/sys/kern/uipc_ktls.c (-2 / +3 lines)
3161	* backlogs of buffers to be encrypted, leading to	3161	* backlogs of buffers to be encrypted, leading to
3162	* surges of traffic and potential NIC output drops.	3162	* surges of traffic and potential NIC output drops.
3163	*/	3163	*/
3164	if (!vm_page_reclaim_contig_domain_ext(domain, VM_ALLOC_NORMAL,	3164	if (vm_page_reclaim_contig_domain_ext(domain, VM_ALLOC_NORMAL,
3165	atop(ktls_maxlen), 0, ~0ul, PAGE_SIZE, 0, ktls_max_reclaim)) {	3165	atop(ktls_maxlen), 0, ~0ul, PAGE_SIZE, 0,
		3166	ktls_max_reclaim) != 0) {
3166	vm_wait_domain(domain);	3167	vm_wait_domain(domain);
3167	} else {	3168	} else {
3168	sc->reclaims += ktls_max_reclaim;	3169	sc->reclaims += ktls_max_reclaim;

Lines 877-884 shm_dotruncate_largepage(struct shmfd shmfd, off_t length, void rl_cookie) Link Here

(-)b/sys/kern/uipc_shm.c (-2 / +3 lines)
877	}	877	}
878	error = vm_page_reclaim_contig(aflags,	878	error = vm_page_reclaim_contig(aflags,
879	pagesizes[psind] / PAGE_SIZE, 0, ~0,	879	pagesizes[psind] / PAGE_SIZE, 0, ~0,
880	pagesizes[psind], 0) ? 0 :	880	pagesizes[psind], 0);
881	vm_wait_intr(object);	881	if (error == ENOMEM)
		882	error = vm_wait_intr(object);
882	if (error != 0) {	883	if (error != 0) {
883	VM_OBJECT_WLOCK(object);	884	VM_OBJECT_WLOCK(object);
884	return (error);	885	return (error);

Lines 68-73 vm_domainset_iter_init(struct vm_domainset_iter di, struct domainset ds, Link Here

(-)b/sys/vm/vm_domainset.c (-5 / +24 lines)
68	di->di_domain = ds;	68	di->di_domain = ds;
69	di->di_iter = iter;	69	di->di_iter = iter;
70	di->di_policy = ds->ds_policy;	70	di->di_policy = ds->ds_policy;
		71	DOMAINSET_COPY(&ds->ds_mask, &di->di_valid_mask);
71	if (di->di_policy == DOMAINSET_POLICY_INTERLEAVE) {	72	if (di->di_policy == DOMAINSET_POLICY_INTERLEAVE) {
72	#if VM_NRESERVLEVEL > 0	73	#if VM_NRESERVLEVEL > 0
73	if (vm_object_reserv(obj)) {	74	if (vm_object_reserv(obj)) {
Lines 158-164 vm_domainset_iter_first(struct vm_domainset_iter di, int domain) Link Here
158	switch (di->di_policy) {	159	switch (di->di_policy) {
159	case DOMAINSET_POLICY_FIRSTTOUCH:	160	case DOMAINSET_POLICY_FIRSTTOUCH:
160	*domain = PCPU_GET(domain);	161	*domain = PCPU_GET(domain);
161	if (DOMAINSET_ISSET(*domain, &di->di_domain->ds_mask)) {	162	if (DOMAINSET_ISSET(*domain, &di->di_valid_mask)) {
162	/*	163	/*
163	* Add an extra iteration because we will visit the	164	* Add an extra iteration because we will visit the
164	* current domain a second time in the rr iterator.	165	* current domain a second time in the rr iterator.
Lines 221-231 int Link Here
221	vm_domainset_iter_page(struct vm_domainset_iter di, struct vm_object obj,	222	vm_domainset_iter_page(struct vm_domainset_iter di, struct vm_object obj,
222	int *domain)	223	int *domain)
223	{	224	{
		225	if (DOMAINSET_EMPTY(&di->di_valid_mask))
		226	return (ENOMEM);
224		227
225	/* If there are more domains to visit we run the iterator. */	228	/* If there are more domains to visit we run the iterator. */
226	while (--di->di_n != 0) {	229	while (--di->di_n != 0) {
227	vm_domainset_iter_next(di, domain);	230	vm_domainset_iter_next(di, domain);
228	if (!di->di_minskip \|\| !vm_page_count_min_domain(*domain))	231	if (DOMAINSET_ISSET(*domain, &di->di_valid_mask) &&
		232	(!di->di_minskip \|\| !vm_page_count_min_domain(*domain)))
229	return (0);	233	return (0);
230	}	234	}
231		235
Lines 243-249 vm_domainset_iter_page(struct vm_domainset_iter di, struct vm_object obj, Link Here
243	/* Wait for one of the domains to accumulate some free pages. */	247	/* Wait for one of the domains to accumulate some free pages. */
244	if (obj != NULL)	248	if (obj != NULL)
245	VM_OBJECT_WUNLOCK(obj);	249	VM_OBJECT_WUNLOCK(obj);
246	vm_wait_doms(&di->di_domain->ds_mask, 0);	250	vm_wait_doms(&di->di_valid_mask, 0);
247	if (obj != NULL)	251	if (obj != NULL)
248	VM_OBJECT_WLOCK(obj);	252	VM_OBJECT_WLOCK(obj);
249	if ((di->di_flags & VM_ALLOC_WAITFAIL) != 0)	253	if ((di->di_flags & VM_ALLOC_WAITFAIL) != 0)
Lines 288-298 vm_domainset_iter_policy_ref_init(struct vm_domainset_iter *di, Link Here
288	int	292	int
289	vm_domainset_iter_policy(struct vm_domainset_iter di, int domain)	293	vm_domainset_iter_policy(struct vm_domainset_iter di, int domain)
290	{	294	{
		295	if (DOMAINSET_EMPTY(&di->di_valid_mask))
		296	return (ENOMEM);
291		297
292	/* If there are more domains to visit we run the iterator. */	298	/* If there are more domains to visit we run the iterator. */
293	while (--di->di_n != 0) {	299	while (--di->di_n != 0) {
294	vm_domainset_iter_next(di, domain);	300	vm_domainset_iter_next(di, domain);
295	if (!di->di_minskip \|\| !vm_page_count_min_domain(*domain))	301	if (DOMAINSET_ISSET(*domain, &di->di_valid_mask) &&
		302	(!di->di_minskip \|\| !vm_page_count_min_domain(*domain)))
296	return (0);	303	return (0);
297	}	304	}
298		305
Lines 308-314 vm_domainset_iter_policy(struct vm_domainset_iter di, int domain) Link Here
308	return (ENOMEM);	315	return (ENOMEM);
309		316
310	/* Wait for one of the domains to accumulate some free pages. */	317	/* Wait for one of the domains to accumulate some free pages. */
311	vm_wait_doms(&di->di_domain->ds_mask, 0);	318	vm_wait_doms(&di->di_valid_mask, 0);
312		319
313	/* Restart the search. */	320	/* Restart the search. */
314	vm_domainset_iter_first(di, domain);	321	vm_domainset_iter_first(di, domain);
Lines 316-321 vm_domainset_iter_policy(struct vm_domainset_iter di, int domain) Link Here
316	return (0);	323	return (0);
317	}	324	}
318		325
		326	void
		327	vm_domainset_iter_ignore(struct vm_domainset_iter *di, int domain)
		328	{
		329	DOMAINSET_CLR(domain, &di->di_valid_mask);
		330	}
		331
319	#else /* !NUMA */	332	#else /* !NUMA */
320		333
321	int	334	int
Lines 357-360 vm_domainset_iter_policy_ref_init(struct vm_domainset_iter *di, Link Here
357	*domain = 0;	370	*domain = 0;
358	}	371	}
359		372
		373	void
		374	vm_domainset_iter_ignore(struct vm_domainset_iter *di __unused,
		375	int domain __unused)
		376	{
		377	}
		378
360	#endif /* NUMA */	379	#endif /* NUMA */

Lines 31-36 Link Here

(-)b/sys/vm/vm_domainset.h (+2 lines)
31	struct vm_domainset_iter {	31	struct vm_domainset_iter {
32	struct domainset *di_domain;	32	struct domainset *di_domain;
33	unsigned int *di_iter;	33	unsigned int *di_iter;
		34	domainset_t di_valid_mask;
34	vm_pindex_t di_offset;	35	vm_pindex_t di_offset;
35	int di_flags;	36	int di_flags;
36	uint16_t di_policy;	37	uint16_t di_policy;
Lines 47-52 void vm_domainset_iter_policy_init(struct vm_domainset_iter *, Link Here
47	struct domainset , int , int *);	48	struct domainset , int , int *);
48	void vm_domainset_iter_policy_ref_init(struct vm_domainset_iter *,	49	void vm_domainset_iter_policy_ref_init(struct vm_domainset_iter *,
49	struct domainset_ref , int , int *);	50	struct domainset_ref , int , int *);
		51	void vm_domainset_iter_ignore(struct vm_domainset_iter *, int);
50		52
51	int vm_wait_doms(const domainset_t *, int mflags);	53	int vm_wait_doms(const domainset_t *, int mflags);
52		54

Lines 212-219 kmem_alloc_contig_pages(vm_object_t object, vm_pindex_t pindex, int domain, Link Here

(-)b/sys/vm/vm_kern.c (-2 / +18 lines)
212	break;	212	break;
213		213
214	VM_OBJECT_WUNLOCK(object);	214	VM_OBJECT_WUNLOCK(object);
215	if (!vm_page_reclaim_contig_domain(domain, pflags, npages,	215	if ((vm_page_reclaim_contig_domain(domain, pflags, npages,
216	low, high, alignment, boundary) && wait)	216	low, high, alignment, boundary) == ENOMEM) && wait)
217	vm_wait_domain(domain);	217	vm_wait_domain(domain);
218	VM_OBJECT_WLOCK(object);	218	VM_OBJECT_WLOCK(object);
219	}	219	}
Lines 286-293 kmem_alloc_attr_domainset(struct domainset *ds, vm_size_t size, int flags, Link Here
286	vm_paddr_t low, vm_paddr_t high, vm_memattr_t memattr)	286	vm_paddr_t low, vm_paddr_t high, vm_memattr_t memattr)
287	{	287	{
288	struct vm_domainset_iter di;	288	struct vm_domainset_iter di;
		289	vm_page_t bounds[2];
289	void *addr;	290	void *addr;
290	int domain;	291	int domain;
		292	int start_segind;
		293
		294	start_segind = vm_phys_lookup_segind(low);
291		295
292	vm_domainset_iter_policy_init(&di, ds, &domain, &flags);	296	vm_domainset_iter_policy_init(&di, ds, &domain, &flags);
293	do {	297	do {
Lines 295-300 kmem_alloc_attr_domainset(struct domainset *ds, vm_size_t size, int flags, Link Here
295	memattr);	299	memattr);
296	if (addr != NULL)	300	if (addr != NULL)
297	break;	301	break;
		302	if (vm_phys_find_range(bounds, start_segind, domain,
		303	atop(round_page(size)), low, high) == -1) {
		304	vm_domainset_iter_ignore(&di, domain);
		305	}
298	} while (vm_domainset_iter_policy(&di, &domain) == 0);	306	} while (vm_domainset_iter_policy(&di, &domain) == 0);
299		307
300	return (addr);	308	return (addr);
Lines 370-377 kmem_alloc_contig_domainset(struct domainset *ds, vm_size_t size, int flags, Link Here
370	vm_memattr_t memattr)	378	vm_memattr_t memattr)
371	{	379	{
372	struct vm_domainset_iter di;	380	struct vm_domainset_iter di;
		381	vm_page_t bounds[2];
373	void *addr;	382	void *addr;
374	int domain;	383	int domain;
		384	int start_segind;
		385
		386	start_segind = vm_phys_lookup_segind(low);
375		387
376	vm_domainset_iter_policy_init(&di, ds, &domain, &flags);	388	vm_domainset_iter_policy_init(&di, ds, &domain, &flags);
377	do {	389	do {
Lines 379-384 kmem_alloc_contig_domainset(struct domainset *ds, vm_size_t size, int flags, Link Here
379	alignment, boundary, memattr);	391	alignment, boundary, memattr);
380	if (addr != NULL)	392	if (addr != NULL)
381	break;	393	break;
		394	if (vm_phys_find_range(bounds, start_segind, domain,
		395	atop(round_page(size)), low, high) == -1) {
		396	vm_domainset_iter_ignore(&di, domain);
		397	}
382	} while (vm_domainset_iter_policy(&di, &domain) == 0);	398	} while (vm_domainset_iter_policy(&di, &domain) == 0);
383		399
384	return (addr);	400	return (addr);

Lines 2168-2175 vm_page_alloc_contig(vm_object_t object, vm_pindex_t pindex, int req, Link Here

(-)b/sys/vm/vm_page.c (-14 / +36 lines)
2168	vm_paddr_t boundary, vm_memattr_t memattr)	2168	vm_paddr_t boundary, vm_memattr_t memattr)
2169	{	2169	{
2170	struct vm_domainset_iter di;	2170	struct vm_domainset_iter di;
		2171	vm_page_t bounds[2];
2171	vm_page_t m;	2172	vm_page_t m;
2172	int domain;	2173	int domain;
		2174	int start_segind;
		2175
		2176	start_segind = vm_phys_lookup_segind(low);
2173		2177
2174	vm_domainset_iter_page_init(&di, object, pindex, &domain, &req);	2178	vm_domainset_iter_page_init(&di, object, pindex, &domain, &req);
2175	do {	2179	do {
Lines 2177-2182 vm_page_alloc_contig(vm_object_t object, vm_pindex_t pindex, int req, Link Here
2177	npages, low, high, alignment, boundary, memattr);	2181	npages, low, high, alignment, boundary, memattr);
2178	if (m != NULL)	2182	if (m != NULL)
2179	break;	2183	break;
		2184	if (vm_phys_find_range(bounds, start_segind, domain,
		2185	npages, low, high) == -1) {
		2186	vm_domainset_iter_ignore(&di, domain);
		2187	}
2180	} while (vm_domainset_iter_page(&di, object, &domain) == 0);	2188	} while (vm_domainset_iter_page(&di, object, &domain) == 0);
2181		2189
2182	return (m);	2190	return (m);
Lines 3020-3026 vm_page_reclaim_run(int req_class, int domain, u_long npages, vm_page_t m_run, Link Here
3020	* "npages" must be greater than zero. Both "alignment" and "boundary"	3028	* "npages" must be greater than zero. Both "alignment" and "boundary"
3021	* must be a power of two.	3029	* must be a power of two.
3022	*/	3030	*/
3023	bool	3031	int
3024	vm_page_reclaim_contig_domain_ext(int domain, int req, u_long npages,	3032	vm_page_reclaim_contig_domain_ext(int domain, int req, u_long npages,
3025	vm_paddr_t low, vm_paddr_t high, u_long alignment, vm_paddr_t boundary,	3033	vm_paddr_t low, vm_paddr_t high, u_long alignment, vm_paddr_t boundary,
3026	int desired_runs)	3034	int desired_runs)
Lines 3028-3041 vm_page_reclaim_contig_domain_ext(int domain, int req, u_long npages, Link Here
3028	struct vm_domain *vmd;	3036	struct vm_domain *vmd;
3029	vm_page_t bounds[2], m_run, _m_runs[NRUNS], *m_runs;	3037	vm_page_t bounds[2], m_run, _m_runs[NRUNS], *m_runs;
3030	u_long count, minalign, reclaimed;	3038	u_long count, minalign, reclaimed;
3031	int error, i, min_reclaim, nruns, options, req_class, segind;	3039	int error, i, min_reclaim, nruns, options, req_class;
3032	bool ret;	3040	int segind, start_segind;
		3041	int ret;
3033		3042
3034	KASSERT(npages > 0, ("npages is 0"));	3043	KASSERT(npages > 0, ("npages is 0"));
3035	KASSERT(powerof2(alignment), ("alignment is not a power of 2"));	3044	KASSERT(powerof2(alignment), ("alignment is not a power of 2"));
3036	KASSERT(powerof2(boundary), ("boundary is not a power of 2"));	3045	KASSERT(powerof2(boundary), ("boundary is not a power of 2"));
3037		3046
3038	ret = false;	3047	ret = ENOMEM;
3039		3048
3040	/*	3049	/*
3041	* If the caller wants to reclaim multiple runs, try to allocate	3050	* If the caller wants to reclaim multiple runs, try to allocate
Lines 3075-3080 vm_page_reclaim_contig_domain_ext(int domain, int req, u_long npages, Link Here
3075	if (curproc == pageproc && req_class != VM_ALLOC_INTERRUPT)	3084	if (curproc == pageproc && req_class != VM_ALLOC_INTERRUPT)
3076	req_class = VM_ALLOC_SYSTEM;	3085	req_class = VM_ALLOC_SYSTEM;
3077		3086
		3087	start_segind = vm_phys_lookup_segind(low);
		3088	if (vm_phys_find_range(bounds, start_segind, domain, npages,
		3089	low, high) == -1) {
		3090	ret = ERANGE;
		3091	goto done;
		3092	}
		3093
3078	/*	3094	/*
3079	* Return if the number of free pages cannot satisfy the requested	3095	* Return if the number of free pages cannot satisfy the requested
3080	* allocation.	3096	* allocation.
Lines 3096-3102 vm_page_reclaim_contig_domain_ext(int domain, int req, u_long npages, Link Here
3096	* and restrictions, and record them in "m_runs".	3112	* and restrictions, and record them in "m_runs".
3097	*/	3113	*/
3098	count = 0;	3114	count = 0;
3099	segind = vm_phys_lookup_segind(low);	3115	segind = start_segind;
3100	while ((segind = vm_phys_find_range(bounds, segind, domain,	3116	while ((segind = vm_phys_find_range(bounds, segind, domain,
3101	npages, low, high)) != -1) {	3117	npages, low, high)) != -1) {
3102	while ((m_run = vm_page_scan_contig(npages, bounds[0],	3118	while ((m_run = vm_page_scan_contig(npages, bounds[0],
Lines 3124-3130 vm_page_reclaim_contig_domain_ext(int domain, int req, u_long npages, Link Here
3124	if (error == 0) {	3140	if (error == 0) {
3125	reclaimed += npages;	3141	reclaimed += npages;
3126	if (reclaimed >= min_reclaim) {	3142	if (reclaimed >= min_reclaim) {
3127	ret = true;	3143	ret = 0;
3128	goto done;	3144	goto done;
3129	}	3145	}
3130	}	3146	}
Lines 3139-3145 vm_page_reclaim_contig_domain_ext(int domain, int req, u_long npages, Link Here
3139	else if (options == VPSC_NOSUPER)	3155	else if (options == VPSC_NOSUPER)
3140	options = VPSC_ANY;	3156	options = VPSC_ANY;
3141	else if (options == VPSC_ANY) {	3157	else if (options == VPSC_ANY) {
3142	ret = reclaimed != 0;	3158	if (reclaimed != 0)
		3159	ret = 0;
3143	goto done;	3160	goto done;
3144	}	3161	}
3145	}	3162	}
Lines 3149-3155 vm_page_reclaim_contig_domain_ext(int domain, int req, u_long npages, Link Here
3149	return (ret);	3166	return (ret);
3150	}	3167	}
3151		3168
3152	bool	3169	int
3153	vm_page_reclaim_contig_domain(int domain, int req, u_long npages,	3170	vm_page_reclaim_contig_domain(int domain, int req, u_long npages,
3154	vm_paddr_t low, vm_paddr_t high, u_long alignment, vm_paddr_t boundary)	3171	vm_paddr_t low, vm_paddr_t high, u_long alignment, vm_paddr_t boundary)
3155	{	3172	{
Lines 3157-3176 vm_page_reclaim_contig_domain(int domain, int req, u_long npages, Link Here
3157	alignment, boundary, 1));	3174	alignment, boundary, 1));
3158	}	3175	}
3159		3176
3160	bool	3177	int
3161	vm_page_reclaim_contig(int req, u_long npages, vm_paddr_t low, vm_paddr_t high,	3178	vm_page_reclaim_contig(int req, u_long npages, vm_paddr_t low, vm_paddr_t high,
3162	u_long alignment, vm_paddr_t boundary)	3179	u_long alignment, vm_paddr_t boundary)
3163	{	3180	{
3164	struct vm_domainset_iter di;	3181	struct vm_domainset_iter di;
3165	int domain;	3182	int domain, ret, status;
3166	bool ret;	3183
		3184	ret = ERANGE;
3167		3185
3168	vm_domainset_iter_page_init(&di, NULL, 0, &domain, &req);	3186	vm_domainset_iter_page_init(&di, NULL, 0, &domain, &req);
3169	do {	3187	do {
3170	ret = vm_page_reclaim_contig_domain(domain, req, npages, low,	3188	status = vm_page_reclaim_contig_domain(domain, req, npages, low,
3171	high, alignment, boundary);	3189	high, alignment, boundary);
3172	if (ret)	3190	if (status == 0)
3173	break;	3191	return (0);
		3192	if (status != ENOMEM)
		3193	vm_domainset_iter_ignore(&di, domain);
		3194	else
		3195	ret = ENOMEM;
3174	} while (vm_domainset_iter_page(&di, NULL, &domain) == 0);	3196	} while (vm_domainset_iter_page(&di, NULL, &domain) == 0);
3175		3197
3176	return (ret);	3198	return (ret);

Lines 662-672 vm_page_t vm_page_prev(vm_page_t m); Link Here

(-)b/sys/vm/vm_page.h (-3 / +3 lines)
662	bool vm_page_ps_test(vm_page_t m, int flags, vm_page_t skip_m);	662	bool vm_page_ps_test(vm_page_t m, int flags, vm_page_t skip_m);
663	void vm_page_putfake(vm_page_t m);	663	void vm_page_putfake(vm_page_t m);
664	void vm_page_readahead_finish(vm_page_t m);	664	void vm_page_readahead_finish(vm_page_t m);
665	bool vm_page_reclaim_contig(int req, u_long npages, vm_paddr_t low,	665	int vm_page_reclaim_contig(int req, u_long npages, vm_paddr_t low,
666	vm_paddr_t high, u_long alignment, vm_paddr_t boundary);	666	vm_paddr_t high, u_long alignment, vm_paddr_t boundary);
667	bool vm_page_reclaim_contig_domain(int domain, int req, u_long npages,	667	int vm_page_reclaim_contig_domain(int domain, int req, u_long npages,
668	vm_paddr_t low, vm_paddr_t high, u_long alignment, vm_paddr_t boundary);	668	vm_paddr_t low, vm_paddr_t high, u_long alignment, vm_paddr_t boundary);
669	bool vm_page_reclaim_contig_domain_ext(int domain, int req, u_long npages,	669	int vm_page_reclaim_contig_domain_ext(int domain, int req, u_long npages,
670	vm_paddr_t low, vm_paddr_t high, u_long alignment, vm_paddr_t boundary,	670	vm_paddr_t low, vm_paddr_t high, u_long alignment, vm_paddr_t boundary,
671	int desired_runs);	671	int desired_runs);
672	void vm_page_reference(vm_page_t m);	672	void vm_page_reference(vm_page_t m);

Return to bug 274252

Lines 100-105 struct page * Link Here

(-)b/sys/compat/linuxkpi/common/src/linux_page.c (-3 / +6 lines)
100	linux_alloc_pages(gfp_t flags, unsigned int order)	100	linux_alloc_pages(gfp_t flags, unsigned int order)
101	{	101	{
102	struct page *page;	102	struct page *page;
		103	int err;
103		104
104	if (PMAP_HAS_DMAP) {	105	if (PMAP_HAS_DMAP) {
105	unsigned long npages = 1UL << order;	106	unsigned long npages = 1UL << order;
Lines 119-128 linux_alloc_pages(gfp_t flags, unsigned int order) Link Here
119	PAGE_SIZE, 0, VM_MEMATTR_DEFAULT);	120	PAGE_SIZE, 0, VM_MEMATTR_DEFAULT);
120	if (page == NULL) {	121	if (page == NULL) {
121	if (flags & M_WAITOK) {	122	if (flags & M_WAITOK) {
122	if (!vm_page_reclaim_contig(req,	123	err = vm_page_reclaim_contig(req,
123	npages, 0, pmax, PAGE_SIZE, 0)) {	124	npages, 0, pmax, PAGE_SIZE, 0);
		125	if (err == ENOMEM)
124	vm_wait(NULL);	126	vm_wait(NULL);
125	}	127	else if (err != 0)
		128	return (NULL);
126	flags &= ~M_WAITOK;	129	flags &= ~M_WAITOK;
127	goto retry;	130	goto retry;
128	}	131	}

Lines 158-173 static vm_page_t Link Here

(-)b/sys/dev/drm2/ttm/ttm_page_alloc.c (-3 / +6 lines)
158	ttm_vm_page_alloc_dma32(int req, vm_memattr_t memattr)	158	ttm_vm_page_alloc_dma32(int req, vm_memattr_t memattr)
159	{	159	{
160	vm_page_t p;	160	vm_page_t p;
161	int tries;	161	int err, tries;
162		162
163	for (tries = 0; ; tries++) {	163	for (tries = 0; ; tries++) {
164	p = vm_page_alloc_noobj_contig(req, 1, 0, 0xffffffff, PAGE_SIZE,	164	p = vm_page_alloc_noobj_contig(req, 1, 0, 0xffffffff, PAGE_SIZE,
165	0, memattr);	165	0, memattr);
166	if (p != NULL \|\| tries > 2)	166	if (p != NULL \|\| tries > 2)
167	return (p);	167	return (p);
168	if (!vm_page_reclaim_contig(req, 1, 0, 0xffffffff,	168	err = vm_page_reclaim_contig(req, 1, 0, 0xffffffff,
169	PAGE_SIZE, 0))	169	PAGE_SIZE, 0);
		170	if (err == ENOMEM)
170	vm_wait(NULL);	171	vm_wait(NULL);
		172	else if (err != 0)
		173	return (NULL);
171	}	174	}
172	}	175	}
173		176