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: stable/10/usr.sbin/bsdinstall/partedit/gpart_ops.c 329870 2018-02-23 16:46:49Z rpokala $ 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 43static void 44gpart_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 69static int 70scheme_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 82static void 83newfs_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 209const char * 210choose_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 230parttypemenu: 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 257int 258gpart_partition(const char *lg_name, const char *scheme) 259{ 260 int cancel; 261 struct gctl_req *r; 262 const char *errstr; 263 264schememenu: 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 308static void 309gpart_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 355void 356gpart_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 375static void 376gpart_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 429static void 430gpart_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 465void 466gpart_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 507void 508gpart_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 614editpart: 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 649endedit: 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 661void 662set_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 765static 766int 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 793intmax_t 794gpart_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 878void 879gpart_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); 986addpartform: 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 1205void 1206gpart_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 1280void 1281gpart_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 1322void 1323gpart_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 1404