event.c

linux下的多线程调试工具

/* Copyright (C) 2004,2005,2006  Bull S.A.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#if HAVE_CONFIG_H
#include <config.h>
#endif

#include "types.h"

#define EVT0(param,s1,f) \
    {#param, 0, {0,}, {s1,}, f} 
#define EVT1(param,s1,s2,x,f) \
    {#param, 1, {PTT_##x,}, {s1, s2,}, f} 
#define EVT2(param,s1,s2,s3,x,y,f) \
    {#param, 2, {PTT_##x, PTT_##y,}, {s1,s2,s3,}, f}
#define EVT3(param,s1,s2,s3,s4,x,y,z,f) \
    {#param, 3, {PTT_##x,PTT_##y,PTT_##z,}, {s1,s2,s3,s4,}, f}
#define EVT4(param,s1,s2,s3,s4,s5,x,y,z,t,f) \
    {#param, 4, {PTT_##x,PTT_##y,PTT_##z,PTT_##t,}, {s1,s2,s3,s4,s5,}, f}
#define EVT5(param,s1,s2,s3,s4,s5,s6,x,y,z,t,u,f) \
    {#param, 5,	{PTT_##x,PTT_##y,PTT_##z,PTT_##t,PTT_##u}, \
     {s1,s2,s3,s4,s5,s6}, f}

ptt_event_data_t ptt_event_array[] = {
    {"NULL", 0, {0,}, {0,}, 0},
    EVT1(START_USER_FUNC, " starts user function, version=", "", UINT, 0),
    EVT0(END_USER_FUNC, " leaves user function", 0),
    EVT2(BARRIER_LOCK_FREE, " frees barrier ", ", lock=", "", PTR, INT, 0),
    EVT2(BARRIER_LOCK_REQUIRE, " requires barrier ", ", lock=", "", PTR, INT,
                               0),
    EVT2(BARRIER_LOCK_TAKEN, " takes barrier ", ", lock=", "", PTR, INT, 0),
    EVT2(BARRIER_LEFT_DEC, " decrements barrier ", ", left=", "", PTR, UINT,
                           0),
    EVT2(BARRIER_LEFT_INC, " increments barrier ", ", left=", "", PTR, UINT,
                           0),
    EVT2(BARRIER_INIT, " initializes barrier ", ", left=", "", PTR, UINT, 0),
    EVT1(BARRIER_DESTROY, " destroys barrier ", "", PTR, 0),
    EVT1(BARRIER_DESTROY_IN, " enters function pthread_barrier_destroy, "
                             "barrier=", "", PTR, 0),
    EVT2(BARRIER_DESTROY_OUT, " leaves function pthread_barrier_destroy, "
                              "barrier= ", ", return=", "", PTR, INT, 0),
    EVT3(BARRIER_INIT_IN, " enters function pthread_barrier_init, barrier=",
                          ", attribute=", ", count=", "", PTR, PTR, UINT, 0),
    EVT2(BARRIER_INIT_OUT, " leaves function pthread_barrier_init, barrier=",
                           ", return=", "", PTR, INT, 0),
    EVT1(BARRIER_WAIT_IN, " enters function pthread_barrier_wait, barrier=",
                          "", PTR, 0),
    EVT2(BARRIER_WAIT_OUT, " leaves function pthread_barrier_wait, barrier=",
                           ", return=", "", PTR, INT, 0),
    EVT2(COND_LOCK_FREE, " frees cond-var ", ", lock=", "", PTR, INT, 0),
    EVT2(COND_LOCK_REQUIRE, " requires cond-var ", ", lock=", "", PTR, INT, 0),
    EVT2(COND_LOCK_TAKEN, " takes cond-var ", ", lock=", "", PTR, INT, 0),
    EVT2(COND_TOTAL_SEQ_SET, " blocks cond-var ", "for destruction, "
                             "total_seq=", "", PTR, ULL, 0),
    EVT2(COND_TOTAL_SEQ_INC, " uses the cond-var ", ", total_seq=", "", PTR,
                             ULL, 0),
    EVT2(COND_BROAD_SEQ_INC, " wakes up everyone waiting for cond-var ",
                             ", broad_seq=", "", PTR, UINT, 0),
    EVT2(COND_MUTEX_FREE, " frees mutex ", " of cond-var ", "", PTR, PTR, 0),
    EVT2(COND_MUTEX_REQUIRE, " requires mutex ", " of cond-var ", "", PTR,
                             PTR, 0),
    EVT2(COND_MUTEX_TAKEN, " takes mutex ", " of cond-var ", "", PTR, PTR, 0),
    EVT4(COND_INIT, " initializes cond-var ", ", mutex=", ", total_seq=",
                    ", broad_seq=", "", PTR, PTR, ULL, UINT, 0),
    EVT1(COND_DESTROY, " destroys cond-var ", "", PTR, 0),
    EVT1(COND_DESTROY_IN, " enters function pthread_cond_destroy, cond-var=",
                          "", PTR, 0),
    EVT2(COND_DESTROY_OUT, " leaves function pthread_cond_destroy, cond-var=",
                           ", return=", "", PTR, INT, 0),
    EVT2(COND_INIT_IN, " enters function pthread_cond_init, cond-var=",
                       ", attribute=", "", PTR, PTR, 0),
    EVT2(COND_INIT_OUT, " leaves function pthread_cond_init, cond-var=",
                        ", return=", "", PTR, INT, 0),
    EVT1(COND_BROAD_IN, " enters function pthread_cond_broadcast, cond-var=",
                        "", PTR, 0),
    EVT2(COND_BROAD_OUT, " leaves function pthread_cond_broadcast, cond-var=",
                         ", return=", "", PTR, INT, 0),
    EVT1(COND_SIGNAL_IN, " enters function pthread_cond_signal, cond-var=",
                         "", PTR, 0),
    EVT2(COND_SIGNAL_OUT, " leaves function pthread_cond_signal, cond-var=",
                          ", return=", "", PTR, INT, 0),
    EVT2(COND_WAIT_IN, " enters function pthread_cond_wait, cond-var=",
                       ", mutex=", "", PTR, PTR, 0),
    EVT2(COND_WAIT_OUT, " leaves function pthread_cond_wait, cond-var=",
                        ", return=", "", PTR, INT, 0),
    EVT2(MUTEX_STATE_FREE, " frees mutex ", ", lock=", "", PTR, INT, 0),
    EVT2(MUTEX_STATE_REQUIRE, " requires mutex ", ", lock=", "", PTR, INT, 0),
    EVT2(MUTEX_STATE_TAKEN, " locks mutex ", ", lock=", "", PTR, INT, 0),
    EVT2(MUTEX_COUNT_DEC, " decrements mutex ", ", count=", "", PTR, UINT, 0),
    EVT2(MUTEX_COUNT_INC, " increments mutex ", ", count=", "", PTR, UINT, 0),
    EVT2(MUTEX_OWNER_CHANGE, " changes the owner of mutex ", ", owner=", "",
                             PTR, INT, 0),
    EVT4(MUTEX_INIT, " initializes mutex ", ", owner=", ", count=", ", kind=",
                     "", PTR, UINT, INT, INT, 0),
    EVT1(MUTEX_DESTROY, " destroys mutex ", "", PTR, 0),
    EVT1(MUTEX_DESTROY_IN, " enters function pthread_mutex_destroy, mutex=",
                           "", PTR, 0),
    EVT2(MUTEX_DESTROY_OUT, " leaves function pthread_mutex_destroy, mutex=",
                            " return=", "", PTR, INT, 0),
    EVT2(MUTEX_INIT_IN, " enters function pthread_mutex_init, mutex=",
                        ", attribute=", "", PTR, PTR, 0),
    EVT2(MUTEX_INIT_OUT, " leaves function pthread_mutex_init, mutex=",
                         " return=", "", PTR, INT, 0),
    EVT1(MUTEX_LOCK_IN, " enters function pthread_mutex_lock, mutex=", "",
                        PTR, 0),
    EVT2(MUTEX_LOCK_OUT, " leaves function pthread_mutex_lock, mutex=",
                         " return=", "", PTR, INT, 0),
    EVT1(MUTEX_UNLOCK_IN, " enters function pthread_mutex_unlock, mutex=", "",
                          PTR, 0),
    EVT2(MUTEX_UNLOCK_OUT, " leaves function pthread_mutex_unlock, mutex=",
                           " return=", "", PTR, INT, 0),
    EVT2(THREAD_JOIN, " joins thread ", " that returned ", "", PTR, INT, 0),
    EVT1(THREAD_DETACH, " makes thread ", " unjoinable", PTR, 0),
    EVT0(THREAD_STATE_DEAD, " is dead", 0),
    EVT0(THREAD_STATE_WAIT, " is blocked", 0),
    EVT0(THREAD_STATE_WAKE, " is resumed", 0),
    EVT1(THREAD_INIT, " creates thread ", "", PTR, 0),
    EVT4(THREAD_CREATE_IN, " enters function pthread_create, thread=",
                           ", attribute=", ", start_routine=", ", argument=",
                           "", PTR, PTR, PTR, PTR, 0),
    EVT1(THREAD_CREATE_OUT, " leaves function pthread_create, return=", "",
                            INT, 0),
    EVT2(THREAD_JOIN_IN, " enters function pthread_join, thread=",
                         " thread returns in ", "", PTR, PTR, 0),
    EVT1(THREAD_JOIN_OUT, " leaves function pthread_join, return=", "", INT,
                          0),
    EVT1(THREAD_SET_PD, " sets new thread at address ", "", PTR, 0),	
    EVT1(THREAD_CANCEL_IN, " enters function pthread_cancel, thread=", "",
                           PTR, 0),
    EVT1(THREAD_CANCEL_OUT, " leaves function pthread_cancel, return=", "",
                            INT, 0),
    EVT1(THREAD_CANCEL_PROG, " cancelling thread ", " is in progress ",
                             PTR, 0),
    EVT1(THREAD_STATE_CANCEL, " cancels thread ", "", PTR ,0),
    EVT1(THREAD_STATE_WAIT_MUTEX, " is blocked on mutex ", "", PTR, 0),
    EVT1(THREAD_STATE_WAKE_MUTEX, " is resumed, mutex=", "", PTR, 0),
    EVT1(THREAD_STATE_WAIT_BARRIER, " is blocked on barrier ", "", PTR, 0),
    EVT1(THREAD_STATE_WAKE_BARRIER, " is resumed, barrier=", "", PTR, 0),
    EVT1(THREAD_STATE_WAIT_COND, " is blocked on cond-var ", "", PTR, 0),
    EVT1(THREAD_STATE_WAKE_COND, " is resumed, cond-var=", "", PTR, 0),
    EVT1(THREAD_STATE_WAIT_SEM, " is blocked on semaphore ", "", PTR, 0),
    EVT1(THREAD_STATE_WAKE_SEM, " is resumed, semaphore=", "", PTR, 0),
    EVT1(PROG_FORK, " is child of ", "", INT, 0),
    EVT2(SEM_COUNT_DEC, " decrements semaphore ", ", count=", "", PTR, UINT,
                        0),
    EVT2(SEM_COUNT_INC, " increments semaphore ", ", count=", "", PTR, UINT,
                        0),
    EVT2(SEM_INIT, " initializes semaphore ", ", count=", "", PTR, UINT, 0),
    EVT3(SEM_INIT_IN, " enters function sem_init, sem=", ", pshared=",
                      ", count=", "", PTR, INT, UINT, 0),
    EVT2(SEM_INIT_OUT, " leaves function sem_init, sem =", ", return=", "",
                       PTR, INT, 0),
    EVT1(SEM_DESTROY, " destroys semaphore ", "", PTR, 0),
    EVT1(SEM_DESTROY_IN, " enters function sem_destroy, sem=", "", PTR, 0),
    EVT2(SEM_DESTROY_OUT, " leaves function sem_destroy, sem=", ", return=",
                          "", PTR, INT, 0),
    EVT1(SEM_POST_IN, " enters function sem_post, sem=", "", PTR, 0),
    EVT2(SEM_POST_OUT, " leaves function sem_post, sem=", ", return=", "",
                       PTR, INT, 0),
    EVT1(SEM_WAIT_IN, " enters function sem_wait, sem=", "", PTR, 0),
    EVT2(SEM_TRYWAIT_OUT, " leaves function sem_trywait, sem=", ", return=",
                          "", PTR, INT, 0),
    EVT1(SEM_TRYWAIT_IN, " enters function sem_trywait, sem=", "", PTR, 0),
    EVT2(SEM_WAIT_OUT, " leaves function sem_wait, sem=", " return=", "", PTR,
                       INT, 0),
    EVT2(SEM_OPEN_IN, " enters function sem_open, sem name=", ", oflag=", "",
                      PTR, INT, 0),
    EVT2(SEM_OPEN_OUT, " leaves function sem_open, sem name=", ", return=",
                       "", PTR, PTR, 0),
    EVT2(SEM_OPEN_CREATE, " will create a semaphore, mode=", ", count=", "",
                          UINT, INT, 0),
    EVT1(SEM_CLOSE_IN, " enters function sem_close, sem=", "", PTR, 0),
    EVT1(SEM_CLOSE_OUT, " leaves function sem_close, return=", "", INT, 0),
    EVT0(SEM_MAPPINGSLOCK_FREE, " frees sem mapping ", 0),
    EVT0(SEM_MAPPINGSLOCK_REQUIRE, " requires sem mapping ", 0),
    EVT0(SEM_MAPPINGSLOCK_TAKEN, " takes sem mapping ", 0),
    EVT2(SEM_REFCOUNT_DEC, " decrements reference counter for semaphore ",
                           ", count=", "", PTR, UINT, 0),
    EVT2(SEM_REFCOUNT_INC, " increments reference counter for semaphore ",
                           ", count=", "", PTR, UINT, 0),
    EVT1(SEM_UNLINK_IN, " enters function sem_unlink, sem name=", "", PTR, 0),
    EVT2(SEM_UNLINK_OUT, " leaves function sem_unlink, sem name=",
                         ", return=", "", PTR, INT, 0)
};