diff --git a/bin/shell/exec.c b/bin/shell/exec.c
index 13acd4f..fd80db5 100644
--- a/bin/shell/exec.c
+++ b/bin/shell/exec.c
@@ -34,8 +34,9 @@
 
   int boo = 0x0;
 
-static char *argv_init[2] = { "/bin/cat", NULL, }; // ARGV For Initial Proccess
-static char *envp_init[8] = { "HOME=/", "PWD=/", "PATH=/bin:/sbin:/usr/bin:/usr/sbin", "USER=root", "GROUP=admin", "LD_DEBUG=all", "LD_LIBRARY_PATH=/lib", NULL, }; //ENVP For Initial Proccess
+static char *argv_init[2] = { "/bin/sh", NULL, }; // ARGV For Initial Proccess
+//static char *envp_init[12] = { "HOST=MrOlsen.uBixOS.com", "TERM=xterm", "SHELL=/bin/sh", "HOME=/", "PWD=/", "PATH=/bin:/sbin:/usr/bin:/usr/sbin", "USER=root", "LOGNAME=root", "GROUP=admin", "LD_DEBUG=all", "LD_LIBRARY_PATH=/lib", NULL, }; //ENVP For Initial Proccess
+static char *envp_init[11] = { "HOST=MrOlsen.uBixOS.com", "TERM=xterm", "SHELL=/bin/sh", "HOME=/", "PWD=/", "PATH=/bin:/sbin:/usr/bin:/usr/sbin", "USER=root", "LOGNAME=root", "GROUP=admin", "LD_LIBRARY_PATH=/lib", NULL, }; //ENVP For Initial Proccess
 
 
 void execProgram(inputBuffer *data) {
diff --git a/bin/shell/main.c b/bin/shell/main.c
index 4155073..4eb2957 100644
--- a/bin/shell/main.c
+++ b/bin/shell/main.c
@@ -45,6 +45,7 @@
   __asm __volatile("movl %%gs:0, %0" : "=r" (segbase));
 
   printf("Segbase: 0x%X - 0x%X\n", segbase, &segbase);
+  printf("Segbase[0]: 0x%X\n", segbase[0]);
   */
 
   for (int i=0;i < argc; i++)
diff --git a/sys/fs/vfs/stat.c b/sys/fs/vfs/stat.c
index 94714d5..7f8c570 100644
--- a/sys/fs/vfs/stat.c
+++ b/sys/fs/vfs/stat.c
@@ -33,7 +33,7 @@
 #include <lib/kprintf.h>
 #include <sys/descrip.h>
 
-int sys_stat(char *path, struct stat *sb, int flags) {
+int _sys_stat(char *path, struct stat *sb, int flags) {
   int error = 0;
   //struct inode *inode;
 
@@ -182,7 +182,11 @@
 
 /* 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);
+  td->td_retval[0] = _sys_stat(args->path, args->sb, STAT_LSTAT);
   return(0x0);
 }
 
+int sys_stat(struct thread *td, struct sys_stat_args *args) {
+  td->td_retval[0] = _sys_stat(args->path, args->ub, STAT_LSTAT);
+  return(0x0);
+}
diff --git a/sys/i386/fork.c b/sys/i386/fork.c
index 1b090e2..93b2d89 100644
--- a/sys/i386/fork.c
+++ b/sys/i386/fork.c
@@ -50,6 +50,12 @@
   /* Set CWD */
   memcpy(newProcess->oInfo.cwd, _current->oInfo.cwd, 1024);
 
+  /* Set PPID */
+  newProcess->ppid = _current->id;
+
+  /* Set PGRP */
+  newProcess->pgrp = _current->pgrp;
+
   /* Set Up Task State */
   newProcess->tss.eip = td->frame->tf_eip;
   newProcess->oInfo.vmStart = _current->oInfo.vmStart;
@@ -101,7 +107,8 @@
 
   /* Return Id of Proccess */
   kprintf("Returning! [%i][0x%X]\n", _current->id, newProcess->tss.cr3);
-  return (newProcess->id);
+  td->td_retval[0] = newProcess->id;
+  return (0);
 
 }
 
diff --git a/sys/i386/i386_exec.c b/sys/i386/i386_exec.c
index 2435a45..2a78116 100644
--- a/sys/i386/i386_exec.c
+++ b/sys/i386/i386_exec.c
@@ -399,13 +399,13 @@
   newProcess->tss.ss = 0x30 + 3;
   newProcess->tss.ds = 0x30 + 3;
   newProcess->tss.fs = 0x30 + 3;
-  newProcess->tss.gs = 0x50 + 3; //0x30 + 3;
+  newProcess->tss.gs = 0x8 + 3 + 4;//0x50 + 3; //0x30 + 3;
 
   newProcess->tss.ldt = 0x18;
   newProcess->tss.trace_bitmap = 0x0000;
   newProcess->tss.io_map = 0x8000;
 
-  sched_setStatus(newProcess->id, READY);
+  //sched_setStatus(newProcess->id, READY);
 
   kfree(binaryHeader);
   kfree(programHeader);
@@ -441,6 +441,27 @@
   }
   tmp[i + x] = 0x0;
 
+  /* Build LDT For GS and FS */
+  if (vmm_remapPage(vmm_findFreePage(newProcess->id), 0x400000, PAGE_DEFAULT, newProcess->id) == 0x0) {
+    K_PANIC("Error: Remap Page Failed");
+  }
+
+  struct gdtDescriptor *taskLDT = 0x400000;
+
+  struct gdtDescriptor *tmpDesc = 0x0;
+
+  tmpDesc = 0x400000 + sizeof(struct gdtDescriptor);//taskLDT[1];
+  uint32_t data_addr = 0x0;
+
+  tmpDesc->limitLow = (0xFFFFF & 0xFFFF);
+  tmpDesc->baseLow = (data_addr & 0xFFFF);
+  tmpDesc->baseMed = ((data_addr >> 16) & 0xFF);
+  tmpDesc->access = ((dData + dWrite + dBig + dBiglim + dDpl3) + dPresent) >> 8;
+  tmpDesc->limitHigh = (0xFFFFF >> 16);
+  tmpDesc->granularity = ((dData + dWrite + dBig + dBiglim + dDpl3) & 0xFF) >> 4;
+  tmpDesc->baseHigh = data_addr >> 24;
+
+
   /* Switch Back To The Kernels VM Space */
   asm volatile(
     "movl %0,%%eax          \n"
@@ -464,6 +485,10 @@
   int i = 0x0;
   int x = 0x0;
 
+  kprintf("EXEVE: %s(%i)", file, _current->id);
+  if (_current->id == 10)
+    asm("nop");
+
   int argc = argv_count(argv);
   int envc = envp_count(envp);
 
@@ -600,7 +625,7 @@
             K_PANIC("Error: Remap Page Failed");
           }
            else {
-           kprintf("rP[0x%X]", (programHeader[i].p_vaddr & 0xFFFFF000) + x);
+           //MrOlsen 2018-01-15 kprintf("rP[0x%X]", (programHeader[i].p_vaddr & 0xFFFFF000) + x);
            }
 
           memset((void *) ((programHeader[i].p_vaddr & 0xFFFFF000) + x), 0x0, 0x1000);
@@ -786,9 +811,15 @@
   tmp[i++] = 14;
   tmp[i++] = 0x0;
 
-  tmp[i++] = 15;
+  tmp[i++] = 15; //EXEC PATH
   tmp[i++] = EXECP;
 
+  tmp[i++] = 19; //NCPUS
+  tmp[i++] = 0x1;
+ 
+  tmp[i++] = 23; //STACKPROT
+  tmp[i++] = 0x3;
+
   tmp[i++] = 0;
   tmp[i++] = 0;
 
@@ -831,17 +862,18 @@
     K_PANIC("Error: Remap Page Failed");
   }
 
-  union descriptorTableUnion *taskLDT = 0x400000;
-  struct gdtDescriptor *tmpDesc;
+  struct gdtDescriptor *taskLDT = 0x400000;
 
-  tmpDesc = taskLDT[1];
+  struct gdtDescriptor *tmpDesc = 0x0;
+
+  tmpDesc = 0x400000 + sizeof(struct gdtDescriptor);//taskLDT[1];
 
   tmpDesc->limitLow = (0xFFFFF & 0xFFFF);
   tmpDesc->baseLow = (data_addr & 0xFFFF);
   tmpDesc->baseMed = ((data_addr >> 16) & 0xFF);
-  tmpDesc->access = ((dData + dWrite + dBig + dBiglim) + dPresent) >> 8;
+  tmpDesc->access = ((dData + dWrite + dBig + dBiglim + dDpl3) + dPresent) >> 8;
   tmpDesc->limitHigh = (0xFFFFF >> 16);
-  tmpDesc->granularity = ((dData + dWrite + dBig + dBiglim) & 0xFF) >> 4;
+  tmpDesc->granularity = ((dData + dWrite + dBig + dBiglim + dDpl3) & 0xFF) >> 4;
   tmpDesc->baseHigh = data_addr >> 24;
 
   _current->tss.gs = 0xF; //Select 0x8 + Ring 3 + LDT
diff --git a/sys/i386/syscall.c b/sys/i386/syscall.c
index e26a9ad..960a1c2 100644
--- a/sys/i386/syscall.c
+++ b/sys/i386/syscall.c
@@ -157,14 +157,14 @@
 
 int sys_getcwd(struct thread *td, struct sys_getcwd_args *args) {
   char *buf = (char *) args->buf;
-  kprintf("GETCWD: [%s][0x%X]\n", _current->oInfo.cwd, args->buf);
+  //kprintf("GETCWD: [%s][0x%X]\n", _current->oInfo.cwd, args->buf);
   if (args->buf) {
     sprintf(buf, "%s", _current->oInfo.cwd);
     buf[strlen(_current->oInfo.cwd)] = '\0';
     //MrOlsen (2018-01-01) - Why is sprintf not null terminating
   }
-  kprintf("GETCWD: [%s][0x%X]\n", _current->oInfo.cwd, args->buf);
-  kprintf("[%s]", args->buf);
+ // kprintf("GETCWD: [%s][0x%X]\n", _current->oInfo.cwd, args->buf);
+ // kprintf("[%s]", args->buf);
   return (0);
 }
 
