add resource probes in da_io_posix.c, da_io_stdc.c; comment da log printing there

diff --git a/probe_file/da_io.h b/probe_file/da_io.h
index 74515c6..4cd5a10 100755 (executable)
--- a/probe_file/da_io.h
+++ b/probe_file/da_io.h
@@ -78,10 +78,19 @@
        log.length += sprintf(log.data + log.length, "`,%u`,%d`,%d`,%d`,%ld`,%s",       \\r
                        SIZE, FD, FD_FILE, APITYPE, (_fstatret == 0 ? _statbuf.st_size : 0), _filepath)\r
 \r
+#define POST_PACK_PROBEBLOCK_MIDDLE_FD(SIZE, FD, APITYPE)                      \\r
+       PACK_RESOURCE(SIZE, FD, FD_FILE, APITYPE,                                               \\r
+                     (_fstatret == 0 ? _statbuf.st_size : 0), _filepath);      \\r
+       FLUSH_LOCAL_BUF()\r
+\r
 #define POST_PROBEBLOCK_MIDDLE_NOFD(SIZE, APITYPE)                                                     \\r
        log.length += sprintf(log.data + log.length, "`,%u`,`,%d`,%d`,0`,%s",   \\r
                        SIZE, FD_FILE, APITYPE, _filepath)\r
 \r
+#define POST_PACK_PROBEBLOCK_MIDDLE_NOFD(SIZE, APITYPE)                        \\r
+       PACK_RESOURCE(SIZE, 0, FD_FILE, APITYPE, 0, _filepath);         \\r
+       FLUSH_LOCAL_BUF()\r
+\r
 #define POST_PROBEBLOCK_CALLSTACK_RESOURCE(APITYPE)                                    \\r
        do {                                                                                                                    \\r
                if(APITYPE == FD_API_OPEN) {                                                            \\r
@@ -119,12 +128,29 @@
        POST_PROBEBLOCK_CALLSTACK_RESOURCE(APITYPE);                                                            \\r
        POST_PROBEBLOCK_END()\r
 \r
+#define AFTER_PACK_ORIGINAL_FD(RVAL, SIZE, FD, APITYPE, INPUTFORMAT, ...)                      \\r
+       POST_PACK_PROBEBLOCK_BEGIN();                                                                                                   \\r
+       PREPARE_LOCAL_BUF();                                                                                                                    \\r
+       PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE, LC_RESOURCE, INPUTFORMAT, __VA_ARGS__);   \\r
+       PACK_COMMON_END(RVAL, newerrno, blockresult);                                                                   \\r
+       _fstatret = fstat(FD, &_statbuf);                                                                                               \\r
+       POST_PACK_PROBEBLOCK_MIDDLE_FD(SIZE, FD, APITYPE);                                                              \\r
+       POST_PACK_PROBEBLOCK_END()\r
+\r
 #define AFTER_ORIGINAL_NOFD_RET(RTYPE, RVAL, SIZE, APITYPE, INPUTFORMAT, ...)  \\r
        POST_PROBEBLOCK_BEGIN(LC_RESOURCE, RTYPE, RVAL, INPUTFORMAT, __VA_ARGS__);      \\r
        POST_PROBEBLOCK_MIDDLE_NOFD(SIZE, APITYPE);                                                                     \\r
        POST_PROBEBLOCK_CALLSTACK_RESOURCE(APITYPE);                                                            \\r
        POST_PROBEBLOCK_END()\r
 \r
+#define AFTER_PACK_ORIGINAL_NOFD(RVAL, SIZE, APITYPE, INPUTFORMAT, ...)                                        \\r
+       POST_PACK_PROBEBLOCK_BEGIN();                                                                                                           \\r
+       PREPARE_LOCAL_BUF();                                                                                                                            \\r
+       PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE, LC_RESOURCE, INPUTFORMAT, __VA_ARGS__);           \\r
+       PACK_COMMON_END(RVAL, newerrno, blockresult);                                                                           \\r
+       POST_PACK_PROBEBLOCK_MIDDLE_NOFD(SIZE, APITYPE);                                                                        \\r
+       POST_PACK_PROBEBLOCK_END()\r
+\r
 #define AFTER_ORIGINAL_FILEP_RET(RTYPE, RVAL, SIZE, FILEP, APITYPE, INPUTFORMAT, ...)  \\r
        POST_PROBEBLOCK_BEGIN(LC_RESOURCE, RTYPE, RVAL, INPUTFORMAT, __VA_ARGS__);                      \\r
        GET_FD_FROM_FILEP(FILEP);                                                                                                                       \\r
@@ -136,6 +162,17 @@
        POST_PROBEBLOCK_CALLSTACK_RESOURCE(APITYPE);                                                                            \\r
        POST_PROBEBLOCK_END()\r
 \r
+#define AFTER_PACK_ORIGINAL_FILEP(RVAL, SIZE, FILEP, APITYPE, INPUTFORMAT, ...)                        \\r
+       POST_PACK_PROBEBLOCK_BEGIN();                                                                                                           \\r
+       GET_FD_FROM_FILEP(FILEP);                                                                                                                       \\r
+       if(_fd != -1) {                                                                                                                                         \\r
+               _fstatret = fstat(_fd, &_statbuf);                                                                                              \\r
+       }                                                                                                                                                                       \\r
+       PREPARE_LOCAL_BUF();                                                                                                                            \\r
+       PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE, LC_RESOURCE, INPUTFORMAT, __VA_ARGS__);           \\r
+       PACK_COMMON_END(RVAL, newerrno, blockresult);                                                                           \\r
+       POST_PACK_PROBEBLOCK_MIDDLE_FD(SIZE, _fd, APITYPE);                                                                     \\r
+       POST_PACK_PROBEBLOCK_END()\r
 \r
 #define AFTER_ORIGINAL_FD(SIZE, FD, APITYPE, INPUTFORMAT, ...)                 \\r
        AFTER_ORIGINAL_FD_RET(VT_INT, ret, SIZE, FD, APITYPE, INPUTFORMAT, __VA_ARGS__)\r

diff --git a/probe_file/da_io_posix.c b/probe_file/da_io_posix.c
index 28f83fe..4254cb9 100755 (executable)
--- a/probe_file/da_io_posix.c
+++ b/probe_file/da_io_posix.c
@@ -48,6 +48,8 @@
 #include <stdlib.h>
 #include <errno.h>
 
+#include "binproto.h"
+
 static enum DaOptions _sopt = OPT_FILE;
 
 int open(const char* path, int oflag, ...)
@@ -68,7 +70,9 @@ int open(const char* path, int oflag, ...)
 
        ret = openp(path, oflag, mode);
 
-       AFTER_ORIGINAL_FD(0, ret, FD_API_OPEN, "%s, %d, %d", path, oflag, mode);
+//     AFTER_ORIGINAL_FD(0, ret, FD_API_OPEN, "%s, %d, %d", path, oflag, mode);
+
+       AFTER_PACK_ORIGINAL_FD(ret, 0, ret, FD_API_OPEN, "sdd", path, oflag, mode);
 
        return ret;
 }
@@ -91,7 +95,9 @@ int openat(int fd, const char* path, int oflag, ...)
 
        ret = openatp(fd, path, oflag, mode);
 
-       AFTER_ORIGINAL_FD(0, ret, FD_API_OPEN, "%d, %s, %d, %d", fd, path, oflag, mode);
+//     AFTER_ORIGINAL_FD(0, ret, FD_API_OPEN, "%d, %s, %d, %d", fd, path, oflag, mode);
+
+       AFTER_PACK_ORIGINAL_FD(ret, 0, ret, FD_API_OPEN, "dsdd", fd, path, oflag, mode);
 
        return ret;
 }
@@ -105,7 +111,9 @@ int creat(const char* path, mode_t mode)
 
        ret = creatp(path, mode);
 
-       AFTER_ORIGINAL_FD(0, ret, FD_API_OPEN, "%s, %d", path, mode);
+//     AFTER_ORIGINAL_FD(0, ret, FD_API_OPEN, "%s, %d", path, mode);
+
+       AFTER_PACK_ORIGINAL_FD(ret, 0, ret, FD_API_OPEN, "sd", path, mode);
 
        return ret;
 }
@@ -123,11 +131,18 @@ int close(int fd)
        PRE_PROBEBLOCK_END();
 
        ret = closep(fd);
-
+/*
        POST_PROBEBLOCK_BEGIN(LC_RESOURCE, VT_INT, ret, "%d", fd);
        POST_PROBEBLOCK_MIDDLE_FD(0, fd, FD_API_CLOSE);
        POST_PROBEBLOCK_CALLSTACK_RESOURCE(FD_API_CLOSE);
        POST_PROBEBLOCK_END();
+*/
+       POST_PACK_PROBEBLOCK_BEGIN();
+       PREPARE_LOCAL_BUF();
+       PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE, LC_RESOURCE, "d", fd);
+       PACK_COMMON_END(ret, newerrno, blockresult);
+       POST_PACK_PROBEBLOCK_MIDDLE_FD(0, fd, FD_API_CLOSE);
+       POST_PACK_PROBEBLOCK_END();
 
        return ret;
 }
@@ -141,7 +156,9 @@ int access(const char *path, int amode)
 
        ret = accessp(path, amode);
 
-       AFTER_ORIGINAL_NOFD(0, FD_API_PERMISSION, "%s, %d", path, amode);
+//     AFTER_ORIGINAL_NOFD(0, FD_API_PERMISSION, "%s, %d", path, amode);
+
+       AFTER_PACK_ORIGINAL_NOFD(ret, 0, FD_API_PERMISSION, "sd", path, amode);
 
        return ret;
 }
@@ -155,8 +172,10 @@ int faccessat(int fd, const char *path, int amode, int flag)
 
        ret = faccessatp(fd, path, amode, flag);
 
-       AFTER_ORIGINAL_FD(0, fd, FD_API_PERMISSION,
-                       "%d, %s, %d, %d", fd, path, amode, flag);
+//     AFTER_ORIGINAL_FD(0, fd, FD_API_PERMISSION,
+//                     "%d, %s, %d, %d", fd, path, amode, flag);
+
+       AFTER_PACK_ORIGINAL_FD(ret, 0, fd, FD_API_PERMISSION, "dsdd", fd, path, amode, flag);
 
        return ret;
 }
@@ -170,8 +189,11 @@ off_t lseek(int fd, off_t offset, int whence)
 
        offret = lseekp(fd, offset, whence);
 
-       AFTER_ORIGINAL_FD_RET(VT_OFF_T, offret, (unsigned int)offset, fd, FD_API_OTHER,
-                       "%d, %ld, %d", fd, offset, whence);
+//     AFTER_ORIGINAL_FD_RET(VT_OFF_T, offret, (unsigned int)offset, fd, FD_API_OTHER,
+//                     "%d, %ld, %d", fd, offset, whence);
+
+       AFTER_PACK_ORIGINAL_FD(offret, (unsigned int)offset, fd, FD_API_OTHER,
+                       "dxd", fd, offset, whence);
 
        return offret;
 }
@@ -184,7 +206,9 @@ int fsync(int fd)
 
        ret = fsyncp(fd);
 
-       AFTER_ORIGINAL_FD(0, fd, FD_API_OTHER, "%d", fd);
+//     AFTER_ORIGINAL_FD(0, fd, FD_API_OTHER, "%d", fd);
+
+       AFTER_PACK_ORIGINAL_FD(ret, 0, fd, FD_API_OTHER, "d", fd);
 
        return ret;
 }
@@ -197,7 +221,9 @@ int fdatasync(int fd)
 
        ret = fdatasyncp(fd);
 
-       AFTER_ORIGINAL_FD(0, fd, FD_API_OTHER, "%d", fd);
+//     AFTER_ORIGINAL_FD(0, fd, FD_API_OTHER, "%d", fd);
+
+       AFTER_PACK_ORIGINAL_FD(ret, 0, fd, FD_API_OTHER, "d", fd);
 
        return ret;
 }
@@ -211,8 +237,10 @@ int truncate(const char *path, off_t length)
 
        ret = truncatep(path, length);
 
-       AFTER_ORIGINAL_NOFD((unsigned int)length, FD_API_DIRECTORY,
-                       "%s, %ld", path, length);
+//     AFTER_ORIGINAL_NOFD((unsigned int)length, FD_API_DIRECTORY,
+//                     "%s, %ld", path, length);
+
+       AFTER_PACK_ORIGINAL_NOFD(ret, (unsigned int)length, FD_API_DIRECTORY, "sx", path, length);
 
        return ret;
 }
@@ -225,8 +253,10 @@ int ftruncate(int fd, off_t length)
 
        ret = ftruncatep(fd, length);
 
-       AFTER_ORIGINAL_FD((unsigned int)length, fd, FD_API_DIRECTORY,
-                       "%d, %ld", fd, length);
+//     AFTER_ORIGINAL_FD((unsigned int)length, fd, FD_API_DIRECTORY,
+//                     "%d, %ld", fd, length);
+
+       AFTER_PACK_ORIGINAL_FD(ret, (unsigned int)length, fd, FD_API_DIRECTORY, "dx", fd, length);
 
        return ret;
 }
@@ -242,7 +272,9 @@ int mkfifo(const char *path, mode_t mode)
 
        ret = mkfifop(path, mode);
 
-       AFTER_ORIGINAL_NOFD(0, FD_API_OTHER, "%s, %u", path, mode);
+//     AFTER_ORIGINAL_NOFD(0, FD_API_OTHER, "%s, %u", path, mode);
+
+       AFTER_PACK_ORIGINAL_NOFD(ret, 0, FD_API_OTHER, "sd", path, mode);
 
        return ret;
 }
@@ -256,8 +288,10 @@ int mkfifoat(int fd, const char *path, mode_t mode)
 
        ret = mkfifoatp(fd, path, mode);
 
-       AFTER_ORIGINAL_FD(0, fd, FD_API_OTHER,
-                       "%d, %s, %u", fd, path, mode);
+//     AFTER_ORIGINAL_FD(0, fd, FD_API_OTHER,
+//                     "%d, %s, %u", fd, path, mode);
+
+       AFTER_PACK_ORIGINAL_FD(ret, 0, fd, FD_API_OTHER, "dsd", fd, path, mode);
 
        return ret;
 }
@@ -271,8 +305,11 @@ int mknod(const char *path, mode_t mode, dev_t dev)
 
        ret = mknodp(path, mode, dev);
 
-       AFTER_ORIGINAL_NOFD(0, FD_API_OTHER,
-                       "%s, %u, %lu", path, mode, (unsigned long int)dev);
+//     AFTER_ORIGINAL_NOFD(0, FD_API_OTHER,
+//                     "%s, %u, %lu", path, mode, (unsigned long int)dev);
+
+       AFTER_PACK_ORIGINAL_NOFD(ret, 0, FD_API_OTHER,
+                       "sdx", path, mode, (unsigned long int)dev);
 
        return ret;
 }
@@ -286,8 +323,11 @@ int mknodat(int fd, const char *path, mode_t mode, dev_t dev)
 
        ret = mknodatp(fd,path, mode,dev);
 
-       AFTER_ORIGINAL_FD(0, fd, FD_API_OTHER,
-                       "%d, %s, %u, %lu", fd, path, mode, (unsigned long int)dev);
+//     AFTER_ORIGINAL_FD(0, fd, FD_API_OTHER,
+//                     "%d, %s, %u, %lu", fd, path, mode, (unsigned long int)dev);
+
+       AFTER_PACK_ORIGINAL_FD(ret, 0, fd, FD_API_OTHER,
+                       "dsdx", fd, path, mode, (unsigned long int)dev);
 
        return ret;
 }
@@ -303,7 +343,8 @@ int chown(const char *path, uid_t owner, gid_t group)
        BEFORE_ORIGINAL_FILE(chown, LIBC);
        _filepath = (char*)path;
        ret = chownp(path, owner, group);
-       AFTER_ORIGINAL_NOFD(0, FD_API_PERMISSION, "%s, %u, %u", path, owner, group);
+//     AFTER_ORIGINAL_NOFD(0, FD_API_PERMISSION, "%s, %u, %u", path, owner, group);
+       AFTER_PACK_ORIGINAL_NOFD(ret, 0, FD_API_PERMISSION, "sdd", path, owner, group);
        return ret;
 }
 
@@ -314,8 +355,10 @@ int fchownat(int fd, const char *path, uid_t owner, gid_t group, int flag)
        BEFORE_ORIGINAL_FILE(fchownat, LIBC);
        _filepath = (char*)path;
        ret = fchownatp(fd, path, owner, group, flag);
-       AFTER_ORIGINAL_FD(0, fd, FD_API_PERMISSION,
-                       "%d, %s, %u, %u, %d", fd, path, owner, group, flag);
+//     AFTER_ORIGINAL_FD(0, fd, FD_API_PERMISSION,
+//                     "%d, %s, %u, %u, %d", fd, path, owner, group, flag);
+       AFTER_PACK_ORIGINAL_FD(ret, 0, fd, FD_API_PERMISSION,
+                       "dsddd", fd, path, owner, group, flag);
        return ret;
 }
 
@@ -325,7 +368,8 @@ int fchown(int fd, uid_t owner, gid_t group)
 
        BEFORE_ORIGINAL_FILE(fchown, LIBC);
        ret = fchownp(fd, owner, group);
-       AFTER_ORIGINAL_FD(0, fd, FD_API_PERMISSION, "%d, %u, %u", fd, owner, group);
+//     AFTER_ORIGINAL_FD(0, fd, FD_API_PERMISSION, "%d, %u, %u", fd, owner, group);
+       AFTER_PACK_ORIGINAL_FD(ret, 0, fd, FD_API_PERMISSION, "ddd", fd, owner, group);
        return ret;
 }
 
@@ -336,7 +380,8 @@ int lchown(const char *path, uid_t owner, gid_t group)
        BEFORE_ORIGINAL_FILE(lchown, LIBC);
        _filepath = (char*)path;
        ret = lchownp(path, owner, group);
