diff --git a/src/bin/ld/addlibrary.c b/src/bin/ld/addlibrary.c
index d8330d9..402e40f 100644
--- a/src/bin/ld/addlibrary.c
+++ b/src/bin/ld/addlibrary.c
@@ -121,12 +121,15 @@
             case R_386_RELATIVE:
               *reMap += (uInt32)tmpLib->output;
               break;
-            case R_386_GLOB_DAT:
             case R_386_JMP_SLOT:
               *reMap += (uInt32)tmpLib->output;
               break;
+            case R_386_GLOB_DAT:
+              *reMap = ((uInt32)tmpLib->output + tmpLib->linkerRelSymTab[rel].dynValue);
+              break;
             default:
               printf("Unhandled sym: [0x%X]\n", ELF32_R_TYPE(tmpLib->linkerElfRel[x].pltInfo));
+              while (1);
               break;
             }
           }
diff --git a/src/lib/libc/i386/Makefile.inc b/src/lib/libc/i386/Makefile.inc
index 55ed355..ec4bcba 100755
--- a/src/lib/libc/i386/Makefile.inc
+++ b/src/lib/libc/i386/Makefile.inc
@@ -1,2 +1,2 @@
 INCLUDES = -I../../include -I../../../../include.new
-CFLAGS += -DPORTMAP -D__DBINTERFACE_PRIVATE -nostdinc
+CFLAGS += -DPIC -DPORTMAP -D__DBINTERFACE_PRIVATE -nostdinc
diff --git a/src/lib/libc/stdio/makebuf.c b/src/lib/libc/stdio/makebuf.c
index a76e9ba..a3de9fa 100644
--- a/src/lib/libc/stdio/makebuf.c
+++ b/src/lib/libc/stdio/makebuf.c
@@ -96,7 +96,6 @@
 	int *couldbetty;
 {
 	struct stat st;
-__sys_write(1,"swhatbuf");
 	if (fp->_file < 0 || _fstat(fp->_file, &st) < 0) {
 		*couldbetty = 0;
 		*bufsize = BUFSIZ;
diff --git a/src/lib/libc/stdio/wsetup.c b/src/lib/libc/stdio/wsetup.c
index 2cdf557..8d10c35 100644
--- a/src/lib/libc/stdio/wsetup.c
+++ b/src/lib/libc/stdio/wsetup.c
@@ -75,7 +75,6 @@
 		}
 		fp->_flags |= __SWR;
 	}
-        __sys_write(1,"BBB");
 
 	/*
 	 * Make a buffer if necessary, then set _w.
diff --git a/src/lib/libc/stdlib/malloc.c b/src/lib/libc/stdlib/malloc.c
index 6e2f9cd..343da15 100644
--- a/src/lib/libc/stdlib/malloc.c
+++ b/src/lib/libc/stdlib/malloc.c
@@ -320,14 +320,17 @@
     if (tail < result)
 	return (NULL);
 
+ //   __sys_write(1,"<Z>");
+
     if (brk(tail)) {
 	wrterror("(ES): map_pages fails\n");
 	return (NULL);
     }
-
+    __sys_write(1,"<X>");
     last_index = ptr2index(tail) - 1;
     malloc_brk = tail;
 
+
     if ((last_index+1) >= malloc_ninfo && !extend_pgdir(last_index))
 	return (NULL);
 
@@ -457,9 +460,10 @@
      */
     if (malloc_zero)
 	malloc_junk=1;
-
+    __sys_write(1,"<A>");
     /* Allocate one page for the page directory */
     page_dir = (struct pginfo **) MMAP(malloc_pagesize);
+    __sys_write(1,"<B>");
 
     if (page_dir == MAP_FAILED)
 	wrterror("mmap(2) failed, check limits\n");
@@ -470,7 +474,7 @@
      */
     malloc_origo = ((u_long)pageround((u_long)sbrk(0))) >> malloc_pageshift;
     malloc_origo -= malloc_pageshift;
-
+    __sys_write(1,"<B.B>");
     malloc_ninfo = malloc_pagesize / sizeof *page_dir;
 
     /* Recalculate the cache size in bytes, and make sure it's nonzero */
@@ -502,11 +506,12 @@
     size = pageround(size);
 
     p = NULL;
-
+  __sys_write(1,"<IK>");
     /* Look for free pages before asking for more */
     for(pf = free_list.next; pf; pf = pf->next) {
-
+  __sys_write(1,"<I.I>");
 #ifdef MALLOC_EXTRA_SANITY
+__sys_write(1,"<*>");
 	if (pf->size & malloc_pagemask)
 	    wrterror("(ES): junk length entry on free_list\n");
 	if (!pf->size)
@@ -534,6 +539,7 @@
 	    delay_free = pf;
 	    break;
 	}
+  __sys_write(1,"<J>");
 
 	p = pf->page;
 	pf->page = (char *)pf->page + size;
@@ -547,10 +553,11 @@
 #endif /* MALLOC_EXTRA_SANITY */
 
     size >>= malloc_pageshift;
-
+    __sys_write(1,"<K>");
     /* Map new pages */
     if (p == NULL)
 	p = map_pages(size);
