Lines Matching refs:pFile
25081 sqlite3_file *pFile,
25092 rc = pVfs->xOpen(pVfs, zPath, pFile, flags & 0x1087f7f, pFlagsOut);
25093 assert( rc==SQLITE_OK || pFile->pMethods==0 );
25179 sqlite3_file *pFile;
25180 pFile = (sqlite3_file *)sqlite3MallocZero(pVfs->szOsFile);
25181 if( pFile ){
25182 rc = sqlite3OsOpen(pVfs, zFile, pFile, flags, pOutFlags);
25184 sqlite3_free(pFile);
25187 *ppFile = pFile;
25196 SQLITE_PRIVATE void sqlite3OsCloseFree(sqlite3_file *pFile){
25197 assert( pFile );
25198 sqlite3OsClose(pFile);
25199 sqlite3_free(pFile);
36227 ** Decode a complete journal file. Allocate space in pFile->aJrnl
36228 ** and store the decoding there. Or leave pFile->aJrnl set to NULL
36238 KVVfsFile *pFile, /* Store decoding in pFile->aJrnl */
36250 sqlite3_free(pFile->aJrnl);
36251 pFile->aJrnl = sqlite3_malloc64( n );
36252 if( pFile->aJrnl==0 ){
36253 pFile->nJrnl = 0;
36256 pFile->nJrnl = n;
36257 n = kvvfsDecode(zTxt+i, pFile->aJrnl, pFile->nJrnl);
36258 if( n<pFile->nJrnl ){
36259 sqlite3_free(pFile->aJrnl);
36260 pFile->aJrnl = 0;
36261 pFile->nJrnl = 0;
36268 static sqlite3_int64 kvvfsReadFileSize(KVVfsFile *pFile){
36271 sqlite3KvvfsMethods.xRead(pFile->zClass, "sz", zData, sizeof(zData)-1);
36274 static int kvvfsWriteFileSize(KVVfsFile *pFile, sqlite3_int64 sz){
36277 return sqlite3KvvfsMethods.xWrite(pFile->zClass, "sz", zData);
36286 KVVfsFile *pFile = (KVVfsFile *)pProtoFile;
36288 SQLITE_KV_LOG(("xClose %s %s\n", pFile->zClass,
36289 pFile->isJournal ? "journal" : "db"));
36290 sqlite3_free(pFile->aJrnl);
36303 KVVfsFile *pFile = (KVVfsFile*)pProtoFile;
36304 assert( pFile->isJournal );
36305 SQLITE_KV_LOG(("xRead('%s-journal',%d,%lld)\n", pFile->zClass, iAmt, iOfst));
36306 if( pFile->aJrnl==0 ){
36307 int szTxt = kvstorageRead(pFile->zClass, "jrnl", 0, 0);
36314 kvstorageRead(pFile->zClass, "jrnl", aTxt, szTxt+1);
36315 kvvfsDecodeJournal(pFile, aTxt, szTxt);
36317 if( pFile->aJrnl==0 ) return SQLITE_IOERR;
36319 if( iOfst+iAmt>pFile->nJrnl ){
36322 memcpy(zBuf, pFile->aJrnl+iOfst, iAmt);
36335 KVVfsFile *pFile = (KVVfsFile*)pProtoFile;
36342 SQLITE_KV_LOG(("xRead('%s-db',%d,%lld)\n", pFile->zClass, iAmt, iOfst));
36350 pFile->szPage = iAmt;
36356 got = sqlite3KvvfsMethods.xRead(pFile->zClass, zKey, aData, sizeof(aData)-1);
36392 KVVfsFile *pFile = (KVVfsFile*)pProtoFile;
36394 SQLITE_KV_LOG(("xWrite('%s-journal',%d,%lld)\n", pFile->zClass, iAmt, iOfst));
36396 if( pFile->aJrnl==0 || pFile->nJrnl<iEnd ){
36397 char *aNew = sqlite3_realloc(pFile->aJrnl, iEnd);
36401 pFile->aJrnl = aNew;
36402 if( pFile->nJrnl<iOfst ){
36403 memset(pFile->aJrnl+pFile->nJrnl, 0, iOfst-pFile->nJrnl);
36405 pFile->nJrnl = iEnd;
36407 memcpy(pFile->aJrnl+iOfst, zBuf, iAmt);
36420 KVVfsFile *pFile = (KVVfsFile*)pProtoFile;
36424 SQLITE_KV_LOG(("xWrite('%s-db',%d,%lld)\n", pFile->zClass, iAmt, iOfst));
36427 assert( pFile->szPage<0 || pFile->szPage==iAmt );
36428 pFile->szPage = iAmt;
36432 if( sqlite3KvvfsMethods.xWrite(pFile->zClass, zKey, aData) ){
36435 if( iOfst+iAmt > pFile->szDb ){
36436 pFile->szDb = iOfst + iAmt;
36445 KVVfsFile *pFile = (KVVfsFile *)pProtoFile;
36446 SQLITE_KV_LOG(("xTruncate('%s-journal',%lld)\n", pFile->zClass, size));
36448 sqlite3KvvfsMethods.xDelete(pFile->zClass, "jrnl");
36449 sqlite3_free(pFile->aJrnl);
36450 pFile->aJrnl = 0;
36451 pFile->nJrnl = 0;
36455 KVVfsFile *pFile = (KVVfsFile *)pProtoFile;
36456 if( pFile->szDb>size
36457 && pFile->szPage>0
36458 && (size % pFile->szPage)==0
36462 SQLITE_KV_LOG(("xTruncate('%s-db',%lld)\n", pFile->zClass, size));
36463 pgno = 1 + size/pFile->szPage;
36464 pgnoMax = 2 + pFile->szDb/pFile->szPage;
36467 sqlite3KvvfsMethods.xDelete(pFile->zClass, zKey);
36470 pFile->szDb = size;
36471 return kvvfsWriteFileSize(pFile, size) ? SQLITE_IOERR : SQLITE_OK;
36481 KVVfsFile *pFile = (KVVfsFile *)pProtoFile;
36483 SQLITE_KV_LOG(("xSync('%s-journal')\n", pFile->zClass));
36484 if( pFile->nJrnl<=0 ){
36487 zOut = sqlite3_malloc64( pFile->nJrnl*2 + 50 );
36491 n = pFile->nJrnl;
36498 kvvfsEncode(pFile->aJrnl, pFile->nJrnl, &zOut[i]);
36499 i = sqlite3KvvfsMethods.xWrite(pFile->zClass, "jrnl", zOut);
36511 KVVfsFile *pFile = (KVVfsFile *)pProtoFile;
36512 SQLITE_KV_LOG(("xFileSize('%s-journal')\n", pFile->zClass));
36513 *pSize = pFile->nJrnl;
36517 KVVfsFile *pFile = (KVVfsFile *)pProtoFile;
36518 SQLITE_KV_LOG(("xFileSize('%s-db')\n", pFile->zClass));
36519 if( pFile->szDb>=0 ){
36520 *pSize = pFile->szDb;
36522 *pSize = kvvfsReadFileSize(pFile);
36531 KVVfsFile *pFile = (KVVfsFile *)pProtoFile;
36532 assert( !pFile->isJournal );
36533 SQLITE_KV_LOG(("xLock(%s,%d)\n", pFile->zClass, eLock));
36536 pFile->szDb = kvvfsReadFileSize(pFile);
36545 KVVfsFile *pFile = (KVVfsFile *)pProtoFile;
36546 assert( !pFile->isJournal );
36547 SQLITE_KV_LOG(("xUnlock(%s,%d)\n", pFile->zClass, eLock));
36549 pFile->szDb = -1;
36573 KVVfsFile *pFile = (KVVfsFile *)pProtoFile;
36575 SQLITE_KV_LOG(("xSync('%s-db')\n", pFile->zClass));
36576 if( pFile->szDb>0 && 0!=kvvfsWriteFileSize(pFile, pFile->szDb) ){
36587 static int kvvfsSectorSize(sqlite3_file *pFile){
36610 KVVfsFile *pFile = (KVVfsFile*)pProtoFile;
36616 pFile->isJournal = 0;
36617 pFile->base.pMethods = &kvvfs_db_io_methods;
36622 pFile->isJournal = 1;
36623 pFile->base.pMethods = &kvvfs_jrnl_io_methods;
36628 pFile->zClass = "session";
36630 pFile->zClass = "local";
36632 pFile->aJrnl = 0;
36633 pFile->nJrnl = 0;
36634 pFile->szPage = -1;
36635 pFile->szDb = -1;
38013 int unixFileMutexHeld(unixFile *pFile){
38014 assert( pFile->pInode );
38015 return sqlite3_mutex_held(pFile->pInode->pLockMutex);
38017 int unixFileMutexNotheld(unixFile *pFile){
38018 assert( pFile->pInode );
38019 return sqlite3_mutex_notheld(pFile->pInode->pLockMutex);
38105 static void robust_close(unixFile *pFile, int h, int lineno){
38108 pFile ? pFile->zPath : 0, lineno);
38113 ** Set the pFile->lastErrno. Do this in a subroutine as that provides
38116 static void storeLastErrno(unixFile *pFile, int error){
38117 pFile->lastErrno = error;
38123 static void closePendingFds(unixFile *pFile){
38124 unixInodeInfo *pInode = pFile->pInode;
38127 assert( unixFileMutexHeld(pFile) );
38130 robust_close(pFile, p->fd, __LINE__);
38142 static void releaseInodeInfo(unixFile *pFile){
38143 unixInodeInfo *pInode = pFile->pInode;
38145 assert( unixFileMutexNotheld(pFile) );
38151 closePendingFds(pFile);
38180 unixFile *pFile, /* Unix file with file desc used in the key */
38184 int fd; /* The file descriptor for pFile */
38194 fd = pFile->h;
38197 storeLastErrno(pFile, errno);
38199 if( pFile->lastErrno==EOVERFLOW ) return SQLITE_NOLFS;
38218 if( statbuf.st_size==0 && (pFile->fsFlags & SQLITE_FSFLAGS_IS_MSDOS)!=0 ){
38221 storeLastErrno(pFile, errno);
38229 storeLastErrno(pFile, errno);
38241 fileId.pId = pFile->pId;
38278 ** Return TRUE if pFile has been renamed or unlinked since it was first opened.
38280 static int fileHasMoved(unixFile *pFile){
38282 return pFile->pInode!=0 && pFile->pId!=pFile->pInode->fileId.pId;
38285 return pFile->pInode!=0 &&
38286 (osStat(pFile->zPath, &buf)!=0
38287 || (u64)buf.st_ino!=pFile->pInode->fileId.ino);
38301 static void verifyDbFile(unixFile *pFile){
38306 if( pFile->ctrlFlags & UNIXFILE_NOLOCK ) return;
38308 rc = osFstat(pFile->h, &buf);
38310 sqlite3_log(SQLITE_WARNING, "cannot fstat db file %s", pFile->zPath);
38314 sqlite3_log(SQLITE_WARNING, "file unlinked while open: %s", pFile->zPath);
38318 sqlite3_log(SQLITE_WARNING, "multiple links to file: %s", pFile->zPath);
38321 if( fileHasMoved(pFile) ){
38322 sqlite3_log(SQLITE_WARNING, "file renamed while open: %s", pFile->zPath);
38337 unixFile *pFile = (unixFile*)id;
38341 assert( pFile );
38342 assert( pFile->eFileLock<=SHARED_LOCK );
38343 sqlite3_mutex_enter(pFile->pInode->pLockMutex);
38346 if( pFile->pInode->eFileLock>SHARED_LOCK ){
38353 if( !reserved && !pFile->pInode->bProcessLock ){
38359 if( osFcntl(pFile->h, F_GETLK, &lock) ){
38361 storeLastErrno(pFile, errno);
38368 sqlite3_mutex_leave(pFile->pInode->pLockMutex);
38369 OSTRACE(("TEST WR-LOCK %d %d %d (unix)\n", pFile->h, rc, reserved));
38397 unixFile *pFile /* Structure holding timeout value */
38399 int tm = pFile->iBusyTimeout;
38417 ** Attempt to set a system-lock on the file pFile. The lock is
38420 ** If the pFile was opened read/write from unix-excl, then the only lock
38428 ** This function is a pass-through to fcntl(F_SETLK) if pFile is using
38429 ** any VFS other than "unix-excl" or if pFile is opened on "unix-excl"
38435 static int unixFileLock(unixFile *pFile, struct flock *pLock){
38437 unixInodeInfo *pInode = pFile->pInode;
38440 if( (pFile->ctrlFlags & (UNIXFILE_EXCL|UNIXFILE_RDONLY))==UNIXFILE_EXCL ){
38448 rc = osSetPosixAdvisoryLock(pFile->h, &lock, pFile);
38456 rc = osSetPosixAdvisoryLock(pFile->h, pLock, pFile);
38526 unixFile *pFile = (unixFile*)id;
38531 assert( pFile );
38532 OSTRACE(("LOCK %d %s was %s(%s,%d) pid=%d (unix)\n", pFile->h,
38533 azFileLock(eFileLock), azFileLock(pFile->eFileLock),
38534 azFileLock(pFile->pInode->eFileLock), pFile->pInode->nShared,
38541 if( pFile->eFileLock>=eFileLock ){
38542 OSTRACE(("LOCK %d %s ok (already held) (unix)\n", pFile->h,
38552 assert( pFile->eFileLock!=NO_LOCK || eFileLock==SHARED_LOCK );
38554 assert( eFileLock!=RESERVED_LOCK || pFile->eFileLock==SHARED_LOCK );
38556 /* This mutex is needed because pFile->pInode is shared across threads
38558 pInode = pFile->pInode;
38564 if( (pFile->eFileLock!=pInode->eFileLock &&
38578 assert( pFile->eFileLock==0 );
38580 pFile->eFileLock = SHARED_LOCK;
38594 || (eFileLock==EXCLUSIVE_LOCK && pFile->eFileLock<PENDING_LOCK)
38598 if( unixFileLock(pFile, &lock) ){
38602 storeLastErrno(pFile, tErrno);
38620 if( unixFileLock(pFile, &lock) ){
38629 if( unixFileLock(pFile, &lock) && rc==SQLITE_OK ){
38637 storeLastErrno(pFile, tErrno);
38641 pFile->eFileLock = SHARED_LOCK;
38654 assert( 0!=pFile->eFileLock );
38666 if( unixFileLock(pFile, &lock) ){
38670 storeLastErrno(pFile, tErrno);
38683 && pFile->eFileLock<=SHARED_LOCK
38686 pFile->transCntrChng = 0;
38687 pFile->dbUpdate = 0;
38688 pFile->inNormalWrite = 1;
38694 pFile->eFileLock = eFileLock;
38697 pFile->eFileLock = PENDING_LOCK;
38703 OSTRACE(("LOCK %d %s %s (unix)\n", pFile->h, azFileLock(eFileLock),
38709 ** Add the file descriptor used by file handle pFile to the corresponding
38712 static void setPendingFd(unixFile *pFile){
38713 unixInodeInfo *pInode = pFile->pInode;
38714 UnixUnusedFd *p = pFile->pPreallocatedUnused;
38715 assert( unixFileMutexHeld(pFile) );
38718 pFile->h = -1;
38719 pFile->pPreallocatedUnused = 0;
38723 ** Lower the locking level on file descriptor pFile to eFileLock. eFileLock
38736 unixFile *pFile = (unixFile*)id;
38741 assert( pFile );
38742 OSTRACE(("UNLOCK %d %d was %d(%d,%d) pid=%d (unix)\n", pFile->h, eFileLock,
38743 pFile->eFileLock, pFile->pInode->eFileLock, pFile->pInode->nShared,
38747 if( pFile->eFileLock<=eFileLock ){
38750 pInode = pFile->pInode;
38753 if( pFile->eFileLock>SHARED_LOCK ){
38754 assert( pInode->eFileLock==pFile->eFileLock );
38765 pFile->inNormalWrite = 0;
38791 if( unixFileLock(pFile, &lock)==(-1) ){
38794 storeLastErrno(pFile, tErrno);
38801 if( unixFileLock(pFile, &lock)==(-1) ){
38805 storeLastErrno(pFile, tErrno);
38813 if( unixFileLock(pFile, &lock)==(-1) ){
38816 storeLastErrno(pFile, tErrno);
38826 if( unixFileLock(pFile, &lock) ){
38834 storeLastErrno(pFile, errno);
38843 if( unixFileLock(pFile, &lock)==0 ){
38847 storeLastErrno(pFile, errno);
38861 if( unixFileLock(pFile, &lock)==0 ){
38865 storeLastErrno(pFile, errno);
38867 pFile->eFileLock = NO_LOCK;
38877 if( pInode->nLock==0 ) closePendingFds(pFile);
38883 pFile->eFileLock = eFileLock;
38889 ** Lower the locking level on file descriptor pFile to eFileLock. eFileLock
38918 unixFile *pFile = (unixFile*)id;
38920 unixUnmapfile(pFile);
38922 if( pFile->h>=0 ){
38923 robust_close(pFile, pFile->h, __LINE__);
38924 pFile->h = -1;
38927 if( pFile->pId ){
38928 if( pFile->ctrlFlags & UNIXFILE_DELETE ){
38929 osUnlink(pFile->pId->zCanonicalName);
38931 vxworksReleaseFileId(pFile->pId);
38932 pFile->pId = 0;
38936 if( pFile->ctrlFlags & UNIXFILE_DELETE ){
38937 osUnlink(pFile->zPath);
38938 sqlite3_free(*(char**)&pFile->zPath);
38939 pFile->zPath = 0;
38942 OSTRACE(("CLOSE %-3d\n", pFile->h));
38944 sqlite3_free(pFile->pPreallocatedUnused);
38945 memset(pFile, 0, sizeof(unixFile));
38954 unixFile *pFile = (unixFile *)id;
38955 unixInodeInfo *pInode = pFile->pInode;
38958 verifyDbFile(pFile);
38960 assert( unixFileMutexNotheld(pFile) );
38966 assert( pFile->pInode->nLock>0 || pFile->pInode->bProcessLock==0 );
38974 setPendingFd(pFile);
38977 releaseInodeInfo(pFile);
38978 assert( pFile->pShm==0 );
39069 unixFile *pFile = (unixFile*)id;
39073 assert( pFile );
39074 reserved = osAccess((const char*)pFile->lockingContext, 0)==0;
39075 OSTRACE(("TEST WR-LOCK %d %d %d (dotlock)\n", pFile->h, rc, reserved));
39108 unixFile *pFile = (unixFile*)id;
39109 char *zLockFile = (char *)pFile->lockingContext;
39116 if( pFile->eFileLock > NO_LOCK ){
39117 pFile->eFileLock = eFileLock;
39137 storeLastErrno(pFile, tErrno);
39144 pFile->eFileLock = eFileLock;
39149 ** Lower the locking level on file descriptor pFile to eFileLock. eFileLock
39158 unixFile *pFile = (unixFile*)id;
39159 char *zLockFile = (char *)pFile->lockingContext;
39162 assert( pFile );
39163 OSTRACE(("UNLOCK %d %d was %d pid=%d (dotlock)\n", pFile->h, eFileLock,
39164 pFile->eFileLock, osGetpid(0)));
39168 if( pFile->eFileLock==eFileLock ){
39176 pFile->eFileLock = SHARED_LOCK;
39189 storeLastErrno(pFile, tErrno);
39193 pFile->eFileLock = NO_LOCK;
39201 unixFile *pFile = (unixFile*)id;
39204 sqlite3_free(pFile->lockingContext);
39249 unixFile *pFile = (unixFile*)id;
39253 assert( pFile );
39256 if( pFile->eFileLock>SHARED_LOCK ){
39263 int lrc = robust_flock(pFile->h, LOCK_EX | LOCK_NB);
39266 lrc = robust_flock(pFile->h, LOCK_UN);
39271 storeLastErrno(pFile, tErrno);
39280 storeLastErrno(pFile, tErrno);
39285 OSTRACE(("TEST WR-LOCK %d %d %d (flock)\n", pFile->h, rc, reserved));
39328 unixFile *pFile = (unixFile*)id;
39330 assert( pFile );
39334 if (pFile->eFileLock > NO_LOCK) {
39335 pFile->eFileLock = eFileLock;
39341 if (robust_flock(pFile->h, LOCK_EX | LOCK_NB)) {
39346 storeLastErrno(pFile, tErrno);
39350 pFile->eFileLock = eFileLock;
39352 OSTRACE(("LOCK %d %s %s (flock)\n", pFile->h, azFileLock(eFileLock),
39364 ** Lower the locking level on file descriptor pFile to eFileLock. eFileLock
39371 unixFile *pFile = (unixFile*)id;
39373 assert( pFile );
39374 OSTRACE(("UNLOCK %d %d was %d pid=%d (flock)\n", pFile->h, eFileLock,
39375 pFile->eFileLock, osGetpid(0)));
39379 if( pFile->eFileLock==eFileLock ){
39385 pFile->eFileLock = eFileLock;
39390 if( robust_flock(pFile->h, LOCK_UN) ){
39395 sqlite3_log(SQLITE_IOERR_UNLOCK, "IOERR_UNLOCK fd[%d], eFileLock[%d]", pFile->h, eFileLock);
39399 pFile->eFileLock = NO_LOCK;
39439 unixFile *pFile = (unixFile*)id;
39443 assert( pFile );
39446 if( pFile->eFileLock>SHARED_LOCK ){
39452 sem_t *pSem = pFile->pInode->pSem;
39458 storeLastErrno(pFile, tErrno);
39461 reserved = (pFile->eFileLock < SHARED_LOCK);
39468 OSTRACE(("TEST WR-LOCK %d %d %d (sem)\n", pFile->h, rc, reserved));
39504 unixFile *pFile = (unixFile*)id;
39505 sem_t *pSem = pFile->pInode->pSem;
39510 if (pFile->eFileLock > NO_LOCK) {
39511 pFile->eFileLock = eFileLock;
39523 pFile->eFileLock = eFileLock;
39530 ** Lower the locking level on file descriptor pFile to eFileLock. eFileLock
39537 unixFile *pFile = (unixFile*)id;
39538 sem_t *pSem = pFile->pInode->pSem;
39540 assert( pFile );
39542 OSTRACE(("UNLOCK %d %d was %d pid=%d (sem)\n", pFile->h, eFileLock,
39543 pFile->eFileLock, osGetpid(0)));
39547 if( pFile->eFileLock==eFileLock ){
39553 pFile->eFileLock = eFileLock;
39562 storeLastErrno(pFile, tErrno);
39566 pFile->eFileLock = NO_LOCK;
39575 unixFile *pFile = (unixFile*)id;
39577 assert( pFile );
39578 assert( unixFileMutexNotheld(pFile) );
39580 releaseInodeInfo(pFile);
39635 unixFile *pFile, /* Open file descriptor on path */
39647 pb.fd = pFile->h;
39650 (setLockFlag?"ON":"OFF"), pFile->h, (pb.fd==-1?"[testval-1]":""),
39665 storeLastErrno(pFile, tErrno);
39682 unixFile *pFile = (unixFile*)id;
39687 assert( pFile );
39688 context = (afpLockingContext *) pFile->lockingContext;
39693 sqlite3_mutex_enter(pFile->pInode->pLockMutex);
39695 if( pFile->pInode->eFileLock>SHARED_LOCK ){
39703 int lrc = afpSetLock(context->dbPath, pFile, RESERVED_BYTE, 1,1);
39707 lrc = afpSetLock(context->dbPath, pFile, RESERVED_BYTE, 1, 0);
39717 sqlite3_mutex_leave(pFile->pInode->pLockMutex);
39718 OSTRACE(("TEST WR-LOCK %d %d %d (afp)\n", pFile->h, rc, reserved));
39750 unixFile *pFile = (unixFile*)id;
39751 unixInodeInfo *pInode = pFile->pInode;
39752 afpLockingContext *context = (afpLockingContext *) pFile->lockingContext;
39754 assert( pFile );
39755 OSTRACE(("LOCK %d %s was %s(%s,%d) pid=%d (afp)\n", pFile->h,
39756 azFileLock(eFileLock), azFileLock(pFile->eFileLock),
39763 if( pFile->eFileLock>=eFileLock ){
39764 OSTRACE(("LOCK %d %s ok (already held) (afp)\n", pFile->h,
39774 assert( pFile->eFileLock!=NO_LOCK || eFileLock==SHARED_LOCK );
39776 assert( eFileLock!=RESERVED_LOCK || pFile->eFileLock==SHARED_LOCK );
39778 /* This mutex is needed because pFile->pInode is shared across threads
39780 pInode = pFile->pInode;
39786 if( (pFile->eFileLock!=pInode->eFileLock &&
39800 assert( pFile->eFileLock==0 );
39802 pFile->eFileLock = SHARED_LOCK;
39813 || (eFileLock==EXCLUSIVE_LOCK && pFile->eFileLock<PENDING_LOCK)
39816 failed = afpSetLock(context->dbPath, pFile, PENDING_BYTE, 1, 1);
39838 lrc1 = afpSetLock(context->dbPath, pFile,
39841 lrc1Errno = pFile->lastErrno;
39844 lrc2 = afpSetLock(context->dbPath, pFile, PENDING_BYTE, 1, 0);
39847 storeLastErrno(pFile, lrc1Errno);
39856 pFile->eFileLock = SHARED_LOCK;
39870 assert( 0!=pFile->eFileLock );
39871 if (eFileLock >= RESERVED_LOCK && pFile->eFileLock < RESERVED_LOCK) {
39873 failed = afpSetLock(context->dbPath, pFile, RESERVED_BYTE, 1,1);
39884 if( !(failed = afpSetLock(context->dbPath, pFile, SHARED_FIRST +
39888 failed = afpSetLock(context->dbPath, pFile, SHARED_FIRST,
39890 if( failed && (failed2 = afpSetLock(context->dbPath, pFile,
39909 pFile->eFileLock = eFileLock;
39912 pFile->eFileLock = PENDING_LOCK;
39918 OSTRACE(("LOCK %d %s %s (afp)\n", pFile->h, azFileLock(eFileLock),
39924 ** Lower the locking level on file descriptor pFile to eFileLock. eFileLock
39932 unixFile *pFile = (unixFile*)id;
39934 afpLockingContext *context = (afpLockingContext *) pFile->lockingContext;
39937 int h = pFile->h;
39940 assert( pFile );
39941 OSTRACE(("UNLOCK %d %d was %d(%d,%d) pid=%d (afp)\n", pFile->h, eFileLock,
39942 pFile->eFileLock, pFile->pInode->eFileLock, pFile->pInode->nShared,
39946 if( pFile->eFileLock<=eFileLock ){
39949 pInode = pFile->pInode;
39952 if( pFile->eFileLock>SHARED_LOCK ){
39953 assert( pInode->eFileLock==pFile->eFileLock );
39967 assert( pFile->inNormalWrite==0
39968 || pFile->dbUpdate==0
39969 || pFile->transCntrChng==1 );
39970 pFile->inNormalWrite = 0;
39973 if( pFile->eFileLock==EXCLUSIVE_LOCK ){
39974 rc = afpSetLock(context->dbPath, pFile, SHARED_FIRST, SHARED_SIZE, 0);
39978 rc = afpSetLock(context->dbPath, pFile, sharedLockByte, 1, 1);
39983 if( rc==SQLITE_OK && pFile->eFileLock>=PENDING_LOCK ){
39984 rc = afpSetLock(context->dbPath, pFile, PENDING_BYTE, 1, 0);
39986 if( rc==SQLITE_OK && pFile->eFileLock>=RESERVED_LOCK && context->reserved ){
39987 rc = afpSetLock(context->dbPath, pFile, RESERVED_BYTE, 1, 0);
40009 rc = afpSetLock(context->dbPath, pFile, sharedLockByte, 1, 0);
40013 pFile->eFileLock = NO_LOCK;
40019 if( pInode->nLock==0 ) closePendingFds(pFile);
40025 pFile->eFileLock = eFileLock;
40035 unixFile *pFile = (unixFile*)id;
40038 assert( unixFileMutexNotheld(pFile) );
40040 if( pFile->pInode ){
40041 unixInodeInfo *pInode = pFile->pInode;
40049 setPendingFd(pFile);
40053 releaseInodeInfo(pFile);
40054 sqlite3_free(pFile->lockingContext);
40075 ** Lower the locking level on file descriptor pFile to eFileLock. eFileLock
40172 unixFile *pFile = (unixFile *)id;
40181 assert( pFile->pPreallocatedUnused==0
40190 if( offset<pFile->mmapSize ){
40191 if( offset+amt <= pFile->mmapSize ){
40192 memcpy(pBuf, &((u8 *)(pFile->pMapRegion))[offset], amt);
40195 int nCopy = pFile->mmapSize - offset;
40196 memcpy(pBuf, &((u8 *)(pFile->pMapRegion))[offset], nCopy);
40204 got = seekAndRead(pFile, offset, pBuf, amt);
40208 /* pFile->lastErrno has been set by seekAndRead().
40215 switch( pFile->lastErrno ){
40225 sqlite3_log(SQLITE_IOERR_CORRUPTFS, "unixRead-EDEVERR, fd:[%d], amt[%d], got[%d], offset[%lld]", pFile->h, amt, got, offset);
40230 sqlite3_log(SQLITE_IOERR_READ, "unixRead-got<0, fd: [%d], amt[%d], got[%d], offset[%lld]", pFile->h, amt, got, offset);
40234 storeLastErrno(pFile, 0); /* not a system error */
40309 unixFile *pFile = (unixFile*)id;
40317 assert( pFile->pPreallocatedUnused==0
40330 if( pFile->inNormalWrite ){
40331 pFile->dbUpdate = 1; /* The database has been modified */
40336 rc = seekAndRead(pFile, 24, oldCntr, 4);
40339 pFile->transCntrChng = 1; /* The transaction counter has changed */
40348 if( offset<pFile->mmapSize ){
40349 if( offset+amt <= pFile->mmapSize ){
40350 memcpy(&((u8 *)(pFile->pMapRegion))[offset], pBuf, amt);
40353 int nCopy = pFile->mmapSize - offset;
40354 memcpy(&((u8 *)(pFile->pMapRegion))[offset], pBuf, nCopy);
40362 while( (wrote = seekAndWrite(pFile, offset, pBuf, amt))<amt && wrote>0 ){
40371 if( wrote<0 && pFile->lastErrno!=ENOSPC ){
40376 pFile->h,
40380 pFile->lastErrno);
40384 storeLastErrno(pFile, 0); /* not a system error */
40388 pFile->h,
40392 pFile->lastErrno);
40591 unixFile *pFile = (unixFile*)id;
40606 assert( pFile );
40607 OSTRACE(("SYNC %-3d\n", pFile->h));
40608 rc = full_fsync(pFile->h, isFullsync, isDataOnly);
40611 storeLastErrno(pFile, errno);
40612 return unixLogError(SQLITE_IOERR_FSYNC, "full_fsync", pFile->zPath);
40619 if( pFile->ctrlFlags & UNIXFILE_DIRSYNC ){
40621 OSTRACE(("DIRSYNC %s (have_fullfsync=%d fullsync=%d)\n", pFile->zPath,
40623 rc = osOpenDirectory(pFile->zPath, &dirfd);
40626 robust_close(pFile, dirfd, __LINE__);
40631 pFile->ctrlFlags &= ~UNIXFILE_DIRSYNC;
40640 unixFile *pFile = (unixFile *)id;
40642 assert( pFile );
40650 if( pFile->szChunk>0 ){
40651 nByte = ((nByte + pFile->szChunk - 1)/pFile->szChunk) * pFile->szChunk;
40654 rc = robust_ftruncate(pFile->h, nByte);
40656 storeLastErrno(pFile, errno);
40657 return unixLogError(SQLITE_IOERR_TRUNCATE, "ftruncate", pFile->zPath);
40667 if( pFile->inNormalWrite && nByte==0 ){
40668 pFile->transCntrChng = 1;
40677 if( nByte<pFile->mmapSize ){
40678 pFile->mmapSize = nByte;
40727 static int fcntlSizeHint(unixFile *pFile, i64 nByte){
40728 if( pFile->szChunk>0 ){
40732 if( osFstat(pFile->h, &buf) ){
40736 nSize = ((nByte+pFile->szChunk-1) / pFile->szChunk) * pFile->szChunk;
40745 err = osFallocate(pFile->h, buf.st_size, nSize-buf.st_size);
40751 pFile->h,
40775 nWrite = seekAndWrite(pFile, iWrite, "", 1);
40780 pFile->h,
40794 if( pFile->mmapSizeMax>0 && nByte>pFile->mmapSize ){
40796 if( pFile->szChunk<=0 ){
40797 if( robust_ftruncate(pFile->h, nByte) ){
40798 storeLastErrno(pFile, errno);
40799 return unixLogError(SQLITE_IOERR_TRUNCATE, "ftruncate", pFile->zPath);
40803 rc = unixMapfile(pFile, nByte);
40813 ** 1 or 0 depending on whether or not bit mask of pFile->ctrlFlags is set.
40815 ** If *pArg is 0 or 1, then clear or set the mask bit of pFile->ctrlFlags.
40817 static void unixModeBit(unixFile *pFile, unsigned char mask, int *pArg){
40819 *pArg = (pFile->ctrlFlags & mask)!=0;
40821 pFile->ctrlFlags &= ~mask;
40823 pFile->ctrlFlags |= mask;
40837 unixFile *pFile = (unixFile*)id;
40841 int rc = osIoctl(pFile->h, F2FS_IOC_START_ATOMIC_WRITE);
40844 sqlite3_log(SQLITE_IOERR_BEGIN_ATOMIC, "unixFileControl-begin, fd[%d], op[%d]", pFile->h, op);
40850 int rc = osIoctl(pFile->h, F2FS_IOC_COMMIT_ATOMIC_WRITE);
40853 sqlite3_log(SQLITE_IOERR_COMMIT_ATOMIC, "unixFileControl-commit, fd[%d], op[%d]", pFile->h, op);
40859 int rc = osIoctl(pFile->h, F2FS_IOC_ABORT_VOLATILE_WRITE);
40862 sqlite3_log(SQLITE_IOERR_ROLLBACK_ATOMIC, "unixFileControl-rollback, fd[%d], op[%d]", pFile->h, op);
40870 *(int*)pArg = pFile->eFileLock;
40874 *(int*)pArg = pFile->lastErrno;
40878 pFile->szChunk = *(int *)pArg;
40884 rc = fcntlSizeHint(pFile, *(i64 *)pArg);
40889 unixModeBit(pFile, UNIXFILE_PERSIST_WAL, (int*)pArg);
40893 unixModeBit(pFile, UNIXFILE_PSOW, (int*)pArg);
40897 *(char**)pArg = sqlite3_mprintf("%s", pFile->pVfs->zName);
40901 char *zTFile = sqlite3_malloc64( pFile->pVfs->mxPathname );
40903 unixGetTempname(pFile->pVfs->mxPathname, zTFile);
40909 *(int*)pArg = fileHasMoved(pFile);
40914 int iOld = pFile->iBusyTimeout;
40915 pFile->iBusyTimeout = *(int*)pArg;
40935 *(i64*)pArg = pFile->mmapSizeMax;
40936 if( newLimit>=0 && newLimit!=pFile->mmapSizeMax && pFile->nFetchOut==0 ){
40937 pFile->mmapSizeMax = newLimit;
40938 if( pFile->mmapSize>0 ){
40939 unixUnmapfile(pFile);
40940 rc = unixMapfile(pFile, -1);
41011 static void setDeviceCharacteristics(unixFile *pFile){
41012 if( pFile->sectorSize == 0 ){
41016 pFile->sectorSize = SQLITE_DEFAULT_SECTOR_SIZE;
41017 pFile->deviceCharacteristics = 0;
41018 if( fstatvfs(pFile->h, &fsInfo) == -1 ) {
41023 pFile->sectorSize = fsInfo.f_bsize;
41024 pFile->deviceCharacteristics =
41032 pFile->sectorSize = fsInfo.f_bsize;
41033 pFile->deviceCharacteristics =
41035 (pFile->sectorSize / 512 * SQLITE_IOCAP_ATOMIC512) |
41042 pFile->sectorSize = fsInfo.f_bsize;
41043 pFile->deviceCharacteristics =
41051 pFile->sectorSize = fsInfo.f_bsize;
41052 pFile->deviceCharacteristics =
41054 ((pFile->sectorSize / 512 * SQLITE_IOCAP_ATOMIC512) << 1) - 2 |
41059 pFile->sectorSize = fsInfo.f_bsize;
41060 pFile->deviceCharacteristics =
41062 ((pFile->sectorSize / 512 * SQLITE_IOCAP_ATOMIC512) << 1) - 2 |
41067 pFile->deviceCharacteristics =
41076 if( pFile->sectorSize % 512 != 0 ){
41077 pFile->deviceCharacteristics = 0;
41078 pFile->sectorSize = SQLITE_DEFAULT_SECTOR_SIZE;
41219 ** wal-mode transactions in other processes on database file pFile. If
41225 static int unixFcntlExternalReader(unixFile *pFile, int *piOut){
41228 if( pFile->pShm){
41229 unixShmNode *pShmNode = pFile->pShm->pShmNode;
41258 unixFile *pFile, /* Open connection to the WAL file */
41268 pShmNode = pFile->pInode->pShmNode;
41285 res = osSetPosixAdvisoryLock(pShmNode->hShm, &f, pFile);
41288 rc = (pFile->iBusyTimeout ? SQLITE_BUSY_TIMEOUT : SQLITE_BUSY);
42986 sqlite3_file *pFile, /* The file descriptor to be filled in */
42990 unixFile *p = (unixFile *)pFile;
43200 ((unixFile*)pFile)->fsFlags |= SQLITE_FSFLAGS_IS_MSDOS;
43203 ((unixFile*)pFile)->fsFlags |= SQLITE_FSFLAGS_IS_MSDOS;
43231 rc = fillInUnixFile(pVfs, fd, pFile, zPath, ctrlFlags);
43233 rc = proxyTransformUnixFile((unixFile*)pFile, ":auto:");
43237 ** pFile->pMethods will be NULL so sqlite3OsClose will be a no-op
43239 unixClose(pFile);
43251 rc = fillInUnixFile(pVfs, fd, pFile, zPath, ctrlFlags);
44128 static int proxyBreakConchLock(unixFile *pFile, uuid_t myHostID){
44129 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
44170 robust_close(pFile, conchFile->h, __LINE__);
44178 robust_close(pFile, fd, __LINE__);
44188 static int proxyConchLock(unixFile *pFile, uuid_t myHostID, int lockType){
44189 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
44208 storeLastErrno(pFile, errno);
44210 sqlite3_log(SQLITE_IOERR_LOCK, "proxyConchLock pFile fd[%d], conchFile fd[%d], lastErrno[%d]", pFile->h, conchFile->h, errno);
44231 storeLastErrno(pFile, errno);
44233 sqlite3_log(SQLITE_IOERR_LOCK, "proxyConchLock tries 2, pFile fd[%d], conchFile fd[%d], lastErrno[%d]", pFile->h, conchFile->h, errno);
44251 if( 0==proxyBreakConchLock(pFile, myHostID) ){
44272 static int proxyTakeConch(unixFile *pFile){
44273 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
44297 storeLastErrno(pFile, pError);
44300 rc = proxyConchLock(pFile, myHostID, SHARED_LOCK);
44308 storeLastErrno(pFile, conchFile->lastErrno);
44310 sqlite3_log(SQLITE_IOERR_READ, "proxyTakeConch pFile fd[%d], conchFile fd[%d], lastErrno[%d]", pFile->h, conchFile->h, conchFile->lastErrno);
44381 rc = proxyConchLock(pFile, myHostID, EXCLUSIVE_LOCK);
44384 rc = proxyConchLock(pFile, myHostID, EXCLUSIVE_LOCK);
44407 int err = osFstat(pFile->h, &buf);
44436 OSTRACE(("TRANSPROXY: CLOSE %d\n", pFile->h));
44437 if( rc==SQLITE_OK && pFile->openFlags ){
44439 if( pFile->h>=0 ){
44440 robust_close(pFile, pFile->h, __LINE__);
44442 pFile->h = -1;
44443 fd = robust_open(pCtx->dbPath, pFile->openFlags, 0);
44446 pFile->h = fd;
44495 ** If pFile holds a lock on a conch file, then release that lock.
44497 static int proxyReleaseConch(unixFile *pFile){
44502 pCtx = (proxyLockingContext *)pFile->lockingContext;
44564 static int switchLockProxyPath(unixFile *pFile, const char *path) {
44565 proxyLockingContext *pCtx = (proxyLockingContext*)pFile->lockingContext;
44569 if( pFile->eFileLock!=NO_LOCK ){
44594 ** pFile is a file that has been opened by a prior xOpen call. dbPath
44597 ** This routine find the filename associated with pFile and writes it
44600 static int proxyGetDbPathForUnixFile(unixFile *pFile, char *dbPath){
44602 if( pFile->pMethod == &afpIoMethods ){
44605 assert( (int)strlen((char*)pFile->lockingContext)<=MAXPATHLEN );
44606 strlcpy(dbPath, ((afpLockingContext *)pFile->lockingContext)->dbPath,
44610 if( pFile->pMethod == &dotlockIoMethods ){
44613 int len = strlen((char *)pFile->lockingContext) - strlen(DOTLOCK_SUFFIX);
44614 memcpy(dbPath, (char *)pFile->lockingContext, len + 1);
44617 assert( strlen((char*)pFile->lockingContext)<=MAXPATHLEN );
44618 strlcpy(dbPath, (char *)pFile->lockingContext, MAXPATHLEN);
44631 static int proxyTransformUnixFile(unixFile *pFile, const char *path) {
44637 if( pFile->eFileLock!=NO_LOCK ){
44640 proxyGetDbPathForUnixFile(pFile, dbPath);
44647 OSTRACE(("TRANSPROXY %d for %s pid=%d\n", pFile->h,
44659 if( rc==SQLITE_CANTOPEN && ((pFile->openFlags&O_RDWR) == 0) ){
44695 pCtx->oldLockingContext = pFile->lockingContext;
44696 pFile->lockingContext = pCtx;
44697 pCtx->pOldMethod = pFile->pMethod;
44698 pFile->pMethod = &proxyIoMethods;
44708 OSTRACE(("TRANSPROXY %d %s\n", pFile->h,
44721 unixFile *pFile = (unixFile*)id;
44722 if( pFile->pMethod == &proxyIoMethods ){
44723 proxyLockingContext *pCtx = (proxyLockingContext*)pFile->lockingContext;
44724 proxyTakeConch(pFile);
44736 unixFile *pFile = (unixFile*)id;
44738 int isProxyStyle = (pFile->pMethod == &proxyIoMethods);
44754 (proxyLockingContext*)pFile->lockingContext;
44761 rc = switchLockProxyPath(pFile, proxyPath);
44765 rc = proxyTransformUnixFile(pFile, proxyPath);
44792 unixFile *pFile = (unixFile*)id;
44793 int rc = proxyTakeConch(pFile);
44795 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
44831 unixFile *pFile = (unixFile*)id;
44832 int rc = proxyTakeConch(pFile);
44834 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
44838 pFile->eFileLock = proxy->eFileLock;
44848 ** Lower the locking level on file descriptor pFile to eFileLock. eFileLock
44855 unixFile *pFile = (unixFile*)id;
44856 int rc = proxyTakeConch(pFile);
44858 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
44862 pFile->eFileLock = proxy->eFileLock;
44875 unixFile *pFile = (unixFile*)id;
44876 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
44891 rc = proxyReleaseConch(pFile);
44902 pFile->lockingContext = pCtx->oldLockingContext;
44903 pFile->pMethod = pCtx->pOldMethod;
44905 return pFile->pMethod->xClose(id);
47322 ** descriptor pFile
47324 static int winceCreateLock(const char *zFilename, winFile *pFile){
47338 memset(&pFile->local, 0, sizeof(pFile->local));
47348 pFile->hMutex = osCreateMutexW(NULL, FALSE, zName);
47349 if (!pFile->hMutex){
47350 pFile->lastErrno = osGetLastError();
47352 return winLogError(SQLITE_IOERR, pFile->lastErrno,
47357 winceMutexAcquire(pFile->hMutex);
47364 pFile->hShared = osCreateFileMappingW(INVALID_HANDLE_VALUE, NULL,
47378 if( pFile->hShared ){
47379 pFile->shared = (winceLock*)osMapViewOfFile(pFile->hShared,
47382 if( !pFile->shared ){
47383 pFile->lastErrno = osGetLastError();
47384 winLogError(SQLITE_IOERR, pFile->lastErrno,
47387 osCloseHandle(pFile->hShared);
47388 pFile->hShared = NULL;
47393 if( pFile->hShared==NULL ){
47395 pFile->lastErrno = lastErrno;
47396 winLogError(SQLITE_IOERR, pFile->lastErrno,
47400 winceMutexRelease(pFile->hMutex);
47401 osCloseHandle(pFile->hMutex);
47402 pFile->hMutex = NULL;
47408 memset(pFile->shared, 0, sizeof(winceLock));
47411 winceMutexRelease(pFile->hMutex);
47418 static void winceDestroyLock(winFile *pFile){
47419 if (pFile->hMutex){
47421 winceMutexAcquire(pFile->hMutex);
47425 if (pFile->local.nReaders){
47426 pFile->shared->nReaders --;
47428 if (pFile->local.bReserved){
47429 pFile->shared->bReserved = FALSE;
47431 if (pFile->local.bPending){
47432 pFile->shared->bPending = FALSE;
47434 if (pFile->local.bExclusive){
47435 pFile->shared->bExclusive = FALSE;
47439 osUnmapViewOfFile(pFile->shared);
47440 osCloseHandle(pFile->hShared);
47443 winceMutexRelease(pFile->hMutex);
47444 osCloseHandle(pFile->hMutex);
47445 pFile->hMutex = NULL;
47459 winFile *pFile = HANDLE_TO_WINFILE(phFile);
47465 if (!pFile->hMutex) return TRUE;
47466 winceMutexAcquire(pFile->hMutex);
47471 if (pFile->shared->nReaders == 0 && pFile->shared->bExclusive == 0){
47472 pFile->shared->bExclusive = TRUE;
47473 pFile->local.bExclusive = TRUE;
47481 if (pFile->shared->bExclusive == 0){
47482 pFile->local.nReaders ++;
47483 if (pFile->local.nReaders == 1){
47484 pFile->shared->nReaders ++;
47494 if (pFile->shared->bPending == 0) {
47495 pFile->shared->bPending = TRUE;
47496 pFile->local.bPending = TRUE;
47504 if (pFile->shared->bReserved == 0) {
47505 pFile->shared->bReserved = TRUE;
47506 pFile->local.bReserved = TRUE;
47511 winceMutexRelease(pFile->hMutex);
47525 winFile *pFile = HANDLE_TO_WINFILE(phFile);
47531 if (!pFile->hMutex) return TRUE;
47532 winceMutexAcquire(pFile->hMutex);
47537 if (pFile->local.bExclusive){
47539 pFile->local.bExclusive = FALSE;
47540 pFile->shared->bExclusive = FALSE;
47545 else if (pFile->local.nReaders){
47548 pFile->local.nReaders --;
47549 if (pFile->local.nReaders == 0)
47551 pFile->shared->nReaders --;
47560 if (pFile->local.bPending){
47561 pFile->local.bPending = FALSE;
47562 pFile->shared->bPending = FALSE;
47569 if (pFile->local.bReserved) {
47570 pFile->local.bReserved = FALSE;
47571 pFile->shared->bReserved = FALSE;
47576 winceMutexRelease(pFile->hMutex);
47662 ** Otherwise, set pFile->lastErrno and return non-zero.
47664 static int winSeekFile(winFile *pFile, sqlite3_int64 iOffset){
47671 OSTRACE(("SEEK file=%p, offset=%lld\n", pFile->h, iOffset));
47683 dwRet = osSetFilePointer(pFile->h, lowerBits, &upperBits, FILE_BEGIN);
47687 pFile->lastErrno = lastErrno;
47688 winLogError(SQLITE_IOERR_SEEK, pFile->lastErrno,
47689 "winSeekFile", pFile->zPath);
47690 OSTRACE(("SEEK file=%p, rc=SQLITE_IOERR_SEEK\n", pFile->h));
47694 OSTRACE(("SEEK file=%p, rc=SQLITE_OK\n", pFile->h));
47705 bRet = osSetFilePointerEx(pFile->h, x, 0, FILE_BEGIN);
47708 pFile->lastErrno = osGetLastError();
47709 winLogError(SQLITE_IOERR_SEEK, pFile->lastErrno,
47710 "winSeekFile", pFile->zPath);
47711 OSTRACE(("SEEK file=%p, rc=SQLITE_IOERR_SEEK\n", pFile->h));
47715 OSTRACE(("SEEK file=%p, rc=SQLITE_OK\n", pFile->h));
47739 winFile *pFile = (winFile*)id;
47743 assert( pFile->pShm==0 );
47745 assert( pFile->h!=NULL && pFile->h!=INVALID_HANDLE_VALUE );
47746 OSTRACE(("CLOSE pid=%lu, pFile=%p, file=%p\n",
47747 osGetCurrentProcessId(), pFile, pFile->h));
47750 winUnmapfile(pFile);
47754 rc = osCloseHandle(pFile->h);
47760 winVfsAppData *pAppData = (winVfsAppData*)pFile->pVfs->pAppData;
47762 winceDestroyLock(pFile);
47765 if( pFile->zDeleteOnClose ){
47768 osDeleteFileW(pFile->zDeleteOnClose)==0
47769 && osGetFileAttributesW(pFile->zDeleteOnClose)!=0xffffffff
47774 sqlite3_free(pFile->zDeleteOnClose);
47778 pFile->h = NULL;
47781 OSTRACE(("CLOSE pid=%lu, pFile=%p, file=%p, rc=%s\n",
47782 osGetCurrentProcessId(), pFile, pFile->h, rc ? "ok" : "failed"));
47785 "winClose", pFile->zPath);
47802 winFile *pFile = (winFile*)id; /* file handle */
47810 OSTRACE(("READ pid=%lu, pFile=%p, file=%p, buffer=%p, amount=%d, "
47811 "offset=%lld, lock=%d\n", osGetCurrentProcessId(), pFile,
47812 pFile->h, pBuf, amt, offset, pFile->locktype));
47817 if( offset<pFile->mmapSize ){
47818 if( offset+amt <= pFile->mmapSize ){
47819 memcpy(pBuf, &((u8 *)(pFile->pMapRegion))[offset], amt);
47820 OSTRACE(("READ-MMAP pid=%lu, pFile=%p, file=%p, rc=SQLITE_OK\n",
47821 osGetCurrentProcessId(), pFile, pFile->h));
47824 int nCopy = (int)(pFile->mmapSize - offset);
47825 memcpy(pBuf, &((u8 *)(pFile->pMapRegion))[offset], nCopy);
47834 if( winSeekFile(pFile, offset) ){
47835 OSTRACE(("READ pid=%lu, pFile=%p, file=%p, rc=SQLITE_FULL\n",
47836 osGetCurrentProcessId(), pFile, pFile->h));
47839 while( !osReadFile(pFile->h, pBuf, amt, &nRead, 0) ){
47844 while( !osReadFile(pFile->h, pBuf, amt, &nRead, &overlapped) &&
47849 pFile->lastErrno = lastErrno;
47850 OSTRACE(("READ pid=%lu, pFile=%p, file=%p, rc=SQLITE_IOERR_READ\n",
47851 osGetCurrentProcessId(), pFile, pFile->h));
47852 return winLogError(SQLITE_IOERR_READ, pFile->lastErrno,
47853 "winRead", pFile->zPath);
47859 OSTRACE(("READ pid=%lu, pFile=%p, file=%p, rc=SQLITE_IOERR_SHORT_READ\n",
47860 osGetCurrentProcessId(), pFile, pFile->h));
47864 OSTRACE(("READ pid=%lu, pFile=%p, file=%p, rc=SQLITE_OK\n",
47865 osGetCurrentProcessId(), pFile, pFile->h));
47880 winFile *pFile = (winFile*)id; /* File handle */
47884 assert( pFile );
47888 OSTRACE(("WRITE pid=%lu, pFile=%p, file=%p, buffer=%p, amount=%d, "
47889 "offset=%lld, lock=%d\n", osGetCurrentProcessId(), pFile,
47890 pFile->h, pBuf, amt, offset, pFile->locktype));
47895 if( offset<pFile->mmapSize ){
47896 if( offset+amt <= pFile->mmapSize ){
47897 memcpy(&((u8 *)(pFile->pMapRegion))[offset], pBuf, amt);
47898 OSTRACE(("WRITE-MMAP pid=%lu, pFile=%p, file=%p, rc=SQLITE_OK\n",
47899 osGetCurrentProcessId(), pFile, pFile->h));
47902 int nCopy = (int)(pFile->mmapSize - offset);
47903 memcpy(&((u8 *)(pFile->pMapRegion))[offset], pBuf, nCopy);
47912 rc = winSeekFile(pFile, offset);
47933 if( !osWriteFile(pFile->h, aRem, nRem, &nWrite, 0) ){
47935 if( !osWriteFile(pFile->h, aRem, nRem, &nWrite, &overlapped) ){
47954 pFile->lastErrno = lastErrno;
47960 if( ( pFile->lastErrno==ERROR_HANDLE_DISK_FULL )
47961 || ( pFile->lastErrno==ERROR_DISK_FULL )){
47962 OSTRACE(("WRITE pid=%lu, pFile=%p, file=%p, rc=SQLITE_FULL\n",
47963 osGetCurrentProcessId(), pFile, pFile->h));
47964 return winLogError(SQLITE_FULL, pFile->lastErrno,
47965 "winWrite1", pFile->zPath);
47967 OSTRACE(("WRITE pid=%lu, pFile=%p, file=%p, rc=SQLITE_IOERR_WRITE\n",
47968 osGetCurrentProcessId(), pFile, pFile->h));
47969 return winLogError(SQLITE_IOERR_WRITE, pFile->lastErrno,
47970 "winWrite2", pFile->zPath);
47974 OSTRACE(("WRITE pid=%lu, pFile=%p, file=%p, rc=SQLITE_OK\n",
47975 osGetCurrentProcessId(), pFile, pFile->h));
47983 winFile *pFile = (winFile*)id; /* File handle object */
47988 if( pFile->nFetchOut>0 ){
48010 assert( pFile );
48012 OSTRACE(("TRUNCATE pid=%lu, pFile=%p, file=%p, size=%lld, lock=%d\n",
48013 osGetCurrentProcessId(), pFile, pFile->h, nByte, pFile->locktype));
48020 if( pFile->szChunk>0 ){
48021 nByte = ((nByte + pFile->szChunk - 1)/pFile->szChunk) * pFile->szChunk;
48025 if( pFile->pMapRegion ){
48026 oldMmapSize = pFile->mmapSize;
48030 winUnmapfile(pFile);
48034 if( winSeekFile(pFile, nByte) ){
48035 rc = winLogError(SQLITE_IOERR_TRUNCATE, pFile->lastErrno,
48036 "winTruncate1", pFile->zPath);
48037 }else if( 0==osSetEndOfFile(pFile->h) &&
48039 pFile->lastErrno = lastErrno;
48040 rc = winLogError(SQLITE_IOERR_TRUNCATE, pFile->lastErrno,
48041 "winTruncate2", pFile->zPath);
48047 winMapfile(pFile, -1);
48049 winMapfile(pFile, oldMmapSize);
48054 OSTRACE(("TRUNCATE pid=%lu, pFile=%p, file=%p, rc=%s\n",
48055 osGetCurrentProcessId(), pFile, pFile->h, sqlite3ErrName(rc)));
48084 winFile *pFile = (winFile*)id;
48089 assert( pFile );
48100 OSTRACE(("SYNC pid=%lu, pFile=%p, file=%p, flags=%x, lock=%d\n",
48101 osGetCurrentProcessId(), pFile, pFile->h, flags,
48102 pFile->locktype));
48117 OSTRACE(("SYNC-NOP pid=%lu, pFile=%p, file=%p, rc=SQLITE_OK\n",
48118 osGetCurrentProcessId(), pFile, pFile->h));
48122 if( pFile->pMapRegion ){
48123 if( osFlushViewOfFile(pFile->pMapRegion, 0) ){
48124 OSTRACE(("SYNC-MMAP pid=%lu, pFile=%p, pMapRegion=%p, "
48126 pFile, pFile->pMapRegion));
48128 pFile->lastErrno = osGetLastError();
48129 OSTRACE(("SYNC-MMAP pid=%lu, pFile=%p, pMapRegion=%p, "
48131 pFile, pFile->pMapRegion));
48132 return winLogError(SQLITE_IOERR_MMAP, pFile->lastErrno,
48133 "winSync1", pFile->zPath);
48137 rc = osFlushFileBuffers(pFile->h);
48140 OSTRACE(("SYNC pid=%lu, pFile=%p, file=%p, rc=SQLITE_OK\n",
48141 osGetCurrentProcessId(), pFile, pFile->h));
48144 pFile->lastErrno = osGetLastError();
48145 OSTRACE(("SYNC pid=%lu, pFile=%p, file=%p, rc=SQLITE_IOERR_FSYNC\n",
48146 osGetCurrentProcessId(), pFile, pFile->h));
48147 return winLogError(SQLITE_IOERR_FSYNC, pFile->lastErrno,
48148 "winSync2", pFile->zPath);
48157 winFile *pFile = (winFile*)id;
48163 OSTRACE(("SIZE file=%p, pSize=%p\n", pFile->h, pSize));
48168 if( osGetFileInformationByHandleEx(pFile->h, FileStandardInfo,
48172 pFile->lastErrno = osGetLastError();
48173 rc = winLogError(SQLITE_IOERR_FSTAT, pFile->lastErrno,
48174 "winFileSize", pFile->zPath);
48183 lowerBits = osGetFileSize(pFile->h, &upperBits);
48187 pFile->lastErrno = lastErrno;
48188 rc = winLogError(SQLITE_IOERR_FSTAT, pFile->lastErrno,
48189 "winFileSize", pFile->zPath);
48194 pFile->h, pSize, *pSize, sqlite3ErrName(rc)));
48234 static int winGetReadLock(winFile *pFile){
48236 OSTRACE(("READ-LOCK file=%p, lock=%d\n", pFile->h, pFile->locktype));
48243 res = winceLockFile(&pFile->h, SHARED_FIRST, 0, 1, 0);
48245 res = winLockFile(&pFile->h, SQLITE_LOCKFILEEX_FLAGS, SHARED_FIRST, 0,
48253 pFile->sharedLockByte = (short)((lk & 0x7fffffff)%(SHARED_SIZE - 1));
48254 res = winLockFile(&pFile->h, SQLITE_LOCKFILE_FLAGS,
48255 SHARED_FIRST+pFile->sharedLockByte, 0, 1, 0);
48259 pFile->lastErrno = osGetLastError();
48262 OSTRACE(("READ-LOCK file=%p, result=%d\n", pFile->h, res));
48269 static int winUnlockReadLock(winFile *pFile){
48272 OSTRACE(("READ-UNLOCK file=%p, lock=%d\n", pFile->h, pFile->locktype));
48274 res = winUnlockFile(&pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0);
48278 res = winUnlockFile(&pFile->h, SHARED_FIRST+pFile->sharedLockByte, 0, 1, 0);
48282 pFile->lastErrno = lastErrno;
48283 winLogError(SQLITE_IOERR_UNLOCK, pFile->lastErrno,
48284 "winUnlockReadLock", pFile->zPath);
48286 OSTRACE(("READ-UNLOCK file=%p, result=%d\n", pFile->h, res));
48319 int newLocktype; /* Set pFile->locktype to this value before exiting */
48321 winFile *pFile = (winFile*)id;
48326 pFile->h, pFile->locktype, pFile->sharedLockByte, locktype));
48332 if( pFile->locktype>=locktype ){
48333 OSTRACE(("LOCK-HELD file=%p, rc=SQLITE_OK\n", pFile->h));
48339 if( (pFile->ctrlFlags & WINFILE_RDONLY)!=0 && locktype>=RESERVED_LOCK ){
48345 assert( pFile->locktype!=NO_LOCK || locktype==SHARED_LOCK );
48347 assert( locktype!=RESERVED_LOCK || pFile->locktype==SHARED_LOCK );
48353 newLocktype = pFile->locktype;
48354 if( pFile->locktype==NO_LOCK
48355 || (locktype==EXCLUSIVE_LOCK && pFile->locktype<=RESERVED_LOCK)
48358 while( cnt-->0 && (res = winLockFile(&pFile->h, SQLITE_LOCKFILE_FLAGS,
48368 pFile->h, cnt, res));
48370 pFile->lastErrno = lastErrno;
48373 pFile->h, cnt, sqlite3ErrName(rc)));
48387 assert( pFile->locktype==NO_LOCK );
48388 res = winGetReadLock(pFile);
48399 assert( pFile->locktype==SHARED_LOCK );
48400 res = winLockFile(&pFile->h, SQLITE_LOCKFILE_FLAGS, RESERVED_BYTE, 0, 1, 0);
48418 assert( pFile->locktype>=SHARED_LOCK );
48419 res = winUnlockReadLock(pFile);
48420 res = winLockFile(&pFile->h, SQLITE_LOCKFILE_FLAGS, SHARED_FIRST, 0,
48426 winGetReadLock(pFile);
48434 winUnlockFile(&pFile->h, PENDING_BYTE, 0, 1, 0);
48443 pFile->lastErrno = lastErrno;
48446 pFile->h, locktype, newLocktype));
48448 pFile->locktype = (u8)newLocktype;
48450 pFile->h, pFile->locktype, sqlite3ErrName(rc)));
48461 winFile *pFile = (winFile*)id;
48464 OSTRACE(("TEST-WR-LOCK file=%p, pResOut=%p\n", pFile->h, pResOut));
48467 if( pFile->locktype>=RESERVED_LOCK ){
48469 OSTRACE(("TEST-WR-LOCK file=%p, result=%d (local)\n", pFile->h, res));
48471 res = winLockFile(&pFile->h, SQLITE_LOCKFILEEX_FLAGS,RESERVED_BYTE,0,1,0);
48473 winUnlockFile(&pFile->h, RESERVED_BYTE, 0, 1, 0);
48476 OSTRACE(("TEST-WR-LOCK file=%p, result=%d (remote)\n", pFile->h, res));
48480 pFile->h, pResOut, *pResOut));
48497 winFile *pFile = (winFile*)id;
48499 assert( pFile!=0 );
48502 pFile->h, pFile->locktype, pFile->sharedLockByte, locktype));
48503 type = pFile->locktype;
48505 winUnlockFile(&pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0);
48506 if( locktype==SHARED_LOCK && !winGetReadLock(pFile) ){
48510 "winUnlock", pFile->zPath);
48514 winUnlockFile(&pFile->h, RESERVED_BYTE, 0, 1, 0);
48517 winUnlockReadLock(pFile);
48520 winUnlockFile(&pFile->h, PENDING_BYTE, 0, 1, 0);
48522 pFile->locktype = (u8)locktype;
48524 pFile->h, pFile->locktype, sqlite3ErrName(rc)));
48568 ** 1 or 0 depending on whether or not bit mask of pFile->ctrlFlags is set.
48570 ** If *pArg is 0 or 1, then clear or set the mask bit of pFile->ctrlFlags.
48572 static void winModeBit(winFile *pFile, unsigned char mask, int *pArg){
48574 *pArg = (pFile->ctrlFlags & mask)!=0;
48576 pFile->ctrlFlags &= ~mask;
48578 pFile->ctrlFlags |= mask;
48592 winFile *pFile = (winFile*)id;
48593 OSTRACE(("FCNTL file=%p, op=%d, pArg=%p\n", pFile->h, op, pArg));
48596 *(int*)pArg = pFile->locktype;
48597 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
48601 *(int*)pArg = (int)pFile->lastErrno;
48602 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
48606 pFile->szChunk = *(int *)pArg;
48607 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
48611 if( pFile->szChunk>0 ){
48622 OSTRACE(("FCNTL file=%p, rc=%s\n", pFile->h, sqlite3ErrName(rc)));
48625 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
48629 winModeBit(pFile, WINFILE_PERSIST_WAL, (int*)pArg);
48630 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
48634 winModeBit(pFile, WINFILE_PSOW, (int*)pArg);
48635 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
48639 *(char**)pArg = sqlite3_mprintf("%s", pFile->pVfs->zName);
48640 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
48655 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
48660 *phFile = pFile->h;
48661 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
48667 HANDLE hOldFile = pFile->h;
48668 pFile->h = *phFile;
48671 hOldFile, pFile->h));
48677 int rc = winGetTempname(pFile->pVfs, &zTFile);
48681 OSTRACE(("FCNTL file=%p, rc=%s\n", pFile->h, sqlite3ErrName(rc)));
48699 *(i64*)pArg = pFile->mmapSizeMax;
48700 if( newLimit>=0 && newLimit!=pFile->mmapSizeMax && pFile->nFetchOut==0 ){
48701 pFile->mmapSizeMax = newLimit;
48702 if( pFile->mmapSize>0 ){
48703 winUnmapfile(pFile);
48704 rc = winMapfile(pFile, -1);
48707 OSTRACE(("FCNTL file=%p, rc=%s\n", pFile->h, sqlite3ErrName(rc)));
48712 OSTRACE(("FCNTL file=%p, rc=SQLITE_NOTFOUND\n", pFile->h));
48867 winShmNode *pFile, /* Apply locks to this open shared-memory segment */
48875 assert( pFile->nRef==0 || sqlite3_mutex_held(pFile->mutex) );
48878 pFile->hFile.h, lockType, ofst, nByte));
48882 rc = winUnlockFile(&pFile->hFile.h, ofst, 0, nByte, 0);
48887 rc = winLockFile(&pFile->hFile.h, dwFlags, ofst, 0, nByte, 0);
48893 pFile->lastErrno = osGetLastError();
48898 pFile->hFile.h, (lockType == WINSHM_UNLCK) ? "winUnlockFile" :
48899 "winLockFile", pFile->lastErrno, sqlite3ErrName(rc)));
49439 static int winUnmapfile(winFile *pFile){
49440 assert( pFile!=0 );
49441 OSTRACE(("UNMAP-FILE pid=%lu, pFile=%p, hMap=%p, pMapRegion=%p, "
49443 osGetCurrentProcessId(), pFile, pFile->hMap, pFile->pMapRegion,
49444 pFile->mmapSize, pFile->mmapSizeMax));
49445 if( pFile->pMapRegion ){
49446 if( !osUnmapViewOfFile(pFile->pMapRegion) ){
49447 pFile->lastErrno = osGetLastError();
49448 OSTRACE(("UNMAP-FILE pid=%lu, pFile=%p, pMapRegion=%p, "
49449 "rc=SQLITE_IOERR_MMAP\n", osGetCurrentProcessId(), pFile,
49450 pFile->pMapRegion));
49451 return winLogError(SQLITE_IOERR_MMAP, pFile->lastErrno,
49452 "winUnmapfile1", pFile->zPath);
49454 pFile->pMapRegion = 0;
49455 pFile->mmapSize = 0;
49457 if( pFile->hMap!=NULL ){
49458 if( !osCloseHandle(pFile->hMap) ){
49459 pFile->lastErrno = osGetLastError();
49460 OSTRACE(("UNMAP-FILE pid=%lu, pFile=%p, hMap=%p, rc=SQLITE_IOERR_MMAP\n",
49461 osGetCurrentProcessId(), pFile, pFile->hMap));
49462 return winLogError(SQLITE_IOERR_MMAP, pFile->lastErrno,
49463 "winUnmapfile2", pFile->zPath);
49465 pFile->hMap = NULL;
49467 OSTRACE(("UNMAP-FILE pid=%lu, pFile=%p, rc=SQLITE_OK\n",
49468 osGetCurrentProcessId(), pFile));
49493 OSTRACE(("MAP-FILE pid=%lu, pFile=%p, size=%lld\n",
49501 OSTRACE(("MAP-FILE pid=%lu, pFile=%p, rc=SQLITE_IOERR_FSTAT\n",
49542 OSTRACE(("MAP-FILE-CREATE pid=%lu, pFile=%p, rc=%s\n",
49560 OSTRACE(("MAP-FILE-MAP pid=%lu, pFile=%p, rc=%s\n",
49568 OSTRACE(("MAP-FILE pid=%lu, pFile=%p, rc=SQLITE_OK\n",
49592 OSTRACE(("FETCH pid=%lu, pFile=%p, offset=%lld, amount=%d, pp=%p\n",
49600 OSTRACE(("FETCH pid=%lu, pFile=%p, rc=%s\n",
49613 OSTRACE(("FETCH pid=%lu, pFile=%p, pp=%p, *pp=%p, rc=SQLITE_OK\n",
49640 OSTRACE(("UNFETCH pid=%lu, pFile=%p, offset=%lld, p=%p\n",
49656 OSTRACE(("UNFETCH pid=%lu, pFile=%p, rc=SQLITE_OK\n",
50103 winFile *pFile = (winFile*)id;
50132 OSTRACE(("OPEN name=%s, pFile=%p, flags=%x, pOutFlags=%p\n",
50161 assert( pFile!=0 );
50162 memset(pFile, 0, sizeof(winFile));
50163 pFile->h = INVALID_HANDLE_VALUE;
50331 pFile->lastErrno = lastErrno;
50332 winLogError(SQLITE_CANTOPEN, pFile->lastErrno, "winOpen", zUtf8Name);
50355 && (rc = winceCreateLock(zName, pFile))!=SQLITE_OK
50365 pFile->zDeleteOnClose = zConverted;
50374 pFile->pVfs = pVfs;
50375 pFile->h = h;
50377 pFile->ctrlFlags |= WINFILE_RDONLY;
50382 pFile->ctrlFlags |= WINFILE_PSOW;
50384 pFile->lastErrno = NO_ERROR;
50385 pFile->zPath = zName;
50387 pFile->hMap = NULL;
50388 pFile->pMapRegion = 0;
50389 pFile->mmapSize = 0;
50390 pFile->mmapSizeMax = sqlite3GlobalConfig.szMmap;
51481 static int memdbClose(sqlite3_file *pFile){
51482 MemStore *p = ((MemFile*)pFile)->pStore;
51524 sqlite3_file *pFile,
51529 MemStore *p = ((MemFile*)pFile)->pStore;
51566 sqlite3_file *pFile,
51571 MemStore *p = ((MemFile*)pFile)->pStore;
51602 static int memdbTruncate(sqlite3_file *pFile, sqlite_int64 size){
51603 MemStore *p = ((MemFile*)pFile)->pStore;
51619 static int memdbSync(sqlite3_file *pFile, int flags){
51620 UNUSED_PARAMETER(pFile);
51628 static int memdbFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){
51629 MemStore *p = ((MemFile*)pFile)->pStore;
51639 static int memdbLock(sqlite3_file *pFile, int eLock){
51640 MemFile *pThis = (MemFile*)pFile;
51697 static int memdbUnlock(sqlite3_file *pFile, int eLock){
51698 MemFile *pThis = (MemFile*)pFile;
51725 static int memdbCheckReservedLock(sqlite3_file *pFile, int *pResOut){
51735 static int memdbFileControl(sqlite3_file *pFile, int op, void *pArg){
51736 MemStore *p = ((MemFile*)pFile)->pStore;
51764 static int memdbSectorSize(sqlite3_file *pFile){
51772 static int memdbDeviceCharacteristics(sqlite3_file *pFile){
51773 UNUSED_PARAMETER(pFile);
51782 sqlite3_file *pFile,
51787 MemStore *p = ((MemFile*)pFile)->pStore;
51800 static int memdbUnfetch(sqlite3_file *pFile, sqlite3_int64 iOfst, void *pPage){
51801 MemStore *p = ((MemFile*)pFile)->pStore;
51820 MemFile *pFile = (MemFile*)pFd;
51825 memset(pFile, 0, sizeof(*pFile));
51883 pFile->pStore = p;
58199 ** Return a sanitized version of the sector-size of OS file pFile. The
58202 SQLITE_PRIVATE int sqlite3SectorSize(sqlite3_file *pFile){
58203 int iRet = sqlite3OsSectorSize(pFile);
59171 ** Write the file descriptor into *pFile. Return SQLITE_OK on success
59185 sqlite3_file *pFile, /* Write the file descriptor here */
59196 rc = sqlite3OsOpen(pPager->pVfs, 0, pFile, vfsFlags, 0);
59197 assert( rc!=SQLITE_OK || isOpen(pFile) );
71339 sqlite3_file *pFile;
71349 pFile = sqlite3PagerFile(pBt->pPager);
71350 if( pFile->pMethods ){
71351 sqlite3OsFileControlHint(pFile, SQLITE_FCNTL_PDB, (void*)&pBt->db);
80059 ** If pFile is currently larger than iSize bytes, then truncate it to
80060 ** exactly iSize bytes. If pFile is not larger than iSize bytes, then
80066 static int backupTruncateFile(sqlite3_file *pFile, i64 iSize){
80068 int rc = sqlite3OsFileSize(pFile, &iCurrent);
80070 rc = sqlite3OsTruncate(pFile, iSize);
80245 sqlite3_file * const pFile = sqlite3PagerFile(pDestPager);
80251 assert( pFile );
80291 rc = sqlite3OsWrite(pFile, zData, pgszSrc, iOff);
80296 rc = backupTruncateFile(pFile, iSize);
100381 ** Attempt to memory map file pFile. If successful, set *pp to point to the
100389 static int vdbeSorterMapFile(SortSubtask *pTask, SorterFile *pFile, u8 **pp){
100391 if( pFile->iEof<=(i64)(pTask->pSorter->db->nMaxSorterMmap) ){
100392 sqlite3_file *pFd = pFile->pFd;
100394 rc = sqlite3OsFetch(pFd, 0, (int)pFile->iEof, (void**)pp);
100402 ** Attach PmaReader pReadr to file pFile (if it is not already attached to
100409 SorterFile *pFile, /* Sorter file to read from */
100410 i64 iOff /* Offset in pFile */
100422 pReadr->iEof = pFile->iEof;
100423 pReadr->pFd = pFile->pFd;
100425 rc = vdbeSorterMapFile(pTask, pFile, &pReadr->aMap);
100492 ** Initialize PmaReader pReadr to scan through the PMA stored in file pFile
100502 SorterFile *pFile, /* Sorter file to read from */
100503 i64 iStart, /* Start offset in pFile */
100509 assert( pFile->iEof>iStart );
100514 rc = vdbePmaReaderSeek(pTask, pReadr, pFile, iStart);
135308 sqlite3_file *pFile = sqlite3PagerFile(pPager);
135309 sqlite3OsFileControlHint(pFile, SQLITE_GET_LOCKPROXYFILE,
135314 sqlite3_file *pFile = sqlite3PagerFile(pPager);
135317 res=sqlite3OsFileControl(pFile, SQLITE_SET_LOCKPROXYFILE,
135320 res=sqlite3OsFileControl(pFile, SQLITE_SET_LOCKPROXYFILE,
175134 ** lock on VFS file pFile.
213385 static int rbuVfsClose(sqlite3_file *pFile){
213386 rbu_file *p = (rbu_file*)pFile;
213445 sqlite3_file *pFile,
213450 rbu_file *p = (rbu_file*)pFile;
213511 sqlite3_file *pFile,
213516 rbu_file *p = (rbu_file*)pFile;
213553 static int rbuVfsTruncate(sqlite3_file *pFile, sqlite_int64 size){
213554 rbu_file *p = (rbu_file*)pFile;
213565 static int rbuVfsSync(sqlite3_file *pFile, int flags){
213566 rbu_file *p = (rbu_file *)pFile;
213579 static int rbuVfsFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){
213580 rbu_file *p = (rbu_file *)pFile;
213600 static int rbuVfsLock(sqlite3_file *pFile, int eLock){
213601 rbu_file *p = (rbu_file*)pFile;
213622 static int rbuVfsUnlock(sqlite3_file *pFile, int eLock){
213623 rbu_file *p = (rbu_file *)pFile;
213630 static int rbuVfsCheckReservedLock(sqlite3_file *pFile, int *pResOut){
213631 rbu_file *p = (rbu_file *)pFile;
213638 static int rbuVfsFileControl(sqlite3_file *pFile, int op, void *pArg){
213639 rbu_file *p = (rbu_file *)pFile;
213694 static int rbuVfsSectorSize(sqlite3_file *pFile){
213695 rbu_file *p = (rbu_file *)pFile;
213702 static int rbuVfsDeviceCharacteristics(sqlite3_file *pFile){
213703 rbu_file *p = (rbu_file *)pFile;
213710 static int rbuVfsShmLock(sqlite3_file *pFile, int ofst, int n, int flags){
213711 rbu_file *p = (rbu_file*)pFile;
213749 sqlite3_file *pFile,
213755 rbu_file *p = (rbu_file*)pFile;
213806 static void rbuVfsShmBarrier(sqlite3_file *pFile){
213807 rbu_file *p = (rbu_file *)pFile;
213814 static int rbuVfsShmUnmap(sqlite3_file *pFile, int delFlag){
213815 rbu_file *p = (rbu_file*)pFile;
213836 sqlite3_file *pFile,
213862 rbu_file *pFd = (rbu_file *)pFile;
213917 pFile->pMethods = &rbuvfs_io_methods;