myvfs.c File Reference

#include <sqlite3.h>
#include <assert.h>
#include <dlfcn.h>
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/types.h>
#include <time.h>
#include <unistd.h>

Go to the source code of this file.

Classes
struct	unixFileId
struct	UnixUnusedFd
struct	unixInodeInfo
struct	unixFile
struct	unix_syscall

Macros
#define	SQLITE_OPEN_WAL   0x00080000 /* VFS only */
#define	SQLITE_FCNTL_SIZE_HINT   5
#define	SQLITE_FCNTL_CHUNK_SIZE   6
#define	SQLITE_FCNTL_SYNC_OMITTED   8
#define	SQLITE_FCNTL_DB_UNCHANGED   0xca093fa0
#define	SQLITE_DEFAULT_SECTOR_SIZE   512
#define	UNUSED_PARAMETER(x)   (void)(x)
#define	UNUSED_PARAMETER2(x, y)   UNUSED_PARAMETER(x),UNUSED_PARAMETER(y)
#define	ArraySize(X)   ((int)(sizeof(X)/sizeof(X[0])))
#define	_LARGE_FILE   1
#define	_FILE_OFFSET_BITS   64
#define	_LARGEFILE_SOURCE   1
#define	SQLITE_DEFAULT_FILE_PERMISSIONS   0644
#define	MAX_PATHNAME   512
#define	SQLITE_TEMP_FILE_PREFIX   "etilqs_"
#define	UNIXFILE_EXCL   0x01 /* Connections from one process only */
#define	UNIXFILE_RDONLY   0x02 /* Connection is read only */
#define	O_LARGEFILE   0
#define	O_NOFOLLOW   0
#define	O_BINARY   0
#define	SQLITE_CANTOPEN_BKPT   sqlite3CantopenError(__LINE__)
#define	osOpen   ((int(*)(const char*,int,...))aSyscall[0].pCurrent)
#define	osClose   ((int(*)(int))aSyscall[1].pCurrent)
#define	osAccess   ((int(*)(const char*,int))aSyscall[2].pCurrent)
#define	osGetcwd   ((char*(*)(char*,size_t))aSyscall[3].pCurrent)
#define	osStat   ((int(*)(const char*,struct stat*))aSyscall[4].pCurrent)
#define	osFstat   ((int(*)(int,struct stat*))aSyscall[5].pCurrent)
#define	osFtruncate   ((int(*)(int,off_t))aSyscall[6].pCurrent)
#define	osFcntl   ((int(*)(int,int,...))aSyscall[7].pCurrent)
#define	osRead   ((ssize_t(*)(int,void*,size_t))aSyscall[8].pCurrent)
#define	osPread   ((ssize_t(*)(int,void*,size_t,off_t))aSyscall[9].pCurrent)
#define	osPread64   ((ssize_t(*)(int,void*,size_t,off_t))aSyscall[10].pCurrent)
#define	osWrite   ((ssize_t(*)(int,const void*,size_t))aSyscall[11].pCurrent)
#define	osPwrite
#define	osPwrite64
#define	osFchmod   ((int(*)(int,mode_t))aSyscall[14].pCurrent)
#define	osFallocate   ((int(*)(int,off_t,off_t))aSyscall[15].pCurrent)
#define	unixLogError(a, b, c)   unixLogErrorAtLine(a,b,c,__LINE__)
#define	UNIXVFS(VFSNAME, FINDER)

Typedefs
typedef sqlite_int64	i64
typedef struct unixShmNode	unixShmNode
typedef struct unixFile	unixFile
typedef const sqlite3_io_methods *(*	finder_type) (const char *, unixFile *)

Functions
static int	sqlite3CantopenError (int lineno)
static int	sqlite3Strlen30 (const char *z)
static const sqlite3_io_methods *	nolockIoFinderImpl (const char *z, unixFile *p)
static int	unixLogErrorAtLine (int errcode, const char *zFunc, const char *zPath, int iLine)
static int	robust_open (const char *z, int f, int m)
static void	robust_close (unixFile *pFile, int h, int lineno)
static int	robust_ftruncate (int h, sqlite3_int64 sz)
static int	fillInUnixFile (sqlite3_vfs *pVfs, int h, int dirfd, sqlite3_file *pId, const char *zFilename, int noLock, int isDelete, int isReadOnly)
static int	openDirectory (const char *zFilename, int *pFd)
static const char *	unixTempFileDir (void)
static int	unixGetTempname (int nBuf, char *zBuf)
static struct UnixUnusedFd *	findReusableFd (const char *zPath, int flags)
static int	findCreateFileMode (const char *zPath, int flags, mode_t *pMode)
static int	fcntlSizeHint (unixFile *pFile, i64 nByte)
static int	full_fsync (int fd, int fullSync, int dataOnly)
static int	seekAndRead (unixFile *id, sqlite3_int64 offset, void *pBuf, int cnt)
static int	seekAndWrite (unixFile *id, i64 offset, const void *pBuf, int cnt)
static int	nolockClose (sqlite3_file *id)
static int	unixRead (sqlite3_file *id, void *pBuf, int amt, sqlite3_int64 offset)
static int	unixWrite (sqlite3_file *id, const void *pBuf, int amt, sqlite3_int64 offset)
static int	unixTruncate (sqlite3_file *id, i64 nByte)
static int	unixSync (sqlite3_file *id, int flags)
static int	unixFileSize (sqlite3_file *id, i64 *pSize)
static int	nolockLock (sqlite3_file *NotUsed, int NotUsed2)
static int	nolockUnlock (sqlite3_file *NotUsed, int NotUsed2)
static int	nolockCheckReservedLock (sqlite3_file *NotUsed, int *pResOut)
static int	unixFileControl (sqlite3_file *id, int op, void *pArg)
static int	unixSectorSize (sqlite3_file *NotUsed)
static int	unixDeviceCharacteristics (sqlite3_file *NotUsed)
static int	unixOpen (sqlite3_vfs *pVfs, const char *zPath, sqlite3_file *pFile, int flags, int *pOutFlags)
static int	unixDelete (sqlite3_vfs *NotUsed, const char *zPath, int dirSync)
static int	unixAccess (sqlite3_vfs *NotUsed, const char *zPath, int flags, int *pResOut)
static int	unixFullPathname (sqlite3_vfs *pVfs, const char *zPath, int nOut, char *zOut)
static void *	unixDlOpen (sqlite3_vfs *NotUsed, const char *zFilename)
static void	unixDlError (sqlite3_vfs *NotUsed, int nBuf, char *zBufOut)
static void	unixDlClose (sqlite3_vfs *NotUsed, void *pHandle)
static int	unixRandomness (sqlite3_vfs *NotUsed, int nBuf, char *zBuf)
static int	unixSleep (sqlite3_vfs *NotUsed, int microseconds)
static int	unixCurrentTime (sqlite3_vfs *NotUsed, double *prNow)
static int	unixGetLastError (sqlite3_vfs *NotUsed, int NotUsed2, char *NotUsed3)
static int	unixCurrentTimeInt64 (sqlite3_vfs *NotUsed, sqlite3_int64 *piNow)
static int	unixSetSystemCall (sqlite3_vfs *pNotUsed, const char *zName, sqlite3_syscall_ptr pNewFunc)
static sqlite3_syscall_ptr	unixGetSystemCall (sqlite3_vfs *pNotUsed, const char *zName)
static const char *	unixNextSystemCall (sqlite3_vfs *p, const char *zName)
int	sqlite3_os_init (void)
static int	closeUnixFile (sqlite3_file *id)
int	myvfs_init (void)

Variables
static struct unixInodeInfo *	inodeList = 0
static void(*)(void)	unixDlSym (sqlite3_vfs *NotUsed, void *p, const char *zSym)
static struct unix_syscall	aSyscall []
static const sqlite3_io_methods	nolockIoMethods
static const sqlite3_io_methods *(*const	nolockIoFinder )(const char *, unixFile *p) = nolockIoFinderImpl

Macro Definition Documentation

#define _FILE_OFFSET_BITS   64

Definition at line 24 of file myvfs.c.

#define _LARGE_FILE   1

Definition at line 23 of file myvfs.c.

#define _LARGEFILE_SOURCE   1

Definition at line 25 of file myvfs.c.

#define ArraySize

(

X

)

((int)(sizeof(X)/sizeof(X[0])))

Definition at line 19 of file myvfs.c.

#define MAX_PATHNAME   512

Definition at line 50 of file myvfs.c.

#define O_BINARY   0

Definition at line 154 of file myvfs.c.

#define O_LARGEFILE   0

Definition at line 144 of file myvfs.c.

#define O_NOFOLLOW   0

Definition at line 151 of file myvfs.c.

#define osAccess   ((int(*)(const char*,int))aSyscall[2].pCurrent)

#define osClose   ((int(*)(int))aSyscall[1].pCurrent)

#define osFallocate   ((int(*)(int,off_t,off_t))aSyscall[15].pCurrent)

#define osFchmod   ((int(*)(int,mode_t))aSyscall[14].pCurrent)

#define osFcntl   ((int(*)(int,int,...))aSyscall[7].pCurrent)

#define osFstat   ((int(*)(int,struct stat*))aSyscall[5].pCurrent)

#define osFtruncate   ((int(*)(int,off_t))aSyscall[6].pCurrent)

#define osGetcwd   ((char*(*)(char*,size_t))aSyscall[3].pCurrent)

#define osOpen   ((int(*)(const char*,int,...))aSyscall[0].pCurrent)

#define osPread   ((ssize_t(*)(int,void*,size_t,off_t))aSyscall[9].pCurrent)

#define osPread64   ((ssize_t(*)(int,void*,size_t,off_t))aSyscall[10].pCurrent)

#define osPwrite

Value:

((ssize_t(*)(int,const void*,size_t,off_t))\
  aSyscall[12].pCurrent)

#define osPwrite64

Value:

((ssize_t(*)(int,const void*,size_t,off_t))\
  aSyscall[13].pCurrent)

#define osRead   ((ssize_t(*)(int,void*,size_t))aSyscall[8].pCurrent)

#define osStat   ((int(*)(const char*,struct stat*))aSyscall[4].pCurrent)

#define osWrite   ((ssize_t(*)(int,const void*,size_t))aSyscall[11].pCurrent)

#define SQLITE_CANTOPEN_BKPT   sqlite3CantopenError(__LINE__)

Definition at line 224 of file myvfs.c.

#define SQLITE_DEFAULT_FILE_PERMISSIONS   0644

Definition at line 44 of file myvfs.c.

#define SQLITE_DEFAULT_SECTOR_SIZE   512

Definition at line 14 of file myvfs.c.

#define SQLITE_FCNTL_CHUNK_SIZE   6

Definition at line 10 of file myvfs.c.

#define SQLITE_FCNTL_DB_UNCHANGED   0xca093fa0

Definition at line 13 of file myvfs.c.

#define SQLITE_FCNTL_SIZE_HINT   5

Definition at line 9 of file myvfs.c.

#define SQLITE_FCNTL_SYNC_OMITTED   8

Definition at line 11 of file myvfs.c.

#define SQLITE_OPEN_WAL   0x00080000 /* VFS only */

Definition at line 8 of file myvfs.c.

#define SQLITE_TEMP_FILE_PREFIX   "etilqs_"

Definition at line 52 of file myvfs.c.

#define UNIXFILE_EXCL   0x01 /* Connections from one process only */

Definition at line 137 of file myvfs.c.

#define UNIXFILE_RDONLY   0x02 /* Connection is read only */

Definition at line 138 of file myvfs.c.

#define unixLogError	(		a,
			b,
			c
	)		unixLogErrorAtLine(a,b,c,__LINE__)

Definition at line 390 of file myvfs.c.

#define UNIXVFS	(		VFSNAME,
			FINDER
	)

Value:

{                        \
    1,                    /* iVersion */                    \
    sizeof(unixFile),     /* szOsFile */                    \
    MAX_PATHNAME,         /* mxPathname */                  \
    0,                    /* pNext */                       \
    VFSNAME,              /* zName */                       \
    (void*)&FINDER,       /* pAppData */                    \
    unixOpen,             /* xOpen */                       \
    unixDelete,           /* xDelete */                     \
    unixAccess,           /* xAccess */                     \
    unixFullPathname,     /* xFullPathname */               \
    unixDlOpen,           /* xDlOpen */                     \
    unixDlError,          /* xDlError */                    \
    unixDlSym,            /* xDlSym */                      \
    unixDlClose,          /* xDlClose */                    \
    unixRandomness,       /* xRandomness */                 \
    unixSleep,            /* xSleep */                      \
    unixCurrentTime,      /* xCurrentTime */                \
    unixGetLastError,     /* xGetLastError */               \
    /* unixCurrentTimeInt64, v2, xCurrentTimeInt64 */       \
    /* unixSetSystemCall,    v3, xSetSystemCall */          \
    /* unixGetSystemCall,    v3, xGetSystemCall */          \
    /* unixNextSystemCall,   v3, xNextSystemCall */         \
  }

#define UNUSED_PARAMETER

(

x

)

(void)(x)

Definition at line 16 of file myvfs.c.

#define UNUSED_PARAMETER2	(		x,
			y
	)		UNUSED_PARAMETER(x),UNUSED_PARAMETER(y)

Definition at line 17 of file myvfs.c.

Typedef Documentation

typedef const sqlite3_io_methods*(* finder_type) (const char *, unixFile *)

Definition at line 372 of file myvfs.c.

typedef sqlite_int64 i64

Definition at line 21 of file myvfs.c.

typedef struct unixFile unixFile

Definition at line 109 of file myvfs.c.

typedef struct unixShmNode unixShmNode

Definition at line 54 of file myvfs.c.

Function Documentation

static int closeUnixFile ( sqlite3_file *  id )

static

Definition at line 474 of file myvfs.c.

{
  unixFile * pFile = (unixFile *)id;
  if (pFile->dirfd >= 0) {
    robust_close(pFile, pFile->dirfd, __LINE__);
    pFile->dirfd = -1;
  }
  if (pFile->h >= 0) {
    robust_close(pFile, pFile->h, __LINE__);
    pFile->h = -1;
  }
  sqlite3_free(pFile->pUnused);
  memset(pFile, 0, sizeof(unixFile));
  return SQLITE_OK;
}

