sanchayanmaity/minix
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

vm: use assert() instead of vm_assert(); remove vm_assert().

Browse source
This commit is contained in:
Ben Gras 2010-04-12 12:37:28 +00:00
parent c78250332d
commit 27fc7ab1f3
13 changed files with 259 additions and 271 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

70
servers/vm/alloc.c
View file

@ -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;

114
servers/vm/arch/i386/pagetable.c
View file

@ -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;

2
servers/vm/arch/i386/vm.c
View file

@ -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;
} }

24
servers/vm/exec.c
View file

@ -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);

10
servers/vm/fork.c
View file

@ -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");

2
servers/vm/mmap.c
View file

@ -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);

16
servers/vm/pagefaults.c
View file

@ -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)

226
servers/vm/region.c
View file

@ -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;

4
servers/vm/rs.c
View file

@ -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) {

4
servers/vm/sanitycheck.h
View file

@ -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; \
} }

44
servers/vm/slaballoc.c
View file

@ -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);

12
servers/vm/util.h
View file

@ -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

2
servers/vm/vm.h
View file

@ -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. */