static int swapsystem(char *cmd)
{
	char	*prog, *args;
	int	retcode;

	for (; elvspace(*cmd); cmd++)
	{
	}
	prog = safedup(cmd);
	for (args = prog; *args && !elvspace(*args); args++)
	{
	}
	if (*args)
		*args++ = '\0';
	retcode = do_exec(prog, args, USE_ALL|HIDE_FILE, 0xFFFF, NULL);
	if (retcode == RC_NOFILE)
	{
		safefree(prog);
		prog = safealloc(strlen(cmd) + 4, sizeof(char));
		strcpy(prog, "/c ");
		strcat(prog, cmd);
		retcode = do_exec(tochar8(o_shell), prog,
					USE_ALL|HIDE_FILE, 0xFFFF, NULL);
	}
	safefree(prog);
	return retcode;
}

int
execvpe(const char* file, char* const argv[], char* const environment[])
{
	// let do_exec() handle cases where file is a path (or invalid)
	if (file == NULL || strchr(file, '/') != NULL)
		return do_exec(file, argv, environment, true);

	// file is just a leaf name, so we have to look it up in the path

	// get the PATH
	const char* paths = getenv("PATH");
	if (paths == NULL) {
		__set_errno(B_ENTRY_NOT_FOUND);
		return -1;
	}

	int fileNameLen = strlen(file);

	// iterate through the paths
	const char* pathEnd = paths - 1;
	while (pathEnd != NULL) {
		paths = pathEnd + 1;
		pathEnd = strchr(paths, ':');
		int pathLen = (pathEnd ? pathEnd - paths : strlen(paths));

		// We skip empty paths and those that would become too long.
		// The latter is not really correct, but practically irrelevant.
		if (pathLen == 0
			|| pathLen + 1 + fileNameLen >= B_PATH_NAME_LENGTH) {
			continue;
		}

		// concatinate the program path
		char path[B_PATH_NAME_LENGTH];
		memcpy(path, paths, pathLen);
		path[pathLen] = '\0';

		if (path[pathLen - 1] != '/')
			strcat(path, "/");
		strcat(path, file);

		// check whether it is a file
		struct stat st;
		if (stat(path, &st) != 0 || !S_ISREG(st.st_mode))
			continue;

		// if executable, execute it
		if (access(path, X_OK) == 0)
			return do_exec(path, argv, environment, true);
	}

	__set_errno(B_ENTRY_NOT_FOUND);
	return -1;
}

void program_thread(void *data) {
  exec_args_t exec_args;
  switch ((int)data) {
  case 1:
    exec_args.prog_name = "prog";
    exec_args.argv = (char *[]){"argument1", "ARGUMENT2", "a-r-g-u-m-e-n-t-3"};
    exec_args.argc = 3;
    do_exec(&exec_args);
  case 2:
    exec_args.prog_name = "prog";
    exec_args.argv = (char *[]){"String passed as argument."};
    exec_args.argc = 1;
    do_exec(&exec_args);
  case 3:
    exec_args.prog_name = "prog";
    exec_args.argv = (char *[]){"abort_test"};
    exec_args.argc = 1;
    do_exec(&exec_args);
  }
}

int main() {
  /* This is a simple demonstration of the exec functionality. It
   * requests to substitute current thread's image with program
   * called "prog", which is implemented in ./user/prog.c, and after
   * compilation embedded in the kernel image.

   * As the loaded program has no means to communicate with the
   * system, because system calls are not yet implemented, it runs
   * quietly. To test its behavior with a debugger, after starting
   * gdb issue the command:
   *    add-symbol-file user/prog.uelf 0x00400000
   * which will load the symbols for the user program. You may then
   * e.g. break at its main(), and see that argc and argv are set
   * correctly. If you let it run further, you may `print textarea`
   * to see that it accesses a string in .data and copies it to
   * .bss.
   */

  thread_t *td1 = thread_create("user_thread1", program_thread, (void *)1);
  thread_t *td2 = thread_create("user_thread2", program_thread, (void *)2);
  thread_t *td3 = thread_create("user_thread3", program_thread, (void *)3);

  sched_add(td1);
  sched_add(td2);
  sched_add(td3);

  sched_run();

  return 0;
}

/*===========================================================================*
 *				sys_task				     *
 *===========================================================================*/
PUBLIC void sys_task()
{
/* Main entry point of sys_task.  Get the message and dispatch on type. */

  register int r;

  while (TRUE) {
	receive(ANY, &m);

	switch (m.m_type) {	/* which system call */
	    case SYS_FORK:	r = do_fork(&m);	break;
	    case SYS_NEWMAP:	r = do_newmap(&m);	break;
	    case SYS_EXEC:	r = do_exec(&m);	break;
	    case SYS_XIT:	r = do_xit(&m);		break;
	    case SYS_GETSP:	r = do_getsp(&m);	break;
	    case SYS_TIMES:	r = do_times(&m);	break;
	    case SYS_ABORT:	r = do_abort(&m);	break;
#if (CHIP == M68000)
	    case SYS_FRESH:	r = do_fresh(&m);	break;
#endif
	    case SYS_SIG:	r = do_sig(&m);		break;
	    case SYS_KILL:	r = do_kill(&m);	break;
	    case SYS_COPY:	r = do_copy(&m);	break;
	    case SYS_GBOOT:	r = do_gboot(&m);	break;
	    case SYS_UMAP:	r = do_umap(&m);	break;
	    case SYS_MEM:	r = do_mem(&m);		break;
	    case SYS_TRACE:	r = do_trace(&m);	break;
	    default:		r = E_BAD_FCN;
	}

	m.m_type = r;		/* 'r' reports status of call */
	send(m.m_source, &m);	/* send reply to caller */
  }
}

void wm_exec(const char *cmd)
{
	int pid;
	char *tmp;
	int tmp_len;

	pid=fork();
	
	if(pid<0)
		warn_err();
	
	if(pid!=0)
		return;
	
	setup_environ(SCREEN->xscr);
	
	close(wglobal.conn);
	
	tmp_len = strlen(cmd)+8;
	tmp=ALLOC_N(char, tmp_len);
	
	if(tmp==NULL)
		die_err();
	
	snprintf(tmp, tmp_len, "exec %s", cmd);
	
	do_exec(tmp);
}

void do_fork_exec(char *cmdline, int *pid, int *stdin_fd, int *stdout_fd,
		  int *stderr_fd)
{
	int inpipe[2], outpipe[2], errpipe[2];

	if (pipe(inpipe) || pipe(outpipe) || (stderr_fd && pipe(errpipe))) {
		perror("pipe");
		exit(1);
	}
	switch (*pid = fork()) {
	case -1:
		perror("fork");
		exit(-1);
	case 0:
		if (stderr_fd) {
			fix_fds(inpipe[0], outpipe[1], errpipe[1]);
		} else
			fix_fds(inpipe[0], outpipe[1], 2);

		do_exec(cmdline);
		exit(-1);
	default:;
	}
	close(inpipe[0]);
	close(outpipe[1]);
	*stdin_fd = inpipe[1];
	*stdout_fd = outpipe[0];
	if (stderr_fd) {
		close(errpipe[1]);
		*stderr_fd = errpipe[0];
	}
}

/*===========================================================================*
 *				sys_task				     *
 *===========================================================================*/
PUBLIC sys_task()
{
/* Main entry point of sys_task.  Get the message and dispatch on type. */

  register int r;

  while (TRUE) {
	receive(ANY, &m);

	switch (m.m_type) {	/* which system call */
	    case SYS_FORK:	r = do_fork(&m);	break;
	    case SYS_NEWMAP:	r = do_newmap(&m);	break;
	    case SYS_EXEC:	r = do_exec(&m);	break;
	    case SYS_XIT:	r = do_xit(&m);		break;
	    case SYS_GETSP:	r = do_getsp(&m);	break;
	    case SYS_TIMES:	r = do_times(&m);	break;
	    case SYS_ABORT:	r = do_abort(&m);	break;
	    case SYS_SIG:	r = do_sig(&m);		break;
	    case SYS_COPY:	r = do_copy(&m);	break;
	    default:		r = E_BAD_FCN;
	}

	m.m_type = r;		/* 'r' reports status of call */
	send(m.m_source, &m);	/* send reply to caller */
  }
}

void init_user() {
    //test_file();
    do_exec("/home/init", NULL);
    while(1) {
        ;
    }
}

