From fa1eb2c420c7da280f3ba2fc0d0c1fb5d02fd9a8 Mon Sep 17 00:00:00 2001 From: Anastasia Lyupa Date: Mon, 24 Jun 2013 18:58:43 +0400 Subject: [PATCH] add pthread probes --- include/binproto.h | 11 +-- probe_thread/da_thread.h | 13 ++++ probe_thread/libdathread.c | 180 ++++++++++++++++++++++++++++++++++++++++++++- 3 files changed, 197 insertions(+), 7 deletions(-) diff --git a/include/binproto.h b/include/binproto.h index 879125d..8bb85fb 100644 --- a/include/binproto.h +++ b/include/binproto.h @@ -245,11 +245,12 @@ static inline char *pack_args(char *to, const char *fmt, ...) /* BUF_PTR = pack_int32(BUF_PTR, user_transition_time); \ */ /* } while (0) */ -/* #define PACK_THREAD(BUF_PTRthread_id, osp_thread_id, thread_type, api_type) \ */ -/* BUF_PTR = pack_int32(BUF_PTR, pthread_id); \ */ -/* BUF_PTR = pack_int32(BUF_PTR, osp_thread_id); \ */ -/* BUF_PTR = pack_int32(BUF_PTR, thread_type); \ */ -/* BUF_PTR = pack_int32(BUF_PTR, api_type); */ + #define PACK_THREAD(thread_id, thread_type, api_type) \ + do { \ + BUF_PTR = pack_int64(BUF_PTR, thread_id); \ + BUF_PTR = pack_int32(BUF_PTR, thread_type); \ + BUF_PTR = pack_int32(BUF_PTR, api_type); \ + } while (0) /* #define PACK_CUSTOM(handle, type, name, color, value) \ */ /* BUF_PTR = pack_int32(BUF_PTR, handle); \ */ diff --git a/probe_thread/da_thread.h b/probe_thread/da_thread.h index 71aefc8..e5e0924 100644 --- a/probe_thread/da_thread.h +++ b/probe_thread/da_thread.h @@ -52,5 +52,18 @@ POST_PROBEBLOCK_CALLSTACK(); \ POST_PROBEBLOCK_END() +#define BEFORE_PACK_ORIGINAL_THREAD(FUNCNAME, LIBNAME) \ + PREPARE_LOCAL_BUF(); \ + GET_REAL_FUNC(FUNCNAME, LIBNAME); \ + PRE_PROBEBLOCK() + +#define AFTER_PACK_ORIGINAL_THREAD(RVAL, THREADVAL, APITYPE, INPUTFORMAT, ...) \ + POST_PACK_PROBEBLOCK_BEGIN(LC_THREAD, RVAL, INPUTFORMAT, __VA_ARGS__); \ + PACK_COMMON_BEGIN(MSG_PROBE_THREAD, LC_THREAD, INPUTFORMAT, __VA_ARGS__); \ + PACK_COMMON_END(RVAL, errno, blockresult); \ + PACK_THREAD(THREADVAL, THREAD_PTHREAD, APITYPE); \ + FLUSH_LOCAL_BUF(); \ + POST_PACK_PROBEBLOCK_END() + #endif // __DA_THREAD_H__ diff --git a/probe_thread/libdathread.c b/probe_thread/libdathread.c index 8ee23ce..c229340 100644 --- a/probe_thread/libdathread.c +++ b/probe_thread/libdathread.c @@ -35,6 +35,8 @@ #include "dahelper.h" #include "da_thread.h" +#include "binproto.h" + typedef struct thread_routine_call_t { void *(*thread_routine)(void *); void *argument; @@ -59,6 +61,13 @@ void _da_cleanup_handler(void *data) pSelf, THREAD_PTHREAD, THREAD_API_INTERNAL_STOP); APPEND_LOG_NULL_CALLSTACK(); printLog(&log, MSG_LOG); + + PREPARE_LOCAL_BUF(); + PACK_COMMON_BEGIN(MSG_PROBE_THREAD, LC_THREAD, "p", data); + PACK_COMMON_END(0, 0, 1); + PACK_THREAD(pSelf, THREAD_PTHREAD, THREAD_API_INTERNAL_STOP); + FLUSH_LOCAL_BUF(); + PRE_UNCONDITIONAL_BLOCK_END(); return; @@ -85,6 +94,13 @@ void *_da_ThreadProc(void *params) pSelf, THREAD_PTHREAD, THREAD_API_INTERNAL_START); APPEND_LOG_NULL_CALLSTACK(); printLog(&log, MSG_LOG); + + PREPARE_LOCAL_BUF(); + PACK_COMMON_BEGIN(MSG_PROBE_THREAD, LC_THREAD, "p", params); + PACK_COMMON_END(0, 0, 1); + PACK_THREAD(pSelf, THREAD_PTHREAD, THREAD_API_INTERNAL_START); + FLUSH_LOCAL_BUF(); + PRE_UNCONDITIONAL_BLOCK_END(); pthread_cleanup_push(_da_cleanup_handler, NULL); @@ -104,6 +120,13 @@ void *_da_ThreadProc(void *params) pSelf, THREAD_PTHREAD, THREAD_API_INTERNAL_STOP); APPEND_LOG_NULL_CALLSTACK(); printLog(&log, MSG_LOG); + + PREPARE_LOCAL_BUF(); + PACK_COMMON_BEGIN(MSG_PROBE_THREAD, LC_THREAD, "p", params); + PACK_COMMON_END(ret, 0, 1); + PACK_THREAD(pSelf, THREAD_PTHREAD, THREAD_API_INTERNAL_STOP); + FLUSH_LOCAL_BUF(); + PRE_UNCONDITIONAL_BLOCK_END(); free(ptrc); @@ -118,6 +141,8 @@ int pthread_create(pthread_t *thread, const pthread_attr_t *attr, BEFORE_ORIGINAL_THREAD(pthread_create, LIBPTHREAD); + BEFORE_PACK_ORIGINAL_THREAD(pthread_create, LIBPTHREAD); + if(blockresult) { probeBlockStart(); @@ -137,6 +162,9 @@ int pthread_create(pthread_t *thread, const pthread_attr_t *attr, AFTER_ORIGINAL_THREAD_RET(VT_INT, ret, *thread, THREAD_API_START, "%p,%p,%p,%p", thread, attr, start_routine, arg); + AFTER_PACK_ORIGINAL_THREAD(ret, *thread, THREAD_API_START, + "pppp", thread, attr, start_routine, arg); + return ret; } @@ -159,6 +187,13 @@ int pthread_join(pthread_t thread, void **retval) THREAD_PTHREAD, THREAD_API_WAIT_START); APPEND_LOG_NULL_CALLSTACK(); printLog(&log, MSG_LOG); + + PREPARE_LOCAL_BUF(); + PACK_COMMON_BEGIN(MSG_PROBE_THREAD, LC_THREAD, "xp", thread, retval); + PACK_COMMON_END(0, 0, blockresult); + PACK_THREAD(thread, THREAD_PTHREAD, THREAD_API_WAIT_START); + FLUSH_LOCAL_BUF(); + PRE_PROBEBLOCK_END(); ret = pthread_joinp(thread, retval); @@ -176,6 +211,13 @@ int pthread_join(pthread_t thread, void **retval) POST_PROBEBLOCK_MIDDLE_THREAD(thread, THREAD_API_WAIT_END); POST_PROBEBLOCK_CALLSTACK(); printLog(&log, MSG_LOG); + + PREPARE_LOCAL_BUF(); + PACK_COMMON_BEGIN(MSG_PROBE_THREAD, LC_THREAD, "xp", thread, retval); + PACK_COMMON_END(ret, errno, blockresult); + PACK_THREAD(thread, THREAD_PTHREAD, THREAD_API_WAIT_END); + FLUSH_LOCAL_BUF(); + postBlockEnd(); } @@ -203,6 +245,13 @@ void pthread_exit(void *retval) pSelf, THREAD_PTHREAD, THREAD_API_EXIT); APPEND_LOG_NULL_CALLSTACK(); printLog(&log, MSG_LOG); + + PREPARE_LOCAL_BUF(); + PACK_COMMON_BEGIN(MSG_PROBE_THREAD, LC_THREAD, "p", retval); + PACK_COMMON_END(0, 0, blockresult); + PACK_THREAD(pSelf, THREAD_PTHREAD, THREAD_API_EXIT); + FLUSH_LOCAL_BUF(); + PRE_PROBEBLOCK_END(); pthread_exitp(retval); @@ -214,10 +263,14 @@ int pthread_cancel(pthread_t thread) BEFORE_ORIGINAL_THREAD(pthread_cancel, LIBPTHREAD); + BEFORE_PACK_ORIGINAL_THREAD(pthread_cancel, LIBPTHREAD); + ret = pthread_cancelp(thread); AFTER_ORIGINAL_THREAD_RET(VT_INT, ret, thread, THREAD_API_STOP, "%lu", thread); + AFTER_PACK_ORIGINAL_THREAD(ret, thread, THREAD_API_STOP, "x", thread); + return ret; } @@ -227,10 +280,14 @@ int pthread_detach(pthread_t thread) BEFORE_ORIGINAL_THREAD(pthread_detach, LIBPTHREAD); + BEFORE_PACK_ORIGINAL_THREAD(pthread_detach, LIBPTHREAD); + ret = pthread_detachp(thread); AFTER_ORIGINAL_THREAD_RET(VT_INT, ret, thread, THREAD_API_OTHER, "%lu", thread); + AFTER_PACK_ORIGINAL_THREAD(ret, thread, THREAD_API_OTHER, "x", thread); + return ret; } @@ -241,6 +298,8 @@ pthread_t pthread_self(void) BEFORE_ORIGINAL_THREAD(pthread_self, LIBPTHREAD); + BEFORE_PACK_ORIGINAL_THREAD(pthread_self, LIBPTHREAD); + ret_pthr = pthread_selfp(); newerrno = errno; @@ -254,7 +313,12 @@ pthread_t pthread_self(void) POST_PROBEBLOCK_MIDDLE_THREAD(ret_pthr, THREAD_API_OTHER); POST_PROBEBLOCK_CALLSTACK(); printLog(&log, MSG_LOG); + + AFTER_PACK_ORIGINAL_THREAD(ret_pthr, ret_pthr, THREAD_API_OTHER, "", 0); + postBlockEnd(); + } else { + FLUSH_LOCAL_BUF(); } return ret_pthr; @@ -266,10 +330,14 @@ int pthread_equal(pthread_t t1, pthread_t t2) BEFORE_ORIGINAL_THREAD(pthread_equal, LIBPTHREAD); + BEFORE_PACK_ORIGINAL_THREAD(pthread_equal, LIBPTHREAD); + ret = pthread_equalp(t1, t2); AFTER_ORIGINAL_THREAD_RET(VT_INT, ret, t1, THREAD_API_OTHER, "%lu,%lu", t1, t2); + AFTER_PACK_ORIGINAL_THREAD(ret, t1, THREAD_API_OTHER, "xx", t1, t2); + return ret; } @@ -280,11 +348,16 @@ int pthread_setcancelstate(int state, int *oldstate) BEFORE_ORIGINAL_THREAD(pthread_setcancelstate, LIBPTHREAD); + BEFORE_PACK_ORIGINAL_THREAD(pthread_setcancelstate, LIBPTHREAD); + pSelf = pthread_self(); ret = pthread_setcancelstatep(state, oldstate); AFTER_ORIGINAL_THREAD_RET(VT_INT, ret, pSelf, THREAD_API_OTHER, - "%d,%p", state, oldstate); + "%d,%p", state, oldstate); + + AFTER_PACK_ORIGINAL_THREAD(ret, pSelf, THREAD_API_OTHER, + "dp", state, oldstate); return ret; } @@ -296,11 +369,16 @@ int pthread_setcanceltype(int type, int *oldtype) BEFORE_ORIGINAL_THREAD(pthread_setcanceltype, LIBPTHREAD); + BEFORE_PACK_ORIGINAL_THREAD(pthread_setcanceltype, LIBPTHREAD); + pSelf = pthread_self(); ret = pthread_setcanceltypep(type, oldtype); AFTER_ORIGINAL_THREAD_RET(VT_INT, ret, pSelf, THREAD_API_OTHER, - "%d,%p", type, oldtype); + "%d,%p", type, oldtype); + + AFTER_PACK_ORIGINAL_THREAD(ret, pSelf, THREAD_API_OTHER, + "dp", type, oldtype); return ret; } @@ -312,10 +390,14 @@ int pthread_attr_init(pthread_attr_t *attr) BEFORE_ORIGINAL_THREAD(pthread_attr_init, LIBPTHREAD); + BEFORE_PACK_ORIGINAL_THREAD(pthread_attr_init, LIBPTHREAD); + ret = pthread_attr_initp(attr); AFTER_ORIGINAL_THREAD_RET(VT_INT, ret, thread, THREAD_API_OTHER, "%p", attr); + AFTER_PACK_ORIGINAL_THREAD(ret, thread, THREAD_API_OTHER, "p", attr); + return ret; } @@ -326,10 +408,14 @@ int pthread_attr_destroy(pthread_attr_t *attr) BEFORE_ORIGINAL_THREAD(pthread_attr_destroy, LIBPTHREAD); + BEFORE_PACK_ORIGINAL_THREAD(pthread_attr_destroy, LIBPTHREAD); + ret = pthread_attr_destroyp(attr); AFTER_ORIGINAL_THREAD_RET(VT_INT, ret, thread, THREAD_API_OTHER, "%p", attr); + AFTER_PACK_ORIGINAL_THREAD(ret, thread, THREAD_API_OTHER, "p", attr); + return ret; } @@ -341,11 +427,16 @@ int pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate) BEFORE_ORIGINAL_THREAD(pthread_attr_getdetachstate, LIBPTHREAD); + BEFORE_PACK_ORIGINAL_THREAD(pthread_attr_getdetachstate, LIBPTHREAD); + ret = pthread_attr_getdetachstatep(attr, detachstate); AFTER_ORIGINAL_THREAD_RET(VT_INT, ret, thread, THREAD_API_OTHER, "%p,%p", attr, detachstate); + AFTER_PACK_ORIGINAL_THREAD(ret, thread, THREAD_API_OTHER, + "pp", attr, detachstate); + return ret; } @@ -357,11 +448,16 @@ int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate) BEFORE_ORIGINAL_THREAD(pthread_attr_setdetachstate, LIBPTHREAD); + BEFORE_PACK_ORIGINAL_THREAD(pthread_attr_setdetachstate, LIBPTHREAD); + ret = pthread_attr_setdetachstatep(attr, detachstate); AFTER_ORIGINAL_THREAD_RET(VT_INT, ret, thread, THREAD_API_OTHER, "%p,%d", attr, detachstate); + AFTER_PACK_ORIGINAL_THREAD(ret, thread, THREAD_API_OTHER, + "pd", attr, detachstate); + return ret; } @@ -373,11 +469,16 @@ int pthread_attr_getstacksize(const pthread_attr_t *attr, size_t *stacksize) BEFORE_ORIGINAL_THREAD(pthread_attr_getstacksize, LIBPTHREAD); + BEFORE_PACK_ORIGINAL_THREAD(pthread_attr_getstacksize, LIBPTHREAD); + ret = pthread_attr_getstacksizep(attr, stacksize); AFTER_ORIGINAL_THREAD_RET(VT_INT, ret, thread, THREAD_API_OTHER, "%p,%p", attr, stacksize); + AFTER_PACK_ORIGINAL_THREAD(ret, thread, THREAD_API_OTHER, + "pp", attr, stacksize); + return ret; } @@ -389,11 +490,16 @@ int pthread_attr_setstacksize(pthread_attr_t *attr, size_t stacksize) BEFORE_ORIGINAL_THREAD(pthread_attr_setstacksize, LIBPTHREAD); + BEFORE_PACK_ORIGINAL_THREAD(pthread_attr_setstacksize, LIBPTHREAD); + ret = pthread_attr_setstacksizep(attr, stacksize); AFTER_ORIGINAL_THREAD_RET(VT_INT, ret, thread, THREAD_API_OTHER, "%p,%u", attr, stacksize); + AFTER_PACK_ORIGINAL_THREAD(ret, thread, THREAD_API_OTHER, + "pd", attr, stacksize); + return ret; } @@ -405,11 +511,16 @@ int pthread_attr_getstackaddr(const pthread_attr_t *attr, void **stackaddr) BEFORE_ORIGINAL_THREAD(pthread_attr_getstackaddr, LIBPTHREAD); + BEFORE_PACK_ORIGINAL_THREAD(pthread_attr_getstackaddr, LIBPTHREAD); + ret = pthread_attr_getstackaddrp(attr, stackaddr); AFTER_ORIGINAL_THREAD_RET(VT_INT, ret, thread, THREAD_API_OTHER, "%p,%p", attr, stackaddr); + AFTER_PACK_ORIGINAL_THREAD(ret, thread, THREAD_API_OTHER, + "pp", attr, stackaddr); + return ret; } @@ -421,11 +532,16 @@ int pthread_attr_setstackaddr(pthread_attr_t *attr, void *stackaddr) BEFORE_ORIGINAL_THREAD(pthread_attr_setstackaddr, LIBPTHREAD); + BEFORE_PACK_ORIGINAL_THREAD(pthread_attr_setstackaddr, LIBPTHREAD); + ret = pthread_attr_setstackaddrp(attr, stackaddr); AFTER_ORIGINAL_THREAD_RET(VT_INT, ret, thread, THREAD_API_OTHER, "%p,%p", attr, stackaddr); + AFTER_PACK_ORIGINAL_THREAD(ret, thread, THREAD_API_OTHER, + "pp", attr, stackaddr); + return ret; } @@ -437,11 +553,16 @@ int pthread_attr_getinheritsched(const pthread_attr_t *attr, int *inheritsched) BEFORE_ORIGINAL_THREAD(pthread_attr_getinheritsched, LIBPTHREAD); + BEFORE_PACK_ORIGINAL_THREAD(pthread_attr_getinheritsched, LIBPTHREAD); + ret = pthread_attr_getinheritschedp(attr, inheritsched); AFTER_ORIGINAL_THREAD_RET(VT_INT, ret, thread, THREAD_API_OTHER, "%p,%p", attr, inheritsched); + AFTER_PACK_ORIGINAL_THREAD(ret, thread, THREAD_API_OTHER, + "pp", attr, inheritsched); + return ret; } @@ -453,11 +574,16 @@ int pthread_attr_setinheritsched(pthread_attr_t *attr, int inheritsched) BEFORE_ORIGINAL_THREAD(pthread_attr_setinheritsched, LIBPTHREAD); + BEFORE_PACK_ORIGINAL_THREAD(pthread_attr_setinheritsched, LIBPTHREAD); + ret = pthread_attr_setinheritschedp(attr, inheritsched); AFTER_ORIGINAL_THREAD_RET(VT_INT, ret, thread, THREAD_API_OTHER, "%p,%d", attr, inheritsched); + AFTER_PACK_ORIGINAL_THREAD(ret, thread, THREAD_API_OTHER, + "pd", attr, inheritsched); + return ret; } @@ -470,11 +596,16 @@ int pthread_attr_getschedparam(const pthread_attr_t *attr, BEFORE_ORIGINAL_THREAD(pthread_attr_getschedparam, LIBPTHREAD); + BEFORE_PACK_ORIGINAL_THREAD(pthread_attr_getschedparam, LIBPTHREAD); + ret = pthread_attr_getschedparamp(attr, param); AFTER_ORIGINAL_THREAD_RET(VT_INT, ret, thread, THREAD_API_OTHER, "%p,%p", attr, param); + AFTER_PACK_ORIGINAL_THREAD(ret, thread, THREAD_API_OTHER, + "pp", attr, param); + return ret; } @@ -487,11 +618,16 @@ int pthread_attr_setschedparam(pthread_attr_t *attr, BEFORE_ORIGINAL_THREAD(pthread_attr_setschedparam, LIBPTHREAD); + BEFORE_PACK_ORIGINAL_THREAD(pthread_attr_setschedparam, LIBPTHREAD); + ret = pthread_attr_setschedparamp(attr, param); AFTER_ORIGINAL_THREAD_RET(VT_INT, ret, thread, THREAD_API_OTHER, "%p,%p", attr, param); + AFTER_PACK_ORIGINAL_THREAD(ret, thread, THREAD_API_OTHER, + "pp", attr, param); + return ret; } @@ -503,11 +639,16 @@ int pthread_attr_getschedpolicy(const pthread_attr_t *attr, int *policy) BEFORE_ORIGINAL_THREAD(pthread_attr_getschedpolicy, LIBPTHREAD); + BEFORE_PACK_ORIGINAL_THREAD(pthread_attr_getschedpolicy, LIBPTHREAD); + ret = pthread_attr_getschedpolicyp(attr, policy); AFTER_ORIGINAL_THREAD_RET(VT_INT, ret, thread, THREAD_API_OTHER, "%p,%p", attr, policy); + AFTER_PACK_ORIGINAL_THREAD(ret, thread, THREAD_API_OTHER, + "pp", attr, policy); + return ret; } @@ -519,11 +660,16 @@ int pthread_attr_setschedpolicy(pthread_attr_t *attr, int policy) BEFORE_ORIGINAL_THREAD(pthread_attr_setschedpolicy, LIBPTHREAD); + BEFORE_PACK_ORIGINAL_THREAD(pthread_attr_setschedpolicy, LIBPTHREAD); + ret = pthread_attr_setschedpolicyp(attr, policy); AFTER_ORIGINAL_THREAD_RET(VT_INT, ret, thread, THREAD_API_OTHER, "%p,%d", attr, policy); + AFTER_PACK_ORIGINAL_THREAD(ret, thread, THREAD_API_OTHER, + "pd", attr, policy); + return ret; } @@ -535,11 +681,16 @@ int pthread_attr_getguardsize(const pthread_attr_t *attr, size_t *guardsize) BEFORE_ORIGINAL_THREAD(pthread_attr_getguardsize, LIBPTHREAD); + BEFORE_PACK_ORIGINAL_THREAD(pthread_attr_getguardsize, LIBPTHREAD); + ret = pthread_attr_getguardsizep(attr, guardsize); AFTER_ORIGINAL_THREAD_RET(VT_INT, ret, thread, THREAD_API_OTHER, "%p,%p", attr, guardsize); + AFTER_PACK_ORIGINAL_THREAD(ret, thread, THREAD_API_OTHER, + "pp", attr, guardsize); + return ret; } @@ -551,11 +702,16 @@ int pthread_attr_setguardsize(pthread_attr_t *attr, size_t guardsize) BEFORE_ORIGINAL_THREAD(pthread_attr_setguardsize, LIBPTHREAD); + BEFORE_PACK_ORIGINAL_THREAD(pthread_attr_setguardsize, LIBPTHREAD); + ret = pthread_attr_setguardsizep(attr, guardsize); AFTER_ORIGINAL_THREAD_RET(VT_INT, ret, thread, THREAD_API_OTHER, "%p,%u", attr, guardsize); + AFTER_PACK_ORIGINAL_THREAD(ret, thread, THREAD_API_OTHER, + "pd", attr, guardsize); + return ret; } @@ -567,11 +723,16 @@ int pthread_attr_getscope(const pthread_attr_t *attr, int *contentionscope) BEFORE_ORIGINAL_THREAD(pthread_attr_getscope, LIBPTHREAD); + BEFORE_PACK_ORIGINAL_THREAD(pthread_attr_getscope, LIBPTHREAD); + ret = pthread_attr_getscopep(attr, contentionscope); AFTER_ORIGINAL_THREAD_RET(VT_INT, ret, thread, THREAD_API_OTHER, "%p,%p", attr, contentionscope); + AFTER_PACK_ORIGINAL_THREAD(ret, thread, THREAD_API_OTHER, + "pp", attr, contentionscope); + return ret; } @@ -583,11 +744,16 @@ int pthread_attr_setscope(pthread_attr_t *attr, int contentionscope) BEFORE_ORIGINAL_THREAD(pthread_attr_setscope, LIBPTHREAD); + BEFORE_PACK_ORIGINAL_THREAD(pthread_attr_setscope, LIBPTHREAD); + ret = pthread_attr_setscopep(attr, contentionscope); AFTER_ORIGINAL_THREAD_RET(VT_INT, ret, thread, THREAD_API_OTHER, "%p,%d", attr, contentionscope); + AFTER_PACK_ORIGINAL_THREAD(ret, thread, THREAD_API_OTHER, + "pd", attr, contentionscope); + return ret; } @@ -600,11 +766,16 @@ int pthread_attr_getstack(const pthread_attr_t *attr, BEFORE_ORIGINAL_THREAD(pthread_attr_getstack, LIBPTHREAD); + BEFORE_PACK_ORIGINAL_THREAD(pthread_attr_getstack, LIBPTHREAD); + ret = pthread_attr_getstackp(attr, stackaddr, stacksize); AFTER_ORIGINAL_THREAD_RET(VT_INT, ret, thread, THREAD_API_OTHER, "%p,%p,%p", attr, stackaddr, stacksize); + AFTER_PACK_ORIGINAL_THREAD(ret, thread, THREAD_API_OTHER, + "ppp", attr, stackaddr, stacksize); + return ret; } @@ -617,11 +788,16 @@ int pthread_attr_setstack(pthread_attr_t *attr, BEFORE_ORIGINAL_THREAD(pthread_attr_setstack, LIBPTHREAD); + BEFORE_PACK_ORIGINAL_THREAD(pthread_attr_setstack, LIBPTHREAD); + ret = pthread_attr_setstackp(attr, stackaddr, stacksize); AFTER_ORIGINAL_THREAD_RET(VT_INT, ret, thread, THREAD_API_OTHER, "%p,%p,%u", attr, stackaddr, stacksize); + AFTER_PACK_ORIGINAL_THREAD(ret, thread, THREAD_API_OTHER, + "ppd", attr, stackaddr, stacksize); + return ret; } -- 2.7.4