Annotation of embedaddon/sqlite3/src/test_devsym.c, revision 1.1
1.1 ! misho 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
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to test_devsym.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / src