partition_driver.hpp

#if !defined(__PARTITION_DRIVER_HPP__)
#define __PARTITION_DRIVER_HPP__

//
// local includes
//
#include "core/drivers/block/partitions/partitions.hpp"
#include "block_driver.hpp"

struct partition_driver : public block_driver, private noncopyable
{
    static const uint16_t DEFAULT_PARTITION_TYPE = 0x83;
    static const uint16_t START_SECTORS          = 30;
    static const uint16_t END_SECTORS            = 30;

  protected:
    static const efi::guid_t DUMMY_GUID;
    static const uint32_t DUMMY_UID;

    const uint16_t partition_type;

    block_driver * const driver;
    const l4_sector_t driver_start_lba;
    const l4_sector_t driver_end_lba;

    const l4_sector_t size;
    uint8_t start_sectors[START_SECTORS * SECTOR_SIZE];
    uint8_t end_sectors[END_SECTORS * SECTOR_SIZE];

  public:
    //
    // constructor & destructor
    //
    inline partition_driver(block_driver *driver,
                            const uint16_t partition_type=DEFAULT_PARTITION_TYPE)
        : partition_type(partition_type), driver(driver), driver_start_lba(START_SECTORS),
          driver_end_lba(START_SECTORS + (driver ? driver->sectors() : 0) - 1),
          size(driver ? START_SECTORS + driver->sectors() + END_SECTORS : 0)
    {
        if (is(READY))
            if (build_fake_sectors()) log::error("%s: disabled\n", name());
    }

    virtual inline ~partition_driver(void)
    {
        delete driver;
    }

    virtual inline int reset(void)
    {
        return driver ? driver->reset() : -L4_ENOTAVAIL;
    }

    //
    // block_driver: override name
    //
    virtual inline const char *name(void) const
    {
        return driver ? driver->name() : L4VMM_DRIVER" uninitialized partition driver";
    }

    //
    // block_driver: override state management functions
    //
    virtual inline bool is(const state_flags flags) const
    {
        return driver ? driver->is(flags) : false;
    }

    virtual inline const state_flags state(void) const
    {
        return driver ? driver->state() : static_cast<state_flags>(0);
    }

    //
    // block_driver: override medium functions
    //
    virtual inline l4_sector_t sectors(void) const
    {
        // return modified size
        return is(READY) ? size : 0;
    }

    virtual inline int read_sectors(uint8_t *buffer, l4_sector_t sector, l4_sector_t number)
    {
        return read_write_sectors(1, buffer, sector, number);
    }

    virtual inline int write_sectors(uint8_t *buffer, l4_sector_t sector, l4_sector_t number)
    {
        return read_write_sectors(0, buffer, sector, number);
    }

    virtual inline int flush_sectors(void)
    {
        return driver ? driver->flush_sectors() : -L4_ENOTAVAIL;
    }

  protected:
    virtual inline bool is_valid_partition(l4_sector_t start_lba, l4_sector_t end_lba)
    {
        return (start_lba >= driver_start_lba) && (end_lba >= driver_start_lba) &&
               (start_lba <= driver_end_lba)   && (end_lba <= driver_end_lba)   &&
               (start_lba <= end_lba);
    }

    virtual int write_mbr(uint8_t type, l4_sector_t start_lba, l4_sector_t end_lba, uint8_t attributes=0);

    virtual int write_gpt(uint8_t type, l4_sector_t start_lba, l4_sector_t end_lba, uint64_t attributes=0);

    virtual int build_fake_sectors(void);

    int read_write_sectors(uint8_t read_write, uint8_t *buffer, l4_sector_t sector, l4_sector_t number);
};

#endif

// ***** end of source ***** //