Partition.h

/*
 * Copyright (c) 2008-2014, Pedigree Developers
 *
 * Please see the CONTRIB file in the root of the source tree for a full
 * list of contributors.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
#ifndef PARTITION_H
#define PARTITION_H
 
#include "pedigree/kernel/LockGuard.h"
#include "pedigree/kernel/TargetInfo.h"
#include "pedigree/kernel/machine/Disk.h"
#include "pedigree/kernel/process/Mutex.h"
#include "pedigree/kernel/processor/types.h"
#include "pedigree/kernel/utilities/StaticString.h"
#include "pedigree/kernel/utilities/String.h"
 
class Partition : public Disk {
 public:
  Partition(const String& type, uint64_t start, uint64_t length);
  virtual ~Partition() override;
 
  virtual void getName(String& str) override {
    NormalStaticString str2;
    str2 += m_Type;
    str2 += " partition";
    str.assign(str2, str2.length());
  }
 
  virtual void dump(String& str) override {
    LargeStaticString str2;
    str2 += m_Type;
    str2 += " partition at 0x";
    str2.append(m_Start, 16);
    str2 += "-";
    str2.append(m_Start + m_Length, 16);
    str.assign(str2, str2.length());
  }
 
  virtual BufferView read(uint64_t location) override {
    if (!containsCachePage(location))
      return BufferView();
 
    Disk* pParent = static_cast<Disk*>(getParent());
 
    ensureAligned(pParent);
 
    BufferView view = pParent->read(location + m_Start);
    if (!view) {
      return BufferView();
    }
 
    const uint64_t remaining = m_Length - location;
    return remaining < view.size() ? view.first(static_cast<size_t>(remaining)) : view;
  }
 
  bool zero(uint64_t location, size_t length) override {
    if (!containsRange(location, length))
      return false;
    auto* parent = static_cast<Disk*>(getParent());
    ensureAligned(parent);
    return parent->zero(m_Start + location, length);
  }
 
  DiskReadView readView(uint64_t location) override {
    if (!containsRange(location, 1))
      return {};
    auto* parent = static_cast<Disk*>(getParent());
    ensureAligned(parent);
    auto view = parent->readView(m_Start + location);
    if (view && m_Length - location < view.size())
      view.truncate(static_cast<size_t>(m_Length - location));
    return view;
  }
 
  DiskWriteView writeView(uint64_t location) override {
    if (!containsRange(location, 1))
      return {};
    auto* parent = static_cast<Disk*>(getParent());
    ensureAligned(parent);
    auto view = parent->writeView(m_Start + location);
    if (view && m_Length - location < view.size())
      view.truncate(static_cast<size_t>(m_Length - location));
    return view;
  }
 
  virtual void write(uint64_t location) override {
    if (!containsCachePage(location))
      return;
 
    Disk* pParent = static_cast<Disk*>(getParent());
 
    ensureAligned(pParent);
 
    pParent->write(location + m_Start);
  }
 
  virtual void flush(uint64_t location) override {
    if (!containsCachePage(location))
      return;
 
    Disk* pParent = static_cast<Disk*>(getParent());
 
    ensureAligned(pParent);
 
    pParent->flush(location + m_Start);
  }
 
  MUST_USE_RESULT virtual bool retireCachePage(uint64_t location) override {
    if (!containsCachePage(location))
      return false;
 
    Disk* pParent = static_cast<Disk*>(getParent());
 
    ensureAligned(pParent);
 
    return pParent->retireCachePage(location + m_Start);
  }
 
  virtual bool sync(uint64_t location, bool async) override {
    if (!containsCachePage(location))
      return false;
 
    Disk* parent = static_cast<Disk*>(getParent());
    ensureAligned(parent);
    return parent->sync(location + m_Start, async);
  }
 
  MUST_USE_RESULT bool syncPages(const uint64_t* locations, size_t count) override;
 
  bool readInto(uint64_t location, void* buffer, size_t length) override;
  bool readIntoBatch(ReadBuffer* buffers, size_t count) override;
  bool writeFrom(uint64_t location, const void* buffer, size_t length) override;
  bool writeFromBatch(WriteBuffer* buffers, size_t count) override;
  bool syncData() override;
 
  MUST_USE_RESULT virtual bool syncAll() override;
 
  Disk* physicalDisk() override {
    Disk* parent = static_cast<Disk*>(getParent());
    return parent ? parent->physicalDisk() : nullptr;
  }
 
  virtual size_t getSize() const override {
    return getLength();
  }
 
  virtual size_t getBlockSize() const override {
    const Disk* pParent = static_cast<const Disk*>(getParent());
    return pParent->getBlockSize();
  }
 
  size_t getNativeBlockSize() const override {
    const Disk* parent = static_cast<const Disk*>(getParent());
    return parent ? parent->getNativeBlockSize() : 0;
  }
 
  virtual bool pin(uint64_t location) override {
    if (!containsCachePage(location))
      return false;
    Disk* pParent = static_cast<Disk*>(getParent());
    ensureAligned(pParent);
    return pParent->pin(location + m_Start);
  }
 
  virtual void unpin(uint64_t location) override {
    if (!containsCachePage(location))
      return;
    Disk* pParent = static_cast<Disk*>(getParent());
    pParent->unpin(location + m_Start);
  }
 
  uint64_t getStart();
 
  uint64_t getLength() const {
    return m_Length;
  }
 
  const String& getPartitionType() const {
    return m_Type;
  }
 
  void setPartitionIdentity(const String& uuid, const String& label) {
    m_Uuid = uuid;
    m_Label = label;
  }
 
  bool getPartitionUuid(String& uuid) const override {
    uuid = m_Uuid;
    return uuid.length() != 0;
  }
 
  bool getPartitionLabel(String& label) const override {
    label = m_Label;
    return label.length() != 0;
  }
 
 private:
  bool containsRange(uint64_t location, size_t length) const;
 
  bool containsCachePage(uint64_t location) const {
    if (location >= m_Length) {
      return false;
    }
 
    const uint64_t pageSize = TargetInfo::getPageSize();
    const uint64_t pageLocation = location - (location % pageSize);
    return pageSize <= (m_Length - pageLocation);
  }
 
  void ensureAligned(Disk* pParent) {
    LockGuard<Mutex> guard(m_AlignmentLock);
    if (!m_bAligned) {
      // A partition-relative page must map to one parent cache page even
      // when the partition begins in the middle of a physical page.
      pParent->align(m_Start);
      m_bAligned = true;
    }
  }
 
  String m_Type;
  String m_Uuid;
  String m_Label;
  uint64_t m_Start;
  uint64_t m_Length;
  Mutex m_AlignmentLock;
  bool m_bAligned;
};
 
#endif