static int fcntlSizeHint ( unixFile *  pFile, i64  nByte  )

static

Definition at line 776 of file myvfs.c.

{
  if (pFile->szChunk) {
    i64 nSize;                    /* Required file size */
    struct stat buf;              /* Used to hold return values of fstat() */
    if (osFstat(pFile->h, &buf)) {
      return SQLITE_IOERR_FSTAT;
    }
    nSize = ((nByte + pFile->szChunk - 1) / pFile->szChunk) * pFile->szChunk;
    if (nSize > (i64)buf.st_size) {
      /* The code below is handling the return value of osFallocate()
      ** correctly. posix_fallocate() is defined to "returns zero on success,
      ** or an error number on  failure". See the manpage for details. */
      int err;
      do {
        err = osFallocate(pFile->h, buf.st_size, nSize - buf.st_size);
      }
      while (err == EINTR);
      if (err) {
        return SQLITE_IOERR_WRITE;
      }
    }
  }
  return SQLITE_OK;
}

static int fillInUnixFile ( sqlite3_vfs *  pVfs, int  h, int  dirfd, sqlite3_file *  pId, const char *  zFilename, int  noLock, int  isDelete, int  isReadOnly  )

static

Definition at line 493 of file myvfs.c.

{
  const sqlite3_io_methods * pLockingStyle;
  unixFile * pNew = (unixFile *)pId;
  int rc = SQLITE_OK;
  assert(pNew->pInode == NULL);
  /* Parameter isDelete is only used on vxworks. Express this explicitly
  ** here to prevent compiler warnings about unused parameters.
  */
  UNUSED_PARAMETER(isDelete);
  /* Usually the path zFilename should not be a relative pathname. The
  ** exception is when opening the proxy "conch" file in builds that
  ** include the special Apple locking styles.
  */
  assert(zFilename == 0 || zFilename[0] == '/');
  pNew->h = h;
  pNew->dirfd = dirfd;
  pNew->zPath = zFilename;
  if (strcmp(pVfs->zName, "unix-excl") == 0) {
    pNew->ctrlFlags = UNIXFILE_EXCL;
  }
  else {
    pNew->ctrlFlags = 0;
  }
  if (isReadOnly) {
    pNew->ctrlFlags |= UNIXFILE_RDONLY;
  }
  pLockingStyle = &nolockIoMethods;
  pNew->lastErrno = 0;
  if (rc != SQLITE_OK) {
    if (dirfd >= 0) {
      robust_close(pNew, dirfd, __LINE__);
    }
    if (h >= 0) {
      robust_close(pNew, h, __LINE__);
    }
  }
  else {
    pNew->pMethod = pLockingStyle;
  }
  return rc;
}

static int findCreateFileMode ( const char *  zPath, int  flags, mode_t *  pMode  )

static

Definition at line 722 of file myvfs.c.

{
  int rc = SQLITE_OK;             /* Return Code */
  if (flags & (SQLITE_OPEN_WAL | SQLITE_OPEN_MAIN_JOURNAL)) {
    char zDb[MAX_PATHNAME + 1];   /* Database file path */
    int nDb;                      /* Number of valid bytes in zDb */
    struct stat sStat;            /* Output of stat() on database file */
    /* zPath is a path to a WAL or journal file. The following block derives
    ** the path to the associated database file from zPath. This block handles
    ** the following naming conventions:
    **
    **   "<path to db>-journal"
    **   "<path to db>-wal"
    **   "<path to db>-journal-NNNN"
    **   "<path to db>-wal-NNNN"
    **
    ** where NNNN is a 4 digit decimal number. The NNNN naming schemes are
    ** used by the test_multiplex.c module.
    */
    nDb = sqlite3Strlen30(zPath) - 1;
    while (nDb > 0 && zPath[nDb] != 'l') {
      nDb--;
    }
    nDb -= ((flags & SQLITE_OPEN_WAL) ? 3 : 7);
    memcpy(zDb, zPath, nDb);
    zDb[nDb] = '\0';
    if (0 == stat(zDb, &sStat)) {
      *pMode = sStat.st_mode & 0777;
    }
    else {
      rc = SQLITE_IOERR_FSTAT;
    }
  }
  else if (flags & SQLITE_OPEN_DELETEONCLOSE) {
    *pMode = 0600;
  }
  else {
    *pMode = SQLITE_DEFAULT_FILE_PERMISSIONS;
  }
  return rc;
}

static struct UnixUnusedFd * findReusableFd ( const char *  zPath, int  flags  )

static

Definition at line 667 of file myvfs.c.

                                                                           {
  struct UnixUnusedFd * pUnused = 0;
  /* Do not search for an unused file descriptor on vxworks. Not because
  ** vxworks would not benefit from the change (it might, we're not sure),
  ** but because no way to test it is currently available. It is better
  ** not to risk breaking vxworks support for the sake of such an obscure
  ** feature.  */
  struct stat sStat;                   /* Results of stat() call */
  /* A stat() call may fail for various reasons. If this happens, it is
  ** almost certain that an open() call on the same path will also fail.
  ** For this reason, if an error occurs in the stat() call here, it is
  ** ignored and -1 is returned. The caller will try to open a new file
  ** descriptor on the same path, fail, and return an error to SQLite.
  **
  ** Even if a subsequent open() call does succeed, the consequences of
  ** not searching for a resusable file descriptor are not dire.  */
  if (0 == stat(zPath, &sStat)) {
    struct unixInodeInfo * pInode;
    pInode = inodeList;
    while (pInode && (pInode->fileId.dev != sStat.st_dev
                      || pInode->fileId.ino != sStat.st_ino)) {
      pInode = pInode->pNext;
    }
    if (pInode) {
      struct UnixUnusedFd ** pp;
      for (pp = &pInode->pUnused; *pp && (*pp)->flags != flags; pp = &((*pp)->pNext)) {
        ;
      }
      pUnused = *pp;
      if (pUnused) {
        *pp = pUnused->pNext;
      }
    }
  }
  return pUnused;
}

static int full_fsync ( int  fd, int  fullSync, int  dataOnly  )

static

Definition at line 826 of file myvfs.c.

{
  int rc;
  UNUSED_PARAMETER(fullSync);
  UNUSED_PARAMETER(dataOnly);
#if __APPLE__ && __MACH__
  rc = fcntl(fd, F_FULLFSYNC);
#else
  rc = fdatasync(fd);
#endif
  return rc;
}

int myvfs_init

(

void

)

Definition at line 1748 of file myvfs.c.

