Index: src/os_unix.c
==================================================================
--- src/os_unix.c
+++ src/os_unix.c
@@ -189,10 +189,11 @@
   int lastErrno;                      /* The unix errno from last I/O error */
   void *lockingContext;               /* Locking style specific state */
   UnixUnusedFd *pUnused;              /* Pre-allocated UnixUnusedFd */
   const char *zPath;                  /* Name of the file */
   unixShm *pShm;                      /* Shared memory segment information */
+  sqlite3_int64 szFile;               /* File size for UNIXFILE_DELETE files */
   int szChunk;                        /* Configured by FCNTL_CHUNK_SIZE */
 #if SQLITE_MAX_MMAP_SIZE>0
   int nFetchOut;                      /* Number of outstanding xFetch refs */
   sqlite3_int64 mmapSize;             /* Usable size of mapping at pMapRegion */
   sqlite3_int64 mmapSizeActual;       /* Actual size of mapping at pMapRegion */
@@ -1319,22 +1320,24 @@
 ** Issue sqlite3_log(SQLITE_WARNING,...) messages if anything is not right.
 */
 static void verifyDbFile(unixFile *pFile){
   struct stat buf;
   int rc;
-  if( pFile->ctrlFlags & UNIXFILE_WARNED ){
-    /* One or more of the following warnings have already been issued.  Do not
-    ** repeat them so as not to clutter the error log */
+  if( pFile->ctrlFlags & (UNIXFILE_WARNED|UNIXFILE_DELETE) ){
+    /* UNIXFILE_WARNED means that one or more of the following warnings have
+    ** already been issued.  Do not* repeat them so as not to clutter the error
+    ** log.  Do not investigate unlinked files since fstat() does not always
+    ** work following an unlink(). */
     return;
   }
   rc = osFstat(pFile->h, &buf);
   if( rc!=0 ){
     sqlite3_log(SQLITE_WARNING, "cannot fstat db file %s", pFile->zPath);
     pFile->ctrlFlags |= UNIXFILE_WARNED;
     return;
   }
-  if( buf.st_nlink==0 && (pFile->ctrlFlags & UNIXFILE_DELETE)==0 ){
+  if( buf.st_nlink==0 ){
     sqlite3_log(SQLITE_WARNING, "file unlinked while open: %s", pFile->zPath);
     pFile->ctrlFlags |= UNIXFILE_WARNED;
     return;
   }
   if( buf.st_nlink>1 ){
@@ -3278,10 +3281,14 @@
 ){
   unixFile *pFile = (unixFile*)id;
   int wrote = 0;
   assert( id );
   assert( amt>0 );
+
+  /* Update the internally tracked file size.  The internal file size is only
+  ** accurate for unlinked files */
+  if( offset+amt>pFile->szFile ) pFile->szFile = offset+amt;
 
   /* If this is a database file (not a journal, master-journal or temp
   ** file), the bytes in the locking range should never be read or written. */
 #if 0
   assert( pFile->pUnused==0
@@ -3619,25 +3626,41 @@
     if( nByte<pFile->mmapSize ){
       pFile->mmapSize = nByte;
     }
 #endif
 
+    pFile->szFile = nByte;
     return SQLITE_OK;
   }
 }
 
 /*
 ** Determine the current size of a file in bytes
 */
 static int unixFileSize(sqlite3_file *id, i64 *pSize){
   int rc;
+  unixFile *pFile = (unixFile*)id;
   struct stat buf;
-  assert( id );
-  rc = osFstat(((unixFile*)id)->h, &buf);
+  assert( pFile );
+
+  /* For files that have been unlinked, simply return the szFile which we keep
+  ** track of internally.  There is no need to fstat() as SQLite has exclusive
+  ** access to the file and no other process can modify the file and thus change
+  ** the file size without our knowing it.  We do this because fstat() will
+  ** fail on unlinked files on some (broken) unix filesystems.
+  */
+  if( pFile->ctrlFlags & UNIXFILE_DELETE ){
+    *pSize = pFile->szFile;
+    /* The following assert() confirms that the internal filesize is correct */
+    assert( osFstat(pFile->h, &buf)!=0 || buf.st_size==pFile->szFile );
+    return SQLITE_OK;
+  }
+
+  rc = osFstat(pFile->h, &buf);
   SimulateIOError( rc=1 );
   if( rc!=0 ){
-    ((unixFile*)id)->lastErrno = errno;
+    pFile->lastErrno = errno;
     return SQLITE_IOERR_FSTAT;
   }
   *pSize = buf.st_size;
 
   /* When opening a zero-size database, the findInodeInfo() procedure
@@ -3669,10 +3692,11 @@
 static int fcntlSizeHint(unixFile *pFile, i64 nByte){
   if( pFile->szChunk>0 ){
     i64 nSize;                    /* Required file size */
     struct stat buf;              /* Used to hold return values of fstat() */
    
+    if( pFile->ctrlFlags & UNIXFILE_DELETE ) return SQLITE_OK;
     if( osFstat(pFile->h, &buf) ) return SQLITE_IOERR_FSTAT;
 
     nSize = ((nByte+pFile->szChunk-1) / pFile->szChunk) * pFile->szChunk;
     if( nSize>(i64)buf.st_size ){
 
@@ -4217,10 +4241,11 @@
   /* Allocate space for the new unixShm object. */
   p = sqlite3_malloc( sizeof(*p) );
   if( p==0 ) return SQLITE_NOMEM;
   memset(p, 0, sizeof(*p));
   assert( pDbFd->pShm==0 );
+  assert( (pDbFd->ctrlFlags & UNIXFILE_DELETE)==0 );
 
   /* Check to see if a unixShmNode object already exists. Reuse an existing
   ** one if present. Create a new one if necessary.
   */
   unixEnterMutex();
@@ -4763,10 +4788,11 @@
     ** in this case.  */
     pFd->mmapSizeMax = 0;
   }
   pFd->pMapRegion = (void *)pNew;
   pFd->mmapSize = pFd->mmapSizeActual = nNew;
+  if( nNew>pFd->szFile ) pFd->szFile = nNew;
 }
 
 /*
 ** Memory map or remap the file opened by file-descriptor pFd (if the file
 ** is already mapped, the existing mapping is replaced by the new). Or, if 
@@ -4789,16 +4815,14 @@
 
   assert( nMap>=0 || pFd->nFetchOut==0 );
   if( pFd->nFetchOut>0 ) return SQLITE_OK;
 
   if( nMap<0 ){
-    struct stat statbuf;          /* Low-level file information */
-    rc = osFstat(pFd->h, &statbuf);
+    rc = unixFileSize((sqlite3_file*)pFd, &nMap);
     if( rc!=SQLITE_OK ){
       return SQLITE_IOERR_FSTAT;
     }
-    nMap = statbuf.st_size;
   }
   if( nMap>pFd->mmapSizeMax ){
     nMap = pFd->mmapSizeMax;
   }
 
@@ -5768,10 +5792,11 @@
     p->pUnused->fd = fd;
     p->pUnused->flags = flags;
   }
 
   if( isDelete ){
+    p->szFile = 0;
 #if OS_VXWORKS
     zPath = zName;
 #else
     osUnlink(zName);
 #endif