danielk1977 | a7a8e14 | 2008-02-13 18:25:27 +0000 | [diff] [blame] | 1 | /* |
drh | 054889e | 2005-11-30 03:20:31 +0000 | [diff] [blame] | 2 | ** 2005 November 29 |
| 3 | ** |
| 4 | ** The author disclaims copyright to this source code. In place of |
| 5 | ** a legal notice, here is a blessing: |
| 6 | ** |
| 7 | ** May you do good and not evil. |
| 8 | ** May you find forgiveness for yourself and forgive others. |
| 9 | ** May you share freely, never taking more than you give. |
| 10 | ** |
| 11 | ****************************************************************************** |
| 12 | ** |
| 13 | ** This file contains OS interface code that is common to all |
| 14 | ** architectures. |
| 15 | */ |
drh | 3f45902 | 2006-01-07 16:06:07 +0000 | [diff] [blame] | 16 | #define _SQLITE_OS_C_ 1 |
drh | 054889e | 2005-11-30 03:20:31 +0000 | [diff] [blame] | 17 | #include "sqliteInt.h" |
drh | bd08af4 | 2007-04-05 21:58:33 +0000 | [diff] [blame] | 18 | #undef _SQLITE_OS_C_ |
drh | 054889e | 2005-11-30 03:20:31 +0000 | [diff] [blame] | 19 | |
| 20 | /* |
danielk1977 | ae72d98 | 2007-10-03 08:46:44 +0000 | [diff] [blame] | 21 | ** The default SQLite sqlite3_vfs implementations do not allocate |
| 22 | ** memory (actually, os_unix.c allocates a small amount of memory |
| 23 | ** from within OsOpen()), but some third-party implementations may. |
| 24 | ** So we test the effects of a malloc() failing and the sqlite3OsXXX() |
| 25 | ** function returning SQLITE_IOERR_NOMEM using the DO_OS_MALLOC_TEST macro. |
| 26 | ** |
| 27 | ** The following functions are instrumented for malloc() failure |
| 28 | ** testing: |
| 29 | ** |
danielk1977 | ae72d98 | 2007-10-03 08:46:44 +0000 | [diff] [blame] | 30 | ** sqlite3OsRead() |
| 31 | ** sqlite3OsWrite() |
| 32 | ** sqlite3OsSync() |
mistachkin | 6c3c1a0 | 2011-11-12 03:17:40 +0000 | [diff] [blame] | 33 | ** sqlite3OsFileSize() |
danielk1977 | ae72d98 | 2007-10-03 08:46:44 +0000 | [diff] [blame] | 34 | ** sqlite3OsLock() |
mistachkin | 6c3c1a0 | 2011-11-12 03:17:40 +0000 | [diff] [blame] | 35 | ** sqlite3OsCheckReservedLock() |
| 36 | ** sqlite3OsFileControl() |
| 37 | ** sqlite3OsShmMap() |
| 38 | ** sqlite3OsOpen() |
| 39 | ** sqlite3OsDelete() |
| 40 | ** sqlite3OsAccess() |
| 41 | ** sqlite3OsFullPathname() |
danielk1977 | ae72d98 | 2007-10-03 08:46:44 +0000 | [diff] [blame] | 42 | ** |
| 43 | */ |
shaneh | fd28639 | 2010-07-02 19:49:38 +0000 | [diff] [blame] | 44 | #if defined(SQLITE_TEST) |
dan | c396d4a | 2010-07-02 11:27:43 +0000 | [diff] [blame] | 45 | int sqlite3_memdebug_vfs_oom_test = 1; |
| 46 | #define DO_OS_MALLOC_TEST(x) \ |
| 47 | if (sqlite3_memdebug_vfs_oom_test && (!x || !sqlite3IsMemJournal(x))) { \ |
danielk1977 | b5a1920 | 2009-07-27 11:41:20 +0000 | [diff] [blame] | 48 | void *pTstAlloc = sqlite3Malloc(10); \ |
| 49 | if (!pTstAlloc) return SQLITE_IOERR_NOMEM; \ |
| 50 | sqlite3_free(pTstAlloc); \ |
danielk1977 | ae72d98 | 2007-10-03 08:46:44 +0000 | [diff] [blame] | 51 | } |
| 52 | #else |
danielk1977 | b5a1920 | 2009-07-27 11:41:20 +0000 | [diff] [blame] | 53 | #define DO_OS_MALLOC_TEST(x) |
danielk1977 | ae72d98 | 2007-10-03 08:46:44 +0000 | [diff] [blame] | 54 | #endif |
| 55 | |
| 56 | /* |
drh | 054889e | 2005-11-30 03:20:31 +0000 | [diff] [blame] | 57 | ** The following routines are convenience wrappers around methods |
danielk1977 | 6207906 | 2007-08-15 17:08:46 +0000 | [diff] [blame] | 58 | ** of the sqlite3_file object. This is mostly just syntactic sugar. All |
drh | 054889e | 2005-11-30 03:20:31 +0000 | [diff] [blame] | 59 | ** of this would be completely automatic if SQLite were coded using |
| 60 | ** C++ instead of plain old C. |
| 61 | */ |
danielk1977 | b4b4741 | 2007-08-17 15:53:36 +0000 | [diff] [blame] | 62 | int sqlite3OsClose(sqlite3_file *pId){ |
danielk1977 | c7b6017 | 2007-08-22 11:22:03 +0000 | [diff] [blame] | 63 | int rc = SQLITE_OK; |
| 64 | if( pId->pMethods ){ |
| 65 | rc = pId->pMethods->xClose(pId); |
| 66 | pId->pMethods = 0; |
| 67 | } |
| 68 | return rc; |
drh | 054889e | 2005-11-30 03:20:31 +0000 | [diff] [blame] | 69 | } |
danielk1977 | 6207906 | 2007-08-15 17:08:46 +0000 | [diff] [blame] | 70 | int sqlite3OsRead(sqlite3_file *id, void *pBuf, int amt, i64 offset){ |
danielk1977 | b5a1920 | 2009-07-27 11:41:20 +0000 | [diff] [blame] | 71 | DO_OS_MALLOC_TEST(id); |
danielk1977 | 6207906 | 2007-08-15 17:08:46 +0000 | [diff] [blame] | 72 | return id->pMethods->xRead(id, pBuf, amt, offset); |
drh | 054889e | 2005-11-30 03:20:31 +0000 | [diff] [blame] | 73 | } |
danielk1977 | 6207906 | 2007-08-15 17:08:46 +0000 | [diff] [blame] | 74 | int sqlite3OsWrite(sqlite3_file *id, const void *pBuf, int amt, i64 offset){ |
danielk1977 | b5a1920 | 2009-07-27 11:41:20 +0000 | [diff] [blame] | 75 | DO_OS_MALLOC_TEST(id); |
danielk1977 | 6207906 | 2007-08-15 17:08:46 +0000 | [diff] [blame] | 76 | return id->pMethods->xWrite(id, pBuf, amt, offset); |
drh | 054889e | 2005-11-30 03:20:31 +0000 | [diff] [blame] | 77 | } |
danielk1977 | 6207906 | 2007-08-15 17:08:46 +0000 | [diff] [blame] | 78 | int sqlite3OsTruncate(sqlite3_file *id, i64 size){ |
| 79 | return id->pMethods->xTruncate(id, size); |
drh | 054889e | 2005-11-30 03:20:31 +0000 | [diff] [blame] | 80 | } |
danielk1977 | 90949c2 | 2007-08-17 16:50:38 +0000 | [diff] [blame] | 81 | int sqlite3OsSync(sqlite3_file *id, int flags){ |
danielk1977 | b5a1920 | 2009-07-27 11:41:20 +0000 | [diff] [blame] | 82 | DO_OS_MALLOC_TEST(id); |
danielk1977 | 90949c2 | 2007-08-17 16:50:38 +0000 | [diff] [blame] | 83 | return id->pMethods->xSync(id, flags); |
drh | 054889e | 2005-11-30 03:20:31 +0000 | [diff] [blame] | 84 | } |
danielk1977 | 6207906 | 2007-08-15 17:08:46 +0000 | [diff] [blame] | 85 | int sqlite3OsFileSize(sqlite3_file *id, i64 *pSize){ |
danielk1977 | b5a1920 | 2009-07-27 11:41:20 +0000 | [diff] [blame] | 86 | DO_OS_MALLOC_TEST(id); |
danielk1977 | 6207906 | 2007-08-15 17:08:46 +0000 | [diff] [blame] | 87 | return id->pMethods->xFileSize(id, pSize); |
drh | 054889e | 2005-11-30 03:20:31 +0000 | [diff] [blame] | 88 | } |
danielk1977 | 6207906 | 2007-08-15 17:08:46 +0000 | [diff] [blame] | 89 | int sqlite3OsLock(sqlite3_file *id, int lockType){ |
danielk1977 | b5a1920 | 2009-07-27 11:41:20 +0000 | [diff] [blame] | 90 | DO_OS_MALLOC_TEST(id); |
danielk1977 | 6207906 | 2007-08-15 17:08:46 +0000 | [diff] [blame] | 91 | return id->pMethods->xLock(id, lockType); |
drh | 054889e | 2005-11-30 03:20:31 +0000 | [diff] [blame] | 92 | } |
danielk1977 | 6207906 | 2007-08-15 17:08:46 +0000 | [diff] [blame] | 93 | int sqlite3OsUnlock(sqlite3_file *id, int lockType){ |
| 94 | return id->pMethods->xUnlock(id, lockType); |
drh | 054889e | 2005-11-30 03:20:31 +0000 | [diff] [blame] | 95 | } |
danielk1977 | 861f745 | 2008-06-05 11:39:11 +0000 | [diff] [blame] | 96 | int sqlite3OsCheckReservedLock(sqlite3_file *id, int *pResOut){ |
danielk1977 | b5a1920 | 2009-07-27 11:41:20 +0000 | [diff] [blame] | 97 | DO_OS_MALLOC_TEST(id); |
danielk1977 | 861f745 | 2008-06-05 11:39:11 +0000 | [diff] [blame] | 98 | return id->pMethods->xCheckReservedLock(id, pResOut); |
drh | 054889e | 2005-11-30 03:20:31 +0000 | [diff] [blame] | 99 | } |
drh | c02372c | 2012-01-10 17:59:59 +0000 | [diff] [blame] | 100 | |
| 101 | /* |
| 102 | ** Use sqlite3OsFileControl() when we are doing something that might fail |
| 103 | ** and we need to know about the failures. Use sqlite3OsFileControlHint() |
| 104 | ** when simply tossing information over the wall to the VFS and we do not |
| 105 | ** really care if the VFS receives and understands the information since it |
| 106 | ** is only a hint and can be safely ignored. The sqlite3OsFileControlHint() |
| 107 | ** routine has no return value since the return value would be meaningless. |
| 108 | */ |
drh | cc6bb3e | 2007-08-31 16:11:35 +0000 | [diff] [blame] | 109 | int sqlite3OsFileControl(sqlite3_file *id, int op, void *pArg){ |
mistachkin | 6c3c1a0 | 2011-11-12 03:17:40 +0000 | [diff] [blame] | 110 | DO_OS_MALLOC_TEST(id); |
danielk1977 | 861f745 | 2008-06-05 11:39:11 +0000 | [diff] [blame] | 111 | return id->pMethods->xFileControl(id, op, pArg); |
drh | cc6bb3e | 2007-08-31 16:11:35 +0000 | [diff] [blame] | 112 | } |
drh | c02372c | 2012-01-10 17:59:59 +0000 | [diff] [blame] | 113 | void sqlite3OsFileControlHint(sqlite3_file *id, int op, void *pArg){ |
| 114 | (void)id->pMethods->xFileControl(id, op, pArg); |
dan | 6f2f19a | 2012-01-10 16:56:39 +0000 | [diff] [blame] | 115 | } |
drh | c02372c | 2012-01-10 17:59:59 +0000 | [diff] [blame] | 116 | |
danielk1977 | bf26097 | 2008-01-22 11:50:13 +0000 | [diff] [blame] | 117 | int sqlite3OsSectorSize(sqlite3_file *id){ |
| 118 | int (*xSectorSize)(sqlite3_file*) = id->pMethods->xSectorSize; |
| 119 | return (xSectorSize ? xSectorSize(id) : SQLITE_DEFAULT_SECTOR_SIZE); |
| 120 | } |
| 121 | int sqlite3OsDeviceCharacteristics(sqlite3_file *id){ |
| 122 | return id->pMethods->xDeviceCharacteristics(id); |
| 123 | } |
drh | 73b64e4 | 2010-05-30 19:55:15 +0000 | [diff] [blame] | 124 | int sqlite3OsShmLock(sqlite3_file *id, int offset, int n, int flags){ |
| 125 | return id->pMethods->xShmLock(id, offset, n, flags); |
drh | d9e5c4f | 2010-05-12 18:01:39 +0000 | [diff] [blame] | 126 | } |
drh | 286a288 | 2010-05-20 23:51:06 +0000 | [diff] [blame] | 127 | void sqlite3OsShmBarrier(sqlite3_file *id){ |
| 128 | id->pMethods->xShmBarrier(id); |
| 129 | } |
drh | e11fedc | 2010-07-14 00:14:30 +0000 | [diff] [blame] | 130 | int sqlite3OsShmUnmap(sqlite3_file *id, int deleteFlag){ |
dan | da9fe0c | 2010-07-13 18:44:03 +0000 | [diff] [blame] | 131 | return id->pMethods->xShmUnmap(id, deleteFlag); |
drh | d9e5c4f | 2010-05-12 18:01:39 +0000 | [diff] [blame] | 132 | } |
dan | 1880191 | 2010-06-14 14:07:50 +0000 | [diff] [blame] | 133 | int sqlite3OsShmMap( |
dan | da9fe0c | 2010-07-13 18:44:03 +0000 | [diff] [blame] | 134 | sqlite3_file *id, /* Database file handle */ |
| 135 | int iPage, |
| 136 | int pgsz, |
| 137 | int bExtend, /* True to extend file if necessary */ |
| 138 | void volatile **pp /* OUT: Pointer to mapping */ |
dan | 13a3cb8 | 2010-06-11 19:04:21 +0000 | [diff] [blame] | 139 | ){ |
mistachkin | 6c3c1a0 | 2011-11-12 03:17:40 +0000 | [diff] [blame] | 140 | DO_OS_MALLOC_TEST(id); |
dan | da9fe0c | 2010-07-13 18:44:03 +0000 | [diff] [blame] | 141 | return id->pMethods->xShmMap(id, iPage, pgsz, bExtend, pp); |
dan | 13a3cb8 | 2010-06-11 19:04:21 +0000 | [diff] [blame] | 142 | } |
drh | 3f45902 | 2006-01-07 16:06:07 +0000 | [diff] [blame] | 143 | |
drh | d677b3d | 2007-08-20 22:48:41 +0000 | [diff] [blame] | 144 | /* |
| 145 | ** The next group of routines are convenience wrappers around the |
| 146 | ** VFS methods. |
| 147 | */ |
danielk1977 | b4b4741 | 2007-08-17 15:53:36 +0000 | [diff] [blame] | 148 | int sqlite3OsOpen( |
| 149 | sqlite3_vfs *pVfs, |
| 150 | const char *zPath, |
| 151 | sqlite3_file *pFile, |
| 152 | int flags, |
| 153 | int *pFlagsOut |
| 154 | ){ |
drh | 072db2f | 2009-03-25 14:24:41 +0000 | [diff] [blame] | 155 | int rc; |
danielk1977 | b5a1920 | 2009-07-27 11:41:20 +0000 | [diff] [blame] | 156 | DO_OS_MALLOC_TEST(0); |
dan | 44659c9 | 2011-12-30 05:08:41 +0000 | [diff] [blame] | 157 | /* 0x87f7f is a mask of SQLITE_OPEN_ flags that are valid to be passed |
drh | f1f1268 | 2009-09-09 14:17:52 +0000 | [diff] [blame] | 158 | ** down into the VFS layer. Some SQLITE_OPEN_ flags (for example, |
| 159 | ** SQLITE_OPEN_FULLMUTEX or SQLITE_OPEN_SHAREDCACHE) are blocked before |
| 160 | ** reaching the VFS. */ |
drh | 877eeb3 | 2011-07-20 17:13:30 +0000 | [diff] [blame] | 161 | rc = pVfs->xOpen(pVfs, zPath, pFile, flags & 0x87f7f, pFlagsOut); |
drh | 072db2f | 2009-03-25 14:24:41 +0000 | [diff] [blame] | 162 | assert( rc==SQLITE_OK || pFile->pMethods==0 ); |
| 163 | return rc; |
drh | 3f45902 | 2006-01-07 16:06:07 +0000 | [diff] [blame] | 164 | } |
danielk1977 | fee2d25 | 2007-08-18 10:59:19 +0000 | [diff] [blame] | 165 | int sqlite3OsDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){ |
mistachkin | 6c3c1a0 | 2011-11-12 03:17:40 +0000 | [diff] [blame] | 166 | DO_OS_MALLOC_TEST(0); |
drh | e349519 | 2012-01-05 16:07:30 +0000 | [diff] [blame] | 167 | assert( dirSync==0 || dirSync==1 ); |
drh | 153c62c | 2007-08-24 03:51:33 +0000 | [diff] [blame] | 168 | return pVfs->xDelete(pVfs, zPath, dirSync); |
danielk1977 | b4b4741 | 2007-08-17 15:53:36 +0000 | [diff] [blame] | 169 | } |
danielk1977 | 861f745 | 2008-06-05 11:39:11 +0000 | [diff] [blame] | 170 | int sqlite3OsAccess( |
| 171 | sqlite3_vfs *pVfs, |
| 172 | const char *zPath, |
| 173 | int flags, |
| 174 | int *pResOut |
| 175 | ){ |
danielk1977 | b5a1920 | 2009-07-27 11:41:20 +0000 | [diff] [blame] | 176 | DO_OS_MALLOC_TEST(0); |
danielk1977 | 861f745 | 2008-06-05 11:39:11 +0000 | [diff] [blame] | 177 | return pVfs->xAccess(pVfs, zPath, flags, pResOut); |
danielk1977 | b4b4741 | 2007-08-17 15:53:36 +0000 | [diff] [blame] | 178 | } |
danielk1977 | adfb9b0 | 2007-09-17 07:02:56 +0000 | [diff] [blame] | 179 | int sqlite3OsFullPathname( |
| 180 | sqlite3_vfs *pVfs, |
| 181 | const char *zPath, |
| 182 | int nPathOut, |
| 183 | char *zPathOut |
| 184 | ){ |
mistachkin | 6c3c1a0 | 2011-11-12 03:17:40 +0000 | [diff] [blame] | 185 | DO_OS_MALLOC_TEST(0); |
drh | 68ff78b | 2009-11-16 23:36:33 +0000 | [diff] [blame] | 186 | zPathOut[0] = 0; |
danielk1977 | adfb9b0 | 2007-09-17 07:02:56 +0000 | [diff] [blame] | 187 | return pVfs->xFullPathname(pVfs, zPath, nPathOut, zPathOut); |
danielk1977 | b4b4741 | 2007-08-17 15:53:36 +0000 | [diff] [blame] | 188 | } |
shane | 75998ab | 2008-05-29 02:52:59 +0000 | [diff] [blame] | 189 | #ifndef SQLITE_OMIT_LOAD_EXTENSION |
danielk1977 | b4b4741 | 2007-08-17 15:53:36 +0000 | [diff] [blame] | 190 | void *sqlite3OsDlOpen(sqlite3_vfs *pVfs, const char *zPath){ |
drh | 153c62c | 2007-08-24 03:51:33 +0000 | [diff] [blame] | 191 | return pVfs->xDlOpen(pVfs, zPath); |
danielk1977 | b4b4741 | 2007-08-17 15:53:36 +0000 | [diff] [blame] | 192 | } |
| 193 | void sqlite3OsDlError(sqlite3_vfs *pVfs, int nByte, char *zBufOut){ |
drh | 153c62c | 2007-08-24 03:51:33 +0000 | [diff] [blame] | 194 | pVfs->xDlError(pVfs, nByte, zBufOut); |
danielk1977 | b4b4741 | 2007-08-17 15:53:36 +0000 | [diff] [blame] | 195 | } |
drh | 1875f7a | 2008-12-08 18:19:17 +0000 | [diff] [blame] | 196 | void (*sqlite3OsDlSym(sqlite3_vfs *pVfs, void *pHdle, const char *zSym))(void){ |
| 197 | return pVfs->xDlSym(pVfs, pHdle, zSym); |
danielk1977 | b4b4741 | 2007-08-17 15:53:36 +0000 | [diff] [blame] | 198 | } |
| 199 | void sqlite3OsDlClose(sqlite3_vfs *pVfs, void *pHandle){ |
drh | 153c62c | 2007-08-24 03:51:33 +0000 | [diff] [blame] | 200 | pVfs->xDlClose(pVfs, pHandle); |
danielk1977 | b4b4741 | 2007-08-17 15:53:36 +0000 | [diff] [blame] | 201 | } |
shane | 75998ab | 2008-05-29 02:52:59 +0000 | [diff] [blame] | 202 | #endif /* SQLITE_OMIT_LOAD_EXTENSION */ |
danielk1977 | b4b4741 | 2007-08-17 15:53:36 +0000 | [diff] [blame] | 203 | int sqlite3OsRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){ |
drh | 153c62c | 2007-08-24 03:51:33 +0000 | [diff] [blame] | 204 | return pVfs->xRandomness(pVfs, nByte, zBufOut); |
danielk1977 | b4b4741 | 2007-08-17 15:53:36 +0000 | [diff] [blame] | 205 | } |
| 206 | int sqlite3OsSleep(sqlite3_vfs *pVfs, int nMicro){ |
drh | 153c62c | 2007-08-24 03:51:33 +0000 | [diff] [blame] | 207 | return pVfs->xSleep(pVfs, nMicro); |
danielk1977 | b4b4741 | 2007-08-17 15:53:36 +0000 | [diff] [blame] | 208 | } |
drh | b7e8ea2 | 2010-05-03 14:32:30 +0000 | [diff] [blame] | 209 | int sqlite3OsCurrentTimeInt64(sqlite3_vfs *pVfs, sqlite3_int64 *pTimeOut){ |
| 210 | int rc; |
drh | bfccdaf | 2010-09-01 19:29:57 +0000 | [diff] [blame] | 211 | /* IMPLEMENTATION-OF: R-49045-42493 SQLite will use the xCurrentTimeInt64() |
| 212 | ** method to get the current date and time if that method is available |
| 213 | ** (if iVersion is 2 or greater and the function pointer is not NULL) and |
| 214 | ** will fall back to xCurrentTime() if xCurrentTimeInt64() is |
| 215 | ** unavailable. |
| 216 | */ |
drh | b7e8ea2 | 2010-05-03 14:32:30 +0000 | [diff] [blame] | 217 | if( pVfs->iVersion>=2 && pVfs->xCurrentTimeInt64 ){ |
| 218 | rc = pVfs->xCurrentTimeInt64(pVfs, pTimeOut); |
| 219 | }else{ |
| 220 | double r; |
| 221 | rc = pVfs->xCurrentTime(pVfs, &r); |
| 222 | *pTimeOut = (sqlite3_int64)(r*86400000.0); |
| 223 | } |
| 224 | return rc; |
danielk1977 | b4b4741 | 2007-08-17 15:53:36 +0000 | [diff] [blame] | 225 | } |
| 226 | |
| 227 | int sqlite3OsOpenMalloc( |
| 228 | sqlite3_vfs *pVfs, |
| 229 | const char *zFile, |
| 230 | sqlite3_file **ppFile, |
danielk1977 | 967a4a1 | 2007-08-20 14:23:44 +0000 | [diff] [blame] | 231 | int flags, |
| 232 | int *pOutFlags |
danielk1977 | b4b4741 | 2007-08-17 15:53:36 +0000 | [diff] [blame] | 233 | ){ |
| 234 | int rc = SQLITE_NOMEM; |
| 235 | sqlite3_file *pFile; |
mistachkin | f1c40f4 | 2011-09-17 15:34:50 +0000 | [diff] [blame] | 236 | pFile = (sqlite3_file *)sqlite3MallocZero(pVfs->szOsFile); |
danielk1977 | b4b4741 | 2007-08-17 15:53:36 +0000 | [diff] [blame] | 237 | if( pFile ){ |
danielk1977 | 967a4a1 | 2007-08-20 14:23:44 +0000 | [diff] [blame] | 238 | rc = sqlite3OsOpen(pVfs, zFile, pFile, flags, pOutFlags); |
danielk1977 | b4b4741 | 2007-08-17 15:53:36 +0000 | [diff] [blame] | 239 | if( rc!=SQLITE_OK ){ |
| 240 | sqlite3_free(pFile); |
| 241 | }else{ |
| 242 | *ppFile = pFile; |
| 243 | } |
| 244 | } |
| 245 | return rc; |
| 246 | } |
| 247 | int sqlite3OsCloseFree(sqlite3_file *pFile){ |
| 248 | int rc = SQLITE_OK; |
mlcreech | 4003298 | 2008-04-08 03:09:22 +0000 | [diff] [blame] | 249 | assert( pFile ); |
| 250 | rc = sqlite3OsClose(pFile); |
| 251 | sqlite3_free(pFile); |
danielk1977 | b4b4741 | 2007-08-17 15:53:36 +0000 | [diff] [blame] | 252 | return rc; |
| 253 | } |
| 254 | |
drh | d677b3d | 2007-08-20 22:48:41 +0000 | [diff] [blame] | 255 | /* |
dan | 3d6e060 | 2009-08-17 15:52:25 +0000 | [diff] [blame] | 256 | ** This function is a wrapper around the OS specific implementation of |
| 257 | ** sqlite3_os_init(). The purpose of the wrapper is to provide the |
| 258 | ** ability to simulate a malloc failure, so that the handling of an |
| 259 | ** error in sqlite3_os_init() by the upper layers can be tested. |
| 260 | */ |
| 261 | int sqlite3OsInit(void){ |
drh | adad77a | 2009-08-17 16:01:11 +0000 | [diff] [blame] | 262 | void *p = sqlite3_malloc(10); |
| 263 | if( p==0 ) return SQLITE_NOMEM; |
| 264 | sqlite3_free(p); |
dan | 3d6e060 | 2009-08-17 15:52:25 +0000 | [diff] [blame] | 265 | return sqlite3_os_init(); |
| 266 | } |
| 267 | |
| 268 | /* |
danielk1977 | c0fa4c5 | 2008-06-25 17:19:00 +0000 | [diff] [blame] | 269 | ** The list of all registered VFS implementations. |
drh | d677b3d | 2007-08-20 22:48:41 +0000 | [diff] [blame] | 270 | */ |
danielk1977 | 95e80d6 | 2008-09-02 17:18:51 +0000 | [diff] [blame] | 271 | static sqlite3_vfs * SQLITE_WSD vfsList = 0; |
danielk1977 | 5c8f858 | 2008-09-02 10:22:00 +0000 | [diff] [blame] | 272 | #define vfsList GLOBAL(sqlite3_vfs *, vfsList) |
drh | d677b3d | 2007-08-20 22:48:41 +0000 | [diff] [blame] | 273 | |
| 274 | /* |
| 275 | ** Locate a VFS by name. If no name is given, simply return the |
| 276 | ** first VFS on the list. |
| 277 | */ |
| 278 | sqlite3_vfs *sqlite3_vfs_find(const char *zVfs){ |
drh | a418980 | 2008-06-19 16:07:07 +0000 | [diff] [blame] | 279 | sqlite3_vfs *pVfs = 0; |
drh | 18472fa | 2008-10-07 15:25:48 +0000 | [diff] [blame] | 280 | #if SQLITE_THREADSAFE |
drh | 40257ff | 2008-06-13 18:24:27 +0000 | [diff] [blame] | 281 | sqlite3_mutex *mutex; |
| 282 | #endif |
| 283 | #ifndef SQLITE_OMIT_AUTOINIT |
| 284 | int rc = sqlite3_initialize(); |
| 285 | if( rc ) return 0; |
| 286 | #endif |
drh | 18472fa | 2008-10-07 15:25:48 +0000 | [diff] [blame] | 287 | #if SQLITE_THREADSAFE |
danielk1977 | 59f8c08 | 2008-06-18 17:09:10 +0000 | [diff] [blame] | 288 | mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER); |
drh | 7e8b848 | 2008-01-23 03:03:05 +0000 | [diff] [blame] | 289 | #endif |
drh | d677b3d | 2007-08-20 22:48:41 +0000 | [diff] [blame] | 290 | sqlite3_mutex_enter(mutex); |
| 291 | for(pVfs = vfsList; pVfs; pVfs=pVfs->pNext){ |
| 292 | if( zVfs==0 ) break; |
| 293 | if( strcmp(zVfs, pVfs->zName)==0 ) break; |
| 294 | } |
drh | d677b3d | 2007-08-20 22:48:41 +0000 | [diff] [blame] | 295 | sqlite3_mutex_leave(mutex); |
| 296 | return pVfs; |
danielk1977 | b4b4741 | 2007-08-17 15:53:36 +0000 | [diff] [blame] | 297 | } |
| 298 | |
drh | d677b3d | 2007-08-20 22:48:41 +0000 | [diff] [blame] | 299 | /* |
drh | d677b3d | 2007-08-20 22:48:41 +0000 | [diff] [blame] | 300 | ** Unlink a VFS from the linked list |
| 301 | */ |
| 302 | static void vfsUnlink(sqlite3_vfs *pVfs){ |
danielk1977 | 59f8c08 | 2008-06-18 17:09:10 +0000 | [diff] [blame] | 303 | assert( sqlite3_mutex_held(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER)) ); |
drh | 9bc5449 | 2007-10-23 14:49:59 +0000 | [diff] [blame] | 304 | if( pVfs==0 ){ |
| 305 | /* No-op */ |
| 306 | }else if( vfsList==pVfs ){ |
drh | d677b3d | 2007-08-20 22:48:41 +0000 | [diff] [blame] | 307 | vfsList = pVfs->pNext; |
drh | 9bc5449 | 2007-10-23 14:49:59 +0000 | [diff] [blame] | 308 | }else if( vfsList ){ |
drh | d677b3d | 2007-08-20 22:48:41 +0000 | [diff] [blame] | 309 | sqlite3_vfs *p = vfsList; |
| 310 | while( p->pNext && p->pNext!=pVfs ){ |
| 311 | p = p->pNext; |
| 312 | } |
| 313 | if( p->pNext==pVfs ){ |
| 314 | p->pNext = pVfs->pNext; |
| 315 | } |
| 316 | } |
| 317 | } |
| 318 | |
| 319 | /* |
| 320 | ** Register a VFS with the system. It is harmless to register the same |
| 321 | ** VFS multiple times. The new VFS becomes the default if makeDflt is |
| 322 | ** true. |
| 323 | */ |
| 324 | int sqlite3_vfs_register(sqlite3_vfs *pVfs, int makeDflt){ |
drh | 30ddce6 | 2011-10-15 00:16:30 +0000 | [diff] [blame] | 325 | MUTEX_LOGIC(sqlite3_mutex *mutex;) |
drh | 40257ff | 2008-06-13 18:24:27 +0000 | [diff] [blame] | 326 | #ifndef SQLITE_OMIT_AUTOINIT |
| 327 | int rc = sqlite3_initialize(); |
| 328 | if( rc ) return rc; |
| 329 | #endif |
drh | 30ddce6 | 2011-10-15 00:16:30 +0000 | [diff] [blame] | 330 | MUTEX_LOGIC( mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER); ) |
drh | d677b3d | 2007-08-20 22:48:41 +0000 | [diff] [blame] | 331 | sqlite3_mutex_enter(mutex); |
| 332 | vfsUnlink(pVfs); |
| 333 | if( makeDflt || vfsList==0 ){ |
| 334 | pVfs->pNext = vfsList; |
| 335 | vfsList = pVfs; |
| 336 | }else{ |
| 337 | pVfs->pNext = vfsList->pNext; |
danielk1977 | 95c8a54 | 2007-09-01 06:51:27 +0000 | [diff] [blame] | 338 | vfsList->pNext = pVfs; |
drh | d677b3d | 2007-08-20 22:48:41 +0000 | [diff] [blame] | 339 | } |
danielk1977 | f1da17a | 2007-08-21 13:07:46 +0000 | [diff] [blame] | 340 | assert(vfsList); |
drh | d677b3d | 2007-08-20 22:48:41 +0000 | [diff] [blame] | 341 | sqlite3_mutex_leave(mutex); |
| 342 | return SQLITE_OK; |
| 343 | } |
| 344 | |
| 345 | /* |
| 346 | ** Unregister a VFS so that it is no longer accessible. |
| 347 | */ |
| 348 | int sqlite3_vfs_unregister(sqlite3_vfs *pVfs){ |
drh | 18472fa | 2008-10-07 15:25:48 +0000 | [diff] [blame] | 349 | #if SQLITE_THREADSAFE |
danielk1977 | 59f8c08 | 2008-06-18 17:09:10 +0000 | [diff] [blame] | 350 | sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER); |
drh | 7e8b848 | 2008-01-23 03:03:05 +0000 | [diff] [blame] | 351 | #endif |
drh | d677b3d | 2007-08-20 22:48:41 +0000 | [diff] [blame] | 352 | sqlite3_mutex_enter(mutex); |
| 353 | vfsUnlink(pVfs); |
| 354 | sqlite3_mutex_leave(mutex); |
| 355 | return SQLITE_OK; |
| 356 | } |