Cleaned up the return values for all system calls.
authorKevin Klues <klueska@cs.berkeley.edu>
Sat, 30 May 2009 09:55:06 +0000 (02:55 -0700)
committerKevin Klues <klueska@cs.berkeley.edu>
Fri, 5 Jun 2009 01:16:42 +0000 (18:16 -0700)
Defined a type intreg_t and uintreg_t to denote values stored into variables in a platform
independent manner.  This type is now returned by the top level syscall handler, with the
semantics of its meaning needing to be interpreted by the caller upon its return.  Also cleaned
up a bit of newlib backends handling of the standard stream file descriptors.

15 files changed:
include/arch/types.h
include/ros/syscall.h
kern/src/Makefrag
kern/src/manager.c
kern/src/syscall.c
user/apps/parlib/matrix.c [new file with mode: 0644]
user/apps/parlib/my_ls.c [new file with mode: 0755]
user/apps/parlib/open_read.c
user/parlib/inc/parlib.h
user/parlib/src/debug.c
user/parlib/src/newlib_backend.c
user/parlib/src/syscall.c
user/roslib/inc/lib.h
user/roslib/inc/stdio.h
user/roslib/src/syscall.c

index d1f7a21..4ef863b 100644 (file)
@@ -34,6 +34,10 @@ 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;
 
index 5593b0e..da15bd4 100644 (file)
@@ -1,5 +1,5 @@
-#ifndef ROS_INC_SYSCALL_H
-#define ROS_INC_SYSCALL_H
+#ifndef ROS_INCLUDE_SYSCALL_H
+#define ROS_INCLUDE_SYSCALL_H
 
 #include <arch/types.h>
 #include <ros/ring_buffer.h>
@@ -27,6 +27,13 @@ enum
 // syscall number starts at 1 and goes up to NSYSCALLS, without holes.
 #define INVALID_SYSCALL(syscallno) ((syscallno) > NSYSCALLS)
 
+//intreg_t syscall_sysenter(uint16_t num, intreg_t a1,
+//                          intreg_t a2, intreg_t a3,
+//                          intreg_t a4, intreg_t a5);
+int32_t syscall_sysenter(uint16_t num, int32_t a1,
+                         int32_t a2, int32_t a3,
+                         int32_t a4, int32_t a5);
+
 #define NUM_SYS_ARGS 6
 typedef struct syscall_req {
        uint32_t num;
@@ -52,7 +59,4 @@ struct syscall_desc {
 };
 LIST_HEAD(syscall_desc_list_t, syscall_desc_t);
 
-static uint32_t
-syscall_sysenter(int num, uint32_t a1, uint32_t a2, uint32_t a3, uint32_t a4, uint32_t a5);
-
-#endif /* !ROS_INC_SYSCALL_H */
+#endif /* !ROS_INCLUDE_SYSCALL_H */
index 6d3de32..dc43680 100644 (file)
@@ -39,8 +39,9 @@ KERN_SRCFILES := $(KERN_SRC_DIR)/entry.S \
 # Only build files if they exist.
 KERN_SRCFILES := $(wildcard $(KERN_SRCFILES))
 
-KERN_APPFILES :=       $(USER_APPS_ROSLIB_DIR)/null \
-                    $(USER_APPS_PARLIB_DIR)/open_read 
+KERN_APPFILES :=       $(USER_APPS_PARLIB_DIR)/matrix 
+#                    $(USER_APPS_PARLIB_DIR)/open_read \
+#                    $(USER_APPS_ROSLIB_DIR)/null
 #                                      $(USER_APPS_ROSLIB_DIR)/hello \
 #                                      apps/hello \
 #                                      apps_newlib/null \
index a274fb5..fb0ebd1 100644 (file)
@@ -42,52 +42,9 @@ void manager(void)
        
        if(progress == 0) {
                progress++;
-               env_batch[0] = ENV_CREATE(parlib_open_read);
+               env_batch[0] = ENV_CREATE(parlib_matrix);
                env_run(env_batch[0]);
        }
        return;
-
-       switch (progress++) {
-               case 0:
-                       
-                       for (int i = 2; i < 8; i++)
-                               env_batch[i] = ENV_CREATE(parlib_open_read);
-                       for (int i = 2; i < 8; i++)
-                               smp_call_function_single(i, run_env_handler, env_batch[i], 0);
-                       int count = 0;
-                       while (count > -6) {
-                               count = 0;
-                               for (int i = 2; i < 8; i++) {
-                                       count += process_generic_syscalls(env_batch[i], 1);
-                               }
-                               cpu_relax();
-                       }
-                       process_workqueue(); // Will run this core (0)'s env
-                       panic("Don't Panic");
-                       break; // only need this when planning to reenter manager
-               case 1:
-                       for (int i = 0; i < 4; i++)
-                               env_batch[i] = ENV_CREATE(roslib_null);
-                       for (int i = 0; i < 4; i++)
-                               smp_call_function_single(i, run_env_handler, env_batch[i], 0);
-                       //env_t* an_env = ENV_CREATE(user_null);
-                       //env_run(an_env);
-                       //smp_call_function_single(2, run_env_handler, an_env, 0);
-                       process_workqueue();
-                       break;
-               default:
-                       printk("Waiting 5 sec for whatever reason\n");
-                       udelay(5000000);
-                       panic("Don't Panic");
-       }
-       panic("If you see me, then you probably screwed up");
-
-       /*
-       printk("Servicing syscalls from Core 0:\n\n");
-       while (1) {
-               process_generic_syscalls(&envs[0], 1);
-               cpu_relax();
-       }
-       */
 }
 
index e48ea40..784b4c2 100644 (file)
@@ -3,6 +3,7 @@
 #pragma nodeputy
 #endif
 
+#include <arch/types.h>
 #include <arch/x86.h>
 #include <arch/console.h>
 #include <arch/apic.h>
@@ -19,13 +20,13 @@ void syscall_wrapper(struct Trapframe *tf)
        env_t* curenv = curenvs[lapic_get_id()];
     curenv->env_tf = *tf;
     tf->tf_regs.reg_eax =
-        syscall(curenv,
-                               tf->tf_regs.reg_eax,
-                tf->tf_regs.reg_edx,
-                tf->tf_regs.reg_ecx,
-                tf->tf_regs.reg_ebx,
-                tf->tf_regs.reg_edi,
-                               0);
+           (intreg_t) syscall(curenv,
+                              tf->tf_regs.reg_eax,
+                              tf->tf_regs.reg_edx,
+                              tf->tf_regs.reg_ecx,
+                              tf->tf_regs.reg_ebx,
+                              tf->tf_regs.reg_edi,
+                              0);
     return;
 }
 
@@ -36,25 +37,25 @@ static void sys_null(void)
 }
 
 //Write a buffer over the serial port
-static uint16_t sys_serial_write(env_t* e, const char *DANGEROUS buf, uint16_t len) 
+static ssize_t sys_serial_write(env_t* e, const char *DANGEROUS buf, size_t len) 
 {
        char *COUNT(len) _buf = user_mem_assert(e, buf, len, PTE_U);
        for(int i =0; i<len; i++)
                serial_send_byte(buf[i]);       
-       return len;
+       return (ssize_t)len;
 }
 
 //Read a buffer over the serial port
-static uint16_t sys_serial_read(env_t* e, char *DANGEROUS buf, uint16_t len) 
+static ssize_t sys_serial_read(env_t* e, char *DANGEROUS buf, size_t len) 
 {
     char *COUNT(len) _buf = user_mem_assert(e, buf, len, PTE_U);
-       uint16_t bytes_read = 0;
+       size_t bytes_read = 0;
        int c;
        while((c = serial_read_byte()) != -1) {
                buf[bytes_read++] = (uint8_t)c;
                if(bytes_read == len) break;
        }
-       return bytes_read;
+       return (ssize_t)bytes_read;
 }
 
 // Invalidate the cache of this core
@@ -79,40 +80,39 @@ static void sys_cache_buster(env_t* e, uint32_t num_writes, uint32_t val)
        for (int i = 0; i < MIN(num_writes, MAX_WRITES); i++)
                buster[i] = val;
        spin_unlock(&buster_lock);
+       return;
 }
 
 // Print a string to the system console.
 // The string is exactly 'len' characters long.
 // Destroys the environment on memory errors.
-static void
-sys_cputs(env_t* e, const char *DANGEROUS s, size_t len)
+static ssize_t sys_cputs(env_t* e, const char *DANGEROUS s, size_t len)
 {
        // Check that the user has permission to read memory [s, s+len).
        // Destroy the environment if not.
     char *COUNT(len) _s = user_mem_assert(e, s, len, PTE_U);
 
        // Print the string supplied by the user.
-       cprintf("%.*s", len, _s);
+       printk("%.*s", len, _s);
+       return (ssize_t)len;
 }
 
 // Read a character from the system console.
 // Returns the character.
-static int
-sys_cgetc(env_t* e)
+static uint16_t sys_cgetc(env_t* e)
 {
-       int c;
+       uint16_t c;
 
        // The cons_getc() primitive doesn't wait for a character,
        // but the sys_cgetc() system call does.
        while ((c = cons_getc()) == 0)
-               /* do nothing */;
+               cpu_relax();
 
        return c;
 }
 
 // Returns the current environment's envid.
-static envid_t
-sys_getenvid(env_t* e)
+static envid_t sys_getenvid(env_t* e)
 {
        return e->env_id;
 }
@@ -128,8 +128,7 @@ static envid_t sys_getcpuid(void)
 // Returns 0 on success, < 0 on error.  Errors are:
 //     -E_BAD_ENV if environment envid doesn't currently exist,
 //             or the caller doesn't have permission to change envid.
-static int
-sys_env_destroy(env_t* e, envid_t envid)
+static error_t sys_env_destroy(env_t* e, envid_t envid)
 {
        int r;
        env_t *env_to_die;
@@ -137,9 +136,9 @@ sys_env_destroy(env_t* e, envid_t envid)
        if ((r = envid2env(envid, &env_to_die, 1)) < 0)
                return r;
        if (env_to_die == e)
-               cprintf("[%08x] exiting gracefully\n", e->env_id);
+               printk("[%08x] exiting gracefully\n", e->env_id);
        else
-               cprintf("[%08x] destroying %08x\n", e->env_id, env_to_die->env_id);
+               printk("[%08x] destroying %08x\n", e->env_id, env_to_die->env_id);
        env_destroy(env_to_die);
        return 0;
 }
@@ -147,13 +146,15 @@ sys_env_destroy(env_t* e, envid_t envid)
 
 // TODO: Build a dispatch table instead of switching on the syscallno
 // Dispatches to the correct kernel function, passing the arguments.
-int32_t syscall(env_t* e, uint32_t syscallno, uint32_t a1, uint32_t a2,
+intreg_t syscall(env_t* e, uint32_t syscallno, uint32_t a1, uint32_t a2,
                 uint32_t a3, uint32_t a4, uint32_t a5)
 {
        // Call the function corresponding to the 'syscallno' parameter.
        // Return any appropriate return value.
 
-       //cprintf("Incoming syscall number: %d\n    a1: %x\n    a2: %x\n    a3: %x\n    a4: %x\n    a5: %x\n", syscallno, a1, a2, a3, a4, a5);
+       //cprintf("Incoming syscall number: %d\n    a1: %x\n   "
+       //        " a2: %x\n    a3: %x\n    a4: %x\n    a5: %x\n", 
+       //        syscallno, a1, a2, a3, a4, a5);
 
        assert(e); // should always have an env for every syscall
        //printk("Running syscall: %d\n", syscallno);
@@ -176,8 +177,7 @@ int32_t syscall(env_t* e, uint32_t syscallno, uint32_t a1, uint32_t a2,
                        sys_cache_buster(e, a1, a2);
                        return 0;
                case SYS_cputs:
-                       sys_cputs(e, (char *DANGEROUS)a1, (size_t)a2);
-                       return 0;  // would rather have this return the number of chars put.
+                       return sys_cputs(e, (char *DANGEROUS)a1, (size_t)a2);
                case SYS_cgetc:
                        return sys_cgetc(e);
                case SYS_getenvid:
@@ -193,15 +193,15 @@ int32_t syscall(env_t* e, uint32_t syscallno, uint32_t a1, uint32_t a2,
        return 0xdeadbeef;
 }
 
-int32_t syscall_async(env_t* e, syscall_req_t *call)
+intreg_t syscall_async(env_t* e, syscall_req_t *call)
 {
        return syscall(e, call->num, call->args[0], call->args[1],
                       call->args[2], call->args[3], call->args[4]);
 }
 
-int32_t process_generic_syscalls(env_t* e, uint32_t max)
+intreg_t process_generic_syscalls(env_t* e, size_t max)
 {
-       uint32_t count = 0;
+       size_t count = 0;
        syscall_back_ring_t* sysbr = &e->env_sysbackring;
 
        // make sure the env is still alive.  incref will return 0 on success.
@@ -235,5 +235,5 @@ int32_t process_generic_syscalls(env_t* e, uint32_t max)
                           sysbr->sring->req_prod, sysbr->sring->rsp_prod);
        }
        env_decref(e);
-       return count;
+       return (intreg_t)count;
 }
diff --git a/user/apps/parlib/matrix.c b/user/apps/parlib/matrix.c
new file mode 100644 (file)
index 0000000..a5aaff2
--- /dev/null
@@ -0,0 +1,13 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <time.h>
+#include <unistd.h>
+#include <sys/stat.h>
+
+int main(int argc, char** argv)
+{
+
+       printf("Welcome to the ROS newlib test suite!\nEnter at you're own risk....\n");
+       return 0;
+}
diff --git a/user/apps/parlib/my_ls.c b/user/apps/parlib/my_ls.c
new file mode 100755 (executable)
index 0000000..9056c04
--- /dev/null
@@ -0,0 +1,438 @@
+/* Reinventing the wheel - and why not?!               */
+/* An implementation of ls                                             */
+/* (C) 2004 Kevin Waldron                                              */
+/* http://www.zazzybob.com                                             */
+/*                                                                                             */
+/* Distributed under the terms of the                  */
+/* GNU General Public Licence                                  */
+/*                                                                                             */
+/* Current emulates ls -1 (one) for a given            */
+/* list of directories and files                               */
+/* supports -i (inode)                                                 */
+/*          -d (directory)                                             */
+/*          -l (long listing)                   */
+/*          -a (all)                            */
+/*          -A (all, no . or .. )               */
+/* assumes -1(one) by default                                  */
+
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <dirent.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <pwd.h>
+#include <grp.h>
+#include <time.h>
+
+#define MAXDIRS 20
+
+void print_usage(void);
+void print_it(struct stat, char *);
+
+int i_flag = 0;
+int d_flag = 0;
+int l_flag = 0;
+int a_flag = 0;
+int A_flag = 0;  /* case sensitivity, woohoo! */
+
+char *username;
+char *groupname;
+               
+int main( int argc, char *argv[] )
+{
+  int c;
+  extern char *optarg;
+  extern int optind, optopt;
+
+  int errflag = 0;
+  DIR *p_dir;
+  struct stat st;
+  struct dirent *en;
+
+  /* malloc our user/groupnames to save hassle later */
+  username = (char *)malloc(256);
+  *username='\0';
+  groupname = (char *)malloc(256);
+  *groupname='\0';
+  
+  while ( ( c = getopt( argc, argv, "iaAld" ) ) != -1 )
+  {
+    switch( c ) {
+         case 'a':
+                a_flag = 1;
+            break;
+         case 'A':
+                A_flag = 1;
+            break;
+      case 'i':
+         i_flag = 1;
+         break;
+         case 'd':
+                d_flag = 1;
+            break;
+         case 'l':
+                l_flag = 1;
+            break;
+      case '?':
+         errflag++;
+         break;
+    }
+  }
+
+  /* incorrect option passed - print usage && exit */
+  if ( errflag != 0 )
+  {
+     print_usage();
+     exit( 1 );
+  }
+
+  char *dirs[MAXDIRS];
+  int counter = 0;
+
+  /* no dirs passed as args */
+  if ( optind == argc )
+  {
+     dirs[0] = (char *)malloc(2);
+     strcpy( dirs[0], "." );
+     counter = 1;
+  }
+  else
+  {
+    for ( ; optind < argc; optind++ ) {
+
+      if ( optind > MAXDIRS ) {
+        fprintf( stderr, "Too many arguments....\n" );
+        exit( 1 );
+      }
+
+      dirs[counter] = (char *)malloc(strlen(argv[optind])+1);
+      strcpy( dirs[counter], argv[optind] );
+      counter++;
+    }
+  } 
+
+  int i = 0;
+  for ( i = 0 ; i < counter; i++ )
+  {
+        char buf[256];
+        getcwd( buf, 255 );
+        char *p_path;
+        char *p_file;
+        char *tmp_c;
+                               
+        p_file = (char *)malloc(256); 
+        p_path = (char *)malloc(256); 
+        tmp_c = (char *)malloc(2);      
+
+        *p_file = '\0';
+        *p_path = '\0';
+        *tmp_c = '\0';
+     
+        if ( ( p_dir = opendir( dirs[i]) ) == NULL )
+     {
+               /* if dir[i] contains ./ or ../ then we must have somekind of relative path, so... */
+               int result;
+               if ( ( result = strstr( dirs[i], "./" ) != NULL ) ||
+                        ( result = strstr( dirs[i], "../" ) != NULL ) )
+               {
+                       char *loc;
+                       loc = strrchr( dirs[i], '/' );
+
+
+
+                       int k;
+                       for ( k = 0 ; k < ( loc - dirs[i] ); k++ )
+                       {
+                               *(tmp_c) = dirs[i][k];
+                               *(tmp_c+1) = '\0';
+                               strcat( p_path, tmp_c );
+                       }
+                       k++; /*strip leading /*/
+                       for ( ; k < strlen( dirs[i] ); k++ )
+                       {
+                               *(tmp_c)= dirs[i][k];
+                               *(tmp_c+1) = '\0';
+                               strcat( p_file, tmp_c );
+                       }
+
+                       chdir( p_path );
+                       struct stat tmpstat;
+                       int r;
+                       if ( ( r = lstat( p_file, &tmpstat ) ) != 0 )
+                       {
+                           fprintf( stderr, "\n%s: not found\n", p_file );
+                       }
+                       else
+                       {
+                               lstat( p_file, &st );
+                               printf( "\n%s:\n", dirs[i] );
+                               print_it( st, p_file );
+                       }
+                       
+                       chdir( buf );
+
+               }
+               else
+               {
+                       /* either full path or current directory */
+                       struct stat tmpstat;
+                       int r;
+                       if ( ( r = lstat( dirs[i], &tmpstat ) ) != 0  )
+                       {
+                           fprintf( stderr, "\n%s: not found\n", dirs[i] );
+                       }
+                       else
+                       {
+                               lstat( dirs[i], &st );
+                               print_it( st, dirs[i] );
+                       }
+               }
+     } 
+        else if ( d_flag != 0 )
+        {
+                /* don't descend into directory */
+                lstat( dirs[i], &st );
+                print_it( st, dirs[i] );
+        }
+        else 
+        {
+               /* descend into directory as normal */
+
+               /* if more than one dir specified then print header */
+               ( counter > 1 ? printf( "\n%s:\n", dirs[i] ) : printf( "" ) );
+
+               chdir( dirs[i] );
+        
+               while ( ( en = readdir( p_dir ) ) != NULL )
+               {
+                  lstat( en->d_name, &st );
+                  print_it( st, en->d_name );
+               }
+               chdir( buf );
+               closedir( p_dir );
+        }
+
+       free( p_file );
+       free( p_path );
+       free( tmp_c ); 
+  }
+  int iDealloc;
+  /* Cycle through dir array and free pointers - to be nice */
+  for ( iDealloc = 0; iDealloc < i; iDealloc++ )
+  {
+     free( dirs[ iDealloc ] );
+  }
+  free( username );
+  free( groupname );
+  exit( 0 );
+}
+
+/* print_it gets data from the struct and formats it */
+void print_it(struct stat stst, char *dn )
+{
+           if ( A_flag != 0 )
+           {
+                       /* print dot files but not . or .. */
+                       if ( ( strcmp( dn, "." ) == 0 ) || ( strcmp( dn, ".." ) == 0 ) )
+                       {
+                               /* need this otherwise current directory will be ignored for ls -d */
+                               if ( d_flag == 0 )
+                               {
+                                       /* ignore */
+                                       return;
+                               } 
+                       }
+               } 
+           /* supress all dot files */
+           if ( ( a_flag == 0 ) && ( A_flag == 0 ) )
+           {
+                       /* if first char is . */
+                       if ( dn[0] == '.' )
+                       {
+                               /* need this otherwise current directory will be ignored for ls -d */
+                               if ( d_flag == 0 )
+                               {
+                                       /*ignore*/
+                                       return;
+                               }
+                       }
+           }
+               /* ELSE, print the lot.... */
+           
+               /* set various mode flags */
+               char *ft = "-\0";
+               char *ur = "-\0";
+               char *uw = "-\0";
+               char *ux = "-\0";
+               char *gr = "-\0";
+               char *gw = "-\0";
+               char *gx = "-\0";
+               char *or = "-\0";
+               char *ow = "-\0";
+               char *ox = "-\0";
+
+               if ( S_ISDIR( stst.st_mode ) ) {
+                       ft = "d";
+               }
+               if ( S_ISBLK( stst.st_mode ) ) {
+                       ft = "b";
+               }
+               if ( S_ISCHR( stst.st_mode ) ) {
+                       ft = "c";
+               }
+               if ( S_ISFIFO( stst.st_mode ) ) {
+                       ft = "f";
+               }
+               if ( S_ISLNK( stst.st_mode ) ) {
+                       ft = "l";
+               }
+               if (  stst.st_mode & S_IRUSR )
+               {
+                       ur = "r";
+               }
+               if ( stst.st_mode & S_IWUSR )
+               {
+                       uw = "w";
+               }
+               if ( stst.st_mode & S_IXUSR )
+               {
+                       ux = "x";
+               }
+               if ( stst.st_mode & S_IRGRP )
+               {
+                       gr = "r";
+               }
+               if ( stst.st_mode & S_IWGRP )
+               {
+                       gw = "w";
+               }
+               if ( stst.st_mode & S_IXGRP )
+               {
+                       gx = "x";
+               }
+               if ( stst.st_mode & S_IROTH )
+               {
+                       or = "r";
+               }
+               if ( stst.st_mode & S_IWOTH )
+               {
+                       ow = "w";
+               }
+               if ( stst.st_mode & S_IXOTH )
+               {
+                       
+                       ox = "x";
+               }
+               if ( stst.st_mode & S_ISVTX )
+               {
+                               if ( stst.st_mode & S_IXOTH )
+                               {
+                                       ox = "t";
+                               }
+                               else
+                               {
+                                       ox = "T";
+                               }
+               }
+               if ( stst.st_mode & S_ISUID )
+               {
+                               if ( stst.st_mode & S_IXUSR )
+                               {
+                                       ux = "s";
+                               }
+                               else
+                               {
+                                       ux = "S";
+                               }
+               }
+               if ( stst.st_mode & S_ISGID )
+               {
+                               if ( stst.st_mode & S_IXGRP )
+                               {
+                                       gx = "s";
+                               }
+                               else
+                               {
+                                       gx = "S";
+                               }
+               }
+
+               /* check this - is it doing what we want? */
+               unsigned long ino = stst.st_ino;
+
+           unsigned long nl = stst.st_nlink;
+               unsigned long fs = stst.st_size;
+
+               struct passwd *pw;
+               struct group *grp;
+
+               uid_t uid = stst.st_uid;
+               gid_t gid = stst.st_gid;
+
+        pw = getpwuid(uid);
+               grp = getgrgid(gid);
+
+           
+               strncpy( username, pw->pw_name, 9 );
+               strcat( username, "\0");
+               strncpy( groupname, grp->gr_name, 9 );
+               strcat( groupname, "\0");
+
+               /* time calc */
+               char m_time[81];
+               time_t t;
+               struct tm *tm;
+               tm = malloc(sizeof(struct tm));
+               t = stst.st_mtime;
+               tm = localtime( &t );
+           strftime(m_time,80,"%d-%m-%Y %H:%M",tm);
+
+               /* preceed listing with inode number */
+        if ( i_flag != 0 )
+        {
+                       printf( "%7lu ", ino );
+        }
+        if ( l_flag != 0)
+        {
+                       /* long listing....*/
+                       printf( "%s%s%s%s%s%s%s%s%s%s%3lu %9s %9s", ft, ur, uw, ux,
+                                                             gr, gw, gx,
+                                                             or, ow, ox, nl, username, 
+                                                             groupname);
+                       if ( ( ft == "c" ) || ( ft == "b" ) ) /* Must be a device file */
+                       {
+                               int min = minor(stst.st_rdev);
+                               int maj = major(stst.st_rdev);
+                               printf( "%3d, %3d", maj, min );
+                       }
+                       else
+                       {
+                               printf( "%8lu", fs );
+                       }
+                       printf( " %s ", m_time );
+        }
+               /* print file name under all circumstances */
+               printf ( "%s\n", dn );
+
+               free( tm );
+}
+
+void print_usage(void)
+{
+       char *usage[] = { "my_ls - (C) 2004 Kevin Waldron",
+                             "Distributed under the terms of the GNU General Public Licence",
+                             "USAGE:", "my_ls [options] [files, directories]",
+                             "  -a  Print listing for all files",
+                             "  -A  Print listing for all files, except . and ..",
+                             "  -d  Print information about directory entry", 
+                             "  -i  Preceed each listing with the inode number",
+                                     "  -l  List output in long format" };
+
+    int i = 0;
+       for ( i = 0 ; i < 9 ; i++ )
+       {
+               printf( "%s\n", *(usage+i) );
+       }
+}
index 2c33ec9..7931719 100644 (file)
@@ -1,24 +1,25 @@
 #include <stdlib.h>
-#include <stdio.h>
+#include <sys/types.h>
+#include <sys/stat.h>
 #include <fcntl.h>
+#include <stdio.h>
 #include <unistd.h>
 
 int main(int argc, char** argv)
 {
-       printf("Hello world from newlib!!\n");
-       printf("Hello\nWorld\nMulti\nLine\n");
-       printf("Hello after multiline.\n");
-
-       int fd = open("/test/file", O_RDWR, 0);
-       char buf[10];
-       int read_amt = read(fd, buf, 10);
+       printf("Welcome to the ROS newlib test suite!\nEnter at you're own risk....\n");
+       int fd = open("./test/matrix", O_RDWR, 0);
+       char buf[100];
+       int read_amt = read(fd, buf, 100);
        printf("FD: %d\n", fd);
        printf("read_amt: %d\n", read_amt);
        printf("read: %s\n", buf);
 
        char buf2[] = "NANWAN!\n";
 
-       int write_amt = write(fd, buf2, 8);
+       int fd = open("./test/nanwan", O_RDWR | O_CREAT, 
+                     S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH);
+       int write_amt = write(fd, buf2, sizeof(buf2));
         printf("write_amt: %d\n", write_amt);        
        printf("wrote: %s\n", buf2);
 
index 449fbf2..f27c2a6 100644 (file)
@@ -20,11 +20,12 @@ extern volatile env_t *env;
 extern volatile uint8_t (COUNT(PGSIZE * UINFO_PAGES) procinfo)[];
 extern volatile uint8_t (COUNT(PGSIZE * UDATA_PAGES) procdata)[];
 
-error_t        sys_cputs(const char *s, size_t len);
-uint16_t       sys_serial_write(void* buf, uint16_t len); 
-uint16_t       sys_serial_read(void* buf, uint16_t len);
-envid_t                sys_getenvid(void);
-uint32_t       sys_getcpuid(void);
-void           sys_env_destroy(envid_t);
+ssize_t     sys_cputs(const uint8_t *s, size_t len);
+uint16_t    sys_cgetc(void);
+ssize_t     sys_serial_write(void* buf, size_t len); 
+ssize_t     sys_serial_read(void* buf, size_t len);
+envid_t     sys_getenvid(void);
+envid_t     sys_getcpuid(void);
+void        sys_env_destroy(envid_t);
 
 #endif // !ROS_INC_LIB_H
index 04fa2bc..bfa2981 100644 (file)
@@ -19,9 +19,9 @@
 // in the middle of a console output line and such.
 #define BUF_SIZE 256
 typedef struct debugbuf {
-       int idx;        // current buffer index
-       int cnt;        // total bytes printed so far
-       char buf[BUF_SIZE];
+       size_t  idx;    // current buffer index
+       size_t  cnt;    // total bytes printed so far
+       uint8_t buf[BUF_SIZE];
 } debugbuf_t;
 
 
index 03d050d..53b5fef 100644 (file)
@@ -6,6 +6,7 @@
 #endif
 
 #include <parlib.h>
+#include <unistd.h>
 #include <newlib_backend.h>
 #include <string.h>
 #include <malloc.h>
@@ -14,7 +15,7 @@
 #include <debug.h>
 
 #define debug_in_out(fmt, ...) // debug(fmt, __VA_ARGS__)  
-#define debug_write_check(fmt, ...) debug(fmt, __VA_ARGS__)
+#define debug_write_check(fmt, ...) // debug(fmt, __VA_ARGS__)
 
 /* environ
  * A pointer to a list of environment variables and their values. 
@@ -43,8 +44,8 @@ int close(int file)
        debug_in_out("CLOSE\n");
 
        // If trying to close stdin/out/err just return
-        if ((file > -1) && (file <3))
-                return 0;
+       if ((file >= STDIN_FILENO) && (file <= STDERR_FILENO))
+               return 0;
 
        // Allocate a new buffer of proper size
        byte *out_msg = malloc(CLOSE_MESSAGE_FIXED_SIZE);
@@ -231,6 +232,11 @@ ssize_t read(int file, void *ptr, size_t len)
 {
        debug_in_out("READ\n");
 
+       if(file == STDIN_FILENO) {
+               for(int i=0; i<len; i++)        
+                       ((uint8_t*)ptr)[i] = sys_cgetc();
+               return len;
+       }
 
        // Allocate a new buffer of proper size
        byte *out_msg = (byte*)malloc(READ_MESSAGE_FIXED_SIZE);
@@ -306,7 +312,7 @@ int read_from_channel(byte * buf, int len, int peek)
  * The following suffices for a standalone system; it exploits the 
  * symbol _end automatically defined by the GNU linker.
  */
-caddr_t sbrk(int incr) 
+void* sbrk(ptrdiff_t incr) 
 {
        debug_in_out("SBRK\n");
        debug_in_out("\tincr: %u\n", incr);     
@@ -497,8 +503,8 @@ ssize_t write(int file, void *ptr, size_t len) {
 
        debug_write_check("Writing len: %d\n", len);
 
-       if ((file > -1) && (file < 3))  //STDOUT_FILENO || STDERR_FILENO || STDIN_FILENO
-               return (sys_cputs(ptr, len) == E_SUCCESS) ? len : -1;
+       if ((file >= STDIN_FILENO) && (file <= STDERR_FILENO)) 
+               return sys_cputs(ptr, len);
        
        int out_msg_len = WRITE_MESSAGE_FIXED_SIZE + len;
 
index 33c1a96..d1fa775 100644 (file)
@@ -7,10 +7,11 @@
 #include <parlib.h>
 
 // TODO: modify to take only four parameters
-static uint32_t
-syscall_sysenter(int num, uint32_t a1, uint32_t a2, uint32_t a3, uint32_t a4, uint32_t a5)
+static intreg_t syscall_sysenter(uint16_t num, intreg_t a1,
+                                 intreg_t a2, intreg_t a3,
+                                 intreg_t a4, intreg_t a5)
 {
-       uint32_t ret;
+       intreg_t ret;
     asm volatile(
             //"pushl %%ecx\n\t"
             //"pushl %%edx\n\t"
@@ -34,10 +35,11 @@ syscall_sysenter(int num, uint32_t a1, uint32_t a2, uint32_t a3, uint32_t a4, ui
        return ret;
 }
 
-static inline uint32_t syscall_trap(int num, uint32_t a1, uint32_t a2, 
-                                    uint32_t a3, uint32_t a4, uint32_t a5)
+static intreg_t syscall_trap(uint16_t num, intreg_t a1,
+                             intreg_t a2, intreg_t a3,
+                             intreg_t a4, intreg_t a5)
 {
-       uint32_t ret;
+       intreg_t ret;
 
        // Generic system call: pass system call number in AX,
        // up to five parameters in DX, CX, BX, DI, SI.
@@ -65,8 +67,9 @@ static inline uint32_t syscall_trap(int num, uint32_t a1, uint32_t a2,
        return ret;
 }
 
-static inline uint32_t syscall(int num, uint32_t a1, uint32_t a2, uint32_t a3,
-                               uint32_t a4, uint32_t a5)
+static intreg_t syscall(uint16_t num, intreg_t a1,
+                        intreg_t a2, intreg_t a3,
+                        intreg_t a4, intreg_t a5)
 {
        #ifndef SYSCALL_TRAP
                return syscall_sysenter(num, a1, a2, a3, a4, a5);
@@ -86,24 +89,29 @@ envid_t sys_getenvid(void)
         return syscall(SYS_getenvid, 0, 0, 0, 0, 0);
 }
 
-uint32_t sys_getcpuid(void)
+envid_t sys_getcpuid(void)
 {
         return syscall(SYS_getcpuid, 0, 0, 0, 0, 0);
 }
 
-error_t sys_cputs(const char *s, size_t len)
+ssize_t sys_cputs(const uint8_t *s, size_t len)
 {
-    return syscall(SYS_cputs, (uint32_t) s,  len, 0, 0, 0);
+    return syscall(SYS_cputs, (intreg_t) s,  len, 0, 0, 0);
+}
+
+uint16_t sys_cgetc(void)
+{
+    return syscall(SYS_cgetc, 0, 0, 0, 0, 0);
 }
 
 //Write a buffer over the serial port
-uint16_t sys_serial_write(void* buf, uint16_t len) 
+ssize_t sys_serial_write(void* buf, size_t len) 
 {
-       return syscall(SYS_serial_write, (uint32_t)buf, len, 0, 0, 0);
+       return syscall(SYS_serial_write, (intreg_t)buf, len, 0, 0, 0);
 }
 
 //Read a buffer over the serial port
-uint16_t sys_serial_read(void* buf, uint16_t len) 
+ssize_t sys_serial_read(void* buf, size_t len) 
 {
-       return syscall(SYS_serial_read, (uint32_t)buf, len, 0, 0, 0);
+       return syscall(SYS_serial_read, (intreg_t)buf, len, 0, 0, 0);
 }
index 793c63b..fbded5e 100644 (file)
@@ -30,24 +30,21 @@ extern volatile uint8_t (COUNT(PGSIZE * UDATA_PAGES) procdata)[];
 extern syscall_front_ring_t sysfrontring;
 void exit(void) __attribute__((noreturn));
 
-// readline.c
-char*  readline(const char *buf);
-
 // syscall.c
-void           sys_null();
-error_t                sys_null_async(syscall_desc_t* desc);
-void           sys_cache_invalidate();
-void           sys_cache_buster(uint32_t num_writes, uint32_t val);
-error_t                sys_cache_buster_async(syscall_desc_t* desc, uint32_t num_writes,
-                                              uint32_t val);
-void           sys_cputs(const char *string, size_t len);
-error_t                sys_cputs_async(const char *s, size_t len, syscall_desc_t* desc,
-                                       void (*cleanup_handler)(void*), void* cleanup_data);
-int                    sys_cgetc(void);
-envid_t                sys_getenvid(void);
-uint32_t       sys_getcpuid(void);
-int                    sys_env_destroy(envid_t);
-error_t                waiton_syscall(syscall_desc_t* desc, syscall_rsp_t* rsp);
+void        sys_null();
+error_t     sys_null_async(syscall_desc_t* desc);
+void        sys_cache_invalidate();
+void        sys_cache_buster(uint32_t num_writes, uint32_t val);
+error_t     sys_cache_buster_async(syscall_desc_t* desc, 
+                                   uint32_t num_writes, uint32_t val);
+ssize_t     sys_cputs(const char *string, size_t len);
+error_t     sys_cputs_async(const char *s, size_t len, syscall_desc_t* desc,
+                            void (*cleanup_handler)(void*), void* cleanup_data);
+uint16_t    sys_cgetc(void);
+envid_t     sys_getenvid(void);
+envid_t     sys_getcpuid(void);
+error_t     sys_env_destroy(envid_t);
+error_t     waiton_syscall(syscall_desc_t* desc, syscall_rsp_t* rsp);
 
 // async callback
 #define MAX_SYSCALLS 100
index 2282a25..72d63b2 100644 (file)
@@ -16,9 +16,9 @@
 #define printk(args...) cprintf(args)
 
 // lib/stdio.c
-void   cputchar(int c);
-int    getchar(void);
-int    iscons(int fd);
+void cputchar(int c);
+int     getchar(void);
+int     iscons(int fd);
 
 // lib/printfmt.c
 void   printfmt(void (*putch)(int, void**), void **putdat, const char *NTS fmt, ...);
index a09e7ae..ead316a 100644 (file)
@@ -3,15 +3,17 @@
 #pragma nodeputy
 #endif
 
+#include <arch/types.h>
 #include <arch/x86.h>
 #include <ros/syscall.h>
 #include <lib.h>
 
-// TODO: modify to take only four parameters
-static uint32_t
-syscall_sysenter(int num, uint32_t a1, uint32_t a2, uint32_t a3, uint32_t a4, uint32_t a5)
+// TODO: modift to take only four parameters
+static intreg_t syscall_sysenter(uint16_t num, intreg_t a1,
+                                 intreg_t a2, intreg_t a3,
+                                 intreg_t a4, intreg_t a5)
 {
-       uint32_t ret;
+       intreg_t ret;
     asm volatile(
             //"pushl %%ecx\n\t"
             //"pushl %%edx\n\t"
@@ -35,8 +37,9 @@ syscall_sysenter(int num, uint32_t a1, uint32_t a2, uint32_t a3, uint32_t a4, ui
        return ret;
 }
 
-static inline uint32_t
-syscall_trap(int num, uint32_t a1, uint32_t a2, uint32_t a3, uint32_t a4, uint32_t a5)
+static intreg_t syscall_trap(uint16_t num, intreg_t a1,
+                             intreg_t a2, intreg_t a3,
+                             intreg_t a4, intreg_t a5)
 {
        uint32_t ret;
 
@@ -66,8 +69,9 @@ syscall_trap(int num, uint32_t a1, uint32_t a2, uint32_t a3, uint32_t a4, uint32
        return ret;
 }
 
-static inline uint32_t syscall(int num, uint32_t a1, uint32_t a2, uint32_t a3,
-                               uint32_t a4, uint32_t a5)
+static intreg_t syscall(uint16_t num, intreg_t a1,
+                        intreg_t a2, intreg_t a3,
+                        intreg_t a4, intreg_t a5)
 {
        #ifndef SYSCALL_TRAP
                return syscall_sysenter(num, a1, a2, a3, a4, a5);
@@ -163,31 +167,27 @@ void sys_cache_invalidate()
        syscall(SYS_cache_invalidate, 0, 0, 0, 0, 0);
 }
 
-void
-sys_cputs(const char *s, size_t len)
+ssize_t sys_cputs(const char *s, size_t len)
 {
-       syscall(SYS_cputs, (uint32_t) s,  len, 0, 0, 0);
+       return syscall(SYS_cputs, (intreg_t)s,  len, 0, 0, 0);
 }
 
-int
-sys_cgetc(void)
+uint16_t sys_cgetc(void)
 {
        return syscall(SYS_cgetc, 0, 0, 0, 0, 0);
 }
 
-int
-sys_env_destroy(envid_t envid)
+error_t sys_env_destroy(envid_t envid)
 {
        return syscall(SYS_env_destroy, envid, 0, 0, 0, 0);
 }
 
-envid_t
-sys_getenvid(void)
+envid_t sys_getenvid(void)
 {
         return syscall(SYS_getenvid, 0, 0, 0, 0, 0);
 }
 
-uint32_t sys_getcpuid(void)
+envid_t sys_getcpuid(void)
 {
         return syscall(SYS_getcpuid, 0, 0, 0, 0, 0);
 }