/*

** 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 labeled.

**

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

/*

** Define the OS_VXWORKS pre-processor macro to 1 if building on

** vxworks, or 0 otherwise.

*/

#ifndef OS_VXWORKS

# if defined(__RTP__) || defined(_WRS_KERNEL)

# define OS_VXWORKS 1

# else

# define OS_VXWORKS 0

# endif

#endif

/*

** These #defines should enable >2GB file support on Posix if the

** underlying operating system supports it. If the OS lacks

** large file support, these should be no-ops.

**

** Large file support can be disabled using the -DSQLITE_DISABLE_LFS switch

** on the compiler command line. This is necessary if you are compiling

** on a recent machine (ex: RedHat 7.2) but you want your code to work

** on an older machine (ex: RedHat 6.0). If you compile on RedHat 7.2

** without this option, LFS is enable. But LFS does not exist in the kernel

** in RedHat 6.0, so the code won't work. Hence, for maximum binary

** portability you should omit LFS.

**

** The previous paragraph was written in 2005. (This paragraph is written

** on 2008-11-28.) These days, all Linux kernels support large files, so

** you should probably leave LFS enabled. But some embedded platforms might

** lack LFS in which case the SQLITE_DISABLE_LFS macro might still be useful.

*/

#ifndef SQLITE_DISABLE_LFS

# define _LARGE_FILE 1

# ifndef _FILE_OFFSET_BITS

# define _FILE_OFFSET_BITS 64

# endif

# define _LARGEFILE_SOURCE 1

#endif

/*

** standard include files.

*/

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <unistd.h>

#include <time.h>

#include <sys/time.h>

#include <errno.h>

#ifndef SQLITE_OMIT_WAL

#include <sys/mman.h>

#endif

#if SQLITE_ENABLE_LOCKING_STYLE

# include <sys/ioctl.h>

# if OS_VXWORKS

# include <semaphore.h>

# include <limits.h>

# else

# include <sys/file.h>

# include <sys/param.h>

# endif

#endif /* SQLITE_ENABLE_LOCKING_STYLE */

#if defined(__APPLE__) || (SQLITE_ENABLE_LOCKING_STYLE && !OS_VXWORKS)

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

** the SQLITE_UNIX_THREADS macro.

*/

#if SQLITE_THREADSAFE

# include <pthread.h>

# define SQLITE_UNIX_THREADS 1

#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

/*

** 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 *pUnused; /* 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_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

#if OS_VXWORKS

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

#endif

#ifndef NDEBUG

/* 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

};

/*

** 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 */

#ifndef SQLITE_DISABLE_DIRSYNC

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

#define UNIXFILE_CHOWN 0x100 /* File ownership was changed */

/*

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

/*

** 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*);

/*

** 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 sytem 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,off_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,off_t))\

aSyscall[13].pCurrent)

#if SQLITE_ENABLE_LOCKING_STYLE

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

#else

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

#endif

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

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

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

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

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

#define osUmask ((mode_t(*)(mode_t))aSyscall[21].pCurrent)

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

/*

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

** "unix" VFSes. Return SQLITE_OK opon 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;

}

/*

** 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;

mode_t origM = 0;

if( m==0 ){

m2 = SQLITE_DEFAULT_FILE_PERMISSIONS;

}else{

m2 = m;

origM = osUmask(0);

}

do{

#if defined(O_CLOEXEC)

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

#else

fd = osOpen(z,f,m2);

#endif

}while( fd<0 && errno==EINTR );

if( m ){

osUmask(origM);

}

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

if( fd>=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 and

** vxworksFileId 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()

*/

static void unixEnterMutex(void){

sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));

}

static void unixLeaveMutex(void){

sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));

}

#ifdef SQLITE_DEBUG

static int unixMutexHeld(void) {

return sqlite3_mutex_held(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));

}

#endif

#if defined(SQLITE_TEST) && defined(SQLITE_DEBUG)

/*

** Helper function for printing out trace information from debugging

** binaries. This returns the string represetation 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

*/

static int robust_ftruncate(int h, sqlite3_int64 sz){

int rc;

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

return rc;

}

/*

** This routine translates a standard POSIX errno code into something

** useful to the clients of the sqlite3 functions. Specifically, it is

** intended to translate a variety of "try again" errors into SQLITE_BUSY

** and a variety of "please close the file descriptor NOW" errors into

** SQLITE_IOERR

**

** Errors during initialization of locks, or file system support for locks,

** should handle ENOLCK, ENOTSUP, EOPNOTSUPP separately.

*/

static int sqliteErrorFromPosixError(int posixError, int sqliteIOErr) {

switch (posixError) {

#if 0

/* At one point this code was not commented out. In theory, this branch

** should never be hit, as this function should only be called after

** a locking-related function (i.e. fcntl()) has returned non-zero with

** the value of errno as the first argument. Since a system call has failed,

** errno should be non-zero.

**

** Despite this, if errno really is zero, we still don't want to return

** SQLITE_OK. The system call failed, and *some* SQLite error should be

** propagated back to the caller. Commenting this branch out means errno==0

** will be handled by the "default:" case below.

*/

case 0:

return SQLITE_OK;

#endif

case EAGAIN:

case ETIMEDOUT:

case EBUSY:

case EINTR:

case ENOLCK:

/* random NFS retry error, unless during file system support

* introspection, in which it actually means what it says */

return SQLITE_BUSY;

case EACCES:

/* EACCES is like EAGAIN during locking operations, but not any other time*/

if( (sqliteIOErr == SQLITE_IOERR_LOCK) ||

(sqliteIOErr == SQLITE_IOERR_UNLOCK) ||

(sqliteIOErr == SQLITE_IOERR_RDLOCK) ||

(sqliteIOErr == SQLITE_IOERR_CHECKRESERVEDLOCK) ){

return SQLITE_BUSY;

}

/* else fall through */

case EPERM:

return SQLITE_PERM;

/* EDEADLK is only possible if a call to fcntl(F_SETLKW) is made. And

** this module never makes such a call. And the code in SQLite itself

** asserts that SQLITE_IOERR_BLOCKED is never returned. For these reasons

** this case is also commented out. If the system does set errno to EDEADLK,

** the default SQLITE_IOERR_XXX code will be returned. */

#if 0

case EDEADLK:

return SQLITE_IOERR_BLOCKED;

#endif

#if EOPNOTSUPP!=ENOTSUP

case EOPNOTSUPP:

/* something went terribly awry, unless during file system support

* introspection, in which it actually means what it says */

#endif

#ifdef ENOTSUP

case ENOTSUP:

/* invalid fd, unless during file system support introspection, in which

* it actually means what it says */

#endif

case EIO:

case EBADF:

case EINVAL:

case ENOTCONN:

case ENODEV:

case ENXIO:

case ENOENT:

#ifdef ESTALE /* ESTALE is not defined on Interix systems */

case ESTALE:

#endif

case ENOSYS:

/* these should force the client to close the file and reconnect */

default:

return sqliteIOErr;

}

}

/******************************************************************************

****************** Begin Unique File ID Utility Used By VxWorks ***************

**

** On most versions of unix, we can get a unique ID for a file by concatenating

** the device number and the inode number. But this does not work on VxWorks.

** On VxWorks, a unique file id must be based on the canonical filename.

**

** A pointer to an instance of the following structure can be used as a

** unique file ID in VxWorks. Each instance of this structure contains

** a copy of the canonical filename. There is also a reference count.

** The structure is reclaimed when the number of pointers to it drops to

** zero.

**

** There are never very many files open at one time and lookups are not

** a performance-critical path, so it is sufficient to put these

** structures on a linked list.

*/

struct vxworksFileId {

struct vxworksFileId *pNext; /* Next in a list of them all */

int nRef; /* Number of references to this one */

int nName; /* Length of the zCanonicalName[] string */

char *zCanonicalName; /* Canonical filename */

};

#if OS_VXWORKS

/*

** All unique filenames are held on a linked list headed by this

** variable:

*/

static struct vxworksFileId *vxworksFileList = 0;

/*

** Simplify a filename into its canonical form

** by making the following changes:

**

** * removing any trailing and duplicate /

** * convert /./ into just /

** * convert /A/../ where A is any simple name into just /

**

** Changes are made in-place. Return the new name length.

**

** The original filename is in z[0..n-1]. Return the number of

** characters in the simplified name.

*/

static int vxworksSimplifyName(char *z, int n){

int i, j;

while( n>1 && z[n-1]=='/' ){ n--; }

for(i=j=0; i<n; i++){

if( z[i]=='/' ){

if( z[i+1]=='/' ) continue;

if( z[i+1]=='.' && i+2<n && z[i+2]=='/' ){

i += 1;

continue;

}

if( z[i+1]=='.' && i+3<n && z[i+2]=='.' && z[i+3]=='/' ){

while( j>0 && z[j-1]!='/' ){ j--; }

if( j>0 ){ j--; }

i += 2;

continue;

}

}

z[j++] = z[i];

}

z[j] = 0;

return j;

}

/*

** Find a unique file ID for the given absolute pathname. Return

** a pointer to the vxworksFileId object. This pointer is the unique

** file ID.

**

** The nRef field of the vxworksFileId object is incremented before

** the object is returned. A new vxworksFileId object is created

** and added to the global list if necessary.

**

** If a memory allocation error occurs, return NULL.

*/

static struct vxworksFileId *vxworksFindFileId(const char *zAbsoluteName){

struct vxworksFileId *pNew; /* search key and new file ID */

struct vxworksFileId *pCandidate; /* For looping over existing file IDs */

int n; /* Length of zAbsoluteName string */

assert( zAbsoluteName[0]=='/' );

n = (int)strlen(zAbsoluteName);

pNew = sqlite3_malloc( sizeof(*pNew) + (n+1) );

if( pNew==0 ) return 0;

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

memcpy(pNew->zCanonicalName, zAbsoluteName, n+1);

n = vxworksSimplifyName(pNew->zCanonicalName, n);

/* Search for an existing entry that matching the canonical name.

** If found, increment the reference count and return a pointer to

** the existing file ID.

*/

unixEnterMutex();

for(pCandidate=vxworksFileList; pCandidate; pCandidate=pCandidate->pNext){

if( pCandidate->nName==n

&& memcmp(pCandidate->zCanonicalName, pNew->zCanonicalName, n)==0

){

sqlite3_free(pNew);

pCandidate->nRef++;

unixLeaveMutex();

return pCandidate;

}

}

/* No match was found. We will make a new file ID */

pNew->nRef = 1;

pNew->nName = n;

pNew->pNext = vxworksFileList;

vxworksFileList = pNew;

unixLeaveMutex();

return pNew;

}

/*

** Decrement the reference count on a vxworksFileId object. Free

** the object when the reference count reaches zero.

*/

static void vxworksReleaseFileId(struct vxworksFileId *pId){

unixEnterMutex();

assert( pId->nRef>0 );

pId->nRef--;

if( pId->nRef==0 ){

struct vxworksFileId **pp;

for(pp=&vxworksFileList; *pp && *pp!=pId; pp = &((*pp)->pNext)){}

assert( *pp==pId );

*pp = pId->pNext;

sqlite3_free(pId);

}

unixLeaveMutex();

}

#endif /* OS_VXWORKS */

/*************** End of Unique File ID Utility Used By VxWorks ****************

******************************************************************************/

/******************************************************************************

*************************** Posix Advisory Locking ****************************

**

** POSIX advisory locks are broken by design. ANSI STD 1003.1 (1996)

** section 6.5.2.2 lines 483 through 490 specify that when a process

** sets or clears a lock, that operation overrides any prior locks set

** by the same process. It does not explicitly say so, but this implies

** that it overrides locks set by the same process using a different

** file descriptor. Consider this test case:

**

** int fd1 = open("./file1", O_RDWR|O_CREAT, 0644);

** int fd2 = open("./file2", O_RDWR|O_CREAT, 0644);

**

** Suppose ./file1 and ./file2 are really the same file (because

** one is a hard or symbolic link to the other) then if you set

** an exclusive lock on fd1, then try to get an exclusive lock

** on fd2, it works. I would have expected the second lock to

** fail since there was already a lock on the file due to fd1.

** But not so. Since both locks came from the same process, the

** second overrides the first, even though they were on different

** file descriptors opened on different file names.

**

** This means that we cannot use POSIX locks to synchronize file access

** among competing threads of the same process. POSIX locks will work fine

** to synchronize access for threads in separate processes, but not

** threads within the same process.

**

** To work around the problem, SQLite has to manage file locks internally

** on its own. Whenever a new database is opened, we have to find the

** specific inode of the database file (the inode is determined by the

** st_dev and st_ino fields of the stat structure that fstat() fills in)

** and check for locks already existing on that inode. When locks are

** created or removed, we have to look at our own internal record of the

** locks to see if another thread has previously set a lock on that same

** inode.

**

** (Aside: The use of inode numbers as unique IDs does not work on VxWorks.

** For VxWorks, we have to use the alternative unique ID system based on

** canonical filename and implemented in the previous division.)

**

** The sqlite3_file structure for POSIX is no longer just an integer file

** descriptor. It is now a structure that holds the integer file

** descriptor and a pointer to a structure that describes the internal

** locks on the corresponding inode. There is one locking structure

** per inode, so if the same inode is opened twice, both unixFile structures

** point to the same locking structure. The locking structure keeps

** a reference count (so we will know when to delete it) and a "cnt"

** field that tells us its internal lock status. cnt==0 means the

** file is unlocked. cnt==-1 means the file has an exclusive lock.

** cnt>0 means there are cnt shared locks on the file.

**

** Any attempt to lock or unlock a file first checks the locking

** structure. The fcntl() system call is only invoked to set a

** POSIX lock if the internal lock structure transitions between

** a locked and an unlocked state.

**

** But wait: there are yet more problems with POSIX advisory locks.

**

** If you close a file descriptor that points to a file that has locks,

** all locks on that file that are owned by the current process are

** released. To work around this problem, each unixInodeInfo object

** maintains a count of the number of pending locks on tha inode.

** When an attempt is made to close an unixFile, if there are

** other unixFile open on the same inode that are holding locks, the call

** to close() the file descriptor is deferred until all of the locks clear.

** The unixInodeInfo structure keeps a list of file descriptors that need to

** be closed and that list is walked (and cleared) when the last lock

** clears.

**

** Yet another problem: LinuxThreads do not play well with posix locks.

**

** Many older versions of linux use the LinuxThreads library which is

** not posix compliant. Under LinuxThreads, a lock created by thread

** A cannot be modified or overridden by a different thread B.

** Only thread A can modify the lock. Locking behavior is correct

** if the appliation uses the newer Native Posix Thread Library (NPTL)

** on linux - with NPTL a lock created by thread A can override locks

** in thread B. But there is no way to know at compile-time which

** threading library is being used. So there is no way to know at

** compile-time whether or not thread A can override locks on thread B.

** One has to do a run-time check to discover the behavior of the

** current process.

**

** SQLite used to support LinuxThreads. But support for LinuxThreads

** was dropped beginning with version 3.7.0. SQLite will still work with

** LinuxThreads provided that (1) there is no more than one connection

** per database file in the same process and (2) database connections

** do not move across threads.

*/

/*

** An instance of the following structure serves as the key used

** to locate a particular unixInodeInfo object.

*/

struct unixFileId {

dev_t dev; /* Device number */

#if OS_VXWORKS

struct vxworksFileId *pId; /* Unique file ID for vxworks. */

#else

ino_t ino; /* Inode number */

#endif

};

/*