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