Annotation of embedaddon/sqlite3/src/test_syscall.c, revision 1.1
1.1 ! misho 1: /*
! 2: ** 2011 March 28
! 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: ** The code in this file implements a Tcl interface used to test error
! 14: ** handling in the os_unix.c module. Wrapper functions that support fault
! 15: ** injection are registered as the low-level OS functions using the
! 16: ** xSetSystemCall() method of the VFS. The Tcl interface is as follows:
! 17: **
! 18: **
! 19: ** test_syscall install LIST
! 20: ** Install wrapper functions for all system calls in argument LIST.
! 21: ** LIST must be a list consisting of zero or more of the following
! 22: ** literal values:
! 23: **
! 24: ** open close access getcwd stat fstat
! 25: ** ftruncate fcntl read pread pread64 write
! 26: ** pwrite pwrite64 fchmod fallocate
! 27: **
! 28: ** test_syscall uninstall
! 29: ** Uninstall all wrapper functions.
! 30: **
! 31: ** test_syscall fault ?COUNT PERSIST?
! 32: ** If [test_syscall fault] is invoked without the two arguments, fault
! 33: ** injection is disabled. Otherwise, fault injection is configured to
! 34: ** cause a failure on the COUNT'th next call to a system call with a
! 35: ** wrapper function installed. A COUNT value of 1 means fail the next
! 36: ** system call.
! 37: **
! 38: ** Argument PERSIST is interpreted as a boolean. If true, the all
! 39: ** system calls following the initial failure also fail. Otherwise, only
! 40: ** the single transient failure is injected.
! 41: **
! 42: ** test_syscall errno CALL ERRNO
! 43: ** Set the value that the global "errno" is set to following a fault
! 44: ** in call CALL. Argument CALL must be one of the system call names
! 45: ** listed above (under [test_syscall install]). ERRNO is a symbolic
! 46: ** name (i.e. "EACCES"). Not all errno codes are supported. Add extra
! 47: ** to the aErrno table in function test_syscall_errno() below as
! 48: ** required.
! 49: **
! 50: ** test_syscall reset ?SYSTEM-CALL?
! 51: ** With no argument, this is an alias for the [uninstall] command. However,
! 52: ** this command uses a VFS call of the form:
! 53: **
! 54: ** xSetSystemCall(pVfs, 0, 0);
! 55: **
! 56: ** To restore the default system calls. The [uninstall] command restores
! 57: ** each system call individually by calling (i.e.):
! 58: **
! 59: ** xSetSystemCall(pVfs, "open", 0);
! 60: **
! 61: ** With an argument, this command attempts to reset the system call named
! 62: ** by the parameter using the same method as [uninstall].
! 63: **
! 64: ** test_syscall exists SYSTEM-CALL
! 65: ** Return true if the named system call exists. Or false otherwise.
! 66: **
! 67: ** test_syscall list
! 68: ** Return a list of all system calls. The list is constructed using
! 69: ** the xNextSystemCall() VFS method.
! 70: */
! 71:
! 72: #include "sqlite3.h"
! 73: #include "tcl.h"
! 74: #include <stdlib.h>
! 75: #include <string.h>
! 76: #include <assert.h>
! 77:
! 78: #include "sqliteInt.h"
! 79: #if SQLITE_OS_UNIX
! 80:
! 81: /* From test1.c */
! 82: extern const char *sqlite3TestErrorName(int);
! 83:
! 84: #include <sys/types.h>
! 85: #include <errno.h>
! 86:
! 87: static struct TestSyscallGlobal {
! 88: int bPersist; /* 1 for persistent errors, 0 for transient */
! 89: int nCount; /* Fail after this many more calls */
! 90: int nFail; /* Number of failures that have occurred */
! 91: } gSyscall = { 0, 0 };
! 92:
! 93: static int ts_open(const char *, int, int);
! 94: static int ts_close(int fd);
! 95: static int ts_access(const char *zPath, int mode);
! 96: static char *ts_getcwd(char *zPath, size_t nPath);
! 97: static int ts_stat(const char *zPath, struct stat *p);
! 98: static int ts_fstat(int fd, struct stat *p);
! 99: static int ts_ftruncate(int fd, off_t n);
! 100: static int ts_fcntl(int fd, int cmd, ... );
! 101: static int ts_read(int fd, void *aBuf, size_t nBuf);
! 102: static int ts_pread(int fd, void *aBuf, size_t nBuf, off_t off);
! 103: static int ts_pread64(int fd, void *aBuf, size_t nBuf, off_t off);
! 104: static int ts_write(int fd, const void *aBuf, size_t nBuf);
! 105: static int ts_pwrite(int fd, const void *aBuf, size_t nBuf, off_t off);
! 106: static int ts_pwrite64(int fd, const void *aBuf, size_t nBuf, off_t off);
! 107: static int ts_fchmod(int fd, mode_t mode);
! 108: static int ts_fallocate(int fd, off_t off, off_t len);
! 109:
! 110:
! 111: struct TestSyscallArray {
! 112: const char *zName;
! 113: sqlite3_syscall_ptr xTest;
! 114: sqlite3_syscall_ptr xOrig;
! 115: int default_errno; /* Default value for errno following errors */
! 116: int custom_errno; /* Current value for errno if error */
! 117: } aSyscall[] = {
! 118: /* 0 */ { "open", (sqlite3_syscall_ptr)ts_open, 0, EACCES, 0 },
! 119: /* 1 */ { "close", (sqlite3_syscall_ptr)ts_close, 0, 0, 0 },
! 120: /* 2 */ { "access", (sqlite3_syscall_ptr)ts_access, 0, 0, 0 },
! 121: /* 3 */ { "getcwd", (sqlite3_syscall_ptr)ts_getcwd, 0, 0, 0 },
! 122: /* 4 */ { "stat", (sqlite3_syscall_ptr)ts_stat, 0, 0, 0 },
! 123: /* 5 */ { "fstat", (sqlite3_syscall_ptr)ts_fstat, 0, 0, 0 },
! 124: /* 6 */ { "ftruncate", (sqlite3_syscall_ptr)ts_ftruncate, 0, EIO, 0 },
! 125: /* 7 */ { "fcntl", (sqlite3_syscall_ptr)ts_fcntl, 0, EACCES, 0 },
! 126: /* 8 */ { "read", (sqlite3_syscall_ptr)ts_read, 0, 0, 0 },
! 127: /* 9 */ { "pread", (sqlite3_syscall_ptr)ts_pread, 0, 0, 0 },
! 128: /* 10 */ { "pread64", (sqlite3_syscall_ptr)ts_pread64, 0, 0, 0 },
! 129: /* 11 */ { "write", (sqlite3_syscall_ptr)ts_write, 0, 0, 0 },
! 130: /* 12 */ { "pwrite", (sqlite3_syscall_ptr)ts_pwrite, 0, 0, 0 },
! 131: /* 13 */ { "pwrite64", (sqlite3_syscall_ptr)ts_pwrite64, 0, 0, 0 },
! 132: /* 14 */ { "fchmod", (sqlite3_syscall_ptr)ts_fchmod, 0, 0, 0 },
! 133: /* 15 */ { "fallocate", (sqlite3_syscall_ptr)ts_fallocate, 0, 0, 0 },
! 134: { 0, 0, 0, 0, 0 }
! 135: };
! 136:
! 137: #define orig_open ((int(*)(const char *, int, int))aSyscall[0].xOrig)
! 138: #define orig_close ((int(*)(int))aSyscall[1].xOrig)
! 139: #define orig_access ((int(*)(const char*,int))aSyscall[2].xOrig)
! 140: #define orig_getcwd ((char*(*)(char*,size_t))aSyscall[3].xOrig)
! 141: #define orig_stat ((int(*)(const char*,struct stat*))aSyscall[4].xOrig)
! 142: #define orig_fstat ((int(*)(int,struct stat*))aSyscall[5].xOrig)
! 143: #define orig_ftruncate ((int(*)(int,off_t))aSyscall[6].xOrig)
! 144: #define orig_fcntl ((int(*)(int,int,...))aSyscall[7].xOrig)
! 145: #define orig_read ((ssize_t(*)(int,void*,size_t))aSyscall[8].xOrig)
! 146: #define orig_pread ((ssize_t(*)(int,void*,size_t,off_t))aSyscall[9].xOrig)
! 147: #define orig_pread64 ((ssize_t(*)(int,void*,size_t,off_t))aSyscall[10].xOrig)
! 148: #define orig_write ((ssize_t(*)(int,const void*,size_t))aSyscall[11].xOrig)
! 149: #define orig_pwrite ((ssize_t(*)(int,const void*,size_t,off_t))\
! 150: aSyscall[12].xOrig)
! 151: #define orig_pwrite64 ((ssize_t(*)(int,const void*,size_t,off_t))\
! 152: aSyscall[13].xOrig)
! 153: #define orig_fchmod ((int(*)(int,mode_t))aSyscall[14].xOrig)
! 154: #define orig_fallocate ((int(*)(int,off_t,off_t))aSyscall[15].xOrig)
! 155:
! 156: /*
! 157: ** This function is called exactly once from within each invocation of a
! 158: ** system call wrapper in this file. It returns 1 if the function should
! 159: ** fail, or 0 if it should succeed.
! 160: */
! 161: static int tsIsFail(void){
! 162: gSyscall.nCount--;
! 163: if( gSyscall.nCount==0 || (gSyscall.nFail && gSyscall.bPersist) ){
! 164: gSyscall.nFail++;
! 165: return 1;
! 166: }
! 167: return 0;
! 168: }
! 169:
! 170: /*
! 171: ** Return the current error-number value for function zFunc. zFunc must be
! 172: ** the name of a system call in the aSyscall[] table.
! 173: **
! 174: ** Usually, the current error-number is the value that errno should be set
! 175: ** to if the named system call fails. The exception is "fallocate". See
! 176: ** comments above the implementation of ts_fallocate() for details.
! 177: */
! 178: static int tsErrno(const char *zFunc){
! 179: int i;
! 180: int nFunc = strlen(zFunc);
! 181: for(i=0; aSyscall[i].zName; i++){
! 182: if( strlen(aSyscall[i].zName)!=nFunc ) continue;
! 183: if( memcmp(aSyscall[i].zName, zFunc, nFunc) ) continue;
! 184: return aSyscall[i].custom_errno;
! 185: }
! 186:
! 187: assert(0);
! 188: return 0;
! 189: }
! 190:
! 191: /*
! 192: ** A wrapper around tsIsFail(). If tsIsFail() returns non-zero, set the
! 193: ** value of errno before returning.
! 194: */
! 195: static int tsIsFailErrno(const char *zFunc){
! 196: if( tsIsFail() ){
! 197: errno = tsErrno(zFunc);
! 198: return 1;
! 199: }
! 200: return 0;
! 201: }
! 202:
! 203: /*
! 204: ** A wrapper around open().
! 205: */
! 206: static int ts_open(const char *zFile, int flags, int mode){
! 207: if( tsIsFailErrno("open") ){
! 208: return -1;
! 209: }
! 210: return orig_open(zFile, flags, mode);
! 211: }
! 212:
! 213: /*
! 214: ** A wrapper around close().
! 215: */
! 216: static int ts_close(int fd){
! 217: if( tsIsFail() ){
! 218: /* Even if simulating an error, close the original file-descriptor.
! 219: ** This is to stop the test process from running out of file-descriptors
! 220: ** when running a long test. If a call to close() appears to fail, SQLite
! 221: ** never attempts to use the file-descriptor afterwards (or even to close
! 222: ** it a second time). */
! 223: orig_close(fd);
! 224: return -1;
! 225: }
! 226: return orig_close(fd);
! 227: }
! 228:
! 229: /*
! 230: ** A wrapper around access().
! 231: */
! 232: static int ts_access(const char *zPath, int mode){
! 233: if( tsIsFail() ){
! 234: return -1;
! 235: }
! 236: return orig_access(zPath, mode);
! 237: }
! 238:
! 239: /*
! 240: ** A wrapper around getcwd().
! 241: */
! 242: static char *ts_getcwd(char *zPath, size_t nPath){
! 243: if( tsIsFail() ){
! 244: return NULL;
! 245: }
! 246: return orig_getcwd(zPath, nPath);
! 247: }
! 248:
! 249: /*
! 250: ** A wrapper around stat().
! 251: */
! 252: static int ts_stat(const char *zPath, struct stat *p){
! 253: if( tsIsFail() ){
! 254: return -1;
! 255: }
! 256: return orig_stat(zPath, p);
! 257: }
! 258:
! 259: /*
! 260: ** A wrapper around fstat().
! 261: */
! 262: static int ts_fstat(int fd, struct stat *p){
! 263: if( tsIsFailErrno("fstat") ){
! 264: return -1;
! 265: }
! 266: return orig_fstat(fd, p);
! 267: }
! 268:
! 269: /*
! 270: ** A wrapper around ftruncate().
! 271: */
! 272: static int ts_ftruncate(int fd, off_t n){
! 273: if( tsIsFailErrno("ftruncate") ){
! 274: return -1;
! 275: }
! 276: return orig_ftruncate(fd, n);
! 277: }
! 278:
! 279: /*
! 280: ** A wrapper around fcntl().
! 281: */
! 282: static int ts_fcntl(int fd, int cmd, ... ){
! 283: va_list ap;
! 284: void *pArg;
! 285: if( tsIsFailErrno("fcntl") ){
! 286: return -1;
! 287: }
! 288: va_start(ap, cmd);
! 289: pArg = va_arg(ap, void *);
! 290: return orig_fcntl(fd, cmd, pArg);
! 291: }
! 292:
! 293: /*
! 294: ** A wrapper around read().
! 295: */
! 296: static int ts_read(int fd, void *aBuf, size_t nBuf){
! 297: if( tsIsFailErrno("read") ){
! 298: return -1;
! 299: }
! 300: return orig_read(fd, aBuf, nBuf);
! 301: }
! 302:
! 303: /*
! 304: ** A wrapper around pread().
! 305: */
! 306: static int ts_pread(int fd, void *aBuf, size_t nBuf, off_t off){
! 307: if( tsIsFailErrno("pread") ){
! 308: return -1;
! 309: }
! 310: return orig_pread(fd, aBuf, nBuf, off);
! 311: }
! 312:
! 313: /*
! 314: ** A wrapper around pread64().
! 315: */
! 316: static int ts_pread64(int fd, void *aBuf, size_t nBuf, off_t off){
! 317: if( tsIsFailErrno("pread64") ){
! 318: return -1;
! 319: }
! 320: return orig_pread64(fd, aBuf, nBuf, off);
! 321: }
! 322:
! 323: /*
! 324: ** A wrapper around write().
! 325: */
! 326: static int ts_write(int fd, const void *aBuf, size_t nBuf){
! 327: if( tsIsFailErrno("write") ){
! 328: if( tsErrno("write")==EINTR ) orig_write(fd, aBuf, nBuf/2);
! 329: return -1;
! 330: }
! 331: return orig_write(fd, aBuf, nBuf);
! 332: }
! 333:
! 334: /*
! 335: ** A wrapper around pwrite().
! 336: */
! 337: static int ts_pwrite(int fd, const void *aBuf, size_t nBuf, off_t off){
! 338: if( tsIsFailErrno("pwrite") ){
! 339: return -1;
! 340: }
! 341: return orig_pwrite(fd, aBuf, nBuf, off);
! 342: }
! 343:
! 344: /*
! 345: ** A wrapper around pwrite64().
! 346: */
! 347: static int ts_pwrite64(int fd, const void *aBuf, size_t nBuf, off_t off){
! 348: if( tsIsFailErrno("pwrite64") ){
! 349: return -1;
! 350: }
! 351: return orig_pwrite64(fd, aBuf, nBuf, off);
! 352: }
! 353:
! 354: /*
! 355: ** A wrapper around fchmod().
! 356: */
! 357: static int ts_fchmod(int fd, mode_t mode){
! 358: if( tsIsFail() ){
! 359: return -1;
! 360: }
! 361: return orig_fchmod(fd, mode);
! 362: }
! 363:
! 364: /*
! 365: ** A wrapper around fallocate().
! 366: **
! 367: ** SQLite assumes that the fallocate() function is compatible with
! 368: ** posix_fallocate(). According to the Linux man page (2009-09-30):
! 369: **
! 370: ** posix_fallocate() returns zero on success, or an error number on
! 371: ** failure. Note that errno is not set.
! 372: */
! 373: static int ts_fallocate(int fd, off_t off, off_t len){
! 374: if( tsIsFail() ){
! 375: return tsErrno("fallocate");
! 376: }
! 377: return orig_fallocate(fd, off, len);
! 378: }
! 379:
! 380: static int test_syscall_install(
! 381: void * clientData,
! 382: Tcl_Interp *interp,
! 383: int objc,
! 384: Tcl_Obj *CONST objv[]
! 385: ){
! 386: sqlite3_vfs *pVfs;
! 387: int nElem;
! 388: int i;
! 389: Tcl_Obj **apElem;
! 390:
! 391: if( objc!=3 ){
! 392: Tcl_WrongNumArgs(interp, 2, objv, "SYSCALL-LIST");
! 393: return TCL_ERROR;
! 394: }
! 395: if( Tcl_ListObjGetElements(interp, objv[2], &nElem, &apElem) ){
! 396: return TCL_ERROR;
! 397: }
! 398: pVfs = sqlite3_vfs_find(0);
! 399:
! 400: for(i=0; i<nElem; i++){
! 401: int iCall;
! 402: int rc = Tcl_GetIndexFromObjStruct(interp,
! 403: apElem[i], aSyscall, sizeof(aSyscall[0]), "system-call", 0, &iCall
! 404: );
! 405: if( rc ) return rc;
! 406: if( aSyscall[iCall].xOrig==0 ){
! 407: aSyscall[iCall].xOrig = pVfs->xGetSystemCall(pVfs, aSyscall[iCall].zName);
! 408: pVfs->xSetSystemCall(pVfs, aSyscall[iCall].zName, aSyscall[iCall].xTest);
! 409: }
! 410: aSyscall[iCall].custom_errno = aSyscall[iCall].default_errno;
! 411: }
! 412:
! 413: return TCL_OK;
! 414: }
! 415:
! 416: static int test_syscall_uninstall(
! 417: void * clientData,
! 418: Tcl_Interp *interp,
! 419: int objc,
! 420: Tcl_Obj *CONST objv[]
! 421: ){
! 422: sqlite3_vfs *pVfs;
! 423: int i;
! 424:
! 425: if( objc!=2 ){
! 426: Tcl_WrongNumArgs(interp, 2, objv, "");
! 427: return TCL_ERROR;
! 428: }
! 429:
! 430: pVfs = sqlite3_vfs_find(0);
! 431: for(i=0; aSyscall[i].zName; i++){
! 432: if( aSyscall[i].xOrig ){
! 433: pVfs->xSetSystemCall(pVfs, aSyscall[i].zName, 0);
! 434: aSyscall[i].xOrig = 0;
! 435: }
! 436: }
! 437: return TCL_OK;
! 438: }
! 439:
! 440: static int test_syscall_reset(
! 441: void * clientData,
! 442: Tcl_Interp *interp,
! 443: int objc,
! 444: Tcl_Obj *CONST objv[]
! 445: ){
! 446: sqlite3_vfs *pVfs;
! 447: int i;
! 448: int rc;
! 449:
! 450: if( objc!=2 && objc!=3 ){
! 451: Tcl_WrongNumArgs(interp, 2, objv, "");
! 452: return TCL_ERROR;
! 453: }
! 454:
! 455: pVfs = sqlite3_vfs_find(0);
! 456: if( objc==2 ){
! 457: rc = pVfs->xSetSystemCall(pVfs, 0, 0);
! 458: for(i=0; aSyscall[i].zName; i++) aSyscall[i].xOrig = 0;
! 459: }else{
! 460: int nFunc;
! 461: char *zFunc = Tcl_GetStringFromObj(objv[2], &nFunc);
! 462: rc = pVfs->xSetSystemCall(pVfs, Tcl_GetString(objv[2]), 0);
! 463: for(i=0; rc==SQLITE_OK && aSyscall[i].zName; i++){
! 464: if( strlen(aSyscall[i].zName)!=nFunc ) continue;
! 465: if( memcmp(aSyscall[i].zName, zFunc, nFunc) ) continue;
! 466: aSyscall[i].xOrig = 0;
! 467: }
! 468: }
! 469: if( rc!=SQLITE_OK ){
! 470: Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3TestErrorName(rc), -1));
! 471: return TCL_ERROR;
! 472: }
! 473:
! 474: Tcl_ResetResult(interp);
! 475: return TCL_OK;
! 476: }
! 477:
! 478: static int test_syscall_exists(
! 479: void * clientData,
! 480: Tcl_Interp *interp,
! 481: int objc,
! 482: Tcl_Obj *CONST objv[]
! 483: ){
! 484: sqlite3_vfs *pVfs;
! 485: sqlite3_syscall_ptr x;
! 486:
! 487: if( objc!=3 ){
! 488: Tcl_WrongNumArgs(interp, 2, objv, "");
! 489: return TCL_ERROR;
! 490: }
! 491:
! 492: pVfs = sqlite3_vfs_find(0);
! 493: x = pVfs->xGetSystemCall(pVfs, Tcl_GetString(objv[2]));
! 494:
! 495: Tcl_SetObjResult(interp, Tcl_NewBooleanObj(x!=0));
! 496: return TCL_OK;
! 497: }
! 498:
! 499: static int test_syscall_fault(
! 500: void * clientData,
! 501: Tcl_Interp *interp,
! 502: int objc,
! 503: Tcl_Obj *CONST objv[]
! 504: ){
! 505: int nCount = 0;
! 506: int bPersist = 0;
! 507:
! 508: if( objc!=2 && objc!=4 ){
! 509: Tcl_WrongNumArgs(interp, 2, objv, "?COUNT PERSIST?");
! 510: return TCL_ERROR;
! 511: }
! 512:
! 513: if( objc==4 ){
! 514: if( Tcl_GetIntFromObj(interp, objv[2], &nCount)
! 515: || Tcl_GetBooleanFromObj(interp, objv[3], &bPersist)
! 516: ){
! 517: return TCL_ERROR;
! 518: }
! 519: }
! 520:
! 521: Tcl_SetObjResult(interp, Tcl_NewIntObj(gSyscall.nFail));
! 522: gSyscall.nCount = nCount;
! 523: gSyscall.bPersist = bPersist;
! 524: gSyscall.nFail = 0;
! 525: return TCL_OK;
! 526: }
! 527:
! 528: static int test_syscall_errno(
! 529: void * clientData,
! 530: Tcl_Interp *interp,
! 531: int objc,
! 532: Tcl_Obj *CONST objv[]
! 533: ){
! 534: int iCall;
! 535: int iErrno;
! 536: int rc;
! 537:
! 538: struct Errno {
! 539: const char *z;
! 540: int i;
! 541: } aErrno[] = {
! 542: { "EACCES", EACCES },
! 543: { "EINTR", EINTR },
! 544: { "EIO", EIO },
! 545: { "EOVERFLOW", EOVERFLOW },
! 546: { "ENOMEM", ENOMEM },
! 547: { "EAGAIN", EAGAIN },
! 548: { "ETIMEDOUT", ETIMEDOUT },
! 549: { "EBUSY", EBUSY },
! 550: { "EPERM", EPERM },
! 551: { "EDEADLK", EDEADLK },
! 552: { "ENOLCK", ENOLCK },
! 553: { 0, 0 }
! 554: };
! 555:
! 556: if( objc!=4 ){
! 557: Tcl_WrongNumArgs(interp, 2, objv, "SYSCALL ERRNO");
! 558: return TCL_ERROR;
! 559: }
! 560:
! 561: rc = Tcl_GetIndexFromObjStruct(interp,
! 562: objv[2], aSyscall, sizeof(aSyscall[0]), "system-call", 0, &iCall
! 563: );
! 564: if( rc!=TCL_OK ) return rc;
! 565: rc = Tcl_GetIndexFromObjStruct(interp,
! 566: objv[3], aErrno, sizeof(aErrno[0]), "errno", 0, &iErrno
! 567: );
! 568: if( rc!=TCL_OK ) return rc;
! 569:
! 570: aSyscall[iCall].custom_errno = aErrno[iErrno].i;
! 571: return TCL_OK;
! 572: }
! 573:
! 574: static int test_syscall_list(
! 575: void * clientData,
! 576: Tcl_Interp *interp,
! 577: int objc,
! 578: Tcl_Obj *CONST objv[]
! 579: ){
! 580: const char *zSys;
! 581: sqlite3_vfs *pVfs;
! 582: Tcl_Obj *pList;
! 583:
! 584: if( objc!=2 ){
! 585: Tcl_WrongNumArgs(interp, 2, objv, "");
! 586: return TCL_ERROR;
! 587: }
! 588:
! 589: pVfs = sqlite3_vfs_find(0);
! 590: pList = Tcl_NewObj();
! 591: Tcl_IncrRefCount(pList);
! 592: for(zSys = pVfs->xNextSystemCall(pVfs, 0);
! 593: zSys!=0;
! 594: zSys = pVfs->xNextSystemCall(pVfs, zSys)
! 595: ){
! 596: Tcl_ListObjAppendElement(interp, pList, Tcl_NewStringObj(zSys, -1));
! 597: }
! 598:
! 599: Tcl_SetObjResult(interp, pList);
! 600: Tcl_DecrRefCount(pList);
! 601: return TCL_OK;
! 602: }
! 603:
! 604: static int test_syscall_defaultvfs(
! 605: void * clientData,
! 606: Tcl_Interp *interp,
! 607: int objc,
! 608: Tcl_Obj *CONST objv[]
! 609: ){
! 610: sqlite3_vfs *pVfs;
! 611:
! 612: if( objc!=2 ){
! 613: Tcl_WrongNumArgs(interp, 2, objv, "");
! 614: return TCL_ERROR;
! 615: }
! 616:
! 617: pVfs = sqlite3_vfs_find(0);
! 618: Tcl_SetObjResult(interp, Tcl_NewStringObj(pVfs->zName, -1));
! 619: return TCL_OK;
! 620: }
! 621:
! 622: static int test_syscall(
! 623: void * clientData,
! 624: Tcl_Interp *interp,
! 625: int objc,
! 626: Tcl_Obj *CONST objv[]
! 627: ){
! 628: struct SyscallCmd {
! 629: const char *zName;
! 630: Tcl_ObjCmdProc *xCmd;
! 631: } aCmd[] = {
! 632: { "fault", test_syscall_fault },
! 633: { "install", test_syscall_install },
! 634: { "uninstall", test_syscall_uninstall },
! 635: { "reset", test_syscall_reset },
! 636: { "errno", test_syscall_errno },
! 637: { "exists", test_syscall_exists },
! 638: { "list", test_syscall_list },
! 639: { "defaultvfs", test_syscall_defaultvfs },
! 640: { 0, 0 }
! 641: };
! 642: int iCmd;
! 643: int rc;
! 644:
! 645: if( objc<2 ){
! 646: Tcl_WrongNumArgs(interp, 1, objv, "SUB-COMMAND ...");
! 647: return TCL_ERROR;
! 648: }
! 649: rc = Tcl_GetIndexFromObjStruct(interp,
! 650: objv[1], aCmd, sizeof(aCmd[0]), "sub-command", 0, &iCmd
! 651: );
! 652: if( rc!=TCL_OK ) return rc;
! 653: return aCmd[iCmd].xCmd(clientData, interp, objc, objv);
! 654: }
! 655:
! 656: int SqlitetestSyscall_Init(Tcl_Interp *interp){
! 657: struct SyscallCmd {
! 658: const char *zName;
! 659: Tcl_ObjCmdProc *xCmd;
! 660: } aCmd[] = {
! 661: { "test_syscall", test_syscall},
! 662: };
! 663: int i;
! 664:
! 665: for(i=0; i<sizeof(aCmd)/sizeof(aCmd[0]); i++){
! 666: Tcl_CreateObjCommand(interp, aCmd[i].zName, aCmd[i].xCmd, 0, 0);
! 667: }
! 668: return TCL_OK;
! 669: }
! 670: #else
! 671: int SqlitetestSyscall_Init(Tcl_Interp *interp){
! 672: return TCL_OK;
! 673: }
! 674: #endif
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to test_syscall.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