usr.sbin/bsdinstall/partedit/gpart_ops.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2011 Nathan Whitehorn
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  *
  28  * $FreeBSD$
  29  */
  30
  31 #include <sys/param.h>
  32 #include <sys/stat.h>
  33 #include <errno.h>
  34 #include <fcntl.h>
  35 #include <libutil.h>
  36 #include <inttypes.h>
  37
  38 #include <libgeom.h>
  39 #include <dialog.h>
  40 #include <dlg_keys.h>
  41
  42 #include "partedit.h"
  43
  44 #define GPART_FLAGS "x" /* Do not commit changes by default */
  45
  46 static void
  47 gpart_show_error(const char *title, const char *explanation, const char *errstr)
  48 {
  49         char *errmsg;
  50         char message[512];
  51         int error;
  52
  53         if (explanation == NULL)
  54                 explanation = "";
  55
  56         error = strtol(errstr, &errmsg, 0);
  57         if (errmsg != errstr) {
  58                 while (errmsg[0] == ' ')
  59                         errmsg++;
  60                 if (errmsg[0] != '\0')
  61                         sprintf(message, "%s%s. %s", explanation,
  62                             strerror(error), errmsg);
  63                 else
  64                         sprintf(message, "%s%s", explanation, strerror(error));
  65         } else {
  66                 sprintf(message, "%s%s", explanation, errmsg);
  67         }
  68
  69         dialog_msgbox(title, message, 0, 0, TRUE);
  70 }
  71
  72 static int
  73 scheme_supports_labels(const char *scheme)
  74 {
  75         if (strcmp(scheme, "APM") == 0)
  76                 return (1);
  77         if (strcmp(scheme, "GPT") == 0)
  78                 return (1);
  79
  80         return (0);
  81 }
  82
  83 static void
  84 newfs_command(const char *fstype, char *command, int use_default)
  85 {
  86         if (strcmp(fstype, "freebsd-ufs") == 0) {
  87                 int i;
  88                 DIALOG_LISTITEM items[] = {
  89                         {"UFS1", "UFS Version 1",
  90                             "Use version 1 of the UFS file system instead "
  91                             "of version 2 (not recommended)", 0 },
  92                         {"SU", "Softupdates",
  93                             "Enable softupdates (default)", 1 },
  94                         {"SUJ", "Softupdates journaling",
  95                             "Enable file system journaling (default - "
  96                             "turn off for SSDs)", 1 },
  97                         {"TRIM", "Enable SSD TRIM support",
  98                             "Enable TRIM support, useful on solid-state drives",
  99                             0 },
 100                 };
 101
 102                 if (!use_default) {
 103                         int choice;
 104                         choice = dlg_checklist("UFS Options", "", 0, 0, 0,
 105                             nitems(items), items, NULL,
 106                             FLAG_CHECK, &i);
 107                         if (choice == 1) /* Cancel */
 108                                 return;
 109                 }
 110
 111                 strcpy(command, "newfs ");
 112                 for (i = 0; i < (int)nitems(items); i++) {
 113                         if (items[i].state == 0)
 114                                 continue;
 115                         if (strcmp(items[i].name, "UFS1") == 0)
 116                                 strcat(command, "-O1 ");
 117                         else if (strcmp(items[i].name, "SU") == 0)
 118                                 strcat(command, "-U ");
 119                         else if (strcmp(items[i].name, "SUJ") == 0)
 120                                 strcat(command, "-j ");
 121                         else if (strcmp(items[i].name, "TRIM") == 0)
 122                                 strcat(command, "-t ");
 123                 }
 124         } else if (strcmp(fstype, "freebsd-zfs") == 0) {
 125                 int i;
 126                 DIALOG_LISTITEM items[] = {
 127                         {"fletcher4", "checksum algorithm: fletcher4",
 128                             "Use fletcher4 for data integrity checking. "
 129                             "(default)", 1 },
 130                         {"fletcher2", "checksum algorithm: fletcher2",
 131                             "Use fletcher2 for data integrity checking. "
 132                             "(not recommended)", 0 },
 133                         {"sha256", "checksum algorithm: sha256",
 134                             "Use sha256 for data integrity checking. "
 135                             "(not recommended)", 0 },
 136                         {"atime", "Update atimes for files",
 137                             "Disable atime update", 0 },
 138                 };
 139
 140                 if (!use_default) {
 141                         int choice;
 142                         choice = dlg_checklist("ZFS Options", "", 0, 0, 0,
 143                             nitems(items), items, NULL,
 144                             FLAG_CHECK, &i);
 145                         if (choice == 1) /* Cancel */
 146                                 return;
 147                 }
 148
 149                 strcpy(command, "zpool create -f -m none ");
 150                 if (getenv("BSDINSTALL_TMPBOOT") != NULL) {
 151                         char zfsboot_path[MAXPATHLEN];
 152                         snprintf(zfsboot_path, sizeof(zfsboot_path), "%s/zfs",
 153                             getenv("BSDINSTALL_TMPBOOT"));
 154                         mkdir(zfsboot_path, S_IRWXU | S_IRGRP | S_IXGRP |
 155                             S_IROTH | S_IXOTH);
 156                         sprintf(command, "%s -o cachefile=%s/zpool.cache ",
 157                             command, zfsboot_path);
 158                 }
 159                 for (i = 0; i < (int)nitems(items); i++) {
 160                         if (items[i].state == 0)
 161                                 continue;
 162                         if (strcmp(items[i].name, "fletcher4") == 0)
 163                                 strcat(command, "-O checksum=fletcher4 ");
 164                         else if (strcmp(items[i].name, "fletcher2") == 0)
 165                                 strcat(command, "-O checksum=fletcher2 ");
 166                         else if (strcmp(items[i].name, "sha256") == 0)
 167                                 strcat(command, "-O checksum=sha256 ");
 168                         else if (strcmp(items[i].name, "atime") == 0)
 169                                 strcat(command, "-O atime=off ");
 170                 }
 171         } else if (strcmp(fstype, "fat32") == 0 || strcmp(fstype, "efi") == 0 ||
 172              strcmp(fstype, "ms-basic-data") == 0) {
 173                 int i;
 174                 DIALOG_LISTITEM items[] = {
 175                         {"FAT32", "FAT Type 32",
 176                             "Create a FAT32 filesystem (default)", 1 },
 177                         {"FAT16", "FAT Type 16",
 178                             "Create a FAT16 filesystem", 0 },
 179                         {"FAT12", "FAT Type 12",
 180                             "Create a FAT12 filesystem", 0 },
 181                 };
 182
 183                 if (!use_default) {
 184                         int choice;
 185                         choice = dlg_checklist("FAT Options", "", 0, 0, 0,
 186                             nitems(items), items, NULL,
 187                             FLAG_RADIO, &i);
 188                         if (choice == 1) /* Cancel */
 189                                 return;
 190                 }
 191
 192                 strcpy(command, "newfs_msdos ");
 193                 for (i = 0; i < (int)nitems(items); i++) {
 194                         if (items[i].state == 0)
 195                                 continue;
 196                         if (strcmp(items[i].name, "FAT32") == 0)
 197                                 strcat(command, "-F 32 -c 1");
 198                         else if (strcmp(items[i].name, "FAT16") == 0)
 199                                 strcat(command, "-F 16 ");
 200                         else if (strcmp(items[i].name, "FAT12") == 0)
 201                                 strcat(command, "-F 12 ");
 202                 }
 203         } else {
 204                 if (!use_default)
 205                         dialog_msgbox("Error", "No configurable options exist "
 206                             "for this filesystem.", 0, 0, TRUE);
 207                 command[0] = '\0';
 208         }
 209 }
 210
 211 const char *
 212 choose_part_type(const char *def_scheme)
 213 {
 214         int cancel, choice;
 215         const char *scheme = NULL;
 216
 217         DIALOG_LISTITEM items[] = {
 218                 {"APM", "Apple Partition Map",
 219                     "Bootable on PowerPC Apple Hardware", 0 },
 220                 {"BSD", "BSD Labels",
 221                     "Bootable on most x86 systems", 0 },
 222                 {"GPT", "GUID Partition Table",
 223                     "Bootable on most x86 systems and EFI aware ARM64", 0 },
 224                 {"MBR", "DOS Partitions",
 225                     "Bootable on most x86 systems", 0 },
 226         };
 227
 228 parttypemenu:
 229         dialog_vars.default_item = __DECONST(char *, def_scheme);
 230         cancel = dlg_menu("Partition Scheme",
 231             "Select a partition scheme for this volume:", 0, 0, 0,
 232             nitems(items), items, &choice, NULL);
 233         dialog_vars.default_item = NULL;
 234
 235         if (cancel)
 236                 return NULL;
 237
 238         if (!is_scheme_bootable(items[choice].name)) {
 239                 char message[512];
 240                 sprintf(message, "This partition scheme (%s) is not "
 241                     "bootable on this platform. Are you sure you want "
 242                     "to proceed?", items[choice].name);
 243                 dialog_vars.defaultno = TRUE;
 244                 cancel = dialog_yesno("Warning", message, 0, 0);
 245                 dialog_vars.defaultno = FALSE;
 246                 if (cancel) /* cancel */
 247                         goto parttypemenu;
 248         }
 249
 250         scheme = items[choice].name;
 251
 252         return scheme;
 253 }
 254
 255 int
 256 gpart_partition(const char *lg_name, const char *scheme)
 257 {
 258         int cancel;
 259         struct gctl_req *r;
 260         const char *errstr;
 261
 262 schememenu:
 263         if (scheme == NULL) {
 264                 scheme = choose_part_type(default_scheme());
 265
 266                 if (scheme == NULL)
 267                         return (-1);
 268
 269                 if (!is_scheme_bootable(scheme)) {
 270                         char message[512];
 271                         sprintf(message, "This partition scheme (%s) is not "
 272                             "bootable on this platform. Are you sure you want "
 273                             "to proceed?", scheme);
 274                         dialog_vars.defaultno = TRUE;
 275                         cancel = dialog_yesno("Warning", message, 0, 0);
 276                         dialog_vars.defaultno = FALSE;
 277                         if (cancel) { /* cancel */
 278                                 /* Reset scheme so user can choose another */
 279                                 scheme = NULL;
 280                                 goto schememenu;
 281                         }
 282                 }
 283         }
 284
 285         r = gctl_get_handle();
 286         gctl_ro_param(r, "class", -1, "PART");
 287         gctl_ro_param(r, "arg0", -1, lg_name);
 288         gctl_ro_param(r, "flags", -1, GPART_FLAGS);
 289         gctl_ro_param(r, "scheme", -1, scheme);
 290         gctl_ro_param(r, "verb", -1, "create");
 291
 292         errstr = gctl_issue(r);
 293         if (errstr != NULL && errstr[0] != '\0') {
 294                 gpart_show_error("Error", NULL, errstr);
 295                 gctl_free(r);
 296                 scheme = NULL;
 297                 goto schememenu;
 298         }
 299         gctl_free(r);
 300
 301         if (bootcode_path(scheme) != NULL)
 302                 get_part_metadata(lg_name, 1)->bootcode = 1;
 303         return (0);
 304 }
 305
 306 static void
 307 gpart_activate(struct gprovider *pp)
 308 {
 309         struct gconfig *gc;
 310         struct gctl_req *r;
 311         const char *errstr, *scheme;
 312         const char *attribute = NULL;
 313         intmax_t idx;
 314
 315         /*
 316          * Some partition schemes need this partition to be marked 'active'
 317          * for it to be bootable.
 318          */
 319         LIST_FOREACH(gc, &pp->lg_geom->lg_config, lg_config) {
 320                 if (strcmp(gc->lg_name, "scheme") == 0) {
 321                         scheme = gc->lg_val;
 322                         break;
 323                 }
 324         }
 325
 326         if (strcmp(scheme, "MBR") == 0 || strcmp(scheme, "EBR") == 0)
 327                 attribute = "active";
 328         else
 329                 return;
 330
 331         LIST_FOREACH(gc, &pp->lg_config, lg_config) {
 332                 if (strcmp(gc->lg_name, "index") == 0) {
 333                         idx = atoi(gc->lg_val);
 334                         break;
 335                 }
 336         }
 337
 338         r = gctl_get_handle();
 339         gctl_ro_param(r, "class", -1, "PART");
 340         gctl_ro_param(r, "arg0", -1, pp->lg_geom->lg_name);
 341         gctl_ro_param(r, "verb", -1, "set");
 342         gctl_ro_param(r, "attrib", -1, attribute);
 343         gctl_ro_param(r, "index", sizeof(idx), &idx);
 344
 345         errstr = gctl_issue(r);
 346         if (errstr != NULL && errstr[0] != '\0')
 347                 gpart_show_error("Error", "Error marking partition active:",
 348                     errstr);
 349         gctl_free(r);
 350 }
 351
 352 void
 353 gpart_set_root(const char *lg_name, const char *attribute)
 354 {
 355         struct gctl_req *r;
 356         const char *errstr;
 357
 358         r = gctl_get_handle();
 359         gctl_ro_param(r, "class", -1, "PART");
 360         gctl_ro_param(r, "arg0", -1, lg_name);
 361         gctl_ro_param(r, "flags", -1, "C");
 362         gctl_ro_param(r, "verb", -1, "set");
 363         gctl_ro_param(r, "attrib", -1, attribute);
 364
 365         errstr = gctl_issue(r);
 366         if (errstr != NULL && errstr[0] != '\0')
 367                 gpart_show_error("Error", "Error setting parameter on disk:",
 368                     errstr);
 369         gctl_free(r);
 370 }
 371
 372 static void
 373 gpart_bootcode(struct ggeom *gp)
 374 {
 375         const char *bootcode;
 376         struct gconfig *gc;
 377         struct gctl_req *r;
 378         const char *errstr, *scheme;
 379         uint8_t *boot;
 380         size_t bootsize, bytes;
 381         int bootfd;
 382
 383         /*
 384          * Write default bootcode to the newly partitioned disk, if that
 385          * applies on this platform.
 386          */
 387         LIST_FOREACH(gc, &gp->lg_config, lg_config) {
 388                 if (strcmp(gc->lg_name, "scheme") == 0) {
 389                         scheme = gc->lg_val;
 390                         break;
 391                 }
 392         }
 393
 394         bootcode = bootcode_path(scheme);
 395         if (bootcode == NULL)
 396                 return;
 397
 398         bootfd = open(bootcode, O_RDONLY);
 399         if (bootfd < 0) {
 400                 dialog_msgbox("Bootcode Error", strerror(errno), 0, 0,
 401                     TRUE);
 402                 return;
 403         }
 404
 405         bootsize = lseek(bootfd, 0, SEEK_END);
 406         boot = malloc(bootsize);
 407         lseek(bootfd, 0, SEEK_SET);
 408         bytes = 0;
 409         while (bytes < bootsize)
 410                 bytes += read(bootfd, boot + bytes, bootsize - bytes);
 411         close(bootfd);
 412
 413         r = gctl_get_handle();
 414         gctl_ro_param(r, "class", -1, "PART");
 415         gctl_ro_param(r, "arg0", -1, gp->lg_name);
 416         gctl_ro_param(r, "verb", -1, "bootcode");
 417         gctl_ro_param(r, "bootcode", bootsize, boot);
 418
 419         errstr = gctl_issue(r);
 420         if (errstr != NULL && errstr[0] != '\0')
 421                 gpart_show_error("Bootcode Error", NULL, errstr);
 422         gctl_free(r);
 423         free(boot);
 424 }
 425
 426 static void
 427 gpart_partcode(struct gprovider *pp, const char *fstype)
 428 {
 429         struct gconfig *gc;
 430         const char *scheme;
 431         const char *indexstr;
 432         char message[255], command[255];
 433
 434         LIST_FOREACH(gc, &pp->lg_geom->lg_config, lg_config) {
 435                 if (strcmp(gc->lg_name, "scheme") == 0) {
 436                         scheme = gc->lg_val;
 437                         break;
 438                 }
 439         }
 440
 441         /* Make sure this partition scheme needs partcode on this platform */
 442         if (partcode_path(scheme, fstype) == NULL)
 443                 return;
 444
 445         LIST_FOREACH(gc, &pp->lg_config, lg_config) {
 446                 if (strcmp(gc->lg_name, "index") == 0) {
 447                         indexstr = gc->lg_val;
 448                         break;
 449                 }
 450         }
 451
 452         /* Shell out to gpart for partcode for now */
 453         sprintf(command, "gpart bootcode -p %s -i %s %s",
 454             partcode_path(scheme, fstype), indexstr, pp->lg_geom->lg_name);
 455         if (system(command) != 0) {
 456                 sprintf(message, "Error installing partcode on partition %s",
 457                     pp->lg_name);
 458                 dialog_msgbox("Error", message, 0, 0, TRUE);
 459         }
 460 }
 461
 462 void
 463 gpart_destroy(struct ggeom *lg_geom)
 464 {
 465         struct gctl_req *r;
 466         struct gprovider *pp;
 467         const char *errstr;
 468         int force = 1;
 469
 470         /* Delete all child metadata */
 471         LIST_FOREACH(pp, &lg_geom->lg_provider, lg_provider)
 472                 gpart_delete(pp);
 473
 474         /* Revert any local changes to get this geom into a pristine state */
 475         r = gctl_get_handle();
 476         gctl_ro_param(r, "class", -1, "PART");
 477         gctl_ro_param(r, "arg0", -1, lg_geom->lg_name);
 478         gctl_ro_param(r, "verb", -1, "undo");
 479         gctl_issue(r); /* Ignore errors -- these are non-fatal */
 480         gctl_free(r);
 481
 482         /* Now destroy the geom itself */
 483         r = gctl_get_handle();
 484         gctl_ro_param(r, "class", -1, "PART");
 485         gctl_ro_param(r, "arg0", -1, lg_geom->lg_name);
 486         gctl_ro_param(r, "flags", -1, GPART_FLAGS);
 487         gctl_ro_param(r, "force", sizeof(force), &force);
 488         gctl_ro_param(r, "verb", -1, "destroy");
 489         errstr = gctl_issue(r);
 490         if (errstr != NULL && errstr[0] != '\0') {
 491                 /*
 492                  * Check if we reverted away the existence of the geom
 493                  * altogether. Show all other errors to the user.
 494                  */
 495                 if (strtol(errstr, NULL, 0) != EINVAL)
 496                         gpart_show_error("Error", NULL, errstr);
 497         }
 498         gctl_free(r);
 499
 500         /* And any metadata associated with the partition scheme itself */
 501         delete_part_metadata(lg_geom->lg_name);
 502 }
 503
 504 void
 505 gpart_edit(struct gprovider *pp)
 506 {
 507         struct gctl_req *r;
 508         struct gconfig *gc;
 509         struct gconsumer *cp;
 510         struct ggeom *geom;
 511         const char *errstr, *oldtype, *scheme;
 512         struct partition_metadata *md;
 513         char sizestr[32];
 514         char newfs[255];
 515         intmax_t idx;
 516         int hadlabel, choice, junk, nitems;
 517         unsigned i;
 518
 519         DIALOG_FORMITEM items[] = {
 520                 {0, "Type:", 5, 0, 0, FALSE, "", 11, 0, 12, 15, 0,
 521                     FALSE, "Filesystem type (e.g. freebsd-ufs, freebsd-zfs, "
 522                     "freebsd-swap)", FALSE},
 523                 {0, "Size:", 5, 1, 0, FALSE, "", 11, 1, 12, 0, 0,
 524                     FALSE, "Partition size. Append K, M, G for kilobytes, "
 525                     "megabytes or gigabytes.", FALSE},
 526                 {0, "Mountpoint:", 11, 2, 0, FALSE, "", 11, 2, 12, 15, 0,
 527                     FALSE, "Path at which to mount this partition (leave blank "
 528                     "for swap, set to / for root filesystem)", FALSE},
 529                 {0, "Label:", 7, 3, 0, FALSE, "", 11, 3, 12, 15, 0, FALSE,
 530                     "Partition name. Not all partition schemes support this.",
 531                     FALSE},
 532         };
 533
 534         /*
 535          * Find the PART geom we are manipulating. This may be a consumer of
 536          * this provider, or its parent. Check the consumer case first.
 537          */
 538         geom = NULL;
 539         LIST_FOREACH(cp, &pp->lg_consumers, lg_consumers)
 540                 if (strcmp(cp->lg_geom->lg_class->lg_name, "PART") == 0) {
 541                         /* Check for zombie geoms, treating them as blank */
 542                         scheme = NULL;
 543                         LIST_FOREACH(gc, &cp->lg_geom->lg_config, lg_config) {
 544                                 if (strcmp(gc->lg_name, "scheme") == 0) {
 545                                         scheme = gc->lg_val;
 546                                         break;
 547                                 }
 548                         }
 549                         if (scheme == NULL || strcmp(scheme, "(none)") == 0) {
 550                                 gpart_partition(cp->lg_geom->lg_name, NULL);
 551                                 return;
 552                         }
 553
 554                         /* If this is a nested partition, edit as usual */
 555                         if (strcmp(pp->lg_geom->lg_class->lg_name, "PART") == 0)
 556                                 break;
 557
 558                         /* Destroy the geom and all sub-partitions */
 559                         gpart_destroy(cp->lg_geom);
 560
 561                         /* Now re-partition and return */
 562                         gpart_partition(cp->lg_geom->lg_name, NULL);
 563                         return;
 564                 }
 565
 566         if (geom == NULL && strcmp(pp->lg_geom->lg_class->lg_name, "PART") == 0)
 567                 geom = pp->lg_geom;
 568
 569         if (geom == NULL) {
 570                 /* Disk not partitioned, so partition it */
 571                 gpart_partition(pp->lg_name, NULL);
 572                 return;
 573         }
 574
 575         LIST_FOREACH(gc, &geom->lg_config, lg_config) {
 576                 if (strcmp(gc->lg_name, "scheme") == 0) {
 577                         scheme = gc->lg_val;
 578                         break;
 579                 }
 580         }
 581
 582         nitems = scheme_supports_labels(scheme) ? 4 : 3;
 583
 584         /* Edit editable parameters of a partition */
 585         hadlabel = 0;
 586         LIST_FOREACH(gc, &pp->lg_config, lg_config) {
 587                 if (strcmp(gc->lg_name, "type") == 0) {
 588                         oldtype = gc->lg_val;
 589                         items[0].text = gc->lg_val;
 590                 }
 591                 if (strcmp(gc->lg_name, "label") == 0 && gc->lg_val != NULL) {
 592                         hadlabel = 1;
 593                         items[3].text = gc->lg_val;
 594                 }
 595                 if (strcmp(gc->lg_name, "index") == 0)
 596                         idx = atoi(gc->lg_val);
 597         }
 598
 599         TAILQ_FOREACH(md, &part_metadata, metadata) {
 600                 if (md->name != NULL && strcmp(md->name, pp->lg_name) == 0) {
 601                         if (md->fstab != NULL)
 602                                 items[2].text = md->fstab->fs_file;
 603                         break;
 604                 }
 605         }
 606
 607         humanize_number(sizestr, 7, pp->lg_mediasize, "B", HN_AUTOSCALE,
 608             HN_NOSPACE | HN_DECIMAL);
 609         items[1].text = sizestr;
 610
 611 editpart:
 612         choice = dlg_form("Edit Partition", "", 0, 0, 0, nitems, items, &junk);
 613
 614         if (choice) /* Cancel pressed */
 615                 goto endedit;
 616
 617         /* If this is the root partition, check that this fs is bootable */
 618         if (strcmp(items[2].text, "/") == 0 && !is_fs_bootable(scheme,
 619             items[0].text)) {
 620                 char message[512];
 621                 sprintf(message, "This file system (%s) is not bootable "
 622                     "on this system. Are you sure you want to proceed?",
 623                     items[0].text);
 624                 dialog_vars.defaultno = TRUE;
 625                 choice = dialog_yesno("Warning", message, 0, 0);
 626                 dialog_vars.defaultno = FALSE;
 627                 if (choice == 1) /* cancel */
 628                         goto editpart;
 629         }
 630
 631         /* Check if the label has a / in it */
 632         if (strchr(items[3].text, '/') != NULL) {
 633                 dialog_msgbox("Error", "Label contains a /, which is not an "
 634                     "allowed character.", 0, 0, TRUE);
 635                 goto editpart;
 636         }
 637
 638         r = gctl_get_handle();
 639         gctl_ro_param(r, "class", -1, "PART");
 640         gctl_ro_param(r, "arg0", -1, geom->lg_name);
 641         gctl_ro_param(r, "flags", -1, GPART_FLAGS);
 642         gctl_ro_param(r, "verb", -1, "modify");
 643         gctl_ro_param(r, "index", sizeof(idx), &idx);
 644         if (hadlabel || items[3].text[0] != '\0')
 645                 gctl_ro_param(r, "label", -1, items[3].text);
 646         gctl_ro_param(r, "type", -1, items[0].text);
 647         errstr = gctl_issue(r);
 648         if (errstr != NULL && errstr[0] != '\0') {
 649                 gpart_show_error("Error", NULL, errstr);
 650                 gctl_free(r);
 651                 goto editpart;
 652         }
 653         gctl_free(r);
 654
 655         newfs_command(items[0].text, newfs, 1);
 656         set_default_part_metadata(pp->lg_name, scheme, items[0].text,
 657             items[2].text, (strcmp(oldtype, items[0].text) != 0) ?
 658             newfs : NULL);
 659
 660 endedit:
 661         if (strcmp(oldtype, items[0].text) != 0 && cp != NULL)
 662                 gpart_destroy(cp->lg_geom);
 663         if (strcmp(oldtype, items[0].text) != 0 && strcmp(items[0].text,
 664             "freebsd") == 0)
 665                 gpart_partition(pp->lg_name, "BSD");
 666
 667         for (i = 0; i < nitems(items); i++)
 668                 if (items[i].text_free)
 669                         free(items[i].text);
 670 }
 671
 672 void
 673 set_default_part_metadata(const char *name, const char *scheme,
 674     const char *type, const char *mountpoint, const char *newfs)
 675 {
 676         struct partition_metadata *md;
 677         char *zpool_name = NULL;
 678         const char *default_bootmount = NULL;
 679         int i;
 680
 681         /* Set part metadata */
 682         md = get_part_metadata(name, 1);
 683
 684         if (newfs) {
 685                 if (md->newfs != NULL) {
 686                         free(md->newfs);
 687                         md->newfs = NULL;
 688                 }
 689
 690                 if (newfs != NULL && newfs[0] != '\0') {
 691                         md->newfs = malloc(strlen(newfs) + strlen(" /dev/") +
 692                             strlen(mountpoint) + 5 + strlen(name) + 1);
 693                         if (strcmp("freebsd-zfs", type) == 0) {
 694                                 zpool_name = strdup((strlen(mountpoint) == 1) ?
 695                                     "root" : &mountpoint[1]);
 696                                 for (i = 0; zpool_name[i] != 0; i++)
 697                                         if (!isalnum(zpool_name[i]))
 698                                                 zpool_name[i] = '_';
 699                                 sprintf(md->newfs, "%s %s /dev/%s", newfs,
 700                                     zpool_name, name);
 701                         } else {
 702                                 sprintf(md->newfs, "%s /dev/%s", newfs, name);
 703                         }
 704                 }
 705         }
 706
 707         if (strcmp(type, "freebsd-swap") == 0)
 708                 mountpoint = "none";
 709         if (strcmp(type, bootpart_type(scheme, &default_bootmount)) == 0) {
 710                 if (default_bootmount == NULL) {
 711
 712                         int fd = openat(tmpdfd, "bsdinstall-esps",
 713                             O_CREAT | O_WRONLY | O_APPEND, 0600);
 714                         if (fd > 0) {
 715                                 write(fd, md->name, strlen(md->name));
 716                                 write(fd, "\n", 1);
 717                                 close(fd);
 718                         }
 719
 720                         md->bootcode = 1;
 721                 }
 722                 else if (mountpoint == NULL || strlen(mountpoint) == 0)
 723                         mountpoint = default_bootmount;
 724         }
 725
 726         if (mountpoint == NULL || mountpoint[0] == '\0') {
 727                 if (md->fstab != NULL) {
 728                         free(md->fstab->fs_spec);
 729                         free(md->fstab->fs_file);
 730                         free(md->fstab->fs_vfstype);
 731                         free(md->fstab->fs_mntops);
 732                         free(md->fstab->fs_type);
 733                         free(md->fstab);
 734                         md->fstab = NULL;
 735                 }
 736         } else {
 737                 if (md->fstab == NULL) {
 738                         md->fstab = malloc(sizeof(struct fstab));
 739                 } else {
 740                         free(md->fstab->fs_spec);
 741                         free(md->fstab->fs_file);
 742                         free(md->fstab->fs_vfstype);
 743                         free(md->fstab->fs_mntops);
 744                         free(md->fstab->fs_type);
 745                 }
 746                 if (strcmp("freebsd-zfs", type) == 0) {
 747                         md->fstab->fs_spec = strdup(zpool_name);
 748                 } else {
 749                         md->fstab->fs_spec = malloc(strlen(name) +
 750                             strlen("/dev/") + 1);
 751                         sprintf(md->fstab->fs_spec, "/dev/%s", name);
 752                 }
 753                 md->fstab->fs_file = strdup(mountpoint);
 754                 /* Get VFS from text after freebsd-, if possible */
 755                 if (strncmp("freebsd-", type, 8) == 0)
 756                         md->fstab->fs_vfstype = strdup(&type[8]);
 757                 else if (strcmp("fat32", type) == 0 || strcmp("efi", type) == 0
 758                     || strcmp("ms-basic-data", type) == 0)
 759                         md->fstab->fs_vfstype = strdup("msdosfs");
 760                 else
 761                         md->fstab->fs_vfstype = strdup(type); /* Guess */
 762                 if (strcmp(type, "freebsd-swap") == 0) {
 763                         md->fstab->fs_type = strdup(FSTAB_SW);
 764                         md->fstab->fs_freq = 0;
 765                         md->fstab->fs_passno = 0;
 766                 } else if (strcmp(type, "freebsd-zfs") == 0) {
 767                         md->fstab->fs_type = strdup(FSTAB_RW);
 768                         md->fstab->fs_freq = 0;
 769                         md->fstab->fs_passno = 0;
 770                 } else {
 771                         md->fstab->fs_type = strdup(FSTAB_RW);
 772                         if (strcmp(mountpoint, "/") == 0) {
 773                                 md->fstab->fs_freq = 1;
 774                                 md->fstab->fs_passno = 1;
 775                         } else {
 776                                 md->fstab->fs_freq = 2;
 777                                 md->fstab->fs_passno = 2;
 778                         }
 779                 }
 780                 md->fstab->fs_mntops = strdup(md->fstab->fs_type);
 781         }
 782
 783         if (zpool_name != NULL)
 784                 free(zpool_name);
 785 }
 786
 787 static
 788 int part_compare(const void *xa, const void *xb)
 789 {
 790         struct gprovider **a = (struct gprovider **)xa;
 791         struct gprovider **b = (struct gprovider **)xb;
 792         intmax_t astart, bstart;
 793         struct gconfig *gc;
 794
 795         astart = bstart = 0;
 796         LIST_FOREACH(gc, &(*a)->lg_config, lg_config)
 797                 if (strcmp(gc->lg_name, "start") == 0) {
 798                         astart = strtoimax(gc->lg_val, NULL, 0);
 799                         break;
 800                 }
 801         LIST_FOREACH(gc, &(*b)->lg_config, lg_config)
 802                 if (strcmp(gc->lg_name, "start") == 0) {
 803                         bstart = strtoimax(gc->lg_val, NULL, 0);
 804                         break;
 805                 }
 806
 807         if (astart < bstart)
 808                 return -1;
 809         else if (astart > bstart)
 810                 return 1;
 811         else
 812                 return 0;
 813 }
 814
 815 intmax_t
 816 gpart_max_free(struct ggeom *geom, intmax_t *npartstart)
 817 {
 818         struct gconfig *gc;
 819         struct gprovider *pp, **providers;
 820         intmax_t sectorsize, stripesize, offset;
 821         intmax_t lastend;
 822         intmax_t start, end;
 823         intmax_t maxsize, maxstart;
 824         intmax_t partstart, partend;
 825         int i, nparts;
 826
 827         /* Now get the maximum free size and free start */
 828         start = end = 0;
 829         LIST_FOREACH(gc, &geom->lg_config, lg_config) {
 830                 if (strcmp(gc->lg_name, "first") == 0)
 831                         start = strtoimax(gc->lg_val, NULL, 0);
 832                 if (strcmp(gc->lg_name, "last") == 0)
 833                         end = strtoimax(gc->lg_val, NULL, 0);
 834         }
 835
 836         i = nparts = 0;
 837         LIST_FOREACH(pp, &geom->lg_provider, lg_provider)
 838                 nparts++;
 839         providers = calloc(nparts, sizeof(providers[0]));
 840         LIST_FOREACH(pp, &geom->lg_provider, lg_provider)
 841                 providers[i++] = pp;
 842         qsort(providers, nparts, sizeof(providers[0]), part_compare);
 843
 844         lastend = start - 1;
 845         maxsize = 0;
 846         for (i = 0; i < nparts; i++) {
 847                 pp = providers[i];
 848
 849                 LIST_FOREACH(gc, &pp->lg_config, lg_config) {
 850                         if (strcmp(gc->lg_name, "start") == 0)
 851                                 partstart = strtoimax(gc->lg_val, NULL, 0);
 852                         if (strcmp(gc->lg_name, "end") == 0)
 853                                 partend = strtoimax(gc->lg_val, NULL, 0);
 854                 }
 855
 856                 if (partstart - lastend > maxsize) {
 857                         maxsize = partstart - lastend - 1;
 858                         maxstart = lastend + 1;
 859                 }
 860
 861                 lastend = partend;
 862         }
 863
 864         if (end - lastend > maxsize) {
 865                 maxsize = end - lastend;
 866                 maxstart = lastend + 1;
 867         }
 868
 869         pp = LIST_FIRST(&geom->lg_consumer)->lg_provider;
 870
 871         /*
 872          * Round the start and size of the largest available space up to
 873          * the nearest multiple of the adjusted stripe size.
 874          *
 875          * The adjusted stripe size is the least common multiple of the
 876          * actual stripe size, or the sector size if no stripe size was
 877          * reported, and 4096.  The reason for this is that contemporary
 878          * disks often have 4096-byte physical sectors but report 512
 879          * bytes instead for compatibility with older / broken operating
 880          * systems and BIOSes.  For the same reasons, virtualized storage
 881          * may also report a 512-byte stripe size, or none at all.
 882          */
 883         sectorsize = pp->lg_sectorsize;
 884         if ((stripesize = pp->lg_stripesize) == 0)
 885                 stripesize = sectorsize;
 886         while (stripesize % 4096 != 0)
 887                 stripesize *= 2;
 888         if ((offset = maxstart * sectorsize % stripesize) != 0) {
 889                 offset = (stripesize - offset) / sectorsize;
 890                 maxstart += offset;
 891                 maxsize -= offset;
 892         }
 893
 894         if (npartstart != NULL)
 895                 *npartstart = maxstart;
 896
 897         return (maxsize);
 898 }
 899
 900 static size_t
 901 add_boot_partition(struct ggeom *geom, struct gprovider *pp,
 902     const char *scheme, int interactive)
 903 {
 904         struct gconfig *gc;
 905         struct gprovider *ppi;
 906         int choice;
 907
 908         /* Check for existing freebsd-boot partition */
 909         LIST_FOREACH(ppi, &geom->lg_provider, lg_provider) {
 910                 struct partition_metadata *md;
 911                 const char *bootmount = NULL;
 912
 913                 LIST_FOREACH(gc, &ppi->lg_config, lg_config)
 914                         if (strcmp(gc->lg_name, "type") == 0)
 915                                 break;
 916                 if (gc == NULL)
 917                         continue;
 918                 if (strcmp(gc->lg_val, bootpart_type(scheme, &bootmount)) != 0)
 919                         continue;
 920
 921                 /*
 922                  * If the boot partition is not mountable and needs partcode,
 923                  * but doesn't have it, it doesn't satisfy our requirements.
 924                  */
 925                 md = get_part_metadata(ppi->lg_name, 0);
 926                 if (bootmount == NULL && (md == NULL || !md->bootcode))
 927                         continue;
 928
 929                 /* If it is mountable, but mounted somewhere else, remount */
 930                 if (bootmount != NULL && md != NULL && md->fstab != NULL
 931                     && strlen(md->fstab->fs_file) > 0
 932                     && strcmp(md->fstab->fs_file, bootmount) != 0)
 933                         continue;
 934
 935                 /* If it is mountable, but mountpoint is not set, mount it */
 936                 if (bootmount != NULL && md == NULL)
 937                         set_default_part_metadata(ppi->lg_name, scheme,
 938                             gc->lg_val, bootmount, NULL);
 939
 940                 /* Looks good at this point, no added data needed */
 941                 return (0);
 942         }
 943
 944         if (interactive)
 945                 choice = dialog_yesno("Boot Partition",
 946                     "This partition scheme requires a boot partition "
 947                     "for the disk to be bootable. Would you like to "
 948                     "make one now?", 0, 0);
 949         else
 950                 choice = 0;
 951
 952         if (choice == 0) { /* yes */
 953                 struct partition_metadata *md;
 954                 const char *bootmount = NULL;
 955                 char *bootpartname = NULL;
 956                 char sizestr[7];
 957
 958                 humanize_number(sizestr, 7,
 959                     bootpart_size(scheme), "B", HN_AUTOSCALE,
 960                     HN_NOSPACE | HN_DECIMAL);
 961
 962                 gpart_create(pp, bootpart_type(scheme, &bootmount),
 963                     sizestr, bootmount, &bootpartname, 0);
 964
 965                 if (bootpartname == NULL) /* Error reported to user already */
 966                         return 0;
 967
 968                 /* If the part is not mountable, make sure newfs isn't set */
 969                 if (bootmount == NULL) {
 970                         md = get_part_metadata(bootpartname, 0);
 971                         if (md != NULL && md->newfs != NULL) {
 972                                 free(md->newfs);
 973                                 md->newfs = NULL;
 974                         }
 975                 }
 976
 977                 free(bootpartname);
 978
 979                 return (bootpart_size(scheme));
 980         }
 981
 982         return (0);
 983 }
 984
 985 void
 986 gpart_create(struct gprovider *pp, const char *default_type,
 987     const char *default_size, const char *default_mountpoint,
 988     char **partname, int interactive)
 989 {
 990         struct gctl_req *r;
 991         struct gconfig *gc;
 992         struct gconsumer *cp;
 993         struct ggeom *geom;
 994         const char *errstr, *scheme;
 995         char sizestr[32], startstr[32], output[64], *newpartname;
 996         char newfs[255], options_fstype[64];
 997         intmax_t maxsize, size, sector, firstfree, stripe;
 998         uint64_t bytes;
 999         int nitems, choice, junk;
1000         unsigned i;
1001
1002         DIALOG_FORMITEM items[] = {
1003                 {0, "Type:", 5, 0, 0, FALSE, "freebsd-ufs", 11, 0, 12, 15, 0,
1004                     FALSE, "Filesystem type (e.g. freebsd-ufs, freebsd-zfs, "
1005                     "freebsd-swap)", FALSE},
1006                 {0, "Size:", 5, 1, 0, FALSE, "", 11, 1, 12, 15, 0,
1007                     FALSE, "Partition size. Append K, M, G for kilobytes, "
1008                     "megabytes or gigabytes.", FALSE},
1009                 {0, "Mountpoint:", 11, 2, 0, FALSE, "", 11, 2, 12, 15, 0,
1010                     FALSE, "Path at which to mount partition (blank for "
1011                     "swap, / for root filesystem)", FALSE},
1012                 {0, "Label:", 7, 3, 0, FALSE, "", 11, 3, 12, 15, 0, FALSE,
1013                     "Partition name. Not all partition schemes support this.",
1014                     FALSE},
1015         };
1016
1017         if (partname != NULL)
1018                 *partname = NULL;
1019
1020         /* Record sector and stripe sizes */
1021         sector = pp->lg_sectorsize;
1022         stripe = pp->lg_stripesize;
1023
1024         /*
1025          * Find the PART geom we are manipulating. This may be a consumer of
1026          * this provider, or its parent. Check the consumer case first.
1027          */
1028         geom = NULL;
1029         LIST_FOREACH(cp, &pp->lg_consumers, lg_consumers)
1030                 if (strcmp(cp->lg_geom->lg_class->lg_name, "PART") == 0) {
1031                         geom = cp->lg_geom;
1032                         break;
1033                 }
1034
1035         if (geom == NULL && strcmp(pp->lg_geom->lg_class->lg_name, "PART") == 0)
1036                 geom = pp->lg_geom;
1037
1038         /* Now get the partition scheme */
1039         scheme = NULL;
1040         if (geom != NULL) {
1041                 LIST_FOREACH(gc, &geom->lg_config, lg_config)
1042                         if (strcmp(gc->lg_name, "scheme") == 0)
1043                                 scheme = gc->lg_val;
1044         }
1045
1046         if (geom == NULL || scheme == NULL || strcmp(scheme, "(none)") == 0) {
1047                 if (gpart_partition(pp->lg_name, NULL) == 0)
1048                         dialog_msgbox("",
1049                             "The partition table has been successfully created."
1050                             " Please press Create again to create partitions.",
1051                             0, 0, TRUE);
1052
1053                 return;
1054         }
1055
1056         /*
1057          * If we still don't have a geom, either the user has
1058          * canceled partitioning or there has been an error which has already
1059          * been displayed, so bail.
1060          */
1061         if (geom == NULL)
1062                 return;
1063
1064         maxsize = size = gpart_max_free(geom, &firstfree);
1065         if (size <= 0) {
1066                 dialog_msgbox("Error", "No free space left on device.", 0, 0,
1067                     TRUE);
1068                 return;
1069         }
1070
1071         humanize_number(sizestr, 7, size*sector, "B", HN_AUTOSCALE,
1072             HN_NOSPACE | HN_DECIMAL);
1073         items[1].text = sizestr;
1074
1075         /* Special-case the MBR default type for nested partitions */
1076         if (strcmp(scheme, "MBR") == 0) {
1077                 items[0].text = "freebsd";
1078                 items[0].help = "Filesystem type (e.g. freebsd, fat32)";
1079         }
1080
1081         nitems = scheme_supports_labels(scheme) ? 4 : 3;
1082
1083         if (default_type != NULL)
1084                 items[0].text = (char *)default_type;
1085         if (default_size != NULL)
1086                 items[1].text = (char *)default_size;
1087         if (default_mountpoint != NULL)
1088                 items[2].text = (char *)default_mountpoint;
1089
1090         /* Default options */
1091         strncpy(options_fstype, items[0].text,
1092             sizeof(options_fstype));
1093         newfs_command(options_fstype, newfs, 1);
1094 addpartform:
1095         if (interactive) {
1096                 dialog_vars.extra_label = "Options";
1097                 dialog_vars.extra_button = TRUE;
1098                 choice = dlg_form("Add Partition", "", 0, 0, 0, nitems,
1099                     items, &junk);
1100                 dialog_vars.extra_button = FALSE;
1101                 switch (choice) {
1102                 case 0: /* OK */
1103                         break;
1104                 case 1: /* Cancel */
1105                         return;
1106                 case 3: /* Options */
1107                         strncpy(options_fstype, items[0].text,
1108                             sizeof(options_fstype));
1109                         newfs_command(options_fstype, newfs, 0);
1110                         goto addpartform;
1111                 }
1112         }
1113
1114         /*
1115          * If the user changed the fs type after specifying options, undo
1116          * their choices in favor of the new filesystem's defaults.
1117          */
1118         if (strcmp(options_fstype, items[0].text) != 0) {
1119                 strncpy(options_fstype, items[0].text, sizeof(options_fstype));
1120                 newfs_command(options_fstype, newfs, 1);
1121         }
1122
1123         size = maxsize;
1124         if (strlen(items[1].text) > 0) {
1125                 if (expand_number(items[1].text, &bytes) != 0) {
1126                         char error[512];
1127
1128                         sprintf(error, "Invalid size: %s\n", strerror(errno));
1129                         dialog_msgbox("Error", error, 0, 0, TRUE);
1130                         goto addpartform;
1131                 }
1132                 size = MIN((intmax_t)(bytes/sector), maxsize);
1133         }
1134
1135         /* Check if the label has a / in it */
1136         if (strchr(items[3].text, '/') != NULL) {
1137                 dialog_msgbox("Error", "Label contains a /, which is not an "
1138                     "allowed character.", 0, 0, TRUE);
1139                 goto addpartform;
1140         }
1141
1142         /* Warn if no mountpoint set */
1143         if (strcmp(items[0].text, "freebsd-ufs") == 0 &&
1144             items[2].text[0] != '/') {
1145                 choice = 0;
1146                 if (interactive) {
1147                         dialog_vars.defaultno = TRUE;
1148                         choice = dialog_yesno("Warning",
1149                             "This partition does not have a valid mountpoint "
1150                             "(for the partition from which you intend to boot the "
1151                             "operating system, the mountpoint should be /). Are you "
1152                             "sure you want to continue?"
1153                         , 0, 0);
1154                         dialog_vars.defaultno = FALSE;
1155                 }
1156                 if (choice == 1) /* cancel */
1157                         goto addpartform;
1158         }
1159
1160         /*
1161          * Error if this scheme needs nested partitions, this is one, and
1162          * a mountpoint was set.
1163          */
1164         if (strcmp(items[0].text, "freebsd") == 0 &&
1165             strlen(items[2].text) > 0) {
1166                 dialog_msgbox("Error", "Partitions of type \"freebsd\" are "
1167                     "nested BSD-type partition schemes and cannot have "
1168                     "mountpoints. After creating one, select it and press "
1169                     "Create again to add the actual file systems.", 0, 0, TRUE);
1170                 goto addpartform;
1171         }
1172
1173         /* If this is the root partition, check that this scheme is bootable */
1174         if (strcmp(items[2].text, "/") == 0 && !is_scheme_bootable(scheme)) {
1175                 char message[512];
1176                 sprintf(message, "This partition scheme (%s) is not bootable "
1177                     "on this platform. Are you sure you want to proceed?",
1178                     scheme);
1179                 dialog_vars.defaultno = TRUE;
1180                 choice = dialog_yesno("Warning", message, 0, 0);
1181                 dialog_vars.defaultno = FALSE;
1182                 if (choice == 1) /* cancel */
1183                         goto addpartform;
1184         }
1185
1186         /* If this is the root partition, check that this fs is bootable */
1187         if (strcmp(items[2].text, "/") == 0 && !is_fs_bootable(scheme,
1188             items[0].text)) {
1189                 char message[512];
1190                 sprintf(message, "This file system (%s) is not bootable "
1191                     "on this system. Are you sure you want to proceed?",
1192                     items[0].text);
1193                 dialog_vars.defaultno = TRUE;
1194                 choice = dialog_yesno("Warning", message, 0, 0);
1195                 dialog_vars.defaultno = FALSE;
1196                 if (choice == 1) /* cancel */
1197                         goto addpartform;
1198         }
1199
1200         /*
1201          * If this is the root partition, and we need a boot partition, ask
1202          * the user to add one.
1203          */
1204
1205         if ((strcmp(items[0].text, "freebsd") == 0 ||
1206             strcmp(items[2].text, "/") == 0) && bootpart_size(scheme) > 0) {
1207                 size_t bytes = add_boot_partition(geom, pp, scheme,
1208                     interactive);
1209
1210                 /* Now adjust the part we are really adding forward */
1211                 if (bytes > 0) {
1212                         firstfree += bytes / sector;
1213                         size -= (bytes + stripe)/sector;
1214                         if (stripe > 0 && (firstfree*sector % stripe) != 0)
1215                                 firstfree += (stripe - ((firstfree*sector) %
1216                                     stripe)) / sector;
1217                 }
1218         }
1219
1220         r = gctl_get_handle();
1221         gctl_ro_param(r, "class", -1, "PART");
1222         gctl_ro_param(r, "arg0", -1, geom->lg_name);
1223         gctl_ro_param(r, "flags", -1, GPART_FLAGS);
1224         gctl_ro_param(r, "verb", -1, "add");
1225
1226         gctl_ro_param(r, "type", -1, items[0].text);
1227         snprintf(sizestr, sizeof(sizestr), "%jd", size);
1228         gctl_ro_param(r, "size", -1, sizestr);
1229         snprintf(startstr, sizeof(startstr), "%jd", firstfree);
1230         gctl_ro_param(r, "start", -1, startstr);
1231         if (items[3].text[0] != '\0')
1232                 gctl_ro_param(r, "label", -1, items[3].text);
1233         gctl_rw_param(r, "output", sizeof(output), output);
1234         errstr = gctl_issue(r);
1235         if (errstr != NULL && errstr[0] != '\0') {
1236                 gpart_show_error("Error", NULL, errstr);
1237                 gctl_free(r);
1238                 goto addpartform;
1239         }
1240         newpartname = strtok(output, " ");
1241         gctl_free(r);
1242
1243         /*
1244          * Try to destroy any geom that gpart picked up already here from
1245          * dirty blocks.
1246          */
1247         r = gctl_get_handle();
1248         gctl_ro_param(r, "class", -1, "PART");
1249         gctl_ro_param(r, "arg0", -1, newpartname);
1250         gctl_ro_param(r, "flags", -1, GPART_FLAGS);
1251         junk = 1;
1252         gctl_ro_param(r, "force", sizeof(junk), &junk);
1253         gctl_ro_param(r, "verb", -1, "destroy");
1254         gctl_issue(r); /* Error usually expected and non-fatal */
1255         gctl_free(r);
1256
1257
1258         if (strcmp(items[0].text, "freebsd") == 0)
1259                 gpart_partition(newpartname, "BSD");
1260         else
1261                 set_default_part_metadata(newpartname, scheme,
1262                     items[0].text, items[2].text, newfs);
1263
1264         for (i = 0; i < nitems(items); i++)
1265                 if (items[i].text_free)
1266                         free(items[i].text);
1267
1268         if (partname != NULL)
1269                 *partname = strdup(newpartname);
1270 }
1271
1272 void
1273 gpart_delete(struct gprovider *pp)
1274 {
1275         struct gconfig *gc;
1276         struct ggeom *geom;
1277         struct gconsumer *cp;
1278         struct gctl_req *r;
1279         const char *errstr;
1280         intmax_t idx;
1281         int is_partition;
1282
1283         /* Is it a partition? */
1284         is_partition = (strcmp(pp->lg_geom->lg_class->lg_name, "PART") == 0);
1285
1286         /* Find out if this is the root of a gpart geom */
1287         geom = NULL;
1288         LIST_FOREACH(cp, &pp->lg_consumers, lg_consumers)
1289                 if (strcmp(cp->lg_geom->lg_class->lg_name, "PART") == 0) {
1290                         geom = cp->lg_geom;
1291                         break;
1292                 }
1293
1294         /* If so, destroy all children */
1295         if (geom != NULL) {
1296                 gpart_destroy(geom);
1297
1298                 /* If this is a partition, revert it, so it can be deleted */
1299                 if (is_partition) {
1300                         r = gctl_get_handle();
1301                         gctl_ro_param(r, "class", -1, "PART");
1302                         gctl_ro_param(r, "arg0", -1, geom->lg_name);
1303                         gctl_ro_param(r, "verb", -1, "undo");
1304                         gctl_issue(r); /* Ignore non-fatal errors */
1305                         gctl_free(r);
1306                 }
1307         }
1308
1309         /*
1310          * If this is not a partition, see if that is a problem, complain if
1311          * necessary, and return always, since we need not do anything further,
1312          * error or no.
1313          */
1314         if (!is_partition) {
1315                 if (geom == NULL)
1316                         dialog_msgbox("Error",
1317                             "Only partitions can be deleted.", 0, 0, TRUE);
1318                 return;
1319         }
1320
1321         r = gctl_get_handle();
1322         gctl_ro_param(r, "class", -1, pp->lg_geom->lg_class->lg_name);
1323         gctl_ro_param(r, "arg0", -1, pp->lg_geom->lg_name);
1324         gctl_ro_param(r, "flags", -1, GPART_FLAGS);
1325         gctl_ro_param(r, "verb", -1, "delete");
1326
1327         LIST_FOREACH(gc, &pp->lg_config, lg_config) {
1328                 if (strcmp(gc->lg_name, "index") == 0) {
1329                         idx = atoi(gc->lg_val);
1330                         gctl_ro_param(r, "index", sizeof(idx), &idx);
1331                         break;
1332                 }
1333         }
1334
1335         errstr = gctl_issue(r);
1336         if (errstr != NULL && errstr[0] != '\0') {
1337                 gpart_show_error("Error", NULL, errstr);
1338                 gctl_free(r);
1339                 return;
1340         }
1341
1342         gctl_free(r);
1343
1344         delete_part_metadata(pp->lg_name);
1345 }
1346
1347 void
1348 gpart_revert_all(struct gmesh *mesh)
1349 {
1350         struct gclass *classp;
1351         struct gconfig *gc;
1352         struct ggeom *gp;
1353         struct gctl_req *r;
1354         const char *modified;
1355
1356         LIST_FOREACH(classp, &mesh->lg_class, lg_class) {
1357                 if (strcmp(classp->lg_name, "PART") == 0)
1358                         break;
1359         }
1360
1361         if (strcmp(classp->lg_name, "PART") != 0) {
1362                 dialog_msgbox("Error", "gpart not found!", 0, 0, TRUE);
1363                 return;
1364         }
1365
1366         LIST_FOREACH(gp, &classp->lg_geom, lg_geom) {
1367                 modified = "true"; /* XXX: If we don't know (kernel too old),
1368                                     * assume there are modifications. */
1369                 LIST_FOREACH(gc, &gp->lg_config, lg_config) {
1370                         if (strcmp(gc->lg_name, "modified") == 0) {
1371                                 modified = gc->lg_val;
1372                                 break;
1373                         }
1374                 }
1375
1376                 if (strcmp(modified, "false") == 0)
1377                         continue;
1378
1379                 r = gctl_get_handle();
1380                 gctl_ro_param(r, "class", -1, "PART");
1381                 gctl_ro_param(r, "arg0", -1, gp->lg_name);
1382                 gctl_ro_param(r, "verb", -1, "undo");
1383
1384                 gctl_issue(r);
1385                 gctl_free(r);
1386         }
1387 }
1388
1389 void
1390 gpart_commit(struct gmesh *mesh)
1391 {
1392         struct partition_metadata *md;
1393         struct gclass *classp;
1394         struct ggeom *gp;
1395         struct gconfig *gc;
1396         struct gconsumer *cp;
1397         struct gprovider *pp;
1398         struct gctl_req *r;
1399         const char *errstr;
1400         const char *modified;
1401         const char *rootfs;
1402
1403         LIST_FOREACH(classp, &mesh->lg_class, lg_class) {
1404                 if (strcmp(classp->lg_name, "PART") == 0)
1405                         break;
1406         }
1407
1408         /* Figure out what filesystem / uses */
1409         rootfs = "ufs"; /* Assume ufs if nothing else present */
1410         TAILQ_FOREACH(md, &part_metadata, metadata) {
1411                 if (md->fstab != NULL && strcmp(md->fstab->fs_file, "/") == 0) {
1412                         rootfs = md->fstab->fs_vfstype;
1413                         break;
1414                 }
1415         }
1416
1417         if (strcmp(classp->lg_name, "PART") != 0) {
1418                 dialog_msgbox("Error", "gpart not found!", 0, 0, TRUE);
1419                 return;
1420         }
1421
1422         LIST_FOREACH(gp, &classp->lg_geom, lg_geom) {
1423                 modified = "true"; /* XXX: If we don't know (kernel too old),
1424                                     * assume there are modifications. */
1425                 LIST_FOREACH(gc, &gp->lg_config, lg_config) {
1426                         if (strcmp(gc->lg_name, "modified") == 0) {
1427                                 modified = gc->lg_val;
1428                                 break;
1429                         }
1430                 }
1431
1432                 if (strcmp(modified, "false") == 0)
1433                         continue;
1434
1435                 /* Add bootcode if necessary, before the commit */
1436                 md = get_part_metadata(gp->lg_name, 0);
1437                 if (md != NULL && md->bootcode)
1438                         gpart_bootcode(gp);
1439
1440                 /* Now install partcode on its partitions, if necessary */
1441                 LIST_FOREACH(pp, &gp->lg_provider, lg_provider) {
1442                         md = get_part_metadata(pp->lg_name, 0);
1443                         if (md == NULL || !md->bootcode)
1444                                 continue;
1445
1446                         /* Mark this partition active if that's required */
1447                         gpart_activate(pp);
1448
1449                         /* Check if the partition has sub-partitions */
1450                         LIST_FOREACH(cp, &pp->lg_consumers, lg_consumers)
1451                                 if (strcmp(cp->lg_geom->lg_class->lg_name,
1452                                     "PART") == 0)
1453                                         break;
1454
1455                         if (cp == NULL) /* No sub-partitions */
1456                                 gpart_partcode(pp, rootfs);
1457                 }
1458
1459                 r = gctl_get_handle();
1460                 gctl_ro_param(r, "class", -1, "PART");
1461                 gctl_ro_param(r, "arg0", -1, gp->lg_name);
1462                 gctl_ro_param(r, "verb", -1, "commit");
1463
1464                 errstr = gctl_issue(r);
1465                 if (errstr != NULL && errstr[0] != '\0')
1466                         gpart_show_error("Error", NULL, errstr);
1467                 gctl_free(r);
1468         }
1469 }
1470