{
  /*
  ** The following macro defines an initializer for an sqlite3_vfs object.
  ** The name of the VFS is NAME.  The pAppData is a pointer to a pointer
  ** to the "finder" function.  (pAppData is a pointer to a pointer because
  ** silly C90 rules prohibit a void* from being cast to a function pointer
  ** and so we have to go through the intermediate pointer to avoid problems
  ** when compiling with -pedantic-errors on GCC.)
  **
  ** The FINDER parameter to this macro is the name of the pointer to the
  ** finder-function.  The finder-function returns a pointer to the
  ** sqlite_io_methods object that implements the desired locking
  ** behaviors.  See the division above that contains the IOMETHODS
  ** macro for addition information on finder-functions.
  **
  ** Most finders simply return a pointer to a fixed sqlite3_io_methods
  ** object.  But the "autolockIoFinder" available on MacOSX does a little
  ** more than that; it looks at the filesystem type that hosts the
  ** database file and tries to choose an locking method appropriate for
  ** that filesystem time.
  */
#define UNIXVFS(VFSNAME, FINDER) {                        \
    1,                    /* iVersion */                    \
    sizeof(unixFile),     /* szOsFile */                    \
    MAX_PATHNAME,         /* mxPathname */                  \
    0,                    /* pNext */                       \
    VFSNAME,              /* zName */                       \
    (void*)&FINDER,       /* pAppData */                    \
    unixOpen,             /* xOpen */                       \
    unixDelete,           /* xDelete */                     \
    unixAccess,           /* xAccess */                     \
    unixFullPathname,     /* xFullPathname */               \
    unixDlOpen,           /* xDlOpen */                     \
    unixDlError,          /* xDlError */                    \
    unixDlSym,            /* xDlSym */                      \
    unixDlClose,          /* xDlClose */                    \
    unixRandomness,       /* xRandomness */                 \
    unixSleep,            /* xSleep */                      \
    unixCurrentTime,      /* xCurrentTime */                \
    unixGetLastError,     /* xGetLastError */               \
    /* unixCurrentTimeInt64, v2, xCurrentTimeInt64 */       \
    /* unixSetSystemCall,    v3, xSetSystemCall */          \
    /* unixGetSystemCall,    v3, xGetSystemCall */          \
    /* unixNextSystemCall,   v3, xNextSystemCall */         \
  }
  /*
  ** All default VFSes for unix are contained in the following array.
  **
  ** Note that the sqlite3_vfs.pNext field of the VFS object is modified
  ** by the SQLite core when the VFS is registered.  So the following
  ** array cannot be const.
  */
  static sqlite3_vfs aVfs[] = {
    UNIXVFS("myvfs",     nolockIoFinder),
  };
  unsigned int i;          /* Loop counter */
  /* Double-check that the aSyscall[] array has been constructed
  ** correctly.  See ticket [bb3a86e890c8e96ab] */
  assert(ArraySize(aSyscall) == 16);
  /* Register all VFSes defined in the aVfs[] array */
  for (i = 0; i < (sizeof(aVfs) / sizeof(sqlite3_vfs)); i++) {
    sqlite3_vfs_register(&aVfs[i], i == 0);
  }
  return SQLITE_OK;
}

static int nolockCheckReservedLock ( sqlite3_file *  NotUsed, int *  pResOut  )

static

Definition at line 1137 of file myvfs.c.

{
  UNUSED_PARAMETER(NotUsed);
  *pResOut = 0;
  return SQLITE_OK;
}

static int nolockClose ( sqlite3_file *  id )

static

Definition at line 910 of file myvfs.c.

{
  fprintf(stderr, "trace: begin nolockClose ...\n");
  return closeUnixFile(id);
}

static const sqlite3_io_methods * nolockIoFinderImpl ( const char *  z, unixFile *  p  )

static

Definition at line 362 of file myvfs.c.

{
  UNUSED_PARAMETER(z);
  UNUSED_PARAMETER(p);
  return &nolockIoMethods;
}

static int nolockLock ( sqlite3_file *  NotUsed, int  NotUsed2  )

static

Definition at line 1125 of file myvfs.c.

{
  UNUSED_PARAMETER2(NotUsed, NotUsed2);
  return SQLITE_OK;
}

static int nolockUnlock ( sqlite3_file *  NotUsed, int  NotUsed2  )

static

Definition at line 1131 of file myvfs.c.

{
  UNUSED_PARAMETER2(NotUsed, NotUsed2);
  return SQLITE_OK;
}

static int openDirectory ( const char *  zFilename, int *  pFd  )

static

Definition at line 555 of file myvfs.c.

{
  int ii;
  int fd = -1;
  char zDirname[MAX_PATHNAME + 1];
  sqlite3_snprintf(MAX_PATHNAME, zDirname, "%s", zFilename);
  for (ii = (int)strlen(zDirname); ii > 1 && zDirname[ii] != '/'; ii--) {
    ;
  }
  if (ii > 0) {
    zDirname[ii] = '\0';
    fd = robust_open(zDirname, O_RDONLY | O_BINARY, 0);
  }
  *pFd = fd;
  return (fd >= 0 ? SQLITE_OK : unixLogError(SQLITE_CANTOPEN_BKPT, "open", zDirname));
}

static void robust_close ( unixFile *  pFile, int  h, int  lineno  )

static

Definition at line 444 of file myvfs.c.

{
  if (osClose(h)) {
    unixLogErrorAtLine(SQLITE_IOERR_CLOSE, "close", pFile ? pFile->zPath : 0, lineno);
  }
}

static int robust_ftruncate ( int  h, sqlite3_int64  sz  )

static

Definition at line 454 of file myvfs.c.

{
  int rc;
  do {
    rc = osFtruncate(h, sz);
  }
  while (rc < 0 && errno == EINTR);
  return rc;
}

static int robust_open ( const char *  z, int  f, int  m  )

static

Definition at line 421 of file myvfs.c.

{
  int rc;
  do {
    rc = osOpen(z, f, m);
  }
  while (rc < 0 && errno == EINTR);
  return rc;
}

static int seekAndRead ( unixFile *  id, sqlite3_int64  offset, void *  pBuf, int  cnt  )

static

Definition at line 852 of file myvfs.c.

{
  int got;
  i64 newOffset;
  newOffset = lseek(id->h, offset, SEEK_SET);
  if (newOffset != offset) {
    if (newOffset == -1) {
      ((unixFile *)id)->lastErrno = errno;
    }
    else {
      ((unixFile *)id)->lastErrno = 0;
    }
    return -1;
  }
  do {
    got = osRead(id->h, pBuf, cnt);
  }
  while (got < 0 && errno == EINTR);
  if (got < 0) {
    ((unixFile *)id)->lastErrno = errno;
  }
  return got;
}

static int seekAndWrite ( unixFile *  id, i64  offset, const void *  pBuf, int  cnt  )

static

Definition at line 883 of file myvfs.c.

{
  int got;
  i64 newOffset;
  newOffset = lseek(id->h, offset, SEEK_SET);
  if (newOffset != offset) {
    if (newOffset == -1) {
      ((unixFile *)id)->lastErrno = errno;
    }
    else {
      ((unixFile *)id)->lastErrno = 0;
    }
    return -1;
  }
  do {
    got = osWrite(id->h, pBuf, cnt);
  }
  while (got < 0 && errno == EINTR);
  if (got < 0) {
    ((unixFile *)id)->lastErrno = errno;
  }
  return got;
}

int sqlite3_os_init

(

void

)

static int sqlite3CantopenError ( int  lineno )

static

Definition at line 212 of file myvfs.c.

{
#if 0
  sqlite3_log(SQLITE_CANTOPEN,
              "cannot open file at line %d of [%.10s]",
              lineno, 20 + sqlite3_sourceid());
#endif /* 0 */
  fprintf(stderr,
          "myvfs.c: cannot open file at line %d of [%.10s]",
          lineno, 20 + sqlite3_sourceid());
  return SQLITE_CANTOPEN;
}

static int sqlite3Strlen30 ( const char *  z )

static

Definition at line 234 of file myvfs.c.

{
  const char * z2 = z;
  if (z == 0) {
    return 0;
  }
  while (*z2) {
    z2++;
  }
  return 0x3fffffff & (int)(z2 - z);
}

static int unixAccess ( sqlite3_vfs *  NotUsed, const char *  zPath, int  flags, int *  pResOut  )

static

Definition at line 1424 of file myvfs.c.

{
  int amode = 0;
  UNUSED_PARAMETER(NotUsed);
  switch (flags) {
    case SQLITE_ACCESS_EXISTS:
      amode = F_OK;
      break;
    case SQLITE_ACCESS_READWRITE:
      amode = W_OK | R_OK;
      break;
    case SQLITE_ACCESS_READ:
      amode = R_OK;
      break;
    default:
      assert(!"Invalid flags argument");
  }
  *pResOut = (osAccess(zPath, amode) == 0);
  if (flags == SQLITE_ACCESS_EXISTS && *pResOut) {
    struct stat buf;
    if (0 == stat(zPath, &buf) && buf.st_size == 0) {
      *pResOut = 0;
    }
  }
  return SQLITE_OK;
}

static int unixCurrentTime ( sqlite3_vfs *  NotUsed, double *  prNow  )

static

Definition at line 1616 of file myvfs.c.

{
  sqlite3_int64 i;
  UNUSED_PARAMETER(NotUsed);
  unixCurrentTimeInt64(0, &i);
  *prNow = i / 86400000.0;
  return 0;
}

static int unixCurrentTimeInt64 ( sqlite3_vfs *  NotUsed, sqlite3_int64 *  piNow  )

static

Definition at line 1649 of file myvfs.c.

{
  static const sqlite3_int64 unixEpoch = 24405875 * (sqlite3_int64)8640000;
  struct timeval sNow;
  gettimeofday(&sNow, 0);
  *piNow = unixEpoch + 1000 * (sqlite3_int64)sNow.tv_sec + sNow.tv_usec / 1000;
  UNUSED_PARAMETER(NotUsed);
  return 0;
}

static int unixDelete ( sqlite3_vfs *  NotUsed, const char *  zPath, int  dirSync  )

static

Definition at line 1390 of file myvfs.c.

{
  int rc = SQLITE_OK;
  UNUSED_PARAMETER(NotUsed);
  if (unlink(zPath) == (-1) && errno != ENOENT) {
    return unixLogError(SQLITE_IOERR_DELETE, "unlink", zPath);
  }
  if (dirSync) {
    int fd;
    rc = openDirectory(zPath, &fd);
    if (rc == SQLITE_OK) {
      if (fsync(fd)) {
        rc = unixLogError(SQLITE_IOERR_DIR_FSYNC, "fsync", zPath);
      }
      robust_close(0, fd, __LINE__);
    }
  }
  return rc;
}

static int unixDeviceCharacteristics ( sqlite3_file *  NotUsed )

static

Definition at line 1200 of file myvfs.c.

{
  UNUSED_PARAMETER(NotUsed);
  return 0;
}

static void unixDlClose ( sqlite3_vfs *  NotUsed, void *  pHandle  )

static

Definition at line 1546 of file myvfs.c.

{
  UNUSED_PARAMETER(NotUsed);
  dlclose(pHandle);
}

static void unixDlError ( sqlite3_vfs *  NotUsed, int  nBuf, char *  zBufOut  )

static

Definition at line 1511 of file myvfs.c.

{
  const char * zErr;
  UNUSED_PARAMETER(NotUsed);
  zErr = dlerror();
  if (zErr) {
    sqlite3_snprintf(nBuf, zBufOut, "%s", zErr);
  }
}

static void * unixDlOpen ( sqlite3_vfs *  NotUsed, const char *  zFilename  )

static

Definition at line 1498 of file myvfs.c.

{
  UNUSED_PARAMETER(NotUsed);
  return dlopen(zFilename, RTLD_NOW | RTLD_GLOBAL);
}

static int unixFileControl ( sqlite3_file *  id, int  op, void *  pArg  )

static

Definition at line 1147 of file myvfs.c.

{
  switch (op) {
    case SQLITE_FCNTL_LOCKSTATE: {
      *(int *)pArg = ((unixFile *)id)->eFileLock;
      return SQLITE_OK;
    }
    case SQLITE_LAST_ERRNO: {
      *(int *)pArg = ((unixFile *)id)->lastErrno;
      return SQLITE_OK;
    }
    case SQLITE_FCNTL_CHUNK_SIZE: {
      ((unixFile *)id)->szChunk = *(int *)pArg;
      return SQLITE_OK;
    }
    case SQLITE_FCNTL_SIZE_HINT: {
      return fcntlSizeHint((unixFile *)id, *(i64 *)pArg);
    }
    /* The pager calls this method to signal that it has done
    ** a rollback and that the database is therefore unchanged and
    ** it hence it is OK for the transaction change counter to be
    ** unchanged.
    */
    case SQLITE_FCNTL_DB_UNCHANGED: {
      ((unixFile *)id)->dbUpdate = 0;
      return SQLITE_OK;
    }
    case SQLITE_FCNTL_SYNC_OMITTED: {
      return SQLITE_OK;  /* A no-op */
    }
  }
  return SQLITE_NOTFOUND;
}

static int unixFileSize ( sqlite3_file *  id, i64 *  pSize  )

static

Definition at line 1102 of file myvfs.c.

{
  int rc;
  struct stat buf;
  assert(id);
  rc = osFstat(((unixFile *)id)->h, &buf);
  if (rc != 0) {
    ((unixFile *)id)->lastErrno = errno;
    return SQLITE_IOERR_FSTAT;
  }
  *pSize = buf.st_size;
  /* When opening a zero-size database, the findInodeInfo() procedure
  ** writes a single byte into that file in order to work around a bug
  ** in the OS-X msdos filesystem.  In order to avoid problems with upper
  ** layers, we need to report this file size as zero even though it is
  ** really 1.   Ticket #3260.
  */
  if (*pSize == 1) {
    *pSize = 0;
  }
  return SQLITE_OK;
}

static int unixFullPathname ( sqlite3_vfs *  pVfs, const char *  zPath, int  nOut, char *  zOut  )

static

Definition at line 1465 of file myvfs.c.

{
  /* It's odd to simulate an io-error here, but really this is just
  ** using the io-error infrastructure to test that SQLite handles this
  ** function failing. This function could fail if, for example, the
  ** current working directory has been unlinked.
  */
  assert(pVfs->mxPathname == MAX_PATHNAME);
  UNUSED_PARAMETER(pVfs);
  zOut[nOut - 1] = '\0';
  if (zPath[0] == '/') {
    sqlite3_snprintf(nOut, zOut, "%s", zPath);
  }
  else {
    int nCwd;
    if (osGetcwd(zOut, nOut - 1) == 0) {
      return unixLogError(SQLITE_CANTOPEN_BKPT, "getcwd", zPath);
    }
    nCwd = (int)strlen(zOut);
    sqlite3_snprintf(nOut - nCwd, &zOut[nCwd], "/%s", zPath);
  }
  return SQLITE_OK;
}

static int unixGetLastError ( sqlite3_vfs *  NotUsed, int  NotUsed2, char *  NotUsed3  )

static

Definition at line 1632 of file myvfs.c.

{
  UNUSED_PARAMETER(NotUsed);
  UNUSED_PARAMETER(NotUsed2);
  UNUSED_PARAMETER(NotUsed3);
  return 0;
}

static sqlite3_syscall_ptr unixGetSystemCall ( sqlite3_vfs *  pNotUsed, const char *  zName  )

static

Definition at line 1711 of file myvfs.c.

{
  unsigned int i;
  UNUSED_PARAMETER(pNotUsed);
  for (i = 0; i < sizeof(aSyscall) / sizeof(aSyscall[0]); i++) {
    if (strcmp(zName, aSyscall[i].zName) == 0) {
      return aSyscall[i].pCurrent;
    }
  }
  return 0;
}

static int unixGetTempname ( int  nBuf, char *  zBuf  )

static

Definition at line 616 of file myvfs.c.

{
  static const unsigned char zChars[] =
    "abcdefghijklmnopqrstuvwxyz"
    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    "0123456789";
  unsigned int i, j;
  const char * zDir;
  /* It's odd to simulate an io-error here, but really this is just
  ** using the io-error infrastructure to test that SQLite handles this
  ** function failing.
  */
  zDir = unixTempFileDir();
  if (zDir == 0) {
    zDir = ".";
  }
  /* Check that the output buffer is large enough for the temporary file
  ** name. If it is not, return SQLITE_ERROR.
  */
  if ((strlen(zDir) + strlen(SQLITE_TEMP_FILE_PREFIX) + 17) >= (size_t)nBuf) {
    return SQLITE_ERROR;
  }
  do {
    sqlite3_snprintf(nBuf - 17, zBuf, "%s/"SQLITE_TEMP_FILE_PREFIX, zDir);
    j = (int)strlen(zBuf);
    sqlite3_randomness(15, &zBuf[j]);
    for (i = 0; i < 15; i++, j++) {
      zBuf[j] = (char)zChars[((unsigned char)zBuf[j]) % (sizeof(zChars) - 1) ];
    }
    zBuf[j] = 0;
  }
  while (osAccess(zBuf, 0) == 0);
  return SQLITE_OK;
}

static int unixLogErrorAtLine ( int  errcode, const char *  zFunc, const char *  zPath, int  iLine  )

static

Definition at line 391 of file myvfs.c.

{
  char * zErr; /* Message from strerror() or equivalent */
  int iErrno = errno; /* Saved syscall error number */
  zErr = strerror(iErrno);
  assert(errcode != SQLITE_OK);
  if (zPath == 0) {
    zPath = "";
  }
#if 0
  sqlite3_log(errcode,
              "os_unix.c:%d: (%d) %s(%s) - %s",
              iLine, iErrno, zFunc, zPath, zErr
             );
#endif /* 0 */
  fprintf(stderr,
          "myvfs.c:%d: (%d) %s(%s) - %s",
          iLine, iErrno, zFunc, zPath, zErr
         );
  return errcode;
}

static const char * unixNextSystemCall ( sqlite3_vfs *  p, const char *  zName  )

static

Definition at line 1729 of file myvfs.c.

{
  int i = -1;
  UNUSED_PARAMETER(p);
  if (zName) {
    for (i = 0; i < ArraySize(aSyscall) - 1; i++) {
      if (strcmp(zName, aSyscall[i].zName) == 0) {
        break;
      }
    }
  }
  for (i++; i < ArraySize(aSyscall); i++) {
    if (aSyscall[i].pCurrent != 0) {
      return aSyscall[i].zName;
    }
  }
  return 0;
}

static int unixOpen ( sqlite3_vfs *  pVfs, const char *  zPath, sqlite3_file *  pFile, int  flags, int *  pOutFlags  )

static

Definition at line 1231 of file myvfs.c.

{
  unixFile * p = (unixFile *)pFile;
  int fd = -1;                   /* File descriptor returned by open() */
  int dirfd = -1;                /* Directory file descriptor */
  int openFlags = 0;             /* Flags to pass to open() */
  int eType = flags & 0xFFFFFF00; /* Type of file to open */
  int noLock;                    /* True to omit locking primitives */
  int rc = SQLITE_OK;            /* Function Return Code */
  int isExclusive  = (flags & SQLITE_OPEN_EXCLUSIVE);
  int isDelete     = (flags & SQLITE_OPEN_DELETEONCLOSE);
  int isCreate     = (flags & SQLITE_OPEN_CREATE);
  int isReadonly   = (flags & SQLITE_OPEN_READONLY);
  int isReadWrite  = (flags & SQLITE_OPEN_READWRITE);
  /* If creating a master or main-file journal, this function will open
  ** a file-descriptor on the directory too. The first time unixSync()
  ** is called the directory file descriptor will be fsync()ed and close()d.
  */
  int isOpenDirectory = (isCreate && (
                           eType == SQLITE_OPEN_MASTER_JOURNAL
                           || eType == SQLITE_OPEN_MAIN_JOURNAL
                           || eType == SQLITE_OPEN_WAL
                         ));
  /* If argument zPath is a NULL pointer, this function is required to open
  ** a temporary file. Use this buffer to store the file name in.
  */
  char zTmpname[MAX_PATHNAME + 1];
  const char * zName = zPath;
  fprintf(stderr, "trace: begin unixOpen ...\n");
  /* Check the following statements are true:
  **
  **   (a) Exactly one of the READWRITE and READONLY flags must be set, and
  **   (b) if CREATE is set, then READWRITE must also be set, and
  **   (c) if EXCLUSIVE is set, then CREATE must also be set.
  **   (d) if DELETEONCLOSE is set, then CREATE must also be set.
  */
  assert((isReadonly == 0 || isReadWrite == 0) && (isReadWrite || isReadonly));
  assert(isCreate == 0 || isReadWrite);
  assert(isExclusive == 0 || isCreate);
  assert(isDelete == 0 || isCreate);
  /* The main DB, main journal, WAL file and master journal are never
  ** automatically deleted. Nor are they ever temporary files.  */
  assert((!isDelete && zName) || eType != SQLITE_OPEN_MAIN_DB);
  assert((!isDelete && zName) || eType != SQLITE_OPEN_MAIN_JOURNAL);
  assert((!isDelete && zName) || eType != SQLITE_OPEN_MASTER_JOURNAL);
  assert((!isDelete && zName) || eType != SQLITE_OPEN_WAL);
  /* Assert that the upper layer has set one of the "file-type" flags. */
  assert(eType == SQLITE_OPEN_MAIN_DB      || eType == SQLITE_OPEN_TEMP_DB
         || eType == SQLITE_OPEN_MAIN_JOURNAL || eType == SQLITE_OPEN_TEMP_JOURNAL
         || eType == SQLITE_OPEN_SUBJOURNAL   || eType == SQLITE_OPEN_MASTER_JOURNAL
         || eType == SQLITE_OPEN_TRANSIENT_DB || eType == SQLITE_OPEN_WAL
        );
  memset(p, 0, sizeof(unixFile));
  if (eType == SQLITE_OPEN_MAIN_DB) {
    struct UnixUnusedFd * pUnused;
    pUnused = findReusableFd(zName, flags);
    if (pUnused) {
      fd = pUnused->fd;
    }
    else {
      pUnused = sqlite3_malloc(sizeof(*pUnused));
      if (!pUnused) {
        return SQLITE_NOMEM;
      }
    }
    p->pUnused = pUnused;
  }
  else if (!zName) {
    /* If zName is NULL, the upper layer is requesting a temp file. */
    assert(isDelete && !isOpenDirectory);
    rc = unixGetTempname(MAX_PATHNAME + 1, zTmpname);
    if (rc != SQLITE_OK) {
      return rc;
    }
    zName = zTmpname;
  }
  /* Determine the value of the flags parameter passed to POSIX function
  ** open(). These must be calculated even if open() is not called, as
  ** they may be stored as part of the file handle and used by the
  ** 'conch file' locking functions later on.  */
  if (isReadonly) {
    openFlags |= O_RDONLY;
  }
  if (isReadWrite) {
    openFlags |= O_RDWR;
  }
  if (isCreate) {
    openFlags |= O_CREAT;
  }
  if (isExclusive) {
    openFlags |= (O_EXCL | O_NOFOLLOW);
  }
  openFlags |= (O_LARGEFILE | O_BINARY);
  if (fd < 0) {
    mode_t openMode;              /* Permissions to create file with */
    rc = findCreateFileMode(zName, flags, &openMode);
    if (rc != SQLITE_OK) {
      assert(!p->pUnused);
      assert(eType == SQLITE_OPEN_WAL || eType == SQLITE_OPEN_MAIN_JOURNAL);
      return rc;
    }
    fd = robust_open(zName, openFlags, openMode);
    if (fd < 0 && errno != EISDIR && isReadWrite && !isExclusive) {
      /* Failed to open the file for read/write access. Try read-only. */
      flags &= ~(SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE);
      openFlags &= ~(O_RDWR | O_CREAT);
      flags |= SQLITE_OPEN_READONLY;
      openFlags |= O_RDONLY;
      isReadonly = 1;
      fd = robust_open(zName, openFlags, openMode);
    }
    if (fd < 0) {
      rc = unixLogError(SQLITE_CANTOPEN_BKPT, "open", zName);
      goto open_finished;
    }
  }
  assert(fd >= 0);
  if (pOutFlags) {
    *pOutFlags = flags;
  }
  if (p->pUnused) {
    p->pUnused->fd = fd;
    p->pUnused->flags = flags;
  }
  if (isDelete) {
    unlink(zName);
  }
  if (isOpenDirectory) {
    rc = openDirectory(zPath, &dirfd);
    if (rc != SQLITE_OK) {
      /* It is safe to close fd at this point, because it is guaranteed not
      ** to be open on a database file. If it were open on a database file,
      ** it would not be safe to close as this would release any locks held
      ** on the file by this process.  */
      assert(eType != SQLITE_OPEN_MAIN_DB);
      robust_close(p, fd, __LINE__);
      goto open_finished;
    }
  }
  noLock = eType != SQLITE_OPEN_MAIN_DB;
  rc = fillInUnixFile(pVfs, fd, dirfd, pFile, zPath, noLock,
                      isDelete, isReadonly);
open_finished:
  if (rc != SQLITE_OK) {
    sqlite3_free(p->pUnused);
  }
  return rc;
}

