LIBOBJ = alter.lo analyze.lo attach.lo auth.lo btree.lo build.lo \
callback.lo complete.lo date.lo \
delete.lo expr.lo func.lo hash.lo insert.lo \
- main.lo opcodes.lo os_unix.lo os_win.lo \
+ main.lo opcodes.lo os.lo os_unix.lo os_win.lo \
pager.lo parse.lo pragma.lo prepare.lo printf.lo random.lo \
select.lo table.lo tokenize.lo trigger.lo update.lo \
util.lo vacuum.lo \
$(TOP)/src/insert.c \
$(TOP)/src/legacy.c \
$(TOP)/src/main.c \
+ $(TOP)/src/os.c \
$(TOP)/src/os_unix.c \
$(TOP)/src/os_win.c \
$(TOP)/src/pager.c \
opcodes.h: parse.h $(TOP)/src/vdbe.c $(TOP)/mkopcodeh.awk
cat parse.h $(TOP)/src/vdbe.c | awk -f $(TOP)/mkopcodeh.awk >opcodes.h
+os.lo: $(TOP)/src/os.c $(HDR)
+ $(LTCOMPILE) -c $(TOP)/src/os.c
+
os_unix.lo: $(TOP)/src/os_unix.c $(HDR)
$(LTCOMPILE) -c $(TOP)/src/os_unix.c
LIBOBJ+= alter.o analyze.o attach.o auth.o btree.o build.o \
callback.o complete.o date.o delete.o \
expr.o func.o hash.o insert.o \
- main.o opcodes.o os_unix.o os_win.o \
+ main.o opcodes.o os.o os_unix.o os_win.o \
pager.o parse.o pragma.o prepare.o printf.o random.o \
select.o table.o tclsqlite.o tokenize.o trigger.o \
update.o util.o vacuum.o \
$(TOP)/src/insert.c \
$(TOP)/src/legacy.c \
$(TOP)/src/main.c \
+ $(TOP)/src/os.c \
$(TOP)/src/os_unix.c \
$(TOP)/src/os_win.c \
$(TOP)/src/pager.c \
opcodes.h: parse.h $(TOP)/src/vdbe.c $(TOP)/mkopcodeh.awk
cat parse.h $(TOP)/src/vdbe.c | awk -f $(TOP)/mkopcodeh.awk >opcodes.h
+os.o: $(TOP)/src/os.c $(HDR)
+ $(TCCX) -c $(TOP)/src/os.c
+
os_unix.o: $(TOP)/src/os_unix.c $(HDR)
$(TCCX) -c $(TOP)/src/os_unix.c
-C The\scrash\stest\sworks\snow,\sat\sleast\son\sunix.\s\sUntested\son\swindows.\sBut\sit\snever\nworked\son\swindows\sbefore\sso\sif\sit\sstill\sdoes\snot\sthere\sis\sno\sbig\sloss.\s\sI\sam\nstill\stroubled\sby\sthe\scurrent\sdesign\sof\sthe\sOS\soverloading\smechanism.\s\sExpect\nto\ssee\smore\schanges.\s(CVS\s2794)
-D 2005-11-29T19:56:32
-F Makefile.in eac4c98a32a0eae9d6bb2779ac74bbb5441758d3
+C Restructure\sthe\sOS\sinterface\syet\sagain.\s\sThis\stime\smake\sthe\sOsFile\sobject\na\svirtual\sbase\sclass\swhich\sis\ssubclassed\sfor\sunix,\swindows,\sand\sthe\scrash\ntest\ssimulator.\s\sAdd\sthe\snew\sfile\s"os.c"\sfor\scommon\sos\slayer\scode.\s\sMove\nall\sOS-specific\sroutines\sinto\sthe\ssqlite3Os\sstructure.\s(CVS\s2795)
+D 2005-11-30T03:20:31
+F Makefile.in e3c6b3a38d734d41574c04f2fc90d18de2b87102
F Makefile.linux-gcc aee18d8a05546dcf1888bd4547e442008a49a092
F README 9c4e2d6706bdcc3efdd773ce752a8cdab4f90028
F VERSION b818cce180263e590a00ad4509a713892c3eecea
F doc/report1.txt a031aaf37b185e4fa540223cb516d3bccec7eeac
F install-sh 9d4de14ab9fb0facae2f48780b874848cbf2f895
F ltmain.sh f6b283068efa69f06eb8aa1fe4bddfdbdeb35826
-F main.mk 76d9e7bcebea556f0db40811b9273d6b704df88e
+F main.mk 19f33320f3ce5fc000de87abafca07ef4b6dffb4
F mkdll.sh 5ec23622515d5bf8969404e80cfb5e220ddf0512
F mkopcodec.awk bd46ad001c98dfbab07b1713cb8e692fa0e5415d
F mkopcodeh.awk 071dbba4eaf56c8d643baf4604a043af35683316
F src/build.c 8c93ae10563e8b92d3d7ea532a606424be3cb4f7
F src/callback.c 90ab4f235a2603c4cb8e6a2497091a71fb732bfa
F src/complete.c 4de937dfdd4c79a501772ab2035b26082f337a79
-F src/date.c 7444b0900a28da77e57e3337a636873cff0ae940
+F src/date.c 8bc8d084a17d19c44d9cbf357b5f656db6706ce1
F src/delete.c 29dac493f4d83b05f91233b116827c133bcdab72
F src/experimental.c 50c1e3b34f752f4ac10c36f287db095c2b61766d
F src/expr.c 80ceb8c7d15dd53985831f0b4c660b3c3df796a3
F src/hash.h 1b0c445e1c89ff2aaad9b4605ba61375af001e84
F src/insert.c da031c3ed8e1675fac891990095d277c2ba6e205
F src/legacy.c d58ea507bce885298a2c8c3cbb0f4bff5d47830b
-F src/main.c 97bb830cdbd378d1f87469618471f52d9d263d09
+F src/main.c 7d719efe04b760c5e0faa9e910c6d4f00f85f2f3
F src/md5.c 7ae1c39044b95de2f62e066f47bb1deb880a1070
-F src/os.h 4172cf1dfb84ce13fe5f1073accbc320b4b25ad2
+F src/os.c bdd3a2fd089777e7ad18b57c896f1141d5a0c1fd
+F src/os.h c5decb84948b4ec614903caa8da31ce86c25031e
F src/os_common.h d74a11728ad2444b6b695b94c28c06881f049e49
F src/os_test.c 49833426101f99aee4bb5f6a44b7c4b2029fda1c
F src/os_test.h 903c93554c23d88f34f667f1979e4a1cee792af3
-F src/os_unix.c 471d3642d0f41ecd4113b17b618f487cf8237f0f
+F src/os_unix.c 1a7278bf7ad95f8c62a946d6b1726a539ab5e790
F src/os_unix.h 5768d56d28240d3fe4537fac08cc85e4fb52279e
-F src/os_win.c 2095cae6b283edc4e6b9d9d6a8a509210ea51eac
+F src/os_win.c d962ac2dd0e482847e42b846d46cd044f97d1c32
F src/os_win.h 41a946bea10f61c158ce8645e7646b29d44f122b
-F src/pager.c 18cc5b274a0df28dc9145da522a6e281f80b925f
+F src/pager.c bcb54653c3020d7cde88b4e8bad81ff6f93402b4
F src/pager.h e7b41ce8e7b5f629d456708b7ad9a8c8ede37140
F src/parse.y e4d57c2fd5cc02f19822ec41f6dc2bfc9bc85609
-F src/pragma.c e278b3f722379ab9d630a1569ac05f586f01f4db
+F src/pragma.c 2793699ab0d73fa730fa8c1c7521e9436604f024
F src/prepare.c fc098db25d2a121affb08686cf04833fd50452d4
F src/printf.c 3ea3a17d25d7ac498efc18007c70371a42c968f8
-F src/random.c 90adff4e73a3b249eb4f1fc2a6ff9cf78c7233a4
+F src/random.c ff5e9a8cad790e2a51cd4d2e7737dc8540e09d1d
F src/select.c 4a9e5366f4a16bd2e6e93c05f585633887be6372
F src/shell.c 3596c1e559b82663057940d19ba533ad421c7dd3
F src/sqlite.h.in 8e648e1f386e4509f2f96c09ded7c07b0df0c9a2
F src/sqliteInt.h 4148c9778e350014c2e27b332d7a2ef7278fe62e
F src/table.c 486dcfce532685b53b5a2b5da8bba0ded6fb2316
F src/tclsqlite.c a497c3adfd2c85da6a934331ec0041e47884fbcb
-F src/test1.c c2c307a4cbbf4670f43a7b4b144dce866d1d701f
-F src/test2.c 02d639d515ddf99a3bbc00f640d8544ecb925a9b
+F src/test1.c 014f00eda1007e21631148e4168f00c9ee2568ae
+F src/test2.c 36390cdfc70c08e5ee0b466d0654a117f398bbff
F src/test3.c f4e6a16a602091696619a1171bda25c0e3df49f7
F src/test4.c a8fd681e139e1c61f22a77d07fc3a99cb28fff3f
F src/test5.c 64f08b2a50ef371a1bd68ff206829e7b1b9997f5
-F src/test6.c 951effde62e2032a3d6702a33ba2c2c2f993f412
+F src/test6.c cb811391ec0b7c75f29e545d4820a9cf19f3637e
F src/tokenize.c bdb79702217af49eba44c2a3b4f5fc7bd9ed2917
F src/trigger.c aea0283a3ef729a3e9c8dc5dc1a11c9fcc0a12a7
F src/update.c fec7665138ccf2a2133f11dcd24c1134c6b33526
F src/utf.c bda5eb85039ef16f2d17004c1e18c96e1ab0a80c
F src/util.c 48fecbbef4391d102a23096d32f0d74173428406
-F src/vacuum.c 3a9d801b642a2004e8a99efa8d19ceef3f79d8df
-F src/vdbe.c 88a85e681522e82e14c8d08adacccbe4e96dd1c9
+F src/vacuum.c c9fe2660919bd1595a7fbdeddadc16c7d9723400
+F src/vdbe.c 91b91272446d0a62b2d27d330d6a1a622acfb0fb
F src/vdbe.h 8729a4ee16ff9aeab2af9667df3cf300ff978e13
F src/vdbeInt.h 0055c37eccbf3a189fd893a90f8eb6a5fa60c871
-F src/vdbeapi.c 85bbe1d0243a89655433d60711b4bd71979b59cd
-F src/vdbeaux.c 09b9bcfed1101b53b433e5d0d7b80943bdf3d1b2
+F src/vdbeapi.c 73d56a8899d46cf0353e32a85aa1ff7f36cb24ea
+F src/vdbeaux.c 0c4af4af29d42a7f008c7562afee58b470dd6d4a
F src/vdbefifo.c 9efb94c8c3f4c979ebd0028219483f88e57584f5
F src/vdbemem.c cd9609c1e7f71ec76d9840c84c3a57ebfa6539cf
F src/where.c a9fed5a5b549f5dae1aa95dc9463cd1f35efa0f1
F www/vdbe.tcl 87a31ace769f20d3627a64fa1fade7fed47b90d0
F www/version3.tcl a99cf5f6d8bd4d5537584a2b342f0fb9fa601d8b
F www/whentouse.tcl 97e2b5cd296f7d8057e11f44427dea8a4c2db513
-P 59bdca2552b2e5c09d5ca2b7a02ee34460139d7b
-R 017afb31f003c30d6ff4dc490b01097c
+P fa1d7ecfcc648fbe9fc6d92e080cf937bdc9c439
+R 9be695e305d95d89dc0ca507829a93a0
U drh
-Z 38c6fa4706794e96cb17051f7e19d848
+Z 170795265fa237ab9dcb51e37d55abf3
-fa1d7ecfcc648fbe9fc6d92e080cf937bdc9c439
\ No newline at end of file
+bd8740d1aecba69e1b5d64d43db07e8ad8841f07
\ No newline at end of file
** sqlite3RegisterDateTimeFunctions() found at the bottom of the file.
** All other code has file scope.
**
-** $Id: date.c,v 1.45 2005/06/25 18:42:14 drh Exp $
+** $Id: date.c,v 1.46 2005/11/30 03:20:31 drh Exp $
**
** NOTES:
**
return 0;
}else if( sqlite3StrICmp(zDate,"now")==0){
double r;
- sqlite3OsCurrentTime(&r);
+ sqlite3Os.xCurrentTime(&r);
p->rJD = r;
p->validJD = 1;
return 0;
x.validJD = 0;
computeJD(&x);
t = (x.rJD-2440587.5)*86400.0 + 0.5;
- sqlite3OsEnterMutex();
+ sqlite3Os.xEnterMutex();
pTm = localtime(&t);
y.Y = pTm->tm_year + 1900;
y.M = pTm->tm_mon + 1;
y.h = pTm->tm_hour;
y.m = pTm->tm_min;
y.s = pTm->tm_sec;
- sqlite3OsLeaveMutex();
+ sqlite3Os.xLeaveMutex();
y.validYMD = 1;
y.validHMS = 1;
y.validJD = 0;
}
#endif
- sqlite3OsEnterMutex();
+ sqlite3Os.xEnterMutex();
strftime(zBuf, 20, zFormat, gmtime(&t));
- sqlite3OsLeaveMutex();
+ sqlite3Os.xLeaveMutex();
sqlite3_result_text(context, zBuf, -1, SQLITE_TRANSIENT);
}
** other files are for internal use by SQLite and should not be
** accessed by users of the library.
**
-** $Id: main.c,v 1.303 2005/10/20 07:28:18 drh Exp $
+** $Id: main.c,v 1.304 2005/11/30 03:20:31 drh Exp $
*/
#include "sqliteInt.h"
#include "os.h"
#ifndef SQLITE_OMIT_GLOBALRECOVER
{
sqlite3 *pPrev;
- sqlite3OsEnterMutex();
+ sqlite3Os.xEnterMutex();
pPrev = pDbList;
while( pPrev && pPrev->pNext!=db ){
pPrev = pPrev->pNext;
assert( pDbList==db );
pDbList = db->pNext;
}
- sqlite3OsLeaveMutex();
+ sqlite3Os.xLeaveMutex();
}
#endif
delay = timeout - prior;
if( delay<=0 ) return 0;
}
- sqlite3OsSleep(delay);
+ sqlite3Os.xSleep(delay);
return 1;
#else
int timeout = ((sqlite3 *)ptr)->busyTimeout;
if( (count+1)*1000 > timeout ){
return 0;
}
- sqlite3OsSleep(1000);
+ sqlite3Os.xSleep(1000);
return 1;
#endif
}
*ppDb = db;
#ifndef SQLITE_OMIT_GLOBALRECOVER
if( db ){
- sqlite3OsEnterMutex();
+ sqlite3Os.xEnterMutex();
db->pNext = pDbList;
pDbList = db;
- sqlite3OsLeaveMutex();
+ sqlite3Os.xLeaveMutex();
}
#endif
return sqlite3_errcode(db);
--- /dev/null
+/*
+** 2005 November 29
+**
+** 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.
+**
+******************************************************************************
+**
+** This file contains OS interface code that is common to all
+** architectures.
+*/
+#include "sqliteInt.h"
+#include "os.h"
+
+/*
+** The following routines are convenience wrappers around methods
+** of the OsFile object. This is mostly just syntactic sugar. All
+** of this would be completely automatic if SQLite were coded using
+** C++ instead of plain old C.
+*/
+int sqlite3OsClose(OsFile **pId){
+ OsFile *id;
+ if( pId!=0 && (id = *pId)!=0 ){
+ return id->pMethod->xClose(pId);
+ }else{
+ return SQLITE_OK;
+ }
+}
+int sqlite3OsOpenDirectory(OsFile *id, const char *zName){
+ return id->pMethod->xOpenDirectory(id, zName);
+}
+int sqlite3OsRead(OsFile *id, void *pBuf, int amt){
+ return id->pMethod->xRead(id, pBuf, amt);
+}
+int sqlite3OsWrite(OsFile *id, const void *pBuf, int amt){
+ return id->pMethod->xWrite(id, pBuf, amt);
+}
+int sqlite3OsSeek(OsFile *id, i64 offset){
+ return id->pMethod->xSeek(id, offset);
+}
+int sqlite3OsTruncate(OsFile *id, i64 size){
+ return id->pMethod->xTruncate(id, size);
+}
+int sqlite3OsSync(OsFile *id, int fullsync){
+ return id->pMethod->xSync(id, fullsync);
+}
+void sqlite3OsSetFullSync(OsFile *id, int value){
+ id->pMethod->xSetFullSync(id, value);
+}
+int sqlite3OsFileHandle(OsFile *id){
+ return id->pMethod->xFileHandle(id);
+}
+int sqlite3OsFileSize(OsFile *id, i64 *pSize){
+ return id->pMethod->xFileSize(id, pSize);
+}
+int sqlite3OsLock(OsFile *id, int lockType){
+ return id->pMethod->xLock(id, lockType);
+}
+int sqlite3OsUnlock(OsFile *id, int lockType){
+ return id->pMethod->xUnlock(id, lockType);
+}
+int sqlite3OsLockState(OsFile *id){
+ return id->pMethod->xLockState(id);
+}
+int sqlite3OsCheckReservedLock(OsFile *id){
+ return id->pMethod->xCheckReservedLock(id);
+}
# endif
#endif
+
/*
-** The OsFile object describes an open disk file in an OS-dependent way.
+** Forward declarations
*/
typedef struct OsFile OsFile;
+typedef struct IoMethod IoMethod;
+
+/*
+** An instance of the following structure contains pointers to all
+** methods on an OsFile object.
+*/
+struct IoMethod {
+ int (*xClose)(OsFile**);
+ int (*xOpenDirectory)(OsFile*, const char*);
+ int (*xRead)(OsFile*, void*, int amt);
+ int (*xWrite)(OsFile*, const void*, int amt);
+ int (*xSeek)(OsFile*, i64 offset);
+ int (*xTruncate)(OsFile*, i64 size);
+ int (*xSync)(OsFile*, int);
+ void (*xSetFullSync)(OsFile *id, int setting);
+ int (*xFileHandle)(OsFile *id);
+ int (*xFileSize)(OsFile*, i64 *pSize);
+ int (*xLock)(OsFile*, int);
+ int (*xUnlock)(OsFile*, int);
+ int (*xLockState)(OsFile *id);
+ int (*xCheckReservedLock)(OsFile *id);
+};
+
+/*
+** The OsFile object describes an open disk file in an OS-dependent way.
+** The version of OsFile defined here is a generic versions. Each Os
+** implementation defines its own subclass of this structure that contains
+** additional information needed to handle file I/O.
+*/
+struct OsFile {
+ IoMethod const *pMethod;
+};
/*
** Define the maximum size of a temporary filename
/*
** A single global instance of the following structure holds pointers to the
-** various disk I/O routines.
+** various system-specific interface routines.
*/
-extern struct sqlite3IoVtbl {
- int (*xDelete)(const char*);
- int (*xFileExists)(const char*);
+extern struct sqlite3OsVtbl {
int (*xOpenReadWrite)(const char*, OsFile**, int*);
int (*xOpenExclusive)(const char*, OsFile**, int);
int (*xOpenReadOnly)(const char*, OsFile**);
- int (*xOpenDirectory)(const char*, OsFile*);
+
+ int (*xDelete)(const char*);
+ int (*xFileExists)(const char*);
+ char *(*xFullPathname)(const char*);
+ int (*xIsDirWritable)(char*);
int (*xSyncDirectory)(const char*);
int (*xTempFileName)(char*);
- int (*xIsDirWritable)(char*);
- int (*xClose)(OsFile**);
- int (*xRead)(OsFile*, void*, int amt);
- int (*xWrite)(OsFile*, const void*, int amt);
- int (*xSeek)(OsFile*, i64 offset);
- int (*xSync)(OsFile*, int);
- int (*xTruncate)(OsFile*, i64 size);
- int (*xFileSize)(OsFile*, i64 *pSize);
- char *(*xFullPathname)(const char*);
- int (*xLock)(OsFile*, int);
- int (*xUnlock)(OsFile*, int);
- int (*xCheckReservedLock)(OsFile *id);
- void (*xSetFullSync)(OsFile *id, int setting);
- int (*xFileHandle)(OsFile *id);
- int (*xLockState)(OsFile *id);
-} sqlite3Io;
-/* The interface for file I/O is above. Other miscellaneous functions
-** are below */
+ int (*xRandomSeed)(char*);
+ int (*xSleep)(int ms);
+ int (*xCurrentTime)(double*);
+ void (*xEnterMutex)(void);
+ void (*xLeaveMutex)(void);
+} sqlite3Os;
-int sqlite3OsRandomSeed(char*);
-int sqlite3OsSleep(int ms);
-int sqlite3OsCurrentTime(double*);
-void sqlite3OsEnterMutex(void);
-void sqlite3OsLeaveMutex(void);
+/*
+** Prototypes for routines found in os.c
+*/
+int sqlite3OsClose(OsFile**);
+int sqlite3OsOpenDirectory(OsFile*, const char*);
+int sqlite3OsRead(OsFile*, void*, int amt);
+int sqlite3OsWrite(OsFile*, const void*, int amt);
+int sqlite3OsSeek(OsFile*, i64 offset);
+int sqlite3OsTruncate(OsFile*, i64 size);
+int sqlite3OsSync(OsFile*, int);
+void sqlite3OsSetFullSync(OsFile *id, int setting);
+int sqlite3OsFileHandle(OsFile *id);
+int sqlite3OsFileSize(OsFile*, i64 *pSize);
+int sqlite3OsLock(OsFile*, int);
+int sqlite3OsUnlock(OsFile*, int);
+int sqlite3OsLockState(OsFile *id);
+int sqlite3OsCheckReservedLock(OsFile *id);
#endif /* _SQLITE_OS_H_ */
/*
-** The OsFile structure is a operating-system dependent representation
-** of an open file handle. It is defined differently for each architecture.
-**
-** This is the definition for Unix.
-**
-** OsFile.locktype takes one of the values SHARED_LOCK, RESERVED_LOCK,
-** PENDING_LOCK or EXCLUSIVE_LOCK.
+** The unixFile structure is subclass of OsFile specific for the unix
+** protability layer.
*/
-struct OsFile {
+typedef struct unixFile unixFile;
+struct unixFile {
+ IoMethod const *pMethod; /* Always the first entry */
struct openCnt *pOpen; /* Info about all open fd's on this inode */
struct lockInfo *pLock; /* Info about locks on this inode */
int h; /* The file descriptor */
return access(zFilename, 0)==0;
}
-/*
-** Allocate memory for an OsFile. Initialize the new OsFile
-** to the value given in pInit and return a pointer to the new
-** OsFile. If we run out of memory, close the file and return NULL.
-*/
-static OsFile *allocateOsFile(OsFile *pInit){
- OsFile *pNew;
- pNew = sqliteMalloc( sizeof(OsFile) );
- if( pNew==0 ){
- close(pInit->h);
- }else{
- *pNew = *pInit;
- }
- return pNew;
-}
+/* Forward declaration */
+static int allocateUnixFile(unixFile *pInit, OsFile **pId);
/*
** Attempt to open a file for both reading and writing. If that
int *pReadonly
){
int rc;
- OsFile f;
+ unixFile f;
assert( 0==*pId );
f.dirfd = -1;
}else{
*pReadonly = 0;
}
- sqlite3OsEnterMutex();
+ sqlite3Os.xEnterMutex();
rc = findLockInfo(f.h, &f.pLock, &f.pOpen);
- sqlite3OsLeaveMutex();
+ sqlite3Os.xLeaveMutex();
if( rc ){
close(f.h);
return SQLITE_NOMEM;
}
f.locktype = 0;
TRACE3("OPEN %-3d %s\n", f.h, zFilename);
- *pId = allocateOsFile(&f);
- if( *pId==0 ){
- return SQLITE_NOMEM;
- }else{
- OpenCounter(+1);
- return SQLITE_OK;
- }
+ return allocateUnixFile(&f, pId);
}
*/
static int unixOpenExclusive(const char *zFilename, OsFile **pId, int delFlag){
int rc;
- OsFile f;
+ unixFile f;
assert( 0==*pId );
if( access(zFilename, 0)==0 ){
if( f.h<0 ){
return SQLITE_CANTOPEN;
}
- sqlite3OsEnterMutex();
+ sqlite3Os.xEnterMutex();
rc = findLockInfo(f.h, &f.pLock, &f.pOpen);
- sqlite3OsLeaveMutex();
+ sqlite3Os.xLeaveMutex();
if( rc ){
close(f.h);
unlink(zFilename);
unlink(zFilename);
}
TRACE3("OPEN-EX %-3d %s\n", f.h, zFilename);
- *pId = allocateOsFile(&f);
- if( *pId==0 ){
- return SQLITE_NOMEM;
- }else{
- OpenCounter(+1);
- return SQLITE_OK;
- }
+ return allocateUnixFile(&f, pId);
}
/*
*/
static int unixOpenReadOnly(const char *zFilename, OsFile **pId){
int rc;
- OsFile f;
+ unixFile f;
assert( 0==*pId );
SET_THREADID(&f);
if( f.h<0 ){
return SQLITE_CANTOPEN;
}
- sqlite3OsEnterMutex();
+ sqlite3Os.xEnterMutex();
rc = findLockInfo(f.h, &f.pLock, &f.pOpen);
- sqlite3OsLeaveMutex();
+ sqlite3Os.xLeaveMutex();
if( rc ){
close(f.h);
return SQLITE_NOMEM;
}
f.locktype = 0;
TRACE3("OPEN-RO %-3d %s\n", f.h, zFilename);
- *pId = allocateOsFile(&f);
- if( *pId==0 ){
- return SQLITE_NOMEM;
- }else{
- OpenCounter(+1);
- return SQLITE_OK;
- }
+ return allocateUnixFile(&f, pId);
}
/*
** *id unchanged.
*/
static int unixOpenDirectory(
- const char *zDirname,
- OsFile *id
+ OsFile *id,
+ const char *zDirname
){
- if( id==0 ){
+ unixFile *pFile = (unixFile*)id;
+ if( pFile==0 ){
/* Do not open the directory if the corresponding file is not already
** open. */
return SQLITE_CANTOPEN;
}
- SET_THREADID(id);
- assert( id->dirfd<0 );
- id->dirfd = open(zDirname, O_RDONLY|O_BINARY, 0);
- if( id->dirfd<0 ){
+ SET_THREADID(pFile);
+ assert( pFile->dirfd<0 );
+ pFile->dirfd = open(zDirname, O_RDONLY|O_BINARY, 0);
+ if( pFile->dirfd<0 ){
return SQLITE_CANTOPEN;
}
- TRACE3("OPENDIR %-3d %s\n", id->dirfd, zDirname);
+ TRACE3("OPENDIR %-3d %s\n", pFile->dirfd, zDirname);
return SQLITE_OK;
}
assert( id );
SimulateIOError(SQLITE_IOERR);
TIMER_START;
- got = read(id->h, pBuf, amt);
+ got = read(((unixFile*)id)->h, pBuf, amt);
TIMER_END;
- TRACE5("READ %-3d %5d %7d %d\n", id->h, got, last_page, TIMER_ELAPSED);
+ TRACE5("READ %-3d %5d %7d %d\n", ((unixFile*)id)->h, got,
+ last_page, TIMER_ELAPSED);
SEEK(0);
/* if( got<0 ) got = 0; */
if( got==amt ){
SimulateIOError(SQLITE_IOERR);
SimulateDiskfullError;
TIMER_START;
- while( amt>0 && (wrote = write(id->h, pBuf, amt))>0 ){
+ while( amt>0 && (wrote = write(((unixFile*)id)->h, pBuf, amt))>0 ){
amt -= wrote;
pBuf = &((char*)pBuf)[wrote];
}
TIMER_END;
- TRACE5("WRITE %-3d %5d %7d %d\n", id->h, wrote, last_page, TIMER_ELAPSED);
+ TRACE5("WRITE %-3d %5d %7d %d\n", ((unixFile*)id)->h, wrote,
+ last_page, TIMER_ELAPSED);
SEEK(0);
if( amt>0 ){
return SQLITE_FULL;
#ifdef SQLITE_TEST
if( offset ) SimulateDiskfullError
#endif
- lseek(id->h, offset, SEEK_SET);
+ lseek(((unixFile*)id)->h, offset, SEEK_SET);
return SQLITE_OK;
}
** will not roll back - possibly leading to database corruption.
*/
static int unixSync(OsFile *id, int dataOnly){
- assert( id );
+ unixFile *pFile = (unixFile*)id;
+ assert( pFile );
SimulateIOError(SQLITE_IOERR);
- TRACE2("SYNC %-3d\n", id->h);
- if( full_fsync(id->h, id->fullSync, dataOnly) ){
+ TRACE2("SYNC %-3d\n", pFile->h);
+ if( full_fsync(pFile->h, pFile->fullSync, dataOnly) ){
return SQLITE_IOERR;
}
- if( id->dirfd>=0 ){
- TRACE2("DIRSYNC %-3d\n", id->dirfd);
+ if( pFile->dirfd>=0 ){
+ TRACE2("DIRSYNC %-3d\n", pFile->dirfd);
#ifndef SQLITE_DISABLE_DIRSYNC
- if( full_fsync(id->dirfd, id->fullSync, 0) ){
+ if( full_fsync(pFile->dirfd, pFile->fullSync, 0) ){
return SQLITE_IOERR;
}
#endif
- close(id->dirfd); /* Only need to sync once, so close the directory */
- id->dirfd = -1; /* when we are done. */
+ close(pFile->dirfd); /* Only need to sync once, so close the directory */
+ pFile->dirfd = -1; /* when we are done. */
}
return SQLITE_OK;
}
static int unixTruncate(OsFile *id, i64 nByte){
assert( id );
SimulateIOError(SQLITE_IOERR);
- return ftruncate(id->h, nByte)==0 ? SQLITE_OK : SQLITE_IOERR;
+ return ftruncate(((unixFile*)id)->h, nByte)==0 ? SQLITE_OK : SQLITE_IOERR;
}
/*
struct stat buf;
assert( id );
SimulateIOError(SQLITE_IOERR);
- if( fstat(id->h, &buf)!=0 ){
+ if( fstat(((unixFile*)id)->h, &buf)!=0 ){
return SQLITE_IOERR;
}
*pSize = buf.st_size;
*/
static int unixCheckReservedLock(OsFile *id){
int r = 0;
+ unixFile *pFile = (unixFile*)id;
- assert( id );
- if( CHECK_THREADID(id) ) return SQLITE_MISUSE;
- sqlite3OsEnterMutex(); /* Needed because id->pLock is shared across threads */
+ assert( pFile );
+ if( CHECK_THREADID(pFile) ) return SQLITE_MISUSE;
+ sqlite3Os.xEnterMutex(); /* Because pFile->pLock is shared across threads */
/* Check if a thread in this process holds such a lock */
- if( id->pLock->locktype>SHARED_LOCK ){
+ if( pFile->pLock->locktype>SHARED_LOCK ){
r = 1;
}
lock.l_start = RESERVED_BYTE;
lock.l_len = 1;
lock.l_type = F_WRLCK;
- fcntl(id->h, F_GETLK, &lock);
+ fcntl(pFile->h, F_GETLK, &lock);
if( lock.l_type!=F_UNLCK ){
r = 1;
}
}
- sqlite3OsLeaveMutex();
- TRACE3("TEST WR-LOCK %d %d\n", id->h, r);
+ sqlite3Os.xLeaveMutex();
+ TRACE3("TEST WR-LOCK %d %d\n", pFile->h, r);
return r;
}
** binaries. This returns the string represetation of the supplied
** integer lock-type.
*/
-static const char * locktypeName(int locktype){
+static const char *locktypeName(int locktype){
switch( locktype ){
case NO_LOCK: return "NONE";
case SHARED_LOCK: return "SHARED";
** even if the locking primitive used is always a write-lock.
*/
int rc = SQLITE_OK;
- struct lockInfo *pLock = id->pLock;
+ unixFile *pFile = (unixFile*)id;
+ struct lockInfo *pLock = pFile->pLock;
struct flock lock;
int s;
- assert( id );
- TRACE7("LOCK %d %s was %s(%s,%d) pid=%d\n", id->h, locktypeName(locktype),
- locktypeName(id->locktype), locktypeName(pLock->locktype), pLock->cnt
- ,getpid() );
- if( CHECK_THREADID(id) ) return SQLITE_MISUSE;
+ assert( pFile );
+ TRACE7("LOCK %d %s was %s(%s,%d) pid=%d\n", pFile->h,
+ locktypeName(locktype), locktypeName(pFile->locktype),
+ locktypeName(pLock->locktype), pLock->cnt , getpid());
+ if( CHECK_THREADID(pFile) ) return SQLITE_MISUSE;
/* If there is already a lock of this type or more restrictive on the
** OsFile, do nothing. Don't use the end_lock: exit path, as
- ** sqlite3OsEnterMutex() hasn't been called yet.
+ ** sqlite3Os.xEnterMutex() hasn't been called yet.
*/
- if( id->locktype>=locktype ){
- TRACE3("LOCK %d %s ok (already held)\n", id->h, locktypeName(locktype));
+ if( pFile->locktype>=locktype ){
+ TRACE3("LOCK %d %s ok (already held)\n", pFile->h,
+ locktypeName(locktype));
return SQLITE_OK;
}
/* Make sure the locking sequence is correct
*/
- assert( id->locktype!=NO_LOCK || locktype==SHARED_LOCK );
+ assert( pFile->locktype!=NO_LOCK || locktype==SHARED_LOCK );
assert( locktype!=PENDING_LOCK );
- assert( locktype!=RESERVED_LOCK || id->locktype==SHARED_LOCK );
+ assert( locktype!=RESERVED_LOCK || pFile->locktype==SHARED_LOCK );
- /* This mutex is needed because id->pLock is shared across threads
+ /* This mutex is needed because pFile->pLock is shared across threads
*/
- sqlite3OsEnterMutex();
+ sqlite3Os.xEnterMutex();
/* If some thread using this PID has a lock via a different OsFile*
** handle that precludes the requested lock, return BUSY.
*/
- if( (id->locktype!=pLock->locktype &&
+ if( (pFile->locktype!=pLock->locktype &&
(pLock->locktype>=PENDING_LOCK || locktype>SHARED_LOCK))
){
rc = SQLITE_BUSY;
if( locktype==SHARED_LOCK &&
(pLock->locktype==SHARED_LOCK || pLock->locktype==RESERVED_LOCK) ){
assert( locktype==SHARED_LOCK );
- assert( id->locktype==0 );
+ assert( pFile->locktype==0 );
assert( pLock->cnt>0 );
- id->locktype = SHARED_LOCK;
+ pFile->locktype = SHARED_LOCK;
pLock->cnt++;
- id->pOpen->nLock++;
+ pFile->pOpen->nLock++;
goto end_lock;
}
** be released.
*/
if( locktype==SHARED_LOCK
- || (locktype==EXCLUSIVE_LOCK &&
id->locktype<PENDING_LOCK)
+ || (locktype==EXCLUSIVE_LOCK &&
pFile->locktype<PENDING_LOCK)
){
lock.l_type = (locktype==SHARED_LOCK?F_RDLCK:F_WRLCK);
lock.l_start = PENDING_BYTE;
- s = fcntl(id->h, F_SETLK, &lock);
+ s = fcntl(pFile->h, F_SETLK, &lock);
if( s ){
rc = (errno==EINVAL) ? SQLITE_NOLFS : SQLITE_BUSY;
goto end_lock;
/* Now get the read-lock */
lock.l_start = SHARED_FIRST;
lock.l_len = SHARED_SIZE;
- s = fcntl(id->h, F_SETLK, &lock);
+ s = fcntl(pFile->h, F_SETLK, &lock);
/* Drop the temporary PENDING lock */
lock.l_start = PENDING_BYTE;
lock.l_len = 1L;
lock.l_type = F_UNLCK;
- if( fcntl(id->h, F_SETLK, &lock)!=0 ){
+ if( fcntl(pFile->h, F_SETLK, &lock)!=0 ){
rc = SQLITE_IOERR; /* This should never happen */
goto end_lock;
}
if( s ){
rc = (errno==EINVAL) ? SQLITE_NOLFS : SQLITE_BUSY;
}else{
- id->locktype = SHARED_LOCK;
- id->pOpen->nLock++;
+ pFile->locktype = SHARED_LOCK;
+ pFile->pOpen->nLock++;
pLock->cnt = 1;
}
}else if( locktype==EXCLUSIVE_LOCK && pLock->cnt>1 ){
** assumed that there is a SHARED or greater lock on the file
** already.
*/
- assert( 0!=id->locktype );
+ assert( 0!=pFile->locktype );
lock.l_type = F_WRLCK;
switch( locktype ){
case RESERVED_LOCK:
default:
assert(0);
}
- s = fcntl(id->h, F_SETLK, &lock);
+ s = fcntl(pFile->h, F_SETLK, &lock);
if( s ){
rc = (errno==EINVAL) ? SQLITE_NOLFS : SQLITE_BUSY;
}
}
if( rc==SQLITE_OK ){
- id->locktype = locktype;
+ pFile->locktype = locktype;
pLock->locktype = locktype;
}else if( locktype==EXCLUSIVE_LOCK ){
- id->locktype = PENDING_LOCK;
+ pFile->locktype = PENDING_LOCK;
pLock->locktype = PENDING_LOCK;
}
end_lock:
- sqlite3OsLeaveMutex();
- TRACE4("LOCK %d %s %s\n", id->h, locktypeName(locktype),
+ sqlite3Os.xLeaveMutex();
+ TRACE4("LOCK %d %s %s\n", pFile->h, locktypeName(locktype),
rc==SQLITE_OK ? "ok" : "failed");
return rc;
}
/*
-** Lower the locking level on file descriptor id to locktype. locktype
+** Lower the locking level on file descriptor pFile to locktype. locktype
** must be either NO_LOCK or SHARED_LOCK.
**
** If the locking level of the file descriptor is already at or below
struct lockInfo *pLock;
struct flock lock;
int rc = SQLITE_OK;
+ unixFile *pFile = (unixFile*)id;
- assert( id );
- TRACE7("UNLOCK %d %d was %d(%d,%d) pid=%d\n", id->h, locktype, id->locktype,
- id->pLock->locktype, id->pLock->cnt, getpid());
- if( CHECK_THREADID(id) ) return SQLITE_MISUSE;
+ assert( pFile );
+ TRACE7("UNLOCK %d %d was %d(%d,%d) pid=%d\n", pFile->h, locktype,
+ pFile->locktype, pFile->pLock->locktype, pFile->pLock->cnt, getpid());
+ if( CHECK_THREADID(pFile) ) return SQLITE_MISUSE;
assert( locktype<=SHARED_LOCK );
- if( id->locktype<=locktype ){
+ if( pFile->locktype<=locktype ){
return SQLITE_OK;
}
- sqlite3OsEnterMutex();
- pLock = id->pLock;
+ sqlite3Os.xEnterMutex();
+ pLock = pFile->pLock;
assert( pLock->cnt!=0 );
- if( id->locktype>SHARED_LOCK ){
- assert( pLock->locktype==id->locktype );
+ if( pFile->locktype>SHARED_LOCK ){
+ assert( pLock->locktype==pFile->locktype );
if( locktype==SHARED_LOCK ){
lock.l_type = F_RDLCK;
lock.l_whence = SEEK_SET;
lock.l_start = SHARED_FIRST;
lock.l_len = SHARED_SIZE;
- if( fcntl(id->h, F_SETLK, &lock)!=0 ){
+ if( fcntl(pFile->h, F_SETLK, &lock)!=0 ){
/* This should never happen */
rc = SQLITE_IOERR;
}
lock.l_whence = SEEK_SET;
lock.l_start = PENDING_BYTE;
lock.l_len = 2L; assert( PENDING_BYTE+1==RESERVED_BYTE );
- if( fcntl(id->h, F_SETLK, &lock)==0 ){
+ if( fcntl(pFile->h, F_SETLK, &lock)==0 ){
pLock->locktype = SHARED_LOCK;
}else{
rc = SQLITE_IOERR; /* This should never happen */
lock.l_type = F_UNLCK;
lock.l_whence = SEEK_SET;
lock.l_start = lock.l_len = 0L;
- if( fcntl(id->h, F_SETLK, &lock)==0 ){
+ if( fcntl(pFile->h, F_SETLK, &lock)==0 ){
pLock->locktype = NO_LOCK;
}else{
rc = SQLITE_IOERR; /* This should never happen */
** count reaches zero, close any other file descriptors whose close
** was deferred because of outstanding locks.
*/
- pOpen = id->pOpen;
+ pOpen = pFile->pOpen;
pOpen->nLock--;
assert( pOpen->nLock>=0 );
if( pOpen->nLock==0 && pOpen->nPending>0 ){
pOpen->aPending = 0;
}
}
- sqlite3OsLeaveMutex();
- id->locktype = locktype;
+ sqlite3Os.xLeaveMutex();
+ pFile->locktype = locktype;
return rc;
}
** Close a file.
*/
static int unixClose(OsFile **pId){
- OsFile *id = *pId;
+ unixFile *id = (unixFile*)*pId;
if( !id ) return SQLITE_OK;
if( CHECK_THREADID(id) ) return SQLITE_MISUSE;
- unixUnlock(id, NO_LOCK);
+ unixUnlock(*pId, NO_LOCK);
if( id->dirfd>=0 ) close(id->dirfd);
id->dirfd = -1;
- sqlite3OsEnterMutex();
+ sqlite3Os.xEnterMutex();
if( id->pOpen->nLock ){
/* If there are outstanding locks, do not actually close the file just
** yet because that would clear those locks. Instead, add the file
}
releaseLockInfo(id->pLock);
releaseOpenCnt(id->pOpen);
- sqlite3OsLeaveMutex();
+ sqlite3Os.xLeaveMutex();
id->isOpen = 0;
TRACE2("CLOSE %-3d\n", id->h);
OpenCounter(-1);
** Change the value of the fullsync flag in the given file descriptor.
*/
static void unixSetFullSync(OsFile *id, int v){
- id->fullSync = v;
+ ((unixFile*)id)->fullSync = v;
}
/*
** Return the underlying file handle for an OsFile
*/
static int unixFileHandle(OsFile *id){
- return id->h;
+ return ((unixFile*)id)->h;
}
/*
** by this handle. (Used for testing and analysis only.)
*/
static int unixLockState(OsFile *id){
- return id->locktype;
+ return ((unixFile*)id)->locktype;
}
/*
-** This is the structure that defines all of the I/O routines.
+** This vector defines all the methods that can operate on an OsFile
+** for unix.
*/
-struct sqlite3IoVtbl sqlite3Io = {
- unixDelete,
- unixFileExists,
- unixOpenReadWrite,
- unixOpenExclusive,
- unixOpenReadOnly,
- unixOpenDirectory,
- unixSyncDirectory,
- unixTempFileName,
- unixIsDirWritable,
+static const IoMethod sqlite3UnixIoMethod = {
unixClose,
+ unixOpenDirectory,
unixRead,
unixWrite,
unixSeek,
- unixSync,
unixTruncate,
+ unixSync,
+ unixSetFullSync,
+ unixFileHandle,
unixFileSize,
- unixFullPathname,
unixLock,
unixUnlock,
- unixCheckReservedLock,
- unixSetFullSync,
- unixFileHandle,
unixLockState,
+ unixCheckReservedLock,
};
+/*
+** Allocate memory for a unixFile. Initialize the new unixFile
+** to the value given in pInit and return a pointer to the new
+** OsFile. If we run out of memory, close the file and return NULL.
+*/
+static int allocateUnixFile(unixFile *pInit, OsFile **pId){
+ unixFile *pNew;
+ pNew = sqliteMalloc( sizeof(unixFile) );
+ if( pNew==0 ){
+ close(pInit->h);
+ *pId = 0;
+ return SQLITE_NOMEM;
+ }else{
+ *pNew = *pInit;
+ pNew->pMethod = &sqlite3UnixIoMethod;
+ *pId = (OsFile*)pNew;
+ OpenCounter(+1);
+ return SQLITE_OK;
+ }
+}
+
#endif /* SQLITE_OMIT_DISKIO */
/***************************************************************************
** is written into the buffer zBuf[256]. The calling function must
** supply a sufficiently large buffer.
*/
-int sqlite3OsRandomSeed(char *zBuf){
+static int unixRandomSeed(char *zBuf){
/* We have to initialize zBuf to prevent valgrind from reporting
** errors. The reports issued by valgrind are incorrect - we would
** prefer that the randomness be increased by making use of the
/*
** Sleep for a little while. Return the amount of time slept.
*/
-int sqlite3OsSleep(int ms){
+static int unixSleep(int ms){
#if defined(HAVE_USLEEP) && HAVE_USLEEP
usleep(ms*1000);
return ms;
** SQLite uses only a single Mutex. There is not much critical
** code and what little there is executes quickly and without blocking.
*/
-void sqlite3OsEnterMutex(){
+static void unixEnterMutex(){
#ifdef SQLITE_UNIX_THREADS
pthread_mutex_lock(&mutex);
#endif
assert( !inMutex );
inMutex = 1;
}
-void sqlite3OsLeaveMutex(){
+static void unixLeaveMutex(){
assert( inMutex );
inMutex = 0;
#ifdef SQLITE_UNIX_THREADS
/*
** The following variable, if set to a non-zero value, becomes the result
-** returned from sqlite3OsCurrentTime(). This is used for testing.
+** returned from sqlite3Os.xCurrentTime(). This is used for testing.
*/
#ifdef SQLITE_TEST
int sqlite3_current_time = 0;
** current time and date as a Julian Day number into *prNow and
** return 0. Return 1 if the time and date cannot be found.
*/
-int sqlite3OsCurrentTime(double *prNow){
+static int unixCurrentTime(double *prNow){
#ifdef NO_GETTOD
time_t t;
time(&t);
return 0;
}
+/* Macro used to comment out routines that do not exists when there is
+** no disk I/O */
+#ifdef SQLITE_OMIT_DISKIO
+# define IF_DISKIO(X) 0
+#else
+# define IF_DISKIO(X) X
+#endif
+
+/*
+** This is the structure that defines all of the I/O routines.
+*/
+struct sqlite3OsVtbl sqlite3Os = {
+ IF_DISKIO( unixOpenReadWrite ),
+ IF_DISKIO( unixOpenExclusive ),
+ IF_DISKIO( unixOpenReadOnly ),
+ IF_DISKIO( unixDelete ),
+ IF_DISKIO( unixFileExists ),
+ IF_DISKIO( unixFullPathname ),
+ IF_DISKIO( unixIsDirWritable ),
+ IF_DISKIO( unixSyncDirectory ),
+ IF_DISKIO( unixTempFileName ),
+ unixRandomSeed,
+ unixSleep,
+ unixCurrentTime,
+ unixEnterMutex,
+ unixLeaveMutex,
+};
+
+
+
#endif /* OS_UNIX */
#include "os_common.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.
+** The winFile structure is a subclass of OsFile specific to the win32
+** portability layer.
*/
-struct OsFile {
+typedef struct winFile winFile;
+struct winFile {
+ IoMethod const *pMethod;/* Must be first */
HANDLE h; /* Handle for accessing the file */
unsigned char locktype; /* Type of lock currently held on this file */
short sharedLockByte; /* Randomly chosen byte used as a shared lock */
};
-
/*
** Do not include any of the File I/O interface procedures if the
** SQLITE_OMIT_DISKIO macro is defined (indicating that there database
return exists;
}
-
-/*
-** Allocate memory for an OsFile. Initialize the new OsFile
-** to the value given in pInit and return a pointer to the new
-** OsFile. If we run out of memory, close the file and return NULL.
-*/
-static OsFile *allocateOsFile(OsFile *pInit){
- OsFile *pNew;
- pNew = sqliteMalloc( sizeof(OsFile) );
- if( pNew==0 ){
- CloseHandle(pInit->h);
- }else{
- *pNew = *pInit;
- }
- return pNew;
-}
+/* Forward declaration */
+int allocateWinFile(winFile *pInit, OsFile **pId);
/*
** Attempt to open a file for both reading and writing. If that
OsFile **pId,
int *pReadonly
){
- OsFile f;
+ winFile f;
HANDLE h;
WCHAR *zWide = utf8ToUnicode(zFilename);
assert( *pId==0 );
f.locktype = NO_LOCK;
f.sharedLockByte = 0;
TRACE3("OPEN R/W %d \"%s\"\n", h, zFilename);
- *pId = allocateOsFile(&f);
- if( *pId==0 ){
- return SQLITE_NOMEM;
- }else{
- OpenCounter(+1);
- return SQLITE_OK;
- }
+ return allocateWinFile(&f, pId);
}
** On failure, return SQLITE_CANTOPEN.
*/
static int winOpenExclusive(const char *zFilename, OsFile **pId, int delFlag){
- OsFile f;
+ winFile f;
HANDLE h;
int fileflags;
WCHAR *zWide = utf8ToUnicode(zFilename);
f.locktype = NO_LOCK;
f.sharedLockByte = 0;
TRACE3("OPEN EX %d \"%s\"\n", h, zFilename);
- *pId = allocateOsFile(&f);
- if( *pId==0 ){
- return SQLITE_NOMEM;
- }else{
- OpenCounter(+1);
- return SQLITE_OK;
- }
+ return allocateWinFile(&f, pId);
}
/*
** On failure, return SQLITE_CANTOPEN.
*/
static int winOpenReadOnly(const char *zFilename, OsFile **pId){
- OsFile f;
+ winFile f;
HANDLE h;
WCHAR *zWide = utf8ToUnicode(zFilename);
assert( *pId==0 );
f.locktype = NO_LOCK;
f.sharedLockByte = 0;
TRACE3("OPEN RO %d \"%s\"\n", h, zFilename);
- *pId = allocateOsFile(&f);
- if( *pId==0 ){
- return SQLITE_NOMEM;
- }else{
- OpenCounter(+1);
- return SQLITE_OK;
- }
+ return allocateWinFile(&f, pId);
}
/*
** *id unchanged.
*/
static int winOpenDirectory(
- const char *zDirname,
- OsFile *id
+ OsFile *id,
+ const char *zDirname
){
return SQLITE_OK;
}
zBuf[j] = (char)zChars[ ((unsigned char)zBuf[j])%(sizeof(zChars)-1) ];
}
zBuf[j] = 0;
- if( !sqlite3Io.xFileExists(zBuf) ) break;
+ if( !sqlite3Os.xFileExists(zBuf) ) break;
}
TRACE2("TEMP FILENAME: %s\n", zBuf);
return SQLITE_OK;
** Close a file.
*/
static int winClose(OsFile **pId){
- if( *pId ){
- TRACE2("CLOSE %d\n", (*pId)->h);
- CloseHandle((*pId)->h);
+ winFile *pFile;
+ if( pId && (pFile = (winFile*)*pId)!=0 ){
+ TRACE2("CLOSE %d\n", pFile->h);
+ CloseHandle(pFile->h);
OpenCounter(-1);
- sqliteFree(*pId);
+ sqliteFree(pFile);
*pId = 0;
}
return SQLITE_OK;
DWORD got;
assert( id!=0 );
SimulateIOError(SQLITE_IOERR);
- TRACE3("READ %d lock=%d\n", id->h, id->locktype);
- if( !ReadFile(id->h, pBuf, amt, &got, 0) ){
+ TRACE3("READ %d lock=%d\n", ((winFile*)id)->h, ((winFile*)id)->locktype);
+ if( !ReadFile(((winFile*)id)->h, pBuf, amt, &got, 0) ){
got = 0;
}
if( got==(DWORD)amt ){
assert( id!=0 );
SimulateIOError(SQLITE_IOERR);
SimulateDiskfullError;
- TRACE3("WRITE %d lock=%d\n", id->h, id->locktype);
+ TRACE3("WRITE %d lock=%d\n", ((winFile*)id)->h, ((winFile*)id)->locktype);
assert( amt>0 );
- while( amt>0 && (rc = WriteFile(id->h, pBuf, amt, &wrote, 0))!=0 && wrote>0 ){
+ while( amt>0 && (rc = WriteFile(((winFile*)id)->h, pBuf, amt, &wrote, 0))!=0
+ && wrote>0 ){
amt -= wrote;
pBuf = &((char*)pBuf)[wrote];
}
if( offset ) SimulateDiskfullError
#endif
SEEK(offset/1024 + 1);
- rc = SetFilePointer(id->h, lowerBits, &upperBits, FILE_BEGIN);
- TRACE3("SEEK %d %lld\n", id->h, offset);
+ rc = SetFilePointer(((winFile*)id)->h, lowerBits, &upperBits, FILE_BEGIN);
+ TRACE3("SEEK %d %lld\n", ((winFile*)id)->h, offset);
if( rc==INVALID_SET_FILE_POINTER && GetLastError()!=NO_ERROR ){
return SQLITE_FULL;
}
*/
static int winSync(OsFile *id, int dataOnly){
assert( id!=0 );
- TRACE3("SYNC %d lock=%d\n", id->h, id->locktype);
- if( FlushFileBuffers(id->h) ){
+ TRACE3("SYNC %d lock=%d\n", ((winFile*)id)->h, ((winFile*)id)->locktype);
+ if( FlushFileBuffers(((winFile*)id)->h) ){
return SQLITE_OK;
}else{
return SQLITE_IOERR;
static int winTruncate(OsFile *id, i64 nByte){
LONG upperBits = nByte>>32;
assert( id!=0 );
- TRACE3("TRUNCATE %d %lld\n", id->h, nByte);
+ TRACE3("TRUNCATE %d %lld\n", ((winFile*)id)->h, nByte);
SimulateIOError(SQLITE_IOERR);
- SetFilePointer(id->h, nByte, &upperBits, FILE_BEGIN);
- SetEndOfFile(id->h);
+ SetFilePointer(((winFile*)id)->h, nByte, &upperBits, FILE_BEGIN);
+ SetEndOfFile(((winFile*)id)->h);
return SQLITE_OK;
}
DWORD upperBits, lowerBits;
assert( id!=0 );
SimulateIOError(SQLITE_IOERR);
- lowerBits = GetFileSize(id->h, &upperBits);
+ lowerBits = GetFileSize(((winFile*)id)->h, &upperBits);
*pSize = (((i64)upperBits)<<32) + lowerBits;
return SQLITE_OK;
}
** Different API routines are called depending on whether or not this
** is Win95 or WinNT.
*/
-static int getReadLock(OsFile *id){
+static int getReadLock(winFile *id){
int res;
if( isNT() ){
OVERLAPPED ovlp;
/*
** Undo a readlock
*/
-static int unlockReadLock(OsFile *id){
+static int unlockReadLock(winFile *pFile){
int res;
if( isNT() ){
- res = UnlockFile(id->h, SHARED_FIRST, 0, SHARED_SIZE, 0);
+ res = UnlockFile(pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0);
}else{
- res = UnlockFile(id->h, SHARED_FIRST + id->sharedLockByte, 0, 1, 0);
+ res = UnlockFile(pFile->h, SHARED_FIRST + pFile->sharedLockByte, 0, 1, 0);
}
return res;
}
int res = 1; /* Result of a windows lock call */
int newLocktype; /* Set id->locktype to this value before exiting */
int gotPendingLock = 0;/* True if we acquired a PENDING lock this time */
+ winFile *pFile = (winFile*)id;
- assert( id!=0 );
+ assert( pFile!=0 );
TRACE5("LOCK %d %d was %d(%d)\n",
- id->h, locktype, id->locktype, id->sharedLockByte);
+ pFile->h, locktype, pFile->locktype, pFile->sharedLockByte);
/* If there is already a lock of this type or more restrictive on the
** OsFile, do nothing. Don't use the end_lock: exit path, as
** sqlite3OsEnterMutex() hasn't been called yet.
*/
- if( id->locktype>=locktype ){
+ if( pFile->locktype>=locktype ){
return SQLITE_OK;
}
/* Make sure the locking sequence is correct
*/
- assert( id->locktype!=NO_LOCK || locktype==SHARED_LOCK );
+ assert( pFile->locktype!=NO_LOCK || locktype==SHARED_LOCK );
assert( locktype!=PENDING_LOCK );
- assert( locktype!=RESERVED_LOCK || id->locktype==SHARED_LOCK );
+ assert( locktype!=RESERVED_LOCK || pFile->locktype==SHARED_LOCK );
/* Lock the PENDING_LOCK byte if we need to acquire a PENDING lock or
** a SHARED lock. If we are acquiring a SHARED lock, the acquisition of
** the PENDING_LOCK byte is temporary.
*/
- newLocktype = id->locktype;
- if( id->locktype==NO_LOCK
- || (locktype==EXCLUSIVE_LOCK && id->locktype==RESERVED_LOCK)
+ newLocktype = pFile->locktype;
+ if( pFile->locktype==NO_LOCK
+ || (locktype==EXCLUSIVE_LOCK && pFile->locktype==RESERVED_LOCK)
){
int cnt = 3;
- while( cnt-->0 && (res = LockFile(id->h, PENDING_BYTE, 0, 1, 0))==0 ){
+ while( cnt-->0 && (res = LockFile(pFile->h, PENDING_BYTE, 0, 1, 0))==0 ){
/* Try 3 times to get the pending lock. The pending lock might be
** held by another reader process who will release it momentarily.
*/
/* Acquire a shared lock
*/
if( locktype==SHARED_LOCK && res ){
- assert( id->locktype==NO_LOCK );
- res = getReadLock(id);
+ assert( pFile->locktype==NO_LOCK );
+ res = getReadLock(pFile);
if( res ){
newLocktype = SHARED_LOCK;
}
/* Acquire a RESERVED lock
*/
if( locktype==RESERVED_LOCK && res ){
- assert( id->locktype==SHARED_LOCK );
- res = LockFile(id->h, RESERVED_BYTE, 0, 1, 0);
+ assert( pFile->locktype==SHARED_LOCK );
+ res = LockFile(pFile->h, RESERVED_BYTE, 0, 1, 0);
if( res ){
newLocktype = RESERVED_LOCK;
}
/* Acquire an EXCLUSIVE lock
*/
if( locktype==EXCLUSIVE_LOCK && res ){
- assert( id->locktype>=SHARED_LOCK );
- res = unlockReadLock(id);
+ assert( pFile->locktype>=SHARED_LOCK );
+ res = unlockReadLock(pFile);
TRACE2("unreadlock = %d\n", res);
- res = LockFile(id->h, SHARED_FIRST, 0, SHARED_SIZE, 0);
+ res = LockFile(pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0);
if( res ){
newLocktype = EXCLUSIVE_LOCK;
}else{
** release it now.
*/
if( gotPendingLock && locktype==SHARED_LOCK ){
- UnlockFile(id->h, PENDING_BYTE, 0, 1, 0);
+ UnlockFile(pFile->h, PENDING_BYTE, 0, 1, 0);
}
/* Update the state of the lock has held in the file descriptor then
if( res ){
rc = SQLITE_OK;
}else{
- TRACE4("LOCK FAILED %d trying for %d but got %d\n", id->h,
+ TRACE4("LOCK FAILED %d trying for %d but got %d\n", pFile->h,
locktype, newLocktype);
rc = SQLITE_BUSY;
}
- id->locktype = newLocktype;
+ pFile->locktype = newLocktype;
return rc;
}
*/
static int winCheckReservedLock(OsFile *id){
int rc;
- assert( id!=0 );
- if( id->locktype>=RESERVED_LOCK ){
+ winFile *pFile = (winFile*)id;
+ assert( pFile!=0 );
+ if( pFile->locktype>=RESERVED_LOCK ){
rc = 1;
- TRACE3("TEST WR-LOCK %d %d (local)\n", id->h, rc);
+ TRACE3("TEST WR-LOCK %d %d (local)\n", pFile->h, rc);
}else{
- rc = LockFile(id->h, RESERVED_BYTE, 0, 1, 0);
+ rc = LockFile(pFile->h, RESERVED_BYTE, 0, 1, 0);
if( rc ){
- UnlockFile(id->h, RESERVED_BYTE, 0, 1, 0);
+ UnlockFile(pFile->h, RESERVED_BYTE, 0, 1, 0);
}
rc = !rc;
- TRACE3("TEST WR-LOCK %d %d (remote)\n", id->h, rc);
+ TRACE3("TEST WR-LOCK %d %d (remote)\n", pFile->h, rc);
}
return rc;
}
static int winUnlock(OsFile *id, int locktype){
int type;
int rc = SQLITE_OK;
- assert( id!=0 );
+ winFile *pFile = (winFile*)id;
+ assert( pFile!=0 );
assert( locktype<=SHARED_LOCK );
- TRACE5("UNLOCK %d to %d was %d(%d)\n", id->h, locktype,
- id->locktype, id->sharedLockByte);
- type = id->locktype;
+ TRACE5("UNLOCK %d to %d was %d(%d)\n", pFile->h, locktype,
+ pFile->locktype, pFile->sharedLockByte);
+ type = pFile->locktype;
if( type>=EXCLUSIVE_LOCK ){
- UnlockFile(id->h, SHARED_FIRST, 0, SHARED_SIZE, 0);
- if( locktype==SHARED_LOCK && !getReadLock(id) ){
+ UnlockFile(pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0);
+ if( locktype==SHARED_LOCK && !getReadLock(pFile) ){
/* This should never happen. We should always be able to
** reacquire the read lock */
rc = SQLITE_IOERR;
}
}
if( type>=RESERVED_LOCK ){
- UnlockFile(id->h, RESERVED_BYTE, 0, 1, 0);
+ UnlockFile(pFile->h, RESERVED_BYTE, 0, 1, 0);
}
if( locktype==NO_LOCK && type>=SHARED_LOCK ){
- unlockReadLock(id);
+ unlockReadLock(pFile);
}
if( type>=PENDING_LOCK ){
- UnlockFile(id->h, PENDING_BYTE, 0, 1, 0);
+ UnlockFile(pFile->h, PENDING_BYTE, 0, 1, 0);
}
- id->locktype = locktype;
+ pFile->locktype = locktype;
return rc;
}
** Return the underlying file handle for an OsFile
*/
static int winFileHandle(OsFile *id){
- return (int)id->h;
+ return (int)((winFile*)id)->h;
}
/*
** by this handle. (Used for testing and analysis only.)
*/
static int winLockState(OsFile *id){
- return id->locktype;
+ return ((winFile*)id)->locktype;
}
-
/*
-** This is the structure that defines all of the I/O routines.
+** This vector defines all the methods that can operate on an OsFile
+** for win32.
*/
-struct sqlite3IoVtbl sqlite3Io = {
- winDelete,
- winFileExists,
- winOpenReadWrite,
- winOpenExclusive,
- winOpenReadOnly,
- winOpenDirectory,
- winSyncDirectory,
- winTempFileName,
- winIsDirWritable,
+static const IoMethod sqlite3WinIoMethod = {
winClose,
+ winOpenDirectory,
winRead,
winWrite,
winSeek,
- winSync,
winTruncate,
+ winSync,
+ winSetFullSync,
+ winFileHandle,
winFileSize,
- winFullPathname,
winLock,
winUnlock,
- winCheckReservedLock,
- winSetFullSync,
- winFileHandle,
winLockState,
+ winCheckReservedLock,
};
+/*
+** Allocate memory for an OsFile. Initialize the new OsFile
+** to the value given in pInit and return a pointer to the new
+** OsFile. If we run out of memory, close the file and return NULL.
+*/
+int allocateWinFile(winFile *pInit, OsFile **pId){
+ winFile *pNew;
+ pNew = sqliteMalloc( sizeof(*pNew) );
+ if( pNew==0 ){
+ CloseHandle(pInit->h);
+ *pId = 0;
+ return SQLITE_NOMEM;
+ }else{
+ *pNew = *pInit;
+ pNew->pMethod = &sqlite3WinIoMethod;
+ *pId = pNew;
+ return SQLITE_OK;
+ }
+}
+
+
#endif /* SQLITE_OMIT_DISKIO */
/***************************************************************************
** Everything above deals with file I/O. Everything that follows deals
** is written into the buffer zBuf[256]. The calling function must
** supply a sufficiently large buffer.
*/
-int sqlite3OsRandomSeed(char *zBuf){
+static int winRandomSeed(char *zBuf){
/* We have to initialize zBuf to prevent valgrind from reporting
** errors. The reports issued by valgrind are incorrect - we would
** prefer that the randomness be increased by making use of the
/*
** Sleep for a little while. Return the amount of time slept.
*/
-int sqlite3OsSleep(int ms){
+static int winSleep(int ms){
Sleep(ms);
return ms;
}
** SQLite uses only a single Mutex. There is not much critical
** code and what little there is executes quickly and without blocking.
*/
-void sqlite3OsEnterMutex(){
+static void winEnterMutex(){
#ifdef SQLITE_W32_THREADS
static int isInit = 0;
while( !isInit ){
assert( !inMutex );
inMutex = 1;
}
-void sqlite3OsLeaveMutex(){
+static void winLeaveMutex(){
assert( inMutex );
inMutex = 0;
#ifdef SQLITE_W32_THREADS
** current time and date as a Julian Day number into *prNow and
** return 0. Return 1 if the time and date cannot be found.
*/
-int sqlite3OsCurrentTime(double *prNow){
+static int winCurrentTime(double *prNow){
FILETIME ft;
/* FILETIME structure is a 64-bit value representing the number of
100-nanosecond intervals since January 1, 1601 (= JD 2305813.5).
return 0;
}
+/* Macro used to comment out routines that do not exists when there is
+** no disk I/O
+*/
+#ifdef SQLITE_OMIT_DISKIO
+# define IF_DISKIO(X) 0
+#else
+# define IF_DISKIO(X) X
+#endif
+
+/*
+** This is the structure that defines all of the I/O routines.
+*/
+struct sqlite3OsVtbl sqlite3Os = {
+ IF_DISKIO( winOpenReadWrite ),
+ IF_DISKIO( winOpenExclusive ),
+ IF_DISKIO( winOpenReadOnly ),
+ IF_DISKIO( winDelete ),
+ IF_DISKIO( winFileExists ),
+ IF_DISKIO( winFullPathname ),
+ IF_DISKIO( winIsDirWritable ),
+ IF_DISKIO( winSyncDirectory ),
+ IF_DISKIO( winTempFileName ),
+ winRandomSeed,
+ winSleep,
+ winCurrentTime,
+ winEnterMutex,
+ winLeaveMutex,
+};
+
#endif /* OS_WIN */
** file simultaneously, or one process from reading the database while
** another is writing.
**
-** @(#) $Id: pager.c,v 1.221 2005/11/29 03:13:22 drh Exp $
+** @(#) $Id: pager.c,v 1.222 2005/11/30 03:20:31 drh Exp $
*/
#ifndef SQLITE_OMIT_DISKIO
#include "sqliteInt.h"
** struct as it's argument.
*/
#define PAGERID(p) FILEHANDLEID(&(p)->fd)
-#define FILEHANDLEID(fd) (sqlite3Io.xFileHandle(&fd))
+#define FILEHANDLEID(fd) (sqlite3OsFileHandle(&fd))
/*
** The page cache as a whole is always in one of the following
static int read32bits(OsFile *fd, u32 *pRes){
u32 res;
int rc;
- rc = sqlite3Io.xRead(fd, &res, sizeof(res));
+ rc = sqlite3OsRead(fd, &res, sizeof(res));
if( rc==SQLITE_OK ){
unsigned char ac[4];
memcpy(ac, &res, 4);
ac[1] = (val>>16) & 0xff;
ac[2] = (val>>8) & 0xff;
ac[3] = val & 0xff;
- return sqlite3Io.xWrite(fd, ac, 4);
+ return sqlite3OsWrite(fd, ac, 4);
}
/*
*pzMaster = 0;
- rc = sqlite3Io.xFileSize(pJrnl, &szJ);
+ rc = sqlite3OsFileSize(pJrnl, &szJ);
if( rc!=SQLITE_OK || szJ<16 ) return rc;
- rc = sqlite3Io.xSeek(pJrnl, szJ-16);
+ rc = sqlite3OsSeek(pJrnl, szJ-16);
if( rc!=SQLITE_OK ) return rc;
rc = read32bits(pJrnl, &len);
rc = read32bits(pJrnl, &cksum);
if( rc!=SQLITE_OK ) return rc;
- rc = sqlite3Io.xRead(pJrnl, aMagic, 8);
+ rc = sqlite3OsRead(pJrnl, aMagic, 8);
if( rc!=SQLITE_OK || memcmp(aMagic, aJournalMagic, 8) ) return rc;
- rc = sqlite3Io.xSeek(pJrnl, szJ-16-len);
+ rc = sqlite3OsSeek(pJrnl, szJ-16-len);
if( rc!=SQLITE_OK ) return rc;
*pzMaster = (char *)sqliteMalloc(len+1);
if( !*pzMaster ){
return SQLITE_NOMEM;
}
- rc = sqlite3Io.xRead(pJrnl, *pzMaster, len);
+ rc = sqlite3OsRead(pJrnl, *pzMaster, len);
if( rc!=SQLITE_OK ){
sqliteFree(*pzMaster);
*pzMaster = 0;
assert( offset>=c );
assert( (offset-c)<JOURNAL_HDR_SZ(pPager) );
pPager->journalOff = offset;
- return sqlite3Io.xSeek(pPager->jfd, pPager->journalOff);
+ return sqlite3OsSeek(pPager->jfd, pPager->journalOff);
}
/*
** Actually maybe the whole journal header should be delayed until that
** point. Think about this.
*/
- rc = sqlite3Io.xWrite(pPager->jfd, aJournalMagic, sizeof(aJournalMagic));
+ rc = sqlite3OsWrite(pPager->jfd, aJournalMagic, sizeof(aJournalMagic));
if( rc==SQLITE_OK ){
/* The nRec Field. 0xFFFFFFFF for no-sync journals. */
** file descriptor to the end of the journal header sector.
*/
if( rc==SQLITE_OK ){
- rc = sqlite3Io.xSeek(pPager->jfd, pPager->journalOff-1);
+ rc = sqlite3OsSeek(pPager->jfd, pPager->journalOff-1);
if( rc==SQLITE_OK ){
- rc = sqlite3Io.xWrite(pPager->jfd, "\000", 1);
+ rc = sqlite3OsWrite(pPager->jfd, "\000", 1);
}
}
return rc;
return SQLITE_DONE;
}
- rc = sqlite3Io.xRead(pPager->jfd, aMagic, sizeof(aMagic));
+ rc = sqlite3OsRead(pPager->jfd, aMagic, sizeof(aMagic));
if( rc ) return rc;
if( memcmp(aMagic, aJournalMagic, sizeof(aMagic))!=0 ){
if( rc ) return rc;
pPager->journalOff += JOURNAL_HDR_SZ(pPager);
- rc = sqlite3Io.xSeek(pPager->jfd, pPager->journalOff);
+ rc = sqlite3OsSeek(pPager->jfd, pPager->journalOff);
return rc;
}
rc = write32bits(pPager->jfd, PAGER_MJ_PGNO(pPager));
if( rc!=SQLITE_OK ) return rc;
- rc = sqlite3Io.xWrite(pPager->jfd, zMaster, len);
+ rc = sqlite3OsWrite(pPager->jfd, zMaster, len);
if( rc!=SQLITE_OK ) return rc;
rc = write32bits(pPager->jfd, len);
rc = write32bits(pPager->jfd, cksum);
if( rc!=SQLITE_OK ) return rc;
- rc = sqlite3Io.xWrite(pPager->jfd, aJournalMagic, sizeof(aJournalMagic));
+ rc = sqlite3OsWrite(pPager->jfd, aJournalMagic, sizeof(aJournalMagic));
pPager->needSync = !pPager->noSync;
return rc;
}
if( pPager->state>=PAGER_RESERVED ){
sqlite3pager_rollback(pPager);
}
- sqlite3Io.xUnlock(pPager->fd, NO_LOCK);
+ sqlite3OsUnlock(pPager->fd, NO_LOCK);
pPager->state = PAGER_UNLOCK;
pPager->dbSize = -1;
pPager->nRef = 0;
}
sqlite3pager_stmt_commit(pPager);
if( pPager->stmtOpen ){
- sqlite3Io.xClose(&pPager->stfd);
+ sqlite3OsClose(&pPager->stfd);
pPager->stmtOpen = 0;
}
if( pPager->journalOpen ){
- sqlite3Io.xClose(&pPager->jfd);
+ sqlite3OsClose(&pPager->jfd);
pPager->journalOpen = 0;
- sqlite3Io.xDelete(pPager->zJournal);
+ sqlite3Os.xDelete(pPager->zJournal);
sqliteFree( pPager->aInJournal );
pPager->aInJournal = 0;
for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){
assert( pPager->aInJournal==0 );
assert( pPager->dirtyCache==0 || pPager->useJournal==0 );
}
- rc = sqlite3Io.xUnlock(pPager->fd, SHARED_LOCK);
+ rc = sqlite3OsUnlock(pPager->fd, SHARED_LOCK);
pPager->state = PAGER_SHARED;
pPager->origDbSize = 0;
pPager->setMaster = 0;
rc = read32bits(jfd, &pgno);
if( rc!=SQLITE_OK ) return rc;
- rc = sqlite3Io.xRead(jfd, &aData, pPager->pageSize);
+ rc = sqlite3OsRead(jfd, &aData, pPager->pageSize);
if( rc!=SQLITE_OK ) return rc;
pPager->journalOff += pPager->pageSize + 4;
assert( pPager->state>=PAGER_EXCLUSIVE || pPg!=0 );
TRACE3("PLAYBACK %d page %d\n", PAGERID(pPager), pgno);
if( pPager->state>=PAGER_EXCLUSIVE && (pPg==0 || pPg->needSync==0) ){
- rc = sqlite3Io.xSeek(pPager->fd, (pgno-1)*(i64)pPager->pageSize);
+ rc = sqlite3OsSeek(pPager->fd, (pgno-1)*(i64)pPager->pageSize);
if( rc==SQLITE_OK ){
- rc = sqlite3Io.xWrite(pPager->fd, aData, pPager->pageSize);
+ rc = sqlite3OsWrite(pPager->fd, aData, pPager->pageSize);
}
if( pPg ) pPg->dirty = 0;
}
/* Open the master journal file exclusively in case some other process
** is running this routine also. Not that it makes too much difference.
*/
- rc = sqlite3Io.xOpenReadOnly(zMaster, &master);
+ rc = sqlite3Os.xOpenReadOnly(zMaster, &master);
if( rc!=SQLITE_OK ) goto delmaster_out;
master_open = 1;
- rc = sqlite3Io.xFileSize(master, &nMasterJournal);
+ rc = sqlite3OsFileSize(master, &nMasterJournal);
if( rc!=SQLITE_OK ) goto delmaster_out;
if( nMasterJournal>0 ){
rc = SQLITE_NOMEM;
goto delmaster_out;
}
- rc = sqlite3Io.xRead(master, zMasterJournal, nMasterJournal);
+ rc = sqlite3OsRead(master, zMasterJournal, nMasterJournal);
if( rc!=SQLITE_OK ) goto delmaster_out;
zJournal = zMasterJournal;
while( (zJournal-zMasterJournal)<nMasterJournal ){
- if( sqlite3Io.xFileExists(zJournal) ){
+ if( sqlite3Os.xFileExists(zJournal) ){
/* One of the journals pointed to by the master journal exists.
** Open it and check if it points at the master journal. If
** so, return without deleting the master journal file.
OsFile *journal = 0;
int c;
- rc = sqlite3Io.xOpenReadOnly(zJournal, &journal);
+ rc = sqlite3Os.xOpenReadOnly(zJournal, &journal);
if( rc!=SQLITE_OK ){
goto delmaster_out;
}
rc = readMasterJournal(journal, &zMasterPtr);
- sqlite3Io.xClose(&journal);
+ sqlite3OsClose(&journal);
if( rc!=SQLITE_OK ){
goto delmaster_out;
}
}
}
- sqlite3Io.xDelete(zMaster);
+ sqlite3Os.xDelete(zMaster);
delmaster_out:
if( zMasterJournal ){
sqliteFree(zMasterJournal);
}
if( master_open ){
- sqlite3Io.xClose(&master);
+ sqlite3OsClose(&master);
}
return rc;
}
char zBuf[SQLITE_MAX_PAGE_SIZE];
if( !pPg->dirty ) continue;
if( (int)pPg->pgno <= pPager->origDbSize ){
- rc = sqlite3Io.xSeek(pPager->fd, pPager->pageSize*(i64)(pPg->pgno-1));
+ rc = sqlite3OsSeek(pPager->fd, pPager->pageSize*(i64)(pPg->pgno-1));
if( rc==SQLITE_OK ){
- rc = sqlite3Io.xRead(pPager->fd, zBuf, pPager->pageSize);
+ rc = sqlite3OsRead(pPager->fd, zBuf, pPager->pageSize);
}
TRACE3("REFETCH %d page %d\n", PAGERID(pPager), pPg->pgno);
if( rc ) break;
*/
static int pager_truncate(Pager *pPager, int nPage){
assert( pPager->state>=PAGER_EXCLUSIVE );
- return sqlite3Io.xTruncate(pPager->fd, pPager->pageSize*(i64)nPage);
+ return sqlite3OsTruncate(pPager->fd, pPager->pageSize*(i64)nPage);
}
/*
** the journal is empty.
*/
assert( pPager->journalOpen );
- rc = sqlite3Io.xFileSize(pPager->jfd, &szJ);
+ rc = sqlite3OsFileSize(pPager->jfd, &szJ);
if( rc!=SQLITE_OK ){
goto end_playback;
}
*/
rc = readMasterJournal(pPager->jfd, &zMaster);
assert( rc!=SQLITE_DONE );
- if( rc!=SQLITE_OK || (zMaster && !sqlite3Io.xFileExists(zMaster)) ){
+ if( rc!=SQLITE_OK || (zMaster && !sqlite3Os.xFileExists(zMaster)) ){
sqliteFree(zMaster);
zMaster = 0;
if( rc==SQLITE_DONE ) rc = SQLITE_OK;
goto end_playback;
}
- sqlite3Io.xSeek(pPager->jfd, 0);
+ sqlite3OsSeek(pPager->jfd, 0);
pPager->journalOff = 0;
/* This loop terminates either when the readJournalHdr() call returns
pPager->dbSize = mxPg;
}
- /* rc = sqlite3Io.xSeek(pPager->jfd, JOURNAL_HDR_SZ(pPager)); */
+ /* rc = sqlite3OsSeek(pPager->jfd, JOURNAL_HDR_SZ(pPager)); */
if( rc!=SQLITE_OK ) goto end_playback;
/* Copy original pages out of the journal and back into the database file.
#ifndef NDEBUG
{
i64 os_szJ;
- rc = sqlite3Io.xFileSize(pPager->jfd, &os_szJ);
+ rc = sqlite3OsFileSize(pPager->jfd, &os_szJ);
if( rc!=SQLITE_OK ) return rc;
assert( szJ==os_szJ );
}
/* Figure out how many records are in the statement journal.
*/
assert( pPager->stmtInUse && pPager->journalOpen );
- sqlite3Io.xSeek(pPager->stfd, 0);
+ sqlite3OsSeek(pPager->stfd, 0);
nRec = pPager->stmtNRec;
/* Copy original pages out of the statement journal and back into the
** If it is not zero, then Pager.stmtHdrOff is the offset to the start
** of the first journal header written during this statement transaction.
*/
- rc = sqlite3Io.xSeek(pPager->jfd, pPager->stmtJSize);
+ rc = sqlite3OsSeek(pPager->jfd, pPager->stmtJSize);
if( rc!=SQLITE_OK ){
goto end_stmt_playback;
}
** or power failures by changing the number of syncs()s when writing
** the rollback journal. There are three levels:
**
-** OFF sqlite3Io.xSync() is never called. This is the default
+** OFF sqlite3OsSync() is never called. This is the default
** for temporary and transient files.
**
** NORMAL The journal is synced once before writes begin on the
sqlite3_opentemp_count++; /* Used for testing and analysis only */
do{
cnt--;
- sqlite3Io.xTempFileName(zFile);
- rc = sqlite3Io.xOpenExclusive(zFile, pFd, 1);
+ sqlite3Os.xTempFileName(zFile);
+ rc = sqlite3Os.xOpenExclusive(zFile, pFd, 1);
}while( cnt>0 && rc!=SQLITE_OK && rc!=SQLITE_NOMEM );
return rc;
}
}else
#endif
{
- zFullPathname = sqlite3Io.xFullPathname(zFilename);
+ zFullPathname = sqlite3Os.xFullPathname(zFilename);
if( zFullPathname ){
- rc = sqlite3Io.xOpenReadWrite(zFullPathname, &fd, &readOnly);
+ rc = sqlite3Os.xOpenReadWrite(zFullPathname, &fd, &readOnly);
}
}
}else{
rc = sqlite3pager_opentemp(zTemp, &fd);
zFilename = zTemp;
- zFullPathname = sqlite3Io.xFullPathname(zFilename);
+ zFullPathname = sqlite3Os.xFullPathname(zFilename);
if( rc==SQLITE_OK ){
tempFile = 1;
}
}
if( !zFullPathname ){
- sqlite3Io.xClose(&fd);
+ sqlite3OsClose(&fd);
return SQLITE_NOMEM;
}
if( rc!=SQLITE_OK ){
- sqlite3Io.xClose(&fd);
+ sqlite3OsClose(&fd);
sqliteFree(zFullPathname);
return rc;
}
nameLen = strlen(zFullPathname);
pPager = sqliteMalloc( sizeof(*pPager) + nameLen*3 + 30 );
if( pPager==0 ){
- sqlite3Io.xClose(&fd);
+ sqlite3OsClose(&fd);
sqliteFree(zFullPathname);
return SQLITE_NOMEM;
}
void sqlite3pager_read_fileheader(Pager *pPager, int N, unsigned char *pDest){
memset(pDest, 0, N);
if( MEMDB==0 ){
- sqlite3Io.xSeek(pPager->fd, 0);
- sqlite3Io.xRead(pPager->fd, pDest, N);
+ sqlite3OsSeek(pPager->fd, 0);
+ sqlite3OsRead(pPager->fd, pDest, N);
clear_simulated_io_error();
}
}
if( pPager->dbSize>=0 ){
n = pPager->dbSize;
} else {
- if( sqlite3Io.xFileSize(pPager->fd, &n)!=SQLITE_OK ){
+ if( sqlite3OsFileSize(pPager->fd, &n)!=SQLITE_OK ){
pPager->errMask |= PAGER_ERR_DISK;
return 0;
}
rc = SQLITE_OK;
}else{
do {
- rc = sqlite3Io.xLock(pPager->fd, locktype);
+ rc = sqlite3OsLock(pPager->fd, locktype);
}while( rc==SQLITE_BUSY && sqlite3InvokeBusyHandler(pPager->pBusyHandler) );
if( rc==SQLITE_OK ){
pPager->state = locktype;
sqlite3pager_rollback(pPager);
enable_simulated_io_errors();
if( !MEMDB ){
- sqlite3Io.xUnlock(pPager->fd, NO_LOCK);
+ sqlite3OsUnlock(pPager->fd, NO_LOCK);
}
assert( pPager->errMask || pPager->journalOpen==0 );
break;
}
case PAGER_SHARED: {
if( !MEMDB ){
- sqlite3Io.xUnlock(pPager->fd, NO_LOCK);
+ sqlite3OsUnlock(pPager->fd, NO_LOCK);
}
break;
}
TRACE2("CLOSE %d\n", PAGERID(pPager));
assert( pPager->errMask || (pPager->journalOpen==0 && pPager->stmtOpen==0) );
if( pPager->journalOpen ){
- sqlite3Io.xClose(&pPager->jfd);
+ sqlite3OsClose(&pPager->jfd);
}
sqliteFree(pPager->aInJournal);
if( pPager->stmtOpen ){
- sqlite3Io.xClose(&pPager->stfd);
+ sqlite3OsClose(&pPager->stfd);
}
- sqlite3Io.xClose(&pPager->fd);
+ sqlite3OsClose(&pPager->fd);
/* Temp files are automatically deleted by the OS
** if( pPager->tempFile ){
- ** sqlite3Io.xDelete(pPager->zFilename);
+ ** sqlite3Os.xDelete(pPager->zFilename);
** }
*/
** with the nRec computed from the size of the journal file.
*/
i64 jSz;
- rc = sqlite3Io.xFileSize(pPager->jfd, &jSz);
+ rc = sqlite3OsFileSize(pPager->jfd, &jSz);
if( rc!=0 ) return rc;
assert( pPager->journalOff==jSz );
}
*/
if( pPager->fullSync ){
TRACE2("SYNC journal of %d\n", PAGERID(pPager));
- rc = sqlite3Io.xSync(pPager->jfd, 0);
+ rc = sqlite3OsSync(pPager->jfd, 0);
if( rc!=0 ) return rc;
}
- rc = sqlite3Io.xSeek(pPager->jfd,
+ rc = sqlite3OsSeek(pPager->jfd,
pPager->journalHdr + sizeof(aJournalMagic));
if( rc ) return rc;
rc = write32bits(pPager->jfd, pPager->nRec);
if( rc ) return rc;
- rc = sqlite3Io.xSeek(pPager->jfd, pPager->journalOff);
+ rc = sqlite3OsSeek(pPager->jfd, pPager->journalOff);
if( rc ) return rc;
}
TRACE2("SYNC journal of %d\n", PAGERID(pPager));
- rc = sqlite3Io.xSync(pPager->jfd, pPager->fullSync);
+ rc = sqlite3OsSync(pPager->jfd, pPager->fullSync);
if( rc!=0 ) return rc;
pPager->journalStarted = 1;
}
/* At this point there may be either a RESERVED or EXCLUSIVE lock on the
** database file. If there is already an EXCLUSIVE lock, the following
- ** calls to sqlite3Io.xLock() are no-ops.
+ ** calls to sqlite3OsLock() are no-ops.
**
** Moving the lock from RESERVED to EXCLUSIVE actually involves going
** through an intermediate state PENDING. A PENDING lock prevents new
while( pList ){
assert( pList->dirty );
- rc = sqlite3Io.xSeek(pPager->fd, (pList->pgno-1)*(i64)pPager->pageSize);
+ rc = sqlite3OsSeek(pPager->fd, (pList->pgno-1)*(i64)pPager->pageSize);
if( rc ) return rc;
/* If there are dirty pages in the page cache with page numbers greater
** than Pager.dbSize, this means sqlite3pager_truncate() was called to
if( pList->pgno<=pPager->dbSize ){
CODEC(pPager, PGHDR_TO_DATA(pList), pList->pgno, 6);
TRACE3("STORE %d page %d\n", PAGERID(pPager), pList->pgno);
- rc = sqlite3Io.xWrite(pPager->fd, PGHDR_TO_DATA(pList),
+ rc = sqlite3OsWrite(pPager->fd, PGHDR_TO_DATA(pList),
pPager->pageSize);
CODEC(pPager, PGHDR_TO_DATA(pList), pList->pgno, 0);
TEST_INCR(pPager->nWrite);
*/
static int hasHotJournal(Pager *pPager){
if( !pPager->useJournal ) return 0;
- if( !sqlite3Io.xFileExists(pPager->zJournal) ) return 0;
- if( sqlite3Io.xCheckReservedLock(pPager->fd) ) return 0;
+ if( !sqlite3Os.xFileExists(pPager->zJournal) ) return 0;
+ if( sqlite3OsCheckReservedLock(pPager->fd) ) return 0;
if( sqlite3pager_pagecount(pPager)==0 ){
- sqlite3Io.xDelete(pPager->zJournal);
+ sqlite3Os.xDelete(pPager->zJournal);
return 0;
}else{
return 1;
** second process will get to this point in the code and fail to
** obtain it's own EXCLUSIVE lock on the database file.
*/
- rc = sqlite3Io.xLock(pPager->fd, EXCLUSIVE_LOCK);
+ rc = sqlite3OsLock(pPager->fd, EXCLUSIVE_LOCK);
if( rc!=SQLITE_OK ){
- sqlite3Io.xUnlock(pPager->fd, NO_LOCK);
+ sqlite3OsUnlock(pPager->fd, NO_LOCK);
pPager->state = PAGER_UNLOCK;
return rc;
}
** a write lock, so there is never any chance of two or more
** processes opening the journal at the same time.
*/
- rc = sqlite3Io.xOpenReadOnly(pPager->zJournal, &pPager->jfd);
+ rc = sqlite3Os.xOpenReadOnly(pPager->zJournal, &pPager->jfd);
if( rc!=SQLITE_OK ){
- sqlite3Io.xUnlock(pPager->fd, NO_LOCK);
+ sqlite3OsUnlock(pPager->fd, NO_LOCK);
pPager->state = PAGER_UNLOCK;
return SQLITE_BUSY;
}
}else{
int rc;
assert( MEMDB==0 );
- rc = sqlite3Io.xSeek(pPager->fd, (pgno-1)*(i64)pPager->pageSize);
+ rc = sqlite3OsSeek(pPager->fd, (pgno-1)*(i64)pPager->pageSize);
if( rc==SQLITE_OK ){
- rc = sqlite3Io.xRead(pPager->fd, PGHDR_TO_DATA(pPg),
+ rc = sqlite3OsRead(pPager->fd, PGHDR_TO_DATA(pPg),
pPager->pageSize);
}
TRACE3("FETCH %d page %d\n", PAGERID(pPager), pPg->pgno);
CODEC(pPager, PGHDR_TO_DATA(pPg), pPg->pgno, 3);
if( rc!=SQLITE_OK ){
i64 fileSize;
- if( sqlite3Io.xFileSize(pPager->fd,&fileSize)!=SQLITE_OK
+ if( sqlite3OsFileSize(pPager->fd,&fileSize)!=SQLITE_OK
|| fileSize>=pgno*pPager->pageSize ){
sqlite3pager_unref(PGHDR_TO_DATA(pPg));
return rc;
rc = SQLITE_NOMEM;
goto failed_to_open_journal;
}
- rc = sqlite3Io.xOpenExclusive(pPager->zJournal, &pPager->jfd,
+ rc = sqlite3Os.xOpenExclusive(pPager->zJournal, &pPager->jfd,
pPager->tempFile);
pPager->journalOff = 0;
pPager->setMaster = 0;
if( rc!=SQLITE_OK ){
goto failed_to_open_journal;
}
- sqlite3Io.xSetFullSync(pPager->jfd, pPager->fullSync);
- sqlite3Io.xSetFullSync(pPager->fd, pPager->fullSync);
- sqlite3Io.xOpenDirectory(pPager->zDirectory, pPager->jfd);
+ sqlite3OsSetFullSync(pPager->jfd, pPager->fullSync);
+ sqlite3OsSetFullSync(pPager->fd, pPager->fullSync);
+ sqlite3OsOpenDirectory(pPager->jfd, pPager->zDirectory);
pPager->journalOpen = 1;
pPager->journalStarted = 0;
pPager->needSync = 0;
failed_to_open_journal:
sqliteFree(pPager->aInJournal);
pPager->aInJournal = 0;
- sqlite3Io.xUnlock(pPager->fd, NO_LOCK);
+ sqlite3OsUnlock(pPager->fd, NO_LOCK);
pPager->state = PAGER_UNLOCK;
return rc;
}
pPager->state = PAGER_EXCLUSIVE;
pPager->origDbSize = pPager->dbSize;
}else{
- rc = sqlite3Io.xLock(pPager->fd, RESERVED_LOCK);
+ rc = sqlite3OsLock(pPager->fd, RESERVED_LOCK);
if( rc==SQLITE_OK ){
pPager->state = PAGER_RESERVED;
if( exFlag ){
store32bits(cksum, pPg, pPager->pageSize);
szPg = pPager->pageSize+8;
store32bits(pPg->pgno, pPg, -4);
- rc = sqlite3Io.xWrite(pPager->jfd, &((char*)pData)[-4], szPg);
+ rc = sqlite3OsWrite(pPager->jfd, &((char*)pData)[-4], szPg);
pPager->journalOff += szPg;
TRACE4("JOURNAL %d page %d needSync=%d\n",
PAGERID(pPager), pPg->pgno, pPg->needSync);
}else{
store32bits(pPg->pgno, pPg, -4);
CODEC(pPager, pData, pPg->pgno, 7);
- rc = sqlite3Io.xWrite(pPager->stfd,((char*)pData)-4,
+ rc = sqlite3OsWrite(pPager->stfd,((char*)pData)-4,
pPager->pageSize+4);
TRACE3("STMT-JOURNAL %d page %d\n", PAGERID(pPager), pPg->pgno);
CODEC(pPager, pData, pPg->pgno, 0);
return SQLITE_OK;
}
if( pPager->dirtyCache==0 ){
- /* Exit early (without doing the time-consuming sqlite3Io.xSync() calls)
+ /* Exit early (without doing the time-consuming sqlite3OsSync() calls)
** if there have been no changes to the database file. */
assert( pPager->needSync==0 );
rc = pager_unwritelock(pPager);
assert( pPager->journalOpen );
pPager->aInStmt = sqliteMalloc( pPager->dbSize/8 + 1 );
if( pPager->aInStmt==0 ){
- sqlite3Io.xLock(pPager->fd, SHARED_LOCK);
+ sqlite3OsLock(pPager->fd, SHARED_LOCK);
return SQLITE_NOMEM;
}
#ifndef NDEBUG
- rc = sqlite3Io.xFileSize(pPager->jfd, &pPager->stmtJSize);
+ rc = sqlite3OsFileSize(pPager->jfd, &pPager->stmtJSize);
if( rc ) goto stmt_begin_failed;
assert( pPager->stmtJSize == pPager->journalOff );
#endif
PgHdr *pPg, *pNext;
TRACE2("STMT-COMMIT %d\n", PAGERID(pPager));
if( !MEMDB ){
- sqlite3Io.xSeek(pPager->stfd, 0);
- /* sqlite3Io.xTruncate(pPager->stfd, 0); */
+ sqlite3OsSeek(pPager->stfd, 0);
+ /* sqlite3OsTruncate(pPager->stfd, 0); */
sqliteFree( pPager->aInStmt );
pPager->aInStmt = 0;
}
/* Sync the database file. */
if( !pPager->noSync ){
- rc = sqlite3Io.xSync(pPager->fd, 0);
+ rc = sqlite3OsSync(pPager->fd, 0);
}
pPager->state = PAGER_SYNCED;
** PENDING_LOCK, or EXCLUSIVE_LOCK.
*/
int sqlite3pager_lockstate(Pager *pPager){
- return sqlite3Io.xLockState(pPager->fd);
+ return sqlite3OsLockState(pPager->fd);
}
#endif
*************************************************************************
** This file contains code used to implement the PRAGMA command.
**
-** $Id: pragma.c,v 1.104 2005/11/26 00:25:03 drh Exp $
+** $Id: pragma.c,v 1.105 2005/11/30 03:20:31 drh Exp $
*/
#include "sqliteInt.h"
#include "os.h"
sqlite3VdbeAddOp(v, OP_Callback, 1, 0);
}
}else{
- if( zRight[0] && !sqlite3Io.xIsDirWritable(zRight) ){
+ if( zRight[0] && !sqlite3Os.xIsDirWritable(zRight) ){
sqlite3ErrorMsg(pParse, "not a writable directory");
goto pragma_out;
}
** Random numbers are used by some of the database backends in order
** to generate random integer keys for tables or random filenames.
**
-** $Id: random.c,v 1.13 2005/06/12 21:35:52 drh Exp $
+** $Id: random.c,v 1.14 2005/11/30 03:20:32 drh Exp $
*/
#include "sqliteInt.h"
#include "os.h"
char k[256];
prng.j = 0;
prng.i = 0;
- sqlite3OsRandomSeed(k);
+ sqlite3Os.xRandomSeed(k);
for(i=0; i<256; i++){
prng.s[i] = i;
}
*/
void sqlite3Randomness(int N, void *pBuf){
unsigned char *zBuf = pBuf;
- sqlite3OsEnterMutex();
+ sqlite3Os.xEnterMutex();
while( N-- ){
*(zBuf++) = randomByte();
}
- sqlite3OsLeaveMutex();
+ sqlite3Os.xLeaveMutex();
}
** is not included in the SQLite library. It is used for automated
** testing of the SQLite library.
**
-** $Id: test1.c,v 1.167 2005/11/29 03:13:22 drh Exp $
+** $Id: test1.c,v 1.168 2005/11/30 03:20:32 drh Exp $
*/
#include "sqliteInt.h"
#include "tcl.h"
return TCL_ERROR;
}
- rc = sqlite3Io.xOpenReadWrite(Tcl_GetString(objv[1]), &pFile, &dummy);
+ rc = sqlite3Os.xOpenReadWrite(Tcl_GetString(objv[1]), &pFile, &dummy);
if( rc!=SQLITE_OK ){
Tcl_SetResult(interp, (char *)errorName(rc), TCL_STATIC);
return TCL_ERROR;
if( getFilePointer(interp, Tcl_GetString(objv[1]), &pFile) ){
return TCL_ERROR;
}
- rc = sqlite3Io.xClose(&pFile);
+ rc = sqlite3OsClose(&pFile);
if( rc!=SQLITE_OK ){
Tcl_SetResult(interp, (char *)errorName(rc), TCL_STATIC);
return TCL_ERROR;
}
if( 0==strcmp("SHARED", Tcl_GetString(objv[2])) ){
- rc = sqlite3Io.xLock(pFile, SHARED_LOCK);
+ rc = sqlite3OsLock(pFile, SHARED_LOCK);
}
else if( 0==strcmp("RESERVED", Tcl_GetString(objv[2])) ){
- rc = sqlite3Io.xLock(pFile, RESERVED_LOCK);
+ rc = sqlite3OsLock(pFile, RESERVED_LOCK);
}
else if( 0==strcmp("PENDING", Tcl_GetString(objv[2])) ){
- rc = sqlite3Io.xLock(pFile, PENDING_LOCK);
+ rc = sqlite3OsLock(pFile, PENDING_LOCK);
}
else if( 0==strcmp("EXCLUSIVE", Tcl_GetString(objv[2])) ){
- rc = sqlite3Io.xLock(pFile, EXCLUSIVE_LOCK);
+ rc = sqlite3OsLock(pFile, EXCLUSIVE_LOCK);
}else{
Tcl_AppendResult(interp, "wrong # args: should be \"",
Tcl_GetString(objv[0]),
if( getFilePointer(interp, Tcl_GetString(objv[1]), &pFile) ){
return TCL_ERROR;
}
- rc = sqlite3Io.xUnlock(pFile, NO_LOCK);
+ rc = sqlite3OsUnlock(pFile, NO_LOCK);
if( rc!=SQLITE_OK ){
Tcl_SetResult(interp, (char *)errorName(rc), TCL_STATIC);
return TCL_ERROR;
char zFile[SQLITE_TEMPNAME_SIZE];
int rc;
- rc = sqlite3Io.xTempFileName(zFile);
+ rc = sqlite3Os.xTempFileName(zFile);
if( rc!=SQLITE_OK ){
Tcl_SetResult(interp, (char *)errorName(rc), TCL_STATIC);
return TCL_ERROR;
** is not included in the SQLite library. It is used for automated
** testing of the SQLite library.
**
-** $Id: test2.c,v 1.37 2005/11/29 03:13:22 drh Exp $
+** $Id: test2.c,v 1.38 2005/11/30 03:20:32 drh Exp $
*/
#include "sqliteInt.h"
#include "os.h"
return TCL_ERROR;
}
if( Tcl_GetInt(interp, argv[1], &n) ) return TCL_ERROR;
- rc = sqlite3Io.xOpenReadWrite(argv[2], &fd, &readOnly);
+ rc = sqlite3Os.xOpenReadWrite(argv[2], &fd, &readOnly);
if( rc ){
Tcl_AppendResult(interp, "open failed: ", errorName(rc), 0);
return TCL_ERROR;
}
offset = n;
offset *= 1024*1024;
- rc = sqlite3Io.xSeek(fd, offset);
+ rc = sqlite3OsSeek(fd, offset);
if( rc ){
Tcl_AppendResult(interp, "seek failed: ", errorName(rc), 0);
return TCL_ERROR;
}
- rc = sqlite3Io.xWrite(fd, "Hello, World!", 14);
- sqlite3Io.xClose(&fd);
+ rc = sqlite3OsWrite(fd, "Hello, World!", 14);
+ sqlite3OsClose(&fd);
if( rc ){
Tcl_AppendResult(interp, "write failed: ", errorName(rc), 0);
return TCL_ERROR;
#include "tcl.h"
/*
-** A copy of the original sqlite3Io structure
+** A copy of the original sqlite3Os structure
*/
-static struct sqlite3IoVtbl origIo;
+static struct sqlite3OsVtbl origOs;
/*
-** The OsFile structure for the crash-test backend. The pBase field
-** points to an OsFile structure for the native backend.
+** crashFile is a subclass of OsFile that is taylored for the
+** crash test module.
*/
-struct OsFile {
- u8 **apBlk; /* Array of blocks that have been written to. */
- int nBlk; /* Size of apBlock. */
- i64 offset; /* Next character to be read from the file */
- int nMaxWrite; /* Largest offset written to. */
- char *zName; /* File name */
- OsFile *pBase; /* Base class */
- OsFile *pNext; /* Next in a list of them all */
+typedef struct crashFile crashFile;
+struct crashFile {
+ IoMethod const *pMethod; /* Must be first */
+ u8 **apBlk; /* Array of blocks that have been written to. */
+ int nBlk; /* Size of apBlock. */
+ i64 offset; /* Next character to be read from the file */
+ int nMaxWrite; /* Largest offset written to. */
+ char *zName; /* File name */
+ OsFile *pBase; /* The real file */
+ crashFile *pNext; /* Next in a list of them all */
};
/*
** Set the value of the two crash parameters.
*/
static void setCrashParams(int iDelay, char const *zFile){
- sqlite3OsEnterMutex();
+ sqlite3Os.xEnterMutex();
assert( strlen(zFile)<sizeof(zCrashFile) );
strcpy(zCrashFile, zFile);
iCrashDelay = iDelay;
- sqlite3OsLeaveMutex();
+ sqlite3Os.xLeaveMutex();
}
/*
static int crashRequired(char const *zPath){
int r;
int n;
- sqlite3OsEnterMutex();
+ sqlite3Os.xEnterMutex();
n = strlen(zCrashFile);
if( zCrashFile[n-1]=='*' ){
n--;
r = 1;
}
}
- sqlite3OsLeaveMutex();
+ sqlite3Os.xLeaveMutex();
return r;
}
/*
** A list of all open files.
*/
-static OsFile *pAllFiles = 0;
+static crashFile *pAllFiles = 0;
-/*
-** Initialise the os_test.c specific fields of pFile.
-*/
-static void initFile(OsFile **pId, char const *zName, OsFile *pBase){
- OsFile *pFile = *pId = sqliteMalloc(sizeof(OsFile) + strlen(zName)+1);
- pFile->nMaxWrite = 0;
- pFile->offset = 0;
- pFile->nBlk = 0;
- pFile->apBlk = 0;
- pFile->zName = (char *)(&pFile[1]);
- strcpy(pFile->zName, zName);
- pFile->pBase = pBase;
- pFile->pNext = pAllFiles;
- pAllFiles = pFile;
-}
+/* Forward reference */
+static void initFile(OsFile **pId, char const *zName, OsFile *pBase);
/*
** Undo the work done by initFile. Delete the OsFile structure
** and unlink the structure from the pAllFiles list.
*/
-static void closeFile(OsFile **pId){
- OsFile *pFile = *pId;
+static void closeFile(crashFile **pId){
+ crashFile *pFile = *pId;
if( pFile==pAllFiles ){
pAllFiles = pFile->pNext;
}else{
- OsFile *p;
+ crashFile *p;
for(p=pAllFiles; p->pNext!=pFile; p=p->pNext ){
assert( p );
}
/*
** Read block 'blk' off of the real disk file and into the cache of pFile.
*/
-static int readBlockIntoCache(OsFile *pFile, int blk){
+static int readBlockIntoCache(crashFile *pFile, int blk){
if( blk>=pFile->nBlk ){
int n = ((pFile->nBlk * 2) + 100 + blk);
/* if( pFile->nBlk==0 ){ printf("DIRTY %s\n", pFile->zName); } */
if( !p ) return SQLITE_NOMEM;
pFile->apBlk[blk] = p;
- rc = origIo.xFileSize(pFile->pBase, &filesize);
+ rc = sqlite3OsFileSize(pFile->pBase, &filesize);
if( rc!=SQLITE_OK ) return rc;
if( BLOCK_OFFSET(blk)<filesize ){
int len = BLOCKSIZE;
- rc = origIo.xSeek(pFile->pBase, blk*BLOCKSIZE);
+ rc = sqlite3OsSeek(pFile->pBase, blk*BLOCKSIZE);
if( BLOCK_OFFSET(blk+1)>filesize ){
len = filesize - BLOCK_OFFSET(blk);
}
if( rc!=SQLITE_OK ) return rc;
- rc = origIo.xRead(pFile->pBase, p, len);
+ rc = sqlite3OsRead(pFile->pBase, p, len);
if( rc!=SQLITE_OK ) return rc;
}
}
** 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(OsFile *pFile, int crash){
+static int writeCache2(crashFile *pFile, int crash){
int i;
int nMax = pFile->nMaxWrite;
int rc = SQLITE_OK;
}
}
if( rc==SQLITE_OK ){
- rc = origIo.xSeek(pFile->pBase, BLOCK_OFFSET(i));
+ rc = sqlite3OsSeek(pFile->pBase, BLOCK_OFFSET(i));
}
if( rc==SQLITE_OK && !skip ){
int len = BLOCKSIZE;
if( trash ){
sqlite3Randomness(len, p);
}
- rc = origIo.xWrite(pFile->pBase, p, len);
+ rc = sqlite3OsWrite(pFile->pBase, p, len);
}
}
sqliteFree(p);
/*
** Write the cache to disk.
*/
-static int writeCache(OsFile *pFile){
+static int writeCache(crashFile *pFile){
if( pFile->apBlk ){
int c = crashRequired(pFile->zName);
if( c ){
- OsFile *p;
+ crashFile *p;
#ifdef TRACE_WRITECACHE
printf("\nCrash during sync of %s\n", pFile->zName);
#endif
** Close the file.
*/
static int crashClose(OsFile **pId){
- OsFile *pFile = *pId;
+ crashFile *pFile = (crashFile*)*pId;
if( pFile ){
/* printf("CLOSE %s (%d blocks)\n", pFile->zName, pFile->nBlk); */
writeCache(pFile);
- origIo.xClose(&pFile->pBase);
+ sqlite3OsClose(&pFile->pBase);
}
- closeFile(pId);
+ closeFile(&pFile);
+ *pId = 0;
return SQLITE_OK;
}
static int crashSeek(OsFile *id, i64 offset){
- id->offset = offset;
+ ((crashFile*)id)->offset = offset;
return SQLITE_OK;
}
int i;
u8 *zCsr;
int rc = SQLITE_OK;
- OsFile *pFile = id;
+ crashFile *pFile = (crashFile*)id;
offset = pFile->offset;
end = offset+amt;
u8 *pBlk = pFile->apBlk[i];
memcpy(zCsr, &pBlk[off], len);
}else{
- rc = origIo.xSeek(id->pBase, BLOCK_OFFSET(i) + off);
+ rc = sqlite3OsSeek(pFile->pBase, BLOCK_OFFSET(i) + off);
if( rc!=SQLITE_OK ) return rc;
- rc = origIo.xRead(id->pBase, zCsr, len);
+ rc = sqlite3OsRead(pFile->pBase, zCsr, len);
if( rc!=SQLITE_OK ) return rc;
}
}
assert( zCsr==&((u8 *)pBuf)[amt] );
- id->offset = end;
+ pFile->offset = end;
return rc;
}
int i;
const u8 *zCsr;
int rc = SQLITE_OK;
+ crashFile *pFile = (crashFile*)id;
- offset = id->offset;
+ offset = pFile->offset;
end = offset+amt;
blk = (offset/BLOCKSIZE);
int len = 0;
/* Make sure the block is in the cache */
- rc = readBlockIntoCache(id, i);
+ rc = readBlockIntoCache(pFile, i);
if( rc!=SQLITE_OK ) return rc;
/* Write into the cache */
- pBlk = id->apBlk[i];
+ pBlk = pFile->apBlk[i];
assert( pBlk );
if( BLOCK_OFFSET(i) < offset ){
memcpy(&pBlk[off], zCsr, len);
zCsr += len;
}
- if( id->nMaxWrite<end ){
- id->nMaxWrite = end;
+ if( pFile->nMaxWrite<end ){
+ pFile->nMaxWrite = end;
}
assert( zCsr==&((u8 *)pBuf)[amt] );
- id->offset = end;
+ pFile->offset = end;
return rc;
}
** real sync() function.
*/
static int crashSync(OsFile *id, int dataOnly){
- int rc;
- /* printf("SYNC %s (%d blocks)\n", (*id)->zName, (*id)->nBlk); */
- rc = writeCache(id);
- /* if( rc!=SQLITE_OK ) return rc; rc = origIo.xSync(id->pBase, dataOnly); */
- return rc;
+ return writeCache((crashFile*)id);
}
/*
** is written to disk.
*/
static int crashTruncate(OsFile *id, i64 nByte){
- id->nMaxWrite = nByte;
- return origIo.xTruncate(id->pBase, nByte);
+ crashFile *pFile = (crashFile*)id;
+ pFile->nMaxWrite = nByte;
+ return sqlite3OsTruncate(pFile->pBase, nByte);
}
/*
** the file, then return this size instead of the on-disk size.
*/
static int crashFileSize(OsFile *id, i64 *pSize){
- int rc = origIo.xFileSize(id->pBase, pSize);
- if( rc==SQLITE_OK && pSize && *pSize<id->nMaxWrite ){
- *pSize = id->nMaxWrite;
+ crashFile *pFile = (crashFile*)id;
+ int rc = sqlite3OsFileSize(pFile->pBase, pSize);
+ if( rc==SQLITE_OK && pSize && *pSize<pFile->nMaxWrite ){
+ *pSize = pFile->nMaxWrite;
}
return rc;
}
*/
static int crashOpenReadWrite(const char *zFilename, OsFile **pId,int *pRdonly){
OsFile *pBase = 0;
- int rc = origIo.xOpenReadWrite(zFilename, &pBase, pRdonly);
+ int rc = origOs.xOpenReadWrite(zFilename, &pBase, pRdonly);
if( !rc ){
initFile(pId, zFilename, pBase);
}
}
static int crashOpenExclusive(const char *zFilename, OsFile **pId, int delFlag){
OsFile *pBase = 0;
- int rc = origIo.xOpenExclusive(zFilename, &pBase, delFlag);
+ int rc = origOs.xOpenExclusive(zFilename, &pBase, delFlag);
if( !rc ){
initFile(pId, zFilename, pBase);
}
}
static int crashOpenReadOnly(const char *zFilename, OsFile **pId){
OsFile *pBase = 0;
- int rc = origIo.xOpenReadOnly(zFilename, &pBase);
+ int rc = origOs.xOpenReadOnly(zFilename, &pBase);
if( !rc ){
initFile(pId, zFilename, pBase);
}
}
/*
-** OpenDirectory and SyncDirectory are no-ops
+** OpenDirectory is a no-op
*/
-static int crashOpenDir(const char *zName, OsFile *id){
- return SQLITE_OK;
-}
-static int crashSyncDir(const char *zName){
+static int crashOpenDir(OsFile *id, const char *zName){
return SQLITE_OK;
}
** file descriptor.
*/
int crashLock(OsFile *id, int lockType){
- return origIo.xLock(id->pBase, lockType);
+ return sqlite3OsLock(((crashFile*)id)->pBase, lockType);
}
int crashUnlock(OsFile *id, int lockType){
- return origIo.xUnlock(id->pBase, lockType);
+ return sqlite3OsUnlock(((crashFile*)id)->pBase, lockType);
}
int crashCheckReservedLock(OsFile *id){
- return origIo.xCheckReservedLock(id->pBase);
+ return sqlite3OsCheckReservedLock(((crashFile*)id)->pBase);
}
void crashSetFullSync(OsFile *id, int setting){
return; /* This is a no-op */
}
int crashLockState(OsFile *id){
- return origIo.xLockState(id->pBase);
+ return sqlite3OsLockState(((crashFile*)id)->pBase);
}
/*
** Return the underlying file handle.
*/
int crashFileHandle(OsFile *id){
- return origIo.xFileHandle(id->pBase);
+ return sqlite3OsFileHandle(((crashFile*)id)->pBase);
}
+/*
+** This vector defines all the methods that can operate on an OsFile
+** for the crash tester.
+*/
+static const IoMethod crashIoMethod = {
+ crashClose,
+ crashOpenDir,
+ crashRead,
+ crashWrite,
+ crashSeek,
+ crashTruncate,
+ crashSync,
+ crashSetFullSync,
+ crashFileHandle,
+ crashFileSize,
+ crashLock,
+ crashUnlock,
+ crashLockState,
+ crashCheckReservedLock,
+};
+
+
+/*
+** Initialise the os_test.c specific fields of pFile.
+*/
+static void initFile(OsFile **pId, char const *zName, OsFile *pBase){
+ crashFile *pFile = sqliteMalloc(sizeof(crashFile) + strlen(zName)+1);
+ pFile->pMethod = &crashIoMethod;
+ pFile->nMaxWrite = 0;
+ pFile->offset = 0;
+ pFile->nBlk = 0;
+ pFile->apBlk = 0;
+ pFile->zName = (char *)(&pFile[1]);
+ strcpy(pFile->zName, zName);
+ pFile->pBase = pBase;
+ pFile->pNext = pAllFiles;
+ pAllFiles = pFile;
+ *pId = (OsFile*)pFile;
+}
+
+
/*
** tclcmd: sqlite_crashparams DELAY CRASHFILE
**
return TCL_ERROR;
}
setCrashParams(delay, zFile);
- origIo = sqlite3Io;
- /* xDelete unchanged */
- /* xFileExists unchanged */
- sqlite3Io.xOpenReadWrite = crashOpenReadWrite;
- sqlite3Io.xOpenExclusive = crashOpenExclusive;
- sqlite3Io.xOpenReadOnly = crashOpenReadOnly;
- sqlite3Io.xOpenDirectory = crashOpenDir;
- sqlite3Io.xSyncDirectory = crashSyncDir;
- /* xTempFileName unchanged */
- /* xIsDirWritable unchanged */
- sqlite3Io.xClose = crashClose;
- sqlite3Io.xRead = crashRead;
- sqlite3Io.xWrite = crashWrite;
- sqlite3Io.xSeek = crashSeek;
- sqlite3Io.xSync = crashSync;
- sqlite3Io.xTruncate = crashTruncate;
- sqlite3Io.xFileSize = crashFileSize;
- /* xFullPathname unchanged */
- sqlite3Io.xLock = crashLock;
- sqlite3Io.xUnlock = crashUnlock;
- sqlite3Io.xCheckReservedLock = crashCheckReservedLock;
- sqlite3Io.xSetFullSync = crashSetFullSync;
- sqlite3Io.xFileHandle = crashFileHandle;
- sqlite3Io.xLockState = crashLockState;
+ if( origOs.xOpenReadWrite==0 ){
+ origOs = sqlite3Os;
+ sqlite3Os.xOpenReadWrite = crashOpenReadWrite;
+ sqlite3Os.xOpenExclusive = crashOpenExclusive;
+ sqlite3Os.xOpenReadOnly = crashOpenReadOnly;
+ }
return TCL_OK;
}
** Most of the code in this file may be omitted by defining the
** SQLITE_OMIT_VACUUM macro.
**
-** $Id: vacuum.c,v 1.48 2005/11/26 00:25:04 drh Exp $
+** $Id: vacuum.c,v 1.49 2005/11/30 03:20:32 drh Exp $
*/
#include "sqliteInt.h"
#include "os.h"
do {
zTemp[nFilename] = '-';
randomName((unsigned char*)&zTemp[nFilename+1]);
- } while( sqlite3Io.xFileExists(zTemp) );
+ } while( sqlite3Os.xFileExists(zTemp) );
/* Attach the temporary database as 'vacuum_db'. The synchronous pragma
** can be set to 'off' for this file, as it is not recovered if a crash
rc = rc2;
}
if( zTemp ){
- sqlite3Io.xDelete(zTemp);
+ sqlite3Os.xDelete(zTemp);
sqliteFree(zTemp);
}
sqliteFree( zSql );
** in this file for details. If in doubt, do not deviate from existing
** commenting and indentation practices when changing or adding code.
**
-** $Id: vdbe.c,v 1.500 2005/11/26 00:25:04 drh Exp $
+** $Id: vdbe.c,v 1.501 2005/11/30 03:20:32 drh Exp $
*/
#include "sqliteInt.h"
#include "os.h"
}
sqlite3VdbePrintOp(p->trace, pc, pOp);
}
- if( p->trace==0 && pc==0 && sqlite3Io.xFileExists("vdbe_sqltrace") ){
+ if( p->trace==0 && pc==0 && sqlite3Os.xFileExists("vdbe_sqltrace") ){
sqlite3VdbePrintSql(p);
}
#endif
}
if( db->xProfile && !db->init.busy ){
double rNow;
- sqlite3OsCurrentTime(&rNow);
+ sqlite3Os.xCurrentTime(&rNow);
p->startTime = (rNow - (int)rNow)*3600.0*24.0*1000000000.0;
}
#endif
double rNow;
u64 elapseTime;
- sqlite3OsCurrentTime(&rNow);
+ sqlite3Os.xCurrentTime(&rNow);
elapseTime = (rNow - (int)rNow)*3600.0*24.0*1000000000.0 - p->startTime;
assert( p->nOp>0 );
assert( p->aOp[p->nOp-1].opcode==OP_Noop );
/* If we never rollback a statement transaction, then statement
** transactions are not needed. So change every OP_Statement
- ** opcode into an OP_Noop. This avoid a call to sqlite3Io.xOpenExclusive()
+ ** opcode into an OP_Noop. This avoid a call to sqlite3Os.xOpenExclusive()
** which can be expensive on some platforms.
*/
if( hasStatementBegin && !doesStatementRollback ){
#ifdef SQLITE_DEBUG
if( (p->db->flags & SQLITE_VdbeListing)!=0
- || sqlite3Io.xFileExists("vdbe_explain")
+ || sqlite3Os.xFileExists("vdbe_explain")
){
int i;
printf("VDBE Program Listing:\n");
sqlite3VdbePrintOp(stdout, i, &p->aOp[i]);
}
}
- if( sqlite3Io.xFileExists("vdbe_trace") ){
+ if( sqlite3Os.xFileExists("vdbe_trace") ){
p->trace = stdout;
}
#endif
if( !zMaster ){
return SQLITE_NOMEM;
}
- }while( sqlite3Io.xFileExists(zMaster) );
+ }while( sqlite3Os.xFileExists(zMaster) );
/* Open the master journal. */
- rc = sqlite3Io.xOpenExclusive(zMaster, &master, 0);
+ rc = sqlite3Os.xOpenExclusive(zMaster, &master, 0);
if( rc!=SQLITE_OK ){
sqliteFree(zMaster);
return rc;
if( !needSync && !sqlite3BtreeSyncDisabled(pBt) ){
needSync = 1;
}
- rc = sqlite3Io.xWrite(master, zFile, strlen(zFile)+1);
+ rc = sqlite3OsWrite(master, zFile, strlen(zFile)+1);
if( rc!=SQLITE_OK ){
- sqlite3Io.xClose(&master);
- sqlite3Io.xDelete(zMaster);
+ sqlite3OsClose(&master);
+ sqlite3Os.xDelete(zMaster);
sqliteFree(zMaster);
return rc;
}
** the master journal file is store in so that it gets synced too.
*/
zMainFile = sqlite3BtreeGetDirname(db->aDb[0].pBt);
- rc = sqlite3Io.xOpenDirectory(zMainFile, master);
+ rc = sqlite3OsOpenDirectory(master, zMainFile);
if( rc!=SQLITE_OK ||
- (needSync && (rc=sqlite3Io.xSync(master,0))!=SQLITE_OK) ){
- sqlite3Io.xClose(&master);
- sqlite3Io.xDelete(zMaster);
+ (needSync && (rc=sqlite3OsSync(master,0))!=SQLITE_OK) ){
+ sqlite3OsClose(&master);
+ sqlite3Os.xDelete(zMaster);
sqliteFree(zMaster);
return rc;
}
if( pBt && sqlite3BtreeIsInTrans(pBt) ){
rc = sqlite3BtreeSync(pBt, zMaster);
if( rc!=SQLITE_OK ){
- sqlite3Io.xClose(&master);
+ sqlite3OsClose(&master);
sqliteFree(zMaster);
return rc;
}
}
}
- sqlite3Io.xClose(&master);
+ sqlite3OsClose(&master);
/* Delete the master journal file. This commits the transaction. After
** doing this the directory is synced again before any individual
** transaction files are deleted.
*/
- rc = sqlite3Io.xDelete(zMaster);
+ rc = sqlite3Os.xDelete(zMaster);
assert( rc==SQLITE_OK );
sqliteFree(zMaster);
zMaster = 0;
- rc = sqlite3Io.xSyncDirectory(zMainFile);
+ rc = sqlite3Os.xSyncDirectory(zMainFile);
if( rc!=SQLITE_OK ){
/* This is not good. The master journal file has been deleted, but
** the directory sync failed. There is no completely safe course of
projects / thirdparty / sqlite.git / commitdiff
