thd.h

Go to the documentation of this file.

/*
 * Copyright (c) 2008 - 2012, Andy Bierman, All Rights Reserved.
 * Copyright (c) 2012 - 2021, YumaWorks, Inc., All Rights Reserved.
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

#ifdef PTHREADS
#ifndef _H_thd
#define _H_thd

/*  FILE: thd.h
*********************************************************************
*                                                                   *
*                        P U R P O S E                              *
*                                                                   *
*********************************************************************/

/*********************************************************************
*                                                                   *
*                  C H A N G E   H I S T O R Y                      *
*                                                                   *
*********************************************************************

date         init     comment
----------------------------------------------------------------------
14-Jan-13    mts      begun, borrowed from log.h: Pthread feature set
*/

#include <assert.h>
#include <stdio.h>
#include <xmlstring.h>
#include <pthread.h>

#ifdef WINDOWS
#include <winsock2.h>
#include <windows.h>
#else
#include <sys/signal.h>
#endif

#ifdef HAS_SIGNALFD
#include <sys/signalfd.h>
#endif

#include "procdefs.h"
#include "status.h"
#include "ses.h"

#ifdef __cplusplus
extern "C" {
#endif

/********************************************************************
*                                                                   *
*                           M A C R O S                             *
*                                                                   *
*********************************************************************/


/********************************************************************
*                                                                   *
*                        C O N S T A N T S                          *
*                                                                   *
*********************************************************************/
#undef DEBUG_THD
/*
 * Not strictly necessary, but this gives us the flexibility to
 * force thd debugs separately into a special (non-DEBUG) build.
 */
#ifdef DEBUG
#define DEBUG_THD // DEBUG compile only thread-related debugs
#endif

#define LOCK_BANNER "[LOCK]"

/* For use with thd_cleanup() */
#define THD_CLEANUP_PHASE1 TRUE
#define THD_CLEANUP_PHASE2 FALSE

/* For use with thd_find_tcb_by_sid() ('strict' param) */
#define THD_STRICT_LOOKUP  TRUE
#define THD_SIMPLE_LOOKUP  !THD_STRICT_LOOKUP

#define NULL_PTHREAD (pthread_t)NULL

#define INIT_TID     (-1)               /* For use during init */
#define INIT_SID     (-1)               /* For use during init */

#define MAINLINE_TID  0  /* To distinguish between MAINLINE and thread */
#define MAINLINE_SID  0  /* To distinguish between MAINLINE and thread */

#define NULL_TID      0               /* For use to show "none" */
#define NULL_SID      SES_NULL_SID    /* For use to show "none" */


/* Thread capability bits */
#define THD_CAP_CANCEL_CC       bit0  /* Background thread for CC cancel */
#define THD_CAP_NEXT_AVAIL      bit1

#define THD_INC_THD_CNT    ENTER_FAST_CS; /* ++++++++++++++++++++++++ */      \
                               thread_count++;                                \
                           EXIT_FAST_CS;  /* ------------------------ */

#define THD_DEC_THD_CNT    ENTER_FAST_CS; /* ++++++++++++++++++++++++ */      \
                               thread_count--;                                \
                           EXIT_FAST_CS;  /* ------------------------ */

#ifdef HAS_SIGNALFD
#define THD_SIGNAL SIGVTALRM
#else
#define THD_SIGNAL SIGTERM
#endif

#define THD_LOGROTATE_SIG SIGUSR2


/********************************************************************
*                                                                   *
*                            T Y P E S                              *
*                                                                   *
*********************************************************************/

typedef boolean (*test_cdx_void_t) (void);
typedef boolean (*test_cdx_int_t) (int);

typedef enum thd_tcb_state_t_ {
    THD_TCB_STATE_NONE,         
    THD_TCB_STATE_ACTIVE,       
    THD_TCB_STATE_INACTIVE,    
    THD_TCB_STATE_DELETED,     
    THD_TCB_STATE_LIMIT
} thd_tcb_state_t;

#define THD_TCB_STATE_MIN (THD_TCB_STATE_NONE  + 1)
#define THD_TCB_STATE_MAX (THD_TCB_STATE_LIMIT - 1)

typedef enum thd_type_t_ {
    THD_TYPE_NONE,      
    THD_TYPE_BKGD,      
    THD_TYPE_CONN,      
    THD_TYPE_TMR,       
    THD_TYPE_SES,       
    THD_TYPE_DUMMY,     
    THD_TYPE_LIMIT
} thd_type_t;

#define THD_TYPE_MIN (THD_TYPE_NONE  + 1)
#define THD_TYPE_MAX (THD_TYPE_LIMIT - 1)

typedef struct thd_tcb_t_ {

    dlq_hdr_t       qhdr;    
    thd_tcb_state_t state;   
    pthread_t       handle;    
    thd_type_t      thd_type;  
    uint            thd_cap;  
    const char     *name;     
    ses_cb_t       *dscb;     
    ses_id_t        sid;      
    // ses_cb_t       *scb;   /* NOT USED anymore, use SID instead*/
    int             tid;       
    int             run;       
    int             fd;       
    int             sfd;      
    fd_set          tcb_fd_set;  
    int             sleep;     
    void            *rwlock_locked[NCX_CFGID_CNT];

    boolean          rwlock_wrlocked[NCX_CFGID_CNT];

    int              rwlock_lock_level[NCX_CFGID_CNT];

    boolean          rwlock_req_needed[NCX_CFGID_CNT];

    boolean          rwlock_req_wrlock[NCX_CFGID_CNT];

    boolean          rwlock_req_locked[NCX_CFGID_CNT];

    boolean          rwlock_req_error[NCX_CFGID_CNT];

    boolean           module_db_locked;

    boolean           kill_session;

    ses_id_t          killedby;

    ses_term_reason_t termreason;

    boolean              cancel_cc;

    ncx_confirm_event_t  cancel_cc_event;

    struct agt_not_subscription_t_ *sub; /* back-ptr to subscription */
    boolean      snmp_notif;      
} thd_tcb_t;



/********************************************************************
*                                                                   *
*                       V A R I A B L E S                           *
*                                                                   *
*********************************************************************/
extern boolean thd_init_called;
extern boolean thd_init_successful;

extern int thread_count;
extern boolean thd_cs_mutex_init;

extern pthread_attr_t pthread_attr;


/********************************************************************
*                                                                   *
*                       F U N C T I O N S                           *
*                                                                   *
*********************************************************************/

extern boolean
    thd_rcv_signal_setup(sigset_t *sigmask,
                         thd_tcb_t *tcb);


extern void
    thd_check_shutdown_signal (sigset_t *sigmask,
                               thd_tcb_t *tcb);

extern boolean
    thd_yield_for_cdx (int max_yield_count,
                       uint usec,
                       int ival,
                       test_cdx_int_t sid_test_func);


extern void thd_set_main_pthread_attr (void);


extern status_t thd_master_init ( void );


extern void thd_set_main_handle ( void );


extern thd_tcb_t *thd_new_tcb ( thd_type_t type );


extern void thd_clear_locks(thd_tcb_t *tcb);


extern void thd_mark_tcb_deleted( thd_tcb_t *tcb);


extern void thd_shutdown (void);


extern void thd_cleanup( boolean phase1 );


extern thd_tcb_t *thd_find_tcb_by_handle( pthread_t handle );


extern thd_tcb_t *thd_find_tcb_by_capability( uint cap );


extern thd_tcb_t *
    thd_find_tcb_by_type (thd_type_t type);


extern int
    thd_count_ses_threads (void);


extern thd_tcb_t *thd_find_tcb_by_sid( ses_id_t sid, boolean strict );



extern ses_id_t thd_find_sess_id_by_handle( pthread_t handle );


extern ses_id_t thd_find_sess_id ( void );


extern int thd_find_thread_id ( void );


extern thd_tcb_t *thd_get_thread_tcb ( void );


extern void thd_get_ids (int *tid, ses_id_t *sid);


extern void thd_set_ready (void);


extern int thd_lock_recursive_log_cs_mutex (void);


extern int thd_unlock_recursive_log_cs_mutex (void);


extern int thd_lock_ses_sync_mutex (void);


extern int thd_unlock_ses_sync_mutex (void);


extern int thd_lock_inreadyQ_mutex (ses_id_t sid);


extern int thd_unlock_inreadyQ_mutex (ses_id_t sid);


extern status_t thd_module_db_rdlock (thd_tcb_t *tcb);


extern status_t thd_module_db_wrlock (thd_tcb_t *tcb);


extern status_t thd_module_db_unlock (thd_tcb_t *tcb);


extern thd_tcb_t *
    thd_get_first_tcb (void);


extern thd_tcb_t *
    thd_get_next_tcb (thd_tcb_t *tcb);


#ifdef __cplusplus
}  /* end extern 'C' */
#endif

#endif /* _H_thd */
#endif // PTHREADS