/* Send signal SIG to process number PID.  If PID is zero,
   send SIG to all processes in the current process's process group.
   If PID is < -1, send SIG to all processes in process group - PID.
   If SIG is SIGKILL, kill the process. */
int __kill (int pid, int sig)
{
	struct event_msg local_msg = {0};
	if (pid <= 0) {
		errno = ENOSYS;
		return -1;
	}
	if (sig == SIGKILL)
		return ros_syscall(SYS_proc_destroy, pid, 0, 0, 0, 0, 0);
	local_msg.ev_type = EV_POSIX_SIGNAL;
	local_msg.ev_arg1 = sig;
	return ros_syscall(SYS_notify, pid, EV_POSIX_SIGNAL, &local_msg, 0, 0, 0);
}

/* Yield the processor.  */
int
__sched_yield (void)
{
  /* TRUE tells the kernel we simply want to let someone else process, and not
   * that we are waiting on an event. */
  return ros_syscall(SYS_yield, TRUE, 0, 0, 0, 0, 0);
}

/* Seek to OFFSET on FD, starting from WHENCE.  */
off64_t
__libc_lseek64 (int fd, off64_t offset, int whence)
{
	off64_t retoff = 0;
	off_t hi = 0;
	off_t lo = 0;
	int ret;
	if (fd < 0) {
		__set_errno (EBADF);
		return -1;
	}
	switch (whence) {
		case SEEK_SET:
		case SEEK_CUR:
		case SEEK_END:
			break;
		default:
			__set_errno (EINVAL);
			return -1;
	}
	hi = offset >> 32;
	lo = offset & 0xffffffff;
	ret = ros_syscall(SYS_llseek, fd, hi, lo, &retoff, whence, 0);
	if (ret) {
		assert(ret == -1);	/* catch odd bugs */
		return ret;
	}
	return retoff;
}

ssize_t sys_shared_page_alloc(void** addr, pid_t p2, 
                              int p1_flags, int p2_flags
                             ) 
{
	return ros_syscall(SYS_shared_page_alloc, addr, 
	               p2, p1_flags, p2_flags, 0, 0);
}

/* Get the pathname of the current working directory,
   and put it in SIZE bytes of BUF.  Returns NULL if the
   directory couldn't be determined or SIZE was too small.
   If successful, returns BUF.  In GNU, if BUF is NULL,
   an array is allocated with `malloc'; the array is SIZE
   bytes long, unless SIZE <= 0, in which case it is as
   big as necessary.  */
char *
__getcwd (char *buf, size_t size)
{
  int allocated = 0;
  if(buf == NULL)
  {
    // Linux ABI requires we allocate a buffer if NULL is passed.
    // If size is passed as 0, it means "as big as necessary"
    if(size == 0)
      size = PGSIZE;

    buf = (char*)malloc(size);
    if(buf == NULL)
    {
      errno = ENOMEM;
      return NULL;
    }
    allocated = 1;
  }

  int ret = ros_syscall(SYS_getcwd, buf, size, 0, 0, 0, 0);

  if(ret == -1 && allocated)
  {
    free(buf);
    return NULL;
  }

  return buf;
}

void *timer_thread(void *arg)
{
	while (1) {
		set_posted_interrupt(0xef);
		ros_syscall(SYS_vmm_poke_guest, 0, 0, 0, 0, 0, 0);
		uthread_usleep(100000);
	}
	fprintf(stderr, "SENDING TIMER\n");
}

/* Create a one-way communication channel (__pipe).  If successful,
   two file descriptors are stored in PIPEDES; bytes written on
   PIPEDES[1] can be read from PIPEDES[0].  Apply FLAGS to the new
   file descriptors.  Returns 0 if successful, -1 if not.  */
int __pipe2(int pipedes[2], int flags)
{
	if (pipedes == NULL) {
		__set_errno (EINVAL);
		return -1;
	}

	__set_errno (ENOSYS);
	return ros_syscall(SYS_pipe, pipedes, flags, 0, 0, 0, 0);
}

