diff --git a/bin/login/main.c b/bin/login/main.c
index f620c5e..37e006c 100644
--- a/bin/login/main.c
+++ b/bin/login/main.c
@@ -55,8 +55,11 @@
   string[count] = '\0';
   return(string);
   }
+
+static char *argv_shell[2] = { "shell", NULL, }; // ARGV For Initial Proccess
+static char *envp_shell[6] = { "HOME=/", "PWD=/", "PATH=/bin:/sbin:/usr/bin:/usr/sbin", "USER=root", "GROUP=admin", NULL, }; //ENVP For Initial Proccess
   
-int main() {
+int main(int argc, char **argv, char **env) {
   FILE *fd;
   int shellPid = 0,i = 0x0;
   char userName[32];
@@ -133,7 +136,7 @@
           fclose(fd);          
           //chdir(data[i].path);
           chdir("sys:/bin/");
-          execve(data[i].shell,0x0,0x0);
+          execve(data[i].shell,argv_shell,envp_shell);
           printf("Error: Problem Starting Shell\n");
           exit(-1);
           }
diff --git a/bin/shell/exec.c b/bin/shell/exec.c
index 6a2ee04..c542678 100644
--- a/bin/shell/exec.c
+++ b/bin/shell/exec.c
@@ -30,6 +30,10 @@
 
   int boo = 0x0;
 
+static char *argv_init[2] = { "init", NULL, }; // ARGV For Initial Proccess
+static char *envp_init[7] = { "HOME=/", "PWD=/", "PATH=/bin:/sbin:/usr/bin:/usr/sbin", "USER=root", "GROUP=admin", "LD_DEBUG=all", NULL, }; //ENVP For Initial Proccess
+
+
 void execProgram(inputBuffer *data) {
   char file[1024];
   int cPid = 0x0;
@@ -43,7 +47,7 @@
     sprintf(file, "%s%s", cwd, data->argv[1]);
  //   if (boo == 0)
       //execve(file,data->argv, 0x0);
-      execve(file,0x0, 0x0);
+      execve(file,argv_init, envp_init);
    /*
     else
       execn(file,&data->argv);
diff --git a/sys/Makefile.incl b/sys/Makefile.incl
index 12c9d5a..fc05a04 100644
--- a/sys/Makefile.incl
+++ b/sys/Makefile.incl
@@ -8,5 +8,5 @@
 KMAKE= ${MAKE} ${KERNEL_FLAGS} INCLUDE=${KERNEL_INC} KERNEL=${KERNEL_NAME}
 
 INCLUDES = -I${INCLUDE}
-CFLAGS = ${KFLAGS} -m32 -Wall -nostdlib -nostdinc -fno-builtin -fno-exceptions -ffreestanding -O
+CFLAGS = ${KFLAGS} -m32 -Wall -nostdlib -nostdinc -fno-builtin -fno-exceptions -ffreestanding
 ROOT=/ubixos
diff --git a/sys/fs/vfs/Makefile b/sys/fs/vfs/Makefile
index fb5ef9d..6a32a0d 100644
--- a/sys/fs/vfs/Makefile
+++ b/sys/fs/vfs/Makefile
@@ -6,7 +6,7 @@
 include ../../Makefile.incl
 
 #  Objects
-OBJS = mount.o file.o vfs.o
+OBJS = mount.o file.o vfs.o stat.o namei.o inode.o
 
 all: $(OBJS)
 
diff --git a/sys/fs/vfs/inode.c b/sys/fs/vfs/inode.c
new file mode 100644
index 0000000..190f475
--- /dev/null
+++ b/sys/fs/vfs/inode.c
@@ -0,0 +1,37 @@
+#include <vfs/vfs.h>
+
+void iput(struct inode * inode) {
+  if (!inode)
+    return;
+  wait_on_inode(inode);
+  if (!inode->i_count) {
+    printk("VFS: iput: trying to free free inode\n");
+    printk("VFS: device %d/%d, inode %lu, mode=0%07o\n", MAJOR(inode->i_rdev), MINOR(inode->i_rdev), inode->i_ino, inode->i_mode);
+    return;
+  }
+  if (inode->i_pipe)
+    wake_up_interruptible(&PIPE_WAIT(*inode));
+  repeat: if (inode->i_count > 1) {
+    inode->i_count--;
+    return;
+  }
+  wake_up(&inode_wait);
+  if (inode->i_pipe) {
+    unsigned long page = (unsigned long) PIPE_BASE(*inode);
+    PIPE_BASE(*inode) = NULL;
+    free_page(page);
+  }
+  if (inode->i_sb && inode->i_sb->s_op && inode->i_sb->s_op->put_inode) {
+    inode->i_sb->s_op->put_inode(inode);
+    if (!inode->i_nlink)
+      return;
+  }
+  if (inode->i_dirt) {
+    write_inode(inode); /* we can sleep - so do again */
+    wait_on_inode(inode);
+    goto repeat;
+  }
+  inode->i_count--;
+  nr_free_inodes++;
+  return;
+}
diff --git a/sys/fs/vfs/namei.c b/sys/fs/vfs/namei.c
new file mode 100644
index 0000000..a128331
--- /dev/null
+++ b/sys/fs/vfs/namei.c
@@ -0,0 +1,131 @@
+#include <ubixos/errno.h>
+#include <vfs/vfs.h>
+
+int permission(struct inode * inode, int mask) {
+  int mode = inode->i_mode;
+
+  if (inode->i_op && inode->i_op->permission)
+    return inode->i_op->permission(inode, mask);
+  else if (_current->euid == inode->i_uid)
+    mode >>= 6;
+  else if (in_group_p(inode->i_gid))
+    mode >>= 3;
+  if (((mode & mask & 0007) == mask))// || suser())
+    return 1;
+  return 0;
+}
+
+int lookup(struct inode * dir, const char * name, int len, struct inode ** result) {
+  struct super_block * sb;
+  int perm;
+
+  *result = NULL;
+  if (!dir)
+    return -ENOENT;
+  /* check permissions before traversing mount-points */
+  perm = permission(dir, MAY_EXEC);
+  if (len == 2 && name[0] == '.' && name[1] == '.') {
+    if (dir == _current->root) {
+      *result = dir;
+      return 0;
+    }
+    else if ((sb = dir->i_sb) && (dir == sb->s_mounted)) {
+      sb = dir->i_sb;
+      iput(dir);
+      dir = sb->s_covered;
+      if (!dir)
+        return -ENOENT;
+      dir->i_count++;
+    }
+  }
+  if (!dir->i_op || !dir->i_op->lookup) {
+    iput(dir);
+    return -ENOTDIR;
+  }
+  if (!perm) {
+    iput(dir);
+    return -EACCES;
+  }
+  if (!len) {
+    *result = dir;
+    return 0;
+  }
+  return dir->i_op->lookup(dir, name, len, result);
+}
+
+
+static int dir_namei(const char * pathname, int * namelen, const char ** name, struct inode * base, struct inode ** res_inode) {
+  char c;
+  const char * thisname;
+  int len, error;
+  struct inode * inode;
+
+  *res_inode = NULL;
+  if (!base) {
+    base = _current->pwd;
+    base->i_count++;
+  }
+  if ((c = *pathname) == '/') {
+    iput(base);
+    base = _current->root;
+    pathname++;
+    base->i_count++;
+  }
+  while (1) {
+    thisname = pathname;
+    for (len = 0; (c = *(pathname++)) && (c != '/'); len++)
+      /* nothing */;
+    if (!c)
+      break;
+    base->i_count++;
+    error = lookup(base, thisname, len, &inode);
+    if (error) {
+      iput(base);
+      return error;
+    }
+    error = follow_link(base, inode, 0, 0, &base);
+    if (error)
+      return error;
+  }
+  if (!base->i_op || !base->i_op->lookup) {
+    iput(base);
+    return -ENOTDIR;
+  }
+  *name = thisname;
+  *namelen = len;
+  *res_inode = base;
+  return 0;
+}
+
+int namei(const char * pathname, struct inode * base, int follow_links, struct inode ** res_inode) {
+  const char *basename;
+  int namelen, error;
+  struct inode *inode;
+
+  *res_inode = NULL;
+
+  error = dir_namei(pathname, &namelen, &basename, base, &base);
+  if (error)
+    return error;
+
+  base->i_count++; /* lookup uses up base */
+
+  error = lookup(base, basename, namelen, &inode);
+
+  if (error) {
+    iput(base);
+    return error;
+  }
+
+  if (follow_links) {
+    error = follow_link(base, inode, 0, 0, &inode);
+    if (error)
+      return error;
+  }
+  else
+    iput(base);
+
+  *res_inode = inode;
+
+  return 0;
+}
diff --git a/sys/fs/vfs/stat.c b/sys/fs/vfs/stat.c
new file mode 100644
index 0000000..a6cb89f
--- /dev/null
+++ b/sys/fs/vfs/stat.c
@@ -0,0 +1,39 @@
+#include <ubixos/errno.h>
+#include <vfs/stat.h>
+#include <vfs/vfs.h>
+
+int sys_stat(char *path, struct stat *sb, int flags) {
+  int error = 0;
+  struct inode *inode;
+
+  //NOTE: Should we verify that the memory is writable?
+  kprintf("SYS_STAT {%s}", path);
+
+  switch (flags) {
+    case STAT_LSTAT:
+      namei(path, NULL, STAT_NO_FOLLOW, &inode);
+      break;
+    default:
+      error = -1;
+     break;
+  }
+
+  sb->st_dev = 0x5E;
+  sb->st_ino = 0x3003;
+  sb->st_mode = 0x41FF;
+  sb->st_nlink = 0x2;
+  sb->st_uid = 0x0;
+  sb->st_gid = 0x0;
+  sb->st_rdev = 0x7FF3;
+  sb->st_size = 0xFFFFEB70;
+
+  return(error);
+}
+
+
+/* Return stat of path do not follow if link return stat of link */
+int sys_lstat(struct thread *td, struct sys_lstat_args *args) {
+  td->td_retval[0] = sys_stat(args->path, args->sb, STAT_LSTAT);
+  return(0x0);
+}
+
diff --git a/sys/fs/vfs/vfs.c b/sys/fs/vfs/vfs.c
index f813947..7c971ca 100644
--- a/sys/fs/vfs/vfs.c
+++ b/sys/fs/vfs/vfs.c
@@ -161,7 +161,8 @@
   if (nfp->fd == 0x0)
     td->td_retval[0] = -1;
   else
-    td->td_retval[0] = index;
+    td->td_retval[0] = nfp->fd;//MrOlsen 2018index;
+
   return (error);
   }
 
diff --git a/sys/i386/i386_exec.c b/sys/i386/i386_exec.c
index ba18605..f1e0a0f 100644
--- a/sys/i386/i386_exec.c
+++ b/sys/i386/i386_exec.c
@@ -39,9 +39,9 @@
 #include <assert.h>
 #include <string.h>
 
-#define ENVP_PAGE 0x1000
-#define ARGV_PAGE 0x1000
-#define ELF_AUX 0x1000
+#define ENVP_PAGE 0x100
+#define ARGV_PAGE 0x100
+#define ELF_AUX 0x100
 #define STACK_PAD 16
 
 #define ENOEXEC -1
@@ -77,6 +77,57 @@
   return (i);
 }
 
+static int args_copyin(char **argv_in, char **argv_out, char **args_out) {
+
+  int argc = argv_count(argv_in);
+
+  uint32_t *argv_tmp = (uint32_t *)kmalloc(sizeof(char *) * (argc + 2)); // + 1 For ARGC + 1 For NULL TERM
+
+  char *args_tmp = (char *)kmalloc(ARGV_PAGE);
+
+  argv_tmp[0] = argc;
+
+  uint32_t sp = 0x0;
+
+  int i = 0x0;
+
+  for (i = 1; i <=argc; i++) {
+    argv_tmp[i] = args_tmp + sp;
+    strcpy(argv_tmp[i], argv_in[i - 1]);
+    sp += strlen(argv_in[i - 1]) + 1;
+  }
+
+  argv_tmp[i++] = 0x0;
+
+  *argv_out = argv_tmp;
+  *args_out = args_tmp;
+
+}
+
+static int envs_copyin(char **envp_in, char **envp_out, char **envs_out) {
+
+  int envc = envp_count(envp_in);
+
+  uint32_t *envp_tmp = (uint32_t *)kmalloc(sizeof(char *) * (envc + 1)); // + 1 For NULL TERM
+
+  char *envs_tmp = (char *)kmalloc(ENVP_PAGE);
+
+  uint32_t sp = 0x0;
+
+  int i = 0x0;
+
+  for (i = 0; i < envc; i++) {
+    envp_tmp[i] = envs_tmp + sp;
+    strcpy(envp_tmp[i], envp_in[i]);
+    sp += strlen(envp_in[i]) + 1;
+  }
+  envp_tmp[i++] = 0x0;
+
+  *envp_out = envp_tmp;
+  *envs_out = envs_tmp;
+
+}
+
 static int elf_parse_dynamic(elf_file_t ef);
 
 /*****************************************************************************************
@@ -191,9 +242,9 @@
 
   uint32_t *tmp = 0x0;
 
-  Elf32_Ehdr *binaryHeader = 0x0;
+  Elf_Ehdr *binaryHeader = 0x0;
 
-  Elf32_Phdr *programHeader = 0x0;
+  Elf_Phdr *programHeader = 0x0;
 
   int argc = argv_count(argv);
   int envc = envp_count(envp);
@@ -239,9 +290,9 @@
   }
 
   /* Load ELF Header */
-  binaryHeader = (Elf32_Ehdr *) kmalloc(sizeof(Elf32_Ehdr));
+  binaryHeader = (Elf_Ehdr *) kmalloc(sizeof(Elf_Ehdr));
 
-  fread(binaryHeader, sizeof(Elf32_Ehdr), 1, newProcess->imageFd);
+  fread(binaryHeader, sizeof(Elf_Ehdr), 1, newProcess->imageFd);
 
   /* Check If App Is A Real Application */
   if ((binaryHeader->e_ident[1] != 'E') && (binaryHeader->e_ident[2] != 'L') && (binaryHeader->e_ident[3] != 'F')) {
@@ -269,9 +320,7 @@
   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(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 */
   for (i = 0; i < binaryHeader->e_phnum; i++) {
@@ -315,9 +364,7 @@
 
   /* Kernel Stack 0x2000 bytes long */
 
-  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 */
@@ -422,18 +469,19 @@
 
   uint32_t cr3 = 0x0;
 
-  unsigned int *tmp = 0x0;
+  uint32_t *tmp = 0x0;
 
   uInt32 seg_size = 0x0;
   uInt32 seg_addr = 0x0;
 
   char *interp = 0x0;
+  uint32_t ldAddr = 0x0;
 
   fileDescriptor *fd = 0x0;
 
-  Elf32_Ehdr *binaryHeader = 0x0;
-  Elf32_Phdr *programHeader = 0x0;
-  Elf32_Shdr *sectionHeader = 0x0;
+  Elf_Ehdr *binaryHeader = 0x0;
+  Elf_Phdr *programHeader = 0x0;
+  Elf_Shdr *sectionHeader = 0x0;
 
   elf_file_t ef = 0x0;
 
@@ -459,16 +507,29 @@
   /* Set Threads FD to open FD */
   _current->imageFd = fd;
 
+  /* Copy In ARGS & ENVS Before Cleaning Virtual Space */
+  uint32_t *argv_out = 0x0;
+  char *args_out = 0x0;
+
+  kprintf("ARGV: 0x%X\n", &argv_out);
+
+  args_copyin(argv, &argv_out, &args_out);
+
+  uint32_t *envp_out = 0x0;
+  char *envs_out = 0x0;
+
+  envs_copyin(envp, &envp_out, &envs_out);
+
   //! Clean the virtual of COW pages left over from the fork
   //vmm_cleanVirtualSpace( (uint32_t) _current->td.vm_daddr + (_current->td.vm_dsize << PAGE_SHIFT) );
   //MrOlsen 2017-12-15 - FIX! - This should be done before it was causing a lot of problems why did I free space after loading binary????
   vmm_cleanVirtualSpace((uint32_t) 0x8048000);
 
   /* Load ELF Header */
-  if ((binaryHeader = (Elf32_Ehdr *) kmalloc(sizeof(Elf32_Ehdr))) == 0x0)
+  if ((binaryHeader = (Elf_Ehdr *) kmalloc(sizeof(Elf_Ehdr))) == 0x0)
     K_PANIC("MALLOC FAILED");
 
-  fread(binaryHeader, sizeof(Elf32_Ehdr), 1, fd);
+  fread(binaryHeader, sizeof(Elf_Ehdr), 1, fd);
   /* Done Loading ELF Header */
 
   /* Check If App Is A Real Application */
@@ -495,7 +556,7 @@
   td->abi = binaryHeader->e_ident[EI_OSABI];
 
   /* Load The Program Header(s) */
-  if ((programHeader = (Elf32_Phdr *) kmalloc(sizeof(Elf32_Phdr) * binaryHeader->e_phnum)) == 0x0)
+  if ((programHeader = (Elf_Phdr *) kmalloc(sizeof(Elf_Phdr) * binaryHeader->e_phnum)) == 0x0)
     K_PANIC("MALLOC FAILED");
 
   assert(programHeader);
@@ -505,7 +566,7 @@
   /* Done Loading Program Header(s) */
 
   /* Load The Section Header(s) */
-  if ((sectionHeader = (Elf32_Shdr *) kmalloc(sizeof(Elf32_Shdr) * binaryHeader->e_shnum)) == 0x0)
+  if ((sectionHeader = (Elf_Shdr *) kmalloc(sizeof(Elf_Shdr) * binaryHeader->e_shnum)) == 0x0)
     K_PANIC("MALLOC FAILED");
 
   assert(sectionHeader);
@@ -514,6 +575,7 @@
   /* Done Loading Section Header(s) */
 
   ef = kmalloc(sizeof(struct elf_file));
+  memset(ef, 0x0, sizeof(struct elf_file));
 
   /* Loop Through The Header And Load Sections Which Need To Be Loaded */
   for (i = 0; i < binaryHeader->e_phnum; i++) {
@@ -578,7 +640,7 @@
       case PT_DYNAMIC:
         //newLoc = (char *)programHeader[i].phVaddr;
         //elfDynamicS = (elfDynamic *) programHeader[i].p_vaddr;
-        ef->dynamic = (Elf32_Dyn *) programHeader[i].p_vaddr;
+        ef->dynamic = (Elf_Dyn *) programHeader[i].p_vaddr;
         //fseek( fd, programHeader[i].phOffset, 0 );
         //fread( (void *) programHeader[i].phVaddr, programHeader[i].phFilesz, 1, fd );
       break;
@@ -588,13 +650,14 @@
         fseek(fd, programHeader[i].p_offset, 0);
         fread((void *) interp, programHeader[i].p_filesz, 1, fd);
         kprintf("Interp: [%s]\n", interp);
-        //ldAddr = ldEnable();
-        ef->ld_addr = ldEnable();
+        ldAddr = ldEnable();
+        //ef->ld_addr = ldEnable();
       break;
       case PT_GNU_STACK:
-      break;
+        asm("nop");
+        break;
       default:
-      break;
+        break;
     }
   }
 
@@ -605,84 +668,116 @@
 
   kprintf("Done Looping\n");
 
+  ef->preloaded = 1;
+  ef->address = 0x0;
   elf_parse_dynamic(ef);
 
-  /*
-   _current->td.vm_dsize = seg_size >> PAGE_SHIFT;
-   _current->td.vm_daddr = (char *) seg_addr;
-   */
-
+  //asm("cld");
+  //irqDisable(0);
   iFrame = (struct i386_frame *) (_current->tss.esp0 - sizeof(struct i386_frame));
-  /*
-   iFrameNew = (struct i386_frame *) kmalloc( sizeof(struct i386_frame) );
 
-   memcpy( iFrameNew, iFrame, sizeof(struct i386_frame) );
-   */
+  //iFrame->ebp = 0x0;
 
-  //! Adjust iframe
-//  iFrame = (struct i386_frame *) (_current->tss.esp0 - sizeof(struct i386_frame));
-  //kprintf( "EBP-1(%i): EBP: [0x%X], EIP: [0x%X], ESP: [0x%X]\n", _current->id, iFrame->ebp, iFrame->eip, iFrame->user_esp );
+  if (ldAddr != 0x0) {
+    iFrame->eip = ldAddr;
+    kprintf("DYN");
+  }
+  else {
+    iFrame->eip = binaryHeader->e_entry;
+    kprintf("STATIC");
+  }
 
-  iFrame->ebp = 0x0;      //STACK_ADDR;
-  iFrame->eip = binaryHeader->e_entry;
-  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));
+  //iFrame->edx = 0x0;
 
-  iFrame->user_esp = STACK_ADDR - ARGV_PAGE - ENVP_PAGE - ELF_AUX - (argc + 1) - (envc + 1) - STACK_PAD;
+  iFrame->user_esp = (uint32_t)STACK_ADDR - ARGV_PAGE - ENVP_PAGE - ELF_AUX - (argc + 1) - (envc + 1) - STACK_PAD;
 
-  tmp = (void *) iFrame->user_esp; //MrOlsen 2017-11-14 iFrame->user_ebp;
+  tmp = (uint32_t *)iFrame->user_esp;
 
   memset((char *) tmp, 0x0, ARGV_PAGE + ENVP_PAGE + ELF_AUX + (argc + 1) + (envc + 1) + STACK_PAD);
 
-  kprintf("ARGC: [%i]", argc);
-  kprintf("ARGV[0] %s - 0x%X", argv[0], &argv[0]);
-  while(1);
-
   tmp[0] = argc;
 
   uint32_t sp = 0x0;
 
   for (i = 1; i <= argc; i++) {
-    tmp[i] = STACK_ADDR - ARGV_PAGE + sp;
-    strcpy((char *)tmp[i], argv[i - 1]);
-    sp += strlen(argv[i - 1]) + 1;
+    tmp[i] = (uint32_t)STACK_ADDR - ARGV_PAGE + sp;
+    strcpy((char *)tmp[i], (char *)argv_out[i]);
+    sp += strlen(argv_out[i]) + 1;
   }
-  tmp[i++] = 0x0;
+
+  tmp[i++] = (char *)0x0;
+
+  kfree(argv_out);
+  kfree(args_out);
 
   sp = 0;
-  for (int x = 0; x < envc; x++) {
-    tmp[x + i] = STACK_ADDR - ARGV_PAGE - ENVP_PAGE + sp;
-    strcpy((char *)tmp[x + i], envp[x]);
-    sp += strlen(envp[x]) + 1;
+ 
+  x = 0;
+
+  for (x = 0; x < envc; x++) {
+    tmp[x + i] = (uint32_t)STACK_ADDR - ARGV_PAGE - ENVP_PAGE + sp;
+    strcpy((char *)tmp[x + i], (char *)envp_out[x]);
+    sp += strlen(envp_out[x]) + 1;
   }
-  tmp[i + x] = 0x0;
 
-  /*
-   tmp[0] = argc; // ARGC
+  tmp[i + x] = (char *)0x0;
 
-   tmp[1] = 0x0; // ARGV
-   tmp[2] = 0x0; // ARGV Terminator
+  kfree(envp_out);
+  kfree(envs_out);
 
-   tmp[3] = 0x0; // ENV
-   tmp[4] = 0x0; // ENV Terminator
+  i = i+ x + 1;
 
-   tmp[5] = 0x1;
-   tmp[6] = 0x2;
+  tmp[i++] = 2;
+  tmp[i++] = -1;// _current->imageFd;
+  kprintf("AT_EXECFD: [%i]", tmp[i-1]);
 
-   tmp[7] = 0x3; // AUX VECTOR 8 Bytes
-   tmp[8] = 0x4; // Terminator
+  tmp[i++] = 3;
+  tmp[i++] = binaryHeader->e_phoff + 0x08048000;
+  kprintf("AT_PHDR: [0x%X]", tmp[i-1]);
 
-   tmp[9] = 0x5;
-   tmp[10] = 0x6;
+  tmp[i++] = 4;
+  tmp[i++] = binaryHeader->e_phentsize;
+  kprintf("AT_PHENT: [0x%X]", tmp[i-1]);
+  
+  tmp[i++] = 5;
+  tmp[i++] = binaryHeader->e_phnum;
+  kprintf("AT_PHNUM: [0x%X]", tmp[i-1]);
 
-   tmp[11] = 0x7;
-   tmp[12] = 0x8;
-   */
+  tmp[i++] = 6;
+  tmp[i++] = 0x1000;
+
+  tmp[i++] = 7;
+  tmp[i++] = 0x0;//LD_START;
+  kprintf("AT_BASE: [0x%X]", tmp[i-1]);
+
+  tmp[i++] = 8;
+  tmp[i++] = 0x0;
+
+  tmp[i++] = 9;
+  tmp[i++] = binaryHeader->e_entry;
+
+  tmp[i++] = 11;
+  tmp[i++] = 0x0;
+
+  tmp[i++] = 12;
+  tmp[i++] = 0x0;
+
+  tmp[i++] = 13;
+  tmp[i++] = 0x0;
+
+  tmp[i++] = 14;
+  tmp[i++] = 0x0;
+
+  tmp[i++] = 0;
+  tmp[i++] = 0;
+
 
   /* Now That We Relocated The Binary We Can Unmap And Free Header Info */
   kfree(binaryHeader);
   kfree(programHeader);
+  //irqEnable(0);
+  //asm("sti");
+
 
   /*
    _current->tss.es = 0x30 + 3;
@@ -734,7 +829,7 @@
       case DT_HASH:
         asm("nop");
         /* From src/libexec/rtld-elf/rtld.c */
-        const Elf32_Hashelt *hashtab = (const Elf32_Hashelt *) (ef->address + dynp->d_un.d_ptr);
+        const Elf_Hashelt *hashtab = (const Elf_Hashelt *) (ef->address + dynp->d_un.d_ptr);
         ef->nbuckets = hashtab[0];
         ef->nchains = hashtab[1];
         ef->buckets = hashtab + 2;
@@ -747,36 +842,36 @@
         ef->strsz = dynp->d_un.d_val;
       break;
       case DT_SYMTAB:
-        ef->symtab = (Elf32_Sym *) (ef->address + dynp->d_un.d_ptr);
+        ef->symtab = (Elf_Sym *) (ef->address + dynp->d_un.d_ptr);
       break;
       case DT_SYMENT:
         if (dynp->d_un.d_val != sizeof(Elf32_Sym))
           return (ENOEXEC);
       break;
       case DT_REL:
-        ef->rel = (const Elf32_Rel *) (ef->address + dynp->d_un.d_ptr);
+        ef->rel = (const Elf_Rel *) (ef->address + dynp->d_un.d_ptr);
       break;
       case DT_RELSZ:
         ef->relsize = dynp->d_un.d_val;
       break;
       case DT_RELENT:
-        if (dynp->d_un.d_val != sizeof(Elf32_Rel))
+        if (dynp->d_un.d_val != sizeof(Elf_Rel))
           return (ENOEXEC);
       break;
       case DT_JMPREL:
-        ef->pltrel = (const Elf32_Rel *) (ef->address + dynp->d_un.d_ptr);
+        ef->pltrel = (const Elf_Rel *) (ef->address + dynp->d_un.d_ptr);
       break;
       case DT_PLTRELSZ:
         ef->pltrelsize = dynp->d_un.d_val;
       break;
       case DT_RELA:
-        ef->rela = (const Elf32_Rela *) (ef->address + dynp->d_un.d_ptr);
+        ef->rela = (const Elf_Rela *) (ef->address + dynp->d_un.d_ptr);
       break;
       case DT_RELASZ:
         ef->relasize = dynp->d_un.d_val;
       break;
       case DT_RELAENT:
-        if (dynp->d_un.d_val != sizeof(Elf32_Rela))
+        if (dynp->d_un.d_val != sizeof(Elf_Rela))
           return (ENOEXEC);
       break;
       case DT_PLTREL:
@@ -785,14 +880,12 @@
           return (ENOEXEC);
       break;
       case DT_PLTGOT:
-        ef->got = (Elf32_Addr *) (ef->address + dynp->d_un.d_ptr);
+        ef->got = (Elf_Addr *) (ef->address + dynp->d_un.d_ptr);
+        /*
         tmp = (void *) dynp->d_un.d_ptr; //elfDynamicS[i].dynPtr;
-        if (tmp == 0x0)
-          kpanic("tmp: NULL\n");
-        else
-          kprintf("PLT[0x%X:0x%X]", tmp, ef->ld_addr);
         tmp[2] = (uInt32) ef->ld_addr;
         tmp[1] = (uInt32) ef; //0x0;//0xBEEFEAD;//STACK_ADDR - 128;//_current->imageFd;//0xBEEFDEAD;//ef;
+        */
       break;
       default:
         asm("nop");
@@ -800,10 +893,13 @@
       break;
     }
   }
-  ef->pltrela = (const Elf32_Rela *) ef->pltrel;
+
+  if (plttype == DT_RELA) {
+  ef->pltrela = (const Elf_Rela *) ef->pltrel;
   ef->pltrel = NULL;
   ef->pltrelasize = ef->pltrelsize;
   ef->pltrelsize = 0;
+  }
 
   ef->ddbsymtab = ef->symtab;
   ef->ddbsymcnt = ef->nchains;
diff --git a/sys/i386/trap.c b/sys/i386/trap.c
index 7114abc..a11dba2 100644
--- a/sys/i386/trap.c
+++ b/sys/i386/trap.c
@@ -182,6 +182,8 @@
 
   cr2 = rcr2();
   kprintf("trap_code: %i(0x%X), EIP: 0x%X, CR2: 0x%X\n", frame->tf_trapno, frame->tf_trapno, frame->tf_eip, cr2);
+
+  //kpanic("trap_code: %i(0x%X), EIP: 0x%X, CR2: 0x%X\n", frame->tf_trapno, frame->tf_trapno, frame->tf_eip, cr2);
   die_if_kernel("trapCode", frame, frame->tf_trapno);
   endTask( _current->id );
   sched_yield();
diff --git a/sys/include/fs/msdos_fs.h b/sys/include/fs/msdos_fs.h
new file mode 100644
index 0000000..372bbe0
--- /dev/null
+++ b/sys/include/fs/msdos_fs.h
@@ -0,0 +1,43 @@
+#ifndef _FS_MSDOS_FS_H
+#define _FS_MSDOS_FS_H
+
+/*
+ * MS-DOS file system in-core superblock data
+ */
+
+struct msdos_sb_info {
+    unsigned short cluster_size; /* sectors/cluster */
+    unsigned char fats, fat_bits; /* number of FATs, FAT bits (12 or 16) */
+    unsigned short fat_start, fat_length; /* FAT start & length (sec.) */
+    unsigned short dir_start, dir_entries; /* root dir start & entries */
+    unsigned short data_start; /* first data sector */
+    unsigned long clusters; /* number of clusters */
+    uid_t fs_uid;
+    gid_t fs_gid;
+    int quiet; /* fake successful chmods and chowns */
+    unsigned short fs_umask;
+    unsigned char name_check; /* r = relaxed, n = normal, s = strict */
+    unsigned char conversion; /* b = binary, t = text, a = auto */
+    struct wait_queue *fat_wait;
+    int fat_lock;
+    int prev_free; /* previously returned free cluster number */
+    int free_clusters; /* -1 if undefined */
+};
+
+/*
+ * MS-DOS file system inode data in memory
+ */
+
+struct msdos_inode_info {
+	int i_start;	/* first cluster or 0 */
+	int i_attrs;	/* unused attribute bits */
+	int i_busy;	/* file is either deleted but still open, or
+			   inconsistent (mkdir) */
+	struct inode *i_depend; /* pointer to inode that depends on the
+				   current inode */
+	struct inode *i_old;	/* pointer to the old inode this inode
+				   depends on */
+	int i_binary;	/* file contains non-text data */
+};
+
+#endif
diff --git a/sys/include/fs/pipe_fs.h b/sys/include/fs/pipe_fs.h
new file mode 100644
index 0000000..42882b9
--- /dev/null
+++ b/sys/include/fs/pipe_fs.h
@@ -0,0 +1,16 @@
+#ifndef _FS_PIPE_FS_H
+#define _FS_PIPE_FS_H
+
+struct pipe_inode_info {
+	struct wait_queue *wait;
+	char *base;
+	unsigned int start;
+	unsigned int len;
+	unsigned int lock;
+	unsigned int rd_openers;
+	unsigned int wr_openers;
+	unsigned int readers;
+	unsigned int writers;
+};
+
+#endif
diff --git a/sys/include/sys/elf.h b/sys/include/sys/elf.h
index 16235a1..2cb4336 100644
--- a/sys/include/sys/elf.h
+++ b/sys/include/sys/elf.h
@@ -71,8 +71,6 @@
   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/sys/kern_descrip.h b/sys/include/sys/kern_descrip.h
index bfcddfa..66a0b10 100644
--- a/sys/include/sys/kern_descrip.h
+++ b/sys/include/sys/kern_descrip.h
@@ -34,6 +34,7 @@
 #include <sys/sysproto.h>
 
 #include <vfs/file.h>
+#include <vfs/stat.h>
 
 typedef  __mode_t        mode_t;
 typedef  __nlink_t       nlink_t;
@@ -96,12 +97,14 @@
   fileDescriptor *fd;
   };
 
+#ifdef _BALLS
 /* TEMP */
 struct __timespec {
         __time_t tv_sec;        /* seconds */
         long    tv_nsec;        /* and nanoseconds */
 };
 
+
 struct stat {
         __dev_t   st_dev;               /* inode's device */
         ino_t     st_ino;               /* inode's number */
@@ -147,6 +150,7 @@
         unsigned int :(8 / 2) * (16 - (int)sizeof(struct __timespec));
 #endif
 };
+#endif
 
 
 int fcntl(struct thread *, struct fcntl_args *);
diff --git a/sys/include/sys/sysproto.h b/sys/include/sys/sysproto.h
index a7e433b..cf68ae1 100644
--- a/sys/include/sys/sysproto.h
+++ b/sys/include/sys/sysproto.h
@@ -308,7 +308,7 @@
 struct getpid_args {
     register_t dummy;
 };
