Annotation of embedaddon/sqlite3/src/test_superlock.c, revision 1.1
1.1 ! misho 1: /*
! 2: ** 2010 November 19
! 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: ** Example code for obtaining an exclusive lock on an SQLite database
! 13: ** file. This method is complicated, but works for both WAL and rollback
! 14: ** mode database files. The interface to the example code in this file
! 15: ** consists of the following two functions:
! 16: **
! 17: ** sqlite3demo_superlock()
! 18: ** sqlite3demo_superunlock()
! 19: */
! 20:
! 21: #include <sqlite3.h>
! 22: #include <string.h> /* memset(), strlen() */
! 23: #include <assert.h> /* assert() */
! 24:
! 25: /*
! 26: ** A structure to collect a busy-handler callback and argument and a count
! 27: ** of the number of times it has been invoked.
! 28: */
! 29: struct SuperlockBusy {
! 30: int (*xBusy)(void*,int); /* Pointer to busy-handler function */
! 31: void *pBusyArg; /* First arg to pass to xBusy */
! 32: int nBusy; /* Number of times xBusy has been invoked */
! 33: };
! 34: typedef struct SuperlockBusy SuperlockBusy;
! 35:
! 36: /*
! 37: ** An instance of the following structure is allocated for each active
! 38: ** superlock. The opaque handle returned by sqlite3demo_superlock() is
! 39: ** actually a pointer to an instance of this structure.
! 40: */
! 41: struct Superlock {
! 42: sqlite3 *db; /* Database handle used to lock db */
! 43: int bWal; /* True if db is a WAL database */
! 44: };
! 45: typedef struct Superlock Superlock;
! 46:
! 47: /*
! 48: ** The pCtx pointer passed to this function is actually a pointer to a
! 49: ** SuperlockBusy structure. Invoke the busy-handler function encapsulated
! 50: ** by the structure and return the result.
! 51: */
! 52: static int superlockBusyHandler(void *pCtx, int UNUSED){
! 53: SuperlockBusy *pBusy = (SuperlockBusy *)pCtx;
! 54: if( pBusy->xBusy==0 ) return 0;
! 55: return pBusy->xBusy(pBusy->pBusyArg, pBusy->nBusy++);
! 56: }
! 57:
! 58: /*
! 59: ** This function is used to determine if the main database file for
! 60: ** connection db is open in WAL mode or not. If no error occurs and the
! 61: ** database file is in WAL mode, set *pbWal to true and return SQLITE_OK.
! 62: ** If it is not in WAL mode, set *pbWal to false.
! 63: **
! 64: ** If an error occurs, return an SQLite error code. The value of *pbWal
! 65: ** is undefined in this case.
! 66: */
! 67: static int superlockIsWal(Superlock *pLock){
! 68: int rc; /* Return Code */
! 69: sqlite3_stmt *pStmt; /* Compiled PRAGMA journal_mode statement */
! 70:
! 71: rc = sqlite3_prepare(pLock->db, "PRAGMA main.journal_mode", -1, &pStmt, 0);
! 72: if( rc!=SQLITE_OK ) return rc;
! 73:
! 74: pLock->bWal = 0;
! 75: if( SQLITE_ROW==sqlite3_step(pStmt) ){
! 76: const char *zMode = (const char *)sqlite3_column_text(pStmt, 0);
! 77: if( zMode && strlen(zMode)==3 && sqlite3_strnicmp("wal", zMode, 3)==0 ){
! 78: pLock->bWal = 1;
! 79: }
! 80: }
! 81:
! 82: return sqlite3_finalize(pStmt);
! 83: }
! 84:
! 85: /*
! 86: ** Obtain an exclusive shm-lock on nByte bytes starting at offset idx
! 87: ** of the file fd. If the lock cannot be obtained immediately, invoke
! 88: ** the busy-handler until either it is obtained or the busy-handler
! 89: ** callback returns 0.
! 90: */
! 91: static int superlockShmLock(
! 92: sqlite3_file *fd, /* Database file handle */
! 93: int idx, /* Offset of shm-lock to obtain */
! 94: int nByte, /* Number of consective bytes to lock */
! 95: SuperlockBusy *pBusy /* Busy-handler wrapper object */
! 96: ){
! 97: int rc;
! 98: int (*xShmLock)(sqlite3_file*, int, int, int) = fd->pMethods->xShmLock;
! 99: do {
! 100: rc = xShmLock(fd, idx, nByte, SQLITE_SHM_LOCK|SQLITE_SHM_EXCLUSIVE);
! 101: }while( rc==SQLITE_BUSY && superlockBusyHandler((void *)pBusy, 0) );
! 102: return rc;
! 103: }
! 104:
! 105: /*
! 106: ** Obtain the extra locks on the database file required for WAL databases.
! 107: ** Invoke the supplied busy-handler as required.
! 108: */
! 109: static int superlockWalLock(
! 110: sqlite3 *db, /* Database handle open on WAL database */
! 111: SuperlockBusy *pBusy /* Busy handler wrapper object */
! 112: ){
! 113: int rc; /* Return code */
! 114: sqlite3_file *fd = 0; /* Main database file handle */
! 115: void volatile *p = 0; /* Pointer to first page of shared memory */
! 116:
! 117: /* Obtain a pointer to the sqlite3_file object open on the main db file. */
! 118: rc = sqlite3_file_control(db, "main", SQLITE_FCNTL_FILE_POINTER, (void *)&fd);
! 119: if( rc!=SQLITE_OK ) return rc;
! 120:
! 121: /* Obtain the "recovery" lock. Normally, this lock is only obtained by
! 122: ** clients running database recovery.
! 123: */
! 124: rc = superlockShmLock(fd, 2, 1, pBusy);
! 125: if( rc!=SQLITE_OK ) return rc;
! 126:
! 127: /* Zero the start of the first shared-memory page. This means that any
! 128: ** clients that open read or write transactions from this point on will
! 129: ** have to run recovery before proceeding. Since they need the "recovery"
! 130: ** lock that this process is holding to do that, no new read or write
! 131: ** transactions may now be opened. Nor can a checkpoint be run, for the
! 132: ** same reason.
! 133: */
! 134: rc = fd->pMethods->xShmMap(fd, 0, 32*1024, 1, &p);
! 135: if( rc!=SQLITE_OK ) return rc;
! 136: memset((void *)p, 0, 32);
! 137:
! 138: /* Obtain exclusive locks on all the "read-lock" slots. Once these locks
! 139: ** are held, it is guaranteed that there are no active reader, writer or
! 140: ** checkpointer clients.
! 141: */
! 142: rc = superlockShmLock(fd, 3, SQLITE_SHM_NLOCK-3, pBusy);
! 143: return rc;
! 144: }
! 145:
! 146: /*
! 147: ** Release a superlock held on a database file. The argument passed to
! 148: ** this function must have been obtained from a successful call to
! 149: ** sqlite3demo_superlock().
! 150: */
! 151: void sqlite3demo_superunlock(void *pLock){
! 152: Superlock *p = (Superlock *)pLock;
! 153: if( p->bWal ){
! 154: int rc; /* Return code */
! 155: int flags = SQLITE_SHM_UNLOCK | SQLITE_SHM_EXCLUSIVE;
! 156: sqlite3_file *fd = 0;
! 157: rc = sqlite3_file_control(p->db, "main", SQLITE_FCNTL_FILE_POINTER, (void *)&fd);
! 158: if( rc==SQLITE_OK ){
! 159: fd->pMethods->xShmLock(fd, 2, 1, flags);
! 160: fd->pMethods->xShmLock(fd, 3, SQLITE_SHM_NLOCK-3, flags);
! 161: }
! 162: }
! 163: sqlite3_close(p->db);
! 164: sqlite3_free(p);
! 165: }
! 166:
! 167: /*
! 168: ** Obtain a superlock on the database file identified by zPath, using the
! 169: ** locking primitives provided by VFS zVfs. If successful, SQLITE_OK is
! 170: ** returned and output variable *ppLock is populated with an opaque handle
! 171: ** that may be used with sqlite3demo_superunlock() to release the lock.
! 172: **
! 173: ** If an error occurs, *ppLock is set to 0 and an SQLite error code
! 174: ** (e.g. SQLITE_BUSY) is returned.
! 175: **
! 176: ** If a required lock cannot be obtained immediately and the xBusy parameter
! 177: ** to this function is not NULL, then xBusy is invoked in the same way
! 178: ** as a busy-handler registered with SQLite (using sqlite3_busy_handler())
! 179: ** until either the lock can be obtained or the busy-handler function returns
! 180: ** 0 (indicating "give up").
! 181: */
! 182: int sqlite3demo_superlock(
! 183: const char *zPath, /* Path to database file to lock */
! 184: const char *zVfs, /* VFS to use to access database file */
! 185: int (*xBusy)(void*,int), /* Busy handler callback */
! 186: void *pBusyArg, /* Context arg for busy handler */
! 187: void **ppLock /* OUT: Context to pass to superunlock() */
! 188: ){
! 189: SuperlockBusy busy = {0, 0, 0}; /* Busy handler wrapper object */
! 190: int rc; /* Return code */
! 191: Superlock *pLock;
! 192:
! 193: pLock = sqlite3_malloc(sizeof(Superlock));
! 194: if( !pLock ) return SQLITE_NOMEM;
! 195: memset(pLock, 0, sizeof(Superlock));
! 196:
! 197: /* Open a database handle on the file to superlock. */
! 198: rc = sqlite3_open_v2(
! 199: zPath, &pLock->db, SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE, zVfs
! 200: );
! 201:
! 202: /* Install a busy-handler and execute a BEGIN EXCLUSIVE. If this is not
! 203: ** a WAL database, this is all we need to do.
! 204: **
! 205: ** A wrapper function is used to invoke the busy-handler instead of
! 206: ** registering the busy-handler function supplied by the user directly
! 207: ** with SQLite. This is because the same busy-handler function may be
! 208: ** invoked directly later on when attempting to obtain the extra locks
! 209: ** required in WAL mode. By using the wrapper, we are able to guarantee
! 210: ** that the "nBusy" integer parameter passed to the users busy-handler
! 211: ** represents the total number of busy-handler invocations made within
! 212: ** this call to sqlite3demo_superlock(), including any made during the
! 213: ** "BEGIN EXCLUSIVE".
! 214: */
! 215: if( rc==SQLITE_OK ){
! 216: busy.xBusy = xBusy;
! 217: busy.pBusyArg = pBusyArg;
! 218: sqlite3_busy_handler(pLock->db, superlockBusyHandler, (void *)&busy);
! 219: rc = sqlite3_exec(pLock->db, "BEGIN EXCLUSIVE", 0, 0, 0);
! 220: }
! 221:
! 222: /* If the BEGIN EXCLUSIVE was executed successfully and this is a WAL
! 223: ** database, call superlockWalLock() to obtain the extra locks required
! 224: ** to prevent readers, writers and/or checkpointers from accessing the
! 225: ** db while this process is holding the superlock.
! 226: **
! 227: ** Before attempting any WAL locks, commit the transaction started above
! 228: ** to drop the WAL read and write locks currently held. Otherwise, the
! 229: ** new WAL locks may conflict with the old.
! 230: */
! 231: if( rc==SQLITE_OK ){
! 232: if( SQLITE_OK==(rc = superlockIsWal(pLock)) && pLock->bWal ){
! 233: rc = sqlite3_exec(pLock->db, "COMMIT", 0, 0, 0);
! 234: if( rc==SQLITE_OK ){
! 235: rc = superlockWalLock(pLock->db, &busy);
! 236: }
! 237: }
! 238: }
! 239:
! 240: if( rc!=SQLITE_OK ){
! 241: sqlite3demo_superunlock(pLock);
! 242: *ppLock = 0;
! 243: }else{
! 244: *ppLock = pLock;
! 245: }
! 246:
! 247: return rc;
! 248: }
! 249:
! 250: /*
! 251: ** End of example code. Everything below here is the test harness.
! 252: **************************************************************************
! 253: **************************************************************************
! 254: *************************************************************************/
! 255:
! 256:
! 257: #ifdef SQLITE_TEST
! 258:
! 259: #include <tcl.h>
! 260:
! 261: struct InterpAndScript {
! 262: Tcl_Interp *interp;
! 263: Tcl_Obj *pScript;
! 264: };
! 265: typedef struct InterpAndScript InterpAndScript;
! 266:
! 267: static void superunlock_del(ClientData cd){
! 268: sqlite3demo_superunlock((void *)cd);
! 269: }
! 270:
! 271: static int superunlock_cmd(
! 272: ClientData cd,
! 273: Tcl_Interp *interp,
! 274: int objc,
! 275: Tcl_Obj *CONST objv[]
! 276: ){
! 277: if( objc!=1 ){
! 278: Tcl_WrongNumArgs(interp, 1, objv, "");
! 279: return TCL_ERROR;
! 280: }
! 281: Tcl_DeleteCommand(interp, Tcl_GetString(objv[0]));
! 282: return TCL_OK;
! 283: }
! 284:
! 285: static int superlock_busy(void *pCtx, int nBusy){
! 286: InterpAndScript *p = (InterpAndScript *)pCtx;
! 287: Tcl_Obj *pEval; /* Script to evaluate */
! 288: int iVal = 0; /* Value to return */
! 289:
! 290: pEval = Tcl_DuplicateObj(p->pScript);
! 291: Tcl_IncrRefCount(pEval);
! 292: Tcl_ListObjAppendElement(p->interp, pEval, Tcl_NewIntObj(nBusy));
! 293: Tcl_EvalObjEx(p->interp, pEval, TCL_EVAL_GLOBAL);
! 294: Tcl_GetIntFromObj(p->interp, Tcl_GetObjResult(p->interp), &iVal);
! 295: Tcl_DecrRefCount(pEval);
! 296:
! 297: return iVal;
! 298: }
! 299:
! 300: /*
! 301: ** Tclcmd: sqlite3demo_superlock CMDNAME PATH VFS BUSY-HANDLER-SCRIPT
! 302: */
! 303: static int superlock_cmd(
! 304: ClientData cd,
! 305: Tcl_Interp *interp,
! 306: int objc,
! 307: Tcl_Obj *CONST objv[]
! 308: ){
! 309: void *pLock; /* Lock context */
! 310: char *zPath;
! 311: char *zVfs = 0;
! 312: InterpAndScript busy = {0, 0};
! 313: int (*xBusy)(void*,int) = 0; /* Busy handler callback */
! 314: int rc; /* Return code from sqlite3demo_superlock() */
! 315:
! 316: if( objc<3 || objc>5 ){
! 317: Tcl_WrongNumArgs(
! 318: interp, 1, objv, "CMDNAME PATH ?VFS? ?BUSY-HANDLER-SCRIPT?");
! 319: return TCL_ERROR;
! 320: }
! 321:
! 322: zPath = Tcl_GetString(objv[2]);
! 323:
! 324: if( objc>3 ){
! 325: zVfs = Tcl_GetString(objv[3]);
! 326: if( strlen(zVfs)==0 ) zVfs = 0;
! 327: }
! 328: if( objc>4 ){
! 329: busy.interp = interp;
! 330: busy.pScript = objv[4];
! 331: xBusy = superlock_busy;
! 332: }
! 333:
! 334: rc = sqlite3demo_superlock(zPath, zVfs, xBusy, &busy, &pLock);
! 335: assert( rc==SQLITE_OK || pLock==0 );
! 336: assert( rc!=SQLITE_OK || pLock!=0 );
! 337:
! 338: if( rc!=SQLITE_OK ){
! 339: extern const char *sqlite3ErrStr(int);
! 340: Tcl_ResetResult(interp);
! 341: Tcl_AppendResult(interp, sqlite3ErrStr(rc), 0);
! 342: return TCL_ERROR;
! 343: }
! 344:
! 345: Tcl_CreateObjCommand(
! 346: interp, Tcl_GetString(objv[1]), superunlock_cmd, pLock, superunlock_del
! 347: );
! 348: Tcl_SetObjResult(interp, objv[1]);
! 349: return TCL_OK;
! 350: }
! 351:
! 352: int SqliteSuperlock_Init(Tcl_Interp *interp){
! 353: Tcl_CreateObjCommand(interp, "sqlite3demo_superlock", superlock_cmd, 0, 0);
! 354: return TCL_OK;
! 355: }
! 356: #endif
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to test_superlock.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