1: /*
2: ** 2008 June 18
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: ** This file contains test logic for the sqlite3_mutex interfaces.
13: */
14:
15: #include "tcl.h"
16: #include "sqlite3.h"
17: #include "sqliteInt.h"
18: #include <stdlib.h>
19: #include <assert.h>
20: #include <string.h>
21:
22: /* defined in test1.c */
23: const char *sqlite3TestErrorName(int);
24:
25: /* A countable mutex */
26: struct sqlite3_mutex {
27: sqlite3_mutex *pReal;
28: int eType;
29: };
30:
31: /* State variables */
32: static struct test_mutex_globals {
33: int isInstalled; /* True if installed */
34: int disableInit; /* True to cause sqlite3_initalize() to fail */
35: int disableTry; /* True to force sqlite3_mutex_try() to fail */
36: int isInit; /* True if initialized */
37: sqlite3_mutex_methods m; /* Interface to "real" mutex system */
38: int aCounter[8]; /* Number of grabs of each type of mutex */
39: sqlite3_mutex aStatic[6]; /* The six static mutexes */
40: } g = {0};
41:
42: /* Return true if the countable mutex is currently held */
43: static int counterMutexHeld(sqlite3_mutex *p){
44: return g.m.xMutexHeld(p->pReal);
45: }
46:
47: /* Return true if the countable mutex is not currently held */
48: static int counterMutexNotheld(sqlite3_mutex *p){
49: return g.m.xMutexNotheld(p->pReal);
50: }
51:
52: /* Initialize the countable mutex interface
53: ** Or, if g.disableInit is non-zero, then do not initialize but instead
54: ** return the value of g.disableInit as the result code. This can be used
55: ** to simulate an initialization failure.
56: */
57: static int counterMutexInit(void){
58: int rc;
59: if( g.disableInit ) return g.disableInit;
60: rc = g.m.xMutexInit();
61: g.isInit = 1;
62: return rc;
63: }
64:
65: /*
66: ** Uninitialize the mutex subsystem
67: */
68: static int counterMutexEnd(void){
69: g.isInit = 0;
70: return g.m.xMutexEnd();
71: }
72:
73: /*
74: ** Allocate a countable mutex
75: */
76: static sqlite3_mutex *counterMutexAlloc(int eType){
77: sqlite3_mutex *pReal;
78: sqlite3_mutex *pRet = 0;
79:
80: assert( g.isInit );
81: assert(eType<8 && eType>=0);
82:
83: pReal = g.m.xMutexAlloc(eType);
84: if( !pReal ) return 0;
85:
86: if( eType==SQLITE_MUTEX_FAST || eType==SQLITE_MUTEX_RECURSIVE ){
87: pRet = (sqlite3_mutex *)malloc(sizeof(sqlite3_mutex));
88: }else{
89: pRet = &g.aStatic[eType-2];
90: }
91:
92: pRet->eType = eType;
93: pRet->pReal = pReal;
94: return pRet;
95: }
96:
97: /*
98: ** Free a countable mutex
99: */
100: static void counterMutexFree(sqlite3_mutex *p){
101: assert( g.isInit );
102: g.m.xMutexFree(p->pReal);
103: if( p->eType==SQLITE_MUTEX_FAST || p->eType==SQLITE_MUTEX_RECURSIVE ){
104: free(p);
105: }
106: }
107:
108: /*
109: ** Enter a countable mutex. Block until entry is safe.
110: */
111: static void counterMutexEnter(sqlite3_mutex *p){
112: assert( g.isInit );
113: g.aCounter[p->eType]++;
114: g.m.xMutexEnter(p->pReal);
115: }
116:
117: /*
118: ** Try to enter a mutex. Return true on success.
119: */
120: static int counterMutexTry(sqlite3_mutex *p){
121: assert( g.isInit );
122: g.aCounter[p->eType]++;
123: if( g.disableTry ) return SQLITE_BUSY;
124: return g.m.xMutexTry(p->pReal);
125: }
126:
127: /* Leave a mutex
128: */
129: static void counterMutexLeave(sqlite3_mutex *p){
130: assert( g.isInit );
131: g.m.xMutexLeave(p->pReal);
132: }
133:
134: /*
135: ** sqlite3_shutdown
136: */
137: static int test_shutdown(
138: void * clientData,
139: Tcl_Interp *interp,
140: int objc,
141: Tcl_Obj *CONST objv[]
142: ){
143: int rc;
144:
145: if( objc!=1 ){
146: Tcl_WrongNumArgs(interp, 1, objv, "");
147: return TCL_ERROR;
148: }
149:
150: rc = sqlite3_shutdown();
151: Tcl_SetResult(interp, (char *)sqlite3TestErrorName(rc), TCL_VOLATILE);
152: return TCL_OK;
153: }
154:
155: /*
156: ** sqlite3_initialize
157: */
158: static int test_initialize(
159: void * clientData,
160: Tcl_Interp *interp,
161: int objc,
162: Tcl_Obj *CONST objv[]
163: ){
164: int rc;
165:
166: if( objc!=1 ){
167: Tcl_WrongNumArgs(interp, 1, objv, "");
168: return TCL_ERROR;
169: }
170:
171: rc = sqlite3_initialize();
172: Tcl_SetResult(interp, (char *)sqlite3TestErrorName(rc), TCL_VOLATILE);
173: return TCL_OK;
174: }
175:
176: /*
177: ** install_mutex_counters BOOLEAN
178: */
179: static int test_install_mutex_counters(
180: void * clientData,
181: Tcl_Interp *interp,
182: int objc,
183: Tcl_Obj *CONST objv[]
184: ){
185: int rc = SQLITE_OK;
186: int isInstall;
187:
188: sqlite3_mutex_methods counter_methods = {
189: counterMutexInit,
190: counterMutexEnd,
191: counterMutexAlloc,
192: counterMutexFree,
193: counterMutexEnter,
194: counterMutexTry,
195: counterMutexLeave,
196: counterMutexHeld,
197: counterMutexNotheld
198: };
199:
200: if( objc!=2 ){
201: Tcl_WrongNumArgs(interp, 1, objv, "BOOLEAN");
202: return TCL_ERROR;
203: }
204: if( TCL_OK!=Tcl_GetBooleanFromObj(interp, objv[1], &isInstall) ){
205: return TCL_ERROR;
206: }
207:
208: assert(isInstall==0 || isInstall==1);
209: assert(g.isInstalled==0 || g.isInstalled==1);
210: if( isInstall==g.isInstalled ){
211: Tcl_AppendResult(interp, "mutex counters are ", 0);
212: Tcl_AppendResult(interp, isInstall?"already installed":"not installed", 0);
213: return TCL_ERROR;
214: }
215:
216: if( isInstall ){
217: assert( g.m.xMutexAlloc==0 );
218: rc = sqlite3_config(SQLITE_CONFIG_GETMUTEX, &g.m);
219: if( rc==SQLITE_OK ){
220: sqlite3_config(SQLITE_CONFIG_MUTEX, &counter_methods);
221: }
222: g.disableTry = 0;
223: }else{
224: assert( g.m.xMutexAlloc );
225: rc = sqlite3_config(SQLITE_CONFIG_MUTEX, &g.m);
226: memset(&g.m, 0, sizeof(sqlite3_mutex_methods));
227: }
228:
229: if( rc==SQLITE_OK ){
230: g.isInstalled = isInstall;
231: }
232:
233: Tcl_SetResult(interp, (char *)sqlite3TestErrorName(rc), TCL_VOLATILE);
234: return TCL_OK;
235: }
236:
237: /*
238: ** read_mutex_counters
239: */
240: static int test_read_mutex_counters(
241: void * clientData,
242: Tcl_Interp *interp,
243: int objc,
244: Tcl_Obj *CONST objv[]
245: ){
246: Tcl_Obj *pRet;
247: int ii;
248: char *aName[8] = {
249: "fast", "recursive", "static_master", "static_mem",
250: "static_open", "static_prng", "static_lru", "static_pmem"
251: };
252:
253: if( objc!=1 ){
254: Tcl_WrongNumArgs(interp, 1, objv, "");
255: return TCL_ERROR;
256: }
257:
258: pRet = Tcl_NewObj();
259: Tcl_IncrRefCount(pRet);
260: for(ii=0; ii<8; ii++){
261: Tcl_ListObjAppendElement(interp, pRet, Tcl_NewStringObj(aName[ii], -1));
262: Tcl_ListObjAppendElement(interp, pRet, Tcl_NewIntObj(g.aCounter[ii]));
263: }
264: Tcl_SetObjResult(interp, pRet);
265: Tcl_DecrRefCount(pRet);
266:
267: return TCL_OK;
268: }
269:
270: /*
271: ** clear_mutex_counters
272: */
273: static int test_clear_mutex_counters(
274: void * clientData,
275: Tcl_Interp *interp,
276: int objc,
277: Tcl_Obj *CONST objv[]
278: ){
279: int ii;
280:
281: if( objc!=1 ){
282: Tcl_WrongNumArgs(interp, 1, objv, "");
283: return TCL_ERROR;
284: }
285:
286: for(ii=0; ii<8; ii++){
287: g.aCounter[ii] = 0;
288: }
289: return TCL_OK;
290: }
291:
292: /*
293: ** Create and free a mutex. Return the mutex pointer. The pointer
294: ** will be invalid since the mutex has already been freed. The
295: ** return pointer just checks to see if the mutex really was allocated.
296: */
297: static int test_alloc_mutex(
298: void * clientData,
299: Tcl_Interp *interp,
300: int objc,
301: Tcl_Obj *CONST objv[]
302: ){
303: #if SQLITE_THREADSAFE
304: sqlite3_mutex *p = sqlite3_mutex_alloc(SQLITE_MUTEX_FAST);
305: char zBuf[100];
306: sqlite3_mutex_free(p);
307: sqlite3_snprintf(sizeof(zBuf), zBuf, "%p", p);
308: Tcl_AppendResult(interp, zBuf, (char*)0);
309: #endif
310: return TCL_OK;
311: }
312:
313: /*
314: ** sqlite3_config OPTION
315: **
316: ** OPTION can be either one of the keywords:
317: **
318: ** SQLITE_CONFIG_SINGLETHREAD
319: ** SQLITE_CONFIG_MULTITHREAD
320: ** SQLITE_CONFIG_SERIALIZED
321: **
322: ** Or OPTION can be an raw integer.
323: */
324: static int test_config(
325: void * clientData,
326: Tcl_Interp *interp,
327: int objc,
328: Tcl_Obj *CONST objv[]
329: ){
330: struct ConfigOption {
331: const char *zName;
332: int iValue;
333: } aOpt[] = {
334: {"singlethread", SQLITE_CONFIG_SINGLETHREAD},
335: {"multithread", SQLITE_CONFIG_MULTITHREAD},
336: {"serialized", SQLITE_CONFIG_SERIALIZED},
337: {0, 0}
338: };
339: int s = sizeof(struct ConfigOption);
340: int i;
341: int rc;
342:
343: if( objc!=2 ){
344: Tcl_WrongNumArgs(interp, 1, objv, "");
345: return TCL_ERROR;
346: }
347:
348: if( Tcl_GetIndexFromObjStruct(interp, objv[1], aOpt, s, "flag", 0, &i) ){
349: if( Tcl_GetIntFromObj(interp, objv[1], &i) ){
350: return TCL_ERROR;
351: }
352: }else{
353: i = aOpt[i].iValue;
354: }
355:
356: rc = sqlite3_config(i);
357: Tcl_SetResult(interp, (char *)sqlite3TestErrorName(rc), TCL_VOLATILE);
358: return TCL_OK;
359: }
360:
361: static sqlite3 *getDbPointer(Tcl_Interp *pInterp, Tcl_Obj *pObj){
362: sqlite3 *db;
363: Tcl_CmdInfo info;
364: char *zCmd = Tcl_GetString(pObj);
365: if( Tcl_GetCommandInfo(pInterp, zCmd, &info) ){
366: db = *((sqlite3 **)info.objClientData);
367: }else{
368: db = (sqlite3*)sqlite3TestTextToPtr(zCmd);
369: }
370: assert( db );
371: return db;
372: }
373:
374: static int test_enter_db_mutex(
375: void * clientData,
376: Tcl_Interp *interp,
377: int objc,
378: Tcl_Obj *CONST objv[]
379: ){
380: sqlite3 *db;
381: if( objc!=2 ){
382: Tcl_WrongNumArgs(interp, 1, objv, "DB");
383: return TCL_ERROR;
384: }
385: db = getDbPointer(interp, objv[1]);
386: if( !db ){
387: return TCL_ERROR;
388: }
389: sqlite3_mutex_enter(sqlite3_db_mutex(db));
390: return TCL_OK;
391: }
392:
393: static int test_leave_db_mutex(
394: void * clientData,
395: Tcl_Interp *interp,
396: int objc,
397: Tcl_Obj *CONST objv[]
398: ){
399: sqlite3 *db;
400: if( objc!=2 ){
401: Tcl_WrongNumArgs(interp, 1, objv, "DB");
402: return TCL_ERROR;
403: }
404: db = getDbPointer(interp, objv[1]);
405: if( !db ){
406: return TCL_ERROR;
407: }
408: sqlite3_mutex_leave(sqlite3_db_mutex(db));
409: return TCL_OK;
410: }
411:
412: int Sqlitetest_mutex_Init(Tcl_Interp *interp){
413: static struct {
414: char *zName;
415: Tcl_ObjCmdProc *xProc;
416: } aCmd[] = {
417: { "sqlite3_shutdown", (Tcl_ObjCmdProc*)test_shutdown },
418: { "sqlite3_initialize", (Tcl_ObjCmdProc*)test_initialize },
419: { "sqlite3_config", (Tcl_ObjCmdProc*)test_config },
420:
421: { "enter_db_mutex", (Tcl_ObjCmdProc*)test_enter_db_mutex },
422: { "leave_db_mutex", (Tcl_ObjCmdProc*)test_leave_db_mutex },
423:
424: { "alloc_dealloc_mutex", (Tcl_ObjCmdProc*)test_alloc_mutex },
425: { "install_mutex_counters", (Tcl_ObjCmdProc*)test_install_mutex_counters },
426: { "read_mutex_counters", (Tcl_ObjCmdProc*)test_read_mutex_counters },
427: { "clear_mutex_counters", (Tcl_ObjCmdProc*)test_clear_mutex_counters },
428: };
429: int i;
430: for(i=0; i<sizeof(aCmd)/sizeof(aCmd[0]); i++){
431: Tcl_CreateObjCommand(interp, aCmd[i].zName, aCmd[i].xProc, 0, 0);
432: }
433:
434: Tcl_LinkVar(interp, "disable_mutex_init",
435: (char*)&g.disableInit, TCL_LINK_INT);
436: Tcl_LinkVar(interp, "disable_mutex_try",
437: (char*)&g.disableTry, TCL_LINK_INT);
438: return SQLITE_OK;
439: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to test_mutex.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