Merged in all of the recent changes for compiling on sparc
authorSarah Bird <slbird@r53.millennium.berkeley.edu>
Wed, 23 Sep 2009 22:51:43 +0000 (15:51 -0700)
committerKevin Klues <klueska@cs.berkeley.edu>
Thu, 1 Oct 2009 20:09:51 +0000 (22:09 +0200)
19 files changed:
kern/arch/sparc/Makefrag
kern/arch/sparc/arch.h
kern/arch/sparc/atomic.h
kern/arch/sparc/boot.c
kern/arch/sparc/colored_caches.c
kern/arch/sparc/cpuinfo.c
kern/arch/sparc/env.c
kern/arch/sparc/frontend.c
kern/arch/sparc/page_alloc.c
kern/arch/sparc/pmap.c
kern/arch/sparc/process.c [new file with mode: 0644]
kern/arch/sparc/smp.c
kern/arch/sparc/sparc.h
kern/arch/sparc/timer.c
kern/arch/sparc/trap.c
kern/arch/sparc/types.h
kern/src/kfs.c
kern/src/pmap.c
user/parlib/src/sparc/newlib_backend.c

index 55d3a57..00c8863 100644 (file)
@@ -22,6 +22,7 @@ KERN_ARCH_SRCFILES := $(KERN_ARCH_SRC_DIR)/entry.S \
                       $(KERN_ARCH_SRC_DIR)/frontend.c \
                       $(KERN_ARCH_SRC_DIR)/pmap.c \
                       $(KERN_ARCH_SRC_DIR)/page_alloc.c \
+                      $(KERN_ARCH_SRC_DIR)/process.c \
                       $(KERN_ARCH_SRC_DIR)/colored_caches.c \
                       $(KERN_ARCH_SRC_DIR)/timer.c \
                       $(KERN_ARCH_SRC_DIR)/env.c \
index b9d0d5b..2049a81 100644 (file)
@@ -10,8 +10,8 @@
 
 #ifndef __ASSEMBLER__
 
+#include <ros/common.h>
 #include <arch/timer.h>
-#include <arch/types.h>
 #include <arch/frontend.h>
 
 static __inline void breakpoint(void) __attribute__((always_inline));
index 73d370f..b0886f3 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()
@@ -21,6 +21,7 @@ static inline void atomic_set(atomic_t* number, int32_t val);
 static inline void atomic_add(atomic_t* number, int32_t inc);
 static inline void atomic_inc(atomic_t* number);
 static inline void atomic_dec(atomic_t* number);
+static inline void atomic_andb(volatile uint8_t RACY* number, uint8_t mask);
 static inline uint32_t spin_trylock(spinlock_t*SAFE lock);
 static inline void spin_lock(spinlock_t*SAFE lock);
 static inline void spin_unlock(spinlock_t*SAFE lock);
@@ -53,7 +54,7 @@ static inline void atomic_add(atomic_t* number, int32_t inc)
        atomic_init(number,inc);
 }
 
-static inline void atomic_set(atomic_t* number, uint32_t val)
+static inline void atomic_set(atomic_t* number, int32_t val)
 {
        // this works basically the same as atomic_add... but without the add
        spin_lock((spinlock_t*)number);
@@ -70,6 +71,13 @@ static inline void atomic_dec(atomic_t* number)
        atomic_add(number,-1);
 }
 
+static inline void atomic_andb(volatile uint8_t RACY*number, uint8_t mask)
+{
+       // asm volatile("lock andb %1,%0" : "=m"(*number) : "r"(mask) : "cc");
+      // SARAH TODO: change to sparc
+}
+
+
 static inline uint32_t spin_trylock(spinlock_t*SAFE lock)
 {
        uint32_t reg;
index ea397fc..d5f4a1b 100644 (file)
@@ -5,10 +5,16 @@
 #include <ros/memlayout.h>
 #include <string.h>
 
+#ifdef __SHARC__
+#pragma nosharc
+#endif
+
 #ifdef __DEPUTY__
 #pragma nodeputy
 #endif
 
+extern uintptr_t mmu_context_table[NCONTEXTS];
+
 void
 build_multiboot_info(multiboot_info_t* mbi)
 {
@@ -26,7 +32,6 @@ build_multiboot_info(multiboot_info_t* mbi)
 void
 build_boot_pgdir(void)
 {
-       extern uintptr_t mmu_context_table[NCONTEXTS];
        extern uintptr_t l1_page_table[NL1ENTRIES];
 
        // relocate symbols
index 679c4e2..683881f 100644 (file)
@@ -7,6 +7,10 @@
 
 #include <colored_caches.h>
 
+#ifdef __SHARC__
+#pragma nosharc
+#endif
+
 // Global variables
 cache_t l1,l2,l3;
 available_caches_t available_caches;
@@ -17,7 +21,7 @@ void cache_init()
        // Initialize the caches available on this system.
        // TODO: Should call out to something reading the acpi tables from 
        // memory, or something similar.  For now, just initialize them inline
-       init_cache_properties(&l1,   32,  8, 64);
+       init_cache_properties(&l1, 32,  8, 64);
        available_caches.l1 = TRUE;
        available_caches.l2 = FALSE;
        available_caches.l3 = FALSE;
index 3609f51..865cb29 100644 (file)
@@ -6,6 +6,10 @@
 #include <smp.h>
 #include <pmap.h>
 
+#ifdef __SHARC__
+#pragma nosharc
+#endif
+
 #ifdef __DEPUTY__
 #pragma nodeputy
 #endif
index 905e786..042a117 100644 (file)
@@ -1,4 +1,8 @@
 /* See COPYRIGHT for copyright information. */
+#ifdef __SHARC__
+#pragma nosharc
+#endif
+
 #ifdef __DEPUTY__
 #pragma noasync
 #endif
@@ -80,23 +84,6 @@ void
        }
 }
 
-void
-proc_set_program_counter(trapframe_t *tf, uintptr_t pc)
-{
-       tf->pc = pc;
-       tf->npc = pc+4;
-}
-
-void
-proc_init_trapframe(trapframe_t *tf)
-{
-       extern char trap_table;
-
-       tf->gpr[14] = USTACKTOP-64;
-       tf->psr = PSR_S; // but PS = 0
-       tf->wim = 0;
-       tf->tbr = (uint32_t)&trap_table;
-}
 
 // Flush all mapped pages in the user portion of the address space
 // TODO: only supports L3 user pages
index 9c76ba6..09de8f8 100644 (file)
@@ -1,5 +1,9 @@
 #include <atomic.h>
 
+#ifdef __SHARC__
+#pragma nosharc
+#endif
+
 #ifdef __DEPUTY__
 #pragma nodeputy
 #endif
index a5f9aca..f0afaf0 100644 (file)
@@ -5,6 +5,10 @@
  * Kevin Klues <klueska@cs.berkeley.edu>    
  */
  
+#ifdef __SHARC__
+#pragma nosharc
+#endif
+
 #ifdef __DEPUTY__
 #pragma nodeputy
 #endif
 #include <kmalloc.h>
 #include <multiboot.h>
 
-page_list_t page_free_list;    // Free list of physical pages
-DECLARE_CACHE_COLORED_PAGE_FREE_LISTS(); // Free list of pages filed by color
+// llc stands for last-level-cache
+uint16_t llc_num_colors;
+page_list_t *COUNT(llc_num_colors) colored_page_free_list = NULL;
+spinlock_t colored_page_free_list_lock;
+
+void page_alloc_bootstrap(cache_t* llc) {
+        // Initialize the properties of the last level cache used by this allocator
+        llc_num_colors = get_cache_num_page_colors(llc);
+
+        // Allocate space for the array required to manage the free lists
+        size_t list_size = llc_num_colors*sizeof(page_list_t);
+        colored_page_free_list = (page_list_t*) boot_alloc(list_size, PGSIZE);
+}
 
 /*
  * Initialize the memory free lists.
@@ -26,9 +41,19 @@ DECLARE_CACHE_COLORED_PAGE_FREE_LISTS(); // Free list of pages filed by color
  */
 void page_alloc_init() 
 {
-       // Now, initialize the lists required to manage the page free lists
-       LIST_INIT(&page_free_list);
-       INIT_CACHE_COLORED_PAGE_FREE_LISTS();
+        cache_t* llc = available_caches.llc;
+
+        // First Bootstrap the page alloc process
+        static bool bootstrapped = FALSE;
+        if(!bootstrapped) {
+                bootstrapped = TRUE;
+                page_alloc_bootstrap(llc);
+        }
+
+        // Then, initialize the array required to manage the colored page free list
+        for(int i=0; i<llc_num_colors; i++) {
+                LIST_INIT(&(colored_page_free_list[i]));
+        }
        
        //  Finally, mark the pages already in use by the kernel. 
        //  1) Mark page 0 as in use.
@@ -50,8 +75,11 @@ void page_alloc_init()
        for(i = PPN(physaddr_after_kernel); i < PPN(maxaddrpa); i++)
        {
                pages[i].page_ref = 0;
-               LIST_INSERT_HEAD(&page_free_list,&pages[i],global_link);
-               INSERT_CACHE_COLORING_PAGE_ONTO_FREE_LISTS(&pages[i]);
+                LIST_INSERT_HEAD(
+                   &(colored_page_free_list[get_page_color(page2ppn(&pages[i]), llc)]),
+                   &pages[i],
+                   page_link
+                );
        }
 
        // mark [maxaddrpa, ...) as in-use (as they are invalid)
index 8a76031..1b9de1f 100644 (file)
@@ -1,3 +1,7 @@
+#ifdef __SHARC__
+#pragma nosharc
+#endif
+
 #ifdef __DEPUTY__
 #pragma nodeputy
 #endif
@@ -24,7 +28,7 @@ vm_init(void)
        boot_cr3 = PADDR(boot_pgdir);
 
        size_t env_array_size = ROUNDUP(NENV*sizeof(env_t), PGSIZE);
-       envs = /*(env_t *)*/boot_calloc(env_array_size, PGSIZE);
+       envs = /*(env_t *)*/boot_calloc(env_array_size, 1, PGSIZE);
        //memset(envs, 0, env_array_size);
 }
 
@@ -121,6 +125,39 @@ int get_va_perms(pde_t *pgdir, const void *SNT va)
 {
        return (int)pgdir_walk(pgdir, va, 0);
 }
+//SARAH TODO: add sparc code here
+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;
+//}
+}
+
+
+
 
 void
 page_check(void)
diff --git a/kern/arch/sparc/process.c b/kern/arch/sparc/process.c
new file mode 100644 (file)
index 0000000..5e3732f
--- /dev/null
@@ -0,0 +1,40 @@
+#include <arch/arch.h>
+#include <arch/trap.h>
+#include <process.h>
+#include <pmap.h>
+#include <smp.h>
+
+#include <string.h>
+#include <assert.h>
+#include <stdio.h>
+
+#ifdef __SHARC__
+#pragma nosharc
+#endif
+
+
+void
+proc_set_program_counter(trapframe_t *tf, uintptr_t pc)
+{
+        tf->pc = pc;
+        tf->npc = pc+4;
+}
+
+void
+proc_init_trapframe(trapframe_t *tf)
+{
+        extern char trap_table;
+
+        tf->gpr[14] = USTACKTOP-64;
+        tf->psr = PSR_S; // but PS = 0
+        tf->wim = 0;
+        tf->tbr = (uint32_t)&trap_table;
+}
+
+
+
+//SARAH TODO: FILL in these functions
+void proc_set_tfcoreid(trapframe_t *tf, uint32_t id)
+{
+//     tf->tf_regs.reg_eax = id;
+}
index b5e1783..b9082f0 100644 (file)
@@ -7,6 +7,10 @@
 #include <assert.h>
 #include <atomic.h>
 
+#ifdef __SHARC__
+#pragma nosharc
+#endif
+
 #ifdef __DEPUTY__
 #pragma nodeputy
 #endif
index 0e53aa2..b246f30 100644 (file)
@@ -23,7 +23,6 @@
 #define XSTR(arg) STR(arg)
 
 #include <ros/common.h>
-#include <trap.h>
 #include <arch/frontend.h>
 
 static __inline uint32_t read_psr(void) __attribute__((always_inline));
@@ -158,7 +157,7 @@ num_cores(void)
 static __inline uint32_t
 mmu_probe(uint32_t va)
 {
-       return load_alternate(va & ~0xFFF | 0x400, 3);
+       return load_alternate((va & ~0xFFF) | 0x400, 3);
 }
 
 #endif /* !__ASSEMBLER__ */
index f3d5725..557b58d 100644 (file)
@@ -5,6 +5,10 @@
 #include <stdio.h>
 #include <assert.h>
 
+#ifdef __SHARC__
+#pragma nosharc
+#endif
+
 system_timing_t system_timing = {0};
 volatile uint32_t timer_ticks = 0;
 
index db372af..d8595b8 100644 (file)
@@ -9,6 +9,10 @@
 #include <stdio.h>
 #include <smp.h>
 
+#ifdef __SHARC__
+#pragma nosharc
+#endif
+
 #ifdef __DEPUTY__
 #pragma nodeputy
 #endif
@@ -99,7 +103,7 @@ get_trapname(uint8_t tt, char buf[TRAPNAME_MAX])
        else if(tt >= sizeof(trapnames)/sizeof(trapnames[0]) || !trapnames[tt])
                snprintf(buf,TRAPNAME_MAX,"(unknown trap 0x%02x)",tt);
        else
-               strcpy(buf,trapnames[tt]);
+               strncpy(buf,trapnames[tt],sizeof(trapnames) + 1);
 
        return buf;
 }
index 7e55ca9..28853dc 100644 (file)
@@ -1,24 +1,19 @@
 #ifndef ROS_INC_TYPES_H
 #define ROS_INC_TYPES_H
 
-#define BIG_ENDIAN
-
-#ifndef NULL
-#define NULL ((void*) 0)
-#endif
+#include <stddef.h>
 
-#ifndef TRUE
-#define TRUE   1
-#endif
+#define BIG_ENDIAN
 
-#ifndef FALSE
-#define FALSE  0
-#endif
+#define NUM_ADDR_BITS 32
+#define MAX_VADDR     ((uint64_t)(~0) >> (64-NUM_ADDR_BITS))
 
 #define CHECK_FLAG(flags,bit)   ((flags) & (1 << (bit)))
 
-// Represents true-or-false values
-typedef int bool;
+//Constants for byte sizes
+#define ONE_KILOBYTE  (1L<<10)
+#define ONE_MEGABYTE  (1L<<20)
+#define ONE_GIGABYTE  (1L<<30)
 
 // Explicitly-sized versions of integer types
 typedef __signed char int8_t;
@@ -30,131 +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;
-
-#define NUM_ADDR_BITS 32
-#define MAX_VADDR     ((uint64_t)(~0) >> (64-NUM_ADDR_BITS))
-
-//Constants for byte sizes
-#define ONE_KILOBYTE  (1L<<10)
-#define ONE_MEGABYTE  (1L<<20)
-#define ONE_GIGABYTE  (1L<<30)
-
-// 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;
-}
-
-// 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
-#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)
-#define BYTES_FOR_BITMASK_WITH_CHECK(size) (size)
-#define DECL_BITMASK(name, size) uint8_t (name)[BYTES_FOR_BITMASK((size))]
-
-#define GET_BITMASK_BIT(name, bit) ((name)[(bit)])
-#define SET_BITMASK_BIT(name, bit) ((name)[(bit)] = 1)
-#define CLR_BITMASK_BIT(name, bit) ((name)[(bit)] = 0)
-#define SET_BITMASK_BIT_ATOMIC(name, bit) SET_BITMASK_BIT(name,bit)
-#define CLR_BITMASK_BIT_ATOMIC(name, bit) CLR_BITMASK_BIT(name,bit)
-
-#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)), 1, BYTES_FOR_BITMASK((size))); \
-       } \
-}) 
-
-#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 __i; \
-       uint8_t __notclear = 0; \
-       for(__i = 0; __i < BYTES_FOR_BITMASK(size); __i++) \
-               __notclear |= (name)[__i]; \
-       1-__notclear; })
-
-#define PRINT_BITMASK(name, size) { \
-       int __i; \
-       for (__i = 0; __i < BYTES_FOR_BITMASK(size); __i++) \
-               printk("%x", (name)[__i]); \
-       printk("\n"); \
-}
-/**************************************************************/
 
 #endif /* !ROS_INC_TYPES_H */
index 16629b7..8479545 100644 (file)
@@ -8,6 +8,10 @@
 #pragma nosharc
 #endif
 
+#ifdef __DEPUTY__
+#pragma nodeputy
+#endif
+
 #include <kfs.h>
 #include <string.h>
 #include <assert.h>
index ebd136a..4960e5f 100644 (file)
 #pragma nosharc
 #endif
 
+#ifdef __DEPUTY__
+#pragma nodeputy
+#endif
+
 #include <arch/arch.h>
 #include <arch/mmu.h>
 
index f714629..3427ab1 100644 (file)
@@ -4,6 +4,8 @@
 #include <arch/frontend.h>
 #include <parlib.h>
 #include <sys/unistd.h>
+#include <sys/times.h>
+#include <sys/time.h>
 
 char *__env[1] = { 0 };
 char **environ = __env;
@@ -40,7 +42,7 @@ fork(void)
 }
 
 int
-execve(char* name, char** argv, char** env)
+execve(const char* name, char* const argv[], char* const env[])
 {
        return -1;
 }
@@ -58,13 +60,13 @@ wait(int* status)
 }
 
 int
-link(char* old, char* new)
+link(const char *old, const char *new)
 {
        return -1;
 }
 
 int
-unlink(char* old)
+unlink(const char* old)
 {
        return syscall(SYS_frontend,RAMP_SYSCALL_unlink,(int)old,0,0,0);
 }
@@ -76,7 +78,7 @@ fstat(int fd, struct stat* st)
 }
 
 int
-stat(char* name, struct stat* st)
+stat(const char* name, struct stat* st)
 {
        return syscall(SYS_frontend,RAMP_SYSCALL_stat,(int)name,(int)st,0,0);
 }
@@ -87,13 +89,13 @@ lseek(int fd, off_t ptr, int dir)
        return syscall(SYS_frontend,RAMP_SYSCALL_lseek,fd,ptr,dir,0);
 }
 
-size_t
-write(int fd, void* ptr, size_t len)
+ssize_t
+write(int fd, const void* ptr, size_t len)
 {
        return syscall(SYS_frontend,RAMP_SYSCALL_write,fd,(int)ptr,len,0);
 }
 
-size_t
+ssize_t
 read(int fd, void* ptr, size_t len)
 {
        return syscall(SYS_frontend,RAMP_SYSCALL_read,fd,(int)ptr,len,0);
@@ -113,7 +115,7 @@ close(int fd)
        return syscall(SYS_frontend,RAMP_SYSCALL_close,fd,0,0,0);
 }
 
-int
+clock_t
 times(struct tms* buf)
 {
        return -1;