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 sqlite3OsClose(p->pReal); 137 return SQLITE_OK; 138 } 139 140 /* 141 ** Read data from an devsym-file. 142 */ 143 static int devsymRead( 144 sqlite3_file *pFile, 145 void *zBuf, 146 int iAmt, 147 sqlite_int64 iOfst 148 ){ 149 devsym_file *p = (devsym_file *)pFile; 150 return sqlite3OsRead(p->pReal, zBuf, iAmt, iOfst); 151 } 152 153 /* 154 ** Write data to an devsym-file. 155 */ 156 static int devsymWrite( 157 sqlite3_file *pFile, 158 const void *zBuf, 159 int iAmt, 160 sqlite_int64 iOfst 161 ){ 162 devsym_file *p = (devsym_file *)pFile; 163 return sqlite3OsWrite(p->pReal, zBuf, iAmt, iOfst); 164 } 165 166 /* 167 ** Truncate an devsym-file. 168 */ 169 static int devsymTruncate(sqlite3_file *pFile, sqlite_int64 size){ 170 devsym_file *p = (devsym_file *)pFile; 171 return sqlite3OsTruncate(p->pReal, size); 172 } 173 174 /* 175 ** Sync an devsym-file. 176 */ 177 static int devsymSync(sqlite3_file *pFile, int flags){ 178 devsym_file *p = (devsym_file *)pFile; 179 return sqlite3OsSync(p->pReal, flags); 180 } 181 182 /* 183 ** Return the current file-size of an devsym-file. 184 */ 185 static int devsymFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){ 186 devsym_file *p = (devsym_file *)pFile; 187 return sqlite3OsFileSize(p->pReal, pSize); 188 } 189 190 /* 191 ** Lock an devsym-file. 192 */ 193 static int devsymLock(sqlite3_file *pFile, int eLock){ 194 devsym_file *p = (devsym_file *)pFile; 195 return sqlite3OsLock(p->pReal, eLock); 196 } 197 198 /* 199 ** Unlock an devsym-file. 200 */ 201 static int devsymUnlock(sqlite3_file *pFile, int eLock){ 202 devsym_file *p = (devsym_file *)pFile; 203 return sqlite3OsUnlock(p->pReal, eLock); 204 } 205 206 /* 207 ** Check if another file-handle holds a RESERVED lock on an devsym-file. 208 */ 209 static int devsymCheckReservedLock(sqlite3_file *pFile, int *pResOut){ 210 devsym_file *p = (devsym_file *)pFile; 211 return sqlite3OsCheckReservedLock(p->pReal, pResOut); 212 } 213 214 /* 215 ** File control method. For custom operations on an devsym-file. 216 */ 217 static int devsymFileControl(sqlite3_file *pFile, int op, void *pArg){ 218 devsym_file *p = (devsym_file *)pFile; 219 return sqlite3OsFileControl(p->pReal, op, pArg); 220 } 221 222 /* 223 ** Return the sector-size in bytes for an devsym-file. 224 */ 225 static int devsymSectorSize(sqlite3_file *pFile){ 226 return g.iSectorSize; 227 } 228 229 /* 230 ** Return the device characteristic flags supported by an devsym-file. 231 */ 232 static int devsymDeviceCharacteristics(sqlite3_file *pFile){ 233 return g.iDeviceChar; 234 } 235 236 /* 237 ** Shared-memory methods are all pass-thrus. 238 */ 239 static int devsymShmLock(sqlite3_file *pFile, int ofst, int n, int flags){ 240 devsym_file *p = (devsym_file *)pFile; 241 return sqlite3OsShmLock(p->pReal, ofst, n, flags); 242 } 243 static int devsymShmMap( 244 sqlite3_file *pFile, 245 int iRegion, 246 int szRegion, 247 int isWrite, 248 void volatile **pp 249 ){ 250 devsym_file *p = (devsym_file *)pFile; 251 return sqlite3OsShmMap(p->pReal, iRegion, szRegion, isWrite, pp); 252 } 253 static void devsymShmBarrier(sqlite3_file *pFile){ 254 devsym_file *p = (devsym_file *)pFile; 255 sqlite3OsShmBarrier(p->pReal); 256 } 257 static int devsymShmUnmap(sqlite3_file *pFile, int delFlag){ 258 devsym_file *p = (devsym_file *)pFile; 259 return sqlite3OsShmUnmap(p->pReal, delFlag); 260 } 261 262 263 264 /* 265 ** Open an devsym file handle. 266 */ 267 static int devsymOpen( 268 sqlite3_vfs *pVfs, 269 const char *zName, 270 sqlite3_file *pFile, 271 int flags, 272 int *pOutFlags 273 ){ 274 int rc; 275 devsym_file *p = (devsym_file *)pFile; 276 p->pReal = (sqlite3_file *)&p[1]; 277 rc = sqlite3OsOpen(g.pVfs, zName, p->pReal, flags, pOutFlags); 278 if( p->pReal->pMethods ){ 279 pFile->pMethods = &devsym_io_methods; 280 } 281 return rc; 282 } 283 284 /* 285 ** Delete the file located at zPath. If the dirSync argument is true, 286 ** ensure the file-system modifications are synced to disk before 287 ** returning. 288 */ 289 static int devsymDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){ 290 return sqlite3OsDelete(g.pVfs, zPath, dirSync); 291 } 292 293 /* 294 ** Test for access permissions. Return true if the requested permission 295 ** is available, or false otherwise. 296 */ 297 static int devsymAccess( 298 sqlite3_vfs *pVfs, 299 const char *zPath, 300 int flags, 301 int *pResOut 302 ){ 303 return sqlite3OsAccess(g.pVfs, zPath, flags, pResOut); 304 } 305 306 /* 307 ** Populate buffer zOut with the full canonical pathname corresponding 308 ** to the pathname in zPath. zOut is guaranteed to point to a buffer 309 ** of at least (DEVSYM_MAX_PATHNAME+1) bytes. 310 */ 311 static int devsymFullPathname( 312 sqlite3_vfs *pVfs, 313 const char *zPath, 314 int nOut, 315 char *zOut 316 ){ 317 return sqlite3OsFullPathname(g.pVfs, zPath, nOut, zOut); 318 } 319 320 #ifndef SQLITE_OMIT_LOAD_EXTENSION 321 /* 322 ** Open the dynamic library located at zPath and return a handle. 323 */ 324 static void *devsymDlOpen(sqlite3_vfs *pVfs, const char *zPath){ 325 return sqlite3OsDlOpen(g.pVfs, zPath); 326 } 327 328 /* 329 ** Populate the buffer zErrMsg (size nByte bytes) with a human readable 330 ** utf-8 string describing the most recent error encountered associated 331 ** with dynamic libraries. 332 */ 333 static void devsymDlError(sqlite3_vfs *pVfs, int nByte, char *zErrMsg){ 334 sqlite3OsDlError(g.pVfs, nByte, zErrMsg); 335 } 336 337 /* 338 ** Return a pointer to the symbol zSymbol in the dynamic library pHandle. 339 */ 340 static void (*devsymDlSym(sqlite3_vfs *pVfs, void *p, const char *zSym))(void){ 341 return sqlite3OsDlSym(g.pVfs, p, zSym); 342 } 343 344 /* 345 ** Close the dynamic library handle pHandle. 346 */ 347 static void devsymDlClose(sqlite3_vfs *pVfs, void *pHandle){ 348 sqlite3OsDlClose(g.pVfs, pHandle); 349 } 350 #endif /* SQLITE_OMIT_LOAD_EXTENSION */ 351 352 /* 353 ** Populate the buffer pointed to by zBufOut with nByte bytes of 354 ** random data. 355 */ 356 static int devsymRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){ 357 return sqlite3OsRandomness(g.pVfs, nByte, zBufOut); 358 } 359 360 /* 361 ** Sleep for nMicro microseconds. Return the number of microseconds 362 ** actually slept. 363 */ 364 static int devsymSleep(sqlite3_vfs *pVfs, int nMicro){ 365 return sqlite3OsSleep(g.pVfs, nMicro); 366 } 367 368 /* 369 ** Return the current time as a Julian Day number in *pTimeOut. 370 */ 371 static int devsymCurrentTime(sqlite3_vfs *pVfs, double *pTimeOut){ 372 return g.pVfs->xCurrentTime(g.pVfs, pTimeOut); 373 } 374 375 376 /* 377 ** This procedure registers the devsym vfs with SQLite. If the argument is 378 ** true, the devsym vfs becomes the new default vfs. It is the only publicly 379 ** available function in this file. 380 */ 381 void devsym_register(int iDeviceChar, int iSectorSize){ 382 if( g.pVfs==0 ){ 383 g.pVfs = sqlite3_vfs_find(0); 384 devsym_vfs.szOsFile += g.pVfs->szOsFile; 385 sqlite3_vfs_register(&devsym_vfs, 0); 386 } 387 if( iDeviceChar>=0 ){ 388 g.iDeviceChar = iDeviceChar; 389 }else{ 390 g.iDeviceChar = 0; 391 } 392 if( iSectorSize>=0 ){ 393 g.iSectorSize = iSectorSize; 394 }else{ 395 g.iSectorSize = 512; 396 } 397 } 398 399 void devsym_unregister(){ 400 sqlite3_vfs_unregister(&devsym_vfs); 401 g.pVfs = 0; 402 g.iDeviceChar = 0; 403 g.iSectorSize = 0; 404 } 405 406 #endif 407