vm: use assert() instead of vm_assert(); remove vm_assert().
This commit is contained in:
parent
c78250332d
commit
27fc7ab1f3
13 changed files with 259 additions and 271 deletions
|
@ -49,8 +49,8 @@ addr_avl addravl;
|
||||||
/* Used for sanity check. */
|
/* Used for sanity check. */
|
||||||
PRIVATE phys_bytes mem_low, mem_high;
|
PRIVATE phys_bytes mem_low, mem_high;
|
||||||
#define assert_range(addr, len) \
|
#define assert_range(addr, len) \
|
||||||
vm_assert((addr) >= mem_low); \
|
assert((addr) >= mem_low); \
|
||||||
vm_assert((addr) + (len) - 1 <= mem_high);
|
assert((addr) + (len) - 1 <= mem_high);
|
||||||
|
|
||||||
struct hole {
|
struct hole {
|
||||||
struct hole *h_next; /* pointer to next entry on the list */
|
struct hole *h_next; /* pointer to next entry on the list */
|
||||||
|
@ -104,7 +104,7 @@ int line;
|
||||||
if(!(c)) { \
|
if(!(c)) { \
|
||||||
printf("holes_sanity_f:%s:%d: %s failed\n", file, line, #c); \
|
printf("holes_sanity_f:%s:%d: %s failed\n", file, line, #c); \
|
||||||
util_stacktrace(); \
|
util_stacktrace(); \
|
||||||
panic("vm_assert failed"); } \
|
panic("assert failed"); } \
|
||||||
}
|
}
|
||||||
|
|
||||||
int h, c = 0, n = 0;
|
int h, c = 0, n = 0;
|
||||||
|
@ -184,7 +184,7 @@ PUBLIC phys_clicks alloc_mem(phys_clicks clicks, u32_t memflags)
|
||||||
}
|
}
|
||||||
|
|
||||||
if(vm_paged) {
|
if(vm_paged) {
|
||||||
vm_assert(CLICK_SIZE == VM_PAGE_SIZE);
|
assert(CLICK_SIZE == VM_PAGE_SIZE);
|
||||||
mem = alloc_pages(clicks, memflags, NULL);
|
mem = alloc_pages(clicks, memflags, NULL);
|
||||||
} else {
|
} else {
|
||||||
CHECKHOLES;
|
CHECKHOLES;
|
||||||
|
@ -255,7 +255,7 @@ CHECKHOLES;
|
||||||
if (clicks == 0) return;
|
if (clicks == 0) return;
|
||||||
|
|
||||||
if(vm_paged) {
|
if(vm_paged) {
|
||||||
vm_assert(CLICK_SIZE == VM_PAGE_SIZE);
|
assert(CLICK_SIZE == VM_PAGE_SIZE);
|
||||||
free_pages(base, clicks);
|
free_pages(base, clicks);
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
@ -408,10 +408,10 @@ PRIVATE void sanitycheck(void)
|
||||||
addr_start_iter_least(&addravl, &iter);
|
addr_start_iter_least(&addravl, &iter);
|
||||||
while((p=addr_get_iter(&iter))) {
|
while((p=addr_get_iter(&iter))) {
|
||||||
SLABSANE(p);
|
SLABSANE(p);
|
||||||
vm_assert(p->size > 0);
|
assert(p->size > 0);
|
||||||
if(prevp) {
|
if(prevp) {
|
||||||
vm_assert(prevp->addr < p->addr);
|
assert(prevp->addr < p->addr);
|
||||||
vm_assert(prevp->addr + p->addr < p->addr);
|
assert(prevp->addr + p->addr < p->addr);
|
||||||
}
|
}
|
||||||
addr_incr_iter(&iter);
|
addr_incr_iter(&iter);
|
||||||
}
|
}
|
||||||
|
@ -471,7 +471,7 @@ PRIVATE PUBLIC phys_bytes alloc_pages(int pages, int memflags, phys_bytes *len)
|
||||||
|
|
||||||
while((pr = addr_get_iter(&iter))) {
|
while((pr = addr_get_iter(&iter))) {
|
||||||
SLABSANE(pr);
|
SLABSANE(pr);
|
||||||
vm_assert(pr->size > 0);
|
assert(pr->size > 0);
|
||||||
if(pr->size >= pages || (memflags & PAF_FIRSTBLOCK)) {
|
if(pr->size >= pages || (memflags & PAF_FIRSTBLOCK)) {
|
||||||
if(memflags & PAF_LOWER16MB) {
|
if(memflags & PAF_LOWER16MB) {
|
||||||
if(pr->addr + pages > boundary16)
|
if(pr->addr + pages > boundary16)
|
||||||
|
@ -509,7 +509,7 @@ PRIVATE PUBLIC phys_bytes alloc_pages(int pages, int memflags, phys_bytes *len)
|
||||||
SLABSANE(pr);
|
SLABSANE(pr);
|
||||||
|
|
||||||
if(memflags & PAF_FIRSTBLOCK) {
|
if(memflags & PAF_FIRSTBLOCK) {
|
||||||
vm_assert(len);
|
assert(len);
|
||||||
/* block doesn't have to as big as requested;
|
/* block doesn't have to as big as requested;
|
||||||
* return its size though.
|
* return its size though.
|
||||||
*/
|
*/
|
||||||
|
@ -527,12 +527,12 @@ PRIVATE PUBLIC phys_bytes alloc_pages(int pages, int memflags, phys_bytes *len)
|
||||||
/* Allocated chunk is off the end. */
|
/* Allocated chunk is off the end. */
|
||||||
mem = pr->addr + pr->size - pages;
|
mem = pr->addr + pr->size - pages;
|
||||||
|
|
||||||
vm_assert(pr->size >= pages);
|
assert(pr->size >= pages);
|
||||||
if(pr->size == pages) {
|
if(pr->size == pages) {
|
||||||
pagerange_t *prr;
|
pagerange_t *prr;
|
||||||
prr = addr_remove(&addravl, pr->addr);
|
prr = addr_remove(&addravl, pr->addr);
|
||||||
vm_assert(prr);
|
assert(prr);
|
||||||
vm_assert(prr == pr);
|
assert(prr == pr);
|
||||||
SLABFREE(pr);
|
SLABFREE(pr);
|
||||||
#if SANITYCHECKS
|
#if SANITYCHECKS
|
||||||
wantnodes--;
|
wantnodes--;
|
||||||
|
@ -556,8 +556,8 @@ PRIVATE PUBLIC phys_bytes alloc_pages(int pages, int memflags, phys_bytes *len)
|
||||||
printf("pages start: %d req: %d final: %d\n",
|
printf("pages start: %d req: %d final: %d\n",
|
||||||
firstpages, pages, finalpages);
|
firstpages, pages, finalpages);
|
||||||
}
|
}
|
||||||
vm_assert(finalnodes == wantnodes);
|
assert(finalnodes == wantnodes);
|
||||||
vm_assert(finalpages == wantpages);
|
assert(finalpages == wantpages);
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
return mem;
|
return mem;
|
||||||
|
@ -581,7 +581,7 @@ PRIVATE void free_pages(phys_bytes pageno, int npages)
|
||||||
wantpages = firstpages + npages;
|
wantpages = firstpages + npages;
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
vm_assert(!addr_search(&addravl, pageno, AVL_EQUAL));
|
assert(!addr_search(&addravl, pageno, AVL_EQUAL));
|
||||||
|
|
||||||
/* try to merge with higher neighbour */
|
/* try to merge with higher neighbour */
|
||||||
if((pr=addr_search(&addravl, pageno+npages, AVL_EQUAL))) {
|
if((pr=addr_search(&addravl, pageno+npages, AVL_EQUAL))) {
|
||||||
|
@ -598,7 +598,7 @@ PRIVATE void free_pages(phys_bytes pageno, int npages)
|
||||||
|
|
||||||
sanitycheck();
|
sanitycheck();
|
||||||
#endif
|
#endif
|
||||||
vm_assert(npages > 0);
|
assert(npages > 0);
|
||||||
USE(pr, pr->addr = pageno;
|
USE(pr, pr->addr = pageno;
|
||||||
pr->size = npages;);
|
pr->size = npages;);
|
||||||
addr_insert(&addravl, pr);
|
addr_insert(&addravl, pr);
|
||||||
|
@ -609,8 +609,8 @@ PRIVATE void free_pages(phys_bytes pageno, int npages)
|
||||||
|
|
||||||
addr_start_iter(&addravl, &iter, pr->addr, AVL_EQUAL);
|
addr_start_iter(&addravl, &iter, pr->addr, AVL_EQUAL);
|
||||||
p = addr_get_iter(&iter);
|
p = addr_get_iter(&iter);
|
||||||
vm_assert(p);
|
assert(p);
|
||||||
vm_assert(p == pr);
|
assert(p == pr);
|
||||||
|
|
||||||
addr_decr_iter(&iter);
|
addr_decr_iter(&iter);
|
||||||
if((p = addr_get_iter(&iter))) {
|
if((p = addr_get_iter(&iter))) {
|
||||||
|
@ -630,8 +630,8 @@ PRIVATE void free_pages(phys_bytes pageno, int npages)
|
||||||
memstats(&finalnodes, &finalpages, &largest);
|
memstats(&finalnodes, &finalpages, &largest);
|
||||||
sanitycheck();
|
sanitycheck();
|
||||||
|
|
||||||
vm_assert(finalnodes == wantnodes);
|
assert(finalnodes == wantnodes);
|
||||||
vm_assert(finalpages == wantpages);
|
assert(finalpages == wantpages);
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -864,9 +864,9 @@ int usedpages_add_f(phys_bytes addr, phys_bytes len, char *file, int line)
|
||||||
if(!incheck)
|
if(!incheck)
|
||||||
return OK;
|
return OK;
|
||||||
|
|
||||||
vm_assert(!(addr % VM_PAGE_SIZE));
|
assert(!(addr % VM_PAGE_SIZE));
|
||||||
vm_assert(!(len % VM_PAGE_SIZE));
|
assert(!(len % VM_PAGE_SIZE));
|
||||||
vm_assert(len > 0);
|
assert(len > 0);
|
||||||
assert_range(addr, len);
|
assert_range(addr, len);
|
||||||
|
|
||||||
pagestart = addr / VM_PAGE_SIZE;
|
pagestart = addr / VM_PAGE_SIZE;
|
||||||
|
@ -874,8 +874,8 @@ int usedpages_add_f(phys_bytes addr, phys_bytes len, char *file, int line)
|
||||||
|
|
||||||
while(pages > 0) {
|
while(pages > 0) {
|
||||||
phys_bytes thisaddr;
|
phys_bytes thisaddr;
|
||||||
vm_assert(pagestart > 0);
|
assert(pagestart > 0);
|
||||||
vm_assert(pagestart < MAXPAGES);
|
assert(pagestart < MAXPAGES);
|
||||||
thisaddr = pagestart * VM_PAGE_SIZE;
|
thisaddr = pagestart * VM_PAGE_SIZE;
|
||||||
if(GET_BIT(pagemap, pagestart)) {
|
if(GET_BIT(pagemap, pagestart)) {
|
||||||
int i;
|
int i;
|
||||||
|
@ -901,8 +901,8 @@ struct memlist *alloc_mem_in_list(phys_bytes bytes, u32_t flags)
|
||||||
phys_bytes rempages;
|
phys_bytes rempages;
|
||||||
struct memlist *head = NULL, *ml;
|
struct memlist *head = NULL, *ml;
|
||||||
|
|
||||||
vm_assert(bytes > 0);
|
assert(bytes > 0);
|
||||||
vm_assert(!(bytes % VM_PAGE_SIZE));
|
assert(!(bytes % VM_PAGE_SIZE));
|
||||||
|
|
||||||
rempages = bytes / VM_PAGE_SIZE;
|
rempages = bytes / VM_PAGE_SIZE;
|
||||||
|
|
||||||
|
@ -923,8 +923,8 @@ struct memlist *alloc_mem_in_list(phys_bytes bytes, u32_t flags)
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
|
|
||||||
vm_assert(gotpages <= rempages);
|
assert(gotpages <= rempages);
|
||||||
vm_assert(gotpages > 0);
|
assert(gotpages > 0);
|
||||||
|
|
||||||
if(!(SLABALLOC(ml))) {
|
if(!(SLABALLOC(ml))) {
|
||||||
free_mem_list(head, 1);
|
free_mem_list(head, 1);
|
||||||
|
@ -941,8 +941,8 @@ struct memlist *alloc_mem_in_list(phys_bytes bytes, u32_t flags)
|
||||||
} while(rempages > 0);
|
} while(rempages > 0);
|
||||||
|
|
||||||
for(ml = head; ml; ml = ml->next) {
|
for(ml = head; ml; ml = ml->next) {
|
||||||
vm_assert(ml->phys);
|
assert(ml->phys);
|
||||||
vm_assert(ml->length);
|
assert(ml->length);
|
||||||
}
|
}
|
||||||
|
|
||||||
return head;
|
return head;
|
||||||
|
@ -956,8 +956,8 @@ void free_mem_list(struct memlist *list, int all)
|
||||||
while(list) {
|
while(list) {
|
||||||
struct memlist *next;
|
struct memlist *next;
|
||||||
next = list->next;
|
next = list->next;
|
||||||
vm_assert(!(list->phys % VM_PAGE_SIZE));
|
assert(!(list->phys % VM_PAGE_SIZE));
|
||||||
vm_assert(!(list->length % VM_PAGE_SIZE));
|
assert(!(list->length % VM_PAGE_SIZE));
|
||||||
if(all)
|
if(all)
|
||||||
free_pages(list->phys / VM_PAGE_SIZE,
|
free_pages(list->phys / VM_PAGE_SIZE,
|
||||||
list->length / VM_PAGE_SIZE);
|
list->length / VM_PAGE_SIZE);
|
||||||
|
@ -972,7 +972,7 @@ void free_mem_list(struct memlist *list, int all)
|
||||||
void print_mem_list(struct memlist *list)
|
void print_mem_list(struct memlist *list)
|
||||||
{
|
{
|
||||||
while(list) {
|
while(list) {
|
||||||
vm_assert(list->length > 0);
|
assert(list->length > 0);
|
||||||
printf("0x%lx-0x%lx", list->phys, list->phys+list->length-1);
|
printf("0x%lx-0x%lx", list->phys, list->phys+list->length-1);
|
||||||
printf(" ");
|
printf(" ");
|
||||||
list = list->next;
|
list = list->next;
|
||||||
|
|
|
@ -160,10 +160,10 @@ PRIVATE u32_t findhole(pt_t *pt, u32_t vmin, u32_t vmax)
|
||||||
static u32_t lastv = 0;
|
static u32_t lastv = 0;
|
||||||
|
|
||||||
/* Input sanity check. */
|
/* Input sanity check. */
|
||||||
vm_assert(vmin + I386_PAGE_SIZE >= vmin);
|
assert(vmin + I386_PAGE_SIZE >= vmin);
|
||||||
vm_assert(vmax >= vmin + I386_PAGE_SIZE);
|
assert(vmax >= vmin + I386_PAGE_SIZE);
|
||||||
vm_assert((vmin % I386_PAGE_SIZE) == 0);
|
assert((vmin % I386_PAGE_SIZE) == 0);
|
||||||
vm_assert((vmax % I386_PAGE_SIZE) == 0);
|
assert((vmax % I386_PAGE_SIZE) == 0);
|
||||||
|
|
||||||
#if SANITYCHECKS
|
#if SANITYCHECKS
|
||||||
curv = ((u32_t) random()) % ((vmax - vmin)/I386_PAGE_SIZE);
|
curv = ((u32_t) random()) % ((vmax - vmin)/I386_PAGE_SIZE);
|
||||||
|
@ -180,8 +180,8 @@ PRIVATE u32_t findhole(pt_t *pt, u32_t vmin, u32_t vmax)
|
||||||
while(curv < vmax) {
|
while(curv < vmax) {
|
||||||
int pte;
|
int pte;
|
||||||
|
|
||||||
vm_assert(curv >= vmin);
|
assert(curv >= vmin);
|
||||||
vm_assert(curv < vmax);
|
assert(curv < vmax);
|
||||||
|
|
||||||
pde = I386_VM_PDE(curv);
|
pde = I386_VM_PDE(curv);
|
||||||
pte = I386_VM_PTE(curv);
|
pte = I386_VM_PTE(curv);
|
||||||
|
@ -210,10 +210,10 @@ PRIVATE u32_t findhole(pt_t *pt, u32_t vmin, u32_t vmax)
|
||||||
*===========================================================================*/
|
*===========================================================================*/
|
||||||
PRIVATE void vm_freepages(vir_bytes vir, vir_bytes phys, int pages, int reason)
|
PRIVATE void vm_freepages(vir_bytes vir, vir_bytes phys, int pages, int reason)
|
||||||
{
|
{
|
||||||
vm_assert(reason >= 0 && reason < VMP_CATEGORIES);
|
assert(reason >= 0 && reason < VMP_CATEGORIES);
|
||||||
if(vir >= vmprocess->vm_stacktop) {
|
if(vir >= vmprocess->vm_stacktop) {
|
||||||
vm_assert(!(vir % I386_PAGE_SIZE));
|
assert(!(vir % I386_PAGE_SIZE));
|
||||||
vm_assert(!(phys % I386_PAGE_SIZE));
|
assert(!(phys % I386_PAGE_SIZE));
|
||||||
free_mem(ABS2CLICK(phys), pages);
|
free_mem(ABS2CLICK(phys), pages);
|
||||||
if(pt_writemap(&vmprocess->vm_pt, arch_vir2map(vmprocess, vir),
|
if(pt_writemap(&vmprocess->vm_pt, arch_vir2map(vmprocess, vir),
|
||||||
MAP_NONE, pages*I386_PAGE_SIZE, 0, WMF_OVERWRITE) != OK)
|
MAP_NONE, pages*I386_PAGE_SIZE, 0, WMF_OVERWRITE) != OK)
|
||||||
|
@ -239,7 +239,7 @@ PRIVATE void vm_freepages(vir_bytes vir, vir_bytes phys, int pages, int reason)
|
||||||
PRIVATE void *vm_getsparepage(u32_t *phys)
|
PRIVATE void *vm_getsparepage(u32_t *phys)
|
||||||
{
|
{
|
||||||
int s;
|
int s;
|
||||||
vm_assert(missing_spares >= 0 && missing_spares <= SPAREPAGES);
|
assert(missing_spares >= 0 && missing_spares <= SPAREPAGES);
|
||||||
for(s = 0; s < SPAREPAGES; s++) {
|
for(s = 0; s < SPAREPAGES; s++) {
|
||||||
if(sparepages[s].page) {
|
if(sparepages[s].page) {
|
||||||
void *sp;
|
void *sp;
|
||||||
|
@ -247,7 +247,7 @@ PRIVATE void *vm_getsparepage(u32_t *phys)
|
||||||
*phys = sparepages[s].phys;
|
*phys = sparepages[s].phys;
|
||||||
sparepages[s].page = NULL;
|
sparepages[s].page = NULL;
|
||||||
missing_spares++;
|
missing_spares++;
|
||||||
vm_assert(missing_spares >= 0 && missing_spares <= SPAREPAGES);
|
assert(missing_spares >= 0 && missing_spares <= SPAREPAGES);
|
||||||
return sp;
|
return sp;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -261,15 +261,15 @@ PRIVATE void *vm_checkspares(void)
|
||||||
{
|
{
|
||||||
int s, n = 0;
|
int s, n = 0;
|
||||||
static int total = 0, worst = 0;
|
static int total = 0, worst = 0;
|
||||||
vm_assert(missing_spares >= 0 && missing_spares <= SPAREPAGES);
|
assert(missing_spares >= 0 && missing_spares <= SPAREPAGES);
|
||||||
for(s = 0; s < SPAREPAGES && missing_spares > 0; s++)
|
for(s = 0; s < SPAREPAGES && missing_spares > 0; s++)
|
||||||
if(!sparepages[s].page) {
|
if(!sparepages[s].page) {
|
||||||
n++;
|
n++;
|
||||||
if((sparepages[s].page = vm_allocpage(&sparepages[s].phys,
|
if((sparepages[s].page = vm_allocpage(&sparepages[s].phys,
|
||||||
VMP_SPARE))) {
|
VMP_SPARE))) {
|
||||||
missing_spares--;
|
missing_spares--;
|
||||||
vm_assert(missing_spares >= 0);
|
assert(missing_spares >= 0);
|
||||||
vm_assert(missing_spares <= SPAREPAGES);
|
assert(missing_spares <= SPAREPAGES);
|
||||||
} else {
|
} else {
|
||||||
printf("VM: warning: couldn't get new spare page\n");
|
printf("VM: warning: couldn't get new spare page\n");
|
||||||
}
|
}
|
||||||
|
@ -294,12 +294,12 @@ PUBLIC void *vm_allocpage(phys_bytes *phys, int reason)
|
||||||
void *ret;
|
void *ret;
|
||||||
|
|
||||||
pt = &vmprocess->vm_pt;
|
pt = &vmprocess->vm_pt;
|
||||||
vm_assert(reason >= 0 && reason < VMP_CATEGORIES);
|
assert(reason >= 0 && reason < VMP_CATEGORIES);
|
||||||
|
|
||||||
level++;
|
level++;
|
||||||
|
|
||||||
vm_assert(level >= 1);
|
assert(level >= 1);
|
||||||
vm_assert(level <= 2);
|
assert(level <= 2);
|
||||||
|
|
||||||
if(level > 1 || !(vmprocess->vm_flags & VMF_HASPT) || !meminit_done) {
|
if(level > 1 || !(vmprocess->vm_flags & VMF_HASPT) || !meminit_done) {
|
||||||
int r;
|
int r;
|
||||||
|
@ -370,7 +370,7 @@ PUBLIC void vm_pagelock(void *vir, int lockflag)
|
||||||
pt = &vmprocess->vm_pt;
|
pt = &vmprocess->vm_pt;
|
||||||
m = arch_vir2map(vmprocess, (vir_bytes) vir);
|
m = arch_vir2map(vmprocess, (vir_bytes) vir);
|
||||||
|
|
||||||
vm_assert(!(m % I386_PAGE_SIZE));
|
assert(!(m % I386_PAGE_SIZE));
|
||||||
|
|
||||||
if(!lockflag)
|
if(!lockflag)
|
||||||
flags |= I386_VM_WRITE;
|
flags |= I386_VM_WRITE;
|
||||||
|
@ -443,14 +443,14 @@ PRIVATE int pt_ptalloc(pt_t *pt, int pde, u32_t flags)
|
||||||
u32_t pt_phys;
|
u32_t pt_phys;
|
||||||
|
|
||||||
/* Argument must make sense. */
|
/* Argument must make sense. */
|
||||||
vm_assert(pde >= 0 && pde < I386_VM_DIR_ENTRIES);
|
assert(pde >= 0 && pde < I386_VM_DIR_ENTRIES);
|
||||||
vm_assert(!(flags & ~(PTF_ALLFLAGS)));
|
assert(!(flags & ~(PTF_ALLFLAGS)));
|
||||||
|
|
||||||
/* We don't expect to overwrite page directory entry, nor
|
/* We don't expect to overwrite page directory entry, nor
|
||||||
* storage for the page table.
|
* storage for the page table.
|
||||||
*/
|
*/
|
||||||
vm_assert(!(pt->pt_dir[pde] & I386_VM_PRESENT));
|
assert(!(pt->pt_dir[pde] & I386_VM_PRESENT));
|
||||||
vm_assert(!pt->pt_pt[pde]);
|
assert(!pt->pt_pt[pde]);
|
||||||
|
|
||||||
/* Get storage for the page table. */
|
/* Get storage for the page table. */
|
||||||
if(!(pt->pt_pt[pde] = vm_allocpage(&pt_phys, VMP_PAGETABLE)))
|
if(!(pt->pt_pt[pde] = vm_allocpage(&pt_phys, VMP_PAGETABLE)))
|
||||||
|
@ -510,8 +510,8 @@ PUBLIC int pt_writemap(pt_t *pt, vir_bytes v, phys_bytes physaddr,
|
||||||
if(writemapflags & WMF_VERIFY)
|
if(writemapflags & WMF_VERIFY)
|
||||||
verify = 1;
|
verify = 1;
|
||||||
|
|
||||||
vm_assert(!(bytes % I386_PAGE_SIZE));
|
assert(!(bytes % I386_PAGE_SIZE));
|
||||||
vm_assert(!(flags & ~(PTF_ALLFLAGS)));
|
assert(!(flags & ~(PTF_ALLFLAGS)));
|
||||||
|
|
||||||
pages = bytes / I386_PAGE_SIZE;
|
pages = bytes / I386_PAGE_SIZE;
|
||||||
|
|
||||||
|
@ -519,8 +519,8 @@ PUBLIC int pt_writemap(pt_t *pt, vir_bytes v, phys_bytes physaddr,
|
||||||
* what's actually written into the PTE if I386_VM_PRESENT
|
* what's actually written into the PTE if I386_VM_PRESENT
|
||||||
* isn't on, so we can just write MAP_NONE into it.
|
* isn't on, so we can just write MAP_NONE into it.
|
||||||
*/
|
*/
|
||||||
vm_assert(physaddr == MAP_NONE || (flags & I386_VM_PRESENT));
|
assert(physaddr == MAP_NONE || (flags & I386_VM_PRESENT));
|
||||||
vm_assert(physaddr != MAP_NONE || !flags);
|
assert(physaddr != MAP_NONE || !flags);
|
||||||
|
|
||||||
finalpde = I386_VM_PDE(v + I386_PAGE_SIZE * pages);
|
finalpde = I386_VM_PDE(v + I386_PAGE_SIZE * pages);
|
||||||
|
|
||||||
|
@ -530,15 +530,15 @@ PUBLIC int pt_writemap(pt_t *pt, vir_bytes v, phys_bytes physaddr,
|
||||||
* sized leaps.
|
* sized leaps.
|
||||||
*/
|
*/
|
||||||
for(pdecheck = I386_VM_PDE(v); pdecheck <= finalpde; pdecheck++) {
|
for(pdecheck = I386_VM_PDE(v); pdecheck <= finalpde; pdecheck++) {
|
||||||
vm_assert(pdecheck >= 0 && pdecheck < I386_VM_DIR_ENTRIES);
|
assert(pdecheck >= 0 && pdecheck < I386_VM_DIR_ENTRIES);
|
||||||
vm_assert(!(pt->pt_dir[pdecheck] & I386_VM_BIGPAGE));
|
assert(!(pt->pt_dir[pdecheck] & I386_VM_BIGPAGE));
|
||||||
if(!(pt->pt_dir[pdecheck] & I386_VM_PRESENT)) {
|
if(!(pt->pt_dir[pdecheck] & I386_VM_PRESENT)) {
|
||||||
int r;
|
int r;
|
||||||
if(verify) {
|
if(verify) {
|
||||||
printf("pt_writemap verify: no pde %d\n", pdecheck);
|
printf("pt_writemap verify: no pde %d\n", pdecheck);
|
||||||
return EFAULT;
|
return EFAULT;
|
||||||
}
|
}
|
||||||
vm_assert(!pt->pt_dir[pdecheck]);
|
assert(!pt->pt_dir[pdecheck]);
|
||||||
if((r=pt_ptalloc(pt, pdecheck, flags)) != OK) {
|
if((r=pt_ptalloc(pt, pdecheck, flags)) != OK) {
|
||||||
/* Couldn't do (complete) mapping.
|
/* Couldn't do (complete) mapping.
|
||||||
* Don't bother freeing any previously
|
* Don't bother freeing any previously
|
||||||
|
@ -551,7 +551,7 @@ PUBLIC int pt_writemap(pt_t *pt, vir_bytes v, phys_bytes physaddr,
|
||||||
return r;
|
return r;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
vm_assert(pt->pt_dir[pdecheck] & I386_VM_PRESENT);
|
assert(pt->pt_dir[pdecheck] & I386_VM_PRESENT);
|
||||||
}
|
}
|
||||||
|
|
||||||
/* Now write in them. */
|
/* Now write in them. */
|
||||||
|
@ -560,23 +560,23 @@ PUBLIC int pt_writemap(pt_t *pt, vir_bytes v, phys_bytes physaddr,
|
||||||
int pde = I386_VM_PDE(v);
|
int pde = I386_VM_PDE(v);
|
||||||
int pte = I386_VM_PTE(v);
|
int pte = I386_VM_PTE(v);
|
||||||
|
|
||||||
vm_assert(!(v % I386_PAGE_SIZE));
|
assert(!(v % I386_PAGE_SIZE));
|
||||||
vm_assert(pte >= 0 && pte < I386_VM_PT_ENTRIES);
|
assert(pte >= 0 && pte < I386_VM_PT_ENTRIES);
|
||||||
vm_assert(pde >= 0 && pde < I386_VM_DIR_ENTRIES);
|
assert(pde >= 0 && pde < I386_VM_DIR_ENTRIES);
|
||||||
|
|
||||||
/* Page table has to be there. */
|
/* Page table has to be there. */
|
||||||
vm_assert(pt->pt_dir[pde] & I386_VM_PRESENT);
|
assert(pt->pt_dir[pde] & I386_VM_PRESENT);
|
||||||
|
|
||||||
/* Make sure page directory entry for this page table
|
/* Make sure page directory entry for this page table
|
||||||
* is marked present and page table entry is available.
|
* is marked present and page table entry is available.
|
||||||
*/
|
*/
|
||||||
vm_assert((pt->pt_dir[pde] & I386_VM_PRESENT));
|
assert((pt->pt_dir[pde] & I386_VM_PRESENT));
|
||||||
vm_assert(pt->pt_pt[pde]);
|
assert(pt->pt_pt[pde]);
|
||||||
|
|
||||||
#if SANITYCHECKS
|
#if SANITYCHECKS
|
||||||
/* We don't expect to overwrite a page. */
|
/* We don't expect to overwrite a page. */
|
||||||
if(!(writemapflags & (WMF_OVERWRITE|WMF_VERIFY)))
|
if(!(writemapflags & (WMF_OVERWRITE|WMF_VERIFY)))
|
||||||
vm_assert(!(pt->pt_pt[pde][pte] & I386_VM_PRESENT));
|
assert(!(pt->pt_pt[pde][pte] & I386_VM_PRESENT));
|
||||||
#endif
|
#endif
|
||||||
if(writemapflags & (WMF_WRITEFLAGSONLY|WMF_FREE)) {
|
if(writemapflags & (WMF_WRITEFLAGSONLY|WMF_FREE)) {
|
||||||
physaddr = pt->pt_pt[pde][pte] & I386_VM_ADDR_MASK;
|
physaddr = pt->pt_pt[pde][pte] & I386_VM_ADDR_MASK;
|
||||||
|
@ -610,7 +610,7 @@ PUBLIC int pt_writemap(pt_t *pt, vir_bytes v, phys_bytes physaddr,
|
||||||
} else {
|
} else {
|
||||||
/* Write pagetable entry. */
|
/* Write pagetable entry. */
|
||||||
#if SANITYCHECKS
|
#if SANITYCHECKS
|
||||||
vm_assert(vm_addrok(pt->pt_pt[pde], 1));
|
assert(vm_addrok(pt->pt_pt[pde], 1));
|
||||||
#endif
|
#endif
|
||||||
pt->pt_pt[pde][pte] = entry;
|
pt->pt_pt[pde][pte] = entry;
|
||||||
}
|
}
|
||||||
|
@ -630,7 +630,7 @@ PUBLIC int pt_checkrange(pt_t *pt, vir_bytes v, size_t bytes,
|
||||||
{
|
{
|
||||||
int p, pages, pde;
|
int p, pages, pde;
|
||||||
|
|
||||||
vm_assert(!(bytes % I386_PAGE_SIZE));
|
assert(!(bytes % I386_PAGE_SIZE));
|
||||||
|
|
||||||
pages = bytes / I386_PAGE_SIZE;
|
pages = bytes / I386_PAGE_SIZE;
|
||||||
|
|
||||||
|
@ -639,9 +639,9 @@ PUBLIC int pt_checkrange(pt_t *pt, vir_bytes v, size_t bytes,
|
||||||
int pde = I386_VM_PDE(v);
|
int pde = I386_VM_PDE(v);
|
||||||
int pte = I386_VM_PTE(v);
|
int pte = I386_VM_PTE(v);
|
||||||
|
|
||||||
vm_assert(!(v % I386_PAGE_SIZE));
|
assert(!(v % I386_PAGE_SIZE));
|
||||||
vm_assert(pte >= 0 && pte < I386_VM_PT_ENTRIES);
|
assert(pte >= 0 && pte < I386_VM_PT_ENTRIES);
|
||||||
vm_assert(pde >= 0 && pde < I386_VM_DIR_ENTRIES);
|
assert(pde >= 0 && pde < I386_VM_DIR_ENTRIES);
|
||||||
|
|
||||||
/* Page table has to be there. */
|
/* Page table has to be there. */
|
||||||
if(!(pt->pt_dir[pde] & I386_VM_PRESENT))
|
if(!(pt->pt_dir[pde] & I386_VM_PRESENT))
|
||||||
|
@ -650,7 +650,7 @@ PUBLIC int pt_checkrange(pt_t *pt, vir_bytes v, size_t bytes,
|
||||||
/* Make sure page directory entry for this page table
|
/* Make sure page directory entry for this page table
|
||||||
* is marked present and page table entry is available.
|
* is marked present and page table entry is available.
|
||||||
*/
|
*/
|
||||||
vm_assert((pt->pt_dir[pde] & I386_VM_PRESENT) && pt->pt_pt[pde]);
|
assert((pt->pt_dir[pde] & I386_VM_PRESENT) && pt->pt_pt[pde]);
|
||||||
|
|
||||||
if(!(pt->pt_pt[pde][pte] & I386_VM_PRESENT)) {
|
if(!(pt->pt_pt[pde][pte] & I386_VM_PRESENT)) {
|
||||||
return EFAULT;
|
return EFAULT;
|
||||||
|
@ -767,14 +767,14 @@ PUBLIC void pt_init(phys_bytes usedlimit)
|
||||||
hi = CLICK2ABS(vmprocess->vm_arch.vm_seg[S].mem_phys +
|
hi = CLICK2ABS(vmprocess->vm_arch.vm_seg[S].mem_phys +
|
||||||
vmprocess->vm_arch.vm_seg[S].mem_len);
|
vmprocess->vm_arch.vm_seg[S].mem_len);
|
||||||
|
|
||||||
vm_assert(!(lo % I386_PAGE_SIZE));
|
assert(!(lo % I386_PAGE_SIZE));
|
||||||
vm_assert(!(hi % I386_PAGE_SIZE));
|
assert(!(hi % I386_PAGE_SIZE));
|
||||||
|
|
||||||
if(lo < VM_PROCSTART) {
|
if(lo < VM_PROCSTART) {
|
||||||
moveup = VM_PROCSTART - lo;
|
moveup = VM_PROCSTART - lo;
|
||||||
vm_assert(!(VM_PROCSTART % I386_PAGE_SIZE));
|
assert(!(VM_PROCSTART % I386_PAGE_SIZE));
|
||||||
vm_assert(!(lo % I386_PAGE_SIZE));
|
assert(!(lo % I386_PAGE_SIZE));
|
||||||
vm_assert(!(moveup % I386_PAGE_SIZE));
|
assert(!(moveup % I386_PAGE_SIZE));
|
||||||
}
|
}
|
||||||
|
|
||||||
/* Make new page table for ourselves, partly copied
|
/* Make new page table for ourselves, partly copied
|
||||||
|
@ -925,17 +925,17 @@ PUBLIC int pt_bind(pt_t *pt, struct vmproc *who)
|
||||||
u32_t phys;
|
u32_t phys;
|
||||||
|
|
||||||
/* Basic sanity checks. */
|
/* Basic sanity checks. */
|
||||||
vm_assert(who);
|
assert(who);
|
||||||
vm_assert(who->vm_flags & VMF_INUSE);
|
assert(who->vm_flags & VMF_INUSE);
|
||||||
vm_assert(pt);
|
assert(pt);
|
||||||
|
|
||||||
slot = who->vm_slot;
|
slot = who->vm_slot;
|
||||||
vm_assert(slot >= 0);
|
assert(slot >= 0);
|
||||||
vm_assert(slot < ELEMENTS(vmproc));
|
assert(slot < ELEMENTS(vmproc));
|
||||||
vm_assert(slot < I386_VM_PT_ENTRIES);
|
assert(slot < I386_VM_PT_ENTRIES);
|
||||||
|
|
||||||
phys = pt->pt_dir_phys & I386_VM_ADDR_MASK;
|
phys = pt->pt_dir_phys & I386_VM_ADDR_MASK;
|
||||||
vm_assert(pt->pt_dir_phys == phys);
|
assert(pt->pt_dir_phys == phys);
|
||||||
|
|
||||||
/* Update "page directory pagetable." */
|
/* Update "page directory pagetable." */
|
||||||
page_directories[slot] = phys | I386_VM_PRESENT|I386_VM_WRITE;
|
page_directories[slot] = phys | I386_VM_PRESENT|I386_VM_WRITE;
|
||||||
|
@ -972,14 +972,14 @@ PUBLIC int pt_mapkernel(pt_t *pt)
|
||||||
int r, i;
|
int r, i;
|
||||||
|
|
||||||
/* Any i386 page table needs to map in the kernel address space. */
|
/* Any i386 page table needs to map in the kernel address space. */
|
||||||
vm_assert(vmproc[VMP_SYSTEM].vm_flags & VMF_INUSE);
|
assert(vmproc[VMP_SYSTEM].vm_flags & VMF_INUSE);
|
||||||
|
|
||||||
if(bigpage_ok) {
|
if(bigpage_ok) {
|
||||||
int pde;
|
int pde;
|
||||||
for(pde = 0; pde <= id_map_high_pde; pde++) {
|
for(pde = 0; pde <= id_map_high_pde; pde++) {
|
||||||
phys_bytes addr;
|
phys_bytes addr;
|
||||||
addr = pde * I386_BIG_PAGE_SIZE;
|
addr = pde * I386_BIG_PAGE_SIZE;
|
||||||
vm_assert((addr & I386_VM_ADDR_MASK) == addr);
|
assert((addr & I386_VM_ADDR_MASK) == addr);
|
||||||
pt->pt_dir[pde] = addr | I386_VM_PRESENT |
|
pt->pt_dir[pde] = addr | I386_VM_PRESENT |
|
||||||
I386_VM_BIGPAGE | I386_VM_USER |
|
I386_VM_BIGPAGE | I386_VM_USER |
|
||||||
I386_VM_WRITE | global_bit;
|
I386_VM_WRITE | global_bit;
|
||||||
|
|
|
@ -36,7 +36,7 @@ PUBLIC vir_bytes arch_map2vir(struct vmproc *vmp, vir_bytes addr)
|
||||||
vir_bytes datastart = CLICK2ABS(vmp->vm_arch.vm_seg[D].mem_phys);
|
vir_bytes datastart = CLICK2ABS(vmp->vm_arch.vm_seg[D].mem_phys);
|
||||||
|
|
||||||
/* Could be a text address. */
|
/* Could be a text address. */
|
||||||
vm_assert(datastart <= addr || textstart <= addr);
|
assert(datastart <= addr || textstart <= addr);
|
||||||
|
|
||||||
return addr - datastart;
|
return addr - datastart;
|
||||||
}
|
}
|
||||||
|
|
|
@ -193,7 +193,7 @@ vir_bytes *stack_top; /* top of process stack */
|
||||||
/* No need to allocate text if it can be shared. */
|
/* No need to allocate text if it can be shared. */
|
||||||
if (sh_mp != NULL) {
|
if (sh_mp != NULL) {
|
||||||
text_bytes = 0;
|
text_bytes = 0;
|
||||||
vm_assert(!vm_paged);
|
assert(!vm_paged);
|
||||||
}
|
}
|
||||||
|
|
||||||
/* Acquire the new memory. Each of the 4 parts: text, (data+bss), gap,
|
/* Acquire the new memory. Each of the 4 parts: text, (data+bss), gap,
|
||||||
|
@ -224,7 +224,7 @@ SANITYCHECK(SCL_DETAIL);
|
||||||
rmp->vm_flags &= ~VMF_HASPT;
|
rmp->vm_flags &= ~VMF_HASPT;
|
||||||
pt_free(&rmp->vm_pt);
|
pt_free(&rmp->vm_pt);
|
||||||
}
|
}
|
||||||
vm_assert(!(vmpold->vm_flags & VMF_INUSE));
|
assert(!(vmpold->vm_flags & VMF_INUSE));
|
||||||
*vmpold = *rmp; /* copy current state. */
|
*vmpold = *rmp; /* copy current state. */
|
||||||
rmp->vm_regions = NULL; /* exec()ing process regions thrown out. */
|
rmp->vm_regions = NULL; /* exec()ing process regions thrown out. */
|
||||||
SANITYCHECK(SCL_DETAIL);
|
SANITYCHECK(SCL_DETAIL);
|
||||||
|
@ -385,11 +385,11 @@ PUBLIC phys_bytes find_kernel_top(void)
|
||||||
u32_t kernel_top = 0;
|
u32_t kernel_top = 0;
|
||||||
#define MEMTOP(v, i) \
|
#define MEMTOP(v, i) \
|
||||||
(vmproc[v].vm_arch.vm_seg[i].mem_phys + vmproc[v].vm_arch.vm_seg[i].mem_len)
|
(vmproc[v].vm_arch.vm_seg[i].mem_phys + vmproc[v].vm_arch.vm_seg[i].mem_len)
|
||||||
vm_assert(vmproc[VMP_SYSTEM].vm_flags & VMF_INUSE);
|
assert(vmproc[VMP_SYSTEM].vm_flags & VMF_INUSE);
|
||||||
kernel_top = MEMTOP(VMP_SYSTEM, T);
|
kernel_top = MEMTOP(VMP_SYSTEM, T);
|
||||||
kernel_top = MAX(kernel_top, MEMTOP(VMP_SYSTEM, D));
|
kernel_top = MAX(kernel_top, MEMTOP(VMP_SYSTEM, D));
|
||||||
kernel_top = MAX(kernel_top, MEMTOP(VMP_SYSTEM, S));
|
kernel_top = MAX(kernel_top, MEMTOP(VMP_SYSTEM, S));
|
||||||
vm_assert(kernel_top);
|
assert(kernel_top);
|
||||||
|
|
||||||
return CLICK2ABS(kernel_top);
|
return CLICK2ABS(kernel_top);
|
||||||
}
|
}
|
||||||
|
@ -414,14 +414,14 @@ PUBLIC int proc_new(struct vmproc *vmp,
|
||||||
int prealloc;
|
int prealloc;
|
||||||
struct vir_region *reg;
|
struct vir_region *reg;
|
||||||
|
|
||||||
vm_assert(!(vstart % VM_PAGE_SIZE));
|
assert(!(vstart % VM_PAGE_SIZE));
|
||||||
vm_assert(!(text_bytes % VM_PAGE_SIZE));
|
assert(!(text_bytes % VM_PAGE_SIZE));
|
||||||
vm_assert(!(data_bytes % VM_PAGE_SIZE));
|
assert(!(data_bytes % VM_PAGE_SIZE));
|
||||||
vm_assert(!(stack_bytes % VM_PAGE_SIZE));
|
assert(!(stack_bytes % VM_PAGE_SIZE));
|
||||||
vm_assert(!(gap_bytes % VM_PAGE_SIZE));
|
assert(!(gap_bytes % VM_PAGE_SIZE));
|
||||||
vm_assert(!(text_start % VM_PAGE_SIZE));
|
assert(!(text_start % VM_PAGE_SIZE));
|
||||||
vm_assert(!(data_start % VM_PAGE_SIZE));
|
assert(!(data_start % VM_PAGE_SIZE));
|
||||||
vm_assert((!text_start && !data_start) || (text_start && data_start));
|
assert((!text_start && !data_start) || (text_start && data_start));
|
||||||
|
|
||||||
/* Place text at start of process. */
|
/* Place text at start of process. */
|
||||||
vmp->vm_arch.vm_seg[T].mem_phys = ABS2CLICK(vstart);
|
vmp->vm_arch.vm_seg[T].mem_phys = ABS2CLICK(vstart);
|
||||||
|
|
|
@ -56,7 +56,7 @@ PUBLIC int do_fork(message *msg)
|
||||||
|
|
||||||
vmp = &vmproc[proc]; /* parent */
|
vmp = &vmproc[proc]; /* parent */
|
||||||
vmc = &vmproc[childproc]; /* child */
|
vmc = &vmproc[childproc]; /* child */
|
||||||
vm_assert(vmc->vm_slot == childproc);
|
assert(vmc->vm_slot == childproc);
|
||||||
|
|
||||||
if(vmp->vm_flags & VMF_HAS_DMA) {
|
if(vmp->vm_flags & VMF_HAS_DMA) {
|
||||||
printf("VM: %d has DMA memory and may not fork\n", msg->VMF_ENDPOINT);
|
printf("VM: %d has DMA memory and may not fork\n", msg->VMF_ENDPOINT);
|
||||||
|
@ -96,7 +96,7 @@ PUBLIC int do_fork(message *msg)
|
||||||
|
|
||||||
if(vmp->vm_heap) {
|
if(vmp->vm_heap) {
|
||||||
vmc->vm_heap = map_region_lookup_tag(vmc, VRT_HEAP);
|
vmc->vm_heap = map_region_lookup_tag(vmc, VRT_HEAP);
|
||||||
vm_assert(vmc->vm_heap);
|
assert(vmc->vm_heap);
|
||||||
}
|
}
|
||||||
|
|
||||||
SANITYCHECK(SCL_DETAIL);
|
SANITYCHECK(SCL_DETAIL);
|
||||||
|
@ -149,10 +149,10 @@ PUBLIC int do_fork(message *msg)
|
||||||
|
|
||||||
if(!(heap = map_region_lookup_tag(vmc, VRT_HEAP)))
|
if(!(heap = map_region_lookup_tag(vmc, VRT_HEAP)))
|
||||||
panic("couldn't lookup heap");
|
panic("couldn't lookup heap");
|
||||||
vm_assert(heap->phys);
|
assert(heap->phys);
|
||||||
if(!(stack = map_region_lookup_tag(vmc, VRT_STACK)))
|
if(!(stack = map_region_lookup_tag(vmc, VRT_STACK)))
|
||||||
panic("couldn't lookup stack");
|
panic("couldn't lookup stack");
|
||||||
vm_assert(stack->phys);
|
assert(stack->phys);
|
||||||
|
|
||||||
/* Now copy the memory regions. */
|
/* Now copy the memory regions. */
|
||||||
|
|
||||||
|
@ -160,7 +160,7 @@ PUBLIC int do_fork(message *msg)
|
||||||
struct vir_region *text;
|
struct vir_region *text;
|
||||||
if(!(text = map_region_lookup_tag(vmc, VRT_TEXT)))
|
if(!(text = map_region_lookup_tag(vmc, VRT_TEXT)))
|
||||||
panic("couldn't lookup text");
|
panic("couldn't lookup text");
|
||||||
vm_assert(text->phys);
|
assert(text->phys);
|
||||||
if(copy_abs2region(CLICK2ABS(vmp->vm_arch.vm_seg[T].mem_phys),
|
if(copy_abs2region(CLICK2ABS(vmp->vm_arch.vm_seg[T].mem_phys),
|
||||||
text, 0, text_bytes) != OK)
|
text, 0, text_bytes) != OK)
|
||||||
panic("couldn't copy text");
|
panic("couldn't copy text");
|
||||||
|
|
|
@ -82,7 +82,7 @@ PUBLIC int do_mmap(message *m)
|
||||||
}
|
}
|
||||||
|
|
||||||
/* Return mapping, as seen from process. */
|
/* Return mapping, as seen from process. */
|
||||||
vm_assert(vr);
|
assert(vr);
|
||||||
m->VMM_RETADDR = arch_map2vir(vmp, vr->vaddr);
|
m->VMM_RETADDR = arch_map2vir(vmp, vr->vaddr);
|
||||||
|
|
||||||
|
|
||||||
|
|
|
@ -67,11 +67,11 @@ PUBLIC void do_pagefaults(void)
|
||||||
panic("do_pagefaults: endpoint wrong: %d", ep);
|
panic("do_pagefaults: endpoint wrong: %d", ep);
|
||||||
|
|
||||||
vmp = &vmproc[p];
|
vmp = &vmproc[p];
|
||||||
vm_assert(vmp->vm_flags & VMF_INUSE);
|
assert(vmp->vm_flags & VMF_INUSE);
|
||||||
|
|
||||||
/* See if address is valid at all. */
|
/* See if address is valid at all. */
|
||||||
if(!(region = map_lookup(vmp, addr))) {
|
if(!(region = map_lookup(vmp, addr))) {
|
||||||
vm_assert(PFERR_NOPAGE(err));
|
assert(PFERR_NOPAGE(err));
|
||||||
printf("VM: pagefault: SIGSEGV %d bad addr 0x%lx %s\n",
|
printf("VM: pagefault: SIGSEGV %d bad addr 0x%lx %s\n",
|
||||||
ep, arch_map2vir(vmp, addr), pf_errstr(err));
|
ep, arch_map2vir(vmp, addr), pf_errstr(err));
|
||||||
if((s=sys_kill(vmp->vm_endpoint, SIGSEGV)) != OK)
|
if((s=sys_kill(vmp->vm_endpoint, SIGSEGV)) != OK)
|
||||||
|
@ -84,12 +84,12 @@ PUBLIC void do_pagefaults(void)
|
||||||
/* Make sure this isn't a region that isn't supposed
|
/* Make sure this isn't a region that isn't supposed
|
||||||
* to cause pagefaults.
|
* to cause pagefaults.
|
||||||
*/
|
*/
|
||||||
vm_assert(!(region->flags & VR_NOPF));
|
assert(!(region->flags & VR_NOPF));
|
||||||
|
|
||||||
/* We do not allow shared memory to cause pagefaults.
|
/* We do not allow shared memory to cause pagefaults.
|
||||||
* These pages have to be pre-allocated.
|
* These pages have to be pre-allocated.
|
||||||
*/
|
*/
|
||||||
vm_assert(!(region->flags & VR_SHARED));
|
assert(!(region->flags & VR_SHARED));
|
||||||
|
|
||||||
/* If process was writing, see if it's writable. */
|
/* If process was writing, see if it's writable. */
|
||||||
if(!(region->flags & VR_WRITABLE) && wr) {
|
if(!(region->flags & VR_WRITABLE) && wr) {
|
||||||
|
@ -102,7 +102,7 @@ PUBLIC void do_pagefaults(void)
|
||||||
continue;
|
continue;
|
||||||
}
|
}
|
||||||
|
|
||||||
vm_assert(addr >= region->vaddr);
|
assert(addr >= region->vaddr);
|
||||||
offset = addr - region->vaddr;
|
offset = addr - region->vaddr;
|
||||||
|
|
||||||
/* Access is allowed; handle it. */
|
/* Access is allowed; handle it. */
|
||||||
|
@ -195,9 +195,9 @@ int handle_memory(struct vmproc *vmp, vir_bytes mem, vir_bytes len, int wrflag)
|
||||||
r = EFAULT;
|
r = EFAULT;
|
||||||
} else {
|
} else {
|
||||||
vir_bytes offset, sublen;
|
vir_bytes offset, sublen;
|
||||||
vm_assert(region->vaddr <= mem);
|
assert(region->vaddr <= mem);
|
||||||
vm_assert(!(region->flags & VR_NOPF));
|
assert(!(region->flags & VR_NOPF));
|
||||||
vm_assert(!(region->vaddr % VM_PAGE_SIZE));
|
assert(!(region->vaddr % VM_PAGE_SIZE));
|
||||||
offset = mem - region->vaddr;
|
offset = mem - region->vaddr;
|
||||||
sublen = len;
|
sublen = len;
|
||||||
if(offset + sublen > region->length)
|
if(offset + sublen > region->length)
|
||||||
|
|
|
@ -242,10 +242,10 @@ PRIVATE int map_ph_writept(struct vmproc *vmp, struct vir_region *vr,
|
||||||
int rw;
|
int rw;
|
||||||
struct phys_block *pb = pr->ph;
|
struct phys_block *pb = pr->ph;
|
||||||
|
|
||||||
vm_assert(!(vr->vaddr % VM_PAGE_SIZE));
|
assert(!(vr->vaddr % VM_PAGE_SIZE));
|
||||||
vm_assert(!(pb->length % VM_PAGE_SIZE));
|
assert(!(pb->length % VM_PAGE_SIZE));
|
||||||
vm_assert(!(pr->offset % VM_PAGE_SIZE));
|
assert(!(pr->offset % VM_PAGE_SIZE));
|
||||||
vm_assert(pb->refcount > 0);
|
assert(pb->refcount > 0);
|
||||||
|
|
||||||
if(WRITABLE(vr, pb))
|
if(WRITABLE(vr, pb))
|
||||||
rw = PTF_WRITE;
|
rw = PTF_WRITE;
|
||||||
|
@ -283,10 +283,10 @@ PRIVATE vir_bytes region_find_slot(struct vmproc *vmp,
|
||||||
SANITYCHECK(SCL_FUNCTIONS);
|
SANITYCHECK(SCL_FUNCTIONS);
|
||||||
|
|
||||||
/* We must be in paged mode to be able to do this. */
|
/* We must be in paged mode to be able to do this. */
|
||||||
vm_assert(vm_paged);
|
assert(vm_paged);
|
||||||
|
|
||||||
/* Length must be reasonable. */
|
/* Length must be reasonable. */
|
||||||
vm_assert(length > 0);
|
assert(length > 0);
|
||||||
|
|
||||||
/* Special case: allow caller to set maxv to 0 meaning 'I want
|
/* Special case: allow caller to set maxv to 0 meaning 'I want
|
||||||
* it to be mapped in right here.'
|
* it to be mapped in right here.'
|
||||||
|
@ -304,13 +304,13 @@ PRIVATE vir_bytes region_find_slot(struct vmproc *vmp,
|
||||||
}
|
}
|
||||||
|
|
||||||
/* Basic input sanity checks. */
|
/* Basic input sanity checks. */
|
||||||
vm_assert(!(length % VM_PAGE_SIZE));
|
assert(!(length % VM_PAGE_SIZE));
|
||||||
if(minv >= maxv) {
|
if(minv >= maxv) {
|
||||||
printf("VM: 1 minv: 0x%lx maxv: 0x%lx length: 0x%lx\n",
|
printf("VM: 1 minv: 0x%lx maxv: 0x%lx length: 0x%lx\n",
|
||||||
minv, maxv, length);
|
minv, maxv, length);
|
||||||
}
|
}
|
||||||
vm_assert(minv < maxv);
|
assert(minv < maxv);
|
||||||
vm_assert(minv + length <= maxv);
|
assert(minv + length <= maxv);
|
||||||
|
|
||||||
#define FREEVRANGE(rangestart, rangeend, foundcode) { \
|
#define FREEVRANGE(rangestart, rangeend, foundcode) { \
|
||||||
vir_bytes frstart = (rangestart), frend = (rangeend); \
|
vir_bytes frstart = (rangestart), frend = (rangeend); \
|
||||||
|
@ -342,13 +342,13 @@ PRIVATE vir_bytes region_find_slot(struct vmproc *vmp,
|
||||||
}
|
}
|
||||||
|
|
||||||
#if SANITYCHECKS
|
#if SANITYCHECKS
|
||||||
if(prevregion) vm_assert(prevregion->vaddr < startv);
|
if(prevregion) assert(prevregion->vaddr < startv);
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
/* However we got it, startv must be in the requested range. */
|
/* However we got it, startv must be in the requested range. */
|
||||||
vm_assert(startv >= minv);
|
assert(startv >= minv);
|
||||||
vm_assert(startv < maxv);
|
assert(startv < maxv);
|
||||||
vm_assert(startv + length <= maxv);
|
assert(startv + length <= maxv);
|
||||||
|
|
||||||
if (prev)
|
if (prev)
|
||||||
*prev = prevregion;
|
*prev = prevregion;
|
||||||
|
@ -373,7 +373,7 @@ int mapflags;
|
||||||
struct phys_region *ph;
|
struct phys_region *ph;
|
||||||
physr_avl *phavl;
|
physr_avl *phavl;
|
||||||
|
|
||||||
vm_assert(!(length % VM_PAGE_SIZE));
|
assert(!(length % VM_PAGE_SIZE));
|
||||||
|
|
||||||
SANITYCHECK(SCL_FUNCTIONS);
|
SANITYCHECK(SCL_FUNCTIONS);
|
||||||
|
|
||||||
|
@ -407,10 +407,10 @@ USE(newregion,
|
||||||
|
|
||||||
/* If we know what we're going to map to, map it right away. */
|
/* If we know what we're going to map to, map it right away. */
|
||||||
if(what != MAP_NONE) {
|
if(what != MAP_NONE) {
|
||||||
vm_assert(what); /* mapping in 0 is unlikely to be right */
|
assert(what); /* mapping in 0 is unlikely to be right */
|
||||||
vm_assert(!(what % VM_PAGE_SIZE));
|
assert(!(what % VM_PAGE_SIZE));
|
||||||
vm_assert(!(startv % VM_PAGE_SIZE));
|
assert(!(startv % VM_PAGE_SIZE));
|
||||||
vm_assert(!(mapflags & MF_PREALLOC));
|
assert(!(mapflags & MF_PREALLOC));
|
||||||
if(map_new_physblock(vmp, newregion, 0, length,
|
if(map_new_physblock(vmp, newregion, 0, length,
|
||||||
what, PAF_CLEAR, 0) != OK) {
|
what, PAF_CLEAR, 0) != OK) {
|
||||||
printf("VM: map_new_physblock failed\n");
|
printf("VM: map_new_physblock failed\n");
|
||||||
|
@ -433,7 +433,7 @@ USE(newregion,
|
||||||
|
|
||||||
/* Link it. */
|
/* Link it. */
|
||||||
if(prevregion) {
|
if(prevregion) {
|
||||||
vm_assert(prevregion->vaddr < newregion->vaddr);
|
assert(prevregion->vaddr < newregion->vaddr);
|
||||||
USE(newregion, newregion->next = prevregion->next;);
|
USE(newregion, newregion->next = prevregion->next;);
|
||||||
USE(prevregion, prevregion->next = newregion;);
|
USE(prevregion, prevregion->next = newregion;);
|
||||||
} else {
|
} else {
|
||||||
|
@ -442,9 +442,9 @@ USE(newregion,
|
||||||
}
|
}
|
||||||
|
|
||||||
#if SANITYCHECKS
|
#if SANITYCHECKS
|
||||||
vm_assert(startv == newregion->vaddr);
|
assert(startv == newregion->vaddr);
|
||||||
if(newregion->next) {
|
if(newregion->next) {
|
||||||
vm_assert(newregion->vaddr < newregion->next->vaddr);
|
assert(newregion->vaddr < newregion->next->vaddr);
|
||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
|
@ -462,9 +462,9 @@ PUBLIC void pb_unreferenced(struct vir_region *region, struct phys_region *pr)
|
||||||
int remap = 0;
|
int remap = 0;
|
||||||
|
|
||||||
pb = pr->ph;
|
pb = pr->ph;
|
||||||
vm_assert(pb->refcount > 0);
|
assert(pb->refcount > 0);
|
||||||
USE(pb, pb->refcount--;);
|
USE(pb, pb->refcount--;);
|
||||||
vm_assert(pb->refcount >= 0);
|
assert(pb->refcount >= 0);
|
||||||
|
|
||||||
if(pb->firstregion == pr) {
|
if(pb->firstregion == pr) {
|
||||||
USE(pb, pb->firstregion = pr->next_ph_list;);
|
USE(pb, pb->firstregion = pr->next_ph_list;);
|
||||||
|
@ -473,18 +473,18 @@ PUBLIC void pb_unreferenced(struct vir_region *region, struct phys_region *pr)
|
||||||
|
|
||||||
for(others = pb->firstregion; others;
|
for(others = pb->firstregion; others;
|
||||||
others = others->next_ph_list) {
|
others = others->next_ph_list) {
|
||||||
vm_assert(others->ph == pb);
|
assert(others->ph == pb);
|
||||||
if(others->next_ph_list == pr) {
|
if(others->next_ph_list == pr) {
|
||||||
USE(others, others->next_ph_list = pr->next_ph_list;);
|
USE(others, others->next_ph_list = pr->next_ph_list;);
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
vm_assert(others); /* Otherwise, wasn't on the list. */
|
assert(others); /* Otherwise, wasn't on the list. */
|
||||||
}
|
}
|
||||||
|
|
||||||
if(pb->refcount == 0) {
|
if(pb->refcount == 0) {
|
||||||
vm_assert(!pb->firstregion);
|
assert(!pb->firstregion);
|
||||||
if(region->flags & VR_ANON) {
|
if(region->flags & VR_ANON) {
|
||||||
free_mem(ABS2CLICK(pb->phys),
|
free_mem(ABS2CLICK(pb->phys),
|
||||||
ABS2CLICK(pb->length));
|
ABS2CLICK(pb->length));
|
||||||
|
@ -508,7 +508,7 @@ PUBLIC void pb_unreferenced(struct vir_region *region, struct phys_region *pr)
|
||||||
}
|
}
|
||||||
n++;
|
n++;
|
||||||
}
|
}
|
||||||
vm_assert(n == pb->refcount);
|
assert(n == pb->refcount);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -519,8 +519,8 @@ PRIVATE struct phys_region *reset_physr_iter(struct vir_region *region,
|
||||||
|
|
||||||
physr_start_iter(region->phys, iter, offset, AVL_EQUAL);
|
physr_start_iter(region->phys, iter, offset, AVL_EQUAL);
|
||||||
ph = physr_get_iter(iter);
|
ph = physr_get_iter(iter);
|
||||||
vm_assert(ph);
|
assert(ph);
|
||||||
vm_assert(ph->offset == offset);
|
assert(ph->offset == offset);
|
||||||
|
|
||||||
return ph;
|
return ph;
|
||||||
}
|
}
|
||||||
|
@ -546,7 +546,7 @@ PRIVATE int map_subfree(struct vmproc *vmp,
|
||||||
|
|
||||||
for(others = pb->firstregion; others;
|
for(others = pb->firstregion; others;
|
||||||
others = others->next_ph_list) {
|
others = others->next_ph_list) {
|
||||||
vm_assert(others->ph == pb);
|
assert(others->ph == pb);
|
||||||
}
|
}
|
||||||
physr_incr_iter(&iter);
|
physr_incr_iter(&iter);
|
||||||
}
|
}
|
||||||
|
@ -565,19 +565,19 @@ PRIVATE int map_subfree(struct vmproc *vmp,
|
||||||
SLABFREE(pr);
|
SLABFREE(pr);
|
||||||
} else {
|
} else {
|
||||||
vir_bytes sublen;
|
vir_bytes sublen;
|
||||||
vm_assert(len > pr->offset);
|
assert(len > pr->offset);
|
||||||
vm_assert(len < pr->offset + pr->ph->length);
|
assert(len < pr->offset + pr->ph->length);
|
||||||
vm_assert(pr->ph->refcount > 0);
|
assert(pr->ph->refcount > 0);
|
||||||
sublen = len - pr->offset;
|
sublen = len - pr->offset;
|
||||||
vm_assert(!(sublen % VM_PAGE_SIZE));
|
assert(!(sublen % VM_PAGE_SIZE));
|
||||||
vm_assert(sublen < pr->ph->length);
|
assert(sublen < pr->ph->length);
|
||||||
if(pr->ph->refcount > 1) {
|
if(pr->ph->refcount > 1) {
|
||||||
int r;
|
int r;
|
||||||
if(!(pr = map_clone_ph_block(vmp, region,
|
if(!(pr = map_clone_ph_block(vmp, region,
|
||||||
pr, &iter)))
|
pr, &iter)))
|
||||||
return ENOMEM;
|
return ENOMEM;
|
||||||
}
|
}
|
||||||
vm_assert(pr->ph->refcount == 1);
|
assert(pr->ph->refcount == 1);
|
||||||
if(!(region->flags & VR_DIRECT)) {
|
if(!(region->flags & VR_DIRECT)) {
|
||||||
free_mem(ABS2CLICK(pr->ph->phys), ABS2CLICK(sublen));
|
free_mem(ABS2CLICK(pr->ph->phys), ABS2CLICK(sublen));
|
||||||
}
|
}
|
||||||
|
@ -585,9 +585,9 @@ PRIVATE int map_subfree(struct vmproc *vmp,
|
||||||
USE(pr->ph,
|
USE(pr->ph,
|
||||||
pr->ph->phys += sublen;
|
pr->ph->phys += sublen;
|
||||||
pr->ph->length -= sublen;);
|
pr->ph->length -= sublen;);
|
||||||
vm_assert(!(pr->offset % VM_PAGE_SIZE));
|
assert(!(pr->offset % VM_PAGE_SIZE));
|
||||||
vm_assert(!(pr->ph->phys % VM_PAGE_SIZE));
|
assert(!(pr->ph->phys % VM_PAGE_SIZE));
|
||||||
vm_assert(!(pr->ph->length % VM_PAGE_SIZE));
|
assert(!(pr->ph->length % VM_PAGE_SIZE));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -704,7 +704,7 @@ int written;
|
||||||
|
|
||||||
SANITYCHECK(SCL_FUNCTIONS);
|
SANITYCHECK(SCL_FUNCTIONS);
|
||||||
|
|
||||||
vm_assert(!(length % VM_PAGE_SIZE));
|
assert(!(length % VM_PAGE_SIZE));
|
||||||
|
|
||||||
if((region->flags & VR_CONTIG) &&
|
if((region->flags & VR_CONTIG) &&
|
||||||
(start_offset > 0 || length < region->length)) {
|
(start_offset > 0 || length < region->length)) {
|
||||||
|
@ -727,15 +727,15 @@ int written;
|
||||||
given.next = NULL;
|
given.next = NULL;
|
||||||
memlist = &given;
|
memlist = &given;
|
||||||
used_memlist = 0;
|
used_memlist = 0;
|
||||||
vm_assert(given.phys);
|
assert(given.phys);
|
||||||
vm_assert(given.length);
|
assert(given.length);
|
||||||
}
|
}
|
||||||
|
|
||||||
r = OK;
|
r = OK;
|
||||||
|
|
||||||
for(ml = memlist; ml; ml = ml->next) {
|
for(ml = memlist; ml; ml = ml->next) {
|
||||||
vm_assert(ml->phys);
|
assert(ml->phys);
|
||||||
vm_assert(ml->length);
|
assert(ml->length);
|
||||||
}
|
}
|
||||||
|
|
||||||
for(ml = memlist; ml; ml = ml->next) {
|
for(ml = memlist; ml; ml = ml->next) {
|
||||||
|
@ -751,11 +751,11 @@ int written;
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
|
||||||
vm_assert(ml->phys);
|
assert(ml->phys);
|
||||||
vm_assert(ml->length);
|
assert(ml->length);
|
||||||
|
|
||||||
/* New physical block. */
|
/* New physical block. */
|
||||||
vm_assert(!(ml->phys % VM_PAGE_SIZE));
|
assert(!(ml->phys % VM_PAGE_SIZE));
|
||||||
|
|
||||||
USE(newpb,
|
USE(newpb,
|
||||||
newpb->phys = ml->phys;
|
newpb->phys = ml->phys;
|
||||||
|
@ -796,13 +796,13 @@ int written;
|
||||||
offset += ml->length;
|
offset += ml->length;
|
||||||
if((physr = physr_search(region->phys, offset,
|
if((physr = physr_search(region->phys, offset,
|
||||||
AVL_EQUAL))) {
|
AVL_EQUAL))) {
|
||||||
vm_assert(physr->ph->refcount == 1);
|
assert(physr->ph->refcount == 1);
|
||||||
pb_unreferenced(region, physr);
|
pb_unreferenced(region, physr);
|
||||||
physr_remove(region->phys, physr->offset);
|
physr_remove(region->phys, physr->offset);
|
||||||
SLABFREE(physr);
|
SLABFREE(physr);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
} else vm_assert(mapped == length);
|
} else assert(mapped == length);
|
||||||
|
|
||||||
/* Always clean up the memlist itself, even if everything
|
/* Always clean up the memlist itself, even if everything
|
||||||
* worked we're not using the memlist nodes any more. And
|
* worked we're not using the memlist nodes any more. And
|
||||||
|
@ -863,9 +863,9 @@ physr_iter *iter;
|
||||||
SANITYCHECK(SCL_DETAIL);
|
SANITYCHECK(SCL_DETAIL);
|
||||||
SLABSANE(ph);
|
SLABSANE(ph);
|
||||||
SLABSANE(ph->ph);
|
SLABSANE(ph->ph);
|
||||||
vm_assert(ph->ph->refcount > 1);
|
assert(ph->ph->refcount > 1);
|
||||||
pb_unreferenced(region, ph);
|
pb_unreferenced(region, ph);
|
||||||
vm_assert(ph->ph->refcount >= 1);
|
assert(ph->ph->refcount >= 1);
|
||||||
physr_remove(region->phys, offset);
|
physr_remove(region->phys, offset);
|
||||||
SLABFREE(ph);
|
SLABFREE(ph);
|
||||||
|
|
||||||
|
@ -873,8 +873,8 @@ physr_iter *iter;
|
||||||
|
|
||||||
/* Put new free memory in. */
|
/* Put new free memory in. */
|
||||||
allocflags = vrallocflags(region->flags);
|
allocflags = vrallocflags(region->flags);
|
||||||
vm_assert(!(allocflags & PAF_CONTIG));
|
assert(!(allocflags & PAF_CONTIG));
|
||||||
vm_assert(!(allocflags & PAF_CLEAR));
|
assert(!(allocflags & PAF_CLEAR));
|
||||||
|
|
||||||
if(map_new_physblock(vmp, region, offset, length,
|
if(map_new_physblock(vmp, region, offset, length,
|
||||||
MAP_NONE, allocflags, written) != OK) {
|
MAP_NONE, allocflags, written) != OK) {
|
||||||
|
@ -891,12 +891,12 @@ physr_iter *iter;
|
||||||
panic("copy_abs2region failed, no good reason for that");
|
panic("copy_abs2region failed, no good reason for that");
|
||||||
|
|
||||||
newpr = physr_search(region->phys, offset, AVL_EQUAL);
|
newpr = physr_search(region->phys, offset, AVL_EQUAL);
|
||||||
vm_assert(newpr);
|
assert(newpr);
|
||||||
vm_assert(newpr->offset == offset);
|
assert(newpr->offset == offset);
|
||||||
|
|
||||||
if(iter) {
|
if(iter) {
|
||||||
physr_start_iter(region->phys, iter, offset, AVL_EQUAL);
|
physr_start_iter(region->phys, iter, offset, AVL_EQUAL);
|
||||||
vm_assert(physr_get_iter(iter) == newpr);
|
assert(physr_get_iter(iter) == newpr);
|
||||||
}
|
}
|
||||||
|
|
||||||
SANITYCHECK(SCL_FUNCTIONS);
|
SANITYCHECK(SCL_FUNCTIONS);
|
||||||
|
@ -918,11 +918,11 @@ int write;
|
||||||
struct phys_region *ph;
|
struct phys_region *ph;
|
||||||
int r = OK;
|
int r = OK;
|
||||||
|
|
||||||
vm_assert(offset >= 0);
|
assert(offset >= 0);
|
||||||
vm_assert(offset < region->length);
|
assert(offset < region->length);
|
||||||
|
|
||||||
vm_assert(region->flags & VR_ANON);
|
assert(region->flags & VR_ANON);
|
||||||
vm_assert(!(region->vaddr % VM_PAGE_SIZE));
|
assert(!(region->vaddr % VM_PAGE_SIZE));
|
||||||
|
|
||||||
virpage = offset - offset % VM_PAGE_SIZE;
|
virpage = offset - offset % VM_PAGE_SIZE;
|
||||||
|
|
||||||
|
@ -932,9 +932,9 @@ int write;
|
||||||
(ph->offset <= offset && offset < ph->offset + ph->ph->length)) {
|
(ph->offset <= offset && offset < ph->offset + ph->ph->length)) {
|
||||||
phys_bytes blockoffset = ph->offset;
|
phys_bytes blockoffset = ph->offset;
|
||||||
/* Pagefault in existing block. Do copy-on-write. */
|
/* Pagefault in existing block. Do copy-on-write. */
|
||||||
vm_assert(write);
|
assert(write);
|
||||||
vm_assert(region->flags & VR_WRITABLE);
|
assert(region->flags & VR_WRITABLE);
|
||||||
vm_assert(ph->ph->refcount > 0);
|
assert(ph->ph->refcount > 0);
|
||||||
|
|
||||||
if(WRITABLE(region, ph->ph)) {
|
if(WRITABLE(region, ph->ph)) {
|
||||||
r = map_ph_writept(vmp, region, ph);
|
r = map_ph_writept(vmp, region, ph);
|
||||||
|
@ -1010,11 +1010,11 @@ int write;
|
||||||
|
|
||||||
SANITYCHECK(SCL_FUNCTIONS);
|
SANITYCHECK(SCL_FUNCTIONS);
|
||||||
|
|
||||||
vm_assert(region->flags & VR_ANON);
|
assert(region->flags & VR_ANON);
|
||||||
vm_assert(!(region->vaddr % VM_PAGE_SIZE));
|
assert(!(region->vaddr % VM_PAGE_SIZE));
|
||||||
vm_assert(!(offset % VM_PAGE_SIZE));
|
assert(!(offset % VM_PAGE_SIZE));
|
||||||
vm_assert(!(length % VM_PAGE_SIZE));
|
assert(!(length % VM_PAGE_SIZE));
|
||||||
vm_assert(!write || (region->flags & VR_WRITABLE));
|
assert(!write || (region->flags & VR_WRITABLE));
|
||||||
|
|
||||||
physr_start_iter(region->phys, &iter, offset, AVL_LESS_EQUAL);
|
physr_start_iter(region->phys, &iter, offset, AVL_LESS_EQUAL);
|
||||||
physr = physr_get_iter(&iter);
|
physr = physr_get_iter(&iter);
|
||||||
|
@ -1046,7 +1046,7 @@ int write;
|
||||||
SANITYCHECK(SCL_DETAIL);
|
SANITYCHECK(SCL_DETAIL);
|
||||||
|
|
||||||
if(write) {
|
if(write) {
|
||||||
vm_assert(physr->ph->refcount > 0);
|
assert(physr->ph->refcount > 0);
|
||||||
if(!WRITABLE(region, physr->ph)) {
|
if(!WRITABLE(region, physr->ph)) {
|
||||||
if(!(physr = map_clone_ph_block(vmp, region,
|
if(!(physr = map_clone_ph_block(vmp, region,
|
||||||
physr, &iter))) {
|
physr, &iter))) {
|
||||||
|
@ -1170,13 +1170,13 @@ PRIVATE struct vir_region *map_copy_region(struct vmproc *vmp, struct vir_region
|
||||||
#endif
|
#endif
|
||||||
physr_insert(newvr->phys, newph);
|
physr_insert(newvr->phys, newph);
|
||||||
#if SANITYCHECKS
|
#if SANITYCHECKS
|
||||||
vm_assert(countregions(vr) == cr);
|
assert(countregions(vr) == cr);
|
||||||
#endif
|
#endif
|
||||||
physr_incr_iter(&iter);
|
physr_incr_iter(&iter);
|
||||||
}
|
}
|
||||||
|
|
||||||
#if SANITYCHECKS
|
#if SANITYCHECKS
|
||||||
vm_assert(countregions(vr) == countregions(newvr));
|
assert(countregions(vr) == countregions(newvr));
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
return newvr;
|
return newvr;
|
||||||
|
@ -1189,28 +1189,28 @@ PUBLIC int copy_abs2region(phys_bytes abs, struct vir_region *destregion,
|
||||||
phys_bytes offset, phys_bytes len)
|
phys_bytes offset, phys_bytes len)
|
||||||
|
|
||||||
{
|
{
|
||||||
vm_assert(destregion);
|
assert(destregion);
|
||||||
vm_assert(destregion->phys);
|
assert(destregion->phys);
|
||||||
while(len > 0) {
|
while(len > 0) {
|
||||||
phys_bytes sublen, suboffset;
|
phys_bytes sublen, suboffset;
|
||||||
struct phys_region *ph;
|
struct phys_region *ph;
|
||||||
vm_assert(destregion);
|
assert(destregion);
|
||||||
vm_assert(destregion->phys);
|
assert(destregion->phys);
|
||||||
if(!(ph = physr_search(destregion->phys, offset, AVL_LESS_EQUAL))) {
|
if(!(ph = physr_search(destregion->phys, offset, AVL_LESS_EQUAL))) {
|
||||||
printf("VM: copy_abs2region: no phys region found (1).\n");
|
printf("VM: copy_abs2region: no phys region found (1).\n");
|
||||||
return EFAULT;
|
return EFAULT;
|
||||||
}
|
}
|
||||||
vm_assert(ph->offset <= offset);
|
assert(ph->offset <= offset);
|
||||||
if(ph->offset+ph->ph->length <= offset) {
|
if(ph->offset+ph->ph->length <= offset) {
|
||||||
printf("VM: copy_abs2region: no phys region found (2).\n");
|
printf("VM: copy_abs2region: no phys region found (2).\n");
|
||||||
return EFAULT;
|
return EFAULT;
|
||||||
}
|
}
|
||||||
suboffset = offset - ph->offset;
|
suboffset = offset - ph->offset;
|
||||||
vm_assert(suboffset < ph->ph->length);
|
assert(suboffset < ph->ph->length);
|
||||||
sublen = len;
|
sublen = len;
|
||||||
if(sublen > ph->ph->length - suboffset)
|
if(sublen > ph->ph->length - suboffset)
|
||||||
sublen = ph->ph->length - suboffset;
|
sublen = ph->ph->length - suboffset;
|
||||||
vm_assert(suboffset + sublen <= ph->ph->length);
|
assert(suboffset + sublen <= ph->ph->length);
|
||||||
if(ph->ph->refcount != 1) {
|
if(ph->ph->refcount != 1) {
|
||||||
printf("VM: copy_abs2region: no phys region found (3).\n");
|
printf("VM: copy_abs2region: no phys region found (3).\n");
|
||||||
return EFAULT;
|
return EFAULT;
|
||||||
|
@ -1292,21 +1292,21 @@ struct vmproc *src;
|
||||||
/* Check two physregions both are nonnull,
|
/* Check two physregions both are nonnull,
|
||||||
* are different, and match physblocks.
|
* are different, and match physblocks.
|
||||||
*/
|
*/
|
||||||
vm_assert(new_ph);
|
assert(new_ph);
|
||||||
vm_assert(orig_ph);
|
assert(orig_ph);
|
||||||
vm_assert(orig_ph != new_ph);
|
assert(orig_ph != new_ph);
|
||||||
pb = orig_ph->ph;
|
pb = orig_ph->ph;
|
||||||
vm_assert(pb == new_ph->ph);
|
assert(pb == new_ph->ph);
|
||||||
|
|
||||||
/* Link in new physregion. */
|
/* Link in new physregion. */
|
||||||
vm_assert(!new_ph->next_ph_list);
|
assert(!new_ph->next_ph_list);
|
||||||
USE(new_ph, new_ph->next_ph_list = pb->firstregion;);
|
USE(new_ph, new_ph->next_ph_list = pb->firstregion;);
|
||||||
USE(pb, pb->firstregion = new_ph;);
|
USE(pb, pb->firstregion = new_ph;);
|
||||||
|
|
||||||
/* Increase phys block refcount */
|
/* Increase phys block refcount */
|
||||||
vm_assert(pb->refcount > 0);
|
assert(pb->refcount > 0);
|
||||||
USE(pb, pb->refcount++;);
|
USE(pb, pb->refcount++;);
|
||||||
vm_assert(pb->refcount > 1);
|
assert(pb->refcount > 1);
|
||||||
|
|
||||||
/* If the phys block has been shared as SMAP,
|
/* If the phys block has been shared as SMAP,
|
||||||
* do the regular copy. */
|
* do the regular copy. */
|
||||||
|
@ -1321,7 +1321,7 @@ struct vmproc *src;
|
||||||
physr_incr_iter(&iter_orig);
|
physr_incr_iter(&iter_orig);
|
||||||
physr_incr_iter(&iter_new);
|
physr_incr_iter(&iter_new);
|
||||||
}
|
}
|
||||||
vm_assert(!physr_get_iter(&iter_new));
|
assert(!physr_get_iter(&iter_new));
|
||||||
prevvr = newvr;
|
prevvr = newvr;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -1342,12 +1342,12 @@ PUBLIC struct vir_region *map_proc_kernel(struct vmproc *vmp)
|
||||||
/* We assume these are the first regions to be mapped to
|
/* We assume these are the first regions to be mapped to
|
||||||
* make the function a bit simpler (free all regions on error).
|
* make the function a bit simpler (free all regions on error).
|
||||||
*/
|
*/
|
||||||
vm_assert(!vmp->vm_regions);
|
assert(!vmp->vm_regions);
|
||||||
vm_assert(vmproc[VMP_SYSTEM].vm_flags & VMF_INUSE);
|
assert(vmproc[VMP_SYSTEM].vm_flags & VMF_INUSE);
|
||||||
vm_assert(!(KERNEL_TEXT % VM_PAGE_SIZE));
|
assert(!(KERNEL_TEXT % VM_PAGE_SIZE));
|
||||||
vm_assert(!(KERNEL_TEXT_LEN % VM_PAGE_SIZE));
|
assert(!(KERNEL_TEXT_LEN % VM_PAGE_SIZE));
|
||||||
vm_assert(!(KERNEL_DATA % VM_PAGE_SIZE));
|
assert(!(KERNEL_DATA % VM_PAGE_SIZE));
|
||||||
vm_assert(!(KERNEL_DATA_LEN % VM_PAGE_SIZE));
|
assert(!(KERNEL_DATA_LEN % VM_PAGE_SIZE));
|
||||||
|
|
||||||
if(!(vr = map_page_region(vmp, KERNEL_TEXT, 0, KERNEL_TEXT_LEN,
|
if(!(vr = map_page_region(vmp, KERNEL_TEXT, 0, KERNEL_TEXT_LEN,
|
||||||
KERNEL_TEXT, VR_DIRECT | VR_WRITABLE | VR_NOPF, 0)) ||
|
KERNEL_TEXT, VR_DIRECT | VR_WRITABLE | VR_NOPF, 0)) ||
|
||||||
|
@ -1368,13 +1368,13 @@ PUBLIC int map_region_extend(struct vmproc *vmp, struct vir_region *vr,
|
||||||
{
|
{
|
||||||
vir_bytes end;
|
vir_bytes end;
|
||||||
|
|
||||||
vm_assert(vr);
|
assert(vr);
|
||||||
vm_assert(vr->flags & VR_ANON);
|
assert(vr->flags & VR_ANON);
|
||||||
vm_assert(!(delta % VM_PAGE_SIZE));
|
assert(!(delta % VM_PAGE_SIZE));
|
||||||
|
|
||||||
if(!delta) return OK;
|
if(!delta) return OK;
|
||||||
end = vr->vaddr + vr->length;
|
end = vr->vaddr + vr->length;
|
||||||
vm_assert(end >= vr->vaddr);
|
assert(end >= vr->vaddr);
|
||||||
|
|
||||||
if(end + delta <= end) {
|
if(end + delta <= end) {
|
||||||
printf("VM: strange delta 0x%lx\n", delta);
|
printf("VM: strange delta 0x%lx\n", delta);
|
||||||
|
@ -1396,9 +1396,9 @@ PUBLIC int map_region_extend(struct vmproc *vmp, struct vir_region *vr,
|
||||||
*========================================================================*/
|
*========================================================================*/
|
||||||
PUBLIC int map_region_shrink(struct vir_region *vr, vir_bytes delta)
|
PUBLIC int map_region_shrink(struct vir_region *vr, vir_bytes delta)
|
||||||
{
|
{
|
||||||
vm_assert(vr);
|
assert(vr);
|
||||||
vm_assert(vr->flags & VR_ANON);
|
assert(vr->flags & VR_ANON);
|
||||||
vm_assert(!(delta % VM_PAGE_SIZE));
|
assert(!(delta % VM_PAGE_SIZE));
|
||||||
|
|
||||||
#if 0
|
#if 0
|
||||||
printf("VM: ignoring region shrink\n");
|
printf("VM: ignoring region shrink\n");
|
||||||
|
@ -1493,7 +1493,7 @@ PUBLIC int map_unmap_region(struct vmproc *vmp, struct vir_region *region,
|
||||||
* same amount.
|
* same amount.
|
||||||
*/
|
*/
|
||||||
while((pr = physr_get_iter(&iter))) {
|
while((pr = physr_get_iter(&iter))) {
|
||||||
vm_assert(pr->offset >= len);
|
assert(pr->offset >= len);
|
||||||
USE(pr, pr->offset -= len;);
|
USE(pr, pr->offset -= len;);
|
||||||
physr_incr_iter(&iter);
|
physr_incr_iter(&iter);
|
||||||
}
|
}
|
||||||
|
@ -1525,7 +1525,7 @@ PUBLIC int map_remap(struct vmproc *dvmp, vir_bytes da, size_t size,
|
||||||
|
|
||||||
SANITYCHECK(SCL_FUNCTIONS);
|
SANITYCHECK(SCL_FUNCTIONS);
|
||||||
|
|
||||||
vm_assert(region->flags & VR_SHARED);
|
assert(region->flags & VR_SHARED);
|
||||||
|
|
||||||
/* da is handled differently */
|
/* da is handled differently */
|
||||||
if (!da)
|
if (!da)
|
||||||
|
@ -1536,7 +1536,7 @@ PUBLIC int map_remap(struct vmproc *dvmp, vir_bytes da, size_t size,
|
||||||
|
|
||||||
prev = NULL;
|
prev = NULL;
|
||||||
/* round up to page size */
|
/* round up to page size */
|
||||||
vm_assert(!(size % VM_PAGE_SIZE));
|
assert(!(size % VM_PAGE_SIZE));
|
||||||
startv = region_find_slot(dvmp, dst_addr, VM_DATATOP, size, &prev);
|
startv = region_find_slot(dvmp, dst_addr, VM_DATATOP, size, &prev);
|
||||||
if (startv == (vir_bytes) -1) {
|
if (startv == (vir_bytes) -1) {
|
||||||
printf("map_remap: search 0x%x...\n", dst_addr);
|
printf("map_remap: search 0x%x...\n", dst_addr);
|
||||||
|
@ -1557,7 +1557,7 @@ PUBLIC int map_remap(struct vmproc *dvmp, vir_bytes da, size_t size,
|
||||||
vr->flags = region->flags;
|
vr->flags = region->flags;
|
||||||
vr->tag = VRT_NONE;
|
vr->tag = VRT_NONE;
|
||||||
vr->parent = dvmp;);
|
vr->parent = dvmp;);
|
||||||
vm_assert(vr->flags & VR_SHARED);
|
assert(vr->flags & VR_SHARED);
|
||||||
|
|
||||||
if (prev) {
|
if (prev) {
|
||||||
USE(vr,
|
USE(vr,
|
||||||
|
@ -1572,7 +1572,7 @@ PUBLIC int map_remap(struct vmproc *dvmp, vir_bytes da, size_t size,
|
||||||
physr_start_iter_least(vr->phys, &iter);
|
physr_start_iter_least(vr->phys, &iter);
|
||||||
while((ph = physr_get_iter(&iter))) {
|
while((ph = physr_get_iter(&iter))) {
|
||||||
struct phys_block *pb = ph->ph;
|
struct phys_block *pb = ph->ph;
|
||||||
vm_assert(!ph->next_ph_list);
|
assert(!ph->next_ph_list);
|
||||||
USE(ph, ph->next_ph_list = pb->firstregion;);
|
USE(ph, ph->next_ph_list = pb->firstregion;);
|
||||||
USE(pb, pb->firstregion = ph;);
|
USE(pb, pb->firstregion = ph;);
|
||||||
USE(pb, pb->refcount++;);
|
USE(pb, pb->refcount++;);
|
||||||
|
@ -1608,8 +1608,8 @@ PUBLIC int map_get_phys(struct vmproc *vmp, vir_bytes addr, phys_bytes *r)
|
||||||
physr_start_iter_least(vr->phys, &iter);
|
physr_start_iter_least(vr->phys, &iter);
|
||||||
ph = physr_get_iter(&iter);
|
ph = physr_get_iter(&iter);
|
||||||
|
|
||||||
vm_assert(ph);
|
assert(ph);
|
||||||
vm_assert(ph->ph);
|
assert(ph->ph);
|
||||||
if (r)
|
if (r)
|
||||||
*r = ph->ph->phys;
|
*r = ph->ph->phys;
|
||||||
|
|
||||||
|
@ -1635,8 +1635,8 @@ PUBLIC int map_get_ref(struct vmproc *vmp, vir_bytes addr, u8_t *cnt)
|
||||||
physr_start_iter_least(vr->phys, &iter);
|
physr_start_iter_least(vr->phys, &iter);
|
||||||
ph = physr_get_iter(&iter);
|
ph = physr_get_iter(&iter);
|
||||||
|
|
||||||
vm_assert(ph);
|
assert(ph);
|
||||||
vm_assert(ph->ph);
|
assert(ph->ph);
|
||||||
if (cnt)
|
if (cnt)
|
||||||
*cnt = ph->ph->refcount;
|
*cnt = ph->ph->refcount;
|
||||||
|
|
||||||
|
@ -1856,7 +1856,7 @@ PUBLIC int unmap_memory(endpoint_t sour, endpoint_t dest,
|
||||||
vmd = &vmproc[p];
|
vmd = &vmproc[p];
|
||||||
|
|
||||||
vrd = map_lookup(vmd, virt_d);
|
vrd = map_lookup(vmd, virt_d);
|
||||||
vm_assert(vrd);
|
assert(vrd);
|
||||||
|
|
||||||
/* Search for the first phys region in the destination process. */
|
/* Search for the first phys region in the destination process. */
|
||||||
off = virt_d - vrd->vaddr;
|
off = virt_d - vrd->vaddr;
|
||||||
|
@ -1869,8 +1869,8 @@ PUBLIC int unmap_memory(endpoint_t sour, endpoint_t dest,
|
||||||
end = off + length;
|
end = off + length;
|
||||||
while((pr = physr_get_iter(&iter)) && off < end) {
|
while((pr = physr_get_iter(&iter)) && off < end) {
|
||||||
pb = pr->ph;
|
pb = pr->ph;
|
||||||
vm_assert(pb->refcount > 1);
|
assert(pb->refcount > 1);
|
||||||
vm_assert(pb->share_flag == PBSH_SMAP);
|
assert(pb->share_flag == PBSH_SMAP);
|
||||||
|
|
||||||
if(!(pr = map_clone_ph_block(vmd, vrd, pr, &iter)))
|
if(!(pr = map_clone_ph_block(vmd, vrd, pr, &iter)))
|
||||||
return ENOMEM;
|
return ENOMEM;
|
||||||
|
@ -2012,9 +2012,9 @@ PUBLIC int map_memory(endpoint_t sour, endpoint_t dest,
|
||||||
vmd = &vmproc[p];
|
vmd = &vmproc[p];
|
||||||
|
|
||||||
vrs = map_lookup(vms, virt_s);
|
vrs = map_lookup(vms, virt_s);
|
||||||
vm_assert(vrs);
|
assert(vrs);
|
||||||
vrd = map_lookup(vmd, virt_d);
|
vrd = map_lookup(vmd, virt_d);
|
||||||
vm_assert(vrd);
|
assert(vrd);
|
||||||
|
|
||||||
/* Linear address -> offset from start of vir region. */
|
/* Linear address -> offset from start of vir region. */
|
||||||
offset_s = virt_s - vrs->vaddr;
|
offset_s = virt_s - vrs->vaddr;
|
||||||
|
|
|
@ -123,8 +123,8 @@ PUBLIC int do_rs_update(message *m_ptr)
|
||||||
}
|
}
|
||||||
|
|
||||||
/* Adjust page tables. */
|
/* Adjust page tables. */
|
||||||
vm_assert(src_vmp->vm_flags & VMF_HASPT);
|
assert(src_vmp->vm_flags & VMF_HASPT);
|
||||||
vm_assert(dst_vmp->vm_flags & VMF_HASPT);
|
assert(dst_vmp->vm_flags & VMF_HASPT);
|
||||||
pt_bind(&src_vmp->vm_pt, src_vmp);
|
pt_bind(&src_vmp->vm_pt, src_vmp);
|
||||||
pt_bind(&dst_vmp->vm_pt, dst_vmp);
|
pt_bind(&dst_vmp->vm_pt, dst_vmp);
|
||||||
if((r=sys_vmctl(SELF, VMCTL_FLUSHTLB, 0)) != OK) {
|
if((r=sys_vmctl(SELF, VMCTL_FLUSHTLB, 0)) != OK) {
|
||||||
|
|
|
@ -20,7 +20,7 @@
|
||||||
|
|
||||||
#define SANITYCHECK(l) if(!nocheck && ((l) <= vm_sanitychecklevel)) { \
|
#define SANITYCHECK(l) if(!nocheck && ((l) <= vm_sanitychecklevel)) { \
|
||||||
struct vmproc *vmpr; \
|
struct vmproc *vmpr; \
|
||||||
vm_assert(incheck == 0); \
|
assert(incheck == 0); \
|
||||||
incheck = 1; \
|
incheck = 1; \
|
||||||
usedpages_reset(); \
|
usedpages_reset(); \
|
||||||
slab_sanitycheck(__FILE__, __LINE__); \
|
slab_sanitycheck(__FILE__, __LINE__); \
|
||||||
|
@ -31,7 +31,7 @@
|
||||||
} \
|
} \
|
||||||
} \
|
} \
|
||||||
map_sanitycheck(__FILE__, __LINE__); \
|
map_sanitycheck(__FILE__, __LINE__); \
|
||||||
vm_assert(incheck == 1); \
|
assert(incheck == 1); \
|
||||||
incheck = 0; \
|
incheck = 0; \
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -37,19 +37,19 @@
|
||||||
#define BITEL(f, b) (f)->sdh.usebits[(b)/ELBITS]
|
#define BITEL(f, b) (f)->sdh.usebits[(b)/ELBITS]
|
||||||
|
|
||||||
|
|
||||||
#define OFF(f, b) vm_assert(!GETBIT(f, b))
|
#define OFF(f, b) assert(!GETBIT(f, b))
|
||||||
#define ON(f, b) vm_assert(GETBIT(f, b))
|
#define ON(f, b) assert(GETBIT(f, b))
|
||||||
|
|
||||||
#if SANITYCHECKS
|
#if SANITYCHECKS
|
||||||
#define SLABDATAWRITABLE(data, wr) do { \
|
#define SLABDATAWRITABLE(data, wr) do { \
|
||||||
vm_assert(data->sdh.writable == WRITABLE_NONE); \
|
assert(data->sdh.writable == WRITABLE_NONE); \
|
||||||
vm_assert(wr != WRITABLE_NONE); \
|
assert(wr != WRITABLE_NONE); \
|
||||||
vm_pagelock(data, 0); \
|
vm_pagelock(data, 0); \
|
||||||
data->sdh.writable = wr; \
|
data->sdh.writable = wr; \
|
||||||
} while(0)
|
} while(0)
|
||||||
|
|
||||||
#define SLABDATAUNWRITABLE(data) do { \
|
#define SLABDATAUNWRITABLE(data) do { \
|
||||||
vm_assert(data->sdh.writable != WRITABLE_NONE); \
|
assert(data->sdh.writable != WRITABLE_NONE); \
|
||||||
data->sdh.writable = WRITABLE_NONE; \
|
data->sdh.writable = WRITABLE_NONE; \
|
||||||
vm_pagelock(data, 1); \
|
vm_pagelock(data, 1); \
|
||||||
} while(0)
|
} while(0)
|
||||||
|
@ -133,10 +133,10 @@ FORWARD _PROTOTYPE( int objstats, (void *, int, struct slabheader **, struct sla
|
||||||
|
|
||||||
#define GETSLAB(b, s) { \
|
#define GETSLAB(b, s) { \
|
||||||
int i; \
|
int i; \
|
||||||
vm_assert((b) >= MINSIZE); \
|
assert((b) >= MINSIZE); \
|
||||||
i = (b) - MINSIZE; \
|
i = (b) - MINSIZE; \
|
||||||
vm_assert((i) < SLABSIZES); \
|
assert((i) < SLABSIZES); \
|
||||||
vm_assert((i) >= 0); \
|
assert((i) >= 0); \
|
||||||
s = &slabs[i]; \
|
s = &slabs[i]; \
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -145,7 +145,7 @@ FORWARD _PROTOTYPE( int objstats, (void *, int, struct slabheader **, struct sla
|
||||||
/* move head of list l1 to list of l2 in slabheader sl. */
|
/* move head of list l1 to list of l2 in slabheader sl. */
|
||||||
#define MOVEHEAD(sl, l1, l2) { \
|
#define MOVEHEAD(sl, l1, l2) { \
|
||||||
struct slabdata *t; \
|
struct slabdata *t; \
|
||||||
vm_assert(LH(sl,l1)); \
|
assert(LH(sl,l1)); \
|
||||||
REMOVEHEAD(sl, l1, t); \
|
REMOVEHEAD(sl, l1, t); \
|
||||||
ADDHEAD(t, sl, l2); \
|
ADDHEAD(t, sl, l2); \
|
||||||
}
|
}
|
||||||
|
@ -154,7 +154,7 @@ FORWARD _PROTOTYPE( int objstats, (void *, int, struct slabheader **, struct sla
|
||||||
#define REMOVEHEAD(sl, list, to) { \
|
#define REMOVEHEAD(sl, list, to) { \
|
||||||
struct slabdata *dat; \
|
struct slabdata *dat; \
|
||||||
dat = (to) = LH(sl, list); \
|
dat = (to) = LH(sl, list); \
|
||||||
vm_assert(dat); \
|
assert(dat); \
|
||||||
LH(sl, list) = dat->sdh.next; \
|
LH(sl, list) = dat->sdh.next; \
|
||||||
UNLINKNODE(dat); \
|
UNLINKNODE(dat); \
|
||||||
}
|
}
|
||||||
|
@ -185,7 +185,7 @@ struct slabdata *newslabdata(int list)
|
||||||
struct slabdata *n;
|
struct slabdata *n;
|
||||||
phys_bytes p;
|
phys_bytes p;
|
||||||
|
|
||||||
vm_assert(sizeof(*n) == VM_PAGE_SIZE);
|
assert(sizeof(*n) == VM_PAGE_SIZE);
|
||||||
|
|
||||||
if(!(n = vm_allocpage(&p, VMP_SLAB))) {
|
if(!(n = vm_allocpage(&p, VMP_SLAB))) {
|
||||||
printf("newslabdata: vm_allocpage failed\n");
|
printf("newslabdata: vm_allocpage failed\n");
|
||||||
|
@ -290,7 +290,7 @@ PUBLIC void *slaballoc(int bytes)
|
||||||
|
|
||||||
/* Retrieve entry in slabs[]. */
|
/* Retrieve entry in slabs[]. */
|
||||||
GETSLAB(bytes, s);
|
GETSLAB(bytes, s);
|
||||||
vm_assert(s);
|
assert(s);
|
||||||
|
|
||||||
/* To make the common case more common, make space in the 'used'
|
/* To make the common case more common, make space in the 'used'
|
||||||
* queue first.
|
* queue first.
|
||||||
|
@ -314,14 +314,14 @@ PUBLIC void *slaballoc(int bytes)
|
||||||
}
|
}
|
||||||
SLABSANITYCHECK(SCL_DETAIL);
|
SLABSANITYCHECK(SCL_DETAIL);
|
||||||
|
|
||||||
vm_assert(s);
|
assert(s);
|
||||||
firstused = LH(s, LIST_USED);
|
firstused = LH(s, LIST_USED);
|
||||||
vm_assert(firstused);
|
assert(firstused);
|
||||||
#if SANITYCHECKS
|
#if SANITYCHECKS
|
||||||
vm_assert(firstused->sdh.magic1 == MAGIC1);
|
assert(firstused->sdh.magic1 == MAGIC1);
|
||||||
vm_assert(firstused->sdh.magic2 == MAGIC2);
|
assert(firstused->sdh.magic2 == MAGIC2);
|
||||||
#endif
|
#endif
|
||||||
vm_assert(firstused->sdh.nused < ITEMSPERPAGE(bytes));
|
assert(firstused->sdh.nused < ITEMSPERPAGE(bytes));
|
||||||
|
|
||||||
for(i = firstused->sdh.freeguess;
|
for(i = firstused->sdh.freeguess;
|
||||||
count < ITEMSPERPAGE(bytes); count++, i++) {
|
count < ITEMSPERPAGE(bytes); count++, i++) {
|
||||||
|
@ -345,7 +345,7 @@ PUBLIC void *slaballoc(int bytes)
|
||||||
nojunkwarning++;
|
nojunkwarning++;
|
||||||
slabunlock(ret, bytes);
|
slabunlock(ret, bytes);
|
||||||
nojunkwarning--;
|
nojunkwarning--;
|
||||||
vm_assert(!nojunkwarning);
|
assert(!nojunkwarning);
|
||||||
*(u32_t *) ret = NOJUNK;
|
*(u32_t *) ret = NOJUNK;
|
||||||
slablock(ret, bytes);
|
slablock(ret, bytes);
|
||||||
#endif
|
#endif
|
||||||
|
@ -458,7 +458,7 @@ PUBLIC void slabfree(void *mem, int bytes)
|
||||||
nojunkwarning++;
|
nojunkwarning++;
|
||||||
slablock(mem, bytes);
|
slablock(mem, bytes);
|
||||||
nojunkwarning--;
|
nojunkwarning--;
|
||||||
vm_assert(!nojunkwarning);
|
assert(!nojunkwarning);
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
/* Free this data. */
|
/* Free this data. */
|
||||||
|
@ -467,7 +467,7 @@ PUBLIC void slabfree(void *mem, int bytes)
|
||||||
/* Check if this slab changes lists. */
|
/* Check if this slab changes lists. */
|
||||||
if(f->sdh.nused == 0) {
|
if(f->sdh.nused == 0) {
|
||||||
/* Now become FREE; must've been USED */
|
/* Now become FREE; must've been USED */
|
||||||
vm_assert(f->sdh.list == LIST_USED);
|
assert(f->sdh.list == LIST_USED);
|
||||||
UNLINKNODE(f);
|
UNLINKNODE(f);
|
||||||
if(f == LH(s, LIST_USED))
|
if(f == LH(s, LIST_USED))
|
||||||
LH(s, LIST_USED) = f->sdh.next;
|
LH(s, LIST_USED) = f->sdh.next;
|
||||||
|
@ -475,7 +475,7 @@ PUBLIC void slabfree(void *mem, int bytes)
|
||||||
SLABSANITYCHECK(SCL_DETAIL);
|
SLABSANITYCHECK(SCL_DETAIL);
|
||||||
} else if(f->sdh.nused == ITEMSPERPAGE(bytes)-1) {
|
} else if(f->sdh.nused == ITEMSPERPAGE(bytes)-1) {
|
||||||
/* Now become USED; must've been FULL */
|
/* Now become USED; must've been FULL */
|
||||||
vm_assert(f->sdh.list == LIST_FULL);
|
assert(f->sdh.list == LIST_FULL);
|
||||||
UNLINKNODE(f);
|
UNLINKNODE(f);
|
||||||
if(f == LH(s, LIST_FULL))
|
if(f == LH(s, LIST_FULL))
|
||||||
LH(s, LIST_FULL) = f->sdh.next;
|
LH(s, LIST_FULL) = f->sdh.next;
|
||||||
|
@ -483,7 +483,7 @@ PUBLIC void slabfree(void *mem, int bytes)
|
||||||
SLABSANITYCHECK(SCL_DETAIL);
|
SLABSANITYCHECK(SCL_DETAIL);
|
||||||
} else {
|
} else {
|
||||||
/* Stay USED */
|
/* Stay USED */
|
||||||
vm_assert(f->sdh.list == LIST_USED);
|
assert(f->sdh.list == LIST_USED);
|
||||||
}
|
}
|
||||||
|
|
||||||
SLABSANITYCHECK(SCL_FUNCTIONS);
|
SLABSANITYCHECK(SCL_FUNCTIONS);
|
||||||
|
|
|
@ -7,17 +7,5 @@
|
||||||
|
|
||||||
#define ELEMENTS(a) (sizeof(a)/sizeof((a)[0]))
|
#define ELEMENTS(a) (sizeof(a)/sizeof((a)[0]))
|
||||||
|
|
||||||
#if SANITYCHECKS
|
|
||||||
#define vm_assert(cond) { \
|
|
||||||
if(vm_sanitychecklevel > 0 && !(cond)) { \
|
|
||||||
printf("VM:%s:%d: vm_assert failed: %s\n", \
|
|
||||||
__FILE__, __LINE__, #cond); \
|
|
||||||
panic("vm_assert failed"); \
|
|
||||||
} \
|
|
||||||
}
|
|
||||||
#else
|
|
||||||
#define vm_assert(cond) ;
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
|
|
|
@ -28,7 +28,7 @@
|
||||||
#define MINSTACKREGION (64*1024*1024)
|
#define MINSTACKREGION (64*1024*1024)
|
||||||
|
|
||||||
/* If so, this level: */
|
/* If so, this level: */
|
||||||
#define SCL_NONE 0 /* No sanity checks - vm_assert()s only. */
|
#define SCL_NONE 0 /* No sanity checks - assert()s only. */
|
||||||
#define SCL_TOP 1 /* Main loop and other high-level places. */
|
#define SCL_TOP 1 /* Main loop and other high-level places. */
|
||||||
#define SCL_FUNCTIONS 2 /* Function entry/exit. */
|
#define SCL_FUNCTIONS 2 /* Function entry/exit. */
|
||||||
#define SCL_DETAIL 3 /* Detailled steps. */
|
#define SCL_DETAIL 3 /* Detailled steps. */
|
||||||
|
|
Loading…
Reference in a new issue