SQLite4  Check-in [4cb2e9c5af]

  if( rc==SQLITE4_OK ){
    rc = btLockLockop(p, BT_LOCK_DMS1, BT_LOCK_EXCL, 1);
    if( rc==SQLITE4_OK ){
      rc = btLockLockop(p, BT_LOCK_DMS2_RW, BT_LOCK_EXCL, 0);
      if( rc==SQLITE4_OK ){
        rc = btLockLockop(p, BT_LOCK_DMS2_RO, BT_LOCK_EXCL, 0);
      }
      if( rc==SQLITE4_OK ){
        rc = pVfs->xShmMap(p->pFd, 0, 0, 0);
      }
      if( rc==SQLITE4_OK ){
        rc = xRecover(p);
      }
      btLockLockop(p, BT_LOCK_DMS2_RO, BT_LOCK_UNLOCK, 0);
      btLockLockop(p, BT_LOCK_DMS2_RW, BT_LOCK_UNLOCK, 0);
      if( rc==SQLITE4_OK || rc==SQLITE4_BUSY ){
        rc = btLockLockop(p, BT_LOCK_DMS2_RW, BT_LOCK_SHARED, 0);

    btLogChecksum(nativeCksum, a, 8, aIn, aOut);
    btLogChecksum(nativeCksum, &a[4], nByte-4, aOut, aOut);
  }else{
    btLogChecksum(nativeCksum, a, nByte, aIn, aOut);
  }
}

#define BT_ALLOC_DEBUG   0
#define BT_PAGE_DEBUG    0
#define BT_VAL_DEBUG     0
#define BT_HDR_DEBUG     0
#define BT_RECOVER_DEBUG 0

static void btDebugTopology(BtLock *pLock, char *zStr, int iSide, u32 *aLog){
#if BT_PAGE_DEBUG
  fprintf(stderr, "%d:%s: (side=%d) %d..%d  %d..%d  %d..%d\n", 
      pLock->iDebugId, zStr, iSide,
      (int)aLog[0], (int)aLog[1], (int)aLog[2], 
      (int)aLog[3], (int)aLog[4], (int)aLog[5]

  static int nCall = 0;
  fprintf(stderr, "%d:%d: %s db-header "
      "(pgsz=%d nPg=%d iRoot=%d iCookie=%d iFreePg=%d iFreeBlk=%d)\n",
      pLock->iDebugId, nCall++,
      zStr, (int)pHdr->pgsz, (int)pHdr->nPg, (int)pHdr->iRoot, 
      (int)pHdr->iCookie, (int)pHdr->iFreePg, (int)pHdr->iFreeBlk
  );
  fflush(stderr);
#endif
}

static void btDebugRecoverFrame(BtLock *pLock, u32 iFrame, u32 pgno){
#if BT_RECOVER_DEBUG
  static int nCall = 0;
  fprintf(stderr, "%d:%d: recovered page %d from frame %d\n",
      pLock->iDebugId, nCall++, (int)pgno, (int)iFrame
  );
  fflush(stderr);
#endif
}

#ifndef NDEBUG
void sqlite4BtDebugReadlock(BtLock *pLock, u32 iFirst, u32 iLast){
#if BT_PAGE_DEBUG

  BtLog *pLog,                    /* Log module handle */
  void *pCtx,                     /* Pointer to FrameRecoverCtx */
  u32 iFrame,                     /* Frame number */
  BtFrameHdr *pHdr                /* Frame header */
){
  FrameRecoverCtx *pFRC = (FrameRecoverCtx*)pCtx;

  btDebugRecoverFrame(pLog->pLock, iFrame, pHdr->pgno);

  if( btLogIsEmpty(pLog) ){
    /* This is the first frame recovered. It is therefore both the first
    ** and last frame of log region (c).  */
    pLog->snapshot.aLog[4] = iFrame;
    pLog->snapshot.aLog[5] = iFrame;
  }else{
    u32 iExpect = pLog->snapshot.aLog[5]+1;

  i64 nByte = 0;                  /* Size of log file on disk */
  int rc;                         /* Return code */
  BtWalHdr *pHdr = 0;
  int iSlot = 0;
  FrameRecoverCtx ctx = {0, 0};
  BtWalHdr hdr1;
  BtWalHdr hdr2;

static int nCall = 0;
nCall++;

  /* Read a log file header from the start of the file. */
  rc = pVfs->xSize(pLog->pFd, &nByte);
  if( rc==SQLITE4_OK && nByte>0 ){
    rc = btLogReadHeader(pLog, 0, &hdr1);
    if( rc==SQLITE4_OK ){
      rc = btLogReadHeader(pLog, hdr1.nSector, &hdr2);

  return rc;
}

int btPosixOsShmMap(bt_file *pFile, int iChunk, int sz, void **ppShm){
  BtPosixFile *p = (BtPosixFile *)pFile;










  /* If the shared-memory file has not been opened, open it now. */
  if( p->shmfd<=0 ){
    char *zShm = btPosixShmFile(p);
    if( !zShm ) return btErrorBkpt(SQLITE4_NOMEM);
    p->shmfd = open(zShm, O_RDWR|O_CREAT, 0644);
    sqlite4_free(p->pSqlEnv, zShm);
    if( p->shmfd<0 ){ 
      return btErrorBkpt(SQLITE4_IOERR);
    }
  }

  if( ppShm==0 ){
    assert( p->nShm==0 );
    if( p->nShm ) return btErrorBkpt(SQLITE4_MISUSE);
    if( ftruncate(p->shmfd, 0) ){
      return btErrorBkpt(SQLITE4_IOERR);
    }
  }else{

    *ppShm = 0;
    assert( sz==BT_SHM_CHUNK_SIZE );
    if( iChunk>=p->nShm ){
      int i;
      void **apNew;
      int nNew = iChunk+1;
      off_t nReq = nNew * BT_SHM_CHUNK_SIZE;
      struct stat sStat;

      /* If the shared-memory file is not large enough to contain the 
       ** requested chunk, cause it to grow.  */
      if( fstat(p->shmfd, &sStat) ){
        return btErrorBkpt(SQLITE4_IOERR);
      }
      if( sStat.st_size<nReq ){
        if( ftruncate(p->shmfd, nReq) ){
          return btErrorBkpt(SQLITE4_IOERR);
        }
      }

      apNew = (void**)sqlite4_realloc(p->pSqlEnv, p->apShm, sizeof(void*)*nNew);
      if( !apNew ) return btErrorBkpt(SQLITE4_NOMEM);
      for(i=p->nShm; i<nNew; i++){
        apNew[i] = 0;
      }
      p->apShm = apNew;
      p->nShm = nNew;
    }

    if( p->apShm[iChunk]==0 ){
      p->apShm[iChunk] = mmap(0, BT_SHM_CHUNK_SIZE, 
          PROT_READ|PROT_WRITE, MAP_SHARED, p->shmfd, iChunk*BT_SHM_CHUNK_SIZE
      );
      if( p->apShm[iChunk]==0 ) return btErrorBkpt(SQLITE4_IOERR);
    }

    *ppShm = p->apShm[iChunk];
  }
  return SQLITE4_OK;
}

void btPosixOsShmBarrier(bt_file *pFile){
}

int btPosixOsShmUnmap(bt_file *pFile, int bDelete){