store/source/stordata.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*************************************************************************
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * Copyright 2000, 2010 Oracle and/or its affiliates.
   7  *
   8  * OpenOffice.org - a multi-platform office productivity suite
   9  *
  10  * This file is part of OpenOffice.org.
  11  *
  12  * OpenOffice.org is free software: you can redistribute it and/or modify
  13  * it under the terms of the GNU Lesser General Public License version 3
  14  * only, as published by the Free Software Foundation.
  15  *
  16  * OpenOffice.org is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU Lesser General Public License version 3 for more details
  20  * (a copy is included in the LICENSE file that accompanied this code).
  21  *
  22  * You should have received a copy of the GNU Lesser General Public License
  23  * version 3 along with OpenOffice.org.  If not, see
  24  * <http://www.openoffice.org/license.html>
  25  * for a copy of the LGPLv3 License.
  26  *
  27  ************************************************************************/
  28
  29
  30 #include "stordata.hxx"
  31
  32 #include "sal/types.h"
  33 #include "osl/diagnose.h"
  34
  35 #include "store/types.h"
  36 #include "storbase.hxx"
  37 #include "storbios.hxx"
  38
  39 using namespace store;
  40
  41 /*========================================================================
  42  *
  43  * OStoreDataPageObject implementation.
  44  *
  45  *======================================================================*/
  46 /*
  47  * guard.
  48  */
  49 storeError OStoreDataPageObject::guard (sal_uInt32 nAddr)
  50 {
  51     return PageHolderObject< page >::guard (m_xPage, nAddr);
  52 }
  53
  54 /*
  55  * verify.
  56  */
  57 storeError OStoreDataPageObject::verify (sal_uInt32 nAddr) const
  58 {
  59     return PageHolderObject< page >::verify (m_xPage, nAddr);
  60 }
  61
  62 /*========================================================================
  63  *
  64  * OStoreIndirectionPageObject implementation.
  65  *
  66  *======================================================================*/
  67 /*
  68   * store_truncate_Impl (single indirect page).
  69   */
  70 static storeError store_truncate_Impl (
  71     sal_uInt32      nAddr,
  72     sal_uInt16      nSingle,
  73     OStorePageBIOS &rBIOS)
  74 {
  75     if (nAddr != STORE_PAGE_NULL)
  76     {
  77         // Load single indirect page.
  78         OStoreIndirectionPageObject aSingle;
  79         storeError eErrCode = rBIOS.loadObjectAt (aSingle, nAddr);
  80         if (eErrCode == store_E_None)
  81         {
  82             // Truncate to 'nSingle' direct pages.
  83             eErrCode = aSingle.truncate (nSingle, rBIOS);
  84             if (eErrCode != store_E_None)
  85                 return eErrCode;
  86         }
  87         else
  88         {
  89             if (eErrCode != store_E_InvalidChecksum)
  90                 return eErrCode;
  91         }
  92
  93         // Check for complete truncation.
  94         if (nSingle == 0)
  95         {
  96             // Free single indirect page.
  97             eErrCode = rBIOS.free (nAddr);
  98             if (eErrCode != store_E_None)
  99                 return eErrCode;
 100         }
 101     }
 102     return store_E_None;
 103 }
 104
 105 /*
 106  * store_truncate_Impl (double indirect page).
 107  */
 108 static storeError store_truncate_Impl (
 109     sal_uInt32       nAddr,
 110     sal_uInt16       nDouble,
 111     sal_uInt16       nSingle,
 112     OStorePageBIOS  &rBIOS)
 113 {
 114     if (nAddr != STORE_PAGE_NULL)
 115     {
 116         // Load double indirect page.
 117         OStoreIndirectionPageObject aDouble;
 118         storeError eErrCode = rBIOS.loadObjectAt (aDouble, nAddr);
 119         if (eErrCode == store_E_None)
 120         {
 121             // Truncate to 'nDouble', 'nSingle' pages.
 122             eErrCode = aDouble.truncate (nDouble, nSingle, rBIOS);
 123             if (eErrCode != store_E_None)
 124                 return eErrCode;
 125         }
 126         else
 127         {
 128             if (eErrCode != store_E_InvalidChecksum)
 129                 return eErrCode;
 130         }
 131
 132         // Check for complete truncation.
 133         if ((nDouble + nSingle) == 0)
 134         {
 135             // Free double indirect page.
 136             eErrCode = rBIOS.free (nAddr);
 137             if (eErrCode != store_E_None)
 138                 return eErrCode;
 139         }
 140     }
 141     return store_E_None;
 142 }
 143
 144 /*
 145  * store_truncate_Impl (triple indirect page).
 146  */
 147 static storeError store_truncate_Impl (
 148     sal_uInt32       nAddr,
 149     sal_uInt16       nTriple,
 150     sal_uInt16       nDouble,
 151     sal_uInt16       nSingle,
 152     OStorePageBIOS  &rBIOS)
 153 {
 154     if (nAddr != STORE_PAGE_NULL)
 155     {
 156         // Load triple indirect page.
 157         OStoreIndirectionPageObject aTriple;
 158         storeError eErrCode = rBIOS.loadObjectAt (aTriple, nAddr);
 159         if (eErrCode != store_E_None)
 160             return eErrCode;
 161
 162         // Truncate to 'nTriple', 'nDouble', 'nSingle' pages.
 163         eErrCode = aTriple.truncate (nTriple, nDouble, nSingle, rBIOS);
 164         if (eErrCode != store_E_None)
 165             return eErrCode;
 166
 167         // Check for complete truncation.
 168         if ((nTriple + nDouble + nSingle) == 0)
 169         {
 170             // Free triple indirect page.
 171             eErrCode = rBIOS.free (nAddr);
 172             if (eErrCode != store_E_None)
 173                 return eErrCode;
 174         }
 175     }
 176     return store_E_None;
 177 }
 178
 179 /*
 180  * loadOrCreate.
 181  */
 182 storeError OStoreIndirectionPageObject::loadOrCreate (
 183     sal_uInt32       nAddr,
 184     OStorePageBIOS & rBIOS)
 185 {
 186     if (nAddr == STORE_PAGE_NULL)
 187     {
 188         storeError eErrCode = construct<page>(rBIOS.allocator());
 189         if (eErrCode != store_E_None)
 190             return eErrCode;
 191
 192         eErrCode = rBIOS.allocate (*this);
 193         if (eErrCode != store_E_None)
 194             return eErrCode;
 195
 196         // Save location pending at caller.
 197         return store_E_Pending;
 198     }
 199     return rBIOS.loadObjectAt (*this, nAddr);
 200 }
 201
 202 /*
 203  * guard.
 204  */
 205 storeError OStoreIndirectionPageObject::guard (sal_uInt32 nAddr)
 206 {
 207     return PageHolderObject< page >::guard (m_xPage, nAddr);
 208 }
 209
 210 /*
 211  * verify.
 212  */
 213 storeError OStoreIndirectionPageObject::verify (sal_uInt32 nAddr) const
 214 {
 215     return PageHolderObject< page >::verify (m_xPage, nAddr);
 216 }
 217
 218 /*
 219  * read (single indirect).
 220  */
 221 storeError OStoreIndirectionPageObject::read (
 222     sal_uInt16             nSingle,
 223     OStoreDataPageObject  &rData,
 224     OStorePageBIOS        &rBIOS)
 225 {
 226     PageHolderObject< page > xImpl (m_xPage);
 227     page const & rPage = (*xImpl);
 228
 229     // Check arguments.
 230     sal_uInt16 const nLimit = rPage.capacityCount();
 231     if (!(nSingle < nLimit))
 232         return store_E_InvalidAccess;
 233
 234     // Obtain data page location.
 235     sal_uInt32 const nAddr = store::ntohl(rPage.m_pData[nSingle]);
 236     if (nAddr == STORE_PAGE_NULL)
 237         return store_E_NotExists;
 238
 239     // Load data page and leave.
 240     return rBIOS.loadObjectAt (rData, nAddr);
 241 }
 242
 243 /*
 244  * read (double indirect).
 245  */
 246 storeError OStoreIndirectionPageObject::read (
 247     sal_uInt16             nDouble,
 248     sal_uInt16             nSingle,
 249     OStoreDataPageObject  &rData,
 250     OStorePageBIOS        &rBIOS)
 251 {
 252     PageHolderObject< page > xImpl (m_xPage);
 253     page const & rPage = (*xImpl);
 254
 255     // Check arguments.
 256     sal_uInt16 const nLimit = rPage.capacityCount();
 257     if (!((nDouble < nLimit) && (nSingle < nLimit)))
 258         return store_E_InvalidAccess;
 259
 260     // Check single indirect page location.
 261     sal_uInt32 const nAddr = store::ntohl(rPage.m_pData[nDouble]);
 262     if (nAddr == STORE_PAGE_NULL)
 263         return store_E_NotExists;
 264
 265     // Load single indirect page.
 266     OStoreIndirectionPageObject aSingle;
 267     storeError eErrCode = rBIOS.loadObjectAt (aSingle, nAddr);
 268     if (eErrCode != store_E_None)
 269         return eErrCode;
 270
 271     // Read single indirect and leave.
 272     return aSingle.read (nSingle, rData, rBIOS);
 273 }
 274
 275 /*
 276  * read (triple indirect).
 277  */
 278 storeError OStoreIndirectionPageObject::read (
 279     sal_uInt16             nTriple,
 280     sal_uInt16             nDouble,
 281     sal_uInt16             nSingle,
 282     OStoreDataPageObject  &rData,
 283     OStorePageBIOS        &rBIOS)
 284 {
 285     PageHolderObject< page > xImpl (m_xPage);
 286     page const & rPage = (*xImpl);
 287
 288     // Check arguments.
 289     sal_uInt16 const nLimit = rPage.capacityCount();
 290     if (!((nTriple < nLimit) && (nDouble < nLimit) && (nSingle < nLimit)))
 291         return store_E_InvalidAccess;
 292
 293     // Check double indirect page location.
 294     sal_uInt32 const nAddr = store::ntohl(rPage.m_pData[nTriple]);
 295     if (nAddr == STORE_PAGE_NULL)
 296         return store_E_NotExists;
 297
 298     // Load double indirect page.
 299     OStoreIndirectionPageObject aDouble;
 300     storeError eErrCode = rBIOS.loadObjectAt (aDouble, nAddr);
 301     if (eErrCode != store_E_None)
 302         return eErrCode;
 303
 304     // Read double indirect and leave.
 305     return aDouble.read (nDouble, nSingle, rData, rBIOS);
 306 }
 307
 308 /*
 309  * write (single indirect).
 310  */
 311 storeError OStoreIndirectionPageObject::write (
 312     sal_uInt16             nSingle,
 313     OStoreDataPageObject  &rData,
 314     OStorePageBIOS        &rBIOS)
 315 {
 316     PageHolderObject< page > xImpl (m_xPage);
 317     page & rPage = (*xImpl);
 318
 319     // Check arguments.
 320     sal_uInt16 const nLimit = rPage.capacityCount();
 321     if (!(nSingle < nLimit))
 322         return store_E_InvalidAccess;
 323
 324     // Obtain data page location.
 325     sal_uInt32 const nAddr = store::ntohl(rPage.m_pData[nSingle]);
 326     if (nAddr == STORE_PAGE_NULL)
 327     {
 328         // Allocate data page.
 329         storeError eErrCode = rBIOS.allocate (rData);
 330         if (eErrCode != store_E_None)
 331             return eErrCode;
 332
 333         // Store data page location.
 334         rPage.m_pData[nSingle] = store::htonl(rData.location());
 335
 336         // Save this page.
 337         return rBIOS.saveObjectAt (*this, location());
 338     }
 339     else
 340     {
 341         // Save data page.
 342         return rBIOS.saveObjectAt (rData, nAddr);
 343     }
 344 }
 345
 346 /*
 347  * write (double indirect).
 348  */
 349 storeError OStoreIndirectionPageObject::write (
 350     sal_uInt16             nDouble,
 351     sal_uInt16             nSingle,
 352     OStoreDataPageObject  &rData,
 353     OStorePageBIOS        &rBIOS)
 354 {
 355     PageHolderObject< page > xImpl (m_xPage);
 356     page & rPage = (*xImpl);
 357
 358     // Check arguments.
 359     sal_uInt16 const nLimit = rPage.capacityCount();
 360     if (!((nDouble < nLimit) && (nSingle < nLimit)))
 361         return store_E_InvalidAccess;
 362
 363     // Load or create single indirect page.
 364     OStoreIndirectionPageObject aSingle;
 365     storeError eErrCode = aSingle.loadOrCreate (store::ntohl(rPage.m_pData[nDouble]), rBIOS);
 366     if (eErrCode != store_E_None)
 367     {
 368         if (eErrCode != store_E_Pending)
 369             return eErrCode;
 370         rPage.m_pData[nDouble] = store::htonl(aSingle.location());
 371
 372         eErrCode = rBIOS.saveObjectAt (*this, location());
 373         if (eErrCode != store_E_None)
 374             return eErrCode;
 375     }
 376
 377     // Write single indirect and leave.
 378     return aSingle.write (nSingle, rData, rBIOS);
 379 }
 380
 381 /*
 382  * write (triple indirect).
 383  */
 384 storeError OStoreIndirectionPageObject::write (
 385     sal_uInt16             nTriple,
 386     sal_uInt16             nDouble,
 387     sal_uInt16             nSingle,
 388     OStoreDataPageObject  &rData,
 389     OStorePageBIOS        &rBIOS)
 390 {
 391     PageHolderObject< page > xImpl (m_xPage);
 392     page & rPage = (*xImpl);
 393
 394     // Check arguments.
 395     sal_uInt16 const nLimit = rPage.capacityCount();
 396     if (!((nTriple < nLimit) && (nDouble < nLimit) && (nSingle < nLimit)))
 397         return store_E_InvalidAccess;
 398
 399     // Load or create double indirect page.
 400     OStoreIndirectionPageObject aDouble;
 401     storeError eErrCode = aDouble.loadOrCreate (store::ntohl(rPage.m_pData[nTriple]), rBIOS);
 402     if (eErrCode != store_E_None)
 403     {
 404         if (eErrCode != store_E_Pending)
 405             return eErrCode;
 406         rPage.m_pData[nTriple] = store::htonl(aDouble.location());
 407
 408         eErrCode = rBIOS.saveObjectAt (*this, location());
 409         if (eErrCode != store_E_None)
 410             return eErrCode;
 411     }
 412
 413     // Write double indirect and leave.
 414     return aDouble.write (nDouble, nSingle, rData, rBIOS);
 415 }
 416
 417 /*
 418  * truncate (single indirect).
 419  */
 420 storeError OStoreIndirectionPageObject::truncate (
 421     sal_uInt16       nSingle,
 422     OStorePageBIOS & rBIOS)
 423 {
 424     PageHolderObject< page > xImpl (m_xPage);
 425     page & rPage = (*xImpl);
 426
 427     // Check arguments.
 428     sal_uInt16 const nLimit = rPage.capacityCount();
 429     if (!(nSingle < nLimit))
 430         return store_E_InvalidAccess;
 431
 432     // Truncate.
 433     storeError eErrCode = store_E_None;
 434     for (sal_uInt16 i = nLimit; i > nSingle; i--)
 435     {
 436         // Obtain data page location.
 437         sal_uInt32 const nAddr = store::ntohl(rPage.m_pData[i - 1]);
 438         if (nAddr != STORE_PAGE_NULL)
 439         {
 440             // Free data page.
 441             eErrCode = rBIOS.free (nAddr);
 442             if (eErrCode != store_E_None)
 443                 return eErrCode;
 444
 445             // Clear pointer to data page.
 446             rPage.m_pData[i - 1] = STORE_PAGE_NULL;
 447             touch();
 448         }
 449     }
 450
 451     // Check for modified page.
 452     if (dirty())
 453     {
 454         // Save this page.
 455         eErrCode = rBIOS.saveObjectAt (*this, location());
 456     }
 457
 458     // Done.
 459     return eErrCode;
 460 }
 461
 462 /*
 463  * truncate (double indirect).
 464  */
 465 storeError OStoreIndirectionPageObject::truncate (
 466     sal_uInt16             nDouble,
 467     sal_uInt16             nSingle,
 468     OStorePageBIOS        &rBIOS)
 469 {
 470     PageHolderObject< page > xImpl (m_xPage);
 471     page & rPage = (*xImpl);
 472
 473     // Check arguments.
 474     sal_uInt16 const nLimit = rPage.capacityCount();
 475     if (!((nDouble < nLimit) && (nSingle < nLimit)))
 476         return store_E_InvalidAccess;
 477
 478     // Truncate.
 479     storeError eErrCode = store_E_None;
 480     for (sal_uInt16 i = nLimit; i > nDouble + 1; i--)
 481     {
 482         // Truncate single indirect page to zero direct pages.
 483         eErrCode = store_truncate_Impl (store::ntohl(rPage.m_pData[i - 1]), 0, rBIOS);
 484         if (eErrCode != store_E_None)
 485             return eErrCode;
 486
 487         // Clear pointer to single indirect page.
 488         rPage.m_pData[i - 1] = STORE_PAGE_NULL;
 489         touch();
 490     }
 491
 492     // Truncate last single indirect page to 'nSingle' direct pages.
 493     eErrCode = store_truncate_Impl (store::ntohl(rPage.m_pData[nDouble]), nSingle, rBIOS);
 494     if (eErrCode != store_E_None)
 495         return eErrCode;
 496
 497     // Check for complete truncation.
 498     if (nSingle == 0)
 499     {
 500         // Clear pointer to last single indirect page.
 501         rPage.m_pData[nDouble] = STORE_PAGE_NULL;
 502         touch();
 503     }
 504
 505     // Check for modified page.
 506     if (dirty())
 507     {
 508         // Save this page.
 509         eErrCode = rBIOS.saveObjectAt (*this, location());
 510     }
 511
 512     // Done.
 513     return eErrCode;
 514 }
 515
 516 /*
 517  * truncate (triple indirect).
 518  */
 519 storeError OStoreIndirectionPageObject::truncate (
 520     sal_uInt16             nTriple,
 521     sal_uInt16             nDouble,
 522     sal_uInt16             nSingle,
 523     OStorePageBIOS        &rBIOS)
 524 {
 525     PageHolderObject< page > xImpl (m_xPage);
 526     page & rPage = (*xImpl);
 527
 528     // Check arguments.
 529     sal_uInt16 const nLimit = rPage.capacityCount();
 530     if (!((nTriple < nLimit) && (nDouble < nLimit) && (nSingle < nLimit)))
 531         return store_E_InvalidAccess;
 532
 533     // Truncate.
 534     storeError eErrCode = store_E_None;
 535     for (sal_uInt16 i = nLimit; i > nTriple + 1; i--)
 536     {
 537         // Truncate double indirect page to zero single indirect pages.
 538         eErrCode = store_truncate_Impl (store::ntohl(rPage.m_pData[i - 1]), 0, 0, rBIOS);
 539         if (eErrCode != store_E_None)
 540             return eErrCode;
 541
 542         // Clear pointer to double indirect page.
 543         rPage.m_pData[i - 1] = STORE_PAGE_NULL;
 544         touch();
 545     }
 546
 547     // Truncate last double indirect page to 'nDouble', 'nSingle' pages.
 548     eErrCode = store_truncate_Impl (store::ntohl(rPage.m_pData[nTriple]), nDouble, nSingle, rBIOS);
 549     if (eErrCode != store_E_None)
 550         return eErrCode;
 551
 552     // Check for complete truncation.
 553     if ((nDouble + nSingle) == 0)
 554     {
 555         // Clear pointer to last double indirect page.
 556         rPage.m_pData[nTriple] = STORE_PAGE_NULL;
 557         touch();
 558     }
 559
 560     // Check for modified page.
 561     if (dirty())
 562     {
 563         // Save this page.
 564         eErrCode = rBIOS.saveObjectAt (*this, location());
 565     }
 566
 567     // Done.
 568     return eErrCode;
 569 }
 570
 571 /*========================================================================
 572  *
 573  * OStoreDirectoryPageObject implementation.
 574  *
 575  *======================================================================*/
 576 /*
 577  * guard.
 578  */
 579 storeError OStoreDirectoryPageObject::guard (sal_uInt32 nAddr)
 580 {
 581     return PageHolderObject< page >::guard (m_xPage, nAddr);
 582 }
 583
 584 /*
 585  * verify.
 586  */
 587 storeError OStoreDirectoryPageObject::verify (sal_uInt32 nAddr) const
 588 {
 589     return PageHolderObject< page >::verify (m_xPage, nAddr);
 590     // OLD: m_rPage.verifyVersion (STORE_MAGIC_DIRECTORYPAGE);
 591 }
 592
 593 /*
 594  * scope (external data page; private).
 595  */
 596 OStoreDirectoryPageData::ChunkScope
 597 OStoreDirectoryPageObject::scope (
 598     sal_uInt32                       nPage,
 599     page::DataBlock::LinkDescriptor &rDescr) const
 600 {
 601     page const & rPage = PAGE();
 602     OStoreDirectoryDataBlock const & rDataBlock = rPage.m_aDataBlock;
 603
 604     sal_uInt32 index0, index1, index2, index3;
 605
 606     // direct.
 607     sal_uInt32 nCount = rDataBlock.directCount();
 608     sal_uInt32 nLimit = nCount;
 609     if (nPage < nLimit)
 610     {
 611         // Page to index reduction.
 612         index0 = nPage;
 613
 614         // Setup LinkDescriptor indices.
 615         rDescr.m_nIndex0 = (sal_uInt16)(index0 & 0xffff);
 616
 617         // Done.
 618         return page::SCOPE_DIRECT;
 619     }
 620     nPage -= nLimit;
 621
 622     // single indirect.
 623     sal_uInt32 const nCapacity = indirect::capacityCount(rPage.m_aDescr);
 624     nCount = rDataBlock.singleCount();
 625     nLimit = nCount * nCapacity;
 626     if (nPage < nLimit)
 627     {
 628         // Page to index reduction.
 629         sal_uInt32 n = nPage;
 630
 631         // Reduce to single indirect i(1), direct n = i(0).
 632         index1 = n / nCapacity;
 633         index0 = n % nCapacity;
 634
 635         // Verify reduction.
 636         n = index1 * nCapacity + index0;
 637         OSL_POSTCOND(n == nPage, "wrong math on indirect indices");
 638         if (n != nPage)
 639             return page::SCOPE_UNKNOWN;
 640
 641         // Setup LinkDescriptor indices.
 642         rDescr.m_nIndex0 = (sal_uInt16)(index0 & 0xffff);
 643         rDescr.m_nIndex1 = (sal_uInt16)(index1 & 0xffff);
 644
 645         // Done.
 646         return page::SCOPE_SINGLE;
 647     }
 648     nPage -= nLimit;
 649
 650     // double indirect.
 651     nCount = rDataBlock.doubleCount();
 652     nLimit = nCount * nCapacity * nCapacity;
 653     if (nPage < nLimit)
 654     {
 655         // Page to index reduction.
 656         sal_uInt32 n = nPage;
 657
 658         // Reduce to double indirect i(2), single indirect n = i(0).
 659         index2 = n / (nCapacity * nCapacity);
 660         n      = n % (nCapacity * nCapacity);
 661
 662         // Reduce to single indirect i(1), direct n = i(0).
 663         index1 = n / nCapacity;
 664         index0 = n % nCapacity;
 665
 666         // Verify reduction.
 667         n = index2 * nCapacity * nCapacity +
 668             index1 * nCapacity + index0;
 669         OSL_POSTCOND(n == nPage, "wrong math on double indirect indices");
 670         if (n != nPage)
 671             return page::SCOPE_UNKNOWN;
 672
 673         // Setup LinkDescriptor indices.
 674         rDescr.m_nIndex0 = (sal_uInt16)(index0 & 0xffff);
 675         rDescr.m_nIndex1 = (sal_uInt16)(index1 & 0xffff);
 676         rDescr.m_nIndex2 = (sal_uInt16)(index2 & 0xffff);
 677
 678         // Done.
 679         return page::SCOPE_DOUBLE;
 680     }
 681     nPage -= nLimit;
 682
 683     // triple indirect.
 684     nCount = rDataBlock.tripleCount();
 685     nLimit = nCount * nCapacity * nCapacity * nCapacity;
 686     if (nPage < nLimit)
 687     {
 688         // Page to index reduction.
 689         sal_uInt32 n = nPage;
 690
 691         // Reduce to triple indirect i(3), double indirect n.
 692         index3 = n / (nCapacity * nCapacity * nCapacity);
 693         n      = n % (nCapacity * nCapacity * nCapacity);
 694
 695         // Reduce to double indirect i(2), single indirect n.
 696         index2 = n / (nCapacity * nCapacity);
 697         n      = n % (nCapacity * nCapacity);
 698
 699         // Reduce to single indirect i(1), direct n = i(0).
 700         index1 = n / nCapacity;
 701         index0 = n % nCapacity;
 702
 703         // Verify reduction.
 704         n = index3 * nCapacity * nCapacity * nCapacity +
 705             index2 * nCapacity * nCapacity +
 706             index1 * nCapacity + index0;
 707         OSL_POSTCOND(n == nPage, "wrong math on triple indirect indices");
 708         if (n != nPage)
 709             return page::SCOPE_UNKNOWN;
 710
 711         // Setup LinkDescriptor indices.
 712         rDescr.m_nIndex0 = (sal_uInt16)(index0 & 0xffff);
 713         rDescr.m_nIndex1 = (sal_uInt16)(index1 & 0xffff);
 714         rDescr.m_nIndex2 = (sal_uInt16)(index2 & 0xffff);
 715         rDescr.m_nIndex3 = (sal_uInt16)(index3 & 0xffff);
 716
 717         // Done.
 718         return page::SCOPE_TRIPLE;
 719     }
 720
 721     // Unreachable (more than triple indirect).
 722     return page::SCOPE_UNREACHABLE;
 723 }
 724
 725 /*
 726  * read (external data page).
 727  */
 728 storeError OStoreDirectoryPageObject::read (
 729     sal_uInt32             nPage,
 730     OStoreDataPageObject  &rData,
 731     OStorePageBIOS        &rBIOS)
 732 {
 733     // Determine scope and link indices.
 734     page::DataBlock::LinkDescriptor aLink;
 735     page::ChunkScope eScope = scope (nPage, aLink);
 736
 737     storeError eErrCode = store_E_None;
 738     if (eScope == page::SCOPE_DIRECT)
 739     {
 740         sal_uInt32 const nAddr = directLink (aLink.m_nIndex0);
 741         if (nAddr == STORE_PAGE_NULL)
 742             return store_E_NotExists;
 743
 744         eErrCode = rBIOS.loadObjectAt (rData, nAddr);
 745     }
 746     else if (eScope == page::SCOPE_SINGLE)
 747     {
 748         sal_uInt32 const nAddr = singleLink (aLink.m_nIndex1);
 749         if (nAddr == STORE_PAGE_NULL)
 750             return store_E_NotExists;
 751
 752         OStoreIndirectionPageObject aSingle;
 753         eErrCode = rBIOS.loadObjectAt (aSingle, nAddr);
 754         if (eErrCode != store_E_None)
 755             return eErrCode;
 756
 757         eErrCode = aSingle.read (aLink.m_nIndex0, rData, rBIOS);
 758     }
 759     else if (eScope == page::SCOPE_DOUBLE)
 760     {
 761         sal_uInt32 const nAddr = doubleLink (aLink.m_nIndex2);
 762         if (nAddr == STORE_PAGE_NULL)
 763             return store_E_NotExists;
 764
 765         OStoreIndirectionPageObject aDouble;
 766         eErrCode = rBIOS.loadObjectAt (aDouble, nAddr);
 767         if (eErrCode != store_E_None)
 768             return eErrCode;
 769
 770         eErrCode = aDouble.read (aLink.m_nIndex1, aLink.m_nIndex0, rData, rBIOS);
 771     }
 772     else if (eScope == page::SCOPE_TRIPLE)
 773     {
 774         sal_uInt32 const nAddr = tripleLink (aLink.m_nIndex3);
 775         if (nAddr == STORE_PAGE_NULL)
 776             return store_E_NotExists;
 777
 778         OStoreIndirectionPageObject aTriple;
 779         eErrCode = rBIOS.loadObjectAt (aTriple, nAddr);
 780         if (eErrCode != store_E_None)
 781             return eErrCode;
 782
 783         eErrCode = aTriple.read (aLink.m_nIndex2, aLink.m_nIndex1, aLink.m_nIndex0, rData, rBIOS);
 784     }
 785     else if (eScope == page::SCOPE_UNREACHABLE)
 786     {
 787         // Out of scope.
 788         eErrCode = store_E_CantSeek;
 789     }
 790     else
 791     {
 792         // Unknown scope.
 793         OSL_TRACE("OStoreDirectoryPageObject::get(): scope failed");
 794         eErrCode = store_E_Unknown;
 795     }
 796
 797     // Leave.
 798     return eErrCode;
 799 }
 800
 801 /*
 802  * write (external data page).
 803  */
 804 storeError OStoreDirectoryPageObject::write (
 805     sal_uInt32             nPage,
 806     OStoreDataPageObject  &rData,
 807     OStorePageBIOS        &rBIOS)
 808 {
 809     // Determine scope and link indices.
 810     page::DataBlock::LinkDescriptor aLink;
 811     page::ChunkScope eScope = scope (nPage, aLink);
 812
 813     storeError eErrCode = store_E_None;
 814     if (eScope == page::SCOPE_DIRECT)
 815     {
 816         sal_uInt32 const nAddr = directLink (aLink.m_nIndex0);
 817         if (nAddr == STORE_PAGE_NULL)
 818         {
 819             // Allocate data page.
 820             eErrCode = rBIOS.allocate (rData);
 821             if (eErrCode != store_E_None)
 822                 return eErrCode;
 823
 824             // Store data page location.
 825             directLink (aLink.m_nIndex0, rData.location());
 826         }
 827         else
 828         {
 829             // Save data page.
 830             eErrCode = rBIOS.saveObjectAt (rData, nAddr);
 831         }
 832     }
 833     else if (eScope == page::SCOPE_SINGLE)
 834     {
 835         OStoreIndirectionPageObject aSingle;
 836         eErrCode = aSingle.loadOrCreate (singleLink (aLink.m_nIndex1), rBIOS);
 837         if (eErrCode != store_E_None)
 838         {
 839             if (eErrCode != store_E_Pending)
 840                 return eErrCode;
 841             singleLink (aLink.m_nIndex1, aSingle.location());
 842         }
 843
 844         eErrCode = aSingle.write (aLink.m_nIndex0, rData, rBIOS);
 845     }
 846     else if (eScope == page::SCOPE_DOUBLE)
 847     {
 848         OStoreIndirectionPageObject aDouble;
 849         eErrCode = aDouble.loadOrCreate (doubleLink (aLink.m_nIndex2), rBIOS);
 850         if (eErrCode != store_E_None)
 851         {
 852             if (eErrCode != store_E_Pending)
 853                 return eErrCode;
 854             doubleLink (aLink.m_nIndex2, aDouble.location());
 855         }
 856
 857         eErrCode = aDouble.write (aLink.m_nIndex1, aLink.m_nIndex0, rData, rBIOS);
 858     }
 859     else if (eScope == page::SCOPE_TRIPLE)
 860     {
 861         OStoreIndirectionPageObject aTriple;
 862         eErrCode = aTriple.loadOrCreate (tripleLink (aLink.m_nIndex3), rBIOS);
 863         if (eErrCode != store_E_None)
 864         {
 865             if (eErrCode != store_E_Pending)
 866                 return eErrCode;
 867             tripleLink (aLink.m_nIndex3, aTriple.location());
 868         }
 869
 870         eErrCode = aTriple.write (aLink.m_nIndex2, aLink.m_nIndex1, aLink.m_nIndex0, rData, rBIOS);
 871     }
 872     else if (eScope == page::SCOPE_UNREACHABLE)
 873     {
 874         // Out of scope.
 875         eErrCode = store_E_CantSeek;
 876     }
 877     else
 878     {
 879         // Unknown scope.
 880         OSL_TRACE("OStoreDirectoryPageObject::put(): scope failed");
 881         eErrCode = store_E_Unknown;
 882     }
 883
 884     // Leave.
 885     return eErrCode;
 886 }
 887
 888 /*
 889  * truncate (external data page).
 890  */
 891 storeError OStoreDirectoryPageObject::truncate (
 892     sal_uInt32             nPage,
 893     OStorePageBIOS        &rBIOS)
 894 {
 895     // Determine scope and link indices.
 896     page::DataBlock::LinkDescriptor aLink;
 897     page::ChunkScope eScope = scope (nPage, aLink);
 898
 899     storeError eErrCode = store_E_None;
 900     if (eScope == page::SCOPE_DIRECT)
 901     {
 902         // Truncate all triple indirect pages.
 903         eErrCode = truncate (page::SCOPE_TRIPLE, 0, rBIOS);
 904         if (eErrCode != store_E_None)
 905             return eErrCode;
 906
 907         // Truncate all double indirect pages.
 908         eErrCode = truncate (page::SCOPE_DOUBLE, 0, rBIOS);
 909         if (eErrCode != store_E_None)
 910             return eErrCode;
 911
 912         // Truncate all single indirect pages.
 913         eErrCode = truncate (page::SCOPE_SINGLE, 0, rBIOS);
 914         if (eErrCode != store_E_None)
 915             return eErrCode;
 916
 917         // Truncate direct pages, including 'aLink.m_nIndex0'.
 918         eErrCode = truncate (eScope, aLink.m_nIndex0, rBIOS);
 919     }
 920     else if (eScope == page::SCOPE_SINGLE)
 921     {
 922         // Truncate all triple indirect pages.
 923         eErrCode = truncate (page::SCOPE_TRIPLE, 0, rBIOS);
 924         if (eErrCode != store_E_None)
 925             return eErrCode;
 926
 927         // Truncate all double indirect pages.
 928         eErrCode = truncate (page::SCOPE_DOUBLE, 0, rBIOS);
 929         if (eErrCode != store_E_None)
 930             return eErrCode;
 931
 932         // Truncate single indirect pages, downto 'aLink.m_nIndex1'.
 933         eErrCode = truncate (eScope, aLink.m_nIndex1 + 1, rBIOS);
 934         if (eErrCode != store_E_None)
 935             return eErrCode;
 936
 937         // Truncate last single indirect page to ... pages.
 938         eErrCode = store_truncate_Impl (singleLink (aLink.m_nIndex1), aLink.m_nIndex0, rBIOS);
 939         if (eErrCode != store_E_None)
 940             return eErrCode;
 941
 942         // Check for complete truncation.
 943         if (aLink.m_nIndex0 == 0)
 944         {
 945             // Clear pointer to last single indirect page.
 946             singleLink (aLink.m_nIndex1, STORE_PAGE_NULL);
 947         }
 948     }
 949     else if (eScope == page::SCOPE_DOUBLE)
 950     {
 951         // Truncate all triple indirect pages.
 952         eErrCode = truncate (page::SCOPE_TRIPLE, 0, rBIOS);
 953         if (eErrCode != store_E_None)
 954             return eErrCode;
 955
 956         // Truncate double indirect pages, downto 'aLink.m_nIndex2'.
 957         eErrCode = truncate (eScope, aLink.m_nIndex2 + 1, rBIOS);
 958         if (eErrCode != store_E_None)
 959             return eErrCode;
 960
 961         // Truncate last double indirect page to ... pages.
 962         eErrCode = store_truncate_Impl (
 963             doubleLink (aLink.m_nIndex2), aLink.m_nIndex1, aLink.m_nIndex0, rBIOS);
 964         if (eErrCode != store_E_None)
 965             return eErrCode;
 966
 967         // Check for complete truncation.
 968         if ((aLink.m_nIndex1 + aLink.m_nIndex0) == 0)
 969         {
 970             // Clear pointer to last double indirect page.
 971             doubleLink (aLink.m_nIndex2, STORE_PAGE_NULL);
 972         }
 973     }
 974     else if (eScope == page::SCOPE_TRIPLE)
 975     {
 976         // Truncate triple indirect pages, downto 'aLink.m_nIndex3'.
 977         eErrCode = truncate (eScope, aLink.m_nIndex3 + 1, rBIOS);
 978         if (eErrCode != store_E_None)
 979             return eErrCode;
 980
 981         // Truncate last triple indirect page to ... pages.
 982         eErrCode = store_truncate_Impl (
 983             tripleLink (aLink.m_nIndex3), aLink.m_nIndex2, aLink.m_nIndex1, aLink.m_nIndex0, rBIOS);
 984         if (eErrCode != store_E_None)
 985             return eErrCode;
 986
 987         // Check for complete truncation.
 988         if ((aLink.m_nIndex2 + aLink.m_nIndex1 + aLink.m_nIndex0) == 0)
 989         {
 990             // Clear pointer to last triple indirect page.
 991             tripleLink (aLink.m_nIndex3, STORE_PAGE_NULL);
 992         }
 993     }
 994     else if (eScope == page::SCOPE_UNREACHABLE)
 995     {
 996         // Out of scope.
 997         eErrCode = store_E_CantSeek;
 998     }
 999     else
1000     {
1001         // Unknown scope.
1002         OSL_TRACE("OStoreDirectoryPageObject::put(): scope failed");
1003         eErrCode = store_E_Unknown;
1004     }
1005
1006     // Leave.
1007     return eErrCode;
1008 }
1009
1010 /*
1011  * truncate (external data page scope; private).
1012  */
1013 storeError OStoreDirectoryPageObject::truncate (
1014     page::ChunkScope       eScope,
1015     sal_uInt16             nRemain,
1016     OStorePageBIOS        &rBIOS)
1017 {
1018     OStoreDirectoryDataBlock const & rDataBlock = PAGE().m_aDataBlock;
1019
1020     // Enter.
1021     storeError eErrCode = store_E_None;
1022     if (eScope == page::SCOPE_DIRECT)
1023     {
1024         // Truncate direct data pages.
1025         sal_uInt16 i, n = rDataBlock.directCount();
1026         for (i = n; i > nRemain; i--)
1027         {
1028             // Obtain data page location.
1029             sal_uInt32 nAddr = directLink (i - 1);
1030             if (nAddr == STORE_PAGE_NULL) continue;
1031
1032             // Free data page.
1033             eErrCode = rBIOS.free (nAddr);
1034             if (eErrCode != store_E_None)
1035                 break;
1036
1037             // Clear pointer to data page.
1038             directLink (i - 1, STORE_PAGE_NULL);
1039         }
1040
1041         // Done.
1042         return eErrCode;
1043     }
1044
1045     if (eScope == page::SCOPE_SINGLE)
1046     {
1047         // Truncate single indirect pages.
1048         sal_uInt16 i, n = rDataBlock.singleCount();
1049         for (i = n; i > nRemain; i--)
1050         {
1051             // Truncate single indirect page to zero data pages.
1052             eErrCode = store_truncate_Impl (singleLink (i - 1), 0, rBIOS);
1053             if (eErrCode != store_E_None)
1054                 break;
1055
1056             // Clear pointer to single indirect page.
1057             singleLink (i - 1, STORE_PAGE_NULL);
1058         }
1059
1060         // Done.
1061         return eErrCode;
1062     }
1063
1064     if (eScope == page::SCOPE_DOUBLE)
1065     {
1066         // Truncate double indirect pages.
1067         sal_uInt16 i, n = rDataBlock.doubleCount();
1068         for (i = n; i > nRemain; i--)
1069         {
1070             // Truncate double indirect page to zero single indirect pages.
1071             eErrCode = store_truncate_Impl (doubleLink (i - 1), 0, 0, rBIOS);
1072             if (eErrCode != store_E_None)
1073                 break;
1074
1075             // Clear pointer to double indirect page.
1076             doubleLink (i - 1, STORE_PAGE_NULL);
1077         }
1078
1079         // Done.
1080         return eErrCode;
1081     }
1082
1083     if (eScope == page::SCOPE_TRIPLE)
1084     {
1085         // Truncate triple indirect pages.
1086         sal_uInt16 i, n = rDataBlock.tripleCount();
1087         for (i = n; i > nRemain; i--)
1088         {
1089             // Truncate to zero double indirect pages.
1090             eErrCode = store_truncate_Impl (tripleLink (i - 1), 0, 0, 0, rBIOS);
1091             if (eErrCode != store_E_None)
1092                 break;
1093
1094             // Clear pointer to triple indirect page.
1095             tripleLink (i - 1, STORE_PAGE_NULL);
1096         }
1097
1098         // Done.
1099         return eErrCode;
1100     }
1101
1102     // Invalid scope.
1103     return store_E_InvalidAccess;
1104 }
1105
1106 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */