Back to index

openldap  2.4.31
Classes | Defines | Functions | Variables
rmutex.c File Reference
#include "portable.h"
#include <ac/stdlib.h>
#include <ac/errno.h>
#include <ac/string.h>
#include <ac/time.h>
#include "ldap-int.h"
#include "ldap_pvt_thread.h"

Go to the source code of this file.

Classes

struct  ldap_int_thread_rmutex_s

Defines

#define LDAP_PVT_THREAD_RMUTEX_VALID   0x0cdb

Functions

int ldap_pvt_thread_rmutex_init (ldap_pvt_thread_rmutex_t *rmutex)
int ldap_pvt_thread_rmutex_destroy (ldap_pvt_thread_rmutex_t *rmutex)
int ldap_pvt_thread_rmutex_lock (ldap_pvt_thread_rmutex_t *rmutex, ldap_pvt_thread_t owner)
int ldap_pvt_thread_rmutex_trylock (ldap_pvt_thread_rmutex_t *rmutex, ldap_pvt_thread_t owner)
int ldap_pvt_thread_rmutex_unlock (ldap_pvt_thread_rmutex_t *rmutex, ldap_pvt_thread_t owner)

Variables

static const ldap_pvt_thread_t tid_zero

Class Documentation

struct ldap_int_thread_rmutex_s

Definition at line 34 of file rmutex.c.

Class Members
ldap_pvt_thread_cond_t ltrm_cond
int ltrm_depth
ldap_pvt_thread_mutex_t ltrm_mutex
ldap_pvt_thread_t ltrm_owner
int ltrm_valid
int ltrm_waits

Define Documentation

#define LDAP_PVT_THREAD_RMUTEX_VALID   0x0cdb

Definition at line 39 of file rmutex.c.


Function Documentation

Definition at line 69 of file rmutex.c.

{
       struct ldap_int_thread_rmutex_s *rm;

       assert( rmutex != NULL );
       rm = *rmutex;

       assert( rm != NULL );
       assert( rm->ltrm_valid == LDAP_PVT_THREAD_RMUTEX_VALID );

       if( rm->ltrm_valid != LDAP_PVT_THREAD_RMUTEX_VALID )
              return LDAP_PVT_THREAD_EINVAL;

       ldap_pvt_thread_mutex_lock( &rm->ltrm_mutex );

       assert( rm->ltrm_depth >= 0 );
       assert( rm->ltrm_waits >= 0 );

       /* in use? */
       if( rm->ltrm_depth > 0 || rm->ltrm_waits > 0 ) {
              ldap_pvt_thread_mutex_unlock( &rm->ltrm_mutex );
              return LDAP_PVT_THREAD_EBUSY;
       }

       rm->ltrm_valid = 0;

       ldap_pvt_thread_mutex_unlock( &rm->ltrm_mutex );

       ldap_pvt_thread_mutex_destroy( &rm->ltrm_mutex );
       ldap_pvt_thread_cond_destroy( &rm->ltrm_cond );

       LDAP_FREE(rm);
       *rmutex = NULL;
       return 0;
}

Here is the caller graph for this function:

Definition at line 47 of file rmutex.c.

{
       struct ldap_int_thread_rmutex_s *rm;

       assert( rmutex != NULL );

       rm = (struct ldap_int_thread_rmutex_s *) LDAP_CALLOC( 1,
              sizeof( struct ldap_int_thread_rmutex_s ) );
       if ( !rm )
              return LDAP_NO_MEMORY;

       /* we should check return results */
       ldap_pvt_thread_mutex_init( &rm->ltrm_mutex );
       ldap_pvt_thread_cond_init( &rm->ltrm_cond );

       rm->ltrm_valid = LDAP_PVT_THREAD_RMUTEX_VALID;

       *rmutex = rm;
       return 0;
}

Here is the caller graph for this function:

Definition at line 105 of file rmutex.c.

{
       struct ldap_int_thread_rmutex_s *rm;

       assert( rmutex != NULL );
       rm = *rmutex;

       assert( rm != NULL );
       assert( rm->ltrm_valid == LDAP_PVT_THREAD_RMUTEX_VALID );

       if( rm->ltrm_valid != LDAP_PVT_THREAD_RMUTEX_VALID )
              return LDAP_PVT_THREAD_EINVAL;

       ldap_pvt_thread_mutex_lock( &rm->ltrm_mutex );

       assert( rm->ltrm_depth >= 0 );
       assert( rm->ltrm_waits >= 0 );

       if( rm->ltrm_depth > 0 ) {
              /* already locked */
              if ( !ldap_pvt_thread_equal( rm->ltrm_owner, owner )) {
                     rm->ltrm_waits++;
                     do {
                            ldap_pvt_thread_cond_wait( &rm->ltrm_cond,
                                   &rm->ltrm_mutex );
                     } while( rm->ltrm_depth > 0 );

                     rm->ltrm_waits--;
                     assert( rm->ltrm_waits >= 0 );
                     rm->ltrm_owner = owner;
              }
       } else {
              rm->ltrm_owner = owner;
       }

       rm->ltrm_depth++;

       ldap_pvt_thread_mutex_unlock( &rm->ltrm_mutex );

       return 0;
}

Here is the caller graph for this function:

Definition at line 148 of file rmutex.c.

{
       struct ldap_int_thread_rmutex_s *rm;

       assert( rmutex != NULL );
       rm = *rmutex;

       assert( rm != NULL );
       assert( rm->ltrm_valid == LDAP_PVT_THREAD_RMUTEX_VALID );

       if( rm->ltrm_valid != LDAP_PVT_THREAD_RMUTEX_VALID )
              return LDAP_PVT_THREAD_EINVAL;

       ldap_pvt_thread_mutex_lock( &rm->ltrm_mutex );

       assert( rm->ltrm_depth >= 0 );
       assert( rm->ltrm_waits >= 0 );

       if( rm->ltrm_depth > 0 ) {
              if ( !ldap_pvt_thread_equal( owner, rm->ltrm_owner )) {
                     ldap_pvt_thread_mutex_unlock( &rm->ltrm_mutex );
                     return LDAP_PVT_THREAD_EBUSY;
              }
       } else {
              rm->ltrm_owner = owner;
       }

       rm->ltrm_depth++;

       ldap_pvt_thread_mutex_unlock( &rm->ltrm_mutex );

       return 0;
}

Here is the caller graph for this function:

Definition at line 183 of file rmutex.c.

{
       struct ldap_int_thread_rmutex_s *rm;

       assert( rmutex != NULL );
       rm = *rmutex;

       assert( rm != NULL );
       assert( rm->ltrm_valid == LDAP_PVT_THREAD_RMUTEX_VALID );

       if( rm->ltrm_valid != LDAP_PVT_THREAD_RMUTEX_VALID )
              return LDAP_PVT_THREAD_EINVAL;

       ldap_pvt_thread_mutex_lock( &rm->ltrm_mutex );

       if( !ldap_pvt_thread_equal( owner, rm->ltrm_owner )) {
              ldap_pvt_thread_mutex_unlock( &rm->ltrm_mutex );
              return LDAP_PVT_THREAD_EINVAL;
       }

       rm->ltrm_depth--;
       if ( !rm->ltrm_depth )
              rm->ltrm_owner = tid_zero;

       assert( rm->ltrm_depth >= 0 );
       assert( rm->ltrm_waits >= 0 );

       if ( !rm->ltrm_depth && rm->ltrm_waits ) {
              ldap_pvt_thread_cond_signal( &rm->ltrm_cond );
       }

       ldap_pvt_thread_mutex_unlock( &rm->ltrm_mutex );

       return 0;
}

Here is the caller graph for this function:


Variable Documentation

Definition at line 44 of file rmutex.c.