GeezerVison is showing github.com — sqlcipher/src/mutex.c at master · magic-coder/sqlcipher

Expand file tree

mutex.c

Copy path

More file actions

Latest commit

History

169 lines (152 loc) · 4.76 KB

mutex.c

Copy path

File metadata and controls

169 lines (152 loc) · 4.76 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

** 2007 August 14

** The author disclaims copyright to this source code. In place of

** a legal notice, here is a blessing:

** May you do good and not evil.

** May you find forgiveness for yourself and forgive others.

** May you share freely, never taking more than you give.

*************************************************************************

** This file contains the C functions that implement mutexes.

** This file contains code that is common across all mutex implementations.

#include "sqliteInt.h"

#if defined(SQLITE_DEBUG) && !defined(SQLITE_MUTEX_OMIT)

** For debugging purposes, record when the mutex subsystem is initialized

** and uninitialized so that we can assert() if there is an attempt to

** allocate a mutex while the system is uninitialized.

static SQLITE_WSD int mutexIsInit = 0;

#endif /* SQLITE_DEBUG && !defined(SQLITE_MUTEX_OMIT) */

#ifndef SQLITE_MUTEX_OMIT

** Initialize the mutex system.

int sqlite3MutexInit(void){

int rc = SQLITE_OK;

if( !sqlite3GlobalConfig.mutex.xMutexAlloc ){

/* If the xMutexAlloc method has not been set, then the user did not

** install a mutex implementation via sqlite3_config() prior to

** sqlite3_initialize() being called. This block copies pointers to

** the default implementation into the sqlite3GlobalConfig structure.

sqlite3_mutex_methods const *pFrom;

sqlite3_mutex_methods *pTo = &sqlite3GlobalConfig.mutex;

if( sqlite3GlobalConfig.bCoreMutex ){

pFrom = sqlite3DefaultMutex();

}else{

pFrom = sqlite3NoopMutex();

}

pTo->xMutexInit = pFrom->xMutexInit;

pTo->xMutexEnd = pFrom->xMutexEnd;

pTo->xMutexFree = pFrom->xMutexFree;

pTo->xMutexEnter = pFrom->xMutexEnter;

pTo->xMutexTry = pFrom->xMutexTry;

pTo->xMutexLeave = pFrom->xMutexLeave;

pTo->xMutexHeld = pFrom->xMutexHeld;

pTo->xMutexNotheld = pFrom->xMutexNotheld;

sqlite3MemoryBarrier();

pTo->xMutexAlloc = pFrom->xMutexAlloc;

}

assert( sqlite3GlobalConfig.mutex.xMutexInit );

rc = sqlite3GlobalConfig.mutex.xMutexInit();

#ifdef SQLITE_DEBUG

GLOBAL(int, mutexIsInit) = 1;

#endif

return rc;

}

** Shutdown the mutex system. This call frees resources allocated by

** sqlite3MutexInit().

int sqlite3MutexEnd(void){

int rc = SQLITE_OK;

if( sqlite3GlobalConfig.mutex.xMutexEnd ){

rc = sqlite3GlobalConfig.mutex.xMutexEnd();

}

#ifdef SQLITE_DEBUG

GLOBAL(int, mutexIsInit) = 0;

#endif

return rc;

}

** Retrieve a pointer to a static mutex or allocate a new dynamic one.

sqlite3_mutex *sqlite3_mutex_alloc(int id){

#ifndef SQLITE_OMIT_AUTOINIT

if( id<=SQLITE_MUTEX_RECURSIVE && sqlite3_initialize() ) return 0;

if( id>SQLITE_MUTEX_RECURSIVE && sqlite3MutexInit() ) return 0;

#endif

assert( sqlite3GlobalConfig.mutex.xMutexAlloc );

return sqlite3GlobalConfig.mutex.xMutexAlloc(id);

}

sqlite3_mutex *sqlite3MutexAlloc(int id){

if( !sqlite3GlobalConfig.bCoreMutex ){

return 0;

}

assert( GLOBAL(int, mutexIsInit) );

assert( sqlite3GlobalConfig.mutex.xMutexAlloc );

return sqlite3GlobalConfig.mutex.xMutexAlloc(id);

}

** Free a dynamic mutex.

void sqlite3_mutex_free(sqlite3_mutex *p){

if( p ){

assert( sqlite3GlobalConfig.mutex.xMutexFree );

sqlite3GlobalConfig.mutex.xMutexFree(p);

}

** Obtain the mutex p. If some other thread already has the mutex, block

** until it can be obtained.

void sqlite3_mutex_enter(sqlite3_mutex *p){

if( p ){

assert( sqlite3GlobalConfig.mutex.xMutexEnter );

sqlite3GlobalConfig.mutex.xMutexEnter(p);

}

** Obtain the mutex p. If successful, return SQLITE_OK. Otherwise, if another

** thread holds the mutex and it cannot be obtained, return SQLITE_BUSY.

int sqlite3_mutex_try(sqlite3_mutex *p){

int rc = SQLITE_OK;

if( p ){

assert( sqlite3GlobalConfig.mutex.xMutexTry );

return sqlite3GlobalConfig.mutex.xMutexTry(p);

}

return rc;

}

** The sqlite3_mutex_leave() routine exits a mutex that was previously

** entered by the same thread. The behavior is undefined if the mutex

** is not currently entered. If a NULL pointer is passed as an argument

** this function is a no-op.

void sqlite3_mutex_leave(sqlite3_mutex *p){

if( p ){

assert( sqlite3GlobalConfig.mutex.xMutexLeave );

sqlite3GlobalConfig.mutex.xMutexLeave(p);

}

#ifndef NDEBUG

** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routine are

** intended for use inside assert() statements.

int sqlite3_mutex_held(sqlite3_mutex *p){

assert( p==0 || sqlite3GlobalConfig.mutex.xMutexHeld );

return p==0 || sqlite3GlobalConfig.mutex.xMutexHeld(p);

}

int sqlite3_mutex_notheld(sqlite3_mutex *p){

assert( p==0 || sqlite3GlobalConfig.mutex.xMutexNotheld );

return p==0 || sqlite3GlobalConfig.mutex.xMutexNotheld(p);

}

#endif

#endif /* !defined(SQLITE_MUTEX_OMIT) */