gpt.hpp

#if !defined(__GPT_HPP__)
#define __GPT_HPP__

//
// local includes
//
#include "efi.hpp"

struct gpt : public efi
{
    static const uint64_t SIGNATURE   = 0x5452415020494645ull;
    static const uint32_t REVISION    = 0x00010000ul;
    static const uint16_t HEADER_SIZE = 128;

    struct __packed(header_fields)
    {
        le_uint64_t signature;              
        le_uint32_t revision;               
        le_uint32_t header_size;            
        le_uint32_t header_crc32;           
        le_uint32_t reserved0;              
        le_uint64_t header_lba;             
        le_uint64_t alternate_header_lba;   
        le_uint64_t first_usable_lba;       
        le_uint64_t last_usable_lba;        
        guid_t      disk_guid;              
        le_uint64_t entries_lba;            
        le_uint32_t entries_number;         
        le_uint32_t entries_size;           
        le_uint32_t entries_crc32;          
    };

    struct __packed(header) : public header_fields
    {
        uint8_t fill5c[HEADER_SIZE - sizeof(header_fields)];

        inline header(void)
        {
            memset(this, 0, sizeof(header));
        }

        header(const guid_t disk_guid, uint64_t header_lba, uint64_t alternate_header_lba,
               uint64_t first_usable_lba, uint64_t last_usable_lba,
               uint64_t entries_lba, uint32_t entries_number, uint32_t entries_crc32);

        inline bool is_valid(void) const
        {
            return (signature == SIGNATURE) && (revision == REVISION);
        }
    };

    // internal requirement
    static_assert(sizeof(header) == HEADER_SIZE, "wrong header size");
    // mandated by the EFI specification
    static_assert(sizeof(header) <= 512, "header size must be smaller than or equal to a sector");
    static_assert((512 % sizeof(header)) == 0, "wrong header size");

    struct __packed(entry)
    {
        guid_t      type_guid;              
        guid_t      partition_guid;         
        le_uint64_t start_lba;              
        le_uint64_t end_lba;                
        le_uint64_t attributes;             

        uchar_t     name[72 / sizeof(uchar_t)];

        inline entry(void)
        {
            memset(this, 0, sizeof(entry));
        }

        entry(const guid_t type_guid, const guid_t partition_guid, uint64_t start_lba,
              uint64_t end_lba, uint64_t attributes=0, const uchar_t *name=nullptr);

        inline bool is_used(void) const
        {
            return !is_null_guid(type_guid);
        }

        inline bool is_valid(const uint64_t first_lba, const uint64_t last_lba) const
        {
            // an unused entry must be valid
            return (start_lba >= first_lba) && (start_lba <= last_lba) &&
                   (end_lba >= first_lba) && (end_lba <= last_lba) && (start_lba <= end_lba);
        }

        inline bool overlaps(const entry &other) const
        {
            return (start_lba <= other.end_lba) && (other.start_lba <= end_lba);
        }
    };

    // mandated by the EFI specification
    static_assert((512 % sizeof(entry)) == 0, "wrong entry size");
};

#endif

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