usr.sbin/bsdinstall/partedit/gpart_ops.c

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