Annotation of embedaddon/sqlite3/src/os_unix.c, revision 1.1.1.1
1.1 misho 1: /*
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: **
13: ** This file contains the VFS implementation for unix-like operating systems
14: ** include Linux, MacOSX, *BSD, QNX, VxWorks, AIX, HPUX, and others.
15: **
16: ** 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: **
22: ** This source file is organized into divisions where the logic for various
23: ** 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: **
27: ** The layout of divisions is as follows:
28: **
29: ** * General-purpose declarations and utility functions.
30: ** * Unique file ID logic used by VxWorks.
31: ** * Various locking primitive implementations (all except proxy locking):
32: ** + 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)
38: ** * 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.
41: ** * sqlite3_vfs method implementations.
42: ** * Locking primitives for the proxy uber-locking-method. (MacOSX only)
43: ** * Definitions of sqlite3_vfs objects for all locking methods
44: ** plus implementations of sqlite3_os_init() and sqlite3_os_end().
45: */
46: #include "sqliteInt.h"
47: #if SQLITE_OS_UNIX /* This file is used on unix only */
48:
49: /*
50: ** There are various methods for file locking used for concurrency
51: ** control:
52: **
53: ** 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.
65: */
66: #if !defined(SQLITE_ENABLE_LOCKING_STYLE)
67: # if defined(__APPLE__)
68: # define SQLITE_ENABLE_LOCKING_STYLE 1
69: # else
70: # define SQLITE_ENABLE_LOCKING_STYLE 0
71: # endif
72: #endif
73:
74: /*
75: ** Define the OS_VXWORKS pre-processor macro to 1 if building on
76: ** vxworks, or 0 otherwise.
77: */
78: #ifndef OS_VXWORKS
79: # if defined(__RTP__) || defined(_WRS_KERNEL)
80: # define OS_VXWORKS 1
81: # else
82: # define OS_VXWORKS 0
83: # endif
84: #endif
85:
86: /*
87: ** These #defines should enable >2GB file support on Posix if the
88: ** underlying operating system supports it. If the OS lacks
89: ** large file support, these should be no-ops.
90: **
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.
98: **
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.
103: */
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
111:
112: /*
113: ** standard include files.
114: */
115: #include <sys/types.h>
116: #include <sys/stat.h>
117: #include <fcntl.h>
118: #include <unistd.h>
119: #include <time.h>
120: #include <sys/time.h>
121: #include <errno.h>
122: #ifndef SQLITE_OMIT_WAL
123: #include <sys/mman.h>
124: #endif
125:
126:
127: #if SQLITE_ENABLE_LOCKING_STYLE
128: # include <sys/ioctl.h>
129: # if OS_VXWORKS
130: # include <semaphore.h>
131: # include <limits.h>
132: # else
133: # include <sys/file.h>
134: # include <sys/param.h>
135: # endif
136: #endif /* SQLITE_ENABLE_LOCKING_STYLE */
137:
138: #if defined(__APPLE__) || (SQLITE_ENABLE_LOCKING_STYLE && !OS_VXWORKS)
139: # include <sys/mount.h>
140: #endif
141:
142: #ifdef HAVE_UTIME
143: # include <utime.h>
144: #endif
145:
146: /*
147: ** Allowed values of unixFile.fsFlags
148: */
149: #define SQLITE_FSFLAGS_IS_MSDOS 0x1
150:
151: /*
152: ** If we are to be thread-safe, include the pthreads header and define
153: ** the SQLITE_UNIX_THREADS macro.
154: */
155: #if SQLITE_THREADSAFE
156: # include <pthread.h>
157: # define SQLITE_UNIX_THREADS 1
158: #endif
159:
160: /*
161: ** Default permissions when creating a new file
162: */
163: #ifndef SQLITE_DEFAULT_FILE_PERMISSIONS
164: # define SQLITE_DEFAULT_FILE_PERMISSIONS 0644
165: #endif
166:
167: /*
168: ** Default permissions when creating auto proxy dir
169: */
170: #ifndef SQLITE_DEFAULT_PROXYDIR_PERMISSIONS
171: # define SQLITE_DEFAULT_PROXYDIR_PERMISSIONS 0755
172: #endif
173:
174: /*
175: ** Maximum supported path-length.
176: */
177: #define MAX_PATHNAME 512
178:
179: /*
180: ** Only set the lastErrno if the error code is a real error and not
181: ** a normal expected return code of SQLITE_BUSY or SQLITE_OK
182: */
183: #define IS_LOCK_ERROR(x) ((x != SQLITE_OK) && (x != SQLITE_BUSY))
184:
185: /* Forward references */
186: typedef struct unixShm unixShm; /* Connection shared memory */
187: typedef struct unixShmNode unixShmNode; /* Shared memory instance */
188: typedef struct unixInodeInfo unixInodeInfo; /* An i-node */
189: typedef struct UnixUnusedFd UnixUnusedFd; /* An unused file descriptor */
190:
191: /*
192: ** Sometimes, after a file handle is closed by SQLite, the file descriptor
193: ** cannot be closed immediately. In these cases, instances of the following
194: ** structure are used to store the file descriptor while waiting for an
195: ** opportunity to either close or reuse it.
196: */
197: struct UnixUnusedFd {
198: int fd; /* File descriptor to close */
199: int flags; /* Flags this file descriptor was opened with */
200: UnixUnusedFd *pNext; /* Next unused file descriptor on same file */
201: };
202:
203: /*
204: ** The unixFile structure is subclass of sqlite3_file specific to the unix
205: ** VFS implementations.
206: */
207: typedef struct unixFile unixFile;
208: struct unixFile {
209: sqlite3_io_methods const *pMethod; /* Always the first entry */
210: sqlite3_vfs *pVfs; /* The VFS that created this unixFile */
211: unixInodeInfo *pInode; /* Info about locks on this inode */
212: int h; /* The file descriptor */
213: unsigned char eFileLock; /* The type of lock held on this fd */
214: unsigned char ctrlFlags; /* Behavioral bits. UNIXFILE_* flags */
215: int lastErrno; /* The unix errno from last I/O error */
216: void *lockingContext; /* Locking style specific state */
217: UnixUnusedFd *pUnused; /* Pre-allocated UnixUnusedFd */
218: const char *zPath; /* Name of the file */
219: unixShm *pShm; /* Shared memory segment information */
220: int szChunk; /* Configured by FCNTL_CHUNK_SIZE */
221: #if SQLITE_ENABLE_LOCKING_STYLE
222: int openFlags; /* The flags specified at open() */
223: #endif
224: #if SQLITE_ENABLE_LOCKING_STYLE || defined(__APPLE__)
225: unsigned fsFlags; /* cached details from statfs() */
226: #endif
227: #if OS_VXWORKS
228: struct vxworksFileId *pId; /* Unique file ID */
229: #endif
230: #ifndef NDEBUG
231: /* The next group of variables are used to track whether or not the
232: ** transaction counter in bytes 24-27 of database files are updated
233: ** whenever any part of the database changes. An assertion fault will
234: ** occur if a file is updated without also updating the transaction
235: ** counter. This test is made to avoid new problems similar to the
236: ** one described by ticket #3584.
237: */
238: unsigned char transCntrChng; /* True if the transaction counter changed */
239: unsigned char dbUpdate; /* True if any part of database file changed */
240: unsigned char inNormalWrite; /* True if in a normal write operation */
241: #endif
242: #ifdef SQLITE_TEST
243: /* In test mode, increase the size of this structure a bit so that
244: ** it is larger than the struct CrashFile defined in test6.c.
245: */
246: char aPadding[32];
247: #endif
248: };
249:
250: /*
251: ** Allowed values for the unixFile.ctrlFlags bitmask:
252: */
253: #define UNIXFILE_EXCL 0x01 /* Connections from one process only */
254: #define UNIXFILE_RDONLY 0x02 /* Connection is read only */
255: #define UNIXFILE_PERSIST_WAL 0x04 /* Persistent WAL mode */
256: #ifndef SQLITE_DISABLE_DIRSYNC
257: # define UNIXFILE_DIRSYNC 0x08 /* Directory sync needed */
258: #else
259: # define UNIXFILE_DIRSYNC 0x00
260: #endif
261: #define UNIXFILE_PSOW 0x10 /* SQLITE_IOCAP_POWERSAFE_OVERWRITE */
262: #define UNIXFILE_DELETE 0x20 /* Delete on close */
263: #define UNIXFILE_URI 0x40 /* Filename might have query parameters */
264: #define UNIXFILE_NOLOCK 0x80 /* Do no file locking */
265:
266: /*
267: ** Include code that is common to all os_*.c files
268: */
269: #include "os_common.h"
270:
271: /*
272: ** Define various macros that are missing from some systems.
273: */
274: #ifndef O_LARGEFILE
275: # define O_LARGEFILE 0
276: #endif
277: #ifdef SQLITE_DISABLE_LFS
278: # undef O_LARGEFILE
279: # define O_LARGEFILE 0
280: #endif
281: #ifndef O_NOFOLLOW
282: # define O_NOFOLLOW 0
283: #endif
284: #ifndef O_BINARY
285: # define O_BINARY 0
286: #endif
287:
288: /*
289: ** The threadid macro resolves to the thread-id or to 0. Used for
290: ** testing and debugging only.
291: */
292: #if SQLITE_THREADSAFE
293: #define threadid pthread_self()
294: #else
295: #define threadid 0
296: #endif
297:
298: /*
299: ** Different Unix systems declare open() in different ways. Same use
300: ** open(const char*,int,mode_t). Others use open(const char*,int,...).
301: ** The difference is important when using a pointer to the function.
302: **
303: ** The safest way to deal with the problem is to always use this wrapper
304: ** which always has the same well-defined interface.
305: */
306: static int posixOpen(const char *zFile, int flags, int mode){
307: return open(zFile, flags, mode);
308: }
309:
310: /* Forward reference */
311: static int openDirectory(const char*, int*);
312:
313: /*
314: ** Many system calls are accessed through pointer-to-functions so that
315: ** they may be overridden at runtime to facilitate fault injection during
316: ** testing and sandboxing. The following array holds the names and pointers
317: ** to all overrideable system calls.
318: */
319: static struct unix_syscall {
320: const char *zName; /* Name of the sytem call */
321: sqlite3_syscall_ptr pCurrent; /* Current value of the system call */
322: sqlite3_syscall_ptr pDefault; /* Default value */
323: } aSyscall[] = {
324: { "open", (sqlite3_syscall_ptr)posixOpen, 0 },
325: #define osOpen ((int(*)(const char*,int,int))aSyscall[0].pCurrent)
326:
327: { "close", (sqlite3_syscall_ptr)close, 0 },
328: #define osClose ((int(*)(int))aSyscall[1].pCurrent)
329:
330: { "access", (sqlite3_syscall_ptr)access, 0 },
331: #define osAccess ((int(*)(const char*,int))aSyscall[2].pCurrent)
332:
333: { "getcwd", (sqlite3_syscall_ptr)getcwd, 0 },
334: #define osGetcwd ((char*(*)(char*,size_t))aSyscall[3].pCurrent)
335:
336: { "stat", (sqlite3_syscall_ptr)stat, 0 },
337: #define osStat ((int(*)(const char*,struct stat*))aSyscall[4].pCurrent)
338:
339: /*
340: ** The DJGPP compiler environment looks mostly like Unix, but it
341: ** lacks the fcntl() system call. So redefine fcntl() to be something
342: ** that always succeeds. This means that locking does not occur under
343: ** DJGPP. But it is DOS - what did you expect?
344: */
345: #ifdef __DJGPP__
346: { "fstat", 0, 0 },
347: #define osFstat(a,b,c) 0
348: #else
349: { "fstat", (sqlite3_syscall_ptr)fstat, 0 },
350: #define osFstat ((int(*)(int,struct stat*))aSyscall[5].pCurrent)
351: #endif
352:
353: { "ftruncate", (sqlite3_syscall_ptr)ftruncate, 0 },
354: #define osFtruncate ((int(*)(int,off_t))aSyscall[6].pCurrent)
355:
356: { "fcntl", (sqlite3_syscall_ptr)fcntl, 0 },
357: #define osFcntl ((int(*)(int,int,...))aSyscall[7].pCurrent)
358:
359: { "read", (sqlite3_syscall_ptr)read, 0 },
360: #define osRead ((ssize_t(*)(int,void*,size_t))aSyscall[8].pCurrent)
361:
362: #if defined(USE_PREAD) || SQLITE_ENABLE_LOCKING_STYLE
363: { "pread", (sqlite3_syscall_ptr)pread, 0 },
364: #else
365: { "pread", (sqlite3_syscall_ptr)0, 0 },
366: #endif
367: #define osPread ((ssize_t(*)(int,void*,size_t,off_t))aSyscall[9].pCurrent)
368:
369: #if defined(USE_PREAD64)
370: { "pread64", (sqlite3_syscall_ptr)pread64, 0 },
371: #else
372: { "pread64", (sqlite3_syscall_ptr)0, 0 },
373: #endif
374: #define osPread64 ((ssize_t(*)(int,void*,size_t,off_t))aSyscall[10].pCurrent)
375:
376: { "write", (sqlite3_syscall_ptr)write, 0 },
377: #define osWrite ((ssize_t(*)(int,const void*,size_t))aSyscall[11].pCurrent)
378:
379: #if defined(USE_PREAD) || SQLITE_ENABLE_LOCKING_STYLE
380: { "pwrite", (sqlite3_syscall_ptr)pwrite, 0 },
381: #else
382: { "pwrite", (sqlite3_syscall_ptr)0, 0 },
383: #endif
384: #define osPwrite ((ssize_t(*)(int,const void*,size_t,off_t))\
385: aSyscall[12].pCurrent)
386:
387: #if defined(USE_PREAD64)
388: { "pwrite64", (sqlite3_syscall_ptr)pwrite64, 0 },
389: #else
390: { "pwrite64", (sqlite3_syscall_ptr)0, 0 },
391: #endif
392: #define osPwrite64 ((ssize_t(*)(int,const void*,size_t,off_t))\
393: aSyscall[13].pCurrent)
394:
395: #if SQLITE_ENABLE_LOCKING_STYLE
396: { "fchmod", (sqlite3_syscall_ptr)fchmod, 0 },
397: #else
398: { "fchmod", (sqlite3_syscall_ptr)0, 0 },
399: #endif
400: #define osFchmod ((int(*)(int,mode_t))aSyscall[14].pCurrent)
401:
402: #if defined(HAVE_POSIX_FALLOCATE) && HAVE_POSIX_FALLOCATE
403: { "fallocate", (sqlite3_syscall_ptr)posix_fallocate, 0 },
404: #else
405: { "fallocate", (sqlite3_syscall_ptr)0, 0 },
406: #endif
407: #define osFallocate ((int(*)(int,off_t,off_t))aSyscall[15].pCurrent)
408:
409: { "unlink", (sqlite3_syscall_ptr)unlink, 0 },
410: #define osUnlink ((int(*)(const char*))aSyscall[16].pCurrent)
411:
412: { "openDirectory", (sqlite3_syscall_ptr)openDirectory, 0 },
413: #define osOpenDirectory ((int(*)(const char*,int*))aSyscall[17].pCurrent)
414:
415: { "mkdir", (sqlite3_syscall_ptr)mkdir, 0 },
416: #define osMkdir ((int(*)(const char*,mode_t))aSyscall[18].pCurrent)
417:
418: { "rmdir", (sqlite3_syscall_ptr)rmdir, 0 },
419: #define osRmdir ((int(*)(const char*))aSyscall[19].pCurrent)
420:
421: }; /* End of the overrideable system calls */
422:
423: /*
424: ** This is the xSetSystemCall() method of sqlite3_vfs for all of the
425: ** "unix" VFSes. Return SQLITE_OK opon successfully updating the
426: ** system call pointer, or SQLITE_NOTFOUND if there is no configurable
427: ** system call named zName.
428: */
429: static int unixSetSystemCall(
430: sqlite3_vfs *pNotUsed, /* The VFS pointer. Not used */
431: const char *zName, /* Name of system call to override */
432: sqlite3_syscall_ptr pNewFunc /* Pointer to new system call value */
433: ){
434: unsigned int i;
435: int rc = SQLITE_NOTFOUND;
436:
437: UNUSED_PARAMETER(pNotUsed);
438: if( zName==0 ){
439: /* If no zName is given, restore all system calls to their default
440: ** settings and return NULL
441: */
442: rc = SQLITE_OK;
443: for(i=0; i<sizeof(aSyscall)/sizeof(aSyscall[0]); i++){
444: if( aSyscall[i].pDefault ){
445: aSyscall[i].pCurrent = aSyscall[i].pDefault;
446: }
447: }
448: }else{
449: /* If zName is specified, operate on only the one system call
450: ** specified.
451: */
452: for(i=0; i<sizeof(aSyscall)/sizeof(aSyscall[0]); i++){
453: if( strcmp(zName, aSyscall[i].zName)==0 ){
454: if( aSyscall[i].pDefault==0 ){
455: aSyscall[i].pDefault = aSyscall[i].pCurrent;
456: }
457: rc = SQLITE_OK;
458: if( pNewFunc==0 ) pNewFunc = aSyscall[i].pDefault;
459: aSyscall[i].pCurrent = pNewFunc;
460: break;
461: }
462: }
463: }
464: return rc;
465: }
466:
467: /*
468: ** Return the value of a system call. Return NULL if zName is not a
469: ** recognized system call name. NULL is also returned if the system call
470: ** is currently undefined.
471: */
472: static sqlite3_syscall_ptr unixGetSystemCall(
473: sqlite3_vfs *pNotUsed,
474: const char *zName
475: ){
476: unsigned int i;
477:
478: UNUSED_PARAMETER(pNotUsed);
479: for(i=0; i<sizeof(aSyscall)/sizeof(aSyscall[0]); i++){
480: if( strcmp(zName, aSyscall[i].zName)==0 ) return aSyscall[i].pCurrent;
481: }
482: return 0;
483: }
484:
485: /*
486: ** Return the name of the first system call after zName. If zName==NULL
487: ** then return the name of the first system call. Return NULL if zName
488: ** is the last system call or if zName is not the name of a valid
489: ** system call.
490: */
491: static const char *unixNextSystemCall(sqlite3_vfs *p, const char *zName){
492: int i = -1;
493:
494: UNUSED_PARAMETER(p);
495: if( zName ){
496: for(i=0; i<ArraySize(aSyscall)-1; i++){
497: if( strcmp(zName, aSyscall[i].zName)==0 ) break;
498: }
499: }
500: for(i++; i<ArraySize(aSyscall); i++){
501: if( aSyscall[i].pCurrent!=0 ) return aSyscall[i].zName;
502: }
503: return 0;
504: }
505:
506: /*
507: ** Retry open() calls that fail due to EINTR
508: */
509: static int robust_open(const char *z, int f, int m){
510: int rc;
511: do{ rc = osOpen(z,f,m); }while( rc<0 && errno==EINTR );
512: return rc;
513: }
514:
515: /*
516: ** Helper functions to obtain and relinquish the global mutex. The
517: ** global mutex is used to protect the unixInodeInfo and
518: ** vxworksFileId objects used by this file, all of which may be
519: ** shared by multiple threads.
520: **
521: ** Function unixMutexHeld() is used to assert() that the global mutex
522: ** is held when required. This function is only used as part of assert()
523: ** statements. e.g.
524: **
525: ** unixEnterMutex()
526: ** assert( unixMutexHeld() );
527: ** unixEnterLeave()
528: */
529: static void unixEnterMutex(void){
530: sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));
531: }
532: static void unixLeaveMutex(void){
533: sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));
534: }
535: #ifdef SQLITE_DEBUG
536: static int unixMutexHeld(void) {
537: return sqlite3_mutex_held(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));
538: }
539: #endif
540:
541:
542: #if defined(SQLITE_TEST) && defined(SQLITE_DEBUG)
543: /*
544: ** Helper function for printing out trace information from debugging
545: ** binaries. This returns the string represetation of the supplied
546: ** integer lock-type.
547: */
548: static const char *azFileLock(int eFileLock){
549: switch( eFileLock ){
550: case NO_LOCK: return "NONE";
551: case SHARED_LOCK: return "SHARED";
552: case RESERVED_LOCK: return "RESERVED";
553: case PENDING_LOCK: return "PENDING";
554: case EXCLUSIVE_LOCK: return "EXCLUSIVE";
555: }
556: return "ERROR";
557: }
558: #endif
559:
560: #ifdef SQLITE_LOCK_TRACE
561: /*
562: ** Print out information about all locking operations.
563: **
564: ** This routine is used for troubleshooting locks on multithreaded
565: ** platforms. Enable by compiling with the -DSQLITE_LOCK_TRACE
566: ** command-line option on the compiler. This code is normally
567: ** turned off.
568: */
569: static int lockTrace(int fd, int op, struct flock *p){
570: char *zOpName, *zType;
571: int s;
572: int savedErrno;
573: if( op==F_GETLK ){
574: zOpName = "GETLK";
575: }else if( op==F_SETLK ){
576: zOpName = "SETLK";
577: }else{
578: s = osFcntl(fd, op, p);
579: sqlite3DebugPrintf("fcntl unknown %d %d %d\n", fd, op, s);
580: return s;
581: }
582: if( p->l_type==F_RDLCK ){
583: zType = "RDLCK";
584: }else if( p->l_type==F_WRLCK ){
585: zType = "WRLCK";
586: }else if( p->l_type==F_UNLCK ){
587: zType = "UNLCK";
588: }else{
589: assert( 0 );
590: }
591: assert( p->l_whence==SEEK_SET );
592: s = osFcntl(fd, op, p);
593: savedErrno = errno;
594: sqlite3DebugPrintf("fcntl %d %d %s %s %d %d %d %d\n",
595: threadid, fd, zOpName, zType, (int)p->l_start, (int)p->l_len,
596: (int)p->l_pid, s);
597: if( s==(-1) && op==F_SETLK && (p->l_type==F_RDLCK || p->l_type==F_WRLCK) ){
598: struct flock l2;
599: l2 = *p;
600: osFcntl(fd, F_GETLK, &l2);
601: if( l2.l_type==F_RDLCK ){
602: zType = "RDLCK";
603: }else if( l2.l_type==F_WRLCK ){
604: zType = "WRLCK";
605: }else if( l2.l_type==F_UNLCK ){
606: zType = "UNLCK";
607: }else{
608: assert( 0 );
609: }
610: sqlite3DebugPrintf("fcntl-failure-reason: %s %d %d %d\n",
611: zType, (int)l2.l_start, (int)l2.l_len, (int)l2.l_pid);
612: }
613: errno = savedErrno;
614: return s;
615: }
616: #undef osFcntl
617: #define osFcntl lockTrace
618: #endif /* SQLITE_LOCK_TRACE */
619:
620: /*
621: ** Retry ftruncate() calls that fail due to EINTR
622: */
623: static int robust_ftruncate(int h, sqlite3_int64 sz){
624: int rc;
625: do{ rc = osFtruncate(h,sz); }while( rc<0 && errno==EINTR );
626: return rc;
627: }
628:
629: /*
630: ** This routine translates a standard POSIX errno code into something
631: ** useful to the clients of the sqlite3 functions. Specifically, it is
632: ** intended to translate a variety of "try again" errors into SQLITE_BUSY
633: ** and a variety of "please close the file descriptor NOW" errors into
634: ** SQLITE_IOERR
635: **
636: ** Errors during initialization of locks, or file system support for locks,
637: ** should handle ENOLCK, ENOTSUP, EOPNOTSUPP separately.
638: */
639: static int sqliteErrorFromPosixError(int posixError, int sqliteIOErr) {
640: switch (posixError) {
641: #if 0
642: /* At one point this code was not commented out. In theory, this branch
643: ** should never be hit, as this function should only be called after
644: ** a locking-related function (i.e. fcntl()) has returned non-zero with
645: ** the value of errno as the first argument. Since a system call has failed,
646: ** errno should be non-zero.
647: **
648: ** Despite this, if errno really is zero, we still don't want to return
649: ** SQLITE_OK. The system call failed, and *some* SQLite error should be
650: ** propagated back to the caller. Commenting this branch out means errno==0
651: ** will be handled by the "default:" case below.
652: */
653: case 0:
654: return SQLITE_OK;
655: #endif
656:
657: case EAGAIN:
658: case ETIMEDOUT:
659: case EBUSY:
660: case EINTR:
661: case ENOLCK:
662: /* random NFS retry error, unless during file system support
663: * introspection, in which it actually means what it says */
664: return SQLITE_BUSY;
665:
666: case EACCES:
667: /* EACCES is like EAGAIN during locking operations, but not any other time*/
668: if( (sqliteIOErr == SQLITE_IOERR_LOCK) ||
669: (sqliteIOErr == SQLITE_IOERR_UNLOCK) ||
670: (sqliteIOErr == SQLITE_IOERR_RDLOCK) ||
671: (sqliteIOErr == SQLITE_IOERR_CHECKRESERVEDLOCK) ){
672: return SQLITE_BUSY;
673: }
674: /* else fall through */
675: case EPERM:
676: return SQLITE_PERM;
677:
678: /* EDEADLK is only possible if a call to fcntl(F_SETLKW) is made. And
679: ** this module never makes such a call. And the code in SQLite itself
680: ** asserts that SQLITE_IOERR_BLOCKED is never returned. For these reasons
681: ** this case is also commented out. If the system does set errno to EDEADLK,
682: ** the default SQLITE_IOERR_XXX code will be returned. */
683: #if 0
684: case EDEADLK:
685: return SQLITE_IOERR_BLOCKED;
686: #endif
687:
688: #if EOPNOTSUPP!=ENOTSUP
689: case EOPNOTSUPP:
690: /* something went terribly awry, unless during file system support
691: * introspection, in which it actually means what it says */
692: #endif
693: #ifdef ENOTSUP
694: case ENOTSUP:
695: /* invalid fd, unless during file system support introspection, in which
696: * it actually means what it says */
697: #endif
698: case EIO:
699: case EBADF:
700: case EINVAL:
701: case ENOTCONN:
702: case ENODEV:
703: case ENXIO:
704: case ENOENT:
705: #ifdef ESTALE /* ESTALE is not defined on Interix systems */
706: case ESTALE:
707: #endif
708: case ENOSYS:
709: /* these should force the client to close the file and reconnect */
710:
711: default:
712: return sqliteIOErr;
713: }
714: }
715:
716:
717:
718: /******************************************************************************
719: ****************** Begin Unique File ID Utility Used By VxWorks ***************
720: **
721: ** On most versions of unix, we can get a unique ID for a file by concatenating
722: ** the device number and the inode number. But this does not work on VxWorks.
723: ** On VxWorks, a unique file id must be based on the canonical filename.
724: **
725: ** A pointer to an instance of the following structure can be used as a
726: ** unique file ID in VxWorks. Each instance of this structure contains
727: ** a copy of the canonical filename. There is also a reference count.
728: ** The structure is reclaimed when the number of pointers to it drops to
729: ** zero.
730: **
731: ** There are never very many files open at one time and lookups are not
732: ** a performance-critical path, so it is sufficient to put these
733: ** structures on a linked list.
734: */
735: struct vxworksFileId {
736: struct vxworksFileId *pNext; /* Next in a list of them all */
737: int nRef; /* Number of references to this one */
738: int nName; /* Length of the zCanonicalName[] string */
739: char *zCanonicalName; /* Canonical filename */
740: };
741:
742: #if OS_VXWORKS
743: /*
744: ** All unique filenames are held on a linked list headed by this
745: ** variable:
746: */
747: static struct vxworksFileId *vxworksFileList = 0;
748:
749: /*
750: ** Simplify a filename into its canonical form
751: ** by making the following changes:
752: **
753: ** * removing any trailing and duplicate /
754: ** * convert /./ into just /
755: ** * convert /A/../ where A is any simple name into just /
756: **
757: ** Changes are made in-place. Return the new name length.
758: **
759: ** The original filename is in z[0..n-1]. Return the number of
760: ** characters in the simplified name.
761: */
762: static int vxworksSimplifyName(char *z, int n){
763: int i, j;
764: while( n>1 && z[n-1]=='/' ){ n--; }
765: for(i=j=0; i<n; i++){
766: if( z[i]=='/' ){
767: if( z[i+1]=='/' ) continue;
768: if( z[i+1]=='.' && i+2<n && z[i+2]=='/' ){
769: i += 1;
770: continue;
771: }
772: if( z[i+1]=='.' && i+3<n && z[i+2]=='.' && z[i+3]=='/' ){
773: while( j>0 && z[j-1]!='/' ){ j--; }
774: if( j>0 ){ j--; }
775: i += 2;
776: continue;
777: }
778: }
779: z[j++] = z[i];
780: }
781: z[j] = 0;
782: return j;
783: }
784:
785: /*
786: ** Find a unique file ID for the given absolute pathname. Return
787: ** a pointer to the vxworksFileId object. This pointer is the unique
788: ** file ID.
789: **
790: ** The nRef field of the vxworksFileId object is incremented before
791: ** the object is returned. A new vxworksFileId object is created
792: ** and added to the global list if necessary.
793: **
794: ** If a memory allocation error occurs, return NULL.
795: */
796: static struct vxworksFileId *vxworksFindFileId(const char *zAbsoluteName){
797: struct vxworksFileId *pNew; /* search key and new file ID */
798: struct vxworksFileId *pCandidate; /* For looping over existing file IDs */
799: int n; /* Length of zAbsoluteName string */
800:
801: assert( zAbsoluteName[0]=='/' );
802: n = (int)strlen(zAbsoluteName);
803: pNew = sqlite3_malloc( sizeof(*pNew) + (n+1) );
804: if( pNew==0 ) return 0;
805: pNew->zCanonicalName = (char*)&pNew[1];
806: memcpy(pNew->zCanonicalName, zAbsoluteName, n+1);
807: n = vxworksSimplifyName(pNew->zCanonicalName, n);
808:
809: /* Search for an existing entry that matching the canonical name.
810: ** If found, increment the reference count and return a pointer to
811: ** the existing file ID.
812: */
813: unixEnterMutex();
814: for(pCandidate=vxworksFileList; pCandidate; pCandidate=pCandidate->pNext){
815: if( pCandidate->nName==n
816: && memcmp(pCandidate->zCanonicalName, pNew->zCanonicalName, n)==0
817: ){
818: sqlite3_free(pNew);
819: pCandidate->nRef++;
820: unixLeaveMutex();
821: return pCandidate;
822: }
823: }
824:
825: /* No match was found. We will make a new file ID */
826: pNew->nRef = 1;
827: pNew->nName = n;
828: pNew->pNext = vxworksFileList;
829: vxworksFileList = pNew;
830: unixLeaveMutex();
831: return pNew;
832: }
833:
834: /*
835: ** Decrement the reference count on a vxworksFileId object. Free
836: ** the object when the reference count reaches zero.
837: */
838: static void vxworksReleaseFileId(struct vxworksFileId *pId){
839: unixEnterMutex();
840: assert( pId->nRef>0 );
841: pId->nRef--;
842: if( pId->nRef==0 ){
843: struct vxworksFileId **pp;
844: for(pp=&vxworksFileList; *pp && *pp!=pId; pp = &((*pp)->pNext)){}
845: assert( *pp==pId );
846: *pp = pId->pNext;
847: sqlite3_free(pId);
848: }
849: unixLeaveMutex();
850: }
851: #endif /* OS_VXWORKS */
852: /*************** End of Unique File ID Utility Used By VxWorks ****************
853: ******************************************************************************/
854:
855:
856: /******************************************************************************
857: *************************** Posix Advisory Locking ****************************
858: **
859: ** POSIX advisory locks are broken by design. ANSI STD 1003.1 (1996)
860: ** section 6.5.2.2 lines 483 through 490 specify that when a process
861: ** sets or clears a lock, that operation overrides any prior locks set
862: ** by the same process. It does not explicitly say so, but this implies
863: ** that it overrides locks set by the same process using a different
864: ** file descriptor. Consider this test case:
865: **
866: ** int fd1 = open("./file1", O_RDWR|O_CREAT, 0644);
867: ** int fd2 = open("./file2", O_RDWR|O_CREAT, 0644);
868: **
869: ** Suppose ./file1 and ./file2 are really the same file (because
870: ** one is a hard or symbolic link to the other) then if you set
871: ** an exclusive lock on fd1, then try to get an exclusive lock
872: ** on fd2, it works. I would have expected the second lock to
873: ** fail since there was already a lock on the file due to fd1.
874: ** But not so. Since both locks came from the same process, the
875: ** second overrides the first, even though they were on different
876: ** file descriptors opened on different file names.
877: **
878: ** This means that we cannot use POSIX locks to synchronize file access
879: ** among competing threads of the same process. POSIX locks will work fine
880: ** to synchronize access for threads in separate processes, but not
881: ** threads within the same process.
882: **
883: ** To work around the problem, SQLite has to manage file locks internally
884: ** on its own. Whenever a new database is opened, we have to find the
885: ** specific inode of the database file (the inode is determined by the
886: ** st_dev and st_ino fields of the stat structure that fstat() fills in)
887: ** and check for locks already existing on that inode. When locks are
888: ** created or removed, we have to look at our own internal record of the
889: ** locks to see if another thread has previously set a lock on that same
890: ** inode.
891: **
892: ** (Aside: The use of inode numbers as unique IDs does not work on VxWorks.
893: ** For VxWorks, we have to use the alternative unique ID system based on
894: ** canonical filename and implemented in the previous division.)
895: **
896: ** The sqlite3_file structure for POSIX is no longer just an integer file
897: ** descriptor. It is now a structure that holds the integer file
898: ** descriptor and a pointer to a structure that describes the internal
899: ** locks on the corresponding inode. There is one locking structure
900: ** per inode, so if the same inode is opened twice, both unixFile structures
901: ** point to the same locking structure. The locking structure keeps
902: ** a reference count (so we will know when to delete it) and a "cnt"
903: ** field that tells us its internal lock status. cnt==0 means the
904: ** file is unlocked. cnt==-1 means the file has an exclusive lock.
905: ** cnt>0 means there are cnt shared locks on the file.
906: **
907: ** Any attempt to lock or unlock a file first checks the locking
908: ** structure. The fcntl() system call is only invoked to set a
909: ** POSIX lock if the internal lock structure transitions between
910: ** a locked and an unlocked state.
911: **
912: ** But wait: there are yet more problems with POSIX advisory locks.
913: **
914: ** If you close a file descriptor that points to a file that has locks,
915: ** all locks on that file that are owned by the current process are
916: ** released. To work around this problem, each unixInodeInfo object
917: ** maintains a count of the number of pending locks on tha inode.
918: ** When an attempt is made to close an unixFile, if there are
919: ** other unixFile open on the same inode that are holding locks, the call
920: ** to close() the file descriptor is deferred until all of the locks clear.
921: ** The unixInodeInfo structure keeps a list of file descriptors that need to
922: ** be closed and that list is walked (and cleared) when the last lock
923: ** clears.
924: **
925: ** Yet another problem: LinuxThreads do not play well with posix locks.
926: **
927: ** Many older versions of linux use the LinuxThreads library which is
928: ** not posix compliant. Under LinuxThreads, a lock created by thread
929: ** A cannot be modified or overridden by a different thread B.
930: ** Only thread A can modify the lock. Locking behavior is correct
931: ** if the appliation uses the newer Native Posix Thread Library (NPTL)
932: ** on linux - with NPTL a lock created by thread A can override locks
933: ** in thread B. But there is no way to know at compile-time which
934: ** threading library is being used. So there is no way to know at
935: ** compile-time whether or not thread A can override locks on thread B.
936: ** One has to do a run-time check to discover the behavior of the
937: ** current process.
938: **
939: ** SQLite used to support LinuxThreads. But support for LinuxThreads
940: ** was dropped beginning with version 3.7.0. SQLite will still work with
941: ** LinuxThreads provided that (1) there is no more than one connection
942: ** per database file in the same process and (2) database connections
943: ** do not move across threads.
944: */
945:
946: /*
947: ** An instance of the following structure serves as the key used
948: ** to locate a particular unixInodeInfo object.
949: */
950: struct unixFileId {
951: dev_t dev; /* Device number */
952: #if OS_VXWORKS
953: struct vxworksFileId *pId; /* Unique file ID for vxworks. */
954: #else
955: ino_t ino; /* Inode number */
956: #endif
957: };
958:
959: /*
960: ** An instance of the following structure is allocated for each open
961: ** inode. Or, on LinuxThreads, there is one of these structures for
962: ** each inode opened by each thread.
963: **
964: ** A single inode can have multiple file descriptors, so each unixFile
965: ** structure contains a pointer to an instance of this object and this
966: ** object keeps a count of the number of unixFile pointing to it.
967: */
968: struct unixInodeInfo {
969: struct unixFileId fileId; /* The lookup key */
970: int nShared; /* Number of SHARED locks held */
971: unsigned char eFileLock; /* One of SHARED_LOCK, RESERVED_LOCK etc. */
972: unsigned char bProcessLock; /* An exclusive process lock is held */
973: int nRef; /* Number of pointers to this structure */
974: unixShmNode *pShmNode; /* Shared memory associated with this inode */
975: int nLock; /* Number of outstanding file locks */
976: UnixUnusedFd *pUnused; /* Unused file descriptors to close */
977: unixInodeInfo *pNext; /* List of all unixInodeInfo objects */
978: unixInodeInfo *pPrev; /* .... doubly linked */
979: #if SQLITE_ENABLE_LOCKING_STYLE
980: unsigned long long sharedByte; /* for AFP simulated shared lock */
981: #endif
982: #if OS_VXWORKS
983: sem_t *pSem; /* Named POSIX semaphore */
984: char aSemName[MAX_PATHNAME+2]; /* Name of that semaphore */
985: #endif
986: };
987:
988: /*
989: ** A lists of all unixInodeInfo objects.
990: */
991: static unixInodeInfo *inodeList = 0;
992:
993: /*
994: **
995: ** This function - unixLogError_x(), is only ever called via the macro
996: ** unixLogError().
997: **
998: ** It is invoked after an error occurs in an OS function and errno has been
999: ** set. It logs a message using sqlite3_log() containing the current value of
1000: ** errno and, if possible, the human-readable equivalent from strerror() or
1001: ** strerror_r().
1002: **
1003: ** The first argument passed to the macro should be the error code that
1004: ** will be returned to SQLite (e.g. SQLITE_IOERR_DELETE, SQLITE_CANTOPEN).
1005: ** The two subsequent arguments should be the name of the OS function that
1006: ** failed (e.g. "unlink", "open") and the the associated file-system path,
1007: ** if any.
1008: */
1009: #define unixLogError(a,b,c) unixLogErrorAtLine(a,b,c,__LINE__)
1010: static int unixLogErrorAtLine(
1011: int errcode, /* SQLite error code */
1012: const char *zFunc, /* Name of OS function that failed */
1013: const char *zPath, /* File path associated with error */
1014: int iLine /* Source line number where error occurred */
1015: ){
1016: char *zErr; /* Message from strerror() or equivalent */
1017: int iErrno = errno; /* Saved syscall error number */
1018:
1019: /* If this is not a threadsafe build (SQLITE_THREADSAFE==0), then use
1020: ** the strerror() function to obtain the human-readable error message
1021: ** equivalent to errno. Otherwise, use strerror_r().
1022: */
1023: #if SQLITE_THREADSAFE && defined(HAVE_STRERROR_R)
1024: char aErr[80];
1025: memset(aErr, 0, sizeof(aErr));
1026: zErr = aErr;
1027:
1028: /* If STRERROR_R_CHAR_P (set by autoconf scripts) or __USE_GNU is defined,
1029: ** assume that the system provides the the GNU version of strerror_r() that
1030: ** returns a pointer to a buffer containing the error message. That pointer
1031: ** may point to aErr[], or it may point to some static storage somewhere.
1032: ** Otherwise, assume that the system provides the POSIX version of
1033: ** strerror_r(), which always writes an error message into aErr[].
1034: **
1035: ** If the code incorrectly assumes that it is the POSIX version that is
1036: ** available, the error message will often be an empty string. Not a
1037: ** huge problem. Incorrectly concluding that the GNU version is available
1038: ** could lead to a segfault though.
1039: */
1040: #if defined(STRERROR_R_CHAR_P) || defined(__USE_GNU)
1041: zErr =
1042: # endif
1043: strerror_r(iErrno, aErr, sizeof(aErr)-1);
1044:
1045: #elif SQLITE_THREADSAFE
1046: /* This is a threadsafe build, but strerror_r() is not available. */
1047: zErr = "";
1048: #else
1049: /* Non-threadsafe build, use strerror(). */
1050: zErr = strerror(iErrno);
1051: #endif
1052:
1053: assert( errcode!=SQLITE_OK );
1054: if( zPath==0 ) zPath = "";
1055: sqlite3_log(errcode,
1056: "os_unix.c:%d: (%d) %s(%s) - %s",
1057: iLine, iErrno, zFunc, zPath, zErr
1058: );
1059:
1060: return errcode;
1061: }
1062:
1063: /*
1064: ** Close a file descriptor.
1065: **
1066: ** We assume that close() almost always works, since it is only in a
1067: ** very sick application or on a very sick platform that it might fail.
1068: ** If it does fail, simply leak the file descriptor, but do log the
1069: ** error.
1070: **
1071: ** Note that it is not safe to retry close() after EINTR since the
1072: ** file descriptor might have already been reused by another thread.
1073: ** So we don't even try to recover from an EINTR. Just log the error
1074: ** and move on.
1075: */
1076: static void robust_close(unixFile *pFile, int h, int lineno){
1077: if( osClose(h) ){
1078: unixLogErrorAtLine(SQLITE_IOERR_CLOSE, "close",
1079: pFile ? pFile->zPath : 0, lineno);
1080: }
1081: }
1082:
1083: /*
1084: ** Close all file descriptors accumuated in the unixInodeInfo->pUnused list.
1085: */
1086: static void closePendingFds(unixFile *pFile){
1087: unixInodeInfo *pInode = pFile->pInode;
1088: UnixUnusedFd *p;
1089: UnixUnusedFd *pNext;
1090: for(p=pInode->pUnused; p; p=pNext){
1091: pNext = p->pNext;
1092: robust_close(pFile, p->fd, __LINE__);
1093: sqlite3_free(p);
1094: }
1095: pInode->pUnused = 0;
1096: }
1097:
1098: /*
1099: ** Release a unixInodeInfo structure previously allocated by findInodeInfo().
1100: **
1101: ** The mutex entered using the unixEnterMutex() function must be held
1102: ** when this function is called.
1103: */
1104: static void releaseInodeInfo(unixFile *pFile){
1105: unixInodeInfo *pInode = pFile->pInode;
1106: assert( unixMutexHeld() );
1107: if( ALWAYS(pInode) ){
1108: pInode->nRef--;
1109: if( pInode->nRef==0 ){
1110: assert( pInode->pShmNode==0 );
1111: closePendingFds(pFile);
1112: if( pInode->pPrev ){
1113: assert( pInode->pPrev->pNext==pInode );
1114: pInode->pPrev->pNext = pInode->pNext;
1115: }else{
1116: assert( inodeList==pInode );
1117: inodeList = pInode->pNext;
1118: }
1119: if( pInode->pNext ){
1120: assert( pInode->pNext->pPrev==pInode );
1121: pInode->pNext->pPrev = pInode->pPrev;
1122: }
1123: sqlite3_free(pInode);
1124: }
1125: }
1126: }
1127:
1128: /*
1129: ** Given a file descriptor, locate the unixInodeInfo object that
1130: ** describes that file descriptor. Create a new one if necessary. The
1131: ** return value might be uninitialized if an error occurs.
1132: **
1133: ** The mutex entered using the unixEnterMutex() function must be held
1134: ** when this function is called.
1135: **
1136: ** Return an appropriate error code.
1137: */
1138: static int findInodeInfo(
1139: unixFile *pFile, /* Unix file with file desc used in the key */
1140: unixInodeInfo **ppInode /* Return the unixInodeInfo object here */
1141: ){
1142: int rc; /* System call return code */
1143: int fd; /* The file descriptor for pFile */
1144: struct unixFileId fileId; /* Lookup key for the unixInodeInfo */
1145: struct stat statbuf; /* Low-level file information */
1146: unixInodeInfo *pInode = 0; /* Candidate unixInodeInfo object */
1147:
1148: assert( unixMutexHeld() );
1149:
1150: /* Get low-level information about the file that we can used to
1151: ** create a unique name for the file.
1152: */
1153: fd = pFile->h;
1154: rc = osFstat(fd, &statbuf);
1155: if( rc!=0 ){
1156: pFile->lastErrno = errno;
1157: #ifdef EOVERFLOW
1158: if( pFile->lastErrno==EOVERFLOW ) return SQLITE_NOLFS;
1159: #endif
1160: return SQLITE_IOERR;
1161: }
1162:
1163: #ifdef __APPLE__
1164: /* On OS X on an msdos filesystem, the inode number is reported
1165: ** incorrectly for zero-size files. See ticket #3260. To work
1166: ** around this problem (we consider it a bug in OS X, not SQLite)
1167: ** we always increase the file size to 1 by writing a single byte
1168: ** prior to accessing the inode number. The one byte written is
1169: ** an ASCII 'S' character which also happens to be the first byte
1170: ** in the header of every SQLite database. In this way, if there
1171: ** is a race condition such that another thread has already populated
1172: ** the first page of the database, no damage is done.
1173: */
1174: if( statbuf.st_size==0 && (pFile->fsFlags & SQLITE_FSFLAGS_IS_MSDOS)!=0 ){
1175: do{ rc = osWrite(fd, "S", 1); }while( rc<0 && errno==EINTR );
1176: if( rc!=1 ){
1177: pFile->lastErrno = errno;
1178: return SQLITE_IOERR;
1179: }
1180: rc = osFstat(fd, &statbuf);
1181: if( rc!=0 ){
1182: pFile->lastErrno = errno;
1183: return SQLITE_IOERR;
1184: }
1185: }
1186: #endif
1187:
1188: memset(&fileId, 0, sizeof(fileId));
1189: fileId.dev = statbuf.st_dev;
1190: #if OS_VXWORKS
1191: fileId.pId = pFile->pId;
1192: #else
1193: fileId.ino = statbuf.st_ino;
1194: #endif
1195: pInode = inodeList;
1196: while( pInode && memcmp(&fileId, &pInode->fileId, sizeof(fileId)) ){
1197: pInode = pInode->pNext;
1198: }
1199: if( pInode==0 ){
1200: pInode = sqlite3_malloc( sizeof(*pInode) );
1201: if( pInode==0 ){
1202: return SQLITE_NOMEM;
1203: }
1204: memset(pInode, 0, sizeof(*pInode));
1205: memcpy(&pInode->fileId, &fileId, sizeof(fileId));
1206: pInode->nRef = 1;
1207: pInode->pNext = inodeList;
1208: pInode->pPrev = 0;
1209: if( inodeList ) inodeList->pPrev = pInode;
1210: inodeList = pInode;
1211: }else{
1212: pInode->nRef++;
1213: }
1214: *ppInode = pInode;
1215: return SQLITE_OK;
1216: }
1217:
1218:
1219: /*
1220: ** This routine checks if there is a RESERVED lock held on the specified
1221: ** file by this or any other process. If such a lock is held, set *pResOut
1222: ** to a non-zero value otherwise *pResOut is set to zero. The return value
1223: ** is set to SQLITE_OK unless an I/O error occurs during lock checking.
1224: */
1225: static int unixCheckReservedLock(sqlite3_file *id, int *pResOut){
1226: int rc = SQLITE_OK;
1227: int reserved = 0;
1228: unixFile *pFile = (unixFile*)id;
1229:
1230: SimulateIOError( return SQLITE_IOERR_CHECKRESERVEDLOCK; );
1231:
1232: assert( pFile );
1233: unixEnterMutex(); /* Because pFile->pInode is shared across threads */
1234:
1235: /* Check if a thread in this process holds such a lock */
1236: if( pFile->pInode->eFileLock>SHARED_LOCK ){
1237: reserved = 1;
1238: }
1239:
1240: /* Otherwise see if some other process holds it.
1241: */
1242: #ifndef __DJGPP__
1243: if( !reserved && !pFile->pInode->bProcessLock ){
1244: struct flock lock;
1245: lock.l_whence = SEEK_SET;
1246: lock.l_start = RESERVED_BYTE;
1247: lock.l_len = 1;
1248: lock.l_type = F_WRLCK;
1249: if( osFcntl(pFile->h, F_GETLK, &lock) ){
1250: rc = SQLITE_IOERR_CHECKRESERVEDLOCK;
1251: pFile->lastErrno = errno;
1252: } else if( lock.l_type!=F_UNLCK ){
1253: reserved = 1;
1254: }
1255: }
1256: #endif
1257:
1258: unixLeaveMutex();
1259: OSTRACE(("TEST WR-LOCK %d %d %d (unix)\n", pFile->h, rc, reserved));
1260:
1261: *pResOut = reserved;
1262: return rc;
1263: }
1264:
1265: /*
1266: ** Attempt to set a system-lock on the file pFile. The lock is
1267: ** described by pLock.
1268: **
1269: ** If the pFile was opened read/write from unix-excl, then the only lock
1270: ** ever obtained is an exclusive lock, and it is obtained exactly once
1271: ** the first time any lock is attempted. All subsequent system locking
1272: ** operations become no-ops. Locking operations still happen internally,
1273: ** in order to coordinate access between separate database connections
1274: ** within this process, but all of that is handled in memory and the
1275: ** operating system does not participate.
1276: **
1277: ** This function is a pass-through to fcntl(F_SETLK) if pFile is using
1278: ** any VFS other than "unix-excl" or if pFile is opened on "unix-excl"
1279: ** and is read-only.
1280: **
1281: ** Zero is returned if the call completes successfully, or -1 if a call
1282: ** to fcntl() fails. In this case, errno is set appropriately (by fcntl()).
1283: */
1284: static int unixFileLock(unixFile *pFile, struct flock *pLock){
1285: int rc;
1286: unixInodeInfo *pInode = pFile->pInode;
1287: assert( unixMutexHeld() );
1288: assert( pInode!=0 );
1289: if( ((pFile->ctrlFlags & UNIXFILE_EXCL)!=0 || pInode->bProcessLock)
1290: && ((pFile->ctrlFlags & UNIXFILE_RDONLY)==0)
1291: ){
1292: if( pInode->bProcessLock==0 ){
1293: struct flock lock;
1294: assert( pInode->nLock==0 );
1295: lock.l_whence = SEEK_SET;
1296: lock.l_start = SHARED_FIRST;
1297: lock.l_len = SHARED_SIZE;
1298: lock.l_type = F_WRLCK;
1299: rc = osFcntl(pFile->h, F_SETLK, &lock);
1300: if( rc<0 ) return rc;
1301: pInode->bProcessLock = 1;
1302: pInode->nLock++;
1303: }else{
1304: rc = 0;
1305: }
1306: }else{
1307: rc = osFcntl(pFile->h, F_SETLK, pLock);
1308: }
1309: return rc;
1310: }
1311:
1312: /*
1313: ** Lock the file with the lock specified by parameter eFileLock - one
1314: ** of the following:
1315: **
1316: ** (1) SHARED_LOCK
1317: ** (2) RESERVED_LOCK
1318: ** (3) PENDING_LOCK
1319: ** (4) EXCLUSIVE_LOCK
1320: **
1321: ** Sometimes when requesting one lock state, additional lock states
1322: ** are inserted in between. The locking might fail on one of the later
1323: ** transitions leaving the lock state different from what it started but
1324: ** still short of its goal. The following chart shows the allowed
1325: ** transitions and the inserted intermediate states:
1326: **
1327: ** UNLOCKED -> SHARED
1328: ** SHARED -> RESERVED
1329: ** SHARED -> (PENDING) -> EXCLUSIVE
1330: ** RESERVED -> (PENDING) -> EXCLUSIVE
1331: ** PENDING -> EXCLUSIVE
1332: **
1333: ** This routine will only increase a lock. Use the sqlite3OsUnlock()
1334: ** routine to lower a locking level.
1335: */
1336: static int unixLock(sqlite3_file *id, int eFileLock){
1337: /* The following describes the implementation of the various locks and
1338: ** lock transitions in terms of the POSIX advisory shared and exclusive
1339: ** lock primitives (called read-locks and write-locks below, to avoid
1340: ** confusion with SQLite lock names). The algorithms are complicated
1341: ** slightly in order to be compatible with windows systems simultaneously
1342: ** accessing the same database file, in case that is ever required.
1343: **
1344: ** Symbols defined in os.h indentify the 'pending byte' and the 'reserved
1345: ** byte', each single bytes at well known offsets, and the 'shared byte
1346: ** range', a range of 510 bytes at a well known offset.
1347: **
1348: ** To obtain a SHARED lock, a read-lock is obtained on the 'pending
1349: ** byte'. If this is successful, a random byte from the 'shared byte
1350: ** range' is read-locked and the lock on the 'pending byte' released.
1351: **
1352: ** A process may only obtain a RESERVED lock after it has a SHARED lock.
1353: ** A RESERVED lock is implemented by grabbing a write-lock on the
1354: ** 'reserved byte'.
1355: **
1356: ** A process may only obtain a PENDING lock after it has obtained a
1357: ** SHARED lock. A PENDING lock is implemented by obtaining a write-lock
1358: ** on the 'pending byte'. This ensures that no new SHARED locks can be
1359: ** obtained, but existing SHARED locks are allowed to persist. A process
1360: ** does not have to obtain a RESERVED lock on the way to a PENDING lock.
1361: ** This property is used by the algorithm for rolling back a journal file
1362: ** after a crash.
1363: **
1364: ** An EXCLUSIVE lock, obtained after a PENDING lock is held, is
1365: ** implemented by obtaining a write-lock on the entire 'shared byte
1366: ** range'. Since all other locks require a read-lock on one of the bytes
1367: ** within this range, this ensures that no other locks are held on the
1368: ** database.
1369: **
1370: ** The reason a single byte cannot be used instead of the 'shared byte
1371: ** range' is that some versions of windows do not support read-locks. By
1372: ** locking a random byte from a range, concurrent SHARED locks may exist
1373: ** even if the locking primitive used is always a write-lock.
1374: */
1375: int rc = SQLITE_OK;
1376: unixFile *pFile = (unixFile*)id;
1377: unixInodeInfo *pInode;
1378: struct flock lock;
1379: int tErrno = 0;
1380:
1381: assert( pFile );
1382: OSTRACE(("LOCK %d %s was %s(%s,%d) pid=%d (unix)\n", pFile->h,
1383: azFileLock(eFileLock), azFileLock(pFile->eFileLock),
1384: azFileLock(pFile->pInode->eFileLock), pFile->pInode->nShared , getpid()));
1385:
1386: /* If there is already a lock of this type or more restrictive on the
1387: ** unixFile, do nothing. Don't use the end_lock: exit path, as
1388: ** unixEnterMutex() hasn't been called yet.
1389: */
1390: if( pFile->eFileLock>=eFileLock ){
1391: OSTRACE(("LOCK %d %s ok (already held) (unix)\n", pFile->h,
1392: azFileLock(eFileLock)));
1393: return SQLITE_OK;
1394: }
1395:
1396: /* Make sure the locking sequence is correct.
1397: ** (1) We never move from unlocked to anything higher than shared lock.
1398: ** (2) SQLite never explicitly requests a pendig lock.
1399: ** (3) A shared lock is always held when a reserve lock is requested.
1400: */
1401: assert( pFile->eFileLock!=NO_LOCK || eFileLock==SHARED_LOCK );
1402: assert( eFileLock!=PENDING_LOCK );
1403: assert( eFileLock!=RESERVED_LOCK || pFile->eFileLock==SHARED_LOCK );
1404:
1405: /* This mutex is needed because pFile->pInode is shared across threads
1406: */
1407: unixEnterMutex();
1408: pInode = pFile->pInode;
1409:
1410: /* If some thread using this PID has a lock via a different unixFile*
1411: ** handle that precludes the requested lock, return BUSY.
1412: */
1413: if( (pFile->eFileLock!=pInode->eFileLock &&
1414: (pInode->eFileLock>=PENDING_LOCK || eFileLock>SHARED_LOCK))
1415: ){
1416: rc = SQLITE_BUSY;
1417: goto end_lock;
1418: }
1419:
1420: /* If a SHARED lock is requested, and some thread using this PID already
1421: ** has a SHARED or RESERVED lock, then increment reference counts and
1422: ** return SQLITE_OK.
1423: */
1424: if( eFileLock==SHARED_LOCK &&
1425: (pInode->eFileLock==SHARED_LOCK || pInode->eFileLock==RESERVED_LOCK) ){
1426: assert( eFileLock==SHARED_LOCK );
1427: assert( pFile->eFileLock==0 );
1428: assert( pInode->nShared>0 );
1429: pFile->eFileLock = SHARED_LOCK;
1430: pInode->nShared++;
1431: pInode->nLock++;
1432: goto end_lock;
1433: }
1434:
1435:
1436: /* A PENDING lock is needed before acquiring a SHARED lock and before
1437: ** acquiring an EXCLUSIVE lock. For the SHARED lock, the PENDING will
1438: ** be released.
1439: */
1440: lock.l_len = 1L;
1441: lock.l_whence = SEEK_SET;
1442: if( eFileLock==SHARED_LOCK
1443: || (eFileLock==EXCLUSIVE_LOCK && pFile->eFileLock<PENDING_LOCK)
1444: ){
1445: lock.l_type = (eFileLock==SHARED_LOCK?F_RDLCK:F_WRLCK);
1446: lock.l_start = PENDING_BYTE;
1447: if( unixFileLock(pFile, &lock) ){
1448: tErrno = errno;
1449: rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK);
1450: if( rc!=SQLITE_BUSY ){
1451: pFile->lastErrno = tErrno;
1452: }
1453: goto end_lock;
1454: }
1455: }
1456:
1457:
1458: /* If control gets to this point, then actually go ahead and make
1459: ** operating system calls for the specified lock.
1460: */
1461: if( eFileLock==SHARED_LOCK ){
1462: assert( pInode->nShared==0 );
1463: assert( pInode->eFileLock==0 );
1464: assert( rc==SQLITE_OK );
1465:
1466: /* Now get the read-lock */
1467: lock.l_start = SHARED_FIRST;
1468: lock.l_len = SHARED_SIZE;
1469: if( unixFileLock(pFile, &lock) ){
1470: tErrno = errno;
1471: rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK);
1472: }
1473:
1474: /* Drop the temporary PENDING lock */
1475: lock.l_start = PENDING_BYTE;
1476: lock.l_len = 1L;
1477: lock.l_type = F_UNLCK;
1478: if( unixFileLock(pFile, &lock) && rc==SQLITE_OK ){
1479: /* This could happen with a network mount */
1480: tErrno = errno;
1481: rc = SQLITE_IOERR_UNLOCK;
1482: }
1483:
1484: if( rc ){
1485: if( rc!=SQLITE_BUSY ){
1486: pFile->lastErrno = tErrno;
1487: }
1488: goto end_lock;
1489: }else{
1490: pFile->eFileLock = SHARED_LOCK;
1491: pInode->nLock++;
1492: pInode->nShared = 1;
1493: }
1494: }else if( eFileLock==EXCLUSIVE_LOCK && pInode->nShared>1 ){
1495: /* We are trying for an exclusive lock but another thread in this
1496: ** same process is still holding a shared lock. */
1497: rc = SQLITE_BUSY;
1498: }else{
1499: /* The request was for a RESERVED or EXCLUSIVE lock. It is
1500: ** assumed that there is a SHARED or greater lock on the file
1501: ** already.
1502: */
1503: assert( 0!=pFile->eFileLock );
1504: lock.l_type = F_WRLCK;
1505:
1506: assert( eFileLock==RESERVED_LOCK || eFileLock==EXCLUSIVE_LOCK );
1507: if( eFileLock==RESERVED_LOCK ){
1508: lock.l_start = RESERVED_BYTE;
1509: lock.l_len = 1L;
1510: }else{
1511: lock.l_start = SHARED_FIRST;
1512: lock.l_len = SHARED_SIZE;
1513: }
1514:
1515: if( unixFileLock(pFile, &lock) ){
1516: tErrno = errno;
1517: rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK);
1518: if( rc!=SQLITE_BUSY ){
1519: pFile->lastErrno = tErrno;
1520: }
1521: }
1522: }
1523:
1524:
1525: #ifndef NDEBUG
1526: /* Set up the transaction-counter change checking flags when
1527: ** transitioning from a SHARED to a RESERVED lock. The change
1528: ** from SHARED to RESERVED marks the beginning of a normal
1529: ** write operation (not a hot journal rollback).
1530: */
1531: if( rc==SQLITE_OK
1532: && pFile->eFileLock<=SHARED_LOCK
1533: && eFileLock==RESERVED_LOCK
1534: ){
1535: pFile->transCntrChng = 0;
1536: pFile->dbUpdate = 0;
1537: pFile->inNormalWrite = 1;
1538: }
1539: #endif
1540:
1541:
1542: if( rc==SQLITE_OK ){
1543: pFile->eFileLock = eFileLock;
1544: pInode->eFileLock = eFileLock;
1545: }else if( eFileLock==EXCLUSIVE_LOCK ){
1546: pFile->eFileLock = PENDING_LOCK;
1547: pInode->eFileLock = PENDING_LOCK;
1548: }
1549:
1550: end_lock:
1551: unixLeaveMutex();
1552: OSTRACE(("LOCK %d %s %s (unix)\n", pFile->h, azFileLock(eFileLock),
1553: rc==SQLITE_OK ? "ok" : "failed"));
1554: return rc;
1555: }
1556:
1557: /*
1558: ** Add the file descriptor used by file handle pFile to the corresponding
1559: ** pUnused list.
1560: */
1561: static void setPendingFd(unixFile *pFile){
1562: unixInodeInfo *pInode = pFile->pInode;
1563: UnixUnusedFd *p = pFile->pUnused;
1564: p->pNext = pInode->pUnused;
1565: pInode->pUnused = p;
1566: pFile->h = -1;
1567: pFile->pUnused = 0;
1568: }
1569:
1570: /*
1571: ** Lower the locking level on file descriptor pFile to eFileLock. eFileLock
1572: ** must be either NO_LOCK or SHARED_LOCK.
1573: **
1574: ** If the locking level of the file descriptor is already at or below
1575: ** the requested locking level, this routine is a no-op.
1576: **
1577: ** If handleNFSUnlock is true, then on downgrading an EXCLUSIVE_LOCK to SHARED
1578: ** the byte range is divided into 2 parts and the first part is unlocked then
1579: ** set to a read lock, then the other part is simply unlocked. This works
1580: ** around a bug in BSD NFS lockd (also seen on MacOSX 10.3+) that fails to
1581: ** remove the write lock on a region when a read lock is set.
1582: */
1583: static int posixUnlock(sqlite3_file *id, int eFileLock, int handleNFSUnlock){
1584: unixFile *pFile = (unixFile*)id;
1585: unixInodeInfo *pInode;
1586: struct flock lock;
1587: int rc = SQLITE_OK;
1588:
1589: assert( pFile );
1590: OSTRACE(("UNLOCK %d %d was %d(%d,%d) pid=%d (unix)\n", pFile->h, eFileLock,
1591: pFile->eFileLock, pFile->pInode->eFileLock, pFile->pInode->nShared,
1592: getpid()));
1593:
1594: assert( eFileLock<=SHARED_LOCK );
1595: if( pFile->eFileLock<=eFileLock ){
1596: return SQLITE_OK;
1597: }
1598: unixEnterMutex();
1599: pInode = pFile->pInode;
1600: assert( pInode->nShared!=0 );
1601: if( pFile->eFileLock>SHARED_LOCK ){
1602: assert( pInode->eFileLock==pFile->eFileLock );
1603:
1604: #ifndef NDEBUG
1605: /* When reducing a lock such that other processes can start
1606: ** reading the database file again, make sure that the
1607: ** transaction counter was updated if any part of the database
1608: ** file changed. If the transaction counter is not updated,
1609: ** other connections to the same file might not realize that
1610: ** the file has changed and hence might not know to flush their
1611: ** cache. The use of a stale cache can lead to database corruption.
1612: */
1613: pFile->inNormalWrite = 0;
1614: #endif
1615:
1616: /* downgrading to a shared lock on NFS involves clearing the write lock
1617: ** before establishing the readlock - to avoid a race condition we downgrade
1618: ** the lock in 2 blocks, so that part of the range will be covered by a
1619: ** write lock until the rest is covered by a read lock:
1620: ** 1: [WWWWW]
1621: ** 2: [....W]
1622: ** 3: [RRRRW]
1623: ** 4: [RRRR.]
1624: */
1625: if( eFileLock==SHARED_LOCK ){
1626:
1627: #if !defined(__APPLE__) || !SQLITE_ENABLE_LOCKING_STYLE
1628: (void)handleNFSUnlock;
1629: assert( handleNFSUnlock==0 );
1630: #endif
1631: #if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE
1632: if( handleNFSUnlock ){
1633: int tErrno; /* Error code from system call errors */
1634: off_t divSize = SHARED_SIZE - 1;
1635:
1636: lock.l_type = F_UNLCK;
1637: lock.l_whence = SEEK_SET;
1638: lock.l_start = SHARED_FIRST;
1639: lock.l_len = divSize;
1640: if( unixFileLock(pFile, &lock)==(-1) ){
1641: tErrno = errno;
1642: rc = SQLITE_IOERR_UNLOCK;
1643: if( IS_LOCK_ERROR(rc) ){
1644: pFile->lastErrno = tErrno;
1645: }
1646: goto end_unlock;
1647: }
1648: lock.l_type = F_RDLCK;
1649: lock.l_whence = SEEK_SET;
1650: lock.l_start = SHARED_FIRST;
1651: lock.l_len = divSize;
1652: if( unixFileLock(pFile, &lock)==(-1) ){
1653: tErrno = errno;
1654: rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_RDLOCK);
1655: if( IS_LOCK_ERROR(rc) ){
1656: pFile->lastErrno = tErrno;
1657: }
1658: goto end_unlock;
1659: }
1660: lock.l_type = F_UNLCK;
1661: lock.l_whence = SEEK_SET;
1662: lock.l_start = SHARED_FIRST+divSize;
1663: lock.l_len = SHARED_SIZE-divSize;
1664: if( unixFileLock(pFile, &lock)==(-1) ){
1665: tErrno = errno;
1666: rc = SQLITE_IOERR_UNLOCK;
1667: if( IS_LOCK_ERROR(rc) ){
1668: pFile->lastErrno = tErrno;
1669: }
1670: goto end_unlock;
1671: }
1672: }else
1673: #endif /* defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE */
1674: {
1675: lock.l_type = F_RDLCK;
1676: lock.l_whence = SEEK_SET;
1677: lock.l_start = SHARED_FIRST;
1678: lock.l_len = SHARED_SIZE;
1679: if( unixFileLock(pFile, &lock) ){
1680: /* In theory, the call to unixFileLock() cannot fail because another
1681: ** process is holding an incompatible lock. If it does, this
1682: ** indicates that the other process is not following the locking
1683: ** protocol. If this happens, return SQLITE_IOERR_RDLOCK. Returning
1684: ** SQLITE_BUSY would confuse the upper layer (in practice it causes
1685: ** an assert to fail). */
1686: rc = SQLITE_IOERR_RDLOCK;
1687: pFile->lastErrno = errno;
1688: goto end_unlock;
1689: }
1690: }
1691: }
1692: lock.l_type = F_UNLCK;
1693: lock.l_whence = SEEK_SET;
1694: lock.l_start = PENDING_BYTE;
1695: lock.l_len = 2L; assert( PENDING_BYTE+1==RESERVED_BYTE );
1696: if( unixFileLock(pFile, &lock)==0 ){
1697: pInode->eFileLock = SHARED_LOCK;
1698: }else{
1699: rc = SQLITE_IOERR_UNLOCK;
1700: pFile->lastErrno = errno;
1701: goto end_unlock;
1702: }
1703: }
1704: if( eFileLock==NO_LOCK ){
1705: /* Decrement the shared lock counter. Release the lock using an
1706: ** OS call only when all threads in this same process have released
1707: ** the lock.
1708: */
1709: pInode->nShared--;
1710: if( pInode->nShared==0 ){
1711: lock.l_type = F_UNLCK;
1712: lock.l_whence = SEEK_SET;
1713: lock.l_start = lock.l_len = 0L;
1714: if( unixFileLock(pFile, &lock)==0 ){
1715: pInode->eFileLock = NO_LOCK;
1716: }else{
1717: rc = SQLITE_IOERR_UNLOCK;
1718: pFile->lastErrno = errno;
1719: pInode->eFileLock = NO_LOCK;
1720: pFile->eFileLock = NO_LOCK;
1721: }
1722: }
1723:
1724: /* Decrement the count of locks against this same file. When the
1725: ** count reaches zero, close any other file descriptors whose close
1726: ** was deferred because of outstanding locks.
1727: */
1728: pInode->nLock--;
1729: assert( pInode->nLock>=0 );
1730: if( pInode->nLock==0 ){
1731: closePendingFds(pFile);
1732: }
1733: }
1734:
1735: end_unlock:
1736: unixLeaveMutex();
1737: if( rc==SQLITE_OK ) pFile->eFileLock = eFileLock;
1738: return rc;
1739: }
1740:
1741: /*
1742: ** Lower the locking level on file descriptor pFile to eFileLock. eFileLock
1743: ** must be either NO_LOCK or SHARED_LOCK.
1744: **
1745: ** If the locking level of the file descriptor is already at or below
1746: ** the requested locking level, this routine is a no-op.
1747: */
1748: static int unixUnlock(sqlite3_file *id, int eFileLock){
1749: return posixUnlock(id, eFileLock, 0);
1750: }
1751:
1752: /*
1753: ** This function performs the parts of the "close file" operation
1754: ** common to all locking schemes. It closes the directory and file
1755: ** handles, if they are valid, and sets all fields of the unixFile
1756: ** structure to 0.
1757: **
1758: ** It is *not* necessary to hold the mutex when this routine is called,
1759: ** even on VxWorks. A mutex will be acquired on VxWorks by the
1760: ** vxworksReleaseFileId() routine.
1761: */
1762: static int closeUnixFile(sqlite3_file *id){
1763: unixFile *pFile = (unixFile*)id;
1764: if( pFile->h>=0 ){
1765: robust_close(pFile, pFile->h, __LINE__);
1766: pFile->h = -1;
1767: }
1768: #if OS_VXWORKS
1769: if( pFile->pId ){
1770: if( pFile->ctrlFlags & UNIXFILE_DELETE ){
1771: osUnlink(pFile->pId->zCanonicalName);
1772: }
1773: vxworksReleaseFileId(pFile->pId);
1774: pFile->pId = 0;
1775: }
1776: #endif
1777: OSTRACE(("CLOSE %-3d\n", pFile->h));
1778: OpenCounter(-1);
1779: sqlite3_free(pFile->pUnused);
1780: memset(pFile, 0, sizeof(unixFile));
1781: return SQLITE_OK;
1782: }
1783:
1784: /*
1785: ** Close a file.
1786: */
1787: static int unixClose(sqlite3_file *id){
1788: int rc = SQLITE_OK;
1789: unixFile *pFile = (unixFile *)id;
1790: unixUnlock(id, NO_LOCK);
1791: unixEnterMutex();
1792:
1793: /* unixFile.pInode is always valid here. Otherwise, a different close
1794: ** routine (e.g. nolockClose()) would be called instead.
1795: */
1796: assert( pFile->pInode->nLock>0 || pFile->pInode->bProcessLock==0 );
1797: if( ALWAYS(pFile->pInode) && pFile->pInode->nLock ){
1798: /* If there are outstanding locks, do not actually close the file just
1799: ** yet because that would clear those locks. Instead, add the file
1800: ** descriptor to pInode->pUnused list. It will be automatically closed
1801: ** when the last lock is cleared.
1802: */
1803: setPendingFd(pFile);
1804: }
1805: releaseInodeInfo(pFile);
1806: rc = closeUnixFile(id);
1807: unixLeaveMutex();
1808: return rc;
1809: }
1810:
1811: /************** End of the posix advisory lock implementation *****************
1812: ******************************************************************************/
1813:
1814: /******************************************************************************
1815: ****************************** No-op Locking **********************************
1816: **
1817: ** Of the various locking implementations available, this is by far the
1818: ** simplest: locking is ignored. No attempt is made to lock the database
1819: ** file for reading or writing.
1820: **
1821: ** This locking mode is appropriate for use on read-only databases
1822: ** (ex: databases that are burned into CD-ROM, for example.) It can
1823: ** also be used if the application employs some external mechanism to
1824: ** prevent simultaneous access of the same database by two or more
1825: ** database connections. But there is a serious risk of database
1826: ** corruption if this locking mode is used in situations where multiple
1827: ** database connections are accessing the same database file at the same
1828: ** time and one or more of those connections are writing.
1829: */
1830:
1831: static int nolockCheckReservedLock(sqlite3_file *NotUsed, int *pResOut){
1832: UNUSED_PARAMETER(NotUsed);
1833: *pResOut = 0;
1834: return SQLITE_OK;
1835: }
1836: static int nolockLock(sqlite3_file *NotUsed, int NotUsed2){
1837: UNUSED_PARAMETER2(NotUsed, NotUsed2);
1838: return SQLITE_OK;
1839: }
1840: static int nolockUnlock(sqlite3_file *NotUsed, int NotUsed2){
1841: UNUSED_PARAMETER2(NotUsed, NotUsed2);
1842: return SQLITE_OK;
1843: }
1844:
1845: /*
1846: ** Close the file.
1847: */
1848: static int nolockClose(sqlite3_file *id) {
1849: return closeUnixFile(id);
1850: }
1851:
1852: /******************* End of the no-op lock implementation *********************
1853: ******************************************************************************/
1854:
1855: /******************************************************************************
1856: ************************* Begin dot-file Locking ******************************
1857: **
1858: ** The dotfile locking implementation uses the existance of separate lock
1859: ** files (really a directory) to control access to the database. This works
1860: ** on just about every filesystem imaginable. But there are serious downsides:
1861: **
1862: ** (1) There is zero concurrency. A single reader blocks all other
1863: ** connections from reading or writing the database.
1864: **
1865: ** (2) An application crash or power loss can leave stale lock files
1866: ** sitting around that need to be cleared manually.
1867: **
1868: ** Nevertheless, a dotlock is an appropriate locking mode for use if no
1869: ** other locking strategy is available.
1870: **
1871: ** Dotfile locking works by creating a subdirectory in the same directory as
1872: ** the database and with the same name but with a ".lock" extension added.
1873: ** The existance of a lock directory implies an EXCLUSIVE lock. All other
1874: ** lock types (SHARED, RESERVED, PENDING) are mapped into EXCLUSIVE.
1875: */
1876:
1877: /*
1878: ** The file suffix added to the data base filename in order to create the
1879: ** lock directory.
1880: */
1881: #define DOTLOCK_SUFFIX ".lock"
1882:
1883: /*
1884: ** This routine checks if there is a RESERVED lock held on the specified
1885: ** file by this or any other process. If such a lock is held, set *pResOut
1886: ** to a non-zero value otherwise *pResOut is set to zero. The return value
1887: ** is set to SQLITE_OK unless an I/O error occurs during lock checking.
1888: **
1889: ** In dotfile locking, either a lock exists or it does not. So in this
1890: ** variation of CheckReservedLock(), *pResOut is set to true if any lock
1891: ** is held on the file and false if the file is unlocked.
1892: */
1893: static int dotlockCheckReservedLock(sqlite3_file *id, int *pResOut) {
1894: int rc = SQLITE_OK;
1895: int reserved = 0;
1896: unixFile *pFile = (unixFile*)id;
1897:
1898: SimulateIOError( return SQLITE_IOERR_CHECKRESERVEDLOCK; );
1899:
1900: assert( pFile );
1901:
1902: /* Check if a thread in this process holds such a lock */
1903: if( pFile->eFileLock>SHARED_LOCK ){
1904: /* Either this connection or some other connection in the same process
1905: ** holds a lock on the file. No need to check further. */
1906: reserved = 1;
1907: }else{
1908: /* The lock is held if and only if the lockfile exists */
1909: const char *zLockFile = (const char*)pFile->lockingContext;
1910: reserved = osAccess(zLockFile, 0)==0;
1911: }
1912: OSTRACE(("TEST WR-LOCK %d %d %d (dotlock)\n", pFile->h, rc, reserved));
1913: *pResOut = reserved;
1914: return rc;
1915: }
1916:
1917: /*
1918: ** Lock the file with the lock specified by parameter eFileLock - one
1919: ** of the following:
1920: **
1921: ** (1) SHARED_LOCK
1922: ** (2) RESERVED_LOCK
1923: ** (3) PENDING_LOCK
1924: ** (4) EXCLUSIVE_LOCK
1925: **
1926: ** Sometimes when requesting one lock state, additional lock states
1927: ** are inserted in between. The locking might fail on one of the later
1928: ** transitions leaving the lock state different from what it started but
1929: ** still short of its goal. The following chart shows the allowed
1930: ** transitions and the inserted intermediate states:
1931: **
1932: ** UNLOCKED -> SHARED
1933: ** SHARED -> RESERVED
1934: ** SHARED -> (PENDING) -> EXCLUSIVE
1935: ** RESERVED -> (PENDING) -> EXCLUSIVE
1936: ** PENDING -> EXCLUSIVE
1937: **
1938: ** This routine will only increase a lock. Use the sqlite3OsUnlock()
1939: ** routine to lower a locking level.
1940: **
1941: ** With dotfile locking, we really only support state (4): EXCLUSIVE.
1942: ** But we track the other locking levels internally.
1943: */
1944: static int dotlockLock(sqlite3_file *id, int eFileLock) {
1945: unixFile *pFile = (unixFile*)id;
1946: char *zLockFile = (char *)pFile->lockingContext;
1947: int rc = SQLITE_OK;
1948:
1949:
1950: /* If we have any lock, then the lock file already exists. All we have
1951: ** to do is adjust our internal record of the lock level.
1952: */
1953: if( pFile->eFileLock > NO_LOCK ){
1954: pFile->eFileLock = eFileLock;
1955: /* Always update the timestamp on the old file */
1956: #ifdef HAVE_UTIME
1957: utime(zLockFile, NULL);
1958: #else
1959: utimes(zLockFile, NULL);
1960: #endif
1961: return SQLITE_OK;
1962: }
1963:
1964: /* grab an exclusive lock */
1965: rc = osMkdir(zLockFile, 0777);
1966: if( rc<0 ){
1967: /* failed to open/create the lock directory */
1968: int tErrno = errno;
1969: if( EEXIST == tErrno ){
1970: rc = SQLITE_BUSY;
1971: } else {
1972: rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK);
1973: if( IS_LOCK_ERROR(rc) ){
1974: pFile->lastErrno = tErrno;
1975: }
1976: }
1977: return rc;
1978: }
1979:
1980: /* got it, set the type and return ok */
1981: pFile->eFileLock = eFileLock;
1982: return rc;
1983: }
1984:
1985: /*
1986: ** Lower the locking level on file descriptor pFile to eFileLock. eFileLock
1987: ** must be either NO_LOCK or SHARED_LOCK.
1988: **
1989: ** If the locking level of the file descriptor is already at or below
1990: ** the requested locking level, this routine is a no-op.
1991: **
1992: ** When the locking level reaches NO_LOCK, delete the lock file.
1993: */
1994: static int dotlockUnlock(sqlite3_file *id, int eFileLock) {
1995: unixFile *pFile = (unixFile*)id;
1996: char *zLockFile = (char *)pFile->lockingContext;
1997: int rc;
1998:
1999: assert( pFile );
2000: OSTRACE(("UNLOCK %d %d was %d pid=%d (dotlock)\n", pFile->h, eFileLock,
2001: pFile->eFileLock, getpid()));
2002: assert( eFileLock<=SHARED_LOCK );
2003:
2004: /* no-op if possible */
2005: if( pFile->eFileLock==eFileLock ){
2006: return SQLITE_OK;
2007: }
2008:
2009: /* To downgrade to shared, simply update our internal notion of the
2010: ** lock state. No need to mess with the file on disk.
2011: */
2012: if( eFileLock==SHARED_LOCK ){
2013: pFile->eFileLock = SHARED_LOCK;
2014: return SQLITE_OK;
2015: }
2016:
2017: /* To fully unlock the database, delete the lock file */
2018: assert( eFileLock==NO_LOCK );
2019: rc = osRmdir(zLockFile);
2020: if( rc<0 && errno==ENOTDIR ) rc = osUnlink(zLockFile);
2021: if( rc<0 ){
2022: int tErrno = errno;
2023: rc = 0;
2024: if( ENOENT != tErrno ){
2025: rc = SQLITE_IOERR_UNLOCK;
2026: }
2027: if( IS_LOCK_ERROR(rc) ){
2028: pFile->lastErrno = tErrno;
2029: }
2030: return rc;
2031: }
2032: pFile->eFileLock = NO_LOCK;
2033: return SQLITE_OK;
2034: }
2035:
2036: /*
2037: ** Close a file. Make sure the lock has been released before closing.
2038: */
2039: static int dotlockClose(sqlite3_file *id) {
2040: int rc;
2041: if( id ){
2042: unixFile *pFile = (unixFile*)id;
2043: dotlockUnlock(id, NO_LOCK);
2044: sqlite3_free(pFile->lockingContext);
2045: }
2046: rc = closeUnixFile(id);
2047: return rc;
2048: }
2049: /****************** End of the dot-file lock implementation *******************
2050: ******************************************************************************/
2051:
2052: /******************************************************************************
2053: ************************** Begin flock Locking ********************************
2054: **
2055: ** Use the flock() system call to do file locking.
2056: **
2057: ** flock() locking is like dot-file locking in that the various
2058: ** fine-grain locking levels supported by SQLite are collapsed into
2059: ** a single exclusive lock. In other words, SHARED, RESERVED, and
2060: ** PENDING locks are the same thing as an EXCLUSIVE lock. SQLite
2061: ** still works when you do this, but concurrency is reduced since
2062: ** only a single process can be reading the database at a time.
2063: **
2064: ** Omit this section if SQLITE_ENABLE_LOCKING_STYLE is turned off or if
2065: ** compiling for VXWORKS.
2066: */
2067: #if SQLITE_ENABLE_LOCKING_STYLE && !OS_VXWORKS
2068:
2069: /*
2070: ** Retry flock() calls that fail with EINTR
2071: */
2072: #ifdef EINTR
2073: static int robust_flock(int fd, int op){
2074: int rc;
2075: do{ rc = flock(fd,op); }while( rc<0 && errno==EINTR );
2076: return rc;
2077: }
2078: #else
2079: # define robust_flock(a,b) flock(a,b)
2080: #endif
2081:
2082:
2083: /*
2084: ** This routine checks if there is a RESERVED lock held on the specified
2085: ** file by this or any other process. If such a lock is held, set *pResOut
2086: ** to a non-zero value otherwise *pResOut is set to zero. The return value
2087: ** is set to SQLITE_OK unless an I/O error occurs during lock checking.
2088: */
2089: static int flockCheckReservedLock(sqlite3_file *id, int *pResOut){
2090: int rc = SQLITE_OK;
2091: int reserved = 0;
2092: unixFile *pFile = (unixFile*)id;
2093:
2094: SimulateIOError( return SQLITE_IOERR_CHECKRESERVEDLOCK; );
2095:
2096: assert( pFile );
2097:
2098: /* Check if a thread in this process holds such a lock */
2099: if( pFile->eFileLock>SHARED_LOCK ){
2100: reserved = 1;
2101: }
2102:
2103: /* Otherwise see if some other process holds it. */
2104: if( !reserved ){
2105: /* attempt to get the lock */
2106: int lrc = robust_flock(pFile->h, LOCK_EX | LOCK_NB);
2107: if( !lrc ){
2108: /* got the lock, unlock it */
2109: lrc = robust_flock(pFile->h, LOCK_UN);
2110: if ( lrc ) {
2111: int tErrno = errno;
2112: /* unlock failed with an error */
2113: lrc = SQLITE_IOERR_UNLOCK;
2114: if( IS_LOCK_ERROR(lrc) ){
2115: pFile->lastErrno = tErrno;
2116: rc = lrc;
2117: }
2118: }
2119: } else {
2120: int tErrno = errno;
2121: reserved = 1;
2122: /* someone else might have it reserved */
2123: lrc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK);
2124: if( IS_LOCK_ERROR(lrc) ){
2125: pFile->lastErrno = tErrno;
2126: rc = lrc;
2127: }
2128: }
2129: }
2130: OSTRACE(("TEST WR-LOCK %d %d %d (flock)\n", pFile->h, rc, reserved));
2131:
2132: #ifdef SQLITE_IGNORE_FLOCK_LOCK_ERRORS
2133: if( (rc & SQLITE_IOERR) == SQLITE_IOERR ){
2134: rc = SQLITE_OK;
2135: reserved=1;
2136: }
2137: #endif /* SQLITE_IGNORE_FLOCK_LOCK_ERRORS */
2138: *pResOut = reserved;
2139: return rc;
2140: }
2141:
2142: /*
2143: ** Lock the file with the lock specified by parameter eFileLock - one
2144: ** of the following:
2145: **
2146: ** (1) SHARED_LOCK
2147: ** (2) RESERVED_LOCK
2148: ** (3) PENDING_LOCK
2149: ** (4) EXCLUSIVE_LOCK
2150: **
2151: ** Sometimes when requesting one lock state, additional lock states
2152: ** are inserted in between. The locking might fail on one of the later
2153: ** transitions leaving the lock state different from what it started but
2154: ** still short of its goal. The following chart shows the allowed
2155: ** transitions and the inserted intermediate states:
2156: **
2157: ** UNLOCKED -> SHARED
2158: ** SHARED -> RESERVED
2159: ** SHARED -> (PENDING) -> EXCLUSIVE
2160: ** RESERVED -> (PENDING) -> EXCLUSIVE
2161: ** PENDING -> EXCLUSIVE
2162: **
2163: ** flock() only really support EXCLUSIVE locks. We track intermediate
2164: ** lock states in the sqlite3_file structure, but all locks SHARED or
2165: ** above are really EXCLUSIVE locks and exclude all other processes from
2166: ** access the file.
2167: **
2168: ** This routine will only increase a lock. Use the sqlite3OsUnlock()
2169: ** routine to lower a locking level.
2170: */
2171: static int flockLock(sqlite3_file *id, int eFileLock) {
2172: int rc = SQLITE_OK;
2173: unixFile *pFile = (unixFile*)id;
2174:
2175: assert( pFile );
2176:
2177: /* if we already have a lock, it is exclusive.
2178: ** Just adjust level and punt on outta here. */
2179: if (pFile->eFileLock > NO_LOCK) {
2180: pFile->eFileLock = eFileLock;
2181: return SQLITE_OK;
2182: }
2183:
2184: /* grab an exclusive lock */
2185:
2186: if (robust_flock(pFile->h, LOCK_EX | LOCK_NB)) {
2187: int tErrno = errno;
2188: /* didn't get, must be busy */
2189: rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK);
2190: if( IS_LOCK_ERROR(rc) ){
2191: pFile->lastErrno = tErrno;
2192: }
2193: } else {
2194: /* got it, set the type and return ok */
2195: pFile->eFileLock = eFileLock;
2196: }
2197: OSTRACE(("LOCK %d %s %s (flock)\n", pFile->h, azFileLock(eFileLock),
2198: rc==SQLITE_OK ? "ok" : "failed"));
2199: #ifdef SQLITE_IGNORE_FLOCK_LOCK_ERRORS
2200: if( (rc & SQLITE_IOERR) == SQLITE_IOERR ){
2201: rc = SQLITE_BUSY;
2202: }
2203: #endif /* SQLITE_IGNORE_FLOCK_LOCK_ERRORS */
2204: return rc;
2205: }
2206:
2207:
2208: /*
2209: ** Lower the locking level on file descriptor pFile to eFileLock. eFileLock
2210: ** must be either NO_LOCK or SHARED_LOCK.
2211: **
2212: ** If the locking level of the file descriptor is already at or below
2213: ** the requested locking level, this routine is a no-op.
2214: */
2215: static int flockUnlock(sqlite3_file *id, int eFileLock) {
2216: unixFile *pFile = (unixFile*)id;
2217:
2218: assert( pFile );
2219: OSTRACE(("UNLOCK %d %d was %d pid=%d (flock)\n", pFile->h, eFileLock,
2220: pFile->eFileLock, getpid()));
2221: assert( eFileLock<=SHARED_LOCK );
2222:
2223: /* no-op if possible */
2224: if( pFile->eFileLock==eFileLock ){
2225: return SQLITE_OK;
2226: }
2227:
2228: /* shared can just be set because we always have an exclusive */
2229: if (eFileLock==SHARED_LOCK) {
2230: pFile->eFileLock = eFileLock;
2231: return SQLITE_OK;
2232: }
2233:
2234: /* no, really, unlock. */
2235: if( robust_flock(pFile->h, LOCK_UN) ){
2236: #ifdef SQLITE_IGNORE_FLOCK_LOCK_ERRORS
2237: return SQLITE_OK;
2238: #endif /* SQLITE_IGNORE_FLOCK_LOCK_ERRORS */
2239: return SQLITE_IOERR_UNLOCK;
2240: }else{
2241: pFile->eFileLock = NO_LOCK;
2242: return SQLITE_OK;
2243: }
2244: }
2245:
2246: /*
2247: ** Close a file.
2248: */
2249: static int flockClose(sqlite3_file *id) {
2250: if( id ){
2251: flockUnlock(id, NO_LOCK);
2252: }
2253: return closeUnixFile(id);
2254: }
2255:
2256: #endif /* SQLITE_ENABLE_LOCKING_STYLE && !OS_VXWORK */
2257:
2258: /******************* End of the flock lock implementation *********************
2259: ******************************************************************************/
2260:
2261: /******************************************************************************
2262: ************************ Begin Named Semaphore Locking ************************
2263: **
2264: ** Named semaphore locking is only supported on VxWorks.
2265: **
2266: ** Semaphore locking is like dot-lock and flock in that it really only
2267: ** supports EXCLUSIVE locking. Only a single process can read or write
2268: ** the database file at a time. This reduces potential concurrency, but
2269: ** makes the lock implementation much easier.
2270: */
2271: #if OS_VXWORKS
2272:
2273: /*
2274: ** This routine checks if there is a RESERVED lock held on the specified
2275: ** file by this or any other process. If such a lock is held, set *pResOut
2276: ** to a non-zero value otherwise *pResOut is set to zero. The return value
2277: ** is set to SQLITE_OK unless an I/O error occurs during lock checking.
2278: */
2279: static int semCheckReservedLock(sqlite3_file *id, int *pResOut) {
2280: int rc = SQLITE_OK;
2281: int reserved = 0;
2282: unixFile *pFile = (unixFile*)id;
2283:
2284: SimulateIOError( return SQLITE_IOERR_CHECKRESERVEDLOCK; );
2285:
2286: assert( pFile );
2287:
2288: /* Check if a thread in this process holds such a lock */
2289: if( pFile->eFileLock>SHARED_LOCK ){
2290: reserved = 1;
2291: }
2292:
2293: /* Otherwise see if some other process holds it. */
2294: if( !reserved ){
2295: sem_t *pSem = pFile->pInode->pSem;
2296: struct stat statBuf;
2297:
2298: if( sem_trywait(pSem)==-1 ){
2299: int tErrno = errno;
2300: if( EAGAIN != tErrno ){
2301: rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_CHECKRESERVEDLOCK);
2302: pFile->lastErrno = tErrno;
2303: } else {
2304: /* someone else has the lock when we are in NO_LOCK */
2305: reserved = (pFile->eFileLock < SHARED_LOCK);
2306: }
2307: }else{
2308: /* we could have it if we want it */
2309: sem_post(pSem);
2310: }
2311: }
2312: OSTRACE(("TEST WR-LOCK %d %d %d (sem)\n", pFile->h, rc, reserved));
2313:
2314: *pResOut = reserved;
2315: return rc;
2316: }
2317:
2318: /*
2319: ** Lock the file with the lock specified by parameter eFileLock - one
2320: ** of the following:
2321: **
2322: ** (1) SHARED_LOCK
2323: ** (2) RESERVED_LOCK
2324: ** (3) PENDING_LOCK
2325: ** (4) EXCLUSIVE_LOCK
2326: **
2327: ** Sometimes when requesting one lock state, additional lock states
2328: ** are inserted in between. The locking might fail on one of the later
2329: ** transitions leaving the lock state different from what it started but
2330: ** still short of its goal. The following chart shows the allowed
2331: ** transitions and the inserted intermediate states:
2332: **
2333: ** UNLOCKED -> SHARED
2334: ** SHARED -> RESERVED
2335: ** SHARED -> (PENDING) -> EXCLUSIVE
2336: ** RESERVED -> (PENDING) -> EXCLUSIVE
2337: ** PENDING -> EXCLUSIVE
2338: **
2339: ** Semaphore locks only really support EXCLUSIVE locks. We track intermediate
2340: ** lock states in the sqlite3_file structure, but all locks SHARED or
2341: ** above are really EXCLUSIVE locks and exclude all other processes from
2342: ** access the file.
2343: **
2344: ** This routine will only increase a lock. Use the sqlite3OsUnlock()
2345: ** routine to lower a locking level.
2346: */
2347: static int semLock(sqlite3_file *id, int eFileLock) {
2348: unixFile *pFile = (unixFile*)id;
2349: int fd;
2350: sem_t *pSem = pFile->pInode->pSem;
2351: int rc = SQLITE_OK;
2352:
2353: /* if we already have a lock, it is exclusive.
2354: ** Just adjust level and punt on outta here. */
2355: if (pFile->eFileLock > NO_LOCK) {
2356: pFile->eFileLock = eFileLock;
2357: rc = SQLITE_OK;
2358: goto sem_end_lock;
2359: }
2360:
2361: /* lock semaphore now but bail out when already locked. */
2362: if( sem_trywait(pSem)==-1 ){
2363: rc = SQLITE_BUSY;
2364: goto sem_end_lock;
2365: }
2366:
2367: /* got it, set the type and return ok */
2368: pFile->eFileLock = eFileLock;
2369:
2370: sem_end_lock:
2371: return rc;
2372: }
2373:
2374: /*
2375: ** Lower the locking level on file descriptor pFile to eFileLock. eFileLock
2376: ** must be either NO_LOCK or SHARED_LOCK.
2377: **
2378: ** If the locking level of the file descriptor is already at or below
2379: ** the requested locking level, this routine is a no-op.
2380: */
2381: static int semUnlock(sqlite3_file *id, int eFileLock) {
2382: unixFile *pFile = (unixFile*)id;
2383: sem_t *pSem = pFile->pInode->pSem;
2384:
2385: assert( pFile );
2386: assert( pSem );
2387: OSTRACE(("UNLOCK %d %d was %d pid=%d (sem)\n", pFile->h, eFileLock,
2388: pFile->eFileLock, getpid()));
2389: assert( eFileLock<=SHARED_LOCK );
2390:
2391: /* no-op if possible */
2392: if( pFile->eFileLock==eFileLock ){
2393: return SQLITE_OK;
2394: }
2395:
2396: /* shared can just be set because we always have an exclusive */
2397: if (eFileLock==SHARED_LOCK) {
2398: pFile->eFileLock = eFileLock;
2399: return SQLITE_OK;
2400: }
2401:
2402: /* no, really unlock. */
2403: if ( sem_post(pSem)==-1 ) {
2404: int rc, tErrno = errno;
2405: rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_UNLOCK);
2406: if( IS_LOCK_ERROR(rc) ){
2407: pFile->lastErrno = tErrno;
2408: }
2409: return rc;
2410: }
2411: pFile->eFileLock = NO_LOCK;
2412: return SQLITE_OK;
2413: }
2414:
2415: /*
2416: ** Close a file.
2417: */
2418: static int semClose(sqlite3_file *id) {
2419: if( id ){
2420: unixFile *pFile = (unixFile*)id;
2421: semUnlock(id, NO_LOCK);
2422: assert( pFile );
2423: unixEnterMutex();
2424: releaseInodeInfo(pFile);
2425: unixLeaveMutex();
2426: closeUnixFile(id);
2427: }
2428: return SQLITE_OK;
2429: }
2430:
2431: #endif /* OS_VXWORKS */
2432: /*
2433: ** Named semaphore locking is only available on VxWorks.
2434: **
2435: *************** End of the named semaphore lock implementation ****************
2436: ******************************************************************************/
2437:
2438:
2439: /******************************************************************************
2440: *************************** Begin AFP Locking *********************************
2441: **
2442: ** AFP is the Apple Filing Protocol. AFP is a network filesystem found
2443: ** on Apple Macintosh computers - both OS9 and OSX.
2444: **
2445: ** Third-party implementations of AFP are available. But this code here
2446: ** only works on OSX.
2447: */
2448:
2449: #if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE
2450: /*
2451: ** The afpLockingContext structure contains all afp lock specific state
2452: */
2453: typedef struct afpLockingContext afpLockingContext;
2454: struct afpLockingContext {
2455: int reserved;
2456: const char *dbPath; /* Name of the open file */
2457: };
2458:
2459: struct ByteRangeLockPB2
2460: {
2461: unsigned long long offset; /* offset to first byte to lock */
2462: unsigned long long length; /* nbr of bytes to lock */
2463: unsigned long long retRangeStart; /* nbr of 1st byte locked if successful */
2464: unsigned char unLockFlag; /* 1 = unlock, 0 = lock */
2465: unsigned char startEndFlag; /* 1=rel to end of fork, 0=rel to start */
2466: int fd; /* file desc to assoc this lock with */
2467: };
2468:
2469: #define afpfsByteRangeLock2FSCTL _IOWR('z', 23, struct ByteRangeLockPB2)
2470:
2471: /*
2472: ** This is a utility for setting or clearing a bit-range lock on an
2473: ** AFP filesystem.
2474: **
2475: ** Return SQLITE_OK on success, SQLITE_BUSY on failure.
2476: */
2477: static int afpSetLock(
2478: const char *path, /* Name of the file to be locked or unlocked */
2479: unixFile *pFile, /* Open file descriptor on path */
2480: unsigned long long offset, /* First byte to be locked */
2481: unsigned long long length, /* Number of bytes to lock */
2482: int setLockFlag /* True to set lock. False to clear lock */
2483: ){
2484: struct ByteRangeLockPB2 pb;
2485: int err;
2486:
2487: pb.unLockFlag = setLockFlag ? 0 : 1;
2488: pb.startEndFlag = 0;
2489: pb.offset = offset;
2490: pb.length = length;
2491: pb.fd = pFile->h;
2492:
2493: OSTRACE(("AFPSETLOCK [%s] for %d%s in range %llx:%llx\n",
2494: (setLockFlag?"ON":"OFF"), pFile->h, (pb.fd==-1?"[testval-1]":""),
2495: offset, length));
2496: err = fsctl(path, afpfsByteRangeLock2FSCTL, &pb, 0);
2497: if ( err==-1 ) {
2498: int rc;
2499: int tErrno = errno;
2500: OSTRACE(("AFPSETLOCK failed to fsctl() '%s' %d %s\n",
2501: path, tErrno, strerror(tErrno)));
2502: #ifdef SQLITE_IGNORE_AFP_LOCK_ERRORS
2503: rc = SQLITE_BUSY;
2504: #else
2505: rc = sqliteErrorFromPosixError(tErrno,
2506: setLockFlag ? SQLITE_IOERR_LOCK : SQLITE_IOERR_UNLOCK);
2507: #endif /* SQLITE_IGNORE_AFP_LOCK_ERRORS */
2508: if( IS_LOCK_ERROR(rc) ){
2509: pFile->lastErrno = tErrno;
2510: }
2511: return rc;
2512: } else {
2513: return SQLITE_OK;
2514: }
2515: }
2516:
2517: /*
2518: ** This routine checks if there is a RESERVED lock held on the specified
2519: ** file by this or any other process. If such a lock is held, set *pResOut
2520: ** to a non-zero value otherwise *pResOut is set to zero. The return value
2521: ** is set to SQLITE_OK unless an I/O error occurs during lock checking.
2522: */
2523: static int afpCheckReservedLock(sqlite3_file *id, int *pResOut){
2524: int rc = SQLITE_OK;
2525: int reserved = 0;
2526: unixFile *pFile = (unixFile*)id;
2527: afpLockingContext *context;
2528:
2529: SimulateIOError( return SQLITE_IOERR_CHECKRESERVEDLOCK; );
2530:
2531: assert( pFile );
2532: context = (afpLockingContext *) pFile->lockingContext;
2533: if( context->reserved ){
2534: *pResOut = 1;
2535: return SQLITE_OK;
2536: }
2537: unixEnterMutex(); /* Because pFile->pInode is shared across threads */
2538:
2539: /* Check if a thread in this process holds such a lock */
2540: if( pFile->pInode->eFileLock>SHARED_LOCK ){
2541: reserved = 1;
2542: }
2543:
2544: /* Otherwise see if some other process holds it.
2545: */
2546: if( !reserved ){
2547: /* lock the RESERVED byte */
2548: int lrc = afpSetLock(context->dbPath, pFile, RESERVED_BYTE, 1,1);
2549: if( SQLITE_OK==lrc ){
2550: /* if we succeeded in taking the reserved lock, unlock it to restore
2551: ** the original state */
2552: lrc = afpSetLock(context->dbPath, pFile, RESERVED_BYTE, 1, 0);
2553: } 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;
2559: }
2560: }
2561:
2562: unixLeaveMutex();
2563: OSTRACE(("TEST WR-LOCK %d %d %d (afp)\n", pFile->h, rc, reserved));
2564:
2565: *pResOut = reserved;
2566: return rc;
2567: }
2568:
2569: /*
2570: ** Lock the file with the lock specified by parameter eFileLock - one
2571: ** 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: */
2593: static int afpLock(sqlite3_file *id, int eFileLock){
2594: int rc = SQLITE_OK;
2595: unixFile *pFile = (unixFile*)id;
2596: unixInodeInfo *pInode = pFile->pInode;
2597: afpLockingContext *context = (afpLockingContext *) pFile->lockingContext;
2598:
2599: assert( pFile );
2600: OSTRACE(("LOCK %d %s was %s(%s,%d) pid=%d (afp)\n", pFile->h,
2601: azFileLock(eFileLock), azFileLock(pFile->eFileLock),
2602: azFileLock(pInode->eFileLock), pInode->nShared , getpid()));
2603:
2604: /* If there is already a lock of this type or more restrictive on the
2605: ** unixFile, do nothing. Don't use the afp_end_lock: exit path, as
2606: ** unixEnterMutex() hasn't been called yet.
2607: */
2608: if( pFile->eFileLock>=eFileLock ){
2609: OSTRACE(("LOCK %d %s ok (already held) (afp)\n", pFile->h,
2610: azFileLock(eFileLock)));
2611: return SQLITE_OK;
2612: }
2613:
2614: /* Make sure the locking sequence is correct
2615: ** (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.
2618: */
2619: assert( pFile->eFileLock!=NO_LOCK || eFileLock==SHARED_LOCK );
2620: assert( eFileLock!=PENDING_LOCK );
2621: assert( eFileLock!=RESERVED_LOCK || pFile->eFileLock==SHARED_LOCK );
2622:
2623: /* This mutex is needed because pFile->pInode is shared across threads
2624: */
2625: unixEnterMutex();
2626: pInode = pFile->pInode;
2627:
2628: /* If some thread using this PID has a lock via a different unixFile*
2629: ** handle that precludes the requested lock, return BUSY.
2630: */
2631: if( (pFile->eFileLock!=pInode->eFileLock &&
2632: (pInode->eFileLock>=PENDING_LOCK || eFileLock>SHARED_LOCK))
2633: ){
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: */
2642: if( eFileLock==SHARED_LOCK &&
2643: (pInode->eFileLock==SHARED_LOCK || pInode->eFileLock==RESERVED_LOCK) ){
2644: assert( eFileLock==SHARED_LOCK );
2645: assert( pFile->eFileLock==0 );
2646: assert( pInode->nShared>0 );
2647: pFile->eFileLock = SHARED_LOCK;
2648: pInode->nShared++;
2649: pInode->nLock++;
2650: goto afp_end_lock;
2651: }
2652:
2653: /* A PENDING lock is needed before acquiring a SHARED lock and before
2654: ** acquiring an EXCLUSIVE lock. For the SHARED lock, the PENDING will
2655: ** be released.
2656: */
2657: if( eFileLock==SHARED_LOCK
2658: || (eFileLock==EXCLUSIVE_LOCK && pFile->eFileLock<PENDING_LOCK)
2659: ){
2660: int failed;
2661: failed = afpSetLock(context->dbPath, pFile, PENDING_BYTE, 1, 1);
2662: if (failed) {
2663: rc = failed;
2664: goto afp_end_lock;
2665: }
2666: }
2667:
2668: /* If control gets to this point, then actually go ahead and make
2669: ** operating system calls for the specified lock.
2670: */
2671: if( eFileLock==SHARED_LOCK ){
2672: int lrc1, lrc2, lrc1Errno = 0;
2673: long lk, mask;
2674:
2675: assert( pInode->nShared==0 );
2676: assert( pInode->eFileLock==0 );
2677:
2678: mask = (sizeof(long)==8) ? LARGEST_INT64 : 0x7fffffff;
2679: /* Now get the read-lock SHARED_LOCK */
2680: /* note that the quality of the randomness doesn't matter that much */
2681: lk = random();
2682: pInode->sharedByte = (lk & mask)%(SHARED_SIZE - 1);
2683: lrc1 = afpSetLock(context->dbPath, pFile,
2684: SHARED_FIRST+pInode->sharedByte, 1, 1);
2685: if( IS_LOCK_ERROR(lrc1) ){
2686: lrc1Errno = pFile->lastErrno;
2687: }
2688: /* Drop the temporary PENDING lock */
2689: lrc2 = afpSetLock(context->dbPath, pFile, PENDING_BYTE, 1, 0);
2690:
2691: 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;
2700: } else {
2701: pFile->eFileLock = SHARED_LOCK;
2702: pInode->nLock++;
2703: pInode->nShared = 1;
2704: }
2705: }else if( eFileLock==EXCLUSIVE_LOCK && pInode->nShared>1 ){
2706: /* 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;
2709: }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;
2715: assert( 0!=pFile->eFileLock );
2716: if (eFileLock >= RESERVED_LOCK && pFile->eFileLock < RESERVED_LOCK) {
2717: /* Acquire a RESERVED lock */
2718: failed = afpSetLock(context->dbPath, pFile, RESERVED_BYTE, 1,1);
2719: if( !failed ){
2720: context->reserved = 1;
2721: }
2722: }
2723: if (!failed && eFileLock == EXCLUSIVE_LOCK) {
2724: /* Acquire an EXCLUSIVE lock */
2725:
2726: /* Remove the shared lock before trying the range. we'll need to
2727: ** reestablish the shared lock if we can't get the afpUnlock
2728: */
2729: if( !(failed = afpSetLock(context->dbPath, pFile, SHARED_FIRST +
2730: pInode->sharedByte, 1, 0)) ){
2731: int failed2 = SQLITE_OK;
2732: /* now attemmpt to get the exclusive lock range */
2733: failed = afpSetLock(context->dbPath, pFile, SHARED_FIRST,
2734: SHARED_SIZE, 1);
2735: if( failed && (failed2 = afpSetLock(context->dbPath, pFile,
2736: SHARED_FIRST + pInode->sharedByte, 1, 1)) ){
2737: /* 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{
2745: rc = failed;
2746: }
2747: }
2748: if( failed ){
2749: rc = failed;
2750: }
2751: }
2752:
2753: if( rc==SQLITE_OK ){
2754: pFile->eFileLock = eFileLock;
2755: pInode->eFileLock = eFileLock;
2756: }else if( eFileLock==EXCLUSIVE_LOCK ){
2757: pFile->eFileLock = PENDING_LOCK;
2758: pInode->eFileLock = PENDING_LOCK;
2759: }
2760:
2761: afp_end_lock:
2762: unixLeaveMutex();
2763: OSTRACE(("LOCK %d %s %s (afp)\n", pFile->h, azFileLock(eFileLock),
2764: rc==SQLITE_OK ? "ok" : "failed"));
2765: return rc;
2766: }
2767:
2768: /*
2769: ** Lower the locking level on file descriptor pFile to eFileLock. eFileLock
2770: ** 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: */
2775: static int afpUnlock(sqlite3_file *id, int eFileLock) {
2776: int rc = SQLITE_OK;
2777: unixFile *pFile = (unixFile*)id;
2778: unixInodeInfo *pInode;
2779: afpLockingContext *context = (afpLockingContext *) pFile->lockingContext;
2780: int skipShared = 0;
2781: #ifdef SQLITE_TEST
2782: int h = pFile->h;
2783: #endif
2784:
2785: assert( pFile );
2786: OSTRACE(("UNLOCK %d %d was %d(%d,%d) pid=%d (afp)\n", pFile->h, eFileLock,
2787: pFile->eFileLock, pFile->pInode->eFileLock, pFile->pInode->nShared,
2788: getpid()));
2789:
2790: assert( eFileLock<=SHARED_LOCK );
2791: if( pFile->eFileLock<=eFileLock ){
2792: return SQLITE_OK;
2793: }
2794: unixEnterMutex();
2795: pInode = pFile->pInode;
2796: assert( pInode->nShared!=0 );
2797: if( pFile->eFileLock>SHARED_LOCK ){
2798: assert( pInode->eFileLock==pFile->eFileLock );
2799: 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
2817:
2818: if( pFile->eFileLock==EXCLUSIVE_LOCK ){
2819: rc = afpSetLock(context->dbPath, pFile, SHARED_FIRST, SHARED_SIZE, 0);
2820: if( rc==SQLITE_OK && (eFileLock==SHARED_LOCK || pInode->nShared>1) ){
2821: /* only re-establish the shared lock if necessary */
2822: int sharedLockByte = SHARED_FIRST+pInode->sharedByte;
2823: rc = afpSetLock(context->dbPath, pFile, sharedLockByte, 1, 1);
2824: } else {
2825: skipShared = 1;
2826: }
2827: }
2828: if( rc==SQLITE_OK && pFile->eFileLock>=PENDING_LOCK ){
2829: rc = afpSetLock(context->dbPath, pFile, PENDING_BYTE, 1, 0);
2830: }
2831: if( rc==SQLITE_OK && pFile->eFileLock>=RESERVED_LOCK && context->reserved ){
2832: rc = afpSetLock(context->dbPath, pFile, RESERVED_BYTE, 1, 0);
2833: if( !rc ){
2834: context->reserved = 0;
2835: }
2836: }
2837: if( rc==SQLITE_OK && (eFileLock==SHARED_LOCK || pInode->nShared>1)){
2838: pInode->eFileLock = SHARED_LOCK;
2839: }
2840: }
2841: if( rc==SQLITE_OK && eFileLock==NO_LOCK ){
2842:
2843: /* 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: */
2847: unsigned long long sharedLockByte = SHARED_FIRST+pInode->sharedByte;
2848: pInode->nShared--;
2849: if( pInode->nShared==0 ){
2850: 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 ){
2857: pInode->eFileLock = NO_LOCK;
2858: pFile->eFileLock = NO_LOCK;
2859: }
2860: }
2861: if( rc==SQLITE_OK ){
2862: pInode->nLock--;
2863: assert( pInode->nLock>=0 );
2864: if( pInode->nLock==0 ){
2865: closePendingFds(pFile);
2866: }
2867: }
2868: }
2869:
2870: unixLeaveMutex();
2871: if( rc==SQLITE_OK ) pFile->eFileLock = eFileLock;
2872: return rc;
2873: }
2874:
2875: /*
2876: ** Close a file & cleanup AFP specific locking context
2877: */
2878: static int afpClose(sqlite3_file *id) {
2879: int rc = SQLITE_OK;
2880: if( id ){
2881: unixFile *pFile = (unixFile*)id;
2882: afpUnlock(id, NO_LOCK);
2883: unixEnterMutex();
2884: if( pFile->pInode && pFile->pInode->nLock ){
2885: /* If there are outstanding locks, do not actually close the file just
2886: ** yet because that would clear those locks. Instead, add the file
2887: ** descriptor to pInode->aPending. It will be automatically closed when
2888: ** the last lock is cleared.
2889: */
2890: setPendingFd(pFile);
2891: }
2892: releaseInodeInfo(pFile);
2893: sqlite3_free(pFile->lockingContext);
2894: rc = closeUnixFile(id);
2895: unixLeaveMutex();
2896: }
2897: return rc;
2898: }
2899:
2900: #endif /* defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE */
2901: /*
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: ******************************************************************************/
2909:
2910: /******************************************************************************
2911: *************************** Begin NFS Locking ********************************/
2912:
2913: #if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE
2914: /*
2915: ** Lower the locking level on file descriptor pFile to eFileLock. eFileLock
2916: ** 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: */
2921: static int nfsUnlock(sqlite3_file *id, int eFileLock){
2922: return posixUnlock(id, eFileLock, 1);
2923: }
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: ******************************************************************************/
2933:
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: */
2943:
2944: /*
2945: ** 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.
2956: */
2957: static int seekAndRead(unixFile *id, sqlite3_int64 offset, void *pBuf, int cnt){
2958: int got;
2959: int prior = 0;
2960: #if (!defined(USE_PREAD) && !defined(USE_PREAD64))
2961: i64 newOffset;
2962: #endif
2963: TIMER_START;
2964: do{
2965: #if defined(USE_PREAD)
2966: got = osPread(id->h, pBuf, cnt, offset);
2967: SimulateIOError( got = -1 );
2968: #elif defined(USE_PREAD64)
2969: got = osPread64(id->h, pBuf, cnt, offset);
2970: SimulateIOError( got = -1 );
2971: #else
2972: newOffset = lseek(id->h, offset, SEEK_SET);
2973: SimulateIOError( newOffset-- );
2974: if( newOffset!=offset ){
2975: if( newOffset == -1 ){
2976: ((unixFile*)id)->lastErrno = errno;
2977: }else{
2978: ((unixFile*)id)->lastErrno = 0;
2979: }
2980: return -1;
2981: }
2982: got = osRead(id->h, pBuf, cnt);
2983: #endif
2984: if( got==cnt ) break;
2985: if( got<0 ){
2986: if( errno==EINTR ){ got = 1; continue; }
2987: prior = 0;
2988: ((unixFile*)id)->lastErrno = errno;
2989: break;
2990: }else if( got>0 ){
2991: cnt -= got;
2992: offset += got;
2993: prior += got;
2994: pBuf = (void*)(got + (char*)pBuf);
2995: }
2996: }while( got>0 );
2997: TIMER_END;
2998: OSTRACE(("READ %-3d %5d %7lld %llu\n",
2999: id->h, got+prior, offset-prior, TIMER_ELAPSED));
3000: return got+prior;
3001: }
3002:
3003: /*
3004: ** Read data from a file into a buffer. Return SQLITE_OK if all
3005: ** bytes were read successfully and SQLITE_IOERR if anything goes
3006: ** wrong.
3007: */
3008: static int unixRead(
3009: sqlite3_file *id,
3010: void *pBuf,
3011: int amt,
3012: sqlite3_int64 offset
3013: ){
3014: unixFile *pFile = (unixFile *)id;
3015: int got;
3016: assert( id );
3017:
3018: /* If this is a database file (not a journal, master-journal or temp
3019: ** file), the bytes in the locking range should never be read or written. */
3020: #if 0
3021: assert( pFile->pUnused==0
3022: || offset>=PENDING_BYTE+512
3023: || offset+amt<=PENDING_BYTE
3024: );
3025: #endif
3026:
3027: got = seekAndRead(pFile, offset, pBuf, amt);
3028: if( got==amt ){
3029: return SQLITE_OK;
3030: }else if( got<0 ){
3031: /* lastErrno set by seekAndRead */
3032: return SQLITE_IOERR_READ;
3033: }else{
3034: pFile->lastErrno = 0; /* not a system error */
3035: /* Unread parts of the buffer must be zero-filled */
3036: memset(&((char*)pBuf)[got], 0, amt-got);
3037: return SQLITE_IOERR_SHORT_READ;
3038: }
3039: }
3040:
3041: /*
3042: ** Seek to the offset in id->offset then read cnt bytes into pBuf.
3043: ** Return the number of bytes actually read. Update the offset.
3044: **
3045: ** To avoid stomping the errno value on a failed write the lastErrno value
3046: ** is set before returning.
3047: */
3048: static int seekAndWrite(unixFile *id, i64 offset, const void *pBuf, int cnt){
3049: int got;
3050: #if (!defined(USE_PREAD) && !defined(USE_PREAD64))
3051: i64 newOffset;
3052: #endif
3053: TIMER_START;
3054: #if defined(USE_PREAD)
3055: do{ got = osPwrite(id->h, pBuf, cnt, offset); }while( got<0 && errno==EINTR );
3056: #elif defined(USE_PREAD64)
3057: do{ got = osPwrite64(id->h, pBuf, cnt, offset);}while( got<0 && errno==EINTR);
3058: #else
3059: do{
3060: newOffset = lseek(id->h, offset, SEEK_SET);
3061: SimulateIOError( newOffset-- );
3062: if( newOffset!=offset ){
3063: if( newOffset == -1 ){
3064: ((unixFile*)id)->lastErrno = errno;
3065: }else{
3066: ((unixFile*)id)->lastErrno = 0;
3067: }
3068: return -1;
3069: }
3070: got = osWrite(id->h, pBuf, cnt);
3071: }while( got<0 && errno==EINTR );
3072: #endif
3073: TIMER_END;
3074: if( got<0 ){
3075: ((unixFile*)id)->lastErrno = errno;
3076: }
3077:
3078: OSTRACE(("WRITE %-3d %5d %7lld %llu\n", id->h, got, offset, TIMER_ELAPSED));
3079: return got;
3080: }
3081:
3082:
3083: /*
3084: ** Write data from a buffer into a file. Return SQLITE_OK on success
3085: ** or some other error code on failure.
3086: */
3087: static int unixWrite(
3088: sqlite3_file *id,
3089: const void *pBuf,
3090: int amt,
3091: sqlite3_int64 offset
3092: ){
3093: unixFile *pFile = (unixFile*)id;
3094: int wrote = 0;
3095: assert( id );
3096: assert( amt>0 );
3097:
3098: /* If this is a database file (not a journal, master-journal or temp
3099: ** file), the bytes in the locking range should never be read or written. */
3100: #if 0
3101: assert( pFile->pUnused==0
3102: || offset>=PENDING_BYTE+512
3103: || offset+amt<=PENDING_BYTE
3104: );
3105: #endif
3106:
3107: #ifndef NDEBUG
3108: /* If we are doing a normal write to a database file (as opposed to
3109: ** doing a hot-journal rollback or a write to some file other than a
3110: ** normal database file) then record the fact that the database
3111: ** has changed. If the transaction counter is modified, record that
3112: ** fact too.
3113: */
3114: if( pFile->inNormalWrite ){
3115: pFile->dbUpdate = 1; /* The database has been modified */
3116: if( offset<=24 && offset+amt>=27 ){
3117: int rc;
3118: char oldCntr[4];
3119: SimulateIOErrorBenign(1);
3120: rc = seekAndRead(pFile, 24, oldCntr, 4);
3121: SimulateIOErrorBenign(0);
3122: if( rc!=4 || memcmp(oldCntr, &((char*)pBuf)[24-offset], 4)!=0 ){
3123: pFile->transCntrChng = 1; /* The transaction counter has changed */
3124: }
3125: }
3126: }
3127: #endif
3128:
3129: while( amt>0 && (wrote = seekAndWrite(pFile, offset, pBuf, amt))>0 ){
3130: amt -= wrote;
3131: offset += wrote;
3132: pBuf = &((char*)pBuf)[wrote];
3133: }
3134: SimulateIOError(( wrote=(-1), amt=1 ));
3135: SimulateDiskfullError(( wrote=0, amt=1 ));
3136:
3137: if( amt>0 ){
3138: if( wrote<0 && pFile->lastErrno!=ENOSPC ){
3139: /* lastErrno set by seekAndWrite */
3140: return SQLITE_IOERR_WRITE;
3141: }else{
3142: pFile->lastErrno = 0; /* not a system error */
3143: return SQLITE_FULL;
3144: }
3145: }
3146:
3147: return SQLITE_OK;
3148: }
3149:
3150: #ifdef SQLITE_TEST
3151: /*
3152: ** Count the number of fullsyncs and normal syncs. This is used to test
3153: ** that syncs and fullsyncs are occurring at the right times.
3154: */
3155: int sqlite3_sync_count = 0;
3156: int sqlite3_fullsync_count = 0;
3157: #endif
3158:
3159: /*
3160: ** We do not trust systems to provide a working fdatasync(). Some do.
3161: ** Others do no. To be safe, we will stick with the (slightly slower)
3162: ** fsync(). If you know that your system does support fdatasync() correctly,
3163: ** then simply compile with -Dfdatasync=fdatasync
3164: */
3165: #if !defined(fdatasync)
3166: # define fdatasync fsync
3167: #endif
3168:
3169: /*
3170: ** Define HAVE_FULLFSYNC to 0 or 1 depending on whether or not
3171: ** the F_FULLFSYNC macro is defined. F_FULLFSYNC is currently
3172: ** only available on Mac OS X. But that could change.
3173: */
3174: #ifdef F_FULLFSYNC
3175: # define HAVE_FULLFSYNC 1
3176: #else
3177: # define HAVE_FULLFSYNC 0
3178: #endif
3179:
3180:
3181: /*
3182: ** The fsync() system call does not work as advertised on many
3183: ** unix systems. The following procedure is an attempt to make
3184: ** it work better.
3185: **
3186: ** The SQLITE_NO_SYNC macro disables all fsync()s. This is useful
3187: ** for testing when we want to run through the test suite quickly.
3188: ** You are strongly advised *not* to deploy with SQLITE_NO_SYNC
3189: ** enabled, however, since with SQLITE_NO_SYNC enabled, an OS crash
3190: ** or power failure will likely corrupt the database file.
3191: **
3192: ** SQLite sets the dataOnly flag if the size of the file is unchanged.
3193: ** The idea behind dataOnly is that it should only write the file content
3194: ** to disk, not the inode. We only set dataOnly if the file size is
3195: ** unchanged since the file size is part of the inode. However,
3196: ** Ted Ts'o tells us that fdatasync() will also write the inode if the
3197: ** file size has changed. The only real difference between fdatasync()
3198: ** and fsync(), Ted tells us, is that fdatasync() will not flush the
3199: ** inode if the mtime or owner or other inode attributes have changed.
3200: ** We only care about the file size, not the other file attributes, so
3201: ** as far as SQLite is concerned, an fdatasync() is always adequate.
3202: ** So, we always use fdatasync() if it is available, regardless of
3203: ** the value of the dataOnly flag.
3204: */
3205: static int full_fsync(int fd, int fullSync, int dataOnly){
3206: int rc;
3207:
3208: /* The following "ifdef/elif/else/" block has the same structure as
3209: ** the one below. It is replicated here solely to avoid cluttering
3210: ** up the real code with the UNUSED_PARAMETER() macros.
3211: */
3212: #ifdef SQLITE_NO_SYNC
3213: UNUSED_PARAMETER(fd);
3214: UNUSED_PARAMETER(fullSync);
3215: UNUSED_PARAMETER(dataOnly);
3216: #elif HAVE_FULLFSYNC
3217: UNUSED_PARAMETER(dataOnly);
3218: #else
3219: UNUSED_PARAMETER(fullSync);
3220: UNUSED_PARAMETER(dataOnly);
3221: #endif
3222:
3223: /* Record the number of times that we do a normal fsync() and
3224: ** FULLSYNC. This is used during testing to verify that this procedure
3225: ** gets called with the correct arguments.
3226: */
3227: #ifdef SQLITE_TEST
3228: if( fullSync ) sqlite3_fullsync_count++;
3229: sqlite3_sync_count++;
3230: #endif
3231:
3232: /* If we compiled with the SQLITE_NO_SYNC flag, then syncing is a
3233: ** no-op
3234: */
3235: #ifdef SQLITE_NO_SYNC
3236: rc = SQLITE_OK;
3237: #elif HAVE_FULLFSYNC
3238: if( fullSync ){
3239: rc = osFcntl(fd, F_FULLFSYNC, 0);
3240: }else{
3241: rc = 1;
3242: }
3243: /* If the FULLFSYNC failed, fall back to attempting an fsync().
3244: ** It shouldn't be possible for fullfsync to fail on the local
3245: ** file system (on OSX), so failure indicates that FULLFSYNC
3246: ** isn't supported for this file system. So, attempt an fsync
3247: ** and (for now) ignore the overhead of a superfluous fcntl call.
3248: ** It'd be better to detect fullfsync support once and avoid
3249: ** the fcntl call every time sync is called.
3250: */
3251: if( rc ) rc = fsync(fd);
3252:
3253: #elif defined(__APPLE__)
3254: /* fdatasync() on HFS+ doesn't yet flush the file size if it changed correctly
3255: ** so currently we default to the macro that redefines fdatasync to fsync
3256: */
3257: rc = fsync(fd);
3258: #else
3259: rc = fdatasync(fd);
3260: #if OS_VXWORKS
3261: if( rc==-1 && errno==ENOTSUP ){
3262: rc = fsync(fd);
3263: }
3264: #endif /* OS_VXWORKS */
3265: #endif /* ifdef SQLITE_NO_SYNC elif HAVE_FULLFSYNC */
3266:
3267: if( OS_VXWORKS && rc!= -1 ){
3268: rc = 0;
3269: }
3270: return rc;
3271: }
3272:
3273: /*
3274: ** Open a file descriptor to the directory containing file zFilename.
3275: ** If successful, *pFd is set to the opened file descriptor and
3276: ** SQLITE_OK is returned. If an error occurs, either SQLITE_NOMEM
3277: ** or SQLITE_CANTOPEN is returned and *pFd is set to an undefined
3278: ** value.
3279: **
3280: ** The directory file descriptor is used for only one thing - to
3281: ** fsync() a directory to make sure file creation and deletion events
3282: ** are flushed to disk. Such fsyncs are not needed on newer
3283: ** journaling filesystems, but are required on older filesystems.
3284: **
3285: ** This routine can be overridden using the xSetSysCall interface.
3286: ** The ability to override this routine was added in support of the
3287: ** chromium sandbox. Opening a directory is a security risk (we are
3288: ** told) so making it overrideable allows the chromium sandbox to
3289: ** replace this routine with a harmless no-op. To make this routine
3290: ** a no-op, replace it with a stub that returns SQLITE_OK but leaves
3291: ** *pFd set to a negative number.
3292: **
3293: ** If SQLITE_OK is returned, the caller is responsible for closing
3294: ** the file descriptor *pFd using close().
3295: */
3296: static int openDirectory(const char *zFilename, int *pFd){
3297: int ii;
3298: int fd = -1;
3299: char zDirname[MAX_PATHNAME+1];
3300:
3301: sqlite3_snprintf(MAX_PATHNAME, zDirname, "%s", zFilename);
3302: for(ii=(int)strlen(zDirname); ii>1 && zDirname[ii]!='/'; ii--);
3303: if( ii>0 ){
3304: zDirname[ii] = '\0';
3305: fd = robust_open(zDirname, O_RDONLY|O_BINARY, 0);
3306: if( fd>=0 ){
3307: #ifdef FD_CLOEXEC
3308: osFcntl(fd, F_SETFD, osFcntl(fd, F_GETFD, 0) | FD_CLOEXEC);
3309: #endif
3310: OSTRACE(("OPENDIR %-3d %s\n", fd, zDirname));
3311: }
3312: }
3313: *pFd = fd;
3314: return (fd>=0?SQLITE_OK:unixLogError(SQLITE_CANTOPEN_BKPT, "open", zDirname));
3315: }
3316:
3317: /*
3318: ** Make sure all writes to a particular file are committed to disk.
3319: **
3320: ** If dataOnly==0 then both the file itself and its metadata (file
3321: ** size, access time, etc) are synced. If dataOnly!=0 then only the
3322: ** file data is synced.
3323: **
3324: ** Under Unix, also make sure that the directory entry for the file
3325: ** has been created by fsync-ing the directory that contains the file.
3326: ** If we do not do this and we encounter a power failure, the directory
3327: ** entry for the journal might not exist after we reboot. The next
3328: ** SQLite to access the file will not know that the journal exists (because
3329: ** the directory entry for the journal was never created) and the transaction
3330: ** will not roll back - possibly leading to database corruption.
3331: */
3332: static int unixSync(sqlite3_file *id, int flags){
3333: int rc;
3334: unixFile *pFile = (unixFile*)id;
3335:
3336: int isDataOnly = (flags&SQLITE_SYNC_DATAONLY);
3337: int isFullsync = (flags&0x0F)==SQLITE_SYNC_FULL;
3338:
3339: /* Check that one of SQLITE_SYNC_NORMAL or FULL was passed */
3340: assert((flags&0x0F)==SQLITE_SYNC_NORMAL
3341: || (flags&0x0F)==SQLITE_SYNC_FULL
3342: );
3343:
3344: /* Unix cannot, but some systems may return SQLITE_FULL from here. This
3345: ** line is to test that doing so does not cause any problems.
3346: */
3347: SimulateDiskfullError( return SQLITE_FULL );
3348:
3349: assert( pFile );
3350: OSTRACE(("SYNC %-3d\n", pFile->h));
3351: rc = full_fsync(pFile->h, isFullsync, isDataOnly);
3352: SimulateIOError( rc=1 );
3353: if( rc ){
3354: pFile->lastErrno = errno;
3355: return unixLogError(SQLITE_IOERR_FSYNC, "full_fsync", pFile->zPath);
3356: }
3357:
3358: /* Also fsync the directory containing the file if the DIRSYNC flag
3359: ** is set. This is a one-time occurrance. Many systems (examples: AIX)
3360: ** are unable to fsync a directory, so ignore errors on the fsync.
3361: */
3362: if( pFile->ctrlFlags & UNIXFILE_DIRSYNC ){
3363: int dirfd;
3364: OSTRACE(("DIRSYNC %s (have_fullfsync=%d fullsync=%d)\n", pFile->zPath,
3365: HAVE_FULLFSYNC, isFullsync));
3366: rc = osOpenDirectory(pFile->zPath, &dirfd);
3367: if( rc==SQLITE_OK && dirfd>=0 ){
3368: full_fsync(dirfd, 0, 0);
3369: robust_close(pFile, dirfd, __LINE__);
3370: }else if( rc==SQLITE_CANTOPEN ){
3371: rc = SQLITE_OK;
3372: }
3373: pFile->ctrlFlags &= ~UNIXFILE_DIRSYNC;
3374: }
3375: return rc;
3376: }
3377:
3378: /*
3379: ** Truncate an open file to a specified size
3380: */
3381: static int unixTruncate(sqlite3_file *id, i64 nByte){
3382: unixFile *pFile = (unixFile *)id;
3383: int rc;
3384: assert( pFile );
3385: SimulateIOError( return SQLITE_IOERR_TRUNCATE );
3386:
3387: /* If the user has configured a chunk-size for this file, truncate the
3388: ** file so that it consists of an integer number of chunks (i.e. the
3389: ** actual file size after the operation may be larger than the requested
3390: ** size).
3391: */
3392: if( pFile->szChunk ){
3393: nByte = ((nByte + pFile->szChunk - 1)/pFile->szChunk) * pFile->szChunk;
3394: }
3395:
3396: rc = robust_ftruncate(pFile->h, (off_t)nByte);
3397: if( rc ){
3398: pFile->lastErrno = errno;
3399: return unixLogError(SQLITE_IOERR_TRUNCATE, "ftruncate", pFile->zPath);
3400: }else{
3401: #ifndef NDEBUG
3402: /* If we are doing a normal write to a database file (as opposed to
3403: ** doing a hot-journal rollback or a write to some file other than a
3404: ** normal database file) and we truncate the file to zero length,
3405: ** that effectively updates the change counter. This might happen
3406: ** when restoring a database using the backup API from a zero-length
3407: ** source.
3408: */
3409: if( pFile->inNormalWrite && nByte==0 ){
3410: pFile->transCntrChng = 1;
3411: }
3412: #endif
3413:
3414: return SQLITE_OK;
3415: }
3416: }
3417:
3418: /*
3419: ** Determine the current size of a file in bytes
3420: */
3421: static int unixFileSize(sqlite3_file *id, i64 *pSize){
3422: int rc;
3423: struct stat buf;
3424: assert( id );
3425: rc = osFstat(((unixFile*)id)->h, &buf);
3426: SimulateIOError( rc=1 );
3427: if( rc!=0 ){
3428: ((unixFile*)id)->lastErrno = errno;
3429: return SQLITE_IOERR_FSTAT;
3430: }
3431: *pSize = buf.st_size;
3432:
3433: /* When opening a zero-size database, the findInodeInfo() procedure
3434: ** writes a single byte into that file in order to work around a bug
3435: ** in the OS-X msdos filesystem. In order to avoid problems with upper
3436: ** layers, we need to report this file size as zero even though it is
3437: ** really 1. Ticket #3260.
3438: */
3439: if( *pSize==1 ) *pSize = 0;
3440:
3441:
3442: return SQLITE_OK;
3443: }
3444:
3445: #if SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__)
3446: /*
3447: ** Handler for proxy-locking file-control verbs. Defined below in the
3448: ** proxying locking division.
3449: */
3450: static int proxyFileControl(sqlite3_file*,int,void*);
3451: #endif
3452:
3453: /*
3454: ** This function is called to handle the SQLITE_FCNTL_SIZE_HINT
3455: ** file-control operation. Enlarge the database to nBytes in size
3456: ** (rounded up to the next chunk-size). If the database is already
3457: ** nBytes or larger, this routine is a no-op.
3458: */
3459: static int fcntlSizeHint(unixFile *pFile, i64 nByte){
3460: if( pFile->szChunk>0 ){
3461: i64 nSize; /* Required file size */
3462: struct stat buf; /* Used to hold return values of fstat() */
3463:
3464: if( osFstat(pFile->h, &buf) ) return SQLITE_IOERR_FSTAT;
3465:
3466: nSize = ((nByte+pFile->szChunk-1) / pFile->szChunk) * pFile->szChunk;
3467: if( nSize>(i64)buf.st_size ){
3468:
3469: #if defined(HAVE_POSIX_FALLOCATE) && HAVE_POSIX_FALLOCATE
3470: /* The code below is handling the return value of osFallocate()
3471: ** correctly. posix_fallocate() is defined to "returns zero on success,
3472: ** or an error number on failure". See the manpage for details. */
3473: int err;
3474: do{
3475: err = osFallocate(pFile->h, buf.st_size, nSize-buf.st_size);
3476: }while( err==EINTR );
3477: if( err ) return SQLITE_IOERR_WRITE;
3478: #else
3479: /* If the OS does not have posix_fallocate(), fake it. First use
3480: ** ftruncate() to set the file size, then write a single byte to
3481: ** the last byte in each block within the extended region. This
3482: ** is the same technique used by glibc to implement posix_fallocate()
3483: ** on systems that do not have a real fallocate() system call.
3484: */
3485: int nBlk = buf.st_blksize; /* File-system block size */
3486: i64 iWrite; /* Next offset to write to */
3487:
3488: if( robust_ftruncate(pFile->h, nSize) ){
3489: pFile->lastErrno = errno;
3490: return unixLogError(SQLITE_IOERR_TRUNCATE, "ftruncate", pFile->zPath);
3491: }
3492: iWrite = ((buf.st_size + 2*nBlk - 1)/nBlk)*nBlk-1;
3493: while( iWrite<nSize ){
3494: int nWrite = seekAndWrite(pFile, iWrite, "", 1);
3495: if( nWrite!=1 ) return SQLITE_IOERR_WRITE;
3496: iWrite += nBlk;
3497: }
3498: #endif
3499: }
3500: }
3501:
3502: return SQLITE_OK;
3503: }
3504:
3505: /*
3506: ** If *pArg is inititially negative then this is a query. Set *pArg to
3507: ** 1 or 0 depending on whether or not bit mask of pFile->ctrlFlags is set.
3508: **
3509: ** If *pArg is 0 or 1, then clear or set the mask bit of pFile->ctrlFlags.
3510: */
3511: static void unixModeBit(unixFile *pFile, unsigned char mask, int *pArg){
3512: if( *pArg<0 ){
3513: *pArg = (pFile->ctrlFlags & mask)!=0;
3514: }else if( (*pArg)==0 ){
3515: pFile->ctrlFlags &= ~mask;
3516: }else{
3517: pFile->ctrlFlags |= mask;
3518: }
3519: }
3520:
3521: /*
3522: ** Information and control of an open file handle.
3523: */
3524: static int unixFileControl(sqlite3_file *id, int op, void *pArg){
3525: unixFile *pFile = (unixFile*)id;
3526: switch( op ){
3527: case SQLITE_FCNTL_LOCKSTATE: {
3528: *(int*)pArg = pFile->eFileLock;
3529: return SQLITE_OK;
3530: }
3531: case SQLITE_LAST_ERRNO: {
3532: *(int*)pArg = pFile->lastErrno;
3533: return SQLITE_OK;
3534: }
3535: case SQLITE_FCNTL_CHUNK_SIZE: {
3536: pFile->szChunk = *(int *)pArg;
3537: return SQLITE_OK;
3538: }
3539: case SQLITE_FCNTL_SIZE_HINT: {
3540: int rc;
3541: SimulateIOErrorBenign(1);
3542: rc = fcntlSizeHint(pFile, *(i64 *)pArg);
3543: SimulateIOErrorBenign(0);
3544: return rc;
3545: }
3546: case SQLITE_FCNTL_PERSIST_WAL: {
3547: unixModeBit(pFile, UNIXFILE_PERSIST_WAL, (int*)pArg);
3548: return SQLITE_OK;
3549: }
3550: case SQLITE_FCNTL_POWERSAFE_OVERWRITE: {
3551: unixModeBit(pFile, UNIXFILE_PSOW, (int*)pArg);
3552: return SQLITE_OK;
3553: }
3554: case SQLITE_FCNTL_VFSNAME: {
3555: *(char**)pArg = sqlite3_mprintf("%s", pFile->pVfs->zName);
3556: return SQLITE_OK;
3557: }
3558: #ifndef NDEBUG
3559: /* The pager calls this method to signal that it has done
3560: ** a rollback and that the database is therefore unchanged and
3561: ** it hence it is OK for the transaction change counter to be
3562: ** unchanged.
3563: */
3564: case SQLITE_FCNTL_DB_UNCHANGED: {
3565: ((unixFile*)id)->dbUpdate = 0;
3566: return SQLITE_OK;
3567: }
3568: #endif
3569: #if SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__)
3570: case SQLITE_SET_LOCKPROXYFILE:
3571: case SQLITE_GET_LOCKPROXYFILE: {
3572: return proxyFileControl(id,op,pArg);
3573: }
3574: #endif /* SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__) */
3575: }
3576: return SQLITE_NOTFOUND;
3577: }
3578:
3579: /*
3580: ** Return the sector size in bytes of the underlying block device for
3581: ** the specified file. This is almost always 512 bytes, but may be
3582: ** larger for some devices.
3583: **
3584: ** SQLite code assumes this function cannot fail. It also assumes that
3585: ** if two files are created in the same file-system directory (i.e.
3586: ** a database and its journal file) that the sector size will be the
3587: ** same for both.
3588: */
3589: static int unixSectorSize(sqlite3_file *pFile){
3590: (void)pFile;
3591: return SQLITE_DEFAULT_SECTOR_SIZE;
3592: }
3593:
3594: /*
3595: ** Return the device characteristics for the file.
3596: **
3597: ** This VFS is set up to return SQLITE_IOCAP_POWERSAFE_OVERWRITE by default.
3598: ** However, that choice is contraversial since technically the underlying
3599: ** file system does not always provide powersafe overwrites. (In other
3600: ** words, after a power-loss event, parts of the file that were never
3601: ** written might end up being altered.) However, non-PSOW behavior is very,
3602: ** very rare. And asserting PSOW makes a large reduction in the amount
3603: ** of required I/O for journaling, since a lot of padding is eliminated.
3604: ** Hence, while POWERSAFE_OVERWRITE is on by default, there is a file-control
3605: ** available to turn it off and URI query parameter available to turn it off.
3606: */
3607: static int unixDeviceCharacteristics(sqlite3_file *id){
3608: unixFile *p = (unixFile*)id;
3609: if( p->ctrlFlags & UNIXFILE_PSOW ){
3610: return SQLITE_IOCAP_POWERSAFE_OVERWRITE;
3611: }else{
3612: return 0;
3613: }
3614: }
3615:
3616: #ifndef SQLITE_OMIT_WAL
3617:
3618:
3619: /*
3620: ** Object used to represent an shared memory buffer.
3621: **
3622: ** When multiple threads all reference the same wal-index, each thread
3623: ** has its own unixShm object, but they all point to a single instance
3624: ** of this unixShmNode object. In other words, each wal-index is opened
3625: ** only once per process.
3626: **
3627: ** Each unixShmNode object is connected to a single unixInodeInfo object.
3628: ** We could coalesce this object into unixInodeInfo, but that would mean
3629: ** every open file that does not use shared memory (in other words, most
3630: ** open files) would have to carry around this extra information. So
3631: ** the unixInodeInfo object contains a pointer to this unixShmNode object
3632: ** and the unixShmNode object is created only when needed.
3633: **
3634: ** unixMutexHeld() must be true when creating or destroying
3635: ** this object or while reading or writing the following fields:
3636: **
3637: ** nRef
3638: **
3639: ** The following fields are read-only after the object is created:
3640: **
3641: ** fid
3642: ** zFilename
3643: **
3644: ** Either unixShmNode.mutex must be held or unixShmNode.nRef==0 and
3645: ** unixMutexHeld() is true when reading or writing any other field
3646: ** in this structure.
3647: */
3648: struct unixShmNode {
3649: unixInodeInfo *pInode; /* unixInodeInfo that owns this SHM node */
3650: sqlite3_mutex *mutex; /* Mutex to access this object */
3651: char *zFilename; /* Name of the mmapped file */
3652: int h; /* Open file descriptor */
3653: int szRegion; /* Size of shared-memory regions */
3654: u16 nRegion; /* Size of array apRegion */
3655: u8 isReadonly; /* True if read-only */
3656: char **apRegion; /* Array of mapped shared-memory regions */
3657: int nRef; /* Number of unixShm objects pointing to this */
3658: unixShm *pFirst; /* All unixShm objects pointing to this */
3659: #ifdef SQLITE_DEBUG
3660: u8 exclMask; /* Mask of exclusive locks held */
3661: u8 sharedMask; /* Mask of shared locks held */
3662: u8 nextShmId; /* Next available unixShm.id value */
3663: #endif
3664: };
3665:
3666: /*
3667: ** Structure used internally by this VFS to record the state of an
3668: ** open shared memory connection.
3669: **
3670: ** The following fields are initialized when this object is created and
3671: ** are read-only thereafter:
3672: **
3673: ** unixShm.pFile
3674: ** unixShm.id
3675: **
3676: ** All other fields are read/write. The unixShm.pFile->mutex must be held
3677: ** while accessing any read/write fields.
3678: */
3679: struct unixShm {
3680: unixShmNode *pShmNode; /* The underlying unixShmNode object */
3681: unixShm *pNext; /* Next unixShm with the same unixShmNode */
3682: u8 hasMutex; /* True if holding the unixShmNode mutex */
3683: u8 id; /* Id of this connection within its unixShmNode */
3684: u16 sharedMask; /* Mask of shared locks held */
3685: u16 exclMask; /* Mask of exclusive locks held */
3686: };
3687:
3688: /*
3689: ** Constants used for locking
3690: */
3691: #define UNIX_SHM_BASE ((22+SQLITE_SHM_NLOCK)*4) /* first lock byte */
3692: #define UNIX_SHM_DMS (UNIX_SHM_BASE+SQLITE_SHM_NLOCK) /* deadman switch */
3693:
3694: /*
3695: ** Apply posix advisory locks for all bytes from ofst through ofst+n-1.
3696: **
3697: ** Locks block if the mask is exactly UNIX_SHM_C and are non-blocking
3698: ** otherwise.
3699: */
3700: static int unixShmSystemLock(
3701: unixShmNode *pShmNode, /* Apply locks to this open shared-memory segment */
3702: int lockType, /* F_UNLCK, F_RDLCK, or F_WRLCK */
3703: int ofst, /* First byte of the locking range */
3704: int n /* Number of bytes to lock */
3705: ){
3706: struct flock f; /* The posix advisory locking structure */
3707: int rc = SQLITE_OK; /* Result code form fcntl() */
3708:
3709: /* Access to the unixShmNode object is serialized by the caller */
3710: assert( sqlite3_mutex_held(pShmNode->mutex) || pShmNode->nRef==0 );
3711:
3712: /* Shared locks never span more than one byte */
3713: assert( n==1 || lockType!=F_RDLCK );
3714:
3715: /* Locks are within range */
3716: assert( n>=1 && n<SQLITE_SHM_NLOCK );
3717:
3718: if( pShmNode->h>=0 ){
3719: /* Initialize the locking parameters */
3720: memset(&f, 0, sizeof(f));
3721: f.l_type = lockType;
3722: f.l_whence = SEEK_SET;
3723: f.l_start = ofst;
3724: f.l_len = n;
3725:
3726: rc = osFcntl(pShmNode->h, F_SETLK, &f);
3727: rc = (rc!=(-1)) ? SQLITE_OK : SQLITE_BUSY;
3728: }
3729:
3730: /* Update the global lock state and do debug tracing */
3731: #ifdef SQLITE_DEBUG
3732: { u16 mask;
3733: OSTRACE(("SHM-LOCK "));
3734: mask = (1<<(ofst+n)) - (1<<ofst);
3735: if( rc==SQLITE_OK ){
3736: if( lockType==F_UNLCK ){
3737: OSTRACE(("unlock %d ok", ofst));
3738: pShmNode->exclMask &= ~mask;
3739: pShmNode->sharedMask &= ~mask;
3740: }else if( lockType==F_RDLCK ){
3741: OSTRACE(("read-lock %d ok", ofst));
3742: pShmNode->exclMask &= ~mask;
3743: pShmNode->sharedMask |= mask;
3744: }else{
3745: assert( lockType==F_WRLCK );
3746: OSTRACE(("write-lock %d ok", ofst));
3747: pShmNode->exclMask |= mask;
3748: pShmNode->sharedMask &= ~mask;
3749: }
3750: }else{
3751: if( lockType==F_UNLCK ){
3752: OSTRACE(("unlock %d failed", ofst));
3753: }else if( lockType==F_RDLCK ){
3754: OSTRACE(("read-lock failed"));
3755: }else{
3756: assert( lockType==F_WRLCK );
3757: OSTRACE(("write-lock %d failed", ofst));
3758: }
3759: }
3760: OSTRACE((" - afterwards %03x,%03x\n",
3761: pShmNode->sharedMask, pShmNode->exclMask));
3762: }
3763: #endif
3764:
3765: return rc;
3766: }
3767:
3768:
3769: /*
3770: ** Purge the unixShmNodeList list of all entries with unixShmNode.nRef==0.
3771: **
3772: ** This is not a VFS shared-memory method; it is a utility function called
3773: ** by VFS shared-memory methods.
3774: */
3775: static void unixShmPurge(unixFile *pFd){
3776: unixShmNode *p = pFd->pInode->pShmNode;
3777: assert( unixMutexHeld() );
3778: if( p && p->nRef==0 ){
3779: int i;
3780: assert( p->pInode==pFd->pInode );
3781: sqlite3_mutex_free(p->mutex);
3782: for(i=0; i<p->nRegion; i++){
3783: if( p->h>=0 ){
3784: munmap(p->apRegion[i], p->szRegion);
3785: }else{
3786: sqlite3_free(p->apRegion[i]);
3787: }
3788: }
3789: sqlite3_free(p->apRegion);
3790: if( p->h>=0 ){
3791: robust_close(pFd, p->h, __LINE__);
3792: p->h = -1;
3793: }
3794: p->pInode->pShmNode = 0;
3795: sqlite3_free(p);
3796: }
3797: }
3798:
3799: /*
3800: ** Open a shared-memory area associated with open database file pDbFd.
3801: ** This particular implementation uses mmapped files.
3802: **
3803: ** The file used to implement shared-memory is in the same directory
3804: ** as the open database file and has the same name as the open database
3805: ** file with the "-shm" suffix added. For example, if the database file
3806: ** is "/home/user1/config.db" then the file that is created and mmapped
3807: ** for shared memory will be called "/home/user1/config.db-shm".
3808: **
3809: ** Another approach to is to use files in /dev/shm or /dev/tmp or an
3810: ** some other tmpfs mount. But if a file in a different directory
3811: ** from the database file is used, then differing access permissions
3812: ** or a chroot() might cause two different processes on the same
3813: ** database to end up using different files for shared memory -
3814: ** meaning that their memory would not really be shared - resulting
3815: ** in database corruption. Nevertheless, this tmpfs file usage
3816: ** can be enabled at compile-time using -DSQLITE_SHM_DIRECTORY="/dev/shm"
3817: ** or the equivalent. The use of the SQLITE_SHM_DIRECTORY compile-time
3818: ** option results in an incompatible build of SQLite; builds of SQLite
3819: ** that with differing SQLITE_SHM_DIRECTORY settings attempt to use the
3820: ** same database file at the same time, database corruption will likely
3821: ** result. The SQLITE_SHM_DIRECTORY compile-time option is considered
3822: ** "unsupported" and may go away in a future SQLite release.
3823: **
3824: ** When opening a new shared-memory file, if no other instances of that
3825: ** file are currently open, in this process or in other processes, then
3826: ** the file must be truncated to zero length or have its header cleared.
3827: **
3828: ** If the original database file (pDbFd) is using the "unix-excl" VFS
3829: ** that means that an exclusive lock is held on the database file and
3830: ** that no other processes are able to read or write the database. In
3831: ** that case, we do not really need shared memory. No shared memory
3832: ** file is created. The shared memory will be simulated with heap memory.
3833: */
3834: static int unixOpenSharedMemory(unixFile *pDbFd){
3835: struct unixShm *p = 0; /* The connection to be opened */
3836: struct unixShmNode *pShmNode; /* The underlying mmapped file */
3837: int rc; /* Result code */
3838: unixInodeInfo *pInode; /* The inode of fd */
3839: char *zShmFilename; /* Name of the file used for SHM */
3840: int nShmFilename; /* Size of the SHM filename in bytes */
3841:
3842: /* Allocate space for the new unixShm object. */
3843: p = sqlite3_malloc( sizeof(*p) );
3844: if( p==0 ) return SQLITE_NOMEM;
3845: memset(p, 0, sizeof(*p));
3846: assert( pDbFd->pShm==0 );
3847:
3848: /* Check to see if a unixShmNode object already exists. Reuse an existing
3849: ** one if present. Create a new one if necessary.
3850: */
3851: unixEnterMutex();
3852: pInode = pDbFd->pInode;
3853: pShmNode = pInode->pShmNode;
3854: if( pShmNode==0 ){
3855: struct stat sStat; /* fstat() info for database file */
3856:
3857: /* Call fstat() to figure out the permissions on the database file. If
3858: ** a new *-shm file is created, an attempt will be made to create it
3859: ** with the same permissions. The actual permissions the file is created
3860: ** with are subject to the current umask setting.
3861: */
3862: if( osFstat(pDbFd->h, &sStat) && pInode->bProcessLock==0 ){
3863: rc = SQLITE_IOERR_FSTAT;
3864: goto shm_open_err;
3865: }
3866:
3867: #ifdef SQLITE_SHM_DIRECTORY
3868: nShmFilename = sizeof(SQLITE_SHM_DIRECTORY) + 31;
3869: #else
3870: nShmFilename = 6 + (int)strlen(pDbFd->zPath);
3871: #endif
3872: pShmNode = sqlite3_malloc( sizeof(*pShmNode) + nShmFilename );
3873: if( pShmNode==0 ){
3874: rc = SQLITE_NOMEM;
3875: goto shm_open_err;
3876: }
3877: memset(pShmNode, 0, sizeof(*pShmNode)+nShmFilename);
3878: zShmFilename = pShmNode->zFilename = (char*)&pShmNode[1];
3879: #ifdef SQLITE_SHM_DIRECTORY
3880: sqlite3_snprintf(nShmFilename, zShmFilename,
3881: SQLITE_SHM_DIRECTORY "/sqlite-shm-%x-%x",
3882: (u32)sStat.st_ino, (u32)sStat.st_dev);
3883: #else
3884: sqlite3_snprintf(nShmFilename, zShmFilename, "%s-shm", pDbFd->zPath);
3885: sqlite3FileSuffix3(pDbFd->zPath, zShmFilename);
3886: #endif
3887: pShmNode->h = -1;
3888: pDbFd->pInode->pShmNode = pShmNode;
3889: pShmNode->pInode = pDbFd->pInode;
3890: pShmNode->mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_FAST);
3891: if( pShmNode->mutex==0 ){
3892: rc = SQLITE_NOMEM;
3893: goto shm_open_err;
3894: }
3895:
3896: if( pInode->bProcessLock==0 ){
3897: int openFlags = O_RDWR | O_CREAT;
3898: if( sqlite3_uri_boolean(pDbFd->zPath, "readonly_shm", 0) ){
3899: openFlags = O_RDONLY;
3900: pShmNode->isReadonly = 1;
3901: }
3902: pShmNode->h = robust_open(zShmFilename, openFlags, (sStat.st_mode&0777));
3903: if( pShmNode->h<0 ){
3904: if( pShmNode->h<0 ){
3905: rc = unixLogError(SQLITE_CANTOPEN_BKPT, "open", zShmFilename);
3906: goto shm_open_err;
3907: }
3908: }
3909:
3910: /* Check to see if another process is holding the dead-man switch.
3911: ** If not, truncate the file to zero length.
3912: */
3913: rc = SQLITE_OK;
3914: if( unixShmSystemLock(pShmNode, F_WRLCK, UNIX_SHM_DMS, 1)==SQLITE_OK ){
3915: if( robust_ftruncate(pShmNode->h, 0) ){
3916: rc = unixLogError(SQLITE_IOERR_SHMOPEN, "ftruncate", zShmFilename);
3917: }
3918: }
3919: if( rc==SQLITE_OK ){
3920: rc = unixShmSystemLock(pShmNode, F_RDLCK, UNIX_SHM_DMS, 1);
3921: }
3922: if( rc ) goto shm_open_err;
3923: }
3924: }
3925:
3926: /* Make the new connection a child of the unixShmNode */
3927: p->pShmNode = pShmNode;
3928: #ifdef SQLITE_DEBUG
3929: p->id = pShmNode->nextShmId++;
3930: #endif
3931: pShmNode->nRef++;
3932: pDbFd->pShm = p;
3933: unixLeaveMutex();
3934:
3935: /* The reference count on pShmNode has already been incremented under
3936: ** the cover of the unixEnterMutex() mutex and the pointer from the
3937: ** new (struct unixShm) object to the pShmNode has been set. All that is
3938: ** left to do is to link the new object into the linked list starting
3939: ** at pShmNode->pFirst. This must be done while holding the pShmNode->mutex
3940: ** mutex.
3941: */
3942: sqlite3_mutex_enter(pShmNode->mutex);
3943: p->pNext = pShmNode->pFirst;
3944: pShmNode->pFirst = p;
3945: sqlite3_mutex_leave(pShmNode->mutex);
3946: return SQLITE_OK;
3947:
3948: /* Jump here on any error */
3949: shm_open_err:
3950: unixShmPurge(pDbFd); /* This call frees pShmNode if required */
3951: sqlite3_free(p);
3952: unixLeaveMutex();
3953: return rc;
3954: }
3955:
3956: /*
3957: ** This function is called to obtain a pointer to region iRegion of the
3958: ** shared-memory associated with the database file fd. Shared-memory regions
3959: ** are numbered starting from zero. Each shared-memory region is szRegion
3960: ** bytes in size.
3961: **
3962: ** If an error occurs, an error code is returned and *pp is set to NULL.
3963: **
3964: ** Otherwise, if the bExtend parameter is 0 and the requested shared-memory
3965: ** region has not been allocated (by any client, including one running in a
3966: ** separate process), then *pp is set to NULL and SQLITE_OK returned. If
3967: ** bExtend is non-zero and the requested shared-memory region has not yet
3968: ** been allocated, it is allocated by this function.
3969: **
3970: ** If the shared-memory region has already been allocated or is allocated by
3971: ** this call as described above, then it is mapped into this processes
3972: ** address space (if it is not already), *pp is set to point to the mapped
3973: ** memory and SQLITE_OK returned.
3974: */
3975: static int unixShmMap(
3976: sqlite3_file *fd, /* Handle open on database file */
3977: int iRegion, /* Region to retrieve */
3978: int szRegion, /* Size of regions */
3979: int bExtend, /* True to extend file if necessary */
3980: void volatile **pp /* OUT: Mapped memory */
3981: ){
3982: unixFile *pDbFd = (unixFile*)fd;
3983: unixShm *p;
3984: unixShmNode *pShmNode;
3985: int rc = SQLITE_OK;
3986:
3987: /* If the shared-memory file has not yet been opened, open it now. */
3988: if( pDbFd->pShm==0 ){
3989: rc = unixOpenSharedMemory(pDbFd);
3990: if( rc!=SQLITE_OK ) return rc;
3991: }
3992:
3993: p = pDbFd->pShm;
3994: pShmNode = p->pShmNode;
3995: sqlite3_mutex_enter(pShmNode->mutex);
3996: assert( szRegion==pShmNode->szRegion || pShmNode->nRegion==0 );
3997: assert( pShmNode->pInode==pDbFd->pInode );
3998: assert( pShmNode->h>=0 || pDbFd->pInode->bProcessLock==1 );
3999: assert( pShmNode->h<0 || pDbFd->pInode->bProcessLock==0 );
4000:
4001: if( pShmNode->nRegion<=iRegion ){
4002: char **apNew; /* New apRegion[] array */
4003: int nByte = (iRegion+1)*szRegion; /* Minimum required file size */
4004: struct stat sStat; /* Used by fstat() */
4005:
4006: pShmNode->szRegion = szRegion;
4007:
4008: if( pShmNode->h>=0 ){
4009: /* The requested region is not mapped into this processes address space.
4010: ** Check to see if it has been allocated (i.e. if the wal-index file is
4011: ** large enough to contain the requested region).
4012: */
4013: if( osFstat(pShmNode->h, &sStat) ){
4014: rc = SQLITE_IOERR_SHMSIZE;
4015: goto shmpage_out;
4016: }
4017:
4018: if( sStat.st_size<nByte ){
4019: /* The requested memory region does not exist. If bExtend is set to
4020: ** false, exit early. *pp will be set to NULL and SQLITE_OK returned.
4021: **
4022: ** Alternatively, if bExtend is true, use ftruncate() to allocate
4023: ** the requested memory region.
4024: */
4025: if( !bExtend ) goto shmpage_out;
4026: if( robust_ftruncate(pShmNode->h, nByte) ){
4027: rc = unixLogError(SQLITE_IOERR_SHMSIZE, "ftruncate",
4028: pShmNode->zFilename);
4029: goto shmpage_out;
4030: }
4031: }
4032: }
4033:
4034: /* Map the requested memory region into this processes address space. */
4035: apNew = (char **)sqlite3_realloc(
4036: pShmNode->apRegion, (iRegion+1)*sizeof(char *)
4037: );
4038: if( !apNew ){
4039: rc = SQLITE_IOERR_NOMEM;
4040: goto shmpage_out;
4041: }
4042: pShmNode->apRegion = apNew;
4043: while(pShmNode->nRegion<=iRegion){
4044: void *pMem;
4045: if( pShmNode->h>=0 ){
4046: pMem = mmap(0, szRegion,
4047: pShmNode->isReadonly ? PROT_READ : PROT_READ|PROT_WRITE,
4048: MAP_SHARED, pShmNode->h, pShmNode->nRegion*szRegion
4049: );
4050: if( pMem==MAP_FAILED ){
4051: rc = unixLogError(SQLITE_IOERR_SHMMAP, "mmap", pShmNode->zFilename);
4052: goto shmpage_out;
4053: }
4054: }else{
4055: pMem = sqlite3_malloc(szRegion);
4056: if( pMem==0 ){
4057: rc = SQLITE_NOMEM;
4058: goto shmpage_out;
4059: }
4060: memset(pMem, 0, szRegion);
4061: }
4062: pShmNode->apRegion[pShmNode->nRegion] = pMem;
4063: pShmNode->nRegion++;
4064: }
4065: }
4066:
4067: shmpage_out:
4068: if( pShmNode->nRegion>iRegion ){
4069: *pp = pShmNode->apRegion[iRegion];
4070: }else{
4071: *pp = 0;
4072: }
4073: if( pShmNode->isReadonly && rc==SQLITE_OK ) rc = SQLITE_READONLY;
4074: sqlite3_mutex_leave(pShmNode->mutex);
4075: return rc;
4076: }
4077:
4078: /*
4079: ** Change the lock state for a shared-memory segment.
4080: **
4081: ** Note that the relationship between SHAREd and EXCLUSIVE locks is a little
4082: ** different here than in posix. In xShmLock(), one can go from unlocked
4083: ** to shared and back or from unlocked to exclusive and back. But one may
4084: ** not go from shared to exclusive or from exclusive to shared.
4085: */
4086: static int unixShmLock(
4087: sqlite3_file *fd, /* Database file holding the shared memory */
4088: int ofst, /* First lock to acquire or release */
4089: int n, /* Number of locks to acquire or release */
4090: int flags /* What to do with the lock */
4091: ){
4092: unixFile *pDbFd = (unixFile*)fd; /* Connection holding shared memory */
4093: unixShm *p = pDbFd->pShm; /* The shared memory being locked */
4094: unixShm *pX; /* For looping over all siblings */
4095: unixShmNode *pShmNode = p->pShmNode; /* The underlying file iNode */
4096: int rc = SQLITE_OK; /* Result code */
4097: u16 mask; /* Mask of locks to take or release */
4098:
4099: assert( pShmNode==pDbFd->pInode->pShmNode );
4100: assert( pShmNode->pInode==pDbFd->pInode );
4101: assert( ofst>=0 && ofst+n<=SQLITE_SHM_NLOCK );
4102: assert( n>=1 );
4103: assert( flags==(SQLITE_SHM_LOCK | SQLITE_SHM_SHARED)
4104: || flags==(SQLITE_SHM_LOCK | SQLITE_SHM_EXCLUSIVE)
4105: || flags==(SQLITE_SHM_UNLOCK | SQLITE_SHM_SHARED)
4106: || flags==(SQLITE_SHM_UNLOCK | SQLITE_SHM_EXCLUSIVE) );
4107: assert( n==1 || (flags & SQLITE_SHM_EXCLUSIVE)!=0 );
4108: assert( pShmNode->h>=0 || pDbFd->pInode->bProcessLock==1 );
4109: assert( pShmNode->h<0 || pDbFd->pInode->bProcessLock==0 );
4110:
4111: mask = (1<<(ofst+n)) - (1<<ofst);
4112: assert( n>1 || mask==(1<<ofst) );
4113: sqlite3_mutex_enter(pShmNode->mutex);
4114: if( flags & SQLITE_SHM_UNLOCK ){
4115: u16 allMask = 0; /* Mask of locks held by siblings */
4116:
4117: /* See if any siblings hold this same lock */
4118: for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
4119: if( pX==p ) continue;
4120: assert( (pX->exclMask & (p->exclMask|p->sharedMask))==0 );
4121: allMask |= pX->sharedMask;
4122: }
4123:
4124: /* Unlock the system-level locks */
4125: if( (mask & allMask)==0 ){
4126: rc = unixShmSystemLock(pShmNode, F_UNLCK, ofst+UNIX_SHM_BASE, n);
4127: }else{
4128: rc = SQLITE_OK;
4129: }
4130:
4131: /* Undo the local locks */
4132: if( rc==SQLITE_OK ){
4133: p->exclMask &= ~mask;
4134: p->sharedMask &= ~mask;
4135: }
4136: }else if( flags & SQLITE_SHM_SHARED ){
4137: u16 allShared = 0; /* Union of locks held by connections other than "p" */
4138:
4139: /* Find out which shared locks are already held by sibling connections.
4140: ** If any sibling already holds an exclusive lock, go ahead and return
4141: ** SQLITE_BUSY.
4142: */
4143: for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
4144: if( (pX->exclMask & mask)!=0 ){
4145: rc = SQLITE_BUSY;
4146: break;
4147: }
4148: allShared |= pX->sharedMask;
4149: }
4150:
4151: /* Get shared locks at the system level, if necessary */
4152: if( rc==SQLITE_OK ){
4153: if( (allShared & mask)==0 ){
4154: rc = unixShmSystemLock(pShmNode, F_RDLCK, ofst+UNIX_SHM_BASE, n);
4155: }else{
4156: rc = SQLITE_OK;
4157: }
4158: }
4159:
4160: /* Get the local shared locks */
4161: if( rc==SQLITE_OK ){
4162: p->sharedMask |= mask;
4163: }
4164: }else{
4165: /* Make sure no sibling connections hold locks that will block this
4166: ** lock. If any do, return SQLITE_BUSY right away.
4167: */
4168: for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
4169: if( (pX->exclMask & mask)!=0 || (pX->sharedMask & mask)!=0 ){
4170: rc = SQLITE_BUSY;
4171: break;
4172: }
4173: }
4174:
4175: /* Get the exclusive locks at the system level. Then if successful
4176: ** also mark the local connection as being locked.
4177: */
4178: if( rc==SQLITE_OK ){
4179: rc = unixShmSystemLock(pShmNode, F_WRLCK, ofst+UNIX_SHM_BASE, n);
4180: if( rc==SQLITE_OK ){
4181: assert( (p->sharedMask & mask)==0 );
4182: p->exclMask |= mask;
4183: }
4184: }
4185: }
4186: sqlite3_mutex_leave(pShmNode->mutex);
4187: OSTRACE(("SHM-LOCK shmid-%d, pid-%d got %03x,%03x\n",
4188: p->id, getpid(), p->sharedMask, p->exclMask));
4189: return rc;
4190: }
4191:
4192: /*
4193: ** Implement a memory barrier or memory fence on shared memory.
4194: **
4195: ** All loads and stores begun before the barrier must complete before
4196: ** any load or store begun after the barrier.
4197: */
4198: static void unixShmBarrier(
4199: sqlite3_file *fd /* Database file holding the shared memory */
4200: ){
4201: UNUSED_PARAMETER(fd);
4202: unixEnterMutex();
4203: unixLeaveMutex();
4204: }
4205:
4206: /*
4207: ** Close a connection to shared-memory. Delete the underlying
4208: ** storage if deleteFlag is true.
4209: **
4210: ** If there is no shared memory associated with the connection then this
4211: ** routine is a harmless no-op.
4212: */
4213: static int unixShmUnmap(
4214: sqlite3_file *fd, /* The underlying database file */
4215: int deleteFlag /* Delete shared-memory if true */
4216: ){
4217: unixShm *p; /* The connection to be closed */
4218: unixShmNode *pShmNode; /* The underlying shared-memory file */
4219: unixShm **pp; /* For looping over sibling connections */
4220: unixFile *pDbFd; /* The underlying database file */
4221:
4222: pDbFd = (unixFile*)fd;
4223: p = pDbFd->pShm;
4224: if( p==0 ) return SQLITE_OK;
4225: pShmNode = p->pShmNode;
4226:
4227: assert( pShmNode==pDbFd->pInode->pShmNode );
4228: assert( pShmNode->pInode==pDbFd->pInode );
4229:
4230: /* Remove connection p from the set of connections associated
4231: ** with pShmNode */
4232: sqlite3_mutex_enter(pShmNode->mutex);
4233: for(pp=&pShmNode->pFirst; (*pp)!=p; pp = &(*pp)->pNext){}
4234: *pp = p->pNext;
4235:
4236: /* Free the connection p */
4237: sqlite3_free(p);
4238: pDbFd->pShm = 0;
4239: sqlite3_mutex_leave(pShmNode->mutex);
4240:
4241: /* If pShmNode->nRef has reached 0, then close the underlying
4242: ** shared-memory file, too */
4243: unixEnterMutex();
4244: assert( pShmNode->nRef>0 );
4245: pShmNode->nRef--;
4246: if( pShmNode->nRef==0 ){
4247: if( deleteFlag && pShmNode->h>=0 ) osUnlink(pShmNode->zFilename);
4248: unixShmPurge(pDbFd);
4249: }
4250: unixLeaveMutex();
4251:
4252: return SQLITE_OK;
4253: }
4254:
4255:
4256: #else
4257: # define unixShmMap 0
4258: # define unixShmLock 0
4259: # define unixShmBarrier 0
4260: # define unixShmUnmap 0
4261: #endif /* #ifndef SQLITE_OMIT_WAL */
4262:
4263: /*
4264: ** Here ends the implementation of all sqlite3_file methods.
4265: **
4266: ********************** End sqlite3_file Methods *******************************
4267: ******************************************************************************/
4268:
4269: /*
4270: ** This division contains definitions of sqlite3_io_methods objects that
4271: ** implement various file locking strategies. It also contains definitions
4272: ** of "finder" functions. A finder-function is used to locate the appropriate
4273: ** sqlite3_io_methods object for a particular database file. The pAppData
4274: ** field of the sqlite3_vfs VFS objects are initialized to be pointers to
4275: ** the correct finder-function for that VFS.
4276: **
4277: ** Most finder functions return a pointer to a fixed sqlite3_io_methods
4278: ** object. The only interesting finder-function is autolockIoFinder, which
4279: ** looks at the filesystem type and tries to guess the best locking
4280: ** strategy from that.
4281: **
4282: ** For finder-funtion F, two objects are created:
4283: **
4284: ** (1) The real finder-function named "FImpt()".
4285: **
4286: ** (2) A constant pointer to this function named just "F".
4287: **
4288: **
4289: ** A pointer to the F pointer is used as the pAppData value for VFS
4290: ** objects. We have to do this instead of letting pAppData point
4291: ** directly at the finder-function since C90 rules prevent a void*
4292: ** from be cast into a function pointer.
4293: **
4294: **
4295: ** Each instance of this macro generates two objects:
4296: **
4297: ** * A constant sqlite3_io_methods object call METHOD that has locking
4298: ** methods CLOSE, LOCK, UNLOCK, CKRESLOCK.
4299: **
4300: ** * An I/O method finder function called FINDER that returns a pointer
4301: ** to the METHOD object in the previous bullet.
4302: */
4303: #define IOMETHODS(FINDER, METHOD, VERSION, CLOSE, LOCK, UNLOCK, CKLOCK) \
4304: static const sqlite3_io_methods METHOD = { \
4305: VERSION, /* iVersion */ \
4306: CLOSE, /* xClose */ \
4307: unixRead, /* xRead */ \
4308: unixWrite, /* xWrite */ \
4309: unixTruncate, /* xTruncate */ \
4310: unixSync, /* xSync */ \
4311: unixFileSize, /* xFileSize */ \
4312: LOCK, /* xLock */ \
4313: UNLOCK, /* xUnlock */ \
4314: CKLOCK, /* xCheckReservedLock */ \
4315: unixFileControl, /* xFileControl */ \
4316: unixSectorSize, /* xSectorSize */ \
4317: unixDeviceCharacteristics, /* xDeviceCapabilities */ \
4318: unixShmMap, /* xShmMap */ \
4319: unixShmLock, /* xShmLock */ \
4320: unixShmBarrier, /* xShmBarrier */ \
4321: unixShmUnmap /* xShmUnmap */ \
4322: }; \
4323: static const sqlite3_io_methods *FINDER##Impl(const char *z, unixFile *p){ \
4324: UNUSED_PARAMETER(z); UNUSED_PARAMETER(p); \
4325: return &METHOD; \
4326: } \
4327: static const sqlite3_io_methods *(*const FINDER)(const char*,unixFile *p) \
4328: = FINDER##Impl;
4329:
4330: /*
4331: ** Here are all of the sqlite3_io_methods objects for each of the
4332: ** locking strategies. Functions that return pointers to these methods
4333: ** are also created.
4334: */
4335: IOMETHODS(
4336: posixIoFinder, /* Finder function name */
4337: posixIoMethods, /* sqlite3_io_methods object name */
4338: 2, /* shared memory is enabled */
4339: unixClose, /* xClose method */
4340: unixLock, /* xLock method */
4341: unixUnlock, /* xUnlock method */
4342: unixCheckReservedLock /* xCheckReservedLock method */
4343: )
4344: IOMETHODS(
4345: nolockIoFinder, /* Finder function name */
4346: nolockIoMethods, /* sqlite3_io_methods object name */
4347: 1, /* shared memory is disabled */
4348: nolockClose, /* xClose method */
4349: nolockLock, /* xLock method */
4350: nolockUnlock, /* xUnlock method */
4351: nolockCheckReservedLock /* xCheckReservedLock method */
4352: )
4353: IOMETHODS(
4354: dotlockIoFinder, /* Finder function name */
4355: dotlockIoMethods, /* sqlite3_io_methods object name */
4356: 1, /* shared memory is disabled */
4357: dotlockClose, /* xClose method */
4358: dotlockLock, /* xLock method */
4359: dotlockUnlock, /* xUnlock method */
4360: dotlockCheckReservedLock /* xCheckReservedLock method */
4361: )
4362:
4363: #if SQLITE_ENABLE_LOCKING_STYLE && !OS_VXWORKS
4364: IOMETHODS(
4365: flockIoFinder, /* Finder function name */
4366: flockIoMethods, /* sqlite3_io_methods object name */
4367: 1, /* shared memory is disabled */
4368: flockClose, /* xClose method */
4369: flockLock, /* xLock method */
4370: flockUnlock, /* xUnlock method */
4371: flockCheckReservedLock /* xCheckReservedLock method */
4372: )
4373: #endif
4374:
4375: #if OS_VXWORKS
4376: IOMETHODS(
4377: semIoFinder, /* Finder function name */
4378: semIoMethods, /* sqlite3_io_methods object name */
4379: 1, /* shared memory is disabled */
4380: semClose, /* xClose method */
4381: semLock, /* xLock method */
4382: semUnlock, /* xUnlock method */
4383: semCheckReservedLock /* xCheckReservedLock method */
4384: )
4385: #endif
4386:
4387: #if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE
4388: IOMETHODS(
4389: afpIoFinder, /* Finder function name */
4390: afpIoMethods, /* sqlite3_io_methods object name */
4391: 1, /* shared memory is disabled */
4392: afpClose, /* xClose method */
4393: afpLock, /* xLock method */
4394: afpUnlock, /* xUnlock method */
4395: afpCheckReservedLock /* xCheckReservedLock method */
4396: )
4397: #endif
4398:
4399: /*
4400: ** The proxy locking method is a "super-method" in the sense that it
4401: ** opens secondary file descriptors for the conch and lock files and
4402: ** it uses proxy, dot-file, AFP, and flock() locking methods on those
4403: ** secondary files. For this reason, the division that implements
4404: ** proxy locking is located much further down in the file. But we need
4405: ** to go ahead and define the sqlite3_io_methods and finder function
4406: ** for proxy locking here. So we forward declare the I/O methods.
4407: */
4408: #if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE
4409: static int proxyClose(sqlite3_file*);
4410: static int proxyLock(sqlite3_file*, int);
4411: static int proxyUnlock(sqlite3_file*, int);
4412: static int proxyCheckReservedLock(sqlite3_file*, int*);
4413: IOMETHODS(
4414: proxyIoFinder, /* Finder function name */
4415: proxyIoMethods, /* sqlite3_io_methods object name */
4416: 1, /* shared memory is disabled */
4417: proxyClose, /* xClose method */
4418: proxyLock, /* xLock method */
4419: proxyUnlock, /* xUnlock method */
4420: proxyCheckReservedLock /* xCheckReservedLock method */
4421: )
4422: #endif
4423:
4424: /* nfs lockd on OSX 10.3+ doesn't clear write locks when a read lock is set */
4425: #if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE
4426: IOMETHODS(
4427: nfsIoFinder, /* Finder function name */
4428: nfsIoMethods, /* sqlite3_io_methods object name */
4429: 1, /* shared memory is disabled */
4430: unixClose, /* xClose method */
4431: unixLock, /* xLock method */
4432: nfsUnlock, /* xUnlock method */
4433: unixCheckReservedLock /* xCheckReservedLock method */
4434: )
4435: #endif
4436:
4437: #if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE
4438: /*
4439: ** This "finder" function attempts to determine the best locking strategy
4440: ** for the database file "filePath". It then returns the sqlite3_io_methods
4441: ** object that implements that strategy.
4442: **
4443: ** This is for MacOSX only.
4444: */
4445: static const sqlite3_io_methods *autolockIoFinderImpl(
4446: const char *filePath, /* name of the database file */
4447: unixFile *pNew /* open file object for the database file */
4448: ){
4449: static const struct Mapping {
4450: const char *zFilesystem; /* Filesystem type name */
4451: const sqlite3_io_methods *pMethods; /* Appropriate locking method */
4452: } aMap[] = {
4453: { "hfs", &posixIoMethods },
4454: { "ufs", &posixIoMethods },
4455: { "afpfs", &afpIoMethods },
4456: { "smbfs", &afpIoMethods },
4457: { "webdav", &nolockIoMethods },
4458: { 0, 0 }
4459: };
4460: int i;
4461: struct statfs fsInfo;
4462: struct flock lockInfo;
4463:
4464: if( !filePath ){
4465: /* If filePath==NULL that means we are dealing with a transient file
4466: ** that does not need to be locked. */
4467: return &nolockIoMethods;
4468: }
4469: if( statfs(filePath, &fsInfo) != -1 ){
4470: if( fsInfo.f_flags & MNT_RDONLY ){
4471: return &nolockIoMethods;
4472: }
4473: for(i=0; aMap[i].zFilesystem; i++){
4474: if( strcmp(fsInfo.f_fstypename, aMap[i].zFilesystem)==0 ){
4475: return aMap[i].pMethods;
4476: }
4477: }
4478: }
4479:
4480: /* Default case. Handles, amongst others, "nfs".
4481: ** Test byte-range lock using fcntl(). If the call succeeds,
4482: ** assume that the file-system supports POSIX style locks.
4483: */
4484: lockInfo.l_len = 1;
4485: lockInfo.l_start = 0;
4486: lockInfo.l_whence = SEEK_SET;
4487: lockInfo.l_type = F_RDLCK;
4488: if( osFcntl(pNew->h, F_GETLK, &lockInfo)!=-1 ) {
4489: if( strcmp(fsInfo.f_fstypename, "nfs")==0 ){
4490: return &nfsIoMethods;
4491: } else {
4492: return &posixIoMethods;
4493: }
4494: }else{
4495: return &dotlockIoMethods;
4496: }
4497: }
4498: static const sqlite3_io_methods
4499: *(*const autolockIoFinder)(const char*,unixFile*) = autolockIoFinderImpl;
4500:
4501: #endif /* defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE */
4502:
4503: #if OS_VXWORKS && SQLITE_ENABLE_LOCKING_STYLE
4504: /*
4505: ** This "finder" function attempts to determine the best locking strategy
4506: ** for the database file "filePath". It then returns the sqlite3_io_methods
4507: ** object that implements that strategy.
4508: **
4509: ** This is for VXWorks only.
4510: */
4511: static const sqlite3_io_methods *autolockIoFinderImpl(
4512: const char *filePath, /* name of the database file */
4513: unixFile *pNew /* the open file object */
4514: ){
4515: struct flock lockInfo;
4516:
4517: if( !filePath ){
4518: /* If filePath==NULL that means we are dealing with a transient file
4519: ** that does not need to be locked. */
4520: return &nolockIoMethods;
4521: }
4522:
4523: /* Test if fcntl() is supported and use POSIX style locks.
4524: ** Otherwise fall back to the named semaphore method.
4525: */
4526: lockInfo.l_len = 1;
4527: lockInfo.l_start = 0;
4528: lockInfo.l_whence = SEEK_SET;
4529: lockInfo.l_type = F_RDLCK;
4530: if( osFcntl(pNew->h, F_GETLK, &lockInfo)!=-1 ) {
4531: return &posixIoMethods;
4532: }else{
4533: return &semIoMethods;
4534: }
4535: }
4536: static const sqlite3_io_methods
4537: *(*const autolockIoFinder)(const char*,unixFile*) = autolockIoFinderImpl;
4538:
4539: #endif /* OS_VXWORKS && SQLITE_ENABLE_LOCKING_STYLE */
4540:
4541: /*
4542: ** An abstract type for a pointer to a IO method finder function:
4543: */
4544: typedef const sqlite3_io_methods *(*finder_type)(const char*,unixFile*);
4545:
4546:
4547: /****************************************************************************
4548: **************************** sqlite3_vfs methods ****************************
4549: **
4550: ** This division contains the implementation of methods on the
4551: ** sqlite3_vfs object.
4552: */
4553:
4554: /*
4555: ** Initialize the contents of the unixFile structure pointed to by pId.
4556: */
4557: static int fillInUnixFile(
4558: sqlite3_vfs *pVfs, /* Pointer to vfs object */
4559: int h, /* Open file descriptor of file being opened */
4560: sqlite3_file *pId, /* Write to the unixFile structure here */
4561: const char *zFilename, /* Name of the file being opened */
4562: int ctrlFlags /* Zero or more UNIXFILE_* values */
4563: ){
4564: const sqlite3_io_methods *pLockingStyle;
4565: unixFile *pNew = (unixFile *)pId;
4566: int rc = SQLITE_OK;
4567:
4568: assert( pNew->pInode==NULL );
4569:
4570: /* Usually the path zFilename should not be a relative pathname. The
4571: ** exception is when opening the proxy "conch" file in builds that
4572: ** include the special Apple locking styles.
4573: */
4574: #if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE
4575: assert( zFilename==0 || zFilename[0]=='/'
4576: || pVfs->pAppData==(void*)&autolockIoFinder );
4577: #else
4578: assert( zFilename==0 || zFilename[0]=='/' );
4579: #endif
4580:
4581: /* No locking occurs in temporary files */
4582: assert( zFilename!=0 || (ctrlFlags & UNIXFILE_NOLOCK)!=0 );
4583:
4584: OSTRACE(("OPEN %-3d %s\n", h, zFilename));
4585: pNew->h = h;
4586: pNew->pVfs = pVfs;
4587: pNew->zPath = zFilename;
4588: pNew->ctrlFlags = (u8)ctrlFlags;
4589: if( sqlite3_uri_boolean(((ctrlFlags & UNIXFILE_URI) ? zFilename : 0),
4590: "psow", SQLITE_POWERSAFE_OVERWRITE) ){
4591: pNew->ctrlFlags |= UNIXFILE_PSOW;
4592: }
4593: if( memcmp(pVfs->zName,"unix-excl",10)==0 ){
4594: pNew->ctrlFlags |= UNIXFILE_EXCL;
4595: }
4596:
4597: #if OS_VXWORKS
4598: pNew->pId = vxworksFindFileId(zFilename);
4599: if( pNew->pId==0 ){
4600: ctrlFlags |= UNIXFILE_NOLOCK;
4601: rc = SQLITE_NOMEM;
4602: }
4603: #endif
4604:
4605: if( ctrlFlags & UNIXFILE_NOLOCK ){
4606: pLockingStyle = &nolockIoMethods;
4607: }else{
4608: pLockingStyle = (**(finder_type*)pVfs->pAppData)(zFilename, pNew);
4609: #if SQLITE_ENABLE_LOCKING_STYLE
4610: /* Cache zFilename in the locking context (AFP and dotlock override) for
4611: ** proxyLock activation is possible (remote proxy is based on db name)
4612: ** zFilename remains valid until file is closed, to support */
4613: pNew->lockingContext = (void*)zFilename;
4614: #endif
4615: }
4616:
4617: if( pLockingStyle == &posixIoMethods
4618: #if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE
4619: || pLockingStyle == &nfsIoMethods
4620: #endif
4621: ){
4622: unixEnterMutex();
4623: rc = findInodeInfo(pNew, &pNew->pInode);
4624: if( rc!=SQLITE_OK ){
4625: /* If an error occured in findInodeInfo(), close the file descriptor
4626: ** immediately, before releasing the mutex. findInodeInfo() may fail
4627: ** in two scenarios:
4628: **
4629: ** (a) A call to fstat() failed.
4630: ** (b) A malloc failed.
4631: **
4632: ** Scenario (b) may only occur if the process is holding no other
4633: ** file descriptors open on the same file. If there were other file
4634: ** descriptors on this file, then no malloc would be required by
4635: ** findInodeInfo(). If this is the case, it is quite safe to close
4636: ** handle h - as it is guaranteed that no posix locks will be released
4637: ** by doing so.
4638: **
4639: ** If scenario (a) caused the error then things are not so safe. The
4640: ** implicit assumption here is that if fstat() fails, things are in
4641: ** such bad shape that dropping a lock or two doesn't matter much.
4642: */
4643: robust_close(pNew, h, __LINE__);
4644: h = -1;
4645: }
4646: unixLeaveMutex();
4647: }
4648:
4649: #if SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__)
4650: else if( pLockingStyle == &afpIoMethods ){
4651: /* AFP locking uses the file path so it needs to be included in
4652: ** the afpLockingContext.
4653: */
4654: afpLockingContext *pCtx;
4655: pNew->lockingContext = pCtx = sqlite3_malloc( sizeof(*pCtx) );
4656: if( pCtx==0 ){
4657: rc = SQLITE_NOMEM;
4658: }else{
4659: /* NB: zFilename exists and remains valid until the file is closed
4660: ** according to requirement F11141. So we do not need to make a
4661: ** copy of the filename. */
4662: pCtx->dbPath = zFilename;
4663: pCtx->reserved = 0;
4664: srandomdev();
4665: unixEnterMutex();
4666: rc = findInodeInfo(pNew, &pNew->pInode);
4667: if( rc!=SQLITE_OK ){
4668: sqlite3_free(pNew->lockingContext);
4669: robust_close(pNew, h, __LINE__);
4670: h = -1;
4671: }
4672: unixLeaveMutex();
4673: }
4674: }
4675: #endif
4676:
4677: else if( pLockingStyle == &dotlockIoMethods ){
4678: /* Dotfile locking uses the file path so it needs to be included in
4679: ** the dotlockLockingContext
4680: */
4681: char *zLockFile;
4682: int nFilename;
4683: assert( zFilename!=0 );
4684: nFilename = (int)strlen(zFilename) + 6;
4685: zLockFile = (char *)sqlite3_malloc(nFilename);
4686: if( zLockFile==0 ){
4687: rc = SQLITE_NOMEM;
4688: }else{
4689: sqlite3_snprintf(nFilename, zLockFile, "%s" DOTLOCK_SUFFIX, zFilename);
4690: }
4691: pNew->lockingContext = zLockFile;
4692: }
4693:
4694: #if OS_VXWORKS
4695: else if( pLockingStyle == &semIoMethods ){
4696: /* Named semaphore locking uses the file path so it needs to be
4697: ** included in the semLockingContext
4698: */
4699: unixEnterMutex();
4700: rc = findInodeInfo(pNew, &pNew->pInode);
4701: if( (rc==SQLITE_OK) && (pNew->pInode->pSem==NULL) ){
4702: char *zSemName = pNew->pInode->aSemName;
4703: int n;
4704: sqlite3_snprintf(MAX_PATHNAME, zSemName, "/%s.sem",
4705: pNew->pId->zCanonicalName);
4706: for( n=1; zSemName[n]; n++ )
4707: if( zSemName[n]=='/' ) zSemName[n] = '_';
4708: pNew->pInode->pSem = sem_open(zSemName, O_CREAT, 0666, 1);
4709: if( pNew->pInode->pSem == SEM_FAILED ){
4710: rc = SQLITE_NOMEM;
4711: pNew->pInode->aSemName[0] = '\0';
4712: }
4713: }
4714: unixLeaveMutex();
4715: }
4716: #endif
4717:
4718: pNew->lastErrno = 0;
4719: #if OS_VXWORKS
4720: if( rc!=SQLITE_OK ){
4721: if( h>=0 ) robust_close(pNew, h, __LINE__);
4722: h = -1;
4723: osUnlink(zFilename);
4724: isDelete = 0;
4725: }
4726: if( isDelete ) pNew->ctrlFlags |= UNIXFILE_DELETE;
4727: #endif
4728: if( rc!=SQLITE_OK ){
4729: if( h>=0 ) robust_close(pNew, h, __LINE__);
4730: }else{
4731: pNew->pMethod = pLockingStyle;
4732: OpenCounter(+1);
4733: }
4734: return rc;
4735: }
4736:
4737: /*
4738: ** Return the name of a directory in which to put temporary files.
4739: ** If no suitable temporary file directory can be found, return NULL.
4740: */
4741: static const char *unixTempFileDir(void){
4742: static const char *azDirs[] = {
4743: 0,
4744: 0,
4745: "/var/tmp",
4746: "/usr/tmp",
4747: "/tmp",
4748: 0 /* List terminator */
4749: };
4750: unsigned int i;
4751: struct stat buf;
4752: const char *zDir = 0;
4753:
4754: azDirs[0] = sqlite3_temp_directory;
4755: if( !azDirs[1] ) azDirs[1] = getenv("TMPDIR");
4756: for(i=0; i<sizeof(azDirs)/sizeof(azDirs[0]); zDir=azDirs[i++]){
4757: if( zDir==0 ) continue;
4758: if( osStat(zDir, &buf) ) continue;
4759: if( !S_ISDIR(buf.st_mode) ) continue;
4760: if( osAccess(zDir, 07) ) continue;
4761: break;
4762: }
4763: return zDir;
4764: }
4765:
4766: /*
4767: ** Create a temporary file name in zBuf. zBuf must be allocated
4768: ** by the calling process and must be big enough to hold at least
4769: ** pVfs->mxPathname bytes.
4770: */
4771: static int unixGetTempname(int nBuf, char *zBuf){
4772: static const unsigned char zChars[] =
4773: "abcdefghijklmnopqrstuvwxyz"
4774: "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
4775: "0123456789";
4776: unsigned int i, j;
4777: const char *zDir;
4778:
4779: /* It's odd to simulate an io-error here, but really this is just
4780: ** using the io-error infrastructure to test that SQLite handles this
4781: ** function failing.
4782: */
4783: SimulateIOError( return SQLITE_IOERR );
4784:
4785: zDir = unixTempFileDir();
4786: if( zDir==0 ) zDir = ".";
4787:
4788: /* Check that the output buffer is large enough for the temporary file
4789: ** name. If it is not, return SQLITE_ERROR.
4790: */
4791: if( (strlen(zDir) + strlen(SQLITE_TEMP_FILE_PREFIX) + 18) >= (size_t)nBuf ){
4792: return SQLITE_ERROR;
4793: }
4794:
4795: do{
4796: sqlite3_snprintf(nBuf-18, zBuf, "%s/"SQLITE_TEMP_FILE_PREFIX, zDir);
4797: j = (int)strlen(zBuf);
4798: sqlite3_randomness(15, &zBuf[j]);
4799: for(i=0; i<15; i++, j++){
4800: zBuf[j] = (char)zChars[ ((unsigned char)zBuf[j])%(sizeof(zChars)-1) ];
4801: }
4802: zBuf[j] = 0;
4803: zBuf[j+1] = 0;
4804: }while( osAccess(zBuf,0)==0 );
4805: return SQLITE_OK;
4806: }
4807:
4808: #if SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__)
4809: /*
4810: ** Routine to transform a unixFile into a proxy-locking unixFile.
4811: ** Implementation in the proxy-lock division, but used by unixOpen()
4812: ** if SQLITE_PREFER_PROXY_LOCKING is defined.
4813: */
4814: static int proxyTransformUnixFile(unixFile*, const char*);
4815: #endif
4816:
4817: /*
4818: ** Search for an unused file descriptor that was opened on the database
4819: ** file (not a journal or master-journal file) identified by pathname
4820: ** zPath with SQLITE_OPEN_XXX flags matching those passed as the second
4821: ** argument to this function.
4822: **
4823: ** Such a file descriptor may exist if a database connection was closed
4824: ** but the associated file descriptor could not be closed because some
4825: ** other file descriptor open on the same file is holding a file-lock.
4826: ** Refer to comments in the unixClose() function and the lengthy comment
4827: ** describing "Posix Advisory Locking" at the start of this file for
4828: ** further details. Also, ticket #4018.
4829: **
4830: ** If a suitable file descriptor is found, then it is returned. If no
4831: ** such file descriptor is located, -1 is returned.
4832: */
4833: static UnixUnusedFd *findReusableFd(const char *zPath, int flags){
4834: UnixUnusedFd *pUnused = 0;
4835:
4836: /* Do not search for an unused file descriptor on vxworks. Not because
4837: ** vxworks would not benefit from the change (it might, we're not sure),
4838: ** but because no way to test it is currently available. It is better
4839: ** not to risk breaking vxworks support for the sake of such an obscure
4840: ** feature. */
4841: #if !OS_VXWORKS
4842: struct stat sStat; /* Results of stat() call */
4843:
4844: /* A stat() call may fail for various reasons. If this happens, it is
4845: ** almost certain that an open() call on the same path will also fail.
4846: ** For this reason, if an error occurs in the stat() call here, it is
4847: ** ignored and -1 is returned. The caller will try to open a new file
4848: ** descriptor on the same path, fail, and return an error to SQLite.
4849: **
4850: ** Even if a subsequent open() call does succeed, the consequences of
4851: ** not searching for a resusable file descriptor are not dire. */
4852: if( 0==osStat(zPath, &sStat) ){
4853: unixInodeInfo *pInode;
4854:
4855: unixEnterMutex();
4856: pInode = inodeList;
4857: while( pInode && (pInode->fileId.dev!=sStat.st_dev
4858: || pInode->fileId.ino!=sStat.st_ino) ){
4859: pInode = pInode->pNext;
4860: }
4861: if( pInode ){
4862: UnixUnusedFd **pp;
4863: for(pp=&pInode->pUnused; *pp && (*pp)->flags!=flags; pp=&((*pp)->pNext));
4864: pUnused = *pp;
4865: if( pUnused ){
4866: *pp = pUnused->pNext;
4867: }
4868: }
4869: unixLeaveMutex();
4870: }
4871: #endif /* if !OS_VXWORKS */
4872: return pUnused;
4873: }
4874:
4875: /*
4876: ** This function is called by unixOpen() to determine the unix permissions
4877: ** to create new files with. If no error occurs, then SQLITE_OK is returned
4878: ** and a value suitable for passing as the third argument to open(2) is
4879: ** written to *pMode. If an IO error occurs, an SQLite error code is
4880: ** returned and the value of *pMode is not modified.
4881: **
4882: ** If the file being opened is a temporary file, it is always created with
4883: ** the octal permissions 0600 (read/writable by owner only). If the file
4884: ** is a database or master journal file, it is created with the permissions
4885: ** mask SQLITE_DEFAULT_FILE_PERMISSIONS.
4886: **
4887: ** Finally, if the file being opened is a WAL or regular journal file, then
4888: ** this function queries the file-system for the permissions on the
4889: ** corresponding database file and sets *pMode to this value. Whenever
4890: ** possible, WAL and journal files are created using the same permissions
4891: ** as the associated database file.
4892: **
4893: ** If the SQLITE_ENABLE_8_3_NAMES option is enabled, then the
4894: ** original filename is unavailable. But 8_3_NAMES is only used for
4895: ** FAT filesystems and permissions do not matter there, so just use
4896: ** the default permissions.
4897: */
4898: static int findCreateFileMode(
4899: const char *zPath, /* Path of file (possibly) being created */
4900: int flags, /* Flags passed as 4th argument to xOpen() */
4901: mode_t *pMode /* OUT: Permissions to open file with */
4902: ){
4903: int rc = SQLITE_OK; /* Return Code */
4904: *pMode = SQLITE_DEFAULT_FILE_PERMISSIONS;
4905: if( flags & (SQLITE_OPEN_WAL|SQLITE_OPEN_MAIN_JOURNAL) ){
4906: char zDb[MAX_PATHNAME+1]; /* Database file path */
4907: int nDb; /* Number of valid bytes in zDb */
4908: struct stat sStat; /* Output of stat() on database file */
4909:
4910: /* zPath is a path to a WAL or journal file. The following block derives
4911: ** the path to the associated database file from zPath. This block handles
4912: ** the following naming conventions:
4913: **
4914: ** "<path to db>-journal"
4915: ** "<path to db>-wal"
4916: ** "<path to db>-journalNN"
4917: ** "<path to db>-walNN"
4918: **
4919: ** where NN is a decimal number. The NN naming schemes are
4920: ** used by the test_multiplex.c module.
4921: */
4922: nDb = sqlite3Strlen30(zPath) - 1;
4923: #ifdef SQLITE_ENABLE_8_3_NAMES
4924: while( nDb>0 && sqlite3Isalnum(zPath[nDb]) ) nDb--;
4925: if( nDb==0 || zPath[nDb]!='-' ) return SQLITE_OK;
4926: #else
4927: while( zPath[nDb]!='-' ){
4928: assert( nDb>0 );
4929: assert( zPath[nDb]!='\n' );
4930: nDb--;
4931: }
4932: #endif
4933: memcpy(zDb, zPath, nDb);
4934: zDb[nDb] = '\0';
4935:
4936: if( 0==osStat(zDb, &sStat) ){
4937: *pMode = sStat.st_mode & 0777;
4938: }else{
4939: rc = SQLITE_IOERR_FSTAT;
4940: }
4941: }else if( flags & SQLITE_OPEN_DELETEONCLOSE ){
4942: *pMode = 0600;
4943: }
4944: return rc;
4945: }
4946:
4947: /*
4948: ** Open the file zPath.
4949: **
4950: ** Previously, the SQLite OS layer used three functions in place of this
4951: ** one:
4952: **
4953: ** sqlite3OsOpenReadWrite();
4954: ** sqlite3OsOpenReadOnly();
4955: ** sqlite3OsOpenExclusive();
4956: **
4957: ** These calls correspond to the following combinations of flags:
4958: **
4959: ** ReadWrite() -> (READWRITE | CREATE)
4960: ** ReadOnly() -> (READONLY)
4961: ** OpenExclusive() -> (READWRITE | CREATE | EXCLUSIVE)
4962: **
4963: ** The old OpenExclusive() accepted a boolean argument - "delFlag". If
4964: ** true, the file was configured to be automatically deleted when the
4965: ** file handle closed. To achieve the same effect using this new
4966: ** interface, add the DELETEONCLOSE flag to those specified above for
4967: ** OpenExclusive().
4968: */
4969: static int unixOpen(
4970: sqlite3_vfs *pVfs, /* The VFS for which this is the xOpen method */
4971: const char *zPath, /* Pathname of file to be opened */
4972: sqlite3_file *pFile, /* The file descriptor to be filled in */
4973: int flags, /* Input flags to control the opening */
4974: int *pOutFlags /* Output flags returned to SQLite core */
4975: ){
4976: unixFile *p = (unixFile *)pFile;
4977: int fd = -1; /* File descriptor returned by open() */
4978: int openFlags = 0; /* Flags to pass to open() */
4979: int eType = flags&0xFFFFFF00; /* Type of file to open */
4980: int noLock; /* True to omit locking primitives */
4981: int rc = SQLITE_OK; /* Function Return Code */
4982: int ctrlFlags = 0; /* UNIXFILE_* flags */
4983:
4984: int isExclusive = (flags & SQLITE_OPEN_EXCLUSIVE);
4985: int isDelete = (flags & SQLITE_OPEN_DELETEONCLOSE);
4986: int isCreate = (flags & SQLITE_OPEN_CREATE);
4987: int isReadonly = (flags & SQLITE_OPEN_READONLY);
4988: int isReadWrite = (flags & SQLITE_OPEN_READWRITE);
4989: #if SQLITE_ENABLE_LOCKING_STYLE
4990: int isAutoProxy = (flags & SQLITE_OPEN_AUTOPROXY);
4991: #endif
4992: #if defined(__APPLE__) || SQLITE_ENABLE_LOCKING_STYLE
4993: struct statfs fsInfo;
4994: #endif
4995:
4996: /* If creating a master or main-file journal, this function will open
4997: ** a file-descriptor on the directory too. The first time unixSync()
4998: ** is called the directory file descriptor will be fsync()ed and close()d.
4999: */
5000: int syncDir = (isCreate && (
5001: eType==SQLITE_OPEN_MASTER_JOURNAL
5002: || eType==SQLITE_OPEN_MAIN_JOURNAL
5003: || eType==SQLITE_OPEN_WAL
5004: ));
5005:
5006: /* If argument zPath is a NULL pointer, this function is required to open
5007: ** a temporary file. Use this buffer to store the file name in.
5008: */
5009: char zTmpname[MAX_PATHNAME+2];
5010: const char *zName = zPath;
5011:
5012: /* Check the following statements are true:
5013: **
5014: ** (a) Exactly one of the READWRITE and READONLY flags must be set, and
5015: ** (b) if CREATE is set, then READWRITE must also be set, and
5016: ** (c) if EXCLUSIVE is set, then CREATE must also be set.
5017: ** (d) if DELETEONCLOSE is set, then CREATE must also be set.
5018: */
5019: assert((isReadonly==0 || isReadWrite==0) && (isReadWrite || isReadonly));
5020: assert(isCreate==0 || isReadWrite);
5021: assert(isExclusive==0 || isCreate);
5022: assert(isDelete==0 || isCreate);
5023:
5024: /* The main DB, main journal, WAL file and master journal are never
5025: ** automatically deleted. Nor are they ever temporary files. */
5026: assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_DB );
5027: assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_JOURNAL );
5028: assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MASTER_JOURNAL );
5029: assert( (!isDelete && zName) || eType!=SQLITE_OPEN_WAL );
5030:
5031: /* Assert that the upper layer has set one of the "file-type" flags. */
5032: assert( eType==SQLITE_OPEN_MAIN_DB || eType==SQLITE_OPEN_TEMP_DB
5033: || eType==SQLITE_OPEN_MAIN_JOURNAL || eType==SQLITE_OPEN_TEMP_JOURNAL
5034: || eType==SQLITE_OPEN_SUBJOURNAL || eType==SQLITE_OPEN_MASTER_JOURNAL
5035: || eType==SQLITE_OPEN_TRANSIENT_DB || eType==SQLITE_OPEN_WAL
5036: );
5037:
5038: memset(p, 0, sizeof(unixFile));
5039:
5040: if( eType==SQLITE_OPEN_MAIN_DB ){
5041: UnixUnusedFd *pUnused;
5042: pUnused = findReusableFd(zName, flags);
5043: if( pUnused ){
5044: fd = pUnused->fd;
5045: }else{
5046: pUnused = sqlite3_malloc(sizeof(*pUnused));
5047: if( !pUnused ){
5048: return SQLITE_NOMEM;
5049: }
5050: }
5051: p->pUnused = pUnused;
5052:
5053: /* Database filenames are double-zero terminated if they are not
5054: ** URIs with parameters. Hence, they can always be passed into
5055: ** sqlite3_uri_parameter(). */
5056: assert( (flags & SQLITE_OPEN_URI) || zName[strlen(zName)+1]==0 );
5057:
5058: }else if( !zName ){
5059: /* If zName is NULL, the upper layer is requesting a temp file. */
5060: assert(isDelete && !syncDir);
5061: rc = unixGetTempname(MAX_PATHNAME+2, zTmpname);
5062: if( rc!=SQLITE_OK ){
5063: return rc;
5064: }
5065: zName = zTmpname;
5066:
5067: /* Generated temporary filenames are always double-zero terminated
5068: ** for use by sqlite3_uri_parameter(). */
5069: assert( zName[strlen(zName)+1]==0 );
5070: }
5071:
5072: /* Determine the value of the flags parameter passed to POSIX function
5073: ** open(). These must be calculated even if open() is not called, as
5074: ** they may be stored as part of the file handle and used by the
5075: ** 'conch file' locking functions later on. */
5076: if( isReadonly ) openFlags |= O_RDONLY;
5077: if( isReadWrite ) openFlags |= O_RDWR;
5078: if( isCreate ) openFlags |= O_CREAT;
5079: if( isExclusive ) openFlags |= (O_EXCL|O_NOFOLLOW);
5080: openFlags |= (O_LARGEFILE|O_BINARY);
5081:
5082: if( fd<0 ){
5083: mode_t openMode; /* Permissions to create file with */
5084: rc = findCreateFileMode(zName, flags, &openMode);
5085: if( rc!=SQLITE_OK ){
5086: assert( !p->pUnused );
5087: assert( eType==SQLITE_OPEN_WAL || eType==SQLITE_OPEN_MAIN_JOURNAL );
5088: return rc;
5089: }
5090: fd = robust_open(zName, openFlags, openMode);
5091: OSTRACE(("OPENX %-3d %s 0%o\n", fd, zName, openFlags));
5092: if( fd<0 && errno!=EISDIR && isReadWrite && !isExclusive ){
5093: /* Failed to open the file for read/write access. Try read-only. */
5094: flags &= ~(SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE);
5095: openFlags &= ~(O_RDWR|O_CREAT);
5096: flags |= SQLITE_OPEN_READONLY;
5097: openFlags |= O_RDONLY;
5098: isReadonly = 1;
5099: fd = robust_open(zName, openFlags, openMode);
5100: }
5101: if( fd<0 ){
5102: rc = unixLogError(SQLITE_CANTOPEN_BKPT, "open", zName);
5103: goto open_finished;
5104: }
5105: }
5106: assert( fd>=0 );
5107: if( pOutFlags ){
5108: *pOutFlags = flags;
5109: }
5110:
5111: if( p->pUnused ){
5112: p->pUnused->fd = fd;
5113: p->pUnused->flags = flags;
5114: }
5115:
5116: if( isDelete ){
5117: #if OS_VXWORKS
5118: zPath = zName;
5119: #else
5120: osUnlink(zName);
5121: #endif
5122: }
5123: #if SQLITE_ENABLE_LOCKING_STYLE
5124: else{
5125: p->openFlags = openFlags;
5126: }
5127: #endif
5128:
5129: #ifdef FD_CLOEXEC
5130: osFcntl(fd, F_SETFD, osFcntl(fd, F_GETFD, 0) | FD_CLOEXEC);
5131: #endif
5132:
5133: noLock = eType!=SQLITE_OPEN_MAIN_DB;
5134:
5135:
5136: #if defined(__APPLE__) || SQLITE_ENABLE_LOCKING_STYLE
5137: if( fstatfs(fd, &fsInfo) == -1 ){
5138: ((unixFile*)pFile)->lastErrno = errno;
5139: robust_close(p, fd, __LINE__);
5140: return SQLITE_IOERR_ACCESS;
5141: }
5142: if (0 == strncmp("msdos", fsInfo.f_fstypename, 5)) {
5143: ((unixFile*)pFile)->fsFlags |= SQLITE_FSFLAGS_IS_MSDOS;
5144: }
5145: #endif
5146:
5147: /* Set up appropriate ctrlFlags */
5148: if( isDelete ) ctrlFlags |= UNIXFILE_DELETE;
5149: if( isReadonly ) ctrlFlags |= UNIXFILE_RDONLY;
5150: if( noLock ) ctrlFlags |= UNIXFILE_NOLOCK;
5151: if( syncDir ) ctrlFlags |= UNIXFILE_DIRSYNC;
5152: if( flags & SQLITE_OPEN_URI ) ctrlFlags |= UNIXFILE_URI;
5153:
5154: #if SQLITE_ENABLE_LOCKING_STYLE
5155: #if SQLITE_PREFER_PROXY_LOCKING
5156: isAutoProxy = 1;
5157: #endif
5158: if( isAutoProxy && (zPath!=NULL) && (!noLock) && pVfs->xOpen ){
5159: char *envforce = getenv("SQLITE_FORCE_PROXY_LOCKING");
5160: int useProxy = 0;
5161:
5162: /* SQLITE_FORCE_PROXY_LOCKING==1 means force always use proxy, 0 means
5163: ** never use proxy, NULL means use proxy for non-local files only. */
5164: if( envforce!=NULL ){
5165: useProxy = atoi(envforce)>0;
5166: }else{
5167: if( statfs(zPath, &fsInfo) == -1 ){
5168: /* In theory, the close(fd) call is sub-optimal. If the file opened
5169: ** with fd is a database file, and there are other connections open
5170: ** on that file that are currently holding advisory locks on it,
5171: ** then the call to close() will cancel those locks. In practice,
5172: ** we're assuming that statfs() doesn't fail very often. At least
5173: ** not while other file descriptors opened by the same process on
5174: ** the same file are working. */
5175: p->lastErrno = errno;
5176: robust_close(p, fd, __LINE__);
5177: rc = SQLITE_IOERR_ACCESS;
5178: goto open_finished;
5179: }
5180: useProxy = !(fsInfo.f_flags&MNT_LOCAL);
5181: }
5182: if( useProxy ){
5183: rc = fillInUnixFile(pVfs, fd, pFile, zPath, ctrlFlags);
5184: if( rc==SQLITE_OK ){
5185: rc = proxyTransformUnixFile((unixFile*)pFile, ":auto:");
5186: if( rc!=SQLITE_OK ){
5187: /* Use unixClose to clean up the resources added in fillInUnixFile
5188: ** and clear all the structure's references. Specifically,
5189: ** pFile->pMethods will be NULL so sqlite3OsClose will be a no-op
5190: */
5191: unixClose(pFile);
5192: return rc;
5193: }
5194: }
5195: goto open_finished;
5196: }
5197: }
5198: #endif
5199:
5200: rc = fillInUnixFile(pVfs, fd, pFile, zPath, ctrlFlags);
5201:
5202: open_finished:
5203: if( rc!=SQLITE_OK ){
5204: sqlite3_free(p->pUnused);
5205: }
5206: return rc;
5207: }
5208:
5209:
5210: /*
5211: ** Delete the file at zPath. If the dirSync argument is true, fsync()
5212: ** the directory after deleting the file.
5213: */
5214: static int unixDelete(
5215: sqlite3_vfs *NotUsed, /* VFS containing this as the xDelete method */
5216: const char *zPath, /* Name of file to be deleted */
5217: int dirSync /* If true, fsync() directory after deleting file */
5218: ){
5219: int rc = SQLITE_OK;
5220: UNUSED_PARAMETER(NotUsed);
5221: SimulateIOError(return SQLITE_IOERR_DELETE);
5222: if( osUnlink(zPath)==(-1) && errno!=ENOENT ){
5223: return unixLogError(SQLITE_IOERR_DELETE, "unlink", zPath);
5224: }
5225: #ifndef SQLITE_DISABLE_DIRSYNC
5226: if( (dirSync & 1)!=0 ){
5227: int fd;
5228: rc = osOpenDirectory(zPath, &fd);
5229: if( rc==SQLITE_OK ){
5230: #if OS_VXWORKS
5231: if( fsync(fd)==-1 )
5232: #else
5233: if( fsync(fd) )
5234: #endif
5235: {
5236: rc = unixLogError(SQLITE_IOERR_DIR_FSYNC, "fsync", zPath);
5237: }
5238: robust_close(0, fd, __LINE__);
5239: }else if( rc==SQLITE_CANTOPEN ){
5240: rc = SQLITE_OK;
5241: }
5242: }
5243: #endif
5244: return rc;
5245: }
5246:
5247: /*
5248: ** Test the existance of or access permissions of file zPath. The
5249: ** test performed depends on the value of flags:
5250: **
5251: ** SQLITE_ACCESS_EXISTS: Return 1 if the file exists
5252: ** SQLITE_ACCESS_READWRITE: Return 1 if the file is read and writable.
5253: ** SQLITE_ACCESS_READONLY: Return 1 if the file is readable.
5254: **
5255: ** Otherwise return 0.
5256: */
5257: static int unixAccess(
5258: sqlite3_vfs *NotUsed, /* The VFS containing this xAccess method */
5259: const char *zPath, /* Path of the file to examine */
5260: int flags, /* What do we want to learn about the zPath file? */
5261: int *pResOut /* Write result boolean here */
5262: ){
5263: int amode = 0;
5264: UNUSED_PARAMETER(NotUsed);
5265: SimulateIOError( return SQLITE_IOERR_ACCESS; );
5266: switch( flags ){
5267: case SQLITE_ACCESS_EXISTS:
5268: amode = F_OK;
5269: break;
5270: case SQLITE_ACCESS_READWRITE:
5271: amode = W_OK|R_OK;
5272: break;
5273: case SQLITE_ACCESS_READ:
5274: amode = R_OK;
5275: break;
5276:
5277: default:
5278: assert(!"Invalid flags argument");
5279: }
5280: *pResOut = (osAccess(zPath, amode)==0);
5281: if( flags==SQLITE_ACCESS_EXISTS && *pResOut ){
5282: struct stat buf;
5283: if( 0==osStat(zPath, &buf) && buf.st_size==0 ){
5284: *pResOut = 0;
5285: }
5286: }
5287: return SQLITE_OK;
5288: }
5289:
5290:
5291: /*
5292: ** Turn a relative pathname into a full pathname. The relative path
5293: ** is stored as a nul-terminated string in the buffer pointed to by
5294: ** zPath.
5295: **
5296: ** zOut points to a buffer of at least sqlite3_vfs.mxPathname bytes
5297: ** (in this case, MAX_PATHNAME bytes). The full-path is written to
5298: ** this buffer before returning.
5299: */
5300: static int unixFullPathname(
5301: sqlite3_vfs *pVfs, /* Pointer to vfs object */
5302: const char *zPath, /* Possibly relative input path */
5303: int nOut, /* Size of output buffer in bytes */
5304: char *zOut /* Output buffer */
5305: ){
5306:
5307: /* It's odd to simulate an io-error here, but really this is just
5308: ** using the io-error infrastructure to test that SQLite handles this
5309: ** function failing. This function could fail if, for example, the
5310: ** current working directory has been unlinked.
5311: */
5312: SimulateIOError( return SQLITE_ERROR );
5313:
5314: assert( pVfs->mxPathname==MAX_PATHNAME );
5315: UNUSED_PARAMETER(pVfs);
5316:
5317: zOut[nOut-1] = '\0';
5318: if( zPath[0]=='/' ){
5319: sqlite3_snprintf(nOut, zOut, "%s", zPath);
5320: }else{
5321: int nCwd;
5322: if( osGetcwd(zOut, nOut-1)==0 ){
5323: return unixLogError(SQLITE_CANTOPEN_BKPT, "getcwd", zPath);
5324: }
5325: nCwd = (int)strlen(zOut);
5326: sqlite3_snprintf(nOut-nCwd, &zOut[nCwd], "/%s", zPath);
5327: }
5328: return SQLITE_OK;
5329: }
5330:
5331:
5332: #ifndef SQLITE_OMIT_LOAD_EXTENSION
5333: /*
5334: ** Interfaces for opening a shared library, finding entry points
5335: ** within the shared library, and closing the shared library.
5336: */
5337: #include <dlfcn.h>
5338: static void *unixDlOpen(sqlite3_vfs *NotUsed, const char *zFilename){
5339: UNUSED_PARAMETER(NotUsed);
5340: return dlopen(zFilename, RTLD_NOW | RTLD_GLOBAL);
5341: }
5342:
5343: /*
5344: ** SQLite calls this function immediately after a call to unixDlSym() or
5345: ** unixDlOpen() fails (returns a null pointer). If a more detailed error
5346: ** message is available, it is written to zBufOut. If no error message
5347: ** is available, zBufOut is left unmodified and SQLite uses a default
5348: ** error message.
5349: */
5350: static void unixDlError(sqlite3_vfs *NotUsed, int nBuf, char *zBufOut){
5351: const char *zErr;
5352: UNUSED_PARAMETER(NotUsed);
5353: unixEnterMutex();
5354: zErr = dlerror();
5355: if( zErr ){
5356: sqlite3_snprintf(nBuf, zBufOut, "%s", zErr);
5357: }
5358: unixLeaveMutex();
5359: }
5360: static void (*unixDlSym(sqlite3_vfs *NotUsed, void *p, const char*zSym))(void){
5361: /*
5362: ** GCC with -pedantic-errors says that C90 does not allow a void* to be
5363: ** cast into a pointer to a function. And yet the library dlsym() routine
5364: ** returns a void* which is really a pointer to a function. So how do we
5365: ** use dlsym() with -pedantic-errors?
5366: **
5367: ** Variable x below is defined to be a pointer to a function taking
5368: ** parameters void* and const char* and returning a pointer to a function.
5369: ** We initialize x by assigning it a pointer to the dlsym() function.
5370: ** (That assignment requires a cast.) Then we call the function that
5371: ** x points to.
5372: **
5373: ** This work-around is unlikely to work correctly on any system where
5374: ** you really cannot cast a function pointer into void*. But then, on the
5375: ** other hand, dlsym() will not work on such a system either, so we have
5376: ** not really lost anything.
5377: */
5378: void (*(*x)(void*,const char*))(void);
5379: UNUSED_PARAMETER(NotUsed);
5380: x = (void(*(*)(void*,const char*))(void))dlsym;
5381: return (*x)(p, zSym);
5382: }
5383: static void unixDlClose(sqlite3_vfs *NotUsed, void *pHandle){
5384: UNUSED_PARAMETER(NotUsed);
5385: dlclose(pHandle);
5386: }
5387: #else /* if SQLITE_OMIT_LOAD_EXTENSION is defined: */
5388: #define unixDlOpen 0
5389: #define unixDlError 0
5390: #define unixDlSym 0
5391: #define unixDlClose 0
5392: #endif
5393:
5394: /*
5395: ** Write nBuf bytes of random data to the supplied buffer zBuf.
5396: */
5397: static int unixRandomness(sqlite3_vfs *NotUsed, int nBuf, char *zBuf){
5398: UNUSED_PARAMETER(NotUsed);
5399: assert((size_t)nBuf>=(sizeof(time_t)+sizeof(int)));
5400:
5401: /* We have to initialize zBuf to prevent valgrind from reporting
5402: ** errors. The reports issued by valgrind are incorrect - we would
5403: ** prefer that the randomness be increased by making use of the
5404: ** uninitialized space in zBuf - but valgrind errors tend to worry
5405: ** some users. Rather than argue, it seems easier just to initialize
5406: ** the whole array and silence valgrind, even if that means less randomness
5407: ** in the random seed.
5408: **
5409: ** When testing, initializing zBuf[] to zero is all we do. That means
5410: ** that we always use the same random number sequence. This makes the
5411: ** tests repeatable.
5412: */
5413: memset(zBuf, 0, nBuf);
5414: #if !defined(SQLITE_TEST)
5415: {
5416: int pid, fd;
5417: fd = robust_open("/dev/urandom", O_RDONLY, 0);
5418: if( fd<0 ){
5419: time_t t;
5420: time(&t);
5421: memcpy(zBuf, &t, sizeof(t));
5422: pid = getpid();
5423: memcpy(&zBuf[sizeof(t)], &pid, sizeof(pid));
5424: assert( sizeof(t)+sizeof(pid)<=(size_t)nBuf );
5425: nBuf = sizeof(t) + sizeof(pid);
5426: }else{
5427: do{ nBuf = osRead(fd, zBuf, nBuf); }while( nBuf<0 && errno==EINTR );
5428: robust_close(0, fd, __LINE__);
5429: }
5430: }
5431: #endif
5432: return nBuf;
5433: }
5434:
5435:
5436: /*
5437: ** Sleep for a little while. Return the amount of time slept.
5438: ** The argument is the number of microseconds we want to sleep.
5439: ** The return value is the number of microseconds of sleep actually
5440: ** requested from the underlying operating system, a number which
5441: ** might be greater than or equal to the argument, but not less
5442: ** than the argument.
5443: */
5444: static int unixSleep(sqlite3_vfs *NotUsed, int microseconds){
5445: #if OS_VXWORKS
5446: struct timespec sp;
5447:
5448: sp.tv_sec = microseconds / 1000000;
5449: sp.tv_nsec = (microseconds % 1000000) * 1000;
5450: nanosleep(&sp, NULL);
5451: UNUSED_PARAMETER(NotUsed);
5452: return microseconds;
5453: #elif defined(HAVE_USLEEP) && HAVE_USLEEP
5454: usleep(microseconds);
5455: UNUSED_PARAMETER(NotUsed);
5456: return microseconds;
5457: #else
5458: int seconds = (microseconds+999999)/1000000;
5459: sleep(seconds);
5460: UNUSED_PARAMETER(NotUsed);
5461: return seconds*1000000;
5462: #endif
5463: }
5464:
5465: /*
5466: ** The following variable, if set to a non-zero value, is interpreted as
5467: ** the number of seconds since 1970 and is used to set the result of
5468: ** sqlite3OsCurrentTime() during testing.
5469: */
5470: #ifdef SQLITE_TEST
5471: int sqlite3_current_time = 0; /* Fake system time in seconds since 1970. */
5472: #endif
5473:
5474: /*
5475: ** Find the current time (in Universal Coordinated Time). Write into *piNow
5476: ** the current time and date as a Julian Day number times 86_400_000. In
5477: ** other words, write into *piNow the number of milliseconds since the Julian
5478: ** epoch of noon in Greenwich on November 24, 4714 B.C according to the
5479: ** proleptic Gregorian calendar.
5480: **
5481: ** On success, return SQLITE_OK. Return SQLITE_ERROR if the time and date
5482: ** cannot be found.
5483: */
5484: static int unixCurrentTimeInt64(sqlite3_vfs *NotUsed, sqlite3_int64 *piNow){
5485: static const sqlite3_int64 unixEpoch = 24405875*(sqlite3_int64)8640000;
5486: int rc = SQLITE_OK;
5487: #if defined(NO_GETTOD)
5488: time_t t;
5489: time(&t);
5490: *piNow = ((sqlite3_int64)t)*1000 + unixEpoch;
5491: #elif OS_VXWORKS
5492: struct timespec sNow;
5493: clock_gettime(CLOCK_REALTIME, &sNow);
5494: *piNow = unixEpoch + 1000*(sqlite3_int64)sNow.tv_sec + sNow.tv_nsec/1000000;
5495: #else
5496: struct timeval sNow;
5497: if( gettimeofday(&sNow, 0)==0 ){
5498: *piNow = unixEpoch + 1000*(sqlite3_int64)sNow.tv_sec + sNow.tv_usec/1000;
5499: }else{
5500: rc = SQLITE_ERROR;
5501: }
5502: #endif
5503:
5504: #ifdef SQLITE_TEST
5505: if( sqlite3_current_time ){
5506: *piNow = 1000*(sqlite3_int64)sqlite3_current_time + unixEpoch;
5507: }
5508: #endif
5509: UNUSED_PARAMETER(NotUsed);
5510: return rc;
5511: }
5512:
5513: /*
5514: ** Find the current time (in Universal Coordinated Time). Write the
5515: ** current time and date as a Julian Day number into *prNow and
5516: ** return 0. Return 1 if the time and date cannot be found.
5517: */
5518: static int unixCurrentTime(sqlite3_vfs *NotUsed, double *prNow){
5519: sqlite3_int64 i = 0;
5520: int rc;
5521: UNUSED_PARAMETER(NotUsed);
5522: rc = unixCurrentTimeInt64(0, &i);
5523: *prNow = i/86400000.0;
5524: return rc;
5525: }
5526:
5527: /*
5528: ** We added the xGetLastError() method with the intention of providing
5529: ** better low-level error messages when operating-system problems come up
5530: ** during SQLite operation. But so far, none of that has been implemented
5531: ** in the core. So this routine is never called. For now, it is merely
5532: ** a place-holder.
5533: */
5534: static int unixGetLastError(sqlite3_vfs *NotUsed, int NotUsed2, char *NotUsed3){
5535: UNUSED_PARAMETER(NotUsed);
5536: UNUSED_PARAMETER(NotUsed2);
5537: UNUSED_PARAMETER(NotUsed3);
5538: return 0;
5539: }
5540:
5541:
5542: /*
5543: ************************ End of sqlite3_vfs methods ***************************
5544: ******************************************************************************/
5545:
5546: /******************************************************************************
5547: ************************** Begin Proxy Locking ********************************
5548: **
5549: ** Proxy locking is a "uber-locking-method" in this sense: It uses the
5550: ** other locking methods on secondary lock files. Proxy locking is a
5551: ** meta-layer over top of the primitive locking implemented above. For
5552: ** this reason, the division that implements of proxy locking is deferred
5553: ** until late in the file (here) after all of the other I/O methods have
5554: ** been defined - so that the primitive locking methods are available
5555: ** as services to help with the implementation of proxy locking.
5556: **
5557: ****
5558: **
5559: ** The default locking schemes in SQLite use byte-range locks on the
5560: ** database file to coordinate safe, concurrent access by multiple readers
5561: ** and writers [http://sqlite.org/lockingv3.html]. The five file locking
5562: ** states (UNLOCKED, PENDING, SHARED, RESERVED, EXCLUSIVE) are implemented
5563: ** as POSIX read & write locks over fixed set of locations (via fsctl),
5564: ** on AFP and SMB only exclusive byte-range locks are available via fsctl
5565: ** with _IOWR('z', 23, struct ByteRangeLockPB2) to track the same 5 states.
5566: ** To simulate a F_RDLCK on the shared range, on AFP a randomly selected
5567: ** address in the shared range is taken for a SHARED lock, the entire
5568: ** shared range is taken for an EXCLUSIVE lock):
5569: **
5570: ** PENDING_BYTE 0x40000000
5571: ** RESERVED_BYTE 0x40000001
5572: ** SHARED_RANGE 0x40000002 -> 0x40000200
5573: **
5574: ** This works well on the local file system, but shows a nearly 100x
5575: ** slowdown in read performance on AFP because the AFP client disables
5576: ** the read cache when byte-range locks are present. Enabling the read
5577: ** cache exposes a cache coherency problem that is present on all OS X
5578: ** supported network file systems. NFS and AFP both observe the
5579: ** close-to-open semantics for ensuring cache coherency
5580: ** [http://nfs.sourceforge.net/#faq_a8], which does not effectively
5581: ** address the requirements for concurrent database access by multiple
5582: ** readers and writers
5583: ** [http://www.nabble.com/SQLite-on-NFS-cache-coherency-td15655701.html].
5584: **
5585: ** To address the performance and cache coherency issues, proxy file locking
5586: ** changes the way database access is controlled by limiting access to a
5587: ** single host at a time and moving file locks off of the database file
5588: ** and onto a proxy file on the local file system.
5589: **
5590: **
5591: ** Using proxy locks
5592: ** -----------------
5593: **
5594: ** C APIs
5595: **
5596: ** sqlite3_file_control(db, dbname, SQLITE_SET_LOCKPROXYFILE,
5597: ** <proxy_path> | ":auto:");
5598: ** sqlite3_file_control(db, dbname, SQLITE_GET_LOCKPROXYFILE, &<proxy_path>);
5599: **
5600: **
5601: ** SQL pragmas
5602: **
5603: ** PRAGMA [database.]lock_proxy_file=<proxy_path> | :auto:
5604: ** PRAGMA [database.]lock_proxy_file
5605: **
5606: ** Specifying ":auto:" means that if there is a conch file with a matching
5607: ** host ID in it, the proxy path in the conch file will be used, otherwise
5608: ** a proxy path based on the user's temp dir
5609: ** (via confstr(_CS_DARWIN_USER_TEMP_DIR,...)) will be used and the
5610: ** actual proxy file name is generated from the name and path of the
5611: ** database file. For example:
5612: **
5613: ** For database path "/Users/me/foo.db"
5614: ** The lock path will be "<tmpdir>/sqliteplocks/_Users_me_foo.db:auto:")
5615: **
5616: ** Once a lock proxy is configured for a database connection, it can not
5617: ** be removed, however it may be switched to a different proxy path via
5618: ** the above APIs (assuming the conch file is not being held by another
5619: ** connection or process).
5620: **
5621: **
5622: ** How proxy locking works
5623: ** -----------------------
5624: **
5625: ** Proxy file locking relies primarily on two new supporting files:
5626: **
5627: ** * conch file to limit access to the database file to a single host
5628: ** at a time
5629: **
5630: ** * proxy file to act as a proxy for the advisory locks normally
5631: ** taken on the database
5632: **
5633: ** The conch file - to use a proxy file, sqlite must first "hold the conch"
5634: ** by taking an sqlite-style shared lock on the conch file, reading the
5635: ** contents and comparing the host's unique host ID (see below) and lock
5636: ** proxy path against the values stored in the conch. The conch file is
5637: ** stored in the same directory as the database file and the file name
5638: ** is patterned after the database file name as ".<databasename>-conch".
5639: ** If the conch file does not exist, or it's contents do not match the
5640: ** host ID and/or proxy path, then the lock is escalated to an exclusive
5641: ** lock and the conch file contents is updated with the host ID and proxy
5642: ** path and the lock is downgraded to a shared lock again. If the conch
5643: ** is held by another process (with a shared lock), the exclusive lock
5644: ** will fail and SQLITE_BUSY is returned.
5645: **
5646: ** The proxy file - a single-byte file used for all advisory file locks
5647: ** normally taken on the database file. This allows for safe sharing
5648: ** of the database file for multiple readers and writers on the same
5649: ** host (the conch ensures that they all use the same local lock file).
5650: **
5651: ** Requesting the lock proxy does not immediately take the conch, it is
5652: ** only taken when the first request to lock database file is made.
5653: ** This matches the semantics of the traditional locking behavior, where
5654: ** opening a connection to a database file does not take a lock on it.
5655: ** The shared lock and an open file descriptor are maintained until
5656: ** the connection to the database is closed.
5657: **
5658: ** The proxy file and the lock file are never deleted so they only need
5659: ** to be created the first time they are used.
5660: **
5661: ** Configuration options
5662: ** ---------------------
5663: **
5664: ** SQLITE_PREFER_PROXY_LOCKING
5665: **
5666: ** Database files accessed on non-local file systems are
5667: ** automatically configured for proxy locking, lock files are
5668: ** named automatically using the same logic as
5669: ** PRAGMA lock_proxy_file=":auto:"
5670: **
5671: ** SQLITE_PROXY_DEBUG
5672: **
5673: ** Enables the logging of error messages during host id file
5674: ** retrieval and creation
5675: **
5676: ** LOCKPROXYDIR
5677: **
5678: ** Overrides the default directory used for lock proxy files that
5679: ** are named automatically via the ":auto:" setting
5680: **
5681: ** SQLITE_DEFAULT_PROXYDIR_PERMISSIONS
5682: **
5683: ** Permissions to use when creating a directory for storing the
5684: ** lock proxy files, only used when LOCKPROXYDIR is not set.
5685: **
5686: **
5687: ** As mentioned above, when compiled with SQLITE_PREFER_PROXY_LOCKING,
5688: ** setting the environment variable SQLITE_FORCE_PROXY_LOCKING to 1 will
5689: ** force proxy locking to be used for every database file opened, and 0
5690: ** will force automatic proxy locking to be disabled for all database
5691: ** files (explicity calling the SQLITE_SET_LOCKPROXYFILE pragma or
5692: ** sqlite_file_control API is not affected by SQLITE_FORCE_PROXY_LOCKING).
5693: */
5694:
5695: /*
5696: ** Proxy locking is only available on MacOSX
5697: */
5698: #if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE
5699:
5700: /*
5701: ** The proxyLockingContext has the path and file structures for the remote
5702: ** and local proxy files in it
5703: */
5704: typedef struct proxyLockingContext proxyLockingContext;
5705: struct proxyLockingContext {
5706: unixFile *conchFile; /* Open conch file */
5707: char *conchFilePath; /* Name of the conch file */
5708: unixFile *lockProxy; /* Open proxy lock file */
5709: char *lockProxyPath; /* Name of the proxy lock file */
5710: char *dbPath; /* Name of the open file */
5711: int conchHeld; /* 1 if the conch is held, -1 if lockless */
5712: void *oldLockingContext; /* Original lockingcontext to restore on close */
5713: sqlite3_io_methods const *pOldMethod; /* Original I/O methods for close */
5714: };
5715:
5716: /*
5717: ** The proxy lock file path for the database at dbPath is written into lPath,
5718: ** which must point to valid, writable memory large enough for a maxLen length
5719: ** file path.
5720: */
5721: static int proxyGetLockPath(const char *dbPath, char *lPath, size_t maxLen){
5722: int len;
5723: int dbLen;
5724: int i;
5725:
5726: #ifdef LOCKPROXYDIR
5727: len = strlcpy(lPath, LOCKPROXYDIR, maxLen);
5728: #else
5729: # ifdef _CS_DARWIN_USER_TEMP_DIR
5730: {
5731: if( !confstr(_CS_DARWIN_USER_TEMP_DIR, lPath, maxLen) ){
5732: OSTRACE(("GETLOCKPATH failed %s errno=%d pid=%d\n",
5733: lPath, errno, getpid()));
5734: return SQLITE_IOERR_LOCK;
5735: }
5736: len = strlcat(lPath, "sqliteplocks", maxLen);
5737: }
5738: # else
5739: len = strlcpy(lPath, "/tmp/", maxLen);
5740: # endif
5741: #endif
5742:
5743: if( lPath[len-1]!='/' ){
5744: len = strlcat(lPath, "/", maxLen);
5745: }
5746:
5747: /* transform the db path to a unique cache name */
5748: dbLen = (int)strlen(dbPath);
5749: for( i=0; i<dbLen && (i+len+7)<(int)maxLen; i++){
5750: char c = dbPath[i];
5751: lPath[i+len] = (c=='/')?'_':c;
5752: }
5753: lPath[i+len]='\0';
5754: strlcat(lPath, ":auto:", maxLen);
5755: OSTRACE(("GETLOCKPATH proxy lock path=%s pid=%d\n", lPath, getpid()));
5756: return SQLITE_OK;
5757: }
5758:
5759: /*
5760: ** Creates the lock file and any missing directories in lockPath
5761: */
5762: static int proxyCreateLockPath(const char *lockPath){
5763: int i, len;
5764: char buf[MAXPATHLEN];
5765: int start = 0;
5766:
5767: assert(lockPath!=NULL);
5768: /* try to create all the intermediate directories */
5769: len = (int)strlen(lockPath);
5770: buf[0] = lockPath[0];
5771: for( i=1; i<len; i++ ){
5772: if( lockPath[i] == '/' && (i - start > 0) ){
5773: /* only mkdir if leaf dir != "." or "/" or ".." */
5774: if( i-start>2 || (i-start==1 && buf[start] != '.' && buf[start] != '/')
5775: || (i-start==2 && buf[start] != '.' && buf[start+1] != '.') ){
5776: buf[i]='\0';
5777: if( osMkdir(buf, SQLITE_DEFAULT_PROXYDIR_PERMISSIONS) ){
5778: int err=errno;
5779: if( err!=EEXIST ) {
5780: OSTRACE(("CREATELOCKPATH FAILED creating %s, "
5781: "'%s' proxy lock path=%s pid=%d\n",
5782: buf, strerror(err), lockPath, getpid()));
5783: return err;
5784: }
5785: }
5786: }
5787: start=i+1;
5788: }
5789: buf[i] = lockPath[i];
5790: }
5791: OSTRACE(("CREATELOCKPATH proxy lock path=%s pid=%d\n", lockPath, getpid()));
5792: return 0;
5793: }
5794:
5795: /*
5796: ** Create a new VFS file descriptor (stored in memory obtained from
5797: ** sqlite3_malloc) and open the file named "path" in the file descriptor.
5798: **
5799: ** The caller is responsible not only for closing the file descriptor
5800: ** but also for freeing the memory associated with the file descriptor.
5801: */
5802: static int proxyCreateUnixFile(
5803: const char *path, /* path for the new unixFile */
5804: unixFile **ppFile, /* unixFile created and returned by ref */
5805: int islockfile /* if non zero missing dirs will be created */
5806: ) {
5807: int fd = -1;
5808: unixFile *pNew;
5809: int rc = SQLITE_OK;
5810: int openFlags = O_RDWR | O_CREAT;
5811: sqlite3_vfs dummyVfs;
5812: int terrno = 0;
5813: UnixUnusedFd *pUnused = NULL;
5814:
5815: /* 1. first try to open/create the file
5816: ** 2. if that fails, and this is a lock file (not-conch), try creating
5817: ** the parent directories and then try again.
5818: ** 3. if that fails, try to open the file read-only
5819: ** otherwise return BUSY (if lock file) or CANTOPEN for the conch file
5820: */
5821: pUnused = findReusableFd(path, openFlags);
5822: if( pUnused ){
5823: fd = pUnused->fd;
5824: }else{
5825: pUnused = sqlite3_malloc(sizeof(*pUnused));
5826: if( !pUnused ){
5827: return SQLITE_NOMEM;
5828: }
5829: }
5830: if( fd<0 ){
5831: fd = robust_open(path, openFlags, SQLITE_DEFAULT_FILE_PERMISSIONS);
5832: terrno = errno;
5833: if( fd<0 && errno==ENOENT && islockfile ){
5834: if( proxyCreateLockPath(path) == SQLITE_OK ){
5835: fd = robust_open(path, openFlags, SQLITE_DEFAULT_FILE_PERMISSIONS);
5836: }
5837: }
5838: }
5839: if( fd<0 ){
5840: openFlags = O_RDONLY;
5841: fd = robust_open(path, openFlags, SQLITE_DEFAULT_FILE_PERMISSIONS);
5842: terrno = errno;
5843: }
5844: if( fd<0 ){
5845: if( islockfile ){
5846: return SQLITE_BUSY;
5847: }
5848: switch (terrno) {
5849: case EACCES:
5850: return SQLITE_PERM;
5851: case EIO:
5852: return SQLITE_IOERR_LOCK; /* even though it is the conch */
5853: default:
5854: return SQLITE_CANTOPEN_BKPT;
5855: }
5856: }
5857:
5858: pNew = (unixFile *)sqlite3_malloc(sizeof(*pNew));
5859: if( pNew==NULL ){
5860: rc = SQLITE_NOMEM;
5861: goto end_create_proxy;
5862: }
5863: memset(pNew, 0, sizeof(unixFile));
5864: pNew->openFlags = openFlags;
5865: memset(&dummyVfs, 0, sizeof(dummyVfs));
5866: dummyVfs.pAppData = (void*)&autolockIoFinder;
5867: dummyVfs.zName = "dummy";
5868: pUnused->fd = fd;
5869: pUnused->flags = openFlags;
5870: pNew->pUnused = pUnused;
5871:
5872: rc = fillInUnixFile(&dummyVfs, fd, (sqlite3_file*)pNew, path, 0);
5873: if( rc==SQLITE_OK ){
5874: *ppFile = pNew;
5875: return SQLITE_OK;
5876: }
5877: end_create_proxy:
5878: robust_close(pNew, fd, __LINE__);
5879: sqlite3_free(pNew);
5880: sqlite3_free(pUnused);
5881: return rc;
5882: }
5883:
5884: #ifdef SQLITE_TEST
5885: /* simulate multiple hosts by creating unique hostid file paths */
5886: int sqlite3_hostid_num = 0;
5887: #endif
5888:
5889: #define PROXY_HOSTIDLEN 16 /* conch file host id length */
5890:
5891: /* Not always defined in the headers as it ought to be */
5892: extern int gethostuuid(uuid_t id, const struct timespec *wait);
5893:
5894: /* get the host ID via gethostuuid(), pHostID must point to PROXY_HOSTIDLEN
5895: ** bytes of writable memory.
5896: */
5897: static int proxyGetHostID(unsigned char *pHostID, int *pError){
5898: assert(PROXY_HOSTIDLEN == sizeof(uuid_t));
5899: memset(pHostID, 0, PROXY_HOSTIDLEN);
5900: #if defined(__MAX_OS_X_VERSION_MIN_REQUIRED)\
5901: && __MAC_OS_X_VERSION_MIN_REQUIRED<1050
5902: {
5903: static const struct timespec timeout = {1, 0}; /* 1 sec timeout */
5904: if( gethostuuid(pHostID, &timeout) ){
5905: int err = errno;
5906: if( pError ){
5907: *pError = err;
5908: }
5909: return SQLITE_IOERR;
5910: }
5911: }
5912: #else
5913: UNUSED_PARAMETER(pError);
5914: #endif
5915: #ifdef SQLITE_TEST
5916: /* simulate multiple hosts by creating unique hostid file paths */
5917: if( sqlite3_hostid_num != 0){
5918: pHostID[0] = (char)(pHostID[0] + (char)(sqlite3_hostid_num & 0xFF));
5919: }
5920: #endif
5921:
5922: return SQLITE_OK;
5923: }
5924:
5925: /* The conch file contains the header, host id and lock file path
5926: */
5927: #define PROXY_CONCHVERSION 2 /* 1-byte header, 16-byte host id, path */
5928: #define PROXY_HEADERLEN 1 /* conch file header length */
5929: #define PROXY_PATHINDEX (PROXY_HEADERLEN+PROXY_HOSTIDLEN)
5930: #define PROXY_MAXCONCHLEN (PROXY_HEADERLEN+PROXY_HOSTIDLEN+MAXPATHLEN)
5931:
5932: /*
5933: ** Takes an open conch file, copies the contents to a new path and then moves
5934: ** it back. The newly created file's file descriptor is assigned to the
5935: ** conch file structure and finally the original conch file descriptor is
5936: ** closed. Returns zero if successful.
5937: */
5938: static int proxyBreakConchLock(unixFile *pFile, uuid_t myHostID){
5939: proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
5940: unixFile *conchFile = pCtx->conchFile;
5941: char tPath[MAXPATHLEN];
5942: char buf[PROXY_MAXCONCHLEN];
5943: char *cPath = pCtx->conchFilePath;
5944: size_t readLen = 0;
5945: size_t pathLen = 0;
5946: char errmsg[64] = "";
5947: int fd = -1;
5948: int rc = -1;
5949: UNUSED_PARAMETER(myHostID);
5950:
5951: /* create a new path by replace the trailing '-conch' with '-break' */
5952: pathLen = strlcpy(tPath, cPath, MAXPATHLEN);
5953: if( pathLen>MAXPATHLEN || pathLen<6 ||
5954: (strlcpy(&tPath[pathLen-5], "break", 6) != 5) ){
5955: sqlite3_snprintf(sizeof(errmsg),errmsg,"path error (len %d)",(int)pathLen);
5956: goto end_breaklock;
5957: }
5958: /* read the conch content */
5959: readLen = osPread(conchFile->h, buf, PROXY_MAXCONCHLEN, 0);
5960: if( readLen<PROXY_PATHINDEX ){
5961: sqlite3_snprintf(sizeof(errmsg),errmsg,"read error (len %d)",(int)readLen);
5962: goto end_breaklock;
5963: }
5964: /* write it out to the temporary break file */
5965: fd = robust_open(tPath, (O_RDWR|O_CREAT|O_EXCL),
5966: SQLITE_DEFAULT_FILE_PERMISSIONS);
5967: if( fd<0 ){
5968: sqlite3_snprintf(sizeof(errmsg), errmsg, "create failed (%d)", errno);
5969: goto end_breaklock;
5970: }
5971: if( osPwrite(fd, buf, readLen, 0) != (ssize_t)readLen ){
5972: sqlite3_snprintf(sizeof(errmsg), errmsg, "write failed (%d)", errno);
5973: goto end_breaklock;
5974: }
5975: if( rename(tPath, cPath) ){
5976: sqlite3_snprintf(sizeof(errmsg), errmsg, "rename failed (%d)", errno);
5977: goto end_breaklock;
5978: }
5979: rc = 0;
5980: fprintf(stderr, "broke stale lock on %s\n", cPath);
5981: robust_close(pFile, conchFile->h, __LINE__);
5982: conchFile->h = fd;
5983: conchFile->openFlags = O_RDWR | O_CREAT;
5984:
5985: end_breaklock:
5986: if( rc ){
5987: if( fd>=0 ){
5988: osUnlink(tPath);
5989: robust_close(pFile, fd, __LINE__);
5990: }
5991: fprintf(stderr, "failed to break stale lock on %s, %s\n", cPath, errmsg);
5992: }
5993: return rc;
5994: }
5995:
5996: /* Take the requested lock on the conch file and break a stale lock if the
5997: ** host id matches.
5998: */
5999: static int proxyConchLock(unixFile *pFile, uuid_t myHostID, int lockType){
6000: proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
6001: unixFile *conchFile = pCtx->conchFile;
6002: int rc = SQLITE_OK;
6003: int nTries = 0;
6004: struct timespec conchModTime;
6005:
6006: memset(&conchModTime, 0, sizeof(conchModTime));
6007: do {
6008: rc = conchFile->pMethod->xLock((sqlite3_file*)conchFile, lockType);
6009: nTries ++;
6010: if( rc==SQLITE_BUSY ){
6011: /* If the lock failed (busy):
6012: * 1st try: get the mod time of the conch, wait 0.5s and try again.
6013: * 2nd try: fail if the mod time changed or host id is different, wait
6014: * 10 sec and try again
6015: * 3rd try: break the lock unless the mod time has changed.
6016: */
6017: struct stat buf;
6018: if( osFstat(conchFile->h, &buf) ){
6019: pFile->lastErrno = errno;
6020: return SQLITE_IOERR_LOCK;
6021: }
6022:
6023: if( nTries==1 ){
6024: conchModTime = buf.st_mtimespec;
6025: usleep(500000); /* wait 0.5 sec and try the lock again*/
6026: continue;
6027: }
6028:
6029: assert( nTries>1 );
6030: if( conchModTime.tv_sec != buf.st_mtimespec.tv_sec ||
6031: conchModTime.tv_nsec != buf.st_mtimespec.tv_nsec ){
6032: return SQLITE_BUSY;
6033: }
6034:
6035: if( nTries==2 ){
6036: char tBuf[PROXY_MAXCONCHLEN];
6037: int len = osPread(conchFile->h, tBuf, PROXY_MAXCONCHLEN, 0);
6038: if( len<0 ){
6039: pFile->lastErrno = errno;
6040: return SQLITE_IOERR_LOCK;
6041: }
6042: if( len>PROXY_PATHINDEX && tBuf[0]==(char)PROXY_CONCHVERSION){
6043: /* don't break the lock if the host id doesn't match */
6044: if( 0!=memcmp(&tBuf[PROXY_HEADERLEN], myHostID, PROXY_HOSTIDLEN) ){
6045: return SQLITE_BUSY;
6046: }
6047: }else{
6048: /* don't break the lock on short read or a version mismatch */
6049: return SQLITE_BUSY;
6050: }
6051: usleep(10000000); /* wait 10 sec and try the lock again */
6052: continue;
6053: }
6054:
6055: assert( nTries==3 );
6056: if( 0==proxyBreakConchLock(pFile, myHostID) ){
6057: rc = SQLITE_OK;
6058: if( lockType==EXCLUSIVE_LOCK ){
6059: rc = conchFile->pMethod->xLock((sqlite3_file*)conchFile, SHARED_LOCK);
6060: }
6061: if( !rc ){
6062: rc = conchFile->pMethod->xLock((sqlite3_file*)conchFile, lockType);
6063: }
6064: }
6065: }
6066: } while( rc==SQLITE_BUSY && nTries<3 );
6067:
6068: return rc;
6069: }
6070:
6071: /* Takes the conch by taking a shared lock and read the contents conch, if
6072: ** lockPath is non-NULL, the host ID and lock file path must match. A NULL
6073: ** lockPath means that the lockPath in the conch file will be used if the
6074: ** host IDs match, or a new lock path will be generated automatically
6075: ** and written to the conch file.
6076: */
6077: static int proxyTakeConch(unixFile *pFile){
6078: proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
6079:
6080: if( pCtx->conchHeld!=0 ){
6081: return SQLITE_OK;
6082: }else{
6083: unixFile *conchFile = pCtx->conchFile;
6084: uuid_t myHostID;
6085: int pError = 0;
6086: char readBuf[PROXY_MAXCONCHLEN];
6087: char lockPath[MAXPATHLEN];
6088: char *tempLockPath = NULL;
6089: int rc = SQLITE_OK;
6090: int createConch = 0;
6091: int hostIdMatch = 0;
6092: int readLen = 0;
6093: int tryOldLockPath = 0;
6094: int forceNewLockPath = 0;
6095:
6096: OSTRACE(("TAKECONCH %d for %s pid=%d\n", conchFile->h,
6097: (pCtx->lockProxyPath ? pCtx->lockProxyPath : ":auto:"), getpid()));
6098:
6099: rc = proxyGetHostID(myHostID, &pError);
6100: if( (rc&0xff)==SQLITE_IOERR ){
6101: pFile->lastErrno = pError;
6102: goto end_takeconch;
6103: }
6104: rc = proxyConchLock(pFile, myHostID, SHARED_LOCK);
6105: if( rc!=SQLITE_OK ){
6106: goto end_takeconch;
6107: }
6108: /* read the existing conch file */
6109: readLen = seekAndRead((unixFile*)conchFile, 0, readBuf, PROXY_MAXCONCHLEN);
6110: if( readLen<0 ){
6111: /* I/O error: lastErrno set by seekAndRead */
6112: pFile->lastErrno = conchFile->lastErrno;
6113: rc = SQLITE_IOERR_READ;
6114: goto end_takeconch;
6115: }else if( readLen<=(PROXY_HEADERLEN+PROXY_HOSTIDLEN) ||
6116: readBuf[0]!=(char)PROXY_CONCHVERSION ){
6117: /* a short read or version format mismatch means we need to create a new
6118: ** conch file.
6119: */
6120: createConch = 1;
6121: }
6122: /* if the host id matches and the lock path already exists in the conch
6123: ** we'll try to use the path there, if we can't open that path, we'll
6124: ** retry with a new auto-generated path
6125: */
6126: do { /* in case we need to try again for an :auto: named lock file */
6127:
6128: if( !createConch && !forceNewLockPath ){
6129: hostIdMatch = !memcmp(&readBuf[PROXY_HEADERLEN], myHostID,
6130: PROXY_HOSTIDLEN);
6131: /* if the conch has data compare the contents */
6132: if( !pCtx->lockProxyPath ){
6133: /* for auto-named local lock file, just check the host ID and we'll
6134: ** use the local lock file path that's already in there
6135: */
6136: if( hostIdMatch ){
6137: size_t pathLen = (readLen - PROXY_PATHINDEX);
6138:
6139: if( pathLen>=MAXPATHLEN ){
6140: pathLen=MAXPATHLEN-1;
6141: }
6142: memcpy(lockPath, &readBuf[PROXY_PATHINDEX], pathLen);
6143: lockPath[pathLen] = 0;
6144: tempLockPath = lockPath;
6145: tryOldLockPath = 1;
6146: /* create a copy of the lock path if the conch is taken */
6147: goto end_takeconch;
6148: }
6149: }else if( hostIdMatch
6150: && !strncmp(pCtx->lockProxyPath, &readBuf[PROXY_PATHINDEX],
6151: readLen-PROXY_PATHINDEX)
6152: ){
6153: /* conch host and lock path match */
6154: goto end_takeconch;
6155: }
6156: }
6157:
6158: /* if the conch isn't writable and doesn't match, we can't take it */
6159: if( (conchFile->openFlags&O_RDWR) == 0 ){
6160: rc = SQLITE_BUSY;
6161: goto end_takeconch;
6162: }
6163:
6164: /* either the conch didn't match or we need to create a new one */
6165: if( !pCtx->lockProxyPath ){
6166: proxyGetLockPath(pCtx->dbPath, lockPath, MAXPATHLEN);
6167: tempLockPath = lockPath;
6168: /* create a copy of the lock path _only_ if the conch is taken */
6169: }
6170:
6171: /* update conch with host and path (this will fail if other process
6172: ** has a shared lock already), if the host id matches, use the big
6173: ** stick.
6174: */
6175: futimes(conchFile->h, NULL);
6176: if( hostIdMatch && !createConch ){
6177: if( conchFile->pInode && conchFile->pInode->nShared>1 ){
6178: /* We are trying for an exclusive lock but another thread in this
6179: ** same process is still holding a shared lock. */
6180: rc = SQLITE_BUSY;
6181: } else {
6182: rc = proxyConchLock(pFile, myHostID, EXCLUSIVE_LOCK);
6183: }
6184: }else{
6185: rc = conchFile->pMethod->xLock((sqlite3_file*)conchFile, EXCLUSIVE_LOCK);
6186: }
6187: if( rc==SQLITE_OK ){
6188: char writeBuffer[PROXY_MAXCONCHLEN];
6189: int writeSize = 0;
6190:
6191: writeBuffer[0] = (char)PROXY_CONCHVERSION;
6192: memcpy(&writeBuffer[PROXY_HEADERLEN], myHostID, PROXY_HOSTIDLEN);
6193: if( pCtx->lockProxyPath!=NULL ){
6194: strlcpy(&writeBuffer[PROXY_PATHINDEX], pCtx->lockProxyPath, MAXPATHLEN);
6195: }else{
6196: strlcpy(&writeBuffer[PROXY_PATHINDEX], tempLockPath, MAXPATHLEN);
6197: }
6198: writeSize = PROXY_PATHINDEX + strlen(&writeBuffer[PROXY_PATHINDEX]);
6199: robust_ftruncate(conchFile->h, writeSize);
6200: rc = unixWrite((sqlite3_file *)conchFile, writeBuffer, writeSize, 0);
6201: fsync(conchFile->h);
6202: /* If we created a new conch file (not just updated the contents of a
6203: ** valid conch file), try to match the permissions of the database
6204: */
6205: if( rc==SQLITE_OK && createConch ){
6206: struct stat buf;
6207: int err = osFstat(pFile->h, &buf);
6208: if( err==0 ){
6209: mode_t cmode = buf.st_mode&(S_IRUSR|S_IWUSR | S_IRGRP|S_IWGRP |
6210: S_IROTH|S_IWOTH);
6211: /* try to match the database file R/W permissions, ignore failure */
6212: #ifndef SQLITE_PROXY_DEBUG
6213: osFchmod(conchFile->h, cmode);
6214: #else
6215: do{
6216: rc = osFchmod(conchFile->h, cmode);
6217: }while( rc==(-1) && errno==EINTR );
6218: if( rc!=0 ){
6219: int code = errno;
6220: fprintf(stderr, "fchmod %o FAILED with %d %s\n",
6221: cmode, code, strerror(code));
6222: } else {
6223: fprintf(stderr, "fchmod %o SUCCEDED\n",cmode);
6224: }
6225: }else{
6226: int code = errno;
6227: fprintf(stderr, "STAT FAILED[%d] with %d %s\n",
6228: err, code, strerror(code));
6229: #endif
6230: }
6231: }
6232: }
6233: conchFile->pMethod->xUnlock((sqlite3_file*)conchFile, SHARED_LOCK);
6234:
6235: end_takeconch:
6236: OSTRACE(("TRANSPROXY: CLOSE %d\n", pFile->h));
6237: if( rc==SQLITE_OK && pFile->openFlags ){
6238: int fd;
6239: if( pFile->h>=0 ){
6240: robust_close(pFile, pFile->h, __LINE__);
6241: }
6242: pFile->h = -1;
6243: fd = robust_open(pCtx->dbPath, pFile->openFlags,
6244: SQLITE_DEFAULT_FILE_PERMISSIONS);
6245: OSTRACE(("TRANSPROXY: OPEN %d\n", fd));
6246: if( fd>=0 ){
6247: pFile->h = fd;
6248: }else{
6249: rc=SQLITE_CANTOPEN_BKPT; /* SQLITE_BUSY? proxyTakeConch called
6250: during locking */
6251: }
6252: }
6253: if( rc==SQLITE_OK && !pCtx->lockProxy ){
6254: char *path = tempLockPath ? tempLockPath : pCtx->lockProxyPath;
6255: rc = proxyCreateUnixFile(path, &pCtx->lockProxy, 1);
6256: if( rc!=SQLITE_OK && rc!=SQLITE_NOMEM && tryOldLockPath ){
6257: /* we couldn't create the proxy lock file with the old lock file path
6258: ** so try again via auto-naming
6259: */
6260: forceNewLockPath = 1;
6261: tryOldLockPath = 0;
6262: continue; /* go back to the do {} while start point, try again */
6263: }
6264: }
6265: if( rc==SQLITE_OK ){
6266: /* Need to make a copy of path if we extracted the value
6267: ** from the conch file or the path was allocated on the stack
6268: */
6269: if( tempLockPath ){
6270: pCtx->lockProxyPath = sqlite3DbStrDup(0, tempLockPath);
6271: if( !pCtx->lockProxyPath ){
6272: rc = SQLITE_NOMEM;
6273: }
6274: }
6275: }
6276: if( rc==SQLITE_OK ){
6277: pCtx->conchHeld = 1;
6278:
6279: if( pCtx->lockProxy->pMethod == &afpIoMethods ){
6280: afpLockingContext *afpCtx;
6281: afpCtx = (afpLockingContext *)pCtx->lockProxy->lockingContext;
6282: afpCtx->dbPath = pCtx->lockProxyPath;
6283: }
6284: } else {
6285: conchFile->pMethod->xUnlock((sqlite3_file*)conchFile, NO_LOCK);
6286: }
6287: OSTRACE(("TAKECONCH %d %s\n", conchFile->h,
6288: rc==SQLITE_OK?"ok":"failed"));
6289: return rc;
6290: } while (1); /* in case we need to retry the :auto: lock file -
6291: ** we should never get here except via the 'continue' call. */
6292: }
6293: }
6294:
6295: /*
6296: ** If pFile holds a lock on a conch file, then release that lock.
6297: */
6298: static int proxyReleaseConch(unixFile *pFile){
6299: int rc = SQLITE_OK; /* Subroutine return code */
6300: proxyLockingContext *pCtx; /* The locking context for the proxy lock */
6301: unixFile *conchFile; /* Name of the conch file */
6302:
6303: pCtx = (proxyLockingContext *)pFile->lockingContext;
6304: conchFile = pCtx->conchFile;
6305: OSTRACE(("RELEASECONCH %d for %s pid=%d\n", conchFile->h,
6306: (pCtx->lockProxyPath ? pCtx->lockProxyPath : ":auto:"),
6307: getpid()));
6308: if( pCtx->conchHeld>0 ){
6309: rc = conchFile->pMethod->xUnlock((sqlite3_file*)conchFile, NO_LOCK);
6310: }
6311: pCtx->conchHeld = 0;
6312: OSTRACE(("RELEASECONCH %d %s\n", conchFile->h,
6313: (rc==SQLITE_OK ? "ok" : "failed")));
6314: return rc;
6315: }
6316:
6317: /*
6318: ** Given the name of a database file, compute the name of its conch file.
6319: ** Store the conch filename in memory obtained from sqlite3_malloc().
6320: ** Make *pConchPath point to the new name. Return SQLITE_OK on success
6321: ** or SQLITE_NOMEM if unable to obtain memory.
6322: **
6323: ** The caller is responsible for ensuring that the allocated memory
6324: ** space is eventually freed.
6325: **
6326: ** *pConchPath is set to NULL if a memory allocation error occurs.
6327: */
6328: static int proxyCreateConchPathname(char *dbPath, char **pConchPath){
6329: int i; /* Loop counter */
6330: int len = (int)strlen(dbPath); /* Length of database filename - dbPath */
6331: char *conchPath; /* buffer in which to construct conch name */
6332:
6333: /* Allocate space for the conch filename and initialize the name to
6334: ** the name of the original database file. */
6335: *pConchPath = conchPath = (char *)sqlite3_malloc(len + 8);
6336: if( conchPath==0 ){
6337: return SQLITE_NOMEM;
6338: }
6339: memcpy(conchPath, dbPath, len+1);
6340:
6341: /* now insert a "." before the last / character */
6342: for( i=(len-1); i>=0; i-- ){
6343: if( conchPath[i]=='/' ){
6344: i++;
6345: break;
6346: }
6347: }
6348: conchPath[i]='.';
6349: while ( i<len ){
6350: conchPath[i+1]=dbPath[i];
6351: i++;
6352: }
6353:
6354: /* append the "-conch" suffix to the file */
6355: memcpy(&conchPath[i+1], "-conch", 7);
6356: assert( (int)strlen(conchPath) == len+7 );
6357:
6358: return SQLITE_OK;
6359: }
6360:
6361:
6362: /* Takes a fully configured proxy locking-style unix file and switches
6363: ** the local lock file path
6364: */
6365: static int switchLockProxyPath(unixFile *pFile, const char *path) {
6366: proxyLockingContext *pCtx = (proxyLockingContext*)pFile->lockingContext;
6367: char *oldPath = pCtx->lockProxyPath;
6368: int rc = SQLITE_OK;
6369:
6370: if( pFile->eFileLock!=NO_LOCK ){
6371: return SQLITE_BUSY;
6372: }
6373:
6374: /* nothing to do if the path is NULL, :auto: or matches the existing path */
6375: if( !path || path[0]=='\0' || !strcmp(path, ":auto:") ||
6376: (oldPath && !strncmp(oldPath, path, MAXPATHLEN)) ){
6377: return SQLITE_OK;
6378: }else{
6379: unixFile *lockProxy = pCtx->lockProxy;
6380: pCtx->lockProxy=NULL;
6381: pCtx->conchHeld = 0;
6382: if( lockProxy!=NULL ){
6383: rc=lockProxy->pMethod->xClose((sqlite3_file *)lockProxy);
6384: if( rc ) return rc;
6385: sqlite3_free(lockProxy);
6386: }
6387: sqlite3_free(oldPath);
6388: pCtx->lockProxyPath = sqlite3DbStrDup(0, path);
6389: }
6390:
6391: return rc;
6392: }
6393:
6394: /*
6395: ** pFile is a file that has been opened by a prior xOpen call. dbPath
6396: ** is a string buffer at least MAXPATHLEN+1 characters in size.
6397: **
6398: ** This routine find the filename associated with pFile and writes it
6399: ** int dbPath.
6400: */
6401: static int proxyGetDbPathForUnixFile(unixFile *pFile, char *dbPath){
6402: #if defined(__APPLE__)
6403: if( pFile->pMethod == &afpIoMethods ){
6404: /* afp style keeps a reference to the db path in the filePath field
6405: ** of the struct */
6406: assert( (int)strlen((char*)pFile->lockingContext)<=MAXPATHLEN );
6407: strlcpy(dbPath, ((afpLockingContext *)pFile->lockingContext)->dbPath, MAXPATHLEN);
6408: } else
6409: #endif
6410: if( pFile->pMethod == &dotlockIoMethods ){
6411: /* dot lock style uses the locking context to store the dot lock
6412: ** file path */
6413: int len = strlen((char *)pFile->lockingContext) - strlen(DOTLOCK_SUFFIX);
6414: memcpy(dbPath, (char *)pFile->lockingContext, len + 1);
6415: }else{
6416: /* all other styles use the locking context to store the db file path */
6417: assert( strlen((char*)pFile->lockingContext)<=MAXPATHLEN );
6418: strlcpy(dbPath, (char *)pFile->lockingContext, MAXPATHLEN);
6419: }
6420: return SQLITE_OK;
6421: }
6422:
6423: /*
6424: ** Takes an already filled in unix file and alters it so all file locking
6425: ** will be performed on the local proxy lock file. The following fields
6426: ** are preserved in the locking context so that they can be restored and
6427: ** the unix structure properly cleaned up at close time:
6428: ** ->lockingContext
6429: ** ->pMethod
6430: */
6431: static int proxyTransformUnixFile(unixFile *pFile, const char *path) {
6432: proxyLockingContext *pCtx;
6433: char dbPath[MAXPATHLEN+1]; /* Name of the database file */
6434: char *lockPath=NULL;
6435: int rc = SQLITE_OK;
6436:
6437: if( pFile->eFileLock!=NO_LOCK ){
6438: return SQLITE_BUSY;
6439: }
6440: proxyGetDbPathForUnixFile(pFile, dbPath);
6441: if( !path || path[0]=='\0' || !strcmp(path, ":auto:") ){
6442: lockPath=NULL;
6443: }else{
6444: lockPath=(char *)path;
6445: }
6446:
6447: OSTRACE(("TRANSPROXY %d for %s pid=%d\n", pFile->h,
6448: (lockPath ? lockPath : ":auto:"), getpid()));
6449:
6450: pCtx = sqlite3_malloc( sizeof(*pCtx) );
6451: if( pCtx==0 ){
6452: return SQLITE_NOMEM;
6453: }
6454: memset(pCtx, 0, sizeof(*pCtx));
6455:
6456: rc = proxyCreateConchPathname(dbPath, &pCtx->conchFilePath);
6457: if( rc==SQLITE_OK ){
6458: rc = proxyCreateUnixFile(pCtx->conchFilePath, &pCtx->conchFile, 0);
6459: if( rc==SQLITE_CANTOPEN && ((pFile->openFlags&O_RDWR) == 0) ){
6460: /* if (a) the open flags are not O_RDWR, (b) the conch isn't there, and
6461: ** (c) the file system is read-only, then enable no-locking access.
6462: ** Ugh, since O_RDONLY==0x0000 we test for !O_RDWR since unixOpen asserts
6463: ** that openFlags will have only one of O_RDONLY or O_RDWR.
6464: */
6465: struct statfs fsInfo;
6466: struct stat conchInfo;
6467: int goLockless = 0;
6468:
6469: if( osStat(pCtx->conchFilePath, &conchInfo) == -1 ) {
6470: int err = errno;
6471: if( (err==ENOENT) && (statfs(dbPath, &fsInfo) != -1) ){
6472: goLockless = (fsInfo.f_flags&MNT_RDONLY) == MNT_RDONLY;
6473: }
6474: }
6475: if( goLockless ){
6476: pCtx->conchHeld = -1; /* read only FS/ lockless */
6477: rc = SQLITE_OK;
6478: }
6479: }
6480: }
6481: if( rc==SQLITE_OK && lockPath ){
6482: pCtx->lockProxyPath = sqlite3DbStrDup(0, lockPath);
6483: }
6484:
6485: if( rc==SQLITE_OK ){
6486: pCtx->dbPath = sqlite3DbStrDup(0, dbPath);
6487: if( pCtx->dbPath==NULL ){
6488: rc = SQLITE_NOMEM;
6489: }
6490: }
6491: if( rc==SQLITE_OK ){
6492: /* all memory is allocated, proxys are created and assigned,
6493: ** switch the locking context and pMethod then return.
6494: */
6495: pCtx->oldLockingContext = pFile->lockingContext;
6496: pFile->lockingContext = pCtx;
6497: pCtx->pOldMethod = pFile->pMethod;
6498: pFile->pMethod = &proxyIoMethods;
6499: }else{
6500: if( pCtx->conchFile ){
6501: pCtx->conchFile->pMethod->xClose((sqlite3_file *)pCtx->conchFile);
6502: sqlite3_free(pCtx->conchFile);
6503: }
6504: sqlite3DbFree(0, pCtx->lockProxyPath);
6505: sqlite3_free(pCtx->conchFilePath);
6506: sqlite3_free(pCtx);
6507: }
6508: OSTRACE(("TRANSPROXY %d %s\n", pFile->h,
6509: (rc==SQLITE_OK ? "ok" : "failed")));
6510: return rc;
6511: }
6512:
6513:
6514: /*
6515: ** This routine handles sqlite3_file_control() calls that are specific
6516: ** to proxy locking.
6517: */
6518: static int proxyFileControl(sqlite3_file *id, int op, void *pArg){
6519: switch( op ){
6520: case SQLITE_GET_LOCKPROXYFILE: {
6521: unixFile *pFile = (unixFile*)id;
6522: if( pFile->pMethod == &proxyIoMethods ){
6523: proxyLockingContext *pCtx = (proxyLockingContext*)pFile->lockingContext;
6524: proxyTakeConch(pFile);
6525: if( pCtx->lockProxyPath ){
6526: *(const char **)pArg = pCtx->lockProxyPath;
6527: }else{
6528: *(const char **)pArg = ":auto: (not held)";
6529: }
6530: } else {
6531: *(const char **)pArg = NULL;
6532: }
6533: return SQLITE_OK;
6534: }
6535: case SQLITE_SET_LOCKPROXYFILE: {
6536: unixFile *pFile = (unixFile*)id;
6537: int rc = SQLITE_OK;
6538: int isProxyStyle = (pFile->pMethod == &proxyIoMethods);
6539: if( pArg==NULL || (const char *)pArg==0 ){
6540: if( isProxyStyle ){
6541: /* turn off proxy locking - not supported */
6542: rc = SQLITE_ERROR /*SQLITE_PROTOCOL? SQLITE_MISUSE?*/;
6543: }else{
6544: /* turn off proxy locking - already off - NOOP */
6545: rc = SQLITE_OK;
6546: }
6547: }else{
6548: const char *proxyPath = (const char *)pArg;
6549: if( isProxyStyle ){
6550: proxyLockingContext *pCtx =
6551: (proxyLockingContext*)pFile->lockingContext;
6552: if( !strcmp(pArg, ":auto:")
6553: || (pCtx->lockProxyPath &&
6554: !strncmp(pCtx->lockProxyPath, proxyPath, MAXPATHLEN))
6555: ){
6556: rc = SQLITE_OK;
6557: }else{
6558: rc = switchLockProxyPath(pFile, proxyPath);
6559: }
6560: }else{
6561: /* turn on proxy file locking */
6562: rc = proxyTransformUnixFile(pFile, proxyPath);
6563: }
6564: }
6565: return rc;
6566: }
6567: default: {
6568: assert( 0 ); /* The call assures that only valid opcodes are sent */
6569: }
6570: }
6571: /*NOTREACHED*/
6572: return SQLITE_ERROR;
6573: }
6574:
6575: /*
6576: ** Within this division (the proxying locking implementation) the procedures
6577: ** above this point are all utilities. The lock-related methods of the
6578: ** proxy-locking sqlite3_io_method object follow.
6579: */
6580:
6581:
6582: /*
6583: ** This routine checks if there is a RESERVED lock held on the specified
6584: ** file by this or any other process. If such a lock is held, set *pResOut
6585: ** to a non-zero value otherwise *pResOut is set to zero. The return value
6586: ** is set to SQLITE_OK unless an I/O error occurs during lock checking.
6587: */
6588: static int proxyCheckReservedLock(sqlite3_file *id, int *pResOut) {
6589: unixFile *pFile = (unixFile*)id;
6590: int rc = proxyTakeConch(pFile);
6591: if( rc==SQLITE_OK ){
6592: proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
6593: if( pCtx->conchHeld>0 ){
6594: unixFile *proxy = pCtx->lockProxy;
6595: return proxy->pMethod->xCheckReservedLock((sqlite3_file*)proxy, pResOut);
6596: }else{ /* conchHeld < 0 is lockless */
6597: pResOut=0;
6598: }
6599: }
6600: return rc;
6601: }
6602:
6603: /*
6604: ** Lock the file with the lock specified by parameter eFileLock - one
6605: ** of the following:
6606: **
6607: ** (1) SHARED_LOCK
6608: ** (2) RESERVED_LOCK
6609: ** (3) PENDING_LOCK
6610: ** (4) EXCLUSIVE_LOCK
6611: **
6612: ** Sometimes when requesting one lock state, additional lock states
6613: ** are inserted in between. The locking might fail on one of the later
6614: ** transitions leaving the lock state different from what it started but
6615: ** still short of its goal. The following chart shows the allowed
6616: ** transitions and the inserted intermediate states:
6617: **
6618: ** UNLOCKED -> SHARED
6619: ** SHARED -> RESERVED
6620: ** SHARED -> (PENDING) -> EXCLUSIVE
6621: ** RESERVED -> (PENDING) -> EXCLUSIVE
6622: ** PENDING -> EXCLUSIVE
6623: **
6624: ** This routine will only increase a lock. Use the sqlite3OsUnlock()
6625: ** routine to lower a locking level.
6626: */
6627: static int proxyLock(sqlite3_file *id, int eFileLock) {
6628: unixFile *pFile = (unixFile*)id;
6629: int rc = proxyTakeConch(pFile);
6630: if( rc==SQLITE_OK ){
6631: proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
6632: if( pCtx->conchHeld>0 ){
6633: unixFile *proxy = pCtx->lockProxy;
6634: rc = proxy->pMethod->xLock((sqlite3_file*)proxy, eFileLock);
6635: pFile->eFileLock = proxy->eFileLock;
6636: }else{
6637: /* conchHeld < 0 is lockless */
6638: }
6639: }
6640: return rc;
6641: }
6642:
6643:
6644: /*
6645: ** Lower the locking level on file descriptor pFile to eFileLock. eFileLock
6646: ** must be either NO_LOCK or SHARED_LOCK.
6647: **
6648: ** If the locking level of the file descriptor is already at or below
6649: ** the requested locking level, this routine is a no-op.
6650: */
6651: static int proxyUnlock(sqlite3_file *id, int eFileLock) {
6652: unixFile *pFile = (unixFile*)id;
6653: int rc = proxyTakeConch(pFile);
6654: if( rc==SQLITE_OK ){
6655: proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
6656: if( pCtx->conchHeld>0 ){
6657: unixFile *proxy = pCtx->lockProxy;
6658: rc = proxy->pMethod->xUnlock((sqlite3_file*)proxy, eFileLock);
6659: pFile->eFileLock = proxy->eFileLock;
6660: }else{
6661: /* conchHeld < 0 is lockless */
6662: }
6663: }
6664: return rc;
6665: }
6666:
6667: /*
6668: ** Close a file that uses proxy locks.
6669: */
6670: static int proxyClose(sqlite3_file *id) {
6671: if( id ){
6672: unixFile *pFile = (unixFile*)id;
6673: proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
6674: unixFile *lockProxy = pCtx->lockProxy;
6675: unixFile *conchFile = pCtx->conchFile;
6676: int rc = SQLITE_OK;
6677:
6678: if( lockProxy ){
6679: rc = lockProxy->pMethod->xUnlock((sqlite3_file*)lockProxy, NO_LOCK);
6680: if( rc ) return rc;
6681: rc = lockProxy->pMethod->xClose((sqlite3_file*)lockProxy);
6682: if( rc ) return rc;
6683: sqlite3_free(lockProxy);
6684: pCtx->lockProxy = 0;
6685: }
6686: if( conchFile ){
6687: if( pCtx->conchHeld ){
6688: rc = proxyReleaseConch(pFile);
6689: if( rc ) return rc;
6690: }
6691: rc = conchFile->pMethod->xClose((sqlite3_file*)conchFile);
6692: if( rc ) return rc;
6693: sqlite3_free(conchFile);
6694: }
6695: sqlite3DbFree(0, pCtx->lockProxyPath);
6696: sqlite3_free(pCtx->conchFilePath);
6697: sqlite3DbFree(0, pCtx->dbPath);
6698: /* restore the original locking context and pMethod then close it */
6699: pFile->lockingContext = pCtx->oldLockingContext;
6700: pFile->pMethod = pCtx->pOldMethod;
6701: sqlite3_free(pCtx);
6702: return pFile->pMethod->xClose(id);
6703: }
6704: return SQLITE_OK;
6705: }
6706:
6707:
6708:
6709: #endif /* defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE */
6710: /*
6711: ** The proxy locking style is intended for use with AFP filesystems.
6712: ** And since AFP is only supported on MacOSX, the proxy locking is also
6713: ** restricted to MacOSX.
6714: **
6715: **
6716: ******************* End of the proxy lock implementation **********************
6717: ******************************************************************************/
6718:
6719: /*
6720: ** Initialize the operating system interface.
6721: **
6722: ** This routine registers all VFS implementations for unix-like operating
6723: ** systems. This routine, and the sqlite3_os_end() routine that follows,
6724: ** should be the only routines in this file that are visible from other
6725: ** files.
6726: **
6727: ** This routine is called once during SQLite initialization and by a
6728: ** single thread. The memory allocation and mutex subsystems have not
6729: ** necessarily been initialized when this routine is called, and so they
6730: ** should not be used.
6731: */
6732: int sqlite3_os_init(void){
6733: /*
6734: ** The following macro defines an initializer for an sqlite3_vfs object.
6735: ** The name of the VFS is NAME. The pAppData is a pointer to a pointer
6736: ** to the "finder" function. (pAppData is a pointer to a pointer because
6737: ** silly C90 rules prohibit a void* from being cast to a function pointer
6738: ** and so we have to go through the intermediate pointer to avoid problems
6739: ** when compiling with -pedantic-errors on GCC.)
6740: **
6741: ** The FINDER parameter to this macro is the name of the pointer to the
6742: ** finder-function. The finder-function returns a pointer to the
6743: ** sqlite_io_methods object that implements the desired locking
6744: ** behaviors. See the division above that contains the IOMETHODS
6745: ** macro for addition information on finder-functions.
6746: **
6747: ** Most finders simply return a pointer to a fixed sqlite3_io_methods
6748: ** object. But the "autolockIoFinder" available on MacOSX does a little
6749: ** more than that; it looks at the filesystem type that hosts the
6750: ** database file and tries to choose an locking method appropriate for
6751: ** that filesystem time.
6752: */
6753: #define UNIXVFS(VFSNAME, FINDER) { \
6754: 3, /* iVersion */ \
6755: sizeof(unixFile), /* szOsFile */ \
6756: MAX_PATHNAME, /* mxPathname */ \
6757: 0, /* pNext */ \
6758: VFSNAME, /* zName */ \
6759: (void*)&FINDER, /* pAppData */ \
6760: unixOpen, /* xOpen */ \
6761: unixDelete, /* xDelete */ \
6762: unixAccess, /* xAccess */ \
6763: unixFullPathname, /* xFullPathname */ \
6764: unixDlOpen, /* xDlOpen */ \
6765: unixDlError, /* xDlError */ \
6766: unixDlSym, /* xDlSym */ \
6767: unixDlClose, /* xDlClose */ \
6768: unixRandomness, /* xRandomness */ \
6769: unixSleep, /* xSleep */ \
6770: unixCurrentTime, /* xCurrentTime */ \
6771: unixGetLastError, /* xGetLastError */ \
6772: unixCurrentTimeInt64, /* xCurrentTimeInt64 */ \
6773: unixSetSystemCall, /* xSetSystemCall */ \
6774: unixGetSystemCall, /* xGetSystemCall */ \
6775: unixNextSystemCall, /* xNextSystemCall */ \
6776: }
6777:
6778: /*
6779: ** All default VFSes for unix are contained in the following array.
6780: **
6781: ** Note that the sqlite3_vfs.pNext field of the VFS object is modified
6782: ** by the SQLite core when the VFS is registered. So the following
6783: ** array cannot be const.
6784: */
6785: static sqlite3_vfs aVfs[] = {
6786: #if SQLITE_ENABLE_LOCKING_STYLE && (OS_VXWORKS || defined(__APPLE__))
6787: UNIXVFS("unix", autolockIoFinder ),
6788: #else
6789: UNIXVFS("unix", posixIoFinder ),
6790: #endif
6791: UNIXVFS("unix-none", nolockIoFinder ),
6792: UNIXVFS("unix-dotfile", dotlockIoFinder ),
6793: UNIXVFS("unix-excl", posixIoFinder ),
6794: #if OS_VXWORKS
6795: UNIXVFS("unix-namedsem", semIoFinder ),
6796: #endif
6797: #if SQLITE_ENABLE_LOCKING_STYLE
6798: UNIXVFS("unix-posix", posixIoFinder ),
6799: #if !OS_VXWORKS
6800: UNIXVFS("unix-flock", flockIoFinder ),
6801: #endif
6802: #endif
6803: #if SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__)
6804: UNIXVFS("unix-afp", afpIoFinder ),
6805: UNIXVFS("unix-nfs", nfsIoFinder ),
6806: UNIXVFS("unix-proxy", proxyIoFinder ),
6807: #endif
6808: };
6809: unsigned int i; /* Loop counter */
6810:
6811: /* Double-check that the aSyscall[] array has been constructed
6812: ** correctly. See ticket [bb3a86e890c8e96ab] */
6813: assert( ArraySize(aSyscall)==20 );
6814:
6815: /* Register all VFSes defined in the aVfs[] array */
6816: for(i=0; i<(sizeof(aVfs)/sizeof(sqlite3_vfs)); i++){
6817: sqlite3_vfs_register(&aVfs[i], i==0);
6818: }
6819: return SQLITE_OK;
6820: }
6821:
6822: /*
6823: ** Shutdown the operating system interface.
6824: **
6825: ** Some operating systems might need to do some cleanup in this routine,
6826: ** to release dynamically allocated objects. But not on unix.
6827: ** This routine is a no-op for unix.
6828: */
6829: int sqlite3_os_end(void){
6830: return SQLITE_OK;
6831: }
6832:
6833: #endif /* SQLITE_OS_UNIX */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to os_unix.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / src