diff --git a/sys/kernel/gen_calls.c b/sys/kernel/gen_calls.c
index b63488c..7508cfa 100644
--- a/sys/kernel/gen_calls.c
+++ b/sys/kernel/gen_calls.c
@@ -43,9 +43,9 @@
 
 /* Exit Syscall */
 int sys_exit(struct thread *td, struct sys_exit_args *args) {
-  //kprintf("exit(%i)", args->status);
-  endTask(_current->id);
-  return (0x0);
+    //kprintf("exit(%i)", args->status);
+    endTask(_current->id);
+    return (0x0);
 }
 
 /* return the process id */
@@ -53,8 +53,8 @@
 #ifdef DEBUG
   kprintf("[%s:%i]",__FILE__,__LINE__);
 #endif
-  td->td_retval[0] = _current->id;
-  return (0);
+    td->td_retval[0] = _current->id;
+    return (0);
 }
 
 /* return the process user id */
@@ -62,8 +62,8 @@
 #ifdef DEBUG
   kprintf("[%s:%i]",__FILE__,__LINE__);
 #endif
-  td->td_retval[0] = _current->uid;
-  return (0);
+    td->td_retval[0] = _current->uid;
+    return (0);
 }
 
 /* return the process group id */
@@ -71,452 +71,455 @@
 #ifdef DEBUG
   kprintf("[%s:%i]",__FILE__,__LINE__);
 #endif
-  td->td_retval[0] = _current->gid;
-  return (0);
+    td->td_retval[0] = _current->gid;
+    return (0);
 }
 
 int sys_issetugid(register struct thread *td, struct sys_issetugid_args *uap) {
-  td->td_retval[0] = 0;
-  return (0);
+    td->td_retval[0] = 0;
+    return (0);
 }
 
 int readlink(struct thread *td, struct readlink_args *uap) {
 #ifdef DEBUG
   kprintf("[%s:%i]",__FILE__,__LINE__);
 #endif
-  kprintf("readlink: [%s:%i]\n", uap->path, uap->count);
-  td->td_retval[0] = -1;
-  td->td_retval[1] = 0x0;
-  return (0x0);
+    kprintf("readlink: [%s:%i]\n", uap->path, uap->count);
+    td->td_retval[0] = -1;
+    td->td_retval[1] = 0x0;
+    return (0x0);
 }
 
 int gettimeofday_new(struct thread *td, struct gettimeofday_args *uap) {
 #ifdef DEBUG
   kprintf("[%s:%i]",__FILE__,__LINE__);
 #endif
-  return (0x0);
+    return (0x0);
 }
 
 int read(struct thread *td, struct read_args *uap) {
-  int error = 0x0;
-  size_t count = 0x0;
-  struct file *fd = 0x0;
+    int error = 0x0;
+    size_t count = 0x0;
+    struct file *fd = 0x0;
 
 #ifdef DEBUG
   kprintf("[%s:%i]",__FILE__,__LINE__);
 #endif
 
-  error = getfd(td, &fd, uap->fd);
+    error = getfd(td, &fd, uap->fd);
 
-  if (error)
+    if (error)
+        return (error);
+
+    count = fread(uap->buf, uap->nbyte, 0x1, fd->fd);
+    kprintf("count: %i\n", count);
+    td->td_retval[0] = count;
+
     return (error);
-
-  count = fread(uap->buf, uap->nbyte, 0x1, fd->fd);
-  kprintf("count: %i\n", count);
-  td->td_retval[0] = count;
-
-  return (error);
 }
 
 /*!
  * \brief place holder for now functionality to be added later
  */
 int setitimer(struct thread *td, struct setitimer_args *uap) {
-  int error = 0x0;
+    int error = 0x0;
 
-  return (error);
+    return (error);
 }
 
 int access(struct thread *td, struct access_args *uap) {
-  int error = 0x0;
-  kprintf("name: [%s]\n", uap->path);
-  return (error);
+    int error = 0x0;
+    kprintf("name: [%s]\n", uap->path);
+    return (error);
 }
 
 int mprotect(struct thread *td, struct mprotect_args *uap) {
-  int error = 0x0;
-  return (error);
+    int error = 0x0;
+    return (error);
 }
 
 int sys_invalid(struct thread *td, void *args) {
-  kprintf("ISC[%i:%i]", td->frame->tf_eax, _current->id);
-  td->td_retval[0] = -1;
-  return (0);
+    kprintf("ISC[%i:%i]", td->frame->tf_eax, _current->id);
+    td->td_retval[0] = -1;
+    return (0);
 }
 
 int sys_wait4(struct thread *td, struct sys_wait4_args *args) {
-  int error = 0;
+    int error = 0;
 
-  if (args->pid == -1) {
-    if (_current->children <= 0) {
-      td->td_retval[0] = ECHILD;
-      return (-1);
-    }
+    if (args->pid == -1) {
+        if (_current->children <= 0) {
+            td->td_retval[0] = ECHILD;
+            return (-1);
+        }
 
-    int children = _current->children;
+        int children = _current->children;
 
-    sched_setStatus(_current->id, WAIT);
-    while (_current->children == children) {
-      sched_yield();
-    }
+        sched_setStatus(_current->id, WAIT);
+        while (_current->children == children) {
+            sched_yield();
+        }
 
-    td->td_retval[0] = _current->last_exit;
-    td->td_retval[1] = 0x8;
-  }
-  else {
-
-    kTask_t *tmpTask = schedFindTask(args->pid);
-
-    if (tmpTask != 0x0) {
-      sched_setStatus(_current->id, WAIT);
-      while (tmpTask != 0x0) {
-        sched_yield();
-        tmpTask = schedFindTask(args->pid);
-      }
-      td->td_retval[0] = args->pid;
+        td->td_retval[0] = _current->last_exit;
+        td->td_retval[1] = 0x8;
     }
     else {
-      td->td_retval[0] = -1;
-      error = -1;
+
+        kTask_t *tmpTask = schedFindTask(args->pid);
+
+        if (tmpTask != 0x0) {
+            sched_setStatus(_current->id, WAIT);
+            while (tmpTask != 0x0) {
+                sched_yield();
+                tmpTask = schedFindTask(args->pid);
+            }
+            td->td_retval[0] = args->pid;
+        }
+        else {
+            td->td_retval[0] = -1;
+            error = -1;
+        }
     }
-  }
-  return (error);
+    return (error);
 }
 
 int sys_sysarch(struct thread *td, struct sys_sysarch_args *args) {
 
-  void **segbase = 0x0;
-  uint32_t base_addr = 0x0;
-  if (args->op == 10) {
+    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;
+
+        segbase = args->parms;
+
         kprintf("SGS: [0x%X:0x%X]", segbase[0], segbase[1]);
-    base_addr = (uint32_t) segbase[0];
+        base_addr = (uint32_t) segbase[0];
 
-    struct gdtDescriptor *tmpDesc = 0x0;
+        struct gdtDescriptor *tmpDesc = 0x0;
 
-        tmpDesc = VMM_USER_LDT;  //XXX Is this my problem? + sizeof(struct gdtDescriptor); //taskLDT[1];
+        tmpDesc = VMM_USER_LDT + 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;
+        tmpDesc->limitLow = 0xFFFF;  //(0xFFFFF & 0xFFFF);
+        tmpDesc->limitHigh = 0xF;  //(0xFFFFF >> 16);
+        tmpDesc->baseLow = (base_addr & 0xFFFF);
+        tmpDesc->baseMed = ((base_addr >> 16) & 0xFF);
+        tmpDesc->access = ((dData + dWrite + dBig + dBiglim + dDpl3) + dPresent) >> 8;
+        tmpDesc->granularity = ((dData + dWrite + dBig + dBiglim + dDpl3) & 0xFF) >> 4;
+        tmpDesc->baseHigh = base_addr >> 24;
 
-    asm(
-        "push %eax\n"
-        "mov $0x18,%ax\n"
-        "lldt %ax\n" /* "lgdtl (loadGDT)\n" */
-        "mov $0xF,%eax\n"
-        "mov %eax,%gs\n"
-        "pop %eax\n"
-    );
+        asm(
+            "push %eax\n"
+            "mov $0x18,%ax\n"
+            "lldt %ax\n" /* "lgdtl (loadGDT)\n" */
+            "mov $0xF,%eax\n"
+            "mov %eax,%gs\n"
+            "pop %eax\n"
+        );
 
-    td->td_retval[0] = 0;
-  }
-  else {
-    kprintf("sysarch(%i,NULL)", args->op);
-    td->td_retval[0] = -1;
-  }
-  return (0);
+        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);
+    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);
+    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);
+    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);
+    td->td_retval[0] = _current->ppid;
+    return (0);
 }
 
 int sys_sigprocmask(struct thread *td, struct sys_sigprocmask_args *args) {
-  td->td_retval[0] = -1;
+    td->td_retval[0] = -1;
 
-  if (args->oset != 0x0) {
-    memcpy(args->oset, &td->sigmask, sizeof(sigset_t));
-    td->td_retval[0] = 0x0;
-  }
+    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;
-      }
+    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;
+        }
     }
-    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);
+    return (0);
 }
 
 int sys_sigaction(struct thread *td, struct sys_sigaction_args *args) {
-  td->td_retval[0] = -1;
+    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->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);
+    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);
+    td->td_retval[0] = _current->pgrp;
+    return (0);
 }
 
 int sys_setpgid(struct thread *td, struct sys_setpgid_args *args) {
-  pidType pid = 0x0;
-  pidType pgrp = 0x0;
+    pidType pid = 0x0;
+    pidType pgrp = 0x0;
 
-  if (args->pid == 0x0 || args->pid == _current->id) {
-    if (args->pgid == 0x0 || args->pgid == _current->id) {
-      td->td_retval[0] = 0x0;
-      _current->pgrp = _current->id;
+    if (args->pid == 0x0 || args->pid == _current->id) {
+        if (args->pgid == 0x0 || args->pgid == _current->id) {
+            td->td_retval[0] = 0x0;
+            _current->pgrp = _current->id;
+        }
+        else {
+            td->td_retval[0] = -1;
+        }
     }
     else {
-      td->td_retval[0] = -1;
-    }
-  }
-  else {
-    kTask_t *tmpTask = schedFindTask(pid);
+        kTask_t *tmpTask = schedFindTask(pid);
 
-    if (tmpTask == 0x0) {
-      td->td_retval[0] = -1;
-    }
-    else {
+        if (tmpTask == 0x0) {
+            td->td_retval[0] = -1;
+        }
+        else {
 
-      /* Get The PRGP We Want To Set */
-      pgrp = (args->pgid == 0) ? tmpTask->pgrp : args->pgid;
+            /* Get The PRGP We Want To Set */
+            pgrp = (args->pgid == 0) ? tmpTask->pgrp : args->pgid;
 
-      if (pgrp != _current->pgrp || pgrp != tmpTask->id) {
-        td->td_retval[0] = -1;
-      }
-      else {
-        td->td_retval[0] = 0x0;
-        tmpTask->pgrp = pgrp;
-      }
+            if (pgrp != _current->pgrp || pgrp != tmpTask->id) {
+                td->td_retval[0] = -1;
+            }
+            else {
+                td->td_retval[0] = 0x0;
+                tmpTask->pgrp = pgrp;
+            }
+
+        }
 
     }
 
-  }
-
-  return (0);
+    return (0);
 }
 
 int sys_gettimeofday(struct thread *td, struct sys_gettimeofday_args *args) {
-  gettimeofday(args->tp, args->tzp);
-  td->td_retval[0] = 0;
-  return (0);
+    gettimeofday(args->tp, args->tzp);
+    td->td_retval[0] = 0;
+    return (0);
 }
 
 int sys_getlogin(struct thread *thr, struct sys_getlogin_args *args) {
-  int error = 0;
+    int error = 0;
 
-  memcpy(args->namebuf, _current->username, args->namelen);
+    memcpy(args->namebuf, _current->username, args->namelen);
 
-  return (error);
+    return (error);
 }
 
 int sys_setlogin(struct thread *thr, struct sys_setlogin_args *args) {
-  int error = 0;
+    int error = 0;
 
-  memcpy(_current->username, args->namebuf, 256);
+    memcpy(_current->username, args->namebuf, 256);
 
-  return (error);
+    return (error);
 }
 
 int sys_getrlimit(struct thread *thr, struct sys_getrlimit_args *args) {
-  int error = 0;
+    int error = 0;
 
-  struct rlimit *rlim = 0x0;
+    struct rlimit *rlim = 0x0;
 
-  switch (args->which) {
-  case 0:
-    args->rlp->rlim_cur = thr->rlim[args->which].rlim_cur;
-    args->rlp->rlim_max = thr->rlim[args->which].rlim_max;
-    break;
-  case 1:
-    args->rlp->rlim_cur = thr->rlim[args->which].rlim_cur;
-    args->rlp->rlim_max = thr->rlim[args->which].rlim_max;
-    break;
-  case 2:
-    args->rlp->rlim_cur = thr->rlim[args->which].rlim_cur;
-    args->rlp->rlim_max = thr->rlim[args->which].rlim_max;
-    break;
-  case 3:
-    args->rlp->rlim_cur = thr->rlim[args->which].rlim_cur;
-    args->rlp->rlim_max = thr->rlim[args->which].rlim_max;
-    break;
-  case 4:
-    args->rlp->rlim_cur = thr->rlim[args->which].rlim_cur;
-    args->rlp->rlim_max = thr->rlim[args->which].rlim_max;
-    break;
-  case 5:
-    args->rlp->rlim_cur = thr->rlim[args->which].rlim_cur;
-    args->rlp->rlim_max = thr->rlim[args->which].rlim_max;
-    break;
-  case 6:
-    args->rlp->rlim_cur = thr->rlim[args->which].rlim_cur;
-    args->rlp->rlim_max = thr->rlim[args->which].rlim_max;
-    break;
-  case 7:
-    args->rlp->rlim_cur = thr->rlim[args->which].rlim_cur;
-    args->rlp->rlim_max = thr->rlim[args->which].rlim_max;
-    break;
-  case 8:
-    args->rlp->rlim_cur = thr->rlim[args->which].rlim_cur;
-    args->rlp->rlim_max = thr->rlim[args->which].rlim_max;
-    break;
-  case 9:
-    args->rlp->rlim_cur = thr->rlim[args->which].rlim_cur;
-    args->rlp->rlim_max = thr->rlim[args->which].rlim_max;
-    break;
-  case 10:
-    args->rlp->rlim_cur = thr->rlim[args->which].rlim_cur;
-    args->rlp->rlim_max = thr->rlim[args->which].rlim_max;
-    break;
-  case 11:
-    args->rlp->rlim_cur = thr->rlim[args->which].rlim_cur;
-    args->rlp->rlim_max = thr->rlim[args->which].rlim_max;
-    break;
-  case 12:
-    args->rlp->rlim_cur = thr->rlim[args->which].rlim_cur;
-    args->rlp->rlim_max = thr->rlim[args->which].rlim_max;
-    break;
-  case 13:
-    args->rlp->rlim_cur = thr->rlim[args->which].rlim_cur;
-    args->rlp->rlim_max = thr->rlim[args->which].rlim_max;
-    break;
-  case 14:
-    args->rlp->rlim_cur = thr->rlim[args->which].rlim_cur;
-    args->rlp->rlim_max = thr->rlim[args->which].rlim_max;
-    break;
-  default:
-    error = -1;
-    kprintf("[getrlimit: %i]", args->which);
-  }
+    switch (args->which) {
+        case 0:
+            args->rlp->rlim_cur = thr->rlim[args->which].rlim_cur;
+            args->rlp->rlim_max = thr->rlim[args->which].rlim_max;
+            break;
+        case 1:
+            args->rlp->rlim_cur = thr->rlim[args->which].rlim_cur;
+            args->rlp->rlim_max = thr->rlim[args->which].rlim_max;
+            break;
+        case 2:
+            args->rlp->rlim_cur = thr->rlim[args->which].rlim_cur;
+            args->rlp->rlim_max = thr->rlim[args->which].rlim_max;
+            break;
+        case 3:
+            args->rlp->rlim_cur = thr->rlim[args->which].rlim_cur;
+            args->rlp->rlim_max = thr->rlim[args->which].rlim_max;
+            break;
+        case 4:
+            args->rlp->rlim_cur = thr->rlim[args->which].rlim_cur;
+            args->rlp->rlim_max = thr->rlim[args->which].rlim_max;
+            break;
+        case 5:
+            args->rlp->rlim_cur = thr->rlim[args->which].rlim_cur;
+            args->rlp->rlim_max = thr->rlim[args->which].rlim_max;
+            break;
+        case 6:
+            args->rlp->rlim_cur = thr->rlim[args->which].rlim_cur;
+            args->rlp->rlim_max = thr->rlim[args->which].rlim_max;
+            break;
+        case 7:
+            args->rlp->rlim_cur = thr->rlim[args->which].rlim_cur;
+            args->rlp->rlim_max = thr->rlim[args->which].rlim_max;
+            break;
+        case 8:
+            args->rlp->rlim_cur = thr->rlim[args->which].rlim_cur;
+            args->rlp->rlim_max = thr->rlim[args->which].rlim_max;
+            break;
+        case 9:
+            args->rlp->rlim_cur = thr->rlim[args->which].rlim_cur;
+            args->rlp->rlim_max = thr->rlim[args->which].rlim_max;
+            break;
+        case 10:
+            args->rlp->rlim_cur = thr->rlim[args->which].rlim_cur;
+            args->rlp->rlim_max = thr->rlim[args->which].rlim_max;
+            break;
+        case 11:
+            args->rlp->rlim_cur = thr->rlim[args->which].rlim_cur;
+            args->rlp->rlim_max = thr->rlim[args->which].rlim_max;
+            break;
+        case 12:
+            args->rlp->rlim_cur = thr->rlim[args->which].rlim_cur;
+            args->rlp->rlim_max = thr->rlim[args->which].rlim_max;
+            break;
+        case 13:
+            args->rlp->rlim_cur = thr->rlim[args->which].rlim_cur;
+            args->rlp->rlim_max = thr->rlim[args->which].rlim_max;
+            break;
+        case 14:
+            args->rlp->rlim_cur = thr->rlim[args->which].rlim_cur;
+            args->rlp->rlim_max = thr->rlim[args->which].rlim_max;
+            break;
+        default:
+            error = -1;
+            kprintf("[getrlimit: %i]", args->which);
+    }
 
-  return (error);
+    return (error);
 }
 
 int sys_setrlimit(struct thread *thr, struct sys_setrlimit_args *args) {
-  int error = 0;
+    int error = 0;
 
-  switch (args->which) {
-  case 0:
-    thr->rlim[args->which].rlim_cur = args->rlp->rlim_cur;
-    thr->rlim[args->which].rlim_max = args->rlp->rlim_max;
-    break;
-  case 1:
-    thr->rlim[args->which].rlim_cur = args->rlp->rlim_cur;
-    thr->rlim[args->which].rlim_max = args->rlp->rlim_max;
-    break;
-  case 2:
-    thr->rlim[args->which].rlim_cur = args->rlp->rlim_cur;
-    thr->rlim[args->which].rlim_max = args->rlp->rlim_max;
-    break;
-  case 3:
-    thr->rlim[args->which].rlim_cur = args->rlp->rlim_cur;
-    thr->rlim[args->which].rlim_max = args->rlp->rlim_max;
-    break;
-  case 4:
-    thr->rlim[args->which].rlim_cur = args->rlp->rlim_cur;
-    thr->rlim[args->which].rlim_max = args->rlp->rlim_max;
-    break;
-  case 5:
-    thr->rlim[args->which].rlim_cur = args->rlp->rlim_cur;
-    thr->rlim[args->which].rlim_max = args->rlp->rlim_max;
-    break;
-  case 6:
-    thr->rlim[args->which].rlim_cur = args->rlp->rlim_cur;
-    thr->rlim[args->which].rlim_max = args->rlp->rlim_max;
-    break;
-  case 7:
-    thr->rlim[args->which].rlim_cur = args->rlp->rlim_cur;
-    thr->rlim[args->which].rlim_max = args->rlp->rlim_max;
-    break;
-  case 8:
-    thr->rlim[args->which].rlim_cur = args->rlp->rlim_cur;
-    thr->rlim[args->which].rlim_max = args->rlp->rlim_max;
-    break;
-  case 9:
-    thr->rlim[args->which].rlim_cur = args->rlp->rlim_cur;
-    thr->rlim[args->which].rlim_max = args->rlp->rlim_max;
-    break;
-  case 10:
-    thr->rlim[args->which].rlim_cur = args->rlp->rlim_cur;
-    thr->rlim[args->which].rlim_max = args->rlp->rlim_max;
-    break;
-  case 11:
-    thr->rlim[args->which].rlim_cur = args->rlp->rlim_cur;
-    thr->rlim[args->which].rlim_max = args->rlp->rlim_max;
-    break;
-  case 12:
-    thr->rlim[args->which].rlim_cur = args->rlp->rlim_cur;
-    thr->rlim[args->which].rlim_max = args->rlp->rlim_max;
-    break;
-  case 13:
-    thr->rlim[args->which].rlim_cur = args->rlp->rlim_cur;
-    thr->rlim[args->which].rlim_max = args->rlp->rlim_max;
-    break;
-  case 14:
-    thr->rlim[args->which].rlim_cur = args->rlp->rlim_cur;
-    thr->rlim[args->which].rlim_max = args->rlp->rlim_max;
-    break;
-  default:
-    error = -1;
-    kprintf("[setrlimit: %i]", args->which);
-  }
+    switch (args->which) {
+        case 0:
+            thr->rlim[args->which].rlim_cur = args->rlp->rlim_cur;
+            thr->rlim[args->which].rlim_max = args->rlp->rlim_max;
+            break;
+        case 1:
+            thr->rlim[args->which].rlim_cur = args->rlp->rlim_cur;
+            thr->rlim[args->which].rlim_max = args->rlp->rlim_max;
+            break;
+        case 2:
+            thr->rlim[args->which].rlim_cur = args->rlp->rlim_cur;
+            thr->rlim[args->which].rlim_max = args->rlp->rlim_max;
+            break;
+        case 3:
+            thr->rlim[args->which].rlim_cur = args->rlp->rlim_cur;
+            thr->rlim[args->which].rlim_max = args->rlp->rlim_max;
+            break;
+        case 4:
+            thr->rlim[args->which].rlim_cur = args->rlp->rlim_cur;
+            thr->rlim[args->which].rlim_max = args->rlp->rlim_max;
+            break;
+        case 5:
+            thr->rlim[args->which].rlim_cur = args->rlp->rlim_cur;
+            thr->rlim[args->which].rlim_max = args->rlp->rlim_max;
+            break;
+        case 6:
+            thr->rlim[args->which].rlim_cur = args->rlp->rlim_cur;
+            thr->rlim[args->which].rlim_max = args->rlp->rlim_max;
+            break;
+        case 7:
+            thr->rlim[args->which].rlim_cur = args->rlp->rlim_cur;
+            thr->rlim[args->which].rlim_max = args->rlp->rlim_max;
+            break;
+        case 8:
+            thr->rlim[args->which].rlim_cur = args->rlp->rlim_cur;
+            thr->rlim[args->which].rlim_max = args->rlp->rlim_max;
+            break;
+        case 9:
+            thr->rlim[args->which].rlim_cur = args->rlp->rlim_cur;
+            thr->rlim[args->which].rlim_max = args->rlp->rlim_max;
+            break;
+        case 10:
+            thr->rlim[args->which].rlim_cur = args->rlp->rlim_cur;
+            thr->rlim[args->which].rlim_max = args->rlp->rlim_max;
+            break;
+        case 11:
+            thr->rlim[args->which].rlim_cur = args->rlp->rlim_cur;
+            thr->rlim[args->which].rlim_max = args->rlp->rlim_max;
+            break;
+        case 12:
+            thr->rlim[args->which].rlim_cur = args->rlp->rlim_cur;
+            thr->rlim[args->which].rlim_max = args->rlp->rlim_max;
+            break;
+        case 13:
+            thr->rlim[args->which].rlim_cur = args->rlp->rlim_cur;
+            thr->rlim[args->which].rlim_max = args->rlp->rlim_max;
+            break;
+        case 14:
+            thr->rlim[args->which].rlim_cur = args->rlp->rlim_cur;
+            thr->rlim[args->which].rlim_max = args->rlp->rlim_max;
+            break;
+        default:
+            error = -1;
+            kprintf("[setrlimit: %i]", args->which);
+    }
 
-  return (error);
+    return (error);
 }