-C Do\snot\sgenerate\ssqlite_stat1\sentries\sfor\sempty\stables\swhen\srunning\nANALYZE.\s\sTicket\s[83ea97620bd31016451]
-D 2011-03-30T14:54:05.390
+C Further\stests\sfor\sos_unix.c.
+D 2011-03-30T19:08:03.321
F Makefile.arm-wince-mingw32ce-gcc d6df77f1f48d690bd73162294bbba7f59507c72f
F Makefile.in 27701a1653595a1f2187dc61c8117e00a6c1d50f
F Makefile.linux-gcc 91d710bdc4998cb015f39edf3cb314ec4f4d7e23
F src/os.h 9dbed8c2b9c1f2f2ebabc09e49829d4777c26bf9
F src/os_common.h a8f95b81eca8a1ab8593d23e94f8a35f35d4078f
F src/os_os2.c 2596fd2d5d0976c6c0c628d0c3c7c4e7a724f4cf
-F src/os_unix.c 0b37759312e8adb58c0c7dab1ab8ca16957bf299
+F src/os_unix.c be9f9d3383a7b556a1f3805442e0061e436eb7ac
F src/os_win.c 24d72407a90551969744cf9bcbb1b4c72c5fa845
F src/pager.c 6aa906b60a59664ba58d3f746164bb010d407ce1
F src/pager.h 3f8c783de1d4706b40b1ac15b64f5f896bcc78d1
F src/status.c 4997380fbb915426fef9e500b4872e79c99267fc
F src/table.c 2cd62736f845d82200acfa1287e33feb3c15d62e
F src/tclsqlite.c b020ebf3b4af58cae7875e217efd7ac22f485713
-F src/test1.c 9020310c7617234b33fd1c3064f89524db25f290
+F src/test1.c 9ca440e80e16e53920904a0a5ac7feffb9b2c9a1
F src/test2.c 80d323d11e909cf0eb1b6fbb4ac22276483bcf31
F src/test3.c 056093cfef69ff4227a6bdb9108564dc7f45e4bc
F src/test4.c 0528360b5025688002a5feb6be906ddce52eaaee
F src/test_server.c bbba05c144b5fc4b52ff650a4328027b3fa5fcc6
F src/test_stat.c f682704b5d1ba8e1d4e7e882a6d7922e2dcf066c
F src/test_superlock.c 2b97936ca127d13962c3605dbc9a4ef269c424cd
-F src/test_syscall.c d12e8cd163cd33b66d0a3d1b8daaf136d09d65c2
+F src/test_syscall.c 349a2b913e82b029f01527f58f65d66a02a09a84
F src/test_tclvar.c f4dc67d5f780707210d6bb0eb6016a431c04c7fa
F src/test_thread.c bedd05cad673dba53326f3aa468cc803038896c0
F src/test_vfs.c 2ed8853c1e51ac6f9ea091f7ce4e0d618bba8b86
F test/substr.test 18f57c4ca8a598805c4d64e304c418734d843c1a
F test/superlock.test 5d7a4954b0059c903f82c7b67867bc5451a7c082
F test/sync.test ded6b39d8d8ca3c0c5518516c6371b3316d3e3a3
-F test/syscall.test 125d9781d914c408e8629053b5f914dc920ab3eb
-F test/sysfault.test be42aa42f89a82305cf3807047d419595e430480
+F test/syscall.test d1dae1fee88613cf763d97ad0038d867509e0c42
+F test/sysfault.test a2c3ca66d82f3b4ac7d29f1aeaba8962f4f5a22a
F test/table.test 04ba066432430657712d167ebf28080fe878d305
F test/tableapi.test 2674633fa95d80da917571ebdd759a14d9819126
F test/tclsqlite.test 8c154101e704170c2be10f137a5499ac2c6da8d3
F test/types2.test 3555aacf8ed8dc883356e59efc314707e6247a84
F test/types3.test a0f66bf12f80fad89493535474f7a6d16fa58150
F test/unique.test 083c7fff74695bcc27a71d75699deba3595bc9c2
+F test/unixexcl.test 9d80a54d86d2261f660758928959368ffc36151e
F test/update.test 8bc86fd7ef1a00014f76dc6a6a7c974df4aef172
F test/utf16align.test 54cd35a27c005a9b6e7815d887718780b6a462ae
F test/vacuum.test 29b60e8cc9e573b39676df6c4a75fe9e02d04a09
F tool/speedtest8.c 2902c46588c40b55661e471d7a86e4dd71a18224
F tool/speedtest8inst1.c 293327bc76823f473684d589a8160bde1f52c14e
F tool/vdbe-compress.tcl d70ea6d8a19e3571d7ab8c9b75cba86d1173ff0f
-P 3d2de011814002e2e25b7645f94ff8fc7aab9cdd
-R 0216cf925df143bd6cbc69301b702732
-U drh
-Z ebdb63d4898403f81a888e3e3a66ac94
+P 3a27af5b3c688c651ba1fae261026ef77b7ff5e3
+R 8aec69201b7794049bf0ef28fa4da45f
+U dan
+Z 9b217166a2b3bec7df70dcbc250ff848
-3a27af5b3c688c651ba1fae261026ef77b7ff5e3
\ No newline at end of file
+a84f7711949ea3885b0e36e48118d2c76a8a5b82
\ No newline at end of file
*/
static int sqliteErrorFromPosixError(int posixError, int sqliteIOErr) {
switch (posixError) {
+#if 0
+ /* At one point this code was not commented out. In theory, this branch
+ ** should never be hit, as this function should only be called after
+ ** a locking-related function (i.e. fcntl()) has returned non-zero with
+ ** the value of errno as the first argument. Since a system call has failed,
+ ** errno should be non-zero.
+ **
+ ** Despite this, if errno really is zero, we still don't want to return
+ ** SQLITE_OK. The system call failed, and *some* SQLite error should be
+ ** propagated back to the caller. Commenting this branch out means errno==0
+ ** will be handled by the "default:" case below.
+ */
case 0:
return SQLITE_OK;
-
+#endif
+
case EAGAIN:
case ETIMEDOUT:
case EBUSY:
static void releaseInodeInfo(unixFile *pFile){
unixInodeInfo *pInode = pFile->pInode;
assert( unixMutexHeld() );
- if( pInode ){
+ if( ALWAYS(pInode) ){
pInode->nRef--;
if( pInode->nRef==0 ){
assert( pInode->pShmNode==0 );
** This function is a pass-through to fcntl(F_SETLK) if pFile is using
** any VFS other than "unix-excl" or if pFile is opened on "unix-excl"
** and is read-only.
+**
+** Zero is returned if the call completes successfully, or -1 if a call
+** to fcntl() fails. In this case, errno is set appropriately (by fcntl()).
*/
static int unixFileLock(unixFile *pFile, struct flock *pLock){
int rc;
unixFile *pFile = (unixFile*)id;
unixInodeInfo *pInode = pFile->pInode;
struct flock lock;
- int s = 0;
int tErrno = 0;
assert( pFile );
){
lock.l_type = (eFileLock==SHARED_LOCK?F_RDLCK:F_WRLCK);
lock.l_start = PENDING_BYTE;
- s = unixFileLock(pFile, &lock);
- if( s==(-1) ){
+ if( unixFileLock(pFile, &lock) ){
tErrno = errno;
rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK);
- if( IS_LOCK_ERROR(rc) ){
+ if( rc!=SQLITE_BUSY ){
pFile->lastErrno = tErrno;
}
goto end_lock;
if( eFileLock==SHARED_LOCK ){
assert( pInode->nShared==0 );
assert( pInode->eFileLock==0 );
+ assert( rc==SQLITE_OK );
/* Now get the read-lock */
lock.l_start = SHARED_FIRST;
lock.l_len = SHARED_SIZE;
- if( (s = unixFileLock(pFile, &lock))==(-1) ){
+ if( unixFileLock(pFile, &lock) ){
tErrno = errno;
+ rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK);
}
+
/* Drop the temporary PENDING lock */
lock.l_start = PENDING_BYTE;
lock.l_len = 1L;
lock.l_type = F_UNLCK;
- if( unixFileLock(pFile, &lock)!=0 ){
- if( s != -1 ){
- /* This could happen with a network mount */
- tErrno = errno;
- rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_UNLOCK);
- if( IS_LOCK_ERROR(rc) ){
- pFile->lastErrno = tErrno;
- }
- goto end_lock;
- }
+ if( unixFileLock(pFile, &lock) && rc==SQLITE_OK ){
+ /* This could happen with a network mount */
+ tErrno = errno;
+ rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_UNLOCK);
}
- if( s==(-1) ){
- rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK);
- if( IS_LOCK_ERROR(rc) ){
+
+ if( rc ){
+ if( rc!=SQLITE_BUSY ){
pFile->lastErrno = tErrno;
}
+ goto end_lock;
}else{
pFile->eFileLock = SHARED_LOCK;
pInode->nLock++;
*/
assert( 0!=pFile->eFileLock );
lock.l_type = F_WRLCK;
- switch( eFileLock ){
- case RESERVED_LOCK:
- lock.l_start = RESERVED_BYTE;
- break;
- case EXCLUSIVE_LOCK:
- lock.l_start = SHARED_FIRST;
- lock.l_len = SHARED_SIZE;
- break;
- default:
- assert(0);
+
+ assert( eFileLock==RESERVED_LOCK || eFileLock==EXCLUSIVE_LOCK );
+ if( eFileLock==RESERVED_LOCK ){
+ lock.l_start = RESERVED_BYTE;
+ lock.l_len = 1L;
+ }else{
+ lock.l_start = SHARED_FIRST;
+ lock.l_len = SHARED_SIZE;
}
- s = unixFileLock(pFile, &lock);
- if( s==(-1) ){
+
+ if( unixFileLock(pFile, &lock) ){
tErrno = errno;
rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK);
- if( IS_LOCK_ERROR(rc) ){
+ if( rc!=SQLITE_BUSY ){
pFile->lastErrno = tErrno;
}
}
lock.l_whence = SEEK_SET;
lock.l_start = SHARED_FIRST;
lock.l_len = SHARED_SIZE;
- if( unixFileLock(pFile, &lock)==(-1) ){
+ if( unixFileLock(pFile, &lock) ){
tErrno = errno;
rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_RDLOCK);
- if( IS_LOCK_ERROR(rc) ){
+ if( rc!=SQLITE_BUSY ){
pFile->lastErrno = tErrno;
}
goto end_unlock;
lock.l_whence = SEEK_SET;
lock.l_start = PENDING_BYTE;
lock.l_len = 2L; assert( PENDING_BYTE+1==RESERVED_BYTE );
- if( unixFileLock(pFile, &lock)!=(-1) ){
+ if( unixFileLock(pFile, &lock)==0 ){
pInode->eFileLock = SHARED_LOCK;
}else{
tErrno = errno;
rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_UNLOCK);
- if( IS_LOCK_ERROR(rc) ){
+ if( rc!=SQLITE_BUSY ){
pFile->lastErrno = tErrno;
}
goto end_unlock;
SimulateIOErrorBenign(1);
SimulateIOError( h=(-1) )
SimulateIOErrorBenign(0);
- if( unixFileLock(pFile, &lock)!=(-1) ){
+ if( unixFileLock(pFile, &lock)==0 ){
pInode->eFileLock = NO_LOCK;
}else{
tErrno = errno;
rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_UNLOCK);
- if( IS_LOCK_ERROR(rc) ){
+ if( rc!=SQLITE_BUSY ){
pFile->lastErrno = tErrno;
}
pInode->eFileLock = NO_LOCK;
*/
static int closeUnixFile(sqlite3_file *id){
unixFile *pFile = (unixFile*)id;
- if( pFile ){
- if( pFile->dirfd>=0 ){
- robust_close(pFile, pFile->dirfd, __LINE__);
- pFile->dirfd=-1;
- }
- if( pFile->h>=0 ){
- robust_close(pFile, pFile->h, __LINE__);
- pFile->h = -1;
- }
+ if( pFile->dirfd>=0 ){
+ robust_close(pFile, pFile->dirfd, __LINE__);
+ pFile->dirfd=-1;
+ }
+ if( pFile->h>=0 ){
+ robust_close(pFile, pFile->h, __LINE__);
+ pFile->h = -1;
+ }
#if OS_VXWORKS
- if( pFile->pId ){
- if( pFile->isDelete ){
- unlink(pFile->pId->zCanonicalName);
- }
- vxworksReleaseFileId(pFile->pId);
- pFile->pId = 0;
+ if( pFile->pId ){
+ if( pFile->isDelete ){
+ unlink(pFile->pId->zCanonicalName);
}
-#endif
- OSTRACE(("CLOSE %-3d\n", pFile->h));
- OpenCounter(-1);
- sqlite3_free(pFile->pUnused);
- memset(pFile, 0, sizeof(unixFile));
+ vxworksReleaseFileId(pFile->pId);
+ pFile->pId = 0;
}
+#endif
+ OSTRACE(("CLOSE %-3d\n", pFile->h));
+ OpenCounter(-1);
+ sqlite3_free(pFile->pUnused);
+ memset(pFile, 0, sizeof(unixFile));
return SQLITE_OK;
}
*/
static int unixClose(sqlite3_file *id){
int rc = SQLITE_OK;
- if( id ){
- unixFile *pFile = (unixFile *)id;
- unixUnlock(id, NO_LOCK);
- unixEnterMutex();
- assert( pFile->pInode==0 || pFile->pInode->nLock>0
- || pFile->pInode->bProcessLock==0 );
- if( pFile->pInode && pFile->pInode->nLock ){
- /* If there are outstanding locks, do not actually close the file just
- ** yet because that would clear those locks. Instead, add the file
- ** descriptor to pInode->pUnused list. It will be automatically closed
- ** when the last lock is cleared.
- */
- setPendingFd(pFile);
- }
- releaseInodeInfo(pFile);
- rc = closeUnixFile(id);
- unixLeaveMutex();
+ unixFile *pFile = (unixFile *)id;
+ unixUnlock(id, NO_LOCK);
+ unixEnterMutex();
+
+ /* unixFile.pInode is always valid here. Otherwise, a different close
+ ** routine (e.g. nolockClose()) would be called instead.
+ */
+ assert( pFile->pInode->nLock>0 || pFile->pInode->bProcessLock==0 );
+ if( ALWAYS(pFile->pInode) && pFile->pInode->nLock ){
+ /* If there are outstanding locks, do not actually close the file just
+ ** yet because that would clear those locks. Instead, add the file
+ ** descriptor to pInode->pUnused list. It will be automatically closed
+ ** when the last lock is cleared.
+ */
+ setPendingFd(pFile);
}
+ releaseInodeInfo(pFile);
+ rc = closeUnixFile(id);
+ unixLeaveMutex();
return rc;
}
do{ got = osPwrite64(id->h, pBuf, cnt, offset);}while( got<0 && errno==EINTR);
#else
newOffset = lseek(id->h, offset, SEEK_SET);
+ SimulateIOError( newOffset-- );
if( newOffset!=offset ){
if( newOffset == -1 ){
((unixFile*)id)->lastErrno = errno;
nSize = ((nByte+pFile->szChunk-1) / pFile->szChunk) * pFile->szChunk;
if( nSize>(i64)buf.st_size ){
+
#if defined(HAVE_POSIX_FALLOCATE) && HAVE_POSIX_FALLOCATE
- int rc;
+ /* The code below is handling the return value of osFallocate()
+ ** correctly. posix_fallocate() is defined to "returns zero on success,
+ ** or an error number on failure". See the manpage for details. */
+ int err;
do{
- rc = osFallocate(pFile->h, buf.st_size, nSize-buf.st_size);
- }while( rc<0 && errno==EINTR );
- if( rc ) return SQLITE_IOERR_WRITE;
+ err = osFallocate(pFile->h, buf.st_size, nSize-buf.st_size);
+ }while( err==EINTR );
+ if( err ) return SQLITE_IOERR_WRITE;
#else
/* If the OS does not have posix_fallocate(), fake it. First use
** ftruncate() to set the file size, then write a single byte to
return TCL_OK;
}
+/*
+** tclcmd: file_control_sizehint_test DB DBNAME SIZE
+**
+** This TCL command runs the sqlite3_file_control interface and
+** verifies correct operation of the SQLITE_GET_LOCKPROXYFILE and
+** SQLITE_SET_LOCKPROXYFILE verbs.
+*/
+static int file_control_sizehint_test(
+ ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
+ Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
+ int objc, /* Number of arguments */
+ Tcl_Obj *CONST objv[] /* Command arguments */
+){
+ sqlite3_int64 nSize; /* Hinted size */
+ char *zDb; /* Db name ("main", "temp" etc.) */
+ sqlite3 *db; /* Database handle */
+ int rc; /* file_control() return code */
+
+ if( objc!=4 ){
+ Tcl_WrongNumArgs(interp, 1, objv, "DB DBNAME SIZE");
+ return TCL_ERROR;
+ }
+ if( getDbPointer(interp, Tcl_GetString(objv[1]), &db)
+ || Tcl_GetWideIntFromObj(interp, objv[3], &nSize)
+ ){
+ return TCL_ERROR;
+ }
+ zDb = Tcl_GetString(objv[2]);
+ if( zDb[0]=='\0' ) zDb = NULL;
+
+ rc = sqlite3_file_control(db, zDb, SQLITE_FCNTL_SIZE_HINT, (void *)&nSize);
+ if( rc ){
+ Tcl_SetResult(interp, (char *)sqlite3TestErrorName(rc), TCL_STATIC);
+ return TCL_ERROR;
+ }
+ return TCL_OK;
+}
+
/*
** tclcmd: file_control_lockproxy_test DB PWD
**
{ "file_control_lasterrno_test", file_control_lasterrno_test, 0 },
{ "file_control_lockproxy_test", file_control_lockproxy_test, 0 },
{ "file_control_chunksize_test", file_control_chunksize_test, 0 },
+ { "file_control_sizehint_test", file_control_sizehint_test, 0 },
{ "sqlite3_vfs_list", vfs_list, 0 },
{ "sqlite3_create_function_v2", test_create_function_v2, 0 },
/* 4 */ { "stat", (sqlite3_syscall_ptr)ts_stat, 0, 0, 0 },
/* 5 */ { "fstat", (sqlite3_syscall_ptr)ts_fstat, 0, 0, 0 },
/* 6 */ { "ftruncate", (sqlite3_syscall_ptr)ts_ftruncate, 0, EIO, 0 },
- /* 7 */ { "fcntl", (sqlite3_syscall_ptr)ts_fcntl, 0, 0, 0 },
+ /* 7 */ { "fcntl", (sqlite3_syscall_ptr)ts_fcntl, 0, EACCES, 0 },
/* 8 */ { "read", (sqlite3_syscall_ptr)ts_read, 0, 0, 0 },
/* 9 */ { "pread", (sqlite3_syscall_ptr)ts_pread, 0, 0, 0 },
/* 10 */ { "pread64", (sqlite3_syscall_ptr)ts_pread64, 0, 0, 0 },
static int ts_fcntl(int fd, int cmd, ... ){
va_list ap;
void *pArg;
- if( tsIsFail() ){
+ if( tsIsFailErrno("fcntl") ){
return -1;
}
va_start(ap, cmd);
** A wrapper around read().
*/
static int ts_read(int fd, void *aBuf, size_t nBuf){
- if( tsIsFail() ){
+ if( tsIsFailErrno("read") ){
return -1;
}
return orig_read(fd, aBuf, nBuf);
** A wrapper around pread().
*/
static int ts_pread(int fd, void *aBuf, size_t nBuf, off_t off){
- if( tsIsFail() ){
+ if( tsIsFailErrno("pread") ){
return -1;
}
return orig_pread(fd, aBuf, nBuf, off);
** A wrapper around pread64().
*/
static int ts_pread64(int fd, void *aBuf, size_t nBuf, off_t off){
- if( tsIsFail() ){
+ if( tsIsFailErrno("pread64") ){
return -1;
}
return orig_pread64(fd, aBuf, nBuf, off);
** A wrapper around write().
*/
static int ts_write(int fd, const void *aBuf, size_t nBuf){
- if( tsIsFail() ){
+ if( tsIsFailErrno("write") ){
return -1;
}
return orig_write(fd, aBuf, nBuf);
** A wrapper around pwrite().
*/
static int ts_pwrite(int fd, const void *aBuf, size_t nBuf, off_t off){
- if( tsIsFail() ){
+ if( tsIsFailErrno("pwrite") ){
return -1;
}
return orig_pwrite(fd, aBuf, nBuf, off);
** A wrapper around pwrite64().
*/
static int ts_pwrite64(int fd, const void *aBuf, size_t nBuf, off_t off){
- if( tsIsFail() ){
+ if( tsIsFailErrno("pwrite64") ){
return -1;
}
return orig_pwrite64(fd, aBuf, nBuf, off);
const char *z;
int i;
} aErrno[] = {
- { "EACCES", EACCES },
- { "EINTR", EINTR },
- { "EIO", EIO },
+ { "EACCES", EACCES },
+ { "EINTR", EINTR },
+ { "EIO", EIO },
{ "EOVERFLOW", EOVERFLOW },
- { "ENOMEM", ENOMEM },
+ { "ENOMEM", ENOMEM },
+ { "EAGAIN", EAGAIN },
+ { "ETIMEDOUT", ETIMEDOUT },
+ { "EBUSY", EBUSY },
+ { "EPERM", EPERM },
+ { "EDEADLK", EDEADLK },
+ { "ENOLCK", ENOLCK },
{ 0, 0 }
};
db close
} {}
+#-------------------------------------------------------------------------
+# Test that a database file a single byte in size is treated as an empty
+# file. Whereas a file 2 bytes or larger might be considered corrupt.
+#
+catch { db close }
+forcedelete test.db test.db2
+
+proc create_db_file {nByte} {
+ set fd [open test.db w]
+ fconfigure $fd -translation binary -encoding binary
+ puts -nonewline $fd [string range "xSQLite" 1 $nByte]
+ close $fd
+}
+
+foreach {nByte res} {
+ 1 {0 {}}
+ 2 {1 {file is encrypted or is not a database}}
+ 3 {1 {file is encrypted or is not a database}}
+} {
+ do_test 7.$nByte {
+ create_db_file $nByte
+ sqlite3 db test.db
+ catchsql { CREATE TABLE t1(a, b) }
+ } $res
+ catch { db close }
+}
+
+#-------------------------------------------------------------------------
+#
+catch { db close }
+forcedelete test.db test.db2
+
+do_test 8.1 {
+ sqlite3 db test.db
+ file_control_chunksize_test db main 4096
+ file size test.db
+} {0}
+
+foreach {tn hint size} {
+ 1 1000 4096
+ 2 1000 4096
+ 3 3000 4096
+ 4 4096 4096
+ 5 4197 8192
+} {
+ do_test 8.2.$tn {
+ file_control_sizehint_test db main $hint
+ file size test.db
+ } $size
+}
+
finish_test
{1 {attempt to write a readonly database}}
}
-# Errors in the fstat() function when opening and writing a file.
+#-------------------------------------------------------------------------
+# Errors in the fstat() function when opening and writing a file. Cases
+# where fstat() fails and sets errno to ENOMEM and EOVERFLOW are both
+# tested. EOVERFLOW is interpreted as meaning that a file on disk is
+# too large to be opened by the OS.
#
foreach {tn errno errlist} {
1 ENOMEM {{disk I/O error}}
"
}
+#-------------------------------------------------------------------------
+# Various errors in locking functions.
+#
+foreach vfs {unix unix-excl} {
+ foreach {tn errno errlist} {
+ 1 EAGAIN {{database is locked}}
+ 2 ETIMEDOUT {{database is locked}}
+ 3 EBUSY {{database is locked}}
+ 4 EINTR {{database is locked}}
+ 5 ENOLCK {{database is locked}}
+ 6 EACCES {{database is locked}}
+ 7 EPERM {{access permission denied}}
+ 8 EDEADLK {{disk I/O error}}
+ 9 ENOMEM {{disk I/O error}}
+ } {
+ proc vfsfault_install {} { test_syscall install fcntl }
+ set errs [list]
+ foreach e $errlist { lappend errs [list 1 $e] }
+
+ set body [string map [list %VFS% $vfs] {
+ sqlite3 db test.db
+ db eval {
+ CREATE TABLE t1(a, b);
+ INSERT INTO t1 VALUES(1, 2);
+ }
+ set fd [open test.db-journal w]
+ puts $fd "hello world"
+ close $fd
+ sqlite3 db test.db -vfs %VFS%
+ db eval {
+ SELECT * FROM t1;
+ }
+ }]
+
+ do_faultsim_test 1.3.$vfs.$tn -faults vfsfault-* -prep {
+ faultsim_restore
+ } -body "
+ test_syscall errno fcntl $errno
+ $body
+ " -test "
+ faultsim_test_result {0 {1 2}} $errs
+ "
+ }
+}
+
#-------------------------------------------------------------------------
# Check that a single EINTR error does not affect processing.
#
proc vfsfault_install {} {
test_syscall reset
- test_syscall install {open ftruncate close}
+ test_syscall install {open ftruncate close read pread pread64 write fallocate}
}
forcedelete test.db test.db2
test_syscall errno open EINTR
test_syscall errno ftruncate EINTR
test_syscall errno close EINTR
+ test_syscall errno read EINTR
+ test_syscall errno pread EINTR
+ test_syscall errno pread64 EINTR
+ test_syscall errno write EINTR
+ test_syscall errno fallocate EINTR
sqlite3 db test.db
+ file_control_chunksize_test db main 8192
+
set res [db eval {
ATTACH 'test.db2' AS 'aux';
SELECT * FROM t1;
PRAGMA journal_mode = truncate;
BEGIN;
INSERT INTO t1 VALUES('jkl', 'mno', 'pqr');
+ INSERT INTO t1 VALUES(randomblob(10000), 0, 0);
UPDATE t2 SET x = 2;
COMMIT;
+ DELETE FROM t1 WHERE length(a)>3;
SELECT * FROM t1;
SELECT * FROM t2;
}]
}
#-------------------------------------------------------------------------
-#
+proc vfsfault_install {} {
+ test_syscall reset
+ test_syscall install {fstat fallocate}
+}
+do_faultsim_test 3 -faults vfsfault-* -prep {
+ faultsim_delete_and_reopen
+ file_control_chunksize_test db main 8192
+ execsql {
+ CREATE TABLE t1(a, b);
+ BEGIN;
+ SELECT * FROM t1;
+ }
+} -body {
+ test_syscall errno fstat EIO
+ test_syscall errno fallocate EIO
+
+ execsql {
+ INSERT INTO t1 VALUES(randomblob(10000), randomblob(10000));
+ SELECT length(a) + length(b) FROM t1;
+ COMMIT;
+ }
+} -test {
+ faultsim_test_result {0 20000}
+}
finish_test
--- /dev/null
+# 2011 March 30
+#
+# 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 tests for the "unix-excl" VFS module (part of
+# os_unix.c).
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+source $testdir/lock_common.tcl
+source $testdir/malloc_common.tcl
+
+if {$::tcl_platform(platform)!="unix" || [info commands test_syscall]==""} {
+ finish_test
+ return
+}
+set testprefix unixexcl
+
+
+
+# Test that when using VFS "unix-excl", the first time the database is read
+# a process-wide exclusive lock is taken on it. This means other connections
+# within the process may still access the db normally, but connections from
+# outside the process cannot.
+#
+do_multiclient_test tn {
+ do_test unixexcl-1.$tn.1 {
+ sql1 {
+ CREATE TABLE t1(a, b);
+ INSERT INTO t1 VALUES('hello', 'world');
+ }
+ } {}
+ do_test unixexcl-1.$tn.2 { sql2 { SELECT * FROM t1 } } {hello world}
+ do_test unixexcl-1.$tn.3 {
+ code1 {
+ db close
+ sqlite3 db test.db -vfs unix-excl
+ db eval { SELECT * FROM t1 }
+ }
+ } {hello world}
+ if {$tn==1} {
+ do_test unixexcl-1.$tn.4.multiproc {
+ csql2 { SELECT * FROM t1 }
+ } {1 {database is locked}}
+ } else {
+ do_test unixexcl-1.$tn.4.singleproc {
+ csql2 { SELECT * FROM t1 }
+ } {0 {hello world}}
+ }
+}
+
+# Test that when using VFS "unix-excl", if a file is opened in read-only mode
+# the behaviour is the same as if VFS "unix" were used.
+#
+do_multiclient_test tn {
+ do_test unixexcl-2.$tn.1 {
+ sql1 {
+ CREATE TABLE t1(a, b);
+ INSERT INTO t1 VALUES('hello', 'world');
+ }
+ } {}
+ do_test unixexcl-2.$tn.2 { sql2 { SELECT * FROM t1 } } {hello world}
+ do_test unixexcl-2.$tn.3 {
+ code1 {
+ db close
+ sqlite3 db test.db -readonly yes -vfs unix-excl
+ db eval { SELECT * FROM t1 }
+ }
+ } {hello world}
+ do_test unixexcl-2.$tn.4 {
+ csql2 { SELECT * FROM t1 }
+ } {0 {hello world}}
+}
+
+finish_test
projects / thirdparty / sqlite.git / commitdiff
