/*

** 2004 May 22

**

** The author disclaims copyright to this source code. In place of

** a legal notice, here is a blessing:

**

** May you do good and not evil.

** May you find forgiveness for yourself and forgive others.

** May you share freely, never taking more than you give.

**

******************************************************************************

**

** This file contains the VFS implementation for unix-like operating systems

** include Linux, MacOSX, *BSD, QNX, VxWorks, AIX, HPUX, and others.

**

** There are actually several different VFS implementations in this file.

** The differences are in the way that file locking is done. The default

** implementation uses Posix Advisory Locks. Alternative implementations

** use flock(), dot-files, various proprietary locking schemas, or simply

** skip locking all together.

**

** This source file is organized into divisions where the logic for various

** subfunctions is contained within the appropriate division. PLEASE

** KEEP THE STRUCTURE OF THIS FILE INTACT. New code should be placed

** in the correct division and should be clearly labelled.

**

** The layout of divisions is as follows:

**

** * General-purpose declarations and utility functions.

** * Unique file ID logic used by VxWorks.

** * Various locking primitive implementations (all except proxy locking):

** + for Posix Advisory Locks

** + for no-op locks

** + for dot-file locks

** + for flock() locking

** + for named semaphore locks (VxWorks only)

** + for AFP filesystem locks (MacOSX only)

** * sqlite3_file methods not associated with locking.

** * Definitions of sqlite3_io_methods objects for all locking

** methods plus "finder" functions for each locking method.

** * sqlite3_vfs method implementations.

** * Locking primitives for the proxy uber-locking-method. (MacOSX only)

** * Definitions of sqlite3_vfs objects for all locking methods

** plus implementations of sqlite3_os_init() and sqlite3_os_end().

*/

#include "sqliteInt.h"

#if SQLITE_OS_UNIX /* This file is used on unix only */

/*

** There are various methods for file locking used for concurrency

** control:

**

** 1. POSIX locking (the default),

** 2. No locking,

** 3. Dot-file locking,

** 4. flock() locking,

** 5. AFP locking (OSX only),

** 6. Named POSIX semaphores (VXWorks only),

** 7. proxy locking. (OSX only)

**

** Styles 4, 5, and 7 are only available of SQLITE_ENABLE_LOCKING_STYLE

** is defined to 1. The SQLITE_ENABLE_LOCKING_STYLE also enables automatic

** selection of the appropriate locking style based on the filesystem

** where the database is located.

*/

#if !defined(SQLITE_ENABLE_LOCKING_STYLE)

# if defined(__APPLE__)

# define SQLITE_ENABLE_LOCKING_STYLE 1

# else

# define SQLITE_ENABLE_LOCKING_STYLE 0

# endif

#endif

/* Use pread() and pwrite() if they are available */

#if defined(__APPLE__) || defined(__linux__)

# define HAVE_PREAD 1

# define HAVE_PWRITE 1

#endif

#if defined(HAVE_PREAD64) && defined(HAVE_PWRITE64)

# undef USE_PREAD

# define USE_PREAD64 1

#elif defined(HAVE_PREAD) && defined(HAVE_PWRITE)

# undef USE_PREAD64

# define USE_PREAD 1

#endif

/*

** standard include files.

*/

#include <sys/types.h> /* amalgamator: keep */

#include <sys/stat.h> /* amalgamator: keep */

#include <fcntl.h>

#include <sys/ioctl.h>

#include <unistd.h> /* amalgamator: keep */

#include <time.h>

#include <sys/time.h> /* amalgamator: keep */

#include <errno.h>

#if (!defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0) \

&& !defined(SQLITE_WASI)

# include <sys/mman.h>

#endif

#if SQLITE_ENABLE_LOCKING_STYLE

# include <sys/ioctl.h>

# include <sys/file.h>

# include <sys/param.h>

#endif /* SQLITE_ENABLE_LOCKING_STYLE */

/*

** Try to determine if gethostuuid() is available based on standard

** macros. This might sometimes compute the wrong value for some

** obscure platforms. For those cases, simply compile with one of

** the following:

**

** -DHAVE_GETHOSTUUID=0

** -DHAVE_GETHOSTUUID=1

**

** None if this matters except when building on Apple products with

** -DSQLITE_ENABLE_LOCKING_STYLE.

*/

#ifndef HAVE_GETHOSTUUID

# define HAVE_GETHOSTUUID 0

# if defined(__APPLE__) && ((__MAC_OS_X_VERSION_MIN_REQUIRED > 1050) || \