/* Get file information about FILE in BUF.  */
int
__lxstat (int vers, const char *file, struct stat *buf)
{
  if (vers != _STAT_VER || file == NULL || buf == NULL)
  {
    __set_errno (EINVAL);
    return -1;
  }

  int ret = (int)ros_syscall(SYS_lstat, file, strlen(file), buf, 0, 0, 0);
  return ret;
}

int sys_proc_create(char *path, size_t path_l, char *argv[], char *envp[],
                    int flags)
{
	struct serialized_data *sd = serialize_argv_envp(argv, envp);
	if (!sd) {
		errno = ENOMEM;
		return -1;
	}
	int ret = ros_syscall(SYS_proc_create, path, path_l,
	                      sd->buf, sd->len, flags, 0);
	free_serialized_data(sd);
	return ret;
}

int fcntl(int fd, int cmd, ...)
{
	int ret, arg;
	va_list vl;
	va_start(vl, cmd);
	switch (cmd) {
		case F_GETFL:
			ret = ros_syscall(SYS_fcntl, fd, cmd, 0, 0, 0, 0);
			if (ret != -1)
				ret |= get_nonblock_status(fd);
			break;
		case F_SETFL:
			arg = va_arg(vl, int);
			if ((ret = set_nonblock_status(fd, &arg)))
				return ret;
			ret = ros_syscall(SYS_fcntl, fd, cmd, arg, 0, 0, 0);
			break;
		default:
			ret = __vfcntl(fd, cmd, vl);
	}
	va_end(vl);
	return ret;
}

long int syscall(long int num, ...)
{
	va_list vl;
	va_start(vl, num);
	long int a0 = va_arg(vl, long int);
	long int a1 = va_arg(vl, long int);
	long int a2 = va_arg(vl, long int);
	long int a3 = va_arg(vl, long int);
	long int a4 = va_arg(vl, long int);
	long int a5 = va_arg(vl, long int);
	va_end(vl);
	
	return ros_syscall(num, a0, a1, a2, a3, a4, a5);
}

/* Change the protections of FILE to MODE.  */
int
__chmod (const char* file, mode_t mode)
{
  struct dir dir;
  size_t mlen;
  char mbuf[STATFIXLEN];
  int ret;

  if (file == NULL)
  {
    __set_errno (EINVAL);
    return -1;
  }

  init_empty_dir(&dir);
  dir.mode = mode;
  mlen = convD2M(&dir, mbuf, STATFIXLEN);
  ret = ros_syscall(SYS_wstat, file, strlen(file), mbuf, mlen, WSTAT_MODE, 0);
  return (ret == mlen ? 0 : -1);
}

/* Perform file control operations on FD.  */
int
__fcntl(int fd, int cmd, ...)
{
  va_list vl;
  va_start(vl,cmd);
  int arg = va_arg(vl,int);
  va_end(vl);

  switch(cmd)
  {
    case F_DUPFD:
    case F_GETFD:
    case F_SETFD:
    case F_GETFL:
    case F_SETFL:
      return ros_syscall(SYS_fcntl, fd, cmd, arg, 0, 0, 0);
    default:
      errno = ENOSYS;
      return -1;
  }
}

/* Clone the calling process, creating an exact copy.
   Return -1 for errors, 0 to the new process,
   and the process ID of the new process to the old process.  */
int
__fork ()
{
  int ret = -1;
  __libc_lock_lock(__fork_lock);

  if(child_list_size == child_list_capacity)
  {
    int newcap = child_list_capacity ? 2*child_list_capacity : 1;
    int* tmp = realloc(child_list,newcap*sizeof(int));
    if(!tmp)
      goto out;
    child_list_capacity = newcap;
    child_list = tmp;
  }

  ret = ros_syscall(SYS_fork,0,0,0,0,0);
  if(ret > 0)
    child_list[child_list_size++] = ret;

out:
  __libc_lock_unlock(__fork_lock);
  return ret;
}

/* Write NBYTES of BUF to FD.  Return the number written, or -1.  */
int
__close (int fd)
{
  return ros_syscall(SYS_close,fd,0,0,0,0);
}

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen) {
	return ros_syscall(SYS_accept, sockfd, addr, addrlen, 0, 0, 0);
}

