Fix VM -Wall warnings and enable -Werror

diff --git a/servers/vm/Makefile b/servers/vm/Makefile
index ca6ef54d6e1157f205e0630ebd1bc3e571e23b23..511b29d93b1c949aa5ab7b88de7257ab56579b92 100644 (file)
--- a/servers/vm/Makefile
+++ b/servers/vm/Makefile
@@ -16,6 +16,9 @@ INSTALLFLAGS+=        -S 128k
 
 CPPFLAGS+= -I${.CURDIR} -I${.CURDIR}/arch/${ARCH}
 CPPFLAGS+=     -I${MINIXSRCDIR}
+.if ${CC} == gcc
+CFLAGS+= -Wall -Werror
+.endif
 
 .include "arch/${ARCH}/Makefile.inc"
 .include <bsd.prog.mk>

diff --git a/servers/vm/alloc.c b/servers/vm/alloc.c
index d112eb9f56fd30947708b585edbea211b35ee626..62e736f0c23c4db7a4fcd5f526b6ce6edbd5b02a 100644 (file)
--- a/servers/vm/alloc.c
+++ b/servers/vm/alloc.c
@@ -57,8 +57,6 @@ struct hole {
        int holelist;
 };
 
-static int startpages;
-
 
 #define _NR_HOLES (_NR_PROCS*2)  /* No. of memory holes maintained by VM */
 
@@ -169,9 +167,7 @@ PUBLIC phys_clicks alloc_mem(phys_clicks clicks, u32_t memflags)
  * always on a click boundary.  This procedure is called when memory is
  * needed for FORK or EXEC.
  */
-  register struct hole *hp, *prev_ptr;
-  phys_clicks old_base, mem = NO_MEM, align_clicks = 0;
-  int s;
+  phys_clicks mem = NO_MEM, align_clicks = 0;
 
   if(memflags & PAF_ALIGN64K) {
        align_clicks = (64 * 1024) / CLICK_SIZE;
@@ -332,7 +328,6 @@ struct memory *chunks;              /* list of free memory chunks */
  */
   int i, first = 0;
   register struct hole *hp;
-  int nodes, largest;
 
   /* Put all holes on the free list. */
   for (hp = &hole[0]; hp < &hole[_NR_HOLES]; hp++) {
@@ -383,7 +378,7 @@ PRIVATE void sanitycheck(void)
 
 PUBLIC void memstats(int *nodes, int *pages, int *largest)
 {
-       pagerange_t *p, *prevp = NULL;
+       pagerange_t *p;
        addr_iter iter;
        addr_start_iter_least(&addravl, &iter);
        *nodes = 0;
@@ -681,9 +676,8 @@ PUBLIC int do_adddma(message *msg)
 PUBLIC int do_deldma(message *msg)
 {
        endpoint_t req_proc_e, target_proc_e;
-       int i, j, proc_n;
+       int i, j;
        phys_bytes base, size;
-       struct vmproc *vmp;
 
        req_proc_e= msg->VMDD_REQ;
        target_proc_e= msg->VMDD_EP;
@@ -740,10 +734,7 @@ PUBLIC int do_deldma(message *msg)
  *===========================================================================*/
 PUBLIC int do_getdma(message *msg)
 {
-       endpoint_t target_proc_e;
-       int i, proc_n;
-       phys_bytes base, size;
-       struct vmproc *vmp;
+       int i;
 
        /* Find slot to report */
        for (i= 0; i<NR_DMA; i++)
@@ -774,10 +765,8 @@ PUBLIC int do_getdma(message *msg)
  *===========================================================================*/
 PUBLIC void release_dma(struct vmproc *vmp)
 {
-       int i, found_one;
-
-       panic("release_dma not done");
 #if 0
+       int i, found_one;
 
        found_one= FALSE;
        for (i= 0; i<NR_DMA; i++)
@@ -796,6 +785,8 @@ PUBLIC void release_dma(struct vmproc *vmp)
                free_mem(base, size);
 
        msg->VMRD_FOUND = found_one;
+#else
+       panic("release_dma not done");
 #endif
 
        return;

diff --git a/servers/vm/arch/i386/pagetable.c b/servers/vm/arch/i386/pagetable.c
index 746e8e1bd3edcf4f1b2830080767f8f5a9b7c88d..f26e02bec7cc96a4c7b9e3a973eb3bca6ebd1204 100644 (file)
--- a/servers/vm/arch/i386/pagetable.c
+++ b/servers/vm/arch/i386/pagetable.c
@@ -144,7 +144,7 @@ PRIVATE u32_t findhole(pt_t *pt, u32_t vmin, u32_t vmax)
  * between page-aligned BYTE offsets vmin and vmax, to fit
  * a page in. Return byte offset.
  */
-       u32_t freefound = 0, curv;
+       u32_t curv;
        int pde = 0, try_restart;
        static u32_t lastv = 0;
 
@@ -291,7 +291,6 @@ PUBLIC void *vm_allocpage(phys_bytes *phys, int reason)
        assert(level <= 2);
 
        if(level > 1 || !(vmprocess->vm_flags & VMF_HASPT) || !meminit_done) {
-               int r;
                void *s;
                s=vm_getsparepage(phys);
                level--;
@@ -536,8 +535,7 @@ PUBLIC int pt_map_in_range(struct vmproc *src_vmp, struct vmproc *dst_vmp,
  * the destination process in the range specified.
  */
        int pde, pte;
-       int r;
-       vir_bytes viraddr, mapaddr;
+       vir_bytes viraddr;
        pt_t *pt, *dst_pt;
 
        pt = &src_vmp->vm_pt;
@@ -652,7 +650,7 @@ PUBLIC int pt_writemap(struct vmproc * vmp,
 {
 /* Write mapping into page table. Allocate a new page table if necessary. */
 /* Page directory and table entries for this virtual address. */
-       int p, r, pages;
+       int p, pages;
        int verify = 0;
        int ret = OK;
 
@@ -778,14 +776,13 @@ resume_exit:
 PUBLIC int pt_checkrange(pt_t *pt, vir_bytes v,  size_t bytes,
        int write)
 {
-       int p, pages, pde;
+       int p, pages;
 
        assert(!(bytes % I386_PAGE_SIZE));
 
        pages = bytes / I386_PAGE_SIZE;
 
        for(p = 0; p < pages; p++) {
-               u32_t entry;
                int pde = I386_VM_PDE(v);
                int pte = I386_VM_PTE(v);
 
@@ -873,7 +870,6 @@ PUBLIC void pt_init(phys_bytes usedlimit)
         u32_t moveup = 0;
        int global_bit_ok = 0;
        int free_pde;
-       int p;
        struct vm_ep_data ep_data;
        vir_bytes sparepages_mem;
        phys_bytes sparepages_ph;
@@ -943,9 +939,6 @@ PUBLIC void pt_init(phys_bytes usedlimit)
 
         /* Set up mappings for VM process. */
         for(v = lo; v < hi; v += I386_PAGE_SIZE)  {
-                phys_bytes addr;
-                u32_t flags; 
-        
                 /* We have to write the new position in the PT,
                  * so we can move our segments.
                  */ 
@@ -1153,7 +1146,7 @@ PUBLIC void pt_init_mem()
  *===========================================================================*/
 PUBLIC int pt_bind(pt_t *pt, struct vmproc *who)
 {
-       int slot, ispt;
+       int slot;
        u32_t phys;
        void *pdes;
 
@@ -1213,7 +1206,7 @@ PUBLIC void pt_free(pt_t *pt)
  *===========================================================================*/
 PUBLIC int pt_mapkernel(pt_t *pt)
 {
-       int r, i;
+       int i;
 
         /* Any i386 page table needs to map in the kernel address space. */
         assert(vmproc[VMP_SYSTEM].vm_flags & VMF_INUSE);

diff --git a/servers/vm/arch/i386/vm.c b/servers/vm/arch/i386/vm.c
index 86742d519b5dae1a38db9ad7ca0c0fd8dbea471d..107a75f51cf656df063ba50269ff5a37c5302b58 100644 (file)
--- a/servers/vm/arch/i386/vm.c
+++ b/servers/vm/arch/i386/vm.c
@@ -50,7 +50,6 @@ PUBLIC char *arch_map2str(struct vmproc *vmp, vir_bytes addr)
 {
        static char bufstr[100];
        vir_bytes textstart = CLICK2ABS(vmp->vm_arch.vm_seg[T].mem_phys);
-       vir_bytes textend = textstart + CLICK2ABS(vmp->vm_arch.vm_seg[T].mem_len);
        vir_bytes datastart = CLICK2ABS(vmp->vm_arch.vm_seg[D].mem_phys);
        vir_bytes textsegbase = CLICK2ABS(vmp->vm_arch.vm_seg[T].mem_phys -
                                          vmp->vm_arch.vm_seg[T].mem_vir);

diff --git a/servers/vm/cavl_impl.h b/servers/vm/cavl_impl.h
index aec75cbd506969680129b972fa17aee04afe9916..8e8edb34c47921d8f0f24a78b405ed60c26867ba 100644 (file)
--- a/servers/vm/cavl_impl.h
+++ b/servers/vm/cavl_impl.h
@@ -7,6 +7,8 @@
 ** Version: 1.5  Author: Walt Karas
 */
 
+#include <string.h>
+
 #undef L__
 #undef L__EST_LONG_BIT
 #undef L__SIZE
@@ -14,6 +16,7 @@
 #undef L__MASK_HIGH_BIT
 #undef L__LONG_BIT
 #undef L__BIT_ARR_DEFN
+#undef L__BIT_ARR_CLEAR
 #undef L__BIT_ARR_VAL
 #undef L__BIT_ARR_0
 #undef L__BIT_ARR_1
@@ -98,6 +101,8 @@
 
 #define L__BIT_ARR_DEFN(NAME) unsigned long NAME[L__BIT_ARR_LONGS];
 
+#define L__BIT_ARR_CLEAR(NAME) memset(NAME, 0, sizeof(NAME));
+
 #define L__BIT_ARR_VAL(BIT_ARR, BIT_NUM) \
   ((BIT_ARR)[(BIT_NUM) / L__LONG_BIT] & (1L << ((BIT_NUM) % L__LONG_BIT)))
 
@@ -114,6 +119,8 @@
 
 #define L__BIT_ARR_DEFN(NAME) unsigned long NAME;
 
+#define L__BIT_ARR_CLEAR(NAME) NAME = 0;
+
 #define L__BIT_ARR_VAL(BIT_ARR, BIT_NUM) ((BIT_ARR) & (1L << (BIT_NUM)))
 
 #define L__BIT_ARR_0(BIT_ARR, BIT_NUM) (BIT_ARR) &= ~(1L << (BIT_NUM));
@@ -340,6 +347,8 @@ L__SC AVL_HANDLE L__(insert)(L__(avl) *L__tree, AVL_HANDLE h)
        AVL_HANDLE hh = L__tree->root;
        AVL_HANDLE parent = AVL_NULL;
        int cmp;
+       
+       L__BIT_ARR_CLEAR(branch)
 
        do
          {
@@ -548,12 +557,14 @@ L__SC AVL_HANDLE L__(remove)(L__(avl) *L__tree, AVL_KEY k)
     AVL_HANDLE parent = AVL_NULL;
     AVL_HANDLE child;
     AVL_HANDLE path;
-    int cmp, cmp_shortened_sub_with_path;
+    int cmp, cmp_shortened_sub_with_path = 0;
     int reduced_depth;
     int bf;
     AVL_HANDLE rm;
     AVL_HANDLE parent_rm;
 
+    L__BIT_ARR_CLEAR(branch)
+
     for ( ; ; )
       {
        if (h == AVL_NULL)
@@ -752,7 +763,7 @@ L__SC AVL_HANDLE L__(subst)(L__(avl) *L__tree, AVL_HANDLE new_node)
   {
     AVL_HANDLE h = L__tree->root;
     AVL_HANDLE parent = AVL_NULL;
-    int cmp, last_cmp;
+    int cmp, last_cmp = 0;
 
     /* Search for node already in tree with same key. */
     for ( ; ; )
@@ -833,6 +844,9 @@ L__SC int L__(build)(
        return(1);
       }
 
+    L__BIT_ARR_CLEAR(branch)
+    L__BIT_ARR_CLEAR(rem)
+      
     for ( ; ; )
       {
        while (num_sub > 2)
@@ -1178,6 +1192,7 @@ L__SC void L__(decr_iter)(L__(iter) *iter)
 #undef L__MASK_HIGH_BIT
 #undef L__LONG_BIT
 #undef L__BIT_ARR_DEFN
+#undef L__BIT_ARR_CLEAR
 #undef L__BIT_ARR_VAL
 #undef L__BIT_ARR_0
 #undef L__BIT_ARR_1

diff --git a/servers/vm/exec.c b/servers/vm/exec.c
index 38f3d39d020d8672a0a66048dee467ba9d607ca2..8bbf0dcf7d3c4e1ce8424ea15d87c02f301e82c1 100644 (file)
--- a/servers/vm/exec.c
+++ b/servers/vm/exec.c
@@ -37,8 +37,6 @@ FORWARD _PROTOTYPE( int new_mem, (struct vmproc *vmp,
        vir_bytes stk_bytes, phys_bytes tot_bytes, vir_bytes *stack_top,
        int is_elf));
 
-static int failcount;
-
 /*===========================================================================*
  *                             exec_newmem                                  *
  *===========================================================================*/
@@ -150,8 +148,7 @@ PRIVATE int new_mem(
  */
 
   vir_clicks text_clicks, data_clicks, gap_clicks, stack_clicks, tot_clicks;
-  phys_bytes bytes, base, bss_offset;
-  int s, r2, r, hadpt = 0;
+  int r, hadpt = 0;
   struct vmproc *vmpold = &vmproc[VMP_EXECTMP];
   int ptok = 1;
 
@@ -298,7 +295,6 @@ PUBLIC int proc_new(struct vmproc *vmp,
 {
        int s;
        vir_bytes hole_bytes;
-       int prealloc;
        struct vir_region *reg;
        phys_bytes map_text_addr, map_data_addr, map_stack_addr;
 

diff --git a/servers/vm/fork.c b/servers/vm/fork.c
index d984a6cf2c8a8a8132fae9f4a2ee414a3a1a6b34..69cfb9f88732ec829d4b9469b67af00789ca3437 100644 (file)
--- a/servers/vm/fork.c
+++ b/servers/vm/fork.c
@@ -34,7 +34,7 @@
  *===========================================================================*/
 PUBLIC int do_fork(message *msg)
 {
-  int r, proc, s, childproc, fullvm;
+  int r, proc, childproc, fullvm;
   struct vmproc *vmp, *vmc;
   pt_t origpt;
   vir_bytes msgaddr;

diff --git a/servers/vm/main.c b/servers/vm/main.c
index d01b2076d499ec9b41587d8e7dadb28d64d8cc13..925eb8628baa4ae95669138e3df08639c2f3dcb7 100644 (file)
--- a/servers/vm/main.c
+++ b/servers/vm/main.c
@@ -75,7 +75,6 @@ PUBLIC int main(void)
 {
   message msg;
   int result, who_e, rcv_sts;
-  sigset_t sigset;
   int caller_slot;
   struct vmproc *vmp_caller;
 
@@ -172,7 +171,6 @@ PRIVATE int sef_cb_init_fresh(int type, sef_init_info_t *info)
 {
 /* Initialize the vm server. */
        int s, i;
-       int click, clicksforgotten = 0;
        struct memory mem_chunks[NR_MEMS];
        struct boot_image image[NR_BOOT_PROCS];
        struct boot_image *ip;
@@ -271,7 +269,6 @@ PRIVATE int sef_cb_init_fresh(int type, sef_init_info_t *info)
 
        /* Give these processes their own page table. */
        for (ip = &image[0]; ip < &image[NR_BOOT_PROCS]; ip++) {
-               int s;
                struct vmproc *vmp;
                vir_bytes old_stacktop, old_stacklen;
 

diff --git a/servers/vm/mmap.c b/servers/vm/mmap.c
index 47aec72980866f02591a8e2974c454ba77136769..4c67ed989664ce0170eae7065ce6a5fe6f9b6271 100644 (file)
--- a/servers/vm/mmap.c
+++ b/servers/vm/mmap.c
@@ -52,8 +52,6 @@ PUBLIC int do_mmap(message *m)
                return ENXIO;
 
        if(m->VMM_FD == -1 || (m->VMM_FLAGS & MAP_ANON)) {
-               int s;
-               vir_bytes v;
                u32_t vrflags = VR_ANON | VR_WRITABLE;
                size_t len = (vir_bytes) m->VMM_LEN;
 
@@ -221,7 +219,7 @@ PUBLIC int do_remap(message *m)
        int dn, sn;
        vir_bytes da, sa, startv;
        size_t size;
-       struct vir_region *vr, *region;
+       struct vir_region *region;
        struct vmproc *dvmp, *svmp;
        int r;
 

diff --git a/servers/vm/pagefaults.c b/servers/vm/pagefaults.c
index 517dec2c8c84b52bda200fb488952dcc1c9e095b..5bce5f5c6acb4306fd852209423da79c4d84f1c5 100644 (file)
--- a/servers/vm/pagefaults.c
+++ b/servers/vm/pagefaults.c
@@ -57,7 +57,7 @@ PUBLIC void do_pagefaults(message *m)
        u32_t addr = m->VPF_ADDR;
        u32_t err = m->VPF_FLAGS;
        struct vmproc *vmp;
-       int r, s;
+       int s;
 
        struct vir_region *region;
        vir_bytes offset;
@@ -76,7 +76,7 @@ PUBLIC void do_pagefaults(message *m)
                                ep, arch_map2str(vmp, addr), pf_errstr(err));
                if((s=sys_kill(vmp->vm_endpoint, SIGSEGV)) != OK)
                        panic("sys_kill failed: %d", s);
-               if((s=sys_vmctl(ep, VMCTL_CLEAR_PAGEFAULT, r)) != OK)
+               if((s=sys_vmctl(ep, VMCTL_CLEAR_PAGEFAULT, 0 /*unused*/)) != OK)
                        panic("do_pagefaults: sys_vmctl failed: %d", ep);
                return;
        }
@@ -97,7 +97,7 @@ PUBLIC void do_pagefaults(message *m)
                                ep, arch_map2vir(vmp, addr), pf_errstr(err));
                if((s=sys_kill(vmp->vm_endpoint, SIGSEGV)) != OK)
                        panic("sys_kill failed: %d", s);
-               if((s=sys_vmctl(ep, VMCTL_CLEAR_PAGEFAULT, r)) != OK)
+               if((s=sys_vmctl(ep, VMCTL_CLEAR_PAGEFAULT, 0 /*unused*/)) != OK)
                        panic("do_pagefaults: sys_vmctl failed: %d", ep);
                return;
        }
@@ -106,17 +106,17 @@ PUBLIC void do_pagefaults(message *m)
        offset = addr - region->vaddr;
 
        /* Access is allowed; handle it. */
-       if((r=map_pf(vmp, region, offset, wr)) != OK) {
+       if((map_pf(vmp, region, offset, wr)) != OK) {
                printf("VM: pagefault: SIGSEGV %d pagefault not handled\n", ep);
                if((s=sys_kill(vmp->vm_endpoint, SIGSEGV)) != OK)
                        panic("sys_kill failed: %d", s);
-               if((s=sys_vmctl(ep, VMCTL_CLEAR_PAGEFAULT, r)) != OK)
+               if((s=sys_vmctl(ep, VMCTL_CLEAR_PAGEFAULT, 0 /*unused*/)) != OK)
                        panic("do_pagefaults: sys_vmctl failed: %d", ep);
                return;
        }
 
        /* Pagefault is handled, so now reactivate the process. */
-       if((s=sys_vmctl(ep, VMCTL_CLEAR_PAGEFAULT, r)) != OK)
+       if((s=sys_vmctl(ep, VMCTL_CLEAR_PAGEFAULT, 0 /*unused*/)) != OK)
                panic("do_pagefaults: sys_vmctl failed: %d", ep);
 }
 
@@ -167,7 +167,6 @@ int handle_memory(struct vmproc *vmp, vir_bytes mem, vir_bytes len, int wrflag)
 {
        struct vir_region *region;
        vir_bytes o;
-       vir_bytes v;
 
        /* Page-align memory and length. */
        o = mem % VM_PAGE_SIZE;

diff --git a/servers/vm/queryexit.c b/servers/vm/queryexit.c
index 7d981a4ab63c86538633ba8accc91edcce6a1705..d5ae1249127d983eb50c51eee2e7d55140dbd74a 100644 (file)
--- a/servers/vm/queryexit.c
+++ b/servers/vm/queryexit.c
@@ -39,7 +39,7 @@ static struct query_exit_struct array[NR_PROCS];
 PUBLIC int do_query_exit(message *m)
 {
        int i, nr;
-       endpoint_t ep;
+       endpoint_t ep = NONE;
 
        for (i = 0; i < NR_PROCS; i++) {
                if (!array[i].avail) {

diff --git a/servers/vm/region.c b/servers/vm/region.c
index 3d62ed3fb91550ab74e07050681403616104f9c1..081ab1ca42cc9fdfad9ce15d500ca00f5b55cc83 100644 (file)
--- a/servers/vm/region.c
+++ b/servers/vm/region.c
@@ -405,7 +405,7 @@ PRIVATE vir_bytes region_find_slot_range(struct vmproc *vmp,
                vir_bytes minv, vir_bytes maxv, vir_bytes length)
 {
        struct vir_region *firstregion;
-       vir_bytes startv;
+       vir_bytes startv = 0;
        int foundflag = 0;
        region_iter iter;
 
@@ -522,7 +522,6 @@ int mapflags;
 {
        struct vir_region *newregion;
        vir_bytes startv;
-       struct phys_region *ph;
        physr_avl *phavl;
 
        assert(!(length % VM_PAGE_SIZE));
@@ -606,7 +605,6 @@ USE(newregion,
 PUBLIC void pb_unreferenced(struct vir_region *region, struct phys_region *pr)
 {
        struct phys_block *pb;
-       int remap = 0;
 
        pb = pr->ph;
        assert(pb->refcount > 0);
@@ -663,7 +661,7 @@ PRIVATE struct phys_region *reset_physr_iter(struct vir_region *region,
 PRIVATE int map_subfree(struct vmproc *vmp,
        struct vir_region *region, vir_bytes len)
 {
-       struct phys_region *pr, *nextpr;
+       struct phys_region *pr;
        physr_iter iter;
 
 
@@ -706,7 +704,6 @@ PRIVATE int map_subfree(struct vmproc *vmp,
                        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;
@@ -1189,7 +1186,6 @@ int write;
 
        if((ph = physr_search(region->phys, offset, AVL_LESS_EQUAL)) &&
           (ph->offset <= offset && offset < ph->offset + ph->ph->length)) {
-               phys_bytes blockoffset = ph->offset;
                /* Pagefault in existing block. Do copy-on-write. */
                assert(write);
                assert(region->flags & VR_WRITABLE);
@@ -1277,7 +1273,6 @@ int write;
        if(r2) {                                                        \
                end   = MIN(end, r2->offset); }         \
        if(start < end) {                                               \
-               int r;                                                  \
                SANITYCHECK(SCL_DETAIL);                                \
                if(map_new_physblock(vmp, region, start,                \
                        end-start, MAP_NONE, PAF_CLEAR, 0) != OK) {     \
@@ -1675,7 +1670,6 @@ PUBLIC int map_region_extend(struct vmproc *vmp, struct vir_region *vr,
 {
        vir_bytes end;
        struct vir_region *nextvr;
-       region_iter v_iter;
 
        assert(vr);
        assert(vr->flags & VR_ANON);
@@ -2187,7 +2181,7 @@ PUBLIC int unmap_memory(endpoint_t sour, endpoint_t dest,
  *===========================================================================*/
 PRIVATE int split_phys(struct phys_region *pr, vir_bytes point)
 {
-        struct phys_region *newpr, *q, *prev;
+        struct phys_region *newpr, *q, *prev = NULL;
         struct phys_block *newpb;
         struct phys_block *pb = pr->ph;
 /* Split the phys region into 2 parts by @point. */
@@ -2224,6 +2218,7 @@ PRIVATE int split_phys(struct phys_region *pr, vir_bytes point)
                         prev = newpr;
                 }
         }
+       assert(prev);
         prev->next_ph_list = NULL;
 
         return OK;
@@ -2299,7 +2294,6 @@ PUBLIC int map_memory(endpoint_t sour, endpoint_t dest,
  */
        struct vmproc *vms, *vmd;
        struct vir_region *vrs, *vrd;
-       physr_iter iterd;
        vir_bytes offset_s, offset_d;
        int p;
        int r;
@@ -2416,7 +2410,6 @@ get_clean_phys_region(struct vmproc *vmp, vir_bytes vaddr, vir_bytes length,
        /* If it's mapped more than once, make a copy. */
        assert(ph->ph->refcount > 0);
        if(ph->ph->refcount > 1) {
-               int r;
                if(!(ph = map_clone_ph_block(vmp, region,
                        ph, NULL))) {
                        printf("VM: get_clean_phys_region: ph copy failed\n");
@@ -2485,7 +2478,7 @@ PRIVATE int yieldblock(struct vmproc *vmp, u64_t id,
        vir_bytes vaddr, vir_bytes len, yielded_t **retyb)
 {
        yielded_t *newyb;
-       vir_bytes mem_clicks, newmem, clicks;
+       vir_bytes mem_clicks, clicks;
        struct vir_region *region;
        struct phys_region *ph;
        yielded_avl *avl;
@@ -2634,7 +2627,7 @@ PUBLIC int do_forgetblock(message *m)
 PUBLIC int do_yieldblockgetblock(message *m)
 {
        u64_t yieldid, getid;
-       int n, get = 0;
+       int n;
        endpoint_t caller = m->m_source;
        struct vmproc *vmp;
        yielded_t *yb = NULL;

diff --git a/servers/vm/rs.c b/servers/vm/rs.c
index 51134126eae401dfa9b94197b875d52f3f537507..2704169c3e40b440d1119980f29f79f028d8afac 100644 (file)
--- a/servers/vm/rs.c
+++ b/servers/vm/rs.c
@@ -64,7 +64,6 @@ PUBLIC int do_rs_update(message *m_ptr)
        endpoint_t src_e, dst_e, reply_e;
        int src_p, dst_p;
        struct vmproc *src_vmp, *dst_vmp;
-       struct vir_region *vr;
        int r;
 
        src_e = m_ptr->VM_RS_SRC_ENDPT;
@@ -118,7 +117,7 @@ PUBLIC int do_rs_update(message *m_ptr)
  *===========================================================================*/
 PRIVATE int rs_memctl_make_vm_instance(struct vmproc *new_vm_vmp)
 {
-       int vm_p, r;
+       int r;
        u32_t flags;
        int verify;
        struct vmproc *this_vm_vmp;

diff --git a/servers/vm/slaballoc.c b/servers/vm/slaballoc.c
index cf2a51c9d9c16b6371a554dd7db0d78fb7157846..2a0578baa526b9dcc9ec8a9b06de37d01e479f36 100644 (file)
--- a/servers/vm/slaballoc.c
+++ b/servers/vm/slaballoc.c
@@ -277,7 +277,9 @@ PUBLIC int slabsane_f(char *file, int line, void *mem, int bytes)
 }
 #endif
 
+#if SANITYCHECKS
 static int nojunkwarning = 0;
+#endif
 
 /*===========================================================================*
  *                             void *slaballoc                              *
@@ -332,7 +334,6 @@ PUBLIC void *slaballoc(int bytes)
                i = i % ITEMSPERPAGE(bytes);
 
                if(!GETBIT(firstused, i)) {
-                       struct slabdata *f;
                        char *ret;
                        SETBIT(firstused, i);
        SLABSANITYCHECK(SCL_DETAIL);