Finished glue logic to link LWIP to the OS. This is a WIP commit and contains evil...
authorPaul Pearce <pearce@eecs.berkeley.edu>
Sat, 13 Feb 2010 00:49:43 +0000 (19:49 -0500)
committerKevin Klues <klueska@ros-dev.(none)>
Wed, 24 Mar 2010 19:07:51 +0000 (12:07 -0700)
This commit contains a bunch of really ugly evil hacks whose sole job is to test
the underlying network logic. This has no way to receive packets, and the hart_entry()
code is not safe.

19 files changed:
kern/arch/i386/ne2k.c
kern/arch/i386/rl8168.c
kern/arch/i386/rl8168.h
kern/src/Makefrag
kern/src/kfs.c
kern/src/manager.c
kern/src/syscall.c
user/apps/parlib/Makefrag
user/apps/parlib/hart_entry.c [new file with mode: 0644]
user/apps/parlib/manycore_test.c
user/apps/parlib/matrix.c
user/apps/parlib/mhello.c
user/apps/parlib/network_init.c [deleted file]
user/apps/parlib/ping.c
user/lwip/Makefrag
user/lwip/core/sys_arch.c
user/lwip/include/arch/sys_arch.h
user/lwip/include/lwip/lwipopts.h
user/lwip/netif/ethernetif.c

