Lines Matching defs:eLock
36530 static int kvvfsLock(sqlite3_file *pProtoFile, int eLock){
36533 SQLITE_KV_LOG(("xLock(%s,%d)\n", pFile->zClass, eLock));
36535 if( eLock!=SQLITE_LOCK_NONE ){
36544 static int kvvfsUnlock(sqlite3_file *pProtoFile, int eLock){
36547 SQLITE_KV_LOG(("xUnlock(%s,%d)\n", pFile->zClass, eLock));
36548 if( eLock==SQLITE_LOCK_NONE ){
51359 int eLock; /* Most recent lock against this file */
51639 static int memdbLock(sqlite3_file *pFile, int eLock){
51643 if( eLock<=pThis->eLock ) return SQLITE_OK;
51647 assert( pThis->eLock<=SQLITE_LOCK_SHARED || p->nWrLock==1 );
51648 assert( pThis->eLock==SQLITE_LOCK_NONE || p->nRdLock>=1 );
51650 if( eLock>SQLITE_LOCK_SHARED && (p->mFlags & SQLITE_DESERIALIZE_READONLY) ){
51653 switch( eLock ){
51655 assert( pThis->eLock==SQLITE_LOCK_NONE );
51666 assert( pThis->eLock>=SQLITE_LOCK_SHARED );
51667 if( ALWAYS(pThis->eLock==SQLITE_LOCK_SHARED) ){
51678 assert( eLock==SQLITE_LOCK_EXCLUSIVE );
51679 assert( pThis->eLock>=SQLITE_LOCK_SHARED );
51682 }else if( pThis->eLock==SQLITE_LOCK_SHARED ){
51689 if( rc==SQLITE_OK ) pThis->eLock = eLock;
51697 static int memdbUnlock(sqlite3_file *pFile, int eLock){
51700 if( eLock>=pThis->eLock ) return SQLITE_OK;
51703 assert( eLock==SQLITE_LOCK_SHARED || eLock==SQLITE_LOCK_NONE );
51704 if( eLock==SQLITE_LOCK_SHARED ){
51705 if( ALWAYS(pThis->eLock>SQLITE_LOCK_SHARED) ){
51709 if( pThis->eLock>SQLITE_LOCK_SHARED ){
51715 pThis->eLock = eLock;
55841 ** The Pager.eLock variable is almost always set to one of the
55850 ** pagerUnlockDb() take a conservative approach - eLock is always updated
55852 ** VFS call is successful. This way, the Pager.eLock variable may be set
55877 ** database in the ERROR state, Pager.eLock is set to UNKNOWN_LOCK. It
55880 ** omits the check for a hot-journal if Pager.eLock is set to UNKNOWN_LOCK
55885 ** Pager.eLock may only be set to UNKNOWN_LOCK when the pager is in
55955 ** eLock
56140 u8 eLock; /* Current lock held on database file */
56370 assert( p->tempFile==0 || p->eLock==EXCLUSIVE_LOCK );
56400 assert( pPager->changeCountDone==0 || pPager->eLock>=RESERVED_LOCK );
56401 assert( p->eLock!=PENDING_LOCK );
56412 assert( p->eLock!=UNKNOWN_LOCK );
56413 assert( p->eLock>=SHARED_LOCK );
56417 assert( p->eLock!=UNKNOWN_LOCK );
56420 assert( p->eLock>=RESERVED_LOCK );
56429 assert( p->eLock!=UNKNOWN_LOCK );
56437 assert( p->eLock>=RESERVED_LOCK );
56448 assert( p->eLock==EXCLUSIVE_LOCK );
56451 assert( p->eLock>=EXCLUSIVE_LOCK );
56461 assert( p->eLock==EXCLUSIVE_LOCK );
56519 , p->eLock==NO_LOCK ? "NO_LOCK" :
56520 p->eLock==RESERVED_LOCK ? "RESERVED" :
56521 p->eLock==EXCLUSIVE_LOCK ? "EXCLUSIVE" :
56522 p->eLock==SHARED_LOCK ? "SHARED" :
56523 p->eLock==UNKNOWN_LOCK ? "UNKNOWN" : "?error?"
56635 ** Unlock the database file to level eLock, which must be either NO_LOCK
56637 ** succeeds, set the Pager.eLock variable to match the (attempted) new lock.
56639 ** Except, if Pager.eLock is set to UNKNOWN_LOCK when this function is
56643 static int pagerUnlockDb(Pager *pPager, int eLock){
56646 assert( !pPager->exclusiveMode || pPager->eLock==eLock );
56647 assert( eLock==NO_LOCK || eLock==SHARED_LOCK );
56648 assert( eLock!=NO_LOCK || pagerUseWal(pPager)==0 );
56650 assert( pPager->eLock>=eLock );
56651 rc = pPager->noLock ? SQLITE_OK : sqlite3OsUnlock(pPager->fd, eLock);
56652 if( pPager->eLock!=UNKNOWN_LOCK ){
56653 pPager->eLock = (u8)eLock;
56655 IOTRACE(("UNLOCK %p %d\n", pPager, eLock))
56662 ** Lock the database file to level eLock, which must be either SHARED_LOCK,
56664 ** Pager.eLock variable to the new locking state.
56666 ** Except, if Pager.eLock is set to UNKNOWN_LOCK when this function is
56671 static int pagerLockDb(Pager *pPager, int eLock){
56674 assert( eLock==SHARED_LOCK || eLock==RESERVED_LOCK || eLock==EXCLUSIVE_LOCK );
56675 if( pPager->eLock<eLock || pPager->eLock==UNKNOWN_LOCK ){
56676 rc = pPager->noLock ? SQLITE_OK : sqlite3OsLock(pPager->fd, eLock);
56677 if( rc==SQLITE_OK && (pPager->eLock!=UNKNOWN_LOCK||eLock==EXCLUSIVE_LOCK) ){
56678 pPager->eLock = (u8)eLock;
56679 IOTRACE(("LOCK %p %d\n", pPager, eLock))
57371 pPager->eLock = UNKNOWN_LOCK;
57529 ** eState==PAGER_NONE and eLock==EXCLUSIVE_LOCK.
57534 ** and eLock==EXCLUSIVE_LOCK when the read-transaction is closed.
57538 if( pPager->eState<PAGER_WRITER_LOCKED && pPager->eLock<RESERVED_LOCK ){
57629 assert( pPager->eLock==EXCLUSIVE_LOCK );
57812 || (pPager->eState==PAGER_OPEN && pPager->eLock==EXCLUSIVE_LOCK)
58175 assert( pPager->eLock==EXCLUSIVE_LOCK );
58799 assert( pPager->eLock>=SHARED_LOCK );
58852 assert( pPager->eLock>=SHARED_LOCK );
59453 assert( (pPager->eLock>=locktype)
59454 || (pPager->eLock==NO_LOCK && locktype==SHARED_LOCK)
59455 || (pPager->eLock==RESERVED_LOCK && locktype==EXCLUSIVE_LOCK)
59936 assert( pPager->eLock==EXCLUSIVE_LOCK );
60522 pPager->eLock = EXCLUSIVE_LOCK; /* Pretend we are in EXCLUSIVE mode */
60792 assert( pPager->tempFile==0 || pPager->eLock==EXCLUSIVE_LOCK );
60796 assert( pPager->eLock==NO_LOCK || pPager->eLock==UNKNOWN_LOCK );
60803 if( pPager->eLock<=SHARED_LOCK ){
60889 ** the file. If the unlock attempt fails, then Pager.eLock must be
60907 assert( (pPager->eLock==SHARED_LOCK)
60908 || (pPager->exclusiveMode && pPager->eLock>SHARED_LOCK)
62954 if( pPager->eLock>=RESERVED_LOCK ){
63100 assert( pPager->eLock==SHARED_LOCK || pPager->eLock==EXCLUSIVE_LOCK );
63121 assert( pPager->eLock==SHARED_LOCK || pPager->eLock==EXCLUSIVE_LOCK );
67882 u8 eLock; /* READ_LOCK or WRITE_LOCK */
67886 /* Candidate values for BtLock.eLock */
68855 && (pLock->iTable==iTab || (pLock->eLock==WRITE_LOCK && pLock->iTable==1))
68856 && pLock->eLock>=eLockType
68901 ** Query to see if Btree handle p may obtain a lock of type eLock
68906 static int querySharedCacheTableLock(Btree *p, Pgno iTab, u8 eLock){
68911 assert( eLock==READ_LOCK || eLock==WRITE_LOCK );
68913 assert( !(p->db->flags&SQLITE_ReadUncommit)||eLock==WRITE_LOCK||iTab==1 );
68919 assert( eLock==READ_LOCK || (p==pBt->pWriter && p->inTrans==TRANS_WRITE) );
68920 assert( eLock==READ_LOCK || pBt->inTransaction==TRANS_WRITE );
68936 /* The condition (pIter->eLock!=eLock) in the following if(...)
68939 ** (eLock==WRITE_LOCK || pIter->eLock==WRITE_LOCK)
68941 ** since we know that if eLock==WRITE_LOCK, then no other connection
68945 assert( pIter->eLock==READ_LOCK || pIter->eLock==WRITE_LOCK );
68946 assert( eLock==READ_LOCK || pIter->pBtree==p || pIter->eLock==READ_LOCK);
68947 if( pIter->pBtree!=p && pIter->iTable==iTab && pIter->eLock!=eLock ){
68949 if( eLock==WRITE_LOCK ){
68963 ** by Btree handle p. Parameter eLock must be either READ_LOCK or
68978 static int setSharedCacheTableLock(Btree *p, Pgno iTable, u8 eLock){
68984 assert( eLock==READ_LOCK || eLock==WRITE_LOCK );
68991 assert( 0==(p->db->flags&SQLITE_ReadUncommit) || eLock==WRITE_LOCK );
68996 assert( SQLITE_OK==querySharedCacheTableLock(p, iTable, eLock) );
69020 /* Set the BtLock.eLock variable to the maximum of the current lock
69025 if( eLock>pLock->eLock ){
69026 pLock->eLock = eLock;
69053 assert( pLock->pBtree->inTrans>=pLock->eLock );
69093 assert( pLock->eLock==READ_LOCK || pLock->pBtree==p );
69094 pLock->eLock = READ_LOCK;
72247 p->lock.eLock = READ_LOCK;
213600 static int rbuVfsLock(sqlite3_file *pFile, int eLock){
213606 if( eLock==SQLITE_LOCK_EXCLUSIVE
213613 rc = p->pReal->pMethods->xLock(p->pReal, eLock);
213622 static int rbuVfsUnlock(sqlite3_file *pFile, int eLock){
213624 return p->pReal->pMethods->xUnlock(p->pReal, eLock);