[libc] Add the first version for AIO.

components/libc/Kconfig

@@ -22,6 +22,10 @@ if RT_USING_LIBC && RT_USING_DFS
     config RT_USING_POSIX_TERMIOS
         bool "Enable termios feature"
         default n
+    
+    config RT_USING_POSIX_AIO
+        bool "Enable AIO"
+        default n
     endif
 endif
 

components/libc/aio/SConscript

+# RT-Thread building script for component
+
+from building import *
+
+cwd     = GetCurrentDir()
+src     = Glob('*.c') + Glob('*.cpp')
+CPPPATH = [cwd]
+
+group = DefineGroup('aio', src, depend = ['RT_USING_POSIX', 'RT_USING_POSIX_AIO'], CPPPATH = CPPPATH)
+
+Return('group')

components/libc/aio/posix_aio.c

+/*
+ * File      : posix_aio.c
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2017, RT-Thread Development Team
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2017/12/30     Bernard      The first version.
+ */
+
+#include <stdint.h>
+#include <stdio.h>
+
+#include <rthw.h>
+#include <rtdevice.h>
+#include <rtthread.h>
+
+#include <dfs_posix.h>
+
+#include "posix_aio.h"
+
+struct rt_workqueue* aio_queue = NULL;
+
+/**
+ * The aio_cancel() function shall attempt to cancel one or more asynchronous I/O 
+ * requests currently outstanding against file descriptor fildes. The aiocbp 
+ * argument points to the asynchronous I/O control block for a particular request 
+ * to be canceled. If aiocbp is NULL, then all outstanding cancelable asynchronous 
+ * I/O requests against fildes shall be canceled.
+ * 
+ * Normal asynchronous notification shall occur for asynchronous I/O operations 
+ * that are successfully canceled. If there are requests that cannot be canceled, 
+ * then the normal asynchronous completion process shall take place for those 
+ * requests when they are completed.
+ * 
+ * For requested operations that are successfully canceled, the associated error 
+ * status shall be set to [ECANCELED] and the return status shall be -1. For 
+ * requested operations that are not successfully canceled, the aiocbp shall not 
+ * be modified by aio_cancel().
+ * 
+ * If aiocbp is not NULL, then if fildes does not have the same value as the file 
+ * descriptor with which the asynchronous operation was initiated, unspecified results occur.
+ * 
+ * Which operations are cancelable is implementation-defined.
+ */
+int aio_cancel(int fd, struct aiocb *cb)
+{
+    rt_err_t ret;
+
+    if (!cb) return -EINVAL;
+    if (cb->aio_fildes != fd) return -EINVAL;
+
+    ret = rt_workqueue_cancel_work_sync(aio_queue, &(cb->aio_work));
+    if (ret == RT_EOK)
+    {
+        errno = -ECANCELED;
+        return -1;
+    }
+
+    return 0;
+}
+
+/**
+ * The aio_error() function shall return the error status associated with the 
+ * aiocb structure referenced by the aiocbp argument. The error status for an 
+ * asynchronous I/O operation is the errno value that would be set by the corresponding 
+ * read(), write(),
+ */
+int aio_error (const struct aiocb *cb)
+{
+    if (cb)
+    {
+        return cb->aio_result;
+    }
+
+    return -EINVAL;
+}
+
+/**
+ * The aio_fsync() function shall asynchronously perform a file synchronization 
+ * operation, as specified by the op argument, for I/O operations associated with 
+ * the file indicated by the file descriptor aio_fildes member of the aiocb 
+ * structure referenced by the aiocbp argument and queued at the time of the 
+ * call to aio_fsync(). The function call shall return when the synchronization 
+ * request has been initiated or queued to the file or device (even when the data 
+ * cannot be synchronized immediately).
+ * 
+ * option: If op is O_DSYNC, all currently queued I/O operations shall be completed 
+ * as if by a call to fdatasync(); that is, as defined for synchronized I/O data 
+ * integrity completion.
+ * 
+ * option: If op is O_SYNC, all currently queued I/O operations shall be completed 
+ * as if by a call to fsync(); that is, as defined for synchronized I/O file integrity 
+ * completion. If the aio_fsync() function fails, or if the operation queued by 
+ * aio_fsync() fails, then outstanding I/O operations are not guaranteed to have 
+ * been completed.
+ * 
+ * If aio_fsync() succeeds, then it is only the I/O that was queued at the time 
+ * of the call to aio_fsync() that is guaranteed to be forced to the relevant 
+ * completion state. The completion of subsequent I/O on the file descriptor is
+ * not guaranteed to be completed in a synchronized fashion.
+ * 
+ * The aiocbp argument refers to an asynchronous I/O control block. The aiocbp 
+ * value may be used as an argument to aio_error() and aio_return() in order to 
+ * determine the error status and return status, respectively, of the asynchronous 
+ * operation while it is proceeding. When the request is queued, the error status 
+ * for the operation is [EINPROGRESS]. When all data has been successfully transferred, 
+ * the error status shall be reset to reflect the success or failure of the operation. 
+ * If the operation does not complete successfully, the error status for the 
+ * operation shall be set to indicate the error. The aio_sigevent member determines 
+ * the asynchronous notification to occur as specified in Signal Generation and 
+ * Delivery when all operations have achieved synchronized I/O completion. All 
+ * other members of the structure referenced by aiocbp are ignored. If the control 
+ * block referenced by aiocbp becomes an illegal address prior to asynchronous 
+ * I/O completion, then the behavior is undefined.
+ * 
+ * If the aio_fsync() function fails or aiocbp indicates an error condition, 
+ * data is not guaranteed to have been successfully transferred.
+ */
+static void aio_fync_work(struct rt_work* work, void* work_data)
+{
+    int result;
+    rt_ubase_t level;
+    struct aiocb *cb = (struct aiocb*)work_data;
+
+    RT_ASSERT(cb != RT_NULL);
+
+    result = fsync(cb->aio_fildes);
+    /* modify result */
+    level = rt_hw_interrupt_disable();
+    if (result < 0)
+        cb->aio_result = errno;
+    else
+        cb->aio_result = 0;
+    rt_hw_interrupt_enable(level);
+
+    return ;
+}
+
+int aio_fsync(int op, struct aiocb *cb)
+{
+    rt_ubase_t level;
+    if (!cb) return -EINVAL;
+
+    level = rt_hw_interrupt_disable();
+    cb->aio_result = -EINPROGRESS;
+    rt_hw_interrupt_enable(level);
+
+    rt_work_init(&(cb->aio_work), aio_fync_work, cb);
+    rt_workqueue_dowork(aio_queue, &(cb->aio_work));
+
+    return 0;
+}
+
+static void aio_read_work(struct rt_work* work, void* work_data)
+{
+    int len;
+    rt_ubase_t level;
+    uint8_t *buf_ptr;
+    struct aiocb *cb = (struct aiocb*)work_data;
+
+    buf_ptr = (uint8_t*)cb->aio_buf;
+
+    /* seek to offset */
+    lseek(cb->aio_fildes, cb->aio_offset, SEEK_SET);
+    len = read(cb->aio_fildes, &buf_ptr[cb->aio_offset], cb->aio_nbytes);
+
+    /* modify result */
+    level = rt_hw_interrupt_disable();
+    if (len <= 0)
+        cb->aio_result = errno;
+    else 
+        cb->aio_result = 0;
+    rt_hw_interrupt_enable(level);
+
+    return ;
+}
+
+/**
+ * The aio_read() function shall read aiocbp->aio_nbytes from the file associated 
+ * with aiocbp->aio_fildes into the buffer pointed to by aiocbp->aio_buf. The 
+ * function call shall return when the read request has been initiated or queued 
+ * to the file or device (even when the data cannot be delivered immediately).
+ * 
+ * If prioritized I/O is supported for this file, then the asynchronous operation 
+ * shall be submitted at a priority equal to a base scheduling priority minus 
+ * aiocbp->aio_reqprio. If Thread Execution Scheduling is not supported, then 
+ * the base scheduling priority is that of the calling process;
+ * 
+ * otherwise, the base scheduling priority is that of the calling thread. 
+ * 
+ * The aiocbp value may be used as an argument to aio_error() and aio_return() 
+ * in order to determine the error status and return status, respectively, of 
+ * the asynchronous operation while it is proceeding. If an error condition is 
+ * encountered during queuing, the function call shall return without having 
+ * initiated or queued the request. The requested operation takes place at the 
+ * absolute position in the file as given by aio_offset, as if lseek() were called 
+ * immediately prior to the operation with an offset equal to aio_offset and a 
+ * whence equal to SEEK_SET. After a successful call to enqueue an asynchronous 
+ * I/O operation, the value of the file offset for the file is unspecified.
+ *
+ * The aio_sigevent member specifies the notification which occurs when the 
+ * request is completed.
+ *
+ * The aiocbp->aio_lio_opcode field shall be ignored by aio_read().
+ * 
+ * The aiocbp argument points to an aiocb structure. If the buffer pointed to by 
+ * aiocbp->aio_buf or the control block pointed to by aiocbp becomes an illegal 
+ * address prior to asynchronous I/O completion, then the behavior is undefined.
+ * 
+ * Simultaneous asynchronous operations using the same aiocbp produce undefined 
+ * results.
+ * 
+ * If synchronized I/O is enabled on the file associated with aiocbp->aio_fildes,
+ * the behavior of this function shall be according to the definitions of synchronized 
+ * I/O data integrity completion and synchronized I/O file integrity completion. 
+ * 
+ * For any system action that changes the process memory space while an asynchronous 
+ * I/O is outstanding to the address range being changed, the result of that action 
+ * is undefined.
+ * 
+ * For regular files, no data transfer shall occur past the offset maximum 
+ * established in the open file description associated with aiocbp->aio_fildes.
+ * 
+ */
+int aio_read(struct aiocb *cb)
+{
+    rt_ubase_t level;
+
+    if (!cb) return -EINVAL;
+    if (cb->aio_offset < 0) return -EINVAL;
+
+    level = rt_hw_interrupt_disable();
+    cb->aio_result = -EINPROGRESS;
+    rt_hw_interrupt_enable(level);
+
+    /* en-queue read work */
+    rt_work_init(&(cb->aio_work), aio_read_work, cb);
+    rt_workqueue_dowork(aio_queue, &(cb->aio_work));
+
+    return 0;
+}
+
+/**
+ * The aio_return() function shall return the return status associated with the 
+ * aiocb structure referenced by the aiocbp argument. The return status for an 
+ * asynchronous I/O operation is the value that would be returned by the corresponding 
+ * read(), write(), or fsync() function call. If the error status for the operation 
+ * is equal to [EINPROGRESS], then the return status for the operation is undefined. 
+ * The aio_return() function may be called exactly once to retrieve the return 
+ * status of a given asynchronous operation; thereafter, if the same aiocb structure 
+ * is used in a call to aio_return() or aio_error(), an error may be returned. 
+ * When the aiocb structure referred to by aiocbp is used to submit another asynchronous 
+ * operation, then aio_return() may be successfully used to retrieve the return 
+ * status of that operation.
+ */
+ssize_t  aio_return(struct aiocb *cb)
+{
+    if (cb)
+    {
+        if (cb->aio_result < 0)
+            rt_set_errno(cb->aio_result);
+
+        return cb->aio_result;
+    }
+
+    return -EINVAL;
+}
+
+/**
+ * The aio_suspend() function shall suspend the calling thread until at least 
+ * one of the asynchronous I/O operations referenced by the list argument has 
+ * completed, until a signal interrupts the function, or, if timeout is not NULL, 
+ * until the time interval specified by timeout has passed. If any of the aiocb 
+ * structures in the list correspond to completed asynchronous I/O operations 
+ * (that is, the error status for the operation is not equal to [EINPROGRESS]) 
+ * at the time of the call, the function shall return without suspending the 
+ * calling thread. The list argument is an array of pointers to asynchronous I/O 
+ * control blocks. The nent argument indicates the number of elements in the 
+ * array. Each aiocb structure pointed to has been used in initiating an asynchronous 
+ * I/O request via aio_read(), aio_write(), or lio_listio(). This array may 
+ * contain null pointers, which are ignored. If this array contains pointers 
+ * that refer to aiocb structures that have not been used in submitting asynchronous 
+ * I/O, the effect is undefined.
+ * 
+ * If the time interval indicated in the timespec structure pointed to by timeout 
+ * passes before any of the I/O operations referenced by list are completed, then 
+ * aio_suspend() shall return with an error.
+ */
+int aio_suspend(const struct aiocb *const list[], int nent,
+             const struct timespec *timeout)
+{
+    return -ENOSYS;
+}
+
+static void aio_write_work(struct rt_work* work, void* work_data)
+{
+    int len, oflags, level;
+    uint8_t *buf_ptr;
+    struct aiocb *cb = (struct aiocb*)work_data;
+
+    buf_ptr = (uint8_t*)cb->aio_buf;
+
+    /* whether seek offset */
+    oflags = fcntl(cb->aio_fildes, F_GETFL, 0);
+    if ((oflags & O_APPEND) == 0)
+    {
+        lseek(cb->aio_fildes, SEEK_SET, cb->aio_offset);
+    }
+
+    /* write data */
+    len = write(cb->aio_fildes, buf_ptr, cb->aio_nbytes);
+
+    /* modify result */
+    level = rt_hw_interrupt_disable();
+    if (len <= 0)
+        cb->aio_result = errno;
+    else 
+        cb->aio_result = len;
+    rt_hw_interrupt_enable(level);
+
+    return;
+}
+/**
+ * The aio_write() function shall write aiocbp->aio_nbytes to the file associated 
+ * with aiocbp->aio_fildes from the buffer pointed to by aiocbp->aio_buf. The 
+ * function shall return when the write request has been initiated or, at a minimum, 
+ * queued to the file or device.
+ * 
+ * The aiocbp argument may be used as an argument to aio_error() and aio_return() 
+ * in order to determine the error status and return status, respectively, of the 
+ * asynchronous operation while it is proceeding.
+ * 
+ * The aiocbp argument points to an aiocb structure. If the buffer pointed to by 
+ * aiocbp->aio_buf or the control block pointed to by aiocbp becomes an illegal 
+ * address prior to asynchronous I/O completion, then the behavior is undefined.
+ * 
+ * If O_APPEND is not set for the file descriptor aio_fildes, then the requested 
+ * operation shall take place at the absolute position in the file as given by 
+ * aio_offset, as if lseek() were called immediately prior to the operation with 
+ * an offset equal to aio_offset and a whence equal to SEEK_SET. If O_APPEND is 
+ * set for the file descriptor, or if aio_fildes is associated with a device that 
+ * is incapable of seeking, write operations append to the file in the same order 
+ * as the calls were made, except under circumstances described in Asynchronous 
+ * I/O. After a successful call to enqueue an asynchronous I/O operation, the value 
+ * of the file offset for the file is unspecified.
+ * 
+ * The aio_sigevent member specifies the notification which occurs when the request 
+ * is completed.
+ * 
+ * The aiocbp->aio_lio_opcode field shall be ignored by aio_write().
+ * 
+ * Simultaneous asynchronous operations using the same aiocbp produce undefined 
+ * results.
+ * 
+ * If synchronized I/O is enabled on the file associated with aiocbp->aio_fildes, 
+ * the behavior of this function shall be according to the definitions of synchronized 
+ * I/O data integrity completion, and synchronized I/O file integrity completion.
+ *  
+ * For regular files, no data transfer shall occur past the offset maximum established 
+ * in the open file description associated with aiocbp->aio_fildes.
+ */
+int aio_write(struct aiocb *cb)
+{
+    int oflags;
+    rt_ubase_t level;
+
+    if (!cb || (cb->aio_buf == NULL)) return -EINVAL;
+
+    /* check access mode */
+    oflags = fcntl(cb->aio_fildes, F_GETFL, 0);
+    if ((oflags & O_ACCMODE) != O_WRONLY ||
+        (oflags & O_ACCMODE) != O_RDWR)
+        return -EINVAL;
+
+    level = rt_hw_interrupt_disable();
+    cb->aio_result = -EINPROGRESS;
+    rt_hw_interrupt_enable(level);
+
+    rt_work_init(&(cb->aio_work), aio_write_work, cb);
+    rt_workqueue_dowork(aio_queue, &(cb->aio_work));
+
+    return 0;
+}
+
+/**
+ * The lio_listio() function shall initiate a list of I/O requests with a single 
+ * function call.
+ * 
+ * The mode argument takes one of the values LIO_WAIT or LIO_NOWAIT declared in 
+ * <aio.h> and determines whether the function returns when the I/O operations 
+ * have been completed, or as soon as the operations have been queued. If the 
+ * mode argument is LIO_WAIT, the function shall wait until all I/O is complete 
+ * and the sig argument shall be ignored.
+ * 
+ * If the mode argument is LIO_NOWAIT, the function shall return immediately, and 
+ * asynchronous notification shall occur, according to the sig argument, when all 
+ * the I/O operations complete. If sig is NULL, then no asynchronous notification 
+ * shall occur. If sig is not NULL, asynchronous notification occurs as specified 
+ * in Signal Generation and Delivery when all the requests in list have completed.
+ * 
+ * The I/O requests enumerated by list are submitted in an unspecified order.
+ * 
+ * The list argument is an array of pointers to aiocb structures. The array contains 
+ * nent elements. The array may contain NULL elements, which shall be ignored.
+ * 
+ * If the buffer pointed to by list or the aiocb structures pointed to by the 
+ * elements of the array list become illegal addresses before all asynchronous I/O 
+ * completed and, if necessary, the notification is sent, then the behavior is 
+ * undefined. If the buffers pointed to by the aio_buf member of the aiocb structure 
+ * pointed to by the elements of the array list become illegal addresses prior to 
+ * the asynchronous I/O associated with that aiocb structure being completed, the 
+ * behavior is undefined.
+ * 
+ * The aio_lio_opcode field of each aiocb structure specifies the operation to be 
+ * performed. The supported operations are LIO_READ, LIO_WRITE, and LIO_NOP; these 
+ * symbols are defined in <aio.h>. The LIO_NOP operation causes the list entry to 
+ * be ignored. If the aio_lio_opcode element is equal to LIO_READ, then an I/O operation 
+ * is submitted as if by a call to aio_read() with the aiocbp equal to the address 
+ * of the aiocb structure. If the aio_lio_opcode element is equal to LIO_WRITE, then 
+ * an I/O operation is submitted as if by a call to aio_write() with the aiocbp equal 
+ * to the address of the aiocb structure.
+ * 
+ * The aio_fildes member specifies the file descriptor on which the operation is to 
+ * be performed.
+ * 
+ * The aio_buf member specifies the address of the buffer to or from which the data 
+ * is transferred.
+ * 
+ * The aio_nbytes member specifies the number of bytes of data to be transferred.
+ * 
+ * The members of the aiocb structure further describe the I/O operation to be 
+ * performed, in a manner identical to that of the corresponding aiocb structure 
+ * when used by the aio_read() and aio_write() functions.
+ * 
+ * The nent argument specifies how many elements are members of the list; that is, 
+ * the length of the array.
+ * 
+ * The behavior of this function is altered according to the definitions of synchronized 
+ * I/O data integrity completion and synchronized I/O file integrity completion if 
+ * synchronized I/O is enabled on the file associated with aio_fildes.
+ * 
+ * For regular files, no data transfer shall occur past the offset maximum established 
+ * in the open file description associated with aiocbp->aio_fildes.
+ * 
+ * If sig->sigev_notify is SIGEV_THREAD and sig->sigev_notify_attributes is a 
+ * non-null pointer and the block pointed to by this pointer becomes an illegal 
+ * address prior to all asynchronous I/O being completed, then the behavior is 
+ * undefined. 
+ */
+int lio_listio(int mode, struct aiocb * const list[], int nent,
+            struct sigevent *sig)
+{
+    return -ENOSYS;
+}
+
+int aio_system_init(void)
+{
+    aio_queue = rt_workqueue_create("aio", 2048, RT_THREAD_PRIORITY_MAX/2);
+    RT_ASSERT(aio_queue != NULL);
+
+    return 0;
+}
+INIT_COMPONENT_EXPORT(aio_system_init);

