diff --git a/src/sys/include/vmm/memory.h b/src/sys/include/vmm/memory.h
index a579bc0..0326236 100755
--- a/src/sys/include/vmm/memory.h
+++ b/src/sys/include/vmm/memory.h
@@ -39,9 +39,9 @@
 extern int numPages;
 
 int countMemory();
-unsigned long findFreepage(int pid);
+unsigned long findFreePage(int pid);
 void initMmap();
-void freePage(unsigned long pageAddr);
+//void freePage(unsigned long pageAddr);
 void freeProcesspages(int pid);
 
 #endif
\ No newline at end of file
diff --git a/src/sys/include/vmm/paging.h b/src/sys/include/vmm/paging.h
index c3ca266..10829dd 100755
--- a/src/sys/include/vmm/paging.h
+++ b/src/sys/include/vmm/paging.h
@@ -26,22 +26,27 @@
 
 #include <ubixos/types.h>
 
-#define pageLength  0x00000400
-#define pageSize    4096
-#define pageEntries (pageSize/4)
-#define pagePresent 0x00000001
-#define pageWrite   0x00000002
-#define pageUser    0x00000004
-#define pageDefault (pagePresent|pageWrite|pageUser)
+#define pageLength        0x00000400
+#define pageSize          4096
+#define pageEntries       (pageSize/4)
+#define pagePresent       0x00000001
+#define pageWrite         0x00000002
+#define pageUser          0x00000004
+#define pageDefault       (pagePresent|pageWrite|pageUser)
+#define tablesBaseAddress 0xBFC00000
+#define parentPageDirAddr 0x100000
 
 extern uLong *kernelPageDirectory;
 extern uLong *pageDirectory;
 extern uLong memoryStart;
 
-//void initPaging();
 void initPagingSystem();
-unsigned int allocPage();
+void *createVirtualSpace();
 void remapPage(uLong source,uLong dest);
+void freePage(uLong pageAddr);
+void unmapPage(uLong pageAddr,int flags);
+void *getFreePage();
+void *getPhysicalAddr(uLong pageAddr);
 void pageFault();
 void _pageFault();
 
diff --git a/src/sys/kernel/exec.c b/src/sys/kernel/exec.c
index d8856a8..58b0595 100755
--- a/src/sys/kernel/exec.c
+++ b/src/sys/kernel/exec.c
@@ -38,7 +38,7 @@
   elfProgramheader *programHeader;
   newProcess = findTask();
   pid = newProcess->id;
-  pdn = (uLong *)allocPage();
+//  pdn = (uLong *)allocPage();
   for (i=0;i<1024;i++) {
     pdn[i] = 0x0;
     }
diff --git a/src/sys/kernel/schedule.c b/src/sys/kernel/schedule.c
index c7235da..8ced83f 100755
--- a/src/sys/kernel/schedule.c
+++ b/src/sys/kernel/schedule.c
@@ -60,9 +60,9 @@
 void initScheduler(void) {
   int i;
   for (i=0;i<(sizeof(kTask_t)*1024)/0x1000;i++) {
-    remapPage(allocPage(),(0xE0800000+(i*0x1000)));
+    remapPage(getFreePage(-1),(0xE0800000+(i*0x1000)));
     }
-  remapPage(allocPage(),(0xE0800000-0x1000));
+  remapPage(getFreePage(-1),(0xE0800000-0x1000));
   taskList[-1].id = -1;
   taskList[-1].status = EMPTY;
   for (i=0;i<numTasks;i++) {
diff --git a/src/sys/vmm/memory.c b/src/sys/vmm/memory.c
index 6a7d772..55714e1 100755
--- a/src/sys/vmm/memory.c
+++ b/src/sys/vmm/memory.c
@@ -96,7 +96,7 @@
 void initMmap() {
   int i=0;
   numPages = countMemory();
-  memoryMap = (mMap *) 0x100000;
+  memoryMap = (mMap *) 0x101000;
   for (i=0;i<numPages;i++) {
     memoryMap[i].status = memNotavail;
     memoryMap[i].pid = -1;
@@ -113,7 +113,7 @@
   */
   }
 
-unsigned long findFreepage(int pid) {
+unsigned long findFreePage(int pid) {
   int i=0;
   for (i=0;i<=numPages;i++) {
     if (memoryMap[i].status == memAvail) {
@@ -124,12 +124,13 @@
     }
   return(-1);
   }
-
+/*
 void freePage(unsigned long pageAddr) {
   int i=0;
   i = (pageAddr/4096);
   memoryMap[i].status = memAvail;
   }
+*/
 
 void freeProcesspages(int pid) {
   int i=0;
diff --git a/src/sys/vmm/paging.c b/src/sys/vmm/paging.c
index ab1b81a..05a9004 100755
--- a/src/sys/vmm/paging.c
+++ b/src/sys/vmm/paging.c
@@ -44,20 +44,20 @@
 07/30/02 - I Decided That To Save On Performance All Page Tables Will Be
            Mapped In At BFC00000 So That Memory Does Not Need To Be Relocated
            To Alter Page Tables.
-           Also Put Page Index At 0xC0000000
+           Also Put Page Index At 0x100000
            
 ************************************************************************/
 void initPagingSystem() {
   int i=0,x=0;
   uLong *pageTable;
   //Allocate A Page For The Kernels VM Space Page Directory
-  kernelPageDirectory = (uLong *)allocPage();
+  kernelPageDirectory = (uLong *)findFreePage(_current->id);
   //Make Sure The Page Directory Is Clean
   for (i=0;i<pageEntries;i++) {
     kernelPageDirectory[i] = (uLong)0x0;
     }
   //Allocate A Page For The First 4MB Of Memory
-  pageTable = (uLong *)allocPage();
+  pageTable = (uLong *)findFreePage(_current->id);
   kernelPageDirectory[0] = (uLong)((uLong)(pageTable) | pageDefault);
   //Make Sure The Page Table Is Clean
   for (i=0;i<pageEntries;i++) {
@@ -69,7 +69,7 @@
     }
   //Create Page Tables For The Top 1GB Of VM Space This Is To Be Shared With All VM Spaces
   for (i=767;i<pageEntries;i++) {
-    pageTable = (uLong *)allocPage();
+    pageTable = (uLong *)findFreePage(_current->id);
     //Make Sure The Page Table Is Clean
     for (x=0;x<pageEntries;x++) {
       pageTable[x] = (uLong)0x0;
@@ -83,8 +83,8 @@
     pageTable[i] = kernelPageDirectory[i];
     }
   //Also Set Up Page Directory To Be The The First Page In 0xE0400000
-  pageTable = (uLong *)(kernelPageDirectory[768] & 0xFFFFF000);
-  pageTable[0] = (uLong)((uLong)(kernelPageDirectory) | pageDefault);
+  pageTable = (uLong *)(kernelPageDirectory[0] & 0xFFFFF000);
+  pageTable[256] = (uLong)((uLong)(kernelPageDirectory) | pageDefault);
   //Now Lets Turn On Paging With This Initial Page Table
   asm(
     "movl %0,%%eax          \n"
@@ -97,14 +97,163 @@
   //Now Add The IDT Entry For Page Faults
   setVector(_pageFault,14,dPresent + dInt + dDpl3);        
   //Remap The Memory List
-  for (i=0x100000;i<=(0x100000+(numPages*8));i+=0x1000) {
-    remapPage(i,(0xE6667000+(i-0x100000)));
+  for (i=0x101000;i<=(0x101000+(numPages*8));i+=0x1000) {
+    remapPage(i,(0xE6667000+(i-0x101000)));
     }
   memoryMap = (mMap *)0xE6667000;
-  }                           
+  }
 
 /************************************************************************
 
+Function: void *getPhysicalAddr();
+Description: Returns The Physical Address Of The Virtual Page
+Notes:
+
+************************************************************************/
+void *getPhysicalAddr(uLong pageAddr) {
+  int pageDirectoryIndex=0,pageTableIndex=0;
+  uLong *pageTable = 0x0;
+  //Get The Index To The Page Directory
+  pageDirectoryIndex = (pageAddr/(1024*4096));
+  //Get The Index To The Page Table
+  pageTableIndex = ((pageAddr-(pageDirectoryIndex*(1024*4096)))/4096);
+  //Set pageTable To The Virtual Address Of Table
+  pageTable = (uLong *)(tablesBaseAddress + (4096 * pageDirectoryIndex));
+  //Return The Physical Address Of The Page
+  return((void *)(pageTable[pageTableIndex] & 0xFFFFF000));
+  }
+
+/************************************************************************
+
+Function: void freePage(uLong pageAddr);
+Description: This Function Marks The Page As Free
+Notes:
+
+07/30/02 - This Was Moved Out Of memory.c Into Here
+
+************************************************************************/
+void freePage(uLong pageAddr) {
+  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;
+  }
+    
+/************************************************************************
+
+Function: void unmapPage(uLong pageAddr,int flags);
+Description: This Function Will Unmap A Page From The Kernel VM Space
+             The Flags Variable Decides If Its To Free The Page Or Not
+             A Flag Of 0 Will Free It And A Flag Of 1 Will Keep It
+Notes:
+
+07/30/02 - I Have Decided That This Should Free The Physical Page There
+           Is No Reason To Keep It Marked As Not Available
+
+07/30/02 - Ok A Found A Reason To Keep It Marked As Available I Admit
+           Even I Am Not Perfect Ok The Case Where You Wouldn't Want To
+           Free It Would Be On Something Like Where I Allocated A Page
+           To Create A New Virtual Space So Now It Has A Flag
+
+************************************************************************/  
+void unmapPage(uLong pageAddr,int flags) {
+    int pageDirectoryIndex=0,pageTableIndex=0;
+  uLong *pageTable = 0x0;
+  //Get The Index To The Page Directory
+  pageDirectoryIndex = (pageAddr/(1024*4096));
+  //Get The Index To The Page Table
+  pageTableIndex = ((pageAddr-(pageDirectoryIndex*(1024*4096)))/4096);
+  //Set pageTable To The Virtual Address Of Table
+  pageTable = (uLong *)(tablesBaseAddress + (4096 * pageDirectoryIndex));
+  //Free The Physical Page If Flags Is 0
+  if (flags == 0) {
+    freePage((pageTable[pageTableIndex] & 0xFFFFF000));
+    }
+  //Unmap The Page
+  pageTable[pageTableIndex] = 0x0;
+  //Rehash The Page Directory
+  asm(
+    "movl %cr3,%eax\n"
+    "movl %eax,%cr3\n"
+    );
+  }
+                                                  
+/************************************************************************
+
+Function: void *createVirtualSpace();
+Description: Creates A Virtual Space For A New Task
+Notes:
+
+07/30/02 - This Is Going To Create A New VM Space However Its Going To
+           Share The Same Top 1GB Space With The Kernels VM And Lower
+           1MB Of VM Space With The Kernel
+           
+07/30/02 - Note This Is Going To Get The Top 1Gig And Lower 1MB Region
+           From The Currently Loaded Page Directory This Is Safe Because
+           All VM Spaces Will Share These Regions
+
+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.           
+           
+************************************************************************/
+void *createVirtualSpace() {
+  void *newPageDirectoryAddress = 0x0;
+  uLong *parentPageDirectory = 0x0,*newPageDirectory = 0x0;
+  uLong *parentPageTable = 0x0,*newPageTable = 0x0;
+  int x = 0;
+  //Set Address Of Parent Page Directory
+  parentPageDirectory = (uLong *)parentPageDirAddr;
+  //Allocate A New Page For The New Page Directory  
+  newPageDirectory = (uLong *)getFreePage();
+  //Set newPageDirectoryAddress To The Newly Created Page Directories Page
+  newPageDirectoryAddress = getPhysicalAddr((uLong)newPageDirectory);
+  //Map The Top 1GB Region Of The VM Space
+  for (x=768;x<pageEntries;x++) {
+    newPageDirectory[x] = parentPageDirectory[x];
+    }
+  /*
+  Allocate A New Page For The The First Page Table Where We Will Map The
+  Lower Region
+  */
+  newPageTable = (uLong *)getFreePage();
+  //Map This Into The Page Directory
+  newPageDirectory[0] = ((uLong)newPageTable | pageDefault);
+  //Set Address Of Parents Page Table
+  parentPageTable = (uLong *)tablesBaseAddress;
+  //Map The First 1MB Worth Of Pages
+  for (x=0;x<256;x++) {
+    newPageTable[x] = parentPageTable[x];
+    }
+  //Set Virtual Mapping For Page Directory
+  newPageTable[256] = ((uLong)getPhysicalAddr((uLong)newPageDirectory) | pageDefault);
+  /*
+  Now The Fun Stuff Build The Initial Virtual Page Space So We Don't
+  Have To Worry About Mapping Them In Later How Ever I'm Concerned This
+  May Become A Security Issue
+  */
+  //First Lets Unmap The Previously Allocated Page Table
+  unmapPage((uLong)newPageTable,1);
+  //Allocate A New Page Table
+  newPageTable = (uLong *)getFreePage();
+  //First Set Our Page Directory To Contain This
+  newPageDirectory[767] = (uLong)newPageTable | pageDefault;
+  //Now Lets Build The Page Table
+  for (x=0;x<pageEntries;x++) {
+    newPageTable[x] = newPageDirectory[x];
+    }
+  //Now We Are Done So Lets Unmap This Page
+  unmapPage((uLong)newPageTable,1);
+  //Now We Are Done With The Page Directory So Lets Unmap That Too
+  unmapPage((uLong)newPageDirectory,1);
+  //Return Physical Address Of Page Directory
+  return(newPageDirectoryAddress);    
+  }
+  
+/************************************************************************
+
 Function: void *getFreePage();
 Description: Returns A Free Page Mapped To The VM Space
 Notes:
@@ -118,32 +267,20 @@
   //Lets Search For A Free Page
   for (x=768;x<1024;x++) {
     //Set Page Table Address
-    pageTableSrc = (uLong *)(0xBFC00000 + (4096*x));
+    pageTableSrc = (uLong *)(tablesBaseAddress + (4096*x));
     for (y=0;y<1024;y++) {
       //Loop Through The Page Table Find An UnAllocated Page
       if ((uLong)pageTableSrc[y] == (uLong)0x0) {
         //Map A Physical Page To The Virtual Page
-        remapPage(allocPage(),((x*(1024*4096))+(y*4096)));
+        remapPage(findFreePage(_current->id),((x*(1024*4096))+(y*4096)));
         //Return The Address Of The Newly Allocate Page
-        return(((x*(1024*4096))+(y*4096)));
+        return((void *)((x*(1024*4096))+(y*4096)));
         }
       }
     }
   //If No Free Page Was Found Return NULL
   return(0x0);
   }
-unsigned int allocPage() {
-  uLong page;
-  page = findFreepage(_current->id);
-  /*
-  if (memoryStart%4096 != 0) {
-   memoryStart += 4096 - memoryStart%4096;
-   }
-  page = memoryStart;
-  memoryStart += 4096;
-  */
-  return(page);
-  }
 
 /************************************************************************
 
@@ -160,14 +297,14 @@
   uShort destPageDirectoryIndex=0,destPageTableIndex=0;
   uLong *pageDir,*pageTable;
   //Set Pointer pageDirectory To Point To The Virtual Mapping Of The Page Directory
-  pageDir = (uLong *)0xC0000000;
+  pageDir = (uLong *)parentPageDirAddr;
   //Check To See If Page Table Exists
   destPageDirectoryIndex = (dest/(1024*4096));
   if (pageDir[destPageDirectoryIndex] == 0) {
     //If Page Table Is Non Existant Then Set It Up
-    pageDir[destPageDirectoryIndex] = (uLong)allocPage() | pageDefault;
+    pageDir[destPageDirectoryIndex] = (uLong)findFreePage(_current->id) | pageDefault;
     //Also Add It To Virtual Space So We Can Make Changes Later
-    pageTable = (uLong *)(0xBFC00000 + (4096 * 767));
+    pageTable = (uLong *)(tablesBaseAddress + (4096 * 767));
     pageTable[destPageDirectoryIndex] = pageDir[destPageDirectoryIndex];
     //Reload Page Directory
     asm(
@@ -176,7 +313,7 @@
       );
     }
   //Set Address To Page Table
-  pageTable = (uLong *)(0xBFC00000 + (4096 * destPageDirectoryIndex));    
+  pageTable = (uLong *)(tablesBaseAddress + (4096 * destPageDirectoryIndex));    
   //Get The Index To The Page Table
   destPageTableIndex = ((dest-(destPageDirectoryIndex*(1024*4096)))/4096);
   //Set The Source Address In The Destination
@@ -188,6 +325,18 @@
     );
   }
 
+/************************************************************************
+
+Function: void pageFault();
+Description: This Function Is The Second Half Of The Page Fault ISR
+             Currently It Handles COW However I Need To Prepar It For
+             Swapping
+Notes:
+
+07/30/02 - Fixed COW However I Need To Think Of A Way To Impliment
+           A Paging System Also Start To Add Security Levels
+
+************************************************************************/     
 void pageFault() {
   uLong cr2 = 0,i = 0, page = 0,pi = 0;
   uLong *pageDir,*pageTable;
@@ -208,25 +357,25 @@
   if (pageDir[pi] == 0) {
     kprintf("Dumb Ass You Forgot To Allocate Memory [%i]\n",cr2);
     while (1);
-    pageTable = (uLong *)allocPage();
+//    pageTable = (uLong *)allocPage();
     pageDir[pi] = (uLong)pageTable | pageDefault;
     for (i=0;i<1024;i++) {
       pageTable[i] = 0;
       }
-    pageTable[page] = allocPage() | pageDefault;
+//    pageTable[page] = allocPage() | pageDefault;
     }
   else {
     pageTable = (uLong *)(pageDir[pi] & 0xFFFFF000);
     if (pageTable[page] > 0) {
       src = (uChar *) (pageTable[page] & 0xFFFFF000);
-      pageTable[page] = allocPage() | pageDefault;
+      pageTable[page] = findFreePage(_current->id) | pageDefault;
       dst = (uChar *) (pageTable[page] & 0xFFFFF000);
       for (i=0;i<4096;i++) {
         dst[i] = src[i];
         }
       }
     else {
-      pageTable[page] = allocPage() | pageDefault;
+      pageTable[page] = findFreePage(_current->id) | pageDefault;
       }
     }
   asm(
@@ -235,6 +384,13 @@
     );
   }
 
+/************************************************************************
+
+Function: void _pageFault()
+Description: This Is The ASM Code That Calls The pageFault() Function
+Notes:
+
+************************************************************************/
 asm(
     ".global _pageFault  \n"
     "_pageFault:         \n"