store/source/storbios.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <sal/config.h>
  21
  22 #include "storbios.hxx"
  23
  24 #include <sal/types.h>
  25 #include <sal/log.hxx>
  26
  27 #include <rtl/alloc.h>
  28 #include <rtl/ref.hxx>
  29
  30 #include <osl/diagnose.h>
  31 #include <osl/mutex.hxx>
  32
  33 #include <store/types.h>
  34 #include "lockbyte.hxx"
  35 #include "storcach.hxx"
  36
  37 using namespace store;
  38
  39 /*========================================================================
  40  *
  41  * OStoreSuperBlock.
  42  *
  43  *======================================================================*/
  44 #define STORE_MAGIC_SUPERBLOCK sal_uInt32(0x484D5343)
  45
  46 namespace {
  47
  48 struct OStoreSuperBlock
  49 {
  50     typedef OStorePageGuard      G;
  51     typedef OStorePageDescriptor D;
  52     typedef OStorePageLink       L;
  53
  54     /** Representation.
  55      */
  56     G          m_aGuard;
  57     D          m_aDescr;
  58     sal_uInt32 m_nMarked;
  59     L          m_aMarked;
  60     sal_uInt32 m_nUnused;
  61     L          m_aUnused;
  62
  63     /** theSize.
  64      */
  65     static const size_t theSize = sizeof(G) + sizeof(D) + 2 * (sizeof(L) + sizeof(sal_uInt32));
  66
  67     /** Construction.
  68      */
  69     explicit OStoreSuperBlock (sal_uInt16 nPageSize)
  70         : m_aGuard  (STORE_MAGIC_SUPERBLOCK),
  71           m_aDescr  (nPageSize, nPageSize, STORE_MINIMUM_PAGESIZE),
  72           m_nMarked (store::htonl(0)),
  73           m_aMarked (0),
  74           m_nUnused (store::htonl(0)),
  75           m_aUnused (0)
  76     {}
  77
  78     /** Comparison.
  79      */
  80     bool operator== (const OStoreSuperBlock & rhs) const
  81     {
  82         return ((m_aGuard  == rhs.m_aGuard ) &&
  83                 (m_aDescr  == rhs.m_aDescr ) &&
  84                 (m_nMarked == rhs.m_nMarked) &&
  85                 (m_aMarked == rhs.m_aMarked) &&
  86                 (m_nUnused == rhs.m_nUnused) &&
  87                 (m_aUnused == rhs.m_aUnused)    );
  88     }
  89
  90     /** unused(Count|Head|Insert|Remove|Reset).
  91      */
  92     sal_uInt32 unusedCount() const
  93     {
  94         return store::ntohl(m_nUnused);
  95     }
  96     const L& unusedHead() const
  97     {
  98         return m_aUnused;
  99     }
 100     void unusedInsert (const L& rLink)
 101     {
 102         sal_uInt32 nUnused = unusedCount();
 103         m_nUnused = store::htonl(nUnused + 1);
 104         m_aUnused = rLink;
 105     }
 106     void unusedRemove (const L& rLink)
 107     {
 108         sal_uInt32 nUnused = unusedCount();
 109         m_nUnused = store::htonl(nUnused - 1);
 110         m_aUnused = rLink;
 111     }
 112     void unusedReset()
 113     {
 114         m_nUnused = store::htonl(0);
 115         m_aUnused = L(0);
 116     }
 117
 118     /** guard (external representation).
 119      */
 120     void guard()
 121     {
 122         sal_uInt32 nCRC32 = rtl_crc32 (0, &m_aGuard.m_nMagic, sizeof(sal_uInt32));
 123         nCRC32 = rtl_crc32 (nCRC32, &m_aDescr, static_cast<sal_uInt32>(theSize - sizeof(G)));
 124         m_aGuard.m_nCRC32 = store::htonl(nCRC32);
 125     }
 126
 127     /** verify (external representation).
 128      */
 129     storeError verify() const
 130     {
 131         sal_uInt32 nMagic = store::ntohl(m_aGuard.m_nMagic);
 132         if (nMagic != STORE_MAGIC_SUPERBLOCK)
 133             return store_E_WrongFormat;
 134
 135         sal_uInt32 nCRC32 = rtl_crc32 (0, &m_aGuard.m_nMagic, sizeof(sal_uInt32));
 136         nCRC32 = rtl_crc32 (nCRC32, &m_aDescr, static_cast<sal_uInt32>(theSize - sizeof(G)));
 137         if (m_aGuard.m_nCRC32 != store::htonl(nCRC32))
 138             return store_E_InvalidChecksum;
 139         else
 140             return store_E_None;
 141     }
 142 };
 143
 144 }
 145
 146 /*========================================================================
 147  *
 148  * SuperBlockPage interface.
 149  *
 150  *======================================================================*/
 151 namespace store
 152 {
 153
 154 struct SuperBlockPage
 155 {
 156     typedef OStoreSuperBlock SuperBlock;
 157
 158     /** Representation.
 159      */
 160     SuperBlock m_aSuperOne;
 161     SuperBlock m_aSuperTwo;
 162
 163     /** theSize.
 164      */
 165     static const size_t     theSize     = 2 * SuperBlock::theSize;
 166     static const sal_uInt16 thePageSize = theSize;
 167     static_assert(STORE_MINIMUM_PAGESIZE >= thePageSize, "must be at least thePageSize");
 168
 169     /** Allocation.
 170      */
 171     static void * operator new (size_t n)
 172     {
 173         return std::malloc(sal::static_int_cast<sal_Size>(n));
 174     }
 175     static void operator delete (void * p)
 176     {
 177         std::free (p);
 178     }
 179
 180     static void * operator new (SAL_UNUSED_PARAMETER size_t, sal_uInt16 nPageSize)
 181     {
 182         return rtl_allocateZeroMemory (sal::static_int_cast<sal_Size>(nPageSize));
 183     }
 184     static void operator delete (void * p, SAL_UNUSED_PARAMETER sal_uInt16)
 185     {
 186         std::free (p);
 187     }
 188
 189     /** Construction.
 190      */
 191     explicit SuperBlockPage (sal_uInt16 nPageSize = thePageSize)
 192         : m_aSuperOne(nPageSize),
 193           m_aSuperTwo(nPageSize)
 194     {}
 195
 196     /** save.
 197      */
 198     storeError save (OStorePageBIOS const & rBIOS, sal_uInt32 nSize = theSize)
 199     {
 200         m_aSuperOne.guard();
 201         m_aSuperTwo = m_aSuperOne;
 202         return rBIOS.write (0, this, nSize);
 203     }
 204
 205     /** Page allocation.
 206      */
 207     storeError unusedHead (
 208         OStorePageBIOS const & rBIOS,
 209         PageData &       rPageHead);
 210
 211     storeError unusedPop (
 212         OStorePageBIOS const & rBIOS,
 213         PageData const & rPageHead);
 214
 215     storeError unusedPush (
 216         OStorePageBIOS const & rBIOS,
 217         sal_uInt32       nAddr);
 218
 219     /** verify (with repair).
 220      */
 221     storeError verify (OStorePageBIOS const & rBIOS);
 222 };
 223
 224 } // namespace store
 225
 226 /*========================================================================
 227  *
 228  * SuperBlockPage implementation.
 229  *
 230  *======================================================================*/
 231 /*
 232  * unusedHead(): get freelist head (alloc page, step 1).
 233  */
 234 storeError SuperBlockPage::unusedHead (OStorePageBIOS const & rBIOS, PageData & rPageHead)
 235 {
 236     storeError eErrCode = verify (rBIOS);
 237     if (eErrCode != store_E_None)
 238         return eErrCode;
 239
 240     // Check freelist head.
 241     OStorePageLink const aListHead (m_aSuperOne.unusedHead());
 242     if (aListHead.location() == 0)
 243     {
 244         // Freelist empty, see SuperBlock::ctor().
 245         rPageHead.location (STORE_PAGE_NULL);
 246         return store_E_None;
 247     }
 248
 249     // Load PageHead.
 250     eErrCode = rBIOS.read (aListHead.location(), &rPageHead, PageData::theSize);
 251     if (eErrCode != store_E_None)
 252         return eErrCode;
 253
 254     eErrCode = rPageHead.verify (aListHead.location());
 255     if (eErrCode != store_E_None)
 256         return eErrCode;
 257
 258     // Verify page is unused.
 259     sal_uInt32 const nAddr = rPageHead.m_aUnused.location();
 260     if (nAddr == STORE_PAGE_NULL)
 261     {
 262         SAL_WARN("store", "store::SuperBlock::unusedHead(): page not free");
 263
 264         // Page in use.
 265         rPageHead.location (STORE_PAGE_NULL);
 266
 267         // Recovery: Reset freelist to empty.
 268         m_aSuperOne.unusedReset();
 269         eErrCode = save (rBIOS);
 270     }
 271     return eErrCode;
 272 }
 273
 274 /*
 275  * unusedPop(): pop freelist head (alloc page, step 2).
 276  */
 277 storeError SuperBlockPage::unusedPop (OStorePageBIOS const & rBIOS, PageData const & rPageHead)
 278 {
 279     sal_uInt32 const nAddr = rPageHead.m_aUnused.location();
 280     OSL_PRECOND(nAddr != STORE_PAGE_NULL, "store::SuperBlock::unusedPop(): page not free");
 281     if (nAddr == STORE_PAGE_NULL)
 282         return store_E_CantSeek;
 283
 284     // Pop from FreeList.
 285     OStorePageLink const aListHead (nAddr);
 286     m_aSuperOne.unusedRemove (aListHead);
 287     return save (rBIOS);
 288 }
 289
 290 /*
 291  * unusedPush(): push new freelist head.
 292  */
 293 storeError SuperBlockPage::unusedPush (OStorePageBIOS const & rBIOS, sal_uInt32 nAddr)
 294 {
 295     storeError eErrCode = verify (rBIOS);
 296     if (eErrCode != store_E_None)
 297         return eErrCode;
 298
 299     PageData aPageHead;
 300     eErrCode = rBIOS.read (nAddr, &aPageHead, PageData::theSize);
 301     if (eErrCode != store_E_None)
 302         return eErrCode;
 303
 304     eErrCode = aPageHead.verify (nAddr);
 305     if (eErrCode != store_E_None)
 306         return eErrCode;
 307
 308     aPageHead.m_aUnused = m_aSuperOne.unusedHead();
 309     aPageHead.guard (nAddr);
 310
 311     eErrCode = rBIOS.write (nAddr, &aPageHead, PageData::theSize);
 312     if (eErrCode != store_E_None)
 313         return eErrCode;
 314
 315     OStorePageLink const aListHead (nAddr);
 316     m_aSuperOne.unusedInsert(aListHead);
 317     return save (rBIOS);
 318 }
 319
 320 /*
 321  * verify (with repair).
 322  */
 323 storeError SuperBlockPage::verify (OStorePageBIOS const & rBIOS)
 324 {
 325     // Verify 1st copy.
 326     storeError eErrCode = m_aSuperOne.verify();
 327     if (eErrCode == store_E_None)
 328     {
 329         // Ok. Verify 2nd copy.
 330         eErrCode = m_aSuperTwo.verify();
 331         if (eErrCode == store_E_None)
 332         {
 333             // Ok. Ensure identical copies (1st copy wins).
 334             if (!(m_aSuperOne == m_aSuperTwo))
 335             {
 336                 // Different. Replace 2nd copy with 1st copy.
 337                 m_aSuperTwo = m_aSuperOne;
 338
 339                 // Write back.
 340                 if (rBIOS.isWriteable())
 341                     eErrCode = rBIOS.write (0, this, theSize);
 342                 else
 343                     eErrCode = store_E_None;
 344             }
 345         }
 346         else
 347         {
 348             // Failure. Replace 2nd copy with 1st copy.
 349             m_aSuperTwo = m_aSuperOne;
 350
 351             // Write back.
 352             if (rBIOS.isWriteable())
 353                 eErrCode = rBIOS.write (0, this, theSize);
 354             else
 355                 eErrCode = store_E_None;
 356         }
 357     }
 358     else
 359     {
 360         // Failure. Verify 2nd copy.
 361         eErrCode = m_aSuperTwo.verify();
 362         if (eErrCode == store_E_None)
 363         {
 364             // Ok. Replace 1st copy with 2nd copy.
 365             m_aSuperOne = m_aSuperTwo;
 366
 367             // Write back.
 368             if (rBIOS.isWriteable())
 369                 eErrCode = rBIOS.write (0, this, theSize);
 370             else
 371                 eErrCode = store_E_None;
 372         }
 373         else
 374         {
 375             // Double Failure.
 376             SAL_WARN("store", "OStoreSuperBlockPage::verify(): double failure.");
 377         }
 378     }
 379
 380     // Done.
 381     return eErrCode;
 382 }
 383
 384 /*========================================================================
 385  *
 386  * OStorePageBIOS::Ace implementation.
 387  *
 388  *======================================================================*/
 389 OStorePageBIOS::Ace::Ace()
 390   : m_next (this), m_prev (this), m_addr (STORE_PAGE_NULL), m_used (0)
 391 {}
 392
 393 OStorePageBIOS::Ace::~Ace()
 394 {
 395   m_next->m_prev = m_prev;
 396   m_prev->m_next = m_next;
 397 }
 398
 399 int
 400 SAL_CALL OStorePageBIOS::Ace::constructor (
 401     void * obj, SAL_UNUSED_PARAMETER void * /* arg */)
 402 {
 403   Ace * ace = static_cast<Ace*>(obj);
 404   ace->m_next = ace->m_prev = ace;
 405   return 1;
 406 }
 407
 408 OStorePageBIOS::Ace *
 409 OStorePageBIOS::Ace::find (OStorePageBIOS::Ace * head, sal_uInt32 addr)
 410 {
 411   OStorePageBIOS::Ace * entry;
 412   for (entry = head->m_next; entry != head; entry = entry->m_next)
 413   {
 414     if (entry->m_addr >= addr)
 415       return entry;
 416   }
 417   return head;
 418 }
 419
 420 void
 421 OStorePageBIOS::Ace::insert (OStorePageBIOS::Ace * head, OStorePageBIOS::Ace * entry)
 422 {
 423   // insert entry at queue tail (before head).
 424   entry->m_next = head;
 425   entry->m_prev = head->m_prev;
 426   head->m_prev = entry;
 427   entry->m_prev->m_next = entry;
 428 }
 429
 430 /*========================================================================
 431  *
 432  * OStorePageBIOS::AceCache interface.
 433  *
 434  *======================================================================*/
 435 namespace store
 436 {
 437
 438 class OStorePageBIOS::AceCache
 439 {
 440   rtl_cache_type * m_ace_cache;
 441
 442 public:
 443   static AceCache & get();
 444
 445   OStorePageBIOS::Ace *
 446   create (sal_uInt32 addr);
 447
 448   void
 449   destroy (OStorePageBIOS::Ace * ace);
 450
 451 protected:
 452   AceCache();
 453   ~AceCache();
 454 };
 455
 456 } // namespace store
 457
 458 /*========================================================================
 459  *
 460  * OStorePageBIOS::AceCache implementation.
 461  *
 462  *======================================================================*/
 463
 464 OStorePageBIOS::AceCache &
 465 OStorePageBIOS::AceCache::get()
 466 {
 467   static AceCache g_ace_cache;
 468   return g_ace_cache;
 469 }
 470
 471 OStorePageBIOS::AceCache::AceCache()
 472 {
 473   m_ace_cache = rtl_cache_create (
 474     "store_ace_cache",
 475     sizeof (OStorePageBIOS::Ace),
 476     0, // objalign
 477     OStorePageBIOS::Ace::constructor,
 478     nullptr, // destructor,
 479     nullptr, // reclaim,
 480     nullptr, // userarg,
 481     nullptr, // default source,
 482     0  // flags
 483     );
 484 }
 485
 486 OStorePageBIOS::AceCache::~AceCache()
 487 {
 488   rtl_cache_destroy (m_ace_cache);
 489   m_ace_cache = nullptr;
 490 }
 491
 492 OStorePageBIOS::Ace *
 493 OStorePageBIOS::AceCache::create (sal_uInt32 addr)
 494 {
 495   Ace * ace = static_cast<Ace*>(rtl_cache_alloc (m_ace_cache));
 496   if (ace != nullptr)
 497   {
 498     // verify invariant state.
 499     OSL_ASSERT((ace->m_next == ace) && (ace->m_prev == ace));
 500
 501     // initialize.
 502     ace->m_addr = addr;
 503     ace->m_used = 1;
 504   }
 505   return ace;
 506 }
 507
 508 void
 509 OStorePageBIOS::AceCache::destroy (OStorePageBIOS::Ace * ace)
 510 {
 511   if (ace != nullptr)
 512   {
 513     // remove from queue (if any).
 514     ace->m_next->m_prev = ace->m_prev;
 515     ace->m_prev->m_next = ace->m_next;
 516
 517     // restore invariant state.
 518     ace->m_next = ace->m_prev = ace;
 519
 520     // return to cache.
 521     rtl_cache_free (m_ace_cache, ace);
 522   }
 523 }
 524
 525 /*========================================================================
 526  *
 527  * OStorePageBIOS implementation.
 528  *
 529  *======================================================================*/
 530 /*
 531  * OStorePageBIOS.
 532  */
 533 OStorePageBIOS::OStorePageBIOS()
 534     : m_bWriteable (false)
 535 {
 536 }
 537
 538 /*
 539  * ~OStorePageBIOS.
 540  */
 541 OStorePageBIOS::~OStorePageBIOS()
 542 {
 543     cleanup_Impl();
 544 }
 545
 546 /*
 547  * initialize.
 548  * Precond: none.
 549  */
 550 storeError OStorePageBIOS::initialize (
 551     ILockBytes *    pLockBytes,
 552     storeAccessMode eAccessMode,
 553     sal_uInt16 &    rnPageSize)
 554 {
 555     // Acquire exclusive access.
 556     osl::MutexGuard aGuard (m_aMutex);
 557
 558     // Initialize.
 559     storeError eErrCode = initialize_Impl (pLockBytes, eAccessMode, rnPageSize);
 560     if (eErrCode != store_E_None)
 561     {
 562         // Cleanup.
 563         cleanup_Impl();
 564     }
 565     return eErrCode;
 566 }
 567
 568 /*
 569  * initialize_Impl.
 570  * Internal: Precond: exclusive access.
 571  */
 572 storeError OStorePageBIOS::initialize_Impl (
 573     ILockBytes *    pLockBytes,
 574     storeAccessMode eAccessMode,
 575     sal_uInt16 &    rnPageSize)
 576 {
 577     // Cleanup.
 578     cleanup_Impl();
 579
 580     // Initialize.
 581     m_xLockBytes = pLockBytes;
 582     if (!m_xLockBytes.is())
 583         return store_E_InvalidParameter;
 584     m_bWriteable = (eAccessMode != storeAccessMode::ReadOnly);
 585
 586     // Check access mode.
 587     storeError eErrCode = store_E_None;
 588     if (eAccessMode != storeAccessMode::Create)
 589     {
 590         // Load SuperBlock page.
 591         m_pSuper.reset(new SuperBlockPage());
 592
 593         eErrCode = read (0, m_pSuper.get(), SuperBlockPage::theSize);
 594         if (eErrCode == store_E_None)
 595         {
 596             // Verify SuperBlock page (with repair).
 597             eErrCode = m_pSuper->verify (*this);
 598         }
 599     }
 600     else
 601     {
 602         // Truncate to zero length.
 603         eErrCode = m_xLockBytes->setSize(0);
 604         if (eErrCode != store_E_None)
 605             return eErrCode;
 606
 607         // Mark as not existing.
 608         eErrCode = store_E_NotExists;
 609     }
 610
 611     if (eErrCode != store_E_None)
 612     {
 613         // Check reason.
 614         if (eErrCode != store_E_NotExists)
 615             return eErrCode;
 616
 617         // Check mode.
 618         if (eAccessMode == storeAccessMode::ReadOnly)
 619             return store_E_NotExists;
 620         if (eAccessMode == storeAccessMode::ReadWrite)
 621             return store_E_NotExists;
 622
 623         // Check PageSize.
 624         if ((STORE_MINIMUM_PAGESIZE > rnPageSize) || (rnPageSize > STORE_MAXIMUM_PAGESIZE))
 625             return store_E_InvalidParameter;
 626         rnPageSize = ((rnPageSize + STORE_MINIMUM_PAGESIZE - 1) & ~(STORE_MINIMUM_PAGESIZE - 1));
 627
 628         // Create initial page (w/ SuperBlock).
 629         m_pSuper.reset(new(rnPageSize) SuperBlockPage(rnPageSize));
 630         eErrCode = m_pSuper->save (*this, rnPageSize);
 631     }
 632     if (eErrCode == store_E_None)
 633     {
 634         // Obtain page size.
 635         rnPageSize = store::ntohs(m_pSuper->m_aSuperOne.m_aDescr.m_nSize);
 636
 637         // Create page allocator.
 638         eErrCode = m_xLockBytes->initialize (m_xAllocator, rnPageSize);
 639         if (eErrCode != store_E_None)
 640             return eErrCode;
 641
 642         // Create page cache.
 643         eErrCode = PageCache_createInstance (m_xCache, rnPageSize);
 644     }
 645     return eErrCode;
 646 }
 647
 648 /*
 649  * cleanup_Impl.
 650  * Internal: Precond: exclusive access.
 651  */
 652 void OStorePageBIOS::cleanup_Impl()
 653 {
 654     // Check referer count.
 655     if (m_ace_head.m_used > 0)
 656     {
 657         // Report remaining referer count.
 658         SAL_INFO("store", "referer count: " << m_ace_head.m_used);
 659         for (Ace * ace = m_ace_head.m_next; ace != &m_ace_head; ace = m_ace_head.m_next)
 660         {
 661             m_ace_head.m_used -= ace->m_used;
 662             AceCache::get().destroy (ace);
 663         }
 664         OSL_ENSURE(m_ace_head.m_used == 0, "store::PageBIOS::cleanup_Impl(): logic error");
 665     }
 666
 667     // Release SuperBlock page.
 668     m_pSuper.reset();
 669
 670     // Release PageCache.
 671     m_xCache.clear();
 672
 673     // Release PageAllocator.
 674     m_xAllocator.clear();
 675
 676     // Release LockBytes.
 677     m_xLockBytes.clear();
 678 }
 679
 680 /*
 681  * read.
 682  * Low Level: Precond: initialized, exclusive access.
 683  */
 684 storeError OStorePageBIOS::read (
 685     sal_uInt32 nAddr, void *pData, sal_uInt32 nSize) const
 686 {
 687     // Check precond.
 688     if (!m_xLockBytes.is())
 689         return store_E_InvalidAccess;
 690
 691     // Read Data.
 692     return m_xLockBytes->readAt (nAddr, pData, nSize);
 693 }
 694
 695 /*
 696  * write.
 697  * Low Level: Precond: initialized, writeable, exclusive access.
 698  */
 699 storeError OStorePageBIOS::write (
 700     sal_uInt32 nAddr, const void *pData, sal_uInt32 nSize) const
 701 {
 702     // Check precond.
 703     if (!m_xLockBytes.is())
 704         return store_E_InvalidAccess;
 705     if (!m_bWriteable)
 706         return store_E_AccessViolation;
 707
 708     // Write Data.
 709     return m_xLockBytes->writeAt (nAddr, pData, nSize);
 710 }
 711
 712 /*
 713  * acquirePage.
 714  * Precond: initialized.
 715  */
 716 storeError OStorePageBIOS::acquirePage (
 717     const OStorePageDescriptor& rDescr, storeAccessMode eMode)
 718 {
 719     // Acquire exclusive access.
 720     osl::MutexGuard aGuard (m_aMutex);
 721
 722     // Check precond.
 723     if (!m_xLockBytes.is())
 724         return store_E_InvalidAccess;
 725
 726     // Check access mode.
 727     if (!(m_bWriteable || (eMode == storeAccessMode::ReadOnly)))
 728         return store_E_AccessViolation;
 729
 730     // Find access control list entry.
 731     Ace * ace = Ace::find (&m_ace_head, rDescr.m_nAddr);
 732     if (ace->m_addr == rDescr.m_nAddr)
 733     {
 734       // Acquire existing entry (with ShareDenyWrite).
 735       if (eMode == storeAccessMode::ReadOnly)
 736         ace->m_used += 1;
 737       else
 738         return store_E_AccessViolation;
 739     }
 740     else
 741     {
 742       // Insert new entry.
 743       Ace * entry = AceCache::get().create (rDescr.m_nAddr);
 744       if (!entry)
 745         return store_E_OutOfMemory;
 746       Ace::insert (ace, entry);
 747     }
 748
 749     // Increment total referer count and finish.
 750     m_ace_head.m_used += 1;
 751     return store_E_None;
 752 }
 753
 754 /*
 755  * releasePage.
 756  * Precond: initialized.
 757  */
 758 storeError OStorePageBIOS::releasePage (const OStorePageDescriptor& rDescr)
 759 {
 760     // Acquire exclusive access.
 761     osl::MutexGuard aGuard (m_aMutex);
 762
 763     // Check precond.
 764     if (!m_xLockBytes.is())
 765         return store_E_InvalidAccess;
 766
 767     // Find access control list entry.
 768     Ace * ace = Ace::find (&m_ace_head, rDescr.m_nAddr);
 769     if (ace->m_addr != rDescr.m_nAddr)
 770       return store_E_NotExists;
 771
 772     // Release existing entry.
 773     if (ace->m_used > 1)
 774       ace->m_used -= 1;
 775     else
 776       AceCache::get().destroy (ace);
 777
 778     // Decrement total referer count and finish.
 779     m_ace_head.m_used -= 1;
 780     return store_E_None;
 781 }
 782
 783 /*
 784  * allocate.
 785  * Precond: initialized, writeable.
 786  */
 787 storeError OStorePageBIOS::allocate (
 788     OStorePageObject& rPage)
 789 {
 790     // Acquire exclusive access.
 791     osl::MutexGuard aGuard (m_aMutex);
 792
 793     // Check precond.
 794     if (!m_xLockBytes.is())
 795         return store_E_InvalidAccess;
 796     if (!m_bWriteable)
 797         return store_E_AccessViolation;
 798
 799     // Check allocation type.
 800     storeError eErrCode = store_E_None;
 801     // Try freelist head.
 802     PageData aPageHead;
 803     eErrCode = m_pSuper->unusedHead (*this, aPageHead);
 804     if (eErrCode != store_E_None)
 805         return eErrCode;
 806
 807     sal_uInt32 const nAddr = aPageHead.location();
 808     if (nAddr != STORE_PAGE_NULL)
 809     {
 810         // Save page.
 811         eErrCode = saveObjectAt_Impl (rPage, nAddr);
 812         if (eErrCode != store_E_None)
 813             return eErrCode;
 814
 815         // Pop freelist head and finish.
 816         return m_pSuper->unusedPop (*this, aPageHead);
 817     }
 818
 819     // Allocate from EOF. Determine current size.
 820     sal_uInt32 nSize = STORE_PAGE_NULL;
 821     eErrCode = m_xLockBytes->getSize (nSize);
 822     if (eErrCode != store_E_None)
 823         return eErrCode;
 824
 825     // Save page at current EOF.
 826     return saveObjectAt_Impl (rPage, nSize);
 827 }
 828
 829 /*
 830  * free.
 831  * Precond: initialized, writeable.
 832  */
 833 storeError OStorePageBIOS::free (sal_uInt32 nAddr)
 834 {
 835     // Acquire exclusive access.
 836     osl::MutexGuard aGuard (m_aMutex);
 837
 838     // Check precond.
 839     if (!m_xLockBytes.is())
 840         return store_E_InvalidAccess;
 841     if (!m_bWriteable)
 842         return store_E_AccessViolation;
 843
 844     // Invalidate cache.
 845     (void) m_xCache->removePageAt (nAddr);
 846
 847     // Push onto freelist.
 848     return m_pSuper->unusedPush (*this, nAddr);
 849 }
 850
 851 /*
 852  * loadObjectAt.
 853  * Precond: initialized, readable.
 854  */
 855 storeError OStorePageBIOS::loadObjectAt (OStorePageObject & rPage, sal_uInt32 nAddr)
 856 {
 857     // Acquire exclusive access.
 858     osl::MutexGuard aGuard (m_aMutex);
 859
 860     // Check precond.
 861     if (!m_xLockBytes.is())
 862         return store_E_InvalidAccess;
 863
 864     return loadObjectAt_Impl (rPage, nAddr);
 865 }
 866
 867 /*
 868  * loadObjectAt_Impl.
 869  * Internal: Precond: initialized, readable, exclusive access.
 870  */
 871 storeError OStorePageBIOS::loadObjectAt_Impl (OStorePageObject & rPage, sal_uInt32 nAddr) const
 872 {
 873     storeError eErrCode = m_xCache->lookupPageAt (rPage.get(), nAddr);
 874     if (eErrCode != store_E_NotExists)
 875         return eErrCode;
 876
 877     // Read page.
 878     eErrCode = m_xLockBytes->readPageAt (rPage.get(), nAddr);
 879     if (eErrCode != store_E_None)
 880         return eErrCode;
 881
 882     // Verify page.
 883     eErrCode = rPage.verify (nAddr);
 884     if (eErrCode != store_E_None)
 885         return eErrCode;
 886
 887     // Mark page as clean.
 888     rPage.clean();
 889
 890     // Cache page.
 891     return m_xCache->insertPageAt (rPage.get(), nAddr);
 892 }
 893
 894 /*
 895  * saveObjectAt.
 896  * Precond: initialized, writeable.
 897  */
 898 storeError OStorePageBIOS::saveObjectAt (OStorePageObject & rPage, sal_uInt32 nAddr)
 899 {
 900     // Acquire exclusive access.
 901     osl::MutexGuard aGuard (m_aMutex);
 902
 903     // Check precond.
 904     if (!m_xLockBytes.is())
 905         return store_E_InvalidAccess;
 906     if (!m_bWriteable)
 907         return store_E_AccessViolation;
 908
 909     // Save Page.
 910     return saveObjectAt_Impl (rPage, nAddr);
 911 }
 912
 913 /*
 914  * saveObjectAt_Impl.
 915  * Internal: Precond: initialized, writeable, exclusive access.
 916  */
 917 storeError OStorePageBIOS::saveObjectAt_Impl (OStorePageObject & rPage, sal_uInt32 nAddr) const
 918 {
 919     // Guard page (incl. set location).
 920     storeError eErrCode = rPage.guard (nAddr);
 921     if (eErrCode != store_E_None)
 922         return eErrCode;
 923
 924     // Write page.
 925     eErrCode = m_xLockBytes->writePageAt(rPage.get(), nAddr);
 926     if (eErrCode != store_E_None)
 927         return eErrCode;
 928
 929     // Mark page as clean.
 930     rPage.clean();
 931
 932     // Cache page.
 933     return m_xCache->updatePageAt (rPage.get(), nAddr);
 934 }
 935
 936 /*
 937  * close.
 938  * Precond: none.
 939  */
 940 storeError OStorePageBIOS::close()
 941 {
 942     // Acquire exclusive access.
 943     osl::MutexGuard aGuard (m_aMutex);
 944
 945     // Cleanup.
 946     cleanup_Impl();
 947
 948     // Done.
 949     return store_E_None;
 950 }
 951
 952 /*
 953  * flush.
 954  * Precond: initialized.
 955  */
 956 storeError OStorePageBIOS::flush()
 957 {
 958     // Acquire exclusive access.
 959     osl::MutexGuard aGuard (m_aMutex);
 960
 961     // Check precond.
 962     if (!m_xLockBytes.is())
 963         return store_E_InvalidAccess;
 964
 965     // Flush LockBytes and finish.
 966     return m_xLockBytes->flush();
 967 }
 968
 969 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */