--- libaitio/src/aio.c 2010/09/10 12:39:41 1.2 +++ libaitio/src/aio.c 2013/05/30 09:10:13 1.8 @@ -1,8 +1,58 @@ +/************************************************************************* +* (C) 2010 AITNET ltd - Sofia/Bulgaria - +* by Michael Pounov +* +* $Author: misho $ +* $Id: aio.c,v 1.8 2013/05/30 09:10:13 misho Exp $ +* +************************************************************************** +The ELWIX and AITNET software is distributed under the following +terms: + +All of the documentation and software included in the ELWIX and AITNET +Releases is copyrighted by ELWIX - Sofia/Bulgaria + +Copyright 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 + by Michael Pounov . 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. +3. All advertising materials mentioning features or use of this software + must display the following acknowledgement: +This product includes software developed by Michael Pounov +ELWIX - Embedded LightWeight unIX and its contributors. +4. Neither the name of AITNET nor the names of its contributors + may be used to endorse or promote products derived from this software + without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY AITNET AND CONTRIBUTORS ``AS IS'' AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +SUCH DAMAGE. +*/ #include "global.h" +/* default AIO completion request timeout */ +struct timespec aiots = { 10, 0 }; + + /* - * io_rread() Raw VFS read function + * io_rread() - Raw VFS read function + * * @fd = File handle * @buf = Read buffer * @nbytes = Read buffer size @@ -10,17 +60,17 @@ * @update = Update file handle position !0 * return: -1 error or !=-1 readed bytes */ -inline int +int io_rread(int fd, void * __restrict buf, size_t nbytes, off_t offset, int update) { int ret; #ifdef AIO_OPS off_t old = 0; - struct aiocb acb; + struct aiocb acb, *racb; #endif if (!buf) { - io_SetErr(EINVAL, "Error:: invalid arguments ...\n"); + io_SetErr(EINVAL, "Invalid arguments"); return -1; } if (!nbytes) @@ -56,13 +106,15 @@ io_rread(int fd, void * __restrict buf, size_t nbytes, return -1; } +#if 0 while (aio_error(&acb) == EINPROGRESS); ret = aio_return(&acb); +#endif + ret = aio_waitcomplete(&racb, &aiots); if (ret == -1) { LOGERR; return -1; - } else - ret = acb.aio_nbytes; + } #else ret = pread(fd, buf, nbytes, offset); if (ret == -1) { @@ -78,24 +130,25 @@ io_rread(int fd, void * __restrict buf, size_t nbytes, } /* - * io_rwrite() Raw VFS write function + * io_rwrite() - Raw VFS write function + * * @fd = File handle * @buf = Write buffer * @nbytes = Write bytes from buffer * @offset = Write at position, if -1 write nbytes from current position * @update = Update file handle position !0 - * return: -1 error or !=-1 writed bytes + * return: -1 error or !=-1 written bytes */ -inline int +int io_rwrite(int fd, void * __restrict buf, size_t nbytes, off_t offset, int update) { int ret; #ifdef AIO_OPS - struct aiocb acb; + struct aiocb acb, *racb; #endif if (!buf) { - io_SetErr(EINVAL, "Error:: invalid arguments ...\n"); + io_SetErr(EINVAL, "Invalid arguments"); return -1; } if (!nbytes) @@ -120,13 +173,15 @@ io_rwrite(int fd, void * __restrict buf, size_t nbytes return -1; } +#if 0 while (aio_error(&acb) == EINPROGRESS); ret = aio_return(&acb); +#endif + ret = aio_waitcomplete(&racb, &aiots); if (ret == -1) { LOGERR; return -1; - } else - ret = acb.aio_nbytes; + } #else ret = pwrite(fd, buf, nbytes, offset); if (ret == -1) { @@ -138,6 +193,227 @@ io_rwrite(int fd, void * __restrict buf, size_t nbytes if (update) lseek(fd, offset + ret, SEEK_SET); + + return ret; +} + +#ifdef AIO_OPS +/* + * io_aiobulk() - AIO bulk R/W function + * + * @mode = Bulk wait mode + * @acbs = List of aiocb structures + * @nacb = Number of aiocb in list + * @sig = Event for completed operations, may be =NULL + * return: -1 error or 0 ok + */ +int +io_aiobulk(int mode, struct aiocb ** __restrict acbs, int nacb, struct sigevent *sig) +{ + int ret; + + if (!acbs) { + io_SetErr(EINVAL, "Invalid arguments"); + return -1; + } + if (!nacb) + return 0; + + if ((ret = lio_listio(mode, acbs, nacb, sig)) == -1) + LOGERR; + + return ret; +} +#endif + +/* + * io_rreadv() - Raw VFS bulk read function + * + * @fd = File handle + * @bufs = Read buffers + * @nbufs = Number of read buffers + * @offset = Read from position, if -1 read nbytes from current position + * @update = Update file handle position !0 + * return: -1 error or !=-1 readed bytes + */ +int +io_rreadv(int fd, struct iovec * __restrict bufs, int nbufs, off_t offset, int update) +{ + int ret; +#ifdef AIO_OPS + register int i; + off_t off, old = 0; + struct aiocb **acb; +#endif + + if (!bufs) { + io_SetErr(EINVAL, "Invalid arguments"); + return -1; + } + if (!nbufs) + return 0; + if (offset == -1) { + offset = lseek(fd, 0, SEEK_CUR); + if (offset == -1) { + LOGERR; + return -1; + } + } + +#ifdef AIO_OPS + /* This made for generate EOF for file */ + if (!update && (old = lseek(fd, 0, SEEK_CUR)) == -1) { + LOGERR; + return -1; + } + if (offset >= lseek(fd, 0, SEEK_END)) + return 0; + if (!update) + lseek(fd, old, SEEK_SET); + + acb = e_calloc(sizeof(void*), nbufs); + if (!acb) { + LOGERR; + return -1; + } + memset(acb, 0, sizeof(void*) * nbufs); + for (i = 0, off = offset; i < nbufs; off += bufs[i++].iov_len) { + acb[i] = e_malloc(sizeof(struct aiocb)); + if (!acb[i]) { + LOGERR; + for (i = 0; i < nbufs; i++) + if (acb[i]) + e_free(acb[i]); + e_free(acb); + return -1; + } else + memset(acb[i], 0, sizeof(struct aiocb)); + acb[i]->aio_fildes = fd; + acb[i]->aio_nbytes = bufs[i].iov_len; + acb[i]->aio_buf = bufs[i].iov_base; + acb[i]->aio_offset = off; + acb[i]->aio_lio_opcode = LIO_READ; + } + + ret = io_aiobulk(LIO_WAIT, acb, nbufs, NULL); + if (ret == -1) { + LOGERR; + for (i = 0; i < nbufs; i++) + if (acb[i]) + e_free(acb[i]); + e_free(acb); + return -1; + } + + for (i = 0; i < nbufs; i++) { + bufs[i].iov_len = aio_return(acb[i]); + offset += bufs[i].iov_len; + if (acb[i]) + e_free(acb[i]); + } + e_free(acb); +#else + ret = preadv(fd, bufs, nbufs, offset); + if (ret == -1) { + LOGERR; + return -1; + } else + offset += ret; +#endif + + if (update) + lseek(fd, offset, SEEK_SET); + + return ret; +} + +/* + * io_rwritev() - Raw VFS bulk write function + * + * @fd = File handle + * @bufs = Write buffers + * @nbufs = Number of write buffers + * @offset = Write to position, if -1 write nbytes to current position + * @update = Update file handle position !0 + * return: -1 error or !=-1 written bytes + */ +int +io_rwritev(int fd, struct iovec * __restrict bufs, int nbufs, off_t offset, int update) +{ + int ret; +#ifdef AIO_OPS + register int i; + struct aiocb **acb; + off_t off; +#endif + + if (!bufs) { + io_SetErr(EINVAL, "Invalid arguments"); + return -1; + } + if (!nbufs) + return 0; + if (offset == -1) { + offset = lseek(fd, 0, SEEK_CUR); + if (offset == -1) { + LOGERR; + return -1; + } + } + +#ifdef AIO_OPS + acb = e_calloc(sizeof(void*), nbufs); + if (!acb) { + LOGERR; + return -1; + } else + memset(acb, 0, sizeof(void*) * nbufs); + for (i = 0, off = offset; i < nbufs; off += bufs[i++].iov_len) { + acb[i] = e_malloc(sizeof(struct aiocb)); + if (!acb[i]) { + LOGERR; + for (i = 0; i < nbufs; i++) + if (acb[i]) + e_free(acb[i]); + e_free(acb); + return -1; + } else + memset(acb[i], 0, sizeof(struct aiocb)); + acb[i]->aio_fildes = fd; + acb[i]->aio_nbytes = bufs[i].iov_len; + acb[i]->aio_buf = bufs[i].iov_base; + acb[i]->aio_offset = off; + acb[i]->aio_lio_opcode = LIO_WRITE; + } + + ret = io_aiobulk(LIO_WAIT, acb, nbufs, NULL); + if (ret == -1) { + LOGERR; + for (i = 0; i < nbufs; i++) + if (acb[i]) + e_free(acb[i]); + e_free(acb); + return -1; + } + + for (i = 0; i < nbufs; i++) { + bufs[i].iov_len = aio_return(acb[i]); + offset += bufs[i].iov_len; + if (acb[i]) + e_free(acb[i]); + } + e_free(acb); +#else + ret = pwritev(fd, bufs, nbufs, offset); + if (ret == -1) { + LOGERR; + return -1; + } else + offset += ret; +#endif + + if (update) + lseek(fd, offset, SEEK_SET); return ret; }