RPM Package Manager, CVS Repository http://rpm5.org/cvs/ ____________________________________________________________________________
Server: rpm5.org Name: Jeff Johnson Root: /v/rpm/cvs Email: [email protected] Module: rpm Date: 14-Jun-2017 00:25:23 Branch: rpm-5_4 Handle: 2017061322252201 Added files: (Branch: rpm-5_4) rpm/rpmio rpmeio.c rpmeio.h Modified files: (Branch: rpm-5_4) rpm CHANGES configure.ac rpm/rpmio Makefile.am librpmio.vers poptIO.c rpmio.c tmq.c Log: - rpmeio: stub in libeio wrapper(s). Summary: Revision Changes Path 1.3501.2.577+1 -0 rpm/CHANGES 2.472.2.175 +76 -0 rpm/configure.ac 1.293.2.91 +19 -5 rpm/rpmio/Makefile.am 2.199.2.91 +61 -0 rpm/rpmio/librpmio.vers 1.94.2.39 +3 -0 rpm/rpmio/poptIO.c 1.1.2.1 +607 -0 rpm/rpmio/rpmeio.c 1.1.2.1 +248 -0 rpm/rpmio/rpmeio.h 1.230.2.60 +1 -0 rpm/rpmio/rpmio.c 1.1.2.22 +268 -156 rpm/rpmio/tmq.c ____________________________________________________________________________ patch -p0 <<'@@ .' Index: rpm/CHANGES ============================================================================ $ cvs diff -u -r1.3501.2.576 -r1.3501.2.577 CHANGES --- rpm/CHANGES 12 Jun 2017 06:54:06 -0000 1.3501.2.576 +++ rpm/CHANGES 13 Jun 2017 22:25:22 -0000 1.3501.2.577 @@ -1,4 +1,5 @@ 5.4.17 -> 5.4.18: + - jbj: rpmeio: stub in libeio wrapper(s). - jbj: rpmev: stub in libev wrapper(s). - jbj: rpmio: add rpmioB2N/rpmioN2B to display/set bit soup. - jbj: rpmio: rename rpmio{Fts,Open}Flags. @@ . patch -p0 <<'@@ .' Index: rpm/configure.ac ============================================================================ $ cvs diff -u -r2.472.2.174 -r2.472.2.175 configure.ac --- rpm/configure.ac 12 Jun 2017 06:54:06 -0000 2.472.2.174 +++ rpm/configure.ac 13 Jun 2017 22:25:22 -0000 2.472.2.175 @@ -5181,6 +5181,82 @@ AC_CHECK_FUNCS(ev_version_minor) ], []) +dnl # libeio +RPM_CHECK_LIB( + [Libeio], [libeio], + [ev-eio], [eio_init], [eio.h], + [no,external:none], [], + [ + AC_CHECK_FUNCS(eio_busy) + AC_CHECK_FUNCS(eio_cancel) + AC_CHECK_FUNCS(eio_chmod) + AC_CHECK_FUNCS(eio_chown) + AC_CHECK_FUNCS(eio_close) + AC_CHECK_FUNCS(eio_custom) + AC_CHECK_FUNCS(eio_dup2) + AC_CHECK_FUNCS(eio_fallocate) + AC_CHECK_FUNCS(eio_fchmod) + AC_CHECK_FUNCS(eio_fchown) + AC_CHECK_FUNCS(eio_fdatasync) + AC_CHECK_FUNCS(eio_fstat) + AC_CHECK_FUNCS(eio_fstatvfs) + AC_CHECK_FUNCS(eio_fsync) + AC_CHECK_FUNCS(eio_ftruncate) + AC_CHECK_FUNCS(eio_futime) + AC_CHECK_FUNCS(eio_grp) + AC_CHECK_FUNCS(eio_grp_add) + AC_CHECK_FUNCS(eio_grp_cancel) + AC_CHECK_FUNCS(eio_grp_feed) + AC_CHECK_FUNCS(eio_grp_limit) + AC_CHECK_FUNCS(eio_init) + AC_CHECK_FUNCS(eio_link) + AC_CHECK_FUNCS(eio_lstat) + AC_CHECK_FUNCS(eio_mkdir) + AC_CHECK_FUNCS(eio_mknod) + AC_CHECK_FUNCS(eio_mlock) + AC_CHECK_FUNCS(eio_mlockall) + AC_CHECK_FUNCS(eio_msync) + AC_CHECK_FUNCS(eio_mtouch) + AC_CHECK_FUNCS(eio_nop) + AC_CHECK_FUNCS(eio_npending) + AC_CHECK_FUNCS(eio_nready) + AC_CHECK_FUNCS(eio_nreqs) + AC_CHECK_FUNCS(eio_nthreads) + AC_CHECK_FUNCS(eio_open) + AC_CHECK_FUNCS(eio_poll) + AC_CHECK_FUNCS(eio_read) + AC_CHECK_FUNCS(eio_readahead) + AC_CHECK_FUNCS(eio_readdir) + AC_CHECK_FUNCS(eio_readlink) + AC_CHECK_FUNCS(eio_realpath) + AC_CHECK_FUNCS(eio_rename) + AC_CHECK_FUNCS(eio_rmdir) + AC_CHECK_FUNCS(eio_seek) + AC_CHECK_FUNCS(eio_sendfile) + AC_CHECK_FUNCS(eio_sendfile_sync) + AC_CHECK_FUNCS(eio_set_idle_timeout) + AC_CHECK_FUNCS(eio_set_max_idle) + AC_CHECK_FUNCS(eio_set_max_parallel) + AC_CHECK_FUNCS(eio_set_max_poll_reqs) + AC_CHECK_FUNCS(eio_set_max_poll_time) + AC_CHECK_FUNCS(eio_set_min_parallel) + AC_CHECK_FUNCS(eio_stat) + AC_CHECK_FUNCS(eio_statvfs) + AC_CHECK_FUNCS(eio_submit) + AC_CHECK_FUNCS(eio_symlink) + AC_CHECK_FUNCS(eio_sync) + AC_CHECK_FUNCS(eio_sync_file_range) + AC_CHECK_FUNCS(eio_syncfs) + AC_CHECK_FUNCS(eio_truncate) + AC_CHECK_FUNCS(eio_unlink) + AC_CHECK_FUNCS(eio_utime) + AC_CHECK_FUNCS(eio_wd_close) + AC_CHECK_FUNCS(eio_wd_close_sync) + AC_CHECK_FUNCS(eio_wd_open) + AC_CHECK_FUNCS(eio_wd_open_sync) + AC_CHECK_FUNCS(eio_write) + ], []) + dnl # Libuv RPM_CHECK_LIB( [Libuv], [libuv], @@ . patch -p0 <<'@@ .' Index: rpm/rpmio/Makefile.am ============================================================================ $ cvs diff -u -r1.293.2.90 -r1.293.2.91 Makefile.am --- rpm/rpmio/Makefile.am 12 Jun 2017 06:54:06 -0000 1.293.2.90 +++ rpm/rpmio/Makefile.am 13 Jun 2017 22:25:23 -0000 1.293.2.91 @@ -4,6 +4,10 @@ LINT = splint MCCABE = pmccabe +PAHOLE = pahole + +.c.xml: + castxml --castxml-cc-gnu-c $(COMPILE) -o $@ $< SUBDIRS = auto # tests @@ -156,9 +160,9 @@ salsa10.h salsa20.h shabal.h shavite3.h simd.h skein.h tib3.h tiger.h \ pcrs.h rpmacl.h rpmaio.h rpmasn.h rpmaug.h rpmbag.h rpmbc.h rpmbz.h \ rpmcap.h rpmcdsa.h rpmct.h rpmcudf.h rpmcvs.h rpmdate.h rpmdav.h \ - rpmdir.h rpmev.h rpmficl.h rpmgc.h rpmgfs.h rpmgit.h rpmhash.h \ - rpmhkp.h rpmhook.h rpmio_internal.h rpmjni.h rpmjs.h rpmjsio.h \ - rpmkeyring.h rpmku.h rpmltc.h rpmlua.h \ + rpmdir.h rpmeio.h rpmev.h rpmficl.h rpmgc.h rpmgfs.h rpmgit.h \ + rpmhash.h rpmhkp.h rpmhook.h rpmio_internal.h rpmjni.h rpmjs.h \ + rpmjsio.h rpmkeyring.h rpmku.h rpmltc.h rpmlua.h \ rpmmqtt.h rpmmrb.h rpmmsq.h rpmnix.h rpmnss.h \ rpmodbc.h rpmperl.h rpmpgp.h rpmpython.h rpmruby.h rpmsed.h rpmsm.h rpmsp.h \ rpmsq.h rpmsql.h rpmsquirrel.h rpmssl.h rpmsvn.h rpmsx.h rpmsyck.h \ @@ -213,6 +217,7 @@ rpmdate.c \ rpmdav.c \ rpmdir.c \ + rpmeio.c \ rpmev.c \ rpmficl.c \ rpmgc.c \ @@ -392,9 +397,18 @@ lint_rpmtar: $(LINT) -f .splintrc_rpmtar $(DEFS) $(INCLUDES) rpmtar.c -.PHONY: mccabe +.PHONY: mccabe mccabe: - $(MCCABE) $(librpmio_la_SOURCES) | sort -n -r | head -n 20 + @echo "|mmccabe|mccabe |#stmts |lineno |LOC |file(line): function" + @echo "=============================================================" + @$(MCCABE) $(librpmio_la_SOURCES) | sort -n -r | head -n 40 + + +.PHONY: pahole +pahole: + for F in $(librpmio_la_OBJECTS); do \ + $(PAHOLE) -PR $$(basename $$F .lo).o 2>/dev/null; \ + done | sort -u .PHONY: lcov-reset # run lcov from scratch, always lcov-reset: @@ . patch -p0 <<'@@ .' Index: rpm/rpmio/librpmio.vers ============================================================================ $ cvs diff -u -r2.199.2.90 -r2.199.2.91 librpmio.vers --- rpm/rpmio/librpmio.vers 13 Jun 2017 00:00:45 -0000 2.199.2.90 +++ rpm/rpmio/librpmio.vers 13 Jun 2017 22:25:23 -0000 2.199.2.91 @@ -473,6 +473,67 @@ vrpmMCExpand; rpmMCExpand; rpmMCExpandNumeric; + _rpmeio_debug; + rpmeioDumpREQ; + rpmeioNew; + rpmeioReqType; + rpmeioPipe; + rpmeioPollWant; + rpmeioPollDone; + rpmeioStart; + rpmeioLoop; + rpmeioCB; + rpmeioCB_readdir; + rpmeioCB_stat; + rpmeioCB_read; + rpmeioLastFdno; + rpmeioCB_open; + Eio_wd_open; + Eio_wd_close; + Eio_nop; + Eio_busy; + Eio_sync; + Eio_fsync; + Eio_fdatasync; + Eio_syncfs; + Eio_msync; + Eio_mtouch; + Eio_mlock; + Eio_mlockall; + Eio_sync_file_range; + Eio_fallocate; + Eio_close; + Eio_readahead; + Eio_seek; + Eio_read; + Eio_write; + Eio_fstat; + Eio_fstatvfs; + Eio_futime; + Eio_ftruncate; + Eio_fchmod; + Eio_fchown; + Eio_dup2; + Eio_sendfile; + Eio_open; + Eio_utime; + Eio_truncate; + Eio_chown; + Eio_chmod; + Eio_mkdir; + Eio_readdir; + Eio_rmdir; + Eio_unlink; + Eio_readlink; + Eio_realpath; + Eio_stat; + Eio_lstat; + Eio_statvfs; + Eio_mknod; + Eio_link; + Eio_symlink; + Eio_rename; + Eio_custom; _rpmev_debug; rpmevDump; rpmevNew; @@ . patch -p0 <<'@@ .' Index: rpm/rpmio/poptIO.c ============================================================================ $ cvs diff -u -r1.94.2.38 -r1.94.2.39 poptIO.c --- rpm/rpmio/poptIO.c 13 Jun 2017 00:00:45 -0000 1.94.2.38 +++ rpm/rpmio/poptIO.c 13 Jun 2017 22:25:23 -0000 1.94.2.39 @@ -51,6 +51,7 @@ #include <rpmct.h> #include <rpmcudf.h> #include <rpmcvs.h> +#include <rpmeio.h> #include <rpmev.h> #include <rpmficl.h> #include <rpmgit.h> @@ -1052,6 +1053,8 @@ N_("Debug sed(1)"), NULL}, { "rpmcudfdebug", '\0', POPT_ARG_VAL|POPT_ARGFLAG_DOC_HIDDEN, &_rpmcudf_debug, -1, N_("Debug embedded CUDF parser"), NULL}, + { "rpmeiodebug", '\0', POPT_ARG_VAL|POPT_ARGFLAG_DOC_HIDDEN, &_rpmeio_debug, -1, + N_("Debug libev"), NULL}, { "rpmevdebug", '\0', POPT_ARG_VAL|POPT_ARGFLAG_DOC_HIDDEN, &_rpmev_debug, -1, N_("Debug libev"), NULL}, { "rpmficldebug", '\0', POPT_ARG_VAL|POPT_ARGFLAG_DOC_HIDDEN, &_rpmficl_debug, -1, @@ . patch -p0 <<'@@ .' Index: rpm/rpmio/rpmeio.c ============================================================================ $ cvs diff -u -r0 -r1.1.2.1 rpmeio.c --- /dev/null 2017-06-14 00:22:00.000000000 +0200 +++ rpmeio.c 2017-06-14 00:25:23.555624070 +0200 @@ -0,0 +1,607 @@ +#include "system.h" + +#include <rpmio.h> + +#define _RPMEIO_INTERNAL +#include <rpmeio.h> + +#include "debug.h" + +int _rpmeio_debug = -1; + +#define SPEW(_fmt, ...) \ + if (_rpmeio_debug || _rpmio_debug) \ + fprintf(stderr, _fmt, __VA_ARGS__) + +/*==============================================================*/ +const char * rpmeioReqType(int reqtype) +{ + switch (reqtype) { + case EIO_CUSTOM: return("EIO_CUSTOM"); + case EIO_WD_OPEN: return("EIO_WD_OPEN"); + case EIO_WD_CLOSE: return("EIO_WD_CLOSE"); + case EIO_CLOSE: return("EIO_CLOSE"); + case EIO_DUP2: return("EIO_DUP2"); + case EIO_SEEK: return("EIO_SEEK"); + case EIO_READ: return("EIO_READ"); + case EIO_WRITE: return("EIO_WRITE"); + case EIO_READAHEAD: return("EIO_READAHEAD"); + case EIO_SENDFILE: return("EIO_SENDFILE"); + case EIO_FSTAT: return("EIO_FSTAT"); + case EIO_FSTATVFS: return("EIO_FSTATVFS"); + case EIO_FTRUNCATE: return("EIO_FTRUNCATE"); + case EIO_FUTIME: return("EIO_FUTIME"); + case EIO_FCHMOD: return("EIO_FCHMOD"); + case EIO_FCHOWN: return("EIO_FCHOWN"); + case EIO_SYNC: return("EIO_SYNC"); + case EIO_FSYNC: return("EIO_FSYNC"); + case EIO_FDATASYNC: return("EIO_FDATASYNC"); + case EIO_SYNCFS: return("EIO_SYNCFS"); + case EIO_MSYNC: return("EIO_MSYNC"); + case EIO_MTOUCH: return("EIO_MTOUCH"); + case EIO_SYNC_FILE_RANGE: return("EIO_SYNC_FILE_RANGE"); + case EIO_FALLOCATE: return("EIO_FALLOCATE"); + case EIO_MLOCK: return("EIO_MLOCK"); + case EIO_MLOCKALL: return("EIO_MLOCKALL"); + case EIO_GROUP: return("EIO_GROUP"); + case EIO_NOP: return("EIO_NOP"); + case EIO_BUSY: return("EIO_BUSY"); + case EIO_REALPATH: return("EIO_REALPATH"); + case EIO_READDIR: return("EIO_READDIR"); + case EIO_OPEN: return("EIO_OPEN"); + case EIO_STAT: return("EIO_STAT"); + case EIO_LSTAT: return("EIO_LSTAT"); + case EIO_STATVFS: return("EIO_STATVFS"); + case EIO_TRUNCATE: return("EIO_TRUNCATE"); + case EIO_UTIME: return("EIO_UTIME"); + case EIO_CHMOD: return("EIO_CHMOD"); + case EIO_CHOWN: return("EIO_CHOWN"); + case EIO_UNLINK: return("EIO_UNLINK"); + case EIO_RMDIR: return("EIO_RMDIR"); + case EIO_MKDIR: return("EIO_MKDIR"); + case EIO_RENAME: return("EIO_RENAME"); + case EIO_MKNOD: return("EIO_MKNOD"); + case EIO_LINK: return("EIO_LINK"); + case EIO_SYMLINK: return("EIO_SYMLINK"); + case EIO_READLINK: return("EIO_READLINK"); + } + return ("?EIO_TYPE?"); +} + +void rpmeioDumpREQ(const char *msg, eio_req * req, FILE *fp) +{ + if (fp == NULL) fp = stderr; + if (msg) fprintf(stderr, "========================== %s(%p)\n", msg, req); + + if (req) { + +#define PRINT(_fmt, _foo) \ + { fprintf(fp, "%25s: %"#_fmt"\n", #_foo, req->_foo); } + if (req->next) + PRINT(p, next); + if (req->wd) + PRINT(p, wd); + + if (req->result) + PRINT(zd, result); + if (req->offs) + PRINT(ld, offs); + if (req->size) + PRINT(zu, size); + + if (req->ptr1) + PRINT(p, ptr1); + if (req->ptr2) + PRINT(p, ptr2); + + if (req->nv1 != 0.0) + PRINT(f, nv1); + if (req->nv2 != 0.0) + PRINT(f, nv2); + + if (req->int1) + PRINT(d, int1); + if (req->int2) + PRINT(ld, int2); + if (req->int3) + PRINT(ld, int3); + +#ifdef DYING + PRINT(d, errorno); +#else + if (req->errorno) + fprintf(fp, "%25s: %d %s\n", "errorno", req->errorno, strerror(req->errorno)); +#endif + +#ifdef DYING + PRINT(hhx, type); +#else + fprintf(fp, "%25s: %d %s data %s\n", "type", req->type, REQ_TYPE(req), (char *)REQ_DATA(req)); +#endif + +#ifdef NOTYET + PRINT(hhx, cancelled); + PRINT(hhx, flags); + PRINT(hhx, pri); + + PRINT(p, data); + PRINT(p, finish); + PRINT(p, destroy); + if (req->feed) + PRINT(p, feed); + + if (req->grp) + PRINT(p, grp); + if (req->grp_prev) + PRINT(p, grp_prev); + if (req->grp_next) + PRINT(p, grp_next); + if (req->grp_first) + PRINT(p, grp_first); +#endif /* NOTYET */ +#undef PRINT + + } +} + +/*==============================================================*/ +int rpmeioPipe[2]; + +void rpmeioPollWant(void) +{ + char dummy; + ssize_t nw = write(rpmeioPipe[1], &dummy, 1); +SPEW("<-- %s() nw %zd\n)\n", __FUNCTION__, nw); +} + +void rpmeioPollDone(void) +{ + char dummy; + ssize_t nr = read(rpmeioPipe[0], &dummy, 1); +SPEW("<-- %s() nr %zd\n)\n", __FUNCTION__, nr); +} + +int rpmeioStart(void) +{ + int rc = pipe(rpmeioPipe); + + if (!rc) + rc = eio_init(rpmeioPollWant, rpmeioPollDone); + +SPEW("<-- %s() rc %d pipe [%d,%d]\n", __FUNCTION__, rc, rpmeioPipe[0], rpmeioPipe[1]); + return rc; +} + +void rpmeioLoop(void) +{ + int polled = 0; + int xx; + + struct pollfd pfd; + pfd.fd = rpmeioPipe[0]; + pfd.events = POLLIN; + +SPEW("==> %s()\n", __FUNCTION__); + while (eio_nreqs()) { + xx = poll(&pfd, 1, -1); + polled = eio_poll(); + } +SPEW("<== %s() polled %d\n", __FUNCTION__, polled); +} + +int rpmeioCB(eio_req * req) +{ +rpmeioDumpREQ(__FUNCTION__, req, NULL); +SPEW("--> %s(%s|%p) res %ld\n", __FUNCTION__, REQ_TYPE(req), REQ_DATA(req), EIO_RESULT(req)); + + if (req->result < 0) + abort(); + + return 0; +} + +int rpmeioCB_readdir(eio_req * req) +{ +rpmeioDumpREQ(__FUNCTION__, req, NULL); + char *buf = (char *) EIO_BUF(req); + +SPEW("--> %s(%s|%p) res %ld\n", __FUNCTION__, REQ_TYPE(req), REQ_DATA(req), EIO_RESULT(req)); + + if (EIO_RESULT(req) < 0) + return 0; + + while (EIO_RESULT(req)--) { + SPEW("\treaddir = <%s>\n", buf); + buf += strlen(buf) + 1; + } + + return 0; +} + +int rpmeioCB_stat(eio_req * req) +{ +rpmeioDumpREQ(__FUNCTION__, req, NULL); + struct stat *buf = EIO_STAT_BUF(req); + +SPEW("--> %s(%s|%p) res %ld\n", __FUNCTION__, REQ_TYPE(req), REQ_DATA(req), EIO_RESULT(req)); + if (req->type == EIO_FSTAT) { + SPEW("\tfstat = %ld\n", EIO_RESULT(req)); + } else { + SPEW("\tstat(%s) = %ld\n", EIO_PATH(req), EIO_RESULT(req)); + } + + if (!EIO_RESULT(req)) + SPEW("\tstat size %ld perm 0%o\n", buf->st_size, + buf->st_mode & 0777); + + return 0; +} + +int rpmeioCB_read(eio_req * req) +{ +rpmeioDumpREQ(__FUNCTION__, req, NULL); + unsigned char *buf = (unsigned char *) EIO_BUF(req); + +SPEW("--> %s(%s|%p) res %ld (%02x%02x%02x%02x %02x%02x%02x%02x)\n", + __FUNCTION__, REQ_TYPE(req), REQ_DATA(req), EIO_RESULT(req), + buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6], buf[7]); + + return 0; +} + +int rpmeioLastFdno; + +int rpmeioCB_open(eio_req * req) +{ +rpmeioDumpREQ(__FUNCTION__, req, NULL); +SPEW("--> %s(%s|%p) res %ld\n", __FUNCTION__, REQ_TYPE(req), REQ_DATA(req), EIO_RESULT(req)); + + rpmeioLastFdno = EIO_RESULT(req); + + return 0; +} + +/*==============================================================*/ +eio_req *Eio_wd_open (const char *path, int pri, eio_cb cb, void *data) +{ + eio_req * req = eio_wd_open(path, pri, cb, data); +SPEW("<-- %s(%s|%p) req %p\n", __FUNCTION__, REQ_TYPE(req), REQ_DATA(req), req); + return req; +} + +eio_req *Eio_wd_close (eio_wd wd, int pri, eio_cb cb, void *data) +{ + eio_req *req = eio_wd_close(wd, pri, cb, data); +SPEW("<-- %s(%s|%p) req %p\n", __FUNCTION__, REQ_TYPE(req), REQ_DATA(req), req); + return req; +} + +eio_req *Eio_nop (int pri, eio_cb cb, void *data) +{ + eio_req *req = eio_nop(pri,cb, data); +SPEW("<-- %s(%s|%p) req %p\n", __FUNCTION__, REQ_TYPE(req), REQ_DATA(req), req); + return req; +} + +eio_req *Eio_busy (eio_tstamp delay, int pri, eio_cb cb, void *data) +{ + eio_req *req = eio_busy(delay, pri, cb, data); +SPEW("<-- %s(%s|%p) req %p\n", __FUNCTION__, REQ_TYPE(req), REQ_DATA(req), req); + return req; +} + +eio_req *Eio_sync (int pri, eio_cb cb, void *data) +{ + eio_req *req = eio_sync(pri, cb, data); +SPEW("<-- %s(%s|%p) req %p\n", __FUNCTION__, REQ_TYPE(req), REQ_DATA(req), req); + return req; +} + +eio_req *Eio_fsync (int fd, int pri, eio_cb cb, void *data) +{ + eio_req *req = eio_fsync(fd, pri, cb, data); +SPEW("<-- %s(%s|%p) req %p\n", __FUNCTION__, REQ_TYPE(req), REQ_DATA(req), req); + return req; +} + +eio_req *Eio_fdatasync (int fd, int pri, eio_cb cb, void *data) +{ + eio_req *req = eio_fdatasync(fd, pri, cb, data); +SPEW("<-- %s(%s|%p) req %p\n", __FUNCTION__, REQ_TYPE(req), REQ_DATA(req), req); + return req; +} + +eio_req *Eio_syncfs (int fd, int pri, eio_cb cb, void *data) +{ + eio_req *req = eio_syncfs(fd, pri, cb, data); +SPEW("<-- %s(%s|%p) req %p\n", __FUNCTION__, REQ_TYPE(req), REQ_DATA(req), req); + return req; +} + +eio_req *Eio_msync (void *addr, size_t length, int flags, int pri, eio_cb cb, void *data) +{ + eio_req *req = eio_msync(addr, length, flags, pri, cb, data); +SPEW("<-- %s(%s|%p) req %p\n", __FUNCTION__, REQ_TYPE(req), REQ_DATA(req), req); + return req; +} + +eio_req *Eio_mtouch (void *addr, size_t length, int flags, int pri, eio_cb cb, void *data) +{ + eio_req *req = eio_mtouch(addr, length, flags, pri, cb, data); +SPEW("<-- %s(%s|%p) req %p\n", __FUNCTION__, REQ_TYPE(req), REQ_DATA(req), req); + return req; +} + +eio_req *Eio_mlock (void *addr, size_t length, int pri, eio_cb cb, void *data) +{ + eio_req *req = eio_mlock(addr, length, pri, cb, data); +SPEW("<-- %s(%s|%p) req %p\n", __FUNCTION__, REQ_TYPE(req), REQ_DATA(req), req); + return req; +} + +eio_req *Eio_mlockall (int flags, int pri, eio_cb cb, void *data) +{ + eio_req *req = eio_mlockall(flags, pri, cb, data); +SPEW("<-- %s(%s|%p) req %p\n", __FUNCTION__, REQ_TYPE(req), REQ_DATA(req), req); + return req; +} + +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 *req = eio_sync_file_range(fd, offset, nbytes, flags, pri, cb, data); +SPEW("<-- %s(%s|%p) req %p\n", __FUNCTION__, REQ_TYPE(req), REQ_DATA(req), req); + return req; +} + +eio_req *Eio_fallocate (int fd, int mode, off_t offset, size_t len, int pri, eio_cb cb, void *data) +{ + eio_req *req = eio_fallocate (fd, mode, offset, len, pri, cb, data); +SPEW("<-- %s(%s|%p) req %p\n", __FUNCTION__, REQ_TYPE(req), REQ_DATA(req), req); + return req; +} + +eio_req *Eio_close (int fd, int pri, eio_cb cb, void *data) +{ + eio_req *req = eio_close(fd, pri, cb, data); +SPEW("<-- %s(%s|%p) req %p\n", __FUNCTION__, REQ_TYPE(req), REQ_DATA(req), req); + return req; +} + +eio_req *Eio_readahead (int fd, off_t offset, size_t length, int pri, eio_cb cb, void *data) +{ + eio_req *req = eio_readahead(fd, offset, length, pri, cb, data); +SPEW("<-- %s(%s|%p) req %p\n", __FUNCTION__, REQ_TYPE(req), REQ_DATA(req), req); + return req; +} + +eio_req *Eio_seek (int fd, off_t offset, int whence, int pri, eio_cb cb, void *data) +{ + eio_req *req = eio_seek(fd, offset, whence, pri, cb, data); +SPEW("<-- %s(%s|%p) req %p\n", __FUNCTION__, REQ_TYPE(req), REQ_DATA(req), req); + return req; +} + +eio_req *Eio_read (int fd, void *buf, size_t length, off_t offset, int pri, eio_cb cb, void *data) +{ + eio_req *req = eio_read(fd, buf, length, offset, pri, cb, data); +SPEW("<-- %s(%s|%p) req %p\n", __FUNCTION__, REQ_TYPE(req), REQ_DATA(req), req); + return req; +} + +eio_req *Eio_write (int fd, void *buf, size_t length, off_t offset, int pri, eio_cb cb, void *data) +{ + eio_req *req = eio_write(fd, buf, length, offset, pri, cb, data); +SPEW("<-- %s(%s|%p) req %p\n", __FUNCTION__, REQ_TYPE(req), REQ_DATA(req), req); + return req; +} + +eio_req *Eio_fstat (int fd, int pri, eio_cb cb, void *data) +{ + eio_req *req = eio_fstat(fd, pri, cb, data); +SPEW("<-- %s(%s|%p) req %p\n", __FUNCTION__, REQ_TYPE(req), REQ_DATA(req), req); + return req; +} + +eio_req *Eio_fstatvfs (int fd, int pri, eio_cb cb, void *data) +{ + eio_req *req = eio_fstatvfs(fd, pri, cb, data); +SPEW("<-- %s(%s|%p) req %p\n", __FUNCTION__, REQ_TYPE(req), REQ_DATA(req), req); + return req; +} + +eio_req *Eio_futime (int fd, eio_tstamp atime, eio_tstamp mtime, int pri, eio_cb cb, void *data) +{ + eio_req *req = eio_futime(fd, atime, mtime, pri, cb, data); +SPEW("<-- %s(%s|%p) req %p\n", __FUNCTION__, REQ_TYPE(req), REQ_DATA(req), req); + return req; +} + +eio_req *Eio_ftruncate (int fd, off_t offset, int pri, eio_cb cb, void *data) +{ + eio_req *req = eio_ftruncate(fd, offset, pri, cb, data); +SPEW("<-- %s(%s|%p) req %p\n", __FUNCTION__, REQ_TYPE(req), REQ_DATA(req), req); + return req; +} + +eio_req *Eio_fchmod (int fd, mode_t mode, int pri, eio_cb cb, void *data) +{ + eio_req *req = eio_fchmod(fd, mode, pri, cb, data); +SPEW("<-- %s(%s|%p) req %p\n", __FUNCTION__, REQ_TYPE(req), REQ_DATA(req), req); + return req; +} + +eio_req *Eio_fchown (int fd, eio_uid_t uid, eio_gid_t gid, int pri, eio_cb cb, void *data) +{ + eio_req *req = eio_fchown(fd, uid, gid, pri, cb, data); +SPEW("<-- %s(%s|%p) req %p\n", __FUNCTION__, REQ_TYPE(req), REQ_DATA(req), req); + return req; +} + +eio_req *Eio_dup2 (int fd, int fd2, int pri, eio_cb cb, void *data) +{ + eio_req *req = eio_dup2(fd, fd2, pri, cb, data); +SPEW("<-- %s(%s|%p) req %p\n", __FUNCTION__, REQ_TYPE(req), REQ_DATA(req), req); + return req; +} + +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 *req = eio_sendfile(out_fd, in_fd, in_offset, length, pri, cb, data); +SPEW("<-- %s(%s|%p) req %p\n", __FUNCTION__, REQ_TYPE(req), REQ_DATA(req), req); + return req; +} + +eio_req *Eio_open (const char *path, int flags, mode_t mode, int pri, eio_cb cb, void *data) +{ + eio_req *req = eio_open(path, flags, mode, pri, cb, data); +SPEW("<-- %s(%s|%p) req %p\n", __FUNCTION__, REQ_TYPE(req), REQ_DATA(req), req); + return req; +} + +eio_req *Eio_utime (const char *path, eio_tstamp atime, eio_tstamp mtime, int pri, eio_cb cb, void *data) +{ + eio_req *req = eio_utime(path, atime, mtime, pri, cb, data); +SPEW("<-- %s(%s|%p) req %p\n", __FUNCTION__, REQ_TYPE(req), REQ_DATA(req), req); + return req; +} + +eio_req *Eio_truncate (const char *path, off_t offset, int pri, eio_cb cb, void *data) +{ + eio_req *req = eio_truncate(path, offset, pri, cb, data); +SPEW("<-- %s(%s|%p) req %p\n", __FUNCTION__, REQ_TYPE(req), REQ_DATA(req), req); + return req; +} + +eio_req *Eio_chown (const char *path, eio_uid_t uid, eio_gid_t gid, int pri, eio_cb cb, void *data) +{ + eio_req *req = eio_chown(path, uid, gid, pri, cb, data); +SPEW("<-- %s(%s|%p) req %p\n", __FUNCTION__, REQ_TYPE(req), REQ_DATA(req), req); + return req; +} + +eio_req *Eio_chmod (const char *path, mode_t mode, int pri, eio_cb cb, void *data) +{ + eio_req *req = eio_chmod(path, mode, pri, cb, data); +SPEW("<-- %s(%s|%p) req %p\n", __FUNCTION__, REQ_TYPE(req), REQ_DATA(req), req); + return req; +} + +eio_req *Eio_mkdir (const char *path, mode_t mode, int pri, eio_cb cb, void *data) +{ + eio_req *req = eio_mkdir(path, mode, pri, cb, data); +SPEW("<-- %s(%s|%p) req %p\n", __FUNCTION__, REQ_TYPE(req), REQ_DATA(req), req); + return req; +} + +eio_req *Eio_readdir (const char *path, int flags, int pri, eio_cb cb, void *data) +{ + eio_req *req = eio_readdir(path, flags, pri, cb, data); +SPEW("<-- %s(%s|%p) req %p\n", __FUNCTION__, REQ_TYPE(req), REQ_DATA(req), req); + return req; +} + +eio_req *Eio_rmdir (const char *path, int pri, eio_cb cb, void *data) +{ + eio_req *req = eio_rmdir(path, pri, cb, data); +SPEW("<-- %s(%s|%p) req %p\n", __FUNCTION__, REQ_TYPE(req), REQ_DATA(req), req); + return req; +} + +eio_req *Eio_unlink (const char *path, int pri, eio_cb cb, void *data) +{ + eio_req *req = eio_unlink(path, pri, cb, data); +SPEW("<-- %s(%s|%p) req %p\n", __FUNCTION__, REQ_TYPE(req), REQ_DATA(req), req); + return req; +} + +eio_req *Eio_readlink (const char *path, int pri, eio_cb cb, void *data) +{ + eio_req *req = eio_readlink(path, pri, cb, data); +SPEW("<-- %s(%s|%p) req %p\n", __FUNCTION__, REQ_TYPE(req), REQ_DATA(req), req); + return req; +} + +eio_req *Eio_realpath (const char *path, int pri, eio_cb cb, void *data) +{ + eio_req *req = eio_realpath(path, pri, cb, data); +SPEW("<-- %s(%s|%p) req %p\n", __FUNCTION__, REQ_TYPE(req), REQ_DATA(req), req); + return req; +} + +eio_req *Eio_stat (const char *path, int pri, eio_cb cb, void *data) +{ + eio_req *req = eio_stat(path, pri, cb, data); +SPEW("<-- %s(%s|%p) req %p\n", __FUNCTION__, REQ_TYPE(req), REQ_DATA(req), req); + return req; +} + +eio_req *Eio_lstat (const char *path, int pri, eio_cb cb, void *data) +{ + eio_req *req = eio_lstat(path, pri, cb, data); +SPEW("<-- %s(%s|%p) req %p\n", __FUNCTION__, REQ_TYPE(req), REQ_DATA(req), req); + return req; +} + +eio_req *Eio_statvfs (const char *path, int pri, eio_cb cb, void *data) +{ + eio_req *req = eio_statvfs(path, pri, cb, data); +SPEW("<-- %s(%s|%p) req %p\n", __FUNCTION__, REQ_TYPE(req), REQ_DATA(req), req); + return req; +} + +eio_req *Eio_mknod (const char *path, mode_t mode, dev_t dev, int pri, eio_cb cb, void *data) +{ + eio_req *req = eio_mknod(path, mode, dev, pri, cb, data); +SPEW("<-- %s(%s|%p) req %p\n", __FUNCTION__, REQ_TYPE(req), REQ_DATA(req), req); + return req; +} + +eio_req *Eio_link (const char *path, const char *new_path, int pri, eio_cb cb, void *data) +{ + eio_req *req = eio_link(path, new_path, pri, cb, data); +SPEW("<-- %s(%s|%p) req %p\n", __FUNCTION__, REQ_TYPE(req), REQ_DATA(req), req); + return req; +} + +eio_req *Eio_symlink (const char *path, const char *new_path, int pri, eio_cb cb, void *data) +{ + eio_req *req = eio_symlink(path, new_path, pri, cb, data); +SPEW("<-- %s(%s|%p) req %p\n", __FUNCTION__, REQ_TYPE(req), REQ_DATA(req), req); + return req; +} + +eio_req *Eio_rename (const char *path, const char *new_path, int pri, eio_cb cb, void *data) +{ + eio_req *req = eio_rename(path, new_path, pri, cb, data); +SPEW("<-- %s(%s|%p) req %p\n", __FUNCTION__, REQ_TYPE(req), REQ_DATA(req), req); + return req; +} + +eio_req *Eio_custom (void (*execute)(eio_req *), int pri, eio_cb cb, void *data) +{ + eio_req *req = eio_custom(execute, pri, cb, data); +SPEW("<-- %s(%s|%p) req %p\n", __FUNCTION__, REQ_TYPE(req), REQ_DATA(req), req); + return req; +} + +/*==============================================================*/ +static void rpmeioFini(void *_eio) +{ + rpmeio eio = (rpmeio) _eio; + if (eio) { + eio->reqtype = 0; + } +} + +#define rpmeioDbug NULL +#define rpmeioInit NULL +RPMIOPOOL_MODULE(eio) + +rpmeio rpmeioNew(rpmeioType reqtype, ...) +{ + rpmeio eio = rpmeioGetPool(_rpmeioPool); + + eio->reqtype = reqtype; + + return rpmeioLink(eio); +} @@ . patch -p0 <<'@@ .' Index: rpm/rpmio/rpmeio.h ============================================================================ $ cvs diff -u -r0 -r1.1.2.1 rpmeio.h --- /dev/null 2017-06-14 00:22:00.000000000 +0200 +++ rpmeio.h 2017-06-14 00:25:23.566624175 +0200 @@ -0,0 +1,248 @@ +#ifndef _H_RPMEIO_ +#define _H_RPMEIO_ + +#include <eio.h> + +/** + */ +extern int _rpmeio_debug; + +typedef struct rpmeio_s * rpmeio; + +/** + */ +typedef enum rpmeioType_e { + RPMEIO_CUSTOM = EIO_CUSTOM, + RPMEIO_WD_OPEN = EIO_WD_OPEN, + RPMEIO_WD_CLOSE = EIO_WD_CLOSE, + RPMEIO_CLOSE = EIO_CLOSE, + RPMEIO_DUP2 = EIO_DUP2, + RPMEIO_SEEK = EIO_SEEK, + RPMEIO_READ = EIO_READ, + RPMEIO_WRITE = EIO_WRITE, + RPMEIO_READAHEAD = EIO_READAHEAD, + RPMEIO_SENDFILE = EIO_SENDFILE, + RPMEIO_FSTAT = EIO_FSTAT, + RPMEIO_FSTATVFS = EIO_FSTATVFS, + RPMEIO_FTRUNCATE = EIO_FTRUNCATE, + RPMEIO_FUTIME = EIO_FUTIME, + RPMEIO_FCHMOD = EIO_FCHMOD, + RPMEIO_FCHOWN = EIO_FCHOWN, + RPMEIO_SYNC = EIO_SYNC, + RPMEIO_FSYNC = EIO_FSYNC, + RPMEIO_FDATASYNC = EIO_FDATASYNC, + RPMEIO_SYNCFS = EIO_SYNCFS, + RPMEIO_MSYNC = EIO_MSYNC, + RPMEIO_MTOUCH = EIO_MTOUCH, + RPMEIO_SYNC_FILE_RANGE = EIO_SYNC_FILE_RANGE, + RPMEIO_FALLOCATE = EIO_FALLOCATE, + RPMEIO_MLOCK = EIO_MLOCK, + RPMEIO_MLOCKALL = EIO_MLOCKALL, + RPMEIO_GROUP = EIO_GROUP, + RPMEIO_NOP = EIO_NOP, + RPMEIO_BUSY = EIO_BUSY, + RPMEIO_REALPATH = EIO_REALPATH, + RPMEIO_READDIR = EIO_READDIR, + RPMEIO_OPEN = EIO_OPEN, + RPMEIO_STAT = EIO_STAT, + RPMEIO_LSTAT = EIO_LSTAT, + RPMEIO_STATVFS = EIO_STATVFS, + RPMEIO_TRUNCATE = EIO_TRUNCATE, + RPMEIO_UTIME = EIO_UTIME, + RPMEIO_CHMOD = EIO_CHMOD, + RPMEIO_CHOWN = EIO_CHOWN, + RPMEIO_UNLINK = EIO_UNLINK, + RPMEIO_RMDIR = EIO_RMDIR, + RPMEIO_MKDIR = EIO_MKDIR, + RPMEIO_RENAME = EIO_RENAME, + RPMEIO_MKNOD = EIO_MKNOD, + RPMEIO_LINK = EIO_LINK, + RPMEIO_SYMLINK = EIO_SYMLINK, + RPMEIO_READLINK = EIO_READLINK, + RPMEIO_REQ_TYPE_NUM = EIO_REQ_TYPE_NUM, +} rpmeioType; +#define RPMEIO_REQ_TYPE_MASK 0xff + +/** + */ +#define _KFB(n) (1U << (n)) +#define _MFB(n) (_KFB(n)) +#define RPMEIO_FLAGS_TYPE_SHIFT 23 +typedef enum rpmeioFlags_e { + RPMEIO_FLAGS_NONE = 0, + /* bits 1-31 reserved */ +} rpmeioFlags; +#undef _MFB +#undef _KFB + +#ifdef __cplusplus +extern "C" { +#endif + +/** + */ +#if defined(_RPMEIO_INTERNAL) + +struct rpmeio_s { + struct rpmioItem_s _item; /*!< usage mutex and pool identifier. */ + eio_req *req; + eio_req _req; + rpmeioType reqtype; +}; + +RPM_GNUC_CONST +extern const char * rpmeioReqType(int reqtype); +#define REQ_DATA(_req) (_req->data) +#define REQ_TYPE(_req) (rpmeioReqType(_req->type)) + +extern void rpmeioDumpREQ(const char *msg, eio_req * req, FILE *fp); + +extern int rpmeioPipe[2]; +void rpmeioPollWant(void); +void rpmeioPollDone(void); +int rpmeioStart(void); + +void rpmeioLoop(void); + +int rpmeioCB(eio_req * req); +int rpmeioCB_readdir(eio_req * req); +int rpmeioCB_stat(eio_req * req); +int rpmeioCB_read(eio_req * req); + +int rpmeioLastFdno; +int rpmeioCB_open(eio_req * req); + +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_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); + +#ifdef NOTYET +eio_req *Eio_custom (void (*execute)(eio_req *), int pri, eio_cb cb, void *data); +#endif /* NOTYET */ + +#endif /* _RPMEIO_INTERNAL */ + +/** + * Unreference a eio wrapper instance. + * @param eio eio wrapper + * @return NULL on last dereference + */ +rpmeio rpmeioUnlink (rpmeio eio); +#define rpmeioUnlink(_eio) \ + ((rpmeio)rpmioUnlinkPoolItem((rpmioItem)(_eio), __FUNCTION__, __FILE__, __LINE__)) + +/** + * Reference a eio wrapper instance. + * @param eio eio wrapper + * @return new eio wrapper reference + */ +rpmeio rpmeioLink (rpmeio eio); +#define rpmeioLink(_eio) \ + ((rpmeio)rpmioLinkPoolItem((rpmioItem)(_eio), __FUNCTION__, __FILE__, __LINE__)) + +/** + * Destroy a eio wrapper. + * @param eio eio wrapper + * @return NULL on last dereference + */ +rpmeio rpmeioFree(rpmeio eio); +#define rpmeioFree(_eio) \ + ((rpmeio)rpmioFreePoolItem((rpmioItem)(_eio), __FUNCTION__, __FILE__, __LINE__)) + +/** + * Create a eio wrapper. + * @return eio wrapper + */ +rpmeio rpmeioNew(rpmeioType reqtype, ...); + +#ifdef __cplusplus +} +#endif + +#endif /* _H_RPMEIO_ */ @@ . patch -p0 <<'@@ .' Index: rpm/rpmio/rpmio.c ============================================================================ $ cvs diff -u -r1.230.2.59 -r1.230.2.60 rpmio.c --- rpm/rpmio/rpmio.c 12 Jun 2017 06:54:06 -0000 1.230.2.59 +++ rpm/rpmio/rpmio.c 13 Jun 2017 22:25:23 -0000 1.230.2.60 @@ -3827,6 +3827,7 @@ RPMIOPOOL_INTERP_FREE(sx) RPMIOPOOL_FREE(aio) + RPMIOPOOL_FREE(eio) RPMIOPOOL_FREE(ev) RPMIOPOOL_FREE(msq) RPMIOPOOL_FREE(zstd) @@ . patch -p0 <<'@@ .' Index: rpm/rpmio/tmq.c ============================================================================ $ cvs diff -u -r1.1.2.21 -r1.1.2.22 tmq.c --- rpm/rpmio/tmq.c 13 Jun 2017 00:00:45 -0000 1.1.2.21 +++ rpm/rpmio/tmq.c 13 Jun 2017 22:25:23 -0000 1.1.2.22 @@ -76,6 +76,9 @@ #include <rpmmsq.h> +# define _RPMEIO_INTERNAL +# include <rpmeio.h> + #if defined(HAVE_EV_H) # include <ev.h> #endif @@ -1260,193 +1263,302 @@ } /*==============================================================*/ -#if defined(HAVE_EIO_H) -# include <eio.h> -#endif - -int respipe[2]; - -void want_poll(void) -{ - char dummy; - ssize_t nw = write(respipe[1], &dummy, 1); -SPEW("<-- %s() nw %zd\n)\n", __FUNCTION__, nw); -} - -void done_poll(void) -{ - char dummy; - ssize_t nr = read(respipe[0], &dummy, 1); -SPEW("<-- %s() nr %zd\n)\n", __FUNCTION__, nr); -} - -void event_loop(void) -{ - // an event loop. yeah. - struct pollfd pfd; - pfd.fd = respipe[0]; - pfd.events = POLLIN; - -SPEW("--> %s()\n", __FUNCTION__); - while (eio_nreqs()) { - poll(&pfd, 1, -1); - SPEW(" %s() = %d\n", __FUNCTION__, eio_poll()); - } -SPEW("<-- %s()\n", __FUNCTION__); -} - -#define REQ_DATA(_req) (req && req->data ? (char *)req->data : "???") -int res_cb(eio_req * req) -{ -SPEW("--> %s(%d|%s) res %ld\n", __FUNCTION__, req->type, REQ_DATA(req), EIO_RESULT(req)); - - if (req->result < 0) - abort(); - - return 0; -} - -int readdir_cb(eio_req * req) +#ifdef NOTYET +static eio_req * rpmeioRequest(int reqtype, ...) { - char *buf = (char *) EIO_BUF(req); - -SPEW("--> %s(%d|%s) res %ld\n", __FUNCTION__, req->type, REQ_DATA(req), EIO_RESULT(req)); - - if (EIO_RESULT(req) < 0) - return 0; - - while (EIO_RESULT(req)--) { - SPEW("\treaddir = <%s>\n", buf); - buf += strlen(buf) + 1; - } + eio_req * req = NULL; + const char * fmt = NULL; + va_list ap; - return 0; -} + if (reqtype >= EIO_REQ_TYPE_NUM) + goto exit; -int stat_cb(eio_req * req) -{ - struct stat *buf = EIO_STAT_BUF(req); + va_start(ap, reqtype); -SPEW("--> %s(%d|%s) res %ld\n", __FUNCTION__, req->type, REQ_DATA(req), EIO_RESULT(req)); - if (req->type == EIO_FSTAT) { - SPEW("\tfstat_cb = %ld\n", EIO_RESULT(req)); - } else { - SPEW("\tstat_cb(%s) = %ld\n", EIO_PATH(req), EIO_RESULT(req)); + switch (reqtype) { + case EIO_CUSTOM: + req = eio_custom(execute, pri, cb, data); + break; + case EIO_WD_OPEN: + fmt = "%s | %d, %p, %p"; + req = eio_wd_open(path, pri, cb, data); + break; + case EIO_WD_CLOSE: + fmt = "%p | %d, %p, %p"; + req = eio_wd_close(wd, pri, cb, data); + break; + case EIO_CLOSE: + fmt = "%d | %d, %p, %p"; + req = eio_close(fd, pri, cb, data); + break; + case EIO_DUP2: + fmt = "%d, %d | %d, %p, %p"; + req = eio_dup2(fd, fd2, pri, cb, data); + break; + case EIO_SEEK: + fmt = "%d, %ld, %d | %d, %p, %p"; + req = eio_seek(fd, offset, whence, pri, cb, data); + break; + case EIO_READ: + fmt = "%d, %p, %zu | %d, %p, %p"; + req = eio_read(fd, buf, length, offset, pri, cb, data); + break; + case EIO_WRITE: + fmt = "%d, %p, %zu | %d, %p, %p"; + req = eio_write(fd, buf, length, offset, pri, cb, data); + break; + case EIO_READAHEAD: + fmt = "%d, %lld, %zu | %d, %p, %p"; + req = eio_readahead(fd, offset, length, pri, cb, data); + break; + case EIO_SENDFILE: + fmt = "%d, %d, %p, %zu | %d, %p, %p"; + req = eio_sendfile(out_fd, in_fd, in_offset, length, pri, cb, data); + break; + case EIO_FSTAT: + fmt = "%d | %d, %p, %p"; + req = eio_fstat(fd, pri, cb, data); + break; + case EIO_FSTATVFS: + fmt = "%d | %d, %p, %p"; + req = eio_fstatvfs(fd, pri, cb, data); + break; + case EIO_FTRUNCATE: + fmt = "%d, %ld | %d, %p, %p"; + req = eio_ftruncate(fd, offset, pri, cb, data); + break; + case EIO_FUTIME: + fmt = "%d, %f, %f | %d, %p, %p"; + req = eio_futime(fd, atime, mtime, pri, cb, data); + break; + case EIO_FCHMOD: + fmt = "%d, %hd | %d, %p, %p"; + req = eio_fchmod(fd, mode, pri, cb, data); + break; + case EIO_FCHOWN: + fmt = "%d, %d, %d | %d, %p, %p"; + req = eio_fchown(fd, uid, gid, pri, cb, data); + break; + case EIO_SYNC: + fmt = "| %d, %p, %p"; + req = eio_sync(pri, cb, data); + break; + case EIO_FSYNC: + fmt = "%d | %d, %p, %p"; + req = eio_fsync(fd, pri, cb, data); + break; + case EIO_FDATASYNC: + fmt = "%d | %d, %p, %p"; + req = eio_fdatasync(fd, pri, cb, data); + break; + case EIO_SYNCFS: + fmt = "%d | %d, %p, %p"; + req = eio_syncfs(fd, pri, cb, data); + break; + case EIO_MSYNC: + fmt = "%p, %zu, %d | %d, %p, %p"; + req = eio_msync(addr, length, flags, pri, cb, data); + break; + case EIO_MTOUCH: + fmt = "%p, %zu, %d | %d, %p, %p"; + req = eio_mtouch(addr, length, flags, pri, cb, data); + break; + case EIO_SYNC_FILE_RANGE: + fmt = "%p, %lld, %lld, %u | %d, %p, %p"; + req = eio_sync_file_range(fd, offset, nbytes, flags, pri, cb, data); + break; + case EIO_FALLOCATE: + fmt = "%p, %d, %ld, %ld | %d, %p, %p"; + req = eio_fallocate (fd, mode, offset, len, pri, cb, data); + break; + case EIO_MLOCK: + fmt = "%p, %zu | %d, %p, %p"; + req = eio_mlock(addr, length, pri, cb, data); + break; + case EIO_MLOCKALL: + fmt = "%d | %d, %p, %p"; + req = eio_mlockall(flags, pri, cb, data); + break; + case EIO_GROUP: + const int pri = EIO_PRI_MAX; /* XXX */ + fmt = "| %p, %p"; + req = eio_grp(eio_cb cb, void *data) + break; + case EIO_NOP: + fmt = "| %d, %p, %p"; + req = eio_nop(pri,cb, data); + break; + case EIO_BUSY: + fmt = "%f | %d, %p, %p"; + req = eio_busy(delay, pri, cb, data); + break; + case EIO_REALPATH: + fmt = "%s | %d, %p, %p"; + req = eio_realpath(path, pri, cb, data); + break; + case EIO_READDIR: + fmt = "%s, %d | %d, %p, %p"; + req = eio_readdir(path, flags, pri, cb, data); + break; + case EIO_OPEN: + fmt = "%s, %d, %d | %d, %p, %p"; + req = eio_open(path, flags, mode, pri, cb, data); + break; + case EIO_STAT: + fmt = "%s | %d, %p, %p"; + req = eio_stat(path, pri, cb, data); + break; + case EIO_LSTAT: + fmt = "%s | %d, %p, %p"; + req = eio_lstat(path, pri, cb, data); + break; + case EIO_STATVFS: + fmt = "%s | %d, %p, %p"; + req = eio_statvfs(path, pri, cb, data); + break; + case EIO_TRUNCATE: + fmt = "%s, %ld | %d, %p, %p"; + req = eio_truncate(path, offset, pri, cb, data); + break; + case EIO_UTIME: + fmt = "%s, %p, %p | %d, %p, %p"; + req = eio_utime(path, atime, mtime, pri, cb, data); + break; + case EIO_CHMOD: + fmt = "%s, %d | %d, %p, %p"; + req = eio_chmod(path, mode, pri, cb, data); + break; + case EIO_CHOWN: + fmt = "%s, %d, %d | %d, %p, %p"; + req = eio_chown(path, uid, gid, pri, cb, data); + break; + case EIO_UNLINK: + fmt = "%s | %d, %p, %p"; + req = eio_unlink(path, pri, cb, data); + break; + case EIO_RMDIR: + fmt = "%s | %d, %p, %p"; + req = eio_rmdir(path, pri, cb, data); + break; + case EIO_MKDIR: + fmt = "%s, %d | %d, %p, %p"; + req = eio_mkdir(path, mode, pri, cb, data); + break; + case EIO_RENAME: + fmt = "%s, %s | %d, %p, %p"; + req = eio_rename(path, new_path, pri, cb, data); + break; + case EIO_MKNOD: + fmt = "%s, %d, %ld | %d, %p, %p"; + req = eio_mknod(path, mode, dev, pri, cb, data); + break; + case EIO_LINK: + fmt = "%s, %s | %d, %p, %p"; + req = eio_link(path, new_path, pri, cb, data); + break; + case EIO_SYMLINK: + fmt = "%s, %s | %d, %p, %p"; + req = eio_symlink(path, new_path, pri, cb, data); + break; + case EIO_READLINK: + fmt = "%s | %d, %p, %p"; + req = eio_readlink(path, pri, cb, data); + break; + default: +assert(0); + break; } - if (!EIO_RESULT(req)) - SPEW("\tstat size %ld perm 0%o\n", buf->st_size, - buf->st_mode & 0777); - - return 0; -} - -int read_cb(eio_req * req) -{ - unsigned char *buf = (unsigned char *) EIO_BUF(req); - -SPEW("--> %s(%d|%s) res %ld (%02x%02x%02x%02x %02x%02x%02x%02x)\n", - __FUNCTION__, req->type, REQ_DATA(req), EIO_RESULT(req), - buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6], buf[7]); + va_end(ap); - return 0; -} - -int last_fd; - -int open_cb(eio_req * req) -{ -SPEW("--> %s(%d|%s) res %ld\n", __FUNCTION__, req->type, REQ_DATA(req), EIO_RESULT(req)); - - last_fd = EIO_RESULT(req); - - return 0; +exit: + return req; } +#endif /* NOTYET */ /*==============================================================*/ static int doEIO(ARGV_t av, int ac) { int rc = 0; -SPEW("*** pipe()\n"); - if (pipe(respipe)) - abort(); - -SPEW("*** eio_init()\n"); - if (eio_init(want_poll, done_poll)) - abort(); + rc = rpmeioStart(); + if (rc) + goto exit; do { /* avoid relative paths yourself(!) */ - eio_mkdir("eio-test-dir", 0777, 0, res_cb, "mkdir"); - eio_nop(0, res_cb, "nop"); - event_loop(); - - eio_stat("eio-test-dir", 0, stat_cb, "stat"); - eio_lstat("eio-test-dir", 0, stat_cb, "stat"); - eio_open("eio-test-dir/eio-test-file", O_RDWR | O_CREAT, 0777, 0, - open_cb, "open"); - eio_symlink("test", "eio-test-dir/eio-symlink", 0, res_cb, + Eio_mkdir("eio-test-dir", 0777, 0, rpmeioCB, "mkdir"); + Eio_nop(0, rpmeioCB, "nop"); + rpmeioLoop(); + + Eio_stat("eio-test-dir", 0, rpmeioCB_stat, "stat"); + Eio_lstat("eio-test-dir", 0, rpmeioCB_stat, "stat"); + Eio_open("eio-test-dir/eio-test-file", O_RDWR | O_CREAT, 0777, 0, + rpmeioCB_open, "open"); + Eio_symlink("test", "eio-test-dir/eio-symlink", 0, rpmeioCB, "symlink"); - eio_mknod("eio-test-dir/eio-fifo", S_IFIFO, 0, 0, res_cb, "mknod"); - event_loop(); + Eio_mknod("eio-test-dir/eio-fifo", S_IFIFO, 0, 0, rpmeioCB, "mknod"); + rpmeioLoop(); - eio_utime("eio-test-dir", 12345.678, 23456.789, 0, res_cb, + Eio_utime("eio-test-dir", 12345.678, 23456.789, 0, rpmeioCB, "utime"); - eio_futime(last_fd, 92345.678, 93456.789, 0, res_cb, "futime"); - eio_chown("eio-test-dir", getuid(), getgid(), 0, res_cb, "chown"); - eio_fchown(last_fd, getuid(), getgid(), 0, res_cb, "fchown"); - eio_fchmod(last_fd, 0723, 0, res_cb, "fchmod"); - eio_readdir("eio-test-dir", 0, 0, readdir_cb, "readdir"); - eio_readdir("/nonexistant", 0, 0, readdir_cb, "readdir"); - eio_fstat(last_fd, 0, stat_cb, "stat"); - eio_write(last_fd, "test\nfail\n", 10, 4, 0, res_cb, "write"); - event_loop(); - - eio_read(last_fd, 0, 8, 0, EIO_PRI_DEFAULT, read_cb, "read"); - eio_readlink("eio-test-dir/eio-symlink", 0, res_cb, "readlink"); - event_loop(); - - eio_dup2(1, 2, EIO_PRI_DEFAULT, res_cb, "dup"); // dup stdout to stderr - eio_chmod("eio-test-dir", 0765, 0, res_cb, "chmod"); - eio_ftruncate(last_fd, 9, 0, res_cb, "ftruncate"); - eio_fdatasync(last_fd, 0, res_cb, "fdatasync"); - eio_fsync(last_fd, 0, res_cb, "fsync"); - eio_sync(0, res_cb, "sync"); - eio_busy(0.5, 0, res_cb, "busy"); - event_loop(); - - eio_sendfile(1, last_fd, 4, 5, 0, res_cb, "sendfile"); // write "test\n" to stdout - eio_fstat(last_fd, 0, stat_cb, "stat"); - event_loop(); + Eio_futime(rpmeioLastFdno, 92345.678, 93456.789, 0, rpmeioCB, "futime"); + Eio_chown("eio-test-dir", getuid(), getgid(), 0, rpmeioCB, "chown"); + Eio_fchown(rpmeioLastFdno, getuid(), getgid(), 0, rpmeioCB, "fchown"); + Eio_fchmod(rpmeioLastFdno, 0723, 0, rpmeioCB, "fchmod"); + Eio_readdir("eio-test-dir", 0, 0, rpmeioCB_readdir, "readdir"); + Eio_readdir("/nonexistant", 0, 0, rpmeioCB_readdir, "readdir"); + Eio_fstat(rpmeioLastFdno, 0, rpmeioCB_stat, "stat"); + Eio_write(rpmeioLastFdno, "test\nfail\n", 10, 4, 0, rpmeioCB, "write"); + rpmeioLoop(); + + Eio_read(rpmeioLastFdno, 0, 8, 0, EIO_PRI_DEFAULT, rpmeioCB_read, "read"); + Eio_readlink("eio-test-dir/eio-symlink", 0, rpmeioCB, "readlink"); + rpmeioLoop(); + + Eio_dup2(1, 2, EIO_PRI_DEFAULT, rpmeioCB, "dup"); // dup stdout to stderr + Eio_chmod("eio-test-dir", 0765, 0, rpmeioCB, "chmod"); + Eio_ftruncate(rpmeioLastFdno, 9, 0, rpmeioCB, "ftruncate"); + Eio_fdatasync(rpmeioLastFdno, 0, rpmeioCB, "fdatasync"); + Eio_fsync(rpmeioLastFdno, 0, rpmeioCB, "fsync"); + Eio_sync(0, rpmeioCB, "sync"); + Eio_busy(0.5, 0, rpmeioCB, "busy"); + rpmeioLoop(); + + Eio_sendfile(1, rpmeioLastFdno, 4, 5, 0, rpmeioCB, "sendfile"); // write "test\n" to stdout + Eio_fstat(rpmeioLastFdno, 0, rpmeioCB_stat, "stat"); + rpmeioLoop(); - eio_truncate("eio-test-dir/eio-test-file", 6, 0, res_cb, + Eio_truncate("eio-test-dir/eio-test-file", 6, 0, rpmeioCB, "truncate"); - eio_readahead(last_fd, 0, 64, 0, res_cb, "readahead"); - event_loop(); + Eio_readahead(rpmeioLastFdno, 0, 64, 0, rpmeioCB, "readahead"); + rpmeioLoop(); - eio_close(last_fd, 0, res_cb, "close"); - eio_link("eio-test-dir/eio-test-file", - "eio-test-dir/eio-test-file-2", 0, res_cb, "link"); - event_loop(); + Eio_close(rpmeioLastFdno, 0, rpmeioCB, "close"); + Eio_link("eio-test-dir/eio-test-file", + "eio-test-dir/eio-test-file-2", 0, rpmeioCB, "link"); + rpmeioLoop(); - eio_rename("eio-test-dir/eio-test-file", - "eio-test-dir/eio-test-file-renamed", 0, res_cb, + Eio_rename("eio-test-dir/eio-test-file", + "eio-test-dir/eio-test-file-renamed", 0, rpmeioCB, "rename"); - event_loop(); + rpmeioLoop(); - eio_unlink("eio-test-dir/eio-fifo", 0, res_cb, "unlink"); - eio_unlink("eio-test-dir/eio-symlink", 0, res_cb, "unlink"); - eio_unlink("eio-test-dir/eio-test-file-2", 0, res_cb, "unlink"); - eio_unlink("eio-test-dir/eio-test-file-renamed", 0, res_cb, + Eio_unlink("eio-test-dir/eio-fifo", 0, rpmeioCB, "unlink"); + Eio_unlink("eio-test-dir/eio-symlink", 0, rpmeioCB, "unlink"); + Eio_unlink("eio-test-dir/eio-test-file-2", 0, rpmeioCB, "unlink"); + Eio_unlink("eio-test-dir/eio-test-file-renamed", 0, rpmeioCB, "unlink"); - event_loop(); + rpmeioLoop(); - eio_rmdir("eio-test-dir", 0, res_cb, "rmdir"); - event_loop(); + Eio_rmdir("eio-test-dir", 0, rpmeioCB, "rmdir"); + rpmeioLoop(); } while (0); + rc = 0; /* XXX */ + +exit: return rc; } @@ . ______________________________________________________________________ RPM Package Manager http://rpm5.org CVS Sources Repository [email protected]
