[PROTO] probe_file changes

- change FD_API_ defines
- replace FD_API_READ and _WRITE by FD_API_READ_END and _WRITE_END
- add packing of FD_API_READ_START, FD_API_WRITE_START msg

diff --git a/include/probeinfo.h b/include/probeinfo.h
index 5ce0d88..0b02ff9 100755 (executable)
--- a/include/probeinfo.h
+++ b/include/probeinfo.h
@@ -75,19 +75,17 @@ extern "C"{
 
 #define                FD_API_OPEN                             0
 #define                FD_API_CLOSE                    1
-#define                FD_API_READ                             2
-#define                FD_API_WRITE                    3
-#define                FD_API_DIRECTORY                4
-#define                FD_API_PERMISSION               5
-#define                FD_API_OTHER                    6
-#define                FD_API_SEND                             7
-#define                FD_API_RECEIVE                  8
-#define                FD_API_OPTION                   9
-#define                FD_API_MANAGE                   10
-#define                FD_API_INTERNAL_START   11
-#define                FD_API_INTERNAL_CLOSE   12
-#define                FD_API_WAIT                             13
-#define                FD_API_INTERNAL_WAIT    14
+#define                FD_API_READ_START               2
+#define                FD_API_READ_END                 3
+#define                FD_API_WRITE_START              4
+#define                FD_API_WRITE_END                5
+#define                FD_API_DIRECTORY                6
+#define                FD_API_PERMISSION               7
+#define                FD_API_OTHER                    8
+#define                FD_API_SEND             9
+#define                FD_API_RECEIVE                  10
+#define                FD_API_OPTION                   11
+#define                FD_API_MANAGE                   12
 
 #define                MEMORY_API_ALLOC        0
 #define                MEMORY_API_FREE         1

diff --git a/probe_badaapi/bada_file.cpp b/probe_badaapi/bada_file.cpp
index 5d3acea..6473b19 100755 (executable)
--- a/probe_badaapi/bada_file.cpp
+++ b/probe_badaapi/bada_file.cpp
@@ -632,7 +632,7 @@ result File::Read(Tizen::Base::String& buffer) {
                                  API_ID_result_File__Read_Tizen__Base__String__buffer_,
                                  "x", (unsigned long)&buffer);
                PACK_COMMON_END(ret, ret, blockresult);
-               PACK_RESOURCE(nRead, (unsigned long)this, FD_FILE, FD_API_READ, size, temp);
+               PACK_RESOURCE(nRead, (unsigned long)this, FD_FILE, FD_API_READ_END, size, temp);
                FLUSH_LOCAL_BUF();
 
                 postBlockEnd();
@@ -686,7 +686,7 @@ result File::Read(Tizen::Base::ByteBuffer& buffer) {
                                  API_ID_result_File__Read_Tizen__Base__ByteBuffer__buffer_,
                                  "x", (unsigned long)&buffer);
                PACK_COMMON_END(ret, ret, blockresult);
-               PACK_RESOURCE(nRead, (unsigned long)this, FD_FILE, FD_API_READ, size, temp);
+               PACK_RESOURCE(nRead, (unsigned long)this, FD_FILE, FD_API_READ_END, size, temp);
                FLUSH_LOCAL_BUF();
                
                 postBlockEnd();
@@ -741,7 +741,7 @@ int File::Read(void *buffer, int length) {
                                  API_ID_int_File__Read_void__buffer__int_length_,
                                  "xd", (unsigned long)buffer, length);
                PACK_COMMON_END(ret, res, blockresult);
-               PACK_RESOURCE(nRead, (unsigned long)this, FD_FILE, FD_API_READ, size, temp);
+               PACK_RESOURCE(nRead, (unsigned long)this, FD_FILE, FD_API_READ_END, size, temp);
                FLUSH_LOCAL_BUF();
 
                 postBlockEnd();
@@ -964,7 +964,7 @@ result File::Write(const void *buffer, int length) {
                                  API_ID_result_File__Write_const_void__buffer__int_length_,
                                  "xd", (unsigned long)buffer, length);
                PACK_COMMON_END(ret, ret, blockresult);
-               PACK_RESOURCE(nWritten, (unsigned long)this, FD_FILE, FD_API_WRITE, size, temp);
+               PACK_RESOURCE(nWritten, (unsigned long)this, FD_FILE, FD_API_WRITE_END, size, temp);
                FLUSH_LOCAL_BUF();
 
                 postBlockEnd();
@@ -1018,7 +1018,7 @@ result File::Write(const Tizen::Base::ByteBuffer& buffer) {
                                  API_ID_result_File__Write_const_Tizen__Base__ByteBuffer__buffer_,
                                  "x", (unsigned long)&buffer);
                PACK_COMMON_END(ret, ret, blockresult);
-               PACK_RESOURCE(nWritten, (unsigned long)this, FD_FILE, FD_API_WRITE, size, temp);
+               PACK_RESOURCE(nWritten, (unsigned long)this, FD_FILE, FD_API_WRITE_END, size, temp);
                FLUSH_LOCAL_BUF();
 
                 postBlockEnd();
@@ -1075,7 +1075,7 @@ result File::Write(const Tizen::Base::String& buffer) {
                                  API_ID_result_File__Write_const_Tizen__Base__String__buffer_,
                                  "s", temp_buf);
                PACK_COMMON_END(ret, ret, blockresult);
-               PACK_RESOURCE(nWritten, (unsigned long)this, FD_FILE, FD_API_WRITE, size, temp_path);
+               PACK_RESOURCE(nWritten, (unsigned long)this, FD_FILE, FD_API_WRITE_END, size, temp_path);
                FLUSH_LOCAL_BUF();
 
                 postBlockEnd();

diff --git a/probe_file/da_io.h b/probe_file/da_io.h
index 6b7aa3c..aab9e80 100755 (executable)
--- a/probe_file/da_io.h
+++ b/probe_file/da_io.h
@@ -101,6 +101,20 @@
        PRE_PROBEBLOCK()
 
 // ==================================================================
+// Additional macro for READ_START and WRITE_START
+// ==================================================================
+
+#define FILE_API_START_BLOCK(API_ID, APITYPE)                                          \
+    PRE_PROBEBLOCK();                                                                                          \
+       POST_PACK_PROBEBLOCK_BEGIN();                                                                   \
+       PREPARE_LOCAL_BUF();                                                                                    \
+       PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE, API_ID, "", 0);                   \
+       PACK_COMMON_END(0, 0, 0);                                                                               \
+       PACK_RESOURCE(0, 0, FD_FILE, APITYPE, 0, _filepath);                    \
+       FLUSH_LOCAL_BUF();                                                                                              \
+       POST_PACK_PROBEBLOCK_END()
+
+// ==================================================================
 // AFTER_ORIGINAL macro for file
 // ==================================================================
 

