Removed the notion of environments from userspace
authorBarret Rhoden <brho@cs.berkeley.edu>
Sat, 18 Jul 2009 01:21:16 +0000 (18:21 -0700)
committerBarret Rhoden <brho@cs.berkeley.edu>
Sat, 18 Jul 2009 01:23:41 +0000 (18:23 -0700)
Merged include/ros/env.h into include/env.h, and userspace can't see it
anymore.  All previous uses were changed to use some form of
sys_getpid().  Userspace can cache it in a library call to getpid() if
it wants.

24 files changed:
include/env.h
include/ros/env.h [deleted file]
include/ros/syscall.h
kern/src/syscall.c
user/apps/roslib/buggyhello.c
user/apps/roslib/evilhello.c
user/apps/roslib/hello.c
user/apps/roslib/measurements.c
user/apps/roslib/print_tests.c
user/apps/roslib/proctests.c
user/apps/roslib/testpmap.c
user/parlib/inc/parlib.h
user/parlib/src/debug.c
user/parlib/src/entry.S
user/parlib/src/newlib_backend.c
user/parlib/src/parlibmain.c
user/parlib/src/syscall.c
user/roslib/inc/lib.h
user/roslib/inc/measure.h
user/roslib/src/entry.S
user/roslib/src/exit.c
user/roslib/src/libmain.c
user/roslib/src/printf.c
user/roslib/src/syscall.c

index 6a3012e..7b4edc0 100644 (file)
@@ -2,10 +2,76 @@
 
 #ifndef ROS_KERN_ENV_H
 #define ROS_KERN_ENV_H
+/* Note that the old include/ros/env.h is merged into this file */
 
-#include <arch/x86.h>
-#include <ros/env.h>
+#include <ros/trap.h>
+#include <ros/memlayout.h>
+#include <ros/syscall.h>
 #include <ros/error.h>
+#include <arch/types.h>
+#include <arch/x86.h>
+#include <sys/queue.h>
+
+struct Env;
+typedef struct Env env_t;
+
+typedef int32_t envid_t;
+
+// An environment ID 'envid_t' has three parts:
+//
+// +1+---------------21-----------------+--------10--------+
+// |0|          Uniqueifier             |   Environment    |
+// | |                                  |      Index       |
+// +------------------------------------+------------------+
+//                                       \--- ENVX(eid) --/
+//
+// The environment index ENVX(eid) equals the environment's offset in the
+// 'envs[]' array.  The uniqueifier distinguishes environments that were
+// created at different times, but share the same environment index.
+//
+// All real environments are greater than 0 (so the sign bit is zero).
+// envid_ts less than 0 signify errors.  The envid_t == 0 is special, and
+// stands for the current environment.
+
+#define LOG2NENV               10
+#define NENV                   (1 << LOG2NENV)
+#define ENVX(envid)            ((envid) & (NENV - 1))
+
+// Values of env_status in struct Env
+// TODO: think about what states we want.
+#define ENV_FREE                       0
+#define ENV_RUNNING                    1
+#define ENV_RUNNABLE           2
+#define ENV_NOT_RUNNABLE       3
+#define ENV_DYING                      4
+#define ENV_CREATED                    5
+
+struct Env {
+       LIST_ENTRY(Env) env_link NOINIT;        // Free list link pointers
+       uint32_t lock;
+       trapframe_t env_tf;                     // Saved registers
+       envid_t env_id;                         // Unique environment identifier
+       envid_t env_parent_id;          // env_id of this env's parent
+       unsigned env_status;            // Status of the environment
+       uint32_t env_runs;                      // Number of times environment has run
+       uint32_t env_refcnt;            // Reference count of kernel contexts using this
+       uint32_t env_flags;
+       // Note this is the actual backring, not a pointer to it somewhere else
+       syscall_back_ring_t env_sysbackring;    // BackRing for generic syscalls
+
+       // Address space
+       pde_t *COUNT(NPDENTRIES) env_pgdir;                     // Kernel virtual address of page dir
+       physaddr_t env_cr3;                     // Physical address of page dir
+       // TODO - give these two proper types (pointers to structs)
+       // TODO - not always going to be PGSIZE either!
+       void*COUNT(PGSIZE) env_procinfo;                // KVA of per-process shared info table (RO)
+       void*COUNT(PGSIZE) env_procdata;                // KVA of per-process shared data table (RW)
+       // Eventually want to move this to a per-system shared-info page
+       uint64_t env_tscfreq;           // Frequency of the TSC for measurements
+};
+
+/* Process Flags */
+// None yet
 
 extern env_t *COUNT(NENV) envs;                // All environments
 extern uint32_t num_envs;              // Number of envs
diff --git a/include/ros/env.h b/include/ros/env.h
deleted file mode 100644 (file)
index 349855a..0000000
+++ /dev/null
@@ -1,73 +0,0 @@
-/* See COPYRIGHT for copyright information. */
-
-#ifndef ROS_INC_ENV_H
-#define ROS_INC_ENV_H
-
-#include <ros/trap.h>
-#include <ros/memlayout.h>
-#include <ros/syscall.h>
-#include <arch/types.h>
-#include <sys/queue.h>
-
-struct Env;
-typedef struct Env env_t;
-
-typedef int32_t envid_t;
-
-// An environment ID 'envid_t' has three parts:
-//
-// +1+---------------21-----------------+--------10--------+
-// |0|          Uniqueifier             |   Environment    |
-// | |                                  |      Index       |
-// +------------------------------------+------------------+
-//                                       \--- ENVX(eid) --/
-//
-// The environment index ENVX(eid) equals the environment's offset in the
-// 'envs[]' array.  The uniqueifier distinguishes environments that were
-// created at different times, but share the same environment index.
-//
-// All real environments are greater than 0 (so the sign bit is zero).
-// envid_ts less than 0 signify errors.  The envid_t == 0 is special, and
-// stands for the current environment.
-
-#define LOG2NENV               10
-#define NENV                   (1 << LOG2NENV)
-#define ENVX(envid)            ((envid) & (NENV - 1))
-
-// Values of env_status in struct Env
-// TODO: think about what states we want.
-#define ENV_FREE                       0
-#define ENV_RUNNING                    1
-#define ENV_RUNNABLE           2
-#define ENV_NOT_RUNNABLE       3
-#define ENV_DYING                      4
-#define ENV_CREATED                    5
-
-struct Env {
-       LIST_ENTRY(Env) env_link NOINIT;        // Free list link pointers
-       uint32_t lock;
-       trapframe_t env_tf;                     // Saved registers
-       envid_t env_id;                         // Unique environment identifier
-       envid_t env_parent_id;          // env_id of this env's parent
-       unsigned env_status;            // Status of the environment
-       uint32_t env_runs;                      // Number of times environment has run
-       uint32_t env_refcnt;            // Reference count of kernel contexts using this
-       uint32_t env_flags;
-       // Note this is the actual backring, not a pointer to it somewhere else
-       syscall_back_ring_t env_sysbackring;    // BackRing for generic syscalls
-
-       // Address space
-       pde_t *COUNT(NPDENTRIES) env_pgdir;                     // Kernel virtual address of page dir
-       physaddr_t env_cr3;                     // Physical address of page dir
-       // TODO - give these two proper types (pointers to structs)
-       // TODO - not always going to be PGSIZE either!
-       void*COUNT(PGSIZE) env_procinfo;                // KVA of per-process shared info table (RO)
-       void*COUNT(PGSIZE) env_procdata;                // KVA of per-process shared data table (RW)
-       // Eventually want to move this to a per-system shared-info page
-       uint64_t env_tscfreq;           // Frequency of the TSC for measurements
-};
-
-/* Process Flags */
-// None yet
-
-#endif // !ROS_INC_ENV_H
index e7e4520..8fbf78f 100644 (file)
@@ -17,8 +17,8 @@ enum
        SYS_getcpuid,
        SYS_serial_write,
        SYS_serial_read,
-       SYS_getenvid,
-       SYS_env_destroy,
+       SYS_getpid,
+       SYS_proc_destroy,
        SYS_yield,
        SYS_proc_create,
        SYS_proc_run,
index 74ce283..8524025 100644 (file)
@@ -310,9 +310,9 @@ intreg_t syscall(env_t* e, uint32_t syscallno, uint32_t a1, uint32_t a2,
                        return sys_serial_write(e, (char *DANGEROUS)a1, (size_t)a2);
                case SYS_serial_read:
                        return sys_serial_read(e, (char *DANGEROUS)a1, (size_t)a2);
-               case SYS_getenvid:
+               case SYS_getpid:
                        return sys_getenvid(e);
-               case SYS_env_destroy:
+               case SYS_proc_destroy:
                        return sys_env_destroy(e, (envid_t)a1);
                case SYS_yield:
                        sys_yield(e);
index dc1b82a..e021da3 100644 (file)
@@ -1,5 +1,5 @@
 // buggy hello world -- unmapped pointer passed to kernel
-// kernel should destroy user environment in response
+// kernel should destroy user process in response
 
 #include <inc/lib.h>
 
index 19b30aa..254d992 100644 (file)
@@ -1,5 +1,5 @@
 // evil hello world -- kernel pointer passed to kernel
-// kernel should destroy user environment in response
+// kernel should destroy user process in response
 
 #include <inc/lib.h>
 
index 7b3eefe..fadc6a6 100644 (file)
@@ -2,6 +2,6 @@
 
 int main(int argc, char** argv)
 {
-       cprintf("Goodbye, world, from PID: %d!\n", env->env_id);
+       cprintf("Goodbye, world, from PID: %d!\n", sys_getpid());
        return 0;
 }
index 8e86443..1a2fe54 100644 (file)
@@ -3,6 +3,7 @@
 #include <arch/timer.h>
 
 #include <ros/syscall.h>
+#include <ros/trap.h>
 
 #include <lib.h>
 #include <measure.h>
@@ -267,7 +268,7 @@ int main(int argc, char** argv)
                                cprintf("Bug in Job Selection!!!\n");
        }
        waiton_barrier(bar);
-       //cprintf("Env %x, on core %d, finishes\n", env->env_id, coreid);
+       //cprintf("Env %x, on core %d, finishes\n", sys_getpid(), coreid);
        return 0;
        /* Options for Cache Buster:
         * BUSTER_SHARED
index 3d1ff85..79fb480 100644 (file)
@@ -7,28 +7,29 @@
 
 int main(int argc, char** argv)
 {
-       cprintf("i am environment %08x, running on core %d\n", env->env_id, getcpuid());
+       int pid = sys_getpid();
+       cprintf("i am process %08x, running on core %d\n", pid, getcpuid());
 
        async_desc_t *desc1, *desc2, *desc3;
        async_rsp_t rsp1, rsp2, rsp3;
-       cprintf_async(&desc1, "Cross-Core call 1, coming from env %08x\n", env->env_id);
-       cprintf_async(&desc1, "Cross-Core call 1, coming from env %08x\n", env->env_id);
-       cprintf_async(&desc1, "Cross-Core call 1, coming from env %08x\n", env->env_id);
-       cprintf_async(&desc1, "Cross-Core call 1, coming from env %08x\n", env->env_id);
-       cprintf_async(&desc1, "Cross-Core call 1, coming from env %08x\n", env->env_id);
+       cprintf_async(&desc1, "Cross-Core call 1, coming from process %08x\n", pid);
+       cprintf_async(&desc1, "Cross-Core call 1, coming from process %08x\n", pid);
+       cprintf_async(&desc1, "Cross-Core call 1, coming from process %08x\n", pid);
+       cprintf_async(&desc1, "Cross-Core call 1, coming from process %08x\n", pid);
+       cprintf_async(&desc1, "Cross-Core call 1, coming from process %08x\n", pid);
        //cprintf("Call 1 is sent!\n");
-       //cprintf_async(&desc2, "Cross-Core call 2, coming from env %08x\n", env->env_id);
-       //cprintf_async(&desc2, "1111111111111111111111111111111122222222222222222222222222222222333333333333333333333333333333334444444444444444444444444444444455555555555555555555555555555555666666666666666666666666666666667777777777777777777777777777777788888888888888888888888888888888Cross-Core call 2, coming from env %08x\n", env->env_id);
+       //cprintf_async(&desc2, "Cross-Core call 2, coming from process %08x\n", pid);
+       //cprintf_async(&desc2, "1111111111111111111111111111111122222222222222222222222222222222333333333333333333333333333333334444444444444444444444444444444455555555555555555555555555555555666666666666666666666666666666667777777777777777777777777777777788888888888888888888888888888888Cross-Core call 2, coming from process %08x\n", pid);
        //cprintf("Call 2 is sent!\n");
        //cprintf("Waiting on Call 1\n");
        waiton_async_call(desc1, &rsp1);
        //cprintf("Received 1\n");
        //waiton_async_call(desc2, &rsp2);
-//     cprintf_async(&desc3, "Cross-Core call 3, coming from env %08x\n", env->env_id);
+//     cprintf_async(&desc3, "Cross-Core call 3, coming from process %08x\n", pid);
 //     cprintf("Call 3 is sent!\n");
 //     waiton_async_call(desc3, &rsp3);
        // might as well spin, just to make sure nothing gets deallocated
        // while we're waiting to test the async call
        //while (1);
-       //cprintf("DYING: environment %08x\n", env->env_id);
+       //cprintf("DYING: process %08x\n", pid);
 }
index 50fb8cf..9ebca53 100644 (file)
@@ -3,12 +3,13 @@
 
 int main(int argc, char** argv)
 {
-       cprintf("Process %x, Starting and yielding.\n", env->env_id);
+       int pid = sys_getpid();
+       cprintf("Process %x, Starting and yielding.\n", pid);
        yield();
-       cprintf("Process %x, Return from yield1, starting yield2.\n", env->env_id);
+       cprintf("Process %x, Return from yield1, starting yield2.\n", pid);
        yield();
-       cprintf("Process %x, Return from yield2, starting yield3.\n", env->env_id);
+       cprintf("Process %x, Return from yield2, starting yield3.\n", pid);
        yield();
-       cprintf("Process %x, Return from yield3, exiting.\n", env->env_id);
+       cprintf("Process %x, Return from yield3, exiting.\n", pid);
        return 0;
 }
index 0a9ecde..9c574b3 100644 (file)
@@ -56,7 +56,7 @@ alloc_range(int initaddr, int maxpa, int startn) {
   initva = initaddr;
   maxva = initva + maxpa;
   
-  cprintf ("[%08x] trying to alloc pages in range [%08x, %08x]\n", env->env_id, initva, maxva);
+  cprintf ("[%08x] trying to alloc pages in range [%08x, %08x]\n", sys_getpid(), initva, maxva);
 
   // how many pages can I alloc? 
   // - limit to 256 M worth of pages
@@ -76,7 +76,7 @@ alloc_range(int initaddr, int maxpa, int startn) {
   }
   cprintf("\n");
 
-  cprintf("[%08x] able to allocate [%d] pages of requested [%d] pages\n", env->env_id, n, maxnum);
+  cprintf("[%08x] able to allocate [%d] pages of requested [%d] pages\n", sys_getpid(), n, maxnum);
 
   maxva = va;
   return n;
@@ -85,14 +85,14 @@ alloc_range(int initaddr, int maxpa, int startn) {
 int
 test_range(int startva, int endva, int startn) {
   int c;
-  cprintf("[%08x] testing pages in [%08x, %08x] to see if they look okay\n", env->env_id, startva, endva);
+  cprintf("[%08x] testing pages in [%08x, %08x] to see if they look okay\n", sys_getpid(), startva, endva);
   n = startn;
   failures = 0;  
   for (va = startva, c = 0; va < endva; va += PGSIZE, n++, c++) { 
     page_id = (int*)va;
 
     if (test_page((int*)va, n)) {
-      cprintf("\n[%08x] unexpected value at [%08x]:\n  {", env->env_id, va);
+      cprintf("\n[%08x] unexpected value at [%08x]:\n  {", sys_getpid(), va);
       print_marked_page((int*)va);
       cprintf("} should be\n  {");
       print_expected_mark(n);
@@ -104,7 +104,7 @@ test_range(int startva, int endva, int startn) {
       int perm = (PTE_U | PTE_P | PTE_W | PTE_AVAIL);
 
       if ((pte & perm) != perm) {
-       cprintf("\n[%08x] unexpected PTE permissions [04x] for address [%08x]\n {", env->env_id, pte & perm, va);
+       cprintf("\n[%08x] unexpected PTE permissions [04x] for address [%08x]\n {", sys_getpid(), pte & perm, va);
        failures++;
       }
 
@@ -120,29 +120,29 @@ test_range(int startva, int endva, int startn) {
   }
   cprintf("\n");
 
-  cprintf("[%08x] tested %d pages: %d failed assertions.\n", env->env_id, c, failures);
+  cprintf("[%08x] tested %d pages: %d failed assertions.\n", sys_getpid(), c, failures);
 
   return failures;
 }
 
 void
 unmap_range(int startva, int endva) {
-  cprintf("[%08x] unmapping range [%08x, %08x].\n", env->env_id, startva, endva);
+  cprintf("[%08x] unmapping range [%08x, %08x].\n", sys_getpid(), startva, endva);
   int xva, z;
   for (z=0, xva = startva; xva < endva; xva += PGSIZE, z++) { 
     sys_mem_unmap(0, xva);
   }
-  cprintf("[%08x] unmapped %d pages.\n", env->env_id, z);
+  cprintf("[%08x] unmapped %d pages.\n", sys_getpid(), z);
 }
 
 int
 duplicate_range(int startva, int dupeva, int nbytes) {
   cprintf("[%08x] duplicating range [%08x, %08x] at [%08x, %08x]\n", 
-        env->env_id, startva, startva+nbytes, dupeva, dupeva+nbytes);
+        sys_getpid(), startva, startva+nbytes, dupeva, dupeva+nbytes);
   int xva, r, k;
   for (xva = 0, k = 0; xva < nbytes; xva += PGSIZE, k+=PGSIZE) { 
     if ((r = sys_mem_map(0, startva+xva, 0, dupeva+xva, PTE_P | PTE_U | PTE_W | PTE_USER)) < 0) {
-      cprintf ("[%08x] duplicate_range FAILURE: %e\n", env->env_id, r);
+      cprintf ("[%08x] duplicate_range FAILURE: %e\n", sys_getpid(), r);
       return r;
     }
   }
@@ -158,7 +158,7 @@ int main(int argc, char** argv)
   int max, max2, k, j, i, dupesize, dupen;
 
   for (i = 0; i < 2; i++) { // might as well do this multiple times to stress the system...
-    cprintf("PMAPTEST[%08x] starting ROUND %d.\n", env->env_id, i);
+    cprintf("PMAPTEST[%08x] starting ROUND %d.\n", sys_getpid(), i);
 
     // Try to allocate as many pages as possible...
     k = alloc_range(UTEXT+PDMAP, (256 * 1024 * 1024), 0);       // alloc as many as possible
@@ -166,17 +166,17 @@ int main(int argc, char** argv)
     test_range(UTEXT+PDMAP, max, 0);                            // test if all are unique pages
 
     // If we've corrupted kernel memory, a yield might expose a problem.
-    cprintf("PMAPTEST[%08x] yielding...\n", env->env_id);
+    cprintf("PMAPTEST[%08x] yielding...\n", sys_getpid());
     sys_yield();
-    cprintf("PMAPTEST[%08x] back.\n", env->env_id);
+    cprintf("PMAPTEST[%08x] back.\n", sys_getpid());
 
-    // Free a couple of pages for use by page tables and other envs...
+    // Free a couple of pages for use by page tables and other processes...
     unmap_range(max-16 * PGSIZE, max);                           // free some pages so we have wiggle room, if extra
     max -= 16 * PGSIZE;                                          // pages are needed for page tables...
     
     // Unmap last 1024 pages and then try to reallocate them in the same place
     unmap_range(max - PDMAP, max);                              // unmap last 1024 pages
-    j = alloc_range(max - PDMAP, PDMAP, 0);                     // try to realloc them (<1024 if other envs alloc'd)
+    j = alloc_range(max - PDMAP, PDMAP, 0);                     // try to realloc them (<1024 if other processes alloc'd)
     max2 = maxva; // max2 <= max && max2 >= (max - PDMAP)
     test_range(max - PDMAP, max2, 0);                           // test if new pages are unique
   
@@ -188,7 +188,7 @@ int main(int argc, char** argv)
   
     // Remove one of the duplicate mappings and then unmap and realloc the last 1024 pages
     unmap_range(max2-PDMAP, max2-PDMAP+dupesize);           // unmap lower mapping
-    j = alloc_range(max2-PDMAP, PDMAP, 0);                  // try to alloc something, should be below 1024 (really? other envs?)
+    j = alloc_range(max2-PDMAP, PDMAP, 0);                  // try to alloc something, should be below 1024 (really? other processes?)
     unmap_range(max2-2*PDMAP, max2 - PDMAP);                // free 1024 pages
     j = alloc_range(max2-2*PDMAP, PDMAP, 0);                // alloc new pages for free'd 1024
     //max2 = maxva; // max2 <= old_max2 - PDMAP
index f27c2a6..25ae8a8 100644 (file)
 #include <arch/types.h>
 #include <ros/memlayout.h>
 #include <ros/syscall.h>
-#include <ros/env.h>
 #include <ros/error.h>
 #include <newlib_backend.h>
 
-extern volatile env_t *env;
 // will need to change these types when we have real structs
 // seems like they need to be either arrays [] or functions () for it to work
 extern volatile uint8_t (COUNT(PGSIZE * UINFO_PAGES) procinfo)[];
@@ -24,8 +22,8 @@ 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);
+int         sys_getpid(void);
+size_t      sys_getcpuid(void);
+error_t     sys_proc_destroy(int pid);
 
 #endif // !ROS_INC_LIB_H
index bfa2981..534faf1 100644 (file)
@@ -1,4 +1,4 @@
-// Implementation of cprintf console output for user environments,
+// Implementation of cprintf console output for user processes,
 // based on printfmt() and the sys_cputs() system call.
 //
 // cprintf is a debugging statement, not a generic output statement.
index 4734b02..50ae355 100644 (file)
@@ -4,7 +4,7 @@
 .data
 
 
-// Define the global symbols 'envs', 'pages', 'vpt', and 'vpd'
+// Define the global symbols 'procinfo', 'procdata', 'pages', 'vpt', and 'vpd'
 // so that they can be used in C as if they were ordinary global arrays.
        .globl procinfo
        .set procinfo, UINFO
@@ -18,8 +18,8 @@
        .set vpd, (UVPT+(UVPT>>12)*4)
 
 
-// Entrypoint - this is where the kernel (or our parent environment)
-// starts us running when we are initially loaded into a new environment.
+// Entrypoint - this is where the kernel (or our parent process)
+// starts us running when we are initially created and run
 .text
 .globl _start
 _start:
index 1e347de..b2e7dc5 100644 (file)
@@ -23,7 +23,6 @@
  */
 char *__env[1] = { 0 };
 char **environ = __env;
-extern env_t* env;
 
 /* _exit()
  * Exit a program without cleaning up files. 
@@ -32,7 +31,7 @@ extern env_t* env;
  */
 void _exit(int __status) _ATTRIBUTE ((noreturn))
 {
-       sys_env_destroy(env->env_id);
+       sys_proc_destroy(sys_getpid()); // TODO: can run getpid and cache it
        while(1); //Should never get here...
 }
     
@@ -168,7 +167,7 @@ int fstat(int file, struct stat *st)
  */
 int getpid(void) 
 {
-       return env->env_id;
+       return sys_getpid(); // TODO: can run getpid and cache it
 }
 
 /* isatty()
index 25d9e46..e8a1718 100644 (file)
@@ -1,24 +1,22 @@
 // Called from entry.S to get us going.
-// entry.S already took care of defining envs, pages, vpd, and vpt.
 #ifdef __DEPUTY__
 #pragma nodeputy
 #endif
 
 #include <parlib.h>
 #include <stdlib.h>
+#include <unistd.h>
 #include <debug.h>
 
-volatile env_t *env;
 extern int main(int argc, char **argv);
 
 void parlibmain(int argc, char **argv)
 {
-       // set env to point at our env structure in envs[].
-       // TODO: for now, the kernel just copies our env struct to the beginning of
-       // procinfo.  When we figure out what we want there, change this.
-       env = (env_t*)procinfo; 
+       /* This is a good time to connect a global var to the procinfo structure
+        * like we used to do with env_t */
+       //env = (env_t*)procinfo;       
 
-       debug("Hello from env %d!\n", env->env_id);
+       debug("Hello from process %d!\n", getpid());
        // call user main routine
        int r = main(argc, argv);
 
index cab3792..0e6cddf 100644 (file)
@@ -5,6 +5,7 @@
 
 #include <arch/x86.h>
 #include <parlib.h>
+#include <ros/trap.h>
 
 // TODO: modify to take only four parameters
 static intreg_t syscall_sysenter(uint16_t num, intreg_t a1,
@@ -74,18 +75,17 @@ static intreg_t syscall(uint16_t num, intreg_t a1,
        #endif
 }
 
-void sys_env_destroy(envid_t envid)
+error_t sys_proc_destroy(int pid)
 {
-       syscall(SYS_env_destroy, envid, 0, 0, 0, 0);
-       while(1); //Should never get here...
+       return syscall(SYS_proc_destroy, pid, 0, 0, 0, 0);
 }
 
-envid_t sys_getenvid(void)
+int sys_getpid(void)
 {
-        return syscall(SYS_getenvid, 0, 0, 0, 0, 0);
+        return syscall(SYS_getpid, 0, 0, 0, 0, 0);
 }
 
-envid_t sys_getcpuid(void)
+size_t sys_getcpuid(void)
 {
         return syscall(SYS_getcpuid, 0, 0, 0, 0, 0);
 }
index 677f0d1..d5e4693 100644 (file)
@@ -12,7 +12,6 @@
 #include <ros/error.h>
 #include <ros/memlayout.h>
 #include <ros/syscall.h>
-#include <ros/env.h>
 
 #include <stdarg.h>
 #include <string.h>
@@ -23,7 +22,6 @@
 
 // libos.c or entry.S
 extern char *binaryname;
-extern volatile env_t *env;
 // will need to change these types when we have real structs
 // seems like they need to be either arrays [] or functions () for it to work
 extern volatile uint8_t (COUNT(PGSIZE * UINFO_PAGES) procinfo)[];
@@ -60,13 +58,13 @@ 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_getcpuid(void);
+size_t     sys_getcpuid(void);
 /* Process Management */
-envid_t     sys_getenvid(void);
-error_t     sys_env_destroy(envid_t);
-void           sys_yield(void);
-int                    sys_proc_create(char* path);
-error_t                sys_proc_run(int pid);
+int         sys_getpid(void);
+error_t     sys_proc_destroy(int pid);
+void        sys_yield(void);
+int         sys_proc_create(char* path);
+error_t     sys_proc_run(int pid);
 /* Generic Async Call */
 error_t     waiton_syscall(syscall_desc_t* desc, syscall_rsp_t* rsp);
 
index 623a53d..7d3d22a 100644 (file)
@@ -46,6 +46,7 @@
        cpuid(0, 0, 0, 0, 0);                                                      \
        ticks = read_tsc() - ticks;                                                \
        /* Compute the average and print it */                                     \
+       /* env->whatever doesn't work, but these functions are never used. */      \
        uint64_t a = (1000000000LL/(iters) * ticks) / (env->env_tscfreq);          \
        if ((name))                                                                \
                cprintf("Measuring %s:\n"                                              \
index cc33ea3..2b94c7e 100644 (file)
@@ -4,7 +4,7 @@
 .data
 
 
-// Define the global symbols 'envs', 'pages', 'vpt', and 'vpd'
+// Define the global symbols 'procinfo', 'procdata', 'pages', 'vpt', and 'vpd'
 // so that they can be used in C as if they were ordinary global arrays.
        .globl procinfo
        .set procinfo, UINFO
@@ -18,8 +18,8 @@
        .set vpd, (UVPT+(UVPT>>12)*4)
 
 
-// Entrypoint - this is where the kernel (or our parent environment)
-// starts us running when we are initially loaded into a new environment.
+// Entrypoint - this is where the kernel (or our parent process)
+// starts us running when we are initially created and run
 .text
 .globl _start
 _start:
index 7556ec2..fbaa67e 100644 (file)
@@ -1,11 +1,8 @@
 #include <lib.h>
 
-extern env_t* env;
-
 void exit(void) __attribute__((noreturn))
 {
-       sys_env_destroy(env->env_id);
+       sys_proc_destroy(sys_getpid());
        //Shouldn't get here, but include anyway so the compiler is happy.. 
        while(1);
 }
-
index 41976eb..de138b8 100644 (file)
@@ -1,5 +1,4 @@
 // Called from entry.S to get us going.
-// entry.S already took care of defining envs, pages, vpd, and vpt.
 #ifdef __DEPUTY__
 #pragma nodeputy
 #endif
@@ -9,7 +8,6 @@
 
 extern int main(int argc, char **argv);
 
-volatile env_t *env;
 char *binaryname = "(PROGRAM NAME UNKNOWN)";
 syscall_front_ring_t sysfrontring;
 syscall_desc_pool_t syscall_desc_pool;
@@ -22,10 +20,9 @@ async_desc_t* current_async_desc;
 void
 libmain(int argc, char **argv)
 {
-       // set env to point at our env structure in envs[].
-       // TODO: for now, the kernel just copies our env struct to the beginning of
-       // procinfo.  When we figure out what we want there, change this.
-       env = (env_t*)procinfo; 
+       /* This is a good time to connect a global var to the procinfo structure
+        * like we used to do with env_t */
+       //env = (env_t*)procinfo;       
 
        // Set up the front ring for the general syscall ring
        // TODO: Reorganize these global variables
index 9757da5..ea36552 100644 (file)
@@ -1,4 +1,4 @@
-// Implementation of cprintf console output for user environments,
+// Implementation of cprintf console output for user processes,
 // based on printfmt() and the sys_cputs() system call.
 //
 // cprintf is a debugging statement, not a generic output statement.
index ed0284f..3ec405c 100644 (file)
@@ -6,6 +6,7 @@
 #include <arch/types.h>
 #include <arch/x86.h>
 #include <ros/syscall.h>
+#include <ros/trap.h>
 #include <lib.h>
 
 // TODO: fix sysenter to take all 5 params
@@ -171,19 +172,19 @@ uint16_t sys_cgetc(void)
        return syscall(SYS_cgetc, 0, 0, 0, 0, 0);
 }
 
-envid_t sys_getcpuid(void)
+size_t sys_getcpuid(void)
 {
        return syscall(SYS_getcpuid, 0, 0, 0, 0, 0);
 }
 
-envid_t sys_getenvid(void)
+int sys_getpid(void)
 {
-       return syscall(SYS_getenvid, 0, 0, 0, 0, 0);
+       return syscall(SYS_getpid, 0, 0, 0, 0, 0);
 }
 
-error_t sys_env_destroy(envid_t envid)
+error_t sys_proc_destroy(int pid)
 {
-       return syscall(SYS_env_destroy, envid, 0, 0, 0, 0);
+       return syscall(SYS_proc_destroy, pid, 0, 0, 0, 0);
 }
 
 void sys_yield(void)