Annotation of embedaddon/sqlite3/src/os_os2.c, revision 1.1
1.1 ! misho 1: /*
! 2: ** 2006 Feb 14
! 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 OS/2.
! 14: */
! 15:
! 16: #include "sqliteInt.h"
! 17:
! 18: #if SQLITE_OS_OS2
! 19:
! 20: /*
! 21: ** A Note About Memory Allocation:
! 22: **
! 23: ** This driver uses malloc()/free() directly rather than going through
! 24: ** the SQLite-wrappers sqlite3_malloc()/sqlite3_free(). Those wrappers
! 25: ** are designed for use on embedded systems where memory is scarce and
! 26: ** malloc failures happen frequently. OS/2 does not typically run on
! 27: ** embedded systems, and when it does the developers normally have bigger
! 28: ** problems to worry about than running out of memory. So there is not
! 29: ** a compelling need to use the wrappers.
! 30: **
! 31: ** But there is a good reason to not use the wrappers. If we use the
! 32: ** wrappers then we will get simulated malloc() failures within this
! 33: ** driver. And that causes all kinds of problems for our tests. We
! 34: ** could enhance SQLite to deal with simulated malloc failures within
! 35: ** the OS driver, but the code to deal with those failure would not
! 36: ** be exercised on Linux (which does not need to malloc() in the driver)
! 37: ** and so we would have difficulty writing coverage tests for that
! 38: ** code. Better to leave the code out, we think.
! 39: **
! 40: ** The point of this discussion is as follows: When creating a new
! 41: ** OS layer for an embedded system, if you use this file as an example,
! 42: ** avoid the use of malloc()/free(). Those routines work ok on OS/2
! 43: ** desktops but not so well in embedded systems.
! 44: */
! 45:
! 46: /*
! 47: ** Macros used to determine whether or not to use threads.
! 48: */
! 49: #if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE
! 50: # define SQLITE_OS2_THREADS 1
! 51: #endif
! 52:
! 53: /*
! 54: ** Include code that is common to all os_*.c files
! 55: */
! 56: #include "os_common.h"
! 57:
! 58: /* Forward references */
! 59: typedef struct os2File os2File; /* The file structure */
! 60: typedef struct os2ShmNode os2ShmNode; /* A shared descritive memory node */
! 61: typedef struct os2ShmLink os2ShmLink; /* A connection to shared-memory */
! 62:
! 63: /*
! 64: ** The os2File structure is subclass of sqlite3_file specific for the OS/2
! 65: ** protability layer.
! 66: */
! 67: struct os2File {
! 68: const sqlite3_io_methods *pMethod; /* Always the first entry */
! 69: HFILE h; /* Handle for accessing the file */
! 70: int flags; /* Flags provided to os2Open() */
! 71: int locktype; /* Type of lock currently held on this file */
! 72: int szChunk; /* Chunk size configured by FCNTL_CHUNK_SIZE */
! 73: char *zFullPathCp; /* Full path name of this file */
! 74: os2ShmLink *pShmLink; /* Instance of shared memory on this file */
! 75: };
! 76:
! 77: #define LOCK_TIMEOUT 10L /* the default locking timeout */
! 78:
! 79: /*
! 80: ** Missing from some versions of the OS/2 toolkit -
! 81: ** used to allocate from high memory if possible
! 82: */
! 83: #ifndef OBJ_ANY
! 84: # define OBJ_ANY 0x00000400
! 85: #endif
! 86:
! 87: /*****************************************************************************
! 88: ** The next group of routines implement the I/O methods specified
! 89: ** by the sqlite3_io_methods object.
! 90: ******************************************************************************/
! 91:
! 92: /*
! 93: ** Close a file.
! 94: */
! 95: static int os2Close( sqlite3_file *id ){
! 96: APIRET rc;
! 97: os2File *pFile = (os2File*)id;
! 98:
! 99: assert( id!=0 );
! 100: OSTRACE(( "CLOSE %d (%s)\n", pFile->h, pFile->zFullPathCp ));
! 101:
! 102: rc = DosClose( pFile->h );
! 103:
! 104: if( pFile->flags & SQLITE_OPEN_DELETEONCLOSE )
! 105: DosForceDelete( (PSZ)pFile->zFullPathCp );
! 106:
! 107: free( pFile->zFullPathCp );
! 108: pFile->zFullPathCp = NULL;
! 109: pFile->locktype = NO_LOCK;
! 110: pFile->h = (HFILE)-1;
! 111: pFile->flags = 0;
! 112:
! 113: OpenCounter( -1 );
! 114: return rc == NO_ERROR ? SQLITE_OK : SQLITE_IOERR;
! 115: }
! 116:
! 117: /*
! 118: ** Read data from a file into a buffer. Return SQLITE_OK if all
! 119: ** bytes were read successfully and SQLITE_IOERR if anything goes
! 120: ** wrong.
! 121: */
! 122: static int os2Read(
! 123: sqlite3_file *id, /* File to read from */
! 124: void *pBuf, /* Write content into this buffer */
! 125: int amt, /* Number of bytes to read */
! 126: sqlite3_int64 offset /* Begin reading at this offset */
! 127: ){
! 128: ULONG fileLocation = 0L;
! 129: ULONG got;
! 130: os2File *pFile = (os2File*)id;
! 131: assert( id!=0 );
! 132: SimulateIOError( return SQLITE_IOERR_READ );
! 133: OSTRACE(( "READ %d lock=%d\n", pFile->h, pFile->locktype ));
! 134: if( DosSetFilePtr(pFile->h, offset, FILE_BEGIN, &fileLocation) != NO_ERROR ){
! 135: return SQLITE_IOERR;
! 136: }
! 137: if( DosRead( pFile->h, pBuf, amt, &got ) != NO_ERROR ){
! 138: return SQLITE_IOERR_READ;
! 139: }
! 140: if( got == (ULONG)amt )
! 141: return SQLITE_OK;
! 142: else {
! 143: /* Unread portions of the input buffer must be zero-filled */
! 144: memset(&((char*)pBuf)[got], 0, amt-got);
! 145: return SQLITE_IOERR_SHORT_READ;
! 146: }
! 147: }
! 148:
! 149: /*
! 150: ** Write data from a buffer into a file. Return SQLITE_OK on success
! 151: ** or some other error code on failure.
! 152: */
! 153: static int os2Write(
! 154: sqlite3_file *id, /* File to write into */
! 155: const void *pBuf, /* The bytes to be written */
! 156: int amt, /* Number of bytes to write */
! 157: sqlite3_int64 offset /* Offset into the file to begin writing at */
! 158: ){
! 159: ULONG fileLocation = 0L;
! 160: APIRET rc = NO_ERROR;
! 161: ULONG wrote;
! 162: os2File *pFile = (os2File*)id;
! 163: assert( id!=0 );
! 164: SimulateIOError( return SQLITE_IOERR_WRITE );
! 165: SimulateDiskfullError( return SQLITE_FULL );
! 166: OSTRACE(( "WRITE %d lock=%d\n", pFile->h, pFile->locktype ));
! 167: if( DosSetFilePtr(pFile->h, offset, FILE_BEGIN, &fileLocation) != NO_ERROR ){
! 168: return SQLITE_IOERR;
! 169: }
! 170: assert( amt>0 );
! 171: while( amt > 0 &&
! 172: ( rc = DosWrite( pFile->h, (PVOID)pBuf, amt, &wrote ) ) == NO_ERROR &&
! 173: wrote > 0
! 174: ){
! 175: amt -= wrote;
! 176: pBuf = &((char*)pBuf)[wrote];
! 177: }
! 178:
! 179: return ( rc != NO_ERROR || amt > (int)wrote ) ? SQLITE_FULL : SQLITE_OK;
! 180: }
! 181:
! 182: /*
! 183: ** Truncate an open file to a specified size
! 184: */
! 185: static int os2Truncate( sqlite3_file *id, i64 nByte ){
! 186: APIRET rc;
! 187: os2File *pFile = (os2File*)id;
! 188: assert( id!=0 );
! 189: OSTRACE(( "TRUNCATE %d %lld\n", pFile->h, nByte ));
! 190: SimulateIOError( return SQLITE_IOERR_TRUNCATE );
! 191:
! 192: /* If the user has configured a chunk-size for this file, truncate the
! 193: ** file so that it consists of an integer number of chunks (i.e. the
! 194: ** actual file size after the operation may be larger than the requested
! 195: ** size).
! 196: */
! 197: if( pFile->szChunk ){
! 198: nByte = ((nByte + pFile->szChunk - 1)/pFile->szChunk) * pFile->szChunk;
! 199: }
! 200:
! 201: rc = DosSetFileSize( pFile->h, nByte );
! 202: return rc == NO_ERROR ? SQLITE_OK : SQLITE_IOERR_TRUNCATE;
! 203: }
! 204:
! 205: #ifdef SQLITE_TEST
! 206: /*
! 207: ** Count the number of fullsyncs and normal syncs. This is used to test
! 208: ** that syncs and fullsyncs are occuring at the right times.
! 209: */
! 210: int sqlite3_sync_count = 0;
! 211: int sqlite3_fullsync_count = 0;
! 212: #endif
! 213:
! 214: /*
! 215: ** Make sure all writes to a particular file are committed to disk.
! 216: */
! 217: static int os2Sync( sqlite3_file *id, int flags ){
! 218: os2File *pFile = (os2File*)id;
! 219: OSTRACE(( "SYNC %d lock=%d\n", pFile->h, pFile->locktype ));
! 220: #ifdef SQLITE_TEST
! 221: if( flags & SQLITE_SYNC_FULL){
! 222: sqlite3_fullsync_count++;
! 223: }
! 224: sqlite3_sync_count++;
! 225: #endif
! 226: /* If we compiled with the SQLITE_NO_SYNC flag, then syncing is a
! 227: ** no-op
! 228: */
! 229: #ifdef SQLITE_NO_SYNC
! 230: UNUSED_PARAMETER(pFile);
! 231: return SQLITE_OK;
! 232: #else
! 233: return DosResetBuffer( pFile->h ) == NO_ERROR ? SQLITE_OK : SQLITE_IOERR;
! 234: #endif
! 235: }
! 236:
! 237: /*
! 238: ** Determine the current size of a file in bytes
! 239: */
! 240: static int os2FileSize( sqlite3_file *id, sqlite3_int64 *pSize ){
! 241: APIRET rc = NO_ERROR;
! 242: FILESTATUS3 fsts3FileInfo;
! 243: memset(&fsts3FileInfo, 0, sizeof(fsts3FileInfo));
! 244: assert( id!=0 );
! 245: SimulateIOError( return SQLITE_IOERR_FSTAT );
! 246: rc = DosQueryFileInfo( ((os2File*)id)->h, FIL_STANDARD, &fsts3FileInfo, sizeof(FILESTATUS3) );
! 247: if( rc == NO_ERROR ){
! 248: *pSize = fsts3FileInfo.cbFile;
! 249: return SQLITE_OK;
! 250: }else{
! 251: return SQLITE_IOERR_FSTAT;
! 252: }
! 253: }
! 254:
! 255: /*
! 256: ** Acquire a reader lock.
! 257: */
! 258: static int getReadLock( os2File *pFile ){
! 259: FILELOCK LockArea,
! 260: UnlockArea;
! 261: APIRET res;
! 262: memset(&LockArea, 0, sizeof(LockArea));
! 263: memset(&UnlockArea, 0, sizeof(UnlockArea));
! 264: LockArea.lOffset = SHARED_FIRST;
! 265: LockArea.lRange = SHARED_SIZE;
! 266: UnlockArea.lOffset = 0L;
! 267: UnlockArea.lRange = 0L;
! 268: res = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 1L );
! 269: OSTRACE(( "GETREADLOCK %d res=%d\n", pFile->h, res ));
! 270: return res;
! 271: }
! 272:
! 273: /*
! 274: ** Undo a readlock
! 275: */
! 276: static int unlockReadLock( os2File *id ){
! 277: FILELOCK LockArea,
! 278: UnlockArea;
! 279: APIRET res;
! 280: memset(&LockArea, 0, sizeof(LockArea));
! 281: memset(&UnlockArea, 0, sizeof(UnlockArea));
! 282: LockArea.lOffset = 0L;
! 283: LockArea.lRange = 0L;
! 284: UnlockArea.lOffset = SHARED_FIRST;
! 285: UnlockArea.lRange = SHARED_SIZE;
! 286: res = DosSetFileLocks( id->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 1L );
! 287: OSTRACE(( "UNLOCK-READLOCK file handle=%d res=%d?\n", id->h, res ));
! 288: return res;
! 289: }
! 290:
! 291: /*
! 292: ** Lock the file with the lock specified by parameter locktype - one
! 293: ** of the following:
! 294: **
! 295: ** (1) SHARED_LOCK
! 296: ** (2) RESERVED_LOCK
! 297: ** (3) PENDING_LOCK
! 298: ** (4) EXCLUSIVE_LOCK
! 299: **
! 300: ** Sometimes when requesting one lock state, additional lock states
! 301: ** are inserted in between. The locking might fail on one of the later
! 302: ** transitions leaving the lock state different from what it started but
! 303: ** still short of its goal. The following chart shows the allowed
! 304: ** transitions and the inserted intermediate states:
! 305: **
! 306: ** UNLOCKED -> SHARED
! 307: ** SHARED -> RESERVED
! 308: ** SHARED -> (PENDING) -> EXCLUSIVE
! 309: ** RESERVED -> (PENDING) -> EXCLUSIVE
! 310: ** PENDING -> EXCLUSIVE
! 311: **
! 312: ** This routine will only increase a lock. The os2Unlock() routine
! 313: ** erases all locks at once and returns us immediately to locking level 0.
! 314: ** It is not possible to lower the locking level one step at a time. You
! 315: ** must go straight to locking level 0.
! 316: */
! 317: static int os2Lock( sqlite3_file *id, int locktype ){
! 318: int rc = SQLITE_OK; /* Return code from subroutines */
! 319: APIRET res = NO_ERROR; /* Result of an OS/2 lock call */
! 320: int newLocktype; /* Set pFile->locktype to this value before exiting */
! 321: int gotPendingLock = 0;/* True if we acquired a PENDING lock this time */
! 322: FILELOCK LockArea,
! 323: UnlockArea;
! 324: os2File *pFile = (os2File*)id;
! 325: memset(&LockArea, 0, sizeof(LockArea));
! 326: memset(&UnlockArea, 0, sizeof(UnlockArea));
! 327: assert( pFile!=0 );
! 328: OSTRACE(( "LOCK %d %d was %d\n", pFile->h, locktype, pFile->locktype ));
! 329:
! 330: /* If there is already a lock of this type or more restrictive on the
! 331: ** os2File, do nothing. Don't use the end_lock: exit path, as
! 332: ** sqlite3_mutex_enter() hasn't been called yet.
! 333: */
! 334: if( pFile->locktype>=locktype ){
! 335: OSTRACE(( "LOCK %d %d ok (already held)\n", pFile->h, locktype ));
! 336: return SQLITE_OK;
! 337: }
! 338:
! 339: /* Make sure the locking sequence is correct
! 340: */
! 341: assert( pFile->locktype!=NO_LOCK || locktype==SHARED_LOCK );
! 342: assert( locktype!=PENDING_LOCK );
! 343: assert( locktype!=RESERVED_LOCK || pFile->locktype==SHARED_LOCK );
! 344:
! 345: /* Lock the PENDING_LOCK byte if we need to acquire a PENDING lock or
! 346: ** a SHARED lock. If we are acquiring a SHARED lock, the acquisition of
! 347: ** the PENDING_LOCK byte is temporary.
! 348: */
! 349: newLocktype = pFile->locktype;
! 350: if( pFile->locktype==NO_LOCK
! 351: || (locktype==EXCLUSIVE_LOCK && pFile->locktype==RESERVED_LOCK)
! 352: ){
! 353: LockArea.lOffset = PENDING_BYTE;
! 354: LockArea.lRange = 1L;
! 355: UnlockArea.lOffset = 0L;
! 356: UnlockArea.lRange = 0L;
! 357:
! 358: /* wait longer than LOCK_TIMEOUT here not to have to try multiple times */
! 359: res = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, 100L, 0L );
! 360: if( res == NO_ERROR ){
! 361: gotPendingLock = 1;
! 362: OSTRACE(( "LOCK %d pending lock boolean set. res=%d\n", pFile->h, res ));
! 363: }
! 364: }
! 365:
! 366: /* Acquire a shared lock
! 367: */
! 368: if( locktype==SHARED_LOCK && res == NO_ERROR ){
! 369: assert( pFile->locktype==NO_LOCK );
! 370: res = getReadLock(pFile);
! 371: if( res == NO_ERROR ){
! 372: newLocktype = SHARED_LOCK;
! 373: }
! 374: OSTRACE(( "LOCK %d acquire shared lock. res=%d\n", pFile->h, res ));
! 375: }
! 376:
! 377: /* Acquire a RESERVED lock
! 378: */
! 379: if( locktype==RESERVED_LOCK && res == NO_ERROR ){
! 380: assert( pFile->locktype==SHARED_LOCK );
! 381: LockArea.lOffset = RESERVED_BYTE;
! 382: LockArea.lRange = 1L;
! 383: UnlockArea.lOffset = 0L;
! 384: UnlockArea.lRange = 0L;
! 385: res = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 0L );
! 386: if( res == NO_ERROR ){
! 387: newLocktype = RESERVED_LOCK;
! 388: }
! 389: OSTRACE(( "LOCK %d acquire reserved lock. res=%d\n", pFile->h, res ));
! 390: }
! 391:
! 392: /* Acquire a PENDING lock
! 393: */
! 394: if( locktype==EXCLUSIVE_LOCK && res == NO_ERROR ){
! 395: newLocktype = PENDING_LOCK;
! 396: gotPendingLock = 0;
! 397: OSTRACE(( "LOCK %d acquire pending lock. pending lock boolean unset.\n",
! 398: pFile->h ));
! 399: }
! 400:
! 401: /* Acquire an EXCLUSIVE lock
! 402: */
! 403: if( locktype==EXCLUSIVE_LOCK && res == NO_ERROR ){
! 404: assert( pFile->locktype>=SHARED_LOCK );
! 405: res = unlockReadLock(pFile);
! 406: OSTRACE(( "unreadlock = %d\n", res ));
! 407: LockArea.lOffset = SHARED_FIRST;
! 408: LockArea.lRange = SHARED_SIZE;
! 409: UnlockArea.lOffset = 0L;
! 410: UnlockArea.lRange = 0L;
! 411: res = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 0L );
! 412: if( res == NO_ERROR ){
! 413: newLocktype = EXCLUSIVE_LOCK;
! 414: }else{
! 415: OSTRACE(( "OS/2 error-code = %d\n", res ));
! 416: getReadLock(pFile);
! 417: }
! 418: OSTRACE(( "LOCK %d acquire exclusive lock. res=%d\n", pFile->h, res ));
! 419: }
! 420:
! 421: /* If we are holding a PENDING lock that ought to be released, then
! 422: ** release it now.
! 423: */
! 424: if( gotPendingLock && locktype==SHARED_LOCK ){
! 425: int r;
! 426: LockArea.lOffset = 0L;
! 427: LockArea.lRange = 0L;
! 428: UnlockArea.lOffset = PENDING_BYTE;
! 429: UnlockArea.lRange = 1L;
! 430: r = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 0L );
! 431: OSTRACE(( "LOCK %d unlocking pending/is shared. r=%d\n", pFile->h, r ));
! 432: }
! 433:
! 434: /* Update the state of the lock has held in the file descriptor then
! 435: ** return the appropriate result code.
! 436: */
! 437: if( res == NO_ERROR ){
! 438: rc = SQLITE_OK;
! 439: }else{
! 440: OSTRACE(( "LOCK FAILED %d trying for %d but got %d\n", pFile->h,
! 441: locktype, newLocktype ));
! 442: rc = SQLITE_BUSY;
! 443: }
! 444: pFile->locktype = newLocktype;
! 445: OSTRACE(( "LOCK %d now %d\n", pFile->h, pFile->locktype ));
! 446: return rc;
! 447: }
! 448:
! 449: /*
! 450: ** This routine checks if there is a RESERVED lock held on the specified
! 451: ** file by this or any other process. If such a lock is held, return
! 452: ** non-zero, otherwise zero.
! 453: */
! 454: static int os2CheckReservedLock( sqlite3_file *id, int *pOut ){
! 455: int r = 0;
! 456: os2File *pFile = (os2File*)id;
! 457: assert( pFile!=0 );
! 458: if( pFile->locktype>=RESERVED_LOCK ){
! 459: r = 1;
! 460: OSTRACE(( "TEST WR-LOCK %d %d (local)\n", pFile->h, r ));
! 461: }else{
! 462: FILELOCK LockArea,
! 463: UnlockArea;
! 464: APIRET rc = NO_ERROR;
! 465: memset(&LockArea, 0, sizeof(LockArea));
! 466: memset(&UnlockArea, 0, sizeof(UnlockArea));
! 467: LockArea.lOffset = RESERVED_BYTE;
! 468: LockArea.lRange = 1L;
! 469: UnlockArea.lOffset = 0L;
! 470: UnlockArea.lRange = 0L;
! 471: rc = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 0L );
! 472: OSTRACE(( "TEST WR-LOCK %d lock reserved byte rc=%d\n", pFile->h, rc ));
! 473: if( rc == NO_ERROR ){
! 474: APIRET rcu = NO_ERROR; /* return code for unlocking */
! 475: LockArea.lOffset = 0L;
! 476: LockArea.lRange = 0L;
! 477: UnlockArea.lOffset = RESERVED_BYTE;
! 478: UnlockArea.lRange = 1L;
! 479: rcu = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 0L );
! 480: OSTRACE(( "TEST WR-LOCK %d unlock reserved byte r=%d\n", pFile->h, rcu ));
! 481: }
! 482: r = !(rc == NO_ERROR);
! 483: OSTRACE(( "TEST WR-LOCK %d %d (remote)\n", pFile->h, r ));
! 484: }
! 485: *pOut = r;
! 486: return SQLITE_OK;
! 487: }
! 488:
! 489: /*
! 490: ** Lower the locking level on file descriptor id to locktype. locktype
! 491: ** must be either NO_LOCK or SHARED_LOCK.
! 492: **
! 493: ** If the locking level of the file descriptor is already at or below
! 494: ** the requested locking level, this routine is a no-op.
! 495: **
! 496: ** It is not possible for this routine to fail if the second argument
! 497: ** is NO_LOCK. If the second argument is SHARED_LOCK then this routine
! 498: ** might return SQLITE_IOERR;
! 499: */
! 500: static int os2Unlock( sqlite3_file *id, int locktype ){
! 501: int type;
! 502: os2File *pFile = (os2File*)id;
! 503: APIRET rc = SQLITE_OK;
! 504: APIRET res = NO_ERROR;
! 505: FILELOCK LockArea,
! 506: UnlockArea;
! 507: memset(&LockArea, 0, sizeof(LockArea));
! 508: memset(&UnlockArea, 0, sizeof(UnlockArea));
! 509: assert( pFile!=0 );
! 510: assert( locktype<=SHARED_LOCK );
! 511: OSTRACE(( "UNLOCK %d to %d was %d\n", pFile->h, locktype, pFile->locktype ));
! 512: type = pFile->locktype;
! 513: if( type>=EXCLUSIVE_LOCK ){
! 514: LockArea.lOffset = 0L;
! 515: LockArea.lRange = 0L;
! 516: UnlockArea.lOffset = SHARED_FIRST;
! 517: UnlockArea.lRange = SHARED_SIZE;
! 518: res = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 0L );
! 519: OSTRACE(( "UNLOCK %d exclusive lock res=%d\n", pFile->h, res ));
! 520: if( locktype==SHARED_LOCK && getReadLock(pFile) != NO_ERROR ){
! 521: /* This should never happen. We should always be able to
! 522: ** reacquire the read lock */
! 523: OSTRACE(( "UNLOCK %d to %d getReadLock() failed\n", pFile->h, locktype ));
! 524: rc = SQLITE_IOERR_UNLOCK;
! 525: }
! 526: }
! 527: if( type>=RESERVED_LOCK ){
! 528: LockArea.lOffset = 0L;
! 529: LockArea.lRange = 0L;
! 530: UnlockArea.lOffset = RESERVED_BYTE;
! 531: UnlockArea.lRange = 1L;
! 532: res = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 0L );
! 533: OSTRACE(( "UNLOCK %d reserved res=%d\n", pFile->h, res ));
! 534: }
! 535: if( locktype==NO_LOCK && type>=SHARED_LOCK ){
! 536: res = unlockReadLock(pFile);
! 537: OSTRACE(( "UNLOCK %d is %d want %d res=%d\n",
! 538: pFile->h, type, locktype, res ));
! 539: }
! 540: if( type>=PENDING_LOCK ){
! 541: LockArea.lOffset = 0L;
! 542: LockArea.lRange = 0L;
! 543: UnlockArea.lOffset = PENDING_BYTE;
! 544: UnlockArea.lRange = 1L;
! 545: res = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 0L );
! 546: OSTRACE(( "UNLOCK %d pending res=%d\n", pFile->h, res ));
! 547: }
! 548: pFile->locktype = locktype;
! 549: OSTRACE(( "UNLOCK %d now %d\n", pFile->h, pFile->locktype ));
! 550: return rc;
! 551: }
! 552:
! 553: /*
! 554: ** Control and query of the open file handle.
! 555: */
! 556: static int os2FileControl(sqlite3_file *id, int op, void *pArg){
! 557: switch( op ){
! 558: case SQLITE_FCNTL_LOCKSTATE: {
! 559: *(int*)pArg = ((os2File*)id)->locktype;
! 560: OSTRACE(( "FCNTL_LOCKSTATE %d lock=%d\n",
! 561: ((os2File*)id)->h, ((os2File*)id)->locktype ));
! 562: return SQLITE_OK;
! 563: }
! 564: case SQLITE_FCNTL_CHUNK_SIZE: {
! 565: ((os2File*)id)->szChunk = *(int*)pArg;
! 566: return SQLITE_OK;
! 567: }
! 568: case SQLITE_FCNTL_SIZE_HINT: {
! 569: sqlite3_int64 sz = *(sqlite3_int64*)pArg;
! 570: SimulateIOErrorBenign(1);
! 571: os2Truncate(id, sz);
! 572: SimulateIOErrorBenign(0);
! 573: return SQLITE_OK;
! 574: }
! 575: case SQLITE_FCNTL_SYNC_OMITTED: {
! 576: return SQLITE_OK;
! 577: }
! 578: }
! 579: return SQLITE_NOTFOUND;
! 580: }
! 581:
! 582: /*
! 583: ** Return the sector size in bytes of the underlying block device for
! 584: ** the specified file. This is almost always 512 bytes, but may be
! 585: ** larger for some devices.
! 586: **
! 587: ** SQLite code assumes this function cannot fail. It also assumes that
! 588: ** if two files are created in the same file-system directory (i.e.
! 589: ** a database and its journal file) that the sector size will be the
! 590: ** same for both.
! 591: */
! 592: static int os2SectorSize(sqlite3_file *id){
! 593: UNUSED_PARAMETER(id);
! 594: return SQLITE_DEFAULT_SECTOR_SIZE;
! 595: }
! 596:
! 597: /*
! 598: ** Return a vector of device characteristics.
! 599: */
! 600: static int os2DeviceCharacteristics(sqlite3_file *id){
! 601: UNUSED_PARAMETER(id);
! 602: return SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN;
! 603: }
! 604:
! 605:
! 606: /*
! 607: ** Character set conversion objects used by conversion routines.
! 608: */
! 609: static UconvObject ucUtf8 = NULL; /* convert between UTF-8 and UCS-2 */
! 610: static UconvObject uclCp = NULL; /* convert between local codepage and UCS-2 */
! 611:
! 612: /*
! 613: ** Helper function to initialize the conversion objects from and to UTF-8.
! 614: */
! 615: static void initUconvObjects( void ){
! 616: if( UniCreateUconvObject( UTF_8, &ucUtf8 ) != ULS_SUCCESS )
! 617: ucUtf8 = NULL;
! 618: if ( UniCreateUconvObject( (UniChar *)L"@path=yes", &uclCp ) != ULS_SUCCESS )
! 619: uclCp = NULL;
! 620: }
! 621:
! 622: /*
! 623: ** Helper function to free the conversion objects from and to UTF-8.
! 624: */
! 625: static void freeUconvObjects( void ){
! 626: if ( ucUtf8 )
! 627: UniFreeUconvObject( ucUtf8 );
! 628: if ( uclCp )
! 629: UniFreeUconvObject( uclCp );
! 630: ucUtf8 = NULL;
! 631: uclCp = NULL;
! 632: }
! 633:
! 634: /*
! 635: ** Helper function to convert UTF-8 filenames to local OS/2 codepage.
! 636: ** The two-step process: first convert the incoming UTF-8 string
! 637: ** into UCS-2 and then from UCS-2 to the current codepage.
! 638: ** The returned char pointer has to be freed.
! 639: */
! 640: static char *convertUtf8PathToCp( const char *in ){
! 641: UniChar tempPath[CCHMAXPATH];
! 642: char *out = (char *)calloc( CCHMAXPATH, 1 );
! 643:
! 644: if( !out )
! 645: return NULL;
! 646:
! 647: if( !ucUtf8 || !uclCp )
! 648: initUconvObjects();
! 649:
! 650: /* determine string for the conversion of UTF-8 which is CP1208 */
! 651: if( UniStrToUcs( ucUtf8, tempPath, (char *)in, CCHMAXPATH ) != ULS_SUCCESS )
! 652: return out; /* if conversion fails, return the empty string */
! 653:
! 654: /* conversion for current codepage which can be used for paths */
! 655: UniStrFromUcs( uclCp, out, tempPath, CCHMAXPATH );
! 656:
! 657: return out;
! 658: }
! 659:
! 660: /*
! 661: ** Helper function to convert filenames from local codepage to UTF-8.
! 662: ** The two-step process: first convert the incoming codepage-specific
! 663: ** string into UCS-2 and then from UCS-2 to the codepage of UTF-8.
! 664: ** The returned char pointer has to be freed.
! 665: **
! 666: ** This function is non-static to be able to use this in shell.c and
! 667: ** similar applications that take command line arguments.
! 668: */
! 669: char *convertCpPathToUtf8( const char *in ){
! 670: UniChar tempPath[CCHMAXPATH];
! 671: char *out = (char *)calloc( CCHMAXPATH, 1 );
! 672:
! 673: if( !out )
! 674: return NULL;
! 675:
! 676: if( !ucUtf8 || !uclCp )
! 677: initUconvObjects();
! 678:
! 679: /* conversion for current codepage which can be used for paths */
! 680: if( UniStrToUcs( uclCp, tempPath, (char *)in, CCHMAXPATH ) != ULS_SUCCESS )
! 681: return out; /* if conversion fails, return the empty string */
! 682:
! 683: /* determine string for the conversion of UTF-8 which is CP1208 */
! 684: UniStrFromUcs( ucUtf8, out, tempPath, CCHMAXPATH );
! 685:
! 686: return out;
! 687: }
! 688:
! 689:
! 690: #ifndef SQLITE_OMIT_WAL
! 691:
! 692: /*
! 693: ** Use main database file for interprocess locking. If un-defined
! 694: ** a separate file is created for this purpose. The file will be
! 695: ** used only to set file locks. There will be no data written to it.
! 696: */
! 697: #define SQLITE_OS2_NO_WAL_LOCK_FILE
! 698:
! 699: #if 0
! 700: static void _ERR_TRACE( const char *fmt, ... ) {
! 701: va_list ap;
! 702: va_start(ap, fmt);
! 703: vfprintf(stderr, fmt, ap);
! 704: fflush(stderr);
! 705: }
! 706: #define ERR_TRACE(rc, msg) \
! 707: if( (rc) != SQLITE_OK ) _ERR_TRACE msg;
! 708: #else
! 709: #define ERR_TRACE(rc, msg)
! 710: #endif
! 711:
! 712: /*
! 713: ** Helper functions to obtain and relinquish the global mutex. The
! 714: ** global mutex is used to protect os2ShmNodeList.
! 715: **
! 716: ** Function os2ShmMutexHeld() is used to assert() that the global mutex
! 717: ** is held when required. This function is only used as part of assert()
! 718: ** statements. e.g.
! 719: **
! 720: ** os2ShmEnterMutex()
! 721: ** assert( os2ShmMutexHeld() );
! 722: ** os2ShmLeaveMutex()
! 723: */
! 724: static void os2ShmEnterMutex(void){
! 725: sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));
! 726: }
! 727: static void os2ShmLeaveMutex(void){
! 728: sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));
! 729: }
! 730: #ifdef SQLITE_DEBUG
! 731: static int os2ShmMutexHeld(void) {
! 732: return sqlite3_mutex_held(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));
! 733: }
! 734: int GetCurrentProcessId(void) {
! 735: PPIB pib;
! 736: DosGetInfoBlocks(NULL, &pib);
! 737: return (int)pib->pib_ulpid;
! 738: }
! 739: #endif
! 740:
! 741: /*
! 742: ** Object used to represent a the shared memory area for a single log file.
! 743: ** When multiple threads all reference the same log-summary, each thread has
! 744: ** its own os2File object, but they all point to a single instance of this
! 745: ** object. In other words, each log-summary is opened only once per process.
! 746: **
! 747: ** os2ShmMutexHeld() must be true when creating or destroying
! 748: ** this object or while reading or writing the following fields:
! 749: **
! 750: ** nRef
! 751: ** pNext
! 752: **
! 753: ** The following fields are read-only after the object is created:
! 754: **
! 755: ** szRegion
! 756: ** hLockFile
! 757: ** shmBaseName
! 758: **
! 759: ** Either os2ShmNode.mutex must be held or os2ShmNode.nRef==0 and
! 760: ** os2ShmMutexHeld() is true when reading or writing any other field
! 761: ** in this structure.
! 762: **
! 763: */
! 764: struct os2ShmNode {
! 765: sqlite3_mutex *mutex; /* Mutex to access this object */
! 766: os2ShmNode *pNext; /* Next in list of all os2ShmNode objects */
! 767:
! 768: int szRegion; /* Size of shared-memory regions */
! 769:
! 770: int nRegion; /* Size of array apRegion */
! 771: void **apRegion; /* Array of pointers to shared-memory regions */
! 772:
! 773: int nRef; /* Number of os2ShmLink objects pointing to this */
! 774: os2ShmLink *pFirst; /* First os2ShmLink object pointing to this */
! 775:
! 776: HFILE hLockFile; /* File used for inter-process memory locking */
! 777: char shmBaseName[1]; /* Name of the memory object !!! must last !!! */
! 778: };
! 779:
! 780:
! 781: /*
! 782: ** Structure used internally by this VFS to record the state of an
! 783: ** open shared memory connection.
! 784: **
! 785: ** The following fields are initialized when this object is created and
! 786: ** are read-only thereafter:
! 787: **
! 788: ** os2Shm.pShmNode
! 789: ** os2Shm.id
! 790: **
! 791: ** All other fields are read/write. The os2Shm.pShmNode->mutex must be held
! 792: ** while accessing any read/write fields.
! 793: */
! 794: struct os2ShmLink {
! 795: os2ShmNode *pShmNode; /* The underlying os2ShmNode object */
! 796: os2ShmLink *pNext; /* Next os2Shm with the same os2ShmNode */
! 797: u32 sharedMask; /* Mask of shared locks held */
! 798: u32 exclMask; /* Mask of exclusive locks held */
! 799: #ifdef SQLITE_DEBUG
! 800: u8 id; /* Id of this connection with its os2ShmNode */
! 801: #endif
! 802: };
! 803:
! 804:
! 805: /*
! 806: ** A global list of all os2ShmNode objects.
! 807: **
! 808: ** The os2ShmMutexHeld() must be true while reading or writing this list.
! 809: */
! 810: static os2ShmNode *os2ShmNodeList = NULL;
! 811:
! 812: /*
! 813: ** Constants used for locking
! 814: */
! 815: #ifdef SQLITE_OS2_NO_WAL_LOCK_FILE
! 816: #define OS2_SHM_BASE (PENDING_BYTE + 0x10000) /* first lock byte */
! 817: #else
! 818: #define OS2_SHM_BASE ((22+SQLITE_SHM_NLOCK)*4) /* first lock byte */
! 819: #endif
! 820:
! 821: #define OS2_SHM_DMS (OS2_SHM_BASE+SQLITE_SHM_NLOCK) /* deadman switch */
! 822:
! 823: /*
! 824: ** Apply advisory locks for all n bytes beginning at ofst.
! 825: */
! 826: #define _SHM_UNLCK 1 /* no lock */
! 827: #define _SHM_RDLCK 2 /* shared lock, no wait */
! 828: #define _SHM_WRLCK 3 /* exlusive lock, no wait */
! 829: #define _SHM_WRLCK_WAIT 4 /* exclusive lock, wait */
! 830: static int os2ShmSystemLock(
! 831: os2ShmNode *pNode, /* Apply locks to this open shared-memory segment */
! 832: int lockType, /* _SHM_UNLCK, _SHM_RDLCK, _SHM_WRLCK or _SHM_WRLCK_WAIT */
! 833: int ofst, /* Offset to first byte to be locked/unlocked */
! 834: int nByte /* Number of bytes to lock or unlock */
! 835: ){
! 836: APIRET rc;
! 837: FILELOCK area;
! 838: ULONG mode, timeout;
! 839:
! 840: /* Access to the os2ShmNode object is serialized by the caller */
! 841: assert( sqlite3_mutex_held(pNode->mutex) || pNode->nRef==0 );
! 842:
! 843: mode = 1; /* shared lock */
! 844: timeout = 0; /* no wait */
! 845: area.lOffset = ofst;
! 846: area.lRange = nByte;
! 847:
! 848: switch( lockType ) {
! 849: case _SHM_WRLCK_WAIT:
! 850: timeout = (ULONG)-1; /* wait forever */
! 851: case _SHM_WRLCK:
! 852: mode = 0; /* exclusive lock */
! 853: case _SHM_RDLCK:
! 854: rc = DosSetFileLocks(pNode->hLockFile,
! 855: NULL, &area, timeout, mode);
! 856: break;
! 857: /* case _SHM_UNLCK: */
! 858: default:
! 859: rc = DosSetFileLocks(pNode->hLockFile,
! 860: &area, NULL, 0, 0);
! 861: break;
! 862: }
! 863:
! 864: OSTRACE(("SHM-LOCK %d %s %s 0x%08lx\n",
! 865: pNode->hLockFile,
! 866: rc==SQLITE_OK ? "ok" : "failed",
! 867: lockType==_SHM_UNLCK ? "Unlock" : "Lock",
! 868: rc));
! 869:
! 870: ERR_TRACE(rc, ("os2ShmSystemLock: %d %s\n", rc, pNode->shmBaseName))
! 871:
! 872: return ( rc == 0 ) ? SQLITE_OK : SQLITE_BUSY;
! 873: }
! 874:
! 875: /*
! 876: ** Find an os2ShmNode in global list or allocate a new one, if not found.
! 877: **
! 878: ** This is not a VFS shared-memory method; it is a utility function called
! 879: ** by VFS shared-memory methods.
! 880: */
! 881: static int os2OpenSharedMemory( os2File *fd, int szRegion ) {
! 882: os2ShmLink *pLink;
! 883: os2ShmNode *pNode;
! 884: int cbShmName, rc = SQLITE_OK;
! 885: char shmName[CCHMAXPATH + 30];
! 886: #ifndef SQLITE_OS2_NO_WAL_LOCK_FILE
! 887: ULONG action;
! 888: #endif
! 889:
! 890: /* We need some additional space at the end to append the region number */
! 891: cbShmName = sprintf(shmName, "\\SHAREMEM\\%s", fd->zFullPathCp );
! 892: if( cbShmName >= CCHMAXPATH-8 )
! 893: return SQLITE_IOERR_SHMOPEN;
! 894:
! 895: /* Replace colon in file name to form a valid shared memory name */
! 896: shmName[10+1] = '!';
! 897:
! 898: /* Allocate link object (we free it later in case of failure) */
! 899: pLink = sqlite3_malloc( sizeof(*pLink) );
! 900: if( !pLink )
! 901: return SQLITE_NOMEM;
! 902:
! 903: /* Access node list */
! 904: os2ShmEnterMutex();
! 905:
! 906: /* Find node by it's shared memory base name */
! 907: for( pNode = os2ShmNodeList;
! 908: pNode && stricmp(shmName, pNode->shmBaseName) != 0;
! 909: pNode = pNode->pNext ) ;
! 910:
! 911: /* Not found: allocate a new node */
! 912: if( !pNode ) {
! 913: pNode = sqlite3_malloc( sizeof(*pNode) + cbShmName );
! 914: if( pNode ) {
! 915: memset(pNode, 0, sizeof(*pNode) );
! 916: pNode->szRegion = szRegion;
! 917: pNode->hLockFile = (HFILE)-1;
! 918: strcpy(pNode->shmBaseName, shmName);
! 919:
! 920: #ifdef SQLITE_OS2_NO_WAL_LOCK_FILE
! 921: if( DosDupHandle(fd->h, &pNode->hLockFile) != 0 ) {
! 922: #else
! 923: sprintf(shmName, "%s-lck", fd->zFullPathCp);
! 924: if( DosOpen((PSZ)shmName, &pNode->hLockFile, &action, 0, FILE_NORMAL,
! 925: OPEN_ACTION_OPEN_IF_EXISTS | OPEN_ACTION_CREATE_IF_NEW,
! 926: OPEN_ACCESS_READWRITE | OPEN_SHARE_DENYNONE |
! 927: OPEN_FLAGS_NOINHERIT | OPEN_FLAGS_FAIL_ON_ERROR,
! 928: NULL) != 0 ) {
! 929: #endif
! 930: sqlite3_free(pNode);
! 931: rc = SQLITE_IOERR;
! 932: } else {
! 933: pNode->mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_FAST);
! 934: if( !pNode->mutex ) {
! 935: sqlite3_free(pNode);
! 936: rc = SQLITE_NOMEM;
! 937: }
! 938: }
! 939: } else {
! 940: rc = SQLITE_NOMEM;
! 941: }
! 942:
! 943: if( rc == SQLITE_OK ) {
! 944: pNode->pNext = os2ShmNodeList;
! 945: os2ShmNodeList = pNode;
! 946: } else {
! 947: pNode = NULL;
! 948: }
! 949: } else if( pNode->szRegion != szRegion ) {
! 950: rc = SQLITE_IOERR_SHMSIZE;
! 951: pNode = NULL;
! 952: }
! 953:
! 954: if( pNode ) {
! 955: sqlite3_mutex_enter(pNode->mutex);
! 956:
! 957: memset(pLink, 0, sizeof(*pLink));
! 958:
! 959: pLink->pShmNode = pNode;
! 960: pLink->pNext = pNode->pFirst;
! 961: pNode->pFirst = pLink;
! 962: pNode->nRef++;
! 963:
! 964: fd->pShmLink = pLink;
! 965:
! 966: sqlite3_mutex_leave(pNode->mutex);
! 967:
! 968: } else {
! 969: /* Error occured. Free our link object. */
! 970: sqlite3_free(pLink);
! 971: }
! 972:
! 973: os2ShmLeaveMutex();
! 974:
! 975: ERR_TRACE(rc, ("os2OpenSharedMemory: %d %s\n", rc, fd->zFullPathCp))
! 976:
! 977: return rc;
! 978: }
! 979:
! 980: /*
! 981: ** Purge the os2ShmNodeList list of all entries with nRef==0.
! 982: **
! 983: ** This is not a VFS shared-memory method; it is a utility function called
! 984: ** by VFS shared-memory methods.
! 985: */
! 986: static void os2PurgeShmNodes( int deleteFlag ) {
! 987: os2ShmNode *pNode;
! 988: os2ShmNode **ppNode;
! 989:
! 990: os2ShmEnterMutex();
! 991:
! 992: ppNode = &os2ShmNodeList;
! 993:
! 994: while( *ppNode ) {
! 995: pNode = *ppNode;
! 996:
! 997: if( pNode->nRef == 0 ) {
! 998: *ppNode = pNode->pNext;
! 999:
! 1000: if( pNode->apRegion ) {
! 1001: /* Prevent other processes from resizing the shared memory */
! 1002: os2ShmSystemLock(pNode, _SHM_WRLCK_WAIT, OS2_SHM_DMS, 1);
! 1003:
! 1004: while( pNode->nRegion-- ) {
! 1005: #ifdef SQLITE_DEBUG
! 1006: int rc =
! 1007: #endif
! 1008: DosFreeMem(pNode->apRegion[pNode->nRegion]);
! 1009:
! 1010: OSTRACE(("SHM-PURGE pid-%d unmap region=%d %s\n",
! 1011: (int)GetCurrentProcessId(), pNode->nRegion,
! 1012: rc == 0 ? "ok" : "failed"));
! 1013: }
! 1014:
! 1015: /* Allow other processes to resize the shared memory */
! 1016: os2ShmSystemLock(pNode, _SHM_UNLCK, OS2_SHM_DMS, 1);
! 1017:
! 1018: sqlite3_free(pNode->apRegion);
! 1019: }
! 1020:
! 1021: DosClose(pNode->hLockFile);
! 1022:
! 1023: #ifndef SQLITE_OS2_NO_WAL_LOCK_FILE
! 1024: if( deleteFlag ) {
! 1025: char fileName[CCHMAXPATH];
! 1026: /* Skip "\\SHAREMEM\\" */
! 1027: sprintf(fileName, "%s-lck", pNode->shmBaseName + 10);
! 1028: /* restore colon */
! 1029: fileName[1] = ':';
! 1030:
! 1031: DosForceDelete(fileName);
! 1032: }
! 1033: #endif
! 1034:
! 1035: sqlite3_mutex_free(pNode->mutex);
! 1036:
! 1037: sqlite3_free(pNode);
! 1038:
! 1039: } else {
! 1040: ppNode = &pNode->pNext;
! 1041: }
! 1042: }
! 1043:
! 1044: os2ShmLeaveMutex();
! 1045: }
! 1046:
! 1047: /*
! 1048: ** This function is called to obtain a pointer to region iRegion of the
! 1049: ** shared-memory associated with the database file id. Shared-memory regions
! 1050: ** are numbered starting from zero. Each shared-memory region is szRegion
! 1051: ** bytes in size.
! 1052: **
! 1053: ** If an error occurs, an error code is returned and *pp is set to NULL.
! 1054: **
! 1055: ** Otherwise, if the bExtend parameter is 0 and the requested shared-memory
! 1056: ** region has not been allocated (by any client, including one running in a
! 1057: ** separate process), then *pp is set to NULL and SQLITE_OK returned. If
! 1058: ** bExtend is non-zero and the requested shared-memory region has not yet
! 1059: ** been allocated, it is allocated by this function.
! 1060: **
! 1061: ** If the shared-memory region has already been allocated or is allocated by
! 1062: ** this call as described above, then it is mapped into this processes
! 1063: ** address space (if it is not already), *pp is set to point to the mapped
! 1064: ** memory and SQLITE_OK returned.
! 1065: */
! 1066: static int os2ShmMap(
! 1067: sqlite3_file *id, /* Handle open on database file */
! 1068: int iRegion, /* Region to retrieve */
! 1069: int szRegion, /* Size of regions */
! 1070: int bExtend, /* True to extend block if necessary */
! 1071: void volatile **pp /* OUT: Mapped memory */
! 1072: ){
! 1073: PVOID pvTemp;
! 1074: void **apRegion;
! 1075: os2ShmNode *pNode;
! 1076: int n, rc = SQLITE_OK;
! 1077: char shmName[CCHMAXPATH];
! 1078: os2File *pFile = (os2File*)id;
! 1079:
! 1080: *pp = NULL;
! 1081:
! 1082: if( !pFile->pShmLink )
! 1083: rc = os2OpenSharedMemory( pFile, szRegion );
! 1084:
! 1085: if( rc == SQLITE_OK ) {
! 1086: pNode = pFile->pShmLink->pShmNode ;
! 1087:
! 1088: sqlite3_mutex_enter(pNode->mutex);
! 1089:
! 1090: assert( szRegion==pNode->szRegion );
! 1091:
! 1092: /* Unmapped region ? */
! 1093: if( iRegion >= pNode->nRegion ) {
! 1094: /* Prevent other processes from resizing the shared memory */
! 1095: os2ShmSystemLock(pNode, _SHM_WRLCK_WAIT, OS2_SHM_DMS, 1);
! 1096:
! 1097: apRegion = sqlite3_realloc(
! 1098: pNode->apRegion, (iRegion + 1) * sizeof(apRegion[0]));
! 1099:
! 1100: if( apRegion ) {
! 1101: pNode->apRegion = apRegion;
! 1102:
! 1103: while( pNode->nRegion <= iRegion ) {
! 1104: sprintf(shmName, "%s-%u",
! 1105: pNode->shmBaseName, pNode->nRegion);
! 1106:
! 1107: if( DosGetNamedSharedMem(&pvTemp, (PSZ)shmName,
! 1108: PAG_READ | PAG_WRITE) != NO_ERROR ) {
! 1109: if( !bExtend )
! 1110: break;
! 1111:
! 1112: if( DosAllocSharedMem(&pvTemp, (PSZ)shmName, szRegion,
! 1113: PAG_READ | PAG_WRITE | PAG_COMMIT | OBJ_ANY) != NO_ERROR &&
! 1114: DosAllocSharedMem(&pvTemp, (PSZ)shmName, szRegion,
! 1115: PAG_READ | PAG_WRITE | PAG_COMMIT) != NO_ERROR ) {
! 1116: rc = SQLITE_NOMEM;
! 1117: break;
! 1118: }
! 1119: }
! 1120:
! 1121: apRegion[pNode->nRegion++] = pvTemp;
! 1122: }
! 1123:
! 1124: /* zero out remaining entries */
! 1125: for( n = pNode->nRegion; n <= iRegion; n++ )
! 1126: pNode->apRegion[n] = NULL;
! 1127:
! 1128: /* Return this region (maybe zero) */
! 1129: *pp = pNode->apRegion[iRegion];
! 1130: } else {
! 1131: rc = SQLITE_NOMEM;
! 1132: }
! 1133:
! 1134: /* Allow other processes to resize the shared memory */
! 1135: os2ShmSystemLock(pNode, _SHM_UNLCK, OS2_SHM_DMS, 1);
! 1136:
! 1137: } else {
! 1138: /* Region has been mapped previously */
! 1139: *pp = pNode->apRegion[iRegion];
! 1140: }
! 1141:
! 1142: sqlite3_mutex_leave(pNode->mutex);
! 1143: }
! 1144:
! 1145: ERR_TRACE(rc, ("os2ShmMap: %s iRgn = %d, szRgn = %d, bExt = %d : %d\n",
! 1146: pFile->zFullPathCp, iRegion, szRegion, bExtend, rc))
! 1147:
! 1148: return rc;
! 1149: }
! 1150:
! 1151: /*
! 1152: ** Close a connection to shared-memory. Delete the underlying
! 1153: ** storage if deleteFlag is true.
! 1154: **
! 1155: ** If there is no shared memory associated with the connection then this
! 1156: ** routine is a harmless no-op.
! 1157: */
! 1158: static int os2ShmUnmap(
! 1159: sqlite3_file *id, /* The underlying database file */
! 1160: int deleteFlag /* Delete shared-memory if true */
! 1161: ){
! 1162: os2File *pFile = (os2File*)id;
! 1163: os2ShmLink *pLink = pFile->pShmLink;
! 1164:
! 1165: if( pLink ) {
! 1166: int nRef = -1;
! 1167: os2ShmLink **ppLink;
! 1168: os2ShmNode *pNode = pLink->pShmNode;
! 1169:
! 1170: sqlite3_mutex_enter(pNode->mutex);
! 1171:
! 1172: for( ppLink = &pNode->pFirst;
! 1173: *ppLink && *ppLink != pLink;
! 1174: ppLink = &(*ppLink)->pNext ) ;
! 1175:
! 1176: assert(*ppLink);
! 1177:
! 1178: if( *ppLink ) {
! 1179: *ppLink = pLink->pNext;
! 1180: nRef = --pNode->nRef;
! 1181: } else {
! 1182: ERR_TRACE(1, ("os2ShmUnmap: link not found ! %s\n",
! 1183: pNode->shmBaseName))
! 1184: }
! 1185:
! 1186: pFile->pShmLink = NULL;
! 1187: sqlite3_free(pLink);
! 1188:
! 1189: sqlite3_mutex_leave(pNode->mutex);
! 1190:
! 1191: if( nRef == 0 )
! 1192: os2PurgeShmNodes( deleteFlag );
! 1193: }
! 1194:
! 1195: return SQLITE_OK;
! 1196: }
! 1197:
! 1198: /*
! 1199: ** Change the lock state for a shared-memory segment.
! 1200: **
! 1201: ** Note that the relationship between SHAREd and EXCLUSIVE locks is a little
! 1202: ** different here than in posix. In xShmLock(), one can go from unlocked
! 1203: ** to shared and back or from unlocked to exclusive and back. But one may
! 1204: ** not go from shared to exclusive or from exclusive to shared.
! 1205: */
! 1206: static int os2ShmLock(
! 1207: sqlite3_file *id, /* Database file holding the shared memory */
! 1208: int ofst, /* First lock to acquire or release */
! 1209: int n, /* Number of locks to acquire or release */
! 1210: int flags /* What to do with the lock */
! 1211: ){
! 1212: u32 mask; /* Mask of locks to take or release */
! 1213: int rc = SQLITE_OK; /* Result code */
! 1214: os2File *pFile = (os2File*)id;
! 1215: os2ShmLink *p = pFile->pShmLink; /* The shared memory being locked */
! 1216: os2ShmLink *pX; /* For looping over all siblings */
! 1217: os2ShmNode *pShmNode = p->pShmNode; /* Our node */
! 1218:
! 1219: assert( ofst>=0 && ofst+n<=SQLITE_SHM_NLOCK );
! 1220: assert( n>=1 );
! 1221: assert( flags==(SQLITE_SHM_LOCK | SQLITE_SHM_SHARED)
! 1222: || flags==(SQLITE_SHM_LOCK | SQLITE_SHM_EXCLUSIVE)
! 1223: || flags==(SQLITE_SHM_UNLOCK | SQLITE_SHM_SHARED)
! 1224: || flags==(SQLITE_SHM_UNLOCK | SQLITE_SHM_EXCLUSIVE) );
! 1225: assert( n==1 || (flags & SQLITE_SHM_EXCLUSIVE)!=0 );
! 1226:
! 1227: mask = (u32)((1U<<(ofst+n)) - (1U<<ofst));
! 1228: assert( n>1 || mask==(1<<ofst) );
! 1229:
! 1230:
! 1231: sqlite3_mutex_enter(pShmNode->mutex);
! 1232:
! 1233: if( flags & SQLITE_SHM_UNLOCK ){
! 1234: u32 allMask = 0; /* Mask of locks held by siblings */
! 1235:
! 1236: /* See if any siblings hold this same lock */
! 1237: for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
! 1238: if( pX==p ) continue;
! 1239: assert( (pX->exclMask & (p->exclMask|p->sharedMask))==0 );
! 1240: allMask |= pX->sharedMask;
! 1241: }
! 1242:
! 1243: /* Unlock the system-level locks */
! 1244: if( (mask & allMask)==0 ){
! 1245: rc = os2ShmSystemLock(pShmNode, _SHM_UNLCK, ofst+OS2_SHM_BASE, n);
! 1246: }else{
! 1247: rc = SQLITE_OK;
! 1248: }
! 1249:
! 1250: /* Undo the local locks */
! 1251: if( rc==SQLITE_OK ){
! 1252: p->exclMask &= ~mask;
! 1253: p->sharedMask &= ~mask;
! 1254: }
! 1255: }else if( flags & SQLITE_SHM_SHARED ){
! 1256: u32 allShared = 0; /* Union of locks held by connections other than "p" */
! 1257:
! 1258: /* Find out which shared locks are already held by sibling connections.
! 1259: ** If any sibling already holds an exclusive lock, go ahead and return
! 1260: ** SQLITE_BUSY.
! 1261: */
! 1262: for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
! 1263: if( (pX->exclMask & mask)!=0 ){
! 1264: rc = SQLITE_BUSY;
! 1265: break;
! 1266: }
! 1267: allShared |= pX->sharedMask;
! 1268: }
! 1269:
! 1270: /* Get shared locks at the system level, if necessary */
! 1271: if( rc==SQLITE_OK ){
! 1272: if( (allShared & mask)==0 ){
! 1273: rc = os2ShmSystemLock(pShmNode, _SHM_RDLCK, ofst+OS2_SHM_BASE, n);
! 1274: }else{
! 1275: rc = SQLITE_OK;
! 1276: }
! 1277: }
! 1278:
! 1279: /* Get the local shared locks */
! 1280: if( rc==SQLITE_OK ){
! 1281: p->sharedMask |= mask;
! 1282: }
! 1283: }else{
! 1284: /* Make sure no sibling connections hold locks that will block this
! 1285: ** lock. If any do, return SQLITE_BUSY right away.
! 1286: */
! 1287: for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
! 1288: if( (pX->exclMask & mask)!=0 || (pX->sharedMask & mask)!=0 ){
! 1289: rc = SQLITE_BUSY;
! 1290: break;
! 1291: }
! 1292: }
! 1293:
! 1294: /* Get the exclusive locks at the system level. Then if successful
! 1295: ** also mark the local connection as being locked.
! 1296: */
! 1297: if( rc==SQLITE_OK ){
! 1298: rc = os2ShmSystemLock(pShmNode, _SHM_WRLCK, ofst+OS2_SHM_BASE, n);
! 1299: if( rc==SQLITE_OK ){
! 1300: assert( (p->sharedMask & mask)==0 );
! 1301: p->exclMask |= mask;
! 1302: }
! 1303: }
! 1304: }
! 1305:
! 1306: sqlite3_mutex_leave(pShmNode->mutex);
! 1307:
! 1308: OSTRACE(("SHM-LOCK shmid-%d, pid-%d got %03x,%03x %s\n",
! 1309: p->id, (int)GetCurrentProcessId(), p->sharedMask, p->exclMask,
! 1310: rc ? "failed" : "ok"));
! 1311:
! 1312: ERR_TRACE(rc, ("os2ShmLock: ofst = %d, n = %d, flags = 0x%x -> %d \n",
! 1313: ofst, n, flags, rc))
! 1314:
! 1315: return rc;
! 1316: }
! 1317:
! 1318: /*
! 1319: ** Implement a memory barrier or memory fence on shared memory.
! 1320: **
! 1321: ** All loads and stores begun before the barrier must complete before
! 1322: ** any load or store begun after the barrier.
! 1323: */
! 1324: static void os2ShmBarrier(
! 1325: sqlite3_file *id /* Database file holding the shared memory */
! 1326: ){
! 1327: UNUSED_PARAMETER(id);
! 1328: os2ShmEnterMutex();
! 1329: os2ShmLeaveMutex();
! 1330: }
! 1331:
! 1332: #else
! 1333: # define os2ShmMap 0
! 1334: # define os2ShmLock 0
! 1335: # define os2ShmBarrier 0
! 1336: # define os2ShmUnmap 0
! 1337: #endif /* #ifndef SQLITE_OMIT_WAL */
! 1338:
! 1339:
! 1340: /*
! 1341: ** This vector defines all the methods that can operate on an
! 1342: ** sqlite3_file for os2.
! 1343: */
! 1344: static const sqlite3_io_methods os2IoMethod = {
! 1345: 2, /* iVersion */
! 1346: os2Close, /* xClose */
! 1347: os2Read, /* xRead */
! 1348: os2Write, /* xWrite */
! 1349: os2Truncate, /* xTruncate */
! 1350: os2Sync, /* xSync */
! 1351: os2FileSize, /* xFileSize */
! 1352: os2Lock, /* xLock */
! 1353: os2Unlock, /* xUnlock */
! 1354: os2CheckReservedLock, /* xCheckReservedLock */
! 1355: os2FileControl, /* xFileControl */
! 1356: os2SectorSize, /* xSectorSize */
! 1357: os2DeviceCharacteristics, /* xDeviceCharacteristics */
! 1358: os2ShmMap, /* xShmMap */
! 1359: os2ShmLock, /* xShmLock */
! 1360: os2ShmBarrier, /* xShmBarrier */
! 1361: os2ShmUnmap /* xShmUnmap */
! 1362: };
! 1363:
! 1364:
! 1365: /***************************************************************************
! 1366: ** Here ends the I/O methods that form the sqlite3_io_methods object.
! 1367: **
! 1368: ** The next block of code implements the VFS methods.
! 1369: ****************************************************************************/
! 1370:
! 1371: /*
! 1372: ** Create a temporary file name in zBuf. zBuf must be big enough to
! 1373: ** hold at pVfs->mxPathname characters.
! 1374: */
! 1375: static int getTempname(int nBuf, char *zBuf ){
! 1376: static const char zChars[] =
! 1377: "abcdefghijklmnopqrstuvwxyz"
! 1378: "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
! 1379: "0123456789";
! 1380: int i, j;
! 1381: PSZ zTempPathCp;
! 1382: char zTempPath[CCHMAXPATH];
! 1383: ULONG ulDriveNum, ulDriveMap;
! 1384:
! 1385: /* It's odd to simulate an io-error here, but really this is just
! 1386: ** using the io-error infrastructure to test that SQLite handles this
! 1387: ** function failing.
! 1388: */
! 1389: SimulateIOError( return SQLITE_IOERR );
! 1390:
! 1391: if( sqlite3_temp_directory ) {
! 1392: sqlite3_snprintf(CCHMAXPATH-30, zTempPath, "%s", sqlite3_temp_directory);
! 1393: } else if( DosScanEnv( (PSZ)"TEMP", &zTempPathCp ) == NO_ERROR ||
! 1394: DosScanEnv( (PSZ)"TMP", &zTempPathCp ) == NO_ERROR ||
! 1395: DosScanEnv( (PSZ)"TMPDIR", &zTempPathCp ) == NO_ERROR ) {
! 1396: char *zTempPathUTF = convertCpPathToUtf8( (char *)zTempPathCp );
! 1397: sqlite3_snprintf(CCHMAXPATH-30, zTempPath, "%s", zTempPathUTF);
! 1398: free( zTempPathUTF );
! 1399: } else if( DosQueryCurrentDisk( &ulDriveNum, &ulDriveMap ) == NO_ERROR ) {
! 1400: zTempPath[0] = (char)('A' + ulDriveNum - 1);
! 1401: zTempPath[1] = ':';
! 1402: zTempPath[2] = '\0';
! 1403: } else {
! 1404: zTempPath[0] = '\0';
! 1405: }
! 1406:
! 1407: /* Strip off a trailing slashes or backslashes, otherwise we would get *
! 1408: * multiple (back)slashes which causes DosOpen() to fail. *
! 1409: * Trailing spaces are not allowed, either. */
! 1410: j = sqlite3Strlen30(zTempPath);
! 1411: while( j > 0 && ( zTempPath[j-1] == '\\' || zTempPath[j-1] == '/' ||
! 1412: zTempPath[j-1] == ' ' ) ){
! 1413: j--;
! 1414: }
! 1415: zTempPath[j] = '\0';
! 1416:
! 1417: /* We use 20 bytes to randomize the name */
! 1418: sqlite3_snprintf(nBuf-22, zBuf,
! 1419: "%s\\"SQLITE_TEMP_FILE_PREFIX, zTempPath);
! 1420: j = sqlite3Strlen30(zBuf);
! 1421: sqlite3_randomness( 20, &zBuf[j] );
! 1422: for( i = 0; i < 20; i++, j++ ){
! 1423: zBuf[j] = zChars[ ((unsigned char)zBuf[j])%(sizeof(zChars)-1) ];
! 1424: }
! 1425: zBuf[j] = 0;
! 1426:
! 1427: OSTRACE(( "TEMP FILENAME: %s\n", zBuf ));
! 1428: return SQLITE_OK;
! 1429: }
! 1430:
! 1431:
! 1432: /*
! 1433: ** Turn a relative pathname into a full pathname. Write the full
! 1434: ** pathname into zFull[]. zFull[] will be at least pVfs->mxPathname
! 1435: ** bytes in size.
! 1436: */
! 1437: static int os2FullPathname(
! 1438: sqlite3_vfs *pVfs, /* Pointer to vfs object */
! 1439: const char *zRelative, /* Possibly relative input path */
! 1440: int nFull, /* Size of output buffer in bytes */
! 1441: char *zFull /* Output buffer */
! 1442: ){
! 1443: char *zRelativeCp = convertUtf8PathToCp( zRelative );
! 1444: char zFullCp[CCHMAXPATH] = "\0";
! 1445: char *zFullUTF;
! 1446: APIRET rc = DosQueryPathInfo( (PSZ)zRelativeCp, FIL_QUERYFULLNAME,
! 1447: zFullCp, CCHMAXPATH );
! 1448: free( zRelativeCp );
! 1449: zFullUTF = convertCpPathToUtf8( zFullCp );
! 1450: sqlite3_snprintf( nFull, zFull, zFullUTF );
! 1451: free( zFullUTF );
! 1452: return rc == NO_ERROR ? SQLITE_OK : SQLITE_IOERR;
! 1453: }
! 1454:
! 1455:
! 1456: /*
! 1457: ** Open a file.
! 1458: */
! 1459: static int os2Open(
! 1460: sqlite3_vfs *pVfs, /* Not used */
! 1461: const char *zName, /* Name of the file (UTF-8) */
! 1462: sqlite3_file *id, /* Write the SQLite file handle here */
! 1463: int flags, /* Open mode flags */
! 1464: int *pOutFlags /* Status return flags */
! 1465: ){
! 1466: HFILE h;
! 1467: ULONG ulOpenFlags = 0;
! 1468: ULONG ulOpenMode = 0;
! 1469: ULONG ulAction = 0;
! 1470: ULONG rc;
! 1471: os2File *pFile = (os2File*)id;
! 1472: const char *zUtf8Name = zName;
! 1473: char *zNameCp;
! 1474: char zTmpname[CCHMAXPATH];
! 1475:
! 1476: int isExclusive = (flags & SQLITE_OPEN_EXCLUSIVE);
! 1477: int isCreate = (flags & SQLITE_OPEN_CREATE);
! 1478: int isReadWrite = (flags & SQLITE_OPEN_READWRITE);
! 1479: #ifndef NDEBUG
! 1480: int isDelete = (flags & SQLITE_OPEN_DELETEONCLOSE);
! 1481: int isReadonly = (flags & SQLITE_OPEN_READONLY);
! 1482: int eType = (flags & 0xFFFFFF00);
! 1483: int isOpenJournal = (isCreate && (
! 1484: eType==SQLITE_OPEN_MASTER_JOURNAL
! 1485: || eType==SQLITE_OPEN_MAIN_JOURNAL
! 1486: || eType==SQLITE_OPEN_WAL
! 1487: ));
! 1488: #endif
! 1489:
! 1490: UNUSED_PARAMETER(pVfs);
! 1491: assert( id!=0 );
! 1492:
! 1493: /* Check the following statements are true:
! 1494: **
! 1495: ** (a) Exactly one of the READWRITE and READONLY flags must be set, and
! 1496: ** (b) if CREATE is set, then READWRITE must also be set, and
! 1497: ** (c) if EXCLUSIVE is set, then CREATE must also be set.
! 1498: ** (d) if DELETEONCLOSE is set, then CREATE must also be set.
! 1499: */
! 1500: assert((isReadonly==0 || isReadWrite==0) && (isReadWrite || isReadonly));
! 1501: assert(isCreate==0 || isReadWrite);
! 1502: assert(isExclusive==0 || isCreate);
! 1503: assert(isDelete==0 || isCreate);
! 1504:
! 1505: /* The main DB, main journal, WAL file and master journal are never
! 1506: ** automatically deleted. Nor are they ever temporary files. */
! 1507: assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_DB );
! 1508: assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_JOURNAL );
! 1509: assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MASTER_JOURNAL );
! 1510: assert( (!isDelete && zName) || eType!=SQLITE_OPEN_WAL );
! 1511:
! 1512: /* Assert that the upper layer has set one of the "file-type" flags. */
! 1513: assert( eType==SQLITE_OPEN_MAIN_DB || eType==SQLITE_OPEN_TEMP_DB
! 1514: || eType==SQLITE_OPEN_MAIN_JOURNAL || eType==SQLITE_OPEN_TEMP_JOURNAL
! 1515: || eType==SQLITE_OPEN_SUBJOURNAL || eType==SQLITE_OPEN_MASTER_JOURNAL
! 1516: || eType==SQLITE_OPEN_TRANSIENT_DB || eType==SQLITE_OPEN_WAL
! 1517: );
! 1518:
! 1519: memset( pFile, 0, sizeof(*pFile) );
! 1520: pFile->h = (HFILE)-1;
! 1521:
! 1522: /* If the second argument to this function is NULL, generate a
! 1523: ** temporary file name to use
! 1524: */
! 1525: if( !zUtf8Name ){
! 1526: assert(isDelete && !isOpenJournal);
! 1527: rc = getTempname(CCHMAXPATH, zTmpname);
! 1528: if( rc!=SQLITE_OK ){
! 1529: return rc;
! 1530: }
! 1531: zUtf8Name = zTmpname;
! 1532: }
! 1533:
! 1534: if( isReadWrite ){
! 1535: ulOpenMode |= OPEN_ACCESS_READWRITE;
! 1536: }else{
! 1537: ulOpenMode |= OPEN_ACCESS_READONLY;
! 1538: }
! 1539:
! 1540: /* Open in random access mode for possibly better speed. Allow full
! 1541: ** sharing because file locks will provide exclusive access when needed.
! 1542: ** The handle should not be inherited by child processes and we don't
! 1543: ** want popups from the critical error handler.
! 1544: */
! 1545: ulOpenMode |= OPEN_FLAGS_RANDOM | OPEN_SHARE_DENYNONE |
! 1546: OPEN_FLAGS_NOINHERIT | OPEN_FLAGS_FAIL_ON_ERROR;
! 1547:
! 1548: /* SQLITE_OPEN_EXCLUSIVE is used to make sure that a new file is
! 1549: ** created. SQLite doesn't use it to indicate "exclusive access"
! 1550: ** as it is usually understood.
! 1551: */
! 1552: if( isExclusive ){
! 1553: /* Creates a new file, only if it does not already exist. */
! 1554: /* If the file exists, it fails. */
! 1555: ulOpenFlags |= OPEN_ACTION_CREATE_IF_NEW | OPEN_ACTION_FAIL_IF_EXISTS;
! 1556: }else if( isCreate ){
! 1557: /* Open existing file, or create if it doesn't exist */
! 1558: ulOpenFlags |= OPEN_ACTION_CREATE_IF_NEW | OPEN_ACTION_OPEN_IF_EXISTS;
! 1559: }else{
! 1560: /* Opens a file, only if it exists. */
! 1561: ulOpenFlags |= OPEN_ACTION_FAIL_IF_NEW | OPEN_ACTION_OPEN_IF_EXISTS;
! 1562: }
! 1563:
! 1564: zNameCp = convertUtf8PathToCp( zUtf8Name );
! 1565: rc = DosOpen( (PSZ)zNameCp,
! 1566: &h,
! 1567: &ulAction,
! 1568: 0L,
! 1569: FILE_NORMAL,
! 1570: ulOpenFlags,
! 1571: ulOpenMode,
! 1572: (PEAOP2)NULL );
! 1573: free( zNameCp );
! 1574:
! 1575: if( rc != NO_ERROR ){
! 1576: OSTRACE(( "OPEN Invalid handle rc=%d: zName=%s, ulAction=%#lx, ulFlags=%#lx, ulMode=%#lx\n",
! 1577: rc, zUtf8Name, ulAction, ulOpenFlags, ulOpenMode ));
! 1578:
! 1579: if( isReadWrite ){
! 1580: return os2Open( pVfs, zName, id,
! 1581: ((flags|SQLITE_OPEN_READONLY)&~(SQLITE_OPEN_CREATE|SQLITE_OPEN_READWRITE)),
! 1582: pOutFlags );
! 1583: }else{
! 1584: return SQLITE_CANTOPEN;
! 1585: }
! 1586: }
! 1587:
! 1588: if( pOutFlags ){
! 1589: *pOutFlags = isReadWrite ? SQLITE_OPEN_READWRITE : SQLITE_OPEN_READONLY;
! 1590: }
! 1591:
! 1592: os2FullPathname( pVfs, zUtf8Name, sizeof( zTmpname ), zTmpname );
! 1593: pFile->zFullPathCp = convertUtf8PathToCp( zTmpname );
! 1594: pFile->pMethod = &os2IoMethod;
! 1595: pFile->flags = flags;
! 1596: pFile->h = h;
! 1597:
! 1598: OpenCounter(+1);
! 1599: OSTRACE(( "OPEN %d pOutFlags=%d\n", pFile->h, pOutFlags ));
! 1600: return SQLITE_OK;
! 1601: }
! 1602:
! 1603: /*
! 1604: ** Delete the named file.
! 1605: */
! 1606: static int os2Delete(
! 1607: sqlite3_vfs *pVfs, /* Not used on os2 */
! 1608: const char *zFilename, /* Name of file to delete */
! 1609: int syncDir /* Not used on os2 */
! 1610: ){
! 1611: APIRET rc;
! 1612: char *zFilenameCp;
! 1613: SimulateIOError( return SQLITE_IOERR_DELETE );
! 1614: zFilenameCp = convertUtf8PathToCp( zFilename );
! 1615: rc = DosDelete( (PSZ)zFilenameCp );
! 1616: free( zFilenameCp );
! 1617: OSTRACE(( "DELETE \"%s\"\n", zFilename ));
! 1618: return (rc == NO_ERROR ||
! 1619: rc == ERROR_FILE_NOT_FOUND ||
! 1620: rc == ERROR_PATH_NOT_FOUND ) ? SQLITE_OK : SQLITE_IOERR_DELETE;
! 1621: }
! 1622:
! 1623: /*
! 1624: ** Check the existance and status of a file.
! 1625: */
! 1626: static int os2Access(
! 1627: sqlite3_vfs *pVfs, /* Not used on os2 */
! 1628: const char *zFilename, /* Name of file to check */
! 1629: int flags, /* Type of test to make on this file */
! 1630: int *pOut /* Write results here */
! 1631: ){
! 1632: APIRET rc;
! 1633: FILESTATUS3 fsts3ConfigInfo;
! 1634: char *zFilenameCp;
! 1635:
! 1636: UNUSED_PARAMETER(pVfs);
! 1637: SimulateIOError( return SQLITE_IOERR_ACCESS; );
! 1638:
! 1639: zFilenameCp = convertUtf8PathToCp( zFilename );
! 1640: rc = DosQueryPathInfo( (PSZ)zFilenameCp, FIL_STANDARD,
! 1641: &fsts3ConfigInfo, sizeof(FILESTATUS3) );
! 1642: free( zFilenameCp );
! 1643: OSTRACE(( "ACCESS fsts3ConfigInfo.attrFile=%d flags=%d rc=%d\n",
! 1644: fsts3ConfigInfo.attrFile, flags, rc ));
! 1645:
! 1646: switch( flags ){
! 1647: case SQLITE_ACCESS_EXISTS:
! 1648: /* For an SQLITE_ACCESS_EXISTS query, treat a zero-length file
! 1649: ** as if it does not exist.
! 1650: */
! 1651: if( fsts3ConfigInfo.cbFile == 0 )
! 1652: rc = ERROR_FILE_NOT_FOUND;
! 1653: break;
! 1654: case SQLITE_ACCESS_READ:
! 1655: break;
! 1656: case SQLITE_ACCESS_READWRITE:
! 1657: if( fsts3ConfigInfo.attrFile & FILE_READONLY )
! 1658: rc = ERROR_ACCESS_DENIED;
! 1659: break;
! 1660: default:
! 1661: rc = ERROR_FILE_NOT_FOUND;
! 1662: assert( !"Invalid flags argument" );
! 1663: }
! 1664:
! 1665: *pOut = (rc == NO_ERROR);
! 1666: OSTRACE(( "ACCESS %s flags %d: rc=%d\n", zFilename, flags, *pOut ));
! 1667:
! 1668: return SQLITE_OK;
! 1669: }
! 1670:
! 1671:
! 1672: #ifndef SQLITE_OMIT_LOAD_EXTENSION
! 1673: /*
! 1674: ** Interfaces for opening a shared library, finding entry points
! 1675: ** within the shared library, and closing the shared library.
! 1676: */
! 1677: /*
! 1678: ** Interfaces for opening a shared library, finding entry points
! 1679: ** within the shared library, and closing the shared library.
! 1680: */
! 1681: static void *os2DlOpen(sqlite3_vfs *pVfs, const char *zFilename){
! 1682: HMODULE hmod;
! 1683: APIRET rc;
! 1684: char *zFilenameCp = convertUtf8PathToCp(zFilename);
! 1685: rc = DosLoadModule(NULL, 0, (PSZ)zFilenameCp, &hmod);
! 1686: free(zFilenameCp);
! 1687: return rc != NO_ERROR ? 0 : (void*)hmod;
! 1688: }
! 1689: /*
! 1690: ** A no-op since the error code is returned on the DosLoadModule call.
! 1691: ** os2Dlopen returns zero if DosLoadModule is not successful.
! 1692: */
! 1693: static void os2DlError(sqlite3_vfs *pVfs, int nBuf, char *zBufOut){
! 1694: /* no-op */
! 1695: }
! 1696: static void (*os2DlSym(sqlite3_vfs *pVfs, void *pHandle, const char *zSymbol))(void){
! 1697: PFN pfn;
! 1698: APIRET rc;
! 1699: rc = DosQueryProcAddr((HMODULE)pHandle, 0L, (PSZ)zSymbol, &pfn);
! 1700: if( rc != NO_ERROR ){
! 1701: /* if the symbol itself was not found, search again for the same
! 1702: * symbol with an extra underscore, that might be needed depending
! 1703: * on the calling convention */
! 1704: char _zSymbol[256] = "_";
! 1705: strncat(_zSymbol, zSymbol, 254);
! 1706: rc = DosQueryProcAddr((HMODULE)pHandle, 0L, (PSZ)_zSymbol, &pfn);
! 1707: }
! 1708: return rc != NO_ERROR ? 0 : (void(*)(void))pfn;
! 1709: }
! 1710: static void os2DlClose(sqlite3_vfs *pVfs, void *pHandle){
! 1711: DosFreeModule((HMODULE)pHandle);
! 1712: }
! 1713: #else /* if SQLITE_OMIT_LOAD_EXTENSION is defined: */
! 1714: #define os2DlOpen 0
! 1715: #define os2DlError 0
! 1716: #define os2DlSym 0
! 1717: #define os2DlClose 0
! 1718: #endif
! 1719:
! 1720:
! 1721: /*
! 1722: ** Write up to nBuf bytes of randomness into zBuf.
! 1723: */
! 1724: static int os2Randomness(sqlite3_vfs *pVfs, int nBuf, char *zBuf ){
! 1725: int n = 0;
! 1726: #if defined(SQLITE_TEST)
! 1727: n = nBuf;
! 1728: memset(zBuf, 0, nBuf);
! 1729: #else
! 1730: int i;
! 1731: PPIB ppib;
! 1732: PTIB ptib;
! 1733: DATETIME dt;
! 1734: static unsigned c = 0;
! 1735: /* Ordered by variation probability */
! 1736: static ULONG svIdx[6] = { QSV_MS_COUNT, QSV_TIME_LOW,
! 1737: QSV_MAXPRMEM, QSV_MAXSHMEM,
! 1738: QSV_TOTAVAILMEM, QSV_TOTRESMEM };
! 1739:
! 1740: /* 8 bytes; timezone and weekday don't increase the randomness much */
! 1741: if( (int)sizeof(dt)-3 <= nBuf - n ){
! 1742: c += 0x0100;
! 1743: DosGetDateTime(&dt);
! 1744: dt.year = (USHORT)((dt.year - 1900) | c);
! 1745: memcpy(&zBuf[n], &dt, sizeof(dt)-3);
! 1746: n += sizeof(dt)-3;
! 1747: }
! 1748:
! 1749: /* 4 bytes; PIDs and TIDs are 16 bit internally, so combine them */
! 1750: if( (int)sizeof(ULONG) <= nBuf - n ){
! 1751: DosGetInfoBlocks(&ptib, &ppib);
! 1752: *(PULONG)&zBuf[n] = MAKELONG(ppib->pib_ulpid,
! 1753: ptib->tib_ptib2->tib2_ultid);
! 1754: n += sizeof(ULONG);
! 1755: }
! 1756:
! 1757: /* Up to 6 * 4 bytes; variables depend on the system state */
! 1758: for( i = 0; i < 6 && (int)sizeof(ULONG) <= nBuf - n; i++ ){
! 1759: DosQuerySysInfo(svIdx[i], svIdx[i],
! 1760: (PULONG)&zBuf[n], sizeof(ULONG));
! 1761: n += sizeof(ULONG);
! 1762: }
! 1763: #endif
! 1764:
! 1765: return n;
! 1766: }
! 1767:
! 1768: /*
! 1769: ** Sleep for a little while. Return the amount of time slept.
! 1770: ** The argument is the number of microseconds we want to sleep.
! 1771: ** The return value is the number of microseconds of sleep actually
! 1772: ** requested from the underlying operating system, a number which
! 1773: ** might be greater than or equal to the argument, but not less
! 1774: ** than the argument.
! 1775: */
! 1776: static int os2Sleep( sqlite3_vfs *pVfs, int microsec ){
! 1777: DosSleep( (microsec/1000) );
! 1778: return microsec;
! 1779: }
! 1780:
! 1781: /*
! 1782: ** The following variable, if set to a non-zero value, becomes the result
! 1783: ** returned from sqlite3OsCurrentTime(). This is used for testing.
! 1784: */
! 1785: #ifdef SQLITE_TEST
! 1786: int sqlite3_current_time = 0;
! 1787: #endif
! 1788:
! 1789: /*
! 1790: ** Find the current time (in Universal Coordinated Time). Write into *piNow
! 1791: ** the current time and date as a Julian Day number times 86_400_000. In
! 1792: ** other words, write into *piNow the number of milliseconds since the Julian
! 1793: ** epoch of noon in Greenwich on November 24, 4714 B.C according to the
! 1794: ** proleptic Gregorian calendar.
! 1795: **
! 1796: ** On success, return 0. Return 1 if the time and date cannot be found.
! 1797: */
! 1798: static int os2CurrentTimeInt64(sqlite3_vfs *pVfs, sqlite3_int64 *piNow){
! 1799: #ifdef SQLITE_TEST
! 1800: static const sqlite3_int64 unixEpoch = 24405875*(sqlite3_int64)8640000;
! 1801: #endif
! 1802: int year, month, datepart, timepart;
! 1803:
! 1804: DATETIME dt;
! 1805: DosGetDateTime( &dt );
! 1806:
! 1807: year = dt.year;
! 1808: month = dt.month;
! 1809:
! 1810: /* Calculations from http://www.astro.keele.ac.uk/~rno/Astronomy/hjd.html
! 1811: ** http://www.astro.keele.ac.uk/~rno/Astronomy/hjd-0.1.c
! 1812: ** Calculate the Julian days
! 1813: */
! 1814: datepart = (int)dt.day - 32076 +
! 1815: 1461*(year + 4800 + (month - 14)/12)/4 +
! 1816: 367*(month - 2 - (month - 14)/12*12)/12 -
! 1817: 3*((year + 4900 + (month - 14)/12)/100)/4;
! 1818:
! 1819: /* Time in milliseconds, hours to noon added */
! 1820: timepart = 12*3600*1000 + dt.hundredths*10 + dt.seconds*1000 +
! 1821: ((int)dt.minutes + dt.timezone)*60*1000 + dt.hours*3600*1000;
! 1822:
! 1823: *piNow = (sqlite3_int64)datepart*86400*1000 + timepart;
! 1824:
! 1825: #ifdef SQLITE_TEST
! 1826: if( sqlite3_current_time ){
! 1827: *piNow = 1000*(sqlite3_int64)sqlite3_current_time + unixEpoch;
! 1828: }
! 1829: #endif
! 1830:
! 1831: UNUSED_PARAMETER(pVfs);
! 1832: return 0;
! 1833: }
! 1834:
! 1835: /*
! 1836: ** Find the current time (in Universal Coordinated Time). Write the
! 1837: ** current time and date as a Julian Day number into *prNow and
! 1838: ** return 0. Return 1 if the time and date cannot be found.
! 1839: */
! 1840: static int os2CurrentTime( sqlite3_vfs *pVfs, double *prNow ){
! 1841: int rc;
! 1842: sqlite3_int64 i;
! 1843: rc = os2CurrentTimeInt64(pVfs, &i);
! 1844: if( !rc ){
! 1845: *prNow = i/86400000.0;
! 1846: }
! 1847: return rc;
! 1848: }
! 1849:
! 1850: /*
! 1851: ** The idea is that this function works like a combination of
! 1852: ** GetLastError() and FormatMessage() on windows (or errno and
! 1853: ** strerror_r() on unix). After an error is returned by an OS
! 1854: ** function, SQLite calls this function with zBuf pointing to
! 1855: ** a buffer of nBuf bytes. The OS layer should populate the
! 1856: ** buffer with a nul-terminated UTF-8 encoded error message
! 1857: ** describing the last IO error to have occurred within the calling
! 1858: ** thread.
! 1859: **
! 1860: ** If the error message is too large for the supplied buffer,
! 1861: ** it should be truncated. The return value of xGetLastError
! 1862: ** is zero if the error message fits in the buffer, or non-zero
! 1863: ** otherwise (if the message was truncated). If non-zero is returned,
! 1864: ** then it is not necessary to include the nul-terminator character
! 1865: ** in the output buffer.
! 1866: **
! 1867: ** Not supplying an error message will have no adverse effect
! 1868: ** on SQLite. It is fine to have an implementation that never
! 1869: ** returns an error message:
! 1870: **
! 1871: ** int xGetLastError(sqlite3_vfs *pVfs, int nBuf, char *zBuf){
! 1872: ** assert(zBuf[0]=='\0');
! 1873: ** return 0;
! 1874: ** }
! 1875: **
! 1876: ** However if an error message is supplied, it will be incorporated
! 1877: ** by sqlite into the error message available to the user using
! 1878: ** sqlite3_errmsg(), possibly making IO errors easier to debug.
! 1879: */
! 1880: static int os2GetLastError(sqlite3_vfs *pVfs, int nBuf, char *zBuf){
! 1881: assert(zBuf[0]=='\0');
! 1882: return 0;
! 1883: }
! 1884:
! 1885: /*
! 1886: ** Initialize and deinitialize the operating system interface.
! 1887: */
! 1888: int sqlite3_os_init(void){
! 1889: static sqlite3_vfs os2Vfs = {
! 1890: 3, /* iVersion */
! 1891: sizeof(os2File), /* szOsFile */
! 1892: CCHMAXPATH, /* mxPathname */
! 1893: 0, /* pNext */
! 1894: "os2", /* zName */
! 1895: 0, /* pAppData */
! 1896:
! 1897: os2Open, /* xOpen */
! 1898: os2Delete, /* xDelete */
! 1899: os2Access, /* xAccess */
! 1900: os2FullPathname, /* xFullPathname */
! 1901: os2DlOpen, /* xDlOpen */
! 1902: os2DlError, /* xDlError */
! 1903: os2DlSym, /* xDlSym */
! 1904: os2DlClose, /* xDlClose */
! 1905: os2Randomness, /* xRandomness */
! 1906: os2Sleep, /* xSleep */
! 1907: os2CurrentTime, /* xCurrentTime */
! 1908: os2GetLastError, /* xGetLastError */
! 1909: os2CurrentTimeInt64, /* xCurrentTimeInt64 */
! 1910: 0, /* xSetSystemCall */
! 1911: 0, /* xGetSystemCall */
! 1912: 0 /* xNextSystemCall */
! 1913: };
! 1914: sqlite3_vfs_register(&os2Vfs, 1);
! 1915: initUconvObjects();
! 1916: /* sqlite3OSTrace = 1; */
! 1917: return SQLITE_OK;
! 1918: }
! 1919: int sqlite3_os_end(void){
! 1920: freeUconvObjects();
! 1921: return SQLITE_OK;
! 1922: }
! 1923:
! 1924: #endif /* SQLITE_OS_OS2 */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to os_os2.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / src