mirror of
https://github.com/freebsd/freebsd-src
synced 2024-09-06 17:18:32 +00:00
6e8bf24073
When generating a message for a dialog box into a static buffer, use snprintf instead of sprintf to avoid buffer overflows. Reviewed by: emaste Differential Revision: https://reviews.freebsd.org/D42240
1565 lines
42 KiB
C
1565 lines
42 KiB
C
/*-
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
|
*
|
|
* Copyright (c) 2011 Nathan Whitehorn
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*/
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/stat.h>
|
|
|
|
#include <bsddialog.h>
|
|
#include <ctype.h>
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <libutil.h>
|
|
#include <inttypes.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
|
|
#include <libgeom.h>
|
|
|
|
#include "partedit.h"
|
|
|
|
#define GPART_FLAGS "x" /* Do not commit changes by default */
|
|
|
|
static void
|
|
gpart_show_error(const char *title, const char *explanation, const char *errstr)
|
|
{
|
|
char *errmsg;
|
|
char message[512];
|
|
int error;
|
|
struct bsddialog_conf conf;
|
|
|
|
if (explanation == NULL)
|
|
explanation = "";
|
|
|
|
error = strtol(errstr, &errmsg, 0);
|
|
if (errmsg != errstr) {
|
|
while (errmsg[0] == ' ')
|
|
errmsg++;
|
|
if (errmsg[0] != '\0')
|
|
snprintf(message, sizeof(message), "%s%s. %s",
|
|
explanation, strerror(error), errmsg);
|
|
else
|
|
snprintf(message, sizeof(message), "%s%s", explanation,
|
|
strerror(error));
|
|
} else {
|
|
snprintf(message, sizeof(message), "%s%s", explanation, errmsg);
|
|
}
|
|
|
|
bsddialog_initconf(&conf);
|
|
conf.title = title;
|
|
bsddialog_msgbox(&conf, message, 0, 0);
|
|
}
|
|
|
|
static int
|
|
scheme_supports_labels(const char *scheme)
|
|
{
|
|
if (strcmp(scheme, "APM") == 0)
|
|
return (1);
|
|
if (strcmp(scheme, "GPT") == 0)
|
|
return (1);
|
|
|
|
return (0);
|
|
}
|
|
|
|
static char *
|
|
newfs_command(const char *fstype, int use_default)
|
|
{
|
|
struct bsddialog_conf conf;
|
|
FILE *fp;
|
|
char *buf;
|
|
size_t len;
|
|
|
|
bsddialog_initconf(&conf);
|
|
fp = open_memstream(&buf, &len);
|
|
|
|
if (strcmp(fstype, "freebsd-ufs") == 0) {
|
|
int i;
|
|
struct bsddialog_menuitem items[] = {
|
|
{"", false, 0, "UFS1", "UFS Version 1",
|
|
"Use version 1 of the UFS file system instead "
|
|
"of version 2 (not recommended)"},
|
|
{"", true, 0, "SU", "Softupdates",
|
|
"Enable softupdates (default)"},
|
|
{"", true, 0, "SUJ", "Softupdates journaling",
|
|
"Enable file system journaling (default - "
|
|
"turn off for SSDs)"},
|
|
{"", false, 0, "TRIM", "Enable SSD TRIM support",
|
|
"Enable TRIM support, useful on solid-state "
|
|
"drives" },
|
|
};
|
|
|
|
if (!use_default) {
|
|
int choice;
|
|
conf.title = "UFS Options";
|
|
choice = bsddialog_checklist(&conf, "", 0, 0, 0,
|
|
nitems(items), items, NULL);
|
|
if (choice == BSDDIALOG_CANCEL)
|
|
goto out;
|
|
}
|
|
|
|
fputs("newfs ", fp);
|
|
for (i = 0; i < (int)nitems(items); i++) {
|
|
if (items[i].on == false)
|
|
continue;
|
|
if (strcmp(items[i].name, "UFS1") == 0)
|
|
fputs("-O1 ", fp);
|
|
else if (strcmp(items[i].name, "SU") == 0)
|
|
fputs("-U ", fp);
|
|
else if (strcmp(items[i].name, "SUJ") == 0)
|
|
fputs("-j ", fp);
|
|
else if (strcmp(items[i].name, "TRIM") == 0)
|
|
fputs("-t ", fp);
|
|
}
|
|
} else if (strcmp(fstype, "freebsd-zfs") == 0) {
|
|
int i;
|
|
struct bsddialog_menuitem items[] = {
|
|
{"", 0, true, "fletcher4", "checksum algorithm: fletcher4",
|
|
"Use fletcher4 for data integrity checking. "
|
|
"(default)"},
|
|
{"", 0, false, "fletcher2", "checksum algorithm: fletcher2",
|
|
"Use fletcher2 for data integrity checking. "
|
|
"(not recommended)"},
|
|
{"", 0, false, "sha256", "checksum algorithm: sha256",
|
|
"Use sha256 for data integrity checking. "
|
|
"(not recommended)"},
|
|
{"", 0, false, "atime", "Update atimes for files",
|
|
"Disable atime update"},
|
|
};
|
|
|
|
if (!use_default) {
|
|
int choice;
|
|
conf.title = "ZFS Options";
|
|
choice = bsddialog_checklist(&conf, "", 0, 0, 0,
|
|
nitems(items), items, NULL);
|
|
if (choice == BSDDIALOG_CANCEL)
|
|
goto out;
|
|
}
|
|
|
|
fputs("zpool create -f -m none ", fp);
|
|
if (getenv("BSDINSTALL_TMPBOOT") != NULL) {
|
|
char zfsboot_path[MAXPATHLEN];
|
|
|
|
snprintf(zfsboot_path, sizeof(zfsboot_path), "%s/zfs",
|
|
getenv("BSDINSTALL_TMPBOOT"));
|
|
mkdir(zfsboot_path, S_IRWXU | S_IRGRP | S_IXGRP |
|
|
S_IROTH | S_IXOTH);
|
|
fprintf(fp, " -o cachefile=%s/zpool.cache ",
|
|
zfsboot_path);
|
|
}
|
|
for (i = 0; i < (int)nitems(items); i++) {
|
|
if (items[i].on == false)
|
|
continue;
|
|
if (strcmp(items[i].name, "fletcher4") == 0)
|
|
fputs("-O checksum=fletcher4 ", fp);
|
|
else if (strcmp(items[i].name, "fletcher2") == 0)
|
|
fputs("-O checksum=fletcher2 ", fp);
|
|
else if (strcmp(items[i].name, "sha256") == 0)
|
|
fputs("-O checksum=sha256 ", fp);
|
|
else if (strcmp(items[i].name, "atime") == 0)
|
|
fputs("-O atime=off ", fp);
|
|
}
|
|
} else if (strcmp(fstype, "fat32") == 0 || strcmp(fstype, "efi") == 0 ||
|
|
strcmp(fstype, "ms-basic-data") == 0) {
|
|
int i;
|
|
struct bsddialog_menuitem items[] = {
|
|
{"", 0, true, "FAT32", "FAT Type 32",
|
|
"Create a FAT32 filesystem (default)"},
|
|
{"", 0, false, "FAT16", "FAT Type 16",
|
|
"Create a FAT16 filesystem"},
|
|
{"", 0, false, "FAT12", "FAT Type 12",
|
|
"Create a FAT12 filesystem"},
|
|
};
|
|
|
|
if (!use_default) {
|
|
int choice;
|
|
conf.title = "FAT Options";
|
|
choice = bsddialog_radiolist(&conf, "", 0, 0, 0,
|
|
nitems(items), items, NULL);
|
|
if (choice == BSDDIALOG_CANCEL)
|
|
goto out;
|
|
}
|
|
|
|
fputs("newfs_msdos ", fp);
|
|
for (i = 0; i < (int)nitems(items); i++) {
|
|
if (items[i].on == false)
|
|
continue;
|
|
if (strcmp(items[i].name, "FAT32") == 0)
|
|
fputs("-F 32 -c 1", fp);
|
|
else if (strcmp(items[i].name, "FAT16") == 0)
|
|
fputs("-F 16 ", fp);
|
|
else if (strcmp(items[i].name, "FAT12") == 0)
|
|
fputs("-F 12 ", fp);
|
|
}
|
|
} else {
|
|
if (!use_default) {
|
|
conf.title = "Error";
|
|
bsddialog_msgbox(&conf, "No configurable options exist "
|
|
"for this filesystem.", 0, 0);
|
|
}
|
|
}
|
|
|
|
out:
|
|
fclose(fp);
|
|
return (buf);
|
|
}
|
|
|
|
const char *
|
|
choose_part_type(const char *def_scheme)
|
|
{
|
|
int button, choice, i;
|
|
const char *scheme = NULL;
|
|
struct bsddialog_conf conf;
|
|
|
|
struct bsddialog_menuitem items[] = {
|
|
{"", false, 0, "APM", "Apple Partition Map",
|
|
"Bootable on PowerPC Apple Hardware" },
|
|
{"", false, 0, "BSD", "BSD Labels",
|
|
"Bootable on most x86 systems" },
|
|
{"", false, 0, "GPT", "GUID Partition Table",
|
|
"Bootable on most x86 systems and EFI aware ARM64" },
|
|
{"", false, 0, "MBR", "DOS Partitions",
|
|
"Bootable on most x86 systems" },
|
|
};
|
|
|
|
for (i = 0; i < (int)nitems(items); i++)
|
|
if (strcmp(items[i].name, def_scheme) == 0)
|
|
choice = i;
|
|
|
|
bsddialog_initconf(&conf);
|
|
|
|
parttypemenu:
|
|
conf.title = "Partition Scheme";
|
|
button = bsddialog_menu(&conf,
|
|
"Select a partition scheme for this volume:", 0, 0, 0,
|
|
nitems(items), items, &choice);
|
|
|
|
if (button == BSDDIALOG_CANCEL)
|
|
return NULL;
|
|
|
|
if (!is_scheme_bootable(items[choice].name)) {
|
|
char message[512];
|
|
|
|
snprintf(message, sizeof(message),
|
|
"This partition scheme (%s) is not "
|
|
"bootable on this platform. Are you sure you want "
|
|
"to proceed?", items[choice].name);
|
|
conf.button.default_cancel = true;
|
|
conf.title = "Warning";
|
|
button = bsddialog_yesno(&conf, message, 0, 0);
|
|
conf.button.default_cancel = false;
|
|
if (button == BSDDIALOG_NO)
|
|
goto parttypemenu;
|
|
}
|
|
|
|
scheme = items[choice].name;
|
|
|
|
return scheme;
|
|
}
|
|
|
|
int
|
|
gpart_partition(const char *lg_name, const char *scheme)
|
|
{
|
|
int button;
|
|
struct gctl_req *r;
|
|
const char *errstr;
|
|
struct bsddialog_conf conf;
|
|
|
|
bsddialog_initconf(&conf);
|
|
|
|
schememenu:
|
|
if (scheme == NULL) {
|
|
scheme = choose_part_type(default_scheme());
|
|
|
|
if (scheme == NULL)
|
|
return (-1);
|
|
|
|
if (!is_scheme_bootable(scheme)) {
|
|
char message[512];
|
|
|
|
snprintf(message, sizeof(message),
|
|
"This partition scheme (%s) is not "
|
|
"bootable on this platform. Are you sure you want "
|
|
"to proceed?", scheme);
|
|
conf.button.default_cancel = true;
|
|
conf.title = "Warning";
|
|
button = bsddialog_yesno(&conf, message, 0, 0);
|
|
conf.button.default_cancel = false;
|
|
if (button == BSDDIALOG_NO) {
|
|
/* Reset scheme so user can choose another */
|
|
scheme = NULL;
|
|
goto schememenu;
|
|
}
|
|
}
|
|
}
|
|
|
|
r = gctl_get_handle();
|
|
gctl_ro_param(r, "class", -1, "PART");
|
|
gctl_ro_param(r, "arg0", -1, lg_name);
|
|
gctl_ro_param(r, "flags", -1, GPART_FLAGS);
|
|
gctl_ro_param(r, "scheme", -1, scheme);
|
|
gctl_ro_param(r, "verb", -1, "create");
|
|
|
|
errstr = gctl_issue(r);
|
|
if (errstr != NULL && errstr[0] != '\0') {
|
|
gpart_show_error("Error", NULL, errstr);
|
|
gctl_free(r);
|
|
scheme = NULL;
|
|
goto schememenu;
|
|
}
|
|
gctl_free(r);
|
|
|
|
if (bootcode_path(scheme) != NULL)
|
|
get_part_metadata(lg_name, 1)->bootcode = 1;
|
|
return (0);
|
|
}
|
|
|
|
static void
|
|
gpart_activate(struct gprovider *pp)
|
|
{
|
|
struct gconfig *gc;
|
|
struct gctl_req *r;
|
|
const char *errstr, *scheme;
|
|
const char *attribute = NULL;
|
|
intmax_t idx;
|
|
|
|
/*
|
|
* Some partition schemes need this partition to be marked 'active'
|
|
* for it to be bootable.
|
|
*/
|
|
LIST_FOREACH(gc, &pp->lg_geom->lg_config, lg_config) {
|
|
if (strcmp(gc->lg_name, "scheme") == 0) {
|
|
scheme = gc->lg_val;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (strcmp(scheme, "MBR") == 0 || strcmp(scheme, "EBR") == 0)
|
|
attribute = "active";
|
|
else
|
|
return;
|
|
|
|
LIST_FOREACH(gc, &pp->lg_config, lg_config) {
|
|
if (strcmp(gc->lg_name, "index") == 0) {
|
|
idx = atoi(gc->lg_val);
|
|
break;
|
|
}
|
|
}
|
|
|
|
r = gctl_get_handle();
|
|
gctl_ro_param(r, "class", -1, "PART");
|
|
gctl_ro_param(r, "arg0", -1, pp->lg_geom->lg_name);
|
|
gctl_ro_param(r, "verb", -1, "set");
|
|
gctl_ro_param(r, "attrib", -1, attribute);
|
|
gctl_ro_param(r, "index", sizeof(idx), &idx);
|
|
|
|
errstr = gctl_issue(r);
|
|
if (errstr != NULL && errstr[0] != '\0')
|
|
gpart_show_error("Error", "Error marking partition active:",
|
|
errstr);
|
|
gctl_free(r);
|
|
}
|
|
|
|
void
|
|
gpart_set_root(const char *lg_name, const char *attribute)
|
|
{
|
|
struct gctl_req *r;
|
|
const char *errstr;
|
|
|
|
r = gctl_get_handle();
|
|
gctl_ro_param(r, "class", -1, "PART");
|
|
gctl_ro_param(r, "arg0", -1, lg_name);
|
|
gctl_ro_param(r, "flags", -1, "C");
|
|
gctl_ro_param(r, "verb", -1, "set");
|
|
gctl_ro_param(r, "attrib", -1, attribute);
|
|
|
|
errstr = gctl_issue(r);
|
|
if (errstr != NULL && errstr[0] != '\0')
|
|
gpart_show_error("Error", "Error setting parameter on disk:",
|
|
errstr);
|
|
gctl_free(r);
|
|
}
|
|
|
|
static void
|
|
gpart_bootcode(struct ggeom *gp)
|
|
{
|
|
const char *bootcode;
|
|
struct gconfig *gc;
|
|
struct gctl_req *r;
|
|
const char *errstr, *scheme;
|
|
uint8_t *boot;
|
|
size_t bootsize, bytes;
|
|
int bootfd;
|
|
struct bsddialog_conf conf;
|
|
|
|
/*
|
|
* Write default bootcode to the newly partitioned disk, if that
|
|
* applies on this platform.
|
|
*/
|
|
LIST_FOREACH(gc, &gp->lg_config, lg_config) {
|
|
if (strcmp(gc->lg_name, "scheme") == 0) {
|
|
scheme = gc->lg_val;
|
|
break;
|
|
}
|
|
}
|
|
|
|
bootcode = bootcode_path(scheme);
|
|
if (bootcode == NULL)
|
|
return;
|
|
|
|
bootfd = open(bootcode, O_RDONLY);
|
|
if (bootfd < 0) {
|
|
bsddialog_initconf(&conf);
|
|
conf.title = "Bootcode Error";
|
|
bsddialog_msgbox(&conf, strerror(errno), 0, 0);
|
|
return;
|
|
}
|
|
|
|
bootsize = lseek(bootfd, 0, SEEK_END);
|
|
boot = malloc(bootsize);
|
|
lseek(bootfd, 0, SEEK_SET);
|
|
bytes = 0;
|
|
while (bytes < bootsize)
|
|
bytes += read(bootfd, boot + bytes, bootsize - bytes);
|
|
close(bootfd);
|
|
|
|
r = gctl_get_handle();
|
|
gctl_ro_param(r, "class", -1, "PART");
|
|
gctl_ro_param(r, "arg0", -1, gp->lg_name);
|
|
gctl_ro_param(r, "verb", -1, "bootcode");
|
|
gctl_ro_param(r, "bootcode", bootsize, boot);
|
|
|
|
errstr = gctl_issue(r);
|
|
if (errstr != NULL && errstr[0] != '\0')
|
|
gpart_show_error("Bootcode Error", NULL, errstr);
|
|
gctl_free(r);
|
|
free(boot);
|
|
}
|
|
|
|
static void
|
|
gpart_partcode(struct gprovider *pp, const char *fstype)
|
|
{
|
|
struct gconfig *gc;
|
|
const char *scheme;
|
|
const char *indexstr;
|
|
char message[255], command[255];
|
|
struct bsddialog_conf conf;
|
|
|
|
LIST_FOREACH(gc, &pp->lg_geom->lg_config, lg_config) {
|
|
if (strcmp(gc->lg_name, "scheme") == 0) {
|
|
scheme = gc->lg_val;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Make sure this partition scheme needs partcode on this platform */
|
|
if (partcode_path(scheme, fstype) == NULL)
|
|
return;
|
|
|
|
LIST_FOREACH(gc, &pp->lg_config, lg_config) {
|
|
if (strcmp(gc->lg_name, "index") == 0) {
|
|
indexstr = gc->lg_val;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Shell out to gpart for partcode for now */
|
|
snprintf(command, sizeof(command), "gpart bootcode -p %s -i %s %s",
|
|
partcode_path(scheme, fstype), indexstr, pp->lg_geom->lg_name);
|
|
if (system(command) != 0) {
|
|
snprintf(message, sizeof(message),
|
|
"Error installing partcode on partition %s",
|
|
pp->lg_name);
|
|
bsddialog_initconf(&conf);
|
|
conf.title = "Error";
|
|
bsddialog_msgbox(&conf, message, 0, 0);
|
|
}
|
|
}
|
|
|
|
void
|
|
gpart_destroy(struct ggeom *lg_geom)
|
|
{
|
|
struct gctl_req *r;
|
|
struct gprovider *pp;
|
|
const char *errstr;
|
|
int force = 1;
|
|
|
|
/* Delete all child metadata */
|
|
LIST_FOREACH(pp, &lg_geom->lg_provider, lg_provider)
|
|
gpart_delete(pp);
|
|
|
|
/* Revert any local changes to get this geom into a pristine state */
|
|
r = gctl_get_handle();
|
|
gctl_ro_param(r, "class", -1, "PART");
|
|
gctl_ro_param(r, "arg0", -1, lg_geom->lg_name);
|
|
gctl_ro_param(r, "verb", -1, "undo");
|
|
gctl_issue(r); /* Ignore errors -- these are non-fatal */
|
|
gctl_free(r);
|
|
|
|
/* Now destroy the geom itself */
|
|
r = gctl_get_handle();
|
|
gctl_ro_param(r, "class", -1, "PART");
|
|
gctl_ro_param(r, "arg0", -1, lg_geom->lg_name);
|
|
gctl_ro_param(r, "flags", -1, GPART_FLAGS);
|
|
gctl_ro_param(r, "force", sizeof(force), &force);
|
|
gctl_ro_param(r, "verb", -1, "destroy");
|
|
errstr = gctl_issue(r);
|
|
if (errstr != NULL && errstr[0] != '\0') {
|
|
/*
|
|
* Check if we reverted away the existence of the geom
|
|
* altogether. Show all other errors to the user.
|
|
*/
|
|
if (strtol(errstr, NULL, 0) != EINVAL)
|
|
gpart_show_error("Error", NULL, errstr);
|
|
}
|
|
gctl_free(r);
|
|
|
|
/* And any metadata associated with the partition scheme itself */
|
|
delete_part_metadata(lg_geom->lg_name);
|
|
}
|
|
|
|
void
|
|
gpart_edit(struct gprovider *pp)
|
|
{
|
|
struct gctl_req *r;
|
|
struct gconfig *gc;
|
|
struct gconsumer *cp;
|
|
struct ggeom *geom;
|
|
const char *errstr, *oldtype, *scheme;
|
|
struct partition_metadata *md;
|
|
char sizestr[32];
|
|
char *newfs;
|
|
intmax_t idx;
|
|
int hadlabel, choice, nitems;
|
|
unsigned i;
|
|
struct bsddialog_conf conf;
|
|
|
|
struct bsddialog_formitem items[] = {
|
|
{ "Type:", 1, 1, "", 1, 12, 12, 15, NULL, 0,
|
|
"Filesystem type (e.g. freebsd-ufs, freebsd-zfs, "
|
|
"freebsd-swap)"},
|
|
{ "Size:", 2, 1, "", 2, 12, 12, 15, NULL, 0,
|
|
"Partition size. Append K, M, G for kilobytes, "
|
|
"megabytes or gigabytes."},
|
|
{ "Mountpoint:", 3, 1, "", 3, 12, 12, 15, NULL, 0,
|
|
"Path at which to mount this partition (leave blank "
|
|
"for swap, set to / for root filesystem)"},
|
|
{ "Label:", 4, 1, "", 4, 12, 12, 15, NULL, 0,
|
|
"Partition name. Not all partition schemes support this."},
|
|
};
|
|
|
|
bsddialog_initconf(&conf);
|
|
|
|
/*
|
|
* Find the PART geom we are manipulating. This may be a consumer of
|
|
* this provider, or its parent. Check the consumer case first.
|
|
*/
|
|
geom = NULL;
|
|
LIST_FOREACH(cp, &pp->lg_consumers, lg_consumers)
|
|
if (strcmp(cp->lg_geom->lg_class->lg_name, "PART") == 0) {
|
|
/* Check for zombie geoms, treating them as blank */
|
|
scheme = NULL;
|
|
LIST_FOREACH(gc, &cp->lg_geom->lg_config, lg_config) {
|
|
if (strcmp(gc->lg_name, "scheme") == 0) {
|
|
scheme = gc->lg_val;
|
|
break;
|
|
}
|
|
}
|
|
if (scheme == NULL || strcmp(scheme, "(none)") == 0) {
|
|
gpart_partition(cp->lg_geom->lg_name, NULL);
|
|
return;
|
|
}
|
|
|
|
/* If this is a nested partition, edit as usual */
|
|
if (strcmp(pp->lg_geom->lg_class->lg_name, "PART") == 0)
|
|
break;
|
|
|
|
/* Destroy the geom and all sub-partitions */
|
|
gpart_destroy(cp->lg_geom);
|
|
|
|
/* Now re-partition and return */
|
|
gpart_partition(cp->lg_geom->lg_name, NULL);
|
|
return;
|
|
}
|
|
|
|
if (geom == NULL && strcmp(pp->lg_geom->lg_class->lg_name, "PART") == 0)
|
|
geom = pp->lg_geom;
|
|
|
|
if (geom == NULL) {
|
|
/* Disk not partitioned, so partition it */
|
|
gpart_partition(pp->lg_name, NULL);
|
|
return;
|
|
}
|
|
|
|
LIST_FOREACH(gc, &geom->lg_config, lg_config) {
|
|
if (strcmp(gc->lg_name, "scheme") == 0) {
|
|
scheme = gc->lg_val;
|
|
break;
|
|
}
|
|
}
|
|
|
|
nitems = scheme_supports_labels(scheme) ? 4 : 3;
|
|
|
|
/* Edit editable parameters of a partition */
|
|
hadlabel = 0;
|
|
LIST_FOREACH(gc, &pp->lg_config, lg_config) {
|
|
if (strcmp(gc->lg_name, "type") == 0) {
|
|
oldtype = gc->lg_val;
|
|
items[0].init = gc->lg_val;
|
|
}
|
|
if (strcmp(gc->lg_name, "label") == 0 && gc->lg_val != NULL) {
|
|
hadlabel = 1;
|
|
items[3].init = gc->lg_val;
|
|
}
|
|
if (strcmp(gc->lg_name, "index") == 0)
|
|
idx = atoi(gc->lg_val);
|
|
}
|
|
|
|
TAILQ_FOREACH(md, &part_metadata, metadata) {
|
|
if (md->name != NULL && strcmp(md->name, pp->lg_name) == 0) {
|
|
if (md->fstab != NULL)
|
|
items[2].init = md->fstab->fs_file;
|
|
break;
|
|
}
|
|
}
|
|
|
|
humanize_number(sizestr, 7, pp->lg_mediasize, "B", HN_AUTOSCALE,
|
|
HN_NOSPACE | HN_DECIMAL);
|
|
items[1].init = sizestr;
|
|
|
|
editpart:
|
|
conf.button.always_active = true;
|
|
conf.title = "Edit Partition";
|
|
choice = bsddialog_form(&conf, "", 0, 0, 0, nitems, items, NULL);
|
|
conf.button.always_active = false;
|
|
|
|
if (choice == BSDDIALOG_CANCEL)
|
|
goto endedit;
|
|
|
|
/* If this is the root partition, check that this fs is bootable */
|
|
if (strcmp(items[2].value, "/") == 0 && !is_fs_bootable(scheme,
|
|
items[0].value)) {
|
|
char message[512];
|
|
|
|
snprintf(message, sizeof(message),
|
|
"This file system (%s) is not bootable "
|
|
"on this system. Are you sure you want to proceed?",
|
|
items[0].value);
|
|
conf.button.default_cancel = true;
|
|
conf.title = "Warning";
|
|
choice = bsddialog_yesno(&conf, message, 0, 0);
|
|
conf.button.default_cancel = false;
|
|
if (choice == BSDDIALOG_CANCEL)
|
|
goto editpart;
|
|
}
|
|
|
|
/* Check if the label has a / in it */
|
|
if (items[3].value != NULL && strchr(items[3].value, '/') != NULL) {
|
|
conf.title = "Error";
|
|
bsddialog_msgbox(&conf, "Label contains a /, which is not an "
|
|
"allowed character.", 0, 0);
|
|
goto editpart;
|
|
}
|
|
|
|
r = gctl_get_handle();
|
|
gctl_ro_param(r, "class", -1, "PART");
|
|
gctl_ro_param(r, "arg0", -1, geom->lg_name);
|
|
gctl_ro_param(r, "flags", -1, GPART_FLAGS);
|
|
gctl_ro_param(r, "verb", -1, "modify");
|
|
gctl_ro_param(r, "index", sizeof(idx), &idx);
|
|
if (items[3].value != NULL && (hadlabel || items[3].value[0] != '\0'))
|
|
gctl_ro_param(r, "label", -1, items[3].value);
|
|
gctl_ro_param(r, "type", -1, items[0].value);
|
|
errstr = gctl_issue(r);
|
|
if (errstr != NULL && errstr[0] != '\0') {
|
|
gpart_show_error("Error", NULL, errstr);
|
|
gctl_free(r);
|
|
goto editpart;
|
|
}
|
|
gctl_free(r);
|
|
|
|
newfs = newfs_command(items[0].value, 1);
|
|
set_default_part_metadata(pp->lg_name, scheme, items[0].value,
|
|
items[2].value, (strcmp(oldtype, items[0].value) != 0) ?
|
|
newfs : NULL);
|
|
free(newfs);
|
|
|
|
endedit:
|
|
if (strcmp(oldtype, items[0].value) != 0 && cp != NULL)
|
|
gpart_destroy(cp->lg_geom);
|
|
if (strcmp(oldtype, items[0].value) != 0 && strcmp(items[0].value,
|
|
"freebsd") == 0)
|
|
gpart_partition(pp->lg_name, "BSD");
|
|
|
|
for (i = 0; i < nitems(items); i++)
|
|
if (items[i].value != NULL)
|
|
free(items[i].value);
|
|
}
|
|
|
|
void
|
|
set_default_part_metadata(const char *name, const char *scheme,
|
|
const char *type, const char *mountpoint, const char *newfs)
|
|
{
|
|
struct partition_metadata *md;
|
|
char *zpool_name = NULL;
|
|
const char *default_bootmount = NULL;
|
|
int i;
|
|
|
|
/* Set part metadata */
|
|
md = get_part_metadata(name, 1);
|
|
|
|
if (newfs) {
|
|
if (md->newfs != NULL) {
|
|
free(md->newfs);
|
|
md->newfs = NULL;
|
|
}
|
|
|
|
if (newfs != NULL && newfs[0] != '\0') {
|
|
if (strcmp("freebsd-zfs", type) == 0) {
|
|
zpool_name = strdup((strlen(mountpoint) == 1) ?
|
|
"root" : &mountpoint[1]);
|
|
for (i = 0; zpool_name[i] != 0; i++)
|
|
if (!isalnum(zpool_name[i]))
|
|
zpool_name[i] = '_';
|
|
asprintf(&md->newfs, "%s %s /dev/%s", newfs,
|
|
zpool_name, name);
|
|
} else {
|
|
asprintf(&md->newfs, "%s /dev/%s", newfs, name);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (strcmp(type, "freebsd-swap") == 0)
|
|
mountpoint = "none";
|
|
if (strcmp(type, bootpart_type(scheme, &default_bootmount)) == 0) {
|
|
if (default_bootmount == NULL)
|
|
md->bootcode = 1;
|
|
else if (mountpoint == NULL || strlen(mountpoint) == 0)
|
|
mountpoint = default_bootmount;
|
|
}
|
|
|
|
if (mountpoint == NULL || mountpoint[0] == '\0') {
|
|
if (md->fstab != NULL) {
|
|
free(md->fstab->fs_spec);
|
|
free(md->fstab->fs_file);
|
|
free(md->fstab->fs_vfstype);
|
|
free(md->fstab->fs_mntops);
|
|
free(md->fstab->fs_type);
|
|
free(md->fstab);
|
|
md->fstab = NULL;
|
|
}
|
|
} else {
|
|
if (md->fstab == NULL) {
|
|
md->fstab = malloc(sizeof(struct fstab));
|
|
} else {
|
|
free(md->fstab->fs_spec);
|
|
free(md->fstab->fs_file);
|
|
free(md->fstab->fs_vfstype);
|
|
free(md->fstab->fs_mntops);
|
|
free(md->fstab->fs_type);
|
|
}
|
|
if (strcmp("freebsd-zfs", type) == 0) {
|
|
md->fstab->fs_spec = strdup(zpool_name);
|
|
} else {
|
|
asprintf(&md->fstab->fs_spec, "/dev/%s", name);
|
|
}
|
|
md->fstab->fs_file = strdup(mountpoint);
|
|
/* Get VFS from text after freebsd-, if possible */
|
|
if (strncmp("freebsd-", type, 8) == 0)
|
|
md->fstab->fs_vfstype = strdup(&type[8]);
|
|
else if (strcmp("fat32", type) == 0 || strcmp("efi", type) == 0
|
|
|| strcmp("ms-basic-data", type) == 0)
|
|
md->fstab->fs_vfstype = strdup("msdosfs");
|
|
else
|
|
md->fstab->fs_vfstype = strdup(type); /* Guess */
|
|
if (strcmp(type, "freebsd-swap") == 0) {
|
|
md->fstab->fs_type = strdup(FSTAB_SW);
|
|
md->fstab->fs_freq = 0;
|
|
md->fstab->fs_passno = 0;
|
|
} else if (strcmp(type, "freebsd-zfs") == 0) {
|
|
md->fstab->fs_type = strdup(FSTAB_RW);
|
|
md->fstab->fs_freq = 0;
|
|
md->fstab->fs_passno = 0;
|
|
} else {
|
|
md->fstab->fs_type = strdup(FSTAB_RW);
|
|
if (strcmp(mountpoint, "/") == 0) {
|
|
md->fstab->fs_freq = 1;
|
|
md->fstab->fs_passno = 1;
|
|
} else {
|
|
md->fstab->fs_freq = 2;
|
|
md->fstab->fs_passno = 2;
|
|
}
|
|
}
|
|
md->fstab->fs_mntops = strdup(md->fstab->fs_type);
|
|
}
|
|
|
|
if (zpool_name != NULL)
|
|
free(zpool_name);
|
|
}
|
|
|
|
static
|
|
int part_compare(const void *xa, const void *xb)
|
|
{
|
|
struct gprovider **a = (struct gprovider **)xa;
|
|
struct gprovider **b = (struct gprovider **)xb;
|
|
intmax_t astart, bstart;
|
|
struct gconfig *gc;
|
|
|
|
astart = bstart = 0;
|
|
LIST_FOREACH(gc, &(*a)->lg_config, lg_config)
|
|
if (strcmp(gc->lg_name, "start") == 0) {
|
|
astart = strtoimax(gc->lg_val, NULL, 0);
|
|
break;
|
|
}
|
|
LIST_FOREACH(gc, &(*b)->lg_config, lg_config)
|
|
if (strcmp(gc->lg_name, "start") == 0) {
|
|
bstart = strtoimax(gc->lg_val, NULL, 0);
|
|
break;
|
|
}
|
|
|
|
if (astart < bstart)
|
|
return -1;
|
|
else if (astart > bstart)
|
|
return 1;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
intmax_t
|
|
gpart_max_free(struct ggeom *geom, intmax_t *npartstart)
|
|
{
|
|
struct gconfig *gc;
|
|
struct gprovider *pp, **providers;
|
|
intmax_t sectorsize, stripesize, offset;
|
|
intmax_t lastend;
|
|
intmax_t start, end;
|
|
intmax_t maxsize, maxstart;
|
|
intmax_t partstart, partend;
|
|
int i, nparts;
|
|
|
|
/* Now get the maximum free size and free start */
|
|
start = end = 0;
|
|
LIST_FOREACH(gc, &geom->lg_config, lg_config) {
|
|
if (strcmp(gc->lg_name, "first") == 0)
|
|
start = strtoimax(gc->lg_val, NULL, 0);
|
|
if (strcmp(gc->lg_name, "last") == 0)
|
|
end = strtoimax(gc->lg_val, NULL, 0);
|
|
}
|
|
|
|
i = nparts = 0;
|
|
LIST_FOREACH(pp, &geom->lg_provider, lg_provider)
|
|
nparts++;
|
|
providers = calloc(nparts, sizeof(providers[0]));
|
|
LIST_FOREACH(pp, &geom->lg_provider, lg_provider)
|
|
providers[i++] = pp;
|
|
qsort(providers, nparts, sizeof(providers[0]), part_compare);
|
|
|
|
lastend = start - 1;
|
|
maxsize = 0;
|
|
for (i = 0; i < nparts; i++) {
|
|
pp = providers[i];
|
|
|
|
LIST_FOREACH(gc, &pp->lg_config, lg_config) {
|
|
if (strcmp(gc->lg_name, "start") == 0)
|
|
partstart = strtoimax(gc->lg_val, NULL, 0);
|
|
if (strcmp(gc->lg_name, "end") == 0)
|
|
partend = strtoimax(gc->lg_val, NULL, 0);
|
|
}
|
|
|
|
if (partstart - lastend > maxsize) {
|
|
maxsize = partstart - lastend - 1;
|
|
maxstart = lastend + 1;
|
|
}
|
|
|
|
lastend = partend;
|
|
}
|
|
|
|
if (end - lastend > maxsize) {
|
|
maxsize = end - lastend;
|
|
maxstart = lastend + 1;
|
|
}
|
|
|
|
pp = LIST_FIRST(&geom->lg_consumer)->lg_provider;
|
|
|
|
/*
|
|
* Round the start and size of the largest available space up to
|
|
* the nearest multiple of the adjusted stripe size.
|
|
*
|
|
* The adjusted stripe size is the least common multiple of the
|
|
* actual stripe size, or the sector size if no stripe size was
|
|
* reported, and 4096. The reason for this is that contemporary
|
|
* disks often have 4096-byte physical sectors but report 512
|
|
* bytes instead for compatibility with older / broken operating
|
|
* systems and BIOSes. For the same reasons, virtualized storage
|
|
* may also report a 512-byte stripe size, or none at all.
|
|
*/
|
|
sectorsize = pp->lg_sectorsize;
|
|
if ((stripesize = pp->lg_stripesize) == 0)
|
|
stripesize = sectorsize;
|
|
while (stripesize % 4096 != 0)
|
|
stripesize *= 2;
|
|
if ((offset = maxstart * sectorsize % stripesize) != 0) {
|
|
offset = (stripesize - offset) / sectorsize;
|
|
maxstart += offset;
|
|
maxsize -= offset;
|
|
}
|
|
|
|
if (npartstart != NULL)
|
|
*npartstart = maxstart;
|
|
|
|
return (maxsize);
|
|
}
|
|
|
|
static size_t
|
|
add_boot_partition(struct ggeom *geom, struct gprovider *pp,
|
|
const char *scheme, int interactive)
|
|
{
|
|
struct gconfig *gc;
|
|
struct gprovider *ppi;
|
|
int choice;
|
|
struct bsddialog_conf conf;
|
|
|
|
/* Check for existing freebsd-boot partition */
|
|
LIST_FOREACH(ppi, &geom->lg_provider, lg_provider) {
|
|
struct partition_metadata *md;
|
|
const char *bootmount = NULL;
|
|
|
|
LIST_FOREACH(gc, &ppi->lg_config, lg_config)
|
|
if (strcmp(gc->lg_name, "type") == 0)
|
|
break;
|
|
if (gc == NULL)
|
|
continue;
|
|
if (strcmp(gc->lg_val, bootpart_type(scheme, &bootmount)) != 0)
|
|
continue;
|
|
|
|
/*
|
|
* If the boot partition is not mountable and needs partcode,
|
|
* but doesn't have it, it doesn't satisfy our requirements.
|
|
*/
|
|
md = get_part_metadata(ppi->lg_name, 0);
|
|
if (bootmount == NULL && (md == NULL || !md->bootcode))
|
|
continue;
|
|
|
|
/* If it is mountable, but mounted somewhere else, remount */
|
|
if (bootmount != NULL && md != NULL && md->fstab != NULL
|
|
&& strlen(md->fstab->fs_file) > 0
|
|
&& strcmp(md->fstab->fs_file, bootmount) != 0)
|
|
continue;
|
|
|
|
/* If it is mountable, but mountpoint is not set, mount it */
|
|
if (bootmount != NULL && md == NULL)
|
|
set_default_part_metadata(ppi->lg_name, scheme,
|
|
gc->lg_val, bootmount, NULL);
|
|
|
|
/* Looks good at this point, no added data needed */
|
|
return (0);
|
|
}
|
|
|
|
if (interactive) {
|
|
bsddialog_initconf(&conf);
|
|
conf.title = "Boot Partition";
|
|
choice = bsddialog_yesno(&conf,
|
|
"This partition scheme requires a boot partition "
|
|
"for the disk to be bootable. Would you like to "
|
|
"make one now?", 0, 0);
|
|
} else {
|
|
choice = BSDDIALOG_YES;
|
|
}
|
|
|
|
if (choice == BSDDIALOG_YES) {
|
|
struct partition_metadata *md;
|
|
const char *bootmount = NULL;
|
|
char *bootpartname = NULL;
|
|
char sizestr[7];
|
|
|
|
humanize_number(sizestr, 7,
|
|
bootpart_size(scheme), "B", HN_AUTOSCALE,
|
|
HN_NOSPACE | HN_DECIMAL);
|
|
|
|
gpart_create(pp, bootpart_type(scheme, &bootmount),
|
|
sizestr, bootmount, &bootpartname, 0);
|
|
|
|
if (bootpartname == NULL) /* Error reported to user already */
|
|
return 0;
|
|
|
|
/* If the part is not mountable, make sure newfs isn't set */
|
|
if (bootmount == NULL) {
|
|
md = get_part_metadata(bootpartname, 0);
|
|
if (md != NULL && md->newfs != NULL) {
|
|
free(md->newfs);
|
|
md->newfs = NULL;
|
|
}
|
|
}
|
|
|
|
free(bootpartname);
|
|
|
|
return (bootpart_size(scheme));
|
|
}
|
|
|
|
return (0);
|
|
}
|
|
|
|
void
|
|
gpart_create(struct gprovider *pp, const char *default_type,
|
|
const char *default_size, const char *default_mountpoint,
|
|
char **partname, int interactive)
|
|
{
|
|
struct gctl_req *r;
|
|
struct gconfig *gc;
|
|
struct gconsumer *cp;
|
|
struct ggeom *geom;
|
|
const char *errstr, *scheme;
|
|
char sizestr[32], startstr[32], output[64], *newpartname;
|
|
char *newfs, options_fstype[64];
|
|
intmax_t maxsize, size, sector, firstfree, stripe;
|
|
uint64_t bytes;
|
|
int nitems, choice, junk;
|
|
unsigned i;
|
|
bool init_allocated;
|
|
struct bsddialog_conf conf;
|
|
|
|
struct bsddialog_formitem items[] = {
|
|
{"Type:", 1, 1, "freebsd-ufs", 1, 12, 12, 15, NULL, 0,
|
|
"Filesystem type (e.g. freebsd-ufs, freebsd-zfs, "
|
|
"freebsd-swap)"},
|
|
{"Size:", 2, 1, "", 2, 12, 12, 15, NULL, 0,
|
|
"Partition size. Append K, M, G for kilobytes, "
|
|
"megabytes or gigabytes."},
|
|
{"Mountpoint:", 3, 1, "", 3, 12, 12, 15, NULL, 0,
|
|
"Path at which to mount partition (blank for "
|
|
"swap, / for root filesystem)"},
|
|
{"Label:", 4, 1, "", 4, 12, 12, 15, NULL, 0,
|
|
"Partition name. Not all partition schemes support this."},
|
|
};
|
|
|
|
bsddialog_initconf(&conf);
|
|
|
|
if (partname != NULL)
|
|
*partname = NULL;
|
|
|
|
/* Record sector and stripe sizes */
|
|
sector = pp->lg_sectorsize;
|
|
stripe = pp->lg_stripesize;
|
|
|
|
/*
|
|
* Find the PART geom we are manipulating. This may be a consumer of
|
|
* this provider, or its parent. Check the consumer case first.
|
|
*/
|
|
geom = NULL;
|
|
LIST_FOREACH(cp, &pp->lg_consumers, lg_consumers)
|
|
if (strcmp(cp->lg_geom->lg_class->lg_name, "PART") == 0) {
|
|
geom = cp->lg_geom;
|
|
break;
|
|
}
|
|
|
|
if (geom == NULL && strcmp(pp->lg_geom->lg_class->lg_name, "PART") == 0)
|
|
geom = pp->lg_geom;
|
|
|
|
/* Now get the partition scheme */
|
|
scheme = NULL;
|
|
if (geom != NULL) {
|
|
LIST_FOREACH(gc, &geom->lg_config, lg_config)
|
|
if (strcmp(gc->lg_name, "scheme") == 0)
|
|
scheme = gc->lg_val;
|
|
}
|
|
|
|
if (geom == NULL || scheme == NULL || strcmp(scheme, "(none)") == 0) {
|
|
if (gpart_partition(pp->lg_name, NULL) == 0) {
|
|
bsddialog_msgbox(&conf,
|
|
"The partition table has been successfully created."
|
|
" Please press Create again to create partitions.",
|
|
0, 0);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* If we still don't have a geom, either the user has
|
|
* canceled partitioning or there has been an error which has already
|
|
* been displayed, so bail.
|
|
*/
|
|
if (geom == NULL)
|
|
return;
|
|
|
|
maxsize = size = gpart_max_free(geom, &firstfree);
|
|
if (size <= 0) {
|
|
conf .title = "Error";
|
|
bsddialog_msgbox(&conf, "No free space left on device.", 0, 0);
|
|
return;
|
|
}
|
|
|
|
humanize_number(sizestr, 7, size*sector, "B", HN_AUTOSCALE,
|
|
HN_NOSPACE | HN_DECIMAL);
|
|
items[1].init = sizestr;
|
|
|
|
/* Special-case the MBR default type for nested partitions */
|
|
if (strcmp(scheme, "MBR") == 0) {
|
|
items[0].init = "freebsd";
|
|
items[0].bottomdesc = "Filesystem type (e.g. freebsd, fat32)";
|
|
}
|
|
|
|
nitems = scheme_supports_labels(scheme) ? 4 : 3;
|
|
|
|
if (default_type != NULL)
|
|
items[0].init = (char *)default_type;
|
|
if (default_size != NULL)
|
|
items[1].init = (char *)default_size;
|
|
if (default_mountpoint != NULL)
|
|
items[2].init = (char *)default_mountpoint;
|
|
|
|
/* Default options */
|
|
strncpy(options_fstype, items[0].init,
|
|
sizeof(options_fstype));
|
|
newfs = newfs_command(options_fstype, 1);
|
|
|
|
init_allocated = false;
|
|
addpartform:
|
|
if (interactive) {
|
|
conf.button.with_extra = true;
|
|
conf.button.extra_label = "Options";
|
|
conf.button.always_active = true;
|
|
conf.title = "Add Partition";
|
|
choice = bsddialog_form(&conf, "", 0, 0, 0, nitems, items, NULL);
|
|
conf.button.with_extra = false;
|
|
conf.button.extra_label = NULL;
|
|
conf.button.always_active = false;
|
|
switch (choice) {
|
|
case BSDDIALOG_OK:
|
|
break;
|
|
case BSDDIALOG_CANCEL:
|
|
return;
|
|
case BSDDIALOG_EXTRA: /* Options */
|
|
free(newfs);
|
|
strncpy(options_fstype, items[0].value,
|
|
sizeof(options_fstype));
|
|
newfs = newfs_command(options_fstype, 0);
|
|
for (i = 0; i < nitems(items); i++) {
|
|
if (init_allocated)
|
|
free((char*)items[i].init);
|
|
items[i].init = items[i].value;
|
|
}
|
|
init_allocated = true;
|
|
goto addpartform;
|
|
}
|
|
} else { /* auto partitioning */
|
|
items[0].value = strdup(items[0].init);
|
|
items[1].value = strdup(items[1].init);
|
|
items[2].value = strdup(items[2].init);
|
|
if (nitems > 3)
|
|
items[3].value = strdup(items[3].init);
|
|
}
|
|
|
|
/*
|
|
* If the user changed the fs type after specifying options, undo
|
|
* their choices in favor of the new filesystem's defaults.
|
|
*/
|
|
if (strcmp(options_fstype, items[0].value) != 0) {
|
|
free(newfs);
|
|
strncpy(options_fstype, items[0].value, sizeof(options_fstype));
|
|
newfs = newfs_command(options_fstype, 1);
|
|
}
|
|
|
|
size = maxsize;
|
|
if (strlen(items[1].value) > 0) {
|
|
if (expand_number(items[1].value, &bytes) != 0) {
|
|
char error[512];
|
|
|
|
snprintf(error, sizeof(error), "Invalid size: %s\n",
|
|
strerror(errno));
|
|
conf.title = "Error";
|
|
bsddialog_msgbox(&conf, error, 0, 0);
|
|
goto addpartform;
|
|
}
|
|
size = MIN((intmax_t)(bytes/sector), maxsize);
|
|
}
|
|
|
|
/* Check if the label has a / in it */
|
|
if (items[3].value != NULL && strchr(items[3].value, '/') != NULL) {
|
|
conf.title = "Error";
|
|
bsddialog_msgbox(&conf, "Label contains a /, which is not an "
|
|
"allowed character.", 0, 0);
|
|
goto addpartform;
|
|
}
|
|
|
|
/* Warn if no mountpoint set */
|
|
if (strcmp(items[0].value, "freebsd-ufs") == 0 &&
|
|
items[2].value[0] != '/') {
|
|
choice = 0;
|
|
if (interactive) {
|
|
conf.button.default_cancel = true;
|
|
conf.title = "Warning";
|
|
choice = bsddialog_yesno(&conf,
|
|
"This partition does not have a valid mountpoint "
|
|
"(for the partition from which you intend to boot the "
|
|
"operating system, the mountpoint should be /). Are you "
|
|
"sure you want to continue?"
|
|
, 0, 0);
|
|
conf.button.default_cancel = false;
|
|
}
|
|
if (choice == BSDDIALOG_CANCEL)
|
|
goto addpartform;
|
|
}
|
|
|
|
/*
|
|
* Error if this scheme needs nested partitions, this is one, and
|
|
* a mountpoint was set.
|
|
*/
|
|
if (strcmp(items[0].value, "freebsd") == 0 &&
|
|
strlen(items[2].value) > 0) {
|
|
conf.title = "Error";
|
|
bsddialog_msgbox(&conf, "Partitions of type \"freebsd\" are "
|
|
"nested BSD-type partition schemes and cannot have "
|
|
"mountpoints. After creating one, select it and press "
|
|
"Create again to add the actual file systems.", 0, 0);
|
|
goto addpartform;
|
|
}
|
|
|
|
/* If this is the root partition, check that this scheme is bootable */
|
|
if (strcmp(items[2].value, "/") == 0 && !is_scheme_bootable(scheme)) {
|
|
char message[512];
|
|
|
|
snprintf(message, sizeof(message),
|
|
"This partition scheme (%s) is not bootable "
|
|
"on this platform. Are you sure you want to proceed?",
|
|
scheme);
|
|
conf.button.default_cancel = true;
|
|
conf.title = "Warning";
|
|
choice = bsddialog_yesno(&conf, message, 0, 0);
|
|
conf.button.default_cancel = false;
|
|
if (choice == BSDDIALOG_CANCEL)
|
|
goto addpartform;
|
|
}
|
|
|
|
/* If this is the root partition, check that this fs is bootable */
|
|
if (strcmp(items[2].value, "/") == 0 && !is_fs_bootable(scheme,
|
|
items[0].value)) {
|
|
char message[512];
|
|
|
|
snprintf(message, sizeof(message),
|
|
"This file system (%s) is not bootable "
|
|
"on this system. Are you sure you want to proceed?",
|
|
items[0].value);
|
|
conf.button.default_cancel = true;
|
|
conf.title = "Warning";
|
|
choice = bsddialog_yesno(&conf, message, 0, 0);
|
|
conf.button.default_cancel = false;
|
|
if (choice == BSDDIALOG_CANCEL)
|
|
goto addpartform;
|
|
}
|
|
|
|
/*
|
|
* If this is the root partition, and we need a boot partition, ask
|
|
* the user to add one.
|
|
*/
|
|
|
|
if ((strcmp(items[0].value, "freebsd") == 0 ||
|
|
strcmp(items[2].value, "/") == 0) && bootpart_size(scheme) > 0) {
|
|
size_t bytes = add_boot_partition(geom, pp, scheme,
|
|
interactive);
|
|
|
|
/* Now adjust the part we are really adding forward */
|
|
if (bytes > 0) {
|
|
firstfree += bytes / sector;
|
|
size -= (bytes + stripe)/sector;
|
|
if (stripe > 0 && (firstfree*sector % stripe) != 0)
|
|
firstfree += (stripe - ((firstfree*sector) %
|
|
stripe)) / sector;
|
|
}
|
|
}
|
|
|
|
output[0] = '\0';
|
|
|
|
r = gctl_get_handle();
|
|
gctl_ro_param(r, "class", -1, "PART");
|
|
gctl_ro_param(r, "arg0", -1, geom->lg_name);
|
|
gctl_ro_param(r, "flags", -1, GPART_FLAGS);
|
|
gctl_ro_param(r, "verb", -1, "add");
|
|
|
|
gctl_ro_param(r, "type", -1, items[0].value);
|
|
snprintf(sizestr, sizeof(sizestr), "%jd", size);
|
|
gctl_ro_param(r, "size", -1, sizestr);
|
|
snprintf(startstr, sizeof(startstr), "%jd", firstfree);
|
|
gctl_ro_param(r, "start", -1, startstr);
|
|
if (items[3].value != NULL && items[3].value[0] != '\0')
|
|
gctl_ro_param(r, "label", -1, items[3].value);
|
|
gctl_add_param(r, "output", sizeof(output), output,
|
|
GCTL_PARAM_WR | GCTL_PARAM_ASCII);
|
|
errstr = gctl_issue(r);
|
|
if (errstr != NULL && errstr[0] != '\0') {
|
|
gpart_show_error("Error", NULL, errstr);
|
|
gctl_free(r);
|
|
goto addpartform;
|
|
}
|
|
newpartname = strtok(output, " ");
|
|
gctl_free(r);
|
|
|
|
/*
|
|
* Try to destroy any geom that gpart picked up already here from
|
|
* dirty blocks.
|
|
*/
|
|
r = gctl_get_handle();
|
|
gctl_ro_param(r, "class", -1, "PART");
|
|
gctl_ro_param(r, "arg0", -1, newpartname);
|
|
gctl_ro_param(r, "flags", -1, GPART_FLAGS);
|
|
junk = 1;
|
|
gctl_ro_param(r, "force", sizeof(junk), &junk);
|
|
gctl_ro_param(r, "verb", -1, "destroy");
|
|
gctl_issue(r); /* Error usually expected and non-fatal */
|
|
gctl_free(r);
|
|
|
|
|
|
if (strcmp(items[0].value, "freebsd") == 0)
|
|
gpart_partition(newpartname, "BSD");
|
|
else
|
|
set_default_part_metadata(newpartname, scheme,
|
|
items[0].value, items[2].value, newfs);
|
|
free(newfs);
|
|
|
|
for (i = 0; i < nitems(items); i++) {
|
|
if (items[i].value != NULL) {
|
|
free(items[i].value);
|
|
if (init_allocated && items[i].init != NULL)
|
|
free((char*)items[i].init);
|
|
}
|
|
}
|
|
|
|
if (partname != NULL)
|
|
*partname = strdup(newpartname);
|
|
}
|
|
|
|
void
|
|
gpart_delete(struct gprovider *pp)
|
|
{
|
|
struct gconfig *gc;
|
|
struct ggeom *geom;
|
|
struct gconsumer *cp;
|
|
struct gctl_req *r;
|
|
const char *errstr;
|
|
intmax_t idx;
|
|
int is_partition;
|
|
struct bsddialog_conf conf;
|
|
|
|
/* Is it a partition? */
|
|
is_partition = (strcmp(pp->lg_geom->lg_class->lg_name, "PART") == 0);
|
|
|
|
/* Find out if this is the root of a gpart geom */
|
|
geom = NULL;
|
|
LIST_FOREACH(cp, &pp->lg_consumers, lg_consumers)
|
|
if (strcmp(cp->lg_geom->lg_class->lg_name, "PART") == 0) {
|
|
geom = cp->lg_geom;
|
|
break;
|
|
}
|
|
|
|
/* If so, destroy all children */
|
|
if (geom != NULL) {
|
|
gpart_destroy(geom);
|
|
|
|
/* If this is a partition, revert it, so it can be deleted */
|
|
if (is_partition) {
|
|
r = gctl_get_handle();
|
|
gctl_ro_param(r, "class", -1, "PART");
|
|
gctl_ro_param(r, "arg0", -1, geom->lg_name);
|
|
gctl_ro_param(r, "verb", -1, "undo");
|
|
gctl_issue(r); /* Ignore non-fatal errors */
|
|
gctl_free(r);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* If this is not a partition, see if that is a problem, complain if
|
|
* necessary, and return always, since we need not do anything further,
|
|
* error or no.
|
|
*/
|
|
if (!is_partition) {
|
|
if (geom == NULL) {
|
|
bsddialog_initconf(&conf);
|
|
conf.title = "Error";
|
|
bsddialog_msgbox(&conf,
|
|
"Only partitions can be deleted.", 0, 0);
|
|
}
|
|
return;
|
|
}
|
|
|
|
r = gctl_get_handle();
|
|
gctl_ro_param(r, "class", -1, pp->lg_geom->lg_class->lg_name);
|
|
gctl_ro_param(r, "arg0", -1, pp->lg_geom->lg_name);
|
|
gctl_ro_param(r, "flags", -1, GPART_FLAGS);
|
|
gctl_ro_param(r, "verb", -1, "delete");
|
|
|
|
LIST_FOREACH(gc, &pp->lg_config, lg_config) {
|
|
if (strcmp(gc->lg_name, "index") == 0) {
|
|
idx = atoi(gc->lg_val);
|
|
gctl_ro_param(r, "index", sizeof(idx), &idx);
|
|
break;
|
|
}
|
|
}
|
|
|
|
errstr = gctl_issue(r);
|
|
if (errstr != NULL && errstr[0] != '\0') {
|
|
gpart_show_error("Error", NULL, errstr);
|
|
gctl_free(r);
|
|
return;
|
|
}
|
|
|
|
gctl_free(r);
|
|
|
|
delete_part_metadata(pp->lg_name);
|
|
}
|
|
|
|
void
|
|
gpart_revert_all(struct gmesh *mesh)
|
|
{
|
|
struct gclass *classp;
|
|
struct gconfig *gc;
|
|
struct ggeom *gp;
|
|
struct gctl_req *r;
|
|
const char *modified;
|
|
struct bsddialog_conf conf;
|
|
|
|
LIST_FOREACH(classp, &mesh->lg_class, lg_class) {
|
|
if (strcmp(classp->lg_name, "PART") == 0)
|
|
break;
|
|
}
|
|
|
|
if (strcmp(classp->lg_name, "PART") != 0) {
|
|
bsddialog_initconf(&conf);
|
|
conf.title = "Error";
|
|
bsddialog_msgbox(&conf, "gpart not found!", 0, 0);
|
|
return;
|
|
}
|
|
|
|
LIST_FOREACH(gp, &classp->lg_geom, lg_geom) {
|
|
modified = "true"; /* XXX: If we don't know (kernel too old),
|
|
* assume there are modifications. */
|
|
LIST_FOREACH(gc, &gp->lg_config, lg_config) {
|
|
if (strcmp(gc->lg_name, "modified") == 0) {
|
|
modified = gc->lg_val;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (strcmp(modified, "false") == 0)
|
|
continue;
|
|
|
|
r = gctl_get_handle();
|
|
gctl_ro_param(r, "class", -1, "PART");
|
|
gctl_ro_param(r, "arg0", -1, gp->lg_name);
|
|
gctl_ro_param(r, "verb", -1, "undo");
|
|
|
|
gctl_issue(r);
|
|
gctl_free(r);
|
|
}
|
|
}
|
|
|
|
void
|
|
gpart_commit(struct gmesh *mesh)
|
|
{
|
|
struct partition_metadata *md;
|
|
struct gclass *classp;
|
|
struct ggeom *gp;
|
|
struct gconfig *gc;
|
|
struct gconsumer *cp;
|
|
struct gprovider *pp;
|
|
struct gctl_req *r;
|
|
const char *errstr;
|
|
const char *modified;
|
|
const char *rootfs;
|
|
struct bsddialog_conf conf;
|
|
|
|
LIST_FOREACH(classp, &mesh->lg_class, lg_class) {
|
|
if (strcmp(classp->lg_name, "PART") == 0)
|
|
break;
|
|
}
|
|
|
|
/* Figure out what filesystem / uses */
|
|
rootfs = "ufs"; /* Assume ufs if nothing else present */
|
|
TAILQ_FOREACH(md, &part_metadata, metadata) {
|
|
if (md->fstab != NULL && strcmp(md->fstab->fs_file, "/") == 0) {
|
|
rootfs = md->fstab->fs_vfstype;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (strcmp(classp->lg_name, "PART") != 0) {
|
|
bsddialog_initconf(&conf);
|
|
conf.title = "Error";
|
|
bsddialog_msgbox(&conf, "gpart not found!", 0, 0);
|
|
return;
|
|
}
|
|
|
|
LIST_FOREACH(gp, &classp->lg_geom, lg_geom) {
|
|
modified = "true"; /* XXX: If we don't know (kernel too old),
|
|
* assume there are modifications. */
|
|
LIST_FOREACH(gc, &gp->lg_config, lg_config) {
|
|
if (strcmp(gc->lg_name, "modified") == 0) {
|
|
modified = gc->lg_val;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (strcmp(modified, "false") == 0)
|
|
continue;
|
|
|
|
/* Add bootcode if necessary, before the commit */
|
|
md = get_part_metadata(gp->lg_name, 0);
|
|
if (md != NULL && md->bootcode)
|
|
gpart_bootcode(gp);
|
|
|
|
/* Now install partcode on its partitions, if necessary */
|
|
LIST_FOREACH(pp, &gp->lg_provider, lg_provider) {
|
|
md = get_part_metadata(pp->lg_name, 0);
|
|
if (md == NULL || !md->bootcode)
|
|
continue;
|
|
|
|
/* Mark this partition active if that's required */
|
|
gpart_activate(pp);
|
|
|
|
/* Check if the partition has sub-partitions */
|
|
LIST_FOREACH(cp, &pp->lg_consumers, lg_consumers)
|
|
if (strcmp(cp->lg_geom->lg_class->lg_name,
|
|
"PART") == 0)
|
|
break;
|
|
|
|
if (cp == NULL) /* No sub-partitions */
|
|
gpart_partcode(pp, rootfs);
|
|
}
|
|
|
|
r = gctl_get_handle();
|
|
gctl_ro_param(r, "class", -1, "PART");
|
|
gctl_ro_param(r, "arg0", -1, gp->lg_name);
|
|
gctl_ro_param(r, "verb", -1, "commit");
|
|
|
|
errstr = gctl_issue(r);
|
|
if (errstr != NULL && errstr[0] != '\0')
|
|
gpart_show_error("Error", NULL, errstr);
|
|
gctl_free(r);
|
|
}
|
|
}
|
|
|