diff --git a/usr.sbin/bsdinstall/partedit/gpart_ops.c b/usr.sbin/bsdinstall/partedit/gpart_ops.c index 331cbc4ffba6..bc45a0f2d383 100644 --- a/usr.sbin/bsdinstall/partedit/gpart_ops.c +++ b/usr.sbin/bsdinstall/partedit/gpart_ops.c @@ -1,1474 +1,1470 @@ /*- * SPDX-License-Identifier: BSD-2-Clause * * 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. */ #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; 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); } dialog_msgbox(title, message, 0, 0, TRUE); } 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 char * newfs_command(const char *fstype, int use_default) { FILE *fp; char *buf; size_t len; fp = open_memstream(&buf, &len); if (strcmp(fstype, "freebsd-ufs") == 0) { int i; DIALOG_LISTITEM items[] = { {"UFS1", "UFS Version 1", "Use version 1 of the UFS file system instead " "of version 2 (not recommended)", 0 }, {"SU", "Softupdates", "Enable softupdates (default)", 1 }, {"SUJ", "Softupdates journaling", "Enable file system journaling (default - " "turn off for SSDs)", 1 }, {"TRIM", "Enable SSD TRIM support", "Enable TRIM support, useful on solid-state drives", 0 }, }; if (!use_default) { int choice; choice = dlg_checklist("UFS Options", "", 0, 0, 0, nitems(items), items, NULL, FLAG_CHECK, &i); if (choice == 1) /* Cancel */ goto out; } fputs("newfs ", fp); for (i = 0; i < (int)nitems(items); i++) { if (items[i].state == 0) continue; if (strcmp(items[i].name, "UFS1") == 0) fputs("-O1 ", fp); else if (strcmp(items[i].name, "SU") == 0) fputs("-U ", fp); else if (strcmp(items[i].name, "SUJ") == 0) fputs("-j ", fp); else if (strcmp(items[i].name, "TRIM") == 0) fputs("-t ", fp); } } else if (strcmp(fstype, "freebsd-zfs") == 0) { int i; DIALOG_LISTITEM items[] = { {"fletcher4", "checksum algorithm: fletcher4", "Use fletcher4 for data integrity checking. " "(default)", 1 }, {"fletcher2", "checksum algorithm: fletcher2", "Use fletcher2 for data integrity checking. " "(not recommended)", 0 }, {"sha256", "checksum algorithm: sha256", "Use sha256 for data integrity checking. " "(not recommended)", 0 }, {"atime", "Update atimes for files", "Disable atime update", 0 }, }; if (!use_default) { int choice; choice = dlg_checklist("ZFS Options", "", 0, 0, 0, nitems(items), items, NULL, FLAG_CHECK, &i); if (choice == 1) /* Cancel */ goto out; } fputs("zpool create -f -m none ", fp); 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); fprintf(fp, " -o cachefile=%s/zpool.cache ", zfsboot_path); } for (i = 0; i < (int)nitems(items); i++) { if (items[i].state == 0) continue; if (strcmp(items[i].name, "fletcher4") == 0) fputs("-O checksum=fletcher4 ", fp); else if (strcmp(items[i].name, "fletcher2") == 0) fputs("-O checksum=fletcher2 ", fp); else if (strcmp(items[i].name, "sha256") == 0) fputs("-O checksum=sha256 ", fp); else if (strcmp(items[i].name, "atime") == 0) fputs("-O atime=off ", fp); } } else if (strcmp(fstype, "fat32") == 0 || strcmp(fstype, "efi") == 0 || strcmp(fstype, "ms-basic-data") == 0) { int i; DIALOG_LISTITEM items[] = { {"FAT32", "FAT Type 32", "Create a FAT32 filesystem (default)", 1 }, {"FAT16", "FAT Type 16", "Create a FAT16 filesystem", 0 }, {"FAT12", "FAT Type 12", "Create a FAT12 filesystem", 0 }, }; if (!use_default) { int choice; choice = dlg_checklist("FAT Options", "", 0, 0, 0, nitems(items), items, NULL, FLAG_RADIO, &i); if (choice == 1) /* Cancel */ goto out; } fputs("newfs_msdos ", fp); for (i = 0; i < (int)nitems(items); i++) { if (items[i].state == 0) continue; if (strcmp(items[i].name, "FAT32") == 0) fputs("-F 32 -c 1", fp); else if (strcmp(items[i].name, "FAT16") == 0) fputs("-F 16 ", fp); else if (strcmp(items[i].name, "FAT12") == 0) fputs("-F 12 ", fp); } } else { if (!use_default) dialog_msgbox("Error", "No configurable options exist " "for this filesystem.", 0, 0, TRUE); } out: fclose(fp); return (buf); } const char * choose_part_type(const char *def_scheme) { int cancel, choice; const char *scheme = NULL; DIALOG_LISTITEM items[] = { {"APM", "Apple Partition Map", "Bootable on PowerPC Apple Hardware", 0 }, {"BSD", "BSD Labels", "Bootable on most x86 systems", 0 }, {"GPT", "GUID Partition Table", "Bootable on most x86 systems and EFI aware ARM64", 0 }, {"MBR", "DOS Partitions", "Bootable on most x86 systems", 0 }, }; parttypemenu: dialog_vars.default_item = __DECONST(char *, def_scheme); cancel = dlg_menu("Partition Scheme", "Select a partition scheme for this volume:", 0, 0, 0, nitems(items), items, &choice, NULL); dialog_vars.default_item = NULL; if (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); dialog_vars.defaultno = TRUE; cancel = dialog_yesno("Warning", message, 0, 0); dialog_vars.defaultno = FALSE; if (cancel) /* cancel */ goto parttypemenu; } scheme = items[choice].name; return scheme; } int gpart_partition(const char *lg_name, const char *scheme) { int cancel; struct gctl_req *r; const char *errstr; 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); dialog_vars.defaultno = TRUE; cancel = dialog_yesno("Warning", message, 0, 0); dialog_vars.defaultno = FALSE; if (cancel) { /* cancel */ /* 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; /* * 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) { dialog_msgbox("Bootcode Error", strerror(errno), 0, 0, TRUE); 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]; 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); dialog_msgbox("Error", message, 0, 0, TRUE); } } 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; intmax_t idx; int hadlabel, choice, junk, nitems; unsigned i; DIALOG_FORMITEM items[] = { {0, "Type:", 5, 0, 0, FALSE, "", 11, 0, 12, 15, 0, FALSE, "Filesystem type (e.g. freebsd-ufs, freebsd-zfs, " "freebsd-swap)", FALSE}, {0, "Size:", 5, 1, 0, FALSE, "", 11, 1, 12, 0, 0, FALSE, "Partition size. Append K, M, G for kilobytes, " "megabytes or gigabytes.", FALSE}, {0, "Mountpoint:", 11, 2, 0, FALSE, "", 11, 2, 12, 15, 0, FALSE, "Path at which to mount this partition (leave blank " "for swap, set to / for root filesystem)", FALSE}, {0, "Label:", 7, 3, 0, FALSE, "", 11, 3, 12, 15, 0, FALSE, "Partition name. Not all partition schemes support this.", FALSE}, }; /* * 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].text = gc->lg_val; } if (strcmp(gc->lg_name, "label") == 0 && gc->lg_val != NULL) { hadlabel = 1; items[3].text = 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].text = md->fstab->fs_file; break; } } humanize_number(sizestr, 7, pp->lg_mediasize, "B", HN_AUTOSCALE, HN_NOSPACE | HN_DECIMAL); items[1].text = sizestr; editpart: choice = dlg_form("Edit Partition", "", 0, 0, 0, nitems, items, &junk); if (choice) /* Cancel pressed */ goto endedit; /* If this is the root partition, check that this fs is bootable */ if (strcmp(items[2].text, "/") == 0 && !is_fs_bootable(scheme, items[0].text)) { char message[512]; sprintf(message, "This file system (%s) is not bootable " "on this system. Are you sure you want to proceed?", items[0].text); dialog_vars.defaultno = TRUE; choice = dialog_yesno("Warning", message, 0, 0); dialog_vars.defaultno = FALSE; if (choice == 1) /* cancel */ goto editpart; } /* Check if the label has a / in it */ if (strchr(items[3].text, '/') != NULL) { dialog_msgbox("Error", "Label contains a /, which is not an " "allowed character.", 0, 0, TRUE); 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 (hadlabel || items[3].text[0] != '\0') gctl_ro_param(r, "label", -1, items[3].text); gctl_ro_param(r, "type", -1, items[0].text); 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 = newfs_command(items[0].text, 1); set_default_part_metadata(pp->lg_name, scheme, items[0].text, items[2].text, (strcmp(oldtype, items[0].text) != 0) ? newfs : NULL); free(newfs); endedit: if (strcmp(oldtype, items[0].text) != 0 && cp != NULL) gpart_destroy(cp->lg_geom); if (strcmp(oldtype, items[0].text) != 0 && strcmp(items[0].text, "freebsd") == 0) gpart_partition(pp->lg_name, "BSD"); for (i = 0; i < nitems(items); i++) if (items[i].text_free) free(items[i].text); } 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, + asprintf(&md->newfs, "%s %s /dev/%s", newfs, zpool_name, name); } else { - sprintf(md->newfs, "%s /dev/%s", newfs, name); + asprintf(&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); + asprintf(&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; /* 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) choice = dialog_yesno("Boot Partition", "This partition scheme requires a boot partition " "for the disk to be bootable. Would you like to " "make one now?", 0, 0); else choice = 0; if (choice == 0) { /* 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, options_fstype[64]; intmax_t maxsize, size, sector, firstfree, stripe; uint64_t bytes; int nitems, choice, junk; unsigned i; DIALOG_FORMITEM items[] = { {0, "Type:", 5, 0, 0, FALSE, "freebsd-ufs", 11, 0, 12, 15, 0, FALSE, "Filesystem type (e.g. freebsd-ufs, freebsd-zfs, " "freebsd-swap)", FALSE}, {0, "Size:", 5, 1, 0, FALSE, "", 11, 1, 12, 15, 0, FALSE, "Partition size. Append K, M, G for kilobytes, " "megabytes or gigabytes.", FALSE}, {0, "Mountpoint:", 11, 2, 0, FALSE, "", 11, 2, 12, 15, 0, FALSE, "Path at which to mount partition (blank for " "swap, / for root filesystem)", FALSE}, {0, "Label:", 7, 3, 0, FALSE, "", 11, 3, 12, 15, 0, FALSE, "Partition name. Not all partition schemes support this.", FALSE}, }; 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) dialog_msgbox("", "The partition table has been successfully created." " Please press Create again to create partitions.", 0, 0, TRUE); 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) { dialog_msgbox("Error", "No free space left on device.", 0, 0, TRUE); return; } humanize_number(sizestr, 7, size*sector, "B", HN_AUTOSCALE, HN_NOSPACE | HN_DECIMAL); items[1].text = sizestr; /* Special-case the MBR default type for nested partitions */ if (strcmp(scheme, "MBR") == 0) { items[0].text = "freebsd"; items[0].help = "Filesystem type (e.g. freebsd, fat32)"; } nitems = scheme_supports_labels(scheme) ? 4 : 3; if (default_type != NULL) items[0].text = (char *)default_type; if (default_size != NULL) items[1].text = (char *)default_size; if (default_mountpoint != NULL) items[2].text = (char *)default_mountpoint; /* Default options */ strncpy(options_fstype, items[0].text, sizeof(options_fstype)); newfs = newfs_command(options_fstype, 1); addpartform: if (interactive) { dialog_vars.extra_label = "Options"; dialog_vars.extra_button = TRUE; choice = dlg_form("Add Partition", "", 0, 0, 0, nitems, items, &junk); dialog_vars.extra_button = FALSE; switch (choice) { case 0: /* OK */ break; case 1: /* Cancel */ return; case 3: /* Options */ free(newfs); strncpy(options_fstype, items[0].text, sizeof(options_fstype)); newfs = newfs_command(options_fstype, 0); goto addpartform; } } /* * 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].text) != 0) { free(newfs); strncpy(options_fstype, items[0].text, sizeof(options_fstype)); newfs = newfs_command(options_fstype, 1); } size = maxsize; if (strlen(items[1].text) > 0) { if (expand_number(items[1].text, &bytes) != 0) { char error[512]; sprintf(error, "Invalid size: %s\n", strerror(errno)); dialog_msgbox("Error", error, 0, 0, TRUE); goto addpartform; } size = MIN((intmax_t)(bytes/sector), maxsize); } /* Check if the label has a / in it */ if (strchr(items[3].text, '/') != NULL) { dialog_msgbox("Error", "Label contains a /, which is not an " "allowed character.", 0, 0, TRUE); goto addpartform; } /* Warn if no mountpoint set */ if (strcmp(items[0].text, "freebsd-ufs") == 0 && items[2].text[0] != '/') { choice = 0; if (interactive) { dialog_vars.defaultno = TRUE; choice = dialog_yesno("Warning", "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); dialog_vars.defaultno = FALSE; } if (choice == 1) /* cancel */ goto addpartform; } /* * Error if this scheme needs nested partitions, this is one, and * a mountpoint was set. */ if (strcmp(items[0].text, "freebsd") == 0 && strlen(items[2].text) > 0) { dialog_msgbox("Error", "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, TRUE); goto addpartform; } /* If this is the root partition, check that this scheme is bootable */ if (strcmp(items[2].text, "/") == 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); dialog_vars.defaultno = TRUE; choice = dialog_yesno("Warning", message, 0, 0); dialog_vars.defaultno = FALSE; if (choice == 1) /* cancel */ goto addpartform; } /* If this is the root partition, check that this fs is bootable */ if (strcmp(items[2].text, "/") == 0 && !is_fs_bootable(scheme, items[0].text)) { char message[512]; sprintf(message, "This file system (%s) is not bootable " "on this system. Are you sure you want to proceed?", items[0].text); dialog_vars.defaultno = TRUE; choice = dialog_yesno("Warning", message, 0, 0); dialog_vars.defaultno = FALSE; if (choice == 1) /* 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].text, "freebsd") == 0 || strcmp(items[2].text, "/") == 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].text); 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].text[0] != '\0') gctl_ro_param(r, "label", -1, items[3].text); 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].text, "freebsd") == 0) gpart_partition(newpartname, "BSD"); else set_default_part_metadata(newpartname, scheme, items[0].text, items[2].text, newfs); free(newfs); for (i = 0; i < nitems(items); i++) if (items[i].text_free) free(items[i].text); 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; /* 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) dialog_msgbox("Error", "Only partitions can be deleted.", 0, 0, TRUE); 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; LIST_FOREACH(classp, &mesh->lg_class, lg_class) { if (strcmp(classp->lg_name, "PART") == 0) break; } if (strcmp(classp->lg_name, "PART") != 0) { dialog_msgbox("Error", "gpart not found!", 0, 0, TRUE); 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; 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) { dialog_msgbox("Error", "gpart not found!", 0, 0, TRUE); 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); } } diff --git a/usr.sbin/bsdinstall/partedit/partedit.c b/usr.sbin/bsdinstall/partedit/partedit.c index ffc809507b08..0f116d2c716a 100644 --- a/usr.sbin/bsdinstall/partedit/partedit.c +++ b/usr.sbin/bsdinstall/partedit/partedit.c @@ -1,606 +1,606 @@ /*- * SPDX-License-Identifier: BSD-2-Clause * * 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. */ #include #include #include #include #include #include #include #include #include #include #include #include "diskeditor.h" #include "partedit.h" struct pmetadata_head part_metadata; static int sade_mode = 0; static int apply_changes(struct gmesh *mesh); static void apply_workaround(struct gmesh *mesh); static struct partedit_item *read_geom_mesh(struct gmesh *mesh, int *nitems); static void add_geom_children(struct ggeom *gp, int recurse, struct partedit_item **items, int *nitems); static void init_fstab_metadata(void); static void get_mount_points(struct partedit_item *items, int nitems); static int validate_setup(void); static void sigint_handler(int sig) { struct gmesh mesh; /* Revert all changes and exit dialog-mode cleanly on SIGINT */ if (geom_gettree(&mesh) == 0) { gpart_revert_all(&mesh); geom_deletetree(&mesh); } end_dialog(); exit(1); } int main(int argc, const char **argv) { struct partition_metadata *md; const char *progname, *prompt; struct partedit_item *items = NULL; struct gmesh mesh; int i, op, nitems, nscroll; int error; progname = getprogname(); if (strcmp(progname, "sade") == 0) sade_mode = 1; TAILQ_INIT(&part_metadata); init_fstab_metadata(); init_dialog(stdin, stdout); if (!sade_mode) dialog_vars.backtitle = __DECONST(char *, "FreeBSD Installer"); dialog_vars.item_help = TRUE; nscroll = i = 0; /* Revert changes on SIGINT */ signal(SIGINT, sigint_handler); if (strcmp(progname, "autopart") == 0) { /* Guided */ prompt = "Please review the disk setup. When complete, press " "the Finish button."; /* Experimental ZFS autopartition support */ if (argc > 1 && strcmp(argv[1], "zfs") == 0) { part_wizard("zfs"); } else { part_wizard("ufs"); } } else if (strcmp(progname, "scriptedpart") == 0) { error = scripted_editor(argc, argv); prompt = NULL; if (error != 0) { end_dialog(); return (error); } } else { prompt = "Create partitions for FreeBSD. No changes will be " "made until you select Finish."; } /* Show the part editor either immediately, or to confirm wizard */ while (prompt != NULL) { dlg_clear(); dlg_put_backtitle(); error = geom_gettree(&mesh); if (error == 0) items = read_geom_mesh(&mesh, &nitems); if (error || items == NULL) { dialog_msgbox("Error", "No disks found. If you need to " "install a kernel driver, choose Shell at the " "installation menu.", 0, 0, TRUE); break; } get_mount_points(items, nitems); if (i >= nitems) i = nitems - 1; op = diskeditor_show("Partition Editor", prompt, items, nitems, &i, &nscroll); switch (op) { case 0: /* Create */ gpart_create((struct gprovider *)(items[i].cookie), NULL, NULL, NULL, NULL, 1); break; case 1: /* Delete */ gpart_delete((struct gprovider *)(items[i].cookie)); break; case 2: /* Modify */ gpart_edit((struct gprovider *)(items[i].cookie)); break; case 3: /* Revert */ gpart_revert_all(&mesh); while ((md = TAILQ_FIRST(&part_metadata)) != NULL) { 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); } if (md->newfs != NULL) free(md->newfs); free(md->name); TAILQ_REMOVE(&part_metadata, md, metadata); free(md); } init_fstab_metadata(); break; case 4: /* Auto */ part_wizard("ufs"); break; } error = 0; if (op == 5) { /* Finished */ dialog_vars.ok_label = __DECONST(char *, "Commit"); dialog_vars.extra_label = __DECONST(char *, "Revert & Exit"); dialog_vars.extra_button = TRUE; dialog_vars.cancel_label = __DECONST(char *, "Back"); op = dialog_yesno("Confirmation", "Your changes will " "now be written to disk. If you have chosen to " "overwrite existing data, it will be PERMANENTLY " "ERASED. Are you sure you want to commit your " "changes?", 0, 0); dialog_vars.ok_label = NULL; dialog_vars.extra_button = FALSE; dialog_vars.cancel_label = NULL; if (op == 0 && validate_setup()) { /* Save */ error = apply_changes(&mesh); if (!error) apply_workaround(&mesh); break; } else if (op == 3) { /* Quit */ gpart_revert_all(&mesh); error = -1; break; } } geom_deletetree(&mesh); free(items); } if (prompt == NULL) { error = geom_gettree(&mesh); if (error == 0) { if (validate_setup()) { error = apply_changes(&mesh); } else { gpart_revert_all(&mesh); error = -1; } geom_deletetree(&mesh); } } end_dialog(); return (error); } struct partition_metadata * get_part_metadata(const char *name, int create) { struct partition_metadata *md; TAILQ_FOREACH(md, &part_metadata, metadata) if (md->name != NULL && strcmp(md->name, name) == 0) break; if (md == NULL && create) { md = calloc(1, sizeof(*md)); md->name = strdup(name); TAILQ_INSERT_TAIL(&part_metadata, md, metadata); } return (md); } void delete_part_metadata(const char *name) { struct partition_metadata *md; TAILQ_FOREACH(md, &part_metadata, metadata) { if (md->name != NULL && strcmp(md->name, name) == 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); } if (md->newfs != NULL) free(md->newfs); free(md->name); TAILQ_REMOVE(&part_metadata, md, metadata); free(md); break; } } } static int validate_setup(void) { struct partition_metadata *md, *root = NULL; int cancel; TAILQ_FOREACH(md, &part_metadata, metadata) { if (md->fstab != NULL && strcmp(md->fstab->fs_file, "/") == 0) root = md; /* XXX: Check for duplicate mountpoints */ } if (root == NULL) { dialog_msgbox("Error", "No root partition was found. " "The root FreeBSD partition must have a mountpoint of '/'.", 0, 0, TRUE); return (FALSE); } /* * Check for root partitions that we aren't formatting, which is * usually a mistake */ if (root->newfs == NULL && !sade_mode) { dialog_vars.defaultno = TRUE; cancel = dialog_yesno("Warning", "The chosen root partition " "has a preexisting filesystem. If it contains an existing " "FreeBSD system, please update it with freebsd-update " "instead of installing a new system on it. The partition " "can also be erased by pressing \"No\" and then deleting " "and recreating it. Are you sure you want to proceed?", 0, 0); dialog_vars.defaultno = FALSE; if (cancel) return (FALSE); } return (TRUE); } static int mountpoint_sorter(const void *xa, const void *xb) { struct partition_metadata *a = *(struct partition_metadata **)xa; struct partition_metadata *b = *(struct partition_metadata **)xb; if (a->fstab == NULL && b->fstab == NULL) return 0; if (a->fstab == NULL) return 1; if (b->fstab == NULL) return -1; return strcmp(a->fstab->fs_file, b->fstab->fs_file); } static int apply_changes(struct gmesh *mesh) { struct partition_metadata *md; char message[512]; int i, nitems, error; const char **items; const char *fstab_path; FILE *fstab; nitems = 1; /* Partition table changes */ TAILQ_FOREACH(md, &part_metadata, metadata) { if (md->newfs != NULL) nitems++; } items = calloc(nitems * 2, sizeof(const char *)); items[0] = "Writing partition tables"; items[1] = "7"; /* In progress */ i = 1; TAILQ_FOREACH(md, &part_metadata, metadata) { if (md->newfs != NULL) { char *item; - item = malloc(255); - sprintf(item, "Initializing %s", md->name); + + asprintf(&item, "Initializing %s", md->name); items[i*2] = item; items[i*2 + 1] = "Pending"; i++; } } i = 0; dialog_mixedgauge("Initializing", "Initializing file systems. Please wait.", 0, 0, i*100/nitems, nitems, __DECONST(char **, items)); gpart_commit(mesh); items[i*2 + 1] = "3"; i++; if (getenv("BSDINSTALL_LOG") == NULL) setenv("BSDINSTALL_LOG", "/dev/null", 1); TAILQ_FOREACH(md, &part_metadata, metadata) { if (md->newfs != NULL) { items[i*2 + 1] = "7"; /* In progress */ dialog_mixedgauge("Initializing", "Initializing file systems. Please wait.", 0, 0, i*100/nitems, nitems, __DECONST(char **, items)); sprintf(message, "(echo %s; %s) >>%s 2>>%s", md->newfs, md->newfs, getenv("BSDINSTALL_LOG"), getenv("BSDINSTALL_LOG")); error = system(message); items[i*2 + 1] = (error == 0) ? "3" : "1"; i++; } } dialog_mixedgauge("Initializing", "Initializing file systems. Please wait.", 0, 0, i*100/nitems, nitems, __DECONST(char **, items)); for (i = 1; i < nitems; i++) free(__DECONST(char *, items[i*2])); free(items); /* Sort filesystems for fstab so that mountpoints are ordered */ { struct partition_metadata **tobesorted; struct partition_metadata *tmp; int nparts = 0; TAILQ_FOREACH(md, &part_metadata, metadata) nparts++; tobesorted = malloc(sizeof(struct partition_metadata *)*nparts); nparts = 0; TAILQ_FOREACH_SAFE(md, &part_metadata, metadata, tmp) { tobesorted[nparts++] = md; TAILQ_REMOVE(&part_metadata, md, metadata); } qsort(tobesorted, nparts, sizeof(tobesorted[0]), mountpoint_sorter); /* Now re-add everything */ while (nparts-- > 0) TAILQ_INSERT_HEAD(&part_metadata, tobesorted[nparts], metadata); free(tobesorted); } if (getenv("PATH_FSTAB") != NULL) fstab_path = getenv("PATH_FSTAB"); else fstab_path = "/etc/fstab"; fstab = fopen(fstab_path, "w+"); if (fstab == NULL) { sprintf(message, "Cannot open fstab file %s for writing (%s)\n", getenv("PATH_FSTAB"), strerror(errno)); dialog_msgbox("Error", message, 0, 0, TRUE); return (-1); } fprintf(fstab, "# Device\tMountpoint\tFStype\tOptions\tDump\tPass#\n"); TAILQ_FOREACH(md, &part_metadata, metadata) { if (md->fstab != NULL) fprintf(fstab, "%s\t%s\t\t%s\t%s\t%d\t%d\n", md->fstab->fs_spec, md->fstab->fs_file, md->fstab->fs_vfstype, md->fstab->fs_mntops, md->fstab->fs_freq, md->fstab->fs_passno); } fclose(fstab); return (0); } static void apply_workaround(struct gmesh *mesh) { struct gclass *classp; struct ggeom *gp; struct gconfig *gc; const char *scheme = NULL, *modified = NULL; LIST_FOREACH(classp, &mesh->lg_class, lg_class) { if (strcmp(classp->lg_name, "PART") == 0) break; } if (strcmp(classp->lg_name, "PART") != 0) { dialog_msgbox("Error", "gpart not found!", 0, 0, TRUE); return; } LIST_FOREACH(gp, &classp->lg_geom, lg_geom) { LIST_FOREACH(gc, &gp->lg_config, lg_config) { if (strcmp(gc->lg_name, "scheme") == 0) { scheme = gc->lg_val; } else if (strcmp(gc->lg_name, "modified") == 0) { modified = gc->lg_val; } } if (scheme && strcmp(scheme, "GPT") == 0 && modified && strcmp(modified, "true") == 0) { if (getenv("WORKAROUND_LENOVO")) gpart_set_root(gp->lg_name, "lenovofix"); if (getenv("WORKAROUND_GPTACTIVE")) gpart_set_root(gp->lg_name, "active"); } } } static struct partedit_item * read_geom_mesh(struct gmesh *mesh, int *nitems) { struct gclass *classp; struct ggeom *gp; struct partedit_item *items; *nitems = 0; items = NULL; /* * Build the device table. First add all disks (and CDs). */ LIST_FOREACH(classp, &mesh->lg_class, lg_class) { if (strcmp(classp->lg_name, "DISK") != 0 && strcmp(classp->lg_name, "MD") != 0) continue; /* Now recurse into all children */ LIST_FOREACH(gp, &classp->lg_geom, lg_geom) add_geom_children(gp, 0, &items, nitems); } return (items); } static void add_geom_children(struct ggeom *gp, int recurse, struct partedit_item **items, int *nitems) { struct gconsumer *cp; struct gprovider *pp; struct gconfig *gc; if (strcmp(gp->lg_class->lg_name, "PART") == 0 && !LIST_EMPTY(&gp->lg_config)) { LIST_FOREACH(gc, &gp->lg_config, lg_config) { if (strcmp(gc->lg_name, "scheme") == 0) (*items)[*nitems-1].type = gc->lg_val; } } if (LIST_EMPTY(&gp->lg_provider)) return; LIST_FOREACH(pp, &gp->lg_provider, lg_provider) { if (strcmp(gp->lg_class->lg_name, "LABEL") == 0) continue; /* Skip WORM media */ if (strncmp(pp->lg_name, "cd", 2) == 0) continue; *items = realloc(*items, (*nitems+1)*sizeof(struct partedit_item)); (*items)[*nitems].indentation = recurse; (*items)[*nitems].name = pp->lg_name; (*items)[*nitems].size = pp->lg_mediasize; (*items)[*nitems].mountpoint = NULL; (*items)[*nitems].type = ""; (*items)[*nitems].cookie = pp; LIST_FOREACH(gc, &pp->lg_config, lg_config) { if (strcmp(gc->lg_name, "type") == 0) (*items)[*nitems].type = gc->lg_val; } /* Skip swap-backed MD devices */ if (strcmp(gp->lg_class->lg_name, "MD") == 0 && strcmp((*items)[*nitems].type, "swap") == 0) continue; (*nitems)++; LIST_FOREACH(cp, &pp->lg_consumers, lg_consumers) add_geom_children(cp->lg_geom, recurse+1, items, nitems); /* Only use first provider for acd */ if (strcmp(gp->lg_class->lg_name, "ACD") == 0) break; } } static void init_fstab_metadata(void) { struct fstab *fstab; struct partition_metadata *md; setfsent(); while ((fstab = getfsent()) != NULL) { md = calloc(1, sizeof(struct partition_metadata)); md->name = NULL; if (strncmp(fstab->fs_spec, "/dev/", 5) == 0) md->name = strdup(&fstab->fs_spec[5]); md->fstab = malloc(sizeof(struct fstab)); md->fstab->fs_spec = strdup(fstab->fs_spec); md->fstab->fs_file = strdup(fstab->fs_file); md->fstab->fs_vfstype = strdup(fstab->fs_vfstype); md->fstab->fs_mntops = strdup(fstab->fs_mntops); md->fstab->fs_type = strdup(fstab->fs_type); md->fstab->fs_freq = fstab->fs_freq; md->fstab->fs_passno = fstab->fs_passno; md->newfs = NULL; TAILQ_INSERT_TAIL(&part_metadata, md, metadata); } } static void get_mount_points(struct partedit_item *items, int nitems) { struct partition_metadata *md; int i; for (i = 0; i < nitems; i++) { TAILQ_FOREACH(md, &part_metadata, metadata) { if (md->name != NULL && md->fstab != NULL && strcmp(md->name, items[i].name) == 0) { items[i].mountpoint = md->fstab->fs_file; break; } } } }