(__IPHONE_OS_VERSION_MIN_REQUIRED > 2000))

# if (!defined(TARGET_OS_EMBEDDED) || (TARGET_OS_EMBEDDED==0)) \

&& (!defined(TARGET_IPHONE_SIMULATOR) || (TARGET_IPHONE_SIMULATOR==0))\

&& (!defined(TARGET_OS_MACCATALYST) || (TARGET_OS_MACCATALYST==0))

# undef HAVE_GETHOSTUUID

# define HAVE_GETHOSTUUID 1

# else

# warning "gethostuuid() is disabled."

# endif

# endif

#endif

#if OS_VXWORKS

# include <sys/ioctl.h>

# include <semaphore.h>

# include <limits.h>

#endif /* OS_VXWORKS */

#if defined(__APPLE__) || SQLITE_ENABLE_LOCKING_STYLE

# include <sys/mount.h>

#endif

#ifdef HAVE_UTIME

# include <utime.h>

#endif

/*

** Allowed values of unixFile.fsFlags

*/

#define SQLITE_FSFLAGS_IS_MSDOS 0x1

/*

** If we are to be thread-safe, include the pthreads header.

*/

#if SQLITE_THREADSAFE

# include <pthread.h>

#endif

/*

** Default permissions when creating a new file

*/

#ifndef SQLITE_DEFAULT_FILE_PERMISSIONS

# define SQLITE_DEFAULT_FILE_PERMISSIONS 0644

#endif

/*

** Default permissions when creating auto proxy dir

*/

#ifndef SQLITE_DEFAULT_PROXYDIR_PERMISSIONS

# define SQLITE_DEFAULT_PROXYDIR_PERMISSIONS 0755

#endif

/*

** Maximum supported path-length.

*/

#define MAX_PATHNAME 512

/*

** Maximum supported symbolic links

*/

#define SQLITE_MAX_SYMLINKS 100

/*

** Remove and stub certain info for WASI (WebAssembly System

** Interface) builds.

*/

#ifdef SQLITE_WASI

# undef HAVE_FCHMOD

# undef HAVE_FCHOWN

# undef HAVE_MREMAP

# define HAVE_MREMAP 0

# ifndef SQLITE_DEFAULT_UNIX_VFS

# define SQLITE_DEFAULT_UNIX_VFS "unix-dotfile"

/* ^^^ should SQLITE_DEFAULT_UNIX_VFS be "unix-none"? */

# endif

# ifndef F_RDLCK

# define F_RDLCK 0

# define F_WRLCK 1

# define F_UNLCK 2

# if __LONG_MAX == 0x7fffffffL

# define F_GETLK 12

# define F_SETLK 13

# define F_SETLKW 14

# else

# define F_GETLK 5

# define F_SETLK 6

# define F_SETLKW 7

# endif

# endif

#else /* !SQLITE_WASI */

# ifndef HAVE_FCHMOD

# define HAVE_FCHMOD 1

# endif

#endif /* SQLITE_WASI */

#ifdef SQLITE_WASI

# define osGetpid(X) (pid_t)1

#else

/* Always cast the getpid() return type for compatibility with

** kernel modules in VxWorks. */

# define osGetpid(X) (pid_t)getpid()

#endif

/*

** Only set the lastErrno if the error code is a real error and not

** a normal expected return code of SQLITE_BUSY or SQLITE_OK

*/

#define IS_LOCK_ERROR(x) ((x != SQLITE_OK) && (x != SQLITE_BUSY))

/* Forward references */

typedef struct unixShm unixShm; /* Connection shared memory */

typedef struct unixShmNode unixShmNode; /* Shared memory instance */

typedef struct unixInodeInfo unixInodeInfo; /* An i-node */

typedef struct UnixUnusedFd UnixUnusedFd; /* An unused file descriptor */

/*

** Sometimes, after a file handle is closed by SQLite, the file descriptor

** cannot be closed immediately. In these cases, instances of the following

** structure are used to store the file descriptor while waiting for an

** opportunity to either close or reuse it.

*/

struct UnixUnusedFd {

int fd; /* File descriptor to close */

int flags; /* Flags this file descriptor was opened with */

UnixUnusedFd *pNext; /* Next unused file descriptor on same file */

};

/*

** The unixFile structure is subclass of sqlite3_file specific to the unix

** VFS implementations.

*/

typedef struct unixFile unixFile;

struct unixFile {

sqlite3_io_methods const *pMethod; /* Always the first entry */

sqlite3_vfs *pVfs; /* The VFS that created this unixFile */

unixInodeInfo *pInode; /* Info about locks on this inode */

int h; /* The file descriptor */

unsigned char eFileLock; /* The type of lock held on this fd */

unsigned short int ctrlFlags; /* Behavioral bits. UNIXFILE_* flags */

int lastErrno; /* The unix errno from last I/O error */

void *lockingContext; /* Locking style specific state */

UnixUnusedFd *pPreallocatedUnused; /* Pre-allocated UnixUnusedFd */

const char *zPath; /* Name of the file */

unixShm *pShm; /* Shared memory segment information */

int szChunk; /* Configured by FCNTL_CHUNK_SIZE */

#if SQLITE_MAX_MMAP_SIZE>0

int nFetchOut; /* Number of outstanding xFetch refs */

sqlite3_int64 mmapSize; /* Usable size of mapping at pMapRegion */

sqlite3_int64 mmapSizeActual; /* Actual size of mapping at pMapRegion */

sqlite3_int64 mmapSizeMax; /* Configured FCNTL_MMAP_SIZE value */

void *pMapRegion; /* Memory mapped region */

#endif

int sectorSize; /* Device sector size */

int deviceCharacteristics; /* Precomputed device characteristics */

#if SQLITE_ENABLE_LOCKING_STYLE

int openFlags; /* The flags specified at open() */

#endif

#if SQLITE_ENABLE_LOCKING_STYLE || defined(__APPLE__)

unsigned fsFlags; /* cached details from statfs() */

#endif

#ifdef SQLITE_ENABLE_SETLK_TIMEOUT

unsigned iBusyTimeout; /* Wait this many millisec on locks */

int bBlockOnConnect; /* True to block for SHARED locks */

#endif

#if OS_VXWORKS

struct vxworksFileId *pId; /* Unique file ID */

#endif

#ifdef SQLITE_DEBUG

/* The next group of variables are used to track whether or not the

** transaction counter in bytes 24-27 of database files are updated

** whenever any part of the database changes. An assertion fault will

** occur if a file is updated without also updating the transaction

** counter. This test is made to avoid new problems similar to the

** one described by ticket #3584.

*/

unsigned char transCntrChng; /* True if the transaction counter changed */

unsigned char dbUpdate; /* True if any part of database file changed */

unsigned char inNormalWrite; /* True if in a normal write operation */

#endif

#ifdef SQLITE_TEST

/* In test mode, increase the size of this structure a bit so that

** it is larger than the struct CrashFile defined in test6.c.

*/

char aPadding[32];

#endif

};

/* This variable holds the process id (pid) from when the xRandomness()

** method was called. If xOpen() is called from a different process id,

** indicating that a fork() has occurred, the PRNG will be reset.

*/

static pid_t randomnessPid = 0;

/*

** Allowed values for the unixFile.ctrlFlags bitmask:

*/

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

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

#define UNIXFILE_PERSIST_WAL 0x04 /* Persistent WAL mode */

#if !defined(SQLITE_DISABLE_DIRSYNC) && !defined(_AIX)

# define UNIXFILE_DIRSYNC 0x08 /* Directory sync needed */

#else

# define UNIXFILE_DIRSYNC 0x00

#endif

#define UNIXFILE_PSOW 0x10 /* SQLITE_IOCAP_POWERSAFE_OVERWRITE */

#define UNIXFILE_DELETE 0x20 /* Delete on close */

#define UNIXFILE_URI 0x40 /* Filename might have query parameters */

#define UNIXFILE_NOLOCK 0x80 /* Do no file locking */

/*

** Include code that is common to all os_*.c files

*/

#include "os_common.h"

/*

** Define various macros that are missing from some systems.

*/

#ifndef O_LARGEFILE

# define O_LARGEFILE 0

#endif

#ifdef SQLITE_DISABLE_LFS

# undef O_LARGEFILE

# define O_LARGEFILE 0

#endif

#ifndef O_NOFOLLOW

# define O_NOFOLLOW 0

#endif

#ifndef O_BINARY

# define O_BINARY 0

#endif

/*

** The threadid macro resolves to the thread-id or to 0. Used for

** testing and debugging only.

*/

#if SQLITE_THREADSAFE

#define threadid pthread_self()

#else

#define threadid 0

#endif

/*

** HAVE_MREMAP defaults to true on Linux and false everywhere else.

*/

#if !defined(HAVE_MREMAP)

# if defined(__linux__) && defined(_GNU_SOURCE)

# define HAVE_MREMAP 1

# else

# define HAVE_MREMAP 0

# endif

#endif

/*

** Explicitly call the 64-bit version of lseek() on Android. Otherwise, lseek()

** is the 32-bit version, even if _FILE_OFFSET_BITS=64 is defined.

*/

#ifdef __ANDROID__

# define lseek lseek64

#endif

#ifdef __linux__

/*

** Linux-specific IOCTL magic numbers used for controlling F2FS

*/

#define F2FS_IOCTL_MAGIC 0xf5

#define F2FS_IOC_START_ATOMIC_WRITE _IO(F2FS_IOCTL_MAGIC, 1)

#define F2FS_IOC_COMMIT_ATOMIC_WRITE _IO(F2FS_IOCTL_MAGIC, 2)

#define F2FS_IOC_START_VOLATILE_WRITE _IO(F2FS_IOCTL_MAGIC, 3)

#define F2FS_IOC_ABORT_VOLATILE_WRITE _IO(F2FS_IOCTL_MAGIC, 5)

#define F2FS_IOC_GET_FEATURES _IOR(F2FS_IOCTL_MAGIC, 12, u32)

#define F2FS_FEATURE_ATOMIC_WRITE 0x0004

#endif /* __linux__ */

/*

** Different Unix systems declare open() in different ways. Same use

** open(const char*,int,mode_t). Others use open(const char*,int,...).

** The difference is important when using a pointer to the function.

**

** The safest way to deal with the problem is to always use this wrapper

** which always has the same well-defined interface.

*/

static int posixOpen(const char *zFile, int flags, int mode){

return open(zFile, flags, mode);

}

/* Forward reference */

static int openDirectory(const char*, int*);

static int unixGetpagesize(void);

/*

** Many system calls are accessed through pointer-to-functions so that

** they may be overridden at runtime to facilitate fault injection during

** testing and sandboxing. The following array holds the names and pointers

** to all overrideable system calls.

*/

static struct unix_syscall {

const char *zName; /* Name of the system call */

sqlite3_syscall_ptr pCurrent; /* Current value of the system call */

sqlite3_syscall_ptr pDefault; /* Default value */

} aSyscall[] = {

{ "open", (sqlite3_syscall_ptr)posixOpen, 0 },

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

{ "close", (sqlite3_syscall_ptr)close, 0 },

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

{ "access", (sqlite3_syscall_ptr)access, 0 },

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

{ "getcwd", (sqlite3_syscall_ptr)getcwd, 0 },

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

{ "stat", (sqlite3_syscall_ptr)stat, 0 },

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

/*

** The DJGPP compiler environment looks mostly like Unix, but it

** lacks the fcntl() system call. So redefine fcntl() to be something

** that always succeeds. This means that locking does not occur under

** DJGPP. But it is DOS - what did you expect?

*/

#ifdef __DJGPP__

{ "fstat", 0, 0 },

#define osFstat(a,b,c) 0

#else

{ "fstat", (sqlite3_syscall_ptr)fstat, 0 },

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

#endif

{ "ftruncate", (sqlite3_syscall_ptr)ftruncate, 0 },

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

{ "fcntl", (sqlite3_syscall_ptr)fcntl, 0 },

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

{ "read", (sqlite3_syscall_ptr)read, 0 },

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

#if defined(USE_PREAD) || SQLITE_ENABLE_LOCKING_STYLE

{ "pread", (sqlite3_syscall_ptr)pread, 0 },

#else

{ "pread", (sqlite3_syscall_ptr)0, 0 },

#endif

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

#if defined(USE_PREAD64)

{ "pread64", (sqlite3_syscall_ptr)pread64, 0 },

#else

{ "pread64", (sqlite3_syscall_ptr)0, 0 },

#endif

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

{ "write", (sqlite3_syscall_ptr)write, 0 },

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

#if defined(USE_PREAD) || SQLITE_ENABLE_LOCKING_STYLE

{ "pwrite", (sqlite3_syscall_ptr)pwrite, 0 },

#else

{ "pwrite", (sqlite3_syscall_ptr)0, 0 },

#endif

#define osPwrite ((ssize_t(*)(int,const void*,size_t,off_t))\

aSyscall[12].pCurrent)

#if defined(USE_PREAD64)

{ "pwrite64", (sqlite3_syscall_ptr)pwrite64, 0 },

#else

{ "pwrite64", (sqlite3_syscall_ptr)0, 0 },

#endif

#define osPwrite64 ((ssize_t(*)(int,const void*,size_t,off64_t))\

aSyscall[13].pCurrent)

#if defined(HAVE_FCHMOD)

{ "fchmod", (sqlite3_syscall_ptr)fchmod, 0 },

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

#else

{ "fchmod", (sqlite3_syscall_ptr)0, 0 },

#define osFchmod(FID,MODE) 0

#endif

#if defined(HAVE_POSIX_FALLOCATE) && HAVE_POSIX_FALLOCATE

{ "fallocate", (sqlite3_syscall_ptr)posix_fallocate, 0 },

#else

{ "fallocate", (sqlite3_syscall_ptr)0, 0 },

#endif

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

{ "unlink", (sqlite3_syscall_ptr)unlink, 0 },

#define osUnlink ((int(*)(const char*))aSyscall[16].pCurrent)

{ "openDirectory", (sqlite3_syscall_ptr)openDirectory, 0 },

#define osOpenDirectory ((int(*)(const char*,int*))aSyscall[17].pCurrent)

{ "mkdir", (sqlite3_syscall_ptr)mkdir, 0 },

#define osMkdir ((int(*)(const char*,mode_t))aSyscall[18].pCurrent)

{ "rmdir", (sqlite3_syscall_ptr)rmdir, 0 },

#define osRmdir ((int(*)(const char*))aSyscall[19].pCurrent)

#if defined(HAVE_FCHOWN)

{ "fchown", (sqlite3_syscall_ptr)fchown, 0 },

#else

{ "fchown", (sqlite3_syscall_ptr)0, 0 },

#endif

#define osFchown ((int(*)(int,uid_t,gid_t))aSyscall[20].pCurrent)

#if defined(HAVE_FCHOWN)

{ "geteuid", (sqlite3_syscall_ptr)geteuid, 0 },

#else

{ "geteuid", (sqlite3_syscall_ptr)0, 0 },

#endif

#define osGeteuid ((uid_t(*)(void))aSyscall[21].pCurrent)

#if (!defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0) \

&& !defined(SQLITE_WASI)

{ "mmap", (sqlite3_syscall_ptr)mmap, 0 },

#else

{ "mmap", (sqlite3_syscall_ptr)0, 0 },

#endif

#define osMmap ((void*(*)(void*,size_t,int,int,int,off_t))aSyscall[22].pCurrent)

#if (!defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0) \

&& !defined(SQLITE_WASI)

{ "munmap", (sqlite3_syscall_ptr)munmap, 0 },

#else

{ "munmap", (sqlite3_syscall_ptr)0, 0 },

#endif

#define osMunmap ((int(*)(void*,size_t))aSyscall[23].pCurrent)

#if HAVE_MREMAP && (!defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0)

{ "mremap", (sqlite3_syscall_ptr)mremap, 0 },

#else

{ "mremap", (sqlite3_syscall_ptr)0, 0 },

#endif

#define osMremap ((void*(*)(void*,size_t,size_t,int,...))aSyscall[24].pCurrent)

#if !defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0

{ "getpagesize", (sqlite3_syscall_ptr)unixGetpagesize, 0 },

#else

{ "getpagesize", (sqlite3_syscall_ptr)0, 0 },

#endif

#define osGetpagesize ((int(*)(void))aSyscall[25].pCurrent)

#if defined(HAVE_READLINK)

{ "readlink", (sqlite3_syscall_ptr)readlink, 0 },

#else

{ "readlink", (sqlite3_syscall_ptr)0, 0 },

#endif

#define osReadlink ((ssize_t(*)(const char*,char*,size_t))aSyscall[26].pCurrent)

#if defined(HAVE_LSTAT)

{ "lstat", (sqlite3_syscall_ptr)lstat, 0 },

#else

{ "lstat", (sqlite3_syscall_ptr)0, 0 },

#endif

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

#if defined(__linux__) && defined(SQLITE_ENABLE_BATCH_ATOMIC_WRITE)

# ifdef __ANDROID__

{ "ioctl", (sqlite3_syscall_ptr)(int(*)(int, int, ...))ioctl, 0 },

#define osIoctl ((int(*)(int,int,...))aSyscall[28].pCurrent)

# else

{ "ioctl", (sqlite3_syscall_ptr)ioctl, 0 },

