SQLite

** using SQLITE_FCNTL_MMAP_LIMIT, whichever is smaller.
**
** SQLITE_OK is returned if no error occurs (even if the mapping is not
** recreated as a result of outstanding references) or an SQLite error
** code otherwise.
*/
static int unixMapfile(unixFile *pFd, i64 nByte){
  i64 nMap;                       /* Number of bytes of file to map */
  int rc;

  assert( nMap>=0 || pFd->nFetchOut==0 );
  if( pFd->nFetchOut>0 ) return SQLITE_OK;

  /* Set variable nMap to the number of bytes of the file to map. This is
  ** the smaller of argument nByte and the limit configured by
  ** SQLITE_FCNTL_MMAP_LIMIT. Or, if nByte is less than zero, the smaller
  ** of the file size or the SQLITE_FCNTL_MMAP_LIMIT value.  */
  nMap = nByte;
  if( nMap<0 ){
    struct stat statbuf;          /* Low-level file information */
    rc = osFstat(pFd->h, &statbuf);
    if( rc!=SQLITE_OK ){
      return SQLITE_IOERR_FSTAT;
    }
    nMap = statbuf.st_size;
  }
  if( nMap>pFd->mmapLimit ){
    nMap = pFd->mmapLimit;
  }

  if( nMap!=(pFd->aMmap[0].mmapSize + pFd->aMmap[1].mmapSize) ){


    /* If the request is for a mapping zero bytes in size, or there are 
    ** currently already two mapping regions, or there is already a mapping
    ** region that is not a multiple of the page-size in size, unmap
    ** everything.  */
    if( nMap==0 
#if !HAVE_MREMAP
     || (pFd->aMmap[0].pMapRegion && pFd->aMmap[1].pMapRegion)
     || (pFd->aMmap[0].mmapSize % pFd->szSyspage)
#endif
    ){
      unixUnmapfile(pFd);
    }
    assert( pFd->aMmap[1].pMapRegion==0 );

    if( nMap>0 ){
      unixMapping *pMap = &pFd->aMmap[0];   /* First mapping object */
      void *pNew = 0;
      int iNew = 0;
      int flags = PROT_READ;
      if( (pFd->ctrlFlags & UNIXFILE_RDONLY)==0 ) flags |= PROT_WRITE;

      /* If there are currently no mappings, create a new one */
      if( pMap->pMapRegion==0 ){
        pNew = osMmap(0, nMap, flags, MAP_SHARED, pFd->h, 0);






      }
#if HAVE_MREMAP
      /* If we have an mremap() call, resize the existing mapping. */
      else{

        pNew = osMremap(
            pMap->pMapRegion, pMap->mmapOrigsize, nMap, MREMAP_MAYMOVE
        );






      }
#else
      /* Otherwise, create a second mapping. If the existing mapping is
      ** a multiple of the page-size in size, then request that the new
      ** mapping immediately follow the old in virtual memory.  */
      else{
        i64 nNew;                 /* Bytes to map with this call */
        void *pAddr = 0;          /* Virtual address to request mapping at */

        nNew = nMap - pMap->mmapSize;

        if( pMap->mmapSize==pMap->mmapOrigsize ){
          pAddr = (void *)&((u8 *)pMap->pMapRegion)[pMap->mmapSize];
        }

        pNew = osMmap(pAddr, nNew, flags, MAP_SHARED, pFd->h, pMap->mmapSize);



        if( pAddr && pNew==pAddr ){

          pNew = pMap->pMapRegion;
        }else{
          iNew = 1;
          nMap = nNew;

        }
      }
#endif

      if( pNew==MAP_FAILED ){
        return SQLITE_IOERR_MMAP;
      }
      pFd->aMmap[iNew].pMapRegion = pNew;
      pFd->aMmap[iNew].mmapSize = nMap;
      pFd->aMmap[iNew].mmapOrigsize = nMap;
    }
  }

  return SQLITE_OK;
}

/*