Many hyperlinks are disabled.
Use anonymous login
to enable hyperlinks.
Overview
Comment: | Modify the sqlite3OsInMutex os-layer interface to take a single parameter to distinguish between mutexes held by the current thread and mutexes held by any thread. Part of the fix for ticket #1630. (CVS 2973) |
---|---|
Downloads: | Tarball | ZIP archive |
Timelines: | family | ancestors | descendants | both | trunk |
Files: | files | file ages | folders |
SHA1: |
e1ad9df1cf46287f2a7789275e98d28e |
User & Date: | drh 2006-01-18 17:25:46.000 |
Context
2006-01-18
| ||
18:22 | Include the ThreadData structure in internal malloc() testing. Also fixes for revealed bugs. (CVS 2974) (check-in: c7b9d50d0a user: danielk1977 tags: trunk) | |
17:25 | Modify the sqlite3OsInMutex os-layer interface to take a single parameter to distinguish between mutexes held by the current thread and mutexes held by any thread. Part of the fix for ticket #1630. (CVS 2973) (check-in: e1ad9df1cf user: drh tags: trunk) | |
16:51 | Use a global variable protected by a mutex instead of thread-specific-data to record malloc() failures. (CVS 2972) (check-in: ac090f2ab3 user: danielk1977 tags: trunk) | |
Changes
Changes to src/os.h.
︙ | ︙ | |||
287 288 289 290 291 292 293 | int sqlite3OsSyncDirectory(const char*); int sqlite3OsTempFileName(char*); int sqlite3OsRandomSeed(char*); int sqlite3OsSleep(int ms); int sqlite3OsCurrentTime(double*); void sqlite3OsEnterMutex(void); void sqlite3OsLeaveMutex(void); | | | 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 | int sqlite3OsSyncDirectory(const char*); int sqlite3OsTempFileName(char*); int sqlite3OsRandomSeed(char*); int sqlite3OsSleep(int ms); int sqlite3OsCurrentTime(double*); void sqlite3OsEnterMutex(void); void sqlite3OsLeaveMutex(void); int sqlite3OsInMutex(int); ThreadData *sqlite3OsThreadSpecificData(int); void *sqlite3OsMalloc(int); void *sqlite3OsRealloc(void *, int); void sqlite3OsFree(void *); int sqlite3OsAllocationSize(void *); /* |
︙ | ︙ |
Changes to src/os_unix.c.
︙ | ︙ | |||
474 475 476 477 478 479 480 | } #endif /* SQLITE_UNIX_THREADS */ /* ** Release a lockInfo structure previously allocated by findLockInfo(). */ static void releaseLockInfo(struct lockInfo *pLock){ | | | | 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 | } #endif /* SQLITE_UNIX_THREADS */ /* ** Release a lockInfo structure previously allocated by findLockInfo(). */ static void releaseLockInfo(struct lockInfo *pLock){ assert( sqlite3OsInMutex(1) ); pLock->nRef--; if( pLock->nRef==0 ){ sqlite3HashInsert(&lockHash, &pLock->key, sizeof(pLock->key), 0); sqliteFree(pLock); } } /* ** Release a openCnt structure previously allocated by findLockInfo(). */ static void releaseOpenCnt(struct openCnt *pOpen){ assert( sqlite3OsInMutex(1) ); pOpen->nRef--; if( pOpen->nRef==0 ){ sqlite3HashInsert(&openHash, &pOpen->key, sizeof(pOpen->key), 0); free(pOpen->aPending); sqliteFree(pOpen); } } |
︙ | ︙ | |||
516 517 518 519 520 521 522 | struct openKey key2; struct stat statbuf; struct lockInfo *pLock; struct openCnt *pOpen; rc = fstat(fd, &statbuf); if( rc!=0 ) return 1; | | | 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 | struct openKey key2; struct stat statbuf; struct lockInfo *pLock; struct openCnt *pOpen; rc = fstat(fd, &statbuf); if( rc!=0 ) return 1; assert( sqlite3OsInMutex(1) ); memset(&key1, 0, sizeof(key1)); key1.dev = statbuf.st_dev; key1.ino = statbuf.st_ino; #ifdef SQLITE_UNIX_THREADS if( threadsOverrideEachOthersLocks<0 ){ testThreadLockingBehavior(fd); } |
︙ | ︙ | |||
1676 1677 1678 1679 1680 1681 1682 | ** The following pair of routine implement mutual exclusion for ** multi-threaded processes. Only a single thread is allowed to ** executed code that is surrounded by EnterMutex() and LeaveMutex(). ** ** SQLite uses only a single Mutex. There is not much critical ** code and what little there is executes quickly and without blocking. ** | | | 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 | ** The following pair of routine implement mutual exclusion for ** multi-threaded processes. Only a single thread is allowed to ** executed code that is surrounded by EnterMutex() and LeaveMutex(). ** ** SQLite uses only a single Mutex. There is not much critical ** code and what little there is executes quickly and without blocking. ** ** As of version 3.3.2, this mutex must be recursive. */ void sqlite3UnixEnterMutex(){ #ifdef SQLITE_UNIX_THREADS pthread_mutex_lock(&mutex1); if( inMutex==0 ){ pthread_mutex_lock(&mutex2); mutexOwner = pthread_self(); |
︙ | ︙ | |||
1705 1706 1707 1708 1709 1710 1711 | pthread_mutex_unlock(&mutex1); #else inMutex--; #endif } /* | | > > > > | > | | | 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 | pthread_mutex_unlock(&mutex1); #else inMutex--; #endif } /* ** Return TRUE if the mutex is currently held. ** ** If the thisThreadOnly parameter is true, return true only if the ** calling thread holds the mutex. If the parameter is false, return ** true if any thread holds the mutex. */ int sqlite3UnixInMutex(int thisThreadOnly){ #ifdef SQLITE_UNIX_THREADS return inMutex>0 && (thisThreadOnly==0 || pthread_equal(mutexOwner, pthread_self())); #else return inMutex>0; #endif } /* ** Remember the number of thread-specific-data blocks allocated. ** Use this to verify that we are not leaking thread-specific-data. ** Ticket #1601 |
︙ | ︙ |
Changes to src/os_win.c.
︙ | ︙ | |||
1064 1065 1066 1067 1068 1069 1070 | } /* ** Static variables used for thread synchronization */ static int inMutex = 0; #ifdef SQLITE_W32_THREADS | | | > > > | > | > > > > | | | | 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 | } /* ** Static variables used for thread synchronization */ static int inMutex = 0; #ifdef SQLITE_W32_THREADS static DWORD mutexOwner; static CRITICAL_SECTION cs; #endif /* ** The following pair of routines implement mutual exclusion for ** multi-threaded processes. Only a single thread is allowed to ** executed code that is surrounded by EnterMutex() and LeaveMutex(). ** ** SQLite uses only a single Mutex. There is not much critical ** code and what little there is executes quickly and without blocking. ** ** Version 3.3.1 and earlier used a simple mutex. Beginning with ** version 3.3.2, a recursive mutex is required. */ void sqlite3WinEnterMutex(){ #ifdef SQLITE_W32_THREADS static int isInit = 0; while( !isInit ){ static long lock = 0; if( InterlockedIncrement(&lock)==1 ){ InitializeCriticalSection(&cs); isInit = 1; }else{ Sleep(1); } } EnterCriticalSection(&cs); mutexOwner = GetCurrentThreadId(); #endif inMutex++; } void sqlite3WinLeaveMutex(){ assert( inMutex ); inMutex--; #ifdef SQLITE_W32_THREADS assert( mutexOwner==GetCurrentThreadId() ); LeaveCriticalSection(&cs); #endif } /* ** Return TRUE if the mutex is currently held. ** ** If the thisThreadOnly parameter is true, return true if and only if the ** calling thread holds the mutex. If the parameter is false, return ** true if any thread holds the mutex. */ int sqlite3WinInMutex(int thisThreadOnly){ #ifdef SQLITE_W32_THREADS return inMutex>0 && (thisThreadOnly==0 || mutexOwner==GetCurrentThreadId()); #else return inMutex>0; #endif } /* ** The following variable, if set to a non-zero value, becomes the result ** returned from sqlite3OsCurrentTime(). This is used for testing. |
︙ | ︙ |
Changes to src/pager.c.
︙ | ︙ | |||
14 15 16 17 18 19 20 | ** The pager is used to access a database disk file. It implements ** atomic commit and rollback through the use of a journal file that ** is separate from the database file. The pager also implements file ** locking to prevent two processes from writing the same database ** file simultaneously, or one process from reading the database while ** another is writing. ** | | | 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 | ** The pager is used to access a database disk file. It implements ** atomic commit and rollback through the use of a journal file that ** is separate from the database file. The pager also implements file ** locking to prevent two processes from writing the same database ** file simultaneously, or one process from reading the database while ** another is writing. ** ** @(#) $Id: pager.c,v 1.244 2006/01/18 17:25:46 drh Exp $ */ #ifndef SQLITE_OMIT_DISKIO #include "sqliteInt.h" #include "os.h" #include "pager.h" #include <assert.h> #include <string.h> |
︙ | ︙ | |||
2433 2434 2435 2436 2437 2438 2439 | int i; /* If the the global mutex is held, this subroutine becomes a ** o-op; zero bytes of memory are freed. This is because ** some of the code invoked by this function may also ** try to obtain the mutex, resulting in a deadlock. */ | | | 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 | int i; /* If the the global mutex is held, this subroutine becomes a ** o-op; zero bytes of memory are freed. This is because ** some of the code invoked by this function may also ** try to obtain the mutex, resulting in a deadlock. */ if( sqlite3OsInMutex(0) ){ return 0; } /* Outermost loop runs for at most two iterations. First iteration we ** try to find memory that can be released without calling fsync(). Second ** iteration (which only runs if the first failed to free nReq bytes of ** memory) is permitted to call fsync(). This is of course much more |
︙ | ︙ |
Changes to src/util.c.
︙ | ︙ | |||
10 11 12 13 14 15 16 | ** ************************************************************************* ** Utility functions used throughout sqlite. ** ** This file contains functions for allocating memory, comparing ** strings, and stuff like that. ** | | | 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 | ** ************************************************************************* ** Utility functions used throughout sqlite. ** ** This file contains functions for allocating memory, comparing ** strings, and stuff like that. ** ** $Id: util.c,v 1.177 2006/01/18 17:25:46 drh Exp $ */ #include "sqliteInt.h" #include "os.h" #include <stdarg.h> #include <ctype.h> /* |
︙ | ︙ | |||
1369 1370 1371 1372 1373 1374 1375 | } /* ** Return true is a malloc has failed in this thread since the last call ** to sqlite3ApiExit(), or false otherwise. */ int sqlite3MallocFailed(){ | | | 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 | } /* ** Return true is a malloc has failed in this thread since the last call ** to sqlite3ApiExit(), or false otherwise. */ int sqlite3MallocFailed(){ return (mallocHasFailed && sqlite3OsInMutex(1)); } /* ** Set the "malloc has failed" condition to true for this thread. */ void sqlite3FailedMalloc(){ sqlite3OsEnterMutex(); |
︙ | ︙ |