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 #pragma once
  21
  22 #include <sal/config.h>
  23 #include <salhelper/simplereferenceobject.hxx>
  24
  25 #include <sal/types.h>
  26
  27 #include <rtl/crc.h>
  28 #include <rtl/ref.hxx>
  29
  30 #include <osl/diagnose.h>
  31 #include <osl/endian.h>
  32
  33 #include <store/types.h>
  34
  35 #include <memory>
  36 #include <utility>
  37
  38 /** @file store common internals.
  39 */
  40
  41 namespace store
  42 {
  43
  44 #ifdef htons
  45 #undef htons
  46 #endif
  47 #ifdef ntohs
  48 #undef ntohs
  49 #endif
  50
  51 #ifdef htonl
  52 #undef htonl
  53 #endif
  54 #ifdef ntohl
  55 #undef ntohl
  56 #endif
  57
  58 #ifdef OSL_BIGENDIAN
  59 inline sal_uInt16 htons (sal_uInt16 h) { return OSL_SWAPWORD(h); }
  60 inline sal_uInt16 ntohs (sal_uInt16 n) { return OSL_SWAPWORD(n); }
  61
  62 inline sal_uInt32 htonl (sal_uInt32 h) { return OSL_SWAPDWORD(h); }
  63 inline sal_uInt32 ntohl (sal_uInt32 n) { return OSL_SWAPDWORD(n); }
  64 #else
  65 inline sal_uInt16 htons (sal_uInt16 h) { return h; }
  66 inline sal_uInt16 ntohs (sal_uInt16 n) { return n; }
  67
  68 inline sal_uInt32 htonl (sal_uInt32 h) { return h; }
  69 inline sal_uInt32 ntohl (sal_uInt32 n) { return n; }
  70 #endif /* OSL_BIGENDIAN */
  71
  72 struct OStorePageGuard
  73 {
  74     /** Representation.
  75      */
  76     sal_uInt32 m_nMagic;
  77     sal_uInt32 m_nCRC32;
  78
  79     /** Construction.
  80      */
  81     explicit OStorePageGuard (sal_uInt32 nMagic = 0)
  82         : m_nMagic (store::htonl(nMagic)),
  83           m_nCRC32 (store::htonl(0))
  84     {}
  85
  86     void swap (OStorePageGuard & rhs)
  87     {
  88         std::swap(m_nMagic, rhs.m_nMagic);
  89         std::swap(m_nCRC32, rhs.m_nCRC32);
  90     }
  91
  92     OStorePageGuard (OStorePageGuard const & rhs)
  93         : m_nMagic (rhs.m_nMagic),
  94           m_nCRC32 (rhs.m_nCRC32)
  95     {}
  96
  97     OStorePageGuard& operator= (const OStorePageGuard& rhs)
  98     {
  99         m_nMagic = rhs.m_nMagic;
 100         m_nCRC32 = rhs.m_nCRC32;
 101         return *this;
 102     }
 103
 104     /** Comparison.
 105      */
 106     bool operator== (const OStorePageGuard& rhs) const
 107     {
 108         return ((m_nMagic == rhs.m_nMagic) &&
 109                 (m_nCRC32 == rhs.m_nCRC32)    );
 110     }
 111 };
 112
 113 #define STORE_PAGE_NULL (sal_uInt32(~0))
 114
 115 struct OStorePageDescriptor
 116 {
 117     /** Representation.
 118      */
 119     sal_uInt32 m_nAddr;
 120     sal_uInt16 m_nSize;
 121     sal_uInt16 m_nUsed;
 122
 123     /** Construction.
 124      */
 125     explicit OStorePageDescriptor (
 126         sal_uInt32 nAddr,
 127         sal_uInt16 nSize,
 128         sal_uInt16 nUsed)
 129         : m_nAddr (store::htonl(nAddr)),
 130           m_nSize (store::htons(nSize)),
 131           m_nUsed (store::htons(nUsed))
 132     {}
 133
 134     void swap (OStorePageDescriptor & rhs)
 135     {
 136         std::swap(m_nAddr, rhs.m_nAddr);
 137         std::swap(m_nSize, rhs.m_nSize);
 138         std::swap(m_nUsed, rhs.m_nUsed);
 139     }
 140
 141     OStorePageDescriptor (const OStorePageDescriptor & rhs)
 142         : m_nAddr (rhs.m_nAddr),
 143           m_nSize (rhs.m_nSize),
 144           m_nUsed (rhs.m_nUsed)
 145     {}
 146
 147     OStorePageDescriptor & operator= (const OStorePageDescriptor & rhs)
 148     {
 149         m_nAddr = rhs.m_nAddr;
 150         m_nSize = rhs.m_nSize;
 151         m_nUsed = rhs.m_nUsed;
 152         return *this;
 153     }
 154
 155     /** Comparison.
 156      */
 157     bool operator== (const OStorePageDescriptor & rhs) const
 158     {
 159         return ((m_nAddr == rhs.m_nAddr) &&
 160                 (m_nSize == rhs.m_nSize)    );
 161     }
 162 };
 163
 164 struct OStorePageKey
 165 {
 166     /** Representation.
 167      */
 168     sal_uInt32 m_nLow;
 169     sal_uInt32 m_nHigh;
 170
 171     /** Construction.
 172      */
 173     explicit OStorePageKey (sal_uInt32 nLow = 0, sal_uInt32 nHigh = 0)
 174         : m_nLow  (store::htonl(nLow)),
 175           m_nHigh (store::htonl(nHigh))
 176     {}
 177
 178     /** Comparison.
 179      */
 180     bool operator== (const OStorePageKey & rhs) const
 181     {
 182         return ((m_nLow  == rhs.m_nLow ) &&
 183                 (m_nHigh == rhs.m_nHigh)    );
 184     }
 185
 186     bool operator< (const OStorePageKey & rhs) const
 187     {
 188         if (m_nHigh == rhs.m_nHigh)
 189             return (store::ntohl(m_nLow) < store::ntohl(rhs.m_nLow));
 190         else
 191             return (store::ntohl(m_nHigh) < store::ntohl(rhs.m_nHigh));
 192     }
 193 };
 194
 195 struct OStorePageLink
 196 {
 197     /** Representation.
 198      */
 199     sal_uInt32 m_nAddr;
 200
 201     /** Construction.
 202      */
 203     explicit OStorePageLink (sal_uInt32 nAddr = STORE_PAGE_NULL)
 204         : m_nAddr (store::htonl(nAddr))
 205     {}
 206
 207     void swap (OStorePageLink & rhs)
 208     {
 209         std::swap(m_nAddr, rhs.m_nAddr);
 210     }
 211
 212     OStorePageLink & operator= (sal_uInt32 nAddr)
 213     {
 214         m_nAddr = store::htonl(nAddr);
 215         return *this;
 216     }
 217
 218     /** Comparison.
 219      */
 220     bool operator== (const OStorePageLink & rhs) const
 221     {
 222         return (m_nAddr == rhs.m_nAddr);
 223     }
 224
 225     /** Operation.
 226      */
 227     sal_uInt32 location() const
 228     {
 229         return store::ntohl(m_nAddr);
 230     }
 231
 232 };
 233
 234 struct PageData
 235 {
 236     typedef OStorePageGuard      G;
 237     typedef OStorePageDescriptor D;
 238     typedef OStorePageLink       L;
 239
 240     /** Representation.
 241      */
 242     G m_aGuard;
 243     D m_aDescr;
 244     L m_aMarked;
 245     L m_aUnused;
 246
 247     /** theSize.
 248      */
 249     static const size_t     theSize     = sizeof(G) + sizeof(D) + 2 * sizeof(L);
 250     static const sal_uInt16 thePageSize = theSize;
 251     static_assert(STORE_MINIMUM_PAGESIZE >= thePageSize, "must be at least thePageSize");
 252
 253     /** location.
 254      */
 255     sal_uInt32 location() const
 256     {
 257         return store::ntohl(m_aDescr.m_nAddr);
 258     }
 259     void location (sal_uInt32 nAddr)
 260     {
 261         m_aDescr.m_nAddr = store::htonl(nAddr);
 262     }
 263
 264     /** size.
 265      */
 266     sal_uInt16 size() const
 267     {
 268         return store::ntohs(m_aDescr.m_nSize);
 269     }
 270
 271     /** type.
 272      */
 273     sal_uInt32 type() const
 274     {
 275         return store::ntohl(m_aGuard.m_nMagic);
 276     }
 277
 278     /** Allocation.
 279      */
 280     class Allocator_Impl;
 281     class Allocator : public virtual salhelper::SimpleReferenceObject
 282     {
 283     public:
 284         template< class T > T * construct()
 285         {
 286             void * page = nullptr;
 287             sal_uInt16 nSize = 0;
 288             if (allocate (&page, &nSize))
 289             {
 290                 return new(page) T(nSize);
 291             }
 292             return nullptr;
 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> allocator):
 323             allocator_(std::move(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) : nullptr;
 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) : nullptr;
 415     }
 416
 417 public:
 418     bool construct (rtl::Reference< PageData::Allocator > const & rxAllocator)
 419     {
 420         if (!m_xPage && rxAllocator.is())
 421         {
 422             std::shared_ptr<PageData> tmp (rxAllocator->construct<T>(), PageData::Deallocate(rxAllocator));
 423             m_xPage.swap (tmp);
 424         }
 425         return bool(m_xPage);
 426     }
 427
 428     explicit PageHolderObject (std::shared_ptr<PageData> xPage = std::shared_ptr<PageData>())
 429         : m_xPage (std::move(xPage))
 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 bool(m_xPage);
 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>  rxPage)
 551         : m_xPage (std::move(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)
 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 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */