/* $NetBSD: gpt.c,v 1.30.2.1 2024/03/24 20:27:04 bouyer Exp $ */ /* * Copyright 2018 The NetBSD Foundation, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY PIERMONT INFORMATION SYSTEMS INC. ``AS IS'' * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL PIERMONT INFORMATION SYSTEMS INC. BE * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF * THE POSSIBILITY OF SUCH DAMAGE. * */ #include "defs.h" #include "mbr.h" #include "md.h" #include "gpt_uuid.h" #include #include #include #include #include #include #include #include bool gpt_parts_check(void); /* check for needed binaries */ /*************** GPT ************************************************/ /* a GPT based disk_partitions interface */ #define GUID_STR_LEN 40 #define GPT_PTYPE_ALLOC 32 /* initial type array allocation, should be > * gpt type -l | wc -l */ #define GPT_DEV_LEN DISKNAMESIZE /* dkNN */ #define GPT_PARTS_PER_SEC 4 /* a 512 byte sector holds 4 entries */ #define GPT_DEFAULT_MAX_PARTS 128 /* a usable label will be short, so we can get away with an arbitrary limit */ #define GPT_LABEL_LEN 96 #define GPT_ATTR_BIOSBOOT 1 #define GPT_ATTR_BOOTME 2 #define GPT_ATTR_BOOTONCE 4 #define GPT_ATTR_BOOTFAILED 8 #define GPT_ATTR_NOBLOCKIO 16 #define GPT_ATTR_REQUIRED 32 /* when we don't care for BIOS or UEFI boot, use the combined boot flags */ #define GPT_ATTR_BOOT (GPT_ATTR_BIOSBOOT|GPT_ATTR_BOOTME) struct gpt_attr_desc { const char *name; uint flag; }; static const struct gpt_attr_desc gpt_avail_attrs[] = { { "biosboot", GPT_ATTR_BIOSBOOT }, { "bootme", GPT_ATTR_BOOTME }, { "bootonce", GPT_ATTR_BOOTONCE }, { "bootfailed", GPT_ATTR_BOOTFAILED }, { "noblockio", GPT_ATTR_NOBLOCKIO }, { "required", GPT_ATTR_REQUIRED }, { NULL, 0 } }; struct gpt_ptype_desc { struct part_type_desc gent; char tid[GUID_STR_LEN]; uint fsflags, default_fs_type; }; static const struct { const char *name; uint fstype; enum part_type ptype; uint fsflags; } gpt_fs_types[] = { { .name = "ffs", .fstype = FS_BSDFFS, .ptype = PT_root, .fsflags = GLM_LIKELY_FFS }, { .name = "swap", .fstype = FS_SWAP, .ptype = PT_swap }, { .name = "windows", .fstype = FS_MSDOS, .ptype = PT_FAT, .fsflags = GLM_MAYBE_FAT32|GLM_MAYBE_NTFS }, { .name = "windows", .fstype = FS_NTFS, .ptype = PT_FAT, .fsflags = GLM_MAYBE_FAT32|GLM_MAYBE_NTFS }, { .name = "efi", .fstype = FS_MSDOS, .ptype = PT_EFI_SYSTEM, .fsflags = GLM_MAYBE_FAT32 }, { .name = "efi", .fstype = FS_EFI_SP, .ptype = PT_EFI_SYSTEM, .fsflags = GLM_MAYBE_FAT32 }, { .name = "bios", .fstype = FS_MSDOS, .ptype = PT_FAT, .fsflags = GLM_MAYBE_FAT32 }, { .name = "lfs", .fstype = FS_BSDLFS, .ptype = PT_root }, { .name = "linux-data", .fstype = FS_EX2FS, .ptype = PT_root }, { .name = "apple", .fstype = FS_HFS, .ptype = PT_unknown }, { .name = "ccd", .fstype = FS_CCD, .ptype = PT_root }, { .name = "cgd", .fstype = FS_CGD, .ptype = PT_root }, { .name = "raid", .fstype = FS_RAID, .ptype = PT_root }, { .name = "vmcore", .fstype = FS_VMKCORE, .ptype = PT_unknown }, { .name = "vmfs", .fstype = FS_VMFS, .ptype = PT_unknown }, { .name = "vmresered", .fstype = FS_VMWRESV, .ptype = PT_unknown }, { .name = "zfs", .fstype = FS_ZFS, .ptype = PT_root }, }; static size_t gpt_ptype_cnt = 0, gpt_ptype_alloc = 0; static struct gpt_ptype_desc *gpt_ptype_descs = NULL; /* "well" known types with special handling */ static const struct part_type_desc *gpt_native_root; /* similar to struct gpt_ent, but matching our needs */ struct gpt_part_entry { const struct gpt_ptype_desc *gp_type; char gp_id[GUID_STR_LEN]; /* partition guid as string */ daddr_t gp_start, gp_size; uint gp_attr; /* various attribute bits */ char gp_label[GPT_LABEL_LEN]; /* user defined label */ char gp_dev_name[GPT_DEV_LEN]; /* name of wedge */ const char *last_mounted; /* last mounted if known */ uint fs_type, fs_sub_type, /* FS_* and maybe sub type */ fs_opt1, fs_opt2, fs_opt3; /* transient file system options */ uint gp_flags; #define GPEF_ON_DISK 1 /* This entry exists on-disk */ #define GPEF_MODIFIED 2 /* this entry has been changed */ #define GPEF_WEDGE 4 /* wedge for this exists */ #define GPEF_RESIZED 8 /* size has changed */ #define GPEF_TARGET 16 /* marked install target */ struct gpt_part_entry *gp_next; }; static const struct gpt_ptype_desc *gpt_find_native_type( const struct part_type_desc *gent); static const struct gpt_ptype_desc *gpt_find_guid_type(const char*); static bool gpt_info_to_part(struct gpt_part_entry *p, const struct disk_part_info *info, const char **err_msg); const struct disk_partitioning_scheme gpt_parts; struct gpt_disk_partitions { struct disk_partitions dp; /* * We keep a list of our current valid partitions, pointed * to by "partitions". * dp.num_part is the number of entries in "partitions". * When partitions that have a representation on disk already * are deleted, we move them to the "obsolete" list so we * can issue the proper commands to remove it when writing back. */ struct gpt_part_entry *partitions, /* current partitions */ *obsolete; /* deleted partitions */ size_t max_num_parts; /* how many entries max? */ size_t prologue, epilogue; /* number of sectors res. */ bool has_gpt; /* disk already has a GPT */ }; /* * Init global variables from MD details */ static void gpt_md_init(bool is_boot_disk, size_t *max_parts, size_t *head, size_t *tail) { size_t num; if (is_boot_disk) { #ifdef MD_GPT_INITIAL_SIZE #if MD_GPT_INITIAL_SIZE < 2*512 #error impossible small GPT prologue #endif num = ((MD_GPT_INITIAL_SIZE-(2*512))/512)*GPT_PARTS_PER_SEC; #else num = GPT_DEFAULT_MAX_PARTS; #endif } else { num = GPT_DEFAULT_MAX_PARTS; } *max_parts = num; *head = 2 + num/GPT_PARTS_PER_SEC; *tail = 1 + num/GPT_PARTS_PER_SEC; } /* * Parse a part of "gpt show" output into a struct gpt_part_entry. * Output is from "show -a" format if details = false, otherwise * from details for a specific partition (show -i or show -b) */ static void gpt_add_info(struct gpt_part_entry *part, const char *tag, char *val, bool details) { char *s, *e; if (details && strcmp(tag, "Start:") == 0) { part->gp_start = strtouq(val, NULL, 10); } else if (details && strcmp(tag, "Size:") == 0) { part->gp_size = strtouq(val, NULL, 10); } else if (details && strcmp(tag, "Type:") == 0) { s = strchr(val, '('); if (!s) return; e = strchr(s, ')'); if (!e) return; *e = 0; part->gp_type = gpt_find_guid_type(s+1); } else if (strcmp(tag, "TypeID:") == 0) { part->gp_type = gpt_find_guid_type(val); } else if (strcmp(tag, "GUID:") == 0) { strlcpy(part->gp_id, val, sizeof(part->gp_id)); } else if (strcmp(tag, "Label:") == 0) { strlcpy(part->gp_label, val, sizeof(part->gp_label)); } else if (strcmp(tag, "Attributes:") == 0) { char *n; while ((n = strsep(&val, ", ")) != NULL) { if (*n == 0) continue; for (const struct gpt_attr_desc *p = gpt_avail_attrs; p->name != NULL; p++) { if (strcmp(p->name, n) == 0) part->gp_attr |= p->flag; } } } } /* * Find the partition matching this wedge info and record that we * have a wedge already. */ static void update_part_from_wedge_info(struct gpt_disk_partitions *parts, const struct dkwedge_info *dkw) { for (struct gpt_part_entry *p = parts->partitions; p != NULL; p = p->gp_next) { if (p->gp_start != dkw->dkw_offset || (uint64_t)p->gp_size != dkw->dkw_size) continue; p->gp_flags |= GPEF_WEDGE; strlcpy(p->gp_dev_name, dkw->dkw_devname, sizeof p->gp_dev_name); return; } } static struct disk_partitions * gpt_read_from_disk(const char *dev, daddr_t start, daddr_t len, size_t bps, const struct disk_partitioning_scheme *scheme) { char diskpath[MAXPATHLEN]; int fd; struct dkwedge_info *dkw; struct dkwedge_list dkwl; size_t bufsize, dk; assert(start == 0); assert(have_gpt); if (run_program(RUN_SILENT | RUN_ERROR_OK, "gpt -rq header %s", dev) != 0) return NULL; /* read the partitions */ int i; unsigned int p_index; daddr_t p_start = 0, p_size = 0, avail_start = 0, avail_size = 0, disk_size = 0; char *textbuf, *t, *tt, p_type[STRSIZE]; static const char regpart_prefix[] = "GPT part - "; struct gpt_disk_partitions *parts; struct gpt_part_entry *last = NULL, *add_to = NULL; const struct gpt_ptype_desc *native_root = gpt_find_native_type(gpt_native_root); bool have_target = false; if (collect(T_OUTPUT, &textbuf, "gpt -r show -a %s 2>/dev/null", dev) < 1) return NULL; /* parse output and create our list */ parts = calloc(1, sizeof(*parts)); if (parts == NULL) return NULL; (void)strtok(textbuf, "\n"); /* ignore first line */ while ((t = strtok(NULL, "\n")) != NULL) { i = 0; p_start = 0; p_size = 0; p_index = 0; p_type[0] = 0; while ((tt = strsep(&t, " \t")) != NULL) { if (strlen(tt) == 0) continue; if (i == 0) { if (add_to != NULL) gpt_add_info(add_to, tt, t, false); p_start = strtouq(tt, NULL, 10); if (p_start == 0 && add_to != NULL) break; else add_to = NULL; } if (i == 1) p_size = strtouq(tt, NULL, 10); if (i == 2) p_index = strtouq(tt, NULL, 10); if (i > 2 || (i == 2 && p_index == 0)) { if (p_type[0]) strlcat(p_type, " ", STRSIZE); strlcat(p_type, tt, STRSIZE); } i++; } if (p_start == 0 || p_size == 0) continue; else if (strcmp(p_type, "Pri GPT table") == 0) { avail_start = p_start + p_size; parts->prologue = avail_start; parts->epilogue = p_size + 1; parts->max_num_parts = p_size * GPT_PARTS_PER_SEC; } else if (strcmp(p_type, "Sec GPT table") == 0) avail_size = p_start - avail_start; else if(strcmp(p_type, "Sec GPT header") == 0) disk_size = p_start + p_size; else if (p_index == 0 && strlen(p_type) > 0) /* Utilitary entry (PMBR, etc) */ continue; else if (p_index == 0) { /* Free space */ continue; } else { /* Usual partition */ tt = p_type; if (strncmp(tt, regpart_prefix, strlen(regpart_prefix)) == 0) tt += strlen(regpart_prefix); /* Add to our linked list */ struct gpt_part_entry *np = calloc(1, sizeof(*np)); if (np == NULL) break; strlcpy(np->gp_label, tt, sizeof(np->gp_label)); np->gp_start = p_start; np->gp_size = p_size; np->gp_flags |= GPEF_ON_DISK; if (!have_target && native_root != NULL && strcmp(np->gp_id, native_root->tid) == 0) { have_target = true; np->gp_flags |= GPEF_TARGET; } if (last == NULL) parts->partitions = np; else last->gp_next = np; last = np; add_to = np; parts->dp.num_part++; } } free(textbuf); /* If the GPT was not complete (e.g. truncated image), barf */ if (disk_size <= 0) { free(parts); return NULL; } parts->dp.pscheme = scheme; parts->dp.disk = strdup(dev); parts->dp.disk_start = start; parts->dp.disk_size = disk_size; parts->dp.free_space = avail_size; parts->dp.bytes_per_sector = bps; parts->has_gpt = true; fd = opendisk(parts->dp.disk, O_RDONLY, diskpath, sizeof(diskpath), 0); for (struct gpt_part_entry *p = parts->partitions; p != NULL; p = p->gp_next) { #ifdef DEFAULT_UFS2 bool fs_is_default = false; #endif if (p->gp_type != NULL) { if (p->gp_type->fsflags != 0) { const char *lm = get_last_mounted(fd, p->gp_start, &p->fs_type, &p->fs_sub_type, p->gp_type->fsflags); if (lm != NULL && *lm != 0) { char *path = strdup(lm); canonicalize_last_mounted(path); p->last_mounted = path; } else { p->fs_type = p->gp_type-> default_fs_type; #ifdef DEFAULT_UFS2 fs_is_default = true; #endif } } else { p->fs_type = p->gp_type->default_fs_type; #ifdef DEFAULT_UFS2 fs_is_default = true; #endif } #ifdef DEFAULT_UFS2 if (fs_is_default && p->fs_type == FS_BSDFFS) p->fs_sub_type = 2; #endif } parts->dp.free_space -= p->gp_size; } /* * Check if we have any (matching/auto-configured) wedges already */ dkw = NULL; dkwl.dkwl_buf = dkw; dkwl.dkwl_bufsize = 0; if (ioctl(fd, DIOCLWEDGES, &dkwl) == 0) { /* do not even try to deal with any races at this point */ bufsize = dkwl.dkwl_nwedges * sizeof(*dkw); dkw = malloc(bufsize); dkwl.dkwl_buf = dkw; dkwl.dkwl_bufsize = bufsize; if (dkw != NULL && ioctl(fd, DIOCLWEDGES, &dkwl) == 0) { for (dk = 0; dk < dkwl.dkwl_ncopied; dk++) update_part_from_wedge_info(parts, &dkw[dk]); } free(dkw); } close(fd); return &parts->dp; } static size_t gpt_cyl_size(const struct disk_partitions *arg) { return MEG / 512; } static struct disk_partitions * gpt_create_new(const char *disk, daddr_t start, daddr_t len, bool is_boot_drive, struct disk_partitions *parent) { struct gpt_disk_partitions *parts; struct disk_geom geo; if (start != 0) { assert(0); return NULL; } if (!get_disk_geom(disk, &geo)) return NULL; parts = calloc(1, sizeof(*parts)); if (!parts) return NULL; parts->dp.pscheme = &gpt_parts; parts->dp.disk = strdup(disk); gpt_md_init(is_boot_drive, &parts->max_num_parts, &parts->prologue, &parts->epilogue); parts->dp.disk_start = start; parts->dp.disk_size = len; parts->dp.bytes_per_sector = geo.dg_secsize; parts->dp.free_space = len - start - parts->prologue - parts->epilogue; parts->has_gpt = false; return &parts->dp; } static bool gpt_get_part_info(const struct disk_partitions *arg, part_id id, struct disk_part_info *info) { static const struct part_type_desc gpt_unknown_type = { .generic_ptype = PT_undef, .short_desc = "" }; const struct gpt_disk_partitions *parts = (const struct gpt_disk_partitions*)arg; const struct gpt_part_entry *p = parts->partitions; part_id no; for (no = 0; p != NULL && no < id; no++) p = p->gp_next; if (no != id || p == NULL) return false; memset(info, 0, sizeof(*info)); info->start = p->gp_start; info->size = p->gp_size; if (p->gp_type) info->nat_type = &p->gp_type->gent; else info->nat_type = &gpt_unknown_type; info->last_mounted = p->last_mounted; info->fs_type = p->fs_type; info->fs_sub_type = p->fs_sub_type; info->fs_opt1 = p->fs_opt1; info->fs_opt2 = p->fs_opt2; info->fs_opt3 = p->fs_opt3; if (p->gp_flags & GPEF_TARGET) info->flags |= PTI_INSTALL_TARGET; return true; } static bool gpt_get_part_attr_str(const struct disk_partitions *arg, part_id id, char *str, size_t avail_space) { const struct gpt_disk_partitions *parts = (const struct gpt_disk_partitions*)arg; const struct gpt_part_entry *p = parts->partitions; part_id no; static const char *flags = NULL; for (no = 0; p != NULL && no < id; no++) p = p->gp_next; if (no != id || p == NULL) return false; if (flags == NULL) flags = msg_string(MSG_gpt_flags); if (avail_space < 2) return false; if (p->gp_attr & GPT_ATTR_BOOT) *str++ = flags[0]; *str = 0; return true; } /* * Find insert position and check for duplicates. * If all goes well, insert the new "entry" in the "list". * If there are collisions, report "no free space". * We keep all lists sorted by start sector number, */ static bool gpt_insert_part_into_list(struct gpt_disk_partitions *parts, struct gpt_part_entry **list, struct gpt_part_entry *entry, const char **err_msg, part_id *new_id) { struct gpt_part_entry *p, *last; part_id pno; /* find the first entry past the new one (if any) */ for (pno = 0, last = NULL, p = *list; p != NULL; last = p, p = p->gp_next, pno++) { if (p->gp_start > entry->gp_start) break; } /* check if last partition overlaps with new one */ if (last) { if (last->gp_start + last->gp_size > entry->gp_start) { if (err_msg) *err_msg = msg_string(MSG_No_free_space); return false; } } if (p == NULL) { entry->gp_next = NULL; if (last != NULL) { last->gp_next = entry; } } else { /* check if new entry overlaps with next */ if (entry->gp_start + entry->gp_size > p->gp_start) { if (err_msg) *err_msg = msg_string(MSG_No_free_space); return false; } entry->gp_next = p; if (last != NULL) last->gp_next = entry; else *list = entry; } if (*list == NULL) *list = entry; if (new_id != NULL) *new_id = pno; return true; } static bool gpt_set_part_info(struct disk_partitions *arg, part_id id, const struct disk_part_info *info, const char **err_msg) { struct gpt_disk_partitions *parts = (struct gpt_disk_partitions*)arg; struct gpt_part_entry *p = parts->partitions, *n; part_id no; daddr_t lendiff; for (no = 0; p != NULL && no < id; no++) p = p->gp_next; if (no != id || p == NULL) return false; /* update target mark - we can only have one */ if (info->flags & PTI_INSTALL_TARGET) { p->gp_flags |= GPEF_TARGET; for (n = parts->partitions; n != NULL; n = n->gp_next) if (n != p) n->gp_flags &= ~GPEF_TARGET; } else { p->gp_flags &= ~GPEF_TARGET; } if ((p->gp_flags & GPEF_ON_DISK)) { if (info->start != p->gp_start) { /* partition moved, we need to delete and re-add */ n = calloc(1, sizeof(*n)); if (n == NULL) { if (err_msg) *err_msg = err_outofmem; return false; } *n = *p; p->gp_flags &= ~GPEF_ON_DISK; if (!gpt_insert_part_into_list(parts, &parts->obsolete, n, err_msg, NULL)) return false; } else if (info->size != p->gp_size) { p->gp_flags |= GPEF_RESIZED; } } p->gp_flags |= GPEF_MODIFIED; lendiff = info->size - p->gp_size; parts->dp.free_space -= lendiff; return gpt_info_to_part(p, info, err_msg); } static size_t gpt_get_free_spaces_internal(const struct gpt_disk_partitions *parts, struct disk_part_free_space *result, size_t max_num_result, daddr_t min_space_size, daddr_t align, daddr_t start, daddr_t ignore) { size_t cnt = 0; daddr_t s, e, from, size, end_of_disk; struct gpt_part_entry *p; if (align > 1) start = max(roundup(start, align), align); if (start < 0 || start < (daddr_t)parts->prologue) start = parts->prologue; if (parts->dp.disk_start != 0 && parts->dp.disk_start > start) start = parts->dp.disk_start; if (min_space_size < 1) min_space_size = 1; end_of_disk = parts->dp.disk_start + parts->dp.disk_size - parts->epilogue; from = start; while (from < end_of_disk && cnt < max_num_result) { again: size = parts->dp.disk_start + parts->dp.disk_size - from; start = from; if (start + size > end_of_disk) size = end_of_disk - start; for (p = parts->partitions; p != NULL; p = p->gp_next) { s = p->gp_start; e = p->gp_size + s; if (s == ignore) continue; if (e < from) continue; if (s <= from && e > from) { if (e - 1 >= end_of_disk) return cnt; from = e + 1; if (align > 1) { from = max(roundup(from, align), align); if (from >= end_of_disk) { size = 0; break; } } goto again; } if (s > from && s - from < size) { size = s - from; } } if (size >= min_space_size) { result->start = start; result->size = size; result++; cnt++; } from += size + 1; if (align > 1) from = max(roundup(from, align), align); } return cnt; } static daddr_t gpt_max_free_space_at(const struct disk_partitions *arg, daddr_t start) { const struct gpt_disk_partitions *parts = (const struct gpt_disk_partitions*)arg; struct disk_part_free_space space; if (gpt_get_free_spaces_internal(parts, &space, 1, 1, 0, start, start) == 1) return space.size; return 0; } static size_t gpt_get_free_spaces(const struct disk_partitions *arg, struct disk_part_free_space *result, size_t max_num_result, daddr_t min_space_size, daddr_t align, daddr_t start, daddr_t ignore) { const struct gpt_disk_partitions *parts = (const struct gpt_disk_partitions*)arg; return gpt_get_free_spaces_internal(parts, result, max_num_result, min_space_size, align, start, ignore); } static void gpt_match_ptype(const char *name, struct gpt_ptype_desc *t) { size_t i; for (i = 0; i < __arraycount(gpt_fs_types); i++) { if (strcmp(name, gpt_fs_types[i].name) == 0) { t->gent.generic_ptype = gpt_fs_types[i].ptype; t->fsflags = gpt_fs_types[i].fsflags; t->default_fs_type = gpt_fs_types[i].fstype; /* recongnize special entries */ if (gpt_native_root == NULL && i == 0) gpt_native_root = &t->gent; return; } } t->gent.generic_ptype = PT_unknown; t->fsflags = 0; t->default_fs_type = FS_BSDFFS; } static void gpt_internal_add_ptype(const char *uid, const char *name, const char *desc) { if (gpt_ptype_cnt >= gpt_ptype_alloc) { gpt_ptype_alloc = gpt_ptype_alloc ? 2*gpt_ptype_alloc : GPT_PTYPE_ALLOC; struct gpt_ptype_desc *nptypes = realloc(gpt_ptype_descs, gpt_ptype_alloc*sizeof(*gpt_ptype_descs)); if (nptypes == 0) errx(EXIT_FAILURE, "out of memory"); gpt_ptype_descs = nptypes; } strlcpy(gpt_ptype_descs[gpt_ptype_cnt].tid, uid, sizeof(gpt_ptype_descs[gpt_ptype_cnt].tid)); gpt_ptype_descs[gpt_ptype_cnt].gent.short_desc = strdup(name); gpt_ptype_descs[gpt_ptype_cnt].gent.description = strdup(desc); gpt_match_ptype(name, &gpt_ptype_descs[gpt_ptype_cnt]); gpt_ptype_cnt++; } static void gpt_init_ptypes(void) { if (gpt_ptype_cnt == 0) gpt_uuid_query(gpt_internal_add_ptype); } static void gpt_cleanup(void) { /* free all of gpt_ptype_descs */ for (size_t i = 0; i < gpt_ptype_cnt; i++) { free(__UNCONST(gpt_ptype_descs[i].gent.short_desc)); free(__UNCONST(gpt_ptype_descs[i].gent.description)); } free(gpt_ptype_descs); gpt_ptype_descs = NULL; gpt_ptype_cnt = gpt_ptype_alloc = 0; } static size_t gpt_type_count(void) { if (gpt_ptype_cnt == 0) gpt_init_ptypes(); return gpt_ptype_cnt; } static const struct part_type_desc * gpt_get_ptype(size_t ndx) { if (gpt_ptype_cnt == 0) gpt_init_ptypes(); if (ndx >= gpt_ptype_cnt) return NULL; return &gpt_ptype_descs[ndx].gent; } static const struct part_type_desc * gpt_get_generic_type(enum part_type gent) { if (gpt_ptype_cnt == 0) gpt_init_ptypes(); if (gent == PT_root) return gpt_native_root; if (gent == PT_unknown) return NULL; for (size_t i = 0; i < gpt_ptype_cnt; i++) if (gpt_ptype_descs[i].gent.generic_ptype == gent) return &gpt_ptype_descs[i].gent; return NULL; } static const struct gpt_ptype_desc * gpt_find_native_type(const struct part_type_desc *gent) { if (gpt_ptype_cnt == 0) gpt_init_ptypes(); if (gent == NULL) return NULL; for (size_t i = 0; i < gpt_ptype_cnt; i++) if (gent == &gpt_ptype_descs[i].gent) return &gpt_ptype_descs[i]; gent = gpt_get_generic_type(gent->generic_ptype); if (gent == NULL) return NULL; /* this can not recurse deeper than once, we would not have found a * generic type a few lines above if it would. */ return gpt_find_native_type(gent); } static const struct gpt_ptype_desc * gpt_find_guid_type(const char *uid) { if (gpt_ptype_cnt == 0) gpt_init_ptypes(); if (uid == NULL || uid[0] == 0) return NULL; for (size_t i = 0; i < gpt_ptype_cnt; i++) if (strcmp(gpt_ptype_descs[i].tid, uid) == 0) return &gpt_ptype_descs[i]; return NULL; } static const struct part_type_desc * gpt_find_type(const char *desc) { if (gpt_ptype_cnt == 0) gpt_init_ptypes(); if (desc == NULL || desc[0] == 0) return NULL; for (size_t i = 0; i < gpt_ptype_cnt; i++) if (strcmp(gpt_ptype_descs[i].gent.short_desc, desc) == 0) return &gpt_ptype_descs[i].gent; return NULL; } static const struct part_type_desc * gpt_get_fs_part_type(enum part_type pt, unsigned fstype, unsigned fs_sub_type) { size_t i; /* Try with complete match (including part_type) first */ for (i = 0; i < __arraycount(gpt_fs_types); i++) if (fstype == gpt_fs_types[i].fstype && pt == gpt_fs_types[i].ptype) return gpt_find_type(gpt_fs_types[i].name); /* If that did not work, ignore part_type */ for (i = 0; i < __arraycount(gpt_fs_types); i++) if (fstype == gpt_fs_types[i].fstype) return gpt_find_type(gpt_fs_types[i].name); return NULL; } static bool gpt_get_default_fstype(const struct part_type_desc *nat_type, unsigned *fstype, unsigned *fs_sub_type) { const struct gpt_ptype_desc *gtype; gtype = gpt_find_native_type(nat_type); if (gtype == NULL) return false; *fstype = gtype->default_fs_type; #ifdef DEFAULT_UFS2 if (gtype->default_fs_type == FS_BSDFFS) *fs_sub_type = 2; else #endif *fs_sub_type = 0; return true; } static const struct part_type_desc * gpt_get_uuid_part_type(const uuid_t *id) { char str[GUID_STR_LEN], desc[GUID_STR_LEN + MENUSTRSIZE]; const struct gpt_ptype_desc *t; char *guid = NULL; uint32_t err; uuid_to_string(id, &guid, &err); strlcpy(str, err == uuid_s_ok ? guid : "-", sizeof str); free(guid); t = gpt_find_guid_type(str); if (t == NULL) { snprintf(desc, sizeof desc, "%s (%s)", msg_string(MSG_custom_type), str); gpt_internal_add_ptype(str, str, desc); t = gpt_find_guid_type(str); assert(t != NULL); } return &t->gent; } static const struct part_type_desc * gpt_create_custom_part_type(const char *custom, const char **err_msg) { uuid_t id; uint32_t err; uuid_from_string(custom, &id, &err); if (err_msg != NULL && (err == uuid_s_invalid_string_uuid || err == uuid_s_bad_version)) { *err_msg = MSG_invalid_guid; return NULL; } if (err != uuid_s_ok) return NULL; return gpt_get_uuid_part_type(&id); } static const struct part_type_desc * gpt_create_unknown_part_type(void) { uuid_t id; uint32_t err; uuid_create(&id, &err); if (err != uuid_s_ok) return NULL; return gpt_get_uuid_part_type(&id); } static daddr_t gpt_get_part_alignment(const struct disk_partitions *parts) { assert(parts->disk_size > 0); if (parts->disk_size < 0) return 1; /* Use 1MB offset/alignemnt for large (>128GB) disks */ if (parts->disk_size > HUGE_DISK_SIZE) return 2048; else if (parts->disk_size > TINY_DISK_SIZE) return 64; else return 4; } static bool gpt_can_add_partition(const struct disk_partitions *arg) { const struct gpt_disk_partitions *parts = (const struct gpt_disk_partitions*)arg; struct disk_part_free_space space; daddr_t align; if (parts->dp.num_part >= parts->max_num_parts) return false; align = gpt_get_part_alignment(arg); if (parts->dp.free_space <= align) return false; if (gpt_get_free_spaces_internal(parts, &space, 1, align, align, 0, -1) < 1) return false; return true; } static bool gpt_info_to_part(struct gpt_part_entry *p, const struct disk_part_info *info, const char **err_msg) { p->gp_type = gpt_find_native_type(info->nat_type); p->gp_start = info->start; p->gp_size = info->size; if (info->last_mounted != NULL && info->last_mounted != p->last_mounted) { free(__UNCONST(p->last_mounted)); p->last_mounted = strdup(info->last_mounted); } p->fs_type = info->fs_type; p->fs_sub_type = info->fs_sub_type; p->fs_opt1 = info->fs_opt1; p->fs_opt2 = info->fs_opt2; p->fs_opt3 = info->fs_opt3; return true; } static part_id gpt_add_part(struct disk_partitions *arg, const struct disk_part_info *info, const char **err_msg) { struct gpt_disk_partitions *parts = (struct gpt_disk_partitions*)arg; struct disk_part_free_space space; struct disk_part_info data = *info; struct gpt_part_entry *p, *n; part_id pno; bool ok; if (err_msg != NULL) *err_msg = NULL; if (gpt_get_free_spaces_internal(parts, &space, 1, 1, 1, info->start, -1) < 1) { if (err_msg) *err_msg = msg_string(MSG_No_free_space); return NO_PART; } if (parts->dp.num_part >= parts->max_num_parts) { if (err_msg) *err_msg = msg_string(MSG_err_too_many_partitions); return NO_PART; } if (data.size > space.size) data.size = space.size; p = calloc(1, sizeof(*p)); if (p == NULL) { if (err_msg != NULL) *err_msg = INTERNAL_ERROR; return NO_PART; } if (!gpt_info_to_part(p, &data, err_msg)) { free(p); return NO_PART; } p->gp_flags |= GPEF_MODIFIED; ok = gpt_insert_part_into_list(parts, &parts->partitions, p, err_msg, &pno); if (ok) { if (info->flags & PTI_INSTALL_TARGET) { /* update target mark - we can only have one */ p->gp_flags |= GPEF_TARGET; for (n = parts->partitions; n != NULL; n = n->gp_next) if (n != p) n->gp_flags &= ~GPEF_TARGET; } parts->dp.num_part++; parts->dp.free_space -= p->gp_size; return pno; } else { free(p); return NO_PART; } } static bool gpt_delete_partition(struct disk_partitions *arg, part_id id, const char **err_msg) { struct gpt_disk_partitions *parts = (struct gpt_disk_partitions*)arg; struct gpt_part_entry *p, *last = NULL; part_id i; bool res; if (parts->dp.num_part == 0) return false; for (i = 0, p = parts->partitions; i != id && i < parts->dp.num_part && p != NULL; i++, p = p->gp_next) last = p; if (p == NULL) { if (err_msg) *err_msg = INTERNAL_ERROR; return false; } if (last == NULL) parts->partitions = p->gp_next; else last->gp_next = p->gp_next; res = true; if (p->gp_flags & GPEF_ON_DISK) { if (!gpt_insert_part_into_list(parts, &parts->obsolete, p, err_msg, NULL)) res = false; } else { free(p); } if (res) { parts->dp.num_part--; parts->dp.free_space += p->gp_size; } return res; } static bool gpt_delete_all_partitions(struct disk_partitions *arg) { struct gpt_disk_partitions *parts = (struct gpt_disk_partitions*)arg; while (parts->dp.num_part > 0) { if (!gpt_delete_partition(&parts->dp, 0, NULL)) return false; } return true; } static bool gpt_read_part(const char *disk, daddr_t start, struct gpt_part_entry *p) { char *textbuf, *t, *tt; static const char expected_hdr[] = "Details for index "; /* run gpt show for this partition */ if (collect(T_OUTPUT, &textbuf, "gpt -r show -b %" PRIu64 " %s 2>/dev/null", start, disk) < 1) return false; /* * gpt show should respond with single partition details, but will * fall back to "show -a" output if something is wrong */ t = strtok(textbuf, "\n"); /* first line is special */ if (strncmp(t, expected_hdr, sizeof(expected_hdr)-1) != 0) { free(textbuf); return false; } /* parse output into "old" */ while ((t = strtok(NULL, "\n")) != NULL) { tt = strsep(&t, " \t"); if (strlen(tt) == 0) continue; gpt_add_info(p, tt, t, true); } free(textbuf); return true; } static bool gpt_apply_attr(const char *disk, const char *cmd, off_t start, uint todo) { size_t i; char attr_str[STRSIZE]; if (todo == 0) return true; strcpy(attr_str, "-a "); for (i = 0; todo != 0; i++) { if (!(gpt_avail_attrs[i].flag & todo)) continue; todo &= ~gpt_avail_attrs[i].flag; if (attr_str[0]) strlcat(attr_str, ",", sizeof(attr_str)); strlcat(attr_str, gpt_avail_attrs[i].name, sizeof(attr_str)); } if (run_program(RUN_SILENT, "gpt %s %s -b %" PRIu64 " %s", cmd, attr_str, start, disk) != 0) return false; return true; } /* * Modify an existing on-disk partition. * Start and size can not be changed here, caller needs to deal * with that kind of changes upfront. */ static bool gpt_modify_part(const char *disk, struct gpt_part_entry *p) { struct gpt_part_entry old; uint todo_set, todo_unset; /* * Query current on-disk state */ memset(&old, 0, sizeof old); if (!gpt_read_part(disk, p->gp_start, &old)) return false; /* Reject unsupported changes */ if (old.gp_start != p->gp_start || old.gp_size != p->gp_size) return false; /* * GUID should never change, but the internal copy * may not yet know it. */ strcpy(p->gp_id, old.gp_id); /* Check type */ if (p->gp_type != old.gp_type) { if (run_program(RUN_SILENT, "gpt type -b %" PRIu64 " -T %s %s", p->gp_start, p->gp_type->tid, disk) != 0) return false; } /* Check label */ if (strcmp(p->gp_label, old.gp_label) != 0) { if (run_program(RUN_SILENT, "gpt label -b %" PRIu64 " -l \'%s\' %s", p->gp_start, p->gp_label, disk) != 0) return false; } /* Check attributes */ if (p->gp_attr != old.gp_attr) { if (p->gp_attr == 0) { if (run_program(RUN_SILENT, "gpt set -N -b %" PRIu64 " %s", p->gp_start, disk) != 0) return false; } else { todo_set = (p->gp_attr ^ old.gp_attr) & p->gp_attr; todo_unset = (p->gp_attr ^ old.gp_attr) & old.gp_attr; if (!gpt_apply_attr(disk, "unset", p->gp_start, todo_unset)) return false; if (!gpt_apply_attr(disk, "set", p->gp_start, todo_set)) return false; } } return true; } /* * verbatim copy from sys/dev/dkwedge/dkwedge_bsdlabel.c: * map FS_* to wedge strings */ static const char * bsdlabel_fstype_to_str(uint8_t fstype) { const char *str; /* * For each type known to FSTYPE_DEFN (from ), * a suitable case branch will convert the type number to a string. */ switch (fstype) { #define FSTYPE_TO_STR_CASE(tag, number, name, fsck, mount) \ case __CONCAT(FS_,tag): str = __CONCAT(DKW_PTYPE_,tag); break; FSTYPE_DEFN(FSTYPE_TO_STR_CASE) #undef FSTYPE_TO_STR_CASE default: str = NULL; break; } return (str); } /* * diskfd is an open file descriptor for a disk we had trouble with * creating some new wedges. * Go through all wedges actually on that disk, check if we have a * record for them and remove all others. * This should sync our internal model of partitions with the real state. */ static void gpt_sanitize(int diskfd, const struct gpt_disk_partitions *parts, struct gpt_part_entry *ignore) { struct dkwedge_info *dkw, delw; struct dkwedge_list dkwl; size_t bufsize; u_int i; dkw = NULL; dkwl.dkwl_buf = dkw; dkwl.dkwl_bufsize = 0; /* get a list of all wedges */ for (;;) { if (ioctl(diskfd, DIOCLWEDGES, &dkwl) == -1) return; if (dkwl.dkwl_nwedges == dkwl.dkwl_ncopied) break; bufsize = dkwl.dkwl_nwedges * sizeof(*dkw); if (dkwl.dkwl_bufsize < bufsize) { dkw = realloc(dkwl.dkwl_buf, bufsize); if (dkw == NULL) return; dkwl.dkwl_buf = dkw; dkwl.dkwl_bufsize = bufsize; } } /* try to remove all the ones we do not know about */ for (i = 0; i < dkwl.dkwl_nwedges; i++) { bool found = false; const char *devname = dkw[i].dkw_devname; for (struct gpt_part_entry *pe = parts->partitions; pe != NULL; pe = pe->gp_next) { if (pe == ignore) continue; if ((pe->gp_flags & GPEF_WEDGE) && strcmp(pe->gp_dev_name, devname) == 0) { found = true; break; } } if (found) continue; memset(&delw, 0, sizeof(delw)); strlcpy(delw.dkw_devname, devname, sizeof(delw.dkw_devname)); (void)ioctl(diskfd, DIOCDWEDGE, &delw); } /* cleanup */ free(dkw); } static bool gpt_add_wedge(const char *disk, struct gpt_part_entry *p, const struct gpt_disk_partitions *parts) { struct dkwedge_info dkw; const char *tname; char diskpath[MAXPATHLEN]; int fd; memset(&dkw, 0, sizeof(dkw)); tname = bsdlabel_fstype_to_str(p->fs_type); if (tname) strlcpy(dkw.dkw_ptype, tname, sizeof(dkw.dkw_ptype)); strlcpy((char*)&dkw.dkw_wname, p->gp_id, sizeof(dkw.dkw_wname)); dkw.dkw_offset = p->gp_start; dkw.dkw_size = p->gp_size; if (dkw.dkw_wname[0] == 0) { if (p->gp_label[0] != 0) strlcpy((char*)&dkw.dkw_wname, p->gp_label, sizeof(dkw.dkw_wname)); } if (dkw.dkw_wname[0] == 0) { snprintf((char*)dkw.dkw_wname, sizeof dkw.dkw_wname, "%s_%" PRIi64 "@%" PRIi64, disk, p->gp_size, p->gp_start); } fd = opendisk(disk, O_RDWR, diskpath, sizeof(diskpath), 0); if (fd < 0) return false; if (ioctl(fd, DIOCAWEDGE, &dkw) == -1) { if (errno == EINVAL) { /* sanitize existing wedges and try again */ gpt_sanitize(fd, parts, p); if (ioctl(fd, DIOCAWEDGE, &dkw) == 0) goto ok; } close(fd); return false; } ok: close(fd); strlcpy(p->gp_dev_name, dkw.dkw_devname, sizeof(p->gp_dev_name)); p->gp_flags |= GPEF_WEDGE; return true; } static void escape_spaces(char *dest, const char *src) { unsigned char c; while (*src) { c = *src++; if (isspace(c) || c == '\\') *dest++ = '\\'; *dest++ = c; } *dest = 0; } static bool gpt_get_part_device(const struct disk_partitions *arg, part_id id, char *devname, size_t max_devname_len, int *part, enum dev_name_usage usage, bool with_path, bool life) { const struct gpt_disk_partitions *parts = (const struct gpt_disk_partitions*)arg; struct gpt_part_entry *p = parts->partitions; char tmpname[GPT_LABEL_LEN*2]; part_id no; for (no = 0; p != NULL && no < id; no++) p = p->gp_next; if (no != id || p == NULL) return false; if (part) *part = -1; if (usage == logical_name && p->gp_label[0] == 0 && p->gp_id[0] == 0) usage = plain_name; if (usage == plain_name || usage == raw_dev_name) life = true; if (!(p->gp_flags & GPEF_WEDGE) && life && !gpt_add_wedge(arg->disk, p, parts)) return false; switch (usage) { case logical_name: if (p->gp_label[0] != 0) { escape_spaces(tmpname, p->gp_label); snprintf(devname, max_devname_len, "NAME=%s", tmpname); } else { snprintf(devname, max_devname_len, "NAME=%s", p->gp_id); } break; case plain_name: assert(p->gp_flags & GPEF_WEDGE); if (with_path) snprintf(devname, max_devname_len, _PATH_DEV "%s", p->gp_dev_name); else strlcpy(devname, p->gp_dev_name, max_devname_len); break; case raw_dev_name: assert(p->gp_flags & GPEF_WEDGE); if (with_path) snprintf(devname, max_devname_len, _PATH_DEV "r%s", p->gp_dev_name); else snprintf(devname, max_devname_len, "r%s", p->gp_dev_name); break; default: return false; } return true; } static bool gpt_write_to_disk(struct disk_partitions *arg) { struct gpt_disk_partitions *parts = (struct gpt_disk_partitions*)arg; struct gpt_part_entry *p, *n; char label_arg[sizeof(p->gp_label) + 10]; char diskpath[MAXPATHLEN]; int fd, bits = 0; bool root_is_new = false, efi_is_new = false; part_id root_id = NO_PART, efi_id = NO_PART, pno; /* * Remove all wedges on this disk - they may become invalid and we * have no easy way to associate them with the partitioning data. * Instead we will explicitly request creation of wedges on demand * later. */ fd = opendisk(arg->disk, O_RDWR, diskpath, sizeof(diskpath), 0); if (fd < 0) return false; if (ioctl(fd, DIOCRMWEDGES, &bits) == -1) return false; close(fd); /* * Collect first root and efi partition (if available), clear * "have wedge" flags. */ for (pno = 0, p = parts->partitions; p != NULL; p = p->gp_next, pno++) { p->gp_flags &= ~GPEF_WEDGE; if (root_id == NO_PART && p->gp_type != NULL) { if (p->gp_type->gent.generic_ptype == PT_root && (p->gp_flags & GPEF_TARGET)) { root_id = pno; root_is_new = !(p->gp_flags & GPEF_ON_DISK); } else if (efi_id == NO_PART && p->gp_type->gent.generic_ptype == PT_EFI_SYSTEM) { efi_id = pno; efi_is_new = !(p->gp_flags & GPEF_ON_DISK); } } } /* * If no GPT on disk yet, create it. */ if (!parts->has_gpt) { char limit[30]; if (parts->max_num_parts > 0) sprintf(limit, "-p %zu", parts->max_num_parts); else limit[0] = 0; if (run_program(RUN_SILENT, "gpt create %s %s", limit, parts->dp.disk)) return false; parts->has_gpt = true; } /* * Delete all old partitions */ for (p = parts->obsolete; p != NULL; p = n) { run_program(RUN_SILENT, "gpt -n remove -b %" PRIu64 " %s", p->gp_start, arg->disk); n = p->gp_next; free(p); } parts->obsolete = NULL; /* * Modify existing but changed partitions */ for (p = parts->partitions; p != NULL; p = p->gp_next) { if (!(p->gp_flags & GPEF_ON_DISK)) continue; if (p->gp_flags & GPEF_RESIZED) { run_program(RUN_SILENT, "gpt -n resize -b %" PRIu64 " -s %" PRIu64 "s %s", p->gp_start, p->gp_size, arg->disk); p->gp_flags &= ~GPEF_RESIZED; } if (!(p->gp_flags & GPEF_MODIFIED)) continue; if (!gpt_modify_part(parts->dp.disk, p)) return false; } /* * Add new partitions */ for (p = parts->partitions; p != NULL; p = p->gp_next) { if (p->gp_flags & GPEF_ON_DISK) continue; if (!(p->gp_flags & GPEF_MODIFIED)) continue; if (p->gp_label[0] == 0) label_arg[0] = 0; else sprintf(label_arg, "-l \'%s\'", p->gp_label); if (p->gp_type != NULL) run_program(RUN_SILENT, "gpt -n add -b %" PRIu64 " -s %" PRIu64 "s -t %s %s %s", p->gp_start, p->gp_size, p->gp_type->tid, label_arg, arg->disk); else run_program(RUN_SILENT, "gpt -n add -b %" PRIu64 " -s %" PRIu64 "s %s %s", p->gp_start, p->gp_size, label_arg, arg->disk); gpt_apply_attr(arg->disk, "set", p->gp_start, p->gp_attr); gpt_read_part(arg->disk, p->gp_start, p); p->gp_flags |= GPEF_ON_DISK; } /* * Additional MD bootloader magic... */ if (!md_gpt_post_write(&parts->dp, root_id, root_is_new, efi_id, efi_is_new)) return false; return true; } static part_id gpt_find_by_name(struct disk_partitions *arg, const char *name) { struct gpt_disk_partitions *parts = (struct gpt_disk_partitions*)arg; struct gpt_part_entry *p; part_id pno; for (pno = 0, p = parts->partitions; p != NULL; p = p->gp_next, pno++) { if (strcmp(p->gp_label, name) == 0) return pno; if (strcmp(p->gp_id, name) == 0) return pno; } return NO_PART; } bool gpt_parts_check(void) { check_available_binaries(); return have_gpt && have_dk; } static void gpt_free(struct disk_partitions *arg) { struct gpt_disk_partitions *parts = (struct gpt_disk_partitions*)arg; struct gpt_part_entry *p, *n; assert(parts != NULL); for (p = parts->partitions; p != NULL; p = n) { if (p->gp_flags & GPEF_WEDGE) register_post_umount_delwedge(parts->dp.disk, p->gp_dev_name); free(__UNCONST(p->last_mounted)); n = p->gp_next; free(p); } free(__UNCONST(parts->dp.disk)); free(parts); } static void gpt_destroy_part_scheme(struct disk_partitions *arg) { run_program(RUN_SILENT, "gpt destroy %s", arg->disk); gpt_free(arg); } static bool gpt_custom_attribute_writable(const struct disk_partitions *arg, part_id ptn, size_t attr_no) { const struct gpt_disk_partitions *parts = (const struct gpt_disk_partitions*)arg; size_t i; struct gpt_part_entry *p; if (attr_no >= arg->pscheme->custom_attribute_count) return false; const msg label = arg->pscheme->custom_attributes[attr_no].label; /* we can not edit the uuid attribute */ if (label == MSG_ptn_uuid) return false; /* the label is always editable */ if (label == MSG_ptn_label) return true; /* the GPT type is read only */ if (label == MSG_ptn_gpt_type) return false; /* BOOTME makes no sense on swap partitions */ for (i = 0, p = parts->partitions; p != NULL; i++, p = p->gp_next) if (i == ptn) break; if (p == NULL) return false; if (p->fs_type == FS_SWAP || (p->gp_type != NULL && p->gp_type->gent.generic_ptype == PT_swap)) return false; return true; } static const char * gpt_get_label_str(const struct disk_partitions *arg, part_id ptn) { const struct gpt_disk_partitions *parts = (const struct gpt_disk_partitions*)arg; size_t i; struct gpt_part_entry *p; for (i = 0, p = parts->partitions; p != NULL; i++, p = p->gp_next) if (i == ptn) break; if (p == NULL) return NULL; if (p->gp_label[0] != 0) return p->gp_label; return p->gp_id; } static bool gpt_format_custom_attribute(const struct disk_partitions *arg, part_id ptn, size_t attr_no, const struct disk_part_info *info, char *out, size_t out_space) { const struct gpt_disk_partitions *parts = (const struct gpt_disk_partitions*)arg; size_t i; struct gpt_part_entry *p, data; for (i = 0, p = parts->partitions; p != NULL; i++, p = p->gp_next) if (i == ptn) break; if (p == NULL) return false; if (attr_no >= parts->dp.pscheme->custom_attribute_count) return false; const msg label = parts->dp.pscheme->custom_attributes[attr_no].label; if (info != NULL) { data = *p; gpt_info_to_part(&data, info, NULL); p = &data; } if (label == MSG_ptn_label) strlcpy(out, p->gp_label, out_space); else if (label == MSG_ptn_uuid) strlcpy(out, p->gp_id, out_space); else if (label == MSG_ptn_gpt_type) { if (p->gp_type != NULL) strlcpy(out, p->gp_type->gent.description, out_space); else if (out_space > 1) out[0] = 0; } else if (label == MSG_ptn_boot) strlcpy(out, msg_string(p->gp_attr & GPT_ATTR_BOOT ? MSG_Yes : MSG_No), out_space); else return false; return true; } static bool gpt_custom_attribute_toggle(struct disk_partitions *arg, part_id ptn, size_t attr_no) { const struct gpt_disk_partitions *parts = (const struct gpt_disk_partitions*)arg; size_t i; struct gpt_part_entry *p; for (i = 0, p = parts->partitions; p != NULL; i++, p = p->gp_next) if (i == ptn) break; if (p == NULL) return false; if (attr_no >= parts->dp.pscheme->custom_attribute_count) return false; const msg label = parts->dp.pscheme->custom_attributes[attr_no].label; if (label != MSG_ptn_boot) return false; if (p->gp_attr & GPT_ATTR_BOOT) { p->gp_attr &= ~GPT_ATTR_BOOT; } else { for (i = 0, p = parts->partitions; p != NULL; i++, p = p->gp_next) if (i == ptn) p->gp_attr |= GPT_ATTR_BOOT; else p->gp_attr &= ~GPT_ATTR_BOOT; } return true; } static bool gpt_custom_attribute_set_str(struct disk_partitions *arg, part_id ptn, size_t attr_no, const char *new_val) { const struct gpt_disk_partitions *parts = (const struct gpt_disk_partitions*)arg; size_t i; struct gpt_part_entry *p; for (i = 0, p = parts->partitions; p != NULL; i++, p = p->gp_next) if (i == ptn) break; if (p == NULL) return false; if (attr_no >= parts->dp.pscheme->custom_attribute_count) return false; const msg label = parts->dp.pscheme->custom_attributes[attr_no].label; if (label != MSG_ptn_label) return false; strlcpy(p->gp_label, new_val, sizeof(p->gp_label)); return true; } static bool gpt_have_boot_support(const char *disk) { #ifdef HAVE_GPT_BOOT return true; #else return false; #endif } const struct disk_part_custom_attribute gpt_custom_attrs[] = { { .label = MSG_ptn_label, .type = pet_str }, { .label = MSG_ptn_uuid, .type = pet_str }, { .label = MSG_ptn_gpt_type, .type = pet_str }, { .label = MSG_ptn_boot, .type = pet_bool }, }; const struct disk_partitioning_scheme gpt_parts = { .name = MSG_parttype_gpt, .short_name = MSG_parttype_gpt_short, .part_flag_desc = MSG_gpt_flag_desc, .custom_attribute_count = __arraycount(gpt_custom_attrs), .custom_attributes = gpt_custom_attrs, .get_part_types_count = gpt_type_count, .get_part_type = gpt_get_ptype, .get_generic_part_type = gpt_get_generic_type, .get_fs_part_type = gpt_get_fs_part_type, .get_default_fstype = gpt_get_default_fstype, .create_custom_part_type = gpt_create_custom_part_type, .create_unknown_part_type = gpt_create_unknown_part_type, .get_part_alignment = gpt_get_part_alignment, .read_from_disk = gpt_read_from_disk, .get_cylinder_size = gpt_cyl_size, .create_new_for_disk = gpt_create_new, .have_boot_support = gpt_have_boot_support, .find_by_name = gpt_find_by_name, .can_add_partition = gpt_can_add_partition, .custom_attribute_writable = gpt_custom_attribute_writable, .format_custom_attribute = gpt_format_custom_attribute, .custom_attribute_toggle = gpt_custom_attribute_toggle, .custom_attribute_set_str = gpt_custom_attribute_set_str, .other_partition_identifier = gpt_get_label_str, .get_part_device = gpt_get_part_device, .max_free_space_at = gpt_max_free_space_at, .get_free_spaces = gpt_get_free_spaces, .adapt_foreign_part_info = generic_adapt_foreign_part_info, .get_part_info = gpt_get_part_info, .get_part_attr_str = gpt_get_part_attr_str, .set_part_info = gpt_set_part_info, .add_partition = gpt_add_part, .delete_all_partitions = gpt_delete_all_partitions, .delete_partition = gpt_delete_partition, .write_to_disk = gpt_write_to_disk, .free = gpt_free, .destroy_part_scheme = gpt_destroy_part_scheme, .cleanup = gpt_cleanup, };