HelenOS sources
This source file includes following definitions.
- fdsk_confirm
- fdsk_dev_sel_choice
- fdsk_create_label
- fdsk_delete_label
- fdsk_erase_disk
- fdsk_select_fstype
- fdsk_create_part
- fdsk_add_part_choices
- fdsk_modify_mountp
- fdsk_modify_part
- fdsk_delete_part
- fdsk_dev_menu
- main
#include <capa.h>
#include <errno.h>
#include <fdisk.h>
#include <io/label.h>
#include <nchoice.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <str.h>
#include <vol.h>
#define NO_LABEL_CAPTION "(No name)"
static bool quit = false;
static fdisk_t *fdisk;
typedef enum {
devac_create_label,
devac_delete_label,
devac_erase_disk,
devac_create_pri_part,
devac_create_ext_part,
devac_create_log_part,
devac_modify_part,
devac_delete_part,
devac_exit
} devac_t;
typedef enum {
pm_mountp,
pm_cancel
} pmprop_t;
static errno_t fdsk_confirm(const char *msg, bool *rconfirm)
{
tinput_t *tinput = NULL;
char *answer;
errno_t rc;
tinput = tinput_new();
if (tinput == NULL) {
rc = ENOMEM;
goto error;
}
rc = tinput_set_prompt(tinput, "y/n> ");
if (rc != EOK)
goto error;
while (true) {
printf("%s\n", msg);
rc = tinput_read(tinput, &answer);
if (rc == ENOENT) {
*rconfirm = false;
free(answer);
break;
}
if (rc != EOK)
goto error;
if (str_cmp(answer, "y") == 0) {
*rconfirm = true;
free(answer);
break;
} else if (str_cmp(answer, "n") == 0) {
*rconfirm = false;
free(answer);
break;
}
}
tinput_destroy(tinput);
return EOK;
error:
if (tinput != NULL)
tinput_destroy(tinput);
return rc;
}
static errno_t fdsk_dev_sel_choice(service_id_t *rsvcid)
{
fdisk_dev_list_t *devlist = NULL;
fdisk_dev_info_t *info;
nchoice_t *choice = NULL;
char *svcname = NULL;
capa_spec_t capa;
fdisk_dev_info_t *sdev;
char *scapa = NULL;
char *dtext = NULL;
service_id_t svcid;
void *sel;
int ndevs;
errno_t rc;
rc = nchoice_create(&choice);
if (rc != EOK) {
assert(rc == ENOMEM);
printf("Out of memory.\n");
goto error;
}
rc = nchoice_set_prompt(choice, "Select device");
if (rc != EOK) {
assert(rc == ENOMEM);
printf("Out of memory.\n");
goto error;
}
rc = fdisk_dev_list_get(fdisk, &devlist);
if (rc != EOK) {
printf("Error getting device list.\n");
goto error;
}
info = fdisk_dev_first(devlist);
ndevs = 0;
while (info != NULL) {
rc = fdisk_dev_info_get_svcname(info, &svcname);
if (rc != EOK) {
fdisk_dev_info_get_svcid(info, &svcid);
printf("Error getting device service name "
"(service ID %zu).\n", svcid);
info = fdisk_dev_next(info);
continue;
}
rc = fdisk_dev_info_capacity(info, &capa);
if (rc != EOK) {
printf("Error getting device capacity "
"(device %s).\n", svcname);
info = fdisk_dev_next(info);
continue;
}
capa_simplify(&capa);
rc = capa_format(&capa, &scapa);
if (rc != EOK) {
assert(rc == ENOMEM);
printf("Out of memory.\n");
goto error;
}
int ret = asprintf(&dtext, "%s (%s)", svcname, scapa);
if (ret < 0) {
rc = ENOMEM;
printf("Out of memory.\n");
goto error;
}
free(svcname);
svcname = NULL;
free(scapa);
scapa = NULL;
rc = nchoice_add(choice, dtext, info, 0);
if (rc != EOK) {
assert(rc == ENOMEM);
printf("Out of memory.\n");
goto error;
}
++ndevs;
free(dtext);
dtext = NULL;
info = fdisk_dev_next(info);
}
if (ndevs == 0) {
printf("No disk devices found.\n");
rc = ENOENT;
goto error;
}
rc = nchoice_add(choice, "Exit", NULL, 0);
if (rc != EOK) {
assert(rc == ENOMEM);
printf("Out of memory.\n");
goto error;
}
rc = nchoice_get(choice, &sel);
if (rc != EOK) {
printf("Error getting user selection.\n");
return rc;
}
sdev = (fdisk_dev_info_t *)sel;
if (sdev != NULL) {
fdisk_dev_info_get_svcid(sdev, &svcid);
} else {
svcid = 0;
}
fdisk_dev_list_free(devlist);
nchoice_destroy(choice);
*rsvcid = svcid;
return EOK;
error:
assert(rc != EOK);
*rsvcid = 0;
if (devlist != NULL)
fdisk_dev_list_free(devlist);
if (choice != NULL)
nchoice_destroy(choice);
free(dtext);
free(svcname);
free(scapa);
return rc;
}
static errno_t fdsk_create_label(fdisk_dev_t *dev)
{
nchoice_t *choice = NULL;
void *sel;
char *sltype = NULL;
int i;
errno_t rc;
rc = nchoice_create(&choice);
if (rc != EOK) {
assert(rc == ENOMEM);
printf("Out of memory.\n");
goto error;
}
rc = nchoice_set_prompt(choice, "Select label type");
if (rc != EOK) {
assert(rc == ENOMEM);
printf("Out of memory.\n");
goto error;
}
for (i = LT_FIRST; i < LT_LIMIT; i++) {
rc = label_type_format(i, &sltype);
if (rc != EOK)
goto error;
rc = nchoice_add(choice, sltype, (void *)(uintptr_t)i,
i == LT_DEFAULT);
if (rc != EOK) {
assert(rc == ENOMEM);
printf("Out of memory.\n");
goto error;
}
free(sltype);
sltype = NULL;
}
rc = nchoice_get(choice, &sel);
if (rc != EOK) {
printf("Error getting user selection.\n");
goto error;
}
rc = fdisk_label_create(dev, (label_type_t)sel);
if (rc != EOK) {
printf("Error creating label.\n");
goto error;
}
nchoice_destroy(choice);
return EOK;
error:
free(sltype);
if (choice != NULL)
nchoice_destroy(choice);
return rc;
}
static errno_t fdsk_delete_label(fdisk_dev_t *dev)
{
bool confirm;
errno_t rc;
rc = fdsk_confirm("Warning. Any data on disk will be lost. "
"Really delete label?", &confirm);
if (rc != EOK) {
printf("Error getting user confirmation.\n");
return rc;
}
if (!confirm)
return EOK;
rc = fdisk_label_destroy(dev);
if (rc != EOK) {
printf("Error deleting label.\n");
return rc;
}
return EOK;
}
static errno_t fdsk_erase_disk(fdisk_dev_t *dev)
{
bool confirm;
errno_t rc;
rc = fdsk_confirm("Warning. Any data on disk will be lost. "
"Really erase disk?", &confirm);
if (rc != EOK) {
printf("Error getting user confirmation.\n");
return rc;
}
if (!confirm)
return EOK;
rc = fdisk_dev_erase(dev);
if (rc != EOK) {
printf("Error erasing disk.\n");
return rc;
}
return EOK;
}
static errno_t fdsk_select_fstype(vol_fstype_t *fstype)
{
nchoice_t *choice = NULL;
void *sel;
char *sfstype = NULL;
int i;
errno_t rc;
rc = nchoice_create(&choice);
if (rc != EOK) {
assert(rc == ENOMEM);
printf("Out of memory.\n");
goto error;
}
rc = nchoice_set_prompt(choice, "Select file system type");
if (rc != EOK) {
assert(rc == ENOMEM);
printf("Out of memory.\n");
goto error;
}
for (i = 0; i < VOL_FSTYPE_LIMIT; i++) {
rc = vol_fstype_format(i, &sfstype);
if (rc != EOK)
goto error;
rc = nchoice_add(choice, sfstype, (void *)(uintptr_t)i,
i == VOL_FSTYPE_DEFAULT);
if (rc != EOK) {
assert(rc == ENOMEM);
printf("Out of memory.\n");
goto error;
}
free(sfstype);
sfstype = NULL;
}
rc = nchoice_get(choice, &sel);
if (rc != EOK) {
printf("Error getting user selection.\n");
goto error;
}
nchoice_destroy(choice);
*fstype = (vol_fstype_t)sel;
return EOK;
error:
free(sfstype);
if (choice != NULL)
nchoice_destroy(choice);
return rc;
}
static errno_t fdsk_create_part(fdisk_dev_t *dev, label_pkind_t pkind)
{
errno_t rc;
fdisk_part_spec_t pspec;
capa_spec_t capa;
capa_spec_t mcapa;
vol_label_supp_t vlsupp;
vol_fstype_t fstype = 0;
tinput_t *tinput = NULL;
fdisk_spc_t spc;
char *scapa;
char *smcapa = NULL;
char *label = NULL;
char *mountp = NULL;
if (pkind == lpk_logical)
spc = spc_log;
else
spc = spc_pri;
rc = fdisk_part_get_max_avail(dev, spc, &mcapa);
if (rc != EOK) {
rc = EIO;
goto error;
}
capa_simplify(&mcapa);
rc = capa_format(&mcapa, &smcapa);
if (rc != EOK) {
rc = ENOMEM;
goto error;
}
tinput = tinput_new();
if (tinput == NULL) {
rc = ENOMEM;
goto error;
}
rc = tinput_set_prompt(tinput, "?> ");
if (rc != EOK)
goto error;
while (true) {
printf("Enter capacity of new partition.\n");
rc = tinput_read_i(tinput, smcapa, &scapa);
if (rc != EOK)
goto error;
rc = capa_parse(scapa, &capa);
if (rc == EOK)
break;
}
tinput_destroy(tinput);
tinput = NULL;
free(smcapa);
smcapa = NULL;
if (pkind != lpk_extended) {
rc = fdsk_select_fstype(&fstype);
if (rc != EOK)
goto error;
}
fdisk_get_vollabel_support(dev, fstype, &vlsupp);
if (vlsupp.supported) {
tinput = tinput_new();
if (tinput == NULL) {
rc = ENOMEM;
goto error;
}
rc = tinput_set_prompt(tinput, "?> ");
if (rc != EOK)
goto error;
printf("Enter volume label for new partition.\n");
rc = tinput_read_i(tinput, "New volume", &label);
if (rc != EOK)
goto error;
tinput_destroy(tinput);
tinput = NULL;
}
tinput = tinput_new();
if (tinput == NULL) {
rc = ENOMEM;
goto error;
}
rc = tinput_set_prompt(tinput, "?> ");
if (rc != EOK)
goto error;
while (true) {
printf("Enter mount point for new partition (Auto, None or /path).\n");
rc = tinput_read_i(tinput, "Auto", &mountp);
if (rc != EOK)
goto error;
rc = vol_mountp_validate(mountp);
if (rc == EOK)
break;
free(mountp);
mountp = NULL;
}
tinput_destroy(tinput);
tinput = NULL;
fdisk_pspec_init(&pspec);
pspec.capacity = capa;
pspec.pkind = pkind;
pspec.fstype = fstype;
pspec.label = label;
pspec.mountp = mountp;
rc = fdisk_part_create(dev, &pspec, NULL);
if (rc != EOK) {
printf("Error creating partition.\n");
goto error;
}
free(label);
free(mountp);
return EOK;
error:
free(smcapa);
free(label);
free(mountp);
if (tinput != NULL)
tinput_destroy(tinput);
return rc;
}
static errno_t fdsk_add_part_choices(fdisk_dev_t *dev,
nchoice_t *choice)
{
fdisk_part_t *part;
fdisk_part_info_t pinfo;
char *scapa = NULL;
char *spkind = NULL;
char *sfstype = NULL;
char *sdesc = NULL;
const char *label;
errno_t rc;
part = fdisk_part_first(dev);
while (part != NULL) {
rc = fdisk_part_get_info(part, &pinfo);
if (rc != EOK) {
printf("Error getting partition information.\n");
goto error;
}
capa_simplify(&pinfo.capacity);
rc = capa_format(&pinfo.capacity, &scapa);
if (rc != EOK) {
printf("Out of memory.\n");
goto error;
}
rc = label_pkind_format(pinfo.pkind, &spkind);
if (rc != EOK) {
printf("\nOut of memory.\n");
goto error;
}
if (pinfo.pkind != lpk_extended) {
rc = vol_pcnt_fs_format(pinfo.pcnt, pinfo.fstype, &sfstype);
if (rc != EOK) {
printf("Out of memory.\n");
goto error;
}
if (str_size(pinfo.label) > 0)
label = pinfo.label;
else
label = "(No name)";
int ret = asprintf(&sdesc, "%s %s, %s, %s", label,
scapa, spkind, sfstype);
if (ret < 0) {
rc = ENOMEM;
goto error;
}
} else {
int ret = asprintf(&sdesc, "%s, %s", scapa, spkind);
if (ret < 0) {
rc = ENOMEM;
goto error;
}
}
rc = nchoice_add(choice, sdesc, (void *)part, 0);
if (rc != EOK) {
assert(rc == ENOMEM);
printf("Out of memory.\n");
goto error;
}
free(scapa);
scapa = NULL;
free(spkind);
spkind = NULL;
free(sfstype);
sfstype = NULL;
free(sdesc);
sdesc = NULL;
part = fdisk_part_next(part);
}
return EOK;
error:
free(scapa);
free(spkind);
free(sfstype);
free(sdesc);
return rc;
}
static errno_t fdsk_modify_mountp(fdisk_part_t *part)
{
tinput_t *tinput = NULL;
errno_t rc;
char *mountp = NULL;
tinput = tinput_new();
if (tinput == NULL) {
rc = ENOMEM;
goto error;
}
rc = tinput_set_prompt(tinput, "?> ");
if (rc != EOK)
goto error;
while (true) {
printf("Enter mount point for new partition (Auto, None or /path).\n");
rc = tinput_read_i(tinput, "Auto", &mountp);
if (rc != EOK)
goto error;
rc = vol_mountp_validate(mountp);
if (rc == EOK)
break;
free(mountp);
mountp = NULL;
}
rc = fdisk_part_set_mountp(part, mountp);
if (rc != EOK)
goto error;
free(mountp);
tinput_destroy(tinput);
tinput = NULL;
return EOK;
error:
if (mountp != NULL)
free(mountp);
if (tinput != NULL)
tinput_destroy(tinput);
return rc;
}
static errno_t fdsk_modify_part(fdisk_dev_t *dev)
{
nchoice_t *choice = NULL;
fdisk_part_t *part;
void *sel;
errno_t rc;
rc = nchoice_create(&choice);
if (rc != EOK) {
assert(rc == ENOMEM);
printf("Out of memory.\n");
goto error;
}
rc = nchoice_set_prompt(choice, "Select partition to modify");
if (rc != EOK) {
assert(rc == ENOMEM);
printf("Out of memory.\n");
goto error;
}
rc = fdsk_add_part_choices(dev, choice);
if (rc != EOK)
goto error;
rc = nchoice_add(choice, "Cancel", NULL, 0);
if (rc != EOK) {
assert(rc == ENOMEM);
printf("Out of memory.\n");
goto error;
}
rc = nchoice_get(choice, &sel);
if (rc == ENOENT)
return EOK;
if (rc != EOK) {
printf("Error getting user selection.\n");
goto error;
}
nchoice_destroy(choice);
choice = NULL;
if (sel == NULL)
return EOK;
part = (fdisk_part_t *)sel;
rc = nchoice_create(&choice);
if (rc != EOK) {
assert(rc == ENOMEM);
printf("Out of memory.\n");
goto error;
}
rc = nchoice_set_prompt(choice, "Select property to modify");
if (rc != EOK) {
assert(rc == ENOMEM);
printf("Out of memory.\n");
goto error;
}
rc = nchoice_add(choice, "Mount point", (void *)pm_mountp, 0);
if (rc != EOK) {
assert(rc == ENOMEM);
printf("Out of memory.\n");
goto error;
}
rc = nchoice_add(choice, "Cancel", (void *)pm_cancel, 0);
if (rc != EOK) {
assert(rc == ENOMEM);
printf("Out of memory.\n");
goto error;
}
rc = nchoice_get(choice, &sel);
if (rc == ENOENT)
return EOK;
if (rc != EOK) {
printf("Error getting user selection.\n");
goto error;
}
nchoice_destroy(choice);
choice = NULL;
switch ((pmprop_t)sel) {
case pm_mountp:
rc = fdsk_modify_mountp(part);
break;
case pm_cancel:
rc = EOK;
break;
}
return rc;
error:
if (choice != NULL)
nchoice_destroy(choice);
return rc;
}
static errno_t fdsk_delete_part(fdisk_dev_t *dev)
{
nchoice_t *choice = NULL;
bool confirm;
void *sel;
errno_t rc;
rc = nchoice_create(&choice);
if (rc != EOK) {
assert(rc == ENOMEM);
printf("Out of memory.\n");
goto error;
}
rc = nchoice_set_prompt(choice, "Select partition to delete");
if (rc != EOK) {
assert(rc == ENOMEM);
printf("Out of memory.\n");
goto error;
}
rc = fdsk_add_part_choices(dev, choice);
if (rc != EOK)
goto error;
rc = nchoice_add(choice, "Cancel", NULL, 0);
if (rc != EOK) {
assert(rc == ENOMEM);
printf("Out of memory.\n");
goto error;
}
rc = nchoice_get(choice, &sel);
if (rc == ENOENT)
return EOK;
if (rc != EOK) {
printf("Error getting user selection.\n");
goto error;
}
nchoice_destroy(choice);
choice = NULL;
if (sel == NULL)
return EOK;
rc = fdsk_confirm("Warning. Any data in partition will be lost. "
"Really delete partition?", &confirm);
if (rc != EOK) {
printf("Error getting user confirmation.\n");
goto error;
}
if (!confirm)
return EOK;
rc = fdisk_part_destroy((fdisk_part_t *)sel);
if (rc != EOK) {
printf("Error deleting partition.\n");
return rc;
}
return EOK;
error:
if (choice != NULL)
nchoice_destroy(choice);
return rc;
}
static errno_t fdsk_dev_menu(fdisk_dev_t *dev)
{
nchoice_t *choice = NULL;
fdisk_label_info_t linfo;
fdisk_part_t *part;
fdisk_part_info_t pinfo;
capa_spec_t capa;
capa_spec_t mcapa;
fdisk_dev_flags_t dflags;
char *sltype = NULL;
char *sdcapa = NULL;
char *scapa = NULL;
char *smcapa = NULL;
char *sfstype = NULL;
char *svcname = NULL;
char *spkind;
const char *label;
errno_t rc;
int npart;
void *sel;
rc = nchoice_create(&choice);
if (rc != EOK) {
assert(rc == ENOMEM);
printf("Out of memory.\n");
goto error;
}
rc = nchoice_set_prompt(choice, "Select action");
if (rc != EOK) {
assert(rc == ENOMEM);
printf("Out of memory.\n");
goto error;
}
rc = fdisk_dev_capacity(dev, &capa);
if (rc != EOK) {
printf("Error getting device capacity.\n");
goto error;
}
capa_simplify(&capa);
rc = capa_format(&capa, &sdcapa);
if (rc != EOK) {
printf("Out of memory.\n");
goto error;
}
rc = fdisk_dev_get_svcname(dev, &svcname);
if (rc != EOK) {
printf("Error getting device service name.\n");
goto error;
}
fdisk_dev_get_flags(dev, &dflags);
printf("Device: %s (%s)\n", svcname, sdcapa);
free(sdcapa);
sdcapa = NULL;
rc = fdisk_label_get_info(dev, &linfo);
if (rc != EOK) {
printf("Error getting label information.\n");
goto error;
}
switch (linfo.ltype) {
case lt_none:
printf("Disk contains no label.\n");
break;
default:
rc = label_type_format(linfo.ltype, &sltype);
if (rc != EOK) {
assert(rc == ENOMEM);
printf("Out of memory.\n");
goto error;
}
printf("Label type: %s\n", sltype);
free(sltype);
sltype = NULL;
break;
}
part = fdisk_part_first(dev);
npart = 0;
while (part != NULL) {
++npart;
rc = fdisk_part_get_info(part, &pinfo);
if (rc != EOK) {
printf("Error getting partition information.\n");
goto error;
}
capa_simplify(&pinfo.capacity);
rc = capa_format(&pinfo.capacity, &scapa);
if (rc != EOK) {
printf("Out of memory.\n");
goto error;
}
rc = vol_pcnt_fs_format(pinfo.pcnt, pinfo.fstype, &sfstype);
if (rc != EOK) {
printf("Out of memory.\n");
goto error;
}
if (str_size(pinfo.label) > 0)
label = pinfo.label;
else
label = "(No name)";
if (linfo.ltype == lt_none)
printf("Entire disk: %s %s", label, scapa);
else
printf("Partition %d: %s %s", npart, label, scapa);
if ((linfo.flags & lf_ext_supp) != 0) {
rc = label_pkind_format(pinfo.pkind, &spkind);
if (rc != EOK) {
printf("\nOut of memory.\n");
goto error;
}
printf(", %s", spkind);
free(spkind);
}
if (pinfo.pkind != lpk_extended) {
printf(", %s", sfstype);
}
printf("\n");
free(scapa);
scapa = NULL;
free(sfstype);
sfstype = NULL;
part = fdisk_part_next(part);
}
if ((linfo.flags & lf_can_create_pri) != 0) {
rc = fdisk_part_get_max_avail(dev, spc_pri, &mcapa);
if (rc != EOK) {
rc = EIO;
goto error;
}
capa_simplify(&mcapa);
rc = capa_format(&mcapa, &smcapa);
if (rc != EOK) {
rc = ENOMEM;
goto error;
}
if ((linfo.flags & lf_ext_supp) != 0)
printf("Maximum free primary block: %s\n", smcapa);
else
printf("Maximum free block: %s\n", smcapa);
free(smcapa);
smcapa = NULL;
rc = fdisk_part_get_tot_avail(dev, spc_pri, &mcapa);
if (rc != EOK) {
rc = EIO;
goto error;
}
capa_simplify(&mcapa);
rc = capa_format(&mcapa, &smcapa);
if (rc != EOK) {
rc = ENOMEM;
goto error;
}
if ((linfo.flags & lf_ext_supp) != 0)
printf("Total free primary space: %s\n", smcapa);
else
printf("Total free space: %s\n", smcapa);
free(smcapa);
smcapa = NULL;
}
if ((linfo.flags & lf_can_create_log) != 0) {
rc = fdisk_part_get_max_avail(dev, spc_log, &mcapa);
if (rc != EOK) {
rc = EIO;
goto error;
}
capa_simplify(&mcapa);
rc = capa_format(&mcapa, &smcapa);
if (rc != EOK) {
rc = ENOMEM;
goto error;
}
printf("Maximum free logical block: %s\n", smcapa);
free(smcapa);
smcapa = NULL;
rc = fdisk_part_get_tot_avail(dev, spc_log, &mcapa);
if (rc != EOK) {
rc = EIO;
goto error;
}
capa_simplify(&mcapa);
rc = capa_format(&mcapa, &smcapa);
if (rc != EOK) {
rc = ENOMEM;
goto error;
}
printf("Total free logical space: %s\n", smcapa);
free(smcapa);
smcapa = NULL;
}
rc = nchoice_set_prompt(choice, "Select action");
if (rc != EOK) {
assert(rc == ENOMEM);
printf("Out of memory.\n");
goto error;
}
if ((linfo.flags & lf_ext_supp) != 0) {
if ((linfo.flags & lf_can_create_pri) != 0) {
rc = nchoice_add(choice, "Create primary "
"partition",
(void *)devac_create_pri_part, 0);
if (rc != EOK) {
assert(rc == ENOMEM);
printf("Out of memory.\n");
goto error;
}
}
if ((linfo.flags & lf_can_create_ext) != 0) {
rc = nchoice_add(choice, "Create extended "
"partition",
(void *)devac_create_ext_part, 0);
if (rc != EOK) {
assert(rc == ENOMEM);
printf("Out of memory.\n");
goto error;
}
}
if ((linfo.flags & lf_can_create_log) != 0) {
rc = nchoice_add(choice, "Create logical "
"partition",
(void *)devac_create_log_part, 0);
if (rc != EOK) {
assert(rc == ENOMEM);
printf("Out of memory.\n");
goto error;
}
}
} else {
if ((linfo.flags & lf_can_create_pri) != 0) {
rc = nchoice_add(choice, "Create partition",
(void *)devac_create_pri_part, 0);
if (rc != EOK) {
assert(rc == ENOMEM);
printf("Out of memory.\n");
goto error;
}
}
}
if ((linfo.flags & lf_can_modify_part) != 0) {
rc = nchoice_add(choice, "Modify partition",
(void *)devac_modify_part, 0);
if (rc != EOK) {
assert(rc == ENOMEM);
printf("Out of memory.\n");
goto error;
}
}
if ((linfo.flags & lf_can_delete_part) != 0) {
rc = nchoice_add(choice, "Delete partition",
(void *)devac_delete_part, 0);
if (rc != EOK) {
assert(rc == ENOMEM);
printf("Out of memory.\n");
goto error;
}
}
if ((dflags & fdf_can_create_label) != 0) {
rc = nchoice_add(choice, "Create label",
(void *)devac_create_label, 0);
if (rc != EOK) {
assert(rc == ENOMEM);
printf("Out of memory.\n");
goto error;
}
}
if ((dflags & fdf_can_delete_label) != 0) {
rc = nchoice_add(choice, "Delete label",
(void *)devac_delete_label, 0);
if (rc != EOK) {
assert(rc == ENOMEM);
printf("Out of memory.\n");
goto error;
}
}
if ((dflags & fdf_can_erase_dev) != 0) {
rc = nchoice_add(choice, "Erase disk",
(void *)devac_erase_disk, 0);
if (rc != EOK) {
assert(rc == ENOMEM);
printf("Out of memory.\n");
goto error;
}
}
rc = nchoice_add(choice, "Exit", (void *)devac_exit, 0);
if (rc != EOK) {
assert(rc == ENOMEM);
printf("Out of memory.\n");
goto error;
}
rc = nchoice_get(choice, &sel);
if (rc != EOK) {
printf("Error getting user selection.\n");
return rc;
}
switch ((devac_t)sel) {
case devac_create_label:
(void) fdsk_create_label(dev);
break;
case devac_delete_label:
(void) fdsk_delete_label(dev);
break;
case devac_erase_disk:
(void) fdsk_erase_disk(dev);
break;
case devac_create_pri_part:
(void) fdsk_create_part(dev, lpk_primary);
break;
case devac_create_ext_part:
(void) fdsk_create_part(dev, lpk_extended);
break;
case devac_create_log_part:
(void) fdsk_create_part(dev, lpk_logical);
break;
case devac_modify_part:
(void) fdsk_modify_part(dev);
break;
case devac_delete_part:
(void) fdsk_delete_part(dev);
break;
case devac_exit:
quit = true;
break;
}
nchoice_destroy(choice);
return EOK;
error:
free(sdcapa);
free(scapa);
free(smcapa);
free(sfstype);
free(svcname);
if (choice != NULL)
nchoice_destroy(choice);
return rc;
}
int main(int argc, char *argv[])
{
service_id_t svcid;
fdisk_dev_t *dev;
errno_t rc;
rc = fdisk_create(&fdisk);
if (rc != EOK) {
printf("Error initializing Fdisk.\n");
return 1;
}
rc = fdsk_dev_sel_choice(&svcid);
if (rc != EOK)
return 1;
if (svcid == 0)
return 0;
rc = fdisk_dev_open(fdisk, svcid, &dev);
if (rc != EOK) {
printf("Error opening device.\n");
return 1;
}
while (!quit) {
rc = fdsk_dev_menu(dev);
if (rc != EOK) {
fdisk_dev_close(dev);
return 1;
}
}
fdisk_dev_close(dev);
fdisk_destroy(fdisk);
return 0;
}
HelenOS homepage, sources at GitHub