} \
errno = (newerrno != 0) ? newerrno : olderrno
+// ====================== start/end pre/post block macro ==================
+
+#define PRE_START_END_PROBEBLOCK_BEGIN(LCTYPE, INPUTFORMAT, ...) \
+ PRE_PROBEBLOCK_BEGIN(); \
+ INIT_LOG; \
+ APPEND_LOG_BASIC(LCTYPE); \
+ APPEND_LOG_INPUT(INPUTFORMAT, __VA_ARGS__); \
+ log.length += sprintf(log.data + log.length, "`,`,0`,0`,%d", blockresult); \
+ APPEND_LOG_CALLER()
+
+#define POST_START_END_PROBEBLOCK_BEGIN(LCTYPE, RETTYPE, RETVALUE, INPUTFORMAT, ...) \
+ newerrno = errno; \
+ if(postBlockBegin(blockresult)) { \
+ setProbePoint(&probeInfo); \
+ INIT_LOG; \
+ APPEND_LOG_BASIC(LCTYPE); \
+ APPEND_LOG_INPUT(INPUTFORMAT, __VA_ARGS__); \
+ APPEND_LOG_RESULT(RETTYPE, RETVALUE); \
+ APPEND_LOG_CALLER()
+
// ===================== unconditional probe block ========================
#define PRE_UNCONDITIONAL_BLOCK_BEGIN() \
\r
#define FD_API_OPEN 0\r
#define FD_API_CLOSE 1\r
-#define FD_API_READ 2\r
-#define FD_API_WRITE 3\r
-#define FD_API_DIRECTORY 4\r
-#define FD_API_PERMISSION 5\r
-#define FD_API_OTHER 6\r
-#define FD_API_SEND 7\r
-#define FD_API_RECEIVE 8\r
-#define FD_API_OPTION 9\r
-#define FD_API_MANAGE 10\r
-#define FD_API_INTERNAL_START 11\r
-#define FD_API_INTERNAL_CLOSE 12\r
-#define FD_API_WAIT 13\r
-#define FD_API_INTERNAL_WAIT 14\r
+#define FD_API_READ_START 2\r
+#define FD_API_READ_END 3\r
+#define FD_API_WRITE_START 4\r
+#define FD_API_WRITE_END 5\r
+#define FD_API_DIRECTORY 6\r
+#define FD_API_PERMISSION 7\r
+#define FD_API_OTHER 8\r
+#define FD_API_SEND 9\r
+#define FD_API_RECEIVE 10\r
+#define FD_API_OPTION 11\r
+#define FD_API_MANAGE 12\r
\r
#define MEMORY_API_ALLOC 0\r
#define MEMORY_API_FREE 1\r
if((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
setProbePoint(&probeInfo);
+ log.type = 0;
+ log.length = 0;
+ log.data[0] = '\0';
+ log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d",
+ LC_RESOURCE, probeInfo.eventIndex, "File::Read",
+ probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
+ //Input,ret
+ log.length += sprintf(log.data + log.length,"`,0x%x`,",(unsigned int)&buffer);
+ //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
+ if(E_SUCCESS == File::GetAttributes(this->GetName(),attr))
+ size = attr.GetFileSize();
+ WcharToChar(temp,this->GetName().GetPointer());
+ log.length += sprintf(log.data + log.length,"`,0`,0`,%d`,%u`,0`,0x%x`,%d`,%d`,%lld`,%s",blockresult,(unsigned int)CALLER_ADDRESS,(unsigned int)this,FD_FILE,FD_API_READ_START,size,temp);
+ //callstack
+ log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
+ log.length += sprintf(log.data + log.length, "`,callstack_end");
+ printLog(&log, MSG_LOG);
preBlockEnd();
}
ret = (this->*Readp)(buffer);
if(postBlockBegin(blockresult)) {
+ setProbePoint(&probeInfo);
log.type = 0;
log.length = 0;
log.data[0] = '\0';
if((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
setProbePoint(&probeInfo);
+ log.type = 0;
+ log.length = 0;
+ log.data[0] = '\0';
+ log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d",
+ LC_RESOURCE, probeInfo.eventIndex, "File::Read",
+ probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
+ //Input,ret
+ log.length += sprintf(log.data + log.length,"`,0x%x`,",(unsigned int)&buffer);
+ //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
+ if(E_SUCCESS == File::GetAttributes(this->GetName(),attr))
+ size = attr.GetFileSize();
+ WcharToChar(temp,this->GetName().GetPointer());
+ log.length += sprintf(log.data + log.length,"`,0`,0`,%d`,%u`,0`,0x%x`,%d`,%d`,%lld`,%s",blockresult,(unsigned int)CALLER_ADDRESS,(unsigned int)this,FD_FILE,FD_API_READ_START,size,temp);
+ log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
+ log.length += sprintf(log.data + log.length, "`,callstack_end");
+ printLog(&log, MSG_LOG);
preBlockEnd();
}
ret = (this->*Readp)(buffer);
if(postBlockBegin(blockresult)) {
+ setProbePoint(&probeInfo);
log.type = 0;
log.length = 0;
log.data[0] = '\0';
if((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
setProbePoint(&probeInfo);
nRead = Tell();
+ log.type = 0;
+ log.length = 0;
+ log.data[0] = '\0';
+ log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d",
+ LC_RESOURCE, probeInfo.eventIndex, "File::Read",
+ probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
+ //Input,ret
+ log.length += sprintf(log.data + log.length,"`,0x%x, %d`,",(unsigned int)buffer,length);
+ //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
+ if(E_SUCCESS == File::GetAttributes(this->GetName(),attr))
+ size = attr.GetFileSize();
+ WcharToChar(temp,this->GetName().GetPointer());
+ log.length += sprintf(log.data + log.length,"`,0`,0`,%d`,%u`,0`,0x%x`,%d`,%d`,%lld`,%s",blockresult,(unsigned int)CALLER_ADDRESS,(unsigned int)this,FD_FILE,FD_API_READ_START,size,temp);
+ log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
+ log.length += sprintf(log.data + log.length, "`,callstack_end");
+ printLog(&log, MSG_LOG);
preBlockEnd();
}
result res = GetLastResult();
if(postBlockBegin(blockresult)) {
+ setProbePoint(&probeInfo);
log.type = 0;
log.length = 0;
log.data[0] = '\0';
if((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
setProbePoint(&probeInfo);
nWritten = Tell();
+ log.type = 0;
+ log.length = 0;
+ log.data[0] = '\0';
+ log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d",
+ LC_RESOURCE, probeInfo.eventIndex, "File::Write",
+ probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
+ //Input,ret
+ log.length += sprintf(log.data + log.length,"`,0x%x, %d`,",(unsigned int)buffer,length);
+ //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
+ if(E_SUCCESS == File::GetAttributes(this->GetName(),attr))
+ size = attr.GetFileSize();
+ WcharToChar(temp,this->GetName().GetPointer());
+ log.length += sprintf(log.data + log.length,"`,0`,0`,%d`,%u`,0`,0x%x`,%d`,%d`,%lld`,%s",blockresult,(unsigned int)CALLER_ADDRESS,(unsigned int)this,FD_FILE,FD_API_WRITE_START,size,temp);
+ log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
+ log.length += sprintf(log.data + log.length, "`,callstack_end");
+ printLog(&log, MSG_LOG);
preBlockEnd();
}
ret = (this->*Writep)(buffer, length);
if(postBlockBegin(blockresult)) {
+ setProbePoint(&probeInfo);
log.type = 0;
log.length = 0;
log.data[0] = '\0';
if((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
setProbePoint(&probeInfo);
nWritten = Tell();
+ log.type = 0;
+ log.length = 0;
+ log.data[0] = '\0';
+ log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d",
+ LC_RESOURCE, probeInfo.eventIndex, "File::Write",
+ probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
+ //Input,ret
+ log.length += sprintf(log.data + log.length,"`,0x%x`,",(unsigned int)&buffer);
+ //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
+ if(E_SUCCESS == File::GetAttributes(this->GetName(),attr))
+ size = attr.GetFileSize();
+ WcharToChar(temp,this->GetName().GetPointer());
+ log.length += sprintf(log.data + log.length,"`,0`,0`,%d`,%u`,0`,0x%x`,%d`,%d`,%lld`,%s",blockresult,(unsigned int)CALLER_ADDRESS,(unsigned int)this,FD_FILE,FD_API_WRITE_START,size,temp);
+ log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
+ log.length += sprintf(log.data + log.length, "`,callstack_end");
+ printLog(&log, MSG_LOG);
preBlockEnd();
}
ret = (this->*Writep)(buffer);
if(postBlockBegin(blockresult)) {
+ setProbePoint(&probeInfo);
log.type = 0;
log.length = 0;
log.data[0] = '\0';
if((blockresult = preBlockBegin(CALLER_ADDRESS, bfiltering, _sopt)) != 0) {
setProbePoint(&probeInfo);
nWritten = Tell();
+ log.type = 0;
+ log.length = 0;
+ log.data[0] = '\0';
+ log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d",
+ LC_RESOURCE, probeInfo.eventIndex, "File::Write",
+ probeInfo.currentTime, probeInfo.pID, probeInfo.tID);
+ //Input,ret
+ WcharToChar(temp,buffer.GetPointer());
+ log.length += sprintf(log.data + log.length,"`,%s`,",temp);
+ //PCAddr,errno,InternalCall,size,FD,FDType,FDApiType,FileSize,FilePath
+ if(E_SUCCESS == File::GetAttributes(this->GetName(),attr))
+ size = attr.GetFileSize();
+ WcharToChar(temp,this->GetName().GetPointer());
+ log.length += sprintf(log.data + log.length,"`,0`,0`,%d`,%u`,0`,0x%x`,%d`,%d`,%lld`,%s",blockresult,(unsigned int)CALLER_ADDRESS,(unsigned int)this,FD_FILE,FD_API_WRITE_START,size,temp);
+ log.length += sprintf(log.data + log.length, "`,\ncallstack_start`,");
+ log.length += sprintf(log.data + log.length, "`,callstack_end");
+ printLog(&log, MSG_LOG);
preBlockEnd();
}
ret = (this->*Writep)(buffer);
if(postBlockBegin(blockresult)) {
+ setProbePoint(&probeInfo);
log.type = 0;
log.length = 0;
log.data[0] = '\0';
#define AFTER_ORIGINAL_FILEP(SIZE, FILEP, APITYPE, INPUTFORMAT, ...) \\r
AFTER_ORIGINAL_FILEP_RET(VT_INT, ret, SIZE, FILEP, APITYPE, INPUTFORMAT, __VA_ARGS__)\r
\r
+// ==================================================================\r
+// START_END macro for file\r
+// ==================================================================\r
+\r
+#define BEFORE_ORIGINAL_START_END_FD(FUNCNAME, LIBNAME, FD, APITYPE, INPUTFORMAT, ...) \\r
+ DECLARE_VARIABLE_FD; \\r
+ GET_REAL_FUNC(FUNCNAME, LIBNAME); \\r
+ PRE_START_END_PROBEBLOCK_BEGIN(LC_RESOURCE, INPUTFORMAT, __VA_ARGS__); \\r
+ _fstatret = fstat(FD, &_statbuf); \\r
+ POST_PROBEBLOCK_MIDDLE_FD(0, FD, APITYPE); \\r
+ APPEND_LOG_NULL_CALLSTACK(); \\r
+ printLog(&log, MSG_LOG); \\r
+ PRE_PROBEBLOCK_END()\r
+\r
+#define BEFORE_ORIGINAL_START_END_NOFD(FUNCNAME, LIBNAME, APITYPE, INPUTFORMAT, ...) \\r
+ DECLARE_VARIABLE_FD; \\r
+ GET_REAL_FUNC(FUNCNAME, LIBNAME); \\r
+ PRE_START_END_PROBEBLOCK_BEGIN(LC_RESOURCE, INPUTFORMAT, __VA_ARGS__); \\r
+ POST_PROBEBLOCK_MIDDLE_NOFD(0, APITYPE); \\r
+ APPEND_LOG_NULL_CALLSTACK(); \\r
+ printLog(&log, MSG_LOG); \\r
+ PRE_PROBEBLOCK_END()\r
+\r
+\r
+#define BEFORE_ORIGINAL_START_END_FILEP(FUNCNAME, LIBNAME, FILEP, APITYPE, INPUTFORMAT, ...) \\r
+ DECLARE_VARIABLE_FD; \\r
+ GET_REAL_FUNC(FUNCNAME, LIBNAME); \\r
+ PRE_START_END_PROBEBLOCK_BEGIN(LC_RESOURCE, INPUTFORMAT, __VA_ARGS__); \\r
+ GET_FD_FROM_FILEP(FILEP); \\r
+ if(_fd != -1) { \\r
+ _fstatret = fstat(_fd, &_statbuf); \\r
+ } \\r
+ if(_fstatret != 0) PRINTMSG("ERROR : fstat error\n"); \\r
+ POST_PROBEBLOCK_MIDDLE_FD(0, _fd, APITYPE); \\r
+ APPEND_LOG_NULL_CALLSTACK(); \\r
+ printLog(&log, MSG_LOG); \\r
+ PRE_PROBEBLOCK_END()\r
+\r
+#define AFTER_ORIGINAL_START_END_FD_RET(RTYPE, RVAL, SIZE, FD, APITYPE, INPUTFORMAT, ...) \\r
+ POST_START_END_PROBEBLOCK_BEGIN(LC_RESOURCE, RTYPE, RVAL, INPUTFORMAT, __VA_ARGS__); \\r
+ _fstatret = fstat(FD, &_statbuf); \\r
+ POST_PROBEBLOCK_MIDDLE_FD(SIZE, FD, APITYPE); \\r
+ POST_PROBEBLOCK_CALLSTACK_RESOURCE(APITYPE); \\r
+ POST_PROBEBLOCK_END()\r
+\r
+#define AFTER_ORIGINAL_START_END_NOFD_RET(RTYPE, RVAL, SIZE, APITYPE, INPUTFORMAT, ...) \\r
+ POST_START_END_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_ORIGINAL_START_END_FILEP_RET(RTYPE, RVAL, SIZE, FILEP, APITYPE, INPUTFORMAT, ...) \\r
+ POST_START_END_PROBEBLOCK_BEGIN(LC_RESOURCE, RTYPE, RVAL, INPUTFORMAT, __VA_ARGS__); \\r
+ GET_FD_FROM_FILEP(FILEP); \\r
+ if(_fd != -1) { \\r
+ _fstatret = fstat(_fd, &_statbuf); \\r
+ } \\r
+ if(_fstatret != 0) PRINTMSG("ERROR : fstat error\n"); \\r
+ POST_PROBEBLOCK_MIDDLE_FD(SIZE, _fd, APITYPE); \\r
+ POST_PROBEBLOCK_CALLSTACK_RESOURCE(APITYPE); \\r
+ POST_PROBEBLOCK_END()\r
+\r
+#define AFTER_ORIGINAL_START_END_FD(SIZE, FD, APITYPE, INPUTFORMAT, ...) \\r
+ AFTER_ORIGINAL_START_END_FD_RET(VT_INT, ret, SIZE, FD, APITYPE, INPUTFORMAT, __VA_ARGS__)\r
+\r
+#define AFTER_ORIGINAL_START_END_NOFD(SIZE, APITYPE, INPUTFORMAT, ...) \\r
+ AFTER_ORIGINAL_START_END_NOFD_RET(VT_INT, ret, SIZE, APITYPE, INPUTFORMAT, __VA_ARGS__)\r
+\r
+#define AFTER_ORIGINAL_START_END_FILEP(SIZE, FILEP, APITYPE, INPUTFORMAT, ...) \\r
+ AFTER_ORIGINAL_START_END_FILEP_RET(VT_INT, ret, SIZE, FILEP, APITYPE, INPUTFORMAT, __VA_ARGS__)\r
+\r
#endif // __DA_IO_H__\r
static ssize_t (*preadp)(int fd, void *buf, size_t nbyte, off_t offset);
ssize_t sret;
+#if 0
BEFORE_ORIGINAL_FILE(pread, LIBC);
-
+#else
+ BEFORE_ORIGINAL_START_END_FD(pread, LIBC, fd, FD_API_READ_START, "%d, %p, %u, %ld", fd, buf, nbyte, offset);
+#endif
sret = preadp(fd, buf, nbyte, offset);
+#if 0
AFTER_ORIGINAL_FD_RET(VT_SSIZE_T, sret, (unsigned int)sret, fd, FD_API_READ,
"%d, %p, %u, %ld", fd, buf, nbyte, offset);
-
+#else
+ AFTER_ORIGINAL_START_END_FD_RET(VT_SSIZE_T, sret, (unsigned int)sret, fd, FD_API_READ_END, "%d, %p, %u, %ld", fd, buf, nbyte, offset);
+#endif
return sret;
}
ssize_t read(int fd, void *buf, size_t nbyte)
static ssize_t (*readp)(int fildes, void *buf, size_t nbyte);
ssize_t sret;
+#if 0
BEFORE_ORIGINAL_FILE(read, LIBC);
+#else
+ BEFORE_ORIGINAL_START_END_FD(read, LIBC, fd, FD_API_READ_START, "%d, %p, %u", fd, buf, nbyte);
+#endif
sret = readp(fd, buf, nbyte);
+#if 0
AFTER_ORIGINAL_FD_RET(VT_SSIZE_T, sret, (unsigned int)sret, fd, FD_API_READ,
"%d, %p, %u", fd, buf, nbyte);
+#else
+ AFTER_ORIGINAL_START_END_FD_RET(VT_SSIZE_T, sret, (unsigned int)sret, fd, FD_API_READ_END, "%d, %p, %u", fd, buf, nbyte);
+#endif
return sret;
}
static ssize_t (*pwritep)(int fd, const void *buf, size_t nbyte, off_t offset);
ssize_t sret;
+#if 0
BEFORE_ORIGINAL_FILE(pwrite, LIBC);
-
+#else
+ BEFORE_ORIGINAL_START_END_FD(pwrite, LIBC, fd, FD_API_WRITE_START, "%d, %p, %u, %ld", fd, buf, nbyte, offset);
+#endif
sret = pwritep(fd, buf, nbyte, offset);
+#if 0
AFTER_ORIGINAL_FD_RET(VT_SSIZE_T, sret, (unsigned int)sret, fd, FD_API_WRITE,
"%d, %p, %u, %ld", fd, buf, nbyte, offset);
-
+#else
+ AFTER_ORIGINAL_START_END_FD_RET(VT_SSIZE_T, sret, (unsigned int)sret, fd, FD_API_WRITE_END, "%d, %p, %u, %ld", fd, buf, nbyte, offset);
+#endif
return sret;
}
static ssize_t (*writep)(int fildes, const void *buf, size_t nbyte);
ssize_t sret;
+#if 0
BEFORE_ORIGINAL_FILE(write, LIBC);
-
+#else
+ BEFORE_ORIGINAL_START_END_FD(write, LIBC, fd, FD_API_WRITE_START, "%d, %p, %u", fd, buf, nbyte);
+#endif
sret = writep(fd, buf, nbyte);
+#if 0
AFTER_ORIGINAL_FD_RET(VT_SSIZE_T, sret, (unsigned int)sret, fd, FD_API_WRITE,
"%d, %p, %u", fd, buf, nbyte);
-
+#else
+ AFTER_ORIGINAL_START_END_FD_RET(VT_SSIZE_T, sret, (unsigned int)sret, fd, FD_API_WRITE_END, "%d, %p, %u", fd, buf, nbyte);
+#endif
return sret;
}
static ssize_t (*readvp)(int fd, const struct iovec *iov, int iovcnt);
ssize_t sret;
+#if 0
BEFORE_ORIGINAL_FILE(readv, LIBC);
+#else
+ BEFORE_ORIGINAL_START_END_FD(readv, LIBC, fd, FD_API_READ_START, "%d, %p, %d", fd, iov, iovcnt);
+#endif
sret = readvp(fd,iov,iovcnt);
+#if 0
AFTER_ORIGINAL_FD_RET(VT_SSIZE_T, sret, (unsigned int)sret, fd, FD_API_READ,
"%d, %p, %d", fd, iov, iovcnt);
-
+#else
+ AFTER_ORIGINAL_START_END_FD_RET(VT_SSIZE_T, sret, (unsigned int)sret, fd, FD_API_READ_END, "%d, %p, %d", fd, iov, iovcnt);
+#endif
return sret;
}
{
static int (*vfprintfp)(FILE* stream, const char* format, va_list arg);
+#if 0
BEFORE_ORIGINAL_FILE(vfprintf, LIBC);
+#else
+ BEFORE_ORIGINAL_START_END_FILEP(vfprintf, LIBC, stream, FD_API_WRITE_START, "%p, %s", stream, format);
+#endif
ret = vfprintfp(stream, format, arg);
+#if 0
AFTER_ORIGINAL_FILEP(ret, stream, FD_API_WRITE, "%p, %s", stream, format);
+#else
+ AFTER_ORIGINAL_START_END_FILEP(ret, stream, FD_API_WRITE_END, "%p, %s", stream, format);
+#endif
return ret;
}
{
static int (*vfscanfp)(FILE* stream, const char* format, va_list arg);
+#if 0
BEFORE_ORIGINAL_FILE(vfscanf, LIBC);
+#else
+ BEFORE_ORIGINAL_START_END_FILEP(vfscanf, LIBC, stream, FD_API_READ_START, "%p, %s", stream, format);
+#endif
ret = vfscanfp(stream, format, arg);
+#if 0
AFTER_ORIGINAL_FILEP(ret, stream, FD_API_READ, "%p, %s", stream, format);
+#else
+ AFTER_ORIGINAL_START_END_FILEP(ret, stream, FD_API_READ_END, "%p, %s", stream, format);
+#endif
return ret;
}
{
static int (*fgetcp)(FILE* stream);
+#if 0
BEFORE_ORIGINAL_FILE(fgetc, LIBC);
+#else
+ BEFORE_ORIGINAL_START_END_FILEP(fgetc, LIBC, stream, FD_API_READ_START, "%p", stream);
+#endif
ret = fgetcp(stream);
+#if 0
AFTER_ORIGINAL_FILEP((ret == EOF ? 0 : 1), stream, FD_API_READ, "%p", stream);
+#else
+ AFTER_ORIGINAL_START_END_FILEP((ret == EOF ? 0 : 1), stream, FD_API_READ_END, "%p", stream);
+#endif
return ret;
}
static char* (*fgetsp)(char* str, int num, FILE* stream);
char* cret;
+#if 0
BEFORE_ORIGINAL_FILE(fgets, LIBC);
+#else
+ BEFORE_ORIGINAL_START_END_FILEP(fgets, LIBC, stream, FD_API_READ_START, "%s, %d, %p", str, size, stream);
+#endif
cret = fgetsp(str, size, stream);
+#if 0
AFTER_ORIGINAL_FILEP_RET(VT_STR, cret, (ret == NULL ? 0 : strlen(cret)),
stream, FD_API_READ, "%s, %d, %p", str, size, stream);
+#else
+ AFTER_ORIGINAL_START_END_FILEP_RET(VT_STR, cret, (ret == NULL ? 0 : strlen(cret)), stream, FD_API_READ_END, "%s, %d, %p", str, size, stream);
+#endif
return cret;
}
{
static int (*fputcp)(int character, FILE* stream);
+#if 0
BEFORE_ORIGINAL_FILE(fputc, LIBC);
+#else
+ BEFORE_ORIGINAL_START_END_FILEP(fputc, LIBC, stream, FD_API_WRITE_START, "%d, %p", character, stream);
+#endif
ret = fputcp(character, stream);
+#if 0
AFTER_ORIGINAL_FILEP((ret == EOF ? 0 : 1), stream, FD_API_WRITE,
"%d, %p", character, stream);
+#else
+ AFTER_ORIGINAL_START_END_FILEP((ret == EOF ? 0 : 1), stream, FD_API_WRITE_END, "%d, %p", character, stream);
+#endif
return ret;
}
{
static int (*fputsp)(const char* str, FILE* stream);
+#if 0
BEFORE_ORIGINAL_FILE(fputs, LIBC);
+#else
+ BEFORE_ORIGINAL_START_END_FILEP(fputs, LIBC, stream, FD_API_WRITE_START, "%s, %p", str, stream);
+#endif
ret = fputsp(str, stream);
+#if 0
AFTER_ORIGINAL_FILEP(ret, stream, FD_API_WRITE, "%s, %p", str, stream);
+#else
+ AFTER_ORIGINAL_START_END_FILEP(ret, stream, FD_API_WRITE_END, "%s, %p", str, stream);
+#endif
return ret;
}
{
static int (*getcp)(FILE* stream);
+#if 0
BEFORE_ORIGINAL_FILE(getc, LIBC);
+#else
+ BEFORE_ORIGINAL_START_END_FILEP(getc, LIBC, stream, FD_API_READ_START, "%p", stream);
+#endif
ret = getcp(stream);
+#if 0
AFTER_ORIGINAL_FILEP((ret == EOF ? 0 : 1), stream, FD_API_READ, "%p", stream);
+#else
+ AFTER_ORIGINAL_START_END_FILEP((ret == EOF ? 0 : 1), stream, FD_API_READ_END, "%p", stream);
+#endif
return ret;
}
{
static int (*putcp)(int character, FILE* stream);
+#if 0
BEFORE_ORIGINAL_FILE(putc, LIBC);
+#else
+ BEFORE_ORIGINAL_START_END_FILEP(putc, LIBC, stream, FD_API_WRITE_START, "%d, %p", character, stream);
+#endif
ret = putcp(character, stream);
+#if 0
AFTER_ORIGINAL_FILEP((ret == EOF ? 0 : 1), stream, FD_API_WRITE,
"%d, %p", character, stream);
+#else
+ AFTER_ORIGINAL_START_END_FILEP((ret == EOF ? 0 : 1), stream, FD_API_WRITE_END, "%d, %p", character, stream);
+#endif
return ret;
}
static size_t (*freadp)(void* ptr, size_t size, size_t count, FILE* stream);
size_t tret;
+#if 0
BEFORE_ORIGINAL_FILE(fread, LIBC);
-
+#else
+ BEFORE_ORIGINAL_START_END_FILEP(fread, LIBC, stream, FD_API_READ_START, "%p, %u, %u, %p", ptr, size, count, stream);
+#endif
tret = freadp(ptr, size, count, stream);
+#if 0
AFTER_ORIGINAL_FILEP_RET(VT_SIZE_T, tret, 0, stream, FD_API_READ,
"%p, %u, %u, %p", ptr, size, count, stream);
+#else
+ AFTER_ORIGINAL_START_END_FILEP_RET(VT_SIZE_T, tret, 0, stream, FD_API_READ_END, "%p, %u, %u, %p", ptr, size, count, stream);
+#endif
return tret;
}
static size_t (*fwritep)(const void* ptr, size_t size, size_t count, FILE* stream);
size_t tret;
+#if 0
BEFORE_ORIGINAL_FILE(fwrite, LIBC);
+#else
+ BEFORE_ORIGINAL_START_END_FILEP(fwrite, LIBC, stream, FD_API_WRITE_START, "%p, %u, %u, %p", ptr, size, count, stream);
+#endif
tret = fwritep(ptr, size, count, stream);
+#if 0
AFTER_ORIGINAL_FILEP_RET(VT_SIZE_T, tret, 0, stream, FD_API_WRITE,
"%p, %u, %u, %p", ptr, size, count, stream);
+#else
+ AFTER_ORIGINAL_START_END_FILEP_RET(VT_SIZE_T, tret, 0, stream, FD_API_WRITE_END, "%p, %u, %u, %p", ptr, size, count, stream);
+#endif
return tret;
}
{
static int (*vfprintfp)(FILE* stream, const char* format, ...);
+#if 0
BEFORE_ORIGINAL_FILE(vfprintf, LIBC);
-
+#else
+ BEFORE_ORIGINAL_START_END_FILEP(vfprintf, LIBC, stream, FD_API_WRITE_START, "%p, %s, ...", stream, format);
+#endif
va_list arg;
va_start(arg, format);
ret = vfprintfp(stream, format, arg);
+#if 0
AFTER_ORIGINAL_FILEP(ret, stream, FD_API_WRITE, "%p, %s, ...", stream, format);
+#else
+ AFTER_ORIGINAL_START_END_FILEP(ret, stream, FD_API_WRITE_END, "%p, %s, ...", stream, format);
+#endif
va_end(arg);
return ret;
{
static int (*vfscanfp)(FILE* stream, const char* format, ...);
+#if 0
BEFORE_ORIGINAL_FILE(vfscanf, LIBC);
+#else
+ BEFORE_ORIGINAL_START_END_FILEP(vfscanf, LIBC, stream, FD_API_READ_START, "%p, %s, ...", stream, format);
+#endif
va_list arg;
va_start(arg, format);
ret = vfscanfp(stream, format, arg);
+#if 0
AFTER_ORIGINAL_FILEP(ret, stream, FD_API_READ, "%p, %s, ...", stream, format);
+#else
+ AFTER_ORIGINAL_START_END_FILEP(ret, stream, FD_API_READ_END, "%p, %s, ...", stream, format);
+#endif
va_end(arg);
return ret;
{
static int (*vprintfp)(const char* format, ...);
+#if 0
BEFORE_ORIGINAL_FILE(vprintf, LIBC);
+#else
+ BEFORE_ORIGINAL_START_END_NOFD(vprintf, LIBC, FD_API_WRITE_START, "%s,...", format);
+#endif
va_list arg;
va_start(arg, format);
ret = vprintfp(format, arg);
+#if 0
AFTER_ORIGINAL_NOFD(ret, FD_API_WRITE, "%s,...", format);
+#else
+ AFTER_ORIGINAL_START_END_NOFD(ret, FD_API_WRITE_END, "%s,...", format);
+#endif
va_end(arg);
return ret;
{
static int (*vscanfp)(const char* format, ...);
+#if 0
BEFORE_ORIGINAL_FILE(vscanf, LIBC);
+#else
+ BEFORE_ORIGINAL_START_END_NOFD(vscanf, LIBC, FD_API_READ_START, "%s,...", format);
+#endif
va_list arg;
va_start(arg, format);
ret = vscanfp(format, arg);
+#if 0
AFTER_ORIGINAL_NOFD(ret, FD_API_READ, "%s,...", format);
+#else
+ AFTER_ORIGINAL_START_END_NOFD(ret, FD_API_READ_END, "%s,...", format);
+#endif
va_end(arg);
return ret;
{
static int (*getcharp)();
+#if 0
BEFORE_ORIGINAL_FILE(getchar, LIBC);
+#else
+ BEFORE_ORIGINAL_START_END_NOFD(getchar, LIBC, FD_API_READ_START, "%s", "");
+#endif
ret = getcharp();
+#if 0
AFTER_ORIGINAL_NOFD((ret == EOF ? 0 : 1), FD_API_READ, "%s", "");
+#else
+ AFTER_ORIGINAL_START_END_NOFD((ret == EOF ? 0 : 1), FD_API_READ_END, "%s", "");
+#endif
return ret;
}
{
static int (*putcharp)(int c);
+#if 0
BEFORE_ORIGINAL_FILE(putchar, LIBC);
+#else
+ BEFORE_ORIGINAL_START_END_NOFD(putchar, LIBC, FD_API_WRITE_START, "%d", c);
+#endif
ret = putcharp(c);
+#if 0
AFTER_ORIGINAL_NOFD((ret == EOF ? 0 : 1), FD_API_WRITE, "%d", c);
+#else
+ AFTER_ORIGINAL_START_END_NOFD((ret == EOF ? 0 : 1), FD_API_WRITE_END, "%d", c);
+#endif
return ret;
}
static char* (*getsp)(char* str);
char* cret;
+#if 0
BEFORE_ORIGINAL_FILE(gets, LIBC);
+#else
+ BEFORE_ORIGINAL_START_END_NOFD(gets, LIBC, FD_API_READ_START, "%s", str);
+#endif
cret = getsp(str);
+#if 0
AFTER_ORIGINAL_NOFD_RET(VT_STR, cret, strlen(cret), FD_API_READ, "%s", str);
+#else
+ AFTER_ORIGINAL_START_END_NOFD_RET(VT_STR, cret, strlen(cret), FD_API_READ_END, "%s", str);
+#endif
return cret;
}
{
static int (*putsp)(const char* str);
+#if 0
BEFORE_ORIGINAL_FILE(puts, LIBC);
+#else
+ BEFORE_ORIGINAL_START_END_NOFD(puts, LIBC, FD_API_WRITE_START, "%s", str);
+#endif
ret = putsp(str);
+#if 0
AFTER_ORIGINAL_NOFD(ret, FD_API_WRITE, "%s", str);
+#else
+ AFTER_ORIGINAL_START_END_NOFD(ret, FD_API_WRITE_END, "%s", str);
+#endif
return ret;
}
#endif
POST_PROBEBLOCK_CALLSTACK(); \
POST_PROBEBLOCK_END()
+#define BEFORE_ORIGINAL_START_END_SYNC(FUNCNAME, LIBNAME, SYNCVAL, SYNCTYPE, APITYPE, INPUTFORMAT, ...) \
+ DECLARE_VARIABLE_STANDARD; \
+ GET_REAL_FUNC(FUNCNAME, LIBNAME); \
+ PRE_START_END_PROBEBLOCK_BEGIN(LC_SYNC, INPUTFORMAT, __VA_ARGS__); \
+ POST_PROBEBLOCK_MIDDLE_SYNCVAL(SYNCVAL, SYNCTYPE, APITYPE); \
+ APPEND_LOG_NULL_CALLSTACK(); \
+ printLog(&log, MSG_LOG); \
+ PRE_PROBEBLOCK_END()
+
+#define AFTER_ORIGINAL_START_END_SYNCVAL_RET(RTYPE, RVAL, SYNCVAL, SYNCTYPE, APITYPE, INPUTFORMAT, ...) \
+ POST_START_END_PROBEBLOCK_BEGIN(LC_SYNC, RTYPE, RVAL, INPUTFORMAT, __VA_ARGS__); \
+ POST_PROBEBLOCK_MIDDLE_SYNCVAL(SYNCVAL, SYNCTYPE, APITYPE); \
+ POST_PROBEBLOCK_CALLSTACK(); \
+ POST_PROBEBLOCK_END()
+
#ifdef __cplusplus
}
#endif
POST_PROBEBLOCK_CALLSTACK(); \
POST_PROBEBLOCK_END()
+#define BEFORE_ORIGINAL_START_END_THREAD(FUNCNAME, LIBNAME, THREADVAL, APITYPE, INPUTFORMAT, ...) \
+ DECLARE_VARIABLE_THREAD; \
+ GET_REAL_FUNC(FUNCNAME, LIBNAME); \
+ PRE_START_END_PROBEBLOCK_BEGIN(LC_THREAD, INPUTFORMAT, __VA_ARGS__); \
+ POST_PROBEBLOCK_MIDDLE_THREAD(THREADVAL, APITYPE); \
+ APPEND_LOG_NULL_CALLSTACK(); \
+ printLog(&log, MSG_LOG); \
+ PRE_PROBEBLOCK_END()
+
+#define AFTER_ORIGINAL_START_END_THREAD_RET(RTYPE, RVAL, THREADVAL, APITYPE, INPUTFORMAT, ...) \
+ POST_START_END_PROBEBLOCK_BEGIN(LC_THREAD, RTYPE, RVAL, INPUTFORMAT, __VA_ARGS__); \
+ POST_PROBEBLOCK_MIDDLE_THREAD(THREADVAL, APITYPE); \
+ POST_PROBEBLOCK_CALLSTACK(); \
+ POST_PROBEBLOCK_END()
+
#endif // __DA_THREAD_H__
int pthread_mutex_lock(pthread_mutex_t *mutex) {
static int (*pthread_mutex_lockp)(pthread_mutex_t *mutex);
-
+
+#if 0
DECLARE_VARIABLE_STANDARD;
GET_REAL_FUNC(pthread_mutex_lock, LIBPTHREAD);
APPEND_LOG_NULL_CALLSTACK();
printLog(&log, MSG_LOG);
PRE_PROBEBLOCK_END();
-
+#else
+ BEFORE_ORIGINAL_START_END_SYNC(pthread_mutex_lock, LIBPTHREAD, mutex, SYNC_PTHREAD_MUTEX, SYNC_API_ACQUIRE_WAIT_START, "%p", mutex);
+#endif
ret = pthread_mutex_lockp(mutex);
+#if 0
// send WAIT_END log
newerrno = errno;
if(postBlockBegin(blockresult)) {
printLog(&log, MSG_LOG);
postBlockEnd();
}
-
+#else
+ AFTER_ORIGINAL_START_END_SYNCVAL_RET(VT_INT, ret, mutex, SYNC_PTHREAD_MUTEX, SYNC_API_ACQUIRE_WAIT_END, "%p", mutex);
+#endif
return ret;
}
static int (*pthread_mutex_timedlockp)(pthread_mutex_t *mutex,
const struct timespec *abs_timeout);
+#if 0
DECLARE_VARIABLE_STANDARD;
GET_REAL_FUNC(pthread_mutex_timedlock, LIBPTHREAD);
APPEND_LOG_NULL_CALLSTACK();
printLog(&log, MSG_LOG);
PRE_PROBEBLOCK_END();
+#else
+ BEFORE_ORIGINAL_START_END_SYNC(pthread_mutex_timedlock, LIBPTHREAD, mutex, SYNC_PTHREAD_MUTEX, SYNC_API_ACQUIRE_WAIT_START, "%p,%p", mutex, abs_timeout);
+#endif
ret = pthread_mutex_timedlockp(mutex, abs_timeout);
+#if 0
// send WAIT_END log
newerrno = errno;
if(postBlockBegin(blockresult)) {
printLog(&log, MSG_LOG);
postBlockEnd();
}
-
+#else
+ AFTER_ORIGINAL_START_END_SYNCVAL_RET(VT_INT, ret, mutex, SYNC_PTHREAD_MUTEX, SYNC_API_ACQUIRE_WAIT_END, "%p,%p", mutex, abs_timeout);
+
+#endif
return ret;
}
static int (*pthread_cond_waitp)(pthread_cond_t *cond,
pthread_mutex_t *mutex);
+#if 0
DECLARE_VARIABLE_STANDARD;
GET_REAL_FUNC(pthread_cond_wait, LIBPTHREAD);
APPEND_LOG_NULL_CALLSTACK();
printLog(&log, MSG_LOG);
PRE_PROBEBLOCK_END();
-
+#else
+ BEFORE_ORIGINAL_START_END_SYNC(pthread_cond_wait, LIBPTHREAD, cond, SYNC_PTHREAD_COND_VARIABLE, SYNC_API_COND_WAIT_START, "%p,%p", cond, mutex);
+#endif
ret = pthread_cond_waitp(cond, mutex);
+#if 0
// send WAIT_END log
newerrno = errno;
if(postBlockBegin(blockresult)) {
printLog(&log, MSG_LOG);
postBlockEnd();
}
-
+#else
+ AFTER_ORIGINAL_START_END_SYNCVAL_RET(VT_INT, ret, cond, SYNC_PTHREAD_COND_VARIABLE, SYNC_API_COND_WAIT_END, "%p,%p", cond, mutex);
+#endif
return ret;
}
static int (*pthread_cond_timedwaitp)(pthread_cond_t *cond,
pthread_mutex_t *mutex, const struct timespec *abstime);
+#if 0
DECLARE_VARIABLE_STANDARD;
GET_REAL_FUNC(pthread_cond_timedwait, LIBPTHREAD);
APPEND_LOG_NULL_CALLSTACK();
printLog(&log, MSG_LOG);
PRE_PROBEBLOCK_END();
-
+#else
+ BEFORE_ORIGINAL_START_END_SYNC(pthread_cond_timedwait, LIBPTHREAD, cond, SYNC_PTHREAD_COND_VARIABLE, SYNC_API_COND_WAIT_START, "%p,%p,%p", cond, mutex, abstime);
+#endif
ret = pthread_cond_timedwaitp(cond, mutex, abstime);
+#if 0
// send WAIT_END log
newerrno = errno;
if(postBlockBegin(blockresult)) {
printLog(&log, MSG_LOG);
postBlockEnd();
}
-
+#else
+ AFTER_ORIGINAL_START_END_SYNCVAL_RET(VT_INT, ret, cond, SYNC_PTHREAD_COND_VARIABLE, SYNC_API_COND_WAIT_END, "%p,%p,%p", cond, mutex, abstime);
+#endif
return ret;
}
{
static int (*pthread_joinp)(pthread_t thread, void **retval);
+#if 0
DECLARE_VARIABLE_STANDARD;
GET_REAL_FUNC(pthread_join, LIBPTHREAD);
APPEND_LOG_NULL_CALLSTACK();
printLog(&log, MSG_LOG);
PRE_PROBEBLOCK_END();
-
+#else
+ BEFORE_ORIGINAL_START_END_THREAD(pthread_join, LIBPTHREAD, thread, THREAD_API_WAIT_START, "%lu,%p", thread, retval);
ret = pthread_joinp(thread, retval);
-
+#endif
+#if 0
// send WAIT_END log
newerrno = errno;
if(postBlockBegin(blockresult)) {
printLog(&log, MSG_LOG);
postBlockEnd();
}
-
+#else
+ AFTER_ORIGINAL_START_END_THREAD_RET(VT_INT, ret, thread, THREAD_API_WAIT_END, "%lu,%p", thread, retval);
+#endif
return ret;
}
projects / framework / system / dynamic-analysis-probe.git / commitdiff