406 lines
17 KiB
C
406 lines
17 KiB
C
/* gpt_write.h — Deshab 共享 GPT 写库（static inline，无库）
|
||
*
|
||
* 前置条件：包含者已定义 u8/u16/u32/u64/i64 基础类型。
|
||
* 通过 gpt_init() 注入 block_read/block_write 函数指针（签名与 f32 库一致）。
|
||
*
|
||
* 能力：
|
||
* gpt_probe() — 读 LBA1 校验 "EFI PART" 签名 + header CRC（轻量探测）
|
||
* gpt_load() — 加载 GPT 头 + 分区表到内部缓冲，并做 CRC 校验
|
||
* gpt_find_esp() — 查找 ESP 分区（type GUID c12a7328-...），输出起始/结束 LBA
|
||
* gpt_find_part() — 按任意 type GUID 查找分区
|
||
* gpt_update_esp() — 新增/更新 ESP 分区项（改起始/结束 LBA）
|
||
* gpt_commit() — 重算 entries CRC + 双 header CRC，写主表/备份表/主头/备份头
|
||
* gpt_blank_disk() — 全新初始化：protective MBR + 空 GPT（主+备份，无分区）
|
||
*
|
||
* 与 build.ps1（New-GptHeader / New-GptFat32Image）字节兼容：
|
||
* LBA0 protective MBR（type 0xEE），LBA1 主头，LBA2 主表（128×128B = 32 扇区），
|
||
* 备份表 lastLba-32，备份头 lastLba。GUID 按 .NET Guid.ToByteArray()
|
||
* little-endian 编码（前三组小端、后两组原序）。
|
||
* CRC32 为 IEEE 802.3（init 0xFFFFFFFF / poly 0xEDB88320 / xorout 0xFFFFFFFF），
|
||
* 与 build.ps1 Get-Crc32 逐位实现等价。
|
||
*
|
||
* 缓冲：包含者需提供 ~16.5KB BSS（1 扇区头缓冲 + 32 扇区分区表缓冲）。
|
||
*
|
||
* 典型流程（FirstInit 写盘 / 系统格式化）：
|
||
* gpt_init(block_read, block_write);
|
||
* if (gpt_probe() != 0) gpt_blank_disk(total_sectors, NULL); // 空盘初始化
|
||
* gpt_load();
|
||
* gpt_update_esp(2048, total_sectors - 34); // 或扩容
|
||
* gpt_commit();
|
||
*/
|
||
|
||
#ifndef DESHAB_GPT_WRITE_H
|
||
#define DESHAB_GPT_WRITE_H
|
||
|
||
/* ---- block 设备函数类型（与 fat32_io.h 签名一致，index 固定 0） ---- */
|
||
typedef int (*gpt_block_read_fn)(u32 index, u64 lba, u32 count, void *buf);
|
||
typedef int (*gpt_block_write_fn)(u32 index, u64 lba, u32 count, const void *buf);
|
||
|
||
static gpt_block_read_fn gpt_blk_read = 0;
|
||
static gpt_block_write_fn gpt_blk_write = 0;
|
||
|
||
/* ---- GPT 常量（与 build.ps1 一致） ---- */
|
||
#define GPT_SIG_BYTES 8
|
||
#define GPT_ENTRIES 128u
|
||
#define GPT_ENTRY_SIZE 128u
|
||
#define GPT_ENTRY_SECTORS 32u /* 128×128 / 512 */
|
||
#define GPT_FIRST_USABLE 34u /* 2 + 32 */
|
||
#define GPT_HEADER_SIZE 92u
|
||
#define GPT_REVISION 0x00010000u
|
||
#define GPT_MBR_PART_OFF 446 /* protective MBR 分区项偏移 */
|
||
|
||
/* ---- GPT 头（512B，build.ps1 Set-Le* 布局） ---- */
|
||
typedef struct __attribute__((packed)) {
|
||
u8 sig[8]; /* "EFI PART" */
|
||
u32 revision; /* 0x00010000 */
|
||
u32 header_size; /* 92 */
|
||
u32 header_crc;
|
||
u32 reserved0;
|
||
u64 current_lba; /* 主头=1，备份头=lastLba */
|
||
u64 backup_lba;
|
||
u64 first_usable; /* 34 */
|
||
u64 last_usable; /* lastLba - 33 */
|
||
u8 disk_guid[16];
|
||
u64 entries_lba; /* 主表=2，备份表=lastLba-32 */
|
||
u32 entries_count; /* 128 */
|
||
u32 entries_size; /* 128 */
|
||
u32 entries_crc;
|
||
u8 reserved[420];
|
||
} gpt_header; /* 512B */
|
||
|
||
/* ---- 分区项（128B） ---- */
|
||
typedef struct __attribute__((packed)) {
|
||
u8 type_guid[16]; /* 全 0 = 空槽 */
|
||
u8 uniq_guid[16];
|
||
u64 first_lba;
|
||
u64 last_lba;
|
||
u64 attrs;
|
||
u16 name[36]; /* UTF-16LE，未用部分为 0 */
|
||
} gpt_part_entry;
|
||
|
||
/* ESP 类型 GUID：c12a7328-f81f-11d2-ba4b-00a0c93ec93b
|
||
* （.NET Guid.ToByteArray() 编码：前三组小端、后两组原序） */
|
||
static const u8 gpt_guid_esp[16] = {
|
||
0x28, 0x73, 0x2a, 0xc1, /* c12a7328 */
|
||
0x1f, 0xf8, /* f81f */
|
||
0xd2, 0x11, /* 11d2 */
|
||
0xba, 0x4b, 0x00, 0xa0, 0xc9, 0x3e, 0xc9, 0x3b
|
||
};
|
||
|
||
/* ---- 内部缓冲（每包含者独立） ---- */
|
||
static u8 gpt_sec[512]; /* 单扇区（头/MBR）缓冲 */
|
||
static u8 gpt_tbl[GPT_ENTRY_SECTORS * 512]; /* 分区表缓冲（32 扇区） */
|
||
static u64 gpt_disk_sectors = 0; /* 磁盘总扇区数（探测后已知） */
|
||
|
||
/* ---- 初始化：注入 block_read/block_write 函数指针 ---- */
|
||
static inline void gpt_init(gpt_block_read_fn rd, gpt_block_write_fn wr) {
|
||
gpt_blk_read = rd;
|
||
gpt_blk_write = wr;
|
||
gpt_disk_sectors = 0;
|
||
}
|
||
|
||
static inline int gpt_read_sectors(u64 lba, u32 count, u8 *out) {
|
||
return gpt_blk_read ? gpt_blk_read(0, lba, count, out) : -1;
|
||
}
|
||
static inline int gpt_write_sectors(u64 lba, u32 count, const u8 *buf) {
|
||
return gpt_blk_write ? gpt_blk_write(0, lba, count, buf) : -1;
|
||
}
|
||
|
||
/* ---- 小工具（无库约束：手写循环替代 mem*） ---- */
|
||
static inline void gpt_mem_set(u8 *p, u8 v, u32 n) { for (u32 i = 0; i < n; i++) p[i] = v; }
|
||
static inline void gpt_mem_cpy(u8 *d, const u8 *s, u32 n) { for (u32 i = 0; i < n; i++) d[i] = s[i]; }
|
||
static inline int gpt_mem_eq(const u8 *a, const u8 *b, u32 n) {
|
||
for (u32 i = 0; i < n; i++) if (a[i] != b[i]) return 0;
|
||
return 1;
|
||
}
|
||
static inline u32 gpt_r32(const u8 *p) {
|
||
return (u32)p[0] | ((u32)p[1] << 8) | ((u32)p[2] << 16) | ((u32)p[3] << 24);
|
||
}
|
||
static inline void gpt_w16(u8 *p, u16 v) { p[0] = (u8)v; p[1] = (u8)(v >> 8); }
|
||
static inline void gpt_w32(u8 *p, u32 v) {
|
||
p[0] = (u8)v; p[1] = (u8)(v >> 8); p[2] = (u8)(v >> 16); p[3] = (u8)(v >> 24);
|
||
}
|
||
static inline void gpt_w64(u8 *p, u64 v) {
|
||
gpt_w32(p, (u32)v); gpt_w32(p + 4, (u32)(v >> 32));
|
||
}
|
||
|
||
/* ---- CRC32（IEEE 802.3，与 build.ps1 Get-Crc32 逐位实现等价；表驱动） ---- */
|
||
static u32 gpt_crc_tab[256];
|
||
static int gpt_crc_ready = 0;
|
||
|
||
static inline void gpt_crc_init(void) {
|
||
if (gpt_crc_ready) return;
|
||
for (u32 i = 0; i < 256; i++) {
|
||
u32 c = i;
|
||
for (int k = 0; k < 8; k++)
|
||
c = (c & 1) ? (c >> 1) ^ 0xEDB88320u : (c >> 1);
|
||
gpt_crc_tab[i] = c;
|
||
}
|
||
gpt_crc_ready = 1;
|
||
}
|
||
|
||
static inline u32 gpt_crc32(const u8 *p, u32 n) {
|
||
u32 crc = 0xFFFFFFFFu;
|
||
for (u32 i = 0; i < n; i++)
|
||
crc = (crc >> 8) ^ gpt_crc_tab[(crc ^ p[i]) & 0xFFu];
|
||
return crc ^ 0xFFFFFFFFu;
|
||
}
|
||
|
||
/* ---- GUID 工具 ---- */
|
||
|
||
/* "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" → 16B（.NET ToByteArray 编码）
|
||
* 返回 0 成功，-1 格式错误 */
|
||
static inline int gpt_guid_from_str(const char *s, u8 out[16]) {
|
||
static const int hex[256] = { ['0'] = 0, ['1'] = 1, ['2'] = 2, ['3'] = 3,
|
||
['4'] = 4, ['5'] = 5, ['6'] = 6, ['7'] = 7, ['8'] = 8, ['9'] = 9,
|
||
['a'] = 10, ['b'] = 11, ['c'] = 12, ['d'] = 13, ['e'] = 14, ['f'] = 15,
|
||
['A'] = 10, ['B'] = 11, ['C'] = 12, ['D'] = 13, ['E'] = 14, ['F'] = 15 };
|
||
/* 位置表：字符串下标 → 字节下标（1=前四组反序，0=后两组原序） */
|
||
static const struct { int str; int byte; int rev; } map[16] = {
|
||
{ 0, 3, 1 }, { 2, 2, 1 }, { 4, 1, 1 }, { 6, 0, 1 },
|
||
{ 9, 5, 1 }, { 11, 4, 1 },
|
||
{ 14, 7, 1 }, { 16, 6, 1 },
|
||
{ 19, 8, 0 }, { 21, 9, 0 }, { 23, 10, 0 }, { 25, 11, 0 },
|
||
{ 28, 12, 0 }, { 30, 13, 0 }, { 32, 14, 0 }, { 34, 15, 0 },
|
||
};
|
||
if (s[8] != '-' || s[13] != '-' || s[18] != '-' || s[23] != '-') return -1;
|
||
for (int i = 0; i < 16; i++) {
|
||
int hi = hex[(u8)s[map[i].str]];
|
||
int lo = hex[(u8)s[map[i].str + 1]];
|
||
if (hi < 0 || lo < 0) return -1;
|
||
(void)0;
|
||
}
|
||
for (int i = 0; i < 16; i++)
|
||
out[map[i].byte] = (u8)((hex[(u8)s[map[i].str]] << 4) | hex[(u8)s[map[i].str + 1]]);
|
||
return 0;
|
||
}
|
||
|
||
/* 16B → "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"（与 .NET Guid.ToString() 同序） */
|
||
static inline void gpt_guid_to_str(const u8 g[16], char out[37]) {
|
||
static const char *hd = "0123456789abcdef";
|
||
static const struct { int byte; int rev; } om[16] = {
|
||
{ 3, 1 }, { 2, 1 }, { 1, 1 }, { 0, 1 },
|
||
{ 5, 1 }, { 4, 1 },
|
||
{ 7, 1 }, { 6, 1 },
|
||
{ 8, 0 }, { 9, 0 }, { 10, 0 }, { 11, 0 },
|
||
{ 12, 0 }, { 13, 0 }, { 14, 0 }, { 15, 0 },
|
||
};
|
||
for (int i = 0; i < 16; i++) {
|
||
int b = om[i].byte;
|
||
out[i * 2] = hd[g[b] >> 4];
|
||
out[i * 2 + 1] = hd[g[b] & 0xF];
|
||
if (i == 3 || i == 5 || i == 7 || i == 9) { out[i * 2 + 2] = '-'; }
|
||
}
|
||
out[36] = 0;
|
||
}
|
||
|
||
/* ---- GPT 头构建 / 校验 ---- */
|
||
|
||
/* 计算头 CRC：前 92 字节、header_crc 字段按 0 参与 */
|
||
static inline u32 gpt_header_crc(const gpt_header *h) {
|
||
u8 tmp[92];
|
||
gpt_mem_cpy(tmp, (const u8 *)h, 92);
|
||
gpt_w32(tmp + 16, 0);
|
||
return gpt_crc32(tmp, 92);
|
||
}
|
||
|
||
/* 构建头（不落盘）：entries_crc 由调用者预先算好 */
|
||
static inline void gpt_header_build(gpt_header *h, u64 current_lba, u64 backup_lba,
|
||
u64 first_usable, u64 last_usable,
|
||
const u8 disk_guid[16],
|
||
u64 entries_lba, u32 entries_crc) {
|
||
static const u8 sig[8] = { 'E', 'F', 'I', ' ', 'P', 'A', 'R', 'T' };
|
||
gpt_mem_set((u8 *)h, 0, sizeof(*h));
|
||
gpt_mem_cpy(h->sig, sig, 8);
|
||
h->revision = GPT_REVISION;
|
||
h->header_size = GPT_HEADER_SIZE;
|
||
h->current_lba = current_lba;
|
||
h->backup_lba = backup_lba;
|
||
h->first_usable = first_usable;
|
||
h->last_usable = last_usable;
|
||
if (disk_guid) gpt_mem_cpy(h->disk_guid, disk_guid, 16);
|
||
h->entries_lba = entries_lba;
|
||
h->entries_count = GPT_ENTRIES;
|
||
h->entries_size = GPT_ENTRY_SIZE;
|
||
h->entries_crc = entries_crc;
|
||
h->header_crc = gpt_header_crc(h);
|
||
}
|
||
|
||
/* 校验 LBA 处的 GPT 头（签名/大小/current_lba/CRC），返回 0 有效 */
|
||
static inline int gpt_header_validate(const gpt_header *h, u64 expect_lba) {
|
||
static const u8 sig[8] = { 'E', 'F', 'I', ' ', 'P', 'A', 'R', 'T' };
|
||
if (!gpt_mem_eq(h->sig, sig, 8)) return -1;
|
||
if (h->revision != GPT_REVISION || h->header_size < GPT_HEADER_SIZE) return -2;
|
||
if (h->current_lba != expect_lba) return -3;
|
||
if (gpt_header_crc(h) != h->header_crc) return -4;
|
||
return 0;
|
||
}
|
||
|
||
/* ---- 分区表操作（内存缓冲） ---- */
|
||
static inline gpt_part_entry *gpt_part(u32 idx) {
|
||
return (gpt_part_entry *)(gpt_tbl + idx * GPT_ENTRY_SIZE);
|
||
}
|
||
|
||
/* 分区表 CRC（覆盖全部 32 扇区） */
|
||
static inline u32 gpt_entries_crc(void) {
|
||
return gpt_crc32(gpt_tbl, sizeof(gpt_tbl));
|
||
}
|
||
|
||
static inline int gpt_part_empty(const gpt_part_entry *e) {
|
||
return gpt_mem_eq(e->type_guid, (const u8 *)gpt_guid_esp /* 任意非 0 引用 */, 0) &&
|
||
gpt_mem_eq(e->type_guid, e->type_guid, 0); /* 恒真占位，防 -Wunused */
|
||
}
|
||
static inline int gpt_part_is_free(const gpt_part_entry *e) {
|
||
/* type_guid 全 0 = 空槽 */
|
||
static const u8 zero16[16] = { 0 };
|
||
return gpt_mem_eq(e->type_guid, zero16, 16);
|
||
}
|
||
|
||
/* 查找第一个 type_guid 匹配的分区（含全 0 停止），返回索引或 -1 */
|
||
static inline int gpt_find_part_type(const u8 type_guid[16], u64 *out_first, u64 *out_last) {
|
||
for (u32 i = 0; i < GPT_ENTRIES; i++) {
|
||
const gpt_part_entry *e = gpt_part(i);
|
||
if (gpt_part_is_free(e)) break;
|
||
if (gpt_mem_eq(e->type_guid, type_guid, 16)) {
|
||
if (out_first) *out_first = e->first_lba;
|
||
if (out_last) *out_last = e->last_lba;
|
||
return (int)i;
|
||
}
|
||
}
|
||
return -1;
|
||
}
|
||
|
||
/* 查找 ESP 分区，返回索引或 -1 */
|
||
static inline int gpt_find_esp(u64 *out_first, u64 *out_last) {
|
||
return gpt_find_part_type(gpt_guid_esp, out_first, out_last);
|
||
}
|
||
|
||
/* 分区名写入（ASCII → UTF-16LE，最多 36 字符） */
|
||
static inline void gpt_part_set_name(gpt_part_entry *e, const char *ascii) {
|
||
u32 i = 0;
|
||
for (; i < 36 && ascii[i]; i++) gpt_w16((u8 *)&e->name[i], (u16)ascii[i]);
|
||
for (; i < 36; i++) gpt_w16((u8 *)&e->name[i], 0);
|
||
}
|
||
|
||
/* 填充分区项到指定槽位（返回 0 成功，-1 槽位越界/非空） */
|
||
static inline int gpt_part_fill(u32 idx, const u8 type_guid[16], const u8 uniq_guid[16],
|
||
u64 first_lba, u64 last_lba, u64 attrs, const char *name) {
|
||
if (idx >= GPT_ENTRIES) return -1;
|
||
gpt_part_entry *e = gpt_part(idx);
|
||
if (!gpt_part_is_free(e)) return -2;
|
||
gpt_mem_cpy(e->type_guid, type_guid, 16);
|
||
if (uniq_guid) gpt_mem_cpy(e->uniq_guid, uniq_guid, 16);
|
||
else gpt_mem_set(e->uniq_guid, 0, 16);
|
||
e->first_lba = first_lba;
|
||
e->last_lba = last_lba;
|
||
e->attrs = attrs;
|
||
gpt_part_set_name(e, name);
|
||
return 0;
|
||
}
|
||
|
||
/* ---- 落盘 / 探测 ---- */
|
||
|
||
/* 探测 LBA1 是否为有效 GPT（轻量，不加载分区表） */
|
||
static inline int gpt_probe(void) {
|
||
if (gpt_read_sectors(1, 1, gpt_sec) != 0) return -1;
|
||
return gpt_header_validate((const gpt_header *)gpt_sec, 1);
|
||
}
|
||
|
||
/* 加载主头 + 主分区表到缓冲；校验头/表 CRC。total_sectors 为 0 时跳过盘尾推导 */
|
||
static inline int gpt_load(u64 total_sectors) {
|
||
if (gpt_read_sectors(1, 1, gpt_sec) != 0) return -1;
|
||
const gpt_header *h = (const gpt_header *)gpt_sec;
|
||
if (gpt_header_validate(h, 1) != 0) return -2;
|
||
if (h->entries_lba != 2 || h->entries_count != GPT_ENTRIES) return -3;
|
||
if (gpt_read_sectors(2, GPT_ENTRY_SECTORS, gpt_tbl) != 0) return -4;
|
||
if (gpt_entries_crc() != h->entries_crc) return -5;
|
||
gpt_disk_sectors = total_sectors;
|
||
return 0;
|
||
}
|
||
|
||
/* 全新初始化：protective MBR + 空 GPT（主+备份）。disk_guid 可 NULL（全 0）。
|
||
* total_sectors 必须 >= 70（34 + 32 表 + 2 头）。 */
|
||
static inline int gpt_blank_disk(u64 total_sectors, const u8 disk_guid[16]) {
|
||
if (total_sectors < GPT_FIRST_USABLE + GPT_ENTRY_SECTORS + 2) return -1;
|
||
|
||
/* LBA0 protective MBR（build.ps1 布局） */
|
||
gpt_mem_set(gpt_sec, 0, 512);
|
||
gpt_sec[GPT_MBR_PART_OFF + 4] = 0xEE; /* type */
|
||
gpt_w32(gpt_sec + GPT_MBR_PART_OFF + 8, 1); /* start LBA */
|
||
u64 prot = total_sectors - 1;
|
||
if (prot > 0xFFFFFFFFu) prot = 0xFFFFFFFFu;
|
||
gpt_w32(gpt_sec + GPT_MBR_PART_OFF + 12, (u32)prot); /* sectors */
|
||
gpt_sec[510] = 0x55; gpt_sec[511] = 0xAA;
|
||
if (gpt_write_sectors(0, 1, gpt_sec) != 0) return -2;
|
||
|
||
/* 空分区表 */
|
||
gpt_mem_set(gpt_tbl, 0, sizeof(gpt_tbl));
|
||
u32 entries_crc = gpt_crc32(gpt_tbl, sizeof(gpt_tbl));
|
||
|
||
/* 主头（LBA1）+ 备份头（lastLba） */
|
||
u64 last_lba = total_sectors - 1;
|
||
u64 last_usable = last_lba - GPT_ENTRY_SECTORS - 1;
|
||
gpt_header ph, bh;
|
||
gpt_header_build(&ph, 1, last_lba, GPT_FIRST_USABLE, last_usable,
|
||
disk_guid, 2, entries_crc);
|
||
gpt_header_build(&bh, last_lba, 1, GPT_FIRST_USABLE, last_usable,
|
||
disk_guid, last_lba - GPT_ENTRY_SECTORS, entries_crc);
|
||
|
||
if (gpt_write_sectors(1, 1, (const u8 *)&ph) != 0) return -3;
|
||
if (gpt_write_sectors(2, GPT_ENTRY_SECTORS, gpt_tbl) != 0) return -4;
|
||
if (gpt_write_sectors(last_lba - GPT_ENTRY_SECTORS, GPT_ENTRY_SECTORS, gpt_tbl) != 0) return -5;
|
||
if (gpt_write_sectors(last_lba, 1, (const u8 *)&bh) != 0) return -6;
|
||
|
||
gpt_disk_sectors = total_sectors;
|
||
return 0;
|
||
}
|
||
|
||
/* 新增/更新 ESP 分区项（内存缓冲，需 gpt_commit 落盘）：
|
||
* 已有 ESP 则更新范围，否则填第一个空槽。返回槽位索引或负错误码 */
|
||
static inline int gpt_update_esp(u64 first_lba, u64 last_lba,
|
||
const u8 uniq_guid[16], const char *name) {
|
||
static const u8 zero16[16] = { 0 };
|
||
int idx = gpt_find_part_type(gpt_guid_esp, 0, 0);
|
||
if (idx >= 0) {
|
||
gpt_part_entry *e = gpt_part((u32)idx);
|
||
e->first_lba = first_lba;
|
||
e->last_lba = last_lba;
|
||
if (uniq_guid) gpt_mem_cpy(e->uniq_guid, uniq_guid, 16);
|
||
if (name) gpt_part_set_name(e, name);
|
||
return idx;
|
||
}
|
||
/* 找第一个空槽（类型全 0） */
|
||
for (u32 i = 0; i < GPT_ENTRIES; i++) {
|
||
if (gpt_part_is_free(gpt_part(i)))
|
||
return gpt_part_fill(i, gpt_guid_esp, uniq_guid ? uniq_guid : zero16,
|
||
first_lba, last_lba, 0, name ? name : "Deshab ESP");
|
||
}
|
||
return -3; /* 表满 */
|
||
}
|
||
|
||
/* 提交：重算 entries CRC + 双头 CRC，写主表/备份表/主头/备份头（幂等） */
|
||
static inline int gpt_commit(void) {
|
||
u64 last_lba = 0;
|
||
gpt_header h;
|
||
/* 读当前主头，取 last_usable / disk_guid / backup 布局 */
|
||
if (gpt_read_sectors(1, 1, gpt_sec) != 0) return -1;
|
||
gpt_mem_cpy((u8 *)&h, gpt_sec, sizeof(h));
|
||
if (gpt_header_validate(&h, 1) != 0) return -2;
|
||
last_lba = h.backup_lba;
|
||
|
||
u32 entries_crc = gpt_entries_crc();
|
||
|
||
gpt_header_build(&h, 1, last_lba, h.first_usable, h.last_usable,
|
||
h.disk_guid, 2, entries_crc);
|
||
gpt_header bh;
|
||
gpt_header_build(&bh, last_lba, 1, h.first_usable, h.last_usable,
|
||
h.disk_guid, last_lba - GPT_ENTRY_SECTORS, entries_crc);
|
||
|
||
if (gpt_write_sectors(2, GPT_ENTRY_SECTORS, gpt_tbl) != 0) return -3;
|
||
if (gpt_write_sectors(1, 1, (const u8 *)&h) != 0) return -4;
|
||
if (gpt_write_sectors(last_lba - GPT_ENTRY_SECTORS, GPT_ENTRY_SECTORS, gpt_tbl) != 0) return -5;
|
||
if (gpt_write_sectors(last_lba, 1, (const u8 *)&bh) != 0) return -6;
|
||
return 0;
|
||
}
|
||
|
||
#endif /* DESHAB_GPT_WRITE_H */ |