SQLite

    pFile->ctrlFlags |= mask;
  }
}

/* Forward declaration */
static int unixGetTempname(int nBuf, char *zBuf);

#ifdef SQLITE_SERVER_EDITION

/*
** Structure passed by SQLite through the (void*) argument to various 
** fcntl operations.
*/
struct UnixServerArg {
  void *h;                        /* Handle from SHMOPEN */
  void *p;                        /* Mapping */
  int i1;                         /* Integer value 1 */
  int i2;                         /* Integer value 2 */
};
typedef struct UnixServerArg UnixServerArg;

/*
** Structure used as a server-shm handle.
*/
struct UnixServerShm {
  void *pMap;                     /* Pointer to mapping */
  int nMap;                       /* Size of mapping in bytes */
  int fd;                         /* File descriptor open on *-hma file */
};
typedef struct UnixServerShm UnixServerShm;

/*
** Implementation of SQLITE_FCNTL_FILEID
*/
static int unixFcntlServerFileid(unixFile *pFile, void *pArg){
  i64 *aId = (i64*)pArg;
  aId[0] = (i64)(pFile->pInode->fileId.dev);
  aId[1] = (i64)(pFile->pInode->fileId.ino);
  return SQLITE_OK;
}

/*
** Implementation of SQLITE_FCNTL_SERVER_MODE
*/
static int unixFcntlServerMode(unixFile *pFile, void *pArg){
  int rc = SQLITE_OK;
  int eServer = 0;
  char *zJrnl = sqlite3_mprintf("%s-journal", pFile->zPath);
  if( zJrnl==0 ){
    rc = SQLITE_NOMEM;
  }else{
    struct stat buf;        /* Used to hold return values of stat() */
    if( osStat(zJrnl, &buf) ){
      rc = SQLITE_IOERR_FSTAT;
    }else if( buf.st_mode & S_IFDIR ){
      eServer = (pFile->ctrlFlags & UNIXFILE_EXCL) ? 1 : 2;
    }
  }
  sqlite3_free(zJrnl);
  *((int*)pArg) = eServer;
  return rc;
}

/*
** Implementation of SQLITE_FCNTL_SERVER_SHMOPEN.
**
** The (void*) argument passed to this file control should actually be
** a pointer to a UnixServerArg or equivalent structure. Arguments are
** interpreted as follows:
**
**   UnixServerArg.h  - OUT: New server shm handle.
**   UnixServerArg.p  - OUT: New server shm mapping.
**   UnixServerArg.i1 - Size of requested mapping in bytes.
**   UnixServerArg.i2 - OUT: True if journal rollback + SHMOPEN2 are required.
*/
static int unixFcntlServerShmopen(unixFile *pFd, void *pArg){
  int rc = SQLITE_OK;
  UnixServerArg *pSArg = (UnixServerArg*)pArg;
  UnixServerShm *p;
  char *zHma;

  p = sqlite3_malloc(sizeof(UnixServerShm));
  if( p==0 ) return SQLITE_NOMEM;
  memset(p, 0, sizeof(UnixServerShm));
  p->fd = -1;

  zHma = sqlite3_mprintf("%s-journal/hma", pFd->zPath);
  if( zHma==0 ){
    rc = SQLITE_NOMEM;
  }else{
    p->fd = osOpen(zHma, O_RDWR|O_CREAT, 0644);
    p->nMap = pSArg->i1;

    if( p->fd<0 ){
      rc = SQLITE_CANTOPEN;
    }else{
      int res = ftruncate(p->fd, p->nMap);
      if( res!=0 ){
        rc = SQLITE_IOERR_TRUNCATE;
      }else{
        p->pMap = osMmap(0, p->nMap, PROT_READ|PROT_WRITE, MAP_SHARED, p->fd,0);
        if( p->pMap==0 ){
          rc = SQLITE_IOERR_MMAP;
        }
      }
    }
    sqlite3_free(zHma);
  }

  if( rc==SQLITE_OK ){
    int res;
    struct flock lock;
    memset(&lock, 0, sizeof(struct flock));
    lock.l_type = F_WRLCK;
    lock.l_whence = SEEK_SET;
    lock.l_start = p->nMap;
    lock.l_len = 1;

    res = osFcntl(p->fd, F_SETLK, &lock);
    if( res==0 ){
      pSArg->i2 = 1;
      memset(p->pMap, 0, p->nMap);
    }else{
      pSArg->i2 = 0;
      lock.l_type = F_RDLCK;
      res = osFcntl(p->fd, F_SETLKW, &lock);
      if( res!=0 ){
        rc = SQLITE_IOERR_LOCK;
      }
    }
  }

  if( rc!=SQLITE_OK ){
    if( p->pMap ) osMunmap(p->pMap, p->nMap);
    if( p->fd>=0 ) close(p->fd);
    sqlite3_free(p);
    pSArg->h = pSArg->p = 0;
  }else{
    pSArg->h = (void*)p;
    pSArg->p = (void*)(p->pMap);
  }

  return rc;
}

/*
** Implementation of SQLITE_FCNTL_SERVER_SHMOPEN2.
**
** The (void*) argument passed to this file control should actually be
** a pointer to a UnixServerArg or equivalent structure. Arguments are
** interpreted as follows:
**
**   UnixServerArg.h  - Server shm handle (from SHMOPEN).
**   UnixServerArg.p  - unused.
**   UnixServerArg.i1 - unused.
**   UnixServerArg.i2 - unused.
*/
static int unixFcntlServerShmopen2(unixFile *pFd, void *pArg){
  UnixServerArg *pSArg = (UnixServerArg*)pArg;
  UnixServerShm *p = (UnixServerShm*)pSArg->h;
  int res;
  struct flock lock;

  memset(&lock, 0, sizeof(struct flock));
  lock.l_type = F_RDLCK;
  lock.l_whence = SEEK_SET;
  lock.l_start = p->nMap;
  lock.l_len = 1;
  res = osFcntl(p->fd, F_SETLK, &lock);

  return res ? SQLITE_IOERR_LOCK : SQLITE_OK;
}

