Annotation of embedaddon/sqlite3/src/test_devsym.c, revision 1.1.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