Many hyperlinks are disabled.
Use anonymous login
to enable hyperlinks.
Overview
Comment: | Use type i64 instead of off_t for file offsets since off_t is giving portability problems. Ticket #924. (CVS 1992) |
---|---|
Downloads: | Tarball | ZIP archive |
Timelines: | family | ancestors | descendants | both | trunk |
Files: | files | file ages | folders |
SHA1: |
8972c004dc825f668d952e7d082a8904 |
User & Date: | drh 2004-10-01 02:00:31.000 |
Context
2004-10-01
| ||
03:02 | Fully release exclusive locks in the Unlock primitive of Unix. Ticket #913. (CVS 1993) (check-in: 11a37a74b1 user: drh tags: trunk) | |
02:00 | Use type i64 instead of off_t for file offsets since off_t is giving portability problems. Ticket #924. (CVS 1992) (check-in: 8972c004dc user: drh tags: trunk) | |
2004-09-30
| ||
14:24 | Strict prototype on sqlite3_libversion(). Ticket #936 (CVS 1991) (check-in: 1d3c6f7351 user: drh tags: trunk) | |
Changes
Changes to src/date.c.
︙ | ︙ | |||
12 13 14 15 16 17 18 | ** This file contains the C functions that implement date and time ** functions for SQLite. ** ** There is only one exported symbol in this file - the function ** sqlite3RegisterDateTimeFunctions() found at the bottom of the file. ** All other code has file scope. ** | | | 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 | ** This file contains the C functions that implement date and time ** functions for SQLite. ** ** There is only one exported symbol in this file - the function ** sqlite3RegisterDateTimeFunctions() found at the bottom of the file. ** All other code has file scope. ** ** $Id: date.c,v 1.36 2004/10/01 02:00:31 drh Exp $ ** ** NOTES: ** ** SQLite processes all times and dates as Julian Day numbers. The ** dates and times are stored as the number of days since noon ** in Greenwich on November 24, 4714 B.C. according to the Gregorian ** calendar system. |
︙ | ︙ | |||
43 44 45 46 47 48 49 | ** ** Jean Meeus ** Astronomical Algorithms, 2nd Edition, 1998 ** ISBM 0-943396-61-1 ** Willmann-Bell, Inc ** Richmond, Virginia (USA) */ | | | | 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 | ** ** Jean Meeus ** Astronomical Algorithms, 2nd Edition, 1998 ** ISBM 0-943396-61-1 ** Willmann-Bell, Inc ** Richmond, Virginia (USA) */ #include "sqliteInt.h" #include "os.h" #include <ctype.h> #include <stdlib.h> #include <assert.h> #include <time.h> #ifndef SQLITE_OMIT_DATETIME_FUNCS |
︙ | ︙ |
Changes to src/os.h.
︙ | ︙ | |||
175 176 177 178 179 180 181 | int sqlite3OsOpenReadOnly(const char*, OsFile*); int sqlite3OsOpenDirectory(const char*, OsFile*); int sqlite3OsSyncDirectory(const char*); int sqlite3OsTempFileName(char*); int sqlite3OsClose(OsFile*); int sqlite3OsRead(OsFile*, void*, int amt); int sqlite3OsWrite(OsFile*, const void*, int amt); | | | | | 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 | int sqlite3OsOpenReadOnly(const char*, OsFile*); int sqlite3OsOpenDirectory(const char*, OsFile*); int sqlite3OsSyncDirectory(const char*); int sqlite3OsTempFileName(char*); int sqlite3OsClose(OsFile*); int sqlite3OsRead(OsFile*, void*, int amt); int sqlite3OsWrite(OsFile*, const void*, int amt); int sqlite3OsSeek(OsFile*, i64 offset); int sqlite3OsSync(OsFile*); int sqlite3OsTruncate(OsFile*, i64 size); int sqlite3OsFileSize(OsFile*, i64 *pSize); int sqlite3OsRandomSeed(char*); int sqlite3OsSleep(int ms); int sqlite3OsCurrentTime(double*); int sqlite3OsFileModTime(OsFile*, double*); void sqlite3OsEnterMutex(void); void sqlite3OsLeaveMutex(void); char *sqlite3OsFullPathname(const char*); |
︙ | ︙ |
Changes to src/os_mac.c.
︙ | ︙ | |||
9 10 11 12 13 14 15 | ** May you share freely, never taking more than you give. ** ****************************************************************************** ** ** This file contains code that is specific classic mac. Mac OS X ** uses the os_unix.c file, not this one. */ | > | < | 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 | ** May you share freely, never taking more than you give. ** ****************************************************************************** ** ** This file contains code that is specific classic mac. Mac OS X ** uses the os_unix.c file, not this one. */ #include "sqliteInt.h" #include "os.h" #if OS_MAC /* This file used on classic mac only */ #include <extras.h> #include <path2fss.h> #include <TextUtils.h> #include <FinderRegistry.h> #include <Folders.h> #include <Timer.h> |
︙ | ︙ |
Changes to src/os_mac.h.
︙ | ︙ | |||
15 16 17 18 19 20 21 | */ #ifndef _SQLITE_OS_MAC_H_ #define _SQLITE_OS_MAC_H_ #include <unistd.h> #include <Files.h> | < < < < < | 15 16 17 18 19 20 21 22 23 24 25 26 27 28 | */ #ifndef _SQLITE_OS_MAC_H_ #define _SQLITE_OS_MAC_H_ #include <unistd.h> #include <Files.h> #define SQLITE_TEMPNAME_SIZE _MAX_PATH #define SQLITE_MIN_SLEEP_MS 17 /* ** The OsFile structure is a operating-system independing representation ** of an open file handle. It is defined differently for each architecture. ** |
︙ | ︙ |
Changes to src/os_test.c.
︙ | ︙ | |||
9 10 11 12 13 14 15 | ** May you share freely, never taking more than you give. ** ****************************************************************************** ** ** This file contains code that is specific to Unix systems. It is used ** for testing SQLite only. */ | < > | 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 | ** May you share freely, never taking more than you give. ** ****************************************************************************** ** ** This file contains code that is specific to Unix systems. It is used ** for testing SQLite only. */ #if OS_TEST /* This file is used for the test backend only */ #include "sqliteInt.h" #include "os.h" /* Must be first to enable large file support */ #define sqlite3OsOpenReadWrite sqlite3RealOpenReadWrite #define sqlite3OsOpenExclusive sqlite3RealOpenExclusive #define sqlite3OsOpenReadOnly sqlite3RealOpenReadOnly #define sqlite3OsOpenDirectory sqlite3RealOpenDirectory #define sqlite3OsClose sqlite3RealClose #define sqlite3OsRead sqlite3RealRead |
︙ | ︙ | |||
145 146 147 148 149 150 151 | *id = 0; } /* ** Return the current seek offset from the start of the file. This ** is unix-only code. */ | | | | 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 | *id = 0; } /* ** Return the current seek offset from the start of the file. This ** is unix-only code. */ static i64 osTell(OsTestFile *pFile){ return lseek(pFile->fd.h, 0, SEEK_CUR); } /* ** Load block 'blk' into the cache of pFile. */ static int cacheBlock(OsTestFile *pFile, int blk){ if( blk>=pFile->nBlk ){ int n = ((pFile->nBlk * 2) + 100 + blk); /* if( pFile->nBlk==0 ){ printf("DIRTY %s\n", pFile->zName); } */ pFile->apBlk = (u8 **)sqliteRealloc(pFile->apBlk, n * sizeof(u8*)); if( !pFile->apBlk ) return SQLITE_NOMEM; memset(&pFile->apBlk[pFile->nBlk], 0, (n - pFile->nBlk)*sizeof(u8*)); pFile->nBlk = n; } if( !pFile->apBlk[blk] ){ i64 filesize; int rc; u8 *p = sqliteMalloc(BLOCKSIZE); if( !p ) return SQLITE_NOMEM; pFile->apBlk[blk] = p; rc = sqlite3RealFileSize(&pFile->fd, &filesize); |
︙ | ︙ | |||
197 198 199 200 201 202 203 | /* ** Write the cache of pFile to disk. If crash is non-zero, randomly ** skip blocks when writing. The cache is deleted before returning. */ static int writeCache2(OsTestFile *pFile, int crash){ int i; int nMax = pFile->nMaxWrite; | | | 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 | /* ** Write the cache of pFile to disk. If crash is non-zero, randomly ** skip blocks when writing. The cache is deleted before returning. */ static int writeCache2(OsTestFile *pFile, int crash){ int i; int nMax = pFile->nMaxWrite; i64 offset; int rc = SQLITE_OK; offset = osTell(pFile); for(i=0; i<pFile->nBlk; i++){ u8 *p = pFile->apBlk[i]; if( p ){ int skip = 0; |
︙ | ︙ | |||
291 292 293 294 295 296 297 | sqlite3RealClose(&(*id)->fd); } closeFile(id); return SQLITE_OK; } int sqlite3OsRead(OsFile *id, void *pBuf, int amt){ | | | | 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 | sqlite3RealClose(&(*id)->fd); } closeFile(id); return SQLITE_OK; } int sqlite3OsRead(OsFile *id, void *pBuf, int amt){ i64 offset; /* The current offset from the start of the file */ i64 end; /* The byte just past the last byte read */ int blk; /* Block number the read starts on */ int i; u8 *zCsr; int rc = SQLITE_OK; OsTestFile *pFile = *id; offset = osTell(pFile); |
︙ | ︙ | |||
336 337 338 339 340 341 342 | assert( zCsr==&((u8 *)pBuf)[amt] ); rc = sqlite3RealSeek(&pFile->fd, end); return rc; } int sqlite3OsWrite(OsFile *id, const void *pBuf, int amt){ | | | | 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 | assert( zCsr==&((u8 *)pBuf)[amt] ); rc = sqlite3RealSeek(&pFile->fd, end); return rc; } int sqlite3OsWrite(OsFile *id, const void *pBuf, int amt){ i64 offset; /* The current offset from the start of the file */ i64 end; /* The byte just past the last byte written */ int blk; /* Block number the write starts on */ int i; const u8 *zCsr; int rc = SQLITE_OK; OsTestFile *pFile = *id; offset = osTell(pFile); |
︙ | ︙ | |||
399 400 401 402 403 404 405 | } /* ** Truncate the file. Set the internal OsFile.nMaxWrite variable to the new ** file size to ensure that nothing in the write-cache past this point ** is written to disk. */ | | | | 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 | } /* ** Truncate the file. Set the internal OsFile.nMaxWrite variable to the new ** file size to ensure that nothing in the write-cache past this point ** is written to disk. */ int sqlite3OsTruncate(OsFile *id, i64 nByte){ (*id)->nMaxWrite = nByte; return sqlite3RealTruncate(&(*id)->fd, nByte); } /* ** Return the size of the file. If the cache contains a write that extended ** the file, then return this size instead of the on-disk size. */ int sqlite3OsFileSize(OsFile *id, i64 *pSize){ int rc = sqlite3RealFileSize(&(*id)->fd, pSize); if( rc==SQLITE_OK && pSize && *pSize<(*id)->nMaxWrite ){ *pSize = (*id)->nMaxWrite; } return rc; } |
︙ | ︙ | |||
438 439 440 441 442 443 444 | return sqlite3RealOpenReadOnly(zFilename, &(*id)->fd); } /* ** These six function calls are passed straight through to the os_unix.c ** backend. */ | | | 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 | return sqlite3RealOpenReadOnly(zFilename, &(*id)->fd); } /* ** These six function calls are passed straight through to the os_unix.c ** backend. */ int sqlite3OsSeek(OsFile *id, i64 offset){ return sqlite3RealSeek(&(*id)->fd, offset); } int sqlite3OsCheckReservedLock(OsFile *id){ return sqlite3RealCheckReservedLock(&(*id)->fd); } int sqlite3OsLock(OsFile *id, int locktype){ return sqlite3RealLock(&(*id)->fd, locktype); |
︙ | ︙ |
Changes to src/os_unix.c.
︙ | ︙ | |||
8 9 10 11 12 13 14 | ** May you find forgiveness for yourself and forgive others. ** May you share freely, never taking more than you give. ** ****************************************************************************** ** ** This file contains code that is specific to Unix systems. */ | > | < > | 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 | ** May you find forgiveness for yourself and forgive others. ** May you share freely, never taking more than you give. ** ****************************************************************************** ** ** This file contains code that is specific to Unix systems. */ #include "sqliteInt.h" #include "os.h" #if OS_UNIX /* This file is used on unix only */ #include <time.h> #include <errno.h> #include <unistd.h> #ifndef O_LARGEFILE # define O_LARGEFILE 0 #endif #ifdef SQLITE_DISABLE_LFS # undef O_LARGEFILE # define O_LARGEFILE 0 #endif #ifndef O_NOFOLLOW # define O_NOFOLLOW 0 #endif #ifndef O_BINARY # define O_BINARY 0 #endif /* ** The DJGPP compiler environment looks mostly like Unix, but it ** lacks the fcntl() system call. So redefine fcntl() to be something ** that always succeeds. This means that locking does not occur under ** DJGPP. But its DOS - what did you expect? */ |
︙ | ︙ | |||
658 659 660 661 662 663 664 | } return SQLITE_OK; } /* ** Move the read/write pointer in a file. */ | | | 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 | } return SQLITE_OK; } /* ** Move the read/write pointer in a file. */ int sqlite3OsSeek(OsFile *id, i64 offset){ assert( id->isOpen ); SEEK(offset/1024 + 1); lseek(id->h, offset, SEEK_SET); return SQLITE_OK; } /* |
︙ | ︙ | |||
729 730 731 732 733 734 735 | close(fd); return ((r==0)?SQLITE_OK:SQLITE_IOERR); } /* ** Truncate an open file to a specified size */ | | | | 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 | close(fd); return ((r==0)?SQLITE_OK:SQLITE_IOERR); } /* ** Truncate an open file to a specified size */ int sqlite3OsTruncate(OsFile *id, i64 nByte){ assert( id->isOpen ); SimulateIOError(SQLITE_IOERR); return ftruncate(id->h, nByte)==0 ? SQLITE_OK : SQLITE_IOERR; } /* ** Determine the current size of a file in bytes */ int sqlite3OsFileSize(OsFile *id, i64 *pSize){ struct stat buf; assert( id->isOpen ); SimulateIOError(SQLITE_IOERR); if( fstat(id->h, &buf)!=0 ){ return SQLITE_IOERR; } *pSize = buf.st_size; |
︙ | ︙ |
Changes to src/os_win.c.
︙ | ︙ | |||
8 9 10 11 12 13 14 | ** May you find forgiveness for yourself and forgive others. ** May you share freely, never taking more than you give. ** ****************************************************************************** ** ** This file contains code that is specific to windows. */ | > | < | 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 | ** May you find forgiveness for yourself and forgive others. ** May you share freely, never taking more than you give. ** ****************************************************************************** ** ** This file contains code that is specific to windows. */ #include "sqliteInt.h" #include "os.h" #if OS_WIN /* This file is used for windows only */ #include <winbase.h> /* ** Macros used to determine whether or not to use threads. */ #if defined(THREADSAFE) && THREADSAFE |
︙ | ︙ | |||
289 290 291 292 293 294 295 | } return SQLITE_OK; } /* ** Move the read/write pointer in a file. */ | | | 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 | } return SQLITE_OK; } /* ** Move the read/write pointer in a file. */ int sqlite3OsSeek(OsFile *id, i64 offset){ LONG upperBits = offset>>32; LONG lowerBits = offset & 0xffffffff; DWORD rc; assert( id->isOpen ); SEEK(offset/1024 + 1); rc = SetFilePointer(id->h, lowerBits, &upperBits, FILE_BEGIN); TRACE3("SEEK %d %lld\n", id->h, offset); |
︙ | ︙ | |||
325 326 327 328 329 330 331 | SimulateIOError(SQLITE_IOERR); return SQLITE_OK; } /* ** Truncate an open file to a specified size */ | | | | | 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 | SimulateIOError(SQLITE_IOERR); return SQLITE_OK; } /* ** Truncate an open file to a specified size */ int sqlite3OsTruncate(OsFile *id, i64 nByte){ LONG upperBits = nByte>>32; assert( id->isOpen ); TRACE3("TRUNCATE %d %lld\n", id->h, nByte); SimulateIOError(SQLITE_IOERR); SetFilePointer(id->h, nByte, &upperBits, FILE_BEGIN); SetEndOfFile(id->h); return SQLITE_OK; } /* ** Determine the current size of a file in bytes */ int sqlite3OsFileSize(OsFile *id, i64 *pSize){ DWORD upperBits, lowerBits; assert( id->isOpen ); SimulateIOError(SQLITE_IOERR); lowerBits = GetFileSize(id->h, &upperBits); *pSize = (((i64)upperBits)<<32) + lowerBits; return SQLITE_OK; } /* ** Return true (non-zero) if we are running under WinNT, Win2K or WinXP. ** Return false (zero) for Win95, Win98, or WinME. ** |
︙ | ︙ |
Changes to src/os_win.h.
︙ | ︙ | |||
14 15 16 17 18 19 20 | */ #ifndef _SQLITE_OS_WIN_H_ #define _SQLITE_OS_WIN_H_ #include <windows.h> #include <winbase.h> | < < < < < < < < < < < | 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | */ #ifndef _SQLITE_OS_WIN_H_ #define _SQLITE_OS_WIN_H_ #include <windows.h> #include <winbase.h> /* ** The OsFile structure is a operating-system independing representation ** of an open file handle. It is defined differently for each architecture. ** ** This is the definition for Win32. */ typedef struct OsFile OsFile; |
︙ | ︙ |
Changes to src/pager.c.
︙ | ︙ | |||
14 15 16 17 18 19 20 | ** The pager is used to access a database disk file. It implements ** atomic commit and rollback through the use of a journal file that ** is separate from the database file. The pager also implements file ** locking to prevent two processes from writing the same database ** file simultaneously, or one process from reading the database while ** another is writing. ** | | | | | 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 | ** The pager is used to access a database disk file. It implements ** atomic commit and rollback through the use of a journal file that ** is separate from the database file. The pager also implements file ** locking to prevent two processes from writing the same database ** file simultaneously, or one process from reading the database while ** another is writing. ** ** @(#) $Id: pager.c,v 1.165 2004/10/01 02:00:31 drh Exp $ */ #include "sqliteInt.h" #include "os.h" #include "pager.h" #include <assert.h> #include <string.h> /* ** Macros for troubleshooting. Normally turned off */ |
︙ | ︙ | |||
186 187 188 189 190 191 192 | char *zJournal; /* Name of the journal file */ char *zDirectory; /* Directory hold database and journal files */ OsFile fd, jfd; /* File descriptors for database and journal */ OsFile stfd; /* File descriptor for the statement subjournal*/ int dbSize; /* Number of pages in the file */ int origDbSize; /* dbSize before the current change */ int stmtSize; /* Size of database (in pages) at stmt_begin() */ | | | 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 | char *zJournal; /* Name of the journal file */ char *zDirectory; /* Directory hold database and journal files */ OsFile fd, jfd; /* File descriptors for database and journal */ OsFile stfd; /* File descriptor for the statement subjournal*/ int dbSize; /* Number of pages in the file */ int origDbSize; /* dbSize before the current change */ int stmtSize; /* Size of database (in pages) at stmt_begin() */ i64 stmtJSize; /* Size of journal at stmt_begin() */ int nRec; /* Number of pages written to the journal */ u32 cksumInit; /* Quasi-random value added to every checksum */ int stmtNRec; /* Number of records in stmt subjournal */ int nExtra; /* Add this many bytes to each in-memory page */ void (*xDestructor)(void*,int); /* Call this routine when freeing pages */ void (*xReiniter)(void*,int); /* Call this routine when reloading pages */ int pageSize; /* Number of bytes in a page */ |
︙ | ︙ | |||
224 225 226 227 228 229 230 | u8 *aInStmt; /* One bit for each page in the database */ u8 setMaster; /* True if a m-j name has been written to jrnl */ BusyHandler *pBusyHandler; /* Pointer to sqlite.busyHandler */ PgHdr *pFirst, *pLast; /* List of free pages */ PgHdr *pFirstSynced; /* First free page with PgHdr.needSync==0 */ PgHdr *pAll; /* List of all pages */ PgHdr *pStmt; /* List of pages in the statement subjournal */ | | | | | | 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 | u8 *aInStmt; /* One bit for each page in the database */ u8 setMaster; /* True if a m-j name has been written to jrnl */ BusyHandler *pBusyHandler; /* Pointer to sqlite.busyHandler */ PgHdr *pFirst, *pLast; /* List of free pages */ PgHdr *pFirstSynced; /* First free page with PgHdr.needSync==0 */ PgHdr *pAll; /* List of all pages */ PgHdr *pStmt; /* List of pages in the statement subjournal */ i64 journalOff; /* Current byte offset in the journal file */ i64 journalHdr; /* Byte offset to previous journal header */ i64 stmtHdrOff; /* First journal header written this statement */ i64 stmtCksum; /* cksumInit when statement was started */ int sectorSize; /* Assumed sector size during rollback */ PgHdr *aHash[N_PG_HASH]; /* Hash table to map page number to PgHdr */ }; /* ** These are bits that can be set in Pager.errMask. */ |
︙ | ︙ | |||
395 396 397 398 399 400 401 | ** ** If no master journal file name is present *pzMaster is set to 0 and ** SQLITE_OK returned. */ static int readMasterJournal(OsFile *pJrnl, char **pzMaster){ int rc; u32 len; | | | 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 | ** ** If no master journal file name is present *pzMaster is set to 0 and ** SQLITE_OK returned. */ static int readMasterJournal(OsFile *pJrnl, char **pzMaster){ int rc; u32 len; i64 szJ; u32 cksum; int i; unsigned char aMagic[8]; /* A buffer to hold the magic header */ *pzMaster = 0; rc = sqlite3OsFileSize(pJrnl, &szJ); |
︙ | ︙ | |||
465 466 467 468 469 470 471 | ** 0 0 ** 512 512 ** 100 512 ** 2000 2048 ** */ static int seekJournalHdr(Pager *pPager){ | | | | 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 | ** 0 0 ** 512 512 ** 100 512 ** 2000 2048 ** */ static int seekJournalHdr(Pager *pPager){ i64 offset = 0; i64 c = pPager->journalOff; if( c ){ offset = ((c-1)/JOURNAL_HDR_SZ(pPager) + 1) * JOURNAL_HDR_SZ(pPager); } assert( offset%JOURNAL_HDR_SZ(pPager)==0 ); assert( offset>=c ); assert( (offset-c)<JOURNAL_HDR_SZ(pPager) ); pPager->journalOff = offset; |
︙ | ︙ | |||
558 559 560 561 562 563 564 | ** ** If the journal header file appears to be corrupted, SQLITE_DONE is ** returned and *nRec and *dbSize are not set. If JOURNAL_HDR_SZ bytes ** cannot be read from the journal file an error code is returned. */ static int readJournalHdr( Pager *pPager, | | | 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 | ** ** If the journal header file appears to be corrupted, SQLITE_DONE is ** returned and *nRec and *dbSize are not set. If JOURNAL_HDR_SZ bytes ** cannot be read from the journal file an error code is returned. */ static int readJournalHdr( Pager *pPager, i64 journalSize, u32 *pNRec, u32 *pDbSize ){ int rc; unsigned char aMagic[8]; /* A buffer to hold the magic header */ rc = seekJournalHdr(pPager); |
︙ | ︙ | |||
867 868 869 870 871 872 873 | ** If in EXCLUSIVE state, then we update the pager cache if it exists ** and the main file. The page is then marked not dirty. */ pPg = pager_lookup(pPager, pgno); assert( pPager->state>=PAGER_EXCLUSIVE || pPg ); TRACE3("PLAYBACK %d page %d\n", pPager->fd.h, pgno); if( pPager->state>=PAGER_EXCLUSIVE ){ | | | 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 | ** If in EXCLUSIVE state, then we update the pager cache if it exists ** and the main file. The page is then marked not dirty. */ pPg = pager_lookup(pPager, pgno); assert( pPager->state>=PAGER_EXCLUSIVE || pPg ); TRACE3("PLAYBACK %d page %d\n", pPager->fd.h, pgno); if( pPager->state>=PAGER_EXCLUSIVE ){ sqlite3OsSeek(&pPager->fd, (pgno-1)*(i64)pPager->pageSize); rc = sqlite3OsWrite(&pPager->fd, aData, pPager->pageSize); } if( pPg ){ /* No page should ever be rolled back that is in use, except for page ** 1 which is held in use in order to keep the lock on the database ** active. */ |
︙ | ︙ | |||
907 908 909 910 911 912 913 | ** a different master journal, then this master journal can be deleted. */ static int pager_delmaster(const char *zMaster){ int rc; int master_open = 0; OsFile master; char *zMasterJournal = 0; /* Contents of master journal file */ | | | 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 | ** a different master journal, then this master journal can be deleted. */ static int pager_delmaster(const char *zMaster){ int rc; int master_open = 0; OsFile master; char *zMasterJournal = 0; /* Contents of master journal file */ i64 nMasterJournal; /* Size of master journal file */ /* Open the master journal file exclusively in case some other process ** is running this routine also. Not that it makes too much difference. */ memset(&master, 0, sizeof(master)); rc = sqlite3OsOpenReadOnly(zMaster, &master); if( rc!=SQLITE_OK ) goto delmaster_out; |
︙ | ︙ | |||
992 993 994 995 996 997 998 | static int pager_reload_cache(Pager *pPager){ PgHdr *pPg; int rc = SQLITE_OK; for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){ char zBuf[SQLITE_MAX_PAGE_SIZE]; if( !pPg->dirty ) continue; if( (int)pPg->pgno <= pPager->origDbSize ){ | | | 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 | static int pager_reload_cache(Pager *pPager){ PgHdr *pPg; int rc = SQLITE_OK; for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){ char zBuf[SQLITE_MAX_PAGE_SIZE]; if( !pPg->dirty ) continue; if( (int)pPg->pgno <= pPager->origDbSize ){ sqlite3OsSeek(&pPager->fd, pPager->pageSize*(i64)(pPg->pgno-1)); rc = sqlite3OsRead(&pPager->fd, zBuf, pPager->pageSize); TRACE3("REFETCH %d page %d\n", pPager->fd.h, pPg->pgno); if( rc ) break; CODEC(pPager, zBuf, pPg->pgno, 2); }else{ memset(zBuf, 0, pPager->pageSize); } |
︙ | ︙ | |||
1019 1020 1021 1022 1023 1024 1025 | } /* ** Truncate the main file of the given pager to the number of pages ** indicated. */ static int pager_truncate(Pager *pPager, int nPage){ | | | 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 | } /* ** Truncate the main file of the given pager to the number of pages ** indicated. */ static int pager_truncate(Pager *pPager, int nPage){ return sqlite3OsTruncate(&pPager->fd, pPager->pageSize*(i64)nPage); } /* ** Playback the journal and thus restore the database file to ** the state it was in before we started making changes. ** ** The journal file format is as follows: |
︙ | ︙ | |||
1076 1077 1078 1079 1080 1081 1082 | ** is then deleted and SQLITE_OK returned, just as if no corruption had ** been encountered. ** ** If an I/O or malloc() error occurs, the journal-file is not deleted ** and an error code is returned. */ static int pager_playback(Pager *pPager){ | | | 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 | ** is then deleted and SQLITE_OK returned, just as if no corruption had ** been encountered. ** ** If an I/O or malloc() error occurs, the journal-file is not deleted ** and an error code is returned. */ static int pager_playback(Pager *pPager){ i64 szJ; /* Size of the journal file in bytes */ u32 nRec; /* Number of Records in the journal */ int i; /* Loop counter */ Pgno mxPg = 0; /* Size of the original file in pages */ int rc; /* Result code of a subroutine */ char *zMaster = 0; /* Name of master journal file if any */ /* Figure out how many records are in the journal. Abort early if |
︙ | ︙ | |||
1211 1212 1213 1214 1215 1216 1217 | ** journal file itself. ** ** (2) In addition to playing back the statement journal, also ** playback all pages of the transaction journal beginning ** at offset pPager->stmtJSize. */ static int pager_stmt_playback(Pager *pPager){ | | | | | 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 | ** journal file itself. ** ** (2) In addition to playing back the statement journal, also ** playback all pages of the transaction journal beginning ** at offset pPager->stmtJSize. */ static int pager_stmt_playback(Pager *pPager){ i64 szJ; /* Size of the full journal */ i64 hdrOff; int nRec; /* Number of Records */ int i; /* Loop counter */ int rc; szJ = pPager->journalOff; #ifndef NDEBUG { i64 os_szJ; rc = sqlite3OsFileSize(&pPager->jfd, &os_szJ); if( rc!=SQLITE_OK ) return rc; assert( szJ==os_szJ ); } #endif /* Set hdrOff to be the offset to the first journal header written |
︙ | ︙ | |||
1562 1563 1564 1565 1566 1567 1568 | } /* ** Return the total number of pages in the disk file associated with ** pPager. */ int sqlite3pager_pagecount(Pager *pPager){ | | | 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 | } /* ** Return the total number of pages in the disk file associated with ** pPager. */ int sqlite3pager_pagecount(Pager *pPager){ i64 n; assert( pPager!=0 ); if( pPager->dbSize>=0 ){ return pPager->dbSize; } if( sqlite3OsFileSize(&pPager->fd, &n)!=SQLITE_OK ){ pPager->errMask |= PAGER_ERR_DISK; return 0; |
︙ | ︙ | |||
1848 1849 1850 1851 1852 1853 1854 | /* assert( !pPager->noSync ); // noSync might be set if synchronous ** was turned off after the transaction was started. Ticket #615 */ #ifndef NDEBUG { /* Make sure the pPager->nRec counter we are keeping agrees ** with the nRec computed from the size of the journal file. */ | | | 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 | /* assert( !pPager->noSync ); // noSync might be set if synchronous ** was turned off after the transaction was started. Ticket #615 */ #ifndef NDEBUG { /* Make sure the pPager->nRec counter we are keeping agrees ** with the nRec computed from the size of the journal file. */ i64 jSz; rc = sqlite3OsFileSize(&pPager->jfd, &jSz); if( rc!=0 ) return rc; assert( pPager->journalOff==jSz ); } #endif { /* Write the nRec value into the journal file header. If in |
︙ | ︙ | |||
1945 1946 1947 1948 1949 1950 1951 | if( rc!=SQLITE_OK ){ return rc; } pPager->state = PAGER_EXCLUSIVE; while( pList ){ assert( pList->dirty ); | | | 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 | if( rc!=SQLITE_OK ){ return rc; } pPager->state = PAGER_EXCLUSIVE; while( pList ){ assert( pList->dirty ); sqlite3OsSeek(&pPager->fd, (pList->pgno-1)*(i64)pPager->pageSize); CODEC(pPager, PGHDR_TO_DATA(pList), pList->pgno, 6); TRACE3("STORE %d page %d\n", pPager->fd.h, pList->pgno); rc = sqlite3OsWrite(&pPager->fd, PGHDR_TO_DATA(pList), pPager->pageSize); CODEC(pPager, PGHDR_TO_DATA(pList), pList->pgno, 0); if( rc ) return rc; pList->dirty = 0; pList = pList->pDirty; |
︙ | ︙ | |||
2222 2223 2224 2225 2226 2227 2228 | return rc; } if( pPager->dbSize<(int)pgno ){ memset(PGHDR_TO_DATA(pPg), 0, pPager->pageSize); }else{ int rc; assert( pPager->memDb==0 ); | | | | 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 | return rc; } if( pPager->dbSize<(int)pgno ){ memset(PGHDR_TO_DATA(pPg), 0, pPager->pageSize); }else{ int rc; assert( pPager->memDb==0 ); sqlite3OsSeek(&pPager->fd, (pgno-1)*(i64)pPager->pageSize); rc = sqlite3OsRead(&pPager->fd, PGHDR_TO_DATA(pPg), pPager->pageSize); TRACE3("FETCH %d page %d\n", pPager->fd.h, pPg->pgno); CODEC(pPager, PGHDR_TO_DATA(pPg), pPg->pgno, 3); if( rc!=SQLITE_OK ){ i64 fileSize; if( sqlite3OsFileSize(&pPager->fd,&fileSize)!=SQLITE_OK || fileSize>=pgno*pPager->pageSize ){ sqlite3pager_unref(PGHDR_TO_DATA(pPg)); return rc; }else{ memset(PGHDR_TO_DATA(pPg), 0, pPager->pageSize); } |
︙ | ︙ |
Changes to src/sqliteInt.h.
1 2 3 4 5 6 7 8 9 10 11 12 13 | /* ** 2001 September 15 ** ** The author disclaims copyright to this source code. In place of ** a legal notice, here is a blessing: ** ** May you do good and not evil. ** May you find forgiveness for yourself and forgive others. ** May you share freely, never taking more than you give. ** ************************************************************************* ** Internal interface definitions for SQLite. ** | | > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 | /* ** 2001 September 15 ** ** The author disclaims copyright to this source code. In place of ** a legal notice, here is a blessing: ** ** May you do good and not evil. ** May you find forgiveness for yourself and forgive others. ** May you share freely, never taking more than you give. ** ************************************************************************* ** Internal interface definitions for SQLite. ** ** @(#) $Id: sqliteInt.h,v 1.325 2004/10/01 02:00:31 drh Exp $ */ #ifndef _SQLITEINT_H_ #define _SQLITEINT_H_ /* ** These #defines should enable >2GB file support on Posix if the ** underlying operating system supports it. If the OS lacks ** large file support, or if the OS is windows, these should be no-ops. ** ** Large file support can be disabled using the -DSQLITE_DISABLE_LFS switch ** on the compiler command line. This is necessary if you are compiling ** on a recent machine (ex: RedHat 7.2) but you want your code to work ** on an older machine (ex: RedHat 6.0). If you compile on RedHat 7.2 ** without this option, LFS is enable. But LFS does not exist in the kernel ** in RedHat 6.0, so the code won't work. Hence, for maximum binary ** portability you should omit LFS. ** ** Similar is true for MacOS. LFS is only supported on MacOS 9 and later. */ #ifndef SQLITE_DISABLE_LFS # define _LARGE_FILE 1 # ifndef _FILE_OFFSET_BITS # define _FILE_OFFSET_BITS 64 # endif # define _LARGEFILE_SOURCE 1 #endif #include "config.h" #include "sqlite3.h" #include "hash.h" #include "parse.h" #include <stdio.h> #include <stdlib.h> #include <string.h> |
︙ | ︙ |
Changes to src/test2.c.
︙ | ︙ | |||
9 10 11 12 13 14 15 | ** May you share freely, never taking more than you give. ** ************************************************************************* ** Code for testing the pager.c module in SQLite. This code ** is not included in the SQLite library. It is used for automated ** testing of the SQLite library. ** | | | | | 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 | ** May you share freely, never taking more than you give. ** ************************************************************************* ** Code for testing the pager.c module in SQLite. This code ** is not included in the SQLite library. It is used for automated ** testing of the SQLite library. ** ** $Id: test2.c,v 1.26 2004/10/01 02:00:31 drh Exp $ */ #include "sqliteInt.h" #include "os.h" #include "pager.h" #include "tcl.h" #include <stdlib.h> #include <string.h> /* ** Interpret an SQLite error number |
︙ | ︙ | |||
493 494 495 496 497 498 499 | void *NotUsed, Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ int argc, /* Number of arguments */ const char **argv /* Text of each argument */ ){ int rc; int n; | | | 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 | void *NotUsed, Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ int argc, /* Number of arguments */ const char **argv /* Text of each argument */ ){ int rc; int n; i64 offset; OsFile fd; int readOnly = 0; if( argc!=3 ){ Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], " N-MEGABYTES FILE\"", 0); return TCL_ERROR; } |
︙ | ︙ |