4
** The author disclaims copyright to this source code. In place of
5
** a legal notice, here is a blessing:
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.
11
******************************************************************************
13
** This file contains code that is specific to Unix systems.
15
#include "sqliteInt.h"
17
#if OS_UNIX /* This file is used on unix only */
24
# define O_LARGEFILE 0
26
#ifdef SQLITE_DISABLE_LFS
28
# define O_LARGEFILE 0
39
** The DJGPP compiler environment looks mostly like Unix, but it
40
** lacks the fcntl() system call. So redefine fcntl() to be something
41
** that always succeeds. This means that locking does not occur under
42
** DJGPP. But its DOS - what did you expect?
45
# define fcntl(A,B,C) 0
49
** Macros used to determine whether or not to use threads. The
50
** SQLITE_UNIX_THREADS macro is defined if we are synchronizing for
51
** Posix threads and SQLITE_W32_THREADS is defined if we are
52
** synchronizing using Win32 threads.
54
#if defined(THREADSAFE) && THREADSAFE
56
# define SQLITE_UNIX_THREADS 1
61
** Include code that is common to all os_*.c files
63
#include "os_common.h"
65
#if defined(THREADSAFE) && THREADSAFE && defined(__linux__)
66
#define getpid pthread_self
70
** Here is the dirt on POSIX advisory locks: ANSI STD 1003.1 (1996)
71
** section 6.5.2.2 lines 483 through 490 specify that when a process
72
** sets or clears a lock, that operation overrides any prior locks set
73
** by the same process. It does not explicitly say so, but this implies
74
** that it overrides locks set by the same process using a different
75
** file descriptor. Consider this test case:
77
** int fd1 = open("./file1", O_RDWR|O_CREAT, 0644);
78
** int fd2 = open("./file2", O_RDWR|O_CREAT, 0644);
80
** Suppose ./file1 and ./file2 are really the same file (because
81
** one is a hard or symbolic link to the other) then if you set
82
** an exclusive lock on fd1, then try to get an exclusive lock
83
** on fd2, it works. I would have expected the second lock to
84
** fail since there was already a lock on the file due to fd1.
85
** But not so. Since both locks came from the same process, the
86
** second overrides the first, even though they were on different
87
** file descriptors opened on different file names.
89
** Bummer. If you ask me, this is broken. Badly broken. It means
90
** that we cannot use POSIX locks to synchronize file access among
91
** competing threads of the same process. POSIX locks will work fine
92
** to synchronize access for threads in separate processes, but not
93
** threads within the same process.
95
** To work around the problem, SQLite has to manage file locks internally
96
** on its own. Whenever a new database is opened, we have to find the
97
** specific inode of the database file (the inode is determined by the
98
** st_dev and st_ino fields of the stat structure that fstat() fills in)
99
** and check for locks already existing on that inode. When locks are
100
** created or removed, we have to look at our own internal record of the
101
** locks to see if another thread has previously set a lock on that same
104
** The OsFile structure for POSIX is no longer just an integer file
105
** descriptor. It is now a structure that holds the integer file
106
** descriptor and a pointer to a structure that describes the internal
107
** locks on the corresponding inode. There is one locking structure
108
** per inode, so if the same inode is opened twice, both OsFile structures
109
** point to the same locking structure. The locking structure keeps
110
** a reference count (so we will know when to delete it) and a "cnt"
111
** field that tells us its internal lock status. cnt==0 means the
112
** file is unlocked. cnt==-1 means the file has an exclusive lock.
113
** cnt>0 means there are cnt shared locks on the file.
115
** Any attempt to lock or unlock a file first checks the locking
116
** structure. The fcntl() system call is only invoked to set a
117
** POSIX lock if the internal lock structure transitions between
118
** a locked and an unlocked state.
121
** More recent discoveries about POSIX advisory locks. (The more
122
** I discover, the more I realize the a POSIX advisory locks are
125
** If you close a file descriptor that points to a file that has locks,
126
** all locks on that file that are owned by the current process are
127
** released. To work around this problem, each OsFile structure contains
128
** a pointer to an openCnt structure. There is one openCnt structure
129
** per open inode, which means that multiple OsFiles can point to a single
130
** openCnt. When an attempt is made to close an OsFile, if there are
131
** other OsFiles open on the same inode that are holding locks, the call
132
** to close() the file descriptor is deferred until all of the locks clear.
133
** The openCnt structure keeps a list of file descriptors that need to
134
** be closed and that list is walked (and cleared) when the last lock
137
** First, under Linux threads, because each thread has a separate
138
** process ID, lock operations in one thread do not override locks
139
** to the same file in other threads. Linux threads behave like
140
** separate processes in this respect. But, if you close a file
141
** descriptor in linux threads, all locks are cleared, even locks
142
** on other threads and even though the other threads have different
143
** process IDs. Linux threads is inconsistent in this respect.
144
** (I'm beginning to think that linux threads is an abomination too.)
145
** The consequence of this all is that the hash table for the lockInfo
146
** structure has to include the process id as part of its key because
147
** locks in different threads are treated as distinct. But the
148
** openCnt structure should not include the process id in its
149
** key because close() clears lock on all threads, not just the current
150
** thread. Were it not for this goofiness in linux threads, we could
151
** combine the lockInfo and openCnt structures into a single structure.
154
** On some versions of linux, threads can override each others locks.
155
** On others not. Sometimes you can change the behavior on the same
156
** system by setting the LD_ASSUME_KERNEL environment variable. The
157
** POSIX standard is silent as to which behavior is correct, as far
158
** as I can tell, so other versions of unix might show the same
159
** inconsistency. There is no little doubt in my mind that posix
160
** advisory locks and linux threads are profoundly broken.
162
** To work around the inconsistencies, we have to test at runtime
163
** whether or not threads can override each others locks. This test
164
** is run once, the first time any lock is attempted. A static
165
** variable is set to record the results of this test for future
170
** An instance of the following structure serves as the key used
171
** to locate a particular lockInfo structure given its inode.
173
** If threads cannot override each others locks, then we set the
174
** lockKey.tid field to the thread ID. If threads can override
175
** each others locks then tid is always set to zero. tid is also
176
** set to zero if we compile without threading support.
179
dev_t dev; /* Device number */
180
ino_t ino; /* Inode number */
181
#ifdef SQLITE_UNIX_THREADS
182
pthread_t tid; /* Thread ID or zero if threads cannot override each other */
187
** An instance of the following structure is allocated for each open
188
** inode on each thread with a different process ID. (Threads have
189
** different process IDs on linux, but not on most other unixes.)
191
** A single inode can have multiple file descriptors, so each OsFile
192
** structure contains a pointer to an instance of this object and this
193
** object keeps a count of the number of OsFiles pointing to it.
196
struct lockKey key; /* The lookup key */
197
int cnt; /* Number of SHARED locks held */
198
int locktype; /* One of SHARED_LOCK, RESERVED_LOCK etc. */
199
int nRef; /* Number of pointers to this structure */
203
** An instance of the following structure serves as the key used
204
** to locate a particular openCnt structure given its inode. This
205
** is the same as the lockKey except that the thread ID is omitted.
208
dev_t dev; /* Device number */
209
ino_t ino; /* Inode number */
213
** An instance of the following structure is allocated for each open
214
** inode. This structure keeps track of the number of locks on that
215
** inode. If a close is attempted against an inode that is holding
216
** locks, the close is deferred until all locks clear by adding the
217
** file descriptor to be closed to the pending list.
220
struct openKey key; /* The lookup key */
221
int nRef; /* Number of pointers to this structure */
222
int nLock; /* Number of outstanding locks */
223
int nPending; /* Number of pending close() operations */
224
int *aPending; /* Malloced space holding fd's awaiting a close() */
228
** These hash table maps inodes and process IDs into lockInfo and openCnt
229
** structures. Access to these hash tables must be protected by a mutex.
231
static Hash lockHash = { SQLITE_HASH_BINARY, 0, 0, 0, 0, 0 };
232
static Hash openHash = { SQLITE_HASH_BINARY, 0, 0, 0, 0, 0 };
235
#ifdef SQLITE_UNIX_THREADS
237
** This variable records whether or not threads can override each others
240
** 0: No. Threads cannot override each others locks.
241
** 1: Yes. Threads can override each others locks.
242
** -1: We don't know yet.
244
static int threadsOverrideEachOthersLocks = -1;
247
** This structure holds information passed into individual test
248
** threads by the testThreadLockingBehavior() routine.
250
struct threadTestData {
251
int fd; /* File to be locked */
252
struct flock lock; /* The locking operation */
253
int result; /* Result of the locking operation */
257
** The testThreadLockingBehavior() routine launches two separate
258
** threads on this routine. This routine attempts to lock a file
259
** descriptor then returns. The success or failure of that attempt
260
** allows the testThreadLockingBehavior() procedure to determine
261
** whether or not threads can override each others locks.
263
static void *threadLockingTest(void *pArg){
264
struct threadTestData *pData = (struct threadTestData*)pArg;
265
pData->result = fcntl(pData->fd, F_SETLK, &pData->lock);
270
** This procedure attempts to determine whether or not threads
271
** can override each others locks then sets the
272
** threadsOverrideEachOthersLocks variable appropriately.
274
static void testThreadLockingBehavior(fd_orig){
276
struct threadTestData d[2];
281
memset(d, 0, sizeof(d));
283
d[0].lock.l_type = F_RDLCK;
285
d[0].lock.l_start = 0;
286
d[0].lock.l_whence = SEEK_SET;
288
d[1].lock.l_type = F_WRLCK;
289
pthread_create(&t[0], 0, threadLockingTest, &d[0]);
290
pthread_create(&t[1], 0, threadLockingTest, &d[1]);
291
pthread_join(t[0], 0);
292
pthread_join(t[1], 0);
294
threadsOverrideEachOthersLocks = d[0].result==0 && d[1].result==0;
296
#endif /* SQLITE_UNIX_THREADS */
299
** Release a lockInfo structure previously allocated by findLockInfo().
301
static void releaseLockInfo(struct lockInfo *pLock){
303
if( pLock->nRef==0 ){
304
sqlite3HashInsert(&lockHash, &pLock->key, sizeof(pLock->key), 0);
310
** Release a openCnt structure previously allocated by findLockInfo().
312
static void releaseOpenCnt(struct openCnt *pOpen){
314
if( pOpen->nRef==0 ){
315
sqlite3HashInsert(&openHash, &pOpen->key, sizeof(pOpen->key), 0);
316
sqliteFree(pOpen->aPending);
322
** Given a file descriptor, locate lockInfo and openCnt structures that
323
** describes that file descriptor. Create a new ones if necessary. The
324
** return values might be unset if an error occurs.
326
** Return the number of errors.
328
static int findLockInfo(
329
int fd, /* The file descriptor used in the key */
330
struct lockInfo **ppLock, /* Return the lockInfo structure here */
331
struct openCnt **ppOpen /* Return the openCnt structure here */
337
struct lockInfo *pLock;
338
struct openCnt *pOpen;
339
rc = fstat(fd, &statbuf);
340
if( rc!=0 ) return 1;
341
memset(&key1, 0, sizeof(key1));
342
key1.dev = statbuf.st_dev;
343
key1.ino = statbuf.st_ino;
344
#ifdef SQLITE_UNIX_THREADS
345
if( threadsOverrideEachOthersLocks<0 ){
346
testThreadLockingBehavior(fd);
348
key1.tid = threadsOverrideEachOthersLocks ? 0 : pthread_self();
350
memset(&key2, 0, sizeof(key2));
351
key2.dev = statbuf.st_dev;
352
key2.ino = statbuf.st_ino;
353
pLock = (struct lockInfo*)sqlite3HashFind(&lockHash, &key1, sizeof(key1));
355
struct lockInfo *pOld;
356
pLock = sqliteMallocRaw( sizeof(*pLock) );
357
if( pLock==0 ) return 1;
362
pOld = sqlite3HashInsert(&lockHash, &pLock->key, sizeof(key1), pLock);
364
assert( pOld==pLock );
372
pOpen = (struct openCnt*)sqlite3HashFind(&openHash, &key2, sizeof(key2));
374
struct openCnt *pOld;
375
pOpen = sqliteMallocRaw( sizeof(*pOpen) );
377
releaseLockInfo(pLock);
385
pOld = sqlite3HashInsert(&openHash, &pOpen->key, sizeof(key2), pOpen);
387
assert( pOld==pOpen );
389
releaseLockInfo(pLock);
400
** Delete the named file
402
int sqlite3OsDelete(const char *zFilename){
408
** Return TRUE if the named file exists.
410
int sqlite3OsFileExists(const char *zFilename){
411
return access(zFilename, 0)==0;
415
** Attempt to open a file for both reading and writing. If that
416
** fails, try opening it read-only. If the file does not exist,
419
** On success, a handle for the open file is written to *id
420
** and *pReadonly is set to 0 if the file was opened for reading and
421
** writing or 1 if the file was opened read-only. The function returns
424
** On failure, the function returns SQLITE_CANTOPEN and leaves
425
** *id and *pReadonly unchanged.
427
int sqlite3OsOpenReadWrite(
428
const char *zFilename,
433
assert( !id->isOpen );
435
id->h = open(zFilename, O_RDWR|O_CREAT|O_LARGEFILE|O_BINARY, 0644);
439
return SQLITE_CANTOPEN;
442
id->h = open(zFilename, O_RDONLY|O_LARGEFILE|O_BINARY);
444
return SQLITE_CANTOPEN;
450
sqlite3OsEnterMutex();
451
rc = findLockInfo(id->h, &id->pLock, &id->pOpen);
452
sqlite3OsLeaveMutex();
459
TRACE3("OPEN %-3d %s\n", id->h, zFilename);
466
** Attempt to open a new file for exclusive access by this process.
467
** The file will be opened for both reading and writing. To avoid
468
** a potential security problem, we do not allow the file to have
469
** previously existed. Nor do we allow the file to be a symbolic
472
** If delFlag is true, then make arrangements to automatically delete
473
** the file when it is closed.
475
** On success, write the file handle into *id and return SQLITE_OK.
477
** On failure, return SQLITE_CANTOPEN.
479
int sqlite3OsOpenExclusive(const char *zFilename, OsFile *id, int delFlag){
481
assert( !id->isOpen );
482
if( access(zFilename, 0)==0 ){
483
return SQLITE_CANTOPEN;
486
id->h = open(zFilename,
487
O_RDWR|O_CREAT|O_EXCL|O_NOFOLLOW|O_LARGEFILE|O_BINARY, 0600);
489
return SQLITE_CANTOPEN;
491
sqlite3OsEnterMutex();
492
rc = findLockInfo(id->h, &id->pLock, &id->pOpen);
493
sqlite3OsLeaveMutex();
504
TRACE3("OPEN-EX %-3d %s\n", id->h, zFilename);
510
** Attempt to open a new file for read-only access.
512
** On success, write the file handle into *id and return SQLITE_OK.
514
** On failure, return SQLITE_CANTOPEN.
516
int sqlite3OsOpenReadOnly(const char *zFilename, OsFile *id){
518
assert( !id->isOpen );
520
id->h = open(zFilename, O_RDONLY|O_LARGEFILE|O_BINARY);
522
return SQLITE_CANTOPEN;
524
sqlite3OsEnterMutex();
525
rc = findLockInfo(id->h, &id->pLock, &id->pOpen);
526
sqlite3OsLeaveMutex();
533
TRACE3("OPEN-RO %-3d %s\n", id->h, zFilename);
539
** Attempt to open a file descriptor for the directory that contains a
540
** file. This file descriptor can be used to fsync() the directory
541
** in order to make sure the creation of a new file is actually written
544
** This routine is only meaningful for Unix. It is a no-op under
545
** windows since windows does not support hard links.
547
** On success, a handle for a previously open file is at *id is
548
** updated with the new directory file descriptor and SQLITE_OK is
551
** On failure, the function returns SQLITE_CANTOPEN and leaves
554
int sqlite3OsOpenDirectory(
555
const char *zDirname,
559
/* Do not open the directory if the corresponding file is not already
561
return SQLITE_CANTOPEN;
563
assert( id->dirfd<0 );
564
id->dirfd = open(zDirname, O_RDONLY|O_BINARY, 0644);
566
return SQLITE_CANTOPEN;
568
TRACE3("OPENDIR %-3d %s\n", id->dirfd, zDirname);
573
** If the following global variable points to a string which is the
574
** name of a directory, then that directory will be used to store
577
char *sqlite3_temp_directory = 0;
580
** Create a temporary file name in zBuf. zBuf must be big enough to
581
** hold at least SQLITE_TEMPNAME_SIZE characters.
583
int sqlite3OsTempFileName(char *zBuf){
584
static const char *azDirs[] = {
591
static const unsigned char zChars[] =
592
"abcdefghijklmnopqrstuvwxyz"
593
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
597
const char *zDir = ".";
598
azDirs[0] = sqlite3_temp_directory;
599
for(i=0; i<sizeof(azDirs)/sizeof(azDirs[0]); i++){
600
if( azDirs[i]==0 ) continue;
601
if( stat(azDirs[i], &buf) ) continue;
602
if( !S_ISDIR(buf.st_mode) ) continue;
603
if( access(azDirs[i], 07) ) continue;
608
sprintf(zBuf, "%s/"TEMP_FILE_PREFIX, zDir);
610
sqlite3Randomness(15, &zBuf[j]);
611
for(i=0; i<15; i++, j++){
612
zBuf[j] = (char)zChars[ ((unsigned char)zBuf[j])%(sizeof(zChars)-1) ];
615
}while( access(zBuf,0)==0 );
619
#ifndef SQLITE_OMIT_PAGER_PRAGMAS
621
** Check that a given pathname is a directory and is writable
624
int sqlite3OsIsDirWritable(char *zBuf){
626
if( zBuf==0 ) return 0;
627
if( zBuf[0]==0 ) return 0;
628
if( stat(zBuf, &buf) ) return 0;
629
if( !S_ISDIR(buf.st_mode) ) return 0;
630
if( access(zBuf, 07) ) return 0;
633
#endif /* SQLITE_OMIT_PAGER_PRAGMAS */
636
** Read data from a file into a buffer. Return SQLITE_OK if all
637
** bytes were read successfully and SQLITE_IOERR if anything goes
640
int sqlite3OsRead(OsFile *id, void *pBuf, int amt){
642
assert( id->isOpen );
643
SimulateIOError(SQLITE_IOERR);
645
got = read(id->h, pBuf, amt);
647
TRACE5("READ %-3d %5d %7d %d\n", id->h, got, last_page, TIMER_ELAPSED);
649
/* if( got<0 ) got = 0; */
658
** Write data from a buffer into a file. Return SQLITE_OK on success
659
** or some other error code on failure.
661
int sqlite3OsWrite(OsFile *id, const void *pBuf, int amt){
663
assert( id->isOpen );
665
SimulateIOError(SQLITE_IOERR);
666
SimulateDiskfullError;
668
while( amt>0 && (wrote = write(id->h, pBuf, amt))>0 ){
670
pBuf = &((char*)pBuf)[wrote];
673
TRACE5("WRITE %-3d %5d %7d %d\n", id->h, wrote, last_page, TIMER_ELAPSED);
682
** Move the read/write pointer in a file.
684
int sqlite3OsSeek(OsFile *id, i64 offset){
685
assert( id->isOpen );
686
SEEK(offset/1024 + 1);
687
lseek(id->h, offset, SEEK_SET);
693
** Count the number of fullsyncs and normal syncs. This is used to test
694
** that syncs and fullsyncs are occuring at the right times.
696
int sqlite3_sync_count = 0;
697
int sqlite3_fullsync_count = 0;
702
** The fsync() system call does not work as advertised on many
703
** unix systems. The following procedure is an attempt to make
706
** The SQLITE_NO_SYNC macro disables all fsync()s. This is useful
707
** for testing when we want to run through the test suite quickly.
708
** You are strongly advised *not* to deploy with SQLITE_NO_SYNC
709
** enabled, however, since with SQLITE_NO_SYNC enabled, an OS crash
710
** or power failure will likely corrupt the database file.
712
static int full_fsync(int fd, int fullSync){
715
/* Record the number of times that we do a normal fsync() and
716
** FULLSYNC. This is used during testing to verify that this procedure
717
** gets called with the correct arguments.
720
if( fullSync ) sqlite3_fullsync_count++;
721
sqlite3_sync_count++;
724
/* If we compiled with the SQLITE_NO_SYNC flag, then syncing is a
727
#ifdef SQLITE_NO_SYNC
733
rc = fcntl(fd, F_FULLFSYNC, 0);
737
/* If the FULLSYNC failed, try to do a normal fsync() */
738
if( rc ) rc = fsync(fd);
742
#endif /* defined(F_FULLFSYNC) */
743
#endif /* defined(SQLITE_NO_SYNC) */
749
** Make sure all writes to a particular file are committed to disk.
751
** Under Unix, also make sure that the directory entry for the file
752
** has been created by fsync-ing the directory that contains the file.
753
** If we do not do this and we encounter a power failure, the directory
754
** entry for the journal might not exist after we reboot. The next
755
** SQLite to access the file will not know that the journal exists (because
756
** the directory entry for the journal was never created) and the transaction
757
** will not roll back - possibly leading to database corruption.
759
int sqlite3OsSync(OsFile *id){
760
assert( id->isOpen );
761
SimulateIOError(SQLITE_IOERR);
762
TRACE2("SYNC %-3d\n", id->h);
763
if( full_fsync(id->h, id->fullSync) ){
767
TRACE2("DIRSYNC %-3d\n", id->dirfd);
768
full_fsync(id->dirfd, id->fullSync);
769
close(id->dirfd); /* Only need to sync once, so close the directory */
770
id->dirfd = -1; /* when we are done. */
776
** Sync the directory zDirname. This is a no-op on operating systems other
779
** This is used to make sure the master journal file has truely been deleted
780
** before making changes to individual journals on a multi-database commit.
781
** The F_FULLFSYNC option is not needed here.
783
int sqlite3OsSyncDirectory(const char *zDirname){
786
SimulateIOError(SQLITE_IOERR);
787
fd = open(zDirname, O_RDONLY|O_BINARY, 0644);
788
TRACE3("DIRSYNC %-3d (%s)\n", fd, zDirname);
790
return SQLITE_CANTOPEN;
794
return ((r==0)?SQLITE_OK:SQLITE_IOERR);
798
** Truncate an open file to a specified size
800
int sqlite3OsTruncate(OsFile *id, i64 nByte){
801
assert( id->isOpen );
802
SimulateIOError(SQLITE_IOERR);
803
return ftruncate(id->h, nByte)==0 ? SQLITE_OK : SQLITE_IOERR;
807
** Determine the current size of a file in bytes
809
int sqlite3OsFileSize(OsFile *id, i64 *pSize){
811
assert( id->isOpen );
812
SimulateIOError(SQLITE_IOERR);
813
if( fstat(id->h, &buf)!=0 ){
816
*pSize = buf.st_size;
821
** This routine checks if there is a RESERVED lock held on the specified
822
** file by this or any other process. If such a lock is held, return
823
** non-zero. If the file is unlocked or holds only SHARED locks, then
826
int sqlite3OsCheckReservedLock(OsFile *id){
829
assert( id->isOpen );
830
sqlite3OsEnterMutex(); /* Needed because id->pLock is shared across threads */
832
/* Check if a thread in this process holds such a lock */
833
if( id->pLock->locktype>SHARED_LOCK ){
837
/* Otherwise see if some other process holds it.
841
lock.l_whence = SEEK_SET;
842
lock.l_start = RESERVED_BYTE;
844
lock.l_type = F_WRLCK;
845
fcntl(id->h, F_GETLK, &lock);
846
if( lock.l_type!=F_UNLCK ){
851
sqlite3OsLeaveMutex();
852
TRACE3("TEST WR-LOCK %d %d\n", id->h, r);
859
** Helper function for printing out trace information from debugging
860
** binaries. This returns the string represetation of the supplied
861
** integer lock-type.
863
static const char * locktypeName(int locktype){
865
case NO_LOCK: return "NONE";
866
case SHARED_LOCK: return "SHARED";
867
case RESERVED_LOCK: return "RESERVED";
868
case PENDING_LOCK: return "PENDING";
869
case EXCLUSIVE_LOCK: return "EXCLUSIVE";
876
** Lock the file with the lock specified by parameter locktype - one
882
** (4) EXCLUSIVE_LOCK
884
** Sometimes when requesting one lock state, additional lock states
885
** are inserted in between. The locking might fail on one of the later
886
** transitions leaving the lock state different from what it started but
887
** still short of its goal. The following chart shows the allowed
888
** transitions and the inserted intermediate states:
890
** UNLOCKED -> SHARED
891
** SHARED -> RESERVED
892
** SHARED -> (PENDING) -> EXCLUSIVE
893
** RESERVED -> (PENDING) -> EXCLUSIVE
894
** PENDING -> EXCLUSIVE
896
** This routine will only increase a lock. Use the sqlite3OsUnlock()
897
** routine to lower a locking level.
899
int sqlite3OsLock(OsFile *id, int locktype){
900
/* The following describes the implementation of the various locks and
901
** lock transitions in terms of the POSIX advisory shared and exclusive
902
** lock primitives (called read-locks and write-locks below, to avoid
903
** confusion with SQLite lock names). The algorithms are complicated
904
** slightly in order to be compatible with windows systems simultaneously
905
** accessing the same database file, in case that is ever required.
907
** Symbols defined in os.h indentify the 'pending byte' and the 'reserved
908
** byte', each single bytes at well known offsets, and the 'shared byte
909
** range', a range of 510 bytes at a well known offset.
911
** To obtain a SHARED lock, a read-lock is obtained on the 'pending
912
** byte'. If this is successful, a random byte from the 'shared byte
913
** range' is read-locked and the lock on the 'pending byte' released.
915
** A process may only obtain a RESERVED lock after it has a SHARED lock.
916
** A RESERVED lock is implemented by grabbing a write-lock on the
919
** A process may only obtain a PENDING lock after it has obtained a
920
** SHARED lock. A PENDING lock is implemented by obtaining a write-lock
921
** on the 'pending byte'. This ensures that no new SHARED locks can be
922
** obtained, but existing SHARED locks are allowed to persist. A process
923
** does not have to obtain a RESERVED lock on the way to a PENDING lock.
924
** This property is used by the algorithm for rolling back a journal file
927
** An EXCLUSIVE lock, obtained after a PENDING lock is held, is
928
** implemented by obtaining a write-lock on the entire 'shared byte
929
** range'. Since all other locks require a read-lock on one of the bytes
930
** within this range, this ensures that no other locks are held on the
933
** The reason a single byte cannot be used instead of the 'shared byte
934
** range' is that some versions of windows do not support read-locks. By
935
** locking a random byte from a range, concurrent SHARED locks may exist
936
** even if the locking primitive used is always a write-lock.
939
struct lockInfo *pLock = id->pLock;
943
assert( id->isOpen );
944
TRACE7("LOCK %d %s was %s(%s,%d) pid=%d\n", id->h, locktypeName(locktype),
945
locktypeName(id->locktype), locktypeName(pLock->locktype), pLock->cnt
948
/* If there is already a lock of this type or more restrictive on the
949
** OsFile, do nothing. Don't use the end_lock: exit path, as
950
** sqlite3OsEnterMutex() hasn't been called yet.
952
if( id->locktype>=locktype ){
953
TRACE3("LOCK %d %s ok (already held)\n", id->h, locktypeName(locktype));
957
/* Make sure the locking sequence is correct
959
assert( id->locktype!=NO_LOCK || locktype==SHARED_LOCK );
960
assert( locktype!=PENDING_LOCK );
961
assert( locktype!=RESERVED_LOCK || id->locktype==SHARED_LOCK );
963
/* This mutex is needed because id->pLock is shared across threads
965
sqlite3OsEnterMutex();
967
/* If some thread using this PID has a lock via a different OsFile*
968
** handle that precludes the requested lock, return BUSY.
970
if( (id->locktype!=pLock->locktype &&
971
(pLock->locktype>=PENDING_LOCK || locktype>SHARED_LOCK))
977
/* If a SHARED lock is requested, and some thread using this PID already
978
** has a SHARED or RESERVED lock, then increment reference counts and
981
if( locktype==SHARED_LOCK &&
982
(pLock->locktype==SHARED_LOCK || pLock->locktype==RESERVED_LOCK) ){
983
assert( locktype==SHARED_LOCK );
984
assert( id->locktype==0 );
985
assert( pLock->cnt>0 );
986
id->locktype = SHARED_LOCK;
993
lock.l_whence = SEEK_SET;
995
/* A PENDING lock is needed before acquiring a SHARED lock and before
996
** acquiring an EXCLUSIVE lock. For the SHARED lock, the PENDING will
999
if( locktype==SHARED_LOCK
1000
|| (locktype==EXCLUSIVE_LOCK && id->locktype<PENDING_LOCK)
1002
lock.l_type = (locktype==SHARED_LOCK?F_RDLCK:F_WRLCK);
1003
lock.l_start = PENDING_BYTE;
1004
s = fcntl(id->h, F_SETLK, &lock);
1006
rc = (errno==EINVAL) ? SQLITE_NOLFS : SQLITE_BUSY;
1012
/* If control gets to this point, then actually go ahead and make
1013
** operating system calls for the specified lock.
1015
if( locktype==SHARED_LOCK ){
1016
assert( pLock->cnt==0 );
1017
assert( pLock->locktype==0 );
1019
/* Now get the read-lock */
1020
lock.l_start = SHARED_FIRST;
1021
lock.l_len = SHARED_SIZE;
1022
s = fcntl(id->h, F_SETLK, &lock);
1024
/* Drop the temporary PENDING lock */
1025
lock.l_start = PENDING_BYTE;
1027
lock.l_type = F_UNLCK;
1028
fcntl(id->h, F_SETLK, &lock);
1030
rc = (errno==EINVAL) ? SQLITE_NOLFS : SQLITE_BUSY;
1032
id->locktype = SHARED_LOCK;
1036
}else if( locktype==EXCLUSIVE_LOCK && pLock->cnt>1 ){
1037
/* We are trying for an exclusive lock but another thread in this
1038
** same process is still holding a shared lock. */
1041
/* The request was for a RESERVED or EXCLUSIVE lock. It is
1042
** assumed that there is a SHARED or greater lock on the file
1045
assert( 0!=id->locktype );
1046
lock.l_type = F_WRLCK;
1049
lock.l_start = RESERVED_BYTE;
1051
case EXCLUSIVE_LOCK:
1052
lock.l_start = SHARED_FIRST;
1053
lock.l_len = SHARED_SIZE;
1058
s = fcntl(id->h, F_SETLK, &lock);
1060
rc = (errno==EINVAL) ? SQLITE_NOLFS : SQLITE_BUSY;
1064
if( rc==SQLITE_OK ){
1065
id->locktype = locktype;
1066
pLock->locktype = locktype;
1067
}else if( locktype==EXCLUSIVE_LOCK ){
1068
id->locktype = PENDING_LOCK;
1069
pLock->locktype = PENDING_LOCK;
1073
sqlite3OsLeaveMutex();
1074
TRACE4("LOCK %d %s %s\n", id->h, locktypeName(locktype),
1075
rc==SQLITE_OK ? "ok" : "failed");
1080
** Lower the locking level on file descriptor id to locktype. locktype
1081
** must be either NO_LOCK or SHARED_LOCK.
1083
** If the locking level of the file descriptor is already at or below
1084
** the requested locking level, this routine is a no-op.
1086
** It is not possible for this routine to fail if the second argument
1087
** is NO_LOCK. If the second argument is SHARED_LOCK, this routine
1088
** might return SQLITE_IOERR instead of SQLITE_OK.
1090
int sqlite3OsUnlock(OsFile *id, int locktype){
1091
struct lockInfo *pLock;
1095
assert( id->isOpen );
1096
TRACE7("UNLOCK %d %d was %d(%d,%d) pid=%d\n", id->h, locktype, id->locktype,
1097
id->pLock->locktype, id->pLock->cnt, getpid());
1099
assert( locktype<=SHARED_LOCK );
1100
if( id->locktype<=locktype ){
1103
sqlite3OsEnterMutex();
1105
assert( pLock->cnt!=0 );
1106
if( id->locktype>SHARED_LOCK ){
1107
assert( pLock->locktype==id->locktype );
1108
if( locktype==SHARED_LOCK ){
1109
lock.l_type = F_RDLCK;
1110
lock.l_whence = SEEK_SET;
1111
lock.l_start = SHARED_FIRST;
1112
lock.l_len = SHARED_SIZE;
1113
if( fcntl(id->h, F_SETLK, &lock)!=0 ){
1114
/* This should never happen */
1118
lock.l_type = F_UNLCK;
1119
lock.l_whence = SEEK_SET;
1120
lock.l_start = PENDING_BYTE;
1121
lock.l_len = 2L; assert( PENDING_BYTE+1==RESERVED_BYTE );
1122
fcntl(id->h, F_SETLK, &lock);
1123
pLock->locktype = SHARED_LOCK;
1125
if( locktype==NO_LOCK ){
1126
struct openCnt *pOpen;
1128
/* Decrement the shared lock counter. Release the lock using an
1129
** OS call only when all threads in this same process have released
1133
if( pLock->cnt==0 ){
1134
lock.l_type = F_UNLCK;
1135
lock.l_whence = SEEK_SET;
1136
lock.l_start = lock.l_len = 0L;
1137
fcntl(id->h, F_SETLK, &lock);
1138
pLock->locktype = NO_LOCK;
1141
/* Decrement the count of locks against this same file. When the
1142
** count reaches zero, close any other file descriptors whose close
1143
** was deferred because of outstanding locks.
1147
assert( pOpen->nLock>=0 );
1148
if( pOpen->nLock==0 && pOpen->nPending>0 ){
1150
for(i=0; i<pOpen->nPending; i++){
1151
close(pOpen->aPending[i]);
1153
sqliteFree(pOpen->aPending);
1154
pOpen->nPending = 0;
1155
pOpen->aPending = 0;
1158
sqlite3OsLeaveMutex();
1159
id->locktype = locktype;
1166
int sqlite3OsClose(OsFile *id){
1167
if( !id->isOpen ) return SQLITE_OK;
1168
sqlite3OsUnlock(id, NO_LOCK);
1169
if( id->dirfd>=0 ) close(id->dirfd);
1171
sqlite3OsEnterMutex();
1172
if( id->pOpen->nLock ){
1173
/* If there are outstanding locks, do not actually close the file just
1174
** yet because that would clear those locks. Instead, add the file
1175
** descriptor to pOpen->aPending. It will be automatically closed when
1176
** the last lock is cleared.
1179
struct openCnt *pOpen = id->pOpen;
1181
aNew = sqliteRealloc( pOpen->aPending, pOpen->nPending*sizeof(int) );
1183
/* If a malloc fails, just leak the file descriptor */
1185
pOpen->aPending = aNew;
1186
pOpen->aPending[pOpen->nPending-1] = id->h;
1189
/* There are no outstanding locks so we can close the file immediately */
1192
releaseLockInfo(id->pLock);
1193
releaseOpenCnt(id->pOpen);
1194
sqlite3OsLeaveMutex();
1196
TRACE2("CLOSE %-3d\n", id->h);
1202
** Get information to seed the random number generator. The seed
1203
** is written into the buffer zBuf[256]. The calling function must
1204
** supply a sufficiently large buffer.
1206
int sqlite3OsRandomSeed(char *zBuf){
1207
/* We have to initialize zBuf to prevent valgrind from reporting
1208
** errors. The reports issued by valgrind are incorrect - we would
1209
** prefer that the randomness be increased by making use of the
1210
** uninitialized space in zBuf - but valgrind errors tend to worry
1211
** some users. Rather than argue, it seems easier just to initialize
1212
** the whole array and silence valgrind, even if that means less randomness
1213
** in the random seed.
1215
** When testing, initializing zBuf[] to zero is all we do. That means
1216
** that we always use the same random number sequence.* This makes the
1217
** tests repeatable.
1219
memset(zBuf, 0, 256);
1220
#if !defined(SQLITE_TEST)
1223
fd = open("/dev/urandom", O_RDONLY);
1225
time((time_t*)zBuf);
1227
memcpy(&zBuf[sizeof(time_t)], &pid, sizeof(pid));
1229
read(fd, zBuf, 256);
1238
** Sleep for a little while. Return the amount of time slept.
1240
int sqlite3OsSleep(int ms){
1241
#if defined(HAVE_USLEEP) && HAVE_USLEEP
1245
sleep((ms+999)/1000);
1246
return 1000*((ms+999)/1000);
1251
** Static variables used for thread synchronization
1253
static int inMutex = 0;
1254
#ifdef SQLITE_UNIX_THREADS
1255
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
1259
** The following pair of routine implement mutual exclusion for
1260
** multi-threaded processes. Only a single thread is allowed to
1261
** executed code that is surrounded by EnterMutex() and LeaveMutex().
1263
** SQLite uses only a single Mutex. There is not much critical
1264
** code and what little there is executes quickly and without blocking.
1266
void sqlite3OsEnterMutex(){
1267
#ifdef SQLITE_UNIX_THREADS
1268
pthread_mutex_lock(&mutex);
1273
void sqlite3OsLeaveMutex(){
1276
#ifdef SQLITE_UNIX_THREADS
1277
pthread_mutex_unlock(&mutex);
1282
** Turn a relative pathname into a full pathname. Return a pointer
1283
** to the full pathname stored in space obtained from sqliteMalloc().
1284
** The calling function is responsible for freeing this space once it
1285
** is no longer needed.
1287
char *sqlite3OsFullPathname(const char *zRelative){
1289
if( zRelative[0]=='/' ){
1290
sqlite3SetString(&zFull, zRelative, (char*)0);
1293
sqlite3SetString(&zFull, getcwd(zBuf, sizeof(zBuf)), "/", zRelative,
1300
** The following variable, if set to a non-zero value, becomes the result
1301
** returned from sqlite3OsCurrentTime(). This is used for testing.
1304
int sqlite3_current_time = 0;
1308
** Find the current time (in Universal Coordinated Time). Write the
1309
** current time and date as a Julian Day number into *prNow and
1310
** return 0. Return 1 if the time and date cannot be found.
1312
int sqlite3OsCurrentTime(double *prNow){
1315
*prNow = t/86400.0 + 2440587.5;
1317
if( sqlite3_current_time ){
1318
*prNow = sqlite3_current_time/86400.0 + 2440587.5;
1324
#if 0 /* NOT USED */
1326
** Find the time that the file was last modified. Write the
1327
** modification time and date as a Julian Day number into *prNow and
1328
** return SQLITE_OK. Return SQLITE_ERROR if the modification
1329
** time cannot be found.
1331
int sqlite3OsFileModTime(OsFile *id, double *prNow){
1333
struct stat statbuf;
1334
if( fstat(id->h, &statbuf)==0 ){
1335
*prNow = statbuf.st_mtime/86400.0 + 2440587.5;
1342
#endif /* NOT USED */
1344
#endif /* OS_UNIX */
added
removed
src/3rdparty/sqlite/os_unix.c
