diff --git a/lib/ubix/sstart.c b/lib/ubix/sstart.c
index df1582e..bf16bb3 100644
--- a/lib/ubix/sstart.c
+++ b/lib/ubix/sstart.c
@@ -28,6 +28,15 @@
 
         handle_static_init(argc, argv, env);
 */
+/*
+asm(
+  "pushl %eax\n"
+  "movl $0xDEADBEEF,%eax\n"
+  "pushl %eax\n"
+  "movl (%eax),%eax\n"
+  "pushl %eax\n"
+);
+*/
         exit(main(argc, argv, env));
 }
 
diff --git a/libexec/ld/addlibrary.c b/libexec/ld/addlibrary.c
index f591d31..f487356 100644
--- a/libexec/ld/addlibrary.c
+++ b/libexec/ld/addlibrary.c
@@ -2,6 +2,8 @@
 #include <stdlib.h>
 #include "ld.h"
 
+#define DT_PLTGOT 3
+
 ldLibrary *ldAddLibrary(const char *lib) {
   int        i        = 0x0;
   int        x        = 0x0;
@@ -11,6 +13,8 @@
   FILE      *linkerFd = 0x0;
   char       tmpFile[1024];
   ldLibrary *tmpLib   = 0x0;
+  elfDynamic *dynp    = 0x0;
+  uInt32     *tmp     = 0x0;
 
   if ((tmpLib = (ldLibrary *)malloc(sizeof(ldLibrary))) == 0x0) {
     printf("malloc failed: tmpLib\n");
@@ -33,6 +37,7 @@
       }
     sprintf(tmpLib->name,lib);
     }
