/*-
 * Copyright (c) 2011 Venkatesh Srinivas <vsrinivas@dragonflybsd.org>  
 * 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.
 */

/*
 * This file contains support for the POSIX 1003.1B AIO/LIO facility.
 *
 * This version of AIO is aimed at standards compliance; it is not aimed
 * at either reasonability or performance. It merely wraps synchronous I/O
 * routines.
 *
 * This version cannot perform asynchronous notification of I/O completion
 * on DragonFly via SIGEV_SIGNAL.
 *
 *    2) SIGEV_SIGNAL code is present, but if-ed out as 'not yet'; Dfly
 *	 does not support sigqueue(), so we cannot control the payload to
 *	 a SIGINFO-signal from userspace. Programs using AIO signals use
 *	 the payload field to carry pointers to the completed AIO structure,
 *	 which is not yet possible here.
 *
 * It would be possible for this version to support SIGEV_KEVENT.
 */

#include <stdlib.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/signal.h>
#include <sys/queue.h>
#include <sys/stat.h>
#include <unistd.h>
#include <errno.h>
#include <sys/aio.h>
#include <pthread.h>

static void 	*_aio_thr_start(void *);

static void
_aio_notify(struct sigevent *sigevp)
{
#if 0 /* not yet */
	int sig;
	union sigval sv;
	pid_t pid;
#endif
	pthread_t thr;

	switch (sigevp->sigev_notify) {
	case SIGEV_NONE:
		return;

	case SIGEV_THREAD:
		pthread_create(&thr, 
			       sigevp->sigev_notify_attributes,
			       _aio_thr_start,
			       sigevp);
		break;

	case SIGEV_SIGNAL:
#if 0 /* not yet */
		pid = getpid();
		sig = sigevp->sigev_signo;
		sv = sigevp->sigev_value;
		sigqueue(pid, sig, sv);
#endif
		break;

	case SIGEV_KEVENT:
		/* not yet */
		break;
	}
}

static void *
_aio_thr_start(void *vsigevp)
{
	struct sigevent *sigevp = vsigevp;
	sigevp->sigev_notify_function(sigevp->sigev_value);
	return (NULL);
}

/*
 * aio_read()
 *
 *	Asynchronously read from a file
 */
int 
aio_read(struct aiocb *ap)
{
#if 0 /* not yet */
	if ((ap->aio_sigevent.sigev_notify != SIGEV_NONE) &&
	    (ap->aio_sigevent.sigev_notify != SIGEV_THREAD))
		return (ENOSYS);
#endif

	ap->_aio_val = pread(ap->aio_fildes, 
			     (void *) ap->aio_buf, 
			     ap->aio_nbytes,
			     ap->aio_offset);
	ap->_aio_err = errno;

	_aio_notify(&ap->aio_sigevent);

	return (0);
}

int 
aio_write(struct aiocb *ap)
{
#if 0 /* not yet */
	if ((ap->aio_sigevent.sigev_notify != SIGEV_NONE) &&
	    (ap->aio_sigevent.sigev_notify != SIGEV_THREAD))
		return (ENOSYS);
#endif

	ap->_aio_val = pwrite(ap->aio_fildes,
			      (void *) ap->aio_buf, 
			      ap->aio_nbytes,
			      ap->aio_offset);
	ap->_aio_err = errno;

	_aio_notify(&ap->aio_sigevent);

	return (0);
}

int
aio_fsync(int op, struct aiocb *ap)
{
#if 0 /* not yet */
	if ((ap->aio_sigevent.sigev_notify != SIGEV_NONE) &&
	    (ap->aio_sigevent.sigev_notify != SIGEV_THREAD))
		return (ENOSYS);
#endif

	ap->_aio_val = fsync(ap->aio_fildes);
	ap->_aio_err = errno;

	_aio_notify(&ap->aio_sigevent);

	return(0);
}

int 
lio_listio(int mode, struct aiocb * __restrict const apv[__restrict_arr],
    int nent, struct sigevent * __restrict sigevp)
{
	int i;

#if 0 /* not yet */
	if (sigevp &&
	    (sigevp->sigev_notify != SIGEV_NONE) &&
	    (sigevp->sigev_notify != SIGEV_THREAD))
		return (ENOSYS);
#endif

	for (i = 0; i < nent; i++)
		switch (apv[i]->aio_lio_opcode) {
		case LIO_READ:
			aio_read(apv[i]);
			break;
		case LIO_WRITE:
			aio_write(apv[i]);
			break;
		case LIO_NOP:
			break;
		}

	if (sigevp && 
	    (mode == LIO_NOWAIT)
	   ) {
		_aio_notify(sigevp);
	}

	return (0);
}

/*
 * aio_error()
 *
 * 	Get I/O completion status
 *
 *      Returns EINPROGRESS until I/O is complete. Returns ECANCELED if
 *	I/O is canceled. Returns I/O status if operation completed.
 *
 *      This routine does not block.
 */
int 
aio_error(const struct aiocb *ap)
{
	return (ap->_aio_err);
}

/*
 * aio_return()
 *
 *	Finish up I/O, releasing I/O resources and returns the value
 *	that would have been associated with a synchronous request.
 */
ssize_t
aio_return(struct aiocb *ap)
{
	return (ap->_aio_val);
}

int
aio_cancel(int fildes, struct aiocb *aiocbp)
{
	struct stat sb;

	/* must be a valid file descriptor */
	if (fstat(fildes, &sb)) {
		errno = EBADF;
		return -1;
	}
	return (AIO_ALLDONE);
}

int
aio_suspend(const struct aiocb *const list[], int nent, const struct timespec *timo)
{
	return (0);
}