+    __sys_write(1,"<L>");
 
     if (p != NULL) {
 
@@ -585,10 +592,11 @@
     int i, k, l;
 
     /* Allocate a new bucket */
+    __sys_write(1,"<G>");
     pp = malloc_pages(malloc_pagesize);
     if (pp == NULL)
 	return (0);
-
+    __sys_write(1,"<H>");
     /* Find length of admin structure */
     l = offsetof(struct pginfo, bits[0]);
     l += sizeof bp->bits[0] *
@@ -664,11 +672,11 @@
     i = size-1;
     while (i >>= 1)
 	j++;
-
+    __sys_write(1,"<E>");
     /* If it's empty, make a page more of that size chunks */
     if (page_dir[j] == NULL && !malloc_make_chunks(j))
 	return (NULL);
-
+    __sys_write(1,"<F>");
     bp = page_dir[j];
 
     /* Find first word of bitmap which isn't empty */
@@ -718,9 +726,11 @@
     result = NULL;
     }
   else if (size <= malloc_maxsize) {
+    __sys_write(1,"<C>");
     result = malloc_bytes(size);
     }
   else {
+    __sys_write(1,"<D>");
     result = malloc_pages(size);
     }
 
diff --git a/src/sys/include/sys/thread.h b/src/sys/include/sys/thread.h
index 089731b..1bb8a10 100644
--- a/src/sys/include/sys/thread.h
+++ b/src/sys/include/sys/thread.h
@@ -34,6 +34,7 @@
   int     td_retval[2];
   uInt32  o_files[1024]; 
   uInt32  vm_daddr;
+  uInt32  vm_dsize;
   };
 
 #endif
diff --git a/src/sys/include/ubixos/kpanic.h b/src/sys/include/ubixos/kpanic.h
index 4055f01..3b96ef6 100644
--- a/src/sys/include/ubixos/kpanic.h
+++ b/src/sys/include/ubixos/kpanic.h
@@ -30,21 +30,13 @@
 #ifndef _KPANIC_H
 #define _KPANIC_H
 
+#define K_PANIC(msg) kpanic("Error: (%s), File: %s, Line: %i\n",msg ,__FILE__,__LINE__);
+
 void kpanic(const char *fmt, ...);
 
 #endif
 
 /***
- $Log$
- Revision 1.2  2005/10/12 00:13:37  reddawg
- Removed
-
- Revision 1.1.1.1  2005/09/26 17:23:55  reddawg
- no message
-
- Revision 1.2  2004/05/21 15:20:00  reddawg
- Cleaned up
-
-
  END
  ***/
+
diff --git a/src/sys/include/vmm/paging.h b/src/sys/include/vmm/paging.h
index 08eba72..e561322 100644
--- a/src/sys/include/vmm/paging.h
+++ b/src/sys/include/vmm/paging.h
@@ -48,6 +48,13 @@
 #define PAGE_DEFAULT        (PAGE_PRESENT|PAGE_WRITE|PAGE_USER)
 #define KERNEL_PAGE_DEFAULT (PAGE_PRESENT|PAGE_WRITE)
 
+#define PAGE_SHIFT      12              /* LOG2(PAGE_SIZE) */
+#define PAGE_SIZE       (1<<PAGE_SHIFT) /* bytes/page */
+#define PAGE_MASK       (PAGE_SIZE-1)
+
+#define trunc_page(x)           ((x) & ~PAGE_MASK)
+#define round_page(x)           (((x) + PAGE_MASK) & ~PAGE_MASK)
+
 int vmmClearVirtualPage(uInt32 pageAddr);
 
 void vmmUnmapPage(uInt32,int);
@@ -57,7 +64,7 @@
 void *vmmGetFreePage(pidType);
 void *vmmGetFreeKernelPage(pidType pid,uInt16 count);
 void *vmmCreateVirtualSpace(pidType);
-void *vmmGetFreeVirtualPage(pidType,int);
+void *vmmGetFreeVirtualPage(pidType,int,int);
 
 uInt32 vmm_getPhysicalAddr(uInt32);
 int    vmm_setPageAttributes(uInt32,uInt16);
diff --git a/src/sys/init/main.c b/src/sys/init/main.c
index c12fa02..acabdcc 100644
--- a/src/sys/init/main.c
+++ b/src/sys/init/main.c
@@ -38,6 +38,26 @@
 #include <lib/kprintf.h>
 #include <lib/kmalloc.h>
 
+#define B_ADAPTORSHIFT          24
+#define B_ADAPTORMASK           0x0f
+#define B_ADAPTOR(val)          (((val) >> B_ADAPTORSHIFT) & B_ADAPTORMASK)
+#define B_CONTROLLERSHIFT       20
+#define B_CONTROLLERMASK        0xf
+#define B_CONTROLLER(val)       (((val)>>B_CONTROLLERSHIFT) & B_CONTROLLERMASK)
+#define B_SLICESHIFT            20
+#define B_SLICEMASK             0xff
+#define B_SLICE(val)            (((val)>>B_SLICESHIFT) & B_SLICEMASK)
+#define B_UNITSHIFT             16
+#define B_UNITMASK              0xf
+#define B_UNIT(val)             (((val) >> B_UNITSHIFT) & B_UNITMASK)
+#define B_PARTITIONSHIFT        8
+#define B_PARTITIONMASK         0xff
+#define B_PARTITION(val)        (((val) >> B_PARTITIONSHIFT) & B_PARTITIONMASK)
+#define B_TYPESHIFT             0
+#define B_TYPEMASK              0xff
+#define B_TYPE(val)             (((val) >> B_TYPESHIFT) & B_TYPEMASK)
+
+
 /*****************************************************************************************
  Desc: The Kernels Descriptor table:
        0x00 - Dummy Entry
@@ -78,7 +98,7 @@
  Notes: 
 
 *****************************************************************************************/
-int main() {
+int kmain(uInt32 rootdev) {
   /* Set up counter for startup routine */
   int i = 0x0;
   uInt32 *sysTask;
@@ -95,7 +115,8 @@
 
   /* New Root Mount Point */
   //Old 2 new 10
-  if (vfs_mount(0x1,2,0x0,0xAA,"sys","rw") != 0x0) {
+  kprintf("[0xX][0x%X:0x%X:0x%X:0x%X:0x%X:0x%X]\n",B_ADAPTOR(rootdev),B_CONTROLLER(rootdev),B_SLICE(rootdev),B_UNIT(rootdev),B_PARTITION(rootdev),B_TYPE(rootdev));
+  if (vfs_mount(0x1,B_PARTITION(rootdev)+2,0x0,0xAA,"sys","rw") != 0x0) {
     kprintf("Problem Mounting sys Mount Point\n");
     }
 
diff --git a/src/sys/init/start.S b/src/sys/init/start.S
index 8a1d46b..9619706 100644
--- a/src/sys/init/start.S
+++ b/src/sys/init/start.S
@@ -40,6 +40,7 @@
   mov   %eax,%ss
   mov   $kStack,%eax
   addl  $0x2000,%eax
+  mov   %esp,%edx
   mov   %eax,%esp
   mov   %eax,%ebp 
   mov   $0x18,%ax
@@ -48,7 +49,8 @@
   ltr   %ax
   ljmp  $0x08,$start_next
 start_next:
-  call main
+  push 8(%edx)
+  call kmain
 
 .data
 .comm kStack,0x2000
diff --git a/src/sys/kernel/exec.c b/src/sys/kernel/exec.c
index c948f4e..3308ff2 100644
--- a/src/sys/kernel/exec.c
+++ b/src/sys/kernel/exec.c
@@ -226,10 +226,11 @@
       Allocate Memory Im Going To Have To Make This Load Memory With Correct
       Settings so it helps us in the future
       */
-      for (x = 0x0;x < (programHeader[i].phMemsz+4095);x += 0x1000) {
+      for (x = 0x0;x < (programHeader[i].phMemsz);x += 0x1000) {
         /* Make readonly and read/write !!! */
         if (vmm_remapPage(vmmFindFreePage(_current->id),((programHeader[i].phVaddr & 0xFFFFF000) + x),PAGE_DEFAULT) == 0x0)
-          kpanic("Error: vmmFindFreePage Failed\n");
+          K_PANIC("Remap Page Failed");
+
         memset((void *)((programHeader[i].phVaddr & 0xFFFFF000) + x),0x0,0x1000);
         }
       _current->oInfo.vmStart = 0x80000000;//((programHeader[i].phVaddr & 0xFFFFF000) + 0x1900000);
@@ -238,7 +239,8 @@
       fseek(tmpFd,programHeader[i].phOffset,0);
       fread((void *)programHeader[i].phVaddr,programHeader[i].phFilesz,1,tmpFd);
       if ((programHeader[i].phFlags & 0x2) != 0x2) {
-        for (x = 0x0;x < (programHeader[i].phMemsz+4095);x += 0x1000) {
+        kprintf("pH: [0x%X]\n",programHeader[i].phMemsz);
+        for (x = 0x0;x < (programHeader[i].phMemsz);x += 0x1000) {
           if ((vmm_setPageAttributes((programHeader[i].phVaddr & 0xFFFFF000) + x,PAGE_PRESENT | PAGE_USER)) != 0x0)
 	    kpanic("Error: vmm_setPageAttributes failed, File: %s, Line: %i\n",__FILE__,__LINE__);
 	  }
@@ -345,16 +347,19 @@
 
 *****************************************************************************************/
 void sysExec(char *file,int argc,char **argv) {
-  int    i            = 0x0;
-  int    x            = 0x0;
+  int     i           = 0x0;
+  int     x           = 0x0;
   uInt32 *tmp         = 0x0;
   uInt32  ldAddr      = 0x0;
+  uInt32  seg_size    = 0x0;
+  uInt32  seg_addr    = 0x0;
 
   fileDescriptor   *tmpFd         = 0x0;
   elfHeader        *binaryHeader  = 0x0;
   elfProgramHeader *programHeader = 0x0;
   elfSectionHeader *sectionHeader = 0x0;
   elfDynamic       *elfDynamicS   = 0x0;
+
   tmpFd = fopen(file,"r");
   _current->imageFd = tmpFd;
   /* If We Dont Find the File Return */
@@ -412,38 +417,64 @@
 
   /* Loop Through The Header And Load Sections Which Need To Be Loaded */
   for (i=0;i<binaryHeader->ePhnum;i++) {
-    if (programHeader[i].phType == 1) {
-      /*
-      Allocate Memory Im Going To Have To Make This Load Memory With Correct
-      Settings so it helps us in the future
-      */
-      for (x=0;x<(programHeader[i].phMemsz+4095);x += 0x1000) {
-        /* Make readonly and read/write !!! */
-        if (vmm_remapPage(vmmFindFreePage(_current->id),((programHeader[i].phVaddr & 0xFFFFF000) + x),PAGE_DEFAULT) == 0x0)
-          kpanic("Error: vmmFindFreePage Failed\n");
-        memset((void *)((programHeader[i].phVaddr & 0xFFFFF000) + x),0x0,0x1000);
-        }
-      _current->oInfo.vmStart = 0x80000000;//((programHeader[i].phVaddr & 0xFFFFF000) + 0x1900000);
-      _current->td.vm_daddr = (programHeader[i].phVaddr & 0xFFFFF000);
+    switch (programHeader[i].phType) {
+      case PT_LOAD:
+        seg_addr = trunc_page(programHeader[i].phVaddr);
+        seg_size = round_page(programHeader[i].phMemsz + programHeader[i].phVaddr - seg_addr);
 
-      /* Now Load Section To Memory */
-      fseek(tmpFd,programHeader[i].phOffset,0);
-      fread((void *)programHeader[i].phVaddr,programHeader[i].phFilesz,1,tmpFd);
-      if ((programHeader[i].phFlags & 0x2) != 0x2) {
-        for (x = 0x0;x < (programHeader[i].phMemsz+4095);x += 0x1000) {
-          if ((vmm_setPageAttributes((programHeader[i].phVaddr & 0xFFFFF000) + x,PAGE_PRESENT | PAGE_USER)) != 0x0)
-	    kpanic("Error: vmm_setPageAttributes failed, File: %s,Line: %i\n",__FILE__,__LINE__);
-	  }
-        }
-      }
-    else if (programHeader[i].phType == 2) {
-      //newLoc = (char *)programHeader[i].phVaddr;
-      elfDynamicS = (elfDynamic *)programHeader[i].phVaddr;
-      fseek(tmpFd,programHeader[i].phOffset,0);
-      fread((void *)programHeader[i].phVaddr,programHeader[i].phFilesz,1,tmpFd);
-      }
-    else if (programHeader[i].phType == 3) {
-      ldAddr = ldEnable();
+        /*
+        Allocate Memory Im Going To Have To Make This Load Memory With Correct
+        Settings so it helps us in the future
+        */
+        for (x=0;x<(programHeader[i].phMemsz);x += 0x1000) {
+          /* Make readonly and read/write !!! */
+          if (vmm_remapPage(vmmFindFreePage(_current->id),((programHeader[i].phVaddr & 0xFFFFF000) + x),PAGE_DEFAULT) == 0x0)
+            K_PANIC("Error: Remap Page Failed");
+          memset((void *)((programHeader[i].phVaddr & 0xFFFFF000) + x),0x0,0x1000);
+          }
+
+        /* Now Load Section To Memory */
+        fseek(tmpFd,programHeader[i].phOffset,0);
+        fread((void *)programHeader[i].phVaddr,programHeader[i].phFilesz,1,tmpFd);
+        if ((programHeader[i].phFlags & 0x2) != 0x2) {
+          for (x = 0x0;x < (programHeader[i].phMemsz);x += 0x1000) {
+            if ((vmm_setPageAttributes((programHeader[i].phVaddr & 0xFFFFF000) + x,PAGE_PRESENT | PAGE_USER)) != 0x0)
+	      kpanic("Error: vmm_setPageAttributes failed, File: %s,Line: %i\n",__FILE__,__LINE__);
+	    }
+          }
+        kprintf("setting daddr\n");
+        if (binaryHeader->eEntry >= programHeader[i].phVaddr && binaryHeader->eEntry < (programHeader[i].phVaddr + programHeader[i].phMemsz)) {
+          /*
+          text_size = seg_size;
+          text_addr = seg_addr;
+          entry = (u_long)hdr->e_entry;
+          */
+  //        kprintf("A[0x%X:0x%X:0x%X]",seg_size,seg_addr,seg_addr + seg_size);
+          }
+        else {
+          /*
+          data_size = seg_size;
+          data_addr = seg_addr;
+          */
+ //         kprintf("B[0x%X:0x%X:0x%X]",seg_size,seg_addr,seg_addr + seg_size);
+          //_current->td.vm_daddr = (programHeader[i].phVaddr & 0xFFFFF000);
+          _current->td.vm_dsize = seg_size;
+          _current->td.vm_daddr = seg_addr;
+          }
+
+        _current->oInfo.vmStart = 0x80000000;//((programHeader[i].phVaddr & 0xFFFFF000) + 0x1900000);
+        break;
+      case PT_DYNAMIC:
+        //newLoc = (char *)programHeader[i].phVaddr;
+        elfDynamicS = (elfDynamic *)programHeader[i].phVaddr;
+        fseek(tmpFd,programHeader[i].phOffset,0);
+        fread((void *)programHeader[i].phVaddr,programHeader[i].phFilesz,1,tmpFd);
+        break;
+      case PT_INTERP:
+        ldAddr = ldEnable();
+        break;
+      default:
+        break;
       }
     }
 
diff --git a/src/sys/kernel/ld.c b/src/sys/kernel/ld.c
index ad95697..8120df4 100644
--- a/src/sys/kernel/ld.c
+++ b/src/sys/kernel/ld.c
@@ -48,6 +48,8 @@
   char             *shStr         = 0x0;
   char             *dynStr        = 0x0;
   uInt32           *reMap         = 0x0;
+  uInt32            seg_addr      = 0x0;
+  uInt32            seg_size      = 0x0;
   fileDescriptor   *ldFd          = 0x0;
   elfHeader        *binaryHeader  = 0x0;
   elfProgramHeader *programHeader = 0x0;
@@ -84,21 +86,26 @@
   for (i = 0x0;i < binaryHeader->ePhnum;i++) {
     switch (programHeader[i].phType) {
       case PT_LOAD:
-      case PT_DYNAMIC:
         newLoc = (char *)programHeader[i].phVaddr + LD_START;
         /*
         Allocate Memory Im Going To Have To Make This Load Memory With Correct
         Settings so it helps us in the future
         */
-        for (x=0;x < ((programHeader[i].phMemsz)+4095);x += 0x1000) {
+        for (x=0;x < (programHeader[i].phMemsz);x += 0x1000) {
           /* make r/w or ro */
           if ((vmm_remapPage(vmmFindFreePage(_current->id),((programHeader[i].phVaddr & 0xFFFFF000) + x + LD_START),PAGE_DEFAULT)) == 0x0) 
-	    kpanic("vmmRemapPage: ld\n");
+	    K_PANIC("vmmRemapPage: ld");
           memset((void *)((programHeader[i].phVaddr & 0xFFFFF000) + x + LD_START),0x0,0x1000);
           }
         /* Now Load Section To Memory */
         fseek(ldFd,programHeader[i].phOffset,0x0);
         fread(newLoc,programHeader[i].phFilesz,1,ldFd);
+
+        break;
+      case PT_DYNAMIC:
+        /* Now Load Section To Memory */
+        fseek(ldFd,programHeader[i].phOffset,0x0);
+        fread(newLoc,programHeader[i].phFilesz,1,ldFd);
         break;
       case PT_GNU_STACK:
         /* Tells us if the stack should be executable.  Failsafe to executable
diff --git a/src/sys/kernel/syscall.c b/src/sys/kernel/syscall.c
index fda4a41..7ed5484 100644
--- a/src/sys/kernel/syscall.c
+++ b/src/sys/kernel/syscall.c
@@ -195,7 +195,7 @@
 void sysGetFreePage(long *ptr,int count)
 {
 	if (ptr)
-		*ptr = (long) vmmGetFreeVirtualPage(_current->id,count);
+		*ptr = (long) vmmGetFreeVirtualPage(_current->id,count,0);
 	return;
 }
 
diff --git a/src/sys/vmm/copyvirtualspace.c b/src/sys/vmm/copyvirtualspace.c
index 765a905..673ef46 100644
--- a/src/sys/vmm/copyvirtualspace.c
+++ b/src/sys/vmm/copyvirtualspace.c
@@ -82,7 +82,7 @@
    * The Permissions On Every Mapped Pages To COW This Will Conserve Memory
    * Because The Two VM Spaces Will Be Sharing Some Pages
    */
-  for (x = 1; x <= 766; x++) {
+  for (x = 0x1; x <= 766; x++) {
     /* If Page Table Exists Map It */
     if (parentPageDirectory[x] != 0) {
       /* Set Parent  To Propper Page Table */
@@ -113,21 +113,25 @@
 	    newPageTable[i] = (vmm_getPhysicalAddr((uInt32) newStackPage) | PAGE_DEFAULT | PAGE_STACK);
 	    /* Unmap From Kernel Space */
 	    vmmUnmapPage((uInt32) newStackPage, 1);
-	  } else {
+  	    }
+          else {
 	    /* Set Page To COW In Parent And Child Space */
 	    newPageTable[i] = (((uInt32) parentPageTable[i] & 0xFFFFF000) | (PAGE_DEFAULT | pageCow));
 	    /* Increment The COW Counter For This Page */
 	    if (((uInt32) parentPageTable[i] & pageCow) == pageCow) {
 	      adjustCowCounter(((uInt32) parentPageTable[i] & 0xFFFFF000), 1);
-	    } else {
+	      }
+            else {
 	      adjustCowCounter(((uInt32) parentPageTable[i] & 0xFFFFF000), 2);
 	      parentPageTable[i] = newPageTable[i];
+	      }
 	    }
 	  }
-	} else {
+        else {
 	  newPageTable[i] = (uInt32) 0x0;
-	}
-      }
+	  }
+        }
+
       /* Put New Page Table Into New Page Directory */
       newPageDirectory[x] = (vmm_getPhysicalAddr((uInt32) newPageTable) | PAGE_DEFAULT);
       /* Unmap Page From Kernel Space But Keep It Marked As Not Avail */
@@ -203,6 +207,9 @@
 
 /***
  $Log$
+ Revision 1.1.1.1  2006/06/01 12:46:13  reddawg
+ ubix2
+
  Revision 1.2  2005/10/12 00:13:38  reddawg
  Removed
 
diff --git a/src/sys/vmm/getfreevirtualpage.c b/src/sys/vmm/getfreevirtualpage.c
index bed3e11..bbc5bbe 100644
--- a/src/sys/vmm/getfreevirtualpage.c
+++ b/src/sys/vmm/getfreevirtualpage.c
@@ -43,21 +43,34 @@
 08/11/02 - This Will Return Next Avilable Free Page Of Tasks VM Space
 
 ************************************************************************/
-void           *
-vmmGetFreeVirtualPage(pidType pid, int count)
-{
+void *vmmGetFreeVirtualPage(pidType pid, int count,int type) {
   int             x = 0, y = 0, c = 0;
   uInt32         *pageTableSrc = 0x0;
   uInt32         *pageDir = 0x0;
+  uInt32          start_page = 0x0;
+
   
   spinLock(&fvpSpinLock);
   
   pageDir = (uInt32 *) parentPageDirAddr;
 
+  /*
+  if (type == 0x0) 
+    kprintf("getfreevirtualpage");
+  */
+
+
   /* Lets Search For A Free Page */
   if (_current->oInfo.vmStart <= 0x100000)
     kpanic("Invalid vmStart\n");
-  for (x = (_current->oInfo.vmStart / (1024 * 4096)); x < 1024; x++) {
+  if (type == 0x0) {
+    start_page = (_current->td.vm_daddr + _current->td.vm_dsize);
+    }
+  else {
+    start_page = _current->oInfo.vmStart;
+    }
+  //for (x = ((_current->td.vm_daddr + _current->td.vm_dsize) / (1024 * 4096)); x < 1024; x++) {
+  for (x = (start_page / (1024 * 4096)); x < 1024; x++) {
     /* Set Page Table Address */
     if ((pageDir[x] & PAGE_PRESENT) != PAGE_PRESENT) {
       /* If Page Table Is Non Existant Then Set It Up */
@@ -96,6 +109,8 @@
 	        kpanic("vmmRemapPage: getFreeVirtualPage-1: [0x%X]\n",((x * (1024 * 4096)) + ((y + c) * 4096)));
 	      vmmClearVirtualPage((uInt32) ((x * (1024 * 4096)) + ((y + c) * 4096)));
 	    }
+            if (type == 0x1)
+              _current->td.vm_dsize += (count * 0x1000);
 	    spinUnlock(&fvpSpinLock);
 	    return ((void *)((x * (1024 * 4096)) + (y * 4096)));
 	  }
@@ -111,6 +126,8 @@
 	  /* Clear This Page So No Garbage Is There */
 	  vmmClearVirtualPage((uInt32) ((x * (1024 * 4096)) + (y * 4096)));
 	  /* Return The Address Of The Newly Allocate Page */
+          if (type == 0x1)
+            _current->td.vm_dsize += (count * 0x1000);
 	  spinUnlock(&fvpSpinLock);
 	  return ((void *)((x * (1024 * 4096)) + (y * 4096)));
 	}
@@ -124,6 +141,9 @@
 
 /***
  $Log$
+ Revision 1.1.1.1  2006/06/01 12:46:13  reddawg
+ ubix2
+
  Revision 1.2  2005/10/12 00:13:38  reddawg
  Removed
 
diff --git a/src/sys/vmm/pagefault.c b/src/sys/vmm/pagefault.c
index 51bf0e4..4253278 100644
--- a/src/sys/vmm/pagefault.c
+++ b/src/sys/vmm/pagefault.c
@@ -88,7 +88,8 @@
       /* Set Src To Base Address Of Page To Copy */
       src = (uInt32 *)(memAddr & 0xFFFFF000);
       /* Allocate A Free Page For Destination */
-      dst = (uInt32 *) vmmGetFreeVirtualPage(_current->id,1);
+      /* USE vmInfo */
+      dst = (uInt32 *) vmmGetFreeVirtualPage(_current->id,1,0x1);
       /* Copy Memory */
       for (i=0;i<pageEntries;i++) {
         dst[i] = src[i];
@@ -128,6 +129,9 @@
   
 /***
  $Log$
+ Revision 1.2  2006/10/31 20:44:19  reddawg
+ Lots of changes
+
  Revision 1.1.1.1  2006/06/01 12:46:13  reddawg
  ubix2
 
diff --git a/src/sys/vmm/paging.c b/src/sys/vmm/paging.c
index a414a91..00445bb 100644
--- a/src/sys/vmm/paging.c
+++ b/src/sys/vmm/paging.c
@@ -63,7 +63,7 @@
   /* Allocate A Page Of Memory For Kernels Page Directory */
   kernelPageDirectory = (uInt32 *) vmmFindFreePage(sysID);
   if (kernelPageDirectory == 0x0) {
-    kpanic("Error: vmmFindFreePage Failed");
+    K_PANIC("Error: vmmFindFreePage Failed");
     return (0x1);
     } /* end if */
     
@@ -74,7 +74,7 @@
   
   /* Allocate a page for the first 4MB of memory */
   if ((pageTable = (uInt32 *) vmmFindFreePage(sysID)) == 0x0)
-    kpanic("Error: vmmFindFreePage Failed");
+    K_PANIC("Error: vmmFindFreePage Failed");
   kernelPageDirectory[0] = (uInt32) ((uInt32) (pageTable) | KERNEL_PAGE_DEFAULT);    
     
   /* Make Sure The Page Table Is Clean */
@@ -95,7 +95,7 @@
    */
   for (i = 768; i < pageEntries; i++) {
     if ((pageTable = (uInt32 *) vmmFindFreePage(sysID)) == 0x0)
-      kpanic("Error: vmmFindFreePage Failed");
+      K_PANIC("Error: vmmFindFreePage Failed");
       
     /* Make Sure The Page Table Is Clean */
     memset(pageTable,0x0,0x1000);
@@ -106,7 +106,7 @@
     
   /* Set Up Memory To Be All The Allocated Page Directories */
   if ((pageTable = (uInt32 *) vmmFindFreePage(sysID)) == 0x0)
-    kpanic("Error: vmmFindFreePage Failed");
+    K_PANIC("Error: vmmFindFreePage Failed");
   
   /* Clean Page Table */
   memset(pageTable,0x0,0x1000);
@@ -134,7 +134,7 @@
   /* Remap The Memory List */
   for (i = 0x101000; i <= (0x101000 + (numPages * sizeof(mMap))); i += 0x1000) {
     if ((vmm_remapPage(i, (vmmMemoryMapAddr + (i - 0x101000)),KERNEL_PAGE_DEFAULT)) == 0x0)
-      kpanic("vmmRemapPage failed\n");
+      K_PANIC("vmmRemapPage failed\n");
     }
   /* Set New Address For Memory Map Since Its Relocation */
   vmmMemoryMap = (mMap *) vmmMemoryMapAddr;
@@ -163,6 +163,11 @@
   uInt32 *pageDir = 0x0, *pageTable = 0x0;
   short   i = 0x0;
 
+  if (source == 0x0)
+    K_PANIC("source == 0x0");
+  if (dest == 0x0)
+    K_PANIC("dest == 0x0");
+
   spinLock(&rmpSpinLock);
   if (perms == 0x0)
     perms = KERNEL_PAGE_DEFAULT;
@@ -203,8 +208,18 @@
 
   /* Get The Index To The Page Table */
   destPageTableIndex = ((dest - (destPageDirectoryIndex * 0x400000)) / 0x1000);
+
+
   /* If The Page Is Mapped In Free It Before We Remap */
   if ((pageTable[destPageTableIndex] & PAGE_PRESENT) == PAGE_PRESENT) {
+    if ((pageTable[destPageTableIndex] & PAGE_STACK) == PAGE_STACK)
+      kprintf("Stack Page\n");
+    if ((pageTable[destPageTableIndex] & pageCow) != pageCow) {
+      kprintf("Page NOT COW\n");
+      kprintf("Page Present: [0x%X]",dest);
+      source = 0x0;
+      goto rmDone;
+      }
     /* Clear The Page First For Security Reasons */
     freePage(((uInt32) pageTable[destPageTableIndex] & 0xFFFFF000));
   }
@@ -217,6 +232,8 @@
       "movl %eax,%cr3\n"
       "pop  %eax     \n"
     );
+
+  rmDone:
   /* Return */
   spinUnlock(&rmpSpinLock);
   return (source);
@@ -257,7 +274,7 @@
 	  if (c != -1) {
 	    for (c = 0; c < count; c++) {
 	      if ((vmm_remapPage((uInt32) vmmFindFreePage(pid), ((x * (1024 * 4096)) + ((y + c) * 4096)),KERNEL_PAGE_DEFAULT)) == 0x0)
-	        kpanic("vmmRemapPage failed: gfkp-1\n");
+	        K_PANIC("vmmRemapPage failed: gfkp-1\n");
 	      vmmClearVirtualPage((uInt32) ((x * (1024 * 4096)) + ((y + c) * 4096)));
 	    }
 	    spinUnlock(&fkpSpinLock);
@@ -267,7 +284,7 @@
 	  /* Map A Physical Page To The Virtual Page */
 
 	  if ((vmm_remapPage((uInt32) vmmFindFreePage(pid), ((x * (1024 * 4096)) + (y * 4096)),KERNEL_PAGE_DEFAULT)) == 0x0)
-	    kpanic("vmmRemapPage failed: gfkp-2\n");
+	    K_PANIC("vmmRemapPage failed: gfkp-2\n");
 	  /* Clear This Page So No Garbage Is There */
 	  vmmClearVirtualPage((uInt32) ((x * (1024 * 4096)) + (y * 4096)));
 	  /* Return The Address Of The Newly Allocate Page */
@@ -325,9 +342,12 @@
   //Calculate The Page Table Index And Page Directory Index
   dI = (baseAddr/(1024*4096));
   tI = ((baseAddr-(dI*(1024*4096)))/4096);
-  vmm_remapPage(child->tss.cr3,0x5A00000,KERNEL_PAGE_DEFAULT);
+  if (vmm_remapPage(child->tss.cr3,0x5A00000,KERNEL_PAGE_DEFAULT) == 0x0)
+    K_PANIC("vmmFailed");
+
   for (i=0;i<0x1000;i++) {
-    vmm_remapPage(childPageDir[i],0x5A01000 + (i * 0x1000),KERNEL_PAGE_DEFAULT);
+    if (vmm_remapPage(childPageDir[i],0x5A01000 + (i * 0x1000),KERNEL_PAGE_DEFAULT) == 0x0)
+      K_PANIC("Returned NULL");
     }
   for (x=(_current->oInfo.vmStart/(1024*4096));x<1024;x++) {
     pageTableSrc = (uInt32 *)(tablesBaseAddress + (4096*x));
@@ -348,7 +368,8 @@
                 tI = 0-c;
                 }
               childPageTable = (uInt32 *)(0x5A01000 + (0x1000 * dI));
-              vmm_remapPage(childPageTable[tI+c],((x*(1024*4096))+((y+c)*4096)),KERNEL_PAGE_DEFAULT);
+              if (vmm_remapPage(childPageTable[tI+c],((x*(1024*4096))+((y+c)*4096)),KERNEL_PAGE_DEFAULT) == 0x0)
+                K_PANIC("remap == NULL");
               }
             vmmUnmapPage(0x5A00000,1);
             for (i=0;i<0x1000;i++) {
@@ -360,7 +381,9 @@
         else {
           //Map A Physical Page To The Virtual Page
           childPageTable = (uInt32 *)(0x5A01000 + (0x1000 * dI));
-          vmm_remapPage(childPageTable[tI],((x*(1024*4096))+(y*4096)),KERNEL_PAGE_DEFAULT);
+          if (vmm_remapPage(childPageTable[tI],((x*(1024*4096))+(y*4096)),KERNEL_PAGE_DEFAULT) == 0x0)
+            K_PANIC("remap Failed");
+
           //Return The Address Of The Mapped In Memory
           vmmUnmapPage(0x5A00000,1);
           for (i=0;i<0x1000;i++) {
@@ -398,7 +421,9 @@
             }
           if (c != -1) {
             for (c = 0; c < count; c++) {
-              vmm_remapPage((uInt32) vmmFindFreePage(sysID), ((x * 0x400000) + ((y + c) * 0x1000)),KERNEL_PAGE_DEFAULT);
+              if (vmm_remapPage((uInt32) vmmFindFreePage(sysID), ((x * 0x400000) + ((y + c) * 0x1000)),KERNEL_PAGE_DEFAULT) == 0x0)
+                K_PANIC("remap Failed");
+
               vmmClearVirtualPage((uInt32) ((x * 0x400000) + ((y + c) * 0x1000)));
               }
             spinUnlock(&fkpSpinLock);
@@ -407,7 +432,9 @@
           }
         else {
           /* Map A Physical Page To The Virtual Page */
-          vmm_remapPage((uInt32) vmmFindFreePage(sysID), ((x * 0x400000) + (y * 0x1000)),KERNEL_PAGE_DEFAULT);
+          if (vmm_remapPage((uInt32) vmmFindFreePage(sysID), ((x * 0x400000) + (y * 0x1000)),KERNEL_PAGE_DEFAULT) == 0x0)
+            K_PANIC("Failed");
+
           /* Clear This Page So No Garbage Is There */
           vmmClearVirtualPage((uInt32) ((x * 0x400000) + (y * 0x1000)));
           /* Return The Address Of The Newly Allocate Page */
@@ -426,6 +453,7 @@
   if (uap->addr != 0x0) {
     kprintf("Address hints are not supported yet.\n");
     }
+  /*
   kprintf("uap->addr:  [0x%X]\n",uap->addr);
   kprintf("uap->len:   [0x%X]\n",uap->len);
   kprintf("uap->prot:  [0x%X]\n",uap->prot);
@@ -433,18 +461,33 @@
   kprintf("uap->fd:    [%i]\n",uap->fd);
   kprintf("uap->pad:   [0x%X]\n",uap->pad);
   kprintf("uap->pos:   [0x%X]\n",uap->pos);
+  */
   if (uap->fd == -1)
-  td->td_retval[0] = vmmGetFreeVirtualPage(_current->id,uap->len/0x1000);
+    td->td_retval[0] = vmmGetFreeVirtualPage(_current->id,uap->len/0x1000,0x1);
   else 
     td->td_retval[0] = 0x0;
   return(0x0);
   }
 
 int obreak(struct thread *td,struct obreak_args *uap) {
+  int    i   = 0x0;
+  uInt32 old = 0x0;
   kprintf("nsize:    [0x%X]\n",uap->nsize);
   kprintf("vm_daddr: [0x%X]\n",td->vm_daddr);
-  td->td_retval[0] = uap->nsize;
-  //td->td_retval[1] = 0x0;
+  kprintf("vm_dsize: [0x%X]\n",td->vm_dsize);
+  kprintf("total:    [0x%X]\n",td->vm_daddr + td->vm_dsize);
+
+  old = td->vm_daddr + td->vm_dsize;
+
+  for (i = (td->vm_daddr + td->vm_dsize);i <= uap->nsize ;i+= 0x1000) {
+    if (vmm_remapPage(vmmFindFreePage(_current->id),i,PAGE_DEFAULT) == 0x0)
+      K_PANIC("remap Failed");
+    }
+  td->vm_dsize += (uap->nsize - old);
+//  kprintf("vm_dsize: [0x%X]\n",td->vm_dsize);
+//  kprintf("total:    [0x%X]\n",td->vm_daddr + td->vm_dsize);
+
+  //td->td_retval[0] = td->vm_daddr + td->vm_dsize;
   return(0x0);
   }