components/libc/aio/posix_aio.h

+/*
+ * File      : posix_aio.h
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2017, RT-Thread Development Team
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2017/12/30     Bernard      The first version.
+ */
+
+#ifndef POSIX_AIO_H__
+#define POSIX_AIO_H__
+
+struct aiocb
+{
+    int aio_fildes;         /* File descriptor. */
+    off_t aio_offset;       /* File offset. */
+
+    volatile void *aio_buf; /* Location of buffer. */
+    size_t aio_nbytes;      /* Length of transfer. */
+    int aio_reqprio;        /* Request priority offset. */
+    struct sigevent aio_sigevent; /* Signal number and value. */
+    int aio_lio_opcode;     /* Operation to be performed. */
+
+    int aio_result;
+    struct rt_work aio_work;
+};
+
+int aio_cancel(int fd, struct aiocb *cb);
+int aio_error (const struct aiocb *cb);
+
+int aio_fsync(int op, struct aiocb *cb);
+
+int aio_read(struct aiocb *cb);
+ssize_t  aio_return(struct aiocb *cb);
+int aio_suspend(const struct aiocb *const list[], int nent,
+             const struct timespec *timeout);
+int aio_write(struct aiocb *cb);
+
+int lio_listio(int mode, struct aiocb * const list[], int nent,
+            struct sigevent *sig);
+
+#endif