aio.c 20 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504
  1. /*
  2. * Copyright (c) 2006-2021, RT-Thread Development Team
  3. *
  4. * SPDX-License-Identifier: Apache-2.0
  5. *
  6. * Change Logs:
  7. * Date Author Notes
  8. * 2017/12/30 Bernard The first version.
  9. * 2024/03/26 TroyMitchelle Added some function comments
  10. */
  11. #include <rtthread.h>
  12. #include <rthw.h>
  13. #include <stdint.h>
  14. #include <unistd.h>
  15. #include <fcntl.h>
  16. #include <sys/errno.h>
  17. #include "aio.h"
  18. struct rt_workqueue* aio_queue = NULL;
  19. /**
  20. * The aio_cancel() function shall attempt to cancel one or more asynchronous I/O
  21. * requests currently outstanding against file descriptor fildes. The aiocbp
  22. * argument points to the asynchronous I/O control block for a particular request
  23. * to be canceled. If aiocbp is NULL, then all outstanding cancelable asynchronous
  24. * I/O requests against fildes shall be canceled.
  25. *
  26. * Normal asynchronous notification shall occur for asynchronous I/O operations
  27. * that are successfully canceled. If there are requests that cannot be canceled,
  28. * then the normal asynchronous completion process shall take place for those
  29. * requests when they are completed.
  30. *
  31. * For requested operations that are successfully canceled, the associated error
  32. * status shall be set to [ECANCELED] and the return status shall be -1. For
  33. * requested operations that are not successfully canceled, the aiocbp shall not
  34. * be modified by aio_cancel().
  35. *
  36. * If aiocbp is not NULL, then if fildes does not have the same value as the file
  37. * descriptor with which the asynchronous operation was initiated, unspecified results occur.
  38. *
  39. * Which operations are cancelable is implementation-defined.
  40. */
  41. int aio_cancel(int fd, struct aiocb *cb)
  42. {
  43. rt_err_t ret;
  44. if (!cb) return -EINVAL;
  45. if (cb->aio_fildes != fd) return -EINVAL;
  46. ret = rt_workqueue_cancel_work_sync(aio_queue, &(cb->aio_work));
  47. if (ret == RT_EOK)
  48. {
  49. errno = -ECANCELED;
  50. return -1;
  51. }
  52. return 0;
  53. }
  54. /**
  55. * The aio_error() function shall return the error status associated with the
  56. * aiocb structure referenced by the aiocbp argument. The error status for an
  57. * asynchronous I/O operation is the errno value that would be set by the corresponding
  58. * read(), write(),
  59. */
  60. int aio_error(const struct aiocb *cb)
  61. {
  62. if (cb)
  63. {
  64. return cb->aio_result;
  65. }
  66. return -EINVAL;
  67. }
  68. /**
  69. * The aio_fsync() function shall asynchronously perform a file synchronization
  70. * operation, as specified by the op argument, for I/O operations associated with
  71. * the file indicated by the file descriptor aio_fildes member of the aiocb
  72. * structure referenced by the aiocbp argument and queued at the time of the
  73. * call to aio_fsync(). The function call shall return when the synchronization
  74. * request has been initiated or queued to the file or device (even when the data
  75. * cannot be synchronized immediately).
  76. *
  77. * option: If op is O_DSYNC, all currently queued I/O operations shall be completed
  78. * as if by a call to fdatasync(); that is, as defined for synchronized I/O data
  79. * integrity completion.
  80. *
  81. * option: If op is O_SYNC, all currently queued I/O operations shall be completed
  82. * as if by a call to fsync(); that is, as defined for synchronized I/O file integrity
  83. * completion. If the aio_fsync() function fails, or if the operation queued by
  84. * aio_fsync() fails, then outstanding I/O operations are not guaranteed to have
  85. * been completed.
  86. *
  87. * If aio_fsync() succeeds, then it is only the I/O that was queued at the time
  88. * of the call to aio_fsync() that is guaranteed to be forced to the relevant
  89. * completion state. The completion of subsequent I/O on the file descriptor is
  90. * not guaranteed to be completed in a synchronized fashion.
  91. *
  92. * The aiocbp argument refers to an asynchronous I/O control block. The aiocbp
  93. * value may be used as an argument to aio_error() and aio_return() in order to
  94. * determine the error status and return status, respectively, of the asynchronous
  95. * operation while it is proceeding. When the request is queued, the error status
  96. * for the operation is [EINPROGRESS]. When all data has been successfully transferred,
  97. * the error status shall be reset to reflect the success or failure of the operation.
  98. * If the operation does not complete successfully, the error status for the
  99. * operation shall be set to indicate the error. The aio_sigevent member determines
  100. * the asynchronous notification to occur as specified in Signal Generation and
  101. * Delivery when all operations have achieved synchronized I/O completion. All
  102. * other members of the structure referenced by aiocbp are ignored. If the control
  103. * block referenced by aiocbp becomes an illegal address prior to asynchronous
  104. * I/O completion, then the behavior is undefined.
  105. *
  106. * If the aio_fsync() function fails or aiocbp indicates an error condition,
  107. * data is not guaranteed to have been successfully transferred.
  108. */
  109. static void aio_fync_work(struct rt_work* work, void* work_data)
  110. {
  111. int result;
  112. rt_base_t level;
  113. struct aiocb *cb = (struct aiocb*)work_data;
  114. RT_ASSERT(cb != RT_NULL);
  115. result = fsync(cb->aio_fildes);
  116. /* modify result */
  117. level = rt_hw_interrupt_disable();
  118. if (result < 0)
  119. cb->aio_result = errno;
  120. else
  121. cb->aio_result = 0;
  122. rt_hw_interrupt_enable(level);
  123. return ;
  124. }
  125. /**
  126. * @brief Initiates an asynchronous fsync operation.
  127. *
  128. * This function initiates an asynchronous fsync operation on the file associated
  129. * with the specified aiocb structure. The operation is queued to the workqueue
  130. * for execution.
  131. *
  132. * @param op The operation to be performed. This parameter is ignored.
  133. * @param cb Pointer to the aiocb structure representing the asynchronous fsync operation.
  134. *
  135. * @return Returns 0 on success.
  136. */
  137. int aio_fsync(int op, struct aiocb *cb)
  138. {
  139. rt_base_t level;
  140. if (!cb) return -EINVAL;
  141. level = rt_hw_interrupt_disable();
  142. cb->aio_result = -EINPROGRESS;
  143. rt_hw_interrupt_enable(level);
  144. rt_work_init(&(cb->aio_work), aio_fync_work, cb);
  145. rt_workqueue_dowork(aio_queue, &(cb->aio_work));
  146. return 0;
  147. }
  148. /**
  149. * @brief Worker function for asynchronous read operation.
  150. *
  151. * This function performs the actual reading of data from the file associated with
  152. * the specified aiocb structure. It sets the result of the operation in the
  153. * aio_result field of the aiocb structure.
  154. *
  155. * @param work Pointer to the work item.
  156. * @param work_data Pointer to the aiocb structure representing the asynchronous read operation.
  157. */
  158. static void aio_read_work(struct rt_work* work, void* work_data)
  159. {
  160. int len;
  161. rt_base_t level;
  162. uint8_t *buf_ptr;
  163. struct aiocb *cb = (struct aiocb*)work_data;
  164. buf_ptr = (uint8_t*)cb->aio_buf;
  165. /* seek to offset */
  166. lseek(cb->aio_fildes, cb->aio_offset, SEEK_SET);
  167. len = read(cb->aio_fildes, &buf_ptr[cb->aio_offset], cb->aio_nbytes);
  168. /* modify result */
  169. level = rt_hw_interrupt_disable();
  170. if (len <= 0)
  171. cb->aio_result = errno;
  172. else
  173. cb->aio_result = len;
  174. rt_hw_interrupt_enable(level);
  175. return ;
  176. }
  177. /**
  178. * The aio_read() function shall read aiocbp->aio_nbytes from the file associated
  179. * with aiocbp->aio_fildes into the buffer pointed to by aiocbp->aio_buf. The
  180. * function call shall return when the read request has been initiated or queued
  181. * to the file or device (even when the data cannot be delivered immediately).
  182. *
  183. * If prioritized I/O is supported for this file, then the asynchronous operation
  184. * shall be submitted at a priority equal to a base scheduling priority minus
  185. * aiocbp->aio_reqprio. If Thread Execution Scheduling is not supported, then
  186. * the base scheduling priority is that of the calling process;
  187. *
  188. * otherwise, the base scheduling priority is that of the calling thread.
  189. *
  190. * The aiocbp value may be used as an argument to aio_error() and aio_return()
  191. * in order to determine the error status and return status, respectively, of
  192. * the asynchronous operation while it is proceeding. If an error condition is
  193. * encountered during queuing, the function call shall return without having
  194. * initiated or queued the request. The requested operation takes place at the
  195. * absolute position in the file as given by aio_offset, as if lseek() were called
  196. * immediately prior to the operation with an offset equal to aio_offset and a
  197. * whence equal to SEEK_SET. After a successful call to enqueue an asynchronous
  198. * I/O operation, the value of the file offset for the file is unspecified.
  199. *
  200. * The aio_sigevent member specifies the notification which occurs when the
  201. * request is completed.
  202. *
  203. * The aiocbp->aio_lio_opcode field shall be ignored by aio_read().
  204. *
  205. * The aiocbp argument points to an aiocb structure. If the buffer pointed to by
  206. * aiocbp->aio_buf or the control block pointed to by aiocbp becomes an illegal
  207. * address prior to asynchronous I/O completion, then the behavior is undefined.
  208. *
  209. * Simultaneous asynchronous operations using the same aiocbp produce undefined
  210. * results.
  211. *
  212. * If synchronized I/O is enabled on the file associated with aiocbp->aio_fildes,
  213. * the behavior of this function shall be according to the definitions of synchronized
  214. * I/O data integrity completion and synchronized I/O file integrity completion.
  215. *
  216. * For any system action that changes the process memory space while an asynchronous
  217. * I/O is outstanding to the address range being changed, the result of that action
  218. * is undefined.
  219. *
  220. * For regular files, no data transfer shall occur past the offset maximum
  221. * established in the open file description associated with aiocbp->aio_fildes.
  222. *
  223. */
  224. int aio_read(struct aiocb *cb)
  225. {
  226. rt_base_t level;
  227. if (!cb) return -EINVAL;
  228. if (cb->aio_offset < 0) return -EINVAL;
  229. level = rt_hw_interrupt_disable();
  230. cb->aio_result = -EINPROGRESS;
  231. rt_hw_interrupt_enable(level);
  232. /* en-queue read work */
  233. rt_work_init(&(cb->aio_work), aio_read_work, cb);
  234. rt_workqueue_dowork(aio_queue, &(cb->aio_work));
  235. return 0;
  236. }
  237. /**
  238. * The aio_return() function shall return the return status associated with the
  239. * aiocb structure referenced by the aiocbp argument. The return status for an
  240. * asynchronous I/O operation is the value that would be returned by the corresponding
  241. * read(), write(), or fsync() function call. If the error status for the operation
  242. * is equal to [EINPROGRESS], then the return status for the operation is undefined.
  243. * The aio_return() function may be called exactly once to retrieve the return
  244. * status of a given asynchronous operation; thereafter, if the same aiocb structure
  245. * is used in a call to aio_return() or aio_error(), an error may be returned.
  246. * When the aiocb structure referred to by aiocbp is used to submit another asynchronous
  247. * operation, then aio_return() may be successfully used to retrieve the return
  248. * status of that operation.
  249. */
  250. ssize_t aio_return(struct aiocb *cb)
  251. {
  252. if (cb)
  253. {
  254. if (cb->aio_result < 0)
  255. rt_set_errno(cb->aio_result);
  256. return cb->aio_result;
  257. }
  258. return -EINVAL;
  259. }
  260. /**
  261. * The aio_suspend() function shall suspend the calling thread until at least
  262. * one of the asynchronous I/O operations referenced by the list argument has
  263. * completed, until a signal interrupts the function, or, if timeout is not NULL,
  264. * until the time interval specified by timeout has passed. If any of the aiocb
  265. * structures in the list correspond to completed asynchronous I/O operations
  266. * (that is, the error status for the operation is not equal to [EINPROGRESS])
  267. * at the time of the call, the function shall return without suspending the
  268. * calling thread. The list argument is an array of pointers to asynchronous I/O
  269. * control blocks. The nent argument indicates the number of elements in the
  270. * array. Each aiocb structure pointed to has been used in initiating an asynchronous
  271. * I/O request via aio_read(), aio_write(), or lio_listio(). This array may
  272. * contain null pointers, which are ignored. If this array contains pointers
  273. * that refer to aiocb structures that have not been used in submitting asynchronous
  274. * I/O, the effect is undefined.
  275. *
  276. * If the time interval indicated in the timespec structure pointed to by timeout
  277. * passes before any of the I/O operations referenced by list are completed, then
  278. * aio_suspend() shall return with an error.
  279. */
  280. int aio_suspend(const struct aiocb *const list[], int nent,
  281. const struct timespec *timeout)
  282. {
  283. return -ENOSYS;
  284. }
  285. /**
  286. * @brief Worker function for asynchronous write operation.
  287. *
  288. * This function performs the actual writing of data to the file associated with
  289. * the specified aiocb structure. It sets the result of the operation in the
  290. * aio_result field of the aiocb structure.
  291. *
  292. * @param work Pointer to the work item.
  293. * @param work_data Pointer to the aiocb structure representing the asynchronous write operation.
  294. */
  295. static void aio_write_work(struct rt_work* work, void* work_data)
  296. {
  297. rt_base_t level;
  298. int len, oflags;
  299. uint8_t *buf_ptr;
  300. struct aiocb *cb = (struct aiocb*)work_data;
  301. buf_ptr = (uint8_t*)cb->aio_buf;
  302. /* whether seek offset */
  303. oflags = fcntl(cb->aio_fildes, F_GETFL, 0);
  304. if ((oflags & O_APPEND) == 0)
  305. {
  306. lseek(cb->aio_fildes, SEEK_SET, cb->aio_offset);
  307. }
  308. /* write data */
  309. len = write(cb->aio_fildes, buf_ptr, cb->aio_nbytes);
  310. /* modify result */
  311. level = rt_hw_interrupt_disable();
  312. if (len <= 0)
  313. cb->aio_result = errno;
  314. else
  315. cb->aio_result = len;
  316. rt_hw_interrupt_enable(level);
  317. return;
  318. }
  319. /**
  320. * The aio_write() function shall write aiocbp->aio_nbytes to the file associated
  321. * with aiocbp->aio_fildes from the buffer pointed to by aiocbp->aio_buf. The
  322. * function shall return when the write request has been initiated or, at a minimum,
  323. * queued to the file or device.
  324. *
  325. * The aiocbp argument may be used as an argument to aio_error() and aio_return()
  326. * in order to determine the error status and return status, respectively, of the
  327. * asynchronous operation while it is proceeding.
  328. *
  329. * The aiocbp argument points to an aiocb structure. If the buffer pointed to by
  330. * aiocbp->aio_buf or the control block pointed to by aiocbp becomes an illegal
  331. * address prior to asynchronous I/O completion, then the behavior is undefined.
  332. *
  333. * If O_APPEND is not set for the file descriptor aio_fildes, then the requested
  334. * operation shall take place at the absolute position in the file as given by
  335. * aio_offset, as if lseek() were called immediately prior to the operation with
  336. * an offset equal to aio_offset and a whence equal to SEEK_SET. If O_APPEND is
  337. * set for the file descriptor, or if aio_fildes is associated with a device that
  338. * is incapable of seeking, write operations append to the file in the same order
  339. * as the calls were made, except under circumstances described in Asynchronous
  340. * I/O. After a successful call to enqueue an asynchronous I/O operation, the value
  341. * of the file offset for the file is unspecified.
  342. *
  343. * The aio_sigevent member specifies the notification which occurs when the request
  344. * is completed.
  345. *
  346. * The aiocbp->aio_lio_opcode field shall be ignored by aio_write().
  347. *
  348. * Simultaneous asynchronous operations using the same aiocbp produce undefined
  349. * results.
  350. *
  351. * If synchronized I/O is enabled on the file associated with aiocbp->aio_fildes,
  352. * the behavior of this function shall be according to the definitions of synchronized
  353. * I/O data integrity completion, and synchronized I/O file integrity completion.
  354. *
  355. * For regular files, no data transfer shall occur past the offset maximum established
  356. * in the open file description associated with aiocbp->aio_fildes.
  357. */
  358. int aio_write(struct aiocb *cb)
  359. {
  360. int oflags;
  361. rt_base_t level;
  362. if (!cb || (cb->aio_buf == NULL)) return -EINVAL;
  363. /* check access mode */
  364. oflags = fcntl(cb->aio_fildes, F_GETFL, 0);
  365. if ((oflags & O_ACCMODE) != O_WRONLY ||
  366. (oflags & O_ACCMODE) != O_RDWR)
  367. return -EINVAL;
  368. level = rt_hw_interrupt_disable();
  369. cb->aio_result = -EINPROGRESS;
  370. rt_hw_interrupt_enable(level);
  371. rt_work_init(&(cb->aio_work), aio_write_work, cb);
  372. rt_workqueue_dowork(aio_queue, &(cb->aio_work));
  373. return 0;
  374. }
  375. /**
  376. * The lio_listio() function shall initiate a list of I/O requests with a single
  377. * function call.
  378. *
  379. * The mode argument takes one of the values LIO_WAIT or LIO_NOWAIT declared in
  380. * <aio.h> and determines whether the function returns when the I/O operations
  381. * have been completed, or as soon as the operations have been queued. If the
  382. * mode argument is LIO_WAIT, the function shall wait until all I/O is complete
  383. * and the sig argument shall be ignored.
  384. *
  385. * If the mode argument is LIO_NOWAIT, the function shall return immediately, and
  386. * asynchronous notification shall occur, according to the sig argument, when all
  387. * the I/O operations complete. If sig is NULL, then no asynchronous notification
  388. * shall occur. If sig is not NULL, asynchronous notification occurs as specified
  389. * in Signal Generation and Delivery when all the requests in list have completed.
  390. *
  391. * The I/O requests enumerated by list are submitted in an unspecified order.
  392. *
  393. * The list argument is an array of pointers to aiocb structures. The array contains
  394. * nent elements. The array may contain NULL elements, which shall be ignored.
  395. *
  396. * If the buffer pointed to by list or the aiocb structures pointed to by the
  397. * elements of the array list become illegal addresses before all asynchronous I/O
  398. * completed and, if necessary, the notification is sent, then the behavior is
  399. * undefined. If the buffers pointed to by the aio_buf member of the aiocb structure
  400. * pointed to by the elements of the array list become illegal addresses prior to
  401. * the asynchronous I/O associated with that aiocb structure being completed, the
  402. * behavior is undefined.
  403. *
  404. * The aio_lio_opcode field of each aiocb structure specifies the operation to be
  405. * performed. The supported operations are LIO_READ, LIO_WRITE, and LIO_NOP; these
  406. * symbols are defined in <aio.h>. The LIO_NOP operation causes the list entry to
  407. * be ignored. If the aio_lio_opcode element is equal to LIO_READ, then an I/O operation
  408. * is submitted as if by a call to aio_read() with the aiocbp equal to the address
  409. * of the aiocb structure. If the aio_lio_opcode element is equal to LIO_WRITE, then
  410. * an I/O operation is submitted as if by a call to aio_write() with the aiocbp equal
  411. * to the address of the aiocb structure.
  412. *
  413. * The aio_fildes member specifies the file descriptor on which the operation is to
  414. * be performed.
  415. *
  416. * The aio_buf member specifies the address of the buffer to or from which the data
  417. * is transferred.
  418. *
  419. * The aio_nbytes member specifies the number of bytes of data to be transferred.
  420. *
  421. * The members of the aiocb structure further describe the I/O operation to be
  422. * performed, in a manner identical to that of the corresponding aiocb structure
  423. * when used by the aio_read() and aio_write() functions.
  424. *
  425. * The nent argument specifies how many elements are members of the list; that is,
  426. * the length of the array.
  427. *
  428. * The behavior of this function is altered according to the definitions of synchronized
  429. * I/O data integrity completion and synchronized I/O file integrity completion if
  430. * synchronized I/O is enabled on the file associated with aio_fildes.
  431. *
  432. * For regular files, no data transfer shall occur past the offset maximum established
  433. * in the open file description associated with aiocbp->aio_fildes.
  434. *
  435. * If sig->sigev_notify is SIGEV_THREAD and sig->sigev_notify_attributes is a
  436. * non-null pointer and the block pointed to by this pointer becomes an illegal
  437. * address prior to all asynchronous I/O being completed, then the behavior is
  438. * undefined.
  439. */
  440. int lio_listio(int mode, struct aiocb * const list[], int nent,
  441. struct sigevent *sig)
  442. {
  443. return -ENOSYS;
  444. }
  445. /**
  446. * @brief Initializes the asynchronous I/O system.
  447. *
  448. * This function initializes the asynchronous I/O system by creating a workqueue
  449. * for asynchronous I/O operations.
  450. *
  451. * @return Returns 0 on success.
  452. */
  453. int aio_system_init(void)
  454. {
  455. aio_queue = rt_workqueue_create("aio", 2048, RT_THREAD_PRIORITY_MAX/2);
  456. RT_ASSERT(aio_queue != NULL);
  457. return 0;
  458. }
  459. INIT_COMPONENT_EXPORT(aio_system_init);