Added annotations to i386/pmap.c i386/kdebug.c and i386/cpuinfo.c
authorZach Anderson <zra@zra-intrepid.(none)>
Fri, 14 Aug 2009 04:49:55 +0000 (21:49 -0700)
committerZach Anderson <zra@zra-intrepid.(none)>
Fri, 14 Aug 2009 04:49:55 +0000 (21:49 -0700)
kern/arch/i386/cpuinfo.c
kern/arch/i386/kdebug.c
kern/arch/i386/pmap.c
kern/include/kdebug.h
kern/include/pmap.h
kern/include/ros/memlayout.h
kern/include/string.h
kern/src/pmap.c
user/parlib/inc/channel.h
user/parlib/inc/libc_patch.h
user/parlib/src/channel.c

index 1aeec3f..b3d52c3 100644 (file)
@@ -4,10 +4,6 @@
  * See LICENSE for details.
  */
 
-#ifdef __DEPUTY__
-#pragma nodeputy
-#endif
-
 #include <arch/arch.h>
 #include <arch/x86.h>
 #include <arch/mmu.h>
@@ -101,7 +97,7 @@ void print_cpuinfo(void)
 
 void show_mapping(uintptr_t start, size_t size)
 {
-       pde_t* pgdir = (pde_t*)vpd;
+       pde_t* pgdir = /*(pde_t*)*/vpd;
        pte_t *pte, *pde;
        page_t* page;
        uintptr_t i;
@@ -109,7 +105,7 @@ void show_mapping(uintptr_t start, size_t size)
        cprintf("   Virtual    Physical  Ps Dr Ac CD WT U W\n");
        cprintf("------------------------------------------\n");
        for(i = 0; i < size; i += PGSIZE, start += PGSIZE) {
-               page = page_lookup(pgdir, (void*)start, &pte);
+               page = page_lookup(pgdir, (void*SNT)start, &pte);
                cprintf("%08p  ", start);
                if (page) {
                        pde = &pgdir[PDX(start)];
@@ -124,12 +120,12 @@ void show_mapping(uintptr_t start, size_t size)
 }
 
 void backtrace(void)
-{
-       uint32_tebp, eip;
+{ TRUSTEDBLOCK
+       uint32_t *ebp, eip;
        eipdebuginfo_t debuginfo;
        char buf[256];
        int j, i = 1;
-       ebp = (uint32_t*)read_ebp();    
+       ebp = (uint32_t*)read_ebp();
        // this is part of the way back into the call() instruction's bytes
        // eagle-eyed readers should be able to explain why this is good enough,
        // and retaddr (just *(ebp + 1) is not)
index 77ad476..2b8f098 100644 (file)
@@ -1,7 +1,3 @@
-#ifdef __DEPUTY__
-#pragma nodeputy
-#endif
-
 #include <stab.h>
 #include <string.h>
 #include <assert.h>
 
 #include <ros/memlayout.h>
 
-extern const stab_t __STAB_BEGIN__[];  // Beginning of stabs table
-extern const stab_t __STAB_END__[];    // End of stabs table
-extern const char __STABSTR_BEGIN__[];         // Beginning of string table
-extern const char __STABSTR_END__[];           // End of string table
+extern const stab_t (BND(__this,__STAB_END__) __STAB_BEGIN__)[]; // Beginning of stabs table
+extern const stab_t (SNT __STAB_END__)[]; // End of stabs table
+extern const char (NT BND(__this,__STABSTR_END__) __STABSTR_BEGIN__)[]; // Beginning of string table
+extern const char (SNT __STABSTR_END__)[]; // End of string table
 
 typedef struct UserStabData {
-       const stab_t *stabs;
-       const stab_t *stab_end;
-       const char *stabstr;
-       const char *stabstr_end;
+       const stab_t *BND(__this,stab_end) stabs;
+       const stab_t *SNT stab_end;
+       const char *NT BND(__this, stabstr_end) stabstr;
+       const char *SNT stabstr_end;
 } user_stab_data_t;
 
 
@@ -61,7 +57,9 @@ typedef struct UserStabData {
 //     will exit setting left = 118, right = 554.
 //
 static void
-stab_binsearch(const stab_t *stabs, int *region_left, int *region_right,
+stab_binsearch(const stab_t *BND(__this, stab_end) stabs,
+           const stab_t *SNT stab_end,
+           int *region_left, int *region_right,
               int type, uintptr_t addr)
 {
        int l = *region_left, r = *region_right, any_matches = 0;
@@ -115,10 +113,12 @@ stab_binsearch(const stab_t *stabs, int *region_left, int *region_right,
 //     information into '*info'.
 //
 int
-debuginfo_eip(uintptr_t addr, eipdebuginfo_t *info)
+debuginfo_eip(uintptr_t addr, eipdebuginfo_t *NONNULL info)
 {
-       const stab_t *stabs, *stab_end;
-       const char *stabstr, *stabstr_end;
+       const stab_t *SNT stab_end;
+       const stab_t *BND(__this,stab_end) stabs;
+       const char *SNT stabstr_end;
+       const char *NT BND(__this,stabstr_end) stabstr;
        int lfile, rfile, lfun, rfun, lline, rline;
 
        // Initialize *info
@@ -131,34 +131,37 @@ debuginfo_eip(uintptr_t addr, eipdebuginfo_t *info)
 
        // Find the relevant set of stabs
        if (addr >= ULIM) {
-               stabs = __STAB_BEGIN__;
                stab_end = __STAB_END__;
-               stabstr = __STABSTR_BEGIN__;
+               stabs = __STAB_BEGIN__;
                stabstr_end = __STABSTR_END__;
+               stabstr = __STABSTR_BEGIN__;
        } else {
                // The user-application linker script, user/user.ld,
                // puts information about the application's stabs (equivalent
                // to __STAB_BEGIN__, __STAB_END__, __STABSTR_BEGIN__, and
                // __STABSTR_END__) in a structure located at virtual address
                // USTABDATA.
-               const user_stab_data_t *usd = (const user_stab_data_t *) USTABDATA;
+               const user_stab_data_t *usd = (const user_stab_data_t *COUNT(1))TC(USTABDATA);
 
                // Make sure this memory is valid.
                // Return -1 if it is not.  Hint: Call user_mem_check.
                // LAB 3: Your code here.
-               
-               stabs = usd->stabs;
+
                stab_end = usd->stab_end;
-               stabstr = usd->stabstr;
+               stabs = usd->stabs;
                stabstr_end = usd->stabstr_end;
+               stabstr = usd->stabstr;
 
                // Make sure the STABS and string table memory is valid.
                // LAB 3: Your code here.
        }
 
        // String table validity checks
-       if (stabstr_end <= stabstr || stabstr_end[-1] != 0)
-               return -1;
+       {
+               int stabstrsz = stabstr_end - stabstr;
+               if (stabstr_end <= stabstr || stabstr[stabstrsz-1] != 0)
+                       return -1;
+       }
 
        // Now we find the right stabs that define the function containing
        // 'eip'.  First, we find the basic source file containing 'eip'.
@@ -168,7 +171,7 @@ debuginfo_eip(uintptr_t addr, eipdebuginfo_t *info)
        // Search the entire set of stabs for the source file (type N_SO).
        lfile = 0;
        rfile = (stab_end - stabs) - 1;
-       stab_binsearch(stabs, &lfile, &rfile, N_SO, addr);
+       stab_binsearch(stabs, stab_end, &lfile, &rfile, N_SO, addr);
        if (lfile == 0)
                return -1;
 
@@ -176,7 +179,7 @@ debuginfo_eip(uintptr_t addr, eipdebuginfo_t *info)
        // (N_FUN).
        lfun = lfile;
        rfun = rfile;
-       stab_binsearch(stabs, &lfun, &rfun, N_FUN, addr);
+       stab_binsearch(stabs, stab_end, &lfun, &rfun, N_FUN, addr);
 
        if (lfun <= rfun) {
                // stabs[lfun] points to the function name
@@ -208,7 +211,7 @@ debuginfo_eip(uintptr_t addr, eipdebuginfo_t *info)
        //      which one.
        // Your code here.
 
-       stab_binsearch(stabs, &lline, &rline, N_SLINE, addr);
+       stab_binsearch(stabs, stab_end, &lline, &rline, N_SLINE, addr);
        if (lline <= rline) 
                // stabs[lline] points to the line number
                info->eip_line = stabs[lline].n_value;
index 30d30e5..3fe73eb 100644 (file)
@@ -1,8 +1,4 @@
 /* See COPYRIGHT for copyright information. */
-#ifdef __DEPUTY__
-#pragma nodeputy
-#endif
-
 #include <arch/x86.h>
 #include <arch/arch.h>
 #include <arch/mmu.h>
@@ -114,7 +110,7 @@ static void check_boot_pgdir(bool pse);
 // UVPT.  UVPT security comes from the UVPT mapping (U/R).  All other kernel pages
 // protected at the second layer
 static pte_t*
-boot_pgdir_walk(pde_t *pgdir, uintptr_t la, int create)
+boot_pgdir_walk(pde_t *COUNT(NPDENTRIES) pgdir, uintptr_t la, int create)
 {
        pde_t* the_pde = &pgdir[PDX(la)];
        void* new_table;
@@ -122,7 +118,7 @@ boot_pgdir_walk(pde_t *pgdir, uintptr_t la, int create)
        if (*the_pde & PTE_P) {
                if (*the_pde & PTE_PS)
                        return (pte_t*)the_pde;
-               return &((pde_t*)KADDR(PTE_ADDR(*the_pde)))[PTX(la)];
+               return &((pde_t*COUNT(NPTENTRIES))KADDR(PTE_ADDR(*the_pde)))[PTX(la)];
        }
        if (!create)
                return NULL;
@@ -135,7 +131,7 @@ boot_pgdir_walk(pde_t *pgdir, uintptr_t la, int create)
        new_table = boot_alloc(PGSIZE, PGSIZE);
        memset(new_table, 0, PGSIZE);
        *the_pde = (pde_t)PADDR(new_table) | PTE_P | PTE_W | PTE_U | PTE_G;
-       return &((pde_t*)KADDR(PTE_ADDR(*the_pde)))[PTX(la)];
+       return &((pde_t*COUNT(NPTENTRIES))KADDR(PTE_ADDR(*the_pde)))[PTX(la)];
 }
 
 //
@@ -148,7 +144,7 @@ boot_pgdir_walk(pde_t *pgdir, uintptr_t la, int create)
 //
 // To map with Jumbos, set PTE_PS in perm
 static void
-boot_map_segment(pde_t *pgdir, uintptr_t la, size_t size, physaddr_t pa, int perm)
+boot_map_segment(pde_t *COUNT(NPDENTRIES) pgdir, uintptr_t la, size_t size, physaddr_t pa, int perm)
 {
        uintptr_t i;
        pte_t *pte;
@@ -368,8 +364,8 @@ vm_init(void)
        
        // round up to the nearest page
        size_t page_array_size = ROUNDUP(npage*sizeof(page_t), PGSIZE);
-       pages = (page_t *)boot_alloc(page_array_size, PGSIZE);
-       memset(pages, 0, page_array_size);
+       pages = /*(page_t *COUNT(npage))*/boot_calloc(page_array_size, 1, PGSIZE);
+       //memset(pages, 0, page_array_size);
 
        //////////////////////////////////////////////////////////////////////
        // Make 'envs' point to an array of size 'NENV' of 'env_t'.
@@ -377,8 +373,8 @@ vm_init(void)
        
        // round up to the nearest page
        size_t env_array_size = ROUNDUP(NENV*sizeof(env_t), PGSIZE);
-       envs = (env_t *)boot_alloc(env_array_size, PGSIZE);
-       memset(envs, 0, env_array_size);
+       envs = /*(env_t *)*/boot_calloc(env_array_size, 1, PGSIZE);
+       //memset(envs, 0, env_array_size);
 
        // Check that the initial page directory has been set up correctly.
        check_boot_pgdir(pse);
@@ -449,8 +445,8 @@ vm_init(void)
 // in fact it doesn't test the permission bits at all,
 // but it is a pretty good sanity check. 
 //
-static physaddr_t check_va2pa(pde_t *pgdir, uintptr_t va);
-static pte_t get_vaperms(pde_t *pgdir, uintptr_t va);
+static physaddr_t check_va2pa(pde_t *COUNT(NPDENTRIES) pgdir, uintptr_t va);
+static pte_t get_vaperms(pde_t *COUNT(NPDENTRIES) pgdir, uintptr_t va);
 
 static void
 check_boot_pgdir(bool pse)
@@ -539,16 +535,17 @@ check_boot_pgdir(bool pse)
 // the check_boot_pgdir() function; it shouldn't be used elsewhere.
 
 static physaddr_t
-check_va2pa(pde_t *pgdir, uintptr_t va)
+check_va2pa(pde_t *COUNT(NPDENTRIES) _pgdir, uintptr_t va)
 {
-       pte_t *p;
+       pte_t *COUNT(NPTENTRIES) p;
+       pde_t *COUNT(1) pgdir;
 
-       pgdir = &pgdir[PDX(va)];
+       pgdir = &_pgdir[PDX(va)];
        if (!(*pgdir & PTE_P))
                return ~0;
        if (*pgdir & PTE_PS)
                return PTE_ADDR(*pgdir);
-       p = (pte_t*) KADDR(PTE_ADDR(*pgdir));
+       p = (pte_t*COUNT(NPTENTRIES)) KADDR(PTE_ADDR(*pgdir));
        if (!(p[PTX(va)] & PTE_P))
                return ~0;
        return PTE_ADDR(p[PTX(va)]);
@@ -562,10 +559,10 @@ check_va2pa(pde_t *pgdir, uintptr_t va)
  */
 
 static pte_t
-get_vaperms(pde_t *pgdir, uintptr_t va)
+get_vaperms(pde_t *COUNT(NPDENTRIES) pgdir, uintptr_t va)
 {
        pde_t* pde = &pgdir[PDX(va)];
-       pte_t* pte = pgdir_walk(pgdir, (void*)va, 0);
+       pte_t* pte = pgdir_walk(pgdir, (void*SNT)va, 0);
        if (!pte || !(*pte & PTE_P))
                return 0;
        return PGOFF(*pde & *pte) + PTE_PS & (*pde | *pte);
@@ -600,7 +597,7 @@ page_init(void)
        //
        // Change the code to reflect this.
        int i;
-       physaddr_t physaddr_after_kernel = PADDR(ROUNDUP(boot_freemem, PGSIZE));
+       physaddr_t physaddr_after_kernel = PADDR(ROUNDUP((unsigned int)boot_freemem, PGSIZE));
        LIST_INIT(&page_free_list);
 
        pages[0].pp_ref = 1;
@@ -641,7 +638,7 @@ error_t     pagetable_remove(pde_t *pgdir, void *va)
 
        if (!(*the_pde & PTE_P) || (*the_pde & PTE_PS))
                return -EFAULT;
-       pte_t* page_table = (pde_t*)KADDR(PTE_ADDR(*the_pde));
+       pte_t* page_table = (pde_t*COUNT(NPTENTRIES))KADDR(PTE_ADDR(*the_pde));
        for (int i = 0; i < NPTENTRIES; i++) 
                if (page_table[i] & PTE_P)
                        panic("Page table not empty during attempted removal!");
@@ -676,7 +673,7 @@ pgdir_walk(pde_t *pgdir, const void *SNT va, int create)
        if (*the_pde & PTE_P) {
                if (*the_pde & PTE_PS)
                        return (pte_t*)the_pde;
-               return &((pde_t*)KADDR(PTE_ADDR(*the_pde)))[PTX(va)];
+               return &((pde_t*COUNT(NPTENTRIES))KADDR(PTE_ADDR(*the_pde)))[PTX(va)];
        }
        if (!create)
                return NULL;
@@ -691,7 +688,7 @@ pgdir_walk(pde_t *pgdir, const void *SNT va, int create)
        new_table->pp_ref = 1;
        memset(page2kva(new_table), 0, PGSIZE);
        *the_pde = (pde_t)page2pa(new_table) | PTE_P | PTE_W | PTE_U;
-       return &((pde_t*)KADDR(PTE_ADDR(*the_pde)))[PTX(va)];
+       return &((pde_t*COUNT(NPTENTRIES))KADDR(PTE_ADDR(*the_pde)))[PTX(va)];
 }
 
 /* Flushes a TLB, including global pages.  We should always have the CR4_PGE
@@ -745,7 +742,7 @@ page_check(void)
        assert(page_insert(boot_pgdir, pp1, 0x0, 0) == 0);
        tlb_invalidate(boot_pgdir, 0x0);
        // DEP Should have shot down invalid TLB entry - let's check
-       {
+       { TRUSTEDBLOCK
          int *x = 0x0;
          assert(*x == 0xFFFFFFFF);
        }
@@ -755,28 +752,28 @@ page_check(void)
        assert(pp0->pp_ref == 1);
 
        // should be able to map pp2 at PGSIZE because pp0 is already allocated for page table
-       assert(page_insert(boot_pgdir, pp2, (void*) PGSIZE, 0) == 0);
+       assert(page_insert(boot_pgdir, pp2, (void*SNT) PGSIZE, 0) == 0);
        assert(check_va2pa(boot_pgdir, PGSIZE) == page2pa(pp2));
        assert(pp2->pp_ref == 1);
 
        // Make sure that pgdir_walk returns a pointer to the pte and
        // not the table or some other garbage
        {
-         pte_t *p = KADDR(PTE_ADDR(boot_pgdir[PDX(PGSIZE)]));
-         assert(pgdir_walk(boot_pgdir, (void *)PGSIZE, 0) == &p[PTX(PGSIZE)]);
+         pte_t *p = (pte_t*COUNT(NPTENTRIES))KADDR(PTE_ADDR(boot_pgdir[PDX(PGSIZE)]));
+         assert(pgdir_walk(boot_pgdir, (void *SNT)PGSIZE, 0) == &p[PTX(PGSIZE)]);
        }
 
        // should be no free memory
        assert(page_alloc(&pp) == -ENOMEM);
 
        // should be able to map pp2 at PGSIZE because it's already there
-       assert(page_insert(boot_pgdir, pp2, (void*) PGSIZE, PTE_U) == 0);
+       assert(page_insert(boot_pgdir, pp2, (void*SNT) PGSIZE, PTE_U) == 0);
        assert(check_va2pa(boot_pgdir, PGSIZE) == page2pa(pp2));
        assert(pp2->pp_ref == 1);
 
        // Make sure that we actually changed the permission on pp2 when we re-mapped it
        {
-         pte_t *p = pgdir_walk(boot_pgdir, (void*)PGSIZE, 0);
+         pte_t *p = pgdir_walk(boot_pgdir, (void*SNT)PGSIZE, 0);
          assert(((*p) & PTE_U) == PTE_U);
        }
 
@@ -785,10 +782,10 @@ page_check(void)
        assert(page_alloc(&pp) == -ENOMEM);
 
        // should not be able to map at PTSIZE because need free page for page table
-       assert(page_insert(boot_pgdir, pp0, (void*) PTSIZE, 0) < 0);
+       assert(page_insert(boot_pgdir, pp0, (void*SNT) PTSIZE, 0) < 0);
 
        // insert pp1 at PGSIZE (replacing pp2)
-       assert(page_insert(boot_pgdir, pp1, (void*) PGSIZE, 0) == 0);
+       assert(page_insert(boot_pgdir, pp1, (void*SNT) PGSIZE, 0) == 0);
 
        // should have pp1 at both 0 and PGSIZE, pp2 nowhere, ...
        assert(check_va2pa(boot_pgdir, 0) == page2pa(pp1));
@@ -808,7 +805,7 @@ page_check(void)
        assert(pp2->pp_ref == 0);
 
        // unmapping pp1 at PGSIZE should free it
-       page_remove(boot_pgdir, (void*) PGSIZE);
+       page_remove(boot_pgdir, (void*SNT) PGSIZE);
        assert(check_va2pa(boot_pgdir, 0x0) == ~0);
        assert(check_va2pa(boot_pgdir, PGSIZE) == ~0);
        assert(pp1->pp_ref == 0);
@@ -831,9 +828,9 @@ page_check(void)
          // Give back pp0 for a bit
          page_free(pp0);
 
-         void * va = (void *)((PGSIZE * NPDENTRIES) + PGSIZE);
+         void *SNT va = (void *SNT)((PGSIZE * NPDENTRIES) + PGSIZE);
          pte_t *p2 = pgdir_walk(boot_pgdir, va, 1);
-         pte_t *p = KADDR(PTE_ADDR(boot_pgdir[PDX(va)]));
+         pte_t *p = (pte_t*COUNT(NPTENTRIES))KADDR(PTE_ADDR(boot_pgdir[PDX(va)]));
          assert(p2 == &p[PTX(va)]);
 
          // Clean up again
index 0db7fc8..9fbf3fd 100644 (file)
@@ -5,16 +5,16 @@
 
 // Debug information about a particular instruction pointer
 typedef struct Eipdebuginfo {
-       const char *eip_file;           // Source code filename for EIP
+       const char *NTS eip_file;               // Source code filename for EIP
        int eip_line;                           // Source code linenumber for EIP
 
-       const char *eip_fn_name;        // Name of function containing EIP
+       const char *NT COUNT(eip_fn_namelen) eip_fn_name;       // Name of function containing EIP
                                                                //  - Note: not null terminated!
        int eip_fn_namelen;                     // Length of function name
        uintptr_t eip_fn_addr;          // Address of start of function
        int eip_fn_narg;                        // Number of function arguments
 } eipdebuginfo_t;
 
-int debuginfo_eip(uintptr_t eip, eipdebuginfo_t *info);
+int debuginfo_eip(uintptr_t eip, eipdebuginfo_t *NONNULL info);
 
 #endif
index 2248621..550a75e 100644 (file)
@@ -66,7 +66,7 @@ struct Page {
 };
 
 
-extern char bootstacktop[], bootstack[];
+extern char (SNT bootstacktop)[], (SNT bootstack)[];
 
 extern page_t *COUNT(npage) pages;
 extern size_t npage;
@@ -77,7 +77,8 @@ extern pde_t *COUNT(NPDENTRIES) boot_pgdir;
 extern char* boot_freemem;
 extern page_list_t page_free_list;
 
-void*  boot_alloc(uint32_t n, uint32_t align);
+void*  (DALLOC(n) boot_alloc)(uint32_t n, uint32_t align);
+void*  (DALLOC(_n*sz) boot_calloc)(uint32_t _n, size_t sz, uint32_t align);
 
 void   multiboot_detect_memory(multiboot_info_t *mbi);
 void   multiboot_print_memory_map(multiboot_info_t *mbi);
@@ -94,7 +95,7 @@ int       page_insert(pde_t *COUNT(NPDENTRIES) pgdir, page_t *pp, void *SNT va, in
 void*   page_insert_in_range(pde_t *COUNT(NPDENTRIES) pgdir, page_t *pp, 
                              void *SNT vab, void *SNT vae, int perm);
 void   page_remove(pde_t *COUNT(NPDENTRIES) pgdir, void *SNT va);
-page_t* page_lookup(pde_t *COUNT(NPDENTRIES) pgdir, void *va, pte_t **pte_store);
+page_t* page_lookup(pde_t *COUNT(NPDENTRIES) pgdir, void *SNT va, pte_t **pte_store);
 error_t        pagetable_remove(pde_t *COUNT(NPDENTRIES) pgdir, void *va);
 void   page_decref(page_t *pp);
 
index 507abfd..88eb8c7 100644 (file)
 typedef uint32_t pte_t;
 typedef uint32_t pde_t;
 
-extern volatile pte_t vpt[];     // VA of "virtual page table"
-extern volatile pde_t vpd[];     // VA of current page directory
+extern volatile pte_t (COUNT(PTSIZE) vpt)[];     // VA of "virtual page table"
+extern volatile pde_t (COUNT(PTSIZE) vpd)[];     // VA of current page directory
 
 #endif /* !__ASSEMBLER__ */
 #endif /* !ROS_INC_MEMLAYOUT_H */
index 59a7f93..b1ca2ab 100644 (file)
@@ -3,22 +3,25 @@
 
 #include <arch/types.h>
 
-int    strlen(const char *s);
-int    strnlen(const char *s, size_t size);
-char * strcpy(char *dst, const char *src);
+#define STRING char *NTS NONNULL
+#define STRBUF(n) char *NT COUNT(n) NONNULL
+
+int    strlen(const STRING s);
+int    strnlen(const STRBUF(size) s, size_t size);
+char * strcpy(STRING dst, const STRING src);
 char * strcat(char *dst, const char *src);
-char * strncpy(char *dst, const char *src, size_t size);
-size_t strlcpy(char *dst, const char *src, size_t size);
-int    strcmp(const char *s1, const char *s2);
-int    strncmp(const char *s1, const char *s2, size_t size);
-char * strchr(const char *s, char c);
-char * strfind(const char *s, char c);
+char * strncpy(STRBUF(size) dst, const STRING src, size_t size);
+size_t strlcpy(STRBUF(size-1) dst, const STRING src, size_t size);
+int    strcmp(const STRING s1, const STRING s2);
+int    strncmp(const STRING s1, const STRING s2, size_t size);
+char * strchr(const STRING s, char c);
+char * strfind(const STRING s, char c);
 
-void * memset(void *dst, int c, size_t len);
-void * memcpy(void *dst, const void *src, size_t len);
-void * memmove(void *dst, const void *src, size_t len);
-int    memcmp(const void *s1, const void *s2, size_t len);
-void * memfind(const void *s, int c, size_t len);
+void * memset(void *COUNT(len) dst, int c, size_t len);
+void * memcpy(void *COUNT(len) dst, const void *COUNT(len) src, size_t len);
+void * memmove(void *COUNT(len) dst, const void *COUNT(len) src, size_t len);
+int    memcmp(const void *COUNT(len) s1, const void *COUNT(len) s2, size_t len);
+void * memfind(const void *COUNT(len) s, int c, size_t len);
 
 long   strtol(const char *s, char **endptr, int base);
 
index 6011bc7..f557714 100644 (file)
@@ -53,6 +53,37 @@ boot_alloc(uint32_t n, uint32_t align)
        return v;
 }
 
+void*
+boot_calloc(uint32_t _n, size_t sz, uint32_t align)
+{
+       extern char end[];
+       uint32_t n = _n *sz;
+       void *v;
+
+       // Initialize boot_freemem if this is the first time.
+       // 'end' is a magic symbol automatically generated by the linker,
+       // which points to the end of the kernel's bss segment -
+       // i.e., the first virtual address that the linker
+       // did _not_ assign to any kernel code or global variables.
+       if (boot_freemem == 0)
+               boot_freemem = end;
+
+       //      Step 1: round boot_freemem up to be aligned properly
+       boot_freemem = ROUNDUP(boot_freemem, align);
+
+       //      Step 2: save current value of boot_freemem as allocated chunk
+       v = boot_freemem;
+       //  Step 2.5: check if we can alloc
+       if (PADDR(boot_freemem + n) > maxaddrpa)
+               panic("Out of memory in boot alloc, you fool!\n");
+       //      Step 3: increase boot_freemem to record allocation
+       boot_freemem += n;
+       //  Step 4: zero allocated chunk
+       memset(v,0,n);
+       //      Step 5: return allocated chunk
+       return v;
+}
+
 //
 // Initialize a Page structure.
 // The result has null links and 0 refcount.
index e26d2a1..f49dfbb 100644 (file)
@@ -26,7 +26,7 @@ enum {
 
 typedef struct channel_msg {
        size_t len;
-       void* buf;
+       void *COUNT(len) buf;
 } channel_msg_t;
 
 typedef struct channel_ack {
@@ -60,7 +60,7 @@ typedef struct channel_attr {
 
 /***************** Channel related functions *****************/
 
-error_t channel_create(pid_t server, channel_t* ch, channel_attr_t* attr);
+error_t channel_create(pid_t server, channel_t*COUNT(1) ch, channel_attr_t* attr);
 error_t channel_create_wait(channel_t* ch, channel_attr_t* attr);
 error_t channel_destroy(channel_t* ch);
 
index 5f64518..8760158 100644 (file)
@@ -315,10 +315,10 @@ int system(const OPTSTRING str);
 
 unsigned int  strlen(const STRING s);
 
-void * (DMEMSET(1, 2, 3) memset)(void* p, int what, size_t sz);
-int    (DMEMCMP(1, 2, 3) memcmp)(void* s1, void* s2, size_t sz);
+void * (DMEMSET(1, 2, 3) memset)(void* p, int what, void sz);
+int    (DMEMCMP(1, 2, 3) memcmp)(void* s1, void* s2, void sz);
 void * (DMEMCPY(1, 2, 3) memcpy)(void* dst, void* src, void sz);
-void * (DMEMCPY(1, 2, 3) memmove)(void *dst, void* src, size_t sz);
+void * (DMEMCPY(1, 2, 3) memmove)(void *dst, void* src, void sz);
 
 void bzero(void * COUNT(size) buff, unsigned int size);
 
index 9417a91..ba576f2 100644 (file)
@@ -51,7 +51,7 @@ error_t channel_create(pid_t server, channel_t* ch, channel_attr_t* ch_attr) {
         * initialization now on this end, and only accessing it on the server side
         * after our data page has been created.
         */
-       memset((void*SAFE) TC(ch), 0, sizeof(channel_t));
+       memset(ch, 0, sizeof(channel_t));
        ch->endpoint = server;
        ch->ring_addr = (channel_sring_t *COUNT(1)) TC(ring_addr);
        ch->type = CHANNEL_CLIENT;