/* $NetBSD: disklabel.c,v 1.10.2.12 2023/01/02 10:13:30 martin 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 "md.h" #include #include #include #include #include const struct disk_partitioning_scheme disklabel_parts; /*************** disklabel ******************************************/ /* a disklabel based disk_partitions interface */ struct disklabel_disk_partitions { struct disk_partitions dp; struct disklabel l; daddr_t ptn_alignment, install_target; char last_mounted[MAXPARTITIONS][MOUNTLEN]; uint fs_sub_type[MAXPARTITIONS], fs_opt3[MAXPARTITIONS]; }; /* * Maximum number of disklabel partitions the current kernel supports */ size_t dl_maxpart; /* index into this arrray is the type code */ static struct part_type_desc dl_types[__arraycount(fstypenames)-1]; struct dl_custom_ptype { unsigned int type; char short_desc[6], description[30]; struct part_type_desc desc; }; struct dl_custom_ptype * dl_custom_ptypes; size_t dl_custom_ptype_count; static uint8_t dl_part_type_from_generic(const struct part_type_desc*); static void disklabel_init_default_alignment(struct disklabel_disk_partitions *parts, uint track) { if (track == 0) track = MEG / parts->dp.bytes_per_sector; if (dl_maxpart == 0) dl_maxpart = getmaxpartitions(); #ifdef MD_DISKLABEL_SET_ALIGN_PRE if (MD_DISKLABEL_SET_ALIGN_PRE(parts->ptn_alignment, track)) return; #endif /* Use 1MB alignemnt for large (>128GB) disks */ if (parts->dp.disk_size > HUGE_DISK_SIZE) { parts->ptn_alignment = 2048; } else if (parts->dp.disk_size > TINY_DISK_SIZE || parts->dp.bytes_per_sector > 512) { parts->ptn_alignment = 64; } else { parts->ptn_alignment = 1; } #ifdef MD_DISKLABEL_SET_ALIGN_POST MD_DISKLABEL_SET_ALIGN_POST(parts->ptn_alignment, track); #endif } static bool disklabel_change_geom(struct disk_partitions *arg, int ncyl, int nhead, int nsec) { struct disklabel_disk_partitions *parts = (struct disklabel_disk_partitions*)arg; assert(parts->l.d_secsize != 0); assert(parts->l.d_nsectors != 0); assert(parts->l.d_ntracks != 0); assert(parts->l.d_ncylinders != 0); assert(parts->l.d_secpercyl != 0); disklabel_init_default_alignment(parts, nhead * nsec); if (ncyl*nhead*nsec <= TINY_DISK_SIZE) set_default_sizemult(arg->disk, arg->bytes_per_sector, arg->bytes_per_sector); else set_default_sizemult(arg->disk, MEG, arg->bytes_per_sector); return true; } static size_t disklabel_cylinder_size(const struct disk_partitions *arg) { const struct disklabel_disk_partitions *parts = (const struct disklabel_disk_partitions*)arg; return parts->l.d_secpercyl; } #ifdef NO_DISKLABEL_BOOT static bool disklabel_non_bootable(const char *disk) { return false; } #endif static struct disk_partitions * disklabel_parts_new(const char *dev, daddr_t start, daddr_t len, bool is_boot_drive, struct disk_partitions *parent) { struct disklabel_disk_partitions *parts; struct disk_geom geo; daddr_t total_size; if (!get_disk_geom(dev, &geo)) return NULL; parts = calloc(1, sizeof(*parts)); if (parts == NULL) return NULL; parts->install_target = -1; total_size = geo.dg_secperunit; if (len*(geo.dg_secsize/512) > disklabel_parts.size_limit) len = disklabel_parts.size_limit/(geo.dg_secsize/512); if (total_size*(geo.dg_secsize/512) > disklabel_parts.size_limit) total_size = disklabel_parts.size_limit/(geo.dg_secsize/512); parts->l.d_ncylinders = geo.dg_ncylinders; parts->l.d_ntracks = geo.dg_ntracks; parts->l.d_nsectors = geo.dg_nsectors; parts->l.d_secsize = geo.dg_secsize; parts->l.d_secpercyl = geo.dg_nsectors * geo.dg_ntracks; parts->dp.pscheme = &disklabel_parts; parts->dp.disk = strdup(dev); parts->dp.disk_start = start; parts->dp.disk_size = parts->dp.free_space = len; parts->dp.bytes_per_sector = parts->l.d_secsize; disklabel_init_default_alignment(parts, parts->l.d_secpercyl); parts->dp.parent = parent; strncpy(parts->l.d_packname, "fictious", sizeof parts->l.d_packname); #if RAW_PART == 3 if (parts->dp.parent != NULL) { parts->l.d_partitions[RAW_PART-1].p_fstype = FS_UNUSED; parts->l.d_partitions[RAW_PART-1].p_offset = start; parts->l.d_partitions[RAW_PART-1].p_size = len; parts->dp.num_part++; } #endif parts->l.d_partitions[RAW_PART].p_fstype = FS_UNUSED; parts->l.d_partitions[RAW_PART].p_offset = 0; parts->l.d_partitions[RAW_PART].p_size = total_size; parts->dp.num_part++; parts->l.d_npartitions = RAW_PART+1; return &parts->dp; } static struct disk_partitions * disklabel_parts_read(const char *disk, daddr_t start, daddr_t len, size_t bps, const struct disk_partitioning_scheme *scheme) { int fd; char diskpath[MAXPATHLEN]; uint flags; bool have_own_label = false; /* read partitions */ struct disklabel_disk_partitions *parts = calloc(1, sizeof(*parts)); if (parts == NULL) return NULL; parts->install_target = -1; fd = opendisk(disk, O_RDONLY, diskpath, sizeof(diskpath), 0); if (fd == -1) { free(parts); return NULL; } /* * We should actually try to read the label inside the start/len * boundary, but for simplicity just rely on the kernel and * instead verify a FS_UNUSED partition at RAW_PART-1 (if * RAW_PART > 'c') is within the given limits. */ if (ioctl(fd, DIOCGDINFO, &parts->l) < 0) { free(parts); close(fd); return NULL; } #if RAW_PART == 3 if (parts->l.d_partitions[RAW_PART-1].p_fstype == FS_UNUSED) { daddr_t dlstart = parts->l.d_partitions[RAW_PART-1].p_offset; daddr_t dlend = start + parts->l.d_partitions[RAW_PART-1].p_size; if (dlstart < start || dlend > (start+len)) { /* * Kernel assumes different outer partion * (probably not yet written back to disk) * so this label is invalid. */ free(parts); close(fd); return NULL; } } #endif if (len > disklabel_parts.size_limit) len = disklabel_parts.size_limit; parts->dp.pscheme = scheme; parts->dp.disk = strdup(disk); parts->dp.disk_start = start; parts->dp.disk_size = parts->dp.free_space = len; parts->l.d_secsize = bps; parts->dp.bytes_per_sector = bps; disklabel_init_default_alignment(parts, parts->l.d_secpercyl); for (int part = 0; part < parts->l.d_npartitions; part++) { if (parts->l.d_partitions[part].p_fstype == FS_UNUSED && parts->l.d_partitions[part].p_size == 0) continue; parts->dp.num_part++; if (parts->l.d_partitions[part].p_fstype == FS_UNUSED) continue; flags = 0; if (parts->l.d_partitions[part].p_fstype == FS_MSDOS) flags = GLM_MAYBE_FAT32; else if (parts->l.d_partitions[part].p_fstype == FS_BSDFFS) { flags = GLM_LIKELY_FFS; if (parts->install_target < 0) parts->install_target = parts->l.d_partitions[part].p_offset; } if (flags != 0) { uint fs_type, fs_sub_type; const char *lm = get_last_mounted(fd, parts->l.d_partitions[part].p_offset, &fs_type, &fs_sub_type, flags); if (lm != NULL && *lm != 0) { strlcpy(parts->last_mounted[part], lm, sizeof(parts->last_mounted[part])); if (parts->l.d_partitions[part].p_fstype == fs_type) parts->fs_sub_type[part] = fs_sub_type; canonicalize_last_mounted( parts->last_mounted[part]); } } if (parts->l.d_partitions[part].p_size > parts->dp.free_space) parts->dp.free_space = 0; else parts->dp.free_space -= parts->l.d_partitions[part].p_size; } close(fd); /* * Verify we really have a disklabel on the target disk. */ if (run_program(RUN_SILENT | RUN_ERROR_OK, "disklabel -r %s", disk) == 0) { have_own_label = true; } #ifdef DISKLABEL_NO_ONDISK_VERIFY else { /* * disklabel(8) with -r checks a native disklabel at * LABELOFFSET sector, but several ports don't have * a native label and use emulated one translated from * port specific MD disk partition information. * Unfortunately, there is no MI way to check whether * the disk has a native BSD disklabel by readdisklabel(9) * via DIOCGDINFO. So check if returned label looks * defaults set by readdisklabel(9) per MD way. */ have_own_label = !md_disklabel_is_default(&parts->l); } #endif if (!have_own_label) { bool found_real_part = false; if (parts->l.d_npartitions <= RAW_PART || parts->l.d_partitions[RAW_PART].p_size == 0) goto no_valid_label; /* * Check if kernel translation gave us "something" besides * the raw or the whole-disk partition. * If not: report missing disklabel. */ for (int part = 0; part < parts->l.d_npartitions; part++) { if (parts->l.d_partitions[part].p_fstype == FS_UNUSED) continue; if (/* part == 0 && */ /* PR kern/54882 */ parts->l.d_partitions[part].p_offset == parts->l.d_partitions[RAW_PART].p_offset && parts->l.d_partitions[part].p_size == parts->l.d_partitions[RAW_PART].p_size) continue; if (part == RAW_PART) continue; found_real_part = true; break; } if (!found_real_part) { /* no partion there yet */ no_valid_label: free(parts); return NULL; } } return &parts->dp; } /* * Escape a string for usage as a tag name in a capfile(5), * we really know there is enough space in the destination buffer... */ static void escape_capfile(char *dest, const char *src, size_t len) { while (*src && len > 0) { if (*src == ':') *dest++ = ' '; else *dest++ = *src; src++; len--; } *dest = 0; } static bool disklabel_write_to_disk(struct disk_partitions *arg) { struct disklabel_disk_partitions *parts = (struct disklabel_disk_partitions*)arg; FILE *f; char fname[PATH_MAX], packname[sizeof(parts->l.d_packname)+1], disktype[sizeof(parts->l.d_typename)+1]; int i, rv = 0; const char *disk = parts->dp.disk, *s; const struct partition *lp; char *d; size_t n; assert(parts->l.d_secsize != 0); assert(parts->l.d_nsectors != 0); assert(parts->l.d_ntracks != 0); assert(parts->l.d_ncylinders != 0); assert(parts->l.d_secpercyl != 0); /* make sure we have a 0 terminated packname */ strlcpy(packname, parts->l.d_packname, sizeof packname); if (packname[0] == 0) strcpy(packname, "fictious"); /* fill typename with disk name prefix, if not already set */ if (strlen(parts->l.d_typename) == 0) { for (n = 0, d = parts->l.d_typename, s = disk; *s && n < sizeof(parts->l.d_typename); d++, s++, n++) { if (isdigit((unsigned char)*s)) break; *d = *s; } } /* we need a valid disk type name, so enforce an arbitrary if * above did not yield a usable one */ if (strlen(parts->l.d_typename) == 0) strncpy(parts->l.d_typename, "SCSI", sizeof(parts->l.d_typename)); escape_capfile(disktype, parts->l.d_typename, sizeof(parts->l.d_typename)); sprintf(fname, "/tmp/disklabel.%u", getpid()); f = fopen(fname, "w"); if (f == NULL) return false; lp = parts->l.d_partitions; scripting_fprintf(NULL, "cat <%s\n", fname); scripting_fprintf(f, "%s|NetBSD installation generated:\\\n", disktype); scripting_fprintf(f, "\t:nc#%d:nt#%d:ns#%d:\\\n", parts->l.d_ncylinders, parts->l.d_ntracks, parts->l.d_nsectors); scripting_fprintf(f, "\t:sc#%d:su#%" PRIu32 ":\\\n", parts->l.d_secpercyl, lp[RAW_PART].p_offset+lp[RAW_PART].p_size); scripting_fprintf(f, "\t:se#%d:\\\n", parts->l.d_secsize); for (i = 0; i < parts->l.d_npartitions; i++) { scripting_fprintf(f, "\t:p%c#%" PRIu32 ":o%c#%" PRIu32 ":t%c=%s:", 'a'+i, (uint32_t)lp[i].p_size, 'a'+i, (uint32_t)lp[i].p_offset, 'a'+i, getfslabelname(lp[i].p_fstype, 0)); if (lp[i].p_fstype == FS_BSDLFS || lp[i].p_fstype == FS_BSDFFS) scripting_fprintf (f, "b%c#%" PRIu32 ":f%c#%" PRIu32 ":", 'a'+i, (uint32_t)(lp[i].p_fsize * lp[i].p_frag), 'a'+i, (uint32_t)lp[i].p_fsize); if (i < parts->l.d_npartitions - 1) scripting_fprintf(f, "\\\n"); else scripting_fprintf(f, "\n"); } scripting_fprintf(NULL, "EOF\n"); fclose(f); /* * Label a disk using an MD-specific string DISKLABEL_CMD for * to invoke disklabel. * if MD code does not define DISKLABEL_CMD, this is a no-op. * * i386 port uses "/sbin/disklabel -w -r", just like i386 * miniroot scripts, though this may leave a bogus incore label. * * Sun ports should use DISKLABEL_CMD "/sbin/disklabel -w" * to get incore to ondisk inode translation for the Sun proms. */ #ifdef DISKLABEL_CMD /* disklabel the disk */ rv = run_program(0, "%s -f %s %s '%s' '%s'", DISKLABEL_CMD, fname, disk, disktype, packname); #endif unlink(fname); return rv == 0; } static bool disklabel_delete_all(struct disk_partitions *arg) { struct disklabel_disk_partitions *parts = (struct disklabel_disk_partitions*)arg; daddr_t total_size = parts->l.d_partitions[RAW_PART].p_size; memset(&parts->l.d_partitions, 0, sizeof(parts->l.d_partitions)); parts->dp.num_part = 0; #if RAW_PART == 3 if (parts->dp.parent != NULL) { parts->l.d_partitions[RAW_PART-1].p_fstype = FS_UNUSED; parts->l.d_partitions[RAW_PART-1].p_offset = parts->dp.disk_start; parts->l.d_partitions[RAW_PART-1].p_size = parts->dp.disk_size; parts->dp.num_part++; } #endif parts->l.d_partitions[RAW_PART].p_fstype = FS_UNUSED; parts->l.d_partitions[RAW_PART].p_offset = 0; parts->l.d_partitions[RAW_PART].p_size = total_size; parts->dp.num_part++; parts->l.d_npartitions = RAW_PART+1; return true; } static bool disklabel_delete(struct disk_partitions *arg, part_id id, const char **err_msg) { struct disklabel_disk_partitions *parts = (struct disklabel_disk_partitions*)arg; part_id ndx; ndx = 0; for (int part = 0; part < parts->l.d_npartitions; part++) { if (parts->l.d_partitions[part].p_fstype == FS_UNUSED && parts->l.d_partitions[part].p_size == 0) continue; if (ndx == id) { if (part == RAW_PART #if RAW_PART == 3 || (part == RAW_PART-1 && parts->dp.parent != NULL) #endif ) { if (err_msg) *err_msg = msg_string( MSG_part_not_deletable); return false; } if (parts->install_target == parts->l.d_partitions[part].p_offset) parts->install_target = -1; parts->dp.free_space += parts->l.d_partitions[part].p_size; parts->l.d_partitions[part].p_size = 0; parts->l.d_partitions[part].p_offset = 0; parts->l.d_partitions[part].p_fstype = FS_UNUSED; parts->dp.num_part--; return true; } ndx++; } if (err_msg) *err_msg = INTERNAL_ERROR; return false; } static bool disklabel_delete_range(struct disk_partitions *arg, daddr_t r_start, daddr_t r_size) { struct disklabel_disk_partitions *parts = (struct disklabel_disk_partitions*)arg; for (int part = 0; part < parts->l.d_npartitions; part++) { if (parts->l.d_partitions[part].p_fstype == FS_UNUSED && parts->l.d_partitions[part].p_size == 0) continue; if (part == RAW_PART) continue; daddr_t start = parts->l.d_partitions[part].p_offset; daddr_t end = start + parts->l.d_partitions[part].p_size; #if RAW_PART == 3 if (parts->dp.parent != NULL && part == RAW_PART - 1 && start == r_start && r_start + r_size == end) continue; #endif if ((start >= r_start && start <= r_start+r_size) || (end >= r_start && end <= r_start+r_size)) { if (start == parts->install_target) parts->install_target = -1; if (parts->dp.num_part > 1) parts->dp.num_part--; parts->dp.free_space += parts->l.d_partitions[part].p_size; parts->l.d_partitions[part].p_fstype = FS_UNUSED; parts->l.d_partitions[part].p_size = 0; } } return true; } static void dl_init_types(void) { for (size_t i = 0; i < __arraycount(dl_types); i++) { if (fstypenames[i] == NULL) break; dl_types[i].short_desc = dl_types[i].description = getfslabelname(i, 0); enum part_type pt; switch (i) { case FS_UNUSED: pt = PT_undef; break; case FS_BSDFFS: case FS_RAID: case FS_BSDLFS: case FS_CGD: pt = PT_root; break; case FS_SWAP: pt = PT_swap; break; case FS_MSDOS: pt = PT_FAT; break; case FS_EX2FS: pt = PT_EXT2; break; case FS_SYSVBFS: pt = PT_SYSVBFS; break; default: pt = PT_unknown; break; } dl_types[i].generic_ptype = pt; } } static uint8_t dl_part_type_from_generic(const struct part_type_desc *gent) { if (dl_types[0].description == NULL) dl_init_types(); for (size_t i = 0; i < __arraycount(dl_types); i++) if (gent == &dl_types[i]) return (uint8_t)i; for (size_t i = 0; i < dl_custom_ptype_count; i++) if (gent == &dl_custom_ptypes[i].desc) return dl_custom_ptypes[i].type; return 0; } static size_t disklabel_type_count(void) { return __arraycount(dl_types) + dl_custom_ptype_count; } static const struct part_type_desc * disklabel_get_type(size_t ndx) { if (dl_types[0].description == NULL) dl_init_types(); if (ndx < __arraycount(dl_types)) return &dl_types[ndx]; ndx -= __arraycount(dl_types); if (ndx >= dl_custom_ptype_count) return NULL; return &dl_custom_ptypes[ndx].desc; } static const struct part_type_desc * disklabel_find_type(uint type, bool create_if_unknown) { if (dl_types[0].description == NULL) dl_init_types(); if (type < __arraycount(dl_types)) return &dl_types[type]; for (size_t i = 0; i < dl_custom_ptype_count; i++) if (dl_custom_ptypes[i].type == type) return &dl_custom_ptypes[i].desc; if (create_if_unknown) { struct dl_custom_ptype *nt; nt = realloc(dl_custom_ptypes, dl_custom_ptype_count+1); if (nt == NULL) return NULL; dl_custom_ptypes = nt; nt = dl_custom_ptypes + dl_custom_ptype_count; dl_custom_ptype_count++; memset(nt, 0, sizeof(*nt)); nt->type = type; snprintf(nt->short_desc, sizeof(nt->short_desc), "%u", type); nt->short_desc[sizeof(nt->short_desc)-1] = 0; snprintf(nt->description, sizeof(nt->description), "%s (%u)", msg_string(MSG_custom_type), type); nt->description[sizeof(nt->description)-1] = 0; nt->desc.generic_ptype = PT_unknown; nt->desc.short_desc = nt->short_desc; nt->desc.description = nt->description; return &nt->desc; } return NULL; } static const struct part_type_desc * disklabel_create_custom_part_type(const char *custom, const char **err_msg) { char *endp; unsigned long fstype; fstype = strtoul(custom, &endp, 10); if (*endp != 0) { if (err_msg) *err_msg = msg_string(MSG_dl_type_invalid); return NULL; } return disklabel_find_type(fstype, true); } static const struct part_type_desc * disklabel_get_fs_part_type(enum part_type pt, unsigned fstype, unsigned subtype) { return disklabel_find_type(fstype, false); } static const struct part_type_desc * disklabel_create_unknown_part_type(void) { return disklabel_find_type(FS_OTHER, false); } static const struct part_type_desc * disklabel_get_generic_type(enum part_type pt) { size_t nt; if (dl_types[0].description == NULL) dl_init_types(); switch (pt) { case PT_root: nt = FS_BSDFFS; break; case PT_swap: nt = FS_SWAP; break; case PT_FAT: case PT_EFI_SYSTEM: nt = FS_MSDOS; break; case PT_EXT2: nt = FS_EX2FS; break; case PT_SYSVBFS: nt = FS_SYSVBFS; break; default: nt = FS_UNUSED; break; } return disklabel_get_type(nt); } static bool disklabel_get_default_fstype(const struct part_type_desc *nat_type, unsigned *fstype, unsigned *fs_sub_type) { *fstype = dl_part_type_from_generic(nat_type); #ifdef DEFAULT_UFS2 if (*fstype == FS_BSDFFS) *fs_sub_type = 2; else #endif *fs_sub_type = 0; return true; } static bool disklabel_get_part_info(const struct disk_partitions *arg, part_id id, struct disk_part_info *info) { const struct disklabel_disk_partitions *parts = (const struct disklabel_disk_partitions*)arg; part_id ndx; if (dl_types[0].description == NULL) dl_init_types(); ndx = 0; for (int part = 0; part < parts->l.d_npartitions; part++) { if (parts->l.d_partitions[part].p_fstype == FS_UNUSED && parts->l.d_partitions[part].p_size == 0) continue; if (ndx == id) { memset(info, 0, sizeof(*info)); info->start = parts->l.d_partitions[part].p_offset; info->size = parts->l.d_partitions[part].p_size; info->nat_type = disklabel_find_type( parts->l.d_partitions[part].p_fstype, true); if (parts->last_mounted[part][0] != 0) info->last_mounted = parts->last_mounted[part]; info->fs_type = parts->l.d_partitions[part].p_fstype; info->fs_sub_type = parts->fs_sub_type[part]; info->fs_opt2 = parts->l.d_partitions[part].p_fsize; info->fs_opt1 = info->fs_opt2 * parts->l.d_partitions[part].p_frag; info->fs_opt3 = parts->fs_opt3[part]; if (part == RAW_PART && parts->l.d_partitions[part].p_fstype == FS_UNUSED) info->flags |= PTI_PSCHEME_INTERNAL|PTI_RAW_PART; if (info->start == parts->install_target) info->flags |= PTI_INSTALL_TARGET; #if RAW_PART == 3 if (part == (RAW_PART-1) && parts->dp.parent != NULL && parts->l.d_partitions[part].p_fstype == FS_UNUSED) info->flags |= PTI_PSCHEME_INTERNAL|PTI_WHOLE_DISK; #endif return true; } ndx++; if (ndx > parts->dp.num_part || ndx > id) break; } return false; } static bool disklabel_set_part_info(struct disk_partitions *arg, part_id id, const struct disk_part_info *info, const char **err_msg) { struct disklabel_disk_partitions *parts = (struct disklabel_disk_partitions*)arg; part_id ndx; bool was_inst_target; if (dl_types[0].description == NULL) dl_init_types(); ndx = 0; for (int part = 0; part < parts->l.d_npartitions; part++) { if (parts->l.d_partitions[part].p_fstype == FS_UNUSED && parts->l.d_partitions[part].p_size == 0) continue; if (ndx == id) { was_inst_target = parts->l.d_partitions[part].p_offset == parts->install_target; parts->l.d_partitions[part].p_offset = info->start; if (part != RAW_PART #if RAW_PART == 3 && (part != RAW_PART-1 || parts->dp.parent == NULL) #endif ) { parts->dp.free_space += parts->l.d_partitions[part].p_size - info->size; } parts->l.d_partitions[part].p_size = info->size; parts->l.d_partitions[part].p_fstype = dl_part_type_from_generic(info->nat_type); parts->l.d_partitions[part].p_fsize = info->fs_opt2; if (info->fs_opt2 != 0) parts->l.d_partitions[part].p_frag = info->fs_opt1 / info->fs_opt2; else parts->l.d_partitions[part].p_frag = 0; parts->fs_opt3[part] = info->fs_opt3; if (info->last_mounted != NULL && info->last_mounted != parts->last_mounted[part]) strlcpy(parts->last_mounted[part], info->last_mounted, sizeof(parts->last_mounted[part])); if (info->flags & PTI_INSTALL_TARGET) parts->install_target = info->start; else if (was_inst_target) parts->install_target = -1; assert(info->fs_type == 0 || info->fs_type == parts->l.d_partitions[part].p_fstype); if (info->fs_sub_type != 0) parts->fs_sub_type[part] = info->fs_sub_type; return true; } ndx++; if (ndx > parts->dp.num_part || ndx > id) break; } return false; } static size_t disklabel_get_free_spaces_internal(const struct disklabel_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, i; daddr_t s, e, from, size, end_of_disk; if (start < parts->dp.disk_start) start = parts->dp.disk_start; if (min_space_size < 1) min_space_size = 1; if (align > 1 && (start % align) != 0) start = max(roundup(start, align), align); end_of_disk = parts->dp.disk_start + parts->dp.disk_size; from = start; while (from < end_of_disk && cnt < max_num_result) { again: size = parts->dp.disk_start + parts->dp.disk_size - from; start = from; for (i = 0; i < parts->l.d_npartitions; i++) { if (i == RAW_PART) continue; if (parts->l.d_partitions[i].p_fstype == FS_UNUSED) continue; if (parts->l.d_partitions[i].p_size == 0) continue; s = parts->l.d_partitions[i].p_offset; e = parts->l.d_partitions[i].p_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 bool disklabel_can_add_partition(const struct disk_partitions *arg) { const struct disklabel_disk_partitions *parts = (const struct disklabel_disk_partitions*)arg; struct disk_part_free_space space; int i; if (dl_maxpart == 0) dl_maxpart = getmaxpartitions(); if (parts->dp.free_space < parts->ptn_alignment) return false; if (parts->dp.num_part >= dl_maxpart) return false; if (disklabel_get_free_spaces_internal(parts, &space, 1, parts->ptn_alignment, parts->ptn_alignment, 0, -1) < 1) return false; if (parts->l.d_npartitions < dl_maxpart) return true; for (i = 0; i < parts->l.d_npartitions; i++) { if (i == RAW_PART) continue; #if RAW_PART == 3 if (i == RAW_PART-1 && parts->dp.parent != NULL) continue; #endif if (parts->l.d_partitions[i].p_fstype == FS_UNUSED) return true; } return false; } static bool disklabel_get_disk_pack_name(const struct disk_partitions *arg, char *buf, size_t len) { const struct disklabel_disk_partitions *parts = (const struct disklabel_disk_partitions*)arg; strlcpy(buf, parts->l.d_packname, min(len, sizeof(parts->l.d_packname)+1)); return true; } static bool disklabel_set_disk_pack_name(struct disk_partitions *arg, const char *pack) { struct disklabel_disk_partitions *parts = (struct disklabel_disk_partitions*)arg; strncpy(parts->l.d_packname, pack, sizeof(parts->l.d_packname)); return true; } static bool disklabel_get_part_device(const struct disk_partitions *arg, part_id ptn, char *devname, size_t max_devname_len, int *part, enum dev_name_usage which_name, bool with_path, bool life) { const struct disklabel_disk_partitions *parts = (const struct disklabel_disk_partitions*)arg; part_id id; int part_index; char pname; if (ptn >= parts->l.d_npartitions) return false; for (id = part_index = 0; part_index < parts->l.d_npartitions; part_index++) { if (parts->l.d_partitions[part_index].p_fstype == FS_UNUSED && parts->l.d_partitions[part_index].p_size == 0) continue; if (id == ptn) break; id++; if (id > ptn) return false; } if (part != 0) *part = part_index; pname = 'a'+ part_index; switch (which_name) { case parent_device_only: strlcpy(devname, arg->disk, max_devname_len); return true; case logical_name: case plain_name: if (with_path) snprintf(devname, max_devname_len, _PATH_DEV "%s%c", arg->disk, pname); else snprintf(devname, max_devname_len, "%s%c", arg->disk, pname); return true; case raw_dev_name: if (with_path) snprintf(devname, max_devname_len, _PATH_DEV "r%s%c", arg->disk, pname); else snprintf(devname, max_devname_len, "r%s%c", arg->disk, pname); return true; } return false; } /* * If the requested partition file system type internally skips * the disk label sector, we can allow it to start at the beginning * of the disk. In most cases though we have to move the partition * to start past the label sector. */ static bool need_to_skip_past_label(const struct disk_part_info *info) { switch (info->fs_type) { case FS_BSDFFS: case FS_RAID: return false; } return true; } static part_id disklabel_add_partition(struct disk_partitions *arg, const struct disk_part_info *info, const char **err_msg) { struct disklabel_disk_partitions *parts = (struct disklabel_disk_partitions*)arg; int i, part = -1; part_id new_id; struct disk_part_free_space space; struct disk_part_info data = *info; if (disklabel_get_free_spaces_internal(parts, &space, 1, 1, 1, data.start, -1) < 1) { if (err_msg) *err_msg = msg_string(MSG_No_free_space); return NO_PART; } if (space.start <= (parts->dp.disk_start + LABELSECTOR) && need_to_skip_past_label(&data)) { daddr_t new_start = roundup(parts->dp.disk_start + LABELSECTOR, parts->ptn_alignment); daddr_t off = new_start - space.start; space.start += off; space.size -= off; } if (data.size > space.size) data.size = space.size; daddr_t dend = data.start+data.size; if (space.start > data.start) data.start = space.start; if (space.start + space.size < dend) data.size = space.start+space.size-data.start; if (dl_maxpart == 0) dl_maxpart = getmaxpartitions(); for (new_id = 0, i = 0; i < parts->l.d_npartitions; i++) { if (parts->l.d_partitions[i].p_size > 0) new_id++; if (data.nat_type->generic_ptype != PT_root && data.nat_type->generic_ptype != PT_swap && i < RAW_PART) continue; if (i == 0 && data.nat_type->generic_ptype != PT_root) continue; if (i == 1 && data.nat_type->generic_ptype != PT_swap) continue; if (i == RAW_PART) continue; #if RAW_PART == 3 if (i == RAW_PART-1 && parts->dp.parent != NULL) continue; #endif if (parts->l.d_partitions[i].p_size > 0) continue; part = i; break; } if (part < 0) { if (parts->l.d_npartitions >= dl_maxpart) { if (err_msg) *err_msg = msg_string(MSG_err_too_many_partitions); return NO_PART; } part = parts->l.d_npartitions++; } parts->l.d_partitions[part].p_offset = data.start; parts->l.d_partitions[part].p_size = data.size; parts->l.d_partitions[part].p_fstype = dl_part_type_from_generic(data.nat_type); parts->l.d_partitions[part].p_fsize = info->fs_opt2; if (info->fs_opt2 != 0) parts->l.d_partitions[part].p_frag = info->fs_opt1 / info->fs_opt2; else parts->l.d_partitions[part].p_frag = 0; if (data.last_mounted && data.last_mounted[0]) strlcpy(parts->last_mounted[part], data.last_mounted, sizeof(parts->last_mounted[part])); else parts->last_mounted[part][0] = 0; parts->fs_sub_type[part] = data.fs_sub_type; parts->dp.num_part++; if (data.size <= parts->dp.free_space) parts->dp.free_space -= data.size; else parts->dp.free_space = 0; return new_id; } static part_id disklabel_add_outer_partition(struct disk_partitions *arg, const struct disk_part_info *info, const char **err_msg) { struct disklabel_disk_partitions *parts = (struct disklabel_disk_partitions*)arg; int i, part = -1; part_id new_id; if (dl_maxpart == 0) dl_maxpart = getmaxpartitions(); for (new_id = 0, i = 0; i < parts->l.d_npartitions; i++) { if (parts->l.d_partitions[i].p_size > 0) new_id++; if (info->nat_type->generic_ptype != PT_root && info->nat_type->generic_ptype != PT_swap && i < RAW_PART) continue; if (i == 0 && info->nat_type->generic_ptype != PT_root) continue; if (i == 1 && info->nat_type->generic_ptype != PT_swap) continue; if (i == RAW_PART) continue; #if RAW_PART == 3 if (i == RAW_PART-1 && parts->dp.parent != NULL) continue; #endif if (parts->l.d_partitions[i].p_size > 0) continue; part = i; break; } if (part < 0) { if (parts->l.d_npartitions >= dl_maxpart) { if (err_msg) *err_msg = msg_string(MSG_err_too_many_partitions); return NO_PART; } part = parts->l.d_npartitions++; } parts->l.d_partitions[part].p_offset = info->start; parts->l.d_partitions[part].p_size = info->size; parts->l.d_partitions[part].p_fstype = dl_part_type_from_generic(info->nat_type); parts->l.d_partitions[part].p_fsize = info->fs_opt2; if (info->fs_opt2 != 0) parts->l.d_partitions[part].p_frag = info->fs_opt1 / info->fs_opt2; else parts->l.d_partitions[part].p_frag = 0; if (info->last_mounted && info->last_mounted[0]) strlcpy(parts->last_mounted[part], info->last_mounted, sizeof(parts->last_mounted[part])); else parts->last_mounted[part][0] = 0; parts->fs_sub_type[part] = info->fs_sub_type; parts->dp.num_part++; return new_id; } static size_t disklabel_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 disklabel_disk_partitions *parts = (const struct disklabel_disk_partitions*)arg; return disklabel_get_free_spaces_internal(parts, result, max_num_result, min_space_size, align, start, ignore); } static daddr_t disklabel_max_free_space_at(const struct disk_partitions *arg, daddr_t start) { const struct disklabel_disk_partitions *parts = (const struct disklabel_disk_partitions*)arg; struct disk_part_free_space space; if (disklabel_get_free_spaces_internal(parts, &space, 1, 1, 0, start, start) == 1) return space.size; return 0; } static daddr_t disklabel_get_alignment(const struct disk_partitions *arg) { const struct disklabel_disk_partitions *parts = (const struct disklabel_disk_partitions*)arg; return parts->ptn_alignment; } static part_id disklabel_find_by_name(struct disk_partitions *arg, const char *name) { const struct disklabel_disk_partitions *parts = (const struct disklabel_disk_partitions*)arg; char *sl, part; ptrdiff_t n; part_id pno, id, i; sl = strrchr(name, '/'); if (sl == NULL) return NO_PART; n = sl - name; if (strncmp(name, parts->l.d_packname, n) != 0) return NO_PART; part = name[n+1]; if (part < 'a') return NO_PART; pno = part - 'a'; if (pno >= parts->l.d_npartitions) return NO_PART; if (parts->l.d_partitions[pno].p_fstype == FS_UNUSED) return NO_PART; for (id = 0, i = 0; i < pno; i++) if (parts->l.d_partitions[i].p_fstype != FS_UNUSED || parts->l.d_partitions[i].p_size != 0) id++; return id; } static void disklabel_free(struct disk_partitions *arg) { assert(arg != NULL); free(__UNCONST(arg->disk)); free(arg); } static void disklabel_destroy_part_scheme(struct disk_partitions *arg) { run_program(RUN_SILENT, "disklabel -D %s", arg->disk); free(arg); } const struct disk_partitioning_scheme disklabel_parts = { .name = MSG_parttype_disklabel, .short_name = MSG_parttype_disklabel_short, .new_type_prompt = MSG_dl_get_custom_fstype, .size_limit = (daddr_t)UINT32_MAX, .write_to_disk = disklabel_write_to_disk, .read_from_disk = disklabel_parts_read, .create_new_for_disk = disklabel_parts_new, #ifdef NO_DISKLABEL_BOOT .have_boot_support = disklabel_non_bootable, #endif .change_disk_geom = disklabel_change_geom, .get_cylinder_size = disklabel_cylinder_size, .find_by_name = disklabel_find_by_name, .get_disk_pack_name = disklabel_get_disk_pack_name, .set_disk_pack_name = disklabel_set_disk_pack_name, .delete_all_partitions = disklabel_delete_all, .delete_partitions_in_range = disklabel_delete_range, .delete_partition = disklabel_delete, .get_part_types_count = disklabel_type_count, .get_part_type = disklabel_get_type, .get_generic_part_type = disklabel_get_generic_type, .get_fs_part_type = disklabel_get_fs_part_type, .get_default_fstype = disklabel_get_default_fstype, .create_custom_part_type = disklabel_create_custom_part_type, .create_unknown_part_type = disklabel_create_unknown_part_type, .get_part_alignment = disklabel_get_alignment, .adapt_foreign_part_info = generic_adapt_foreign_part_info, .get_part_info = disklabel_get_part_info, .can_add_partition = disklabel_can_add_partition, .set_part_info = disklabel_set_part_info, .add_partition = disklabel_add_partition, .add_outer_partition = disklabel_add_outer_partition, .max_free_space_at = disklabel_max_free_space_at, .get_free_spaces = disklabel_get_free_spaces, .get_part_device = disklabel_get_part_device, .free = disklabel_free, .destroy_part_scheme = disklabel_destroy_part_scheme, };