584 lines · 11.4 KB · C
RawDownload
#include "u.h"#include "../port/lib.h"#include "mem.h"#include "dat.h"#include "fns.h"#include "io.h"#include "ureg.h" enum {	MemUPA		= 0,	/* unbacked physical address */	MemUMB		= 1,	/* upper memory block (<16MB) */	MemRAM		= 2,	/* physical memory */	MemACPI		= 3,	/* ACPI tables */	MemReserved	= 4,	/* don't allocate */ 	KB = 1024,}; u32int	MemMin;		/* set by l.s */ void*rampage(void){	uintptr pa;		if(conf.mem[0].npage != 0)		return xspanalloc(BY2PG, BY2PG, 0); 	/*	 * Allocate from the map directly to make page tables.	 */	pa = memmapalloc(-1, BY2PG, BY2PG, MemRAM);	if(pa == -1 || cankaddr(pa) == 0)		panic("rampage: out of memory\n");	return KADDR(pa);} static voidmapkzero(uintptr base, uintptr len, int type){	uintptr flags, n; 	if(base < MemMin && base+len > MemMin){		mapkzero(base, MemMin-base, type);		len = base+len-MemMin;		base = MemMin;	} 	n = cankaddr(base);	if(n == 0)		return;	if(len > n)		len = n; 	switch(type){	default:		return;	case MemRAM:		if(base < MemMin)			return;		flags = PTEWRITE|PTEVALID;		break;	case MemUMB:		if(base < MemMin)			punmap(base+KZERO, len);		flags = PTEWRITE|PTEUNCACHED|PTEVALID;		break;	}#ifdef PTENOEXEC	flags |= PTENOEXEC;#endif	pmap(base|flags, base+KZERO, len);} static uintptrebdaseg(void){	uchar *bda; 	if(memcmp(KADDR(0xfffd9), "EISA", 4) != 0)		return 0;	bda = KADDR(0x400);	return ((bda[0x0f]<<8)|bda[0x0e]) << 4;} static uintptrconvmemsize(void){	uintptr top;	uchar *bda; 	bda = KADDR(0x400);	top = ((bda[0x14]<<8) | bda[0x13])*KB; 	if(top < 64*KB || top > 640*KB)		top = 640*KB;	/* sanity */ 	/* Reserved for BIOS tables */	top -= 1*KB; 	return top;} static voidlowraminit(void){	uintptr base, pa, len;	uchar *p; 	/*	 * Discover the memory bank information for conventional memory	 * (i.e. less than 640KB). The base is the first location after the	 * bootstrap processor MMU information and the limit is obtained from	 * the BIOS data area.	 */	base = PADDR(CPU0END);	pa = convmemsize();	if(base < pa)		memmapadd(base, pa-base, MemRAM); 	/* Reserve BIOS tables */	memmapadd(pa, 1*KB, MemReserved); 	/* Reserve EBDA */	if((pa = ebdaseg()) != 0)		memmapadd(pa, 1*KB, MemReserved);	memmapadd(0xA0000-1*KB, 1*KB, MemReserved); 	/* Reserve the VGA frame buffer */	umballoc(0xA0000, 128*KB, 0); 	/* Reserve VGA ROM */	memmapadd(0xC0000, 64*KB, MemReserved); 	/*	 * Scan the Upper Memory Blocks (0xD0000->0xF0000) for device BIOS ROMs.	 * This should start with a two-byte header of 0x55 0xAA, followed by a	 * byte giving the size of the ROM in 512-byte chunks.	 * These ROM's must start on a 2KB boundary.	 */	for(p = (uchar*)KADDR(0xD0000); p < (uchar*)KADDR(0xF0000); p += len){		len = 2*KB;		if(p[0] == 0x55 && p[1] == 0xAA){			if(p[2] != 0)				len = p[2]*512;			memmapadd(PADDR(p), len, MemReserved);			len = ROUND(len, 2*KB);		}	} 	/* Reserve BIOS ROM */	memmapadd(0xF0000, 64*KB, MemReserved);} intchecksum(void *v, int n){	uchar *p, s; 	s = 0;	p = v;	while(n-- > 0)		s += *p++;	return s;} static void*sigscan(uchar *addr, int len, char *sig, int size, int step){	uchar *e, *p;	int sl; 	sl = strlen(sig);	e = addr+len-(size > sl ? size : sl);	for(p = addr; p <= e; p += step){		if(memcmp(p, sig, sl) != 0)			continue;		if(size && checksum(p, size) != 0)			continue;		return p;	}	return nil;} void*sigsearch(char* signature, int size){	uintptr p;	void *r; 	/*	 * Search for the data structure:	 * 1) within the first KiB of the Extended BIOS Data Area (EBDA), or	 * 2) within the last KiB of system base memory if the EBDA segment	 *    is undefined, or	 * 3) within the BIOS ROM address space between 0xf0000 and 0xfffff	 *    (but will actually check 0xe0000 to 0xfffff).	 */	if((p = ebdaseg()) != 0){		if((r = sigscan(KADDR(p), 1*KB, signature, size, 16)) != nil)			return r;	}	if((r = sigscan(KADDR(convmemsize()), 1*KB, signature, size, 16)) != nil)		return r; 	/* hack for virtualbox: look in KiB below 0xa0000 */	if((r = sigscan(KADDR(0xA0000-1*KB), 1*KB, signature, size, 16)) != nil)		return r; 	return sigscan(KADDR(0xE0000), 128*KB, signature, size, 16);} void*rsdsearch(void){	static char signature[] = "RSD PTR ";	uintptr base, size;	uchar *v, *p; 	if((p = sigsearch(signature, 36)) != nil)		return p;	if((p = sigsearch(signature, 20)) != nil)		return p; 	for(base = memmapnext(-1, MemACPI); base != -1; base = memmapnext(base, MemACPI)){		size = memmapsize(base, 0);		if(size == 0 || size > 0x7fffffff)			continue;		if((v = vmap(base, size)) != nil){			p = sigscan(v, size, signature, 36, 4);			if(p == nil)				p = sigscan(v, size, signature, 20, 4);			vunmap(v, size);			if(p != nil)				return vmap(base + (p - v), 64);		}	}	return nil;} /* * Give out otherwise-unused physical address space * for use in configuring devices.  Note that upaalloc * does not map the physical address into virtual memory. * Call vmap to do that. */uvlongupaalloc(uvlong pa, uvlong size, uvlong align){	return memmapalloc(pa, size, align, MemUPA);} uvlongupaallocwin(uvlong pa, uvlong win, uvlong size, uvlong align){	uvlong a, base, top = pa + win; 	for(base = memmapnext(-1, MemUPA); base != -1 && base < top; base = memmapnext(base, MemUPA)){		if(base < pa){			if(pa >= base + memmapsize(base, 0))				continue;			base = pa;		}		a = upaalloc(base, size, align);		if(a != -1)			return a;	}	return -1ULL;} voidupafree(uvlong pa, uvlong size){	memmapfree(pa, size, MemUPA);} /* * Allocate memory from the upper memory blocks. */ulongumballoc(ulong pa, ulong size, ulong align){	return (ulong)memmapalloc(pa == -1UL ? -1ULL : (uvlong)pa, size, align, MemUMB);} voidumbfree(ulong pa, ulong size){	memmapfree(pa, size, MemUMB);} static voidumbexclude(void){	ulong pa, size;	char *op, *p, *rptr; 	if((p = getconf("umbexclude")) == nil)		return; 	while(p && *p != '\0' && *p != '\n'){		op = p;		pa = strtoul(p, &rptr, 0);		if(rptr == nil || rptr == p || *rptr != '-'){			print("umbexclude: invalid argument <%s>\n", op);			break;		}		p = rptr+1; 		size = strtoul(p, &rptr, 0) - pa + 1;		if(size <= 0){			print("umbexclude: bad range <%s>\n", op);			break;		}		if(rptr != nil && *rptr == ',')			*rptr++ = '\0';		p = rptr; 		memmapalloc(pa, size, 0, MemUMB);	}} static voidmtrrexclude(int type, char *expect){	uvlong base, top, next, pa;	char *attr; 	for(base = memmapnext(-1, type); base != -1; base = memmapnext(base, type)){		top = base + memmapsize(base, 0);		for(pa = base; pa < top; pa = next){			next = top;			attr = mtrrattr(pa, &next);			if(attr != nil && strcmp(attr, expect) != 0){				if(next > top)					next = top;				memmapadd(pa, next - pa, MemReserved);			}			base = pa;		}	}} static inte820scan(void){	uvlong base, top, size;	int type;	char *s; 	/* passed by bootloader */	if((s = getconf("*e820")) == nil)		if((s = getconf("e820")) == nil)			return -1; 	for(;;){		while(*s == ' ')			s++;		if(*s == 0)			break;		type = 1;		if(s[1] == ' '){	/* new format */			type = s[0] - '0';			s += 2;		}		base = strtoull(s, &s, 16);		if(*s != ' ')			break;		top  = strtoull(s, &s, 16);		if(*s != ' ' && *s != 0)			break;		if(base >= top)			continue;		switch(type){		case 1:			memmapadd(base, top - base, MemRAM);			break;		case 3:			memmapadd(base, top - base, MemACPI);			break;		default:			memmapadd(base, top - base, MemReserved);		}	} 	/* RAM needs to be writeback */	mtrrexclude(MemRAM, "wb"); 	for(base = memmapnext(-1, MemRAM); base != -1; base = memmapnext(base, MemRAM)){		size = memmapsize(base, BY2PG) & ~(BY2PG-1);		if(size != 0)			mapkzero(PGROUND(base), size, MemRAM);	} 	return 0;} static voidramscan(uintptr pa, uintptr top, uintptr chunk){	ulong save, pat, seed, *v, *k0;	int i, n, w;	char *attr; 	pa += chunk-1;	pa &= ~(chunk-1);	top &= ~(chunk-1); 	n = chunk/sizeof(*v);	w = BY2PG/sizeof(*v); 	k0 = KADDR(0);	save = *k0; 	pat = 0x12345678UL;	for(; pa < top; pa += chunk){		attr = mtrrattr(pa, nil);		if(attr != nil && strcmp(attr, "wb") != 0)			goto Skip; 		/* write pattern */		seed = pat;		if((v = vmap(pa, chunk)) == nil)			continue;		for(i = 0; i < n; i += w){			pat += 0x3141526UL;			v[i] = pat;			*k0 = ~pat;			if(v[i] != pat)				goto Bad;		}		vunmap(v, chunk); 		/* verify pattern */		pat = seed;		if((v = vmap(pa, chunk)) == nil)			continue;		for(i = 0; i < n; i += w){			pat += 0x3141526UL;			if(v[i] != pat)				goto Bad;		}		vunmap(v, chunk); 		memmapadd(pa, chunk, MemRAM);		mapkzero(pa, chunk, MemRAM);		continue; 	Bad:		vunmap(v, chunk); 	Skip:		if(pa+chunk <= 16*MB)			memmapadd(pa, chunk, MemUMB); 		/*		 * If we encounter a chunk of missing memory		 * at a sufficiently high offset, call it the end of		 * memory.  Otherwise we run the risk of thinking		 * that video memory is real RAM.		 */		if(pa >= 32*MB)			break;	} 	*k0 = save;} /* * Sort out initial memory map and discover RAM. */voidmeminit0(void){	/*	 * Add the already mapped memory after the kernel.	 */	if(MemMin < PADDR(PGROUND((uintptr)end)))		panic("kernel too big");	memmapadd(PADDR(PGROUND((uintptr)end)), MemMin-PADDR(PGROUND((uintptr)end)), MemRAM); 	/*	 * Memory between KTZERO and end is the kernel itself.	 */	memreserve(PADDR(KTZERO), PADDR(PGROUND((uintptr)end))-PADDR(KTZERO)); 	/*	 * Memory below CPU0END is reserved for the kernel.	 */	memreserve(0, PADDR(CPU0END)); 	/*	 * Addresses below 16MB default to be upper	 * memory blocks usable for ISA devices.	 */	memmapadd(0, 16*MB, MemUMB); 	/*	 * Everything between 16MB and 4GB defaults	 * to unbacked physical addresses usable for

Lines 1–500 of 584.

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t