Annotation of embedaddon/php/ext/sqlite/libsqlite/src/os.c, revision 1.1
1.1 ! misho 1: /*
! 2: ** 2001 September 16
! 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 code that is specific to particular operating
! 14: ** systems. The purpose of this file is to provide a uniform abstraction
! 15: ** on which the rest of SQLite can operate.
! 16: */
! 17: #include "os.h" /* Must be first to enable large file support */
! 18: #include "sqliteInt.h"
! 19:
! 20: #if OS_UNIX
! 21: # include <time.h>
! 22: # include <errno.h>
! 23: # include <unistd.h>
! 24: # ifndef O_LARGEFILE
! 25: # define O_LARGEFILE 0
! 26: # endif
! 27: # ifdef SQLITE_DISABLE_LFS
! 28: # undef O_LARGEFILE
! 29: # define O_LARGEFILE 0
! 30: # endif
! 31: # ifndef O_NOFOLLOW
! 32: # define O_NOFOLLOW 0
! 33: # endif
! 34: # ifndef O_BINARY
! 35: # define O_BINARY 0
! 36: # endif
! 37: #endif
! 38:
! 39:
! 40: #if OS_WIN
! 41: # include <winbase.h>
! 42: #endif
! 43:
! 44: #if OS_MAC
! 45: # include <extras.h>
! 46: # include <path2fss.h>
! 47: # include <TextUtils.h>
! 48: # include <FinderRegistry.h>
! 49: # include <Folders.h>
! 50: # include <Timer.h>
! 51: # include <OSUtils.h>
! 52: #endif
! 53:
! 54: /*
! 55: ** The DJGPP compiler environment looks mostly like Unix, but it
! 56: ** lacks the fcntl() system call. So redefine fcntl() to be something
! 57: ** that always succeeds. This means that locking does not occur under
! 58: ** DJGPP. But its DOS - what did you expect?
! 59: */
! 60: #ifdef __DJGPP__
! 61: # define fcntl(A,B,C) 0
! 62: #endif
! 63:
! 64: /*
! 65: ** Macros used to determine whether or not to use threads. The
! 66: ** SQLITE_UNIX_THREADS macro is defined if we are synchronizing for
! 67: ** Posix threads and SQLITE_W32_THREADS is defined if we are
! 68: ** synchronizing using Win32 threads.
! 69: */
! 70: #if OS_UNIX && defined(THREADSAFE) && THREADSAFE
! 71: # include <pthread.h>
! 72: # define SQLITE_UNIX_THREADS 1
! 73: #endif
! 74: #if OS_WIN && defined(THREADSAFE) && THREADSAFE
! 75: # define SQLITE_W32_THREADS 1
! 76: #endif
! 77: #if OS_MAC && defined(THREADSAFE) && THREADSAFE
! 78: # include <Multiprocessing.h>
! 79: # define SQLITE_MACOS_MULTITASKING 1
! 80: #endif
! 81:
! 82: /*
! 83: ** Macros for performance tracing. Normally turned off
! 84: */
! 85: #if 0
! 86: static int last_page = 0;
! 87: __inline__ unsigned long long int hwtime(void){
! 88: unsigned long long int x;
! 89: __asm__("rdtsc\n\t"
! 90: "mov %%edx, %%ecx\n\t"
! 91: :"=A" (x));
! 92: return x;
! 93: }
! 94: static unsigned long long int g_start;
! 95: static unsigned int elapse;
! 96: #define TIMER_START g_start=hwtime()
! 97: #define TIMER_END elapse=hwtime()-g_start
! 98: #define SEEK(X) last_page=(X)
! 99: #define TRACE1(X) fprintf(stderr,X)
! 100: #define TRACE2(X,Y) fprintf(stderr,X,Y)
! 101: #define TRACE3(X,Y,Z) fprintf(stderr,X,Y,Z)
! 102: #define TRACE4(X,Y,Z,A) fprintf(stderr,X,Y,Z,A)
! 103: #define TRACE5(X,Y,Z,A,B) fprintf(stderr,X,Y,Z,A,B)
! 104: #else
! 105: #define TIMER_START
! 106: #define TIMER_END
! 107: #define SEEK(X)
! 108: #define TRACE1(X)
! 109: #define TRACE2(X,Y)
! 110: #define TRACE3(X,Y,Z)
! 111: #define TRACE4(X,Y,Z,A)
! 112: #define TRACE5(X,Y,Z,A,B)
! 113: #endif
! 114:
! 115:
! 116: #if OS_UNIX
! 117: /*
! 118: ** Here is the dirt on POSIX advisory locks: ANSI STD 1003.1 (1996)
! 119: ** section 6.5.2.2 lines 483 through 490 specify that when a process
! 120: ** sets or clears a lock, that operation overrides any prior locks set
! 121: ** by the same process. It does not explicitly say so, but this implies
! 122: ** that it overrides locks set by the same process using a different
! 123: ** file descriptor. Consider this test case:
! 124: **
! 125: ** int fd1 = open("./file1", O_RDWR|O_CREAT, 0644);
! 126: ** int fd2 = open("./file2", O_RDWR|O_CREAT, 0644);
! 127: **
! 128: ** Suppose ./file1 and ./file2 are really the same file (because
! 129: ** one is a hard or symbolic link to the other) then if you set
! 130: ** an exclusive lock on fd1, then try to get an exclusive lock
! 131: ** on fd2, it works. I would have expected the second lock to
! 132: ** fail since there was already a lock on the file due to fd1.
! 133: ** But not so. Since both locks came from the same process, the
! 134: ** second overrides the first, even though they were on different
! 135: ** file descriptors opened on different file names.
! 136: **
! 137: ** Bummer. If you ask me, this is broken. Badly broken. It means
! 138: ** that we cannot use POSIX locks to synchronize file access among
! 139: ** competing threads of the same process. POSIX locks will work fine
! 140: ** to synchronize access for threads in separate processes, but not
! 141: ** threads within the same process.
! 142: **
! 143: ** To work around the problem, SQLite has to manage file locks internally
! 144: ** on its own. Whenever a new database is opened, we have to find the
! 145: ** specific inode of the database file (the inode is determined by the
! 146: ** st_dev and st_ino fields of the stat structure that fstat() fills in)
! 147: ** and check for locks already existing on that inode. When locks are
! 148: ** created or removed, we have to look at our own internal record of the
! 149: ** locks to see if another thread has previously set a lock on that same
! 150: ** inode.
! 151: **
! 152: ** The OsFile structure for POSIX is no longer just an integer file
! 153: ** descriptor. It is now a structure that holds the integer file
! 154: ** descriptor and a pointer to a structure that describes the internal
! 155: ** locks on the corresponding inode. There is one locking structure
! 156: ** per inode, so if the same inode is opened twice, both OsFile structures
! 157: ** point to the same locking structure. The locking structure keeps
! 158: ** a reference count (so we will know when to delete it) and a "cnt"
! 159: ** field that tells us its internal lock status. cnt==0 means the
! 160: ** file is unlocked. cnt==-1 means the file has an exclusive lock.
! 161: ** cnt>0 means there are cnt shared locks on the file.
! 162: **
! 163: ** Any attempt to lock or unlock a file first checks the locking
! 164: ** structure. The fcntl() system call is only invoked to set a
! 165: ** POSIX lock if the internal lock structure transitions between
! 166: ** a locked and an unlocked state.
! 167: **
! 168: ** 2004-Jan-11:
! 169: ** More recent discoveries about POSIX advisory locks. (The more
! 170: ** I discover, the more I realize the a POSIX advisory locks are
! 171: ** an abomination.)
! 172: **
! 173: ** If you close a file descriptor that points to a file that has locks,
! 174: ** all locks on that file that are owned by the current process are
! 175: ** released. To work around this problem, each OsFile structure contains
! 176: ** a pointer to an openCnt structure. There is one openCnt structure
! 177: ** per open inode, which means that multiple OsFiles can point to a single
! 178: ** openCnt. When an attempt is made to close an OsFile, if there are
! 179: ** other OsFiles open on the same inode that are holding locks, the call
! 180: ** to close() the file descriptor is deferred until all of the locks clear.
! 181: ** The openCnt structure keeps a list of file descriptors that need to
! 182: ** be closed and that list is walked (and cleared) when the last lock
! 183: ** clears.
! 184: **
! 185: ** First, under Linux threads, because each thread has a separate
! 186: ** process ID, lock operations in one thread do not override locks
! 187: ** to the same file in other threads. Linux threads behave like
! 188: ** separate processes in this respect. But, if you close a file
! 189: ** descriptor in linux threads, all locks are cleared, even locks
! 190: ** on other threads and even though the other threads have different
! 191: ** process IDs. Linux threads is inconsistent in this respect.
! 192: ** (I'm beginning to think that linux threads is an abomination too.)
! 193: ** The consequence of this all is that the hash table for the lockInfo
! 194: ** structure has to include the process id as part of its key because
! 195: ** locks in different threads are treated as distinct. But the
! 196: ** openCnt structure should not include the process id in its
! 197: ** key because close() clears lock on all threads, not just the current
! 198: ** thread. Were it not for this goofiness in linux threads, we could
! 199: ** combine the lockInfo and openCnt structures into a single structure.
! 200: */
! 201:
! 202: /*
! 203: ** An instance of the following structure serves as the key used
! 204: ** to locate a particular lockInfo structure given its inode. Note
! 205: ** that we have to include the process ID as part of the key. On some
! 206: ** threading implementations (ex: linux), each thread has a separate
! 207: ** process ID.
! 208: */
! 209: struct lockKey {
! 210: dev_t dev; /* Device number */
! 211: ino_t ino; /* Inode number */
! 212: pid_t pid; /* Process ID */
! 213: };
! 214:
! 215: /*
! 216: ** An instance of the following structure is allocated for each open
! 217: ** inode on each thread with a different process ID. (Threads have
! 218: ** different process IDs on linux, but not on most other unixes.)
! 219: **
! 220: ** A single inode can have multiple file descriptors, so each OsFile
! 221: ** structure contains a pointer to an instance of this object and this
! 222: ** object keeps a count of the number of OsFiles pointing to it.
! 223: */
! 224: struct lockInfo {
! 225: struct lockKey key; /* The lookup key */
! 226: int cnt; /* 0: unlocked. -1: write lock. 1...: read lock. */
! 227: int nRef; /* Number of pointers to this structure */
! 228: };
! 229:
! 230: /*
! 231: ** An instance of the following structure serves as the key used
! 232: ** to locate a particular openCnt structure given its inode. This
! 233: ** is the same as the lockKey except that the process ID is omitted.
! 234: */
! 235: struct openKey {
! 236: dev_t dev; /* Device number */
! 237: ino_t ino; /* Inode number */
! 238: };
! 239:
! 240: /*
! 241: ** An instance of the following structure is allocated for each open
! 242: ** inode. This structure keeps track of the number of locks on that
! 243: ** inode. If a close is attempted against an inode that is holding
! 244: ** locks, the close is deferred until all locks clear by adding the
! 245: ** file descriptor to be closed to the pending list.
! 246: */
! 247: struct openCnt {
! 248: struct openKey key; /* The lookup key */
! 249: int nRef; /* Number of pointers to this structure */
! 250: int nLock; /* Number of outstanding locks */
! 251: int nPending; /* Number of pending close() operations */
! 252: int *aPending; /* Malloced space holding fd's awaiting a close() */
! 253: };
! 254:
! 255: /*
! 256: ** These hash table maps inodes and process IDs into lockInfo and openCnt
! 257: ** structures. Access to these hash tables must be protected by a mutex.
! 258: */
! 259: static Hash lockHash = { SQLITE_HASH_BINARY, 0, 0, 0, 0, 0 };
! 260: static Hash openHash = { SQLITE_HASH_BINARY, 0, 0, 0, 0, 0 };
! 261:
! 262: /*
! 263: ** Release a lockInfo structure previously allocated by findLockInfo().
! 264: */
! 265: static void releaseLockInfo(struct lockInfo *pLock){
! 266: pLock->nRef--;
! 267: if( pLock->nRef==0 ){
! 268: sqliteHashInsert(&lockHash, &pLock->key, sizeof(pLock->key), 0);
! 269: sqliteFree(pLock);
! 270: }
! 271: }
! 272:
! 273: /*
! 274: ** Release a openCnt structure previously allocated by findLockInfo().
! 275: */
! 276: static void releaseOpenCnt(struct openCnt *pOpen){
! 277: pOpen->nRef--;
! 278: if( pOpen->nRef==0 ){
! 279: sqliteHashInsert(&openHash, &pOpen->key, sizeof(pOpen->key), 0);
! 280: sqliteFree(pOpen->aPending);
! 281: sqliteFree(pOpen);
! 282: }
! 283: }
! 284:
! 285: /*
! 286: ** Given a file descriptor, locate lockInfo and openCnt structures that
! 287: ** describes that file descriptor. Create a new ones if necessary. The
! 288: ** return values might be unset if an error occurs.
! 289: **
! 290: ** Return the number of errors.
! 291: */
! 292: int findLockInfo(
! 293: int fd, /* The file descriptor used in the key */
! 294: struct lockInfo **ppLock, /* Return the lockInfo structure here */
! 295: struct openCnt **ppOpen /* Return the openCnt structure here */
! 296: ){
! 297: int rc;
! 298: struct lockKey key1;
! 299: struct openKey key2;
! 300: struct stat statbuf;
! 301: struct lockInfo *pLock;
! 302: struct openCnt *pOpen;
! 303: rc = fstat(fd, &statbuf);
! 304: if( rc!=0 ) return 1;
! 305: memset(&key1, 0, sizeof(key1));
! 306: key1.dev = statbuf.st_dev;
! 307: key1.ino = statbuf.st_ino;
! 308: key1.pid = getpid();
! 309: memset(&key2, 0, sizeof(key2));
! 310: key2.dev = statbuf.st_dev;
! 311: key2.ino = statbuf.st_ino;
! 312: pLock = (struct lockInfo*)sqliteHashFind(&lockHash, &key1, sizeof(key1));
! 313: if( pLock==0 ){
! 314: struct lockInfo *pOld;
! 315: pLock = sqliteMallocRaw( sizeof(*pLock) );
! 316: if( pLock==0 ) return 1;
! 317: pLock->key = key1;
! 318: pLock->nRef = 1;
! 319: pLock->cnt = 0;
! 320: pOld = sqliteHashInsert(&lockHash, &pLock->key, sizeof(key1), pLock);
! 321: if( pOld!=0 ){
! 322: assert( pOld==pLock );
! 323: sqliteFree(pLock);
! 324: return 1;
! 325: }
! 326: }else{
! 327: pLock->nRef++;
! 328: }
! 329: *ppLock = pLock;
! 330: pOpen = (struct openCnt*)sqliteHashFind(&openHash, &key2, sizeof(key2));
! 331: if( pOpen==0 ){
! 332: struct openCnt *pOld;
! 333: pOpen = sqliteMallocRaw( sizeof(*pOpen) );
! 334: if( pOpen==0 ){
! 335: releaseLockInfo(pLock);
! 336: return 1;
! 337: }
! 338: pOpen->key = key2;
! 339: pOpen->nRef = 1;
! 340: pOpen->nLock = 0;
! 341: pOpen->nPending = 0;
! 342: pOpen->aPending = 0;
! 343: pOld = sqliteHashInsert(&openHash, &pOpen->key, sizeof(key2), pOpen);
! 344: if( pOld!=0 ){
! 345: assert( pOld==pOpen );
! 346: sqliteFree(pOpen);
! 347: releaseLockInfo(pLock);
! 348: return 1;
! 349: }
! 350: }else{
! 351: pOpen->nRef++;
! 352: }
! 353: *ppOpen = pOpen;
! 354: return 0;
! 355: }
! 356:
! 357: #endif /** POSIX advisory lock work-around **/
! 358:
! 359: /*
! 360: ** If we compile with the SQLITE_TEST macro set, then the following block
! 361: ** of code will give us the ability to simulate a disk I/O error. This
! 362: ** is used for testing the I/O recovery logic.
! 363: */
! 364: #ifdef SQLITE_TEST
! 365: int sqlite_io_error_pending = 0;
! 366: #define SimulateIOError(A) \
! 367: if( sqlite_io_error_pending ) \
! 368: if( sqlite_io_error_pending-- == 1 ){ local_ioerr(); return A; }
! 369: static void local_ioerr(){
! 370: sqlite_io_error_pending = 0; /* Really just a place to set a breakpoint */
! 371: }
! 372: #else
! 373: #define SimulateIOError(A)
! 374: #endif
! 375:
! 376: /*
! 377: ** When testing, keep a count of the number of open files.
! 378: */
! 379: #ifdef SQLITE_TEST
! 380: int sqlite_open_file_count = 0;
! 381: #define OpenCounter(X) sqlite_open_file_count+=(X)
! 382: #else
! 383: #define OpenCounter(X)
! 384: #endif
! 385:
! 386:
! 387: /*
! 388: ** Delete the named file
! 389: */
! 390: int sqliteOsDelete(const char *zFilename){
! 391: #if OS_UNIX
! 392: unlink(zFilename);
! 393: #endif
! 394: #if OS_WIN
! 395: DeleteFile(zFilename);
! 396: #endif
! 397: #if OS_MAC
! 398: unlink(zFilename);
! 399: #endif
! 400: return SQLITE_OK;
! 401: }
! 402:
! 403: /*
! 404: ** Return TRUE if the named file exists.
! 405: */
! 406: int sqliteOsFileExists(const char *zFilename){
! 407: #if OS_UNIX
! 408: return access(zFilename, 0)==0;
! 409: #endif
! 410: #if OS_WIN
! 411: return GetFileAttributes(zFilename) != 0xffffffff;
! 412: #endif
! 413: #if OS_MAC
! 414: return access(zFilename, 0)==0;
! 415: #endif
! 416: }
! 417:
! 418:
! 419: #if 0 /* NOT USED */
! 420: /*
! 421: ** Change the name of an existing file.
! 422: */
! 423: int sqliteOsFileRename(const char *zOldName, const char *zNewName){
! 424: #if OS_UNIX
! 425: if( link(zOldName, zNewName) ){
! 426: return SQLITE_ERROR;
! 427: }
! 428: unlink(zOldName);
! 429: return SQLITE_OK;
! 430: #endif
! 431: #if OS_WIN
! 432: if( !MoveFile(zOldName, zNewName) ){
! 433: return SQLITE_ERROR;
! 434: }
! 435: return SQLITE_OK;
! 436: #endif
! 437: #if OS_MAC
! 438: /**** FIX ME ***/
! 439: return SQLITE_ERROR;
! 440: #endif
! 441: }
! 442: #endif /* NOT USED */
! 443:
! 444: /*
! 445: ** Attempt to open a file for both reading and writing. If that
! 446: ** fails, try opening it read-only. If the file does not exist,
! 447: ** try to create it.
! 448: **
! 449: ** On success, a handle for the open file is written to *id
! 450: ** and *pReadonly is set to 0 if the file was opened for reading and
! 451: ** writing or 1 if the file was opened read-only. The function returns
! 452: ** SQLITE_OK.
! 453: **
! 454: ** On failure, the function returns SQLITE_CANTOPEN and leaves
! 455: ** *id and *pReadonly unchanged.
! 456: */
! 457: int sqliteOsOpenReadWrite(
! 458: const char *zFilename,
! 459: OsFile *id,
! 460: int *pReadonly
! 461: ){
! 462: #if OS_UNIX
! 463: int rc;
! 464: id->dirfd = -1;
! 465: id->fd = open(zFilename, O_RDWR|O_CREAT|O_LARGEFILE|O_BINARY, 0644);
! 466: if( id->fd<0 ){
! 467: #ifdef EISDIR
! 468: if( errno==EISDIR ){
! 469: return SQLITE_CANTOPEN;
! 470: }
! 471: #endif
! 472: id->fd = open(zFilename, O_RDONLY|O_LARGEFILE|O_BINARY);
! 473: if( id->fd<0 ){
! 474: return SQLITE_CANTOPEN;
! 475: }
! 476: *pReadonly = 1;
! 477: }else{
! 478: *pReadonly = 0;
! 479: }
! 480: sqliteOsEnterMutex();
! 481: rc = findLockInfo(id->fd, &id->pLock, &id->pOpen);
! 482: sqliteOsLeaveMutex();
! 483: if( rc ){
! 484: close(id->fd);
! 485: return SQLITE_NOMEM;
! 486: }
! 487: id->locked = 0;
! 488: TRACE3("OPEN %-3d %s\n", id->fd, zFilename);
! 489: OpenCounter(+1);
! 490: return SQLITE_OK;
! 491: #endif
! 492: #if OS_WIN
! 493: HANDLE h = CreateFile(zFilename,
! 494: GENERIC_READ | GENERIC_WRITE,
! 495: FILE_SHARE_READ | FILE_SHARE_WRITE,
! 496: NULL,
! 497: OPEN_ALWAYS,
! 498: FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS,
! 499: NULL
! 500: );
! 501: if( h==INVALID_HANDLE_VALUE ){
! 502: h = CreateFile(zFilename,
! 503: GENERIC_READ,
! 504: FILE_SHARE_READ,
! 505: NULL,
! 506: OPEN_ALWAYS,
! 507: FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS,
! 508: NULL
! 509: );
! 510: if( h==INVALID_HANDLE_VALUE ){
! 511: return SQLITE_CANTOPEN;
! 512: }
! 513: *pReadonly = 1;
! 514: }else{
! 515: *pReadonly = 0;
! 516: }
! 517: id->h = h;
! 518: id->locked = 0;
! 519: OpenCounter(+1);
! 520: return SQLITE_OK;
! 521: #endif
! 522: #if OS_MAC
! 523: FSSpec fsSpec;
! 524: # ifdef _LARGE_FILE
! 525: HFSUniStr255 dfName;
! 526: FSRef fsRef;
! 527: if( __path2fss(zFilename, &fsSpec) != noErr ){
! 528: if( HCreate(fsSpec.vRefNum, fsSpec.parID, fsSpec.name, 'SQLI', cDocumentFile) != noErr )
! 529: return SQLITE_CANTOPEN;
! 530: }
! 531: if( FSpMakeFSRef(&fsSpec, &fsRef) != noErr )
! 532: return SQLITE_CANTOPEN;
! 533: FSGetDataForkName(&dfName);
! 534: if( FSOpenFork(&fsRef, dfName.length, dfName.unicode,
! 535: fsRdWrShPerm, &(id->refNum)) != noErr ){
! 536: if( FSOpenFork(&fsRef, dfName.length, dfName.unicode,
! 537: fsRdWrPerm, &(id->refNum)) != noErr ){
! 538: if (FSOpenFork(&fsRef, dfName.length, dfName.unicode,
! 539: fsRdPerm, &(id->refNum)) != noErr )
! 540: return SQLITE_CANTOPEN;
! 541: else
! 542: *pReadonly = 1;
! 543: } else
! 544: *pReadonly = 0;
! 545: } else
! 546: *pReadonly = 0;
! 547: # else
! 548: __path2fss(zFilename, &fsSpec);
! 549: if( !sqliteOsFileExists(zFilename) ){
! 550: if( HCreate(fsSpec.vRefNum, fsSpec.parID, fsSpec.name, 'SQLI', cDocumentFile) != noErr )
! 551: return SQLITE_CANTOPEN;
! 552: }
! 553: if( HOpenDF(fsSpec.vRefNum, fsSpec.parID, fsSpec.name, fsRdWrShPerm, &(id->refNum)) != noErr ){
! 554: if( HOpenDF(fsSpec.vRefNum, fsSpec.parID, fsSpec.name, fsRdWrPerm, &(id->refNum)) != noErr ){
! 555: if( HOpenDF(fsSpec.vRefNum, fsSpec.parID, fsSpec.name, fsRdPerm, &(id->refNum)) != noErr )
! 556: return SQLITE_CANTOPEN;
! 557: else
! 558: *pReadonly = 1;
! 559: } else
! 560: *pReadonly = 0;
! 561: } else
! 562: *pReadonly = 0;
! 563: # endif
! 564: if( HOpenRF(fsSpec.vRefNum, fsSpec.parID, fsSpec.name, fsRdWrShPerm, &(id->refNumRF)) != noErr){
! 565: id->refNumRF = -1;
! 566: }
! 567: id->locked = 0;
! 568: id->delOnClose = 0;
! 569: OpenCounter(+1);
! 570: return SQLITE_OK;
! 571: #endif
! 572: }
! 573:
! 574:
! 575: /*
! 576: ** Attempt to open a new file for exclusive access by this process.
! 577: ** The file will be opened for both reading and writing. To avoid
! 578: ** a potential security problem, we do not allow the file to have
! 579: ** previously existed. Nor do we allow the file to be a symbolic
! 580: ** link.
! 581: **
! 582: ** If delFlag is true, then make arrangements to automatically delete
! 583: ** the file when it is closed.
! 584: **
! 585: ** On success, write the file handle into *id and return SQLITE_OK.
! 586: **
! 587: ** On failure, return SQLITE_CANTOPEN.
! 588: */
! 589: int sqliteOsOpenExclusive(const char *zFilename, OsFile *id, int delFlag){
! 590: #if OS_UNIX
! 591: int rc;
! 592: if( access(zFilename, 0)==0 ){
! 593: return SQLITE_CANTOPEN;
! 594: }
! 595: id->dirfd = -1;
! 596: id->fd = open(zFilename,
! 597: O_RDWR|O_CREAT|O_EXCL|O_NOFOLLOW|O_LARGEFILE|O_BINARY, 0600);
! 598: if( id->fd<0 ){
! 599: return SQLITE_CANTOPEN;
! 600: }
! 601: sqliteOsEnterMutex();
! 602: rc = findLockInfo(id->fd, &id->pLock, &id->pOpen);
! 603: sqliteOsLeaveMutex();
! 604: if( rc ){
! 605: close(id->fd);
! 606: unlink(zFilename);
! 607: return SQLITE_NOMEM;
! 608: }
! 609: id->locked = 0;
! 610: if( delFlag ){
! 611: unlink(zFilename);
! 612: }
! 613: TRACE3("OPEN-EX %-3d %s\n", id->fd, zFilename);
! 614: OpenCounter(+1);
! 615: return SQLITE_OK;
! 616: #endif
! 617: #if OS_WIN
! 618: HANDLE h;
! 619: int fileflags;
! 620: if( delFlag ){
! 621: fileflags = FILE_ATTRIBUTE_TEMPORARY | FILE_FLAG_RANDOM_ACCESS
! 622: | FILE_FLAG_DELETE_ON_CLOSE;
! 623: }else{
! 624: fileflags = FILE_FLAG_RANDOM_ACCESS;
! 625: }
! 626: h = CreateFile(zFilename,
! 627: GENERIC_READ | GENERIC_WRITE,
! 628: 0,
! 629: NULL,
! 630: CREATE_ALWAYS,
! 631: fileflags,
! 632: NULL
! 633: );
! 634: if( h==INVALID_HANDLE_VALUE ){
! 635: return SQLITE_CANTOPEN;
! 636: }
! 637: id->h = h;
! 638: id->locked = 0;
! 639: OpenCounter(+1);
! 640: return SQLITE_OK;
! 641: #endif
! 642: #if OS_MAC
! 643: FSSpec fsSpec;
! 644: # ifdef _LARGE_FILE
! 645: HFSUniStr255 dfName;
! 646: FSRef fsRef;
! 647: __path2fss(zFilename, &fsSpec);
! 648: if( HCreate(fsSpec.vRefNum, fsSpec.parID, fsSpec.name, 'SQLI', cDocumentFile) != noErr )
! 649: return SQLITE_CANTOPEN;
! 650: if( FSpMakeFSRef(&fsSpec, &fsRef) != noErr )
! 651: return SQLITE_CANTOPEN;
! 652: FSGetDataForkName(&dfName);
! 653: if( FSOpenFork(&fsRef, dfName.length, dfName.unicode,
! 654: fsRdWrPerm, &(id->refNum)) != noErr )
! 655: return SQLITE_CANTOPEN;
! 656: # else
! 657: __path2fss(zFilename, &fsSpec);
! 658: if( HCreate(fsSpec.vRefNum, fsSpec.parID, fsSpec.name, 'SQLI', cDocumentFile) != noErr )
! 659: return SQLITE_CANTOPEN;
! 660: if( HOpenDF(fsSpec.vRefNum, fsSpec.parID, fsSpec.name, fsRdWrPerm, &(id->refNum)) != noErr )
! 661: return SQLITE_CANTOPEN;
! 662: # endif
! 663: id->refNumRF = -1;
! 664: id->locked = 0;
! 665: id->delOnClose = delFlag;
! 666: if (delFlag)
! 667: id->pathToDel = sqliteOsFullPathname(zFilename);
! 668: OpenCounter(+1);
! 669: return SQLITE_OK;
! 670: #endif
! 671: }
! 672:
! 673: /*
! 674: ** Attempt to open a new file for read-only access.
! 675: **
! 676: ** On success, write the file handle into *id and return SQLITE_OK.
! 677: **
! 678: ** On failure, return SQLITE_CANTOPEN.
! 679: */
! 680: int sqliteOsOpenReadOnly(const char *zFilename, OsFile *id){
! 681: #if OS_UNIX
! 682: int rc;
! 683: id->dirfd = -1;
! 684: id->fd = open(zFilename, O_RDONLY|O_LARGEFILE|O_BINARY);
! 685: if( id->fd<0 ){
! 686: return SQLITE_CANTOPEN;
! 687: }
! 688: sqliteOsEnterMutex();
! 689: rc = findLockInfo(id->fd, &id->pLock, &id->pOpen);
! 690: sqliteOsLeaveMutex();
! 691: if( rc ){
! 692: close(id->fd);
! 693: return SQLITE_NOMEM;
! 694: }
! 695: id->locked = 0;
! 696: TRACE3("OPEN-RO %-3d %s\n", id->fd, zFilename);
! 697: OpenCounter(+1);
! 698: return SQLITE_OK;
! 699: #endif
! 700: #if OS_WIN
! 701: HANDLE h = CreateFile(zFilename,
! 702: GENERIC_READ,
! 703: 0,
! 704: NULL,
! 705: OPEN_EXISTING,
! 706: FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS,
! 707: NULL
! 708: );
! 709: if( h==INVALID_HANDLE_VALUE ){
! 710: return SQLITE_CANTOPEN;
! 711: }
! 712: id->h = h;
! 713: id->locked = 0;
! 714: OpenCounter(+1);
! 715: return SQLITE_OK;
! 716: #endif
! 717: #if OS_MAC
! 718: FSSpec fsSpec;
! 719: # ifdef _LARGE_FILE
! 720: HFSUniStr255 dfName;
! 721: FSRef fsRef;
! 722: if( __path2fss(zFilename, &fsSpec) != noErr )
! 723: return SQLITE_CANTOPEN;
! 724: if( FSpMakeFSRef(&fsSpec, &fsRef) != noErr )
! 725: return SQLITE_CANTOPEN;
! 726: FSGetDataForkName(&dfName);
! 727: if( FSOpenFork(&fsRef, dfName.length, dfName.unicode,
! 728: fsRdPerm, &(id->refNum)) != noErr )
! 729: return SQLITE_CANTOPEN;
! 730: # else
! 731: __path2fss(zFilename, &fsSpec);
! 732: if( HOpenDF(fsSpec.vRefNum, fsSpec.parID, fsSpec.name, fsRdPerm, &(id->refNum)) != noErr )
! 733: return SQLITE_CANTOPEN;
! 734: # endif
! 735: if( HOpenRF(fsSpec.vRefNum, fsSpec.parID, fsSpec.name, fsRdWrShPerm, &(id->refNumRF)) != noErr){
! 736: id->refNumRF = -1;
! 737: }
! 738: id->locked = 0;
! 739: id->delOnClose = 0;
! 740: OpenCounter(+1);
! 741: return SQLITE_OK;
! 742: #endif
! 743: }
! 744:
! 745: /*
! 746: ** Attempt to open a file descriptor for the directory that contains a
! 747: ** file. This file descriptor can be used to fsync() the directory
! 748: ** in order to make sure the creation of a new file is actually written
! 749: ** to disk.
! 750: **
! 751: ** This routine is only meaningful for Unix. It is a no-op under
! 752: ** windows since windows does not support hard links.
! 753: **
! 754: ** On success, a handle for a previously open file is at *id is
! 755: ** updated with the new directory file descriptor and SQLITE_OK is
! 756: ** returned.
! 757: **
! 758: ** On failure, the function returns SQLITE_CANTOPEN and leaves
! 759: ** *id unchanged.
! 760: */
! 761: int sqliteOsOpenDirectory(
! 762: const char *zDirname,
! 763: OsFile *id
! 764: ){
! 765: #if OS_UNIX
! 766: if( id->fd<0 ){
! 767: /* Do not open the directory if the corresponding file is not already
! 768: ** open. */
! 769: return SQLITE_CANTOPEN;
! 770: }
! 771: assert( id->dirfd<0 );
! 772: id->dirfd = open(zDirname, O_RDONLY|O_BINARY, 0644);
! 773: if( id->dirfd<0 ){
! 774: return SQLITE_CANTOPEN;
! 775: }
! 776: TRACE3("OPENDIR %-3d %s\n", id->dirfd, zDirname);
! 777: #endif
! 778: return SQLITE_OK;
! 779: }
! 780:
! 781: /*
! 782: ** If the following global variable points to a string which is the
! 783: ** name of a directory, then that directory will be used to store
! 784: ** temporary files.
! 785: */
! 786: const char *sqlite_temp_directory = 0;
! 787:
! 788: /*
! 789: ** Create a temporary file name in zBuf. zBuf must be big enough to
! 790: ** hold at least SQLITE_TEMPNAME_SIZE characters.
! 791: */
! 792: int sqliteOsTempFileName(char *zBuf){
! 793: #if OS_UNIX
! 794: static const char *azDirs[] = {
! 795: 0,
! 796: "/var/tmp",
! 797: "/usr/tmp",
! 798: "/tmp",
! 799: ".",
! 800: };
! 801: static unsigned char zChars[] =
! 802: "abcdefghijklmnopqrstuvwxyz"
! 803: "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
! 804: "0123456789";
! 805: int i, j;
! 806: struct stat buf;
! 807: const char *zDir = ".";
! 808: azDirs[0] = sqlite_temp_directory;
! 809: for(i=0; i<sizeof(azDirs)/sizeof(azDirs[0]); i++){
! 810: if( azDirs[i]==0 ) continue;
! 811: if( stat(azDirs[i], &buf) ) continue;
! 812: if( !S_ISDIR(buf.st_mode) ) continue;
! 813: if( access(azDirs[i], 07) ) continue;
! 814: zDir = azDirs[i];
! 815: break;
! 816: }
! 817: do{
! 818: sprintf(zBuf, "%s/"TEMP_FILE_PREFIX, zDir);
! 819: j = strlen(zBuf);
! 820: sqliteRandomness(15, &zBuf[j]);
! 821: for(i=0; i<15; i++, j++){
! 822: zBuf[j] = (char)zChars[ ((unsigned char)zBuf[j])%(sizeof(zChars)-1) ];
! 823: }
! 824: zBuf[j] = 0;
! 825: }while( access(zBuf,0)==0 );
! 826: #endif
! 827: #if OS_WIN
! 828: static char zChars[] =
! 829: "abcdefghijklmnopqrstuvwxyz"
! 830: "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
! 831: "0123456789";
! 832: int i, j;
! 833: const char *zDir;
! 834: char zTempPath[SQLITE_TEMPNAME_SIZE];
! 835: if( sqlite_temp_directory==0 ){
! 836: GetTempPath(SQLITE_TEMPNAME_SIZE-30, zTempPath);
! 837: for(i=strlen(zTempPath); i>0 && zTempPath[i-1]=='\\'; i--){}
! 838: zTempPath[i] = 0;
! 839: zDir = zTempPath;
! 840: }else{
! 841: zDir = sqlite_temp_directory;
! 842: }
! 843: for(;;){
! 844: sprintf(zBuf, "%s\\"TEMP_FILE_PREFIX, zDir);
! 845: j = strlen(zBuf);
! 846: sqliteRandomness(15, &zBuf[j]);
! 847: for(i=0; i<15; i++, j++){
! 848: zBuf[j] = (char)zChars[ ((unsigned char)zBuf[j])%(sizeof(zChars)-1) ];
! 849: }
! 850: zBuf[j] = 0;
! 851: if( !sqliteOsFileExists(zBuf) ) break;
! 852: }
! 853: #endif
! 854: #if OS_MAC
! 855: static char zChars[] =
! 856: "abcdefghijklmnopqrstuvwxyz"
! 857: "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
! 858: "0123456789";
! 859: int i, j;
! 860: char *zDir;
! 861: char zTempPath[SQLITE_TEMPNAME_SIZE];
! 862: char zdirName[32];
! 863: CInfoPBRec infoRec;
! 864: Str31 dirName;
! 865: memset(&infoRec, 0, sizeof(infoRec));
! 866: memset(zTempPath, 0, SQLITE_TEMPNAME_SIZE);
! 867: if( sqlite_temp_directory!=0 ){
! 868: zDir = sqlite_temp_directory;
! 869: }else if( FindFolder(kOnSystemDisk, kTemporaryFolderType, kCreateFolder,
! 870: &(infoRec.dirInfo.ioVRefNum), &(infoRec.dirInfo.ioDrParID)) == noErr ){
! 871: infoRec.dirInfo.ioNamePtr = dirName;
! 872: do{
! 873: infoRec.dirInfo.ioFDirIndex = -1;
! 874: infoRec.dirInfo.ioDrDirID = infoRec.dirInfo.ioDrParID;
! 875: if( PBGetCatInfoSync(&infoRec) == noErr ){
! 876: CopyPascalStringToC(dirName, zdirName);
! 877: i = strlen(zdirName);
! 878: memmove(&(zTempPath[i+1]), zTempPath, strlen(zTempPath));
! 879: strcpy(zTempPath, zdirName);
! 880: zTempPath[i] = ':';
! 881: }else{
! 882: *zTempPath = 0;
! 883: break;
! 884: }
! 885: } while( infoRec.dirInfo.ioDrDirID != fsRtDirID );
! 886: zDir = zTempPath;
! 887: }
! 888: if( zDir[0]==0 ){
! 889: getcwd(zTempPath, SQLITE_TEMPNAME_SIZE-24);
! 890: zDir = zTempPath;
! 891: }
! 892: for(;;){
! 893: sprintf(zBuf, "%s"TEMP_FILE_PREFIX, zDir);
! 894: j = strlen(zBuf);
! 895: sqliteRandomness(15, &zBuf[j]);
! 896: for(i=0; i<15; i++, j++){
! 897: zBuf[j] = (char)zChars[ ((unsigned char)zBuf[j])%(sizeof(zChars)-1) ];
! 898: }
! 899: zBuf[j] = 0;
! 900: if( !sqliteOsFileExists(zBuf) ) break;
! 901: }
! 902: #endif
! 903: return SQLITE_OK;
! 904: }
! 905:
! 906: /*
! 907: ** Close a file.
! 908: */
! 909: int sqliteOsClose(OsFile *id){
! 910: #if OS_UNIX
! 911: sqliteOsUnlock(id);
! 912: if( id->dirfd>=0 ) close(id->dirfd);
! 913: id->dirfd = -1;
! 914: sqliteOsEnterMutex();
! 915: if( id->pOpen->nLock ){
! 916: /* If there are outstanding locks, do not actually close the file just
! 917: ** yet because that would clear those locks. Instead, add the file
! 918: ** descriptor to pOpen->aPending. It will be automatically closed when
! 919: ** the last lock is cleared.
! 920: */
! 921: int *aNew;
! 922: struct openCnt *pOpen = id->pOpen;
! 923: pOpen->nPending++;
! 924: aNew = sqliteRealloc( pOpen->aPending, pOpen->nPending*sizeof(int) );
! 925: if( aNew==0 ){
! 926: /* If a malloc fails, just leak the file descriptor */
! 927: }else{
! 928: pOpen->aPending = aNew;
! 929: pOpen->aPending[pOpen->nPending-1] = id->fd;
! 930: }
! 931: }else{
! 932: /* There are no outstanding locks so we can close the file immediately */
! 933: close(id->fd);
! 934: }
! 935: releaseLockInfo(id->pLock);
! 936: releaseOpenCnt(id->pOpen);
! 937: sqliteOsLeaveMutex();
! 938: TRACE2("CLOSE %-3d\n", id->fd);
! 939: OpenCounter(-1);
! 940: return SQLITE_OK;
! 941: #endif
! 942: #if OS_WIN
! 943: CloseHandle(id->h);
! 944: OpenCounter(-1);
! 945: return SQLITE_OK;
! 946: #endif
! 947: #if OS_MAC
! 948: if( id->refNumRF!=-1 )
! 949: FSClose(id->refNumRF);
! 950: # ifdef _LARGE_FILE
! 951: FSCloseFork(id->refNum);
! 952: # else
! 953: FSClose(id->refNum);
! 954: # endif
! 955: if( id->delOnClose ){
! 956: unlink(id->pathToDel);
! 957: sqliteFree(id->pathToDel);
! 958: }
! 959: OpenCounter(-1);
! 960: return SQLITE_OK;
! 961: #endif
! 962: }
! 963:
! 964: /*
! 965: ** Read data from a file into a buffer. Return SQLITE_OK if all
! 966: ** bytes were read successfully and SQLITE_IOERR if anything goes
! 967: ** wrong.
! 968: */
! 969: int sqliteOsRead(OsFile *id, void *pBuf, int amt){
! 970: #if OS_UNIX
! 971: int got;
! 972: SimulateIOError(SQLITE_IOERR);
! 973: TIMER_START;
! 974: got = read(id->fd, pBuf, amt);
! 975: TIMER_END;
! 976: TRACE4("READ %-3d %7d %d\n", id->fd, last_page, elapse);
! 977: SEEK(0);
! 978: /* if( got<0 ) got = 0; */
! 979: if( got==amt ){
! 980: return SQLITE_OK;
! 981: }else{
! 982: return SQLITE_IOERR;
! 983: }
! 984: #endif
! 985: #if OS_WIN
! 986: DWORD got;
! 987: SimulateIOError(SQLITE_IOERR);
! 988: TRACE2("READ %d\n", last_page);
! 989: if( !ReadFile(id->h, pBuf, amt, &got, 0) ){
! 990: got = 0;
! 991: }
! 992: if( got==(DWORD)amt ){
! 993: return SQLITE_OK;
! 994: }else{
! 995: return SQLITE_IOERR;
! 996: }
! 997: #endif
! 998: #if OS_MAC
! 999: int got;
! 1000: SimulateIOError(SQLITE_IOERR);
! 1001: TRACE2("READ %d\n", last_page);
! 1002: # ifdef _LARGE_FILE
! 1003: FSReadFork(id->refNum, fsAtMark, 0, (ByteCount)amt, pBuf, (ByteCount*)&got);
! 1004: # else
! 1005: got = amt;
! 1006: FSRead(id->refNum, &got, pBuf);
! 1007: # endif
! 1008: if( got==amt ){
! 1009: return SQLITE_OK;
! 1010: }else{
! 1011: return SQLITE_IOERR;
! 1012: }
! 1013: #endif
! 1014: }
! 1015:
! 1016: /*
! 1017: ** Write data from a buffer into a file. Return SQLITE_OK on success
! 1018: ** or some other error code on failure.
! 1019: */
! 1020: int sqliteOsWrite(OsFile *id, const void *pBuf, int amt){
! 1021: #if OS_UNIX
! 1022: int wrote = 0;
! 1023: SimulateIOError(SQLITE_IOERR);
! 1024: TIMER_START;
! 1025: while( amt>0 && (wrote = write(id->fd, pBuf, amt))>0 ){
! 1026: amt -= wrote;
! 1027: pBuf = &((char*)pBuf)[wrote];
! 1028: }
! 1029: TIMER_END;
! 1030: TRACE4("WRITE %-3d %7d %d\n", id->fd, last_page, elapse);
! 1031: SEEK(0);
! 1032: if( amt>0 ){
! 1033: return SQLITE_FULL;
! 1034: }
! 1035: return SQLITE_OK;
! 1036: #endif
! 1037: #if OS_WIN
! 1038: int rc;
! 1039: DWORD wrote;
! 1040: SimulateIOError(SQLITE_IOERR);
! 1041: TRACE2("WRITE %d\n", last_page);
! 1042: while( amt>0 && (rc = WriteFile(id->h, pBuf, amt, &wrote, 0))!=0 && wrote>0 ){
! 1043: amt -= wrote;
! 1044: pBuf = &((char*)pBuf)[wrote];
! 1045: }
! 1046: if( !rc || amt>(int)wrote ){
! 1047: return SQLITE_FULL;
! 1048: }
! 1049: return SQLITE_OK;
! 1050: #endif
! 1051: #if OS_MAC
! 1052: OSErr oserr;
! 1053: int wrote = 0;
! 1054: SimulateIOError(SQLITE_IOERR);
! 1055: TRACE2("WRITE %d\n", last_page);
! 1056: while( amt>0 ){
! 1057: # ifdef _LARGE_FILE
! 1058: oserr = FSWriteFork(id->refNum, fsAtMark, 0,
! 1059: (ByteCount)amt, pBuf, (ByteCount*)&wrote);
! 1060: # else
! 1061: wrote = amt;
! 1062: oserr = FSWrite(id->refNum, &wrote, pBuf);
! 1063: # endif
! 1064: if( wrote == 0 || oserr != noErr)
! 1065: break;
! 1066: amt -= wrote;
! 1067: pBuf = &((char*)pBuf)[wrote];
! 1068: }
! 1069: if( oserr != noErr || amt>wrote ){
! 1070: return SQLITE_FULL;
! 1071: }
! 1072: return SQLITE_OK;
! 1073: #endif
! 1074: }
! 1075:
! 1076: /*
! 1077: ** Move the read/write pointer in a file.
! 1078: */
! 1079: int sqliteOsSeek(OsFile *id, off_t offset){
! 1080: SEEK(offset/1024 + 1);
! 1081: #if OS_UNIX
! 1082: lseek(id->fd, offset, SEEK_SET);
! 1083: return SQLITE_OK;
! 1084: #endif
! 1085: #if OS_WIN
! 1086: {
! 1087: LONG upperBits = offset>>32;
! 1088: LONG lowerBits = offset & 0xffffffff;
! 1089: DWORD rc;
! 1090: rc = SetFilePointer(id->h, lowerBits, &upperBits, FILE_BEGIN);
! 1091: /* TRACE3("SEEK rc=0x%x upper=0x%x\n", rc, upperBits); */
! 1092: }
! 1093: return SQLITE_OK;
! 1094: #endif
! 1095: #if OS_MAC
! 1096: {
! 1097: off_t curSize;
! 1098: if( sqliteOsFileSize(id, &curSize) != SQLITE_OK ){
! 1099: return SQLITE_IOERR;
! 1100: }
! 1101: if( offset >= curSize ){
! 1102: if( sqliteOsTruncate(id, offset+1) != SQLITE_OK ){
! 1103: return SQLITE_IOERR;
! 1104: }
! 1105: }
! 1106: # ifdef _LARGE_FILE
! 1107: if( FSSetForkPosition(id->refNum, fsFromStart, offset) != noErr ){
! 1108: # else
! 1109: if( SetFPos(id->refNum, fsFromStart, offset) != noErr ){
! 1110: # endif
! 1111: return SQLITE_IOERR;
! 1112: }else{
! 1113: return SQLITE_OK;
! 1114: }
! 1115: }
! 1116: #endif
! 1117: }
! 1118:
! 1119: #ifdef SQLITE_NOSYNC
! 1120: # define fsync(X) 0
! 1121: #endif
! 1122:
! 1123: /*
! 1124: ** Make sure all writes to a particular file are committed to disk.
! 1125: **
! 1126: ** Under Unix, also make sure that the directory entry for the file
! 1127: ** has been created by fsync-ing the directory that contains the file.
! 1128: ** If we do not do this and we encounter a power failure, the directory
! 1129: ** entry for the journal might not exist after we reboot. The next
! 1130: ** SQLite to access the file will not know that the journal exists (because
! 1131: ** the directory entry for the journal was never created) and the transaction
! 1132: ** will not roll back - possibly leading to database corruption.
! 1133: */
! 1134: int sqliteOsSync(OsFile *id){
! 1135: #if OS_UNIX
! 1136: SimulateIOError(SQLITE_IOERR);
! 1137: TRACE2("SYNC %-3d\n", id->fd);
! 1138: if( fsync(id->fd) ){
! 1139: return SQLITE_IOERR;
! 1140: }else{
! 1141: if( id->dirfd>=0 ){
! 1142: TRACE2("DIRSYNC %-3d\n", id->dirfd);
! 1143: fsync(id->dirfd);
! 1144: close(id->dirfd); /* Only need to sync once, so close the directory */
! 1145: id->dirfd = -1; /* when we are done. */
! 1146: }
! 1147: return SQLITE_OK;
! 1148: }
! 1149: #endif
! 1150: #if OS_WIN
! 1151: if( FlushFileBuffers(id->h) ){
! 1152: return SQLITE_OK;
! 1153: }else{
! 1154: return SQLITE_IOERR;
! 1155: }
! 1156: #endif
! 1157: #if OS_MAC
! 1158: # ifdef _LARGE_FILE
! 1159: if( FSFlushFork(id->refNum) != noErr ){
! 1160: # else
! 1161: ParamBlockRec params;
! 1162: memset(¶ms, 0, sizeof(ParamBlockRec));
! 1163: params.ioParam.ioRefNum = id->refNum;
! 1164: if( PBFlushFileSync(¶ms) != noErr ){
! 1165: # endif
! 1166: return SQLITE_IOERR;
! 1167: }else{
! 1168: return SQLITE_OK;
! 1169: }
! 1170: #endif
! 1171: }
! 1172:
! 1173: /*
! 1174: ** Truncate an open file to a specified size
! 1175: */
! 1176: int sqliteOsTruncate(OsFile *id, off_t nByte){
! 1177: SimulateIOError(SQLITE_IOERR);
! 1178: #if OS_UNIX
! 1179: return ftruncate(id->fd, nByte)==0 ? SQLITE_OK : SQLITE_IOERR;
! 1180: #endif
! 1181: #if OS_WIN
! 1182: {
! 1183: LONG upperBits = nByte>>32;
! 1184: SetFilePointer(id->h, nByte, &upperBits, FILE_BEGIN);
! 1185: SetEndOfFile(id->h);
! 1186: }
! 1187: return SQLITE_OK;
! 1188: #endif
! 1189: #if OS_MAC
! 1190: # ifdef _LARGE_FILE
! 1191: if( FSSetForkSize(id->refNum, fsFromStart, nByte) != noErr){
! 1192: # else
! 1193: if( SetEOF(id->refNum, nByte) != noErr ){
! 1194: # endif
! 1195: return SQLITE_IOERR;
! 1196: }else{
! 1197: return SQLITE_OK;
! 1198: }
! 1199: #endif
! 1200: }
! 1201:
! 1202: /*
! 1203: ** Determine the current size of a file in bytes
! 1204: */
! 1205: int sqliteOsFileSize(OsFile *id, off_t *pSize){
! 1206: #if OS_UNIX
! 1207: struct stat buf;
! 1208: SimulateIOError(SQLITE_IOERR);
! 1209: if( fstat(id->fd, &buf)!=0 ){
! 1210: return SQLITE_IOERR;
! 1211: }
! 1212: *pSize = buf.st_size;
! 1213: return SQLITE_OK;
! 1214: #endif
! 1215: #if OS_WIN
! 1216: DWORD upperBits, lowerBits;
! 1217: SimulateIOError(SQLITE_IOERR);
! 1218: lowerBits = GetFileSize(id->h, &upperBits);
! 1219: *pSize = (((off_t)upperBits)<<32) + lowerBits;
! 1220: return SQLITE_OK;
! 1221: #endif
! 1222: #if OS_MAC
! 1223: # ifdef _LARGE_FILE
! 1224: if( FSGetForkSize(id->refNum, pSize) != noErr){
! 1225: # else
! 1226: if( GetEOF(id->refNum, pSize) != noErr ){
! 1227: # endif
! 1228: return SQLITE_IOERR;
! 1229: }else{
! 1230: return SQLITE_OK;
! 1231: }
! 1232: #endif
! 1233: }
! 1234:
! 1235: #if OS_WIN
! 1236: /*
! 1237: ** Return true (non-zero) if we are running under WinNT, Win2K or WinXP.
! 1238: ** Return false (zero) for Win95, Win98, or WinME.
! 1239: **
! 1240: ** Here is an interesting observation: Win95, Win98, and WinME lack
! 1241: ** the LockFileEx() API. But we can still statically link against that
! 1242: ** API as long as we don't call it win running Win95/98/ME. A call to
! 1243: ** this routine is used to determine if the host is Win95/98/ME or
! 1244: ** WinNT/2K/XP so that we will know whether or not we can safely call
! 1245: ** the LockFileEx() API.
! 1246: */
! 1247: int isNT(void){
! 1248: static int osType = 0; /* 0=unknown 1=win95 2=winNT */
! 1249: if( osType==0 ){
! 1250: OSVERSIONINFO sInfo;
! 1251: sInfo.dwOSVersionInfoSize = sizeof(sInfo);
! 1252: GetVersionEx(&sInfo);
! 1253: osType = sInfo.dwPlatformId==VER_PLATFORM_WIN32_NT ? 2 : 1;
! 1254: }
! 1255: return osType==2;
! 1256: }
! 1257: #endif
! 1258:
! 1259: /*
! 1260: ** Windows file locking notes: [similar issues apply to MacOS]
! 1261: **
! 1262: ** We cannot use LockFileEx() or UnlockFileEx() on Win95/98/ME because
! 1263: ** those functions are not available. So we use only LockFile() and
! 1264: ** UnlockFile().
! 1265: **
! 1266: ** LockFile() prevents not just writing but also reading by other processes.
! 1267: ** (This is a design error on the part of Windows, but there is nothing
! 1268: ** we can do about that.) So the region used for locking is at the
! 1269: ** end of the file where it is unlikely to ever interfere with an
! 1270: ** actual read attempt.
! 1271: **
! 1272: ** A database read lock is obtained by locking a single randomly-chosen
! 1273: ** byte out of a specific range of bytes. The lock byte is obtained at
! 1274: ** random so two separate readers can probably access the file at the
! 1275: ** same time, unless they are unlucky and choose the same lock byte.
! 1276: ** A database write lock is obtained by locking all bytes in the range.
! 1277: ** There can only be one writer.
! 1278: **
! 1279: ** A lock is obtained on the first byte of the lock range before acquiring
! 1280: ** either a read lock or a write lock. This prevents two processes from
! 1281: ** attempting to get a lock at a same time. The semantics of
! 1282: ** sqliteOsReadLock() require that if there is already a write lock, that
! 1283: ** lock is converted into a read lock atomically. The lock on the first
! 1284: ** byte allows us to drop the old write lock and get the read lock without
! 1285: ** another process jumping into the middle and messing us up. The same
! 1286: ** argument applies to sqliteOsWriteLock().
! 1287: **
! 1288: ** On WinNT/2K/XP systems, LockFileEx() and UnlockFileEx() are available,
! 1289: ** which means we can use reader/writer locks. When reader writer locks
! 1290: ** are used, the lock is placed on the same range of bytes that is used
! 1291: ** for probabilistic locking in Win95/98/ME. Hence, the locking scheme
! 1292: ** will support two or more Win95 readers or two or more WinNT readers.
! 1293: ** But a single Win95 reader will lock out all WinNT readers and a single
! 1294: ** WinNT reader will lock out all other Win95 readers.
! 1295: **
! 1296: ** Note: On MacOS we use the resource fork for locking.
! 1297: **
! 1298: ** The following #defines specify the range of bytes used for locking.
! 1299: ** N_LOCKBYTE is the number of bytes available for doing the locking.
! 1300: ** The first byte used to hold the lock while the lock is changing does
! 1301: ** not count toward this number. FIRST_LOCKBYTE is the address of
! 1302: ** the first byte in the range of bytes used for locking.
! 1303: */
! 1304: #define N_LOCKBYTE 10239
! 1305: #if OS_MAC
! 1306: # define FIRST_LOCKBYTE (0x000fffff - N_LOCKBYTE)
! 1307: #else
! 1308: # define FIRST_LOCKBYTE (0xffffffff - N_LOCKBYTE)
! 1309: #endif
! 1310:
! 1311: /*
! 1312: ** Change the status of the lock on the file "id" to be a readlock.
! 1313: ** If the file was write locked, then this reduces the lock to a read.
! 1314: ** If the file was read locked, then this acquires a new read lock.
! 1315: **
! 1316: ** Return SQLITE_OK on success and SQLITE_BUSY on failure. If this
! 1317: ** library was compiled with large file support (LFS) but LFS is not
! 1318: ** available on the host, then an SQLITE_NOLFS is returned.
! 1319: */
! 1320: int sqliteOsReadLock(OsFile *id){
! 1321: #if OS_UNIX
! 1322: int rc;
! 1323: sqliteOsEnterMutex();
! 1324: if( id->pLock->cnt>0 ){
! 1325: if( !id->locked ){
! 1326: id->pLock->cnt++;
! 1327: id->locked = 1;
! 1328: id->pOpen->nLock++;
! 1329: }
! 1330: rc = SQLITE_OK;
! 1331: }else if( id->locked || id->pLock->cnt==0 ){
! 1332: struct flock lock;
! 1333: int s;
! 1334: lock.l_type = F_RDLCK;
! 1335: lock.l_whence = SEEK_SET;
! 1336: lock.l_start = lock.l_len = 0L;
! 1337: s = fcntl(id->fd, F_SETLK, &lock);
! 1338: if( s!=0 ){
! 1339: rc = (errno==EINVAL) ? SQLITE_NOLFS : SQLITE_BUSY;
! 1340: }else{
! 1341: rc = SQLITE_OK;
! 1342: if( !id->locked ){
! 1343: id->pOpen->nLock++;
! 1344: id->locked = 1;
! 1345: }
! 1346: id->pLock->cnt = 1;
! 1347: }
! 1348: }else{
! 1349: rc = SQLITE_BUSY;
! 1350: }
! 1351: sqliteOsLeaveMutex();
! 1352: return rc;
! 1353: #endif
! 1354: #if OS_WIN
! 1355: int rc;
! 1356: if( id->locked>0 ){
! 1357: rc = SQLITE_OK;
! 1358: }else{
! 1359: int lk;
! 1360: int res;
! 1361: int cnt = 100;
! 1362: sqliteRandomness(sizeof(lk), &lk);
! 1363: lk = (lk & 0x7fffffff)%N_LOCKBYTE + 1;
! 1364: while( cnt-->0 && (res = LockFile(id->h, FIRST_LOCKBYTE, 0, 1, 0))==0 ){
! 1365: Sleep(1);
! 1366: }
! 1367: if( res ){
! 1368: UnlockFile(id->h, FIRST_LOCKBYTE+1, 0, N_LOCKBYTE, 0);
! 1369: if( isNT() ){
! 1370: OVERLAPPED ovlp;
! 1371: ovlp.Offset = FIRST_LOCKBYTE+1;
! 1372: ovlp.OffsetHigh = 0;
! 1373: ovlp.hEvent = 0;
! 1374: res = LockFileEx(id->h, LOCKFILE_FAIL_IMMEDIATELY,
! 1375: 0, N_LOCKBYTE, 0, &ovlp);
! 1376: }else{
! 1377: res = LockFile(id->h, FIRST_LOCKBYTE+lk, 0, 1, 0);
! 1378: }
! 1379: UnlockFile(id->h, FIRST_LOCKBYTE, 0, 1, 0);
! 1380: }
! 1381: if( res ){
! 1382: id->locked = lk;
! 1383: rc = SQLITE_OK;
! 1384: }else{
! 1385: rc = SQLITE_BUSY;
! 1386: }
! 1387: }
! 1388: return rc;
! 1389: #endif
! 1390: #if OS_MAC
! 1391: int rc;
! 1392: if( id->locked>0 || id->refNumRF == -1 ){
! 1393: rc = SQLITE_OK;
! 1394: }else{
! 1395: int lk;
! 1396: OSErr res;
! 1397: int cnt = 5;
! 1398: ParamBlockRec params;
! 1399: sqliteRandomness(sizeof(lk), &lk);
! 1400: lk = (lk & 0x7fffffff)%N_LOCKBYTE + 1;
! 1401: memset(¶ms, 0, sizeof(params));
! 1402: params.ioParam.ioRefNum = id->refNumRF;
! 1403: params.ioParam.ioPosMode = fsFromStart;
! 1404: params.ioParam.ioPosOffset = FIRST_LOCKBYTE;
! 1405: params.ioParam.ioReqCount = 1;
! 1406: while( cnt-->0 && (res = PBLockRangeSync(¶ms))!=noErr ){
! 1407: UInt32 finalTicks;
! 1408: Delay(1, &finalTicks); /* 1/60 sec */
! 1409: }
! 1410: if( res == noErr ){
! 1411: params.ioParam.ioPosOffset = FIRST_LOCKBYTE+1;
! 1412: params.ioParam.ioReqCount = N_LOCKBYTE;
! 1413: PBUnlockRangeSync(¶ms);
! 1414: params.ioParam.ioPosOffset = FIRST_LOCKBYTE+lk;
! 1415: params.ioParam.ioReqCount = 1;
! 1416: res = PBLockRangeSync(¶ms);
! 1417: params.ioParam.ioPosOffset = FIRST_LOCKBYTE;
! 1418: params.ioParam.ioReqCount = 1;
! 1419: PBUnlockRangeSync(¶ms);
! 1420: }
! 1421: if( res == noErr ){
! 1422: id->locked = lk;
! 1423: rc = SQLITE_OK;
! 1424: }else{
! 1425: rc = SQLITE_BUSY;
! 1426: }
! 1427: }
! 1428: return rc;
! 1429: #endif
! 1430: }
! 1431:
! 1432: /*
! 1433: ** Change the lock status to be an exclusive or write lock. Return
! 1434: ** SQLITE_OK on success and SQLITE_BUSY on a failure. If this
! 1435: ** library was compiled with large file support (LFS) but LFS is not
! 1436: ** available on the host, then an SQLITE_NOLFS is returned.
! 1437: */
! 1438: int sqliteOsWriteLock(OsFile *id){
! 1439: #if OS_UNIX
! 1440: int rc;
! 1441: sqliteOsEnterMutex();
! 1442: if( id->pLock->cnt==0 || (id->pLock->cnt==1 && id->locked==1) ){
! 1443: struct flock lock;
! 1444: int s;
! 1445: lock.l_type = F_WRLCK;
! 1446: lock.l_whence = SEEK_SET;
! 1447: lock.l_start = lock.l_len = 0L;
! 1448: s = fcntl(id->fd, F_SETLK, &lock);
! 1449: if( s!=0 ){
! 1450: rc = (errno==EINVAL) ? SQLITE_NOLFS : SQLITE_BUSY;
! 1451: }else{
! 1452: rc = SQLITE_OK;
! 1453: if( !id->locked ){
! 1454: id->pOpen->nLock++;
! 1455: id->locked = 1;
! 1456: }
! 1457: id->pLock->cnt = -1;
! 1458: }
! 1459: }else{
! 1460: rc = SQLITE_BUSY;
! 1461: }
! 1462: sqliteOsLeaveMutex();
! 1463: return rc;
! 1464: #endif
! 1465: #if OS_WIN
! 1466: int rc;
! 1467: if( id->locked<0 ){
! 1468: rc = SQLITE_OK;
! 1469: }else{
! 1470: int res;
! 1471: int cnt = 100;
! 1472: while( cnt-->0 && (res = LockFile(id->h, FIRST_LOCKBYTE, 0, 1, 0))==0 ){
! 1473: Sleep(1);
! 1474: }
! 1475: if( res ){
! 1476: if( id->locked>0 ){
! 1477: if( isNT() ){
! 1478: UnlockFile(id->h, FIRST_LOCKBYTE+1, 0, N_LOCKBYTE, 0);
! 1479: }else{
! 1480: res = UnlockFile(id->h, FIRST_LOCKBYTE + id->locked, 0, 1, 0);
! 1481: }
! 1482: }
! 1483: if( res ){
! 1484: res = LockFile(id->h, FIRST_LOCKBYTE+1, 0, N_LOCKBYTE, 0);
! 1485: }else{
! 1486: res = 0;
! 1487: }
! 1488: UnlockFile(id->h, FIRST_LOCKBYTE, 0, 1, 0);
! 1489: }
! 1490: if( res ){
! 1491: id->locked = -1;
! 1492: rc = SQLITE_OK;
! 1493: }else{
! 1494: rc = SQLITE_BUSY;
! 1495: }
! 1496: }
! 1497: return rc;
! 1498: #endif
! 1499: #if OS_MAC
! 1500: int rc;
! 1501: if( id->locked<0 || id->refNumRF == -1 ){
! 1502: rc = SQLITE_OK;
! 1503: }else{
! 1504: OSErr res;
! 1505: int cnt = 5;
! 1506: ParamBlockRec params;
! 1507: memset(¶ms, 0, sizeof(params));
! 1508: params.ioParam.ioRefNum = id->refNumRF;
! 1509: params.ioParam.ioPosMode = fsFromStart;
! 1510: params.ioParam.ioPosOffset = FIRST_LOCKBYTE;
! 1511: params.ioParam.ioReqCount = 1;
! 1512: while( cnt-->0 && (res = PBLockRangeSync(¶ms))!=noErr ){
! 1513: UInt32 finalTicks;
! 1514: Delay(1, &finalTicks); /* 1/60 sec */
! 1515: }
! 1516: if( res == noErr ){
! 1517: params.ioParam.ioPosOffset = FIRST_LOCKBYTE + id->locked;
! 1518: params.ioParam.ioReqCount = 1;
! 1519: if( id->locked==0
! 1520: || PBUnlockRangeSync(¶ms)==noErr ){
! 1521: params.ioParam.ioPosOffset = FIRST_LOCKBYTE+1;
! 1522: params.ioParam.ioReqCount = N_LOCKBYTE;
! 1523: res = PBLockRangeSync(¶ms);
! 1524: }else{
! 1525: res = afpRangeNotLocked;
! 1526: }
! 1527: params.ioParam.ioPosOffset = FIRST_LOCKBYTE;
! 1528: params.ioParam.ioReqCount = 1;
! 1529: PBUnlockRangeSync(¶ms);
! 1530: }
! 1531: if( res == noErr ){
! 1532: id->locked = -1;
! 1533: rc = SQLITE_OK;
! 1534: }else{
! 1535: rc = SQLITE_BUSY;
! 1536: }
! 1537: }
! 1538: return rc;
! 1539: #endif
! 1540: }
! 1541:
! 1542: /*
! 1543: ** Unlock the given file descriptor. If the file descriptor was
! 1544: ** not previously locked, then this routine is a no-op. If this
! 1545: ** library was compiled with large file support (LFS) but LFS is not
! 1546: ** available on the host, then an SQLITE_NOLFS is returned.
! 1547: */
! 1548: int sqliteOsUnlock(OsFile *id){
! 1549: #if OS_UNIX
! 1550: int rc;
! 1551: if( !id->locked ) return SQLITE_OK;
! 1552: sqliteOsEnterMutex();
! 1553: assert( id->pLock->cnt!=0 );
! 1554: if( id->pLock->cnt>1 ){
! 1555: id->pLock->cnt--;
! 1556: rc = SQLITE_OK;
! 1557: }else{
! 1558: struct flock lock;
! 1559: int s;
! 1560: lock.l_type = F_UNLCK;
! 1561: lock.l_whence = SEEK_SET;
! 1562: lock.l_start = lock.l_len = 0L;
! 1563: s = fcntl(id->fd, F_SETLK, &lock);
! 1564: if( s!=0 ){
! 1565: rc = (errno==EINVAL) ? SQLITE_NOLFS : SQLITE_BUSY;
! 1566: }else{
! 1567: rc = SQLITE_OK;
! 1568: id->pLock->cnt = 0;
! 1569: }
! 1570: }
! 1571: if( rc==SQLITE_OK ){
! 1572: /* Decrement the count of locks against this same file. When the
! 1573: ** count reaches zero, close any other file descriptors whose close
! 1574: ** was deferred because of outstanding locks.
! 1575: */
! 1576: struct openCnt *pOpen = id->pOpen;
! 1577: pOpen->nLock--;
! 1578: assert( pOpen->nLock>=0 );
! 1579: if( pOpen->nLock==0 && pOpen->nPending>0 ){
! 1580: int i;
! 1581: for(i=0; i<pOpen->nPending; i++){
! 1582: close(pOpen->aPending[i]);
! 1583: }
! 1584: sqliteFree(pOpen->aPending);
! 1585: pOpen->nPending = 0;
! 1586: pOpen->aPending = 0;
! 1587: }
! 1588: }
! 1589: sqliteOsLeaveMutex();
! 1590: id->locked = 0;
! 1591: return rc;
! 1592: #endif
! 1593: #if OS_WIN
! 1594: int rc;
! 1595: if( id->locked==0 ){
! 1596: rc = SQLITE_OK;
! 1597: }else if( isNT() || id->locked<0 ){
! 1598: UnlockFile(id->h, FIRST_LOCKBYTE+1, 0, N_LOCKBYTE, 0);
! 1599: rc = SQLITE_OK;
! 1600: id->locked = 0;
! 1601: }else{
! 1602: UnlockFile(id->h, FIRST_LOCKBYTE+id->locked, 0, 1, 0);
! 1603: rc = SQLITE_OK;
! 1604: id->locked = 0;
! 1605: }
! 1606: return rc;
! 1607: #endif
! 1608: #if OS_MAC
! 1609: int rc;
! 1610: ParamBlockRec params;
! 1611: memset(¶ms, 0, sizeof(params));
! 1612: params.ioParam.ioRefNum = id->refNumRF;
! 1613: params.ioParam.ioPosMode = fsFromStart;
! 1614: if( id->locked==0 || id->refNumRF == -1 ){
! 1615: rc = SQLITE_OK;
! 1616: }else if( id->locked<0 ){
! 1617: params.ioParam.ioPosOffset = FIRST_LOCKBYTE+1;
! 1618: params.ioParam.ioReqCount = N_LOCKBYTE;
! 1619: PBUnlockRangeSync(¶ms);
! 1620: rc = SQLITE_OK;
! 1621: id->locked = 0;
! 1622: }else{
! 1623: params.ioParam.ioPosOffset = FIRST_LOCKBYTE+id->locked;
! 1624: params.ioParam.ioReqCount = 1;
! 1625: PBUnlockRangeSync(¶ms);
! 1626: rc = SQLITE_OK;
! 1627: id->locked = 0;
! 1628: }
! 1629: return rc;
! 1630: #endif
! 1631: }
! 1632:
! 1633: /*
! 1634: ** Get information to seed the random number generator. The seed
! 1635: ** is written into the buffer zBuf[256]. The calling function must
! 1636: ** supply a sufficiently large buffer.
! 1637: */
! 1638: int sqliteOsRandomSeed(char *zBuf){
! 1639: /* We have to initialize zBuf to prevent valgrind from reporting
! 1640: ** errors. The reports issued by valgrind are incorrect - we would
! 1641: ** prefer that the randomness be increased by making use of the
! 1642: ** uninitialized space in zBuf - but valgrind errors tend to worry
! 1643: ** some users. Rather than argue, it seems easier just to initialize
! 1644: ** the whole array and silence valgrind, even if that means less randomness
! 1645: ** in the random seed.
! 1646: **
! 1647: ** When testing, initializing zBuf[] to zero is all we do. That means
! 1648: ** that we always use the same random number sequence.* This makes the
! 1649: ** tests repeatable.
! 1650: */
! 1651: memset(zBuf, 0, 256);
! 1652: #if OS_UNIX && !defined(SQLITE_TEST)
! 1653: {
! 1654: int pid;
! 1655: time((time_t*)zBuf);
! 1656: pid = getpid();
! 1657: memcpy(&zBuf[sizeof(time_t)], &pid, sizeof(pid));
! 1658: }
! 1659: #endif
! 1660: #if OS_WIN && !defined(SQLITE_TEST)
! 1661: GetSystemTime((LPSYSTEMTIME)zBuf);
! 1662: #endif
! 1663: #if OS_MAC
! 1664: {
! 1665: int pid;
! 1666: Microseconds((UnsignedWide*)zBuf);
! 1667: pid = getpid();
! 1668: memcpy(&zBuf[sizeof(UnsignedWide)], &pid, sizeof(pid));
! 1669: }
! 1670: #endif
! 1671: return SQLITE_OK;
! 1672: }
! 1673:
! 1674: /*
! 1675: ** Sleep for a little while. Return the amount of time slept.
! 1676: */
! 1677: int sqliteOsSleep(int ms){
! 1678: #if OS_UNIX
! 1679: #if defined(HAVE_USLEEP) && HAVE_USLEEP
! 1680: usleep(ms*1000);
! 1681: return ms;
! 1682: #else
! 1683: sleep((ms+999)/1000);
! 1684: return 1000*((ms+999)/1000);
! 1685: #endif
! 1686: #endif
! 1687: #if OS_WIN
! 1688: Sleep(ms);
! 1689: return ms;
! 1690: #endif
! 1691: #if OS_MAC
! 1692: UInt32 finalTicks;
! 1693: UInt32 ticks = (((UInt32)ms+16)*3)/50; /* 1/60 sec per tick */
! 1694: Delay(ticks, &finalTicks);
! 1695: return (int)((ticks*50)/3);
! 1696: #endif
! 1697: }
! 1698:
! 1699: /*
! 1700: ** Static variables used for thread synchronization
! 1701: */
! 1702: static int inMutex = 0;
! 1703: #ifdef SQLITE_UNIX_THREADS
! 1704: static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
! 1705: #endif
! 1706: #ifdef SQLITE_W32_THREADS
! 1707: static CRITICAL_SECTION cs;
! 1708: #endif
! 1709: #ifdef SQLITE_MACOS_MULTITASKING
! 1710: static MPCriticalRegionID criticalRegion;
! 1711: #endif
! 1712:
! 1713: /*
! 1714: ** The following pair of routine implement mutual exclusion for
! 1715: ** multi-threaded processes. Only a single thread is allowed to
! 1716: ** executed code that is surrounded by EnterMutex() and LeaveMutex().
! 1717: **
! 1718: ** SQLite uses only a single Mutex. There is not much critical
! 1719: ** code and what little there is executes quickly and without blocking.
! 1720: */
! 1721: void sqliteOsEnterMutex(){
! 1722: #ifdef SQLITE_UNIX_THREADS
! 1723: pthread_mutex_lock(&mutex);
! 1724: #endif
! 1725: #ifdef SQLITE_W32_THREADS
! 1726: static int isInit = 0;
! 1727: while( !isInit ){
! 1728: static long lock = 0;
! 1729: if( InterlockedIncrement(&lock)==1 ){
! 1730: InitializeCriticalSection(&cs);
! 1731: isInit = 1;
! 1732: }else{
! 1733: Sleep(1);
! 1734: }
! 1735: }
! 1736: EnterCriticalSection(&cs);
! 1737: #endif
! 1738: #ifdef SQLITE_MACOS_MULTITASKING
! 1739: static volatile int notInit = 1;
! 1740: if( notInit ){
! 1741: if( notInit == 2 ) /* as close as you can get to thread safe init */
! 1742: MPYield();
! 1743: else{
! 1744: notInit = 2;
! 1745: MPCreateCriticalRegion(&criticalRegion);
! 1746: notInit = 0;
! 1747: }
! 1748: }
! 1749: MPEnterCriticalRegion(criticalRegion, kDurationForever);
! 1750: #endif
! 1751: assert( !inMutex );
! 1752: inMutex = 1;
! 1753: }
! 1754: void sqliteOsLeaveMutex(){
! 1755: assert( inMutex );
! 1756: inMutex = 0;
! 1757: #ifdef SQLITE_UNIX_THREADS
! 1758: pthread_mutex_unlock(&mutex);
! 1759: #endif
! 1760: #ifdef SQLITE_W32_THREADS
! 1761: LeaveCriticalSection(&cs);
! 1762: #endif
! 1763: #ifdef SQLITE_MACOS_MULTITASKING
! 1764: MPExitCriticalRegion(criticalRegion);
! 1765: #endif
! 1766: }
! 1767:
! 1768: /*
! 1769: ** Turn a relative pathname into a full pathname. Return a pointer
! 1770: ** to the full pathname stored in space obtained from sqliteMalloc().
! 1771: ** The calling function is responsible for freeing this space once it
! 1772: ** is no longer needed.
! 1773: */
! 1774: char *sqliteOsFullPathname(const char *zRelative){
! 1775: #if OS_UNIX
! 1776: char *zFull = 0;
! 1777: if( zRelative[0]=='/' ){
! 1778: sqliteSetString(&zFull, zRelative, (char*)0);
! 1779: }else{
! 1780: char zBuf[5000];
! 1781: zBuf[0] = 0;
! 1782: sqliteSetString(&zFull, getcwd(zBuf, sizeof(zBuf)), "/", zRelative,
! 1783: (char*)0);
! 1784: }
! 1785: return zFull;
! 1786: #endif
! 1787: #if OS_WIN
! 1788: char *zNotUsed;
! 1789: char *zFull;
! 1790: int nByte;
! 1791: nByte = GetFullPathName(zRelative, 0, 0, &zNotUsed) + 1;
! 1792: zFull = sqliteMalloc( nByte );
! 1793: if( zFull==0 ) return 0;
! 1794: GetFullPathName(zRelative, nByte, zFull, &zNotUsed);
! 1795: return zFull;
! 1796: #endif
! 1797: #if OS_MAC
! 1798: char *zFull = 0;
! 1799: if( zRelative[0]==':' ){
! 1800: char zBuf[_MAX_PATH+1];
! 1801: sqliteSetString(&zFull, getcwd(zBuf, sizeof(zBuf)), &(zRelative[1]),
! 1802: (char*)0);
! 1803: }else{
! 1804: if( strchr(zRelative, ':') ){
! 1805: sqliteSetString(&zFull, zRelative, (char*)0);
! 1806: }else{
! 1807: char zBuf[_MAX_PATH+1];
! 1808: sqliteSetString(&zFull, getcwd(zBuf, sizeof(zBuf)), zRelative, (char*)0);
! 1809: }
! 1810: }
! 1811: return zFull;
! 1812: #endif
! 1813: }
! 1814:
! 1815: /*
! 1816: ** The following variable, if set to a non-zero value, becomes the result
! 1817: ** returned from sqliteOsCurrentTime(). This is used for testing.
! 1818: */
! 1819: #ifdef SQLITE_TEST
! 1820: int sqlite_current_time = 0;
! 1821: #endif
! 1822:
! 1823: /*
! 1824: ** Find the current time (in Universal Coordinated Time). Write the
! 1825: ** current time and date as a Julian Day number into *prNow and
! 1826: ** return 0. Return 1 if the time and date cannot be found.
! 1827: */
! 1828: int sqliteOsCurrentTime(double *prNow){
! 1829: #if OS_UNIX
! 1830: time_t t;
! 1831: time(&t);
! 1832: *prNow = t/86400.0 + 2440587.5;
! 1833: #endif
! 1834: #if OS_WIN
! 1835: FILETIME ft;
! 1836: /* FILETIME structure is a 64-bit value representing the number of
! 1837: 100-nanosecond intervals since January 1, 1601 (= JD 2305813.5).
! 1838: */
! 1839: double now;
! 1840: GetSystemTimeAsFileTime( &ft );
! 1841: now = ((double)ft.dwHighDateTime) * 4294967296.0;
! 1842: *prNow = (now + ft.dwLowDateTime)/864000000000.0 + 2305813.5;
! 1843: #endif
! 1844: #ifdef SQLITE_TEST
! 1845: if( sqlite_current_time ){
! 1846: *prNow = sqlite_current_time/86400.0 + 2440587.5;
! 1847: }
! 1848: #endif
! 1849: return 0;
! 1850: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to os.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / sqlite / libsqlite / src