Sqlite源码解读（十）

本文主要是介绍Sqlite源码解读（十），对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

2021SC@SDUSC

接着LockFile继续讲解关于锁的内容。

如果*pArg最初是负的，那么这就是一个查询。将*pArg设置为1或0，这取决于是否设置了pfile->ctrlFlags的位掩码。如果*pArg为0或1，则清除或设置pfile->ctrlFlags的掩码位。

static void winModeBit(winFile *pFile, unsigned char mask, int *pArg){

  if( *pArg<0 ){

    *pArg = (pFile->ctrlFlags & mask)!=0;

  }else if( (*pArg)==0 ){

    pFile->ctrlFlags &= ~mask;

  }else{

    pFile->ctrlFlags |= mask;

  }

}

转发对用于临时文件的VFS助手方法的引用

static int winGetTempname(sqlite3_vfs *, char **);

static int winIsDir(const void *);

static BOOL winIsLongPathPrefix(const char *);

static BOOL winIsDriveLetterAndColon(const char *);

返回指定文件的基础块设备的扇区大小(以字节为单位)。SQLite代码假定此函数不会失败。它还假设如果在同一个文件系统目录中创建了两个文件，则这两个文件的扇区大小相同。

static int winSectorSize(sqlite3_file *id){

  (void)id;

  return SQLITE_DEFAULT_SECTOR_SIZE;

}

返回设备的特征向量

static int winDeviceCharacteristics(sqlite3_file *id){

  winFile *p = (winFile*)id;

  return SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN |

         ((p->ctrlFlags & WINFILE_PSOW)?SQLITE_IOCAP_POWERSAFE_OVERWRITE:0);

}

帮助函数获得并放弃全局互斥。全局互斥被用来保护文件所使用的winLockInfo对象，所有这些都可以由多个线程共享。

static sqlite3_mutex *winBigLock = 0;

static void winShmEnterMutex(void){

  sqlite3_mutex_enter(winBigLock);

}

static void winShmLeaveMutex(void){

  sqlite3_mutex_leave(winBigLock);

}

#ifndef NDEBUG

static int winShmMutexHeld(void) {

  return sqlite3_mutex_held(winBigLock);

}

#endif

所有winShmNode对象的全局数组。在读取或写入此列表时，winShmMutexHeld()必须为true。

struct winShm {

  winShmNode *pShmNode;      /* 底层 winShmNode 对象 */

  winShm *pNext;             /* 使用相同的winShmNode的下一个winshm */

  u8 hasMutex;               /* 如果持有winShmNode互斥体，则为true */

  u16 sharedMask;            /* 共享锁的掩码 */

  u16 exclMask;              /* 独占锁的掩码 */

#if defined(SQLITE_DEBUG) || defined(SQLITE_HAVE_OS_TRACE)

  u8 id;                     /* 使用winShmNode 的连接的ID*/

#endif

};

对以ofst开始的所有n个字节应用咨询锁。

#define WINSHM_UNLCK  1

#define WINSHM_RDLCK  2

#define WINSHM_WRLCK  3

static int winShmSystemLock(

  winShmNode *pFile,  /* 将锁应用到这个打开的共享内存段*/

  int lockType,        /* WINSHM_UNLCK、WINSHM_RDLCK 或 WINSHM_WRLCK类型*/

  int ofst,            /*偏移量到要锁定或解锁的第一个字节 */

  int nByte           /* 要锁定或解锁的字节数 */

){

  int rc = 0;          /* Lock/UnlockFileEx()的结果代码 */

  /*调用方序列化对winShmNode对象的访问*/

  assert( pFile->nRef==0 || sqlite3_mutex_held(pFile->mutex) );

  OSTRACE(("SHM-LOCK file=%p, lock=%d, offset=%d, size=%d\n",

           pFile->hFile.h, lockType, ofst, nByte));

  /* 释放或获取系统级锁*/

  if( lockType==WINSHM_UNLCK ){

    rc = winUnlockFile(&pFile->hFile.h, ofst, 0, nByte, 0);

  }else{

    /* Initialize the locking parameters */

    DWORD dwFlags = LOCKFILE_FAIL_IMMEDIATELY;

    if( lockType == WINSHM_WRLCK ) dwFlags |= LOCKFILE_EXCLUSIVE_LOCK;

    rc = winLockFile(&pFile->hFile.h, dwFlags, ofst, 0, nByte, 0);

  }

  if( rc!= 0 ){

    rc = SQLITE_OK;

  }else{

    pFile->lastErrno =  osGetLastError();

    rc = SQLITE_BUSY;

  }

  OSTRACE(("SHM-LOCK file=%p, func=%s, errno=%lu, rc=%s\n",

           pFile->hFile.h, (lockType == WINSHM_UNLCK) ? "winUnlockFile" :

           "winLockFile", pFile->lastErrno, sqlite3ErrName(rc)));

  return rc;

}

清除winShmNode.nRef==0的所有条目的winShmNodeList列表。

这不是一个VFS共享内存方法；它是一个由VFS共享内存方法调用的实用函数。

