diff --git a/usr.sbin/bsdinstall/partedit/gpart_ops.c b/usr.sbin/bsdinstall/partedit/gpart_ops.c index 65cda247e146..26aedb58ef39 100644 --- a/usr.sbin/bsdinstall/partedit/gpart_ops.c +++ b/usr.sbin/bsdinstall/partedit/gpart_ops.c @@ -1,1538 +1,1544 @@ /*- * SPDX-License-Identifier: BSD-2-Clause-FreeBSD * * Copyright (c) 2011 Nathan Whitehorn * 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 THE AUTHOR AND CONTRIBUTORS ``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 THE AUTHOR OR CONTRIBUTORS 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. * * $FreeBSD$ */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include "partedit.h" #define GPART_FLAGS "x" /* Do not commit changes by default */ static void gpart_show_error(const char *title, const char *explanation, const char *errstr) { char *errmsg; char message[512]; int error; struct bsddialog_conf conf; if (explanation == NULL) explanation = ""; error = strtol(errstr, &errmsg, 0); if (errmsg != errstr) { while (errmsg[0] == ' ') errmsg++; if (errmsg[0] != '\0') sprintf(message, "%s%s. %s", explanation, strerror(error), errmsg); else sprintf(message, "%s%s", explanation, strerror(error)); } else { sprintf(message, "%s%s", explanation, errmsg); } bsddialog_initconf(&conf); conf.title = title; bsddialog_msgbox(&conf, message, 0, 0); } static int scheme_supports_labels(const char *scheme) { if (strcmp(scheme, "APM") == 0) return (1); if (strcmp(scheme, "GPT") == 0) return (1); return (0); } static void newfs_command(const char *fstype, char *command, int use_default) { struct bsddialog_conf conf; bsddialog_initconf(&conf); if (strcmp(fstype, "freebsd-ufs") == 0) { int i; struct bsddialog_menuitem items[] = { {"", false, 0, "UFS1", "UFS Version 1", "Use version 1 of the UFS file system instead " "of version 2 (not recommended)"}, {"", true, 0, "SU", "Softupdates", "Enable softupdates (default)"}, {"", true, 0, "SUJ", "Softupdates journaling", "Enable file system journaling (default - " "turn off for SSDs)"}, {"", false, 0, "TRIM", "Enable SSD TRIM support", "Enable TRIM support, useful on solid-state " "drives" }, }; if (!use_default) { int choice; conf.title = "UFS Options"; choice = bsddialog_checklist(&conf, "", 0, 0, 0, nitems(items), items, NULL); if (choice == BSDDIALOG_CANCEL) return; } strcpy(command, "newfs "); for (i = 0; i < (int)nitems(items); i++) { if (items[i].on == false) continue; if (strcmp(items[i].name, "UFS1") == 0) strcat(command, "-O1 "); else if (strcmp(items[i].name, "SU") == 0) strcat(command, "-U "); else if (strcmp(items[i].name, "SUJ") == 0) strcat(command, "-j "); else if (strcmp(items[i].name, "TRIM") == 0) strcat(command, "-t "); } } else if (strcmp(fstype, "freebsd-zfs") == 0) { int i; struct bsddialog_menuitem items[] = { {"", 0, true, "fletcher4", "checksum algorithm: fletcher4", "Use fletcher4 for data integrity checking. " "(default)"}, {"", 0, false, "fletcher2", "checksum algorithm: fletcher2", "Use fletcher2 for data integrity checking. " "(not recommended)"}, {"", 0, false, "sha256", "checksum algorithm: sha256", "Use sha256 for data integrity checking. " "(not recommended)"}, {"", 0, false, "atime", "Update atimes for files", "Disable atime update"}, }; if (!use_default) { int choice; conf.title = "ZFS Options"; choice = bsddialog_checklist(&conf, "", 0, 0, 0, nitems(items), items, NULL); if (choice == BSDDIALOG_CANCEL) return; } strcpy(command, "zpool create -f -m none "); if (getenv("BSDINSTALL_TMPBOOT") != NULL) { char zfsboot_path[MAXPATHLEN]; snprintf(zfsboot_path, sizeof(zfsboot_path), "%s/zfs", getenv("BSDINSTALL_TMPBOOT")); mkdir(zfsboot_path, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH); sprintf(command, "%s -o cachefile=%s/zpool.cache ", command, zfsboot_path); } for (i = 0; i < (int)nitems(items); i++) { if (items[i].on == false) continue; if (strcmp(items[i].name, "fletcher4") == 0) strcat(command, "-O checksum=fletcher4 "); else if (strcmp(items[i].name, "fletcher2") == 0) strcat(command, "-O checksum=fletcher2 "); else if (strcmp(items[i].name, "sha256") == 0) strcat(command, "-O checksum=sha256 "); else if (strcmp(items[i].name, "atime") == 0) strcat(command, "-O atime=off "); } } else if (strcmp(fstype, "fat32") == 0 || strcmp(fstype, "efi") == 0 || strcmp(fstype, "ms-basic-data") == 0) { int i; struct bsddialog_menuitem items[] = { {"", 0, true, "FAT32", "FAT Type 32", "Create a FAT32 filesystem (default)"}, {"", 0, false, "FAT16", "FAT Type 16", "Create a FAT16 filesystem"}, {"", 0, false, "FAT12", "FAT Type 12", "Create a FAT12 filesystem"}, }; if (!use_default) { int choice; conf.title = "FAT Options"; choice = bsddialog_radiolist(&conf, "", 0, 0, 0, nitems(items), items, NULL); if (choice == BSDDIALOG_CANCEL) return; } strcpy(command, "newfs_msdos "); for (i = 0; i < (int)nitems(items); i++) { if (items[i].on == false) continue; if (strcmp(items[i].name, "FAT32") == 0) strcat(command, "-F 32 -c 1"); else if (strcmp(items[i].name, "FAT16") == 0) strcat(command, "-F 16 "); else if (strcmp(items[i].name, "FAT12") == 0) strcat(command, "-F 12 "); } } else { if (!use_default) { conf.title = "Error"; bsddialog_msgbox(&conf, "No configurable options exist " "for this filesystem.", 0, 0); } command[0] = '\0'; } } const char * choose_part_type(const char *def_scheme) { int button, choice, i; const char *scheme = NULL; struct bsddialog_conf conf; struct bsddialog_menuitem items[] = { {"", false, 0, "APM", "Apple Partition Map", "Bootable on PowerPC Apple Hardware" }, {"", false, 0, "BSD", "BSD Labels", "Bootable on most x86 systems" }, {"", false, 0, "GPT", "GUID Partition Table", "Bootable on most x86 systems and EFI aware ARM64" }, {"", false, 0, "MBR", "DOS Partitions", "Bootable on most x86 systems" }, }; for (i = 0; i < (int)nitems(items); i++) if (strcmp(items[i].name, def_scheme) == 0) choice = i; bsddialog_initconf(&conf); parttypemenu: conf.title = "Partition Scheme"; button = bsddialog_menu(&conf, "Select a partition scheme for this volume:", 0, 0, 0, nitems(items), items, &choice); if (button == BSDDIALOG_CANCEL) return NULL; if (!is_scheme_bootable(items[choice].name)) { char message[512]; sprintf(message, "This partition scheme (%s) is not " "bootable on this platform. Are you sure you want " "to proceed?", items[choice].name); conf.button.default_cancel = true; conf.title = "Warning"; button = bsddialog_yesno(&conf, message, 0, 0); conf.button.default_cancel = false; if (button == BSDDIALOG_NO) goto parttypemenu; } scheme = items[choice].name; return scheme; } int gpart_partition(const char *lg_name, const char *scheme) { int button; struct gctl_req *r; const char *errstr; struct bsddialog_conf conf; bsddialog_initconf(&conf); schememenu: if (scheme == NULL) { scheme = choose_part_type(default_scheme()); if (scheme == NULL) return (-1); if (!is_scheme_bootable(scheme)) { char message[512]; sprintf(message, "This partition scheme (%s) is not " "bootable on this platform. Are you sure you want " "to proceed?", scheme); conf.button.default_cancel = true; conf.title = "Warning"; button = bsddialog_yesno(&conf, message, 0, 0); conf.button.default_cancel = false; if (button == BSDDIALOG_NO) { /* Reset scheme so user can choose another */ scheme = NULL; goto schememenu; } } } r = gctl_get_handle(); gctl_ro_param(r, "class", -1, "PART"); gctl_ro_param(r, "arg0", -1, lg_name); gctl_ro_param(r, "flags", -1, GPART_FLAGS); gctl_ro_param(r, "scheme", -1, scheme); gctl_ro_param(r, "verb", -1, "create"); errstr = gctl_issue(r); if (errstr != NULL && errstr[0] != '\0') { gpart_show_error("Error", NULL, errstr); gctl_free(r); scheme = NULL; goto schememenu; } gctl_free(r); if (bootcode_path(scheme) != NULL) get_part_metadata(lg_name, 1)->bootcode = 1; return (0); } static void gpart_activate(struct gprovider *pp) { struct gconfig *gc; struct gctl_req *r; const char *errstr, *scheme; const char *attribute = NULL; intmax_t idx; /* * Some partition schemes need this partition to be marked 'active' * for it to be bootable. */ LIST_FOREACH(gc, &pp->lg_geom->lg_config, lg_config) { if (strcmp(gc->lg_name, "scheme") == 0) { scheme = gc->lg_val; break; } } if (strcmp(scheme, "MBR") == 0 || strcmp(scheme, "EBR") == 0) attribute = "active"; else return; LIST_FOREACH(gc, &pp->lg_config, lg_config) { if (strcmp(gc->lg_name, "index") == 0) { idx = atoi(gc->lg_val); break; } } r = gctl_get_handle(); gctl_ro_param(r, "class", -1, "PART"); gctl_ro_param(r, "arg0", -1, pp->lg_geom->lg_name); gctl_ro_param(r, "verb", -1, "set"); gctl_ro_param(r, "attrib", -1, attribute); gctl_ro_param(r, "index", sizeof(idx), &idx); errstr = gctl_issue(r); if (errstr != NULL && errstr[0] != '\0') gpart_show_error("Error", "Error marking partition active:", errstr); gctl_free(r); } void gpart_set_root(const char *lg_name, const char *attribute) { struct gctl_req *r; const char *errstr; r = gctl_get_handle(); gctl_ro_param(r, "class", -1, "PART"); gctl_ro_param(r, "arg0", -1, lg_name); gctl_ro_param(r, "flags", -1, "C"); gctl_ro_param(r, "verb", -1, "set"); gctl_ro_param(r, "attrib", -1, attribute); errstr = gctl_issue(r); if (errstr != NULL && errstr[0] != '\0') gpart_show_error("Error", "Error setting parameter on disk:", errstr); gctl_free(r); } static void gpart_bootcode(struct ggeom *gp) { const char *bootcode; struct gconfig *gc; struct gctl_req *r; const char *errstr, *scheme; uint8_t *boot; size_t bootsize, bytes; int bootfd; struct bsddialog_conf conf; /* * Write default bootcode to the newly partitioned disk, if that * applies on this platform. */ LIST_FOREACH(gc, &gp->lg_config, lg_config) { if (strcmp(gc->lg_name, "scheme") == 0) { scheme = gc->lg_val; break; } } bootcode = bootcode_path(scheme); if (bootcode == NULL) return; bootfd = open(bootcode, O_RDONLY); if (bootfd < 0) { bsddialog_initconf(&conf); conf.title = "Bootcode Error"; bsddialog_msgbox(&conf, strerror(errno), 0, 0); return; } bootsize = lseek(bootfd, 0, SEEK_END); boot = malloc(bootsize); lseek(bootfd, 0, SEEK_SET); bytes = 0; while (bytes < bootsize) bytes += read(bootfd, boot + bytes, bootsize - bytes); close(bootfd); r = gctl_get_handle(); gctl_ro_param(r, "class", -1, "PART"); gctl_ro_param(r, "arg0", -1, gp->lg_name); gctl_ro_param(r, "verb", -1, "bootcode"); gctl_ro_param(r, "bootcode", bootsize, boot); errstr = gctl_issue(r); if (errstr != NULL && errstr[0] != '\0') gpart_show_error("Bootcode Error", NULL, errstr); gctl_free(r); free(boot); } static void gpart_partcode(struct gprovider *pp, const char *fstype) { struct gconfig *gc; const char *scheme; const char *indexstr; char message[255], command[255]; struct bsddialog_conf conf; LIST_FOREACH(gc, &pp->lg_geom->lg_config, lg_config) { if (strcmp(gc->lg_name, "scheme") == 0) { scheme = gc->lg_val; break; } } /* Make sure this partition scheme needs partcode on this platform */ if (partcode_path(scheme, fstype) == NULL) return; LIST_FOREACH(gc, &pp->lg_config, lg_config) { if (strcmp(gc->lg_name, "index") == 0) { indexstr = gc->lg_val; break; } } /* Shell out to gpart for partcode for now */ sprintf(command, "gpart bootcode -p %s -i %s %s", partcode_path(scheme, fstype), indexstr, pp->lg_geom->lg_name); if (system(command) != 0) { sprintf(message, "Error installing partcode on partition %s", pp->lg_name); bsddialog_initconf(&conf); conf.title = "Error"; bsddialog_msgbox(&conf, message, 0, 0); } } void gpart_destroy(struct ggeom *lg_geom) { struct gctl_req *r; struct gprovider *pp; const char *errstr; int force = 1; /* Delete all child metadata */ LIST_FOREACH(pp, &lg_geom->lg_provider, lg_provider) gpart_delete(pp); /* Revert any local changes to get this geom into a pristine state */ r = gctl_get_handle(); gctl_ro_param(r, "class", -1, "PART"); gctl_ro_param(r, "arg0", -1, lg_geom->lg_name); gctl_ro_param(r, "verb", -1, "undo"); gctl_issue(r); /* Ignore errors -- these are non-fatal */ gctl_free(r); /* Now destroy the geom itself */ r = gctl_get_handle(); gctl_ro_param(r, "class", -1, "PART"); gctl_ro_param(r, "arg0", -1, lg_geom->lg_name); gctl_ro_param(r, "flags", -1, GPART_FLAGS); gctl_ro_param(r, "force", sizeof(force), &force); gctl_ro_param(r, "verb", -1, "destroy"); errstr = gctl_issue(r); if (errstr != NULL && errstr[0] != '\0') { /* * Check if we reverted away the existence of the geom * altogether. Show all other errors to the user. */ if (strtol(errstr, NULL, 0) != EINVAL) gpart_show_error("Error", NULL, errstr); } gctl_free(r); /* And any metadata associated with the partition scheme itself */ delete_part_metadata(lg_geom->lg_name); } void gpart_edit(struct gprovider *pp) { struct gctl_req *r; struct gconfig *gc; struct gconsumer *cp; struct ggeom *geom; const char *errstr, *oldtype, *scheme; struct partition_metadata *md; char sizestr[32]; char newfs[255]; intmax_t idx; int hadlabel, choice, nitems; unsigned i; struct bsddialog_conf conf; struct bsddialog_formitem items[] = { { "Type:", 1, 1, "", 1, 12, 12, 15, NULL, 0, "Filesystem type (e.g. freebsd-ufs, freebsd-zfs, " "freebsd-swap)"}, { "Size:", 2, 1, "", 2, 12, 12, 15, NULL, 0, "Partition size. Append K, M, G for kilobytes, " "megabytes or gigabytes."}, { "Mountpoint:", 3, 1, "", 3, 12, 12, 15, NULL, 0, "Path at which to mount this partition (leave blank " "for swap, set to / for root filesystem)"}, { "Label:", 4, 1, "", 4, 12, 12, 15, NULL, 0, "Partition name. Not all partition schemes support this."}, }; bsddialog_initconf(&conf); /* * Find the PART geom we are manipulating. This may be a consumer of * this provider, or its parent. Check the consumer case first. */ geom = NULL; LIST_FOREACH(cp, &pp->lg_consumers, lg_consumers) if (strcmp(cp->lg_geom->lg_class->lg_name, "PART") == 0) { /* Check for zombie geoms, treating them as blank */ scheme = NULL; LIST_FOREACH(gc, &cp->lg_geom->lg_config, lg_config) { if (strcmp(gc->lg_name, "scheme") == 0) { scheme = gc->lg_val; break; } } if (scheme == NULL || strcmp(scheme, "(none)") == 0) { gpart_partition(cp->lg_geom->lg_name, NULL); return; } /* If this is a nested partition, edit as usual */ if (strcmp(pp->lg_geom->lg_class->lg_name, "PART") == 0) break; /* Destroy the geom and all sub-partitions */ gpart_destroy(cp->lg_geom); /* Now re-partition and return */ gpart_partition(cp->lg_geom->lg_name, NULL); return; } if (geom == NULL && strcmp(pp->lg_geom->lg_class->lg_name, "PART") == 0) geom = pp->lg_geom; if (geom == NULL) { /* Disk not partitioned, so partition it */ gpart_partition(pp->lg_name, NULL); return; } LIST_FOREACH(gc, &geom->lg_config, lg_config) { if (strcmp(gc->lg_name, "scheme") == 0) { scheme = gc->lg_val; break; } } nitems = scheme_supports_labels(scheme) ? 4 : 3; /* Edit editable parameters of a partition */ hadlabel = 0; LIST_FOREACH(gc, &pp->lg_config, lg_config) { if (strcmp(gc->lg_name, "type") == 0) { oldtype = gc->lg_val; items[0].init = gc->lg_val; } if (strcmp(gc->lg_name, "label") == 0 && gc->lg_val != NULL) { hadlabel = 1; items[3].init = gc->lg_val; } if (strcmp(gc->lg_name, "index") == 0) idx = atoi(gc->lg_val); } TAILQ_FOREACH(md, &part_metadata, metadata) { if (md->name != NULL && strcmp(md->name, pp->lg_name) == 0) { if (md->fstab != NULL) items[2].init = md->fstab->fs_file; break; } } humanize_number(sizestr, 7, pp->lg_mediasize, "B", HN_AUTOSCALE, HN_NOSPACE | HN_DECIMAL); items[1].init = sizestr; editpart: conf.form.value_without_ok = true; conf.title = "Edit Partition"; choice = bsddialog_form(&conf, "", 0, 0, 0, nitems, items); if (choice == BSDDIALOG_CANCEL) goto endedit; /* If this is the root partition, check that this fs is bootable */ if (strcmp(items[2].value, "/") == 0 && !is_fs_bootable(scheme, items[0].value)) { char message[512]; sprintf(message, "This file system (%s) is not bootable " "on this system. Are you sure you want to proceed?", items[0].value); conf.button.default_cancel = true; conf.title = "Warning"; choice = bsddialog_yesno(&conf, message, 0, 0); conf.button.default_cancel = false; if (choice == BSDDIALOG_CANCEL) goto editpart; } /* Check if the label has a / in it */ if (items[3].value != NULL && strchr(items[3].value, '/') != NULL) { conf.title = "Error"; bsddialog_msgbox(&conf, "Label contains a /, which is not an " "allowed character.", 0, 0); goto editpart; } r = gctl_get_handle(); gctl_ro_param(r, "class", -1, "PART"); gctl_ro_param(r, "arg0", -1, geom->lg_name); gctl_ro_param(r, "flags", -1, GPART_FLAGS); gctl_ro_param(r, "verb", -1, "modify"); gctl_ro_param(r, "index", sizeof(idx), &idx); if (items[3].value != NULL && (hadlabel || items[3].value[0] != '\0')) gctl_ro_param(r, "label", -1, items[3].value); gctl_ro_param(r, "type", -1, items[0].value); errstr = gctl_issue(r); if (errstr != NULL && errstr[0] != '\0') { gpart_show_error("Error", NULL, errstr); gctl_free(r); goto editpart; } gctl_free(r); newfs_command(items[0].value, newfs, 1); set_default_part_metadata(pp->lg_name, scheme, items[0].value, items[2].value, (strcmp(oldtype, items[0].value) != 0) ? newfs : NULL); endedit: if (strcmp(oldtype, items[0].value) != 0 && cp != NULL) gpart_destroy(cp->lg_geom); if (strcmp(oldtype, items[0].value) != 0 && strcmp(items[0].value, "freebsd") == 0) gpart_partition(pp->lg_name, "BSD"); for (i = 0; i < nitems(items); i++) if (items[i].value != NULL) free(items[i].value); } void set_default_part_metadata(const char *name, const char *scheme, const char *type, const char *mountpoint, const char *newfs) { struct partition_metadata *md; char *zpool_name = NULL; const char *default_bootmount = NULL; int i; /* Set part metadata */ md = get_part_metadata(name, 1); if (newfs) { if (md->newfs != NULL) { free(md->newfs); md->newfs = NULL; } if (newfs != NULL && newfs[0] != '\0') { md->newfs = malloc(strlen(newfs) + strlen(" /dev/") + strlen(mountpoint) + 5 + strlen(name) + 1); if (strcmp("freebsd-zfs", type) == 0) { zpool_name = strdup((strlen(mountpoint) == 1) ? "root" : &mountpoint[1]); for (i = 0; zpool_name[i] != 0; i++) if (!isalnum(zpool_name[i])) zpool_name[i] = '_'; sprintf(md->newfs, "%s %s /dev/%s", newfs, zpool_name, name); } else { sprintf(md->newfs, "%s /dev/%s", newfs, name); } } } if (strcmp(type, "freebsd-swap") == 0) mountpoint = "none"; if (strcmp(type, bootpart_type(scheme, &default_bootmount)) == 0) { if (default_bootmount == NULL) md->bootcode = 1; else if (mountpoint == NULL || strlen(mountpoint) == 0) mountpoint = default_bootmount; } if (mountpoint == NULL || mountpoint[0] == '\0') { if (md->fstab != NULL) { free(md->fstab->fs_spec); free(md->fstab->fs_file); free(md->fstab->fs_vfstype); free(md->fstab->fs_mntops); free(md->fstab->fs_type); free(md->fstab); md->fstab = NULL; } } else { if (md->fstab == NULL) { md->fstab = malloc(sizeof(struct fstab)); } else { free(md->fstab->fs_spec); free(md->fstab->fs_file); free(md->fstab->fs_vfstype); free(md->fstab->fs_mntops); free(md->fstab->fs_type); } if (strcmp("freebsd-zfs", type) == 0) { md->fstab->fs_spec = strdup(zpool_name); } else { md->fstab->fs_spec = malloc(strlen(name) + strlen("/dev/") + 1); sprintf(md->fstab->fs_spec, "/dev/%s", name); } md->fstab->fs_file = strdup(mountpoint); /* Get VFS from text after freebsd-, if possible */ if (strncmp("freebsd-", type, 8) == 0) md->fstab->fs_vfstype = strdup(&type[8]); else if (strcmp("fat32", type) == 0 || strcmp("efi", type) == 0 || strcmp("ms-basic-data", type) == 0) md->fstab->fs_vfstype = strdup("msdosfs"); else md->fstab->fs_vfstype = strdup(type); /* Guess */ if (strcmp(type, "freebsd-swap") == 0) { md->fstab->fs_type = strdup(FSTAB_SW); md->fstab->fs_freq = 0; md->fstab->fs_passno = 0; } else if (strcmp(type, "freebsd-zfs") == 0) { md->fstab->fs_type = strdup(FSTAB_RW); md->fstab->fs_freq = 0; md->fstab->fs_passno = 0; } else { md->fstab->fs_type = strdup(FSTAB_RW); if (strcmp(mountpoint, "/") == 0) { md->fstab->fs_freq = 1; md->fstab->fs_passno = 1; } else { md->fstab->fs_freq = 2; md->fstab->fs_passno = 2; } } md->fstab->fs_mntops = strdup(md->fstab->fs_type); } if (zpool_name != NULL) free(zpool_name); } static int part_compare(const void *xa, const void *xb) { struct gprovider **a = (struct gprovider **)xa; struct gprovider **b = (struct gprovider **)xb; intmax_t astart, bstart; struct gconfig *gc; astart = bstart = 0; LIST_FOREACH(gc, &(*a)->lg_config, lg_config) if (strcmp(gc->lg_name, "start") == 0) { astart = strtoimax(gc->lg_val, NULL, 0); break; } LIST_FOREACH(gc, &(*b)->lg_config, lg_config) if (strcmp(gc->lg_name, "start") == 0) { bstart = strtoimax(gc->lg_val, NULL, 0); break; } if (astart < bstart) return -1; else if (astart > bstart) return 1; else return 0; } intmax_t gpart_max_free(struct ggeom *geom, intmax_t *npartstart) { struct gconfig *gc; struct gprovider *pp, **providers; intmax_t sectorsize, stripesize, offset; intmax_t lastend; intmax_t start, end; intmax_t maxsize, maxstart; intmax_t partstart, partend; int i, nparts; /* Now get the maximum free size and free start */ start = end = 0; LIST_FOREACH(gc, &geom->lg_config, lg_config) { if (strcmp(gc->lg_name, "first") == 0) start = strtoimax(gc->lg_val, NULL, 0); if (strcmp(gc->lg_name, "last") == 0) end = strtoimax(gc->lg_val, NULL, 0); } i = nparts = 0; LIST_FOREACH(pp, &geom->lg_provider, lg_provider) nparts++; providers = calloc(nparts, sizeof(providers[0])); LIST_FOREACH(pp, &geom->lg_provider, lg_provider) providers[i++] = pp; qsort(providers, nparts, sizeof(providers[0]), part_compare); lastend = start - 1; maxsize = 0; for (i = 0; i < nparts; i++) { pp = providers[i]; LIST_FOREACH(gc, &pp->lg_config, lg_config) { if (strcmp(gc->lg_name, "start") == 0) partstart = strtoimax(gc->lg_val, NULL, 0); if (strcmp(gc->lg_name, "end") == 0) partend = strtoimax(gc->lg_val, NULL, 0); } if (partstart - lastend > maxsize) { maxsize = partstart - lastend - 1; maxstart = lastend + 1; } lastend = partend; } if (end - lastend > maxsize) { maxsize = end - lastend; maxstart = lastend + 1; } pp = LIST_FIRST(&geom->lg_consumer)->lg_provider; /* * Round the start and size of the largest available space up to * the nearest multiple of the adjusted stripe size. * * The adjusted stripe size is the least common multiple of the * actual stripe size, or the sector size if no stripe size was * reported, and 4096. The reason for this is that contemporary * disks often have 4096-byte physical sectors but report 512 * bytes instead for compatibility with older / broken operating * systems and BIOSes. For the same reasons, virtualized storage * may also report a 512-byte stripe size, or none at all. */ sectorsize = pp->lg_sectorsize; if ((stripesize = pp->lg_stripesize) == 0) stripesize = sectorsize; while (stripesize % 4096 != 0) stripesize *= 2; if ((offset = maxstart * sectorsize % stripesize) != 0) { offset = (stripesize - offset) / sectorsize; maxstart += offset; maxsize -= offset; } if (npartstart != NULL) *npartstart = maxstart; return (maxsize); } static size_t add_boot_partition(struct ggeom *geom, struct gprovider *pp, const char *scheme, int interactive) { struct gconfig *gc; struct gprovider *ppi; int choice; struct bsddialog_conf conf; /* Check for existing freebsd-boot partition */ LIST_FOREACH(ppi, &geom->lg_provider, lg_provider) { struct partition_metadata *md; const char *bootmount = NULL; LIST_FOREACH(gc, &ppi->lg_config, lg_config) if (strcmp(gc->lg_name, "type") == 0) break; if (gc == NULL) continue; if (strcmp(gc->lg_val, bootpart_type(scheme, &bootmount)) != 0) continue; /* * If the boot partition is not mountable and needs partcode, * but doesn't have it, it doesn't satisfy our requirements. */ md = get_part_metadata(ppi->lg_name, 0); if (bootmount == NULL && (md == NULL || !md->bootcode)) continue; /* If it is mountable, but mounted somewhere else, remount */ if (bootmount != NULL && md != NULL && md->fstab != NULL && strlen(md->fstab->fs_file) > 0 && strcmp(md->fstab->fs_file, bootmount) != 0) continue; /* If it is mountable, but mountpoint is not set, mount it */ if (bootmount != NULL && md == NULL) set_default_part_metadata(ppi->lg_name, scheme, gc->lg_val, bootmount, NULL); /* Looks good at this point, no added data needed */ return (0); } if (interactive) { bsddialog_initconf(&conf); conf.title = "Boot Partition"; choice = bsddialog_yesno(&conf, "This partition scheme requires a boot partition " "for the disk to be bootable. Would you like to " "make one now?", 0, 0); } else { choice = BSDDIALOG_YES; } if (choice == BSDDIALOG_YES) { struct partition_metadata *md; const char *bootmount = NULL; char *bootpartname = NULL; char sizestr[7]; humanize_number(sizestr, 7, bootpart_size(scheme), "B", HN_AUTOSCALE, HN_NOSPACE | HN_DECIMAL); gpart_create(pp, bootpart_type(scheme, &bootmount), sizestr, bootmount, &bootpartname, 0); if (bootpartname == NULL) /* Error reported to user already */ return 0; /* If the part is not mountable, make sure newfs isn't set */ if (bootmount == NULL) { md = get_part_metadata(bootpartname, 0); if (md != NULL && md->newfs != NULL) { free(md->newfs); md->newfs = NULL; } } free(bootpartname); return (bootpart_size(scheme)); } return (0); } void gpart_create(struct gprovider *pp, const char *default_type, const char *default_size, const char *default_mountpoint, char **partname, int interactive) { struct gctl_req *r; struct gconfig *gc; struct gconsumer *cp; struct ggeom *geom; const char *errstr, *scheme; char sizestr[32], startstr[32], output[64], *newpartname; char newfs[255], options_fstype[64]; intmax_t maxsize, size, sector, firstfree, stripe; uint64_t bytes; int nitems, choice, junk; unsigned i; bool init_allocated; struct bsddialog_conf conf; struct bsddialog_formitem items[] = { {"Type:", 1, 1, "freebsd-ufs", 1, 12, 12, 15, NULL, 0, "Filesystem type (e.g. freebsd-ufs, freebsd-zfs, " "freebsd-swap)"}, {"Size:", 2, 1, "", 2, 12, 12, 15, NULL, 0, "Partition size. Append K, M, G for kilobytes, " "megabytes or gigabytes."}, {"Mountpoint:", 3, 1, "", 3, 12, 12, 15, NULL, 0, "Path at which to mount partition (blank for " "swap, / for root filesystem)"}, {"Label:", 4, 1, "", 4, 12, 12, 15, NULL, 0, "Partition name. Not all partition schemes support this."}, }; bsddialog_initconf(&conf); if (partname != NULL) *partname = NULL; /* Record sector and stripe sizes */ sector = pp->lg_sectorsize; stripe = pp->lg_stripesize; /* * Find the PART geom we are manipulating. This may be a consumer of * this provider, or its parent. Check the consumer case first. */ geom = NULL; LIST_FOREACH(cp, &pp->lg_consumers, lg_consumers) if (strcmp(cp->lg_geom->lg_class->lg_name, "PART") == 0) { geom = cp->lg_geom; break; } if (geom == NULL && strcmp(pp->lg_geom->lg_class->lg_name, "PART") == 0) geom = pp->lg_geom; /* Now get the partition scheme */ scheme = NULL; if (geom != NULL) { LIST_FOREACH(gc, &geom->lg_config, lg_config) if (strcmp(gc->lg_name, "scheme") == 0) scheme = gc->lg_val; } if (geom == NULL || scheme == NULL || strcmp(scheme, "(none)") == 0) { if (gpart_partition(pp->lg_name, NULL) == 0) { bsddialog_msgbox(&conf, "The partition table has been successfully created." " Please press Create again to create partitions.", 0, 0); } return; } /* * If we still don't have a geom, either the user has * canceled partitioning or there has been an error which has already * been displayed, so bail. */ if (geom == NULL) return; maxsize = size = gpart_max_free(geom, &firstfree); if (size <= 0) { conf .title = "Error"; bsddialog_msgbox(&conf, "No free space left on device.", 0, 0); return; } humanize_number(sizestr, 7, size*sector, "B", HN_AUTOSCALE, HN_NOSPACE | HN_DECIMAL); items[1].init = sizestr; /* Special-case the MBR default type for nested partitions */ if (strcmp(scheme, "MBR") == 0) { items[0].init = "freebsd"; items[0].bottomdesc = "Filesystem type (e.g. freebsd, fat32)"; } nitems = scheme_supports_labels(scheme) ? 4 : 3; if (default_type != NULL) items[0].init = (char *)default_type; if (default_size != NULL) items[1].init = (char *)default_size; if (default_mountpoint != NULL) items[2].init = (char *)default_mountpoint; /* Default options */ strncpy(options_fstype, items[0].init, sizeof(options_fstype)); newfs_command(options_fstype, newfs, 1); init_allocated = false; addpartform: if (interactive) { conf.button.with_extra = true; conf.button.extra_label = "Options"; conf.form.value_without_ok = true; conf.title = "Add Partition"; choice = bsddialog_form(&conf, "", 0, 0, 0, nitems, items); conf.button.with_extra = false; conf.button.extra_label = NULL; conf.form.value_without_ok = false; switch (choice) { case BSDDIALOG_OK: break; case BSDDIALOG_CANCEL: return; case BSDDIALOG_EXTRA: /* Options */ strncpy(options_fstype, items[0].value, sizeof(options_fstype)); newfs_command(options_fstype, newfs, 0); for (i = 0; i < nitems(items); i++) { if (init_allocated) free((char*)items[i].init); items[i].init = items[i].value; } init_allocated = true; goto addpartform; } + } else { /* auto partitioning */ + items[0].value = strdup(items[0].init); + items[1].value = strdup(items[1].init); + items[2].value = strdup(items[2].init); + if (nitems > 3) + items[3].value = strdup(items[3].init); } /* * If the user changed the fs type after specifying options, undo * their choices in favor of the new filesystem's defaults. */ if (strcmp(options_fstype, items[0].value) != 0) { strncpy(options_fstype, items[0].value, sizeof(options_fstype)); newfs_command(options_fstype, newfs, 1); } size = maxsize; if (strlen(items[1].value) > 0) { if (expand_number(items[1].value, &bytes) != 0) { char error[512]; sprintf(error, "Invalid size: %s\n", strerror(errno)); conf.title = "Error"; bsddialog_msgbox(&conf, error, 0, 0); goto addpartform; } size = MIN((intmax_t)(bytes/sector), maxsize); } /* Check if the label has a / in it */ if (items[3].value != NULL && strchr(items[3].value, '/') != NULL) { conf.title = "Error"; bsddialog_msgbox(&conf, "Label contains a /, which is not an " "allowed character.", 0, 0); goto addpartform; } /* Warn if no mountpoint set */ if (strcmp(items[0].value, "freebsd-ufs") == 0 && items[2].value[0] != '/') { choice = 0; if (interactive) { conf.button.default_cancel = true; conf.title = "Warning"; choice = bsddialog_yesno(&conf, "This partition does not have a valid mountpoint " "(for the partition from which you intend to boot the " "operating system, the mountpoint should be /). Are you " "sure you want to continue?" , 0, 0); conf.button.default_cancel = false; } if (choice == BSDDIALOG_CANCEL) goto addpartform; } /* * Error if this scheme needs nested partitions, this is one, and * a mountpoint was set. */ if (strcmp(items[0].value, "freebsd") == 0 && strlen(items[2].value) > 0) { conf.title = "Error"; bsddialog_msgbox(&conf, "Partitions of type \"freebsd\" are " "nested BSD-type partition schemes and cannot have " "mountpoints. After creating one, select it and press " "Create again to add the actual file systems.", 0, 0); goto addpartform; } /* If this is the root partition, check that this scheme is bootable */ if (strcmp(items[2].value, "/") == 0 && !is_scheme_bootable(scheme)) { char message[512]; sprintf(message, "This partition scheme (%s) is not bootable " "on this platform. Are you sure you want to proceed?", scheme); conf.button.default_cancel = true; conf.title = "Warning"; choice = bsddialog_yesno(&conf, message, 0, 0); conf.button.default_cancel = false; if (choice == BSDDIALOG_CANCEL) goto addpartform; } /* If this is the root partition, check that this fs is bootable */ if (strcmp(items[2].value, "/") == 0 && !is_fs_bootable(scheme, items[0].value)) { char message[512]; sprintf(message, "This file system (%s) is not bootable " "on this system. Are you sure you want to proceed?", items[0].value); conf.button.default_cancel = true; conf.title = "Warning"; choice = bsddialog_yesno(&conf, message, 0, 0); conf.button.default_cancel = false; if (choice == BSDDIALOG_CANCEL) goto addpartform; } /* * If this is the root partition, and we need a boot partition, ask * the user to add one. */ if ((strcmp(items[0].value, "freebsd") == 0 || strcmp(items[2].value, "/") == 0) && bootpart_size(scheme) > 0) { size_t bytes = add_boot_partition(geom, pp, scheme, interactive); /* Now adjust the part we are really adding forward */ if (bytes > 0) { firstfree += bytes / sector; size -= (bytes + stripe)/sector; if (stripe > 0 && (firstfree*sector % stripe) != 0) firstfree += (stripe - ((firstfree*sector) % stripe)) / sector; } } output[0] = '\0'; r = gctl_get_handle(); gctl_ro_param(r, "class", -1, "PART"); gctl_ro_param(r, "arg0", -1, geom->lg_name); gctl_ro_param(r, "flags", -1, GPART_FLAGS); gctl_ro_param(r, "verb", -1, "add"); gctl_ro_param(r, "type", -1, items[0].value); snprintf(sizestr, sizeof(sizestr), "%jd", size); gctl_ro_param(r, "size", -1, sizestr); snprintf(startstr, sizeof(startstr), "%jd", firstfree); gctl_ro_param(r, "start", -1, startstr); if (items[3].value != NULL && items[3].value[0] != '\0') gctl_ro_param(r, "label", -1, items[3].value); gctl_add_param(r, "output", sizeof(output), output, GCTL_PARAM_WR | GCTL_PARAM_ASCII); errstr = gctl_issue(r); if (errstr != NULL && errstr[0] != '\0') { gpart_show_error("Error", NULL, errstr); gctl_free(r); goto addpartform; } newpartname = strtok(output, " "); gctl_free(r); /* * Try to destroy any geom that gpart picked up already here from * dirty blocks. */ r = gctl_get_handle(); gctl_ro_param(r, "class", -1, "PART"); gctl_ro_param(r, "arg0", -1, newpartname); gctl_ro_param(r, "flags", -1, GPART_FLAGS); junk = 1; gctl_ro_param(r, "force", sizeof(junk), &junk); gctl_ro_param(r, "verb", -1, "destroy"); gctl_issue(r); /* Error usually expected and non-fatal */ gctl_free(r); if (strcmp(items[0].value, "freebsd") == 0) gpart_partition(newpartname, "BSD"); else set_default_part_metadata(newpartname, scheme, items[0].value, items[2].value, newfs); for (i = 0; i < nitems(items); i++) { if (items[i].value != NULL) { free(items[i].value); if (init_allocated && items[i].init != NULL) free((char*)items[i].init); } } if (partname != NULL) *partname = strdup(newpartname); } void gpart_delete(struct gprovider *pp) { struct gconfig *gc; struct ggeom *geom; struct gconsumer *cp; struct gctl_req *r; const char *errstr; intmax_t idx; int is_partition; struct bsddialog_conf conf; /* Is it a partition? */ is_partition = (strcmp(pp->lg_geom->lg_class->lg_name, "PART") == 0); /* Find out if this is the root of a gpart geom */ geom = NULL; LIST_FOREACH(cp, &pp->lg_consumers, lg_consumers) if (strcmp(cp->lg_geom->lg_class->lg_name, "PART") == 0) { geom = cp->lg_geom; break; } /* If so, destroy all children */ if (geom != NULL) { gpart_destroy(geom); /* If this is a partition, revert it, so it can be deleted */ if (is_partition) { r = gctl_get_handle(); gctl_ro_param(r, "class", -1, "PART"); gctl_ro_param(r, "arg0", -1, geom->lg_name); gctl_ro_param(r, "verb", -1, "undo"); gctl_issue(r); /* Ignore non-fatal errors */ gctl_free(r); } } /* * If this is not a partition, see if that is a problem, complain if * necessary, and return always, since we need not do anything further, * error or no. */ if (!is_partition) { if (geom == NULL) { bsddialog_initconf(&conf); conf.title = "Error"; bsddialog_msgbox(&conf, "Only partitions can be deleted.", 0, 0); } return; } r = gctl_get_handle(); gctl_ro_param(r, "class", -1, pp->lg_geom->lg_class->lg_name); gctl_ro_param(r, "arg0", -1, pp->lg_geom->lg_name); gctl_ro_param(r, "flags", -1, GPART_FLAGS); gctl_ro_param(r, "verb", -1, "delete"); LIST_FOREACH(gc, &pp->lg_config, lg_config) { if (strcmp(gc->lg_name, "index") == 0) { idx = atoi(gc->lg_val); gctl_ro_param(r, "index", sizeof(idx), &idx); break; } } errstr = gctl_issue(r); if (errstr != NULL && errstr[0] != '\0') { gpart_show_error("Error", NULL, errstr); gctl_free(r); return; } gctl_free(r); delete_part_metadata(pp->lg_name); } void gpart_revert_all(struct gmesh *mesh) { struct gclass *classp; struct gconfig *gc; struct ggeom *gp; struct gctl_req *r; const char *modified; struct bsddialog_conf conf; LIST_FOREACH(classp, &mesh->lg_class, lg_class) { if (strcmp(classp->lg_name, "PART") == 0) break; } if (strcmp(classp->lg_name, "PART") != 0) { bsddialog_initconf(&conf); conf.title = "Error"; bsddialog_msgbox(&conf, "gpart not found!", 0, 0); return; } LIST_FOREACH(gp, &classp->lg_geom, lg_geom) { modified = "true"; /* XXX: If we don't know (kernel too old), * assume there are modifications. */ LIST_FOREACH(gc, &gp->lg_config, lg_config) { if (strcmp(gc->lg_name, "modified") == 0) { modified = gc->lg_val; break; } } if (strcmp(modified, "false") == 0) continue; r = gctl_get_handle(); gctl_ro_param(r, "class", -1, "PART"); gctl_ro_param(r, "arg0", -1, gp->lg_name); gctl_ro_param(r, "verb", -1, "undo"); gctl_issue(r); gctl_free(r); } } void gpart_commit(struct gmesh *mesh) { struct partition_metadata *md; struct gclass *classp; struct ggeom *gp; struct gconfig *gc; struct gconsumer *cp; struct gprovider *pp; struct gctl_req *r; const char *errstr; const char *modified; const char *rootfs; struct bsddialog_conf conf; LIST_FOREACH(classp, &mesh->lg_class, lg_class) { if (strcmp(classp->lg_name, "PART") == 0) break; } /* Figure out what filesystem / uses */ rootfs = "ufs"; /* Assume ufs if nothing else present */ TAILQ_FOREACH(md, &part_metadata, metadata) { if (md->fstab != NULL && strcmp(md->fstab->fs_file, "/") == 0) { rootfs = md->fstab->fs_vfstype; break; } } if (strcmp(classp->lg_name, "PART") != 0) { bsddialog_initconf(&conf); conf.title = "Error"; bsddialog_msgbox(&conf, "gpart not found!", 0, 0); return; } LIST_FOREACH(gp, &classp->lg_geom, lg_geom) { modified = "true"; /* XXX: If we don't know (kernel too old), * assume there are modifications. */ LIST_FOREACH(gc, &gp->lg_config, lg_config) { if (strcmp(gc->lg_name, "modified") == 0) { modified = gc->lg_val; break; } } if (strcmp(modified, "false") == 0) continue; /* Add bootcode if necessary, before the commit */ md = get_part_metadata(gp->lg_name, 0); if (md != NULL && md->bootcode) gpart_bootcode(gp); /* Now install partcode on its partitions, if necessary */ LIST_FOREACH(pp, &gp->lg_provider, lg_provider) { md = get_part_metadata(pp->lg_name, 0); if (md == NULL || !md->bootcode) continue; /* Mark this partition active if that's required */ gpart_activate(pp); /* Check if the partition has sub-partitions */ LIST_FOREACH(cp, &pp->lg_consumers, lg_consumers) if (strcmp(cp->lg_geom->lg_class->lg_name, "PART") == 0) break; if (cp == NULL) /* No sub-partitions */ gpart_partcode(pp, rootfs); } r = gctl_get_handle(); gctl_ro_param(r, "class", -1, "PART"); gctl_ro_param(r, "arg0", -1, gp->lg_name); gctl_ro_param(r, "verb", -1, "commit"); errstr = gctl_issue(r); if (errstr != NULL && errstr[0] != '\0') gpart_show_error("Error", NULL, errstr); gctl_free(r); } }