| OLD | NEW |
|---|
| (Empty) |
| 1 /* | |
| 2 ** 2008 Jan 22 | |
| 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 code that modified the OS layer in order to simulate | |
| 14 ** different device types (by overriding the return values of the | |
| 15 ** xDeviceCharacteristics() and xSectorSize() methods). | |
| 16 */ | |
| 17 #if SQLITE_TEST /* This file is used for testing only */ | |
| 18 | |
| 19 #include "sqlite3.h" | |
| 20 #include "sqliteInt.h" | |
| 21 | |
| 22 /* | |
| 23 ** Maximum pathname length supported by the devsym backend. | |
| 24 */ | |
| 25 #define DEVSYM_MAX_PATHNAME 512 | |
| 26 | |
| 27 /* | |
| 28 ** Name used to identify this VFS. | |
| 29 */ | |
| 30 #define DEVSYM_VFS_NAME "devsym" | |
| 31 | |
| 32 typedef struct devsym_file devsym_file; | |
| 33 struct devsym_file { | |
| 34 sqlite3_file base; | |
| 35 sqlite3_file *pReal; | |
| 36 }; | |
| 37 | |
| 38 /* | |
| 39 ** Method declarations for devsym_file. | |
| 40 */ | |
| 41 static int devsymClose(sqlite3_file*); | |
| 42 static int devsymRead(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst); | |
| 43 static int devsymWrite(sqlite3_file*,const void*,int iAmt, sqlite3_int64 iOfst); | |
| 44 static int devsymTruncate(sqlite3_file*, sqlite3_int64 size); | |
| 45 static int devsymSync(sqlite3_file*, int flags); | |
| 46 static int devsymFileSize(sqlite3_file*, sqlite3_int64 *pSize); | |
| 47 static int devsymLock(sqlite3_file*, int); | |
| 48 static int devsymUnlock(sqlite3_file*, int); | |
| 49 static int devsymCheckReservedLock(sqlite3_file*, int *); | |
| 50 static int devsymFileControl(sqlite3_file*, int op, void *pArg); | |
| 51 static int devsymSectorSize(sqlite3_file*); | |
| 52 static int devsymDeviceCharacteristics(sqlite3_file*); | |
| 53 static int devsymShmLock(sqlite3_file*,int,int,int); | |
| 54 static int devsymShmMap(sqlite3_file*,int,int,int, void volatile **); | |
| 55 static void devsymShmBarrier(sqlite3_file*); | |
| 56 static int devsymShmUnmap(sqlite3_file*,int); | |
| 57 | |
| 58 /* | |
| 59 ** Method declarations for devsym_vfs. | |
| 60 */ | |
| 61 static int devsymOpen(sqlite3_vfs*, const char *, sqlite3_file*, int , int *); | |
| 62 static int devsymDelete(sqlite3_vfs*, const char *zName, int syncDir); | |
| 63 static int devsymAccess(sqlite3_vfs*, const char *zName, int flags, int *); | |
| 64 static int devsymFullPathname(sqlite3_vfs*, const char *zName, int, char *zOut); | |
| 65 #ifndef SQLITE_OMIT_LOAD_EXTENSION | |
| 66 static void *devsymDlOpen(sqlite3_vfs*, const char *zFilename); | |
| 67 static void devsymDlError(sqlite3_vfs*, int nByte, char *zErrMsg); | |
| 68 static void (*devsymDlSym(sqlite3_vfs*,void*, const char *zSymbol))(void); | |
| 69 static void devsymDlClose(sqlite3_vfs*, void*); | |
| 70 #endif /* SQLITE_OMIT_LOAD_EXTENSION */ | |
| 71 static int devsymRandomness(sqlite3_vfs*, int nByte, char *zOut); | |
| 72 static int devsymSleep(sqlite3_vfs*, int microseconds); | |
| 73 static int devsymCurrentTime(sqlite3_vfs*, double*); | |
| 74 | |
| 75 static sqlite3_vfs devsym_vfs = { | |
| 76 2, /* iVersion */ | |
| 77 sizeof(devsym_file), /* szOsFile */ | |
| 78 DEVSYM_MAX_PATHNAME, /* mxPathname */ | |
| 79 0, /* pNext */ | |
| 80 DEVSYM_VFS_NAME, /* zName */ | |
| 81 0, /* pAppData */ | |
| 82 devsymOpen, /* xOpen */ | |
| 83 devsymDelete, /* xDelete */ | |
| 84 devsymAccess, /* xAccess */ | |
| 85 devsymFullPathname, /* xFullPathname */ | |
| 86 #ifndef SQLITE_OMIT_LOAD_EXTENSION | |
| 87 devsymDlOpen, /* xDlOpen */ | |
| 88 devsymDlError, /* xDlError */ | |
| 89 devsymDlSym, /* xDlSym */ | |
| 90 devsymDlClose, /* xDlClose */ | |
| 91 #else | |
| 92 0, /* xDlOpen */ | |
| 93 0, /* xDlError */ | |
| 94 0, /* xDlSym */ | |
| 95 0, /* xDlClose */ | |
| 96 #endif /* SQLITE_OMIT_LOAD_EXTENSION */ | |
| 97 devsymRandomness, /* xRandomness */ | |
| 98 devsymSleep, /* xSleep */ | |
| 99 devsymCurrentTime, /* xCurrentTime */ | |
| 100 0, /* xGetLastError */ | |
| 101 0 /* xCurrentTimeInt64 */ | |
| 102 }; | |
| 103 | |
| 104 static sqlite3_io_methods devsym_io_methods = { | |
| 105 2, /* iVersion */ | |
| 106 devsymClose, /* xClose */ | |
| 107 devsymRead, /* xRead */ | |
| 108 devsymWrite, /* xWrite */ | |
| 109 devsymTruncate, /* xTruncate */ | |
| 110 devsymSync, /* xSync */ | |
| 111 devsymFileSize, /* xFileSize */ | |
| 112 devsymLock, /* xLock */ | |
| 113 devsymUnlock, /* xUnlock */ | |
| 114 devsymCheckReservedLock, /* xCheckReservedLock */ | |
| 115 devsymFileControl, /* xFileControl */ | |
| 116 devsymSectorSize, /* xSectorSize */ | |
| 117 devsymDeviceCharacteristics, /* xDeviceCharacteristics */ | |
| 118 devsymShmMap, /* xShmMap */ | |
| 119 devsymShmLock, /* xShmLock */ | |
| 120 devsymShmBarrier, /* xShmBarrier */ | |
| 121 devsymShmUnmap /* xShmUnmap */ | |
| 122 }; | |
| 123 | |
| 124 struct DevsymGlobal { | |
| 125 sqlite3_vfs *pVfs; | |
| 126 int iDeviceChar; | |
| 127 int iSectorSize; | |
| 128 }; | |
| 129 struct DevsymGlobal g = {0, 0, 512}; | |
| 130 | |
| 131 /* | |
| 132 ** Close an devsym-file. | |
| 133 */ | |
| 134 static int devsymClose(sqlite3_file *pFile){ | |
| 135 devsym_file *p = (devsym_file *)pFile; | |
| 136 return sqlite3OsClose(p->pReal); | |
| 137 } | |
| 138 | |
| 139 /* | |
| 140 ** Read data from an devsym-file. | |
| 141 */ | |
| 142 static int devsymRead( | |
| 143 sqlite3_file *pFile, | |
| 144 void *zBuf, | |
| 145 int iAmt, | |
| 146 sqlite_int64 iOfst | |
| 147 ){ | |
| 148 devsym_file *p = (devsym_file *)pFile; | |
| 149 return sqlite3OsRead(p->pReal, zBuf, iAmt, iOfst); | |
| 150 } | |
| 151 | |
| 152 /* | |
| 153 ** Write data to an devsym-file. | |
| 154 */ | |
| 155 static int devsymWrite( | |
| 156 sqlite3_file *pFile, | |
| 157 const void *zBuf, | |
| 158 int iAmt, | |
| 159 sqlite_int64 iOfst | |
| 160 ){ | |
| 161 devsym_file *p = (devsym_file *)pFile; | |
| 162 return sqlite3OsWrite(p->pReal, zBuf, iAmt, iOfst); | |
| 163 } | |
| 164 | |
| 165 /* | |
| 166 ** Truncate an devsym-file. | |
| 167 */ | |
| 168 static int devsymTruncate(sqlite3_file *pFile, sqlite_int64 size){ | |
| 169 devsym_file *p = (devsym_file *)pFile; | |
| 170 return sqlite3OsTruncate(p->pReal, size); | |
| 171 } | |
| 172 | |
| 173 /* | |
| 174 ** Sync an devsym-file. | |
| 175 */ | |
| 176 static int devsymSync(sqlite3_file *pFile, int flags){ | |
| 177 devsym_file *p = (devsym_file *)pFile; | |
| 178 return sqlite3OsSync(p->pReal, flags); | |
| 179 } | |
| 180 | |
| 181 /* | |
| 182 ** Return the current file-size of an devsym-file. | |
| 183 */ | |
| 184 static int devsymFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){ | |
| 185 devsym_file *p = (devsym_file *)pFile; | |
| 186 return sqlite3OsFileSize(p->pReal, pSize); | |
| 187 } | |
| 188 | |
| 189 /* | |
| 190 ** Lock an devsym-file. | |
| 191 */ | |
| 192 static int devsymLock(sqlite3_file *pFile, int eLock){ | |
| 193 devsym_file *p = (devsym_file *)pFile; | |
| 194 return sqlite3OsLock(p->pReal, eLock); | |
| 195 } | |
| 196 | |
| 197 /* | |
| 198 ** Unlock an devsym-file. | |
| 199 */ | |
| 200 static int devsymUnlock(sqlite3_file *pFile, int eLock){ | |
| 201 devsym_file *p = (devsym_file *)pFile; | |
| 202 return sqlite3OsUnlock(p->pReal, eLock); | |
| 203 } | |
| 204 | |
| 205 /* | |
| 206 ** Check if another file-handle holds a RESERVED lock on an devsym-file. | |
| 207 */ | |
| 208 static int devsymCheckReservedLock(sqlite3_file *pFile, int *pResOut){ | |
| 209 devsym_file *p = (devsym_file *)pFile; | |
| 210 return sqlite3OsCheckReservedLock(p->pReal, pResOut); | |
| 211 } | |
| 212 | |
| 213 /* | |
| 214 ** File control method. For custom operations on an devsym-file. | |
| 215 */ | |
| 216 static int devsymFileControl(sqlite3_file *pFile, int op, void *pArg){ | |
| 217 devsym_file *p = (devsym_file *)pFile; | |
| 218 return sqlite3OsFileControl(p->pReal, op, pArg); | |
| 219 } | |
| 220 | |
| 221 /* | |
| 222 ** Return the sector-size in bytes for an devsym-file. | |
| 223 */ | |
| 224 static int devsymSectorSize(sqlite3_file *pFile){ | |
| 225 return g.iSectorSize; | |
| 226 } | |
| 227 | |
| 228 /* | |
| 229 ** Return the device characteristic flags supported by an devsym-file. | |
| 230 */ | |
| 231 static int devsymDeviceCharacteristics(sqlite3_file *pFile){ | |
| 232 return g.iDeviceChar; | |
| 233 } | |
| 234 | |
| 235 /* | |
| 236 ** Shared-memory methods are all pass-thrus. | |
| 237 */ | |
| 238 static int devsymShmLock(sqlite3_file *pFile, int ofst, int n, int flags){ | |
| 239 devsym_file *p = (devsym_file *)pFile; | |
| 240 return sqlite3OsShmLock(p->pReal, ofst, n, flags); | |
| 241 } | |
| 242 static int devsymShmMap( | |
| 243 sqlite3_file *pFile, | |
| 244 int iRegion, | |
| 245 int szRegion, | |
| 246 int isWrite, | |
| 247 void volatile **pp | |
| 248 ){ | |
| 249 devsym_file *p = (devsym_file *)pFile; | |
| 250 return sqlite3OsShmMap(p->pReal, iRegion, szRegion, isWrite, pp); | |
| 251 } | |
| 252 static void devsymShmBarrier(sqlite3_file *pFile){ | |
| 253 devsym_file *p = (devsym_file *)pFile; | |
| 254 sqlite3OsShmBarrier(p->pReal); | |
| 255 } | |
| 256 static int devsymShmUnmap(sqlite3_file *pFile, int delFlag){ | |
| 257 devsym_file *p = (devsym_file *)pFile; | |
| 258 return sqlite3OsShmUnmap(p->pReal, delFlag); | |
| 259 } | |
| 260 | |
| 261 | |
| 262 | |
| 263 /* | |
| 264 ** Open an devsym file handle. | |
| 265 */ | |
| 266 static int devsymOpen( | |
| 267 sqlite3_vfs *pVfs, | |
| 268 const char *zName, | |
| 269 sqlite3_file *pFile, | |
| 270 int flags, | |
| 271 int *pOutFlags | |
| 272 ){ | |
| 273 int rc; | |
| 274 devsym_file *p = (devsym_file *)pFile; | |
| 275 p->pReal = (sqlite3_file *)&p[1]; | |
| 276 rc = sqlite3OsOpen(g.pVfs, zName, p->pReal, flags, pOutFlags); | |
| 277 if( p->pReal->pMethods ){ | |
| 278 pFile->pMethods = &devsym_io_methods; | |
| 279 } | |
| 280 return rc; | |
| 281 } | |
| 282 | |
| 283 /* | |
| 284 ** Delete the file located at zPath. If the dirSync argument is true, | |
| 285 ** ensure the file-system modifications are synced to disk before | |
| 286 ** returning. | |
| 287 */ | |
| 288 static int devsymDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){ | |
| 289 return sqlite3OsDelete(g.pVfs, zPath, dirSync); | |
| 290 } | |
| 291 | |
| 292 /* | |
| 293 ** Test for access permissions. Return true if the requested permission | |
| 294 ** is available, or false otherwise. | |
| 295 */ | |
| 296 static int devsymAccess( | |
| 297 sqlite3_vfs *pVfs, | |
| 298 const char *zPath, | |
| 299 int flags, | |
| 300 int *pResOut | |
| 301 ){ | |
| 302 return sqlite3OsAccess(g.pVfs, zPath, flags, pResOut); | |
| 303 } | |
| 304 | |
| 305 /* | |
| 306 ** Populate buffer zOut with the full canonical pathname corresponding | |
| 307 ** to the pathname in zPath. zOut is guaranteed to point to a buffer | |
| 308 ** of at least (DEVSYM_MAX_PATHNAME+1) bytes. | |
| 309 */ | |
| 310 static int devsymFullPathname( | |
| 311 sqlite3_vfs *pVfs, | |
| 312 const char *zPath, | |
| 313 int nOut, | |
| 314 char *zOut | |
| 315 ){ | |
| 316 return sqlite3OsFullPathname(g.pVfs, zPath, nOut, zOut); | |
| 317 } | |
| 318 | |
| 319 #ifndef SQLITE_OMIT_LOAD_EXTENSION | |
| 320 /* | |
| 321 ** Open the dynamic library located at zPath and return a handle. | |
| 322 */ | |
| 323 static void *devsymDlOpen(sqlite3_vfs *pVfs, const char *zPath){ | |
| 324 return sqlite3OsDlOpen(g.pVfs, zPath); | |
| 325 } | |
| 326 | |
| 327 /* | |
| 328 ** Populate the buffer zErrMsg (size nByte bytes) with a human readable | |
| 329 ** utf-8 string describing the most recent error encountered associated | |
| 330 ** with dynamic libraries. | |
| 331 */ | |
| 332 static void devsymDlError(sqlite3_vfs *pVfs, int nByte, char *zErrMsg){ | |
| 333 sqlite3OsDlError(g.pVfs, nByte, zErrMsg); | |
| 334 } | |
| 335 | |
| 336 /* | |
| 337 ** Return a pointer to the symbol zSymbol in the dynamic library pHandle. | |
| 338 */ | |
| 339 static void (*devsymDlSym(sqlite3_vfs *pVfs, void *p, const char *zSym))(void){ | |
| 340 return sqlite3OsDlSym(g.pVfs, p, zSym); | |
| 341 } | |
| 342 | |
| 343 /* | |
| 344 ** Close the dynamic library handle pHandle. | |
| 345 */ | |
| 346 static void devsymDlClose(sqlite3_vfs *pVfs, void *pHandle){ | |
| 347 sqlite3OsDlClose(g.pVfs, pHandle); | |
| 348 } | |
| 349 #endif /* SQLITE_OMIT_LOAD_EXTENSION */ | |
| 350 | |
| 351 /* | |
| 352 ** Populate the buffer pointed to by zBufOut with nByte bytes of | |
| 353 ** random data. | |
| 354 */ | |
| 355 static int devsymRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){ | |
| 356 return sqlite3OsRandomness(g.pVfs, nByte, zBufOut); | |
| 357 } | |
| 358 | |
| 359 /* | |
| 360 ** Sleep for nMicro microseconds. Return the number of microseconds | |
| 361 ** actually slept. | |
| 362 */ | |
| 363 static int devsymSleep(sqlite3_vfs *pVfs, int nMicro){ | |
| 364 return sqlite3OsSleep(g.pVfs, nMicro); | |
| 365 } | |
| 366 | |
| 367 /* | |
| 368 ** Return the current time as a Julian Day number in *pTimeOut. | |
| 369 */ | |
| 370 static int devsymCurrentTime(sqlite3_vfs *pVfs, double *pTimeOut){ | |
| 371 return g.pVfs->xCurrentTime(g.pVfs, pTimeOut); | |
| 372 } | |
| 373 | |
| 374 | |
| 375 /* | |
| 376 ** This procedure registers the devsym vfs with SQLite. If the argument is | |
| 377 ** true, the devsym vfs becomes the new default vfs. It is the only publicly | |
| 378 ** available function in this file. | |
| 379 */ | |
| 380 void devsym_register(int iDeviceChar, int iSectorSize){ | |
| 381 if( g.pVfs==0 ){ | |
| 382 g.pVfs = sqlite3_vfs_find(0); | |
| 383 devsym_vfs.szOsFile += g.pVfs->szOsFile; | |
| 384 sqlite3_vfs_register(&devsym_vfs, 0); | |
| 385 } | |
| 386 if( iDeviceChar>=0 ){ | |
| 387 g.iDeviceChar = iDeviceChar; | |
| 388 }else{ | |
| 389 g.iDeviceChar = 0; | |
| 390 } | |
| 391 if( iSectorSize>=0 ){ | |
| 392 g.iSectorSize = iSectorSize; | |
| 393 }else{ | |
| 394 g.iSectorSize = 512; | |
| 395 } | |
| 396 } | |
| 397 | |
| 398 #endif | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2363173002:
[sqlite] Remove obsolete reference version 3.8.7.4. (Closed)
