From: Ben Gras <ben@minix3.org>
Date: Mon, 12 Apr 2010 12:37:28 +0000 (+0000)
Subject: vm: use assert() instead of vm_assert(); remove vm_assert().
X-Git-Tag: v3.1.7~153
X-Git-Url: http://zhaoyanbai.com/repos/%22../static/icons/ChangeLog.html?a=commitdiff_plain;h=27fc7ab1f3b457147f6070a42d7a700dbb376dc3;p=minix.git

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

diff --git a/servers/vm/alloc.c b/servers/vm/alloc.c
index 8a903ae86..4e1cb65de 100644
--- a/servers/vm/alloc.c
+++ b/servers/vm/alloc.c
@@ -49,8 +49,8 @@ addr_avl addravl;
 /* Used for sanity check. */
 PRIVATE phys_bytes mem_low, mem_high;
 #define assert_range(addr, len)  			\
-	vm_assert((addr) >= mem_low);			\
-	vm_assert((addr) + (len) - 1 <= mem_high);
+	assert((addr) >= mem_low);			\
+	assert((addr) + (len) - 1 <= mem_high);
 
 struct hole {
 	struct hole *h_next;          /* pointer to next entry on the list */
@@ -104,7 +104,7 @@ int line;
   if(!(c)) { \
 	printf("holes_sanity_f:%s:%d: %s failed\n", file, line, #c); \
 	util_stacktrace();	\
-	panic("vm_assert failed"); } \
+	panic("assert failed"); } \
   }	
 
 	int h, c = 0, n = 0;
@@ -184,7 +184,7 @@ PUBLIC phys_clicks alloc_mem(phys_clicks clicks, u32_t memflags)
   }
 
   if(vm_paged) {
-	vm_assert(CLICK_SIZE == VM_PAGE_SIZE);
+	assert(CLICK_SIZE == VM_PAGE_SIZE);
 	mem = alloc_pages(clicks, memflags, NULL);
   } else {
 CHECKHOLES;
@@ -255,7 +255,7 @@ CHECKHOLES;
   if (clicks == 0) return;
 
   if(vm_paged) {
-	vm_assert(CLICK_SIZE == VM_PAGE_SIZE);
+	assert(CLICK_SIZE == VM_PAGE_SIZE);
 	free_pages(base, clicks);
 	return;
   }
@@ -408,10 +408,10 @@ PRIVATE void sanitycheck(void)
 	addr_start_iter_least(&addravl, &iter);
 	while((p=addr_get_iter(&iter))) {
 		SLABSANE(p);
-		vm_assert(p->size > 0);
+		assert(p->size > 0);
 		if(prevp) {
-			vm_assert(prevp->addr < p->addr);
-			vm_assert(prevp->addr + p->addr < p->addr);
+			assert(prevp->addr < p->addr);
+			assert(prevp->addr + p->addr < p->addr);
 		}
 		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))) {
 		SLABSANE(pr);
-		vm_assert(pr->size > 0);
+		assert(pr->size > 0);
 		if(pr->size >= pages || (memflags & PAF_FIRSTBLOCK)) {
 			if(memflags & PAF_LOWER16MB) {
 				if(pr->addr + pages > boundary16)
@@ -509,7 +509,7 @@ PRIVATE PUBLIC phys_bytes alloc_pages(int pages, int memflags, phys_bytes *len)
 	SLABSANE(pr);
 
 	if(memflags & PAF_FIRSTBLOCK) {
-		vm_assert(len);
+		assert(len);
 		/* block doesn't have to as big as requested;
 		 * 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. */
 	mem = pr->addr + pr->size - pages;
 
-	vm_assert(pr->size >= pages);
+	assert(pr->size >= pages);
 	if(pr->size == pages) {
 		pagerange_t *prr;
 		prr = addr_remove(&addravl, pr->addr);
-		vm_assert(prr);
-		vm_assert(prr == pr);
+		assert(prr);
+		assert(prr == pr);
 		SLABFREE(pr);
 #if SANITYCHECKS
 		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",
 			firstpages, pages, finalpages);
 	}
-	vm_assert(finalnodes == wantnodes);
-	vm_assert(finalpages == wantpages);
+	assert(finalnodes == wantnodes);
+	assert(finalpages == wantpages);
 #endif
 
 	return mem;
@@ -581,7 +581,7 @@ PRIVATE void free_pages(phys_bytes pageno, int npages)
 	wantpages = firstpages + npages;
 #endif
 
-	vm_assert(!addr_search(&addravl, pageno, AVL_EQUAL));
+	assert(!addr_search(&addravl, pageno, AVL_EQUAL));
 
 	/* try to merge with higher neighbour */
 	if((pr=addr_search(&addravl, pageno+npages, AVL_EQUAL))) {
@@ -598,7 +598,7 @@ PRIVATE void free_pages(phys_bytes pageno, int npages)
 
 		sanitycheck();
 #endif
-		vm_assert(npages > 0);
+		assert(npages > 0);
 		USE(pr, pr->addr = pageno;
 			 pr->size = npages;);
 		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);
 	p = addr_get_iter(&iter);
-	vm_assert(p);
-	vm_assert(p == pr);
+	assert(p);
+	assert(p == pr);
 
 	addr_decr_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);
 	sanitycheck();
 
-	vm_assert(finalnodes == wantnodes);
-	vm_assert(finalpages == wantpages);
+	assert(finalnodes == wantnodes);
+	assert(finalpages == wantpages);
 #endif
 }
 
@@ -864,9 +864,9 @@ int usedpages_add_f(phys_bytes addr, phys_bytes len, char *file, int line)
 	if(!incheck)
 		return OK;
 
-	vm_assert(!(addr % VM_PAGE_SIZE));
-	vm_assert(!(len % VM_PAGE_SIZE));
-	vm_assert(len > 0);
+	assert(!(addr % VM_PAGE_SIZE));
+	assert(!(len % VM_PAGE_SIZE));
+	assert(len > 0);
 	assert_range(addr, len);
 
 	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) {
 		phys_bytes thisaddr;
-		vm_assert(pagestart > 0);
-		vm_assert(pagestart < MAXPAGES);
+		assert(pagestart > 0);
+		assert(pagestart < MAXPAGES);
 		thisaddr = pagestart * VM_PAGE_SIZE;
 		if(GET_BIT(pagemap, pagestart)) {
 			int i;
@@ -901,8 +901,8 @@ struct memlist *alloc_mem_in_list(phys_bytes bytes, u32_t flags)
 	phys_bytes rempages;
 	struct memlist *head = NULL, *ml;
 
-	vm_assert(bytes > 0);
-	vm_assert(!(bytes % VM_PAGE_SIZE));
+	assert(bytes > 0);
+	assert(!(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;
 		}
 
-		vm_assert(gotpages <= rempages);
-		vm_assert(gotpages > 0);
+		assert(gotpages <= rempages);
+		assert(gotpages > 0);
 
 		if(!(SLABALLOC(ml))) {
 			free_mem_list(head, 1);
@@ -941,8 +941,8 @@ struct memlist *alloc_mem_in_list(phys_bytes bytes, u32_t flags)
 	} while(rempages > 0);
 
 	for(ml = head; ml; ml = ml->next) {
-		vm_assert(ml->phys);
-		vm_assert(ml->length);
+		assert(ml->phys);
+		assert(ml->length);
 	}
 
 	return head;
@@ -956,8 +956,8 @@ void free_mem_list(struct memlist *list, int all)
 	while(list) {
 		struct memlist *next;
 		next = list->next;
-		vm_assert(!(list->phys % VM_PAGE_SIZE));
-		vm_assert(!(list->length % VM_PAGE_SIZE));
+		assert(!(list->phys % VM_PAGE_SIZE));
+		assert(!(list->length % VM_PAGE_SIZE));
 		if(all)
 			free_pages(list->phys / 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)
 {
 	while(list) {
-		vm_assert(list->length > 0);
+		assert(list->length > 0);
 		printf("0x%lx-0x%lx", list->phys, list->phys+list->length-1);
 		printf(" ");
 		list = list->next;
diff --git a/servers/vm/arch/i386/pagetable.c b/servers/vm/arch/i386/pagetable.c
index 5946b8986..cc3e8f776 100644
--- a/servers/vm/arch/i386/pagetable.c
+++ b/servers/vm/arch/i386/pagetable.c
@@ -160,10 +160,10 @@ PRIVATE u32_t findhole(pt_t *pt, u32_t vmin, u32_t vmax)
 	static u32_t lastv = 0;
 
 	/* Input sanity check. */
-	vm_assert(vmin + I386_PAGE_SIZE >= vmin);
-	vm_assert(vmax >= vmin + I386_PAGE_SIZE);
-	vm_assert((vmin % I386_PAGE_SIZE) == 0);
-	vm_assert((vmax % I386_PAGE_SIZE) == 0);
+	assert(vmin + I386_PAGE_SIZE >= vmin);
+	assert(vmax >= vmin + I386_PAGE_SIZE);
+	assert((vmin % I386_PAGE_SIZE) == 0);
+	assert((vmax % I386_PAGE_SIZE) == 0);
 
 #if SANITYCHECKS
 	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) {
 		int pte;
 
-		vm_assert(curv >= vmin);
-		vm_assert(curv < vmax);
+		assert(curv >= vmin);
+		assert(curv < vmax);
 
 		pde = I386_VM_PDE(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)
 {
-	vm_assert(reason >= 0 && reason < VMP_CATEGORIES);
+	assert(reason >= 0 && reason < VMP_CATEGORIES);
 	if(vir >= vmprocess->vm_stacktop) {
-		vm_assert(!(vir % I386_PAGE_SIZE)); 
-		vm_assert(!(phys % I386_PAGE_SIZE)); 
+		assert(!(vir % I386_PAGE_SIZE)); 
+		assert(!(phys % I386_PAGE_SIZE)); 
 		free_mem(ABS2CLICK(phys), pages);
 		if(pt_writemap(&vmprocess->vm_pt, arch_vir2map(vmprocess, vir),
 			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)
 {
 	int s;
-	vm_assert(missing_spares >= 0 && missing_spares <= SPAREPAGES);
+	assert(missing_spares >= 0 && missing_spares <= SPAREPAGES);
 	for(s = 0; s < SPAREPAGES; s++) {
 		if(sparepages[s].page) {
 			void *sp;
@@ -247,7 +247,7 @@ PRIVATE void *vm_getsparepage(u32_t *phys)
 			*phys = sparepages[s].phys;
 			sparepages[s].page = NULL;
 			missing_spares++;
-			vm_assert(missing_spares >= 0 && missing_spares <= SPAREPAGES);
+			assert(missing_spares >= 0 && missing_spares <= SPAREPAGES);
 			return sp;
 		}
 	}
@@ -261,15 +261,15 @@ PRIVATE void *vm_checkspares(void)
 {
 	int s, n = 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++)
 	    if(!sparepages[s].page) {
 		n++;
 		if((sparepages[s].page = vm_allocpage(&sparepages[s].phys, 
 			VMP_SPARE))) {
 			missing_spares--;
-			vm_assert(missing_spares >= 0);
-			vm_assert(missing_spares <= SPAREPAGES);
+			assert(missing_spares >= 0);
+			assert(missing_spares <= SPAREPAGES);
 		} else {
 			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;
 
 	pt = &vmprocess->vm_pt;
-	vm_assert(reason >= 0 && reason < VMP_CATEGORIES);
+	assert(reason >= 0 && reason < VMP_CATEGORIES);
 
 	level++;
 
-	vm_assert(level >= 1);
-	vm_assert(level <= 2);
+	assert(level >= 1);
+	assert(level <= 2);
 
 	if(level > 1 || !(vmprocess->vm_flags & VMF_HASPT) || !meminit_done) {
 		int r;
@@ -370,7 +370,7 @@ PUBLIC void vm_pagelock(void *vir, int lockflag)
 	pt = &vmprocess->vm_pt;
 	m = arch_vir2map(vmprocess, (vir_bytes) vir);
 
-	vm_assert(!(m % I386_PAGE_SIZE));
+	assert(!(m % I386_PAGE_SIZE));
 
 	if(!lockflag)
 		flags |= I386_VM_WRITE;
@@ -443,14 +443,14 @@ PRIVATE int pt_ptalloc(pt_t *pt, int pde, u32_t flags)
 	u32_t pt_phys;
 
 	/* Argument must make sense. */
-	vm_assert(pde >= 0 && pde < I386_VM_DIR_ENTRIES);
-	vm_assert(!(flags & ~(PTF_ALLFLAGS)));
+	assert(pde >= 0 && pde < I386_VM_DIR_ENTRIES);
+	assert(!(flags & ~(PTF_ALLFLAGS)));
 
 	/* We don't expect to overwrite page directory entry, nor
 	 * storage for the page table.
 	 */
-	vm_assert(!(pt->pt_dir[pde] & I386_VM_PRESENT));
-	vm_assert(!pt->pt_pt[pde]);
+	assert(!(pt->pt_dir[pde] & I386_VM_PRESENT));
+	assert(!pt->pt_pt[pde]);
 
 	/* Get storage for the page table. */
         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)
 		verify = 1;
 
-	vm_assert(!(bytes % I386_PAGE_SIZE));
-	vm_assert(!(flags & ~(PTF_ALLFLAGS)));
+	assert(!(bytes % I386_PAGE_SIZE));
+	assert(!(flags & ~(PTF_ALLFLAGS)));
 
 	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
 	 * isn't on, so we can just write MAP_NONE into it.
 	 */
-	vm_assert(physaddr == MAP_NONE || (flags & I386_VM_PRESENT));
-	vm_assert(physaddr != MAP_NONE || !flags);
+	assert(physaddr == MAP_NONE || (flags & I386_VM_PRESENT));
+	assert(physaddr != MAP_NONE || !flags);
 
 	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.
 	 */
 	for(pdecheck = I386_VM_PDE(v); pdecheck <= finalpde; pdecheck++) {
-		vm_assert(pdecheck >= 0 && pdecheck < I386_VM_DIR_ENTRIES);
-		vm_assert(!(pt->pt_dir[pdecheck] & I386_VM_BIGPAGE));
+		assert(pdecheck >= 0 && pdecheck < I386_VM_DIR_ENTRIES);
+		assert(!(pt->pt_dir[pdecheck] & I386_VM_BIGPAGE));
 		if(!(pt->pt_dir[pdecheck] & I386_VM_PRESENT)) {
 			int r;
 			if(verify) {
 				printf("pt_writemap verify: no pde %d\n", pdecheck);
 				return EFAULT;
 			}
-			vm_assert(!pt->pt_dir[pdecheck]);
+			assert(!pt->pt_dir[pdecheck]);
 			if((r=pt_ptalloc(pt, pdecheck, flags)) != OK) {
 				/* Couldn't do (complete) mapping.
 				 * 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;
 			}
 		}
-		vm_assert(pt->pt_dir[pdecheck] & I386_VM_PRESENT);
+		assert(pt->pt_dir[pdecheck] & I386_VM_PRESENT);
 	}
 
 	/* 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 pte = I386_VM_PTE(v);
 
-		vm_assert(!(v % I386_PAGE_SIZE));
-		vm_assert(pte >= 0 && pte < I386_VM_PT_ENTRIES);
-		vm_assert(pde >= 0 && pde < I386_VM_DIR_ENTRIES);
+		assert(!(v % I386_PAGE_SIZE));
+		assert(pte >= 0 && pte < I386_VM_PT_ENTRIES);
+		assert(pde >= 0 && pde < I386_VM_DIR_ENTRIES);
 
 		/* 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
 		 * is marked present and page table entry is available.
 		 */
-		vm_assert((pt->pt_dir[pde] & I386_VM_PRESENT));
-		vm_assert(pt->pt_pt[pde]);
+		assert((pt->pt_dir[pde] & I386_VM_PRESENT));
+		assert(pt->pt_pt[pde]);
 
 #if SANITYCHECKS
 		/* We don't expect to overwrite a page. */
 		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
 		if(writemapflags & (WMF_WRITEFLAGSONLY|WMF_FREE)) {
 			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 {
 			/* Write pagetable entry. */
 #if SANITYCHECKS
-			vm_assert(vm_addrok(pt->pt_pt[pde], 1));
+			assert(vm_addrok(pt->pt_pt[pde], 1));
 #endif
 			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;
 
-	vm_assert(!(bytes % I386_PAGE_SIZE));
+	assert(!(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 pte = I386_VM_PTE(v);
 
-		vm_assert(!(v % I386_PAGE_SIZE));
-		vm_assert(pte >= 0 && pte < I386_VM_PT_ENTRIES);
-		vm_assert(pde >= 0 && pde < I386_VM_DIR_ENTRIES);
+		assert(!(v % I386_PAGE_SIZE));
+		assert(pte >= 0 && pte < I386_VM_PT_ENTRIES);
+		assert(pde >= 0 && pde < I386_VM_DIR_ENTRIES);
 
 		/* Page table has to be there. */
 		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
 		 * 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)) {
 			return EFAULT;
@@ -767,14 +767,14 @@ PUBLIC void pt_init(phys_bytes usedlimit)
         hi = CLICK2ABS(vmprocess->vm_arch.vm_seg[S].mem_phys +
                 vmprocess->vm_arch.vm_seg[S].mem_len);
                   
-        vm_assert(!(lo % I386_PAGE_SIZE)); 
-        vm_assert(!(hi % I386_PAGE_SIZE));
+        assert(!(lo % I386_PAGE_SIZE)); 
+        assert(!(hi % I386_PAGE_SIZE));
  
         if(lo < VM_PROCSTART) {
                 moveup = VM_PROCSTART - lo;
-                vm_assert(!(VM_PROCSTART % I386_PAGE_SIZE));
-                vm_assert(!(lo % I386_PAGE_SIZE));
-                vm_assert(!(moveup % I386_PAGE_SIZE));
+                assert(!(VM_PROCSTART % I386_PAGE_SIZE));
+                assert(!(lo % I386_PAGE_SIZE));
+                assert(!(moveup % I386_PAGE_SIZE));
         }
         
         /* 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;
 
 	/* Basic sanity checks. */
-	vm_assert(who);
-	vm_assert(who->vm_flags & VMF_INUSE);
-	vm_assert(pt);
+	assert(who);
+	assert(who->vm_flags & VMF_INUSE);
+	assert(pt);
 
 	slot = who->vm_slot;
-	vm_assert(slot >= 0);
-	vm_assert(slot < ELEMENTS(vmproc));
-	vm_assert(slot < I386_VM_PT_ENTRIES);
+	assert(slot >= 0);
+	assert(slot < ELEMENTS(vmproc));
+	assert(slot < I386_VM_PT_ENTRIES);
 
 	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." */
 	page_directories[slot] = phys | I386_VM_PRESENT|I386_VM_WRITE;
@@ -972,14 +972,14 @@ PUBLIC int pt_mapkernel(pt_t *pt)
 	int r, i;
 
         /* 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) {
 		int pde;
 		for(pde = 0; pde <= id_map_high_pde; pde++) {
 			phys_bytes addr;
 			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 |
 				I386_VM_BIGPAGE | I386_VM_USER |
 				I386_VM_WRITE | global_bit;
diff --git a/servers/vm/arch/i386/vm.c b/servers/vm/arch/i386/vm.c
index 804ea334b..16079e6da 100644
--- a/servers/vm/arch/i386/vm.c
+++ b/servers/vm/arch/i386/vm.c
@@ -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);
 
 	/* Could be a text address. */
-	vm_assert(datastart <= addr || textstart <= addr);
+	assert(datastart <= addr || textstart <= addr);
 
 	return addr - datastart;
 }
diff --git a/servers/vm/exec.c b/servers/vm/exec.c
index 5bcac2c08..7c8465f63 100644
--- a/servers/vm/exec.c
+++ b/servers/vm/exec.c
@@ -193,7 +193,7 @@ vir_bytes *stack_top;		/* top of process stack */
   /* No need to allocate text if it can be shared. */
   if (sh_mp != NULL) {
 	text_bytes = 0;
-	vm_assert(!vm_paged);
+	assert(!vm_paged);
   }
 
   /* 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;
 	  pt_free(&rmp->vm_pt);
   }
-  vm_assert(!(vmpold->vm_flags & VMF_INUSE));
+  assert(!(vmpold->vm_flags & VMF_INUSE));
   *vmpold = *rmp;	/* copy current state. */
   rmp->vm_regions = NULL; /* exec()ing process regions thrown out. */
 SANITYCHECK(SCL_DETAIL);
@@ -385,11 +385,11 @@ PUBLIC phys_bytes find_kernel_top(void)
 	u32_t kernel_top = 0;
 #define MEMTOP(v, i) \
   (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 = MAX(kernel_top, MEMTOP(VMP_SYSTEM, D));
 	kernel_top = MAX(kernel_top, MEMTOP(VMP_SYSTEM, S));
-	vm_assert(kernel_top);
+	assert(kernel_top);
 
 	return CLICK2ABS(kernel_top);
 }
@@ -414,14 +414,14 @@ PUBLIC int proc_new(struct vmproc *vmp,
 	int prealloc;
 	struct vir_region *reg;
 
-	vm_assert(!(vstart % VM_PAGE_SIZE));
-	vm_assert(!(text_bytes % VM_PAGE_SIZE));
-	vm_assert(!(data_bytes % VM_PAGE_SIZE));
-	vm_assert(!(stack_bytes % VM_PAGE_SIZE));
-	vm_assert(!(gap_bytes % VM_PAGE_SIZE));
-	vm_assert(!(text_start % VM_PAGE_SIZE));
-	vm_assert(!(data_start % VM_PAGE_SIZE));
-	vm_assert((!text_start && !data_start) || (text_start && data_start));
+	assert(!(vstart % VM_PAGE_SIZE));
+	assert(!(text_bytes % VM_PAGE_SIZE));
+	assert(!(data_bytes % VM_PAGE_SIZE));
+	assert(!(stack_bytes % VM_PAGE_SIZE));
+	assert(!(gap_bytes % VM_PAGE_SIZE));
+	assert(!(text_start % VM_PAGE_SIZE));
+	assert(!(data_start % VM_PAGE_SIZE));
+	assert((!text_start && !data_start) || (text_start && data_start));
 
 	/* Place text at start of process. */
 	vmp->vm_arch.vm_seg[T].mem_phys = ABS2CLICK(vstart);
diff --git a/servers/vm/fork.c b/servers/vm/fork.c
index 2ab6dac95..aeafa0cbc 100644
--- a/servers/vm/fork.c
+++ b/servers/vm/fork.c
@@ -56,7 +56,7 @@ PUBLIC int do_fork(message *msg)
 
   vmp = &vmproc[proc];		/* parent */
   vmc = &vmproc[childproc];	/* child */
-  vm_assert(vmc->vm_slot == childproc);
+  assert(vmc->vm_slot == childproc);
 
   if(vmp->vm_flags & VMF_HAS_DMA) {
 	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) {
 		vmc->vm_heap = map_region_lookup_tag(vmc, VRT_HEAP);
-		vm_assert(vmc->vm_heap);
+		assert(vmc->vm_heap);
 	}
 
 	SANITYCHECK(SCL_DETAIL);
@@ -149,10 +149,10 @@ PUBLIC int do_fork(message *msg)
 
 	if(!(heap = map_region_lookup_tag(vmc, VRT_HEAP)))
 		panic("couldn't lookup heap");
-	vm_assert(heap->phys);
+	assert(heap->phys);
 	if(!(stack = map_region_lookup_tag(vmc, VRT_STACK)))
 		panic("couldn't lookup stack");
-	vm_assert(stack->phys);
+	assert(stack->phys);
 
 	/* Now copy the memory regions. */
 
@@ -160,7 +160,7 @@ PUBLIC int do_fork(message *msg)
 		struct vir_region *text;
 		if(!(text = map_region_lookup_tag(vmc, VRT_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),
 			text, 0, text_bytes) != OK)
 				panic("couldn't copy text");
diff --git a/servers/vm/mmap.c b/servers/vm/mmap.c
index 8a5507ca2..c85847a6d 100644
--- a/servers/vm/mmap.c
+++ b/servers/vm/mmap.c
@@ -82,7 +82,7 @@ PUBLIC int do_mmap(message *m)
 	}
 
 	/* Return mapping, as seen from process. */
-	vm_assert(vr);
+	assert(vr);
 	m->VMM_RETADDR = arch_map2vir(vmp, vr->vaddr);
 
 
diff --git a/servers/vm/pagefaults.c b/servers/vm/pagefaults.c
index 4cac55aa4..3624d5f89 100644
--- a/servers/vm/pagefaults.c
+++ b/servers/vm/pagefaults.c
@@ -67,11 +67,11 @@ PUBLIC void do_pagefaults(void)
 			panic("do_pagefaults: endpoint wrong: %d", ep);
 
 		vmp = &vmproc[p];
-		vm_assert(vmp->vm_flags & VMF_INUSE);
+		assert(vmp->vm_flags & VMF_INUSE);
 
 		/* See if address is valid at all. */
 		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", 
 				ep, arch_map2vir(vmp, addr), pf_errstr(err));
 			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
 		 * to cause pagefaults.
 		 */
-		vm_assert(!(region->flags & VR_NOPF));
+		assert(!(region->flags & VR_NOPF));
 
 		/* We do not allow shared memory to cause pagefaults.
 		 * 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(!(region->flags & VR_WRITABLE) && wr) {
@@ -102,7 +102,7 @@ PUBLIC void do_pagefaults(void)
 			continue;
 		}
 
-		vm_assert(addr >= region->vaddr);
+		assert(addr >= region->vaddr);
 		offset = addr - region->vaddr;
 
 		/* 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;
 		} else {
 			vir_bytes offset, sublen;
-			vm_assert(region->vaddr <= mem);
-			vm_assert(!(region->flags & VR_NOPF));
-			vm_assert(!(region->vaddr % VM_PAGE_SIZE));
+			assert(region->vaddr <= mem);
+			assert(!(region->flags & VR_NOPF));
+			assert(!(region->vaddr % VM_PAGE_SIZE));
 			offset = mem - region->vaddr;
 			sublen = len;
 			if(offset + sublen > region->length)
diff --git a/servers/vm/region.c b/servers/vm/region.c
index 4dda6609e..b3f2b3565 100644
--- a/servers/vm/region.c
+++ b/servers/vm/region.c
@@ -242,10 +242,10 @@ PRIVATE int map_ph_writept(struct vmproc *vmp, struct vir_region *vr,
 	int rw;
 	struct phys_block *pb = pr->ph;
 
-	vm_assert(!(vr->vaddr % VM_PAGE_SIZE));
-	vm_assert(!(pb->length % VM_PAGE_SIZE));
-	vm_assert(!(pr->offset % VM_PAGE_SIZE));
-	vm_assert(pb->refcount > 0);
+	assert(!(vr->vaddr % VM_PAGE_SIZE));
+	assert(!(pb->length % VM_PAGE_SIZE));
+	assert(!(pr->offset % VM_PAGE_SIZE));
+	assert(pb->refcount > 0);
 
 	if(WRITABLE(vr, pb))
 		rw = PTF_WRITE;
@@ -283,10 +283,10 @@ PRIVATE vir_bytes region_find_slot(struct vmproc *vmp,
 	SANITYCHECK(SCL_FUNCTIONS);
 
 	/* We must be in paged mode to be able to do this. */
-	vm_assert(vm_paged);
+	assert(vm_paged);
 
 	/* Length must be reasonable. */
-	vm_assert(length > 0);
+	assert(length > 0);
 
 	/* Special case: allow caller to set maxv to 0 meaning 'I want
 	 * it to be mapped in right here.'
@@ -304,13 +304,13 @@ PRIVATE vir_bytes region_find_slot(struct vmproc *vmp,
         }
 
 	/* Basic input sanity checks. */
-	vm_assert(!(length % VM_PAGE_SIZE));
+	assert(!(length % VM_PAGE_SIZE));
 	if(minv >= maxv) {
 		printf("VM: 1 minv: 0x%lx maxv: 0x%lx length: 0x%lx\n",
 			minv, maxv, length);
 	}
-	vm_assert(minv < maxv);
-	vm_assert(minv + length <= maxv);
+	assert(minv < maxv);
+	assert(minv + length <= maxv);
 
 #define FREEVRANGE(rangestart, rangeend, foundcode) {		\
 	vir_bytes frstart = (rangestart), frend = (rangeend);	\
@@ -342,13 +342,13 @@ PRIVATE vir_bytes region_find_slot(struct vmproc *vmp,
 	}
 
 #if SANITYCHECKS
-	if(prevregion) vm_assert(prevregion->vaddr < startv);
+	if(prevregion) assert(prevregion->vaddr < startv);
 #endif
 
 	/* However we got it, startv must be in the requested range. */
-	vm_assert(startv >= minv);
-	vm_assert(startv < maxv);
-	vm_assert(startv + length <= maxv);
+	assert(startv >= minv);
+	assert(startv < maxv);
+	assert(startv + length <= maxv);
 
 	if (prev)
 		*prev = prevregion;
@@ -373,7 +373,7 @@ int mapflags;
 	struct phys_region *ph;
 	physr_avl *phavl;
 
-	vm_assert(!(length % VM_PAGE_SIZE));
+	assert(!(length % VM_PAGE_SIZE));
 
 	SANITYCHECK(SCL_FUNCTIONS);
 
@@ -407,10 +407,10 @@ USE(newregion,
 
 	/* If we know what we're going to map to, map it right away. */
 	if(what != MAP_NONE) {
-		vm_assert(what);	/* mapping in 0 is unlikely to be right */
-		vm_assert(!(what % VM_PAGE_SIZE));
-		vm_assert(!(startv % VM_PAGE_SIZE));
-		vm_assert(!(mapflags & MF_PREALLOC));
+		assert(what);	/* mapping in 0 is unlikely to be right */
+		assert(!(what % VM_PAGE_SIZE));
+		assert(!(startv % VM_PAGE_SIZE));
+		assert(!(mapflags & MF_PREALLOC));
 		if(map_new_physblock(vmp, newregion, 0, length,
 			what, PAF_CLEAR, 0) != OK) {
 			printf("VM: map_new_physblock failed\n");
@@ -433,7 +433,7 @@ USE(newregion,
 
 	/* Link it. */
 	if(prevregion) {
-		vm_assert(prevregion->vaddr < newregion->vaddr);
+		assert(prevregion->vaddr < newregion->vaddr);
 		USE(newregion, newregion->next = prevregion->next;);
 		USE(prevregion, prevregion->next = newregion;);
 	} else {
@@ -442,9 +442,9 @@ USE(newregion,
 	}
 
 #if SANITYCHECKS
-	vm_assert(startv == newregion->vaddr);
+	assert(startv == newregion->vaddr);
 	if(newregion->next) {
-		vm_assert(newregion->vaddr < newregion->next->vaddr);
+		assert(newregion->vaddr < newregion->next->vaddr);
 	}
 #endif
 
@@ -462,9 +462,9 @@ PUBLIC void pb_unreferenced(struct vir_region *region, struct phys_region *pr)
 	int remap = 0;
 
 	pb = pr->ph;
-	vm_assert(pb->refcount > 0);
+	assert(pb->refcount > 0);
 	USE(pb, pb->refcount--;);
-	vm_assert(pb->refcount >= 0);
+	assert(pb->refcount >= 0);
 
 	if(pb->firstregion == pr) {
 		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;
 			others = others->next_ph_list) {
-			vm_assert(others->ph == pb);
+			assert(others->ph == pb);
 			if(others->next_ph_list == pr) {
 				USE(others, others->next_ph_list = pr->next_ph_list;);
 				break;
 			}
 		}
 
-		vm_assert(others); /* Otherwise, wasn't on the list. */
+		assert(others); /* Otherwise, wasn't on the list. */
 	}
 
 	if(pb->refcount == 0) {
-		vm_assert(!pb->firstregion);
+		assert(!pb->firstregion);
 		if(region->flags & VR_ANON) {
 			free_mem(ABS2CLICK(pb->phys),
 				ABS2CLICK(pb->length));
@@ -508,7 +508,7 @@ PUBLIC void pb_unreferenced(struct vir_region *region, struct phys_region *pr)
 			} 
 			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);
 	ph = physr_get_iter(iter);
-	vm_assert(ph);
-	vm_assert(ph->offset == offset);
+	assert(ph);
+	assert(ph->offset == offset);
 
 	return ph;
 }
@@ -546,7 +546,7 @@ PRIVATE int map_subfree(struct vmproc *vmp,
 
 		for(others = pb->firstregion; others;
 			others = others->next_ph_list) {
-			vm_assert(others->ph == pb);
+			assert(others->ph == pb);
 		}
 		physr_incr_iter(&iter);
 	}
@@ -565,19 +565,19 @@ PRIVATE int map_subfree(struct vmproc *vmp,
 			SLABFREE(pr);
 		} else {
 			vir_bytes sublen;
-			vm_assert(len > pr->offset);
-			vm_assert(len < pr->offset + pr->ph->length);
-			vm_assert(pr->ph->refcount > 0);
+			assert(len > pr->offset);
+			assert(len < pr->offset + pr->ph->length);
+			assert(pr->ph->refcount > 0);
 			sublen = len - pr->offset;
-			vm_assert(!(sublen % VM_PAGE_SIZE));
-			vm_assert(sublen < pr->ph->length);
+			assert(!(sublen % VM_PAGE_SIZE));
+			assert(sublen < pr->ph->length);
 			if(pr->ph->refcount > 1) {
 				int r;
 				if(!(pr = map_clone_ph_block(vmp, region,
 					pr, &iter)))
 					return ENOMEM;
 			}
-			vm_assert(pr->ph->refcount == 1);
+			assert(pr->ph->refcount == 1);
 			if(!(region->flags & VR_DIRECT)) {
 				free_mem(ABS2CLICK(pr->ph->phys), ABS2CLICK(sublen));
 			}
@@ -585,9 +585,9 @@ PRIVATE int map_subfree(struct vmproc *vmp,
 			USE(pr->ph,
 				pr->ph->phys += sublen;
 				pr->ph->length -= sublen;);
-			vm_assert(!(pr->offset % VM_PAGE_SIZE));
-			vm_assert(!(pr->ph->phys % VM_PAGE_SIZE));
-			vm_assert(!(pr->ph->length % VM_PAGE_SIZE));
+			assert(!(pr->offset % VM_PAGE_SIZE));
+			assert(!(pr->ph->phys % VM_PAGE_SIZE));
+			assert(!(pr->ph->length % VM_PAGE_SIZE));
 		}
 	}
 
@@ -704,7 +704,7 @@ int written;
 
 	SANITYCHECK(SCL_FUNCTIONS);
 
-	vm_assert(!(length % VM_PAGE_SIZE));
+	assert(!(length % VM_PAGE_SIZE));
 
 	if((region->flags & VR_CONTIG) &&
 		(start_offset > 0 || length < region->length)) {
@@ -727,15 +727,15 @@ int written;
 		given.next = NULL;
 		memlist = &given;
 		used_memlist = 0;
-		vm_assert(given.phys);
-		vm_assert(given.length);
+		assert(given.phys);
+		assert(given.length);
 	}
 
 	r = OK;
 
 	for(ml = memlist; ml; ml = ml->next) {
-		vm_assert(ml->phys);
-		vm_assert(ml->length);
+		assert(ml->phys);
+		assert(ml->length);
 	}
 
 	for(ml = memlist; ml; ml = ml->next) {
@@ -751,11 +751,11 @@ int written;
 			break;
 		}
 
-		vm_assert(ml->phys);
-		vm_assert(ml->length);
+		assert(ml->phys);
+		assert(ml->length);
 
 		/* New physical block. */
-		vm_assert(!(ml->phys % VM_PAGE_SIZE));
+		assert(!(ml->phys % VM_PAGE_SIZE));
 
 		USE(newpb,
 		newpb->phys = ml->phys;
@@ -796,13 +796,13 @@ int written;
 				offset += ml->length;
 				if((physr = physr_search(region->phys, offset,
 					AVL_EQUAL))) {
-					vm_assert(physr->ph->refcount == 1);
+					assert(physr->ph->refcount == 1);
 					pb_unreferenced(region, physr);
 					physr_remove(region->phys, physr->offset);
 					SLABFREE(physr);
 				}
 			}
-		} else vm_assert(mapped == length);
+		} else assert(mapped == length);
 
 		/* Always clean up the memlist itself, even if everything
 		 * worked we're not using the memlist nodes any more. And
@@ -863,9 +863,9 @@ physr_iter *iter;
 	SANITYCHECK(SCL_DETAIL);
 	SLABSANE(ph);
 	SLABSANE(ph->ph);
-	vm_assert(ph->ph->refcount > 1);
+	assert(ph->ph->refcount > 1);
 	pb_unreferenced(region, ph);
-	vm_assert(ph->ph->refcount >= 1);
+	assert(ph->ph->refcount >= 1);
 	physr_remove(region->phys, offset);
 	SLABFREE(ph);
 
@@ -873,8 +873,8 @@ physr_iter *iter;
 
 	/* Put new free memory in. */
 	allocflags = vrallocflags(region->flags);
-	vm_assert(!(allocflags & PAF_CONTIG));
-	vm_assert(!(allocflags & PAF_CLEAR));
+	assert(!(allocflags & PAF_CONTIG));
+	assert(!(allocflags & PAF_CLEAR));
 
 	if(map_new_physblock(vmp, region, offset, length,
 		MAP_NONE, allocflags, written) != OK) {
@@ -891,12 +891,12 @@ physr_iter *iter;
 		panic("copy_abs2region failed, no good reason for that");
 
 	newpr = physr_search(region->phys, offset, AVL_EQUAL);
-	vm_assert(newpr);
-	vm_assert(newpr->offset == offset);
+	assert(newpr);
+	assert(newpr->offset == offset);
 
 	if(iter) {
 		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);
@@ -918,11 +918,11 @@ int write;
 	struct phys_region *ph;
 	int r = OK;
 
-	vm_assert(offset >= 0);
-	vm_assert(offset < region->length);
+	assert(offset >= 0);
+	assert(offset < region->length);
 
-	vm_assert(region->flags & VR_ANON);
-	vm_assert(!(region->vaddr % VM_PAGE_SIZE));
+	assert(region->flags & VR_ANON);
+	assert(!(region->vaddr % VM_PAGE_SIZE));
 
 	virpage = offset - offset % VM_PAGE_SIZE;
 
@@ -932,9 +932,9 @@ int write;
 	   (ph->offset <= offset && offset < ph->offset + ph->ph->length)) {
 		phys_bytes blockoffset = ph->offset;
 		/* Pagefault in existing block. Do copy-on-write. */
-		vm_assert(write);
-		vm_assert(region->flags & VR_WRITABLE);
-		vm_assert(ph->ph->refcount > 0);
+		assert(write);
+		assert(region->flags & VR_WRITABLE);
+		assert(ph->ph->refcount > 0);
 
 		if(WRITABLE(region, ph->ph)) {
 			r = map_ph_writept(vmp, region, ph);
@@ -1010,11 +1010,11 @@ int write;
 
 	SANITYCHECK(SCL_FUNCTIONS);
 
-	vm_assert(region->flags & VR_ANON);
-	vm_assert(!(region->vaddr % VM_PAGE_SIZE));
-	vm_assert(!(offset % VM_PAGE_SIZE));
-	vm_assert(!(length % VM_PAGE_SIZE));
-	vm_assert(!write || (region->flags & VR_WRITABLE));
+	assert(region->flags & VR_ANON);
+	assert(!(region->vaddr % VM_PAGE_SIZE));
+	assert(!(offset % VM_PAGE_SIZE));
+	assert(!(length % VM_PAGE_SIZE));
+	assert(!write || (region->flags & VR_WRITABLE));
 
 	physr_start_iter(region->phys, &iter, offset, AVL_LESS_EQUAL);
 	physr = physr_get_iter(&iter);
@@ -1046,7 +1046,7 @@ int write;
 		SANITYCHECK(SCL_DETAIL);
 
 		if(write) {
-		  vm_assert(physr->ph->refcount > 0);
+		  assert(physr->ph->refcount > 0);
 		  if(!WRITABLE(region, physr->ph)) {
 			if(!(physr = map_clone_ph_block(vmp, region,
 				physr, &iter))) {
@@ -1170,13 +1170,13 @@ PRIVATE struct vir_region *map_copy_region(struct vmproc *vmp, struct vir_region
 #endif
 		physr_insert(newvr->phys, newph);
 #if SANITYCHECKS
-		vm_assert(countregions(vr) == cr);
+		assert(countregions(vr) == cr);
 #endif
 		physr_incr_iter(&iter);
 	}
 
 #if SANITYCHECKS
-	vm_assert(countregions(vr) == countregions(newvr));
+	assert(countregions(vr) == countregions(newvr));
 #endif
 
 	return newvr;
@@ -1189,28 +1189,28 @@ PUBLIC int copy_abs2region(phys_bytes abs, struct vir_region *destregion,
 	phys_bytes offset, phys_bytes len)
 
 {
-	vm_assert(destregion);
-	vm_assert(destregion->phys);
+	assert(destregion);
+	assert(destregion->phys);
 	while(len > 0) {
 		phys_bytes sublen, suboffset;
 		struct phys_region *ph;
-		vm_assert(destregion);
-		vm_assert(destregion->phys);
+		assert(destregion);
+		assert(destregion->phys);
 		if(!(ph = physr_search(destregion->phys, offset, AVL_LESS_EQUAL))) {
 			printf("VM: copy_abs2region: no phys region found (1).\n");
 			return EFAULT;
 		}
-		vm_assert(ph->offset <= offset);
+		assert(ph->offset <= offset);
 		if(ph->offset+ph->ph->length <= offset) {
 			printf("VM: copy_abs2region: no phys region found (2).\n");
 			return EFAULT;
 		}
 		suboffset = offset - ph->offset;
-		vm_assert(suboffset < ph->ph->length);
+		assert(suboffset < ph->ph->length);
 		sublen = len;
 		if(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) {
 			printf("VM: copy_abs2region: no phys region found (3).\n");
 			return EFAULT;
@@ -1292,21 +1292,21 @@ struct vmproc *src;
 			/* Check two physregions both are nonnull,
 			 * are different, and match physblocks.
 			 */
-			vm_assert(new_ph);
-			vm_assert(orig_ph);
-			vm_assert(orig_ph != new_ph);
+			assert(new_ph);
+			assert(orig_ph);
+			assert(orig_ph != new_ph);
 			pb = orig_ph->ph;
-			vm_assert(pb == new_ph->ph);
+			assert(pb == new_ph->ph);
 
 			/* 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(pb, pb->firstregion = new_ph;);
 
 			/* Increase phys block refcount */
-			vm_assert(pb->refcount > 0);
+			assert(pb->refcount > 0);
 			USE(pb, pb->refcount++;);
-			vm_assert(pb->refcount > 1);
+			assert(pb->refcount > 1);
 
 			/* If the phys block has been shared as SMAP,
 			 * do the regular copy. */
@@ -1321,7 +1321,7 @@ struct vmproc *src;
 			physr_incr_iter(&iter_orig);
 			physr_incr_iter(&iter_new);
 		}
-		vm_assert(!physr_get_iter(&iter_new));
+		assert(!physr_get_iter(&iter_new));
 		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
 	 * make the function a bit simpler (free all regions on error).
 	 */
-	vm_assert(!vmp->vm_regions);
-	vm_assert(vmproc[VMP_SYSTEM].vm_flags & VMF_INUSE);
-	vm_assert(!(KERNEL_TEXT % VM_PAGE_SIZE));
-	vm_assert(!(KERNEL_TEXT_LEN % VM_PAGE_SIZE));
-	vm_assert(!(KERNEL_DATA % VM_PAGE_SIZE));
-	vm_assert(!(KERNEL_DATA_LEN % VM_PAGE_SIZE));
+	assert(!vmp->vm_regions);
+	assert(vmproc[VMP_SYSTEM].vm_flags & VMF_INUSE);
+	assert(!(KERNEL_TEXT % VM_PAGE_SIZE));
+	assert(!(KERNEL_TEXT_LEN % VM_PAGE_SIZE));
+	assert(!(KERNEL_DATA % VM_PAGE_SIZE));
+	assert(!(KERNEL_DATA_LEN % VM_PAGE_SIZE));
 
 	if(!(vr = map_page_region(vmp, KERNEL_TEXT, 0, KERNEL_TEXT_LEN, 
 		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;
 
-	vm_assert(vr);
-	vm_assert(vr->flags & VR_ANON);
-	vm_assert(!(delta % VM_PAGE_SIZE));
+	assert(vr);
+	assert(vr->flags & VR_ANON);
+	assert(!(delta % VM_PAGE_SIZE));
 
 	if(!delta) return OK;
 	end = vr->vaddr + vr->length;
-	vm_assert(end >= vr->vaddr);
+	assert(end >= vr->vaddr);
 
 	if(end + delta <= end) {
 		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)
 {
-	vm_assert(vr);
-	vm_assert(vr->flags & VR_ANON);
-	vm_assert(!(delta % VM_PAGE_SIZE));
+	assert(vr);
+	assert(vr->flags & VR_ANON);
+	assert(!(delta % VM_PAGE_SIZE));
 
 #if 0
 	printf("VM: ignoring region shrink\n");
@@ -1493,7 +1493,7 @@ PUBLIC int map_unmap_region(struct vmproc *vmp, struct vir_region *region,
 		 * same amount.
 		 */
 		while((pr = physr_get_iter(&iter))) {
-			vm_assert(pr->offset >= len);
+			assert(pr->offset >= len);
 			USE(pr, pr->offset -= len;);
 			physr_incr_iter(&iter);
 		}
@@ -1525,7 +1525,7 @@ PUBLIC int map_remap(struct vmproc *dvmp, vir_bytes da, size_t size,
 
 	SANITYCHECK(SCL_FUNCTIONS);
 
-	vm_assert(region->flags & VR_SHARED);
+	assert(region->flags & VR_SHARED);
 
 	/* da is handled differently */
 	if (!da)
@@ -1536,7 +1536,7 @@ PUBLIC int map_remap(struct vmproc *dvmp, vir_bytes da, size_t size,
 
 	prev = NULL;
 	/* 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);
 	if (startv == (vir_bytes) -1) {
 		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->tag = VRT_NONE;
 	vr->parent = dvmp;);
-	vm_assert(vr->flags & VR_SHARED);
+	assert(vr->flags & VR_SHARED);
 
 	if (prev) {
 		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);
 	while((ph = physr_get_iter(&iter))) {
 		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(pb, pb->firstregion = ph;);
 		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);
 	ph = physr_get_iter(&iter);
 
-	vm_assert(ph);
-	vm_assert(ph->ph);
+	assert(ph);
+	assert(ph->ph);
 	if (r)
 		*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);
 	ph = physr_get_iter(&iter);
 
-	vm_assert(ph);
-	vm_assert(ph->ph);
+	assert(ph);
+	assert(ph->ph);
 	if (cnt)
 		*cnt = ph->ph->refcount;
 
@@ -1856,7 +1856,7 @@ PUBLIC int unmap_memory(endpoint_t sour, endpoint_t dest,
 	vmd = &vmproc[p];
 
 	vrd = map_lookup(vmd, virt_d);
-	vm_assert(vrd);
+	assert(vrd);
 
 	/* Search for the first phys region in the destination process. */
 	off = virt_d - vrd->vaddr;
@@ -1869,8 +1869,8 @@ PUBLIC int unmap_memory(endpoint_t sour, endpoint_t dest,
 	end = off + length;
 	while((pr = physr_get_iter(&iter)) && off < end) {
 		pb = pr->ph;
-		vm_assert(pb->refcount > 1);
-		vm_assert(pb->share_flag == PBSH_SMAP);
+		assert(pb->refcount > 1);
+		assert(pb->share_flag == PBSH_SMAP);
 
 		if(!(pr = map_clone_ph_block(vmd, vrd, pr, &iter)))
 			return ENOMEM;
@@ -2012,9 +2012,9 @@ PUBLIC int map_memory(endpoint_t sour, endpoint_t dest,
 	vmd = &vmproc[p];
 
 	vrs = map_lookup(vms, virt_s);
-	vm_assert(vrs);
+	assert(vrs);
 	vrd = map_lookup(vmd, virt_d);
-	vm_assert(vrd);
+	assert(vrd);
 
 	/* Linear address -> offset from start of vir region. */
 	offset_s = virt_s - vrs->vaddr;
diff --git a/servers/vm/rs.c b/servers/vm/rs.c
index 623240eca..fd453eb40 100644
--- a/servers/vm/rs.c
+++ b/servers/vm/rs.c
@@ -123,8 +123,8 @@ PUBLIC int do_rs_update(message *m_ptr)
 	}
 
 	/* Adjust page tables. */
-	vm_assert(src_vmp->vm_flags & VMF_HASPT);
-	vm_assert(dst_vmp->vm_flags & VMF_HASPT);
+	assert(src_vmp->vm_flags & VMF_HASPT);
+	assert(dst_vmp->vm_flags & VMF_HASPT);
 	pt_bind(&src_vmp->vm_pt, src_vmp);
 	pt_bind(&dst_vmp->vm_pt, dst_vmp);
 	if((r=sys_vmctl(SELF, VMCTL_FLUSHTLB, 0)) != OK) {
diff --git a/servers/vm/sanitycheck.h b/servers/vm/sanitycheck.h
index f341ff531..730786923 100644
--- a/servers/vm/sanitycheck.h
+++ b/servers/vm/sanitycheck.h
@@ -20,7 +20,7 @@
 
 #define SANITYCHECK(l) if(!nocheck && ((l) <= vm_sanitychecklevel)) {  \
 		struct vmproc *vmpr;	\
-		vm_assert(incheck == 0);	\
+		assert(incheck == 0);	\
 		incheck = 1;		\
 		usedpages_reset();	\
 	slab_sanitycheck(__FILE__, __LINE__);	\
@@ -31,7 +31,7 @@
 		} \
 	} \
 	map_sanitycheck(__FILE__, __LINE__); \
-	vm_assert(incheck == 1);	\
+	assert(incheck == 1);	\
 	incheck = 0;		\
 	} 
 
diff --git a/servers/vm/slaballoc.c b/servers/vm/slaballoc.c
index 7072cc372..101ca6f01 100644
--- a/servers/vm/slaballoc.c
+++ b/servers/vm/slaballoc.c
@@ -37,19 +37,19 @@
 #define BITEL(f, b)	(f)->sdh.usebits[(b)/ELBITS]
 
 
-#define OFF(f, b) vm_assert(!GETBIT(f, b))
-#define ON(f, b)  vm_assert(GETBIT(f, b))
+#define OFF(f, b) assert(!GETBIT(f, b))
+#define ON(f, b)  assert(GETBIT(f, b))
 
 #if SANITYCHECKS
 #define SLABDATAWRITABLE(data, wr) do {			\
-	vm_assert(data->sdh.writable == WRITABLE_NONE);	\
-	vm_assert(wr != WRITABLE_NONE);			\
+	assert(data->sdh.writable == WRITABLE_NONE);	\
+	assert(wr != WRITABLE_NONE);			\
 	vm_pagelock(data, 0);				\
 	data->sdh.writable = wr;			\
 } while(0)
 
 #define SLABDATAUNWRITABLE(data) do {			\
-	vm_assert(data->sdh.writable != WRITABLE_NONE);	\
+	assert(data->sdh.writable != WRITABLE_NONE);	\
 	data->sdh.writable = WRITABLE_NONE;		\
 	vm_pagelock(data, 1);				\
 } while(0)
@@ -133,10 +133,10 @@ FORWARD _PROTOTYPE( int objstats, (void *, int, struct slabheader **, struct sla
 
 #define GETSLAB(b, s) {			\
 	int i;				\
-	vm_assert((b) >= MINSIZE);	\
+	assert((b) >= MINSIZE);	\
 	i = (b) - MINSIZE;		\
-	vm_assert((i) < SLABSIZES);	\
-	vm_assert((i) >= 0);		\
+	assert((i) < SLABSIZES);	\
+	assert((i) >= 0);		\
 	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. */
 #define MOVEHEAD(sl, l1, l2) {		\
 	struct slabdata *t;		\
-	vm_assert(LH(sl,l1));		\
+	assert(LH(sl,l1));		\
 	REMOVEHEAD(sl, l1, t);		\
 	ADDHEAD(t, sl, l2);		\
 }
@@ -154,7 +154,7 @@ FORWARD _PROTOTYPE( int objstats, (void *, int, struct slabheader **, struct sla
 #define REMOVEHEAD(sl, list, to) {	\
 	struct slabdata *dat;		\
 	dat = (to) = LH(sl, list);	\
-	vm_assert(dat);			\
+	assert(dat);			\
 	LH(sl, list) = dat->sdh.next;	\
 	UNLINKNODE(dat);		\
 }
@@ -185,7 +185,7 @@ struct slabdata *newslabdata(int list)
 	struct slabdata *n;
 	phys_bytes p;
 
-	vm_assert(sizeof(*n) == VM_PAGE_SIZE);
+	assert(sizeof(*n) == VM_PAGE_SIZE);
 
 	if(!(n = vm_allocpage(&p, VMP_SLAB))) {
 		printf("newslabdata: vm_allocpage failed\n");
@@ -290,7 +290,7 @@ PUBLIC void *slaballoc(int bytes)
 
 	/* Retrieve entry in slabs[]. */
 	GETSLAB(bytes, s);
-	vm_assert(s);
+	assert(s);
 
 	/* To make the common case more common, make space in the 'used'
 	 * queue first.
@@ -314,14 +314,14 @@ PUBLIC void *slaballoc(int bytes)
 	}
 	SLABSANITYCHECK(SCL_DETAIL);
 
-	vm_assert(s);
+	assert(s);
 	firstused = LH(s, LIST_USED);
-	vm_assert(firstused);
+	assert(firstused);
 #if SANITYCHECKS
-	vm_assert(firstused->sdh.magic1 == MAGIC1);
-	vm_assert(firstused->sdh.magic2 == MAGIC2);
+	assert(firstused->sdh.magic1 == MAGIC1);
+	assert(firstused->sdh.magic2 == MAGIC2);
 #endif
-	vm_assert(firstused->sdh.nused < ITEMSPERPAGE(bytes));
+	assert(firstused->sdh.nused < ITEMSPERPAGE(bytes));
 
 	for(i = firstused->sdh.freeguess;
 		count < ITEMSPERPAGE(bytes); count++, i++) {
@@ -345,7 +345,7 @@ PUBLIC void *slaballoc(int bytes)
 			nojunkwarning++;
 			slabunlock(ret, bytes);
 			nojunkwarning--;
-			vm_assert(!nojunkwarning);
+			assert(!nojunkwarning);
 			*(u32_t *) ret = NOJUNK;
 			slablock(ret, bytes);
 #endif
@@ -458,7 +458,7 @@ PUBLIC void slabfree(void *mem, int bytes)
 	nojunkwarning++;
 	slablock(mem, bytes);
 	nojunkwarning--;
-	vm_assert(!nojunkwarning);
+	assert(!nojunkwarning);
 #endif
 
 	/* Free this data. */
@@ -467,7 +467,7 @@ PUBLIC void slabfree(void *mem, int bytes)
 	/* Check if this slab changes lists. */
 	if(f->sdh.nused == 0) {
 		/* Now become FREE; must've been USED */
-		vm_assert(f->sdh.list == LIST_USED);
+		assert(f->sdh.list == LIST_USED);
 		UNLINKNODE(f);
 		if(f == LH(s, LIST_USED))
 			LH(s, LIST_USED) = f->sdh.next;
@@ -475,7 +475,7 @@ PUBLIC void slabfree(void *mem, int bytes)
 		SLABSANITYCHECK(SCL_DETAIL);
 	} else if(f->sdh.nused == ITEMSPERPAGE(bytes)-1) {
 		/* Now become USED; must've been FULL */
-		vm_assert(f->sdh.list == LIST_FULL);
+		assert(f->sdh.list == LIST_FULL);
 		UNLINKNODE(f);
 		if(f == LH(s, LIST_FULL))
 			LH(s, LIST_FULL) = f->sdh.next;
@@ -483,7 +483,7 @@ PUBLIC void slabfree(void *mem, int bytes)
 		SLABSANITYCHECK(SCL_DETAIL);
 	} else {
 		/* Stay USED */
-		vm_assert(f->sdh.list == LIST_USED);
+		assert(f->sdh.list == LIST_USED);
 	}
 
 	SLABSANITYCHECK(SCL_FUNCTIONS);
diff --git a/servers/vm/util.h b/servers/vm/util.h
index d93ec296d..d5d165cae 100644
--- a/servers/vm/util.h
+++ b/servers/vm/util.h
@@ -7,17 +7,5 @@
 
 #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
 
diff --git a/servers/vm/vm.h b/servers/vm/vm.h
index c711dd617..0a20d6ee4 100644
--- a/servers/vm/vm.h
+++ b/servers/vm/vm.h
@@ -28,7 +28,7 @@
 #define MINSTACKREGION	(64*1024*1024)
 
 /* 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_FUNCTIONS	2	/* Function entry/exit. */
 #define SCL_DETAIL	3	/* Detailled steps. */