4 ** The author disclaims copyright to this source code. In place of
5 ** a legal notice, here is a blessing:
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.
11 *************************************************************************
13 ** This file contains code used to implement test interfaces to the
14 ** memory allocation subsystem.
16 #include "sqliteInt.h"
17 #if defined(INCLUDE_SQLITE_TCL_H)
18 # include "sqlite_tcl.h"
27 ** This structure is used to encapsulate the global state variables used
28 ** by malloc() fault simulation.
30 static struct MemFault
{
31 int iCountdown
; /* Number of pending successes before a failure */
32 int nRepeat
; /* Number of times to repeat the failure */
33 int nBenign
; /* Number of benign failures seen since last config */
34 int nFail
; /* Number of failures seen since last config */
35 int nOkBefore
; /* Successful allocations prior to the first fault */
36 int nOkAfter
; /* Successful allocations after a fault */
37 u8 enable
; /* True if enabled */
38 int isInstalled
; /* True if the fault simulation layer is installed */
39 int isBenignMode
; /* True if malloc failures are considered benign */
40 sqlite3_mem_methods m
; /* 'Real' malloc implementation */
44 ** This routine exists as a place to set a breakpoint that will
45 ** fire on any simulated malloc() failure.
47 static void sqlite3Fault(void){
53 ** This routine exists as a place to set a breakpoint that will
54 ** fire the first time any malloc() fails on a single test case.
55 ** The sqlite3Fault() routine above runs on every malloc() failure.
56 ** This routine only runs on the first such failure.
58 static void sqlite3FirstFault(void){
64 ** Check to see if a fault should be simulated. Return true to simulate
65 ** the fault. Return false if the fault should not be simulated.
67 static int faultsimStep(void){
68 if( likely(!memfault
.enable
) ){
72 if( memfault
.iCountdown
>0 ){
73 memfault
.iCountdown
--;
77 if( memfault
.nFail
==0 ) sqlite3FirstFault();
80 if( memfault
.isBenignMode
>0 ){
84 if( memfault
.nRepeat
<=0 ){
91 ** A version of sqlite3_mem_methods.xMalloc() that includes fault simulation
94 static void *faultsimMalloc(int n
){
96 if( !faultsimStep() ){
97 p
= memfault
.m
.xMalloc(n
);
104 ** A version of sqlite3_mem_methods.xRealloc() that includes fault simulation
107 static void *faultsimRealloc(void *pOld
, int n
){
109 if( !faultsimStep() ){
110 p
= memfault
.m
.xRealloc(pOld
, n
);
116 ** The following method calls are passed directly through to the underlying
125 static void faultsimFree(void *p
){
128 static int faultsimSize(void *p
){
129 return memfault
.m
.xSize(p
);
131 static int faultsimRoundup(int n
){
132 return memfault
.m
.xRoundup(n
);
134 static int faultsimInit(void *p
){
135 return memfault
.m
.xInit(memfault
.m
.pAppData
);
137 static void faultsimShutdown(void *p
){
138 memfault
.m
.xShutdown(memfault
.m
.pAppData
);
142 ** This routine configures the malloc failure simulation. After
143 ** calling this routine, the next nDelay mallocs will succeed, followed
144 ** by a block of nRepeat failures, after which malloc() calls will begin
147 static void faultsimConfig(int nDelay
, int nRepeat
){
148 memfault
.iCountdown
= nDelay
;
149 memfault
.nRepeat
= nRepeat
;
150 memfault
.nBenign
= 0;
152 memfault
.nOkBefore
= 0;
153 memfault
.nOkAfter
= 0;
154 memfault
.enable
= nDelay
>=0;
156 /* Sometimes, when running multi-threaded tests, the isBenignMode
157 ** variable is not properly incremented/decremented so that it is
158 ** 0 when not inside a benign malloc block. This doesn't affect
159 ** the multi-threaded tests, as they do not use this system. But
160 ** it does affect OOM tests run later in the same process. So
161 ** zero the variable here, just to be sure.
163 memfault
.isBenignMode
= 0;
167 ** Return the number of faults (both hard and benign faults) that have
168 ** occurred since the injector was last configured.
170 static int faultsimFailures(void){
171 return memfault
.nFail
;
175 ** Return the number of benign faults that have occurred since the
176 ** injector was last configured.
178 static int faultsimBenignFailures(void){
179 return memfault
.nBenign
;
183 ** Return the number of successes that will occur before the next failure.
184 ** If no failures are scheduled, return -1.
186 static int faultsimPending(void){
187 if( memfault
.enable
){
188 return memfault
.iCountdown
;
195 static void faultsimBeginBenign(void){
196 memfault
.isBenignMode
++;
198 static void faultsimEndBenign(void){
199 memfault
.isBenignMode
--;
203 ** Add or remove the fault-simulation layer using sqlite3_config(). If
204 ** the argument is non-zero, the
206 static int faultsimInstall(int install
){
207 static struct sqlite3_mem_methods m
= {
208 faultsimMalloc
, /* xMalloc */
209 faultsimFree
, /* xFree */
210 faultsimRealloc
, /* xRealloc */
211 faultsimSize
, /* xSize */
212 faultsimRoundup
, /* xRoundup */
213 faultsimInit
, /* xInit */
214 faultsimShutdown
, /* xShutdown */
219 install
= (install
? 1 : 0);
220 assert(memfault
.isInstalled
==1 || memfault
.isInstalled
==0);
222 if( install
==memfault
.isInstalled
){
227 rc
= sqlite3_config(SQLITE_CONFIG_GETMALLOC
, &memfault
.m
);
228 assert(memfault
.m
.xMalloc
);
230 rc
= sqlite3_config(SQLITE_CONFIG_MALLOC
, &m
);
232 sqlite3_test_control(SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS
,
233 faultsimBeginBenign
, faultsimEndBenign
236 sqlite3_mem_methods m2
;
237 assert(memfault
.m
.xMalloc
);
239 /* One should be able to reset the default memory allocator by storing
240 ** a zeroed allocator then calling GETMALLOC. */
241 memset(&m2
, 0, sizeof(m2
));
242 sqlite3_config(SQLITE_CONFIG_MALLOC
, &m2
);
243 sqlite3_config(SQLITE_CONFIG_GETMALLOC
, &m2
);
244 assert( memcmp(&m2
, &memfault
.m
, sizeof(m2
))==0 );
246 rc
= sqlite3_config(SQLITE_CONFIG_MALLOC
, &memfault
.m
);
247 sqlite3_test_control(SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS
,
252 memfault
.isInstalled
= 1;
260 ** This function is implemented in main.c. Returns a pointer to a static
261 ** buffer containing the symbolic SQLite error code that corresponds to
262 ** the least-significant 8-bits of the integer passed as an argument.
265 ** sqlite3ErrName(1) -> "SQLITE_ERROR"
267 extern const char *sqlite3ErrName(int);
270 ** Transform pointers to text and back again
272 static void pointerToText(void *p
, char *z
){
273 static const char zHex
[] = "0123456789abcdef";
281 if( sizeof(n
)==sizeof(p
) ){
282 memcpy(&n
, &p
, sizeof(p
));
283 }else if( sizeof(u
)==sizeof(p
) ){
284 memcpy(&u
, &p
, sizeof(u
));
289 for(i
=0, k
=sizeof(p
)*2-1; i
<sizeof(p
)*2; i
++, k
--){
295 static int hexToInt(int h
){
296 if( h
>='0' && h
<='9' ){
298 }else if( h
>='a' && h
<='f' ){
304 static int textToPointer(const char *z
, void **pp
){
305 sqlite3_uint64 n
= 0;
308 for(i
=0; i
<sizeof(void*)*2 && z
[0]; i
++){
311 if( v
<0 ) return TCL_ERROR
;
314 if( *z
!=0 ) return TCL_ERROR
;
315 if( sizeof(n
)==sizeof(*pp
) ){
316 memcpy(pp
, &n
, sizeof(n
));
317 }else if( sizeof(u
)==sizeof(*pp
) ){
319 memcpy(pp
, &u
, sizeof(u
));
327 ** Usage: sqlite3_malloc NBYTES
329 ** Raw test interface for sqlite3_malloc().
331 static int SQLITE_TCLAPI
test_malloc(
335 Tcl_Obj
*CONST objv
[]
341 Tcl_WrongNumArgs(interp
, 1, objv
, "NBYTES");
344 if( Tcl_GetIntFromObj(interp
, objv
[1], &nByte
) ) return TCL_ERROR
;
345 p
= sqlite3_malloc((unsigned)nByte
);
346 pointerToText(p
, zOut
);
347 Tcl_AppendResult(interp
, zOut
, NULL
);
352 ** Usage: sqlite3_realloc PRIOR NBYTES
354 ** Raw test interface for sqlite3_realloc().
356 static int SQLITE_TCLAPI
test_realloc(
360 Tcl_Obj
*CONST objv
[]
366 Tcl_WrongNumArgs(interp
, 1, objv
, "PRIOR NBYTES");
369 if( Tcl_GetIntFromObj(interp
, objv
[2], &nByte
) ) return TCL_ERROR
;
370 if( textToPointer(Tcl_GetString(objv
[1]), &pPrior
) ){
371 Tcl_AppendResult(interp
, "bad pointer: ", Tcl_GetString(objv
[1]), (char*)0);
374 p
= sqlite3_realloc(pPrior
, (unsigned)nByte
);
375 pointerToText(p
, zOut
);
376 Tcl_AppendResult(interp
, zOut
, NULL
);
381 ** Usage: sqlite3_free PRIOR
383 ** Raw test interface for sqlite3_free().
385 static int SQLITE_TCLAPI
test_free(
389 Tcl_Obj
*CONST objv
[]
393 Tcl_WrongNumArgs(interp
, 1, objv
, "PRIOR");
396 if( textToPointer(Tcl_GetString(objv
[1]), &pPrior
) ){
397 Tcl_AppendResult(interp
, "bad pointer: ", Tcl_GetString(objv
[1]), (char*)0);
400 sqlite3_free(pPrior
);
405 ** These routines are in test_hexio.c
407 int sqlite3TestHexToBin(const char *, int, char *);
408 int sqlite3TestBinToHex(char*,int);
411 ** Usage: memset ADDRESS SIZE HEX
413 ** Set a chunk of memory (obtained from malloc, probably) to a
414 ** specified hex pattern.
416 static int SQLITE_TCLAPI
test_memset(
420 Tcl_Obj
*CONST objv
[]
429 Tcl_WrongNumArgs(interp
, 1, objv
, "ADDRESS SIZE HEX");
432 if( textToPointer(Tcl_GetString(objv
[1]), &p
) ){
433 Tcl_AppendResult(interp
, "bad pointer: ", Tcl_GetString(objv
[1]), (char*)0);
436 if( Tcl_GetIntFromObj(interp
, objv
[2], &size
) ){
440 Tcl_AppendResult(interp
, "size must be positive", (char*)0);
443 zHex
= Tcl_GetStringFromObj(objv
[3], &n
);
444 if( n
>sizeof(zBin
)*2 ) n
= sizeof(zBin
)*2;
445 n
= sqlite3TestHexToBin(zHex
, n
, zBin
);
447 Tcl_AppendResult(interp
, "no data", (char*)0);
451 for(i
=0; i
<size
; i
++){
458 ** Usage: memget ADDRESS SIZE
460 ** Return memory as hexadecimal text.
462 static int SQLITE_TCLAPI
test_memget(
466 Tcl_Obj
*CONST objv
[]
474 Tcl_WrongNumArgs(interp
, 1, objv
, "ADDRESS SIZE");
477 if( textToPointer(Tcl_GetString(objv
[1]), &p
) ){
478 Tcl_AppendResult(interp
, "bad pointer: ", Tcl_GetString(objv
[1]), (char*)0);
481 if( Tcl_GetIntFromObj(interp
, objv
[2], &size
) ){
485 Tcl_AppendResult(interp
, "size must be positive", (char*)0);
490 if( size
>(sizeof(zHex
)-1)/2 ){
491 n
= (sizeof(zHex
)-1)/2;
495 memcpy(zHex
, zBin
, n
);
498 sqlite3TestBinToHex(zHex
, n
);
499 Tcl_AppendResult(interp
, zHex
, (char*)0);
505 ** Usage: sqlite3_memory_used
507 ** Raw test interface for sqlite3_memory_used().
509 static int SQLITE_TCLAPI
test_memory_used(
513 Tcl_Obj
*CONST objv
[]
515 Tcl_SetObjResult(interp
, Tcl_NewWideIntObj(sqlite3_memory_used()));
520 ** Usage: sqlite3_memory_highwater ?RESETFLAG?
522 ** Raw test interface for sqlite3_memory_highwater().
524 static int SQLITE_TCLAPI
test_memory_highwater(
528 Tcl_Obj
*CONST objv
[]
531 if( objc
!=1 && objc
!=2 ){
532 Tcl_WrongNumArgs(interp
, 1, objv
, "?RESET?");
536 if( Tcl_GetBooleanFromObj(interp
, objv
[1], &resetFlag
) ) return TCL_ERROR
;
538 Tcl_SetObjResult(interp
,
539 Tcl_NewWideIntObj(sqlite3_memory_highwater(resetFlag
)));
544 ** Usage: sqlite3_memdebug_backtrace DEPTH
546 ** Set the depth of backtracing. If SQLITE_MEMDEBUG is not defined
547 ** then this routine is a no-op.
549 static int SQLITE_TCLAPI
test_memdebug_backtrace(
553 Tcl_Obj
*CONST objv
[]
557 Tcl_WrongNumArgs(interp
, 1, objv
, "DEPT");
560 if( Tcl_GetIntFromObj(interp
, objv
[1], &depth
) ) return TCL_ERROR
;
561 #ifdef SQLITE_MEMDEBUG
563 extern void sqlite3MemdebugBacktrace(int);
564 sqlite3MemdebugBacktrace(depth
);
571 ** Usage: sqlite3_memdebug_dump FILENAME
573 ** Write a summary of unfreed memory to FILENAME.
575 static int SQLITE_TCLAPI
test_memdebug_dump(
579 Tcl_Obj
*CONST objv
[]
582 Tcl_WrongNumArgs(interp
, 1, objv
, "FILENAME");
585 #if defined(SQLITE_MEMDEBUG) || defined(SQLITE_MEMORY_SIZE) \
586 || defined(SQLITE_POW2_MEMORY_SIZE)
588 extern void sqlite3MemdebugDump(const char*);
589 sqlite3MemdebugDump(Tcl_GetString(objv
[1]));
596 ** Usage: sqlite3_memdebug_malloc_count
598 ** Return the total number of times malloc() has been called.
600 static int SQLITE_TCLAPI
test_memdebug_malloc_count(
604 Tcl_Obj
*CONST objv
[]
608 Tcl_WrongNumArgs(interp
, 1, objv
, "");
611 #if defined(SQLITE_MEMDEBUG)
613 extern int sqlite3MemdebugMallocCount();
614 nMalloc
= sqlite3MemdebugMallocCount();
617 Tcl_SetObjResult(interp
, Tcl_NewIntObj(nMalloc
));
623 ** Usage: sqlite3_memdebug_fail COUNTER ?OPTIONS?
625 ** where options are:
628 ** -benigncnt <varname>
630 ** Arrange for a simulated malloc() failure after COUNTER successes.
631 ** If a repeat count is specified, the fault is repeated that many
634 ** Each call to this routine overrides the prior counter value.
635 ** This routine returns the number of simulated failures that have
636 ** happened since the previous call to this routine.
638 ** To disable simulated failures, use a COUNTER of -1.
640 static int SQLITE_TCLAPI
test_memdebug_fail(
644 Tcl_Obj
*CONST objv
[]
649 Tcl_Obj
*pBenignCnt
= 0;
654 Tcl_WrongNumArgs(interp
, 1, objv
, "COUNTER ?OPTIONS?");
657 if( Tcl_GetIntFromObj(interp
, objv
[1], &iFail
) ) return TCL_ERROR
;
659 for(ii
=2; ii
<objc
; ii
+=2){
661 char *zOption
= Tcl_GetStringFromObj(objv
[ii
], &nOption
);
664 if( nOption
>1 && strncmp(zOption
, "-repeat", nOption
)==0 ){
666 zErr
= "option requires an argument: ";
668 if( Tcl_GetIntFromObj(interp
, objv
[ii
+1], &nRepeat
) ){
672 }else if( nOption
>1 && strncmp(zOption
, "-benigncnt", nOption
)==0 ){
674 zErr
= "option requires an argument: ";
676 pBenignCnt
= objv
[ii
+1];
679 zErr
= "unknown option: ";
683 Tcl_AppendResult(interp
, zErr
, zOption
, 0);
688 nBenign
= faultsimBenignFailures();
689 nFail
= faultsimFailures();
690 faultsimConfig(iFail
, nRepeat
);
693 Tcl_ObjSetVar2(interp
, pBenignCnt
, 0, Tcl_NewIntObj(nBenign
), 0);
695 Tcl_SetObjResult(interp
, Tcl_NewIntObj(nFail
));
700 ** Usage: sqlite3_memdebug_pending
702 ** Return the number of malloc() calls that will succeed before a
703 ** simulated failure occurs. A negative return value indicates that
704 ** no malloc() failure is scheduled.
706 static int SQLITE_TCLAPI
test_memdebug_pending(
710 Tcl_Obj
*CONST objv
[]
714 Tcl_WrongNumArgs(interp
, 1, objv
, "");
717 nPending
= faultsimPending();
718 Tcl_SetObjResult(interp
, Tcl_NewIntObj(nPending
));
723 ** The following global variable keeps track of the number of tests
724 ** that have run. This variable is only useful when running in the
727 static int sqlite3_memdebug_title_count
= 0;
730 ** Usage: sqlite3_memdebug_settitle TITLE
732 ** Set a title string stored with each allocation. The TITLE is
733 ** typically the name of the test that was running when the
734 ** allocation occurred. The TITLE is stored with the allocation
735 ** and can be used to figure out which tests are leaking memory.
737 ** Each title overwrite the previous.
739 static int SQLITE_TCLAPI
test_memdebug_settitle(
743 Tcl_Obj
*CONST objv
[]
745 sqlite3_memdebug_title_count
++;
747 Tcl_WrongNumArgs(interp
, 1, objv
, "TITLE");
750 #ifdef SQLITE_MEMDEBUG
753 extern int sqlite3MemdebugSettitle(const char*);
754 zTitle
= Tcl_GetString(objv
[1]);
755 sqlite3MemdebugSettitle(zTitle
);
761 #define MALLOC_LOG_FRAMES 10
762 #define MALLOC_LOG_KEYINTS ( \
763 10 * ((sizeof(int)>=sizeof(void*)) ? 1 : sizeof(void*)/sizeof(int)) \
765 static Tcl_HashTable aMallocLog
;
766 static int mallocLogEnabled
= 0;
768 typedef struct MallocLog MallocLog
;
774 #ifdef SQLITE_MEMDEBUG
775 static void test_memdebug_callback(int nByte
, int nFrame
, void **aFrame
){
776 if( mallocLogEnabled
){
778 Tcl_HashEntry
*pEntry
;
781 int aKey
[MALLOC_LOG_KEYINTS
];
782 unsigned int nKey
= sizeof(int)*MALLOC_LOG_KEYINTS
;
784 memset(aKey
, 0, nKey
);
785 if( (sizeof(void*)*nFrame
)<nKey
){
786 nKey
= nFrame
*sizeof(void*);
788 memcpy(aKey
, aFrame
, nKey
);
790 pEntry
= Tcl_CreateHashEntry(&aMallocLog
, (const char *)aKey
, &isNew
);
792 pLog
= (MallocLog
*)Tcl_Alloc(sizeof(MallocLog
));
793 memset(pLog
, 0, sizeof(MallocLog
));
794 Tcl_SetHashValue(pEntry
, (ClientData
)pLog
);
796 pLog
= (MallocLog
*)Tcl_GetHashValue(pEntry
);
800 pLog
->nByte
+= nByte
;
803 #endif /* SQLITE_MEMDEBUG */
805 static void test_memdebug_log_clear(void){
806 Tcl_HashSearch search
;
807 Tcl_HashEntry
*pEntry
;
809 pEntry
=Tcl_FirstHashEntry(&aMallocLog
, &search
);
811 pEntry
=Tcl_NextHashEntry(&search
)
813 MallocLog
*pLog
= (MallocLog
*)Tcl_GetHashValue(pEntry
);
814 Tcl_Free((char *)pLog
);
816 Tcl_DeleteHashTable(&aMallocLog
);
817 Tcl_InitHashTable(&aMallocLog
, MALLOC_LOG_KEYINTS
);
820 static int SQLITE_TCLAPI
test_memdebug_log(
824 Tcl_Obj
*CONST objv
[]
826 static int isInit
= 0;
829 static const char *MB_strs
[] = { "start", "stop", "dump", "clear", "sync" };
831 MB_LOG_START
, MB_LOG_STOP
, MB_LOG_DUMP
, MB_LOG_CLEAR
, MB_LOG_SYNC
835 #ifdef SQLITE_MEMDEBUG
836 extern void sqlite3MemdebugBacktraceCallback(
837 void (*xBacktrace
)(int, int, void **));
838 sqlite3MemdebugBacktraceCallback(test_memdebug_callback
);
840 Tcl_InitHashTable(&aMallocLog
, MALLOC_LOG_KEYINTS
);
845 Tcl_WrongNumArgs(interp
, 1, objv
, "SUB-COMMAND ...");
847 if( Tcl_GetIndexFromObj(interp
, objv
[1], MB_strs
, "sub-command", 0, &iSub
) ){
851 switch( (enum MB_enum
)iSub
){
853 mallocLogEnabled
= 1;
856 mallocLogEnabled
= 0;
859 Tcl_HashSearch search
;
860 Tcl_HashEntry
*pEntry
;
861 Tcl_Obj
*pRet
= Tcl_NewObj();
863 assert(sizeof(Tcl_WideInt
)>=sizeof(void*));
866 pEntry
=Tcl_FirstHashEntry(&aMallocLog
, &search
);
868 pEntry
=Tcl_NextHashEntry(&search
)
870 Tcl_Obj
*apElem
[MALLOC_LOG_FRAMES
+2];
871 MallocLog
*pLog
= (MallocLog
*)Tcl_GetHashValue(pEntry
);
872 Tcl_WideInt
*aKey
= (Tcl_WideInt
*)Tcl_GetHashKey(&aMallocLog
, pEntry
);
875 apElem
[0] = Tcl_NewIntObj(pLog
->nCall
);
876 apElem
[1] = Tcl_NewIntObj(pLog
->nByte
);
877 for(ii
=0; ii
<MALLOC_LOG_FRAMES
; ii
++){
878 apElem
[ii
+2] = Tcl_NewWideIntObj(aKey
[ii
]);
881 Tcl_ListObjAppendElement(interp
, pRet
,
882 Tcl_NewListObj(MALLOC_LOG_FRAMES
+2, apElem
)
886 Tcl_SetObjResult(interp
, pRet
);
890 test_memdebug_log_clear();
895 #ifdef SQLITE_MEMDEBUG
896 extern void sqlite3MemdebugSync();
897 test_memdebug_log_clear();
898 mallocLogEnabled
= 1;
899 sqlite3MemdebugSync();
909 ** Usage: sqlite3_config_pagecache SIZE N
911 ** Set the page-cache memory buffer using SQLITE_CONFIG_PAGECACHE.
912 ** The buffer is static and is of limited size. N might be
913 ** adjusted downward as needed to accommodate the requested size.
914 ** The revised value of N is returned.
916 ** A negative SIZE causes the buffer pointer to be NULL.
918 static int SQLITE_TCLAPI
test_config_pagecache(
922 Tcl_Obj
*CONST objv
[]
926 static char *buf
= 0;
928 Tcl_WrongNumArgs(interp
, 1, objv
, "SIZE N");
931 if( Tcl_GetIntFromObj(interp
, objv
[1], &sz
) ) return TCL_ERROR
;
932 if( Tcl_GetIntFromObj(interp
, objv
[2], &N
) ) return TCL_ERROR
;
936 /* Set the return value */
938 Tcl_ListObjAppendElement(0, pRes
, Tcl_NewIntObj(sqlite3GlobalConfig
.szPage
));
939 Tcl_ListObjAppendElement(0, pRes
, Tcl_NewIntObj(sqlite3GlobalConfig
.nPage
));
940 Tcl_SetObjResult(interp
, pRes
);
943 sqlite3_config(SQLITE_CONFIG_PAGECACHE
, (void*)0, 0, 0);
945 buf
= malloc( sz
*N
);
946 sqlite3_config(SQLITE_CONFIG_PAGECACHE
, buf
, sz
, N
);
952 ** Usage: sqlite3_config_alt_pcache INSTALL_FLAG DISCARD_CHANCE PRNG_SEED
954 ** Set up the alternative test page cache. Install if INSTALL_FLAG is
955 ** true and uninstall (reverting to the default page cache) if INSTALL_FLAG
956 ** is false. DISCARD_CHANGE is an integer between 0 and 100 inclusive
957 ** which determines the chance of discarding a page when unpinned. 100
958 ** is certainty. 0 is never. PRNG_SEED is the pseudo-random number generator
961 static int SQLITE_TCLAPI
test_alt_pcache(
965 Tcl_Obj
*CONST objv
[]
968 int discardChance
= 0;
971 extern void installTestPCache(int,unsigned,unsigned,unsigned);
972 if( objc
<2 || objc
>5 ){
973 Tcl_WrongNumArgs(interp
, 1, objv
,
974 "INSTALLFLAG DISCARDCHANCE PRNGSEEED HIGHSTRESS");
977 if( Tcl_GetIntFromObj(interp
, objv
[1], &installFlag
) ) return TCL_ERROR
;
978 if( objc
>=3 && Tcl_GetIntFromObj(interp
, objv
[2], &discardChance
) ){
981 if( objc
>=4 && Tcl_GetIntFromObj(interp
, objv
[3], &prngSeed
) ){
984 if( objc
>=5 && Tcl_GetIntFromObj(interp
, objv
[4], &highStress
) ){
987 if( discardChance
<0 || discardChance
>100 ){
988 Tcl_AppendResult(interp
, "discard-chance should be between 0 and 100",
992 installTestPCache(installFlag
, (unsigned)discardChance
, (unsigned)prngSeed
,
993 (unsigned)highStress
);
998 ** Usage: sqlite3_config_memstatus BOOLEAN
1000 ** Enable or disable memory status reporting using SQLITE_CONFIG_MEMSTATUS.
1002 static int SQLITE_TCLAPI
test_config_memstatus(
1006 Tcl_Obj
*CONST objv
[]
1010 Tcl_WrongNumArgs(interp
, 1, objv
, "BOOLEAN");
1013 if( Tcl_GetBooleanFromObj(interp
, objv
[1], &enable
) ) return TCL_ERROR
;
1014 rc
= sqlite3_config(SQLITE_CONFIG_MEMSTATUS
, enable
);
1015 Tcl_SetObjResult(interp
, Tcl_NewIntObj(rc
));
1020 ** Usage: sqlite3_config_lookaside SIZE COUNT
1023 static int SQLITE_TCLAPI
test_config_lookaside(
1027 Tcl_Obj
*CONST objv
[]
1032 Tcl_WrongNumArgs(interp
, 1, objv
, "SIZE COUNT");
1035 if( Tcl_GetIntFromObj(interp
, objv
[1], &sz
) ) return TCL_ERROR
;
1036 if( Tcl_GetIntFromObj(interp
, objv
[2], &cnt
) ) return TCL_ERROR
;
1037 pRet
= Tcl_NewObj();
1038 Tcl_ListObjAppendElement(
1039 interp
, pRet
, Tcl_NewIntObj(sqlite3GlobalConfig
.szLookaside
)
1041 Tcl_ListObjAppendElement(
1042 interp
, pRet
, Tcl_NewIntObj(sqlite3GlobalConfig
.nLookaside
)
1044 sqlite3_config(SQLITE_CONFIG_LOOKASIDE
, sz
, cnt
);
1045 Tcl_SetObjResult(interp
, pRet
);
1051 ** Usage: sqlite3_db_config_lookaside CONNECTION BUFID SIZE COUNT
1053 ** There are two static buffers with BUFID 1 and 2. Each static buffer
1054 ** is 10KB in size. A BUFID of 0 indicates that the buffer should be NULL
1055 ** which will cause sqlite3_db_config() to allocate space on its own.
1057 static int SQLITE_TCLAPI
test_db_config_lookaside(
1061 Tcl_Obj
*CONST objv
[]
1067 static char azBuf
[2][10000];
1068 extern int getDbPointer(Tcl_Interp
*, const char*, sqlite3
**);
1070 Tcl_WrongNumArgs(interp
, 1, objv
, "BUFID SIZE COUNT");
1073 if( getDbPointer(interp
, Tcl_GetString(objv
[1]), &db
) ) return TCL_ERROR
;
1074 if( Tcl_GetIntFromObj(interp
, objv
[2], &bufid
) ) return TCL_ERROR
;
1075 if( Tcl_GetIntFromObj(interp
, objv
[3], &sz
) ) return TCL_ERROR
;
1076 if( Tcl_GetIntFromObj(interp
, objv
[4], &cnt
) ) return TCL_ERROR
;
1078 rc
= sqlite3_db_config(db
, SQLITE_DBCONFIG_LOOKASIDE
, (void*)0, sz
, cnt
);
1079 }else if( bufid
>=1 && bufid
<=2 && sz
*cnt
<=sizeof(azBuf
[0]) ){
1080 rc
= sqlite3_db_config(db
, SQLITE_DBCONFIG_LOOKASIDE
, azBuf
[bufid
], sz
,cnt
);
1082 Tcl_AppendResult(interp
, "illegal arguments - see documentation", (char*)0);
1085 Tcl_SetObjResult(interp
, Tcl_NewIntObj(rc
));
1090 ** Usage: sqlite3_config_heap NBYTE NMINALLOC
1092 static int SQLITE_TCLAPI
test_config_heap(
1096 Tcl_Obj
*CONST objv
[]
1098 static char *zBuf
; /* Use this memory */
1099 int nByte
; /* Size of buffer to pass to sqlite3_config() */
1100 int nMinAlloc
; /* Size of minimum allocation */
1101 int rc
; /* Return code of sqlite3_config() */
1103 Tcl_Obj
* CONST
*aArg
= &objv
[1];
1107 Tcl_WrongNumArgs(interp
, 1, objv
, "NBYTE NMINALLOC");
1110 if( Tcl_GetIntFromObj(interp
, aArg
[0], &nByte
) ) return TCL_ERROR
;
1111 if( Tcl_GetIntFromObj(interp
, aArg
[1], &nMinAlloc
) ) return TCL_ERROR
;
1116 rc
= sqlite3_config(SQLITE_CONFIG_HEAP
, (void*)0, 0, 0);
1118 zBuf
= realloc(zBuf
, nByte
);
1119 rc
= sqlite3_config(SQLITE_CONFIG_HEAP
, zBuf
, nByte
, nMinAlloc
);
1122 Tcl_SetResult(interp
, (char *)sqlite3ErrName(rc
), TCL_VOLATILE
);
1127 ** Usage: sqlite3_config_heap_size NBYTE
1129 static int SQLITE_TCLAPI
test_config_heap_size(
1133 Tcl_Obj
*CONST objv
[]
1135 int nByte
; /* Size to pass to sqlite3_config() */
1136 int rc
; /* Return code of sqlite3_config() */
1138 Tcl_Obj
* CONST
*aArg
= &objv
[1];
1142 Tcl_WrongNumArgs(interp
, 1, objv
, "NBYTE");
1145 if( Tcl_GetIntFromObj(interp
, aArg
[0], &nByte
) ) return TCL_ERROR
;
1147 rc
= sqlite3_config(SQLITE_CONFIG_WIN32_HEAPSIZE
, nByte
);
1149 Tcl_SetResult(interp
, (char *)sqlite3ErrName(rc
), TCL_VOLATILE
);
1154 ** Usage: sqlite3_config_error [DB]
1156 ** Invoke sqlite3_config() or sqlite3_db_config() with invalid
1157 ** opcodes and verify that they return errors.
1159 static int SQLITE_TCLAPI
test_config_error(
1163 Tcl_Obj
*CONST objv
[]
1166 extern int getDbPointer(Tcl_Interp
*, const char*, sqlite3
**);
1168 if( objc
!=2 && objc
!=1 ){
1169 Tcl_WrongNumArgs(interp
, 1, objv
, "[DB]");
1173 if( getDbPointer(interp
, Tcl_GetString(objv
[1]), &db
) ) return TCL_ERROR
;
1174 if( sqlite3_db_config(db
, 99999)!=SQLITE_ERROR
){
1175 Tcl_AppendResult(interp
,
1176 "sqlite3_db_config(db, 99999) does not return SQLITE_ERROR",
1181 if( sqlite3_config(99999)!=SQLITE_ERROR
){
1182 Tcl_AppendResult(interp
,
1183 "sqlite3_config(99999) does not return SQLITE_ERROR",
1192 ** Usage: sqlite3_config_uri BOOLEAN
1194 ** Enables or disables interpretation of URI parameters by default using
1195 ** SQLITE_CONFIG_URI.
1197 static int SQLITE_TCLAPI
test_config_uri(
1201 Tcl_Obj
*CONST objv
[]
1207 Tcl_WrongNumArgs(interp
, 1, objv
, "BOOL");
1210 if( Tcl_GetBooleanFromObj(interp
, objv
[1], &bOpenUri
) ){
1214 rc
= sqlite3_config(SQLITE_CONFIG_URI
, bOpenUri
);
1215 Tcl_SetResult(interp
, (char *)sqlite3ErrName(rc
), TCL_VOLATILE
);
1221 ** Usage: sqlite3_config_cis BOOLEAN
1223 ** Enables or disables the use of the covering-index scan optimization.
1224 ** SQLITE_CONFIG_COVERING_INDEX_SCAN.
1226 static int SQLITE_TCLAPI
test_config_cis(
1230 Tcl_Obj
*CONST objv
[]
1236 Tcl_WrongNumArgs(interp
, 1, objv
, "BOOL");
1239 if( Tcl_GetBooleanFromObj(interp
, objv
[1], &bUseCis
) ){
1243 rc
= sqlite3_config(SQLITE_CONFIG_COVERING_INDEX_SCAN
, bUseCis
);
1244 Tcl_SetResult(interp
, (char *)sqlite3ErrName(rc
), TCL_VOLATILE
);
1250 ** Usage: sqlite3_config_pmasz INTEGER
1252 ** Set the minimum PMA size.
1254 static int SQLITE_TCLAPI
test_config_pmasz(
1258 Tcl_Obj
*CONST objv
[]
1264 Tcl_WrongNumArgs(interp
, 1, objv
, "BOOL");
1267 if( Tcl_GetIntFromObj(interp
, objv
[1], &iPmaSz
) ){
1271 rc
= sqlite3_config(SQLITE_CONFIG_PMASZ
, iPmaSz
);
1272 Tcl_SetResult(interp
, (char *)sqlite3ErrName(rc
), TCL_VOLATILE
);
1279 ** Usage: sqlite3_dump_memsys3 FILENAME
1280 ** sqlite3_dump_memsys5 FILENAME
1282 ** Write a summary of unfreed memsys3 allocations to FILENAME.
1284 static int SQLITE_TCLAPI
test_dump_memsys3(
1288 Tcl_Obj
*CONST objv
[]
1291 Tcl_WrongNumArgs(interp
, 1, objv
, "FILENAME");
1295 switch( SQLITE_PTR_TO_INT(clientData
) ){
1297 #ifdef SQLITE_ENABLE_MEMSYS3
1298 extern void sqlite3Memsys3Dump(const char*);
1299 sqlite3Memsys3Dump(Tcl_GetString(objv
[1]));
1304 #ifdef SQLITE_ENABLE_MEMSYS5
1305 extern void sqlite3Memsys5Dump(const char*);
1306 sqlite3Memsys5Dump(Tcl_GetString(objv
[1]));
1315 ** Usage: sqlite3_status OPCODE RESETFLAG
1317 ** Return a list of three elements which are the sqlite3_status() return
1318 ** code, the current value, and the high-water mark value.
1320 static int SQLITE_TCLAPI
test_status(
1324 Tcl_Obj
*CONST objv
[]
1326 int rc
, iValue
, mxValue
;
1327 int i
, op
= 0, resetFlag
;
1328 const char *zOpName
;
1329 static const struct {
1333 { "SQLITE_STATUS_MEMORY_USED", SQLITE_STATUS_MEMORY_USED
},
1334 { "SQLITE_STATUS_MALLOC_SIZE", SQLITE_STATUS_MALLOC_SIZE
},
1335 { "SQLITE_STATUS_PAGECACHE_USED", SQLITE_STATUS_PAGECACHE_USED
},
1336 { "SQLITE_STATUS_PAGECACHE_OVERFLOW", SQLITE_STATUS_PAGECACHE_OVERFLOW
},
1337 { "SQLITE_STATUS_PAGECACHE_SIZE", SQLITE_STATUS_PAGECACHE_SIZE
},
1338 { "SQLITE_STATUS_SCRATCH_USED", SQLITE_STATUS_SCRATCH_USED
},
1339 { "SQLITE_STATUS_SCRATCH_OVERFLOW", SQLITE_STATUS_SCRATCH_OVERFLOW
},
1340 { "SQLITE_STATUS_SCRATCH_SIZE", SQLITE_STATUS_SCRATCH_SIZE
},
1341 { "SQLITE_STATUS_PARSER_STACK", SQLITE_STATUS_PARSER_STACK
},
1342 { "SQLITE_STATUS_MALLOC_COUNT", SQLITE_STATUS_MALLOC_COUNT
},
1346 Tcl_WrongNumArgs(interp
, 1, objv
, "PARAMETER RESETFLAG");
1349 zOpName
= Tcl_GetString(objv
[1]);
1350 for(i
=0; i
<ArraySize(aOp
); i
++){
1351 if( strcmp(aOp
[i
].zName
, zOpName
)==0 ){
1356 if( i
>=ArraySize(aOp
) ){
1357 if( Tcl_GetIntFromObj(interp
, objv
[1], &op
) ) return TCL_ERROR
;
1359 if( Tcl_GetBooleanFromObj(interp
, objv
[2], &resetFlag
) ) return TCL_ERROR
;
1362 rc
= sqlite3_status(op
, &iValue
, &mxValue
, resetFlag
);
1363 pResult
= Tcl_NewObj();
1364 Tcl_ListObjAppendElement(0, pResult
, Tcl_NewIntObj(rc
));
1365 Tcl_ListObjAppendElement(0, pResult
, Tcl_NewIntObj(iValue
));
1366 Tcl_ListObjAppendElement(0, pResult
, Tcl_NewIntObj(mxValue
));
1367 Tcl_SetObjResult(interp
, pResult
);
1372 ** Usage: sqlite3_db_status DATABASE OPCODE RESETFLAG
1374 ** Return a list of three elements which are the sqlite3_db_status() return
1375 ** code, the current value, and the high-water mark value.
1377 static int SQLITE_TCLAPI
test_db_status(
1381 Tcl_Obj
*CONST objv
[]
1383 int rc
, iValue
, mxValue
;
1384 int i
, op
= 0, resetFlag
;
1385 const char *zOpName
;
1387 extern int getDbPointer(Tcl_Interp
*, const char*, sqlite3
**);
1388 static const struct {
1392 { "LOOKASIDE_USED", SQLITE_DBSTATUS_LOOKASIDE_USED
},
1393 { "CACHE_USED", SQLITE_DBSTATUS_CACHE_USED
},
1394 { "SCHEMA_USED", SQLITE_DBSTATUS_SCHEMA_USED
},
1395 { "STMT_USED", SQLITE_DBSTATUS_STMT_USED
},
1396 { "LOOKASIDE_HIT", SQLITE_DBSTATUS_LOOKASIDE_HIT
},
1397 { "LOOKASIDE_MISS_SIZE", SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE
},
1398 { "LOOKASIDE_MISS_FULL", SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL
},
1399 { "CACHE_HIT", SQLITE_DBSTATUS_CACHE_HIT
},
1400 { "CACHE_MISS", SQLITE_DBSTATUS_CACHE_MISS
},
1401 { "CACHE_WRITE", SQLITE_DBSTATUS_CACHE_WRITE
},
1402 { "DEFERRED_FKS", SQLITE_DBSTATUS_DEFERRED_FKS
},
1403 { "CACHE_USED_SHARED", SQLITE_DBSTATUS_CACHE_USED_SHARED
},
1404 { "CACHE_SPILL", SQLITE_DBSTATUS_CACHE_SPILL
},
1408 Tcl_WrongNumArgs(interp
, 1, objv
, "DB PARAMETER RESETFLAG");
1411 if( getDbPointer(interp
, Tcl_GetString(objv
[1]), &db
) ) return TCL_ERROR
;
1412 zOpName
= Tcl_GetString(objv
[2]);
1413 if( memcmp(zOpName
, "SQLITE_", 7)==0 ) zOpName
+= 7;
1414 if( memcmp(zOpName
, "DBSTATUS_", 9)==0 ) zOpName
+= 9;
1415 for(i
=0; i
<ArraySize(aOp
); i
++){
1416 if( strcmp(aOp
[i
].zName
, zOpName
)==0 ){
1421 if( i
>=ArraySize(aOp
) ){
1422 if( Tcl_GetIntFromObj(interp
, objv
[2], &op
) ) return TCL_ERROR
;
1424 if( Tcl_GetBooleanFromObj(interp
, objv
[3], &resetFlag
) ) return TCL_ERROR
;
1427 rc
= sqlite3_db_status(db
, op
, &iValue
, &mxValue
, resetFlag
);
1428 pResult
= Tcl_NewObj();
1429 Tcl_ListObjAppendElement(0, pResult
, Tcl_NewIntObj(rc
));
1430 Tcl_ListObjAppendElement(0, pResult
, Tcl_NewIntObj(iValue
));
1431 Tcl_ListObjAppendElement(0, pResult
, Tcl_NewIntObj(mxValue
));
1432 Tcl_SetObjResult(interp
, pResult
);
1437 ** install_malloc_faultsim BOOLEAN
1439 static int SQLITE_TCLAPI
test_install_malloc_faultsim(
1443 Tcl_Obj
*CONST objv
[]
1449 Tcl_WrongNumArgs(interp
, 1, objv
, "BOOLEAN");
1452 if( TCL_OK
!=Tcl_GetBooleanFromObj(interp
, objv
[1], &isInstall
) ){
1455 rc
= faultsimInstall(isInstall
);
1456 Tcl_SetResult(interp
, (char *)sqlite3ErrName(rc
), TCL_VOLATILE
);
1461 ** sqlite3_install_memsys3
1463 static int SQLITE_TCLAPI
test_install_memsys3(
1467 Tcl_Obj
*CONST objv
[]
1469 int rc
= SQLITE_MISUSE
;
1470 #ifdef SQLITE_ENABLE_MEMSYS3
1471 const sqlite3_mem_methods
*sqlite3MemGetMemsys3(void);
1472 rc
= sqlite3_config(SQLITE_CONFIG_MALLOC
, sqlite3MemGetMemsys3());
1474 Tcl_SetResult(interp
, (char *)sqlite3ErrName(rc
), TCL_VOLATILE
);
1478 static int SQLITE_TCLAPI
test_vfs_oom_test(
1482 Tcl_Obj
*CONST objv
[]
1484 extern int sqlite3_memdebug_vfs_oom_test
;
1486 Tcl_WrongNumArgs(interp
, 1, objv
, "?INTEGER?");
1488 }else if( objc
==2 ){
1490 if( Tcl_GetIntFromObj(interp
, objv
[1], &iNew
) ) return TCL_ERROR
;
1491 sqlite3_memdebug_vfs_oom_test
= iNew
;
1493 Tcl_SetObjResult(interp
, Tcl_NewIntObj(sqlite3_memdebug_vfs_oom_test
));
1498 ** Register commands with the TCL interpreter.
1500 int Sqlitetest_malloc_Init(Tcl_Interp
*interp
){
1503 Tcl_ObjCmdProc
*xProc
;
1506 { "sqlite3_malloc", test_malloc
,0 },
1507 { "sqlite3_realloc", test_realloc
,0 },
1508 { "sqlite3_free", test_free
,0 },
1509 { "memset", test_memset
,0 },
1510 { "memget", test_memget
,0 },
1511 { "sqlite3_memory_used", test_memory_used
,0 },
1512 { "sqlite3_memory_highwater", test_memory_highwater
,0 },
1513 { "sqlite3_memdebug_backtrace", test_memdebug_backtrace
,0 },
1514 { "sqlite3_memdebug_dump", test_memdebug_dump
,0 },
1515 { "sqlite3_memdebug_fail", test_memdebug_fail
,0 },
1516 { "sqlite3_memdebug_pending", test_memdebug_pending
,0 },
1517 { "sqlite3_memdebug_settitle", test_memdebug_settitle
,0 },
1518 { "sqlite3_memdebug_malloc_count", test_memdebug_malloc_count
,0 },
1519 { "sqlite3_memdebug_log", test_memdebug_log
,0 },
1520 { "sqlite3_config_pagecache", test_config_pagecache
,0 },
1521 { "sqlite3_config_alt_pcache", test_alt_pcache
,0 },
1522 { "sqlite3_status", test_status
,0 },
1523 { "sqlite3_db_status", test_db_status
,0 },
1524 { "install_malloc_faultsim", test_install_malloc_faultsim
,0 },
1525 { "sqlite3_config_heap", test_config_heap
,0 },
1526 { "sqlite3_config_heap_size", test_config_heap_size
,0 },
1527 { "sqlite3_config_memstatus", test_config_memstatus
,0 },
1528 { "sqlite3_config_lookaside", test_config_lookaside
,0 },
1529 { "sqlite3_config_error", test_config_error
,0 },
1530 { "sqlite3_config_uri", test_config_uri
,0 },
1531 { "sqlite3_config_cis", test_config_cis
,0 },
1532 { "sqlite3_config_pmasz", test_config_pmasz
,0 },
1533 { "sqlite3_db_config_lookaside",test_db_config_lookaside
,0 },
1534 { "sqlite3_dump_memsys3", test_dump_memsys3
,3 },
1535 { "sqlite3_dump_memsys5", test_dump_memsys3
,5 },
1536 { "sqlite3_install_memsys3", test_install_memsys3
,0 },
1537 { "sqlite3_memdebug_vfs_oom_test", test_vfs_oom_test
,0 },
1540 for(i
=0; i
<sizeof(aObjCmd
)/sizeof(aObjCmd
[0]); i
++){
1541 ClientData c
= (ClientData
)SQLITE_INT_TO_PTR(aObjCmd
[i
].clientData
);
1542 Tcl_CreateObjCommand(interp
, aObjCmd
[i
].zName
, aObjCmd
[i
].xProc
, c
, 0);