+
   printf("Base: {0x%X}[%i]\n",tmpLib->output, __LINE__);
   if (tmpLib->linkerHeader == 0x0) {
     fseek(linkerFd,0x0,0x0);
@@ -53,17 +58,34 @@
     for (i=0;i<tmpLib->linkerHeader->ePhnum;i++) {
       switch (tmpLib->linkerProgramHeader[i].phType) {
         case PT_LOAD:
-        case PT_DYNAMIC:
-          newLoc = (char *)tmpLib->linkerProgramHeader[i].phVaddr + (uInt32)tmpLib->output;
+          newLoc = (char *)(tmpLib->linkerProgramHeader[i].phVaddr + (uInt32)tmpLib->output);
           fseek(linkerFd,tmpLib->linkerProgramHeader[i].phOffset,0);
           fread(newLoc,tmpLib->linkerProgramHeader[i].phFilesz,1,linkerFd);
           break;
+        case PT_DYNAMIC:
+          dynp = (elfDynamic *)(tmpLib->linkerProgramHeader[i].phVaddr + (uInt32)tmpLib->output);
+          printf("dynp: 0x%X:0x%X:0x%X", dynp, tmpLib->linkerProgramHeader[i].phVaddr, tmpLib->output);
+          for (;dynp->dynVal != 0x0;dynp++) {
+           switch (dynp->dynVal) {
+             case DT_PLTGOT:
+                tmp = (void *)((uInt32)tmpLib->output + dynp->dynPtr);
+                tmp[1] = 0xDEAD;
+                tmp[2] = 0xBEEF;
+                break;
+             default:
+               printf("dV: %i", dynp->dynVal);
+                  break;
+           }
+           }
+          asm("nop");
+          break;
         case PT_TLS:
             tmpLib->tlsindex = 1;
             tmpLib->tlssize = tmpLib->linkerProgramHeader[i].phMemsz;//ph->p_memsz;
             tmpLib->tlsalign = tmpLib->linkerProgramHeader[i].phAlign;//ph->p_align;
             tmpLib->tlsinitsize = tmpLib->linkerProgramHeader[i].phFilesz;//ph->p_filesz;
             tmpLib->tlsinit = (void*)(tmpLib->linkerProgramHeader[i].phVaddr + (uInt32)tmpLib->output);
+            printf("TLS: 0x%X, 0x%X, 0x%X, 0x%X", tmpLib->tlssize, tmpLib->tlsinitsize, tmpLib->tlsinit, tmpLib->tlsinit - (uInt32)tmpLib->output);
 /*
           newLoc = (char *)tmpLib->linkerProgramHeader[i].phVaddr + (uInt32)tmpLib->output;
           fseek(linkerFd,tmpLib->linkerProgramHeader[i].phOffset,0);
diff --git a/sys/i386/i386_exec.c b/sys/i386/i386_exec.c
index 2bc2613..457edad 100644
--- a/sys/i386/i386_exec.c
+++ b/sys/i386/i386_exec.c
@@ -54,45 +54,6 @@
 
 #define AUXARGS_ENTRY(pos, id, val) {*pos = id;pos++; *pos = val;pos++;}
 
-typedef struct elf_file {
-  int preloaded; /* Was file pre-loaded */
-  caddr_t address; /* Relocation address */
-  Elf32_Dyn *dynamic; /* Symbol table etc. */
-  Elf32_Hashelt nbuckets; /* DT_HASH info */
-  Elf32_Hashelt nchains;
-  const Elf32_Hashelt *buckets;
-  const Elf32_Hashelt *chains;
-  caddr_t hash;
-  caddr_t strtab; /* DT_STRTAB */
-  int strsz; /* DT_STRSZ */
-  const Elf32_Sym *symtab; /* DT_SYMTAB */
-  Elf32_Addr *got; /* DT_PLTGOT */
-  const Elf32_Rel *pltrel; /* DT_JMPREL */
-  int pltrelsize; /* DT_PLTRELSZ */
-  const Elf32_Rela *pltrela; /* DT_JMPREL */
-  int pltrelasize; /* DT_PLTRELSZ */
-  const Elf32_Rel *rel; /* DT_REL */
-  int relsize; /* DT_RELSZ */
-  const Elf32_Rela *rela; /* DT_RELA */
-  int relasize; /* DT_RELASZ */
-  caddr_t modptr;
-  const Elf32_Sym *ddbsymtab; /* The symbol table we are using */
-  long ddbsymcnt; /* Number of symbols */
-  caddr_t ddbstrtab; /* String table */
-  long ddbstrcnt; /* number of bytes in string table */
-  caddr_t symbase; /* malloc'ed symbold base */
-  caddr_t strbase; /* malloc'ed string base */
-  caddr_t ctftab; /* CTF table */
-  long ctfcnt; /* number of bytes in CTF table */
-  caddr_t ctfoff; /* CTF offset table */
-  caddr_t typoff; /* Type offset table */
-  long typlen; /* Number of type entries. */
-  Elf32_Addr pcpu_start; /* Pre-relocation pcpu set start. */
-  Elf32_Addr pcpu_stop; /* Pre-relocation pcpu set stop. */
-  Elf32_Addr pcpu_base; /* Relocated pcpu set address. */
-  Elf32_Addr ld_addr; // Entry Point Of Linker (Load It Too)
-} *elf_file_t;
-
 static int elf_parse_dynamic(elf_file_t ef);
 
 /*****************************************************************************************
@@ -200,7 +161,7 @@
  *****************************************************************************************/
 void execFile(char *file, int argc, char **argv, int console) {
 
-  kTask_t newProcess = 0x0;
+  kTask_t *newProcess = 0x0;
 
   int i = 0x0;
   int x = 0x0;
@@ -215,6 +176,7 @@
   newProcess = schedNewTask();
   assert(newProcess);
 
+
   newProcess->gid = 0x0;
   newProcess->uid = 0x0;
   newProcess->term = tty_find(console);
@@ -281,11 +243,11 @@
   newProcess->td.abi = binaryHeader->e_ident[EI_OSABI];
 
   /* Load The Program Header(s) */
-  programHeader = (elfProgramHeader *) kmalloc(sizeof(elfProgramHeader) * binaryHeader->e_phnum);
+  programHeader = (Elf_Phdr *) kmalloc(sizeof(Elf_Phdr) * binaryHeader->e_phnum);
   fseek(newProcess->imageFd, binaryHeader->e_phoff, 0);
 
-  //kprintf(">c:%i:0x%X:0x%X<",sizeof(elfProgramHeader)*binaryHeader->e_phnum,programHeader,tmpFd);
-  fread(programHeader, (sizeof(elfProgramHeader) * binaryHeader->e_phnum), 1, newProcess->imageFd);
+  //kprintf(">c:%i:0x%X:0x%X<",sizeof(Elf_Phdr)*binaryHeader->e_phnum,programHeader,tmpFd);
+  fread(programHeader, (sizeof(Elf_Phdr) * binaryHeader->e_phnum), 1, newProcess->imageFd);
   //kprintf(">d<");
 
   /* Loop Through The Header And Load Sections Which Need To Be Loaded */
@@ -297,7 +259,7 @@
        */
       for (x = 0x0; x < (programHeader[i].p_memsz); x += 0x1000) {
         /* Make readonly and read/write !!! */
-        if (vmm_remapPage(vmm_findFreePage(newProcess->id), ((programHeader[i].p_vaddr & 0xFFFFF000) + x), PAGE_DEFAULT) == 0x0)
+        if (vmm_remapPage(vmm_findFreePage(newProcess->id), ((programHeader[i].p_vaddr & 0xFFFFF000) + x), PAGE_DEFAULT, newProcess->id) == 0x0)
           K_PANIC("Remap Page Failed");
 
         memset((void *) ((programHeader[i].p_vaddr & 0xFFFFF000) + x), 0x0, 0x1000);
@@ -325,12 +287,15 @@
   /* Set Up Stack Space */
   //MrOlsen (2016-01-14) FIX: is the stack start supposed to be addressable xhcnage x= 1 to x=0
   for (x = 0; x < 100; x++) {
-    vmm_remapPage(vmm_findFreePage(newProcess->id), STACK_ADDR - (x * 0x1000), PAGE_DEFAULT | PAGE_STACK);
+    vmm_remapPage(vmm_findFreePage(newProcess->id), STACK_ADDR - (x * 0x1000), PAGE_DEFAULT | PAGE_STACK, newProcess->id);
   }
 
   /* Kernel Stack 0x2000 bytes long */
-  vmm_remapPage(vmm_findFreePage(newProcess->id), 0x5BC000, KERNEL_PAGE_DEFAULT | PAGE_STACK);
-  vmm_remapPage(vmm_findFreePage(newProcess->id), 0x5BB000, KERNEL_PAGE_DEFAULT | PAGE_STACK);
+
+  kprintf("PID: %i\n",newProcess->id);
+  vmm_remapPage(vmm_findFreePage(newProcess->id), 0x5BC000, KERNEL_PAGE_DEFAULT | PAGE_STACK, newProcess->id);
+  kprintf("PID: %i\n",newProcess->id);
+  vmm_remapPage(vmm_findFreePage(newProcess->id), 0x5BB000, KERNEL_PAGE_DEFAULT | PAGE_STACK, newProcess->id);
 
   /* Set All The Proper Information For The Task */
   newProcess->tss.back_link = 0x0;
@@ -380,8 +345,8 @@
   *tmp++ = 0x0; // ARGV TERM
   *tmp++ = 0x0; // ENV
   *tmp++ = 0x0; // ENV TERM
-  *tmp++ = 0x0; // AUX 1.A
-  *tmp++ = 0x0; // AUX 1.B
+  *tmp++ = 0xDEAD; // AUX 1.A
+  *tmp++ = 0xBEEF; // AUX 1.B
   *tmp++ = 0x0; // AUX TERM
   *tmp++ = 0x0; // AUX TERM 
   *tmp++ = 0x1; // TERM
@@ -398,6 +363,8 @@
   /* Put new thread into the READY state */
   sched_setStatus(newProcess->id, READY);
 
+  _current = newProcess;
+
   /* Finally Return */
   return;
 }
@@ -493,7 +460,7 @@
   assert(programHeader);
 
   fseek(fd, binaryHeader->e_phoff, 0);
-  fread(programHeader, (sizeof(elfProgramHeader) * binaryHeader->e_phnum), 1, fd);
+  fread(programHeader, (sizeof(Elf_Phdr) * binaryHeader->e_phnum), 1, fd);
   /* Done Loading Program Header(s) */
 
   /* Load The Section Header(s) */
@@ -502,7 +469,7 @@
 
   assert(sectionHeader);
   fseek(fd, binaryHeader->e_shoff, 0);
-  fread(sectionHeader, sizeof(elfSectionHeader) * binaryHeader->e_shnum, 1, fd);
+  fread(sectionHeader, sizeof(Elf_Shdr) * binaryHeader->e_shnum, 1, fd);
   /* Done Loading Section Header(s) */
 
   ef = kmalloc(sizeof(struct elf_file));
@@ -523,7 +490,7 @@
          */
         for (x = 0x0; x < (round_page(programHeader[i].p_memsz)); x += 0x1000) {
           /* Make readonly and read/write !!! */
-          if (vmm_remapPage(vmm_findFreePage(_current->id), ((programHeader[i].p_vaddr & 0xFFFFF000) + x), PAGE_DEFAULT) == 0x0) {
+          if (vmm_remapPage(vmm_findFreePage(_current->id), ((programHeader[i].p_vaddr & 0xFFFFF000) + x), PAGE_DEFAULT, _current->id) == 0x0) {
             K_PANIC("Error: Remap Page Failed");
           } /*
            else {
@@ -604,31 +571,6 @@
    _current->td.vm_daddr = (char *) seg_addr;
    */
 
-  //argv = &ap;
-  //if (argv[1] != 0x0) {
-  if (argv != 0x0) {
-//MrOlsen (2016-01-12) FIX: Not sure why argv[0] == 0
-    argc = ((int) argv[0] > 0) ? (int) argv[0] : 1;
-
-    kprintf("argc: %i", argc);
-    args = (char *) vmm_getFreeVirtualPage(_current->id, 1, VM_TASK);
-    kprintf("argc: %i, args 0x%X", argc, args);
-    memset(args, 0x0, 0x1000);
-    x = 0x0;
-    argvNew = (char **) kmalloc(sizeof(char *) * argc);
-    for (i = 0x0; i < argc; i++) {
-      strcpy(args + x, argv[i + 1]);
-      argvNew[i] = args + x;
-      x += strlen(argv[i + 1]) + 1;
-      //args[x] = '\0';
-      //x++;
-    }
-    argv = argvNew;
-  }
-  else {
-    argc = 1;
-  }
-
   iFrame = (struct i386_frame *) (_current->tss.esp0 - sizeof(struct i386_frame));
   /*
    iFrameNew = (struct i386_frame *) kmalloc( sizeof(struct i386_frame) );
@@ -643,43 +585,33 @@
 
   iFrame->ebp = 0x0;      //STACK_ADDR;
   iFrame->eip = binaryHeader->e_entry;
-  //iFrame->user_ebp = 0x0;
   iFrame->edx = 0x0;
   //iFrame->user_esp = ((uint32_t) STACK_ADDR) - ((sizeof(uint32_t) * (argc + 8 + 1)) + (sizeof(Elf32_Auxinfo) * 2));
   iFrame->user_esp = ((uint32_t) STACK_ADDR) - (128);      //(sizeof(uint32_t) * (argc + 8 + 1)) + (sizeof(Elf32_Auxinfo) * 2));
 
   tmp = (void *) iFrame->user_esp; //MrOlsen 2017-11-14 iFrame->user_ebp;
 
-  kprintf("[0x%X][0x%X]", iFrame->user_esp, tmp);
-
-  //memset(tmp,0x0,((sizeof(uint32_t) * (argc + 8 + 1)) + (sizeof(Elf32_Auxinfo) * 2)));
   memset((char *) (STACK_ADDR - 128), 0x0, 128);
 
   tmp[0] = argc; // ARGC
 
-  /*
-   if ( argc == 1 ) {
-   *tmp++ = 0x0; //ARGV Pointers
-   }
-   else {
-   for ( i = 0; i < argc; i++ ) {
-   *tmp++ = (u_int) argv[i];
-   }
-   }
-   */
   tmp[1] = 0x0; // ARGV
   tmp[2] = 0x0; // ARGV Terminator
 
   tmp[3] = 0x0; // ENV 
   tmp[4] = 0x0; // ENV Terminator
 
-  tmp[5] = 0x0;
-  tmp[6] = 0x0;
+  tmp[5] = 0x1;
+  tmp[6] = 0x2;
 
-  tmp[7] = 0x0; // AUX VECTOR 8 Bytes
-  tmp[8] = 0x0; // Terminator
+  tmp[7] = 0x3; // AUX VECTOR 8 Bytes
+  tmp[8] = 0x4; // Terminator
 
-  tmp[9] = 0xDEADBEEF; // End Marker
+  tmp[9] = 0x5;
+  tmp[10] = 0x6;
+
+  tmp[11] = 0x7;
+  tmp[12] = 0x8;
 
   kfree(argvNew);
 
@@ -793,9 +725,9 @@
         if (tmp == 0x0)
           kpanic("tmp: NULL\n");
         else
-          kprintf("[0x%X]", tmp);
+          kprintf("PLT[0x%X:0x%X]", tmp, ef->ld_addr);
         tmp[2] = (uInt32) ef->ld_addr;
-        tmp[1] = (uInt32) ef;
+        tmp[1] = (uInt32) ef;//0x0;//0xBEEFEAD;//STACK_ADDR - 128;//_current->imageFd;//0xBEEFDEAD;//ef;
       break;
       default:
         kprintf("t_tag: 0x%X>", dynp->d_tag);
diff --git a/sys/i386/syscall.c b/sys/i386/syscall.c
index 0e3c627..aba1058 100644
--- a/sys/i386/syscall.c
+++ b/sys/i386/syscall.c
@@ -202,7 +202,7 @@
  :
  );
 
- kprintf("Invalid System Call #[%i]\n",sys_call);
+ kprintf("Invalid System Call #[%i].1\n",sys_call);
  kpanic("PID: %i, File: %s, Line: %i", _curent->id, _FILE_, _LINE_);
  return(0);
  }
diff --git a/sys/i386/trap.c b/sys/i386/trap.c
index a30c2f7..7114abc 100644
--- a/sys/i386/trap.c
+++ b/sys/i386/trap.c
@@ -98,13 +98,14 @@
   //if ((regs->tf_eflags & VM_MASK) || (3 & regs->tf_cs) == 3)
   //  return;
 
- // if ((regs->tf_cs & 3) == 3) {
+  if ((regs->tf_cs & 3) == 3) {
     esp = regs->tf_esp;
     ss = regs->tf_ss;
     kprintf("USER TASK!");
-  //}
-
-  ss = 0x30;
+  }
+  else {
+    ss = 0x10;
+  }
 
   kprintf("%s: %04lx(%i:%i)[0x%X]\n", str, err & 0xffff, regs->tf_trapno, regs->tf_err, regs->tf_ss);
   kprintf("CPU: %d\n", 0);
@@ -116,11 +117,15 @@
   kprintf("Process %s (pid: %i, process nr: %d, stackpage=%08lx)\nStack:", _current->name, _current->id, 0xffff & i, KERNEL_STACK);
 
   stack = (unsigned long *)esp;
+
   for (i = 0; i < 16; i++) {
     if (i && ((i % 8) == 0))
       kprintf("\n       ");
     kprintf("%08lx ", get_seg_long(ss, stack++));
   }
+
+#ifdef _BALLS
+
   kprintf("\nCall Trace: ");
   stack = (unsigned long *)esp;
   i = 1;
@@ -153,6 +158,7 @@
   for (i = 0; i < 20; i++)
     kprintf("%02x ", 0xff & get_seg_byte(regs->tf_cs, (i+(char *)regs->tf_eip)));
   kprintf("\n");
+#endif
 }
 
 void trap(struct trapframe *frame) {
diff --git a/sys/include/sys/elf.h b/sys/include/sys/elf.h
index e0f465d..16235a1 100644
--- a/sys/include/sys/elf.h
+++ b/sys/include/sys/elf.h
@@ -38,26 +38,26 @@
 typedef struct elf_file {
   int preloaded; /* Was file pre-loaded */
   caddr_t address; /* Relocation address */
-  Elf32_Dyn *dynamic; /* Symbol table etc. */
-  Elf32_Hashelt nbuckets; /* DT_HASH info */
-  Elf32_Hashelt nchains;
-  const Elf32_Hashelt *buckets;
-  const Elf32_Hashelt *chains;
+  Elf_Dyn *dynamic; /* Symbol table etc. */
+  Elf_Hashelt nbuckets; /* DT_HASH info */
+  Elf_Hashelt nchains;
+  const Elf_Hashelt *buckets;
+  const Elf_Hashelt *chains;
   caddr_t hash;
   caddr_t strtab; /* DT_STRTAB */
   int strsz; /* DT_STRSZ */
-  const Elf32_Sym *symtab; /* DT_SYMTAB */
-  Elf32_Addr *got; /* DT_PLTGOT */
-  const Elf32_Rel *pltrel; /* DT_JMPREL */
+  const Elf_Sym *symtab; /* DT_SYMTAB */
+  Elf_Addr *got; /* DT_PLTGOT */
+  const Elf_Rel *pltrel; /* DT_JMPREL */
   int pltrelsize; /* DT_PLTRELSZ */
-  const Elf32_Rela *pltrela; /* DT_JMPREL */
+  const Elf_Rela *pltrela; /* DT_JMPREL */
   int pltrelasize; /* DT_PLTRELSZ */
-  const Elf32_Rel *rel; /* DT_REL */
+  const Elf_Rel *rel; /* DT_REL */
   int relsize; /* DT_RELSZ */
-  const Elf32_Rela *rela; /* DT_RELA */
+  const Elf_Rela *rela; /* DT_RELA */
   int relasize; /* DT_RELASZ */
   caddr_t modptr;
-  const Elf32_Sym *ddbsymtab; /* The symbol table we are using */
+  const Elf_Sym *ddbsymtab; /* The symbol table we are using */
   long ddbsymcnt; /* Number of symbols */
   caddr_t ddbstrtab; /* String table */
   long ddbstrcnt; /* number of bytes in string table */
@@ -68,10 +68,11 @@
   caddr_t ctfoff; /* CTF offset table */
   caddr_t typoff; /* Type offset table */
   long typlen; /* Number of type entries. */
-  Elf32_Addr pcpu_start; /* Pre-relocation pcpu set start. */
-  Elf32_Addr pcpu_stop; /* Pre-relocation pcpu set stop. */
-  Elf32_Addr pcpu_base; /* Relocated pcpu set address. */
-  Elf32_Addr ld_addr; // Entry Point Of Linker (Load It Too)
+  Elf_Addr pcpu_start; /* Pre-relocation pcpu set start. */
+  Elf_Addr pcpu_stop; /* Pre-relocation pcpu set stop. */
+  Elf_Addr pcpu_base; /* Relocated pcpu set address. */
+  Elf_Addr ld_addr; // Entry Point Of Linker (Load It Too)
+  uint32_t fd;
 } *elf_file_t;
 
 #endif
diff --git a/sys/include/ubixos/spinlock.h b/sys/include/ubixos/spinlock.h
index 3cf8e5d..a4f57f4 100644
--- a/sys/include/ubixos/spinlock.h
+++ b/sys/include/ubixos/spinlock.h
@@ -41,7 +41,7 @@
 
 struct spinLock {
     struct spinLock *next;
-    int locked;
+    uint32_t locked;
 };
 
 typedef struct spinLock *spinLock_t;
diff --git a/sys/include/vmm/paging.h b/sys/include/vmm/paging.h
index 152a4fe..30a8745 100644
--- a/sys/include/vmm/paging.h
+++ b/sys/include/vmm/paging.h
@@ -74,24 +74,24 @@
 #define btoc(x)         (((vm_offset_t)(x)+PAGE_MASK)>>PAGE_SHIFT)
 
 
-int vmmClearVirtualPage(uInt32 pageAddr);
+int vmmClearVirtualPage(uint32_t pageAddr);
 
-void vmm_unmapPage(uInt32, int);
-void vmm_unmapPages(void *, uInt32);
-void *vmm_mapFromTask(pidType, void *, uInt32);
+void vmm_unmapPage(uint32_t, int);
+void vmm_unmapPages(void *, uint32_t);
+void *vmm_mapFromTask(pidType, void *, uint32_t);
 void *vmm_copyVirtualSpace(pidType);
 void *vmm_getFreePage(pidType);
-void *vmmGetFreeKernelPage(pidType pid, uInt16 count);
+void *vmmGetFreeKernelPage(pidType pid, uint16_t count);
 void *vmm_createVirtualSpace(pidType);
 void *vmm_getFreeVirtualPage(pidType, int, int);
 
 uint32_t vmm_getPhysicalAddr(uint32_t);
 uint32_t vmm_getRealAddr(uint32_t);
-int vmm_setPageAttributes(uInt32, uInt16);
-int vmm_remapPage(uInt32, uInt32, uInt16);
+int vmm_setPageAttributes(uint32_t, uint16_t);
+int vmm_remapPage(uint32_t, uint32_t, uint16_t, pidType);
 int vmm_pagingInit();
-void *vmm_getFreeMallocPage(uInt16 count);
-//void vmm_pageFault( uInt32, uInt32, uInt32 );
+void *vmm_getFreeMallocPage(uint16_t count);
+//void vmm_pageFault( uint32_t, uint32_t, uint32_t );
 void vmm_pageFault(struct trapframe *, uint32_t);
 void _vmm_pageFault();
 int mmap(struct thread *, struct sys_mmap_args *);
@@ -101,6 +101,6 @@
 int vmm_cleanVirtualSpace(uint32_t);
 void *vmm_getFreeVirtualPage( pidType pid, int count, int type );
 
-extern uInt32 *kernelPageDirectory;
+extern uint32_t *kernelPageDirectory;
 
 #endif
diff --git a/sys/init/main.c b/sys/init/main.c
index 7c59cb1..b1a4866 100644
--- a/sys/init/main.c
+++ b/sys/init/main.c
@@ -145,6 +145,7 @@
   kprintf("Thread Start!\n");
 
   execFile("sys:/bin/init", 0x0, 0x0, 0x0); /* OS Initializer    */
+  kprintf("File Start!\n");
   //execFile( "sys:/bin/login", 0x0, 0x0, 0x0 ); /* OS Initializer    */
 
   irqEnable(0x0);
diff --git a/sys/kernel/elf.c b/sys/kernel/elf.c
index c2e2096..be3d4c5 100644
--- a/sys/kernel/elf.c
+++ b/sys/kernel/elf.c
@@ -32,10 +32,6 @@
 #include <lib/kprintf.h>
 #include <string.h>
 
-typedef struct elf_file {
-
-}*elf_file_type;
-
 int elf_load_file(kTask_t *p, const char *file, uint32_t *addr, uint32_t *entry) {
   int ret = 0;
 
@@ -95,7 +91,7 @@
         for (x = 0x0; x < (programHeader[i].p_memsz + 0xFFF); x += 0x1000) {
 
           /* Make readonly and read/write */
-          if (vmm_remapPage(vmm_findFreePage(_current->id), ((programHeader[i].p_vaddr & 0xFFFFF000) + x + real_base_addr), PAGE_DEFAULT) == 0x0)
+          if (vmm_remapPage(vmm_findFreePage(_current->id), ((programHeader[i].p_vaddr & 0xFFFFF000) + x + real_base_addr), PAGE_DEFAULT, _current->id) == 0x0)
             K_PANIC("Error: Remap Page Failed");
 
           memset((void *) ((programHeader[i].p_vaddr & 0xFFFFF000) + x + real_base_addr), 0x0, 0x1000);
diff --git a/sys/kernel/gen_calls.c b/sys/kernel/gen_calls.c
index 10c1949..f4efaa0 100644
--- a/sys/kernel/gen_calls.c
+++ b/sys/kernel/gen_calls.c
@@ -169,10 +169,8 @@
   return (error);
 }
 
-/* MrOlsen 2016-01-18 */
 int sys_invalid( struct thread *td, void *args ) {
-  kprintf( "Invalid System Call #[%i]\n", td->frame->tf_eax );
-//kpanic("PID: %i, File: %s, Line: %i", _current->id, __FILE__, __LINE__);
+  kprintf( "Invalid System Call #[%i], Pid: %i\n", td->frame->tf_eax, _current->id );
   return (0);
 }
 
diff --git a/sys/kernel/ld.c b/sys/kernel/ld.c
index f0871f7..3560f86 100644
--- a/sys/kernel/ld.c
+++ b/sys/kernel/ld.c
@@ -38,7 +38,7 @@
 #include <string.h>
 #include <assert.h>
 
-uInt32 ldEnable() {
+uint32_t ldEnable() {
   int i = 0x0;
   int x = 0x0;
   int rel = 0x0;
@@ -46,13 +46,13 @@
   char *newLoc = 0x0;
   char *shStr = 0x0;
   char *dynStr = 0x0;
-  uInt32 *reMap = 0x0;
+  uint32_t *reMap = 0x0;
   fileDescriptor *ldFd = 0x0;
   Elf32_Ehdr *binaryHeader = 0x0;
-  elfProgramHeader *programHeader = 0x0;
-  elfSectionHeader *sectionHeader = 0x0;
-  elfDynSym *relSymTab = 0x0;
-  elfPltInfo *elfRel = 0x0;
+  Elf_Phdr *programHeader = 0x0;
+  Elf_Shdr *sectionHeader = 0x0;
+  Elf_Sym *relSymTab = 0x0;
+  Elf_Rel *elfRel = 0x0;
 
   /* Open our dynamic linker */
   ldFd = fopen("sys:/libexec/ld.so", "rb");
@@ -66,93 +66,93 @@
   assert(binaryHeader);
   fread(binaryHeader, sizeof(Elf32_Ehdr), 1, ldFd);
 
-  programHeader = (elfProgramHeader *) kmalloc(sizeof(elfProgramHeader) * binaryHeader->e_phnum);
+  programHeader = (Elf_Phdr *) kmalloc(sizeof(Elf_Phdr) * binaryHeader->e_phnum);
   assert(programHeader);
   fseek(ldFd, binaryHeader->e_phoff, 0);
-  fread(programHeader, sizeof(elfSectionHeader), binaryHeader->e_phnum, ldFd);
+  fread(programHeader, sizeof(Elf_Shdr), binaryHeader->e_phnum, ldFd);
 
-  sectionHeader = (elfSectionHeader *) kmalloc(sizeof(elfSectionHeader) * binaryHeader->e_shnum);
+  sectionHeader = (Elf_Shdr *) kmalloc(sizeof(Elf_Shdr) * binaryHeader->e_shnum);
   assert(sectionHeader);
   fseek(ldFd, binaryHeader->e_shoff, 0);
-  fread(sectionHeader, sizeof(elfSectionHeader), binaryHeader->e_shnum, ldFd);
+  fread(sectionHeader, sizeof(Elf_Shdr), binaryHeader->e_shnum, ldFd);
 
-  shStr = (char *) kmalloc(sectionHeader[binaryHeader->e_shstrndx].shSize);
-  fseek(ldFd, sectionHeader[binaryHeader->e_shstrndx].shOffset, 0);
-  fread(shStr, sectionHeader[binaryHeader->e_shstrndx].shSize, 1, ldFd);
+  shStr = (char *) kmalloc(sectionHeader[binaryHeader->e_shstrndx].sh_size);
+  fseek(ldFd, sectionHeader[binaryHeader->e_shstrndx].sh_offset, 0);
+  fread(shStr, sectionHeader[binaryHeader->e_shstrndx].sh_size, 1, ldFd);
 
   for (i = 0x0; i < binaryHeader->e_phnum; i++) {
-    switch (programHeader[i].phType) {
+    switch (programHeader[i].p_type) {
       case PT_LOAD:
-        newLoc = (char *) programHeader[i].phVaddr + LD_START;
+        newLoc = (char *) programHeader[i].p_vaddr + 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); x += 0x1000) {
+        for (x = 0; x < (programHeader[i].p_memsz); x += 0x1000) {
           /* make r/w or ro */
-          if ((vmm_remapPage(vmm_findFreePage(_current->id), ((programHeader[i].phVaddr & 0xFFFFF000) + x + LD_START), PAGE_DEFAULT)) == 0x0)
+          if ((vmm_remapPage(vmm_findFreePage(_current->id), ((programHeader[i].p_vaddr & 0xFFFFF000) + x + LD_START), PAGE_DEFAULT, _current->id)) == 0x0)
             K_PANIC("vmmRemapPage: ld");
-          memset((void *) ((programHeader[i].phVaddr & 0xFFFFF000) + x + LD_START), 0x0, 0x1000);
+          memset((void *) ((programHeader[i].p_vaddr & 0xFFFFF000) + x + LD_START), 0x0, 0x1000);
         }
         /* Now Load Section To Memory */
-        fseek(ldFd, programHeader[i].phOffset, 0x0);
-        fread(newLoc, programHeader[i].phFilesz, 1, ldFd);
+        fseek(ldFd, programHeader[i].p_offset, 0x0);
+        fread(newLoc, programHeader[i].p_filesz, 1, ldFd);
 
       break;
       case PT_DYNAMIC:
         /* Now Load Section To Memory */
-        fseek(ldFd, programHeader[i].phOffset, 0x0);
-        fread(newLoc, programHeader[i].phFilesz, 1, ldFd);
+        fseek(ldFd, programHeader[i].p_offset, 0x0);
+        fread(newLoc, programHeader[i].p_filesz, 1, ldFd);
       break;
       case PT_GNU_STACK:
         /* Tells us if the stack should be executable.  Failsafe to executable
          until we add checking */
       break;
       default:
-        kprintf("Unhandled Header (kernel) : %08x\n", programHeader[i].phType);
+        kprintf("Unhandled Header (kernel) : %08x\n", programHeader[i].p_type);
       break;
     }
   }
 
   for (i = 0x0; i < binaryHeader->e_shnum; i++) {
-    switch (sectionHeader[i].shType) {
+    switch (sectionHeader[i].sh_type) {
       case 3:
-        if (!strcmp((shStr + sectionHeader[i].shName), ".dynstr")) {
-          dynStr = (char *) kmalloc(sectionHeader[i].shSize);
-          fseek(ldFd, sectionHeader[i].shOffset, 0x0);
-          fread(dynStr, sectionHeader[i].shSize, 1, ldFd);
+        if (!strcmp((shStr + sectionHeader[i].sh_name), ".dynstr")) {
+          dynStr = (char *) kmalloc(sectionHeader[i].sh_size);
+          fseek(ldFd, sectionHeader[i].sh_offset, 0x0);
+          fread(dynStr, sectionHeader[i].sh_size, 1, ldFd);
         }
       break;
       case 9:
-        elfRel = (elfPltInfo *) kmalloc(sectionHeader[i].shSize);
-        fseek(ldFd, sectionHeader[i].shOffset, 0x0);
-        fread(elfRel, sectionHeader[i].shSize, 1, ldFd);
+        elfRel = (Elf_Rel *) kmalloc(sectionHeader[i].sh_size);
+        fseek(ldFd, sectionHeader[i].sh_offset, 0x0);
+        fread(elfRel, sectionHeader[i].sh_size, 1, ldFd);
 
-        for (x = 0x0; x < sectionHeader[i].shSize / sizeof(elfPltInfo); x++) {
-          rel = ELF32_R_SYM(elfRel[x].pltInfo);
-          reMap = (uInt32 *) ((uInt32) LD_START + elfRel[x].pltOffset);
-          switch (ELF32_R_TYPE(elfRel[x].pltInfo)) {
+        for (x = 0x0; x < sectionHeader[i].sh_size / sizeof(Elf_Rel); x++) {
+          rel = ELF32_R_SYM(elfRel[x].r_info);
+          reMap = (uint32_t *) ((uint32_t) LD_START + elfRel[x].r_offset);
+          switch (ELF32_R_TYPE(elfRel[x].r_info)) {
             case R_386_32:
-              *reMap += ((uInt32) LD_START + relSymTab[rel].dynValue);
+              *reMap += ((uint32_t) LD_START + relSymTab[rel].st_value);
             break;
             case R_386_PC32:
-              *reMap += ((uInt32) LD_START + relSymTab[rel].dynValue) - (uInt32) reMap;
+              *reMap += ((uint32_t) LD_START + relSymTab[rel].st_value) - (uint32_t) reMap;
             break;
             case R_386_RELATIVE:
-              *reMap += (uInt32) LD_START;
+              *reMap += (uint32_t) LD_START;
             break;
             default:
-              kprintf("[0x%X][0x%X](%i)[%s]\n", elfRel[x].pltOffset, elfRel[x].pltInfo, rel, elfGetRelType(ELF32_R_TYPE(elfRel[x].pltInfo)));
-              kprintf("relTab [%s][0x%X][0x%X]\n", dynStr + relSymTab[rel].dynName, relSymTab[rel].dynValue, relSymTab[rel].dynName);
+              kprintf("[0x%X][0x%X](%i)[%s]\n", elfRel[x].r_offset, elfRel[x].r_info, rel, elfGetRelType(ELF32_R_TYPE(elfRel[x].r_info)));
+              kprintf("relTab [%s][0x%X][0x%X]\n", dynStr + relSymTab[rel].st_name, relSymTab[rel].st_value, relSymTab[rel].st_name);
             break;
           }
         }
         kfree(elfRel);
       break;
       case 11:
-        relSymTab = (elfDynSym *) kmalloc(sectionHeader[i].shSize);
-        fseek(ldFd, sectionHeader[i].shOffset, 0x0);
-        fread(relSymTab, sectionHeader[i].shSize, 1, ldFd);
+        relSymTab = (Elf_Sym *) kmalloc(sectionHeader[i].sh_size);
+        fseek(ldFd, sectionHeader[i].sh_offset, 0x0);
+        fread(relSymTab, sectionHeader[i].sh_size, 1, ldFd);
         sym = i;
       break;
     }
@@ -168,5 +168,5 @@
   kfree(binaryHeader);
   fclose(ldFd);
 
-  return ((uInt32) i);
+  return ((uint32_t) i);
 }
diff --git a/sys/kernel/syscall_new.c b/sys/kernel/syscall_new.c
index 76ab262..4e2fd0a 100644
--- a/sys/kernel/syscall_new.c
+++ b/sys/kernel/syscall_new.c
@@ -115,8 +115,6 @@
 
 if ( systemCalls[code].sc_status == SYSCALL_DUMMY )
   kprintf("RET2");
-if ( systemCalls[code].sc_status == SYSCALL_DUMMY )
-  kprintf("RET2.1");
     }
   }
 }
@@ -130,7 +128,6 @@
       :
   );
 
-  kprintf( "Invalid System Call #[%i]\n", sys_call );
-  kpanic("PID: %i", _current->id);
+  kprintf( "Invalid System Call #[%i], PID: %i\n", sys_call, _current->id );
   return (0);
 }
diff --git a/sys/kernel/syscalls.c b/sys/kernel/syscalls.c
index 02c26b2..c62eaf0 100644
--- a/sys/kernel/syscalls.c
+++ b/sys/kernel/syscalls.c
@@ -382,6 +382,7 @@
     { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 347 - Invalid */
     { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 348 - Invalid */
     { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 349 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 350 - Invalid */
 };
 
 int totalCalls = sizeof(systemCalls) / sizeof(struct syscall_entry);
diff --git a/sys/vmm/getfreepage.c b/sys/vmm/getfreepage.c
index da85df1..39a6679 100644
--- a/sys/vmm/getfreepage.c
+++ b/sys/vmm/getfreepage.c
@@ -59,7 +59,7 @@
       /* Loop Through The Page Table Find An UnAllocated Page */
       if ( (uInt32) pageTableSrc[y] == (uInt32) 0x0 ) {
         /* Map A Physical Page To The Virtual Page */
-        if ( (vmm_remapPage( vmm_findFreePage( pid ), ((x * 0x400000) + (y * 0x1000)), KERNEL_PAGE_DEFAULT )) == 0x0 )
+        if ( (vmm_remapPage( vmm_findFreePage( pid ), ((x * 0x400000) + (y * 0x1000)), KERNEL_PAGE_DEFAULT, pid )) == 0x0 )
           kpanic( "vmmRemapPage: vmm_getFreePage\n" );
         /* Clear This Page So No Garbage Is There */
         vmm_clearVirtualPage( (uInt32)( (x * 0x400000) + (y * 0x1000) ) );
diff --git a/sys/vmm/getfreevirtualpage.c b/sys/vmm/getfreevirtualpage.c
index e8ae77d..ff0fcec 100644
--- a/sys/vmm/getfreevirtualpage.c
+++ b/sys/vmm/getfreevirtualpage.c
@@ -122,7 +122,7 @@
         kprintf( "COW PAGE NOT CLEANED!" );
       }
       else if ( (uInt32) pageTableSrc[y] == (uInt32) 0x0 ) {
-        if ( (vmm_remapPage( (uInt32) vmm_findFreePage( pid ), ((pdI * (1024 * 4096)) + (y * 4096)), PAGE_DEFAULT )) == 0x0 )
+        if ( (vmm_remapPage( (uInt32) vmm_findFreePage( pid ), ((pdI * (1024 * 4096)) + (y * 4096)), PAGE_DEFAULT, pid )) == 0x0 )
           kpanic( "vmmRemapPage: getFreeVirtualPage-1: (%i)[0x%X]\n", type, ((pdI * (1024 * 4096)) + (y * 4096)) );
         vmm_clearVirtualPage( (uInt32)( (pdI * (1024 * 4096)) + (y * 4096) ) );
       }
diff --git a/sys/vmm/paging.c b/sys/vmm/paging.c
index e45aaee..f2f5097 100644
--- a/sys/vmm/paging.c
+++ b/sys/vmm/paging.c
@@ -158,7 +158,7 @@
 
   /* Remap The Memory List */
   for (i = 0x101000; i <= (0x101000 + (numPages * sizeof(mMap))); i += 0x1000) {
-    if ((vmm_remapPage(i, (VMM_MMAP_ADDR_PMODE + (i - 0x101000)), PAGE_DEFAULT)) == 0x0)
+    if ((vmm_remapPage(i, (VMM_MMAP_ADDR_PMODE + (i - 0x101000)), PAGE_DEFAULT, sysID)) == 0x0)
       K_PANIC("vmmRemapPage failed\n");
   }
 
@@ -183,11 +183,16 @@
  07/28/04 - If perms == 0x0 set to PAGE_DEFAULT
 
  *****************************************************************************************/
-int vmm_remapPage(uint32_t source, u_int dest, uInt16 perms) {
-  uInt16 destPageDirectoryIndex = 0x0, destPageTableIndex = 0x0;
-  u_int *pageDir = 0x0, *pageTable = 0x0;
+int vmm_remapPage(uint32_t source, uint32_t dest, uint16_t perms, pidType pid) {
+
+  uint16_t destPageDirectoryIndex = 0x0, destPageTableIndex = 0x0;
+  uint32_t *pageDir = 0x0, *pageTable = 0x0;
+
   short i = 0x0;
 
+  if (pid < sysID)
+    kpanic("Invalid PID %i", pid);
+
   if (source == 0x0)
     K_PANIC("source == 0x0");
 
@@ -200,7 +205,7 @@
     perms = KERNEL_PAGE_DEFAULT;
 
   /* Set Pointer pageDirectory To Point To The Virtual Mapping Of The Page Directory */
-  pageDir = PD_BASE_ADDR;
+  pageDir = (uint32_t *)PD_BASE_ADDR;
 
   /* Get Index Into The Page Directory */
   destPageDirectoryIndex = PD_INDEX(dest);
@@ -209,13 +214,13 @@
     //kprintf("Page Not Present: 0x%X, Source: 0x%X, Dest: 0x%X, dPDI: 0x%X\n", dest, source, dest, destPageDirectoryIndex);
     /* If Page Table Is Non Existant Then Set It Up */
     /* UBU Why does the page table need to be user writable? */
-    pageDir[destPageDirectoryIndex] = (uint32_t) vmm_findFreePage(_current->id) | PAGE_DEFAULT;
+    pageDir[destPageDirectoryIndex] = (uint32_t) vmm_findFreePage(pid) | PAGE_DEFAULT;
 
     /* Also Add It To Virtual Space So We Can Make Changes Later */
     pageTable = (uint32_t *) (PT_BASE_ADDR + (PD_INDEX( PT_BASE_ADDR ) * 0x1000)); /* Table that maps that 4b */
     pageTable[destPageDirectoryIndex] = (pageDir[destPageDirectoryIndex] & 0xFFFFF000) | PAGE_DEFAULT; /* Is This Why Page Needs To Be User As Well? */
 
-    pageTable = (PT_BASE_ADDR + (destPageDirectoryIndex * 0x1000));
+    pageTable = (uint32_t *)(PT_BASE_ADDR + (destPageDirectoryIndex * 0x1000));
 
     /* Need To Figure Out invlpg */
     asm volatile(
@@ -305,7 +310,7 @@
           }
           if (c != -1) {
             for (c = 0; c < count; c++) {
-              if ((vmm_remapPage((uint32_t) vmm_findFreePage(pid), ((x * (1024 * 4096)) + ((y + c) * 4096)), KERNEL_PAGE_DEFAULT)) == 0x0)
+              if ((vmm_remapPage((uint32_t) vmm_findFreePage(pid), ((x * (1024 * 4096)) + ((y + c) * 4096)), KERNEL_PAGE_DEFAULT, pid)) == 0x0)
                 K_PANIC("vmmRemapPage failed: gfkp-1\n");
               vmm_clearVirtualPage((uint32_t) ((x * (1024 * 4096)) + ((y + c) * 4096)));
             }
@@ -316,7 +321,7 @@
         else {
           /* Map A Physical Page To The Virtual Page */
 
-          if ((vmm_remapPage((uint32_t) vmm_findFreePage(pid), ((x * (1024 * 4096)) + (y * 4096)), KERNEL_PAGE_DEFAULT)) == 0x0)
+          if ((vmm_remapPage((uint32_t) vmm_findFreePage(pid), ((x * (1024 * 4096)) + (y * 4096)), KERNEL_PAGE_DEFAULT, pid)) == 0x0)
             K_PANIC("vmmRemapPage failed: gfkp-2\n");
 
           /* Clear This Page So No Garbage Is There */
@@ -375,11 +380,11 @@
   dI = (baseAddr / (1024 * 4096));
   tI = ((baseAddr - (dI * (1024 * 4096))) / 4096);
 
-  if (vmm_remapPage(child->tss.cr3, 0x5A00000, KERNEL_PAGE_DEFAULT) == 0x0)
+  if (vmm_remapPage(child->tss.cr3, 0x5A00000, KERNEL_PAGE_DEFAULT, _current->id) == 0x0)
     K_PANIC("vmm_remapPage: Failed");
 
   for (i = 0; i < 0x1000; i++) {
-    if (vmm_remapPage(childPageDir[i], 0x5A01000 + (i * 0x1000), KERNEL_PAGE_DEFAULT) == 0x0)
+    if (vmm_remapPage(childPageDir[i], 0x5A01000 + (i * 0x1000), KERNEL_PAGE_DEFAULT, _current->id) == 0x0)
       K_PANIC("Returned NULL");
   }
   for (x = (_current->oInfo.vmStart / (1024 * 4096)); x < 1024; x++) {
@@ -417,7 +422,7 @@
 
               childPageTable = (uint32_t *) (0x5A01000 + (0x1000 * dI));
 
-              if (vmm_remapPage(childPageTable[tI + c], ((x * (1024 * 4096)) + ((y + c) * 4096)), KERNEL_PAGE_DEFAULT) == 0x0)
+              if (vmm_remapPage(childPageTable[tI + c], ((x * (1024 * 4096)) + ((y + c) * 4096)), KERNEL_PAGE_DEFAULT, _current->id) == 0x0)
                 K_PANIC("remap == NULL");
 
             }
@@ -438,7 +443,7 @@
           //Map A Physical Page To The Virtual Page
           childPageTable = (uint32_t *) (0x5A01000 + (0x1000 * dI));
 
-          if (vmm_remapPage(childPageTable[tI], ((x * (1024 * 4096)) + (y * 4096)), KERNEL_PAGE_DEFAULT) == 0x0)
+          if (vmm_remapPage(childPageTable[tI], ((x * (1024 * 4096)) + (y * 4096)), KERNEL_PAGE_DEFAULT, _current->id) == 0x0)
             K_PANIC("remap Failed");
 
           //Return The Address Of The Mapped In Memory
@@ -485,7 +490,7 @@
           }
           if (c != -1) {
             for (c = 0; c < count; c++) {
-              if (vmm_remapPage((uint32_t) vmm_findFreePage( sysID), ((x * 0x400000) + ((y + c) * 0x1000)), KERNEL_PAGE_DEFAULT) == 0x0)
+              if (vmm_remapPage((uint32_t) vmm_findFreePage( sysID), ((x * 0x400000) + ((y + c) * 0x1000)), KERNEL_PAGE_DEFAULT, sysID) == 0x0)
                 K_PANIC("remap Failed");
 
               vmm_clearVirtualPage((uint32_t) ((x * 0x400000) + ((y + c) * 0x1000)));
@@ -496,7 +501,7 @@
         }
         else {
           /* Map A Physical Page To The Virtual Page */
-          if (vmm_remapPage((uint32_t) vmm_findFreePage( sysID), ((x * 0x400000) + (y * 0x1000)), KERNEL_PAGE_DEFAULT) == 0x0)
+          if (vmm_remapPage((uint32_t) vmm_findFreePage( sysID), ((x * 0x400000) + (y * 0x1000)), KERNEL_PAGE_DEFAULT, sysID) == 0x0)
             K_PANIC("Failed");
 
           /* Clear This Page So No Garbage Is There */
@@ -589,7 +594,7 @@
 
   if (new > old) {
     for (i = old; i < new; i += 0x1000) {
-      if (vmm_remapPage(vmm_findFreePage(_current->id), i, PAGE_DEFAULT) == 0x0)
+      if (vmm_remapPage(vmm_findFreePage(_current->id), i, PAGE_DEFAULT, _current->id) == 0x0)
         K_PANIC("remap Failed");
     }
     td->vm_dsize += btoc(new - old);
diff --git a/sys/vmm/vmm_memory.c b/sys/vmm/vmm_memory.c
index 6c19060..0d80c52 100644
--- a/sys/vmm/vmm_memory.c
+++ b/sys/vmm/vmm_memory.c
@@ -220,7 +220,8 @@
  Notes:
 
  ************************************************************************/
-uInt32 vmm_findFreePage(pidType pid) {
+uint32_t vmm_findFreePage(pidType pid) {
+
   int i = 0x0;
 
   /* Lets Look For A Free Page */
@@ -241,7 +242,6 @@
       freePages--;
       if (systemVitals)
         systemVitals->freePages = freePages;
-//kprintf("vFFP: 0x%X\n", vmmMemoryMap[i].pageAddr);
 
       spinUnlock(&vmmSpinLock);
       return (vmmMemoryMap[i].pageAddr);
diff --git a/sys/vmm/vmm_mmap.c b/sys/vmm/vmm_mmap.c
index b36e96f..e8f8456 100644
--- a/sys/vmm/vmm_mmap.c
+++ b/sys/vmm/vmm_mmap.c
@@ -138,7 +138,7 @@
      cap_maxprot = VM_PROT_ALL;
      */
     for ( i = addr; i < (addr + size); i += 0x1000 ) {
-      if ( vmm_remapPage( vmmFindFreePage( _current->id ), i, PAGE_DEFAULT ) == 0x0 )
+      if ( vmm_remapPage( vmmFindFreePage( _current->id ), i, PAGE_DEFAULT, _current->id ) == 0x0 )
         K_PANIC( "remap Failed" );
     }
     kprintf( "td->vm_dsize should be adjust but isn't" );