diff --git a/sys/include/sys/ioctl.h b/sys/include/sys/ioctl.h
new file mode 100644
index 0000000..38233e0
--- /dev/null
+++ b/sys/include/sys/ioctl.h
@@ -0,0 +1,47 @@
+/*
+ * Ioctl's have the command encoded in the lower word, and the size of
+ * any in or out parameters in the upper word.  The high 3 bits of the
+ * upper word are used to encode the in/out status of the parameter.
+ */
+#define IOCPARM_SHIFT   13              /* number of bits for ioctl size */
+#define IOCPARM_MASK    ((1 << IOCPARM_SHIFT) - 1) /* parameter length mask */
+#define IOCPARM_LEN(x)  (((x) >> 16) & IOCPARM_MASK)
+#define IOCBASECMD(x)   ((x) & ~(IOCPARM_MASK << 16))
+#define IOCGROUP(x)     (((x) >> 8) & 0xff)
+
+#define IOCPARM_MAX     (1 << IOCPARM_SHIFT) /* max size of ioctl */
+#define IOC_VOID        0x20000000      /* no parameters */
+#define IOC_OUT         0x40000000      /* copy out parameters */
+#define IOC_IN          0x80000000      /* copy in parameters */
+#define IOC_INOUT       (IOC_IN|IOC_OUT)
+#define IOC_DIRMASK     (IOC_VOID|IOC_OUT|IOC_IN)
+
+#define _IOC(inout,group,num,len)       ((unsigned long) \
+        ((inout) | (((len) & IOCPARM_MASK) << 16) | ((group) << 8) | (num)))
+#define _IO(g,n)        _IOC(IOC_VOID,  (g), (n), 0)
+#define _IOWINT(g,n)    _IOC(IOC_VOID,  (g), (n), sizeof(int))
+#define _IOR(g,n,t)     _IOC(IOC_OUT,   (g), (n), sizeof(t))
+#define _IOW(g,n,t)     _IOC(IOC_IN,    (g), (n), sizeof(t))
+/* this should be _IORW, but stdio got there first */
+#define _IOWR(g,n,t)    _IOC(IOC_INOUT, (g), (n), sizeof(t))
+
+
+#define IOCPARM_IVAL(x) ((int)(intptr_t)(void *)*(caddr_t *)(void *)(x))
+
+#define NCCS 20
+
+typedef unsigned int        tcflag_t;
+typedef unsigned char       cc_t;
+typedef unsigned int        speed_t;
+
+struct termios {
+        tcflag_t        c_iflag;        /* input flags */
+        tcflag_t        c_oflag;        /* output flags */
+        tcflag_t        c_cflag;        /* control flags */
+        tcflag_t        c_lflag;        /* local flags */
+        cc_t            c_cc[NCCS];     /* control chars */
+        speed_t         c_ispeed;       /* input speed */
+        speed_t         c_ospeed;       /* output speed */
+};
+
+#define       TIOCGETA        _IOR('t', 19, struct termios) /* get termios struct */
diff --git a/sys/include/sys/signal.h b/sys/include/sys/signal.h
index 22ccfd5..eaa3d9e 100644
--- a/sys/include/sys/signal.h
+++ b/sys/include/sys/signal.h
@@ -38,10 +38,29 @@
 #define _SIG_BIT(sig)   (1 << (_SIG_IDX(sig) & 31))
 #define _SIG_VALID(sig) ((sig) <= _SIG_MAXSIG && (sig) > 0)
 
+// Flags for sigprocmask:
+#define SIG_BLOCK       1       /* block specified signal set */
+#define SIG_UNBLOCK     2       /* unblock specified signal set */
+#define SIG_SETMASK     3       /* set specified signal set */
+
 typedef struct __sigset {
         __uint32_t __bits[_SIG_WORDS];
   } __sigset_t;
 
 typedef __sigset_t sigset_t;
 
+// Signal vector "template" used in sigaction call.
+struct sigaction {
+        union {
+                void    (*__sa_handler)(int);
+                void    (*__sa_sigaction)(int, struct __siginfo *, void *);
+        } __sigaction_u;                /* signal handler */
+        int     sa_flags;               /* see signal options below */
+        sigset_t sa_mask;               /* signal mask to apply */
+};
+
+#define sa_handler      __sigaction_u.__sa_handler
+#define sa_sigaction    __sigaction_u.__sa_sigaction
+
+
 #endif /* END _SYS_SIGNAL_H */
diff --git a/sys/include/sys/sysproto.h b/sys/include/sys/sysproto.h
index fb8b554..e90f829 100644
--- a/sys/include/sys/sysproto.h
+++ b/sys/include/sys/sysproto.h
@@ -360,6 +360,11 @@
         char pos_l_[PADL_(off_t)]; off_t pos; char pos_r_[PADR_(off_t)];
 };
 
+struct sys_stat_args {
+        char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)];
+        char ub_l_[PADL_(struct stat *)]; struct stat * ub; char ub_r_[PADR_(struct stat *)];
+};
+
 struct sys_lstat_args {
     char path_l_[PADL_(char *)];
     char *path;
@@ -458,6 +463,58 @@
         char mode_l_[PADL_(__mode_t)]; __mode_t mode; char mode_r_[PADR_(__mode_t)];
 };
 