-       AFTER_ORIGINAL_NOFD(0, FD_API_PERMISSION, "%s, %u, %u", path, owner, group);
+//     AFTER_ORIGINAL_NOFD(0, FD_API_PERMISSION, "%s, %u, %u", path, owner, group);
+       AFTER_PACK_ORIGINAL_NOFD(ret, 0, FD_API_PERMISSION, "sdd", path, owner, group);
        return ret;
 }
 
@@ -346,8 +391,10 @@ int lockf(int fd, int function, off_t size)
 
        BEFORE_ORIGINAL_FILE(lockf, LIBC);
        ret = lockfp(fd, function, size);
-       AFTER_ORIGINAL_FD((unsigned int)size, fd, FD_API_PERMISSION,
-                       "%d, %d, %ld", fd, function, size);
+       // AFTER_ORIGINAL_FD((unsigned int)size, fd, FD_API_PERMISSION,
+       //              "%d, %d, %ld", fd, function, size);
+       AFTER_PACK_ORIGINAL_FD(ret, (unsigned int)size, fd, FD_API_PERMISSION,
+                       "ddx", fd, function, size);
        return ret;
 }
 
@@ -358,7 +405,8 @@ int chmod(const char *path, mode_t mode)
        BEFORE_ORIGINAL_FILE(chmod, LIBC);
        _filepath = (char*)path;
        ret = chmodp(path, mode);
-       AFTER_ORIGINAL_NOFD(0, FD_API_PERMISSION, "%s, %u", path, mode);
+       // AFTER_ORIGINAL_NOFD(0, FD_API_PERMISSION, "%s, %u", path, mode);
+       AFTER_PACK_ORIGINAL_NOFD(ret, 0, FD_API_PERMISSION, "sd", path, mode);
        return ret;
 }
 
@@ -369,8 +417,10 @@ int fchmodat(int fd, const char *path, mode_t mode, int flag)
        BEFORE_ORIGINAL_FILE(fchmodat, LIBC);
        _filepath = (char*)path;
        ret = fchmodatp(fd, path, mode, flag);
-       AFTER_ORIGINAL_FD(0, fd, FD_API_PERMISSION,
-                       "%d, %s, %u, %d", fd, path, mode, flag);
+       // AFTER_ORIGINAL_FD(0, fd, FD_API_PERMISSION,
+       //              "%d, %s, %u, %d", fd, path, mode, flag);
+       AFTER_PACK_ORIGINAL_FD(ret,0, fd, FD_API_PERMISSION,
+                       "dsdd", fd, path, mode, flag);
        return ret;
 }
 
@@ -380,7 +430,8 @@ int fchmod(int fd, mode_t mode)
 
        BEFORE_ORIGINAL_FILE(fchmod, LIBC);
        ret = fchmodp(fd, mode);
-       AFTER_ORIGINAL_FD(0, fd, FD_API_PERMISSION, "%d, %u", fd, mode);
+       // AFTER_ORIGINAL_FD(0, fd, FD_API_PERMISSION, "%d, %u", fd, mode);
+       AFTER_PACK_ORIGINAL_FD(ret, 0, fd, FD_API_PERMISSION, "dd", fd, mode);
        return ret;
 }
 
@@ -397,8 +448,11 @@ ssize_t pread(int fd, void *buf, size_t nbyte, off_t offset)
 
        sret = preadp(fd, buf, nbyte, offset);
 
-       AFTER_ORIGINAL_FD_RET(VT_SSIZE_T, sret, (unsigned int)sret, fd, FD_API_READ,
-                       "%d, %p, %u, %ld", fd, buf, nbyte, offset);
+       // AFTER_ORIGINAL_FD_RET(VT_SSIZE_T, sret, (unsigned int)sret, fd, FD_API_READ,
+       //              "%d, %p, %u, %ld", fd, buf, nbyte, offset);
+
+       AFTER_PACK_ORIGINAL_FD(sret, (unsigned int)sret, fd, FD_API_READ,
+                       "dpdx", fd, buf, nbyte, offset);
 
        return sret;
 }
@@ -411,8 +465,11 @@ ssize_t read(int fd, void *buf, size_t nbyte)
 
        sret = readp(fd, buf, nbyte);
 
-       AFTER_ORIGINAL_FD_RET(VT_SSIZE_T, sret, (unsigned int)sret, fd, FD_API_READ,
-                       "%d, %p, %u", fd, buf, nbyte);
+       // AFTER_ORIGINAL_FD_RET(VT_SSIZE_T, sret, (unsigned int)sret, fd, FD_API_READ,
+       //              "%d, %p, %u", fd, buf, nbyte);
+
+       AFTER_PACK_ORIGINAL_FD(sret, (unsigned int)sret, fd, FD_API_READ,
+                       "dpd", fd, buf, nbyte);
 
        return sret;
 }
@@ -426,8 +483,11 @@ ssize_t pwrite(int fd, const void *buf, size_t nbyte, off_t offset)
 
        sret = pwritep(fd, buf, nbyte, offset);
 
-       AFTER_ORIGINAL_FD_RET(VT_SSIZE_T, sret, (unsigned int)sret, fd, FD_API_WRITE,
-                       "%d, %p, %u, %ld", fd, buf, nbyte, offset);
+       // AFTER_ORIGINAL_FD_RET(VT_SSIZE_T, sret, (unsigned int)sret, fd, FD_API_WRITE,
+       //              "%d, %p, %u, %ld", fd, buf, nbyte, offset);
+
+       AFTER_PACK_ORIGINAL_FD(sret, (unsigned int)sret, fd, FD_API_WRITE,
+                       "dpdx", fd, buf, nbyte, offset);
 
        return sret;
 }
@@ -441,8 +501,11 @@ ssize_t write(int fd, const void *buf, size_t nbyte)
 
        sret = writep(fd, buf, nbyte);
 
-       AFTER_ORIGINAL_FD_RET(VT_SSIZE_T, sret, (unsigned int)sret, fd, FD_API_WRITE,
-                       "%d, %p, %u", fd, buf, nbyte);
+       // AFTER_ORIGINAL_FD_RET(VT_SSIZE_T, sret, (unsigned int)sret, fd, FD_API_WRITE,
+       //              "%d, %p, %u", fd, buf, nbyte);
+
+       AFTER_PACK_ORIGINAL_FD(sret, (unsigned int)sret, fd, FD_API_WRITE,
+                       "dpd", fd, buf, nbyte);
 
        return sret;
 }
@@ -456,8 +519,11 @@ ssize_t readv(int fd, const struct iovec *iov, int iovcnt)
        BEFORE_ORIGINAL_FILE(readv, LIBC);
        sret = readvp(fd,iov,iovcnt);
 
-       AFTER_ORIGINAL_FD_RET(VT_SSIZE_T, sret, (unsigned int)sret, fd, FD_API_READ,
-                       "%d, %p, %d", fd, iov, iovcnt);
+       // AFTER_ORIGINAL_FD_RET(VT_SSIZE_T, sret, (unsigned int)sret, fd, FD_API_READ,
+       //              "%d, %p, %d", fd, iov, iovcnt);
+
+       AFTER_PACK_ORIGINAL_FD(sret, (unsigned int)sret, fd, FD_API_READ,
+                       "dpd", fd, iov, iovcnt);
 
        return sret;
 }
@@ -487,7 +553,8 @@ int rmdir(const char *path)
        BEFORE_ORIGINAL_FILE(rmdir, LIBC);
        _filepath = (char*)path;
        ret = rmdirp(path);
-       AFTER_ORIGINAL_NOFD(0, FD_API_DIRECTORY, "%s", path);
+       // AFTER_ORIGINAL_NOFD(0, FD_API_DIRECTORY, "%s", path);
+       AFTER_PACK_ORIGINAL_NOFD(ret, 0, FD_API_DIRECTORY, "s", path);
        return ret;
 }
 
@@ -497,7 +564,8 @@ int fchdir(int fd)
 
        BEFORE_ORIGINAL_FILE(fchdir, LIBC);
        ret = fchdirp(fd);
-       AFTER_ORIGINAL_FD(0, fd, FD_API_DIRECTORY, "%d", fd);
+       // AFTER_ORIGINAL_FD(0, fd, FD_API_DIRECTORY, "%d", fd);
+       AFTER_PACK_ORIGINAL_FD(ret, 0, fd, FD_API_DIRECTORY, "d", fd);
        return ret;
 }
 
@@ -508,7 +576,8 @@ int chdir(const char *path)
        BEFORE_ORIGINAL_FILE(chdir, LIBC);
        _filepath = (char*)path;
        ret = chdirp(path);
-       AFTER_ORIGINAL_NOFD(0, FD_API_DIRECTORY, "%s", path);
+       // AFTER_ORIGINAL_NOFD(0, FD_API_DIRECTORY, "%s", path);
+       AFTER_PACK_ORIGINAL_NOFD(ret, 0, FD_API_DIRECTORY, "s", path);
        return ret;
 }
 
@@ -519,7 +588,8 @@ int link(const char *path1, const char *path2)
        BEFORE_ORIGINAL_FILE(link, LIBC);
        _filepath = (char*)path1;
        ret = linkp(path1, path2);
-       AFTER_ORIGINAL_NOFD(0, FD_API_DIRECTORY, "%s, %s", path1, path2);
+       // AFTER_ORIGINAL_NOFD(0, FD_API_DIRECTORY, "%s, %s", path1, path2);
+       AFTER_PACK_ORIGINAL_NOFD(ret, 0, FD_API_DIRECTORY, "ss", path1, path2);
        return ret;
 }
 
@@ -530,8 +600,10 @@ int linkat(int fd1, const char *path1, int fd2, const char *path2, int flag)
        BEFORE_ORIGINAL_FILE(linkat, LIBC);
        _filepath = (char*)path1;
        ret = linkatp(fd1, path1, fd2, path2, flag);
-       AFTER_ORIGINAL_FD(0, fd2, FD_API_DIRECTORY,
-                       "%d, %s, %d, %s, %d", fd1, path2, fd2, path2, flag);
+       // AFTER_ORIGINAL_FD(0, fd2, FD_API_DIRECTORY,
+       //              "%d, %s, %d, %s, %d", fd1, path2, fd2, path2, flag);
+       AFTER_PACK_ORIGINAL_FD(ret, 0, fd2, FD_API_DIRECTORY,
+                       "dsdsd", fd1, path2, fd2, path2, flag);
        return ret;
 }
 
@@ -542,7 +614,8 @@ int unlink(const char *path)
        BEFORE_ORIGINAL_FILE(unlink, LIBC);
        _filepath = (char*)path;
        ret = unlinkp(path);
-       AFTER_ORIGINAL_NOFD(0, FD_API_DIRECTORY, "%s", path);
+       // AFTER_ORIGINAL_NOFD(0, FD_API_DIRECTORY, "%s", path);
+       AFTER_PACK_ORIGINAL_NOFD(ret, 0, FD_API_DIRECTORY, "s", path);
        return ret;
 }
 
@@ -553,7 +626,8 @@ int unlinkat(int fd, const char *path, int flag)
        BEFORE_ORIGINAL_FILE(unlinkat, LIBC);
        _filepath = (char*)path;
        ret = unlinkatp(fd, path, flag);
-       AFTER_ORIGINAL_FD(0, fd, FD_API_DIRECTORY, "%d, %s, %d", fd, path, flag);
+       // AFTER_ORIGINAL_FD(0, fd, FD_API_DIRECTORY, "%d, %s, %d", fd, path, flag);
+       AFTER_PACK_ORIGINAL_FD(ret, 0, fd, FD_API_DIRECTORY, "dsd", fd, path, flag);
        return ret;
 }
 
@@ -564,7 +638,8 @@ int symlink(const char *path1, const char *path2)
        BEFORE_ORIGINAL_FILE(symlink, LIBC);
        _filepath = (char*)path1;
        ret = symlinkp(path1, path2);
-       AFTER_ORIGINAL_NOFD(0, FD_API_DIRECTORY, "%s, %s", path1, path2);
+       // AFTER_ORIGINAL_NOFD(0, FD_API_DIRECTORY, "%s, %s", path1, path2);
+       AFTER_PACK_ORIGINAL_NOFD(ret, 0, FD_API_DIRECTORY, "ss", path1, path2);
        return ret;
 }
 
@@ -575,7 +650,8 @@ int symlinkat(const char *path1, int fd, const char *path2)
        BEFORE_ORIGINAL_FILE(symlinkat, LIBC);
        _filepath = (char*)path1;
        ret = symlinkatp(path1, fd, path2);
-       AFTER_ORIGINAL_FD(0, fd, FD_API_DIRECTORY, "%s, %d, %s", path1, fd, path2);
+       // AFTER_ORIGINAL_FD(0, fd, FD_API_DIRECTORY, "%s, %d, %s", path1, fd, path2);
+       AFTER_PACK_ORIGINAL_FD(ret, 0, fd, FD_API_DIRECTORY, "sds", path1, fd, path2);
        return ret;
 }
 
@@ -589,8 +665,11 @@ ssize_t readlink(const char* path, char* buf, size_t bufsize)
 
        sret = readlinkp(path, buf, bufsize);
 
-       AFTER_ORIGINAL_NOFD_RET(VT_SSIZE_T, sret, bufsize, FD_API_DIRECTORY,
-                       "%s, %s, %u", path, buf, bufsize);
+       // AFTER_ORIGINAL_NOFD_RET(VT_SSIZE_T, sret, bufsize, FD_API_DIRECTORY,
+       //              "%s, %s, %u", path, buf, bufsize);
+
+       AFTER_PACK_ORIGINAL_NOFD(sret, bufsize, FD_API_DIRECTORY,
+                       "ssd", path, buf, bufsize);
 
        return sret;
 }
@@ -605,8 +684,11 @@ ssize_t readlinkat(int fd, const char * path, char * buf, size_t bufsize)
 
        sret = readlinkatp(fd, path, buf, bufsize);
 
-       AFTER_ORIGINAL_FD_RET(VT_SSIZE_T, sret, bufsize, fd, FD_API_DIRECTORY,
-                       "%d, %s, %s, %u", fd, path, buf, bufsize);
+       // AFTER_ORIGINAL_FD_RET(VT_SSIZE_T, sret, bufsize, fd, FD_API_DIRECTORY,
+       //              "%d, %s, %s, %u", fd, path, buf, bufsize);
+
+       AFTER_PACK_ORIGINAL_FD(sret, bufsize, fd, FD_API_DIRECTORY,
+                       "dssd", fd, path, buf, bufsize);
 
        return sret;
 }
@@ -618,7 +700,8 @@ int mkdir(const char *path, mode_t mode)
        BEFORE_ORIGINAL_FILE(mkdir, LIBC);
        _filepath = (char*)path;
        ret = mkdirp(path, mode);
-       AFTER_ORIGINAL_NOFD(0, FD_API_DIRECTORY, "%s, %u", path, mode);
+       // AFTER_ORIGINAL_NOFD(0, FD_API_DIRECTORY, "%s, %u", path, mode);
+       AFTER_PACK_ORIGINAL_NOFD(ret, 0, FD_API_DIRECTORY, "sd", path, mode);
        return ret;
 }
 
@@ -629,7 +712,8 @@ int mkdirat(int fd, const char *path, mode_t mode)
        BEFORE_ORIGINAL_FILE(mkdirat, LIBC);
        _filepath = (char*)path;
        ret = mkdiratp(fd, path, mode);
-       AFTER_ORIGINAL_FD(0, fd, FD_API_DIRECTORY, "%d, %s, %u", fd, path, mode);
+       // AFTER_ORIGINAL_FD(0, fd, FD_API_DIRECTORY, "%d, %s, %u", fd, path, mode);
+       AFTER_PACK_ORIGINAL_FD(ret, 0, fd, FD_API_DIRECTORY, "dsd", fd, path, mode);
        return ret;
 }
 
@@ -639,7 +723,8 @@ int closedir(DIR *dirp)
 
        BEFORE_ORIGINAL_FILE(closedir, LIBC);
        ret = closedirp(dirp);
-       AFTER_ORIGINAL_NOFD(0, FD_API_DIRECTORY, "%p", dirp);
+       // AFTER_ORIGINAL_NOFD(0, FD_API_DIRECTORY, "%p", dirp);
+       AFTER_PACK_ORIGINAL_NOFD(ret, 0, FD_API_DIRECTORY, "p", dirp);
        return ret;
 }
 
@@ -652,7 +737,9 @@ DIR *fdopendir(int fd)
 
        dret = fdopendirp(fd);
 
-       AFTER_ORIGINAL_FD_RET(VT_PTR, dret, 0, fd, FD_API_DIRECTORY, "%d", fd);
+       // AFTER_ORIGINAL_FD_RET(VT_PTR, dret, 0, fd, FD_API_DIRECTORY, "%d", fd);
+
+       AFTER_PACK_ORIGINAL_FD(dret, 0, fd, FD_API_DIRECTORY, "d", fd);
 
        return dret;
 }
@@ -667,7 +754,9 @@ DIR *opendir(const char *dirname)
 
        dret = opendirp(dirname);
 
-       AFTER_ORIGINAL_NOFD_RET(VT_PTR, dret, 0, FD_API_DIRECTORY, "%s", dirname);
+       // AFTER_ORIGINAL_NOFD_RET(VT_PTR, dret, 0, FD_API_DIRECTORY, "%s", dirname);
+
+       AFTER_PACK_ORIGINAL_NOFD(dret, 0, FD_API_DIRECTORY, "s", dirname);
 
        return dret;
 }
@@ -681,7 +770,9 @@ struct dirent *readdir(DIR *dirp)
 
        dret = readdirp(dirp);
        
-       AFTER_ORIGINAL_NOFD_RET(VT_PTR, dret, 0, FD_API_DIRECTORY, "%p", dirp);
+       // AFTER_ORIGINAL_NOFD_RET(VT_PTR, dret, 0, FD_API_DIRECTORY, "%p", dirp);
+
+       AFTER_PACK_ORIGINAL_NOFD(dret, 0, FD_API_DIRECTORY, "p", dirp);
 
        return dret;
 }
@@ -692,7 +783,8 @@ int readdir_r(DIR * dirp, struct dirent * entry, struct dirent ** result)
 
        BEFORE_ORIGINAL_FILE(readdir_r, LIBC);
        ret = readdir_rp(dirp, entry, result);
-       AFTER_ORIGINAL_NOFD(0, FD_API_DIRECTORY, "%p, %p, %p", dirp, entry, result);
+       // AFTER_ORIGINAL_NOFD(0, FD_API_DIRECTORY, "%p, %p, %p", dirp, entry, result);
+       AFTER_PACK_ORIGINAL_NOFD(ret, 0, FD_API_DIRECTORY, "ppp", dirp, entry, result);
        return ret;
 }
 
@@ -704,7 +796,8 @@ void rewinddir(DIR *dirp)
 
        rewinddirp(dirp);
        
-       AFTER_ORIGINAL_NOFD_RET(VT_NULL, NULL, 0, FD_API_DIRECTORY, "%p", dirp);
+       // AFTER_ORIGINAL_NOFD_RET(VT_NULL, NULL, 0, FD_API_DIRECTORY, "%p", dirp);
+       AFTER_PACK_ORIGINAL_NOFD(0, 0, FD_API_DIRECTORY, "p", dirp);
 }
 
 void seekdir(DIR *dirp, long loc)
@@ -715,8 +808,10 @@ void seekdir(DIR *dirp, long loc)
 
        seekdirp(dirp, loc);
 
-       AFTER_ORIGINAL_NOFD_RET(VT_NULL, NULL, 0, FD_API_DIRECTORY,
-                       "%p, %ld", dirp, loc);
+       // AFTER_ORIGINAL_NOFD_RET(VT_NULL, NULL, 0, FD_API_DIRECTORY,
+       //              "%p, %ld", dirp, loc);
+
+       AFTER_PACK_ORIGINAL_NOFD(0, 0, FD_API_DIRECTORY, "px", dirp, loc);
 }
 
 long telldir(DIR *dirp)
@@ -728,7 +823,9 @@ long telldir(DIR *dirp)
 
        lret = telldirp(dirp);
 
-       AFTER_ORIGINAL_NOFD_RET(VT_LONG, lret, 0, FD_API_DIRECTORY, "%p", dirp);
+       // AFTER_ORIGINAL_NOFD_RET(VT_LONG, lret, 0, FD_API_DIRECTORY, "%p", dirp);
+
+       AFTER_PACK_ORIGINAL_NOFD(lret, 0, FD_API_DIRECTORY, "p", dirp);
 
        return lret;
 }
@@ -751,7 +848,9 @@ int fcntl(int fd, int cmd, ...)
 
        ret = fcntlp(fd, cmd, arg);
 
-       AFTER_ORIGINAL_FD(0, fd, FD_API_OTHER, "%d, %d, %d", fd, cmd, arg);
+       // AFTER_ORIGINAL_FD(0, fd, FD_API_OTHER, "%d, %d, %d", fd, cmd, arg);
+
+       AFTER_PACK_ORIGINAL_FD(ret, 0, fd, FD_API_OTHER, "ddd", fd, cmd, arg);
 
        return ret;
 }
@@ -764,7 +863,9 @@ int dup(int fd)
 
        ret = dupp(fd);
 
-       AFTER_ORIGINAL_FD(0, ret, FD_API_OPEN, "%d", fd);
+       // AFTER_ORIGINAL_FD(0, ret, FD_API_OPEN, "%d", fd);
+
+       AFTER_PACK_ORIGINAL_FD(ret, 0, ret, FD_API_OPEN, "d", fd);
 
        return ret;
 }
@@ -777,7 +878,9 @@ int dup2(int fd, int fd2)
 
        ret = dup2p(fd, fd2);
 
-       AFTER_ORIGINAL_FD(0, ret, FD_API_OPEN, "%d, %d", fd, fd2);
+       // AFTER_ORIGINAL_FD(0, ret, FD_API_OPEN, "%d, %d", fd, fd2);
+
+       AFTER_PACK_ORIGINAL_FD(ret, 0, ret, FD_API_OPEN, "dd", fd, fd2);
 
        return ret;
 }
@@ -791,7 +894,8 @@ int fstat(int fd, struct stat *buf)
 
        BEFORE_ORIGINAL_FILE(fstat, LIBC);
        ret = fstatp(fd, buf);
-       AFTER_ORIGINAL_FD(0, fd, FD_API_OTHER, "%d, %p", fd, buf);
+       // AFTER_ORIGINAL_FD(0, fd, FD_API_OTHER, "%d, %p", fd, buf);
+       AFTER_PACK_ORIGINAL_FD(ret, 0, fd, FD_API_OTHER, "dp", fd, buf);
        return ret;
 }
 
@@ -802,7 +906,8 @@ int stat(const char * path, struct stat * buf)
        BEFORE_ORIGINAL_FILE(stat, LIBC);
        _filepath = (char*)path;
        ret = statp(path, buf);
-       AFTER_ORIGINAL_NOFD(0, FD_API_OTHER, "%s, %p", path, buf);
+       // AFTER_ORIGINAL_NOFD(0, FD_API_OTHER, "%s, %p", path, buf);
+       AFTER_PACK_ORIGINAL_NOFD(ret, 0, FD_API_OTHER, "sp", path, buf);
        return ret;
 }
 
@@ -815,7 +920,8 @@ int fstatat(int fd, const char * path, struct stat * buf, int flag)
        BEFORE_ORIGINAL_FILE(fstatat, LIBC);
        _filepath = (char*)path;
        ret = fstatatp(fd, path, buf, flag);
-       AFTER_ORIGINAL_FD(0, fd, FD_API_OTHER, "%d, %s, %p, %d", fd, path, buf, flag);
+       // AFTER_ORIGINAL_FD(0, fd, FD_API_OTHER, "%d, %s, %p, %d", fd, path, buf, flag);
+       AFTER_PACK_ORIGINAL_FD(ret, 0, fd, FD_API_OTHER, "dspd", fd, path, buf, flag);
        return ret;
 }
 
@@ -826,7 +932,8 @@ int lstat(const char * path, struct stat * buf)
        BEFORE_ORIGINAL_FILE(lstat, LIBC);
        _filepath = (char*)path;
        ret = lstatp(path, buf);
-       AFTER_ORIGINAL_NOFD(0, FD_API_OTHER, "%s, %p", path, buf);
+       // AFTER_ORIGINAL_NOFD(0, FD_API_OTHER, "%s, %p", path, buf);
+       AFTER_PACK_ORIGINAL_NOFD(ret, 0, FD_API_OTHER, "sp", path, buf);
        return ret;
 }
 
@@ -836,7 +943,8 @@ int futimens(int fd, const struct timespec times[2])
 
        BEFORE_ORIGINAL_FILE(futimens, LIBC);
        ret = futimensp(fd, times);
-       AFTER_ORIGINAL_FD(0, fd, FD_API_OTHER, "%d, %p", fd, times);
+       // AFTER_ORIGINAL_FD(0, fd, FD_API_OTHER, "%d, %p", fd, times);
+       AFTER_PACK_ORIGINAL_FD(ret, 0, fd, FD_API_OTHER, "dp", fd, times);
        return ret;
 }
 
@@ -847,8 +955,9 @@ int utimensat(int fd, const char *path, const struct timespec times[2], int flag
        BEFORE_ORIGINAL_FILE(utimensat, LIBC);
        _filepath = (char*)path;
        ret = utimensatp(fd, path, times, flag);
-       AFTER_ORIGINAL_FD(0, fd, FD_API_OTHER,
-                       "%d, %s, %p, %d", fd, path, times, flag);
+       // AFTER_ORIGINAL_FD(0, fd, FD_API_OTHER,
+       //              "%d, %s, %p, %d", fd, path, times, flag);
+       AFTER_PACK_ORIGINAL_FD(ret, 0, fd, FD_API_OTHER, "dspd", fd, path, times, flag);
        return ret;
 }
 
@@ -859,7 +968,8 @@ int utimes(const char *path, const struct timeval times[2])
        BEFORE_ORIGINAL_FILE(utimes, LIBC);
        _filepath = (char*)path;
        ret = utimesp(path, times);
-       AFTER_ORIGINAL_NOFD(0, FD_API_OTHER, "%s, %p", path, times);
+       // AFTER_ORIGINAL_NOFD(0, FD_API_OTHER, "%s, %p", path, times);
+       AFTER_PACK_ORIGINAL_NOFD(ret, 0, FD_API_OTHER, "sp", path, times);
        return ret;
 }
 
@@ -870,7 +980,8 @@ int utime(const char *path, const struct utimbuf *times)
        BEFORE_ORIGINAL_FILE(utime, LIBC);
        _filepath = (char*)path;
        ret = utimep(path, times);