/*
** Implementation of SQLITE_FCNTL_SERVER_SHMCLOSE.
**
** The (void*) argument passed to this file control should actually be
** a pointer to a UnixServerArg or equivalent structure. Arguments are
** interpreted as follows:
**
**   UnixServerArg.h  - Server shm handle (from SHMOPEN).
**   UnixServerArg.p  - unused.
**   UnixServerArg.i1 - unused.
**   UnixServerArg.i2 - unused.
*/
static int unixFcntlServerShmclose(unixFile *pFd, void *pArg){
  UnixServerArg *pSArg = (UnixServerArg*)pArg;
  UnixServerShm *p = (UnixServerShm*)pSArg->h;

  if( p->pMap ) osMunmap(p->pMap, p->nMap);
  if( p->fd>=0 ) close(p->fd);
  sqlite3_free(p);

  return SQLITE_OK;
}

/*
** Implementation of SQLITE_FCNTL_SERVER_SHMLOCK.
**
** The (void*) argument passed to this file control should actually be
** a pointer to a UnixServerArg or equivalent structure. Arguments are
** interpreted as follows:
**
**   UnixServerArg.h  - Server shm handle (from SHMOPEN).
**   UnixServerArg.p  - unused.
**   UnixServerArg.i1 - slot to lock.
**   UnixServerArg.i2 - true to take the lock, false to release it.
*/
static int unixFcntlServerShmlock(unixFile *pFd, void *pArg){
  UnixServerArg *pSArg = (UnixServerArg*)pArg;
  UnixServerShm *p = (UnixServerShm*)pSArg->h;
  int res;

  struct flock lock;
  memset(&lock, 0, sizeof(struct flock));
  lock.l_type = pSArg->i2 ? F_WRLCK : F_UNLCK;
  lock.l_whence = SEEK_SET;
  lock.l_start = p->nMap + pSArg->i1 + 1;
  lock.l_len = 1;

  res = osFcntl(p->fd, F_SETLK, &lock);

  return (res==0 ? SQLITE_OK : SQLITE_BUSY);
}
#endif