+struct sys_sysarch_args {
+        char op_l_[PADL_(int)]; int op; char op_r_[PADR_(int)];
+        char parms_l_[PADL_(char *)]; char * parms; char parms_r_[PADR_(char *)];
+};
+
+struct sys_getpid_args {
+        register_t dummy;
+};
+
+struct sys_ioctl_args {
+        char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)];
+        char com_l_[PADL_(u_long)]; u_long com; char com_r_[PADR_(u_long)];
+        char data_l_[PADL_(caddr_t)]; caddr_t data; char data_r_[PADR_(caddr_t)];
+};
+
+struct sys_geteuid_args {
+        register_t dummy;
+};
+
+struct sys_getppid_args {
+        register_t dummy;
+};
+
+struct sys_getegid_args {
+        register_t dummy;
+};
+
+struct sys_sigprocmask_args {
+        char how_l_[PADL_(int)]; int how; char how_r_[PADR_(int)];
+        char set_l_[PADL_(const sigset_t *)]; const sigset_t * set; char set_r_[PADR_(const sigset_t *)];
+        char oset_l_[PADL_(sigset_t *)]; sigset_t * oset; char oset_r_[PADR_(sigset_t *)];
+};
+
+struct sys_sigaction_args {
+        char sig_l_[PADL_(int)]; int sig; char sig_r_[PADR_(int)];
+        char act_l_[PADL_(const struct sigaction *)]; const struct sigaction * act; char act_r_[PADR_(const struct sigaction *)];
+        char oact_l_[PADL_(struct sigaction *)]; struct sigaction * oact; char oact_r_[PADR_(struct sigaction *)];
+};
+
+struct sys_getpgrp_args {
+        register_t dummy;
+};
+struct sys_setpgid_args {
+        char pid_l_[PADL_(int)]; int pid; char pid_r_[PADR_(int)];
+        char pgid_l_[PADL_(int)]; int pgid; char pgid_r_[PADR_(int)];
+};
+
+struct sys_access_args {
+        char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)];
+        char amode_l_[PADL_(int)]; int amode; char amode_r_[PADR_(int)];
+};
+
 
 //Func Defs
 int sys_invalid(struct thread *, void *);
@@ -499,10 +556,31 @@
 int mprotect(struct thread *td, struct mprotect_args *uap);
 
 int sys_fstatfs(struct thread *td, struct sys_fstatfs_args *);
+int sys_stat(struct thread *td, struct sys_stat_args *);
 int sys_lstat(struct thread *td, struct sys_lstat_args *);
 int sys_fstat(struct thread *td, struct sys_fstat_args *);
 int sys_openat(struct thread *td, struct sys_openat_args *);
 
+int sys_sysarch(struct thread *td, struct sys_sysarch_args *);
+int sys_getpid(struct thread *td, struct sys_getpid_args *);
+int sys_ioctl(struct thread *td, struct sys_ioctl_args *);
+
+int sys_geteuid(struct thread *td, struct sys_geteuid_args *);
+
+int sys_getegid(struct thread *td, struct sys_getegid_args *);
+
+int sys_getppid(struct thread *td, struct sys_getppid_args *);
+
+int sys_getpgrp(struct thread *td, struct sys_getpgrp_args *);
+int sys_setpgrp(struct thread *td, struct sys_setpgid_args *);
+
+int sys_sigprocmask(struct thread *td, struct sys_sigprocmask_args *);
+int sys_sigaction(struct thread *td, struct sys_sigaction_args *);
+
+int sys_getpgrp(struct thread *td, struct sys_getpgrp_args *);
+int sys_setpgid(struct thread *td, struct sys_setpgid_args *);
+
+int sys_access(struct thread *td, struct sys_access_args *);
 #endif
 
 /***
diff --git a/sys/include/sys/thread.h b/sys/include/sys/thread.h
index 84b474d..23b5d1f 100644
--- a/sys/include/sys/thread.h
+++ b/sys/include/sys/thread.h
@@ -31,6 +31,7 @@
 
 #include <sys/types.h>
 #include <sys/trap.h>
+#include <sys/signal.h>
 
 #define O_FILES 64
 
@@ -43,6 +44,8 @@
     u_long vm_tsize;
     struct trapframe *frame;
     int abi;
+    sigset_t sigmask;
+    struct  sigaction sigact[128];
 };
 
 #endif /* END _SYS_THREAD_H */
diff --git a/sys/include/ubixos/ld.h b/sys/include/ubixos/ld.h
index 0dbb7a9..2790ec4 100644
--- a/sys/include/ubixos/ld.h
+++ b/sys/include/ubixos/ld.h
@@ -31,7 +31,7 @@
 
 #include <sys/types.h>
 
-#define LD_START 0x1000000
+#define LD_START 0xAAA00000 //0x1000000
 
 uInt32 ldEnable();
 
diff --git a/sys/include/ubixos/sched.h b/sys/include/ubixos/sched.h
index e49721e..3c1b18f 100644
--- a/sys/include/ubixos/sched.h
+++ b/sys/include/ubixos/sched.h
@@ -78,6 +78,8 @@
     } inodes;
     uint32_t counter;
     uint16_t groups[NR_GROUPS];
+    pidType ppid;
+    uint32_t pgrp;
 } kTask_t;
 
 int sched_init();
diff --git a/sys/kernel/execve.c b/sys/kernel/execve.c
index ced8d21..1b05c00 100644
--- a/sys/kernel/execve.c
+++ b/sys/kernel/execve.c
@@ -32,6 +32,6 @@
 
 int sys_execve( struct thread *td, struct sys_execve_args *args ) {
   int ret = sys_exec( td, args->fname, args->argv, args->envp );
-  kprintf("RETURNING: [%i]\n", ret);
+  td->td_retval[0] = ret;
   return (ret);
 }
diff --git a/sys/kernel/gen_calls.c b/sys/kernel/gen_calls.c
index a992b21..b812633 100644
--- a/sys/kernel/gen_calls.c
+++ b/sys/kernel/gen_calls.c
@@ -28,6 +28,7 @@
 
 #include <sys/gen_calls.h>
 #include <sys/thread.h>
+#include <sys/gdt.h>
 #include <ubixos/sched.h>
 #include <ubixos/endtask.h>
 #include <lib/kprintf.h>
