remove BEFORE_PACK_ORIGINAL_THREAD and _SYNC because these macros are not required

diff --git a/probe_thread/da_sync.h b/probe_thread/da_sync.h
index bd25aac..f03b066 100644 (file)
--- a/probe_thread/da_sync.h
+++ b/probe_thread/da_sync.h
@@ -65,13 +65,9 @@ int real_pthread_mutex_unlock(pthread_mutex_t *mutex);
        POST_PROBEBLOCK_CALLSTACK();                                                                                                                            \
        POST_PROBEBLOCK_END()
 
-#define BEFORE_PACK_ORIGINAL_SYNC(FUNCNAME, LIBNAME)   \
-       PREPARE_LOCAL_BUF();                                                            \
-       GET_REAL_FUNC(FUNCNAME, LIBNAME);                                       \
-       PRE_PROBEBLOCK()
-
 #define AFTER_PACK_ORIGINAL_SYNC(RVAL, SYNCVAL, SYNCTYPE, APITYPE, INPUTFORMAT, ...)                   \
        POST_PACK_PROBEBLOCK_BEGIN(LC_SYNC, RVAL, INPUTFORMAT, __VA_ARGS__);                                            \
+       PREPARE_LOCAL_BUF();                                                                                                                                            \
        PACK_COMMON_BEGIN(MSG_PROBE_SYNC, LC_SYNC, INPUTFORMAT, __VA_ARGS__);                                           \
        PACK_COMMON_END(RVAL, errno, blockresult);                                                                                                      \
        PACK_SYNC(SYNCVAL, SYNCTYPE, APITYPE);                                                                                                          \

diff --git a/probe_thread/da_thread.h b/probe_thread/da_thread.h
index e5e0924..b28c61d 100644 (file)
--- a/probe_thread/da_thread.h
+++ b/probe_thread/da_thread.h
@@ -52,16 +52,12 @@
        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__);                          \
+       PREPARE_LOCAL_BUF();                                                                                                                            \
        PACK_COMMON_BEGIN(MSG_PROBE_THREAD, LC_THREAD, INPUTFORMAT, __VA_ARGS__);                       \
        PACK_COMMON_END(RVAL, errno, blockresult);                                                                                      \
-       PACK_THREAD(THREADVAL, THREAD_PTHREAD, APITYPE);                                                                \
+       PACK_THREAD(THREADVAL, THREAD_PTHREAD, APITYPE);                                                                        \
        FLUSH_LOCAL_BUF();                                                                                                                                      \
        POST_PACK_PROBEBLOCK_END()
 

diff --git a/probe_thread/libdasync.c b/probe_thread/libdasync.c
index 392dc5f..ae22f94 100644 (file)
--- a/probe_thread/libdasync.c
+++ b/probe_thread/libdasync.c
@@ -47,8 +47,6 @@ int pthread_mutex_init(pthread_mutex_t *mutex,
 
        BEFORE_ORIGINAL_SYNC(pthread_mutex_init, LIBPTHREAD);
 
-       BEFORE_PACK_ORIGINAL_SYNC(pthread_mutex_init, LIBPTHREAD);
-
        ret = pthread_mutex_initp(mutex, attr);
 
        AFTER_ORIGINAL_SYNCVAL_RET(VT_INT, ret, mutex, SYNC_PTHREAD_MUTEX, 
@@ -65,8 +63,6 @@ int pthread_mutex_destroy(pthread_mutex_t *mutex) {
 
        BEFORE_ORIGINAL_SYNC(pthread_mutex_destroy, LIBPTHREAD);
 
-       BEFORE_PACK_ORIGINAL_SYNC(pthread_mutex_destroy, LIBPTHREAD);
-
        ret = pthread_mutex_destroyp(mutex);
 
        AFTER_ORIGINAL_SYNCVAL_RET(VT_INT, ret, mutex, SYNC_PTHREAD_MUTEX, 
@@ -205,8 +201,6 @@ int pthread_mutex_trylock(pthread_mutex_t *mutex) {
 
        BEFORE_ORIGINAL_SYNC(pthread_mutex_trylock, LIBPTHREAD);
 
-       BEFORE_PACK_ORIGINAL_SYNC(pthread_mutex_trylock, LIBPTHREAD);
-
        ret = pthread_mutex_trylockp(mutex);
 
        AFTER_ORIGINAL_SYNCVAL_RET(VT_INT, ret, mutex, SYNC_PTHREAD_MUTEX, 
@@ -231,8 +225,6 @@ int pthread_mutex_unlock(pthread_mutex_t *mutex) {
 
        BEFORE_ORIGINAL_SYNC(pthread_mutex_unlock, LIBPTHREAD);
 
-       BEFORE_PACK_ORIGINAL_SYNC(pthread_mutex_unlock, LIBPTHREAD);
-
        ret = pthread_mutex_unlockp(mutex);
 
        AFTER_ORIGINAL_SYNCVAL_RET(VT_INT, ret, mutex, SYNC_PTHREAD_MUTEX, 
@@ -249,8 +241,6 @@ int pthread_mutexattr_init(pthread_mutexattr_t *attr) {
 
        BEFORE_ORIGINAL_SYNC(pthread_mutexattr_init, LIBPTHREAD);
 
-       BEFORE_PACK_ORIGINAL_SYNC(pthread_mutexattr_init, LIBPTHREAD);
-
        ret = pthread_mutexattr_initp(attr);
 
        AFTER_ORIGINAL_NOSYNCVAL_RET(VT_INT, ret, SYNC_PTHREAD_MUTEX,
@@ -267,8 +257,6 @@ int pthread_mutexattr_destroy(pthread_mutexattr_t *attr) {
 
        BEFORE_ORIGINAL_SYNC(pthread_mutexattr_destroy, LIBPTHREAD);
 
-       BEFORE_PACK_ORIGINAL_SYNC(pthread_mutexattr_destroy, LIBPTHREAD);
-
        ret = pthread_mutexattr_destroyp(attr);
 
        AFTER_ORIGINAL_NOSYNCVAL_RET(VT_INT, ret, SYNC_PTHREAD_MUTEX,
@@ -287,8 +275,6 @@ int pthread_mutexattr_getprioceiling(const pthread_mutexattr_t *attr,
 
        BEFORE_ORIGINAL_SYNC(pthread_mutexattr_getprioceiling, LIBPTHREAD);
 
-       BEFORE_PACK_ORIGINAL_SYNC(pthread_mutexattr_getprioceiling, LIBPTHREAD);
-
        ret = pthread_mutexattr_getprioceilingp(attr, prioceiling);
 
        AFTER_ORIGINAL_NOSYNCVAL_RET(VT_INT, ret, SYNC_PTHREAD_MUTEX,
@@ -307,8 +293,6 @@ int pthread_mutexattr_setprioceiling(pthread_mutexattr_t *attr,
 
        BEFORE_ORIGINAL_SYNC(pthread_mutexattr_setprioceiling, LIBPTHREAD);
 
-       BEFORE_PACK_ORIGINAL_SYNC(pthread_mutexattr_setprioceiling, LIBPTHREAD);
-
        ret = pthread_mutexattr_setprioceilingp(attr, prioceiling);
 
        AFTER_ORIGINAL_NOSYNCVAL_RET(VT_INT, ret, SYNC_PTHREAD_MUTEX,
@@ -327,8 +311,6 @@ int pthread_mutexattr_getprotocol(const pthread_mutexattr_t *attr,
 
        BEFORE_ORIGINAL_SYNC(pthread_mutexattr_getprotocol, LIBPTHREAD);
 
-       BEFORE_PACK_ORIGINAL_SYNC(pthread_mutexattr_getprotocol, LIBPTHREAD);
-
        ret = pthread_mutexattr_getprotocolp(attr, protocol);
 
        AFTER_ORIGINAL_NOSYNCVAL_RET(VT_INT, ret, SYNC_PTHREAD_MUTEX,
@@ -347,8 +329,6 @@ int pthread_mutexattr_setprotocol(pthread_mutexattr_t *attr,
 
        BEFORE_ORIGINAL_SYNC(pthread_mutexattr_setprotocol, LIBPTHREAD);
 
-       BEFORE_PACK_ORIGINAL_SYNC(pthread_mutexattr_setprotocol, LIBPTHREAD);
-
        ret = pthread_mutexattr_setprotocolp(attr, protocol);
 
        AFTER_ORIGINAL_NOSYNCVAL_RET(VT_INT, ret, SYNC_PTHREAD_MUTEX,
@@ -367,8 +347,6 @@ int pthread_mutexattr_getpshared(const pthread_mutexattr_t *attr,
 
        BEFORE_ORIGINAL_SYNC(pthread_mutexattr_getpshared, LIBPTHREAD);
 
-       BEFORE_PACK_ORIGINAL_SYNC(pthread_mutexattr_getpshared, LIBPTHREAD);
-
        ret = pthread_mutexattr_getpsharedp(attr, pshared);
 
        AFTER_ORIGINAL_NOSYNCVAL_RET(VT_INT, ret, SYNC_PTHREAD_MUTEX,
@@ -387,8 +365,6 @@ int pthread_mutexattr_setpshared(pthread_mutexattr_t *attr,
 
        BEFORE_ORIGINAL_SYNC(pthread_mutexattr_setpshared, LIBPTHREAD);
 
-       BEFORE_PACK_ORIGINAL_SYNC(pthread_mutexattr_setpshared, LIBPTHREAD);
-
        ret = pthread_mutexattr_setpsharedp(attr, pshared);
 
        AFTER_ORIGINAL_NOSYNCVAL_RET(VT_INT, ret, SYNC_PTHREAD_MUTEX,
@@ -406,8 +382,6 @@ int pthread_mutexattr_gettype(const pthread_mutexattr_t *attr, int *type) {
 
        BEFORE_ORIGINAL_SYNC(pthread_mutexattr_gettype, LIBPTHREAD);
 
-       BEFORE_PACK_ORIGINAL_SYNC(pthread_mutexattr_gettype, LIBPTHREAD);
-
        ret = pthread_mutexattr_gettypep(attr, type);
 
        AFTER_ORIGINAL_NOSYNCVAL_RET(VT_INT, ret, SYNC_PTHREAD_MUTEX,
@@ -425,8 +399,6 @@ int pthread_mutexattr_settype(pthread_mutexattr_t *attr, int type) {
 
        BEFORE_ORIGINAL_SYNC(pthread_mutexattr_settype, LIBPTHREAD);
 
-       BEFORE_PACK_ORIGINAL_SYNC(pthread_mutexattr_settype, LIBPTHREAD);
-
        ret = pthread_mutexattr_settypep(attr, type);
 
        AFTER_ORIGINAL_NOSYNCVAL_RET(VT_INT, ret, SYNC_PTHREAD_MUTEX,
@@ -451,8 +423,6 @@ int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr) {
 
        BEFORE_ORIGINAL_SYNC(pthread_cond_init, LIBPTHREAD);
 
-       BEFORE_PACK_ORIGINAL_SYNC(pthread_cond_init, LIBPTHREAD);
-
        ret = pthread_cond_initp(cond, attr);
 
        AFTER_ORIGINAL_SYNCVAL_RET(VT_INT, ret, cond, SYNC_PTHREAD_COND_VARIABLE, 
@@ -469,8 +439,6 @@ int pthread_cond_destroy(pthread_cond_t *cond) {
 
        BEFORE_ORIGINAL_SYNC(pthread_cond_destroy, LIBPTHREAD);
 
-       BEFORE_PACK_ORIGINAL_SYNC(pthread_cond_destroy, LIBPTHREAD);
-
        ret = pthread_cond_destroyp(cond);
 
        AFTER_ORIGINAL_SYNCVAL_RET(VT_INT, ret, cond, SYNC_PTHREAD_COND_VARIABLE, 
@@ -602,8 +570,6 @@ int pthread_cond_signal(pthread_cond_t *cond) {
 
        BEFORE_ORIGINAL_SYNC(pthread_cond_signal, LIBPTHREAD);
 
-       BEFORE_PACK_ORIGINAL_SYNC(pthread_cond_signal, LIBPTHREAD);
-
        ret = pthread_cond_signalp(cond);
 
        AFTER_ORIGINAL_SYNCVAL_RET(VT_INT, ret, cond, SYNC_PTHREAD_COND_VARIABLE, 
@@ -620,8 +586,6 @@ int pthread_cond_broadcast(pthread_cond_t *cond) {
 
        BEFORE_ORIGINAL_SYNC(pthread_cond_broadcast, LIBPTHREAD);
 
-       BEFORE_PACK_ORIGINAL_SYNC(pthread_cond_broadcast, LIBPTHREAD);
-
        ret = pthread_cond_broadcastp(cond);
 
        AFTER_ORIGINAL_SYNCVAL_RET(VT_INT, ret, cond, SYNC_PTHREAD_COND_VARIABLE, 

diff --git a/probe_thread/libdathread.c b/probe_thread/libdathread.c
index f6c15bb..8a52faf 100644 (file)
--- a/probe_thread/libdathread.c
+++ b/probe_thread/libdathread.c
@@ -141,8 +141,6 @@ 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();      
@@ -263,8 +261,6 @@ 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);
@@ -280,8 +276,6 @@ 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);
@@ -298,8 +292,6 @@ pthread_t pthread_self(void)
 
        BEFORE_ORIGINAL_THREAD(pthread_self, LIBPTHREAD);
 
-       BEFORE_PACK_ORIGINAL_THREAD(pthread_self, LIBPTHREAD);
-
        ret_pthr = pthread_selfp();
        
        newerrno = errno;
@@ -317,8 +309,6 @@ pthread_t pthread_self(void)
                AFTER_PACK_ORIGINAL_THREAD(ret_pthr, ret_pthr, THREAD_API_OTHER, "", 0);
 
                postBlockEnd();
-       } else {
-               FLUSH_LOCAL_BUF();
        }
 
        return ret_pthr;
@@ -330,8 +320,6 @@ 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);
@@ -348,8 +336,6 @@ 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);
 
@@ -369,8 +355,6 @@ 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);
 
@@ -390,8 +374,6 @@ 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);
@@ -408,8 +390,6 @@ 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);
@@ -427,8 +407,6 @@ 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, 
@@ -448,8 +426,6 @@ 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, 
@@ -469,8 +445,6 @@ 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, 
@@ -490,8 +464,6 @@ 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, 
@@ -511,8 +483,6 @@ 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, 
@@ -532,8 +502,6 @@ 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, 
@@ -553,8 +521,6 @@ 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, 
@@ -574,8 +540,6 @@ 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, 
@@ -596,8 +560,6 @@ 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, 
@@ -618,8 +580,6 @@ 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, 
@@ -639,8 +599,6 @@ 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, 
@@ -660,8 +618,6 @@ 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, 
@@ -681,8 +637,6 @@ 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, 
@@ -702,8 +656,6 @@ 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, 
@@ -723,8 +675,6 @@ 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, 
@@ -744,8 +694,6 @@ 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, 
@@ -766,8 +714,6 @@ 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, 
@@ -788,8 +734,6 @@ 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,