checklocks.h

Go to the documentation of this file.

 
#ifndef TESTCODE_CHECK_LOCKS_H
#define TESTCODE_CHECK_LOCKS_H
 
#ifdef USE_THREAD_DEBUG
#ifndef HAVE_PTHREAD
/* we need the *timed*lock() routines to use for deadlock detection. */
#error "Need pthreads for checked locks"
#endif
/******************* THREAD DEBUG ************************/
#include <pthread.h>
 
#define THRDEBUG_MAX_THREADS 32 /* threads */
extern int check_locking_order;
 
struct protected_area {
    void* region;
    size_t size;
    void* hold;
    struct protected_area* next;
};
 
struct thr_check {
    pthread_t id;
    void* (*func)(void*);
    void* arg;
    int num;
    int locks_created;
    FILE* order_info;
    struct checked_lock *holding_first, *holding_last;
    struct checked_lock* waiting;
};
 
struct checked_lock {
    pthread_mutex_t lock;
    struct protected_area* prot;
    const char* create_func, *create_file;
    int create_line;
    int create_thread, create_instance;
    size_t contention_count;
    size_t history_count;
    int hold_count;
    int wait_count;
    const char* holder_func, *holder_file;
    int holder_line;
    struct thr_check* holder;
    struct thr_check* writeholder;
 
    struct checked_lock* next_held_lock[THRDEBUG_MAX_THREADS];
    struct checked_lock* prev_held_lock[THRDEBUG_MAX_THREADS];
 
    enum check_lock_type {
        check_lock_mutex,
        check_lock_spinlock,
        check_lock_rwlock
    } type;
    union {
        pthread_mutex_t mutex;
        pthread_spinlock_t spinlock;
        pthread_rwlock_t rwlock;
    } u;
};
 
void lock_protect(void* lock, void* area, size_t size);
 
void lock_unprotect(void* lock, void* area);
 
size_t lock_get_mem(void* lock);
 
void checklock_start(void);
 
void checklock_stop(void);
 
void checklock_init(enum check_lock_type type, struct checked_lock** lock,
    const char* func, const char* file, int line);
 
void checklock_destroy(enum check_lock_type type, struct checked_lock** lock,
    const char* func, const char* file, int line);
 
void checklock_rdlock(enum check_lock_type type, struct checked_lock* lock,
    const char* func, const char* file, int line);
 
void checklock_wrlock(enum check_lock_type type, struct checked_lock* lock,
    const char* func, const char* file, int line);
 
void checklock_lock(enum check_lock_type type, struct checked_lock* lock,
    const char* func, const char* file, int line);
 
void checklock_unlock(enum check_lock_type type, struct checked_lock* lock,
    const char* func, const char* file, int line);
 
void checklock_thrcreate(pthread_t* thr, void* (*func)(void*), void* arg);
 
void checklock_thrjoin(pthread_t thread);
 
struct checked_lock_rw { struct checked_lock* c_rw; };
struct checked_lock_mutex { struct checked_lock* c_m; };
struct checked_lock_spl { struct checked_lock* c_spl; };
 
typedef struct checked_lock_rw lock_rw_type;
#define lock_rw_init(lock) checklock_init(check_lock_rwlock, &((lock)->c_rw), __func__, __FILE__, __LINE__)
#define lock_rw_destroy(lock) checklock_destroy(check_lock_rwlock, &((lock)->c_rw), __func__, __FILE__, __LINE__)
#define lock_rw_rdlock(lock) checklock_rdlock(check_lock_rwlock, (lock)->c_rw, __func__, __FILE__, __LINE__)
#define lock_rw_wrlock(lock) checklock_wrlock(check_lock_rwlock, (lock)->c_rw, __func__, __FILE__, __LINE__)
#define lock_rw_unlock(lock) checklock_unlock(check_lock_rwlock, (lock)->c_rw, __func__, __FILE__, __LINE__)
 
typedef struct checked_lock_mutex lock_basic_type;
#define lock_basic_init(lock) checklock_init(check_lock_mutex, &((lock)->c_m), __func__, __FILE__, __LINE__)
#define lock_basic_destroy(lock) checklock_destroy(check_lock_mutex, &((lock)->c_m), __func__, __FILE__, __LINE__)
#define lock_basic_lock(lock) checklock_lock(check_lock_mutex, (lock)->c_m, __func__, __FILE__, __LINE__)
#define lock_basic_unlock(lock) checklock_unlock(check_lock_mutex, (lock)->c_m, __func__, __FILE__, __LINE__)
 
typedef struct checked_lock_spl lock_quick_type;
#define lock_quick_init(lock) checklock_init(check_lock_spinlock, &((lock)->c_spl), __func__, __FILE__, __LINE__)
#define lock_quick_destroy(lock) checklock_destroy(check_lock_spinlock, &((lock)->c_spl), __func__, __FILE__, __LINE__)
#define lock_quick_lock(lock) checklock_lock(check_lock_spinlock, (lock)->c_spl, __func__, __FILE__, __LINE__)
#define lock_quick_unlock(lock) checklock_unlock(check_lock_spinlock, (lock)->c_spl, __func__, __FILE__, __LINE__)
 
typedef pthread_t ub_thread_type;
#define ub_thread_create(thr, func, arg) checklock_thrcreate(thr, func, arg)
#define ub_thread_self() pthread_self()
#define ub_thread_join(thread) checklock_thrjoin(thread)
 
typedef pthread_key_t ub_thread_key_type;
#define ub_thread_key_create(key, f) LOCKRET(pthread_key_create(key, f))
#define ub_thread_key_set(key, v) LOCKRET(pthread_setspecific(key, v))
#define ub_thread_key_get(key) pthread_getspecific(key)
 
#endif /* USE_THREAD_DEBUG */
#endif /* TESTCODE_CHECK_LOCKS_H */