/*
** Information and control of an open file handle.
*/
static int unixFileControl(sqlite3_file *id, int op, void *pArg){
  unixFile *pFile = (unixFile*)id;
  switch( op ){

#ifdef SQLITE_SERVER_EDITION
    case SQLITE_FCNTL_FILEID:
      return unixFcntlServerFileid(pFile, pArg);
    case SQLITE_FCNTL_SERVER_MODE: 
      return unixFcntlServerMode(pFile, pArg);



    case SQLITE_FCNTL_SERVER_SHMOPEN:

      return unixFcntlServerShmopen(pFile, pArg);

    case SQLITE_FCNTL_SERVER_SHMOPEN2:







      return unixFcntlServerShmopen2(pFile, pArg);

    case SQLITE_FCNTL_SERVER_SHMCLOSE:

      return unixFcntlServerShmclose(pFile, pArg);

    case SQLITE_FCNTL_SERVER_SHMLOCK:
      return unixFcntlServerShmlock(pFile, pArg);
#endif

#if defined(__linux__) && defined(SQLITE_ENABLE_BATCH_ATOMIC_WRITE)
    case SQLITE_FCNTL_BEGIN_ATOMIC_WRITE: {
      int rc = osIoctl(pFile->h, F2FS_IOC_START_ATOMIC_WRITE);
      return rc ? SQLITE_IOERR_BEGIN_ATOMIC : SQLITE_OK;
    }
    case SQLITE_FCNTL_COMMIT_ATOMIC_WRITE: {
      int rc = osIoctl(pFile->h, F2FS_IOC_COMMIT_ATOMIC_WRITE);

# define pagerWalFrames(v,w,x,y) 0
# define pagerOpenWalIfPresent(z) SQLITE_OK
# define pagerBeginReadTransaction(z) SQLITE_OK
#endif

#ifdef SQLITE_SERVER_EDITION
# define pagerIsServer(x) ((x)->pServer!=0)
# define pagerIsProcessServer(x) sqlite3ServerIsSingleProcess((x)->pServer)
#else
# define pagerIsServer(x) 0
#endif

#ifndef NDEBUG 
/*
** Usage:

      assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
    }
  }
  return rc;
}

#ifdef SQLITE_SERVER_EDITION
/*
** Free the linked list of ServerPage objects headed at Pager.pServerPage.
*/
static void pagerFreeServerPage(Pager *pPager){
  ServerPage *pPg;
  ServerPage *pNext;
  for(pPg=pPager->pServerPage; pPg; pPg=pNext){
    pNext = pPg->pNext;
    sqlite3_free(pPg);
  }

  /* This function is only called for rollback pagers in WRITER_DBMOD state. */
  assert( !pagerUseWal(pPager) );
  assert( pPager->tempFile || pPager->eState==PAGER_WRITER_DBMOD );
  assert( pPager->eLock==EXCLUSIVE_LOCK );
  assert( isOpen(pPager->fd) || pList->pDirty==0 );

#ifdef SQLITE_SERVER_EDITION
  if( pagerIsProcessServer(pPager) ){
    rc = sqlite3ServerPreCommit(pPager->pServer, pPager->pServerPage);
    pPager->pServerPage = 0;
    if( rc!=SQLITE_OK ) return rc;
  }
#endif

  /* If the file is a temp-file has not yet been opened, open it now. It

    }
  }

  return rc;
}

#ifdef SQLITE_SERVER_EDITION
static int pagerServerConnect(Pager *pPager, int eServer){
  int rc = SQLITE_OK;
  if( pPager->tempFile==0 ){
    pPager->noLock = 1;
    pPager->journalMode = PAGER_JOURNALMODE_PERSIST;
    rc = sqlite3ServerConnect(pPager, eServer, &pPager->pServer);
  }
  return rc;
}

int sqlite3PagerRollbackJournal(Pager *pPager, sqlite3_file *pJfd){
  int rc;                         /* Return Code */
  sqlite3_file *saved_jfd = pPager->jfd;

          sqlite3OsUnfetch(pPager->fd, 0, 0);
        }
      }
    }

#ifdef SQLITE_SERVER_EDITION
    if( eServer ){
      rc = pagerServerConnect(pPager, eServer);
    }
#endif

    /* If there is a WAL file in the file-system, open this database in WAL
    ** mode. Otherwise, the following function call is a no-op.
    */
    if( rc==SQLITE_OK ){

  Pager *pPager = pPg->pPager;
  int rc;
  u32 cksum;
  char *pData2;
  i64 iOff = pPager->journalOff;

#ifdef SQLITE_SERVER_EDITION
  if( pagerIsProcessServer(pPager) ){
    ServerPage *p = sqlite3ServerBuffer(pPager->pServer);
    if( p==0 ){
      int nByte = sizeof(ServerPage) + pPager->pageSize;
      p = (ServerPage*)sqlite3_malloc(nByte);
      if( !p ) return SQLITE_NOMEM_BKPT;
    }
    memset(p, 0, sizeof(ServerPage));

*/
#define HMA_SLOT_RL_BITS 16       /* bits for Read Locks */
#define HMA_SLOT_WL_BITS 5        /* bits for Write Locks */
#define HMA_SLOT_TR_BITS 8        /* bits for Transient Reader locks */

#define HMA_SLOT_RLWL_BITS (HMA_SLOT_RL_BITS + HMA_SLOT_WL_BITS)


#define HMA_SLOT_RL_MASK ((1 << HMA_SLOT_RL_BITS)-1)
#define HMA_SLOT_WL_MASK (((1 << HMA_SLOT_WL_BITS)-1) << HMA_SLOT_RL_BITS)
#define HMA_SLOT_TR_MASK (((1 << HMA_SLOT_TR_BITS)-1) << HMA_SLOT_RLWL_BITS)


/* Number of page-locking slots */
#define HMA_PAGELOCK_SLOTS (256*1024)

/* Maximum concurrent read/write transactions */
#define HMA_MAX_TRANSACTIONID 16

/* Number of buckets in hash table used for MVCC in single-process mode */
#define HMA_HASH_SIZE 512

/*
** The argument to this macro is the value of a locking slot. It returns
** -1 if no client currently holds the write lock, or the transaction-id
** of the locker otherwise.
*/
#define slotGetWriter(v) ((((int)(v)&HMA_SLOT_WL_MASK) >> HMA_SLOT_RL_BITS) - 1)

/*
** The argument to this macro is the value of a locking slot. This macro
** returns the current number of slow reader clients reading the page.
*/
#define slotGetSlowReaders(v) (((v) & HMA_SLOT_TR_MASK) >> HMA_SLOT_RLWL_BITS)

#define slotReaderMask(v) ((v) & HMA_SLOT_RL_MASK)



/* 
** Atomic CAS primitive used in multi-process mode. Equivalent to:

**
**   int serverCompareAndSwap(u32 *ptr, u32 oldval, u32 newval){
**     if( *ptr==oldval ){
**       *ptr = newval;
**       return 1;
**     }
**     return 0;
**   }
*/
#define serverCompareAndSwap(ptr,oldval,newval) \
  __sync_bool_compare_and_swap(ptr,oldval,newval)


typedef struct ServerDb ServerDb;
typedef struct ServerJournal ServerJournal;

struct ServerGlobal {
  ServerDb *pDb;                  /* Linked list of all ServerDb objects */
};
static struct ServerGlobal g_server;

struct ServerJournal {
  char *zJournal;
  sqlite3_file *jfd;
};

  u32 *aSlot;                     /* Array of page locking slots */
  i64 aFileId[2];                 /* Opaque VFS file-id */
  ServerDb *pNext;                /* Next db in this process */

  sqlite3_vfs *pVfs;
  ServerJournal aJrnl[HMA_MAX_TRANSACTIONID];
  u8 *aJrnlFdSpace;

  void *pServerShm;

  int iNextCommit;                /* Commit id for next pre-commit call */ 
  Server *pCommit;                /* List of connections currently commiting */
  Server *pReader;                /* Connections in slower-reader transaction */
  ServerPage *pPgFirst;           /* First (oldest) in list of pages */
  ServerPage *pPgLast;            /* Last (newest) in list of pages */
  ServerPage *apPg[HMA_HASH_SIZE];/* Hash table of "old" page data */

  ServerPage *pFree;              /* List of free page buffers */
};

/*
** Once instance for each client connection open on a server mode database
** in this process.
*/
struct Server {
  ServerDb *pDb;                  /* Database object */
  Pager *pPager;                  /* Associated pager object */
  int eTrans;                     /* One of the SERVER_TRANS_xxx values */ 
  int iTransId;                   /* Current transaction id (or -1) */
  int iCommitId;                  /* Current commit id (or 0) */
  int nAlloc;                     /* Allocated size of aLock[] array */
  int nLock;                      /* Number of entries in aLock[] */
  u32 *aLock;                     /* Array of held locks */
  Server *pNext;                  /* Next in pCommit or pReader list */
};

struct ServerFcntlArg {
  void *h;                        /* Handle from SHMOPEN */
  void *p;                        /* Mapping */
  int i1;                         /* Integer value 1 */
  int i2;                         /* Integer value 2 */
};
typedef struct ServerFcntlArg ServerFcntlArg;

/*
** Possible values for Server.eTrans.
*/
#define SERVER_TRANS_NONE      0
#define SERVER_TRANS_READONLY  1
#define SERVER_TRANS_READWRITE 2

static void serverLeaveMutex(void){
  sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_APP1));
}
static void serverAssertMutexHeld(void){
  assert( sqlite3_mutex_held(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_APP1)) );
}

/*
** Locate the ServerDb object shared by all connections to the db identified
** by aFileId[2], increment its ref count and set pNew->pDb to point to it. 
** In this context "locate" may mean to find an existing object or to
** allocate a new one.
*/
static int serverFindDatabase(Server *pNew, i64 *aFileId){
  ServerDb *p;
  int rc = SQLITE_OK;
  serverEnterMutex();
  for(p=g_server.pDb; p; p=p->pNext){
    if( p->aFileId[0]==aFileId[0] && p->aFileId[1]==aFileId[1] ){
      break;
    }
  }
  if( p==0 ){
    p = (ServerDb*)sqlite3MallocZero(sizeof(ServerDb));
    if( p ){




      p->mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_FAST);
#if SQLITE_THREADSAFE!=0
      if( p->mutex==0 ) rc = SQLITE_NOMEM_BKPT;
#endif


      if( rc==SQLITE_NOMEM ){

        sqlite3_free(p);
        p = 0;
      }else{
        p->nClient = 1;
        p->iNextCommit = 1;
        p->aFileId[0] = aFileId[0];
        p->aFileId[1] = aFileId[1];

  return rc;
}

/*
** Free all resources allocated by serverInitDatabase() associated with the
** object passed as the only argument.
*/
static void serverShutdownDatabase(
  ServerDb *pDb, 
  sqlite3_file *dbfd, 
  int bDelete
){
  int i;

  for(i=0; i<HMA_MAX_TRANSACTIONID; i++){
    ServerJournal *pJ = &pDb->aJrnl[i];
    if( pJ->jfd ){
      sqlite3OsClose(pJ->jfd);
      if( bDelete ) sqlite3OsDelete(pDb->pVfs, pJ->zJournal, 0);
    }
    sqlite3_free(pJ->zJournal);
  }
  memset(pDb->aJrnl, 0, sizeof(ServerJournal)*HMA_MAX_TRANSACTIONID);

  if( pDb->aJrnlFdSpace ){
    sqlite3_free(pDb->aJrnlFdSpace);
    pDb->aJrnlFdSpace = 0;
  }

  if( pDb->pServerShm ){
    ServerFcntlArg arg;
    memset(&arg, 0, sizeof(ServerFcntlArg));
    arg.h = pDb->pServerShm;
    sqlite3OsFileControl(dbfd, SQLITE_FCNTL_SERVER_SHMCLOSE, (void*)&arg);
  }else{
    sqlite3_free(pDb->aSlot);
  }
  pDb->aSlot = 0;
  pDb->bInit = 0;
}

/*
** This function is called when the very first connection to a database
** is established. It is responsible for rolling back any hot journal
** files found in the file-system.
*/
static int serverInitDatabase(Server *pNew, int eServer){
  int nByte;
  int rc = SQLITE_OK;
  ServerDb *pDb = pNew->pDb;
  sqlite3_vfs *pVfs;
  sqlite3_file *dbfd = sqlite3PagerFile(pNew->pPager);
  const char *zFilename = sqlite3PagerFilename(pNew->pPager, 0);
  int bRollback = 0;

  assert( zFilename );
  assert( eServer==1 || eServer==2 );

  pVfs = pDb->pVfs = sqlite3PagerVfs(pNew->pPager);
  nByte = ROUND8(pVfs->szOsFile) * HMA_MAX_TRANSACTIONID;
  pDb->aJrnlFdSpace = (u8*)sqlite3MallocZero(nByte);
  if( pDb->aJrnlFdSpace==0 ){
    rc = SQLITE_NOMEM_BKPT;
  }else{
    if( eServer==2 ){
      ServerFcntlArg arg;
      arg.h = 0;
      arg.p = 0;
      arg.i1 = sizeof(u32)*HMA_PAGELOCK_SLOTS;
      arg.i2 = 0;

      rc = sqlite3OsFileControl(dbfd, SQLITE_FCNTL_SERVER_SHMOPEN, (void*)&arg);
      if( rc==SQLITE_OK ){
        pDb->aSlot = (u32*)arg.p;
        pDb->pServerShm = arg.h;
        bRollback = arg.i2;
      }
    }else{
      pDb->aSlot = (u32*)sqlite3MallocZero(sizeof(u32)*HMA_PAGELOCK_SLOTS);
      if( pDb->aSlot==0 ) rc = SQLITE_NOMEM_BKPT;
      bRollback = 1;
    }
  }

  if( rc==SQLITE_OK ){
    u8 *a = pDb->aJrnlFdSpace;
    int i;
    for(i=0; rc==SQLITE_OK && i<HMA_MAX_TRANSACTIONID; i++){

      ServerJournal *pJ = &pDb->aJrnl[i];
      pJ->jfd = (sqlite3_file*)&a[ROUND8(pVfs->szOsFile)*i];
      pJ->zJournal = sqlite3_mprintf("%s-journal/%d-journal", zFilename, i);
      if( pJ->zJournal==0 ){
        rc = SQLITE_NOMEM_BKPT;
        break;
      }

      if( bRollback ){
        int bExist = 0;
        rc = sqlite3OsAccess(pVfs, pJ->zJournal, SQLITE_ACCESS_EXISTS, &bExist);
        if( rc==SQLITE_OK && bExist ){
          int flags = SQLITE_OPEN_READWRITE|SQLITE_OPEN_MAIN_JOURNAL;
          rc = sqlite3OsOpen(pVfs, pJ->zJournal, pJ->jfd, flags, &flags);
          if( rc==SQLITE_OK ){
            rc = sqlite3PagerRollbackJournal(pNew->pPager, pJ->jfd);
          }
        }
      }
    }
  }

  if( rc==SQLITE_OK && pDb->pServerShm && bRollback ){
    ServerFcntlArg arg;
    arg.h = pDb->pServerShm;
    arg.p = 0;
    arg.p = 0;
    arg.i2 = 0;
    rc = sqlite3OsFileControl(dbfd, SQLITE_FCNTL_SERVER_SHMOPEN2, (void*)&arg);
  }

  if( rc==SQLITE_OK ){
    pDb->bInit = 1;
  }else{
    serverShutdownDatabase(pNew->pDb, dbfd, eServer==1);
  }
  return rc;
}

/*
** Take (bLock==1) or release (bLock==0) a server shmlock on slot iSlot.
** Return SQLITE_OK if successful, or SQLITE_BUSY if the lock cannot be
** obtained. 
*/
static int serverFcntlLock(Server *p, int iSlot, int bLock){
  sqlite3_file *dbfd = sqlite3PagerFile(p->pPager);
  int rc;
  ServerFcntlArg arg;
  arg.h = p->pDb->pServerShm;
  arg.p = 0;
  arg.i1 = iSlot;
  arg.i2 = bLock;
  rc = sqlite3OsFileControl(dbfd, SQLITE_FCNTL_SERVER_SHMLOCK, (void*)&arg);
  return rc;
}

/*
** Close the connection.
*/
void sqlite3ServerDisconnect(Server *p, sqlite3_file *dbfd){
  ServerDb *pDb = p->pDb;

  /* In a multi-process setup, release the lock on the client slot and
  ** clear the bit in the ServerDb.transmask bitmask. */
  if( pDb->pServerShm && p->iTransId>=0 ){
    sqlite3_mutex_enter(pDb->mutex);
    pDb->transmask &= ~((u32)1 << p->iTransId);
    sqlite3_mutex_leave(pDb->mutex);
    serverFcntlLock(p, p->iTransId, 0);
  }

  serverEnterMutex();
  pDb->nClient--;
  if( pDb->nClient==0 ){
    sqlite3_file *dbfd = sqlite3PagerFile(p->pPager);
    ServerPage *pFree;
    ServerDb **pp;

    /* Delete the journal files on shutdown if an EXCLUSIVE lock is already
    ** held (single process mode) or can be obtained (multi process mode)
    ** on the database file. 
    **
    ** TODO: Need to account for disk-full errors and the like here. It
    ** is not necessarily safe to delete journal files here. */
    int bDelete = 0;
    if( pDb->pServerShm ){
      int res;
      res = sqlite3OsLock(dbfd, EXCLUSIVE_LOCK);
      if( res==SQLITE_OK ) bDelete = 1;
    }else{
      bDelete = 1;
    }
    serverShutdownDatabase(pDb, dbfd, bDelete);

    for(pp=&g_server.pDb; *pp!=pDb; pp=&((*pp)->pNext));
    *pp = pDb->pNext;
    sqlite3_mutex_free(pDb->mutex);
    while( (pFree = pDb->pFree) ){
      pDb->pFree = pFree->pNext;
      sqlite3_free(pFree);
    }
    sqlite3_free(pDb);
  }
  serverLeaveMutex();

  sqlite3_free(p->aLock);
  sqlite3_free(p);
}

/*
** Connect to the system.
*/
int sqlite3ServerConnect(
  Pager *pPager,                  /* Pager object */
  int eServer,                    /* 1 -> single process, 2 -> multi process */
  Server **ppOut                  /* OUT: Server handle */
){
  Server *pNew = 0;
  sqlite3_file *dbfd = sqlite3PagerFile(pPager);
  i64 aFileId[2];
  int rc;

  rc = sqlite3OsFileControl(dbfd, SQLITE_FCNTL_FILEID, (void*)aFileId);
  if( rc==SQLITE_OK ){
    pNew = (Server*)sqlite3MallocZero(sizeof(Server));
    if( pNew ){
      pNew->pPager = pPager;
      pNew->iTransId = -1;
      rc = serverFindDatabase(pNew, aFileId);
      if( rc!=SQLITE_OK ){
        sqlite3_free(pNew);
        pNew = 0;
      }else{
        ServerDb *pDb = pNew->pDb;
        sqlite3_mutex_enter(pNew->pDb->mutex);
        if( pDb->bInit==0 ){
          rc = serverInitDatabase(pNew, eServer);
        }

        /* If this is a multi-process connection, need to lock a 
        ** client locking-slot before continuing. */
        if( rc==SQLITE_OK && pDb->pServerShm ){
          int i;
          rc = SQLITE_BUSY;
          for(i=0; rc==SQLITE_BUSY && i<HMA_MAX_TRANSACTIONID; i++){
            if( 0==(pDb->transmask & ((u32)1 << i)) ){
              rc = serverFcntlLock(pNew, i, 1);
              if( rc==SQLITE_OK ){
                pNew->iTransId = i;
                pDb->transmask |= ((u32)1 << i);
              }
            }
          }
        }
        sqlite3_mutex_leave(pNew->pDb->mutex);
      }
    }else{
      rc = SQLITE_NOMEM_BKPT;
    }
  }

  if( rc!=SQLITE_OK && pNew ){
    sqlite3ServerDisconnect(pNew, dbfd);
    pNew = 0;
  }

  *ppOut = pNew;
  return rc;
}

/*
** Begin a transaction.
*/
int sqlite3ServerBegin(Server *p, int bReadonly){
  int rc = SQLITE_OK;

  if( p->eTrans==SERVER_TRANS_NONE ){

    ServerDb *pDb = p->pDb;
    u32 t;


    assert( p->pNext==0 );
    if( pDb->pServerShm ){
      p->eTrans = SERVER_TRANS_READWRITE;
    }else{
      assert( p->iTransId<0 );
      sqlite3_mutex_enter(pDb->mutex);

      if( bReadonly ){
        Server *pIter;
        p->iCommitId = pDb->iNextCommit;
        for(pIter=pDb->pCommit; pIter; pIter=pIter->pNext){
          if( pIter->iCommitId<p->iCommitId ){
            p->iCommitId = pIter->iCommitId;
          }
        }
        p->pNext = pDb->pReader;
        pDb->pReader = p;
        p->eTrans = SERVER_TRANS_READONLY;
      }else{
        int id;

        /* Find a transaction id to use */
        rc = SQLITE_BUSY;
        t = pDb->transmask;
        for(id=0; id<HMA_MAX_TRANSACTIONID; id++){
          if( (t & (1 << id))==0 ){
            t = t | (1 << id);
            rc = SQLITE_OK;
            break;
          }
        }
        pDb->transmask = t;
        p->eTrans = SERVER_TRANS_READWRITE;
        if( rc==SQLITE_OK ){
          p->iTransId = id;
        }
      }
      sqlite3_mutex_leave(pDb->mutex);
    }

    if( rc==SQLITE_OK && p->eTrans==SERVER_TRANS_READWRITE ){
      ServerJournal *pJrnl = &pDb->aJrnl[p->iTransId];
      sqlite3PagerServerJournal(p->pPager, pJrnl->jfd, pJrnl->zJournal);

    }
  }

  return rc;
}

static u32 *serverLockingSlot(ServerDb *pDb, u32 pgno){
  return &pDb->aSlot[pgno % HMA_PAGELOCK_SLOTS];
}

static void serverReleaseLocks(Server *p){
  ServerDb *pDb = p->pDb;
  int i;

  assert( pDb->pServerShm || sqlite3_mutex_held(pDb->mutex) );

  for(i=0; i<p->nLock; i++){
    while( 1 ){
      u32 *pSlot = serverLockingSlot(pDb, p->aLock[i]);
      u32 o = *pSlot;
      u32 n = o & ~((u32)1 << p->iTransId);
      if( slotGetWriter(n)==p->iTransId ){
        n -= ((p->iTransId + 1) << HMA_MAX_TRANSACTIONID);
      }
      if( serverCompareAndSwap(pSlot, o, n) ) break;
    }
  }

  p->nLock = 0;
}

/*
** End a transaction (and release all locks). This version runs in
** single process mode only.
*/
static void serverEndSingle(Server *p){
  Server **pp;
  ServerDb *pDb = p->pDb;
  ServerPage *pPg = 0;

  assert( p->eTrans!=SERVER_TRANS_NONE );
  assert( pDb->pServerShm==0 );

  sqlite3_mutex_enter(pDb->mutex);

  if( p->eTrans==SERVER_TRANS_READONLY ){
    /* Remove the connection from the readers list */
    for(pp=&pDb->pReader; *pp!=p; pp = &((*pp)->pNext));
    *pp = p->pNext;
  }else{
    serverReleaseLocks(p);

    /* Clear the bit in the transaction mask. */
    pDb->transmask &= ~((u32)1 << p->iTransId);

    /* If this connection is in the committers list, remove it. */
    for(pp=&pDb->pCommit; *pp; pp = &((*pp)->pNext)){
      if( *pp==p ){
        *pp = p->pNext;
        break;
      }
    }
  }

  /* See if it is possible to free any ServerPage records. If so, remove
  ** them from the linked list and hash table, but do not call sqlite3_free()
  ** on them until the mutex has been released.  */
  if( pDb->pPgFirst ){
    ServerPage *pLast = 0;
    Server *pIter;
    int iOldest = 0x7FFFFFFF;
    for(pIter=pDb->pReader; pIter; pIter=pIter->pNext){
      iOldest = MIN(iOldest, pIter->iCommitId);
    }
    for(pIter=pDb->pCommit; pIter; pIter=pIter->pNext){
      iOldest = MIN(iOldest, pIter->iCommitId);
    }

    for(pPg=pDb->pPgFirst; pPg && pPg->iCommitId<iOldest; pPg=pPg->pNext){
      if( pPg->pHashPrev ){
        pPg->pHashPrev->pHashNext = pPg->pHashNext;
      }else{
        int iHash = pPg->pgno % HMA_HASH_SIZE;
        assert( pDb->apPg[iHash]==pPg );
        pDb->apPg[iHash] = pPg->pHashNext;
      }
      if( pPg->pHashNext ){
        pPg->pHashNext->pHashPrev = pPg->pHashPrev;
      }
      pLast = pPg;
    }

    if( pLast ){
      assert( pLast->pNext==pPg );
      pLast->pNext = pDb->pFree;
      pDb->pFree = pDb->pPgFirst;
    }

    if( pPg==0 ){
      pDb->pPgFirst = pDb->pPgLast = 0;
    }else{
      pDb->pPgFirst = pPg;
    }
  }

  sqlite3_mutex_leave(pDb->mutex);

  p->pNext = 0;
  p->eTrans = SERVER_TRANS_NONE;
  p->iTransId = -1;
  p->iCommitId = 0;
}

/*
** End a transaction (and release all locks).
*/
int sqlite3ServerEnd(Server *p){

  if( p->eTrans!=SERVER_TRANS_NONE ){
    if( p->pDb->pServerShm ){










      serverReleaseLocks(p);






























    }else{









      serverEndSingle(p);




    }
  }














  return SQLITE_OK;
}

int sqlite3ServerPreCommit(Server *p, ServerPage *pPg){
  ServerDb *pDb = p->pDb;
  int rc = SQLITE_OK;
  ServerPage *pIter;

  /* This should never be called in multi-process mode */
  assert( pDb->pServerShm==0 );
  if( pPg==0 ) return SQLITE_OK;

  sqlite3_mutex_enter(pDb->mutex);

  /* Assign a commit id to this transaction */
  assert( p->iCommitId==0 );
  assert( p->eTrans==SERVER_TRANS_READWRITE );

** If parameter bBlock is non-zero, then make this a blocking lock if
** possible.
*/
int sqlite3ServerLock(Server *p, Pgno pgno, int bWrite, int bBlock){
  int rc = SQLITE_OK;

  assert( p->eTrans==SERVER_TRANS_READWRITE 
       || (p->eTrans==SERVER_TRANS_READONLY && p->pDb->pServerShm==0)
  );
  if( p->eTrans==SERVER_TRANS_READWRITE ){
    ServerDb *pDb = p->pDb;
    int iWriter;
    int bSkip = 0;
    u32 *pSlot;

    /* Grow the aLock[] array if required */
    assert( p->iTransId>=0 );
    assert( p->nLock<=p->nAlloc );
    if( p->nLock==p->nAlloc ){
      int nNew = p->nLock ? p->nLock*2 : 256;
      u32 *aNew = sqlite3_realloc(p->aLock, nNew*sizeof(u32));
      if( aNew==0 ) return SQLITE_NOMEM_BKPT;
      memset(&aNew[p->nLock], 0, sizeof(u32) * (nNew - p->nLock));
      p->nAlloc = nNew;
      p->aLock = aNew;
    }

    /* Find the locking slot for the page in question */
    pSlot = serverLockingSlot(pDb, pgno);

    if( pDb->pServerShm==0 ) sqlite3_mutex_enter(pDb->mutex);

    while( 1 ){
      u32 o = *pSlot;
      u32 n = o;

      assert( slotGetWriter(o)<0 
          || slotReaderMask(o)==0 
          || slotReaderMask(o)==(1 << slotGetWriter(o))
      );

      iWriter = slotGetWriter(o);
      if( iWriter==p->iTransId || (bWrite==0 && (o & (1<<p->iTransId))) ){
        bSkip = 1;
        break;
      }else if( iWriter>=0 ){
        rc = SQLITE_BUSY_DEADLOCK;
      }else if( bWrite ){
        if( (slotReaderMask(o) & ~(1 << p->iTransId))==0 ){
          n += ((p->iTransId + 1) << HMA_MAX_TRANSACTIONID);
        }else{
          rc = SQLITE_BUSY_DEADLOCK;
        }
      }else{
        n |= (1 << p->iTransId);
      }

      assert( slotGetWriter(n)<0 
          || slotReaderMask(n)==0 
          || slotReaderMask(n)==(1 << slotGetWriter(n))
      );
      if( rc!=SQLITE_OK || serverCompareAndSwap(pSlot, o, n) ) break;
    }

    if( pDb->pServerShm==0 ){
      sqlite3_mutex_leave(pDb->mutex);
    }

    if( bSkip==0 && rc==SQLITE_OK ){
      p->aLock[p->nLock++] = pgno;
    }
  }

  return rc;
}

void sqlite3ServerReadPage(Server *p, Pgno pgno, u8 **ppData){
  if( p->eTrans==SERVER_TRANS_READONLY ){
    ServerDb *pDb = p->pDb;
    ServerPage *pIter;
    ServerPage *pBest = 0;
    int iHash = pgno % HMA_HASH_SIZE;

    /* There are no READONLY transactions in a multi process system */
    assert( pDb->pServerShm==0 );
    sqlite3_mutex_enter(pDb->mutex);

    /* Search the hash table for the oldest version of page pgno with
    ** a commit-id greater than or equal to Server.iCommitId.  */
    for(pIter=pDb->apPg[iHash]; pIter; pIter=pIter->pHashNext){
      if( pIter->pgno==pgno 
       && pIter->iCommitId>=p->iCommitId 

  }
}

void sqlite3ServerEndReadPage(Server *p, Pgno pgno){
  if( p->eTrans==SERVER_TRANS_READONLY ){
    ServerDb *pDb = p->pDb;
    u32 *pSlot = &pDb->aSlot[pgno % HMA_PAGELOCK_SLOTS];
    assert( pDb->pServerShm==0 );
    sqlite3_mutex_enter(pDb->mutex);
    serverIncrSlowReader(pSlot, -1);
    assert( slotGetSlowReaders(*pSlot)>=0 );
    sqlite3_mutex_leave(pDb->mutex);
  }
}

ServerPage *sqlite3ServerBuffer(Server *p){
  ServerDb *pDb = p->pDb;
  ServerPage *pRet = 0;
  assert( pDb->pServerShm==0 );
  sqlite3_mutex_enter(pDb->mutex);
  if( pDb->pFree ){
    pRet = pDb->pFree;
    pDb->pFree = pRet->pNext;
    pRet->pNext = 0;
  }
  sqlite3_mutex_leave(pDb->mutex);
  return pRet;
}

/*
** Return true if the handle passed as the only argument is not NULL and
** currently has an open readonly transaction (one started with BEGIN
** READONLY). Return false if the argument is NULL, if there is no open
** transaction, or if the open transaction is read/write.
*/
int sqlite3ServerIsReadonly(Server *p){
  return (p && p->eTrans==SERVER_TRANS_READONLY);
}

/*
** Return true if the argument is non-NULL and connects to a single-process
** server system. Return false if the argument is NULL or the system supports
** multiple processes.
*/
int sqlite3ServerIsSingleProcess(Server *p){
  return (p && p->pDb->pServerShm==0);
}

#endif /* ifdef SQLITE_SERVER_EDITION */

  ServerPage *pNext;

  int iCommitId;
  ServerPage *pHashNext;
  ServerPage *pHashPrev;
};

int sqlite3ServerConnect(Pager *pPager, int eServer, Server **ppOut);
void sqlite3ServerDisconnect(Server *p, sqlite3_file *dbfd);

int sqlite3ServerBegin(Server *p, int bReadonly);
int sqlite3ServerPreCommit(Server*, ServerPage*);
int sqlite3ServerEnd(Server *p);

int sqlite3ServerReleaseWriteLocks(Server *p);

int sqlite3ServerLock(Server *p, Pgno pgno, int bWrite, int bBlock);

int sqlite3ServerHasLock(Server *p, Pgno pgno, int bWrite);

ServerPage *sqlite3ServerBuffer(Server*);

int sqlite3ServerIsSingleProcess(Server*);

/* For "BEGIN READONLY" clients. */
int sqlite3ServerIsReadonly(Server*);
void sqlite3ServerReadPage(Server*, Pgno, u8**);
void sqlite3ServerEndReadPage(Server*, Pgno);

#endif /* SQLITE_SERVER_H */

#define SQLITE_FCNTL_WIN32_GET_HANDLE       29
#define SQLITE_FCNTL_PDB                    30
#define SQLITE_FCNTL_BEGIN_ATOMIC_WRITE     31
#define SQLITE_FCNTL_COMMIT_ATOMIC_WRITE    32
#define SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE  33
#define SQLITE_FCNTL_FILEID                 34
#define SQLITE_FCNTL_SERVER_MODE            35
#define SQLITE_FCNTL_SERVER_SHMOPEN         36
#define SQLITE_FCNTL_SERVER_SHMOPEN2        37
#define SQLITE_FCNTL_SERVER_SHMLOCK         38
#define SQLITE_FCNTL_SERVER_SHMCLOSE        39

/* deprecated names */
#define SQLITE_GET_LOCKPROXYFILE      SQLITE_FCNTL_GET_LOCKPROXYFILE
#define SQLITE_SET_LOCKPROXYFILE      SQLITE_FCNTL_SET_LOCKPROXYFILE
#define SQLITE_LAST_ERRNO             SQLITE_FCNTL_LAST_ERRNO

*/
int sqlite3WalFramesize(Wal *pWal);
#endif

/* Return the sqlite3_file object for the WAL file */
sqlite3_file *sqlite3WalFile(Wal *pWal);





#endif /* ifndef SQLITE_OMIT_WAL */
#endif /* SQLITE_WAL_H */

set testdir [file dirname $argv0]
source $testdir/tester.tcl
set testprefix server2

source $testdir/server_common.tcl
return_if_no_server
db close

foreach {tn vfs} {1 unix-excl 2 unix} {
  server_set_vfs $vfs

  foreach f [glob -nocomplain test.db*] {
    forcedelete $f
  }

  #-------------------------------------------------------------------------
  # Check that the *-journal* files are deleted correctly.
  #
  server_reset_db
  do_execsql_test 1.0 {
    CREATE TABLE t1(a, b);
  } {}
  
  do_test $tn.1.1 {
    lsort [glob -nocomplain test.db-journal/*-journal]
  } {test.db-journal/0-journal}
  
  do_test $tn.1.2 {
    db close
    lsort [glob -nocomplain test.db-journal/*-journal]
  } {}
  
  server_sqlite3 db test.db
  do_execsql_test $tn.1.3 {
    CREATE TABLE t2(a, b);
  } {}
  
  server_sqlite3 db2 test.db
  do_test $tn.1.4 {
    db eval {
      BEGIN;
        INSERT INTO t1 VALUES(1, 2);
    }
    db2 eval {
      BEGIN;
        INSERT INTO t2 VALUES(3, 4);
    }
  } {}
  
  do_test $tn.1.5 {
    db2 eval COMMIT
    db eval COMMIT
    lsort [glob -nocomplain test.db-journal/*-journal]
  } {test.db-journal/0-journal test.db-journal/1-journal}
  
  do_test $tn.1.6 {
    db close
    lsort [glob -nocomplain test.db-journal/*-journal]
  } {test.db-journal/0-journal test.db-journal/1-journal}
  
  do_test $tn.1.7 {
    db2 close
    lsort [glob -nocomplain test.db-journal/*-journal]
  } {}
  
  #-------------------------------------------------------------------------
  #
  server_reset_db
  server_sqlite3 db2 test.db
  
  do_execsql_test $tn.2.0 {
    CREATE TABLE t1(a, b);
    CREATE TABLE t2(c, d);
  }
  
  # Two concurrent transactions committed.
  #
  do_test $tn.2.1 {
    db eval {
      BEGIN;
        INSERT INTO t1 VALUES(1, 2);
    }
    db2 eval {
      BEGIN;
        INSERT INTO t2 VALUES(3, 4);
    }
  } {}
  do_test $tn.2.2 {
    lsort [glob -nocomplain test.db-journal/*-journal]
  } {test.db-journal/0-journal test.db-journal/1-journal}
  do_test $tn.2.3.1 { db eval COMMIT  } {}
  do_test $tn.2.3.2 { db2 eval COMMIT } {}
  do_execsql_test 2.4 {SELECT * FROM t1, t2} {1 2 3 4}
  do_test $tn.2.5 {
    lsort [glob -nocomplain test.db-journal/*-journal]
  } {test.db-journal/0-journal test.db-journal/1-journal}
  
  do_test $tn.2.6 {
    execsql {BEGIN}
    execsql {INSERT INTO t1 VALUES(5, 6)}
  
    execsql {BEGIN} db2
    catchsql {INSERT INTO t1 VALUES(7, 8)} db2
  } {1 {database is locked}}
  do_test $tn.2.7 {
    # Transaction is automatically rolled back in this case.
    sqlite3_get_autocommit db2
  } {1}
  do_test $tn.2.8 {
    execsql COMMIT
    execsql { SELECT * FROM t1 } db2
  } {1 2 5 6}
  db2 close
  
  #-------------------------------------------------------------------------
  #
  server_reset_db
  do_execsql_test $tn.3.0 {
    CREATE TABLE t1(a, b);
  }
  
  do_test $tn.3.1 {
    lsort [glob -nocomplain test.db-journal/*-journal]
  } {test.db-journal/0-journal}
  
  do_test $tn.3.2 {
    db close
    lsort [glob -nocomplain test.db-journal/*-journal]
  } {}
}

finish_test

source $testdir/tester.tcl
source $testdir/lock_common.tcl
set testprefix server3

source $testdir/server_common.tcl
return_if_no_server

foreach {tn vfs} {1 unix-excl 2 unix} {
  server_set_vfs $vfs

  server_reset_db
  server_sqlite3 db2 test.db

  do_test 1.1 {
    db eval { CREATE TABLE t1(a, b) }
    db2 eval { CREATE TABLE t2(a, b) }
  } {}
  
  do_test 1.2 {
    db eval {
      INSERT INTO t2 VALUES(1, 2);
      BEGIN;
      INSERT INTO t1 VALUES(1, 2);
    }
  } {}
  
  do_test 1.3 { 
    list [catch { db2 eval { SELECT * FROM t1 } } msg] $msg
  } {1 {database is locked}}
  do_test 1.4 { 
    list [catch { db2 eval { SELECT * FROM t1 } } msg] $msg
  } {1 {database is locked}}
  
  do_test 1.4 { 
    db2 eval { SELECT * FROM t2 }
  } {1 2}
}


finish_test

  }
  return
} else {
  proc return_if_no_server {} {}
}

proc server_sqlite3 {cmd file} {
  sqlite3 $cmd $file -vfs $::server_vfs
}

proc server_reset_db {} {
  catch {db close}
  forcedelete test.db test.db-journal test.db-wal
  file mkdir test.db-journal
  server_sqlite3 db test.db 
}

set ::server_vfs unix-excl
proc server_set_vfs {vfs} {
  set ::server_vfs $vfs
}