1 /* 2 ** 2007 August 15 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 ** This file contains code used to implement test interfaces to the 14 ** memory allocation subsystem. 15 */ 16 #include "sqliteInt.h" 17 #include "tcl.h" 18 #include <stdlib.h> 19 #include <string.h> 20 #include <assert.h> 21 22 /* 23 ** This structure is used to encapsulate the global state variables used 24 ** by malloc() fault simulation. 25 */ 26 static struct MemFault { 27 int iCountdown; /* Number of pending successes before a failure */ 28 int nRepeat; /* Number of times to repeat the failure */ 29 int nBenign; /* Number of benign failures seen since last config */ 30 int nFail; /* Number of failures seen since last config */ 31 u8 enable; /* True if enabled */ 32 int isInstalled; /* True if the fault simulation layer is installed */ 33 int isBenignMode; /* True if malloc failures are considered benign */ 34 sqlite3_mem_methods m; /* 'Real' malloc implementation */ 35 } memfault; 36 37 /* 38 ** This routine exists as a place to set a breakpoint that will 39 ** fire on any simulated malloc() failure. 40 */ 41 static void sqlite3Fault(void){ 42 static int cnt = 0; 43 cnt++; 44 } 45 46 /* 47 ** Check to see if a fault should be simulated. Return true to simulate 48 ** the fault. Return false if the fault should not be simulated. 49 */ 50 static int faultsimStep(void){ 51 if( likely(!memfault.enable) ){ 52 return 0; 53 } 54 if( memfault.iCountdown>0 ){ 55 memfault.iCountdown--; 56 return 0; 57 } 58 sqlite3Fault(); 59 memfault.nFail++; 60 if( memfault.isBenignMode>0 ){ 61 memfault.nBenign++; 62 } 63 memfault.nRepeat--; 64 if( memfault.nRepeat<=0 ){ 65 memfault.enable = 0; 66 } 67 return 1; 68 } 69 70 /* 71 ** A version of sqlite3_mem_methods.xMalloc() that includes fault simulation 72 ** logic. 73 */ 74 static void *faultsimMalloc(int n){ 75 void *p = 0; 76 if( !faultsimStep() ){ 77 p = memfault.m.xMalloc(n); 78 } 79 return p; 80 } 81 82 83 /* 84 ** A version of sqlite3_mem_methods.xRealloc() that includes fault simulation 85 ** logic. 86 */ 87 static void *faultsimRealloc(void *pOld, int n){ 88 void *p = 0; 89 if( !faultsimStep() ){ 90 p = memfault.m.xRealloc(pOld, n); 91 } 92 return p; 93 } 94 95 /* 96 ** The following method calls are passed directly through to the underlying 97 ** malloc system: 98 ** 99 ** xFree 100 ** xSize 101 ** xRoundup 102 ** xInit 103 ** xShutdown 104 */ 105 static void faultsimFree(void *p){ 106 memfault.m.xFree(p); 107 } 108 static int faultsimSize(void *p){ 109 return memfault.m.xSize(p); 110 } 111 static int faultsimRoundup(int n){ 112 return memfault.m.xRoundup(n); 113 } 114 static int faultsimInit(void *p){ 115 return memfault.m.xInit(memfault.m.pAppData); 116 } 117 static void faultsimShutdown(void *p){ 118 memfault.m.xShutdown(memfault.m.pAppData); 119 } 120 121 /* 122 ** This routine configures the malloc failure simulation. After 123 ** calling this routine, the next nDelay mallocs will succeed, followed 124 ** by a block of nRepeat failures, after which malloc() calls will begin 125 ** to succeed again. 126 */ 127 static void faultsimConfig(int nDelay, int nRepeat){ 128 memfault.iCountdown = nDelay; 129 memfault.nRepeat = nRepeat; 130 memfault.nBenign = 0; 131 memfault.nFail = 0; 132 memfault.enable = nDelay>=0; 133 134 /* Sometimes, when running multi-threaded tests, the isBenignMode 135 ** variable is not properly incremented/decremented so that it is 136 ** 0 when not inside a benign malloc block. This doesn't affect 137 ** the multi-threaded tests, as they do not use this system. But 138 ** it does affect OOM tests run later in the same process. So 139 ** zero the variable here, just to be sure. 140 */ 141 memfault.isBenignMode = 0; 142 } 143 144 /* 145 ** Return the number of faults (both hard and benign faults) that have 146 ** occurred since the injector was last configured. 147 */ 148 static int faultsimFailures(void){ 149 return memfault.nFail; 150 } 151 152 /* 153 ** Return the number of benign faults that have occurred since the 154 ** injector was last configured. 155 */ 156 static int faultsimBenignFailures(void){ 157 return memfault.nBenign; 158 } 159 160 /* 161 ** Return the number of successes that will occur before the next failure. 162 ** If no failures are scheduled, return -1. 163 */ 164 static int faultsimPending(void){ 165 if( memfault.enable ){ 166 return memfault.iCountdown; 167 }else{ 168 return -1; 169 } 170 } 171 172 173 static void faultsimBeginBenign(void){ 174 memfault.isBenignMode++; 175 } 176 static void faultsimEndBenign(void){ 177 memfault.isBenignMode--; 178 } 179 180 /* 181 ** Add or remove the fault-simulation layer using sqlite3_config(). If 182 ** the argument is non-zero, the 183 */ 184 static int faultsimInstall(int install){ 185 static struct sqlite3_mem_methods m = { 186 faultsimMalloc, /* xMalloc */ 187 faultsimFree, /* xFree */ 188 faultsimRealloc, /* xRealloc */ 189 faultsimSize, /* xSize */ 190 faultsimRoundup, /* xRoundup */ 191 faultsimInit, /* xInit */ 192 faultsimShutdown, /* xShutdown */ 193 0 /* pAppData */ 194 }; 195 int rc; 196 197 install = (install ? 1 : 0); 198 assert(memfault.isInstalled==1 || memfault.isInstalled==0); 199 200 if( install==memfault.isInstalled ){ 201 return SQLITE_ERROR; 202 } 203 204 if( install ){ 205 rc = sqlite3_config(SQLITE_CONFIG_GETMALLOC, &memfault.m); 206 assert(memfault.m.xMalloc); 207 if( rc==SQLITE_OK ){ 208 rc = sqlite3_config(SQLITE_CONFIG_MALLOC, &m); 209 } 210 sqlite3_test_control(SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS, 211 faultsimBeginBenign, faultsimEndBenign 212 ); 213 }else{ 214 sqlite3_mem_methods m; 215 assert(memfault.m.xMalloc); 216 217 /* One should be able to reset the default memory allocator by storing 218 ** a zeroed allocator then calling GETMALLOC. */ 219 memset(&m, 0, sizeof(m)); 220 sqlite3_config(SQLITE_CONFIG_MALLOC, &m); 221 sqlite3_config(SQLITE_CONFIG_GETMALLOC, &m); 222 assert( memcmp(&m, &memfault.m, sizeof(m))==0 ); 223 224 rc = sqlite3_config(SQLITE_CONFIG_MALLOC, &memfault.m); 225 sqlite3_test_control(SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS, 0, 0); 226 } 227 228 if( rc==SQLITE_OK ){ 229 memfault.isInstalled = 1; 230 } 231 return rc; 232 } 233 234 #ifdef SQLITE_TEST 235 236 /* 237 ** This function is implemented in main.c. Returns a pointer to a static 238 ** buffer containing the symbolic SQLite error code that corresponds to 239 ** the least-significant 8-bits of the integer passed as an argument. 240 ** For example: 241 ** 242 ** sqlite3ErrName(1) -> "SQLITE_ERROR" 243 */ 244 extern const char *sqlite3ErrName(int); 245 246 /* 247 ** Transform pointers to text and back again 248 */ 249 static void pointerToText(void *p, char *z){ 250 static const char zHex[] = "0123456789abcdef"; 251 int i, k; 252 unsigned int u; 253 sqlite3_uint64 n; 254 if( p==0 ){ 255 strcpy(z, "0"); 256 return; 257 } 258 if( sizeof(n)==sizeof(p) ){ 259 memcpy(&n, &p, sizeof(p)); 260 }else if( sizeof(u)==sizeof(p) ){ 261 memcpy(&u, &p, sizeof(u)); 262 n = u; 263 }else{ 264 assert( 0 ); 265 } 266 for(i=0, k=sizeof(p)*2-1; i<sizeof(p)*2; i++, k--){ 267 z[k] = zHex[n&0xf]; 268 n >>= 4; 269 } 270 z[sizeof(p)*2] = 0; 271 } 272 static int hexToInt(int h){ 273 if( h>='0' && h<='9' ){ 274 return h - '0'; 275 }else if( h>='a' && h<='f' ){ 276 return h - 'a' + 10; 277 }else{ 278 return -1; 279 } 280 } 281 static int textToPointer(const char *z, void **pp){ 282 sqlite3_uint64 n = 0; 283 int i; 284 unsigned int u; 285 for(i=0; i<sizeof(void*)*2 && z[0]; i++){ 286 int v; 287 v = hexToInt(*z++); 288 if( v<0 ) return TCL_ERROR; 289 n = n*16 + v; 290 } 291 if( *z!=0 ) return TCL_ERROR; 292 if( sizeof(n)==sizeof(*pp) ){ 293 memcpy(pp, &n, sizeof(n)); 294 }else if( sizeof(u)==sizeof(*pp) ){ 295 u = (unsigned int)n; 296 memcpy(pp, &u, sizeof(u)); 297 }else{ 298 assert( 0 ); 299 } 300 return TCL_OK; 301 } 302 303 /* 304 ** Usage: sqlite3_malloc NBYTES 305 ** 306 ** Raw test interface for sqlite3_malloc(). 307 */ 308 static int test_malloc( 309 void * clientData, 310 Tcl_Interp *interp, 311 int objc, 312 Tcl_Obj *CONST objv[] 313 ){ 314 int nByte; 315 void *p; 316 char zOut[100]; 317 if( objc!=2 ){ 318 Tcl_WrongNumArgs(interp, 1, objv, "NBYTES"); 319 return TCL_ERROR; 320 } 321 if( Tcl_GetIntFromObj(interp, objv[1], &nByte) ) return TCL_ERROR; 322 p = sqlite3_malloc((unsigned)nByte); 323 pointerToText(p, zOut); 324 Tcl_AppendResult(interp, zOut, NULL); 325 return TCL_OK; 326 } 327 328 /* 329 ** Usage: sqlite3_realloc PRIOR NBYTES 330 ** 331 ** Raw test interface for sqlite3_realloc(). 332 */ 333 static int test_realloc( 334 void * clientData, 335 Tcl_Interp *interp, 336 int objc, 337 Tcl_Obj *CONST objv[] 338 ){ 339 int nByte; 340 void *pPrior, *p; 341 char zOut[100]; 342 if( objc!=3 ){ 343 Tcl_WrongNumArgs(interp, 1, objv, "PRIOR NBYTES"); 344 return TCL_ERROR; 345 } 346 if( Tcl_GetIntFromObj(interp, objv[2], &nByte) ) return TCL_ERROR; 347 if( textToPointer(Tcl_GetString(objv[1]), &pPrior) ){ 348 Tcl_AppendResult(interp, "bad pointer: ", Tcl_GetString(objv[1]), (char*)0); 349 return TCL_ERROR; 350 } 351 p = sqlite3_realloc(pPrior, (unsigned)nByte); 352 pointerToText(p, zOut); 353 Tcl_AppendResult(interp, zOut, NULL); 354 return TCL_OK; 355 } 356 357 /* 358 ** Usage: sqlite3_free PRIOR 359 ** 360 ** Raw test interface for sqlite3_free(). 361 */ 362 static int test_free( 363 void * clientData, 364 Tcl_Interp *interp, 365 int objc, 366 Tcl_Obj *CONST objv[] 367 ){ 368 void *pPrior; 369 if( objc!=2 ){ 370 Tcl_WrongNumArgs(interp, 1, objv, "PRIOR"); 371 return TCL_ERROR; 372 } 373 if( textToPointer(Tcl_GetString(objv[1]), &pPrior) ){ 374 Tcl_AppendResult(interp, "bad pointer: ", Tcl_GetString(objv[1]), (char*)0); 375 return TCL_ERROR; 376 } 377 sqlite3_free(pPrior); 378 return TCL_OK; 379 } 380 381 /* 382 ** These routines are in test_hexio.c 383 */ 384 int sqlite3TestHexToBin(const char *, int, char *); 385 int sqlite3TestBinToHex(char*,int); 386 387 /* 388 ** Usage: memset ADDRESS SIZE HEX 389 ** 390 ** Set a chunk of memory (obtained from malloc, probably) to a 391 ** specified hex pattern. 392 */ 393 static int test_memset( 394 void * clientData, 395 Tcl_Interp *interp, 396 int objc, 397 Tcl_Obj *CONST objv[] 398 ){ 399 void *p; 400 int size, n, i; 401 char *zHex; 402 char *zOut; 403 char zBin[100]; 404 405 if( objc!=4 ){ 406 Tcl_WrongNumArgs(interp, 1, objv, "ADDRESS SIZE HEX"); 407 return TCL_ERROR; 408 } 409 if( textToPointer(Tcl_GetString(objv[1]), &p) ){ 410 Tcl_AppendResult(interp, "bad pointer: ", Tcl_GetString(objv[1]), (char*)0); 411 return TCL_ERROR; 412 } 413 if( Tcl_GetIntFromObj(interp, objv[2], &size) ){ 414 return TCL_ERROR; 415 } 416 if( size<=0 ){ 417 Tcl_AppendResult(interp, "size must be positive", (char*)0); 418 return TCL_ERROR; 419 } 420 zHex = Tcl_GetStringFromObj(objv[3], &n); 421 if( n>sizeof(zBin)*2 ) n = sizeof(zBin)*2; 422 n = sqlite3TestHexToBin(zHex, n, zBin); 423 if( n==0 ){ 424 Tcl_AppendResult(interp, "no data", (char*)0); 425 return TCL_ERROR; 426 } 427 zOut = p; 428 for(i=0; i<size; i++){ 429 zOut[i] = zBin[i%n]; 430 } 431 return TCL_OK; 432 } 433 434 /* 435 ** Usage: memget ADDRESS SIZE 436 ** 437 ** Return memory as hexadecimal text. 438 */ 439 static int test_memget( 440 void * clientData, 441 Tcl_Interp *interp, 442 int objc, 443 Tcl_Obj *CONST objv[] 444 ){ 445 void *p; 446 int size, n; 447 char *zBin; 448 char zHex[100]; 449 450 if( objc!=3 ){ 451 Tcl_WrongNumArgs(interp, 1, objv, "ADDRESS SIZE"); 452 return TCL_ERROR; 453 } 454 if( textToPointer(Tcl_GetString(objv[1]), &p) ){ 455 Tcl_AppendResult(interp, "bad pointer: ", Tcl_GetString(objv[1]), (char*)0); 456 return TCL_ERROR; 457 } 458 if( Tcl_GetIntFromObj(interp, objv[2], &size) ){ 459 return TCL_ERROR; 460 } 461 if( size<=0 ){ 462 Tcl_AppendResult(interp, "size must be positive", (char*)0); 463 return TCL_ERROR; 464 } 465 zBin = p; 466 while( size>0 ){ 467 if( size>(sizeof(zHex)-1)/2 ){ 468 n = (sizeof(zHex)-1)/2; 469 }else{ 470 n = size; 471 } 472 memcpy(zHex, zBin, n); 473 zBin += n; 474 size -= n; 475 sqlite3TestBinToHex(zHex, n); 476 Tcl_AppendResult(interp, zHex, (char*)0); 477 } 478 return TCL_OK; 479 } 480 481 /* 482 ** Usage: sqlite3_memory_used 483 ** 484 ** Raw test interface for sqlite3_memory_used(). 485 */ 486 static int test_memory_used( 487 void * clientData, 488 Tcl_Interp *interp, 489 int objc, 490 Tcl_Obj *CONST objv[] 491 ){ 492 Tcl_SetObjResult(interp, Tcl_NewWideIntObj(sqlite3_memory_used())); 493 return TCL_OK; 494 } 495 496 /* 497 ** Usage: sqlite3_memory_highwater ?RESETFLAG? 498 ** 499 ** Raw test interface for sqlite3_memory_highwater(). 500 */ 501 static int test_memory_highwater( 502 void * clientData, 503 Tcl_Interp *interp, 504 int objc, 505 Tcl_Obj *CONST objv[] 506 ){ 507 int resetFlag = 0; 508 if( objc!=1 && objc!=2 ){ 509 Tcl_WrongNumArgs(interp, 1, objv, "?RESET?"); 510 return TCL_ERROR; 511 } 512 if( objc==2 ){ 513 if( Tcl_GetBooleanFromObj(interp, objv[1], &resetFlag) ) return TCL_ERROR; 514 } 515 Tcl_SetObjResult(interp, 516 Tcl_NewWideIntObj(sqlite3_memory_highwater(resetFlag))); 517 return TCL_OK; 518 } 519 520 /* 521 ** Usage: sqlite3_memdebug_backtrace DEPTH 522 ** 523 ** Set the depth of backtracing. If SQLITE_MEMDEBUG is not defined 524 ** then this routine is a no-op. 525 */ 526 static int test_memdebug_backtrace( 527 void * clientData, 528 Tcl_Interp *interp, 529 int objc, 530 Tcl_Obj *CONST objv[] 531 ){ 532 int depth; 533 if( objc!=2 ){ 534 Tcl_WrongNumArgs(interp, 1, objv, "DEPT"); 535 return TCL_ERROR; 536 } 537 if( Tcl_GetIntFromObj(interp, objv[1], &depth) ) return TCL_ERROR; 538 #ifdef SQLITE_MEMDEBUG 539 { 540 extern void sqlite3MemdebugBacktrace(int); 541 sqlite3MemdebugBacktrace(depth); 542 } 543 #endif 544 return TCL_OK; 545 } 546 547 /* 548 ** Usage: sqlite3_memdebug_dump FILENAME 549 ** 550 ** Write a summary of unfreed memory to FILENAME. 551 */ 552 static int test_memdebug_dump( 553 void * clientData, 554 Tcl_Interp *interp, 555 int objc, 556 Tcl_Obj *CONST objv[] 557 ){ 558 if( objc!=2 ){ 559 Tcl_WrongNumArgs(interp, 1, objv, "FILENAME"); 560 return TCL_ERROR; 561 } 562 #if defined(SQLITE_MEMDEBUG) || defined(SQLITE_MEMORY_SIZE) \ 563 || defined(SQLITE_POW2_MEMORY_SIZE) 564 { 565 extern void sqlite3MemdebugDump(const char*); 566 sqlite3MemdebugDump(Tcl_GetString(objv[1])); 567 } 568 #endif 569 return TCL_OK; 570 } 571 572 /* 573 ** Usage: sqlite3_memdebug_malloc_count 574 ** 575 ** Return the total number of times malloc() has been called. 576 */ 577 static int test_memdebug_malloc_count( 578 void * clientData, 579 Tcl_Interp *interp, 580 int objc, 581 Tcl_Obj *CONST objv[] 582 ){ 583 int nMalloc = -1; 584 if( objc!=1 ){ 585 Tcl_WrongNumArgs(interp, 1, objv, ""); 586 return TCL_ERROR; 587 } 588 #if defined(SQLITE_MEMDEBUG) 589 { 590 extern int sqlite3MemdebugMallocCount(); 591 nMalloc = sqlite3MemdebugMallocCount(); 592 } 593 #endif 594 Tcl_SetObjResult(interp, Tcl_NewIntObj(nMalloc)); 595 return TCL_OK; 596 } 597 598 599 /* 600 ** Usage: sqlite3_memdebug_fail COUNTER ?OPTIONS? 601 ** 602 ** where options are: 603 ** 604 ** -repeat <count> 605 ** -benigncnt <varname> 606 ** 607 ** Arrange for a simulated malloc() failure after COUNTER successes. 608 ** If a repeat count is specified, the fault is repeated that many 609 ** times. 610 ** 611 ** Each call to this routine overrides the prior counter value. 612 ** This routine returns the number of simulated failures that have 613 ** happened since the previous call to this routine. 614 ** 615 ** To disable simulated failures, use a COUNTER of -1. 616 */ 617 static int test_memdebug_fail( 618 void * clientData, 619 Tcl_Interp *interp, 620 int objc, 621 Tcl_Obj *CONST objv[] 622 ){ 623 int ii; 624 int iFail; 625 int nRepeat = 1; 626 Tcl_Obj *pBenignCnt = 0; 627 int nBenign; 628 int nFail = 0; 629 630 if( objc<2 ){ 631 Tcl_WrongNumArgs(interp, 1, objv, "COUNTER ?OPTIONS?"); 632 return TCL_ERROR; 633 } 634 if( Tcl_GetIntFromObj(interp, objv[1], &iFail) ) return TCL_ERROR; 635 636 for(ii=2; ii<objc; ii+=2){ 637 int nOption; 638 char *zOption = Tcl_GetStringFromObj(objv[ii], &nOption); 639 char *zErr = 0; 640 641 if( nOption>1 && strncmp(zOption, "-repeat", nOption)==0 ){ 642 if( ii==(objc-1) ){ 643 zErr = "option requires an argument: "; 644 }else{ 645 if( Tcl_GetIntFromObj(interp, objv[ii+1], &nRepeat) ){ 646 return TCL_ERROR; 647 } 648 } 649 }else if( nOption>1 && strncmp(zOption, "-benigncnt", nOption)==0 ){ 650 if( ii==(objc-1) ){ 651 zErr = "option requires an argument: "; 652 }else{ 653 pBenignCnt = objv[ii+1]; 654 } 655 }else{ 656 zErr = "unknown option: "; 657 } 658 659 if( zErr ){ 660 Tcl_AppendResult(interp, zErr, zOption, 0); 661 return TCL_ERROR; 662 } 663 } 664 665 nBenign = faultsimBenignFailures(); 666 nFail = faultsimFailures(); 667 faultsimConfig(iFail, nRepeat); 668 669 if( pBenignCnt ){ 670 Tcl_ObjSetVar2(interp, pBenignCnt, 0, Tcl_NewIntObj(nBenign), 0); 671 } 672 Tcl_SetObjResult(interp, Tcl_NewIntObj(nFail)); 673 return TCL_OK; 674 } 675 676 /* 677 ** Usage: sqlite3_memdebug_pending 678 ** 679 ** Return the number of malloc() calls that will succeed before a 680 ** simulated failure occurs. A negative return value indicates that 681 ** no malloc() failure is scheduled. 682 */ 683 static int test_memdebug_pending( 684 void * clientData, 685 Tcl_Interp *interp, 686 int objc, 687 Tcl_Obj *CONST objv[] 688 ){ 689 int nPending; 690 if( objc!=1 ){ 691 Tcl_WrongNumArgs(interp, 1, objv, ""); 692 return TCL_ERROR; 693 } 694 nPending = faultsimPending(); 695 Tcl_SetObjResult(interp, Tcl_NewIntObj(nPending)); 696 return TCL_OK; 697 } 698 699 700 /* 701 ** Usage: sqlite3_memdebug_settitle TITLE 702 ** 703 ** Set a title string stored with each allocation. The TITLE is 704 ** typically the name of the test that was running when the 705 ** allocation occurred. The TITLE is stored with the allocation 706 ** and can be used to figure out which tests are leaking memory. 707 ** 708 ** Each title overwrite the previous. 709 */ 710 static int test_memdebug_settitle( 711 void * clientData, 712 Tcl_Interp *interp, 713 int objc, 714 Tcl_Obj *CONST objv[] 715 ){ 716 if( objc!=2 ){ 717 Tcl_WrongNumArgs(interp, 1, objv, "TITLE"); 718 return TCL_ERROR; 719 } 720 #ifdef SQLITE_MEMDEBUG 721 { 722 const char *zTitle; 723 extern int sqlite3MemdebugSettitle(const char*); 724 zTitle = Tcl_GetString(objv[1]); 725 sqlite3MemdebugSettitle(zTitle); 726 } 727 #endif 728 return TCL_OK; 729 } 730 731 #define MALLOC_LOG_FRAMES 10 732 #define MALLOC_LOG_KEYINTS ( \ 733 10 * ((sizeof(int)>=sizeof(void*)) ? 1 : sizeof(void*)/sizeof(int)) \ 734 ) 735 static Tcl_HashTable aMallocLog; 736 static int mallocLogEnabled = 0; 737 738 typedef struct MallocLog MallocLog; 739 struct MallocLog { 740 int nCall; 741 int nByte; 742 }; 743 744 #ifdef SQLITE_MEMDEBUG 745 static void test_memdebug_callback(int nByte, int nFrame, void **aFrame){ 746 if( mallocLogEnabled ){ 747 MallocLog *pLog; 748 Tcl_HashEntry *pEntry; 749 int isNew; 750 751 int aKey[MALLOC_LOG_KEYINTS]; 752 unsigned int nKey = sizeof(int)*MALLOC_LOG_KEYINTS; 753 754 memset(aKey, 0, nKey); 755 if( (sizeof(void*)*nFrame)<nKey ){ 756 nKey = nFrame*sizeof(void*); 757 } 758 memcpy(aKey, aFrame, nKey); 759 760 pEntry = Tcl_CreateHashEntry(&aMallocLog, (const char *)aKey, &isNew); 761 if( isNew ){ 762 pLog = (MallocLog *)Tcl_Alloc(sizeof(MallocLog)); 763 memset(pLog, 0, sizeof(MallocLog)); 764 Tcl_SetHashValue(pEntry, (ClientData)pLog); 765 }else{ 766 pLog = (MallocLog *)Tcl_GetHashValue(pEntry); 767 } 768 769 pLog->nCall++; 770 pLog->nByte += nByte; 771 } 772 } 773 #endif /* SQLITE_MEMDEBUG */ 774 775 static void test_memdebug_log_clear(void){ 776 Tcl_HashSearch search; 777 Tcl_HashEntry *pEntry; 778 for( 779 pEntry=Tcl_FirstHashEntry(&aMallocLog, &search); 780 pEntry; 781 pEntry=Tcl_NextHashEntry(&search) 782 ){ 783 MallocLog *pLog = (MallocLog *)Tcl_GetHashValue(pEntry); 784 Tcl_Free((char *)pLog); 785 } 786 Tcl_DeleteHashTable(&aMallocLog); 787 Tcl_InitHashTable(&aMallocLog, MALLOC_LOG_KEYINTS); 788 } 789 790 static int test_memdebug_log( 791 void * clientData, 792 Tcl_Interp *interp, 793 int objc, 794 Tcl_Obj *CONST objv[] 795 ){ 796 static int isInit = 0; 797 int iSub; 798 799 static const char *MB_strs[] = { "start", "stop", "dump", "clear", "sync" }; 800 enum MB_enum { 801 MB_LOG_START, MB_LOG_STOP, MB_LOG_DUMP, MB_LOG_CLEAR, MB_LOG_SYNC 802 }; 803 804 if( !isInit ){ 805 #ifdef SQLITE_MEMDEBUG 806 extern void sqlite3MemdebugBacktraceCallback( 807 void (*xBacktrace)(int, int, void **)); 808 sqlite3MemdebugBacktraceCallback(test_memdebug_callback); 809 #endif 810 Tcl_InitHashTable(&aMallocLog, MALLOC_LOG_KEYINTS); 811 isInit = 1; 812 } 813 814 if( objc<2 ){ 815 Tcl_WrongNumArgs(interp, 1, objv, "SUB-COMMAND ..."); 816 } 817 if( Tcl_GetIndexFromObj(interp, objv[1], MB_strs, "sub-command", 0, &iSub) ){ 818 return TCL_ERROR; 819 } 820 821 switch( (enum MB_enum)iSub ){ 822 case MB_LOG_START: 823 mallocLogEnabled = 1; 824 break; 825 case MB_LOG_STOP: 826 mallocLogEnabled = 0; 827 break; 828 case MB_LOG_DUMP: { 829 Tcl_HashSearch search; 830 Tcl_HashEntry *pEntry; 831 Tcl_Obj *pRet = Tcl_NewObj(); 832 833 assert(sizeof(Tcl_WideInt)>=sizeof(void*)); 834 835 for( 836 pEntry=Tcl_FirstHashEntry(&aMallocLog, &search); 837 pEntry; 838 pEntry=Tcl_NextHashEntry(&search) 839 ){ 840 Tcl_Obj *apElem[MALLOC_LOG_FRAMES+2]; 841 MallocLog *pLog = (MallocLog *)Tcl_GetHashValue(pEntry); 842 Tcl_WideInt *aKey = (Tcl_WideInt *)Tcl_GetHashKey(&aMallocLog, pEntry); 843 int ii; 844 845 apElem[0] = Tcl_NewIntObj(pLog->nCall); 846 apElem[1] = Tcl_NewIntObj(pLog->nByte); 847 for(ii=0; ii<MALLOC_LOG_FRAMES; ii++){ 848 apElem[ii+2] = Tcl_NewWideIntObj(aKey[ii]); 849 } 850 851 Tcl_ListObjAppendElement(interp, pRet, 852 Tcl_NewListObj(MALLOC_LOG_FRAMES+2, apElem) 853 ); 854 } 855 856 Tcl_SetObjResult(interp, pRet); 857 break; 858 } 859 case MB_LOG_CLEAR: { 860 test_memdebug_log_clear(); 861 break; 862 } 863 864 case MB_LOG_SYNC: { 865 #ifdef SQLITE_MEMDEBUG 866 extern void sqlite3MemdebugSync(); 867 test_memdebug_log_clear(); 868 mallocLogEnabled = 1; 869 sqlite3MemdebugSync(); 870 #endif 871 break; 872 } 873 } 874 875 return TCL_OK; 876 } 877 878 /* 879 ** Usage: sqlite3_config_scratch SIZE N 880 ** 881 ** Set the scratch memory buffer using SQLITE_CONFIG_SCRATCH. 882 ** The buffer is static and is of limited size. N might be 883 ** adjusted downward as needed to accomodate the requested size. 884 ** The revised value of N is returned. 885 ** 886 ** A negative SIZE causes the buffer pointer to be NULL. 887 */ 888 static int test_config_scratch( 889 void * clientData, 890 Tcl_Interp *interp, 891 int objc, 892 Tcl_Obj *CONST objv[] 893 ){ 894 int sz, N, rc; 895 Tcl_Obj *pResult; 896 static char *buf = 0; 897 if( objc!=3 ){ 898 Tcl_WrongNumArgs(interp, 1, objv, "SIZE N"); 899 return TCL_ERROR; 900 } 901 if( Tcl_GetIntFromObj(interp, objv[1], &sz) ) return TCL_ERROR; 902 if( Tcl_GetIntFromObj(interp, objv[2], &N) ) return TCL_ERROR; 903 free(buf); 904 if( sz<0 ){ 905 buf = 0; 906 rc = sqlite3_config(SQLITE_CONFIG_SCRATCH, 0, 0, 0); 907 }else{ 908 buf = malloc( sz*N + 1 ); 909 rc = sqlite3_config(SQLITE_CONFIG_SCRATCH, buf, sz, N); 910 } 911 pResult = Tcl_NewObj(); 912 Tcl_ListObjAppendElement(0, pResult, Tcl_NewIntObj(rc)); 913 Tcl_ListObjAppendElement(0, pResult, Tcl_NewIntObj(N)); 914 Tcl_SetObjResult(interp, pResult); 915 return TCL_OK; 916 } 917 918 /* 919 ** Usage: sqlite3_config_pagecache SIZE N 920 ** 921 ** Set the page-cache memory buffer using SQLITE_CONFIG_PAGECACHE. 922 ** The buffer is static and is of limited size. N might be 923 ** adjusted downward as needed to accomodate the requested size. 924 ** The revised value of N is returned. 925 ** 926 ** A negative SIZE causes the buffer pointer to be NULL. 927 */ 928 static int test_config_pagecache( 929 void * clientData, 930 Tcl_Interp *interp, 931 int objc, 932 Tcl_Obj *CONST objv[] 933 ){ 934 int sz, N, rc; 935 Tcl_Obj *pResult; 936 static char *buf = 0; 937 if( objc!=3 ){ 938 Tcl_WrongNumArgs(interp, 1, objv, "SIZE N"); 939 return TCL_ERROR; 940 } 941 if( Tcl_GetIntFromObj(interp, objv[1], &sz) ) return TCL_ERROR; 942 if( Tcl_GetIntFromObj(interp, objv[2], &N) ) return TCL_ERROR; 943 free(buf); 944 if( sz<0 ){ 945 buf = 0; 946 rc = sqlite3_config(SQLITE_CONFIG_PAGECACHE, 0, 0, 0); 947 }else{ 948 buf = malloc( sz*N ); 949 rc = sqlite3_config(SQLITE_CONFIG_PAGECACHE, buf, sz, N); 950 } 951 pResult = Tcl_NewObj(); 952 Tcl_ListObjAppendElement(0, pResult, Tcl_NewIntObj(rc)); 953 Tcl_ListObjAppendElement(0, pResult, Tcl_NewIntObj(N)); 954 Tcl_SetObjResult(interp, pResult); 955 return TCL_OK; 956 } 957 958 /* 959 ** Usage: sqlite3_config_alt_pcache INSTALL_FLAG DISCARD_CHANCE PRNG_SEED 960 ** 961 ** Set up the alternative test page cache. Install if INSTALL_FLAG is 962 ** true and uninstall (reverting to the default page cache) if INSTALL_FLAG 963 ** is false. DISCARD_CHANGE is an integer between 0 and 100 inclusive 964 ** which determines the chance of discarding a page when unpinned. 100 965 ** is certainty. 0 is never. PRNG_SEED is the pseudo-random number generator 966 ** seed. 967 */ 968 static int test_alt_pcache( 969 void * clientData, 970 Tcl_Interp *interp, 971 int objc, 972 Tcl_Obj *CONST objv[] 973 ){ 974 int installFlag; 975 int discardChance = 0; 976 int prngSeed = 0; 977 int highStress = 0; 978 extern void installTestPCache(int,unsigned,unsigned,unsigned); 979 if( objc<2 || objc>5 ){ 980 Tcl_WrongNumArgs(interp, 1, objv, 981 "INSTALLFLAG DISCARDCHANCE PRNGSEEED HIGHSTRESS"); 982 return TCL_ERROR; 983 } 984 if( Tcl_GetIntFromObj(interp, objv[1], &installFlag) ) return TCL_ERROR; 985 if( objc>=3 && Tcl_GetIntFromObj(interp, objv[2], &discardChance) ){ 986 return TCL_ERROR; 987 } 988 if( objc>=4 && Tcl_GetIntFromObj(interp, objv[3], &prngSeed) ){ 989 return TCL_ERROR; 990 } 991 if( objc>=5 && Tcl_GetIntFromObj(interp, objv[4], &highStress) ){ 992 return TCL_ERROR; 993 } 994 if( discardChance<0 || discardChance>100 ){ 995 Tcl_AppendResult(interp, "discard-chance should be between 0 and 100", 996 (char*)0); 997 return TCL_ERROR; 998 } 999 installTestPCache(installFlag, (unsigned)discardChance, (unsigned)prngSeed, 1000 (unsigned)highStress); 1001 return TCL_OK; 1002 } 1003 1004 /* 1005 ** Usage: sqlite3_config_memstatus BOOLEAN 1006 ** 1007 ** Enable or disable memory status reporting using SQLITE_CONFIG_MEMSTATUS. 1008 */ 1009 static int test_config_memstatus( 1010 void * clientData, 1011 Tcl_Interp *interp, 1012 int objc, 1013 Tcl_Obj *CONST objv[] 1014 ){ 1015 int enable, rc; 1016 if( objc!=2 ){ 1017 Tcl_WrongNumArgs(interp, 1, objv, "BOOLEAN"); 1018 return TCL_ERROR; 1019 } 1020 if( Tcl_GetBooleanFromObj(interp, objv[1], &enable) ) return TCL_ERROR; 1021 rc = sqlite3_config(SQLITE_CONFIG_MEMSTATUS, enable); 1022 Tcl_SetObjResult(interp, Tcl_NewIntObj(rc)); 1023 return TCL_OK; 1024 } 1025 1026 /* 1027 ** Usage: sqlite3_config_lookaside SIZE COUNT 1028 ** 1029 */ 1030 static int test_config_lookaside( 1031 void * clientData, 1032 Tcl_Interp *interp, 1033 int objc, 1034 Tcl_Obj *CONST objv[] 1035 ){ 1036 int sz, cnt; 1037 Tcl_Obj *pRet; 1038 if( objc!=3 ){ 1039 Tcl_WrongNumArgs(interp, 1, objv, "SIZE COUNT"); 1040 return TCL_ERROR; 1041 } 1042 if( Tcl_GetIntFromObj(interp, objv[1], &sz) ) return TCL_ERROR; 1043 if( Tcl_GetIntFromObj(interp, objv[2], &cnt) ) return TCL_ERROR; 1044 pRet = Tcl_NewObj(); 1045 Tcl_ListObjAppendElement( 1046 interp, pRet, Tcl_NewIntObj(sqlite3GlobalConfig.szLookaside) 1047 ); 1048 Tcl_ListObjAppendElement( 1049 interp, pRet, Tcl_NewIntObj(sqlite3GlobalConfig.nLookaside) 1050 ); 1051 sqlite3_config(SQLITE_CONFIG_LOOKASIDE, sz, cnt); 1052 Tcl_SetObjResult(interp, pRet); 1053 return TCL_OK; 1054 } 1055 1056 1057 /* 1058 ** Usage: sqlite3_db_config_lookaside CONNECTION BUFID SIZE COUNT 1059 ** 1060 ** There are two static buffers with BUFID 1 and 2. Each static buffer 1061 ** is 10KB in size. A BUFID of 0 indicates that the buffer should be NULL 1062 ** which will cause sqlite3_db_config() to allocate space on its own. 1063 */ 1064 static int test_db_config_lookaside( 1065 void * clientData, 1066 Tcl_Interp *interp, 1067 int objc, 1068 Tcl_Obj *CONST objv[] 1069 ){ 1070 int rc; 1071 int sz, cnt; 1072 sqlite3 *db; 1073 int bufid; 1074 static char azBuf[2][10000]; 1075 extern int getDbPointer(Tcl_Interp*, const char*, sqlite3**); 1076 if( objc!=5 ){ 1077 Tcl_WrongNumArgs(interp, 1, objv, "BUFID SIZE COUNT"); 1078 return TCL_ERROR; 1079 } 1080 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 1081 if( Tcl_GetIntFromObj(interp, objv[2], &bufid) ) return TCL_ERROR; 1082 if( Tcl_GetIntFromObj(interp, objv[3], &sz) ) return TCL_ERROR; 1083 if( Tcl_GetIntFromObj(interp, objv[4], &cnt) ) return TCL_ERROR; 1084 if( bufid==0 ){ 1085 rc = sqlite3_db_config(db, SQLITE_DBCONFIG_LOOKASIDE, 0, sz, cnt); 1086 }else if( bufid>=1 && bufid<=2 && sz*cnt<=sizeof(azBuf[0]) ){ 1087 rc = sqlite3_db_config(db, SQLITE_DBCONFIG_LOOKASIDE, azBuf[bufid], sz,cnt); 1088 }else{ 1089 Tcl_AppendResult(interp, "illegal arguments - see documentation", (char*)0); 1090 return TCL_ERROR; 1091 } 1092 Tcl_SetObjResult(interp, Tcl_NewIntObj(rc)); 1093 return TCL_OK; 1094 } 1095 1096 /* 1097 ** Usage: sqlite3_config_heap NBYTE NMINALLOC 1098 */ 1099 static int test_config_heap( 1100 void * clientData, 1101 Tcl_Interp *interp, 1102 int objc, 1103 Tcl_Obj *CONST objv[] 1104 ){ 1105 static char *zBuf; /* Use this memory */ 1106 int nByte; /* Size of buffer to pass to sqlite3_config() */ 1107 int nMinAlloc; /* Size of minimum allocation */ 1108 int rc; /* Return code of sqlite3_config() */ 1109 1110 Tcl_Obj * CONST *aArg = &objv[1]; 1111 int nArg = objc-1; 1112 1113 if( nArg!=2 ){ 1114 Tcl_WrongNumArgs(interp, 1, objv, "NBYTE NMINALLOC"); 1115 return TCL_ERROR; 1116 } 1117 if( Tcl_GetIntFromObj(interp, aArg[0], &nByte) ) return TCL_ERROR; 1118 if( Tcl_GetIntFromObj(interp, aArg[1], &nMinAlloc) ) return TCL_ERROR; 1119 1120 if( nByte==0 ){ 1121 free( zBuf ); 1122 zBuf = 0; 1123 rc = sqlite3_config(SQLITE_CONFIG_HEAP, (void*)0, 0, 0); 1124 }else{ 1125 zBuf = realloc(zBuf, nByte); 1126 rc = sqlite3_config(SQLITE_CONFIG_HEAP, zBuf, nByte, nMinAlloc); 1127 } 1128 1129 Tcl_SetResult(interp, (char *)sqlite3ErrName(rc), TCL_VOLATILE); 1130 return TCL_OK; 1131 } 1132 1133 /* 1134 ** Usage: sqlite3_config_heap_size NBYTE 1135 */ 1136 static int test_config_heap_size( 1137 void * clientData, 1138 Tcl_Interp *interp, 1139 int objc, 1140 Tcl_Obj *CONST objv[] 1141 ){ 1142 int nByte; /* Size to pass to sqlite3_config() */ 1143 int rc; /* Return code of sqlite3_config() */ 1144 1145 Tcl_Obj * CONST *aArg = &objv[1]; 1146 int nArg = objc-1; 1147 1148 if( nArg!=1 ){ 1149 Tcl_WrongNumArgs(interp, 1, objv, "NBYTE"); 1150 return TCL_ERROR; 1151 } 1152 if( Tcl_GetIntFromObj(interp, aArg[0], &nByte) ) return TCL_ERROR; 1153 1154 rc = sqlite3_config(SQLITE_CONFIG_WIN32_HEAPSIZE, nByte); 1155 1156 Tcl_SetResult(interp, (char *)sqlite3ErrName(rc), TCL_VOLATILE); 1157 return TCL_OK; 1158 } 1159 1160 /* 1161 ** Usage: sqlite3_config_error [DB] 1162 ** 1163 ** Invoke sqlite3_config() or sqlite3_db_config() with invalid 1164 ** opcodes and verify that they return errors. 1165 */ 1166 static int test_config_error( 1167 void * clientData, 1168 Tcl_Interp *interp, 1169 int objc, 1170 Tcl_Obj *CONST objv[] 1171 ){ 1172 sqlite3 *db; 1173 extern int getDbPointer(Tcl_Interp*, const char*, sqlite3**); 1174 1175 if( objc!=2 && objc!=1 ){ 1176 Tcl_WrongNumArgs(interp, 1, objv, "[DB]"); 1177 return TCL_ERROR; 1178 } 1179 if( objc==2 ){ 1180 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 1181 if( sqlite3_db_config(db, 99999)!=SQLITE_ERROR ){ 1182 Tcl_AppendResult(interp, 1183 "sqlite3_db_config(db, 99999) does not return SQLITE_ERROR", 1184 (char*)0); 1185 return TCL_ERROR; 1186 } 1187 }else{ 1188 if( sqlite3_config(99999)!=SQLITE_ERROR ){ 1189 Tcl_AppendResult(interp, 1190 "sqlite3_config(99999) does not return SQLITE_ERROR", 1191 (char*)0); 1192 return TCL_ERROR; 1193 } 1194 } 1195 return TCL_OK; 1196 } 1197 1198 /* 1199 ** Usage: sqlite3_config_uri BOOLEAN 1200 ** 1201 ** Enables or disables interpretation of URI parameters by default using 1202 ** SQLITE_CONFIG_URI. 1203 */ 1204 static int test_config_uri( 1205 void * clientData, 1206 Tcl_Interp *interp, 1207 int objc, 1208 Tcl_Obj *CONST objv[] 1209 ){ 1210 int rc; 1211 int bOpenUri; 1212 1213 if( objc!=2 ){ 1214 Tcl_WrongNumArgs(interp, 1, objv, "BOOL"); 1215 return TCL_ERROR; 1216 } 1217 if( Tcl_GetBooleanFromObj(interp, objv[1], &bOpenUri) ){ 1218 return TCL_ERROR; 1219 } 1220 1221 rc = sqlite3_config(SQLITE_CONFIG_URI, bOpenUri); 1222 Tcl_SetResult(interp, (char *)sqlite3ErrName(rc), TCL_VOLATILE); 1223 1224 return TCL_OK; 1225 } 1226 1227 /* 1228 ** Usage: sqlite3_config_cis BOOLEAN 1229 ** 1230 ** Enables or disables the use of the covering-index scan optimization. 1231 ** SQLITE_CONFIG_COVERING_INDEX_SCAN. 1232 */ 1233 static int test_config_cis( 1234 void * clientData, 1235 Tcl_Interp *interp, 1236 int objc, 1237 Tcl_Obj *CONST objv[] 1238 ){ 1239 int rc; 1240 int bUseCis; 1241 1242 if( objc!=2 ){ 1243 Tcl_WrongNumArgs(interp, 1, objv, "BOOL"); 1244 return TCL_ERROR; 1245 } 1246 if( Tcl_GetBooleanFromObj(interp, objv[1], &bUseCis) ){ 1247 return TCL_ERROR; 1248 } 1249 1250 rc = sqlite3_config(SQLITE_CONFIG_COVERING_INDEX_SCAN, bUseCis); 1251 Tcl_SetResult(interp, (char *)sqlite3ErrName(rc), TCL_VOLATILE); 1252 1253 return TCL_OK; 1254 } 1255 1256 /* 1257 ** Usage: sqlite3_dump_memsys3 FILENAME 1258 ** sqlite3_dump_memsys5 FILENAME 1259 ** 1260 ** Write a summary of unfreed memsys3 allocations to FILENAME. 1261 */ 1262 static int test_dump_memsys3( 1263 void * clientData, 1264 Tcl_Interp *interp, 1265 int objc, 1266 Tcl_Obj *CONST objv[] 1267 ){ 1268 if( objc!=2 ){ 1269 Tcl_WrongNumArgs(interp, 1, objv, "FILENAME"); 1270 return TCL_ERROR; 1271 } 1272 1273 switch( SQLITE_PTR_TO_INT(clientData) ){ 1274 case 3: { 1275 #ifdef SQLITE_ENABLE_MEMSYS3 1276 extern void sqlite3Memsys3Dump(const char*); 1277 sqlite3Memsys3Dump(Tcl_GetString(objv[1])); 1278 break; 1279 #endif 1280 } 1281 case 5: { 1282 #ifdef SQLITE_ENABLE_MEMSYS5 1283 extern void sqlite3Memsys5Dump(const char*); 1284 sqlite3Memsys5Dump(Tcl_GetString(objv[1])); 1285 break; 1286 #endif 1287 } 1288 } 1289 return TCL_OK; 1290 } 1291 1292 /* 1293 ** Usage: sqlite3_status OPCODE RESETFLAG 1294 ** 1295 ** Return a list of three elements which are the sqlite3_status() return 1296 ** code, the current value, and the high-water mark value. 1297 */ 1298 static int test_status( 1299 void * clientData, 1300 Tcl_Interp *interp, 1301 int objc, 1302 Tcl_Obj *CONST objv[] 1303 ){ 1304 int rc, iValue, mxValue; 1305 int i, op, resetFlag; 1306 const char *zOpName; 1307 static const struct { 1308 const char *zName; 1309 int op; 1310 } aOp[] = { 1311 { "SQLITE_STATUS_MEMORY_USED", SQLITE_STATUS_MEMORY_USED }, 1312 { "SQLITE_STATUS_MALLOC_SIZE", SQLITE_STATUS_MALLOC_SIZE }, 1313 { "SQLITE_STATUS_PAGECACHE_USED", SQLITE_STATUS_PAGECACHE_USED }, 1314 { "SQLITE_STATUS_PAGECACHE_OVERFLOW", SQLITE_STATUS_PAGECACHE_OVERFLOW }, 1315 { "SQLITE_STATUS_PAGECACHE_SIZE", SQLITE_STATUS_PAGECACHE_SIZE }, 1316 { "SQLITE_STATUS_SCRATCH_USED", SQLITE_STATUS_SCRATCH_USED }, 1317 { "SQLITE_STATUS_SCRATCH_OVERFLOW", SQLITE_STATUS_SCRATCH_OVERFLOW }, 1318 { "SQLITE_STATUS_SCRATCH_SIZE", SQLITE_STATUS_SCRATCH_SIZE }, 1319 { "SQLITE_STATUS_PARSER_STACK", SQLITE_STATUS_PARSER_STACK }, 1320 { "SQLITE_STATUS_MALLOC_COUNT", SQLITE_STATUS_MALLOC_COUNT }, 1321 }; 1322 Tcl_Obj *pResult; 1323 if( objc!=3 ){ 1324 Tcl_WrongNumArgs(interp, 1, objv, "PARAMETER RESETFLAG"); 1325 return TCL_ERROR; 1326 } 1327 zOpName = Tcl_GetString(objv[1]); 1328 for(i=0; i<ArraySize(aOp); i++){ 1329 if( strcmp(aOp[i].zName, zOpName)==0 ){ 1330 op = aOp[i].op; 1331 break; 1332 } 1333 } 1334 if( i>=ArraySize(aOp) ){ 1335 if( Tcl_GetIntFromObj(interp, objv[1], &op) ) return TCL_ERROR; 1336 } 1337 if( Tcl_GetBooleanFromObj(interp, objv[2], &resetFlag) ) return TCL_ERROR; 1338 iValue = 0; 1339 mxValue = 0; 1340 rc = sqlite3_status(op, &iValue, &mxValue, resetFlag); 1341 pResult = Tcl_NewObj(); 1342 Tcl_ListObjAppendElement(0, pResult, Tcl_NewIntObj(rc)); 1343 Tcl_ListObjAppendElement(0, pResult, Tcl_NewIntObj(iValue)); 1344 Tcl_ListObjAppendElement(0, pResult, Tcl_NewIntObj(mxValue)); 1345 Tcl_SetObjResult(interp, pResult); 1346 return TCL_OK; 1347 } 1348 1349 /* 1350 ** Usage: sqlite3_db_status DATABASE OPCODE RESETFLAG 1351 ** 1352 ** Return a list of three elements which are the sqlite3_db_status() return 1353 ** code, the current value, and the high-water mark value. 1354 */ 1355 static int test_db_status( 1356 void * clientData, 1357 Tcl_Interp *interp, 1358 int objc, 1359 Tcl_Obj *CONST objv[] 1360 ){ 1361 int rc, iValue, mxValue; 1362 int i, op, resetFlag; 1363 const char *zOpName; 1364 sqlite3 *db; 1365 extern int getDbPointer(Tcl_Interp*, const char*, sqlite3**); 1366 static const struct { 1367 const char *zName; 1368 int op; 1369 } aOp[] = { 1370 { "LOOKASIDE_USED", SQLITE_DBSTATUS_LOOKASIDE_USED }, 1371 { "CACHE_USED", SQLITE_DBSTATUS_CACHE_USED }, 1372 { "SCHEMA_USED", SQLITE_DBSTATUS_SCHEMA_USED }, 1373 { "STMT_USED", SQLITE_DBSTATUS_STMT_USED }, 1374 { "LOOKASIDE_HIT", SQLITE_DBSTATUS_LOOKASIDE_HIT }, 1375 { "LOOKASIDE_MISS_SIZE", SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE }, 1376 { "LOOKASIDE_MISS_FULL", SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL }, 1377 { "CACHE_HIT", SQLITE_DBSTATUS_CACHE_HIT }, 1378 { "CACHE_MISS", SQLITE_DBSTATUS_CACHE_MISS }, 1379 { "CACHE_WRITE", SQLITE_DBSTATUS_CACHE_WRITE }, 1380 { "DEFERRED_FKS", SQLITE_DBSTATUS_DEFERRED_FKS } 1381 }; 1382 Tcl_Obj *pResult; 1383 if( objc!=4 ){ 1384 Tcl_WrongNumArgs(interp, 1, objv, "DB PARAMETER RESETFLAG"); 1385 return TCL_ERROR; 1386 } 1387 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 1388 zOpName = Tcl_GetString(objv[2]); 1389 if( memcmp(zOpName, "SQLITE_", 7)==0 ) zOpName += 7; 1390 if( memcmp(zOpName, "DBSTATUS_", 9)==0 ) zOpName += 9; 1391 for(i=0; i<ArraySize(aOp); i++){ 1392 if( strcmp(aOp[i].zName, zOpName)==0 ){ 1393 op = aOp[i].op; 1394 break; 1395 } 1396 } 1397 if( i>=ArraySize(aOp) ){ 1398 if( Tcl_GetIntFromObj(interp, objv[2], &op) ) return TCL_ERROR; 1399 } 1400 if( Tcl_GetBooleanFromObj(interp, objv[3], &resetFlag) ) return TCL_ERROR; 1401 iValue = 0; 1402 mxValue = 0; 1403 rc = sqlite3_db_status(db, op, &iValue, &mxValue, resetFlag); 1404 pResult = Tcl_NewObj(); 1405 Tcl_ListObjAppendElement(0, pResult, Tcl_NewIntObj(rc)); 1406 Tcl_ListObjAppendElement(0, pResult, Tcl_NewIntObj(iValue)); 1407 Tcl_ListObjAppendElement(0, pResult, Tcl_NewIntObj(mxValue)); 1408 Tcl_SetObjResult(interp, pResult); 1409 return TCL_OK; 1410 } 1411 1412 /* 1413 ** install_malloc_faultsim BOOLEAN 1414 */ 1415 static int test_install_malloc_faultsim( 1416 void * clientData, 1417 Tcl_Interp *interp, 1418 int objc, 1419 Tcl_Obj *CONST objv[] 1420 ){ 1421 int rc; 1422 int isInstall; 1423 1424 if( objc!=2 ){ 1425 Tcl_WrongNumArgs(interp, 1, objv, "BOOLEAN"); 1426 return TCL_ERROR; 1427 } 1428 if( TCL_OK!=Tcl_GetBooleanFromObj(interp, objv[1], &isInstall) ){ 1429 return TCL_ERROR; 1430 } 1431 rc = faultsimInstall(isInstall); 1432 Tcl_SetResult(interp, (char *)sqlite3ErrName(rc), TCL_VOLATILE); 1433 return TCL_OK; 1434 } 1435 1436 /* 1437 ** sqlite3_install_memsys3 1438 */ 1439 static int test_install_memsys3( 1440 void * clientData, 1441 Tcl_Interp *interp, 1442 int objc, 1443 Tcl_Obj *CONST objv[] 1444 ){ 1445 int rc = SQLITE_MISUSE; 1446 #ifdef SQLITE_ENABLE_MEMSYS3 1447 const sqlite3_mem_methods *sqlite3MemGetMemsys3(void); 1448 rc = sqlite3_config(SQLITE_CONFIG_MALLOC, sqlite3MemGetMemsys3()); 1449 #endif 1450 Tcl_SetResult(interp, (char *)sqlite3ErrName(rc), TCL_VOLATILE); 1451 return TCL_OK; 1452 } 1453 1454 static int test_vfs_oom_test( 1455 void * clientData, 1456 Tcl_Interp *interp, 1457 int objc, 1458 Tcl_Obj *CONST objv[] 1459 ){ 1460 extern int sqlite3_memdebug_vfs_oom_test; 1461 if( objc>2 ){ 1462 Tcl_WrongNumArgs(interp, 1, objv, "?INTEGER?"); 1463 return TCL_ERROR; 1464 }else if( objc==2 ){ 1465 int iNew; 1466 if( Tcl_GetIntFromObj(interp, objv[1], &iNew) ) return TCL_ERROR; 1467 sqlite3_memdebug_vfs_oom_test = iNew; 1468 } 1469 Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_memdebug_vfs_oom_test)); 1470 return TCL_OK; 1471 } 1472 1473 /* 1474 ** Register commands with the TCL interpreter. 1475 */ 1476 int Sqlitetest_malloc_Init(Tcl_Interp *interp){ 1477 static struct { 1478 char *zName; 1479 Tcl_ObjCmdProc *xProc; 1480 int clientData; 1481 } aObjCmd[] = { 1482 { "sqlite3_malloc", test_malloc ,0 }, 1483 { "sqlite3_realloc", test_realloc ,0 }, 1484 { "sqlite3_free", test_free ,0 }, 1485 { "memset", test_memset ,0 }, 1486 { "memget", test_memget ,0 }, 1487 { "sqlite3_memory_used", test_memory_used ,0 }, 1488 { "sqlite3_memory_highwater", test_memory_highwater ,0 }, 1489 { "sqlite3_memdebug_backtrace", test_memdebug_backtrace ,0 }, 1490 { "sqlite3_memdebug_dump", test_memdebug_dump ,0 }, 1491 { "sqlite3_memdebug_fail", test_memdebug_fail ,0 }, 1492 { "sqlite3_memdebug_pending", test_memdebug_pending ,0 }, 1493 { "sqlite3_memdebug_settitle", test_memdebug_settitle ,0 }, 1494 { "sqlite3_memdebug_malloc_count", test_memdebug_malloc_count ,0 }, 1495 { "sqlite3_memdebug_log", test_memdebug_log ,0 }, 1496 { "sqlite3_config_scratch", test_config_scratch ,0 }, 1497 { "sqlite3_config_pagecache", test_config_pagecache ,0 }, 1498 { "sqlite3_config_alt_pcache", test_alt_pcache ,0 }, 1499 { "sqlite3_status", test_status ,0 }, 1500 { "sqlite3_db_status", test_db_status ,0 }, 1501 { "install_malloc_faultsim", test_install_malloc_faultsim ,0 }, 1502 { "sqlite3_config_heap", test_config_heap ,0 }, 1503 { "sqlite3_config_heap_size", test_config_heap_size ,0 }, 1504 { "sqlite3_config_memstatus", test_config_memstatus ,0 }, 1505 { "sqlite3_config_lookaside", test_config_lookaside ,0 }, 1506 { "sqlite3_config_error", test_config_error ,0 }, 1507 { "sqlite3_config_uri", test_config_uri ,0 }, 1508 { "sqlite3_config_cis", test_config_cis ,0 }, 1509 { "sqlite3_db_config_lookaside",test_db_config_lookaside ,0 }, 1510 { "sqlite3_dump_memsys3", test_dump_memsys3 ,3 }, 1511 { "sqlite3_dump_memsys5", test_dump_memsys3 ,5 }, 1512 { "sqlite3_install_memsys3", test_install_memsys3 ,0 }, 1513 { "sqlite3_memdebug_vfs_oom_test", test_vfs_oom_test ,0 }, 1514 }; 1515 int i; 1516 for(i=0; i<sizeof(aObjCmd)/sizeof(aObjCmd[0]); i++){ 1517 ClientData c = (ClientData)SQLITE_INT_TO_PTR(aObjCmd[i].clientData); 1518 Tcl_CreateObjCommand(interp, aObjCmd[i].zName, aObjCmd[i].xProc, c, 0); 1519 } 1520 return TCL_OK; 1521 } 1522 #endif 1523