-       AFTER_ORIGINAL_NOFD(0, FD_API_OTHER, "%s, %p", path, times);
+       // AFTER_ORIGINAL_NOFD(0, FD_API_OTHER, "%s, %p", path, times);
+       AFTER_PACK_ORIGINAL_NOFD(ret, 0, FD_API_OTHER, "sp", path, times);
        return ret;
 }
 

diff --git a/probe_file/da_io_stdc.c b/probe_file/da_io_stdc.c
index aa673b9..bcdc519 100644 (file)
--- a/probe_file/da_io_stdc.c
+++ b/probe_file/da_io_stdc.c
@@ -40,6 +40,8 @@
 #include "dahelper.h"
 #include "da_io.h"
 
+#include "binproto.h"
+
 static enum DaOptions _sopt = OPT_FILE;
 
 FILE* fopen(const char* filename, const char* mode)
@@ -52,7 +54,9 @@ FILE* fopen(const char* filename, const char* mode)
        
        fret = fopenp(filename, mode);
        
-       AFTER_ORIGINAL_FILEP_RET(VT_PTR, fret, 0, fret, FD_API_OPEN, "%s, %s", filename, mode);
+       //AFTER_ORIGINAL_FILEP_RET(VT_PTR, fret, 0, fret, FD_API_OPEN, "%s, %s", filename, mode);
+
+       AFTER_PACK_ORIGINAL_FILEP(fret, 0, fret, FD_API_OPEN, "ss", filename, mode);
 
        return fret;
 }
@@ -67,8 +71,10 @@ FILE* freopen(const char * filename, const char * mode, FILE * stream)
 
        fret = freopenp(filename, mode, stream);
 
-       AFTER_ORIGINAL_FILEP_RET(VT_PTR, fret, 0, fret, FD_API_OPEN,
-                       "%s, %s, %p", filename, mode, stream);
+       // AFTER_ORIGINAL_FILEP_RET(VT_PTR, fret, 0, fret, FD_API_OPEN,
+       //              "%s, %s, %p", filename, mode, stream);
+
+       AFTER_PACK_ORIGINAL_FILEP(fret, 0, fret, FD_API_OPEN, "ssp", filename, mode, stream);
 
        return fret;
 }
@@ -82,7 +88,9 @@ FILE* fdopen(int fildes, const char *mode)
 
        fret = fdopenp(fildes, mode);
 
-       AFTER_ORIGINAL_FILEP_RET(VT_PTR, fret, 0, fret, FD_API_OPEN, "%d, %s", fildes, mode);
+       // AFTER_ORIGINAL_FILEP_RET(VT_PTR, fret, 0, fret, FD_API_OPEN, "%d, %s", fildes, mode);
+
+       AFTER_PACK_ORIGINAL_FILEP(fret, 0, fret, FD_API_OPEN, "ds", fildes, mode);
 
        return fret;
 }
@@ -93,7 +101,8 @@ int fflush(FILE* stream)
 
        BEFORE_ORIGINAL_FILE(fflush, LIBC);
        ret = fflushp(stream);
-       AFTER_ORIGINAL_FILEP(0, stream, FD_API_OTHER, "%p", stream);
+       // AFTER_ORIGINAL_FILEP(0, stream, FD_API_OTHER, "%p", stream);
+       AFTER_PACK_ORIGINAL_FILEP(ret, 0, stream, FD_API_OTHER, "p", stream);
        return ret;
 }
 
@@ -113,11 +122,18 @@ int fclose(FILE* stream)
        PRE_PROBEBLOCK_END();
 
        ret = fclosep(stream);
-
+/*
        POST_PROBEBLOCK_BEGIN(LC_RESOURCE, VT_INT, ret, "%p", stream);
        POST_PROBEBLOCK_MIDDLE_FD(0, _fd, FD_API_CLOSE);
        POST_PROBEBLOCK_CALLSTACK_RESOURCE(FD_API_CLOSE);
        POST_PROBEBLOCK_END();
+*/
+       POST_PACK_PROBEBLOCK_BEGIN();
+       PREPARE_LOCAL_BUF();
+       PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE, LC_RESOURCE, "p", stream);
+       PACK_COMMON_END(ret, newerrno, blockresult);
+       POST_PACK_PROBEBLOCK_MIDDLE_FD(0, _fd, FD_API_CLOSE);
+       POST_PACK_PROBEBLOCK_END();
 
        return ret;
 }
@@ -129,7 +145,8 @@ int remove(const char* filename)
        BEFORE_ORIGINAL_FILE(remove, LIBC);
        _filepath = (char*)filename;
        ret = removep(filename);
-       AFTER_ORIGINAL_NOFD(0, FD_API_DIRECTORY, "%s", filename);
+       // AFTER_ORIGINAL_NOFD(0, FD_API_DIRECTORY, "%s", filename);
+       AFTER_PACK_ORIGINAL_NOFD(ret, 0, FD_API_DIRECTORY, "s", filename);
        return ret;
 }
 
@@ -140,7 +157,8 @@ int rename(const char* oldname, const char* newname)
        BEFORE_ORIGINAL_FILE(rename, LIBC);
        _filepath = (char*)newname;
        ret = renamep(oldname, newname);
-       AFTER_ORIGINAL_NOFD(0, FD_API_DIRECTORY, "%s, %s", oldname, newname);
+       // AFTER_ORIGINAL_NOFD(0, FD_API_DIRECTORY, "%s, %s", oldname, newname);
+       AFTER_PACK_ORIGINAL_NOFD(ret, 0, FD_API_DIRECTORY, "ss", oldname, newname);
        return ret;
 }
 
@@ -152,9 +170,8 @@ FILE * tmpfile ( void )
        BEFORE_ORIGINAL_FILE_NOFILTER(tmpfile, LIBC);
        _filepath = "<temp file>";
        fret = tmpfilep();
-
-       AFTER_ORIGINAL_FILEP_RET(VT_PTR, fret, 0, fret, FD_API_OPEN, "%s", "");
-
+       // AFTER_ORIGINAL_FILEP_RET(VT_PTR, fret, 0, fret, FD_API_OPEN, "%s", "");
+       AFTER_PACK_ORIGINAL_FILEP(fret, 0, fret, FD_API_OPEN, "s", "");
        return fret;
 }
 
@@ -164,7 +181,8 @@ int fgetpos(FILE* stream, fpos_t* position)
 
        BEFORE_ORIGINAL_FILE(fgetpos, LIBC);
        ret = fgetposp(stream, position);
-       AFTER_ORIGINAL_FILEP(0, stream, FD_API_OTHER, "%p, %p", stream, position);
+       // AFTER_ORIGINAL_FILEP(0, stream, FD_API_OTHER, "%p, %p", stream, position);
+       AFTER_PACK_ORIGINAL_FILEP(ret, 0, stream, FD_API_OTHER, "pp", stream, position);
        return ret;
 }
 
@@ -174,8 +192,10 @@ int fseek(FILE* stream, long int offset, int origin)
 
        BEFORE_ORIGINAL_FILE(fseek, LIBC);
        ret = fseekp(stream, offset, origin);
-       AFTER_ORIGINAL_FILEP((unsigned int)offset, stream, FD_API_OTHER,
-                       "%p, %ld, %d", stream, offset, origin);
+       // AFTER_ORIGINAL_FILEP((unsigned int)offset, stream, FD_API_OTHER,
+       //              "%p, %ld, %d", stream, offset, origin);
+       AFTER_PACK_ORIGINAL_FILEP(ret, (unsigned int)offset, stream, FD_API_OTHER,
+                       "pxd", stream, offset, origin);
        return ret;
 }
 
@@ -185,7 +205,8 @@ int fsetpos(FILE* stream, const fpos_t* pos)
 
        BEFORE_ORIGINAL_FILE(fsetpos, LIBC);
        ret = fsetposp(stream, pos);
-       AFTER_ORIGINAL_FILEP(0, stream, FD_API_OTHER, "%p, %p", stream, pos);
+       // AFTER_ORIGINAL_FILEP(0, stream, FD_API_OTHER, "%p, %p", stream, pos);
+       AFTER_PACK_ORIGINAL_FILEP(ret, 0, stream, FD_API_OTHER, "pp", stream, pos);
        return ret;
 }
 
@@ -198,7 +219,9 @@ long int ftell(FILE* stream)
        
        lret = ftellp(stream);
 
-       AFTER_ORIGINAL_FILEP_RET(VT_LONG, lret, 0, stream, FD_API_OTHER, "%p", stream);
+       // AFTER_ORIGINAL_FILEP_RET(VT_LONG, lret, 0, stream, FD_API_OTHER, "%p", stream);
+
+       AFTER_PACK_ORIGINAL_FILEP(lret, 0, stream, FD_API_OTHER, "p", stream);
 
        return lret;
 }
@@ -211,7 +234,9 @@ void rewind(FILE* stream)
 
        rewindp(stream);
        
-       AFTER_ORIGINAL_FILEP_RET(VT_NULL, NULL, 0, stream, FD_API_OTHER, "%p", stream);
+       // AFTER_ORIGINAL_FILEP_RET(VT_NULL, NULL, 0, stream, FD_API_OTHER, "%p", stream);
+
+       AFTER_PACK_ORIGINAL_FILEP(0, 0, stream, FD_API_OTHER, "p", stream);
 }
 
 void clearerr(FILE* stream)
@@ -222,7 +247,9 @@ void clearerr(FILE* stream)
 
        clearerrp(stream);
        
-       AFTER_ORIGINAL_FILEP_RET(VT_NULL, NULL, 0, stream, FD_API_OTHER, "%p", stream);
+       // AFTER_ORIGINAL_FILEP_RET(VT_NULL, NULL, 0, stream, FD_API_OTHER, "%p", stream);
+
+       AFTER_PACK_ORIGINAL_FILEP(0, 0, stream, FD_API_OTHER, "p", stream);
 }
 
 int feof(FILE* stream)
@@ -231,7 +258,8 @@ int feof(FILE* stream)
 
        BEFORE_ORIGINAL_FILE(feof, LIBC);
        ret = feofp(stream);
-       AFTER_ORIGINAL_FILEP(0, stream, FD_API_OTHER, "%p", stream);
+       // AFTER_ORIGINAL_FILEP(0, stream, FD_API_OTHER, "%p", stream);
+       AFTER_PACK_ORIGINAL_FILEP(ret, 0, stream, FD_API_OTHER, "p", stream);
        return ret;
 }
 
@@ -241,7 +269,8 @@ int ferror(FILE* stream)
 
        BEFORE_ORIGINAL_FILE(ferror, LIBC);
        ret = ferrorp(stream);
-       AFTER_ORIGINAL_FILEP(0, stream, FD_API_OTHER, "%p", stream);
+       // AFTER_ORIGINAL_FILEP(0, stream, FD_API_OTHER, "%p", stream);
+       AFTER_PACK_ORIGINAL_FILEP(ret, 0, stream, FD_API_OTHER, "p", stream);
        return ret;
 }
 
@@ -251,7 +280,8 @@ int fileno(FILE* stream)
 
        BEFORE_ORIGINAL_FILE(fileno, LIBC);
        ret = filenop(stream);
-       AFTER_ORIGINAL_FILEP(0, stream, FD_API_OTHER, "%p", stream);
+       // AFTER_ORIGINAL_FILEP(0, stream, FD_API_OTHER, "%p", stream);
+       AFTER_PACK_ORIGINAL_FILEP(ret, 0, stream, FD_API_OTHER, "p", stream);
        return ret;
 }
 
@@ -263,7 +293,9 @@ void perror(const char* string)
 
        perrorp(string);
 
-       AFTER_ORIGINAL_NOFD_RET(VT_NULL, NULL, 0, FD_API_OTHER, "%s", string);
+       // AFTER_ORIGINAL_NOFD_RET(VT_NULL, NULL, 0, FD_API_OTHER, "%s", string);
+
+       AFTER_PACK_ORIGINAL_NOFD(0, 0, FD_API_OTHER, "s", string);
 }
 
 // *******************************************************************
@@ -276,7 +308,8 @@ int vfprintf(FILE* stream, const char* format, va_list arg)
 
        BEFORE_ORIGINAL_FILE(vfprintf, LIBC);
        ret = vfprintfp(stream, format, arg);
-       AFTER_ORIGINAL_FILEP(ret, stream, FD_API_WRITE, "%p, %s", stream, format);
+       // AFTER_ORIGINAL_FILEP(ret, stream, FD_API_WRITE, "%p, %s", stream, format);
+       AFTER_PACK_ORIGINAL_FILEP(ret, ret, stream, FD_API_WRITE, "ps", stream, format);
        return ret;
 }
 
@@ -286,7 +319,8 @@ int vfscanf(FILE* stream, const char* format, va_list arg)
 
        BEFORE_ORIGINAL_FILE(vfscanf, LIBC);
        ret = vfscanfp(stream, format, arg);
-       AFTER_ORIGINAL_FILEP(ret, stream, FD_API_READ, "%p, %s", stream, format);
+       // AFTER_ORIGINAL_FILEP(ret, stream, FD_API_READ, "%p, %s", stream, format);
+       AFTER_PACK_ORIGINAL_FILEP(ret, ret, stream, FD_API_READ, "ps", stream, format);
        return ret;
 }
 
@@ -296,7 +330,8 @@ int fgetc(FILE* stream)
 
        BEFORE_ORIGINAL_FILE(fgetc, LIBC);
        ret = fgetcp(stream);
-       AFTER_ORIGINAL_FILEP((ret == EOF ? 0 : 1), stream, FD_API_READ, "%p", stream);
+       // AFTER_ORIGINAL_FILEP((ret == EOF ? 0 : 1), stream, FD_API_READ, "%p", stream);
+       AFTER_PACK_ORIGINAL_FILEP(ret, (ret == EOF ? 0 : 1), stream, FD_API_READ, "p", stream);
        return ret;
 }
 
@@ -310,8 +345,11 @@ char* fgets(char* str, int size, FILE* stream)
        
        cret = fgetsp(str, size, stream);
 
-       AFTER_ORIGINAL_FILEP_RET(VT_STR, cret, (ret == NULL ? 0 : strlen(cret)),
-                       stream, FD_API_READ, "%s, %d, %p", str, size, stream);
+       // AFTER_ORIGINAL_FILEP_RET(VT_STR, cret, (ret == NULL ? 0 : strlen(cret)),
+       //              stream, FD_API_READ, "%s, %d, %p", str, size, stream);
+
+       AFTER_PACK_ORIGINAL_FILEP(cret, (ret == NULL ? 0 : strlen(cret)),
+                       stream, FD_API_READ, "sdp", str, size, stream);
 
        return cret;
 }
@@ -323,8 +361,10 @@ int fputc(int character, FILE* stream)
 
        BEFORE_ORIGINAL_FILE(fputc, LIBC);
        ret = fputcp(character, stream);
-       AFTER_ORIGINAL_FILEP((ret == EOF ? 0 : 1), stream, FD_API_WRITE,
-                       "%d, %p", character, stream);
+       // AFTER_ORIGINAL_FILEP((ret == EOF ? 0 : 1), stream, FD_API_WRITE,
+       //              "%d, %p", character, stream);
+       AFTER_PACK_ORIGINAL_FILEP(ret, (ret == EOF ? 0 : 1), stream, FD_API_WRITE,
+                       "dp", character, stream);
        return ret;
 }
 
@@ -334,7 +374,8 @@ int fputs(const char* str, FILE* stream)
 
        BEFORE_ORIGINAL_FILE(fputs, LIBC);
        ret = fputsp(str, stream);
-       AFTER_ORIGINAL_FILEP(ret, stream, FD_API_WRITE, "%s, %p", str, stream);
+       // AFTER_ORIGINAL_FILEP(ret, stream, FD_API_WRITE, "%s, %p", str, stream);
+       AFTER_PACK_ORIGINAL_FILEP(ret, ret, stream, FD_API_WRITE, "sp", str, stream);
        return ret;
 }
 
@@ -344,7 +385,8 @@ int getc(FILE* stream)
 
        BEFORE_ORIGINAL_FILE(getc, LIBC);
        ret = getcp(stream);
-       AFTER_ORIGINAL_FILEP((ret == EOF ? 0 : 1), stream, FD_API_READ, "%p", stream);
+       // AFTER_ORIGINAL_FILEP((ret == EOF ? 0 : 1), stream, FD_API_READ, "%p", stream);
+       AFTER_PACK_ORIGINAL_FILEP(ret, (ret == EOF ? 0 : 1), stream, FD_API_READ, "p", stream);
        return ret;
 }
 
@@ -354,8 +396,10 @@ int putc(int character, FILE* stream)
 
        BEFORE_ORIGINAL_FILE(putc, LIBC);
        ret = putcp(character, stream);
-       AFTER_ORIGINAL_FILEP((ret == EOF ? 0 : 1), stream, FD_API_WRITE,
-                       "%d, %p", character, stream);
+       // AFTER_ORIGINAL_FILEP((ret == EOF ? 0 : 1), stream, FD_API_WRITE,
+       //              "%d, %p", character, stream);
+       AFTER_PACK_ORIGINAL_FILEP(ret, (ret == EOF ? 0 : 1), stream, FD_API_WRITE,
+                       "dp", character, stream);
        return ret;
 }
 
@@ -365,7 +409,8 @@ int ungetc(int character, FILE* stream)
 
        BEFORE_ORIGINAL_FILE(ungetc, LIBC);
        ret = ungetcp(character, stream);
-       AFTER_ORIGINAL_FILEP(0, stream, FD_API_OTHER, "%d, %p", character, stream);
+       // AFTER_ORIGINAL_FILEP(0, stream, FD_API_OTHER, "%d, %p", character, stream);
+       AFTER_PACK_ORIGINAL_FILEP(ret, 0, stream, FD_API_OTHER, "dp", character, stream);
        return ret;
 }
 
@@ -378,9 +423,12 @@ size_t fread(void* ptr, size_t size, size_t count, FILE* stream)
 
        tret = freadp(ptr, size, count, stream);
        
-       AFTER_ORIGINAL_FILEP_RET(VT_SIZE_T, tret, 0, stream, FD_API_READ,
-                       "%p, %u, %u, %p", ptr, size, count, stream);
-       
+       // AFTER_ORIGINAL_FILEP_RET(VT_SIZE_T, tret, 0, stream, FD_API_READ,
+       //              "%p, %u, %u, %p", ptr, size, count, stream);
+
+       AFTER_PACK_ORIGINAL_FILEP(tret, 0, stream, FD_API_READ,
+                       "pxxp", ptr, size, count, stream);      
+
        return tret;
 }
 
@@ -393,8 +441,11 @@ size_t fwrite(const void* ptr, size_t size, size_t count, FILE* stream)
 
        tret = fwritep(ptr, size, count, stream);
 
-       AFTER_ORIGINAL_FILEP_RET(VT_SIZE_T, tret, 0, stream, FD_API_WRITE,
-                       "%p, %u, %u, %p", ptr, size, count, stream);
+       // AFTER_ORIGINAL_FILEP_RET(VT_SIZE_T, tret, 0, stream, FD_API_WRITE,
+       //              "%p, %u, %u, %p", ptr, size, count, stream);
+
+       AFTER_PACK_ORIGINAL_FILEP(tret, 0, stream, FD_API_WRITE,
+                       "pxxp", ptr, size, count, stream);
 
        return tret;
 }
@@ -412,7 +463,8 @@ int fprintf(FILE* stream, const char* format, ...)
        va_start(arg, format);
        ret = vfprintfp(stream, format, arg);
 
-       AFTER_ORIGINAL_FILEP(ret, stream, FD_API_WRITE, "%p, %s, ...", stream, format);
+       // AFTER_ORIGINAL_FILEP(ret, stream, FD_API_WRITE, "%p, %s, ...", stream, format);
+       AFTER_PACK_ORIGINAL_FILEP(ret, ret, stream, FD_API_WRITE, "ps", stream, format);
        va_end(arg);
 
        return ret;
@@ -428,7 +480,8 @@ int fscanf(FILE* stream, const char* format, ...)
        va_start(arg, format);
        ret = vfscanfp(stream, format, arg);
 
-       AFTER_ORIGINAL_FILEP(ret, stream, FD_API_READ, "%p, %s, ...", stream, format);
+       // AFTER_ORIGINAL_FILEP(ret, stream, FD_API_READ, "%p, %s, ...", stream, format);
+       AFTER_PACK_ORIGINAL_FILEP(ret, ret, stream, FD_API_READ, "ps", stream, format);
        va_end(arg);
 
        return ret;
@@ -445,7 +498,8 @@ int printf(const char* format, ...)
        va_start(arg, format);
        ret = vprintfp(format, arg);
 
-       AFTER_ORIGINAL_NOFD(ret, FD_API_WRITE, "%s,...", format);
+       // AFTER_ORIGINAL_NOFD(ret, FD_API_WRITE, "%s,...", format);
+       AFTER_PACK_ORIGINAL_NOFD(ret, ret, FD_API_WRITE, "s", format);
        va_end(arg);
 
        return ret;
@@ -462,7 +516,8 @@ int scanf(const char* format, ...)
        va_start(arg, format);
        ret = vscanfp(format, arg);
 
-       AFTER_ORIGINAL_NOFD(ret, FD_API_READ, "%s,...", format);
+       // AFTER_ORIGINAL_NOFD(ret, FD_API_READ, "%s,...", format);
+       AFTER_PACK_ORIGINAL_NOFD(ret, ret, FD_API_READ, "s", format);
        va_end(arg);
 
        return ret;
@@ -474,7 +529,8 @@ int getchar()
 
        BEFORE_ORIGINAL_FILE(getchar, LIBC);
        ret = getcharp();
-       AFTER_ORIGINAL_NOFD((ret == EOF ? 0 : 1), FD_API_READ, "%s", "");
+       // AFTER_ORIGINAL_NOFD((ret == EOF ? 0 : 1), FD_API_READ, "%s", "");
+       AFTER_PACK_ORIGINAL_NOFD(ret, (ret == EOF ? 0 : 1), FD_API_READ, "s", "");
        return ret;
 }
 
@@ -484,7 +540,8 @@ int putchar(int c)
 
        BEFORE_ORIGINAL_FILE(putchar, LIBC);
        ret = putcharp(c);
-       AFTER_ORIGINAL_NOFD((ret == EOF ? 0 : 1), FD_API_WRITE, "%d", c);
+       // AFTER_ORIGINAL_NOFD((ret == EOF ? 0 : 1), FD_API_WRITE, "%d", c);
+       AFTER_PACK_ORIGINAL_NOFD(ret, (ret == EOF ? 0 : 1), FD_API_WRITE, "d", c);
        return ret;
 }
 
@@ -497,7 +554,9 @@ char* gets(char* str)
 
        cret = getsp(str);
        
-       AFTER_ORIGINAL_NOFD_RET(VT_STR, cret, strlen(cret), FD_API_READ, "%s", str);
+       // AFTER_ORIGINAL_NOFD_RET(VT_STR, cret, strlen(cret), FD_API_READ, "%s", str);
+
+       AFTER_PACK_ORIGINAL_NOFD(cret, strlen(cret), FD_API_READ, "s", str);
 
        return cret;
 }
@@ -509,7 +568,8 @@ int puts(const char* str)
 
        BEFORE_ORIGINAL_FILE(puts, LIBC);
        ret = putsp(str);
-       AFTER_ORIGINAL_NOFD(ret, FD_API_WRITE, "%s", str);
+       // AFTER_ORIGINAL_NOFD(ret, FD_API_WRITE, "%s", str);
+       AFTER_PACK_ORIGINAL_NOFD(ret, ret, FD_API_WRITE, "s", str);
        return ret;
 }
 #endif
@@ -523,7 +583,9 @@ char* tmpnam(char* str)
 
        cret = tmpnamp(str);
 
-       AFTER_ORIGINAL_NOFD_RET(VT_STR, cret, 0, FD_API_OTHER, "%s", str);
+       // AFTER_ORIGINAL_NOFD_RET(VT_STR, cret, 0, FD_API_OTHER, "%s", str);
+
+       AFTER_PACK_ORIGINAL_NOFD(cret, 0, FD_API_OTHER, "s", str);
 
        return cret;
 }
@@ -536,8 +598,10 @@ void setbuf(FILE* stream, char* buf)
 
        setbufp(stream, buf);
 
-       AFTER_ORIGINAL_FILEP_RET(VT_NULL, NULL, 0, stream, FD_API_OTHER,
-                       "%p, %p", stream, buf);
+       // AFTER_ORIGINAL_FILEP_RET(VT_NULL, NULL, 0, stream, FD_API_OTHER,
+       //              "%p, %p", stream, buf);
+
+       AFTER_PACK_ORIGINAL_FILEP(0, 0, stream, FD_API_OTHER, "pp", stream, buf);
 }
 
 void setbuffer(FILE* stream, char* buf, size_t size)
@@ -548,8 +612,11 @@ void setbuffer(FILE* stream, char* buf, size_t size)
 
        setbufferp(stream, buf, size);
 
-       AFTER_ORIGINAL_FILEP_RET(VT_NULL, NULL, size, stream, FD_API_OTHER,
-                       "%p, %p, %u", stream, buf, size);
+       // AFTER_ORIGINAL_FILEP_RET(VT_NULL, NULL, size, stream, FD_API_OTHER,
+       //              "%p, %p, %u", stream, buf, size);
+
+       AFTER_PACK_ORIGINAL_FILEP(0, size, stream, FD_API_OTHER,
+                       "ppx", stream, buf, size);
 }
 
 void setlinebuf(FILE* stream)
@@ -560,7 +627,9 @@ void setlinebuf(FILE* stream)
 
        setlinebufp(stream);
 
-       AFTER_ORIGINAL_FILEP_RET(VT_NULL, NULL, 0, stream, FD_API_OTHER, "%p", stream);
+       // AFTER_ORIGINAL_FILEP_RET(VT_NULL, NULL, 0, stream, FD_API_OTHER, "%p", stream);
+
+       AFTER_PACK_ORIGINAL_FILEP(0, 0, stream, FD_API_OTHER, "p", stream);
 }
 
 int setvbuf(FILE* stream, char* buf, int mode, size_t size)
@@ -569,8 +638,10 @@ int setvbuf(FILE* stream, char* buf, int mode, size_t size)
 
        BEFORE_ORIGINAL_FILE(setvbuf, LIBC);
        ret = setvbufp(stream,buf,mode,size);
-       AFTER_ORIGINAL_FILEP(size, stream, FD_API_OTHER,
-                       "%p, %p, %d, %u", stream, buf, mode, size);
+       // AFTER_ORIGINAL_FILEP(size, stream, FD_API_OTHER,
+       //              "%p, %p, %d, %u", stream, buf, mode, size);
+       AFTER_PACK_ORIGINAL_FILEP(ret, size, stream, FD_API_OTHER,
+                       "ppdx", stream, buf, mode, size);
        return ret;
 }