mirror of
https://github.com/justinian/jsix.git
synced 2025-12-10 00:14:32 -08:00
0ae489f49d
Updating the build to the new version of bonnibel. This also includes some updates to make sure things keep working with LLVM 11.
115 lines
2.9 KiB
C++
115 lines
2.9 KiB
C++
#include "kutil/assert.h"
|
|
#include "kutil/guid.h"
|
|
#include "kutil/memory.h"
|
|
#include "device_manager.h"
|
|
#include "fs/gpt.h"
|
|
#include "log.h"
|
|
|
|
namespace fs {
|
|
|
|
const kutil::guid efi_system_part = kutil::make_guid(0xC12A7328, 0xF81F, 0x11D2, 0xBA4B, 0x00A0C93EC93B);
|
|
const kutil::guid efi_unused_part = kutil::make_guid(0, 0, 0, 0, 0);
|
|
|
|
const uint64_t gpt_signature = 0x5452415020494645; // "EFI PART"
|
|
const size_t block_size = 512;
|
|
|
|
struct gpt_header
|
|
{
|
|
uint64_t signature;
|
|
uint32_t revision;
|
|
uint32_t headersize;
|
|
uint32_t crc32;
|
|
uint32_t reserved;
|
|
uint64_t my_lba;
|
|
uint64_t alt_lba;
|
|
uint64_t first_usable_lba;
|
|
uint64_t last_usable_lba;
|
|
kutil::guid disk_guid;
|
|
uint64_t table_lba;
|
|
uint32_t entry_count;
|
|
uint32_t entry_length;
|
|
uint32_t table_crc32;
|
|
} __attribute__ ((packed));
|
|
|
|
struct gpt_entry
|
|
{
|
|
kutil::guid type;
|
|
kutil::guid part_guid;
|
|
uint64_t start_lba;
|
|
uint64_t end_lba;
|
|
uint64_t attributes;
|
|
uint16_t name_wide[36];
|
|
} __attribute__ ((packed));
|
|
|
|
|
|
partition::partition(block_device *parent, size_t start, size_t length) :
|
|
m_parent(parent),
|
|
m_start(start),
|
|
m_length(length)
|
|
{
|
|
}
|
|
|
|
size_t
|
|
partition::read(size_t offset, size_t length, void *buffer)
|
|
{
|
|
if (offset + length > m_length)
|
|
offset = m_length - offset;
|
|
return m_parent->read(m_start + offset, length, buffer);
|
|
}
|
|
|
|
|
|
unsigned
|
|
partition::load(block_device *device)
|
|
{
|
|
// Read LBA 1
|
|
uint8_t block[block_size];
|
|
size_t count = device->read(block_size, block_size, &block);
|
|
kassert(count == block_size, "Short read for GPT header.");
|
|
|
|
gpt_header *header = reinterpret_cast<gpt_header *>(&block);
|
|
if (header->signature != gpt_signature)
|
|
return 0;
|
|
|
|
size_t arraysize = header->entry_length * header->entry_count;
|
|
log::debug(logs::fs, "Found GPT header: %d paritions, size 0x%lx",
|
|
header->entry_count, arraysize);
|
|
|
|
uint8_t *array = new uint8_t[arraysize];
|
|
count = device->read(block_size * header->table_lba, arraysize, array);
|
|
kassert(count == arraysize, "Short read for GPT entry array.");
|
|
|
|
auto &dm = device_manager::get();
|
|
|
|
unsigned found = 0;
|
|
gpt_entry *entry0 = reinterpret_cast<gpt_entry *>(array);
|
|
for (uint32_t i = 0; i < header->entry_count; ++i) {
|
|
gpt_entry *entry = kutil::offset_pointer(entry0, i * header->entry_length);
|
|
if (entry->type == efi_unused_part) continue;
|
|
|
|
// TODO: real UTF16->UTF8
|
|
char name[sizeof(gpt_entry::name_wide) / 2];
|
|
for (int i = 0; i < sizeof(name); ++i)
|
|
name[i] = entry->name_wide[i];
|
|
|
|
log::debug(logs::fs, "Found partition %02x at %lx-%lx", i, entry->start_lba, entry->end_lba);
|
|
if (entry->type == efi_system_part)
|
|
log::debug(logs::fs, " type EFI SYSTEM PARTITION");
|
|
else
|
|
log::debug(logs::fs, " type %G", entry->type);
|
|
log::debug(logs::fs, " name %s", name);
|
|
log::debug(logs::fs, " attr %016lx", entry->attributes);
|
|
|
|
found += 1;
|
|
partition *part = new partition(
|
|
device,
|
|
entry->start_lba * block_size,
|
|
(entry->end_lba - entry->start_lba) * block_size);
|
|
dm.register_block_device(part);
|
|
}
|
|
|
|
return found;
|
|
}
|
|
|
|
|
|
} // namespace fs
|