index e469360..ea6d2fd 100644 (file)
@@ -168,7 +168,6 @@ int ne2k_scan_pci() {
 
 void ne2k_configure_nic() {
        
-       printk("I made it here...\n");
        ne2k_debug("-->Configuring Device.\n");
        
        // Reset. Yes reading from this addr resets it
@@ -216,9 +215,8 @@ void ne2k_setup_interrupts() {
 
 void ne2k_mem_alloc() {
        
-       num_pages = NE2K_NUM_PAGES;
-       base_page = kmalloc(num_pages * NE2K_PAGE_SIZE, 0);
-       
+       num_pages = ROUNDUP(NE2K_NUM_PAGES * NE2K_PAGE_SIZE, PGSIZE) / PGSIZE;
+       base_page = get_cont_pages(LOG2_UP(num_pages), 0);      
 }
 
 void ne2k_read_mac() {
@@ -286,6 +284,7 @@ void ne2k_interrupt_handler(trapframe_t *tf, void* data) {
        return;                         
 }
 
+// @TODO: Is this broken? Didn't change it after kmalloc changed
 void ne2k_handle_rx_packet() {
 
         uint8_t bound = inb(ne2k_io_base_addr + NE2K_PG0_RW_BNRY);
@@ -446,7 +445,6 @@ uint16_t cksum(char *CT(len) ip, int len) {
 // Main routine to send a frame. May be completely broken.
 int ne2k_send_frame(const char *data, size_t len) {
 
-
        if (data == NULL)
                return -1;
        if (len == 0)
index 6b22a84..dc94139 100644 (file)
@@ -1,4 +1,4 @@
-/** @file
+/** @filec
  * @brief RL8168 Driver       
  *
  * EXPERIMENTAL. DO NOT USE IF YOU DONT KNOW WHAT YOU ARE DOING
@@ -649,8 +649,10 @@ int rl8168_send_frame(const char *data, size_t len) {
        // THIS IS A HACK: Need to reach inside the frame we are sending and detect if its of type ip/udp/tcp and set right flag
        // For now, for the syscall hack, force ip checksum on. (we dont care about udp checksum).
        // Add an argument to function to specify packet type?
-       tx_des_kva[tx_des_cur].vlan = DES_TX_IP_CHK_MASK;
-       
+       //tx_des_kva[tx_des_cur].vlan = DES_TX_IP_CHK_MASK;
+       tx_des_kva[tx_des_cur].vlan = 0;
+
+
        tx_des_cur = (tx_des_cur + 1) % NUM_TX_DESCRIPTORS;
        
        //rl8168_frame_debug("-->Sent packet.\n");
index c9977fe..79e90d5 100644 (file)
@@ -7,7 +7,7 @@
 #include <arch/nic_common.h>
 
 #define rl8168_debug(...)  //cprintf(__VA_ARGS__)  
-#define rl8168_interrupt_debug(...) //cprintf(__VA_ARGS__)  
+#define rl8168_interrupt_debug(...) cprintf(__VA_ARGS__)  
 #define rl8168_frame_debug(...)  //cprintf(__VA_ARGS__)  
 
 #define NE2K_IRQ_CPU           5
index 6b76900..1d22091 100644 (file)
@@ -61,6 +61,7 @@ KERN_APPFILES += \
                  $(USER_APPS_PARLIB_DIR)/channel_test_server \
                  $(USER_APPS_PARLIB_DIR)/hello \
                  $(USER_APPS_PARLIB_DIR)/mhello \
+                 $(USER_APPS_PARLIB_DIR)/ping \
                  $(USER_APPS_PARLIB_DIR)/manycore_test
 endif
 
index 1d286e2..204f950 100644 (file)
@@ -43,6 +43,7 @@ DECL_PROG(parlib_channel_test_client);
 DECL_PROG(parlib_channel_test_server);
 DECL_PROG(parlib_hello);
 DECL_PROG(parlib_mhello);
+DECL_PROG(parlib_ping);
 DECL_PROG(parlib_manycore_test);
 #endif
 
@@ -62,6 +63,7 @@ struct kfs_entry kfs[MAX_KFS_FILES] = {
        KFS_ENTRY(parlib_channel_test_server)
        KFS_ENTRY(parlib_hello)
        KFS_ENTRY(parlib_mhello)
+       KFS_ENTRY(parlib_ping)
        KFS_ENTRY(parlib_manycore_test)
 #endif
 };
index 3289730..f77602b 100644 (file)
@@ -251,7 +251,19 @@ void manager_waterman()
 
 void manager_pearce()
 {
-       manager_klueska();
+       static struct proc *envs[256];
+       static volatile uint8_t progress = 0;
+
+       if (progress == 0) {
+               progress++;
+               envs[0] = kfs_proc_create(kfs_lookup_path("parlib_ping"));
+               __proc_set_state(envs[0], PROC_RUNNABLE_S);
+               proc_run(envs[0]);
+       }
+       schedule();
+
+       panic("DON'T PANIC");
+
 }
 
 
index f292518..ed56c6f 100644 (file)
@@ -609,6 +609,18 @@ static ssize_t sys_eth_write(env_t* e, const char *DANGEROUS buf, size_t len)
                if (len == 0)
                        return 0;
 
+               // HACK TO BYPASS HACK
+               int just_sent = send_frame( buf, len);
+
+               if (just_sent < 0) {
+                       printk("Packet send fail\n");
+                       return 0;
+               }
+
+               return just_sent;
+
+               // END OF RECURSIVE HACK
+/*
                char *COUNT(len) _buf = user_mem_assert(e, buf, len, PTE_U);
                int total_sent = 0;
                int just_sent = 0;
@@ -628,12 +640,13 @@ static ssize_t sys_eth_write(env_t* e, const char *DANGEROUS buf, size_t len)
                }
 
                return (ssize_t)len;
-
+*/
        }
        else
                return -EINVAL;
 }
 
+
 static ssize_t sys_eth_get_mac_addr(env_t* e, char *DANGEROUS buf) {
        
        extern int eth_up;
index f46d5e0..8ed8196 100644 (file)
@@ -31,8 +31,7 @@ USER_APPS_PARLIB_LDOBJS    := \
                               $(OBJDIR)/$(USER_APPS_PARLIB_DIR)/run_binary.o \
                               $(OBJDIR)/$(USER_APPS_PARLIB_DIR)/run_binary_colored.o \
                               $(OBJDIR)/$(USER_APPS_PARLIB_DIR)/change_user.o \
-                             $(OBJDIR)/$(USER_APPS_PARLIB_DIR)/ping.o \
-                              $(OBJDIR)/$(USER_APPS_PARLIB_DIR)/network_init.o
+                              $(OBJDIR)/$(USER_APPS_PARLIB_DIR)/hart_entry.o
 
 
 USER_APPS_PARLIB_LDDEPENDS := $(USER_APPS_PARLIB_LDOBJS) \
diff --git a/user/apps/parlib/hart_entry.c b/user/apps/parlib/hart_entry.c
new file mode 100644 (file)
index 0000000..8790999
--- /dev/null
@@ -0,0 +1,13 @@
+// Stub file. Paul, clean this up sir.
+
+#include <stdio.h>
+
+void (*hart_startup)(void*arg);
+void *hart_startup_arg;
+
+
+void hart_entry(void) {
+       
+       if (hart_startup != NULL)
+               hart_startup(hart_startup_arg);
+}
index 04de64c..6e3ff93 100644 (file)
@@ -13,7 +13,7 @@ void do_work_son(int vcoreid)
        hart_barrier_wait(&b,vcoreid);
 }
 
-void hart_entry()
+void startup(void *arg)
 {
        assert(hart_self() > 0);
        do_work_son(hart_self());
@@ -23,6 +23,10 @@ int main(int argc, char** argv)
 {
        assert(hart_self() == 0);
        hart_barrier_init(&b,hart_max_harts());
+       extern void* hart_startup_arg;
+       extern void (*hart_startup)();
+       hart_startup = startup;
+       hart_startup_arg = NULL;
        hart_request(hart_max_harts()-1);
        do_work_son(0);
        return 0;
index f913c64..2c8d5cb 100644 (file)
@@ -18,7 +18,6 @@ extern int  shell_exec(const char* cmdline);
 extern void run_binary(size_t colors);
 extern int  run_binary_filename(const char* fn, size_t colors);
 extern void run_binary_colored();
-extern void ping();
 extern char prompt[256];
 
 void help() {
@@ -92,8 +91,6 @@ int main(int argc, char** argv)
                        run_binary(0);
                else if (strcmp(s, "run_binary_colored") == 0)
                        run_binary_colored();
-               else if (strcmp(s, "ping") == 0)
-                       ping();
                else if (shell_exec(s) == 0)
                        ;
                else
index bf79fd8..f20838e 100644 (file)
@@ -22,6 +22,16 @@ void udelay(uint64_t usec, uint64_t tsc_freq)
 
 __thread int temp;
 
+void startup(void *arg)
+{
+        uint32_t vcoreid = hart_self();
+        temp = 0xcafebabe;
+        printf("Hello from hart_entry in vcore %d with temp addr %p and temp %p\n",
+               vcoreid, &temp, temp);
+        while(1);
+}
+
+
 int main(int argc, char** argv)
 {
        uint32_t vcoreid;
@@ -35,19 +45,14 @@ int main(int argc, char** argv)
                       vcoreid, &temp, temp);
                printf("Multi-Goodbye, world, from PID: %d!\n", sys_getpid());
                //retval = sys_resource_req(RES_CORES, 2, 0);
-               retval = hart_request(2);
+               extern void *hart_startup_arg;
+               extern void (*hart_startup)();
+               hart_startup_arg = NULL;
+               hart_startup = startup;         
+               retval = hart_request(4);
                //debug("retval = %d\n", retval);
        }
        printf("Vcore %d Done!\n", vcoreid);
        while (1);
        return 0;
 }
-
-void hart_entry(void)
-{
-       uint32_t vcoreid = hart_self();
-       temp = 0xcafebabe;
-       printf("Hello from hart_entry in vcore %d with temp addr %p and temp %p\n",
-              vcoreid, &temp, temp);
-       while(1);
-}
diff --git a/user/apps/parlib/network_init.c b/user/apps/parlib/network_init.c
deleted file mode 100644 (file)
index 32cd843..0000000
+++ /dev/null
@@ -1,39 +0,0 @@
-#include <string.h>
-#include <stdlib.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <stdio.h>
-#include <unistd.h>
-
-#include <lwip/tcpip.h>
-#include <netif/ethernetif.h>
-
-int network_init()
-{
-       printf("Starting up network stack....\n");
-
-       /* Network interface variables */
-       struct ip_addr ipaddr, netmask, gw;
-       struct netif netif;
-       /* Set network address variables */
-
-       IP4_ADDR(&gw, 192,168,0,1);
-       IP4_ADDR(&ipaddr, 192,168,0,2);
-       IP4_ADDR(&netmask, 255,255,255,0);
-
-       tcpip_init(NULL, NULL);
-
-       netif_add(&netif, &ipaddr, &netmask, &gw, NULL, ethernetif_init, ethernet_input);
-       /* ethhw_init() is user-defined */
-       /* use ip_input instead of ethernet_input for non-ethernet hardware */
-       /* (this function is assigned to netif.input and should be called by the hardware driver) */
-
-       netif_set_default(&netif);
-       netif_set_up(&netif);
-
-       printf("Going into a while loop...\n");
-
-       while(1);
-
-}
index d3013aa..e58b7e9 100644 (file)
@@ -38,6 +38,8 @@
  *
  */
 
+#include <stdio.h>
+
 #include "lwip/opt.h"
 
 #if LWIP_RAW && LWIP_ICMP /* don't build if not configured for use in lwipopts.h */
 #include "lwip/raw.h"
 #include "lwip/icmp.h"
 #include "lwip/netif.h"
+#include "lwip/dhcp.h"
 #include "lwip/sys.h"
 #include "lwip/sockets.h"
 #include "lwip/inet.h"
 #include "lwip/inet_chksum.h"
+#include <lwip/tcpip.h>
+#include <netif/ethernetif.h>
 
 /**
  * PING_DEBUG: Enable debugging for PING.
@@ -121,11 +126,39 @@ ping_prepare_echo( struct icmp_echo_hdr *iecho, u16_t len)
 
 #if LWIP_SOCKET
 
+/* Network interface variables */
+struct ip_addr ipaddr, netmask, gw;
+struct netif netif;
+/* Set network address variables */
+
+void network_init()
+{
+        printf("Starting up network stack....\n");
+
+        IP4_ADDR(&gw, 0,0,0,0);
+        IP4_ADDR(&ipaddr, 0,0,0,0);
+        IP4_ADDR(&netmask, 0,0,0,0);
+
+       netif.name[0] = 'P';
+       netif.name[1] = 'J';
+
+        tcpip_init(NULL, NULL);
+
+        netif_add(&netif, &ipaddr, &netmask, &gw, NULL, ethernetif_init, tcpip_input);
+        /* ethhw_init() is user-defined */
+        /* use ip_input instead of ethernet_input for non-ethernet hardware */
+        /* (this function is assigned to netif.input and should be called by the hardware driver) */
+
+        netif_set_default(&netif);
 
+       dhcp_start(&netif);
+        
+       printf("Done...\n");
 
+}
 
 
-void ping() {
+int main(int argc, char** argv) {
 
        printf("Starting the ping nightmare....\n");
 
@@ -134,12 +167,21 @@ void ping() {
        static struct ip_addr ping_addr;
        
        IP4_ADDR(&ping_addr, 192,168,0,3);
-       
+
+       network_init();
+
        if ((s = lwip_socket(AF_INET, SOCK_RAW, IP_PROTO_ICMP)) < 0) {
-               return;
+               return -1;
        }
 
        ping_init();
+       
+       printf("DONE STARTING PING. SPINNING\n");
+
+       while(1);
+
+       return 0;
+
 }
 
 
index f3cb3cd..a8f1453 100644 (file)
@@ -14,6 +14,7 @@ USER_LWIP_SRC_SRCFILES        := $(USER_LWIP_SRC_DIR)/api/api_msg.c \
                           $(USER_LWIP_SRC_DIR)/api/netdb.c \
                           $(USER_LWIP_SRC_DIR)/api/sockets.c \
                           $(USER_LWIP_SRC_DIR)/api/tcpip.c \
+                          $(USER_LWIP_SRC_DIR)/core/dhcp.c \
                           $(USER_LWIP_SRC_DIR)/core/init.c \
                           $(USER_LWIP_SRC_DIR)/core/sys_arch.c \
                           $(USER_LWIP_SRC_DIR)/core/mem.c \
index 0a9846a..727c254 100644 (file)
 #include "lwip/opt.h"
 #include "lwip/stats.h"
 
+#include <pthread.h>
+#include <arch/arch.h>
 
+#define sys_debug(...) //printf(__VA_ARGS__)
+
+pthread_mutex_t sys_lock;
+
+uint8_t protection_status;
+
+__thread struct sys_timeouts local_timeouts;
+
+typedef struct sys_hart_startup {
+
+        void (*hart_startup)(void* arg);
+        void *arg;
+
+} sys_hart_startup_t;
+
+// HACK
 void sys_init(void) {
-       printf("TODO: SYS_INIT\n");
-       return;
+       sys_debug("In sys_init\n");
+
+       pthread_mutex_init(&sys_lock, NULL);
+       
+       protection_status = 0;
+
+       printf("Register callback\n");
 }
 
+// HACK
 u32_t sys_now(void) {
-       printf("TODO: SYS_NOW\n");
-       return 0xDEADBEEF;
+
+       sys_debug("In sys_now\n");
+
+       uint64_t now = read_tsc();
+
+       now = now / procinfo.tsc_freq;
+
+       now = now * 1000;
+
+       return (uint32_t)now;
 }
 
+// OK
 sys_sem_t sys_sem_new(u8_t count) {
-       sys_sem_t ret = 0;
-       printf("TODO: SYS_SEM_NEW\n");
-       return ret;
-}
 
+       sys_debug("In sys_sem_new\n");
 
+       sys_sem_t sem = (sys_sem_t)malloc(sizeof(struct sys_sem));
+
+       if (sem == NULL)
+               return SYS_SEM_NULL;
+
+       pthread_mutex_init(&(sem->lock), NULL);
+
+       sem->count = count;
+
+       return sem;
+}
+
+// OK
 void sys_sem_free(sys_sem_t sem) {
-       printf("TODO: SYS_SEM_FREE\n");
+
+       sys_debug("In sys_sem_free\n");
+
+       pthread_mutex_destroy(&(sem->lock));    
+
+       free(sem);
+
        return;
 }
 
-
+// OK
 void sys_sem_signal(sys_sem_t sem) {
-       printf("TODO: SYS_SEM_SIGNAL\n");
+
+       sys_debug("In sys_sem_signal\n");
+
+       pthread_mutex_lock(&(sem->lock));
+
+       sem->count = sem->count + 1;
+
+       pthread_mutex_unlock(&(sem->lock));
+       
        return;
 }
 
-
+// OK
 u32_t sys_arch_sem_wait(sys_sem_t sem, u32_t timeout) {
-       printf("TODO: SYS ARCH SEM WAIT\n");    
-       return 0;
+
+       sys_debug("In sys_arch_sem_wait\n");
+
+       uint32_t start = sys_now();
+       uint32_t current = 0;
+
+       pthread_mutex_lock(&(sem->lock));
+
+       while (sem->count == 0) {
+
+               pthread_mutex_unlock(&(sem->lock));
+
+               current = sys_now();
+               
+               if (((current - start) > timeout) && (timeout != 0)) {
+                       return SYS_ARCH_TIMEOUT;
+               }
+
+               hart_relax();
+               
+               pthread_mutex_lock(&(sem->lock));
+       }
+
+       sem->count = sem->count - 1;
+
+       pthread_mutex_unlock(&(sem->lock));
+
+       return sys_now() - start;
 }
 
+
+//HACK
 sys_mbox_t sys_mbox_new(int size) {
-       printf("TODO: SYS MBOX NEW\n");
-       sys_mbox_t box = 0;
-       return box;
+
+       sys_debug("In sys_mbox_new\n");
+
+
+       // HACK:
+       if (size == 0)
+               size = 20;
+
+       sys_mbox_t new_box = (sys_mbox_t)malloc(sizeof(struct sys_mbox) + size * sizeof(char*));
+
+       if (new_box == NULL)
+               return SYS_MBOX_NULL;
+       memset(new_box, 0x00, sizeof(struct sys_mbox) + size * sizeof(char*));
+
+       pthread_mutex_init(&(new_box->lock), NULL);
+
+       new_box->size = size;
+       new_box->count = 0;
+       new_box->first = 0;
+       
+       return new_box;
 }
 
+// HACK
 void sys_mbox_free(sys_mbox_t mbox) {
-       printf("TODO: SYS MBOX FREE\n");
+
+       sys_debug("In sys_mbox_new\n");
+
+       
+       // Should we aquire the lock here?
+       if (mbox->count != 0) {
+               printf("LWIP Stack errror. Bad.\n");
+               return;
+       }
+
+       pthread_mutex_destroy(&(mbox->lock));
+
+       free(mbox);
+
        return;
 }
 
+
+// HACK
 void sys_mbox_post(sys_mbox_t mbox, void *msg) {
-       printf("TODO: SYS MBOX POST\n");
+
+       sys_debug("In sys_mbox_post\n");
+
+       pthread_mutex_lock(&(mbox->lock));
+
+       while(mbox->count >= mbox->size) {
+               
+               pthread_mutex_unlock(&(mbox->lock));
+               
+               hart_relax();
+               
+               pthread_mutex_lock(&(mbox->lock));
+       }
+
+       mbox->buf[(mbox->first + mbox->count) % mbox->size] = msg;
+       mbox->count = mbox->count + 1;
+       
+       pthread_mutex_unlock(&(mbox->lock));
+
        return;
 }
 
+// HACK
 err_t sys_mbox_trypost(sys_mbox_t mbox, void *msg) {
-       printf("TODO: SYS MBOX TRYPOST\n");
-       return 0;
+
+       sys_debug("In sys_mbox_trypost\n");
+
+       pthread_mutex_lock(&(mbox->lock));
+
+       if (mbox->count >= mbox->size) {
+               
+               pthread_mutex_unlock(&(mbox->lock));
+
+               return ERR_MEM;
+       }
+
+
+       mbox->buf[(mbox->first + mbox->count) % mbox->size] = msg;
+       mbox->count = mbox->count + 1;
+
+       pthread_mutex_unlock(&(mbox->lock));
+
+       return ERR_OK;
 }
 
+// HACK
 u32_t sys_arch_mbox_fetch(sys_mbox_t mbox, void **msg, u32_t timeout) {
-       printf("TODO: SYS ARCH MBOX FETCH\n");
-       return 0;
+
+       sys_debug("In sys_arch_mbox_fetch\n");
+
+       uint32_t start = sys_now();
+       uint32_t current = 0;
+
+       pthread_mutex_lock(&(mbox->lock));
+
+        while (mbox->count == 0) {
+
+                pthread_mutex_unlock(&(mbox->lock));
+
+                current = sys_now();
+
+                if (((current - start) > timeout) && (timeout != 0)) {
+                        return SYS_ARCH_TIMEOUT;
+                }
+
+                hart_relax();
+
+                pthread_mutex_lock(&(mbox->lock));
+        }
+
+       *msg = mbox->buf[mbox->first];
+
+       mbox->first = (mbox->first + 1) % (mbox->size);
+
+        mbox->count = mbox->count - 1;
+
+        pthread_mutex_unlock(&(mbox->lock));
+
+        return sys_now() - start;
 }
 
+// HACK
 u32_t sys_arch_mbox_tryfetch(sys_mbox_t mbox, void **msg) {
-       printf("TODO: SYS ARCH MBOX TRYFETCH\n");
-       return 0;
+
+       sys_debug("In sys_arch_mbox_tryfetch\n");
+
+       pthread_mutex_lock(&(mbox->lock));
+
+        if (mbox->count == 0) {
+
+                pthread_mutex_unlock(&(mbox->lock));
+
+               return SYS_MBOX_EMPTY;
+        }
+
+       *msg = mbox->buf[mbox->first];
+
+       mbox->first = (mbox->first + 1) % (mbox->size);
+
+        mbox->count = mbox->count - 1;
+
+        pthread_mutex_unlock(&(mbox->lock));
+
+        return 0;
 }
 
+// HACK
 struct sys_timeouts *sys_arch_timeouts(void) {
-       printf("TODO: SYS_TIMEOUTS\n");
-       struct sys_timeouts *ret = 0;
-       return ret;
+
+       sys_debug("In sys_timeouts\n");
+
+       return &local_timeouts;
+}
+
+void sys_thread_wrapper(void *arg) {
+
+       sys_hart_startup_t* ptr = arg;
+
+       local_timeouts.next = NULL;
+
+       ptr->hart_startup(ptr->arg);
+
+       free(ptr);
 }
 
+// HACK
 sys_thread_t sys_thread_new(char *name, void (* thread)(void *arg), void *arg, int stacksize, int prio) {
-       printf("TODO: SYS THREAD NEW\n");
-       sys_thread_t ret = 0;
-       return ret;
+
+       sys_debug("In sys_thread_new");
+
+       extern void (*hart_startup)();
+       extern void *hart_startup_arg;
+
+       sys_hart_startup_t* wrapper_arg = malloc(sizeof(sys_hart_startup_t));
+
+       if (wrapper_arg == NULL)
+               return NULL;
+
+       wrapper_arg->hart_startup = thread;
+       wrapper_arg->arg = arg;
+
+       hart_startup = sys_thread_wrapper;
+       hart_startup_arg = wrapper_arg;
+
+       hart_request(1);
+
+       return 0;
 }
 
+// HACK
 sys_prot_t sys_arch_protect(void) {
-       printf("TODO: SYS ARCH PROTECT\n");
-       sys_prot_t ret = 0;
-       return ret;
+
+       sys_debug("In sys_arch_protect\n");
+
+       pthread_mutex_lock(&sys_lock);
+
+       sys_prot_t old = protection_status;
+
+       protection_status = 1;
+
+       pthread_mutex_unlock(&sys_lock);
+
+       return old;
 }
 
+// HACK
 void sys_arch_unprotect(sys_prot_t pval) {
-       printf("TODO: SYS ARCH UNPROTECT\n");
-       return;
+
+       sys_debug("In sys_arch_unprotect\n");
+
+       pthread_mutex_lock(&sys_lock);
+
+       protection_status = pval;
+
+       pthread_mutex_unlock(&sys_lock);
+
 }
 
index 7e6a2c9..0344d15 100644 (file)
 #ifndef __ARCH_SYS_ARCH_H__
 #define __ARCH_SYS_ARCH_H__
 
+// Don't reverse the order of these includes. Newlib uglyness.
+#include <pthread.h>
 #include <errno.h>
 
 #define SYS_MBOX_NULL NULL
 #define SYS_SEM_NULL  NULL
 
-typedef u32_t sys_prot_t;
+typedef u8_t sys_prot_t;
 
-struct sys_sem;
-typedef struct sys_sem * sys_sem_t;
+struct sys_sem {
+       pthread_mutex_t lock;
+       uint8_t count;
+};
 
-struct sys_mbox;
+// I hate this I hate this I hate this I hate this. -Paul
+typedef struct sys_sem* sys_sem_t;
+
+
+struct sys_mbox {
+       pthread_mutex_t lock;
+       int size;
+       int count;
+       int first;
+       char* buf[];
+};
 typedef struct sys_mbox *sys_mbox_t;
 
 struct sys_thread;
index fc51cee..b75260e 100644 (file)
@@ -3,6 +3,12 @@
 #define LWIP_SOCKET 1
 #define LWIP_NETCONN 1
 #define LWIP_TCP 1
+#define SYS_LIGHTWEIGHT_PROT 1
+#define LWIP_DHCP 1
+
+#define TCP_SND_BUF 1096
+//#define MEMP_NUM_TCP_SEG 32
 #define ETHARP_DEBUG LWIP_DBG_ON
 #define NETIF_DEBUG LWIP_DBG_ON
 #define PBUF_DEBUG LWIP_DBG_ON
index cf3d5a1..bbd6122 100644 (file)
@@ -40,9 +40,7 @@ low_level_init(struct netif *netif)
         netif->hwaddr_len = ETHARP_HWADDR_LEN;
 
         /* set MAC hardware address */
-       printf("buffer addr: %u\n", netif->hwaddr);
        sys_eth_get_mac_addr(&(netif->hwaddr));
-       printf("chkpt\n");
         /* maximum transfer unit */
         netif->mtu = 1500;