/* $NetBSD: rmutex.c,v 1.1.1.6.6.1 2019/08/10 06:17:15 martin Exp $ */ /* $OpenLDAP$ */ /* This work is part of OpenLDAP Software . * * Copyright 2006-2019 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 * . */ /* This work was initially developed by Howard Chu for inclusion * in OpenLDAP Software. */ /* * This is an implementation of recursive mutexes. */ #include __RCSID("$NetBSD: rmutex.c,v 1.1.1.6.6.1 2019/08/10 06:17:15 martin Exp $"); #include "portable.h" #include #include #include #include #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; }