Compiles with GCC
authorBarret Rhoden <brho@cs.berkeley.edu>
Sat, 5 Sep 2009 04:49:24 +0000 (21:49 -0700)
committerBarret Rhoden <brho@cs.berkeley.edu>
Sat, 5 Sep 2009 04:49:24 +0000 (21:49 -0700)
Set COMPILER in your Makelocal to GCC if you want to not compile with
Ivy.  It will compile and run with Ivy or gcc, though there were a few
places where they are mutually unhappy, or we couldn't figure out nice
ways to do the annotations.  For instance, the struct work isn't
supposed to be TP(env_t*) all the time.  Also, cil destroys our attempts
at unbounded arrays.  Look for pragma nodeputy in a few places.

Also changed types so we can eventually have our own, um, i guess we
still need to have our own types.h for the kernel, but we cleaned it up a
bit is the point, right? (Kevin, verbatim)

Some work in progress for mmap and other stuff, but I never did any of
that.  Just ignore it for now.

106 files changed:
GNUmakefile
kern/Makefrag
kern/arch/i386/apic.h
kern/arch/i386/arch.h
kern/arch/i386/atomic.h
kern/arch/i386/console.c
kern/arch/i386/console.h
kern/arch/i386/cpuinfo.c
kern/arch/i386/mmu.h
kern/arch/i386/pmap.c
kern/arch/i386/smp_boot.c
kern/arch/i386/trap.c
kern/arch/i386/trap.h
kern/arch/i386/types.h
kern/arch/i386/x86.h
kern/arch/sparc/boot.c
kern/arch/sparc/console.h
kern/arch/sparc/frontend.h
kern/arch/sparc/smp.h
kern/arch/sparc/sparc.h
kern/arch/sparc/timer.c
kern/arch/sparc/timer.h
kern/arch/sparc/trap.h
kern/include/atomic.h
kern/include/colored_caches.h
kern/include/elf.h
kern/include/env.h
kern/include/kdebug.h
kern/include/kfs.h
kern/include/kmalloc.h
kern/include/listable.h
kern/include/multiboot.h
kern/include/pmap.h
kern/include/process.h
kern/include/ros/common.h
kern/include/ros/error.h
kern/include/ros/memlayout.h
kern/include/ros/mman.h [new file with mode: 0644]
kern/include/ros/noivy.h [new file with mode: 0644]
kern/include/ros/procdata.h
kern/include/ros/ring_buffer.h
kern/include/ros/syscall.h
kern/include/smp.h
kern/include/stab.h
kern/include/stdint.h [new file with mode: 0644]
kern/include/string.h
kern/include/sys/queue.h
kern/include/sys/types.h [new file with mode: 0644]
kern/include/syscall.h
kern/include/testing.h
kern/include/timing.h
kern/include/types.h [new file with mode: 0644]
kern/include/workqueue.h
kern/ivy/Makefrag
kern/ivy/deputy.c
kern/ivy/sharc.c
kern/src/atomic.c
kern/src/colored_caches.c
kern/src/env.c
kern/src/kfs.c
kern/src/kmalloc.c
kern/src/manager.c
kern/src/monitor.c
kern/src/multiboot.c
kern/src/pmap.c
kern/src/printf.c
kern/src/printfmt.c
kern/src/process.c
kern/src/syscall.c
kern/src/testing.c
kern/src/timer.c
kern/src/workqueue.c
user/Makefrag
user/apps/parlib/Makefrag
user/apps/parlib/file_error.c
user/apps/parlib/file_io.c
user/apps/parlib/matrix.c
user/apps/roslib/measurements.c
user/apps/roslib/mhello.c
user/parlib/inc/channel.h
user/parlib/inc/newlib_backend.h
user/parlib/inc/parlib.h
user/parlib/ivy/Makefrag
user/parlib/ivy/deputy.c
user/parlib/src/Makefrag
user/parlib/src/debug.c
user/parlib/src/debugfmt.c
user/parlib/src/i386/newlib_backend.c
user/parlib/src/i386/syscall.c
user/roslib/inc/lib.h
user/roslib/inc/measure.h
user/roslib/inc/stdint.h [new file with mode: 0644]
user/roslib/inc/string.h
user/roslib/inc/sys [new symlink]
user/roslib/inc/sys/queue.h [deleted symlink]
user/roslib/inc/types.h [deleted file]
user/roslib/ivy/Makefrag
user/roslib/ivy/deputy.c
user/roslib/src/asynccall.c
user/roslib/src/exit.c
user/roslib/src/i386/syscall.c
user/roslib/src/printf.c
user/roslib/src/printfmt.c
user/roslib/src/syscall.c
user/roslib/src/syswrapper.c
user/roslib/src/timer.c

index 2c9e79f..c44f8ca 100644 (file)
@@ -6,7 +6,6 @@
 #      http://aegis.sourceforge.net/auug97.pdf
 #
 
-
 OBJDIR := obj
 
 # Make sure that 'all' is the first target
@@ -14,6 +13,7 @@ all: symlinks
 
 # User defined constants passed on the command line 
 TARGET_ARCH := i386
+COMPILER := IVY
 
 -include Makelocal
 
@@ -49,15 +49,19 @@ GCCPREFIX := $(shell if i386-ros-elf-objdump -i 2>&1 | grep '^elf32-i386$$' >/de
 endif
 
 # Default programs for compilation
-KERN_IVY_FLAGS := --deputy\
+ifeq ($(COMPILER),IVY)
+KERN_CFLAGS := --deputy\
                   --enable-error-db\
                   --no-rc-sharc\
                   --sc-dynamic-is-error\
                   --sc-ops=$(INCLUDE_DIR)/ivy/sharc.h\
                   --sc-all-in-thread
-                  $(EXTRAARGS)
-USER_IVY_FLAGS := --deputy --enable-error-db $(EXTRAARGS)
+USER_CFLAGS := --deputy --enable-error-db
 CC         := ivycc --gcc=$(GCCPREFIX)gcc
+else
+CC         := $(GCCPREFIX)gcc -std=gnu99
+endif
+
 AS         := $(GCCPREFIX)as
 AR         := $(GCCPREFIX)ar
 LD         := $(GCCPREFIX)ld
@@ -69,7 +73,7 @@ PERL    := perl
 # Universal compiler flags
 # -fno-builtin is required to avoid refs to undefined functions in the kernel.
 # Only optimize to -O1 to discourage inlining, which complicates backtraces.
-CFLAGS := $(CFLAGS) -D$(TARGET_ARCH)
+CFLAGS := $(CFLAGS) -D$(TARGET_ARCH) $(EXTRAARGS)
 CFLAGS += -O2 -pipe -MD -fno-builtin -fno-stack-protector -gstabs
 CFLAGS += -Wall -Wno-format -Wno-unused -Wno-attributes
 CFLAGS += -nostdinc -Igccinclude/$(TARGET_ARCH)
index 39c72cd..d0d60c9 100644 (file)
@@ -1,6 +1,6 @@
 KERN_DIR := kern
 
-KERN_CFLAGS := $(KERN_IVY_FLAGS) $(CFLAGS) -DROS_KERNEL
+KERN_CFLAGS += $(CFLAGS) -DROS_KERNEL
 KERN_CFLAGS += -I$(INCLUDE_DIR)
 KERN_LDFLAGS := $(LDFLAGS)
 
index 2d84236..8a03c7c 100644 (file)
@@ -103,7 +103,7 @@ void timer_init(void);
 void udelay_pit(uint64_t usec);
 // TODO: right now timer defaults to TSC
 uint64_t gettimer(void);
-uint64_t inline getfreq(void);
+uint64_t getfreq(void);
 
 static inline void pic_send_eoi(uint32_t irq);
 static inline void lapic_send_eoi(void);
@@ -186,9 +186,8 @@ static inline void lapic_disable(void)
  */
 static inline void lapic_wait_to_send(void)
 {
-       static inline void cpu_relax(void);
        while(read_mmreg32(LAPIC_IPI_ICR_LOWER) & 0x1000)
-               cpu_relax();
+               __cpu_relax();
 }
 
 static inline void lapic_enable(void)
index 448a8eb..3ddb38f 100644 (file)
@@ -2,9 +2,9 @@
 #define ROS_INC_ARCH_H
 
 #include <arch/x86.h>
-#include <arch/types.h>
-#include <arch/apic.h>
+#include <ros/common.h>
 #include <arch/trap.h>
+#include <arch/apic.h>
 
 /* Arch Constants */
 #define MAX_NUM_CPUS                           255
@@ -111,9 +111,7 @@ disable_irqsave(int8_t* state)
 static __inline void
 cpu_relax(void)
 {
-       // in case the compiler doesn't serialize for pause, the "m" will make sure
-       // no memory is reordered around this instruction.
-       asm volatile("pause" : : : "memory");
+       __cpu_relax();
 }
 
 static __inline void
@@ -123,7 +121,7 @@ cpu_halt(void)
 }
 
 static __inline void
-clflush(uintptr_t* addr) __attribute__((always_inline))
+clflush(uintptr_t* addr)
 {
        asm volatile("clflush %0" : : "m"(*addr));
 }
@@ -135,7 +133,7 @@ irq_is_enabled(void)
 }
 
 static __inline uint32_t
-( core_id)(void)
+core_id(void)
 {
        return lapic_get_id();
 }
@@ -143,7 +141,7 @@ static __inline uint32_t
 static __inline void
 cache_flush(void)
 {
-        wbinvd();
+       wbinvd();
 }
 
 static __inline void
@@ -154,4 +152,4 @@ reboot(void)
        while(1);
 }
 
-#endif /* !ROS_INC_X86_H */
+#endif /* !ROS_INC_ARCH_H */
index c85f385..87fbc95 100644 (file)
@@ -1,7 +1,7 @@
 #ifndef ROS_INCLUDE_ATOMIC_H
 #define ROS_INCLUDE_ATOMIC_H
 
-#include <arch/types.h>
+#include <ros/common.h>
 
 #define mb() {rmb(); wmb();}
 #define rmb() ({ asm volatile("lfence"); })
