sl@0: /* sl@0: ** 2001 September 16 sl@0: ** sl@0: ** The author disclaims copyright to this source code. In place of sl@0: ** a legal notice, here is a blessing: sl@0: ** sl@0: ** May you do good and not evil. sl@0: ** May you find forgiveness for yourself and forgive others. sl@0: ** May you share freely, never taking more than you give. sl@0: ** sl@0: ****************************************************************************** sl@0: ** sl@0: ** This header file (together with is companion C source-code file sl@0: ** "os.c") attempt to abstract the underlying operating system so that sl@0: ** the SQLite library will work on both POSIX and windows systems. sl@0: ** sl@0: ** This header file is #include-ed by sqliteInt.h and thus ends up sl@0: ** being included by every source file. sl@0: ** sl@0: ** $Id: os.h,v 1.105 2008/06/26 10:41:19 danielk1977 Exp $ sl@0: */ sl@0: #ifndef _SQLITE_OS_H_ sl@0: #define _SQLITE_OS_H_ sl@0: sl@0: /* sl@0: ** Figure out if we are dealing with Unix, Windows, or some other sl@0: ** operating system. After the following block of preprocess macros, sl@0: ** all of SQLITE_OS_UNIX, SQLITE_OS_WIN, SQLITE_OS_OS2, and SQLITE_OS_OTHER sl@0: ** will defined to either 1 or 0. One of the four will be 1. The other sl@0: ** three will be 0. sl@0: */ sl@0: #if defined(SQLITE_OS_OTHER) sl@0: # if SQLITE_OS_OTHER==1 sl@0: # undef SQLITE_OS_UNIX sl@0: # define SQLITE_OS_UNIX 0 sl@0: # undef SQLITE_OS_WIN sl@0: # define SQLITE_OS_WIN 0 sl@0: # undef SQLITE_OS_OS2 sl@0: # define SQLITE_OS_OS2 0 sl@0: # else sl@0: # undef SQLITE_OS_OTHER sl@0: # endif sl@0: #endif sl@0: #if !defined(SQLITE_OS_UNIX) && !defined(SQLITE_OS_OTHER) sl@0: # define SQLITE_OS_OTHER 0 sl@0: # ifndef SQLITE_OS_WIN sl@0: # if defined(_WIN32) || defined(WIN32) || defined(__CYGWIN__) || defined(__MINGW32__) || defined(__BORLANDC__) sl@0: # define SQLITE_OS_WIN 1 sl@0: # define SQLITE_OS_UNIX 0 sl@0: # define SQLITE_OS_OS2 0 sl@0: # elif defined(__EMX__) || defined(_OS2) || defined(OS2) || defined(_OS2_) || defined(__OS2__) sl@0: # define SQLITE_OS_WIN 0 sl@0: # define SQLITE_OS_UNIX 0 sl@0: # define SQLITE_OS_OS2 1 sl@0: # else sl@0: # define SQLITE_OS_WIN 0 sl@0: # define SQLITE_OS_UNIX 1 sl@0: # define SQLITE_OS_OS2 0 sl@0: # endif sl@0: # else sl@0: # define SQLITE_OS_UNIX 0 sl@0: # define SQLITE_OS_OS2 0 sl@0: # endif sl@0: #else sl@0: # ifndef SQLITE_OS_WIN sl@0: # define SQLITE_OS_WIN 0 sl@0: # endif sl@0: #endif sl@0: sl@0: /* sl@0: ** Determine if we are dealing with WindowsCE - which has a much sl@0: ** reduced API. sl@0: */ sl@0: #if defined(_WIN32_WCE) sl@0: # define SQLITE_OS_WINCE 1 sl@0: #else sl@0: # define SQLITE_OS_WINCE 0 sl@0: #endif sl@0: sl@0: sl@0: /* sl@0: ** Define the maximum size of a temporary filename sl@0: */ sl@0: #if SQLITE_OS_WIN sl@0: # include sl@0: # define SQLITE_TEMPNAME_SIZE (MAX_PATH+50) sl@0: #elif SQLITE_OS_OS2 sl@0: # if (__GNUC__ > 3 || __GNUC__ == 3 && __GNUC_MINOR__ >= 3) && defined(OS2_HIGH_MEMORY) sl@0: # include /* has to be included before os2.h for linking to work */ sl@0: # endif sl@0: # define INCL_DOSDATETIME sl@0: # define INCL_DOSFILEMGR sl@0: # define INCL_DOSERRORS sl@0: # define INCL_DOSMISC sl@0: # define INCL_DOSPROCESS sl@0: # define INCL_DOSMODULEMGR sl@0: # define INCL_DOSSEMAPHORES sl@0: # include sl@0: # include sl@0: # define SQLITE_TEMPNAME_SIZE (CCHMAXPATHCOMP) sl@0: #else sl@0: # define SQLITE_TEMPNAME_SIZE 200 sl@0: #endif sl@0: sl@0: /* If the SET_FULLSYNC macro is not defined above, then make it sl@0: ** a no-op sl@0: */ sl@0: #ifndef SET_FULLSYNC sl@0: # define SET_FULLSYNC(x,y) sl@0: #endif sl@0: sl@0: /* sl@0: ** The default size of a disk sector sl@0: */ sl@0: #ifndef SQLITE_DEFAULT_SECTOR_SIZE sl@0: # define SQLITE_DEFAULT_SECTOR_SIZE 512 sl@0: #endif sl@0: sl@0: /* sl@0: ** Temporary files are named starting with this prefix followed by 16 random sl@0: ** alphanumeric characters, and no file extension. They are stored in the sl@0: ** OS's standard temporary file directory, and are deleted prior to exit. sl@0: ** If sqlite is being embedded in another program, you may wish to change the sl@0: ** prefix to reflect your program's name, so that if your program exits sl@0: ** prematurely, old temporary files can be easily identified. This can be done sl@0: ** using -DSQLITE_TEMP_FILE_PREFIX=myprefix_ on the compiler command line. sl@0: ** sl@0: ** 2006-10-31: The default prefix used to be "sqlite_". But then sl@0: ** Mcafee started using SQLite in their anti-virus product and it sl@0: ** started putting files with the "sqlite" name in the c:/temp folder. sl@0: ** This annoyed many windows users. Those users would then do a sl@0: ** Google search for "sqlite", find the telephone numbers of the sl@0: ** developers and call to wake them up at night and complain. sl@0: ** For this reason, the default name prefix is changed to be "sqlite" sl@0: ** spelled backwards. So the temp files are still identified, but sl@0: ** anybody smart enough to figure out the code is also likely smart sl@0: ** enough to know that calling the developer will not help get rid sl@0: ** of the file. sl@0: */ sl@0: #ifndef SQLITE_TEMP_FILE_PREFIX sl@0: # define SQLITE_TEMP_FILE_PREFIX "etilqs_" sl@0: #endif sl@0: sl@0: /* sl@0: ** The following values may be passed as the second argument to sl@0: ** sqlite3OsLock(). The various locks exhibit the following semantics: sl@0: ** sl@0: ** SHARED: Any number of processes may hold a SHARED lock simultaneously. sl@0: ** RESERVED: A single process may hold a RESERVED lock on a file at sl@0: ** any time. Other processes may hold and obtain new SHARED locks. sl@0: ** PENDING: A single process may hold a PENDING lock on a file at sl@0: ** any one time. Existing SHARED locks may persist, but no new sl@0: ** SHARED locks may be obtained by other processes. sl@0: ** EXCLUSIVE: An EXCLUSIVE lock precludes all other locks. sl@0: ** sl@0: ** PENDING_LOCK may not be passed directly to sqlite3OsLock(). Instead, a sl@0: ** process that requests an EXCLUSIVE lock may actually obtain a PENDING sl@0: ** lock. This can be upgraded to an EXCLUSIVE lock by a subsequent call to sl@0: ** sqlite3OsLock(). sl@0: */ sl@0: #define NO_LOCK 0 sl@0: #define SHARED_LOCK 1 sl@0: #define RESERVED_LOCK 2 sl@0: #define PENDING_LOCK 3 sl@0: #define EXCLUSIVE_LOCK 4 sl@0: sl@0: /* sl@0: ** File Locking Notes: (Mostly about windows but also some info for Unix) sl@0: ** sl@0: ** We cannot use LockFileEx() or UnlockFileEx() on Win95/98/ME because sl@0: ** those functions are not available. So we use only LockFile() and sl@0: ** UnlockFile(). sl@0: ** sl@0: ** LockFile() prevents not just writing but also reading by other processes. sl@0: ** A SHARED_LOCK is obtained by locking a single randomly-chosen sl@0: ** byte out of a specific range of bytes. The lock byte is obtained at sl@0: ** random so two separate readers can probably access the file at the sl@0: ** same time, unless they are unlucky and choose the same lock byte. sl@0: ** An EXCLUSIVE_LOCK is obtained by locking all bytes in the range. sl@0: ** There can only be one writer. A RESERVED_LOCK is obtained by locking sl@0: ** a single byte of the file that is designated as the reserved lock byte. sl@0: ** A PENDING_LOCK is obtained by locking a designated byte different from sl@0: ** the RESERVED_LOCK byte. sl@0: ** sl@0: ** On WinNT/2K/XP systems, LockFileEx() and UnlockFileEx() are available, sl@0: ** which means we can use reader/writer locks. When reader/writer locks sl@0: ** are used, the lock is placed on the same range of bytes that is used sl@0: ** for probabilistic locking in Win95/98/ME. Hence, the locking scheme sl@0: ** will support two or more Win95 readers or two or more WinNT readers. sl@0: ** But a single Win95 reader will lock out all WinNT readers and a single sl@0: ** WinNT reader will lock out all other Win95 readers. sl@0: ** sl@0: ** The following #defines specify the range of bytes used for locking. sl@0: ** SHARED_SIZE is the number of bytes available in the pool from which sl@0: ** a random byte is selected for a shared lock. The pool of bytes for sl@0: ** shared locks begins at SHARED_FIRST. sl@0: ** sl@0: ** These #defines are available in sqlite_aux.h so that adaptors for sl@0: ** connecting SQLite to other operating systems can use the same byte sl@0: ** ranges for locking. In particular, the same locking strategy and sl@0: ** byte ranges are used for Unix. This leaves open the possiblity of having sl@0: ** clients on win95, winNT, and unix all talking to the same shared file sl@0: ** and all locking correctly. To do so would require that samba (or whatever sl@0: ** tool is being used for file sharing) implements locks correctly between sl@0: ** windows and unix. I'm guessing that isn't likely to happen, but by sl@0: ** using the same locking range we are at least open to the possibility. sl@0: ** sl@0: ** Locking in windows is manditory. For this reason, we cannot store sl@0: ** actual data in the bytes used for locking. The pager never allocates sl@0: ** the pages involved in locking therefore. SHARED_SIZE is selected so sl@0: ** that all locks will fit on a single page even at the minimum page size. sl@0: ** PENDING_BYTE defines the beginning of the locks. By default PENDING_BYTE sl@0: ** is set high so that we don't have to allocate an unused page except sl@0: ** for very large databases. But one should test the page skipping logic sl@0: ** by setting PENDING_BYTE low and running the entire regression suite. sl@0: ** sl@0: ** Changing the value of PENDING_BYTE results in a subtly incompatible sl@0: ** file format. Depending on how it is changed, you might not notice sl@0: ** the incompatibility right away, even running a full regression test. sl@0: ** The default location of PENDING_BYTE is the first byte past the sl@0: ** 1GB boundary. sl@0: ** sl@0: */ sl@0: #ifndef SQLITE_TEST sl@0: #define PENDING_BYTE 0x40000000 /* First byte past the 1GB boundary */ sl@0: #else sl@0: extern unsigned int sqlite3_pending_byte; sl@0: #define PENDING_BYTE sqlite3_pending_byte sl@0: #endif sl@0: sl@0: #define RESERVED_BYTE (PENDING_BYTE+1) sl@0: #define SHARED_FIRST (PENDING_BYTE+2) sl@0: #define SHARED_SIZE 510 sl@0: sl@0: /* sl@0: ** Functions for accessing sqlite3_file methods sl@0: */ sl@0: int sqlite3OsClose(sqlite3_file*); sl@0: int sqlite3OsRead(sqlite3_file*, void*, int amt, i64 offset); sl@0: int sqlite3OsWrite(sqlite3_file*, const void*, int amt, i64 offset); sl@0: int sqlite3OsTruncate(sqlite3_file*, i64 size); sl@0: int sqlite3OsSync(sqlite3_file*, int); sl@0: int sqlite3OsFileSize(sqlite3_file*, i64 *pSize); sl@0: int sqlite3OsLock(sqlite3_file*, int); sl@0: int sqlite3OsUnlock(sqlite3_file*, int); sl@0: int sqlite3OsCheckReservedLock(sqlite3_file *id, int *pResOut); sl@0: int sqlite3OsFileControl(sqlite3_file*,int,void*); sl@0: int sqlite3OsSectorSize(sqlite3_file *id); sl@0: int sqlite3OsDeviceCharacteristics(sqlite3_file *id); sl@0: sl@0: /* sl@0: ** Functions for accessing sqlite3_vfs methods sl@0: */ sl@0: int sqlite3OsOpen(sqlite3_vfs *, const char *, sqlite3_file*, int, int *); sl@0: int sqlite3OsDelete(sqlite3_vfs *, const char *, int); sl@0: int sqlite3OsAccess(sqlite3_vfs *, const char *, int, int *pResOut); sl@0: int sqlite3OsFullPathname(sqlite3_vfs *, const char *, int, char *); sl@0: #ifndef SQLITE_OMIT_LOAD_EXTENSION sl@0: void *sqlite3OsDlOpen(sqlite3_vfs *, const char *); sl@0: void sqlite3OsDlError(sqlite3_vfs *, int, char *); sl@0: void *sqlite3OsDlSym(sqlite3_vfs *, void *, const char *); sl@0: void sqlite3OsDlClose(sqlite3_vfs *, void *); sl@0: #endif /* SQLITE_OMIT_LOAD_EXTENSION */ sl@0: int sqlite3OsRandomness(sqlite3_vfs *, int, char *); sl@0: int sqlite3OsSleep(sqlite3_vfs *, int); sl@0: int sqlite3OsCurrentTime(sqlite3_vfs *, double*); sl@0: sl@0: /* sl@0: ** Convenience functions for opening and closing files using sl@0: ** sqlite3_malloc() to obtain space for the file-handle structure. sl@0: */ sl@0: int sqlite3OsOpenMalloc(sqlite3_vfs *, const char *, sqlite3_file **, int,int*); sl@0: int sqlite3OsCloseFree(sqlite3_file *); sl@0: sl@0: #endif /* _SQLITE_OS_H_ */