@@ -36,6 +37,7 @@
 #include <assert.h>
 #include <sys/descrip.h>
 #include <sys/video.h>
+#include <sys/signal.h>
 
 /* Exit Syscall */
 int sys_exit( struct thread *td, struct sys_exit_args *args ) {
@@ -134,8 +136,8 @@
 }
 
 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;
+  kprintf( "ISC[%i:%i]", td->frame->tf_eax, _current->id );
+  td->td_retval[0] = -1;
   return (0);
 }
 
@@ -146,3 +148,136 @@
     return (tmpTask->state);
   return (0);
 }
+
+int sys_sysarch( struct thread *td, struct sys_sysarch_args *args ) {
+  void **segbase = 0x0;
+  uint32_t base_addr = 0x0;
+  if (args->op == 10) {
+  kprintf("SETGSBASE: 0x%X:0x%X", args->parms, args->parms[0]);
+   segbase = args->parms;
+   kprintf("SGS: [0x%X:0x%X]", segbase[0], segbase[1]);
+   base_addr = (uint32_t)segbase[0];
+  struct gdtDescriptor *tmpDesc = 0x0;
+
+  tmpDesc = 0x400000 + sizeof(struct gdtDescriptor);//taskLDT[1];
+
+  tmpDesc->limitLow = (0xFFFFF & 0xFFFF);
+  tmpDesc->baseLow = (base_addr & 0xFFFF);
+  tmpDesc->baseMed = ((base_addr >> 16) & 0xFF);
+  tmpDesc->access = ((dData + dWrite + dBig + dBiglim + dDpl3) + dPresent) >> 8;
+  tmpDesc->limitHigh = (0xFFFFF >> 16);
+  tmpDesc->granularity = ((dData + dWrite + dBig + dBiglim + dDpl3) & 0xFF) >> 4;
+  tmpDesc->baseHigh = base_addr >> 24;
+
+  td->td_retval[0] = 0;
+  }
+  else {
+  kprintf("sysarch(%i,NULL)", args->op);
+  td->td_retval[0] = -1;
+  }
+  return(0);
+}
+
+int sys_getpid(struct thread *td, struct sys_getpid_args *args) {
+  td->td_retval[0] = _current->id;
+  return(0);
+}
+int sys_geteuid(struct thread *td, struct sys_geteuid_args *args) {
+  td->td_retval[0] = _current->uid;
+  return(0);
+}
+
+int sys_getegid(struct thread *td, struct sys_getegid_args *args) {
+  td->td_retval[0] = _current->gid;
+  return(0);
+}
+
+int sys_getppid(struct thread *td, struct sys_getppid_args *args) {
+  td->td_retval[0] = _current->ppid;
+  return(0);
+}
+
+int sys_sigprocmask(struct thread *td, struct sys_sigprocmask_args *args) {
+  td->td_retval[0] = -1;
+
+  if (args->oset != 0x0) {
+    memcpy(args->oset, &td->sigmask, sizeof(sigset_t));
+    td->td_retval[0] = 0x0;
+  }
+
+  if (args->set != 0x0) {
+    if (args->how == SIG_SETMASK) {
+      if (args->set != 0x0) {
+        memcpy(&td->sigmask, args->set,  sizeof(sigset_t));
+        td->td_retval[0] = 0;
+      }
+      else {
+        td->td_retval[0] = -1;
+      }
+    }
+    else if (args->how == SIG_BLOCK) {
+      if (args->set != 0x0) {
+        td->sigmask.__bits[0] &= args->set->__bits[0];
+        td->sigmask.__bits[1] &= args->set->__bits[1];
+        td->sigmask.__bits[2] &= args->set->__bits[2];
+        td->sigmask.__bits[3] &= args->set->__bits[3];
+        td->td_retval[0] = 0;
+      }
+      else {
+        td->td_retval[0] = -1;
+      }
+    }
+    else if (args->how == SIG_UNBLOCK) {
+      if (args->set != 0x0) {
+        td->sigmask.__bits[0] |= args->set->__bits[0];
+        td->sigmask.__bits[1] |= args->set->__bits[1];
+        td->sigmask.__bits[2] |= args->set->__bits[2];
+        td->sigmask.__bits[3] |= args->set->__bits[3];
+        td->td_retval[0] = 0;
+      }
+      else {
+        td->td_retval[0] = -1;
+      }
+    }
+    else {
+      kprintf("SPM: 0x%X", args->how);
+      td->td_retval[0] = -1;
+    }
+  }
+
+  return(0);
+}
+
+
+int sys_sigaction(struct thread *td, struct sys_sigaction_args *args) {
+  td->td_retval[0] = -1;
+
+  if (args->oact != 0x0) {
+    memcpy(args->oact, &td->sigact[args->sig], sizeof(struct sigaction));
+    td->td_retval[0] = 0;
+  }
+
+  if (args->act != 0x0) {
+    //kprintf("SA: %i", args->sig);
+    memcpy(&td->sigact[args->sig], args->act, sizeof(struct sigaction));
+    td->td_retval[0] = 0;
+  }
+  return(0);
+}
+
+int sys_getpgrp(struct thread *td, struct sys_getpgrp_args *args) {
+  td->td_retval[0] = _current->pgrp;
+  return(0);
+}
+
+int sys_setpgid(struct thread *td, struct sys_setpgid_args *args) {
+  kTask_t *tmpTask = schedFindTask(args->pid);
+  if (tmpTask == 0x0) {
+    td->td_retval[0] = -1;
+  }
+  else {
+    tmpTask->pgrp = args->pgid;
+    td->td_retval[0] = 0x0;
+  }
+  return(0);
+}
diff --git a/sys/kernel/kern_descrip.c b/sys/kernel/kern_descrip.c
index 69472bd..0580317 100644
--- a/sys/kernel/kern_descrip.c
+++ b/sys/kernel/kern_descrip.c
@@ -33,6 +33,7 @@
 #include <ubixos/endtask.h>
 #include <lib/kmalloc.h>
 #include <assert.h>
+#include <sys/ioctl.h>
 
 static struct file *kern_files = 0x0;
 
@@ -173,7 +174,51 @@
   return (error);
 }
 
-/***
- END
- ***/
+int sys_ioctl(struct thread *td, struct sys_ioctl_args *args) {
+  switch(args->com) {
+    case TIOCGETA:
+      if (args->fd == 0 || args->fd == 1) {
+        struct termios *t = (struct termios *)args->data; 
 
+        t->c_iflag = 0x2B02;
+        t->c_oflag = 0x3;
+        t->c_cflag = 0x4B00;
+        t->c_lflag = 0x5CB;
+
+        t->c_cc[0] = 4;
+        t->c_cc[1] = 255;
+        t->c_cc[2] = 255;
+        t->c_cc[3] = 127;
+        t->c_cc[4] = 23;
+        t->c_cc[5] = 21;
+        t->c_cc[6] = 18;
+        t->c_cc[7] = 8;
+        t->c_cc[8] = 3;
+        t->c_cc[9] = 28;
+        t->c_cc[10] = 26;
+        t->c_cc[11] = 25;
+        t->c_cc[12] = 17;
+        t->c_cc[13] = 19;
+        t->c_cc[14] = 22;
+        t->c_cc[15] = 15;
+        t->c_cc[16] = 1;
+        t->c_cc[17] = 0;
+        t->c_cc[18] = 20;
+        t->c_cc[19] = 255;
+
+        t->c_ispeed = 0x9600;
+        t->c_ospeed = 0x9600;
+
+        td->td_retval[0] = 0;
+      }
+      else {
+        td->td_retval[0] = -1;
+      }
+      break;
+    default:
+      kprintf("ioFD:%i:%i!", args->fd, args->com);
+    break;
+  }
+  td->td_retval[0] = 0x0;
+  return (0x0);
+}
diff --git a/sys/kernel/syscalls.c b/sys/kernel/syscalls.c
index ab9f4e6..0e36407 100644
--- a/sys/kernel/syscalls.c
+++ b/sys/kernel/syscalls.c
@@ -51,30 +51,30 @@
   { 0, "No Call", sys_invalid, SYSCALL_VALID },
   { 0, "No Call", sys_invalid, SYSCALL_VALID },
   { 0, "No Call", sys_invalid, SYSCALL_VALID },
+  { ARG_COUNT(sys_getpid_args), "getpid", sys_getpid, SYSCALL_VALID }, // 20 - getpid
   { 0, "No Call", sys_invalid, SYSCALL_VALID },
   { 0, "No Call", sys_invalid, SYSCALL_VALID },
-  { 0, "No Call", sys_invalid, SYSCALL_VALID },
-  { ARG_COUNT(sys_setUID_args), "Set UID", (sys_call_t *) sys_setUID, SYSCALL_VALID },
+  { ARG_COUNT(sys_setUID_args), "Set UID", (sys_call_t *) sys_setUID, SYSCALL_VALID }, // 23 - setUID
   { 0, "Get UID", sys_getUID, SYSCALL_VALID },
+  { ARG_COUNT(sys_geteuid_args), "geteuid", sys_geteuid, SYSCALL_VALID }, // 25 - getuid
   { 0, "No Call", sys_invalid, SYSCALL_VALID },
   { 0, "No Call", sys_invalid, SYSCALL_VALID },
   { 0, "No Call", sys_invalid, SYSCALL_VALID },
   { 0, "No Call", sys_invalid, SYSCALL_VALID },
   { 0, "No Call", sys_invalid, SYSCALL_VALID },
+  { 0, "No Call", sys_invalid, SYSCALL_VALID }, // 31
+  { 0, "No Call", sys_invalid, SYSCALL_VALID }, // 32
+  { ARG_COUNT(sys_access_args), "access", sys_access, SYSCALL_VALID }, // 33 - access
   { 0, "No Call", sys_invalid, SYSCALL_VALID },
   { 0, "No Call", sys_invalid, SYSCALL_VALID },
   { 0, "No Call", sys_invalid, SYSCALL_VALID },
   { 0, "No Call", sys_invalid, SYSCALL_VALID },
   { 0, "No Call", sys_invalid, SYSCALL_VALID },
+  { ARG_COUNT(sys_getppid_args), "getpid", sys_getpid, SYSCALL_VALID }, // 39 - getppid
   { 0, "No Call", sys_invalid, SYSCALL_VALID },
   { 0, "No Call", sys_invalid, SYSCALL_VALID },
   { 0, "No Call", sys_invalid, SYSCALL_VALID },
-  { 0, "No Call", sys_invalid, SYSCALL_VALID },
-  { 0, "No Call", sys_invalid, SYSCALL_VALID },
-  { 0, "No Call", sys_invalid, SYSCALL_VALID },
-  { 0, "No Call", sys_invalid, SYSCALL_VALID },
-  { 0, "No Call", sys_invalid, SYSCALL_VALID },
-  { 0, "No Call", sys_invalid, SYSCALL_VALID },
+  { ARG_COUNT(sys_getegid_args), "getegid", sys_getegid, SYSCALL_VALID }, // 43 - getegid
   { 0, "No Call", sys_invalid, SYSCALL_VALID },
   { 0, "No Call", sys_invalid, SYSCALL_VALID },
   { 0, "No Call", sys_invalid, SYSCALL_VALID },
@@ -85,12 +85,12 @@
   { 0, "No Call", sys_invalid, SYSCALL_VALID },
   { 0, "No Call", sys_invalid, SYSCALL_VALID },
   { 0, "No Call", sys_invalid, SYSCALL_VALID },
+  { ARG_COUNT(sys_ioctl_args), "ioctl", sys_ioctl, SYSCALL_VALID }, // 54 - ioctl
   { 0, "No Call", sys_invalid, SYSCALL_VALID },
   { 0, "No Call", sys_invalid, SYSCALL_VALID },
   { 0, "No Call", sys_invalid, SYSCALL_VALID },
   { 0, "No Call", sys_invalid, SYSCALL_VALID },
-  { 0, "No Call", sys_invalid, SYSCALL_VALID },
-  { ARG_COUNT(sys_execve_args), "Exec VE", (sys_call_t *) sys_execve, SYSCALL_DUMMY },
+  { ARG_COUNT(sys_execve_args), "execve", (sys_call_t *) sys_execve, SYSCALL_VALID },
   { 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 */
@@ -112,8 +112,8 @@
   { 0, "No Call", sys_invalid, SYSCALL_VALID }, /*  78 - Invalid */
   { 0, "No Call", sys_invalid, SYSCALL_VALID }, /*  79 - Invalid */
   { 0, "No Call", sys_invalid, SYSCALL_VALID }, /*  80 - Invalid */
-  { 0, "No Call", sys_invalid, SYSCALL_VALID }, /*  81 - Invalid */
-  { 0, "No Call", sys_invalid, SYSCALL_VALID }, /*  82 - Invalid */
+  { ARG_COUNT(sys_getpgrp_args), "getpgrp", sys_getpgrp, SYSCALL_VALID }, //  81 - getpgrp
+  { ARG_COUNT(sys_setpgid_args), "setpgid", sys_setpgid, SYSCALL_VALID }, //  82 - setpgid 
   { 0, "No Call", sys_invalid, SYSCALL_VALID }, /*  83 - Invalid */
   { 0, "No Call", sys_invalid, SYSCALL_VALID }, /*  84 - Invalid */
   { 0, "No Call", sys_invalid, SYSCALL_VALID }, /*  85 - Invalid */
@@ -196,7 +196,7 @@
   { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 162 - Invalid */
   { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 163 - Invalid */
   { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 164 - Invalid */
-  { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 165 - Invalid */
+  { ARG_COUNT(sys_sysarch_args), "sysarch", sys_sysarch, SYSCALL_VALID }, /* 165 - sysarch */
   { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 166 - Invalid */
   { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 167 - Invalid */
   { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 168 - Invalid */
@@ -219,7 +219,7 @@
   { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 185 - Invalid */
   { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 186 - Invalid */
   { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 187 - Invalid */
-  { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 188 - Invalid */
+  { ARG_COUNT(sys_stat_args), "FSTAT", (sys_call_t *) sys_stat, SYSCALL_VALID }, /* 188 - sys_stat */
   { ARG_COUNT(sys_fstat_args), "FSTAT", (sys_call_t *) sys_fstat, SYSCALL_VALID }, /* 189 - sys_fstat */
   { 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 */
@@ -371,7 +371,7 @@
   { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 337 - Invalid */
   { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 338 - Invalid */
   { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 339 - Invalid */
-  { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 340 - Invalid */
+  { ARG_COUNT(sys_sigprocmask_args), "sigprocmask", sys_sigprocmask, SYSCALL_VALID }, // 340 - sigprocmask
   { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 341 - Invalid */
   { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 342 - Invalid */
   { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 343 - Invalid */
@@ -447,7 +447,7 @@
   { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 413 - Invalid */
   { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 414 - Invalid */
   { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 415 - Invalid */
-  { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 416 - Invalid */
+  { ARG_COUNT(sys_sigaction_args), "sigaction", sys_sigaction, SYSCALL_VALID }, // 416 - sigaction
   { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 417 - Invalid */
   { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 418 - Invalid */
   { 0, "No Call", sys_invalid, SYSCALL_VALID }, /* 419 - Invalid */
diff --git a/sys/kernel/vfs_calls.c b/sys/kernel/vfs_calls.c
index 6fcbc6f..9f4daf8 100644
--- a/sys/kernel/vfs_calls.c
+++ b/sys/kernel/vfs_calls.c
@@ -26,6 +26,7 @@
  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
+#include <ubixos/sched.h>
 #include <sys/thread.h>
 #include <sys/sysproto.h>
 #include <sys/descrip.h>
@@ -77,7 +78,9 @@
 }
 
 int sys_read(struct thread *td, struct sys_read_args *args) {
-  char *buf = args->buf;
+  int x = 0;
+  char c = 0x0;
+  volatile char *buf = args->buf;
 
   struct file *fd = 0x0;
 
@@ -87,13 +90,33 @@
     td->td_retval[0] = fread(args->buf, args->nbyte, 1, fd->fd);
   }
   else {
-    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");
+   if ( _current->term == tty_foreground )
+     c = getchar();
+
+    for (x = 0; x < args->nbyte && c != '\n';) {
+      if ( _current->term == tty_foreground ) {
+
+        if ( c != 0x0 )
+          buf[x++] = c;
+
+        if ( c == '\n') {
+          buf[x++] = c;
+          break;
+        }
+
+        sched_yield();
+        c = getchar();
+      }
+      else {
+        sched_yield();
+      }
+    }
+    if ( c == '\n')
+      buf[x++] = '\n';
+
+    kprintf("READ: %i", x);
+
+    td->td_retval[0] = x;
   }
   return (0);
 }
@@ -128,3 +151,9 @@
   }
   return (0x0);
 }
+
+int sys_access(struct thread *td, struct sys_access_args *args) {
+  kprintf("%s:%i", args->path, args->amode);
+  td->td_retval[0] = 0;
+  return(0);
+}
diff --git a/sys/vmm/getfreevirtualpage.c b/sys/vmm/getfreevirtualpage.c
index 98a5fe5..743a7f7 100644
--- a/sys/vmm/getfreevirtualpage.c
+++ b/sys/vmm/getfreevirtualpage.c
@@ -87,6 +87,7 @@
     /* Locate Initial Page Table */
     pdI = ((start_page + (counter * 0x1000)) / 0x400000);
 
+    keepMapping:
       //kprintf("PAGE IS");
     /* If Page Directory Is Not Yet Allocated Allocate It */
     if ((pageDir[pdI] & PAGE_PRESENT) != PAGE_PRESENT) {
@@ -127,7 +128,6 @@
     }
 //kprintf("HERE?");
 
-    keepMapping:
     ptI = ((start_page - (pdI * 0x400000)) / 0x1000);
 
     for (y = ptI; y < 1024 && counter < count; y++) {
@@ -146,12 +146,12 @@
         K_PANIC("UHM HOW DO WE HAVE AN ALLOCATED PAGE HERE!!\n");
       }
 
-      kprintf("[0x%X:%i:%i:%i]", ((pdI * (1024 * 4096)) + (y * 4096)), y, counter, count);
+      //kprintf("[0x%X:%i:%i:%i]", ((pdI * (1024 * 4096)) + (y * 4096)), y, counter, count);
       counter++;
 
     }
     if (counter < count) {
-      kprintf("Need More Pages!");
+      //kprintf("Need More Pages!");
       start_page += (0x1000 * counter);
       pdI = ((start_page + (counter * 0x1000)) / 0x400000);
       goto keepMapping;
@@ -163,7 +163,7 @@
     //kprintf( "vm_dsize: [0x%X]][0x%X]\n", ctob( _current->td.vm_dsize ), _current->td.vm_dsize );
   }
   else if (type == VM_TASK)
-    _current->oInfo.vmStart += count * 0x1000;
+    _current->oInfo.vmStart += (count * 0x1000);
 
   /*
    * MMAP Return
diff --git a/sys/vmm/vmm_mmap.c b/sys/vmm/vmm_mmap.c
index 9db382a..6250713 100644
--- a/sys/vmm/vmm_mmap.c
+++ b/sys/vmm/vmm_mmap.c
@@ -166,7 +166,6 @@
 
   addr = (vm_offset_t) uap->addr;
 
-
   if (uap->fd == -1) {
     if (uap->addr != 0x0) {
       for (x = 0x0; x < round_page(uap->len); x += 0x1000) {
@@ -177,24 +176,21 @@
 
       }
       tmp = uap->addr;
-      kprintf("mm1: 0x%X\n", uap->len);
       bzero(tmp, uap->len);
       td->td_retval[0] = (uint32_t)tmp;
       return (0x0);
     }
-    //td->td_retval[0] = (int) vmm_getFreeVirtualPage( _current->id, uap->len / 0x1000, VM_TASK );
-    //td->td_retval[0] = (int)
+
     td->td_retval[0] = vmm_getFreeVirtualPage(_current->id, round_page( uap->len ) / 0x1000, VM_TASK);
-    kprintf("mm2: 0x%X-0x%X\n", td->td_retval[0], round_page(uap->len) / 0x1000);
     //bzero(td->td_retval[0], uap->len);
     return (0x0); //vmm_getFreeVirtualPage(_current->id, round_page( uap->len ) / 0x1000, VM_THRD));
   }
   else {
     //kprintf("uap->flags: [0x%X]\n", uap->flags);
-    kprintf("uap->addr:  [0x%X]", uap->addr);
-    kprintf("uap->len:   [0x%X]", uap->len);
+    //MrOlsenkprintf("uap->addr:  [0x%X]", uap->addr);
+    //MrOlsenkprintf("uap->len:   [0x%X]", uap->len);
     //kprintf("uap->prot:  [0x%X]", uap->prot);
-    kprintf("uap->fd:    [%i]\n", uap->fd);
+    //MrOlsenkprintf("uap->fd:    [%i]\n", uap->fd);
     //kprintf("uap->pad:   [0x%X]", uap->pad);
     //kprintf("uap->pos:   [0x%X]", uap->pos);
     getfd(td, &fd, uap->fd);
@@ -212,7 +208,7 @@
 
  }
     fseek(fd->fd, uap->pos, 0x0);
-    kprintf("FREAD: 0x%X\n", fread(tmp, uap->len, 0x1, fd->fd));
+    fread(tmp, uap->len, 0x1, fd->fd);
     td->td_retval[0] = (uint32_t) tmp;
     if (td->td_retval[0] == (caddr_t)-1)
       kpanic("BALLS");