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 */
tsIsFail(void)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 */
tsErrno(const char * zFunc)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 */
tsIsFailErrno(const char * zFunc)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 */
ts_open(const char * zFile,int flags,int mode)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 */
ts_close(int fd)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 */
ts_access(const char * zPath,int mode)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 */
ts_getcwd(char * zPath,size_t nPath)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 */
ts_stat(const char * zPath,struct stat * p)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 */
ts_fstat(int fd,struct stat * p)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 */
ts_ftruncate(int fd,off_t n)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 */
ts_fcntl(int fd,int cmd,...)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 */
ts_read(int fd,void * aBuf,size_t nBuf)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 */
ts_pread(int fd,void * aBuf,size_t nBuf,off_t off)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 */
ts_pread64(int fd,void * aBuf,size_t nBuf,off_t off)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 */
ts_write(int fd,const void * aBuf,size_t nBuf)326 static int ts_write(int fd, const void *aBuf, size_t nBuf){
327 if( tsIsFailErrno("write") ){
328 return -1;
329 }
330 return orig_write(fd, aBuf, nBuf);
331 }
332
333 /*
334 ** A wrapper around pwrite().
335 */
ts_pwrite(int fd,const void * aBuf,size_t nBuf,off_t off)336 static int ts_pwrite(int fd, const void *aBuf, size_t nBuf, off_t off){
337 if( tsIsFailErrno("pwrite") ){
338 return -1;
339 }
340 return orig_pwrite(fd, aBuf, nBuf, off);
341 }
342
343 /*
344 ** A wrapper around pwrite64().
345 */
ts_pwrite64(int fd,const void * aBuf,size_t nBuf,off_t off)346 static int ts_pwrite64(int fd, const void *aBuf, size_t nBuf, off_t off){
347 if( tsIsFailErrno("pwrite64") ){
348 return -1;
349 }
350 return orig_pwrite64(fd, aBuf, nBuf, off);
351 }
352
353 /*
354 ** A wrapper around fchmod().
355 */
ts_fchmod(int fd,mode_t mode)356 static int ts_fchmod(int fd, mode_t mode){
357 if( tsIsFail() ){
358 return -1;
359 }
360 return orig_fchmod(fd, mode);
361 }
362
363 /*
364 ** A wrapper around fallocate().
365 **
366 ** SQLite assumes that the fallocate() function is compatible with
367 ** posix_fallocate(). According to the Linux man page (2009-09-30):
368 **
369 ** posix_fallocate() returns zero on success, or an error number on
370 ** failure. Note that errno is not set.
371 */
ts_fallocate(int fd,off_t off,off_t len)372 static int ts_fallocate(int fd, off_t off, off_t len){
373 if( tsIsFail() ){
374 return tsErrno("fallocate");
375 }
376 return orig_fallocate(fd, off, len);
377 }
378
test_syscall_install(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])379 static int test_syscall_install(
380 void * clientData,
381 Tcl_Interp *interp,
382 int objc,
383 Tcl_Obj *CONST objv[]
384 ){
385 sqlite3_vfs *pVfs;
386 int nElem;
387 int i;
388 Tcl_Obj **apElem;
389
390 if( objc!=3 ){
391 Tcl_WrongNumArgs(interp, 2, objv, "SYSCALL-LIST");
392 return TCL_ERROR;
393 }
394 if( Tcl_ListObjGetElements(interp, objv[2], &nElem, &apElem) ){
395 return TCL_ERROR;
396 }
397 pVfs = sqlite3_vfs_find(0);
398
399 for(i=0; i<nElem; i++){
400 int iCall;
401 int rc = Tcl_GetIndexFromObjStruct(interp,
402 apElem[i], aSyscall, sizeof(aSyscall[0]), "system-call", 0, &iCall
403 );
404 if( rc ) return rc;
405 if( aSyscall[iCall].xOrig==0 ){
406 aSyscall[iCall].xOrig = pVfs->xGetSystemCall(pVfs, aSyscall[iCall].zName);
407 pVfs->xSetSystemCall(pVfs, aSyscall[iCall].zName, aSyscall[iCall].xTest);
408 }
409 aSyscall[iCall].custom_errno = aSyscall[iCall].default_errno;
410 }
411
412 return TCL_OK;
413 }
414
test_syscall_uninstall(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])415 static int test_syscall_uninstall(
416 void * clientData,
417 Tcl_Interp *interp,
418 int objc,
419 Tcl_Obj *CONST objv[]
420 ){
421 sqlite3_vfs *pVfs;
422 int i;
423
424 if( objc!=2 ){
425 Tcl_WrongNumArgs(interp, 2, objv, "");
426 return TCL_ERROR;
427 }
428
429 pVfs = sqlite3_vfs_find(0);
430 for(i=0; aSyscall[i].zName; i++){
431 if( aSyscall[i].xOrig ){
432 pVfs->xSetSystemCall(pVfs, aSyscall[i].zName, 0);
433 aSyscall[i].xOrig = 0;
434 }
435 }
436 return TCL_OK;
437 }
438
test_syscall_reset(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])439 static int test_syscall_reset(
440 void * clientData,
441 Tcl_Interp *interp,
442 int objc,
443 Tcl_Obj *CONST objv[]
444 ){
445 sqlite3_vfs *pVfs;
446 int i;
447 int rc;
448
449 if( objc!=2 && objc!=3 ){
450 Tcl_WrongNumArgs(interp, 2, objv, "");
451 return TCL_ERROR;
452 }
453
454 pVfs = sqlite3_vfs_find(0);
455 if( objc==2 ){
456 rc = pVfs->xSetSystemCall(pVfs, 0, 0);
457 for(i=0; aSyscall[i].zName; i++) aSyscall[i].xOrig = 0;
458 }else{
459 int nFunc;
460 char *zFunc = Tcl_GetStringFromObj(objv[2], &nFunc);
461 rc = pVfs->xSetSystemCall(pVfs, Tcl_GetString(objv[2]), 0);
462 for(i=0; rc==SQLITE_OK && aSyscall[i].zName; i++){
463 if( strlen(aSyscall[i].zName)!=nFunc ) continue;
464 if( memcmp(aSyscall[i].zName, zFunc, nFunc) ) continue;
465 aSyscall[i].xOrig = 0;
466 }
467 }
468 if( rc!=SQLITE_OK ){
469 Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3TestErrorName(rc), -1));
470 return TCL_ERROR;
471 }
472
473 Tcl_ResetResult(interp);
474 return TCL_OK;
475 }
476
test_syscall_exists(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])477 static int test_syscall_exists(
478 void * clientData,
479 Tcl_Interp *interp,
480 int objc,
481 Tcl_Obj *CONST objv[]
482 ){
483 sqlite3_vfs *pVfs;
484 sqlite3_syscall_ptr x;
485
486 if( objc!=3 ){
487 Tcl_WrongNumArgs(interp, 2, objv, "");
488 return TCL_ERROR;
489 }
490
491 pVfs = sqlite3_vfs_find(0);
492 x = pVfs->xGetSystemCall(pVfs, Tcl_GetString(objv[2]));
493
494 Tcl_SetObjResult(interp, Tcl_NewBooleanObj(x!=0));
495 return TCL_OK;
496 }
497
test_syscall_fault(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])498 static int test_syscall_fault(
499 void * clientData,
500 Tcl_Interp *interp,
501 int objc,
502 Tcl_Obj *CONST objv[]
503 ){
504 int nCount = 0;
505 int bPersist = 0;
506
507 if( objc!=2 && objc!=4 ){
508 Tcl_WrongNumArgs(interp, 2, objv, "?COUNT PERSIST?");
509 return TCL_ERROR;
510 }
511
512 if( objc==4 ){
513 if( Tcl_GetIntFromObj(interp, objv[2], &nCount)
514 || Tcl_GetBooleanFromObj(interp, objv[3], &bPersist)
515 ){
516 return TCL_ERROR;
517 }
518 }
519
520 Tcl_SetObjResult(interp, Tcl_NewIntObj(gSyscall.nFail));
521 gSyscall.nCount = nCount;
522 gSyscall.bPersist = bPersist;
523 gSyscall.nFail = 0;
524 return TCL_OK;
525 }
526
test_syscall_errno(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])527 static int test_syscall_errno(
528 void * clientData,
529 Tcl_Interp *interp,
530 int objc,
531 Tcl_Obj *CONST objv[]
532 ){
533 int iCall;
534 int iErrno;
535 int rc;
536
537 struct Errno {
538 const char *z;
539 int i;
540 } aErrno[] = {
541 { "EACCES", EACCES },
542 { "EINTR", EINTR },
543 { "EIO", EIO },
544 { "EOVERFLOW", EOVERFLOW },
545 { "ENOMEM", ENOMEM },
546 { "EAGAIN", EAGAIN },
547 { "ETIMEDOUT", ETIMEDOUT },
548 { "EBUSY", EBUSY },
549 { "EPERM", EPERM },
550 { "EDEADLK", EDEADLK },
551 { "ENOLCK", ENOLCK },
552 { 0, 0 }
553 };
554
555 if( objc!=4 ){
556 Tcl_WrongNumArgs(interp, 2, objv, "SYSCALL ERRNO");
557 return TCL_ERROR;
558 }
559
560 rc = Tcl_GetIndexFromObjStruct(interp,
561 objv[2], aSyscall, sizeof(aSyscall[0]), "system-call", 0, &iCall
562 );
563 if( rc!=TCL_OK ) return rc;
564 rc = Tcl_GetIndexFromObjStruct(interp,
565 objv[3], aErrno, sizeof(aErrno[0]), "errno", 0, &iErrno
566 );
567 if( rc!=TCL_OK ) return rc;
568
569 aSyscall[iCall].custom_errno = aErrno[iErrno].i;
570 return TCL_OK;
571 }
572
test_syscall_list(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])573 static int test_syscall_list(
574 void * clientData,
575 Tcl_Interp *interp,
576 int objc,
577 Tcl_Obj *CONST objv[]
578 ){
579 const char *zSys;
580 sqlite3_vfs *pVfs;
581 Tcl_Obj *pList;
582
583 if( objc!=2 ){
584 Tcl_WrongNumArgs(interp, 2, objv, "");
585 return TCL_ERROR;
586 }
587
588 pVfs = sqlite3_vfs_find(0);
589 pList = Tcl_NewObj();
590 Tcl_IncrRefCount(pList);
591 for(zSys = pVfs->xNextSystemCall(pVfs, 0);
592 zSys!=0;
593 zSys = pVfs->xNextSystemCall(pVfs, zSys)
594 ){
595 Tcl_ListObjAppendElement(interp, pList, Tcl_NewStringObj(zSys, -1));
596 }
597
598 Tcl_SetObjResult(interp, pList);
599 Tcl_DecrRefCount(pList);
600 return TCL_OK;
601 }
602
test_syscall_defaultvfs(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])603 static int test_syscall_defaultvfs(
604 void * clientData,
605 Tcl_Interp *interp,
606 int objc,
607 Tcl_Obj *CONST objv[]
608 ){
609 sqlite3_vfs *pVfs;
610
611 if( objc!=2 ){
612 Tcl_WrongNumArgs(interp, 2, objv, "");
613 return TCL_ERROR;
614 }
615
616 pVfs = sqlite3_vfs_find(0);
617 Tcl_SetObjResult(interp, Tcl_NewStringObj(pVfs->zName, -1));
618 return TCL_OK;
619 }
620
test_syscall(void * clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])621 static int test_syscall(
622 void * clientData,
623 Tcl_Interp *interp,
624 int objc,
625 Tcl_Obj *CONST objv[]
626 ){
627 struct SyscallCmd {
628 const char *zName;
629 Tcl_ObjCmdProc *xCmd;
630 } aCmd[] = {
631 { "fault", test_syscall_fault },
632 { "install", test_syscall_install },
633 { "uninstall", test_syscall_uninstall },
634 { "reset", test_syscall_reset },
635 { "errno", test_syscall_errno },
636 { "exists", test_syscall_exists },
637 { "list", test_syscall_list },
638 { "defaultvfs", test_syscall_defaultvfs },
639 { 0, 0 }
640 };
641 int iCmd;
642 int rc;
643
644 if( objc<2 ){
645 Tcl_WrongNumArgs(interp, 1, objv, "SUB-COMMAND ...");
646 return TCL_ERROR;
647 }
648 rc = Tcl_GetIndexFromObjStruct(interp,
649 objv[1], aCmd, sizeof(aCmd[0]), "sub-command", 0, &iCmd
650 );
651 if( rc!=TCL_OK ) return rc;
652 return aCmd[iCmd].xCmd(clientData, interp, objc, objv);
653 }
654
SqlitetestSyscall_Init(Tcl_Interp * interp)655 int SqlitetestSyscall_Init(Tcl_Interp *interp){
656 struct SyscallCmd {
657 const char *zName;
658 Tcl_ObjCmdProc *xCmd;
659 } aCmd[] = {
660 { "test_syscall", test_syscall},
661 };
662 int i;
663
664 for(i=0; i<sizeof(aCmd)/sizeof(aCmd[0]); i++){
665 Tcl_CreateObjCommand(interp, aCmd[i].zName, aCmd[i].xCmd, 0, 0);
666 }
667 return TCL_OK;
668 }
669 #else
SqlitetestSyscall_Init(Tcl_Interp * interp)670 int SqlitetestSyscall_Init(Tcl_Interp *interp){
671 return TCL_OK;
672 }
673 #endif
674
675