static int unixRandomness ( sqlite3_vfs *  NotUsed, int  nBuf, char *  zBuf  )

static

Definition at line 1555 of file myvfs.c.

{
  UNUSED_PARAMETER(NotUsed);
  assert((size_t)nBuf >= (sizeof(time_t) + sizeof(int)));
  /* We have to initialize zBuf to prevent valgrind from reporting
  ** errors.  The reports issued by valgrind are incorrect - we would
  ** prefer that the randomness be increased by making use of the
  ** uninitialized space in zBuf - but valgrind errors tend to worry
  ** some users.  Rather than argue, it seems easier just to initialize
  ** the whole array and silence valgrind, even if that means less randomness
  ** in the random seed.
  **
  ** When testing, initializing zBuf[] to zero is all we do.  That means
  ** that we always use the same random number sequence.  This makes the
  ** tests repeatable.
  */
  memset(zBuf, 0, nBuf);
  {
    int pid, fd;
    fd = robust_open("/dev/urandom", O_RDONLY, 0);
    if (fd < 0) {
      time_t t;
      time(&t);
      memcpy(zBuf, &t, sizeof(t));
      pid = getpid();
      memcpy(&zBuf[sizeof(t)], &pid, sizeof(pid));
      assert(sizeof(t) + sizeof(pid) <= (size_t)nBuf);
      nBuf = sizeof(t) + sizeof(pid);
    }
    else {
      do {
        nBuf = osRead(fd, zBuf, nBuf);
      }
      while (nBuf < 0 && errno == EINTR);
      robust_close(0, fd, __LINE__);
    }
  }
  return nBuf;
}

static int unixRead ( sqlite3_file *  id, void *  pBuf, int  amt, sqlite3_int64  offset  )

static

Definition at line 921 of file myvfs.c.

{
  unixFile * pFile = (unixFile *)id;
  int got;
  fprintf(stderr, "trace: begin unixRead ...\n");
  assert(id);
  /* 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
         || offset >= PENDING_BYTE + 512
         || offset + amt <= PENDING_BYTE
        );
#endif
  got = seekAndRead(pFile, offset, pBuf, amt);
  if (got == amt) {
    return SQLITE_OK;
  }
  else if (got < 0) {
    /* lastErrno set by seekAndRead */
    return SQLITE_IOERR_READ;
  }
  else {
    pFile->lastErrno = 0; /* not a system error */
    /* Unread parts of the buffer must be zero-filled */
    memset(&((char *)pBuf)[got], 0, amt - got);
    return SQLITE_IOERR_SHORT_READ;
  }
}

static int unixSectorSize ( sqlite3_file *  NotUsed )

static

Definition at line 1191 of file myvfs.c.

{
  UNUSED_PARAMETER(NotUsed);
  return SQLITE_DEFAULT_SECTOR_SIZE;
}

static int unixSetSystemCall ( sqlite3_vfs *  pNotUsed, const char *  zName, sqlite3_syscall_ptr  pNewFunc  )

static

Definition at line 1665 of file myvfs.c.

{
  unsigned int i;
  int rc = SQLITE_NOTFOUND;
  UNUSED_PARAMETER(pNotUsed);
  if (zName == 0) {
    /* If no zName is given, restore all system calls to their default
    ** settings and return NULL
    */
    rc = SQLITE_OK;
    for (i = 0; i < sizeof(aSyscall) / sizeof(aSyscall[0]); i++) {
      if (aSyscall[i].pDefault) {
        aSyscall[i].pCurrent = aSyscall[i].pDefault;
      }
    }
  }
  else {
    /* If zName is specified, operate on only the one system call
    ** specified.
    */
    for (i = 0; i < sizeof(aSyscall) / sizeof(aSyscall[0]); i++) {
      if (strcmp(zName, aSyscall[i].zName) == 0) {
        if (aSyscall[i].pDefault == 0) {
          aSyscall[i].pDefault = aSyscall[i].pCurrent;
        }
        rc = SQLITE_OK;
        if (pNewFunc == 0) {
          pNewFunc = aSyscall[i].pDefault;
        }
        aSyscall[i].pCurrent = pNewFunc;
        break;
      }
    }
  }
  return rc;
}

