Attachment #77982 for bug #112194

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




	/* the biggest memory array is the second group of pages */
	vm_paddr_t end;
	vm_paddr_t biggestsize;
	vm_paddr_t low_water;
	int biggestone;

	vm_paddr_t total;

	biggestsize = 0;
	biggestone = 0;
	nblocks = 0;
	page_range = 0;
	vaddr = round_page(vaddr);

	for (i = 0; phys_avail[i + 1]; i += 2) {

	}

	low_water = phys_avail[0];
	high_water = phys_avail[1];

	for (i = 0; phys_avail[i + 1]; i += 2) {
		vm_paddr_t size = phys_avail[i + 1] - phys_avail[i];

		if ((size > biggestsize) && (size > (boot_pages * UMA_SLAB_SIZE))) {
			biggestone = i;
			biggestsize = size;
		}

		if (phys_avail[i] < low_water)
			low_water = phys_avail[i];
		if (phys_avail[i + 1] > high_water)
			high_water = phys_avail[i + 1];
		++nblocks;
		page_range += size/PAGE_SIZE;
		total += size;
	}


	 * use (taking into account the overhead of a page structure per
	 * page).
	 */
	
	first_page = low_water / PAGE_SIZE;
	total = page_range * PAGE_SIZE;
	npages = (total - (page_range * sizeof(struct vm_page)) -
	    (end - new_end)) / PAGE_SIZE;
	end = new_end;




extern vm_page_t vm_page_array;		/* First resident page in table */
extern int vm_page_array_size;		/* number of vm_page_t's */
extern long first_page;			/* first physical page number */
static __inline vm_page_t vm_phys_to_vm_page(vm_paddr_t pa);

static __inline vm_page_t vm_phys_to_vm_page(vm_paddr_t pa) {
	int i,j;
	
	for (i = 0, j = 0; (phys_avail[i+1] <= pa) || (phys_avail[i] > pa); i+= 2)
		j += atop(phys_avail[i+1] - phys_avail[i]);

	return &vm_page_array[j + atop(pa - phys_avail[i])];
}

#define VM_PAGE_TO_PHYS(entry)	((entry)->phys_addr)

#define PHYS_TO_VM_PAGE(pa) \
		vm_phys_to_vm_page(pa)

extern struct mtx vm_page_queue_mtx;
#define vm_page_lock_queues()   mtx_lock(&vm_page_queue_mtx)

Return to bug 112194

Lines 212-218 Link Here

(-)vm_page.c (-6 / +7 lines)
212	/* the biggest memory array is the second group of pages */	212	/* the biggest memory array is the second group of pages */
213	vm_paddr_t end;	213	vm_paddr_t end;
214	vm_paddr_t biggestsize;	214	vm_paddr_t biggestsize;
215	vm_paddr_t low_water, high_water;	215	vm_paddr_t low_water;
216	int biggestone;	216	int biggestone;
217		217
218	vm_paddr_t total;	218	vm_paddr_t total;
Lines 221-226 Link Here
221	biggestsize = 0;	221	biggestsize = 0;
222	biggestone = 0;	222	biggestone = 0;
223	nblocks = 0;	223	nblocks = 0;
		224	page_range = 0;
224	vaddr = round_page(vaddr);	225	vaddr = round_page(vaddr);
225		226
226	for (i = 0; phys_avail[i + 1]; i += 2) {	227	for (i = 0; phys_avail[i + 1]; i += 2) {
Lines 229-248 Link Here
229	}	230	}
230		231
231	low_water = phys_avail[0];	232	low_water = phys_avail[0];
232	high_water = phys_avail[1];
233		233
234	for (i = 0; phys_avail[i + 1]; i += 2) {	234	for (i = 0; phys_avail[i + 1]; i += 2) {
235	vm_paddr_t size = phys_avail[i + 1] - phys_avail[i];	235	vm_paddr_t size = phys_avail[i + 1] - phys_avail[i];
236		236
237	if (size > biggestsize) {	237	if ((size > biggestsize) && (size > (boot_pages * UMA_SLAB_SIZE))) {
238	biggestone = i;	238	biggestone = i;
239	biggestsize = size;	239	biggestsize = size;
240	}	240	}
		241
241	if (phys_avail[i] < low_water)	242	if (phys_avail[i] < low_water)
242	low_water = phys_avail[i];	243	low_water = phys_avail[i];
243	if (phys_avail[i + 1] > high_water)
244	high_water = phys_avail[i + 1];
245	++nblocks;	244	++nblocks;
		245	page_range += size/PAGE_SIZE;
246	total += size;	246	total += size;
247	}	247	}
248		248
Lines 297-304 Link Here
297	* use (taking into account the overhead of a page structure per	297	* use (taking into account the overhead of a page structure per
298	* page).	298	* page).
299	*/	299	*/
		300
300	first_page = low_water / PAGE_SIZE;	301	first_page = low_water / PAGE_SIZE;
301	page_range = high_water / PAGE_SIZE - first_page;	302	total = page_range * PAGE_SIZE;
302	npages = (total - (page_range * sizeof(struct vm_page)) -	303	npages = (total - (page_range * sizeof(struct vm_page)) -
303	(end - new_end)) / PAGE_SIZE;	304	(end - new_end)) / PAGE_SIZE;
304	end = new_end;	305	end = new_end;

Lines 272-282 Link Here

(-)vm_page.h (-1 / +11 lines)
272	extern vm_page_t vm_page_array; /* First resident page in table */	272	extern vm_page_t vm_page_array; /* First resident page in table */
273	extern int vm_page_array_size; /* number of vm_page_t's */	273	extern int vm_page_array_size; /* number of vm_page_t's */
274	extern long first_page; /* first physical page number */	274	extern long first_page; /* first physical page number */
		275	static __inline vm_page_t vm_phys_to_vm_page(vm_paddr_t pa);
		276
		277	static __inline vm_page_t vm_phys_to_vm_page(vm_paddr_t pa) {
		278	int i,j;
		279
		280	for (i = 0, j = 0; (phys_avail[i+1] <= pa) \|\| (phys_avail[i] > pa); i+= 2)
		281	j += atop(phys_avail[i+1] - phys_avail[i]);
		282
		283	return &vm_page_array[j + atop(pa - phys_avail[i])];
		284	}
275		285
276	#define VM_PAGE_TO_PHYS(entry) ((entry)->phys_addr)	286	#define VM_PAGE_TO_PHYS(entry) ((entry)->phys_addr)
277		287
278	#define PHYS_TO_VM_PAGE(pa) \	288	#define PHYS_TO_VM_PAGE(pa) \
279	(&vm_page_array[atop(pa) - first_page ])	289	vm_phys_to_vm_page(pa)
280		290
281	extern struct mtx vm_page_queue_mtx;	291	extern struct mtx vm_page_queue_mtx;
282	#define vm_page_lock_queues() mtx_lock(&vm_page_queue_mtx)	292	#define vm_page_lock_queues() mtx_lock(&vm_page_queue_mtx)