Lines Matching refs:pFile
25976 sqlite3_file *pFile, in sqlite3OsOpen() argument
25987 rc = pVfs->xOpen(pVfs, zPath, pFile, flags & 0x1087f7f, pFlagsOut); in sqlite3OsOpen()
25988 assert( rc==SQLITE_OK || pFile->pMethods==0 ); in sqlite3OsOpen()
26074 sqlite3_file *pFile; in sqlite3OsOpenMalloc() local
26075 pFile = (sqlite3_file *)sqlite3MallocZero(pVfs->szOsFile); in sqlite3OsOpenMalloc()
26076 if( pFile ){ in sqlite3OsOpenMalloc()
26077 rc = sqlite3OsOpen(pVfs, zFile, pFile, flags, pOutFlags); in sqlite3OsOpenMalloc()
26079 sqlite3_free(pFile); in sqlite3OsOpenMalloc()
26082 *ppFile = pFile; in sqlite3OsOpenMalloc()
26091 SQLITE_PRIVATE void sqlite3OsCloseFree(sqlite3_file *pFile){ in sqlite3OsCloseFree() argument
26092 assert( pFile ); in sqlite3OsCloseFree()
26093 sqlite3OsClose(pFile); in sqlite3OsCloseFree()
26094 sqlite3_free(pFile); in sqlite3OsCloseFree()
37480 KVVfsFile *pFile, /* Store decoding in pFile->aJrnl */
37492 sqlite3_free(pFile->aJrnl);
37493 pFile->aJrnl = sqlite3_malloc64( n );
37494 if( pFile->aJrnl==0 ){
37495 pFile->nJrnl = 0;
37498 pFile->nJrnl = n;
37499 n = kvvfsDecode(zTxt+i, pFile->aJrnl, pFile->nJrnl);
37500 if( n<pFile->nJrnl ){
37501 sqlite3_free(pFile->aJrnl);
37502 pFile->aJrnl = 0;
37503 pFile->nJrnl = 0;
37510 static sqlite3_int64 kvvfsReadFileSize(KVVfsFile *pFile){
37513 sqlite3KvvfsMethods.xRead(pFile->zClass, "sz", zData, sizeof(zData)-1);
37516 static int kvvfsWriteFileSize(KVVfsFile *pFile, sqlite3_int64 sz){
37519 return sqlite3KvvfsMethods.xWrite(pFile->zClass, "sz", zData);
37528 KVVfsFile *pFile = (KVVfsFile *)pProtoFile;
37530 SQLITE_KV_LOG(("xClose %s %s\n", pFile->zClass,
37531 pFile->isJournal ? "journal" : "db"));
37532 sqlite3_free(pFile->aJrnl);
37533 sqlite3_free(pFile->aData);
37546 KVVfsFile *pFile = (KVVfsFile*)pProtoFile;
37547 assert( pFile->isJournal );
37548 SQLITE_KV_LOG(("xRead('%s-journal',%d,%lld)\n", pFile->zClass, iAmt, iOfst));
37549 if( pFile->aJrnl==0 ){
37550 int szTxt = kvstorageRead(pFile->zClass, "jrnl", 0, 0);
37557 kvstorageRead(pFile->zClass, "jrnl", aTxt, szTxt+1);
37558 kvvfsDecodeJournal(pFile, aTxt, szTxt);
37560 if( pFile->aJrnl==0 ) return SQLITE_IOERR;
37562 if( iOfst+iAmt>pFile->nJrnl ){
37565 memcpy(zBuf, pFile->aJrnl+iOfst, iAmt);
37578 KVVfsFile *pFile = (KVVfsFile*)pProtoFile;
37582 char *aData = pFile->aData;
37585 SQLITE_KV_LOG(("xRead('%s-db',%d,%lld)\n", pFile->zClass, iAmt, iOfst));
37593 pFile->szPage = iAmt;
37599 got = sqlite3KvvfsMethods.xRead(pFile->zClass, zKey,
37636 KVVfsFile *pFile = (KVVfsFile*)pProtoFile;
37638 SQLITE_KV_LOG(("xWrite('%s-journal',%d,%lld)\n", pFile->zClass, iAmt, iOfst));
37640 if( pFile->aJrnl==0 || pFile->nJrnl<iEnd ){
37641 char *aNew = sqlite3_realloc(pFile->aJrnl, iEnd);
37645 pFile->aJrnl = aNew;
37646 if( pFile->nJrnl<iOfst ){
37647 memset(pFile->aJrnl+pFile->nJrnl, 0, iOfst-pFile->nJrnl);
37649 pFile->nJrnl = iEnd;
37651 memcpy(pFile->aJrnl+iOfst, zBuf, iAmt);
37664 KVVfsFile *pFile = (KVVfsFile*)pProtoFile;
37667 char *aData = pFile->aData;
37668 SQLITE_KV_LOG(("xWrite('%s-db',%d,%lld)\n", pFile->zClass, iAmt, iOfst));
37671 assert( pFile->szPage<0 || pFile->szPage==iAmt );
37672 pFile->szPage = iAmt;
37676 if( sqlite3KvvfsMethods.xWrite(pFile->zClass, zKey, aData) ){
37679 if( iOfst+iAmt > pFile->szDb ){
37680 pFile->szDb = iOfst + iAmt;
37689 KVVfsFile *pFile = (KVVfsFile *)pProtoFile;
37690 SQLITE_KV_LOG(("xTruncate('%s-journal',%lld)\n", pFile->zClass, size));
37692 sqlite3KvvfsMethods.xDelete(pFile->zClass, "jrnl");
37693 sqlite3_free(pFile->aJrnl);
37694 pFile->aJrnl = 0;
37695 pFile->nJrnl = 0;
37699 KVVfsFile *pFile = (KVVfsFile *)pProtoFile;
37700 if( pFile->szDb>size
37701 && pFile->szPage>0
37702 && (size % pFile->szPage)==0
37706 SQLITE_KV_LOG(("xTruncate('%s-db',%lld)\n", pFile->zClass, size));
37707 pgno = 1 + size/pFile->szPage;
37708 pgnoMax = 2 + pFile->szDb/pFile->szPage;
37711 sqlite3KvvfsMethods.xDelete(pFile->zClass, zKey);
37714 pFile->szDb = size;
37715 return kvvfsWriteFileSize(pFile, size) ? SQLITE_IOERR : SQLITE_OK;
37725 KVVfsFile *pFile = (KVVfsFile *)pProtoFile;
37727 SQLITE_KV_LOG(("xSync('%s-journal')\n", pFile->zClass));
37728 if( pFile->nJrnl<=0 ){
37731 zOut = sqlite3_malloc64( pFile->nJrnl*2 + 50 );
37735 n = pFile->nJrnl;
37742 kvvfsEncode(pFile->aJrnl, pFile->nJrnl, &zOut[i]);
37743 i = sqlite3KvvfsMethods.xWrite(pFile->zClass, "jrnl", zOut);
37755 KVVfsFile *pFile = (KVVfsFile *)pProtoFile;
37756 SQLITE_KV_LOG(("xFileSize('%s-journal')\n", pFile->zClass));
37757 *pSize = pFile->nJrnl;
37761 KVVfsFile *pFile = (KVVfsFile *)pProtoFile;
37762 SQLITE_KV_LOG(("xFileSize('%s-db')\n", pFile->zClass));
37763 if( pFile->szDb>=0 ){
37764 *pSize = pFile->szDb;
37766 *pSize = kvvfsReadFileSize(pFile);
37775 KVVfsFile *pFile = (KVVfsFile *)pProtoFile;
37776 assert( !pFile->isJournal );
37777 SQLITE_KV_LOG(("xLock(%s,%d)\n", pFile->zClass, eLock));
37780 pFile->szDb = kvvfsReadFileSize(pFile);
37789 KVVfsFile *pFile = (KVVfsFile *)pProtoFile;
37790 assert( !pFile->isJournal );
37791 SQLITE_KV_LOG(("xUnlock(%s,%d)\n", pFile->zClass, eLock));
37793 pFile->szDb = -1;
37817 KVVfsFile *pFile = (KVVfsFile *)pProtoFile;
37819 SQLITE_KV_LOG(("xSync('%s-db')\n", pFile->zClass));
37820 if( pFile->szDb>0 && 0!=kvvfsWriteFileSize(pFile, pFile->szDb) ){
37831 static int kvvfsSectorSize(sqlite3_file *pFile){
37854 KVVfsFile *pFile = (KVVfsFile*)pProtoFile;
37860 pFile->isJournal = 0;
37861 pFile->base.pMethods = &kvvfs_db_io_methods;
37866 pFile->isJournal = 1;
37867 pFile->base.pMethods = &kvvfs_jrnl_io_methods;
37872 pFile->zClass = "session";
37874 pFile->zClass = "local";
37876 pFile->aData = sqlite3_malloc64(SQLITE_KVOS_SZ);
37877 if( pFile->aData==0 ){
37880 pFile->aJrnl = 0;
37881 pFile->nJrnl = 0;
37882 pFile->szPage = -1;
37883 pFile->szDb = -1;
39260 int unixFileMutexHeld(unixFile *pFile){
39261 assert( pFile->pInode );
39262 return sqlite3_mutex_held(pFile->pInode->pLockMutex);
39264 int unixFileMutexNotheld(unixFile *pFile){
39265 assert( pFile->pInode );
39266 return sqlite3_mutex_notheld(pFile->pInode->pLockMutex);
39352 static void robust_close(unixFile *pFile, int h, int lineno){
39355 pFile ? pFile->zPath : 0, lineno);
39363 static void storeLastErrno(unixFile *pFile, int error){
39364 pFile->lastErrno = error;
39370 static void closePendingFds(unixFile *pFile){
39371 unixInodeInfo *pInode = pFile->pInode;
39374 assert( unixFileMutexHeld(pFile) );
39377 robust_close(pFile, p->fd, __LINE__);
39389 static void releaseInodeInfo(unixFile *pFile){
39390 unixInodeInfo *pInode = pFile->pInode;
39392 assert( unixFileMutexNotheld(pFile) );
39398 closePendingFds(pFile);
39427 unixFile *pFile, /* Unix file with file desc used in the key */
39441 fd = pFile->h;
39444 storeLastErrno(pFile, errno);
39446 if( pFile->lastErrno==EOVERFLOW ) return SQLITE_NOLFS;
39462 if( statbuf.st_size==0 && (pFile->fsFlags & SQLITE_FSFLAGS_IS_MSDOS)!=0 ){
39465 storeLastErrno(pFile, errno);
39470 storeLastErrno(pFile, errno);
39479 fileId.pId = pFile->pId;
39518 static int fileHasMoved(unixFile *pFile){
39520 return pFile->pInode!=0 && pFile->pId!=pFile->pInode->fileId.pId;
39523 return pFile->pInode!=0 &&
39524 (osStat(pFile->zPath, &buf)!=0
39525 || (u64)buf.st_ino!=pFile->pInode->fileId.ino);
39539 static void verifyDbFile(unixFile *pFile){
39544 if( pFile->ctrlFlags & UNIXFILE_NOLOCK ) return;
39546 rc = osFstat(pFile->h, &buf);
39548 sqlite3_log(SQLITE_WARNING, "cannot fstat db file %s", pFile->zPath);
39552 sqlite3_log(SQLITE_WARNING, "file unlinked while open: %s", pFile->zPath);
39556 sqlite3_log(SQLITE_WARNING, "multiple links to file: %s", pFile->zPath);
39559 if( fileHasMoved(pFile) ){
39560 sqlite3_log(SQLITE_WARNING, "file renamed while open: %s", pFile->zPath);
39575 unixFile *pFile = (unixFile*)id;
39579 assert( pFile );
39580 assert( pFile->eFileLock<=SHARED_LOCK );
39581 sqlite3_mutex_enter(pFile->pInode->pLockMutex);
39584 if( pFile->pInode->eFileLock>SHARED_LOCK ){
39591 if( !reserved && !pFile->pInode->bProcessLock ){
39597 if( osFcntl(pFile->h, F_GETLK, &lock) ){
39599 storeLastErrno(pFile, errno);
39606 sqlite3_mutex_leave(pFile->pInode->pLockMutex);
39607 OSTRACE(("TEST WR-LOCK %d %d %d (unix)\n", pFile->h, rc, reserved));
39635 unixFile *pFile /* Structure holding timeout value */
39637 int tm = pFile->iBusyTimeout;
39673 static int unixFileLock(unixFile *pFile, struct flock *pLock){
39675 unixInodeInfo *pInode = pFile->pInode;
39678 if( (pFile->ctrlFlags & (UNIXFILE_EXCL|UNIXFILE_RDONLY))==UNIXFILE_EXCL ){
39686 rc = osSetPosixAdvisoryLock(pFile->h, &lock, pFile);
39694 rc = osSetPosixAdvisoryLock(pFile->h, pLock, pFile);
39765 unixFile *pFile = (unixFile*)id;
39770 assert( pFile );
39771 OSTRACE(("LOCK %d %s was %s(%s,%d) pid=%d (unix)\n", pFile->h,
39772 azFileLock(eFileLock), azFileLock(pFile->eFileLock),
39773 azFileLock(pFile->pInode->eFileLock), pFile->pInode->nShared,
39780 if( pFile->eFileLock>=eFileLock ){
39781 OSTRACE(("LOCK %d %s ok (already held) (unix)\n", pFile->h,
39791 assert( pFile->eFileLock!=NO_LOCK || eFileLock==SHARED_LOCK );
39793 assert( eFileLock!=RESERVED_LOCK || pFile->eFileLock==SHARED_LOCK );
39797 pInode = pFile->pInode;
39803 if( (pFile->eFileLock!=pInode->eFileLock &&
39817 assert( pFile->eFileLock==0 );
39819 pFile->eFileLock = SHARED_LOCK;
39833 || (eFileLock==EXCLUSIVE_LOCK && pFile->eFileLock==RESERVED_LOCK)
39837 if( unixFileLock(pFile, &lock) ){
39841 storeLastErrno(pFile, tErrno);
39845 pFile->eFileLock = PENDING_LOCK;
39862 if( unixFileLock(pFile, &lock) ){
39871 if( unixFileLock(pFile, &lock) && rc==SQLITE_OK ){
39879 storeLastErrno(pFile, tErrno);
39883 pFile->eFileLock = SHARED_LOCK;
39896 assert( 0!=pFile->eFileLock );
39908 if( unixFileLock(pFile, &lock) ){
39912 storeLastErrno(pFile, tErrno);
39925 && pFile->eFileLock<=SHARED_LOCK
39928 pFile->transCntrChng = 0;
39929 pFile->dbUpdate = 0;
39930 pFile->inNormalWrite = 1;
39935 pFile->eFileLock = eFileLock;
39941 OSTRACE(("LOCK %d %s %s (unix)\n", pFile->h, azFileLock(eFileLock),
39950 static void setPendingFd(unixFile *pFile){
39951 unixInodeInfo *pInode = pFile->pInode;
39952 UnixUnusedFd *p = pFile->pPreallocatedUnused;
39953 assert( unixFileMutexHeld(pFile) );
39956 pFile->h = -1;
39957 pFile->pPreallocatedUnused = 0;
39974 unixFile *pFile = (unixFile*)id;
39979 assert( pFile );
39980 OSTRACE(("UNLOCK %d %d was %d(%d,%d) pid=%d (unix)\n", pFile->h, eFileLock,
39981 pFile->eFileLock, pFile->pInode->eFileLock, pFile->pInode->nShared,
39985 if( pFile->eFileLock<=eFileLock ){
39988 pInode = pFile->pInode;
39991 if( pFile->eFileLock>SHARED_LOCK ){
39992 assert( pInode->eFileLock==pFile->eFileLock );
40003 pFile->inNormalWrite = 0;
40029 if( unixFileLock(pFile, &lock)==(-1) ){
40032 storeLastErrno(pFile, tErrno);
40039 if( unixFileLock(pFile, &lock)==(-1) ){
40043 storeLastErrno(pFile, tErrno);
40051 if( unixFileLock(pFile, &lock)==(-1) ){
40054 storeLastErrno(pFile, tErrno);
40064 if( unixFileLock(pFile, &lock) ){
40072 storeLastErrno(pFile, errno);
40081 if( unixFileLock(pFile, &lock)==0 ){
40085 storeLastErrno(pFile, errno);
40099 if( unixFileLock(pFile, &lock)==0 ){
40103 storeLastErrno(pFile, errno);
40105 pFile->eFileLock = NO_LOCK;
40115 if( pInode->nLock==0 ) closePendingFds(pFile);
40121 pFile->eFileLock = eFileLock;
40156 unixFile *pFile = (unixFile*)id;
40158 unixUnmapfile(pFile);
40160 if( pFile->h>=0 ){
40161 robust_close(pFile, pFile->h, __LINE__);
40162 pFile->h = -1;
40165 if( pFile->pId ){
40166 if( pFile->ctrlFlags & UNIXFILE_DELETE ){
40167 osUnlink(pFile->pId->zCanonicalName);
40169 vxworksReleaseFileId(pFile->pId);
40170 pFile->pId = 0;
40174 if( pFile->ctrlFlags & UNIXFILE_DELETE ){
40175 osUnlink(pFile->zPath);
40176 sqlite3_free(*(char**)&pFile->zPath);
40177 pFile->zPath = 0;
40180 OSTRACE(("CLOSE %-3d\n", pFile->h));
40182 sqlite3_free(pFile->pPreallocatedUnused);
40183 memset(pFile, 0, sizeof(unixFile));
40192 unixFile *pFile = (unixFile *)id;
40193 unixInodeInfo *pInode = pFile->pInode;
40196 verifyDbFile(pFile);
40198 assert( unixFileMutexNotheld(pFile) );
40204 assert( pFile->pInode->nLock>0 || pFile->pInode->bProcessLock==0 );
40212 setPendingFd(pFile);
40215 releaseInodeInfo(pFile);
40216 assert( pFile->pShm==0 );
40307 unixFile *pFile = (unixFile*)id;
40311 assert( pFile );
40312 reserved = osAccess((const char*)pFile->lockingContext, 0)==0;
40313 OSTRACE(("TEST WR-LOCK %d %d %d (dotlock)\n", pFile->h, rc, reserved));
40346 unixFile *pFile = (unixFile*)id;
40347 char *zLockFile = (char *)pFile->lockingContext;
40354 if( pFile->eFileLock > NO_LOCK ){
40355 pFile->eFileLock = eFileLock;
40375 storeLastErrno(pFile, tErrno);
40382 pFile->eFileLock = eFileLock;
40396 unixFile *pFile = (unixFile*)id;
40397 char *zLockFile = (char *)pFile->lockingContext;
40400 assert( pFile );
40401 OSTRACE(("UNLOCK %d %d was %d pid=%d (dotlock)\n", pFile->h, eFileLock,
40402 pFile->eFileLock, osGetpid(0)));
40406 if( pFile->eFileLock==eFileLock ){
40414 pFile->eFileLock = SHARED_LOCK;
40427 storeLastErrno(pFile, tErrno);
40431 pFile->eFileLock = NO_LOCK;
40439 unixFile *pFile = (unixFile*)id;
40442 sqlite3_free(pFile->lockingContext);
40487 unixFile *pFile = (unixFile*)id;
40491 assert( pFile );
40494 if( pFile->eFileLock>SHARED_LOCK ){
40501 int lrc = robust_flock(pFile->h, LOCK_EX | LOCK_NB);
40504 lrc = robust_flock(pFile->h, LOCK_UN);
40509 storeLastErrno(pFile, tErrno);
40518 storeLastErrno(pFile, tErrno);
40523 OSTRACE(("TEST WR-LOCK %d %d %d (flock)\n", pFile->h, rc, reserved));
40566 unixFile *pFile = (unixFile*)id;
40568 assert( pFile );
40572 if (pFile->eFileLock > NO_LOCK) {
40573 pFile->eFileLock = eFileLock;
40579 if (robust_flock(pFile->h, LOCK_EX | LOCK_NB)) {
40584 storeLastErrno(pFile, tErrno);
40588 pFile->eFileLock = eFileLock;
40590 OSTRACE(("LOCK %d %s %s (flock)\n", pFile->h, azFileLock(eFileLock),
40609 unixFile *pFile = (unixFile*)id;
40611 assert( pFile );
40612 OSTRACE(("UNLOCK %d %d was %d pid=%d (flock)\n", pFile->h, eFileLock,
40613 pFile->eFileLock, osGetpid(0)));
40617 if( pFile->eFileLock==eFileLock ){
40623 pFile->eFileLock = eFileLock;
40628 if( robust_flock(pFile->h, LOCK_UN) ){
40634 pFile->eFileLock = NO_LOCK;
40674 unixFile *pFile = (unixFile*)id;
40678 assert( pFile );
40681 if( pFile->eFileLock>SHARED_LOCK ){
40687 sem_t *pSem = pFile->pInode->pSem;
40693 storeLastErrno(pFile, tErrno);
40696 reserved = (pFile->eFileLock < SHARED_LOCK);
40703 OSTRACE(("TEST WR-LOCK %d %d %d (sem)\n", pFile->h, rc, reserved));
40739 unixFile *pFile = (unixFile*)id;
40740 sem_t *pSem = pFile->pInode->pSem;
40745 if (pFile->eFileLock > NO_LOCK) {
40746 pFile->eFileLock = eFileLock;
40758 pFile->eFileLock = eFileLock;
40772 unixFile *pFile = (unixFile*)id;
40773 sem_t *pSem = pFile->pInode->pSem;
40775 assert( pFile );
40777 OSTRACE(("UNLOCK %d %d was %d pid=%d (sem)\n", pFile->h, eFileLock,
40778 pFile->eFileLock, osGetpid(0)));
40782 if( pFile->eFileLock==eFileLock ){
40788 pFile->eFileLock = eFileLock;
40797 storeLastErrno(pFile, tErrno);
40801 pFile->eFileLock = NO_LOCK;
40810 unixFile *pFile = (unixFile*)id;
40812 assert( pFile );
40813 assert( unixFileMutexNotheld(pFile) );
40815 releaseInodeInfo(pFile);
40870 unixFile *pFile, /* Open file descriptor on path */
40882 pb.fd = pFile->h;
40885 (setLockFlag?"ON":"OFF"), pFile->h, (pb.fd==-1?"[testval-1]":""),
40900 storeLastErrno(pFile, tErrno);
40917 unixFile *pFile = (unixFile*)id;
40922 assert( pFile );
40923 context = (afpLockingContext *) pFile->lockingContext;
40928 sqlite3_mutex_enter(pFile->pInode->pLockMutex);
40930 if( pFile->pInode->eFileLock>SHARED_LOCK ){
40938 int lrc = afpSetLock(context->dbPath, pFile, RESERVED_BYTE, 1,1);
40942 lrc = afpSetLock(context->dbPath, pFile, RESERVED_BYTE, 1, 0);
40952 sqlite3_mutex_leave(pFile->pInode->pLockMutex);
40953 OSTRACE(("TEST WR-LOCK %d %d %d (afp)\n", pFile->h, rc, reserved));
40985 unixFile *pFile = (unixFile*)id;
40986 unixInodeInfo *pInode = pFile->pInode;
40987 afpLockingContext *context = (afpLockingContext *) pFile->lockingContext;
40989 assert( pFile );
40990 OSTRACE(("LOCK %d %s was %s(%s,%d) pid=%d (afp)\n", pFile->h,
40991 azFileLock(eFileLock), azFileLock(pFile->eFileLock),
40998 if( pFile->eFileLock>=eFileLock ){
40999 OSTRACE(("LOCK %d %s ok (already held) (afp)\n", pFile->h,
41009 assert( pFile->eFileLock!=NO_LOCK || eFileLock==SHARED_LOCK );
41011 assert( eFileLock!=RESERVED_LOCK || pFile->eFileLock==SHARED_LOCK );
41015 pInode = pFile->pInode;
41021 if( (pFile->eFileLock!=pInode->eFileLock &&
41035 assert( pFile->eFileLock==0 );
41037 pFile->eFileLock = SHARED_LOCK;
41048 || (eFileLock==EXCLUSIVE_LOCK && pFile->eFileLock<PENDING_LOCK)
41051 failed = afpSetLock(context->dbPath, pFile, PENDING_BYTE, 1, 1);
41073 lrc1 = afpSetLock(context->dbPath, pFile,
41076 lrc1Errno = pFile->lastErrno;
41079 lrc2 = afpSetLock(context->dbPath, pFile, PENDING_BYTE, 1, 0);
41082 storeLastErrno(pFile, lrc1Errno);
41091 pFile->eFileLock = SHARED_LOCK;
41105 assert( 0!=pFile->eFileLock );
41106 if (eFileLock >= RESERVED_LOCK && pFile->eFileLock < RESERVED_LOCK) {
41108 failed = afpSetLock(context->dbPath, pFile, RESERVED_BYTE, 1,1);
41119 if( !(failed = afpSetLock(context->dbPath, pFile, SHARED_FIRST +
41123 failed = afpSetLock(context->dbPath, pFile, SHARED_FIRST,
41125 if( failed && (failed2 = afpSetLock(context->dbPath, pFile,
41144 pFile->eFileLock = eFileLock;
41147 pFile->eFileLock = PENDING_LOCK;
41153 OSTRACE(("LOCK %d %s %s (afp)\n", pFile->h, azFileLock(eFileLock),
41167 unixFile *pFile = (unixFile*)id;
41169 afpLockingContext *context = (afpLockingContext *) pFile->lockingContext;
41172 assert( pFile );
41173 OSTRACE(("UNLOCK %d %d was %d(%d,%d) pid=%d (afp)\n", pFile->h, eFileLock,
41174 pFile->eFileLock, pFile->pInode->eFileLock, pFile->pInode->nShared,
41178 if( pFile->eFileLock<=eFileLock ){
41181 pInode = pFile->pInode;
41184 if( pFile->eFileLock>SHARED_LOCK ){
41185 assert( pInode->eFileLock==pFile->eFileLock );
41196 assert( pFile->inNormalWrite==0
41197 || pFile->dbUpdate==0
41198 || pFile->transCntrChng==1 );
41199 pFile->inNormalWrite = 0;
41202 if( pFile->eFileLock==EXCLUSIVE_LOCK ){
41203 rc = afpSetLock(context->dbPath, pFile, SHARED_FIRST, SHARED_SIZE, 0);
41207 rc = afpSetLock(context->dbPath, pFile, sharedLockByte, 1, 1);
41212 if( rc==SQLITE_OK && pFile->eFileLock>=PENDING_LOCK ){
41213 rc = afpSetLock(context->dbPath, pFile, PENDING_BYTE, 1, 0);
41215 if( rc==SQLITE_OK && pFile->eFileLock>=RESERVED_LOCK && context->reserved ){
41216 rc = afpSetLock(context->dbPath, pFile, RESERVED_BYTE, 1, 0);
41235 rc = afpSetLock(context->dbPath, pFile, sharedLockByte, 1, 0);
41239 pFile->eFileLock = NO_LOCK;
41245 if( pInode->nLock==0 ) closePendingFds(pFile);
41251 pFile->eFileLock = eFileLock;
41261 unixFile *pFile = (unixFile*)id;
41264 assert( unixFileMutexNotheld(pFile) );
41266 if( pFile->pInode ){
41267 unixInodeInfo *pInode = pFile->pInode;
41275 setPendingFd(pFile);
41279 releaseInodeInfo(pFile);
41280 sqlite3_free(pFile->lockingContext);
41392 unixFile *pFile = (unixFile *)id;
41401 assert( pFile->pPreallocatedUnused==0
41410 if( offset<pFile->mmapSize ){
41411 if( offset+amt <= pFile->mmapSize ){
41412 memcpy(pBuf, &((u8 *)(pFile->pMapRegion))[offset], amt);
41415 int nCopy = pFile->mmapSize - offset;
41416 memcpy(pBuf, &((u8 *)(pFile->pMapRegion))[offset], nCopy);
41424 got = seekAndRead(pFile, offset, pBuf, amt);
41435 switch( pFile->lastErrno ){
41448 storeLastErrno(pFile, 0); /* not a system error */
41523 unixFile *pFile = (unixFile*)id;
41531 assert( pFile->pPreallocatedUnused==0
41544 if( pFile->inNormalWrite ){
41545 pFile->dbUpdate = 1; /* The database has been modified */
41550 rc = seekAndRead(pFile, 24, oldCntr, 4);
41553 pFile->transCntrChng = 1; /* The transaction counter has changed */
41562 if( offset<pFile->mmapSize ){
41563 if( offset+amt <= pFile->mmapSize ){
41564 memcpy(&((u8 *)(pFile->pMapRegion))[offset], pBuf, amt);
41567 int nCopy = pFile->mmapSize - offset;
41568 memcpy(&((u8 *)(pFile->pMapRegion))[offset], pBuf, nCopy);
41576 while( (wrote = seekAndWrite(pFile, offset, pBuf, amt))<amt && wrote>0 ){
41585 if( wrote<0 && pFile->lastErrno!=ENOSPC ){
41589 storeLastErrno(pFile, 0); /* not a system error */
41787 unixFile *pFile = (unixFile*)id;
41802 assert( pFile );
41803 OSTRACE(("SYNC %-3d\n", pFile->h));
41804 rc = full_fsync(pFile->h, isFullsync, isDataOnly);
41807 storeLastErrno(pFile, errno);
41808 return unixLogError(SQLITE_IOERR_FSYNC, "full_fsync", pFile->zPath);
41815 if( pFile->ctrlFlags & UNIXFILE_DIRSYNC ){
41817 OSTRACE(("DIRSYNC %s (have_fullfsync=%d fullsync=%d)\n", pFile->zPath,
41819 rc = osOpenDirectory(pFile->zPath, &dirfd);
41822 robust_close(pFile, dirfd, __LINE__);
41827 pFile->ctrlFlags &= ~UNIXFILE_DIRSYNC;
41836 unixFile *pFile = (unixFile *)id;
41838 assert( pFile );
41846 if( pFile->szChunk>0 ){
41847 nByte = ((nByte + pFile->szChunk - 1)/pFile->szChunk) * pFile->szChunk;
41850 rc = robust_ftruncate(pFile->h, nByte);
41852 storeLastErrno(pFile, errno);
41853 return unixLogError(SQLITE_IOERR_TRUNCATE, "ftruncate", pFile->zPath);
41863 if( pFile->inNormalWrite && nByte==0 ){
41864 pFile->transCntrChng = 1;
41873 if( nByte<pFile->mmapSize ){
41874 pFile->mmapSize = nByte;
41923 static int fcntlSizeHint(unixFile *pFile, i64 nByte){
41924 if( pFile->szChunk>0 ){
41928 if( osFstat(pFile->h, &buf) ){
41932 nSize = ((nByte+pFile->szChunk-1) / pFile->szChunk) * pFile->szChunk;
41941 err = osFallocate(pFile->h, buf.st_size, nSize-buf.st_size);
41961 nWrite = seekAndWrite(pFile, iWrite, "", 1);
41969 if( pFile->mmapSizeMax>0 && nByte>pFile->mmapSize ){
41971 if( pFile->szChunk<=0 ){
41972 if( robust_ftruncate(pFile->h, nByte) ){
41973 storeLastErrno(pFile, errno);
41974 return unixLogError(SQLITE_IOERR_TRUNCATE, "ftruncate", pFile->zPath);
41978 rc = unixMapfile(pFile, nByte);
41992 static void unixModeBit(unixFile *pFile, unsigned char mask, int *pArg){
41994 *pArg = (pFile->ctrlFlags & mask)!=0;
41996 pFile->ctrlFlags &= ~mask;
41998 pFile->ctrlFlags |= mask;
42012 unixFile *pFile = (unixFile*)id;
42016 int rc = osIoctl(pFile->h, F2FS_IOC_START_ATOMIC_WRITE);
42020 int rc = osIoctl(pFile->h, F2FS_IOC_COMMIT_ATOMIC_WRITE);
42024 int rc = osIoctl(pFile->h, F2FS_IOC_ABORT_VOLATILE_WRITE);
42030 *(int*)pArg = pFile->eFileLock;
42034 *(int*)pArg = pFile->lastErrno;
42038 pFile->szChunk = *(int *)pArg;
42044 rc = fcntlSizeHint(pFile, *(i64 *)pArg);
42049 unixModeBit(pFile, UNIXFILE_PERSIST_WAL, (int*)pArg);
42053 unixModeBit(pFile, UNIXFILE_PSOW, (int*)pArg);
42057 *(char**)pArg = sqlite3_mprintf("%s", pFile->pVfs->zName);
42061 char *zTFile = sqlite3_malloc64( pFile->pVfs->mxPathname );
42063 unixGetTempname(pFile->pVfs->mxPathname, zTFile);
42069 *(int*)pArg = fileHasMoved(pFile);
42074 int iOld = pFile->iBusyTimeout;
42076 pFile->iBusyTimeout = *(int*)pArg;
42078 pFile->iBusyTimeout = !!(*(int*)pArg);
42101 *(i64*)pArg = pFile->mmapSizeMax;
42102 if( newLimit>=0 && newLimit!=pFile->mmapSizeMax && pFile->nFetchOut==0 ){
42103 pFile->mmapSizeMax = newLimit;
42104 if( pFile->mmapSize>0 ){
42105 unixUnmapfile(pFile);
42106 rc = unixMapfile(pFile, -1);
42177 static void setDeviceCharacteristics(unixFile *pFile){
42178 if( pFile->sectorSize == 0 ){
42182 pFile->sectorSize = SQLITE_DEFAULT_SECTOR_SIZE;
42183 pFile->deviceCharacteristics = 0;
42184 if( fstatvfs(pFile->h, &fsInfo) == -1 ) {
42189 pFile->sectorSize = fsInfo.f_bsize;
42190 pFile->deviceCharacteristics =
42198 pFile->sectorSize = fsInfo.f_bsize;
42199 pFile->deviceCharacteristics =
42201 (pFile->sectorSize / 512 * SQLITE_IOCAP_ATOMIC512) |
42208 pFile->sectorSize = fsInfo.f_bsize;
42209 pFile->deviceCharacteristics =
42217 pFile->sectorSize = fsInfo.f_bsize;
42218 pFile->deviceCharacteristics =
42220 ((pFile->sectorSize / 512 * SQLITE_IOCAP_ATOMIC512) << 1) - 2 |
42225 pFile->sectorSize = fsInfo.f_bsize;
42226 pFile->deviceCharacteristics =
42228 ((pFile->sectorSize / 512 * SQLITE_IOCAP_ATOMIC512) << 1) - 2 |
42233 pFile->deviceCharacteristics =
42242 if( pFile->sectorSize % 512 != 0 ){
42243 pFile->deviceCharacteristics = 0;
42244 pFile->sectorSize = SQLITE_DEFAULT_SECTOR_SIZE;
42411 static int unixFcntlExternalReader(unixFile *pFile, int *piOut){
42414 if( pFile->pShm){
42415 unixShmNode *pShmNode = pFile->pShm->pShmNode;
42444 unixFile *pFile, /* Open connection to the WAL file */
42453 pShmNode = pFile->pInode->pShmNode;
42490 res = osSetPosixAdvisoryLock(pShmNode->hShm, &f, pFile);
42493 rc = (pFile->iBusyTimeout ? SQLITE_BUSY_TIMEOUT : SQLITE_BUSY);
44271 sqlite3_file *pFile, /* The file descriptor to be filled in */
44275 unixFile *p = (unixFile *)pFile;
44482 ((unixFile*)pFile)->fsFlags |= SQLITE_FSFLAGS_IS_MSDOS;
44485 ((unixFile*)pFile)->fsFlags |= SQLITE_FSFLAGS_IS_MSDOS;
44513 rc = fillInUnixFile(pVfs, fd, pFile, zPath, ctrlFlags);
44515 rc = proxyTransformUnixFile((unixFile*)pFile, ":auto:");
44521 unixClose(pFile);
44533 rc = fillInUnixFile(pVfs, fd, pFile, zPath, ctrlFlags);
45364 static int proxyBreakConchLock(unixFile *pFile, uuid_t myHostID){
45365 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
45406 robust_close(pFile, conchFile->h, __LINE__);
45414 robust_close(pFile, fd, __LINE__);
45424 static int proxyConchLock(unixFile *pFile, uuid_t myHostID, int lockType){
45425 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
45444 storeLastErrno(pFile, errno);
45464 storeLastErrno(pFile, errno);
45481 if( 0==proxyBreakConchLock(pFile, myHostID) ){
45502 static int proxyTakeConch(unixFile *pFile){
45503 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
45527 storeLastErrno(pFile, pError);
45530 rc = proxyConchLock(pFile, myHostID, SHARED_LOCK);
45538 storeLastErrno(pFile, conchFile->lastErrno);
45608 rc = proxyConchLock(pFile, myHostID, EXCLUSIVE_LOCK);
45611 rc = proxyConchLock(pFile, myHostID, EXCLUSIVE_LOCK);
45634 int err = osFstat(pFile->h, &buf);
45663 OSTRACE(("TRANSPROXY: CLOSE %d\n", pFile->h));
45664 if( rc==SQLITE_OK && pFile->openFlags ){
45666 if( pFile->h>=0 ){
45667 robust_close(pFile, pFile->h, __LINE__);
45669 pFile->h = -1;
45670 fd = robust_open(pCtx->dbPath, pFile->openFlags, 0);
45673 pFile->h = fd;
45724 static int proxyReleaseConch(unixFile *pFile){
45729 pCtx = (proxyLockingContext *)pFile->lockingContext;
45791 static int switchLockProxyPath(unixFile *pFile, const char *path) {
45792 proxyLockingContext *pCtx = (proxyLockingContext*)pFile->lockingContext;
45796 if( pFile->eFileLock!=NO_LOCK ){
45827 static int proxyGetDbPathForUnixFile(unixFile *pFile, char *dbPath){
45829 if( pFile->pMethod == &afpIoMethods ){
45832 assert( (int)strlen((char*)pFile->lockingContext)<=MAXPATHLEN );
45833 strlcpy(dbPath, ((afpLockingContext *)pFile->lockingContext)->dbPath,
45837 if( pFile->pMethod == &dotlockIoMethods ){
45840 int len = strlen((char *)pFile->lockingContext) - strlen(DOTLOCK_SUFFIX);
45841 memcpy(dbPath, (char *)pFile->lockingContext, len + 1);
45844 assert( strlen((char*)pFile->lockingContext)<=MAXPATHLEN );
45845 strlcpy(dbPath, (char *)pFile->lockingContext, MAXPATHLEN);
45858 static int proxyTransformUnixFile(unixFile *pFile, const char *path) {
45864 if( pFile->eFileLock!=NO_LOCK ){
45867 proxyGetDbPathForUnixFile(pFile, dbPath);
45874 OSTRACE(("TRANSPROXY %d for %s pid=%d\n", pFile->h,
45886 if( rc==SQLITE_CANTOPEN && ((pFile->openFlags&O_RDWR) == 0) ){
45922 pCtx->oldLockingContext = pFile->lockingContext;
45923 pFile->lockingContext = pCtx;
45924 pCtx->pOldMethod = pFile->pMethod;
45925 pFile->pMethod = &proxyIoMethods;
45935 OSTRACE(("TRANSPROXY %d %s\n", pFile->h,
45948 unixFile *pFile = (unixFile*)id;
45949 if( pFile->pMethod == &proxyIoMethods ){
45950 proxyLockingContext *pCtx = (proxyLockingContext*)pFile->lockingContext;
45951 proxyTakeConch(pFile);
45963 unixFile *pFile = (unixFile*)id;
45965 int isProxyStyle = (pFile->pMethod == &proxyIoMethods);
45981 (proxyLockingContext*)pFile->lockingContext;
45988 rc = switchLockProxyPath(pFile, proxyPath);
45992 rc = proxyTransformUnixFile(pFile, proxyPath);
46019 unixFile *pFile = (unixFile*)id;
46020 int rc = proxyTakeConch(pFile);
46022 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
46058 unixFile *pFile = (unixFile*)id;
46059 int rc = proxyTakeConch(pFile);
46061 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
46065 pFile->eFileLock = proxy->eFileLock;
46082 unixFile *pFile = (unixFile*)id;
46083 int rc = proxyTakeConch(pFile);
46085 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
46089 pFile->eFileLock = proxy->eFileLock;
46102 unixFile *pFile = (unixFile*)id;
46103 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
46118 rc = proxyReleaseConch(pFile);
46129 pFile->lockingContext = pCtx->oldLockingContext;
46130 pFile->pMethod = pCtx->pOldMethod;
46132 return pFile->pMethod->xClose(id);
48551 static int winceCreateLock(const char *zFilename, winFile *pFile){
48565 memset(&pFile->local, 0, sizeof(pFile->local));
48575 pFile->hMutex = osCreateMutexW(NULL, FALSE, zName);
48576 if (!pFile->hMutex){
48577 pFile->lastErrno = osGetLastError();
48579 return winLogError(SQLITE_IOERR, pFile->lastErrno,
48584 winceMutexAcquire(pFile->hMutex);
48591 pFile->hShared = osCreateFileMappingW(INVALID_HANDLE_VALUE, NULL,
48605 if( pFile->hShared ){
48606 pFile->shared = (winceLock*)osMapViewOfFile(pFile->hShared,
48609 if( !pFile->shared ){
48610 pFile->lastErrno = osGetLastError();
48611 winLogError(SQLITE_IOERR, pFile->lastErrno,
48614 osCloseHandle(pFile->hShared);
48615 pFile->hShared = NULL;
48620 if( pFile->hShared==NULL ){
48622 pFile->lastErrno = lastErrno;
48623 winLogError(SQLITE_IOERR, pFile->lastErrno,
48627 winceMutexRelease(pFile->hMutex);
48628 osCloseHandle(pFile->hMutex);
48629 pFile->hMutex = NULL;
48635 memset(pFile->shared, 0, sizeof(winceLock));
48638 winceMutexRelease(pFile->hMutex);
48645 static void winceDestroyLock(winFile *pFile){
48646 if (pFile->hMutex){
48648 winceMutexAcquire(pFile->hMutex);
48652 if (pFile->local.nReaders){
48653 pFile->shared->nReaders --;
48655 if (pFile->local.bReserved){
48656 pFile->shared->bReserved = FALSE;
48658 if (pFile->local.bPending){
48659 pFile->shared->bPending = FALSE;
48661 if (pFile->local.bExclusive){
48662 pFile->shared->bExclusive = FALSE;
48666 osUnmapViewOfFile(pFile->shared);
48667 osCloseHandle(pFile->hShared);
48670 winceMutexRelease(pFile->hMutex);
48671 osCloseHandle(pFile->hMutex);
48672 pFile->hMutex = NULL;
48686 winFile *pFile = HANDLE_TO_WINFILE(phFile);
48692 if (!pFile->hMutex) return TRUE;
48693 winceMutexAcquire(pFile->hMutex);
48698 if (pFile->shared->nReaders == 0 && pFile->shared->bExclusive == 0){
48699 pFile->shared->bExclusive = TRUE;
48700 pFile->local.bExclusive = TRUE;
48708 if (pFile->shared->bExclusive == 0){
48709 pFile->local.nReaders ++;
48710 if (pFile->local.nReaders == 1){
48711 pFile->shared->nReaders ++;
48721 if (pFile->shared->bPending == 0) {
48722 pFile->shared->bPending = TRUE;
48723 pFile->local.bPending = TRUE;
48731 if (pFile->shared->bReserved == 0) {
48732 pFile->shared->bReserved = TRUE;
48733 pFile->local.bReserved = TRUE;
48738 winceMutexRelease(pFile->hMutex);
48752 winFile *pFile = HANDLE_TO_WINFILE(phFile);
48758 if (!pFile->hMutex) return TRUE;
48759 winceMutexAcquire(pFile->hMutex);
48764 if (pFile->local.bExclusive){
48766 pFile->local.bExclusive = FALSE;
48767 pFile->shared->bExclusive = FALSE;
48772 else if (pFile->local.nReaders){
48775 pFile->local.nReaders --;
48776 if (pFile->local.nReaders == 0)
48778 pFile->shared->nReaders --;
48787 if (pFile->local.bPending){
48788 pFile->local.bPending = FALSE;
48789 pFile->shared->bPending = FALSE;
48796 if (pFile->local.bReserved) {
48797 pFile->local.bReserved = FALSE;
48798 pFile->shared->bReserved = FALSE;
48803 winceMutexRelease(pFile->hMutex);
48891 static int winSeekFile(winFile *pFile, sqlite3_int64 iOffset){
48898 OSTRACE(("SEEK file=%p, offset=%lld\n", pFile->h, iOffset));
48910 dwRet = osSetFilePointer(pFile->h, lowerBits, &upperBits, FILE_BEGIN);
48914 pFile->lastErrno = lastErrno;
48915 winLogError(SQLITE_IOERR_SEEK, pFile->lastErrno,
48916 "winSeekFile", pFile->zPath);
48917 OSTRACE(("SEEK file=%p, rc=SQLITE_IOERR_SEEK\n", pFile->h));
48921 OSTRACE(("SEEK file=%p, rc=SQLITE_OK\n", pFile->h));
48932 bRet = osSetFilePointerEx(pFile->h, x, 0, FILE_BEGIN);
48935 pFile->lastErrno = osGetLastError();
48936 winLogError(SQLITE_IOERR_SEEK, pFile->lastErrno,
48937 "winSeekFile", pFile->zPath);
48938 OSTRACE(("SEEK file=%p, rc=SQLITE_IOERR_SEEK\n", pFile->h));
48942 OSTRACE(("SEEK file=%p, rc=SQLITE_OK\n", pFile->h));
48966 winFile *pFile = (winFile*)id;
48970 assert( pFile->pShm==0 );
48972 assert( pFile->h!=NULL && pFile->h!=INVALID_HANDLE_VALUE );
48974 osGetCurrentProcessId(), pFile, pFile->h));
48977 winUnmapfile(pFile);
48981 rc = osCloseHandle(pFile->h);
48987 winVfsAppData *pAppData = (winVfsAppData*)pFile->pVfs->pAppData;
48989 winceDestroyLock(pFile);
48992 if( pFile->zDeleteOnClose ){
48995 osDeleteFileW(pFile->zDeleteOnClose)==0
48996 && osGetFileAttributesW(pFile->zDeleteOnClose)!=0xffffffff
49001 sqlite3_free(pFile->zDeleteOnClose);
49005 pFile->h = NULL;
49009 osGetCurrentProcessId(), pFile, pFile->h, rc ? "ok" : "failed"));
49012 "winClose", pFile->zPath);
49029 winFile *pFile = (winFile*)id; /* file handle */
49038 "offset=%lld, lock=%d\n", osGetCurrentProcessId(), pFile,
49039 pFile->h, pBuf, amt, offset, pFile->locktype));
49044 if( offset<pFile->mmapSize ){
49045 if( offset+amt <= pFile->mmapSize ){
49046 memcpy(pBuf, &((u8 *)(pFile->pMapRegion))[offset], amt);
49048 osGetCurrentProcessId(), pFile, pFile->h));
49051 int nCopy = (int)(pFile->mmapSize - offset);
49052 memcpy(pBuf, &((u8 *)(pFile->pMapRegion))[offset], nCopy);
49061 if( winSeekFile(pFile, offset) ){
49063 osGetCurrentProcessId(), pFile, pFile->h));
49066 while( !osReadFile(pFile->h, pBuf, amt, &nRead, 0) ){
49071 while( !osReadFile(pFile->h, pBuf, amt, &nRead, &overlapped) &&
49076 pFile->lastErrno = lastErrno;
49078 osGetCurrentProcessId(), pFile, pFile->h));
49079 return winLogError(SQLITE_IOERR_READ, pFile->lastErrno,
49080 "winRead", pFile->zPath);
49087 osGetCurrentProcessId(), pFile, pFile->h));
49092 osGetCurrentProcessId(), pFile, pFile->h));
49107 winFile *pFile = (winFile*)id; /* File handle */
49111 assert( pFile );
49116 "offset=%lld, lock=%d\n", osGetCurrentProcessId(), pFile,
49117 pFile->h, pBuf, amt, offset, pFile->locktype));
49122 if( offset<pFile->mmapSize ){
49123 if( offset+amt <= pFile->mmapSize ){
49124 memcpy(&((u8 *)(pFile->pMapRegion))[offset], pBuf, amt);
49126 osGetCurrentProcessId(), pFile, pFile->h));
49129 int nCopy = (int)(pFile->mmapSize - offset);
49130 memcpy(&((u8 *)(pFile->pMapRegion))[offset], pBuf, nCopy);
49139 rc = winSeekFile(pFile, offset);
49160 if( !osWriteFile(pFile->h, aRem, nRem, &nWrite, 0) ){
49162 if( !osWriteFile(pFile->h, aRem, nRem, &nWrite, &overlapped) ){
49181 pFile->lastErrno = lastErrno;
49187 if( ( pFile->lastErrno==ERROR_HANDLE_DISK_FULL )
49188 || ( pFile->lastErrno==ERROR_DISK_FULL )){
49190 osGetCurrentProcessId(), pFile, pFile->h));
49191 return winLogError(SQLITE_FULL, pFile->lastErrno,
49192 "winWrite1", pFile->zPath);
49195 osGetCurrentProcessId(), pFile, pFile->h));
49196 return winLogError(SQLITE_IOERR_WRITE, pFile->lastErrno,
49197 "winWrite2", pFile->zPath);
49202 osGetCurrentProcessId(), pFile, pFile->h));
49210 winFile *pFile = (winFile*)id; /* File handle object */
49215 if( pFile->nFetchOut>0 ){
49237 assert( pFile );
49240 osGetCurrentProcessId(), pFile, pFile->h, nByte, pFile->locktype));
49247 if( pFile->szChunk>0 ){
49248 nByte = ((nByte + pFile->szChunk - 1)/pFile->szChunk) * pFile->szChunk;
49252 if( pFile->pMapRegion ){
49253 oldMmapSize = pFile->mmapSize;
49257 winUnmapfile(pFile);
49261 if( winSeekFile(pFile, nByte) ){
49262 rc = winLogError(SQLITE_IOERR_TRUNCATE, pFile->lastErrno,
49263 "winTruncate1", pFile->zPath);
49264 }else if( 0==osSetEndOfFile(pFile->h) &&
49266 pFile->lastErrno = lastErrno;
49267 rc = winLogError(SQLITE_IOERR_TRUNCATE, pFile->lastErrno,
49268 "winTruncate2", pFile->zPath);
49274 winMapfile(pFile, -1);
49276 winMapfile(pFile, oldMmapSize);
49282 osGetCurrentProcessId(), pFile, pFile->h, sqlite3ErrName(rc)));
49311 winFile *pFile = (winFile*)id;
49316 assert( pFile );
49328 osGetCurrentProcessId(), pFile, pFile->h, flags,
49329 pFile->locktype));
49345 osGetCurrentProcessId(), pFile, pFile->h));
49349 if( pFile->pMapRegion ){
49350 if( osFlushViewOfFile(pFile->pMapRegion, 0) ){
49353 pFile, pFile->pMapRegion));
49355 pFile->lastErrno = osGetLastError();
49358 pFile, pFile->pMapRegion));
49359 return winLogError(SQLITE_IOERR_MMAP, pFile->lastErrno,
49360 "winSync1", pFile->zPath);
49364 rc = osFlushFileBuffers(pFile->h);
49368 osGetCurrentProcessId(), pFile, pFile->h));
49371 pFile->lastErrno = osGetLastError();
49373 osGetCurrentProcessId(), pFile, pFile->h));
49374 return winLogError(SQLITE_IOERR_FSYNC, pFile->lastErrno,
49375 "winSync2", pFile->zPath);
49384 winFile *pFile = (winFile*)id;
49390 OSTRACE(("SIZE file=%p, pSize=%p\n", pFile->h, pSize));
49395 if( osGetFileInformationByHandleEx(pFile->h, FileStandardInfo,
49399 pFile->lastErrno = osGetLastError();
49400 rc = winLogError(SQLITE_IOERR_FSTAT, pFile->lastErrno,
49401 "winFileSize", pFile->zPath);
49410 lowerBits = osGetFileSize(pFile->h, &upperBits);
49414 pFile->lastErrno = lastErrno;
49415 rc = winLogError(SQLITE_IOERR_FSTAT, pFile->lastErrno,
49416 "winFileSize", pFile->zPath);
49421 pFile->h, pSize, *pSize, sqlite3ErrName(rc)));
49461 static int winGetReadLock(winFile *pFile){
49463 OSTRACE(("READ-LOCK file=%p, lock=%d\n", pFile->h, pFile->locktype));
49470 res = winceLockFile(&pFile->h, SHARED_FIRST, 0, 1, 0);
49472 res = winLockFile(&pFile->h, SQLITE_LOCKFILEEX_FLAGS, SHARED_FIRST, 0,
49480 pFile->sharedLockByte = (short)((lk & 0x7fffffff)%(SHARED_SIZE - 1));
49481 res = winLockFile(&pFile->h, SQLITE_LOCKFILE_FLAGS,
49482 SHARED_FIRST+pFile->sharedLockByte, 0, 1, 0);
49486 pFile->lastErrno = osGetLastError();
49489 OSTRACE(("READ-LOCK file=%p, result=%d\n", pFile->h, res));
49496 static int winUnlockReadLock(winFile *pFile){
49499 OSTRACE(("READ-UNLOCK file=%p, lock=%d\n", pFile->h, pFile->locktype));
49501 res = winUnlockFile(&pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0);
49505 res = winUnlockFile(&pFile->h, SHARED_FIRST+pFile->sharedLockByte, 0, 1, 0);
49509 pFile->lastErrno = lastErrno;
49510 winLogError(SQLITE_IOERR_UNLOCK, pFile->lastErrno,
49511 "winUnlockReadLock", pFile->zPath);
49513 OSTRACE(("READ-UNLOCK file=%p, result=%d\n", pFile->h, res));
49548 winFile *pFile = (winFile*)id;
49553 pFile->h, pFile->locktype, pFile->sharedLockByte, locktype));
49559 if( pFile->locktype>=locktype ){
49560 OSTRACE(("LOCK-HELD file=%p, rc=SQLITE_OK\n", pFile->h));
49566 if( (pFile->ctrlFlags & WINFILE_RDONLY)!=0 && locktype>=RESERVED_LOCK ){
49572 assert( pFile->locktype!=NO_LOCK || locktype==SHARED_LOCK );
49574 assert( locktype!=RESERVED_LOCK || pFile->locktype==SHARED_LOCK );
49580 newLocktype = pFile->locktype;
49581 if( pFile->locktype==NO_LOCK
49582 || (locktype==EXCLUSIVE_LOCK && pFile->locktype<=RESERVED_LOCK)
49585 while( cnt-->0 && (res = winLockFile(&pFile->h, SQLITE_LOCKFILE_FLAGS,
49595 pFile->h, cnt, res));
49597 pFile->lastErrno = lastErrno;
49600 pFile->h, cnt, sqlite3ErrName(rc)));
49614 assert( pFile->locktype==NO_LOCK );
49615 res = winGetReadLock(pFile);
49626 assert( pFile->locktype==SHARED_LOCK );
49627 res = winLockFile(&pFile->h, SQLITE_LOCKFILE_FLAGS, RESERVED_BYTE, 0, 1, 0);
49645 assert( pFile->locktype>=SHARED_LOCK );
49646 (void)winUnlockReadLock(pFile);
49647 res = winLockFile(&pFile->h, SQLITE_LOCKFILE_FLAGS, SHARED_FIRST, 0,
49653 winGetReadLock(pFile);
49661 winUnlockFile(&pFile->h, PENDING_BYTE, 0, 1, 0);
49670 pFile->lastErrno = lastErrno;
49673 pFile->h, locktype, newLocktype));
49675 pFile->locktype = (u8)newLocktype;
49677 pFile->h, pFile->locktype, sqlite3ErrName(rc)));
49688 winFile *pFile = (winFile*)id;
49691 OSTRACE(("TEST-WR-LOCK file=%p, pResOut=%p\n", pFile->h, pResOut));
49694 if( pFile->locktype>=RESERVED_LOCK ){
49696 OSTRACE(("TEST-WR-LOCK file=%p, result=%d (local)\n", pFile->h, res));
49698 res = winLockFile(&pFile->h, SQLITE_LOCKFILEEX_FLAGS,RESERVED_BYTE,0,1,0);
49700 winUnlockFile(&pFile->h, RESERVED_BYTE, 0, 1, 0);
49703 OSTRACE(("TEST-WR-LOCK file=%p, result=%d (remote)\n", pFile->h, res));
49707 pFile->h, pResOut, *pResOut));
49724 winFile *pFile = (winFile*)id;
49726 assert( pFile!=0 );
49729 pFile->h, pFile->locktype, pFile->sharedLockByte, locktype));
49730 type = pFile->locktype;
49732 winUnlockFile(&pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0);
49733 if( locktype==SHARED_LOCK && !winGetReadLock(pFile) ){
49737 "winUnlock", pFile->zPath);
49741 winUnlockFile(&pFile->h, RESERVED_BYTE, 0, 1, 0);
49744 winUnlockReadLock(pFile);
49747 winUnlockFile(&pFile->h, PENDING_BYTE, 0, 1, 0);
49749 pFile->locktype = (u8)locktype;
49751 pFile->h, pFile->locktype, sqlite3ErrName(rc)));
49799 static void winModeBit(winFile *pFile, unsigned char mask, int *pArg){
49801 *pArg = (pFile->ctrlFlags & mask)!=0;
49803 pFile->ctrlFlags &= ~mask;
49805 pFile->ctrlFlags |= mask;
49819 winFile *pFile = (winFile*)id;
49820 OSTRACE(("FCNTL file=%p, op=%d, pArg=%p\n", pFile->h, op, pArg));
49823 *(int*)pArg = pFile->locktype;
49824 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
49828 *(int*)pArg = (int)pFile->lastErrno;
49829 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
49833 pFile->szChunk = *(int *)pArg;
49834 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
49838 if( pFile->szChunk>0 ){
49849 OSTRACE(("FCNTL file=%p, rc=%s\n", pFile->h, sqlite3ErrName(rc)));
49852 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
49856 winModeBit(pFile, WINFILE_PERSIST_WAL, (int*)pArg);
49857 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
49861 winModeBit(pFile, WINFILE_PSOW, (int*)pArg);
49862 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
49866 *(char**)pArg = sqlite3_mprintf("%s", pFile->pVfs->zName);
49867 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
49882 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
49887 *phFile = pFile->h;
49888 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
49894 HANDLE hOldFile = pFile->h;
49895 pFile->h = *phFile;
49898 hOldFile, pFile->h));
49904 int rc = winGetTempname(pFile->pVfs, &zTFile);
49908 OSTRACE(("FCNTL file=%p, rc=%s\n", pFile->h, sqlite3ErrName(rc)));
49926 *(i64*)pArg = pFile->mmapSizeMax;
49927 if( newLimit>=0 && newLimit!=pFile->mmapSizeMax && pFile->nFetchOut==0 ){
49928 pFile->mmapSizeMax = newLimit;
49929 if( pFile->mmapSize>0 ){
49930 winUnmapfile(pFile);
49931 rc = winMapfile(pFile, -1);
49934 OSTRACE(("FCNTL file=%p, rc=%s\n", pFile->h, sqlite3ErrName(rc)));
49939 OSTRACE(("FCNTL file=%p, rc=SQLITE_NOTFOUND\n", pFile->h));
50094 winShmNode *pFile, /* Apply locks to this open shared-memory segment */
50102 assert( pFile->nRef==0 || sqlite3_mutex_held(pFile->mutex) );
50105 pFile->hFile.h, lockType, ofst, nByte));
50109 rc = winUnlockFile(&pFile->hFile.h, ofst, 0, nByte, 0);
50114 rc = winLockFile(&pFile->hFile.h, dwFlags, ofst, 0, nByte, 0);
50120 pFile->lastErrno = osGetLastError();
50125 pFile->hFile.h, (lockType == WINSHM_UNLCK) ? "winUnlockFile" :
50126 "winLockFile", pFile->lastErrno, sqlite3ErrName(rc)));
50666 static int winUnmapfile(winFile *pFile){
50667 assert( pFile!=0 );
50670 osGetCurrentProcessId(), pFile, pFile->hMap, pFile->pMapRegion,
50671 pFile->mmapSize, pFile->mmapSizeMax));
50672 if( pFile->pMapRegion ){
50673 if( !osUnmapViewOfFile(pFile->pMapRegion) ){
50674 pFile->lastErrno = osGetLastError();
50676 "rc=SQLITE_IOERR_MMAP\n", osGetCurrentProcessId(), pFile,
50677 pFile->pMapRegion));
50678 return winLogError(SQLITE_IOERR_MMAP, pFile->lastErrno,
50679 "winUnmapfile1", pFile->zPath);
50681 pFile->pMapRegion = 0;
50682 pFile->mmapSize = 0;
50684 if( pFile->hMap!=NULL ){
50685 if( !osCloseHandle(pFile->hMap) ){
50686 pFile->lastErrno = osGetLastError();
50688 osGetCurrentProcessId(), pFile, pFile->hMap));
50689 return winLogError(SQLITE_IOERR_MMAP, pFile->lastErrno,
50690 "winUnmapfile2", pFile->zPath);
50692 pFile->hMap = NULL;
50695 osGetCurrentProcessId(), pFile));
51339 winFile *pFile = (winFile*)id;
51397 assert( pFile!=0 );
51398 memset(pFile, 0, sizeof(winFile));
51399 pFile->h = INVALID_HANDLE_VALUE;
51567 pFile->lastErrno = lastErrno;
51568 winLogError(SQLITE_CANTOPEN, pFile->lastErrno, "winOpen", zUtf8Name);
51591 && (rc = winceCreateLock(zName, pFile))!=SQLITE_OK
51601 pFile->zDeleteOnClose = zConverted;
51610 pFile->pVfs = pVfs;
51611 pFile->h = h;
51613 pFile->ctrlFlags |= WINFILE_RDONLY;
51618 pFile->ctrlFlags |= WINFILE_PSOW;
51620 pFile->lastErrno = NO_ERROR;
51621 pFile->zPath = zName;
51623 pFile->hMap = NULL;
51624 pFile->pMapRegion = 0;
51625 pFile->mmapSize = 0;
51626 pFile->mmapSizeMax = sqlite3GlobalConfig.szMmap;
52724 static int memdbClose(sqlite3_file *pFile){
52725 MemStore *p = ((MemFile*)pFile)->pStore;
52767 sqlite3_file *pFile,
52772 MemStore *p = ((MemFile*)pFile)->pStore;
52809 sqlite3_file *pFile,
52814 MemStore *p = ((MemFile*)pFile)->pStore;
52845 static int memdbTruncate(sqlite3_file *pFile, sqlite_int64 size){
52846 MemStore *p = ((MemFile*)pFile)->pStore;
52862 static int memdbSync(sqlite3_file *pFile, int flags){
52863 UNUSED_PARAMETER(pFile);
52871 static int memdbFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){
52872 MemStore *p = ((MemFile*)pFile)->pStore;
52882 static int memdbLock(sqlite3_file *pFile, int eLock){
52883 MemFile *pThis = (MemFile*)pFile;
52940 static int memdbUnlock(sqlite3_file *pFile, int eLock){
52941 MemFile *pThis = (MemFile*)pFile;
52968 static int memdbCheckReservedLock(sqlite3_file *pFile, int *pResOut){
52978 static int memdbFileControl(sqlite3_file *pFile, int op, void *pArg){
52979 MemStore *p = ((MemFile*)pFile)->pStore;
53007 static int memdbSectorSize(sqlite3_file *pFile){
53015 static int memdbDeviceCharacteristics(sqlite3_file *pFile){
53016 UNUSED_PARAMETER(pFile);
53025 sqlite3_file *pFile,
53030 MemStore *p = ((MemFile*)pFile)->pStore;
53043 static int memdbUnfetch(sqlite3_file *pFile, sqlite3_int64 iOfst, void *pPage){
53044 MemStore *p = ((MemFile*)pFile)->pStore;
53063 MemFile *pFile = (MemFile*)pFd;
53068 memset(pFile, 0, sizeof(*pFile));
53126 pFile->pStore = p;
59432 SQLITE_PRIVATE int sqlite3SectorSize(sqlite3_file *pFile){
59433 int iRet = sqlite3OsSectorSize(pFile);
60411 sqlite3_file *pFile, /* Write the file descriptor here */
60422 rc = sqlite3OsOpen(pPager->pVfs, 0, pFile, vfsFlags, 0);
60423 assert( rc!=SQLITE_OK || isOpen(pFile) );
72929 sqlite3_file *pFile;
72939 pFile = sqlite3PagerFile(pBt->pPager);
72940 if( pFile->pMethods ){
72941 sqlite3OsFileControlHint(pFile, SQLITE_FCNTL_PDB, (void*)&pBt->db);
81861 static int backupTruncateFile(sqlite3_file *pFile, i64 iSize){
81863 int rc = sqlite3OsFileSize(pFile, &iCurrent);
81865 rc = sqlite3OsTruncate(pFile, iSize);
82043 sqlite3_file * const pFile = sqlite3PagerFile(pDestPager);
82049 assert( pFile );
82089 rc = sqlite3OsWrite(pFile, zData, pgszSrc, iOff);
82094 rc = backupTruncateFile(pFile, iSize);
102874 static int vdbeSorterMapFile(SortSubtask *pTask, SorterFile *pFile, u8 **pp){
102876 if( pFile->iEof<=(i64)(pTask->pSorter->db->nMaxSorterMmap) ){
102877 sqlite3_file *pFd = pFile->pFd;
102879 rc = sqlite3OsFetch(pFd, 0, (int)pFile->iEof, (void**)pp);
102894 SorterFile *pFile, /* Sorter file to read from */
102907 pReadr->iEof = pFile->iEof;
102908 pReadr->pFd = pFile->pFd;
102910 rc = vdbeSorterMapFile(pTask, pFile, &pReadr->aMap);
102987 SorterFile *pFile, /* Sorter file to read from */
102994 assert( pFile->iEof>iStart );
102999 rc = vdbePmaReaderSeek(pTask, pReadr, pFile, iStart);
138818 sqlite3_file *pFile = sqlite3PagerFile(pPager);
138819 sqlite3OsFileControlHint(pFile, SQLITE_GET_LOCKPROXYFILE,
138824 sqlite3_file *pFile = sqlite3PagerFile(pPager);
138827 res=sqlite3OsFileControl(pFile, SQLITE_SET_LOCKPROXYFILE,
138830 res=sqlite3OsFileControl(pFile, SQLITE_SET_LOCKPROXYFILE,
220870 static int rbuVfsClose(sqlite3_file *pFile){
220871 rbu_file *p = (rbu_file*)pFile;
220933 sqlite3_file *pFile,
220938 rbu_file *p = (rbu_file*)pFile;
220999 sqlite3_file *pFile,
221004 rbu_file *p = (rbu_file*)pFile;
221041 static int rbuVfsTruncate(sqlite3_file *pFile, sqlite_int64 size){
221042 rbu_file *p = (rbu_file*)pFile;
221053 static int rbuVfsSync(sqlite3_file *pFile, int flags){
221054 rbu_file *p = (rbu_file *)pFile;
221067 static int rbuVfsFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){
221068 rbu_file *p = (rbu_file *)pFile;
221088 static int rbuVfsLock(sqlite3_file *pFile, int eLock){
221089 rbu_file *p = (rbu_file*)pFile;
221110 static int rbuVfsUnlock(sqlite3_file *pFile, int eLock){
221111 rbu_file *p = (rbu_file *)pFile;
221118 static int rbuVfsCheckReservedLock(sqlite3_file *pFile, int *pResOut){
221119 rbu_file *p = (rbu_file *)pFile;
221126 static int rbuVfsFileControl(sqlite3_file *pFile, int op, void *pArg){
221127 rbu_file *p = (rbu_file *)pFile;
221182 static int rbuVfsSectorSize(sqlite3_file *pFile){
221183 rbu_file *p = (rbu_file *)pFile;
221190 static int rbuVfsDeviceCharacteristics(sqlite3_file *pFile){
221191 rbu_file *p = (rbu_file *)pFile;
221198 static int rbuVfsShmLock(sqlite3_file *pFile, int ofst, int n, int flags){
221199 rbu_file *p = (rbu_file*)pFile;
221237 sqlite3_file *pFile,
221243 rbu_file *p = (rbu_file*)pFile;
221294 static void rbuVfsShmBarrier(sqlite3_file *pFile){
221295 rbu_file *p = (rbu_file *)pFile;
221302 static int rbuVfsShmUnmap(sqlite3_file *pFile, int delFlag){
221303 rbu_file *p = (rbu_file*)pFile;
221324 sqlite3_file *pFile,
221369 rbu_file *pFd = (rbu_file *)pFile;
221426 pFile->pMethods = &rbuvfs_io_methods1;
221428 pFile->pMethods = &rbuvfs_io_methods;