#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <strings.h>
#include <signal.h>
#include <fcntl.h>
#include <sys/param.h>
#include <stddef.h>
#include <sys/aio.h>
#include <sys/types.h>
#include <sys/event.h>
#include <sys/time.h>



#define BUFSIZE 512
#define TMOUT_SEC 5
#define TMOUT_NSEC 0

main()
{

	int		fd;
	int		ret;
	struct aiocb	my_aiocb;
	int		kq;

	if ((kq = kqueue()) == -1)
		err(1, "kqueue");
	fd = open("/dev/aacd0s1d", O_RDONLY);
	if (fd < 0)
		perror("open");

	/* Zero out the aiocb structure (recommended) */
	bzero((char *)&my_aiocb, sizeof(struct aiocb));

	/* Allocate a data buffer for the aiocb request */
	my_aiocb.aio_buf = malloc(BUFSIZE + 1);
	if (!my_aiocb.aio_buf)
		perror("malloc");

	/* Initialize the necessary fields in the aiocb */
	my_aiocb.aio_fildes = fd;
	my_aiocb.aio_nbytes = BUFSIZE;
	my_aiocb.aio_offset = (512 * (10000000000LL + 10));
	my_aiocb.aio_sigevent.sigev_notify = SIGEV_KEVENT;
	my_aiocb.aio_sigevent.sigev_notify_kqueue = kq;
	/* udata for the created kqueue */
#if __FreeBSD_version > 700000
	my_aiocb.aio_sigevent.sigev_value.sival_ptr = NULL;
#else
	my_aiocb.aio_sigevent.sigev_value.sigval_ptr = NULL;
#endif

	ret = aio_read(&my_aiocb);
	if (ret < 0)
		perror("aio_read");

#define AAA 1
#if AAA
	while (1) {
		int		i;
		int		n;
		int		nchanges = 0;
		int		nevents = 1;
		struct kevent	ch[1];
		struct kevent	ev[1];
		struct timespec	timeout = {TMOUT_SEC, TMOUT_NSEC};

		n = kevent(kq, ch, nchanges,
			   ev, nevents, &timeout);
		if (n <= 0) {
			perror("kevent");
			exit(1);
		}
		printf("%d events\n", n);
		for (i = 0; i < n; i++) {
			printf("event = 0x%x, %hd, %hx, 0x%x, 0x%x, 0x%x\n",
			ev[i].ident, ev[i].filter, ev[i].flags, ev[i].fflags,
			       ev[i].data, ev[i].udata);
			if (ev[i].flags & (EV_ERROR | EV_EOF)) {
				/* error */
				printf("error is %d\n", (int)ev[i].data);
				break;
			} else {
#if 0
				if (ev[i].filter == EVFILT_READ)
					readable_fd(evi.ident);
				if (ev[i].filter == EVFILT_WRITE)
					writeable_fd(evi.ident);
#endif
			}
		}
		if ((ret = aio_return(&my_aiocb)) > 0) {
			printf("got data\n");
			/* got ret bytes on the read */
		} else {
			/* read failed, consult errno */
			perror("aio_return");
		}
		break;
	}
#else				/* ! AAA */
	/* while (aio_error(&my_aiocb) == EINPROGRESS); */
	if ((ret = aio_return(&my_aiocb)) > 0) {
		printf("got data\n");
		/* got ret bytes on the read */
	} else {
		/* read failed, consult errno */
		perror("aio_return");
	}
#endif

}

#if 0
struct kevent {
	uintptr_t	ident;	/* identifier for this event */
	short		filter;	/* filter for event */
	u_short		flags;	/* action flags for kqueue */
	u_int		fflags;	/* filter flag value */
	intptr_t	data;	/* filter data value */
	void           *udata;	/* opaque user data identifier */
};
struct __aiocb_private {
	long		status;
	long		error;
	void           *kernelinfo;
};
typedef struct aiocb {
	int		aio_fildes;	/* File descriptor */
	off_t		aio_offset;	/* File offset for I/O */
	volatile void  *aio_buf;/* I/O buffer in process space */
	size_t		aio_nbytes;	/* Number of bytes for I/O */
	char		__spare__ [sizeof(int) * 2 + sizeof(void *)];	/* osigevent. */
	int		aio_lio_opcode;	/* LIO opcode */
	int		aio_reqprio;	/* Request priority -- ignored */
	struct __aiocb_private _aiocb_private;
	struct sigevent	aio_sigevent;	/* Signal to deliver */
}		aiocb_t;
#endif