libeio/eio.h

/*
 * libeio API header
 *
 * Copyright (c) 2007,2008,2009,2010,2011,2012,2015,2016,2017 Marc Alexander Lehmann <libeio@schmorp.de>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modifica-
 * tion, 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.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MER-
 * CHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO
 * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE-
 * CIAL, 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 OTH-
 * ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 * OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * Alternatively, the contents of this file may be used under the terms of
 * the GNU General Public License ("GPL") version 2 or any later version,
 * in which case the provisions of the GPL are applicable instead of
 * the above. If you wish to allow the use of your version of this file
 * only under the terms of the GPL and not to allow others to use your
 * version of this file under the BSD license, indicate your decision
 * by deleting the provisions above and replace them with the notice
 * and other provisions required by the GPL. If you do not delete the
 * provisions above, a recipient may use your version of this file under
 * either the BSD or the GPL.
 */

#ifndef EIO_H_
#define EIO_H_

#ifdef __cplusplus
extern "C" {
#endif

#include <stddef.h>
#include <signal.h>
#include <sys/types.h>

typedef struct eio_req    eio_req;
typedef struct eio_dirent eio_dirent;

typedef int (*eio_cb)(eio_req *req);

#ifndef EIO_REQ_MEMBERS
# define EIO_REQ_MEMBERS
#endif

#ifndef EIO_STRUCT_STAT
# ifdef _WIN32
#  define EIO_STRUCT_STAT struct _stati64
#  define EIO_STRUCT_STATI64
# else
#  define EIO_STRUCT_STAT struct stat
# endif
#endif

#ifdef _WIN32

  typedef int      eio_uid_t;
  typedef int      eio_gid_t;
  #ifdef __MINGW32__ /* no intptr_t */
    typedef ssize_t  eio_ssize_t;
  #else
    typedef intptr_t eio_ssize_t; /* or SSIZE_T */
  #endif
  #if __GNUC__
    typedef long long eio_ino_t; /* signed for compatibility to msvc */
  #else
    typedef __int64   eio_ino_t; /* unsigned not supported by msvc */
  #endif
  typedef unsigned int eio_u32_t;
  typedef          int eio_i32_t;

#else

  typedef uid_t    eio_uid_t;
  typedef gid_t    eio_gid_t;
  typedef ssize_t  eio_ssize_t;
  typedef ino_t    eio_ino_t;

  #include <inttypes.h>
  typedef uint32_t eio_u32_t;
  typedef  int32_t eio_i32_t;

#endif

#ifndef EIO_STRUCT_STATVFS
# define EIO_STRUCT_STATVFS struct statvfs
#endif

/* managing working directories */

typedef struct eio_pwd *eio_wd;

#define EIO_CWD 0 /* the current working directory of the process, guaranteed to be a null pointer */
#define EIO_INVALID_WD ((eio_wd)(int)-1) /* failure return for eio_wd_open */

eio_wd eio_wd_open_sync (eio_wd wd, const char *path);
void eio_wd_close_sync (eio_wd wd);

/* for readdir */

/* eio_readdir flags */
enum
{
  EIO_READDIR_DENTS         = 0x01, /* ptr2 contains eio_dirents, not just the (unsorted) names */
  EIO_READDIR_DIRS_FIRST    = 0x02, /* dirents gets sorted into a good stat() ing order to find directories first */
  EIO_READDIR_STAT_ORDER    = 0x04, /* dirents gets sorted into a good stat() ing order to quickly stat all files */
  EIO_READDIR_FOUND_UNKNOWN = 0x80, /* set by eio_readdir when *_ARRAY was set and any TYPE=UNKNOWN's were found */

  EIO_READDIR_CUSTOM1       = 0x100, /* for use by apps */
  EIO_READDIR_CUSTOM2       = 0x200  /* for use by apps */
};

/* using "typical" values in the hope that the compiler will do something sensible */
enum eio_dtype
{
  EIO_DT_UNKNOWN =  0,
  EIO_DT_FIFO    =  1,
  EIO_DT_CHR     =  2,
  EIO_DT_MPC     =  3, /* multiplexed char device (v7+coherent) */
  EIO_DT_DIR     =  4,
  EIO_DT_NAM     =  5, /* xenix special named file */
  EIO_DT_BLK     =  6,
  EIO_DT_MPB     =  7, /* multiplexed block device (v7+coherent) */
  EIO_DT_REG     =  8,
  EIO_DT_NWK     =  9, /* HP-UX network special */
  EIO_DT_CMP     =  9, /* VxFS compressed */
  EIO_DT_LNK     = 10,
  /*  DT_SHAD    = 11,*/
  EIO_DT_SOCK    = 12,
  EIO_DT_DOOR    = 13, /* solaris door */
  EIO_DT_WHT     = 14,
  EIO_DT_MAX     = 15  /* highest DT_VALUE ever, hopefully */
};

struct eio_dirent
{
  int nameofs; /* offset of null-terminated name string in (char *)req->ptr2 */
  unsigned short namelen; /* size of filename without trailing 0 */
  unsigned char type; /* one of EIO_DT_* */
  signed char score; /* internal use */
  eio_ino_t inode; /* the inode number, if available, otherwise unspecified */
};

/* eio_msync flags */
enum
{
  EIO_MS_ASYNC      = 1,
  EIO_MS_INVALIDATE = 2,
  EIO_MS_SYNC       = 4
};

/* eio_mtouch flags */
enum
{
  EIO_MT_MODIFY     = 1
};

/* eio_sync_file_range flags */
enum
{
  EIO_SYNC_FILE_RANGE_WAIT_BEFORE = 1,
  EIO_SYNC_FILE_RANGE_WRITE       = 2,
  EIO_SYNC_FILE_RANGE_WAIT_AFTER  = 4
};

/* eio_fallocate flags */
enum
{
  /* these MUST match the value in linux/falloc.h */
  EIO_FALLOC_FL_KEEP_SIZE      = 0x01,
  EIO_FALLOC_FL_PUNCH_HOLE     = 0x02,
  EIO_FALLOC_FL_COLLAPSE_RANGE = 0x08,
  EIO_FALLOC_FL_ZERO_RANGE     = 0x10,
  EIO_FALLOC_FL_INSERT_RANGE   = 0x20,
  EIO_FALLOC_FL_UNSHARE_RANGE  = 0x40
};

/* eio_rename flags */
enum
{
  /* these MUST match the value in linux/fs.h */
  EIO_RENAME_NOREPLACE = 1 << 0,
  EIO_RENAME_EXCHANGE  = 1 << 1,
  EIO_RENAME_WHITEOUT  = 1 << 2
};

/* timestamps and differences - feel free to use double in your code directly */
#ifndef EIO_TSTAMP_IS_DOUBLE
# define EIO_TSTAMP_IS_DOUBLE 1
#endif
#if EIO_TSTAMP_IS_DOUBLE
  #define EIO_TSTAMP_NSEC_NOW  (-1.)
  #define EIO_TSTAMP_NSEC_OMIT (-2.)
  #define EIO_TSTAMP_IS_NOW(ts)  ((ts) == -1.)
  #define EIO_TSTAMP_IS_OMIT(ts) ((ts) == -2.)
  #define EIO_TSTAMP_IS_NONNEGATIVE(ts) ((ts) >= 0.)
  tpedef double eio_tstamp;
#else
  #define EIO_TSTAMP_NSEC_NOW  (0x3fffffffU)
  #define EIO_TSTAMP_NSEC_OMIT (0x3ffffffeU)
  #define EIO_TSTAMP_IS_NOW(ts)  ((ts).n == EIO_TSTAMP_NSEC_NOW)
  #define EIO_TSTAMP_IS_OMIT(ts) ((ts).n == EIO_TSTAMP_NSEC_OMIT)
  #define EIO_TSTAMP_IS_NONNEGATIVE(ts) ((ts).s >= 0)
  typedef struct
  {
    eio_u32_t s; /* low 32 bits of 34 bit seconds, negative times not supported */
    eio_u32_t n; /* top 2 bits are bits 33-34 bits of seconds, rest is nanoseconds, or EIO_NSEC_NOW, EIO_NSEC_OMIT */
  } eio_tstamp;
#endif

/* the eio request structure */
enum
{
  EIO_CUSTOM,
  EIO_WD_OPEN, EIO_WD_CLOSE,

  EIO_CLOSE, EIO_DUP2,
  EIO_SEEK, EIO_READ, EIO_WRITE, EIO_FCNTL, EIO_IOCTL,
  EIO_READAHEAD, EIO_SENDFILE, /*EIO_COPY_FILE_RANGE,*/
  EIO_FSTAT, EIO_FSTATVFS,
  EIO_FTRUNCATE, EIO_FUTIME, EIO_FCHMOD, EIO_FCHOWN,
  EIO_SYNC, EIO_FSYNC, EIO_FDATASYNC, EIO_SYNCFS,
  EIO_MSYNC, EIO_MTOUCH, EIO_SYNC_FILE_RANGE, EIO_FALLOCATE,
  EIO_MLOCK, EIO_MLOCKALL,
  EIO_GROUP, EIO_NOP,
  EIO_BUSY,

  /* these use wd + ptr1, but are emulated */
  EIO_REALPATH,
  EIO_READDIR,

  /* all the following requests use wd + ptr1 as path in xxxat functions */
  EIO_OPEN,
  EIO_STAT, EIO_LSTAT, EIO_STATVFS,
  EIO_TRUNCATE,
  EIO_UTIME,
  EIO_CHMOD,
  EIO_CHOWN,
  EIO_UNLINK, EIO_RMDIR, EIO_MKDIR, EIO_RENAME,
  EIO_MKNOD,
  EIO_LINK, EIO_SYMLINK, EIO_READLINK,
  EIO_SLURP, /* open + read + close */

  EIO_REQ_TYPE_NUM
};

/* seek whence modes */
/* these are guaranteed to hasve the traditional 0, 1, 2 values, */
/* so you might as wlel use those */
enum
{
  EIO_SEEK_SET = 0,
  EIO_SEEK_CUR = 1,
  EIO_SEEK_END = 2
};


/* mlockall constants */
enum
{
  EIO_MCL_CURRENT = 1,
  EIO_MCL_FUTURE  = 2,
  EIO_MCL_ONFAULT = 4
};

/* request priorities */

enum {
  EIO_PRI_MIN     = -4,
  EIO_PRI_MAX     =  4,
  EIO_PRI_DEFAULT =  0
};

/* eio request structure */
/* this structure is mostly read-only */
/* when initialising it, all members must be zero-initialised */
struct eio_req
{
  eio_req volatile *next; /* private ETP */

  eio_wd wd;       /* all applicable requests: working directory of pathname, old name; wd_open: return wd */

  eio_ssize_t result;  /* result of syscall, e.g. result = read (... */
  off_t offs;      /* read, write, truncate, readahead, sync_file_range, fallocate, slurp: file offset, mknod: dev_t */
  size_t size;     /* read, write, readahead, sendfile, msync, mlock, sync_file_range, fallocate, slurp: length */
  void *ptr1;      /* all applicable requests: pathname, old name, readdir: optional eio_dirents */
  void *ptr2;      /* all applicable requests: new name or memory buffer; readdir: name strings */
  eio_tstamp nv1;  /* utime, futime: atime; busy: sleep time */
  eio_tstamp nv2;  /* utime, futime: mtime */

  int int1;        /* all applicable requests: file descriptor; sendfile: output fd; open, msync, mlockall, readdir: flags */
  long int2;       /* chown, fchown: uid; sendfile: input fd; open, chmod, mkdir, mknod: file mode, seek: whence, fcntl, ioctl: request, sync_file_range, fallocate, rename: flags */
  long int3;       /* chown, fchown: gid; rename, link: working directory of new name */
  int errorno;     /* errno value on syscall return */

  unsigned char flags; /* private */

  signed char type;/* EIO_xxx constant ETP */
  signed char pri;     /* the priority ETP */
#if __i386 || __amd64
  unsigned char cancelled; /* ETP */
#else
  sig_atomic_t  cancelled; /* ETP */
#endif

  void *data;
  eio_cb finish;
  void (*destroy)(eio_req *req); /* called when request no longer needed */
  void (*feed)(eio_req *req);    /* only used for group requests */

  EIO_REQ_MEMBERS

  eio_req *grp, *grp_prev, *grp_next, *grp_first; /* private ETP */
};

/* _private_ request flags */
enum {
  EIO_FLAG_PTR1_FREE = 0x01, /* need to free(ptr1) */
  EIO_FLAG_PTR2_FREE = 0x02, /* need to free(ptr2) */
};

/* undocumented/unsupported/private helper */
/*void eio_page_align (void **addr, size_t *length);*/

/* returns < 0 on error, errno set
 * need_poll, if non-zero, will be called when results are available
 * and eio_poll_cb needs to be invoked (it MUST NOT call eio_poll_cb itself).
 * done_poll is called when the need to poll is gone.
 */
int eio_init (void (*want_poll)(void), void (*done_poll)(void));

/* must be called regularly to handle pending requests */
/* returns 0 if all requests were handled, -1 if not, or the value of EIO_FINISH if != 0 */
int eio_poll (void);

/* stop polling if poll took longer than duration seconds */
void eio_set_max_poll_time (double nseconds);
/* do not handle more then count requests in one call to eio_poll_cb */
void eio_set_max_poll_reqs (unsigned int nreqs);

/* set minimum required number
 * maximum wanted number
 * or maximum idle number of threads */
void eio_set_min_parallel (unsigned int nthreads);
void eio_set_max_parallel (unsigned int nthreads);
void eio_set_max_idle     (unsigned int nthreads);
void eio_set_idle_timeout (unsigned int seconds);

unsigned int eio_nreqs    (void); /* number of requests in-flight */
unsigned int eio_nready   (void); /* number of not-yet handled requests */
unsigned int eio_npending (void); /* number of finished but unhandled requests */
unsigned int eio_nthreads (void); /* number of worker threads in use currently */

/*****************************************************************************/
/* convenience wrappers */
/* these do not expose advanced syscalls and directory fds */

#ifndef EIO_NO_WRAPPERS
eio_req *eio_wd_open   (const char *path, int pri, eio_cb cb, void *data); /* result=wd */
eio_req *eio_wd_close  (eio_wd wd, int pri, eio_cb cb, void *data);
eio_req *eio_nop       (int pri, eio_cb cb, void *data); /* does nothing except go through the whole process */
eio_req *eio_busy      (eio_tstamp delay, int pri, eio_cb cb, void *data); /* ties a thread for this long, simulating busyness */
eio_req *eio_sync      (int pri, eio_cb cb, void *data);
eio_req *eio_fsync     (int fd, int pri, eio_cb cb, void *data);
eio_req *eio_fdatasync (int fd, int pri, eio_cb cb, void *data);
eio_req *eio_syncfs    (int fd, int pri, eio_cb cb, void *data);
eio_req *eio_msync     (void *addr, size_t length, int flags, int pri, eio_cb cb, void *data);
eio_req *eio_mtouch    (void *addr, size_t length, int flags, int pri, eio_cb cb, void *data);
eio_req *eio_mlock     (void *addr, size_t length, int pri, eio_cb cb, void *data);
eio_req *eio_mlockall  (int flags, int pri, eio_cb cb, void *data);
eio_req *eio_sync_file_range (int fd, off_t offset, size_t nbytes, unsigned int flags, int pri, eio_cb cb, void *data);
eio_req *eio_fallocate (int fd, int mode, off_t offset, size_t len, int pri, eio_cb cb, void *data);
eio_req *eio_close     (int fd, int pri, eio_cb cb, void *data);
eio_req *eio_readahead (int fd, off_t offset, size_t length, int pri, eio_cb cb, void *data);
eio_req *eio_seek      (int fd, off_t offset, int whence, int pri, eio_cb cb, void *data);
eio_req *eio_read      (int fd, void *buf, size_t length, off_t offset, int pri, eio_cb cb, void *data);
eio_req *eio_write     (int fd, void *buf, size_t length, off_t offset, int pri, eio_cb cb, void *data);
eio_req *eio_fcntl     (int fd, int cmd, void *arg, int pri, eio_cb cb, void *data);
eio_req *eio_ioctl     (int fd, unsigned long request, void *buf, int pri, eio_cb cb, void *data);
eio_req *eio_fstat     (int fd, int pri, eio_cb cb, void *data); /* stat buffer=ptr2 allocated dynamically */
eio_req *eio_fstatvfs  (int fd, int pri, eio_cb cb, void *data); /* stat buffer=ptr2 allocated dynamically */
eio_req *eio_futime    (int fd, eio_tstamp atime, eio_tstamp mtime, int pri, eio_cb cb, void *data);
eio_req *eio_ftruncate (int fd, off_t offset, int pri, eio_cb cb, void *data);
eio_req *eio_fchmod    (int fd, mode_t mode, int pri, eio_cb cb, void *data);
eio_req *eio_fchown    (int fd, eio_uid_t uid, eio_gid_t gid, int pri, eio_cb cb, void *data);
eio_req *eio_dup2      (int fd, int fd2, int pri, eio_cb cb, void *data);
eio_req *eio_sendfile  (int out_fd, int in_fd, off_t in_offset, size_t length, int pri, eio_cb cb, void *data);
eio_req *eio_open      (const char *path, int flags, mode_t mode, int pri, eio_cb cb, void *data);
eio_req *eio_utime     (const char *path, eio_tstamp atime, eio_tstamp mtime, int pri, eio_cb cb, void *data);
eio_req *eio_truncate  (const char *path, off_t offset, int pri, eio_cb cb, void *data);
eio_req *eio_chown     (const char *path, eio_uid_t uid, eio_gid_t gid, int pri, eio_cb cb, void *data);
eio_req *eio_chmod     (const char *path, mode_t mode, int pri, eio_cb cb, void *data);
eio_req *eio_mkdir     (const char *path, mode_t mode, int pri, eio_cb cb, void *data);
eio_req *eio_readdir   (const char *path, int flags, int pri, eio_cb cb, void *data); /* result=ptr2 allocated dynamically */
eio_req *eio_rmdir     (const char *path, int pri, eio_cb cb, void *data);
eio_req *eio_unlink    (const char *path, int pri, eio_cb cb, void *data);
eio_req *eio_readlink  (const char *path, int pri, eio_cb cb, void *data); /* result=ptr2 allocated dynamically */
eio_req *eio_realpath  (const char *path, int pri, eio_cb cb, void *data); /* result=ptr2 allocated dynamically */
eio_req *eio_stat      (const char *path, int pri, eio_cb cb, void *data); /* stat buffer=ptr2 allocated dynamically */
eio_req *eio_lstat     (const char *path, int pri, eio_cb cb, void *data); /* stat buffer=ptr2 allocated dynamically */
eio_req *eio_statvfs   (const char *path, int pri, eio_cb cb, void *data); /* stat buffer=ptr2 allocated dynamically */
eio_req *eio_mknod     (const char *path, mode_t mode, dev_t dev, int pri, eio_cb cb, void *data);
eio_req *eio_link      (const char *path, const char *new_path, int pri, eio_cb cb, void *data);
eio_req *eio_symlink   (const char *path, const char *new_path, int pri, eio_cb cb, void *data);
eio_req *eio_rename    (const char *path, const char *new_path, int pri, eio_cb cb, void *data);
eio_req *eio_slurp     (const char *path, void *buf, size_t length, off_t offset, int pri, eio_cb cb, void *data);
eio_req *eio_custom    (void (*execute)(eio_req *), int pri, eio_cb cb, void *data);
#endif

/*****************************************************************************/
/* groups */

eio_req *eio_grp       (eio_cb cb, void *data);
void eio_grp_feed      (eio_req *grp, void (*feed)(eio_req *req), int limit);
void eio_grp_limit     (eio_req *grp, int limit);
void eio_grp_add       (eio_req *grp, eio_req *req);
void eio_grp_cancel    (eio_req *grp); /* cancels all sub requests but not the group */

/*****************************************************************************/
/* request api */

/* true if the request was cancelled, useful in the invoke callback */
#define EIO_CANCELLED(req)   ((req)->cancelled)

#define EIO_RESULT(req)      ((req)->result)
/* returns a pointer to the result buffer allocated by eio */
#define EIO_BUF(req)         ((req)->ptr2)
#define EIO_STAT_BUF(req)    ((EIO_STRUCT_STAT    *)EIO_BUF(req))
#define EIO_STATVFS_BUF(req) ((EIO_STRUCT_STATVFS *)EIO_BUF(req))
#define EIO_PATH(req)        ((char *)(req)->ptr1)

/* submit a request for execution */
void eio_submit (eio_req *req);
/* cancel a request as soon fast as possible, if possible */
void eio_cancel (eio_req *req);

/*****************************************************************************/
/* convenience functions */

eio_ssize_t eio_sendfile_sync (int ofd, int ifd, off_t offset, size_t count);
int eio_mlockall_sync (int flags);

#ifdef __cplusplus
}
#endif

#endif

Revision:	1.66
Committed:	Sun Mar 30 05:07:06 2025 UTC (13 months, 2 weeks ago) by root
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.65:	+21 -13 lines
Log Message:	* empty log message *
#	Content
1	/*
2	* libeio API header
3	*
4	* Copyright (c) 2007,2008,2009,2010,2011,2012,2015,2016,2017 Marc Alexander Lehmann <libeio@schmorp.de>
5	* All rights reserved.
6	*
7	* Redistribution and use in source and binary forms, with or without modifica-
8	* tion, are permitted provided that the following conditions are met:
9	*
10	* 1. Redistributions of source code must retain the above copyright notice,
11	* this list of conditions and the following disclaimer.
12	*
13	* 2. Redistributions in binary form must reproduce the above copyright
14	* notice, this list of conditions and the following disclaimer in the
15	* documentation and/or other materials provided with the distribution.
16	*
17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
18	* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MER-
19	* CHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
20	* EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE-
21	* CIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
22	* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
23	* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
24	* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTH-
25	* ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
26	* OF THE POSSIBILITY OF SUCH DAMAGE.
27	*
28	* Alternatively, the contents of this file may be used under the terms of
29	* the GNU General Public License ("GPL") version 2 or any later version,
30	* in which case the provisions of the GPL are applicable instead of
31	* the above. If you wish to allow the use of your version of this file
32	* only under the terms of the GPL and not to allow others to use your
33	* version of this file under the BSD license, indicate your decision
34	* by deleting the provisions above and replace them with the notice
35	* and other provisions required by the GPL. If you do not delete the
36	* provisions above, a recipient may use your version of this file under
37	* either the BSD or the GPL.
38	*/
39
40	#ifndef EIO_H_
41	#define EIO_H_
42
43	#ifdef __cplusplus
44	extern "C" {
45	#endif
46
47	#include <stddef.h>
48	#include <signal.h>
49	#include <sys/types.h>
50
51	typedef struct eio_req eio_req;
52	typedef struct eio_dirent eio_dirent;
53
54	typedef int (eio_cb)(eio_req req);
55
56	#ifndef EIO_REQ_MEMBERS
57	# define EIO_REQ_MEMBERS
58	#endif
59
60	#ifndef EIO_STRUCT_STAT
61	# ifdef _WIN32
62	# define EIO_STRUCT_STAT struct _stati64
63	# define EIO_STRUCT_STATI64
64	# else
65	# define EIO_STRUCT_STAT struct stat
66	# endif
67	#endif
68
69	#ifdef _WIN32
70
71	typedef int eio_uid_t;
72	typedef int eio_gid_t;
73	#ifdef __MINGW32__ /* no intptr_t */
74	typedef ssize_t eio_ssize_t;
75	#else
76	typedef intptr_t eio_ssize_t; /* or SSIZE_T */
77	#endif
78	#if __GNUC__
79	typedef long long eio_ino_t; /* signed for compatibility to msvc */
80	#else
81	typedef __int64 eio_ino_t; /* unsigned not supported by msvc */
82	#endif
83	typedef unsigned int eio_u32_t;
84	typedef int eio_i32_t;
85
86	#else
87
88	typedef uid_t eio_uid_t;
89	typedef gid_t eio_gid_t;
90	typedef ssize_t eio_ssize_t;
91	typedef ino_t eio_ino_t;
92
93	#include <inttypes.h>
94	typedef uint32_t eio_u32_t;
95	typedef int32_t eio_i32_t;
96
97	#endif
98
99	#ifndef EIO_STRUCT_STATVFS
100	# define EIO_STRUCT_STATVFS struct statvfs
101	#endif
102
103	/* managing working directories */
104
105	typedef struct eio_pwd *eio_wd;
106
107	#define EIO_CWD 0 /* the current working directory of the process, guaranteed to be a null pointer */
108	#define EIO_INVALID_WD ((eio_wd)(int)-1) /* failure return for eio_wd_open */
109
110	eio_wd eio_wd_open_sync (eio_wd wd, const char *path);
111	void eio_wd_close_sync (eio_wd wd);
112
113	/* for readdir */
114
115	/* eio_readdir flags */
116	enum
117	{
118	EIO_READDIR_DENTS = 0x01, /* ptr2 contains eio_dirents, not just the (unsorted) names */
119	EIO_READDIR_DIRS_FIRST = 0x02, /* dirents gets sorted into a good stat() ing order to find directories first */
120	EIO_READDIR_STAT_ORDER = 0x04, /* dirents gets sorted into a good stat() ing order to quickly stat all files */
121	EIO_READDIR_FOUND_UNKNOWN = 0x80, /* set by eio_readdir when _ARRAY was set and any TYPE=UNKNOWN's were found /
122
123	EIO_READDIR_CUSTOM1 = 0x100, /* for use by apps */
124	EIO_READDIR_CUSTOM2 = 0x200 /* for use by apps */
125	};
126
127	/* using "typical" values in the hope that the compiler will do something sensible */
128	enum eio_dtype
129	{
130	EIO_DT_UNKNOWN = 0,
131	EIO_DT_FIFO = 1,
132	EIO_DT_CHR = 2,
133	EIO_DT_MPC = 3, /* multiplexed char device (v7+coherent) */
134	EIO_DT_DIR = 4,
135	EIO_DT_NAM = 5, /* xenix special named file */
136	EIO_DT_BLK = 6,
137	EIO_DT_MPB = 7, /* multiplexed block device (v7+coherent) */
138	EIO_DT_REG = 8,
139	EIO_DT_NWK = 9, /* HP-UX network special */
140	EIO_DT_CMP = 9, /* VxFS compressed */
141	EIO_DT_LNK = 10,
142	/* DT_SHAD = 11,*/
143	EIO_DT_SOCK = 12,
144	EIO_DT_DOOR = 13, /* solaris door */
145	EIO_DT_WHT = 14,
146	EIO_DT_MAX = 15 /* highest DT_VALUE ever, hopefully */
147	};
148
149	struct eio_dirent
150	{
151	int nameofs; /* offset of null-terminated name string in (char )req->ptr2 /
152	unsigned short namelen; /* size of filename without trailing 0 */
153	unsigned char type; /* one of EIO_DT_* */
154	signed char score; /* internal use */
155	eio_ino_t inode; /* the inode number, if available, otherwise unspecified */
156	};
157
158	/* eio_msync flags */
159	enum
160	{
161	EIO_MS_ASYNC = 1,
162	EIO_MS_INVALIDATE = 2,
163	EIO_MS_SYNC = 4
164	};
165
166	/* eio_mtouch flags */
167	enum
168	{
169	EIO_MT_MODIFY = 1
170	};
171
172	/* eio_sync_file_range flags */
173	enum
174	{
175	EIO_SYNC_FILE_RANGE_WAIT_BEFORE = 1,
176	EIO_SYNC_FILE_RANGE_WRITE = 2,
177	EIO_SYNC_FILE_RANGE_WAIT_AFTER = 4
178	};
179
180	/* eio_fallocate flags */
181	enum
182	{
183	/* these MUST match the value in linux/falloc.h */
184	EIO_FALLOC_FL_KEEP_SIZE = 0x01,
185	EIO_FALLOC_FL_PUNCH_HOLE = 0x02,
186	EIO_FALLOC_FL_COLLAPSE_RANGE = 0x08,
187	EIO_FALLOC_FL_ZERO_RANGE = 0x10,
188	EIO_FALLOC_FL_INSERT_RANGE = 0x20,
189	EIO_FALLOC_FL_UNSHARE_RANGE = 0x40
190	};
191
192	/* eio_rename flags */
193	enum
194	{
195	/* these MUST match the value in linux/fs.h */
196	EIO_RENAME_NOREPLACE = 1 << 0,
197	EIO_RENAME_EXCHANGE = 1 << 1,
198	EIO_RENAME_WHITEOUT = 1 << 2
199	};
200
201	/* timestamps and differences - feel free to use double in your code directly */
202	#ifndef EIO_TSTAMP_IS_DOUBLE
203	# define EIO_TSTAMP_IS_DOUBLE 1
204	#endif
205	#if EIO_TSTAMP_IS_DOUBLE
206	#define EIO_TSTAMP_NSEC_NOW (-1.)
207	#define EIO_TSTAMP_NSEC_OMIT (-2.)
208	#define EIO_TSTAMP_IS_NOW(ts) ((ts) == -1.)
209	#define EIO_TSTAMP_IS_OMIT(ts) ((ts) == -2.)
210	#define EIO_TSTAMP_IS_NONNEGATIVE(ts) ((ts) >= 0.)
211	tpedef double eio_tstamp;
212	#else
213	#define EIO_TSTAMP_NSEC_NOW (0x3fffffffU)
214	#define EIO_TSTAMP_NSEC_OMIT (0x3ffffffeU)
215	#define EIO_TSTAMP_IS_NOW(ts) ((ts).n == EIO_TSTAMP_NSEC_NOW)
216	#define EIO_TSTAMP_IS_OMIT(ts) ((ts).n == EIO_TSTAMP_NSEC_OMIT)
217	#define EIO_TSTAMP_IS_NONNEGATIVE(ts) ((ts).s >= 0)
218	typedef struct
219	{
220	eio_u32_t s; /* low 32 bits of 34 bit seconds, negative times not supported */
221	eio_u32_t n; /* top 2 bits are bits 33-34 bits of seconds, rest is nanoseconds, or EIO_NSEC_NOW, EIO_NSEC_OMIT */
222	} eio_tstamp;
223	#endif
224
225	/* the eio request structure */
226	enum
227	{
228	EIO_CUSTOM,
229	EIO_WD_OPEN, EIO_WD_CLOSE,
230
231	EIO_CLOSE, EIO_DUP2,
232	EIO_SEEK, EIO_READ, EIO_WRITE, EIO_FCNTL, EIO_IOCTL,
233	EIO_READAHEAD, EIO_SENDFILE, /EIO_COPY_FILE_RANGE,/
234	EIO_FSTAT, EIO_FSTATVFS,
235	EIO_FTRUNCATE, EIO_FUTIME, EIO_FCHMOD, EIO_FCHOWN,
236	EIO_SYNC, EIO_FSYNC, EIO_FDATASYNC, EIO_SYNCFS,
237	EIO_MSYNC, EIO_MTOUCH, EIO_SYNC_FILE_RANGE, EIO_FALLOCATE,
238	EIO_MLOCK, EIO_MLOCKALL,
239	EIO_GROUP, EIO_NOP,
240	EIO_BUSY,
241
242	/* these use wd + ptr1, but are emulated */
243	EIO_REALPATH,
244	EIO_READDIR,
245
246	/* all the following requests use wd + ptr1 as path in xxxat functions */
247	EIO_OPEN,
248	EIO_STAT, EIO_LSTAT, EIO_STATVFS,
249	EIO_TRUNCATE,
250	EIO_UTIME,
251	EIO_CHMOD,
252	EIO_CHOWN,
253	EIO_UNLINK, EIO_RMDIR, EIO_MKDIR, EIO_RENAME,
254	EIO_MKNOD,
255	EIO_LINK, EIO_SYMLINK, EIO_READLINK,
256	EIO_SLURP, /* open + read + close */
257
258	EIO_REQ_TYPE_NUM
259	};
260
261	/* seek whence modes */
262	/* these are guaranteed to hasve the traditional 0, 1, 2 values, */
263	/* so you might as wlel use those */
264	enum
265	{
266	EIO_SEEK_SET = 0,
267	EIO_SEEK_CUR = 1,
268	EIO_SEEK_END = 2
269	};
270
271
272	/* mlockall constants */
273	enum
274	{
275	EIO_MCL_CURRENT = 1,
276	EIO_MCL_FUTURE = 2,
277	EIO_MCL_ONFAULT = 4
278	};
279
280	/* request priorities */
281
282	enum {
283	EIO_PRI_MIN = -4,
284	EIO_PRI_MAX = 4,
285	EIO_PRI_DEFAULT = 0
286	};
287
288	/* eio request structure */
289	/* this structure is mostly read-only */
290	/* when initialising it, all members must be zero-initialised */
291	struct eio_req
292	{
293	eio_req volatile next; / private ETP */
294
295	eio_wd wd; /* all applicable requests: working directory of pathname, old name; wd_open: return wd */
296
297	eio_ssize_t result; /* result of syscall, e.g. result = read (... */
298	off_t offs; /* read, write, truncate, readahead, sync_file_range, fallocate, slurp: file offset, mknod: dev_t */
299	size_t size; /* read, write, readahead, sendfile, msync, mlock, sync_file_range, fallocate, slurp: length */
300	void ptr1; / all applicable requests: pathname, old name, readdir: optional eio_dirents */
301	void ptr2; / all applicable requests: new name or memory buffer; readdir: name strings */
302	eio_tstamp nv1; /* utime, futime: atime; busy: sleep time */
303	eio_tstamp nv2; /* utime, futime: mtime */
304
305	int int1; /* all applicable requests: file descriptor; sendfile: output fd; open, msync, mlockall, readdir: flags */
306	long int2; /* chown, fchown: uid; sendfile: input fd; open, chmod, mkdir, mknod: file mode, seek: whence, fcntl, ioctl: request, sync_file_range, fallocate, rename: flags */
307	long int3; /* chown, fchown: gid; rename, link: working directory of new name */
308	int errorno; /* errno value on syscall return */
309
310	unsigned char flags; /* private */
311
312	signed char type;/* EIO_xxx constant ETP */
313	signed char pri; /* the priority ETP */
314	#if __i386 \|\| __amd64
315	unsigned char cancelled; /* ETP */
316	#else
317	sig_atomic_t cancelled; /* ETP */
318	#endif
319
320	void *data;
321	eio_cb finish;
322	void (destroy)(eio_req req); /* called when request no longer needed */
323	void (feed)(eio_req req); /* only used for group requests */
324
325	EIO_REQ_MEMBERS
326
327	eio_req grp, grp_prev, grp_next, grp_first; /* private ETP */
328	};
329
330	/* _private_ request flags */
331	enum {
332	EIO_FLAG_PTR1_FREE = 0x01, /* need to free(ptr1) */
333	EIO_FLAG_PTR2_FREE = 0x02, /* need to free(ptr2) */
334	};
335
336	/* undocumented/unsupported/private helper */
337	/void eio_page_align (void addr, size_t length);*/
338
339	/* returns < 0 on error, errno set
340	* need_poll, if non-zero, will be called when results are available
341	* and eio_poll_cb needs to be invoked (it MUST NOT call eio_poll_cb itself).
342	* done_poll is called when the need to poll is gone.
343	*/
344	int eio_init (void (want_poll)(void), void (done_poll)(void));
345
346	/* must be called regularly to handle pending requests */
347	/* returns 0 if all requests were handled, -1 if not, or the value of EIO_FINISH if != 0 */
348	int eio_poll (void);
349
350	/* stop polling if poll took longer than duration seconds */
351	void eio_set_max_poll_time (double nseconds);
352	/* do not handle more then count requests in one call to eio_poll_cb */
353	void eio_set_max_poll_reqs (unsigned int nreqs);
354
355	/* set minimum required number
356	* maximum wanted number
357	* or maximum idle number of threads */
358	void eio_set_min_parallel (unsigned int nthreads);
359	void eio_set_max_parallel (unsigned int nthreads);
360	void eio_set_max_idle (unsigned int nthreads);
361	void eio_set_idle_timeout (unsigned int seconds);
362
363	unsigned int eio_nreqs (void); /* number of requests in-flight */
364	unsigned int eio_nready (void); /* number of not-yet handled requests */
365	unsigned int eio_npending (void); /* number of finished but unhandled requests */
366	unsigned int eio_nthreads (void); /* number of worker threads in use currently */
367
368	/*****************************************************************************/
369	/* convenience wrappers */
370	/* these do not expose advanced syscalls and directory fds */
371
372	#ifndef EIO_NO_WRAPPERS
373	eio_req eio_wd_open (const char path, int pri, eio_cb cb, void data); / result=wd */
374	eio_req eio_wd_close (eio_wd wd, int pri, eio_cb cb, void data);
375	eio_req eio_nop (int pri, eio_cb cb, void data); /* does nothing except go through the whole process */
376	eio_req eio_busy (eio_tstamp delay, int pri, eio_cb cb, void data); /* ties a thread for this long, simulating busyness */
377	eio_req eio_sync (int pri, eio_cb cb, void data);
378	eio_req eio_fsync (int fd, int pri, eio_cb cb, void data);
379	eio_req eio_fdatasync (int fd, int pri, eio_cb cb, void data);
380	eio_req eio_syncfs (int fd, int pri, eio_cb cb, void data);
381	eio_req eio_msync (void addr, size_t length, int flags, int pri, eio_cb cb, void *data);
382	eio_req eio_mtouch (void addr, size_t length, int flags, int pri, eio_cb cb, void *data);
383	eio_req eio_mlock (void addr, size_t length, int pri, eio_cb cb, void *data);
384	eio_req eio_mlockall (int flags, int pri, eio_cb cb, void data);
385	eio_req eio_sync_file_range (int fd, off_t offset, size_t nbytes, unsigned int flags, int pri, eio_cb cb, void data);
386	eio_req eio_fallocate (int fd, int mode, off_t offset, size_t len, int pri, eio_cb cb, void data);
387	eio_req eio_close (int fd, int pri, eio_cb cb, void data);
388	eio_req eio_readahead (int fd, off_t offset, size_t length, int pri, eio_cb cb, void data);
389	eio_req eio_seek (int fd, off_t offset, int whence, int pri, eio_cb cb, void data);
390	eio_req eio_read (int fd, void buf, size_t length, off_t offset, int pri, eio_cb cb, void *data);
391	eio_req eio_write (int fd, void buf, size_t length, off_t offset, int pri, eio_cb cb, void *data);
392	eio_req eio_fcntl (int fd, int cmd, void arg, int pri, eio_cb cb, void *data);
393	eio_req eio_ioctl (int fd, unsigned long request, void buf, int pri, eio_cb cb, void *data);
394	eio_req eio_fstat (int fd, int pri, eio_cb cb, void data); /* stat buffer=ptr2 allocated dynamically */
395	eio_req eio_fstatvfs (int fd, int pri, eio_cb cb, void data); /* stat buffer=ptr2 allocated dynamically */
396	eio_req eio_futime (int fd, eio_tstamp atime, eio_tstamp mtime, int pri, eio_cb cb, void data);
397	eio_req eio_ftruncate (int fd, off_t offset, int pri, eio_cb cb, void data);
398	eio_req eio_fchmod (int fd, mode_t mode, int pri, eio_cb cb, void data);
399	eio_req eio_fchown (int fd, eio_uid_t uid, eio_gid_t gid, int pri, eio_cb cb, void data);
400	eio_req eio_dup2 (int fd, int fd2, int pri, eio_cb cb, void data);
401	eio_req eio_sendfile (int out_fd, int in_fd, off_t in_offset, size_t length, int pri, eio_cb cb, void data);
402	eio_req eio_open (const char path, int flags, mode_t mode, int pri, eio_cb cb, void *data);
403	eio_req eio_utime (const char path, eio_tstamp atime, eio_tstamp mtime, int pri, eio_cb cb, void *data);
404	eio_req eio_truncate (const char path, off_t offset, int pri, eio_cb cb, void *data);
405	eio_req eio_chown (const char path, eio_uid_t uid, eio_gid_t gid, int pri, eio_cb cb, void *data);
406	eio_req eio_chmod (const char path, mode_t mode, int pri, eio_cb cb, void *data);
407	eio_req eio_mkdir (const char path, mode_t mode, int pri, eio_cb cb, void *data);
408	eio_req eio_readdir (const char path, int flags, int pri, eio_cb cb, void data); / result=ptr2 allocated dynamically */
409	eio_req eio_rmdir (const char path, int pri, eio_cb cb, void *data);
410	eio_req eio_unlink (const char path, int pri, eio_cb cb, void *data);
411	eio_req eio_readlink (const char path, int pri, eio_cb cb, void data); / result=ptr2 allocated dynamically */
412	eio_req eio_realpath (const char path, int pri, eio_cb cb, void data); / result=ptr2 allocated dynamically */
413	eio_req eio_stat (const char path, int pri, eio_cb cb, void data); / stat buffer=ptr2 allocated dynamically */
414	eio_req eio_lstat (const char path, int pri, eio_cb cb, void data); / stat buffer=ptr2 allocated dynamically */
415	eio_req eio_statvfs (const char path, int pri, eio_cb cb, void data); / stat buffer=ptr2 allocated dynamically */
416	eio_req eio_mknod (const char path, mode_t mode, dev_t dev, int pri, eio_cb cb, void *data);
417	eio_req eio_link (const char path, const char new_path, int pri, eio_cb cb, void data);
418	eio_req eio_symlink (const char path, const char new_path, int pri, eio_cb cb, void data);
419	eio_req eio_rename (const char path, const char new_path, int pri, eio_cb cb, void data);
420	eio_req eio_slurp (const char path, void buf, size_t length, off_t offset, int pri, eio_cb cb, void data);
421	eio_req eio_custom (void (execute)(eio_req ), int pri, eio_cb cb, void data);
422	#endif
423
424	/*****************************************************************************/
425	/* groups */
426
427	eio_req eio_grp (eio_cb cb, void data);
428	void eio_grp_feed (eio_req grp, void (feed)(eio_req *req), int limit);
429	void eio_grp_limit (eio_req *grp, int limit);
430	void eio_grp_add (eio_req grp, eio_req req);
431	void eio_grp_cancel (eio_req grp); / cancels all sub requests but not the group */
432
433	/*****************************************************************************/
434	/* request api */
435
436	/* true if the request was cancelled, useful in the invoke callback */
437	#define EIO_CANCELLED(req) ((req)->cancelled)
438
439	#define EIO_RESULT(req) ((req)->result)
440	/* returns a pointer to the result buffer allocated by eio */
441	#define EIO_BUF(req) ((req)->ptr2)
442	#define EIO_STAT_BUF(req) ((EIO_STRUCT_STAT *)EIO_BUF(req))
443	#define EIO_STATVFS_BUF(req) ((EIO_STRUCT_STATVFS *)EIO_BUF(req))
444	#define EIO_PATH(req) ((char *)(req)->ptr1)
445
446	/* submit a request for execution */
447	void eio_submit (eio_req *req);
448	/* cancel a request as soon fast as possible, if possible */
449	void eio_cancel (eio_req *req);
450
451	/*****************************************************************************/
452	/* convenience functions */
453
454	eio_ssize_t eio_sendfile_sync (int ofd, int ifd, off_t offset, size_t count);
455	int eio_mlockall_sync (int flags);
456
457	#ifdef __cplusplus
458	}
459	#endif
460
461	#endif
462