Added Ivy annotations to Paul's recent commit
authorZach Anderson <zra@zra-intrepid.(none)>
Thu, 17 Sep 2009 23:30:48 +0000 (16:30 -0700)
committerZach Anderson <zra@zra-intrepid.(none)>
Thu, 17 Sep 2009 23:30:48 +0000 (16:30 -0700)
GNUmakefile
kern/arch/i386/ne2k.c
kern/arch/i386/rl8168.c
kern/arch/i386/rl8168.h
kern/src/init.c
kern/src/syscall.c
user/parlib/inc/libc_patch.h
user/parlib/inc/newlib_backend.h
user/parlib/src/i386/newlib_backend.c

index 2976206..f9f6bd3 100644 (file)
@@ -55,7 +55,8 @@ KERN_CFLAGS := --deputy\
                   --no-rc-sharc\
                   --sc-dynamic-is-error\
                   --sc-ops=$(INCLUDE_DIR)/ivy/sharc.h\
-                  --sc-all-in-thread
+                  --sc-all-in-thread\
+                  --enable-precompile
 USER_CFLAGS := --deputy --enable-error-db
 CC         := ivycc --gcc=$(GCCPREFIX)gcc
 else
index 911c30f..8634f8c 100644 (file)
@@ -3,10 +3,6 @@
  * See LICENSE for details.
  */
 
-#ifdef __DEPUTY__
-#pragma nodeputy
-#endif
-
 #ifdef __SHARC__
 #pragma nosharc
 #endif
@@ -160,7 +156,12 @@ void ne2k_setup_interrupts() {
        ne2k_debug("-->Setting interrupts.\n");
        
        // Kernel based interrupt stuff
+#ifdef __IVY__
+       register_interrupt_handler(interrupt_handlers, KERNEL_IRQ_OFFSET + ne2k_irq, ne2k_interrupt_handler, (void *)0);
+#else
        register_interrupt_handler(interrupt_handlers, KERNEL_IRQ_OFFSET + ne2k_irq, ne2k_interrupt_handler, 0);
+#endif
+
        
        ioapic_route_irq(ne2k_irq, 6);  
        
index 4ffc499..4beb753 100644 (file)
 #pragma nosharc
 #endif
 
-#ifdef __DEPUTY__
-#pragma nodeputy
-#endif
-
 #include <arch/mmu.h>
 #include <arch/x86.h>
 #include <arch/smp.h>
@@ -95,11 +91,11 @@ uint32_t rl8168_io_base_addr = 0;
 uint32_t rl8168_irq = 0;
 char device_mac[6];
 
-struct Descriptor *rx_des_kva;
-struct Descriptor *rx_des_pa;
+struct Descriptor *CT(NUM_RX_DESCRIPTORS) rx_des_kva;
+unsigned long rx_des_pa;
 
-struct Descriptor *tx_des_kva;
-struct Descriptor *tx_des_pa;
+struct Descriptor *CT(NUM_TX_DESCRIPTORS) tx_des_kva;
+unsigned long tx_des_pa;
 
 uint32_t rx_des_cur = 0;
 uint32_t tx_des_cur = 0;
@@ -109,8 +105,8 @@ uint8_t eth_up = 0; // TODO: This needs to be somewhere global.
 // Hacky stuff for syscall hack. Go away.
 int packet_waiting;
 int packet_buffer_size;
-char* packet_buffer;
-char* packet_buffer_orig;
+char *CT(packet_buffer_size) packet_buffer;
+char *CT(MAX_FRAME_SIZE) packet_buffer_orig;
 int packet_buffer_pos = 0;
 // End hacky stuff
 
@@ -225,8 +221,8 @@ void rl8168_setup_descriptors() {
        if (rx_des_kva == NULL) panic("Can't allocate page for RX Ring");
        if (tx_des_kva == NULL) panic("Can't allocate page for TX Ring");
        
-       rx_des_pa = (struct Descriptor *)PADDR(rx_des_kva);
-       tx_des_pa = (struct Descriptor *)PADDR(tx_des_kva);
+       rx_des_pa = PADDR(rx_des_kva);
+       tx_des_pa = PADDR(tx_des_kva);
        
     for (int i = 0; i < NUM_RX_DESCRIPTORS; i++) 
                rl8168_set_rx_descriptor(i, TRUE); // Allocate memory for the descriptor
@@ -345,7 +341,11 @@ void rl8168_setup_interrupts() {
        outw(rl8168_io_base_addr + RL_IS_REG, RL_INTRRUPT_CLEAR);
        
        // Kernel based interrupt stuff
+#ifdef __IVY__
+       register_interrupt_handler(interrupt_handlers, KERNEL_IRQ_OFFSET + rl8168_irq, rl8168_interrupt_handler, (void *)0);
+#else
        register_interrupt_handler(interrupt_handlers, KERNEL_IRQ_OFFSET + rl8168_irq, rl8168_interrupt_handler, 0);
+#endif
        ioapic_route_irq(rl8168_irq, NE2K_IRQ_CPU);     
        
        return;
@@ -528,14 +528,14 @@ void rl8168_handle_rx_packet() {
        if ((current_command & DES_PAM_MASK) && (*((uint16_t*)(rx_buffer + 36)) == 0x9bad)) {
                
                if (packet_waiting) return;
-
-               packet_buffer = rx_buffer + PACKET_HEADER_SIZE;
                
                // So ugly I want to cry
                packet_buffer_size = *((uint16_t*)(rx_buffer + 38)); 
                packet_buffer_size = (((uint16_t)packet_buffer_size & 0xff00) >> 8) |  (((uint16_t)packet_buffer_size & 0x00ff) << 8);          
                packet_buffer_size = packet_buffer_size - 8;
 
+               packet_buffer = rx_buffer + PACKET_HEADER_SIZE;
+
                packet_buffer_orig = rx_buffer;
                packet_buffer_pos = 0;
                
@@ -675,32 +675,7 @@ char *rl8168_packet_wrap(const char* data, size_t len) {
 
        if ((len == 0) || (data == NULL))
                return NULL;
-       
-       struct ETH_Header
-       {
-               char dest_mac[6];
-               char source_mac[6];
-               uint16_t eth_type;
-       };
-
-       
-       struct IP_Header
-       {
-               uint32_t ip_opts0;
-               uint32_t ip_opts1;
-               uint32_t ip_opts2;
-               uint32_t source_ip;
-               uint32_t dest_ip;
-       };
-       
-       struct UDP_Header
-       {
-               uint16_t source_port;
-               uint16_t dest_port;
-               uint16_t length;
-               uint16_t checksum;
-       };      
-       
+
        // Hard coded to paul's laptop's mac
        //Format for Makelocal file: -DUSER_MAC_ADDRESS="{0x00, 0x23, 0x32, 0xd5, 0xae, 0x82}"
        char dest_mac_address[6] = USER_MAC_ADDRESS;
@@ -715,16 +690,17 @@ char *rl8168_packet_wrap(const char* data, size_t len) {
                return NULL;
        }
        
-       char* wrap_buffer = kmalloc(MAX_PACKET_SIZE, 0);
+       struct rl8168_packet* wrap_buffer = kmalloc(MAX_PACKET_SIZE, 0);
        
        if (wrap_buffer == NULL) {
                rl8168_frame_debug("Can't allocate page for packet wrapping");
                return NULL;
        }
        
-       struct ETH_Header *eth_header = (struct ETH_Header*) wrap_buffer;
-       struct IP_Header *ip_header = (struct IP_Header*) (wrap_buffer + sizeof(struct ETH_Header));
-       struct UDP_Header *udp_header = (struct UDP_Header*) (wrap_buffer + sizeof(struct ETH_Header) + sizeof(struct IP_Header));
+
+       struct ETH_Header *eth_header = &wrap_buffer->rl8168_head.eth_head;
+       struct IP_Header *ip_header = &wrap_buffer->rl8168_head.ip_head;
+       struct UDP_Header *udp_header = &wrap_buffer->rl8168_head.udp_head;
        
        // Setup eth data
        for (int i = 0; i < 6; i++) 
@@ -748,7 +724,7 @@ char *rl8168_packet_wrap(const char* data, size_t len) {
        udp_header->length = htons(8 + len);
        udp_header->checksum = 0;
        
-       memcpy (wrap_buffer + PACKET_HEADER_SIZE, data, len);
+       memcpy (&wrap_buffer->data[0], data, len);
        
-       return wrap_buffer;     
+       return (char *CT(PACKET_HEADER_SIZE + len))wrap_buffer; 
 }
index 03b2365..8d546a8 100644 (file)
 // v----- Evil line ------v
 // Hacky stuff for syscalls go away.
 
+struct ETH_Header
+{
+       char dest_mac[6];
+       char source_mac[6];
+       uint16_t eth_type;
+};
+
+
+struct IP_Header
+{
+       uint32_t ip_opts0;
+       uint32_t ip_opts1;
+       uint32_t ip_opts2;
+       uint32_t source_ip;
+       uint32_t dest_ip;
+};
+
+struct UDP_Header
+{
+       uint16_t source_port;
+       uint16_t dest_port;
+       uint16_t length;
+       uint16_t checksum;
+};     
+
 #define MINIMUM_PACKET_SIZE 14 // kinda evil. probably evil.
 #define MAX_PACKET_SIZE                MTU
 
-#define PACKET_HEADER_SIZE  20 + 8 + 14 //IP UDP ETH
+#define PACKET_HEADER_SIZE  sizeof(struct rl8168_header) //IP UDP ETH
 #define MAX_PACKET_DATA                MAX_FRAME_SIZE - PACKET_HEADER_SIZE
 // This number needs verification! Also, this is a huge hack, as the driver shouldnt care about UDP/IP etc.
 
-char *rl8168_packet_wrap(const char* data, size_t len);
+struct rl8168_header {
+       struct ETH_Header eth_head;
+       struct IP_Header ip_head;
+       struct UDP_Header udp_head;
+};
+
+struct rl8168_packet {
+       struct rl8168_header rl8168_head;
+       char data[MTU-PACKET_HEADER_SIZE];
+} __attribute__((packed));
+
+char *CT(PACKET_HEADER_SIZE + len)
+rl8168_packet_wrap(const char *CT(len) data, size_t len);
 
 
 // ^----- Evil line ------^
@@ -143,7 +180,8 @@ void rl8168_configure(void);
 void rl8168_handle_rx_packet(void);
 void rl8168_set_rx_descriptor(uint32_t des_num, uint8_t reset_buffer);
 void rl8168_set_tx_descriptor(uint32_t des_num);
-void rl8168_process_frame(char *frame_buffer, uint32_t frame_size, uint32_t command);
-int rl8168_send_frame(const char *data, size_t len);
+void rl8168_process_frame(char *CT(frame_size) frame_buffer,
+                          uint32_t frame_size, uint32_t command);
+int rl8168_send_frame(const char *CT(len) data, size_t len);
 
 #endif /* !ROS_INC_REALTEK_H */
index 04b009d..3981ea2 100644 (file)
 #include <manager.h>
 #include <testing.h>
 
+#ifdef __i386__
 #include <arch/rl8168.h>
 #include <arch/ne2k.h>
 #include <arch/mptables.h>
 #include <arch/pci.h>
 #include <arch/ioapic.h>
+#endif
 
 void kernel_init(multiboot_info_t *mboot_info)
 {
index e5b270d..b376acd 100644 (file)
@@ -4,10 +4,6 @@
 #pragma nosharc
 #endif
 
-#ifdef __DEPUTY__
-#pragma nodeputy
-#endif
-
 #include <ros/common.h>
 #include <arch/types.h>
 #include <arch/arch.h>
@@ -70,14 +66,20 @@ static ssize_t sys_serial_read(env_t* e, char *DANGEROUS _buf, size_t len)
 /* START OF REMOTE SYSTEMCALL SUPPORT SYSCALLS. THESE WILL GO AWAY AS THINGS MATURE */
 //
 
-static ssize_t sys_run_binary(env_t* e, void *binary_buf, void* arg, size_t len) {
+static ssize_t sys_run_binary(env_t* e, void *DANGEROUS binary_buf,
+                              void*DANGEROUS arg, size_t len) {
+       uint8_t *CT(len) checked_binary_buf;
+       checked_binary_buf = user_mem_assert(e, binary_buf, len, PTE_USER_RO);
+#if 0
+       zra: copied into new address space, so no copy needed here.
        uint8_t* new_binary = kmalloc(len, 0);
        if(new_binary == NULL)
                return -ENOMEM;
-       memcpy(new_binary, binary_buf, len);
+       memcpy(new_binary, checked_binary_buf, len);
+#endif
 
-       env_t* env = env_create((uint8_t*)new_binary, len);
-       kfree(new_binary);
+       env_t* env = env_create(checked_binary_buf, len);
+       //kfree(new_binary);
        proc_set_state(env, PROC_RUNNABLE_S);
        schedule_proc(env);
        sys_yield(e);
@@ -99,7 +101,7 @@ static ssize_t sys_eth_write(env_t* e, const char *DANGEROUS buf, size_t len)
                int cur_packet_len = 0;
                while (total_sent != len) {
                        cur_packet_len = ((len - total_sent) > MAX_PACKET_DATA) ? MAX_PACKET_DATA : (len - total_sent);
-                       char* wrap_buffer = packet_wrap(buf + total_sent, cur_packet_len);
+                       char* wrap_buffer = packet_wrap(_buf + total_sent, cur_packet_len);
                        just_sent = send_frame(wrap_buffer, cur_packet_len + PACKET_HEADER_SIZE);
                        
                        if (just_sent < 0)
@@ -122,20 +124,21 @@ static ssize_t sys_eth_write(env_t* e, const char *DANGEROUS buf, size_t len)
 static ssize_t sys_eth_read(env_t* e, char *DANGEROUS buf, size_t len) 
 {
        extern int eth_up;
-       
+
        if (eth_up) {
                extern int packet_waiting;
                extern int packet_buffer_size;
-               extern char* packet_buffer;
-               extern char* packet_buffer_orig;
+               extern char*CT(packet_buffer_size) packet_buffer;
+               extern char*CT(MAX_FRAME_SIZE) packet_buffer_orig;
                extern int packet_buffer_pos;
+               char *CT(len) _buf = user_mem_assert(e, buf,len, PTE_U);
                        
                if (packet_waiting == 0)
                        return 0;
                        
                int read_len = ((packet_buffer_pos + len) > packet_buffer_size) ? packet_buffer_size - packet_buffer_pos : len;
 
-               memcpy(buf, packet_buffer + packet_buffer_pos, read_len);
+               memcpy(_buf, packet_buffer + packet_buffer_pos, read_len);
        
                packet_buffer_pos = packet_buffer_pos + read_len;
        
index cf92096..bca81dd 100644 (file)
@@ -231,7 +231,7 @@ int chmod(const STRING __path, __MODE_T __mode);
 int mkdir(const STRING __path, __MODE_T __mode);
 int mkfifo(const STRING __path, __MODE_T __mode);
 int stat(const STRING __path, struct stat * SAFE NONNULL __sbuf);
-
+int fstat(int fd, struct stat * SAFE NONNULL __sbuf);
 int lstat(const STRING __path, struct stat * SAFE NONNULL __sbuf);
 int _stat(const STRING __path, struct stat * SAFE NONNULL __sbuf);
 
index 2ee9e4d..777faf4 100644 (file)
@@ -7,17 +7,7 @@
 #include <errno.h>
 #include <sys/stat.h>
 
-#define OPEN_ID                0
-#define CLOSE_ID       1
-#define READ_ID                2
-#define WRITE_ID       3
-#define LINK_ID                4
-#define UNLINK_ID      5
-#define LSEEK_ID       6
-#define FSTAT_ID       7
-#define ISATTY_ID      8
-#define STAT_ID                9
-#define NUM_CALLS      10
+
 
 #define debug_in_out(...) // debug(__VA_ARGS__)  
 #define debug_write_check(fmt, ...)  //debug(fmt, __VA_ARGS__)
@@ -31,7 +21,7 @@ typedef struct open_subheader {
        uint32_t flags;
        uint32_t mode;
        uint32_t len;
-       char buf[0];
+       char (CT(len) buf)[0];
 } open_subheader_t;
 
 typedef struct close_subheader {
@@ -50,7 +40,7 @@ typedef struct write_subheader {
        uint32_t fd;
        uint32_t len;
        uint32_t FILL1;
-       char buf[0];
+       char (CT(len) buf)[0];
 } write_subheader_t;
 
 typedef struct lseek_subheader {
@@ -69,14 +59,14 @@ typedef struct link_subheader {
        uint32_t old_len;
        uint32_t new_len;
        uint32_t FILL1;
-       char buf[0];
+       char (CT(old_len + new_len) buf)[0];
 } link_subheader_t;
 
 typedef struct unlink_subheader {
        uint32_t len;
        uint32_t FILL1;
        uint32_t FILL2;
-       char buf[0];
+       char (CT(len) buf)[0];
 } unlink_subheader_t;
 
 typedef struct fstat_subheader {
@@ -89,22 +79,34 @@ typedef struct stat_subheader {
        uint32_t len;
        uint32_t FILL1;
        uint32_t FILL2;
-       char buf[0];
+       char (CT(len) buf)[0];
 } stat_subheader_t;
 
+#define OPEN_ID                0
+#define CLOSE_ID       1
+#define READ_ID                2
+#define WRITE_ID       3
+#define LINK_ID                4
+#define UNLINK_ID      5
+#define LSEEK_ID       6
+#define FSTAT_ID       7
+#define ISATTY_ID      8
+#define STAT_ID                9
+#define NUM_CALLS      10
+
 typedef struct backend_msg {
        syscall_id_t id;
        union {
-               open_subheader_t open;
-               close_subheader_t close;
-               read_subheader_t read;
-               write_subheader_t write;
-               lseek_subheader_t lseek;
-               isatty_subheader_t isatty;
-               link_subheader_t link;
-               unlink_subheader_t unlink;
-               fstat_subheader_t fstat;
-               stat_subheader_t stat;  
+               open_subheader_t open WHEN(id == OPEN_ID);
+               close_subheader_t close WHEN(id == CLOSE_ID);
+               read_subheader_t read WHEN(id == READ_ID);
+               write_subheader_t write WHEN(id == WRITE_ID);
+               lseek_subheader_t lseek WHEN(id == LSEEK_ID);
+               isatty_subheader_t isatty WHEN(id == ISATTY_ID);
+               link_subheader_t link WHEN(id == LINK_ID);
+               unlink_subheader_t unlink WHEN(id == UNLINK_ID);
+               fstat_subheader_t fstat WHEN(id == FSTAT_ID);
+               stat_subheader_t stat WHEN(id == STAT_ID);      
        };
 } msg_t;
 
@@ -112,7 +114,7 @@ typedef struct response {
        int32_t ret;
        uint32_t err;
        struct stat st;
-       char buf[0];
+       char (CT(ret) buf)[0];
 } response_t;
 
 
@@ -135,10 +137,10 @@ typedef struct response {
  *              However once some data is available,
  *                      will block until the entire amount is available.
  */
-int read_from_channel(char * buf, int len, int peek);
+int read_from_channel(char *CT(len) buf, int len, int peek);
 
-int read_response_from_channel(response_t *response);
-int read_buffer_from_channel(char *buf, int len);
+int read_response_from_channel(response_t *CT(1) response);
+int read_buffer_from_channel(char *CT(len) buf, int len);
 
 
 /* send_message()
index 324bc9e..8084567 100644 (file)
  *
  */
 
-#ifdef __DEPUTY__
-#pragma nodeputy
-#endif
-
 #include <parlib.h>
 #include <unistd.h>
 #include <newlib_backend.h>
@@ -349,12 +345,13 @@ int open(const char *name, int flags, int mode)
  */
 ssize_t read(int file, void *ptr, size_t len) 
 {
+       uint8_t *CT(len) _ptr = ptr;
        debug_in_out("READ\n");
 
        // Console hack.
        if (file == STDIN_FILENO) {
                for(int i=0; i<len; i++)        
-                       ((uint8_t*)ptr)[i] = sys_cgetc();
+                       _ptr[i] = (uint8_t)sys_cgetc();
                return len;
        }
 
@@ -383,7 +380,7 @@ ssize_t read(int file, void *ptr, size_t len)
                if (return_val < 0)
                        errno = result->err;
                else
-                       memcpy(ptr, result->buf, return_val);
+                       memcpy(_ptr, result->buf, return_val);
 
                free(result);
        }
@@ -425,7 +422,7 @@ int read_from_channel(char * buf, int len, int peek)
 
 int read_response_from_channel(response_t *response) 
 {
-       return read_from_channel(       (char*) response
+       return read_from_channel(       (char*CT(sizeof(response_t))) TC(response)
                                                        sizeof(response_t), 
                                                                NO_PEEK);
 }
@@ -451,15 +448,15 @@ void* sbrk(ptrdiff_t incr)
 
        #define HEAP_SIZE (1<<18)
        static uint8_t array[HEAP_SIZE];
-       static uint8_t* heap_end = array;
-       static uint8_tstack_ptr = &(array[HEAP_SIZE-1]);
+       static uint8_t *BND(array, array + HEAP_SIZE) heap_end = array;
+       static uint8_t *stack_ptr = &(array[HEAP_SIZE-1]);
 
        uint8_t* prev_heap_end; 
 
        prev_heap_end = heap_end;
        if (heap_end + incr > stack_ptr) {
                errno = ENOMEM;
-               return (void*)-1;
+               return (void*CT(1))TC(-1);
        }
      
        heap_end += incr;
@@ -681,6 +678,6 @@ ssize_t write(int file, const void *ptr, size_t len) {
 int write_to_channel(msg_t * msg, int len)
 {
        //return sys_serial_write((char*)msg, len);
-       return sys_eth_write((char*)msg, len);
+       return sys_eth_write((char*CT(sizeof(msg_t)))TC(msg), len);
        
 }