#define osIoctl ((int(*)(int,unsigned long,...))aSyscall[28].pCurrent)

# endif

#else

{ "ioctl", (sqlite3_syscall_ptr)0, 0 },

#endif

}; /* End of the overrideable system calls */

#if defined(SQLITE_DEBUG) || defined(SQLITE_ENABLE_FILESTAT)

/*

** Extract Posix Advisory Locking information about file description fd

** from the /proc/PID/fdinfo/FD pseudo-file. Fill the string buffer a[16]

** with characters to indicate which SQLite-relevant locks are held.

** a[16] will be a 15-character zero-terminated string with the following

** schema:

**

** AAA/B.DDD.DDDDD

**

** Each of character A-D will be "w" or "r" or "-" to indicate either a

** write-lock, a read-lock, or no-lock, respectively. The "." and "/"

** characters are delimiters intended to make the string more easily

** readable by humans. Here are the meaning of the specific letters:

**

** AAA -> The main database locks. PENDING_BYTE, RESERVED_BYTE,

** and SHARED_FIRST, respectively.

**

** B -> The deadman switch lock. Offset 128 of the -shm file.

**

** CCC -> WAL locks: WRITE, CKPT, RECOVER

**

** DDDDD -> WAL read-locks 0 through 5

**

** Note that elements before the "/" apply to the main database file and

** elements after the "/" apply to the -shm file in WAL mode.

**

** Here is another way of thinking about the meaning of the result string:

**

** AAA/B.CCC.DDDDD

** ||| | ||| \___/

** PENDING--'|| | ||| `----- READ 0-5

** RESERVED--'| | ||`---- RECOVER

** SHARED ----' | |`----- CKPT

** DMS ------' `------ WRITE

**

** Return SQLITE_OK on success and SQLITE_ERROR_UNABLE if the /proc

** pseudo-filesystem is unavailable.

*/

static int unixPosixAdvisoryLocks(

int fd, /* The file descriptor to analyze */

char a[16] /* Write a text description of PALs here */

){

int in;

ssize_t n;

char *p, *pNext, *x;

char z[2000];

/* 1 */

/* 012 4 678 01234 */

memcpy(a, "---/-.---.-----", 16);

sqlite3_snprintf(sizeof(z), z, "/proc/%d/fdinfo/%d", getpid(), fd);

in = osOpen(z, O_RDONLY, 0);

if( in<0 ){

return SQLITE_ERROR_UNABLE;

}

n = osRead(in, z, sizeof(z)-1);

osClose(in);

if( n<=0 ) return SQLITE_ERROR_UNABLE;

z[n] = 0;

/* We are looking for lines that begin with "lock:\t". Examples:

**

** lock: 1: POSIX ADVISORY READ 494716 08:02:5277597 1073741826 1073742335

** lock: 1: POSIX ADVISORY WRITE 494716 08:02:5282282 120 120

** lock: 2: POSIX ADVISORY READ 494716 08:02:5282282 123 123

** lock: 3: POSIX ADVISORY READ 494716 08:02:5282282 128 128

*/

pNext = strstr(z, "lock:\t");

while( pNext ){

char cType = 0;

sqlite3_int64 iFirst, iLast;

p = pNext+6;

pNext = strstr(p, "lock:\t");

if( pNext ) pNext[-1] = 0;

if( (x = strstr(p, " READ "))!=0 ){

cType = 'r';

x += 6;

}else if( (x = strstr(p, " WRITE "))!=0 ){

cType = 'w';

x += 7;

}else{

continue;

}

x = strrchr(x, ' ');

if( x==0 ) continue;

iLast = strtoll(x+1, 0, 10);

*x = 0;

x = strrchr(p, ' ');

if( x==0 ) continue;

iFirst = strtoll(x+1, 0, 10);

if( iLast>=PENDING_BYTE ){

if( iFirst<=PENDING_BYTE && iLast>=PENDING_BYTE ) a[0] = cType;

if( iFirst<=PENDING_BYTE+1 && iLast>=PENDING_BYTE+1 ) a[1] = cType;

if( iFirst<=PENDING_BYTE+2 && iLast>=PENDING_BYTE+510 ) a[2] = cType;

}else if( iLast<=128 ){

if( iFirst<=128 && iLast>=128 ) a[4] = cType;

if( iFirst<=120 && iLast>=120 ) a[6] = cType;

if( iFirst<=121 && iLast>=121 ) a[7] = cType;

if( iFirst<=122 && iLast>=122 ) a[8] = cType;

if( iFirst<=123 && iLast>=123 ) a[10] = cType;

if( iFirst<=124 && iLast>=124 ) a[11] = cType;

if( iFirst<=125 && iLast>=125 ) a[12] = cType;

if( iFirst<=126 && iLast>=126 ) a[13] = cType;

if( iFirst<=127 && iLast>=127 ) a[14] = cType;

}

}

return SQLITE_OK;

}

#else

# define unixPosixAdvisoryLocks(A,B) SQLITE_ERROR_UNABLE

#endif /* SQLITE_DEBUG || SQLITE_ENABLE_FILESTAT */

/*

** On some systems, calls to fchown() will trigger a message in a security

** log if they come from non-root processes. So avoid calling fchown() if

** we are not running as root.

*/

static int robustFchown(int fd, uid_t uid, gid_t gid){

#if defined(HAVE_FCHOWN)

return osGeteuid() ? 0 : osFchown(fd,uid,gid);

#else

return 0;

#endif

}

/*

** This is the xSetSystemCall() method of sqlite3_vfs for all of the

** "unix" VFSes. Return SQLITE_OK upon successfully updating the

** system call pointer, or SQLITE_NOTFOUND if there is no configurable

** system call named zName.

*/

static int unixSetSystemCall(

sqlite3_vfs *pNotUsed, /* The VFS pointer. Not used */

const char *zName, /* Name of system call to override */

sqlite3_syscall_ptr pNewFunc /* Pointer to new system call value */

){

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;

}

/*

** Return the value of a system call. Return NULL if zName is not a

** recognized system call name. NULL is also returned if the system call

** is currently undefined.

*/

static sqlite3_syscall_ptr unixGetSystemCall(

sqlite3_vfs *pNotUsed,

const char *zName

){

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;

}

/*

** Return the name of the first system call after zName. If zName==NULL

** then return the name of the first system call. Return NULL if zName

** is the last system call or if zName is not the name of a valid

** system call.

*/

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

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;

}

/*

** Do not accept any file descriptor less than this value, in order to avoid

** opening database file using file descriptors that are commonly used for

** standard input, output, and error.

*/

#ifndef SQLITE_MINIMUM_FILE_DESCRIPTOR

# define SQLITE_MINIMUM_FILE_DESCRIPTOR 3

#endif

/*

** Invoke open(). Do so multiple times, until it either succeeds or

** fails for some reason other than EINTR.

**

** If the file creation mode "m" is 0 then set it to the default for

** SQLite. The default is SQLITE_DEFAULT_FILE_PERMISSIONS (normally

** 0644) as modified by the system umask. If m is not 0, then

** make the file creation mode be exactly m ignoring the umask.

**

** The m parameter will be non-zero only when creating -wal, -journal,

** and -shm files. We want those files to have *exactly* the same

** permissions as their original database, unadulterated by the umask.

** In that way, if a database file is -rw-rw-rw or -rw-rw-r-, and a

** transaction crashes and leaves behind hot journals, then any

** process that is able to write to the database will also be able to

** recover the hot journals.

*/

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

int fd;

mode_t m2 = m ? m : SQLITE_DEFAULT_FILE_PERMISSIONS;

while(1){

#if defined(O_CLOEXEC)

fd = osOpen(z,f|O_CLOEXEC,m2);

#else

fd = osOpen(z,f,m2);

#endif

if( fd<0 ){

if( errno==EINTR ) continue;

break;

}

if( fd>=SQLITE_MINIMUM_FILE_DESCRIPTOR ) break;

if( (f & (O_EXCL|O_CREAT))==(O_EXCL|O_CREAT) ){

(void)osUnlink(z);

}

osClose(fd);

sqlite3_log(SQLITE_WARNING,

"attempt to open \"%s\" as file descriptor %d", z, fd);

fd = -1;

if( osOpen("/dev/null", O_RDONLY, m)<0 ) break;

}

if( fd>=0 ){

if( m!=0 ){

struct stat statbuf;

if( osFstat(fd, &statbuf)==0

&& statbuf.st_size==0

&& (statbuf.st_mode&0777)!=m

){

osFchmod(fd, m);

}

}

#if defined(FD_CLOEXEC) && (!defined(O_CLOEXEC) || O_CLOEXEC==0)

osFcntl(fd, F_SETFD, osFcntl(fd, F_GETFD, 0) | FD_CLOEXEC);

#endif

}

return fd;

}

/*

** Helper functions to obtain and relinquish the global mutex. The

** global mutex is used to protect the unixInodeInfo objects used by

** this file, all of which may be shared by multiple threads.

**

** Function unixMutexHeld() is used to assert() that the global mutex

** is held when required. This function is only used as part of assert()

** statements. e.g.

**

** unixEnterMutex()

** assert( unixMutexHeld() );

** unixEnterLeave()

**

** To prevent deadlock, the global unixBigLock must must be acquired

** before the unixInodeInfo.pLockMutex mutex, if both are held. It is

** OK to get the pLockMutex without holding unixBigLock first, but if

** that happens, the unixBigLock mutex must not be acquired until after

** pLockMutex is released.

**

** OK: enter(unixBigLock), enter(pLockInfo)

** OK: enter(unixBigLock)

** OK: enter(pLockInfo)

** ERROR: enter(pLockInfo), enter(unixBigLock)

*/

static sqlite3_mutex *unixBigLock = 0;

static void unixEnterMutex(void){

assert( sqlite3_mutex_notheld(unixBigLock) ); /* Not a recursive mutex */

sqlite3_mutex_enter(unixBigLock);

}

static void unixLeaveMutex(void){

assert( sqlite3_mutex_held(unixBigLock) );

sqlite3_mutex_leave(unixBigLock);

}

#ifdef SQLITE_DEBUG

static int unixMutexHeld(void) {

return sqlite3_mutex_held(unixBigLock);

}

#endif

#ifdef SQLITE_HAVE_OS_TRACE

/*

** Helper function for printing out trace information from debugging

** binaries. This returns the string representation of the supplied

** integer lock-type.

*/

static const char *azFileLock(int eFileLock){

switch( eFileLock ){

case NO_LOCK: return "NONE";

case SHARED_LOCK: return "SHARED";

case RESERVED_LOCK: return "RESERVED";

case PENDING_LOCK: return "PENDING";

case EXCLUSIVE_LOCK: return "EXCLUSIVE";

}

return "ERROR";

}

#endif

#ifdef SQLITE_LOCK_TRACE

/*

** Print out information about all locking operations.

**

** This routine is used for troubleshooting locks on multithreaded

** platforms. Enable by compiling with the -DSQLITE_LOCK_TRACE

** command-line option on the compiler. This code is normally

** turned off.

*/

static int lockTrace(int fd, int op, struct flock *p){

char *zOpName, *zType;

int s;

int savedErrno;

if( op==F_GETLK ){

zOpName = "GETLK";

}else if( op==F_SETLK ){

zOpName = "SETLK";

}else{

s = osFcntl(fd, op, p);

sqlite3DebugPrintf("fcntl unknown %d %d %d\n", fd, op, s);

return s;

}

if( p->l_type==F_RDLCK ){

zType = "RDLCK";

}else if( p->l_type==F_WRLCK ){

zType = "WRLCK";

}else if( p->l_type==F_UNLCK ){

zType = "UNLCK";

}else{

assert( 0 );

}

assert( p->l_whence==SEEK_SET );

s = osFcntl(fd, op, p);

savedErrno = errno;

sqlite3DebugPrintf("fcntl %d %d %s %s %d %d %d %d\n",

threadid, fd, zOpName, zType, (int)p->l_start, (int)p->l_len,

(int)p->l_pid, s);

if( s==(-1) && op==F_SETLK && (p->l_type==F_RDLCK || p->l_type==F_WRLCK) ){

struct flock l2;

l2 = *p;

osFcntl(fd, F_GETLK, &l2);

if( l2.l_type==F_RDLCK ){

zType = "RDLCK";

}else if( l2.l_type==F_WRLCK ){

zType = "WRLCK";

}else if( l2.l_type==F_UNLCK ){

zType = "UNLCK";

}else{

assert( 0 );

}

sqlite3DebugPrintf("fcntl-failure-reason: %s %d %d %d\n",

zType, (int)l2.l_start, (int)l2.l_len, (int)l2.l_pid);

}

errno = savedErrno;

return s;

}

#undef osFcntl

#define osFcntl lockTrace

#endif /* SQLITE_LOCK_TRACE */

/*

** Retry ftruncate() calls that fail due to EINTR

**

** All calls to ftruncate() within this file should be made through

** this wrapper. On the Android platform, bypassing the logic below

** could lead to a corrupt database.

*/

static int robust_ftruncate(int h, sqlite3_int64 sz){

int rc;