diff --git a/probe_file/da_io_posix.c b/probe_file/da_io_posix.c
index 87e60bd..f5607cc 100755 (executable)
--- a/probe_file/da_io_posix.c
+++ b/probe_file/da_io_posix.c
@@ -73,7 +73,7 @@ int open(const char* path, int oflag, ...)
        ret = openp(path, oflag, mode);
 
        AFTER_PACK_ORIGINAL_FD(API_ID_open,
-                              ret, 0, ret, FD_API_OPEN, "sdd", path, oflag, mode);
+                                  ret, 0, ret, FD_API_OPEN, "sdd", path, oflag, mode);
 
        return ret;
 }
@@ -97,7 +97,7 @@ int openat(int fd, const char* path, int oflag, ...)
        ret = openatp(fd, path, oflag, mode);
 
        AFTER_PACK_ORIGINAL_FD(API_ID_openat,
-                              ret, 0, ret, FD_API_OPEN, "dsdd", fd, path, oflag, mode);
+                                  ret, 0, ret, FD_API_OPEN, "dsdd", fd, path, oflag, mode);
 
        return ret;
 }
@@ -112,7 +112,7 @@ int creat(const char* path, mode_t mode)
        ret = creatp(path, mode);
 
        AFTER_PACK_ORIGINAL_FD(API_ID_creat,
-                              ret, 0, ret, FD_API_OPEN, "sd", path, mode);
+                                  ret, 0, ret, FD_API_OPEN, "sd", path, mode);
 
        return ret;
 }
@@ -168,7 +168,7 @@ int faccessat(int fd, const char *path, int amode, int flag)
        ret = faccessatp(fd, path, amode, flag);
 
        AFTER_PACK_ORIGINAL_FD(API_ID_faccessat,
-                              ret, 0, fd, FD_API_PERMISSION, "dsdd", fd, path, amode, flag);
+                                  ret, 0, fd, FD_API_PERMISSION, "dsdd", fd, path, amode, flag);
 
        return ret;
 }
