mirror/openldap
2
0
Fork 0
mirror of https://git.openldap.org/openldap/openldap.git synced 2024-12-21 03:10:25 +08:00
Code Issues Packages Projects Releases Wiki Activity

ITS#8772 Remove the local rmutex implementation

Browse Source
This commit is contained in:
Ondřej Kuzník 2018-06-22 14:02:30 +01:00
parent a2d93d69f0
commit 0f44671c51
5 changed files with 2 additions and 252 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/ldap_int_thread.h
View File

@ -23,10 +23,6 @@ LDAP_F(int) ldap_int_thread_destroy LDAP_P(( void ));
LDAP_END_DECL
LDAP_BEGIN_DECL
typedef struct ldap_int_thread_rmutex_s * ldap_int_thread_rmutex_t;
LDAP_END_DECL
#ifndef _LDAP_INT_THREAD_H
#define _LDAP_INT_THREAD_H

19
include/ldap_pvt_thread.h
View File

@ -37,7 +37,6 @@ typedef ldap_int_thread_rdwr_t ldap_pvt_thread_rdwr_t;
#define LDAP_PVT_MUTEX_FIRSTCREATE LDAP_INT_MUTEX_FIRSTCREATE
#define LDAP_PVT_MUTEX_NULL LDAP_INT_MUTEX_NULL
#endif
typedef ldap_int_thread_rmutex_t ldap_pvt_thread_rmutex_t;
typedef ldap_int_thread_key_t ldap_pvt_thread_key_t;
#endif /* !LDAP_PVT_THREAD_H_DONE */
@ -126,24 +125,6 @@ ldap_pvt_thread_mutex_trylock LDAP_P(( ldap_pvt_thread_mutex_t *mutex ));
LDAP_F( int )
ldap_pvt_thread_mutex_unlock LDAP_P(( ldap_pvt_thread_mutex_t *mutex ));
LDAP_F( int )
ldap_pvt_thread_rmutex_init LDAP_P(( ldap_pvt_thread_rmutex_t *rmutex ));
LDAP_F( int )
ldap_pvt_thread_rmutex_destroy LDAP_P(( ldap_pvt_thread_rmutex_t *rmutex ));
LDAP_F( int )
ldap_pvt_thread_rmutex_lock LDAP_P(( ldap_pvt_thread_rmutex_t *rmutex,
ldap_pvt_thread_t owner));
LDAP_F( int )
ldap_pvt_thread_rmutex_trylock LDAP_P(( ldap_pvt_thread_rmutex_t *rmutex,
ldap_pvt_thread_t owner));
LDAP_F( int )
ldap_pvt_thread_rmutex_unlock LDAP_P(( ldap_pvt_thread_rmutex_t *rmutex,
ldap_pvt_thread_t owner));
LDAP_F( ldap_pvt_thread_t )
ldap_pvt_thread_self LDAP_P(( void ));

4
libraries/libldap_r/Makefile.in
View File

@ -31,10 +31,10 @@ XXSRCS = apitest.c test.c \
tls2.c tls_o.c tls_g.c tls_m.c \
turn.c ppolicy.c dds.c txn.c ldap_sync.c stctrl.c \
assertion.c deref.c ldifutil.c ldif.c fetch.c lbase64.c
SRCS = threads.c rdwr.c rmutex.c tpool.c rq.c \
SRCS = threads.c rdwr.c tpool.c rq.c \
thr_posix.c thr_thr.c thr_nt.c \
thr_pth.c thr_stub.c thr_debug.c
OBJS = threads.lo rdwr.lo rmutex.lo tpool.lo rq.lo \
OBJS = threads.lo rdwr.lo tpool.lo rq.lo \
thr_posix.lo thr_thr.lo thr_nt.lo \
thr_pth.lo thr_stub.lo thr_debug.lo \
bind.lo open.lo result.lo error.lo compare.lo search.lo \

219
libraries/libldap_r/rmutex.c
View File

@ -1,219 +0,0 @@
/* $OpenLDAP$ */
/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
*
* Copyright 2006-2018 The OpenLDAP Foundation.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted only as authorized by the OpenLDAP
* Public License.
*
* A copy of this license is available in file LICENSE in the
* top-level directory of the distribution or, alternatively, at
* <http://www.OpenLDAP.org/license.html>.
*/
/* This work was initially developed by Howard Chu for inclusion
* in OpenLDAP Software.
*/
/*
* This is an implementation of recursive mutexes.
*/
#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" /* Get the thread interface */
struct ldap_int_thread_rmutex_s {
ldap_pvt_thread_mutex_t ltrm_mutex;
ldap_pvt_thread_cond_t ltrm_cond;
ldap_pvt_thread_t ltrm_owner;
int ltrm_valid;
#define LDAP_PVT_THREAD_RMUTEX_VALID 0x0cdb
int ltrm_depth;
int ltrm_waits;
};
static const ldap_pvt_thread_t tid_zero;
int
ldap_pvt_thread_rmutex_init( ldap_pvt_thread_rmutex_t *rmutex )
{
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;
}
int
ldap_pvt_thread_rmutex_destroy( ldap_pvt_thread_rmutex_t *rmutex )
{
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;
}
int ldap_pvt_thread_rmutex_lock( ldap_pvt_thread_rmutex_t *rmutex,
ldap_pvt_thread_t owner )
{
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;
}
int ldap_pvt_thread_rmutex_trylock( ldap_pvt_thread_rmutex_t *rmutex,
ldap_pvt_thread_t owner )
{
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;
}
int ldap_pvt_thread_rmutex_unlock( ldap_pvt_thread_rmutex_t *rmutex,
ldap_pvt_thread_t owner )
{
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;
}

8
libraries/libldap_r/threads.c
View File

@ -38,7 +38,6 @@ int ldap_pvt_thread_initialize( void )
{
int rc;
static int init = 0;
ldap_pvt_thread_rmutex_t rm;
ldap_pvt_thread_t tid;
/* we only get one shot at this */
@ -53,14 +52,7 @@ int ldap_pvt_thread_initialize( void )
#endif
/* kludge to pull symbol definitions in */
ldap_pvt_thread_rmutex_init( &rm );
tid = ldap_pvt_thread_self();
ldap_pvt_thread_rmutex_lock( &rm, tid );
ldap_pvt_thread_rmutex_trylock( &rm, tid );
ldap_pvt_thread_rmutex_unlock( &rm, tid );
ldap_pvt_thread_rmutex_unlock( &rm, tid );
ldap_pvt_thread_rmutex_destroy( &rm );
return 0;
}