#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>

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)

keras_to_tensorflow.int

int

Definition: keras_to_tensorflow.py:69

#define osPwrite64

Value:

((ssize_t(*)(int,const void*,size_t,off_t))\

aSyscall[13].pCurrent)

keras_to_tensorflow.int

int

Definition: keras_to_tensorflow.py:69

#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.

Classes

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

Typedef Documentation

Function Documentation

Variable Documentation