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 const char *
 210 choose_part_type(const char *def_scheme)
 211 {
 212         int cancel, choice;
 213         const char *scheme = NULL;
 214
 215         DIALOG_LISTITEM items[] = {
 216                 {"APM", "Apple Partition Map",
 217                     "Bootable on PowerPC Apple Hardware", 0 },
 218                 {"BSD", "BSD Labels",
 219                     "Bootable on most x86 systems", 0 },
 220                 {"GPT", "GUID Partition Table",
 221                     "Bootable on most x86 systems", 0 },
 222                 {"MBR", "DOS Partitions",
 223                     "Bootable on most x86 systems", 0 },
 224                 {"PC98", "NEC PC9801 Partition Table",
 225                     "Bootable on NEC PC9801 systems", 0 },
 226                 {"VTOC8", "Sun VTOC8 Partition Table",
 227                     "Bootable on Sun SPARC systems", 0 },
 228         };
 229
 230 parttypemenu:
 231         dialog_vars.default_item = __DECONST(char *, def_scheme);
 232         cancel = dlg_menu("Partition Scheme",
 233             "Select a partition scheme for this volume:", 0, 0, 0,
 234             sizeof(items) / sizeof(items[0]), items, &choice, NULL);
 235         dialog_vars.default_item = NULL;
 236
 237         if (cancel)
 238                 return NULL;
 239
 240         if (!is_scheme_bootable(items[choice].name)) {
 241                 char message[512];
 242                 sprintf(message, "This partition scheme (%s) is not "
 243                     "bootable on this platform. Are you sure you want "
 244                     "to proceed?", items[choice].name);
 245                 dialog_vars.defaultno = TRUE;
 246                 cancel = dialog_yesno("Warning", message, 0, 0);
 247                 dialog_vars.defaultno = FALSE;
 248                 if (cancel) /* cancel */
 249                         goto parttypemenu;
 250         }
 251
 252         scheme = items[choice].name;
 253
 254         return scheme;
 255 }
 256
 257 int
 258 gpart_partition(const char *lg_name, const char *scheme)
 259 {
 260         int cancel;
 261         struct gctl_req *r;
 262         const char *errstr;
 263
 264 schememenu:
 265         if (scheme == NULL) {
 266                 scheme = choose_part_type(default_scheme());
 267
 268                 if (scheme == NULL)
 269                         return (-1);
 270
 271                 if (!is_scheme_bootable(scheme)) {
 272                         char message[512];
 273                         sprintf(message, "This partition scheme (%s) is not "
 274                             "bootable on this platform. Are you sure you want "
 275                             "to proceed?", scheme);
 276                         dialog_vars.defaultno = TRUE;
 277                         cancel = dialog_yesno("Warning", message, 0, 0);
 278                         dialog_vars.defaultno = FALSE;
 279                         if (cancel) { /* cancel */
 280                                 /* Reset scheme so user can choose another */
 281                                 scheme = NULL;
 282                                 goto schememenu;
 283                         }
 284                 }
 285         }
 286
 287         r = gctl_get_handle();
 288         gctl_ro_param(r, "class", -1, "PART");
 289         gctl_ro_param(r, "arg0", -1, lg_name);
 290         gctl_ro_param(r, "flags", -1, GPART_FLAGS);
 291         gctl_ro_param(r, "scheme", -1, scheme);
 292         gctl_ro_param(r, "verb", -1, "create");
 293
 294         errstr = gctl_issue(r);
 295         if (errstr != NULL && errstr[0] != '\0') {
 296                 gpart_show_error("Error", NULL, errstr);
 297                 gctl_free(r);
 298                 scheme = NULL;
 299                 goto schememenu;
 300         }
 301         gctl_free(r);
 302
 303         if (bootcode_path(scheme) != NULL)
 304                 get_part_metadata(lg_name, 1)->bootcode = 1;
 305         return (0);
 306 }
 307
 308 static void
 309 gpart_activate(struct gprovider *pp)
 310 {
 311         struct gconfig *gc;
 312         struct gctl_req *r;
 313         const char *errstr, *scheme;
 314         const char *attribute = NULL;
 315         intmax_t idx;
 316
 317         /*
 318          * Some partition schemes need this partition to be marked 'active'
 319          * for it to be bootable.
 320          */
 321         LIST_FOREACH(gc, &pp->lg_geom->lg_config, lg_config) {
 322                 if (strcmp(gc->lg_name, "scheme") == 0) {
 323                         scheme = gc->lg_val;
 324                         break;
 325                 }
 326         }
 327
 328         if (strcmp(scheme, "MBR") == 0 || strcmp(scheme, "EBR") == 0 ||
 329             strcmp(scheme, "PC98") == 0)
 330                 attribute = "active";
 331         else
 332                 return;
 333
 334         LIST_FOREACH(gc, &pp->lg_config, lg_config) {
 335                 if (strcmp(gc->lg_name, "index") == 0) {
 336                         idx = atoi(gc->lg_val);
 337                         break;
 338                 }
 339         }
 340
 341         r = gctl_get_handle();
 342         gctl_ro_param(r, "class", -1, "PART");
 343         gctl_ro_param(r, "arg0", -1, pp->lg_geom->lg_name);
 344         gctl_ro_param(r, "verb", -1, "set");
 345         gctl_ro_param(r, "attrib", -1, attribute);
 346         gctl_ro_param(r, "index", sizeof(idx), &idx);
 347
 348         errstr = gctl_issue(r);
 349         if (errstr != NULL && errstr[0] != '\0')
 350                 gpart_show_error("Error", "Error marking partition active:",
 351                     errstr);
 352         gctl_free(r);
 353 }
 354
 355 void
 356 gpart_set_root(const char *lg_name, const char *attribute)
 357 {
 358         struct gctl_req *r;
 359         const char *errstr;
 360
 361         r = gctl_get_handle();
 362         gctl_ro_param(r, "class", -1, "PART");
 363         gctl_ro_param(r, "arg0", -1, lg_name);
 364         gctl_ro_param(r, "flags", -1, "C");
 365         gctl_ro_param(r, "verb", -1, "set");
 366         gctl_ro_param(r, "attrib", -1, attribute);
 367
 368         errstr = gctl_issue(r);
 369         if (errstr != NULL && errstr[0] != '\0')
 370                 gpart_show_error("Error", "Error setting parameter on disk:",
 371                     errstr);
 372         gctl_free(r);
 373 }
 374
 375 static void
 376 gpart_bootcode(struct ggeom *gp)
 377 {
 378         const char *bootcode;
 379         struct gconfig *gc;
 380         struct gctl_req *r;
 381         const char *errstr, *scheme;
 382         uint8_t *boot;
 383         size_t bootsize, bytes;
 384         int bootfd;
 385
 386         /*
 387          * Write default bootcode to the newly partitioned disk, if that
 388          * applies on this platform.
 389          */
 390         LIST_FOREACH(gc, &gp->lg_config, lg_config) {
 391                 if (strcmp(gc->lg_name, "scheme") == 0) {
 392                         scheme = gc->lg_val;
 393                         break;
 394                 }
 395         }
 396
 397         bootcode = bootcode_path(scheme);
 398         if (bootcode == NULL)
 399                 return;
 400
 401         bootfd = open(bootcode, O_RDONLY);
 402         if (bootfd < 0) {
 403                 dialog_msgbox("Bootcode Error", strerror(errno), 0, 0,
 404                     TRUE);
 405                 return;
 406         }
 407
 408         bootsize = lseek(bootfd, 0, SEEK_END);
 409         boot = malloc(bootsize);
 410         lseek(bootfd, 0, SEEK_SET);
 411         bytes = 0;
 412         while (bytes < bootsize)
 413                 bytes += read(bootfd, boot + bytes, bootsize - bytes);
 414         close(bootfd);
 415
 416         r = gctl_get_handle();
 417         gctl_ro_param(r, "class", -1, "PART");
 418         gctl_ro_param(r, "arg0", -1, gp->lg_name);
 419         gctl_ro_param(r, "verb", -1, "bootcode");
 420         gctl_ro_param(r, "bootcode", bootsize, boot);
 421
 422         errstr = gctl_issue(r);
 423         if (errstr != NULL && errstr[0] != '\0')
 424                 gpart_show_error("Bootcode Error", NULL, errstr);
 425         gctl_free(r);
 426         free(boot);
 427 }
 428
 429 static void
 430 gpart_partcode(struct gprovider *pp, const char *fstype)
 431 {
 432         struct gconfig *gc;
 433         const char *scheme;
 434         const char *indexstr;
 435         char message[255], command[255];
 436
 437         LIST_FOREACH(gc, &pp->lg_geom->lg_config, lg_config) {
 438                 if (strcmp(gc->lg_name, "scheme") == 0) {
 439                         scheme = gc->lg_val;
 440                         break;
 441                 }
 442         }
 443
 444         /* Make sure this partition scheme needs partcode on this platform */
 445         if (partcode_path(scheme, fstype) == NULL)
 446                 return;
 447
 448         LIST_FOREACH(gc, &pp->lg_config, lg_config) {
 449                 if (strcmp(gc->lg_name, "index") == 0) {
 450                         indexstr = gc->lg_val;
 451                         break;
 452                 }
 453         }
 454
 455         /* Shell out to gpart for partcode for now */
 456         sprintf(command, "gpart bootcode -p %s -i %s %s",
 457             partcode_path(scheme, fstype), indexstr, pp->lg_geom->lg_name);
 458         if (system(command) != 0) {
 459                 sprintf(message, "Error installing partcode on partition %s",
 460                     pp->lg_name);
 461                 dialog_msgbox("Error", message, 0, 0, TRUE);
 462         }
 463 }
 464
 465 void
 466 gpart_destroy(struct ggeom *lg_geom)
 467 {
 468         struct gctl_req *r;
 469         struct gprovider *pp;
 470         const char *errstr;
 471         int force = 1;
 472
 473         /* Delete all child metadata */
 474         LIST_FOREACH(pp, &lg_geom->lg_provider, lg_provider)
 475                 gpart_delete(pp);
 476
 477         /* Revert any local changes to get this geom into a pristine state */
 478         r = gctl_get_handle();
 479         gctl_ro_param(r, "class", -1, "PART");
 480         gctl_ro_param(r, "arg0", -1, lg_geom->lg_name);
 481         gctl_ro_param(r, "verb", -1, "undo");
 482         gctl_issue(r); /* Ignore errors -- these are non-fatal */
 483         gctl_free(r);
 484
 485         /* Now destroy the geom itself */
 486         r = gctl_get_handle();
 487         gctl_ro_param(r, "class", -1, "PART");
 488         gctl_ro_param(r, "arg0", -1, lg_geom->lg_name);
 489         gctl_ro_param(r, "flags", -1, GPART_FLAGS);
 490         gctl_ro_param(r, "force", sizeof(force), &force);
 491         gctl_ro_param(r, "verb", -1, "destroy");
 492         errstr = gctl_issue(r);
 493         if (errstr != NULL && errstr[0] != '\0') {
 494                 /*
 495                  * Check if we reverted away the existence of the geom
 496                  * altogether. Show all other errors to the user.
 497                  */
 498                 if (strtol(errstr, NULL, 0) != EINVAL)
 499                         gpart_show_error("Error", NULL, errstr);
 500         }
 501         gctl_free(r);
 502
 503         /* And any metadata associated with the partition scheme itself */
 504         delete_part_metadata(lg_geom->lg_name);
 505 }
 506
 507 void
 508 gpart_edit(struct gprovider *pp)
 509 {
 510         struct gctl_req *r;
 511         struct gconfig *gc;
 512         struct gconsumer *cp;
 513         struct ggeom *geom;
 514         const char *errstr, *oldtype, *scheme;
 515         struct partition_metadata *md;
 516         char sizestr[32];
 517         char newfs[255];
 518         intmax_t idx;
 519         int hadlabel, choice, junk, nitems;
 520         unsigned i;
 521
 522         DIALOG_FORMITEM items[] = {
 523                 {0, "Type:", 5, 0, 0, FALSE, "", 11, 0, 12, 15, 0,
 524                     FALSE, "Filesystem type (e.g. freebsd-ufs, freebsd-zfs, "
 525                     "freebsd-swap)", FALSE},
 526                 {0, "Size:", 5, 1, 0, FALSE, "", 11, 1, 12, 0, 0,
 527                     FALSE, "Partition size. Append K, M, G for kilobytes, "
 528                     "megabytes or gigabytes.", FALSE},
 529                 {0, "Mountpoint:", 11, 2, 0, FALSE, "", 11, 2, 12, 15, 0,
 530                     FALSE, "Path at which to mount this partition (leave blank "
 531                     "for swap, set to / for root filesystem)", FALSE},
 532                 {0, "Label:", 7, 3, 0, FALSE, "", 11, 3, 12, 15, 0, FALSE,
 533                     "Partition name. Not all partition schemes support this.",
 534                     FALSE},
 535         };
 536
 537         /*
 538          * Find the PART geom we are manipulating. This may be a consumer of
 539          * this provider, or its parent. Check the consumer case first.
 540          */
 541         geom = NULL;
 542         LIST_FOREACH(cp, &pp->lg_consumers, lg_consumers)
 543                 if (strcmp(cp->lg_geom->lg_class->lg_name, "PART") == 0) {
 544                         /* Check for zombie geoms, treating them as blank */
 545                         scheme = NULL;
 546                         LIST_FOREACH(gc, &cp->lg_geom->lg_config, lg_config) {
 547                                 if (strcmp(gc->lg_name, "scheme") == 0) {
 548                                         scheme = gc->lg_val;
 549                                         break;
 550                                 }
 551                         }
 552                         if (scheme == NULL || strcmp(scheme, "(none)") == 0) {
 553                                 gpart_partition(cp->lg_geom->lg_name, NULL);
 554                                 return;
 555                         }
 556
 557                         /* If this is a nested partition, edit as usual */
 558                         if (strcmp(pp->lg_geom->lg_class->lg_name, "PART") == 0)
 559                                 break;
 560
 561                         /* Destroy the geom and all sub-partitions */
 562                         gpart_destroy(cp->lg_geom);
 563
 564                         /* Now re-partition and return */
 565                         gpart_partition(cp->lg_geom->lg_name, NULL);
 566                         return;
 567                 }
 568
 569         if (geom == NULL && strcmp(pp->lg_geom->lg_class->lg_name, "PART") == 0)
 570                 geom = pp->lg_geom;
 571
 572         if (geom == NULL) {
 573                 /* Disk not partitioned, so partition it */
 574                 gpart_partition(pp->lg_name, NULL);
 575                 return;
 576         }
 577
 578         LIST_FOREACH(gc, &geom->lg_config, lg_config) {
 579                 if (strcmp(gc->lg_name, "scheme") == 0) {
 580                         scheme = gc->lg_val;
 581                         break;
 582                 }
 583         }
 584
 585         nitems = scheme_supports_labels(scheme) ? 4 : 3;
 586
 587         /* Edit editable parameters of a partition */
 588         hadlabel = 0;
 589         LIST_FOREACH(gc, &pp->lg_config, lg_config) {
 590                 if (strcmp(gc->lg_name, "type") == 0) {
 591                         oldtype = gc->lg_val;
 592                         items[0].text = gc->lg_val;
 593                 }
 594                 if (strcmp(gc->lg_name, "label") == 0 && gc->lg_val != NULL) {
 595                         hadlabel = 1;
 596                         items[3].text = gc->lg_val;
 597                 }
 598                 if (strcmp(gc->lg_name, "index") == 0)
 599                         idx = atoi(gc->lg_val);
 600         }
 601
 602         TAILQ_FOREACH(md, &part_metadata, metadata) {
 603                 if (md->name != NULL && strcmp(md->name, pp->lg_name) == 0) {
 604                         if (md->fstab != NULL)
 605                                 items[2].text = md->fstab->fs_file;
 606                         break;
 607                 }
 608         }
 609
 610         humanize_number(sizestr, 7, pp->lg_mediasize, "B", HN_AUTOSCALE,
 611             HN_NOSPACE | HN_DECIMAL);
 612         items[1].text = sizestr;
 613
 614 editpart:
 615         choice = dlg_form("Edit Partition", "", 0, 0, 0, nitems, items, &junk);
 616
 617         if (choice) /* Cancel pressed */
 618                 goto endedit;
 619
 620         /* Check if the label has a / in it */
 621         if (strchr(items[3].text, '/') != NULL) {
 622                 dialog_msgbox("Error", "Label contains a /, which is not an "
 623                     "allowed character.", 0, 0, TRUE);
 624                 goto editpart;
 625         }
 626
 627         r = gctl_get_handle();
 628         gctl_ro_param(r, "class", -1, "PART");
 629         gctl_ro_param(r, "arg0", -1, geom->lg_name);
 630         gctl_ro_param(r, "flags", -1, GPART_FLAGS);
 631         gctl_ro_param(r, "verb", -1, "modify");
 632         gctl_ro_param(r, "index", sizeof(idx), &idx);
 633         if (hadlabel || items[3].text[0] != '\0')
 634                 gctl_ro_param(r, "label", -1, items[3].text);
 635         gctl_ro_param(r, "type", -1, items[0].text);
 636         errstr = gctl_issue(r);
 637         if (errstr != NULL && errstr[0] != '\0') {
 638                 gpart_show_error("Error", NULL, errstr);
 639                 gctl_free(r);
 640                 goto editpart;
 641         }
 642         gctl_free(r);
 643
 644         newfs_command(items[0].text, newfs, 1);
 645         set_default_part_metadata(pp->lg_name, scheme, items[0].text,
 646             items[2].text, (strcmp(oldtype, items[0].text) != 0) ?
 647             newfs : NULL);
 648
 649 endedit:
 650         if (strcmp(oldtype, items[0].text) != 0 && cp != NULL)
 651                 gpart_destroy(cp->lg_geom);
 652         if (strcmp(oldtype, items[0].text) != 0 && strcmp(items[0].text,
 653             "freebsd") == 0)
 654                 gpart_partition(pp->lg_name, "BSD");
 655
 656         for (i = 0; i < (sizeof(items) / sizeof(items[0])); i++)
 657                 if (items[i].text_free)
 658                         free(items[i].text);
 659 }
 660
 661 void
 662 set_default_part_metadata(const char *name, const char *scheme,
 663     const char *type, const char *mountpoint, const char *newfs)
 664 {
 665         struct partition_metadata *md;
 666         char *zpool_name = NULL;
 667         int i;
 668
 669         /* Set part metadata */
 670         md = get_part_metadata(name, 1);
 671
 672         if (newfs) {
 673                 if (md->newfs != NULL) {
 674                         free(md->newfs);
 675                         md->newfs = NULL;
 676                 }
 677
 678                 if (newfs != NULL && newfs[0] != '\0') {
 679                         md->newfs = malloc(strlen(newfs) + strlen(" /dev/") +
 680                             strlen(mountpoint) + 5 + strlen(name) + 1);
 681                         if (strcmp("freebsd-zfs", type) == 0) {
 682                                 zpool_name = strdup((strlen(mountpoint) == 1) ?
 683                                     "root" : &mountpoint[1]);
 684                                 for (i = 0; zpool_name[i] != 0; i++)
 685                                         if (!isalnum(zpool_name[i]))
 686                                                 zpool_name[i] = '_';
 687                                 sprintf(md->newfs, "%s %s /dev/%s", newfs,
 688                                     zpool_name, name);
 689                         } else {
 690                                 sprintf(md->newfs, "%s /dev/%s", newfs, name);
 691                         }
 692                 }
 693         }
 694
 695         if (strcmp(type, "freebsd-swap") == 0)
 696                 mountpoint = "none";
 697         if (strcmp(type, bootpart_type(scheme)) == 0)
 698                 md->bootcode = 1;
 699
 700         /* VTOC8 needs partcode at the start of partitions */
 701         if (strcmp(scheme, "VTOC8") == 0 && (strcmp(type, "freebsd-ufs") == 0
 702             || strcmp(type, "freebsd-zfs") == 0))
 703                 md->bootcode = 1;
 704
 705         if (mountpoint == NULL || mountpoint[0] == '\0') {
 706                 if (md->fstab != NULL) {
 707                         free(md->fstab->fs_spec);
 708                         free(md->fstab->fs_file);
 709                         free(md->fstab->fs_vfstype);
 710                         free(md->fstab->fs_mntops);
 711                         free(md->fstab->fs_type);
 712                         free(md->fstab);
 713                         md->fstab = NULL;
 714                 }
 715         } else {
 716                 if (md->fstab == NULL) {
 717                         md->fstab = malloc(sizeof(struct fstab));
 718                 } else {
 719                         free(md->fstab->fs_spec);
 720                         free(md->fstab->fs_file);
 721                         free(md->fstab->fs_vfstype);
 722                         free(md->fstab->fs_mntops);
 723                         free(md->fstab->fs_type);
 724                 }
 725                 if (strcmp("freebsd-zfs", type) == 0) {
 726                         md->fstab->fs_spec = strdup(zpool_name);
 727                 } else {
 728                         md->fstab->fs_spec = malloc(strlen(name) +
 729                             strlen("/dev/") + 1);
 730                         sprintf(md->fstab->fs_spec, "/dev/%s", name);
 731                 }
 732                 md->fstab->fs_file = strdup(mountpoint);
 733                 /* Get VFS from text after freebsd-, if possible */
 734                 if (strncmp("freebsd-", type, 8) == 0)
 735                         md->fstab->fs_vfstype = strdup(&type[8]);
 736                 else if (strcmp("fat32", type) == 0 || strcmp("efi", type) == 0)
 737                         md->fstab->fs_vfstype = strdup("msdosfs");
 738                 else
 739                         md->fstab->fs_vfstype = strdup(type); /* Guess */
 740                 if (strcmp(type, "freebsd-swap") == 0) {
 741                         md->fstab->fs_type = strdup(FSTAB_SW);
 742                         md->fstab->fs_freq = 0;
 743                         md->fstab->fs_passno = 0;
 744                 } else if (strcmp(type, "freebsd-zfs") == 0) {
 745                         md->fstab->fs_type = strdup(FSTAB_RW);
 746                         md->fstab->fs_freq = 0;
 747                         md->fstab->fs_passno = 0;
 748                 } else {
 749                         md->fstab->fs_type = strdup(FSTAB_RW);
 750                         if (strcmp(mountpoint, "/") == 0) {
 751                                 md->fstab->fs_freq = 1;
 752                                 md->fstab->fs_passno = 1;
 753                         } else {
 754                                 md->fstab->fs_freq = 2;
 755                                 md->fstab->fs_passno = 2;
 756                         }
 757                 }
 758                 md->fstab->fs_mntops = strdup(md->fstab->fs_type);
 759         }
 760
 761         if (zpool_name != NULL)
 762                 free(zpool_name);
 763 }
 764
 765 static
 766 int part_compare(const void *xa, const void *xb)
 767 {
 768         struct gprovider **a = (struct gprovider **)xa;
 769         struct gprovider **b = (struct gprovider **)xb;
 770         intmax_t astart, bstart;
 771         struct gconfig *gc;
 772
 773         astart = bstart = 0;
 774         LIST_FOREACH(gc, &(*a)->lg_config, lg_config)
 775                 if (strcmp(gc->lg_name, "start") == 0) {
 776                         astart = strtoimax(gc->lg_val, NULL, 0);
 777                         break;
 778                 }
 779         LIST_FOREACH(gc, &(*b)->lg_config, lg_config)
 780                 if (strcmp(gc->lg_name, "start") == 0) {
 781                         bstart = strtoimax(gc->lg_val, NULL, 0);
 782                         break;
 783                 }
 784
 785         if (astart < bstart)
 786                 return -1;
 787         else if (astart > bstart)
 788                 return 1;
 789         else
 790                 return 0;
 791 }
 792
 793 intmax_t
 794 gpart_max_free(struct ggeom *geom, intmax_t *npartstart)
 795 {
 796         struct gconfig *gc;
 797         struct gprovider *pp, **providers;
 798         intmax_t sectorsize, stripesize, offset;
 799         intmax_t lastend;
 800         intmax_t start, end;
 801         intmax_t maxsize, maxstart;
 802         intmax_t partstart, partend;
 803         int i, nparts;
 804
 805         /* Now get the maximum free size and free start */
 806         start = end = 0;
 807         LIST_FOREACH(gc, &geom->lg_config, lg_config) {
 808                 if (strcmp(gc->lg_name, "first") == 0)
 809                         start = strtoimax(gc->lg_val, NULL, 0);
 810                 if (strcmp(gc->lg_name, "last") == 0)
 811                         end = strtoimax(gc->lg_val, NULL, 0);
 812         }
 813
 814         i = nparts = 0;
 815         LIST_FOREACH(pp, &geom->lg_provider, lg_provider)
 816                 nparts++;
 817         providers = calloc(nparts, sizeof(providers[0]));
 818         LIST_FOREACH(pp, &geom->lg_provider, lg_provider)
 819                 providers[i++] = pp;
 820         qsort(providers, nparts, sizeof(providers[0]), part_compare);
 821
 822         lastend = start - 1;
 823         maxsize = 0;
 824         for (i = 0; i < nparts; i++) {
 825                 pp = providers[i];
 826
 827                 LIST_FOREACH(gc, &pp->lg_config, lg_config) {
 828                         if (strcmp(gc->lg_name, "start") == 0)
 829                                 partstart = strtoimax(gc->lg_val, NULL, 0);
 830                         if (strcmp(gc->lg_name, "end") == 0)
 831                                 partend = strtoimax(gc->lg_val, NULL, 0);
 832                 }
 833
 834                 if (partstart - lastend > maxsize) {
 835                         maxsize = partstart - lastend - 1;
 836                         maxstart = lastend + 1;
 837                 }
 838
 839                 lastend = partend;
 840         }
 841
 842         if (end - lastend > maxsize) {
 843                 maxsize = end - lastend - 1;
 844                 maxstart = lastend + 1;
 845         }
 846
 847         pp = LIST_FIRST(&geom->lg_consumer)->lg_provider;
 848
 849         /*
 850          * Round the start and size of the largest available space up to
 851          * the nearest multiple of the adjusted stripe size.
 852          *
 853          * The adjusted stripe size is the least common multiple of the
 854          * actual stripe size, or the sector size if no stripe size was
 855          * reported, and 4096.  The reason for this is that contemporary
 856          * disks often have 4096-byte physical sectors but report 512
 857          * bytes instead for compatibility with older / broken operating
 858          * systems and BIOSes.  For the same reasons, virtualized storage
 859          * may also report a 512-byte stripe size, or none at all.
 860          */
 861         sectorsize = pp->lg_sectorsize;
 862         if ((stripesize = pp->lg_stripesize) == 0)
 863                 stripesize = sectorsize;
 864         while (stripesize % 4096 != 0)
 865                 stripesize *= 2;
 866         if ((offset = maxstart * sectorsize % stripesize) != 0) {
 867                 offset = (stripesize - offset) / sectorsize;
 868                 maxstart += offset;
 869                 maxsize -= offset;
 870         }
 871
 872         if (npartstart != NULL)
 873                 *npartstart = maxstart;
 874
 875         return (maxsize);
 876 }
 877
 878 void
 879 gpart_create(struct gprovider *pp, char *default_type, char *default_size,
 880      char *default_mountpoint, char **partname, int interactive)
 881 {
 882         struct gctl_req *r;
 883         struct gconfig *gc;
 884         struct gconsumer *cp;
 885         struct ggeom *geom;
 886         const char *errstr, *scheme;
 887         char sizestr[32], startstr[32], output[64], *newpartname;
 888         char newfs[255], options_fstype[64];
 889         intmax_t maxsize, size, sector, firstfree, stripe;
 890         uint64_t bytes;
 891         int nitems, choice, junk;
 892         unsigned i;
 893
 894         DIALOG_FORMITEM items[] = {
 895                 {0, "Type:", 5, 0, 0, FALSE, "freebsd-ufs", 11, 0, 12, 15, 0,
 896                     FALSE, "Filesystem type (e.g. freebsd-ufs, freebsd-zfs, "
 897                     "freebsd-swap)", FALSE},
 898                 {0, "Size:", 5, 1, 0, FALSE, "", 11, 1, 12, 15, 0,
 899                     FALSE, "Partition size. Append K, M, G for kilobytes, "
 900                     "megabytes or gigabytes.", FALSE},
 901                 {0, "Mountpoint:", 11, 2, 0, FALSE, "", 11, 2, 12, 15, 0,
 902                     FALSE, "Path at which to mount partition (blank for "
 903                     "swap, / for root filesystem)", FALSE},
 904                 {0, "Label:", 7, 3, 0, FALSE, "", 11, 3, 12, 15, 0, FALSE,
 905                     "Partition name. Not all partition schemes support this.",
 906                     FALSE},
 907         };
 908
 909         if (partname != NULL)
 910                 *partname = NULL;
 911
 912         /* Record sector and stripe sizes */
 913         sector = pp->lg_sectorsize;
 914         stripe = pp->lg_stripesize;
 915
 916         /*
 917          * Find the PART geom we are manipulating. This may be a consumer of
 918          * this provider, or its parent. Check the consumer case first.
 919          */
 920         geom = NULL;
 921         LIST_FOREACH(cp, &pp->lg_consumers, lg_consumers)
 922                 if (strcmp(cp->lg_geom->lg_class->lg_name, "PART") == 0) {
 923                         geom = cp->lg_geom;
 924                         break;
 925                 }
 926
 927         if (geom == NULL && strcmp(pp->lg_geom->lg_class->lg_name, "PART") == 0)
 928                 geom = pp->lg_geom;
 929
 930         /* Now get the partition scheme */
 931         scheme = NULL;
 932         if (geom != NULL) {
 933                 LIST_FOREACH(gc, &geom->lg_config, lg_config)
 934                         if (strcmp(gc->lg_name, "scheme") == 0)
 935                                 scheme = gc->lg_val;
 936         }
 937
 938         if (geom == NULL || scheme == NULL || strcmp(scheme, "(none)") == 0) {
 939                 if (gpart_partition(pp->lg_name, NULL) == 0)
 940                         dialog_msgbox("",
 941                             "The partition table has been successfully created."
 942                             " Please press Create again to create partitions.",
 943                             0, 0, TRUE);
 944
 945                 return;
 946         }
 947
 948         /*
 949          * If we still don't have a geom, either the user has
 950          * canceled partitioning or there has been an error which has already
 951          * been displayed, so bail.
 952          */
 953         if (geom == NULL)
 954                 return;
 955
 956         maxsize = size = gpart_max_free(geom, &firstfree);
 957         if (size <= 0) {
 958                 dialog_msgbox("Error", "No free space left on device.", 0, 0,
 959                     TRUE);
 960                 return;
 961         }
 962
 963         humanize_number(sizestr, 7, size*sector, "B", HN_AUTOSCALE,
 964             HN_NOSPACE | HN_DECIMAL);
 965         items[1].text = sizestr;
 966
 967         /* Special-case the MBR default type for nested partitions */
 968         if (strcmp(scheme, "MBR") == 0 || strcmp(scheme, "PC98") == 0) {
 969                 items[0].text = "freebsd";
 970                 items[0].help = "Filesystem type (e.g. freebsd, fat32)";
 971         }
 972
 973         nitems = scheme_supports_labels(scheme) ? 4 : 3;
 974
 975         if (default_type != NULL)
 976                 items[0].text = default_type;
 977         if (default_size != NULL)
 978                 items[1].text = default_size;
 979         if (default_mountpoint != NULL)
 980                 items[2].text = default_mountpoint;
 981
 982         /* Default options */
 983         strncpy(options_fstype, items[0].text,
 984             sizeof(options_fstype));
 985         newfs_command(options_fstype, newfs, 1);
 986 addpartform:
 987         if (interactive) {
 988                 dialog_vars.extra_label = "Options";
 989                 dialog_vars.extra_button = TRUE;
 990                 choice = dlg_form("Add Partition", "", 0, 0, 0, nitems,
 991                     items, &junk);
 992                 dialog_vars.extra_button = FALSE;
 993                 switch (choice) {
 994                 case 0: /* OK */
 995                         break;
 996                 case 1: /* Cancel */
 997                         return;
 998                 case 3: /* Options */
 999                         strncpy(options_fstype, items[0].text,
1000                             sizeof(options_fstype));
1001                         newfs_command(options_fstype, newfs, 0);
1002                         goto addpartform;
1003                 }
1004         }
1005
1006         /*
1007          * If the user changed the fs type after specifying options, undo
1008          * their choices in favor of the new filesystem's defaults.
1009          */
1010         if (strcmp(options_fstype, items[0].text) != 0) {
1011                 strncpy(options_fstype, items[0].text, sizeof(options_fstype));
1012                 newfs_command(options_fstype, newfs, 1);
1013         }
1014
1015         size = maxsize;
1016         if (strlen(items[1].text) > 0) {
1017                 if (expand_number(items[1].text, &bytes) != 0) {
1018                         char error[512];
1019
1020                         sprintf(error, "Invalid size: %s\n", strerror(errno));
1021                         dialog_msgbox("Error", error, 0, 0, TRUE);
1022                         goto addpartform;
1023                 }
1024                 size = MIN((intmax_t)(bytes/sector), maxsize);
1025         }
1026
1027         /* Check if the label has a / in it */
1028         if (strchr(items[3].text, '/') != NULL) {
1029                 dialog_msgbox("Error", "Label contains a /, which is not an "
1030                     "allowed character.", 0, 0, TRUE);
1031                 goto addpartform;
1032         }
1033
1034         /* Warn if no mountpoint set */
1035         if (strcmp(items[0].text, "freebsd-ufs") == 0 &&
1036             items[2].text[0] != '/') {
1037                 choice = 0;
1038                 if (interactive) {
1039                         dialog_vars.defaultno = TRUE;
1040                         choice = dialog_yesno("Warning",
1041                             "This partition does not have a valid mountpoint "
1042                             "(for the partition from which you intend to boot the "
1043                             "operating system, the mountpoint should be /). Are you "
1044                             "sure you want to continue?"
1045                         , 0, 0);
1046                         dialog_vars.defaultno = FALSE;
1047                 }
1048                 if (choice == 1) /* cancel */
1049                         goto addpartform;
1050         }
1051
1052         /*
1053          * Error if this scheme needs nested partitions, this is one, and
1054          * a mountpoint was set.
1055          */
1056         if (strcmp(items[0].text, "freebsd") == 0 &&
1057             strlen(items[2].text) > 0) {
1058                 dialog_msgbox("Error", "Partitions of type \"freebsd\" are "
1059                     "nested BSD-type partition schemes and cannot have "
1060                     "mountpoints. After creating one, select it and press "
1061                     "Create again to add the actual file systems.", 0, 0, TRUE);
1062                 goto addpartform;
1063         }
1064
1065         /* If this is the root partition, check that this scheme is bootable */
1066         if (strcmp(items[2].text, "/") == 0 && !is_scheme_bootable(scheme)) {
1067                 char message[512];
1068                 sprintf(message, "This partition scheme (%s) is not bootable "
1069                     "on this platform. Are you sure you want to proceed?",
1070                     scheme);
1071                 dialog_vars.defaultno = TRUE;
1072                 choice = dialog_yesno("Warning", message, 0, 0);
1073                 dialog_vars.defaultno = FALSE;
1074                 if (choice == 1) /* cancel */
1075                         goto addpartform;
1076         }
1077
1078         /* If this is the root partition, check that this fs is bootable */
1079         if (strcmp(items[2].text, "/") == 0 && !is_fs_bootable(scheme,
1080             items[0].text)) {
1081                 char message[512];
1082                 sprintf(message, "This file system (%s) is not bootable "
1083                     "on this system. Are you sure you want to proceed?",
1084                     items[0].text);
1085                 dialog_vars.defaultno = TRUE;
1086                 choice = dialog_yesno("Warning", message, 0, 0);
1087                 dialog_vars.defaultno = FALSE;
1088                 if (choice == 1) /* cancel */
1089                         goto addpartform;
1090         }
1091
1092         /*
1093          * If this is the root partition, and we need a boot partition, ask
1094          * the user to add one.
1095          */
1096
1097         /* Check for existing freebsd-boot partition */
1098         LIST_FOREACH(pp, &geom->lg_provider, lg_provider) {
1099                 struct partition_metadata *md;
1100                 md = get_part_metadata(pp->lg_name, 0);
1101                 if (md == NULL || !md->bootcode)
1102                         continue;
1103                 LIST_FOREACH(gc, &pp->lg_config, lg_config)
1104                         if (strcmp(gc->lg_name, "type") == 0)
1105                                 break;
1106                 if (gc != NULL && strcmp(gc->lg_val,
1107                     bootpart_type(scheme)) == 0)
1108                         break;
1109         }
1110
1111         /* If there isn't one, and we need one, ask */
1112         if ((strcmp(items[0].text, "freebsd") == 0 ||
1113             strcmp(items[2].text, "/") == 0) && bootpart_size(scheme) > 0 &&
1114             pp == NULL) {
1115                 if (interactive)
1116                         choice = dialog_yesno("Boot Partition",
1117                             "This partition scheme requires a boot partition "
1118                             "for the disk to be bootable. Would you like to "
1119                             "make one now?", 0, 0);
1120                 else
1121                         choice = 0;
1122
1123                 if (choice == 0) { /* yes */
1124                         r = gctl_get_handle();
1125                         gctl_ro_param(r, "class", -1, "PART");
1126                         gctl_ro_param(r, "arg0", -1, geom->lg_name);
1127                         gctl_ro_param(r, "flags", -1, GPART_FLAGS);
1128                         gctl_ro_param(r, "verb", -1, "add");
1129                         gctl_ro_param(r, "type", -1, bootpart_type(scheme));
1130                         snprintf(sizestr, sizeof(sizestr), "%jd",
1131                             bootpart_size(scheme) / sector);
1132                         gctl_ro_param(r, "size", -1, sizestr);
1133                         snprintf(startstr, sizeof(startstr), "%jd", firstfree);
1134                         gctl_ro_param(r, "start", -1, startstr);
1135                         gctl_rw_param(r, "output", sizeof(output), output);
1136                         errstr = gctl_issue(r);
1137                         if (errstr != NULL && errstr[0] != '\0')
1138                                 gpart_show_error("Error", NULL, errstr);
1139                         gctl_free(r);
1140
1141                         get_part_metadata(strtok(output, " "), 1)->bootcode = 1;
1142
1143                         /* Now adjust the part we are really adding forward */
1144                         firstfree += bootpart_size(scheme) / sector;
1145                         size -= (bootpart_size(scheme) + stripe)/sector;
1146                         if (stripe > 0 && (firstfree*sector % stripe) != 0)
1147                                 firstfree += (stripe - ((firstfree*sector) %
1148                                     stripe)) / sector;
1149                 }
1150         }
1151
1152         r = gctl_get_handle();
1153         gctl_ro_param(r, "class", -1, "PART");
1154         gctl_ro_param(r, "arg0", -1, geom->lg_name);
1155         gctl_ro_param(r, "flags", -1, GPART_FLAGS);
1156         gctl_ro_param(r, "verb", -1, "add");
1157
1158         gctl_ro_param(r, "type", -1, items[0].text);
1159         snprintf(sizestr, sizeof(sizestr), "%jd", size);
1160         gctl_ro_param(r, "size", -1, sizestr);
1161         snprintf(startstr, sizeof(startstr), "%jd", firstfree);
1162         gctl_ro_param(r, "start", -1, startstr);
1163         if (items[3].text[0] != '\0')
1164                 gctl_ro_param(r, "label", -1, items[3].text);
1165         gctl_rw_param(r, "output", sizeof(output), output);
1166         errstr = gctl_issue(r);
1167         if (errstr != NULL && errstr[0] != '\0') {
1168                 gpart_show_error("Error", NULL, errstr);
1169                 gctl_free(r);
1170                 goto addpartform;
1171         }
1172         newpartname = strtok(output, " ");
1173         gctl_free(r);
1174
1175         /*
1176          * Try to destroy any geom that gpart picked up already here from
1177          * dirty blocks.
1178          */
1179         r = gctl_get_handle();
1180         gctl_ro_param(r, "class", -1, "PART");
1181         gctl_ro_param(r, "arg0", -1, newpartname);
1182         gctl_ro_param(r, "flags", -1, GPART_FLAGS);
1183         junk = 1;
1184         gctl_ro_param(r, "force", sizeof(junk), &junk);
1185         gctl_ro_param(r, "verb", -1, "destroy");
1186         gctl_issue(r); /* Error usually expected and non-fatal */
1187         gctl_free(r);
1188
1189         if (strcmp(items[0].text, bootpart_type(scheme)) == 0)
1190                 get_part_metadata(newpartname, 1)->bootcode = 1;
1191         else if (strcmp(items[0].text, "freebsd") == 0)
1192                 gpart_partition(newpartname, "BSD");
1193         else
1194                 set_default_part_metadata(newpartname, scheme,
1195                     items[0].text, items[2].text, newfs);
1196
1197         for (i = 0; i < (sizeof(items) / sizeof(items[0])); i++)
1198                 if (items[i].text_free)
1199                         free(items[i].text);
1200
1201         if (partname != NULL)
1202                 *partname = strdup(newpartname);
1203 }
1204
1205 void
1206 gpart_delete(struct gprovider *pp)
1207 {
1208         struct gconfig *gc;
1209         struct ggeom *geom;
1210         struct gconsumer *cp;
1211         struct gctl_req *r;
1212         const char *errstr;
1213         intmax_t idx;
1214         int is_partition;
1215
1216         /* Is it a partition? */
1217         is_partition = (strcmp(pp->lg_geom->lg_class->lg_name, "PART") == 0);
1218
1219         /* Find out if this is the root of a gpart geom */
1220         geom = NULL;
1221         LIST_FOREACH(cp, &pp->lg_consumers, lg_consumers)
1222                 if (strcmp(cp->lg_geom->lg_class->lg_name, "PART") == 0) {
1223                         geom = cp->lg_geom;
1224                         break;
1225                 }
1226
1227         /* If so, destroy all children */
1228         if (geom != NULL) {
1229                 gpart_destroy(geom);
1230
1231                 /* If this is a partition, revert it, so it can be deleted */
1232                 if (is_partition) {
1233                         r = gctl_get_handle();
1234                         gctl_ro_param(r, "class", -1, "PART");
1235                         gctl_ro_param(r, "arg0", -1, geom->lg_name);
1236                         gctl_ro_param(r, "verb", -1, "undo");
1237                         gctl_issue(r); /* Ignore non-fatal errors */
1238                         gctl_free(r);
1239                 }
1240         }
1241
1242         /*
1243          * If this is not a partition, see if that is a problem, complain if
1244          * necessary, and return always, since we need not do anything further,
1245          * error or no.
1246          */
1247         if (!is_partition) {
1248                 if (geom == NULL)
1249                         dialog_msgbox("Error",
1250                             "Only partitions can be deleted.", 0, 0, TRUE);
1251                 return;
1252         }
1253
1254         r = gctl_get_handle();
1255         gctl_ro_param(r, "class", -1, pp->lg_geom->lg_class->lg_name);
1256         gctl_ro_param(r, "arg0", -1, pp->lg_geom->lg_name);
1257         gctl_ro_param(r, "flags", -1, GPART_FLAGS);
1258         gctl_ro_param(r, "verb", -1, "delete");
1259
1260         LIST_FOREACH(gc, &pp->lg_config, lg_config) {
1261                 if (strcmp(gc->lg_name, "index") == 0) {
1262                         idx = atoi(gc->lg_val);
1263                         gctl_ro_param(r, "index", sizeof(idx), &idx);
1264                         break;
1265                 }
1266         }
1267
1268         errstr = gctl_issue(r);
1269         if (errstr != NULL && errstr[0] != '\0') {
1270                 gpart_show_error("Error", NULL, errstr);
1271                 gctl_free(r);
1272                 return;
1273         }
1274
1275         gctl_free(r);
1276
1277         delete_part_metadata(pp->lg_name);
1278 }
1279
1280 void
1281 gpart_revert_all(struct gmesh *mesh)
1282 {
1283         struct gclass *classp;
1284         struct gconfig *gc;
1285         struct ggeom *gp;
1286         struct gctl_req *r;
1287         const char *modified;
1288
1289         LIST_FOREACH(classp, &mesh->lg_class, lg_class) {
1290                 if (strcmp(classp->lg_name, "PART") == 0)
1291                         break;
1292         }
1293
1294         if (strcmp(classp->lg_name, "PART") != 0) {
1295                 dialog_msgbox("Error", "gpart not found!", 0, 0, TRUE);
1296                 return;
1297         }
1298
1299         LIST_FOREACH(gp, &classp->lg_geom, lg_geom) {
1300                 modified = "true"; /* XXX: If we don't know (kernel too old),
1301                                     * assume there are modifications. */
1302                 LIST_FOREACH(gc, &gp->lg_config, lg_config) {
1303                         if (strcmp(gc->lg_name, "modified") == 0) {
1304                                 modified = gc->lg_val;
1305                                 break;
1306                         }
1307                 }
1308
1309                 if (strcmp(modified, "false") == 0)
1310                         continue;
1311
1312                 r = gctl_get_handle();
1313                 gctl_ro_param(r, "class", -1, "PART");
1314                 gctl_ro_param(r, "arg0", -1, gp->lg_name);
1315                 gctl_ro_param(r, "verb", -1, "undo");
1316
1317                 gctl_issue(r);
1318                 gctl_free(r);
1319         }
1320 }
1321
1322 void
1323 gpart_commit(struct gmesh *mesh)
1324 {
1325         struct partition_metadata *md;
1326         struct gclass *classp;
1327         struct ggeom *gp;
1328         struct gconfig *gc;
1329         struct gconsumer *cp;
1330         struct gprovider *pp;
1331         struct gctl_req *r;
1332         const char *errstr;
1333         const char *modified;
1334         const char *rootfs;
1335
1336         LIST_FOREACH(classp, &mesh->lg_class, lg_class) {
1337                 if (strcmp(classp->lg_name, "PART") == 0)
1338                         break;
1339         }
1340
1341         /* Figure out what filesystem / uses */
1342         rootfs = "ufs"; /* Assume ufs if nothing else present */
1343         TAILQ_FOREACH(md, &part_metadata, metadata) {
1344                 if (md->fstab != NULL && strcmp(md->fstab->fs_file, "/") == 0) {
1345                         rootfs = md->fstab->fs_vfstype;
1346                         break;
1347                 }
1348         }
1349
1350         if (strcmp(classp->lg_name, "PART") != 0) {
1351                 dialog_msgbox("Error", "gpart not found!", 0, 0, TRUE);
1352                 return;
1353         }
1354
1355         LIST_FOREACH(gp, &classp->lg_geom, lg_geom) {
1356                 modified = "true"; /* XXX: If we don't know (kernel too old),
1357                                     * assume there are modifications. */
1358                 LIST_FOREACH(gc, &gp->lg_config, lg_config) {
1359                         if (strcmp(gc->lg_name, "modified") == 0) {
1360                                 modified = gc->lg_val;
1361                                 break;
1362                         }
1363                 }
1364
1365                 if (strcmp(modified, "false") == 0)
1366                         continue;
1367
1368                 /* Add bootcode if necessary, before the commit */
1369                 md = get_part_metadata(gp->lg_name, 0);
1370                 if (md != NULL && md->bootcode)
1371                         gpart_bootcode(gp);
1372
1373                 /* Now install partcode on its partitions, if necessary */
1374                 LIST_FOREACH(pp, &gp->lg_provider, lg_provider) {
1375                         md = get_part_metadata(pp->lg_name, 0);
1376                         if (md == NULL || !md->bootcode)
1377                                 continue;
1378
1379                         /* Mark this partition active if that's required */
1380                         gpart_activate(pp);
1381
1382                         /* Check if the partition has sub-partitions */
1383                         LIST_FOREACH(cp, &pp->lg_consumers, lg_consumers)
1384                                 if (strcmp(cp->lg_geom->lg_class->lg_name,
1385                                     "PART") == 0)
1386                                         break;
1387
1388                         if (cp == NULL) /* No sub-partitions */
1389                                 gpart_partcode(pp, rootfs);
1390                 }
1391
1392                 r = gctl_get_handle();
1393                 gctl_ro_param(r, "class", -1, "PART");
1394                 gctl_ro_param(r, "arg0", -1, gp->lg_name);
1395                 gctl_ro_param(r, "verb", -1, "commit");
1396
1397                 errstr = gctl_issue(r);
1398                 if (errstr != NULL && errstr[0] != '\0')
1399                         gpart_show_error("Error", NULL, errstr);
1400                 gctl_free(r);
1401         }
1402 }
1403