Subversion Repositories or1k

/*

 * (c) Copyright 1990-1996 OPEN SOFTWARE FOUNDATION, INC.

 * (c) Copyright 1990-1996 HEWLETT-PACKARD COMPANY

 * (c) Copyright 1990-1996 DIGITAL EQUIPMENT CORPORATION

 * (c) Copyright 1991, 1992 Siemens-Nixdorf Information Systems

 * To anyone who acknowledges that this file is provided "AS IS" without

 * any express or implied warranty: permission to use, copy, modify, and

 * distribute this file for any purpose is hereby granted without fee,

 * provided that the above copyright notices and this notice appears in

 * all source code copies, and that none of the names listed above be used

 * in advertising or publicity pertaining to distribution of the software

 * without specific, written prior permission.  None of these organizations

 * makes any representations about the suitability of this software for

 * any purpose.

 */

/*

 *      Header file for mutex operations

 */

#ifndef CMA_MUTEX

#define CMA_MUTEX

/*

 *  INCLUDE FILES

 */

#include <cma.h>

#include <cma_attr.h>

#include <cma_defs.h>

#include <cma_semaphore_defs.h>

#include <cma_sequence.h>

#include <cma_tcb_defs.h>

#include <cma_stack.h>

/*

 * CONSTANTS AND MACROS

 */

/*

 * TYPEDEFS

 */

typedef struct CMA__T_INT_MUTEX {

    cma__t_object       header;         /* Common header (sequence, type) */

    cma__t_int_attr     *attributes;    /* Back link */

    cma__t_int_tcb      *owner;         /* Current owner (if any) */

    cma_t_integer       nest_count;     /* Nesting level for recursive mutex */

    cma__t_atomic_bit   *unlock;        /* Pointer used for unlock operation */

    cma__t_atomic_bit   lock;           /* Set if currently locked */

    struct CMA__T_INT_MUTEX *int_lock;  /* Internal protection for mutex */

    cma__t_atomic_bit   event;          /* Clear when unlock requires action */

    cma__t_atomic_bit   waiters;        /* Clear when threads are waiting */

    cma__t_atomic_bit   bitbucket;      /* Fake bit to keep friendlies locked */

    cma_t_mutex_kind    mutex_kind;     /* Kind of mutex */

    cma__t_semaphore    semaphore;      /* Semaphore for low-level wait */

    } cma__t_int_mutex;

/*

 *  FUNCTIONAL DESCRIPTION:

 *

 *      Lock a mutex (internal)

 *

 *  FORMAL PARAMETERS:

 *

 *      mutex           Pointer to mutex object to lock

 *

 *  IMPLICIT INPUTS:

 *

 *      none

 *

 *  IMPLICIT OUTPUTS:

 *

 *      none

 *

 *  FUNCTION VALUE:

 *

 *      none

 *

 *  SIDE EFFECTS:

 *

 *      none

 */

#ifdef NDEBUG

# define cma__int_lock(mutex) { \

    if (cma__test_and_set (&((cma__t_int_mutex *)mutex)->lock)) { \

        cma_t_status    res;\

        res = cma__int_mutex_block ((cma__t_int_mutex *)mutex); \

        if (res != cma_s_normal) cma__error (res); \

        } \

    }

#else

# define cma__int_lock(mutex) { \

    cma__t_int_tcb *__ltcb__; \

    __ltcb__ = cma__get_self_tcb (); \

    if (cma__test_and_set (&((cma__t_int_mutex *)mutex)->lock)) { \

        cma_t_status    res;\

        res = cma__int_mutex_block ((cma__t_int_mutex *)mutex); \

        if (res != cma_s_normal) cma__error (res); \

        } \

    ((cma__t_int_mutex *)mutex)->owner = __ltcb__; \

    }

#endif

/*

 *  FUNCTIONAL DESCRIPTION:

 *

 *      Unlock a mutex (internal)

 *

 *  FORMAL PARAMETERS:

 *

 *      mutex           Pointer to mutex object to unlock

 *

 *  IMPLICIT INPUTS:

 *

 *      none

 *

 *  IMPLICIT OUTPUTS:

 *

 *      none

 *

 *  FUNCTION VALUE:

 *

 *      none

 *

 *  SIDE EFFECTS:

 *

 *      none

 */

#ifdef NDEBUG

# define cma__int_unlock(mutex) { \

    cma__unset (((cma__t_int_mutex *)mutex)->unlock); \

    if (!cma__test_and_set (&((cma__t_int_mutex *)mutex)->event)) { \

        cma_t_status    res;\

        res = cma__int_mutex_unblock ((cma__t_int_mutex *)mutex); \

        if (res != cma_s_normal) cma__error (res); \

        } \

    }

#else

# define cma__int_unlock(mutex) { \

    cma__t_int_tcb      *__utcb__; \

    __utcb__ = cma__get_self_tcb (); \

    if (((cma__t_int_mutex *)mutex)->mutex_kind == cma_c_mutex_fast) { \

        cma__assert_warn ( \

                (__utcb__ == ((cma__t_int_mutex *)mutex)->owner), \

                "attempt to release mutx owned by another thread"); \

        ((cma__t_int_mutex *)mutex)->owner = (cma__t_int_tcb *)cma_c_null_ptr; \

        } \

    cma__unset (((cma__t_int_mutex *)mutex)->unlock); \

    if (!cma__test_and_set (&((cma__t_int_mutex *)mutex)->event)) { \

        cma_t_status    res;\

        res = cma__int_mutex_unblock ((cma__t_int_mutex *)mutex); \

        if (res != cma_s_normal) cma__error (res); \

        } \

    }

#endif

/*

 *  FUNCTIONAL DESCRIPTION:

 *

 *      cma__int_mutex_delete - Performs work for cma_mutex_delete

 *

 *  FORMAL PARAMETERS:

 *

 *      cma__t_mutex        _mutex_     - Mutex to be deleted

 *

 *  IMPLICIT INPUTS:

 *

 *      none

 *

 *  IMPLICIT OUTPUTS:

 *

 *      none

 *

 *  FUNCTION VALUE:

 *

 *      none

 *

 *  SIDE EFFECTS:

 *

 *      none

 */

#define cma__int_mutex_delete(_mutex_) { \

    cma__t_int_mutex    *_int_mutex_; \

    _int_mutex_ = cma__validate_null_mutex (_mutex_); \

    if (_int_mutex_ == (cma__t_int_mutex *)cma_c_null_ptr) \

        return; \

    if (cma__int_mutex_locked (_int_mutex_)) \

        cma__error (cma_s_in_use); \

    cma__free_mutex (_int_mutex_); \

    cma__clear_handle (_mutex_); \

    }

/*

 *  GLOBAL DATA

 */

extern cma__t_sequence  cma__g_mutex_seq;

extern cma__t_int_mutex *cma__g_global_lock;

/*

 * INTERNAL INTERFACES

 */

extern void cma__destroy_mutex  (cma__t_int_mutex *);

extern void cma__free_mutex  (cma__t_int_mutex *);

extern void cma__free_mutex_nolock  (cma__t_int_mutex *);

extern cma__t_int_mutex * cma__get_first_mutex  (cma__t_int_attr *);

extern cma__t_int_mutex * cma__get_mutex  (cma__t_int_attr *);

extern void cma__init_mutex  (void);

extern cma_t_status cma__int_mutex_block  (cma__t_int_mutex *);

extern cma_t_boolean cma__int_mutex_locked  (cma__t_int_mutex *);

extern cma_t_boolean cma__int_try_lock  (cma__t_int_mutex *);

extern cma_t_status cma__int_mutex_unblock  (cma__t_int_mutex *);

extern cma_t_boolean cma__mutex_locked  (cma_t_mutex);

extern void cma__reinit_mutex  (cma_t_integer);

#endif