diff --git a/src/bin/init/main.c b/src/bin/init/main.c
index 06c0eb3..9ecc9b3 100755
--- a/src/bin/init/main.c
+++ b/src/bin/init/main.c
@@ -45,7 +45,9 @@
   if (!fork()) {  
     exec("shell");
     printf("Error Starting Shell\n");
-    while(1);
+    while(1) {
+      printf(".");
+      }
     }
   exit(1);
   }
\ No newline at end of file
diff --git a/src/sys/include/vmm/memory.h b/src/sys/include/vmm/memory.h
index 52686a0..0f9a5bc 100755
--- a/src/sys/include/vmm/memory.h
+++ b/src/sys/include/vmm/memory.h
@@ -32,8 +32,8 @@
 typedef struct {
   uLong  pageAddr;
   uShort status;
-  int pid;
-  int cowCounter;
+  pid_t  pid;
+  int    cowCounter;
   } mMap;
 
 extern mMap *memoryMap;
@@ -41,8 +41,9 @@
 extern int freePages;
 
 int countMemory();
-uLong findFreePage(int pid);
+uLong findFreePage(pid_t pid);
 void initMmap();
-void freeProcesspages(int pid);
+void freeProcessPages(pid_t pid);
+void adjustCowCounter(uLong baseAddr,int adjustment);
 
 #endif
\ No newline at end of file
diff --git a/src/sys/include/vmm/paging.h b/src/sys/include/vmm/paging.h
index ddd7b06..1efa7a3 100755
--- a/src/sys/include/vmm/paging.h
+++ b/src/sys/include/vmm/paging.h
@@ -43,12 +43,12 @@
 extern uLong memoryStart;
 
 void initPagingSystem();
-void *createVirtualSpace();
-void *copyVirtualSpace();
+void *createVirtualSpace(pid_t pid);
+void *copyVirtualSpace(pid_t pid);
 void remapPage(uLong source,uLong dest);
 void freePage(uLong pageAddr);
 void unmapPage(uLong pageAddr,int flags);
-void *getFreePage();
+void *getFreePage(pid_t pid);
 void *getPhysicalAddr(uLong pageAddr);
 void setPageAttribute(uLong pageAddr,int attributes);
 void pageFault();
diff --git a/src/sys/kernel/exec.c b/src/sys/kernel/exec.c
index f4dd6b0..03ebc5e 100755
--- a/src/sys/kernel/exec.c
+++ b/src/sys/kernel/exec.c
@@ -54,7 +54,7 @@
   //Get A New Task For This Proccess
   _current = findTask();
   //Now We Must Create A Virtual Space For This Proccess To Run In
-  _current->tss.cr3 = (uLong)createVirtualSpace();
+  _current->tss.cr3 = (uLong)createVirtualSpace(_current->id);
   //To Better Load This Application We Will Switch Over To Its VM Space
   asm(
     "movl %0,%%eax          \n"
diff --git a/src/sys/kernel/fork.c b/src/sys/kernel/fork.c
index 7eeb93d..459e88a 100755
--- a/src/sys/kernel/fork.c
+++ b/src/sys/kernel/fork.c
@@ -64,7 +64,6 @@
   newProcess->tss.ldt          = 0x18;
   newProcess->tss.trace_bitmap = 0x80000000;
   //Create A Copy Of The VM Space For New Task
-  newProcess->tss.cr3 = (long)copyVirtualSpace();
   newProcess->tss.eip = (long)&&childStart;
   //Set EBP And ESP To The Correct Locations
   asm(
@@ -73,6 +72,7 @@
     :
     : "g" (newProcess->tss.esp), "g" (newProcess->tss.ebp)
     );
+  newProcess->tss.cr3 = (long)copyVirtualSpace(newProcess->id);
   newProcess->status = RUNNING;
 childStart:
   //Set Up Pointer to Return Value
diff --git a/src/sys/kernel/kmalloc.c b/src/sys/kernel/kmalloc.c
index 3e9e4c5..b2ce7a6 100755
--- a/src/sys/kernel/kmalloc.c
+++ b/src/sys/kernel/kmalloc.c
@@ -25,6 +25,7 @@
 #include <ubixos/types.h>
 #include <vmm/paging.h>
 #include <drivers/video.h>
+#include <ubixos/schedule.h>
 
 struct memDescriptor {
   void *page;
@@ -39,7 +40,7 @@
 void initMalloc() {
   int i = 0;
   struct memDescriptor *tmpDesc = 0x0;
-  kernDesc = (void *)getFreePage();
+  kernDesc = (void *)getFreePage(_current->id);
   tmpDesc = kernDesc;
   for (i=0;i<4096;i+=sizeof(struct memDescriptor)) {
     tmpDesc->page = 0x0;
@@ -65,7 +66,7 @@
       }
     if (findDesc->next == 0) { break; }
     }
-  tmpDesc = (void *)getFreePage();
+  tmpDesc = (void *)getFreePage(_current->id);
   findDesc->next = tmpDesc;
   for (i=0;i<4096;i+=sizeof(struct memDescriptor)) {
     tmpDesc->page = 0x0;
@@ -102,7 +103,7 @@
         break;
         }         
       if (tmpDesc->page == 0x0) {
-        tmpDesc->page = (void *)getFreePage();
+        tmpDesc->page = (void *)getFreePage(_current->id);
         tmpDesc->base = tmpDesc->page;
         tmpDesc->limit = len;
         tmpDesc->counter = 1;
diff --git a/src/sys/kernel/syscall.c b/src/sys/kernel/syscall.c
index 221dbe9..8da252a 100755
--- a/src/sys/kernel/syscall.c
+++ b/src/sys/kernel/syscall.c
@@ -54,7 +54,8 @@
   int size;
   int fd;
   asm("": "=b" (ptr),"=c" (size),"=d" (fd));
-  if (fd == 0) {
+  //Temp Hack
+  if (fd >= 0) {
     for (i=0;i<size;i++) {
       data[i] = ptr[i];
       }
@@ -74,7 +75,7 @@
 void sysExit() {
   int *status;
   asm("":"=b" (status));
-//  freeProcesspages(_current->id);
+  freeProcessPages(_current->id);
   _current->status = EMPTY;
   schedule();
   }
@@ -100,6 +101,7 @@
     }
   //If We Dont Find the File Return
   if (!tmpFd) {
+    kprintf("Coulnt Find The File");
     return;
     }
   //Now We Must Allocate Memory To Load The Binary Into
diff --git a/src/sys/vmm/memory.c b/src/sys/vmm/memory.c
index 84cedc9..46c4724 100755
--- a/src/sys/vmm/memory.c
+++ b/src/sys/vmm/memory.c
@@ -118,6 +118,7 @@
   //Initialize All Free Pages To Available
   memoryMap[(0x100000/0x1000)].status = memAvail;
   for (i=memStart;i<numPages;i++) {
+    memoryMap[i].cowCounter = 0x0;
     memoryMap[i].status = memAvail;
     freePages++;
     }
@@ -127,14 +128,14 @@
 
 /************************************************************************
 
-Function: uLong findFreePage(int pid);
+Function: uLong findFreePage(pid_t pid);
 Description: This Returns A Free  Physical Page Address Then Marks It
              Not Available As Well As Setting The PID To The Proccess
              Allocating This Page
 Notes:
 
 ************************************************************************/  
-uLong findFreePage(int pid) {
+uLong findFreePage(pid_t pid) {
   int i=0;
   //Lets Look For A Free Page
   for (i=0;i<=numPages;i++) {
@@ -153,11 +154,46 @@
   return(0x0);
   }
 
-void freeProcesspages(int pid) {
+/************************************************************************
+
+Function: void adjustCowCounter(uLong baseAddr,int adjustment);
+Description: This Adjust The COW Counter For Page At baseAddr It Will
+             Error If The Count Goes Below 0
+Notes:
+
+08/01/02 - I Think If Counter Gets To 0 I Should Free The Page
+
+************************************************************************/
+void adjustCowCounter(uLong baseAddr,int adjustment) {
+  int memoryMapIndex = (baseAddr/4096);
+  //Adjust COW Counter
+  memoryMap[memoryMapIndex].cowCounter += adjustment;
+  if (memoryMap[memoryMapIndex].cowCounter <= 0) {
+    memoryMap[memoryMapIndex].status = memAvail;
+    kprintf("Its Free");
+    }
+  //Return
+  return;
+  }
+
+/************************************************************************
+
+Function: void freeProcessPages(pid_t pid);
+Description: This Function Will Free Up Memory For The Exiting Process
+Notes:
+
+************************************************************************/
+void freeProcessPages(pid_t pid) {
   int i=0;
+  //Loop Through Pages To Find Pages Owned By Process
   for (i=0;i<numPages;i++) {
     if (memoryMap[i].pid == pid) {
-      memoryMap[i].status = memAvail;
+      //Check To See If The cowCounter Is Zero If So We Can Ree It
+      if (memoryMap[i].cowCounter <= 0) {
+        memoryMap[i].status = memAvail;
+        }
       }
     }
-  }
+  //Return
+  return;    
+  }  
\ No newline at end of file
diff --git a/src/sys/vmm/paging.c b/src/sys/vmm/paging.c
index c816cd0..44d911b 100755
--- a/src/sys/vmm/paging.c
+++ b/src/sys/vmm/paging.c
@@ -98,7 +98,7 @@
   //Now Add The IDT Entry For Page Faults
   setVector(_pageFault,14,dPresent + dInt + dDpl3);        
   //Remap The Memory List
-  for (i=0x101000;i<=(0x101000+(numPages*8));i+=0x1000) {
+  for (i=0x101000;i<=(0x101000+(numPages*sizeof(mMap)));i+=0x1000) {
     remapPage(i,(0xE6667000+(i-0x101000)));
     }
   memoryMap = (mMap *)0xE6667000;
@@ -137,9 +137,18 @@
   int pageIndex = 0x0;
   //Find The Page Index To The Memory Map
   pageIndex = (pageAddr/4096);
-  //Set Page As Avail So It Can Be Used Again
-  memoryMap[pageIndex].status = memAvail;
-  freePages++;
+  //Check If Page COW Is Greater Then 0 If It Is Dec It If Not Free It
+  if (memoryMap[pageIndex].cowCounter <= 0) {
+    //Set Page As Avail So It Can Be Used Again
+    memoryMap[pageIndex].status = memAvail;
+    freePages++;
+    }
+  else {
+    //Adjust The COW Counter
+    adjustCowCounter(((uLong)memoryMap[pageIndex].pageAddr),-1);
+    }
+  //Return
+  return;
   }
     
 /************************************************************************
@@ -174,10 +183,6 @@
     }
   //Unmap The Page
   pageTable[pageTableIndex] = 0x0;
-  if (flags == 3) {
-    kprintf("test");
-    while (1);
-    }  
   //Rehash The Page Directory
   asm(
     "movl %cr3,%eax\n"
@@ -189,7 +194,7 @@
                                                   
 /************************************************************************
 
-Function: void *createVirtualSpace();
+Function: void *createVirtualSpace(pid_t);
 Description: Creates A Virtual Space For A New Task
 Notes:
 
@@ -204,10 +209,13 @@
 07/30/02 - Note I Realized A Mistake The First Page Table Will Need To Be
            A Copy But The Page Tables For The Top 1GB Will Not Reason For
            This Is That We Just Share The First 1MB In The First Page Table
-           So We Will Just Share Physical Pages.           
+           So We Will Just Share Physical Pages.
+
+08/02/02 - Added Passing Of pid_t pid For Better Tracking Of Who Has Which
+           Set Of Pages
            
 ************************************************************************/
-void *createVirtualSpace() {
+void *createVirtualSpace(pid_t pid) {
   void *newPageDirectoryAddress = 0x0;
   uLong *parentPageDirectory = 0x0,*newPageDirectory = 0x0;
   uLong *parentPageTable = 0x0,*newPageTable = 0x0;
@@ -215,7 +223,7 @@
   //Set Address Of Parent Page Directory
   parentPageDirectory = (uLong *)parentPageDirAddr;
   //Allocate A New Page For The New Page Directory  
-  newPageDirectory = (uLong *)getFreePage();
+  newPageDirectory = (uLong *)getFreePage(pid);
   //Set newPageDirectoryAddress To The Newly Created Page Directories Page
   newPageDirectoryAddress = getPhysicalAddr((uLong)newPageDirectory);
   //First Set Up A Flushed Page Directory
@@ -230,7 +238,7 @@
   Allocate A New Page For The The First Page Table Where We Will Map The
   Lower Region
   */
-  newPageTable = (uLong *)getFreePage();
+  newPageTable = (uLong *)getFreePage(pid);
   //Flush The Page From Garbage In Memory
   for (x=0;x<pageEntries;x++) {
     newPageTable[x] = (uLong)0x0;
@@ -253,7 +261,7 @@
   //First Lets Unmap The Previously Allocated Page Table
   unmapPage((uLong)newPageTable,1);
   //Allocate A New Page Table
-  newPageTable = (uLong *)getFreePage();
+  newPageTable = (uLong *)getFreePage(pid);
   //First Set Our Page Directory To Contain This
   newPageDirectory[767] = (uLong)getPhysicalAddr((uLong)newPageTable) | pageDefault;
   //Now Lets Build The Page Table
@@ -270,14 +278,17 @@
 
 /************************************************************************
 
-Function: void *copyVirtualSpace();
+Function: void *copyVirtualSpace(pid_t pid);
 Description: Creates A Copy Of A Virtual Space And Set All NON Kernel
              Space To COW For A Fork This Will Also Alter The Parents
              VM Space To Make That COW As Well
 Notes:
 
+08/02/02 - Added Passing Of pid_t pid So We Can Better Keep Track Of
+           Which Task Has Which Physical Pages
+
 ************************************************************************/
-void *copyVirtualSpace() {
+void *copyVirtualSpace(pid_t pid) {
   void *newPageDirectoryAddress = 0x0;
   uLong *parentPageDirectory = 0x0,*newPageDirectory = 0x0;
   uLong *parentPageTable = 0x0,*newPageTable = 0x0;
@@ -286,7 +297,7 @@
   //Set Address Of Parent Page Directory
   parentPageDirectory = (uLong *)parentPageDirAddr;
   //Allocate A New Page For The New Page Directory
-  newPageDirectory = (uLong *)getFreePage();
+  newPageDirectory = (uLong *)getFreePage(pid);  
   //Set newPageDirectoryAddress To The Newly Created Page Directories Page
   newPageDirectoryAddress = getPhysicalAddr((uLong)newPageDirectory);
   //First Set Up A Flushed Page Directory
@@ -308,30 +319,37 @@
       //Set Parent  To Propper Page Table
       parentPageTable = (uLong *)(tablesBaseAddress + (4096 * x));
       //Allocate A New Page Table
-      newPageTable = (uLong *)getFreePage();
+      newPageTable = (uLong *)getFreePage(pid);
       //Set Parent And New Pages To COW
       for (i=0;i<pageEntries;i++) {
         //If Page Is Mapped
         if (parentPageTable[i] != 0) {
           //Check To See If Its A Stack Page
           if (((uLong)parentPageTable[i] & pageStack) == pageStack) {
-            newStackPage = (uLong *)getFreePage();
+            //Alloc A New Page For This Stack Page
+            newStackPage = (uLong *)getFreePage(pid);
+            //Set Pointer To Parents Stack Page
             parentStackPage = (uLong *) (((1024*4096)*x)+(4096*i));
+            //Copy The Tack Byte For Byte (I Should Find A Faster Way)
             for (s=0;s<pageEntries;s++) {
               newStackPage[s] = parentStackPage[s];
-              }            
+              }
+            //Insert New Stack Into Page Table
             newPageTable[i] = ((uLong)getPhysicalAddr((uLong)newStackPage) | pageDefault | pageStack);
+            //Unmap From Kernel Space
             unmapPage((uLong)newStackPage,1);
             }
           else {
+            //Set Page To COW In Parent And Child Space
             newPageTable[i] = (((uLong)parentPageTable[i] & 0xFFFFF000) | (pagePresent | pageCow));
             parentPageTable[i] = newPageTable[i];
+            //Increment The COW Counter For This Page
+            adjustCowCounter(((uLong)parentPageTable[i] & 0xFFFFF000),1);
             }
           }
         else {
           newPageTable[i] = (uLong)0x0;
           }
-        //parentPageTable[x] = newPageTable[x];
         }
       //Put New Page Table Into New Page Directory
       newPageDirectory[x] = ((uLong)getPhysicalAddr((uLong)newPageTable) | pageDefault);
@@ -346,7 +364,7 @@
   Allocate A New Page For The The First Page Table Where We Will Map The
   Lower Region
   */
-  newPageTable = (uLong *)getFreePage();
+  newPageTable = (uLong *)getFreePage(pid);
   //Flush The Page From Garbage In Memory
   for (x=0;x<pageEntries;x++) {
     newPageTable[x] = (uLong)0x0;
@@ -381,7 +399,7 @@
   //First Lets Unmap The Previously Allocated Page Table
   unmapPage((uLong)newPageTable,1);
   //Allocate A New Page Table
-  newPageTable = (uLong *)getFreePage();
+  newPageTable = (uLong *)getFreePage(pid);
   //First Set Our Page Directory To Contain This
   newPageDirectory[767] = (uLong)getPhysicalAddr((uLong)newPageTable) | pageDefault;
   //Now Lets Build The Page Table
@@ -392,9 +410,10 @@
   unmapPage((uLong)newPageTable,1);
   //Now We Are Done With The Page Directory So Lets Unmap That Too
   unmapPage((uLong)newPageDirectory,1);
+  //kprintf("Test: [%i]\n",pid);  
   //Return Physical Address Of Page Directory
   return(newPageDirectoryAddress);
-  }  
+  }
 
 /************************************************************************
 
@@ -428,14 +447,14 @@
   
 /************************************************************************
 
-Function: void *getFreePage();
+Function: void *getFreePage(pid_t pid);
 Description: Returns A Free Page Mapped To The VM Space
 Notes:
 
 07/30/02 - This Returns A Free Page In The Top 1GB For The Kernel
 
 ************************************************************************/  
-void *getFreePage() {
+void *getFreePage(pid_t pid) {
   int x=0,y=0;
   uLong *pageTableSrc = 0x0;
   //Lets Search For A Free Page
@@ -446,7 +465,7 @@
       //Loop Through The Page Table Find An UnAllocated Page
       if ((uLong)pageTableSrc[y] == (uLong)0x0) {
         //Map A Physical Page To The Virtual Page
-        remapPage(findFreePage(_current->id),((x*(1024*4096))+(y*4096)));
+        remapPage(findFreePage(pid),((x*(1024*4096))+(y*4096)));
         //Return The Address Of The Newly Allocate Page
         return((void *)((x*(1024*4096))+(y*4096)));
         }
@@ -490,6 +509,10 @@
   pageTable = (uLong *)(tablesBaseAddress + (4096 * destPageDirectoryIndex));    
   //Get The Index To The Page Table
   destPageTableIndex = ((dest-(destPageDirectoryIndex*(1024*4096)))/4096);
+  //If The Page Is Mapped In Free It Before We Remap
+  if (pageTable[destPageTableIndex] > 0) {
+    freePage(((uLong)pageTable[destPageTableIndex] & 0xFFFFF000));
+    }
   //Set The Source Address In The Destination
   pageTable[destPageTableIndex] = (uLong)(source | pageDefault);
   //Reload The Page Table;
@@ -540,7 +563,7 @@
       //Set Src To Base Address Of Page To Copy
       src = (uLong *) ((1024*4096*pageDirectoryIndex) + (4096*pageTableIndex));
       //Allocate A Free Page For Destination
-      dst = (uLong *) getFreePage();
+      dst = (uLong *) getFreePage(-1);
       //Copy Memory
       for (i=0;i<pageEntries;i++) {
         dst[i] = src[i];
@@ -549,6 +572,8 @@
       pageTable[pageTableIndex] = (uLong)((uLong)getPhysicalAddr((uLong)dst)|pageDefault);
       //Unlink From Memory Map Allocated Page
       unmapPage((uLong)dst,1);
+      //Adjust The COW Counter For Physical Page
+      adjustCowCounter(((uLong)pageTable[pageTableIndex] & 0xFFFFF000),-1);
       }
     else {
       //Need To Create A Routine For Attempting To Access Non Mapped Memory