Lines Matching refs:pFile
14819 sqlite3_file *pFile, in sqlite3OsOpen() argument
14829 rc = pVfs->xOpen(pVfs, zPath, pFile, flags & 0x87f7f, pFlagsOut); in sqlite3OsOpen()
14830 assert( rc==SQLITE_OK || pFile->pMethods==0 ); in sqlite3OsOpen()
14903 sqlite3_file *pFile; in sqlite3OsOpenMalloc() local
14904 pFile = (sqlite3_file *)sqlite3MallocZero(pVfs->szOsFile); in sqlite3OsOpenMalloc()
14905 if( pFile ){ in sqlite3OsOpenMalloc()
14906 rc = sqlite3OsOpen(pVfs, zFile, pFile, flags, pOutFlags); in sqlite3OsOpenMalloc()
14908 sqlite3_free(pFile); in sqlite3OsOpenMalloc()
14910 *ppFile = pFile; in sqlite3OsOpenMalloc()
14915 SQLITE_PRIVATE int sqlite3OsCloseFree(sqlite3_file *pFile){ in sqlite3OsCloseFree() argument
14917 assert( pFile ); in sqlite3OsCloseFree()
14918 rc = sqlite3OsClose(pFile); in sqlite3OsCloseFree()
14919 sqlite3_free(pFile); in sqlite3OsCloseFree()
22978 os2File *pFile = (os2File*)id;
22981 OSTRACE(( "CLOSE %d (%s)\n", pFile->h, pFile->zFullPathCp ));
22983 rc = DosClose( pFile->h );
22985 if( pFile->flags & SQLITE_OPEN_DELETEONCLOSE )
22986 DosForceDelete( (PSZ)pFile->zFullPathCp );
22988 free( pFile->zFullPathCp );
22989 pFile->zFullPathCp = NULL;
22990 pFile->locktype = NO_LOCK;
22991 pFile->h = (HFILE)-1;
22992 pFile->flags = 0;
23011 os2File *pFile = (os2File*)id;
23014 OSTRACE(( "READ %d lock=%d\n", pFile->h, pFile->locktype ));
23015 if( DosSetFilePtr(pFile->h, offset, FILE_BEGIN, &fileLocation) != NO_ERROR ){
23018 if( DosRead( pFile->h, pBuf, amt, &got ) != NO_ERROR ){
23043 os2File *pFile = (os2File*)id;
23047 OSTRACE(( "WRITE %d lock=%d\n", pFile->h, pFile->locktype ));
23048 if( DosSetFilePtr(pFile->h, offset, FILE_BEGIN, &fileLocation) != NO_ERROR ){
23053 ( rc = DosWrite( pFile->h, (PVOID)pBuf, amt, &wrote ) ) == NO_ERROR &&
23068 os2File *pFile = (os2File*)id;
23070 OSTRACE(( "TRUNCATE %d %lld\n", pFile->h, nByte ));
23078 if( pFile->szChunk ){
23079 nByte = ((nByte + pFile->szChunk - 1)/pFile->szChunk) * pFile->szChunk;
23082 rc = DosSetFileSize( pFile->h, nByte );
23099 os2File *pFile = (os2File*)id;
23100 OSTRACE(( "SYNC %d lock=%d\n", pFile->h, pFile->locktype ));
23111 UNUSED_PARAMETER(pFile);
23114 return DosResetBuffer( pFile->h ) == NO_ERROR ? SQLITE_OK : SQLITE_IOERR;
23139 static int getReadLock( os2File *pFile ){
23149 res = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 1L );
23150 OSTRACE(( "GETREADLOCK %d res=%d\n", pFile->h, res ));
23205 os2File *pFile = (os2File*)id;
23208 assert( pFile!=0 );
23209 OSTRACE(( "LOCK %d %d was %d\n", pFile->h, locktype, pFile->locktype ));
23215 if( pFile->locktype>=locktype ){
23216 OSTRACE(( "LOCK %d %d ok (already held)\n", pFile->h, locktype ));
23222 assert( pFile->locktype!=NO_LOCK || locktype==SHARED_LOCK );
23224 assert( locktype!=RESERVED_LOCK || pFile->locktype==SHARED_LOCK );
23230 newLocktype = pFile->locktype;
23231 if( pFile->locktype==NO_LOCK
23232 || (locktype==EXCLUSIVE_LOCK && pFile->locktype==RESERVED_LOCK)
23240 res = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, 100L, 0L );
23243 OSTRACE(( "LOCK %d pending lock boolean set. res=%d\n", pFile->h, res ));
23250 assert( pFile->locktype==NO_LOCK );
23251 res = getReadLock(pFile);
23255 OSTRACE(( "LOCK %d acquire shared lock. res=%d\n", pFile->h, res ));
23261 assert( pFile->locktype==SHARED_LOCK );
23266 res = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 0L );
23270 OSTRACE(( "LOCK %d acquire reserved lock. res=%d\n", pFile->h, res ));
23279 pFile->h ));
23285 assert( pFile->locktype>=SHARED_LOCK );
23286 res = unlockReadLock(pFile);
23292 res = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 0L );
23297 getReadLock(pFile);
23299 OSTRACE(( "LOCK %d acquire exclusive lock. res=%d\n", pFile->h, res ));
23311 r = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 0L );
23312 OSTRACE(( "LOCK %d unlocking pending/is shared. r=%d\n", pFile->h, r ));
23321 OSTRACE(( "LOCK FAILED %d trying for %d but got %d\n", pFile->h,
23325 pFile->locktype = newLocktype;
23326 OSTRACE(( "LOCK %d now %d\n", pFile->h, pFile->locktype ));
23337 os2File *pFile = (os2File*)id;
23338 assert( pFile!=0 );
23339 if( pFile->locktype>=RESERVED_LOCK ){
23341 OSTRACE(( "TEST WR-LOCK %d %d (local)\n", pFile->h, r ));
23352 rc = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 0L );
23353 OSTRACE(( "TEST WR-LOCK %d lock reserved byte rc=%d\n", pFile->h, rc ));
23360 rcu = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 0L );
23361 OSTRACE(( "TEST WR-LOCK %d unlock reserved byte r=%d\n", pFile->h, rcu ));
23364 OSTRACE(( "TEST WR-LOCK %d %d (remote)\n", pFile->h, r ));
23383 os2File *pFile = (os2File*)id;
23390 assert( pFile!=0 );
23392 OSTRACE(( "UNLOCK %d to %d was %d\n", pFile->h, locktype, pFile->locktype ));
23393 type = pFile->locktype;
23399 res = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 0L );
23400 OSTRACE(( "UNLOCK %d exclusive lock res=%d\n", pFile->h, res ));
23401 if( locktype==SHARED_LOCK && getReadLock(pFile) != NO_ERROR ){
23404 OSTRACE(( "UNLOCK %d to %d getReadLock() failed\n", pFile->h, locktype ));
23413 res = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 0L );
23414 OSTRACE(( "UNLOCK %d reserved res=%d\n", pFile->h, res ));
23417 res = unlockReadLock(pFile);
23419 pFile->h, type, locktype, res ));
23426 res = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 0L );
23427 OSTRACE(( "UNLOCK %d pending res=%d\n", pFile->h, res ));
23429 pFile->locktype = locktype;
23430 OSTRACE(( "UNLOCK %d now %d\n", pFile->h, pFile->locktype ));
23959 os2File *pFile = (os2File*)id;
23963 if( !pFile->pShmLink )
23964 rc = os2OpenSharedMemory( pFile, szRegion );
23967 pNode = pFile->pShmLink->pShmNode ;
24027 pFile->zFullPathCp, iRegion, szRegion, bExtend, rc))
24043 os2File *pFile = (os2File*)id;
24044 os2ShmLink *pLink = pFile->pShmLink;
24067 pFile->pShmLink = NULL;
24095 os2File *pFile = (os2File*)id;
24096 os2ShmLink *p = pFile->pShmLink; /* The shared memory being locked */
24352 os2File *pFile = (os2File*)id;
24400 memset( pFile, 0, sizeof(*pFile) );
24401 pFile->h = (HFILE)-1;
24474 pFile->zFullPathCp = convertUtf8PathToCp( zTmpname );
24475 pFile->pMethod = &os2IoMethod;
24476 pFile->flags = flags;
24477 pFile->h = h;
24480 OSTRACE(( "OPEN %d pOutFlags=%d\n", pFile->h, pOutFlags ));
26134 static void robust_close(unixFile *pFile, int h, int lineno){
26137 pFile ? pFile->zPath : 0, lineno);
26144 static void closePendingFds(unixFile *pFile){
26145 unixInodeInfo *pInode = pFile->pInode;
26150 robust_close(pFile, p->fd, __LINE__);
26162 static void releaseInodeInfo(unixFile *pFile){
26163 unixInodeInfo *pInode = pFile->pInode;
26169 closePendingFds(pFile);
26197 unixFile *pFile, /* Unix file with file desc used in the key */
26211 fd = pFile->h;
26214 pFile->lastErrno = errno;
26216 if( pFile->lastErrno==EOVERFLOW ) return SQLITE_NOLFS;
26232 if( statbuf.st_size==0 && (pFile->fsFlags & SQLITE_FSFLAGS_IS_MSDOS)!=0 ){
26235 pFile->lastErrno = errno;
26240 pFile->lastErrno = errno;
26249 fileId.pId = pFile->pId;
26286 unixFile *pFile = (unixFile*)id;
26290 assert( pFile );
26294 if( pFile->pInode->eFileLock>SHARED_LOCK ){
26301 if( !reserved && !pFile->pInode->bProcessLock ){
26307 if( osFcntl(pFile->h, F_GETLK, &lock) ){
26309 pFile->lastErrno = errno;
26317 OSTRACE(("TEST WR-LOCK %d %d %d (unix)\n", pFile->h, rc, reserved));
26342 static int unixFileLock(unixFile *pFile, struct flock *pLock){
26344 unixInodeInfo *pInode = pFile->pInode;
26347 if( ((pFile->ctrlFlags & UNIXFILE_EXCL)!=0 || pInode->bProcessLock)
26348 && ((pFile->ctrlFlags & UNIXFILE_RDONLY)==0)
26357 rc = osFcntl(pFile->h, F_SETLK, &lock);
26365 rc = osFcntl(pFile->h, F_SETLK, pLock);
26434 unixFile *pFile = (unixFile*)id;
26439 assert( pFile );
26440 OSTRACE(("LOCK %d %s was %s(%s,%d) pid=%d (unix)\n", pFile->h,
26441 azFileLock(eFileLock), azFileLock(pFile->eFileLock),
26442 azFileLock(pFile->pInode->eFileLock), pFile->pInode->nShared , getpid()));
26448 if( pFile->eFileLock>=eFileLock ){
26449 OSTRACE(("LOCK %d %s ok (already held) (unix)\n", pFile->h,
26459 assert( pFile->eFileLock!=NO_LOCK || eFileLock==SHARED_LOCK );
26461 assert( eFileLock!=RESERVED_LOCK || pFile->eFileLock==SHARED_LOCK );
26466 pInode = pFile->pInode;
26471 if( (pFile->eFileLock!=pInode->eFileLock &&
26485 assert( pFile->eFileLock==0 );
26487 pFile->eFileLock = SHARED_LOCK;
26501 || (eFileLock==EXCLUSIVE_LOCK && pFile->eFileLock<PENDING_LOCK)
26505 if( unixFileLock(pFile, &lock) ){
26509 pFile->lastErrno = tErrno;
26527 if( unixFileLock(pFile, &lock) ){
26536 if( unixFileLock(pFile, &lock) && rc==SQLITE_OK ){
26544 pFile->lastErrno = tErrno;
26548 pFile->eFileLock = SHARED_LOCK;
26561 assert( 0!=pFile->eFileLock );
26573 if( unixFileLock(pFile, &lock) ){
26577 pFile->lastErrno = tErrno;
26590 && pFile->eFileLock<=SHARED_LOCK
26593 pFile->transCntrChng = 0;
26594 pFile->dbUpdate = 0;
26595 pFile->inNormalWrite = 1;
26601 pFile->eFileLock = eFileLock;
26604 pFile->eFileLock = PENDING_LOCK;
26610 OSTRACE(("LOCK %d %s %s (unix)\n", pFile->h, azFileLock(eFileLock),
26619 static void setPendingFd(unixFile *pFile){
26620 unixInodeInfo *pInode = pFile->pInode;
26621 UnixUnusedFd *p = pFile->pUnused;
26624 pFile->h = -1;
26625 pFile->pUnused = 0;
26642 unixFile *pFile = (unixFile*)id;
26647 assert( pFile );
26648 OSTRACE(("UNLOCK %d %d was %d(%d,%d) pid=%d (unix)\n", pFile->h, eFileLock,
26649 pFile->eFileLock, pFile->pInode->eFileLock, pFile->pInode->nShared,
26653 if( pFile->eFileLock<=eFileLock ){
26657 pInode = pFile->pInode;
26659 if( pFile->eFileLock>SHARED_LOCK ){
26660 assert( pInode->eFileLock==pFile->eFileLock );
26671 pFile->inNormalWrite = 0;
26698 if( unixFileLock(pFile, &lock)==(-1) ){
26702 pFile->lastErrno = tErrno;
26710 if( unixFileLock(pFile, &lock)==(-1) ){
26714 pFile->lastErrno = tErrno;
26722 if( unixFileLock(pFile, &lock)==(-1) ){
26726 pFile->lastErrno = tErrno;
26737 if( unixFileLock(pFile, &lock) ){
26745 pFile->lastErrno = errno;
26754 if( unixFileLock(pFile, &lock)==0 ){
26758 pFile->lastErrno = errno;
26772 if( unixFileLock(pFile, &lock)==0 ){
26776 pFile->lastErrno = errno;
26778 pFile->eFileLock = NO_LOCK;
26789 closePendingFds(pFile);
26795 if( rc==SQLITE_OK ) pFile->eFileLock = eFileLock;
26821 unixFile *pFile = (unixFile*)id;
26822 if( pFile->h>=0 ){
26823 robust_close(pFile, pFile->h, __LINE__);
26824 pFile->h = -1;
26827 if( pFile->pId ){
26828 if( pFile->ctrlFlags & UNIXFILE_DELETE ){
26829 osUnlink(pFile->pId->zCanonicalName);
26831 vxworksReleaseFileId(pFile->pId);
26832 pFile->pId = 0;
26835 OSTRACE(("CLOSE %-3d\n", pFile->h));
26837 sqlite3_free(pFile->pUnused);
26838 memset(pFile, 0, sizeof(unixFile));
26847 unixFile *pFile = (unixFile *)id;
26854 assert( pFile->pInode->nLock>0 || pFile->pInode->bProcessLock==0 );
26855 if( ALWAYS(pFile->pInode) && pFile->pInode->nLock ){
26861 setPendingFd(pFile);
26863 releaseInodeInfo(pFile);
26954 unixFile *pFile = (unixFile*)id;
26958 assert( pFile );
26961 if( pFile->eFileLock>SHARED_LOCK ){
26967 const char *zLockFile = (const char*)pFile->lockingContext;
26970 OSTRACE(("TEST WR-LOCK %d %d %d (dotlock)\n", pFile->h, rc, reserved));
27003 unixFile *pFile = (unixFile*)id;
27004 char *zLockFile = (char *)pFile->lockingContext;
27011 if( pFile->eFileLock > NO_LOCK ){
27012 pFile->eFileLock = eFileLock;
27032 pFile->lastErrno = tErrno;
27039 pFile->eFileLock = eFileLock;
27053 unixFile *pFile = (unixFile*)id;
27054 char *zLockFile = (char *)pFile->lockingContext;
27057 assert( pFile );
27058 OSTRACE(("UNLOCK %d %d was %d pid=%d (dotlock)\n", pFile->h, eFileLock,
27059 pFile->eFileLock, getpid()));
27063 if( pFile->eFileLock==eFileLock ){
27071 pFile->eFileLock = SHARED_LOCK;
27086 pFile->lastErrno = tErrno;
27090 pFile->eFileLock = NO_LOCK;
27100 unixFile *pFile = (unixFile*)id;
27102 sqlite3_free(pFile->lockingContext);
27150 unixFile *pFile = (unixFile*)id;
27154 assert( pFile );
27157 if( pFile->eFileLock>SHARED_LOCK ){
27164 int lrc = robust_flock(pFile->h, LOCK_EX | LOCK_NB);
27167 lrc = robust_flock(pFile->h, LOCK_UN);
27173 pFile->lastErrno = tErrno;
27183 pFile->lastErrno = tErrno;
27188 OSTRACE(("TEST WR-LOCK %d %d %d (flock)\n", pFile->h, rc, reserved));
27231 unixFile *pFile = (unixFile*)id;
27233 assert( pFile );
27237 if (pFile->eFileLock > NO_LOCK) {
27238 pFile->eFileLock = eFileLock;
27244 if (robust_flock(pFile->h, LOCK_EX | LOCK_NB)) {
27249 pFile->lastErrno = tErrno;
27253 pFile->eFileLock = eFileLock;
27255 OSTRACE(("LOCK %d %s %s (flock)\n", pFile->h, azFileLock(eFileLock),
27274 unixFile *pFile = (unixFile*)id;
27276 assert( pFile );
27277 OSTRACE(("UNLOCK %d %d was %d pid=%d (flock)\n", pFile->h, eFileLock,
27278 pFile->eFileLock, getpid()));
27282 if( pFile->eFileLock==eFileLock ){
27288 pFile->eFileLock = eFileLock;
27293 if( robust_flock(pFile->h, LOCK_UN) ){
27299 pFile->eFileLock = NO_LOCK;
27340 unixFile *pFile = (unixFile*)id;
27344 assert( pFile );
27347 if( pFile->eFileLock>SHARED_LOCK ){
27353 sem_t *pSem = pFile->pInode->pSem;
27360 pFile->lastErrno = tErrno;
27363 reserved = (pFile->eFileLock < SHARED_LOCK);
27370 OSTRACE(("TEST WR-LOCK %d %d %d (sem)\n", pFile->h, rc, reserved));
27406 unixFile *pFile = (unixFile*)id;
27408 sem_t *pSem = pFile->pInode->pSem;
27413 if (pFile->eFileLock > NO_LOCK) {
27414 pFile->eFileLock = eFileLock;
27426 pFile->eFileLock = eFileLock;
27440 unixFile *pFile = (unixFile*)id;
27441 sem_t *pSem = pFile->pInode->pSem;
27443 assert( pFile );
27445 OSTRACE(("UNLOCK %d %d was %d pid=%d (sem)\n", pFile->h, eFileLock,
27446 pFile->eFileLock, getpid()));
27450 if( pFile->eFileLock==eFileLock ){
27456 pFile->eFileLock = eFileLock;
27465 pFile->lastErrno = tErrno;
27469 pFile->eFileLock = NO_LOCK;
27478 unixFile *pFile = (unixFile*)id;
27480 assert( pFile );
27482 releaseInodeInfo(pFile);
27537 unixFile *pFile, /* Open file descriptor on path */
27549 pb.fd = pFile->h;
27552 (setLockFlag?"ON":"OFF"), pFile->h, (pb.fd==-1?"[testval-1]":""),
27567 pFile->lastErrno = tErrno;
27584 unixFile *pFile = (unixFile*)id;
27589 assert( pFile );
27590 context = (afpLockingContext *) pFile->lockingContext;
27598 if( pFile->pInode->eFileLock>SHARED_LOCK ){
27606 int lrc = afpSetLock(context->dbPath, pFile, RESERVED_BYTE, 1,1);
27610 lrc = afpSetLock(context->dbPath, pFile, RESERVED_BYTE, 1, 0);
27621 OSTRACE(("TEST WR-LOCK %d %d %d (afp)\n", pFile->h, rc, reserved));
27653 unixFile *pFile = (unixFile*)id;
27654 unixInodeInfo *pInode = pFile->pInode;
27655 afpLockingContext *context = (afpLockingContext *) pFile->lockingContext;
27657 assert( pFile );
27658 OSTRACE(("LOCK %d %s was %s(%s,%d) pid=%d (afp)\n", pFile->h,
27659 azFileLock(eFileLock), azFileLock(pFile->eFileLock),
27666 if( pFile->eFileLock>=eFileLock ){
27667 OSTRACE(("LOCK %d %s ok (already held) (afp)\n", pFile->h,
27677 assert( pFile->eFileLock!=NO_LOCK || eFileLock==SHARED_LOCK );
27679 assert( eFileLock!=RESERVED_LOCK || pFile->eFileLock==SHARED_LOCK );
27684 pInode = pFile->pInode;
27689 if( (pFile->eFileLock!=pInode->eFileLock &&
27703 assert( pFile->eFileLock==0 );
27705 pFile->eFileLock = SHARED_LOCK;
27716 || (eFileLock==EXCLUSIVE_LOCK && pFile->eFileLock<PENDING_LOCK)
27719 failed = afpSetLock(context->dbPath, pFile, PENDING_BYTE, 1, 1);
27741 lrc1 = afpSetLock(context->dbPath, pFile,
27744 lrc1Errno = pFile->lastErrno;
27747 lrc2 = afpSetLock(context->dbPath, pFile, PENDING_BYTE, 1, 0);
27750 pFile->lastErrno = lrc1Errno;
27759 pFile->eFileLock = SHARED_LOCK;
27773 assert( 0!=pFile->eFileLock );
27774 if (eFileLock >= RESERVED_LOCK && pFile->eFileLock < RESERVED_LOCK) {
27776 failed = afpSetLock(context->dbPath, pFile, RESERVED_BYTE, 1,1);
27787 if( !(failed = afpSetLock(context->dbPath, pFile, SHARED_FIRST +
27791 failed = afpSetLock(context->dbPath, pFile, SHARED_FIRST,
27793 if( failed && (failed2 = afpSetLock(context->dbPath, pFile,
27812 pFile->eFileLock = eFileLock;
27815 pFile->eFileLock = PENDING_LOCK;
27821 OSTRACE(("LOCK %d %s %s (afp)\n", pFile->h, azFileLock(eFileLock),
27835 unixFile *pFile = (unixFile*)id;
27837 afpLockingContext *context = (afpLockingContext *) pFile->lockingContext;
27840 int h = pFile->h;
27843 assert( pFile );
27844 OSTRACE(("UNLOCK %d %d was %d(%d,%d) pid=%d (afp)\n", pFile->h, eFileLock,
27845 pFile->eFileLock, pFile->pInode->eFileLock, pFile->pInode->nShared,
27849 if( pFile->eFileLock<=eFileLock ){
27853 pInode = pFile->pInode;
27855 if( pFile->eFileLock>SHARED_LOCK ){
27856 assert( pInode->eFileLock==pFile->eFileLock );
27870 assert( pFile->inNormalWrite==0
27871 || pFile->dbUpdate==0
27872 || pFile->transCntrChng==1 );
27873 pFile->inNormalWrite = 0;
27876 if( pFile->eFileLock==EXCLUSIVE_LOCK ){
27877 rc = afpSetLock(context->dbPath, pFile, SHARED_FIRST, SHARED_SIZE, 0);
27881 rc = afpSetLock(context->dbPath, pFile, sharedLockByte, 1, 1);
27886 if( rc==SQLITE_OK && pFile->eFileLock>=PENDING_LOCK ){
27887 rc = afpSetLock(context->dbPath, pFile, PENDING_BYTE, 1, 0);
27889 if( rc==SQLITE_OK && pFile->eFileLock>=RESERVED_LOCK && context->reserved ){
27890 rc = afpSetLock(context->dbPath, pFile, RESERVED_BYTE, 1, 0);
27912 rc = afpSetLock(context->dbPath, pFile, sharedLockByte, 1, 0);
27916 pFile->eFileLock = NO_LOCK;
27923 closePendingFds(pFile);
27929 if( rc==SQLITE_OK ) pFile->eFileLock = eFileLock;
27939 unixFile *pFile = (unixFile*)id;
27942 if( pFile->pInode && pFile->pInode->nLock ){
27948 setPendingFd(pFile);
27950 releaseInodeInfo(pFile);
27951 sqlite3_free(pFile->lockingContext);
28072 unixFile *pFile = (unixFile *)id;
28079 assert( pFile->pUnused==0
28085 got = seekAndRead(pFile, offset, pBuf, amt);
28092 pFile->lastErrno = 0; /* not a system error */
28151 unixFile *pFile = (unixFile*)id;
28159 assert( pFile->pUnused==0
28172 if( pFile->inNormalWrite ){
28173 pFile->dbUpdate = 1; /* The database has been modified */
28178 rc = seekAndRead(pFile, 24, oldCntr, 4);
28181 pFile->transCntrChng = 1; /* The transaction counter has changed */
28187 while( amt>0 && (wrote = seekAndWrite(pFile, offset, pBuf, amt))>0 ){
28196 if( wrote<0 && pFile->lastErrno!=ENOSPC ){
28200 pFile->lastErrno = 0; /* not a system error */
28392 unixFile *pFile = (unixFile*)id;
28407 assert( pFile );
28408 OSTRACE(("SYNC %-3d\n", pFile->h));
28409 rc = full_fsync(pFile->h, isFullsync, isDataOnly);
28412 pFile->lastErrno = errno;
28413 return unixLogError(SQLITE_IOERR_FSYNC, "full_fsync", pFile->zPath);
28420 if( pFile->ctrlFlags & UNIXFILE_DIRSYNC ){
28422 OSTRACE(("DIRSYNC %s (have_fullfsync=%d fullsync=%d)\n", pFile->zPath,
28424 rc = osOpenDirectory(pFile->zPath, &dirfd);
28427 robust_close(pFile, dirfd, __LINE__);
28431 pFile->ctrlFlags &= ~UNIXFILE_DIRSYNC;
28440 unixFile *pFile = (unixFile *)id;
28442 assert( pFile );
28450 if( pFile->szChunk ){
28451 nByte = ((nByte + pFile->szChunk - 1)/pFile->szChunk) * pFile->szChunk;
28454 rc = robust_ftruncate(pFile->h, (off_t)nByte);
28456 pFile->lastErrno = errno;
28457 return unixLogError(SQLITE_IOERR_TRUNCATE, "ftruncate", pFile->zPath);
28467 if( pFile->inNormalWrite && nByte==0 ){
28468 pFile->transCntrChng = 1;
28517 static int fcntlSizeHint(unixFile *pFile, i64 nByte){
28518 if( pFile->szChunk>0 ){
28522 if( osFstat(pFile->h, &buf) ) return SQLITE_IOERR_FSTAT;
28524 nSize = ((nByte+pFile->szChunk-1) / pFile->szChunk) * pFile->szChunk;
28533 err = osFallocate(pFile->h, buf.st_size, nSize-buf.st_size);
28546 if( robust_ftruncate(pFile->h, nSize) ){
28547 pFile->lastErrno = errno;
28548 return unixLogError(SQLITE_IOERR_TRUNCATE, "ftruncate", pFile->zPath);
28552 int nWrite = seekAndWrite(pFile, iWrite, "", 1);
28569 static void unixModeBit(unixFile *pFile, unsigned char mask, int *pArg){
28571 *pArg = (pFile->ctrlFlags & mask)!=0;
28573 pFile->ctrlFlags &= ~mask;
28575 pFile->ctrlFlags |= mask;
28583 unixFile *pFile = (unixFile*)id;
28586 *(int*)pArg = pFile->eFileLock;
28590 *(int*)pArg = pFile->lastErrno;
28594 pFile->szChunk = *(int *)pArg;
28600 rc = fcntlSizeHint(pFile, *(i64 *)pArg);
28605 unixModeBit(pFile, UNIXFILE_PERSIST_WAL, (int*)pArg);
28609 unixModeBit(pFile, UNIXFILE_PSOW, (int*)pArg);
28613 *(char**)pArg = sqlite3_mprintf("%s", pFile->pVfs->zName);
28647 static int unixSectorSize(sqlite3_file *pFile){
28648 (void)pFile;
30042 sqlite3_file *pFile, /* The file descriptor to be filled in */
30046 unixFile *p = (unixFile *)pFile;
30221 ((unixFile*)pFile)->lastErrno = errno;
30226 ((unixFile*)pFile)->fsFlags |= SQLITE_FSFLAGS_IS_MSDOS;
30266 rc = fillInUnixFile(pVfs, fd, pFile, zPath, ctrlFlags);
30268 rc = proxyTransformUnixFile((unixFile*)pFile, ":auto:");
30274 unixClose(pFile);
30283 rc = fillInUnixFile(pVfs, fd, pFile, zPath, ctrlFlags);
31021 static int proxyBreakConchLock(unixFile *pFile, uuid_t myHostID){
31022 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
31063 robust_close(pFile, conchFile->h, __LINE__);
31071 robust_close(pFile, fd, __LINE__);
31081 static int proxyConchLock(unixFile *pFile, uuid_t myHostID, int lockType){
31082 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
31101 pFile->lastErrno = errno;
31121 pFile->lastErrno = errno;
31138 if( 0==proxyBreakConchLock(pFile, myHostID) ){
31159 static int proxyTakeConch(unixFile *pFile){
31160 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
31183 pFile->lastErrno = pError;
31186 rc = proxyConchLock(pFile, myHostID, SHARED_LOCK);
31194 pFile->lastErrno = conchFile->lastErrno;
31264 rc = proxyConchLock(pFile, myHostID, EXCLUSIVE_LOCK);
31289 int err = osFstat(pFile->h, &buf);
31318 OSTRACE(("TRANSPROXY: CLOSE %d\n", pFile->h));
31319 if( rc==SQLITE_OK && pFile->openFlags ){
31321 if( pFile->h>=0 ){
31322 robust_close(pFile, pFile->h, __LINE__);
31324 pFile->h = -1;
31325 fd = robust_open(pCtx->dbPath, pFile->openFlags, 0);
31328 pFile->h = fd;
31379 static int proxyReleaseConch(unixFile *pFile){
31384 pCtx = (proxyLockingContext *)pFile->lockingContext;
31446 static int switchLockProxyPath(unixFile *pFile, const char *path) {
31447 proxyLockingContext *pCtx = (proxyLockingContext*)pFile->lockingContext;
31451 if( pFile->eFileLock!=NO_LOCK ){
31482 static int proxyGetDbPathForUnixFile(unixFile *pFile, char *dbPath){
31484 if( pFile->pMethod == &afpIoMethods ){
31487 assert( (int)strlen((char*)pFile->lockingContext)<=MAXPATHLEN );
31488 strlcpy(dbPath, ((afpLockingContext *)pFile->lockingContext)->dbPath, MAXPATHLEN);
31491 if( pFile->pMethod == &dotlockIoMethods ){
31494 int len = strlen((char *)pFile->lockingContext) - strlen(DOTLOCK_SUFFIX);
31495 memcpy(dbPath, (char *)pFile->lockingContext, len + 1);
31498 assert( strlen((char*)pFile->lockingContext)<=MAXPATHLEN );
31499 strlcpy(dbPath, (char *)pFile->lockingContext, MAXPATHLEN);
31512 static int proxyTransformUnixFile(unixFile *pFile, const char *path) {
31518 if( pFile->eFileLock!=NO_LOCK ){
31521 proxyGetDbPathForUnixFile(pFile, dbPath);
31528 OSTRACE(("TRANSPROXY %d for %s pid=%d\n", pFile->h,
31540 if( rc==SQLITE_CANTOPEN && ((pFile->openFlags&O_RDWR) == 0) ){
31576 pCtx->oldLockingContext = pFile->lockingContext;
31577 pFile->lockingContext = pCtx;
31578 pCtx->pOldMethod = pFile->pMethod;
31579 pFile->pMethod = &proxyIoMethods;
31589 OSTRACE(("TRANSPROXY %d %s\n", pFile->h,
31602 unixFile *pFile = (unixFile*)id;
31603 if( pFile->pMethod == &proxyIoMethods ){
31604 proxyLockingContext *pCtx = (proxyLockingContext*)pFile->lockingContext;
31605 proxyTakeConch(pFile);
31617 unixFile *pFile = (unixFile*)id;
31619 int isProxyStyle = (pFile->pMethod == &proxyIoMethods);
31632 (proxyLockingContext*)pFile->lockingContext;
31639 rc = switchLockProxyPath(pFile, proxyPath);
31643 rc = proxyTransformUnixFile(pFile, proxyPath);
31670 unixFile *pFile = (unixFile*)id;
31671 int rc = proxyTakeConch(pFile);
31673 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
31709 unixFile *pFile = (unixFile*)id;
31710 int rc = proxyTakeConch(pFile);
31712 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
31716 pFile->eFileLock = proxy->eFileLock;
31733 unixFile *pFile = (unixFile*)id;
31734 int rc = proxyTakeConch(pFile);
31736 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
31740 pFile->eFileLock = proxy->eFileLock;
31753 unixFile *pFile = (unixFile*)id;
31754 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
31769 rc = proxyReleaseConch(pFile);
31780 pFile->lockingContext = pCtx->oldLockingContext;
31781 pFile->pMethod = pCtx->pOldMethod;
31783 return pFile->pMethod->xClose(id);
33390 static BOOL winceCreateLock(const char *zFilename, winFile *pFile){
33402 memset(&pFile->local, 0, sizeof(pFile->local));
33412 pFile->hMutex = osCreateMutexW(NULL, FALSE, zName);
33413 if (!pFile->hMutex){
33414 pFile->lastErrno = osGetLastError();
33415 winLogError(SQLITE_ERROR, pFile->lastErrno, "winceCreateLock1", zFilename);
33421 winceMutexAcquire(pFile->hMutex);
33428 pFile->hShared = osCreateFileMappingW(INVALID_HANDLE_VALUE, NULL,
33441 if (pFile->hShared){
33442 pFile->shared = (winceLock*)osMapViewOfFile(pFile->hShared,
33445 if (!pFile->shared){
33446 pFile->lastErrno = osGetLastError();
33447 winLogError(SQLITE_ERROR, pFile->lastErrno,
33449 osCloseHandle(pFile->hShared);
33450 pFile->hShared = NULL;
33455 if (pFile->hShared == NULL){
33456 winceMutexRelease(pFile->hMutex);
33457 osCloseHandle(pFile->hMutex);
33458 pFile->hMutex = NULL;
33464 memset(pFile->shared, 0, sizeof(winceLock));
33467 winceMutexRelease(pFile->hMutex);
33474 static void winceDestroyLock(winFile *pFile){
33475 if (pFile->hMutex){
33477 winceMutexAcquire(pFile->hMutex);
33481 if (pFile->local.nReaders){
33482 pFile->shared->nReaders --;
33484 if (pFile->local.bReserved){
33485 pFile->shared->bReserved = FALSE;
33487 if (pFile->local.bPending){
33488 pFile->shared->bPending = FALSE;
33490 if (pFile->local.bExclusive){
33491 pFile->shared->bExclusive = FALSE;
33495 osUnmapViewOfFile(pFile->shared);
33496 osCloseHandle(pFile->hShared);
33499 winceMutexRelease(pFile->hMutex);
33500 osCloseHandle(pFile->hMutex);
33501 pFile->hMutex = NULL;
33515 winFile *pFile = HANDLE_TO_WINFILE(phFile);
33521 if (!pFile->hMutex) return TRUE;
33522 winceMutexAcquire(pFile->hMutex);
33527 if (pFile->shared->nReaders == 0 && pFile->shared->bExclusive == 0){
33528 pFile->shared->bExclusive = TRUE;
33529 pFile->local.bExclusive = TRUE;
33537 if (pFile->shared->bExclusive == 0){
33538 pFile->local.nReaders ++;
33539 if (pFile->local.nReaders == 1){
33540 pFile->shared->nReaders ++;
33549 if (pFile->shared->bPending == 0) {
33550 pFile->shared->bPending = TRUE;
33551 pFile->local.bPending = TRUE;
33558 if (pFile->shared->bReserved == 0) {
33559 pFile->shared->bReserved = TRUE;
33560 pFile->local.bReserved = TRUE;
33565 winceMutexRelease(pFile->hMutex);
33579 winFile *pFile = HANDLE_TO_WINFILE(phFile);
33585 if (!pFile->hMutex) return TRUE;
33586 winceMutexAcquire(pFile->hMutex);
33591 if (pFile->local.bExclusive){
33593 pFile->local.bExclusive = FALSE;
33594 pFile->shared->bExclusive = FALSE;
33599 else if (pFile->local.nReaders){
33601 pFile->local.nReaders --;
33602 if (pFile->local.nReaders == 0)
33604 pFile->shared->nReaders --;
33612 if (pFile->local.bPending){
33613 pFile->local.bPending = FALSE;
33614 pFile->shared->bPending = FALSE;
33620 if (pFile->local.bReserved) {
33621 pFile->local.bReserved = FALSE;
33622 pFile->shared->bReserved = FALSE;
33627 winceMutexRelease(pFile->hMutex);
33676 static int seekWinFile(winFile *pFile, sqlite3_int64 iOffset){
33692 dwRet = osSetFilePointer(pFile->h, lowerBits, &upperBits, FILE_BEGIN);
33696 pFile->lastErrno = lastErrno;
33697 winLogError(SQLITE_IOERR_SEEK, pFile->lastErrno,
33698 "seekWinFile", pFile->zPath);
33718 winFile *pFile = (winFile*)id;
33721 assert( pFile->pShm==0 );
33722 OSTRACE(("CLOSE %d\n", pFile->h));
33724 rc = osCloseHandle(pFile->h);
33729 winceDestroyLock(pFile);
33730 if( pFile->zDeleteOnClose ){
33733 osDeleteFileW(pFile->zDeleteOnClose)==0
33734 && osGetFileAttributesW(pFile->zDeleteOnClose)!=0xffffffff
33739 sqlite3_free(pFile->zDeleteOnClose);
33742 OSTRACE(("CLOSE %d %s\n", pFile->h, rc ? "ok" : "failed"));
33746 "winClose", pFile->zPath);
33760 winFile *pFile = (winFile*)id; /* file handle */
33766 OSTRACE(("READ %d lock=%d\n", pFile->h, pFile->locktype));
33768 if( seekWinFile(pFile, offset) ){
33771 while( !osReadFile(pFile->h, pBuf, amt, &nRead, 0) ){
33774 pFile->lastErrno = lastErrno;
33775 return winLogError(SQLITE_IOERR_READ, pFile->lastErrno,
33776 "winRead", pFile->zPath);
33799 winFile *pFile = (winFile*)id; /* File handle */
33803 assert( pFile );
33807 OSTRACE(("WRITE %d lock=%d\n", pFile->h, pFile->locktype));
33809 rc = seekWinFile(pFile, offset);
33817 if( !osWriteFile(pFile->h, aRem, nRem, &nWrite, 0) ){
33826 pFile->lastErrno = lastErrno;
33832 if( ( pFile->lastErrno==ERROR_HANDLE_DISK_FULL )
33833 || ( pFile->lastErrno==ERROR_DISK_FULL )){
33836 return winLogError(SQLITE_IOERR_WRITE, pFile->lastErrno,
33837 "winWrite", pFile->zPath);
33848 winFile *pFile = (winFile*)id; /* File handle object */
33851 assert( pFile );
33853 OSTRACE(("TRUNCATE %d %lld\n", pFile->h, nByte));
33861 if( pFile->szChunk>0 ){
33862 nByte = ((nByte + pFile->szChunk - 1)/pFile->szChunk) * pFile->szChunk;
33866 if( seekWinFile(pFile, nByte) ){
33867 rc = winLogError(SQLITE_IOERR_TRUNCATE, pFile->lastErrno,
33868 "winTruncate1", pFile->zPath);
33869 }else if( 0==osSetEndOfFile(pFile->h) ){
33870 pFile->lastErrno = osGetLastError();
33871 rc = winLogError(SQLITE_IOERR_TRUNCATE, pFile->lastErrno,
33872 "winTruncate2", pFile->zPath);
33875 OSTRACE(("TRUNCATE %d %lld %s\n", pFile->h, nByte, rc ? "failed" : "ok"));
33904 winFile *pFile = (winFile*)id;
33909 assert( pFile );
33915 OSTRACE(("SYNC %d lock=%d\n", pFile->h, pFile->locktype));
33937 rc = osFlushFileBuffers(pFile->h);
33942 pFile->lastErrno = osGetLastError();
33943 return winLogError(SQLITE_IOERR_FSYNC, pFile->lastErrno,
33944 "winSync", pFile->zPath);
33955 winFile *pFile = (winFile*)id;
33960 lowerBits = osGetFileSize(pFile->h, &upperBits);
33964 pFile->lastErrno = lastErrno;
33965 return winLogError(SQLITE_IOERR_FSTAT, pFile->lastErrno,
33966 "winFileSize", pFile->zPath);
33984 static int getReadLock(winFile *pFile){
33991 res = osLockFileEx(pFile->h, LOCKFILE_FAIL_IMMEDIATELY,
33999 pFile->sharedLockByte = (short)((lk & 0x7fffffff)%(SHARED_SIZE - 1));
34000 res = osLockFile(pFile->h, SHARED_FIRST+pFile->sharedLockByte, 0, 1, 0);
34004 pFile->lastErrno = osGetLastError();
34013 static int unlockReadLock(winFile *pFile){
34017 res = osUnlockFile(pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0);
34022 res = osUnlockFile(pFile->h, SHARED_FIRST + pFile->sharedLockByte, 0, 1, 0);
34026 pFile->lastErrno = lastErrno;
34027 winLogError(SQLITE_IOERR_UNLOCK, pFile->lastErrno,
34028 "unlockReadLock", pFile->zPath);
34064 winFile *pFile = (winFile*)id;
34069 pFile->h, locktype, pFile->locktype, pFile->sharedLockByte));
34075 if( pFile->locktype>=locktype ){
34081 assert( pFile->locktype!=NO_LOCK || locktype==SHARED_LOCK );
34083 assert( locktype!=RESERVED_LOCK || pFile->locktype==SHARED_LOCK );
34089 newLocktype = pFile->locktype;
34090 if( (pFile->locktype==NO_LOCK)
34092 && (pFile->locktype==RESERVED_LOCK))
34095 while( cnt-->0 && (res = osLockFile(pFile->h, PENDING_BYTE, 0, 1, 0))==0 ){
34114 assert( pFile->locktype==NO_LOCK );
34115 res = getReadLock(pFile);
34126 assert( pFile->locktype==SHARED_LOCK );
34127 res = osLockFile(pFile->h, RESERVED_BYTE, 0, 1, 0);
34145 assert( pFile->locktype>=SHARED_LOCK );
34146 res = unlockReadLock(pFile);
34148 res = osLockFile(pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0);
34154 getReadLock(pFile);
34162 osUnlockFile(pFile->h, PENDING_BYTE, 0, 1, 0);
34171 OSTRACE(("LOCK FAILED %d trying for %d but got %d\n", pFile->h,
34173 pFile->lastErrno = lastErrno;
34176 pFile->locktype = (u8)newLocktype;
34187 winFile *pFile = (winFile*)id;
34192 if( pFile->locktype>=RESERVED_LOCK ){
34194 OSTRACE(("TEST WR-LOCK %d %d (local)\n", pFile->h, rc));
34196 rc = osLockFile(pFile->h, RESERVED_BYTE, 0, 1, 0);
34198 osUnlockFile(pFile->h, RESERVED_BYTE, 0, 1, 0);
34201 OSTRACE(("TEST WR-LOCK %d %d (remote)\n", pFile->h, rc));
34220 winFile *pFile = (winFile*)id;
34222 assert( pFile!=0 );
34224 OSTRACE(("UNLOCK %d to %d was %d(%d)\n", pFile->h, locktype,
34225 pFile->locktype, pFile->sharedLockByte));
34226 type = pFile->locktype;
34228 osUnlockFile(pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0);
34229 if( locktype==SHARED_LOCK && !getReadLock(pFile) ){
34233 "winUnlock", pFile->zPath);
34237 osUnlockFile(pFile->h, RESERVED_BYTE, 0, 1, 0);
34240 unlockReadLock(pFile);
34243 osUnlockFile(pFile->h, PENDING_BYTE, 0, 1, 0);
34245 pFile->locktype = (u8)locktype;
34255 static void winModeBit(winFile *pFile, unsigned char mask, int *pArg){
34257 *pArg = (pFile->ctrlFlags & mask)!=0;
34259 pFile->ctrlFlags &= ~mask;
34261 pFile->ctrlFlags |= mask;
34269 winFile *pFile = (winFile*)id;
34272 *(int*)pArg = pFile->locktype;
34276 *(int*)pArg = (int)pFile->lastErrno;
34280 pFile->szChunk = *(int *)pArg;
34284 if( pFile->szChunk>0 ){
34300 winModeBit(pFile, WINFILE_PERSIST_WAL, (int*)pArg);
34304 winModeBit(pFile, WINFILE_PSOW, (int*)pArg);
34476 winShmNode *pFile, /* Apply locks to this open shared-memory segment */
34486 assert( sqlite3_mutex_held(pFile->mutex) || pFile->nRef==0 );
34497 rc = osUnlockFileEx(pFile->hFile.h, 0, nByte, 0, &ovlp);
34499 rc = osLockFileEx(pFile->hFile.h, dwFlags, 0, nByte, 0, &ovlp);
34505 pFile->lastErrno = osGetLastError();
34510 pFile->hFile.h,
34513 pFile->lastErrno));
35138 winFile *pFile = (winFile*)id;
35198 pFile->h = INVALID_HANDLE_VALUE;
35298 pFile->lastErrno = lastErrno;
35299 winLogError(SQLITE_CANTOPEN, pFile->lastErrno, "winOpen", zUtf8Name);
35317 memset(pFile, 0, sizeof(*pFile));
35318 pFile->pMethod = &winIoMethod;
35319 pFile->h = h;
35320 pFile->lastErrno = NO_ERROR;
35321 pFile->pVfs = pVfs;
35322 pFile->pShm = 0;
35323 pFile->zPath = zName;
35325 pFile->ctrlFlags |= WINFILE_PSOW;
35330 && !winceCreateLock(zName, pFile)
35337 pFile->zDeleteOnClose = zConverted;
41849 sqlite3_file *pFile, /* Write the file descriptor here */
41860 rc = sqlite3OsOpen(pPager->pVfs, 0, pFile, vfsFlags, 0);
41861 assert( rc!=SQLITE_OK || isOpen(pFile) );
57946 static int backupTruncateFile(sqlite3_file *pFile, i64 iSize){
57948 int rc = sqlite3OsFileSize(pFile, &iCurrent);
57950 rc = sqlite3OsTruncate(pFile, iSize);
58106 sqlite3_file * const pFile = sqlite3PagerFile(pDestPager);
58110 assert( pFile );
58136 rc = sqlite3OsWrite(pFile, zData, pgszSrc, iOff);
58141 rc = backupTruncateFile(pFile, iSize);
71773 sqlite3_file *pFile; /* File iterator is reading from */
71829 rc = sqlite3OsRead(pIter->pFile, pIter->aAlloc, nRead, pIter->iReadOff);
71844 pIter->pFile, &pIter->aAlloc[nRead], nRead2, pIter->iReadOff+nRead
71865 sqlite3_file *pFile, /* File to write to */
71874 rc = sqlite3OsWrite(pFile, aVarint, nVarint, *piOffset);
71892 sqlite3_file *pFile, /* File to read from */
71900 rc = sqlite3OsRead(pFile, aVarint, 9, iOff);
71925 pIter->pFile = pSorter->pTemp1;
72016 if( p1->pFile==0 ){
72018 }else if( p2->pFile==0 ){
72395 assert( rc!=SQLITE_OK || pSorter->aIter[ pSorter->aTree[1] ].pFile );
72415 assert( pIter->pFile );
72442 *pbEof = (pSorter->aIter[pSorter->aTree[1]].pFile==0);
72462 *pbEof = (pSorter->aIter[pSorter->aTree[1]].pFile==0);
92901 sqlite3_file *pFile = sqlite3PagerFile(pPager);
92902 sqlite3OsFileControlHint(pFile, SQLITE_GET_LOCKPROXYFILE,
92914 sqlite3_file *pFile = sqlite3PagerFile(pPager);
92917 res=sqlite3OsFileControl(pFile, SQLITE_SET_LOCKPROXYFILE,
92920 res=sqlite3OsFileControl(pFile, SQLITE_SET_LOCKPROXYFILE,