@@ -183,8 +183,8 @@ off_t lseek(int fd, off_t offset, int whence)
        offret = lseekp(fd, offset, whence);
 
        AFTER_PACK_ORIGINAL_FD(API_ID_lseek,
-                              offret, (unsigned int)offset, fd, FD_API_OTHER,
-                              "dxd", fd, offset, whence);
+                                  offret, (unsigned int)offset, fd, FD_API_OTHER,
+                                  "dxd", fd, offset, whence);
 
        return offret;
 }
@@ -198,7 +198,7 @@ int fsync(int fd)
        ret = fsyncp(fd);
 
        AFTER_PACK_ORIGINAL_FD(API_ID_fsync,
-                              ret, 0, fd, FD_API_OTHER, "d", fd);
+                                  ret, 0, fd, FD_API_OTHER, "d", fd);
 
        return ret;
 }
@@ -212,7 +212,7 @@ int fdatasync(int fd)
        ret = fdatasyncp(fd);
 
        AFTER_PACK_ORIGINAL_FD(API_ID_fdatasync,
-                              ret, 0, fd, FD_API_OTHER, "d", fd);
+                                  ret, 0, fd, FD_API_OTHER, "d", fd);
 
        return ret;
 }
@@ -241,7 +241,7 @@ int ftruncate(int fd, off_t length)
        ret = ftruncatep(fd, length);
 
        AFTER_PACK_ORIGINAL_FD(API_ID_ftruncate,
-                              ret, (unsigned int)length, fd, FD_API_DIRECTORY, "dx", fd, length);
+                                  ret, (unsigned int)length, fd, FD_API_DIRECTORY, "dx", fd, length);
 
        return ret;
 }
@@ -273,7 +273,7 @@ int mkfifoat(int fd, const char *path, mode_t mode)
        ret = mkfifoatp(fd, path, mode);
 
        AFTER_PACK_ORIGINAL_FD(API_ID_mkfifoat,
-                              ret, 0, fd, FD_API_OTHER, "dsd", fd, path, mode);
+                                  ret, 0, fd, FD_API_OTHER, "dsd", fd, path, mode);
 
        return ret;
 }
@@ -304,7 +304,7 @@ int mknodat(int fd, const char *path, mode_t mode, dev_t dev)
        ret = mknodatp(fd,path, mode,dev);
 
        AFTER_PACK_ORIGINAL_FD(API_ID_mknodat,
-                              ret, 0, fd, FD_API_OTHER,
+                                  ret, 0, fd, FD_API_OTHER,
                        "dsdx", fd, path, mode, (unsigned long int)dev);
 
        return ret;
@@ -334,8 +334,8 @@ int fchownat(int fd, const char *path, uid_t owner, gid_t group, int flag)
        _filepath = (char*)path;
        ret = fchownatp(fd, path, owner, group, flag);
        AFTER_PACK_ORIGINAL_FD(API_ID_fchownat,
-                              ret, 0, fd, FD_API_PERMISSION,
-                              "dsddd", fd, path, owner, group, flag);
+                                  ret, 0, fd, FD_API_PERMISSION,
+                                  "dsddd", fd, path, owner, group, flag);
        return ret;
 }
 
@@ -346,7 +346,7 @@ int fchown(int fd, uid_t owner, gid_t group)
        BEFORE_ORIGINAL_FILE(fchown, LIBC);
        ret = fchownp(fd, owner, group);
        AFTER_PACK_ORIGINAL_FD(API_ID_fchown,
-                              ret, 0, fd, FD_API_PERMISSION, "ddd", fd, owner, group);
+                                  ret, 0, fd, FD_API_PERMISSION, "ddd", fd, owner, group);
        return ret;
 }
 
@@ -369,8 +369,8 @@ int lockf(int fd, int function, off_t size)
        BEFORE_ORIGINAL_FILE(lockf, LIBC);
        ret = lockfp(fd, function, size);
        AFTER_PACK_ORIGINAL_FD(API_ID_lockf,
-                              ret, (unsigned int)size, fd, FD_API_PERMISSION,
-                              "ddx", fd, function, size);
+                                  ret, (unsigned int)size, fd, FD_API_PERMISSION,
+                                  "ddx", fd, function, size);
        return ret;
 }
 
@@ -394,8 +394,8 @@ int fchmodat(int fd, const char *path, mode_t mode, int flag)
        _filepath = (char*)path;
        ret = fchmodatp(fd, path, mode, flag);
        AFTER_PACK_ORIGINAL_FD(API_ID_fchmodat,
-                              ret,0, fd, FD_API_PERMISSION,
-                              "dsdd", fd, path, mode, flag);
+                                  ret,0, fd, FD_API_PERMISSION,
+                                  "dsdd", fd, path, mode, flag);
        return ret;
 }
 