-struct issetugid_args {
+struct sys_issetugid_args {
     register_t dummy;
 };
 struct fcntl_args {
@@ -376,6 +376,15 @@
     char pos_r_[PADR_( off_t )];
 };
 
+struct sys_lstat_args {
+  char path_l_[PADL_(char *)];
+  char *path;
+  char path_r_[PADR_(char *)];
+  char sb_l_[PADL_( struct stat *)];
+  struct stat *sb;
+  char sb_r_[PADR_( struct stat *)];
+};
+
 struct obreak_args {
     char nsize_l_[PADL_( char * )];
     char * nsize;
@@ -489,11 +498,15 @@
 int sys_mmap( struct thread *td, struct sys_mmap_args * );
 int sys_sysctl( struct thread *td, struct sys_sysctl_args * );
 
+int sys_issetugid(struct thread *td, struct sys_issetugid_args * );
+
 int setitimer( struct thread *td, struct setitimer_args *uap );
 int access( struct thread *td, struct access_args *uap );
 int fstatfs( struct thread *td, struct fstatfs_args *uap );
 int mprotect( struct thread *td, struct mprotect_args *uap );
 
+int sys_lstat(struct thread *td, struct sys_lstat_args * );
+
 #endif
 
 /***
diff --git a/sys/include/ubixos/errno.h b/sys/include/ubixos/errno.h
new file mode 100644
index 0000000..29d909b
--- /dev/null
+++ b/sys/include/ubixos/errno.h
@@ -0,0 +1,180 @@
+/**
+ * @file
+ * Posix Errno defines
+ */
+
+/*
+ * Copyright (c) 2001-2004 Swedish Institute of Computer Science.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
+ * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+ * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+ * OF SUCH DAMAGE.
+ *
+ * This file is part of the lwIP TCP/IP stack.
+ *
+ * Author: Adam Dunkels <adam@sics.se>
+ *
+ */
+#ifndef _UBIXOS_ERRNO_H
+#define _UBIXOS_ERRNO_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define  EPERM            1  /* Operation not permitted */
+#define  ENOENT           2  /* No such file or directory */
+#define  ESRCH            3  /* No such process */
+#define  EINTR            4  /* Interrupted system call */
+#define  EIO              5  /* I/O error */
+#define  ENXIO            6  /* No such device or address */
+#define  E2BIG            7  /* Arg list too long */
+#define  ENOEXEC          8  /* Exec format error */
+#define  EBADF            9  /* Bad file number */
+#define  ECHILD          10  /* No child processes */
+#define  EAGAIN          11  /* Try again */
+#define  ENOMEM          12  /* Out of memory */
+#define  EACCES          13  /* Permission denied */
+#define  EFAULT          14  /* Bad address */
+#define  ENOTBLK         15  /* Block device required */
+#define  EBUSY           16  /* Device or resource busy */
+#define  EEXIST          17  /* File exists */
+#define  EXDEV           18  /* Cross-device link */
+#define  ENODEV          19  /* No such device */
+#define  ENOTDIR         20  /* Not a directory */
+#define  EISDIR          21  /* Is a directory */
+#define  EINVAL          22  /* Invalid argument */
+#define  ENFILE          23  /* File table overflow */
+#define  EMFILE          24  /* Too many open files */
+#define  ENOTTY          25  /* Not a typewriter */
+#define  ETXTBSY         26  /* Text file busy */
+#define  EFBIG           27  /* File too large */
+#define  ENOSPC          28  /* No space left on device */
+#define  ESPIPE          29  /* Illegal seek */
+#define  EROFS           30  /* Read-only file system */
+#define  EMLINK          31  /* Too many links */
+#define  EPIPE           32  /* Broken pipe */
+#define  EDOM            33  /* Math argument out of domain of func */
+#define  ERANGE          34  /* Math result not representable */
+#define  EDEADLK         35  /* Resource deadlock would occur */
+#define  ENAMETOOLONG    36  /* File name too long */
+#define  ENOLCK          37  /* No record locks available */
+#define  ENOSYS          38  /* Function not implemented */
+#define  ENOTEMPTY       39  /* Directory not empty */
+#define  ELOOP           40  /* Too many symbolic links encountered */
+#define  EWOULDBLOCK     EAGAIN  /* Operation would block */
+#define  ENOMSG          42  /* No message of desired type */
+#define  EIDRM           43  /* Identifier removed */
+#define  ECHRNG          44  /* Channel number out of range */
+#define  EL2NSYNC        45  /* Level 2 not synchronized */
+#define  EL3HLT          46  /* Level 3 halted */
+#define  EL3RST          47  /* Level 3 reset */
+#define  ELNRNG          48  /* Link number out of range */
+#define  EUNATCH         49  /* Protocol driver not attached */
+#define  ENOCSI          50  /* No CSI structure available */
+#define  EL2HLT          51  /* Level 2 halted */
+#define  EBADE           52  /* Invalid exchange */
+#define  EBADR           53  /* Invalid request descriptor */
+#define  EXFULL          54  /* Exchange full */
+#define  ENOANO          55  /* No anode */
+#define  EBADRQC         56  /* Invalid request code */
+#define  EBADSLT         57  /* Invalid slot */
+
+#define  EDEADLOCK       EDEADLK
+
+#define  EBFONT          59  /* Bad font file format */
+#define  ENOSTR          60  /* Device not a stream */
+#define  ENODATA         61  /* No data available */
+#define  ETIME           62  /* Timer expired */
+#define  ENOSR           63  /* Out of streams resources */
+#define  ENONET          64  /* Machine is not on the network */
+#define  ENOPKG          65  /* Package not installed */
+#define  EREMOTE         66  /* Object is remote */
+#define  ENOLINK         67  /* Link has been severed */
+#define  EADV            68  /* Advertise error */
+#define  ESRMNT          69  /* Srmount error */
+#define  ECOMM           70  /* Communication error on send */
+#define  EPROTO          71  /* Protocol error */
+#define  EMULTIHOP       72  /* Multihop attempted */
+#define  EDOTDOT         73  /* RFS specific error */
+#define  EBADMSG         74  /* Not a data message */
+#define  EOVERFLOW       75  /* Value too large for defined data type */
+#define  ENOTUNIQ        76  /* Name not unique on network */
+#define  EBADFD          77  /* File descriptor in bad state */
+#define  EREMCHG         78  /* Remote address changed */
+#define  ELIBACC         79  /* Can not access a needed shared library */
+#define  ELIBBAD         80  /* Accessing a corrupted shared library */
+#define  ELIBSCN         81  /* .lib section in a.out corrupted */
+#define  ELIBMAX         82  /* Attempting to link in too many shared libraries */
+#define  ELIBEXEC        83  /* Cannot exec a shared library directly */
+#define  EILSEQ          84  /* Illegal byte sequence */
+#define  ERESTART        85  /* Interrupted system call should be restarted */
+#define  ESTRPIPE        86  /* Streams pipe error */
+#define  EUSERS          87  /* Too many users */
+#define  ENOTSOCK        88  /* Socket operation on non-socket */
+#define  EDESTADDRREQ    89  /* Destination address required */
+#define  EMSGSIZE        90  /* Message too long */
+#define  EPROTOTYPE      91  /* Protocol wrong type for socket */
+#define  ENOPROTOOPT     92  /* Protocol not available */
+#define  EPROTONOSUPPORT 93  /* Protocol not supported */
+#define  ESOCKTNOSUPPORT 94  /* Socket type not supported */
+#define  EOPNOTSUPP      95  /* Operation not supported on transport endpoint */
+#define  EPFNOSUPPORT    96  /* Protocol family not supported */
+#define  EAFNOSUPPORT    97  /* Address family not supported by protocol */
+#define  EADDRINUSE      98  /* Address already in use */
+#define  EADDRNOTAVAIL   99  /* Cannot assign requested address */
+#define  ENETDOWN       100  /* Network is down */
+#define  ENETUNREACH    101  /* Network is unreachable */
+#define  ENETRESET      102  /* Network dropped connection because of reset */
+#define  ECONNABORTED   103  /* Software caused connection abort */
+#define  ECONNRESET     104  /* Connection reset by peer */
+#define  ENOBUFS        105  /* No buffer space available */
+#define  EISCONN        106  /* Transport endpoint is already connected */
+#define  ENOTCONN       107  /* Transport endpoint is not connected */
+#define  ESHUTDOWN      108  /* Cannot send after transport endpoint shutdown */
+#define  ETOOMANYREFS   109  /* Too many references: cannot splice */
+#define  ETIMEDOUT      110  /* Connection timed out */
+#define  ECONNREFUSED   111  /* Connection refused */
+#define  EHOSTDOWN      112  /* Host is down */
+#define  EHOSTUNREACH   113  /* No route to host */
+#define  EALREADY       114  /* Operation already in progress */
+#define  EINPROGRESS    115  /* Operation now in progress */
+#define  ESTALE         116  /* Stale NFS file handle */
+#define  EUCLEAN        117  /* Structure needs cleaning */
+#define  ENOTNAM        118  /* Not a XENIX named type file */
+#define  ENAVAIL        119  /* No XENIX semaphores available */
+#define  EISNAM         120  /* Is a named type file */
+#define  EREMOTEIO      121  /* Remote I/O error */
+#define  EDQUOT         122  /* Quota exceeded */
+
+#define  ENOMEDIUM      123  /* No medium found */
+#define  EMEDIUMTYPE    124  /* Wrong medium type */
+
+#ifndef errno
+extern int errno;
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* LWIP_HDR_ERRNO_H */
diff --git a/sys/include/ubixos/sched.h b/sys/include/ubixos/sched.h
index 229fe6c..f1fec85 100644
--- a/sys/include/ubixos/sched.h
+++ b/sys/include/ubixos/sched.h
@@ -64,9 +64,14 @@
   tState state;
   uint32_t gid;
   uint32_t uid;
+  uint16_t euid, suid;
+  uint16_t egid, sgid;
   uInt16 usedMath;
   tty_term *term;
   struct thread td;
+  struct inode *pwd;
+  struct inode *root;
+  struct inode *exec;
 } kTask_t;
 
 int sched_init();
diff --git a/sys/include/ubixos/wait.h b/sys/include/ubixos/wait.h
new file mode 100644
index 0000000..22feb5e
--- /dev/null
+++ b/sys/include/ubixos/wait.h
@@ -0,0 +1,16 @@
+#ifndef _UBIXOS_WAIT_H
+#define _UBIXOS_WAIT_H
+
+#include <ubixos/sched.h>
+
+struct wait_queue {
+  struct kTask_t *task;
+  struct wait_queue *next;
+};
+
+struct semaphore {
+  int sount;
+  struct wait_queue *wait;
+};
+
+#endif
diff --git a/sys/include/vfs/stat.h b/sys/include/vfs/stat.h
new file mode 100644
index 0000000..a637e14
--- /dev/null
+++ b/sys/include/vfs/stat.h
@@ -0,0 +1,42 @@
+#ifndef _VFS_STAT_H
+#define _VFS_STAT_H
+
+#include <sys/types.h>
+
+#define STAT_LSTAT 0x00000001
+
+#define STAT_NO_FOLLOW 0x00000000
+#define STAT_FOLLOW    0x00000001
+
+struct __timespec {
+        __time_t tv_sec;        /* seconds */
+        long    tv_nsec;        /* and nanoseconds */
+};
+
+struct stat {
+        __dev_t   st_dev;               /* inode's device */
+        ino_t     st_ino;               /* inode's number */
+        __mode_t    st_mode;              /* inode protection mode */
+        __nlink_t   st_nlink;             /* number of hard links */
+        uid_t     st_uid;               /* user ID of the file's owner */
+        gid_t     st_gid;               /* group ID of the file's group */
+        __dev_t   st_rdev;              /* device type */
+        time_t    st_atime;             /* time of last access */
+        long      __st_atimensec;       /* nsec of last access */
+        time_t    st_mtime;             /* time of last data modification */
+        long      __st_mtimensec;       /* nsec of last data modification */
+        time_t    st_ctime;             /* time of last file status change */
+        long      __st_ctimensec;       /* nsec of last file status change */
+        off_t     st_size;              /* file size, in bytes */
+        blkcnt_t st_blocks;             /* blocks allocated for file */
+        blksize_t st_blksize;           /* optimal blocksize for I/O */
+        fflags_t  st_flags;             /* user defined flags for file */
+        __uint32_t st_gen;              /* file generation number */
+        __int32_t st_lspare;
+        time_t    st_birthtime;         /* time of file creation */
+        long      st_birthtimensec;     /* nsec of file creation */
+        unsigned int :(8 / 2) * (16 - (int)sizeof(struct __timespec));
+        unsigned int :(8 / 2) * (16 - (int)sizeof(struct __timespec));
+};
+
+#endif
diff --git a/sys/include/vfs/vfs.h b/sys/include/vfs/vfs.h
index 027b802..77035f4 100644
--- a/sys/include/vfs/vfs.h
+++ b/sys/include/vfs/vfs.h
@@ -35,6 +35,12 @@
 #include <vfs/mount.h>
 #include <sys/sysproto.h>
 #include <sys/thread.h>
+#include <net/net.h>
+#include <ubixos/wait.h>
+
+#define MAY_EXEC 1
+#define MAY_WRITE 2
+#define MAY_READ 4
 
 #define maxFd   32
 #define fdAvail 1
@@ -68,13 +74,93 @@
   };
 
 
+struct inode_operations {
+    struct file_operations * default_file_ops;
+    int (*create)(struct inode *, const char *, int, int, struct inode **);
+    int (*lookup)(struct inode *, const char *, int, struct inode **);
+    int (*link)(struct inode *, struct inode *, const char *, int);
+    int (*unlink)(struct inode *, const char *, int);
+    int (*symlink)(struct inode *, const char *, int, const char *);
+    int (*mkdir)(struct inode *, const char *, int, int);
+    int (*rmdir)(struct inode *, const char *, int);
+    int (*mknod)(struct inode *, const char *, int, int, int);
+    int (*rename)(struct inode *, const char *, int, struct inode *, const char *, int);
+    int (*readlink)(struct inode *, char *, int);
+    int (*follow_link)(struct inode *, struct inode *, int, int, struct inode **);
+    int (*bmap)(struct inode *, int);
+    void (*truncate)(struct inode *);
+    int (*permission)(struct inode *, int);
+};
+
 /* VFS Functions */
 int vfs_init();
 int vfsRegisterFS(struct fileSystem);
 struct fileSystem *vfs_findFS(int);
 
-#endif
+#include <fs/pipe_fs.h>
+#include <fs/msdos_fs.h>
+#include <ufs/ufs.h>
 
-/***
- END
- ***/
+struct super_block {
+    __dev_t s_dev;
+    unsigned long s_blocksize;
+    unsigned char s_blocksize_bits;
+    unsigned char s_lock;
+    unsigned char s_rd_only;
+    unsigned char s_dirt;
+    struct super_operations *s_op;
+    unsigned long s_flags;
+    unsigned long s_magic;
+    unsigned long s_time;
+    struct inode * s_covered;
+    struct inode * s_mounted;
+    struct wait_queue * s_wait;
+    union {
+        struct msdos_sb_info msdos_sb;
+        struct fs ufs1_sb;
+        struct fs ufs2_sb;
+    } u;
+};
+
+struct inode {
+    __dev_t i_dev;
+    unsigned long i_ino;
+    __mode_t i_mode;
+    __nlink_t i_nlink;
+    uid_t i_uid;
+    gid_t i_gid;
+    __dev_t i_rdev;
+    off_t i_size;
+    time_t i_atime;
+    time_t i_mtime;
+    time_t i_ctime;
+    unsigned long i_blksize;
+    unsigned long i_blocks;
+    struct semaphore i_sem;
+    struct inode_operations * i_op;
+    struct super_block * i_sb;
+    struct wait_queue * i_wait;
+    struct file_lock * i_flock;
+    struct vm_area_struct * i_mmap;
+    struct inode * i_next, *i_prev;
+    struct inode * i_hash_next, *i_hash_prev;
+    struct inode * i_bound_to, *i_bound_by;
+    struct inode * i_mount;
+    struct socket * i_socket;
+    unsigned short i_count;
+    unsigned short i_flags;
+    unsigned char i_lock;
+    unsigned char i_dirt;
+    unsigned char i_pipe;
+    unsigned char i_seek;
+    unsigned char i_update;
+    union {
+        struct pipe_inode_info pipe_i;
+        struct msdos_inode_info msdos_i;
+        struct ufs1_dinode ufs1_i;
+        struct ufs2_dinode ufs2_i;
+    } u;
+};
+
+
+#endif
diff --git a/sys/kernel/gen_calls.c b/sys/kernel/gen_calls.c
index f4efaa0..ca2372d 100644
--- a/sys/kernel/gen_calls.c
+++ b/sys/kernel/gen_calls.c
@@ -81,8 +81,7 @@
   if ( uap->fd == 2 ) {
     kprintf( "stderr: %s", uap->buf );
   }
-
-  if ( uap->fd == 1 ) {
+  else if ( uap->fd == 1 ) {
     /* This is Horrible! */
     in = (char *) uap->buf;
     buffer = kmalloc( 1024 );
@@ -103,10 +102,7 @@
   return (0x0);
 }
 
-int issetugid( register struct thread *td, struct issetugid_args *uap ) {
-#ifdef DEBUG
-  kprintf("[%s:%i]",__FILE__,__LINE__);
-#endif
+int sys_issetugid( register struct thread *td, struct sys_issetugid_args *uap ) {
   td->td_retval[0] = 0;
   return (0);
 }
@@ -171,10 +167,18 @@
 
 int sys_invalid( struct thread *td, void *args ) {
   kprintf( "Invalid System Call #[%i], Pid: %i\n", td->frame->tf_eax, _current->id );
+ //td->td_retval[0] =0;
   return (0);
 }
 
 int sys_read( struct thread *td, struct sys_read_args *args ) {
+  char *buf = args->buf;
+  kprintf("ARGS->fd: %i, NBYTE: %i\n", args->fd, args->nbyte);
+  buf[0] = 'C';
+  buf[1] = 'A';
+  buf[2] = 'T';
+  buf[3] = '\0';
+  td->td_retval[0] = 3;
   kprintf( "DUMMY FUNC FIX ME! sys_read" );
   return (0);
 }
diff --git a/sys/kernel/kern_sysctl.c b/sys/kernel/kern_sysctl.c
index 2daf858..bd1d6e2 100644
--- a/sys/kernel/kern_sysctl.c
+++ b/sys/kernel/kern_sysctl.c
@@ -218,9 +218,9 @@
   if ( tmpCtl == 0x0 ) {
     kprintf( "Invalid CTL\n" );
     for ( i = 0x0; i < args->namelen; i++ )
-      kprintf( "(%i)", args->name[i] );
+      kprintf( "(%i)", (int)args->name[i] );
     kprintf( "\n" );
-    //endTask(_current->id);
+    td->td_retval[0] = -1;
     return (-1);
   }
 
@@ -229,7 +229,7 @@
   else
     memcpy( args->oldp, tmpCtl->value, tmpCtl->val_len );
 
-  //td->td_retval[0] = 0x0;
+  td->td_retval[0] = 0x0;
 
   return (0x0);
 }
diff --git a/sys/kernel/ld.c b/sys/kernel/ld.c
index 3560f86..93e9033 100644
--- a/sys/kernel/ld.c
+++ b/sys/kernel/ld.c
@@ -48,7 +48,7 @@
   char *dynStr = 0x0;
   uint32_t *reMap = 0x0;
   fileDescriptor *ldFd = 0x0;
-  Elf32_Ehdr *binaryHeader = 0x0;
+  Elf_Ehdr *binaryHeader = 0x0;
   Elf_Phdr *programHeader = 0x0;
   Elf_Shdr *sectionHeader = 0x0;
   Elf_Sym *relSymTab = 0x0;
@@ -63,11 +63,13 @@
 
   fseek(ldFd, 0x0, 0x0);
   binaryHeader = (Elf32_Ehdr *) kmalloc(sizeof(Elf32_Ehdr));
+
   assert(binaryHeader);
   fread(binaryHeader, sizeof(Elf32_Ehdr), 1, ldFd);
 
   programHeader = (Elf_Phdr *) kmalloc(sizeof(Elf_Phdr) * binaryHeader->e_phnum);
   assert(programHeader);
+
   fseek(ldFd, binaryHeader->e_phoff, 0);
   fread(programHeader, sizeof(Elf_Shdr), binaryHeader->e_phnum, ldFd);
 
diff --git a/sys/kernel/syscall_new.c b/sys/kernel/syscall_new.c
index 4e2fd0a..e8ed0f7 100644
--- a/sys/kernel/syscall_new.c
+++ b/sys/kernel/syscall_new.c
@@ -61,7 +61,8 @@
   }
 
   if ( code > totalCalls ) {
-    kprintf( "Invalid Call: [%i:%i]\n", frame->tf_eax, totalCalls );
+    //kprintf( "Invalid Call: [%i:%i]\n", frame->tf_eax, totalCalls );
+    die_if_kernel("Invalid System Call", frame, frame->tf_eax);
     kpanic("PID: %i", _current->id);
   }
   else if ( (uint32_t) systemCalls[code].sc_status == SYSCALL_INVALID ) {
diff --git a/sys/kernel/syscalls.c b/sys/kernel/syscalls.c
index c62eaf0..6c094e6 100644
--- a/sys/kernel/syscalls.c
+++ b/sys/kernel/syscalls.c
@@ -33,12 +33,12 @@
 /* System Calls List */
 struct syscall_entry systemCalls[] = {
     { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 0 - Invalid */
-    { ARG_COUNT( sys_exit_args ), "exit", (sys_call_t *)sys_exit ,2},
-    { ARG_COUNT( sys_fork_args ), "fork", (sys_call_t *)sys_fork , SYSCALL_VALID},
-    { ARG_COUNT( sys_read_args ), "read", (sys_call_t *)sys_read ,2 },
+    { ARG_COUNT( sys_exit_args ), "exit", (sys_call_t *)sys_exit ,2}, /* 1 - exit */
+    { ARG_COUNT( sys_fork_args ), "fork", (sys_call_t *)sys_fork , SYSCALL_VALID}, /* 2 - fork */
+    { ARG_COUNT( sys_read_args ), "read", (sys_call_t *)sys_read , SYSCALL_VALID}, /* 3 - read */
     { ARG_COUNT( sys_write_args ), "write", (sys_call_t *)sys_write ,SYSCALL_VALID},
-    { ARG_COUNT( sys_open_args ), "open", (sys_call_t *)sys_open ,2 },
-    { ARG_COUNT( sys_close_args ), "close", (sys_call_t *)sys_close ,2 },
+    { ARG_COUNT( sys_open_args ), "open", (sys_call_t *)sys_open , SYSCALL_DUMMY },
+    { ARG_COUNT( sys_close_args ), "close", (sys_call_t *)sys_close , SYSCALL_VALID},
     { ARG_COUNT( sys_wait4_args ), "wiat4", (sys_call_t *)sys_wait4 , 1},
     { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /*   8 - Invalid */
     { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /*   9 - Invalid */
@@ -91,7 +91,7 @@
     { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /*  56 - Invalid */
     { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /*  57 - Invalid */
     { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /*  58 - Invalid */
-    { ARG_COUNT( sys_execve_args), "Exec VE", (sys_call_t *)sys_execve, SYSCALL_DUMMY },                                  /*  59 - Invalid */
+    { ARG_COUNT( sys_execve_args), "Exec VE", (sys_call_t *)sys_execve, SYSCALL_DUMMY }, /*  59 - execve */
     { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /*  60 - Invalid */
     { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /*  61 - Invalid */
     { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /*  62 - Invalid */
@@ -222,7 +222,7 @@
     { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 187 - Invalid */
     { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 188 - Invalid */
     { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 189 - Invalid */
-    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 190 - Invalid */
+    { ARG_COUNT(sys_lstat_args), "LSTAT", (sys_call_t *)sys_lstat, SYSCALL_VALID }, /* 190 - sys_lstat */
     { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 191 - Invalid */
     { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 192 - Invalid */
     { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 193 - Invalid */
@@ -285,7 +285,7 @@
     { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 250 - Invalid */
     { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 251 - Invalid */
     { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 252 - Invalid */
-    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 253 - Invalid */
+    { ARG_COUNT(sys_issetugid_args), "ISSETUGID", (sys_call_t *)sys_issetugid, SYSCALL_VALID },                                  /* 253 - Invalid */
     { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 254 - Invalid */
     { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 255 - Invalid */
     { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 256 - Invalid */
@@ -383,6 +383,165 @@
     { 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 */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 351 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 352 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 353 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 354 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 355 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 356 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 357 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 358 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 359 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 350 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 351 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 352 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 353 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 354 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 355 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 356 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 357 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 358 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 359 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 360 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 361 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 362 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 363 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 364 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 365 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 366 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 367 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 368 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 369 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 370 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 371 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 372 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 373 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 374 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 375 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 376 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 377 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 378 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 379 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 380 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 381 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 382 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 383 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 384 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 385 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 386 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 387 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 388 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 389 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 390 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 391 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 392 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 393 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 394 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 395 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 396 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 397 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 398 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 399 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 400 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 351 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 352 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 353 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 354 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 355 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 356 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 357 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 358 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 359 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 350 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 351 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 352 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 353 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 354 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 355 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 356 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 357 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 358 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 359 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 350 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 351 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 352 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 353 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 354 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 355 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 356 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 357 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 358 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 359 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 350 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 351 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 352 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 353 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 354 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 355 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 356 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 357 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 358 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 359 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 350 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 351 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 352 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 353 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 354 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 355 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 356 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 357 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 358 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 359 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 350 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 351 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 352 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 353 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 354 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 355 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 356 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 357 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 358 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 359 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 350 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 351 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 352 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 353 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 354 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 355 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 356 - Invalid */
+    { ARG_COUNT(sys_mmap_args), "MMAP", (sys_call_t *)sys_mmap, SYSCALL_VALID },   /* 477 - sys_mmap */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 358 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 359 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 350 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 351 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 352 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 353 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 354 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 355 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 356 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 357 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 358 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 359 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 350 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 351 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 352 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 353 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 354 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 355 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 356 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 357 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 358 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 359 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 350 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 351 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 352 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 353 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 354 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 355 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 356 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 357 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 358 - Invalid */
+    { 0, "No Call", sys_invalid, SYSCALL_VALID },                                  /* 359 - Invalid */
 };
 
 int totalCalls = sizeof(systemCalls) / sizeof(struct syscall_entry);
diff --git a/sys/vmm/paging.c b/sys/vmm/paging.c
index f2f5097..a639704 100644
--- a/sys/vmm/paging.c
+++ b/sys/vmm/paging.c
@@ -545,7 +545,8 @@
   if (uap->fd == -1) {
     //td->td_retval[0] = (int) vmm_getFreeVirtualPage( _current->id, uap->len / 0x1000, VM_TASK );
     //td->td_retval[0] = (int)
-    return (vmm_getFreeVirtualPage(_current->id, round_page( uap->len ) / 0x1000, VM_THRD));
+    td->td_retval[0] = vmm_getFreeVirtualPage(_current->id, round_page( uap->len ) / 0x1000, VM_THRD);
+    return (0x0); //vmm_getFreeVirtualPage(_current->id, round_page( uap->len ) / 0x1000, VM_THRD));
   }
   else {
     kprintf("uap->flags: [0x%X]\n", uap->flags);
diff --git a/sys/vmm/vmm_mmap.c b/sys/vmm/vmm_mmap.c
index e8f8456..170c687 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, _current->id ) == 0x0 )
+      if ( vmm_remapPage( vmm_findFreePage( _current->id ), i, PAGE_DEFAULT, _current->id ) == 0x0 )
         K_PANIC( "remap Failed" );
     }
     kprintf( "td->vm_dsize should be adjust but isn't" );