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