@@ -406,7 +406,7 @@ int fchmod(int fd, mode_t mode)
        BEFORE_ORIGINAL_FILE(fchmod, LIBC);
        ret = fchmodp(fd, mode);
        AFTER_PACK_ORIGINAL_FD(API_ID_fchmod,
-                              ret, 0, fd, FD_API_PERMISSION, "dd", fd, mode);
+                                  ret, 0, fd, FD_API_PERMISSION, "dd", fd, mode);
        return ret;
 }
 
@@ -421,11 +421,13 @@ ssize_t pread(int fd, void *buf, size_t nbyte, off_t offset)
 
        BEFORE_ORIGINAL_FILE(pread, LIBC);
 
+       FILE_API_START_BLOCK(API_ID_pread, FD_API_READ_START);
+
        sret = preadp(fd, buf, nbyte, offset);
 
        AFTER_PACK_ORIGINAL_FD(API_ID_pread,
-                              sret, (unsigned int)sret, fd, FD_API_READ,
-                              "dpxx", fd, buf, nbyte, offset);
+                                  sret, (unsigned int)sret, fd, FD_API_READ_END,
+                                  "dpxx", fd, buf, nbyte, offset);
 
        return sret;
 }
@@ -436,11 +438,13 @@ ssize_t read(int fd, void *buf, size_t nbyte)
 
        BEFORE_ORIGINAL_FILE(read, LIBC);
 
+       FILE_API_START_BLOCK(API_ID_read, FD_API_READ_START);
+
        sret = readp(fd, buf, nbyte);
 
        AFTER_PACK_ORIGINAL_FD(API_ID_read,
-                              sret, (unsigned int)sret, fd, FD_API_READ,
-                              "dpx", fd, buf, nbyte);
+                                  sret, (unsigned int)sret, fd, FD_API_READ_END,
+                                  "dpx", fd, buf, nbyte);
 
        return sret;
 }
@@ -452,11 +456,13 @@ ssize_t pwrite(int fd, const void *buf, size_t nbyte, off_t offset)
 
        BEFORE_ORIGINAL_FILE(pwrite, LIBC);
 
+       FILE_API_START_BLOCK(API_ID_pwrite, FD_API_WRITE_START);
+
        sret = pwritep(fd, buf, nbyte, offset);
 
        AFTER_PACK_ORIGINAL_FD(API_ID_pwrite,
-                              sret, (unsigned int)sret, fd, FD_API_WRITE,
-                              "dpxx", fd, buf, nbyte, offset);
+                                  sret, (unsigned int)sret, fd, FD_API_WRITE_END,
+                                  "dpxx", fd, buf, nbyte, offset);
 
        return sret;
 }
@@ -468,11 +474,13 @@ ssize_t write(int fd, const void *buf, size_t nbyte)
 
        BEFORE_ORIGINAL_FILE(write, LIBC);
 
+       FILE_API_START_BLOCK(API_ID_write, FD_API_WRITE_START);
+
        sret = writep(fd, buf, nbyte);
 
        AFTER_PACK_ORIGINAL_FD(API_ID_write,
-                              sret, (unsigned int)sret, fd, FD_API_WRITE,
-                              "dpx", fd, buf, nbyte);
+                                  sret, (unsigned int)sret, fd, FD_API_WRITE_END,
+                                  "dpx", fd, buf, nbyte);
 
        return sret;
 }
@@ -484,11 +492,14 @@ ssize_t readv(int fd, const struct iovec *iov, int iovcnt)
        ssize_t sret;
 
        BEFORE_ORIGINAL_FILE(readv, LIBC);
+
+       FILE_API_START_BLOCK(API_ID_readv, FD_API_READ_START);
+
        sret = readvp(fd,iov,iovcnt);
 
        AFTER_PACK_ORIGINAL_FD(API_ID_readv,
-                              sret, (unsigned int)sret, fd, FD_API_READ,
-                              "dpd", fd, iov, iovcnt);
+                                  sret, (unsigned int)sret, fd, FD_API_READ_END,
+                                  "dpd", fd, iov, iovcnt);
 
        return sret;
 }
@@ -530,7 +541,7 @@ int fchdir(int fd)
        BEFORE_ORIGINAL_FILE(fchdir, LIBC);
        ret = fchdirp(fd);
        AFTER_PACK_ORIGINAL_FD(API_ID_fchdir,
-                              ret, 0, fd, FD_API_DIRECTORY, "d", fd);
+                                  ret, 0, fd, FD_API_DIRECTORY, "d", fd);
        return ret;
 }
 
@@ -566,8 +577,8 @@ int linkat(int fd1, const char *path1, int fd2, const char *path2, int flag)
        _filepath = (char*)path1;
        ret = linkatp(fd1, path1, fd2, path2, flag);
        AFTER_PACK_ORIGINAL_FD(API_ID_linkat,
-                              ret, 0, fd2, FD_API_DIRECTORY,
-                              "dsdsd", fd1, path2, fd2, path2, flag);
+                                  ret, 0, fd2, FD_API_DIRECTORY,
+                                  "dsdsd", fd1, path2, fd2, path2, flag);
        return ret;
 }
 
@@ -591,7 +602,7 @@ int unlinkat(int fd, const char *path, int flag)
        _filepath = (char*)path;
        ret = unlinkatp(fd, path, flag);
        AFTER_PACK_ORIGINAL_FD(API_ID_unlinkat,
-                              ret, 0, fd, FD_API_DIRECTORY, "dsd", fd, path, flag);
+                                  ret, 0, fd, FD_API_DIRECTORY, "dsd", fd, path, flag);
        return ret;
 }
 
@@ -615,7 +626,7 @@ int symlinkat(const char *path1, int fd, const char *path2)
        _filepath = (char*)path1;
        ret = symlinkatp(path1, fd, path2);
        AFTER_PACK_ORIGINAL_FD(API_ID_symlinkat,
-                              ret, 0, fd, FD_API_DIRECTORY, "sds", path1, fd, path2);
+                                  ret, 0, fd, FD_API_DIRECTORY, "sds", path1, fd, path2);
        return ret;
 }
 
@@ -647,8 +658,8 @@ ssize_t readlinkat(int fd, const char * path, char * buf, size_t bufsize)
        sret = readlinkatp(fd, path, buf, bufsize);
 
        AFTER_PACK_ORIGINAL_FD(API_ID_readlinkat,
-                              sret, bufsize, fd, FD_API_DIRECTORY,
-                              "dssx", fd, path, buf, bufsize);
+                                  sret, bufsize, fd, FD_API_DIRECTORY,
+                                  "dssx", fd, path, buf, bufsize);
 
        return sret;
 }
@@ -673,7 +684,7 @@ int mkdirat(int fd, const char *path, mode_t mode)
        _filepath = (char*)path;
        ret = mkdiratp(fd, path, mode);
        AFTER_PACK_ORIGINAL_FD(API_ID_mkdirat,
-                              ret, 0, fd, FD_API_DIRECTORY, "dsd", fd, path, mode);
+                                  ret, 0, fd, FD_API_DIRECTORY, "dsd", fd, path, mode);
        return ret;
 }
 
@@ -698,7 +709,7 @@ DIR *fdopendir(int fd)
        dret = fdopendirp(fd);
 
        AFTER_PACK_ORIGINAL_FD(API_ID_fdopendir,
-                              dret, 0, fd, FD_API_DIRECTORY, "d", fd);
+                                  dret, 0, fd, FD_API_DIRECTORY, "d", fd);
 
        return dret;
 }
@@ -803,7 +814,7 @@ int fcntl(int fd, int cmd, ...)
        ret = fcntlp(fd, cmd, arg);
 
        AFTER_PACK_ORIGINAL_FD(API_ID_fcntl,
-                              ret, 0, fd, FD_API_OTHER, "ddd", fd, cmd, arg);
+                                  ret, 0, fd, FD_API_OTHER, "ddd", fd, cmd, arg);
 
        return ret;
 }
@@ -817,7 +828,7 @@ int dup(int fd)
        ret = dupp(fd);
 
        AFTER_PACK_ORIGINAL_FD(API_ID_dup,
-                              ret, 0, ret, FD_API_OPEN, "d", fd);
+                                  ret, 0, ret, FD_API_OPEN, "d", fd);
 
        return ret;
 }
@@ -831,7 +842,7 @@ int dup2(int fd, int fd2)
        ret = dup2p(fd, fd2);
 
        AFTER_PACK_ORIGINAL_FD(API_ID_dup2,
-                              ret, 0, ret, FD_API_OPEN, "dd", fd, fd2);
+                                  ret, 0, ret, FD_API_OPEN, "dd", fd, fd2);
 
        return ret;
 }
@@ -870,7 +881,7 @@ int fstatat(int fd, const char * path, struct stat * buf, int flag)
        _filepath = (char*)path;
        ret = fstatatp(fd, path, buf, flag);
        AFTER_PACK_ORIGINAL_FD(API_ID_fstatat,
-                              ret, 0, fd, FD_API_OTHER, "dspd", fd, path, buf, flag);
+                                  ret, 0, fd, FD_API_OTHER, "dspd", fd, path, buf, flag);
        return ret;
 }
 
@@ -893,7 +904,7 @@ int futimens(int fd, const struct timespec times[2])
        BEFORE_ORIGINAL_FILE(futimens, LIBC);
        ret = futimensp(fd, times);
        AFTER_PACK_ORIGINAL_FD(API_ID_futimens,
-                              ret, 0, fd, FD_API_OTHER, "dp", fd, times);
+                                  ret, 0, fd, FD_API_OTHER, "dp", fd, times);
        return ret;
 }
 
@@ -905,7 +916,7 @@ int utimensat(int fd, const char *path, const struct timespec times[2], int flag
        _filepath = (char*)path;
        ret = utimensatp(fd, path, times, flag);
        AFTER_PACK_ORIGINAL_FD(API_ID_utimensat,
-                              ret, 0, fd, FD_API_OTHER, "dspd", fd, path, times, flag);
+                                  ret, 0, fd, FD_API_OTHER, "dspd", fd, path, times, flag);
        return ret;
 }
 

diff --git a/probe_file/da_io_stdc.c b/probe_file/da_io_stdc.c
index f2db156..570eb71 100644 (file)
--- a/probe_file/da_io_stdc.c
+++ b/probe_file/da_io_stdc.c
@@ -297,9 +297,10 @@ int vfprintf(FILE* stream, const char* format, va_list arg)
        static int (*vfprintfp)(FILE* stream, const char* format, va_list arg);
 
        BEFORE_ORIGINAL_FILE(vfprintf, LIBC);
+       FILE_API_START_BLOCK(API_ID_vfprintf, FD_API_WRITE_START);
        ret = vfprintfp(stream, format, arg);
        AFTER_PACK_ORIGINAL_FILEP(API_ID_vfprintf,
-                                 ret, ret, stream, FD_API_WRITE, "ps", stream, format);
+                                 ret, ret, stream, FD_API_WRITE_END, "ps", stream, format);
        return ret;
 }
 
@@ -308,9 +309,10 @@ int vfscanf(FILE* stream, const char* format, va_list arg)
        static int (*vfscanfp)(FILE* stream, const char* format, va_list arg);
 
        BEFORE_ORIGINAL_FILE(vfscanf, LIBC);
+       FILE_API_START_BLOCK(API_ID_vfscanf, FD_API_READ_START);
        ret = vfscanfp(stream, format, arg);
        AFTER_PACK_ORIGINAL_FILEP(API_ID_vfscanf,
-                                 ret, ret, stream, FD_API_READ, "ps", stream, format);
+                                 ret, ret, stream, FD_API_READ_END, "ps", stream, format);
        return ret;
 }
 
@@ -319,9 +321,10 @@ int fgetc(FILE* stream)
        static int (*fgetcp)(FILE* stream);
 
        BEFORE_ORIGINAL_FILE(fgetc, LIBC);
+       FILE_API_START_BLOCK(API_ID_fgetc, FD_API_READ_START);
        ret = fgetcp(stream);
        AFTER_PACK_ORIGINAL_FILEP(API_ID_fgetc,
-                                 ret, (ret == EOF ? 0 : 1), stream, FD_API_READ, "p", stream);
+                                 ret, (ret == EOF ? 0 : 1), stream, FD_API_READ_END, "p", stream);
        return ret;
 }
 
@@ -332,11 +335,13 @@ char* fgets(char* str, int size, FILE* stream)
        char* cret;
 
        BEFORE_ORIGINAL_FILE(fgets, LIBC);
+
+       FILE_API_START_BLOCK(API_ID_fgets, FD_API_READ_START);
        
        cret = fgetsp(str, size, stream);
 
-       AFTER_PACK_ORIGINAL_FILEP(cret, (ret == NULL ? 0 : strlen(cret)),
-                       stream, FD_API_READ, "sdp", str, size, stream);
+       AFTER_PACK_ORIGINAL_FILEP(API_ID_fgets, cret, (ret == NULL ? 0 : strlen(cret)),
+                       stream, FD_API_READ_END, "sdp", str, size, stream);
 
        return cret;
 }
@@ -347,9 +352,10 @@ int fputc(int character, FILE* stream)
        static int (*fputcp)(int character, FILE* stream);
 
        BEFORE_ORIGINAL_FILE(fputc, LIBC);
+       FILE_API_START_BLOCK(API_ID_fputc, FD_API_WRITE_START);
        ret = fputcp(character, stream);
        AFTER_PACK_ORIGINAL_FILEP(API_ID_fputc,
-                                 ret, (ret == EOF ? 0 : 1), stream, FD_API_WRITE,
+                                 ret, (ret == EOF ? 0 : 1), stream, FD_API_WRITE_END,
                                  "dp", character, stream);
        return ret;
 }
@@ -359,9 +365,10 @@ int fputs(const char* str, FILE* stream)
        static int (*fputsp)(const char* str, FILE* stream);
 
        BEFORE_ORIGINAL_FILE(fputs, LIBC);
+       FILE_API_START_BLOCK(API_ID_fputs, FD_API_WRITE_START);
        ret = fputsp(str, stream);
        AFTER_PACK_ORIGINAL_FILEP(API_ID_fputs,
-                                 ret, ret, stream, FD_API_WRITE, "sp", str, stream);
+                                 ret, ret, stream, FD_API_WRITE_END, "sp", str, stream);
        return ret;
 }
 
@@ -370,9 +377,10 @@ int getc(FILE* stream)
        static int (*getcp)(FILE* stream);
 
        BEFORE_ORIGINAL_FILE(getc, LIBC);
+       FILE_API_START_BLOCK(API_ID_getc, FD_API_READ_START);
        ret = getcp(stream);
        AFTER_PACK_ORIGINAL_FILEP(API_ID_getc,
-                                 ret, (ret == EOF ? 0 : 1), stream, FD_API_READ, "p", stream);
+                                 ret, (ret == EOF ? 0 : 1), stream, FD_API_READ_END, "p", stream);
        return ret;
 }
 
@@ -381,9 +389,10 @@ int putc(int character, FILE* stream)
        static int (*putcp)(int character, FILE* stream);
 
        BEFORE_ORIGINAL_FILE(putc, LIBC);
+       FILE_API_START_BLOCK(API_ID_putc, FD_API_WRITE_START);
        ret = putcp(character, stream);
        AFTER_PACK_ORIGINAL_FILEP(API_ID_putc,
-                                 ret, (ret == EOF ? 0 : 1), stream, FD_API_WRITE,
+                                 ret, (ret == EOF ? 0 : 1), stream, FD_API_WRITE_END,
                                  "dp", character, stream);
        return ret;
 }
@@ -406,10 +415,12 @@ size_t fread(void* ptr, size_t size, size_t count, FILE* stream)
 
        BEFORE_ORIGINAL_FILE(fread, LIBC);
 
+       FILE_API_START_BLOCK(API_ID_fread, FD_API_READ_START);
+
        tret = freadp(ptr, size, count, stream);
 
        AFTER_PACK_ORIGINAL_FILEP(API_ID_fread,
-                                 tret, 0, stream, FD_API_READ,
+                                 tret, 0, stream, FD_API_READ_END,
                                  "pxxp", ptr, size, count, stream);    
 
        return tret;
@@ -422,10 +433,12 @@ size_t fwrite(const void* ptr, size_t size, size_t count, FILE* stream)
 
        BEFORE_ORIGINAL_FILE(fwrite, LIBC);
 
+       FILE_API_START_BLOCK(API_ID_fwrite, FD_API_WRITE_START);
+
        tret = fwritep(ptr, size, count, stream);
 
        AFTER_PACK_ORIGINAL_FILEP(API_ID_fwrite,
-                                 tret, 0, stream, FD_API_WRITE,
+                                 tret, 0, stream, FD_API_WRITE_END,
                                  "pxxp", ptr, size, count, stream);
 
        return tret;
@@ -440,12 +453,14 @@ int fprintf(FILE* stream, const char* format, ...)
 
        BEFORE_ORIGINAL_FILE(vfprintf, LIBC);
 
+       FILE_API_START_BLOCK(API_ID_fprintf, FD_API_WRITE_START);
+
        va_list arg;
        va_start(arg, format);
        ret = vfprintfp(stream, format, arg);
 
        AFTER_PACK_ORIGINAL_FILEP(API_ID_fprintf,
-                                 ret, ret, stream, FD_API_WRITE, "ps", stream, format);
+                                 ret, ret, stream, FD_API_WRITE_END, "ps", stream, format);
        va_end(arg);
 
        return ret;
@@ -457,12 +472,14 @@ int fscanf(FILE* stream, const char* format, ...)
        
        BEFORE_ORIGINAL_FILE(vfscanf, LIBC);
 
+       FILE_API_START_BLOCK(API_ID_fscanf, FD_API_READ_START);
+
        va_list arg;
        va_start(arg, format);
        ret = vfscanfp(stream, format, arg);
 
        AFTER_PACK_ORIGINAL_FILEP(API_ID_fscanf,
-                                 ret, ret, stream, FD_API_READ, "ps", stream, format);
+                                 ret, ret, stream, FD_API_READ_END, "ps", stream, format);
        va_end(arg);
 
        return ret;
@@ -475,12 +492,14 @@ int printf(const char* format, ...)
        
        BEFORE_ORIGINAL_FILE(vprintf, LIBC);
 
+       FILE_API_START_BLOCK(API_ID_printf, FD_API_WRITE_START);
+
        va_list arg;
        va_start(arg, format);
        ret = vprintfp(format, arg);
 
        AFTER_PACK_ORIGINAL_NOFD(API_ID_printf,
-                                ret, ret, FD_API_WRITE, "s", format);
+                                ret, ret, FD_API_WRITE_END, "s", format);
        va_end(arg);
 
        return ret;
@@ -493,12 +512,14 @@ int scanf(const char* format, ...)
 
        BEFORE_ORIGINAL_FILE(vscanf, LIBC);
 
+       FILE_API_START_BLOCK(API_ID_scanf, FD_API_READ_START);
+
        va_list arg;
        va_start(arg, format);
        ret = vscanfp(format, arg);
 
        AFTER_PACK_ORIGINAL_NOFD(API_ID_scanf,
-                                ret, ret, FD_API_READ, "s", format);
+                                ret, ret, FD_API_READ_END, "s", format);
        va_end(arg);
 
        return ret;
@@ -509,9 +530,10 @@ int getchar()
        static int (*getcharp)();
 
        BEFORE_ORIGINAL_FILE(getchar, LIBC);
+       FILE_API_START_BLOCK(API_ID_getchar, FD_API_READ_START);
        ret = getcharp();
        AFTER_PACK_ORIGINAL_NOFD(API_ID_getchar,
-                                ret, (ret == EOF ? 0 : 1), FD_API_READ, "s", "");
+                                ret, (ret == EOF ? 0 : 1), FD_API_READ_END, "s", "");
        return ret;
 }
 
@@ -520,9 +542,10 @@ int putchar(int c)
        static int (*putcharp)(int c);
 
        BEFORE_ORIGINAL_FILE(putchar, LIBC);
+       FILE_API_START_BLOCK(API_ID_putchar, FD_API_WRITE_START);
        ret = putcharp(c);
        AFTER_PACK_ORIGINAL_NOFD(API_ID_putchar,
-                                ret, (ret == EOF ? 0 : 1), FD_API_WRITE, "d", c);
+                                ret, (ret == EOF ? 0 : 1), FD_API_WRITE_END, "d", c);
        return ret;
 }
 
@@ -533,10 +556,12 @@ char* gets(char* str)
 
        BEFORE_ORIGINAL_FILE(gets, LIBC);
 
+       FILE_API_START_BLOCK(API_ID_gets, FD_API_READ_START);
+
        cret = getsp(str);
 
        AFTER_PACK_ORIGINAL_NOFD(API_ID_gets,
-                                cret, strlen(cret), FD_API_READ, "s", str);
+                                cret, strlen(cret), FD_API_READ_END, "s", str);
 
        return cret;
 }
@@ -547,9 +572,10 @@ int puts(const char* str)
        static int (*putsp)(const char* str);
 
        BEFORE_ORIGINAL_FILE(puts, LIBC);
+       FILE_API_START_BLOCK(API_ID_puts, FD_API_WRITE_START);
        ret = putsp(str);
        AFTER_PACK_ORIGINAL_NOFD(API_ID_puts,
-                                ret, ret, FD_API_WRITE, "s", str);
+                                ret, ret, FD_API_WRITE_END, "s", str);
        return ret;
 }
 #endif