blob: 868e029f8275cf058a093ee145781efcae8b7e66 [file] [log] [blame]
drhbbd42a62004-05-22 17:41:58 +00001/*
2** 2004 May 22
3**
4** The author disclaims copyright to this source code. In place of
5** a legal notice, here is a blessing:
6**
7** May you do good and not evil.
8** May you find forgiveness for yourself and forgive others.
9** May you share freely, never taking more than you give.
10**
11******************************************************************************
12**
drh734c9862008-11-28 15:37:20 +000013** This file contains the VFS implementation for unix-like operating systems
14** include Linux, MacOSX, *BSD, QNX, VxWorks, AIX, HPUX, and others.
danielk1977822a5162008-05-16 04:51:54 +000015**
drh734c9862008-11-28 15:37:20 +000016** There are actually several different VFS implementations in this file.
17** The differences are in the way that file locking is done. The default
18** implementation uses Posix Advisory Locks. Alternative implementations
19** use flock(), dot-files, various proprietary locking schemas, or simply
20** skip locking all together.
21**
drh9b35ea62008-11-29 02:20:26 +000022** This source file is organized into divisions where the logic for various
drh734c9862008-11-28 15:37:20 +000023** subfunctions is contained within the appropriate division. PLEASE
24** KEEP THE STRUCTURE OF THIS FILE INTACT. New code should be placed
25** in the correct division and should be clearly labeled.
26**
drh6b9d6dd2008-12-03 19:34:47 +000027** The layout of divisions is as follows:
drh734c9862008-11-28 15:37:20 +000028**
29** * General-purpose declarations and utility functions.
30** * Unique file ID logic used by VxWorks.
drh715ff302008-12-03 22:32:44 +000031** * Various locking primitive implementations (all except proxy locking):
drh734c9862008-11-28 15:37:20 +000032** + for Posix Advisory Locks
33** + for no-op locks
34** + for dot-file locks
35** + for flock() locking
36** + for named semaphore locks (VxWorks only)
37** + for AFP filesystem locks (MacOSX only)
drh9b35ea62008-11-29 02:20:26 +000038** * sqlite3_file methods not associated with locking.
39** * Definitions of sqlite3_io_methods objects for all locking
40** methods plus "finder" functions for each locking method.
drh6b9d6dd2008-12-03 19:34:47 +000041** * sqlite3_vfs method implementations.
drh715ff302008-12-03 22:32:44 +000042** * Locking primitives for the proxy uber-locking-method. (MacOSX only)
drh9b35ea62008-11-29 02:20:26 +000043** * Definitions of sqlite3_vfs objects for all locking methods
44** plus implementations of sqlite3_os_init() and sqlite3_os_end().
drhbbd42a62004-05-22 17:41:58 +000045*/
drhbbd42a62004-05-22 17:41:58 +000046#include "sqliteInt.h"
danielk197729bafea2008-06-26 10:41:19 +000047#if SQLITE_OS_UNIX /* This file is used on unix only */
drh66560ad2006-01-06 14:32:19 +000048
danielk1977e339d652008-06-28 11:23:00 +000049/*
drh6b9d6dd2008-12-03 19:34:47 +000050** There are various methods for file locking used for concurrency
51** control:
danielk1977e339d652008-06-28 11:23:00 +000052**
drh734c9862008-11-28 15:37:20 +000053** 1. POSIX locking (the default),
54** 2. No locking,
55** 3. Dot-file locking,
56** 4. flock() locking,
57** 5. AFP locking (OSX only),
58** 6. Named POSIX semaphores (VXWorks only),
59** 7. proxy locking. (OSX only)
60**
61** Styles 4, 5, and 7 are only available of SQLITE_ENABLE_LOCKING_STYLE
62** is defined to 1. The SQLITE_ENABLE_LOCKING_STYLE also enables automatic
63** selection of the appropriate locking style based on the filesystem
64** where the database is located.
danielk1977e339d652008-06-28 11:23:00 +000065*/
drh40bbb0a2008-09-23 10:23:26 +000066#if !defined(SQLITE_ENABLE_LOCKING_STYLE)
drhd2cb50b2009-01-09 21:41:17 +000067# if defined(__APPLE__)
drh40bbb0a2008-09-23 10:23:26 +000068# define SQLITE_ENABLE_LOCKING_STYLE 1
69# else
70# define SQLITE_ENABLE_LOCKING_STYLE 0
71# endif
72#endif
drhbfe66312006-10-03 17:40:40 +000073
drh9cbe6352005-11-29 03:13:21 +000074/*
drh6c7d5c52008-11-21 20:32:33 +000075** Define the OS_VXWORKS pre-processor macro to 1 if building on
danielk1977397d65f2008-11-19 11:35:39 +000076** vxworks, or 0 otherwise.
77*/
drh6c7d5c52008-11-21 20:32:33 +000078#ifndef OS_VXWORKS
79# if defined(__RTP__) || defined(_WRS_KERNEL)
80# define OS_VXWORKS 1
81# else
82# define OS_VXWORKS 0
83# endif
danielk1977397d65f2008-11-19 11:35:39 +000084#endif
85
86/*
drh9cbe6352005-11-29 03:13:21 +000087** These #defines should enable >2GB file support on Posix if the
88** underlying operating system supports it. If the OS lacks
drhf1a221e2006-01-15 17:27:17 +000089** large file support, these should be no-ops.
drh9cbe6352005-11-29 03:13:21 +000090**
91** Large file support can be disabled using the -DSQLITE_DISABLE_LFS switch
92** on the compiler command line. This is necessary if you are compiling
93** on a recent machine (ex: RedHat 7.2) but you want your code to work
94** on an older machine (ex: RedHat 6.0). If you compile on RedHat 7.2
95** without this option, LFS is enable. But LFS does not exist in the kernel
96** in RedHat 6.0, so the code won't work. Hence, for maximum binary
97** portability you should omit LFS.
drh9b35ea62008-11-29 02:20:26 +000098**
99** The previous paragraph was written in 2005. (This paragraph is written
100** on 2008-11-28.) These days, all Linux kernels support large files, so
101** you should probably leave LFS enabled. But some embedded platforms might
102** lack LFS in which case the SQLITE_DISABLE_LFS macro might still be useful.
drh9cbe6352005-11-29 03:13:21 +0000103*/
104#ifndef SQLITE_DISABLE_LFS
105# define _LARGE_FILE 1
106# ifndef _FILE_OFFSET_BITS
107# define _FILE_OFFSET_BITS 64
108# endif
109# define _LARGEFILE_SOURCE 1
110#endif
drhbbd42a62004-05-22 17:41:58 +0000111
drh9cbe6352005-11-29 03:13:21 +0000112/*
113** standard include files.
114*/
115#include <sys/types.h>
116#include <sys/stat.h>
117#include <fcntl.h>
118#include <unistd.h>
drhbbd42a62004-05-22 17:41:58 +0000119#include <time.h>
drh19e2d372005-08-29 23:00:03 +0000120#include <sys/time.h>
drhbbd42a62004-05-22 17:41:58 +0000121#include <errno.h>
drhb469f462010-12-22 21:48:50 +0000122#ifndef SQLITE_OMIT_WAL
drhf2424c52010-04-26 00:04:55 +0000123#include <sys/mman.h>
drhb469f462010-12-22 21:48:50 +0000124#endif
danielk1977e339d652008-06-28 11:23:00 +0000125
drh40bbb0a2008-09-23 10:23:26 +0000126#if SQLITE_ENABLE_LOCKING_STYLE
danielk1977c70dfc42008-11-19 13:52:30 +0000127# include <sys/ioctl.h>
drh6c7d5c52008-11-21 20:32:33 +0000128# if OS_VXWORKS
danielk1977c70dfc42008-11-19 13:52:30 +0000129# include <semaphore.h>
130# include <limits.h>
131# else
drh9b35ea62008-11-29 02:20:26 +0000132# include <sys/file.h>
danielk1977c70dfc42008-11-19 13:52:30 +0000133# include <sys/param.h>
danielk1977c70dfc42008-11-19 13:52:30 +0000134# endif
drhbfe66312006-10-03 17:40:40 +0000135#endif /* SQLITE_ENABLE_LOCKING_STYLE */
drh9cbe6352005-11-29 03:13:21 +0000136
drhf8b4d8c2010-03-05 13:53:22 +0000137#if defined(__APPLE__) || (SQLITE_ENABLE_LOCKING_STYLE && !OS_VXWORKS)
drh84a2bf62010-03-05 13:41:06 +0000138# include <sys/mount.h>
139#endif
140
drhdbe4b882011-06-20 18:00:17 +0000141#ifdef HAVE_UTIME
142# include <utime.h>
143#endif
144
drh9cbe6352005-11-29 03:13:21 +0000145/*
drh7ed97b92010-01-20 13:07:21 +0000146** Allowed values of unixFile.fsFlags
147*/
148#define SQLITE_FSFLAGS_IS_MSDOS 0x1
149
150/*
drhf1a221e2006-01-15 17:27:17 +0000151** If we are to be thread-safe, include the pthreads header and define
152** the SQLITE_UNIX_THREADS macro.
drh9cbe6352005-11-29 03:13:21 +0000153*/
drhd677b3d2007-08-20 22:48:41 +0000154#if SQLITE_THREADSAFE
drh9cbe6352005-11-29 03:13:21 +0000155# include <pthread.h>
156# define SQLITE_UNIX_THREADS 1
157#endif
158
159/*
160** Default permissions when creating a new file
161*/
162#ifndef SQLITE_DEFAULT_FILE_PERMISSIONS
163# define SQLITE_DEFAULT_FILE_PERMISSIONS 0644
164#endif
165
danielk1977b4b47412007-08-17 15:53:36 +0000166/*
aswiftaebf4132008-11-21 00:10:35 +0000167 ** Default permissions when creating auto proxy dir
168 */
169#ifndef SQLITE_DEFAULT_PROXYDIR_PERMISSIONS
170# define SQLITE_DEFAULT_PROXYDIR_PERMISSIONS 0755
171#endif
172
173/*
danielk1977b4b47412007-08-17 15:53:36 +0000174** Maximum supported path-length.
175*/
176#define MAX_PATHNAME 512
drh9cbe6352005-11-29 03:13:21 +0000177
drh734c9862008-11-28 15:37:20 +0000178/*
drh734c9862008-11-28 15:37:20 +0000179** Only set the lastErrno if the error code is a real error and not
180** a normal expected return code of SQLITE_BUSY or SQLITE_OK
181*/
182#define IS_LOCK_ERROR(x) ((x != SQLITE_OK) && (x != SQLITE_BUSY))
183
drhd91c68f2010-05-14 14:52:25 +0000184/* Forward references */
185typedef struct unixShm unixShm; /* Connection shared memory */
186typedef struct unixShmNode unixShmNode; /* Shared memory instance */
187typedef struct unixInodeInfo unixInodeInfo; /* An i-node */
188typedef struct UnixUnusedFd UnixUnusedFd; /* An unused file descriptor */
drh9cbe6352005-11-29 03:13:21 +0000189
190/*
dane946c392009-08-22 11:39:46 +0000191** Sometimes, after a file handle is closed by SQLite, the file descriptor
192** cannot be closed immediately. In these cases, instances of the following
193** structure are used to store the file descriptor while waiting for an
194** opportunity to either close or reuse it.
195*/
dane946c392009-08-22 11:39:46 +0000196struct UnixUnusedFd {
197 int fd; /* File descriptor to close */
198 int flags; /* Flags this file descriptor was opened with */
199 UnixUnusedFd *pNext; /* Next unused file descriptor on same file */
200};
201
202/*
drh9b35ea62008-11-29 02:20:26 +0000203** The unixFile structure is subclass of sqlite3_file specific to the unix
204** VFS implementations.
drh9cbe6352005-11-29 03:13:21 +0000205*/
drh054889e2005-11-30 03:20:31 +0000206typedef struct unixFile unixFile;
207struct unixFile {
danielk197762079062007-08-15 17:08:46 +0000208 sqlite3_io_methods const *pMethod; /* Always the first entry */
drhd91c68f2010-05-14 14:52:25 +0000209 unixInodeInfo *pInode; /* Info about locks on this inode */
drh8af6c222010-05-14 12:43:01 +0000210 int h; /* The file descriptor */
drh8af6c222010-05-14 12:43:01 +0000211 unsigned char eFileLock; /* The type of lock held on this fd */
drha7e61d82011-03-12 17:02:57 +0000212 unsigned char ctrlFlags; /* Behavioral bits. UNIXFILE_* flags */
drh8af6c222010-05-14 12:43:01 +0000213 int lastErrno; /* The unix errno from last I/O error */
214 void *lockingContext; /* Locking style specific state */
215 UnixUnusedFd *pUnused; /* Pre-allocated UnixUnusedFd */
drh8af6c222010-05-14 12:43:01 +0000216 const char *zPath; /* Name of the file */
217 unixShm *pShm; /* Shared memory segment information */
dan6e09d692010-07-27 18:34:15 +0000218 int szChunk; /* Configured by FCNTL_CHUNK_SIZE */
drh08c6d442009-02-09 17:34:07 +0000219#if SQLITE_ENABLE_LOCKING_STYLE
drh8af6c222010-05-14 12:43:01 +0000220 int openFlags; /* The flags specified at open() */
drh08c6d442009-02-09 17:34:07 +0000221#endif
drh7ed97b92010-01-20 13:07:21 +0000222#if SQLITE_ENABLE_LOCKING_STYLE || defined(__APPLE__)
drh8af6c222010-05-14 12:43:01 +0000223 unsigned fsFlags; /* cached details from statfs() */
drh6c7d5c52008-11-21 20:32:33 +0000224#endif
225#if OS_VXWORKS
drh8af6c222010-05-14 12:43:01 +0000226 int isDelete; /* Delete on close if true */
227 struct vxworksFileId *pId; /* Unique file ID */
drh6c7d5c52008-11-21 20:32:33 +0000228#endif
drh8f941bc2009-01-14 23:03:40 +0000229#ifndef NDEBUG
230 /* The next group of variables are used to track whether or not the
231 ** transaction counter in bytes 24-27 of database files are updated
232 ** whenever any part of the database changes. An assertion fault will
233 ** occur if a file is updated without also updating the transaction
234 ** counter. This test is made to avoid new problems similar to the
235 ** one described by ticket #3584.
236 */
237 unsigned char transCntrChng; /* True if the transaction counter changed */
238 unsigned char dbUpdate; /* True if any part of database file changed */
239 unsigned char inNormalWrite; /* True if in a normal write operation */
240#endif
danielk1977967a4a12007-08-20 14:23:44 +0000241#ifdef SQLITE_TEST
242 /* In test mode, increase the size of this structure a bit so that
243 ** it is larger than the struct CrashFile defined in test6.c.
244 */
245 char aPadding[32];
246#endif
drh9cbe6352005-11-29 03:13:21 +0000247};
248
drh0ccebe72005-06-07 22:22:50 +0000249/*
drha7e61d82011-03-12 17:02:57 +0000250** Allowed values for the unixFile.ctrlFlags bitmask:
251*/
drhf0b190d2011-07-26 16:03:07 +0000252#define UNIXFILE_EXCL 0x01 /* Connections from one process only */
253#define UNIXFILE_RDONLY 0x02 /* Connection is read only */
254#define UNIXFILE_PERSIST_WAL 0x04 /* Persistent WAL mode */
danee140c42011-08-25 13:46:32 +0000255#ifndef SQLITE_DISABLE_DIRSYNC
256# define UNIXFILE_DIRSYNC 0x08 /* Directory sync needed */
257#else
258# define UNIXFILE_DIRSYNC 0x00
259#endif
drha7e61d82011-03-12 17:02:57 +0000260
261/*
drh198bf392006-01-06 21:52:49 +0000262** Include code that is common to all os_*.c files
263*/
264#include "os_common.h"
265
266/*
drh0ccebe72005-06-07 22:22:50 +0000267** Define various macros that are missing from some systems.
268*/
drhbbd42a62004-05-22 17:41:58 +0000269#ifndef O_LARGEFILE
270# define O_LARGEFILE 0
271#endif
272#ifdef SQLITE_DISABLE_LFS
273# undef O_LARGEFILE
274# define O_LARGEFILE 0
275#endif
276#ifndef O_NOFOLLOW
277# define O_NOFOLLOW 0
278#endif
279#ifndef O_BINARY
280# define O_BINARY 0
281#endif
282
283/*
drh2b4b5962005-06-15 17:47:55 +0000284** The threadid macro resolves to the thread-id or to 0. Used for
285** testing and debugging only.
286*/
drhd677b3d2007-08-20 22:48:41 +0000287#if SQLITE_THREADSAFE
drh2b4b5962005-06-15 17:47:55 +0000288#define threadid pthread_self()
289#else
290#define threadid 0
291#endif
292
drh99ab3b12011-03-02 15:09:07 +0000293/*
drh9a3baf12011-04-25 18:01:27 +0000294** Different Unix systems declare open() in different ways. Same use
295** open(const char*,int,mode_t). Others use open(const char*,int,...).
296** The difference is important when using a pointer to the function.
297**
298** The safest way to deal with the problem is to always use this wrapper
299** which always has the same well-defined interface.
300*/
301static int posixOpen(const char *zFile, int flags, int mode){
302 return open(zFile, flags, mode);
303}
304
drh90315a22011-08-10 01:52:12 +0000305/* Forward reference */
306static int openDirectory(const char*, int*);
307
drh9a3baf12011-04-25 18:01:27 +0000308/*
drh99ab3b12011-03-02 15:09:07 +0000309** Many system calls are accessed through pointer-to-functions so that
310** they may be overridden at runtime to facilitate fault injection during
311** testing and sandboxing. The following array holds the names and pointers
312** to all overrideable system calls.
313*/
314static struct unix_syscall {
drh58ad5802011-03-23 22:02:23 +0000315 const char *zName; /* Name of the sytem call */
316 sqlite3_syscall_ptr pCurrent; /* Current value of the system call */
317 sqlite3_syscall_ptr pDefault; /* Default value */
drh99ab3b12011-03-02 15:09:07 +0000318} aSyscall[] = {
drh9a3baf12011-04-25 18:01:27 +0000319 { "open", (sqlite3_syscall_ptr)posixOpen, 0 },
320#define osOpen ((int(*)(const char*,int,int))aSyscall[0].pCurrent)
drh99ab3b12011-03-02 15:09:07 +0000321
drh58ad5802011-03-23 22:02:23 +0000322 { "close", (sqlite3_syscall_ptr)close, 0 },
drh99ab3b12011-03-02 15:09:07 +0000323#define osClose ((int(*)(int))aSyscall[1].pCurrent)
324
drh58ad5802011-03-23 22:02:23 +0000325 { "access", (sqlite3_syscall_ptr)access, 0 },
drh99ab3b12011-03-02 15:09:07 +0000326#define osAccess ((int(*)(const char*,int))aSyscall[2].pCurrent)
327
drh58ad5802011-03-23 22:02:23 +0000328 { "getcwd", (sqlite3_syscall_ptr)getcwd, 0 },
drh99ab3b12011-03-02 15:09:07 +0000329#define osGetcwd ((char*(*)(char*,size_t))aSyscall[3].pCurrent)
330
drh58ad5802011-03-23 22:02:23 +0000331 { "stat", (sqlite3_syscall_ptr)stat, 0 },
drh99ab3b12011-03-02 15:09:07 +0000332#define osStat ((int(*)(const char*,struct stat*))aSyscall[4].pCurrent)
333
334/*
335** The DJGPP compiler environment looks mostly like Unix, but it
336** lacks the fcntl() system call. So redefine fcntl() to be something
337** that always succeeds. This means that locking does not occur under
338** DJGPP. But it is DOS - what did you expect?
339*/
340#ifdef __DJGPP__
341 { "fstat", 0, 0 },
342#define osFstat(a,b,c) 0
343#else
drh58ad5802011-03-23 22:02:23 +0000344 { "fstat", (sqlite3_syscall_ptr)fstat, 0 },
drh99ab3b12011-03-02 15:09:07 +0000345#define osFstat ((int(*)(int,struct stat*))aSyscall[5].pCurrent)
346#endif
347
drh58ad5802011-03-23 22:02:23 +0000348 { "ftruncate", (sqlite3_syscall_ptr)ftruncate, 0 },
drh99ab3b12011-03-02 15:09:07 +0000349#define osFtruncate ((int(*)(int,off_t))aSyscall[6].pCurrent)
350
drh58ad5802011-03-23 22:02:23 +0000351 { "fcntl", (sqlite3_syscall_ptr)fcntl, 0 },
drh99ab3b12011-03-02 15:09:07 +0000352#define osFcntl ((int(*)(int,int,...))aSyscall[7].pCurrent)
drhe562be52011-03-02 18:01:10 +0000353
drh58ad5802011-03-23 22:02:23 +0000354 { "read", (sqlite3_syscall_ptr)read, 0 },
drhe562be52011-03-02 18:01:10 +0000355#define osRead ((ssize_t(*)(int,void*,size_t))aSyscall[8].pCurrent)
356
drhd4a80312011-04-15 14:33:20 +0000357#if defined(USE_PREAD) || SQLITE_ENABLE_LOCKING_STYLE
drh58ad5802011-03-23 22:02:23 +0000358 { "pread", (sqlite3_syscall_ptr)pread, 0 },
drhe562be52011-03-02 18:01:10 +0000359#else
drh58ad5802011-03-23 22:02:23 +0000360 { "pread", (sqlite3_syscall_ptr)0, 0 },
drhe562be52011-03-02 18:01:10 +0000361#endif
362#define osPread ((ssize_t(*)(int,void*,size_t,off_t))aSyscall[9].pCurrent)
363
364#if defined(USE_PREAD64)
drh58ad5802011-03-23 22:02:23 +0000365 { "pread64", (sqlite3_syscall_ptr)pread64, 0 },
drhe562be52011-03-02 18:01:10 +0000366#else
drh58ad5802011-03-23 22:02:23 +0000367 { "pread64", (sqlite3_syscall_ptr)0, 0 },
drhe562be52011-03-02 18:01:10 +0000368#endif
369#define osPread64 ((ssize_t(*)(int,void*,size_t,off_t))aSyscall[10].pCurrent)
370
drh58ad5802011-03-23 22:02:23 +0000371 { "write", (sqlite3_syscall_ptr)write, 0 },
drhe562be52011-03-02 18:01:10 +0000372#define osWrite ((ssize_t(*)(int,const void*,size_t))aSyscall[11].pCurrent)
373
drhd4a80312011-04-15 14:33:20 +0000374#if defined(USE_PREAD) || SQLITE_ENABLE_LOCKING_STYLE
drh58ad5802011-03-23 22:02:23 +0000375 { "pwrite", (sqlite3_syscall_ptr)pwrite, 0 },
drhe562be52011-03-02 18:01:10 +0000376#else
drh58ad5802011-03-23 22:02:23 +0000377 { "pwrite", (sqlite3_syscall_ptr)0, 0 },
drhe562be52011-03-02 18:01:10 +0000378#endif
379#define osPwrite ((ssize_t(*)(int,const void*,size_t,off_t))\
380 aSyscall[12].pCurrent)
381
382#if defined(USE_PREAD64)
drh58ad5802011-03-23 22:02:23 +0000383 { "pwrite64", (sqlite3_syscall_ptr)pwrite64, 0 },
drhe562be52011-03-02 18:01:10 +0000384#else
drh58ad5802011-03-23 22:02:23 +0000385 { "pwrite64", (sqlite3_syscall_ptr)0, 0 },
drhe562be52011-03-02 18:01:10 +0000386#endif
387#define osPwrite64 ((ssize_t(*)(int,const void*,size_t,off_t))\
388 aSyscall[13].pCurrent)
389
drha6c47492011-04-11 18:35:09 +0000390#if SQLITE_ENABLE_LOCKING_STYLE
drh58ad5802011-03-23 22:02:23 +0000391 { "fchmod", (sqlite3_syscall_ptr)fchmod, 0 },
drh2aa5a002011-04-13 13:42:25 +0000392#else
393 { "fchmod", (sqlite3_syscall_ptr)0, 0 },
drha6c47492011-04-11 18:35:09 +0000394#endif
drh2aa5a002011-04-13 13:42:25 +0000395#define osFchmod ((int(*)(int,mode_t))aSyscall[14].pCurrent)
drhe562be52011-03-02 18:01:10 +0000396
397#if defined(HAVE_POSIX_FALLOCATE) && HAVE_POSIX_FALLOCATE
drh58ad5802011-03-23 22:02:23 +0000398 { "fallocate", (sqlite3_syscall_ptr)posix_fallocate, 0 },
drhe562be52011-03-02 18:01:10 +0000399#else
drh58ad5802011-03-23 22:02:23 +0000400 { "fallocate", (sqlite3_syscall_ptr)0, 0 },
drhe562be52011-03-02 18:01:10 +0000401#endif
dan0fd7d862011-03-29 10:04:23 +0000402#define osFallocate ((int(*)(int,off_t,off_t))aSyscall[15].pCurrent)
drhe562be52011-03-02 18:01:10 +0000403
drh036ac7f2011-08-08 23:18:05 +0000404 { "unlink", (sqlite3_syscall_ptr)unlink, 0 },
405#define osUnlink ((int(*)(const char*))aSyscall[16].pCurrent)
406
drh90315a22011-08-10 01:52:12 +0000407 { "openDirectory", (sqlite3_syscall_ptr)openDirectory, 0 },
408#define osOpenDirectory ((int(*)(const char*,int*))aSyscall[17].pCurrent)
409
drhe562be52011-03-02 18:01:10 +0000410}; /* End of the overrideable system calls */
drh99ab3b12011-03-02 15:09:07 +0000411
412/*
413** This is the xSetSystemCall() method of sqlite3_vfs for all of the
drh1df30962011-03-02 19:06:42 +0000414** "unix" VFSes. Return SQLITE_OK opon successfully updating the
415** system call pointer, or SQLITE_NOTFOUND if there is no configurable
416** system call named zName.
drh99ab3b12011-03-02 15:09:07 +0000417*/
418static int unixSetSystemCall(
drh58ad5802011-03-23 22:02:23 +0000419 sqlite3_vfs *pNotUsed, /* The VFS pointer. Not used */
420 const char *zName, /* Name of system call to override */
421 sqlite3_syscall_ptr pNewFunc /* Pointer to new system call value */
drh99ab3b12011-03-02 15:09:07 +0000422){
drh58ad5802011-03-23 22:02:23 +0000423 unsigned int i;
drh1df30962011-03-02 19:06:42 +0000424 int rc = SQLITE_NOTFOUND;
drh58ad5802011-03-23 22:02:23 +0000425
426 UNUSED_PARAMETER(pNotUsed);
drh99ab3b12011-03-02 15:09:07 +0000427 if( zName==0 ){
428 /* If no zName is given, restore all system calls to their default
429 ** settings and return NULL
430 */
dan51438a72011-04-02 17:00:47 +0000431 rc = SQLITE_OK;
drh99ab3b12011-03-02 15:09:07 +0000432 for(i=0; i<sizeof(aSyscall)/sizeof(aSyscall[0]); i++){
433 if( aSyscall[i].pDefault ){
434 aSyscall[i].pCurrent = aSyscall[i].pDefault;
drh99ab3b12011-03-02 15:09:07 +0000435 }
436 }
437 }else{
438 /* If zName is specified, operate on only the one system call
439 ** specified.
440 */
441 for(i=0; i<sizeof(aSyscall)/sizeof(aSyscall[0]); i++){
442 if( strcmp(zName, aSyscall[i].zName)==0 ){
443 if( aSyscall[i].pDefault==0 ){
444 aSyscall[i].pDefault = aSyscall[i].pCurrent;
445 }
drh1df30962011-03-02 19:06:42 +0000446 rc = SQLITE_OK;
drh99ab3b12011-03-02 15:09:07 +0000447 if( pNewFunc==0 ) pNewFunc = aSyscall[i].pDefault;
448 aSyscall[i].pCurrent = pNewFunc;
449 break;
450 }
451 }
452 }
453 return rc;
454}
455
drh1df30962011-03-02 19:06:42 +0000456/*
457** Return the value of a system call. Return NULL if zName is not a
458** recognized system call name. NULL is also returned if the system call
459** is currently undefined.
460*/
drh58ad5802011-03-23 22:02:23 +0000461static sqlite3_syscall_ptr unixGetSystemCall(
462 sqlite3_vfs *pNotUsed,
463 const char *zName
464){
465 unsigned int i;
466
467 UNUSED_PARAMETER(pNotUsed);
drh1df30962011-03-02 19:06:42 +0000468 for(i=0; i<sizeof(aSyscall)/sizeof(aSyscall[0]); i++){
469 if( strcmp(zName, aSyscall[i].zName)==0 ) return aSyscall[i].pCurrent;
470 }
471 return 0;
472}
473
474/*
475** Return the name of the first system call after zName. If zName==NULL
476** then return the name of the first system call. Return NULL if zName
477** is the last system call or if zName is not the name of a valid
478** system call.
479*/
480static const char *unixNextSystemCall(sqlite3_vfs *p, const char *zName){
dan0fd7d862011-03-29 10:04:23 +0000481 int i = -1;
drh58ad5802011-03-23 22:02:23 +0000482
483 UNUSED_PARAMETER(p);
dan0fd7d862011-03-29 10:04:23 +0000484 if( zName ){
485 for(i=0; i<ArraySize(aSyscall)-1; i++){
486 if( strcmp(zName, aSyscall[i].zName)==0 ) break;
drh1df30962011-03-02 19:06:42 +0000487 }
488 }
dan0fd7d862011-03-29 10:04:23 +0000489 for(i++; i<ArraySize(aSyscall); i++){
490 if( aSyscall[i].pCurrent!=0 ) return aSyscall[i].zName;
drh1df30962011-03-02 19:06:42 +0000491 }
492 return 0;
493}
494
drhad4f1e52011-03-04 15:43:57 +0000495/*
496** Retry open() calls that fail due to EINTR
497*/
498static int robust_open(const char *z, int f, int m){
499 int rc;
500 do{ rc = osOpen(z,f,m); }while( rc<0 && errno==EINTR );
501 return rc;
502}
danielk197713adf8a2004-06-03 16:08:41 +0000503
drh107886a2008-11-21 22:21:50 +0000504/*
dan9359c7b2009-08-21 08:29:10 +0000505** Helper functions to obtain and relinquish the global mutex. The
drh8af6c222010-05-14 12:43:01 +0000506** global mutex is used to protect the unixInodeInfo and
dan9359c7b2009-08-21 08:29:10 +0000507** vxworksFileId objects used by this file, all of which may be
508** shared by multiple threads.
509**
510** Function unixMutexHeld() is used to assert() that the global mutex
511** is held when required. This function is only used as part of assert()
512** statements. e.g.
513**
514** unixEnterMutex()
515** assert( unixMutexHeld() );
516** unixEnterLeave()
drh107886a2008-11-21 22:21:50 +0000517*/
518static void unixEnterMutex(void){
519 sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));
520}
521static void unixLeaveMutex(void){
522 sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));
523}
dan9359c7b2009-08-21 08:29:10 +0000524#ifdef SQLITE_DEBUG
525static int unixMutexHeld(void) {
526 return sqlite3_mutex_held(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));
527}
528#endif
drh107886a2008-11-21 22:21:50 +0000529
drh734c9862008-11-28 15:37:20 +0000530
531#ifdef SQLITE_DEBUG
532/*
533** Helper function for printing out trace information from debugging
534** binaries. This returns the string represetation of the supplied
535** integer lock-type.
536*/
drh308c2a52010-05-14 11:30:18 +0000537static const char *azFileLock(int eFileLock){
538 switch( eFileLock ){
dan9359c7b2009-08-21 08:29:10 +0000539 case NO_LOCK: return "NONE";
540 case SHARED_LOCK: return "SHARED";
541 case RESERVED_LOCK: return "RESERVED";
542 case PENDING_LOCK: return "PENDING";
543 case EXCLUSIVE_LOCK: return "EXCLUSIVE";
drh734c9862008-11-28 15:37:20 +0000544 }
545 return "ERROR";
546}
547#endif
548
549#ifdef SQLITE_LOCK_TRACE
550/*
551** Print out information about all locking operations.
drh6c7d5c52008-11-21 20:32:33 +0000552**
drh734c9862008-11-28 15:37:20 +0000553** This routine is used for troubleshooting locks on multithreaded
554** platforms. Enable by compiling with the -DSQLITE_LOCK_TRACE
555** command-line option on the compiler. This code is normally
556** turned off.
557*/
558static int lockTrace(int fd, int op, struct flock *p){
559 char *zOpName, *zType;
560 int s;
561 int savedErrno;
562 if( op==F_GETLK ){
563 zOpName = "GETLK";
564 }else if( op==F_SETLK ){
565 zOpName = "SETLK";
566 }else{
drh99ab3b12011-03-02 15:09:07 +0000567 s = osFcntl(fd, op, p);
drh734c9862008-11-28 15:37:20 +0000568 sqlite3DebugPrintf("fcntl unknown %d %d %d\n", fd, op, s);
569 return s;
570 }
571 if( p->l_type==F_RDLCK ){
572 zType = "RDLCK";
573 }else if( p->l_type==F_WRLCK ){
574 zType = "WRLCK";
575 }else if( p->l_type==F_UNLCK ){
576 zType = "UNLCK";
577 }else{
578 assert( 0 );
579 }
580 assert( p->l_whence==SEEK_SET );
drh99ab3b12011-03-02 15:09:07 +0000581 s = osFcntl(fd, op, p);
drh734c9862008-11-28 15:37:20 +0000582 savedErrno = errno;
583 sqlite3DebugPrintf("fcntl %d %d %s %s %d %d %d %d\n",
584 threadid, fd, zOpName, zType, (int)p->l_start, (int)p->l_len,
585 (int)p->l_pid, s);
586 if( s==(-1) && op==F_SETLK && (p->l_type==F_RDLCK || p->l_type==F_WRLCK) ){
587 struct flock l2;
588 l2 = *p;
drh99ab3b12011-03-02 15:09:07 +0000589 osFcntl(fd, F_GETLK, &l2);
drh734c9862008-11-28 15:37:20 +0000590 if( l2.l_type==F_RDLCK ){
591 zType = "RDLCK";
592 }else if( l2.l_type==F_WRLCK ){
593 zType = "WRLCK";
594 }else if( l2.l_type==F_UNLCK ){
595 zType = "UNLCK";
596 }else{
597 assert( 0 );
598 }
599 sqlite3DebugPrintf("fcntl-failure-reason: %s %d %d %d\n",
600 zType, (int)l2.l_start, (int)l2.l_len, (int)l2.l_pid);
601 }
602 errno = savedErrno;
603 return s;
604}
drh99ab3b12011-03-02 15:09:07 +0000605#undef osFcntl
606#define osFcntl lockTrace
drh734c9862008-11-28 15:37:20 +0000607#endif /* SQLITE_LOCK_TRACE */
608
drhff812312011-02-23 13:33:46 +0000609/*
610** Retry ftruncate() calls that fail due to EINTR
611*/
drhff812312011-02-23 13:33:46 +0000612static int robust_ftruncate(int h, sqlite3_int64 sz){
613 int rc;
drh99ab3b12011-03-02 15:09:07 +0000614 do{ rc = osFtruncate(h,sz); }while( rc<0 && errno==EINTR );
drhff812312011-02-23 13:33:46 +0000615 return rc;
616}
drh734c9862008-11-28 15:37:20 +0000617
618/*
619** This routine translates a standard POSIX errno code into something
620** useful to the clients of the sqlite3 functions. Specifically, it is
621** intended to translate a variety of "try again" errors into SQLITE_BUSY
622** and a variety of "please close the file descriptor NOW" errors into
623** SQLITE_IOERR
624**
625** Errors during initialization of locks, or file system support for locks,
626** should handle ENOLCK, ENOTSUP, EOPNOTSUPP separately.
627*/
628static int sqliteErrorFromPosixError(int posixError, int sqliteIOErr) {
629 switch (posixError) {
dan661d71a2011-03-30 19:08:03 +0000630#if 0
631 /* At one point this code was not commented out. In theory, this branch
632 ** should never be hit, as this function should only be called after
633 ** a locking-related function (i.e. fcntl()) has returned non-zero with
634 ** the value of errno as the first argument. Since a system call has failed,
635 ** errno should be non-zero.
636 **
637 ** Despite this, if errno really is zero, we still don't want to return
638 ** SQLITE_OK. The system call failed, and *some* SQLite error should be
639 ** propagated back to the caller. Commenting this branch out means errno==0
640 ** will be handled by the "default:" case below.
641 */
drh734c9862008-11-28 15:37:20 +0000642 case 0:
643 return SQLITE_OK;
dan661d71a2011-03-30 19:08:03 +0000644#endif
645
drh734c9862008-11-28 15:37:20 +0000646 case EAGAIN:
647 case ETIMEDOUT:
648 case EBUSY:
649 case EINTR:
650 case ENOLCK:
651 /* random NFS retry error, unless during file system support
652 * introspection, in which it actually means what it says */
653 return SQLITE_BUSY;
654
655 case EACCES:
656 /* EACCES is like EAGAIN during locking operations, but not any other time*/
657 if( (sqliteIOErr == SQLITE_IOERR_LOCK) ||
658 (sqliteIOErr == SQLITE_IOERR_UNLOCK) ||
659 (sqliteIOErr == SQLITE_IOERR_RDLOCK) ||
660 (sqliteIOErr == SQLITE_IOERR_CHECKRESERVEDLOCK) ){
661 return SQLITE_BUSY;
662 }
663 /* else fall through */
664 case EPERM:
665 return SQLITE_PERM;
666
danea83bc62011-04-01 11:56:32 +0000667 /* EDEADLK is only possible if a call to fcntl(F_SETLKW) is made. And
668 ** this module never makes such a call. And the code in SQLite itself
669 ** asserts that SQLITE_IOERR_BLOCKED is never returned. For these reasons
670 ** this case is also commented out. If the system does set errno to EDEADLK,
671 ** the default SQLITE_IOERR_XXX code will be returned. */
672#if 0
drh734c9862008-11-28 15:37:20 +0000673 case EDEADLK:
674 return SQLITE_IOERR_BLOCKED;
danea83bc62011-04-01 11:56:32 +0000675#endif
drh734c9862008-11-28 15:37:20 +0000676
677#if EOPNOTSUPP!=ENOTSUP
678 case EOPNOTSUPP:
679 /* something went terribly awry, unless during file system support
680 * introspection, in which it actually means what it says */
681#endif
682#ifdef ENOTSUP
683 case ENOTSUP:
684 /* invalid fd, unless during file system support introspection, in which
685 * it actually means what it says */
686#endif
687 case EIO:
688 case EBADF:
689 case EINVAL:
690 case ENOTCONN:
691 case ENODEV:
692 case ENXIO:
693 case ENOENT:
dan33067e72011-07-15 13:43:34 +0000694#ifdef ESTALE /* ESTALE is not defined on Interix systems */
drh734c9862008-11-28 15:37:20 +0000695 case ESTALE:
dan33067e72011-07-15 13:43:34 +0000696#endif
drh734c9862008-11-28 15:37:20 +0000697 case ENOSYS:
698 /* these should force the client to close the file and reconnect */
699
700 default:
701 return sqliteIOErr;
702 }
703}
704
705
706
707/******************************************************************************
708****************** Begin Unique File ID Utility Used By VxWorks ***************
709**
710** On most versions of unix, we can get a unique ID for a file by concatenating
711** the device number and the inode number. But this does not work on VxWorks.
712** On VxWorks, a unique file id must be based on the canonical filename.
713**
714** A pointer to an instance of the following structure can be used as a
715** unique file ID in VxWorks. Each instance of this structure contains
716** a copy of the canonical filename. There is also a reference count.
717** The structure is reclaimed when the number of pointers to it drops to
718** zero.
719**
720** There are never very many files open at one time and lookups are not
721** a performance-critical path, so it is sufficient to put these
722** structures on a linked list.
723*/
724struct vxworksFileId {
725 struct vxworksFileId *pNext; /* Next in a list of them all */
726 int nRef; /* Number of references to this one */
727 int nName; /* Length of the zCanonicalName[] string */
728 char *zCanonicalName; /* Canonical filename */
729};
730
731#if OS_VXWORKS
732/*
drh9b35ea62008-11-29 02:20:26 +0000733** All unique filenames are held on a linked list headed by this
drh734c9862008-11-28 15:37:20 +0000734** variable:
735*/
736static struct vxworksFileId *vxworksFileList = 0;
737
738/*
739** Simplify a filename into its canonical form
740** by making the following changes:
741**
742** * removing any trailing and duplicate /
drh9b35ea62008-11-29 02:20:26 +0000743** * convert /./ into just /
744** * convert /A/../ where A is any simple name into just /
drh734c9862008-11-28 15:37:20 +0000745**
746** Changes are made in-place. Return the new name length.
747**
748** The original filename is in z[0..n-1]. Return the number of
749** characters in the simplified name.
750*/
751static int vxworksSimplifyName(char *z, int n){
752 int i, j;
753 while( n>1 && z[n-1]=='/' ){ n--; }
754 for(i=j=0; i<n; i++){
755 if( z[i]=='/' ){
756 if( z[i+1]=='/' ) continue;
757 if( z[i+1]=='.' && i+2<n && z[i+2]=='/' ){
758 i += 1;
759 continue;
760 }
761 if( z[i+1]=='.' && i+3<n && z[i+2]=='.' && z[i+3]=='/' ){
762 while( j>0 && z[j-1]!='/' ){ j--; }
763 if( j>0 ){ j--; }
764 i += 2;
765 continue;
766 }
767 }
768 z[j++] = z[i];
769 }
770 z[j] = 0;
771 return j;
772}
773
774/*
775** Find a unique file ID for the given absolute pathname. Return
776** a pointer to the vxworksFileId object. This pointer is the unique
777** file ID.
778**
779** The nRef field of the vxworksFileId object is incremented before
780** the object is returned. A new vxworksFileId object is created
781** and added to the global list if necessary.
782**
783** If a memory allocation error occurs, return NULL.
784*/
785static struct vxworksFileId *vxworksFindFileId(const char *zAbsoluteName){
786 struct vxworksFileId *pNew; /* search key and new file ID */
787 struct vxworksFileId *pCandidate; /* For looping over existing file IDs */
788 int n; /* Length of zAbsoluteName string */
789
790 assert( zAbsoluteName[0]=='/' );
drhea678832008-12-10 19:26:22 +0000791 n = (int)strlen(zAbsoluteName);
drh734c9862008-11-28 15:37:20 +0000792 pNew = sqlite3_malloc( sizeof(*pNew) + (n+1) );
793 if( pNew==0 ) return 0;
794 pNew->zCanonicalName = (char*)&pNew[1];
795 memcpy(pNew->zCanonicalName, zAbsoluteName, n+1);
796 n = vxworksSimplifyName(pNew->zCanonicalName, n);
797
798 /* Search for an existing entry that matching the canonical name.
799 ** If found, increment the reference count and return a pointer to
800 ** the existing file ID.
801 */
802 unixEnterMutex();
803 for(pCandidate=vxworksFileList; pCandidate; pCandidate=pCandidate->pNext){
804 if( pCandidate->nName==n
805 && memcmp(pCandidate->zCanonicalName, pNew->zCanonicalName, n)==0
806 ){
807 sqlite3_free(pNew);
808 pCandidate->nRef++;
809 unixLeaveMutex();
810 return pCandidate;
811 }
812 }
813
814 /* No match was found. We will make a new file ID */
815 pNew->nRef = 1;
816 pNew->nName = n;
817 pNew->pNext = vxworksFileList;
818 vxworksFileList = pNew;
819 unixLeaveMutex();
820 return pNew;
821}
822
823/*
824** Decrement the reference count on a vxworksFileId object. Free
825** the object when the reference count reaches zero.
826*/
827static void vxworksReleaseFileId(struct vxworksFileId *pId){
828 unixEnterMutex();
829 assert( pId->nRef>0 );
830 pId->nRef--;
831 if( pId->nRef==0 ){
832 struct vxworksFileId **pp;
833 for(pp=&vxworksFileList; *pp && *pp!=pId; pp = &((*pp)->pNext)){}
834 assert( *pp==pId );
835 *pp = pId->pNext;
836 sqlite3_free(pId);
837 }
838 unixLeaveMutex();
839}
840#endif /* OS_VXWORKS */
841/*************** End of Unique File ID Utility Used By VxWorks ****************
842******************************************************************************/
843
844
845/******************************************************************************
846*************************** Posix Advisory Locking ****************************
847**
drh9b35ea62008-11-29 02:20:26 +0000848** POSIX advisory locks are broken by design. ANSI STD 1003.1 (1996)
drhbbd42a62004-05-22 17:41:58 +0000849** section 6.5.2.2 lines 483 through 490 specify that when a process
850** sets or clears a lock, that operation overrides any prior locks set
851** by the same process. It does not explicitly say so, but this implies
852** that it overrides locks set by the same process using a different
853** file descriptor. Consider this test case:
drh6c7d5c52008-11-21 20:32:33 +0000854**
855** int fd1 = open("./file1", O_RDWR|O_CREAT, 0644);
drhbbd42a62004-05-22 17:41:58 +0000856** int fd2 = open("./file2", O_RDWR|O_CREAT, 0644);
857**
858** Suppose ./file1 and ./file2 are really the same file (because
859** one is a hard or symbolic link to the other) then if you set
860** an exclusive lock on fd1, then try to get an exclusive lock
861** on fd2, it works. I would have expected the second lock to
862** fail since there was already a lock on the file due to fd1.
863** But not so. Since both locks came from the same process, the
864** second overrides the first, even though they were on different
865** file descriptors opened on different file names.
866**
drh734c9862008-11-28 15:37:20 +0000867** This means that we cannot use POSIX locks to synchronize file access
868** among competing threads of the same process. POSIX locks will work fine
drhbbd42a62004-05-22 17:41:58 +0000869** to synchronize access for threads in separate processes, but not
870** threads within the same process.
871**
872** To work around the problem, SQLite has to manage file locks internally
873** on its own. Whenever a new database is opened, we have to find the
874** specific inode of the database file (the inode is determined by the
875** st_dev and st_ino fields of the stat structure that fstat() fills in)
876** and check for locks already existing on that inode. When locks are
877** created or removed, we have to look at our own internal record of the
878** locks to see if another thread has previously set a lock on that same
879** inode.
880**
drh9b35ea62008-11-29 02:20:26 +0000881** (Aside: The use of inode numbers as unique IDs does not work on VxWorks.
882** For VxWorks, we have to use the alternative unique ID system based on
883** canonical filename and implemented in the previous division.)
884**
danielk1977ad94b582007-08-20 06:44:22 +0000885** The sqlite3_file structure for POSIX is no longer just an integer file
drhbbd42a62004-05-22 17:41:58 +0000886** descriptor. It is now a structure that holds the integer file
887** descriptor and a pointer to a structure that describes the internal
888** locks on the corresponding inode. There is one locking structure
danielk1977ad94b582007-08-20 06:44:22 +0000889** per inode, so if the same inode is opened twice, both unixFile structures
drhbbd42a62004-05-22 17:41:58 +0000890** point to the same locking structure. The locking structure keeps
891** a reference count (so we will know when to delete it) and a "cnt"
892** field that tells us its internal lock status. cnt==0 means the
893** file is unlocked. cnt==-1 means the file has an exclusive lock.
894** cnt>0 means there are cnt shared locks on the file.
895**
896** Any attempt to lock or unlock a file first checks the locking
897** structure. The fcntl() system call is only invoked to set a
898** POSIX lock if the internal lock structure transitions between
899** a locked and an unlocked state.
900**
drh734c9862008-11-28 15:37:20 +0000901** But wait: there are yet more problems with POSIX advisory locks.
drhbbd42a62004-05-22 17:41:58 +0000902**
903** If you close a file descriptor that points to a file that has locks,
904** all locks on that file that are owned by the current process are
drh8af6c222010-05-14 12:43:01 +0000905** released. To work around this problem, each unixInodeInfo object
906** maintains a count of the number of pending locks on tha inode.
907** When an attempt is made to close an unixFile, if there are
danielk1977ad94b582007-08-20 06:44:22 +0000908** other unixFile open on the same inode that are holding locks, the call
drhbbd42a62004-05-22 17:41:58 +0000909** to close() the file descriptor is deferred until all of the locks clear.
drh8af6c222010-05-14 12:43:01 +0000910** The unixInodeInfo structure keeps a list of file descriptors that need to
drhbbd42a62004-05-22 17:41:58 +0000911** be closed and that list is walked (and cleared) when the last lock
912** clears.
913**
drh9b35ea62008-11-29 02:20:26 +0000914** Yet another problem: LinuxThreads do not play well with posix locks.
drh5fdae772004-06-29 03:29:00 +0000915**
drh9b35ea62008-11-29 02:20:26 +0000916** Many older versions of linux use the LinuxThreads library which is
917** not posix compliant. Under LinuxThreads, a lock created by thread
drh734c9862008-11-28 15:37:20 +0000918** A cannot be modified or overridden by a different thread B.
919** Only thread A can modify the lock. Locking behavior is correct
920** if the appliation uses the newer Native Posix Thread Library (NPTL)
921** on linux - with NPTL a lock created by thread A can override locks
922** in thread B. But there is no way to know at compile-time which
923** threading library is being used. So there is no way to know at
924** compile-time whether or not thread A can override locks on thread B.
drh8af6c222010-05-14 12:43:01 +0000925** One has to do a run-time check to discover the behavior of the
drh734c9862008-11-28 15:37:20 +0000926** current process.
drh5fdae772004-06-29 03:29:00 +0000927**
drh8af6c222010-05-14 12:43:01 +0000928** SQLite used to support LinuxThreads. But support for LinuxThreads
929** was dropped beginning with version 3.7.0. SQLite will still work with
930** LinuxThreads provided that (1) there is no more than one connection
931** per database file in the same process and (2) database connections
932** do not move across threads.
drhbbd42a62004-05-22 17:41:58 +0000933*/
934
935/*
936** An instance of the following structure serves as the key used
drh8af6c222010-05-14 12:43:01 +0000937** to locate a particular unixInodeInfo object.
drh6c7d5c52008-11-21 20:32:33 +0000938*/
939struct unixFileId {
drh107886a2008-11-21 22:21:50 +0000940 dev_t dev; /* Device number */
drh6c7d5c52008-11-21 20:32:33 +0000941#if OS_VXWORKS
drh107886a2008-11-21 22:21:50 +0000942 struct vxworksFileId *pId; /* Unique file ID for vxworks. */
drh6c7d5c52008-11-21 20:32:33 +0000943#else
drh107886a2008-11-21 22:21:50 +0000944 ino_t ino; /* Inode number */
drh6c7d5c52008-11-21 20:32:33 +0000945#endif
946};
947
948/*
drhbbd42a62004-05-22 17:41:58 +0000949** An instance of the following structure is allocated for each open
drh9b35ea62008-11-29 02:20:26 +0000950** inode. Or, on LinuxThreads, there is one of these structures for
951** each inode opened by each thread.
drhbbd42a62004-05-22 17:41:58 +0000952**
danielk1977ad94b582007-08-20 06:44:22 +0000953** A single inode can have multiple file descriptors, so each unixFile
drhbbd42a62004-05-22 17:41:58 +0000954** structure contains a pointer to an instance of this object and this
danielk1977ad94b582007-08-20 06:44:22 +0000955** object keeps a count of the number of unixFile pointing to it.
drhbbd42a62004-05-22 17:41:58 +0000956*/
drh8af6c222010-05-14 12:43:01 +0000957struct unixInodeInfo {
958 struct unixFileId fileId; /* The lookup key */
drh308c2a52010-05-14 11:30:18 +0000959 int nShared; /* Number of SHARED locks held */
drha7e61d82011-03-12 17:02:57 +0000960 unsigned char eFileLock; /* One of SHARED_LOCK, RESERVED_LOCK etc. */
961 unsigned char bProcessLock; /* An exclusive process lock is held */
drh734c9862008-11-28 15:37:20 +0000962 int nRef; /* Number of pointers to this structure */
drhd91c68f2010-05-14 14:52:25 +0000963 unixShmNode *pShmNode; /* Shared memory associated with this inode */
964 int nLock; /* Number of outstanding file locks */
965 UnixUnusedFd *pUnused; /* Unused file descriptors to close */
966 unixInodeInfo *pNext; /* List of all unixInodeInfo objects */
967 unixInodeInfo *pPrev; /* .... doubly linked */
drhd4a80312011-04-15 14:33:20 +0000968#if SQLITE_ENABLE_LOCKING_STYLE
drh7ed97b92010-01-20 13:07:21 +0000969 unsigned long long sharedByte; /* for AFP simulated shared lock */
970#endif
drh6c7d5c52008-11-21 20:32:33 +0000971#if OS_VXWORKS
drh8af6c222010-05-14 12:43:01 +0000972 sem_t *pSem; /* Named POSIX semaphore */
973 char aSemName[MAX_PATHNAME+2]; /* Name of that semaphore */
chw97185482008-11-17 08:05:31 +0000974#endif
drhbbd42a62004-05-22 17:41:58 +0000975};
976
drhda0e7682008-07-30 15:27:54 +0000977/*
drh8af6c222010-05-14 12:43:01 +0000978** A lists of all unixInodeInfo objects.
drhbbd42a62004-05-22 17:41:58 +0000979*/
drhd91c68f2010-05-14 14:52:25 +0000980static unixInodeInfo *inodeList = 0;
drh5fdae772004-06-29 03:29:00 +0000981
drh5fdae772004-06-29 03:29:00 +0000982/*
dane18d4952011-02-21 11:46:24 +0000983**
984** This function - unixLogError_x(), is only ever called via the macro
985** unixLogError().
986**
987** It is invoked after an error occurs in an OS function and errno has been
988** set. It logs a message using sqlite3_log() containing the current value of
989** errno and, if possible, the human-readable equivalent from strerror() or
990** strerror_r().
991**
992** The first argument passed to the macro should be the error code that
993** will be returned to SQLite (e.g. SQLITE_IOERR_DELETE, SQLITE_CANTOPEN).
994** The two subsequent arguments should be the name of the OS function that
995** failed (e.g. "unlink", "open") and the the associated file-system path,
996** if any.
997*/
drh0e9365c2011-03-02 02:08:13 +0000998#define unixLogError(a,b,c) unixLogErrorAtLine(a,b,c,__LINE__)
999static int unixLogErrorAtLine(
dane18d4952011-02-21 11:46:24 +00001000 int errcode, /* SQLite error code */
1001 const char *zFunc, /* Name of OS function that failed */
1002 const char *zPath, /* File path associated with error */
1003 int iLine /* Source line number where error occurred */
1004){
1005 char *zErr; /* Message from strerror() or equivalent */
drh0e9365c2011-03-02 02:08:13 +00001006 int iErrno = errno; /* Saved syscall error number */
dane18d4952011-02-21 11:46:24 +00001007
1008 /* If this is not a threadsafe build (SQLITE_THREADSAFE==0), then use
1009 ** the strerror() function to obtain the human-readable error message
1010 ** equivalent to errno. Otherwise, use strerror_r().
1011 */
1012#if SQLITE_THREADSAFE && defined(HAVE_STRERROR_R)
1013 char aErr[80];
1014 memset(aErr, 0, sizeof(aErr));
1015 zErr = aErr;
1016
1017 /* If STRERROR_R_CHAR_P (set by autoconf scripts) or __USE_GNU is defined,
1018 ** assume that the system provides the the GNU version of strerror_r() that
1019 ** returns a pointer to a buffer containing the error message. That pointer
1020 ** may point to aErr[], or it may point to some static storage somewhere.
1021 ** Otherwise, assume that the system provides the POSIX version of
1022 ** strerror_r(), which always writes an error message into aErr[].
1023 **
1024 ** If the code incorrectly assumes that it is the POSIX version that is
1025 ** available, the error message will often be an empty string. Not a
1026 ** huge problem. Incorrectly concluding that the GNU version is available
1027 ** could lead to a segfault though.
1028 */
1029#if defined(STRERROR_R_CHAR_P) || defined(__USE_GNU)
1030 zErr =
1031# endif
drh0e9365c2011-03-02 02:08:13 +00001032 strerror_r(iErrno, aErr, sizeof(aErr)-1);
dane18d4952011-02-21 11:46:24 +00001033
1034#elif SQLITE_THREADSAFE
1035 /* This is a threadsafe build, but strerror_r() is not available. */
1036 zErr = "";
1037#else
1038 /* Non-threadsafe build, use strerror(). */
drh0e9365c2011-03-02 02:08:13 +00001039 zErr = strerror(iErrno);
dane18d4952011-02-21 11:46:24 +00001040#endif
1041
1042 assert( errcode!=SQLITE_OK );
drh0e9365c2011-03-02 02:08:13 +00001043 if( zPath==0 ) zPath = "";
dane18d4952011-02-21 11:46:24 +00001044 sqlite3_log(errcode,
drh0e9365c2011-03-02 02:08:13 +00001045 "os_unix.c:%d: (%d) %s(%s) - %s",
1046 iLine, iErrno, zFunc, zPath, zErr
dane18d4952011-02-21 11:46:24 +00001047 );
1048
1049 return errcode;
1050}
1051
drh0e9365c2011-03-02 02:08:13 +00001052/*
1053** Close a file descriptor.
1054**
1055** We assume that close() almost always works, since it is only in a
1056** very sick application or on a very sick platform that it might fail.
1057** If it does fail, simply leak the file descriptor, but do log the
1058** error.
1059**
1060** Note that it is not safe to retry close() after EINTR since the
1061** file descriptor might have already been reused by another thread.
1062** So we don't even try to recover from an EINTR. Just log the error
1063** and move on.
1064*/
1065static void robust_close(unixFile *pFile, int h, int lineno){
drh99ab3b12011-03-02 15:09:07 +00001066 if( osClose(h) ){
drh0e9365c2011-03-02 02:08:13 +00001067 unixLogErrorAtLine(SQLITE_IOERR_CLOSE, "close",
1068 pFile ? pFile->zPath : 0, lineno);
1069 }
1070}
dane18d4952011-02-21 11:46:24 +00001071
1072/*
danb0ac3e32010-06-16 10:55:42 +00001073** Close all file descriptors accumuated in the unixInodeInfo->pUnused list.
danb0ac3e32010-06-16 10:55:42 +00001074*/
drh0e9365c2011-03-02 02:08:13 +00001075static void closePendingFds(unixFile *pFile){
danb0ac3e32010-06-16 10:55:42 +00001076 unixInodeInfo *pInode = pFile->pInode;
danb0ac3e32010-06-16 10:55:42 +00001077 UnixUnusedFd *p;
1078 UnixUnusedFd *pNext;
1079 for(p=pInode->pUnused; p; p=pNext){
1080 pNext = p->pNext;
drh0e9365c2011-03-02 02:08:13 +00001081 robust_close(pFile, p->fd, __LINE__);
1082 sqlite3_free(p);
danb0ac3e32010-06-16 10:55:42 +00001083 }
drh0e9365c2011-03-02 02:08:13 +00001084 pInode->pUnused = 0;
danb0ac3e32010-06-16 10:55:42 +00001085}
1086
1087/*
drh8af6c222010-05-14 12:43:01 +00001088** Release a unixInodeInfo structure previously allocated by findInodeInfo().
dan9359c7b2009-08-21 08:29:10 +00001089**
1090** The mutex entered using the unixEnterMutex() function must be held
1091** when this function is called.
drh6c7d5c52008-11-21 20:32:33 +00001092*/
danb0ac3e32010-06-16 10:55:42 +00001093static void releaseInodeInfo(unixFile *pFile){
1094 unixInodeInfo *pInode = pFile->pInode;
dan9359c7b2009-08-21 08:29:10 +00001095 assert( unixMutexHeld() );
dan661d71a2011-03-30 19:08:03 +00001096 if( ALWAYS(pInode) ){
drh8af6c222010-05-14 12:43:01 +00001097 pInode->nRef--;
1098 if( pInode->nRef==0 ){
drhd91c68f2010-05-14 14:52:25 +00001099 assert( pInode->pShmNode==0 );
danb0ac3e32010-06-16 10:55:42 +00001100 closePendingFds(pFile);
drh8af6c222010-05-14 12:43:01 +00001101 if( pInode->pPrev ){
1102 assert( pInode->pPrev->pNext==pInode );
1103 pInode->pPrev->pNext = pInode->pNext;
drhda0e7682008-07-30 15:27:54 +00001104 }else{
drh8af6c222010-05-14 12:43:01 +00001105 assert( inodeList==pInode );
1106 inodeList = pInode->pNext;
drhda0e7682008-07-30 15:27:54 +00001107 }
drh8af6c222010-05-14 12:43:01 +00001108 if( pInode->pNext ){
1109 assert( pInode->pNext->pPrev==pInode );
1110 pInode->pNext->pPrev = pInode->pPrev;
drhda0e7682008-07-30 15:27:54 +00001111 }
drh8af6c222010-05-14 12:43:01 +00001112 sqlite3_free(pInode);
danielk1977e339d652008-06-28 11:23:00 +00001113 }
drhbbd42a62004-05-22 17:41:58 +00001114 }
1115}
1116
1117/*
drh8af6c222010-05-14 12:43:01 +00001118** Given a file descriptor, locate the unixInodeInfo object that
1119** describes that file descriptor. Create a new one if necessary. The
1120** return value might be uninitialized if an error occurs.
drh6c7d5c52008-11-21 20:32:33 +00001121**
dan9359c7b2009-08-21 08:29:10 +00001122** The mutex entered using the unixEnterMutex() function must be held
1123** when this function is called.
1124**
drh6c7d5c52008-11-21 20:32:33 +00001125** Return an appropriate error code.
1126*/
drh8af6c222010-05-14 12:43:01 +00001127static int findInodeInfo(
drh6c7d5c52008-11-21 20:32:33 +00001128 unixFile *pFile, /* Unix file with file desc used in the key */
drhd91c68f2010-05-14 14:52:25 +00001129 unixInodeInfo **ppInode /* Return the unixInodeInfo object here */
drh6c7d5c52008-11-21 20:32:33 +00001130){
1131 int rc; /* System call return code */
1132 int fd; /* The file descriptor for pFile */
drhd91c68f2010-05-14 14:52:25 +00001133 struct unixFileId fileId; /* Lookup key for the unixInodeInfo */
1134 struct stat statbuf; /* Low-level file information */
1135 unixInodeInfo *pInode = 0; /* Candidate unixInodeInfo object */
drh6c7d5c52008-11-21 20:32:33 +00001136
dan9359c7b2009-08-21 08:29:10 +00001137 assert( unixMutexHeld() );
1138
drh6c7d5c52008-11-21 20:32:33 +00001139 /* Get low-level information about the file that we can used to
1140 ** create a unique name for the file.
1141 */
1142 fd = pFile->h;
drh99ab3b12011-03-02 15:09:07 +00001143 rc = osFstat(fd, &statbuf);
drh6c7d5c52008-11-21 20:32:33 +00001144 if( rc!=0 ){
1145 pFile->lastErrno = errno;
1146#ifdef EOVERFLOW
1147 if( pFile->lastErrno==EOVERFLOW ) return SQLITE_NOLFS;
1148#endif
1149 return SQLITE_IOERR;
1150 }
1151
drheb0d74f2009-02-03 15:27:02 +00001152#ifdef __APPLE__
drh6c7d5c52008-11-21 20:32:33 +00001153 /* On OS X on an msdos filesystem, the inode number is reported
1154 ** incorrectly for zero-size files. See ticket #3260. To work
1155 ** around this problem (we consider it a bug in OS X, not SQLite)
1156 ** we always increase the file size to 1 by writing a single byte
1157 ** prior to accessing the inode number. The one byte written is
1158 ** an ASCII 'S' character which also happens to be the first byte
1159 ** in the header of every SQLite database. In this way, if there
1160 ** is a race condition such that another thread has already populated
1161 ** the first page of the database, no damage is done.
1162 */
drh7ed97b92010-01-20 13:07:21 +00001163 if( statbuf.st_size==0 && (pFile->fsFlags & SQLITE_FSFLAGS_IS_MSDOS)!=0 ){
drhe562be52011-03-02 18:01:10 +00001164 do{ rc = osWrite(fd, "S", 1); }while( rc<0 && errno==EINTR );
drheb0d74f2009-02-03 15:27:02 +00001165 if( rc!=1 ){
drh7ed97b92010-01-20 13:07:21 +00001166 pFile->lastErrno = errno;
drheb0d74f2009-02-03 15:27:02 +00001167 return SQLITE_IOERR;
1168 }
drh99ab3b12011-03-02 15:09:07 +00001169 rc = osFstat(fd, &statbuf);
drh6c7d5c52008-11-21 20:32:33 +00001170 if( rc!=0 ){
1171 pFile->lastErrno = errno;
1172 return SQLITE_IOERR;
1173 }
1174 }
drheb0d74f2009-02-03 15:27:02 +00001175#endif
drh6c7d5c52008-11-21 20:32:33 +00001176
drh8af6c222010-05-14 12:43:01 +00001177 memset(&fileId, 0, sizeof(fileId));
1178 fileId.dev = statbuf.st_dev;
drh6c7d5c52008-11-21 20:32:33 +00001179#if OS_VXWORKS
drh8af6c222010-05-14 12:43:01 +00001180 fileId.pId = pFile->pId;
drh6c7d5c52008-11-21 20:32:33 +00001181#else
drh8af6c222010-05-14 12:43:01 +00001182 fileId.ino = statbuf.st_ino;
drh6c7d5c52008-11-21 20:32:33 +00001183#endif
drh8af6c222010-05-14 12:43:01 +00001184 pInode = inodeList;
1185 while( pInode && memcmp(&fileId, &pInode->fileId, sizeof(fileId)) ){
1186 pInode = pInode->pNext;
drh6c7d5c52008-11-21 20:32:33 +00001187 }
drh8af6c222010-05-14 12:43:01 +00001188 if( pInode==0 ){
1189 pInode = sqlite3_malloc( sizeof(*pInode) );
1190 if( pInode==0 ){
1191 return SQLITE_NOMEM;
drh6c7d5c52008-11-21 20:32:33 +00001192 }
drh8af6c222010-05-14 12:43:01 +00001193 memset(pInode, 0, sizeof(*pInode));
1194 memcpy(&pInode->fileId, &fileId, sizeof(fileId));
1195 pInode->nRef = 1;
1196 pInode->pNext = inodeList;
1197 pInode->pPrev = 0;
1198 if( inodeList ) inodeList->pPrev = pInode;
1199 inodeList = pInode;
1200 }else{
1201 pInode->nRef++;
drh6c7d5c52008-11-21 20:32:33 +00001202 }
drh8af6c222010-05-14 12:43:01 +00001203 *ppInode = pInode;
1204 return SQLITE_OK;
drh6c7d5c52008-11-21 20:32:33 +00001205}
drh6c7d5c52008-11-21 20:32:33 +00001206
aswift5b1a2562008-08-22 00:22:35 +00001207
1208/*
danielk197713adf8a2004-06-03 16:08:41 +00001209** This routine checks if there is a RESERVED lock held on the specified
aswift5b1a2562008-08-22 00:22:35 +00001210** file by this or any other process. If such a lock is held, set *pResOut
1211** to a non-zero value otherwise *pResOut is set to zero. The return value
1212** is set to SQLITE_OK unless an I/O error occurs during lock checking.
danielk197713adf8a2004-06-03 16:08:41 +00001213*/
danielk1977861f7452008-06-05 11:39:11 +00001214static int unixCheckReservedLock(sqlite3_file *id, int *pResOut){
aswift5b1a2562008-08-22 00:22:35 +00001215 int rc = SQLITE_OK;
1216 int reserved = 0;
drh054889e2005-11-30 03:20:31 +00001217 unixFile *pFile = (unixFile*)id;
danielk197713adf8a2004-06-03 16:08:41 +00001218
danielk1977861f7452008-06-05 11:39:11 +00001219 SimulateIOError( return SQLITE_IOERR_CHECKRESERVEDLOCK; );
1220
drh054889e2005-11-30 03:20:31 +00001221 assert( pFile );
drh8af6c222010-05-14 12:43:01 +00001222 unixEnterMutex(); /* Because pFile->pInode is shared across threads */
danielk197713adf8a2004-06-03 16:08:41 +00001223
1224 /* Check if a thread in this process holds such a lock */
drh8af6c222010-05-14 12:43:01 +00001225 if( pFile->pInode->eFileLock>SHARED_LOCK ){
aswift5b1a2562008-08-22 00:22:35 +00001226 reserved = 1;
danielk197713adf8a2004-06-03 16:08:41 +00001227 }
1228
drh2ac3ee92004-06-07 16:27:46 +00001229 /* Otherwise see if some other process holds it.
danielk197713adf8a2004-06-03 16:08:41 +00001230 */
danielk197709480a92009-02-09 05:32:32 +00001231#ifndef __DJGPP__
drha7e61d82011-03-12 17:02:57 +00001232 if( !reserved && !pFile->pInode->bProcessLock ){
danielk197713adf8a2004-06-03 16:08:41 +00001233 struct flock lock;
1234 lock.l_whence = SEEK_SET;
drh2ac3ee92004-06-07 16:27:46 +00001235 lock.l_start = RESERVED_BYTE;
1236 lock.l_len = 1;
1237 lock.l_type = F_WRLCK;
danea83bc62011-04-01 11:56:32 +00001238 if( osFcntl(pFile->h, F_GETLK, &lock) ){
1239 rc = SQLITE_IOERR_CHECKRESERVEDLOCK;
1240 pFile->lastErrno = errno;
aswift5b1a2562008-08-22 00:22:35 +00001241 } else if( lock.l_type!=F_UNLCK ){
1242 reserved = 1;
danielk197713adf8a2004-06-03 16:08:41 +00001243 }
1244 }
danielk197709480a92009-02-09 05:32:32 +00001245#endif
danielk197713adf8a2004-06-03 16:08:41 +00001246
drh6c7d5c52008-11-21 20:32:33 +00001247 unixLeaveMutex();
drh308c2a52010-05-14 11:30:18 +00001248 OSTRACE(("TEST WR-LOCK %d %d %d (unix)\n", pFile->h, rc, reserved));
danielk197713adf8a2004-06-03 16:08:41 +00001249
aswift5b1a2562008-08-22 00:22:35 +00001250 *pResOut = reserved;
1251 return rc;
danielk197713adf8a2004-06-03 16:08:41 +00001252}
1253
1254/*
drha7e61d82011-03-12 17:02:57 +00001255** Attempt to set a system-lock on the file pFile. The lock is
1256** described by pLock.
1257**
drh77197112011-03-15 19:08:48 +00001258** If the pFile was opened read/write from unix-excl, then the only lock
1259** ever obtained is an exclusive lock, and it is obtained exactly once
drha7e61d82011-03-12 17:02:57 +00001260** the first time any lock is attempted. All subsequent system locking
1261** operations become no-ops. Locking operations still happen internally,
1262** in order to coordinate access between separate database connections
1263** within this process, but all of that is handled in memory and the
1264** operating system does not participate.
drh77197112011-03-15 19:08:48 +00001265**
1266** This function is a pass-through to fcntl(F_SETLK) if pFile is using
1267** any VFS other than "unix-excl" or if pFile is opened on "unix-excl"
1268** and is read-only.
dan661d71a2011-03-30 19:08:03 +00001269**
1270** Zero is returned if the call completes successfully, or -1 if a call
1271** to fcntl() fails. In this case, errno is set appropriately (by fcntl()).
drha7e61d82011-03-12 17:02:57 +00001272*/
1273static int unixFileLock(unixFile *pFile, struct flock *pLock){
1274 int rc;
drh3cb93392011-03-12 18:10:44 +00001275 unixInodeInfo *pInode = pFile->pInode;
drha7e61d82011-03-12 17:02:57 +00001276 assert( unixMutexHeld() );
drh3cb93392011-03-12 18:10:44 +00001277 assert( pInode!=0 );
drh77197112011-03-15 19:08:48 +00001278 if( ((pFile->ctrlFlags & UNIXFILE_EXCL)!=0 || pInode->bProcessLock)
1279 && ((pFile->ctrlFlags & UNIXFILE_RDONLY)==0)
1280 ){
drh3cb93392011-03-12 18:10:44 +00001281 if( pInode->bProcessLock==0 ){
drha7e61d82011-03-12 17:02:57 +00001282 struct flock lock;
drh3cb93392011-03-12 18:10:44 +00001283 assert( pInode->nLock==0 );
drha7e61d82011-03-12 17:02:57 +00001284 lock.l_whence = SEEK_SET;
1285 lock.l_start = SHARED_FIRST;
1286 lock.l_len = SHARED_SIZE;
1287 lock.l_type = F_WRLCK;
1288 rc = osFcntl(pFile->h, F_SETLK, &lock);
1289 if( rc<0 ) return rc;
drh3cb93392011-03-12 18:10:44 +00001290 pInode->bProcessLock = 1;
1291 pInode->nLock++;
drha7e61d82011-03-12 17:02:57 +00001292 }else{
1293 rc = 0;
1294 }
1295 }else{
1296 rc = osFcntl(pFile->h, F_SETLK, pLock);
1297 }
1298 return rc;
1299}
1300
1301/*
drh308c2a52010-05-14 11:30:18 +00001302** Lock the file with the lock specified by parameter eFileLock - one
danielk19779a1d0ab2004-06-01 14:09:28 +00001303** of the following:
1304**
drh2ac3ee92004-06-07 16:27:46 +00001305** (1) SHARED_LOCK
1306** (2) RESERVED_LOCK
1307** (3) PENDING_LOCK
1308** (4) EXCLUSIVE_LOCK
1309**
drhb3e04342004-06-08 00:47:47 +00001310** Sometimes when requesting one lock state, additional lock states
1311** are inserted in between. The locking might fail on one of the later
1312** transitions leaving the lock state different from what it started but
1313** still short of its goal. The following chart shows the allowed
1314** transitions and the inserted intermediate states:
1315**
1316** UNLOCKED -> SHARED
1317** SHARED -> RESERVED
1318** SHARED -> (PENDING) -> EXCLUSIVE
1319** RESERVED -> (PENDING) -> EXCLUSIVE
1320** PENDING -> EXCLUSIVE
drh2ac3ee92004-06-07 16:27:46 +00001321**
drha6abd042004-06-09 17:37:22 +00001322** This routine will only increase a lock. Use the sqlite3OsUnlock()
1323** routine to lower a locking level.
danielk19779a1d0ab2004-06-01 14:09:28 +00001324*/
drh308c2a52010-05-14 11:30:18 +00001325static int unixLock(sqlite3_file *id, int eFileLock){
danielk1977f42f25c2004-06-25 07:21:28 +00001326 /* The following describes the implementation of the various locks and
1327 ** lock transitions in terms of the POSIX advisory shared and exclusive
1328 ** lock primitives (called read-locks and write-locks below, to avoid
1329 ** confusion with SQLite lock names). The algorithms are complicated
1330 ** slightly in order to be compatible with windows systems simultaneously
1331 ** accessing the same database file, in case that is ever required.
1332 **
1333 ** Symbols defined in os.h indentify the 'pending byte' and the 'reserved
1334 ** byte', each single bytes at well known offsets, and the 'shared byte
1335 ** range', a range of 510 bytes at a well known offset.
1336 **
1337 ** To obtain a SHARED lock, a read-lock is obtained on the 'pending
1338 ** byte'. If this is successful, a random byte from the 'shared byte
1339 ** range' is read-locked and the lock on the 'pending byte' released.
1340 **
danielk197790ba3bd2004-06-25 08:32:25 +00001341 ** A process may only obtain a RESERVED lock after it has a SHARED lock.
1342 ** A RESERVED lock is implemented by grabbing a write-lock on the
1343 ** 'reserved byte'.
danielk1977f42f25c2004-06-25 07:21:28 +00001344 **
1345 ** A process may only obtain a PENDING lock after it has obtained a
danielk197790ba3bd2004-06-25 08:32:25 +00001346 ** SHARED lock. A PENDING lock is implemented by obtaining a write-lock
1347 ** on the 'pending byte'. This ensures that no new SHARED locks can be
1348 ** obtained, but existing SHARED locks are allowed to persist. A process
1349 ** does not have to obtain a RESERVED lock on the way to a PENDING lock.
1350 ** This property is used by the algorithm for rolling back a journal file
1351 ** after a crash.
danielk1977f42f25c2004-06-25 07:21:28 +00001352 **
danielk197790ba3bd2004-06-25 08:32:25 +00001353 ** An EXCLUSIVE lock, obtained after a PENDING lock is held, is
1354 ** implemented by obtaining a write-lock on the entire 'shared byte
1355 ** range'. Since all other locks require a read-lock on one of the bytes
1356 ** within this range, this ensures that no other locks are held on the
1357 ** database.
danielk1977f42f25c2004-06-25 07:21:28 +00001358 **
1359 ** The reason a single byte cannot be used instead of the 'shared byte
1360 ** range' is that some versions of windows do not support read-locks. By
1361 ** locking a random byte from a range, concurrent SHARED locks may exist
1362 ** even if the locking primitive used is always a write-lock.
1363 */
danielk19779a1d0ab2004-06-01 14:09:28 +00001364 int rc = SQLITE_OK;
drh054889e2005-11-30 03:20:31 +00001365 unixFile *pFile = (unixFile*)id;
drhd91c68f2010-05-14 14:52:25 +00001366 unixInodeInfo *pInode = pFile->pInode;
danielk19779a1d0ab2004-06-01 14:09:28 +00001367 struct flock lock;
drh383d30f2010-02-26 13:07:37 +00001368 int tErrno = 0;
danielk19779a1d0ab2004-06-01 14:09:28 +00001369
drh054889e2005-11-30 03:20:31 +00001370 assert( pFile );
drh308c2a52010-05-14 11:30:18 +00001371 OSTRACE(("LOCK %d %s was %s(%s,%d) pid=%d (unix)\n", pFile->h,
1372 azFileLock(eFileLock), azFileLock(pFile->eFileLock),
drh8af6c222010-05-14 12:43:01 +00001373 azFileLock(pInode->eFileLock), pInode->nShared , getpid()));
danielk19779a1d0ab2004-06-01 14:09:28 +00001374
1375 /* If there is already a lock of this type or more restrictive on the
danielk1977ad94b582007-08-20 06:44:22 +00001376 ** unixFile, do nothing. Don't use the end_lock: exit path, as
drh6c7d5c52008-11-21 20:32:33 +00001377 ** unixEnterMutex() hasn't been called yet.
danielk19779a1d0ab2004-06-01 14:09:28 +00001378 */
drh308c2a52010-05-14 11:30:18 +00001379 if( pFile->eFileLock>=eFileLock ){
1380 OSTRACE(("LOCK %d %s ok (already held) (unix)\n", pFile->h,
1381 azFileLock(eFileLock)));
danielk19779a1d0ab2004-06-01 14:09:28 +00001382 return SQLITE_OK;
1383 }
1384
drh0c2694b2009-09-03 16:23:44 +00001385 /* Make sure the locking sequence is correct.
1386 ** (1) We never move from unlocked to anything higher than shared lock.
1387 ** (2) SQLite never explicitly requests a pendig lock.
1388 ** (3) A shared lock is always held when a reserve lock is requested.
drh2ac3ee92004-06-07 16:27:46 +00001389 */
drh308c2a52010-05-14 11:30:18 +00001390 assert( pFile->eFileLock!=NO_LOCK || eFileLock==SHARED_LOCK );
1391 assert( eFileLock!=PENDING_LOCK );
1392 assert( eFileLock!=RESERVED_LOCK || pFile->eFileLock==SHARED_LOCK );
drh2ac3ee92004-06-07 16:27:46 +00001393
drh8af6c222010-05-14 12:43:01 +00001394 /* This mutex is needed because pFile->pInode is shared across threads
drhb3e04342004-06-08 00:47:47 +00001395 */
drh6c7d5c52008-11-21 20:32:33 +00001396 unixEnterMutex();
drh8af6c222010-05-14 12:43:01 +00001397 pInode = pFile->pInode;
drh029b44b2006-01-15 00:13:15 +00001398
danielk1977ad94b582007-08-20 06:44:22 +00001399 /* If some thread using this PID has a lock via a different unixFile*
danielk19779a1d0ab2004-06-01 14:09:28 +00001400 ** handle that precludes the requested lock, return BUSY.
1401 */
drh8af6c222010-05-14 12:43:01 +00001402 if( (pFile->eFileLock!=pInode->eFileLock &&
1403 (pInode->eFileLock>=PENDING_LOCK || eFileLock>SHARED_LOCK))
danielk19779a1d0ab2004-06-01 14:09:28 +00001404 ){
1405 rc = SQLITE_BUSY;
1406 goto end_lock;
1407 }
1408
1409 /* If a SHARED lock is requested, and some thread using this PID already
1410 ** has a SHARED or RESERVED lock, then increment reference counts and
1411 ** return SQLITE_OK.
1412 */
drh308c2a52010-05-14 11:30:18 +00001413 if( eFileLock==SHARED_LOCK &&
drh8af6c222010-05-14 12:43:01 +00001414 (pInode->eFileLock==SHARED_LOCK || pInode->eFileLock==RESERVED_LOCK) ){
drh308c2a52010-05-14 11:30:18 +00001415 assert( eFileLock==SHARED_LOCK );
1416 assert( pFile->eFileLock==0 );
drh8af6c222010-05-14 12:43:01 +00001417 assert( pInode->nShared>0 );
drh308c2a52010-05-14 11:30:18 +00001418 pFile->eFileLock = SHARED_LOCK;
drh8af6c222010-05-14 12:43:01 +00001419 pInode->nShared++;
1420 pInode->nLock++;
danielk19779a1d0ab2004-06-01 14:09:28 +00001421 goto end_lock;
1422 }
1423
danielk19779a1d0ab2004-06-01 14:09:28 +00001424
drh3cde3bb2004-06-12 02:17:14 +00001425 /* A PENDING lock is needed before acquiring a SHARED lock and before
1426 ** acquiring an EXCLUSIVE lock. For the SHARED lock, the PENDING will
1427 ** be released.
danielk19779a1d0ab2004-06-01 14:09:28 +00001428 */
drh0c2694b2009-09-03 16:23:44 +00001429 lock.l_len = 1L;
1430 lock.l_whence = SEEK_SET;
drh308c2a52010-05-14 11:30:18 +00001431 if( eFileLock==SHARED_LOCK
1432 || (eFileLock==EXCLUSIVE_LOCK && pFile->eFileLock<PENDING_LOCK)
drh3cde3bb2004-06-12 02:17:14 +00001433 ){
drh308c2a52010-05-14 11:30:18 +00001434 lock.l_type = (eFileLock==SHARED_LOCK?F_RDLCK:F_WRLCK);
drh2ac3ee92004-06-07 16:27:46 +00001435 lock.l_start = PENDING_BYTE;
dan661d71a2011-03-30 19:08:03 +00001436 if( unixFileLock(pFile, &lock) ){
drh0c2694b2009-09-03 16:23:44 +00001437 tErrno = errno;
aswift5b1a2562008-08-22 00:22:35 +00001438 rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK);
dan661d71a2011-03-30 19:08:03 +00001439 if( rc!=SQLITE_BUSY ){
aswift5b1a2562008-08-22 00:22:35 +00001440 pFile->lastErrno = tErrno;
1441 }
danielk19779a1d0ab2004-06-01 14:09:28 +00001442 goto end_lock;
1443 }
drh3cde3bb2004-06-12 02:17:14 +00001444 }
1445
1446
1447 /* If control gets to this point, then actually go ahead and make
1448 ** operating system calls for the specified lock.
1449 */
drh308c2a52010-05-14 11:30:18 +00001450 if( eFileLock==SHARED_LOCK ){
drh8af6c222010-05-14 12:43:01 +00001451 assert( pInode->nShared==0 );
1452 assert( pInode->eFileLock==0 );
dan661d71a2011-03-30 19:08:03 +00001453 assert( rc==SQLITE_OK );
danielk19779a1d0ab2004-06-01 14:09:28 +00001454
drh2ac3ee92004-06-07 16:27:46 +00001455 /* Now get the read-lock */
drh7ed97b92010-01-20 13:07:21 +00001456 lock.l_start = SHARED_FIRST;
1457 lock.l_len = SHARED_SIZE;
dan661d71a2011-03-30 19:08:03 +00001458 if( unixFileLock(pFile, &lock) ){
drh7ed97b92010-01-20 13:07:21 +00001459 tErrno = errno;
dan661d71a2011-03-30 19:08:03 +00001460 rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK);
drh7ed97b92010-01-20 13:07:21 +00001461 }
dan661d71a2011-03-30 19:08:03 +00001462
drh2ac3ee92004-06-07 16:27:46 +00001463 /* Drop the temporary PENDING lock */
1464 lock.l_start = PENDING_BYTE;
1465 lock.l_len = 1L;
danielk19779a1d0ab2004-06-01 14:09:28 +00001466 lock.l_type = F_UNLCK;
dan661d71a2011-03-30 19:08:03 +00001467 if( unixFileLock(pFile, &lock) && rc==SQLITE_OK ){
1468 /* This could happen with a network mount */
1469 tErrno = errno;
danea83bc62011-04-01 11:56:32 +00001470 rc = SQLITE_IOERR_UNLOCK;
drh2b4b5962005-06-15 17:47:55 +00001471 }
dan661d71a2011-03-30 19:08:03 +00001472
1473 if( rc ){
1474 if( rc!=SQLITE_BUSY ){
aswift5b1a2562008-08-22 00:22:35 +00001475 pFile->lastErrno = tErrno;
1476 }
dan661d71a2011-03-30 19:08:03 +00001477 goto end_lock;
drhbbd42a62004-05-22 17:41:58 +00001478 }else{
drh308c2a52010-05-14 11:30:18 +00001479 pFile->eFileLock = SHARED_LOCK;
drh8af6c222010-05-14 12:43:01 +00001480 pInode->nLock++;
1481 pInode->nShared = 1;
drhbbd42a62004-05-22 17:41:58 +00001482 }
drh8af6c222010-05-14 12:43:01 +00001483 }else if( eFileLock==EXCLUSIVE_LOCK && pInode->nShared>1 ){
drh3cde3bb2004-06-12 02:17:14 +00001484 /* We are trying for an exclusive lock but another thread in this
1485 ** same process is still holding a shared lock. */
1486 rc = SQLITE_BUSY;
drhbbd42a62004-05-22 17:41:58 +00001487 }else{
drh3cde3bb2004-06-12 02:17:14 +00001488 /* The request was for a RESERVED or EXCLUSIVE lock. It is
danielk19779a1d0ab2004-06-01 14:09:28 +00001489 ** assumed that there is a SHARED or greater lock on the file
1490 ** already.
1491 */
drh308c2a52010-05-14 11:30:18 +00001492 assert( 0!=pFile->eFileLock );
danielk19779a1d0ab2004-06-01 14:09:28 +00001493 lock.l_type = F_WRLCK;
dan661d71a2011-03-30 19:08:03 +00001494
1495 assert( eFileLock==RESERVED_LOCK || eFileLock==EXCLUSIVE_LOCK );
1496 if( eFileLock==RESERVED_LOCK ){
1497 lock.l_start = RESERVED_BYTE;
1498 lock.l_len = 1L;
1499 }else{
1500 lock.l_start = SHARED_FIRST;
1501 lock.l_len = SHARED_SIZE;
danielk19779a1d0ab2004-06-01 14:09:28 +00001502 }
dan661d71a2011-03-30 19:08:03 +00001503
1504 if( unixFileLock(pFile, &lock) ){
drh7ed97b92010-01-20 13:07:21 +00001505 tErrno = errno;
aswift5b1a2562008-08-22 00:22:35 +00001506 rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK);
dan661d71a2011-03-30 19:08:03 +00001507 if( rc!=SQLITE_BUSY ){
aswift5b1a2562008-08-22 00:22:35 +00001508 pFile->lastErrno = tErrno;
1509 }
danielk19779a1d0ab2004-06-01 14:09:28 +00001510 }
drhbbd42a62004-05-22 17:41:58 +00001511 }
danielk19779a1d0ab2004-06-01 14:09:28 +00001512
drh8f941bc2009-01-14 23:03:40 +00001513
1514#ifndef NDEBUG
1515 /* Set up the transaction-counter change checking flags when
1516 ** transitioning from a SHARED to a RESERVED lock. The change
1517 ** from SHARED to RESERVED marks the beginning of a normal
1518 ** write operation (not a hot journal rollback).
1519 */
1520 if( rc==SQLITE_OK
drh308c2a52010-05-14 11:30:18 +00001521 && pFile->eFileLock<=SHARED_LOCK
1522 && eFileLock==RESERVED_LOCK
drh8f941bc2009-01-14 23:03:40 +00001523 ){
1524 pFile->transCntrChng = 0;
1525 pFile->dbUpdate = 0;
1526 pFile->inNormalWrite = 1;
1527 }
1528#endif
1529
1530
danielk1977ecb2a962004-06-02 06:30:16 +00001531 if( rc==SQLITE_OK ){
drh308c2a52010-05-14 11:30:18 +00001532 pFile->eFileLock = eFileLock;
drh8af6c222010-05-14 12:43:01 +00001533 pInode->eFileLock = eFileLock;
drh308c2a52010-05-14 11:30:18 +00001534 }else if( eFileLock==EXCLUSIVE_LOCK ){
1535 pFile->eFileLock = PENDING_LOCK;
drh8af6c222010-05-14 12:43:01 +00001536 pInode->eFileLock = PENDING_LOCK;
danielk1977ecb2a962004-06-02 06:30:16 +00001537 }
danielk19779a1d0ab2004-06-01 14:09:28 +00001538
1539end_lock:
drh6c7d5c52008-11-21 20:32:33 +00001540 unixLeaveMutex();
drh308c2a52010-05-14 11:30:18 +00001541 OSTRACE(("LOCK %d %s %s (unix)\n", pFile->h, azFileLock(eFileLock),
1542 rc==SQLITE_OK ? "ok" : "failed"));
drhbbd42a62004-05-22 17:41:58 +00001543 return rc;
1544}
1545
1546/*
dan08da86a2009-08-21 17:18:03 +00001547** Add the file descriptor used by file handle pFile to the corresponding
dane946c392009-08-22 11:39:46 +00001548** pUnused list.
dan08da86a2009-08-21 17:18:03 +00001549*/
1550static void setPendingFd(unixFile *pFile){
drhd91c68f2010-05-14 14:52:25 +00001551 unixInodeInfo *pInode = pFile->pInode;
dane946c392009-08-22 11:39:46 +00001552 UnixUnusedFd *p = pFile->pUnused;
drh8af6c222010-05-14 12:43:01 +00001553 p->pNext = pInode->pUnused;
1554 pInode->pUnused = p;
dane946c392009-08-22 11:39:46 +00001555 pFile->h = -1;
1556 pFile->pUnused = 0;
dan08da86a2009-08-21 17:18:03 +00001557}
1558
1559/*
drh308c2a52010-05-14 11:30:18 +00001560** Lower the locking level on file descriptor pFile to eFileLock. eFileLock
drha6abd042004-06-09 17:37:22 +00001561** must be either NO_LOCK or SHARED_LOCK.
1562**
1563** If the locking level of the file descriptor is already at or below
1564** the requested locking level, this routine is a no-op.
drh7ed97b92010-01-20 13:07:21 +00001565**
1566** If handleNFSUnlock is true, then on downgrading an EXCLUSIVE_LOCK to SHARED
1567** the byte range is divided into 2 parts and the first part is unlocked then
1568** set to a read lock, then the other part is simply unlocked. This works
1569** around a bug in BSD NFS lockd (also seen on MacOSX 10.3+) that fails to
1570** remove the write lock on a region when a read lock is set.
drhbbd42a62004-05-22 17:41:58 +00001571*/
drha7e61d82011-03-12 17:02:57 +00001572static int posixUnlock(sqlite3_file *id, int eFileLock, int handleNFSUnlock){
drh7ed97b92010-01-20 13:07:21 +00001573 unixFile *pFile = (unixFile*)id;
drhd91c68f2010-05-14 14:52:25 +00001574 unixInodeInfo *pInode;
drh7ed97b92010-01-20 13:07:21 +00001575 struct flock lock;
1576 int rc = SQLITE_OK;
1577 int h;
drha6abd042004-06-09 17:37:22 +00001578
drh054889e2005-11-30 03:20:31 +00001579 assert( pFile );
drh308c2a52010-05-14 11:30:18 +00001580 OSTRACE(("UNLOCK %d %d was %d(%d,%d) pid=%d (unix)\n", pFile->h, eFileLock,
drh8af6c222010-05-14 12:43:01 +00001581 pFile->eFileLock, pFile->pInode->eFileLock, pFile->pInode->nShared,
drh308c2a52010-05-14 11:30:18 +00001582 getpid()));
drha6abd042004-06-09 17:37:22 +00001583
drh308c2a52010-05-14 11:30:18 +00001584 assert( eFileLock<=SHARED_LOCK );
1585 if( pFile->eFileLock<=eFileLock ){
drha6abd042004-06-09 17:37:22 +00001586 return SQLITE_OK;
1587 }
drh6c7d5c52008-11-21 20:32:33 +00001588 unixEnterMutex();
drh1aa5af12008-03-07 19:51:14 +00001589 h = pFile->h;
drh8af6c222010-05-14 12:43:01 +00001590 pInode = pFile->pInode;
1591 assert( pInode->nShared!=0 );
drh308c2a52010-05-14 11:30:18 +00001592 if( pFile->eFileLock>SHARED_LOCK ){
drh8af6c222010-05-14 12:43:01 +00001593 assert( pInode->eFileLock==pFile->eFileLock );
drh1aa5af12008-03-07 19:51:14 +00001594 SimulateIOErrorBenign(1);
1595 SimulateIOError( h=(-1) )
1596 SimulateIOErrorBenign(0);
drh8f941bc2009-01-14 23:03:40 +00001597
1598#ifndef NDEBUG
1599 /* When reducing a lock such that other processes can start
1600 ** reading the database file again, make sure that the
1601 ** transaction counter was updated if any part of the database
1602 ** file changed. If the transaction counter is not updated,
1603 ** other connections to the same file might not realize that
1604 ** the file has changed and hence might not know to flush their
1605 ** cache. The use of a stale cache can lead to database corruption.
1606 */
dan7c246102010-04-12 19:00:29 +00001607#if 0
drh8f941bc2009-01-14 23:03:40 +00001608 assert( pFile->inNormalWrite==0
1609 || pFile->dbUpdate==0
1610 || pFile->transCntrChng==1 );
dan7c246102010-04-12 19:00:29 +00001611#endif
drh8f941bc2009-01-14 23:03:40 +00001612 pFile->inNormalWrite = 0;
1613#endif
1614
drh7ed97b92010-01-20 13:07:21 +00001615 /* downgrading to a shared lock on NFS involves clearing the write lock
1616 ** before establishing the readlock - to avoid a race condition we downgrade
1617 ** the lock in 2 blocks, so that part of the range will be covered by a
1618 ** write lock until the rest is covered by a read lock:
1619 ** 1: [WWWWW]
1620 ** 2: [....W]
1621 ** 3: [RRRRW]
1622 ** 4: [RRRR.]
1623 */
drh308c2a52010-05-14 11:30:18 +00001624 if( eFileLock==SHARED_LOCK ){
drh30f776f2011-02-25 03:25:07 +00001625
1626#if !defined(__APPLE__) || !SQLITE_ENABLE_LOCKING_STYLE
drh87e79ae2011-03-08 13:06:41 +00001627 (void)handleNFSUnlock;
drh30f776f2011-02-25 03:25:07 +00001628 assert( handleNFSUnlock==0 );
1629#endif
1630#if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE
drh7ed97b92010-01-20 13:07:21 +00001631 if( handleNFSUnlock ){
drh026663d2011-04-01 13:29:29 +00001632 int tErrno; /* Error code from system call errors */
drh7ed97b92010-01-20 13:07:21 +00001633 off_t divSize = SHARED_SIZE - 1;
1634
1635 lock.l_type = F_UNLCK;
1636 lock.l_whence = SEEK_SET;
1637 lock.l_start = SHARED_FIRST;
1638 lock.l_len = divSize;
dan211fb082011-04-01 09:04:36 +00001639 if( unixFileLock(pFile, &lock)==(-1) ){
drhc05a9a82010-03-04 16:12:34 +00001640 tErrno = errno;
danea83bc62011-04-01 11:56:32 +00001641 rc = SQLITE_IOERR_UNLOCK;
drh7ed97b92010-01-20 13:07:21 +00001642 if( IS_LOCK_ERROR(rc) ){
1643 pFile->lastErrno = tErrno;
1644 }
1645 goto end_unlock;
aswift5b1a2562008-08-22 00:22:35 +00001646 }
drh7ed97b92010-01-20 13:07:21 +00001647 lock.l_type = F_RDLCK;
1648 lock.l_whence = SEEK_SET;
1649 lock.l_start = SHARED_FIRST;
1650 lock.l_len = divSize;
drha7e61d82011-03-12 17:02:57 +00001651 if( unixFileLock(pFile, &lock)==(-1) ){
drhc05a9a82010-03-04 16:12:34 +00001652 tErrno = errno;
drh7ed97b92010-01-20 13:07:21 +00001653 rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_RDLOCK);
1654 if( IS_LOCK_ERROR(rc) ){
1655 pFile->lastErrno = tErrno;
1656 }
1657 goto end_unlock;
1658 }
1659 lock.l_type = F_UNLCK;
1660 lock.l_whence = SEEK_SET;
1661 lock.l_start = SHARED_FIRST+divSize;
1662 lock.l_len = SHARED_SIZE-divSize;
drha7e61d82011-03-12 17:02:57 +00001663 if( unixFileLock(pFile, &lock)==(-1) ){
drhc05a9a82010-03-04 16:12:34 +00001664 tErrno = errno;
danea83bc62011-04-01 11:56:32 +00001665 rc = SQLITE_IOERR_UNLOCK;
drh7ed97b92010-01-20 13:07:21 +00001666 if( IS_LOCK_ERROR(rc) ){
1667 pFile->lastErrno = tErrno;
1668 }
1669 goto end_unlock;
1670 }
drh30f776f2011-02-25 03:25:07 +00001671 }else
1672#endif /* defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE */
1673 {
drh7ed97b92010-01-20 13:07:21 +00001674 lock.l_type = F_RDLCK;
1675 lock.l_whence = SEEK_SET;
1676 lock.l_start = SHARED_FIRST;
1677 lock.l_len = SHARED_SIZE;
dan661d71a2011-03-30 19:08:03 +00001678 if( unixFileLock(pFile, &lock) ){
danea83bc62011-04-01 11:56:32 +00001679 /* In theory, the call to unixFileLock() cannot fail because another
1680 ** process is holding an incompatible lock. If it does, this
1681 ** indicates that the other process is not following the locking
1682 ** protocol. If this happens, return SQLITE_IOERR_RDLOCK. Returning
1683 ** SQLITE_BUSY would confuse the upper layer (in practice it causes
1684 ** an assert to fail). */
1685 rc = SQLITE_IOERR_RDLOCK;
1686 pFile->lastErrno = errno;
drh7ed97b92010-01-20 13:07:21 +00001687 goto end_unlock;
1688 }
drh9c105bb2004-10-02 20:38:28 +00001689 }
1690 }
drhbbd42a62004-05-22 17:41:58 +00001691 lock.l_type = F_UNLCK;
1692 lock.l_whence = SEEK_SET;
drha6abd042004-06-09 17:37:22 +00001693 lock.l_start = PENDING_BYTE;
1694 lock.l_len = 2L; assert( PENDING_BYTE+1==RESERVED_BYTE );
dan661d71a2011-03-30 19:08:03 +00001695 if( unixFileLock(pFile, &lock)==0 ){
drh8af6c222010-05-14 12:43:01 +00001696 pInode->eFileLock = SHARED_LOCK;
drh2b4b5962005-06-15 17:47:55 +00001697 }else{
danea83bc62011-04-01 11:56:32 +00001698 rc = SQLITE_IOERR_UNLOCK;
1699 pFile->lastErrno = errno;
drhcd731cf2009-03-28 23:23:02 +00001700 goto end_unlock;
drh2b4b5962005-06-15 17:47:55 +00001701 }
drhbbd42a62004-05-22 17:41:58 +00001702 }
drh308c2a52010-05-14 11:30:18 +00001703 if( eFileLock==NO_LOCK ){
drha6abd042004-06-09 17:37:22 +00001704 /* Decrement the shared lock counter. Release the lock using an
1705 ** OS call only when all threads in this same process have released
1706 ** the lock.
1707 */
drh8af6c222010-05-14 12:43:01 +00001708 pInode->nShared--;
1709 if( pInode->nShared==0 ){
drha6abd042004-06-09 17:37:22 +00001710 lock.l_type = F_UNLCK;
1711 lock.l_whence = SEEK_SET;
1712 lock.l_start = lock.l_len = 0L;
drh1aa5af12008-03-07 19:51:14 +00001713 SimulateIOErrorBenign(1);
1714 SimulateIOError( h=(-1) )
1715 SimulateIOErrorBenign(0);
dan661d71a2011-03-30 19:08:03 +00001716 if( unixFileLock(pFile, &lock)==0 ){
drh8af6c222010-05-14 12:43:01 +00001717 pInode->eFileLock = NO_LOCK;
drh2b4b5962005-06-15 17:47:55 +00001718 }else{
danea83bc62011-04-01 11:56:32 +00001719 rc = SQLITE_IOERR_UNLOCK;
1720 pFile->lastErrno = errno;
drh8af6c222010-05-14 12:43:01 +00001721 pInode->eFileLock = NO_LOCK;
drh308c2a52010-05-14 11:30:18 +00001722 pFile->eFileLock = NO_LOCK;
drh2b4b5962005-06-15 17:47:55 +00001723 }
drha6abd042004-06-09 17:37:22 +00001724 }
1725
drhbbd42a62004-05-22 17:41:58 +00001726 /* Decrement the count of locks against this same file. When the
1727 ** count reaches zero, close any other file descriptors whose close
1728 ** was deferred because of outstanding locks.
1729 */
drh8af6c222010-05-14 12:43:01 +00001730 pInode->nLock--;
1731 assert( pInode->nLock>=0 );
1732 if( pInode->nLock==0 ){
drh0e9365c2011-03-02 02:08:13 +00001733 closePendingFds(pFile);
drhbbd42a62004-05-22 17:41:58 +00001734 }
1735 }
aswift5b1a2562008-08-22 00:22:35 +00001736
1737end_unlock:
drh6c7d5c52008-11-21 20:32:33 +00001738 unixLeaveMutex();
drh308c2a52010-05-14 11:30:18 +00001739 if( rc==SQLITE_OK ) pFile->eFileLock = eFileLock;
drh9c105bb2004-10-02 20:38:28 +00001740 return rc;
drhbbd42a62004-05-22 17:41:58 +00001741}
1742
1743/*
drh308c2a52010-05-14 11:30:18 +00001744** Lower the locking level on file descriptor pFile to eFileLock. eFileLock
drh7ed97b92010-01-20 13:07:21 +00001745** must be either NO_LOCK or SHARED_LOCK.
1746**
1747** If the locking level of the file descriptor is already at or below
1748** the requested locking level, this routine is a no-op.
1749*/
drh308c2a52010-05-14 11:30:18 +00001750static int unixUnlock(sqlite3_file *id, int eFileLock){
drha7e61d82011-03-12 17:02:57 +00001751 return posixUnlock(id, eFileLock, 0);
drh7ed97b92010-01-20 13:07:21 +00001752}
1753
1754/*
danielk1977e339d652008-06-28 11:23:00 +00001755** This function performs the parts of the "close file" operation
1756** common to all locking schemes. It closes the directory and file
1757** handles, if they are valid, and sets all fields of the unixFile
1758** structure to 0.
drh9b35ea62008-11-29 02:20:26 +00001759**
1760** It is *not* necessary to hold the mutex when this routine is called,
1761** even on VxWorks. A mutex will be acquired on VxWorks by the
1762** vxworksReleaseFileId() routine.
danielk1977e339d652008-06-28 11:23:00 +00001763*/
1764static int closeUnixFile(sqlite3_file *id){
1765 unixFile *pFile = (unixFile*)id;
dan661d71a2011-03-30 19:08:03 +00001766 if( pFile->h>=0 ){
1767 robust_close(pFile, pFile->h, __LINE__);
1768 pFile->h = -1;
1769 }
1770#if OS_VXWORKS
1771 if( pFile->pId ){
1772 if( pFile->isDelete ){
drh036ac7f2011-08-08 23:18:05 +00001773 osUnlink(pFile->pId->zCanonicalName);
dan661d71a2011-03-30 19:08:03 +00001774 }
1775 vxworksReleaseFileId(pFile->pId);
1776 pFile->pId = 0;
1777 }
1778#endif
1779 OSTRACE(("CLOSE %-3d\n", pFile->h));
1780 OpenCounter(-1);
1781 sqlite3_free(pFile->pUnused);
1782 memset(pFile, 0, sizeof(unixFile));
danielk1977e339d652008-06-28 11:23:00 +00001783 return SQLITE_OK;
1784}
1785
1786/*
danielk1977e3026632004-06-22 11:29:02 +00001787** Close a file.
1788*/
danielk197762079062007-08-15 17:08:46 +00001789static int unixClose(sqlite3_file *id){
aswiftaebf4132008-11-21 00:10:35 +00001790 int rc = SQLITE_OK;
dan661d71a2011-03-30 19:08:03 +00001791 unixFile *pFile = (unixFile *)id;
1792 unixUnlock(id, NO_LOCK);
1793 unixEnterMutex();
1794
1795 /* unixFile.pInode is always valid here. Otherwise, a different close
1796 ** routine (e.g. nolockClose()) would be called instead.
1797 */
1798 assert( pFile->pInode->nLock>0 || pFile->pInode->bProcessLock==0 );
1799 if( ALWAYS(pFile->pInode) && pFile->pInode->nLock ){
1800 /* If there are outstanding locks, do not actually close the file just
1801 ** yet because that would clear those locks. Instead, add the file
1802 ** descriptor to pInode->pUnused list. It will be automatically closed
1803 ** when the last lock is cleared.
1804 */
1805 setPendingFd(pFile);
danielk1977e3026632004-06-22 11:29:02 +00001806 }
dan661d71a2011-03-30 19:08:03 +00001807 releaseInodeInfo(pFile);
1808 rc = closeUnixFile(id);
1809 unixLeaveMutex();
aswiftaebf4132008-11-21 00:10:35 +00001810 return rc;
danielk1977e3026632004-06-22 11:29:02 +00001811}
1812
drh734c9862008-11-28 15:37:20 +00001813/************** End of the posix advisory lock implementation *****************
1814******************************************************************************/
drhbfe66312006-10-03 17:40:40 +00001815
drh734c9862008-11-28 15:37:20 +00001816/******************************************************************************
1817****************************** No-op Locking **********************************
1818**
1819** Of the various locking implementations available, this is by far the
1820** simplest: locking is ignored. No attempt is made to lock the database
1821** file for reading or writing.
1822**
1823** This locking mode is appropriate for use on read-only databases
1824** (ex: databases that are burned into CD-ROM, for example.) It can
1825** also be used if the application employs some external mechanism to
1826** prevent simultaneous access of the same database by two or more
1827** database connections. But there is a serious risk of database
1828** corruption if this locking mode is used in situations where multiple
1829** database connections are accessing the same database file at the same
1830** time and one or more of those connections are writing.
1831*/
drhbfe66312006-10-03 17:40:40 +00001832
drh734c9862008-11-28 15:37:20 +00001833static int nolockCheckReservedLock(sqlite3_file *NotUsed, int *pResOut){
1834 UNUSED_PARAMETER(NotUsed);
1835 *pResOut = 0;
1836 return SQLITE_OK;
1837}
drh734c9862008-11-28 15:37:20 +00001838static int nolockLock(sqlite3_file *NotUsed, int NotUsed2){
1839 UNUSED_PARAMETER2(NotUsed, NotUsed2);
1840 return SQLITE_OK;
1841}
drh734c9862008-11-28 15:37:20 +00001842static int nolockUnlock(sqlite3_file *NotUsed, int NotUsed2){
1843 UNUSED_PARAMETER2(NotUsed, NotUsed2);
1844 return SQLITE_OK;
1845}
1846
1847/*
drh9b35ea62008-11-29 02:20:26 +00001848** Close the file.
drh734c9862008-11-28 15:37:20 +00001849*/
1850static int nolockClose(sqlite3_file *id) {
drh9b35ea62008-11-29 02:20:26 +00001851 return closeUnixFile(id);
drh734c9862008-11-28 15:37:20 +00001852}
1853
1854/******************* End of the no-op lock implementation *********************
1855******************************************************************************/
1856
1857/******************************************************************************
1858************************* Begin dot-file Locking ******************************
1859**
drh0c2694b2009-09-03 16:23:44 +00001860** The dotfile locking implementation uses the existance of separate lock
drh734c9862008-11-28 15:37:20 +00001861** files in order to control access to the database. This works on just
1862** about every filesystem imaginable. But there are serious downsides:
1863**
1864** (1) There is zero concurrency. A single reader blocks all other
1865** connections from reading or writing the database.
1866**
1867** (2) An application crash or power loss can leave stale lock files
1868** sitting around that need to be cleared manually.
1869**
1870** Nevertheless, a dotlock is an appropriate locking mode for use if no
1871** other locking strategy is available.
drh7708e972008-11-29 00:56:52 +00001872**
1873** Dotfile locking works by creating a file in the same directory as the
1874** database and with the same name but with a ".lock" extension added.
1875** The existance of a lock file implies an EXCLUSIVE lock. All other lock
1876** types (SHARED, RESERVED, PENDING) are mapped into EXCLUSIVE.
drh734c9862008-11-28 15:37:20 +00001877*/
1878
1879/*
1880** The file suffix added to the data base filename in order to create the
1881** lock file.
1882*/
1883#define DOTLOCK_SUFFIX ".lock"
1884
drh7708e972008-11-29 00:56:52 +00001885/*
1886** This routine checks if there is a RESERVED lock held on the specified
1887** file by this or any other process. If such a lock is held, set *pResOut
1888** to a non-zero value otherwise *pResOut is set to zero. The return value
1889** is set to SQLITE_OK unless an I/O error occurs during lock checking.
1890**
1891** In dotfile locking, either a lock exists or it does not. So in this
1892** variation of CheckReservedLock(), *pResOut is set to true if any lock
1893** is held on the file and false if the file is unlocked.
1894*/
drh734c9862008-11-28 15:37:20 +00001895static int dotlockCheckReservedLock(sqlite3_file *id, int *pResOut) {
1896 int rc = SQLITE_OK;
1897 int reserved = 0;
1898 unixFile *pFile = (unixFile*)id;
1899
1900 SimulateIOError( return SQLITE_IOERR_CHECKRESERVEDLOCK; );
1901
1902 assert( pFile );
1903
1904 /* Check if a thread in this process holds such a lock */
drh308c2a52010-05-14 11:30:18 +00001905 if( pFile->eFileLock>SHARED_LOCK ){
drh7708e972008-11-29 00:56:52 +00001906 /* Either this connection or some other connection in the same process
1907 ** holds a lock on the file. No need to check further. */
drh734c9862008-11-28 15:37:20 +00001908 reserved = 1;
drh7708e972008-11-29 00:56:52 +00001909 }else{
1910 /* The lock is held if and only if the lockfile exists */
1911 const char *zLockFile = (const char*)pFile->lockingContext;
drh99ab3b12011-03-02 15:09:07 +00001912 reserved = osAccess(zLockFile, 0)==0;
drh734c9862008-11-28 15:37:20 +00001913 }
drh308c2a52010-05-14 11:30:18 +00001914 OSTRACE(("TEST WR-LOCK %d %d %d (dotlock)\n", pFile->h, rc, reserved));
drh734c9862008-11-28 15:37:20 +00001915 *pResOut = reserved;
1916 return rc;
1917}
1918
drh7708e972008-11-29 00:56:52 +00001919/*
drh308c2a52010-05-14 11:30:18 +00001920** Lock the file with the lock specified by parameter eFileLock - one
drh7708e972008-11-29 00:56:52 +00001921** of the following:
1922**
1923** (1) SHARED_LOCK
1924** (2) RESERVED_LOCK
1925** (3) PENDING_LOCK
1926** (4) EXCLUSIVE_LOCK
1927**
1928** Sometimes when requesting one lock state, additional lock states
1929** are inserted in between. The locking might fail on one of the later
1930** transitions leaving the lock state different from what it started but
1931** still short of its goal. The following chart shows the allowed
1932** transitions and the inserted intermediate states:
1933**
1934** UNLOCKED -> SHARED
1935** SHARED -> RESERVED
1936** SHARED -> (PENDING) -> EXCLUSIVE
1937** RESERVED -> (PENDING) -> EXCLUSIVE
1938** PENDING -> EXCLUSIVE
1939**
1940** This routine will only increase a lock. Use the sqlite3OsUnlock()
1941** routine to lower a locking level.
1942**
1943** With dotfile locking, we really only support state (4): EXCLUSIVE.
1944** But we track the other locking levels internally.
1945*/
drh308c2a52010-05-14 11:30:18 +00001946static int dotlockLock(sqlite3_file *id, int eFileLock) {
drh734c9862008-11-28 15:37:20 +00001947 unixFile *pFile = (unixFile*)id;
1948 int fd;
1949 char *zLockFile = (char *)pFile->lockingContext;
drh7708e972008-11-29 00:56:52 +00001950 int rc = SQLITE_OK;
drh734c9862008-11-28 15:37:20 +00001951
drh7708e972008-11-29 00:56:52 +00001952
1953 /* If we have any lock, then the lock file already exists. All we have
1954 ** to do is adjust our internal record of the lock level.
1955 */
drh308c2a52010-05-14 11:30:18 +00001956 if( pFile->eFileLock > NO_LOCK ){
1957 pFile->eFileLock = eFileLock;
drh734c9862008-11-28 15:37:20 +00001958 /* Always update the timestamp on the old file */
drhdbe4b882011-06-20 18:00:17 +00001959#ifdef HAVE_UTIME
1960 utime(zLockFile, NULL);
1961#else
drh734c9862008-11-28 15:37:20 +00001962 utimes(zLockFile, NULL);
1963#endif
drh7708e972008-11-29 00:56:52 +00001964 return SQLITE_OK;
drh734c9862008-11-28 15:37:20 +00001965 }
1966
1967 /* grab an exclusive lock */
drhad4f1e52011-03-04 15:43:57 +00001968 fd = robust_open(zLockFile,O_RDONLY|O_CREAT|O_EXCL,0600);
drh734c9862008-11-28 15:37:20 +00001969 if( fd<0 ){
1970 /* failed to open/create the file, someone else may have stolen the lock */
1971 int tErrno = errno;
1972 if( EEXIST == tErrno ){
1973 rc = SQLITE_BUSY;
1974 } else {
1975 rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK);
1976 if( IS_LOCK_ERROR(rc) ){
1977 pFile->lastErrno = tErrno;
1978 }
1979 }
drh7708e972008-11-29 00:56:52 +00001980 return rc;
drh734c9862008-11-28 15:37:20 +00001981 }
drh0e9365c2011-03-02 02:08:13 +00001982 robust_close(pFile, fd, __LINE__);
drh734c9862008-11-28 15:37:20 +00001983
1984 /* got it, set the type and return ok */
drh308c2a52010-05-14 11:30:18 +00001985 pFile->eFileLock = eFileLock;
drh734c9862008-11-28 15:37:20 +00001986 return rc;
1987}
1988
drh7708e972008-11-29 00:56:52 +00001989/*
drh308c2a52010-05-14 11:30:18 +00001990** Lower the locking level on file descriptor pFile to eFileLock. eFileLock
drh7708e972008-11-29 00:56:52 +00001991** must be either NO_LOCK or SHARED_LOCK.
1992**
1993** If the locking level of the file descriptor is already at or below
1994** the requested locking level, this routine is a no-op.
1995**
1996** When the locking level reaches NO_LOCK, delete the lock file.
1997*/
drh308c2a52010-05-14 11:30:18 +00001998static int dotlockUnlock(sqlite3_file *id, int eFileLock) {
drh734c9862008-11-28 15:37:20 +00001999 unixFile *pFile = (unixFile*)id;
2000 char *zLockFile = (char *)pFile->lockingContext;
2001
2002 assert( pFile );
drh308c2a52010-05-14 11:30:18 +00002003 OSTRACE(("UNLOCK %d %d was %d pid=%d (dotlock)\n", pFile->h, eFileLock,
2004 pFile->eFileLock, getpid()));
2005 assert( eFileLock<=SHARED_LOCK );
drh734c9862008-11-28 15:37:20 +00002006
2007 /* no-op if possible */
drh308c2a52010-05-14 11:30:18 +00002008 if( pFile->eFileLock==eFileLock ){
drh734c9862008-11-28 15:37:20 +00002009 return SQLITE_OK;
2010 }
drh7708e972008-11-29 00:56:52 +00002011
2012 /* To downgrade to shared, simply update our internal notion of the
2013 ** lock state. No need to mess with the file on disk.
2014 */
drh308c2a52010-05-14 11:30:18 +00002015 if( eFileLock==SHARED_LOCK ){
2016 pFile->eFileLock = SHARED_LOCK;
drh734c9862008-11-28 15:37:20 +00002017 return SQLITE_OK;
2018 }
2019
drh7708e972008-11-29 00:56:52 +00002020 /* To fully unlock the database, delete the lock file */
drh308c2a52010-05-14 11:30:18 +00002021 assert( eFileLock==NO_LOCK );
drh036ac7f2011-08-08 23:18:05 +00002022 if( osUnlink(zLockFile) ){
drh0d588bb2009-06-17 13:09:38 +00002023 int rc = 0;
2024 int tErrno = errno;
drh734c9862008-11-28 15:37:20 +00002025 if( ENOENT != tErrno ){
danea83bc62011-04-01 11:56:32 +00002026 rc = SQLITE_IOERR_UNLOCK;
drh734c9862008-11-28 15:37:20 +00002027 }
2028 if( IS_LOCK_ERROR(rc) ){
2029 pFile->lastErrno = tErrno;
2030 }
2031 return rc;
2032 }
drh308c2a52010-05-14 11:30:18 +00002033 pFile->eFileLock = NO_LOCK;
drh734c9862008-11-28 15:37:20 +00002034 return SQLITE_OK;
2035}
2036
2037/*
drh9b35ea62008-11-29 02:20:26 +00002038** Close a file. Make sure the lock has been released before closing.
drh734c9862008-11-28 15:37:20 +00002039*/
2040static int dotlockClose(sqlite3_file *id) {
2041 int rc;
2042 if( id ){
2043 unixFile *pFile = (unixFile*)id;
2044 dotlockUnlock(id, NO_LOCK);
2045 sqlite3_free(pFile->lockingContext);
2046 }
drh734c9862008-11-28 15:37:20 +00002047 rc = closeUnixFile(id);
drh734c9862008-11-28 15:37:20 +00002048 return rc;
2049}
2050/****************** End of the dot-file lock implementation *******************
2051******************************************************************************/
2052
2053/******************************************************************************
2054************************** Begin flock Locking ********************************
2055**
2056** Use the flock() system call to do file locking.
2057**
drh6b9d6dd2008-12-03 19:34:47 +00002058** flock() locking is like dot-file locking in that the various
2059** fine-grain locking levels supported by SQLite are collapsed into
2060** a single exclusive lock. In other words, SHARED, RESERVED, and
2061** PENDING locks are the same thing as an EXCLUSIVE lock. SQLite
2062** still works when you do this, but concurrency is reduced since
2063** only a single process can be reading the database at a time.
2064**
drh734c9862008-11-28 15:37:20 +00002065** Omit this section if SQLITE_ENABLE_LOCKING_STYLE is turned off or if
2066** compiling for VXWORKS.
2067*/
2068#if SQLITE_ENABLE_LOCKING_STYLE && !OS_VXWORKS
drh734c9862008-11-28 15:37:20 +00002069
drh6b9d6dd2008-12-03 19:34:47 +00002070/*
drhff812312011-02-23 13:33:46 +00002071** Retry flock() calls that fail with EINTR
2072*/
2073#ifdef EINTR
2074static int robust_flock(int fd, int op){
2075 int rc;
2076 do{ rc = flock(fd,op); }while( rc<0 && errno==EINTR );
2077 return rc;
2078}
2079#else
drh5c819272011-02-23 14:00:12 +00002080# define robust_flock(a,b) flock(a,b)
drhff812312011-02-23 13:33:46 +00002081#endif
2082
2083
2084/*
drh6b9d6dd2008-12-03 19:34:47 +00002085** This routine checks if there is a RESERVED lock held on the specified
2086** file by this or any other process. If such a lock is held, set *pResOut
2087** to a non-zero value otherwise *pResOut is set to zero. The return value
2088** is set to SQLITE_OK unless an I/O error occurs during lock checking.
2089*/
drh734c9862008-11-28 15:37:20 +00002090static int flockCheckReservedLock(sqlite3_file *id, int *pResOut){
2091 int rc = SQLITE_OK;
2092 int reserved = 0;
2093 unixFile *pFile = (unixFile*)id;
2094
2095 SimulateIOError( return SQLITE_IOERR_CHECKRESERVEDLOCK; );
2096
2097 assert( pFile );
2098
2099 /* Check if a thread in this process holds such a lock */
drh308c2a52010-05-14 11:30:18 +00002100 if( pFile->eFileLock>SHARED_LOCK ){
drh734c9862008-11-28 15:37:20 +00002101 reserved = 1;
2102 }
2103
2104 /* Otherwise see if some other process holds it. */
2105 if( !reserved ){
2106 /* attempt to get the lock */
drhff812312011-02-23 13:33:46 +00002107 int lrc = robust_flock(pFile->h, LOCK_EX | LOCK_NB);
drh734c9862008-11-28 15:37:20 +00002108 if( !lrc ){
2109 /* got the lock, unlock it */
drhff812312011-02-23 13:33:46 +00002110 lrc = robust_flock(pFile->h, LOCK_UN);
drh734c9862008-11-28 15:37:20 +00002111 if ( lrc ) {
2112 int tErrno = errno;
2113 /* unlock failed with an error */
danea83bc62011-04-01 11:56:32 +00002114 lrc = SQLITE_IOERR_UNLOCK;
drh734c9862008-11-28 15:37:20 +00002115 if( IS_LOCK_ERROR(lrc) ){
2116 pFile->lastErrno = tErrno;
2117 rc = lrc;
2118 }
2119 }
2120 } else {
2121 int tErrno = errno;
2122 reserved = 1;
2123 /* someone else might have it reserved */
2124 lrc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK);
2125 if( IS_LOCK_ERROR(lrc) ){
2126 pFile->lastErrno = tErrno;
2127 rc = lrc;
2128 }
2129 }
2130 }
drh308c2a52010-05-14 11:30:18 +00002131 OSTRACE(("TEST WR-LOCK %d %d %d (flock)\n", pFile->h, rc, reserved));
drh734c9862008-11-28 15:37:20 +00002132
2133#ifdef SQLITE_IGNORE_FLOCK_LOCK_ERRORS
2134 if( (rc & SQLITE_IOERR) == SQLITE_IOERR ){
2135 rc = SQLITE_OK;
2136 reserved=1;
2137 }
2138#endif /* SQLITE_IGNORE_FLOCK_LOCK_ERRORS */
2139 *pResOut = reserved;
2140 return rc;
2141}
2142
drh6b9d6dd2008-12-03 19:34:47 +00002143/*
drh308c2a52010-05-14 11:30:18 +00002144** Lock the file with the lock specified by parameter eFileLock - one
drh6b9d6dd2008-12-03 19:34:47 +00002145** of the following:
2146**
2147** (1) SHARED_LOCK
2148** (2) RESERVED_LOCK
2149** (3) PENDING_LOCK
2150** (4) EXCLUSIVE_LOCK
2151**
2152** Sometimes when requesting one lock state, additional lock states
2153** are inserted in between. The locking might fail on one of the later
2154** transitions leaving the lock state different from what it started but
2155** still short of its goal. The following chart shows the allowed
2156** transitions and the inserted intermediate states:
2157**
2158** UNLOCKED -> SHARED
2159** SHARED -> RESERVED
2160** SHARED -> (PENDING) -> EXCLUSIVE
2161** RESERVED -> (PENDING) -> EXCLUSIVE
2162** PENDING -> EXCLUSIVE
2163**
2164** flock() only really support EXCLUSIVE locks. We track intermediate
2165** lock states in the sqlite3_file structure, but all locks SHARED or
2166** above are really EXCLUSIVE locks and exclude all other processes from
2167** access the file.
2168**
2169** This routine will only increase a lock. Use the sqlite3OsUnlock()
2170** routine to lower a locking level.
2171*/
drh308c2a52010-05-14 11:30:18 +00002172static int flockLock(sqlite3_file *id, int eFileLock) {
drh734c9862008-11-28 15:37:20 +00002173 int rc = SQLITE_OK;
drh734c9862008-11-28 15:37:20 +00002174 unixFile *pFile = (unixFile*)id;
2175
2176 assert( pFile );
2177
2178 /* if we already have a lock, it is exclusive.
2179 ** Just adjust level and punt on outta here. */
drh308c2a52010-05-14 11:30:18 +00002180 if (pFile->eFileLock > NO_LOCK) {
2181 pFile->eFileLock = eFileLock;
drh734c9862008-11-28 15:37:20 +00002182 return SQLITE_OK;
2183 }
2184
2185 /* grab an exclusive lock */
2186
drhff812312011-02-23 13:33:46 +00002187 if (robust_flock(pFile->h, LOCK_EX | LOCK_NB)) {
drh734c9862008-11-28 15:37:20 +00002188 int tErrno = errno;
2189 /* didn't get, must be busy */
2190 rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK);
2191 if( IS_LOCK_ERROR(rc) ){
2192 pFile->lastErrno = tErrno;
2193 }
2194 } else {
2195 /* got it, set the type and return ok */
drh308c2a52010-05-14 11:30:18 +00002196 pFile->eFileLock = eFileLock;
drh734c9862008-11-28 15:37:20 +00002197 }
drh308c2a52010-05-14 11:30:18 +00002198 OSTRACE(("LOCK %d %s %s (flock)\n", pFile->h, azFileLock(eFileLock),
2199 rc==SQLITE_OK ? "ok" : "failed"));
drh734c9862008-11-28 15:37:20 +00002200#ifdef SQLITE_IGNORE_FLOCK_LOCK_ERRORS
2201 if( (rc & SQLITE_IOERR) == SQLITE_IOERR ){
2202 rc = SQLITE_BUSY;
2203 }
2204#endif /* SQLITE_IGNORE_FLOCK_LOCK_ERRORS */
2205 return rc;
2206}
2207
drh6b9d6dd2008-12-03 19:34:47 +00002208
2209/*
drh308c2a52010-05-14 11:30:18 +00002210** Lower the locking level on file descriptor pFile to eFileLock. eFileLock
drh6b9d6dd2008-12-03 19:34:47 +00002211** must be either NO_LOCK or SHARED_LOCK.
2212**
2213** If the locking level of the file descriptor is already at or below
2214** the requested locking level, this routine is a no-op.
2215*/
drh308c2a52010-05-14 11:30:18 +00002216static int flockUnlock(sqlite3_file *id, int eFileLock) {
drh734c9862008-11-28 15:37:20 +00002217 unixFile *pFile = (unixFile*)id;
2218
2219 assert( pFile );
drh308c2a52010-05-14 11:30:18 +00002220 OSTRACE(("UNLOCK %d %d was %d pid=%d (flock)\n", pFile->h, eFileLock,
2221 pFile->eFileLock, getpid()));
2222 assert( eFileLock<=SHARED_LOCK );
drh734c9862008-11-28 15:37:20 +00002223
2224 /* no-op if possible */
drh308c2a52010-05-14 11:30:18 +00002225 if( pFile->eFileLock==eFileLock ){
drh734c9862008-11-28 15:37:20 +00002226 return SQLITE_OK;
2227 }
2228
2229 /* shared can just be set because we always have an exclusive */
drh308c2a52010-05-14 11:30:18 +00002230 if (eFileLock==SHARED_LOCK) {
2231 pFile->eFileLock = eFileLock;
drh734c9862008-11-28 15:37:20 +00002232 return SQLITE_OK;
2233 }
2234
2235 /* no, really, unlock. */
danea83bc62011-04-01 11:56:32 +00002236 if( robust_flock(pFile->h, LOCK_UN) ){
drh734c9862008-11-28 15:37:20 +00002237#ifdef SQLITE_IGNORE_FLOCK_LOCK_ERRORS
danea83bc62011-04-01 11:56:32 +00002238 return SQLITE_OK;
drh734c9862008-11-28 15:37:20 +00002239#endif /* SQLITE_IGNORE_FLOCK_LOCK_ERRORS */
danea83bc62011-04-01 11:56:32 +00002240 return SQLITE_IOERR_UNLOCK;
2241 }else{
drh308c2a52010-05-14 11:30:18 +00002242 pFile->eFileLock = NO_LOCK;
drh734c9862008-11-28 15:37:20 +00002243 return SQLITE_OK;
2244 }
2245}
2246
2247/*
2248** Close a file.
2249*/
2250static int flockClose(sqlite3_file *id) {
2251 if( id ){
2252 flockUnlock(id, NO_LOCK);
2253 }
2254 return closeUnixFile(id);
2255}
2256
2257#endif /* SQLITE_ENABLE_LOCKING_STYLE && !OS_VXWORK */
2258
2259/******************* End of the flock lock implementation *********************
2260******************************************************************************/
2261
2262/******************************************************************************
2263************************ Begin Named Semaphore Locking ************************
2264**
2265** Named semaphore locking is only supported on VxWorks.
drh6b9d6dd2008-12-03 19:34:47 +00002266**
2267** Semaphore locking is like dot-lock and flock in that it really only
2268** supports EXCLUSIVE locking. Only a single process can read or write
2269** the database file at a time. This reduces potential concurrency, but
2270** makes the lock implementation much easier.
drh734c9862008-11-28 15:37:20 +00002271*/
2272#if OS_VXWORKS
2273
drh6b9d6dd2008-12-03 19:34:47 +00002274/*
2275** This routine checks if there is a RESERVED lock held on the specified
2276** file by this or any other process. If such a lock is held, set *pResOut
2277** to a non-zero value otherwise *pResOut is set to zero. The return value
2278** is set to SQLITE_OK unless an I/O error occurs during lock checking.
2279*/
drh734c9862008-11-28 15:37:20 +00002280static int semCheckReservedLock(sqlite3_file *id, int *pResOut) {
2281 int rc = SQLITE_OK;
2282 int reserved = 0;
2283 unixFile *pFile = (unixFile*)id;
2284
2285 SimulateIOError( return SQLITE_IOERR_CHECKRESERVEDLOCK; );
2286
2287 assert( pFile );
2288
2289 /* Check if a thread in this process holds such a lock */
drh308c2a52010-05-14 11:30:18 +00002290 if( pFile->eFileLock>SHARED_LOCK ){
drh734c9862008-11-28 15:37:20 +00002291 reserved = 1;
2292 }
2293
2294 /* Otherwise see if some other process holds it. */
2295 if( !reserved ){
drh8af6c222010-05-14 12:43:01 +00002296 sem_t *pSem = pFile->pInode->pSem;
drh734c9862008-11-28 15:37:20 +00002297 struct stat statBuf;
2298
2299 if( sem_trywait(pSem)==-1 ){
2300 int tErrno = errno;
2301 if( EAGAIN != tErrno ){
2302 rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_CHECKRESERVEDLOCK);
2303 pFile->lastErrno = tErrno;
2304 } else {
2305 /* someone else has the lock when we are in NO_LOCK */
drh308c2a52010-05-14 11:30:18 +00002306 reserved = (pFile->eFileLock < SHARED_LOCK);
drh734c9862008-11-28 15:37:20 +00002307 }
2308 }else{
2309 /* we could have it if we want it */
2310 sem_post(pSem);
2311 }
2312 }
drh308c2a52010-05-14 11:30:18 +00002313 OSTRACE(("TEST WR-LOCK %d %d %d (sem)\n", pFile->h, rc, reserved));
drh734c9862008-11-28 15:37:20 +00002314
2315 *pResOut = reserved;
2316 return rc;
2317}
2318
drh6b9d6dd2008-12-03 19:34:47 +00002319/*
drh308c2a52010-05-14 11:30:18 +00002320** Lock the file with the lock specified by parameter eFileLock - one
drh6b9d6dd2008-12-03 19:34:47 +00002321** of the following:
2322**
2323** (1) SHARED_LOCK
2324** (2) RESERVED_LOCK
2325** (3) PENDING_LOCK
2326** (4) EXCLUSIVE_LOCK
2327**
2328** Sometimes when requesting one lock state, additional lock states
2329** are inserted in between. The locking might fail on one of the later
2330** transitions leaving the lock state different from what it started but
2331** still short of its goal. The following chart shows the allowed
2332** transitions and the inserted intermediate states:
2333**
2334** UNLOCKED -> SHARED
2335** SHARED -> RESERVED
2336** SHARED -> (PENDING) -> EXCLUSIVE
2337** RESERVED -> (PENDING) -> EXCLUSIVE
2338** PENDING -> EXCLUSIVE
2339**
2340** Semaphore locks only really support EXCLUSIVE locks. We track intermediate
2341** lock states in the sqlite3_file structure, but all locks SHARED or
2342** above are really EXCLUSIVE locks and exclude all other processes from
2343** access the file.
2344**
2345** This routine will only increase a lock. Use the sqlite3OsUnlock()
2346** routine to lower a locking level.
2347*/
drh308c2a52010-05-14 11:30:18 +00002348static int semLock(sqlite3_file *id, int eFileLock) {
drh734c9862008-11-28 15:37:20 +00002349 unixFile *pFile = (unixFile*)id;
2350 int fd;
drh8af6c222010-05-14 12:43:01 +00002351 sem_t *pSem = pFile->pInode->pSem;
drh734c9862008-11-28 15:37:20 +00002352 int rc = SQLITE_OK;
2353
2354 /* if we already have a lock, it is exclusive.
2355 ** Just adjust level and punt on outta here. */
drh308c2a52010-05-14 11:30:18 +00002356 if (pFile->eFileLock > NO_LOCK) {
2357 pFile->eFileLock = eFileLock;
drh734c9862008-11-28 15:37:20 +00002358 rc = SQLITE_OK;
2359 goto sem_end_lock;
2360 }
2361
2362 /* lock semaphore now but bail out when already locked. */
2363 if( sem_trywait(pSem)==-1 ){
2364 rc = SQLITE_BUSY;
2365 goto sem_end_lock;
2366 }
2367
2368 /* got it, set the type and return ok */
drh308c2a52010-05-14 11:30:18 +00002369 pFile->eFileLock = eFileLock;
drh734c9862008-11-28 15:37:20 +00002370
2371 sem_end_lock:
2372 return rc;
2373}
2374
drh6b9d6dd2008-12-03 19:34:47 +00002375/*
drh308c2a52010-05-14 11:30:18 +00002376** Lower the locking level on file descriptor pFile to eFileLock. eFileLock
drh6b9d6dd2008-12-03 19:34:47 +00002377** must be either NO_LOCK or SHARED_LOCK.
2378**
2379** If the locking level of the file descriptor is already at or below
2380** the requested locking level, this routine is a no-op.
2381*/
drh308c2a52010-05-14 11:30:18 +00002382static int semUnlock(sqlite3_file *id, int eFileLock) {
drh734c9862008-11-28 15:37:20 +00002383 unixFile *pFile = (unixFile*)id;
drh8af6c222010-05-14 12:43:01 +00002384 sem_t *pSem = pFile->pInode->pSem;
drh734c9862008-11-28 15:37:20 +00002385
2386 assert( pFile );
2387 assert( pSem );
drh308c2a52010-05-14 11:30:18 +00002388 OSTRACE(("UNLOCK %d %d was %d pid=%d (sem)\n", pFile->h, eFileLock,
2389 pFile->eFileLock, getpid()));
2390 assert( eFileLock<=SHARED_LOCK );
drh734c9862008-11-28 15:37:20 +00002391
2392 /* no-op if possible */
drh308c2a52010-05-14 11:30:18 +00002393 if( pFile->eFileLock==eFileLock ){
drh734c9862008-11-28 15:37:20 +00002394 return SQLITE_OK;
2395 }
2396
2397 /* shared can just be set because we always have an exclusive */
drh308c2a52010-05-14 11:30:18 +00002398 if (eFileLock==SHARED_LOCK) {
2399 pFile->eFileLock = eFileLock;
drh734c9862008-11-28 15:37:20 +00002400 return SQLITE_OK;
2401 }
2402
2403 /* no, really unlock. */
2404 if ( sem_post(pSem)==-1 ) {
2405 int rc, tErrno = errno;
2406 rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_UNLOCK);
2407 if( IS_LOCK_ERROR(rc) ){
2408 pFile->lastErrno = tErrno;
2409 }
2410 return rc;
2411 }
drh308c2a52010-05-14 11:30:18 +00002412 pFile->eFileLock = NO_LOCK;
drh734c9862008-11-28 15:37:20 +00002413 return SQLITE_OK;
2414}
2415
2416/*
2417 ** Close a file.
drhbfe66312006-10-03 17:40:40 +00002418 */
drh734c9862008-11-28 15:37:20 +00002419static int semClose(sqlite3_file *id) {
2420 if( id ){
2421 unixFile *pFile = (unixFile*)id;
2422 semUnlock(id, NO_LOCK);
2423 assert( pFile );
2424 unixEnterMutex();
danb0ac3e32010-06-16 10:55:42 +00002425 releaseInodeInfo(pFile);
drh734c9862008-11-28 15:37:20 +00002426 unixLeaveMutex();
chw78a13182009-04-07 05:35:03 +00002427 closeUnixFile(id);
drh734c9862008-11-28 15:37:20 +00002428 }
2429 return SQLITE_OK;
2430}
2431
2432#endif /* OS_VXWORKS */
2433/*
2434** Named semaphore locking is only available on VxWorks.
2435**
2436*************** End of the named semaphore lock implementation ****************
2437******************************************************************************/
2438
2439
2440/******************************************************************************
2441*************************** Begin AFP Locking *********************************
2442**
2443** AFP is the Apple Filing Protocol. AFP is a network filesystem found
2444** on Apple Macintosh computers - both OS9 and OSX.
2445**
2446** Third-party implementations of AFP are available. But this code here
2447** only works on OSX.
2448*/
2449
drhd2cb50b2009-01-09 21:41:17 +00002450#if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE
drh734c9862008-11-28 15:37:20 +00002451/*
2452** The afpLockingContext structure contains all afp lock specific state
2453*/
drhbfe66312006-10-03 17:40:40 +00002454typedef struct afpLockingContext afpLockingContext;
2455struct afpLockingContext {
drh7ed97b92010-01-20 13:07:21 +00002456 int reserved;
drh6b9d6dd2008-12-03 19:34:47 +00002457 const char *dbPath; /* Name of the open file */
drhbfe66312006-10-03 17:40:40 +00002458};
2459
2460struct ByteRangeLockPB2
2461{
2462 unsigned long long offset; /* offset to first byte to lock */
2463 unsigned long long length; /* nbr of bytes to lock */
2464 unsigned long long retRangeStart; /* nbr of 1st byte locked if successful */
2465 unsigned char unLockFlag; /* 1 = unlock, 0 = lock */
2466 unsigned char startEndFlag; /* 1=rel to end of fork, 0=rel to start */
2467 int fd; /* file desc to assoc this lock with */
2468};
2469
drhfd131da2007-08-07 17:13:03 +00002470#define afpfsByteRangeLock2FSCTL _IOWR('z', 23, struct ByteRangeLockPB2)
drhbfe66312006-10-03 17:40:40 +00002471
drh6b9d6dd2008-12-03 19:34:47 +00002472/*
2473** This is a utility for setting or clearing a bit-range lock on an
2474** AFP filesystem.
2475**
2476** Return SQLITE_OK on success, SQLITE_BUSY on failure.
2477*/
2478static int afpSetLock(
2479 const char *path, /* Name of the file to be locked or unlocked */
2480 unixFile *pFile, /* Open file descriptor on path */
2481 unsigned long long offset, /* First byte to be locked */
2482 unsigned long long length, /* Number of bytes to lock */
2483 int setLockFlag /* True to set lock. False to clear lock */
danielk1977ad94b582007-08-20 06:44:22 +00002484){
drh6b9d6dd2008-12-03 19:34:47 +00002485 struct ByteRangeLockPB2 pb;
2486 int err;
drhbfe66312006-10-03 17:40:40 +00002487
2488 pb.unLockFlag = setLockFlag ? 0 : 1;
2489 pb.startEndFlag = 0;
2490 pb.offset = offset;
2491 pb.length = length;
aswift5b1a2562008-08-22 00:22:35 +00002492 pb.fd = pFile->h;
aswiftaebf4132008-11-21 00:10:35 +00002493
drh308c2a52010-05-14 11:30:18 +00002494 OSTRACE(("AFPSETLOCK [%s] for %d%s in range %llx:%llx\n",
drh734c9862008-11-28 15:37:20 +00002495 (setLockFlag?"ON":"OFF"), pFile->h, (pb.fd==-1?"[testval-1]":""),
drh308c2a52010-05-14 11:30:18 +00002496 offset, length));
drhbfe66312006-10-03 17:40:40 +00002497 err = fsctl(path, afpfsByteRangeLock2FSCTL, &pb, 0);
2498 if ( err==-1 ) {
aswift5b1a2562008-08-22 00:22:35 +00002499 int rc;
2500 int tErrno = errno;
drh308c2a52010-05-14 11:30:18 +00002501 OSTRACE(("AFPSETLOCK failed to fsctl() '%s' %d %s\n",
2502 path, tErrno, strerror(tErrno)));
aswiftaebf4132008-11-21 00:10:35 +00002503#ifdef SQLITE_IGNORE_AFP_LOCK_ERRORS
2504 rc = SQLITE_BUSY;
2505#else
drh734c9862008-11-28 15:37:20 +00002506 rc = sqliteErrorFromPosixError(tErrno,
2507 setLockFlag ? SQLITE_IOERR_LOCK : SQLITE_IOERR_UNLOCK);
aswiftaebf4132008-11-21 00:10:35 +00002508#endif /* SQLITE_IGNORE_AFP_LOCK_ERRORS */
aswift5b1a2562008-08-22 00:22:35 +00002509 if( IS_LOCK_ERROR(rc) ){
2510 pFile->lastErrno = tErrno;
2511 }
2512 return rc;
drhbfe66312006-10-03 17:40:40 +00002513 } else {
aswift5b1a2562008-08-22 00:22:35 +00002514 return SQLITE_OK;
drhbfe66312006-10-03 17:40:40 +00002515 }
2516}
2517
drh6b9d6dd2008-12-03 19:34:47 +00002518/*
2519** This routine checks if there is a RESERVED lock held on the specified
2520** file by this or any other process. If such a lock is held, set *pResOut
2521** to a non-zero value otherwise *pResOut is set to zero. The return value
2522** is set to SQLITE_OK unless an I/O error occurs during lock checking.
2523*/
danielk1977e339d652008-06-28 11:23:00 +00002524static int afpCheckReservedLock(sqlite3_file *id, int *pResOut){
aswift5b1a2562008-08-22 00:22:35 +00002525 int rc = SQLITE_OK;
2526 int reserved = 0;
drhbfe66312006-10-03 17:40:40 +00002527 unixFile *pFile = (unixFile*)id;
2528
aswift5b1a2562008-08-22 00:22:35 +00002529 SimulateIOError( return SQLITE_IOERR_CHECKRESERVEDLOCK; );
2530
2531 assert( pFile );
drhbfe66312006-10-03 17:40:40 +00002532 afpLockingContext *context = (afpLockingContext *) pFile->lockingContext;
drh7ed97b92010-01-20 13:07:21 +00002533 if( context->reserved ){
2534 *pResOut = 1;
2535 return SQLITE_OK;
2536 }
drh8af6c222010-05-14 12:43:01 +00002537 unixEnterMutex(); /* Because pFile->pInode is shared across threads */
drhbfe66312006-10-03 17:40:40 +00002538
2539 /* Check if a thread in this process holds such a lock */
drh8af6c222010-05-14 12:43:01 +00002540 if( pFile->pInode->eFileLock>SHARED_LOCK ){
aswift5b1a2562008-08-22 00:22:35 +00002541 reserved = 1;
drhbfe66312006-10-03 17:40:40 +00002542 }
2543
2544 /* Otherwise see if some other process holds it.
2545 */
aswift5b1a2562008-08-22 00:22:35 +00002546 if( !reserved ){
2547 /* lock the RESERVED byte */
drh6b9d6dd2008-12-03 19:34:47 +00002548 int lrc = afpSetLock(context->dbPath, pFile, RESERVED_BYTE, 1,1);
aswift5b1a2562008-08-22 00:22:35 +00002549 if( SQLITE_OK==lrc ){
drhbfe66312006-10-03 17:40:40 +00002550 /* if we succeeded in taking the reserved lock, unlock it to restore
2551 ** the original state */
drh6b9d6dd2008-12-03 19:34:47 +00002552 lrc = afpSetLock(context->dbPath, pFile, RESERVED_BYTE, 1, 0);
aswift5b1a2562008-08-22 00:22:35 +00002553 } else {
2554 /* if we failed to get the lock then someone else must have it */
2555 reserved = 1;
2556 }
2557 if( IS_LOCK_ERROR(lrc) ){
2558 rc=lrc;
drhbfe66312006-10-03 17:40:40 +00002559 }
2560 }
drhbfe66312006-10-03 17:40:40 +00002561
drh7ed97b92010-01-20 13:07:21 +00002562 unixLeaveMutex();
drh308c2a52010-05-14 11:30:18 +00002563 OSTRACE(("TEST WR-LOCK %d %d %d (afp)\n", pFile->h, rc, reserved));
aswift5b1a2562008-08-22 00:22:35 +00002564
2565 *pResOut = reserved;
2566 return rc;
drhbfe66312006-10-03 17:40:40 +00002567}
2568
drh6b9d6dd2008-12-03 19:34:47 +00002569/*
drh308c2a52010-05-14 11:30:18 +00002570** Lock the file with the lock specified by parameter eFileLock - one
drh6b9d6dd2008-12-03 19:34:47 +00002571** of the following:
2572**
2573** (1) SHARED_LOCK
2574** (2) RESERVED_LOCK
2575** (3) PENDING_LOCK
2576** (4) EXCLUSIVE_LOCK
2577**
2578** Sometimes when requesting one lock state, additional lock states
2579** are inserted in between. The locking might fail on one of the later
2580** transitions leaving the lock state different from what it started but
2581** still short of its goal. The following chart shows the allowed
2582** transitions and the inserted intermediate states:
2583**
2584** UNLOCKED -> SHARED
2585** SHARED -> RESERVED
2586** SHARED -> (PENDING) -> EXCLUSIVE
2587** RESERVED -> (PENDING) -> EXCLUSIVE
2588** PENDING -> EXCLUSIVE
2589**
2590** This routine will only increase a lock. Use the sqlite3OsUnlock()
2591** routine to lower a locking level.
2592*/
drh308c2a52010-05-14 11:30:18 +00002593static int afpLock(sqlite3_file *id, int eFileLock){
drhbfe66312006-10-03 17:40:40 +00002594 int rc = SQLITE_OK;
2595 unixFile *pFile = (unixFile*)id;
drhd91c68f2010-05-14 14:52:25 +00002596 unixInodeInfo *pInode = pFile->pInode;
drhbfe66312006-10-03 17:40:40 +00002597 afpLockingContext *context = (afpLockingContext *) pFile->lockingContext;
drhbfe66312006-10-03 17:40:40 +00002598
2599 assert( pFile );
drh308c2a52010-05-14 11:30:18 +00002600 OSTRACE(("LOCK %d %s was %s(%s,%d) pid=%d (afp)\n", pFile->h,
2601 azFileLock(eFileLock), azFileLock(pFile->eFileLock),
drh8af6c222010-05-14 12:43:01 +00002602 azFileLock(pInode->eFileLock), pInode->nShared , getpid()));
drh339eb0b2008-03-07 15:34:11 +00002603
drhbfe66312006-10-03 17:40:40 +00002604 /* If there is already a lock of this type or more restrictive on the
drh339eb0b2008-03-07 15:34:11 +00002605 ** unixFile, do nothing. Don't use the afp_end_lock: exit path, as
drh6c7d5c52008-11-21 20:32:33 +00002606 ** unixEnterMutex() hasn't been called yet.
drh339eb0b2008-03-07 15:34:11 +00002607 */
drh308c2a52010-05-14 11:30:18 +00002608 if( pFile->eFileLock>=eFileLock ){
2609 OSTRACE(("LOCK %d %s ok (already held) (afp)\n", pFile->h,
2610 azFileLock(eFileLock)));
drhbfe66312006-10-03 17:40:40 +00002611 return SQLITE_OK;
2612 }
2613
2614 /* Make sure the locking sequence is correct
drh7ed97b92010-01-20 13:07:21 +00002615 ** (1) We never move from unlocked to anything higher than shared lock.
2616 ** (2) SQLite never explicitly requests a pendig lock.
2617 ** (3) A shared lock is always held when a reserve lock is requested.
drh339eb0b2008-03-07 15:34:11 +00002618 */
drh308c2a52010-05-14 11:30:18 +00002619 assert( pFile->eFileLock!=NO_LOCK || eFileLock==SHARED_LOCK );
2620 assert( eFileLock!=PENDING_LOCK );
2621 assert( eFileLock!=RESERVED_LOCK || pFile->eFileLock==SHARED_LOCK );
drhbfe66312006-10-03 17:40:40 +00002622
drh8af6c222010-05-14 12:43:01 +00002623 /* This mutex is needed because pFile->pInode is shared across threads
drh339eb0b2008-03-07 15:34:11 +00002624 */
drh6c7d5c52008-11-21 20:32:33 +00002625 unixEnterMutex();
drh8af6c222010-05-14 12:43:01 +00002626 pInode = pFile->pInode;
drh7ed97b92010-01-20 13:07:21 +00002627
2628 /* If some thread using this PID has a lock via a different unixFile*
2629 ** handle that precludes the requested lock, return BUSY.
2630 */
drh8af6c222010-05-14 12:43:01 +00002631 if( (pFile->eFileLock!=pInode->eFileLock &&
2632 (pInode->eFileLock>=PENDING_LOCK || eFileLock>SHARED_LOCK))
drh7ed97b92010-01-20 13:07:21 +00002633 ){
2634 rc = SQLITE_BUSY;
2635 goto afp_end_lock;
2636 }
2637
2638 /* If a SHARED lock is requested, and some thread using this PID already
2639 ** has a SHARED or RESERVED lock, then increment reference counts and
2640 ** return SQLITE_OK.
2641 */
drh308c2a52010-05-14 11:30:18 +00002642 if( eFileLock==SHARED_LOCK &&
drh8af6c222010-05-14 12:43:01 +00002643 (pInode->eFileLock==SHARED_LOCK || pInode->eFileLock==RESERVED_LOCK) ){
drh308c2a52010-05-14 11:30:18 +00002644 assert( eFileLock==SHARED_LOCK );
2645 assert( pFile->eFileLock==0 );
drh8af6c222010-05-14 12:43:01 +00002646 assert( pInode->nShared>0 );
drh308c2a52010-05-14 11:30:18 +00002647 pFile->eFileLock = SHARED_LOCK;
drh8af6c222010-05-14 12:43:01 +00002648 pInode->nShared++;
2649 pInode->nLock++;
drh7ed97b92010-01-20 13:07:21 +00002650 goto afp_end_lock;
2651 }
drhbfe66312006-10-03 17:40:40 +00002652
2653 /* A PENDING lock is needed before acquiring a SHARED lock and before
drh339eb0b2008-03-07 15:34:11 +00002654 ** acquiring an EXCLUSIVE lock. For the SHARED lock, the PENDING will
2655 ** be released.
2656 */
drh308c2a52010-05-14 11:30:18 +00002657 if( eFileLock==SHARED_LOCK
2658 || (eFileLock==EXCLUSIVE_LOCK && pFile->eFileLock<PENDING_LOCK)
drh339eb0b2008-03-07 15:34:11 +00002659 ){
2660 int failed;
drh6b9d6dd2008-12-03 19:34:47 +00002661 failed = afpSetLock(context->dbPath, pFile, PENDING_BYTE, 1, 1);
drhbfe66312006-10-03 17:40:40 +00002662 if (failed) {
aswift5b1a2562008-08-22 00:22:35 +00002663 rc = failed;
drhbfe66312006-10-03 17:40:40 +00002664 goto afp_end_lock;
2665 }
2666 }
2667
2668 /* If control gets to this point, then actually go ahead and make
drh339eb0b2008-03-07 15:34:11 +00002669 ** operating system calls for the specified lock.
2670 */
drh308c2a52010-05-14 11:30:18 +00002671 if( eFileLock==SHARED_LOCK ){
drh7ed97b92010-01-20 13:07:21 +00002672 int lrc1, lrc2, lrc1Errno;
2673 long lk, mask;
drhbfe66312006-10-03 17:40:40 +00002674
drh8af6c222010-05-14 12:43:01 +00002675 assert( pInode->nShared==0 );
2676 assert( pInode->eFileLock==0 );
drh7ed97b92010-01-20 13:07:21 +00002677
2678 mask = (sizeof(long)==8) ? LARGEST_INT64 : 0x7fffffff;
aswift5b1a2562008-08-22 00:22:35 +00002679 /* Now get the read-lock SHARED_LOCK */
drhbfe66312006-10-03 17:40:40 +00002680 /* note that the quality of the randomness doesn't matter that much */
2681 lk = random();
drh8af6c222010-05-14 12:43:01 +00002682 pInode->sharedByte = (lk & mask)%(SHARED_SIZE - 1);
drh6b9d6dd2008-12-03 19:34:47 +00002683 lrc1 = afpSetLock(context->dbPath, pFile,
drh8af6c222010-05-14 12:43:01 +00002684 SHARED_FIRST+pInode->sharedByte, 1, 1);
aswift5b1a2562008-08-22 00:22:35 +00002685 if( IS_LOCK_ERROR(lrc1) ){
2686 lrc1Errno = pFile->lastErrno;
drhbfe66312006-10-03 17:40:40 +00002687 }
aswift5b1a2562008-08-22 00:22:35 +00002688 /* Drop the temporary PENDING lock */
drh6b9d6dd2008-12-03 19:34:47 +00002689 lrc2 = afpSetLock(context->dbPath, pFile, PENDING_BYTE, 1, 0);
drhbfe66312006-10-03 17:40:40 +00002690
aswift5b1a2562008-08-22 00:22:35 +00002691 if( IS_LOCK_ERROR(lrc1) ) {
2692 pFile->lastErrno = lrc1Errno;
2693 rc = lrc1;
2694 goto afp_end_lock;
2695 } else if( IS_LOCK_ERROR(lrc2) ){
2696 rc = lrc2;
2697 goto afp_end_lock;
2698 } else if( lrc1 != SQLITE_OK ) {
2699 rc = lrc1;
drhbfe66312006-10-03 17:40:40 +00002700 } else {
drh308c2a52010-05-14 11:30:18 +00002701 pFile->eFileLock = SHARED_LOCK;
drh8af6c222010-05-14 12:43:01 +00002702 pInode->nLock++;
2703 pInode->nShared = 1;
drhbfe66312006-10-03 17:40:40 +00002704 }
drh8af6c222010-05-14 12:43:01 +00002705 }else if( eFileLock==EXCLUSIVE_LOCK && pInode->nShared>1 ){
drh7ed97b92010-01-20 13:07:21 +00002706 /* We are trying for an exclusive lock but another thread in this
2707 ** same process is still holding a shared lock. */
2708 rc = SQLITE_BUSY;
drhbfe66312006-10-03 17:40:40 +00002709 }else{
2710 /* The request was for a RESERVED or EXCLUSIVE lock. It is
2711 ** assumed that there is a SHARED or greater lock on the file
2712 ** already.
2713 */
2714 int failed = 0;
drh308c2a52010-05-14 11:30:18 +00002715 assert( 0!=pFile->eFileLock );
2716 if (eFileLock >= RESERVED_LOCK && pFile->eFileLock < RESERVED_LOCK) {
drhbfe66312006-10-03 17:40:40 +00002717 /* Acquire a RESERVED lock */
drh6b9d6dd2008-12-03 19:34:47 +00002718 failed = afpSetLock(context->dbPath, pFile, RESERVED_BYTE, 1,1);
drh7ed97b92010-01-20 13:07:21 +00002719 if( !failed ){
2720 context->reserved = 1;
2721 }
drhbfe66312006-10-03 17:40:40 +00002722 }
drh308c2a52010-05-14 11:30:18 +00002723 if (!failed && eFileLock == EXCLUSIVE_LOCK) {
drhbfe66312006-10-03 17:40:40 +00002724 /* Acquire an EXCLUSIVE lock */
2725
2726 /* Remove the shared lock before trying the range. we'll need to
danielk1977e339d652008-06-28 11:23:00 +00002727 ** reestablish the shared lock if we can't get the afpUnlock
drhbfe66312006-10-03 17:40:40 +00002728 */
drh6b9d6dd2008-12-03 19:34:47 +00002729 if( !(failed = afpSetLock(context->dbPath, pFile, SHARED_FIRST +
drh8af6c222010-05-14 12:43:01 +00002730 pInode->sharedByte, 1, 0)) ){
aswiftaebf4132008-11-21 00:10:35 +00002731 int failed2 = SQLITE_OK;
drhbfe66312006-10-03 17:40:40 +00002732 /* now attemmpt to get the exclusive lock range */
drh6b9d6dd2008-12-03 19:34:47 +00002733 failed = afpSetLock(context->dbPath, pFile, SHARED_FIRST,
drhbfe66312006-10-03 17:40:40 +00002734 SHARED_SIZE, 1);
drh6b9d6dd2008-12-03 19:34:47 +00002735 if( failed && (failed2 = afpSetLock(context->dbPath, pFile,
drh8af6c222010-05-14 12:43:01 +00002736 SHARED_FIRST + pInode->sharedByte, 1, 1)) ){
aswiftaebf4132008-11-21 00:10:35 +00002737 /* Can't reestablish the shared lock. Sqlite can't deal, this is
2738 ** a critical I/O error
2739 */
2740 rc = ((failed & SQLITE_IOERR) == SQLITE_IOERR) ? failed2 :
2741 SQLITE_IOERR_LOCK;
2742 goto afp_end_lock;
2743 }
2744 }else{
aswift5b1a2562008-08-22 00:22:35 +00002745 rc = failed;
drhbfe66312006-10-03 17:40:40 +00002746 }
2747 }
aswift5b1a2562008-08-22 00:22:35 +00002748 if( failed ){
2749 rc = failed;
drhbfe66312006-10-03 17:40:40 +00002750 }
2751 }
2752
2753 if( rc==SQLITE_OK ){
drh308c2a52010-05-14 11:30:18 +00002754 pFile->eFileLock = eFileLock;
drh8af6c222010-05-14 12:43:01 +00002755 pInode->eFileLock = eFileLock;
drh308c2a52010-05-14 11:30:18 +00002756 }else if( eFileLock==EXCLUSIVE_LOCK ){
2757 pFile->eFileLock = PENDING_LOCK;
drh8af6c222010-05-14 12:43:01 +00002758 pInode->eFileLock = PENDING_LOCK;
drhbfe66312006-10-03 17:40:40 +00002759 }
2760
2761afp_end_lock:
drh6c7d5c52008-11-21 20:32:33 +00002762 unixLeaveMutex();
drh308c2a52010-05-14 11:30:18 +00002763 OSTRACE(("LOCK %d %s %s (afp)\n", pFile->h, azFileLock(eFileLock),
2764 rc==SQLITE_OK ? "ok" : "failed"));
drhbfe66312006-10-03 17:40:40 +00002765 return rc;
2766}
2767
2768/*
drh308c2a52010-05-14 11:30:18 +00002769** Lower the locking level on file descriptor pFile to eFileLock. eFileLock
drh339eb0b2008-03-07 15:34:11 +00002770** must be either NO_LOCK or SHARED_LOCK.
2771**
2772** If the locking level of the file descriptor is already at or below
2773** the requested locking level, this routine is a no-op.
2774*/
drh308c2a52010-05-14 11:30:18 +00002775static int afpUnlock(sqlite3_file *id, int eFileLock) {
drhbfe66312006-10-03 17:40:40 +00002776 int rc = SQLITE_OK;
2777 unixFile *pFile = (unixFile*)id;
drhd91c68f2010-05-14 14:52:25 +00002778 unixInodeInfo *pInode;
drh7ed97b92010-01-20 13:07:21 +00002779 afpLockingContext *context = (afpLockingContext *) pFile->lockingContext;
2780 int skipShared = 0;
2781#ifdef SQLITE_TEST
2782 int h = pFile->h;
2783#endif
drhbfe66312006-10-03 17:40:40 +00002784
2785 assert( pFile );
drh308c2a52010-05-14 11:30:18 +00002786 OSTRACE(("UNLOCK %d %d was %d(%d,%d) pid=%d (afp)\n", pFile->h, eFileLock,
drh8af6c222010-05-14 12:43:01 +00002787 pFile->eFileLock, pFile->pInode->eFileLock, pFile->pInode->nShared,
drh308c2a52010-05-14 11:30:18 +00002788 getpid()));
aswift5b1a2562008-08-22 00:22:35 +00002789
drh308c2a52010-05-14 11:30:18 +00002790 assert( eFileLock<=SHARED_LOCK );
2791 if( pFile->eFileLock<=eFileLock ){
drhbfe66312006-10-03 17:40:40 +00002792 return SQLITE_OK;
2793 }
drh6c7d5c52008-11-21 20:32:33 +00002794 unixEnterMutex();
drh8af6c222010-05-14 12:43:01 +00002795 pInode = pFile->pInode;
2796 assert( pInode->nShared!=0 );
drh308c2a52010-05-14 11:30:18 +00002797 if( pFile->eFileLock>SHARED_LOCK ){
drh8af6c222010-05-14 12:43:01 +00002798 assert( pInode->eFileLock==pFile->eFileLock );
drh7ed97b92010-01-20 13:07:21 +00002799 SimulateIOErrorBenign(1);
2800 SimulateIOError( h=(-1) )
2801 SimulateIOErrorBenign(0);
2802
2803#ifndef NDEBUG
2804 /* When reducing a lock such that other processes can start
2805 ** reading the database file again, make sure that the
2806 ** transaction counter was updated if any part of the database
2807 ** file changed. If the transaction counter is not updated,
2808 ** other connections to the same file might not realize that
2809 ** the file has changed and hence might not know to flush their
2810 ** cache. The use of a stale cache can lead to database corruption.
2811 */
2812 assert( pFile->inNormalWrite==0
2813 || pFile->dbUpdate==0
2814 || pFile->transCntrChng==1 );
2815 pFile->inNormalWrite = 0;
2816#endif
aswiftaebf4132008-11-21 00:10:35 +00002817
drh308c2a52010-05-14 11:30:18 +00002818 if( pFile->eFileLock==EXCLUSIVE_LOCK ){
drh7ed97b92010-01-20 13:07:21 +00002819 rc = afpSetLock(context->dbPath, pFile, SHARED_FIRST, SHARED_SIZE, 0);
drh8af6c222010-05-14 12:43:01 +00002820 if( rc==SQLITE_OK && (eFileLock==SHARED_LOCK || pInode->nShared>1) ){
aswiftaebf4132008-11-21 00:10:35 +00002821 /* only re-establish the shared lock if necessary */
drh8af6c222010-05-14 12:43:01 +00002822 int sharedLockByte = SHARED_FIRST+pInode->sharedByte;
drh7ed97b92010-01-20 13:07:21 +00002823 rc = afpSetLock(context->dbPath, pFile, sharedLockByte, 1, 1);
2824 } else {
2825 skipShared = 1;
aswiftaebf4132008-11-21 00:10:35 +00002826 }
2827 }
drh308c2a52010-05-14 11:30:18 +00002828 if( rc==SQLITE_OK && pFile->eFileLock>=PENDING_LOCK ){
drh7ed97b92010-01-20 13:07:21 +00002829 rc = afpSetLock(context->dbPath, pFile, PENDING_BYTE, 1, 0);
aswiftaebf4132008-11-21 00:10:35 +00002830 }
drh308c2a52010-05-14 11:30:18 +00002831 if( rc==SQLITE_OK && pFile->eFileLock>=RESERVED_LOCK && context->reserved ){
drh7ed97b92010-01-20 13:07:21 +00002832 rc = afpSetLock(context->dbPath, pFile, RESERVED_BYTE, 1, 0);
2833 if( !rc ){
2834 context->reserved = 0;
2835 }
aswiftaebf4132008-11-21 00:10:35 +00002836 }
drh8af6c222010-05-14 12:43:01 +00002837 if( rc==SQLITE_OK && (eFileLock==SHARED_LOCK || pInode->nShared>1)){
2838 pInode->eFileLock = SHARED_LOCK;
drh7ed97b92010-01-20 13:07:21 +00002839 }
aswiftaebf4132008-11-21 00:10:35 +00002840 }
drh308c2a52010-05-14 11:30:18 +00002841 if( rc==SQLITE_OK && eFileLock==NO_LOCK ){
drhbfe66312006-10-03 17:40:40 +00002842
drh7ed97b92010-01-20 13:07:21 +00002843 /* Decrement the shared lock counter. Release the lock using an
2844 ** OS call only when all threads in this same process have released
2845 ** the lock.
2846 */
drh8af6c222010-05-14 12:43:01 +00002847 unsigned long long sharedLockByte = SHARED_FIRST+pInode->sharedByte;
2848 pInode->nShared--;
2849 if( pInode->nShared==0 ){
drh7ed97b92010-01-20 13:07:21 +00002850 SimulateIOErrorBenign(1);
2851 SimulateIOError( h=(-1) )
2852 SimulateIOErrorBenign(0);
2853 if( !skipShared ){
2854 rc = afpSetLock(context->dbPath, pFile, sharedLockByte, 1, 0);
2855 }
2856 if( !rc ){
drh8af6c222010-05-14 12:43:01 +00002857 pInode->eFileLock = NO_LOCK;
drh308c2a52010-05-14 11:30:18 +00002858 pFile->eFileLock = NO_LOCK;
drh7ed97b92010-01-20 13:07:21 +00002859 }
2860 }
2861 if( rc==SQLITE_OK ){
drh8af6c222010-05-14 12:43:01 +00002862 pInode->nLock--;
2863 assert( pInode->nLock>=0 );
2864 if( pInode->nLock==0 ){
drh0e9365c2011-03-02 02:08:13 +00002865 closePendingFds(pFile);
drhbfe66312006-10-03 17:40:40 +00002866 }
2867 }
drhbfe66312006-10-03 17:40:40 +00002868 }
drh7ed97b92010-01-20 13:07:21 +00002869
drh6c7d5c52008-11-21 20:32:33 +00002870 unixLeaveMutex();
drh308c2a52010-05-14 11:30:18 +00002871 if( rc==SQLITE_OK ) pFile->eFileLock = eFileLock;
drhbfe66312006-10-03 17:40:40 +00002872 return rc;
2873}
2874
2875/*
drh339eb0b2008-03-07 15:34:11 +00002876** Close a file & cleanup AFP specific locking context
2877*/
danielk1977e339d652008-06-28 11:23:00 +00002878static int afpClose(sqlite3_file *id) {
drh7ed97b92010-01-20 13:07:21 +00002879 int rc = SQLITE_OK;
danielk1977e339d652008-06-28 11:23:00 +00002880 if( id ){
2881 unixFile *pFile = (unixFile*)id;
2882 afpUnlock(id, NO_LOCK);
drh6c7d5c52008-11-21 20:32:33 +00002883 unixEnterMutex();
drh8af6c222010-05-14 12:43:01 +00002884 if( pFile->pInode && pFile->pInode->nLock ){
aswiftaebf4132008-11-21 00:10:35 +00002885 /* If there are outstanding locks, do not actually close the file just
drh734c9862008-11-28 15:37:20 +00002886 ** yet because that would clear those locks. Instead, add the file
drh8af6c222010-05-14 12:43:01 +00002887 ** descriptor to pInode->aPending. It will be automatically closed when
drh734c9862008-11-28 15:37:20 +00002888 ** the last lock is cleared.
2889 */
dan08da86a2009-08-21 17:18:03 +00002890 setPendingFd(pFile);
aswiftaebf4132008-11-21 00:10:35 +00002891 }
danb0ac3e32010-06-16 10:55:42 +00002892 releaseInodeInfo(pFile);
danielk1977e339d652008-06-28 11:23:00 +00002893 sqlite3_free(pFile->lockingContext);
drh7ed97b92010-01-20 13:07:21 +00002894 rc = closeUnixFile(id);
drh6c7d5c52008-11-21 20:32:33 +00002895 unixLeaveMutex();
danielk1977e339d652008-06-28 11:23:00 +00002896 }
drh7ed97b92010-01-20 13:07:21 +00002897 return rc;
drhbfe66312006-10-03 17:40:40 +00002898}
2899
drhd2cb50b2009-01-09 21:41:17 +00002900#endif /* defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE */
drh734c9862008-11-28 15:37:20 +00002901/*
2902** The code above is the AFP lock implementation. The code is specific
2903** to MacOSX and does not work on other unix platforms. No alternative
2904** is available. If you don't compile for a mac, then the "unix-afp"
2905** VFS is not available.
2906**
2907********************* End of the AFP lock implementation **********************
2908******************************************************************************/
drhbfe66312006-10-03 17:40:40 +00002909
drh7ed97b92010-01-20 13:07:21 +00002910/******************************************************************************
2911*************************** Begin NFS Locking ********************************/
2912
2913#if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE
2914/*
drh308c2a52010-05-14 11:30:18 +00002915 ** Lower the locking level on file descriptor pFile to eFileLock. eFileLock
drh7ed97b92010-01-20 13:07:21 +00002916 ** must be either NO_LOCK or SHARED_LOCK.
2917 **
2918 ** If the locking level of the file descriptor is already at or below
2919 ** the requested locking level, this routine is a no-op.
2920 */
drh308c2a52010-05-14 11:30:18 +00002921static int nfsUnlock(sqlite3_file *id, int eFileLock){
drha7e61d82011-03-12 17:02:57 +00002922 return posixUnlock(id, eFileLock, 1);
drh7ed97b92010-01-20 13:07:21 +00002923}
2924
2925#endif /* defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE */
2926/*
2927** The code above is the NFS lock implementation. The code is specific
2928** to MacOSX and does not work on other unix platforms. No alternative
2929** is available.
2930**
2931********************* End of the NFS lock implementation **********************
2932******************************************************************************/
drh734c9862008-11-28 15:37:20 +00002933
2934/******************************************************************************
2935**************** Non-locking sqlite3_file methods *****************************
2936**
2937** The next division contains implementations for all methods of the
2938** sqlite3_file object other than the locking methods. The locking
2939** methods were defined in divisions above (one locking method per
2940** division). Those methods that are common to all locking modes
2941** are gather together into this division.
2942*/
drhbfe66312006-10-03 17:40:40 +00002943
2944/*
drh734c9862008-11-28 15:37:20 +00002945** Seek to the offset passed as the second argument, then read cnt
2946** bytes into pBuf. Return the number of bytes actually read.
2947**
2948** NB: If you define USE_PREAD or USE_PREAD64, then it might also
2949** be necessary to define _XOPEN_SOURCE to be 500. This varies from
2950** one system to another. Since SQLite does not define USE_PREAD
2951** any any form by default, we will not attempt to define _XOPEN_SOURCE.
2952** See tickets #2741 and #2681.
2953**
2954** To avoid stomping the errno value on a failed read the lastErrno value
2955** is set before returning.
drh339eb0b2008-03-07 15:34:11 +00002956*/
drh734c9862008-11-28 15:37:20 +00002957static int seekAndRead(unixFile *id, sqlite3_int64 offset, void *pBuf, int cnt){
2958 int got;
drh7ed97b92010-01-20 13:07:21 +00002959#if (!defined(USE_PREAD) && !defined(USE_PREAD64))
drh734c9862008-11-28 15:37:20 +00002960 i64 newOffset;
drh7ed97b92010-01-20 13:07:21 +00002961#endif
drh734c9862008-11-28 15:37:20 +00002962 TIMER_START;
2963#if defined(USE_PREAD)
drhe562be52011-03-02 18:01:10 +00002964 do{ got = osPread(id->h, pBuf, cnt, offset); }while( got<0 && errno==EINTR );
drh734c9862008-11-28 15:37:20 +00002965 SimulateIOError( got = -1 );
2966#elif defined(USE_PREAD64)
drhe562be52011-03-02 18:01:10 +00002967 do{ got = osPread64(id->h, pBuf, cnt, offset); }while( got<0 && errno==EINTR);
drh734c9862008-11-28 15:37:20 +00002968 SimulateIOError( got = -1 );
2969#else
2970 newOffset = lseek(id->h, offset, SEEK_SET);
2971 SimulateIOError( newOffset-- );
2972 if( newOffset!=offset ){
2973 if( newOffset == -1 ){
2974 ((unixFile*)id)->lastErrno = errno;
2975 }else{
2976 ((unixFile*)id)->lastErrno = 0;
2977 }
2978 return -1;
2979 }
drhe562be52011-03-02 18:01:10 +00002980 do{ got = osRead(id->h, pBuf, cnt); }while( got<0 && errno==EINTR );
drh734c9862008-11-28 15:37:20 +00002981#endif
2982 TIMER_END;
2983 if( got<0 ){
2984 ((unixFile*)id)->lastErrno = errno;
2985 }
drh308c2a52010-05-14 11:30:18 +00002986 OSTRACE(("READ %-3d %5d %7lld %llu\n", id->h, got, offset, TIMER_ELAPSED));
drh734c9862008-11-28 15:37:20 +00002987 return got;
drhbfe66312006-10-03 17:40:40 +00002988}
2989
2990/*
drh734c9862008-11-28 15:37:20 +00002991** Read data from a file into a buffer. Return SQLITE_OK if all
2992** bytes were read successfully and SQLITE_IOERR if anything goes
2993** wrong.
drh339eb0b2008-03-07 15:34:11 +00002994*/
drh734c9862008-11-28 15:37:20 +00002995static int unixRead(
2996 sqlite3_file *id,
2997 void *pBuf,
2998 int amt,
2999 sqlite3_int64 offset
3000){
dan08da86a2009-08-21 17:18:03 +00003001 unixFile *pFile = (unixFile *)id;
drh734c9862008-11-28 15:37:20 +00003002 int got;
3003 assert( id );
drh08c6d442009-02-09 17:34:07 +00003004
dan08da86a2009-08-21 17:18:03 +00003005 /* If this is a database file (not a journal, master-journal or temp
3006 ** file), the bytes in the locking range should never be read or written. */
dan7c246102010-04-12 19:00:29 +00003007#if 0
dane946c392009-08-22 11:39:46 +00003008 assert( pFile->pUnused==0
dan08da86a2009-08-21 17:18:03 +00003009 || offset>=PENDING_BYTE+512
3010 || offset+amt<=PENDING_BYTE
3011 );
dan7c246102010-04-12 19:00:29 +00003012#endif
drh08c6d442009-02-09 17:34:07 +00003013
dan08da86a2009-08-21 17:18:03 +00003014 got = seekAndRead(pFile, offset, pBuf, amt);
drh734c9862008-11-28 15:37:20 +00003015 if( got==amt ){
3016 return SQLITE_OK;
3017 }else if( got<0 ){
3018 /* lastErrno set by seekAndRead */
3019 return SQLITE_IOERR_READ;
3020 }else{
dan08da86a2009-08-21 17:18:03 +00003021 pFile->lastErrno = 0; /* not a system error */
drh734c9862008-11-28 15:37:20 +00003022 /* Unread parts of the buffer must be zero-filled */
3023 memset(&((char*)pBuf)[got], 0, amt-got);
3024 return SQLITE_IOERR_SHORT_READ;
3025 }
3026}
3027
3028/*
3029** Seek to the offset in id->offset then read cnt bytes into pBuf.
3030** Return the number of bytes actually read. Update the offset.
3031**
3032** To avoid stomping the errno value on a failed write the lastErrno value
3033** is set before returning.
3034*/
3035static int seekAndWrite(unixFile *id, i64 offset, const void *pBuf, int cnt){
3036 int got;
drh7ed97b92010-01-20 13:07:21 +00003037#if (!defined(USE_PREAD) && !defined(USE_PREAD64))
drh734c9862008-11-28 15:37:20 +00003038 i64 newOffset;
drh7ed97b92010-01-20 13:07:21 +00003039#endif
drh734c9862008-11-28 15:37:20 +00003040 TIMER_START;
3041#if defined(USE_PREAD)
drhe562be52011-03-02 18:01:10 +00003042 do{ got = osPwrite(id->h, pBuf, cnt, offset); }while( got<0 && errno==EINTR );
drh734c9862008-11-28 15:37:20 +00003043#elif defined(USE_PREAD64)
drhe562be52011-03-02 18:01:10 +00003044 do{ got = osPwrite64(id->h, pBuf, cnt, offset);}while( got<0 && errno==EINTR);
drh734c9862008-11-28 15:37:20 +00003045#else
drhbd1e50c2011-08-19 14:54:12 +00003046 do{
3047 newOffset = lseek(id->h, offset, SEEK_SET);
3048 SimulateIOError( newOffset-- );
3049 if( newOffset!=offset ){
3050 if( newOffset == -1 ){
3051 ((unixFile*)id)->lastErrno = errno;
3052 }else{
3053 ((unixFile*)id)->lastErrno = 0;
3054 }
3055 return -1;
drh734c9862008-11-28 15:37:20 +00003056 }
drhbd1e50c2011-08-19 14:54:12 +00003057 got = osWrite(id->h, pBuf, cnt);
3058 }while( got<0 && errno==EINTR );
drh734c9862008-11-28 15:37:20 +00003059#endif
3060 TIMER_END;
3061 if( got<0 ){
3062 ((unixFile*)id)->lastErrno = errno;
3063 }
3064
drh308c2a52010-05-14 11:30:18 +00003065 OSTRACE(("WRITE %-3d %5d %7lld %llu\n", id->h, got, offset, TIMER_ELAPSED));
drh734c9862008-11-28 15:37:20 +00003066 return got;
3067}
3068
3069
3070/*
3071** Write data from a buffer into a file. Return SQLITE_OK on success
3072** or some other error code on failure.
3073*/
3074static int unixWrite(
3075 sqlite3_file *id,
3076 const void *pBuf,
3077 int amt,
3078 sqlite3_int64 offset
3079){
dan08da86a2009-08-21 17:18:03 +00003080 unixFile *pFile = (unixFile*)id;
drh734c9862008-11-28 15:37:20 +00003081 int wrote = 0;
3082 assert( id );
3083 assert( amt>0 );
drh8f941bc2009-01-14 23:03:40 +00003084
dan08da86a2009-08-21 17:18:03 +00003085 /* If this is a database file (not a journal, master-journal or temp
3086 ** file), the bytes in the locking range should never be read or written. */
dan7c246102010-04-12 19:00:29 +00003087#if 0
dane946c392009-08-22 11:39:46 +00003088 assert( pFile->pUnused==0
dan08da86a2009-08-21 17:18:03 +00003089 || offset>=PENDING_BYTE+512
3090 || offset+amt<=PENDING_BYTE
3091 );
dan7c246102010-04-12 19:00:29 +00003092#endif
drh08c6d442009-02-09 17:34:07 +00003093
drh8f941bc2009-01-14 23:03:40 +00003094#ifndef NDEBUG
3095 /* If we are doing a normal write to a database file (as opposed to
3096 ** doing a hot-journal rollback or a write to some file other than a
3097 ** normal database file) then record the fact that the database
3098 ** has changed. If the transaction counter is modified, record that
3099 ** fact too.
3100 */
dan08da86a2009-08-21 17:18:03 +00003101 if( pFile->inNormalWrite ){
drh8f941bc2009-01-14 23:03:40 +00003102 pFile->dbUpdate = 1; /* The database has been modified */
3103 if( offset<=24 && offset+amt>=27 ){
drha6d90f02009-01-16 23:47:42 +00003104 int rc;
drh8f941bc2009-01-14 23:03:40 +00003105 char oldCntr[4];
3106 SimulateIOErrorBenign(1);
drha6d90f02009-01-16 23:47:42 +00003107 rc = seekAndRead(pFile, 24, oldCntr, 4);
drh8f941bc2009-01-14 23:03:40 +00003108 SimulateIOErrorBenign(0);
drha6d90f02009-01-16 23:47:42 +00003109 if( rc!=4 || memcmp(oldCntr, &((char*)pBuf)[24-offset], 4)!=0 ){
drh8f941bc2009-01-14 23:03:40 +00003110 pFile->transCntrChng = 1; /* The transaction counter has changed */
3111 }
3112 }
3113 }
3114#endif
3115
dan08da86a2009-08-21 17:18:03 +00003116 while( amt>0 && (wrote = seekAndWrite(pFile, offset, pBuf, amt))>0 ){
drh734c9862008-11-28 15:37:20 +00003117 amt -= wrote;
3118 offset += wrote;
3119 pBuf = &((char*)pBuf)[wrote];
3120 }
3121 SimulateIOError(( wrote=(-1), amt=1 ));
3122 SimulateDiskfullError(( wrote=0, amt=1 ));
dan6e09d692010-07-27 18:34:15 +00003123
drh734c9862008-11-28 15:37:20 +00003124 if( amt>0 ){
drha21b83b2011-04-15 12:36:10 +00003125 if( wrote<0 && pFile->lastErrno!=ENOSPC ){
drh734c9862008-11-28 15:37:20 +00003126 /* lastErrno set by seekAndWrite */
3127 return SQLITE_IOERR_WRITE;
3128 }else{
dan08da86a2009-08-21 17:18:03 +00003129 pFile->lastErrno = 0; /* not a system error */
drh734c9862008-11-28 15:37:20 +00003130 return SQLITE_FULL;
3131 }
3132 }
dan6e09d692010-07-27 18:34:15 +00003133
drh734c9862008-11-28 15:37:20 +00003134 return SQLITE_OK;
3135}
3136
3137#ifdef SQLITE_TEST
3138/*
3139** Count the number of fullsyncs and normal syncs. This is used to test
drh6b9d6dd2008-12-03 19:34:47 +00003140** that syncs and fullsyncs are occurring at the right times.
drh734c9862008-11-28 15:37:20 +00003141*/
3142int sqlite3_sync_count = 0;
3143int sqlite3_fullsync_count = 0;
3144#endif
3145
3146/*
drh89240432009-03-25 01:06:01 +00003147** We do not trust systems to provide a working fdatasync(). Some do.
3148** Others do no. To be safe, we will stick with the (slower) fsync().
3149** If you know that your system does support fdatasync() correctly,
3150** then simply compile with -Dfdatasync=fdatasync
drh734c9862008-11-28 15:37:20 +00003151*/
drh89240432009-03-25 01:06:01 +00003152#if !defined(fdatasync) && !defined(__linux__)
drh734c9862008-11-28 15:37:20 +00003153# define fdatasync fsync
3154#endif
3155
3156/*
3157** Define HAVE_FULLFSYNC to 0 or 1 depending on whether or not
3158** the F_FULLFSYNC macro is defined. F_FULLFSYNC is currently
3159** only available on Mac OS X. But that could change.
3160*/
3161#ifdef F_FULLFSYNC
3162# define HAVE_FULLFSYNC 1
3163#else
3164# define HAVE_FULLFSYNC 0
3165#endif
3166
3167
3168/*
3169** The fsync() system call does not work as advertised on many
3170** unix systems. The following procedure is an attempt to make
3171** it work better.
3172**
3173** The SQLITE_NO_SYNC macro disables all fsync()s. This is useful
3174** for testing when we want to run through the test suite quickly.
3175** You are strongly advised *not* to deploy with SQLITE_NO_SYNC
3176** enabled, however, since with SQLITE_NO_SYNC enabled, an OS crash
3177** or power failure will likely corrupt the database file.
drh0b647ff2009-03-21 14:41:04 +00003178**
3179** SQLite sets the dataOnly flag if the size of the file is unchanged.
3180** The idea behind dataOnly is that it should only write the file content
3181** to disk, not the inode. We only set dataOnly if the file size is
3182** unchanged since the file size is part of the inode. However,
3183** Ted Ts'o tells us that fdatasync() will also write the inode if the
3184** file size has changed. The only real difference between fdatasync()
3185** and fsync(), Ted tells us, is that fdatasync() will not flush the
3186** inode if the mtime or owner or other inode attributes have changed.
3187** We only care about the file size, not the other file attributes, so
3188** as far as SQLite is concerned, an fdatasync() is always adequate.
3189** So, we always use fdatasync() if it is available, regardless of
3190** the value of the dataOnly flag.
drh734c9862008-11-28 15:37:20 +00003191*/
3192static int full_fsync(int fd, int fullSync, int dataOnly){
chw97185482008-11-17 08:05:31 +00003193 int rc;
drh734c9862008-11-28 15:37:20 +00003194
3195 /* The following "ifdef/elif/else/" block has the same structure as
3196 ** the one below. It is replicated here solely to avoid cluttering
3197 ** up the real code with the UNUSED_PARAMETER() macros.
3198 */
3199#ifdef SQLITE_NO_SYNC
3200 UNUSED_PARAMETER(fd);
3201 UNUSED_PARAMETER(fullSync);
3202 UNUSED_PARAMETER(dataOnly);
3203#elif HAVE_FULLFSYNC
3204 UNUSED_PARAMETER(dataOnly);
3205#else
3206 UNUSED_PARAMETER(fullSync);
drh0b647ff2009-03-21 14:41:04 +00003207 UNUSED_PARAMETER(dataOnly);
drh734c9862008-11-28 15:37:20 +00003208#endif
3209
3210 /* Record the number of times that we do a normal fsync() and
3211 ** FULLSYNC. This is used during testing to verify that this procedure
3212 ** gets called with the correct arguments.
3213 */
3214#ifdef SQLITE_TEST
3215 if( fullSync ) sqlite3_fullsync_count++;
3216 sqlite3_sync_count++;
3217#endif
3218
3219 /* If we compiled with the SQLITE_NO_SYNC flag, then syncing is a
3220 ** no-op
3221 */
3222#ifdef SQLITE_NO_SYNC
3223 rc = SQLITE_OK;
3224#elif HAVE_FULLFSYNC
3225 if( fullSync ){
drh99ab3b12011-03-02 15:09:07 +00003226 rc = osFcntl(fd, F_FULLFSYNC, 0);
drh734c9862008-11-28 15:37:20 +00003227 }else{
3228 rc = 1;
3229 }
3230 /* If the FULLFSYNC failed, fall back to attempting an fsync().
drh6b9d6dd2008-12-03 19:34:47 +00003231 ** It shouldn't be possible for fullfsync to fail on the local
3232 ** file system (on OSX), so failure indicates that FULLFSYNC
3233 ** isn't supported for this file system. So, attempt an fsync
3234 ** and (for now) ignore the overhead of a superfluous fcntl call.
3235 ** It'd be better to detect fullfsync support once and avoid
3236 ** the fcntl call every time sync is called.
3237 */
drh734c9862008-11-28 15:37:20 +00003238 if( rc ) rc = fsync(fd);
3239
drh7ed97b92010-01-20 13:07:21 +00003240#elif defined(__APPLE__)
3241 /* fdatasync() on HFS+ doesn't yet flush the file size if it changed correctly
3242 ** so currently we default to the macro that redefines fdatasync to fsync
3243 */
3244 rc = fsync(fd);
drh734c9862008-11-28 15:37:20 +00003245#else
drh0b647ff2009-03-21 14:41:04 +00003246 rc = fdatasync(fd);
drhc7288ee2009-01-15 04:30:02 +00003247#if OS_VXWORKS
drh0b647ff2009-03-21 14:41:04 +00003248 if( rc==-1 && errno==ENOTSUP ){
drh734c9862008-11-28 15:37:20 +00003249 rc = fsync(fd);
3250 }
drh0b647ff2009-03-21 14:41:04 +00003251#endif /* OS_VXWORKS */
drh734c9862008-11-28 15:37:20 +00003252#endif /* ifdef SQLITE_NO_SYNC elif HAVE_FULLFSYNC */
3253
3254 if( OS_VXWORKS && rc!= -1 ){
3255 rc = 0;
3256 }
chw97185482008-11-17 08:05:31 +00003257 return rc;
drhbfe66312006-10-03 17:40:40 +00003258}
3259
drh734c9862008-11-28 15:37:20 +00003260/*
drh0059eae2011-08-08 23:48:40 +00003261** Open a file descriptor to the directory containing file zFilename.
3262** If successful, *pFd is set to the opened file descriptor and
3263** SQLITE_OK is returned. If an error occurs, either SQLITE_NOMEM
3264** or SQLITE_CANTOPEN is returned and *pFd is set to an undefined
3265** value.
3266**
drh90315a22011-08-10 01:52:12 +00003267** The directory file descriptor is used for only one thing - to
3268** fsync() a directory to make sure file creation and deletion events
3269** are flushed to disk. Such fsyncs are not needed on newer
3270** journaling filesystems, but are required on older filesystems.
3271**
3272** This routine can be overridden using the xSetSysCall interface.
3273** The ability to override this routine was added in support of the
3274** chromium sandbox. Opening a directory is a security risk (we are
3275** told) so making it overrideable allows the chromium sandbox to
3276** replace this routine with a harmless no-op. To make this routine
3277** a no-op, replace it with a stub that returns SQLITE_OK but leaves
3278** *pFd set to a negative number.
3279**
drh0059eae2011-08-08 23:48:40 +00003280** If SQLITE_OK is returned, the caller is responsible for closing
3281** the file descriptor *pFd using close().
3282*/
3283static int openDirectory(const char *zFilename, int *pFd){
3284 int ii;
3285 int fd = -1;
3286 char zDirname[MAX_PATHNAME+1];
3287
3288 sqlite3_snprintf(MAX_PATHNAME, zDirname, "%s", zFilename);
3289 for(ii=(int)strlen(zDirname); ii>1 && zDirname[ii]!='/'; ii--);
3290 if( ii>0 ){
3291 zDirname[ii] = '\0';
3292 fd = robust_open(zDirname, O_RDONLY|O_BINARY, 0);
3293 if( fd>=0 ){
3294#ifdef FD_CLOEXEC
3295 osFcntl(fd, F_SETFD, osFcntl(fd, F_GETFD, 0) | FD_CLOEXEC);
3296#endif
3297 OSTRACE(("OPENDIR %-3d %s\n", fd, zDirname));
3298 }
3299 }
3300 *pFd = fd;
3301 return (fd>=0?SQLITE_OK:unixLogError(SQLITE_CANTOPEN_BKPT, "open", zDirname));
3302}
3303
3304/*
drh734c9862008-11-28 15:37:20 +00003305** Make sure all writes to a particular file are committed to disk.
3306**
3307** If dataOnly==0 then both the file itself and its metadata (file
3308** size, access time, etc) are synced. If dataOnly!=0 then only the
3309** file data is synced.
3310**
3311** Under Unix, also make sure that the directory entry for the file
3312** has been created by fsync-ing the directory that contains the file.
3313** If we do not do this and we encounter a power failure, the directory
3314** entry for the journal might not exist after we reboot. The next
3315** SQLite to access the file will not know that the journal exists (because
3316** the directory entry for the journal was never created) and the transaction
3317** will not roll back - possibly leading to database corruption.
3318*/
3319static int unixSync(sqlite3_file *id, int flags){
3320 int rc;
3321 unixFile *pFile = (unixFile*)id;
3322
3323 int isDataOnly = (flags&SQLITE_SYNC_DATAONLY);
3324 int isFullsync = (flags&0x0F)==SQLITE_SYNC_FULL;
3325
3326 /* Check that one of SQLITE_SYNC_NORMAL or FULL was passed */
3327 assert((flags&0x0F)==SQLITE_SYNC_NORMAL
3328 || (flags&0x0F)==SQLITE_SYNC_FULL
3329 );
3330
3331 /* Unix cannot, but some systems may return SQLITE_FULL from here. This
3332 ** line is to test that doing so does not cause any problems.
3333 */
3334 SimulateDiskfullError( return SQLITE_FULL );
3335
3336 assert( pFile );
drh308c2a52010-05-14 11:30:18 +00003337 OSTRACE(("SYNC %-3d\n", pFile->h));
drh734c9862008-11-28 15:37:20 +00003338 rc = full_fsync(pFile->h, isFullsync, isDataOnly);
3339 SimulateIOError( rc=1 );
3340 if( rc ){
3341 pFile->lastErrno = errno;
dane18d4952011-02-21 11:46:24 +00003342 return unixLogError(SQLITE_IOERR_FSYNC, "full_fsync", pFile->zPath);
drh734c9862008-11-28 15:37:20 +00003343 }
drh0059eae2011-08-08 23:48:40 +00003344
3345 /* Also fsync the directory containing the file if the DIRSYNC flag
drh90315a22011-08-10 01:52:12 +00003346 ** is set. This is a one-time occurrance. Many systems (examples: AIX)
3347 ** are unable to fsync a directory, so ignore errors on the fsync.
drh0059eae2011-08-08 23:48:40 +00003348 */
3349 if( pFile->ctrlFlags & UNIXFILE_DIRSYNC ){
3350 int dirfd;
3351 OSTRACE(("DIRSYNC %s (have_fullfsync=%d fullsync=%d)\n", pFile->zPath,
drh308c2a52010-05-14 11:30:18 +00003352 HAVE_FULLFSYNC, isFullsync));
drh90315a22011-08-10 01:52:12 +00003353 rc = osOpenDirectory(pFile->zPath, &dirfd);
3354 if( rc==SQLITE_OK && dirfd>=0 ){
drh0059eae2011-08-08 23:48:40 +00003355 full_fsync(dirfd, 0, 0);
3356 robust_close(pFile, dirfd, __LINE__);
drh1ee6f742011-08-23 20:11:32 +00003357 }else if( rc==SQLITE_CANTOPEN ){
3358 rc = SQLITE_OK;
drh734c9862008-11-28 15:37:20 +00003359 }
drh0059eae2011-08-08 23:48:40 +00003360 pFile->ctrlFlags &= ~UNIXFILE_DIRSYNC;
drh734c9862008-11-28 15:37:20 +00003361 }
3362 return rc;
3363}
3364
3365/*
3366** Truncate an open file to a specified size
3367*/
3368static int unixTruncate(sqlite3_file *id, i64 nByte){
dan6e09d692010-07-27 18:34:15 +00003369 unixFile *pFile = (unixFile *)id;
drh734c9862008-11-28 15:37:20 +00003370 int rc;
dan6e09d692010-07-27 18:34:15 +00003371 assert( pFile );
drh734c9862008-11-28 15:37:20 +00003372 SimulateIOError( return SQLITE_IOERR_TRUNCATE );
dan6e09d692010-07-27 18:34:15 +00003373
3374 /* If the user has configured a chunk-size for this file, truncate the
3375 ** file so that it consists of an integer number of chunks (i.e. the
3376 ** actual file size after the operation may be larger than the requested
3377 ** size).
3378 */
3379 if( pFile->szChunk ){
3380 nByte = ((nByte + pFile->szChunk - 1)/pFile->szChunk) * pFile->szChunk;
3381 }
3382
drhff812312011-02-23 13:33:46 +00003383 rc = robust_ftruncate(pFile->h, (off_t)nByte);
drh734c9862008-11-28 15:37:20 +00003384 if( rc ){
dan6e09d692010-07-27 18:34:15 +00003385 pFile->lastErrno = errno;
dane18d4952011-02-21 11:46:24 +00003386 return unixLogError(SQLITE_IOERR_TRUNCATE, "ftruncate", pFile->zPath);
drh734c9862008-11-28 15:37:20 +00003387 }else{
drh3313b142009-11-06 04:13:18 +00003388#ifndef NDEBUG
3389 /* If we are doing a normal write to a database file (as opposed to
3390 ** doing a hot-journal rollback or a write to some file other than a
3391 ** normal database file) and we truncate the file to zero length,
3392 ** that effectively updates the change counter. This might happen
3393 ** when restoring a database using the backup API from a zero-length
3394 ** source.
3395 */
dan6e09d692010-07-27 18:34:15 +00003396 if( pFile->inNormalWrite && nByte==0 ){
3397 pFile->transCntrChng = 1;
drh3313b142009-11-06 04:13:18 +00003398 }
3399#endif
3400
drh734c9862008-11-28 15:37:20 +00003401 return SQLITE_OK;
3402 }
3403}
3404
3405/*
3406** Determine the current size of a file in bytes
3407*/
3408static int unixFileSize(sqlite3_file *id, i64 *pSize){
3409 int rc;
3410 struct stat buf;
3411 assert( id );
drh99ab3b12011-03-02 15:09:07 +00003412 rc = osFstat(((unixFile*)id)->h, &buf);
drh734c9862008-11-28 15:37:20 +00003413 SimulateIOError( rc=1 );
3414 if( rc!=0 ){
3415 ((unixFile*)id)->lastErrno = errno;
3416 return SQLITE_IOERR_FSTAT;
3417 }
3418 *pSize = buf.st_size;
3419
drh8af6c222010-05-14 12:43:01 +00003420 /* When opening a zero-size database, the findInodeInfo() procedure
drh734c9862008-11-28 15:37:20 +00003421 ** writes a single byte into that file in order to work around a bug
3422 ** in the OS-X msdos filesystem. In order to avoid problems with upper
3423 ** layers, we need to report this file size as zero even though it is
3424 ** really 1. Ticket #3260.
3425 */
3426 if( *pSize==1 ) *pSize = 0;
3427
3428
3429 return SQLITE_OK;
3430}
3431
drhd2cb50b2009-01-09 21:41:17 +00003432#if SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__)
drh715ff302008-12-03 22:32:44 +00003433/*
3434** Handler for proxy-locking file-control verbs. Defined below in the
3435** proxying locking division.
3436*/
3437static int proxyFileControl(sqlite3_file*,int,void*);
drh947bd802008-12-04 12:34:15 +00003438#endif
drh715ff302008-12-03 22:32:44 +00003439
dan502019c2010-07-28 14:26:17 +00003440/*
3441** This function is called to handle the SQLITE_FCNTL_SIZE_HINT
3442** file-control operation.
3443**
3444** If the user has configured a chunk-size for this file, it could be
3445** that the file needs to be extended at this point. Otherwise, the
3446** SQLITE_FCNTL_SIZE_HINT operation is a no-op for Unix.
3447*/
3448static int fcntlSizeHint(unixFile *pFile, i64 nByte){
drh7d2dc712011-07-25 23:25:47 +00003449 { /* preserve indentation of removed "if" */
dan502019c2010-07-28 14:26:17 +00003450 i64 nSize; /* Required file size */
drh7d2dc712011-07-25 23:25:47 +00003451 i64 szChunk; /* Chunk size */
dan502019c2010-07-28 14:26:17 +00003452 struct stat buf; /* Used to hold return values of fstat() */
3453
drh99ab3b12011-03-02 15:09:07 +00003454 if( osFstat(pFile->h, &buf) ) return SQLITE_IOERR_FSTAT;
dan502019c2010-07-28 14:26:17 +00003455
drh7d2dc712011-07-25 23:25:47 +00003456 szChunk = pFile->szChunk;
3457 if( szChunk==0 ){
3458 nSize = nByte;
3459 }else{
3460 nSize = ((nByte+szChunk-1) / szChunk) * szChunk;
3461 }
dan502019c2010-07-28 14:26:17 +00003462 if( nSize>(i64)buf.st_size ){
dan661d71a2011-03-30 19:08:03 +00003463
dan502019c2010-07-28 14:26:17 +00003464#if defined(HAVE_POSIX_FALLOCATE) && HAVE_POSIX_FALLOCATE
dan661d71a2011-03-30 19:08:03 +00003465 /* The code below is handling the return value of osFallocate()
3466 ** correctly. posix_fallocate() is defined to "returns zero on success,
3467 ** or an error number on failure". See the manpage for details. */
3468 int err;
drhff812312011-02-23 13:33:46 +00003469 do{
dan661d71a2011-03-30 19:08:03 +00003470 err = osFallocate(pFile->h, buf.st_size, nSize-buf.st_size);
3471 }while( err==EINTR );
3472 if( err ) return SQLITE_IOERR_WRITE;
dan502019c2010-07-28 14:26:17 +00003473#else
3474 /* If the OS does not have posix_fallocate(), fake it. First use
3475 ** ftruncate() to set the file size, then write a single byte to
3476 ** the last byte in each block within the extended region. This
3477 ** is the same technique used by glibc to implement posix_fallocate()
3478 ** on systems that do not have a real fallocate() system call.
3479 */
3480 int nBlk = buf.st_blksize; /* File-system block size */
3481 i64 iWrite; /* Next offset to write to */
dan502019c2010-07-28 14:26:17 +00003482
drhff812312011-02-23 13:33:46 +00003483 if( robust_ftruncate(pFile->h, nSize) ){
dan502019c2010-07-28 14:26:17 +00003484 pFile->lastErrno = errno;
dane18d4952011-02-21 11:46:24 +00003485 return unixLogError(SQLITE_IOERR_TRUNCATE, "ftruncate", pFile->zPath);
dan502019c2010-07-28 14:26:17 +00003486 }
3487 iWrite = ((buf.st_size + 2*nBlk - 1)/nBlk)*nBlk-1;
dandc5df0f2011-04-06 19:15:45 +00003488 while( iWrite<nSize ){
3489 int nWrite = seekAndWrite(pFile, iWrite, "", 1);
3490 if( nWrite!=1 ) return SQLITE_IOERR_WRITE;
dan502019c2010-07-28 14:26:17 +00003491 iWrite += nBlk;
dandc5df0f2011-04-06 19:15:45 +00003492 }
dan502019c2010-07-28 14:26:17 +00003493#endif
3494 }
3495 }
3496
3497 return SQLITE_OK;
3498}
danielk1977ad94b582007-08-20 06:44:22 +00003499
danielk1977e3026632004-06-22 11:29:02 +00003500/*
drh9e33c2c2007-08-31 18:34:59 +00003501** Information and control of an open file handle.
drh18839212005-11-26 03:43:23 +00003502*/
drhcc6bb3e2007-08-31 16:11:35 +00003503static int unixFileControl(sqlite3_file *id, int op, void *pArg){
drhf0b190d2011-07-26 16:03:07 +00003504 unixFile *pFile = (unixFile*)id;
drh9e33c2c2007-08-31 18:34:59 +00003505 switch( op ){
3506 case SQLITE_FCNTL_LOCKSTATE: {
drhf0b190d2011-07-26 16:03:07 +00003507 *(int*)pArg = pFile->eFileLock;
drh9e33c2c2007-08-31 18:34:59 +00003508 return SQLITE_OK;
3509 }
drh7708e972008-11-29 00:56:52 +00003510 case SQLITE_LAST_ERRNO: {
drhf0b190d2011-07-26 16:03:07 +00003511 *(int*)pArg = pFile->lastErrno;
drh7708e972008-11-29 00:56:52 +00003512 return SQLITE_OK;
3513 }
dan6e09d692010-07-27 18:34:15 +00003514 case SQLITE_FCNTL_CHUNK_SIZE: {
drhf0b190d2011-07-26 16:03:07 +00003515 pFile->szChunk = *(int *)pArg;
dan502019c2010-07-28 14:26:17 +00003516 return SQLITE_OK;
dan6e09d692010-07-27 18:34:15 +00003517 }
drh9ff27ec2010-05-19 19:26:05 +00003518 case SQLITE_FCNTL_SIZE_HINT: {
danda04ea42011-08-23 05:10:39 +00003519 int rc;
3520 SimulateIOErrorBenign(1);
3521 rc = fcntlSizeHint(pFile, *(i64 *)pArg);
3522 SimulateIOErrorBenign(0);
3523 return rc;
drhf0b190d2011-07-26 16:03:07 +00003524 }
3525 case SQLITE_FCNTL_PERSIST_WAL: {
3526 int bPersist = *(int*)pArg;
3527 if( bPersist<0 ){
drh253cea52011-07-26 16:23:25 +00003528 *(int*)pArg = (pFile->ctrlFlags & UNIXFILE_PERSIST_WAL)!=0;
drhf0b190d2011-07-26 16:03:07 +00003529 }else if( bPersist==0 ){
3530 pFile->ctrlFlags &= ~UNIXFILE_PERSIST_WAL;
3531 }else{
3532 pFile->ctrlFlags |= UNIXFILE_PERSIST_WAL;
3533 }
3534 return SQLITE_OK;
drh9ff27ec2010-05-19 19:26:05 +00003535 }
drh8f941bc2009-01-14 23:03:40 +00003536#ifndef NDEBUG
3537 /* The pager calls this method to signal that it has done
3538 ** a rollback and that the database is therefore unchanged and
3539 ** it hence it is OK for the transaction change counter to be
3540 ** unchanged.
3541 */
3542 case SQLITE_FCNTL_DB_UNCHANGED: {
3543 ((unixFile*)id)->dbUpdate = 0;
3544 return SQLITE_OK;
3545 }
3546#endif
drhd2cb50b2009-01-09 21:41:17 +00003547#if SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__)
drh715ff302008-12-03 22:32:44 +00003548 case SQLITE_SET_LOCKPROXYFILE:
aswiftaebf4132008-11-21 00:10:35 +00003549 case SQLITE_GET_LOCKPROXYFILE: {
drh715ff302008-12-03 22:32:44 +00003550 return proxyFileControl(id,op,pArg);
drh7708e972008-11-29 00:56:52 +00003551 }
drhd2cb50b2009-01-09 21:41:17 +00003552#endif /* SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__) */
drh0b52b7d2011-01-26 19:46:22 +00003553 case SQLITE_FCNTL_SYNC_OMITTED: {
3554 return SQLITE_OK; /* A no-op */
3555 }
drh9e33c2c2007-08-31 18:34:59 +00003556 }
drh0b52b7d2011-01-26 19:46:22 +00003557 return SQLITE_NOTFOUND;
drh9cbe6352005-11-29 03:13:21 +00003558}
3559
3560/*
danielk1977a3d4c882007-03-23 10:08:38 +00003561** Return the sector size in bytes of the underlying block device for
3562** the specified file. This is almost always 512 bytes, but may be
3563** larger for some devices.
3564**
3565** SQLite code assumes this function cannot fail. It also assumes that
3566** if two files are created in the same file-system directory (i.e.
drh85b623f2007-12-13 21:54:09 +00003567** a database and its journal file) that the sector size will be the
danielk1977a3d4c882007-03-23 10:08:38 +00003568** same for both.
3569*/
danielk1977397d65f2008-11-19 11:35:39 +00003570static int unixSectorSize(sqlite3_file *NotUsed){
3571 UNUSED_PARAMETER(NotUsed);
drh3ceeb752007-03-29 18:19:52 +00003572 return SQLITE_DEFAULT_SECTOR_SIZE;
danielk1977a3d4c882007-03-23 10:08:38 +00003573}
3574
danielk197790949c22007-08-17 16:50:38 +00003575/*
danielk1977397d65f2008-11-19 11:35:39 +00003576** Return the device characteristics for the file. This is always 0 for unix.
danielk197790949c22007-08-17 16:50:38 +00003577*/
danielk1977397d65f2008-11-19 11:35:39 +00003578static int unixDeviceCharacteristics(sqlite3_file *NotUsed){
3579 UNUSED_PARAMETER(NotUsed);
danielk197762079062007-08-15 17:08:46 +00003580 return 0;
3581}
3582
drhd9e5c4f2010-05-12 18:01:39 +00003583#ifndef SQLITE_OMIT_WAL
3584
3585
3586/*
drhd91c68f2010-05-14 14:52:25 +00003587** Object used to represent an shared memory buffer.
3588**
3589** When multiple threads all reference the same wal-index, each thread
3590** has its own unixShm object, but they all point to a single instance
3591** of this unixShmNode object. In other words, each wal-index is opened
3592** only once per process.
3593**
3594** Each unixShmNode object is connected to a single unixInodeInfo object.
3595** We could coalesce this object into unixInodeInfo, but that would mean
3596** every open file that does not use shared memory (in other words, most
3597** open files) would have to carry around this extra information. So
3598** the unixInodeInfo object contains a pointer to this unixShmNode object
3599** and the unixShmNode object is created only when needed.
drhd9e5c4f2010-05-12 18:01:39 +00003600**
3601** unixMutexHeld() must be true when creating or destroying
3602** this object or while reading or writing the following fields:
3603**
3604** nRef
drhd9e5c4f2010-05-12 18:01:39 +00003605**
3606** The following fields are read-only after the object is created:
3607**
3608** fid
3609** zFilename
3610**
drhd91c68f2010-05-14 14:52:25 +00003611** Either unixShmNode.mutex must be held or unixShmNode.nRef==0 and
drhd9e5c4f2010-05-12 18:01:39 +00003612** unixMutexHeld() is true when reading or writing any other field
3613** in this structure.
drhd9e5c4f2010-05-12 18:01:39 +00003614*/
drhd91c68f2010-05-14 14:52:25 +00003615struct unixShmNode {
3616 unixInodeInfo *pInode; /* unixInodeInfo that owns this SHM node */
drhd9e5c4f2010-05-12 18:01:39 +00003617 sqlite3_mutex *mutex; /* Mutex to access this object */
drhd9e5c4f2010-05-12 18:01:39 +00003618 char *zFilename; /* Name of the mmapped file */
3619 int h; /* Open file descriptor */
dan18801912010-06-14 14:07:50 +00003620 int szRegion; /* Size of shared-memory regions */
drh66dfec8b2011-06-01 20:01:49 +00003621 u16 nRegion; /* Size of array apRegion */
3622 u8 isReadonly; /* True if read-only */
dan18801912010-06-14 14:07:50 +00003623 char **apRegion; /* Array of mapped shared-memory regions */
drhd9e5c4f2010-05-12 18:01:39 +00003624 int nRef; /* Number of unixShm objects pointing to this */
3625 unixShm *pFirst; /* All unixShm objects pointing to this */
drhd9e5c4f2010-05-12 18:01:39 +00003626#ifdef SQLITE_DEBUG
3627 u8 exclMask; /* Mask of exclusive locks held */
3628 u8 sharedMask; /* Mask of shared locks held */
3629 u8 nextShmId; /* Next available unixShm.id value */
3630#endif
3631};
3632
3633/*
drhd9e5c4f2010-05-12 18:01:39 +00003634** Structure used internally by this VFS to record the state of an
3635** open shared memory connection.
3636**
drhd91c68f2010-05-14 14:52:25 +00003637** The following fields are initialized when this object is created and
3638** are read-only thereafter:
drhd9e5c4f2010-05-12 18:01:39 +00003639**
drhd91c68f2010-05-14 14:52:25 +00003640** unixShm.pFile
3641** unixShm.id
3642**
3643** All other fields are read/write. The unixShm.pFile->mutex must be held
3644** while accessing any read/write fields.
drhd9e5c4f2010-05-12 18:01:39 +00003645*/
3646struct unixShm {
drhd91c68f2010-05-14 14:52:25 +00003647 unixShmNode *pShmNode; /* The underlying unixShmNode object */
3648 unixShm *pNext; /* Next unixShm with the same unixShmNode */
drhd91c68f2010-05-14 14:52:25 +00003649 u8 hasMutex; /* True if holding the unixShmNode mutex */
drh73b64e42010-05-30 19:55:15 +00003650 u16 sharedMask; /* Mask of shared locks held */
3651 u16 exclMask; /* Mask of exclusive locks held */
drhd9e5c4f2010-05-12 18:01:39 +00003652#ifdef SQLITE_DEBUG
drhd91c68f2010-05-14 14:52:25 +00003653 u8 id; /* Id of this connection within its unixShmNode */
drhd9e5c4f2010-05-12 18:01:39 +00003654#endif
3655};
3656
3657/*
drhd9e5c4f2010-05-12 18:01:39 +00003658** Constants used for locking
3659*/
drhbd9676c2010-06-23 17:58:38 +00003660#define UNIX_SHM_BASE ((22+SQLITE_SHM_NLOCK)*4) /* first lock byte */
drh42224412010-05-31 14:28:25 +00003661#define UNIX_SHM_DMS (UNIX_SHM_BASE+SQLITE_SHM_NLOCK) /* deadman switch */
drhd9e5c4f2010-05-12 18:01:39 +00003662
drhd9e5c4f2010-05-12 18:01:39 +00003663/*
drh73b64e42010-05-30 19:55:15 +00003664** Apply posix advisory locks for all bytes from ofst through ofst+n-1.
drhd9e5c4f2010-05-12 18:01:39 +00003665**
3666** Locks block if the mask is exactly UNIX_SHM_C and are non-blocking
3667** otherwise.
3668*/
3669static int unixShmSystemLock(
drhd91c68f2010-05-14 14:52:25 +00003670 unixShmNode *pShmNode, /* Apply locks to this open shared-memory segment */
3671 int lockType, /* F_UNLCK, F_RDLCK, or F_WRLCK */
drh73b64e42010-05-30 19:55:15 +00003672 int ofst, /* First byte of the locking range */
3673 int n /* Number of bytes to lock */
drhd9e5c4f2010-05-12 18:01:39 +00003674){
3675 struct flock f; /* The posix advisory locking structure */
drh73b64e42010-05-30 19:55:15 +00003676 int rc = SQLITE_OK; /* Result code form fcntl() */
drhd9e5c4f2010-05-12 18:01:39 +00003677
drhd91c68f2010-05-14 14:52:25 +00003678 /* Access to the unixShmNode object is serialized by the caller */
3679 assert( sqlite3_mutex_held(pShmNode->mutex) || pShmNode->nRef==0 );
drhd9e5c4f2010-05-12 18:01:39 +00003680
drh73b64e42010-05-30 19:55:15 +00003681 /* Shared locks never span more than one byte */
3682 assert( n==1 || lockType!=F_RDLCK );
3683
3684 /* Locks are within range */
drhc99597c2010-05-31 01:41:15 +00003685 assert( n>=1 && n<SQLITE_SHM_NLOCK );
drh73b64e42010-05-30 19:55:15 +00003686
drh3cb93392011-03-12 18:10:44 +00003687 if( pShmNode->h>=0 ){
3688 /* Initialize the locking parameters */
3689 memset(&f, 0, sizeof(f));
3690 f.l_type = lockType;
3691 f.l_whence = SEEK_SET;
3692 f.l_start = ofst;
3693 f.l_len = n;
drhd9e5c4f2010-05-12 18:01:39 +00003694
drh3cb93392011-03-12 18:10:44 +00003695 rc = osFcntl(pShmNode->h, F_SETLK, &f);
3696 rc = (rc!=(-1)) ? SQLITE_OK : SQLITE_BUSY;
3697 }
drhd9e5c4f2010-05-12 18:01:39 +00003698
3699 /* Update the global lock state and do debug tracing */
3700#ifdef SQLITE_DEBUG
drh73b64e42010-05-30 19:55:15 +00003701 { u16 mask;
drhd9e5c4f2010-05-12 18:01:39 +00003702 OSTRACE(("SHM-LOCK "));
drh73b64e42010-05-30 19:55:15 +00003703 mask = (1<<(ofst+n)) - (1<<ofst);
drhd9e5c4f2010-05-12 18:01:39 +00003704 if( rc==SQLITE_OK ){
3705 if( lockType==F_UNLCK ){
drh73b64e42010-05-30 19:55:15 +00003706 OSTRACE(("unlock %d ok", ofst));
3707 pShmNode->exclMask &= ~mask;
3708 pShmNode->sharedMask &= ~mask;
drhd9e5c4f2010-05-12 18:01:39 +00003709 }else if( lockType==F_RDLCK ){
drh73b64e42010-05-30 19:55:15 +00003710 OSTRACE(("read-lock %d ok", ofst));
3711 pShmNode->exclMask &= ~mask;
3712 pShmNode->sharedMask |= mask;
drhd9e5c4f2010-05-12 18:01:39 +00003713 }else{
3714 assert( lockType==F_WRLCK );
drh73b64e42010-05-30 19:55:15 +00003715 OSTRACE(("write-lock %d ok", ofst));
3716 pShmNode->exclMask |= mask;
3717 pShmNode->sharedMask &= ~mask;
drhd9e5c4f2010-05-12 18:01:39 +00003718 }
3719 }else{
3720 if( lockType==F_UNLCK ){
drh73b64e42010-05-30 19:55:15 +00003721 OSTRACE(("unlock %d failed", ofst));
drhd9e5c4f2010-05-12 18:01:39 +00003722 }else if( lockType==F_RDLCK ){
3723 OSTRACE(("read-lock failed"));
3724 }else{
3725 assert( lockType==F_WRLCK );
drh73b64e42010-05-30 19:55:15 +00003726 OSTRACE(("write-lock %d failed", ofst));
drhd9e5c4f2010-05-12 18:01:39 +00003727 }
3728 }
drh20e1f082010-05-31 16:10:12 +00003729 OSTRACE((" - afterwards %03x,%03x\n",
3730 pShmNode->sharedMask, pShmNode->exclMask));
drh73b64e42010-05-30 19:55:15 +00003731 }
drhd9e5c4f2010-05-12 18:01:39 +00003732#endif
3733
3734 return rc;
3735}
3736
drhd9e5c4f2010-05-12 18:01:39 +00003737
3738/*
drhd91c68f2010-05-14 14:52:25 +00003739** Purge the unixShmNodeList list of all entries with unixShmNode.nRef==0.
drhd9e5c4f2010-05-12 18:01:39 +00003740**
3741** This is not a VFS shared-memory method; it is a utility function called
3742** by VFS shared-memory methods.
3743*/
drhd91c68f2010-05-14 14:52:25 +00003744static void unixShmPurge(unixFile *pFd){
3745 unixShmNode *p = pFd->pInode->pShmNode;
drhd9e5c4f2010-05-12 18:01:39 +00003746 assert( unixMutexHeld() );
drhd91c68f2010-05-14 14:52:25 +00003747 if( p && p->nRef==0 ){
dan13a3cb82010-06-11 19:04:21 +00003748 int i;
drhd91c68f2010-05-14 14:52:25 +00003749 assert( p->pInode==pFd->pInode );
drhdf3aa162011-06-24 11:29:51 +00003750 sqlite3_mutex_free(p->mutex);
dan18801912010-06-14 14:07:50 +00003751 for(i=0; i<p->nRegion; i++){
drh3cb93392011-03-12 18:10:44 +00003752 if( p->h>=0 ){
3753 munmap(p->apRegion[i], p->szRegion);
3754 }else{
3755 sqlite3_free(p->apRegion[i]);
3756 }
dan13a3cb82010-06-11 19:04:21 +00003757 }
dan18801912010-06-14 14:07:50 +00003758 sqlite3_free(p->apRegion);
drh0e9365c2011-03-02 02:08:13 +00003759 if( p->h>=0 ){
3760 robust_close(pFd, p->h, __LINE__);
3761 p->h = -1;
3762 }
drhd91c68f2010-05-14 14:52:25 +00003763 p->pInode->pShmNode = 0;
3764 sqlite3_free(p);
drhd9e5c4f2010-05-12 18:01:39 +00003765 }
3766}
3767
3768/*
danda9fe0c2010-07-13 18:44:03 +00003769** Open a shared-memory area associated with open database file pDbFd.
drh7234c6d2010-06-19 15:10:09 +00003770** This particular implementation uses mmapped files.
drhd9e5c4f2010-05-12 18:01:39 +00003771**
drh7234c6d2010-06-19 15:10:09 +00003772** The file used to implement shared-memory is in the same directory
3773** as the open database file and has the same name as the open database
3774** file with the "-shm" suffix added. For example, if the database file
3775** is "/home/user1/config.db" then the file that is created and mmapped
drha4ced192010-07-15 18:32:40 +00003776** for shared memory will be called "/home/user1/config.db-shm".
3777**
3778** Another approach to is to use files in /dev/shm or /dev/tmp or an
3779** some other tmpfs mount. But if a file in a different directory
3780** from the database file is used, then differing access permissions
3781** or a chroot() might cause two different processes on the same
3782** database to end up using different files for shared memory -
3783** meaning that their memory would not really be shared - resulting
3784** in database corruption. Nevertheless, this tmpfs file usage
3785** can be enabled at compile-time using -DSQLITE_SHM_DIRECTORY="/dev/shm"
3786** or the equivalent. The use of the SQLITE_SHM_DIRECTORY compile-time
3787** option results in an incompatible build of SQLite; builds of SQLite
3788** that with differing SQLITE_SHM_DIRECTORY settings attempt to use the
3789** same database file at the same time, database corruption will likely
3790** result. The SQLITE_SHM_DIRECTORY compile-time option is considered
3791** "unsupported" and may go away in a future SQLite release.
drhd9e5c4f2010-05-12 18:01:39 +00003792**
3793** When opening a new shared-memory file, if no other instances of that
3794** file are currently open, in this process or in other processes, then
3795** the file must be truncated to zero length or have its header cleared.
drh3cb93392011-03-12 18:10:44 +00003796**
3797** If the original database file (pDbFd) is using the "unix-excl" VFS
3798** that means that an exclusive lock is held on the database file and
3799** that no other processes are able to read or write the database. In
3800** that case, we do not really need shared memory. No shared memory
3801** file is created. The shared memory will be simulated with heap memory.
drhd9e5c4f2010-05-12 18:01:39 +00003802*/
danda9fe0c2010-07-13 18:44:03 +00003803static int unixOpenSharedMemory(unixFile *pDbFd){
3804 struct unixShm *p = 0; /* The connection to be opened */
3805 struct unixShmNode *pShmNode; /* The underlying mmapped file */
3806 int rc; /* Result code */
3807 unixInodeInfo *pInode; /* The inode of fd */
3808 char *zShmFilename; /* Name of the file used for SHM */
3809 int nShmFilename; /* Size of the SHM filename in bytes */
drhd9e5c4f2010-05-12 18:01:39 +00003810
danda9fe0c2010-07-13 18:44:03 +00003811 /* Allocate space for the new unixShm object. */
drhd9e5c4f2010-05-12 18:01:39 +00003812 p = sqlite3_malloc( sizeof(*p) );
3813 if( p==0 ) return SQLITE_NOMEM;
3814 memset(p, 0, sizeof(*p));
drhd9e5c4f2010-05-12 18:01:39 +00003815 assert( pDbFd->pShm==0 );
drhd9e5c4f2010-05-12 18:01:39 +00003816
danda9fe0c2010-07-13 18:44:03 +00003817 /* Check to see if a unixShmNode object already exists. Reuse an existing
3818 ** one if present. Create a new one if necessary.
drhd9e5c4f2010-05-12 18:01:39 +00003819 */
3820 unixEnterMutex();
drh8b3cf822010-06-01 21:02:51 +00003821 pInode = pDbFd->pInode;
3822 pShmNode = pInode->pShmNode;
drhd91c68f2010-05-14 14:52:25 +00003823 if( pShmNode==0 ){
danddb0ac42010-07-14 14:48:58 +00003824 struct stat sStat; /* fstat() info for database file */
3825
3826 /* Call fstat() to figure out the permissions on the database file. If
3827 ** a new *-shm file is created, an attempt will be made to create it
3828 ** with the same permissions. The actual permissions the file is created
3829 ** with are subject to the current umask setting.
3830 */
drh3cb93392011-03-12 18:10:44 +00003831 if( osFstat(pDbFd->h, &sStat) && pInode->bProcessLock==0 ){
danddb0ac42010-07-14 14:48:58 +00003832 rc = SQLITE_IOERR_FSTAT;
3833 goto shm_open_err;
3834 }
3835
drha4ced192010-07-15 18:32:40 +00003836#ifdef SQLITE_SHM_DIRECTORY
3837 nShmFilename = sizeof(SQLITE_SHM_DIRECTORY) + 30;
3838#else
drh7234c6d2010-06-19 15:10:09 +00003839 nShmFilename = 5 + (int)strlen(pDbFd->zPath);
drha4ced192010-07-15 18:32:40 +00003840#endif
drh7234c6d2010-06-19 15:10:09 +00003841 pShmNode = sqlite3_malloc( sizeof(*pShmNode) + nShmFilename );
drhd91c68f2010-05-14 14:52:25 +00003842 if( pShmNode==0 ){
drhd9e5c4f2010-05-12 18:01:39 +00003843 rc = SQLITE_NOMEM;
3844 goto shm_open_err;
3845 }
drhd91c68f2010-05-14 14:52:25 +00003846 memset(pShmNode, 0, sizeof(*pShmNode));
drh7234c6d2010-06-19 15:10:09 +00003847 zShmFilename = pShmNode->zFilename = (char*)&pShmNode[1];
drha4ced192010-07-15 18:32:40 +00003848#ifdef SQLITE_SHM_DIRECTORY
3849 sqlite3_snprintf(nShmFilename, zShmFilename,
3850 SQLITE_SHM_DIRECTORY "/sqlite-shm-%x-%x",
3851 (u32)sStat.st_ino, (u32)sStat.st_dev);
3852#else
drh7234c6d2010-06-19 15:10:09 +00003853 sqlite3_snprintf(nShmFilename, zShmFilename, "%s-shm", pDbFd->zPath);
drh81cc5162011-05-17 20:36:21 +00003854 sqlite3FileSuffix3(pDbFd->zPath, zShmFilename);
drha4ced192010-07-15 18:32:40 +00003855#endif
drhd91c68f2010-05-14 14:52:25 +00003856 pShmNode->h = -1;
3857 pDbFd->pInode->pShmNode = pShmNode;
3858 pShmNode->pInode = pDbFd->pInode;
3859 pShmNode->mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_FAST);
3860 if( pShmNode->mutex==0 ){
3861 rc = SQLITE_NOMEM;
3862 goto shm_open_err;
3863 }
drhd9e5c4f2010-05-12 18:01:39 +00003864
drh3cb93392011-03-12 18:10:44 +00003865 if( pInode->bProcessLock==0 ){
drh66dfec8b2011-06-01 20:01:49 +00003866 pShmNode->h = robust_open(zShmFilename, O_RDWR|O_CREAT,
3867 (sStat.st_mode & 0777));
drh3cb93392011-03-12 18:10:44 +00003868 if( pShmNode->h<0 ){
drh66dfec8b2011-06-01 20:01:49 +00003869 const char *zRO;
3870 zRO = sqlite3_uri_parameter(pDbFd->zPath, "readonly_shm");
drhfd019ef2011-06-01 20:13:36 +00003871 if( zRO && sqlite3GetBoolean(zRO) ){
drh66dfec8b2011-06-01 20:01:49 +00003872 pShmNode->h = robust_open(zShmFilename, O_RDONLY,
3873 (sStat.st_mode & 0777));
3874 pShmNode->isReadonly = 1;
3875 }
3876 if( pShmNode->h<0 ){
3877 rc = unixLogError(SQLITE_CANTOPEN_BKPT, "open", zShmFilename);
3878 goto shm_open_err;
3879 }
drhd9e5c4f2010-05-12 18:01:39 +00003880 }
drh3cb93392011-03-12 18:10:44 +00003881
3882 /* Check to see if another process is holding the dead-man switch.
drh66dfec8b2011-06-01 20:01:49 +00003883 ** If not, truncate the file to zero length.
3884 */
3885 rc = SQLITE_OK;
3886 if( unixShmSystemLock(pShmNode, F_WRLCK, UNIX_SHM_DMS, 1)==SQLITE_OK ){
3887 if( robust_ftruncate(pShmNode->h, 0) ){
3888 rc = unixLogError(SQLITE_IOERR_SHMOPEN, "ftruncate", zShmFilename);
drh3cb93392011-03-12 18:10:44 +00003889 }
3890 }
drh66dfec8b2011-06-01 20:01:49 +00003891 if( rc==SQLITE_OK ){
3892 rc = unixShmSystemLock(pShmNode, F_RDLCK, UNIX_SHM_DMS, 1);
3893 }
3894 if( rc ) goto shm_open_err;
drhd9e5c4f2010-05-12 18:01:39 +00003895 }
drhd9e5c4f2010-05-12 18:01:39 +00003896 }
3897
drhd91c68f2010-05-14 14:52:25 +00003898 /* Make the new connection a child of the unixShmNode */
3899 p->pShmNode = pShmNode;
drhd9e5c4f2010-05-12 18:01:39 +00003900#ifdef SQLITE_DEBUG
drhd91c68f2010-05-14 14:52:25 +00003901 p->id = pShmNode->nextShmId++;
drhd9e5c4f2010-05-12 18:01:39 +00003902#endif
drhd91c68f2010-05-14 14:52:25 +00003903 pShmNode->nRef++;
drhd9e5c4f2010-05-12 18:01:39 +00003904 pDbFd->pShm = p;
3905 unixLeaveMutex();
dan0668f592010-07-20 18:59:00 +00003906
3907 /* The reference count on pShmNode has already been incremented under
3908 ** the cover of the unixEnterMutex() mutex and the pointer from the
3909 ** new (struct unixShm) object to the pShmNode has been set. All that is
3910 ** left to do is to link the new object into the linked list starting
3911 ** at pShmNode->pFirst. This must be done while holding the pShmNode->mutex
3912 ** mutex.
3913 */
3914 sqlite3_mutex_enter(pShmNode->mutex);
3915 p->pNext = pShmNode->pFirst;
3916 pShmNode->pFirst = p;
3917 sqlite3_mutex_leave(pShmNode->mutex);
drhd9e5c4f2010-05-12 18:01:39 +00003918 return SQLITE_OK;
3919
3920 /* Jump here on any error */
3921shm_open_err:
drhd91c68f2010-05-14 14:52:25 +00003922 unixShmPurge(pDbFd); /* This call frees pShmNode if required */
drhd9e5c4f2010-05-12 18:01:39 +00003923 sqlite3_free(p);
drhd9e5c4f2010-05-12 18:01:39 +00003924 unixLeaveMutex();
3925 return rc;
3926}
3927
3928/*
danda9fe0c2010-07-13 18:44:03 +00003929** This function is called to obtain a pointer to region iRegion of the
3930** shared-memory associated with the database file fd. Shared-memory regions
3931** are numbered starting from zero. Each shared-memory region is szRegion
3932** bytes in size.
3933**
3934** If an error occurs, an error code is returned and *pp is set to NULL.
3935**
3936** Otherwise, if the bExtend parameter is 0 and the requested shared-memory
3937** region has not been allocated (by any client, including one running in a
3938** separate process), then *pp is set to NULL and SQLITE_OK returned. If
3939** bExtend is non-zero and the requested shared-memory region has not yet
3940** been allocated, it is allocated by this function.
3941**
3942** If the shared-memory region has already been allocated or is allocated by
3943** this call as described above, then it is mapped into this processes
3944** address space (if it is not already), *pp is set to point to the mapped
3945** memory and SQLITE_OK returned.
drhd9e5c4f2010-05-12 18:01:39 +00003946*/
danda9fe0c2010-07-13 18:44:03 +00003947static int unixShmMap(
3948 sqlite3_file *fd, /* Handle open on database file */
3949 int iRegion, /* Region to retrieve */
3950 int szRegion, /* Size of regions */
3951 int bExtend, /* True to extend file if necessary */
3952 void volatile **pp /* OUT: Mapped memory */
drhd9e5c4f2010-05-12 18:01:39 +00003953){
danda9fe0c2010-07-13 18:44:03 +00003954 unixFile *pDbFd = (unixFile*)fd;
3955 unixShm *p;
3956 unixShmNode *pShmNode;
3957 int rc = SQLITE_OK;
drhd9e5c4f2010-05-12 18:01:39 +00003958
danda9fe0c2010-07-13 18:44:03 +00003959 /* If the shared-memory file has not yet been opened, open it now. */
3960 if( pDbFd->pShm==0 ){
3961 rc = unixOpenSharedMemory(pDbFd);
3962 if( rc!=SQLITE_OK ) return rc;
drhd9e5c4f2010-05-12 18:01:39 +00003963 }
drhd9e5c4f2010-05-12 18:01:39 +00003964
danda9fe0c2010-07-13 18:44:03 +00003965 p = pDbFd->pShm;
3966 pShmNode = p->pShmNode;
3967 sqlite3_mutex_enter(pShmNode->mutex);
3968 assert( szRegion==pShmNode->szRegion || pShmNode->nRegion==0 );
drh3cb93392011-03-12 18:10:44 +00003969 assert( pShmNode->pInode==pDbFd->pInode );
3970 assert( pShmNode->h>=0 || pDbFd->pInode->bProcessLock==1 );
3971 assert( pShmNode->h<0 || pDbFd->pInode->bProcessLock==0 );
danda9fe0c2010-07-13 18:44:03 +00003972
3973 if( pShmNode->nRegion<=iRegion ){
3974 char **apNew; /* New apRegion[] array */
3975 int nByte = (iRegion+1)*szRegion; /* Minimum required file size */
3976 struct stat sStat; /* Used by fstat() */
3977
3978 pShmNode->szRegion = szRegion;
3979
drh3cb93392011-03-12 18:10:44 +00003980 if( pShmNode->h>=0 ){
3981 /* The requested region is not mapped into this processes address space.
3982 ** Check to see if it has been allocated (i.e. if the wal-index file is
3983 ** large enough to contain the requested region).
danda9fe0c2010-07-13 18:44:03 +00003984 */
drh3cb93392011-03-12 18:10:44 +00003985 if( osFstat(pShmNode->h, &sStat) ){
3986 rc = SQLITE_IOERR_SHMSIZE;
danda9fe0c2010-07-13 18:44:03 +00003987 goto shmpage_out;
3988 }
drh3cb93392011-03-12 18:10:44 +00003989
3990 if( sStat.st_size<nByte ){
3991 /* The requested memory region does not exist. If bExtend is set to
3992 ** false, exit early. *pp will be set to NULL and SQLITE_OK returned.
3993 **
3994 ** Alternatively, if bExtend is true, use ftruncate() to allocate
3995 ** the requested memory region.
3996 */
3997 if( !bExtend ) goto shmpage_out;
3998 if( robust_ftruncate(pShmNode->h, nByte) ){
3999 rc = unixLogError(SQLITE_IOERR_SHMSIZE, "ftruncate",
4000 pShmNode->zFilename);
4001 goto shmpage_out;
4002 }
4003 }
danda9fe0c2010-07-13 18:44:03 +00004004 }
4005
4006 /* Map the requested memory region into this processes address space. */
4007 apNew = (char **)sqlite3_realloc(
4008 pShmNode->apRegion, (iRegion+1)*sizeof(char *)
4009 );
4010 if( !apNew ){
4011 rc = SQLITE_IOERR_NOMEM;
4012 goto shmpage_out;
4013 }
4014 pShmNode->apRegion = apNew;
4015 while(pShmNode->nRegion<=iRegion){
drh3cb93392011-03-12 18:10:44 +00004016 void *pMem;
4017 if( pShmNode->h>=0 ){
drh66dfec8b2011-06-01 20:01:49 +00004018 pMem = mmap(0, szRegion,
4019 pShmNode->isReadonly ? PROT_READ : PROT_READ|PROT_WRITE,
drh3cb93392011-03-12 18:10:44 +00004020 MAP_SHARED, pShmNode->h, pShmNode->nRegion*szRegion
4021 );
4022 if( pMem==MAP_FAILED ){
drh50990db2011-04-13 20:26:13 +00004023 rc = unixLogError(SQLITE_IOERR_SHMMAP, "mmap", pShmNode->zFilename);
drh3cb93392011-03-12 18:10:44 +00004024 goto shmpage_out;
4025 }
4026 }else{
4027 pMem = sqlite3_malloc(szRegion);
4028 if( pMem==0 ){
4029 rc = SQLITE_NOMEM;
4030 goto shmpage_out;
4031 }
4032 memset(pMem, 0, szRegion);
danda9fe0c2010-07-13 18:44:03 +00004033 }
4034 pShmNode->apRegion[pShmNode->nRegion] = pMem;
4035 pShmNode->nRegion++;
4036 }
4037 }
4038
4039shmpage_out:
4040 if( pShmNode->nRegion>iRegion ){
4041 *pp = pShmNode->apRegion[iRegion];
4042 }else{
4043 *pp = 0;
4044 }
drh66dfec8b2011-06-01 20:01:49 +00004045 if( pShmNode->isReadonly && rc==SQLITE_OK ) rc = SQLITE_READONLY;
danda9fe0c2010-07-13 18:44:03 +00004046 sqlite3_mutex_leave(pShmNode->mutex);
4047 return rc;
drhd9e5c4f2010-05-12 18:01:39 +00004048}
4049
4050/*
drhd9e5c4f2010-05-12 18:01:39 +00004051** Change the lock state for a shared-memory segment.
drh15d68092010-05-31 16:56:14 +00004052**
4053** Note that the relationship between SHAREd and EXCLUSIVE locks is a little
4054** different here than in posix. In xShmLock(), one can go from unlocked
4055** to shared and back or from unlocked to exclusive and back. But one may
4056** not go from shared to exclusive or from exclusive to shared.
drhd9e5c4f2010-05-12 18:01:39 +00004057*/
4058static int unixShmLock(
4059 sqlite3_file *fd, /* Database file holding the shared memory */
drh73b64e42010-05-30 19:55:15 +00004060 int ofst, /* First lock to acquire or release */
4061 int n, /* Number of locks to acquire or release */
4062 int flags /* What to do with the lock */
drhd9e5c4f2010-05-12 18:01:39 +00004063){
drh73b64e42010-05-30 19:55:15 +00004064 unixFile *pDbFd = (unixFile*)fd; /* Connection holding shared memory */
4065 unixShm *p = pDbFd->pShm; /* The shared memory being locked */
4066 unixShm *pX; /* For looping over all siblings */
4067 unixShmNode *pShmNode = p->pShmNode; /* The underlying file iNode */
4068 int rc = SQLITE_OK; /* Result code */
4069 u16 mask; /* Mask of locks to take or release */
drhd9e5c4f2010-05-12 18:01:39 +00004070
drhd91c68f2010-05-14 14:52:25 +00004071 assert( pShmNode==pDbFd->pInode->pShmNode );
4072 assert( pShmNode->pInode==pDbFd->pInode );
drhc99597c2010-05-31 01:41:15 +00004073 assert( ofst>=0 && ofst+n<=SQLITE_SHM_NLOCK );
drh73b64e42010-05-30 19:55:15 +00004074 assert( n>=1 );
4075 assert( flags==(SQLITE_SHM_LOCK | SQLITE_SHM_SHARED)
4076 || flags==(SQLITE_SHM_LOCK | SQLITE_SHM_EXCLUSIVE)
4077 || flags==(SQLITE_SHM_UNLOCK | SQLITE_SHM_SHARED)
4078 || flags==(SQLITE_SHM_UNLOCK | SQLITE_SHM_EXCLUSIVE) );
4079 assert( n==1 || (flags & SQLITE_SHM_EXCLUSIVE)!=0 );
drh3cb93392011-03-12 18:10:44 +00004080 assert( pShmNode->h>=0 || pDbFd->pInode->bProcessLock==1 );
4081 assert( pShmNode->h<0 || pDbFd->pInode->bProcessLock==0 );
drhd91c68f2010-05-14 14:52:25 +00004082
drhc99597c2010-05-31 01:41:15 +00004083 mask = (1<<(ofst+n)) - (1<<ofst);
drh73b64e42010-05-30 19:55:15 +00004084 assert( n>1 || mask==(1<<ofst) );
drhd91c68f2010-05-14 14:52:25 +00004085 sqlite3_mutex_enter(pShmNode->mutex);
drh73b64e42010-05-30 19:55:15 +00004086 if( flags & SQLITE_SHM_UNLOCK ){
4087 u16 allMask = 0; /* Mask of locks held by siblings */
4088
4089 /* See if any siblings hold this same lock */
4090 for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
4091 if( pX==p ) continue;
4092 assert( (pX->exclMask & (p->exclMask|p->sharedMask))==0 );
4093 allMask |= pX->sharedMask;
4094 }
4095
4096 /* Unlock the system-level locks */
4097 if( (mask & allMask)==0 ){
drhc99597c2010-05-31 01:41:15 +00004098 rc = unixShmSystemLock(pShmNode, F_UNLCK, ofst+UNIX_SHM_BASE, n);
drh73b64e42010-05-30 19:55:15 +00004099 }else{
drhd9e5c4f2010-05-12 18:01:39 +00004100 rc = SQLITE_OK;
drhd9e5c4f2010-05-12 18:01:39 +00004101 }
drh73b64e42010-05-30 19:55:15 +00004102
4103 /* Undo the local locks */
4104 if( rc==SQLITE_OK ){
4105 p->exclMask &= ~mask;
4106 p->sharedMask &= ~mask;
4107 }
4108 }else if( flags & SQLITE_SHM_SHARED ){
4109 u16 allShared = 0; /* Union of locks held by connections other than "p" */
4110
4111 /* Find out which shared locks are already held by sibling connections.
4112 ** If any sibling already holds an exclusive lock, go ahead and return
4113 ** SQLITE_BUSY.
4114 */
4115 for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
drh73b64e42010-05-30 19:55:15 +00004116 if( (pX->exclMask & mask)!=0 ){
drhd9e5c4f2010-05-12 18:01:39 +00004117 rc = SQLITE_BUSY;
drh73b64e42010-05-30 19:55:15 +00004118 break;
4119 }
4120 allShared |= pX->sharedMask;
4121 }
4122
4123 /* Get shared locks at the system level, if necessary */
4124 if( rc==SQLITE_OK ){
4125 if( (allShared & mask)==0 ){
drhc99597c2010-05-31 01:41:15 +00004126 rc = unixShmSystemLock(pShmNode, F_RDLCK, ofst+UNIX_SHM_BASE, n);
drhd9e5c4f2010-05-12 18:01:39 +00004127 }else{
drh73b64e42010-05-30 19:55:15 +00004128 rc = SQLITE_OK;
drhd9e5c4f2010-05-12 18:01:39 +00004129 }
drhd9e5c4f2010-05-12 18:01:39 +00004130 }
drh73b64e42010-05-30 19:55:15 +00004131
4132 /* Get the local shared locks */
4133 if( rc==SQLITE_OK ){
4134 p->sharedMask |= mask;
4135 }
4136 }else{
4137 /* Make sure no sibling connections hold locks that will block this
4138 ** lock. If any do, return SQLITE_BUSY right away.
4139 */
4140 for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
drh73b64e42010-05-30 19:55:15 +00004141 if( (pX->exclMask & mask)!=0 || (pX->sharedMask & mask)!=0 ){
4142 rc = SQLITE_BUSY;
4143 break;
4144 }
4145 }
4146
4147 /* Get the exclusive locks at the system level. Then if successful
4148 ** also mark the local connection as being locked.
4149 */
4150 if( rc==SQLITE_OK ){
drhc99597c2010-05-31 01:41:15 +00004151 rc = unixShmSystemLock(pShmNode, F_WRLCK, ofst+UNIX_SHM_BASE, n);
drhd9e5c4f2010-05-12 18:01:39 +00004152 if( rc==SQLITE_OK ){
drh15d68092010-05-31 16:56:14 +00004153 assert( (p->sharedMask & mask)==0 );
drh73b64e42010-05-30 19:55:15 +00004154 p->exclMask |= mask;
drhd9e5c4f2010-05-12 18:01:39 +00004155 }
drhd9e5c4f2010-05-12 18:01:39 +00004156 }
4157 }
drhd91c68f2010-05-14 14:52:25 +00004158 sqlite3_mutex_leave(pShmNode->mutex);
drh20e1f082010-05-31 16:10:12 +00004159 OSTRACE(("SHM-LOCK shmid-%d, pid-%d got %03x,%03x\n",
4160 p->id, getpid(), p->sharedMask, p->exclMask));
drhd9e5c4f2010-05-12 18:01:39 +00004161 return rc;
4162}
4163
drh286a2882010-05-20 23:51:06 +00004164/*
4165** Implement a memory barrier or memory fence on shared memory.
4166**
4167** All loads and stores begun before the barrier must complete before
4168** any load or store begun after the barrier.
4169*/
4170static void unixShmBarrier(
dan18801912010-06-14 14:07:50 +00004171 sqlite3_file *fd /* Database file holding the shared memory */
drh286a2882010-05-20 23:51:06 +00004172){
drhff828942010-06-26 21:34:06 +00004173 UNUSED_PARAMETER(fd);
drhb29ad852010-06-01 00:03:57 +00004174 unixEnterMutex();
4175 unixLeaveMutex();
drh286a2882010-05-20 23:51:06 +00004176}
4177
dan18801912010-06-14 14:07:50 +00004178/*
danda9fe0c2010-07-13 18:44:03 +00004179** Close a connection to shared-memory. Delete the underlying
4180** storage if deleteFlag is true.
drhe11fedc2010-07-14 00:14:30 +00004181**
4182** If there is no shared memory associated with the connection then this
4183** routine is a harmless no-op.
dan18801912010-06-14 14:07:50 +00004184*/
danda9fe0c2010-07-13 18:44:03 +00004185static int unixShmUnmap(
4186 sqlite3_file *fd, /* The underlying database file */
4187 int deleteFlag /* Delete shared-memory if true */
dan13a3cb82010-06-11 19:04:21 +00004188){
danda9fe0c2010-07-13 18:44:03 +00004189 unixShm *p; /* The connection to be closed */
4190 unixShmNode *pShmNode; /* The underlying shared-memory file */
4191 unixShm **pp; /* For looping over sibling connections */
4192 unixFile *pDbFd; /* The underlying database file */
dan13a3cb82010-06-11 19:04:21 +00004193
danda9fe0c2010-07-13 18:44:03 +00004194 pDbFd = (unixFile*)fd;
4195 p = pDbFd->pShm;
4196 if( p==0 ) return SQLITE_OK;
4197 pShmNode = p->pShmNode;
4198
4199 assert( pShmNode==pDbFd->pInode->pShmNode );
4200 assert( pShmNode->pInode==pDbFd->pInode );
4201
4202 /* Remove connection p from the set of connections associated
4203 ** with pShmNode */
dan18801912010-06-14 14:07:50 +00004204 sqlite3_mutex_enter(pShmNode->mutex);
danda9fe0c2010-07-13 18:44:03 +00004205 for(pp=&pShmNode->pFirst; (*pp)!=p; pp = &(*pp)->pNext){}
4206 *pp = p->pNext;
dan13a3cb82010-06-11 19:04:21 +00004207
danda9fe0c2010-07-13 18:44:03 +00004208 /* Free the connection p */
4209 sqlite3_free(p);
4210 pDbFd->pShm = 0;
dan18801912010-06-14 14:07:50 +00004211 sqlite3_mutex_leave(pShmNode->mutex);
danda9fe0c2010-07-13 18:44:03 +00004212
4213 /* If pShmNode->nRef has reached 0, then close the underlying
4214 ** shared-memory file, too */
4215 unixEnterMutex();
4216 assert( pShmNode->nRef>0 );
4217 pShmNode->nRef--;
4218 if( pShmNode->nRef==0 ){
drh036ac7f2011-08-08 23:18:05 +00004219 if( deleteFlag && pShmNode->h>=0 ) osUnlink(pShmNode->zFilename);
danda9fe0c2010-07-13 18:44:03 +00004220 unixShmPurge(pDbFd);
4221 }
4222 unixLeaveMutex();
4223
4224 return SQLITE_OK;
dan13a3cb82010-06-11 19:04:21 +00004225}
drh286a2882010-05-20 23:51:06 +00004226
danda9fe0c2010-07-13 18:44:03 +00004227
drhd9e5c4f2010-05-12 18:01:39 +00004228#else
drh6b017cc2010-06-14 18:01:46 +00004229# define unixShmMap 0
danda9fe0c2010-07-13 18:44:03 +00004230# define unixShmLock 0
drh286a2882010-05-20 23:51:06 +00004231# define unixShmBarrier 0
danda9fe0c2010-07-13 18:44:03 +00004232# define unixShmUnmap 0
drhd9e5c4f2010-05-12 18:01:39 +00004233#endif /* #ifndef SQLITE_OMIT_WAL */
4234
drh734c9862008-11-28 15:37:20 +00004235/*
4236** Here ends the implementation of all sqlite3_file methods.
4237**
4238********************** End sqlite3_file Methods *******************************
4239******************************************************************************/
4240
4241/*
drh6b9d6dd2008-12-03 19:34:47 +00004242** This division contains definitions of sqlite3_io_methods objects that
4243** implement various file locking strategies. It also contains definitions
4244** of "finder" functions. A finder-function is used to locate the appropriate
4245** sqlite3_io_methods object for a particular database file. The pAppData
4246** field of the sqlite3_vfs VFS objects are initialized to be pointers to
4247** the correct finder-function for that VFS.
4248**
4249** Most finder functions return a pointer to a fixed sqlite3_io_methods
4250** object. The only interesting finder-function is autolockIoFinder, which
4251** looks at the filesystem type and tries to guess the best locking
4252** strategy from that.
4253**
drh1875f7a2008-12-08 18:19:17 +00004254** For finder-funtion F, two objects are created:
4255**
4256** (1) The real finder-function named "FImpt()".
4257**
dane946c392009-08-22 11:39:46 +00004258** (2) A constant pointer to this function named just "F".
drh1875f7a2008-12-08 18:19:17 +00004259**
4260**
4261** A pointer to the F pointer is used as the pAppData value for VFS
4262** objects. We have to do this instead of letting pAppData point
4263** directly at the finder-function since C90 rules prevent a void*
4264** from be cast into a function pointer.
4265**
drh6b9d6dd2008-12-03 19:34:47 +00004266**
drh7708e972008-11-29 00:56:52 +00004267** Each instance of this macro generates two objects:
drh734c9862008-11-28 15:37:20 +00004268**
drh7708e972008-11-29 00:56:52 +00004269** * A constant sqlite3_io_methods object call METHOD that has locking
4270** methods CLOSE, LOCK, UNLOCK, CKRESLOCK.
4271**
4272** * An I/O method finder function called FINDER that returns a pointer
4273** to the METHOD object in the previous bullet.
drh734c9862008-11-28 15:37:20 +00004274*/
drhd9e5c4f2010-05-12 18:01:39 +00004275#define IOMETHODS(FINDER, METHOD, VERSION, CLOSE, LOCK, UNLOCK, CKLOCK) \
drh7708e972008-11-29 00:56:52 +00004276static const sqlite3_io_methods METHOD = { \
drhd9e5c4f2010-05-12 18:01:39 +00004277 VERSION, /* iVersion */ \
drh7708e972008-11-29 00:56:52 +00004278 CLOSE, /* xClose */ \
4279 unixRead, /* xRead */ \
4280 unixWrite, /* xWrite */ \
4281 unixTruncate, /* xTruncate */ \
4282 unixSync, /* xSync */ \
4283 unixFileSize, /* xFileSize */ \
4284 LOCK, /* xLock */ \
4285 UNLOCK, /* xUnlock */ \
4286 CKLOCK, /* xCheckReservedLock */ \
4287 unixFileControl, /* xFileControl */ \
4288 unixSectorSize, /* xSectorSize */ \
drhd9e5c4f2010-05-12 18:01:39 +00004289 unixDeviceCharacteristics, /* xDeviceCapabilities */ \
drh6b017cc2010-06-14 18:01:46 +00004290 unixShmMap, /* xShmMap */ \
danda9fe0c2010-07-13 18:44:03 +00004291 unixShmLock, /* xShmLock */ \
drh286a2882010-05-20 23:51:06 +00004292 unixShmBarrier, /* xShmBarrier */ \
danda9fe0c2010-07-13 18:44:03 +00004293 unixShmUnmap /* xShmUnmap */ \
drh7708e972008-11-29 00:56:52 +00004294}; \
drh0c2694b2009-09-03 16:23:44 +00004295static const sqlite3_io_methods *FINDER##Impl(const char *z, unixFile *p){ \
4296 UNUSED_PARAMETER(z); UNUSED_PARAMETER(p); \
drh7708e972008-11-29 00:56:52 +00004297 return &METHOD; \
drh1875f7a2008-12-08 18:19:17 +00004298} \
drh0c2694b2009-09-03 16:23:44 +00004299static const sqlite3_io_methods *(*const FINDER)(const char*,unixFile *p) \
drh1875f7a2008-12-08 18:19:17 +00004300 = FINDER##Impl;
drh7708e972008-11-29 00:56:52 +00004301
4302/*
4303** Here are all of the sqlite3_io_methods objects for each of the
4304** locking strategies. Functions that return pointers to these methods
4305** are also created.
4306*/
4307IOMETHODS(
4308 posixIoFinder, /* Finder function name */
4309 posixIoMethods, /* sqlite3_io_methods object name */
drh6e1f4822010-07-13 23:41:40 +00004310 2, /* shared memory is enabled */
drh7708e972008-11-29 00:56:52 +00004311 unixClose, /* xClose method */
4312 unixLock, /* xLock method */
4313 unixUnlock, /* xUnlock method */
4314 unixCheckReservedLock /* xCheckReservedLock method */
drh1875f7a2008-12-08 18:19:17 +00004315)
drh7708e972008-11-29 00:56:52 +00004316IOMETHODS(
4317 nolockIoFinder, /* Finder function name */
4318 nolockIoMethods, /* sqlite3_io_methods object name */
drh6e1f4822010-07-13 23:41:40 +00004319 1, /* shared memory is disabled */
drh7708e972008-11-29 00:56:52 +00004320 nolockClose, /* xClose method */
4321 nolockLock, /* xLock method */
4322 nolockUnlock, /* xUnlock method */
4323 nolockCheckReservedLock /* xCheckReservedLock method */
drh1875f7a2008-12-08 18:19:17 +00004324)
drh7708e972008-11-29 00:56:52 +00004325IOMETHODS(
4326 dotlockIoFinder, /* Finder function name */
4327 dotlockIoMethods, /* sqlite3_io_methods object name */
drh6e1f4822010-07-13 23:41:40 +00004328 1, /* shared memory is disabled */
drh7708e972008-11-29 00:56:52 +00004329 dotlockClose, /* xClose method */
4330 dotlockLock, /* xLock method */
4331 dotlockUnlock, /* xUnlock method */
4332 dotlockCheckReservedLock /* xCheckReservedLock method */
drh1875f7a2008-12-08 18:19:17 +00004333)
drh7708e972008-11-29 00:56:52 +00004334
chw78a13182009-04-07 05:35:03 +00004335#if SQLITE_ENABLE_LOCKING_STYLE && !OS_VXWORKS
drh7708e972008-11-29 00:56:52 +00004336IOMETHODS(
4337 flockIoFinder, /* Finder function name */
4338 flockIoMethods, /* sqlite3_io_methods object name */
drh6e1f4822010-07-13 23:41:40 +00004339 1, /* shared memory is disabled */
drh7708e972008-11-29 00:56:52 +00004340 flockClose, /* xClose method */
4341 flockLock, /* xLock method */
4342 flockUnlock, /* xUnlock method */
4343 flockCheckReservedLock /* xCheckReservedLock method */
drh1875f7a2008-12-08 18:19:17 +00004344)
drh7708e972008-11-29 00:56:52 +00004345#endif
4346
drh6c7d5c52008-11-21 20:32:33 +00004347#if OS_VXWORKS
drh7708e972008-11-29 00:56:52 +00004348IOMETHODS(
4349 semIoFinder, /* Finder function name */
4350 semIoMethods, /* sqlite3_io_methods object name */
drh6e1f4822010-07-13 23:41:40 +00004351 1, /* shared memory is disabled */
drh7708e972008-11-29 00:56:52 +00004352 semClose, /* xClose method */
4353 semLock, /* xLock method */
4354 semUnlock, /* xUnlock method */
4355 semCheckReservedLock /* xCheckReservedLock method */
drh1875f7a2008-12-08 18:19:17 +00004356)
aswiftaebf4132008-11-21 00:10:35 +00004357#endif
drh7708e972008-11-29 00:56:52 +00004358
drhd2cb50b2009-01-09 21:41:17 +00004359#if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE
drh7708e972008-11-29 00:56:52 +00004360IOMETHODS(
4361 afpIoFinder, /* Finder function name */
4362 afpIoMethods, /* sqlite3_io_methods object name */
drh6e1f4822010-07-13 23:41:40 +00004363 1, /* shared memory is disabled */
drh7708e972008-11-29 00:56:52 +00004364 afpClose, /* xClose method */
4365 afpLock, /* xLock method */
4366 afpUnlock, /* xUnlock method */
4367 afpCheckReservedLock /* xCheckReservedLock method */
drh1875f7a2008-12-08 18:19:17 +00004368)
drh715ff302008-12-03 22:32:44 +00004369#endif
4370
4371/*
4372** The proxy locking method is a "super-method" in the sense that it
4373** opens secondary file descriptors for the conch and lock files and
4374** it uses proxy, dot-file, AFP, and flock() locking methods on those
4375** secondary files. For this reason, the division that implements
4376** proxy locking is located much further down in the file. But we need
4377** to go ahead and define the sqlite3_io_methods and finder function
4378** for proxy locking here. So we forward declare the I/O methods.
4379*/
drhd2cb50b2009-01-09 21:41:17 +00004380#if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE
drh715ff302008-12-03 22:32:44 +00004381static int proxyClose(sqlite3_file*);
4382static int proxyLock(sqlite3_file*, int);
4383static int proxyUnlock(sqlite3_file*, int);
4384static int proxyCheckReservedLock(sqlite3_file*, int*);
drh7708e972008-11-29 00:56:52 +00004385IOMETHODS(
4386 proxyIoFinder, /* Finder function name */
4387 proxyIoMethods, /* sqlite3_io_methods object name */
drh6e1f4822010-07-13 23:41:40 +00004388 1, /* shared memory is disabled */
drh7708e972008-11-29 00:56:52 +00004389 proxyClose, /* xClose method */
4390 proxyLock, /* xLock method */
4391 proxyUnlock, /* xUnlock method */
4392 proxyCheckReservedLock /* xCheckReservedLock method */
drh1875f7a2008-12-08 18:19:17 +00004393)
aswiftaebf4132008-11-21 00:10:35 +00004394#endif
drh7708e972008-11-29 00:56:52 +00004395
drh7ed97b92010-01-20 13:07:21 +00004396/* nfs lockd on OSX 10.3+ doesn't clear write locks when a read lock is set */
4397#if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE
4398IOMETHODS(
4399 nfsIoFinder, /* Finder function name */
4400 nfsIoMethods, /* sqlite3_io_methods object name */
drh6e1f4822010-07-13 23:41:40 +00004401 1, /* shared memory is disabled */
drh7ed97b92010-01-20 13:07:21 +00004402 unixClose, /* xClose method */
4403 unixLock, /* xLock method */
4404 nfsUnlock, /* xUnlock method */
4405 unixCheckReservedLock /* xCheckReservedLock method */
4406)
4407#endif
drh7708e972008-11-29 00:56:52 +00004408
drhd2cb50b2009-01-09 21:41:17 +00004409#if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE
drh7708e972008-11-29 00:56:52 +00004410/*
drh6b9d6dd2008-12-03 19:34:47 +00004411** This "finder" function attempts to determine the best locking strategy
4412** for the database file "filePath". It then returns the sqlite3_io_methods
drh7708e972008-11-29 00:56:52 +00004413** object that implements that strategy.
4414**
4415** This is for MacOSX only.
4416*/
drh1875f7a2008-12-08 18:19:17 +00004417static const sqlite3_io_methods *autolockIoFinderImpl(
drh7708e972008-11-29 00:56:52 +00004418 const char *filePath, /* name of the database file */
drh0c2694b2009-09-03 16:23:44 +00004419 unixFile *pNew /* open file object for the database file */
drh7708e972008-11-29 00:56:52 +00004420){
4421 static const struct Mapping {
drh6b9d6dd2008-12-03 19:34:47 +00004422 const char *zFilesystem; /* Filesystem type name */
4423 const sqlite3_io_methods *pMethods; /* Appropriate locking method */
drh7708e972008-11-29 00:56:52 +00004424 } aMap[] = {
4425 { "hfs", &posixIoMethods },
4426 { "ufs", &posixIoMethods },
4427 { "afpfs", &afpIoMethods },
drh7708e972008-11-29 00:56:52 +00004428 { "smbfs", &afpIoMethods },
drh7708e972008-11-29 00:56:52 +00004429 { "webdav", &nolockIoMethods },
4430 { 0, 0 }
4431 };
4432 int i;
4433 struct statfs fsInfo;
4434 struct flock lockInfo;
4435
4436 if( !filePath ){
drh6b9d6dd2008-12-03 19:34:47 +00004437 /* If filePath==NULL that means we are dealing with a transient file
4438 ** that does not need to be locked. */
drh7708e972008-11-29 00:56:52 +00004439 return &nolockIoMethods;
4440 }
4441 if( statfs(filePath, &fsInfo) != -1 ){
4442 if( fsInfo.f_flags & MNT_RDONLY ){
4443 return &nolockIoMethods;
4444 }
4445 for(i=0; aMap[i].zFilesystem; i++){
4446 if( strcmp(fsInfo.f_fstypename, aMap[i].zFilesystem)==0 ){
4447 return aMap[i].pMethods;
4448 }
4449 }
4450 }
4451
4452 /* Default case. Handles, amongst others, "nfs".
4453 ** Test byte-range lock using fcntl(). If the call succeeds,
4454 ** assume that the file-system supports POSIX style locks.
drh734c9862008-11-28 15:37:20 +00004455 */
drh7708e972008-11-29 00:56:52 +00004456 lockInfo.l_len = 1;
4457 lockInfo.l_start = 0;
4458 lockInfo.l_whence = SEEK_SET;
4459 lockInfo.l_type = F_RDLCK;
drh99ab3b12011-03-02 15:09:07 +00004460 if( osFcntl(pNew->h, F_GETLK, &lockInfo)!=-1 ) {
drh7ed97b92010-01-20 13:07:21 +00004461 if( strcmp(fsInfo.f_fstypename, "nfs")==0 ){
4462 return &nfsIoMethods;
4463 } else {
4464 return &posixIoMethods;
4465 }
drh7708e972008-11-29 00:56:52 +00004466 }else{
4467 return &dotlockIoMethods;
4468 }
4469}
drh0c2694b2009-09-03 16:23:44 +00004470static const sqlite3_io_methods
4471 *(*const autolockIoFinder)(const char*,unixFile*) = autolockIoFinderImpl;
drh1875f7a2008-12-08 18:19:17 +00004472
drhd2cb50b2009-01-09 21:41:17 +00004473#endif /* defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE */
drh7708e972008-11-29 00:56:52 +00004474
chw78a13182009-04-07 05:35:03 +00004475#if OS_VXWORKS && SQLITE_ENABLE_LOCKING_STYLE
4476/*
4477** This "finder" function attempts to determine the best locking strategy
4478** for the database file "filePath". It then returns the sqlite3_io_methods
4479** object that implements that strategy.
4480**
4481** This is for VXWorks only.
4482*/
4483static const sqlite3_io_methods *autolockIoFinderImpl(
4484 const char *filePath, /* name of the database file */
drh0c2694b2009-09-03 16:23:44 +00004485 unixFile *pNew /* the open file object */
chw78a13182009-04-07 05:35:03 +00004486){
4487 struct flock lockInfo;
4488
4489 if( !filePath ){
4490 /* If filePath==NULL that means we are dealing with a transient file
4491 ** that does not need to be locked. */
4492 return &nolockIoMethods;
4493 }
4494
4495 /* Test if fcntl() is supported and use POSIX style locks.
4496 ** Otherwise fall back to the named semaphore method.
4497 */
4498 lockInfo.l_len = 1;
4499 lockInfo.l_start = 0;
4500 lockInfo.l_whence = SEEK_SET;
4501 lockInfo.l_type = F_RDLCK;
drh99ab3b12011-03-02 15:09:07 +00004502 if( osFcntl(pNew->h, F_GETLK, &lockInfo)!=-1 ) {
chw78a13182009-04-07 05:35:03 +00004503 return &posixIoMethods;
4504 }else{
4505 return &semIoMethods;
4506 }
4507}
drh0c2694b2009-09-03 16:23:44 +00004508static const sqlite3_io_methods
4509 *(*const autolockIoFinder)(const char*,unixFile*) = autolockIoFinderImpl;
chw78a13182009-04-07 05:35:03 +00004510
4511#endif /* OS_VXWORKS && SQLITE_ENABLE_LOCKING_STYLE */
4512
drh7708e972008-11-29 00:56:52 +00004513/*
4514** An abstract type for a pointer to a IO method finder function:
4515*/
drh0c2694b2009-09-03 16:23:44 +00004516typedef const sqlite3_io_methods *(*finder_type)(const char*,unixFile*);
drh7708e972008-11-29 00:56:52 +00004517
aswiftaebf4132008-11-21 00:10:35 +00004518
drh734c9862008-11-28 15:37:20 +00004519/****************************************************************************
4520**************************** sqlite3_vfs methods ****************************
4521**
4522** This division contains the implementation of methods on the
4523** sqlite3_vfs object.
4524*/
4525
danielk1977a3d4c882007-03-23 10:08:38 +00004526/*
danielk1977e339d652008-06-28 11:23:00 +00004527** Initialize the contents of the unixFile structure pointed to by pId.
danielk1977ad94b582007-08-20 06:44:22 +00004528*/
4529static int fillInUnixFile(
danielk1977e339d652008-06-28 11:23:00 +00004530 sqlite3_vfs *pVfs, /* Pointer to vfs object */
drhbfe66312006-10-03 17:40:40 +00004531 int h, /* Open file descriptor of file being opened */
drh0059eae2011-08-08 23:48:40 +00004532 int syncDir, /* True to sync directory on first sync */
drh218c5082008-03-07 00:27:10 +00004533 sqlite3_file *pId, /* Write to the unixFile structure here */
drhda0e7682008-07-30 15:27:54 +00004534 const char *zFilename, /* Name of the file being opened */
chw97185482008-11-17 08:05:31 +00004535 int noLock, /* Omit locking if true */
drh77197112011-03-15 19:08:48 +00004536 int isDelete, /* Delete on close if true */
4537 int isReadOnly /* True if the file is opened read-only */
drhbfe66312006-10-03 17:40:40 +00004538){
drh7708e972008-11-29 00:56:52 +00004539 const sqlite3_io_methods *pLockingStyle;
drhda0e7682008-07-30 15:27:54 +00004540 unixFile *pNew = (unixFile *)pId;
4541 int rc = SQLITE_OK;
4542
drh8af6c222010-05-14 12:43:01 +00004543 assert( pNew->pInode==NULL );
drh218c5082008-03-07 00:27:10 +00004544
dane946c392009-08-22 11:39:46 +00004545 /* Parameter isDelete is only used on vxworks. Express this explicitly
4546 ** here to prevent compiler warnings about unused parameters.
danielk1977a03396a2008-11-19 14:35:46 +00004547 */
drh7708e972008-11-29 00:56:52 +00004548 UNUSED_PARAMETER(isDelete);
danielk1977a03396a2008-11-19 14:35:46 +00004549
dan00157392010-10-05 11:33:15 +00004550 /* Usually the path zFilename should not be a relative pathname. The
4551 ** exception is when opening the proxy "conch" file in builds that
4552 ** include the special Apple locking styles.
4553 */
dan00157392010-10-05 11:33:15 +00004554#if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE
drhf7f55ed2010-10-05 18:22:47 +00004555 assert( zFilename==0 || zFilename[0]=='/'
4556 || pVfs->pAppData==(void*)&autolockIoFinder );
4557#else
4558 assert( zFilename==0 || zFilename[0]=='/' );
dan00157392010-10-05 11:33:15 +00004559#endif
dan00157392010-10-05 11:33:15 +00004560
drh308c2a52010-05-14 11:30:18 +00004561 OSTRACE(("OPEN %-3d %s\n", h, zFilename));
danielk1977ad94b582007-08-20 06:44:22 +00004562 pNew->h = h;
drhd9e5c4f2010-05-12 18:01:39 +00004563 pNew->zPath = zFilename;
drha7e61d82011-03-12 17:02:57 +00004564 if( memcmp(pVfs->zName,"unix-excl",10)==0 ){
4565 pNew->ctrlFlags = UNIXFILE_EXCL;
4566 }else{
4567 pNew->ctrlFlags = 0;
4568 }
drh77197112011-03-15 19:08:48 +00004569 if( isReadOnly ){
4570 pNew->ctrlFlags |= UNIXFILE_RDONLY;
4571 }
drh0059eae2011-08-08 23:48:40 +00004572 if( syncDir ){
4573 pNew->ctrlFlags |= UNIXFILE_DIRSYNC;
4574 }
drh339eb0b2008-03-07 15:34:11 +00004575
drh6c7d5c52008-11-21 20:32:33 +00004576#if OS_VXWORKS
drh107886a2008-11-21 22:21:50 +00004577 pNew->pId = vxworksFindFileId(zFilename);
4578 if( pNew->pId==0 ){
4579 noLock = 1;
4580 rc = SQLITE_NOMEM;
chw97185482008-11-17 08:05:31 +00004581 }
4582#endif
4583
drhda0e7682008-07-30 15:27:54 +00004584 if( noLock ){
drh7708e972008-11-29 00:56:52 +00004585 pLockingStyle = &nolockIoMethods;
drhda0e7682008-07-30 15:27:54 +00004586 }else{
drh0c2694b2009-09-03 16:23:44 +00004587 pLockingStyle = (**(finder_type*)pVfs->pAppData)(zFilename, pNew);
aswiftaebf4132008-11-21 00:10:35 +00004588#if SQLITE_ENABLE_LOCKING_STYLE
4589 /* Cache zFilename in the locking context (AFP and dotlock override) for
4590 ** proxyLock activation is possible (remote proxy is based on db name)
4591 ** zFilename remains valid until file is closed, to support */
4592 pNew->lockingContext = (void*)zFilename;
4593#endif
drhda0e7682008-07-30 15:27:54 +00004594 }
danielk1977e339d652008-06-28 11:23:00 +00004595
drh7ed97b92010-01-20 13:07:21 +00004596 if( pLockingStyle == &posixIoMethods
4597#if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE
4598 || pLockingStyle == &nfsIoMethods
4599#endif
4600 ){
drh7708e972008-11-29 00:56:52 +00004601 unixEnterMutex();
drh8af6c222010-05-14 12:43:01 +00004602 rc = findInodeInfo(pNew, &pNew->pInode);
dane946c392009-08-22 11:39:46 +00004603 if( rc!=SQLITE_OK ){
drh8af6c222010-05-14 12:43:01 +00004604 /* If an error occured in findInodeInfo(), close the file descriptor
4605 ** immediately, before releasing the mutex. findInodeInfo() may fail
dane946c392009-08-22 11:39:46 +00004606 ** in two scenarios:
4607 **
4608 ** (a) A call to fstat() failed.
4609 ** (b) A malloc failed.
4610 **
4611 ** Scenario (b) may only occur if the process is holding no other
4612 ** file descriptors open on the same file. If there were other file
4613 ** descriptors on this file, then no malloc would be required by
drh8af6c222010-05-14 12:43:01 +00004614 ** findInodeInfo(). If this is the case, it is quite safe to close
dane946c392009-08-22 11:39:46 +00004615 ** handle h - as it is guaranteed that no posix locks will be released
4616 ** by doing so.
4617 **
4618 ** If scenario (a) caused the error then things are not so safe. The
4619 ** implicit assumption here is that if fstat() fails, things are in
4620 ** such bad shape that dropping a lock or two doesn't matter much.
4621 */
drh0e9365c2011-03-02 02:08:13 +00004622 robust_close(pNew, h, __LINE__);
dane946c392009-08-22 11:39:46 +00004623 h = -1;
4624 }
drh7708e972008-11-29 00:56:52 +00004625 unixLeaveMutex();
4626 }
danielk1977e339d652008-06-28 11:23:00 +00004627
drhd2cb50b2009-01-09 21:41:17 +00004628#if SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__)
aswiftf0551ee2008-12-03 21:26:19 +00004629 else if( pLockingStyle == &afpIoMethods ){
drh7708e972008-11-29 00:56:52 +00004630 /* AFP locking uses the file path so it needs to be included in
4631 ** the afpLockingContext.
4632 */
4633 afpLockingContext *pCtx;
4634 pNew->lockingContext = pCtx = sqlite3_malloc( sizeof(*pCtx) );
4635 if( pCtx==0 ){
4636 rc = SQLITE_NOMEM;
4637 }else{
4638 /* NB: zFilename exists and remains valid until the file is closed
4639 ** according to requirement F11141. So we do not need to make a
4640 ** copy of the filename. */
4641 pCtx->dbPath = zFilename;
drh7ed97b92010-01-20 13:07:21 +00004642 pCtx->reserved = 0;
drh7708e972008-11-29 00:56:52 +00004643 srandomdev();
drh6c7d5c52008-11-21 20:32:33 +00004644 unixEnterMutex();
drh8af6c222010-05-14 12:43:01 +00004645 rc = findInodeInfo(pNew, &pNew->pInode);
drh7ed97b92010-01-20 13:07:21 +00004646 if( rc!=SQLITE_OK ){
4647 sqlite3_free(pNew->lockingContext);
drh0e9365c2011-03-02 02:08:13 +00004648 robust_close(pNew, h, __LINE__);
drh7ed97b92010-01-20 13:07:21 +00004649 h = -1;
4650 }
drh7708e972008-11-29 00:56:52 +00004651 unixLeaveMutex();
drhbfe66312006-10-03 17:40:40 +00004652 }
drh7708e972008-11-29 00:56:52 +00004653 }
4654#endif
danielk1977e339d652008-06-28 11:23:00 +00004655
drh7708e972008-11-29 00:56:52 +00004656 else if( pLockingStyle == &dotlockIoMethods ){
4657 /* Dotfile locking uses the file path so it needs to be included in
4658 ** the dotlockLockingContext
4659 */
4660 char *zLockFile;
4661 int nFilename;
drhea678832008-12-10 19:26:22 +00004662 nFilename = (int)strlen(zFilename) + 6;
drh7708e972008-11-29 00:56:52 +00004663 zLockFile = (char *)sqlite3_malloc(nFilename);
4664 if( zLockFile==0 ){
4665 rc = SQLITE_NOMEM;
4666 }else{
4667 sqlite3_snprintf(nFilename, zLockFile, "%s" DOTLOCK_SUFFIX, zFilename);
danielk1977e339d652008-06-28 11:23:00 +00004668 }
drh7708e972008-11-29 00:56:52 +00004669 pNew->lockingContext = zLockFile;
4670 }
danielk1977e339d652008-06-28 11:23:00 +00004671
drh6c7d5c52008-11-21 20:32:33 +00004672#if OS_VXWORKS
drh7708e972008-11-29 00:56:52 +00004673 else if( pLockingStyle == &semIoMethods ){
4674 /* Named semaphore locking uses the file path so it needs to be
4675 ** included in the semLockingContext
4676 */
4677 unixEnterMutex();
drh8af6c222010-05-14 12:43:01 +00004678 rc = findInodeInfo(pNew, &pNew->pInode);
4679 if( (rc==SQLITE_OK) && (pNew->pInode->pSem==NULL) ){
4680 char *zSemName = pNew->pInode->aSemName;
drh7708e972008-11-29 00:56:52 +00004681 int n;
drh2238dcc2009-08-27 17:56:20 +00004682 sqlite3_snprintf(MAX_PATHNAME, zSemName, "/%s.sem",
drh7708e972008-11-29 00:56:52 +00004683 pNew->pId->zCanonicalName);
drh2238dcc2009-08-27 17:56:20 +00004684 for( n=1; zSemName[n]; n++ )
drh7708e972008-11-29 00:56:52 +00004685 if( zSemName[n]=='/' ) zSemName[n] = '_';
drh8af6c222010-05-14 12:43:01 +00004686 pNew->pInode->pSem = sem_open(zSemName, O_CREAT, 0666, 1);
4687 if( pNew->pInode->pSem == SEM_FAILED ){
drh7708e972008-11-29 00:56:52 +00004688 rc = SQLITE_NOMEM;
drh8af6c222010-05-14 12:43:01 +00004689 pNew->pInode->aSemName[0] = '\0';
chw97185482008-11-17 08:05:31 +00004690 }
chw97185482008-11-17 08:05:31 +00004691 }
drh7708e972008-11-29 00:56:52 +00004692 unixLeaveMutex();
danielk1977e339d652008-06-28 11:23:00 +00004693 }
drh7708e972008-11-29 00:56:52 +00004694#endif
aswift5b1a2562008-08-22 00:22:35 +00004695
4696 pNew->lastErrno = 0;
drh6c7d5c52008-11-21 20:32:33 +00004697#if OS_VXWORKS
chw97185482008-11-17 08:05:31 +00004698 if( rc!=SQLITE_OK ){
drh0e9365c2011-03-02 02:08:13 +00004699 if( h>=0 ) robust_close(pNew, h, __LINE__);
drh309e6552010-02-05 18:00:26 +00004700 h = -1;
drh036ac7f2011-08-08 23:18:05 +00004701 osUnlink(zFilename);
chw97185482008-11-17 08:05:31 +00004702 isDelete = 0;
4703 }
4704 pNew->isDelete = isDelete;
4705#endif
danielk1977e339d652008-06-28 11:23:00 +00004706 if( rc!=SQLITE_OK ){
drh0e9365c2011-03-02 02:08:13 +00004707 if( h>=0 ) robust_close(pNew, h, __LINE__);
danielk1977e339d652008-06-28 11:23:00 +00004708 }else{
drh7708e972008-11-29 00:56:52 +00004709 pNew->pMethod = pLockingStyle;
danielk1977e339d652008-06-28 11:23:00 +00004710 OpenCounter(+1);
drhbfe66312006-10-03 17:40:40 +00004711 }
danielk1977e339d652008-06-28 11:23:00 +00004712 return rc;
drh054889e2005-11-30 03:20:31 +00004713}
drh9c06c952005-11-26 00:25:00 +00004714
danielk1977ad94b582007-08-20 06:44:22 +00004715/*
drh8b3cf822010-06-01 21:02:51 +00004716** Return the name of a directory in which to put temporary files.
4717** If no suitable temporary file directory can be found, return NULL.
danielk197717b90b52008-06-06 11:11:25 +00004718*/
drh7234c6d2010-06-19 15:10:09 +00004719static const char *unixTempFileDir(void){
danielk197717b90b52008-06-06 11:11:25 +00004720 static const char *azDirs[] = {
4721 0,
aswiftaebf4132008-11-21 00:10:35 +00004722 0,
danielk197717b90b52008-06-06 11:11:25 +00004723 "/var/tmp",
4724 "/usr/tmp",
4725 "/tmp",
drh8b3cf822010-06-01 21:02:51 +00004726 0 /* List terminator */
danielk197717b90b52008-06-06 11:11:25 +00004727 };
drh8b3cf822010-06-01 21:02:51 +00004728 unsigned int i;
4729 struct stat buf;
4730 const char *zDir = 0;
4731
4732 azDirs[0] = sqlite3_temp_directory;
4733 if( !azDirs[1] ) azDirs[1] = getenv("TMPDIR");
drh19515c82010-06-19 23:53:11 +00004734 for(i=0; i<sizeof(azDirs)/sizeof(azDirs[0]); zDir=azDirs[i++]){
drh8b3cf822010-06-01 21:02:51 +00004735 if( zDir==0 ) continue;
drh99ab3b12011-03-02 15:09:07 +00004736 if( osStat(zDir, &buf) ) continue;
drh8b3cf822010-06-01 21:02:51 +00004737 if( !S_ISDIR(buf.st_mode) ) continue;
drh99ab3b12011-03-02 15:09:07 +00004738 if( osAccess(zDir, 07) ) continue;
drh8b3cf822010-06-01 21:02:51 +00004739 break;
4740 }
4741 return zDir;
4742}
4743
4744/*
4745** Create a temporary file name in zBuf. zBuf must be allocated
4746** by the calling process and must be big enough to hold at least
4747** pVfs->mxPathname bytes.
4748*/
4749static int unixGetTempname(int nBuf, char *zBuf){
danielk197717b90b52008-06-06 11:11:25 +00004750 static const unsigned char zChars[] =
4751 "abcdefghijklmnopqrstuvwxyz"
4752 "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
4753 "0123456789";
drh41022642008-11-21 00:24:42 +00004754 unsigned int i, j;
drh8b3cf822010-06-01 21:02:51 +00004755 const char *zDir;
danielk197717b90b52008-06-06 11:11:25 +00004756
4757 /* It's odd to simulate an io-error here, but really this is just
4758 ** using the io-error infrastructure to test that SQLite handles this
4759 ** function failing.
4760 */
4761 SimulateIOError( return SQLITE_IOERR );
4762
drh7234c6d2010-06-19 15:10:09 +00004763 zDir = unixTempFileDir();
drh8b3cf822010-06-01 21:02:51 +00004764 if( zDir==0 ) zDir = ".";
danielk197717b90b52008-06-06 11:11:25 +00004765
4766 /* Check that the output buffer is large enough for the temporary file
4767 ** name. If it is not, return SQLITE_ERROR.
4768 */
danielk197700e13612008-11-17 19:18:54 +00004769 if( (strlen(zDir) + strlen(SQLITE_TEMP_FILE_PREFIX) + 17) >= (size_t)nBuf ){
danielk197717b90b52008-06-06 11:11:25 +00004770 return SQLITE_ERROR;
4771 }
4772
4773 do{
4774 sqlite3_snprintf(nBuf-17, zBuf, "%s/"SQLITE_TEMP_FILE_PREFIX, zDir);
drhea678832008-12-10 19:26:22 +00004775 j = (int)strlen(zBuf);
danielk197717b90b52008-06-06 11:11:25 +00004776 sqlite3_randomness(15, &zBuf[j]);
4777 for(i=0; i<15; i++, j++){
4778 zBuf[j] = (char)zChars[ ((unsigned char)zBuf[j])%(sizeof(zChars)-1) ];
4779 }
4780 zBuf[j] = 0;
drh99ab3b12011-03-02 15:09:07 +00004781 }while( osAccess(zBuf,0)==0 );
danielk197717b90b52008-06-06 11:11:25 +00004782 return SQLITE_OK;
4783}
4784
drhd2cb50b2009-01-09 21:41:17 +00004785#if SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__)
drhc66d5b62008-12-03 22:48:32 +00004786/*
4787** Routine to transform a unixFile into a proxy-locking unixFile.
4788** Implementation in the proxy-lock division, but used by unixOpen()
4789** if SQLITE_PREFER_PROXY_LOCKING is defined.
4790*/
4791static int proxyTransformUnixFile(unixFile*, const char*);
drh947bd802008-12-04 12:34:15 +00004792#endif
drhc66d5b62008-12-03 22:48:32 +00004793
dan08da86a2009-08-21 17:18:03 +00004794/*
4795** Search for an unused file descriptor that was opened on the database
4796** file (not a journal or master-journal file) identified by pathname
4797** zPath with SQLITE_OPEN_XXX flags matching those passed as the second
4798** argument to this function.
4799**
4800** Such a file descriptor may exist if a database connection was closed
4801** but the associated file descriptor could not be closed because some
4802** other file descriptor open on the same file is holding a file-lock.
4803** Refer to comments in the unixClose() function and the lengthy comment
4804** describing "Posix Advisory Locking" at the start of this file for
4805** further details. Also, ticket #4018.
4806**
4807** If a suitable file descriptor is found, then it is returned. If no
4808** such file descriptor is located, -1 is returned.
4809*/
dane946c392009-08-22 11:39:46 +00004810static UnixUnusedFd *findReusableFd(const char *zPath, int flags){
4811 UnixUnusedFd *pUnused = 0;
4812
4813 /* Do not search for an unused file descriptor on vxworks. Not because
4814 ** vxworks would not benefit from the change (it might, we're not sure),
4815 ** but because no way to test it is currently available. It is better
4816 ** not to risk breaking vxworks support for the sake of such an obscure
4817 ** feature. */
4818#if !OS_VXWORKS
dan08da86a2009-08-21 17:18:03 +00004819 struct stat sStat; /* Results of stat() call */
4820
4821 /* A stat() call may fail for various reasons. If this happens, it is
4822 ** almost certain that an open() call on the same path will also fail.
4823 ** For this reason, if an error occurs in the stat() call here, it is
4824 ** ignored and -1 is returned. The caller will try to open a new file
4825 ** descriptor on the same path, fail, and return an error to SQLite.
4826 **
4827 ** Even if a subsequent open() call does succeed, the consequences of
4828 ** not searching for a resusable file descriptor are not dire. */
drh58384f12011-07-28 00:14:45 +00004829 if( 0==osStat(zPath, &sStat) ){
drhd91c68f2010-05-14 14:52:25 +00004830 unixInodeInfo *pInode;
dan08da86a2009-08-21 17:18:03 +00004831
4832 unixEnterMutex();
drh8af6c222010-05-14 12:43:01 +00004833 pInode = inodeList;
4834 while( pInode && (pInode->fileId.dev!=sStat.st_dev
4835 || pInode->fileId.ino!=sStat.st_ino) ){
4836 pInode = pInode->pNext;
drh9061ad12010-01-05 00:14:49 +00004837 }
drh8af6c222010-05-14 12:43:01 +00004838 if( pInode ){
dane946c392009-08-22 11:39:46 +00004839 UnixUnusedFd **pp;
drh8af6c222010-05-14 12:43:01 +00004840 for(pp=&pInode->pUnused; *pp && (*pp)->flags!=flags; pp=&((*pp)->pNext));
dane946c392009-08-22 11:39:46 +00004841 pUnused = *pp;
4842 if( pUnused ){
4843 *pp = pUnused->pNext;
dan08da86a2009-08-21 17:18:03 +00004844 }
4845 }
4846 unixLeaveMutex();
4847 }
dane946c392009-08-22 11:39:46 +00004848#endif /* if !OS_VXWORKS */
4849 return pUnused;
dan08da86a2009-08-21 17:18:03 +00004850}
danielk197717b90b52008-06-06 11:11:25 +00004851
4852/*
danddb0ac42010-07-14 14:48:58 +00004853** This function is called by unixOpen() to determine the unix permissions
drhf65bc912010-07-14 20:51:34 +00004854** to create new files with. If no error occurs, then SQLITE_OK is returned
danddb0ac42010-07-14 14:48:58 +00004855** and a value suitable for passing as the third argument to open(2) is
4856** written to *pMode. If an IO error occurs, an SQLite error code is
4857** returned and the value of *pMode is not modified.
4858**
4859** If the file being opened is a temporary file, it is always created with
4860** the octal permissions 0600 (read/writable by owner only). If the file
drh8ab58662010-07-15 18:38:39 +00004861** is a database or master journal file, it is created with the permissions
4862** mask SQLITE_DEFAULT_FILE_PERMISSIONS.
danddb0ac42010-07-14 14:48:58 +00004863**
drh8ab58662010-07-15 18:38:39 +00004864** Finally, if the file being opened is a WAL or regular journal file, then
4865** this function queries the file-system for the permissions on the
4866** corresponding database file and sets *pMode to this value. Whenever
4867** possible, WAL and journal files are created using the same permissions
4868** as the associated database file.
drh81cc5162011-05-17 20:36:21 +00004869**
4870** If the SQLITE_ENABLE_8_3_NAMES option is enabled, then the
4871** original filename is unavailable. But 8_3_NAMES is only used for
4872** FAT filesystems and permissions do not matter there, so just use
4873** the default permissions.
danddb0ac42010-07-14 14:48:58 +00004874*/
4875static int findCreateFileMode(
4876 const char *zPath, /* Path of file (possibly) being created */
4877 int flags, /* Flags passed as 4th argument to xOpen() */
4878 mode_t *pMode /* OUT: Permissions to open file with */
4879){
4880 int rc = SQLITE_OK; /* Return Code */
drh81cc5162011-05-17 20:36:21 +00004881 *pMode = SQLITE_DEFAULT_FILE_PERMISSIONS;
drh8ab58662010-07-15 18:38:39 +00004882 if( flags & (SQLITE_OPEN_WAL|SQLITE_OPEN_MAIN_JOURNAL) ){
danddb0ac42010-07-14 14:48:58 +00004883 char zDb[MAX_PATHNAME+1]; /* Database file path */
4884 int nDb; /* Number of valid bytes in zDb */
4885 struct stat sStat; /* Output of stat() on database file */
4886
dana0c989d2010-11-05 18:07:37 +00004887 /* zPath is a path to a WAL or journal file. The following block derives
4888 ** the path to the associated database file from zPath. This block handles
4889 ** the following naming conventions:
4890 **
4891 ** "<path to db>-journal"
4892 ** "<path to db>-wal"
drh81cc5162011-05-17 20:36:21 +00004893 ** "<path to db>-journalNN"
4894 ** "<path to db>-walNN"
dana0c989d2010-11-05 18:07:37 +00004895 **
drh81cc5162011-05-17 20:36:21 +00004896 ** where NN is a 4 digit decimal number. The NN naming schemes are
dana0c989d2010-11-05 18:07:37 +00004897 ** used by the test_multiplex.c module.
4898 */
4899 nDb = sqlite3Strlen30(zPath) - 1;
drh81cc5162011-05-17 20:36:21 +00004900 while( nDb>0 && zPath[nDb]!='-' ) nDb--;
4901 if( nDb==0 ) return SQLITE_OK;
danddb0ac42010-07-14 14:48:58 +00004902 memcpy(zDb, zPath, nDb);
4903 zDb[nDb] = '\0';
dana0c989d2010-11-05 18:07:37 +00004904
drh58384f12011-07-28 00:14:45 +00004905 if( 0==osStat(zDb, &sStat) ){
danddb0ac42010-07-14 14:48:58 +00004906 *pMode = sStat.st_mode & 0777;
4907 }else{
4908 rc = SQLITE_IOERR_FSTAT;
4909 }
4910 }else if( flags & SQLITE_OPEN_DELETEONCLOSE ){
4911 *pMode = 0600;
danddb0ac42010-07-14 14:48:58 +00004912 }
4913 return rc;
4914}
4915
4916/*
danielk1977ad94b582007-08-20 06:44:22 +00004917** Open the file zPath.
4918**
danielk1977b4b47412007-08-17 15:53:36 +00004919** Previously, the SQLite OS layer used three functions in place of this
4920** one:
4921**
4922** sqlite3OsOpenReadWrite();
4923** sqlite3OsOpenReadOnly();
4924** sqlite3OsOpenExclusive();
4925**
4926** These calls correspond to the following combinations of flags:
4927**
4928** ReadWrite() -> (READWRITE | CREATE)
4929** ReadOnly() -> (READONLY)
4930** OpenExclusive() -> (READWRITE | CREATE | EXCLUSIVE)
4931**
4932** The old OpenExclusive() accepted a boolean argument - "delFlag". If
4933** true, the file was configured to be automatically deleted when the
4934** file handle closed. To achieve the same effect using this new
4935** interface, add the DELETEONCLOSE flag to those specified above for
4936** OpenExclusive().
4937*/
4938static int unixOpen(
drh6b9d6dd2008-12-03 19:34:47 +00004939 sqlite3_vfs *pVfs, /* The VFS for which this is the xOpen method */
4940 const char *zPath, /* Pathname of file to be opened */
4941 sqlite3_file *pFile, /* The file descriptor to be filled in */
4942 int flags, /* Input flags to control the opening */
4943 int *pOutFlags /* Output flags returned to SQLite core */
danielk1977b4b47412007-08-17 15:53:36 +00004944){
dan08da86a2009-08-21 17:18:03 +00004945 unixFile *p = (unixFile *)pFile;
4946 int fd = -1; /* File descriptor returned by open() */
drh6b9d6dd2008-12-03 19:34:47 +00004947 int openFlags = 0; /* Flags to pass to open() */
danielk1977fee2d252007-08-18 10:59:19 +00004948 int eType = flags&0xFFFFFF00; /* Type of file to open */
drhda0e7682008-07-30 15:27:54 +00004949 int noLock; /* True to omit locking primitives */
dan08da86a2009-08-21 17:18:03 +00004950 int rc = SQLITE_OK; /* Function Return Code */
danielk1977b4b47412007-08-17 15:53:36 +00004951
4952 int isExclusive = (flags & SQLITE_OPEN_EXCLUSIVE);
4953 int isDelete = (flags & SQLITE_OPEN_DELETEONCLOSE);
4954 int isCreate = (flags & SQLITE_OPEN_CREATE);
4955 int isReadonly = (flags & SQLITE_OPEN_READONLY);
4956 int isReadWrite = (flags & SQLITE_OPEN_READWRITE);
drh7ed97b92010-01-20 13:07:21 +00004957#if SQLITE_ENABLE_LOCKING_STYLE
4958 int isAutoProxy = (flags & SQLITE_OPEN_AUTOPROXY);
4959#endif
danielk1977b4b47412007-08-17 15:53:36 +00004960
danielk1977fee2d252007-08-18 10:59:19 +00004961 /* If creating a master or main-file journal, this function will open
4962 ** a file-descriptor on the directory too. The first time unixSync()
4963 ** is called the directory file descriptor will be fsync()ed and close()d.
4964 */
drh0059eae2011-08-08 23:48:40 +00004965 int syncDir = (isCreate && (
danddb0ac42010-07-14 14:48:58 +00004966 eType==SQLITE_OPEN_MASTER_JOURNAL
4967 || eType==SQLITE_OPEN_MAIN_JOURNAL
4968 || eType==SQLITE_OPEN_WAL
4969 ));
danielk1977fee2d252007-08-18 10:59:19 +00004970
danielk197717b90b52008-06-06 11:11:25 +00004971 /* If argument zPath is a NULL pointer, this function is required to open
4972 ** a temporary file. Use this buffer to store the file name in.
4973 */
4974 char zTmpname[MAX_PATHNAME+1];
4975 const char *zName = zPath;
4976
danielk1977fee2d252007-08-18 10:59:19 +00004977 /* Check the following statements are true:
4978 **
4979 ** (a) Exactly one of the READWRITE and READONLY flags must be set, and
4980 ** (b) if CREATE is set, then READWRITE must also be set, and
4981 ** (c) if EXCLUSIVE is set, then CREATE must also be set.
drh33f4e022007-09-03 15:19:34 +00004982 ** (d) if DELETEONCLOSE is set, then CREATE must also be set.
danielk1977fee2d252007-08-18 10:59:19 +00004983 */
danielk1977b4b47412007-08-17 15:53:36 +00004984 assert((isReadonly==0 || isReadWrite==0) && (isReadWrite || isReadonly));
danielk1977b4b47412007-08-17 15:53:36 +00004985 assert(isCreate==0 || isReadWrite);
danielk1977b4b47412007-08-17 15:53:36 +00004986 assert(isExclusive==0 || isCreate);
drh33f4e022007-09-03 15:19:34 +00004987 assert(isDelete==0 || isCreate);
4988
danddb0ac42010-07-14 14:48:58 +00004989 /* The main DB, main journal, WAL file and master journal are never
4990 ** automatically deleted. Nor are they ever temporary files. */
dan08da86a2009-08-21 17:18:03 +00004991 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_DB );
4992 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_JOURNAL );
4993 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MASTER_JOURNAL );
danddb0ac42010-07-14 14:48:58 +00004994 assert( (!isDelete && zName) || eType!=SQLITE_OPEN_WAL );
danielk1977b4b47412007-08-17 15:53:36 +00004995
danielk1977fee2d252007-08-18 10:59:19 +00004996 /* Assert that the upper layer has set one of the "file-type" flags. */
4997 assert( eType==SQLITE_OPEN_MAIN_DB || eType==SQLITE_OPEN_TEMP_DB
4998 || eType==SQLITE_OPEN_MAIN_JOURNAL || eType==SQLITE_OPEN_TEMP_JOURNAL
4999 || eType==SQLITE_OPEN_SUBJOURNAL || eType==SQLITE_OPEN_MASTER_JOURNAL
danddb0ac42010-07-14 14:48:58 +00005000 || eType==SQLITE_OPEN_TRANSIENT_DB || eType==SQLITE_OPEN_WAL
danielk1977fee2d252007-08-18 10:59:19 +00005001 );
5002
dan08da86a2009-08-21 17:18:03 +00005003 memset(p, 0, sizeof(unixFile));
danielk1977e339d652008-06-28 11:23:00 +00005004
dan08da86a2009-08-21 17:18:03 +00005005 if( eType==SQLITE_OPEN_MAIN_DB ){
dane946c392009-08-22 11:39:46 +00005006 UnixUnusedFd *pUnused;
5007 pUnused = findReusableFd(zName, flags);
5008 if( pUnused ){
5009 fd = pUnused->fd;
5010 }else{
dan6aa657f2009-08-24 18:57:58 +00005011 pUnused = sqlite3_malloc(sizeof(*pUnused));
dane946c392009-08-22 11:39:46 +00005012 if( !pUnused ){
5013 return SQLITE_NOMEM;
5014 }
5015 }
5016 p->pUnused = pUnused;
dan08da86a2009-08-21 17:18:03 +00005017 }else if( !zName ){
5018 /* If zName is NULL, the upper layer is requesting a temp file. */
drh0059eae2011-08-08 23:48:40 +00005019 assert(isDelete && !syncDir);
drh8b3cf822010-06-01 21:02:51 +00005020 rc = unixGetTempname(MAX_PATHNAME+1, zTmpname);
danielk197717b90b52008-06-06 11:11:25 +00005021 if( rc!=SQLITE_OK ){
5022 return rc;
5023 }
5024 zName = zTmpname;
5025 }
5026
dan08da86a2009-08-21 17:18:03 +00005027 /* Determine the value of the flags parameter passed to POSIX function
5028 ** open(). These must be calculated even if open() is not called, as
5029 ** they may be stored as part of the file handle and used by the
5030 ** 'conch file' locking functions later on. */
drh734c9862008-11-28 15:37:20 +00005031 if( isReadonly ) openFlags |= O_RDONLY;
5032 if( isReadWrite ) openFlags |= O_RDWR;
5033 if( isCreate ) openFlags |= O_CREAT;
5034 if( isExclusive ) openFlags |= (O_EXCL|O_NOFOLLOW);
5035 openFlags |= (O_LARGEFILE|O_BINARY);
danielk1977b4b47412007-08-17 15:53:36 +00005036
danielk1977b4b47412007-08-17 15:53:36 +00005037 if( fd<0 ){
danddb0ac42010-07-14 14:48:58 +00005038 mode_t openMode; /* Permissions to create file with */
5039 rc = findCreateFileMode(zName, flags, &openMode);
5040 if( rc!=SQLITE_OK ){
5041 assert( !p->pUnused );
drh8ab58662010-07-15 18:38:39 +00005042 assert( eType==SQLITE_OPEN_WAL || eType==SQLITE_OPEN_MAIN_JOURNAL );
danddb0ac42010-07-14 14:48:58 +00005043 return rc;
5044 }
drhad4f1e52011-03-04 15:43:57 +00005045 fd = robust_open(zName, openFlags, openMode);
drh308c2a52010-05-14 11:30:18 +00005046 OSTRACE(("OPENX %-3d %s 0%o\n", fd, zName, openFlags));
dan08da86a2009-08-21 17:18:03 +00005047 if( fd<0 && errno!=EISDIR && isReadWrite && !isExclusive ){
5048 /* Failed to open the file for read/write access. Try read-only. */
5049 flags &= ~(SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE);
dane946c392009-08-22 11:39:46 +00005050 openFlags &= ~(O_RDWR|O_CREAT);
dan08da86a2009-08-21 17:18:03 +00005051 flags |= SQLITE_OPEN_READONLY;
dane946c392009-08-22 11:39:46 +00005052 openFlags |= O_RDONLY;
drh77197112011-03-15 19:08:48 +00005053 isReadonly = 1;
drhad4f1e52011-03-04 15:43:57 +00005054 fd = robust_open(zName, openFlags, openMode);
dan08da86a2009-08-21 17:18:03 +00005055 }
5056 if( fd<0 ){
dane18d4952011-02-21 11:46:24 +00005057 rc = unixLogError(SQLITE_CANTOPEN_BKPT, "open", zName);
dane946c392009-08-22 11:39:46 +00005058 goto open_finished;
dan08da86a2009-08-21 17:18:03 +00005059 }
danielk1977b4b47412007-08-17 15:53:36 +00005060 }
dan08da86a2009-08-21 17:18:03 +00005061 assert( fd>=0 );
dan08da86a2009-08-21 17:18:03 +00005062 if( pOutFlags ){
5063 *pOutFlags = flags;
5064 }
5065
dane946c392009-08-22 11:39:46 +00005066 if( p->pUnused ){
5067 p->pUnused->fd = fd;
5068 p->pUnused->flags = flags;
5069 }
5070
danielk1977b4b47412007-08-17 15:53:36 +00005071 if( isDelete ){
drh6c7d5c52008-11-21 20:32:33 +00005072#if OS_VXWORKS
chw97185482008-11-17 08:05:31 +00005073 zPath = zName;
5074#else
drh036ac7f2011-08-08 23:18:05 +00005075 osUnlink(zName);
chw97185482008-11-17 08:05:31 +00005076#endif
danielk1977b4b47412007-08-17 15:53:36 +00005077 }
drh41022642008-11-21 00:24:42 +00005078#if SQLITE_ENABLE_LOCKING_STYLE
5079 else{
dan08da86a2009-08-21 17:18:03 +00005080 p->openFlags = openFlags;
drh08c6d442009-02-09 17:34:07 +00005081 }
5082#endif
5083
danielk1977e339d652008-06-28 11:23:00 +00005084#ifdef FD_CLOEXEC
drh99ab3b12011-03-02 15:09:07 +00005085 osFcntl(fd, F_SETFD, osFcntl(fd, F_GETFD, 0) | FD_CLOEXEC);
danielk1977e339d652008-06-28 11:23:00 +00005086#endif
5087
drhda0e7682008-07-30 15:27:54 +00005088 noLock = eType!=SQLITE_OPEN_MAIN_DB;
aswiftaebf4132008-11-21 00:10:35 +00005089
drh7ed97b92010-01-20 13:07:21 +00005090
5091#if defined(__APPLE__) || SQLITE_ENABLE_LOCKING_STYLE
5092 struct statfs fsInfo;
5093 if( fstatfs(fd, &fsInfo) == -1 ){
5094 ((unixFile*)pFile)->lastErrno = errno;
drh0e9365c2011-03-02 02:08:13 +00005095 robust_close(p, fd, __LINE__);
drh7ed97b92010-01-20 13:07:21 +00005096 return SQLITE_IOERR_ACCESS;
5097 }
5098 if (0 == strncmp("msdos", fsInfo.f_fstypename, 5)) {
5099 ((unixFile*)pFile)->fsFlags |= SQLITE_FSFLAGS_IS_MSDOS;
5100 }
5101#endif
5102
5103#if SQLITE_ENABLE_LOCKING_STYLE
aswiftaebf4132008-11-21 00:10:35 +00005104#if SQLITE_PREFER_PROXY_LOCKING
drh7ed97b92010-01-20 13:07:21 +00005105 isAutoProxy = 1;
5106#endif
5107 if( isAutoProxy && (zPath!=NULL) && (!noLock) && pVfs->xOpen ){
aswiftaebf4132008-11-21 00:10:35 +00005108 char *envforce = getenv("SQLITE_FORCE_PROXY_LOCKING");
5109 int useProxy = 0;
5110
dan08da86a2009-08-21 17:18:03 +00005111 /* SQLITE_FORCE_PROXY_LOCKING==1 means force always use proxy, 0 means
5112 ** never use proxy, NULL means use proxy for non-local files only. */
aswiftaebf4132008-11-21 00:10:35 +00005113 if( envforce!=NULL ){
5114 useProxy = atoi(envforce)>0;
5115 }else{
5116 struct statfs fsInfo;
aswiftaebf4132008-11-21 00:10:35 +00005117 if( statfs(zPath, &fsInfo) == -1 ){
dane946c392009-08-22 11:39:46 +00005118 /* In theory, the close(fd) call is sub-optimal. If the file opened
5119 ** with fd is a database file, and there are other connections open
5120 ** on that file that are currently holding advisory locks on it,
5121 ** then the call to close() will cancel those locks. In practice,
5122 ** we're assuming that statfs() doesn't fail very often. At least
5123 ** not while other file descriptors opened by the same process on
5124 ** the same file are working. */
5125 p->lastErrno = errno;
drh0e9365c2011-03-02 02:08:13 +00005126 robust_close(p, fd, __LINE__);
dane946c392009-08-22 11:39:46 +00005127 rc = SQLITE_IOERR_ACCESS;
5128 goto open_finished;
aswiftaebf4132008-11-21 00:10:35 +00005129 }
5130 useProxy = !(fsInfo.f_flags&MNT_LOCAL);
5131 }
5132 if( useProxy ){
drh0059eae2011-08-08 23:48:40 +00005133 rc = fillInUnixFile(pVfs, fd, syncDir, pFile, zPath, noLock,
drh77197112011-03-15 19:08:48 +00005134 isDelete, isReadonly);
aswiftaebf4132008-11-21 00:10:35 +00005135 if( rc==SQLITE_OK ){
drh715ff302008-12-03 22:32:44 +00005136 rc = proxyTransformUnixFile((unixFile*)pFile, ":auto:");
drh7ed97b92010-01-20 13:07:21 +00005137 if( rc!=SQLITE_OK ){
5138 /* Use unixClose to clean up the resources added in fillInUnixFile
5139 ** and clear all the structure's references. Specifically,
5140 ** pFile->pMethods will be NULL so sqlite3OsClose will be a no-op
5141 */
5142 unixClose(pFile);
5143 return rc;
5144 }
aswiftaebf4132008-11-21 00:10:35 +00005145 }
dane946c392009-08-22 11:39:46 +00005146 goto open_finished;
aswiftaebf4132008-11-21 00:10:35 +00005147 }
5148 }
5149#endif
5150
drh0059eae2011-08-08 23:48:40 +00005151 rc = fillInUnixFile(pVfs, fd, syncDir, pFile, zPath, noLock,
drh77197112011-03-15 19:08:48 +00005152 isDelete, isReadonly);
dane946c392009-08-22 11:39:46 +00005153open_finished:
5154 if( rc!=SQLITE_OK ){
5155 sqlite3_free(p->pUnused);
5156 }
5157 return rc;
danielk1977b4b47412007-08-17 15:53:36 +00005158}
5159
dane946c392009-08-22 11:39:46 +00005160
danielk1977b4b47412007-08-17 15:53:36 +00005161/*
danielk1977fee2d252007-08-18 10:59:19 +00005162** Delete the file at zPath. If the dirSync argument is true, fsync()
5163** the directory after deleting the file.
danielk1977b4b47412007-08-17 15:53:36 +00005164*/
drh6b9d6dd2008-12-03 19:34:47 +00005165static int unixDelete(
5166 sqlite3_vfs *NotUsed, /* VFS containing this as the xDelete method */
5167 const char *zPath, /* Name of file to be deleted */
5168 int dirSync /* If true, fsync() directory after deleting file */
5169){
danielk1977fee2d252007-08-18 10:59:19 +00005170 int rc = SQLITE_OK;
danielk1977397d65f2008-11-19 11:35:39 +00005171 UNUSED_PARAMETER(NotUsed);
danielk1977b4b47412007-08-17 15:53:36 +00005172 SimulateIOError(return SQLITE_IOERR_DELETE);
drh036ac7f2011-08-08 23:18:05 +00005173 if( osUnlink(zPath)==(-1) && errno!=ENOENT ){
dane18d4952011-02-21 11:46:24 +00005174 return unixLogError(SQLITE_IOERR_DELETE, "unlink", zPath);
drh5d4feff2010-07-14 01:45:22 +00005175 }
danielk1977d39fa702008-10-16 13:27:40 +00005176#ifndef SQLITE_DISABLE_DIRSYNC
danielk1977fee2d252007-08-18 10:59:19 +00005177 if( dirSync ){
5178 int fd;
drh90315a22011-08-10 01:52:12 +00005179 rc = osOpenDirectory(zPath, &fd);
danielk1977fee2d252007-08-18 10:59:19 +00005180 if( rc==SQLITE_OK ){
drh6c7d5c52008-11-21 20:32:33 +00005181#if OS_VXWORKS
chw97185482008-11-17 08:05:31 +00005182 if( fsync(fd)==-1 )
5183#else
5184 if( fsync(fd) )
5185#endif
5186 {
dane18d4952011-02-21 11:46:24 +00005187 rc = unixLogError(SQLITE_IOERR_DIR_FSYNC, "fsync", zPath);
danielk1977fee2d252007-08-18 10:59:19 +00005188 }
drh0e9365c2011-03-02 02:08:13 +00005189 robust_close(0, fd, __LINE__);
drh1ee6f742011-08-23 20:11:32 +00005190 }else if( rc==SQLITE_CANTOPEN ){
5191 rc = SQLITE_OK;
danielk1977fee2d252007-08-18 10:59:19 +00005192 }
5193 }
danielk1977d138dd82008-10-15 16:02:48 +00005194#endif
danielk1977fee2d252007-08-18 10:59:19 +00005195 return rc;
danielk1977b4b47412007-08-17 15:53:36 +00005196}
5197
danielk197790949c22007-08-17 16:50:38 +00005198/*
5199** Test the existance of or access permissions of file zPath. The
5200** test performed depends on the value of flags:
5201**
5202** SQLITE_ACCESS_EXISTS: Return 1 if the file exists
5203** SQLITE_ACCESS_READWRITE: Return 1 if the file is read and writable.
5204** SQLITE_ACCESS_READONLY: Return 1 if the file is readable.
5205**
5206** Otherwise return 0.
5207*/
danielk1977861f7452008-06-05 11:39:11 +00005208static int unixAccess(
drh6b9d6dd2008-12-03 19:34:47 +00005209 sqlite3_vfs *NotUsed, /* The VFS containing this xAccess method */
5210 const char *zPath, /* Path of the file to examine */
5211 int flags, /* What do we want to learn about the zPath file? */
5212 int *pResOut /* Write result boolean here */
danielk1977861f7452008-06-05 11:39:11 +00005213){
rse25c0d1a2007-09-20 08:38:14 +00005214 int amode = 0;
danielk1977397d65f2008-11-19 11:35:39 +00005215 UNUSED_PARAMETER(NotUsed);
danielk1977861f7452008-06-05 11:39:11 +00005216 SimulateIOError( return SQLITE_IOERR_ACCESS; );
danielk1977b4b47412007-08-17 15:53:36 +00005217 switch( flags ){
5218 case SQLITE_ACCESS_EXISTS:
5219 amode = F_OK;
5220 break;
5221 case SQLITE_ACCESS_READWRITE:
5222 amode = W_OK|R_OK;
5223 break;
drh50d3f902007-08-27 21:10:36 +00005224 case SQLITE_ACCESS_READ:
danielk1977b4b47412007-08-17 15:53:36 +00005225 amode = R_OK;
5226 break;
5227
5228 default:
5229 assert(!"Invalid flags argument");
5230 }
drh99ab3b12011-03-02 15:09:07 +00005231 *pResOut = (osAccess(zPath, amode)==0);
dan83acd422010-06-18 11:10:06 +00005232 if( flags==SQLITE_ACCESS_EXISTS && *pResOut ){
5233 struct stat buf;
drh58384f12011-07-28 00:14:45 +00005234 if( 0==osStat(zPath, &buf) && buf.st_size==0 ){
dan83acd422010-06-18 11:10:06 +00005235 *pResOut = 0;
5236 }
5237 }
danielk1977861f7452008-06-05 11:39:11 +00005238 return SQLITE_OK;
danielk1977b4b47412007-08-17 15:53:36 +00005239}
5240
danielk1977b4b47412007-08-17 15:53:36 +00005241
5242/*
5243** Turn a relative pathname into a full pathname. The relative path
5244** is stored as a nul-terminated string in the buffer pointed to by
5245** zPath.
5246**
5247** zOut points to a buffer of at least sqlite3_vfs.mxPathname bytes
5248** (in this case, MAX_PATHNAME bytes). The full-path is written to
5249** this buffer before returning.
5250*/
danielk1977adfb9b02007-09-17 07:02:56 +00005251static int unixFullPathname(
5252 sqlite3_vfs *pVfs, /* Pointer to vfs object */
5253 const char *zPath, /* Possibly relative input path */
5254 int nOut, /* Size of output buffer in bytes */
5255 char *zOut /* Output buffer */
5256){
danielk1977843e65f2007-09-01 16:16:15 +00005257
5258 /* It's odd to simulate an io-error here, but really this is just
5259 ** using the io-error infrastructure to test that SQLite handles this
5260 ** function failing. This function could fail if, for example, the
drh6b9d6dd2008-12-03 19:34:47 +00005261 ** current working directory has been unlinked.
danielk1977843e65f2007-09-01 16:16:15 +00005262 */
5263 SimulateIOError( return SQLITE_ERROR );
5264
drh153c62c2007-08-24 03:51:33 +00005265 assert( pVfs->mxPathname==MAX_PATHNAME );
danielk1977f3d3c272008-11-19 16:52:44 +00005266 UNUSED_PARAMETER(pVfs);
chw97185482008-11-17 08:05:31 +00005267
drh3c7f2dc2007-12-06 13:26:20 +00005268 zOut[nOut-1] = '\0';
danielk1977b4b47412007-08-17 15:53:36 +00005269 if( zPath[0]=='/' ){
drh3c7f2dc2007-12-06 13:26:20 +00005270 sqlite3_snprintf(nOut, zOut, "%s", zPath);
danielk1977b4b47412007-08-17 15:53:36 +00005271 }else{
5272 int nCwd;
drh99ab3b12011-03-02 15:09:07 +00005273 if( osGetcwd(zOut, nOut-1)==0 ){
dane18d4952011-02-21 11:46:24 +00005274 return unixLogError(SQLITE_CANTOPEN_BKPT, "getcwd", zPath);
danielk1977b4b47412007-08-17 15:53:36 +00005275 }
drhea678832008-12-10 19:26:22 +00005276 nCwd = (int)strlen(zOut);
drh3c7f2dc2007-12-06 13:26:20 +00005277 sqlite3_snprintf(nOut-nCwd, &zOut[nCwd], "/%s", zPath);
danielk1977b4b47412007-08-17 15:53:36 +00005278 }
5279 return SQLITE_OK;
danielk1977b4b47412007-08-17 15:53:36 +00005280}
5281
drh0ccebe72005-06-07 22:22:50 +00005282
drh761df872006-12-21 01:29:22 +00005283#ifndef SQLITE_OMIT_LOAD_EXTENSION
5284/*
5285** Interfaces for opening a shared library, finding entry points
5286** within the shared library, and closing the shared library.
5287*/
5288#include <dlfcn.h>
danielk1977397d65f2008-11-19 11:35:39 +00005289static void *unixDlOpen(sqlite3_vfs *NotUsed, const char *zFilename){
5290 UNUSED_PARAMETER(NotUsed);
drh761df872006-12-21 01:29:22 +00005291 return dlopen(zFilename, RTLD_NOW | RTLD_GLOBAL);
5292}
danielk197795c8a542007-09-01 06:51:27 +00005293
5294/*
5295** SQLite calls this function immediately after a call to unixDlSym() or
5296** unixDlOpen() fails (returns a null pointer). If a more detailed error
5297** message is available, it is written to zBufOut. If no error message
5298** is available, zBufOut is left unmodified and SQLite uses a default
5299** error message.
5300*/
danielk1977397d65f2008-11-19 11:35:39 +00005301static void unixDlError(sqlite3_vfs *NotUsed, int nBuf, char *zBufOut){
dan32390532010-11-29 18:36:22 +00005302 const char *zErr;
danielk1977397d65f2008-11-19 11:35:39 +00005303 UNUSED_PARAMETER(NotUsed);
drh6c7d5c52008-11-21 20:32:33 +00005304 unixEnterMutex();
danielk1977b4b47412007-08-17 15:53:36 +00005305 zErr = dlerror();
5306 if( zErr ){
drh153c62c2007-08-24 03:51:33 +00005307 sqlite3_snprintf(nBuf, zBufOut, "%s", zErr);
danielk1977b4b47412007-08-17 15:53:36 +00005308 }
drh6c7d5c52008-11-21 20:32:33 +00005309 unixLeaveMutex();
danielk1977b4b47412007-08-17 15:53:36 +00005310}
drh1875f7a2008-12-08 18:19:17 +00005311static void (*unixDlSym(sqlite3_vfs *NotUsed, void *p, const char*zSym))(void){
5312 /*
5313 ** GCC with -pedantic-errors says that C90 does not allow a void* to be
5314 ** cast into a pointer to a function. And yet the library dlsym() routine
5315 ** returns a void* which is really a pointer to a function. So how do we
5316 ** use dlsym() with -pedantic-errors?
5317 **
5318 ** Variable x below is defined to be a pointer to a function taking
5319 ** parameters void* and const char* and returning a pointer to a function.
5320 ** We initialize x by assigning it a pointer to the dlsym() function.
5321 ** (That assignment requires a cast.) Then we call the function that
5322 ** x points to.
5323 **
5324 ** This work-around is unlikely to work correctly on any system where
5325 ** you really cannot cast a function pointer into void*. But then, on the
5326 ** other hand, dlsym() will not work on such a system either, so we have
5327 ** not really lost anything.
5328 */
5329 void (*(*x)(void*,const char*))(void);
danielk1977397d65f2008-11-19 11:35:39 +00005330 UNUSED_PARAMETER(NotUsed);
drh1875f7a2008-12-08 18:19:17 +00005331 x = (void(*(*)(void*,const char*))(void))dlsym;
5332 return (*x)(p, zSym);
drh761df872006-12-21 01:29:22 +00005333}
danielk1977397d65f2008-11-19 11:35:39 +00005334static void unixDlClose(sqlite3_vfs *NotUsed, void *pHandle){
5335 UNUSED_PARAMETER(NotUsed);
danielk1977b4b47412007-08-17 15:53:36 +00005336 dlclose(pHandle);
drh761df872006-12-21 01:29:22 +00005337}
danielk1977b4b47412007-08-17 15:53:36 +00005338#else /* if SQLITE_OMIT_LOAD_EXTENSION is defined: */
5339 #define unixDlOpen 0
5340 #define unixDlError 0
5341 #define unixDlSym 0
5342 #define unixDlClose 0
5343#endif
5344
5345/*
danielk197790949c22007-08-17 16:50:38 +00005346** Write nBuf bytes of random data to the supplied buffer zBuf.
drhbbd42a62004-05-22 17:41:58 +00005347*/
danielk1977397d65f2008-11-19 11:35:39 +00005348static int unixRandomness(sqlite3_vfs *NotUsed, int nBuf, char *zBuf){
5349 UNUSED_PARAMETER(NotUsed);
danielk197700e13612008-11-17 19:18:54 +00005350 assert((size_t)nBuf>=(sizeof(time_t)+sizeof(int)));
danielk197790949c22007-08-17 16:50:38 +00005351
drhbbd42a62004-05-22 17:41:58 +00005352 /* We have to initialize zBuf to prevent valgrind from reporting
5353 ** errors. The reports issued by valgrind are incorrect - we would
5354 ** prefer that the randomness be increased by making use of the
5355 ** uninitialized space in zBuf - but valgrind errors tend to worry
5356 ** some users. Rather than argue, it seems easier just to initialize
5357 ** the whole array and silence valgrind, even if that means less randomness
5358 ** in the random seed.
5359 **
5360 ** When testing, initializing zBuf[] to zero is all we do. That means
drhf1a221e2006-01-15 17:27:17 +00005361 ** that we always use the same random number sequence. This makes the
drhbbd42a62004-05-22 17:41:58 +00005362 ** tests repeatable.
5363 */
danielk1977b4b47412007-08-17 15:53:36 +00005364 memset(zBuf, 0, nBuf);
drhbbd42a62004-05-22 17:41:58 +00005365#if !defined(SQLITE_TEST)
5366 {
drh842b8642005-01-21 17:53:17 +00005367 int pid, fd;
drhad4f1e52011-03-04 15:43:57 +00005368 fd = robust_open("/dev/urandom", O_RDONLY, 0);
drh842b8642005-01-21 17:53:17 +00005369 if( fd<0 ){
drh07397232006-01-06 14:46:46 +00005370 time_t t;
5371 time(&t);
danielk197790949c22007-08-17 16:50:38 +00005372 memcpy(zBuf, &t, sizeof(t));
5373 pid = getpid();
5374 memcpy(&zBuf[sizeof(t)], &pid, sizeof(pid));
danielk197700e13612008-11-17 19:18:54 +00005375 assert( sizeof(t)+sizeof(pid)<=(size_t)nBuf );
drh72cbd072008-10-14 17:58:38 +00005376 nBuf = sizeof(t) + sizeof(pid);
drh842b8642005-01-21 17:53:17 +00005377 }else{
drhe562be52011-03-02 18:01:10 +00005378 do{ nBuf = osRead(fd, zBuf, nBuf); }while( nBuf<0 && errno==EINTR );
drh0e9365c2011-03-02 02:08:13 +00005379 robust_close(0, fd, __LINE__);
drh842b8642005-01-21 17:53:17 +00005380 }
drhbbd42a62004-05-22 17:41:58 +00005381 }
5382#endif
drh72cbd072008-10-14 17:58:38 +00005383 return nBuf;
drhbbd42a62004-05-22 17:41:58 +00005384}
5385
danielk1977b4b47412007-08-17 15:53:36 +00005386
drhbbd42a62004-05-22 17:41:58 +00005387/*
5388** Sleep for a little while. Return the amount of time slept.
danielk1977b4b47412007-08-17 15:53:36 +00005389** The argument is the number of microseconds we want to sleep.
drh4a50aac2007-08-23 02:47:53 +00005390** The return value is the number of microseconds of sleep actually
5391** requested from the underlying operating system, a number which
5392** might be greater than or equal to the argument, but not less
5393** than the argument.
drhbbd42a62004-05-22 17:41:58 +00005394*/
danielk1977397d65f2008-11-19 11:35:39 +00005395static int unixSleep(sqlite3_vfs *NotUsed, int microseconds){
drh6c7d5c52008-11-21 20:32:33 +00005396#if OS_VXWORKS
chw97185482008-11-17 08:05:31 +00005397 struct timespec sp;
5398
5399 sp.tv_sec = microseconds / 1000000;
5400 sp.tv_nsec = (microseconds % 1000000) * 1000;
5401 nanosleep(&sp, NULL);
drhd43fe202009-03-01 22:29:20 +00005402 UNUSED_PARAMETER(NotUsed);
danielk1977397d65f2008-11-19 11:35:39 +00005403 return microseconds;
5404#elif defined(HAVE_USLEEP) && HAVE_USLEEP
danielk1977b4b47412007-08-17 15:53:36 +00005405 usleep(microseconds);
drhd43fe202009-03-01 22:29:20 +00005406 UNUSED_PARAMETER(NotUsed);
danielk1977b4b47412007-08-17 15:53:36 +00005407 return microseconds;
drhbbd42a62004-05-22 17:41:58 +00005408#else
danielk1977b4b47412007-08-17 15:53:36 +00005409 int seconds = (microseconds+999999)/1000000;
5410 sleep(seconds);
drhd43fe202009-03-01 22:29:20 +00005411 UNUSED_PARAMETER(NotUsed);
drh4a50aac2007-08-23 02:47:53 +00005412 return seconds*1000000;
drha3fad6f2006-01-18 14:06:37 +00005413#endif
drh88f474a2006-01-02 20:00:12 +00005414}
5415
5416/*
drh6b9d6dd2008-12-03 19:34:47 +00005417** The following variable, if set to a non-zero value, is interpreted as
5418** the number of seconds since 1970 and is used to set the result of
5419** sqlite3OsCurrentTime() during testing.
drhbbd42a62004-05-22 17:41:58 +00005420*/
5421#ifdef SQLITE_TEST
drh6b9d6dd2008-12-03 19:34:47 +00005422int sqlite3_current_time = 0; /* Fake system time in seconds since 1970. */
drhbbd42a62004-05-22 17:41:58 +00005423#endif
5424
5425/*
drhb7e8ea22010-05-03 14:32:30 +00005426** Find the current time (in Universal Coordinated Time). Write into *piNow
5427** the current time and date as a Julian Day number times 86_400_000. In
5428** other words, write into *piNow the number of milliseconds since the Julian
5429** epoch of noon in Greenwich on November 24, 4714 B.C according to the
5430** proleptic Gregorian calendar.
5431**
5432** On success, return 0. Return 1 if the time and date cannot be found.
5433*/
5434static int unixCurrentTimeInt64(sqlite3_vfs *NotUsed, sqlite3_int64 *piNow){
5435 static const sqlite3_int64 unixEpoch = 24405875*(sqlite3_int64)8640000;
5436#if defined(NO_GETTOD)
5437 time_t t;
5438 time(&t);
dan15eac4e2010-11-22 17:26:07 +00005439 *piNow = ((sqlite3_int64)t)*1000 + unixEpoch;
drhb7e8ea22010-05-03 14:32:30 +00005440#elif OS_VXWORKS
5441 struct timespec sNow;
5442 clock_gettime(CLOCK_REALTIME, &sNow);
5443 *piNow = unixEpoch + 1000*(sqlite3_int64)sNow.tv_sec + sNow.tv_nsec/1000000;
5444#else
5445 struct timeval sNow;
5446 gettimeofday(&sNow, 0);
5447 *piNow = unixEpoch + 1000*(sqlite3_int64)sNow.tv_sec + sNow.tv_usec/1000;
5448#endif
5449
5450#ifdef SQLITE_TEST
5451 if( sqlite3_current_time ){
5452 *piNow = 1000*(sqlite3_int64)sqlite3_current_time + unixEpoch;
5453 }
5454#endif
5455 UNUSED_PARAMETER(NotUsed);
5456 return 0;
5457}
5458
5459/*
drhbbd42a62004-05-22 17:41:58 +00005460** Find the current time (in Universal Coordinated Time). Write the
5461** current time and date as a Julian Day number into *prNow and
5462** return 0. Return 1 if the time and date cannot be found.
5463*/
danielk1977397d65f2008-11-19 11:35:39 +00005464static int unixCurrentTime(sqlite3_vfs *NotUsed, double *prNow){
drhb7e8ea22010-05-03 14:32:30 +00005465 sqlite3_int64 i;
drhff828942010-06-26 21:34:06 +00005466 UNUSED_PARAMETER(NotUsed);
drhb7e8ea22010-05-03 14:32:30 +00005467 unixCurrentTimeInt64(0, &i);
drh0dcb0a72010-05-03 18:22:52 +00005468 *prNow = i/86400000.0;
drhbbd42a62004-05-22 17:41:58 +00005469 return 0;
5470}
danielk1977b4b47412007-08-17 15:53:36 +00005471
drh6b9d6dd2008-12-03 19:34:47 +00005472/*
5473** We added the xGetLastError() method with the intention of providing
5474** better low-level error messages when operating-system problems come up
5475** during SQLite operation. But so far, none of that has been implemented
5476** in the core. So this routine is never called. For now, it is merely
5477** a place-holder.
5478*/
danielk1977397d65f2008-11-19 11:35:39 +00005479static int unixGetLastError(sqlite3_vfs *NotUsed, int NotUsed2, char *NotUsed3){
5480 UNUSED_PARAMETER(NotUsed);
5481 UNUSED_PARAMETER(NotUsed2);
5482 UNUSED_PARAMETER(NotUsed3);
danielk1977bcb97fe2008-06-06 15:49:29 +00005483 return 0;
5484}
5485
drhf2424c52010-04-26 00:04:55 +00005486
5487/*
drh734c9862008-11-28 15:37:20 +00005488************************ End of sqlite3_vfs methods ***************************
5489******************************************************************************/
5490
drh715ff302008-12-03 22:32:44 +00005491/******************************************************************************
5492************************** Begin Proxy Locking ********************************
5493**
5494** Proxy locking is a "uber-locking-method" in this sense: It uses the
5495** other locking methods on secondary lock files. Proxy locking is a
5496** meta-layer over top of the primitive locking implemented above. For
5497** this reason, the division that implements of proxy locking is deferred
5498** until late in the file (here) after all of the other I/O methods have
5499** been defined - so that the primitive locking methods are available
5500** as services to help with the implementation of proxy locking.
5501**
5502****
5503**
5504** The default locking schemes in SQLite use byte-range locks on the
5505** database file to coordinate safe, concurrent access by multiple readers
5506** and writers [http://sqlite.org/lockingv3.html]. The five file locking
5507** states (UNLOCKED, PENDING, SHARED, RESERVED, EXCLUSIVE) are implemented
5508** as POSIX read & write locks over fixed set of locations (via fsctl),
5509** on AFP and SMB only exclusive byte-range locks are available via fsctl
5510** with _IOWR('z', 23, struct ByteRangeLockPB2) to track the same 5 states.
5511** To simulate a F_RDLCK on the shared range, on AFP a randomly selected
5512** address in the shared range is taken for a SHARED lock, the entire
5513** shared range is taken for an EXCLUSIVE lock):
5514**
5515** PENDING_BYTE 0x40000000
5516** RESERVED_BYTE 0x40000001
5517** SHARED_RANGE 0x40000002 -> 0x40000200
5518**
5519** This works well on the local file system, but shows a nearly 100x
5520** slowdown in read performance on AFP because the AFP client disables
5521** the read cache when byte-range locks are present. Enabling the read
5522** cache exposes a cache coherency problem that is present on all OS X
5523** supported network file systems. NFS and AFP both observe the
5524** close-to-open semantics for ensuring cache coherency
5525** [http://nfs.sourceforge.net/#faq_a8], which does not effectively
5526** address the requirements for concurrent database access by multiple
5527** readers and writers
5528** [http://www.nabble.com/SQLite-on-NFS-cache-coherency-td15655701.html].
5529**
5530** To address the performance and cache coherency issues, proxy file locking
5531** changes the way database access is controlled by limiting access to a
5532** single host at a time and moving file locks off of the database file
5533** and onto a proxy file on the local file system.
5534**
5535**
5536** Using proxy locks
5537** -----------------
5538**
5539** C APIs
5540**
5541** sqlite3_file_control(db, dbname, SQLITE_SET_LOCKPROXYFILE,
5542** <proxy_path> | ":auto:");
5543** sqlite3_file_control(db, dbname, SQLITE_GET_LOCKPROXYFILE, &<proxy_path>);
5544**
5545**
5546** SQL pragmas
5547**
5548** PRAGMA [database.]lock_proxy_file=<proxy_path> | :auto:
5549** PRAGMA [database.]lock_proxy_file
5550**
5551** Specifying ":auto:" means that if there is a conch file with a matching
5552** host ID in it, the proxy path in the conch file will be used, otherwise
5553** a proxy path based on the user's temp dir
5554** (via confstr(_CS_DARWIN_USER_TEMP_DIR,...)) will be used and the
5555** actual proxy file name is generated from the name and path of the
5556** database file. For example:
5557**
5558** For database path "/Users/me/foo.db"
5559** The lock path will be "<tmpdir>/sqliteplocks/_Users_me_foo.db:auto:")
5560**
5561** Once a lock proxy is configured for a database connection, it can not
5562** be removed, however it may be switched to a different proxy path via
5563** the above APIs (assuming the conch file is not being held by another
5564** connection or process).
5565**
5566**
5567** How proxy locking works
5568** -----------------------
5569**
5570** Proxy file locking relies primarily on two new supporting files:
5571**
5572** * conch file to limit access to the database file to a single host
5573** at a time
5574**
5575** * proxy file to act as a proxy for the advisory locks normally
5576** taken on the database
5577**
5578** The conch file - to use a proxy file, sqlite must first "hold the conch"
5579** by taking an sqlite-style shared lock on the conch file, reading the
5580** contents and comparing the host's unique host ID (see below) and lock
5581** proxy path against the values stored in the conch. The conch file is
5582** stored in the same directory as the database file and the file name
5583** is patterned after the database file name as ".<databasename>-conch".
5584** If the conch file does not exist, or it's contents do not match the
5585** host ID and/or proxy path, then the lock is escalated to an exclusive
5586** lock and the conch file contents is updated with the host ID and proxy
5587** path and the lock is downgraded to a shared lock again. If the conch
5588** is held by another process (with a shared lock), the exclusive lock
5589** will fail and SQLITE_BUSY is returned.
5590**
5591** The proxy file - a single-byte file used for all advisory file locks
5592** normally taken on the database file. This allows for safe sharing
5593** of the database file for multiple readers and writers on the same
5594** host (the conch ensures that they all use the same local lock file).
5595**
drh715ff302008-12-03 22:32:44 +00005596** Requesting the lock proxy does not immediately take the conch, it is
5597** only taken when the first request to lock database file is made.
5598** This matches the semantics of the traditional locking behavior, where
5599** opening a connection to a database file does not take a lock on it.
5600** The shared lock and an open file descriptor are maintained until
5601** the connection to the database is closed.
5602**
5603** The proxy file and the lock file are never deleted so they only need
5604** to be created the first time they are used.
5605**
5606** Configuration options
5607** ---------------------
5608**
5609** SQLITE_PREFER_PROXY_LOCKING
5610**
5611** Database files accessed on non-local file systems are
5612** automatically configured for proxy locking, lock files are
5613** named automatically using the same logic as
5614** PRAGMA lock_proxy_file=":auto:"
5615**
5616** SQLITE_PROXY_DEBUG
5617**
5618** Enables the logging of error messages during host id file
5619** retrieval and creation
5620**
drh715ff302008-12-03 22:32:44 +00005621** LOCKPROXYDIR
5622**
5623** Overrides the default directory used for lock proxy files that
5624** are named automatically via the ":auto:" setting
5625**
5626** SQLITE_DEFAULT_PROXYDIR_PERMISSIONS
5627**
5628** Permissions to use when creating a directory for storing the
5629** lock proxy files, only used when LOCKPROXYDIR is not set.
5630**
5631**
5632** As mentioned above, when compiled with SQLITE_PREFER_PROXY_LOCKING,
5633** setting the environment variable SQLITE_FORCE_PROXY_LOCKING to 1 will
5634** force proxy locking to be used for every database file opened, and 0
5635** will force automatic proxy locking to be disabled for all database
5636** files (explicity calling the SQLITE_SET_LOCKPROXYFILE pragma or
5637** sqlite_file_control API is not affected by SQLITE_FORCE_PROXY_LOCKING).
5638*/
5639
5640/*
5641** Proxy locking is only available on MacOSX
5642*/
drhd2cb50b2009-01-09 21:41:17 +00005643#if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE
drh715ff302008-12-03 22:32:44 +00005644
drh715ff302008-12-03 22:32:44 +00005645/*
5646** The proxyLockingContext has the path and file structures for the remote
5647** and local proxy files in it
5648*/
5649typedef struct proxyLockingContext proxyLockingContext;
5650struct proxyLockingContext {
5651 unixFile *conchFile; /* Open conch file */
5652 char *conchFilePath; /* Name of the conch file */
5653 unixFile *lockProxy; /* Open proxy lock file */
5654 char *lockProxyPath; /* Name of the proxy lock file */
5655 char *dbPath; /* Name of the open file */
drh7ed97b92010-01-20 13:07:21 +00005656 int conchHeld; /* 1 if the conch is held, -1 if lockless */
drh715ff302008-12-03 22:32:44 +00005657 void *oldLockingContext; /* Original lockingcontext to restore on close */
5658 sqlite3_io_methods const *pOldMethod; /* Original I/O methods for close */
5659};
5660
drh7ed97b92010-01-20 13:07:21 +00005661/*
5662** The proxy lock file path for the database at dbPath is written into lPath,
5663** which must point to valid, writable memory large enough for a maxLen length
5664** file path.
drh715ff302008-12-03 22:32:44 +00005665*/
drh715ff302008-12-03 22:32:44 +00005666static int proxyGetLockPath(const char *dbPath, char *lPath, size_t maxLen){
5667 int len;
5668 int dbLen;
5669 int i;
5670
5671#ifdef LOCKPROXYDIR
5672 len = strlcpy(lPath, LOCKPROXYDIR, maxLen);
5673#else
5674# ifdef _CS_DARWIN_USER_TEMP_DIR
5675 {
drh7ed97b92010-01-20 13:07:21 +00005676 if( !confstr(_CS_DARWIN_USER_TEMP_DIR, lPath, maxLen) ){
drh308c2a52010-05-14 11:30:18 +00005677 OSTRACE(("GETLOCKPATH failed %s errno=%d pid=%d\n",
5678 lPath, errno, getpid()));
drh7ed97b92010-01-20 13:07:21 +00005679 return SQLITE_IOERR_LOCK;
drh715ff302008-12-03 22:32:44 +00005680 }
drh7ed97b92010-01-20 13:07:21 +00005681 len = strlcat(lPath, "sqliteplocks", maxLen);
drh715ff302008-12-03 22:32:44 +00005682 }
5683# else
5684 len = strlcpy(lPath, "/tmp/", maxLen);
5685# endif
5686#endif
5687
5688 if( lPath[len-1]!='/' ){
5689 len = strlcat(lPath, "/", maxLen);
5690 }
5691
5692 /* transform the db path to a unique cache name */
drhea678832008-12-10 19:26:22 +00005693 dbLen = (int)strlen(dbPath);
drh0ab216a2010-07-02 17:10:40 +00005694 for( i=0; i<dbLen && (i+len+7)<(int)maxLen; i++){
drh715ff302008-12-03 22:32:44 +00005695 char c = dbPath[i];
5696 lPath[i+len] = (c=='/')?'_':c;
5697 }
5698 lPath[i+len]='\0';
5699 strlcat(lPath, ":auto:", maxLen);
drh308c2a52010-05-14 11:30:18 +00005700 OSTRACE(("GETLOCKPATH proxy lock path=%s pid=%d\n", lPath, getpid()));
drh715ff302008-12-03 22:32:44 +00005701 return SQLITE_OK;
5702}
5703
drh7ed97b92010-01-20 13:07:21 +00005704/*
5705 ** Creates the lock file and any missing directories in lockPath
5706 */
5707static int proxyCreateLockPath(const char *lockPath){
5708 int i, len;
5709 char buf[MAXPATHLEN];
5710 int start = 0;
5711
5712 assert(lockPath!=NULL);
5713 /* try to create all the intermediate directories */
5714 len = (int)strlen(lockPath);
5715 buf[0] = lockPath[0];
5716 for( i=1; i<len; i++ ){
5717 if( lockPath[i] == '/' && (i - start > 0) ){
5718 /* only mkdir if leaf dir != "." or "/" or ".." */
5719 if( i-start>2 || (i-start==1 && buf[start] != '.' && buf[start] != '/')
5720 || (i-start==2 && buf[start] != '.' && buf[start+1] != '.') ){
5721 buf[i]='\0';
5722 if( mkdir(buf, SQLITE_DEFAULT_PROXYDIR_PERMISSIONS) ){
5723 int err=errno;
5724 if( err!=EEXIST ) {
drh308c2a52010-05-14 11:30:18 +00005725 OSTRACE(("CREATELOCKPATH FAILED creating %s, "
drh7ed97b92010-01-20 13:07:21 +00005726 "'%s' proxy lock path=%s pid=%d\n",
drh308c2a52010-05-14 11:30:18 +00005727 buf, strerror(err), lockPath, getpid()));
drh7ed97b92010-01-20 13:07:21 +00005728 return err;
5729 }
5730 }
5731 }
5732 start=i+1;
5733 }
5734 buf[i] = lockPath[i];
5735 }
drh308c2a52010-05-14 11:30:18 +00005736 OSTRACE(("CREATELOCKPATH proxy lock path=%s pid=%d\n", lockPath, getpid()));
drh7ed97b92010-01-20 13:07:21 +00005737 return 0;
5738}
5739
drh715ff302008-12-03 22:32:44 +00005740/*
5741** Create a new VFS file descriptor (stored in memory obtained from
5742** sqlite3_malloc) and open the file named "path" in the file descriptor.
5743**
5744** The caller is responsible not only for closing the file descriptor
5745** but also for freeing the memory associated with the file descriptor.
5746*/
drh7ed97b92010-01-20 13:07:21 +00005747static int proxyCreateUnixFile(
5748 const char *path, /* path for the new unixFile */
5749 unixFile **ppFile, /* unixFile created and returned by ref */
5750 int islockfile /* if non zero missing dirs will be created */
5751) {
5752 int fd = -1;
drh715ff302008-12-03 22:32:44 +00005753 unixFile *pNew;
5754 int rc = SQLITE_OK;
drh7ed97b92010-01-20 13:07:21 +00005755 int openFlags = O_RDWR | O_CREAT;
drh715ff302008-12-03 22:32:44 +00005756 sqlite3_vfs dummyVfs;
drh7ed97b92010-01-20 13:07:21 +00005757 int terrno = 0;
5758 UnixUnusedFd *pUnused = NULL;
drh715ff302008-12-03 22:32:44 +00005759
drh7ed97b92010-01-20 13:07:21 +00005760 /* 1. first try to open/create the file
5761 ** 2. if that fails, and this is a lock file (not-conch), try creating
5762 ** the parent directories and then try again.
5763 ** 3. if that fails, try to open the file read-only
5764 ** otherwise return BUSY (if lock file) or CANTOPEN for the conch file
5765 */
5766 pUnused = findReusableFd(path, openFlags);
5767 if( pUnused ){
5768 fd = pUnused->fd;
5769 }else{
5770 pUnused = sqlite3_malloc(sizeof(*pUnused));
5771 if( !pUnused ){
5772 return SQLITE_NOMEM;
5773 }
5774 }
5775 if( fd<0 ){
drhad4f1e52011-03-04 15:43:57 +00005776 fd = robust_open(path, openFlags, SQLITE_DEFAULT_FILE_PERMISSIONS);
drh7ed97b92010-01-20 13:07:21 +00005777 terrno = errno;
5778 if( fd<0 && errno==ENOENT && islockfile ){
5779 if( proxyCreateLockPath(path) == SQLITE_OK ){
drhad4f1e52011-03-04 15:43:57 +00005780 fd = robust_open(path, openFlags, SQLITE_DEFAULT_FILE_PERMISSIONS);
drh7ed97b92010-01-20 13:07:21 +00005781 }
5782 }
5783 }
5784 if( fd<0 ){
5785 openFlags = O_RDONLY;
drhad4f1e52011-03-04 15:43:57 +00005786 fd = robust_open(path, openFlags, SQLITE_DEFAULT_FILE_PERMISSIONS);
drh7ed97b92010-01-20 13:07:21 +00005787 terrno = errno;
5788 }
5789 if( fd<0 ){
5790 if( islockfile ){
5791 return SQLITE_BUSY;
5792 }
5793 switch (terrno) {
5794 case EACCES:
5795 return SQLITE_PERM;
5796 case EIO:
5797 return SQLITE_IOERR_LOCK; /* even though it is the conch */
5798 default:
drh9978c972010-02-23 17:36:32 +00005799 return SQLITE_CANTOPEN_BKPT;
drh7ed97b92010-01-20 13:07:21 +00005800 }
5801 }
5802
5803 pNew = (unixFile *)sqlite3_malloc(sizeof(*pNew));
5804 if( pNew==NULL ){
5805 rc = SQLITE_NOMEM;
5806 goto end_create_proxy;
drh715ff302008-12-03 22:32:44 +00005807 }
5808 memset(pNew, 0, sizeof(unixFile));
drh7ed97b92010-01-20 13:07:21 +00005809 pNew->openFlags = openFlags;
dan211fb082011-04-01 09:04:36 +00005810 memset(&dummyVfs, 0, sizeof(dummyVfs));
drh1875f7a2008-12-08 18:19:17 +00005811 dummyVfs.pAppData = (void*)&autolockIoFinder;
dan211fb082011-04-01 09:04:36 +00005812 dummyVfs.zName = "dummy";
drh7ed97b92010-01-20 13:07:21 +00005813 pUnused->fd = fd;
5814 pUnused->flags = openFlags;
5815 pNew->pUnused = pUnused;
5816
drh0059eae2011-08-08 23:48:40 +00005817 rc = fillInUnixFile(&dummyVfs, fd, 0, (sqlite3_file*)pNew, path, 0, 0, 0);
drh7ed97b92010-01-20 13:07:21 +00005818 if( rc==SQLITE_OK ){
5819 *ppFile = pNew;
5820 return SQLITE_OK;
drh715ff302008-12-03 22:32:44 +00005821 }
drh7ed97b92010-01-20 13:07:21 +00005822end_create_proxy:
drh0e9365c2011-03-02 02:08:13 +00005823 robust_close(pNew, fd, __LINE__);
drh7ed97b92010-01-20 13:07:21 +00005824 sqlite3_free(pNew);
5825 sqlite3_free(pUnused);
drh715ff302008-12-03 22:32:44 +00005826 return rc;
5827}
5828
drh7ed97b92010-01-20 13:07:21 +00005829#ifdef SQLITE_TEST
5830/* simulate multiple hosts by creating unique hostid file paths */
5831int sqlite3_hostid_num = 0;
5832#endif
5833
5834#define PROXY_HOSTIDLEN 16 /* conch file host id length */
5835
drh0ab216a2010-07-02 17:10:40 +00005836/* Not always defined in the headers as it ought to be */
5837extern int gethostuuid(uuid_t id, const struct timespec *wait);
5838
drh7ed97b92010-01-20 13:07:21 +00005839/* get the host ID via gethostuuid(), pHostID must point to PROXY_HOSTIDLEN
5840** bytes of writable memory.
5841*/
5842static int proxyGetHostID(unsigned char *pHostID, int *pError){
drh7ed97b92010-01-20 13:07:21 +00005843 assert(PROXY_HOSTIDLEN == sizeof(uuid_t));
5844 memset(pHostID, 0, PROXY_HOSTIDLEN);
drhe8b0c9b2010-09-25 14:13:17 +00005845#if defined(__MAX_OS_X_VERSION_MIN_REQUIRED)\
5846 && __MAC_OS_X_VERSION_MIN_REQUIRED<1050
drh29ecd8a2010-12-21 00:16:40 +00005847 {
5848 static const struct timespec timeout = {1, 0}; /* 1 sec timeout */
5849 if( gethostuuid(pHostID, &timeout) ){
5850 int err = errno;
5851 if( pError ){
5852 *pError = err;
5853 }
5854 return SQLITE_IOERR;
drh7ed97b92010-01-20 13:07:21 +00005855 }
drh7ed97b92010-01-20 13:07:21 +00005856 }
drhe8b0c9b2010-09-25 14:13:17 +00005857#endif
drh7ed97b92010-01-20 13:07:21 +00005858#ifdef SQLITE_TEST
5859 /* simulate multiple hosts by creating unique hostid file paths */
5860 if( sqlite3_hostid_num != 0){
5861 pHostID[0] = (char)(pHostID[0] + (char)(sqlite3_hostid_num & 0xFF));
5862 }
5863#endif
5864
5865 return SQLITE_OK;
5866}
5867
5868/* The conch file contains the header, host id and lock file path
5869 */
5870#define PROXY_CONCHVERSION 2 /* 1-byte header, 16-byte host id, path */
5871#define PROXY_HEADERLEN 1 /* conch file header length */
5872#define PROXY_PATHINDEX (PROXY_HEADERLEN+PROXY_HOSTIDLEN)
5873#define PROXY_MAXCONCHLEN (PROXY_HEADERLEN+PROXY_HOSTIDLEN+MAXPATHLEN)
5874
5875/*
5876** Takes an open conch file, copies the contents to a new path and then moves
5877** it back. The newly created file's file descriptor is assigned to the
5878** conch file structure and finally the original conch file descriptor is
5879** closed. Returns zero if successful.
5880*/
5881static int proxyBreakConchLock(unixFile *pFile, uuid_t myHostID){
5882 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
5883 unixFile *conchFile = pCtx->conchFile;
5884 char tPath[MAXPATHLEN];
5885 char buf[PROXY_MAXCONCHLEN];
5886 char *cPath = pCtx->conchFilePath;
5887 size_t readLen = 0;
5888 size_t pathLen = 0;
5889 char errmsg[64] = "";
5890 int fd = -1;
5891 int rc = -1;
drh0ab216a2010-07-02 17:10:40 +00005892 UNUSED_PARAMETER(myHostID);
drh7ed97b92010-01-20 13:07:21 +00005893
5894 /* create a new path by replace the trailing '-conch' with '-break' */
5895 pathLen = strlcpy(tPath, cPath, MAXPATHLEN);
5896 if( pathLen>MAXPATHLEN || pathLen<6 ||
5897 (strlcpy(&tPath[pathLen-5], "break", 6) != 5) ){
dan0cb3a1e2010-11-29 17:55:18 +00005898 sqlite3_snprintf(sizeof(errmsg),errmsg,"path error (len %d)",(int)pathLen);
drh7ed97b92010-01-20 13:07:21 +00005899 goto end_breaklock;
5900 }
5901 /* read the conch content */
drhe562be52011-03-02 18:01:10 +00005902 readLen = osPread(conchFile->h, buf, PROXY_MAXCONCHLEN, 0);
drh7ed97b92010-01-20 13:07:21 +00005903 if( readLen<PROXY_PATHINDEX ){
dan0cb3a1e2010-11-29 17:55:18 +00005904 sqlite3_snprintf(sizeof(errmsg),errmsg,"read error (len %d)",(int)readLen);
drh7ed97b92010-01-20 13:07:21 +00005905 goto end_breaklock;
5906 }
5907 /* write it out to the temporary break file */
drhad4f1e52011-03-04 15:43:57 +00005908 fd = robust_open(tPath, (O_RDWR|O_CREAT|O_EXCL),
5909 SQLITE_DEFAULT_FILE_PERMISSIONS);
drh7ed97b92010-01-20 13:07:21 +00005910 if( fd<0 ){
dan0cb3a1e2010-11-29 17:55:18 +00005911 sqlite3_snprintf(sizeof(errmsg), errmsg, "create failed (%d)", errno);
drh7ed97b92010-01-20 13:07:21 +00005912 goto end_breaklock;
5913 }
drhe562be52011-03-02 18:01:10 +00005914 if( osPwrite(fd, buf, readLen, 0) != (ssize_t)readLen ){
dan0cb3a1e2010-11-29 17:55:18 +00005915 sqlite3_snprintf(sizeof(errmsg), errmsg, "write failed (%d)", errno);
drh7ed97b92010-01-20 13:07:21 +00005916 goto end_breaklock;
5917 }
5918 if( rename(tPath, cPath) ){
dan0cb3a1e2010-11-29 17:55:18 +00005919 sqlite3_snprintf(sizeof(errmsg), errmsg, "rename failed (%d)", errno);
drh7ed97b92010-01-20 13:07:21 +00005920 goto end_breaklock;
5921 }
5922 rc = 0;
5923 fprintf(stderr, "broke stale lock on %s\n", cPath);
drh0e9365c2011-03-02 02:08:13 +00005924 robust_close(pFile, conchFile->h, __LINE__);
drh7ed97b92010-01-20 13:07:21 +00005925 conchFile->h = fd;
5926 conchFile->openFlags = O_RDWR | O_CREAT;
5927
5928end_breaklock:
5929 if( rc ){
5930 if( fd>=0 ){
drh036ac7f2011-08-08 23:18:05 +00005931 osUnlink(tPath);
drh0e9365c2011-03-02 02:08:13 +00005932 robust_close(pFile, fd, __LINE__);
drh7ed97b92010-01-20 13:07:21 +00005933 }
5934 fprintf(stderr, "failed to break stale lock on %s, %s\n", cPath, errmsg);
5935 }
5936 return rc;
5937}
5938
5939/* Take the requested lock on the conch file and break a stale lock if the
5940** host id matches.
5941*/
5942static int proxyConchLock(unixFile *pFile, uuid_t myHostID, int lockType){
5943 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
5944 unixFile *conchFile = pCtx->conchFile;
5945 int rc = SQLITE_OK;
5946 int nTries = 0;
5947 struct timespec conchModTime;
5948
5949 do {
5950 rc = conchFile->pMethod->xLock((sqlite3_file*)conchFile, lockType);
5951 nTries ++;
5952 if( rc==SQLITE_BUSY ){
5953 /* If the lock failed (busy):
5954 * 1st try: get the mod time of the conch, wait 0.5s and try again.
5955 * 2nd try: fail if the mod time changed or host id is different, wait
5956 * 10 sec and try again
5957 * 3rd try: break the lock unless the mod time has changed.
5958 */
5959 struct stat buf;
drh99ab3b12011-03-02 15:09:07 +00005960 if( osFstat(conchFile->h, &buf) ){
drh7ed97b92010-01-20 13:07:21 +00005961 pFile->lastErrno = errno;
5962 return SQLITE_IOERR_LOCK;
5963 }
5964
5965 if( nTries==1 ){
5966 conchModTime = buf.st_mtimespec;
5967 usleep(500000); /* wait 0.5 sec and try the lock again*/
5968 continue;
5969 }
5970
5971 assert( nTries>1 );
5972 if( conchModTime.tv_sec != buf.st_mtimespec.tv_sec ||
5973 conchModTime.tv_nsec != buf.st_mtimespec.tv_nsec ){
5974 return SQLITE_BUSY;
5975 }
5976
5977 if( nTries==2 ){
5978 char tBuf[PROXY_MAXCONCHLEN];
drhe562be52011-03-02 18:01:10 +00005979 int len = osPread(conchFile->h, tBuf, PROXY_MAXCONCHLEN, 0);
drh7ed97b92010-01-20 13:07:21 +00005980 if( len<0 ){
5981 pFile->lastErrno = errno;
5982 return SQLITE_IOERR_LOCK;
5983 }
5984 if( len>PROXY_PATHINDEX && tBuf[0]==(char)PROXY_CONCHVERSION){
5985 /* don't break the lock if the host id doesn't match */
5986 if( 0!=memcmp(&tBuf[PROXY_HEADERLEN], myHostID, PROXY_HOSTIDLEN) ){
5987 return SQLITE_BUSY;
5988 }
5989 }else{
5990 /* don't break the lock on short read or a version mismatch */
5991 return SQLITE_BUSY;
5992 }
5993 usleep(10000000); /* wait 10 sec and try the lock again */
5994 continue;
5995 }
5996
5997 assert( nTries==3 );
5998 if( 0==proxyBreakConchLock(pFile, myHostID) ){
5999 rc = SQLITE_OK;
6000 if( lockType==EXCLUSIVE_LOCK ){
6001 rc = conchFile->pMethod->xLock((sqlite3_file*)conchFile, SHARED_LOCK);
6002 }
6003 if( !rc ){
6004 rc = conchFile->pMethod->xLock((sqlite3_file*)conchFile, lockType);
6005 }
6006 }
6007 }
6008 } while( rc==SQLITE_BUSY && nTries<3 );
6009
6010 return rc;
6011}
6012
6013/* Takes the conch by taking a shared lock and read the contents conch, if
drh715ff302008-12-03 22:32:44 +00006014** lockPath is non-NULL, the host ID and lock file path must match. A NULL
6015** lockPath means that the lockPath in the conch file will be used if the
6016** host IDs match, or a new lock path will be generated automatically
6017** and written to the conch file.
6018*/
6019static int proxyTakeConch(unixFile *pFile){
6020 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
6021
drh7ed97b92010-01-20 13:07:21 +00006022 if( pCtx->conchHeld!=0 ){
drh715ff302008-12-03 22:32:44 +00006023 return SQLITE_OK;
6024 }else{
6025 unixFile *conchFile = pCtx->conchFile;
drh7ed97b92010-01-20 13:07:21 +00006026 uuid_t myHostID;
6027 int pError = 0;
6028 char readBuf[PROXY_MAXCONCHLEN];
drh715ff302008-12-03 22:32:44 +00006029 char lockPath[MAXPATHLEN];
drh7ed97b92010-01-20 13:07:21 +00006030 char *tempLockPath = NULL;
drh715ff302008-12-03 22:32:44 +00006031 int rc = SQLITE_OK;
drh7ed97b92010-01-20 13:07:21 +00006032 int createConch = 0;
6033 int hostIdMatch = 0;
6034 int readLen = 0;
6035 int tryOldLockPath = 0;
6036 int forceNewLockPath = 0;
6037
drh308c2a52010-05-14 11:30:18 +00006038 OSTRACE(("TAKECONCH %d for %s pid=%d\n", conchFile->h,
6039 (pCtx->lockProxyPath ? pCtx->lockProxyPath : ":auto:"), getpid()));
drh715ff302008-12-03 22:32:44 +00006040
drh7ed97b92010-01-20 13:07:21 +00006041 rc = proxyGetHostID(myHostID, &pError);
6042 if( (rc&0xff)==SQLITE_IOERR ){
6043 pFile->lastErrno = pError;
6044 goto end_takeconch;
drh715ff302008-12-03 22:32:44 +00006045 }
drh7ed97b92010-01-20 13:07:21 +00006046 rc = proxyConchLock(pFile, myHostID, SHARED_LOCK);
drh715ff302008-12-03 22:32:44 +00006047 if( rc!=SQLITE_OK ){
6048 goto end_takeconch;
6049 }
drh7ed97b92010-01-20 13:07:21 +00006050 /* read the existing conch file */
6051 readLen = seekAndRead((unixFile*)conchFile, 0, readBuf, PROXY_MAXCONCHLEN);
6052 if( readLen<0 ){
6053 /* I/O error: lastErrno set by seekAndRead */
6054 pFile->lastErrno = conchFile->lastErrno;
6055 rc = SQLITE_IOERR_READ;
6056 goto end_takeconch;
6057 }else if( readLen<=(PROXY_HEADERLEN+PROXY_HOSTIDLEN) ||
6058 readBuf[0]!=(char)PROXY_CONCHVERSION ){
6059 /* a short read or version format mismatch means we need to create a new
6060 ** conch file.
6061 */
6062 createConch = 1;
6063 }
6064 /* if the host id matches and the lock path already exists in the conch
6065 ** we'll try to use the path there, if we can't open that path, we'll
6066 ** retry with a new auto-generated path
6067 */
6068 do { /* in case we need to try again for an :auto: named lock file */
6069
6070 if( !createConch && !forceNewLockPath ){
6071 hostIdMatch = !memcmp(&readBuf[PROXY_HEADERLEN], myHostID,
6072 PROXY_HOSTIDLEN);
6073 /* if the conch has data compare the contents */
6074 if( !pCtx->lockProxyPath ){
6075 /* for auto-named local lock file, just check the host ID and we'll
6076 ** use the local lock file path that's already in there
6077 */
6078 if( hostIdMatch ){
6079 size_t pathLen = (readLen - PROXY_PATHINDEX);
6080
6081 if( pathLen>=MAXPATHLEN ){
6082 pathLen=MAXPATHLEN-1;
6083 }
6084 memcpy(lockPath, &readBuf[PROXY_PATHINDEX], pathLen);
6085 lockPath[pathLen] = 0;
6086 tempLockPath = lockPath;
6087 tryOldLockPath = 1;
6088 /* create a copy of the lock path if the conch is taken */
6089 goto end_takeconch;
6090 }
6091 }else if( hostIdMatch
6092 && !strncmp(pCtx->lockProxyPath, &readBuf[PROXY_PATHINDEX],
6093 readLen-PROXY_PATHINDEX)
6094 ){
6095 /* conch host and lock path match */
6096 goto end_takeconch;
drh715ff302008-12-03 22:32:44 +00006097 }
drh7ed97b92010-01-20 13:07:21 +00006098 }
6099
6100 /* if the conch isn't writable and doesn't match, we can't take it */
6101 if( (conchFile->openFlags&O_RDWR) == 0 ){
6102 rc = SQLITE_BUSY;
drh715ff302008-12-03 22:32:44 +00006103 goto end_takeconch;
6104 }
drh7ed97b92010-01-20 13:07:21 +00006105
6106 /* either the conch didn't match or we need to create a new one */
drh715ff302008-12-03 22:32:44 +00006107 if( !pCtx->lockProxyPath ){
drh7ed97b92010-01-20 13:07:21 +00006108 proxyGetLockPath(pCtx->dbPath, lockPath, MAXPATHLEN);
6109 tempLockPath = lockPath;
6110 /* create a copy of the lock path _only_ if the conch is taken */
drh715ff302008-12-03 22:32:44 +00006111 }
drh7ed97b92010-01-20 13:07:21 +00006112
6113 /* update conch with host and path (this will fail if other process
6114 ** has a shared lock already), if the host id matches, use the big
6115 ** stick.
drh715ff302008-12-03 22:32:44 +00006116 */
drh7ed97b92010-01-20 13:07:21 +00006117 futimes(conchFile->h, NULL);
6118 if( hostIdMatch && !createConch ){
drh8af6c222010-05-14 12:43:01 +00006119 if( conchFile->pInode && conchFile->pInode->nShared>1 ){
drh7ed97b92010-01-20 13:07:21 +00006120 /* We are trying for an exclusive lock but another thread in this
6121 ** same process is still holding a shared lock. */
6122 rc = SQLITE_BUSY;
6123 } else {
6124 rc = proxyConchLock(pFile, myHostID, EXCLUSIVE_LOCK);
drh715ff302008-12-03 22:32:44 +00006125 }
drh715ff302008-12-03 22:32:44 +00006126 }else{
drh7ed97b92010-01-20 13:07:21 +00006127 rc = conchFile->pMethod->xLock((sqlite3_file*)conchFile, EXCLUSIVE_LOCK);
drh715ff302008-12-03 22:32:44 +00006128 }
drh7ed97b92010-01-20 13:07:21 +00006129 if( rc==SQLITE_OK ){
6130 char writeBuffer[PROXY_MAXCONCHLEN];
6131 int writeSize = 0;
6132
6133 writeBuffer[0] = (char)PROXY_CONCHVERSION;
6134 memcpy(&writeBuffer[PROXY_HEADERLEN], myHostID, PROXY_HOSTIDLEN);
6135 if( pCtx->lockProxyPath!=NULL ){
6136 strlcpy(&writeBuffer[PROXY_PATHINDEX], pCtx->lockProxyPath, MAXPATHLEN);
6137 }else{
6138 strlcpy(&writeBuffer[PROXY_PATHINDEX], tempLockPath, MAXPATHLEN);
6139 }
6140 writeSize = PROXY_PATHINDEX + strlen(&writeBuffer[PROXY_PATHINDEX]);
drhff812312011-02-23 13:33:46 +00006141 robust_ftruncate(conchFile->h, writeSize);
drh7ed97b92010-01-20 13:07:21 +00006142 rc = unixWrite((sqlite3_file *)conchFile, writeBuffer, writeSize, 0);
6143 fsync(conchFile->h);
6144 /* If we created a new conch file (not just updated the contents of a
6145 ** valid conch file), try to match the permissions of the database
6146 */
6147 if( rc==SQLITE_OK && createConch ){
6148 struct stat buf;
drh99ab3b12011-03-02 15:09:07 +00006149 int err = osFstat(pFile->h, &buf);
drh7ed97b92010-01-20 13:07:21 +00006150 if( err==0 ){
6151 mode_t cmode = buf.st_mode&(S_IRUSR|S_IWUSR | S_IRGRP|S_IWGRP |
6152 S_IROTH|S_IWOTH);
6153 /* try to match the database file R/W permissions, ignore failure */
6154#ifndef SQLITE_PROXY_DEBUG
drhe562be52011-03-02 18:01:10 +00006155 osFchmod(conchFile->h, cmode);
drh7ed97b92010-01-20 13:07:21 +00006156#else
drhff812312011-02-23 13:33:46 +00006157 do{
drhe562be52011-03-02 18:01:10 +00006158 rc = osFchmod(conchFile->h, cmode);
drhff812312011-02-23 13:33:46 +00006159 }while( rc==(-1) && errno==EINTR );
6160 if( rc!=0 ){
drh7ed97b92010-01-20 13:07:21 +00006161 int code = errno;
6162 fprintf(stderr, "fchmod %o FAILED with %d %s\n",
6163 cmode, code, strerror(code));
6164 } else {
6165 fprintf(stderr, "fchmod %o SUCCEDED\n",cmode);
6166 }
6167 }else{
6168 int code = errno;
6169 fprintf(stderr, "STAT FAILED[%d] with %d %s\n",
6170 err, code, strerror(code));
6171#endif
6172 }
drh715ff302008-12-03 22:32:44 +00006173 }
6174 }
drh7ed97b92010-01-20 13:07:21 +00006175 conchFile->pMethod->xUnlock((sqlite3_file*)conchFile, SHARED_LOCK);
6176
6177 end_takeconch:
drh308c2a52010-05-14 11:30:18 +00006178 OSTRACE(("TRANSPROXY: CLOSE %d\n", pFile->h));
drh7ed97b92010-01-20 13:07:21 +00006179 if( rc==SQLITE_OK && pFile->openFlags ){
6180 if( pFile->h>=0 ){
drhe84009f2011-03-02 17:54:32 +00006181 robust_close(pFile, pFile->h, __LINE__);
drh7ed97b92010-01-20 13:07:21 +00006182 }
6183 pFile->h = -1;
drhad4f1e52011-03-04 15:43:57 +00006184 int fd = robust_open(pCtx->dbPath, pFile->openFlags,
drh7ed97b92010-01-20 13:07:21 +00006185 SQLITE_DEFAULT_FILE_PERMISSIONS);
drh308c2a52010-05-14 11:30:18 +00006186 OSTRACE(("TRANSPROXY: OPEN %d\n", fd));
drh7ed97b92010-01-20 13:07:21 +00006187 if( fd>=0 ){
6188 pFile->h = fd;
6189 }else{
drh9978c972010-02-23 17:36:32 +00006190 rc=SQLITE_CANTOPEN_BKPT; /* SQLITE_BUSY? proxyTakeConch called
drh7ed97b92010-01-20 13:07:21 +00006191 during locking */
6192 }
6193 }
6194 if( rc==SQLITE_OK && !pCtx->lockProxy ){
6195 char *path = tempLockPath ? tempLockPath : pCtx->lockProxyPath;
6196 rc = proxyCreateUnixFile(path, &pCtx->lockProxy, 1);
6197 if( rc!=SQLITE_OK && rc!=SQLITE_NOMEM && tryOldLockPath ){
6198 /* we couldn't create the proxy lock file with the old lock file path
6199 ** so try again via auto-naming
6200 */
6201 forceNewLockPath = 1;
6202 tryOldLockPath = 0;
dan2b0ef472010-02-16 12:18:47 +00006203 continue; /* go back to the do {} while start point, try again */
drh7ed97b92010-01-20 13:07:21 +00006204 }
6205 }
6206 if( rc==SQLITE_OK ){
6207 /* Need to make a copy of path if we extracted the value
6208 ** from the conch file or the path was allocated on the stack
6209 */
6210 if( tempLockPath ){
6211 pCtx->lockProxyPath = sqlite3DbStrDup(0, tempLockPath);
6212 if( !pCtx->lockProxyPath ){
6213 rc = SQLITE_NOMEM;
6214 }
6215 }
6216 }
6217 if( rc==SQLITE_OK ){
6218 pCtx->conchHeld = 1;
6219
6220 if( pCtx->lockProxy->pMethod == &afpIoMethods ){
6221 afpLockingContext *afpCtx;
6222 afpCtx = (afpLockingContext *)pCtx->lockProxy->lockingContext;
6223 afpCtx->dbPath = pCtx->lockProxyPath;
6224 }
6225 } else {
6226 conchFile->pMethod->xUnlock((sqlite3_file*)conchFile, NO_LOCK);
6227 }
drh308c2a52010-05-14 11:30:18 +00006228 OSTRACE(("TAKECONCH %d %s\n", conchFile->h,
6229 rc==SQLITE_OK?"ok":"failed"));
drh7ed97b92010-01-20 13:07:21 +00006230 return rc;
drh308c2a52010-05-14 11:30:18 +00006231 } while (1); /* in case we need to retry the :auto: lock file -
6232 ** we should never get here except via the 'continue' call. */
drh715ff302008-12-03 22:32:44 +00006233 }
6234}
6235
6236/*
6237** If pFile holds a lock on a conch file, then release that lock.
6238*/
6239static int proxyReleaseConch(unixFile *pFile){
drh1c5bb4d2010-05-10 17:29:28 +00006240 int rc = SQLITE_OK; /* Subroutine return code */
drh715ff302008-12-03 22:32:44 +00006241 proxyLockingContext *pCtx; /* The locking context for the proxy lock */
6242 unixFile *conchFile; /* Name of the conch file */
6243
6244 pCtx = (proxyLockingContext *)pFile->lockingContext;
6245 conchFile = pCtx->conchFile;
drh308c2a52010-05-14 11:30:18 +00006246 OSTRACE(("RELEASECONCH %d for %s pid=%d\n", conchFile->h,
drh715ff302008-12-03 22:32:44 +00006247 (pCtx->lockProxyPath ? pCtx->lockProxyPath : ":auto:"),
drh308c2a52010-05-14 11:30:18 +00006248 getpid()));
drh7ed97b92010-01-20 13:07:21 +00006249 if( pCtx->conchHeld>0 ){
6250 rc = conchFile->pMethod->xUnlock((sqlite3_file*)conchFile, NO_LOCK);
6251 }
drh715ff302008-12-03 22:32:44 +00006252 pCtx->conchHeld = 0;
drh308c2a52010-05-14 11:30:18 +00006253 OSTRACE(("RELEASECONCH %d %s\n", conchFile->h,
6254 (rc==SQLITE_OK ? "ok" : "failed")));
drh715ff302008-12-03 22:32:44 +00006255 return rc;
6256}
6257
6258/*
6259** Given the name of a database file, compute the name of its conch file.
6260** Store the conch filename in memory obtained from sqlite3_malloc().
6261** Make *pConchPath point to the new name. Return SQLITE_OK on success
6262** or SQLITE_NOMEM if unable to obtain memory.
6263**
6264** The caller is responsible for ensuring that the allocated memory
6265** space is eventually freed.
6266**
6267** *pConchPath is set to NULL if a memory allocation error occurs.
6268*/
6269static int proxyCreateConchPathname(char *dbPath, char **pConchPath){
6270 int i; /* Loop counter */
drhea678832008-12-10 19:26:22 +00006271 int len = (int)strlen(dbPath); /* Length of database filename - dbPath */
drh715ff302008-12-03 22:32:44 +00006272 char *conchPath; /* buffer in which to construct conch name */
6273
6274 /* Allocate space for the conch filename and initialize the name to
6275 ** the name of the original database file. */
6276 *pConchPath = conchPath = (char *)sqlite3_malloc(len + 8);
6277 if( conchPath==0 ){
6278 return SQLITE_NOMEM;
6279 }
6280 memcpy(conchPath, dbPath, len+1);
6281
6282 /* now insert a "." before the last / character */
6283 for( i=(len-1); i>=0; i-- ){
6284 if( conchPath[i]=='/' ){
6285 i++;
6286 break;
6287 }
6288 }
6289 conchPath[i]='.';
6290 while ( i<len ){
6291 conchPath[i+1]=dbPath[i];
6292 i++;
6293 }
6294
6295 /* append the "-conch" suffix to the file */
6296 memcpy(&conchPath[i+1], "-conch", 7);
drhea678832008-12-10 19:26:22 +00006297 assert( (int)strlen(conchPath) == len+7 );
drh715ff302008-12-03 22:32:44 +00006298
6299 return SQLITE_OK;
6300}
6301
6302
6303/* Takes a fully configured proxy locking-style unix file and switches
6304** the local lock file path
6305*/
6306static int switchLockProxyPath(unixFile *pFile, const char *path) {
6307 proxyLockingContext *pCtx = (proxyLockingContext*)pFile->lockingContext;
6308 char *oldPath = pCtx->lockProxyPath;
6309 int rc = SQLITE_OK;
6310
drh308c2a52010-05-14 11:30:18 +00006311 if( pFile->eFileLock!=NO_LOCK ){
drh715ff302008-12-03 22:32:44 +00006312 return SQLITE_BUSY;
6313 }
6314
6315 /* nothing to do if the path is NULL, :auto: or matches the existing path */
6316 if( !path || path[0]=='\0' || !strcmp(path, ":auto:") ||
6317 (oldPath && !strncmp(oldPath, path, MAXPATHLEN)) ){
6318 return SQLITE_OK;
6319 }else{
6320 unixFile *lockProxy = pCtx->lockProxy;
6321 pCtx->lockProxy=NULL;
6322 pCtx->conchHeld = 0;
6323 if( lockProxy!=NULL ){
6324 rc=lockProxy->pMethod->xClose((sqlite3_file *)lockProxy);
6325 if( rc ) return rc;
6326 sqlite3_free(lockProxy);
6327 }
6328 sqlite3_free(oldPath);
6329 pCtx->lockProxyPath = sqlite3DbStrDup(0, path);
6330 }
6331
6332 return rc;
6333}
6334
6335/*
6336** pFile is a file that has been opened by a prior xOpen call. dbPath
6337** is a string buffer at least MAXPATHLEN+1 characters in size.
6338**
6339** This routine find the filename associated with pFile and writes it
6340** int dbPath.
6341*/
6342static int proxyGetDbPathForUnixFile(unixFile *pFile, char *dbPath){
drhd2cb50b2009-01-09 21:41:17 +00006343#if defined(__APPLE__)
drh715ff302008-12-03 22:32:44 +00006344 if( pFile->pMethod == &afpIoMethods ){
6345 /* afp style keeps a reference to the db path in the filePath field
6346 ** of the struct */
drhea678832008-12-10 19:26:22 +00006347 assert( (int)strlen((char*)pFile->lockingContext)<=MAXPATHLEN );
drh7ed97b92010-01-20 13:07:21 +00006348 strlcpy(dbPath, ((afpLockingContext *)pFile->lockingContext)->dbPath, MAXPATHLEN);
6349 } else
drh715ff302008-12-03 22:32:44 +00006350#endif
6351 if( pFile->pMethod == &dotlockIoMethods ){
6352 /* dot lock style uses the locking context to store the dot lock
6353 ** file path */
6354 int len = strlen((char *)pFile->lockingContext) - strlen(DOTLOCK_SUFFIX);
6355 memcpy(dbPath, (char *)pFile->lockingContext, len + 1);
6356 }else{
6357 /* all other styles use the locking context to store the db file path */
6358 assert( strlen((char*)pFile->lockingContext)<=MAXPATHLEN );
drh7ed97b92010-01-20 13:07:21 +00006359 strlcpy(dbPath, (char *)pFile->lockingContext, MAXPATHLEN);
drh715ff302008-12-03 22:32:44 +00006360 }
6361 return SQLITE_OK;
6362}
6363
6364/*
6365** Takes an already filled in unix file and alters it so all file locking
6366** will be performed on the local proxy lock file. The following fields
6367** are preserved in the locking context so that they can be restored and
6368** the unix structure properly cleaned up at close time:
6369** ->lockingContext
6370** ->pMethod
6371*/
6372static int proxyTransformUnixFile(unixFile *pFile, const char *path) {
6373 proxyLockingContext *pCtx;
6374 char dbPath[MAXPATHLEN+1]; /* Name of the database file */
6375 char *lockPath=NULL;
6376 int rc = SQLITE_OK;
6377
drh308c2a52010-05-14 11:30:18 +00006378 if( pFile->eFileLock!=NO_LOCK ){
drh715ff302008-12-03 22:32:44 +00006379 return SQLITE_BUSY;
6380 }
6381 proxyGetDbPathForUnixFile(pFile, dbPath);
6382 if( !path || path[0]=='\0' || !strcmp(path, ":auto:") ){
6383 lockPath=NULL;
6384 }else{
6385 lockPath=(char *)path;
6386 }
6387
drh308c2a52010-05-14 11:30:18 +00006388 OSTRACE(("TRANSPROXY %d for %s pid=%d\n", pFile->h,
6389 (lockPath ? lockPath : ":auto:"), getpid()));
drh715ff302008-12-03 22:32:44 +00006390
6391 pCtx = sqlite3_malloc( sizeof(*pCtx) );
6392 if( pCtx==0 ){
6393 return SQLITE_NOMEM;
6394 }
6395 memset(pCtx, 0, sizeof(*pCtx));
6396
6397 rc = proxyCreateConchPathname(dbPath, &pCtx->conchFilePath);
6398 if( rc==SQLITE_OK ){
drh7ed97b92010-01-20 13:07:21 +00006399 rc = proxyCreateUnixFile(pCtx->conchFilePath, &pCtx->conchFile, 0);
6400 if( rc==SQLITE_CANTOPEN && ((pFile->openFlags&O_RDWR) == 0) ){
6401 /* if (a) the open flags are not O_RDWR, (b) the conch isn't there, and
6402 ** (c) the file system is read-only, then enable no-locking access.
6403 ** Ugh, since O_RDONLY==0x0000 we test for !O_RDWR since unixOpen asserts
6404 ** that openFlags will have only one of O_RDONLY or O_RDWR.
6405 */
6406 struct statfs fsInfo;
6407 struct stat conchInfo;
6408 int goLockless = 0;
6409
drh99ab3b12011-03-02 15:09:07 +00006410 if( osStat(pCtx->conchFilePath, &conchInfo) == -1 ) {
drh7ed97b92010-01-20 13:07:21 +00006411 int err = errno;
6412 if( (err==ENOENT) && (statfs(dbPath, &fsInfo) != -1) ){
6413 goLockless = (fsInfo.f_flags&MNT_RDONLY) == MNT_RDONLY;
6414 }
6415 }
6416 if( goLockless ){
6417 pCtx->conchHeld = -1; /* read only FS/ lockless */
6418 rc = SQLITE_OK;
6419 }
6420 }
drh715ff302008-12-03 22:32:44 +00006421 }
6422 if( rc==SQLITE_OK && lockPath ){
6423 pCtx->lockProxyPath = sqlite3DbStrDup(0, lockPath);
6424 }
6425
6426 if( rc==SQLITE_OK ){
drh7ed97b92010-01-20 13:07:21 +00006427 pCtx->dbPath = sqlite3DbStrDup(0, dbPath);
6428 if( pCtx->dbPath==NULL ){
6429 rc = SQLITE_NOMEM;
6430 }
6431 }
6432 if( rc==SQLITE_OK ){
drh715ff302008-12-03 22:32:44 +00006433 /* all memory is allocated, proxys are created and assigned,
6434 ** switch the locking context and pMethod then return.
6435 */
drh715ff302008-12-03 22:32:44 +00006436 pCtx->oldLockingContext = pFile->lockingContext;
6437 pFile->lockingContext = pCtx;
6438 pCtx->pOldMethod = pFile->pMethod;
6439 pFile->pMethod = &proxyIoMethods;
6440 }else{
6441 if( pCtx->conchFile ){
drh7ed97b92010-01-20 13:07:21 +00006442 pCtx->conchFile->pMethod->xClose((sqlite3_file *)pCtx->conchFile);
drh715ff302008-12-03 22:32:44 +00006443 sqlite3_free(pCtx->conchFile);
6444 }
drhd56b1212010-08-11 06:14:15 +00006445 sqlite3DbFree(0, pCtx->lockProxyPath);
drh715ff302008-12-03 22:32:44 +00006446 sqlite3_free(pCtx->conchFilePath);
6447 sqlite3_free(pCtx);
6448 }
drh308c2a52010-05-14 11:30:18 +00006449 OSTRACE(("TRANSPROXY %d %s\n", pFile->h,
6450 (rc==SQLITE_OK ? "ok" : "failed")));
drh715ff302008-12-03 22:32:44 +00006451 return rc;
6452}
6453
6454
6455/*
6456** This routine handles sqlite3_file_control() calls that are specific
6457** to proxy locking.
6458*/
6459static int proxyFileControl(sqlite3_file *id, int op, void *pArg){
6460 switch( op ){
6461 case SQLITE_GET_LOCKPROXYFILE: {
6462 unixFile *pFile = (unixFile*)id;
6463 if( pFile->pMethod == &proxyIoMethods ){
6464 proxyLockingContext *pCtx = (proxyLockingContext*)pFile->lockingContext;
6465 proxyTakeConch(pFile);
6466 if( pCtx->lockProxyPath ){
6467 *(const char **)pArg = pCtx->lockProxyPath;
6468 }else{
6469 *(const char **)pArg = ":auto: (not held)";
6470 }
6471 } else {
6472 *(const char **)pArg = NULL;
6473 }
6474 return SQLITE_OK;
6475 }
6476 case SQLITE_SET_LOCKPROXYFILE: {
6477 unixFile *pFile = (unixFile*)id;
6478 int rc = SQLITE_OK;
6479 int isProxyStyle = (pFile->pMethod == &proxyIoMethods);
6480 if( pArg==NULL || (const char *)pArg==0 ){
6481 if( isProxyStyle ){
6482 /* turn off proxy locking - not supported */
6483 rc = SQLITE_ERROR /*SQLITE_PROTOCOL? SQLITE_MISUSE?*/;
6484 }else{
6485 /* turn off proxy locking - already off - NOOP */
6486 rc = SQLITE_OK;
6487 }
6488 }else{
6489 const char *proxyPath = (const char *)pArg;
6490 if( isProxyStyle ){
6491 proxyLockingContext *pCtx =
6492 (proxyLockingContext*)pFile->lockingContext;
6493 if( !strcmp(pArg, ":auto:")
6494 || (pCtx->lockProxyPath &&
6495 !strncmp(pCtx->lockProxyPath, proxyPath, MAXPATHLEN))
6496 ){
6497 rc = SQLITE_OK;
6498 }else{
6499 rc = switchLockProxyPath(pFile, proxyPath);
6500 }
6501 }else{
6502 /* turn on proxy file locking */
6503 rc = proxyTransformUnixFile(pFile, proxyPath);
6504 }
6505 }
6506 return rc;
6507 }
6508 default: {
6509 assert( 0 ); /* The call assures that only valid opcodes are sent */
6510 }
6511 }
6512 /*NOTREACHED*/
6513 return SQLITE_ERROR;
6514}
6515
6516/*
6517** Within this division (the proxying locking implementation) the procedures
6518** above this point are all utilities. The lock-related methods of the
6519** proxy-locking sqlite3_io_method object follow.
6520*/
6521
6522
6523/*
6524** This routine checks if there is a RESERVED lock held on the specified
6525** file by this or any other process. If such a lock is held, set *pResOut
6526** to a non-zero value otherwise *pResOut is set to zero. The return value
6527** is set to SQLITE_OK unless an I/O error occurs during lock checking.
6528*/
6529static int proxyCheckReservedLock(sqlite3_file *id, int *pResOut) {
6530 unixFile *pFile = (unixFile*)id;
6531 int rc = proxyTakeConch(pFile);
6532 if( rc==SQLITE_OK ){
6533 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
drh7ed97b92010-01-20 13:07:21 +00006534 if( pCtx->conchHeld>0 ){
6535 unixFile *proxy = pCtx->lockProxy;
6536 return proxy->pMethod->xCheckReservedLock((sqlite3_file*)proxy, pResOut);
6537 }else{ /* conchHeld < 0 is lockless */
6538 pResOut=0;
6539 }
drh715ff302008-12-03 22:32:44 +00006540 }
6541 return rc;
6542}
6543
6544/*
drh308c2a52010-05-14 11:30:18 +00006545** Lock the file with the lock specified by parameter eFileLock - one
drh715ff302008-12-03 22:32:44 +00006546** of the following:
6547**
6548** (1) SHARED_LOCK
6549** (2) RESERVED_LOCK
6550** (3) PENDING_LOCK
6551** (4) EXCLUSIVE_LOCK
6552**
6553** Sometimes when requesting one lock state, additional lock states
6554** are inserted in between. The locking might fail on one of the later
6555** transitions leaving the lock state different from what it started but
6556** still short of its goal. The following chart shows the allowed
6557** transitions and the inserted intermediate states:
6558**
6559** UNLOCKED -> SHARED
6560** SHARED -> RESERVED
6561** SHARED -> (PENDING) -> EXCLUSIVE
6562** RESERVED -> (PENDING) -> EXCLUSIVE
6563** PENDING -> EXCLUSIVE
6564**
6565** This routine will only increase a lock. Use the sqlite3OsUnlock()
6566** routine to lower a locking level.
6567*/
drh308c2a52010-05-14 11:30:18 +00006568static int proxyLock(sqlite3_file *id, int eFileLock) {
drh715ff302008-12-03 22:32:44 +00006569 unixFile *pFile = (unixFile*)id;
6570 int rc = proxyTakeConch(pFile);
6571 if( rc==SQLITE_OK ){
6572 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
drh7ed97b92010-01-20 13:07:21 +00006573 if( pCtx->conchHeld>0 ){
6574 unixFile *proxy = pCtx->lockProxy;
drh308c2a52010-05-14 11:30:18 +00006575 rc = proxy->pMethod->xLock((sqlite3_file*)proxy, eFileLock);
6576 pFile->eFileLock = proxy->eFileLock;
drh7ed97b92010-01-20 13:07:21 +00006577 }else{
6578 /* conchHeld < 0 is lockless */
6579 }
drh715ff302008-12-03 22:32:44 +00006580 }
6581 return rc;
6582}
6583
6584
6585/*
drh308c2a52010-05-14 11:30:18 +00006586** Lower the locking level on file descriptor pFile to eFileLock. eFileLock
drh715ff302008-12-03 22:32:44 +00006587** must be either NO_LOCK or SHARED_LOCK.
6588**
6589** If the locking level of the file descriptor is already at or below
6590** the requested locking level, this routine is a no-op.
6591*/
drh308c2a52010-05-14 11:30:18 +00006592static int proxyUnlock(sqlite3_file *id, int eFileLock) {
drh715ff302008-12-03 22:32:44 +00006593 unixFile *pFile = (unixFile*)id;
6594 int rc = proxyTakeConch(pFile);
6595 if( rc==SQLITE_OK ){
6596 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
drh7ed97b92010-01-20 13:07:21 +00006597 if( pCtx->conchHeld>0 ){
6598 unixFile *proxy = pCtx->lockProxy;
drh308c2a52010-05-14 11:30:18 +00006599 rc = proxy->pMethod->xUnlock((sqlite3_file*)proxy, eFileLock);
6600 pFile->eFileLock = proxy->eFileLock;
drh7ed97b92010-01-20 13:07:21 +00006601 }else{
6602 /* conchHeld < 0 is lockless */
6603 }
drh715ff302008-12-03 22:32:44 +00006604 }
6605 return rc;
6606}
6607
6608/*
6609** Close a file that uses proxy locks.
6610*/
6611static int proxyClose(sqlite3_file *id) {
6612 if( id ){
6613 unixFile *pFile = (unixFile*)id;
6614 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
6615 unixFile *lockProxy = pCtx->lockProxy;
6616 unixFile *conchFile = pCtx->conchFile;
6617 int rc = SQLITE_OK;
6618
6619 if( lockProxy ){
6620 rc = lockProxy->pMethod->xUnlock((sqlite3_file*)lockProxy, NO_LOCK);
6621 if( rc ) return rc;
6622 rc = lockProxy->pMethod->xClose((sqlite3_file*)lockProxy);
6623 if( rc ) return rc;
6624 sqlite3_free(lockProxy);
6625 pCtx->lockProxy = 0;
6626 }
6627 if( conchFile ){
6628 if( pCtx->conchHeld ){
6629 rc = proxyReleaseConch(pFile);
6630 if( rc ) return rc;
6631 }
6632 rc = conchFile->pMethod->xClose((sqlite3_file*)conchFile);
6633 if( rc ) return rc;
6634 sqlite3_free(conchFile);
6635 }
drhd56b1212010-08-11 06:14:15 +00006636 sqlite3DbFree(0, pCtx->lockProxyPath);
drh715ff302008-12-03 22:32:44 +00006637 sqlite3_free(pCtx->conchFilePath);
drhd56b1212010-08-11 06:14:15 +00006638 sqlite3DbFree(0, pCtx->dbPath);
drh715ff302008-12-03 22:32:44 +00006639 /* restore the original locking context and pMethod then close it */
6640 pFile->lockingContext = pCtx->oldLockingContext;
6641 pFile->pMethod = pCtx->pOldMethod;
6642 sqlite3_free(pCtx);
6643 return pFile->pMethod->xClose(id);
6644 }
6645 return SQLITE_OK;
6646}
6647
6648
6649
drhd2cb50b2009-01-09 21:41:17 +00006650#endif /* defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE */
drh715ff302008-12-03 22:32:44 +00006651/*
6652** The proxy locking style is intended for use with AFP filesystems.
6653** And since AFP is only supported on MacOSX, the proxy locking is also
6654** restricted to MacOSX.
6655**
6656**
6657******************* End of the proxy lock implementation **********************
6658******************************************************************************/
6659
drh734c9862008-11-28 15:37:20 +00006660/*
danielk1977e339d652008-06-28 11:23:00 +00006661** Initialize the operating system interface.
drh734c9862008-11-28 15:37:20 +00006662**
6663** This routine registers all VFS implementations for unix-like operating
6664** systems. This routine, and the sqlite3_os_end() routine that follows,
6665** should be the only routines in this file that are visible from other
6666** files.
drh6b9d6dd2008-12-03 19:34:47 +00006667**
6668** This routine is called once during SQLite initialization and by a
6669** single thread. The memory allocation and mutex subsystems have not
6670** necessarily been initialized when this routine is called, and so they
6671** should not be used.
drh153c62c2007-08-24 03:51:33 +00006672*/
danielk1977c0fa4c52008-06-25 17:19:00 +00006673int sqlite3_os_init(void){
drh6b9d6dd2008-12-03 19:34:47 +00006674 /*
6675 ** The following macro defines an initializer for an sqlite3_vfs object.
drh1875f7a2008-12-08 18:19:17 +00006676 ** The name of the VFS is NAME. The pAppData is a pointer to a pointer
6677 ** to the "finder" function. (pAppData is a pointer to a pointer because
6678 ** silly C90 rules prohibit a void* from being cast to a function pointer
6679 ** and so we have to go through the intermediate pointer to avoid problems
6680 ** when compiling with -pedantic-errors on GCC.)
6681 **
6682 ** The FINDER parameter to this macro is the name of the pointer to the
drh6b9d6dd2008-12-03 19:34:47 +00006683 ** finder-function. The finder-function returns a pointer to the
6684 ** sqlite_io_methods object that implements the desired locking
6685 ** behaviors. See the division above that contains the IOMETHODS
6686 ** macro for addition information on finder-functions.
6687 **
6688 ** Most finders simply return a pointer to a fixed sqlite3_io_methods
6689 ** object. But the "autolockIoFinder" available on MacOSX does a little
6690 ** more than that; it looks at the filesystem type that hosts the
6691 ** database file and tries to choose an locking method appropriate for
6692 ** that filesystem time.
danielk1977e339d652008-06-28 11:23:00 +00006693 */
drh7708e972008-11-29 00:56:52 +00006694 #define UNIXVFS(VFSNAME, FINDER) { \
drh99ab3b12011-03-02 15:09:07 +00006695 3, /* iVersion */ \
danielk1977e339d652008-06-28 11:23:00 +00006696 sizeof(unixFile), /* szOsFile */ \
6697 MAX_PATHNAME, /* mxPathname */ \
6698 0, /* pNext */ \
drh7708e972008-11-29 00:56:52 +00006699 VFSNAME, /* zName */ \
drh1875f7a2008-12-08 18:19:17 +00006700 (void*)&FINDER, /* pAppData */ \
danielk1977e339d652008-06-28 11:23:00 +00006701 unixOpen, /* xOpen */ \
6702 unixDelete, /* xDelete */ \
6703 unixAccess, /* xAccess */ \
6704 unixFullPathname, /* xFullPathname */ \
6705 unixDlOpen, /* xDlOpen */ \
6706 unixDlError, /* xDlError */ \
6707 unixDlSym, /* xDlSym */ \
6708 unixDlClose, /* xDlClose */ \
6709 unixRandomness, /* xRandomness */ \
6710 unixSleep, /* xSleep */ \
6711 unixCurrentTime, /* xCurrentTime */ \
drhf2424c52010-04-26 00:04:55 +00006712 unixGetLastError, /* xGetLastError */ \
drhb7e8ea22010-05-03 14:32:30 +00006713 unixCurrentTimeInt64, /* xCurrentTimeInt64 */ \
drh99ab3b12011-03-02 15:09:07 +00006714 unixSetSystemCall, /* xSetSystemCall */ \
drh1df30962011-03-02 19:06:42 +00006715 unixGetSystemCall, /* xGetSystemCall */ \
6716 unixNextSystemCall, /* xNextSystemCall */ \
danielk1977e339d652008-06-28 11:23:00 +00006717 }
6718
drh6b9d6dd2008-12-03 19:34:47 +00006719 /*
6720 ** All default VFSes for unix are contained in the following array.
6721 **
6722 ** Note that the sqlite3_vfs.pNext field of the VFS object is modified
6723 ** by the SQLite core when the VFS is registered. So the following
6724 ** array cannot be const.
6725 */
danielk1977e339d652008-06-28 11:23:00 +00006726 static sqlite3_vfs aVfs[] = {
chw78a13182009-04-07 05:35:03 +00006727#if SQLITE_ENABLE_LOCKING_STYLE && (OS_VXWORKS || defined(__APPLE__))
drh7708e972008-11-29 00:56:52 +00006728 UNIXVFS("unix", autolockIoFinder ),
6729#else
6730 UNIXVFS("unix", posixIoFinder ),
6731#endif
6732 UNIXVFS("unix-none", nolockIoFinder ),
6733 UNIXVFS("unix-dotfile", dotlockIoFinder ),
drha7e61d82011-03-12 17:02:57 +00006734 UNIXVFS("unix-excl", posixIoFinder ),
drh734c9862008-11-28 15:37:20 +00006735#if OS_VXWORKS
drh7708e972008-11-29 00:56:52 +00006736 UNIXVFS("unix-namedsem", semIoFinder ),
drh734c9862008-11-28 15:37:20 +00006737#endif
6738#if SQLITE_ENABLE_LOCKING_STYLE
drh7708e972008-11-29 00:56:52 +00006739 UNIXVFS("unix-posix", posixIoFinder ),
chw78a13182009-04-07 05:35:03 +00006740#if !OS_VXWORKS
drh7708e972008-11-29 00:56:52 +00006741 UNIXVFS("unix-flock", flockIoFinder ),
drh734c9862008-11-28 15:37:20 +00006742#endif
chw78a13182009-04-07 05:35:03 +00006743#endif
drhd2cb50b2009-01-09 21:41:17 +00006744#if SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__)
drh7708e972008-11-29 00:56:52 +00006745 UNIXVFS("unix-afp", afpIoFinder ),
drh7ed97b92010-01-20 13:07:21 +00006746 UNIXVFS("unix-nfs", nfsIoFinder ),
drh7708e972008-11-29 00:56:52 +00006747 UNIXVFS("unix-proxy", proxyIoFinder ),
drh734c9862008-11-28 15:37:20 +00006748#endif
drh153c62c2007-08-24 03:51:33 +00006749 };
drh6b9d6dd2008-12-03 19:34:47 +00006750 unsigned int i; /* Loop counter */
6751
drh2aa5a002011-04-13 13:42:25 +00006752 /* Double-check that the aSyscall[] array has been constructed
6753 ** correctly. See ticket [bb3a86e890c8e96ab] */
drh90315a22011-08-10 01:52:12 +00006754 assert( ArraySize(aSyscall)==18 );
drh2aa5a002011-04-13 13:42:25 +00006755
drh6b9d6dd2008-12-03 19:34:47 +00006756 /* Register all VFSes defined in the aVfs[] array */
danielk1977e339d652008-06-28 11:23:00 +00006757 for(i=0; i<(sizeof(aVfs)/sizeof(sqlite3_vfs)); i++){
drh734c9862008-11-28 15:37:20 +00006758 sqlite3_vfs_register(&aVfs[i], i==0);
danielk1977e339d652008-06-28 11:23:00 +00006759 }
danielk1977c0fa4c52008-06-25 17:19:00 +00006760 return SQLITE_OK;
drh153c62c2007-08-24 03:51:33 +00006761}
danielk1977e339d652008-06-28 11:23:00 +00006762
6763/*
drh6b9d6dd2008-12-03 19:34:47 +00006764** Shutdown the operating system interface.
6765**
6766** Some operating systems might need to do some cleanup in this routine,
6767** to release dynamically allocated objects. But not on unix.
6768** This routine is a no-op for unix.
danielk1977e339d652008-06-28 11:23:00 +00006769*/
danielk1977c0fa4c52008-06-25 17:19:00 +00006770int sqlite3_os_end(void){
6771 return SQLITE_OK;
6772}
drhdce8bdb2007-08-16 13:01:44 +00006773
danielk197729bafea2008-06-26 10:41:19 +00006774#endif /* SQLITE_OS_UNIX */