static int unixSleep ( sqlite3_vfs *  NotUsed, int  microseconds  )

static

Definition at line 1604 of file myvfs.c.

{
  usleep(microseconds);
  UNUSED_PARAMETER(NotUsed);
  return microseconds;
}

static int unixSync ( sqlite3_file *  id, int  flags  )

static

Definition at line 1057 of file myvfs.c.

{
  int rc;
  unixFile * pFile = (unixFile *)id;
  int isDataOnly = (flags & SQLITE_SYNC_DATAONLY);
  int isFullsync = (flags & 0x0F) == SQLITE_SYNC_FULL;
  fprintf(stderr, "trace: begin unixSync ...\n");
  /* Check that one of SQLITE_SYNC_NORMAL or FULL was passed */
  assert((flags & 0x0F) == SQLITE_SYNC_NORMAL
         || (flags & 0x0F) == SQLITE_SYNC_FULL
        );
  /* Unix cannot, but some systems may return SQLITE_FULL from here. This
  ** line is to test that doing so does not cause any problems.
  */
  assert(pFile);
  rc = full_fsync(pFile->h, isFullsync, isDataOnly);
  if (rc) {
    pFile->lastErrno = errno;
    return unixLogError(SQLITE_IOERR_FSYNC, "full_fsync", pFile->zPath);
  }
  if (pFile->dirfd >= 0) {
    /* The directory sync is only attempted if full_fsync is
    ** turned off or unavailable.  If a full_fsync occurred above,
    ** then the directory sync is superfluous.
    */
    if (full_fsync(pFile->dirfd, 0, 0)) {
      /*
      ** We have received multiple reports of fsync() returning
      ** errors when applied to directories on certain file systems.
      ** A failed directory sync is not a big deal.  So it seems
      ** better to ignore the error.  Ticket #1657
      */
      /* pFile->lastErrno = errno; */
      /* return SQLITE_IOERR; */
    }
    /* Only need to sync once, so close the  directory when we are done */
    robust_close(pFile, pFile->dirfd, __LINE__);
    pFile->dirfd = -1;
  }
  return rc;
}

static const char * unixTempFileDir ( void  )

static

Definition at line 576 of file myvfs.c.

{
  static const char * azDirs[] = {
    0,
    0,
    "/var/tmp",
    "/usr/tmp",
    "/tmp",
    0        /* List terminator */
  };
  unsigned int i;
  struct stat buf;
  const char * zDir = 0;
  azDirs[0] = sqlite3_temp_directory;
  if (!azDirs[1]) {
    azDirs[1] = getenv("TMPDIR");
  }
  for (i = 0; i < sizeof(azDirs) / sizeof(azDirs[0]); zDir = azDirs[i++]) {
    if (zDir == 0) {
      continue;
    }
    if (osStat(zDir, &buf)) {
      continue;
    }
    if (!S_ISDIR(buf.st_mode)) {
      continue;
    }
    if (osAccess(zDir, 07)) {
      continue;
    }
    break;
  }
  return zDir;
}

static int unixTruncate ( sqlite3_file *  id, i64  nByte  )

static

Definition at line 1008 of file myvfs.c.

{
  unixFile * pFile = (unixFile *)id;
  int rc;
  fprintf(stderr, "trace: begin unixTruncate ...\n");
  assert(pFile);
  /* If the user has configured a chunk-size for this file, truncate the
  ** file so that it consists of an integer number of chunks (i.e. the
  ** actual file size after the operation may be larger than the requested
  ** size).
  */
  if (pFile->szChunk) {
    nByte = ((nByte + pFile->szChunk - 1) / pFile->szChunk) * pFile->szChunk;
  }
  rc = robust_ftruncate(pFile->h, (off_t)nByte);
  if (rc) {
    pFile->lastErrno = errno;
    return unixLogError(SQLITE_IOERR_TRUNCATE, "ftruncate", pFile->zPath);
  }
  else {
    /* If we are doing a normal write to a database file (as opposed to
    ** doing a hot-journal rollback or a write to some file other than a
    ** normal database file) and we truncate the file to zero length,
    ** that effectively updates the change counter.  This might happen
    ** when restoring a database using the backup API from a zero-length
    ** source.
    */
    if (pFile->inNormalWrite && nByte == 0) {
      pFile->transCntrChng = 1;
    }
    return SQLITE_OK;
  }
}

static int unixWrite ( sqlite3_file *  id, const void *  pBuf, int  amt, sqlite3_int64  offset  )

static

Definition at line 955 of file myvfs.c.

{
  unixFile * pFile = (unixFile *)id;
  int wrote = 0;
  fprintf(stderr, "trace: begin unixWrite ...\n");
  assert(id);
  assert(amt > 0);
  /* 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
         || offset >= PENDING_BYTE + 512
         || offset + amt <= PENDING_BYTE
        );
#endif
  /* If we are doing a normal write to a database file (as opposed to
  ** doing a hot-journal rollback or a write to some file other than a
  ** normal database file) then record the fact that the database
  ** has changed.  If the transaction counter is modified, record that
  ** fact too.
  */
  if (pFile->inNormalWrite) {
    pFile->dbUpdate = 1;  /* The database has been modified */
    if (offset <= 24 && offset + amt >= 27) {
      int rc;
      char oldCntr[4];
      rc = seekAndRead(pFile, 24, oldCntr, 4);
      if (rc != 4 || memcmp(oldCntr, &((char *)pBuf)[24 - offset], 4) != 0) {
        pFile->transCntrChng = 1;  /* The transaction counter has changed */
      }
    }
  }
  while (amt > 0 && (wrote = seekAndWrite(pFile, offset, pBuf, amt)) > 0) {
    amt -= wrote;
    offset += wrote;
    pBuf = &((char *)pBuf)[wrote];
  }
  if (amt > 0) {
    if (wrote < 0) {
      /* lastErrno set by seekAndWrite */
      return SQLITE_IOERR_WRITE;
    }
    else {
      pFile->lastErrno = 0; /* not a system error */
      return SQLITE_FULL;
    }
  }
  return SQLITE_OK;
}

Variable Documentation

struct unix_syscall aSyscall[]

static

struct unixInodeInfo* inodeList = 0

static

Definition at line 103 of file myvfs.c.

const sqlite3_io_methods*(*const nolockIoFinder) (const char *, unixFile *p) = nolockIoFinderImpl

static

Definition at line 369 of file myvfs.c.

const sqlite3_io_methods nolockIoMethods

static

Initial value:

= {
  1,                          
  nolockClose,                
  unixRead,                   
  unixWrite,                  
  unixTruncate,               
  unixSync,                   
  unixFileSize,               
  nolockLock,                 
  nolockUnlock,               
  nolockCheckReservedLock,    
  unixFileControl,            
  unixSectorSize,             
  unixDeviceCharacteristics,  





 
}

Definition at line 340 of file myvfs.c.

void(*)(void) unixDlSym(sqlite3_vfs *NotUsed, void *p, const char *zSym)

static

Definition at line 199 of file myvfs.c.