index 12d5c84..0dc36aa 100644 (file)
@@ -400,7 +400,9 @@ static uint8_t * COUNT(256) (SREADONLY charcode)[4] = {
  * Get data from the keyboard.  If we finish a character, return it.  Else 0.
  * Return -1 if no data.
  */
+#ifdef __IVY__
 #pragma cilnoremove("cons_lock")
+#endif
 static volatile uint32_t SRACY cons_lock = 0;
 static uint32_t SLOCKED(&cons_lock) shift;
 static bool SLOCKED(&cons_lock) crt_scrolled = FALSE;
index c00fa58..205581a 100644 (file)
@@ -6,7 +6,7 @@
 # error "This is a ROS kernel header; user programs should not #include it"
 #endif
 
-#include <arch/types.h>
+#include <ros/common.h>
 
 #define MONO_BASE      0x3B4
 #define MONO_BUF       0xB0000
index be253a0..9330f5d 100644 (file)
@@ -72,7 +72,7 @@ void print_cpuinfo(void)
        if (ecx & 0x00000060) {
                msr_val = read_msr(IA32_FEATURE_CONTROL);
                printd("64 Bit Feature Control: 0x%08x\n", msr_val);
-               if (msr_val & 0x5 == 0x5)
+               if ((msr_val & 0x5) == 0x5)
                        printk("Hardware virtualization supported\n");
                else
                        printk("Hardware virtualization not supported\n");
@@ -127,6 +127,7 @@ void show_mapping(uintptr_t start, size_t size)
 
 void backtrace(void)
 { TRUSTEDBLOCK
+       extern char (SNT SREADONLY _start)[];
        uint32_t *ebp, eip;
        eipdebuginfo_t debuginfo;
        char buf[256];
index 115b810..5783fec 100644 (file)
@@ -1,6 +1,10 @@
 #ifndef ROS_INC_MMU_H
 #define ROS_INC_MMU_H
 
+#ifndef __ASSEMBLER__
+#include <ros/common.h>
+#endif
+
 /*
  * This file contains definitions for the x86 memory management unit (MMU),
  * including paging- and segmentation-related data structures and constants,
 
 #else  // not __ASSEMBLER__
 
-#include <arch/types.h>
+#include <ros/common.h>
 
 // Segment Descriptors
 typedef struct Segdesc {
@@ -199,15 +203,15 @@ typedef struct Segdesc {
        unsigned sd_base_31_24 : 8; // High bits of segment base address
 } segdesc_t;
 // Null segment
-#define SEG_NULL       (segdesc_t){ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
+#define SEG_NULL       { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
 // Segment that is loadable but faults when used
-#define SEG_FAULT      (segdesc_t){ 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0 }
+#define SEG_FAULT      { 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0 }
 // Normal segment
-#define SEG(type, base, lim, dpl) (segdesc_t)                                          \
+#define SEG(type, base, lim, dpl)                                                                      \
 { ((lim) >> 12) & 0xffff, (base) & 0xffff, ((base) >> 16) & 0xff,      \
     type, 1, dpl, 1, (unsigned) (lim) >> 28, 0, 0, 1, 1,                       \
     (unsigned) (base) >> 24 }
-#define SEG16(type, base, lim, dpl) (segdesc_t)                                                \
+#define SEG16(type, base, lim, dpl)                                                            \
 { (lim) & 0xffff, (base) & 0xffff, ((base) >> 16) & 0xff,                      \
     type, 1, dpl, 1, (unsigned) (lim) >> 16, 0, 0, 1, 0,                       \
     (unsigned) (base) >> 24 }
index 057723f..16cff72 100644 (file)
@@ -440,7 +440,6 @@ vm_init(void)
 // but it is a pretty good sanity check. 
 //
 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)
@@ -486,13 +485,21 @@ check_boot_pgdir(bool pse)
                }
        }
 
-       // check permissions
-       // user read-only.  check for user and write, should be only user
-       // eagle-eyed viewers should be able to explain the extra cases
+       /* check permissions
+        * user read-only.  check for user and write, should be only user
+        * eagle-eyed viewers should be able to explain the extra cases.
+        * for the mongoose-eyed, remember that weird shit happens when you loop
+        * through UVPT.  Specifically, you can't loop once, then look at a jumbo
+        * page that is kernel only.  That's the end of the page table for you, so
+        * having a U on the entry doesn't make sense.  Thus we check for a jumbo
+        * page, and special case it.  This will happen at 0xbf701000.  Why is this
+        * magical?  Get your eagle glasses and figure it out. */
        for (i = UTOP; i < ULIM; i+=PGSIZE) {
-               pte = get_vaperms(pgdir, i);
-               if ((pte & PTE_P) && (i != UVPT+(VPT>>10))) {
-                       if (pte & PTE_PS) {
+               pte = get_va_perms(pgdir, (void*SAFE)TC(i));
+               if (pte & PTE_P) {
+                       if (i == UVPT+(VPT >> 10))
+                               continue;
+                       if (*pgdir_walk(pgdir, (void*SAFE)TC(i), 0) & PTE_PS) {
                                assert((pte & PTE_U) != PTE_U);
                                assert((pte & PTE_W) != PTE_W);
                        } else {
@@ -503,20 +510,20 @@ check_boot_pgdir(bool pse)
        }
        // kernel read-write.
        for (i = ULIM; i <= KERNBASE + maxaddrpa - PGSIZE; i+=PGSIZE) {
-               pte = get_vaperms(pgdir, i);
+               pte = get_va_perms(pgdir, (void*SAFE)TC(i));
                if ((pte & PTE_P) && (i != VPT+(UVPT>>10))) {
                        assert((pte & PTE_U) != PTE_U);
                        assert((pte & PTE_W) == PTE_W);
                }
        }
        // special mappings
-       pte = get_vaperms(pgdir, UVPT+(VPT>>10));
+       pte = get_va_perms(pgdir, (void*SAFE)TC(UVPT+(VPT>>10)));
        assert((pte & PTE_U) != PTE_U);
        assert((pte & PTE_W) != PTE_W);
 
        // note this means the kernel cannot directly manipulate this virtual address
        // convince yourself this isn't a big deal, eagle-eyes!
-       pte = get_vaperms(pgdir, VPT+(UVPT>>10));
+       pte = get_va_perms(pgdir, (void*SAFE)TC(VPT+(UVPT>>10)));
        assert((pte & PTE_U) != PTE_U);
        assert((pte & PTE_W) != PTE_W);
 
@@ -546,23 +553,6 @@ check_va2pa(pde_t *COUNT(NPDENTRIES) _pgdir, uintptr_t va)
 }
 
 /* 
- * This function returns a PTE with the aggregate permissions equivalent
- * to walking the two levels of paging.  PPN = 0.  Somewhat fragile, in that
- * it returns PTE_PS if either entry has PTE_PS (which should only happen
- * for some of the recusive walks)
- */
-
-static pte_t
-get_vaperms(pde_t *COUNT(NPDENTRIES) pgdir, uintptr_t va)
-{
-       pde_t* pde = &pgdir[PDX(va)];
-       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);
-}
-
-/* 
  * Remove the second level page table associated with virtual address va.
  * Will 0 out the PDE for that page table.
  * Panics if the page table has any present entries.
@@ -634,17 +624,48 @@ pgdir_walk(pde_t *pgdir, const void *SNT va, int create)
 int get_va_perms(pde_t *pgdir, const void *SNT va)
 {
        pde_t the_pde = pgdir[PDX(va)];
-       pte_t the_pte = 0;
+       pte_t the_pte;
 
        if (!(the_pde & PTE_P))
                return 0;
        if (the_pde & PTE_PS)
                return the_pde & (PTE_U | PTE_W | PTE_P);
-       // else
        the_pte = ((pde_t*COUNT(NPTENTRIES))KADDR(PTE_ADDR(the_pde)))[PTX(va)];
+       if (!(the_pte & PTE_P))
+               return 0;
        return the_pte & the_pde & (PTE_U | PTE_W | PTE_P);
 }
 
+void *get_free_va_range(pde_t *pgdir, uintptr_t addr, size_t len)
+{
+{TRUSTEDBLOCK
+       // want to make sure there aren't mappings already.  will need to do this
+       // later with zones, for when we lazily allocate memory
+
+       uintptr_t startaddr;
+
+       int npages = ROUNDUP(len, PGSIZE) / PGSIZE;
+
+       addr &= ~0xfff;
+       if (!addr)
+               // some sensible default.  can cache the previous value somewhere
+               addr = USTACKTOP - PGSIZE; // TODO: not looking down
+       startaddr = addr;       
+       pte_t *pte = pgdir_walk(pgdir, (void*)addr, 0);
+       // what about jumbo pages?
+       // consider looping around, esp if we start from a cached spot
+       // don't map at pg 0, or below brk
+       // consider local memory ranges...
+
+       /*
+       first fit?
+       what if we have a sorted structure of what mem ranges are already in use?
+       */
+
+       return (void*)0xdeadbeef;
+}
+}
+
 /* Flushes a TLB, including global pages.  We should always have the CR4_PGE
  * flag set, but just in case, we'll check.  Toggling this bit flushes the TLB.
  */
index da1a8e7..95373b8 100644 (file)
@@ -8,6 +8,10 @@
 #pragma nosharc
 #endif
 
+#ifdef __IVY__
+#pragma nodeputy
+#endif
+
 #include <arch/x86.h>
 #include <arch/arch.h>
 #include <smp.h>
@@ -56,25 +60,28 @@ static void init_smp_call_function(void)
 
 /******************************************************************************/
 
-static void ( smp_mtrr_handler)(trapframe_t *tf, barrier_t *data)
+static void smp_mtrr_handler(trapframe_t *tf, TV(t) data)
 {
        setup_default_mtrrs(data);
 }
 
 // this needs to be set in smp_entry too...
 #define trampoline_pg 0x00001000
-extern smp_entry(), smp_entry_end(), smp_boot_lock(), smp_semaphore();
+extern char (SNT SREADONLY smp_entry)[];
+extern char (SNT SREADONLY smp_entry_end)[];
+extern char (SNT SREADONLY smp_boot_lock)[];
+extern char (SNT SREADONLY smp_semaphore)[];
 
 static inline volatile uint32_t *COUNT(1)
 get_smp_semaphore()
 {
-       return (volatile uint32_t *COUNT(1))TC(&smp_semaphore - &smp_entry + trampoline_pg);
+       return (volatile uint32_t *COUNT(1))TC(smp_semaphore - smp_entry + trampoline_pg);
 }
 
 static inline uint32_t *COUNT(1)
 get_smp_bootlock()
 {
-       return (uint32_t *COUNT(1))TC(&smp_boot_lock - &smp_entry + trampoline_pg);
+       return (uint32_t *COUNT(1))TC(smp_boot_lock - smp_entry + trampoline_pg);
 }
 
 void smp_boot(void)
@@ -83,8 +90,8 @@ void smp_boot(void)
        // NEED TO GRAB A LOWMEM FREE PAGE FOR AP BOOTUP CODE
        // page1 (2nd page) is reserved, hardcoded in pmap.c
        memset(KADDR(trampoline_pg), 0, PGSIZE);
-       memcpy(KADDR(trampoline_pg), (void *COUNT(PGSIZE))TC(&smp_entry),
-           &smp_entry_end - &smp_entry);
+       memcpy(KADDR(trampoline_pg), (void *COUNT(PGSIZE))TC(smp_entry),
+           smp_entry_end - smp_entry);
 
        // This mapping allows access to the trampoline with paging on and off
        // via trampoline_pg
@@ -227,7 +234,8 @@ uint32_t smp_main(void)
        my_ts->ts_esp0 = my_stack_top;
        my_ts->ts_ss0 = GD_KD;
        // Initialize the TSS field of my_gdt.
-       my_gdt[GD_TSS >> 3] = SEG16(STS_T32A, (uint32_t) (my_ts), sizeof(taskstate_t), 0);
+       my_gdt[GD_TSS >> 3] = (segdesc_t)SEG16(STS_T32A, (uint32_t) (my_ts),
+                             sizeof(taskstate_t), 0);
        my_gdt[GD_TSS >> 3].sd_s = 0;
        // Load the TSS
        ltr(GD_TSS);
index 6d4c3f4..e0c77cb 100644 (file)
@@ -109,8 +109,8 @@ idt_init(void)
        ts.ts_ss0 = GD_KD;
 
        // Initialize the TSS field of the gdt.
-       gdt[GD_TSS >> 3] = SEG16(STS_T32A, (uint32_t) (&ts),
-                                       sizeof(taskstate_t), 0);
+       gdt[GD_TSS >> 3] = (segdesc_t)SEG16(STS_T32A, (uint32_t) (&ts),
+                                          sizeof(taskstate_t), 0);
        gdt[GD_TSS >> 3].sd_s = 0;
 
        // Load the TSS
index d458d48..049172f 100644 (file)
@@ -53,7 +53,7 @@
 
 #ifndef __ASSEMBLER__
 
-#include <arch/types.h>
+#include <ros/common.h>
 #include <arch/mmu.h>
 
 /* The kernel's interrupt descriptor table */
index 28bc462..dc8ea85 100644 (file)
@@ -1,24 +1,11 @@
 #ifndef ROS_INC_TYPES_H
 #define ROS_INC_TYPES_H
 
-#define LITTLE_ENDIAN
-
-#ifndef NULL
-#define NULL ((void*) 0)
-#endif
-
-#ifndef TRUE
-#define TRUE   1
-#endif
+#include <stddef.h>
 
-#ifndef FALSE
-#define FALSE  0
-#endif
-
-#define CHECK_FLAG(flags,bit)   ((flags) & (1 << (bit)))
+#define LITTLE_ENDIAN
 
 // Represents true-or-false values
-typedef int bool;
 
 #define NUM_ADDR_BITS 32
 #define MAX_VADDR     ((uint64_t)(~0) >> (64-NUM_ADDR_BITS))
@@ -38,144 +25,14 @@ typedef unsigned int uint32_t;
 typedef long long int64_t;
 typedef unsigned long long uint64_t;
 
+typedef long ssize_t;
+typedef int pid_t;
+
 // Pointers and addresses are 32 bits long.
 // We use pointer types to represent virtual addresses,
 // uintptr_t to represent the numerical values of virtual addresses,
 // and physaddr_t to represent physical addresses.
 typedef int32_t intptr_t;
 typedef uint32_t uintptr_t;
-typedef uint32_t physaddr_t;
-
-// Registers are 32 bits long
-typedef int32_t intreg_t;
-typedef uint32_t uintreg_t;
-
-// Page numbers are 32 bits long.
-typedef uint32_t ppn_t;
-
-// size_t is used for memory object sizes.
-typedef uint32_t size_t;
-// ssize_t is a signed version of ssize_t, used in case there might be an
-// error return.
-typedef int32_t ssize_t;
-
-// off_t is used for file offsets and lengths.
-typedef int32_t off_t;
-
-// Efficient min and max operations
-#define MIN(_a, _b)                                            \
-({                                                             \
-       typeof(_a) __a = (_a);                                  \
-       typeof(_b) __b = (_b);                                  \
-       __a <= __b ? __a : __b;                                 \
-})
-#define MAX(_a, _b)                                            \
-({                                                             \
-       typeof(_a) __a = (_a);                                  \
-       typeof(_b) __b = (_b);                                  \
-       __a >= __b ? __a : __b;                                 \
-})
-
-// Rounding operations (efficient when n is a power of 2)
-// Round down to the nearest multiple of n
-#define ROUNDDOWN(a, n)                                                \
-({                                                             \
-       uint32_t __a = (uint32_t) (a);                          \
-       (typeof(a)) (__a - __a % (n));                          \
-})
-// Round up to the nearest multiple of n
-#define ROUNDUP(a, n)                                          \
-({                                                             \
-       uint32_t __n = (uint32_t) (n);                          \
-       (typeof(a)) (ROUNDDOWN((uint32_t) (a) + __n - 1, __n)); \
-})
-
-// Round down to the nearest multiple of n
-#define PTRROUNDDOWN(a, n)                                             \
-({                                                             \
-       char * __a = (char *) (a);                              \
-       (typeof(a)) (__a - (uint32_t)__a % (n));                                \
-})
-// Round pointer up to the nearest multiple of n
-#define PTRROUNDUP(a, n)                                               \
-({                                                             \
-       uint32_t __n = (uint32_t) (n);                          \
-       (typeof(a)) (PTRROUNDDOWN((char *) (a) + __n - 1, __n));        \
-})
-
-// Return the integer logarithm of the value provided rounded up
-static inline uint32_t LOG2(uint32_t value)
-{
-    uint32_t l = 0;
-    while( (value >> l) > 1 ) ++l;
-    return l;
-}
-
-// Return the offset of 'member' relative to the beginning of a struct type
-#ifndef offsetof
-#define offsetof(type, member)  ((size_t) (&((type*)0)->member))
-#endif
-
-// Ivy currently can only handle 63 bits (OCaml thing), so use this to make
-// a uint64_t programatically
-#define UINT64(upper, lower) ( (((uint64_t)(upper)) << 32) | (lower) )
-
-/*********************** Bitmask stuff **********************/
-#define BYTES_FOR_BITMASK(size) (((size) - 1) / 8 + 1)
-#define BYTES_FOR_BITMASK_WITH_CHECK(size) ((size) ? ((size) - (1)) / (8) + (1) : (0))
-#define DECL_BITMASK(name, size) uint8_t (name)[BYTES_FOR_BITMASK((size))]
-
-#define GET_BITMASK_BIT(name, bit) (((name)[(bit)/8] & (1 << ((bit) % 8))) ? 1 : 0)
-#define SET_BITMASK_BIT(name, bit) ((name)[(bit)/8] |= (1 << ((bit) % 8)))
-#define CLR_BITMASK_BIT(name, bit) ((name)[(bit)/8] &= ~(1 << ((bit) % 8)))
-#define SET_BITMASK_BIT_ATOMIC(name, bit) (atomic_orb(&(name)[(bit)/8], (1 << ((bit) % 8))))
-#define CLR_BITMASK_BIT_ATOMIC(name, bit) (atomic_andb(&(name)[(bit)/8], ~(1 << ((bit) % 8))))
-
-#define CLR_BITMASK(name, size) \
-({ \
-       {TRUSTEDBLOCK \
-       memset((void*)((uintptr_t)(name)), 0, BYTES_FOR_BITMASK((size))); \
-       } \
-})
-
-#define FILL_BITMASK(name, size) \
-({ \
-       {TRUSTEDBLOCK \
-       memset((void*)((uintptr_t)(name)), 255, BYTES_FOR_BITMASK((size))); \
-       } \
-       (name)[BYTES_FOR_BITMASK((size))-1] >>= (((size) % 8) ? (8 - ((size) % 8)) : 0 ); \
-}) 
-
-#define COPY_BITMASK(newmask, oldmask, size) \
-({ \
-       {TRUSTEDBLOCK \
-       memcpy((void*)((uintptr_t)(newmask)), \
-           (void*)((uintptr_t)(oldmask)), \
-           BYTES_FOR_BITMASK((size))); \
-       } \
-})
-
-// this checks the entire last byte, so keep it 0 in the other macros
-#define BITMASK_IS_CLEAR(name, size) ({ \
-       uint32_t __n = BYTES_FOR_BITMASK((size)); \
-       bool clear = 1; \
-       while (__n-- > 0) { \
-               if ((name)[__n]) { \
-                       clear = 0; \
-                       break;\
-               }\
-       } \
-       clear; })
-
-#define PRINT_BITMASK(name, size) { \
-       int i;  \
-       for (i = 0; i < BYTES_FOR_BITMASK(size); i++) { \
-               int j;  \
-               for (j = 0; j < 8; j++) \
-                       printk("%x", ((name)[i] >> j) & 1);     \
-       } \
-       printk("\n"); \
-}
-/**************************************************************/
 
 #endif /* !ROS_INC_TYPES_H */
index ac192b2..82a70eb 100644 (file)
@@ -1,7 +1,7 @@
 #ifndef ROS_INC_X86_H
 #define ROS_INC_X86_H
 
-#include <arch/types.h>
+#include <ros/common.h>
 #include <arch/mmu.h>
 
 /* Model Specific Registers */
@@ -66,6 +66,7 @@ static __inline void write_msr(uint32_t reg, uint64_t val) __attribute__((always
 static __inline uint32_t read_mmreg32(uint32_t reg) __attribute__((always_inline));
 static __inline void write_mmreg32(uint32_t reg, uint32_t val) __attribute__((always_inline));
 static __inline void wbinvd(void) __attribute__((always_inline));
+static __inline void __cpu_relax(void) __attribute__((always_inline));
 
 static __inline uint8_t
 inb(int port)
@@ -310,9 +311,19 @@ read_mmreg32(uint32_t reg)
 }
 
 static __inline void
-wbinvd(void) __attribute__((always_inline))
+wbinvd(void)
 {
        asm volatile("wbinvd");
 }
 
+/* this version of cpu_relax is needed to resolve some circular dependencies
+ * with arch/arch.h and arch/apic.h */
+static __inline void
+__cpu_relax(void)
+{
+       // in case the compiler doesn't serialize for pause, the "m" will make sure
+       // no memory is reordered around this instruction.
+       asm volatile("pause" : : : "memory");
+}
+
 #endif /* !ROS_INC_X86_H */
index 61f0258..ea397fc 100644 (file)
@@ -1,7 +1,7 @@
 #include <multiboot.h>
 #include <arch/mmu.h>
 #include <arch/arch.h>
-#include <arch/types.h>
+#include <ros/common.h>
 #include <ros/memlayout.h>
 #include <string.h>
 
index 856f146..c12e8fc 100644 (file)
@@ -6,7 +6,7 @@
 # error "This is a ROS kernel header; user programs should not #include it"
 #endif
 
-#include <arch/types.h>
+#include <ros/common.h>
 
 #define CRT_ROWS       25
 #define CRT_COLS       80
index fbabfab..36d5d4b 100644 (file)
@@ -1,7 +1,7 @@
 #ifndef ROS_ARCH_FRONTEND_H
 #define ROS_ARCH_FRONTEND_H
 
-#include <arch/types.h>
+#include <ros/common.h>
 
 int32_t frontend_syscall(int32_t syscall_num, uint32_t arg0, uint32_t arg1, uint32_t arg2);
 
index fc07ba7..b71f0de 100644 (file)
@@ -1,7 +1,7 @@
 #ifndef ROS_ARCH_SMP_H
 #define ROS_ARCH_SMP_H
 
-#include <arch/types.h>
+#include <ros/common.h>
 #include <arch/arch.h>
 #include <atomic.h>
 
index 7ceb7d9..0e53aa2 100644 (file)
@@ -22,7 +22,7 @@
 #define STR(arg) #arg
 #define XSTR(arg) STR(arg)
 
-#include <arch/types.h>
+#include <ros/common.h>
 #include <trap.h>
 #include <arch/frontend.h>
 
index f170dd6..f3d5725 100644 (file)
@@ -1,5 +1,5 @@
 #include <arch/timer.h>
-#include <arch/types.h>
+#include <ros/common.h>
 #include <arch/trap.h>
 #include <arch/arch.h>
 #include <stdio.h>
index 2e1a221..37264b4 100644 (file)
@@ -3,7 +3,7 @@
 
 #define INTERRUPT_TIMER_HZ     100
 
-#include <arch/types.h>
+#include <ros/common.h>
 
 typedef struct system_timing {
        uint64_t tsc_freq;
index b6ae9c0..ab57870 100644 (file)
@@ -6,7 +6,7 @@
 
 #ifndef __ASSEMBLER__
 
-#include <arch/types.h>
+#include <ros/common.h>
 
 typedef struct
 {
index d87d3ed..c284fc9 100644 (file)
@@ -1,7 +1,7 @@
 #ifndef ROS_KERN_ATOMIC_H
 #define ROS_KERN_ATOMIC_H
 
-#include <arch/types.h>
+#include <ros/common.h>
 #include <arch/mmu.h>
 #include <arch/atomic.h>
 #include <arch/arch.h>
@@ -15,13 +15,15 @@ static inline void
 typedef struct checklist_mask {
        // only need an uint8_t, but we need the bits[] to be word aligned
        uint32_t size;
-       volatile uint8_t (COUNT(BYTES_FOR_BITMASK(size)) bits)[];
+       volatile uint8_t (COUNT(BYTES_FOR_BITMASK(size)) bits)[MAX_NUM_CPUS];
 } checklist_mask_t;
 
 // mask contains an unspecified array, so it needs to be at the bottom
 typedef struct checklist {
        volatile uint32_t lock;
        checklist_mask_t mask;
+       // eagle-eyed readers may know why this might have been needed. 2009-09-04
+       //volatile uint8_t (COUNT(BYTES_FOR_BITMASK(size)) bits)[];
 } checklist_t;
 
 #define ZEROS_ARRAY(size) {[0 ... ((size)-1)] 0}
index d66d9e4..691336a 100644 (file)
@@ -8,7 +8,7 @@
 #ifndef ROS_KERN_COLORED_CACHES_H
 #define ROS_KERN_COLORED_CACHES_H
 
-#include <arch/types.h>
+#include <ros/common.h>
 
 /****************** Cache Structures ********************/
 typedef struct Cache {
index 21919ee..d2ac247 100644 (file)
@@ -1,7 +1,7 @@
 #ifndef ROS_INC_ELF_H
 #define ROS_INC_ELF_H
 
-#include <arch/types.h>
+#include <ros/common.h>
 
 #if defined(LITTLE_ENDIAN)
 #  define ELF_MAGIC 0x464C457FU        /* "\x7FELF" in little endian */
index 2cd6147..1180680 100644 (file)
@@ -10,7 +10,7 @@
 #include <ros/error.h>
 #include <ros/procdata.h>
 #include <arch/trap.h>
-#include <arch/types.h>
+#include <ros/common.h>
 #include <arch/arch.h>
 #include <sys/queue.h>
 
@@ -40,7 +40,9 @@ typedef int32_t envid_t;
 #define ENVX(envid)            ((envid) & (NENV - 1))
 
 // TODO: clean this up.
+#ifdef __SHARC__
 typedef sharC_env_t;
+#endif
 struct Env {
        TAILQ_ENTRY(Env) proc_link NOINIT;      // Free list link pointers
        spinlock_t proc_lock;
@@ -69,6 +71,7 @@ struct Env {
        // Address space
        pde_t *COUNT(NPDENTRIES) env_pgdir;                     // Kernel virtual address of page dir
        physaddr_t env_cr3;                     // Physical address of page dir
+//     struct memregion_list memregions;
 
        // Per process info and data pages
        procinfo_t *SAFE env_procinfo;       // KVA of per-process shared info table (RO)
@@ -111,6 +114,6 @@ void        env_pop_tf(trapframe_t *tf) __attribute__((noreturn));
 
 
 /* Helper handler for smp_call to dispatch jobs to other cores */
-void run_env_handler(trapframe_t *tf, env_t* data);
+void run_env_handler(trapframe_t *tf, TV(t) data);
 
 #endif // !ROS_KERN_ENV_H
index 9fbf3fd..4127814 100644 (file)
@@ -1,7 +1,7 @@
 #ifndef ROS_KERN_KDEBUG_H
 #define ROS_KERN_KDEBUG_H
 
-#include <arch/types.h>
+#include <ros/common.h>
 
 // Debug information about a particular instruction pointer
 typedef struct Eipdebuginfo {
index 134d96f..b6d76e6 100644 (file)
 #ifndef ROS_KERN_KFS_H
 #define ROS_KERN_KFS_H
 
-#include <arch/types.h>
+#include <ros/common.h>
 #include <process.h>
 
-// zra : putting nodeputy in header files makes life difficult.
-//#pragma nodeputy
-
 struct kfs_entry {
        char (NT name)[256];
        uint8_t *COUNT(size) start;
index 33df609..90b3edd 100644 (file)
@@ -8,7 +8,7 @@
 #ifndef ROS_KERN_KMALLOC_H
 #define ROS_KERN_KMALLOC_H
 
-#include <arch/types.h>
+#include <ros/common.h>
 
 void  kmalloc_init();
 
index ece51ea..3056e21 100644 (file)
@@ -8,7 +8,7 @@
 #ifndef ROS_LISTABLE_H
 #define ROS_LISTABLE_H
  
-#include <arch/types.h>
+#include <ros/common.h>
 #include <sys/queue.h>
 
 #define DECLARE_LISTABLE_ITEM(name, link, item)   \
index b34a5b4..ac57d17 100644 (file)
@@ -3,7 +3,7 @@
 
 #ifndef __ASSEMBLER__
 
-#include <arch/types.h>
+#include <ros/common.h>
 
 extern physaddr_t maxpa;        // Maximum physical address in the system
 extern physaddr_t maxaddrpa;    // Maximum addressable physical address
index b5fae68..3a57d39 100644 (file)
@@ -2,11 +2,9 @@
 
 #ifndef ROS_KERN_PMAP_H
 #define ROS_KERN_PMAP_H
-#ifndef ROS_KERNEL
-# error "This is a ROS kernel header; user programs should not #include it"
-#endif
 
 #include <ros/memlayout.h>
+#include <ros/mman.h>
 #include <sys/queue.h>
 #include <multiboot.h>
 #include <atomic.h>
@@ -41,7 +39,7 @@
 
 extern char (SNT bootstacktop)[], (SNT bootstack)[];
 
-// List of pysical pages
+// List of physical pages
 extern volatile uint32_t pages_lock;
 extern page_t SLOCKED(&pages_lock) * SREADONLY COUNT(npages) pages;
 
@@ -82,8 +80,10 @@ error_t
 memcpy_from_user(env_t* env, void* COUNT(len) dest,
                  const void *DANGEROUS va, size_t len);
                  
+/* Arch specific implementations for these */
 pte_t *pgdir_walk(pde_t *COUNT(NPDENTRIES) pgdir, const void *SNT va, int create);
-int get_va_perms(pde_t *pgdir, const void *SNT va);
+int get_va_perms(pde_t *COUNT(NPDENTRIES) pgdir, const void *SNT va);
+void *get_free_va_range(pde_t *pgdir, uintptr_t addr, size_t len);
 
 static inline page_t *SAFE ppn2page(size_t ppn)
 {
@@ -124,4 +124,23 @@ static inline page_t* kva2page(void* addr)
        return pa2page(PADDR(addr));
 }
 
+/*
+ * Memory management for processes: syscall related functions, virtual memory
+ * regions, etc.
+ */
+void *mmap(struct proc *p, uintptr_t addr, size_t len, int prot, int flags, int fd, size_t offset);
+
+/* Memory region for a process, consisting of linear(virtual) addresses.  This
+ * is what the kernel allocates a process, and the physical mapping can be done
+ * lazily (or not).  This way, if a page is swapped out, and the PTE says it
+ * isn't present, we still have a way to account for how the whole region ought
+ * to be dealt with. */
+struct memregion {
+       LIST_ENTRY(memregion) link; // actually, i'd like a sorted tree of these
+       uintptr_t base;
+       size_t len;
+       int perm;
+};
+TAILQ_HEAD(memregion_list, memregion); // Declares 'struct memregion_list'
+
 #endif /* !ROS_KERN_PMAP_H */
index 28df555..bdf7738 100644 (file)
@@ -10,7 +10,7 @@
 #ifndef ROS_KERN_PROCESS_H
 #define ROS_KERN_PROCESS_H
 
-#include <arch/types.h>
+#include <ros/common.h>
 #include <trap.h>
 #include <atomic.h>
 
index 1aa2486..331a14f 100644 (file)
@@ -1,7 +1,150 @@
 #ifndef ROS_COMMON_H
 #define ROS_COMMON_H
 
+#ifndef __IVY__
+#include <ros/noivy.h>
+#endif
+
+#include <stddef.h>
+#include <stdint.h>
+#include <sys/types.h>
+
+typedef uintptr_t physaddr_t;
+typedef ssize_t intreg_t;
+typedef size_t uintreg_t;
+typedef int bool;
+
+#ifndef NULL
+#define NULL ((void*) 0)
+#endif
+
+#ifndef TRUE
+#define TRUE   1
+#endif
+
+#ifndef FALSE
+#define FALSE  0
+#endif
+
+#define CHECK_FLAG(flags,bit)   ((flags) & (1 << (bit)))
+
 #define FOR_CIRC_BUFFER(next, size, var) \
        for (int _var = 0, var = (next); _var < (size); _var++, var = (var + 1) % (size))
 
+// Efficient min and max operations
+#define MIN(_a, _b)                                            \
+({                                                             \
+       typeof(_a) __a = (_a);                                  \
+       typeof(_b) __b = (_b);                                  \
+       __a <= __b ? __a : __b;                                 \
+})
+#define MAX(_a, _b)                                            \
+({                                                             \
+       typeof(_a) __a = (_a);                                  \
+       typeof(_b) __b = (_b);                                  \
+       __a >= __b ? __a : __b;                                 \
+})
+
+// Rounding operations (efficient when n is a power of 2)
+// Round down to the nearest multiple of n
+#define ROUNDDOWN(a, n)                                                \
+({                                                             \
+       uint32_t __a = (uint32_t) (a);                          \
+       (typeof(a)) (__a - __a % (n));                          \
+})
+// Round up to the nearest multiple of n
+#define ROUNDUP(a, n)                                          \
+({                                                             \
+       uint32_t __n = (uint32_t) (n);                          \
+       (typeof(a)) (ROUNDDOWN((uint32_t) (a) + __n - 1, __n)); \
+})
+
+// Round down to the nearest multiple of n
+#define PTRROUNDDOWN(a, n)                                             \
+({                                                             \
+       char * __a = (char *) (a);                              \
+       (typeof(a)) (__a - (uint32_t)__a % (n));                                \
+})
+// Round pointer up to the nearest multiple of n
+#define PTRROUNDUP(a, n)                                               \
+({                                                             \
+       uint32_t __n = (uint32_t) (n);                          \
+       (typeof(a)) (PTRROUNDDOWN((char *) (a) + __n - 1, __n));        \
+})
+
+// Return the integer logarithm of the value provided rounded up
+static inline uint32_t LOG2(uint32_t value)
+{
+    uint32_t l = 0;
+    while( (value >> l) > 1 ) ++l;
+    return l;
+}
+
+// Return the offset of 'member' relative to the beginning of a struct type
+#ifndef offsetof
+#define offsetof(type, member)  ((size_t) (&((type*)0)->member))
+#endif
+
+// Ivy currently can only handle 63 bits (OCaml thing), so use this to make
+// a uint64_t programatically
+#define UINT64(upper, lower) ( (((uint64_t)(upper)) << 32) | (lower) )
+
+
+/*********************** Bitmask stuff **********************/
+#define BYTES_FOR_BITMASK(size) (((size) - 1) / 8 + 1)
+#define BYTES_FOR_BITMASK_WITH_CHECK(size) ((size) ? ((size) - (1)) / (8) + (1) : (0))
+#define DECL_BITMASK(name, size) uint8_t (name)[BYTES_FOR_BITMASK((size))]
+
+#define GET_BITMASK_BIT(name, bit) (((name)[(bit)/8] & (1 << ((bit) % 8))) ? 1 : 0)
+#define SET_BITMASK_BIT(name, bit) ((name)[(bit)/8] |= (1 << ((bit) % 8)))
+#define CLR_BITMASK_BIT(name, bit) ((name)[(bit)/8] &= ~(1 << ((bit) % 8)))
+#define SET_BITMASK_BIT_ATOMIC(name, bit) (atomic_orb(&(name)[(bit)/8], (1 << ((bit) % 8))))
+#define CLR_BITMASK_BIT_ATOMIC(name, bit) (atomic_andb(&(name)[(bit)/8], ~(1 << ((bit) % 8))))
+
+#define CLR_BITMASK(name, size) \
+({ \
+       {TRUSTEDBLOCK \
+       memset((void*)((uintptr_t)(name)), 0, BYTES_FOR_BITMASK((size))); \
+       } \
+})
+
+#define FILL_BITMASK(name, size) \
+({ \
+       {TRUSTEDBLOCK \
+       memset((void*)((uintptr_t)(name)), 255, BYTES_FOR_BITMASK((size))); \
+       } \
+       (name)[BYTES_FOR_BITMASK((size))-1] >>= (((size) % 8) ? (8 - ((size) % 8)) : 0 ); \
+}) 
+
+#define COPY_BITMASK(newmask, oldmask, size) \
+({ \
+       {TRUSTEDBLOCK \
+       memcpy((void*)((uintptr_t)(newmask)), \
+           (void*)((uintptr_t)(oldmask)), \
+           BYTES_FOR_BITMASK((size))); \
+       } \
+})
+
+// this checks the entire last byte, so keep it 0 in the other macros
+#define BITMASK_IS_CLEAR(name, size) ({ \
+       uint32_t __n = BYTES_FOR_BITMASK((size)); \
+       bool clear = 1; \
+       while (__n-- > 0) { \
+               if ((name)[__n]) { \
+                       clear = 0; \
+                       break;\
+               }\
+       } \
+       clear; })
+
+#define PRINT_BITMASK(name, size) { \
+       int i;  \
+       for (i = 0; i < BYTES_FOR_BITMASK(size); i++) { \
+               int j;  \
+               for (j = 0; j < 8; j++) \
+                       printk("%x", ((name)[i] >> j) & 1);     \
+       } \
+       printk("\n"); \
+}
+/**************************************************************/
 #endif /* ROS_COMMON_H */
index 6885ed8..4d3b894 100644 (file)
@@ -3,8 +3,12 @@
 #ifndef ROS_INC_ERROR_H
 #define ROS_INC_ERROR_H
 
+#include <ros/common.h>
+
 #define DECLARE_ERROR_CODE(e, s)
 
+// define this to prevent conflicts with newlib's errno.h
+#define __error_t_defined
 typedef enum {
        ESUCCESS = 0,            // Success
        EFAIL,                   // Generic Failure
index 38c521e..f19154b 100644 (file)
@@ -2,7 +2,7 @@
 #define ROS_INC_MEMLAYOUT_H
 
 #ifndef __ASSEMBLER__
-#include <arch/types.h>
+#include <ros/common.h>
 #include <arch/mmu.h>
 #endif /* not __ASSEMBLER__ */
 
@@ -31,7 +31,7 @@
  *                     |         Kernel Stack         | RW/--  KSTKSIZE   |
  *                     | - - - - - - - - - - - - - - -|                 PTSIZE
  *                     |      Invalid Memory (*)      | --/--             |
- *    ULIM      ----> +------------------------------+ 0xbf800000      --+
+ *    ULIM      ---->  +------------------------------+ 0xbf800000      --+
  *                     |  Cur. Page Table (User R-)   | R-/R-  PTSIZE
  *    UVPT      ---->  +------------------------------+ 0xbf400000      --+
  *                     | Unmapped (expandable region) |                   |
 typedef uint32_t pte_t;
 typedef uint32_t pde_t;
 
+#ifdef __IVY__
 #pragma cilnoremove("vpt_lock", "vpd_lock")
+#endif
 extern volatile uint32_t vpt_lock;
 extern volatile uint32_t vpd_lock;
 
diff --git a/kern/include/ros/mman.h b/kern/include/ros/mman.h
new file mode 100644 (file)
index 0000000..4bc9130
--- /dev/null
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2009 The Regents of the University of California
+ * Barret Rhoden <brho@cs.berkeley.edu>
+ * See LICENSE for details.
+ *
+ * Memory management flags, currently used in mmap()
+ */
+
+#ifndef ROS_INCLUDE_MMAN_H
+#define ROS_INCLUDE_MMAN_H
+
+/* Memory protection states (what you're allowed to do */
+#define PROT_NONE              0x1
+#define PROT_EXEC              0x2
+#define PROT_READ              0x4
+#define PROT_WRITE             0x8
+
+/* mmap flags, only anonymous is supported now, feel free to pass others */
+#define MAP_SHARED             0x001
+#define MAP_PRIVATE            0x002
+#define MAP_ANONYMOUS  0x004
+#define MAP_FIXED              0x008
+#define MAP_GROWSDOWN  0x010
+#define MAP_STACK              0x020
+#define MAP_POPULATE   0x040
+#define MAP_NONBLOCK   0x080
+#define MAP_NORESERVE  0x100
+
+/* Other mmap flags, which we probably won't support
+#define MAP_32BIT
+#define MAP_LOCKED
+*/
+
+#endif /* !ROS_INCLUDE_MMAN_H */
diff --git a/kern/include/ros/noivy.h b/kern/include/ros/noivy.h
new file mode 100644 (file)
index 0000000..0d09e8d
--- /dev/null
@@ -0,0 +1,157 @@
+#ifndef NOIVY_H
+#define NOIVY_H
+
+#define BOUND(lo, hi)   
+#define COUNT(n)        
+#define SIZE(n)         
+#define SAFE            
+#define SNT             
+#define DANGEROUS       
+
+/* Begin Experimental attributes */
+#define META(p)            
+#define HANDLER_ATOMIC              
+#define LOCK_HANDLER_ATOMIC(...)   
+#define IN_HANDLER_ATOMIC  
+#define IN_HANDLER         
+#define ASYNC              
+#define NORACE             
+#define SYNCHRONOUS        
+#define REGION(r)          
+#define NOREGION           
+#define SOMEREGION         
+#define SAMEREGION         
+#define DELETES_REGION(r)  
+#define GROUP(g)           
+#define NOGROUP            
+#define SOMEGROUP          
+#define SAMEGROUP          
+#define UNIQUE             
+#define NOALIAS            
+#define PAIRED_WITH(c)     
+#define PAIRED(c1,c2)      
+#define ARGPAIRED(c1,c2,arg) 
+#define FNPTRCALLER(fn)    
+#define INITSTRUCT(s)      
+#define NOINIT             
+#define WRITES(...)        
+#define RPROTECT           
+#define WPROTECT           
+#define RWPROTECT          
+#define R_PERMITTED(...) 
+#define W_PERMITTED(...) 
+#define RW_PERMITTED(...) 
+/* End Experimental attributes */
+
+#define BND(lo, hi)     
+#define CT(n)           
+#define SZ(n)           
+
+#define EFAT            
+#define FAT             
+
+#define NULLTERM        
+#define NT              
+#define NTS             
+#define NTC(n)          
+
+#define NTDROPATTR      
+#define NTEXPANDATTR    
+
+#define NULLABLE
+#define OPT             
+#define NONNULL         
+
+#define TRUSTED         
+#define TRUSTEDBLOCK    
+
+#define POLY           
+
+#define COPYTYPE        
+
+//specifies that Deputy's typechecker (but not optimizer) should assume
+//that this lvalue is constant. (unsound)
+#define ASSUMECONST     
+
+#define WHEN(e)         
+
+#define DMEMCPY(x, y, z) 
+#define DMEMSET(x, y, z) 
+#define DMEMCMP(x, y, z)
+
+#define DALLOC(x)       
+#define DREALLOC(x, y)  
+#define DFREE(x)        
+
+#define DVARARG(x)      
+#define DPRINTF(x)      
+
+#define NTDROP(x)       (x)
+#define NTEXPAND(x)     (x)
+#define TC(x)           (x)
+
+#define TVATTR(x)       
+#define TPATTR(x)       
+
+#define TV(x)           void *
+#define TP(x)           
+
+/* Sharc Stuff */
+
+#define SINTHREAD
+#define SFNPTR
+#define SHASDEF
+#define SPURE
+#define STCREATE(fn,arg)
+#define SBARRIER(n)
+#define SBARRIERFN
+
+#define SLOCK(x)
+#define SUNLOCK(x)
+#define SLOCKED(l)
+#define SSOMELOCK
+#define SREADONLY
+#define SRACY
+#define SREADS(n)
+#define SWRITES(n)
+#define SREADSNT
+#define SWRITESNT
+#define SCTX
+#define SPRIVATE
+#define SDYNAMIC
+#define SINDYNAMIC
+#define SOUTDYNAMIC
+#define SDYNBAR(b)
+
+#define BASE(p)
+
+#define SGROUP(g)
+#define SNOGROUP
+#define SRETGROUP
+#define SARGGROUP
+
+#define SSAME
+
+#define SUNIQUE
+#define SNOALIAS
+
+#define SMAYCAST
+#define SINMAYCAST
+#define SOUTMAYCAST
+#define SCONDMCRET
+
+#define TRUSTEDBLOCK
+
+#define SCAST(x) (x)
+#define SINIT(x) (x)
+#define SINIT_DOUBLE(x) (x)
+#define SINIT_FLOAT(x) (x)
+
+#define hs_nofree
+
+#define DALLOC(x)
+#define DFREE(x)
+
+
+#endif // NOIVY_H
+
index f5ece87..ee7e22f 100644 (file)
@@ -7,8 +7,7 @@
 #include <ros/syscall.h>
 #include <ros/sysevent.h>
 #include <ros/error.h>
-
-typedef int32_t pid_t;
+#include <ros/common.h>
 
 typedef struct procinfo {
        pid_t id;
index aa0d389..6c01406 100644 (file)
@@ -175,7 +175,8 @@ typedef struct __name##_back_ring __name##_back_ring_t;                 \
 /* This is a dummy function just used to statically assert that         \
  * there are no weird padding issues associated with our sring structs  \
  */                                                                     \
-static void __name##_assert_sring_size() __attribute__((used)) {        \
+static void __name##_assert_sring_size() __attribute__((used));         \
+static void __name##_assert_sring_size() {                              \
        __ASSERT_EQUAL( sizeof(__name##_sring_t),                           \
                        ( __RING_HEADER_SIZE()  +                           \
                          ( __RING_SIZE_STATIC(__name, __size) *            \
index 72b30e3..fdec8ab 100644 (file)
@@ -1,7 +1,7 @@
 #ifndef ROS_INCLUDE_SYSCALL_H
 #define ROS_INCLUDE_SYSCALL_H
 
-#include <arch/types.h>
+#include <ros/common.h>
 #include <ros/ring_buffer.h>
 
 /* system call numbers */
@@ -15,8 +15,6 @@ enum
        SYS_cputs,
        SYS_cgetc,
        SYS_getcpuid,
-       SYS_serial_write,
-       SYS_serial_read,
        SYS_getpid,
        SYS_proc_destroy,
        SYS_shared_page_alloc,
@@ -24,6 +22,20 @@ enum
        SYS_yield,
        SYS_proc_create,
        SYS_proc_run,
+
+       SYS_mmap,
+       SYS_brk,
+       /*
+       SYS_mprotect,
+       SYS_mremap,
+       SYS_mincore, // can read page tables instead
+       SYS_madvise,
+       SYS_mlock,
+       SYS_msync,
+       */
+
+       SYS_serial_write,
+       SYS_serial_read,
        SYS_frontend,           // forward a syscall to front-end machine
 
        SYS_endofcalls //Should always be last
@@ -52,6 +64,7 @@ typedef struct syscall_rsp {
 
 // Generic Syscall Ring Buffer
 #define SYSCALLRINGSIZE    PGSIZE
-DEFINE_RING_TYPES_WITH_SIZE(syscall, syscall_req_t, syscall_rsp_t, SYSCALLRINGSIZE);
+//DEFINE_RING_TYPES_WITH_SIZE(syscall, syscall_req_t, syscall_rsp_t, SYSCALLRINGSIZE);
+DEFINE_RING_TYPES(syscall, syscall_req_t, syscall_rsp_t);
 
 #endif /* !ROS_INCLUDE_SYSCALL_H */
index 1596d20..36be0bb 100644 (file)
@@ -10,7 +10,7 @@
 /* SMP related functions */
 
 #include <arch/smp.h>
-#include <arch/types.h>
+#include <ros/common.h>
 #include <trap.h>
 #include <atomic.h>
 #include <process.h>
@@ -21,7 +21,7 @@
 struct per_cpu_info {
        spinlock_t lock;
        bool preempt_pending;
-       struct workqueue workqueue;
+       struct workqueue TP(void*) workqueue;
 #ifdef __i386__
        spinlock_t amsg_lock;
        unsigned amsg_current;
index 9363d1f..eed75ba 100644 (file)
@@ -1,6 +1,6 @@
 #ifndef ROS_STAB_H
 #define ROS_STAB_H
-#include <arch/types.h>
+#include <ros/common.h>
 
 // <inc/stab.h>
 // STABS debugging info
diff --git a/kern/include/stdint.h b/kern/include/stdint.h
new file mode 100644 (file)
index 0000000..44fd3db
--- /dev/null
@@ -0,0 +1,5 @@
+/* GHETTO: To our grandchildren, we are sorry for this
+ * We do this since newlib has it's own stdint that conflicts with the kernel
+ * and roslib's types. */
+
+#include <arch/types.h>
index dd42c41..265cf1f 100644 (file)
@@ -1,7 +1,7 @@
 #ifndef ROS_INC_STRING_H
 #define ROS_INC_STRING_H
 
-#include <arch/types.h>
+#include <ros/common.h>
 
 #define STRING char *NTS
 #define STRBUF(n) char *NT COUNT(n)
index 3dfa6ca..fd2c60f 100644 (file)
@@ -40,7 +40,7 @@
 #define ROS_INCLUDE_SYS_QUEUE_H
 
 //#include <machine/ansi.h>    /* for __offsetof */
-#include <arch/types.h>        /* for __offsetof */
+#include <ros/common.h>        /* for __offsetof */
 
 /*
  * This file defines four types of data structures: singly-linked lists,
diff --git a/kern/include/sys/types.h b/kern/include/sys/types.h
new file mode 100644 (file)
index 0000000..44fd3db
--- /dev/null
@@ -0,0 +1,5 @@
+/* GHETTO: To our grandchildren, we are sorry for this
+ * We do this since newlib has it's own stdint that conflicts with the kernel
+ * and roslib's types. */
+
+#include <arch/types.h>
index 17dc62d..65f865b 100644 (file)
@@ -7,8 +7,8 @@
 #include <ros/syscall.h>
 #include <process.h>
 
-int32_t (syscall)(env_t* e, uint32_t num, uint32_t a1, uint32_t a2,
-                              uint32_t a3, uint32_t a4, uint32_t a5);
-int32_t syscall_async(env_t* e, syscall_req_t *syscall);
-int32_t process_generic_syscalls(env_t* e, uint32_t max);
+intreg_t (syscall)(env_t* e, uintreg_t num, uintreg_t a1, uintreg_t a2,
+                   uintreg_t a3, uintreg_t a4, uintreg_t a5);
+intreg_t syscall_async(env_t* e, syscall_req_t *syscall);
+intreg_t process_generic_syscalls(env_t* e, uint32_t max);
 #endif /* !ROS_KERN_SYSCALL_H */
index 6d97c16..c058af1 100644 (file)
@@ -6,7 +6,7 @@
  * Someone else should actually make these useful on their own
  */
 
-#include <arch/types.h>
+#include <ros/common.h>
 
 void test_ipi_sending(void);
 void test_pic_reception(void);
index eaa6c63..0edd068 100644 (file)
@@ -1,7 +1,7 @@
 #ifndef ROS_INC_TIMING_H
 #define ROS_INC_TIMING_H
 
-#include <arch/types.h>
+#include <ros/common.h>
 
 void udelay(uint64_t usec);
 
diff --git a/kern/include/types.h b/kern/include/types.h
new file mode 100644 (file)
index 0000000..fb343eb
--- /dev/null
@@ -0,0 +1 @@
+#include <
index 27ce98e..c5c5fd2 100644 (file)
@@ -12,7 +12,7 @@
 #define ROS_KERN_WORKQUEUE_H
 
 #include <sys/queue.h>
-#include <arch/types.h>
+#include <ros/common.h>
 #include <env.h>
 
 typedef void (*func_t)(TV(t) data);
@@ -25,11 +25,11 @@ struct work {
 // TODO make these dynamic and hold more than 1.  might want better list macros.
 #define WORKQUEUE_ELEMENTS 1
 struct workqueue {
-       struct work TP(env_t *) statics[WORKQUEUE_ELEMENTS];
+       struct work TP(TV(t)) statics[WORKQUEUE_ELEMENTS];
 };
 
 void process_workqueue(void);
 // For now, the caller should free their struct work after this call
-int enqueue_work(struct workqueue *queue, struct work TP(env_t *) *job);
+int enqueue_work(struct workqueue *queue, struct work *job);
 
 #endif /* ROS_KERN_WORKQUEUE_H */
index aaee01f..46451d2 100644 (file)
@@ -1,7 +1,11 @@
 KERN_IVY_DIR = $(KERN_DIR)/ivy\r
 OBJDIRS += $(KERN_IVY_DIR)\r
 \r
-KERN_IVY_CFLAGS   := $(KERN_CFLAGS) --nodeputy --nosharc\r
+KERN_IVY_CFLAGS   := $(KERN_CFLAGS)\r
+ifeq ($(COMPILER),IVY)\r
+KERN_IVY_CFLAGS   += --nodeputy --nosharc\r
+endif\r
+\r
 KERN_IVY_SRCFILES := $(KERN_IVY_DIR)/deputy.c $(KERN_IVY_DIR)/sharc.c\r
 KERN_IVY_OBJFILES := $(patsubst $(KERN_IVY_DIR)/%.c, \\r
                                    $(OBJDIR)/$(KERN_IVY_DIR)/%.o, \\r
index 87c568c..6f09777 100644 (file)
@@ -1,3 +1,4 @@
+#ifdef __IVY__
 #include <stdio.h>
 #include <assert.h>
 #include <string.h>
@@ -110,3 +111,4 @@ void *__deputy_memset(void *s, int c, unsigned int n) {
   return memset(s, c, n);
 }
 
+#endif // __IVY__
index 17f09a0..4f707ef 100644 (file)
@@ -1,3 +1,4 @@
+#ifdef __IVY__
 #include <assert.h>
 
 int __ivy_checking_on = 1;
@@ -23,3 +24,5 @@ void __sharc_lock_coerce_error(void *dstlck, void *srclck, char *msg)
        warn("Ivy: The locks in the coercion at %s must be the same\n", msg);
        __ivy_checking_on = old;
 }
+
+#endif // __IVY__
index 47c44ac..a88b7ba 100644 (file)
@@ -37,7 +37,7 @@ int commit_checklist_wait(checklist_t* list, checklist_mask_t* mask)
 int commit_checklist_nowait(checklist_t* list, checklist_mask_t* mask)
 {
        int e = 0;
-       if (e = commit_checklist_wait(list, mask))
+       if ((e = commit_checklist_wait(list, mask)))
                return e;
        // give up the lock, since we won't wait for completion
        spin_unlock_irqsave(&list->lock);
index 307c30d..5eb1161 100644 (file)
@@ -9,7 +9,7 @@
 #pragma nosharc
 #endif
 
-#include <arch/types.h>
+#include <ros/common.h>
 #include <arch/mmu.h>
 #include <colored_caches.h>
 #include <stdio.h>
index 4ad9677..87a0056 100644 (file)
@@ -4,6 +4,10 @@
 #pragma nosharc
 #endif
 
+#ifdef __IVY__
+#pragma nodeputy
+#endif
+
 #include <arch/arch.h>
 #include <arch/mmu.h>
 #include <elf.h>
@@ -493,15 +497,14 @@ type SLOCKED(name##_lock) *\
  *
  * Note this is rather old, and meant to run a RUNNABLE_S on a worker core.
  */
-void run_env_handler(trapframe_t *tf, env_t *data)
+void run_env_handler(trapframe_t *tf, TV(t) data)
 {
        assert(data);
-       struct work TP(env_t *) job;
-       struct workqueue *workqueue = &per_cpu_info[core_id()].workqueue;
-       {
-       job.func = proc_run;
+       struct work TP(TV(t)) job;
+       struct workqueue TP(void*) *workqueue = &per_cpu_info[core_id()].workqueue;
+       // this doesn't work, and making it a TP(env_t) is wrong
+       job.func = (func_t)proc_run;
        job.data = data;
-       }
        if (enqueue_work(workqueue, &job))
                panic("Failed to enqueue work!");
 }
index 8ef1c4a..7e19a90 100644 (file)
@@ -64,7 +64,7 @@ ssize_t kfs_lookup_path(char* path)
  * This should take a real inode or something to point to the real location,
  * and env_create shouldn't assume everything is contiguous
  */
-struct proc *kfs_proc_create(size_t kfs_inode)
+struct proc *kfs_proc_create(int kfs_inode)
 {
        if (kfs_inode < 0 || kfs_inode >= MAX_KFS_FILES)
                panic("Invalid kfs_inode.  Check you error codes!");
index 859a8f3..51d81ce 100644 (file)
@@ -9,7 +9,7 @@
 #pragma nosharc
 #endif
 
-#include <arch/types.h>
+#include <ros/common.h>
 #include <ros/error.h>
 #include <pmap.h>
 #include <kmalloc.h>
index 2e9bcde..23d9199 100644 (file)
@@ -8,7 +8,11 @@
 #pragma nosharc
 #endif
 
-#include <arch/types.h>
+#ifdef __IVY__
+#pragma nodeputy
+#endif
+
+#include <ros/common.h>
 #include <smp.h>
 
 #include <assert.h>
index 7556b63..dfe8add 100644 (file)
@@ -179,8 +179,6 @@ int mon_setmapperm(int argc, char **argv, trapframe_t *tf)
 
 int mon_cpuinfo(int argc, char **argv, trapframe_t *tf)
 {
-       extern uint8_t num_cpus;
-
        cprintf("Number of CPUs detected: %d\n", num_cpus);
        cprintf("Calling CPU's ID: 0x%08x\n", core_id());
 
index ece4831..65a2034 100644 (file)
@@ -3,7 +3,7 @@
 #endif
 
 #include <multiboot.h>
-#include <arch/types.h>
+#include <ros/common.h>
 #include <arch/mmu.h>
 #include <arch/arch.h>
 #include <ros/memlayout.h>
index ec712b5..871774e 100644 (file)
@@ -426,3 +426,15 @@ error_t memcpy_from_user(env_t* env, void* COUNT(len) dest,
        return ESUCCESS;
 }
 
+/* mmap2() semantics on the offset */
+void *mmap(struct proc *p, uintptr_t addr, size_t len, int prot, int flags, int fd,
+           size_t offset)
+{
+       if (fd || offset) {
+               printk("[kernel] mmap() does not support files yet.\n");
+               return (void*SAFE)TC(-1);
+       }
+       void *tmp = get_free_va_range(p->env_pgdir, addr, len);
+       printk("tmp = 0x%08x\n", tmp);
+       return 0;
+}
index df4677f..2cf6ed2 100644 (file)
@@ -6,7 +6,7 @@
 #endif
 
 #include <arch/arch.h>
-#include <arch/types.h>
+#include <ros/common.h>
 
 #include <atomic.h>
 #include <stdio.h>
@@ -52,7 +52,11 @@ int vcprintf(const char *fmt, va_list ap)
        spin_lock_irqsave(&output_lock);
 
        // do the buffered printf
+       #ifdef __DEPUTY__
        vprintfmt(buffered_putch, &cntp, fmt, ap);
+       #else
+       vprintfmt((void*)buffered_putch, (void**)&cntp, fmt, ap);
+       #endif
 
        // write out remaining chars in the buffer
        buffered_putch(-1,&cntp);
index e25df34..ea18876 100644 (file)
@@ -6,7 +6,7 @@
 #pragma nosharc
 #endif
 
-#include <arch/types.h>
+#include <ros/common.h>
 #include <ros/error.h>
 #include <stdio.h>
 #include <string.h>
@@ -283,7 +283,11 @@ int vsnprintf(char *buf, int n, const char *fmt, va_list ap)
        b.buf = buf;
 
        // print the string to the buffer
-       vprintfmt(sprintputch, (sprintbuf_t *NONNULL*NONNULL)&bp, fmt, ap);
+       #ifdef __DEPUTY__
+       vprintfmt((void*)sprintputch, (sprintbuf_t *NONNULL*NONNULL)&bp, fmt, ap);
+       #else
+       vprintfmt((void*)sprintputch, (void**)&bp, fmt, ap);
+       #endif
 
        // null terminate the buffer
        *b.buf = '\0';
index bd2f394..c8e6365 100644 (file)
@@ -148,13 +148,14 @@ void proc_run(struct proc *p)
                        if (p->num_vcores) {
                                // TODO: handle silly state (HSS)
                                // set virtual core 0 to run the main context
-                               send_active_msg_sync(p->vcoremap[0], __startcore, p,
-                                                    &p->env_tf, 0);
+                               send_active_msg_sync(p->vcoremap[0], __startcore, (uint32_t)p,
+                                                    (uint32_t)&p->env_tf, 0);
                                /* handle the others.  note the sync message will spin until
                                 * there is a free active message slot, which could lock up the
                                 * system.  think about this. (TODO) */
                                for (int i = 1; i < p->num_vcores; i++)
-                                       send_active_msg_sync(p->vcoremap[i], __startcore, p, 0, i);
+                                       send_active_msg_sync(p->vcoremap[i], __startcore,
+                                                            (uint32_t)p, 0, i);
                        }
                        /* There a subtle (attempted) race avoidance here.  proc_startcore
                         * can handle a death message, but we can't have the startcore come
@@ -316,7 +317,10 @@ void proc_destroy(struct proc *p)
                        spin_unlock(&idle_lock);
                        break;
                default:
-                       panic("Weird state in proc_destroy");
+                       // TODO: getting here if it's already dead and free (ENV_FREE).
+                       // Need to sort reusing process structures and having pointers to
+                       // them floating around the system.
+                       panic("Weird state(0x%08x) in proc_destroy", p->state);
        }
        proc_set_state(p, PROC_DYING);
 
index 8419a7a..6b747b1 100644 (file)
@@ -4,7 +4,11 @@
 #pragma nosharc
 #endif
 
-#include <arch/types.h>
+#ifdef __IVY__
+#pragma nodeputy
+#endif
+
+#include <ros/common.h>
 #include <arch/arch.h>
 #include <arch/mmu.h>
 #include <arch/console.h>
@@ -316,8 +320,8 @@ static error_t sys_proc_run(struct proc *p, unsigned pid)
 
 // TODO: Build a dispatch table instead of switching on the syscallno
 // Dispatches to the correct kernel function, passing the arguments.
-intreg_t syscall(env_t* e, uint32_t syscallno, uint32_t a1, uint32_t a2,
-                 uint32_t a3, uint32_t a4, uint32_t a5)
+intreg_t syscall(env_t* e, uintreg_t syscallno, uintreg_t a1, uintreg_t a2,
+                 uintreg_t a3, uintreg_t a4, uintreg_t a5)
 {
        // Call the function corresponding to the 'syscallno' parameter.
        // Return any appropriate return value.
@@ -326,6 +330,9 @@ intreg_t syscall(env_t* e, uint32_t syscallno, uint32_t a1, uint32_t a2,
        //        " a2: %x\n    a3: %x\n    a4: %x\n    a5: %x\n",
        //        syscallno, a1, a2, a3, a4, a5);
 
+       // used if we need more args, like in mmap
+       int32_t _a4, _a5, _a6, *COUNT(3) args;
+
        assert(e); // should always have an env for every syscall
        //printk("Running syscall: %d\n", syscallno);
        if (INVALID_SYSCALL(syscallno))
@@ -364,6 +371,17 @@ intreg_t syscall(env_t* e, uint32_t syscallno, uint32_t a1, uint32_t a2,
                        return sys_proc_create(e, (char *DANGEROUS)a1);
                case SYS_proc_run:
                        return sys_proc_run(e, (size_t)a1);
+               case SYS_mmap:
+                       // we only have 4 parameters from sysenter currently, need to copy
+                       // in the others.  if we stick with this, we can make a func for it.
+               args = user_mem_assert(e, (void*)a4, 3*sizeof(_a4), PTE_USER_RW);
+                       _a4 = *(args++);
+                       _a5 = *(args++);
+                       _a6 = *(args++);
+                       return (intreg_t) mmap(e, a1, a2, a3, _a4, _a5, _a6);
+               case SYS_brk:
+                       printk("brk not implemented yet\n");
+                       return -EINVAL;
 
        #ifdef __i386__
                case SYS_serial_write:
@@ -410,8 +428,8 @@ intreg_t process_generic_syscalls(env_t* e, size_t max)
                        lcr3(e->env_cr3);
                }
                count++;
-               //printk("DEBUG PRE: sring->req_prod: %d, sring->rsp_prod: %d\n",\
-                          sysbr->sring->req_prod, sysbr->sring->rsp_prod);
+               //printk("DEBUG PRE: sring->req_prod: %d, sring->rsp_prod: %d\n",
+               //         sysbr->sring->req_prod, sysbr->sring->rsp_prod);
                // might want to think about 0-ing this out, if we aren't
                // going to explicitly fill in all fields
                syscall_rsp_t rsp;
@@ -423,8 +441,8 @@ intreg_t process_generic_syscalls(env_t* e, size_t max)
                // update our counter for what we've produced (assumes we went in order!)
                (sysbr->rsp_prod_pvt)++;
                RING_PUSH_RESPONSES(sysbr);
-               //printk("DEBUG POST: sring->req_prod: %d, sring->rsp_prod: %d\n",\
-                          sysbr->sring->req_prod, sysbr->sring->rsp_prod);
+               //printk("DEBUG POST: sring->req_prod: %d, sring->rsp_prod: %d\n",
+               //         sysbr->sring->req_prod, sysbr->sring->rsp_prod);
        }
        // load sane page tables (and don't rely on decref to do it for you).
        lcr3(boot_cr3);
index c2a5c96..e092637 100644 (file)
@@ -3,6 +3,10 @@
 #pragma nosharc
 #endif
 
+#ifdef __IVY__
+#pragma nodeputy
+#endif
+
 #include <arch/mmu.h>
 #include <arch/arch.h>
 #include <smp.h>
@@ -160,7 +164,6 @@ void test_page_coloring(void)
                cprintf("Page: %d\n", page2ppn(page));  
 }
 
-extern uint8_t num_cpus;
 barrier_t test_cpu_array;
 
 void test_barrier(void)
@@ -309,8 +312,6 @@ void test_checklist_handler(trapframe_t *tf, void* data)
        down_checklist(the_global_list);
 }
 
-extern uint8_t num_cpus;
-
 void test_checklists(void)
 {
        INIT_CHECKLIST(a_list, MAX_NUM_CPUS);
@@ -346,7 +347,7 @@ void test_checklists(void)
 
 atomic_t a, b, c;
 
-void test_incrementer_handler(trapframe_t *tf, atomic_t* data)
+void test_incrementer_handler(trapframe_t *tf, void *data)
 {
        assert(data);
        atomic_inc(data);
@@ -680,7 +681,7 @@ void test_barrier_handler(trapframe_t *tf, void* data)
        //cprintf("Round 4: Core %d\n", core_id());
 }
 
-static void test_waiting_handler(trapframe_t *tf, atomic_t * data)
+static void test_waiting_handler(trapframe_t *tf, void *data)
 {
        {HANDLER_ATOMIC atomic_dec(data);}
 }
index d3eeeee..cc089ae 100644 (file)
@@ -18,7 +18,7 @@ uint64_t timing_overhead = 0;
  * value.  It is pusposefully annotated with a noinline so that the overheads 
  * assocaited with calling it are as deterministic as possible.
  */
-uint64_t start_timing() __attribute__((noinline))
+uint64_t start_timing()
 {
     return read_tsc_serialized();
 }
@@ -32,7 +32,7 @@ uint64_t start_timing() __attribute__((noinline))
  * This function is purposefully annotated with a noinline so that 
  * the overheads assocaited with calling it are as deterministic as possible.
  */
-uint64_t stop_timing(uint64_t val) __attribute__((noinline))
+uint64_t stop_timing(uint64_t val)
 {
     uint64_t diff = (read_tsc_serialized() - val - timing_overhead);
        if ((int64_t) diff < 0) 
index b88907c..86a32fc 100644 (file)
@@ -22,7 +22,7 @@
  */
 void process_workqueue()
 {
-       struct work TP(env_t *) work;
+       struct work TP(void*) work;
        struct per_cpu_info *cpuinfo = &per_cpu_info[core_id()];
 
        // copy the work in, since we may never return to this stack frame
@@ -39,7 +39,7 @@ void process_workqueue()
        }
 }
 
-int enqueue_work(struct workqueue *queue, struct work *job)
+int enqueue_work(struct workqueue TP(void*) *queue, struct work TP(TV(t)) *job)
 {
        error_t retval = 0;
        struct per_cpu_info *cpuinfo = &per_cpu_info[core_id()];
index 5eeb0a3..4d746aa 100644 (file)
@@ -1,6 +1,6 @@
 USER_DIR = user
 
-USER_CFLAGS  := $(USER_IVY_FLAGS) $(CFLAGS) -DROS_USER 
+USER_CFLAGS  += $(CFLAGS) -DROS_USER 
 USER_LDFLAGS := $(LDFLAGS)
 
 include $(USER_DIR)/roslib/Makefrag
index de949d9..12c63ce 100644 (file)
@@ -1,9 +1,12 @@
 USER_APPS_PARLIB_DIR = $(USER_APPS_DIR)/parlib
 OBJDIRS += $(USER_APPS_PARLIB_DIR)
 
-USER_APPS_PARLIB_CFLAGS    := $(USER_CFLAGS) --nodeputy --nopatch \
+USER_APPS_PARLIB_CFLAGS    := $(USER_CFLAGS)  \
                               -I$(USER_PARLIB_NEWLIB_DIR)/include \
                               -I$(USER_PARLIB_DIR)/inc
+ifeq ($(COMPILER),IVY)
+       USER_APPS_PARLIB_CFLAGS    += --nodeputy --nopatch
+endif
 
 USER_APPS_PARLIB_LDFLAGS   := $(USER_LDFLAGS) -static \
                               -T $(USER_APPS_PARLIB_DIR)/apps_$(TARGET_ARCH).ld
index 83ecdcf..90df8ec 100644 (file)
@@ -35,7 +35,7 @@ void file_error()
 
        errno = 0;
        printf("\n");
-       int result = read(bad_fd, buf, IN_BUF_SIZE - 1);
+       result = read(bad_fd, buf, IN_BUF_SIZE - 1);
        printf("Read:         %d bytes\n", result);
        printf("ERRNO:        %s\n", strerror(errno));
 
index 22ae07e..c590248 100644 (file)
@@ -1,5 +1,5 @@
-#include <string.h>
 #include <stdlib.h>
+#include <string.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
index cbe98f2..7cb7ff0 100644 (file)
@@ -2,7 +2,7 @@
 #include <string.h>
 #include <stdio.h>
 #include <unistd.h>
-#include <arch/types.h>
+#include <ros/common.h>
 
 extern char * readline(const char *prompt);
 extern void draw_nanwan();
index af17789..0b77a3b 100644 (file)
@@ -1,4 +1,4 @@
-#include <arch/types.h>
+#include <ros/common.h>
 #include <arch/arch.h>
 #include <ros/timer.h>
 #include <ros/syscall.h>
index 6b71134..815fa4c 100644 (file)
@@ -17,9 +17,13 @@ void udelay(uint64_t usec, uint64_t tsc_freq)
        return;
 }
 
+#ifdef __IVY__
+#pragma nodeputy
+#endif
 int main(int argc, char** argv)
 {
        cprintf("Multi-Goodbye, world, from PID: %d!\n", sys_getpid());
+       sys_mmap((void*)1, 2, 3, 4, 0, 0);
        while(1);
        udelay(5000000, 1995014570); // KVM's freq.  Whatever.
 
index f49dfbb..8ad97ec 100644 (file)
@@ -9,7 +9,7 @@
 #define ROS_CHANNEL_H
  
 #include <stdint.h>
-#include <arch/types.h>
+#include <ros/common.h>
 #include <ros/error.h>
 #include <ros/ring_buffer.h>
 
index 868c0fe..0c312ed 100644 (file)
@@ -1,7 +1,7 @@
 /* See COPYRIGHT for copyright information. */
 /* Kevin Klues <klueska@cs.berkeley.edu>       */
 
-#ifndef _NEWLIB_LIBC_WRAPPERS_H
+#ifndef _NEWLIB_LIBC_WRAPPERS_H_
 #define _NEWLIB_LIBC_WRAPPERS_H_
 
 #include <errno.h>
index a2e8ddb..b5a03a2 100644 (file)
@@ -4,10 +4,10 @@
 // and is intended to be linked into all user-mode applications
 // (NOT the kernel or boot loader).
 
-#ifndef ROS_INC_LIB_H
-#define ROS_INC_LIB_H 1
+#ifndef ROS_INC_PARLIB_H
+#define ROS_INC_PARLIB_H 1
 
-#include <arch/types.h>
+#include <ros/common.h>
 #include <ros/memlayout.h>
 #include <ros/syscall.h>
 #include <ros/error.h>
@@ -37,4 +37,4 @@ ssize_t     sys_shared_page_alloc(void *COUNT(PGSIZE) *addr, pid_t p2,
                                   int p1_flags, int p2_flags);
 ssize_t     sys_shared_page_free(void *COUNT(PGSIZE) addr, pid_t p2);
 
-#endif // !ROS_INC_LIB_H
+#endif // !ROS_INC_PARLIB_H
index 43b55c6..e44a40a 100644 (file)
@@ -1,9 +1,12 @@
 USER_PARLIB_IVY_DIR := $(USER_PARLIB_DIR)/ivy
 OBJDIRS += $(USER_PARLIB_IVY_DIR)
 
-USER_PARLIB_IVY_CFLAGS   := $(USER_CFLAGS) --nodeputy \
+USER_PARLIB_IVY_CFLAGS   := $(USER_CFLAGS) \
                             -I$(USER_PARLIB_NEWLIB_DIR)/include \
                             -I$(USER_PARLIB_INCLUDE_DIR)
+ifeq ($(COMPILER),IVY)
+USER_PARLIB_IVY_CFLAGS   += --nodeputy
+endif
 
 USER_PARLIB_IVY_SRCFILES := $(USER_PARLIB_IVY_DIR)/deputy.c
 
index 17ba2d6..01a13fb 100644 (file)
@@ -1,3 +1,4 @@
+#ifdef __IVY__
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -169,3 +170,4 @@ asmlinkage
 void *__deputy_memset(void *s, int c, unsigned int n) {
   return memset(s, c, n);
 }
+#endif // __IVY__
index 4e8864c..fda2337 100644 (file)
@@ -3,9 +3,12 @@ OBJDIRS += $(USER_PARLIB_SRC_DIR)
 
 PATCHFILE = $(OBJDIR)/$(USER_PARLIB_DIR)/libc_patch.i
 
-USER_PARLIB_SRC_CFLAGS   := $(USER_CFLAGS) --nopatch --patch=$(PATCHFILE)\
+USER_PARLIB_SRC_CFLAGS   := $(USER_CFLAGS) \
                             -I$(USER_PARLIB_DIR)/inc \
                             -I$(USER_PARLIB_NEWLIB_DIR)/include
+ifeq ($(COMPILER),IVY)
+USER_PARLIB_SRC_CFLAGS   += --nopatch --patch=$(PATCHFILE)
+endif
 
 USER_PARLIB_SRC_SRCFILES := $(USER_PARLIB_SRC_DIR)/debug.c \
                             $(USER_PARLIB_SRC_DIR)/debugfmt.c \
index 39739af..08e0639 100644 (file)
@@ -5,7 +5,7 @@
 // It is very important that it always go to the console, especially when
 // debugging file descriptor code!
 
-#include <arch/types.h>
+#include <ros/common.h>
 #include <parlib.h>
 #include <debug.h>
 
@@ -39,7 +39,11 @@ int vdebug(const char *fmt, va_list ap)
 
        b.idx = 0;
        b.cnt = 0;
+       #ifdef __DEPUTY__
        vdebugfmt(putch, &bp, fmt, ap);
+       #else
+       vdebugfmt((void*)putch, (void**)&bp, fmt, ap);
+       #endif
        sys_cputs(b.buf, b.idx);
 
        return b.cnt;
index 9dfa3d6..ceb885c 100644 (file)
@@ -1,4 +1,4 @@
-#include <arch/types.h>
+#include <ros/common.h>
 #include <ros/error.h>
 #include <debug.h>
 
index 1011086..b460bb9 100644 (file)
@@ -13,6 +13,7 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <debug.h>
+#include <sys/times.h>
 
 #define debug_in_out(...) // debug(__VA_ARGS__)  
 #define debug_write_check(fmt, ...) // debug(fmt, __VA_ARGS__)
@@ -29,7 +30,7 @@ char **environ = __env;
  * If your system doesn't provide this, it is best to avoid linking 
  * with subroutines that require it (exit, system).
  */
-void _exit(int __status) _ATTRIBUTE ((noreturn))
+void _exit(int __status)
 {
        sys_proc_destroy(sys_getpid()); // TODO: can run getpid and cache it
        while(1); //Should never get here...
@@ -86,7 +87,7 @@ int close(int file) {
  * Minimal implementation (for a system without processes).
  */
 
-int execve(char *name, char **argv, char **env
+int execve(const char *name, char * const argv[], char * const env[]
 {
        debug_in_out("EXECVE\n");
        errno = ENOMEM;
@@ -97,7 +98,7 @@ int execve(char *name, char **argv, char **env)
  * Create a new process. 
  * Minimal implementation (for a system without processes).
  */
-int fork(void) 
+pid_t fork(void) 
 {
        debug_in_out("FORK\n");
        errno = EAGAIN;
@@ -165,7 +166,7 @@ int fstat(int file, struct stat *st)
  * conflict with other processes. Minimal implementation, for a system 
  * without processes.
  */
-int getpid(void) 
+pid_t getpid(void) 
 {
        return sys_getpid(); // TODO: can run getpid and cache it
 }
@@ -234,7 +235,7 @@ int kill(int pid, int sig)
  * Establish a new name for an existing file. 
  * Minimal implementation.
  */
-int link(char *old, char *new) 
+int link(const char *old, const char *new) 
 {
        debug_in_out("LINK\n");
        
@@ -609,7 +610,7 @@ char *send_message(char *message, int len)
  * Status of a file (by name). 
  * Minimal implementation.
  */
-int stat(char *file, struct stat *st) 
+int stat(const char *file, struct stat *st) 
 {
        debug_in_out("STAT\n");
        
@@ -663,7 +664,7 @@ int stat(char *file, struct stat *st)
  * Timing information for current process. 
  * Minimal implementation.
  */
-int times(struct tms *buf) 
+clock_t times(struct tms *buf) 
 {
        debug_in_out("TIMES");
        return -1;
@@ -673,7 +674,7 @@ int times(struct tms *buf)
  * Remove a file's directory entry. 
  * Minimal implementation.
  */
-int unlink(char *name) 
+int unlink(const char *name) 
 {
        debug_in_out("UNLINK\n");
        
@@ -729,7 +730,7 @@ int wait(int *status)
 /* write()
  * Write to a file. 
  */
-ssize_t write(int file, void *ptr, size_t len) {
+ssize_t write(int file, const void *ptr, size_t len) {
        
        debug_in_out("WRITE\n");        
        debug_in_out("\tFILE: %u\n", file);
index d8e0024..0e07188 100644 (file)
@@ -1,6 +1,6 @@
 // System call stubs.
 
-#include <arch/types.h>
+#include <ros/common.h>
 #include <arch/arch.h>
 
 // TODO: fix sysenter to take all 5 params
index 3ad82a2..2f57455 100644 (file)
@@ -7,11 +7,11 @@
 #ifndef ROS_INC_LIB_H
 #define ROS_INC_LIB_H 1
 
-#include <arch/types.h>
 #include <ros/timer.h>
 #include <ros/error.h>
 #include <ros/memlayout.h>
 #include <ros/procdata.h>
+#include <ros/common.h>
 
 #include <stdarg.h>
 #include <string.h>
@@ -65,6 +65,9 @@ error_t     sys_proc_destroy(int pid);
 void        sys_yield(void);
 int         sys_proc_create(char* path);
 error_t     sys_proc_run(int pid);
+/* Memory Management */
+void *sys_mmap(void *addr, size_t length, int prot, int flags, int fd,
+               size_t offset);
 /* Generic Async Call */
 error_t     waiton_syscall(syscall_desc_t* desc, syscall_rsp_t*COUNT(1) rsp);
 
index 6184004..d0dff1c 100644 (file)
@@ -1,7 +1,7 @@
 #ifndef ROS_INC_MEASURE_H
 #define ROS_INC_MEASURE_H
 
-#include <arch/types.h>
+#include <ros/common.h>
 #include <ros/timer.h>
 #include <arch/arch.h>
 
diff --git a/user/roslib/inc/stdint.h b/user/roslib/inc/stdint.h
new file mode 100644 (file)
index 0000000..44fd3db
--- /dev/null
@@ -0,0 +1,5 @@
+/* GHETTO: To our grandchildren, we are sorry for this
+ * We do this since newlib has it's own stdint that conflicts with the kernel
+ * and roslib's types. */
+
+#include <arch/types.h>
index 1ab1770..1493438 100644 (file)
@@ -1,7 +1,7 @@
 #ifndef ROS_INC_STRING_H
 #define ROS_INC_STRING_H
 
-#include <types.h>
+#include <ros/common.h>
 
 #define STRING char *NTS
 #define STRBUF(n) char *NT COUNT(n)
diff --git a/user/roslib/inc/sys b/user/roslib/inc/sys
new file mode 120000 (symlink)
index 0000000..9692909
--- /dev/null
@@ -0,0 +1 @@
+../../../kern/include/sys
\ No newline at end of file
diff --git a/user/roslib/inc/sys/queue.h b/user/roslib/inc/sys/queue.h
deleted file mode 120000 (symlink)
index 93b95c0..0000000
+++ /dev/null
@@ -1 +0,0 @@
-../../../../kern/include/sys/queue.h
\ No newline at end of file
diff --git a/user/roslib/inc/types.h b/user/roslib/inc/types.h
deleted file mode 100644 (file)
index d1f7a21..0000000
+++ /dev/null
@@ -1,142 +0,0 @@
-#ifndef ROS_INC_TYPES_H
-#define ROS_INC_TYPES_H
-
-#ifndef NULL
-#define NULL ((void*) 0)
-#endif
-
-#ifndef TRUE
-#define TRUE   1
-#endif
-
-#ifndef FALSE
-#define FALSE  0
-#endif
-
-// Represents true-or-false values
-typedef int bool;
-
-// Explicitly-sized versions of integer types
-typedef __signed char int8_t;
-typedef unsigned char uint8_t;
-typedef short int16_t;
-typedef unsigned short uint16_t;
-typedef int int32_t;
-typedef unsigned int uint32_t;
-typedef long long int64_t;
-typedef unsigned long long uint64_t;
-
-// Pointers and addresses are 32 bits long.
-// We use pointer types to represent virtual addresses,
-// uintptr_t to represent the numerical values of virtual addresses,
-// and physaddr_t to represent physical addresses.
-typedef int32_t intptr_t;
-typedef uint32_t uintptr_t;
-typedef uint32_t physaddr_t;
-
-// Page numbers are 32 bits long.
-typedef uint32_t ppn_t;
-
-// size_t is used for memory object sizes.
-typedef uint32_t size_t;
-// ssize_t is a signed version of ssize_t, used in case there might be an
-// error return.
-typedef int32_t ssize_t;
-
-// off_t is used for file offsets and lengths.
-typedef int32_t off_t;
-
-// Efficient min and max operations
-#define MIN(_a, _b)                                            \
-({                                                             \
-       typeof(_a) __a = (_a);                                  \
-       typeof(_b) __b = (_b);                                  \
-       __a <= __b ? __a : __b;                                 \
-})
-#define MAX(_a, _b)                                            \
-({                                                             \
-       typeof(_a) __a = (_a);                                  \
-       typeof(_b) __b = (_b);                                  \
-       __a >= __b ? __a : __b;                                 \
-})
-
-// Rounding operations (efficient when n is a power of 2)
-// Round down to the nearest multiple of n
-#define ROUNDDOWN(a, n)                                                \
-({                                                             \
-       uint32_t __a = (uint32_t) (a);                          \
-       (typeof(a)) (__a - __a % (n));                          \
-})
-// Round up to the nearest multiple of n
-#define ROUNDUP(a, n)                                          \
-({                                                             \
-       uint32_t __n = (uint32_t) (n);                          \
-       (typeof(a)) (ROUNDDOWN((uint32_t) (a) + __n - 1, __n)); \
-})
-
-// Return the offset of 'member' relative to the beginning of a struct type
-#define offsetof(type, member)  ((size_t) (&((type*)0)->member))
-
-// Ivy currently can only handle 63 bits (OCaml thing), so use this to make
-// a uint64_t programatically
-#define UINT64(upper, lower) ( (((uint64_t)(upper)) << 32) | (lower) )
-
-/*********************** Bitmask stuff **********************/
-#define BYTES_FOR_BITMASK(size) (((size) - 1) / 8 + 1)
-#define BYTES_FOR_BITMASK_WITH_CHECK(size) ((size) ? ((size) - (1)) / (8) + (1) : (0))
-#define DECL_BITMASK(name, size) uint8_t (name)[BYTES_FOR_BITMASK((size))]
-
-#define GET_BITMASK_BIT(name, bit) (((name)[(bit)/8] & (1 << ((bit) % 8))) ? 1 : 0)
-#define SET_BITMASK_BIT(name, bit) ((name)[(bit)/8] |= (1 << ((bit) % 8)))
-#define CLR_BITMASK_BIT(name, bit) ((name)[(bit)/8] &= ~(1 << ((bit) % 8)))
-#define SET_BITMASK_BIT_ATOMIC(name, bit) (atomic_orb(&(name)[(bit)/8], (1 << ((bit) % 8))))
-#define CLR_BITMASK_BIT_ATOMIC(name, bit) (atomic_andb(&(name)[(bit)/8], ~(1 << ((bit) % 8))))
-
-#define CLR_BITMASK(name, size) \
-({ \
-       {TRUSTEDBLOCK \
-       memset((void*)((uintptr_t)(name)), 0, BYTES_FOR_BITMASK((size))); \
-       } \
-})
-
-#define FILL_BITMASK(name, size) \
-({ \
-       {TRUSTEDBLOCK \
-       memset((void*)((uintptr_t)(name)), 255, BYTES_FOR_BITMASK((size))); \
-       } \
-       (name)[BYTES_FOR_BITMASK((size))-1] >>= (((size) % 8) ? (8 - ((size) % 8)) : 0 ); \
-}) 
-
-#define COPY_BITMASK(newmask, oldmask, size) \
-({ \
-       {TRUSTEDBLOCK \
-       memcpy((void*)((uintptr_t)(newmask)), \
-           (void*)((uintptr_t)(oldmask)), \
-           BYTES_FOR_BITMASK((size))); \
-       } \
-})
-
-// this checks the entire last byte, so keep it 0 in the other macros
-#define BITMASK_IS_CLEAR(name, size) ({ \
-       uint32_t __n = BYTES_FOR_BITMASK((size)); \
-       bool clear = 1; \
-       while (__n-- > 0) { \
-               if ((name)[__n]) { \
-                       clear = 0; \
-                       break;\
-               }\
-       } \
-       clear; })
-
-#define PRINT_BITMASK(name, size) { \
-       int i;  \
-       for (i = 0; i < BYTES_FOR_BITMASK(size); i++) { \
-               int j;  \
-               for (j = 0; j < 8; j++) \
-                       printk("%x", ((name)[i] >> j) & 1);     \
-       } \
-       printk("\n"); \
-}
-/**************************************************************/
-
-#endif /* !ROS_INC_TYPES_H */
index db0d17b..4a83b3c 100644 (file)
@@ -1,8 +1,11 @@
 USER_ROSLIB_IVY_DIR := $(USER_ROSLIB_DIR)/ivy
 OBJDIRS += $(USER_ROSLIB_IVY_DIR)
 
-USER_ROSLIB_IVY_CFLAGS   := $(USER_CFLAGS) --nodeputy \
+USER_ROSLIB_IVY_CFLAGS   := $(USER_CFLAGS) \
                             -I$(USER_ROSLIB_INCLUDE_DIR)
+ifeq ($(COMPILER),IVY)
+USER_ROSLIB_IVY_CFLAGS   += --nodeputy
+endif
 
 USER_ROSLIB_IVY_SRCFILES := $(USER_ROSLIB_IVY_DIR)/deputy.c
 
index fbe6256..8abc39e 100644 (file)
@@ -1,3 +1,5 @@
+#ifdef __IVY__
+
 #include <stdio.h>
 #include <string.h>
 #include <lib.h>
@@ -168,3 +170,4 @@ asmlinkage
 void *__deputy_memset(void *s, int c, unsigned int n) {
   return memset(s, c, n);
 }
+#endif // __IVY__
index 2d6af76..da0be98 100644 (file)
@@ -65,7 +65,7 @@ error_t get_all_desc(async_desc_t** a_desc, syscall_desc_t** s_desc)
        if ((current_async_desc = get_async_desc()) == NULL)
                return -EBUSY;
        *a_desc = current_async_desc;
-       if (*s_desc = get_sys_desc(current_async_desc))
+       if ((*s_desc = get_sys_desc(current_async_desc)))
                return 0;
        // in case we could get an async, but not a syscall desc, then clean up.
        POOL_PUT(&async_desc_pool, current_async_desc);
index fbaa67e..7037f91 100644 (file)
@@ -1,6 +1,6 @@
 #include <lib.h>
 
-void exit(void) __attribute__((noreturn))
+void exit(void)
 {
        sys_proc_destroy(sys_getpid());
        //Shouldn't get here, but include anyway so the compiler is happy.. 
index d8e0024..0e07188 100644 (file)
@@ -1,6 +1,6 @@
 // System call stubs.
 
-#include <arch/types.h>
+#include <ros/common.h>
 #include <arch/arch.h>
 
 // TODO: fix sysenter to take all 5 params
index 0ad7618..26dbc39 100644 (file)
@@ -5,7 +5,7 @@
 // It is very important that it always go to the console, especially when
 // debugging file descriptor code!
 
-#include <types.h>
+#include <ros/common.h>
 #include <stdio.h>
 #include <stdarg.h>
 #include <lib.h>
@@ -41,7 +41,11 @@ int vcprintf(const char *fmt, va_list ap)
 
        b.idx = 0;
        b.cnt = 0;
+       #ifdef __DEPUTY__
        vprintfmt(putch, &bp, fmt, ap);
+       #else
+       vprintfmt((void*)putch, (void**)&bp, fmt, ap);
+       #endif
        sys_cputs(b.buf, b.idx);
 
        return b.cnt;
@@ -103,7 +107,11 @@ static int vcprintf_async(const char *NTS fmt, va_list ap)
 
        b->idx = 0;
        b->cnt = 0;
+       #ifdef __DEPUTY__
        vprintfmt(putch_async, &b, fmt, ap);
+       #else
+       vprintfmt((void*)putch_async, (void**)&b, fmt, ap);
+       #endif
        // TODO - should check for a return value for sys_
        sys_cputs_async(b->buf, b->idx, get_sys_desc(current_async_desc),
                        cputs_async_cleanup, b);
index 066dda5..74b47e5 100644 (file)
@@ -3,7 +3,7 @@
 // This code is also used by both the kernel and user programs.
 
 #include <ros/error.h>
-#include <types.h>
+#include <ros/common.h>
 #include <stdio.h>
 #include <string.h>
 #include <stdarg.h>
@@ -275,7 +275,11 @@ int vsnprintf(char *buf, int n, const char *fmt, va_list ap)
        b.buf = buf;
 
        // print the string to the buffer
-       vprintfmt(sprintputch, (sprintbuf_t *NONNULL*NONNULL)&bp, fmt, ap);
+       #ifdef __DEPUTY__
+       vprintfmt((void*)sprintputch, (sprintbuf_t *NONNULL*NONNULL)&bp, fmt, ap);
+       #else
+       vprintfmt((void*)sprintputch, (void**)&bp, fmt, ap);
+       #endif
 
        // null terminate the buffer
        *b.buf = '\0';
index d4457c7..b34a2ca 100644 (file)
@@ -1,6 +1,6 @@
 // System call stubs.
 
-#include <arch/types.h>
+#include <ros/common.h>
 #include <arch/arch.h>
 #include <ros/syscall.h>
 #include <lib.h>
@@ -26,8 +26,8 @@ static error_t async_syscall(syscall_req_t *COUNT(1) req, syscall_desc_t* desc)
        memcpy(r, req, sizeof(syscall_req_t));
        // push our updates to syscallfrontring.req_prod_pvt
        RING_PUSH_REQUESTS(&syscallfrontring);
-       //cprintf("DEBUG: sring->req_prod: %d, sring->rsp_prod: %d\n", \
-               syscallfrontring.sring->req_prod, syscallfrontring.sring->rsp_prod);
+       //cprintf("DEBUG: sring->req_prod: %d, sring->rsp_prod: %d\n", 
+       //   syscallfrontring.sring->req_prod, syscallfrontring.sring->rsp_prod);
        return 0;
 }
 
@@ -137,3 +137,25 @@ error_t sys_proc_run(int pid)
        return syscall(SYS_proc_run, pid, 0, 0, 0, 0);
 }
 
+#ifdef __IVY__
+#pragma nodeputy
+#endif
+/* We need to do some hackery to pass 6 arguments.  Arg4 pts to the real arg4,
+ * arg5, and arg6.  Keep this in sync with kern/src/syscall.c.
+ * TODO: consider a syscall_multi that can take more args, and keep it in sync
+ * with the kernel.  Maybe wait til we fix sysenter to have 5 or 6 args. */
+void *sys_mmap(void *addr, size_t length, int prot, int flags, int fd,
+               size_t offset)
+{
+       struct args {
+               int _flags;
+               int _fd;
+               size_t _offset;
+       } extra_args;
+       extra_args._flags = flags;
+       extra_args._fd = fd;
+       extra_args._offset = offset;
+       // TODO: deputy bitches about this
+       return (void*)syscall(SYS_mmap, (uint32_t)addr, length, prot,
+                             (int32_t)&extra_args, 0);
+}
index baab955..f877dbe 100644 (file)
@@ -1,7 +1,7 @@
 
-#include <types.h>
-#include <lib.h>
+#include <ros/common.h>
 #include <ros/syscall.h>
+#include <lib.h>
 
 void null()
 {
@@ -12,7 +12,7 @@ error_t null_async(async_desc_t** desc)
 {
        error_t e;
        syscall_desc_t* sysdesc;
-       if (e = get_all_desc(desc, &sysdesc))
+       if ((e = get_all_desc(desc, &sysdesc)))
                return e;
        return sys_null_async(sysdesc);
 }
@@ -28,7 +28,7 @@ error_t cache_buster_async(async_desc_t** desc, uint32_t num_writes,
 {
        error_t e;
        syscall_desc_t* sysdesc;
-       if (e = get_all_desc(desc, &sysdesc))
+       if ((e = get_all_desc(desc, &sysdesc)))
                return e;
        return sys_cache_buster_async(sysdesc, num_writes, num_pages, flags);
 }
index 48fdec4..287ac3d 100644 (file)
@@ -13,7 +13,7 @@ uint64_t timing_overhead = 0;
  * value.  It is pusposefully annotated with a noinline so that the overheads 
  * assocaited with calling it are as deterministic as possible.
  */
-uint64_t start_timing() __attribute__((noinline))
+uint64_t start_timing()
 {
     return read_tsc_serialized();
 }
@@ -27,7 +27,7 @@ uint64_t start_timing() __attribute__((noinline))
  * This function is purposefully annotated with a noinline so that 
  * the overheads assocaited with calling it are as deterministic as possible.
  */
-uint64_t stop_timing(uint64_t val) __attribute__((noinline))
+uint64_t stop_timing(uint64_t val)
 {
     uint64_t diff = (read_tsc_serialized() - val - timing_overhead);
        if ((int64_t) diff < 0)