From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from localhost (localhost [127.0.0.1]) by turing.freelists.org (Avenir Technologies Mail Multiplex) with ESMTP id 62A392B8B7 for ; Mon, 26 Mar 2018 11:57:16 -0400 (EDT) Received: from turing.freelists.org ([127.0.0.1]) by localhost (turing.freelists.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id bDYCZWz4vqRb for ; Mon, 26 Mar 2018 11:57:16 -0400 (EDT) Received: from smtp48.i.mail.ru (smtp48.i.mail.ru [94.100.177.108]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by turing.freelists.org (Avenir Technologies Mail Multiplex) with ESMTPS id B5FDA2B6FE for ; Mon, 26 Mar 2018 11:57:15 -0400 (EDT) From: Kirill Yukhin Subject: [tarantool-patches] [PATCH 2/4] sql: remove mutexes around the code Date: Mon, 26 Mar 2018 18:56:56 +0300 Message-Id: In-Reply-To: References: In-Reply-To: References: Sender: tarantool-patches-bounce@freelists.org Errors-to: tarantool-patches-bounce@freelists.org Reply-To: tarantool-patches@freelists.org List-help: List-unsubscribe: List-software: Ecartis version 1.0.0 List-Id: tarantool-patches List-subscribe: List-owner: List-post: List-archive: To: v.shpilevoy@tarantool.org Cc: tarantool-patches@freelists.org, Kirill Yukhin This is first part, which will be likely squashed with following. Tests pass. --- src/box/sql/CMakeLists.txt | 4 - src/box/sql/date.c | 7 -- src/box/sql/func.c | 2 - src/box/sql/global.c | 6 -- src/box/sql/legacy.c | 2 - src/box/sql/main.c | 200 ++------------------------------------------- src/box/sql/malloc.c | 53 ++---------- src/box/sql/os.c | 21 ----- src/box/sql/os_unix.c | 143 ++------------------------------ src/box/sql/prepare.c | 8 -- src/box/sql/printf.c | 6 -- src/box/sql/random.c | 11 --- src/box/sql/sqliteInt.h | 71 +--------------- src/box/sql/status.c | 9 +- src/box/sql/tokenize.c | 2 - src/box/sql/vdbe.c | 5 +- src/box/sql/vdbeapi.c | 54 ------------ src/box/sql/vdbeaux.c | 2 - src/box/sql/vdbemem.c | 17 ---- src/box/sql/vdbesort.c | 6 +- 20 files changed, 27 insertions(+), 602 deletions(-) diff --git a/src/box/sql/CMakeLists.txt b/src/box/sql/CMakeLists.txt index 238e185..8494e15 100644 --- a/src/box/sql/CMakeLists.txt +++ b/src/box/sql/CMakeLists.txt @@ -14,7 +14,6 @@ set(SRCDIR ${CMAKE_CURRENT_SOURCE_DIR}) include_directories(${SRCDIR}) add_definitions(-DSQLITE_MAX_WORKER_THREADS=0) -add_definitions(-DTHREADSAFE=0) add_definitions(-DSQLITE_DEFAULT_FOREIGN_KEYS=1) add_definitions(-DSQLITE_OMIT_AUTOMATIC_INDEX) @@ -54,9 +53,6 @@ add_library(sql STATIC mem2.c mem3.c mem5.c - mutex.c - mutex_noop.c - mutex_unix.c os.c os_unix.c pragma.c diff --git a/src/box/sql/date.c b/src/box/sql/date.c index 21df6df..9566cc3 100644 --- a/src/box/sql/date.c +++ b/src/box/sql/date.c @@ -545,10 +545,6 @@ osLocaltime(time_t * t, struct tm *pTm) int rc; #if !HAVE_LOCALTIME_R && !HAVE_LOCALTIME_S struct tm *pX; -#if SQLITE_THREADSAFE>0 - sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER); -#endif - sqlite3_mutex_enter(mutex); pX = localtime(t); #ifndef SQLITE_UNTESTABLE if (sqlite3GlobalConfig.bLocaltimeFault) @@ -556,7 +552,6 @@ osLocaltime(time_t * t, struct tm *pTm) #endif if (pX) *pTm = *pX; - sqlite3_mutex_leave(mutex); rc = pX == 0; #else #ifndef SQLITE_UNTESTABLE @@ -1290,11 +1285,9 @@ currentTimeFunc(sqlite3_context * context, int argc, sqlite3_value ** argv) #if HAVE_GMTIME_R pTm = gmtime_r(&t, &sNow); #else - sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER)); pTm = gmtime(&t); if (pTm) memcpy(&sNow, pTm, sizeof(sNow)); - sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER)); #endif if (pTm) { strftime(zBuf, 20, zFormat, &sNow); diff --git a/src/box/sql/func.c b/src/box/sql/func.c index d8d39a2..47b45de 100644 --- a/src/box/sql/func.c +++ b/src/box/sql/func.c @@ -1712,12 +1712,10 @@ sqlite3_overload_function(sqlite3 * db, const char *zName, int nArg) return SQLITE_MISUSE_BKPT; } #endif - sqlite3_mutex_enter(db->mutex); if (sqlite3FindFunction(db, zName, nArg, 0) == 0) { rc = sqlite3CreateFunc(db, zName, nArg, 0, 0, sqlite3InvalidFunction, 0, 0, 0); } rc = sqlite3ApiExit(db, rc); - sqlite3_mutex_leave(db->mutex); return rc; } diff --git a/src/box/sql/global.c b/src/box/sql/global.c index 97bdbe6..6a78550 100644 --- a/src/box/sql/global.c +++ b/src/box/sql/global.c @@ -195,8 +195,6 @@ const unsigned char sqlite3CtypeMap[256] = { */ SQLITE_WSD struct Sqlite3Config sqlite3Config = { SQLITE_DEFAULT_MEMSTATUS, /* bMemstat */ - 1, /* bCoreMutex */ - SQLITE_THREADSAFE == 1, /* bFullMutex */ SQLITE_USE_URI, /* bOpenUri */ SQLITE_ALLOW_COVERING_INDEX_SCAN, /* bUseCis */ 0x7ffffffe, /* mxStrlen */ @@ -205,7 +203,6 @@ SQLITE_WSD struct Sqlite3Config sqlite3Config = { 125, /* nLookaside */ 0, /* nStmtSpill */ {0, 0, 0, 0, 0, 0, 0, 0}, /* m */ - {0, 0, 0, 0, 0, 0, 0, 0, 0}, /* mutex */ {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, /* pcache2 */ (void *)0, /* pHeap */ 0, /* nHeap */ @@ -224,10 +221,7 @@ SQLITE_WSD struct Sqlite3Config sqlite3Config = { /* All the rest should always be initialized to zero */ 0, /* isInit */ 0, /* inProgress */ - 0, /* isMutexInit */ 0, /* isMallocInit */ - 0, /* nRefInitMutex */ - 0, /* pInitMutex */ 0, /* xLog */ 0, /* pLogArg */ #ifdef SQLITE_ENABLE_SQLLOG diff --git a/src/box/sql/legacy.c b/src/box/sql/legacy.c index e757095..978cf01 100644 --- a/src/box/sql/legacy.c +++ b/src/box/sql/legacy.c @@ -69,7 +69,6 @@ sqlite3_exec(sqlite3 * db, /* The database on which the SQL executes */ if (zSql == 0) zSql = ""; - sqlite3_mutex_enter(db->mutex); sqlite3Error(db, SQLITE_OK); while (rc == SQLITE_OK && zSql[0]) { int nCol; @@ -184,6 +183,5 @@ sqlite3_exec(sqlite3 * db, /* The database on which the SQL executes */ } assert((rc & db->errMask) == rc); - sqlite3_mutex_leave(db->mutex); return rc; } diff --git a/src/box/sql/main.c b/src/box/sql/main.c index f0333fa..1f8c026 100644 --- a/src/box/sql/main.c +++ b/src/box/sql/main.c @@ -90,16 +90,6 @@ sqlite3_libversion_number(void) return SQLITE_VERSION_NUMBER; } -/* IMPLEMENTATION-OF: R-20790-14025 The sqlite3_threadsafe() function returns - * zero if and only if SQLite was compiled with mutexing code omitted due to - * the SQLITE_THREADSAFE compile-time option being set to 0. - */ -int -sqlite3_threadsafe(void) -{ - return SQLITE_THREADSAFE; -} - #if !defined(SQLITE_OMIT_TRACE) && defined(SQLITE_ENABLE_IOTRACE) /* * If the following function pointer is not NULL and if @@ -132,7 +122,7 @@ char *sqlite3_data_directory = 0; * Initialize SQLite. * * This routine must be called to initialize the memory allocation, - * VFS, and mutex subsystems prior to doing any serious work with + * and VFS subsystems prior to doing any serious work with * SQLite. But as long as you do not compile with SQLITE_OMIT_AUTOINIT * this routine will be called automatically by key routines such as * sqlite3_open(). @@ -162,9 +152,7 @@ char *sqlite3_data_directory = 0; int sqlite3_initialize(void) { - MUTEX_LOGIC(sqlite3_mutex * pMaster; - ) /* The main static mutex */ - int rc; /* Result code */ + int rc = SQLITE_OK; #ifdef SQLITE_EXTRA_INIT int bRunExtraInit = 0; /* Extra initialization needed */ #endif @@ -190,56 +178,18 @@ sqlite3_initialize(void) if (sqlite3GlobalConfig.isInit) return SQLITE_OK; - /* Make sure the mutex subsystem is initialized. If unable to - * initialize the mutex subsystem, return early with the error. - * If the system is so sick that we are unable to allocate a mutex, - * there is not much SQLite is going to be able to do. - * - * The mutex subsystem must take care of serializing its own - * initialization. - */ - rc = sqlite3MutexInit(); - if (rc) - return rc; - - /* Initialize the malloc() system and the recursive pInitMutex mutex. - * This operation is protected by the STATIC_MASTER mutex. Note that - * MutexAlloc() is called for a static mutex prior to initializing the - * malloc subsystem - this implies that the allocation of a static - * mutex must not require support from the malloc subsystem. - */ - MUTEX_LOGIC(pMaster = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER); - ) - sqlite3_mutex_enter(pMaster); - sqlite3GlobalConfig.isMutexInit = 1; - if (!sqlite3GlobalConfig.isMallocInit) { + if (!sqlite3GlobalConfig.isMallocInit) rc = sqlite3MallocInit(); - } - if (rc == SQLITE_OK) { + if (rc == SQLITE_OK) sqlite3GlobalConfig.isMallocInit = 1; - if (!sqlite3GlobalConfig.pInitMutex) { - sqlite3GlobalConfig.pInitMutex = - sqlite3MutexAlloc(SQLITE_MUTEX_RECURSIVE); - if (sqlite3GlobalConfig.bCoreMutex - && !sqlite3GlobalConfig.pInitMutex) { - rc = SQLITE_NOMEM_BKPT; - } - } - } - if (rc == SQLITE_OK) { - sqlite3GlobalConfig.nRefInitMutex++; - } - sqlite3_mutex_leave(pMaster); - /* If rc is not SQLITE_OK at this point, then either the malloc - * subsystem could not be initialized or the system failed to allocate - * the pInitMutex mutex. Return an error in either case. + /* If rc is not SQLITE_OK at this point, then the malloc + * subsystem could not be initialized. */ - if (rc != SQLITE_OK) { + if (rc != SQLITE_OK) return rc; - } - /* Do the rest of the initialization under the recursive mutex so + /* Do the rest of the initialization * that we will be able to handle recursive calls into * sqlite3_initialize(). The recursive calls normally come through * sqlite3_os_init() when it invokes sqlite3_vfs_register(), but other @@ -248,11 +198,9 @@ sqlite3_initialize(void) * IMPLEMENTATION-OF: R-00140-37445 SQLite automatically serializes calls * to the xInit method, so the xInit method need not be threadsafe. * - * The following mutex is what serializes access to the appdef pcache xInit - * methods. The sqlite3_pcache_methods.xInit() all is embedded in the + * The sqlite3_pcache_methods.xInit() all is embedded in the * call to sqlite3PcacheInitialize(). */ - sqlite3_mutex_enter(sqlite3GlobalConfig.pInitMutex); if (sqlite3GlobalConfig.isInit == 0 && sqlite3GlobalConfig.inProgress == 0) { sqlite3GlobalConfig.inProgress = 1; @@ -276,19 +224,6 @@ sqlite3_initialize(void) } sqlite3GlobalConfig.inProgress = 0; } - sqlite3_mutex_leave(sqlite3GlobalConfig.pInitMutex); - - /* Go back under the static mutex and clean up the recursive - * mutex to prevent a resource leak. - */ - sqlite3_mutex_enter(pMaster); - sqlite3GlobalConfig.nRefInitMutex--; - if (sqlite3GlobalConfig.nRefInitMutex <= 0) { - assert(sqlite3GlobalConfig.nRefInitMutex == 0); - sqlite3_mutex_free(sqlite3GlobalConfig.pInitMutex); - sqlite3GlobalConfig.pInitMutex = 0; - } - sqlite3_mutex_leave(pMaster); /* The following is just a sanity check to make sure SQLite has * been compiled correctly. It is important to run this code, but @@ -364,10 +299,6 @@ sqlite3_shutdown(void) sqlite3_temp_directory = 0; #endif } - if (sqlite3GlobalConfig.isMutexInit) { - sqlite3MutexEnd(); - sqlite3GlobalConfig.isMutexInit = 0; - } return SQLITE_OK; } @@ -395,57 +326,6 @@ sqlite3_config(int op, ...) va_start(ap, op); switch (op) { - - /* Mutex configuration options are only available in a threadsafe - * compile. - */ -#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-54466-46756 */ - case SQLITE_CONFIG_SINGLETHREAD:{ - /* EVIDENCE-OF: R-02748-19096 This option sets the threading mode to - * Single-thread. - */ - sqlite3GlobalConfig.bCoreMutex = 0; /* Disable mutex on core */ - sqlite3GlobalConfig.bFullMutex = 0; /* Disable mutex on connections */ - break; - } -#endif -#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-20520-54086 */ - case SQLITE_CONFIG_MULTITHREAD:{ - /* EVIDENCE-OF: R-14374-42468 This option sets the threading mode to - * Multi-thread. - */ - sqlite3GlobalConfig.bCoreMutex = 1; /* Enable mutex on core */ - sqlite3GlobalConfig.bFullMutex = 0; /* Disable mutex on connections */ - break; - } -#endif -#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-59593-21810 */ - case SQLITE_CONFIG_SERIALIZED:{ - /* EVIDENCE-OF: R-41220-51800 This option sets the threading mode to - * Serialized. - */ - sqlite3GlobalConfig.bCoreMutex = 1; /* Enable mutex on core */ - sqlite3GlobalConfig.bFullMutex = 1; /* Enable mutex on connections */ - break; - } -#endif -#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-63666-48755 */ - case SQLITE_CONFIG_MUTEX:{ - /* Specify an alternative mutex implementation */ - sqlite3GlobalConfig.mutex = - *va_arg(ap, sqlite3_mutex_methods *); - break; - } -#endif -#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-14450-37597 */ - case SQLITE_CONFIG_GETMUTEX:{ - /* Retrieve the current mutex implementation */ - *va_arg(ap, sqlite3_mutex_methods *) = - sqlite3GlobalConfig.mutex; - break; - } -#endif - case SQLITE_CONFIG_MALLOC:{ /* EVIDENCE-OF: R-55594-21030 The SQLITE_CONFIG_MALLOC option takes a * single argument which is a pointer to an instance of the @@ -709,21 +589,6 @@ setupLookaside(sqlite3 * db, void *pBuf, int sz, int cnt) } /* - * Return the mutex associated with a database connection. - */ -sqlite3_mutex * -sqlite3_db_mutex(sqlite3 * db) -{ -#ifdef SQLITE_ENABLE_API_ARMOR - if (!sqlite3SafetyCheckOk(db)) { - (void)SQLITE_MISUSE_BKPT; - return 0; - } -#endif - return db->mutex; -} - -/* * Free up as much memory as we can from the given database * connection. */ @@ -889,7 +754,6 @@ functionDestroy(sqlite3 * db, FuncDef * p) static int connectionIsBusy(sqlite3 * db) { - assert(sqlite3_mutex_held(db->mutex)); if (db->pVdbe) return 1; return 0; @@ -910,7 +774,6 @@ sqlite3Close(sqlite3 * db, int forceZombie) if (!sqlite3SafetyCheckSickOrOk(db)) { return SQLITE_MISUSE_BKPT; } - sqlite3_mutex_enter(db->mutex); if (db->mTrace & SQLITE_TRACE_CLOSE) { db->xTrace(SQLITE_TRACE_CLOSE, db->pTraceArg, db, 0); } @@ -922,7 +785,6 @@ sqlite3Close(sqlite3 * db, int forceZombie) sqlite3ErrorWithMsg(db, SQLITE_BUSY, "unable to close due to unfinalized " "statements"); - sqlite3_mutex_leave(db->mutex); return SQLITE_BUSY; } #ifdef SQLITE_ENABLE_SQLLOG @@ -975,7 +837,6 @@ sqlite3RollbackAll(Vdbe * pVdbe, int tripCode) int inTrans = 0; (void)tripCode; struct session *user_session = current_session(); - assert(sqlite3_mutex_held(db->mutex)); /* DDL is impossible inside a transaction. */ assert((user_session->sql_flags & SQLITE_InternChanges) == 0 @@ -1364,12 +1225,10 @@ sqlite3_busy_handler(sqlite3 * db, int (*xBusy) (void *, int), void *pArg) if (!sqlite3SafetyCheckOk(db)) return SQLITE_MISUSE_BKPT; #endif - sqlite3_mutex_enter(db->mutex); db->busyHandler.xFunc = xBusy; db->busyHandler.pArg = pArg; db->busyHandler.nBusy = 0; db->busyTimeout = 0; - sqlite3_mutex_leave(db->mutex); return SQLITE_OK; } @@ -1389,7 +1248,6 @@ sqlite3_progress_handler(sqlite3 * db, return; } #endif - sqlite3_mutex_enter(db->mutex); if (nOps > 0) { db->xProgress = xProgress; db->nProgressOps = (unsigned)nOps; @@ -1399,7 +1257,6 @@ sqlite3_progress_handler(sqlite3 * db, db->nProgressOps = 0; db->pProgressArg = 0; } - sqlite3_mutex_leave(db->mutex); } #endif @@ -1459,7 +1316,6 @@ sqlite3CreateFunc(sqlite3 * db, FuncDef *p; int extraFlags; - assert(sqlite3_mutex_held(db->mutex)); if (zFunctionName == 0 || (xSFunc && (xFinal || xStep)) || (!xSFunc && (xFinal && !xStep)) || @@ -1554,7 +1410,6 @@ sqlite3_create_function_v2(sqlite3 * db, return SQLITE_MISUSE_BKPT; } #endif - sqlite3_mutex_enter(db->mutex); if (xDestroy) { pArg = (FuncDestructor *) sqlite3DbMallocZero(db, @@ -1577,7 +1432,6 @@ sqlite3_create_function_v2(sqlite3 * db, out: rc = sqlite3ApiExit(db, rc); - sqlite3_mutex_leave(db->mutex); return rc; } @@ -1595,7 +1449,6 @@ sqlite3_trace_v2(sqlite3 * db, /* Trace this connection */ return SQLITE_MISUSE_BKPT; } #endif - sqlite3_mutex_enter(db->mutex); if (mTrace == 0) xTrace = 0; if (xTrace == 0) @@ -1603,7 +1456,6 @@ sqlite3_trace_v2(sqlite3 * db, /* Trace this connection */ db->mTrace = mTrace; db->xTrace = xTrace; db->pTraceArg = pArg; - sqlite3_mutex_leave(db->mutex); return SQLITE_OK; } @@ -1627,11 +1479,9 @@ sqlite3_commit_hook(sqlite3 * db, /* Attach the hook to this database */ return 0; } #endif - sqlite3_mutex_enter(db->mutex); pOld = db->pCommitArg; db->xCommitCallback = xCallback; db->pCommitArg = pArg; - sqlite3_mutex_leave(db->mutex); return pOld; } @@ -1653,11 +1503,9 @@ sqlite3_update_hook(sqlite3 * db, /* Attach the hook to this database */ return 0; } #endif - sqlite3_mutex_enter(db->mutex); pRet = db->pUpdateArg; db->xUpdateCallback = xCallback; db->pUpdateArg = pArg; - sqlite3_mutex_leave(db->mutex); return pRet; } @@ -1678,11 +1526,9 @@ sqlite3_rollback_hook(sqlite3 * db, /* Attach the hook to this database */ return 0; } #endif - sqlite3_mutex_enter(db->mutex); pRet = db->pRollbackArg; db->xRollbackCallback = xCallback; db->pRollbackArg = pArg; - sqlite3_mutex_leave(db->mutex); return pRet; } @@ -1699,11 +1545,9 @@ sqlite3_preupdate_hook(sqlite3 * db, /* Attach the hook to this database */ void *pArg) /* First callback argument */ { void *pRet; - sqlite3_mutex_enter(db->mutex); pRet = db->pPreUpdateArg; db->xPreUpdateCallback = xCallback; db->pPreUpdateArg = pArg; - sqlite3_mutex_leave(db->mutex); return pRet; } #endif /* SQLITE_ENABLE_PREUPDATE_HOOK */ @@ -1779,7 +1623,6 @@ sqlite3_errmsg(sqlite3 * db) if (!sqlite3SafetyCheckSickOrOk(db)) { return sqlite3ErrStr(SQLITE_MISUSE_BKPT); } - sqlite3_mutex_enter(db->mutex); if (db->mallocFailed) { z = sqlite3ErrStr(SQLITE_NOMEM_BKPT); } else { @@ -1790,7 +1633,6 @@ sqlite3_errmsg(sqlite3 * db) z = sqlite3ErrStr(db->errCode); } } - sqlite3_mutex_leave(db->mutex); return z; } @@ -2256,7 +2098,6 @@ sql_init_db(sqlite3 **out_db) { sqlite3 *db; int rc; /* Return code */ - int isThreadsafe; /* True for threadsafe connections */ #ifdef SQLITE_ENABLE_API_ARMOR if (ppDb == 0) @@ -2268,24 +2109,10 @@ sql_init_db(sqlite3 **out_db) return rc; #endif - if (sqlite3GlobalConfig.bCoreMutex == 0) { - isThreadsafe = 0; - } else { - isThreadsafe = sqlite3GlobalConfig.bFullMutex; - } /* Allocate the sqlite data structure */ db = sqlite3MallocZero(sizeof(sqlite3)); if (db == 0) goto opendb_out; - if (isThreadsafe) { - db->mutex = sqlite3MutexAlloc(SQLITE_MUTEX_RECURSIVE); - if (db->mutex == 0) { - sqlite3_free(db); - db = 0; - goto opendb_out; - } - } - sqlite3_mutex_enter(db->mutex); db->errMask = 0xff; db->magic = SQLITE_MAGIC_BUSY; @@ -2382,11 +2209,6 @@ sql_init_db(sqlite3 **out_db) sqlite3CommitInternalChanges(); } opendb_out: - if (db) { - assert(db->mutex != 0 || isThreadsafe == 0 - || sqlite3GlobalConfig.bFullMutex == 0); - sqlite3_mutex_leave(db->mutex); - } rc = sqlite3_errcode(db); assert(db != 0 || rc == SQLITE_NOMEM); if (rc == SQLITE_NOMEM) { @@ -2492,9 +2314,7 @@ sqlite3_extended_result_codes(sqlite3 * db, int onoff) if (!sqlite3SafetyCheckOk(db)) return SQLITE_MISUSE_BKPT; #endif - sqlite3_mutex_enter(db->mutex); db->errMask = onoff ? 0xffffffff : 0xff; - sqlite3_mutex_leave(db->mutex); return SQLITE_OK; } @@ -2805,14 +2625,12 @@ sqlite3_test_control(int op, ...) */ case SQLITE_TESTCTRL_IMPOSTER:{ sqlite3 *db = va_arg(ap, sqlite3 *); - sqlite3_mutex_enter(db->mutex); db->init.busy = db->init.imposterTable = va_arg(ap, int); db->init.newTnum = va_arg(ap, int); if (db->init.busy == 0 && db->init.newTnum > 0) { sqlite3ResetAllSchemasOfConnection(db); } - sqlite3_mutex_leave(db->mutex); break; } } diff --git a/src/box/sql/malloc.c b/src/box/sql/malloc.c index 325faf5..0a8107a 100644 --- a/src/box/sql/malloc.c +++ b/src/box/sql/malloc.c @@ -68,7 +68,6 @@ typedef struct ScratchFreeslot { * State information local to the memory allocation subsystem. */ static SQLITE_WSD struct Mem0Global { - sqlite3_mutex *mutex; /* Mutex to serialize access */ sqlite3_int64 alarmThreshold; /* The soft heap limit */ /* @@ -87,18 +86,10 @@ static SQLITE_WSD struct Mem0Global { */ int nearlyFull; } mem0 = { -0, 0, 0, 0, 0, 0}; +0, 0, 0, 0, 0}; #define mem0 GLOBAL(struct Mem0Global, mem0) -/* - * Return the memory allocator mutex. sqlite3_status() needs it. - */ -sqlite3_mutex * -sqlite3MallocMutex(void) -{ - return mem0.mutex; -} /* * Set the soft heap-size limit for the library. Passing a zero or @@ -115,16 +106,13 @@ sqlite3_soft_heap_limit64(sqlite3_int64 n) if (rc) return -1; #endif - sqlite3_mutex_enter(mem0.mutex); priorLimit = mem0.alarmThreshold; if (n < 0) { - sqlite3_mutex_leave(mem0.mutex); return priorLimit; } mem0.alarmThreshold = n; nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED); mem0.nearlyFull = (n > 0 && n <= nUsed); - sqlite3_mutex_leave(mem0.mutex); excess = sqlite3_memory_used() - n; if (excess > 0) sqlite3_release_memory((int)(excess & 0x7fffffff)); @@ -150,7 +138,6 @@ sqlite3MallocInit(void) sqlite3MemSetDefault(); } memset(&mem0, 0, sizeof(mem0)); - mem0.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM); if (sqlite3GlobalConfig.pScratch && sqlite3GlobalConfig.szScratch >= 100 && sqlite3GlobalConfig.nScratch > 0) { int i, n, sz; @@ -239,9 +226,7 @@ sqlite3MallocAlarm(int nByte) { if (mem0.alarmThreshold <= 0) return; - sqlite3_mutex_leave(mem0.mutex); sqlite3_release_memory(nByte); - sqlite3_mutex_enter(mem0.mutex); } /* @@ -253,7 +238,6 @@ mallocWithAlarm(int n, void **pp) { int nFull; void *p; - assert(sqlite3_mutex_held(mem0.mutex)); nFull = sqlite3GlobalConfig.m.xRoundup(n); sqlite3StatusHighwater(SQLITE_STATUS_MALLOC_SIZE, n); if (mem0.alarmThreshold > 0) { @@ -299,9 +283,7 @@ sqlite3Malloc(u64 n) */ p = 0; } else if (sqlite3GlobalConfig.bMemstat) { - sqlite3_mutex_enter(mem0.mutex); mallocWithAlarm((int)n, &p); - sqlite3_mutex_leave(mem0.mutex); } else { p = sqlite3GlobalConfig.m.xMalloc((int)n); } @@ -340,7 +322,7 @@ sqlite3_malloc64(sqlite3_uint64 n) * case by setting scratchAllocOut to 1 when an allocation * is outstanding clearing it when the allocation is freed. */ -#if SQLITE_THREADSAFE==0 && !defined(NDEBUG) +#if !defined(NDEBUG) static int scratchAllocOut = 0; #endif @@ -358,28 +340,22 @@ sqlite3ScratchMalloc(int n) void *p; assert(n > 0); - sqlite3_mutex_enter(mem0.mutex); sqlite3StatusHighwater(SQLITE_STATUS_SCRATCH_SIZE, n); if (mem0.nScratchFree && sqlite3GlobalConfig.szScratch >= n) { p = mem0.pScratchFree; mem0.pScratchFree = mem0.pScratchFree->pNext; mem0.nScratchFree--; sqlite3StatusUp(SQLITE_STATUS_SCRATCH_USED, 1); - sqlite3_mutex_leave(mem0.mutex); } else { - sqlite3_mutex_leave(mem0.mutex); p = sqlite3Malloc(n); if (sqlite3GlobalConfig.bMemstat && p) { - sqlite3_mutex_enter(mem0.mutex); sqlite3StatusUp(SQLITE_STATUS_SCRATCH_OVERFLOW, sqlite3MallocSize(p)); - sqlite3_mutex_leave(mem0.mutex); } sqlite3MemdebugSetType(p, MEMTYPE_SCRATCH); } - assert(sqlite3_mutex_notheld(mem0.mutex)); -#if SQLITE_THREADSAFE==0 && !defined(NDEBUG) +#if !defined(NDEBUG) /* EVIDENCE-OF: R-12970-05880 SQLite will not use more than one scratch * buffers per thread. * @@ -398,7 +374,7 @@ sqlite3ScratchFree(void *p) { if (p) { -#if SQLITE_THREADSAFE==0 && !defined(NDEBUG) +#if !defined(NDEBUG) /* Verify that no more than two scratch allocation per thread * is outstanding at one time. (This is only checked in the * single-threaded case since checking in the multi-threaded case @@ -413,14 +389,12 @@ sqlite3ScratchFree(void *p) /* Release memory from the SQLITE_CONFIG_SCRATCH allocation */ ScratchFreeslot *pSlot; pSlot = (ScratchFreeslot *) p; - sqlite3_mutex_enter(mem0.mutex); pSlot->pNext = mem0.pScratchFree; mem0.pScratchFree = pSlot; mem0.nScratchFree++; assert(mem0.nScratchFree <= (u32) sqlite3GlobalConfig.nScratch); sqlite3StatusDown(SQLITE_STATUS_SCRATCH_USED, 1); - sqlite3_mutex_leave(mem0.mutex); } else { /* Release memory back to the heap */ assert(sqlite3MemdebugHasType(p, MEMTYPE_SCRATCH)); @@ -429,7 +403,6 @@ sqlite3ScratchFree(void *p) sqlite3MemdebugSetType(p, MEMTYPE_HEAP); if (sqlite3GlobalConfig.bMemstat) { int iSize = sqlite3MallocSize(p); - sqlite3_mutex_enter(mem0.mutex); sqlite3StatusDown (SQLITE_STATUS_SCRATCH_OVERFLOW, iSize); sqlite3StatusDown(SQLITE_STATUS_MEMORY_USED, @@ -437,7 +410,6 @@ sqlite3ScratchFree(void *p) sqlite3StatusDown(SQLITE_STATUS_MALLOC_COUNT, 1); sqlite3GlobalConfig.m.xFree(p); - sqlite3_mutex_leave(mem0.mutex); } else { sqlite3GlobalConfig.m.xFree(p); } @@ -486,10 +458,8 @@ sqlite3DbMallocSize(sqlite3 * db, void *p) } #endif return sqlite3GlobalConfig.m.xSize(p); - } else { - assert(sqlite3_mutex_held(db->mutex)); + } else return db->lookaside.sz; - } } sqlite3_uint64 @@ -511,12 +481,10 @@ sqlite3_free(void *p) assert(sqlite3MemdebugHasType(p, MEMTYPE_HEAP)); assert(sqlite3MemdebugNoType(p, (u8) ~ MEMTYPE_HEAP)); if (sqlite3GlobalConfig.bMemstat) { - sqlite3_mutex_enter(mem0.mutex); sqlite3StatusDown(SQLITE_STATUS_MEMORY_USED, sqlite3MallocSize(p)); sqlite3StatusDown(SQLITE_STATUS_MALLOC_COUNT, 1); sqlite3GlobalConfig.m.xFree(p); - sqlite3_mutex_leave(mem0.mutex); } else { sqlite3GlobalConfig.m.xFree(p); } @@ -539,7 +507,6 @@ measureAllocationSize(sqlite3 * db, void *p) void sqlite3DbFree(sqlite3 * db, void *p) { - assert(db == 0 || sqlite3_mutex_held(db->mutex)); if (p == 0) return; if (db) { @@ -597,7 +564,6 @@ sqlite3Realloc(void *pOld, u64 nBytes) if (nOld == nNew) { pNew = pOld; } else if (sqlite3GlobalConfig.bMemstat) { - sqlite3_mutex_enter(mem0.mutex); sqlite3StatusHighwater(SQLITE_STATUS_MALLOC_SIZE, (int)nBytes); nDiff = nNew - nOld; if (nDiff > 0 @@ -614,7 +580,6 @@ sqlite3Realloc(void *pOld, u64 nBytes) nNew = sqlite3MallocSize(pNew); sqlite3StatusUp(SQLITE_STATUS_MEMORY_USED, nNew - nOld); } - sqlite3_mutex_leave(mem0.mutex); } else { pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew); } @@ -732,7 +697,6 @@ sqlite3DbMallocRawNN(sqlite3 * db, u64 n) #ifndef SQLITE_OMIT_LOOKASIDE LookasideSlot *pBuf; assert(db != 0); - assert(sqlite3_mutex_held(db->mutex)); assert(db->pnBytesFreed == 0); if (db->lookaside.bDisable == 0) { assert(db->mallocFailed == 0); @@ -754,7 +718,6 @@ sqlite3DbMallocRawNN(sqlite3 * db, u64 n) } #else assert(db != 0); - assert(sqlite3_mutex_held(db->mutex)); assert(db->pnBytesFreed == 0); if (db->mallocFailed) { return 0; @@ -776,7 +739,6 @@ sqlite3DbRealloc(sqlite3 * db, void *p, u64 n) assert(db != 0); if (p == 0) return sqlite3DbMallocRawNN(db, n); - assert(sqlite3_mutex_held(db->mutex)); if (isLookaside(db, p) && n <= db->lookaside.sz) return p; return dbReallocFinish(db, p, n); @@ -941,12 +903,7 @@ apiOomError(sqlite3 * db) int sqlite3ApiExit(sqlite3 * db, int rc) { - /* If the db handle must hold the connection handle mutex here. - * Otherwise the read (and possible write) of db->mallocFailed - * is unsafe, as is the call to sqlite3Error(). - */ assert(db != 0); - assert(sqlite3_mutex_held(db->mutex)); if (db->mallocFailed || rc == SQLITE_IOERR_NOMEM) { return apiOomError(db); } diff --git a/src/box/sql/os.c b/src/box/sql/os.c index ecb437f..ae98831 100644 --- a/src/box/sql/os.c +++ b/src/box/sql/os.c @@ -439,25 +439,17 @@ sqlite3_vfs * sqlite3_vfs_find(const char *zVfs) { sqlite3_vfs *pVfs = 0; -#if SQLITE_THREADSAFE - sqlite3_mutex *mutex; -#endif #ifndef SQLITE_OMIT_AUTOINIT int rc = sqlite3_initialize(); if (rc) return 0; #endif -#if SQLITE_THREADSAFE - mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER); -#endif - sqlite3_mutex_enter(mutex); for (pVfs = vfsList; pVfs; pVfs = pVfs->pNext) { if (zVfs == 0) break; if (strcmp(zVfs, pVfs->zName) == 0) break; } - sqlite3_mutex_leave(mutex); return pVfs; } @@ -467,8 +459,6 @@ sqlite3_vfs_find(const char *zVfs) static void vfsUnlink(sqlite3_vfs * pVfs) { - assert(sqlite3_mutex_held - (sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER))); if (pVfs == 0) { /* No-op */ } else if (vfsList == pVfs) { @@ -492,8 +482,6 @@ vfsUnlink(sqlite3_vfs * pVfs) int sqlite3_vfs_register(sqlite3_vfs * pVfs, int makeDflt) { - MUTEX_LOGIC(sqlite3_mutex * mutex; - ) #ifndef SQLITE_OMIT_AUTOINIT int rc = sqlite3_initialize(); if (rc) @@ -504,9 +492,6 @@ sqlite3_vfs_register(sqlite3_vfs * pVfs, int makeDflt) return SQLITE_MISUSE_BKPT; #endif - MUTEX_LOGIC(mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER); - ) - sqlite3_mutex_enter(mutex); vfsUnlink(pVfs); if (makeDflt || vfsList == 0) { pVfs->pNext = vfsList; @@ -516,7 +501,6 @@ sqlite3_vfs_register(sqlite3_vfs * pVfs, int makeDflt) vfsList->pNext = pVfs; } assert(vfsList); - sqlite3_mutex_leave(mutex); return SQLITE_OK; } @@ -526,11 +510,6 @@ sqlite3_vfs_register(sqlite3_vfs * pVfs, int makeDflt) int sqlite3_vfs_unregister(sqlite3_vfs * pVfs) { -#if SQLITE_THREADSAFE - sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER); -#endif - sqlite3_mutex_enter(mutex); vfsUnlink(pVfs); - sqlite3_mutex_leave(mutex); return SQLITE_OK; } diff --git a/src/box/sql/os_unix.c b/src/box/sql/os_unix.c index 56c1c7e..4285d9f 100644 --- a/src/box/sql/os_unix.c +++ b/src/box/sql/os_unix.c @@ -134,15 +134,6 @@ #define SQLITE_FSFLAGS_IS_MSDOS 0x1 /* - * If we are to be thread-safe, include the pthreads header and define - * the SQLITE_UNIX_THREADS macro. - */ -#if SQLITE_THREADSAFE -#include -#define SQLITE_UNIX_THREADS 1 -#endif - -/* * Default permissions when creating a new file */ #ifndef SQLITE_DEFAULT_FILE_PERMISSIONS @@ -287,16 +278,6 @@ static pid_t randomnessPid = 0; #endif /* - * The threadid macro resolves to the thread-id or to 0. Used for - * testing and debugging only. - */ -#if SQLITE_THREADSAFE -#define threadid pthread_self() -#else -#define threadid 0 -#endif - -/* * HAVE_MREMAP defaults to true on Linux and false everywhere else. */ #if !defined(HAVE_MREMAP) @@ -648,39 +629,6 @@ robust_open(const char *z, int f, mode_t m) return fd; } -/* - * Helper functions to obtain and relinquish the global mutex. The - * global mutex is used to protect the unixInodeInfo object - * used by this file, all of which may be shared by multiple threads. - * - * Function unixMutexHeld() is used to assert() that the global mutex - * is held when required. This function is only used as part of assert() - * statements. e.g. - * - * unixEnterMutex() - * assert( unixMutexHeld() ); - * unixEnterLeave() - */ -static void -unixEnterMutex(void) -{ - sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_VFS1)); -} - -static void -unixLeaveMutex(void) -{ - sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_VFS1)); -} - -#ifdef SQLITE_DEBUG -static int -unixMutexHeld(void) -{ - return sqlite3_mutex_held(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_VFS1)); -} -#endif - #ifdef SQLITE_LOCK_TRACE /* * Print out information about all locking operations. @@ -717,8 +665,8 @@ lockTrace(int fd, int op, struct flock *p) assert(p->l_whence == SEEK_SET); s = osFcntl(fd, op, p); savedErrno = errno; - sqlite3DebugPrintf("fcntl %d %d %s %s %d %d %d %d\n", - threadid, fd, zOpName, zType, (int)p->l_start, + sqlite3DebugPrintf("fcntl %d %s %s %d %d %d %d\n", + fd, zOpName, zType, (int)p->l_start, (int)p->l_len, (int)p->l_pid, s); if (s == (-1) && op == F_SETLK && (p->l_type == F_RDLCK || p->l_type == F_WRLCK)) { @@ -951,39 +899,7 @@ unixLogErrorAtLine(int errcode, /* SQLite error code */ char *zErr; /* Message from strerror() or equivalent */ int iErrno = errno; /* Saved syscall error number */ - /* If this is not a threadsafe build (SQLITE_THREADSAFE==0), then use - * the strerror() function to obtain the human-readable error message - * equivalent to errno. Otherwise, use strerror_r(). - */ -#if SQLITE_THREADSAFE && defined(HAVE_STRERROR_R) - char aErr[80]; - memset(aErr, 0, sizeof(aErr)); - zErr = aErr; - - /* If STRERROR_R_CHAR_P (set by autoconf scripts) or __USE_GNU is defined, - * assume that the system provides the GNU version of strerror_r() that - * returns a pointer to a buffer containing the error message. That pointer - * may point to aErr[], or it may point to some static storage somewhere. - * Otherwise, assume that the system provides the POSIX version of - * strerror_r(), which always writes an error message into aErr[]. - * - * If the code incorrectly assumes that it is the POSIX version that is - * available, the error message will often be an empty string. Not a - * huge problem. Incorrectly concluding that the GNU version is available - * could lead to a segfault though. - */ -#if defined(STRERROR_R_CHAR_P) || defined(__USE_GNU) - zErr = -#endif - strerror_r(iErrno, aErr, sizeof(aErr) - 1); - -#elif SQLITE_THREADSAFE - /* This is a threadsafe build, but strerror_r() is not available. */ - zErr = ""; -#else - /* Non-threadsafe build, use strerror(). */ zErr = strerror(iErrno); -#endif if (zPath == 0) zPath = ""; @@ -1045,15 +961,11 @@ closePendingFds(unixFile * pFile) /* * Release a unixInodeInfo structure previously allocated by findInodeInfo(). - * - * The mutex entered using the unixEnterMutex() function must be held - * when this function is called. */ static void releaseInodeInfo(unixFile * pFile) { unixInodeInfo *pInode = pFile->pInode; - assert(unixMutexHeld()); if (ALWAYS(pInode)) { pInode->nRef--; if (pInode->nRef == 0) { @@ -1080,9 +992,6 @@ releaseInodeInfo(unixFile * pFile) * describes that file descriptor. Create a new one if necessary. The * return value might be uninitialized if an error occurs. * - * The mutex entered using the unixEnterMutex() function must be held - * when this function is called. - * * Return an appropriate error code. */ static int @@ -1096,8 +1005,6 @@ findInodeInfo(unixFile * pFile, /* Unix file with file desc used in the key */ struct stat statbuf; /* Low-level file information */ unixInodeInfo *pInode = 0; /* Candidate unixInodeInfo object */ - assert(unixMutexHeld()); - /* Get low-level information about the file that we can used to * create a unique name for the file. */ @@ -1238,15 +1145,12 @@ unixCheckReservedLock(sqlite3_file * id, int *pResOut) assert(pFile); assert(pFile->eFileLock <= SHARED_LOCK); - unixEnterMutex(); /* Because pFile->pInode is shared across threads */ /* Check if a thread in this process holds such a lock */ if (pFile->pInode->eFileLock > SHARED_LOCK) { reserved = 1; } - unixLeaveMutex(); - *pResOut = reserved; return rc; } @@ -1275,7 +1179,6 @@ unixFileLock(unixFile * pFile, struct flock *pLock) { int rc; unixInodeInfo *pInode = pFile->pInode; - assert(unixMutexHeld()); assert(pInode != 0); if ((pFile->ctrlFlags & (UNIXFILE_EXCL | UNIXFILE_RDONLY)) == UNIXFILE_EXCL) { @@ -1367,12 +1270,10 @@ unixLock(sqlite3_file * id, int eFileLock) assert(pFile); /* If there is already a lock of this type or more restrictive on the - * unixFile, do nothing. Don't use the end_lock: exit path, as - * unixEnterMutex() hasn't been called yet. + * unixFile, do nothing. */ - if (pFile->eFileLock >= eFileLock) { + if (pFile->eFileLock >= eFileLock) return SQLITE_OK; - } /* Make sure the locking sequence is correct. * (1) We never move from unlocked to anything higher than shared lock. @@ -1383,9 +1284,6 @@ unixLock(sqlite3_file * id, int eFileLock) assert(eFileLock != PENDING_LOCK); assert(eFileLock != RESERVED_LOCK || pFile->eFileLock == SHARED_LOCK); - /* This mutex is needed because pFile->pInode is shared across threads - */ - unixEnterMutex(); pInode = pFile->pInode; /* If some thread using this PID has a lock via a different unixFile* @@ -1529,7 +1427,6 @@ unixLock(sqlite3_file * id, int eFileLock) } end_lock: - unixLeaveMutex(); return rc; } @@ -1575,7 +1472,6 @@ posixUnlock(sqlite3_file * id, int eFileLock, int handleNFSUnlock) if (pFile->eFileLock <= eFileLock) { return SQLITE_OK; } - unixEnterMutex(); pInode = pFile->pInode; assert(pInode->nShared != 0); if (pFile->eFileLock > SHARED_LOCK) { @@ -1711,7 +1607,6 @@ posixUnlock(sqlite3_file * id, int eFileLock, int handleNFSUnlock) } end_unlock: - unixLeaveMutex(); if (rc == SQLITE_OK) pFile->eFileLock = eFileLock; return rc; @@ -1778,7 +1673,6 @@ unixClose(sqlite3_file * id) unixFile *pFile = (unixFile *) id; verifyDbFile(pFile); unixUnlock(id, NO_LOCK); - unixEnterMutex(); /* unixFile.pInode is always valid here. Otherwise, a different close * routine (e.g. nolockClose()) would be called instead. @@ -1794,7 +1688,6 @@ unixClose(sqlite3_file * id) } releaseInodeInfo(pFile); rc = closeUnixFile(id); - unixLeaveMutex(); return rc; } @@ -2355,7 +2248,6 @@ afpCheckReservedLock(sqlite3_file * id, int *pResOut) *pResOut = 1; return SQLITE_OK; } - unixEnterMutex(); /* Because pFile->pInode is shared across threads */ /* Check if a thread in this process holds such a lock */ if (pFile->pInode->eFileLock > SHARED_LOCK) { @@ -2384,8 +2276,6 @@ afpCheckReservedLock(sqlite3_file * id, int *pResOut) } } - unixLeaveMutex(); - *pResOut = reserved; return rc; } @@ -2426,8 +2316,7 @@ afpLock(sqlite3_file * id, int eFileLock) assert(pFile); /* If there is already a lock of this type or more restrictive on the - * unixFile, do nothing. Don't use the afp_end_lock: exit path, as - * unixEnterMutex() hasn't been called yet. + * unixFile, do nothing. */ if (pFile->eFileLock >= eFileLock) { return SQLITE_OK; @@ -2442,9 +2331,6 @@ afpLock(sqlite3_file * id, int eFileLock) assert(eFileLock != PENDING_LOCK); assert(eFileLock != RESERVED_LOCK || pFile->eFileLock == SHARED_LOCK); - /* This mutex is needed because pFile->pInode is shared across threads - */ - unixEnterMutex(); pInode = pFile->pInode; /* If some thread using this PID has a lock via a different unixFile* @@ -2594,7 +2480,6 @@ afpLock(sqlite3_file * id, int eFileLock) } afp_end_lock: - unixLeaveMutex(); return rc; } @@ -2624,7 +2509,6 @@ afpUnlock(sqlite3_file * id, int eFileLock) if (pFile->eFileLock <= eFileLock) { return SQLITE_OK; } - unixEnterMutex(); pInode = pFile->pInode; assert(pInode->nShared != 0); if (pFile->eFileLock > SHARED_LOCK) { @@ -2710,7 +2594,6 @@ afpUnlock(sqlite3_file * id, int eFileLock) } } - unixLeaveMutex(); if (rc == SQLITE_OK) pFile->eFileLock = eFileLock; return rc; @@ -2726,7 +2609,6 @@ afpClose(sqlite3_file * id) unixFile *pFile = (unixFile *) id; assert(id != 0); afpUnlock(id, NO_LOCK); - unixEnterMutex(); if (pFile->pInode && pFile->pInode->nLock) { /* If there are outstanding locks, do not actually close the file just * yet because that would clear those locks. Instead, add the file @@ -2738,7 +2620,6 @@ afpClose(sqlite3_file * id) releaseInodeInfo(pFile); sqlite3_free(pFile->lockingContext); rc = closeUnixFile(id); - unixLeaveMutex(); return rc; } @@ -4110,11 +3991,10 @@ fillInUnixFile(sqlite3_vfs * pVfs, /* Pointer to vfs object */ || pLockingStyle == &nfsIoMethods #endif ) { - unixEnterMutex(); rc = findInodeInfo(pNew, &pNew->pInode); if (rc != SQLITE_OK) { /* If an error occurred in findInodeInfo(), close the file descriptor - * immediately, before releasing the mutex. findInodeInfo() may fail + * immediately. findInodeInfo() may fail * in two scenarios: * * (a) A call to fstat() failed. @@ -4134,7 +4014,6 @@ fillInUnixFile(sqlite3_vfs * pVfs, /* Pointer to vfs object */ robust_close(pNew, h, __LINE__); h = -1; } - unixLeaveMutex(); } #if SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__) else if (pLockingStyle == &afpIoMethods) { @@ -4153,14 +4032,12 @@ fillInUnixFile(sqlite3_vfs * pVfs, /* Pointer to vfs object */ pCtx->dbPath = zFilename; pCtx->reserved = 0; srandomdev(); - unixEnterMutex(); rc = findInodeInfo(pNew, &pNew->pInode); if (rc != SQLITE_OK) { sqlite3_free(pNew->lockingContext); robust_close(pNew, h, __LINE__); h = -1; } - unixLeaveMutex(); } } #endif @@ -4308,7 +4185,6 @@ findReusableFd(const char *zPath, int flags) if (0 == osStat(zPath, &sStat)) { unixInodeInfo *pInode; - unixEnterMutex(); pInode = inodeList; while (pInode && (pInode->fileId.dev != sStat.st_dev || pInode->fileId.ino != @@ -4325,7 +4201,6 @@ findReusableFd(const char *zPath, int flags) *pp = pUnused->pNext; } } - unixLeaveMutex(); } return pUnused; } @@ -4897,12 +4772,10 @@ unixDlError(sqlite3_vfs * NotUsed, int nBuf, char *zBufOut) { const char *zErr; UNUSED_PARAMETER(NotUsed); - unixEnterMutex(); zErr = dlerror(); if (zErr) { sqlite3_snprintf(nBuf, zBufOut, "%s", zErr); } - unixLeaveMutex(); } static @@ -6379,8 +6252,8 @@ proxyClose(sqlite3_file * id) * files. * * This routine is called once during SQLite initialization and by a - * single thread. The memory allocation and mutex subsystems have not - * necessarily been initialized when this routine is called, and so they + * single thread. The memory allocation subsystem have not + * necessarily been initialized when this routine \is called, and so they * should not be used. */ int diff --git a/src/box/sql/prepare.c b/src/box/sql/prepare.c index 9b80282..0ea181d 100644 --- a/src/box/sql/prepare.c +++ b/src/box/sql/prepare.c @@ -86,7 +86,6 @@ sqlite3InitCallback(void *pInit, int argc, char **argv, char **NotUsed) sqlite3 *db = pData->db; assert(argc == 3); UNUSED_PARAMETER2(NotUsed, argc); - assert(sqlite3_mutex_held(db->mutex)); if (db->mallocFailed) { corruptSchema(pData, argv[0], 0); return 1; @@ -165,7 +164,6 @@ sqlite3InitDatabase(sqlite3 * db) InitData initData; assert(db->pSchema != NULL); - assert(sqlite3_mutex_held(db->mutex)); memset(&initData, 0, sizeof(InitData)); initData.db = db; @@ -227,7 +225,6 @@ sqlite3SchemaToIndex(sqlite3 * db, Schema * pSchema) * more likely to cause a segfault than -1 (of course there are assert() * statements too, but it never hurts to play the odds). */ - assert(sqlite3_mutex_held(db->mutex)); if (pSchema) { if (db->pSchema == pSchema) { i = 0; @@ -279,7 +276,6 @@ sqlite3Prepare(sqlite3 * db, /* Database handle. */ sParse.pReprepare = pReprepare; assert(ppStmt && *ppStmt == 0); /* assert( !db->mallocFailed ); // not true with SQLITE_USE_ALLOCA */ - assert(sqlite3_mutex_held(db->mutex)); /* Check to verify that it is possible to get a read lock on all * database schemas. The inability to get a read lock indicates that @@ -410,7 +406,6 @@ sqlite3LockAndPrepare(sqlite3 * db, /* Database handle. */ if (!sqlite3SafetyCheckOk(db) || zSql == 0) { return SQLITE_MISUSE_BKPT; } - sqlite3_mutex_enter(db->mutex); rc = sqlite3Prepare(db, zSql, nBytes, saveSqlFlag, pOld, ppStmt, pzTail); if (rc == SQLITE_SCHEMA) { @@ -418,7 +413,6 @@ sqlite3LockAndPrepare(sqlite3 * db, /* Database handle. */ rc = sqlite3Prepare(db, zSql, nBytes, saveSqlFlag, pOld, ppStmt, pzTail); } - sqlite3_mutex_leave(db->mutex); assert(rc == SQLITE_OK || *ppStmt == 0); return rc; } @@ -439,11 +433,9 @@ sqlite3Reprepare(Vdbe * p) const char *zSql; sqlite3 *db; - assert(sqlite3_mutex_held(sqlite3VdbeDb(p)->mutex)); zSql = sqlite3_sql((sqlite3_stmt *) p); assert(zSql != 0); /* Reprepare only called for prepare_v2() statements */ db = sqlite3VdbeDb(p); - assert(sqlite3_mutex_held(db->mutex)); rc = sqlite3LockAndPrepare(db, zSql, -1, 0, p, &pNew, 0); if (rc) { if (rc == SQLITE_NOMEM) { diff --git a/src/box/sql/printf.c b/src/box/sql/printf.c index 7884487..4be7bb8 100644 --- a/src/box/sql/printf.c +++ b/src/box/sql/printf.c @@ -1167,14 +1167,8 @@ sqlite3_snprintf(int n, char *zBuf, const char *zFormat, ...) * We house it in a separate routine from sqlite3_log() to avoid using * stack space on small-stack systems when logging is disabled. * - * sqlite3_log() must render into a static buffer. It cannot dynamically - * allocate memory because it might be called while the memory allocator - * mutex is held. - * * sqlite3VXPrintf() might ask for *temporary* memory allocations for * certain format characters (%q) or for very large precisions or widths. - * Care must be taken that any sqlite3_log() calls that occur while the - * memory mutex is held do not use these mechanisms. */ static void renderLogMsg(int iErrCode, const char *zFormat, va_list ap) diff --git a/src/box/sql/random.c b/src/box/sql/random.c index 4006ef0..4d6e642 100644 --- a/src/box/sql/random.c +++ b/src/box/sql/random.c @@ -70,23 +70,13 @@ sqlite3_randomness(int N, void *pBuf) #define wsdPrng sqlite3Prng #endif -#if SQLITE_THREADSAFE - sqlite3_mutex *mutex; -#endif - #ifndef SQLITE_OMIT_AUTOINIT if (sqlite3_initialize()) return; #endif -#if SQLITE_THREADSAFE - mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_PRNG); -#endif - - sqlite3_mutex_enter(mutex); if (N <= 0 || pBuf == 0) { wsdPrng.isInit = 0; - sqlite3_mutex_leave(mutex); return; } @@ -127,7 +117,6 @@ sqlite3_randomness(int N, void *pBuf) t += wsdPrng.s[wsdPrng.i]; *(zBuf++) = wsdPrng.s[t]; } while (--N); - sqlite3_mutex_leave(mutex); } #ifndef SQLITE_UNTESTABLE diff --git a/src/box/sql/sqliteInt.h b/src/box/sql/sqliteInt.h index 50dadf4..f2a74ce 100644 --- a/src/box/sql/sqliteInt.h +++ b/src/box/sql/sqliteInt.h @@ -180,26 +180,6 @@ #define SQLITE_NOINLINE #endif - -/* - * The SQLITE_THREADSAFE macro must be defined as 0, 1, or 2. - * 0 means mutexes are permanently disable and the library is never - * threadsafe. 1 means the library is serialized which is the highest - * level of threadsafety. 2 means the library is multithreaded - multiple - * threads can use SQLite as long as no two threads try to use the same - * database connection at the same time. - * - * Older versions of SQLite used an optional THREADSAFE macro. - * We support that for legacy. - */ -#if !defined(SQLITE_THREADSAFE) -#if defined(THREADSAFE) -#define SQLITE_THREADSAFE THREADSAFE -#else -#define SQLITE_THREADSAFE 1 /* IMP: R-07272-22309 */ -#endif -#endif - /* * Powersafe overwrite is on by default. But can be turned off using * the -DSQLITE_POWERSAFE_OVERWRITE=0 command-line option. @@ -251,16 +231,6 @@ #endif /* - * We need to define _XOPEN_SOURCE as follows in order to enable - * recursive mutexes on most Unix systems and fchmod() on OpenBSD. - * But _XOPEN_SOURCE define causes problems for Mac OS X, so omit - * it. - */ -#if !defined(_XOPEN_SOURCE) && !defined(__DARWIN__) && !defined(__APPLE__) -#define _XOPEN_SOURCE 600 -#endif - -/* * Enable SQLITE_ENABLE_EXPLAIN_COMMENTS if SQLITE_DEBUG is turned on. */ #if !defined(SQLITE_ENABLE_EXPLAIN_COMMENTS) && defined(SQLITE_DEBUG) @@ -450,20 +420,6 @@ struct sqlite3_vfs { */ }; -typedef struct sqlite3_mutex sqlite3_mutex; -typedef struct sqlite3_mutex_methods sqlite3_mutex_methods; -struct sqlite3_mutex_methods { - int (*xMutexInit) (void); - int (*xMutexEnd) (void); - sqlite3_mutex *(*xMutexAlloc) (int); - void (*xMutexFree) (sqlite3_mutex *); - void (*xMutexEnter) (sqlite3_mutex *); - int (*xMutexTry) (sqlite3_mutex *); - void (*xMutexLeave) (sqlite3_mutex *); - int (*xMutexHeld) (sqlite3_mutex *); - int (*xMutexNotheld) (sqlite3_mutex *); -}; - #define SQLITE_LIMIT_LENGTH 0 #define SQLITE_LIMIT_SQL_LENGTH 1 #define SQLITE_LIMIT_COLUMN 2 @@ -1215,7 +1171,7 @@ sqlite3_bind_parameter_lindex(sqlite3_stmt * pStmt, const char *zName, * SQLITE_TEMP_STORE is set to 3 (never use temporary files), set it * to zero. */ -#if SQLITE_TEMP_STORE==3 || SQLITE_THREADSAFE==0 +#if SQLITE_TEMP_STORE==3 #undef SQLITE_MAX_WORKER_THREADS #define SQLITE_MAX_WORKER_THREADS 0 #endif @@ -1657,7 +1613,6 @@ typedef int VList; #include "cursor.h" #include "vdbe.h" #include "os.h" -#include "mutex.h" /* * An instance of the following structure stores a database schema. @@ -1729,7 +1684,6 @@ struct sqlite3 { sqlite3_vfs *pVfs; /* OS Interface */ struct Vdbe *pVdbe; /* List of active virtual machines */ struct coll *pDfltColl; /* The default collating sequence (BINARY) */ - sqlite3_mutex *mutex; /* Connection mutex */ struct Schema *pSchema; /* Schema of the database */ i64 szMmap; /* Default mmap_size setting */ int errCode; /* Most recent error code (SQLITE_*) */ @@ -3365,8 +3319,6 @@ typedef struct { */ struct Sqlite3Config { int bMemstat; /* True to enable memory status */ - int bCoreMutex; /* True to enable core mutexing */ - int bFullMutex; /* True to enable full mutexing */ int bOpenUri; /* True to interpret filenames as URIs */ int bUseCis; /* Use covering indices for full-scans */ int mxStrlen; /* Maximum string length */ @@ -3375,7 +3327,6 @@ struct Sqlite3Config { int nLookaside; /* Default lookaside buffer count */ int nStmtSpill; /* Stmt-journal spill-to-disk threshold */ sqlite3_mem_methods m; /* Low-level memory allocation interface */ - sqlite3_mutex_methods mutex; /* Low-level mutex interface */ sqlite3_pcache_methods2 pcache2; /* Low-level page-cache interface */ void *pHeap; /* Heap storage space */ int nHeap; /* Size of pHeap[] */ @@ -3396,10 +3347,7 @@ struct Sqlite3Config { */ int isInit; /* True after initialization has finished */ int inProgress; /* True while initialization in progress */ - int isMutexInit; /* True after mutexes are initialized */ int isMallocInit; /* True after malloc is initialized */ - int nRefInitMutex; /* Number of users of pInitMutex */ - sqlite3_mutex *pInitMutex; /* Mutex used by sqlite3_initialize() */ void (*xLog) (void *, int, const char *); /* Function for logging */ void *pLogArg; /* First argument to xLog() */ #ifdef SQLITE_ENABLE_SQLLOG @@ -3640,28 +3588,11 @@ const sqlite3_mem_methods *sqlite3MemGetMemsys5(void); const sqlite3_mem_methods *sqlite3MemGetMemsys3(void); #endif -#ifndef SQLITE_MUTEX_OMIT -sqlite3_mutex_methods const *sqlite3DefaultMutex(void); -sqlite3_mutex_methods const *sqlite3NoopMutex(void); -sqlite3_mutex *sqlite3MutexAlloc(int); -int sqlite3MutexInit(void); -int sqlite3MutexEnd(void); -#endif -#if !defined(SQLITE_MUTEX_OMIT) && !defined(SQLITE_MUTEX_NOOP) -void sqlite3MemoryBarrier(void); -#else -#define sqlite3MemoryBarrier() -#endif - sqlite3_int64 sqlite3StatusValue(int); void sqlite3StatusUp(int, int); void sqlite3StatusDown(int, int); void sqlite3StatusHighwater(int, int); -/* Access to mutexes used by sqlite3_status() */ -sqlite3_mutex *sqlite3Pcache1Mutex(void); -sqlite3_mutex *sqlite3MallocMutex(void); - #ifndef SQLITE_OMIT_FLOATING_POINT int sqlite3IsNaN(double); #else diff --git a/src/box/sql/status.c b/src/box/sql/status.c index 8b476f8..963d3d8 100644 --- a/src/box/sql/status.c +++ b/src/box/sql/status.c @@ -68,8 +68,7 @@ static SQLITE_WSD struct sqlite3StatType { #endif /* - * Return the current value of a status parameter. The caller must - * be holding the appropriate mutex. + * Return the current value of a status parameter. */ sqlite3_int64 sqlite3StatusValue(int op) @@ -81,8 +80,7 @@ sqlite3StatusValue(int op) } /* - * Add N to the value of a status record. The caller must hold the - * appropriate mutex. (Locking is checked by assert()). + * Add N to the value of a status record. * * The StatusUp() routine can accept positive or negative values for N. * The value of N is added to the current status value and the high-water @@ -115,7 +113,6 @@ sqlite3StatusDown(int op, int N) /* * Adjust the highwater mark if necessary. - * The caller must hold the appropriate mutex. */ void sqlite3StatusHighwater(int op, int X) @@ -193,7 +190,6 @@ sqlite3_db_status(sqlite3 * db, /* The database connection whose status is desir return SQLITE_MISUSE_BKPT; } #endif - sqlite3_mutex_enter(db->mutex); switch (op) { case SQLITE_DBSTATUS_LOOKASIDE_USED:{ *pCurrent = db->lookaside.nOut; @@ -347,6 +343,5 @@ sqlite3_db_status(sqlite3 * db, /* The database connection whose status is desir rc = SQLITE_ERROR; } } - sqlite3_mutex_leave(db->mutex); return rc; } diff --git a/src/box/sql/tokenize.c b/src/box/sql/tokenize.c index 056924e..f810db4 100644 --- a/src/box/sql/tokenize.c +++ b/src/box/sql/tokenize.c @@ -609,11 +609,9 @@ sqlite3RunParser(Parse * pParse, const char *zSql, char **pzErrMsg) assert(nErr == 0); pParse->zTail = &zSql[i]; #ifdef YYTRACKMAXSTACKDEPTH - sqlite3_mutex_enter(sqlite3MallocMutex()); sqlite3StatusHighwater(SQLITE_STATUS_PARSER_STACK, sqlite3ParserStackPeak(pEngine) ); - sqlite3_mutex_leave(sqlite3MallocMutex()); #endif /* YYDEBUG */ sqlite3ParserFree(pEngine, sqlite3_free); if (db->mallocFailed) { diff --git a/src/box/sql/vdbe.c b/src/box/sql/vdbe.c index 96609b5..6877cab 100644 --- a/src/box/sql/vdbe.c +++ b/src/box/sql/vdbe.c @@ -5527,10 +5527,7 @@ abort_due_to_error: sqlite3SchemaClear(db); } - /* This is the only way out of this procedure. We have to - * release the mutexes on btrees that were acquired at the - * top. - */ + /* This is the only way out of this procedure. */ vdbe_return: testcase( nVmStep>0); p->aCounter[SQLITE_STMTSTATUS_VM_STEP] += (int)nVmStep; diff --git a/src/box/sql/vdbeapi.c b/src/box/sql/vdbeapi.c index 9c86c4c..dff1e16 100644 --- a/src/box/sql/vdbeapi.c +++ b/src/box/sql/vdbeapi.c @@ -125,7 +125,6 @@ sqlite3_finalize(sqlite3_stmt * pStmt) sqlite3 *db = v->db; if (vdbeSafety(v)) return SQLITE_MISUSE_BKPT; - sqlite3_mutex_enter(db->mutex); checkProfileCallback(db, v); rc = sqlite3VdbeFinalize(v); rc = sqlite3ApiExit(db, rc); @@ -150,13 +149,11 @@ sqlite3_reset(sqlite3_stmt * pStmt) } else { Vdbe *v = (Vdbe *) pStmt; sqlite3 *db = v->db; - sqlite3_mutex_enter(db->mutex); checkProfileCallback(db, v); rc = sqlite3VdbeReset(v); sqlite3VdbeRewind(v); assert((rc & (db->errMask)) == rc); rc = sqlite3ApiExit(db, rc); - sqlite3_mutex_leave(db->mutex); } return rc; } @@ -170,10 +167,6 @@ sqlite3_clear_bindings(sqlite3_stmt * pStmt) int i; int rc = SQLITE_OK; Vdbe *p = (Vdbe *) pStmt; -#if SQLITE_THREADSAFE - sqlite3_mutex *mutex = ((Vdbe *) pStmt)->db->mutex; -#endif - sqlite3_mutex_enter(mutex); for (i = 0; i < p->nVar; i++) { sqlite3VdbeMemRelease(&p->aVar[i]); p->aVar[i].flags = MEM_Null; @@ -181,7 +174,6 @@ sqlite3_clear_bindings(sqlite3_stmt * pStmt) if (p->isPrepareV2 && p->expmask) { p->expired = 1; } - sqlite3_mutex_leave(mutex); return rc; } @@ -369,7 +361,6 @@ sqlite3_result_blob(sqlite3_context * pCtx, ) { assert(n >= 0); - assert(sqlite3_mutex_held(pCtx->pOut->db->mutex)); if (sqlite3VdbeMemSetStr(pCtx->pOut, z, n,0, xDel) == SQLITE_TOOBIG) { sqlite3_result_error_toobig(pCtx); } @@ -380,7 +371,6 @@ sqlite3_result_blob64(sqlite3_context * pCtx, const void *z, sqlite3_uint64 n, void (*xDel) (void *) ) { - assert(sqlite3_mutex_held(pCtx->pOut->db->mutex)); assert(xDel != SQLITE_DYNAMIC); if (n > 0x7fffffff) { (void)invokeValueDestructor(z, xDel, pCtx); @@ -392,14 +382,12 @@ sqlite3_result_blob64(sqlite3_context * pCtx, void sqlite3_result_double(sqlite3_context * pCtx, double rVal) { - assert(sqlite3_mutex_held(pCtx->pOut->db->mutex)); sqlite3VdbeMemSetDouble(pCtx->pOut, rVal); } void sqlite3_result_error(sqlite3_context * pCtx, const char *z, int n) { - assert(sqlite3_mutex_held(pCtx->pOut->db->mutex)); pCtx->isError = SQLITE_ERROR; pCtx->fErrorOrAux = 1; sqlite3VdbeMemSetStr(pCtx->pOut, z, n, 1, SQLITE_TRANSIENT); @@ -408,21 +396,18 @@ sqlite3_result_error(sqlite3_context * pCtx, const char *z, int n) void sqlite3_result_int(sqlite3_context * pCtx, int iVal) { - assert(sqlite3_mutex_held(pCtx->pOut->db->mutex)); sqlite3VdbeMemSetInt64(pCtx->pOut, (i64) iVal); } void sqlite3_result_int64(sqlite3_context * pCtx, i64 iVal) { - assert(sqlite3_mutex_held(pCtx->pOut->db->mutex)); sqlite3VdbeMemSetInt64(pCtx->pOut, iVal); } void sqlite3_result_null(sqlite3_context * pCtx) { - assert(sqlite3_mutex_held(pCtx->pOut->db->mutex)); sqlite3VdbeMemSetNull(pCtx->pOut); } @@ -430,7 +415,6 @@ void sqlite3_result_subtype(sqlite3_context * pCtx, unsigned int eSubtype) { Mem *pOut = pCtx->pOut; - assert(sqlite3_mutex_held(pOut->db->mutex)); pOut->eSubtype = eSubtype & 0xff; pOut->flags |= MEM_Subtype; } @@ -440,7 +424,6 @@ sqlite3_result_text(sqlite3_context * pCtx, const char *z, int n, void (*xDel) (void *) ) { - assert(sqlite3_mutex_held(pCtx->pOut->db->mutex)); setResultStrOrError(pCtx, z, n, xDel); } @@ -450,7 +433,6 @@ sqlite3_result_text64(sqlite3_context * pCtx, sqlite3_uint64 n, void (*xDel) (void *)) { - assert(sqlite3_mutex_held(pCtx->pOut->db->mutex)); assert(xDel != SQLITE_DYNAMIC); if (n > 0x7fffffff) { (void)invokeValueDestructor(z, xDel, pCtx); @@ -462,14 +444,12 @@ sqlite3_result_text64(sqlite3_context * pCtx, void sqlite3_result_value(sqlite3_context * pCtx, sqlite3_value * pValue) { - assert(sqlite3_mutex_held(pCtx->pOut->db->mutex)); sqlite3VdbeMemCopy(pCtx->pOut, pValue); } void sqlite3_result_zeroblob(sqlite3_context * pCtx, int n) { - assert(sqlite3_mutex_held(pCtx->pOut->db->mutex)); sqlite3VdbeMemSetZeroBlob(pCtx->pOut, n); } @@ -477,7 +457,6 @@ int sqlite3_result_zeroblob64(sqlite3_context * pCtx, u64 n) { Mem *pOut = pCtx->pOut; - assert(sqlite3_mutex_held(pOut->db->mutex)); if (n > (u64) pOut->db->aLimit[SQLITE_LIMIT_LENGTH]) { return SQLITE_TOOBIG; } @@ -504,7 +483,6 @@ sqlite3_result_error_code(sqlite3_context * pCtx, int errCode) void sqlite3_result_error_toobig(sqlite3_context * pCtx) { - assert(sqlite3_mutex_held(pCtx->pOut->db->mutex)); pCtx->isError = SQLITE_TOOBIG; pCtx->fErrorOrAux = 1; sqlite3VdbeMemSetStr(pCtx->pOut, "string or blob too big", -1, 1, @@ -515,7 +493,6 @@ sqlite3_result_error_toobig(sqlite3_context * pCtx) void sqlite3_result_error_nomem(sqlite3_context * pCtx) { - assert(sqlite3_mutex_held(pCtx->pOut->db->mutex)); sqlite3VdbeMemSetNull(pCtx->pOut); pCtx->isError = SQLITE_NOMEM_BKPT; pCtx->fErrorOrAux = 1; @@ -667,7 +644,6 @@ sqlite3_step(sqlite3_stmt * pStmt) return SQLITE_MISUSE_BKPT; } db = v->db; - sqlite3_mutex_enter(db->mutex); v->doingRerun = 0; while ((rc = sqlite3Step(v)) == SQLITE_SCHEMA && cnt++ < SQLITE_MAX_SCHEMA_RETRY) { @@ -700,7 +676,6 @@ sqlite3_step(sqlite3_stmt * pStmt) } } rc = sqlite3ApiExit(db, rc); - sqlite3_mutex_leave(db->mutex); return rc; } @@ -814,7 +789,6 @@ void * sqlite3_aggregate_context(sqlite3_context * p, int nByte) { assert(p && p->pFunc && p->pFunc->xFinalize); - assert(sqlite3_mutex_held(p->pOut->db->mutex)); testcase(nByte < 0); if ((p->pMem->flags & MEM_Agg) == 0) { return createAggContext(p, nByte); @@ -832,7 +806,6 @@ sqlite3_get_auxdata(sqlite3_context * pCtx, int iArg) { AuxData *pAuxData; - assert(sqlite3_mutex_held(pCtx->pOut->db->mutex)); if (pCtx->pVdbe == 0) return 0; @@ -858,7 +831,6 @@ sqlite3_set_auxdata(sqlite3_context * pCtx, AuxData *pAuxData; Vdbe *pVdbe = pCtx->pVdbe; - assert(sqlite3_mutex_held(pCtx->pOut->db->mutex)); if (iArg < 0) goto failed; if (pVdbe == 0) @@ -973,7 +945,6 @@ columnMem(sqlite3_stmt * pStmt, int i) if (pVm == 0) return (Mem *) columnNullValue(); assert(pVm->db); - sqlite3_mutex_enter(pVm->db->mutex); if (pVm->pResultSet != 0 && i < pVm->nResColumn && i >= 0) { pOut = &pVm->pResultSet[i]; } else { @@ -1011,9 +982,7 @@ columnMallocFailure(sqlite3_stmt * pStmt) Vdbe *p = (Vdbe *) pStmt; if (p) { assert(p->db != 0); - assert(sqlite3_mutex_held(p->db->mutex)); p->rc = sqlite3ApiExit(p->db, p->rc); - sqlite3_mutex_leave(p->db->mutex); } } @@ -1131,7 +1100,6 @@ columnName(sqlite3_stmt * pStmt, n = sqlite3_column_count(pStmt); if (N < n && N >= 0) { N += useType * n; - sqlite3_mutex_enter(db->mutex); assert(db->mallocFailed == 0); ret = xFunc(&p->aColName[N]); /* A malloc may have failed inside of the xFunc() call. If this @@ -1141,7 +1109,6 @@ columnName(sqlite3_stmt * pStmt, sqlite3OomClear(db); ret = 0; } - sqlite3_mutex_leave(db->mutex); } return ret; } @@ -1226,9 +1193,6 @@ sqlite3_column_origin_name(sqlite3_stmt * pStmt, int N) * the same as binding a NULL value to the column. If the "i" parameter is * out of range, then SQLITE_RANGE is returned. Othewise SQLITE_OK. * - * A successful evaluation of this routine acquires the mutex on p. - * the mutex is released if any kind of error occurs. - * * The error code stored in database p->db is overwritten with the return * value in any case. */ @@ -1239,17 +1203,14 @@ vdbeUnbind(Vdbe * p, int i) if (vdbeSafetyNotNull(p)) { return SQLITE_MISUSE_BKPT; } - sqlite3_mutex_enter(p->db->mutex); if (p->magic != VDBE_MAGIC_RUN || p->pc >= 0) { sqlite3Error(p->db, SQLITE_MISUSE); - sqlite3_mutex_leave(p->db->mutex); sqlite3_log(SQLITE_MISUSE, "bind on a busy prepared statement: [%s]", p->zSql); return SQLITE_MISUSE_BKPT; } if (i < 1 || i > p->nVar) { sqlite3Error(p->db, SQLITE_RANGE); - sqlite3_mutex_leave(p->db->mutex); return SQLITE_RANGE; } i--; @@ -1299,7 +1260,6 @@ bindText(sqlite3_stmt * pStmt, /* The statement to bind against */ sqlite3Error(p->db, rc); rc = sqlite3ApiExit(p->db, rc); } - sqlite3_mutex_leave(p->db->mutex); } else if (xDel != SQLITE_STATIC && xDel != SQLITE_TRANSIENT) { xDel((void *)zData); } @@ -1344,7 +1304,6 @@ sqlite3_bind_double(sqlite3_stmt * pStmt, int i, double rValue) rc = vdbeUnbind(p, i); if (rc == SQLITE_OK) { sqlite3VdbeMemSetDouble(&p->aVar[i - 1], rValue); - sqlite3_mutex_leave(p->db->mutex); } return rc; } @@ -1363,7 +1322,6 @@ sqlite3_bind_int64(sqlite3_stmt * pStmt, int i, sqlite_int64 iValue) rc = vdbeUnbind(p, i); if (rc == SQLITE_OK) { sqlite3VdbeMemSetInt64(&p->aVar[i - 1], iValue); - sqlite3_mutex_leave(p->db->mutex); } return rc; } @@ -1374,9 +1332,6 @@ sqlite3_bind_null(sqlite3_stmt * pStmt, int i) int rc; Vdbe *p = (Vdbe *) pStmt; rc = vdbeUnbind(p, i); - if (rc == SQLITE_OK) { - sqlite3_mutex_leave(p->db->mutex); - } return rc; } @@ -1448,7 +1403,6 @@ sqlite3_bind_zeroblob(sqlite3_stmt * pStmt, int i, int n) rc = vdbeUnbind(p, i); if (rc == SQLITE_OK) { sqlite3VdbeMemSetZeroBlob(&p->aVar[i - 1], n); - sqlite3_mutex_leave(p->db->mutex); } return rc; } @@ -1458,7 +1412,6 @@ sqlite3_bind_zeroblob64(sqlite3_stmt * pStmt, int i, sqlite3_uint64 n) { int rc; Vdbe *p = (Vdbe *) pStmt; - sqlite3_mutex_enter(p->db->mutex); if (n > (u64) p->db->aLimit[SQLITE_LIMIT_LENGTH]) { rc = SQLITE_TOOBIG; } else { @@ -1466,7 +1419,6 @@ sqlite3_bind_zeroblob64(sqlite3_stmt * pStmt, int i, sqlite3_uint64 n) rc = sqlite3_bind_zeroblob(pStmt, i, n); } rc = sqlite3ApiExit(p->db, rc); - sqlite3_mutex_leave(p->db->mutex); return rc; } @@ -1534,11 +1486,9 @@ sqlite3TransferBindings(sqlite3_stmt * pFromStmt, sqlite3_stmt * pToStmt) int i; assert(pTo->db == pFrom->db); assert(pTo->nVar == pFrom->nVar); - sqlite3_mutex_enter(pTo->db->mutex); for (i = 0; i < pFrom->nVar; i++) { sqlite3VdbeMemMove(&pTo->aVar[i], &pFrom->aVar[i]); } - sqlite3_mutex_leave(pTo->db->mutex); return SQLITE_OK; } @@ -1580,13 +1530,11 @@ sqlite3_next_stmt(sqlite3 * pDb, sqlite3_stmt * pStmt) return 0; } #endif - sqlite3_mutex_enter(pDb->mutex); if (pStmt == 0) { pNext = (sqlite3_stmt *) pDb->pVdbe; } else { pNext = (sqlite3_stmt *) ((Vdbe *) pStmt)->pNext; } - sqlite3_mutex_leave(pDb->mutex); return pNext; } @@ -1639,9 +1587,7 @@ sqlite3_expanded_sql(sqlite3_stmt * pStmt) const char *zSql = sqlite3_sql(pStmt); if (zSql) { Vdbe *p = (Vdbe *) pStmt; - sqlite3_mutex_enter(p->db->mutex); z = sqlite3VdbeExpandSql(p, zSql); - sqlite3_mutex_leave(p->db->mutex); } return z; #endif diff --git a/src/box/sql/vdbeaux.c b/src/box/sql/vdbeaux.c index 92bf994..2b8d858 100644 --- a/src/box/sql/vdbeaux.c +++ b/src/box/sql/vdbeaux.c @@ -3000,7 +3000,6 @@ sqlite3VdbeDelete(Vdbe * p) if (NEVER(p == 0)) return; db = p->db; - assert(sqlite3_mutex_held(db->mutex)); sqlite3VdbeClearObject(db, p); if (p->pPrev) { p->pPrev->pNext = p->pNext; @@ -4165,7 +4164,6 @@ sqlite3VdbeIdxKeyCompare(sqlite3 * db, /* Database connection */ void sqlite3VdbeSetChanges(sqlite3 * db, int nChange) { - assert(sqlite3_mutex_held(db->mutex)); db->nChange = nChange; db->nTotalChange += nChange; } diff --git a/src/box/sql/vdbemem.c b/src/box/sql/vdbemem.c index 5dd85b8..9dd254f 100644 --- a/src/box/sql/vdbemem.c +++ b/src/box/sql/vdbemem.c @@ -183,7 +183,6 @@ sqlite3VdbeMemClearAndResize(Mem * pMem, int szNew) int sqlite3VdbeMemMakeWriteable(Mem * pMem) { - assert(pMem->db == 0 || sqlite3_mutex_held(pMem->db->mutex)); if ((pMem->flags & (MEM_Str | MEM_Blob)) != 0) { if (ExpandBlob(pMem)) return SQLITE_NOMEM; @@ -215,7 +214,6 @@ sqlite3VdbeMemExpandBlob(Mem * pMem) int nByte; assert(pMem->flags & MEM_Zero); assert(pMem->flags & MEM_Blob); - assert(pMem->db == 0 || sqlite3_mutex_held(pMem->db->mutex)); /* Set nByte to the number of bytes required to store the expanded blob. */ nByte = pMem->n + pMem->u.nZero; @@ -255,7 +253,6 @@ vdbeMemAddTerminator(Mem * pMem) int sqlite3VdbeMemNulTerminate(Mem * pMem) { - assert(pMem->db == 0 || sqlite3_mutex_held(pMem->db->mutex)); testcase((pMem->flags & (MEM_Term | MEM_Str)) == (MEM_Term | MEM_Str)); testcase((pMem->flags & (MEM_Term | MEM_Str)) == 0); if ((pMem->flags & (MEM_Term | MEM_Str)) != MEM_Str) { @@ -285,7 +282,6 @@ sqlite3VdbeMemStringify(Mem * pMem, u8 bForce) int fg = pMem->flags; const int nByte = 32; - assert(pMem->db == 0 || sqlite3_mutex_held(pMem->db->mutex)); assert(!(fg & MEM_Zero)); assert(!(fg & (MEM_Str | MEM_Blob))); assert(fg & (MEM_Int | MEM_Real)); @@ -323,7 +319,6 @@ sqlite3VdbeMemFinalize(Mem * pMem, FuncDef * pFunc) sqlite3_context ctx; Mem t; assert((pMem->flags & MEM_Null) != 0 || pFunc == pMem->u.pDef); - assert(pMem->db == 0 || sqlite3_mutex_held(pMem->db->mutex)); memset(&ctx, 0, sizeof(ctx)); memset(&t, 0, sizeof(t)); t.flags = MEM_Null; @@ -353,7 +348,6 @@ sqlite3VdbeMemFinalize(Mem * pMem, FuncDef * pFunc) static SQLITE_NOINLINE void vdbeMemClearExternAndSetNull(Mem * p) { - assert(p->db == 0 || sqlite3_mutex_held(p->db->mutex)); assert(VdbeMemDynamic(p)); if (p->flags & MEM_Agg) { sqlite3VdbeMemFinalize(p, p->u.pDef); @@ -458,7 +452,6 @@ i64 sqlite3VdbeIntValue(Mem * pMem) { int flags; - assert(pMem->db == 0 || sqlite3_mutex_held(pMem->db->mutex)); assert(EIGHT_BYTE_ALIGNMENT(pMem)); flags = pMem->flags; if (flags & MEM_Int) { @@ -484,7 +477,6 @@ sqlite3VdbeIntValue(Mem * pMem) double sqlite3VdbeRealValue(Mem * pMem) { - assert(pMem->db == 0 || sqlite3_mutex_held(pMem->db->mutex)); assert(EIGHT_BYTE_ALIGNMENT(pMem)); if (pMem->flags & MEM_Real) { return pMem->u.r; @@ -510,7 +502,6 @@ sqlite3VdbeIntegerAffinity(Mem * pMem) { i64 ix; assert(pMem->flags & MEM_Real); - assert(pMem->db == 0 || sqlite3_mutex_held(pMem->db->mutex)); assert(EIGHT_BYTE_ALIGNMENT(pMem)); ix = doubleToInt64(pMem->u.r); @@ -537,7 +528,6 @@ sqlite3VdbeIntegerAffinity(Mem * pMem) int sqlite3VdbeMemIntegerify(Mem * pMem) { - assert(pMem->db == 0 || sqlite3_mutex_held(pMem->db->mutex)); assert(EIGHT_BYTE_ALIGNMENT(pMem)); pMem->u.i = sqlite3VdbeIntValue(pMem); @@ -552,7 +542,6 @@ sqlite3VdbeMemIntegerify(Mem * pMem) int sqlite3VdbeMemRealify(Mem * pMem) { - assert(pMem->db == 0 || sqlite3_mutex_held(pMem->db->mutex)); assert(EIGHT_BYTE_ALIGNMENT(pMem)); pMem->u.r = sqlite3VdbeRealValue(pMem); @@ -573,7 +562,6 @@ sqlite3VdbeMemNumerify(Mem * pMem) { if ((pMem->flags & (MEM_Int | MEM_Real | MEM_Null)) == 0) { assert((pMem->flags & (MEM_Blob | MEM_Str)) != 0); - assert(pMem->db == 0 || sqlite3_mutex_held(pMem->db->mutex)); if (0 == sqlite3Atoi64(pMem->z, &pMem->u.i, pMem->n)) { MemSetTypeFlag(pMem, MEM_Int); } else { @@ -843,8 +831,6 @@ sqlite3VdbeMemCopy(Mem * pTo, const Mem * pFrom) void sqlite3VdbeMemMove(Mem * pTo, Mem * pFrom) { - assert(pFrom->db == 0 || sqlite3_mutex_held(pFrom->db->mutex)); - assert(pTo->db == 0 || sqlite3_mutex_held(pTo->db->mutex)); assert(pFrom->db == 0 || pTo->db == 0 || pFrom->db == pTo->db); sqlite3VdbeMemRelease(pTo); @@ -879,7 +865,6 @@ sqlite3VdbeMemSetStr(Mem * pMem, /* Memory cell to set to string value */ int nByte = n; /* New value for pMem->n */ int iLimit; /* Maximum allowed string or blob size */ u16 flags = 0; /* New value for pMem->flags */ - assert(pMem->db == 0 || sqlite3_mutex_held(pMem->db->mutex)); /* If z is a NULL pointer, set pMem to contain an SQL NULL. */ if (!z) { @@ -1019,7 +1004,6 @@ static SQLITE_NOINLINE const void * valueToText(sqlite3_value * pVal) { assert(pVal != 0); - assert(pVal->db == 0 || sqlite3_mutex_held(pVal->db->mutex)); assert((pVal->flags & (MEM_Null)) == 0); if (pVal->flags & (MEM_Blob | MEM_Str)) { if (ExpandBlob(pVal)) @@ -1048,7 +1032,6 @@ sqlite3ValueText(sqlite3_value * pVal) { if (!pVal) return 0; - assert(pVal->db == 0 || sqlite3_mutex_held(pVal->db->mutex)); if ((pVal->flags & (MEM_Str | MEM_Term)) == (MEM_Str | MEM_Term)) { return pVal->z; } diff --git a/src/box/sql/vdbesort.c b/src/box/sql/vdbesort.c index 68dbf50..fc10ef6 100644 --- a/src/box/sql/vdbesort.c +++ b/src/box/sql/vdbesort.c @@ -863,11 +863,7 @@ sqlite3VdbeSorterInit(sqlite3 * db, /* Database connection (for malloc()) */ /* Initialize the upper limit on the number of worker threads */ #if SQLITE_MAX_WORKER_THREADS>0 - if (sqlite3TempInMemory(db) || sqlite3GlobalConfig.bCoreMutex == 0) { - nWorker = 0; - } else { - nWorker = db->aLimit[SQLITE_LIMIT_WORKER_THREADS]; - } + nWorker = db->aLimit[SQLITE_LIMIT_WORKER_THREADS]; #endif /* Do not allow the total number of threads (main thread + all workers) -- 2.11.0