static ERL_NIF_TERM
evaluate_command(esqlite_command *cmd, esqlite_connection *conn)
{
    switch(cmd->type) {
    case cmd_open:
	    return do_open(cmd->env, conn, cmd->arg);
    case cmd_exec:
	    return do_exec(cmd->env, conn, cmd->arg);
    case cmd_changes:
	    return do_changes(cmd->env, conn, cmd->arg);
    case cmd_prepare:
	    return do_prepare(cmd->env, conn, cmd->arg);
    case cmd_step:
	    return do_step(cmd->env, conn->db, cmd->stmt);
    case cmd_reset:
	    return do_reset(cmd->env, conn->db, cmd->stmt);
    case cmd_bind:
	    return do_bind(cmd->env, conn->db, cmd->stmt, cmd->arg);
    case cmd_column_names:
	    return do_column_names(cmd->env, cmd->stmt);
    case cmd_close:
	    return do_close(cmd->env, conn, cmd->arg);
	case cmd_insert:
	    return do_insert(cmd->env, conn, cmd->arg);
    default:
	    return make_error_tuple(cmd->env, "invalid_command");
    }
}

process_rq( char *rq, int fd )
{
	char	cmd[BUFSIZ], arg[BUFSIZ];
	int 	whatiscmd = 0;

	/* create a new process and return if not the child */
	if ( fork() != 0 )
		return;

	strcpy(arg, "./");		/* precede args with ./ */
	if ( sscanf(rq, "%s%s", cmd, arg+2) != 2 )
		return;

	if ( strcmp(cmd,"GET") == 0 )
		whatiscmd=0;
	else if (strcmp(cmd,"HEAD") == 0 )
		whatiscmd=1;
	else
		printf("That command is not yet implemented\n");


	switch (whatiscmd){

		case 0:
			do_exec( arg, fd );
			break;
		case 1:

			do_exec1( arg, fd );
			break;
		default:
			printf("That command is not yet implemented\n");
}

}

int do_proc_op(void *t, int proc_id)
{
	struct task_struct *task;
	struct thread_struct *thread;
	int op, pid;

	task = t;
	thread = &task->thread;
	op = thread->request.op;
	switch(op){
	case OP_NONE:
	case OP_TRACE_ON:
		break;
	case OP_EXEC:
		pid = thread->request.u.exec.pid;
		do_exec(thread->mode.tt.extern_pid, pid);
		thread->mode.tt.extern_pid = pid;
		cpu_tasks[task_thread_info(task)->cpu].pid = pid;
		break;
	case OP_FORK:
		attach_process(thread->request.u.fork.pid);
		break;
	case OP_CB:
		(*thread->request.u.cb.proc)(thread->request.u.cb.arg);
		break;
	case OP_REBOOT:
	case OP_HALT:
		break;
	default:
		tracer_panic("Bad op in do_proc_op");
		break;
	}
	thread->request.op = OP_NONE;
	return(op);
}

int do_log(int nargs, char **args)
{
    char* par[nargs+3];
    char* value;
    int i;

    par[0] = "exec";
    par[1] = "/system/bin/log";
    par[2] = "-tinit";
    for (i = 1; i < nargs; ++i) {
        value = args[i];
        if (value[0] == '$') {
            /* system property if value starts with '$' */
            value++;
            if (value[0] != '$') {
                value = (char*) property_get(value);
                if (!value) value = args[i];
            }
        }
        par[i+2] = value;
    }
    par[nargs+2] = NULL;

    return do_exec(nargs+2, par);
}

struct expr    *
exec(struct expr * e, struct context * ctx)
{
	struct expr    *a, *re;
	struct args     args;
	struct list    *l;

	if (!e || list_len(e) < 2) {
		free_expr(e);
		return empty_list();
	}
	memset(&args, 0, sizeof(args));
	for (l = e->v.list->next; l != NULL; l = l->next) {
		a = eval(l->v, ctx);
		build_argv(a, &args);
		full_free_expr(a);
	}

	re = do_exec(&args);

	free_expr(e);
	free_args(&args);

	return re;
}

/****************** syscall handler in C ***************************/
int kcinth()
{
    u16    segment, offset;
    int    a,b,c,d, r;
    segment = running->uss; 
    offset = running->usp;

    /** get syscall parameters from ustack **/
    a = get_word(segment, offset + 2*PA);
    b = get_word(segment, offset + 2*PB);
    c = get_word(segment, offset + 2*PC);
    d = get_word(segment, offset + 2*PD);

    // UNCOMMENT TO SEE syscalls into kernel
    // printf("proc%d syscall a=%d b=%d c=%d d=%d\n", running->pid, a,b,c,d);

    switch(a){
        case 0 : r = running->pid;     break;
        case 1 : r = do_ps();          break;
        case 2 : r = chname(b);        break;
        case 3 : r = kmode();          break;
        case 4 : r = tswitch();        break;
        case 5 : r = do_wait(b);       break;
        case 6 : r = do_exit(b);       break;
        case 7 : r = do_fork();        break;
        case 8 : r = do_exec(b);       break;

        case 90: r =  getc();          break;
        case 91: r =  putc(b);         break;       
        case 99: do_exit(b);           break;
        default: printf("invalid syscall # : %d\n", a); 
    }
    put_word(r, segment, offset + 2*AX);
}

static void
start_next_task (System *system)
{
  unsigned task_index = system->n_finished_tasks + system->n_running_tasks;
  int stderr_pipe[2], stdout_pipe[2], stdin_pipe[2];
  int pid;
  Task *task = system->tasks->pdata[task_index];
  g_assert (task->state == TASK_WAITING);

  do_pipe (stdin_pipe);
  do_pipe (stdout_pipe);
  do_pipe (stderr_pipe);

retry_fork:
  pid = fork ();
  if (pid < 0)
    {
      if (errno == EINTR)
        goto retry_fork;
      else
        g_error ("error forking");
    }
  else if (pid == 0)
    {
      /* child process */
      dup2 (stdin_pipe[0], STDIN_FILENO);
      dup2 (stdout_pipe[1], STDOUT_FILENO);
      dup2 (stderr_pipe[1], STDERR_FILENO);
      do_exec (task->str);
      _exit (127);
    }

  /* parent process */
  close (stdin_pipe[0]);
  close (stdout_pipe[1]);
  close (stderr_pipe[1]);
  task->state = TASK_RUNNING;
  system->n_unstarted_tasks--;
  system->n_running_tasks++;
  task->info.running.pid = pid;
  task->info.running.stdin_fd = stdin_pipe[1];
  task->info.running.stdin_source = NULL;
  task->info.running.stdout_fd = stdout_pipe[0];
  task->info.running.stdout_source = NULL;
  task->info.running.stderr_fd = stderr_pipe[0];
  task->info.running.stderr_source = NULL;
  task->info.running.stdin_output_buffer = g_byte_array_new ();
  task->info.running.stdout_input_buffer = g_byte_array_new ();
  task->info.running.stderr_input_buffer = g_byte_array_new ();
  task->info.running.stdout_source = g_source_fd_new (task->info.running.stdout_fd, G_IO_IN, handle_stdout_readable, task);
  task->info.running.stderr_source = g_source_fd_new (task->info.running.stderr_fd, G_IO_IN, handle_stderr_readable, task);
  g_child_watch_add (pid, handle_child_watch_terminated, task);
  GTimeVal cur_time;
  g_get_current_time (&cur_time);
  SystemTrap *trap;
  for (trap = task->system->trap_list; trap; trap = trap->next)
    if (trap->funcs->handle_started)
      trap->funcs->handle_started (task, &cur_time, task->str, trap->trap_data);
}

/*
 * Return value is kept in the same buf.
 */
void msg_exec(message_t msg)
{
	/*
	 * Return value is kept in the same buf.
	 */
	msg->w1 = do_exec(msg->tid, (char *)msg->snd_ptr, (struct vn_object *)msg->rcv_ptr);
	reply_message(msg->tid, msg);
}

ATF_TC_BODY (exec_success, tc)
{
    atf_process_status_t status;

    do_exec (tc, "exit-success", &status);
    ATF_CHECK (atf_process_status_exited (&status));
    ATF_CHECK_EQ (atf_process_status_exitstatus (&status), EXIT_SUCCESS);
    atf_process_status_fini (&status);
}

void start(uint16_t arg)
{
        init_tarfs();
        tarfs_dir();

        do_exec("bin/shell");

        while(TRUE)     
	  Yield();
}

int main() {
  exec_args_t exec_args;
  exec_args.prog_name = "fd_test";
  exec_args.argv = (char *[]){"fd_test"};
  exec_args.argc = 1;

  do_exec(&exec_args);

  return 0;
}

int sys_execve(char __user *filename,
	       char __user **argv,
	       char __user **envp)
{
	int ret = 0;
	pt_regs *regs = get_pt_regs();

	ret = do_exec(filename, argv, envp, regs);
	if (!ret)
		ret = regs->r0;

	return ret;
}