/* Wait for a child matching PID to die.
   If PID is greater than 0, match any process whose process ID is PID.
   If PID is (pid_t) -1, match any process.
   If PID is (pid_t) 0, match any process with the
   same process group as the current process.
   If PID is less than -1, match any process whose
   process group is the absolute value of PID.
   If the WNOHANG bit is set in OPTIONS, and that child
   is not already dead, return (pid_t) 0.  If successful,
   return PID and store the dead child's status in STAT_LOC.
   Return (pid_t) -1 for errors.  If the WUNTRACED bit is set in OPTIONS,
   return status for stopped children; otherwise don't.  */
pid_t __libc_waitpid(pid_t pid, int *stat_loc, int options)
{
	return ros_syscall(SYS_waitpid, pid, stat_loc, options, 0, 0, 0);
}

/* These are the default handlers for each posix signal.  They are listed in
 * SIGNAL(7) of the Linux Programmer's Manual.  We run them as default
 * sigactions, instead of the older handlers, so that we have access to the
 * faulting context.
 *
 * Exit codes are set as suggested in the following link.  I wish I could find
 * the definitive source, but this will have to do for now.
 * http://unix.stackexchange.com/questions/99112/default-exit-code-when-process-is-terminated
 * */
static void default_term_handler(int signr, siginfo_t *info, void *ctx)
{
	ros_syscall(SYS_proc_destroy, __procinfo.pid, signr, 0, 0, 0, 0);
}

/* Write NBYTES of BUF to FD.  Return the number written, or -1.  */
ssize_t
__libc_read (int fd, void *buf, size_t nbytes)
{
  return ros_syscall(SYS_read,fd,buf,nbytes,0,0);
}

void *consin(void *arg)
{
	struct virtio_threadarg *a = arg;
	char *line, *outline;
	static char consline[128];
	static struct scatterlist iov[32];
	static struct scatterlist out[] = { {NULL, sizeof(outline)}, };
	static struct scatterlist in[] = { {NULL, sizeof(line)}, };

	static unsigned int inlen, outlen, conslen;
	struct virtqueue *v = a->arg->virtio;
	fprintf(stderr, "consin thread ..\n");
	uint16_t head, gaveit = 0, gotitback = 0;
	uint32_t vv;
	int i;
	int num;
	//char c[1];

	if (debug) fprintf(stderr, "Spin on console being read, print num queues, halt\n");

	for(num = 0;! quit;num++) {
		//int debug = 1;
		/* host: use any buffers we should have been sent. */
		head = wait_for_vq_desc(v, iov, &outlen, &inlen);
		if (debug)
			fprintf(stderr, "vq desc head %d, gaveit %d gotitback %d\n", head, gaveit, gotitback);
		for(i = 0; debug && i < outlen + inlen; i++)
			fprintf(stderr, "v[%d/%d] v %p len %d\n", i, outlen + inlen, iov[i].v, iov[i].length);
		if (debug)
			fprintf(stderr, "outlen is %d; inlen is %d\n", outlen, inlen);
		/* host: fill in the writeable buffers. */
		for (i = outlen; i < outlen + inlen; i++) {
			/* host: read a line. */
			memset(consline, 0, 128);
			if (read(0, consline, 1) < 0) {
				exit(0);
			}
			if (debug) fprintf(stderr, "CONSIN: GOT A LINE:%s:\n", consline);
			if (debug) fprintf(stderr, "CONSIN: OUTLEN:%d:\n", outlen);
			if (strlen(consline) < 3 && consline[0] == 'q' ) {
				quit = 1;
				break;
			}

			memmove(iov[i].v, consline, strlen(consline)+ 1);
			iov[i].length = strlen(consline) + 1;
		}
		if (debug) fprintf(stderr, "call add_used\n");
		/* host: now ack that we used them all. */
		add_used(v, head, outlen+inlen);
		/* turn off consdata - the IRQ injection isn't right */
		//consdata = 1;
		if (debug) fprintf(stderr, "DONE call add_used\n");

		// Send spurious for testing (Gan)
		set_posted_interrupt(0xE5);
		virtio_mmio_set_vring_irq();

		ros_syscall(SYS_vmm_poke_guest, 0, 0, 0, 0, 0, 0);
	}
	fprintf(stderr, "All done\n");
	return NULL;
}