static void winShmPurge(sqlite3_vfs *pVfs, int deleteFlag){

  winShmNode **pp;

  winShmNode *p;

  assert( winShmMutexHeld() );

  OSTRACE(("SHM-PURGE pid=%lu, deleteFlag=%d\n",

           osGetCurrentProcessId(), deleteFlag));

  pp = &winShmNodeList;

  while( (p = *pp)!=0 ){

    if( p->nRef==0 ){

      int i;

      if( p->mutex ){ sqlite3_mutex_free(p->mutex); }

      for(i=0; i<p->nRegion; i++){

        BOOL bRc = osUnmapViewOfFile(p->aRegion[i].pMap);

        OSTRACE(("SHM-PURGE-UNMAP pid=%lu, region=%d, rc=%s\n",

                 osGetCurrentProcessId(), i, bRc ? "ok" : "failed"));

        UNUSED_VARIABLE_VALUE(bRc);

        bRc = osCloseHandle(p->aRegion[i].hMap);

        OSTRACE(("SHM-PURGE-CLOSE pid=%lu, region=%d, rc=%s\n",

                 osGetCurrentProcessId(), i, bRc ? "ok" : "failed"));

        UNUSED_VARIABLE_VALUE(bRc);

      }

      if( p->hFile.h!=NULL && p->hFile.h!=INVALID_HANDLE_VALUE ){

        SimulateIOErrorBenign(1);

        winClose((sqlite3_file *)&p->hFile);

        SimulateIOErrorBenign(0);

      }

      if( deleteFlag ){

        SimulateIOErrorBenign(1);

        sqlite3BeginBenignMalloc();

        winDelete(pVfs, p->zFilename, 0);

        sqlite3EndBenignMalloc();

        SimulateIOErrorBenign(0);

      }

      *pp = p->pNext;

      sqlite3_free(p->aRegion);

      sqlite3_free(p);

    }else{

      pp = &p->pNext;

    }

  }

}

尚未对SHM文件pShmNode执行DMS锁。现在就试着把它拿走。如果成功，返回SQLITE_OK，否则返回SQLite错误代码。如果DMS由于这是readonly_shm=1连接而无法锁定，并且没有其他进程已经持有锁，则返回SQLITE_READONLY_CANTINIT并设置pShmNode->isUnlock=1。

static int winLockSharedMemory(winShmNode *pShmNode){

  int rc = winShmSystemLock(pShmNode, WINSHM_WRLCK, WIN_SHM_DMS, 1);

  if( rc==SQLITE_OK ){

    if( pShmNode->isReadonly ){

      pShmNode->isUnlocked = 1;

      winShmSystemLock(pShmNode, WINSHM_UNLCK, WIN_SHM_DMS, 1);

      return SQLITE_READONLY_CANTINIT;

    }else if( winTruncate((sqlite3_file*)&pShmNode->hFile, 0) ){

      winShmSystemLock(pShmNode, WINSHM_UNLCK, WIN_SHM_DMS, 1);

      return winLogError(SQLITE_IOERR_SHMOPEN, osGetLastError(),

                         "winLockSharedMemory", pShmNode->zFilename);

    }

  }

  if( rc==SQLITE_OK ){

    winShmSystemLock(pShmNode, WINSHM_UNLCK, WIN_SHM_DMS, 1);

  }

  return winShmSystemLock(pShmNode, WINSHM_RDLCK, WIN_SHM_DMS, 1);

}

打开与数据库文件pDbFd关联的共享内存区域。当打开一个新的共享内存文件时，如果当前没有打开该文件的其他实例，则该文件必须被截断为零长度或清除其标头。

static int winOpenSharedMemory(winFile *pDbFd){

  struct winShm *p;                   /* 要打开的连接*/

  winShmNode *pShmNode = 0;         /*底层mmapped文件*/

  int rc = SQLITE_OK;                 /* 结果代码*/

  winShmNode *pNew;                  /*新分配的winShmNode */

  int nName;                        /*zName的大小(以字节为单位)*/

  assert( pDbFd->pShm==0 );         /*以前没有打开 */

/*为新sqlite3_SHM对象分配空间。此外，还为新的winShmNode和文件名分配空间。*/

p = sqlite3MallocZero( sizeof(*p) );

  if( p==0 ) return SQLITE_IOERR_NOMEM_BKPT;

  nName = sqlite3Strlen30(pDbFd->zPath);

  pNew = sqlite3MallocZero( sizeof(*pShmNode) + nName + 17 );

  if( pNew==0 ){

    sqlite3_free(p);

    return SQLITE_IOERR_NOMEM_BKPT;

  }

  pNew->zFilename = (char*)&pNew[1];

  sqlite3_snprintf(nName+15, pNew->zFilename, "%s-shm", pDbFd->zPath);

  sqlite3FileSuffix3(pDbFd->zPath, pNew->zFilename);

查看是否存在可以使用的现有winShmNode。如果当前不存在匹配的winShmNode，则创建一个新的。

winShmEnterMutex();

  for(pShmNode = winShmNodeList; pShmNode; pShmNode=pShmNode->pNext){

    /*TBD需要在这里找到更好的匹配。也许使用file_id_ANY_DIR_INFO结构。*/  if( sqlite3StrICmp(pShmNode->zFilename, pNew->zFilename)==0 ) break;

  }

  if( pShmNode ){

    sqlite3_free(pNew);

  }else{

    int inFlags = SQLITE_OPEN_WAL;

int outFlags = 0;

/*使新连接成为winShmNode的子节点*/

p->pShmNode = pShmNode;

#if defined(SQLITE_DEBUG) || defined(SQLITE_HAVE_OS_TRACE)

  p->id = pShmNode->nextShmId++;

#endif

  pShmNode->nRef++;

  pDbFd->pShm = p;

  winShmLeaveMutex();

这篇关于Sqlite源码解读（十）的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！