static void
populate_create_subpartitions_form(struct dfui_form *f, struct i_fn_args *a)
{
struct subpartition *sp;
struct dfui_dataset *ds;
int i;
long capacity;
if (slice_subpartition_first(storage_get_selected_slice(a->s)) != NULL) {
/*
* The user has already given us their subpartition
* preferences, so use them here.
*/
for (sp = slice_subpartition_first(storage_get_selected_slice(a->s));
sp != NULL; sp = subpartition_next(sp)) {
ds = dfui_dataset_new();
dfui_dataset_celldata_add(ds, "mountpoint",
subpartition_get_mountpoint(sp));
dfui_dataset_celldata_add(ds, "capacity",
capacity_to_string(subpartition_get_capacity(sp)));
dfui_dataset_celldata_add(ds, "encrypted",
subpartition_is_encrypted(sp) ? "Y" : "N");
dfui_form_dataset_add(f, ds);
}
} else {
/*
* Otherwise, populate the form with datasets representing
* reasonably-calculated defaults. The defaults are chosen
* based on the slice's total capacity and the machine's
* total physical memory (for swap.)
*/
for (i = 0; def_mountpt[i] != NULL; i++) {
capacity = default_capacity(a->s, def_mountpt[i]);
ds = dfui_dataset_new();
dfui_dataset_celldata_add(ds, "mountpoint",
def_mountpt[i]);
dfui_dataset_celldata_add(ds, "capacity",
capacity_to_string(capacity));
dfui_dataset_celldata_add(ds, "encrypted", "N");
dfui_form_dataset_add(f, ds);
}
}
}
/*
* Returns:
* -1 = the form should be redisplayed
* 0 = failure, function is over
* 1 = success, function is over
*/
static int
show_create_subpartitions_form(struct dfui_form *f, struct i_fn_args *a)
{
struct dfui_dataset *ds;
struct dfui_response *r;
for (;;) {
if (dfui_form_dataset_get_first(f) == NULL)
populate_create_subpartitions_form(f, a);
if (!dfui_be_present(a->c, f, &r))
abort_backend();
if (strcmp(dfui_response_get_action_id(r), "cancel") == 0) {
dfui_response_free(r);
return(0);
} else if (strcmp(dfui_response_get_action_id(r), "switch") == 0) {
if (check_subpartition_selections(r, a)) {
save_subpartition_selections(r, a);
expert = expert ? 0 : 1;
dfui_response_free(r);
return(-1);
}
} else {
if (check_subpartition_selections(r, a)) {
save_subpartition_selections(r, a);
if (!warn_subpartition_selections(a) &&
!warn_encrypted_boot(a)) {
if (!create_subpartitions(a)) {
inform(a->c, _("The subpartitions you chose were "
"not correctly created, and the "
"primary partition may "
"now be in an inconsistent state. "
"We recommend re-formatting it "
"before proceeding."));
dfui_response_free(r);
return(0);
} else {
dfui_response_free(r);
return(1);
}
}
}
}
dfui_form_datasets_free(f);
/* dfui_form_datasets_add_from_response(f, r); */
for (ds = dfui_response_dataset_get_first(r); ds != NULL;
ds = dfui_dataset_get_next(ds)) {
dfui_form_dataset_add(f, dfui_dataset_dup(ds));
}
}
}
void
fn_memtest(struct i_fn_args *a)
{
struct dfui_form *f;
struct dfui_response *r;
struct dfui_dataset *ds, *new_ds;
struct commands *cmds;
struct command *cmd;
const char *memtestsize;
f = dfui_form_create(
"memtest",
_("Memory test"),
_("Memory test - Enter the size in values such as 400M, 1G."),
"",
"f", "memtestsize", _("Memory test size"),
_("Enter the amount of memory you would like to check:"), "",
"a", "ok", _("OK"), "", "",
"a", "cancel", _("Cancel Memory Test"), "", "",
"p", "accelerator", "ESC",
NULL
);
ds = dfui_dataset_new();
dfui_dataset_celldata_add(ds, "memtestsize", "");
dfui_form_dataset_add(f, ds);
if (!dfui_be_present(a->c, f, &r))
abort_backend();
if (strcmp(dfui_response_get_action_id(r), "ok") == 0) {
new_ds = dfui_response_dataset_get_first(r);
memtestsize = dfui_dataset_get_value(new_ds, "memtestsize");
cmds = commands_new();
cmd = command_add(cmds,
"cd %s && %s%s %s 1 --log",
a->tmp,
a->os_root, cmd_name(a, "MEMTEST"),
memtestsize);
command_set_log_mode(cmd, COMMAND_LOG_QUIET);
cmd = command_add(cmds,
"%s%s -E -v '^Unable to malloc' %smemtest.log > %smemtest.log.new",
a->os_root, cmd_name(a, "GREP"),
a->tmp, a->tmp);
cmd = command_add(cmds, "%s%s %smemtest.log.new %smemtest.log",
a->os_root, cmd_name(a, "MV"),
a->tmp, a->tmp);
cmd = command_add(cmds,
"%s%s -E -v '^Allocated.*failed' %smemtest.log > %smemtest.log.new",
a->os_root, cmd_name(a, "GREP"),
a->tmp, a->tmp);
cmd = command_add(cmds, "%s%s %smemtest.log.new %smemtest.log",
a->os_root, cmd_name(a, "MV"),
a->tmp, a->tmp);
if (commands_execute(a, cmds)) {
commands_free(cmds);
view_memtest_log(a);
cmds = commands_new();
cmd = command_add(cmds, "%s%s -f %smemtest.log",
a->os_root, cmd_name(a, "RM"),
a->tmp);
commands_execute(a, cmds);
} else {
inform(a->c, _("Memory test could not be run."));
}
commands_free(cmds);
}
dfui_form_free(f);
dfui_response_free(r);
}
void
fn_install_bootblocks(struct i_fn_args *a, const char *device)
{
struct dfui_form *f;
struct dfui_response *r;
struct dfui_dataset *ds;
struct disk *d;
struct commands *cmds;
struct command *cmd;
char disk[64], boot0cfg[32], packet[32];
char msg_buf[1][1024];
snprintf(msg_buf[0], sizeof(msg_buf[0]),
"'Packet Mode' refers to using newer BIOS calls to boot "
"from a partition of the disk. It is generally not "
"required unless:\n\n"
"- your BIOS does not support legacy mode; or\n"
"- your %s primary partition resides on a "
"cylinder of the disk beyond cylinder 1024; or\n"
"- you just can't get it to boot without it.",
OPERATING_SYSTEM_NAME);
f = dfui_form_create(
"install_bootstrap",
_("Install Bootblock(s)"),
a->short_desc,
msg_buf[0],
"p", "special", "dfinstaller_install_bootstrap",
"f", "disk", _("Disk Drive"),
_("The disk on which you wish to install a bootblock"), "",
"p", "editable", "false",
"f", "boot0cfg", _("Install Bootblock?"),
_("Install a bootblock on this disk"), "",
"p", "control", "checkbox",
"f", "packet", _("Packet Mode?"),
_("Select this to use 'packet mode' to boot the disk"), "",
"p", "control", "checkbox",
"a", "ok", _("Accept and Install Bootblocks"), "", "",
"a", "cancel", a->cancel_desc, "", "",
"p", "accelerator", "ESC",
NULL
);
dfui_form_set_multiple(f, 1);
if (device != NULL) {
ds = dfui_dataset_new();
dfui_dataset_celldata_add(ds, "disk", device);
dfui_dataset_celldata_add(ds, "boot0cfg", "Y");
dfui_dataset_celldata_add(ds, "packet", "Y");
dfui_form_dataset_add(f, ds);
} else {
for (d = storage_disk_first(a->s); d != NULL; d = disk_next(d)) {
ds = dfui_dataset_new();
dfui_dataset_celldata_add(ds, "disk",
disk_get_device_name(d));
dfui_dataset_celldata_add(ds, "boot0cfg", "Y");
dfui_dataset_celldata_add(ds, "packet", "Y");
dfui_form_dataset_add(f, ds);
}
}
if (!dfui_be_present(a->c, f, &r))
abort_backend();
a->result = 0;
if (strcmp(dfui_response_get_action_id(r), "ok") == 0) {
cmds = commands_new();
for (ds = dfui_response_dataset_get_first(r); ds != NULL;
ds = dfui_dataset_get_next(ds)) {
strlcpy(disk, dfui_dataset_get_value(ds, "disk"), 64);
strlcpy(boot0cfg, dfui_dataset_get_value(ds, "boot0cfg"), 32);
strlcpy(packet, dfui_dataset_get_value(ds, "packet"), 32);
if (strcasecmp(boot0cfg, "Y") == 0) {
cmd = command_add(cmds, "%s%s -B -o %spacket %s",
a->os_root, cmd_name(a, "BOOT0CFG"),
strcasecmp(packet, "Y") == 0 ? "" : "no",
disk);
command_set_failure_mode(cmd, COMMAND_FAILURE_WARN);
command_set_tag(cmd, "%s", disk);
cmd = command_add(cmds, "%s%s -v %s",
a->os_root, cmd_name(a, "BOOT0CFG"),
disk);
command_set_failure_mode(cmd, COMMAND_FAILURE_WARN);
command_set_tag(cmd, "%s", disk);
}
}
if (!commands_execute(a, cmds)) {
ask_to_wipe_boot_sector(a, cmds);
} else {
inform(a->c, _("Bootblocks were successfully installed!"));
a->result = 1;
}
commands_free(cmds);
}
dfui_form_free(f);
dfui_response_free(r);
}
/*
* Pop a Lua table representing a DFUI form from the Lua stack,
* create a new DFUI form from it, and return it.
*/
static struct dfui_form *
dfui_form_from_lua_table(lua_State *L, int table_idx)
{
struct dfui_form *f;
struct dfui_action *a;
struct dfui_field *fi;
struct dfui_dataset *ds;
const char *id, *name, *short_desc, *long_desc;
int list_idx, subtable_idx, counter, done;
/*
* Get the basic properties of the form.
*/
id = lua_access_table_string(L, table_idx, "id");
name = lua_access_table_string(L, table_idx, "name");
short_desc = lua_access_table_string(L, table_idx, "short_desc");
long_desc = lua_access_table_string(L, table_idx, "long_desc");
/*
* Create the initial form.
*/
f = dfui_form_new(id, dfui_info_new(name, short_desc, long_desc));
set_dfui_properties_from_lua_table(L, table_idx, DFUI_OBJ_FORM, f);
/*
* Get the list of actions attached to the form.
*/
lua_pushliteral(L, "actions");
lua_gettable(L, table_idx);
list_idx = lua_gettop(L);
if (lua_istable(L, list_idx)) {
/*
* Loop through all entries in this table, creating
* and attaching a new action for each one.
*/
counter = 1;
done = 0;
while (!done) {
lua_pushnumber(L, counter++);
lua_gettable(L, list_idx);
subtable_idx = lua_gettop(L);
if (lua_istable(L, subtable_idx)) {
a = dfui_action_from_lua_table(L, subtable_idx);
dfui_form_action_attach(f, a);
} else {
done = 1;
}
}
} else {
/* No actions */
}
lua_pop(L, 1);
/*
* Get the list of fields attached to the form.
*/
lua_pushliteral(L, "fields");
lua_gettable(L, table_idx);
list_idx = lua_gettop(L);
if (lua_istable(L, list_idx)) {
/*
* Loop through all entries in this table, creating
* and attaching a new field for each one.
*/
counter = 1;
done = 0;
while (!done) {
lua_pushnumber(L, counter++);
lua_gettable(L, list_idx);
subtable_idx = lua_gettop(L);
if (lua_istable(L, subtable_idx)) {
fi = dfui_field_from_lua_table(L, subtable_idx);
dfui_form_field_attach(f, fi);
} else {
done = 1;
}
}
} else {
/* No fields */
}
lua_pop(L, 1);
/*
* Get the list of datasets attached to the form.
*/
lua_pushliteral(L, "datasets");
lua_gettable(L, table_idx);
list_idx = lua_gettop(L);
if (lua_istable(L, list_idx)) {
/*
* Loop through all entries in this table, creating
* and attaching a new dataset for each one.
*/
counter = 1;
done = 0;
while (!done) {
lua_pushnumber(L, counter++);
lua_gettable(L, list_idx);
subtable_idx = lua_gettop(L);
if (lua_istable(L, subtable_idx)) {
ds = dfui_dataset_from_lua_table(L, subtable_idx);
dfui_form_dataset_add(f, ds);
} else {
done = 1;
}
}
} else {
/* No datasets */
}
lua_pop(L, 1);
/*
* Finally, delete the table representing the form by
* popping it from the top of the stack.
*/
lua_pop(L, 1);
return(f);
}