Lines Matching refs:pFile
26255 sqlite3_file *pFile, in sqlite3OsOpen() argument
26266 rc = pVfs->xOpen(pVfs, zPath, pFile, flags & 0x1087f7f, pFlagsOut); in sqlite3OsOpen()
26267 assert( rc==SQLITE_OK || pFile->pMethods==0 ); in sqlite3OsOpen()
26353 sqlite3_file *pFile; in sqlite3OsOpenMalloc() local
26354 pFile = (sqlite3_file *)sqlite3MallocZero(pVfs->szOsFile); in sqlite3OsOpenMalloc()
26355 if( pFile ){ in sqlite3OsOpenMalloc()
26356 rc = sqlite3OsOpen(pVfs, zFile, pFile, flags, pOutFlags); in sqlite3OsOpenMalloc()
26358 sqlite3_free(pFile); in sqlite3OsOpenMalloc()
26361 *ppFile = pFile; in sqlite3OsOpenMalloc()
26370 SQLITE_PRIVATE void sqlite3OsCloseFree(sqlite3_file *pFile){ in sqlite3OsCloseFree() argument
26371 assert( pFile ); in sqlite3OsCloseFree()
26372 sqlite3OsClose(pFile); in sqlite3OsCloseFree()
26373 sqlite3_free(pFile); in sqlite3OsCloseFree()
37820 KVVfsFile *pFile, /* Store decoding in pFile->aJrnl */
37832 sqlite3_free(pFile->aJrnl);
37833 pFile->aJrnl = sqlite3_malloc64( n );
37834 if( pFile->aJrnl==0 ){
37835 pFile->nJrnl = 0;
37838 pFile->nJrnl = n;
37839 n = kvvfsDecode(zTxt+i, pFile->aJrnl, pFile->nJrnl);
37840 if( n<pFile->nJrnl ){
37841 sqlite3_free(pFile->aJrnl);
37842 pFile->aJrnl = 0;
37843 pFile->nJrnl = 0;
37850 static sqlite3_int64 kvvfsReadFileSize(KVVfsFile *pFile){
37853 sqlite3KvvfsMethods.xRead(pFile->zClass, "sz", zData, sizeof(zData)-1);
37856 static int kvvfsWriteFileSize(KVVfsFile *pFile, sqlite3_int64 sz){
37859 return sqlite3KvvfsMethods.xWrite(pFile->zClass, "sz", zData);
37868 KVVfsFile *pFile = (KVVfsFile *)pProtoFile;
37870 SQLITE_KV_LOG(("xClose %s %s\n", pFile->zClass,
37871 pFile->isJournal ? "journal" : "db"));
37872 sqlite3_free(pFile->aJrnl);
37873 sqlite3_free(pFile->aData);
37886 KVVfsFile *pFile = (KVVfsFile*)pProtoFile;
37887 assert( pFile->isJournal );
37888 SQLITE_KV_LOG(("xRead('%s-journal',%d,%lld)\n", pFile->zClass, iAmt, iOfst));
37889 if( pFile->aJrnl==0 ){
37890 int szTxt = kvstorageRead(pFile->zClass, "jrnl", 0, 0);
37897 kvstorageRead(pFile->zClass, "jrnl", aTxt, szTxt+1);
37898 kvvfsDecodeJournal(pFile, aTxt, szTxt);
37900 if( pFile->aJrnl==0 ) return SQLITE_IOERR;
37902 if( iOfst+iAmt>pFile->nJrnl ){
37905 memcpy(zBuf, pFile->aJrnl+iOfst, iAmt);
37918 KVVfsFile *pFile = (KVVfsFile*)pProtoFile;
37922 char *aData = pFile->aData;
37925 SQLITE_KV_LOG(("xRead('%s-db',%d,%lld)\n", pFile->zClass, iAmt, iOfst));
37933 pFile->szPage = iAmt;
37939 got = sqlite3KvvfsMethods.xRead(pFile->zClass, zKey,
37976 KVVfsFile *pFile = (KVVfsFile*)pProtoFile;
37978 SQLITE_KV_LOG(("xWrite('%s-journal',%d,%lld)\n", pFile->zClass, iAmt, iOfst));
37980 if( pFile->aJrnl==0 || pFile->nJrnl<iEnd ){
37981 char *aNew = sqlite3_realloc(pFile->aJrnl, iEnd);
37985 pFile->aJrnl = aNew;
37986 if( pFile->nJrnl<iOfst ){
37987 memset(pFile->aJrnl+pFile->nJrnl, 0, iOfst-pFile->nJrnl);
37989 pFile->nJrnl = iEnd;
37991 memcpy(pFile->aJrnl+iOfst, zBuf, iAmt);
38004 KVVfsFile *pFile = (KVVfsFile*)pProtoFile;
38007 char *aData = pFile->aData;
38008 SQLITE_KV_LOG(("xWrite('%s-db',%d,%lld)\n", pFile->zClass, iAmt, iOfst));
38011 assert( pFile->szPage<0 || pFile->szPage==iAmt );
38012 pFile->szPage = iAmt;
38016 if( sqlite3KvvfsMethods.xWrite(pFile->zClass, zKey, aData) ){
38019 if( iOfst+iAmt > pFile->szDb ){
38020 pFile->szDb = iOfst + iAmt;
38029 KVVfsFile *pFile = (KVVfsFile *)pProtoFile;
38030 SQLITE_KV_LOG(("xTruncate('%s-journal',%lld)\n", pFile->zClass, size));
38032 sqlite3KvvfsMethods.xDelete(pFile->zClass, "jrnl");
38033 sqlite3_free(pFile->aJrnl);
38034 pFile->aJrnl = 0;
38035 pFile->nJrnl = 0;
38039 KVVfsFile *pFile = (KVVfsFile *)pProtoFile;
38040 if( pFile->szDb>size
38041 && pFile->szPage>0
38042 && (size % pFile->szPage)==0
38046 SQLITE_KV_LOG(("xTruncate('%s-db',%lld)\n", pFile->zClass, size));
38047 pgno = 1 + size/pFile->szPage;
38048 pgnoMax = 2 + pFile->szDb/pFile->szPage;
38051 sqlite3KvvfsMethods.xDelete(pFile->zClass, zKey);
38054 pFile->szDb = size;
38055 return kvvfsWriteFileSize(pFile, size) ? SQLITE_IOERR : SQLITE_OK;
38065 KVVfsFile *pFile = (KVVfsFile *)pProtoFile;
38067 SQLITE_KV_LOG(("xSync('%s-journal')\n", pFile->zClass));
38068 if( pFile->nJrnl<=0 ){
38071 zOut = sqlite3_malloc64( pFile->nJrnl*2 + 50 );
38075 n = pFile->nJrnl;
38082 kvvfsEncode(pFile->aJrnl, pFile->nJrnl, &zOut[i]);
38083 i = sqlite3KvvfsMethods.xWrite(pFile->zClass, "jrnl", zOut);
38095 KVVfsFile *pFile = (KVVfsFile *)pProtoFile;
38096 SQLITE_KV_LOG(("xFileSize('%s-journal')\n", pFile->zClass));
38097 *pSize = pFile->nJrnl;
38101 KVVfsFile *pFile = (KVVfsFile *)pProtoFile;
38102 SQLITE_KV_LOG(("xFileSize('%s-db')\n", pFile->zClass));
38103 if( pFile->szDb>=0 ){
38104 *pSize = pFile->szDb;
38106 *pSize = kvvfsReadFileSize(pFile);
38115 KVVfsFile *pFile = (KVVfsFile *)pProtoFile;
38116 assert( !pFile->isJournal );
38117 SQLITE_KV_LOG(("xLock(%s,%d)\n", pFile->zClass, eLock));
38120 pFile->szDb = kvvfsReadFileSize(pFile);
38129 KVVfsFile *pFile = (KVVfsFile *)pProtoFile;
38130 assert( !pFile->isJournal );
38131 SQLITE_KV_LOG(("xUnlock(%s,%d)\n", pFile->zClass, eLock));
38133 pFile->szDb = -1;
38157 KVVfsFile *pFile = (KVVfsFile *)pProtoFile;
38159 SQLITE_KV_LOG(("xSync('%s-db')\n", pFile->zClass));
38160 if( pFile->szDb>0 && 0!=kvvfsWriteFileSize(pFile, pFile->szDb) ){
38171 static int kvvfsSectorSize(sqlite3_file *pFile){
38194 KVVfsFile *pFile = (KVVfsFile*)pProtoFile;
38200 pFile->isJournal = 0;
38201 pFile->base.pMethods = &kvvfs_db_io_methods;
38206 pFile->isJournal = 1;
38207 pFile->base.pMethods = &kvvfs_jrnl_io_methods;
38212 pFile->zClass = "session";
38214 pFile->zClass = "local";
38216 pFile->aData = sqlite3_malloc64(SQLITE_KVOS_SZ);
38217 if( pFile->aData==0 ){
38220 pFile->aJrnl = 0;
38221 pFile->nJrnl = 0;
38222 pFile->szPage = -1;
38223 pFile->szDb = -1;
39600 int unixFileMutexHeld(unixFile *pFile){
39601 assert( pFile->pInode );
39602 return sqlite3_mutex_held(pFile->pInode->pLockMutex);
39604 int unixFileMutexNotheld(unixFile *pFile){
39605 assert( pFile->pInode );
39606 return sqlite3_mutex_notheld(pFile->pInode->pLockMutex);
39696 static void robust_close(unixFile *pFile, int h, int lineno){
39699 pFile ? pFile->zPath : 0, lineno);
39707 static void storeLastErrno(unixFile *pFile, int error){
39708 pFile->lastErrno = error;
39714 static void closePendingFds(unixFile *pFile){
39715 unixInodeInfo *pInode = pFile->pInode;
39718 assert( unixFileMutexHeld(pFile) );
39721 robust_close(pFile, p->fd, __LINE__);
39733 static void releaseInodeInfo(unixFile *pFile){
39734 unixInodeInfo *pInode = pFile->pInode;
39736 assert( unixFileMutexNotheld(pFile) );
39742 closePendingFds(pFile);
39771 unixFile *pFile, /* Unix file with file desc used in the key */
39785 fd = pFile->h;
39788 storeLastErrno(pFile, errno);
39790 if( pFile->lastErrno==EOVERFLOW ) return SQLITE_NOLFS;
39806 if( statbuf.st_size==0 && (pFile->fsFlags & SQLITE_FSFLAGS_IS_MSDOS)!=0 ){
39809 storeLastErrno(pFile, errno);
39814 storeLastErrno(pFile, errno);
39823 fileId.pId = pFile->pId;
39862 static int fileHasMoved(unixFile *pFile){
39864 return pFile->pInode!=0 && pFile->pId!=pFile->pInode->fileId.pId;
39867 return pFile->pInode!=0 &&
39868 (osStat(pFile->zPath, &buf)!=0
39869 || (u64)buf.st_ino!=pFile->pInode->fileId.ino);
39883 static void verifyDbFile(unixFile *pFile){
39888 if( pFile->ctrlFlags & UNIXFILE_NOLOCK ) return;
39890 rc = osFstat(pFile->h, &buf);
39892 sqlite3_log(SQLITE_WARNING, "cannot fstat db file %s", pFile->zPath);
39896 sqlite3_log(SQLITE_WARNING, "file unlinked while open: %s", pFile->zPath);
39900 sqlite3_log(SQLITE_WARNING, "multiple links to file: %s", pFile->zPath);
39903 if( fileHasMoved(pFile) ){
39904 sqlite3_log(SQLITE_WARNING, "file renamed while open: %s", pFile->zPath);
39919 unixFile *pFile = (unixFile*)id;
39923 assert( pFile );
39924 assert( pFile->eFileLock<=SHARED_LOCK );
39925 sqlite3_mutex_enter(pFile->pInode->pLockMutex);
39928 if( pFile->pInode->eFileLock>SHARED_LOCK ){
39935 if( !reserved && !pFile->pInode->bProcessLock ){
39941 if( osFcntl(pFile->h, F_GETLK, &lock) ){
39943 storeLastErrno(pFile, errno);
39950 sqlite3_mutex_leave(pFile->pInode->pLockMutex);
39951 OSTRACE(("TEST WR-LOCK %d %d %d (unix)\n", pFile->h, rc, reserved));
39979 unixFile *pFile /* Structure holding timeout value */
39981 int tm = pFile->iBusyTimeout;
40017 static int unixFileLock(unixFile *pFile, struct flock *pLock){
40019 unixInodeInfo *pInode = pFile->pInode;
40022 if( (pFile->ctrlFlags & (UNIXFILE_EXCL|UNIXFILE_RDONLY))==UNIXFILE_EXCL ){
40030 rc = osSetPosixAdvisoryLock(pFile->h, &lock, pFile);
40038 rc = osSetPosixAdvisoryLock(pFile->h, pLock, pFile);
40109 unixFile *pFile = (unixFile*)id;
40114 assert( pFile );
40115 OSTRACE(("LOCK %d %s was %s(%s,%d) pid=%d (unix)\n", pFile->h,
40116 azFileLock(eFileLock), azFileLock(pFile->eFileLock),
40117 azFileLock(pFile->pInode->eFileLock), pFile->pInode->nShared,
40124 if( pFile->eFileLock>=eFileLock ){
40125 OSTRACE(("LOCK %d %s ok (already held) (unix)\n", pFile->h,
40135 assert( pFile->eFileLock!=NO_LOCK || eFileLock==SHARED_LOCK );
40137 assert( eFileLock!=RESERVED_LOCK || pFile->eFileLock==SHARED_LOCK );
40141 pInode = pFile->pInode;
40147 if( (pFile->eFileLock!=pInode->eFileLock &&
40161 assert( pFile->eFileLock==0 );
40163 pFile->eFileLock = SHARED_LOCK;
40177 || (eFileLock==EXCLUSIVE_LOCK && pFile->eFileLock==RESERVED_LOCK)
40181 if( unixFileLock(pFile, &lock) ){
40185 storeLastErrno(pFile, tErrno);
40189 pFile->eFileLock = PENDING_LOCK;
40206 if( unixFileLock(pFile, &lock) ){
40215 if( unixFileLock(pFile, &lock) && rc==SQLITE_OK ){
40223 storeLastErrno(pFile, tErrno);
40227 pFile->eFileLock = SHARED_LOCK;
40240 assert( 0!=pFile->eFileLock );
40252 if( unixFileLock(pFile, &lock) ){
40256 storeLastErrno(pFile, tErrno);
40269 && pFile->eFileLock<=SHARED_LOCK
40272 pFile->transCntrChng = 0;
40273 pFile->dbUpdate = 0;
40274 pFile->inNormalWrite = 1;
40279 pFile->eFileLock = eFileLock;
40285 OSTRACE(("LOCK %d %s %s (unix)\n", pFile->h, azFileLock(eFileLock),
40294 static void setPendingFd(unixFile *pFile){
40295 unixInodeInfo *pInode = pFile->pInode;
40296 UnixUnusedFd *p = pFile->pPreallocatedUnused;
40297 assert( unixFileMutexHeld(pFile) );
40300 pFile->h = -1;
40301 pFile->pPreallocatedUnused = 0;
40318 unixFile *pFile = (unixFile*)id;
40323 assert( pFile );
40324 OSTRACE(("UNLOCK %d %d was %d(%d,%d) pid=%d (unix)\n", pFile->h, eFileLock,
40325 pFile->eFileLock, pFile->pInode->eFileLock, pFile->pInode->nShared,
40329 if( pFile->eFileLock<=eFileLock ){
40332 pInode = pFile->pInode;
40335 if( pFile->eFileLock>SHARED_LOCK ){
40336 assert( pInode->eFileLock==pFile->eFileLock );
40347 pFile->inNormalWrite = 0;
40373 if( unixFileLock(pFile, &lock)==(-1) ){
40376 storeLastErrno(pFile, tErrno);
40383 if( unixFileLock(pFile, &lock)==(-1) ){
40387 storeLastErrno(pFile, tErrno);
40395 if( unixFileLock(pFile, &lock)==(-1) ){
40398 storeLastErrno(pFile, tErrno);
40408 if( unixFileLock(pFile, &lock) ){
40416 storeLastErrno(pFile, errno);
40425 if( unixFileLock(pFile, &lock)==0 ){
40429 storeLastErrno(pFile, errno);
40443 if( unixFileLock(pFile, &lock)==0 ){
40447 storeLastErrno(pFile, errno);
40449 pFile->eFileLock = NO_LOCK;
40459 if( pInode->nLock==0 ) closePendingFds(pFile);
40465 pFile->eFileLock = eFileLock;
40500 unixFile *pFile = (unixFile*)id;
40502 unixUnmapfile(pFile);
40504 if( pFile->h>=0 ){
40505 robust_close(pFile, pFile->h, __LINE__);
40506 pFile->h = -1;
40509 if( pFile->pId ){
40510 if( pFile->ctrlFlags & UNIXFILE_DELETE ){
40511 osUnlink(pFile->pId->zCanonicalName);
40513 vxworksReleaseFileId(pFile->pId);
40514 pFile->pId = 0;
40518 if( pFile->ctrlFlags & UNIXFILE_DELETE ){
40519 osUnlink(pFile->zPath);
40520 sqlite3_free(*(char**)&pFile->zPath);
40521 pFile->zPath = 0;
40524 OSTRACE(("CLOSE %-3d\n", pFile->h));
40526 sqlite3_free(pFile->pPreallocatedUnused);
40527 memset(pFile, 0, sizeof(unixFile));
40536 unixFile *pFile = (unixFile *)id;
40537 unixInodeInfo *pInode = pFile->pInode;
40540 verifyDbFile(pFile);
40542 assert( unixFileMutexNotheld(pFile) );
40548 assert( pFile->pInode->nLock>0 || pFile->pInode->bProcessLock==0 );
40556 setPendingFd(pFile);
40559 releaseInodeInfo(pFile);
40560 assert( pFile->pShm==0 );
40651 unixFile *pFile = (unixFile*)id;
40655 assert( pFile );
40656 reserved = osAccess((const char*)pFile->lockingContext, 0)==0;
40657 OSTRACE(("TEST WR-LOCK %d %d %d (dotlock)\n", pFile->h, rc, reserved));
40690 unixFile *pFile = (unixFile*)id;
40691 char *zLockFile = (char *)pFile->lockingContext;
40698 if( pFile->eFileLock > NO_LOCK ){
40699 pFile->eFileLock = eFileLock;
40719 storeLastErrno(pFile, tErrno);
40726 pFile->eFileLock = eFileLock;
40740 unixFile *pFile = (unixFile*)id;
40741 char *zLockFile = (char *)pFile->lockingContext;
40744 assert( pFile );
40745 OSTRACE(("UNLOCK %d %d was %d pid=%d (dotlock)\n", pFile->h, eFileLock,
40746 pFile->eFileLock, osGetpid(0)));
40750 if( pFile->eFileLock==eFileLock ){
40758 pFile->eFileLock = SHARED_LOCK;
40771 storeLastErrno(pFile, tErrno);
40775 pFile->eFileLock = NO_LOCK;
40783 unixFile *pFile = (unixFile*)id;
40786 sqlite3_free(pFile->lockingContext);
40831 unixFile *pFile = (unixFile*)id;
40835 assert( pFile );
40838 if( pFile->eFileLock>SHARED_LOCK ){
40845 int lrc = robust_flock(pFile->h, LOCK_EX | LOCK_NB);
40848 lrc = robust_flock(pFile->h, LOCK_UN);
40853 storeLastErrno(pFile, tErrno);
40862 storeLastErrno(pFile, tErrno);
40867 OSTRACE(("TEST WR-LOCK %d %d %d (flock)\n", pFile->h, rc, reserved));
40910 unixFile *pFile = (unixFile*)id;
40912 assert( pFile );
40916 if (pFile->eFileLock > NO_LOCK) {
40917 pFile->eFileLock = eFileLock;
40923 if (robust_flock(pFile->h, LOCK_EX | LOCK_NB)) {
40928 storeLastErrno(pFile, tErrno);
40932 pFile->eFileLock = eFileLock;
40934 OSTRACE(("LOCK %d %s %s (flock)\n", pFile->h, azFileLock(eFileLock),
40953 unixFile *pFile = (unixFile*)id;
40955 assert( pFile );
40956 OSTRACE(("UNLOCK %d %d was %d pid=%d (flock)\n", pFile->h, eFileLock,
40957 pFile->eFileLock, osGetpid(0)));
40961 if( pFile->eFileLock==eFileLock ){
40967 pFile->eFileLock = eFileLock;
40972 if( robust_flock(pFile->h, LOCK_UN) ){
40978 pFile->eFileLock = NO_LOCK;
41018 unixFile *pFile = (unixFile*)id;
41022 assert( pFile );
41025 if( pFile->eFileLock>SHARED_LOCK ){
41031 sem_t *pSem = pFile->pInode->pSem;
41037 storeLastErrno(pFile, tErrno);
41040 reserved = (pFile->eFileLock < SHARED_LOCK);
41047 OSTRACE(("TEST WR-LOCK %d %d %d (sem)\n", pFile->h, rc, reserved));
41083 unixFile *pFile = (unixFile*)id;
41084 sem_t *pSem = pFile->pInode->pSem;
41089 if (pFile->eFileLock > NO_LOCK) {
41090 pFile->eFileLock = eFileLock;
41102 pFile->eFileLock = eFileLock;
41116 unixFile *pFile = (unixFile*)id;
41117 sem_t *pSem = pFile->pInode->pSem;
41119 assert( pFile );
41121 OSTRACE(("UNLOCK %d %d was %d pid=%d (sem)\n", pFile->h, eFileLock,
41122 pFile->eFileLock, osGetpid(0)));
41126 if( pFile->eFileLock==eFileLock ){
41132 pFile->eFileLock = eFileLock;
41141 storeLastErrno(pFile, tErrno);
41145 pFile->eFileLock = NO_LOCK;
41154 unixFile *pFile = (unixFile*)id;
41156 assert( pFile );
41157 assert( unixFileMutexNotheld(pFile) );
41159 releaseInodeInfo(pFile);
41214 unixFile *pFile, /* Open file descriptor on path */
41226 pb.fd = pFile->h;
41229 (setLockFlag?"ON":"OFF"), pFile->h, (pb.fd==-1?"[testval-1]":""),
41244 storeLastErrno(pFile, tErrno);
41261 unixFile *pFile = (unixFile*)id;
41266 assert( pFile );
41267 context = (afpLockingContext *) pFile->lockingContext;
41272 sqlite3_mutex_enter(pFile->pInode->pLockMutex);
41274 if( pFile->pInode->eFileLock>SHARED_LOCK ){
41282 int lrc = afpSetLock(context->dbPath, pFile, RESERVED_BYTE, 1,1);
41286 lrc = afpSetLock(context->dbPath, pFile, RESERVED_BYTE, 1, 0);
41296 sqlite3_mutex_leave(pFile->pInode->pLockMutex);
41297 OSTRACE(("TEST WR-LOCK %d %d %d (afp)\n", pFile->h, rc, reserved));
41329 unixFile *pFile = (unixFile*)id;
41330 unixInodeInfo *pInode = pFile->pInode;
41331 afpLockingContext *context = (afpLockingContext *) pFile->lockingContext;
41333 assert( pFile );
41334 OSTRACE(("LOCK %d %s was %s(%s,%d) pid=%d (afp)\n", pFile->h,
41335 azFileLock(eFileLock), azFileLock(pFile->eFileLock),
41342 if( pFile->eFileLock>=eFileLock ){
41343 OSTRACE(("LOCK %d %s ok (already held) (afp)\n", pFile->h,
41353 assert( pFile->eFileLock!=NO_LOCK || eFileLock==SHARED_LOCK );
41355 assert( eFileLock!=RESERVED_LOCK || pFile->eFileLock==SHARED_LOCK );
41359 pInode = pFile->pInode;
41365 if( (pFile->eFileLock!=pInode->eFileLock &&
41379 assert( pFile->eFileLock==0 );
41381 pFile->eFileLock = SHARED_LOCK;
41392 || (eFileLock==EXCLUSIVE_LOCK && pFile->eFileLock<PENDING_LOCK)
41395 failed = afpSetLock(context->dbPath, pFile, PENDING_BYTE, 1, 1);
41417 lrc1 = afpSetLock(context->dbPath, pFile,
41420 lrc1Errno = pFile->lastErrno;
41423 lrc2 = afpSetLock(context->dbPath, pFile, PENDING_BYTE, 1, 0);
41426 storeLastErrno(pFile, lrc1Errno);
41435 pFile->eFileLock = SHARED_LOCK;
41449 assert( 0!=pFile->eFileLock );
41450 if (eFileLock >= RESERVED_LOCK && pFile->eFileLock < RESERVED_LOCK) {
41452 failed = afpSetLock(context->dbPath, pFile, RESERVED_BYTE, 1,1);
41463 if( !(failed = afpSetLock(context->dbPath, pFile, SHARED_FIRST +
41467 failed = afpSetLock(context->dbPath, pFile, SHARED_FIRST,
41469 if( failed && (failed2 = afpSetLock(context->dbPath, pFile,
41488 pFile->eFileLock = eFileLock;
41491 pFile->eFileLock = PENDING_LOCK;
41497 OSTRACE(("LOCK %d %s %s (afp)\n", pFile->h, azFileLock(eFileLock),
41511 unixFile *pFile = (unixFile*)id;
41513 afpLockingContext *context = (afpLockingContext *) pFile->lockingContext;
41516 assert( pFile );
41517 OSTRACE(("UNLOCK %d %d was %d(%d,%d) pid=%d (afp)\n", pFile->h, eFileLock,
41518 pFile->eFileLock, pFile->pInode->eFileLock, pFile->pInode->nShared,
41522 if( pFile->eFileLock<=eFileLock ){
41525 pInode = pFile->pInode;
41528 if( pFile->eFileLock>SHARED_LOCK ){
41529 assert( pInode->eFileLock==pFile->eFileLock );
41540 assert( pFile->inNormalWrite==0
41541 || pFile->dbUpdate==0
41542 || pFile->transCntrChng==1 );
41543 pFile->inNormalWrite = 0;
41546 if( pFile->eFileLock==EXCLUSIVE_LOCK ){
41547 rc = afpSetLock(context->dbPath, pFile, SHARED_FIRST, SHARED_SIZE, 0);
41551 rc = afpSetLock(context->dbPath, pFile, sharedLockByte, 1, 1);
41556 if( rc==SQLITE_OK && pFile->eFileLock>=PENDING_LOCK ){
41557 rc = afpSetLock(context->dbPath, pFile, PENDING_BYTE, 1, 0);
41559 if( rc==SQLITE_OK && pFile->eFileLock>=RESERVED_LOCK && context->reserved ){
41560 rc = afpSetLock(context->dbPath, pFile, RESERVED_BYTE, 1, 0);
41579 rc = afpSetLock(context->dbPath, pFile, sharedLockByte, 1, 0);
41583 pFile->eFileLock = NO_LOCK;
41589 if( pInode->nLock==0 ) closePendingFds(pFile);
41595 pFile->eFileLock = eFileLock;
41605 unixFile *pFile = (unixFile*)id;
41608 assert( unixFileMutexNotheld(pFile) );
41610 if( pFile->pInode ){
41611 unixInodeInfo *pInode = pFile->pInode;
41619 setPendingFd(pFile);
41623 releaseInodeInfo(pFile);
41624 sqlite3_free(pFile->lockingContext);
41736 unixFile *pFile = (unixFile *)id;
41745 assert( pFile->pPreallocatedUnused==0
41754 if( offset<pFile->mmapSize ){
41755 if( offset+amt <= pFile->mmapSize ){
41756 memcpy(pBuf, &((u8 *)(pFile->pMapRegion))[offset], amt);
41759 int nCopy = pFile->mmapSize - offset;
41760 memcpy(pBuf, &((u8 *)(pFile->pMapRegion))[offset], nCopy);
41768 got = seekAndRead(pFile, offset, pBuf, amt);
41779 switch( pFile->lastErrno ){
41792 storeLastErrno(pFile, 0); /* not a system error */
41867 unixFile *pFile = (unixFile*)id;
41875 assert( pFile->pPreallocatedUnused==0
41888 if( pFile->inNormalWrite ){
41889 pFile->dbUpdate = 1; /* The database has been modified */
41894 rc = seekAndRead(pFile, 24, oldCntr, 4);
41897 pFile->transCntrChng = 1; /* The transaction counter has changed */
41906 if( offset<pFile->mmapSize ){
41907 if( offset+amt <= pFile->mmapSize ){
41908 memcpy(&((u8 *)(pFile->pMapRegion))[offset], pBuf, amt);
41911 int nCopy = pFile->mmapSize - offset;
41912 memcpy(&((u8 *)(pFile->pMapRegion))[offset], pBuf, nCopy);
41920 while( (wrote = seekAndWrite(pFile, offset, pBuf, amt))<amt && wrote>0 ){
41929 if( wrote<0 && pFile->lastErrno!=ENOSPC ){
41933 storeLastErrno(pFile, 0); /* not a system error */
42131 unixFile *pFile = (unixFile*)id;
42146 assert( pFile );
42147 OSTRACE(("SYNC %-3d\n", pFile->h));
42148 rc = full_fsync(pFile->h, isFullsync, isDataOnly);
42151 storeLastErrno(pFile, errno);
42152 return unixLogError(SQLITE_IOERR_FSYNC, "full_fsync", pFile->zPath);
42159 if( pFile->ctrlFlags & UNIXFILE_DIRSYNC ){
42161 OSTRACE(("DIRSYNC %s (have_fullfsync=%d fullsync=%d)\n", pFile->zPath,
42163 rc = osOpenDirectory(pFile->zPath, &dirfd);
42166 robust_close(pFile, dirfd, __LINE__);
42171 pFile->ctrlFlags &= ~UNIXFILE_DIRSYNC;
42180 unixFile *pFile = (unixFile *)id;
42182 assert( pFile );
42190 if( pFile->szChunk>0 ){
42191 nByte = ((nByte + pFile->szChunk - 1)/pFile->szChunk) * pFile->szChunk;
42194 rc = robust_ftruncate(pFile->h, nByte);
42196 storeLastErrno(pFile, errno);
42197 return unixLogError(SQLITE_IOERR_TRUNCATE, "ftruncate", pFile->zPath);
42207 if( pFile->inNormalWrite && nByte==0 ){
42208 pFile->transCntrChng = 1;
42217 if( nByte<pFile->mmapSize ){
42218 pFile->mmapSize = nByte;
42267 static int fcntlSizeHint(unixFile *pFile, i64 nByte){
42268 if( pFile->szChunk>0 ){
42272 if( osFstat(pFile->h, &buf) ){
42276 nSize = ((nByte+pFile->szChunk-1) / pFile->szChunk) * pFile->szChunk;
42285 err = osFallocate(pFile->h, buf.st_size, nSize-buf.st_size);
42305 nWrite = seekAndWrite(pFile, iWrite, "", 1);
42313 if( pFile->mmapSizeMax>0 && nByte>pFile->mmapSize ){
42315 if( pFile->szChunk<=0 ){
42316 if( robust_ftruncate(pFile->h, nByte) ){
42317 storeLastErrno(pFile, errno);
42318 return unixLogError(SQLITE_IOERR_TRUNCATE, "ftruncate", pFile->zPath);
42322 rc = unixMapfile(pFile, nByte);
42336 static void unixModeBit(unixFile *pFile, unsigned char mask, int *pArg){
42338 *pArg = (pFile->ctrlFlags & mask)!=0;
42340 pFile->ctrlFlags &= ~mask;
42342 pFile->ctrlFlags |= mask;
42356 unixFile *pFile = (unixFile*)id;
42360 int rc = osIoctl(pFile->h, F2FS_IOC_START_ATOMIC_WRITE);
42364 int rc = osIoctl(pFile->h, F2FS_IOC_COMMIT_ATOMIC_WRITE);
42368 int rc = osIoctl(pFile->h, F2FS_IOC_ABORT_VOLATILE_WRITE);
42374 *(int*)pArg = pFile->eFileLock;
42378 *(int*)pArg = pFile->lastErrno;
42382 pFile->szChunk = *(int *)pArg;
42388 rc = fcntlSizeHint(pFile, *(i64 *)pArg);
42393 unixModeBit(pFile, UNIXFILE_PERSIST_WAL, (int*)pArg);
42397 unixModeBit(pFile, UNIXFILE_PSOW, (int*)pArg);
42401 *(char**)pArg = sqlite3_mprintf("%s", pFile->pVfs->zName);
42405 char *zTFile = sqlite3_malloc64( pFile->pVfs->mxPathname );
42407 unixGetTempname(pFile->pVfs->mxPathname, zTFile);
42413 *(int*)pArg = fileHasMoved(pFile);
42418 int iOld = pFile->iBusyTimeout;
42420 pFile->iBusyTimeout = *(int*)pArg;
42422 pFile->iBusyTimeout = !!(*(int*)pArg);
42445 *(i64*)pArg = pFile->mmapSizeMax;
42446 if( newLimit>=0 && newLimit!=pFile->mmapSizeMax && pFile->nFetchOut==0 ){
42447 pFile->mmapSizeMax = newLimit;
42448 if( pFile->mmapSize>0 ){
42449 unixUnmapfile(pFile);
42450 rc = unixMapfile(pFile, -1);
42521 static void setDeviceCharacteristics(unixFile *pFile){
42522 if( pFile->sectorSize == 0 ){
42526 pFile->sectorSize = SQLITE_DEFAULT_SECTOR_SIZE;
42527 pFile->deviceCharacteristics = 0;
42528 if( fstatvfs(pFile->h, &fsInfo) == -1 ) {
42533 pFile->sectorSize = fsInfo.f_bsize;
42534 pFile->deviceCharacteristics =
42542 pFile->sectorSize = fsInfo.f_bsize;
42543 pFile->deviceCharacteristics =
42545 (pFile->sectorSize / 512 * SQLITE_IOCAP_ATOMIC512) |
42552 pFile->sectorSize = fsInfo.f_bsize;
42553 pFile->deviceCharacteristics =
42561 pFile->sectorSize = fsInfo.f_bsize;
42562 pFile->deviceCharacteristics =
42564 ((pFile->sectorSize / 512 * SQLITE_IOCAP_ATOMIC512) << 1) - 2 |
42569 pFile->sectorSize = fsInfo.f_bsize;
42570 pFile->deviceCharacteristics =
42572 ((pFile->sectorSize / 512 * SQLITE_IOCAP_ATOMIC512) << 1) - 2 |
42577 pFile->deviceCharacteristics =
42586 if( pFile->sectorSize % 512 != 0 ){
42587 pFile->deviceCharacteristics = 0;
42588 pFile->sectorSize = SQLITE_DEFAULT_SECTOR_SIZE;
42755 static int unixFcntlExternalReader(unixFile *pFile, int *piOut){
42758 if( pFile->pShm){
42759 unixShmNode *pShmNode = pFile->pShm->pShmNode;
42788 unixFile *pFile, /* Open connection to the WAL file */
42797 pShmNode = pFile->pInode->pShmNode;
42834 res = osSetPosixAdvisoryLock(pShmNode->hShm, &f, pFile);
42837 rc = (pFile->iBusyTimeout ? SQLITE_BUSY_TIMEOUT : SQLITE_BUSY);
44615 sqlite3_file *pFile, /* The file descriptor to be filled in */
44619 unixFile *p = (unixFile *)pFile;
44833 ((unixFile*)pFile)->fsFlags |= SQLITE_FSFLAGS_IS_MSDOS;
44836 ((unixFile*)pFile)->fsFlags |= SQLITE_FSFLAGS_IS_MSDOS;
44864 rc = fillInUnixFile(pVfs, fd, pFile, zPath, ctrlFlags);
44866 rc = proxyTransformUnixFile((unixFile*)pFile, ":auto:");
44872 unixClose(pFile);
44884 rc = fillInUnixFile(pVfs, fd, pFile, zPath, ctrlFlags);
45715 static int proxyBreakConchLock(unixFile *pFile, uuid_t myHostID){
45716 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
45757 robust_close(pFile, conchFile->h, __LINE__);
45765 robust_close(pFile, fd, __LINE__);
45775 static int proxyConchLock(unixFile *pFile, uuid_t myHostID, int lockType){
45776 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
45795 storeLastErrno(pFile, errno);
45815 storeLastErrno(pFile, errno);
45832 if( 0==proxyBreakConchLock(pFile, myHostID) ){
45853 static int proxyTakeConch(unixFile *pFile){
45854 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
45878 storeLastErrno(pFile, pError);
45881 rc = proxyConchLock(pFile, myHostID, SHARED_LOCK);
45889 storeLastErrno(pFile, conchFile->lastErrno);
45959 rc = proxyConchLock(pFile, myHostID, EXCLUSIVE_LOCK);
45962 rc = proxyConchLock(pFile, myHostID, EXCLUSIVE_LOCK);
45985 int err = osFstat(pFile->h, &buf);
46014 OSTRACE(("TRANSPROXY: CLOSE %d\n", pFile->h));
46015 if( rc==SQLITE_OK && pFile->openFlags ){
46017 if( pFile->h>=0 ){
46018 robust_close(pFile, pFile->h, __LINE__);
46020 pFile->h = -1;
46021 fd = robust_open(pCtx->dbPath, pFile->openFlags, 0);
46024 pFile->h = fd;
46075 static int proxyReleaseConch(unixFile *pFile){
46080 pCtx = (proxyLockingContext *)pFile->lockingContext;
46142 static int switchLockProxyPath(unixFile *pFile, const char *path) {
46143 proxyLockingContext *pCtx = (proxyLockingContext*)pFile->lockingContext;
46147 if( pFile->eFileLock!=NO_LOCK ){
46178 static int proxyGetDbPathForUnixFile(unixFile *pFile, char *dbPath){
46180 if( pFile->pMethod == &afpIoMethods ){
46183 assert( (int)strlen((char*)pFile->lockingContext)<=MAXPATHLEN );
46184 strlcpy(dbPath, ((afpLockingContext *)pFile->lockingContext)->dbPath,
46188 if( pFile->pMethod == &dotlockIoMethods ){
46191 int len = strlen((char *)pFile->lockingContext) - strlen(DOTLOCK_SUFFIX);
46192 memcpy(dbPath, (char *)pFile->lockingContext, len + 1);
46195 assert( strlen((char*)pFile->lockingContext)<=MAXPATHLEN );
46196 strlcpy(dbPath, (char *)pFile->lockingContext, MAXPATHLEN);
46209 static int proxyTransformUnixFile(unixFile *pFile, const char *path) {
46215 if( pFile->eFileLock!=NO_LOCK ){
46218 proxyGetDbPathForUnixFile(pFile, dbPath);
46225 OSTRACE(("TRANSPROXY %d for %s pid=%d\n", pFile->h,
46237 if( rc==SQLITE_CANTOPEN && ((pFile->openFlags&O_RDWR) == 0) ){
46273 pCtx->oldLockingContext = pFile->lockingContext;
46274 pFile->lockingContext = pCtx;
46275 pCtx->pOldMethod = pFile->pMethod;
46276 pFile->pMethod = &proxyIoMethods;
46286 OSTRACE(("TRANSPROXY %d %s\n", pFile->h,
46299 unixFile *pFile = (unixFile*)id;
46300 if( pFile->pMethod == &proxyIoMethods ){
46301 proxyLockingContext *pCtx = (proxyLockingContext*)pFile->lockingContext;
46302 proxyTakeConch(pFile);
46314 unixFile *pFile = (unixFile*)id;
46316 int isProxyStyle = (pFile->pMethod == &proxyIoMethods);
46332 (proxyLockingContext*)pFile->lockingContext;
46339 rc = switchLockProxyPath(pFile, proxyPath);
46343 rc = proxyTransformUnixFile(pFile, proxyPath);
46370 unixFile *pFile = (unixFile*)id;
46371 int rc = proxyTakeConch(pFile);
46373 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
46409 unixFile *pFile = (unixFile*)id;
46410 int rc = proxyTakeConch(pFile);
46412 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
46416 pFile->eFileLock = proxy->eFileLock;
46433 unixFile *pFile = (unixFile*)id;
46434 int rc = proxyTakeConch(pFile);
46436 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
46440 pFile->eFileLock = proxy->eFileLock;
46453 unixFile *pFile = (unixFile*)id;
46454 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
46469 rc = proxyReleaseConch(pFile);
46480 pFile->lockingContext = pCtx->oldLockingContext;
46481 pFile->pMethod = pCtx->pOldMethod;
46483 return pFile->pMethod->xClose(id);
48902 static int winceCreateLock(const char *zFilename, winFile *pFile){
48916 memset(&pFile->local, 0, sizeof(pFile->local));
48926 pFile->hMutex = osCreateMutexW(NULL, FALSE, zName);
48927 if (!pFile->hMutex){
48928 pFile->lastErrno = osGetLastError();
48930 return winLogError(SQLITE_IOERR, pFile->lastErrno,
48935 winceMutexAcquire(pFile->hMutex);
48942 pFile->hShared = osCreateFileMappingW(INVALID_HANDLE_VALUE, NULL,
48956 if( pFile->hShared ){
48957 pFile->shared = (winceLock*)osMapViewOfFile(pFile->hShared,
48960 if( !pFile->shared ){
48961 pFile->lastErrno = osGetLastError();
48962 winLogError(SQLITE_IOERR, pFile->lastErrno,
48965 osCloseHandle(pFile->hShared);
48966 pFile->hShared = NULL;
48971 if( pFile->hShared==NULL ){
48973 pFile->lastErrno = lastErrno;
48974 winLogError(SQLITE_IOERR, pFile->lastErrno,
48978 winceMutexRelease(pFile->hMutex);
48979 osCloseHandle(pFile->hMutex);
48980 pFile->hMutex = NULL;
48986 memset(pFile->shared, 0, sizeof(winceLock));
48989 winceMutexRelease(pFile->hMutex);
48996 static void winceDestroyLock(winFile *pFile){
48997 if (pFile->hMutex){
48999 winceMutexAcquire(pFile->hMutex);
49003 if (pFile->local.nReaders){
49004 pFile->shared->nReaders --;
49006 if (pFile->local.bReserved){
49007 pFile->shared->bReserved = FALSE;
49009 if (pFile->local.bPending){
49010 pFile->shared->bPending = FALSE;
49012 if (pFile->local.bExclusive){
49013 pFile->shared->bExclusive = FALSE;
49017 osUnmapViewOfFile(pFile->shared);
49018 osCloseHandle(pFile->hShared);
49021 winceMutexRelease(pFile->hMutex);
49022 osCloseHandle(pFile->hMutex);
49023 pFile->hMutex = NULL;
49037 winFile *pFile = HANDLE_TO_WINFILE(phFile);
49043 if (!pFile->hMutex) return TRUE;
49044 winceMutexAcquire(pFile->hMutex);
49049 if (pFile->shared->nReaders == 0 && pFile->shared->bExclusive == 0){
49050 pFile->shared->bExclusive = TRUE;
49051 pFile->local.bExclusive = TRUE;
49059 if (pFile->shared->bExclusive == 0){
49060 pFile->local.nReaders ++;
49061 if (pFile->local.nReaders == 1){
49062 pFile->shared->nReaders ++;
49072 if (pFile->shared->bPending == 0) {
49073 pFile->shared->bPending = TRUE;
49074 pFile->local.bPending = TRUE;
49082 if (pFile->shared->bReserved == 0) {
49083 pFile->shared->bReserved = TRUE;
49084 pFile->local.bReserved = TRUE;
49089 winceMutexRelease(pFile->hMutex);
49103 winFile *pFile = HANDLE_TO_WINFILE(phFile);
49109 if (!pFile->hMutex) return TRUE;
49110 winceMutexAcquire(pFile->hMutex);
49115 if (pFile->local.bExclusive){
49117 pFile->local.bExclusive = FALSE;
49118 pFile->shared->bExclusive = FALSE;
49123 else if (pFile->local.nReaders){
49126 pFile->local.nReaders --;
49127 if (pFile->local.nReaders == 0)
49129 pFile->shared->nReaders --;
49138 if (pFile->local.bPending){
49139 pFile->local.bPending = FALSE;
49140 pFile->shared->bPending = FALSE;
49147 if (pFile->local.bReserved) {
49148 pFile->local.bReserved = FALSE;
49149 pFile->shared->bReserved = FALSE;
49154 winceMutexRelease(pFile->hMutex);
49242 static int winSeekFile(winFile *pFile, sqlite3_int64 iOffset){
49249 OSTRACE(("SEEK file=%p, offset=%lld\n", pFile->h, iOffset));
49261 dwRet = osSetFilePointer(pFile->h, lowerBits, &upperBits, FILE_BEGIN);
49265 pFile->lastErrno = lastErrno;
49266 winLogError(SQLITE_IOERR_SEEK, pFile->lastErrno,
49267 "winSeekFile", pFile->zPath);
49268 OSTRACE(("SEEK file=%p, rc=SQLITE_IOERR_SEEK\n", pFile->h));
49272 OSTRACE(("SEEK file=%p, rc=SQLITE_OK\n", pFile->h));
49283 bRet = osSetFilePointerEx(pFile->h, x, 0, FILE_BEGIN);
49286 pFile->lastErrno = osGetLastError();
49287 winLogError(SQLITE_IOERR_SEEK, pFile->lastErrno,
49288 "winSeekFile", pFile->zPath);
49289 OSTRACE(("SEEK file=%p, rc=SQLITE_IOERR_SEEK\n", pFile->h));
49293 OSTRACE(("SEEK file=%p, rc=SQLITE_OK\n", pFile->h));
49317 winFile *pFile = (winFile*)id;
49321 assert( pFile->pShm==0 );
49323 assert( pFile->h!=NULL && pFile->h!=INVALID_HANDLE_VALUE );
49325 osGetCurrentProcessId(), pFile, pFile->h));
49328 winUnmapfile(pFile);
49332 rc = osCloseHandle(pFile->h);
49338 winVfsAppData *pAppData = (winVfsAppData*)pFile->pVfs->pAppData;
49340 winceDestroyLock(pFile);
49343 if( pFile->zDeleteOnClose ){
49346 osDeleteFileW(pFile->zDeleteOnClose)==0
49347 && osGetFileAttributesW(pFile->zDeleteOnClose)!=0xffffffff
49352 sqlite3_free(pFile->zDeleteOnClose);
49356 pFile->h = NULL;
49360 osGetCurrentProcessId(), pFile, pFile->h, rc ? "ok" : "failed"));
49363 "winClose", pFile->zPath);
49380 winFile *pFile = (winFile*)id; /* file handle */
49389 "offset=%lld, lock=%d\n", osGetCurrentProcessId(), pFile,
49390 pFile->h, pBuf, amt, offset, pFile->locktype));
49395 if( offset<pFile->mmapSize ){
49396 if( offset+amt <= pFile->mmapSize ){
49397 memcpy(pBuf, &((u8 *)(pFile->pMapRegion))[offset], amt);
49399 osGetCurrentProcessId(), pFile, pFile->h));
49402 int nCopy = (int)(pFile->mmapSize - offset);
49403 memcpy(pBuf, &((u8 *)(pFile->pMapRegion))[offset], nCopy);
49412 if( winSeekFile(pFile, offset) ){
49414 osGetCurrentProcessId(), pFile, pFile->h));
49417 while( !osReadFile(pFile->h, pBuf, amt, &nRead, 0) ){
49422 while( !osReadFile(pFile->h, pBuf, amt, &nRead, &overlapped) &&
49427 pFile->lastErrno = lastErrno;
49429 osGetCurrentProcessId(), pFile, pFile->h));
49430 return winLogError(SQLITE_IOERR_READ, pFile->lastErrno,
49431 "winRead", pFile->zPath);
49438 osGetCurrentProcessId(), pFile, pFile->h));
49443 osGetCurrentProcessId(), pFile, pFile->h));
49458 winFile *pFile = (winFile*)id; /* File handle */
49462 assert( pFile );
49467 "offset=%lld, lock=%d\n", osGetCurrentProcessId(), pFile,
49468 pFile->h, pBuf, amt, offset, pFile->locktype));
49473 if( offset<pFile->mmapSize ){
49474 if( offset+amt <= pFile->mmapSize ){
49475 memcpy(&((u8 *)(pFile->pMapRegion))[offset], pBuf, amt);
49477 osGetCurrentProcessId(), pFile, pFile->h));
49480 int nCopy = (int)(pFile->mmapSize - offset);
49481 memcpy(&((u8 *)(pFile->pMapRegion))[offset], pBuf, nCopy);
49490 rc = winSeekFile(pFile, offset);
49511 if( !osWriteFile(pFile->h, aRem, nRem, &nWrite, 0) ){
49513 if( !osWriteFile(pFile->h, aRem, nRem, &nWrite, &overlapped) ){
49532 pFile->lastErrno = lastErrno;
49538 if( ( pFile->lastErrno==ERROR_HANDLE_DISK_FULL )
49539 || ( pFile->lastErrno==ERROR_DISK_FULL )){
49541 osGetCurrentProcessId(), pFile, pFile->h));
49542 return winLogError(SQLITE_FULL, pFile->lastErrno,
49543 "winWrite1", pFile->zPath);
49546 osGetCurrentProcessId(), pFile, pFile->h));
49547 return winLogError(SQLITE_IOERR_WRITE, pFile->lastErrno,
49548 "winWrite2", pFile->zPath);
49553 osGetCurrentProcessId(), pFile, pFile->h));
49561 winFile *pFile = (winFile*)id; /* File handle object */
49566 if( pFile->nFetchOut>0 ){
49588 assert( pFile );
49591 osGetCurrentProcessId(), pFile, pFile->h, nByte, pFile->locktype));
49598 if( pFile->szChunk>0 ){
49599 nByte = ((nByte + pFile->szChunk - 1)/pFile->szChunk) * pFile->szChunk;
49603 if( pFile->pMapRegion ){
49604 oldMmapSize = pFile->mmapSize;
49608 winUnmapfile(pFile);
49612 if( winSeekFile(pFile, nByte) ){
49613 rc = winLogError(SQLITE_IOERR_TRUNCATE, pFile->lastErrno,
49614 "winTruncate1", pFile->zPath);
49615 }else if( 0==osSetEndOfFile(pFile->h) &&
49617 pFile->lastErrno = lastErrno;
49618 rc = winLogError(SQLITE_IOERR_TRUNCATE, pFile->lastErrno,
49619 "winTruncate2", pFile->zPath);
49625 winMapfile(pFile, -1);
49627 winMapfile(pFile, oldMmapSize);
49633 osGetCurrentProcessId(), pFile, pFile->h, sqlite3ErrName(rc)));
49662 winFile *pFile = (winFile*)id;
49667 assert( pFile );
49679 osGetCurrentProcessId(), pFile, pFile->h, flags,
49680 pFile->locktype));
49696 osGetCurrentProcessId(), pFile, pFile->h));
49700 if( pFile->pMapRegion ){
49701 if( osFlushViewOfFile(pFile->pMapRegion, 0) ){
49704 pFile, pFile->pMapRegion));
49706 pFile->lastErrno = osGetLastError();
49709 pFile, pFile->pMapRegion));
49710 return winLogError(SQLITE_IOERR_MMAP, pFile->lastErrno,
49711 "winSync1", pFile->zPath);
49715 rc = osFlushFileBuffers(pFile->h);
49719 osGetCurrentProcessId(), pFile, pFile->h));
49722 pFile->lastErrno = osGetLastError();
49724 osGetCurrentProcessId(), pFile, pFile->h));
49725 return winLogError(SQLITE_IOERR_FSYNC, pFile->lastErrno,
49726 "winSync2", pFile->zPath);
49735 winFile *pFile = (winFile*)id;
49741 OSTRACE(("SIZE file=%p, pSize=%p\n", pFile->h, pSize));
49746 if( osGetFileInformationByHandleEx(pFile->h, FileStandardInfo,
49750 pFile->lastErrno = osGetLastError();
49751 rc = winLogError(SQLITE_IOERR_FSTAT, pFile->lastErrno,
49752 "winFileSize", pFile->zPath);
49761 lowerBits = osGetFileSize(pFile->h, &upperBits);
49765 pFile->lastErrno = lastErrno;
49766 rc = winLogError(SQLITE_IOERR_FSTAT, pFile->lastErrno,
49767 "winFileSize", pFile->zPath);
49772 pFile->h, pSize, *pSize, sqlite3ErrName(rc)));
49812 static int winGetReadLock(winFile *pFile){
49814 OSTRACE(("READ-LOCK file=%p, lock=%d\n", pFile->h, pFile->locktype));
49821 res = winceLockFile(&pFile->h, SHARED_FIRST, 0, 1, 0);
49823 res = winLockFile(&pFile->h, SQLITE_LOCKFILEEX_FLAGS, SHARED_FIRST, 0,
49831 pFile->sharedLockByte = (short)((lk & 0x7fffffff)%(SHARED_SIZE - 1));
49832 res = winLockFile(&pFile->h, SQLITE_LOCKFILE_FLAGS,
49833 SHARED_FIRST+pFile->sharedLockByte, 0, 1, 0);
49837 pFile->lastErrno = osGetLastError();
49840 OSTRACE(("READ-LOCK file=%p, result=%d\n", pFile->h, res));
49847 static int winUnlockReadLock(winFile *pFile){
49850 OSTRACE(("READ-UNLOCK file=%p, lock=%d\n", pFile->h, pFile->locktype));
49852 res = winUnlockFile(&pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0);
49856 res = winUnlockFile(&pFile->h, SHARED_FIRST+pFile->sharedLockByte, 0, 1, 0);
49860 pFile->lastErrno = lastErrno;
49861 winLogError(SQLITE_IOERR_UNLOCK, pFile->lastErrno,
49862 "winUnlockReadLock", pFile->zPath);
49864 OSTRACE(("READ-UNLOCK file=%p, result=%d\n", pFile->h, res));
49899 winFile *pFile = (winFile*)id;
49904 pFile->h, pFile->locktype, pFile->sharedLockByte, locktype));
49910 if( pFile->locktype>=locktype ){
49911 OSTRACE(("LOCK-HELD file=%p, rc=SQLITE_OK\n", pFile->h));
49917 if( (pFile->ctrlFlags & WINFILE_RDONLY)!=0 && locktype>=RESERVED_LOCK ){
49923 assert( pFile->locktype!=NO_LOCK || locktype==SHARED_LOCK );
49925 assert( locktype!=RESERVED_LOCK || pFile->locktype==SHARED_LOCK );
49931 newLocktype = pFile->locktype;
49932 if( pFile->locktype==NO_LOCK
49933 || (locktype==EXCLUSIVE_LOCK && pFile->locktype<=RESERVED_LOCK)
49936 while( cnt-->0 && (res = winLockFile(&pFile->h, SQLITE_LOCKFILE_FLAGS,
49946 pFile->h, cnt, res));
49948 pFile->lastErrno = lastErrno;
49951 pFile->h, cnt, sqlite3ErrName(rc)));
49965 assert( pFile->locktype==NO_LOCK );
49966 res = winGetReadLock(pFile);
49977 assert( pFile->locktype==SHARED_LOCK );
49978 res = winLockFile(&pFile->h, SQLITE_LOCKFILE_FLAGS, RESERVED_BYTE, 0, 1, 0);
49996 assert( pFile->locktype>=SHARED_LOCK );
49997 (void)winUnlockReadLock(pFile);
49998 res = winLockFile(&pFile->h, SQLITE_LOCKFILE_FLAGS, SHARED_FIRST, 0,
50004 winGetReadLock(pFile);
50012 winUnlockFile(&pFile->h, PENDING_BYTE, 0, 1, 0);
50021 pFile->lastErrno = lastErrno;
50024 pFile->h, locktype, newLocktype));
50026 pFile->locktype = (u8)newLocktype;
50028 pFile->h, pFile->locktype, sqlite3ErrName(rc)));
50039 winFile *pFile = (winFile*)id;
50042 OSTRACE(("TEST-WR-LOCK file=%p, pResOut=%p\n", pFile->h, pResOut));
50045 if( pFile->locktype>=RESERVED_LOCK ){
50047 OSTRACE(("TEST-WR-LOCK file=%p, result=%d (local)\n", pFile->h, res));
50049 res = winLockFile(&pFile->h, SQLITE_LOCKFILEEX_FLAGS,RESERVED_BYTE,0,1,0);
50051 winUnlockFile(&pFile->h, RESERVED_BYTE, 0, 1, 0);
50054 OSTRACE(("TEST-WR-LOCK file=%p, result=%d (remote)\n", pFile->h, res));
50058 pFile->h, pResOut, *pResOut));
50075 winFile *pFile = (winFile*)id;
50077 assert( pFile!=0 );
50080 pFile->h, pFile->locktype, pFile->sharedLockByte, locktype));
50081 type = pFile->locktype;
50083 winUnlockFile(&pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0);
50084 if( locktype==SHARED_LOCK && !winGetReadLock(pFile) ){
50088 "winUnlock", pFile->zPath);
50092 winUnlockFile(&pFile->h, RESERVED_BYTE, 0, 1, 0);
50095 winUnlockReadLock(pFile);
50098 winUnlockFile(&pFile->h, PENDING_BYTE, 0, 1, 0);
50100 pFile->locktype = (u8)locktype;
50102 pFile->h, pFile->locktype, sqlite3ErrName(rc)));
50150 static void winModeBit(winFile *pFile, unsigned char mask, int *pArg){
50152 *pArg = (pFile->ctrlFlags & mask)!=0;
50154 pFile->ctrlFlags &= ~mask;
50156 pFile->ctrlFlags |= mask;
50170 winFile *pFile = (winFile*)id;
50171 OSTRACE(("FCNTL file=%p, op=%d, pArg=%p\n", pFile->h, op, pArg));
50174 *(int*)pArg = pFile->locktype;
50175 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
50179 *(int*)pArg = (int)pFile->lastErrno;
50180 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
50184 pFile->szChunk = *(int *)pArg;
50185 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
50189 if( pFile->szChunk>0 ){
50200 OSTRACE(("FCNTL file=%p, rc=%s\n", pFile->h, sqlite3ErrName(rc)));
50203 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
50207 winModeBit(pFile, WINFILE_PERSIST_WAL, (int*)pArg);
50208 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
50212 winModeBit(pFile, WINFILE_PSOW, (int*)pArg);
50213 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
50217 *(char**)pArg = sqlite3_mprintf("%s", pFile->pVfs->zName);
50218 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
50233 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
50238 *phFile = pFile->h;
50239 OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
50245 HANDLE hOldFile = pFile->h;
50246 pFile->h = *phFile;
50249 hOldFile, pFile->h));
50255 int rc = winGetTempname(pFile->pVfs, &zTFile);
50259 OSTRACE(("FCNTL file=%p, rc=%s\n", pFile->h, sqlite3ErrName(rc)));
50277 *(i64*)pArg = pFile->mmapSizeMax;
50278 if( newLimit>=0 && newLimit!=pFile->mmapSizeMax && pFile->nFetchOut==0 ){
50279 pFile->mmapSizeMax = newLimit;
50280 if( pFile->mmapSize>0 ){
50281 winUnmapfile(pFile);
50282 rc = winMapfile(pFile, -1);
50285 OSTRACE(("FCNTL file=%p, rc=%s\n", pFile->h, sqlite3ErrName(rc)));
50290 OSTRACE(("FCNTL file=%p, rc=SQLITE_NOTFOUND\n", pFile->h));
50445 winShmNode *pFile, /* Apply locks to this open shared-memory segment */
50453 assert( pFile->nRef==0 || sqlite3_mutex_held(pFile->mutex) );
50456 pFile->hFile.h, lockType, ofst, nByte));
50460 rc = winUnlockFile(&pFile->hFile.h, ofst, 0, nByte, 0);
50465 rc = winLockFile(&pFile->hFile.h, dwFlags, ofst, 0, nByte, 0);
50471 pFile->lastErrno = osGetLastError();
50476 pFile->hFile.h, (lockType == WINSHM_UNLCK) ? "winUnlockFile" :
50477 "winLockFile", pFile->lastErrno, sqlite3ErrName(rc)));
51017 static int winUnmapfile(winFile *pFile){
51018 assert( pFile!=0 );
51021 osGetCurrentProcessId(), pFile, pFile->hMap, pFile->pMapRegion,
51022 pFile->mmapSize, pFile->mmapSizeMax));
51023 if( pFile->pMapRegion ){
51024 if( !osUnmapViewOfFile(pFile->pMapRegion) ){
51025 pFile->lastErrno = osGetLastError();
51027 "rc=SQLITE_IOERR_MMAP\n", osGetCurrentProcessId(), pFile,
51028 pFile->pMapRegion));
51029 return winLogError(SQLITE_IOERR_MMAP, pFile->lastErrno,
51030 "winUnmapfile1", pFile->zPath);
51032 pFile->pMapRegion = 0;
51033 pFile->mmapSize = 0;
51035 if( pFile->hMap!=NULL ){
51036 if( !osCloseHandle(pFile->hMap) ){
51037 pFile->lastErrno = osGetLastError();
51039 osGetCurrentProcessId(), pFile, pFile->hMap));
51040 return winLogError(SQLITE_IOERR_MMAP, pFile->lastErrno,
51041 "winUnmapfile2", pFile->zPath);
51043 pFile->hMap = NULL;
51046 osGetCurrentProcessId(), pFile));
51690 winFile *pFile = (winFile*)id;
51748 assert( pFile!=0 );
51749 memset(pFile, 0, sizeof(winFile));
51750 pFile->h = INVALID_HANDLE_VALUE;
51918 pFile->lastErrno = lastErrno;
51919 winLogError(SQLITE_CANTOPEN, pFile->lastErrno, "winOpen", zUtf8Name);
51942 && (rc = winceCreateLock(zName, pFile))!=SQLITE_OK
51952 pFile->zDeleteOnClose = zConverted;
51961 pFile->pVfs = pVfs;
51962 pFile->h = h;
51964 pFile->ctrlFlags |= WINFILE_RDONLY;
51969 pFile->ctrlFlags |= WINFILE_PSOW;
51971 pFile->lastErrno = NO_ERROR;
51972 pFile->zPath = zName;
51974 pFile->hMap = NULL;
51975 pFile->pMapRegion = 0;
51976 pFile->mmapSize = 0;
51977 pFile->mmapSizeMax = sqlite3GlobalConfig.szMmap;
53075 static int memdbClose(sqlite3_file *pFile){
53076 MemStore *p = ((MemFile*)pFile)->pStore;
53118 sqlite3_file *pFile,
53123 MemStore *p = ((MemFile*)pFile)->pStore;
53160 sqlite3_file *pFile,
53165 MemStore *p = ((MemFile*)pFile)->pStore;
53196 static int memdbTruncate(sqlite3_file *pFile, sqlite_int64 size){
53197 MemStore *p = ((MemFile*)pFile)->pStore;
53213 static int memdbSync(sqlite3_file *pFile, int flags){
53214 UNUSED_PARAMETER(pFile);
53222 static int memdbFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){
53223 MemStore *p = ((MemFile*)pFile)->pStore;
53233 static int memdbLock(sqlite3_file *pFile, int eLock){
53234 MemFile *pThis = (MemFile*)pFile;
53291 static int memdbUnlock(sqlite3_file *pFile, int eLock){
53292 MemFile *pThis = (MemFile*)pFile;
53319 static int memdbCheckReservedLock(sqlite3_file *pFile, int *pResOut){
53329 static int memdbFileControl(sqlite3_file *pFile, int op, void *pArg){
53330 MemStore *p = ((MemFile*)pFile)->pStore;
53358 static int memdbSectorSize(sqlite3_file *pFile){
53366 static int memdbDeviceCharacteristics(sqlite3_file *pFile){
53367 UNUSED_PARAMETER(pFile);
53376 sqlite3_file *pFile,
53381 MemStore *p = ((MemFile*)pFile)->pStore;
53394 static int memdbUnfetch(sqlite3_file *pFile, sqlite3_int64 iOfst, void *pPage){
53395 MemStore *p = ((MemFile*)pFile)->pStore;
53414 MemFile *pFile = (MemFile*)pFd;
53419 memset(pFile, 0, sizeof(*pFile));
53477 pFile->pStore = p;
59791 SQLITE_PRIVATE int sqlite3SectorSize(sqlite3_file *pFile){
59792 int iRet = sqlite3OsSectorSize(pFile);
60770 sqlite3_file *pFile, /* Write the file descriptor here */
60781 rc = sqlite3OsOpen(pPager->pVfs, 0, pFile, vfsFlags, 0);
60782 assert( rc!=SQLITE_OK || isOpen(pFile) );
73337 sqlite3_file *pFile;
73347 pFile = sqlite3PagerFile(pBt->pPager);
73348 if( pFile->pMethods ){
73349 sqlite3OsFileControlHint(pFile, SQLITE_FCNTL_PDB, (void*)&pBt->db);
82301 static int backupTruncateFile(sqlite3_file *pFile, i64 iSize){
82303 int rc = sqlite3OsFileSize(pFile, &iCurrent);
82305 rc = sqlite3OsTruncate(pFile, iSize);
82483 sqlite3_file * const pFile = sqlite3PagerFile(pDestPager);
82489 assert( pFile );
82529 rc = sqlite3OsWrite(pFile, zData, pgszSrc, iOff);
82534 rc = backupTruncateFile(pFile, iSize);
103414 static int vdbeSorterMapFile(SortSubtask *pTask, SorterFile *pFile, u8 **pp){
103416 if( pFile->iEof<=(i64)(pTask->pSorter->db->nMaxSorterMmap) ){
103417 sqlite3_file *pFd = pFile->pFd;
103419 rc = sqlite3OsFetch(pFd, 0, (int)pFile->iEof, (void**)pp);
103434 SorterFile *pFile, /* Sorter file to read from */
103447 pReadr->iEof = pFile->iEof;
103448 pReadr->pFd = pFile->pFd;
103450 rc = vdbeSorterMapFile(pTask, pFile, &pReadr->aMap);
103527 SorterFile *pFile, /* Sorter file to read from */
103534 assert( pFile->iEof>iStart );
103539 rc = vdbePmaReaderSeek(pTask, pReadr, pFile, iStart);
139807 sqlite3_file *pFile = sqlite3PagerFile(pPager);
139808 sqlite3OsFileControlHint(pFile, SQLITE_GET_LOCKPROXYFILE,
139813 sqlite3_file *pFile = sqlite3PagerFile(pPager);
139816 res=sqlite3OsFileControl(pFile, SQLITE_SET_LOCKPROXYFILE,
139819 res=sqlite3OsFileControl(pFile, SQLITE_SET_LOCKPROXYFILE,
222713 static int rbuVfsClose(sqlite3_file *pFile){
222714 rbu_file *p = (rbu_file*)pFile;
222776 sqlite3_file *pFile,
222781 rbu_file *p = (rbu_file*)pFile;
222842 sqlite3_file *pFile,
222847 rbu_file *p = (rbu_file*)pFile;
222884 static int rbuVfsTruncate(sqlite3_file *pFile, sqlite_int64 size){
222885 rbu_file *p = (rbu_file*)pFile;
222896 static int rbuVfsSync(sqlite3_file *pFile, int flags){
222897 rbu_file *p = (rbu_file *)pFile;
222910 static int rbuVfsFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){
222911 rbu_file *p = (rbu_file *)pFile;
222931 static int rbuVfsLock(sqlite3_file *pFile, int eLock){
222932 rbu_file *p = (rbu_file*)pFile;
222953 static int rbuVfsUnlock(sqlite3_file *pFile, int eLock){
222954 rbu_file *p = (rbu_file *)pFile;
222961 static int rbuVfsCheckReservedLock(sqlite3_file *pFile, int *pResOut){
222962 rbu_file *p = (rbu_file *)pFile;
222969 static int rbuVfsFileControl(sqlite3_file *pFile, int op, void *pArg){
222970 rbu_file *p = (rbu_file *)pFile;
223025 static int rbuVfsSectorSize(sqlite3_file *pFile){
223026 rbu_file *p = (rbu_file *)pFile;
223033 static int rbuVfsDeviceCharacteristics(sqlite3_file *pFile){
223034 rbu_file *p = (rbu_file *)pFile;
223041 static int rbuVfsShmLock(sqlite3_file *pFile, int ofst, int n, int flags){
223042 rbu_file *p = (rbu_file*)pFile;
223080 sqlite3_file *pFile,
223086 rbu_file *p = (rbu_file*)pFile;
223137 static void rbuVfsShmBarrier(sqlite3_file *pFile){
223138 rbu_file *p = (rbu_file *)pFile;
223145 static int rbuVfsShmUnmap(sqlite3_file *pFile, int delFlag){
223146 rbu_file *p = (rbu_file*)pFile;
223167 sqlite3_file *pFile,
223212 rbu_file *pFd = (rbu_file *)pFile;
223269 pFile->pMethods = &rbuvfs_io_methods1;
223271 pFile->pMethods = &rbuvfs_io_methods;