store/source/storbios.cxx

   1 /*************************************************************************
   2  *
   3  *  OpenOffice.org - a multi-platform office productivity suite
   4  *
   5  *  $RCSfile: storbios.cxx,v $
   6  *
   7  *  $Revision: 1.1.2.3 $
   8  *
   9  *  last change: $Author: mhu $ $Date: 2008/10/31 18:28:18 $
  10  *
  11  *  The Contents of this file are made available subject to
  12  *  the terms of GNU Lesser General Public License Version 2.1.
  13  *
  14  *
  15  *    GNU Lesser General Public License Version 2.1
  16  *    =============================================
  17  *    Copyright 2005 by Sun Microsystems, Inc.
  18  *    901 San Antonio Road, Palo Alto, CA 94303, USA
  19  *
  20  *    This library is free software; you can redistribute it and/or
  21  *    modify it under the terms of the GNU Lesser General Public
  22  *    License version 2.1, as published by the Free Software Foundation.
  23  *
  24  *    This library is distributed in the hope that it will be useful,
  25  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  26  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  27  *    Lesser General Public License for more details.
  28  *
  29  *    You should have received a copy of the GNU Lesser General Public
  30  *    License along with this library; if not, write to the Free Software
  31  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  32  *    MA  02111-1307  USA
  33  *
  34  ************************************************************************/
  35
  36 // MARKER(update_precomp.py): autogen include statement, do not remove
  37 #include "precompiled_store.hxx"
  38
  39 #include "storbios.hxx"
  40
  41 #include "sal/types.h"
  42 #include "sal/macros.h"
  43
  44 #include "rtl/alloc.h"
  45 #include "rtl/ref.hxx"
  46
  47 #include "osl/diagnose.h"
  48 #include "osl/mutex.hxx"
  49
  50 #include "store/types.h"
  51 #include "object.hxx"
  52 #include "lockbyte.hxx"
  53 #include "storcach.hxx"
  54
  55 using namespace store;
  56
  57 /*========================================================================
  58  *
  59  * OStoreSuperBlock.
  60  *
  61  *======================================================================*/
  62 #define STORE_MAGIC_SUPERBLOCK sal_uInt32(0x484D5343)
  63
  64 struct OStoreSuperBlock
  65 {
  66     typedef OStorePageGuard      G;
  67     typedef OStorePageDescriptor D;
  68     typedef OStorePageLink       L;
  69
  70     /** Representation.
  71      */
  72     G          m_aGuard;
  73     D          m_aDescr;
  74     sal_uInt32 m_nMarked;
  75     L          m_aMarked;
  76     sal_uInt32 m_nUnused;
  77     L          m_aUnused;
  78
  79     /** theSize.
  80      */
  81     static const size_t theSize = sizeof(G) + sizeof(D) + 2 * (sizeof(L) + sizeof(sal_uInt32));
  82
  83     /** Construction.
  84      */
  85     explicit OStoreSuperBlock (sal_uInt16 nPageSize)
  86         : m_aGuard  (STORE_MAGIC_SUPERBLOCK),
  87           m_aDescr  (nPageSize, nPageSize, STORE_MINIMUM_PAGESIZE),
  88           m_nMarked (store::htonl(0)),
  89           m_aMarked (0),
  90           m_nUnused (store::htonl(0)),
  91           m_aUnused (0)
  92     {}
  93
  94     OStoreSuperBlock (const OStoreSuperBlock& rOther)
  95         : m_aGuard  (rOther.m_aGuard),
  96           m_aDescr  (rOther.m_aDescr),
  97           m_nMarked (rOther.m_nMarked),
  98           m_aMarked (rOther.m_aMarked),
  99           m_nUnused (rOther.m_nUnused),
 100           m_aUnused (rOther.m_aUnused)
 101     {}
 102
 103     OStoreSuperBlock& operator= (const OStoreSuperBlock& rOther)
 104     {
 105         m_aGuard  = rOther.m_aGuard;
 106         m_aDescr  = rOther.m_aDescr;
 107         m_nMarked = rOther.m_nMarked;
 108         m_aMarked = rOther.m_aMarked;
 109         m_nUnused = rOther.m_nUnused;
 110         m_aUnused = rOther.m_aUnused;
 111         return *this;
 112     }
 113
 114     /** Comparison.
 115      */
 116     sal_Bool operator== (const OStoreSuperBlock& rOther) const
 117     {
 118         return ((m_aGuard  == rOther.m_aGuard ) &&
 119                 (m_aDescr  == rOther.m_aDescr ) &&
 120                 (m_nMarked == rOther.m_nMarked) &&
 121                 (m_aMarked == rOther.m_aMarked) &&
 122                 (m_nUnused == rOther.m_nUnused) &&
 123                 (m_aUnused == rOther.m_aUnused)    );
 124     }
 125
 126     /** unused(Count|Head|Insert|Remove|Reset).
 127      */
 128     sal_uInt32 unusedCount (void) const
 129     {
 130         return store::ntohl(m_nUnused);
 131     }
 132     const L& unusedHead (void) const
 133     {
 134         return m_aUnused;
 135     }
 136     void unusedInsert (const L& rLink)
 137     {
 138         sal_uInt32 nUnused = unusedCount();
 139         m_nUnused = store::htonl(nUnused + 1);
 140         m_aUnused = rLink;
 141     }
 142     void unusedRemove (const L& rLink)
 143     {
 144         sal_uInt32 nUnused = unusedCount();
 145         m_nUnused = store::htonl(nUnused - 1);
 146         m_aUnused = rLink;
 147     }
 148     void unusedReset (void)
 149     {
 150         m_nUnused = store::htonl(0);
 151         m_aUnused = L(0);
 152     }
 153
 154     /** guard (external representation).
 155      */
 156     void guard()
 157     {
 158         sal_uInt32 nCRC32 = 0;
 159         nCRC32 = rtl_crc32 (nCRC32, &m_aGuard.m_nMagic, sizeof(sal_uInt32));
 160         nCRC32 = rtl_crc32 (nCRC32, &m_aDescr, theSize - sizeof(G));
 161         m_aGuard.m_nCRC32 = store::htonl(nCRC32);
 162     }
 163
 164     /** verify (external representation).
 165      */
 166     storeError verify() const
 167     {
 168         sal_uInt32 nMagic = store::ntohl(m_aGuard.m_nMagic);
 169         if (nMagic != STORE_MAGIC_SUPERBLOCK)
 170             return store_E_WrongFormat;
 171
 172         sal_uInt32 nCRC32 = 0;
 173         nCRC32 = rtl_crc32 (nCRC32, &m_aGuard.m_nMagic, sizeof(sal_uInt32));
 174         nCRC32 = rtl_crc32 (nCRC32, &m_aDescr, theSize - sizeof(G));
 175         if (m_aGuard.m_nCRC32 != store::htonl(nCRC32))
 176             return store_E_InvalidChecksum;
 177         else
 178             return store_E_None;
 179     }
 180 };
 181
 182 /*========================================================================
 183  *
 184  * OStoreStateBlock.
 185  *
 186  *======================================================================*/
 187 struct OStoreStateBlock
 188 {
 189     enum StateBits
 190     {
 191         STATE_CLEAN      = 0,
 192         STATE_CLOSE_WAIT = 1,
 193         STATE_FLUSH_WAIT = 2
 194     };
 195
 196     /** Representation.
 197      */
 198     sal_uInt32 m_nState;
 199
 200     /** theSize.
 201      */
 202     static const size_t theSize = sizeof(sal_uInt32);
 203
 204     /** Construction.
 205      */
 206     OStoreStateBlock()
 207         : m_nState (store::htonl(STATE_CLEAN))
 208     {}
 209
 210     /** Operation.
 211      */
 212     bool closePending (void) const
 213     {
 214         sal_uInt32 nState = store::ntohl(m_nState);
 215         return ((nState & STATE_CLOSE_WAIT) == STATE_CLOSE_WAIT);
 216     }
 217     void closed (void)
 218     {
 219         sal_uInt32 nState = store::ntohl(m_nState);
 220         nState &= ~STATE_CLOSE_WAIT;
 221         m_nState = store::htonl(nState);
 222     }
 223
 224     bool flushPending (void) const
 225     {
 226         sal_uInt32 nState = store::ntohl(m_nState);
 227         return ((nState & STATE_FLUSH_WAIT) == STATE_FLUSH_WAIT);
 228     }
 229     void flushed (void)
 230     {
 231         sal_uInt32 nState = store::ntohl(m_nState);
 232         nState &= ~STATE_FLUSH_WAIT;
 233         m_nState = store::htonl(nState);
 234     }
 235
 236     void modified (void)
 237     {
 238         sal_uInt32 nState = store::ntohl(m_nState);
 239         nState |= (STATE_CLOSE_WAIT | STATE_FLUSH_WAIT);
 240         m_nState = store::htonl(nState);
 241     }
 242     void clean (void)
 243     {
 244         sal_uInt32 nState = store::ntohl(m_nState);
 245         nState &= ~(STATE_CLOSE_WAIT | STATE_FLUSH_WAIT);
 246         m_nState = store::htonl(nState);
 247     }
 248 };
 249
 250 /*========================================================================
 251  *
 252  * OStoreSuperBlockPage interface.
 253  *
 254  *======================================================================*/
 255 namespace store
 256 {
 257
 258 struct OStoreSuperBlockPage
 259 {
 260     typedef OStoreSuperBlock SuperBlock;
 261     typedef OStoreStateBlock StateBlock;
 262
 263     /** Representation.
 264      */
 265     SuperBlock m_aSuperOne;
 266     SuperBlock m_aSuperTwo;
 267     StateBlock m_aState;
 268
 269     /** theSize.
 270      */
 271     static const size_t     theSize     = 2 * SuperBlock::theSize + StateBlock::theSize;
 272     static const sal_uInt16 thePageSize = theSize;
 273     STORE_STATIC_ASSERT(STORE_MINIMUM_PAGESIZE >= thePageSize);
 274
 275     /** Allocation.
 276      */
 277     static void * operator new (size_t n) SAL_THROW(())
 278     {
 279         return rtl_allocateMemory (sal::static_int_cast<sal_Size>(n));
 280     }
 281     static void operator delete (void * p, size_t) SAL_THROW(())
 282     {
 283         rtl_freeMemory (p);
 284     }
 285
 286     static void * operator new (size_t, sal_uInt16 nPageSize) SAL_THROW(())
 287     {
 288         return rtl_allocateZeroMemory (sal::static_int_cast<sal_Size>(nPageSize));
 289     }
 290     static void operator delete (void * p, sal_uInt16) SAL_THROW(())
 291     {
 292         rtl_freeMemory (p);
 293     }
 294
 295     /** Construction.
 296      */
 297     explicit OStoreSuperBlockPage (sal_uInt16 nPageSize = thePageSize)
 298         : m_aSuperOne(nPageSize),
 299           m_aSuperTwo(nPageSize),
 300           m_aState()
 301     {}
 302
 303     /** guard (external representation).
 304      */
 305     void guard()
 306     {
 307         m_aSuperOne.guard();
 308         m_aSuperTwo.guard();
 309     }
 310
 311     /** save.
 312      */
 313     storeError save (OStorePageBIOS &rBIOS)
 314     {
 315         // Guard.
 316         guard();
 317
 318         // Write.
 319         return rBIOS.write (0, this, theSize);
 320     }
 321
 322     /** close.
 323      */
 324     storeError close (
 325         OStorePageBIOS &rBIOS);
 326
 327     /** flush.
 328      */
 329     storeError flush (
 330         OStorePageBIOS &rBIOS);
 331
 332     /** modified.
 333      */
 334     storeError modified (
 335         OStorePageBIOS &rBIOS);
 336
 337     /** verify (with repair).
 338      */
 339     storeError verify (
 340         OStorePageBIOS &rBIOS);
 341 };
 342
 343 } // namespace store
 344
 345 /*========================================================================
 346  *
 347  * OStoreSuperBlockPage implementation.
 348  *
 349  *======================================================================*/
 350 /*
 351  * close.
 352  */
 353 storeError OStoreSuperBlockPage::close (OStorePageBIOS &rBIOS)
 354 {
 355     storeError eErrCode = store_E_None;
 356     if (m_aState.closePending())
 357     {
 358         // Mark as modified.
 359         m_aState.modified();
 360
 361         // Check access mode.
 362         if (rBIOS.isWriteable())
 363         {
 364             // Save StateBlock.
 365             StateBlock aState (m_aState);
 366
 367             // Mark as clean.
 368             aState.clean();
 369
 370             // Write behind SuperBlock.
 371             sal_uInt32 nAddr = 2 * SuperBlock::theSize;
 372             eErrCode = rBIOS.write (nAddr, &aState, StateBlock::theSize);
 373         }
 374
 375         // Mark as clean.
 376         m_aState.clean();
 377     }
 378     return eErrCode;
 379 }
 380
 381 /*
 382  * flush.
 383  */
 384 storeError OStoreSuperBlockPage::flush (OStorePageBIOS &rBIOS)
 385 {
 386     storeError eErrCode = store_E_None;
 387     if (m_aState.flushPending())
 388     {
 389         // Check access mode.
 390         if (rBIOS.isWriteable())
 391         {
 392             // Save StateBlock.
 393             StateBlock aState (m_aState);
 394
 395             // Mark as flushed.
 396             aState.flushed();
 397
 398             // Write behind SuperBlock.
 399             sal_uInt32 nAddr = 2 * SuperBlock::theSize;
 400             eErrCode = rBIOS.write (nAddr, &aState, StateBlock::theSize);
 401         }
 402
 403         // Mark as flushed.
 404         m_aState.flushed();
 405     }
 406     return eErrCode;
 407 }
 408
 409 /*
 410  * modified.
 411  */
 412 storeError OStoreSuperBlockPage::modified (OStorePageBIOS &rBIOS)
 413 {
 414     storeError eErrCode = store_E_None;
 415     if (!m_aState.flushPending())
 416     {
 417         // Mark as modified.
 418         m_aState.modified();
 419
 420         // Check access mode.
 421         if (rBIOS.isWriteable())
 422         {
 423             // Save StateBlock.
 424             StateBlock aState (m_aState);
 425
 426             // Write behind SuperBlock.
 427             sal_uInt32 nAddr = 2 * SuperBlock::theSize;
 428             eErrCode = rBIOS.write (nAddr, &aState, StateBlock::theSize);
 429         }
 430     }
 431     return eErrCode;
 432 }
 433
 434 /*
 435  * verify (with repair).
 436  */
 437 storeError OStoreSuperBlockPage::verify (OStorePageBIOS &rBIOS)
 438 {
 439     // Verify 1st copy.
 440     storeError eErrCode = m_aSuperOne.verify();
 441     if (eErrCode == store_E_None)
 442     {
 443         // Ok. Verify 2nd copy.
 444         eErrCode = m_aSuperTwo.verify();
 445         if (eErrCode == store_E_None)
 446         {
 447             // Ok. Ensure identical copies (1st copy wins).
 448             if (!(m_aSuperOne == m_aSuperTwo))
 449             {
 450                 // Different. Replace 2nd copy with 1st copy.
 451                 m_aSuperTwo = m_aSuperOne;
 452
 453                 // Write back.
 454                 if (rBIOS.isWriteable())
 455                     eErrCode = rBIOS.write (0, this, theSize);
 456                 else
 457                     eErrCode = store_E_None;
 458             }
 459         }
 460         else
 461         {
 462             // Failure. Replace 2nd copy with 1st copy.
 463             m_aSuperTwo = m_aSuperOne;
 464
 465             // Write back.
 466             if (rBIOS.isWriteable())
 467                 eErrCode = rBIOS.write (0, this, theSize);
 468             else
 469                 eErrCode = store_E_None;
 470         }
 471     }
 472     else
 473     {
 474         // Failure. Verify 2nd copy.
 475         eErrCode = m_aSuperTwo.verify();
 476         if (eErrCode == store_E_None)
 477         {
 478             // Ok. Replace 1st copy with 2nd copy.
 479             m_aSuperOne = m_aSuperTwo;
 480
 481             // Write back.
 482             if (rBIOS.isWriteable())
 483                 eErrCode = rBIOS.write (0, this, theSize);
 484             else
 485                 eErrCode = store_E_None;
 486         }
 487         else
 488         {
 489             // Double Failure.
 490             OSL_TRACE("OStoreSuperBlockPage::verify(): double failure.\n");
 491         }
 492     }
 493
 494     // Done.
 495     return eErrCode;
 496 }
 497
 498 /*========================================================================
 499  *
 500  * OStorePageBIOS::Ace implementation.
 501  *
 502  *======================================================================*/
 503 OStorePageBIOS::Ace::Ace()
 504   : m_next (this), m_prev (this), m_addr (STORE_PAGE_NULL), m_used (0)
 505 {}
 506
 507 OStorePageBIOS::Ace::~Ace()
 508 {
 509   m_next->m_prev = m_prev, m_prev->m_next = m_next;
 510 }
 511
 512 int
 513 SAL_CALL OStorePageBIOS::Ace::constructor (void * obj, void * /* arg */)
 514 {
 515   Ace * ace = static_cast<Ace*>(obj);
 516   ace->m_next = ace->m_prev = ace;
 517   return 1;
 518 }
 519
 520 OStorePageBIOS::Ace *
 521 OStorePageBIOS::Ace::find (OStorePageBIOS::Ace * head, sal_uInt32 addr)
 522 {
 523   OStorePageBIOS::Ace * entry;
 524   for (entry = head->m_next; entry != head; entry = entry->m_next)
 525   {
 526     if (entry->m_addr >= addr)
 527       return entry;
 528   }
 529   return head;
 530 }
 531
 532 void
 533 OStorePageBIOS::Ace::insert (OStorePageBIOS::Ace * head, OStorePageBIOS::Ace * entry)
 534 {
 535   // insert entry at queue tail (before head).
 536   entry->m_next = head;
 537   entry->m_prev = head->m_prev;
 538   head->m_prev = entry;
 539   entry->m_prev->m_next = entry;
 540 }
 541
 542 /*========================================================================
 543  *
 544  * OStorePageBIOS::AceCache interface.
 545  *
 546  *======================================================================*/
 547 namespace store
 548 {
 549
 550 class OStorePageBIOS::AceCache
 551 {
 552   rtl_cache_type * m_ace_cache;
 553
 554 public:
 555   static AceCache & get();
 556
 557   OStorePageBIOS::Ace *
 558   create (sal_uInt32 addr, sal_uInt32 used = 1);
 559
 560   void
 561   destroy (OStorePageBIOS::Ace * ace);
 562
 563 protected:
 564   AceCache();
 565   ~AceCache();
 566 };
 567
 568 } // namespace store
 569
 570 /*========================================================================
 571  *
 572  * OStorePageBIOS::AceCache implementation.
 573  *
 574  *======================================================================*/
 575 extern "C"  typedef  int (SAL_CALL * ace_constructor_type)(void*,void*);
 576
 577 OStorePageBIOS::AceCache &
 578 OStorePageBIOS::AceCache::get()
 579 {
 580   static AceCache g_ace_cache;
 581   return g_ace_cache;
 582 }
 583
 584 OStorePageBIOS::AceCache::AceCache()
 585 {
 586   m_ace_cache = rtl_cache_create (
 587     "store_ace_cache",
 588     sizeof (OStorePageBIOS::Ace),
 589     0, // objalign
 590    reinterpret_cast<ace_constructor_type>( OStorePageBIOS::Ace::constructor),
 591     0, // destructor,
 592     0, // reclaim,
 593     0, // userarg,
 594     0, // default source,
 595     0  // flags
 596     );
 597 }
 598
 599 OStorePageBIOS::AceCache::~AceCache()
 600 {
 601   rtl_cache_destroy (m_ace_cache), m_ace_cache = 0;
 602 }
 603
 604 OStorePageBIOS::Ace *
 605 OStorePageBIOS::AceCache::create (sal_uInt32 addr, sal_uInt32 used)
 606 {
 607   Ace * ace = static_cast<Ace*>(rtl_cache_alloc (m_ace_cache));
 608   if (ace != 0)
 609   {
 610     // verify invariant state.
 611     OSL_ASSERT((ace->m_next == ace) && (ace->m_prev == ace));
 612
 613     // initialize.
 614     ace->m_addr = addr;
 615     ace->m_used = used;
 616   }
 617   return ace;
 618 }
 619
 620 void
 621 OStorePageBIOS::AceCache::destroy (OStorePageBIOS::Ace * ace)
 622 {
 623   if (ace != 0)
 624   {
 625     // remove from queue (if any).
 626     ace->m_next->m_prev = ace->m_prev, ace->m_prev->m_next = ace->m_next;
 627
 628     // restore invariant state.
 629     ace->m_next = ace->m_prev = ace;
 630
 631     // return to cache.
 632     rtl_cache_free (m_ace_cache, ace);
 633   }
 634 }
 635
 636 /*========================================================================
 637  *
 638  * OStorePageBIOS implementation.
 639  *
 640  *======================================================================*/
 641 /*
 642  * OStorePageBIOS.
 643  */
 644 OStorePageBIOS::OStorePageBIOS (void)
 645     : m_xLockBytes (NULL),
 646       m_pSuper     (NULL),
 647       m_bModified  (sal_False),
 648       m_bWriteable (sal_False)
 649 {
 650 }
 651
 652 /*
 653  * ~OStorePageBIOS.
 654  */
 655 OStorePageBIOS::~OStorePageBIOS (void)
 656 {
 657     OStorePageBIOS::close();
 658 }
 659
 660 /*
 661  * verify (SuperBlock with repair).
 662  * Internal: Precond: initialized, exclusive access.
 663  */
 664 storeError OStorePageBIOS::verify (SuperPage *&rpSuper)
 665 {
 666     // Check SuperBlock page allocation.
 667     if (rpSuper == 0)
 668     {
 669         // Allocate.
 670         if ((rpSuper = new SuperPage()) == 0)
 671             return store_E_OutOfMemory;
 672
 673         // Load (w/o verification).
 674         storeError eErrCode = read (0, rpSuper, SuperPage::theSize);
 675         if (eErrCode != store_E_None)
 676         {
 677             // Cleanup and fail.
 678             delete rpSuper, rpSuper = 0;
 679             return eErrCode;
 680         }
 681
 682         // Check SuperBlock state.
 683         if (rpSuper->m_aState.closePending())
 684             OSL_TRACE("OStorePageBIOS::verify(): close pending.\n");
 685
 686         if (rpSuper->m_aState.flushPending())
 687             OSL_TRACE("OStorePageBIOS::verify(): flush pending.\n");
 688     }
 689
 690     // Verify SuperBlock page (with repair).
 691     return rpSuper->verify (*this);
 692 }
 693
 694 /*
 695  * repair (SuperBlock).
 696  * Internal: Precond: initialized, exclusive access.
 697  */
 698 storeError OStorePageBIOS::repair (SuperPage *&rpSuper)
 699 {
 700     // Acquire Lock.
 701     storeError eErrCode = acquireLock (0, SuperPage::theSize);
 702     if (eErrCode != store_E_None)
 703         return eErrCode;
 704
 705     // Verify SuperBlock page (with repair).
 706     eErrCode = verify (rpSuper);
 707     if (eErrCode != store_E_None)
 708     {
 709         // Failure.
 710         releaseLock (0, SuperPage::theSize);
 711         return eErrCode;
 712     }
 713
 714     // ReleaseLock.
 715     return releaseLock (0, SuperPage::theSize);
 716 }
 717
 718 /*
 719  * create (SuperBlock).
 720  * Internal: Precond: initialized, exclusive access.
 721  */
 722 storeError OStorePageBIOS::create (sal_uInt16 nPageSize)
 723 {
 724     // Check (internal) precond.
 725     OSL_PRECOND(m_xLockBytes.is(), "store::PageBIOS::create(): contract violation");
 726
 727     // Check PageSize.
 728     if ((STORE_MINIMUM_PAGESIZE > nPageSize) || (nPageSize > STORE_MAXIMUM_PAGESIZE))
 729         return store_E_InvalidParameter;
 730     nPageSize = ((nPageSize + STORE_MINIMUM_PAGESIZE - 1) & ~(STORE_MINIMUM_PAGESIZE - 1));
 731
 732     // Acquire Lock.
 733     storeError eErrCode = acquireLock (0, nPageSize);
 734     if (eErrCode != store_E_None)
 735         return eErrCode;
 736
 737     // Allocate SuperBlock page.
 738     delete m_pSuper, m_pSuper = 0;
 739     if ((m_pSuper = new(nPageSize) SuperPage(nPageSize)) == 0)
 740     {
 741         // Cleanup and fail.
 742         releaseLock (0, nPageSize);
 743         return store_E_OutOfMemory;
 744     }
 745     m_pSuper->guard();
 746
 747     // Create initial page (w/ SuperBlock).
 748     eErrCode = m_xLockBytes->writeAt (0, m_pSuper, nPageSize);
 749     if (eErrCode != store_E_None)
 750     {
 751         // Cleanup and fail.
 752         releaseLock (0, nPageSize);
 753         return eErrCode;
 754     }
 755
 756 #ifdef STORE_FEATURE_COMMIT
 757     // Commit.
 758     eErrCode = m_xLockBytes->flush();
 759     OSL_POSTCOND(
 760         eErrCode == store_E_None,
 761         "OStorePageBIOS::create(): flush failed");
 762 #endif /* STORE_FEATURE_COMMIT */
 763
 764     // Adjust modified state.
 765     m_bModified = (eErrCode != store_E_None);
 766
 767     // Release Lock and finish.
 768     return releaseLock (0, nPageSize);
 769 }
 770
 771 /*
 772  * initialize.
 773  * Precond: none.
 774  */
 775 storeError OStorePageBIOS::initialize (
 776     ILockBytes *    pLockBytes,
 777     storeAccessMode eAccessMode,
 778     sal_uInt16 &    rnPageSize)
 779 {
 780     // Acquire exclusive access.
 781     osl::MutexGuard aGuard (m_aMutex);
 782
 783     // Check arguments.
 784     storeError eErrCode = store_E_InvalidParameter;
 785     if (!pLockBytes)
 786         return eErrCode;
 787
 788     // Cleanup.
 789 #if 0  /* OLD */
 790     __STORE_DELETEZ (m_pAcl); /* @@@ */
 791 #endif /* OLD */
 792     delete m_pSuper, m_pSuper = 0;
 793
 794     // Initialize.
 795     m_xLockBytes = pLockBytes;
 796     m_bModified  = sal_False;
 797     m_bWriteable = (!(eAccessMode == store_AccessReadOnly));
 798
 799     // Check access mode.
 800     if (eAccessMode == store_AccessReadOnly)
 801     {
 802         // Verify SuperBlock page.
 803         eErrCode = verify (m_pSuper);
 804     }
 805     else if (eAccessMode != store_AccessCreate)
 806     {
 807         // Verify (w/ repair) SuperBlock page.
 808         eErrCode = repair (m_pSuper);
 809     }
 810     else
 811     {
 812         // Truncate to zero length.
 813         eErrCode = m_xLockBytes->setSize(0);
 814         if (eErrCode != store_E_None)
 815             return eErrCode;
 816
 817 #ifdef STORE_FEATURE_COMMIT
 818         // Commit.
 819         eErrCode = m_xLockBytes->flush();
 820         if (eErrCode != store_E_None)
 821             return eErrCode;
 822 #endif /* STORE_FEATURE_COMMIT */
 823
 824         // Mark as not existing.
 825         eErrCode = store_E_NotExists;
 826     }
 827
 828     if (eErrCode != store_E_None)
 829     {
 830         // Check reason.
 831         if (eErrCode != store_E_NotExists)
 832             return eErrCode;
 833
 834         // Check mode.
 835         if (eAccessMode == store_AccessReadOnly)
 836             return store_E_NotExists;
 837         if (eAccessMode == store_AccessReadWrite)
 838             return store_E_NotExists;
 839
 840         // Create SuperBlock page.
 841         eErrCode = create (rnPageSize);
 842     }
 843     if (eErrCode == store_E_None)
 844     {
 845         // Obtain modified state.
 846         m_bModified = m_pSuper->m_aState.flushPending();
 847
 848         // Obtain page size.
 849         rnPageSize = store::ntohs(m_pSuper->m_aSuperOne.m_aDescr.m_nSize);
 850
 851         // Create page allocator.
 852         eErrCode = m_xLockBytes->initialize (m_xAllocator, rnPageSize);
 853         if (eErrCode != store_E_None)
 854             return eErrCode;
 855
 856         // Create page cache.
 857         eErrCode = PageCache_createInstance (m_xCache, rnPageSize);
 858     }
 859     return eErrCode;
 860 }
 861
 862 /*
 863  * acquireLock.
 864  * Low Level: Precond: initialized, exclusive access.
 865  */
 866 storeError OStorePageBIOS::acquireLock (
 867     sal_uInt32 nAddr, sal_uInt32 nSize)
 868 {
 869     // Check precond.
 870     if (!m_xLockBytes.is())
 871         return store_E_InvalidAccess;
 872
 873     // Acquire Lock.
 874     return m_xLockBytes->lockRange (nAddr, nSize);
 875 }
 876
 877 /*
 878  * releaseLock.
 879  * Low Level: Precond: initialized, exclusive access.
 880  */
 881 storeError OStorePageBIOS::releaseLock (
 882     sal_uInt32 nAddr, sal_uInt32 nSize)
 883 {
 884     // Check precond.
 885     if (!m_xLockBytes.is())
 886         return store_E_InvalidAccess;
 887
 888     // Release Lock.
 889     return m_xLockBytes->unlockRange (nAddr, nSize);
 890 }
 891
 892 /*
 893  * read.
 894  * Low Level: Precond: initialized, exclusive access.
 895  */
 896 storeError OStorePageBIOS::read (
 897     sal_uInt32 nAddr, void *pData, sal_uInt32 nSize)
 898 {
 899     // Check precond.
 900     if (!m_xLockBytes.is())
 901         return store_E_InvalidAccess;
 902
 903     // Read Page.
 904     return m_xLockBytes->readAt (nAddr, pData, nSize);
 905 }
 906
 907 /*
 908  * write.
 909  * Low Level: Precond: initialized, writeable, exclusive access.
 910  */
 911 storeError OStorePageBIOS::write (
 912     sal_uInt32 nAddr, const void *pData, sal_uInt32 nSize)
 913 {
 914     // Check precond.
 915     if (!m_xLockBytes.is())
 916         return store_E_InvalidAccess;
 917     if (!m_bWriteable)
 918         return store_E_AccessViolation;
 919
 920     // Check modified state.
 921     if (!m_bModified)
 922     {
 923         // Mark as modified.
 924         m_bModified = sal_True;
 925
 926         // Mark SuperBlock modified.
 927         storeError eErrCode = m_pSuper->modified (*this);
 928         if (eErrCode != store_E_None)
 929             return eErrCode;
 930     }
 931
 932     // Write Data.
 933     return m_xLockBytes->writeAt (nAddr, pData, nSize);
 934 }
 935
 936 /*
 937  * acquirePage.
 938  * Precond: initialized.
 939  */
 940 storeError OStorePageBIOS::acquirePage (
 941     const OStorePageDescriptor& rDescr, storeAccessMode eMode)
 942 {
 943     // Acquire exclusive access.
 944     osl::MutexGuard aGuard (m_aMutex);
 945
 946     // Check precond.
 947     if (!m_xLockBytes.is())
 948         return store_E_InvalidAccess;
 949
 950     // Check access mode.
 951     if (!(m_bWriteable || (eMode == store_AccessReadOnly)))
 952         return store_E_AccessViolation;
 953
 954     // Find access control list entry.
 955     Ace * ace = Ace::find (&m_ace_head, rDescr.m_nAddr);
 956     if (ace->m_addr == rDescr.m_nAddr)
 957     {
 958       // Acquire existing entry (with ShareDenyWrite).
 959       if (eMode == store_AccessReadOnly)
 960         ace->m_used += 1;
 961       else
 962         return store_E_AccessViolation;
 963     }
 964     else
 965     {
 966       // Insert new entry.
 967       Ace * entry = AceCache::get().create (rDescr.m_nAddr, 1);
 968       if (!entry)
 969         return store_E_OutOfMemory;
 970       Ace::insert (ace, entry);
 971     }
 972
 973     // Increment total referer count and finish.
 974     m_ace_head.m_used += 1;
 975     return store_E_None;
 976 }
 977
 978 /*
 979  * releasePage.
 980  * Precond: initialized.
 981  */
 982 storeError OStorePageBIOS::releasePage (
 983     const OStorePageDescriptor& rDescr, storeAccessMode /* eMode */)
 984 {
 985     // Acquire exclusive access.
 986     osl::MutexGuard aGuard (m_aMutex);
 987
 988     // Check precond.
 989     if (!m_xLockBytes.is())
 990         return store_E_InvalidAccess;
 991
 992     // Find access control list entry.
 993     Ace * ace = Ace::find (&m_ace_head, rDescr.m_nAddr);
 994     if (ace->m_addr != rDescr.m_nAddr)
 995       return store_E_NotExists;
 996
 997     // Release existing entry.
 998     if (ace->m_used > 1)
 999       ace->m_used -= 1;
1000     else
1001       AceCache::get().destroy (ace);
1002
1003     // Decrement total referer count and finish.
1004     m_ace_head.m_used -= 1;
1005     return store_E_None;
1006 }
1007
1008 /*
1009  * getRefererCount.
1010  * Precond: none.
1011  */
1012 sal_uInt32 OStorePageBIOS::getRefererCount (void)
1013 {
1014     // Acquire exclusive access.
1015     osl::MutexGuard aGuard (m_aMutex);
1016
1017     // Obtain total referer count.
1018     return m_ace_head.m_used;
1019 }
1020
1021 /*
1022  * allocate.
1023  * Precond: initialized, writeable.
1024  */
1025 storeError OStorePageBIOS::allocate (
1026     OStorePageObject& rPage, Allocation eAlloc)
1027 {
1028     // Acquire exclusive access.
1029     osl::MutexGuard aGuard (m_aMutex);
1030
1031     // Check precond.
1032     if (!m_xLockBytes.is())
1033         return store_E_InvalidAccess;
1034     if (!m_bWriteable)
1035         return store_E_AccessViolation;
1036
1037     // Acquire SuperBlock Lock.
1038     storeError eErrCode = acquireLock (0, SuperPage::theSize);
1039     if (eErrCode != store_E_None)
1040         return eErrCode;
1041
1042     // Load SuperBlock and require good health.
1043     eErrCode = verify (m_pSuper);
1044     if (eErrCode != store_E_None)
1045     {
1046         releaseLock (0, SuperPage::theSize);
1047         return eErrCode;
1048     }
1049
1050     // Check allocation.
1051     if (eAlloc != ALLOCATE_EOF)
1052     {
1053         // Check FreeList.
1054         OStorePageLink aListHead (m_pSuper->m_aSuperTwo.unusedHead());
1055         if (aListHead.location())
1056         {
1057             // Allocate from FreeList.
1058             OStorePageData aPageHead (OStorePageData::theSize);
1059             aPageHead.location (aListHead.location());
1060
1061             // Load PageHead.
1062             eErrCode = peek (aPageHead);
1063             if (eErrCode != store_E_None)
1064             {
1065                 releaseLock (0, SuperPage::theSize);
1066                 return eErrCode;
1067             }
1068
1069             // Verify FreeList head.
1070             OSL_PRECOND(
1071                 aPageHead.m_aUnused.m_nAddr != STORE_PAGE_NULL,
1072                 "OStorePageBIOS::allocate(): page not free");
1073             if (aPageHead.m_aUnused.location() == STORE_PAGE_NULL)
1074             {
1075                 // Recovery: Reset FreeList.
1076                 m_pSuper->m_aSuperTwo.unusedReset();
1077                 m_pSuper->m_aSuperOne = m_pSuper->m_aSuperTwo;
1078
1079                 // Save SuperBlock page.
1080                 eErrCode = m_pSuper->save (*this);
1081
1082                 // Release SuperBlock Lock.
1083                 releaseLock (0, SuperPage::theSize);
1084
1085                 // Recovery: Allocate from EOF.
1086                 if (eErrCode == store_E_None)
1087                     return allocate (rPage, ALLOCATE_EOF);
1088                 else
1089                     return store_E_Unknown;
1090             }
1091
1092             // Pop from FreeList.
1093             aListHead = aPageHead.m_aUnused.location();
1094             rPage.get()->m_aUnused = STORE_PAGE_NULL;
1095
1096             // Save page at PageHead location.
1097             eErrCode = saveObjectAt_Impl (rPage, aPageHead.location());
1098             if (eErrCode != store_E_None)
1099             {
1100                 releaseLock (0, SuperPage::theSize);
1101                 return eErrCode;
1102             }
1103
1104             // Save SuperBlock page.
1105             m_pSuper->m_aSuperTwo.unusedRemove (aListHead);
1106             m_pSuper->m_aSuperOne = m_pSuper->m_aSuperTwo;
1107
1108             eErrCode = m_pSuper->save (*this);
1109             OSL_POSTCOND(
1110                 eErrCode == store_E_None,
1111                 "OStorePageBIOS::allocate(): SuperBlock save failed");
1112
1113             // Release SuperBlock Lock and finish.
1114             return releaseLock (0, SuperPage::theSize);
1115         }
1116     }
1117
1118     // Allocate from logical EOF. Determine physical EOF.
1119     sal_uInt32 nPhysLen = STORE_PAGE_NULL;
1120     eErrCode = m_xLockBytes->getSize (nPhysLen);
1121     if (eErrCode != store_E_None)
1122     {
1123         releaseLock (0, SuperPage::theSize);
1124         return eErrCode;
1125     }
1126
1127     // Obtain logical EOF.
1128     OStorePageDescriptor aDescr (m_pSuper->m_aSuperTwo.m_aDescr);
1129     sal_uInt32 nLogLen = store::ntohl(aDescr.m_nAddr);
1130     if (nLogLen == 0)
1131         nLogLen = nPhysLen; /* backward compatibility */
1132
1133     if (!(nLogLen < nPhysLen))
1134     {
1135         // Check modified state.
1136         if (!m_bModified)
1137         {
1138             // Mark modified.
1139             m_bModified = sal_True;
1140
1141             // Mark SuperBlock modified.
1142             eErrCode = m_pSuper->modified (*this);
1143             if (eErrCode != store_E_None)
1144             {
1145                 releaseLock (0, SuperPage::theSize);
1146                 return eErrCode;
1147             }
1148         }
1149
1150         // Resize.
1151         sal_uInt32 nAlign = SAL_MIN (nPhysLen, STORE_MAXIMUM_PAGESIZE);
1152         nPhysLen = ((nPhysLen + nAlign) / nAlign) * nAlign;
1153
1154         eErrCode = m_xLockBytes->setSize (nPhysLen);
1155         if (eErrCode != store_E_None)
1156         {
1157             releaseLock (0, SuperPage::theSize);
1158             return eErrCode;
1159         }
1160     }
1161
1162     // Save page at logical EOF.
1163     eErrCode = saveObjectAt_Impl (rPage, nLogLen);
1164     if (eErrCode != store_E_None)
1165     {
1166         releaseLock (0, SuperPage::theSize);
1167         return eErrCode;
1168     }
1169
1170     // Save SuperBlock page.
1171     nLogLen += store::ntohs(aDescr.m_nSize);
1172     aDescr.m_nAddr = store::htonl(nLogLen);
1173
1174     m_pSuper->m_aSuperTwo.m_aDescr = aDescr;
1175     m_pSuper->m_aSuperOne = m_pSuper->m_aSuperTwo;
1176
1177     eErrCode = m_pSuper->save (*this);
1178     OSL_POSTCOND(
1179         eErrCode == store_E_None,
1180         "OStorePageBIOS::allocate(): SuperBlock save failed");
1181
1182     // Release SuperBlock Lock and finish.
1183     return releaseLock (0, SuperPage::theSize);
1184 }
1185
1186 /*
1187  * free.
1188  * Precond: initialized, writeable.
1189  */
1190 storeError OStorePageBIOS::free (OStorePageData & /* rData */, sal_uInt32 nAddr)
1191 {
1192     // Acquire exclusive access.
1193     osl::MutexGuard aGuard (m_aMutex);
1194
1195     // Check precond.
1196     if (!m_xLockBytes.is())
1197         return store_E_InvalidAccess;
1198     if (!m_bWriteable)
1199         return store_E_AccessViolation;
1200
1201     // Acquire SuperBlock Lock.
1202     storeError eErrCode = acquireLock (0, SuperPage::theSize);
1203     if (eErrCode != store_E_None)
1204         return eErrCode;
1205
1206     // Load SuperBlock and require good health.
1207     eErrCode = verify (m_pSuper);
1208     if (eErrCode != store_E_None)
1209     {
1210         releaseLock (0, SuperPage::theSize);
1211         return eErrCode;
1212     }
1213
1214     // Load PageHead.
1215     OStorePageData aPageHead(OStorePageData::theSize);
1216     aPageHead.location (nAddr);
1217
1218     eErrCode = peek (aPageHead);
1219     if (eErrCode != store_E_None)
1220     {
1221         releaseLock (0, SuperPage::theSize);
1222         return eErrCode;
1223     }
1224
1225     // Invalidate cache.
1226     (void) m_xCache->removePageAt (nAddr);
1227
1228     // Push onto FreeList.
1229     OStorePageLink aListHead (m_pSuper->m_aSuperTwo.unusedHead());
1230
1231     aPageHead.m_aUnused.m_nAddr = aListHead.m_nAddr;
1232     aListHead.m_nAddr = aPageHead.m_aDescr.m_nAddr;
1233
1234     // Save PageHead.
1235     eErrCode = poke (aPageHead);
1236     if (eErrCode != store_E_None)
1237     {
1238         releaseLock (0, SuperPage::theSize);
1239         return eErrCode;
1240     }
1241
1242     // Save SuperBlock page.
1243     m_pSuper->m_aSuperTwo.unusedInsert (aListHead);
1244     m_pSuper->m_aSuperOne = m_pSuper->m_aSuperTwo;
1245
1246     eErrCode = m_pSuper->save (*this);
1247     OSL_POSTCOND(
1248         eErrCode == store_E_None,
1249         "OStorePageBIOS::free(): SuperBlock save failed");
1250
1251     // Release SuperBlock Lock and finish.
1252     return releaseLock (0, SuperPage::theSize);
1253 }
1254
1255 /*
1256  * loadObjectAt.
1257  * Precond: initialized, readable.
1258  */
1259 storeError OStorePageBIOS::loadObjectAt (OStorePageObject & rPage, sal_uInt32 nAddr)
1260 {
1261     // Acquire exclusive access.
1262     osl::MutexGuard aGuard (m_aMutex);
1263
1264     // Check precond.
1265     if (!m_xLockBytes.is())
1266         return store_E_InvalidAccess;
1267
1268     return loadObjectAt_Impl (rPage, nAddr);
1269 }
1270
1271 /*
1272  * loadObjectAt_Impl.
1273  * Internal: Precond: initialized, readable, exclusive access.
1274  */
1275 storeError OStorePageBIOS::loadObjectAt_Impl (OStorePageObject & rPage, sal_uInt32 nAddr)
1276 {
1277     storeError eErrCode = m_xCache->lookupPageAt (rPage.get(), nAddr);
1278     if (eErrCode != store_E_NotExists)
1279         return eErrCode;
1280
1281     // Read page.
1282     eErrCode = m_xLockBytes->readPageAt (rPage.get(), nAddr);
1283     if (eErrCode != store_E_None)
1284         return eErrCode;
1285
1286     // Verify page.
1287     eErrCode = rPage.verify (nAddr);
1288     if (eErrCode != store_E_None)
1289         return eErrCode;
1290
1291     // Mark page as clean.
1292     rPage.clean();
1293
1294     // Cache page.
1295     return m_xCache->insertPageAt (rPage.get(), nAddr);
1296 }
1297
1298 /*
1299  * saveObjectAt.
1300  * Precond: initialized, writeable.
1301  */
1302 storeError OStorePageBIOS::saveObjectAt (OStorePageObject & rPage, sal_uInt32 nAddr)
1303 {
1304     // Acquire exclusive access.
1305     osl::MutexGuard aGuard (m_aMutex);
1306
1307     // Check precond.
1308     if (!m_xLockBytes.is())
1309         return store_E_InvalidAccess;
1310     if (!m_bWriteable)
1311         return store_E_AccessViolation;
1312
1313     // Save Page.
1314     return saveObjectAt_Impl (rPage, nAddr);
1315 }
1316
1317 /*
1318  * saveObjectAt_Impl.
1319  * Internal: Precond: initialized, writeable, exclusive access.
1320  */
1321 storeError OStorePageBIOS::saveObjectAt_Impl (OStorePageObject & rPage, sal_uInt32 nAddr)
1322 {
1323     // Guard page (incl. set location).
1324     storeError eErrCode = rPage.guard (nAddr);
1325     if (eErrCode != store_E_None)
1326         return eErrCode;
1327
1328     // Write page.
1329     eErrCode = m_xLockBytes->writePageAt(rPage.get(), nAddr);
1330     if (eErrCode != store_E_None)
1331         return eErrCode;
1332
1333     // Mark page as clean.
1334     rPage.clean();
1335
1336     // Cache page.
1337     return m_xCache->updatePageAt (rPage.get(), nAddr);
1338 }
1339
1340 /*
1341  * close.
1342  * Precond: none.
1343  */
1344 storeError OStorePageBIOS::close (void)
1345 {
1346     // Acquire exclusive access.
1347     osl::MutexGuard aGuard (m_aMutex);
1348
1349     // Check referer count.
1350     if (m_ace_head.m_used > 0)
1351     {
1352         // Report remaining referer count.
1353         OSL_TRACE("store::PageBIOS::close(): referer count: %d\n", m_ace_head.m_used);
1354 #if 1  /* NEW */
1355         for (Ace * ace = m_ace_head.m_next; ace != &m_ace_head; ace = m_ace_head.m_next)
1356         {
1357             m_ace_head.m_used -= ace->m_used;
1358             AceCache::get().destroy (ace);
1359         }
1360         OSL_ENSURE(m_ace_head.m_used == 0, "store::PageBIOS::close(): logic error");
1361 #endif /* NEW */
1362     }
1363
1364     // Check SuperBlock page.
1365     storeError eErrCode = store_E_None;
1366     if (m_pSuper)
1367     {
1368         // Release SuperBlock page.
1369         eErrCode = m_pSuper->close (*this);
1370         delete m_pSuper, m_pSuper = 0;
1371     }
1372
1373     // Release PageCache.
1374     m_xCache.clear();
1375
1376     // Check LockBytes.
1377     if (m_xLockBytes.is())
1378     {
1379 #ifdef STORE_FEATURE_COMMIT
1380         // Commit.
1381         storeError result = m_xLockBytes->flush();
1382         if (eErrCode == store_E_None)
1383         {
1384             // Previous result(s) okay. Propagate next result.
1385             eErrCode = result;
1386         }
1387 #endif /* STORE_FEATURE_COMMIT */
1388
1389         // Release LockBytes.
1390         m_xLockBytes.clear();
1391     }
1392
1393     // Done.
1394     return eErrCode;
1395 }
1396
1397 /*
1398  * flush.
1399  * Precond: initialized.
1400  */
1401 storeError OStorePageBIOS::flush (void)
1402 {
1403     // Acquire exclusive access.
1404     osl::MutexGuard aGuard (m_aMutex);
1405
1406     // Check precond.
1407     if (!m_xLockBytes.is())
1408         return store_E_InvalidAccess;
1409
1410     // Check mode and state.
1411     storeError eErrCode = store_E_None;
1412     if (!(m_bWriteable && m_bModified))
1413         return eErrCode;
1414
1415     // Flush SuperBlock page.
1416     eErrCode = m_pSuper->flush (*this);
1417
1418     // Flush LockBytes.
1419     storeError result = m_xLockBytes->flush();
1420     if (eErrCode == store_E_None)
1421     {
1422         // Previous result(s) okay. Propagate next result.
1423         eErrCode = result;
1424     }
1425
1426     // Adjust modified state.
1427     m_bModified = (eErrCode != store_E_None);
1428
1429     // Done.
1430     return eErrCode;
1431 }
1432
1433 /*
1434  * size.
1435  * Precond: initialized.
1436  */
1437 storeError OStorePageBIOS::size (sal_uInt32 &rnSize)
1438 {
1439     // Acquire exclusive access.
1440     osl::MutexGuard aGuard (m_aMutex);
1441
1442     // Initialize [out] param.
1443     rnSize = 0;
1444
1445     // Check precond.
1446     if (!m_xLockBytes.is())
1447         return store_E_InvalidAccess;
1448
1449     // Obtain LockBytes size.
1450     return m_xLockBytes->getSize (rnSize);
1451 }
1452
1453 /*
1454  * scanBegin.
1455  * Precond: initialized.
1456  */
1457 storeError OStorePageBIOS::scanBegin (
1458     ScanContext &rCtx, sal_uInt32 nMagic)
1459 {
1460     // Acquire exclusive access.
1461     osl::MutexGuard aGuard (m_aMutex);
1462
1463     // Initialize [out] param.
1464     rCtx.m_aDescr = OStorePageDescriptor(0, 0, 0);
1465     rCtx.m_nSize  = 0;
1466     rCtx.m_nMagic = nMagic;
1467
1468     // Check precond.
1469     if (!m_xLockBytes.is())
1470         return store_E_InvalidAccess;
1471
1472     // Check SuperBlock page.
1473     storeError eErrCode = verify (m_pSuper);
1474     if (eErrCode != store_E_None)
1475     {
1476         // Damaged. Determine page size (NYI).
1477         OSL_TRACE ("OStorePageBIOS::scanBegin(): damaged.\n");
1478         return eErrCode;
1479     }
1480
1481     // Setup Context descriptor.
1482     rCtx.m_aDescr = m_pSuper->m_aSuperOne.m_aDescr;
1483     rCtx.m_aDescr.m_nAddr = rCtx.m_aDescr.m_nSize; // @@@ ntoh @@@
1484
1485     // Setup Context size.
1486     eErrCode = size (rCtx.m_nSize);
1487     if (eErrCode != store_E_None)
1488         rCtx.m_nSize = ((sal_uInt32)(~0));
1489
1490     // Done.
1491     return store_E_None;
1492 }
1493
1494 /*
1495  * scanNext.
1496  * Precond: initialized.
1497  */
1498 storeError OStorePageBIOS::scanNext (
1499     ScanContext &rCtx, OStorePageObject &rPage)
1500 {
1501     // Acquire exclusive access.
1502     osl::MutexGuard aGuard (m_aMutex);
1503
1504     // Check precond.
1505     if (!m_xLockBytes.is())
1506         return store_E_InvalidAccess;
1507
1508     // Setup PageHead.
1509     OStorePageData aPageHead (OStorePageData::theSize);
1510
1511     // Check context.
1512     while (rCtx.isValid())
1513     {
1514         // Assign next location.
1515         aPageHead.location (rCtx.m_aDescr.m_nAddr);
1516         rCtx.m_aDescr.m_nAddr += rCtx.m_aDescr.m_nSize;
1517
1518         // Load PageHead.
1519         storeError eErrCode = peek (aPageHead);
1520         if (eErrCode != store_E_None)
1521             continue;
1522
1523         // Check PageHead Magic number.
1524         if (aPageHead.m_aGuard.m_nMagic != rCtx.m_nMagic)
1525             continue;
1526
1527         // Check PageHead Unused link.
1528         if (aPageHead.m_aUnused.m_nAddr != STORE_PAGE_NULL)
1529             continue;
1530
1531         // Load page.
1532         eErrCode = loadObjectAt_Impl (rPage, aPageHead.location());
1533         if (eErrCode != store_E_None)
1534             continue;
1535
1536         // Deliver page.
1537         return store_E_None;
1538     }
1539
1540     // Done.
1541     return store_E_CantSeek;
1542 }
1543
1544 /*
1545  * peek (PageHead).
1546  * Internal: Precond: initialized, readable, exclusive access.
1547  */
1548 storeError OStorePageBIOS::peek (OStorePageData &rData)
1549 {
1550     // Read PageHead.
1551     storeError eErrCode = read (rData.location(), &rData, OStorePageData::theSize);
1552     if (eErrCode != store_E_None)
1553         return eErrCode;
1554
1555     // Verify PageHead.
1556     return rData.verify();
1557 }
1558
1559 /*
1560  * poke (PageHead).
1561  * Internal: Precond: initialized, writeable, exclusive access.
1562  */
1563 storeError OStorePageBIOS::poke (OStorePageData &rData)
1564 {
1565     // Guard PageHead.
1566     rData.guard();
1567
1568     // Write PageHead.
1569     return write (rData.location(), &rData, OStorePageData::theSize);
1570 }