Annotation of embedaddon/sqlite3/src/test_malloc.c, revision 1.1
1.1 ! misho 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 test1.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: ** sqlite3TestErrorName(1) -> "SQLITE_ERROR"
! 243: */
! 244: const char *sqlite3TestErrorName(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: const char *zTitle;
! 717: if( objc!=2 ){
! 718: Tcl_WrongNumArgs(interp, 1, objv, "TITLE");
! 719: return TCL_ERROR;
! 720: }
! 721: zTitle = Tcl_GetString(objv[1]);
! 722: #ifdef SQLITE_MEMDEBUG
! 723: {
! 724: extern int sqlite3MemdebugSettitle(const char*);
! 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: 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 rc;
! 1037: int sz, cnt;
! 1038: Tcl_Obj *pRet;
! 1039: if( objc!=3 ){
! 1040: Tcl_WrongNumArgs(interp, 1, objv, "SIZE COUNT");
! 1041: return TCL_ERROR;
! 1042: }
! 1043: if( Tcl_GetIntFromObj(interp, objv[1], &sz) ) return TCL_ERROR;
! 1044: if( Tcl_GetIntFromObj(interp, objv[2], &cnt) ) return TCL_ERROR;
! 1045: pRet = Tcl_NewObj();
! 1046: Tcl_ListObjAppendElement(
! 1047: interp, pRet, Tcl_NewIntObj(sqlite3GlobalConfig.szLookaside)
! 1048: );
! 1049: Tcl_ListObjAppendElement(
! 1050: interp, pRet, Tcl_NewIntObj(sqlite3GlobalConfig.nLookaside)
! 1051: );
! 1052: rc = sqlite3_config(SQLITE_CONFIG_LOOKASIDE, sz, cnt);
! 1053: Tcl_SetObjResult(interp, pRet);
! 1054: return TCL_OK;
! 1055: }
! 1056:
! 1057:
! 1058: /*
! 1059: ** Usage: sqlite3_db_config_lookaside CONNECTION BUFID SIZE COUNT
! 1060: **
! 1061: ** There are two static buffers with BUFID 1 and 2. Each static buffer
! 1062: ** is 10KB in size. A BUFID of 0 indicates that the buffer should be NULL
! 1063: ** which will cause sqlite3_db_config() to allocate space on its own.
! 1064: */
! 1065: static int test_db_config_lookaside(
! 1066: void * clientData,
! 1067: Tcl_Interp *interp,
! 1068: int objc,
! 1069: Tcl_Obj *CONST objv[]
! 1070: ){
! 1071: int rc;
! 1072: int sz, cnt;
! 1073: sqlite3 *db;
! 1074: int bufid;
! 1075: static char azBuf[2][10000];
! 1076: int getDbPointer(Tcl_Interp*, const char*, sqlite3**);
! 1077: if( objc!=5 ){
! 1078: Tcl_WrongNumArgs(interp, 1, objv, "BUFID SIZE COUNT");
! 1079: return TCL_ERROR;
! 1080: }
! 1081: if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
! 1082: if( Tcl_GetIntFromObj(interp, objv[2], &bufid) ) return TCL_ERROR;
! 1083: if( Tcl_GetIntFromObj(interp, objv[3], &sz) ) return TCL_ERROR;
! 1084: if( Tcl_GetIntFromObj(interp, objv[4], &cnt) ) return TCL_ERROR;
! 1085: if( bufid==0 ){
! 1086: rc = sqlite3_db_config(db, SQLITE_DBCONFIG_LOOKASIDE, 0, sz, cnt);
! 1087: }else if( bufid>=1 && bufid<=2 && sz*cnt<=sizeof(azBuf[0]) ){
! 1088: rc = sqlite3_db_config(db, SQLITE_DBCONFIG_LOOKASIDE, azBuf[bufid], sz,cnt);
! 1089: }else{
! 1090: Tcl_AppendResult(interp, "illegal arguments - see documentation", (char*)0);
! 1091: return TCL_ERROR;
! 1092: }
! 1093: Tcl_SetObjResult(interp, Tcl_NewIntObj(rc));
! 1094: return TCL_OK;
! 1095: }
! 1096:
! 1097: /*
! 1098: ** Usage:
! 1099: **
! 1100: ** sqlite3_config_heap NBYTE NMINALLOC
! 1101: */
! 1102: static int test_config_heap(
! 1103: void * clientData,
! 1104: Tcl_Interp *interp,
! 1105: int objc,
! 1106: Tcl_Obj *CONST objv[]
! 1107: ){
! 1108: static char *zBuf; /* Use this memory */
! 1109: static int szBuf; /* Bytes allocated for zBuf */
! 1110: int nByte; /* Size of buffer to pass to sqlite3_config() */
! 1111: int nMinAlloc; /* Size of minimum allocation */
! 1112: int rc; /* Return code of sqlite3_config() */
! 1113:
! 1114: Tcl_Obj * CONST *aArg = &objv[1];
! 1115: int nArg = objc-1;
! 1116:
! 1117: if( nArg!=2 ){
! 1118: Tcl_WrongNumArgs(interp, 1, objv, "NBYTE NMINALLOC");
! 1119: return TCL_ERROR;
! 1120: }
! 1121: if( Tcl_GetIntFromObj(interp, aArg[0], &nByte) ) return TCL_ERROR;
! 1122: if( Tcl_GetIntFromObj(interp, aArg[1], &nMinAlloc) ) return TCL_ERROR;
! 1123:
! 1124: if( nByte==0 ){
! 1125: free( zBuf );
! 1126: zBuf = 0;
! 1127: szBuf = 0;
! 1128: rc = sqlite3_config(SQLITE_CONFIG_HEAP, (void*)0, 0, 0);
! 1129: }else{
! 1130: zBuf = realloc(zBuf, nByte);
! 1131: szBuf = nByte;
! 1132: rc = sqlite3_config(SQLITE_CONFIG_HEAP, zBuf, nByte, nMinAlloc);
! 1133: }
! 1134:
! 1135: Tcl_SetResult(interp, (char *)sqlite3TestErrorName(rc), TCL_VOLATILE);
! 1136: return TCL_OK;
! 1137: }
! 1138:
! 1139: /*
! 1140: ** tclcmd: sqlite3_config_error [DB]
! 1141: **
! 1142: ** Invoke sqlite3_config() or sqlite3_db_config() with invalid
! 1143: ** opcodes and verify that they return errors.
! 1144: */
! 1145: static int test_config_error(
! 1146: void * clientData,
! 1147: Tcl_Interp *interp,
! 1148: int objc,
! 1149: Tcl_Obj *CONST objv[]
! 1150: ){
! 1151: sqlite3 *db;
! 1152: int getDbPointer(Tcl_Interp*, const char*, sqlite3**);
! 1153:
! 1154: if( objc!=2 && objc!=1 ){
! 1155: Tcl_WrongNumArgs(interp, 1, objv, "[DB]");
! 1156: return TCL_ERROR;
! 1157: }
! 1158: if( objc==2 ){
! 1159: if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
! 1160: if( sqlite3_db_config(db, 99999)!=SQLITE_ERROR ){
! 1161: Tcl_AppendResult(interp,
! 1162: "sqlite3_db_config(db, 99999) does not return SQLITE_ERROR",
! 1163: (char*)0);
! 1164: return TCL_ERROR;
! 1165: }
! 1166: }else{
! 1167: if( sqlite3_config(99999)!=SQLITE_ERROR ){
! 1168: Tcl_AppendResult(interp,
! 1169: "sqlite3_config(99999) does not return SQLITE_ERROR",
! 1170: (char*)0);
! 1171: return TCL_ERROR;
! 1172: }
! 1173: }
! 1174: return TCL_OK;
! 1175: }
! 1176:
! 1177: /*
! 1178: ** tclcmd: sqlite3_config_uri BOOLEAN
! 1179: **
! 1180: ** Invoke sqlite3_config() or sqlite3_db_config() with invalid
! 1181: ** opcodes and verify that they return errors.
! 1182: */
! 1183: static int test_config_uri(
! 1184: void * clientData,
! 1185: Tcl_Interp *interp,
! 1186: int objc,
! 1187: Tcl_Obj *CONST objv[]
! 1188: ){
! 1189: int rc;
! 1190: int bOpenUri;
! 1191:
! 1192: if( objc!=2 ){
! 1193: Tcl_WrongNumArgs(interp, 1, objv, "BOOL");
! 1194: return TCL_ERROR;
! 1195: }
! 1196: if( Tcl_GetBooleanFromObj(interp, objv[1], &bOpenUri) ){
! 1197: return TCL_ERROR;
! 1198: }
! 1199:
! 1200: rc = sqlite3_config(SQLITE_CONFIG_URI, bOpenUri);
! 1201: Tcl_SetResult(interp, (char *)sqlite3TestErrorName(rc), TCL_VOLATILE);
! 1202:
! 1203: return TCL_OK;
! 1204: }
! 1205:
! 1206: /*
! 1207: ** Usage:
! 1208: **
! 1209: ** sqlite3_dump_memsys3 FILENAME
! 1210: ** sqlite3_dump_memsys5 FILENAME
! 1211: **
! 1212: ** Write a summary of unfreed memsys3 allocations to FILENAME.
! 1213: */
! 1214: static int test_dump_memsys3(
! 1215: void * clientData,
! 1216: Tcl_Interp *interp,
! 1217: int objc,
! 1218: Tcl_Obj *CONST objv[]
! 1219: ){
! 1220: if( objc!=2 ){
! 1221: Tcl_WrongNumArgs(interp, 1, objv, "FILENAME");
! 1222: return TCL_ERROR;
! 1223: }
! 1224:
! 1225: switch( SQLITE_PTR_TO_INT(clientData) ){
! 1226: case 3: {
! 1227: #ifdef SQLITE_ENABLE_MEMSYS3
! 1228: extern void sqlite3Memsys3Dump(const char*);
! 1229: sqlite3Memsys3Dump(Tcl_GetString(objv[1]));
! 1230: break;
! 1231: #endif
! 1232: }
! 1233: case 5: {
! 1234: #ifdef SQLITE_ENABLE_MEMSYS5
! 1235: extern void sqlite3Memsys5Dump(const char*);
! 1236: sqlite3Memsys5Dump(Tcl_GetString(objv[1]));
! 1237: break;
! 1238: #endif
! 1239: }
! 1240: }
! 1241: return TCL_OK;
! 1242: }
! 1243:
! 1244: /*
! 1245: ** Usage: sqlite3_status OPCODE RESETFLAG
! 1246: **
! 1247: ** Return a list of three elements which are the sqlite3_status() return
! 1248: ** code, the current value, and the high-water mark value.
! 1249: */
! 1250: static int test_status(
! 1251: void * clientData,
! 1252: Tcl_Interp *interp,
! 1253: int objc,
! 1254: Tcl_Obj *CONST objv[]
! 1255: ){
! 1256: int rc, iValue, mxValue;
! 1257: int i, op, resetFlag;
! 1258: const char *zOpName;
! 1259: static const struct {
! 1260: const char *zName;
! 1261: int op;
! 1262: } aOp[] = {
! 1263: { "SQLITE_STATUS_MEMORY_USED", SQLITE_STATUS_MEMORY_USED },
! 1264: { "SQLITE_STATUS_MALLOC_SIZE", SQLITE_STATUS_MALLOC_SIZE },
! 1265: { "SQLITE_STATUS_PAGECACHE_USED", SQLITE_STATUS_PAGECACHE_USED },
! 1266: { "SQLITE_STATUS_PAGECACHE_OVERFLOW", SQLITE_STATUS_PAGECACHE_OVERFLOW },
! 1267: { "SQLITE_STATUS_PAGECACHE_SIZE", SQLITE_STATUS_PAGECACHE_SIZE },
! 1268: { "SQLITE_STATUS_SCRATCH_USED", SQLITE_STATUS_SCRATCH_USED },
! 1269: { "SQLITE_STATUS_SCRATCH_OVERFLOW", SQLITE_STATUS_SCRATCH_OVERFLOW },
! 1270: { "SQLITE_STATUS_SCRATCH_SIZE", SQLITE_STATUS_SCRATCH_SIZE },
! 1271: { "SQLITE_STATUS_PARSER_STACK", SQLITE_STATUS_PARSER_STACK },
! 1272: { "SQLITE_STATUS_MALLOC_COUNT", SQLITE_STATUS_MALLOC_COUNT },
! 1273: };
! 1274: Tcl_Obj *pResult;
! 1275: if( objc!=3 ){
! 1276: Tcl_WrongNumArgs(interp, 1, objv, "PARAMETER RESETFLAG");
! 1277: return TCL_ERROR;
! 1278: }
! 1279: zOpName = Tcl_GetString(objv[1]);
! 1280: for(i=0; i<ArraySize(aOp); i++){
! 1281: if( strcmp(aOp[i].zName, zOpName)==0 ){
! 1282: op = aOp[i].op;
! 1283: break;
! 1284: }
! 1285: }
! 1286: if( i>=ArraySize(aOp) ){
! 1287: if( Tcl_GetIntFromObj(interp, objv[1], &op) ) return TCL_ERROR;
! 1288: }
! 1289: if( Tcl_GetBooleanFromObj(interp, objv[2], &resetFlag) ) return TCL_ERROR;
! 1290: iValue = 0;
! 1291: mxValue = 0;
! 1292: rc = sqlite3_status(op, &iValue, &mxValue, resetFlag);
! 1293: pResult = Tcl_NewObj();
! 1294: Tcl_ListObjAppendElement(0, pResult, Tcl_NewIntObj(rc));
! 1295: Tcl_ListObjAppendElement(0, pResult, Tcl_NewIntObj(iValue));
! 1296: Tcl_ListObjAppendElement(0, pResult, Tcl_NewIntObj(mxValue));
! 1297: Tcl_SetObjResult(interp, pResult);
! 1298: return TCL_OK;
! 1299: }
! 1300:
! 1301: /*
! 1302: ** Usage: sqlite3_db_status DATABASE OPCODE RESETFLAG
! 1303: **
! 1304: ** Return a list of three elements which are the sqlite3_db_status() return
! 1305: ** code, the current value, and the high-water mark value.
! 1306: */
! 1307: static int test_db_status(
! 1308: void * clientData,
! 1309: Tcl_Interp *interp,
! 1310: int objc,
! 1311: Tcl_Obj *CONST objv[]
! 1312: ){
! 1313: int rc, iValue, mxValue;
! 1314: int i, op, resetFlag;
! 1315: const char *zOpName;
! 1316: sqlite3 *db;
! 1317: int getDbPointer(Tcl_Interp*, const char*, sqlite3**);
! 1318: static const struct {
! 1319: const char *zName;
! 1320: int op;
! 1321: } aOp[] = {
! 1322: { "LOOKASIDE_USED", SQLITE_DBSTATUS_LOOKASIDE_USED },
! 1323: { "CACHE_USED", SQLITE_DBSTATUS_CACHE_USED },
! 1324: { "SCHEMA_USED", SQLITE_DBSTATUS_SCHEMA_USED },
! 1325: { "STMT_USED", SQLITE_DBSTATUS_STMT_USED },
! 1326: { "LOOKASIDE_HIT", SQLITE_DBSTATUS_LOOKASIDE_HIT },
! 1327: { "LOOKASIDE_MISS_SIZE", SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE },
! 1328: { "LOOKASIDE_MISS_FULL", SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL },
! 1329: { "CACHE_HIT", SQLITE_DBSTATUS_CACHE_HIT },
! 1330: { "CACHE_MISS", SQLITE_DBSTATUS_CACHE_MISS }
! 1331: };
! 1332: Tcl_Obj *pResult;
! 1333: if( objc!=4 ){
! 1334: Tcl_WrongNumArgs(interp, 1, objv, "DB PARAMETER RESETFLAG");
! 1335: return TCL_ERROR;
! 1336: }
! 1337: if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
! 1338: zOpName = Tcl_GetString(objv[2]);
! 1339: if( memcmp(zOpName, "SQLITE_", 7)==0 ) zOpName += 7;
! 1340: if( memcmp(zOpName, "DBSTATUS_", 9)==0 ) zOpName += 9;
! 1341: for(i=0; i<ArraySize(aOp); i++){
! 1342: if( strcmp(aOp[i].zName, zOpName)==0 ){
! 1343: op = aOp[i].op;
! 1344: break;
! 1345: }
! 1346: }
! 1347: if( i>=ArraySize(aOp) ){
! 1348: if( Tcl_GetIntFromObj(interp, objv[2], &op) ) return TCL_ERROR;
! 1349: }
! 1350: if( Tcl_GetBooleanFromObj(interp, objv[3], &resetFlag) ) return TCL_ERROR;
! 1351: iValue = 0;
! 1352: mxValue = 0;
! 1353: rc = sqlite3_db_status(db, op, &iValue, &mxValue, resetFlag);
! 1354: pResult = Tcl_NewObj();
! 1355: Tcl_ListObjAppendElement(0, pResult, Tcl_NewIntObj(rc));
! 1356: Tcl_ListObjAppendElement(0, pResult, Tcl_NewIntObj(iValue));
! 1357: Tcl_ListObjAppendElement(0, pResult, Tcl_NewIntObj(mxValue));
! 1358: Tcl_SetObjResult(interp, pResult);
! 1359: return TCL_OK;
! 1360: }
! 1361:
! 1362: /*
! 1363: ** install_malloc_faultsim BOOLEAN
! 1364: */
! 1365: static int test_install_malloc_faultsim(
! 1366: void * clientData,
! 1367: Tcl_Interp *interp,
! 1368: int objc,
! 1369: Tcl_Obj *CONST objv[]
! 1370: ){
! 1371: int rc;
! 1372: int isInstall;
! 1373:
! 1374: if( objc!=2 ){
! 1375: Tcl_WrongNumArgs(interp, 1, objv, "BOOLEAN");
! 1376: return TCL_ERROR;
! 1377: }
! 1378: if( TCL_OK!=Tcl_GetBooleanFromObj(interp, objv[1], &isInstall) ){
! 1379: return TCL_ERROR;
! 1380: }
! 1381: rc = faultsimInstall(isInstall);
! 1382: Tcl_SetResult(interp, (char *)sqlite3TestErrorName(rc), TCL_VOLATILE);
! 1383: return TCL_OK;
! 1384: }
! 1385:
! 1386: /*
! 1387: ** sqlite3_install_memsys3
! 1388: */
! 1389: static int test_install_memsys3(
! 1390: void * clientData,
! 1391: Tcl_Interp *interp,
! 1392: int objc,
! 1393: Tcl_Obj *CONST objv[]
! 1394: ){
! 1395: int rc = SQLITE_MISUSE;
! 1396: #ifdef SQLITE_ENABLE_MEMSYS3
! 1397: const sqlite3_mem_methods *sqlite3MemGetMemsys3(void);
! 1398: rc = sqlite3_config(SQLITE_CONFIG_MALLOC, sqlite3MemGetMemsys3());
! 1399: #endif
! 1400: Tcl_SetResult(interp, (char *)sqlite3TestErrorName(rc), TCL_VOLATILE);
! 1401: return TCL_OK;
! 1402: }
! 1403:
! 1404: static int test_vfs_oom_test(
! 1405: void * clientData,
! 1406: Tcl_Interp *interp,
! 1407: int objc,
! 1408: Tcl_Obj *CONST objv[]
! 1409: ){
! 1410: extern int sqlite3_memdebug_vfs_oom_test;
! 1411: if( objc>2 ){
! 1412: Tcl_WrongNumArgs(interp, 1, objv, "?INTEGER?");
! 1413: return TCL_ERROR;
! 1414: }else if( objc==2 ){
! 1415: int iNew;
! 1416: if( Tcl_GetIntFromObj(interp, objv[1], &iNew) ) return TCL_ERROR;
! 1417: sqlite3_memdebug_vfs_oom_test = iNew;
! 1418: }
! 1419: Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_memdebug_vfs_oom_test));
! 1420: return TCL_OK;
! 1421: }
! 1422:
! 1423: /*
! 1424: ** Register commands with the TCL interpreter.
! 1425: */
! 1426: int Sqlitetest_malloc_Init(Tcl_Interp *interp){
! 1427: static struct {
! 1428: char *zName;
! 1429: Tcl_ObjCmdProc *xProc;
! 1430: int clientData;
! 1431: } aObjCmd[] = {
! 1432: { "sqlite3_malloc", test_malloc ,0 },
! 1433: { "sqlite3_realloc", test_realloc ,0 },
! 1434: { "sqlite3_free", test_free ,0 },
! 1435: { "memset", test_memset ,0 },
! 1436: { "memget", test_memget ,0 },
! 1437: { "sqlite3_memory_used", test_memory_used ,0 },
! 1438: { "sqlite3_memory_highwater", test_memory_highwater ,0 },
! 1439: { "sqlite3_memdebug_backtrace", test_memdebug_backtrace ,0 },
! 1440: { "sqlite3_memdebug_dump", test_memdebug_dump ,0 },
! 1441: { "sqlite3_memdebug_fail", test_memdebug_fail ,0 },
! 1442: { "sqlite3_memdebug_pending", test_memdebug_pending ,0 },
! 1443: { "sqlite3_memdebug_settitle", test_memdebug_settitle ,0 },
! 1444: { "sqlite3_memdebug_malloc_count", test_memdebug_malloc_count ,0 },
! 1445: { "sqlite3_memdebug_log", test_memdebug_log ,0 },
! 1446: { "sqlite3_config_scratch", test_config_scratch ,0 },
! 1447: { "sqlite3_config_pagecache", test_config_pagecache ,0 },
! 1448: { "sqlite3_config_alt_pcache", test_alt_pcache ,0 },
! 1449: { "sqlite3_status", test_status ,0 },
! 1450: { "sqlite3_db_status", test_db_status ,0 },
! 1451: { "install_malloc_faultsim", test_install_malloc_faultsim ,0 },
! 1452: { "sqlite3_config_heap", test_config_heap ,0 },
! 1453: { "sqlite3_config_memstatus", test_config_memstatus ,0 },
! 1454: { "sqlite3_config_lookaside", test_config_lookaside ,0 },
! 1455: { "sqlite3_config_error", test_config_error ,0 },
! 1456: { "sqlite3_config_uri", test_config_uri ,0 },
! 1457: { "sqlite3_db_config_lookaside",test_db_config_lookaside ,0 },
! 1458: { "sqlite3_dump_memsys3", test_dump_memsys3 ,3 },
! 1459: { "sqlite3_dump_memsys5", test_dump_memsys3 ,5 },
! 1460: { "sqlite3_install_memsys3", test_install_memsys3 ,0 },
! 1461: { "sqlite3_memdebug_vfs_oom_test", test_vfs_oom_test ,0 },
! 1462: };
! 1463: int i;
! 1464: for(i=0; i<sizeof(aObjCmd)/sizeof(aObjCmd[0]); i++){
! 1465: ClientData c = (ClientData)SQLITE_INT_TO_PTR(aObjCmd[i].clientData);
! 1466: Tcl_CreateObjCommand(interp, aObjCmd[i].zName, aObjCmd[i].xProc, c, 0);
! 1467: }
! 1468: return TCL_OK;
! 1469: }
! 1470: #endif
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to test_malloc.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / src