1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/extensions/sqlite/sqlite-source/os_unix.c Sun Mar 30 07:00:22 2008 +0000
1.3 @@ -0,0 +1,2749 @@
1.4 +/*
1.5 +** 2004 May 22
1.6 +**
1.7 +** The author disclaims copyright to this source code. In place of
1.8 +** a legal notice, here is a blessing:
1.9 +**
1.10 +** May you do good and not evil.
1.11 +** May you find forgiveness for yourself and forgive others.
1.12 +** May you share freely, never taking more than you give.
1.13 +**
1.14 +******************************************************************************
1.15 +**
1.16 +** This file contains code that is specific to Unix systems.
1.17 +*/
1.18 +#include "sqliteInt.h"
1.19 +#if OS_UNIX /* This file is used on unix only */
1.20 +
1.21 +/* #define SQLITE_ENABLE_LOCKING_STYLE 0 */
1.22 +
1.23 +/*
1.24 +** These #defines should enable >2GB file support on Posix if the
1.25 +** underlying operating system supports it. If the OS lacks
1.26 +** large file support, these should be no-ops.
1.27 +**
1.28 +** Large file support can be disabled using the -DSQLITE_DISABLE_LFS switch
1.29 +** on the compiler command line. This is necessary if you are compiling
1.30 +** on a recent machine (ex: RedHat 7.2) but you want your code to work
1.31 +** on an older machine (ex: RedHat 6.0). If you compile on RedHat 7.2
1.32 +** without this option, LFS is enable. But LFS does not exist in the kernel
1.33 +** in RedHat 6.0, so the code won't work. Hence, for maximum binary
1.34 +** portability you should omit LFS.
1.35 +*/
1.36 +#ifndef SQLITE_DISABLE_LFS
1.37 +# define _LARGE_FILE 1
1.38 +# ifndef _FILE_OFFSET_BITS
1.39 +# define _FILE_OFFSET_BITS 64
1.40 +# endif
1.41 +# define _LARGEFILE_SOURCE 1
1.42 +#endif
1.43 +
1.44 +/*
1.45 +** standard include files.
1.46 +*/
1.47 +#include <sys/types.h>
1.48 +#include <sys/stat.h>
1.49 +#include <fcntl.h>
1.50 +#include <unistd.h>
1.51 +#include <time.h>
1.52 +#include <sys/time.h>
1.53 +#include <errno.h>
1.54 +#ifdef SQLITE_ENABLE_LOCKING_STYLE
1.55 +#include <sys/ioctl.h>
1.56 +#include <sys/param.h>
1.57 +#include <sys/mount.h>
1.58 +#endif /* SQLITE_ENABLE_LOCKING_STYLE */
1.59 +
1.60 +/*
1.61 +** If we are to be thread-safe, include the pthreads header and define
1.62 +** the SQLITE_UNIX_THREADS macro.
1.63 +*/
1.64 +#if SQLITE_THREADSAFE
1.65 +# include <pthread.h>
1.66 +# define SQLITE_UNIX_THREADS 1
1.67 +#endif
1.68 +
1.69 +/*
1.70 +** Default permissions when creating a new file
1.71 +*/
1.72 +#ifndef SQLITE_DEFAULT_FILE_PERMISSIONS
1.73 +# define SQLITE_DEFAULT_FILE_PERMISSIONS 0644
1.74 +#endif
1.75 +
1.76 +/*
1.77 +** Maximum supported path-length.
1.78 +*/
1.79 +#define MAX_PATHNAME 512
1.80 +
1.81 +
1.82 +/*
1.83 +** The unixFile structure is subclass of sqlite3_file specific for the unix
1.84 +** protability layer.
1.85 +*/
1.86 +typedef struct unixFile unixFile;
1.87 +struct unixFile {
1.88 + sqlite3_io_methods const *pMethod; /* Always the first entry */
1.89 +#ifdef SQLITE_TEST
1.90 + /* In test mode, increase the size of this structure a bit so that
1.91 + ** it is larger than the struct CrashFile defined in test6.c.
1.92 + */
1.93 + char aPadding[32];
1.94 +#endif
1.95 + struct openCnt *pOpen; /* Info about all open fd's on this inode */
1.96 + struct lockInfo *pLock; /* Info about locks on this inode */
1.97 +#ifdef SQLITE_ENABLE_LOCKING_STYLE
1.98 + void *lockingContext; /* Locking style specific state */
1.99 +#endif /* SQLITE_ENABLE_LOCKING_STYLE */
1.100 + int h; /* The file descriptor */
1.101 + unsigned char locktype; /* The type of lock held on this fd */
1.102 + int dirfd; /* File descriptor for the directory */
1.103 +#if SQLITE_THREADSAFE
1.104 + pthread_t tid; /* The thread that "owns" this unixFile */
1.105 +#endif
1.106 +};
1.107 +
1.108 +/*
1.109 +** Include code that is common to all os_*.c files
1.110 +*/
1.111 +#include "os_common.h"
1.112 +
1.113 +/*
1.114 +** Define various macros that are missing from some systems.
1.115 +*/
1.116 +#ifndef O_LARGEFILE
1.117 +# define O_LARGEFILE 0
1.118 +#endif
1.119 +#ifdef SQLITE_DISABLE_LFS
1.120 +# undef O_LARGEFILE
1.121 +# define O_LARGEFILE 0
1.122 +#endif
1.123 +#ifndef O_NOFOLLOW
1.124 +# define O_NOFOLLOW 0
1.125 +#endif
1.126 +#ifndef O_BINARY
1.127 +# define O_BINARY 0
1.128 +#endif
1.129 +
1.130 +/*
1.131 +** The DJGPP compiler environment looks mostly like Unix, but it
1.132 +** lacks the fcntl() system call. So redefine fcntl() to be something
1.133 +** that always succeeds. This means that locking does not occur under
1.134 +** DJGPP. But it's DOS - what did you expect?
1.135 +*/
1.136 +#ifdef __DJGPP__
1.137 +# define fcntl(A,B,C) 0
1.138 +#endif
1.139 +
1.140 +/*
1.141 +** The threadid macro resolves to the thread-id or to 0. Used for
1.142 +** testing and debugging only.
1.143 +*/
1.144 +#if SQLITE_THREADSAFE
1.145 +#define threadid pthread_self()
1.146 +#else
1.147 +#define threadid 0
1.148 +#endif
1.149 +
1.150 +/*
1.151 +** Set or check the unixFile.tid field. This field is set when an unixFile
1.152 +** is first opened. All subsequent uses of the unixFile verify that the
1.153 +** same thread is operating on the unixFile. Some operating systems do
1.154 +** not allow locks to be overridden by other threads and that restriction
1.155 +** means that sqlite3* database handles cannot be moved from one thread
1.156 +** to another. This logic makes sure a user does not try to do that
1.157 +** by mistake.
1.158 +**
1.159 +** Version 3.3.1 (2006-01-15): unixFile can be moved from one thread to
1.160 +** another as long as we are running on a system that supports threads
1.161 +** overriding each others locks (which now the most common behavior)
1.162 +** or if no locks are held. But the unixFile.pLock field needs to be
1.163 +** recomputed because its key includes the thread-id. See the
1.164 +** transferOwnership() function below for additional information
1.165 +*/
1.166 +#if SQLITE_THREADSAFE
1.167 +# define SET_THREADID(X) (X)->tid = pthread_self()
1.168 +# define CHECK_THREADID(X) (threadsOverrideEachOthersLocks==0 && \
1.169 + !pthread_equal((X)->tid, pthread_self()))
1.170 +#else
1.171 +# define SET_THREADID(X)
1.172 +# define CHECK_THREADID(X) 0
1.173 +#endif
1.174 +
1.175 +/*
1.176 +** Here is the dirt on POSIX advisory locks: ANSI STD 1003.1 (1996)
1.177 +** section 6.5.2.2 lines 483 through 490 specify that when a process
1.178 +** sets or clears a lock, that operation overrides any prior locks set
1.179 +** by the same process. It does not explicitly say so, but this implies
1.180 +** that it overrides locks set by the same process using a different
1.181 +** file descriptor. Consider this test case:
1.182 +**
1.183 +** int fd1 = open("./file1", O_RDWR|O_CREAT, 0644);
1.184 +** int fd2 = open("./file2", O_RDWR|O_CREAT, 0644);
1.185 +**
1.186 +** Suppose ./file1 and ./file2 are really the same file (because
1.187 +** one is a hard or symbolic link to the other) then if you set
1.188 +** an exclusive lock on fd1, then try to get an exclusive lock
1.189 +** on fd2, it works. I would have expected the second lock to
1.190 +** fail since there was already a lock on the file due to fd1.
1.191 +** But not so. Since both locks came from the same process, the
1.192 +** second overrides the first, even though they were on different
1.193 +** file descriptors opened on different file names.
1.194 +**
1.195 +** Bummer. If you ask me, this is broken. Badly broken. It means
1.196 +** that we cannot use POSIX locks to synchronize file access among
1.197 +** competing threads of the same process. POSIX locks will work fine
1.198 +** to synchronize access for threads in separate processes, but not
1.199 +** threads within the same process.
1.200 +**
1.201 +** To work around the problem, SQLite has to manage file locks internally
1.202 +** on its own. Whenever a new database is opened, we have to find the
1.203 +** specific inode of the database file (the inode is determined by the
1.204 +** st_dev and st_ino fields of the stat structure that fstat() fills in)
1.205 +** and check for locks already existing on that inode. When locks are
1.206 +** created or removed, we have to look at our own internal record of the
1.207 +** locks to see if another thread has previously set a lock on that same
1.208 +** inode.
1.209 +**
1.210 +** The sqlite3_file structure for POSIX is no longer just an integer file
1.211 +** descriptor. It is now a structure that holds the integer file
1.212 +** descriptor and a pointer to a structure that describes the internal
1.213 +** locks on the corresponding inode. There is one locking structure
1.214 +** per inode, so if the same inode is opened twice, both unixFile structures
1.215 +** point to the same locking structure. The locking structure keeps
1.216 +** a reference count (so we will know when to delete it) and a "cnt"
1.217 +** field that tells us its internal lock status. cnt==0 means the
1.218 +** file is unlocked. cnt==-1 means the file has an exclusive lock.
1.219 +** cnt>0 means there are cnt shared locks on the file.
1.220 +**
1.221 +** Any attempt to lock or unlock a file first checks the locking
1.222 +** structure. The fcntl() system call is only invoked to set a
1.223 +** POSIX lock if the internal lock structure transitions between
1.224 +** a locked and an unlocked state.
1.225 +**
1.226 +** 2004-Jan-11:
1.227 +** More recent discoveries about POSIX advisory locks. (The more
1.228 +** I discover, the more I realize the a POSIX advisory locks are
1.229 +** an abomination.)
1.230 +**
1.231 +** If you close a file descriptor that points to a file that has locks,
1.232 +** all locks on that file that are owned by the current process are
1.233 +** released. To work around this problem, each unixFile structure contains
1.234 +** a pointer to an openCnt structure. There is one openCnt structure
1.235 +** per open inode, which means that multiple unixFile can point to a single
1.236 +** openCnt. When an attempt is made to close an unixFile, if there are
1.237 +** other unixFile open on the same inode that are holding locks, the call
1.238 +** to close() the file descriptor is deferred until all of the locks clear.
1.239 +** The openCnt structure keeps a list of file descriptors that need to
1.240 +** be closed and that list is walked (and cleared) when the last lock
1.241 +** clears.
1.242 +**
1.243 +** First, under Linux threads, because each thread has a separate
1.244 +** process ID, lock operations in one thread do not override locks
1.245 +** to the same file in other threads. Linux threads behave like
1.246 +** separate processes in this respect. But, if you close a file
1.247 +** descriptor in linux threads, all locks are cleared, even locks
1.248 +** on other threads and even though the other threads have different
1.249 +** process IDs. Linux threads is inconsistent in this respect.
1.250 +** (I'm beginning to think that linux threads is an abomination too.)
1.251 +** The consequence of this all is that the hash table for the lockInfo
1.252 +** structure has to include the process id as part of its key because
1.253 +** locks in different threads are treated as distinct. But the
1.254 +** openCnt structure should not include the process id in its
1.255 +** key because close() clears lock on all threads, not just the current
1.256 +** thread. Were it not for this goofiness in linux threads, we could
1.257 +** combine the lockInfo and openCnt structures into a single structure.
1.258 +**
1.259 +** 2004-Jun-28:
1.260 +** On some versions of linux, threads can override each others locks.
1.261 +** On others not. Sometimes you can change the behavior on the same
1.262 +** system by setting the LD_ASSUME_KERNEL environment variable. The
1.263 +** POSIX standard is silent as to which behavior is correct, as far
1.264 +** as I can tell, so other versions of unix might show the same
1.265 +** inconsistency. There is no little doubt in my mind that posix
1.266 +** advisory locks and linux threads are profoundly broken.
1.267 +**
1.268 +** To work around the inconsistencies, we have to test at runtime
1.269 +** whether or not threads can override each others locks. This test
1.270 +** is run once, the first time any lock is attempted. A static
1.271 +** variable is set to record the results of this test for future
1.272 +** use.
1.273 +*/
1.274 +
1.275 +/*
1.276 +** An instance of the following structure serves as the key used
1.277 +** to locate a particular lockInfo structure given its inode.
1.278 +**
1.279 +** If threads cannot override each others locks, then we set the
1.280 +** lockKey.tid field to the thread ID. If threads can override
1.281 +** each others locks then tid is always set to zero. tid is omitted
1.282 +** if we compile without threading support.
1.283 +*/
1.284 +struct lockKey {
1.285 + dev_t dev; /* Device number */
1.286 + ino_t ino; /* Inode number */
1.287 +#if SQLITE_THREADSAFE
1.288 + pthread_t tid; /* Thread ID or zero if threads can override each other */
1.289 +#endif
1.290 +};
1.291 +
1.292 +/*
1.293 +** An instance of the following structure is allocated for each open
1.294 +** inode on each thread with a different process ID. (Threads have
1.295 +** different process IDs on linux, but not on most other unixes.)
1.296 +**
1.297 +** A single inode can have multiple file descriptors, so each unixFile
1.298 +** structure contains a pointer to an instance of this object and this
1.299 +** object keeps a count of the number of unixFile pointing to it.
1.300 +*/
1.301 +struct lockInfo {
1.302 + struct lockKey key; /* The lookup key */
1.303 + int cnt; /* Number of SHARED locks held */
1.304 + int locktype; /* One of SHARED_LOCK, RESERVED_LOCK etc. */
1.305 + int nRef; /* Number of pointers to this structure */
1.306 +};
1.307 +
1.308 +/*
1.309 +** An instance of the following structure serves as the key used
1.310 +** to locate a particular openCnt structure given its inode. This
1.311 +** is the same as the lockKey except that the thread ID is omitted.
1.312 +*/
1.313 +struct openKey {
1.314 + dev_t dev; /* Device number */
1.315 + ino_t ino; /* Inode number */
1.316 +};
1.317 +
1.318 +/*
1.319 +** An instance of the following structure is allocated for each open
1.320 +** inode. This structure keeps track of the number of locks on that
1.321 +** inode. If a close is attempted against an inode that is holding
1.322 +** locks, the close is deferred until all locks clear by adding the
1.323 +** file descriptor to be closed to the pending list.
1.324 +*/
1.325 +struct openCnt {
1.326 + struct openKey key; /* The lookup key */
1.327 + int nRef; /* Number of pointers to this structure */
1.328 + int nLock; /* Number of outstanding locks */
1.329 + int nPending; /* Number of pending close() operations */
1.330 + int *aPending; /* Malloced space holding fd's awaiting a close() */
1.331 +};
1.332 +
1.333 +/*
1.334 +** These hash tables map inodes and file descriptors (really, lockKey and
1.335 +** openKey structures) into lockInfo and openCnt structures. Access to
1.336 +** these hash tables must be protected by a mutex.
1.337 +*/
1.338 +static Hash lockHash = {SQLITE_HASH_BINARY, 0, 0, 0, 0, 0};
1.339 +static Hash openHash = {SQLITE_HASH_BINARY, 0, 0, 0, 0, 0};
1.340 +
1.341 +#ifdef SQLITE_ENABLE_LOCKING_STYLE
1.342 +/*
1.343 +** The locking styles are associated with the different file locking
1.344 +** capabilities supported by different file systems.
1.345 +**
1.346 +** POSIX locking style fully supports shared and exclusive byte-range locks
1.347 +** ADP locking only supports exclusive byte-range locks
1.348 +** FLOCK only supports a single file-global exclusive lock
1.349 +** DOTLOCK isn't a true locking style, it refers to the use of a special
1.350 +** file named the same as the database file with a '.lock' extension, this
1.351 +** can be used on file systems that do not offer any reliable file locking
1.352 +** NO locking means that no locking will be attempted, this is only used for
1.353 +** read-only file systems currently
1.354 +** UNSUPPORTED means that no locking will be attempted, this is only used for
1.355 +** file systems that are known to be unsupported
1.356 +*/
1.357 +typedef enum {
1.358 + posixLockingStyle = 0, /* standard posix-advisory locks */
1.359 + afpLockingStyle, /* use afp locks */
1.360 + flockLockingStyle, /* use flock() */
1.361 + dotlockLockingStyle, /* use <file>.lock files */
1.362 + noLockingStyle, /* useful for read-only file system */
1.363 + unsupportedLockingStyle /* indicates unsupported file system */
1.364 +} sqlite3LockingStyle;
1.365 +#endif /* SQLITE_ENABLE_LOCKING_STYLE */
1.366 +
1.367 +/*
1.368 +** Helper functions to obtain and relinquish the global mutex.
1.369 +*/
1.370 +static void enterMutex(){
1.371 + sqlite3_mutex_enter(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER));
1.372 +}
1.373 +static void leaveMutex(){
1.374 + sqlite3_mutex_leave(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER));
1.375 +}
1.376 +
1.377 +#if SQLITE_THREADSAFE
1.378 +/*
1.379 +** This variable records whether or not threads can override each others
1.380 +** locks.
1.381 +**
1.382 +** 0: No. Threads cannot override each others locks.
1.383 +** 1: Yes. Threads can override each others locks.
1.384 +** -1: We don't know yet.
1.385 +**
1.386 +** On some systems, we know at compile-time if threads can override each
1.387 +** others locks. On those systems, the SQLITE_THREAD_OVERRIDE_LOCK macro
1.388 +** will be set appropriately. On other systems, we have to check at
1.389 +** runtime. On these latter systems, SQLTIE_THREAD_OVERRIDE_LOCK is
1.390 +** undefined.
1.391 +**
1.392 +** This variable normally has file scope only. But during testing, we make
1.393 +** it a global so that the test code can change its value in order to verify
1.394 +** that the right stuff happens in either case.
1.395 +*/
1.396 +#ifndef SQLITE_THREAD_OVERRIDE_LOCK
1.397 +# define SQLITE_THREAD_OVERRIDE_LOCK -1
1.398 +#endif
1.399 +#ifdef SQLITE_TEST
1.400 +int threadsOverrideEachOthersLocks = SQLITE_THREAD_OVERRIDE_LOCK;
1.401 +#else
1.402 +static int threadsOverrideEachOthersLocks = SQLITE_THREAD_OVERRIDE_LOCK;
1.403 +#endif
1.404 +
1.405 +/*
1.406 +** This structure holds information passed into individual test
1.407 +** threads by the testThreadLockingBehavior() routine.
1.408 +*/
1.409 +struct threadTestData {
1.410 + int fd; /* File to be locked */
1.411 + struct flock lock; /* The locking operation */
1.412 + int result; /* Result of the locking operation */
1.413 +};
1.414 +
1.415 +#ifdef SQLITE_LOCK_TRACE
1.416 +/*
1.417 +** Print out information about all locking operations.
1.418 +**
1.419 +** This routine is used for troubleshooting locks on multithreaded
1.420 +** platforms. Enable by compiling with the -DSQLITE_LOCK_TRACE
1.421 +** command-line option on the compiler. This code is normally
1.422 +** turned off.
1.423 +*/
1.424 +static int lockTrace(int fd, int op, struct flock *p){
1.425 + char *zOpName, *zType;
1.426 + int s;
1.427 + int savedErrno;
1.428 + if( op==F_GETLK ){
1.429 + zOpName = "GETLK";
1.430 + }else if( op==F_SETLK ){
1.431 + zOpName = "SETLK";
1.432 + }else{
1.433 + s = fcntl(fd, op, p);
1.434 + sqlite3DebugPrintf("fcntl unknown %d %d %d\n", fd, op, s);
1.435 + return s;
1.436 + }
1.437 + if( p->l_type==F_RDLCK ){
1.438 + zType = "RDLCK";
1.439 + }else if( p->l_type==F_WRLCK ){
1.440 + zType = "WRLCK";
1.441 + }else if( p->l_type==F_UNLCK ){
1.442 + zType = "UNLCK";
1.443 + }else{
1.444 + assert( 0 );
1.445 + }
1.446 + assert( p->l_whence==SEEK_SET );
1.447 + s = fcntl(fd, op, p);
1.448 + savedErrno = errno;
1.449 + sqlite3DebugPrintf("fcntl %d %d %s %s %d %d %d %d\n",
1.450 + threadid, fd, zOpName, zType, (int)p->l_start, (int)p->l_len,
1.451 + (int)p->l_pid, s);
1.452 + if( s==(-1) && op==F_SETLK && (p->l_type==F_RDLCK || p->l_type==F_WRLCK) ){
1.453 + struct flock l2;
1.454 + l2 = *p;
1.455 + fcntl(fd, F_GETLK, &l2);
1.456 + if( l2.l_type==F_RDLCK ){
1.457 + zType = "RDLCK";
1.458 + }else if( l2.l_type==F_WRLCK ){
1.459 + zType = "WRLCK";
1.460 + }else if( l2.l_type==F_UNLCK ){
1.461 + zType = "UNLCK";
1.462 + }else{
1.463 + assert( 0 );
1.464 + }
1.465 + sqlite3DebugPrintf("fcntl-failure-reason: %s %d %d %d\n",
1.466 + zType, (int)l2.l_start, (int)l2.l_len, (int)l2.l_pid);
1.467 + }
1.468 + errno = savedErrno;
1.469 + return s;
1.470 +}
1.471 +#define fcntl lockTrace
1.472 +#endif /* SQLITE_LOCK_TRACE */
1.473 +
1.474 +/*
1.475 +** The testThreadLockingBehavior() routine launches two separate
1.476 +** threads on this routine. This routine attempts to lock a file
1.477 +** descriptor then returns. The success or failure of that attempt
1.478 +** allows the testThreadLockingBehavior() procedure to determine
1.479 +** whether or not threads can override each others locks.
1.480 +*/
1.481 +static void *threadLockingTest(void *pArg){
1.482 + struct threadTestData *pData = (struct threadTestData*)pArg;
1.483 + pData->result = fcntl(pData->fd, F_SETLK, &pData->lock);
1.484 + return pArg;
1.485 +}
1.486 +
1.487 +/*
1.488 +** This procedure attempts to determine whether or not threads
1.489 +** can override each others locks then sets the
1.490 +** threadsOverrideEachOthersLocks variable appropriately.
1.491 +*/
1.492 +static void testThreadLockingBehavior(int fd_orig){
1.493 + int fd;
1.494 + struct threadTestData d[2];
1.495 + pthread_t t[2];
1.496 +
1.497 + fd = dup(fd_orig);
1.498 + if( fd<0 ) return;
1.499 + memset(d, 0, sizeof(d));
1.500 + d[0].fd = fd;
1.501 + d[0].lock.l_type = F_RDLCK;
1.502 + d[0].lock.l_len = 1;
1.503 + d[0].lock.l_start = 0;
1.504 + d[0].lock.l_whence = SEEK_SET;
1.505 + d[1] = d[0];
1.506 + d[1].lock.l_type = F_WRLCK;
1.507 + pthread_create(&t[0], 0, threadLockingTest, &d[0]);
1.508 + pthread_create(&t[1], 0, threadLockingTest, &d[1]);
1.509 + pthread_join(t[0], 0);
1.510 + pthread_join(t[1], 0);
1.511 + close(fd);
1.512 + threadsOverrideEachOthersLocks = d[0].result==0 && d[1].result==0;
1.513 +}
1.514 +#endif /* SQLITE_THREADSAFE */
1.515 +
1.516 +/*
1.517 +** Release a lockInfo structure previously allocated by findLockInfo().
1.518 +*/
1.519 +static void releaseLockInfo(struct lockInfo *pLock){
1.520 + if (pLock == NULL)
1.521 + return;
1.522 + pLock->nRef--;
1.523 + if( pLock->nRef==0 ){
1.524 + sqlite3HashInsert(&lockHash, &pLock->key, sizeof(pLock->key), 0);
1.525 + sqlite3_free(pLock);
1.526 + }
1.527 +}
1.528 +
1.529 +/*
1.530 +** Release a openCnt structure previously allocated by findLockInfo().
1.531 +*/
1.532 +static void releaseOpenCnt(struct openCnt *pOpen){
1.533 + if (pOpen == NULL)
1.534 + return;
1.535 + pOpen->nRef--;
1.536 + if( pOpen->nRef==0 ){
1.537 + sqlite3HashInsert(&openHash, &pOpen->key, sizeof(pOpen->key), 0);
1.538 + free(pOpen->aPending);
1.539 + sqlite3_free(pOpen);
1.540 + }
1.541 +}
1.542 +
1.543 +#ifdef SQLITE_ENABLE_LOCKING_STYLE
1.544 +/*
1.545 +** Tests a byte-range locking query to see if byte range locks are
1.546 +** supported, if not we fall back to dotlockLockingStyle.
1.547 +*/
1.548 +static sqlite3LockingStyle sqlite3TestLockingStyle(
1.549 + const char *filePath,
1.550 + int fd
1.551 +){
1.552 + /* test byte-range lock using fcntl */
1.553 + struct flock lockInfo;
1.554 +
1.555 + lockInfo.l_len = 1;
1.556 + lockInfo.l_start = 0;
1.557 + lockInfo.l_whence = SEEK_SET;
1.558 + lockInfo.l_type = F_RDLCK;
1.559 +
1.560 + if( fcntl(fd, F_GETLK, &lockInfo)!=-1 ) {
1.561 + return posixLockingStyle;
1.562 + }
1.563 +
1.564 + /* testing for flock can give false positives. So if if the above test
1.565 + ** fails, then we fall back to using dot-lock style locking.
1.566 + */
1.567 + return dotlockLockingStyle;
1.568 +}
1.569 +
1.570 +/*
1.571 +** Examines the f_fstypename entry in the statfs structure as returned by
1.572 +** stat() for the file system hosting the database file, assigns the
1.573 +** appropriate locking style based on it's value. These values and
1.574 +** assignments are based on Darwin/OSX behavior and have not been tested on
1.575 +** other systems.
1.576 +*/
1.577 +static sqlite3LockingStyle sqlite3DetectLockingStyle(
1.578 + const char *filePath,
1.579 + int fd
1.580 +){
1.581 +
1.582 +#ifdef SQLITE_FIXED_LOCKING_STYLE
1.583 + return (sqlite3LockingStyle)SQLITE_FIXED_LOCKING_STYLE;
1.584 +#else
1.585 + struct statfs fsInfo;
1.586 +
1.587 + if (statfs(filePath, &fsInfo) == -1)
1.588 + return sqlite3TestLockingStyle(filePath, fd);
1.589 +
1.590 + if (fsInfo.f_flags & MNT_RDONLY)
1.591 + return noLockingStyle;
1.592 +
1.593 + if( (!strcmp(fsInfo.f_fstypename, "hfs")) ||
1.594 + (!strcmp(fsInfo.f_fstypename, "ufs")) )
1.595 + return posixLockingStyle;
1.596 +
1.597 + if(!strcmp(fsInfo.f_fstypename, "afpfs"))
1.598 + return afpLockingStyle;
1.599 +
1.600 + if(!strcmp(fsInfo.f_fstypename, "nfs"))
1.601 + return sqlite3TestLockingStyle(filePath, fd);
1.602 +
1.603 + if(!strcmp(fsInfo.f_fstypename, "smbfs"))
1.604 + return flockLockingStyle;
1.605 +
1.606 + if(!strcmp(fsInfo.f_fstypename, "msdos"))
1.607 + return dotlockLockingStyle;
1.608 +
1.609 + if(!strcmp(fsInfo.f_fstypename, "webdav"))
1.610 + return unsupportedLockingStyle;
1.611 +
1.612 + return sqlite3TestLockingStyle(filePath, fd);
1.613 +#endif /* SQLITE_FIXED_LOCKING_STYLE */
1.614 +}
1.615 +
1.616 +#endif /* SQLITE_ENABLE_LOCKING_STYLE */
1.617 +
1.618 +/*
1.619 +** Given a file descriptor, locate lockInfo and openCnt structures that
1.620 +** describes that file descriptor. Create new ones if necessary. The
1.621 +** return values might be uninitialized if an error occurs.
1.622 +**
1.623 +** Return the number of errors.
1.624 +*/
1.625 +static int findLockInfo(
1.626 + int fd, /* The file descriptor used in the key */
1.627 + struct lockInfo **ppLock, /* Return the lockInfo structure here */
1.628 + struct openCnt **ppOpen /* Return the openCnt structure here */
1.629 +){
1.630 + int rc;
1.631 + struct lockKey key1;
1.632 + struct openKey key2;
1.633 + struct stat statbuf;
1.634 + struct lockInfo *pLock;
1.635 + struct openCnt *pOpen;
1.636 + rc = fstat(fd, &statbuf);
1.637 + if( rc!=0 ) return 1;
1.638 +
1.639 + memset(&key1, 0, sizeof(key1));
1.640 + key1.dev = statbuf.st_dev;
1.641 + key1.ino = statbuf.st_ino;
1.642 +#if SQLITE_THREADSAFE
1.643 + if( threadsOverrideEachOthersLocks<0 ){
1.644 + testThreadLockingBehavior(fd);
1.645 + }
1.646 + key1.tid = threadsOverrideEachOthersLocks ? 0 : pthread_self();
1.647 +#endif
1.648 + memset(&key2, 0, sizeof(key2));
1.649 + key2.dev = statbuf.st_dev;
1.650 + key2.ino = statbuf.st_ino;
1.651 + pLock = (struct lockInfo*)sqlite3HashFind(&lockHash, &key1, sizeof(key1));
1.652 + if( pLock==0 ){
1.653 + struct lockInfo *pOld;
1.654 + pLock = sqlite3_malloc( sizeof(*pLock) );
1.655 + if( pLock==0 ){
1.656 + rc = 1;
1.657 + goto exit_findlockinfo;
1.658 + }
1.659 + pLock->key = key1;
1.660 + pLock->nRef = 1;
1.661 + pLock->cnt = 0;
1.662 + pLock->locktype = 0;
1.663 + pOld = sqlite3HashInsert(&lockHash, &pLock->key, sizeof(key1), pLock);
1.664 + if( pOld!=0 ){
1.665 + assert( pOld==pLock );
1.666 + sqlite3_free(pLock);
1.667 + rc = 1;
1.668 + goto exit_findlockinfo;
1.669 + }
1.670 + }else{
1.671 + pLock->nRef++;
1.672 + }
1.673 + *ppLock = pLock;
1.674 + if( ppOpen!=0 ){
1.675 + pOpen = (struct openCnt*)sqlite3HashFind(&openHash, &key2, sizeof(key2));
1.676 + if( pOpen==0 ){
1.677 + struct openCnt *pOld;
1.678 + pOpen = sqlite3_malloc( sizeof(*pOpen) );
1.679 + if( pOpen==0 ){
1.680 + releaseLockInfo(pLock);
1.681 + rc = 1;
1.682 + goto exit_findlockinfo;
1.683 + }
1.684 + pOpen->key = key2;
1.685 + pOpen->nRef = 1;
1.686 + pOpen->nLock = 0;
1.687 + pOpen->nPending = 0;
1.688 + pOpen->aPending = 0;
1.689 + pOld = sqlite3HashInsert(&openHash, &pOpen->key, sizeof(key2), pOpen);
1.690 + if( pOld!=0 ){
1.691 + assert( pOld==pOpen );
1.692 + sqlite3_free(pOpen);
1.693 + releaseLockInfo(pLock);
1.694 + rc = 1;
1.695 + goto exit_findlockinfo;
1.696 + }
1.697 + }else{
1.698 + pOpen->nRef++;
1.699 + }
1.700 + *ppOpen = pOpen;
1.701 + }
1.702 +
1.703 +exit_findlockinfo:
1.704 + return rc;
1.705 +}
1.706 +
1.707 +#ifdef SQLITE_DEBUG
1.708 +/*
1.709 +** Helper function for printing out trace information from debugging
1.710 +** binaries. This returns the string represetation of the supplied
1.711 +** integer lock-type.
1.712 +*/
1.713 +static const char *locktypeName(int locktype){
1.714 + switch( locktype ){
1.715 + case NO_LOCK: return "NONE";
1.716 + case SHARED_LOCK: return "SHARED";
1.717 + case RESERVED_LOCK: return "RESERVED";
1.718 + case PENDING_LOCK: return "PENDING";
1.719 + case EXCLUSIVE_LOCK: return "EXCLUSIVE";
1.720 + }
1.721 + return "ERROR";
1.722 +}
1.723 +#endif
1.724 +
1.725 +/*
1.726 +** If we are currently in a different thread than the thread that the
1.727 +** unixFile argument belongs to, then transfer ownership of the unixFile
1.728 +** over to the current thread.
1.729 +**
1.730 +** A unixFile is only owned by a thread on systems where one thread is
1.731 +** unable to override locks created by a different thread. RedHat9 is
1.732 +** an example of such a system.
1.733 +**
1.734 +** Ownership transfer is only allowed if the unixFile is currently unlocked.
1.735 +** If the unixFile is locked and an ownership is wrong, then return
1.736 +** SQLITE_MISUSE. SQLITE_OK is returned if everything works.
1.737 +*/
1.738 +#if SQLITE_THREADSAFE
1.739 +static int transferOwnership(unixFile *pFile){
1.740 + int rc;
1.741 + pthread_t hSelf;
1.742 + if( threadsOverrideEachOthersLocks ){
1.743 + /* Ownership transfers not needed on this system */
1.744 + return SQLITE_OK;
1.745 + }
1.746 + hSelf = pthread_self();
1.747 + if( pthread_equal(pFile->tid, hSelf) ){
1.748 + /* We are still in the same thread */
1.749 + OSTRACE1("No-transfer, same thread\n");
1.750 + return SQLITE_OK;
1.751 + }
1.752 + if( pFile->locktype!=NO_LOCK ){
1.753 + /* We cannot change ownership while we are holding a lock! */
1.754 + return SQLITE_MISUSE;
1.755 + }
1.756 + OSTRACE4("Transfer ownership of %d from %d to %d\n",
1.757 + pFile->h, pFile->tid, hSelf);
1.758 + pFile->tid = hSelf;
1.759 + if (pFile->pLock != NULL) {
1.760 + releaseLockInfo(pFile->pLock);
1.761 + rc = findLockInfo(pFile->h, &pFile->pLock, 0);
1.762 + OSTRACE5("LOCK %d is now %s(%s,%d)\n", pFile->h,
1.763 + locktypeName(pFile->locktype),
1.764 + locktypeName(pFile->pLock->locktype), pFile->pLock->cnt);
1.765 + return rc;
1.766 + } else {
1.767 + return SQLITE_OK;
1.768 + }
1.769 +}
1.770 +#else
1.771 + /* On single-threaded builds, ownership transfer is a no-op */
1.772 +# define transferOwnership(X) SQLITE_OK
1.773 +#endif
1.774 +
1.775 +/*
1.776 +** Seek to the offset passed as the second argument, then read cnt
1.777 +** bytes into pBuf. Return the number of bytes actually read.
1.778 +*/
1.779 +static int seekAndRead(unixFile *id, sqlite3_int64 offset, void *pBuf, int cnt){
1.780 + int got;
1.781 + i64 newOffset;
1.782 + TIMER_START;
1.783 +#if defined(USE_PREAD)
1.784 + got = pread(id->h, pBuf, cnt, offset);
1.785 + SimulateIOError( got = -1 );
1.786 +#elif defined(USE_PREAD64)
1.787 + got = pread64(id->h, pBuf, cnt, offset);
1.788 + SimulateIOError( got = -1 );
1.789 +#else
1.790 + newOffset = lseek(id->h, offset, SEEK_SET);
1.791 + SimulateIOError( newOffset-- );
1.792 + if( newOffset!=offset ){
1.793 + return -1;
1.794 + }
1.795 + got = read(id->h, pBuf, cnt);
1.796 +#endif
1.797 + TIMER_END;
1.798 + OSTRACE5("READ %-3d %5d %7lld %d\n", id->h, got, offset, TIMER_ELAPSED);
1.799 + return got;
1.800 +}
1.801 +
1.802 +/*
1.803 +** Read data from a file into a buffer. Return SQLITE_OK if all
1.804 +** bytes were read successfully and SQLITE_IOERR if anything goes
1.805 +** wrong.
1.806 +*/
1.807 +static int unixRead(
1.808 + sqlite3_file *id,
1.809 + void *pBuf,
1.810 + int amt,
1.811 + sqlite3_int64 offset
1.812 +){
1.813 + int got;
1.814 + assert( id );
1.815 + got = seekAndRead((unixFile*)id, offset, pBuf, amt);
1.816 + if( got==amt ){
1.817 + return SQLITE_OK;
1.818 + }else if( got<0 ){
1.819 + return SQLITE_IOERR_READ;
1.820 + }else{
1.821 + memset(&((char*)pBuf)[got], 0, amt-got);
1.822 + return SQLITE_IOERR_SHORT_READ;
1.823 + }
1.824 +}
1.825 +
1.826 +/*
1.827 +** Seek to the offset in id->offset then read cnt bytes into pBuf.
1.828 +** Return the number of bytes actually read. Update the offset.
1.829 +*/
1.830 +static int seekAndWrite(unixFile *id, i64 offset, const void *pBuf, int cnt){
1.831 + int got;
1.832 + i64 newOffset;
1.833 + TIMER_START;
1.834 +#if defined(USE_PREAD)
1.835 + got = pwrite(id->h, pBuf, cnt, offset);
1.836 +#elif defined(USE_PREAD64)
1.837 + got = pwrite64(id->h, pBuf, cnt, offset);
1.838 +#else
1.839 + newOffset = lseek(id->h, offset, SEEK_SET);
1.840 + if( newOffset!=offset ){
1.841 + return -1;
1.842 + }
1.843 + got = write(id->h, pBuf, cnt);
1.844 +#endif
1.845 + TIMER_END;
1.846 + OSTRACE5("WRITE %-3d %5d %7lld %d\n", id->h, got, offset, TIMER_ELAPSED);
1.847 + return got;
1.848 +}
1.849 +
1.850 +
1.851 +/*
1.852 +** Write data from a buffer into a file. Return SQLITE_OK on success
1.853 +** or some other error code on failure.
1.854 +*/
1.855 +static int unixWrite(
1.856 + sqlite3_file *id,
1.857 + const void *pBuf,
1.858 + int amt,
1.859 + sqlite3_int64 offset
1.860 +){
1.861 + int wrote = 0;
1.862 + assert( id );
1.863 + assert( amt>0 );
1.864 + while( amt>0 && (wrote = seekAndWrite((unixFile*)id, offset, pBuf, amt))>0 ){
1.865 + amt -= wrote;
1.866 + offset += wrote;
1.867 + pBuf = &((char*)pBuf)[wrote];
1.868 + }
1.869 + SimulateIOError(( wrote=(-1), amt=1 ));
1.870 + SimulateDiskfullError(( wrote=0, amt=1 ));
1.871 + if( amt>0 ){
1.872 + if( wrote<0 ){
1.873 + return SQLITE_IOERR_WRITE;
1.874 + }else{
1.875 + return SQLITE_FULL;
1.876 + }
1.877 + }
1.878 + return SQLITE_OK;
1.879 +}
1.880 +
1.881 +#ifdef SQLITE_TEST
1.882 +/*
1.883 +** Count the number of fullsyncs and normal syncs. This is used to test
1.884 +** that syncs and fullsyncs are occuring at the right times.
1.885 +*/
1.886 +int sqlite3_sync_count = 0;
1.887 +int sqlite3_fullsync_count = 0;
1.888 +#endif
1.889 +
1.890 +/*
1.891 +** Use the fdatasync() API only if the HAVE_FDATASYNC macro is defined.
1.892 +** Otherwise use fsync() in its place.
1.893 +*/
1.894 +#ifndef HAVE_FDATASYNC
1.895 +# define fdatasync fsync
1.896 +#endif
1.897 +
1.898 +/*
1.899 +** Define HAVE_FULLFSYNC to 0 or 1 depending on whether or not
1.900 +** the F_FULLFSYNC macro is defined. F_FULLFSYNC is currently
1.901 +** only available on Mac OS X. But that could change.
1.902 +*/
1.903 +#ifdef F_FULLFSYNC
1.904 +# define HAVE_FULLFSYNC 1
1.905 +#else
1.906 +# define HAVE_FULLFSYNC 0
1.907 +#endif
1.908 +
1.909 +
1.910 +/*
1.911 +** The fsync() system call does not work as advertised on many
1.912 +** unix systems. The following procedure is an attempt to make
1.913 +** it work better.
1.914 +**
1.915 +** The SQLITE_NO_SYNC macro disables all fsync()s. This is useful
1.916 +** for testing when we want to run through the test suite quickly.
1.917 +** You are strongly advised *not* to deploy with SQLITE_NO_SYNC
1.918 +** enabled, however, since with SQLITE_NO_SYNC enabled, an OS crash
1.919 +** or power failure will likely corrupt the database file.
1.920 +*/
1.921 +static int full_fsync(int fd, int fullSync, int dataOnly){
1.922 + int rc;
1.923 +
1.924 + /* Record the number of times that we do a normal fsync() and
1.925 + ** FULLSYNC. This is used during testing to verify that this procedure
1.926 + ** gets called with the correct arguments.
1.927 + */
1.928 +#ifdef SQLITE_TEST
1.929 + if( fullSync ) sqlite3_fullsync_count++;
1.930 + sqlite3_sync_count++;
1.931 +#endif
1.932 +
1.933 + /* If we compiled with the SQLITE_NO_SYNC flag, then syncing is a
1.934 + ** no-op
1.935 + */
1.936 +#ifdef SQLITE_NO_SYNC
1.937 + rc = SQLITE_OK;
1.938 +#else
1.939 +
1.940 +#if HAVE_FULLFSYNC
1.941 + if( fullSync ){
1.942 + rc = fcntl(fd, F_FULLFSYNC, 0);
1.943 + }else{
1.944 + rc = 1;
1.945 + }
1.946 + /* If the FULLFSYNC failed, fall back to attempting an fsync().
1.947 + * It shouldn't be possible for fullfsync to fail on the local
1.948 + * file system (on OSX), so failure indicates that FULLFSYNC
1.949 + * isn't supported for this file system. So, attempt an fsync
1.950 + * and (for now) ignore the overhead of a superfluous fcntl call.
1.951 + * It'd be better to detect fullfsync support once and avoid
1.952 + * the fcntl call every time sync is called.
1.953 + */
1.954 + if( rc ) rc = fsync(fd);
1.955 +
1.956 +#else
1.957 + if( dataOnly ){
1.958 + rc = fdatasync(fd);
1.959 + }else{
1.960 + rc = fsync(fd);
1.961 + }
1.962 +#endif /* HAVE_FULLFSYNC */
1.963 +#endif /* defined(SQLITE_NO_SYNC) */
1.964 +
1.965 + return rc;
1.966 +}
1.967 +
1.968 +/*
1.969 +** Make sure all writes to a particular file are committed to disk.
1.970 +**
1.971 +** If dataOnly==0 then both the file itself and its metadata (file
1.972 +** size, access time, etc) are synced. If dataOnly!=0 then only the
1.973 +** file data is synced.
1.974 +**
1.975 +** Under Unix, also make sure that the directory entry for the file
1.976 +** has been created by fsync-ing the directory that contains the file.
1.977 +** If we do not do this and we encounter a power failure, the directory
1.978 +** entry for the journal might not exist after we reboot. The next
1.979 +** SQLite to access the file will not know that the journal exists (because
1.980 +** the directory entry for the journal was never created) and the transaction
1.981 +** will not roll back - possibly leading to database corruption.
1.982 +*/
1.983 +static int unixSync(sqlite3_file *id, int flags){
1.984 + int rc;
1.985 + unixFile *pFile = (unixFile*)id;
1.986 +
1.987 + int isDataOnly = (flags&SQLITE_SYNC_DATAONLY);
1.988 + int isFullsync = (flags&0x0F)==SQLITE_SYNC_FULL;
1.989 +
1.990 + /* Check that one of SQLITE_SYNC_NORMAL or FULL was passed */
1.991 + assert((flags&0x0F)==SQLITE_SYNC_NORMAL
1.992 + || (flags&0x0F)==SQLITE_SYNC_FULL
1.993 + );
1.994 +
1.995 + assert( pFile );
1.996 + OSTRACE2("SYNC %-3d\n", pFile->h);
1.997 + rc = full_fsync(pFile->h, isFullsync, isDataOnly);
1.998 + SimulateIOError( rc=1 );
1.999 + if( rc ){
1.1000 + return SQLITE_IOERR_FSYNC;
1.1001 + }
1.1002 + if( pFile->dirfd>=0 ){
1.1003 + OSTRACE4("DIRSYNC %-3d (have_fullfsync=%d fullsync=%d)\n", pFile->dirfd,
1.1004 + HAVE_FULLFSYNC, isFullsync);
1.1005 +#ifndef SQLITE_DISABLE_DIRSYNC
1.1006 + /* The directory sync is only attempted if full_fsync is
1.1007 + ** turned off or unavailable. If a full_fsync occurred above,
1.1008 + ** then the directory sync is superfluous.
1.1009 + */
1.1010 + if( (!HAVE_FULLFSYNC || !isFullsync) && full_fsync(pFile->dirfd,0,0) ){
1.1011 + /*
1.1012 + ** We have received multiple reports of fsync() returning
1.1013 + ** errors when applied to directories on certain file systems.
1.1014 + ** A failed directory sync is not a big deal. So it seems
1.1015 + ** better to ignore the error. Ticket #1657
1.1016 + */
1.1017 + /* return SQLITE_IOERR; */
1.1018 + }
1.1019 +#endif
1.1020 + close(pFile->dirfd); /* Only need to sync once, so close the directory */
1.1021 + pFile->dirfd = -1; /* when we are done. */
1.1022 + }
1.1023 + return SQLITE_OK;
1.1024 +}
1.1025 +
1.1026 +/*
1.1027 +** Truncate an open file to a specified size
1.1028 +*/
1.1029 +static int unixTruncate(sqlite3_file *id, i64 nByte){
1.1030 + int rc;
1.1031 + assert( id );
1.1032 + rc = ftruncate(((unixFile*)id)->h, (off_t)nByte);
1.1033 + SimulateIOError( rc=1 );
1.1034 + if( rc ){
1.1035 + return SQLITE_IOERR_TRUNCATE;
1.1036 + }else{
1.1037 + return SQLITE_OK;
1.1038 + }
1.1039 +}
1.1040 +
1.1041 +/*
1.1042 +** Determine the current size of a file in bytes
1.1043 +*/
1.1044 +static int unixFileSize(sqlite3_file *id, i64 *pSize){
1.1045 + int rc;
1.1046 + struct stat buf;
1.1047 + assert( id );
1.1048 + rc = fstat(((unixFile*)id)->h, &buf);
1.1049 + SimulateIOError( rc=1 );
1.1050 + if( rc!=0 ){
1.1051 + return SQLITE_IOERR_FSTAT;
1.1052 + }
1.1053 + *pSize = buf.st_size;
1.1054 + return SQLITE_OK;
1.1055 +}
1.1056 +
1.1057 +/*
1.1058 +** This routine checks if there is a RESERVED lock held on the specified
1.1059 +** file by this or any other process. If such a lock is held, return
1.1060 +** non-zero. If the file is unlocked or holds only SHARED locks, then
1.1061 +** return zero.
1.1062 +*/
1.1063 +static int unixCheckReservedLock(sqlite3_file *id){
1.1064 + int r = 0;
1.1065 + unixFile *pFile = (unixFile*)id;
1.1066 +
1.1067 + assert( pFile );
1.1068 + enterMutex(); /* Because pFile->pLock is shared across threads */
1.1069 +
1.1070 + /* Check if a thread in this process holds such a lock */
1.1071 + if( pFile->pLock->locktype>SHARED_LOCK ){
1.1072 + r = 1;
1.1073 + }
1.1074 +
1.1075 + /* Otherwise see if some other process holds it.
1.1076 + */
1.1077 + if( !r ){
1.1078 + struct flock lock;
1.1079 + lock.l_whence = SEEK_SET;
1.1080 + lock.l_start = RESERVED_BYTE;
1.1081 + lock.l_len = 1;
1.1082 + lock.l_type = F_WRLCK;
1.1083 + fcntl(pFile->h, F_GETLK, &lock);
1.1084 + if( lock.l_type!=F_UNLCK ){
1.1085 + r = 1;
1.1086 + }
1.1087 + }
1.1088 +
1.1089 + leaveMutex();
1.1090 + OSTRACE3("TEST WR-LOCK %d %d\n", pFile->h, r);
1.1091 +
1.1092 + return r;
1.1093 +}
1.1094 +
1.1095 +/*
1.1096 +** Lock the file with the lock specified by parameter locktype - one
1.1097 +** of the following:
1.1098 +**
1.1099 +** (1) SHARED_LOCK
1.1100 +** (2) RESERVED_LOCK
1.1101 +** (3) PENDING_LOCK
1.1102 +** (4) EXCLUSIVE_LOCK
1.1103 +**
1.1104 +** Sometimes when requesting one lock state, additional lock states
1.1105 +** are inserted in between. The locking might fail on one of the later
1.1106 +** transitions leaving the lock state different from what it started but
1.1107 +** still short of its goal. The following chart shows the allowed
1.1108 +** transitions and the inserted intermediate states:
1.1109 +**
1.1110 +** UNLOCKED -> SHARED
1.1111 +** SHARED -> RESERVED
1.1112 +** SHARED -> (PENDING) -> EXCLUSIVE
1.1113 +** RESERVED -> (PENDING) -> EXCLUSIVE
1.1114 +** PENDING -> EXCLUSIVE
1.1115 +**
1.1116 +** This routine will only increase a lock. Use the sqlite3OsUnlock()
1.1117 +** routine to lower a locking level.
1.1118 +*/
1.1119 +static int unixLock(sqlite3_file *id, int locktype){
1.1120 + /* The following describes the implementation of the various locks and
1.1121 + ** lock transitions in terms of the POSIX advisory shared and exclusive
1.1122 + ** lock primitives (called read-locks and write-locks below, to avoid
1.1123 + ** confusion with SQLite lock names). The algorithms are complicated
1.1124 + ** slightly in order to be compatible with windows systems simultaneously
1.1125 + ** accessing the same database file, in case that is ever required.
1.1126 + **
1.1127 + ** Symbols defined in os.h indentify the 'pending byte' and the 'reserved
1.1128 + ** byte', each single bytes at well known offsets, and the 'shared byte
1.1129 + ** range', a range of 510 bytes at a well known offset.
1.1130 + **
1.1131 + ** To obtain a SHARED lock, a read-lock is obtained on the 'pending
1.1132 + ** byte'. If this is successful, a random byte from the 'shared byte
1.1133 + ** range' is read-locked and the lock on the 'pending byte' released.
1.1134 + **
1.1135 + ** A process may only obtain a RESERVED lock after it has a SHARED lock.
1.1136 + ** A RESERVED lock is implemented by grabbing a write-lock on the
1.1137 + ** 'reserved byte'.
1.1138 + **
1.1139 + ** A process may only obtain a PENDING lock after it has obtained a
1.1140 + ** SHARED lock. A PENDING lock is implemented by obtaining a write-lock
1.1141 + ** on the 'pending byte'. This ensures that no new SHARED locks can be
1.1142 + ** obtained, but existing SHARED locks are allowed to persist. A process
1.1143 + ** does not have to obtain a RESERVED lock on the way to a PENDING lock.
1.1144 + ** This property is used by the algorithm for rolling back a journal file
1.1145 + ** after a crash.
1.1146 + **
1.1147 + ** An EXCLUSIVE lock, obtained after a PENDING lock is held, is
1.1148 + ** implemented by obtaining a write-lock on the entire 'shared byte
1.1149 + ** range'. Since all other locks require a read-lock on one of the bytes
1.1150 + ** within this range, this ensures that no other locks are held on the
1.1151 + ** database.
1.1152 + **
1.1153 + ** The reason a single byte cannot be used instead of the 'shared byte
1.1154 + ** range' is that some versions of windows do not support read-locks. By
1.1155 + ** locking a random byte from a range, concurrent SHARED locks may exist
1.1156 + ** even if the locking primitive used is always a write-lock.
1.1157 + */
1.1158 + int rc = SQLITE_OK;
1.1159 + unixFile *pFile = (unixFile*)id;
1.1160 + struct lockInfo *pLock = pFile->pLock;
1.1161 + struct flock lock;
1.1162 + int s;
1.1163 +
1.1164 + assert( pFile );
1.1165 + OSTRACE7("LOCK %d %s was %s(%s,%d) pid=%d\n", pFile->h,
1.1166 + locktypeName(locktype), locktypeName(pFile->locktype),
1.1167 + locktypeName(pLock->locktype), pLock->cnt , getpid());
1.1168 +
1.1169 + /* If there is already a lock of this type or more restrictive on the
1.1170 + ** unixFile, do nothing. Don't use the end_lock: exit path, as
1.1171 + ** enterMutex() hasn't been called yet.
1.1172 + */
1.1173 + if( pFile->locktype>=locktype ){
1.1174 + OSTRACE3("LOCK %d %s ok (already held)\n", pFile->h,
1.1175 + locktypeName(locktype));
1.1176 + return SQLITE_OK;
1.1177 + }
1.1178 +
1.1179 + /* Make sure the locking sequence is correct
1.1180 + */
1.1181 + assert( pFile->locktype!=NO_LOCK || locktype==SHARED_LOCK );
1.1182 + assert( locktype!=PENDING_LOCK );
1.1183 + assert( locktype!=RESERVED_LOCK || pFile->locktype==SHARED_LOCK );
1.1184 +
1.1185 + /* This mutex is needed because pFile->pLock is shared across threads
1.1186 + */
1.1187 + enterMutex();
1.1188 +
1.1189 + /* Make sure the current thread owns the pFile.
1.1190 + */
1.1191 + rc = transferOwnership(pFile);
1.1192 + if( rc!=SQLITE_OK ){
1.1193 + leaveMutex();
1.1194 + return rc;
1.1195 + }
1.1196 + pLock = pFile->pLock;
1.1197 +
1.1198 + /* If some thread using this PID has a lock via a different unixFile*
1.1199 + ** handle that precludes the requested lock, return BUSY.
1.1200 + */
1.1201 + if( (pFile->locktype!=pLock->locktype &&
1.1202 + (pLock->locktype>=PENDING_LOCK || locktype>SHARED_LOCK))
1.1203 + ){
1.1204 + rc = SQLITE_BUSY;
1.1205 + goto end_lock;
1.1206 + }
1.1207 +
1.1208 + /* If a SHARED lock is requested, and some thread using this PID already
1.1209 + ** has a SHARED or RESERVED lock, then increment reference counts and
1.1210 + ** return SQLITE_OK.
1.1211 + */
1.1212 + if( locktype==SHARED_LOCK &&
1.1213 + (pLock->locktype==SHARED_LOCK || pLock->locktype==RESERVED_LOCK) ){
1.1214 + assert( locktype==SHARED_LOCK );
1.1215 + assert( pFile->locktype==0 );
1.1216 + assert( pLock->cnt>0 );
1.1217 + pFile->locktype = SHARED_LOCK;
1.1218 + pLock->cnt++;
1.1219 + pFile->pOpen->nLock++;
1.1220 + goto end_lock;
1.1221 + }
1.1222 +
1.1223 + lock.l_len = 1L;
1.1224 +
1.1225 + lock.l_whence = SEEK_SET;
1.1226 +
1.1227 + /* A PENDING lock is needed before acquiring a SHARED lock and before
1.1228 + ** acquiring an EXCLUSIVE lock. For the SHARED lock, the PENDING will
1.1229 + ** be released.
1.1230 + */
1.1231 + if( locktype==SHARED_LOCK
1.1232 + || (locktype==EXCLUSIVE_LOCK && pFile->locktype<PENDING_LOCK)
1.1233 + ){
1.1234 + lock.l_type = (locktype==SHARED_LOCK?F_RDLCK:F_WRLCK);
1.1235 + lock.l_start = PENDING_BYTE;
1.1236 + s = fcntl(pFile->h, F_SETLK, &lock);
1.1237 + if( s==(-1) ){
1.1238 + rc = (errno==EINVAL) ? SQLITE_NOLFS : SQLITE_BUSY;
1.1239 + goto end_lock;
1.1240 + }
1.1241 + }
1.1242 +
1.1243 +
1.1244 + /* If control gets to this point, then actually go ahead and make
1.1245 + ** operating system calls for the specified lock.
1.1246 + */
1.1247 + if( locktype==SHARED_LOCK ){
1.1248 + assert( pLock->cnt==0 );
1.1249 + assert( pLock->locktype==0 );
1.1250 +
1.1251 + /* Now get the read-lock */
1.1252 + lock.l_start = SHARED_FIRST;
1.1253 + lock.l_len = SHARED_SIZE;
1.1254 + s = fcntl(pFile->h, F_SETLK, &lock);
1.1255 +
1.1256 + /* Drop the temporary PENDING lock */
1.1257 + lock.l_start = PENDING_BYTE;
1.1258 + lock.l_len = 1L;
1.1259 + lock.l_type = F_UNLCK;
1.1260 + if( fcntl(pFile->h, F_SETLK, &lock)!=0 ){
1.1261 + rc = SQLITE_IOERR_UNLOCK; /* This should never happen */
1.1262 + goto end_lock;
1.1263 + }
1.1264 + if( s==(-1) ){
1.1265 + rc = (errno==EINVAL) ? SQLITE_NOLFS : SQLITE_BUSY;
1.1266 + }else{
1.1267 + pFile->locktype = SHARED_LOCK;
1.1268 + pFile->pOpen->nLock++;
1.1269 + pLock->cnt = 1;
1.1270 + }
1.1271 + }else if( locktype==EXCLUSIVE_LOCK && pLock->cnt>1 ){
1.1272 + /* We are trying for an exclusive lock but another thread in this
1.1273 + ** same process is still holding a shared lock. */
1.1274 + rc = SQLITE_BUSY;
1.1275 + }else{
1.1276 + /* The request was for a RESERVED or EXCLUSIVE lock. It is
1.1277 + ** assumed that there is a SHARED or greater lock on the file
1.1278 + ** already.
1.1279 + */
1.1280 + assert( 0!=pFile->locktype );
1.1281 + lock.l_type = F_WRLCK;
1.1282 + switch( locktype ){
1.1283 + case RESERVED_LOCK:
1.1284 + lock.l_start = RESERVED_BYTE;
1.1285 + break;
1.1286 + case EXCLUSIVE_LOCK:
1.1287 + lock.l_start = SHARED_FIRST;
1.1288 + lock.l_len = SHARED_SIZE;
1.1289 + break;
1.1290 + default:
1.1291 + assert(0);
1.1292 + }
1.1293 + s = fcntl(pFile->h, F_SETLK, &lock);
1.1294 + if( s==(-1) ){
1.1295 + rc = (errno==EINVAL) ? SQLITE_NOLFS : SQLITE_BUSY;
1.1296 + }
1.1297 + }
1.1298 +
1.1299 + if( rc==SQLITE_OK ){
1.1300 + pFile->locktype = locktype;
1.1301 + pLock->locktype = locktype;
1.1302 + }else if( locktype==EXCLUSIVE_LOCK ){
1.1303 + pFile->locktype = PENDING_LOCK;
1.1304 + pLock->locktype = PENDING_LOCK;
1.1305 + }
1.1306 +
1.1307 +end_lock:
1.1308 + leaveMutex();
1.1309 + OSTRACE4("LOCK %d %s %s\n", pFile->h, locktypeName(locktype),
1.1310 + rc==SQLITE_OK ? "ok" : "failed");
1.1311 + return rc;
1.1312 +}
1.1313 +
1.1314 +/*
1.1315 +** Lower the locking level on file descriptor pFile to locktype. locktype
1.1316 +** must be either NO_LOCK or SHARED_LOCK.
1.1317 +**
1.1318 +** If the locking level of the file descriptor is already at or below
1.1319 +** the requested locking level, this routine is a no-op.
1.1320 +*/
1.1321 +static int unixUnlock(sqlite3_file *id, int locktype){
1.1322 + struct lockInfo *pLock;
1.1323 + struct flock lock;
1.1324 + int rc = SQLITE_OK;
1.1325 + unixFile *pFile = (unixFile*)id;
1.1326 +
1.1327 + assert( pFile );
1.1328 + OSTRACE7("UNLOCK %d %d was %d(%d,%d) pid=%d\n", pFile->h, locktype,
1.1329 + pFile->locktype, pFile->pLock->locktype, pFile->pLock->cnt, getpid());
1.1330 +
1.1331 + assert( locktype<=SHARED_LOCK );
1.1332 + if( pFile->locktype<=locktype ){
1.1333 + return SQLITE_OK;
1.1334 + }
1.1335 + if( CHECK_THREADID(pFile) ){
1.1336 + return SQLITE_MISUSE;
1.1337 + }
1.1338 + enterMutex();
1.1339 + pLock = pFile->pLock;
1.1340 + assert( pLock->cnt!=0 );
1.1341 + if( pFile->locktype>SHARED_LOCK ){
1.1342 + assert( pLock->locktype==pFile->locktype );
1.1343 + if( locktype==SHARED_LOCK ){
1.1344 + lock.l_type = F_RDLCK;
1.1345 + lock.l_whence = SEEK_SET;
1.1346 + lock.l_start = SHARED_FIRST;
1.1347 + lock.l_len = SHARED_SIZE;
1.1348 + if( fcntl(pFile->h, F_SETLK, &lock)==(-1) ){
1.1349 + /* This should never happen */
1.1350 + rc = SQLITE_IOERR_RDLOCK;
1.1351 + }
1.1352 + }
1.1353 + lock.l_type = F_UNLCK;
1.1354 + lock.l_whence = SEEK_SET;
1.1355 + lock.l_start = PENDING_BYTE;
1.1356 + lock.l_len = 2L; assert( PENDING_BYTE+1==RESERVED_BYTE );
1.1357 + if( fcntl(pFile->h, F_SETLK, &lock)!=(-1) ){
1.1358 + pLock->locktype = SHARED_LOCK;
1.1359 + }else{
1.1360 + rc = SQLITE_IOERR_UNLOCK; /* This should never happen */
1.1361 + }
1.1362 + }
1.1363 + if( locktype==NO_LOCK ){
1.1364 + struct openCnt *pOpen;
1.1365 +
1.1366 + /* Decrement the shared lock counter. Release the lock using an
1.1367 + ** OS call only when all threads in this same process have released
1.1368 + ** the lock.
1.1369 + */
1.1370 + pLock->cnt--;
1.1371 + if( pLock->cnt==0 ){
1.1372 + lock.l_type = F_UNLCK;
1.1373 + lock.l_whence = SEEK_SET;
1.1374 + lock.l_start = lock.l_len = 0L;
1.1375 + if( fcntl(pFile->h, F_SETLK, &lock)!=(-1) ){
1.1376 + pLock->locktype = NO_LOCK;
1.1377 + }else{
1.1378 + rc = SQLITE_IOERR_UNLOCK; /* This should never happen */
1.1379 + }
1.1380 + }
1.1381 +
1.1382 + /* Decrement the count of locks against this same file. When the
1.1383 + ** count reaches zero, close any other file descriptors whose close
1.1384 + ** was deferred because of outstanding locks.
1.1385 + */
1.1386 + pOpen = pFile->pOpen;
1.1387 + pOpen->nLock--;
1.1388 + assert( pOpen->nLock>=0 );
1.1389 + if( pOpen->nLock==0 && pOpen->nPending>0 ){
1.1390 + int i;
1.1391 + for(i=0; i<pOpen->nPending; i++){
1.1392 + close(pOpen->aPending[i]);
1.1393 + }
1.1394 + free(pOpen->aPending);
1.1395 + pOpen->nPending = 0;
1.1396 + pOpen->aPending = 0;
1.1397 + }
1.1398 + }
1.1399 + leaveMutex();
1.1400 + pFile->locktype = locktype;
1.1401 + return rc;
1.1402 +}
1.1403 +
1.1404 +/*
1.1405 +** Close a file.
1.1406 +*/
1.1407 +static int unixClose(sqlite3_file *id){
1.1408 + unixFile *pFile = (unixFile *)id;
1.1409 + if( !pFile ) return SQLITE_OK;
1.1410 + unixUnlock(id, NO_LOCK);
1.1411 + if( pFile->dirfd>=0 ) close(pFile->dirfd);
1.1412 + pFile->dirfd = -1;
1.1413 + enterMutex();
1.1414 +
1.1415 + if( pFile->pOpen->nLock ){
1.1416 + /* If there are outstanding locks, do not actually close the file just
1.1417 + ** yet because that would clear those locks. Instead, add the file
1.1418 + ** descriptor to pOpen->aPending. It will be automatically closed when
1.1419 + ** the last lock is cleared.
1.1420 + */
1.1421 + int *aNew;
1.1422 + struct openCnt *pOpen = pFile->pOpen;
1.1423 + aNew = realloc( pOpen->aPending, (pOpen->nPending+1)*sizeof(int) );
1.1424 + if( aNew==0 ){
1.1425 + /* If a malloc fails, just leak the file descriptor */
1.1426 + }else{
1.1427 + pOpen->aPending = aNew;
1.1428 + pOpen->aPending[pOpen->nPending] = pFile->h;
1.1429 + pOpen->nPending++;
1.1430 + }
1.1431 + }else{
1.1432 + /* There are no outstanding locks so we can close the file immediately */
1.1433 + close(pFile->h);
1.1434 + }
1.1435 + releaseLockInfo(pFile->pLock);
1.1436 + releaseOpenCnt(pFile->pOpen);
1.1437 +
1.1438 + leaveMutex();
1.1439 + OSTRACE2("CLOSE %-3d\n", pFile->h);
1.1440 + OpenCounter(-1);
1.1441 + memset(pFile, 0, sizeof(unixFile));
1.1442 + return SQLITE_OK;
1.1443 +}
1.1444 +
1.1445 +
1.1446 +#ifdef SQLITE_ENABLE_LOCKING_STYLE
1.1447 +#pragma mark AFP Support
1.1448 +
1.1449 +/*
1.1450 + ** The afpLockingContext structure contains all afp lock specific state
1.1451 + */
1.1452 +typedef struct afpLockingContext afpLockingContext;
1.1453 +struct afpLockingContext {
1.1454 + unsigned long long sharedLockByte;
1.1455 + char *filePath;
1.1456 +};
1.1457 +
1.1458 +struct ByteRangeLockPB2
1.1459 +{
1.1460 + unsigned long long offset; /* offset to first byte to lock */
1.1461 + unsigned long long length; /* nbr of bytes to lock */
1.1462 + unsigned long long retRangeStart; /* nbr of 1st byte locked if successful */
1.1463 + unsigned char unLockFlag; /* 1 = unlock, 0 = lock */
1.1464 + unsigned char startEndFlag; /* 1=rel to end of fork, 0=rel to start */
1.1465 + int fd; /* file desc to assoc this lock with */
1.1466 +};
1.1467 +
1.1468 +#define afpfsByteRangeLock2FSCTL _IOWR('z', 23, struct ByteRangeLockPB2)
1.1469 +
1.1470 +/*
1.1471 +** Return 0 on success, 1 on failure. To match the behavior of the
1.1472 +** normal posix file locking (used in unixLock for example), we should
1.1473 +** provide 'richer' return codes - specifically to differentiate between
1.1474 +** 'file busy' and 'file system error' results.
1.1475 +*/
1.1476 +static int _AFPFSSetLock(
1.1477 + const char *path,
1.1478 + int fd,
1.1479 + unsigned long long offset,
1.1480 + unsigned long long length,
1.1481 + int setLockFlag
1.1482 +){
1.1483 + struct ByteRangeLockPB2 pb;
1.1484 + int err;
1.1485 +
1.1486 + pb.unLockFlag = setLockFlag ? 0 : 1;
1.1487 + pb.startEndFlag = 0;
1.1488 + pb.offset = offset;
1.1489 + pb.length = length;
1.1490 + pb.fd = fd;
1.1491 + OSTRACE5("AFPLOCK setting lock %s for %d in range %llx:%llx\n",
1.1492 + (setLockFlag?"ON":"OFF"), fd, offset, length);
1.1493 + err = fsctl(path, afpfsByteRangeLock2FSCTL, &pb, 0);
1.1494 + if ( err==-1 ) {
1.1495 + OSTRACE4("AFPLOCK failed to fsctl() '%s' %d %s\n", path, errno,
1.1496 + strerror(errno));
1.1497 + return 1; /* error */
1.1498 + } else {
1.1499 + return 0;
1.1500 + }
1.1501 +}
1.1502 +
1.1503 +/*
1.1504 + ** This routine checks if there is a RESERVED lock held on the specified
1.1505 + ** file by this or any other process. If such a lock is held, return
1.1506 + ** non-zero. If the file is unlocked or holds only SHARED locks, then
1.1507 + ** return zero.
1.1508 + */
1.1509 +static int afpUnixCheckReservedLock(sqlite3_file *id){
1.1510 + int r = 0;
1.1511 + unixFile *pFile = (unixFile*)id;
1.1512 +
1.1513 + assert( pFile );
1.1514 + afpLockingContext *context = (afpLockingContext *) pFile->lockingContext;
1.1515 +
1.1516 + /* Check if a thread in this process holds such a lock */
1.1517 + if( pFile->locktype>SHARED_LOCK ){
1.1518 + r = 1;
1.1519 + }
1.1520 +
1.1521 + /* Otherwise see if some other process holds it.
1.1522 + */
1.1523 + if ( !r ) {
1.1524 + /* lock the byte */
1.1525 + int failed = _AFPFSSetLock(context->filePath, pFile->h, RESERVED_BYTE, 1,1);
1.1526 + if (failed) {
1.1527 + /* if we failed to get the lock then someone else must have it */
1.1528 + r = 1;
1.1529 + } else {
1.1530 + /* if we succeeded in taking the reserved lock, unlock it to restore
1.1531 + ** the original state */
1.1532 + _AFPFSSetLock(context->filePath, pFile->h, RESERVED_BYTE, 1, 0);
1.1533 + }
1.1534 + }
1.1535 + OSTRACE3("TEST WR-LOCK %d %d\n", pFile->h, r);
1.1536 +
1.1537 + return r;
1.1538 +}
1.1539 +
1.1540 +/* AFP-style locking following the behavior of unixLock, see the unixLock
1.1541 +** function comments for details of lock management. */
1.1542 +static int afpUnixLock(sqlite3_file *id, int locktype)
1.1543 +{
1.1544 + int rc = SQLITE_OK;
1.1545 + unixFile *pFile = (unixFile*)id;
1.1546 + afpLockingContext *context = (afpLockingContext *) pFile->lockingContext;
1.1547 + int gotPendingLock = 0;
1.1548 +
1.1549 + assert( pFile );
1.1550 + OSTRACE5("LOCK %d %s was %s pid=%d\n", pFile->h,
1.1551 + locktypeName(locktype), locktypeName(pFile->locktype), getpid());
1.1552 + /* If there is already a lock of this type or more restrictive on the
1.1553 + ** unixFile, do nothing. Don't use the afp_end_lock: exit path, as
1.1554 + ** enterMutex() hasn't been called yet.
1.1555 + */
1.1556 + if( pFile->locktype>=locktype ){
1.1557 + OSTRACE3("LOCK %d %s ok (already held)\n", pFile->h,
1.1558 + locktypeName(locktype));
1.1559 + return SQLITE_OK;
1.1560 + }
1.1561 +
1.1562 + /* Make sure the locking sequence is correct
1.1563 + */
1.1564 + assert( pFile->locktype!=NO_LOCK || locktype==SHARED_LOCK );
1.1565 + assert( locktype!=PENDING_LOCK );
1.1566 + assert( locktype!=RESERVED_LOCK || pFile->locktype==SHARED_LOCK );
1.1567 +
1.1568 + /* This mutex is needed because pFile->pLock is shared across threads
1.1569 + */
1.1570 + enterMutex();
1.1571 +
1.1572 + /* Make sure the current thread owns the pFile.
1.1573 + */
1.1574 + rc = transferOwnership(pFile);
1.1575 + if( rc!=SQLITE_OK ){
1.1576 + leaveMutex();
1.1577 + return rc;
1.1578 + }
1.1579 +
1.1580 + /* A PENDING lock is needed before acquiring a SHARED lock and before
1.1581 + ** acquiring an EXCLUSIVE lock. For the SHARED lock, the PENDING will
1.1582 + ** be released.
1.1583 + */
1.1584 + if( locktype==SHARED_LOCK
1.1585 + || (locktype==EXCLUSIVE_LOCK && pFile->locktype<PENDING_LOCK)
1.1586 + ){
1.1587 + int failed = _AFPFSSetLock(context->filePath, pFile->h,
1.1588 + PENDING_BYTE, 1, 1);
1.1589 + if (failed) {
1.1590 + rc = SQLITE_BUSY;
1.1591 + goto afp_end_lock;
1.1592 + }
1.1593 + }
1.1594 +
1.1595 + /* If control gets to this point, then actually go ahead and make
1.1596 + ** operating system calls for the specified lock.
1.1597 + */
1.1598 + if( locktype==SHARED_LOCK ){
1.1599 + int lk, failed;
1.1600 + int tries = 0;
1.1601 +
1.1602 + /* Now get the read-lock */
1.1603 + /* note that the quality of the randomness doesn't matter that much */
1.1604 + lk = random();
1.1605 + context->sharedLockByte = (lk & 0x7fffffff)%(SHARED_SIZE - 1);
1.1606 + failed = _AFPFSSetLock(context->filePath, pFile->h,
1.1607 + SHARED_FIRST+context->sharedLockByte, 1, 1);
1.1608 +
1.1609 + /* Drop the temporary PENDING lock */
1.1610 + if (_AFPFSSetLock(context->filePath, pFile->h, PENDING_BYTE, 1, 0)) {
1.1611 + rc = SQLITE_IOERR_UNLOCK; /* This should never happen */
1.1612 + goto afp_end_lock;
1.1613 + }
1.1614 +
1.1615 + if( failed ){
1.1616 + rc = SQLITE_BUSY;
1.1617 + } else {
1.1618 + pFile->locktype = SHARED_LOCK;
1.1619 + }
1.1620 + }else{
1.1621 + /* The request was for a RESERVED or EXCLUSIVE lock. It is
1.1622 + ** assumed that there is a SHARED or greater lock on the file
1.1623 + ** already.
1.1624 + */
1.1625 + int failed = 0;
1.1626 + assert( 0!=pFile->locktype );
1.1627 + if (locktype >= RESERVED_LOCK && pFile->locktype < RESERVED_LOCK) {
1.1628 + /* Acquire a RESERVED lock */
1.1629 + failed = _AFPFSSetLock(context->filePath, pFile->h, RESERVED_BYTE, 1,1);
1.1630 + }
1.1631 + if (!failed && locktype == EXCLUSIVE_LOCK) {
1.1632 + /* Acquire an EXCLUSIVE lock */
1.1633 +
1.1634 + /* Remove the shared lock before trying the range. we'll need to
1.1635 + ** reestablish the shared lock if we can't get the afpUnixUnlock
1.1636 + */
1.1637 + if (!_AFPFSSetLock(context->filePath, pFile->h, SHARED_FIRST +
1.1638 + context->sharedLockByte, 1, 0)) {
1.1639 + /* now attemmpt to get the exclusive lock range */
1.1640 + failed = _AFPFSSetLock(context->filePath, pFile->h, SHARED_FIRST,
1.1641 + SHARED_SIZE, 1);
1.1642 + if (failed && _AFPFSSetLock(context->filePath, pFile->h, SHARED_FIRST +
1.1643 + context->sharedLockByte, 1, 1)) {
1.1644 + rc = SQLITE_IOERR_RDLOCK; /* this should never happen */
1.1645 + }
1.1646 + } else {
1.1647 + /* */
1.1648 + rc = SQLITE_IOERR_UNLOCK; /* this should never happen */
1.1649 + }
1.1650 + }
1.1651 + if( failed && rc == SQLITE_OK){
1.1652 + rc = SQLITE_BUSY;
1.1653 + }
1.1654 + }
1.1655 +
1.1656 + if( rc==SQLITE_OK ){
1.1657 + pFile->locktype = locktype;
1.1658 + }else if( locktype==EXCLUSIVE_LOCK ){
1.1659 + pFile->locktype = PENDING_LOCK;
1.1660 + }
1.1661 +
1.1662 +afp_end_lock:
1.1663 + leaveMutex();
1.1664 + OSTRACE4("LOCK %d %s %s\n", pFile->h, locktypeName(locktype),
1.1665 + rc==SQLITE_OK ? "ok" : "failed");
1.1666 + return rc;
1.1667 +}
1.1668 +
1.1669 +/*
1.1670 + ** Lower the locking level on file descriptor pFile to locktype. locktype
1.1671 + ** must be either NO_LOCK or SHARED_LOCK.
1.1672 + **
1.1673 + ** If the locking level of the file descriptor is already at or below
1.1674 + ** the requested locking level, this routine is a no-op.
1.1675 + */
1.1676 +static int afpUnixUnlock(sqlite3_file *id, int locktype) {
1.1677 + struct flock lock;
1.1678 + int rc = SQLITE_OK;
1.1679 + unixFile *pFile = (unixFile*)id;
1.1680 + afpLockingContext *context = (afpLockingContext *) pFile->lockingContext;
1.1681 +
1.1682 + assert( pFile );
1.1683 + OSTRACE5("UNLOCK %d %d was %d pid=%d\n", pFile->h, locktype,
1.1684 + pFile->locktype, getpid());
1.1685 +
1.1686 + assert( locktype<=SHARED_LOCK );
1.1687 + if( pFile->locktype<=locktype ){
1.1688 + return SQLITE_OK;
1.1689 + }
1.1690 + if( CHECK_THREADID(pFile) ){
1.1691 + return SQLITE_MISUSE;
1.1692 + }
1.1693 + enterMutex();
1.1694 + if( pFile->locktype>SHARED_LOCK ){
1.1695 + if( locktype==SHARED_LOCK ){
1.1696 + int failed = 0;
1.1697 +
1.1698 + /* unlock the exclusive range - then re-establish the shared lock */
1.1699 + if (pFile->locktype==EXCLUSIVE_LOCK) {
1.1700 + failed = _AFPFSSetLock(context->filePath, pFile->h, SHARED_FIRST,
1.1701 + SHARED_SIZE, 0);
1.1702 + if (!failed) {
1.1703 + /* successfully removed the exclusive lock */
1.1704 + if (_AFPFSSetLock(context->filePath, pFile->h, SHARED_FIRST+
1.1705 + context->sharedLockByte, 1, 1)) {
1.1706 + /* failed to re-establish our shared lock */
1.1707 + rc = SQLITE_IOERR_RDLOCK; /* This should never happen */
1.1708 + }
1.1709 + } else {
1.1710 + /* This should never happen - failed to unlock the exclusive range */
1.1711 + rc = SQLITE_IOERR_UNLOCK;
1.1712 + }
1.1713 + }
1.1714 + }
1.1715 + if (rc == SQLITE_OK && pFile->locktype>=PENDING_LOCK) {
1.1716 + if (_AFPFSSetLock(context->filePath, pFile->h, PENDING_BYTE, 1, 0)){
1.1717 + /* failed to release the pending lock */
1.1718 + rc = SQLITE_IOERR_UNLOCK; /* This should never happen */
1.1719 + }
1.1720 + }
1.1721 + if (rc == SQLITE_OK && pFile->locktype>=RESERVED_LOCK) {
1.1722 + if (_AFPFSSetLock(context->filePath, pFile->h, RESERVED_BYTE, 1, 0)) {
1.1723 + /* failed to release the reserved lock */
1.1724 + rc = SQLITE_IOERR_UNLOCK; /* This should never happen */
1.1725 + }
1.1726 + }
1.1727 + }
1.1728 + if( locktype==NO_LOCK ){
1.1729 + int failed = _AFPFSSetLock(context->filePath, pFile->h,
1.1730 + SHARED_FIRST + context->sharedLockByte, 1, 0);
1.1731 + if (failed) {
1.1732 + rc = SQLITE_IOERR_UNLOCK; /* This should never happen */
1.1733 + }
1.1734 + }
1.1735 + if (rc == SQLITE_OK)
1.1736 + pFile->locktype = locktype;
1.1737 + leaveMutex();
1.1738 + return rc;
1.1739 +}
1.1740 +
1.1741 +/*
1.1742 + ** Close a file & cleanup AFP specific locking context
1.1743 + */
1.1744 +static int afpUnixClose(sqlite3_file *id) {
1.1745 + unixFile *pFile = (unixFile*)pId;
1.1746 +
1.1747 + if( !pFile ) return SQLITE_OK;
1.1748 + afpUnixUnlock(*pId, NO_LOCK);
1.1749 + /* free the AFP locking structure */
1.1750 + if (pFile->lockingContext != NULL) {
1.1751 + if (((afpLockingContext *)pFile->lockingContext)->filePath != NULL)
1.1752 + sqlite3_free(((afpLockingContext*)pFile->lockingContext)->filePath);
1.1753 + sqlite3_free(pFile->lockingContext);
1.1754 + }
1.1755 +
1.1756 + if( pFile->dirfd>=0 ) close(pFile->dirfd);
1.1757 + pFile->dirfd = -1;
1.1758 + close(pFile->h);
1.1759 + OSTRACE2("CLOSE %-3d\n", pFile->h);
1.1760 + OpenCounter(-1);
1.1761 + return SQLITE_OK;
1.1762 +}
1.1763 +
1.1764 +
1.1765 +#pragma mark flock() style locking
1.1766 +
1.1767 +/*
1.1768 + ** The flockLockingContext is not used
1.1769 + */
1.1770 +typedef void flockLockingContext;
1.1771 +
1.1772 +static int flockUnixCheckReservedLock(sqlite3_file *id) {
1.1773 + unixFile *pFile = (unixFile*)id;
1.1774 +
1.1775 + if (pFile->locktype == RESERVED_LOCK) {
1.1776 + return 1; /* already have a reserved lock */
1.1777 + } else {
1.1778 + /* attempt to get the lock */
1.1779 + int rc = flock(pFile->h, LOCK_EX | LOCK_NB);
1.1780 + if (!rc) {
1.1781 + /* got the lock, unlock it */
1.1782 + flock(pFile->h, LOCK_UN);
1.1783 + return 0; /* no one has it reserved */
1.1784 + }
1.1785 + return 1; /* someone else might have it reserved */
1.1786 + }
1.1787 +}
1.1788 +
1.1789 +static int flockUnixLock(sqlite3_file *id, int locktype) {
1.1790 + unixFile *pFile = (unixFile*)id;
1.1791 +
1.1792 + /* if we already have a lock, it is exclusive.
1.1793 + ** Just adjust level and punt on outta here. */
1.1794 + if (pFile->locktype > NO_LOCK) {
1.1795 + pFile->locktype = locktype;
1.1796 + return SQLITE_OK;
1.1797 + }
1.1798 +
1.1799 + /* grab an exclusive lock */
1.1800 + int rc = flock(pFile->h, LOCK_EX | LOCK_NB);
1.1801 + if (rc) {
1.1802 + /* didn't get, must be busy */
1.1803 + return SQLITE_BUSY;
1.1804 + } else {
1.1805 + /* got it, set the type and return ok */
1.1806 + pFile->locktype = locktype;
1.1807 + return SQLITE_OK;
1.1808 + }
1.1809 +}
1.1810 +
1.1811 +static int flockUnixUnlock(sqlite3_file *id, int locktype) {
1.1812 + unixFile *pFile = (unixFile*)id;
1.1813 +
1.1814 + assert( locktype<=SHARED_LOCK );
1.1815 +
1.1816 + /* no-op if possible */
1.1817 + if( pFile->locktype==locktype ){
1.1818 + return SQLITE_OK;
1.1819 + }
1.1820 +
1.1821 + /* shared can just be set because we always have an exclusive */
1.1822 + if (locktype==SHARED_LOCK) {
1.1823 + pFile->locktype = locktype;
1.1824 + return SQLITE_OK;
1.1825 + }
1.1826 +
1.1827 + /* no, really, unlock. */
1.1828 + int rc = flock(pFile->h, LOCK_UN);
1.1829 + if (rc)
1.1830 + return SQLITE_IOERR_UNLOCK;
1.1831 + else {
1.1832 + pFile->locktype = NO_LOCK;
1.1833 + return SQLITE_OK;
1.1834 + }
1.1835 +}
1.1836 +
1.1837 +/*
1.1838 + ** Close a file.
1.1839 + */
1.1840 +static int flockUnixClose(sqlite3_file *pId) {
1.1841 + unixFile *pFile = (unixFile*)*pId;
1.1842 +
1.1843 + if( !pFile ) return SQLITE_OK;
1.1844 + flockUnixUnlock(*pId, NO_LOCK);
1.1845 +
1.1846 + if( pFile->dirfd>=0 ) close(pFile->dirfd);
1.1847 + pFile->dirfd = -1;
1.1848 + enterMutex();
1.1849 +
1.1850 + close(pFile->h);
1.1851 + leaveMutex();
1.1852 + OSTRACE2("CLOSE %-3d\n", pFile->h);
1.1853 + OpenCounter(-1);
1.1854 + return SQLITE_OK;
1.1855 +}
1.1856 +
1.1857 +#pragma mark Old-School .lock file based locking
1.1858 +
1.1859 +/*
1.1860 + ** The dotlockLockingContext structure contains all dotlock (.lock) lock
1.1861 + ** specific state
1.1862 + */
1.1863 +typedef struct dotlockLockingContext dotlockLockingContext;
1.1864 +struct dotlockLockingContext {
1.1865 + char *lockPath;
1.1866 +};
1.1867 +
1.1868 +
1.1869 +static int dotlockUnixCheckReservedLock(sqlite3_file *id) {
1.1870 + unixFile *pFile = (unixFile*)id;
1.1871 + dotlockLockingContext *context =
1.1872 + (dotlockLockingContext *) pFile->lockingContext;
1.1873 +
1.1874 + if (pFile->locktype == RESERVED_LOCK) {
1.1875 + return 1; /* already have a reserved lock */
1.1876 + } else {
1.1877 + struct stat statBuf;
1.1878 + if (lstat(context->lockPath,&statBuf) == 0)
1.1879 + /* file exists, someone else has the lock */
1.1880 + return 1;
1.1881 + else
1.1882 + /* file does not exist, we could have it if we want it */
1.1883 + return 0;
1.1884 + }
1.1885 +}
1.1886 +
1.1887 +static int dotlockUnixLock(sqlite3_file *id, int locktype) {
1.1888 + unixFile *pFile = (unixFile*)id;
1.1889 + dotlockLockingContext *context =
1.1890 + (dotlockLockingContext *) pFile->lockingContext;
1.1891 +
1.1892 + /* if we already have a lock, it is exclusive.
1.1893 + ** Just adjust level and punt on outta here. */
1.1894 + if (pFile->locktype > NO_LOCK) {
1.1895 + pFile->locktype = locktype;
1.1896 +
1.1897 + /* Always update the timestamp on the old file */
1.1898 + utimes(context->lockPath,NULL);
1.1899 + return SQLITE_OK;
1.1900 + }
1.1901 +
1.1902 + /* check to see if lock file already exists */
1.1903 + struct stat statBuf;
1.1904 + if (lstat(context->lockPath,&statBuf) == 0){
1.1905 + return SQLITE_BUSY; /* it does, busy */
1.1906 + }
1.1907 +
1.1908 + /* grab an exclusive lock */
1.1909 + int fd = open(context->lockPath,O_RDONLY|O_CREAT|O_EXCL,0600);
1.1910 + if (fd < 0) {
1.1911 + /* failed to open/create the file, someone else may have stolen the lock */
1.1912 + return SQLITE_BUSY;
1.1913 + }
1.1914 + close(fd);
1.1915 +
1.1916 + /* got it, set the type and return ok */
1.1917 + pFile->locktype = locktype;
1.1918 + return SQLITE_OK;
1.1919 +}
1.1920 +
1.1921 +static int dotlockUnixUnlock(sqlite3_file *id, int locktype) {
1.1922 + unixFile *pFile = (unixFile*)id;
1.1923 + dotlockLockingContext *context =
1.1924 + (dotlockLockingContext *) pFile->lockingContext;
1.1925 +
1.1926 + assert( locktype<=SHARED_LOCK );
1.1927 +
1.1928 + /* no-op if possible */
1.1929 + if( pFile->locktype==locktype ){
1.1930 + return SQLITE_OK;
1.1931 + }
1.1932 +
1.1933 + /* shared can just be set because we always have an exclusive */
1.1934 + if (locktype==SHARED_LOCK) {
1.1935 + pFile->locktype = locktype;
1.1936 + return SQLITE_OK;
1.1937 + }
1.1938 +
1.1939 + /* no, really, unlock. */
1.1940 + unlink(context->lockPath);
1.1941 + pFile->locktype = NO_LOCK;
1.1942 + return SQLITE_OK;
1.1943 +}
1.1944 +
1.1945 +/*
1.1946 + ** Close a file.
1.1947 + */
1.1948 +static int dotlockUnixClose(sqlite3_file *id) {
1.1949 + unixFile *pFile = (unixFile*)id;
1.1950 +
1.1951 + if( !pFile ) return SQLITE_OK;
1.1952 + dotlockUnixUnlock(*pId, NO_LOCK);
1.1953 + /* free the dotlock locking structure */
1.1954 + if (pFile->lockingContext != NULL) {
1.1955 + if (((dotlockLockingContext *)pFile->lockingContext)->lockPath != NULL)
1.1956 + sqlite3_free( ( (dotlockLockingContext *)
1.1957 + pFile->lockingContext)->lockPath);
1.1958 + sqlite3_free(pFile->lockingContext);
1.1959 + }
1.1960 +
1.1961 + if( pFile->dirfd>=0 ) close(pFile->dirfd);
1.1962 + pFile->dirfd = -1;
1.1963 + enterMutex();
1.1964 +
1.1965 + close(pFile->h);
1.1966 +
1.1967 + leaveMutex();
1.1968 + OSTRACE2("CLOSE %-3d\n", pFile->h);
1.1969 + OpenCounter(-1);
1.1970 + return SQLITE_OK;
1.1971 +}
1.1972 +
1.1973 +
1.1974 +#pragma mark No locking
1.1975 +
1.1976 +/*
1.1977 + ** The nolockLockingContext is void
1.1978 + */
1.1979 +typedef void nolockLockingContext;
1.1980 +
1.1981 +static int nolockUnixCheckReservedLock(sqlite3_file *id) {
1.1982 + return 0;
1.1983 +}
1.1984 +
1.1985 +static int nolockUnixLock(sqlite3_file *id, int locktype) {
1.1986 + return SQLITE_OK;
1.1987 +}
1.1988 +
1.1989 +static int nolockUnixUnlock(sqlite3_file *id, int locktype) {
1.1990 + return SQLITE_OK;
1.1991 +}
1.1992 +
1.1993 +/*
1.1994 + ** Close a file.
1.1995 + */
1.1996 +static int nolockUnixClose(sqlite3_file *id) {
1.1997 + unixFile *pFile = (unixFile*)id;
1.1998 +
1.1999 + if( !pFile ) return SQLITE_OK;
1.2000 + if( pFile->dirfd>=0 ) close(pFile->dirfd);
1.2001 + pFile->dirfd = -1;
1.2002 + enterMutex();
1.2003 +
1.2004 + close(pFile->h);
1.2005 +
1.2006 + leaveMutex();
1.2007 + OSTRACE2("CLOSE %-3d\n", pFile->h);
1.2008 + OpenCounter(-1);
1.2009 + return SQLITE_OK;
1.2010 +}
1.2011 +
1.2012 +#endif /* SQLITE_ENABLE_LOCKING_STYLE */
1.2013 +
1.2014 +
1.2015 +/*
1.2016 +** Information and control of an open file handle.
1.2017 +*/
1.2018 +static int unixFileControl(sqlite3_file *id, int op, void *pArg){
1.2019 + switch( op ){
1.2020 + case SQLITE_FCNTL_LOCKSTATE: {
1.2021 + *(int*)pArg = ((unixFile*)id)->locktype;
1.2022 + return SQLITE_OK;
1.2023 + }
1.2024 + }
1.2025 + return SQLITE_ERROR;
1.2026 +}
1.2027 +
1.2028 +/*
1.2029 +** Return the sector size in bytes of the underlying block device for
1.2030 +** the specified file. This is almost always 512 bytes, but may be
1.2031 +** larger for some devices.
1.2032 +**
1.2033 +** SQLite code assumes this function cannot fail. It also assumes that
1.2034 +** if two files are created in the same file-system directory (i.e.
1.2035 +** a database and it's journal file) that the sector size will be the
1.2036 +** same for both.
1.2037 +*/
1.2038 +static int unixSectorSize(sqlite3_file *id){
1.2039 + return SQLITE_DEFAULT_SECTOR_SIZE;
1.2040 +}
1.2041 +
1.2042 +/*
1.2043 +** Return the device characteristics for the file. This is always 0.
1.2044 +*/
1.2045 +static int unixDeviceCharacteristics(sqlite3_file *id){
1.2046 + return 0;
1.2047 +}
1.2048 +
1.2049 +/*
1.2050 +** This vector defines all the methods that can operate on an sqlite3_file
1.2051 +** for unix.
1.2052 +*/
1.2053 +static const sqlite3_io_methods sqlite3UnixIoMethod = {
1.2054 + 1, /* iVersion */
1.2055 + unixClose,
1.2056 + unixRead,
1.2057 + unixWrite,
1.2058 + unixTruncate,
1.2059 + unixSync,
1.2060 + unixFileSize,
1.2061 + unixLock,
1.2062 + unixUnlock,
1.2063 + unixCheckReservedLock,
1.2064 + unixFileControl,
1.2065 + unixSectorSize,
1.2066 + unixDeviceCharacteristics
1.2067 +};
1.2068 +
1.2069 +#ifdef SQLITE_ENABLE_LOCKING_STYLE
1.2070 +/*
1.2071 +** This vector defines all the methods that can operate on an sqlite3_file
1.2072 +** for unix with AFP style file locking.
1.2073 +*/
1.2074 +static const sqlite3_io_methods sqlite3AFPLockingUnixIoMethod = {
1.2075 + 1, /* iVersion */
1.2076 + unixClose,
1.2077 + unixRead,
1.2078 + unixWrite,
1.2079 + unixTruncate,
1.2080 + unixSync,
1.2081 + unixFileSize,
1.2082 + afpUnixLock,
1.2083 + afpUnixUnlock,
1.2084 + afpUnixCheckReservedLock,
1.2085 + unixFileControl,
1.2086 + unixSectorSize,
1.2087 + unixDeviceCharacteristics
1.2088 +};
1.2089 +
1.2090 +/*
1.2091 +** This vector defines all the methods that can operate on an sqlite3_file
1.2092 +** for unix with flock() style file locking.
1.2093 +*/
1.2094 +static const sqlite3_io_methods sqlite3FlockLockingUnixIoMethod = {
1.2095 + 1, /* iVersion */
1.2096 + flockUnixClose,
1.2097 + unixRead,
1.2098 + unixWrite,
1.2099 + unixTruncate,
1.2100 + unixSync,
1.2101 + unixFileSize,
1.2102 + flockUnixLock,
1.2103 + flockUnixUnlock,
1.2104 + flockUnixCheckReservedLock,
1.2105 + unixFileControl,
1.2106 + unixSectorSize,
1.2107 + unixDeviceCharacteristics
1.2108 +};
1.2109 +
1.2110 +/*
1.2111 +** This vector defines all the methods that can operate on an sqlite3_file
1.2112 +** for unix with dotlock style file locking.
1.2113 +*/
1.2114 +static const sqlite3_io_methods sqlite3DotlockLockingUnixIoMethod = {
1.2115 + 1, /* iVersion */
1.2116 + dotlockUnixClose,
1.2117 + unixRead,
1.2118 + unixWrite,
1.2119 + unixTruncate,
1.2120 + unixSync,
1.2121 + unixFileSize,
1.2122 + dotlockUnixLock,
1.2123 + dotlockUnixUnlock,
1.2124 + dotlockUnixCheckReservedLock,
1.2125 + unixFileControl,
1.2126 + unixSectorSize,
1.2127 + unixDeviceCharacteristics
1.2128 +};
1.2129 +
1.2130 +/*
1.2131 +** This vector defines all the methods that can operate on an sqlite3_file
1.2132 +** for unix with dotlock style file locking.
1.2133 +*/
1.2134 +static const sqlite3_io_methods sqlite3NolockLockingUnixIoMethod = {
1.2135 + 1, /* iVersion */
1.2136 + nolockUnixClose,
1.2137 + unixRead,
1.2138 + unixWrite,
1.2139 + unixTruncate,
1.2140 + unixSync,
1.2141 + unixFileSize,
1.2142 + nolockUnixLock,
1.2143 + nolockUnixUnlock,
1.2144 + nolockUnixCheckReservedLock,
1.2145 + unixFileControl,
1.2146 + unixSectorSize,
1.2147 + unixDeviceCharacteristics
1.2148 +};
1.2149 +
1.2150 +#endif /* SQLITE_ENABLE_LOCKING_STYLE */
1.2151 +
1.2152 +/*
1.2153 +** Allocate memory for a new unixFile and initialize that unixFile.
1.2154 +** Write a pointer to the new unixFile into *pId.
1.2155 +** If we run out of memory, close the file and return an error.
1.2156 +*/
1.2157 +#ifdef SQLITE_ENABLE_LOCKING_STYLE
1.2158 +/*
1.2159 +** When locking extensions are enabled, the filepath and locking style
1.2160 +** are needed to determine the unixFile pMethod to use for locking operations.
1.2161 +** The locking-style specific lockingContext data structure is created
1.2162 +** and assigned here also.
1.2163 +*/
1.2164 +static int fillInUnixFile(
1.2165 + int h, /* Open file descriptor of file being opened */
1.2166 + int dirfd, /* Directory file descriptor */
1.2167 + sqlite3_file *pId, /* Write completed initialization here */
1.2168 + const char *zFilename, /* Name of the file being opened */
1.2169 +){
1.2170 + sqlite3LockingStyle lockingStyle;
1.2171 + unixFile *pNew = (unixFile *)pId;
1.2172 + int rc;
1.2173 +
1.2174 + memset(pNew, 0, sizeof(unixFile));
1.2175 + lockingStyle = sqlite3DetectLockingStyle(zFilename, h);
1.2176 + if ( lockingStyle == posixLockingStyle ) {
1.2177 + enterMutex();
1.2178 + rc = findLockInfo(h, &pNew->pLock, &pNew->pOpen);
1.2179 + leaveMutex();
1.2180 + if( rc ){
1.2181 + close(h);
1.2182 + unlink(zFilename);
1.2183 + return SQLITE_NOMEM;
1.2184 + }
1.2185 + } else {
1.2186 + /* pLock and pOpen are only used for posix advisory locking */
1.2187 + pNew->pLock = NULL;
1.2188 + pNew->pOpen = NULL;
1.2189 + }
1.2190 + pNew->dirfd = -1;
1.2191 + pNew->h = h;
1.2192 + SET_THREADID(pNew);
1.2193 + pNew = sqlite3_malloc( sizeof(unixFile) );
1.2194 + if( pNew==0 ){
1.2195 + close(h);
1.2196 + enterMutex();
1.2197 + releaseLockInfo(pNew->pLock);
1.2198 + releaseOpenCnt(pNew->pOpen);
1.2199 + leaveMutex();
1.2200 + return SQLITE_NOMEM;
1.2201 + }else{
1.2202 + switch(lockingStyle) {
1.2203 + case afpLockingStyle: {
1.2204 + /* afp locking uses the file path so it needs to be included in
1.2205 + ** the afpLockingContext */
1.2206 + int nFilename;
1.2207 + pNew->pMethod = &sqlite3AFPLockingUnixIoMethod;
1.2208 + pNew->lockingContext =
1.2209 + sqlite3_malloc(sizeof(afpLockingContext));
1.2210 + nFilename = strlen(zFilename)+1;
1.2211 + ((afpLockingContext *)pNew->lockingContext)->filePath =
1.2212 + sqlite3_malloc(nFilename);
1.2213 + memcpy(((afpLockingContext *)pNew->lockingContext)->filePath,
1.2214 + zFilename, nFilename);
1.2215 + srandomdev();
1.2216 + break;
1.2217 + }
1.2218 + case flockLockingStyle:
1.2219 + /* flock locking doesn't need additional lockingContext information */
1.2220 + pNew->pMethod = &sqlite3FlockLockingUnixIoMethod;
1.2221 + break;
1.2222 + case dotlockLockingStyle: {
1.2223 + /* dotlock locking uses the file path so it needs to be included in
1.2224 + ** the dotlockLockingContext */
1.2225 + int nFilename;
1.2226 + pNew->pMethod = &sqlite3DotlockLockingUnixIoMethod;
1.2227 + pNew->lockingContext = sqlite3_malloc(
1.2228 + sizeof(dotlockLockingContext));
1.2229 + nFilename = strlen(zFilename) + 6;
1.2230 + ((dotlockLockingContext *)pNew->lockingContext)->lockPath =
1.2231 + sqlite3_malloc( nFilename );
1.2232 + sqlite3_snprintf(nFilename,
1.2233 + ((dotlockLockingContext *)pNew->lockingContext)->lockPath,
1.2234 + "%s.lock", zFilename);
1.2235 + break;
1.2236 + }
1.2237 + case posixLockingStyle:
1.2238 + /* posix locking doesn't need additional lockingContext information */
1.2239 + pNew->pMethod = &sqlite3UnixIoMethod;
1.2240 + break;
1.2241 + case noLockingStyle:
1.2242 + case unsupportedLockingStyle:
1.2243 + default:
1.2244 + pNew->pMethod = &sqlite3NolockLockingUnixIoMethod;
1.2245 + }
1.2246 + OpenCounter(+1);
1.2247 + return SQLITE_OK;
1.2248 + }
1.2249 +}
1.2250 +#else /* SQLITE_ENABLE_LOCKING_STYLE */
1.2251 +static int fillInUnixFile(
1.2252 + int h, /* Open file descriptor on file being opened */
1.2253 + int dirfd,
1.2254 + sqlite3_file *pId, /* Write to the unixFile structure here */
1.2255 + const char *zFilename /* Name of the file being opened */
1.2256 +){
1.2257 + unixFile *pNew = (unixFile *)pId;
1.2258 + int rc;
1.2259 +
1.2260 +#ifdef FD_CLOEXEC
1.2261 + fcntl(h, F_SETFD, fcntl(h, F_GETFD, 0) | FD_CLOEXEC);
1.2262 +#endif
1.2263 +
1.2264 + enterMutex();
1.2265 + rc = findLockInfo(h, &pNew->pLock, &pNew->pOpen);
1.2266 + leaveMutex();
1.2267 + if( rc ){
1.2268 + close(h);
1.2269 + return SQLITE_NOMEM;
1.2270 + }
1.2271 +
1.2272 + OSTRACE3("OPEN %-3d %s\n", h, zFilename);
1.2273 + pNew->dirfd = -1;
1.2274 + pNew->h = h;
1.2275 + pNew->dirfd = dirfd;
1.2276 + SET_THREADID(pNew);
1.2277 +
1.2278 + pNew->pMethod = &sqlite3UnixIoMethod;
1.2279 + OpenCounter(+1);
1.2280 + return SQLITE_OK;
1.2281 +}
1.2282 +#endif /* SQLITE_ENABLE_LOCKING_STYLE */
1.2283 +
1.2284 +/*
1.2285 +** Open a file descriptor to the directory containing file zFilename.
1.2286 +** If successful, *pFd is set to the opened file descriptor and
1.2287 +** SQLITE_OK is returned. If an error occurs, either SQLITE_NOMEM
1.2288 +** or SQLITE_CANTOPEN is returned and *pFd is set to an undefined
1.2289 +** value.
1.2290 +**
1.2291 +** If SQLITE_OK is returned, the caller is responsible for closing
1.2292 +** the file descriptor *pFd using close().
1.2293 +*/
1.2294 +static int openDirectory(const char *zFilename, int *pFd){
1.2295 + int ii;
1.2296 + int fd = -1;
1.2297 + char zDirname[MAX_PATHNAME+1];
1.2298 +
1.2299 + sqlite3_snprintf(MAX_PATHNAME, zDirname, "%s", zFilename);
1.2300 + for(ii=strlen(zDirname); ii>=0 && zDirname[ii]!='/'; ii--);
1.2301 + if( ii>0 ){
1.2302 + zDirname[ii] = '\0';
1.2303 + fd = open(zDirname, O_RDONLY|O_BINARY, 0);
1.2304 + if( fd>=0 ){
1.2305 +#ifdef FD_CLOEXEC
1.2306 + fcntl(fd, F_SETFD, fcntl(fd, F_GETFD, 0) | FD_CLOEXEC);
1.2307 +#endif
1.2308 + OSTRACE3("OPENDIR %-3d %s\n", fd, zDirname);
1.2309 + }
1.2310 + }
1.2311 + *pFd = fd;
1.2312 + return (fd>=0?SQLITE_OK:SQLITE_CANTOPEN);
1.2313 +}
1.2314 +
1.2315 +/*
1.2316 +** Open the file zPath.
1.2317 +**
1.2318 +** Previously, the SQLite OS layer used three functions in place of this
1.2319 +** one:
1.2320 +**
1.2321 +** sqlite3OsOpenReadWrite();
1.2322 +** sqlite3OsOpenReadOnly();
1.2323 +** sqlite3OsOpenExclusive();
1.2324 +**
1.2325 +** These calls correspond to the following combinations of flags:
1.2326 +**
1.2327 +** ReadWrite() -> (READWRITE | CREATE)
1.2328 +** ReadOnly() -> (READONLY)
1.2329 +** OpenExclusive() -> (READWRITE | CREATE | EXCLUSIVE)
1.2330 +**
1.2331 +** The old OpenExclusive() accepted a boolean argument - "delFlag". If
1.2332 +** true, the file was configured to be automatically deleted when the
1.2333 +** file handle closed. To achieve the same effect using this new
1.2334 +** interface, add the DELETEONCLOSE flag to those specified above for
1.2335 +** OpenExclusive().
1.2336 +*/
1.2337 +static int unixOpen(
1.2338 + sqlite3_vfs *pVfs,
1.2339 + const char *zPath,
1.2340 + sqlite3_file *pFile,
1.2341 + int flags,
1.2342 + int *pOutFlags
1.2343 +){
1.2344 + int fd = 0; /* File descriptor returned by open() */
1.2345 + int dirfd = -1; /* Directory file descriptor */
1.2346 + int oflags = 0; /* Flags to pass to open() */
1.2347 + int eType = flags&0xFFFFFF00; /* Type of file to open */
1.2348 +
1.2349 + int isExclusive = (flags & SQLITE_OPEN_EXCLUSIVE);
1.2350 + int isDelete = (flags & SQLITE_OPEN_DELETEONCLOSE);
1.2351 + int isCreate = (flags & SQLITE_OPEN_CREATE);
1.2352 + int isReadonly = (flags & SQLITE_OPEN_READONLY);
1.2353 + int isReadWrite = (flags & SQLITE_OPEN_READWRITE);
1.2354 +
1.2355 + /* If creating a master or main-file journal, this function will open
1.2356 + ** a file-descriptor on the directory too. The first time unixSync()
1.2357 + ** is called the directory file descriptor will be fsync()ed and close()d.
1.2358 + */
1.2359 + int isOpenDirectory = (isCreate &&
1.2360 + (eType==SQLITE_OPEN_MASTER_JOURNAL || eType==SQLITE_OPEN_MAIN_JOURNAL)
1.2361 + );
1.2362 +
1.2363 + /* Check the following statements are true:
1.2364 + **
1.2365 + ** (a) Exactly one of the READWRITE and READONLY flags must be set, and
1.2366 + ** (b) if CREATE is set, then READWRITE must also be set, and
1.2367 + ** (c) if EXCLUSIVE is set, then CREATE must also be set.
1.2368 + ** (d) if DELETEONCLOSE is set, then CREATE must also be set.
1.2369 + */
1.2370 + assert((isReadonly==0 || isReadWrite==0) && (isReadWrite || isReadonly));
1.2371 + assert(isCreate==0 || isReadWrite);
1.2372 + assert(isExclusive==0 || isCreate);
1.2373 + assert(isDelete==0 || isCreate);
1.2374 +
1.2375 +
1.2376 + /* The main DB, main journal, and master journal are never automatically
1.2377 + ** deleted
1.2378 + */
1.2379 + assert( eType!=SQLITE_OPEN_MAIN_DB || !isDelete );
1.2380 + assert( eType!=SQLITE_OPEN_MAIN_JOURNAL || !isDelete );
1.2381 + assert( eType!=SQLITE_OPEN_MASTER_JOURNAL || !isDelete );
1.2382 +
1.2383 + /* Assert that the upper layer has set one of the "file-type" flags. */
1.2384 + assert( eType==SQLITE_OPEN_MAIN_DB || eType==SQLITE_OPEN_TEMP_DB
1.2385 + || eType==SQLITE_OPEN_MAIN_JOURNAL || eType==SQLITE_OPEN_TEMP_JOURNAL
1.2386 + || eType==SQLITE_OPEN_SUBJOURNAL || eType==SQLITE_OPEN_MASTER_JOURNAL
1.2387 + || eType==SQLITE_OPEN_TRANSIENT_DB
1.2388 + );
1.2389 +
1.2390 + if( isReadonly ) oflags |= O_RDONLY;
1.2391 + if( isReadWrite ) oflags |= O_RDWR;
1.2392 + if( isCreate ) oflags |= O_CREAT;
1.2393 + if( isExclusive ) oflags |= (O_EXCL|O_NOFOLLOW);
1.2394 + oflags |= (O_LARGEFILE|O_BINARY);
1.2395 +
1.2396 + memset(pFile, 0, sizeof(unixFile));
1.2397 + fd = open(zPath, oflags, isDelete?0600:SQLITE_DEFAULT_FILE_PERMISSIONS);
1.2398 + if( fd<0 && errno!=EISDIR && isReadWrite && !isExclusive ){
1.2399 + /* Failed to open the file for read/write access. Try read-only. */
1.2400 + flags &= ~(SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE);
1.2401 + flags |= SQLITE_OPEN_READONLY;
1.2402 + return unixOpen(pVfs, zPath, pFile, flags, pOutFlags);
1.2403 + }
1.2404 + if( fd<0 ){
1.2405 + return SQLITE_CANTOPEN;
1.2406 + }
1.2407 + if( isDelete ){
1.2408 + unlink(zPath);
1.2409 + }
1.2410 + if( pOutFlags ){
1.2411 + *pOutFlags = flags;
1.2412 + }
1.2413 +
1.2414 + assert(fd!=0);
1.2415 + if( isOpenDirectory ){
1.2416 + int rc = openDirectory(zPath, &dirfd);
1.2417 + if( rc!=SQLITE_OK ){
1.2418 + close(fd);
1.2419 + return rc;
1.2420 + }
1.2421 + }
1.2422 + return fillInUnixFile(fd, dirfd, pFile, zPath);
1.2423 +}
1.2424 +
1.2425 +/*
1.2426 +** Delete the file at zPath. If the dirSync argument is true, fsync()
1.2427 +** the directory after deleting the file.
1.2428 +*/
1.2429 +static int unixDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){
1.2430 + int rc = SQLITE_OK;
1.2431 + SimulateIOError(return SQLITE_IOERR_DELETE);
1.2432 + unlink(zPath);
1.2433 + if( dirSync ){
1.2434 + int fd;
1.2435 + rc = openDirectory(zPath, &fd);
1.2436 + if( rc==SQLITE_OK ){
1.2437 + if( fsync(fd) ){
1.2438 + rc = SQLITE_IOERR_DIR_FSYNC;
1.2439 + }
1.2440 + close(fd);
1.2441 + }
1.2442 + }
1.2443 + return rc;
1.2444 +}
1.2445 +
1.2446 +/*
1.2447 +** Test the existance of or access permissions of file zPath. The
1.2448 +** test performed depends on the value of flags:
1.2449 +**
1.2450 +** SQLITE_ACCESS_EXISTS: Return 1 if the file exists
1.2451 +** SQLITE_ACCESS_READWRITE: Return 1 if the file is read and writable.
1.2452 +** SQLITE_ACCESS_READONLY: Return 1 if the file is readable.
1.2453 +**
1.2454 +** Otherwise return 0.
1.2455 +*/
1.2456 +static int unixAccess(sqlite3_vfs *pVfs, const char *zPath, int flags){
1.2457 + int amode = 0;
1.2458 + switch( flags ){
1.2459 + case SQLITE_ACCESS_EXISTS:
1.2460 + amode = F_OK;
1.2461 + break;
1.2462 + case SQLITE_ACCESS_READWRITE:
1.2463 + amode = W_OK|R_OK;
1.2464 + break;
1.2465 + case SQLITE_ACCESS_READ:
1.2466 + amode = R_OK;
1.2467 + break;
1.2468 +
1.2469 + default:
1.2470 + assert(!"Invalid flags argument");
1.2471 + }
1.2472 + return (access(zPath, amode)==0);
1.2473 +}
1.2474 +
1.2475 +/*
1.2476 +** Create a temporary file name in zBuf. zBuf must be allocated
1.2477 +** by the calling process and must be big enough to hold at least
1.2478 +** pVfs->mxPathname bytes.
1.2479 +*/
1.2480 +static int unixGetTempname(sqlite3_vfs *pVfs, int nBuf, char *zBuf){
1.2481 + static const char *azDirs[] = {
1.2482 + 0,
1.2483 + "/var/tmp",
1.2484 + "/usr/tmp",
1.2485 + "/tmp",
1.2486 + ".",
1.2487 + };
1.2488 + static const unsigned char zChars[] =
1.2489 + "abcdefghijklmnopqrstuvwxyz"
1.2490 + "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1.2491 + "0123456789";
1.2492 + int i, j;
1.2493 + struct stat buf;
1.2494 + const char *zDir = ".";
1.2495 +
1.2496 + /* It's odd to simulate an io-error here, but really this is just
1.2497 + ** using the io-error infrastructure to test that SQLite handles this
1.2498 + ** function failing.
1.2499 + */
1.2500 + SimulateIOError( return SQLITE_ERROR );
1.2501 +
1.2502 + azDirs[0] = sqlite3_temp_directory;
1.2503 + for(i=0; i<sizeof(azDirs)/sizeof(azDirs[0]); i++){
1.2504 + if( azDirs[i]==0 ) continue;
1.2505 + if( stat(azDirs[i], &buf) ) continue;
1.2506 + if( !S_ISDIR(buf.st_mode) ) continue;
1.2507 + if( access(azDirs[i], 07) ) continue;
1.2508 + zDir = azDirs[i];
1.2509 + break;
1.2510 + }
1.2511 + do{
1.2512 + assert( pVfs->mxPathname==MAX_PATHNAME );
1.2513 + assert( nBuf>=MAX_PATHNAME );
1.2514 + sqlite3_snprintf(MAX_PATHNAME-17, zBuf, "%s/"SQLITE_TEMP_FILE_PREFIX, zDir);
1.2515 + j = strlen(zBuf);
1.2516 + sqlite3Randomness(15, &zBuf[j]);
1.2517 + for(i=0; i<15; i++, j++){
1.2518 + zBuf[j] = (char)zChars[ ((unsigned char)zBuf[j])%(sizeof(zChars)-1) ];
1.2519 + }
1.2520 + zBuf[j] = 0;
1.2521 + }while( access(zBuf,0)==0 );
1.2522 + return SQLITE_OK;
1.2523 +}
1.2524 +
1.2525 +
1.2526 +/*
1.2527 +** Turn a relative pathname into a full pathname. The relative path
1.2528 +** is stored as a nul-terminated string in the buffer pointed to by
1.2529 +** zPath.
1.2530 +**
1.2531 +** zOut points to a buffer of at least sqlite3_vfs.mxPathname bytes
1.2532 +** (in this case, MAX_PATHNAME bytes). The full-path is written to
1.2533 +** this buffer before returning.
1.2534 +*/
1.2535 +static int unixFullPathname(
1.2536 + sqlite3_vfs *pVfs, /* Pointer to vfs object */
1.2537 + const char *zPath, /* Possibly relative input path */
1.2538 + int nOut, /* Size of output buffer in bytes */
1.2539 + char *zOut /* Output buffer */
1.2540 +){
1.2541 +
1.2542 + /* It's odd to simulate an io-error here, but really this is just
1.2543 + ** using the io-error infrastructure to test that SQLite handles this
1.2544 + ** function failing. This function could fail if, for example, the
1.2545 + ** current working directly has been unlinked.
1.2546 + */
1.2547 + SimulateIOError( return SQLITE_ERROR );
1.2548 +
1.2549 + assert( pVfs->mxPathname==MAX_PATHNAME );
1.2550 + zOut[MAX_PATHNAME-1] = '\0';
1.2551 + if( zPath[0]=='/' ){
1.2552 + sqlite3_snprintf(MAX_PATHNAME, zOut, "%s", zPath);
1.2553 + }else{
1.2554 + int nCwd;
1.2555 + if( getcwd(zOut, MAX_PATHNAME-1)==0 ){
1.2556 + return SQLITE_CANTOPEN;
1.2557 + }
1.2558 + nCwd = strlen(zOut);
1.2559 + sqlite3_snprintf(MAX_PATHNAME-nCwd, &zOut[nCwd], "/%s", zPath);
1.2560 + }
1.2561 + return SQLITE_OK;
1.2562 +
1.2563 +#if 0
1.2564 + /*
1.2565 + ** Remove "/./" path elements and convert "/A/./" path elements
1.2566 + ** to just "/".
1.2567 + */
1.2568 + if( zFull ){
1.2569 + int i, j;
1.2570 + for(i=j=0; zFull[i]; i++){
1.2571 + if( zFull[i]=='/' ){
1.2572 + if( zFull[i+1]=='/' ) continue;
1.2573 + if( zFull[i+1]=='.' && zFull[i+2]=='/' ){
1.2574 + i += 1;
1.2575 + continue;
1.2576 + }
1.2577 + if( zFull[i+1]=='.' && zFull[i+2]=='.' && zFull[i+3]=='/' ){
1.2578 + while( j>0 && zFull[j-1]!='/' ){ j--; }
1.2579 + i += 3;
1.2580 + continue;
1.2581 + }
1.2582 + }
1.2583 + zFull[j++] = zFull[i];
1.2584 + }
1.2585 + zFull[j] = 0;
1.2586 + }
1.2587 +#endif
1.2588 +}
1.2589 +
1.2590 +
1.2591 +#ifndef SQLITE_OMIT_LOAD_EXTENSION
1.2592 +/*
1.2593 +** Interfaces for opening a shared library, finding entry points
1.2594 +** within the shared library, and closing the shared library.
1.2595 +*/
1.2596 +#include <dlfcn.h>
1.2597 +static void *unixDlOpen(sqlite3_vfs *pVfs, const char *zFilename){
1.2598 + return dlopen(zFilename, RTLD_NOW | RTLD_GLOBAL);
1.2599 +}
1.2600 +
1.2601 +/*
1.2602 +** SQLite calls this function immediately after a call to unixDlSym() or
1.2603 +** unixDlOpen() fails (returns a null pointer). If a more detailed error
1.2604 +** message is available, it is written to zBufOut. If no error message
1.2605 +** is available, zBufOut is left unmodified and SQLite uses a default
1.2606 +** error message.
1.2607 +*/
1.2608 +static void unixDlError(sqlite3_vfs *pVfs, int nBuf, char *zBufOut){
1.2609 + char *zErr;
1.2610 + enterMutex();
1.2611 + zErr = dlerror();
1.2612 + if( zErr ){
1.2613 + sqlite3_snprintf(nBuf, zBufOut, "%s", zErr);
1.2614 + }
1.2615 + leaveMutex();
1.2616 +}
1.2617 +static void *unixDlSym(sqlite3_vfs *pVfs, void *pHandle, const char *zSymbol){
1.2618 + return dlsym(pHandle, zSymbol);
1.2619 +}
1.2620 +static void unixDlClose(sqlite3_vfs *pVfs, void *pHandle){
1.2621 + dlclose(pHandle);
1.2622 +}
1.2623 +#else /* if SQLITE_OMIT_LOAD_EXTENSION is defined: */
1.2624 + #define unixDlOpen 0
1.2625 + #define unixDlError 0
1.2626 + #define unixDlSym 0
1.2627 + #define unixDlClose 0
1.2628 +#endif
1.2629 +
1.2630 +/*
1.2631 +** Write nBuf bytes of random data to the supplied buffer zBuf.
1.2632 +*/
1.2633 +static int unixRandomness(sqlite3_vfs *pVfs, int nBuf, char *zBuf){
1.2634 +
1.2635 + assert(nBuf>=(sizeof(time_t)+sizeof(int)));
1.2636 +
1.2637 + /* We have to initialize zBuf to prevent valgrind from reporting
1.2638 + ** errors. The reports issued by valgrind are incorrect - we would
1.2639 + ** prefer that the randomness be increased by making use of the
1.2640 + ** uninitialized space in zBuf - but valgrind errors tend to worry
1.2641 + ** some users. Rather than argue, it seems easier just to initialize
1.2642 + ** the whole array and silence valgrind, even if that means less randomness
1.2643 + ** in the random seed.
1.2644 + **
1.2645 + ** When testing, initializing zBuf[] to zero is all we do. That means
1.2646 + ** that we always use the same random number sequence. This makes the
1.2647 + ** tests repeatable.
1.2648 + */
1.2649 + memset(zBuf, 0, nBuf);
1.2650 +#if !defined(SQLITE_TEST)
1.2651 + {
1.2652 + int pid, fd;
1.2653 + fd = open("/dev/urandom", O_RDONLY);
1.2654 + if( fd<0 ){
1.2655 + time_t t;
1.2656 + time(&t);
1.2657 + memcpy(zBuf, &t, sizeof(t));
1.2658 + pid = getpid();
1.2659 + memcpy(&zBuf[sizeof(t)], &pid, sizeof(pid));
1.2660 + }else{
1.2661 + read(fd, zBuf, nBuf);
1.2662 + close(fd);
1.2663 + }
1.2664 + }
1.2665 +#endif
1.2666 + return SQLITE_OK;
1.2667 +}
1.2668 +
1.2669 +
1.2670 +/*
1.2671 +** Sleep for a little while. Return the amount of time slept.
1.2672 +** The argument is the number of microseconds we want to sleep.
1.2673 +** The return value is the number of microseconds of sleep actually
1.2674 +** requested from the underlying operating system, a number which
1.2675 +** might be greater than or equal to the argument, but not less
1.2676 +** than the argument.
1.2677 +*/
1.2678 +static int unixSleep(sqlite3_vfs *pVfs, int microseconds){
1.2679 +#if defined(HAVE_USLEEP) && HAVE_USLEEP
1.2680 + usleep(microseconds);
1.2681 + return microseconds;
1.2682 +#else
1.2683 + int seconds = (microseconds+999999)/1000000;
1.2684 + sleep(seconds);
1.2685 + return seconds*1000000;
1.2686 +#endif
1.2687 +}
1.2688 +
1.2689 +/*
1.2690 +** The following variable, if set to a non-zero value, becomes the result
1.2691 +** returned from sqlite3OsCurrentTime(). This is used for testing.
1.2692 +*/
1.2693 +#ifdef SQLITE_TEST
1.2694 +int sqlite3_current_time = 0;
1.2695 +#endif
1.2696 +
1.2697 +/*
1.2698 +** Find the current time (in Universal Coordinated Time). Write the
1.2699 +** current time and date as a Julian Day number into *prNow and
1.2700 +** return 0. Return 1 if the time and date cannot be found.
1.2701 +*/
1.2702 +static int unixCurrentTime(sqlite3_vfs *pVfs, double *prNow){
1.2703 +#ifdef NO_GETTOD
1.2704 + time_t t;
1.2705 + time(&t);
1.2706 + *prNow = t/86400.0 + 2440587.5;
1.2707 +#else
1.2708 + struct timeval sNow;
1.2709 + gettimeofday(&sNow, 0);
1.2710 + *prNow = 2440587.5 + sNow.tv_sec/86400.0 + sNow.tv_usec/86400000000.0;
1.2711 +#endif
1.2712 +#ifdef SQLITE_TEST
1.2713 + if( sqlite3_current_time ){
1.2714 + *prNow = sqlite3_current_time/86400.0 + 2440587.5;
1.2715 + }
1.2716 +#endif
1.2717 + return 0;
1.2718 +}
1.2719 +
1.2720 +/*
1.2721 +** Return a pointer to the sqlite3DefaultVfs structure. We use
1.2722 +** a function rather than give the structure global scope because
1.2723 +** some compilers (MSVC) do not allow forward declarations of
1.2724 +** initialized structures.
1.2725 +*/
1.2726 +sqlite3_vfs *sqlite3OsDefaultVfs(void){
1.2727 + static sqlite3_vfs unixVfs = {
1.2728 + 1, /* iVersion */
1.2729 + sizeof(unixFile), /* szOsFile */
1.2730 + MAX_PATHNAME, /* mxPathname */
1.2731 + 0, /* pNext */
1.2732 + "unix", /* zName */
1.2733 + 0, /* pAppData */
1.2734 +
1.2735 + unixOpen, /* xOpen */
1.2736 + unixDelete, /* xDelete */
1.2737 + unixAccess, /* xAccess */
1.2738 + unixGetTempname, /* xGetTempName */
1.2739 + unixFullPathname, /* xFullPathname */
1.2740 + unixDlOpen, /* xDlOpen */
1.2741 + unixDlError, /* xDlError */
1.2742 + unixDlSym, /* xDlSym */
1.2743 + unixDlClose, /* xDlClose */
1.2744 + unixRandomness, /* xRandomness */
1.2745 + unixSleep, /* xSleep */
1.2746 + unixCurrentTime /* xCurrentTime */
1.2747 + };
1.2748 +
1.2749 + return &unixVfs;
1.2750 +}
1.2751 +
1.2752 +#endif /* OS_UNIX */
