store/source/storbase.hxx

   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 #ifndef INCLUDED_STORE_SOURCE_STORBASE_HXX
  21 #define INCLUDED_STORE_SOURCE_STORBASE_HXX
  22
  23 #include <sal/config.h>
  24 #include <salhelper/simplereferenceobject.hxx>
  25
  26 #include <sal/types.h>
  27
  28 #include <rtl/crc.h>
  29 #include <rtl/ref.hxx>
  30
  31 #include <osl/diagnose.h>
  32 #include <osl/endian.h>
  33
  34 #include <store/types.h>
  35
  36 #include <memory>
  37 #include <utility>
  38
  39 /** @file store common internals.
  40 */
  41
  42 namespace store
  43 {
  44
  45 #ifdef htons
  46 #undef htons
  47 #endif
  48 #ifdef ntohs
  49 #undef ntohs
  50 #endif
  51
  52 #ifdef htonl
  53 #undef htonl
  54 #endif
  55 #ifdef ntohl
  56 #undef ntohl
  57 #endif
  58
  59 #ifdef OSL_BIGENDIAN
  60 inline sal_uInt16 htons (sal_uInt16 h) { return OSL_SWAPWORD(h); }
  61 inline sal_uInt16 ntohs (sal_uInt16 n) { return OSL_SWAPWORD(n); }
  62
  63 inline sal_uInt32 htonl (sal_uInt32 h) { return OSL_SWAPDWORD(h); }
  64 inline sal_uInt32 ntohl (sal_uInt32 n) { return OSL_SWAPDWORD(n); }
  65 #else
  66 inline sal_uInt16 htons (sal_uInt16 h) { return h; }
  67 inline sal_uInt16 ntohs (sal_uInt16 n) { return n; }
  68
  69 inline sal_uInt32 htonl (sal_uInt32 h) { return h; }
  70 inline sal_uInt32 ntohl (sal_uInt32 n) { return n; }
  71 #endif /* OSL_BIGENDIAN */
  72
  73 struct OStorePageGuard
  74 {
  75     /** Representation.
  76      */
  77     sal_uInt32 m_nMagic;
  78     sal_uInt32 m_nCRC32;
  79
  80     /** Construction.
  81      */
  82     explicit OStorePageGuard (sal_uInt32 nMagic = 0)
  83         : m_nMagic (store::htonl(nMagic)),
  84           m_nCRC32 (store::htonl(0))
  85     {}
  86
  87     void swap (OStorePageGuard & rhs)
  88     {
  89         std::swap(m_nMagic, rhs.m_nMagic);
  90         std::swap(m_nCRC32, rhs.m_nCRC32);
  91     }
  92
  93     OStorePageGuard (OStorePageGuard const & rhs)
  94         : m_nMagic (rhs.m_nMagic),
  95           m_nCRC32 (rhs.m_nCRC32)
  96     {}
  97
  98     OStorePageGuard& operator= (const OStorePageGuard& rhs)
  99     {
 100         m_nMagic = rhs.m_nMagic;
 101         m_nCRC32 = rhs.m_nCRC32;
 102         return *this;
 103     }
 104
 105     /** Comparison.
 106      */
 107     bool operator== (const OStorePageGuard& rhs) const
 108     {
 109         return ((m_nMagic == rhs.m_nMagic) &&
 110                 (m_nCRC32 == rhs.m_nCRC32)    );
 111     }
 112 };
 113
 114 #define STORE_PAGE_NULL (sal_uInt32(~0))
 115
 116 struct OStorePageDescriptor
 117 {
 118     /** Representation.
 119      */
 120     sal_uInt32 m_nAddr;
 121     sal_uInt16 m_nSize;
 122     sal_uInt16 m_nUsed;
 123
 124     /** Construction.
 125      */
 126     explicit OStorePageDescriptor (
 127         sal_uInt32 nAddr,
 128         sal_uInt16 nSize,
 129         sal_uInt16 nUsed)
 130         : m_nAddr (store::htonl(nAddr)),
 131           m_nSize (store::htons(nSize)),
 132           m_nUsed (store::htons(nUsed))
 133     {}
 134
 135     void swap (OStorePageDescriptor & rhs)
 136     {
 137         std::swap(m_nAddr, rhs.m_nAddr);
 138         std::swap(m_nSize, rhs.m_nSize);
 139         std::swap(m_nUsed, rhs.m_nUsed);
 140     }
 141
 142     OStorePageDescriptor (const OStorePageDescriptor & rhs)
 143         : m_nAddr (rhs.m_nAddr),
 144           m_nSize (rhs.m_nSize),
 145           m_nUsed (rhs.m_nUsed)
 146     {}
 147
 148     OStorePageDescriptor & operator= (const OStorePageDescriptor & rhs)
 149     {
 150         m_nAddr = rhs.m_nAddr;
 151         m_nSize = rhs.m_nSize;
 152         m_nUsed = rhs.m_nUsed;
 153         return *this;
 154     }
 155
 156     /** Comparison.
 157      */
 158     bool operator== (const OStorePageDescriptor & rhs) const
 159     {
 160         return ((m_nAddr == rhs.m_nAddr) &&
 161                 (m_nSize == rhs.m_nSize)    );
 162     }
 163 };
 164
 165 struct OStorePageKey
 166 {
 167     /** Representation.
 168      */
 169     sal_uInt32 m_nLow;
 170     sal_uInt32 m_nHigh;
 171
 172     /** Construction.
 173      */
 174     explicit OStorePageKey (sal_uInt32 nLow = 0, sal_uInt32 nHigh = 0)
 175         : m_nLow  (store::htonl(nLow)),
 176           m_nHigh (store::htonl(nHigh))
 177     {}
 178
 179     /** Comparison.
 180      */
 181     bool operator== (const OStorePageKey & rhs) const
 182     {
 183         return ((m_nLow  == rhs.m_nLow ) &&
 184                 (m_nHigh == rhs.m_nHigh)    );
 185     }
 186
 187     bool operator< (const OStorePageKey & rhs) const
 188     {
 189         if (m_nHigh == rhs.m_nHigh)
 190             return (store::ntohl(m_nLow) < store::ntohl(rhs.m_nLow));
 191         else
 192             return (store::ntohl(m_nHigh) < store::ntohl(rhs.m_nHigh));
 193     }
 194 };
 195
 196 struct OStorePageLink
 197 {
 198     /** Representation.
 199      */
 200     sal_uInt32 m_nAddr;
 201
 202     /** Construction.
 203      */
 204     explicit OStorePageLink (sal_uInt32 nAddr = STORE_PAGE_NULL)
 205         : m_nAddr (store::htonl(nAddr))
 206     {}
 207
 208     void swap (OStorePageLink & rhs)
 209     {
 210         std::swap(m_nAddr, rhs.m_nAddr);
 211     }
 212
 213     OStorePageLink & operator= (sal_uInt32 nAddr)
 214     {
 215         m_nAddr = store::htonl(nAddr);
 216         return *this;
 217     }
 218
 219     /** Comparison.
 220      */
 221     bool operator== (const OStorePageLink & rhs) const
 222     {
 223         return (m_nAddr == rhs.m_nAddr);
 224     }
 225
 226     /** Operation.
 227      */
 228     sal_uInt32 location() const
 229     {
 230         return store::ntohl(m_nAddr);
 231     }
 232
 233 };
 234
 235 struct PageData
 236 {
 237     typedef OStorePageGuard      G;
 238     typedef OStorePageDescriptor D;
 239     typedef OStorePageLink       L;
 240
 241     /** Representation.
 242      */
 243     G m_aGuard;
 244     D m_aDescr;
 245     L m_aMarked;
 246     L m_aUnused;
 247
 248     /** theSize.
 249      */
 250     static const size_t     theSize     = sizeof(G) + sizeof(D) + 2 * sizeof(L);
 251     static const sal_uInt16 thePageSize = theSize;
 252     static_assert(STORE_MINIMUM_PAGESIZE >= thePageSize, "must be at least thePageSize");
 253
 254     /** location.
 255      */
 256     sal_uInt32 location() const
 257     {
 258         return store::ntohl(m_aDescr.m_nAddr);
 259     }
 260     void location (sal_uInt32 nAddr)
 261     {
 262         m_aDescr.m_nAddr = store::htonl(nAddr);
 263     }
 264
 265     /** size.
 266      */
 267     sal_uInt16 size() const
 268     {
 269         return store::ntohs(m_aDescr.m_nSize);
 270     }
 271
 272     /** type.
 273      */
 274     sal_uInt32 type() const
 275     {
 276         return store::ntohl(m_aGuard.m_nMagic);
 277     }
 278
 279     /** Allocation.
 280      */
 281     class Allocator_Impl;
 282     class Allocator : public virtual salhelper::SimpleReferenceObject
 283     {
 284     public:
 285         template< class T > T * construct()
 286         {
 287             void * page = nullptr; sal_uInt16 size = 0;
 288             if (allocate (&page, &size))
 289             {
 290                 return new(page) T(size);
 291             }
 292             return 0;
 293         }
 294
 295         bool allocate (void ** ppPage, sal_uInt16 * pnSize)
 296         {
 297             allocate_Impl (ppPage, pnSize);
 298             return ((*ppPage != nullptr) && (*pnSize != 0));
 299         }
 300
 301         void deallocate (void * pPage)
 302         {
 303             if (pPage != nullptr)
 304                 deallocate_Impl (pPage);
 305         }
 306
 307         static storeError createInstance (
 308             rtl::Reference< PageData::Allocator > & rxAllocator, sal_uInt16 nPageSize);
 309
 310     protected:
 311         virtual ~Allocator() override {}
 312
 313     private:
 314         /** Implementation (abstract).
 315          */
 316         virtual void allocate_Impl (void ** ppPage, sal_uInt16 * pnSize) = 0;
 317         virtual void deallocate_Impl (void * pPage) = 0;
 318     };
 319
 320     class Deallocate {
 321     public:
 322         explicit Deallocate(rtl::Reference<Allocator> const & allocator):
 323             allocator_(allocator) {};
 324
 325         void operator ()(void * page) const { allocator_->deallocate(page); }
 326
 327     private:
 328         rtl::Reference<Allocator> allocator_;
 329     };
 330
 331     static void* operator new (size_t, void * p) { return p; }
 332     static void  operator delete (void * , void *) {}
 333
 334     /** Construction.
 335      */
 336     explicit PageData (sal_uInt16 nPageSize = thePageSize)
 337         : m_aGuard(),
 338           m_aDescr(STORE_PAGE_NULL, nPageSize, thePageSize),
 339           m_aMarked(),
 340           m_aUnused()
 341     {}
 342
 343     void swap (PageData & rhs) // nothrow
 344     {
 345         m_aGuard.swap(rhs.m_aGuard);
 346         m_aDescr.swap(rhs.m_aDescr);
 347         m_aMarked.swap(rhs.m_aMarked);
 348         m_aUnused.swap(rhs.m_aUnused);
 349     }
 350
 351     PageData (PageData const & rhs) // nothrow
 352         : m_aGuard (rhs.m_aGuard),
 353           m_aDescr (rhs.m_aDescr),
 354           m_aMarked(rhs.m_aMarked),
 355           m_aUnused(rhs.m_aUnused)
 356     {}
 357
 358     PageData & operator= (PageData const & rhs) // nothrow
 359     {
 360         PageData tmp (rhs);
 361         swap (tmp);
 362         return *this;
 363     }
 364
 365     /** guard (external representation).
 366      */
 367     void guard (sal_uInt32 nAddr)
 368     {
 369         sal_uInt32 nCRC32 = rtl_crc32 (0, &m_aGuard.m_nMagic, sizeof(sal_uInt32));
 370         m_aDescr.m_nAddr = store::htonl(nAddr);
 371         nCRC32 = rtl_crc32 (nCRC32, &m_aDescr, static_cast<sal_uInt32>(theSize - sizeof(G)));
 372         m_aGuard.m_nCRC32 = store::htonl(nCRC32);
 373     }
 374
 375     /** verify (external representation).
 376      */
 377     storeError verify (sal_uInt32 nAddr) const
 378     {
 379         sal_uInt32 nCRC32 = rtl_crc32 (0, &m_aGuard.m_nMagic, sizeof(sal_uInt32));
 380         nCRC32 = rtl_crc32 (nCRC32, &m_aDescr, static_cast<sal_uInt32>(theSize - sizeof(G)));
 381         if (m_aGuard.m_nCRC32 != store::htonl(nCRC32))
 382             return store_E_InvalidChecksum;
 383         if (m_aDescr.m_nAddr != store::htonl(nAddr))
 384             return store_E_InvalidAccess;
 385         return store_E_None;
 386     }
 387
 388 };
 389
 390 template< class T >
 391 class PageHolderObject
 392 {
 393     /** Representation.
 394      */
 395     std::shared_ptr<PageData> m_xPage;
 396
 397     /** Checked cast.
 398      */
 399     template< class U >
 400     static bool isA (PageData const * p)
 401     {
 402         return ((p != nullptr) && (p->type() == U::theTypeId));
 403     }
 404
 405     template< class U >
 406     static U * dynamic_page_cast (PageData * p)
 407     {
 408         return isA<U>(p) ? static_cast<U*>(p) : 0;
 409     }
 410
 411     template< class U >
 412     static U const * dynamic_page_cast (PageData const * p)
 413     {
 414         return isA<U>(p) ? static_cast<U const *>(p) : 0;
 415     }
 416
 417 public:
 418     bool construct (rtl::Reference< PageData::Allocator > const & rxAllocator)
 419     {
 420         if ((m_xPage.get() == nullptr) && rxAllocator.is())
 421         {
 422             std::shared_ptr<PageData> tmp (rxAllocator->construct<T>(), PageData::Deallocate(rxAllocator));
 423             m_xPage.swap (tmp);
 424         }
 425         return (m_xPage.get() != nullptr);
 426     }
 427
 428     explicit PageHolderObject (std::shared_ptr<PageData> const & rxPage = std::shared_ptr<PageData>())
 429         : m_xPage (rxPage)
 430     {}
 431
 432     void swap (PageHolderObject<T> & rhs)
 433     {
 434         m_xPage.swap (rhs.m_xPage);
 435     }
 436
 437     PageHolderObject (PageHolderObject<T> const & rhs)
 438         : m_xPage (rhs.m_xPage)
 439     {}
 440
 441     PageHolderObject<T> & operator= (PageHolderObject<T> const & rhs)
 442     {
 443         PageHolderObject<T> tmp (rhs);
 444         this->swap (tmp);
 445         return *this;
 446     }
 447
 448     bool is() const
 449     {
 450         return (m_xPage.get() != nullptr);
 451     }
 452
 453     std::shared_ptr<PageData> & get() { return m_xPage; }
 454     std::shared_ptr<PageData> const & get() const { return m_xPage; }
 455
 456     T * operator->()
 457     {
 458         T * pImpl = dynamic_page_cast<T>(m_xPage.get());
 459         OSL_PRECOND(pImpl != nullptr, "store::PageHolder<T>::operator*(): Null pointer");
 460         return pImpl;
 461     }
 462
 463     T const * operator->() const
 464     {
 465         T const * pImpl = dynamic_page_cast<T>(m_xPage.get());
 466         OSL_PRECOND(pImpl != nullptr, "store::PageHolder<T>::operator*(): Null pointer");
 467         return pImpl;
 468     }
 469
 470     T & operator*()
 471     {
 472         T * pImpl = dynamic_page_cast<T>(m_xPage.get());
 473         OSL_PRECOND(pImpl != nullptr, "store::PageHolder<T>::operator*(): Null pointer");
 474         return (*pImpl);
 475     }
 476
 477     T const & operator*() const
 478     {
 479         T const * pImpl = dynamic_page_cast<T>(m_xPage.get());
 480         OSL_PRECOND(pImpl != nullptr, "store::PageHolder<T>::operator*(): Null pointer");
 481         return (*pImpl);
 482     }
 483
 484     static storeError guard (std::shared_ptr<PageData> const & rxPage, sal_uInt32 nAddr)
 485     {
 486         PageData * pHead = rxPage.get();
 487         if (!pHead)
 488             return store_E_InvalidAccess;
 489         pHead->guard(nAddr);
 490
 491         T * pImpl = dynamic_page_cast<T>(pHead);
 492         OSL_PRECOND(pImpl != nullptr, "store::PageHolder<T>::guard(): Null pointer");
 493         pImpl->guard();
 494
 495         return store_E_None;
 496     }
 497
 498     static storeError verify (std::shared_ptr<PageData> const & rxPage, sal_uInt32 nAddr)
 499     {
 500         PageData const * pHead = rxPage.get();
 501         if (!pHead)
 502             return store_E_InvalidAccess;
 503
 504         storeError eErrCode = pHead->verify(nAddr);
 505         if (eErrCode != store_E_None)
 506             return eErrCode;
 507
 508         T const * pImpl = dynamic_page_cast<T>(pHead);
 509         if (!pImpl)
 510             return store_E_WrongVersion;
 511
 512         return pImpl->verify();
 513     }
 514 };
 515
 516 class OStorePageObject
 517 {
 518     typedef PageData       page;
 519
 520 public:
 521     /** Allocation.
 522      */
 523     static void * operator new (size_t n)
 524     {
 525         return std::malloc(sal_uInt32(n));
 526     }
 527     static void operator delete (void * p)
 528     {
 529         std::free (p);
 530     }
 531
 532     /** State.
 533      */
 534     inline bool dirty() const;
 535     inline void clean();
 536     inline void touch();
 537
 538     /** Location.
 539      */
 540     inline sal_uInt32 location() const;
 541
 542 protected:
 543     /** Representation.
 544      */
 545     std::shared_ptr<PageData> m_xPage;
 546     bool       m_bDirty;
 547
 548     /** Construction.
 549      */
 550     explicit OStorePageObject (std::shared_ptr<PageData> const & rxPage)
 551         : m_xPage (rxPage), m_bDirty (false)
 552     {}
 553
 554     /** Destruction.
 555      */
 556     virtual ~OStorePageObject();
 557
 558 public:
 559     template< class U >
 560     PageHolderObject<U> makeHolder() const
 561     {
 562         return PageHolderObject<U>(m_xPage);
 563     }
 564
 565     template< class U >
 566     storeError construct (rtl::Reference< PageData::Allocator > const & rxAllocator)
 567     {
 568         if (!rxAllocator.is())
 569             return store_E_InvalidAccess;
 570
 571         std::shared_ptr<PageData> tmp (rxAllocator->construct<U>(), PageData::Deallocate(rxAllocator));
 572         if (!tmp.get())
 573             return store_E_OutOfMemory;
 574
 575         m_xPage.swap (tmp);
 576         return store_E_None;
 577     }
 578
 579     std::shared_ptr<PageData> & get() { return m_xPage; }
 580
 581     virtual storeError guard  (sal_uInt32 nAddr) = 0;
 582     virtual storeError verify (sal_uInt32 nAddr) const = 0;
 583 };
 584
 585 inline bool OStorePageObject::dirty() const
 586 {
 587     return m_bDirty;
 588 }
 589
 590 inline void OStorePageObject::clean()
 591 {
 592     m_bDirty = false;
 593 }
 594
 595 inline void OStorePageObject::touch()
 596 {
 597     m_bDirty = true;
 598 }
 599
 600 inline sal_uInt32 OStorePageObject::location() const
 601 {
 602     return m_xPage->location();
 603 }
 604
 605 } // namespace store
 606
 607 #endif // INCLUDED_STORE_SOURCE_STORBASE_HXX
 608
 609 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */