Changeset 3879 in MondoRescue for branches/3.3/mondo/src/mondorestore/mondo-rstr-newt.c

Timestamp:

Mar 9, 2024, 3:10:04 AM (3 months ago)

Author:

Bruno Cornec

Message:

Fix all remaining compiler errors

File:

• branches/3.3/mondo/src/mondorestore/mondo-rstr-newt.c (modified) (14 diffs)

branches/3.3/mondo/src/mondorestore/mondo-rstr-newt.c

@@ -10 +10 @@
 #endif
 
-#include "mondo-rstr-newt.h"
+#include "my-stuff.h"
+#include "mondostructures.h"
 #include "mr_mem.h"
 #include "mr_str.h"
+#include "libmondo-raid-EXT.h"
+#include "libmondo-mountlist-EXT.h"
+#include "libmondo-string-EXT.h"
+#include "libmondo-tools-EXT.h"
+#include "libmondo-files-EXT.h"
+#include "libmondo-filelist-EXT.h"
+#include "newt-specific-EXT.h"
 
 //static char cvsid[] = "$Id$";
@@ -18 +26 @@
 extern bool popup_with_buttons(char *p, char *button1, char *button2);
 extern char err_log_lines[NOOF_ERR_LINES][MAX_STR_LEN];
+
+static char g_strings_of_flist_window[ARBITRARY_MAXIMUM][MAX_STR_LEN];
+static bool g_is_path_selected[ARBITRARY_MAXIMUM];
+static bool g_is_path_expanded[ARBITRARY_MAXIMUM];
+static char tmpnopath[MAX_STR_LEN + 2];
+static char tmpprevpath[MAX_STR_LEN + 2];
+
+// from mondo-rstr-mountlist.c
+extern void make_list_of_unallocated_raid_partitions(struct mountlist_itself *, struct mountlist_itself *, struct raidlist_itself *);
+
+extern bool g_text_mode;
+
 
 /**
@@ -36 +56 @@
 
 /**
- * @addtogroup restoreGuiGroup
- * @{
- */
+ * Redraw the list of unallocated RAID partitions.
+ * @param unallocated_raid_partitions The mountlist containing unallocated RAID partitions.
+ * @param keylist The list of keys for @p listbox.
+ * @param listbox The Newt listbox component to redraw.
+ * @ingroup restoreGuiDisklist
+ */
+void redraw_unallocpartnslist(struct mountlist_itself
+                              *unallocated_raid_partitions,
+                              void *keylist[ARBITRARY_MAXIMUM],
+                              newtComponent listbox)
+{
+
+    /** long *************************************************************/
+    long i = 0;
+
+    /** buffers **********************************************************/
+    char tmp[MAX_STR_LEN];
+
+    assert(unallocated_raid_partitions != NULL);
+    assert(keylist != NULL);
+    assert(listbox != NULL);
+
+    newtListboxClear(listbox);
+    for (i = 0; i < ARBITRARY_MAXIMUM; i++) {
+        keylist[i] = (void *) i;
+    }
+    for (i = 0; i < unallocated_raid_partitions->entries; i++) {
+        sprintf(tmp, "%-22s %8lld",
+                unallocated_raid_partitions->el[i].device,
+                unallocated_raid_partitions->el[i].size / 1024L);
+        newtListboxAppendEntry(listbox, tmp, keylist[i]);
+    }
+}
+
+
+/**
+ * Find the next free location to place a disk in @p disklist.
+ * @param disklist The disklist to operate on.
+ * @return The next free location (starting from 0).
+ * @ingroup restoreGuiDisklist
+ */
+int find_next_free_index_in_disklist(struct list_of_disks *disklist)
+{
+
+    /** int ***************************************************************/
+    int index = -1;
+    int pos = 0;
+
+  /** bool **************************************************************/
+    bool done;
+
+    assert(disklist != NULL);
+
+    for (done = FALSE; !done;) {
+        for (pos = 0;
+             pos < disklist->entries && disklist->el[pos].index <= index;
+             pos++);
+        if (pos >= disklist->entries) {
+            done = TRUE;
+        } else {
+            index = disklist->el[pos].index;
+        }
+    }
+    return (index + 1);
+}
+
+
+
 /**
  * Add an entry in @p disklist from the list in @p unallocated_raid_partitions.
@@ -118 +203 @@
 
 
-
-
-/**
- * Add an entry to @p mountlist.
- * @param mountlist The mountlist to add an entry to.
- * @param raidlist The raidlist that accompanies @p mountlist.
- * @param listbox The listbox component in the mountlist editor.
- * @param currline The line selected in @p listbox.
+/**
+ * Locate @p device in @p raidlist.
+ * @param raidlist The raidlist ot search in.
+ * @param device The RAID device to search for.
+ * @return The index of the device, or -1 if it could not be found.
+ * @ingroup restoreGuiMountlist
+ */
+int
+find_raid_device_in_raidlist(struct raidlist_itself *raidlist,
+                             char *device)
+{
+
+    /** int ***************************************************************/
+    int i = 0;
+#ifdef __FreeBSD__
+    char *vdev = NULL;
+    int res = 0;
+#else
+// Linux
+#endif
+
+    assert(raidlist != NULL);
+    assert_string_is_neither_NULL_nor_zerolength(device);
+
+#ifdef __FreeBSD__
+    for (i = 0; i < raidlist->entries; i++) {
+        mr_asprintf(vdev, "/dev/vinum/%s", raidlist->el[i].volname);
+        res = strcmp(device, vdev);
+        mr_free(vdev);
+
+        if (!res)
+            break;
+    }
+#else
+
+    for (i = 0;
+         strcmp(raidlist->el[i].raid_device, device)
+         && i < raidlist->entries; i++);
+#endif
+    if (i == raidlist->entries) {
+        return (-1);
+    } else {
+        return (i);
+    }
+}
+
+
+/**
+ * Redraw the disklist.
+ * @param disklist The disklist to read from.
  * @param keylist The list of keys for @p listbox.
+ * @param listbox The Newt listbox component to redraw.
+ * @ingroup restoreGuiDisklist
+ */
+void
+redraw_disklist(struct list_of_disks *disklist,
+                void *keylist[ARBITRARY_MAXIMUM], newtComponent listbox)
+{
+
+    /** long **************************************************************/
+    long i = 0;
+    char *tmp = NULL;
+
+    assert(disklist != NULL);
+    assert(keylist != NULL);
+    assert(listbox != NULL);
+
+    newtListboxClear(listbox);
+
+    for (i = 0; i < ARBITRARY_MAXIMUM; i++) {
+        keylist[i] = (void *) i;
+    }
+    for (i = 0; i < disklist->entries; i++) {
+        tmp = disklist_entry_to_string(disklist, i);
+        newtListboxAppendEntry(listbox, tmp, keylist[i]);
+        mr_free(tmp);
+    }
+}
+
+
+
+/**
+ * Delete entry number @p currline from @p disklist.
+ * @param disklist The disklist to remove the entry from.
+ * @param raid_device The RAID device containing the partition we're removing.
+ * Used only in the popup "are you sure?" box.
+ * @param currline The line number (starting from 0) of the item to delete.
+ * @ingroup restoreGuiDisklist
+ */
+void
+delete_disklist_entry(struct list_of_disks *disklist, char *raid_device,
+                      int currline)
+{
+
+    /** int ***************************************************************/
+    int pos = 0;
+    int res = 0;
+
+    /** buffers ***********************************************************/
+    char *tmp = NULL;
+
+    assert(disklist != NULL);
+    assert_string_is_neither_NULL_nor_zerolength(raid_device);
+
+    mr_asprintf(tmp, "Delete %s from RAID device %s - are you sure?", disklist->el[currline].device, raid_device);
+    res = ask_me_yes_or_no(tmp);
+    mr_free(tmp);
+
+    if (!res) {
+        return;
+    }
+    for (pos = currline; pos < disklist->entries - 1; pos++) {
+        strcpy(disklist->el[pos].device, disklist->el[pos + 1].device);
+    }
+    disklist->entries--;
+}
+
+
+
+/**
+ * Select the RAID disks to use in @p raidrec.
+ * @param mountlist_dontedit The mountlist (will not be edited).
+ * @param raidlist The raidlist to modify.
+ * @param raidrec The RAID device record in @p raidlist to work on.
+ * @param description_of_list The type of disks we're selecting (e.g. "data").
+ * @param disklist The disklist to put the user-selected disks in.
  * @ingroup restoreGuiMountlist
  */
 void
-add_mountlist_entry(struct mountlist_itself *mountlist,
-                    struct raidlist_itself *raidlist,
-                    newtComponent listbox, int currline, void *keylist[])
+select_raid_disks(struct mountlist_itself *mountlist_dontedit,
+                  struct raidlist_itself *raidlist,
+                  struct raid_device_record *raidrec,
+                  char *description_of_list,
+                  struct list_of_disks *disklist)
+{
+    void *curr_choice;
+
+    /** ??? ***************************************************************/
+
+    /** structures ********************************************************/
+    struct raidlist_itself *bkp_raidlist;
+    struct raid_device_record *bkp_raidrec;
+    struct list_of_disks *bkp_disklist;
+    struct mountlist_itself *unallocated_raid_partitions;
+
+    /** newt **************************************************************/
+    newtComponent myForm = NULL;
+    newtComponent bAdd = NULL;
+    newtComponent bDelete = NULL;
+    newtComponent bOK = NULL;
+    newtComponent bCancel = NULL;
+    newtComponent b_res = NULL;
+    newtComponent partitionsListbox = NULL;
+    newtComponent headerMsg = NULL;
+
+    /** buffers **********************************************************/
+    void *keylist[ARBITRARY_MAXIMUM];
+    char *tmp = NULL;
+    char *help_text = NULL;
+    char *title_of_window = NULL;
+    char sz_res[MAX_STR_LEN];
+    char *header_text = NULL;
+
+  /** int **************************************************************/
+    int i = 0;
+    int currline = 0;
+
+    assert(mountlist_dontedit != NULL);
+    assert(raidlist != NULL);
+    assert(raidrec != NULL);
+    assert(description_of_list != NULL);
+    assert(disklist != NULL);
+
+    log_it("malloc'ing");
+    bkp_raidrec = mr_malloc(sizeof(struct raid_device_record));
+    bkp_disklist = mr_malloc(sizeof(struct list_of_disks));
+    bkp_raidlist = mr_malloc(sizeof(struct raidlist_itself));
+    unallocated_raid_partitions = mr_malloc(sizeof(struct mountlist_itself));
+
+    memcpy((void *) bkp_raidlist, (void *) raidlist, sizeof(struct raidlist_itself));
+    memcpy((void *) bkp_raidrec, (void *) raidrec, sizeof(struct raid_device_record));
+    memcpy((void *) bkp_disklist, (void *) disklist, sizeof(struct list_of_disks));
+
+    log_it("Post-malloc");
+    mr_asprintf(help_text, "   Edit this RAID device's list of partitions. Choose OK or Cancel when done.");
+    mr_asprintf(header_text, "%-24s    %s", "Device", "Index");
+    mr_asprintf(title_of_window, "%s contains...", raidrec->raid_device);
+    newtPushHelpLine(help_text);
+    for (b_res = (newtComponent) 12345; b_res != bOK && b_res != bCancel;) {
+        headerMsg = newtLabel(1, 1, header_text);
+        partitionsListbox =
+            newtListbox(1, 2, 6, NEWT_FLAG_SCROLL | NEWT_FLAG_RETURNEXIT);
+        redraw_disklist(disklist, keylist, partitionsListbox);
+        i = 1;
+        bAdd = newtCompactButton(i, 9, " Add ");
+        bDelete = newtCompactButton(i += 8, 9, "Delete");
+        bOK = newtCompactButton(i += 9, 9, "  OK  ");
+        bCancel = newtCompactButton(i += 9, 9, "Cancel");
+        newtOpenWindow(21, 7, 38, 10, title_of_window);
+        myForm = newtForm(NULL, NULL, 0);
+        if (disklist->entries == 0) {
+            newtFormAddComponents(myForm, headerMsg, bAdd, bDelete, bOK,
+                                  bCancel, NULL);
+        } else {
+            newtFormAddComponents(myForm, headerMsg, partitionsListbox,
+                                  bAdd, bDelete, bOK, bCancel, NULL);
+        }
+        b_res = newtRunForm(myForm);
+        if (b_res == bOK || b_res == bCancel) { /* do nothing */
+// That's OK. At the end of this subroutine (after this do/while loop),
+// we'll throw away the changes if Cancel was pushed.
+        } else {
+            curr_choice = newtListboxGetCurrent(partitionsListbox);
+            for (i = 0; i < disklist->entries && keylist[i] != curr_choice;
+                 i++);
+            if (i == disklist->entries && disklist->entries > 0) {
+                log_to_screen("I don't know what that button does!");
+            } else {
+                currline = i;
+                if (b_res == bAdd) {
+                    log_it("Making list of unallocated RAID slices");
+                    make_list_of_unallocated_raid_partitions
+                        (unallocated_raid_partitions, mountlist_dontedit,
+                         raidlist);
+                    if (unallocated_raid_partitions->entries <= 0) {
+                        popup_and_OK
+                            ("There are no unallocated partitions marked for RAID.");
+                    } else {
+                        log_it
+                            ("Done. The user may add one or more of the above to RAID device");
+                        add_disklist_entry(disklist, raidrec->raid_device,
+                                           unallocated_raid_partitions);
+                        log_it("I have finished adding a disklist entry.");
+                        redraw_disklist(disklist, keylist,
+                                        partitionsListbox);
+                    }
+                } else if (b_res == bDelete) {
+                    delete_disklist_entry(disklist, raidrec->raid_device,
+                                          currline);
+                    redraw_disklist(disklist, keylist, partitionsListbox);
+                } else {
+                    mr_asprintf(tmp, "%s's index is %d. What should it be?", raidrec->raid_device, disklist->el[currline].index);
+                    sprintf(sz_res, "%d", disklist->el[currline].index);
+                    if (popup_and_get_string("Set index", tmp, sz_res, 10)) {
+                        disklist->el[currline].index = atoi(sz_res);
+                    }
+                    mr_free(tmp);
+
+                    redraw_disklist(disklist, keylist, partitionsListbox);
+                }
+            }
+        }
+        newtFormDestroy(myForm);
+        newtPopWindow();
+    }
+    newtPopHelpLine();
+    mr_free(help_text);
+    mr_free(header_text);
+    mr_free(title_of_window);
+
+    if (b_res == bCancel) {
+        memcpy((void *) raidlist, (void *) bkp_raidlist, sizeof(struct raidlist_itself));
+        memcpy((void *) raidrec, (void *) bkp_raidrec, sizeof(struct raid_device_record));
+        memcpy((void *) disklist, (void *) bkp_disklist, sizeof(struct list_of_disks));
+    }
+    mr_free(bkp_raidrec);
+    mr_free(bkp_disklist);
+    mr_free(bkp_raidlist);
+    mr_free(unallocated_raid_partitions);
+}
+
+
+#ifndef __FreeBSD__
+/**
+ * Insert the RAID variables not stored in the "additional RAID variables" list there too.
+ * @param raidrec The RAID device record to operate on.
+ * @ingroup restoreGuiVarslist
+ */
+void insert_essential_additionalvars(struct raid_device_record *raidrec)
 {
 
     /** int **************************************************************/
+    int items = 0;
+
+    assert(raidrec != NULL);
+
+    items = raidrec->additional_vars.entries;
+    write_variableINT_to_raid_var_line(raidrec, items++,
+                                       "persistent-superblock",
+                                       raidrec->persistent_superblock);
+    write_variableINT_to_raid_var_line(raidrec, items++, "chunk-size",
+                                       raidrec->chunk_size);
+    raidrec->additional_vars.entries = items;
+}
+
+#endif
+
+
+#ifndef __FreeBSD__
+/**
+ * Redraw the list of additional RAID variables.
+ * @param additional_vars The list of additional RAID varibals.
+ * @param keylist The list of keys for @p listbox.
+ * @param listbox The Newt listbox component to redraw.
+ * @ingroup restoreGuiVarslist
+ */
+void
+redraw_varslist(struct additional_raid_variables *additional_vars,
+                void *keylist[], newtComponent listbox)
+{
+    /** long ************************************************************/
+    long i = 0;
+
+    /** buffers *********************************************************/
+    char tmp[MAX_STR_LEN];
+
+    assert(additional_vars != NULL);
+    assert(keylist != NULL);
+    assert(listbox != NULL);
+
+    newtListboxClear(listbox);
+
+    for (i = 0; i < ARBITRARY_MAXIMUM; i++) {
+        keylist[i] = (void *) i;
+    }
+    for (i = 0; i < additional_vars->entries; i++) {
+        sprintf(tmp, "%-32s %-8s", additional_vars->el[i].label,
+                additional_vars->el[i].value);
+        newtListboxAppendEntry(listbox, tmp, keylist[i]);
+    }
+}
+
+#endif
+
+
+#ifndef __FreeBSD__
+/**
+ * Remove variable @p label from the RAID variables list in @p raidrec.
+ * @param raidrec The RAID device record to remove the variable from.
+ * @param label The variable name to remove.
+ * @return The value of the variable removed.
+ * @ingroup restoreUtilityGroup
+ */
+int
+read_variableINT_and_remove_from_raidvars(struct
+                                          OSSWAP (raid_device_record,
+                                                  vinum_volume) * raidrec,
+                                          char *label)
+{
+    /** int ***************************************************************/
     int i = 0;
-
-    /** newt *************************************************************/
-    newtComponent myForm;
+    int res = 0;
+
+
+    assert(raidrec != NULL);
+    assert(label != NULL);
+
+    for (i = 0;
+         i < raidrec->additional_vars.entries
+         && strcmp(raidrec->additional_vars.el[i].label, label); i++);
+    if (i == raidrec->additional_vars.entries) {
+        res = -1;
+    } else {
+        res = atoi(raidrec->additional_vars.el[i].value);
+        for (i++; i < raidrec->additional_vars.entries; i++) {
+            memcpy((void *) &raidrec->additional_vars.el[i - 1],
+                   (void *) &raidrec->additional_vars.el[i],
+                   sizeof(struct raid_var_line));
+        }
+        raidrec->additional_vars.entries--;
+    }
+    return (res);
+}
+#endif
+
+#ifndef __FreeBSD__
+/**
+ * Remove the essential RAID variables from the "additional variables" section.
+ * If they have been changed, set them in their normal locations too.
+ * @param raidrec The RAID device record to operate on.
+ * @ingroup restoreUtilityVarslist
+ */
+void remove_essential_additionalvars(struct raid_device_record *raidrec)
+{
+
+    /** int **************************************************************/
+    int res = 0;
+
+    assert(raidrec != NULL);
+
+    res =
+        read_variableINT_and_remove_from_raidvars(raidrec,
+                                                  "persistent-superblock");
+    if (res > 0) {
+        raidrec->persistent_superblock = res;
+    }
+    res = read_variableINT_and_remove_from_raidvars(raidrec, "chunk-size");
+    if (res > 0) {
+        raidrec->chunk_size = res;
+    }
+    res = read_variableINT_and_remove_from_raidvars(raidrec, "block-size");
+}
+
+#endif
+
+
+
+/**
+ * Choose the RAID level for the RAID device record in @p raidrec.
+ * @param raidrec The RAID device record to set the RAID level of.
+ * @ingroup restoreGuiMountlist
+ */
+void
+choose_raid_level(struct OSSWAP (raid_device_record, vinum_plex) * raidrec)
+{
+
+#ifdef __FreeBSD__
+
+    /** int ***************************************************************/
+    int res = 0;
+    int out = 0;
+
+    /** buffers ***********************************************************/
+    char tmp[MAX_STR_LEN];
+    char *prompt = NULL;
+    char sz[MAX_STR_LEN];
+
+    mr_asprintf(prompt, "Please enter the RAID level you want. (concat, striped, raid5)");
+    if (raidrec->raidlevel == -1) {
+        strcpy(tmp, "concat");
+    } else if (raidrec->raidlevel == 0) {
+        strcpy(tmp, "striped");
+    } else {
+        sprintf(tmp, "raid%i", raidrec->raidlevel);
+    }
+    for (out = 999; out == 999;) {
+        res = popup_and_get_string("Specify RAID level", prompt, tmp, 10);
+        if (!res) {
+            mr_free(prompt);
+            return;
+        }
+        strip_spaces(tmp);
+        if (tmp[0] == '[' && tmp[strlen(tmp) - 1] == ']') {
+            strcpy(sz, tmp);
+            strncpy(tmp, sz + 1, strlen(sz) - 2);
+            tmp[strlen(sz) - 2] = '\0';
+        }
+        if (!strcmp(tmp, "concat")) {
+            out = -1;
+        } else if (!strcmp(tmp, "striped")) {
+            out = 0;
+        } else if (!strcmp(tmp, "raid5")) {
+            out = 5;
+        }
+        log_it(tmp);
+        if (is_this_raid_personality_registered(out)) {
+            log_it("Groovy. You've picked a RAID personality which is registered.");
+        } else {
+            if (ask_me_yes_or_no("You have chosen a RAID personality which is not registered with the kernel. Make another selection?"))
+            {
+                out = 999;
+            }
+        }
+    }
+    mr_free(prompt);
+
+    raidrec->raidlevel = out;
+#else
+    /** buffers ***********************************************************/
+    char tmp[MAX_STR_LEN];
+    char *personalities = NULL;
+    char *prompt = NULL;
+    char sz[MAX_STR_LEN];
+    int out = 0;
+    int res = 0;
+
+
+    assert(raidrec != NULL);
+    paranoid_system("grep Pers /proc/mdstat > /tmp/raid-personalities.txt 2> /dev/null");
+    mr_asprintf(personalities, "%s", last_line_of_file("/tmp/raid-personalities.txt"));
+    mr_asprintf(prompt, "Please enter the RAID level you want. %s", personalities);
+    mr_free(personalities);
+
+    if (raidrec->raid_level == -1) {
+        strcpy(tmp, "linear");
+    } else {
+        sprintf(tmp, "%d", raidrec->raid_level);
+    }
+    for (out = 999;
+         out != -1 && out != 0 && out != 1 && out != 4 && out != 5
+         && out != 10;) {
+        res = popup_and_get_string("Specify RAID level", prompt, tmp, 10);
+        if (!res) {
+            return;
+        }
+        strip_spaces(tmp);
+        if (tmp[0] == '[' && tmp[strlen(tmp) - 1] == ']') {
+            strcpy(sz, tmp);
+            strncpy(tmp, sz + 1, strlen(sz) - 2);
+            tmp[strlen(sz) - 2] = '\0';
+        }
+        if (!strcmp(tmp, "linear")) {
+            out = -1;
+        } else if (!strncmp(tmp, "raid", 4)) {
+            out = atoi(tmp + 4);
+        } else {
+            out = atoi(tmp);
+        }
+        log_it(tmp);
+        if (is_this_raid_personality_registered(out)) {
+            log_it("Groovy. You've picked a RAID personality which is registered.");
+        } else {
+            if (ask_me_yes_or_no("You have chosen a RAID personality which is not registered with the kernel. Make another selection?")) {
+                out = 999;
+            }
+        }
+    }
+    mr_free(prompt);
+
+    raidrec->raid_level = out;
+#endif
+}
+
+
+#ifdef __FreeBSD__
+
+/**
+ * Edit the plex @p raidrec in @p raidlist.
+ * @param mountlist The mountlist to get some of the information from.
+ * @param raidlist The raidlist containing information about RAID devices.
+ * @param raidrec The plex to edit.
+ * @param currline The line number (starting from 0) of the RAID device in @p mountlist.
+ * @param currline2 The line number (starting from 0) of the plex within the RAID device.
+ * @author Joshua Oreman
+ * @ingroup restoreGuiMountlist
+ */
+void
+edit_raidlist_plex(struct mountlist_itself *mountlist,
+                   struct raidlist_itself *raidlist,
+                   struct vinum_plex *raidrec, int currline, int currline2)
+{
+
+    /** structures ********************************************************/
+    struct vinum_plex bkp_raidrec;
+
+
+    /** buffers ***********************************************************/
+    char *title_of_editraidForm_window = NULL;
+
+    /** newt **************************************************************/
+    newtComponent editraidForm;
     newtComponent bOK;
     newtComponent bCancel;
+    newtComponent bEdit;
+    newtComponent bAdd;
+    newtComponent bDelete;
     newtComponent b_res;
-    newtComponent mountpointComp;
-    newtComponent label0;
-    newtComponent label1;
-    newtComponent label2;
-    newtComponent label3;
-    newtComponent sizeComp;
-    newtComponent deviceComp;
-    newtComponent formatComp;
-
-    /** buffers **********************************************************/
-    char *drive_to_add = NULL;
-    char *mountpoint_str = NULL;
-    char *size_str = NULL;
-    char *device_str = NULL;
-    char *format_str = NULL;
-
-    /** pointers *********************************************************/
-    char *mountpoint_here;
-    char *size_here;
-    char *device_here;
-    char *format_here;
-
-    assert(mountlist != NULL);
-    assert(raidlist != NULL);
-    assert(listbox != NULL);
-    assert(keylist != NULL);
-
-    mr_asprintf(device_str, "/dev/");
-    mr_asprintf(mountpoint_str, "/");
-    mr_asprintf(size_str, "");
-#ifdef __FreeBSD__
-    mr_asprintf(format_str, "ufs");
+    newtComponent unallocListbox, allocListbox;
+    newtComponent bLevel, sLevel;
+    newtComponent bStripeSize, sStripeSize;
+    newtComponent bAlloc, bUnalloc;
+
+    void *keylist[ARBITRARY_MAXIMUM];
+    void *curr_choice_a, *curr_choice_u;
+    int currline_a, currline_u;
+
+    char *p = NULL;
+    char *tmp = NULL;
+    char *entry = NULL;
+
+    struct mountlist_itself *unallocparts;
+
+    unallocparts = malloc(sizeof(struct mountlist_itself));
+
+    log_it("Started edit_raidlist_entry");
+    memcpy((void *) &bkp_raidrec, (void *) raidrec,
+           sizeof(struct vinum_plex));
+    mr_asprintf(title_of_editraidForm_window, "%s.p%i", raidlist->el[currline].volname, currline2);
+    newtPushHelpLine
+        ("   Please select a subdisk to edit, or edit this plex's parameters");
+    newtOpenWindow(13, 3, 54, 18, title_of_editraidForm_window);
+    mr_free(title_of_editraidForm_window);
+
+    for (;;) {
+        int i;
+
+        switch (raidrec->raidlevel) {
+        case -1:
+            mr_asprintf(tmp, "concat");
+            break;
+        case 0:
+            mr_asprintf(tmp, "striped");
+            break;
+        case 5:
+            mr_asprintf(tmp, "raid5");
+            break;
+        default:
+            mr_asprintf(tmp, "unknown (%i)", raidrec->raidlevel);
+            break;
+        }
+        bLevel = newtCompactButton(2, 2, " RAID level ");
+        sLevel = newtLabel(19, 2, tmp);
+        mr_free(tmp);
+
+        if (raidrec->raidlevel >= 0) {
+            mr_asprintf(tmp, "%ik", raidrec->stripesize);
+            bStripeSize = newtCompactButton(2, 4, " Stripe size ");
+        } else {
+            mr_asprintf(tmp, "N/A");
+            bStripeSize = newtLabel(2, 4, "Stripe size:");
+        }
+        sStripeSize = newtLabel(19, 4, tmp);
+        mr_free(tmp);
+
+        bOK = newtCompactButton(2, 16, "  OK  ");
+        bCancel = newtCompactButton(12, 16, "Cancel");
+        bAdd = newtCompactButton(22, 16, " Add ");
+        bEdit = newtCompactButton(32, 16, " Edit ");
+        bDelete = newtCompactButton(42, 16, "Delete");
+
+
+        unallocListbox =
+            newtListbox(2, 7, 7, NEWT_FLAG_SCROLL | NEWT_FLAG_RETURNEXIT);
+        allocListbox =
+            newtListbox(33, 7, 7, NEWT_FLAG_SCROLL | NEWT_FLAG_RETURNEXIT);
+        bAlloc = newtButton(23, 7, " -> ");
+        bUnalloc = newtButton(23, 11, " <- ");
+
+        editraidForm = newtForm(NULL, NULL, 0);
+
+        newtListboxClear(allocListbox);
+        newtListboxClear(unallocListbox);
+        bzero(unallocparts, sizeof(struct mountlist_itself));
+        make_list_of_unallocated_raid_partitions(unallocparts, mountlist,
+                                                 raidlist);
+        for (i = 0; i < ARBITRARY_MAXIMUM; ++i) {
+            keylist[i] = (void *) i;
+            if (i < raidrec->subdisks) {
+                mr_asprintf(entry, "%-17s", find_dev_entry_for_raid_device_name(raidlist, raidrec->sd[i].which_device));
+                newtListboxAppendEntry(allocListbox, entry, keylist[i]);
+                mr_free(entry);
+            }
+            if (i < unallocparts->entries) {
+                mr_asprintf(entry, "%-17s", unallocparts->el[i].device);
+                newtListboxAppendEntry(unallocListbox, entry, keylist[i]);
+                mr_free(entry);
+            }
+        }
+
+#define COMP(x)  newtFormAddComponent (editraidForm, x)
+#define UCOMP(x) if (unallocparts->entries > 0) COMP(x)
+#define ACOMP(x) if (raidrec->subdisks > 0) COMP(x)
+        editraidForm = newtForm(NULL, NULL, 0);
+        UCOMP(unallocListbox);
+        UCOMP(bAlloc);
+        ACOMP(allocListbox);
+        ACOMP(bUnalloc);
+        COMP(bOK);
+        COMP(bCancel);
+        COMP(bLevel);
+        COMP(sLevel);
+        if (raidrec->raidlevel != -1) {
+            COMP(bStripeSize);
+            COMP(sStripeSize);
+        }
+#undef COMP
+#undef UCOMP
+#undef ACOMP
+
+        newtDrawForm(editraidForm);
+        newtRefresh();
+        b_res = newtRunForm(editraidForm);
+        if (b_res == bOK || b_res == bCancel) {
+            break;
+        }
+
+        curr_choice_a = (raidrec->subdisks > 0) ?
+            newtListboxGetCurrent(allocListbox) : (void *) 1234;
+        curr_choice_u = (unallocparts->entries > 0) ?
+            newtListboxGetCurrent(unallocListbox) : (void *) 1234;
+        for (currline_a = 0; currline_a < raidrec->subdisks; ++currline_a) {
+            if (currline_a > ARBITRARY_MAXIMUM)
+                break;
+            if (keylist[currline_a] == curr_choice_a)
+                break;
+        }
+        for (currline_u = 0; currline_u < unallocparts->entries;
+             ++currline_u) {
+            if (currline_u > ARBITRARY_MAXIMUM)
+                break;
+            if (keylist[currline_u] == curr_choice_u)
+                break;
+        }
+        if (b_res == bLevel) {
+            choose_raid_level(raidrec);
+        } else if (b_res == bStripeSize) {
+            char tmp1[64];
+            sprintf(tmp1, "%i", raidrec->stripesize);
+            if (popup_and_get_string
+                ("Stripe size",
+                 "Please enter the stripe size in kilobytes.", tmp1, 20)) {
+                raidrec->stripesize = atoi(tmp1);
+            }
+        } else if ((b_res == bAlloc) || (b_res == unallocListbox)) {
+            if (currline_u <= unallocparts->entries)
+                add_raid_subdisk(raidlist, raidrec,
+                                 unallocparts->el[currline_u].device);
+        } else if ((b_res == bUnalloc) || (b_res == allocListbox)) {
+            if (currline_a <= raidrec->subdisks) {
+                memcpy((void *) &raidrec->sd[currline_a],
+                       (void *) &raidrec->sd[raidrec->subdisks - 1],
+                       sizeof(struct vinum_subdisk));
+                raidrec->subdisks--;
+            }
+        }
+    newtFormDestroy(editraidForm);
+    newtRefresh();
+}
+
+if (b_res == bCancel) {
+    memcpy((void *) raidrec, (void *) &bkp_raidrec, sizeof(struct vinum_plex));
+}
+newtPopWindow();
+newtPopHelpLine();
+}
 #else
-    mr_asprintf(format_str, "ext3");
+/**
+ * Edit additional RAID variable number @p lino.
+ * @param raidrec The RAID device record to edit the variable in.
+ * @param lino The line number (starting from 0) of the variable to edit.
+ * @ingroup restoreGuiVarslist
+ */
+void edit_varslist_entry(struct raid_device_record *raidrec, int lino)
+{
+
+    /** buffers ***********************************************************/
+    char *header = NULL;
+    char *comment = NULL;
+    char sz_out[MAX_STR_LEN];
+
+    assert(raidrec != 0);
+    assert(lino >= 0);
+
+    strcpy(sz_out, raidrec->additional_vars.el[lino].value);
+    mr_asprintf(header, "Edit %s", raidrec->additional_vars.el[lino].label);
+    mr_asprintf(comment, "Please set %s's value (currently '%s')", raidrec->additional_vars.el[lino].label, sz_out);
+    if (popup_and_get_string(header, comment, sz_out, MAX_STR_LEN)) {
+        strip_spaces(sz_out);
+        strcpy(raidrec->additional_vars.el[lino].value, sz_out);
+    }
+    mr_free(header);
+    mr_free(comment);
+}
 #endif
-    newtOpenWindow(20, 5, 48, 10, "Add entry");
-    label0 = newtLabel(2, 1, "Device:    ");
-    label1 = newtLabel(2, 2, "Mountpoint:");
-    label2 = newtLabel(2, 3, "Size (MB): ");
-    label3 = newtLabel(2, 4, "Format:    ");
-    deviceComp = newtEntry(14, 1, device_str, 30, (void *) &device_here, 0);
-    mountpointComp = newtEntry(14, 2, mountpoint_str, 30, (void *) &mountpoint_here, 0);
-    formatComp = newtEntry(14, 4, format_str, 15, (void *) &format_here, 0);
-    sizeComp = newtEntry(14, 3, size_str, 10, (void *) &size_here, 0);
-    bOK = newtButton(5, 6, "  OK  ");
-    bCancel = newtButton(17, 6, "Cancel");
-    newtPushHelpLine
-        ("To add an entry to the mountlist, please fill in these fields and then hit 'OK'");
-    myForm = newtForm(NULL, NULL, 0);
-    newtFormAddComponents(myForm, deviceComp, mountpointComp, sizeComp,
-                          formatComp, label0, label1, label2, label3, bOK,
-                          bCancel, NULL);
-    for (b_res = NULL; b_res != bOK && b_res != bCancel;) {
-        b_res = newtRunForm(myForm);
-        mr_free(device_str);
-        device_str = mr_strip_spaces(device_here);
-
-        mr_free(mountpoint_str);
-        mountpoint_str = mr_strip_spaces(mountpoint_here);
-
-        mr_free(format_str);
-        format_str = mr_strip_spaces(format_here);
-
-        mr_free(size_str);
-        size_str = mr_strip_spaces(size_here);
-
-        if (b_res == bOK) {
-            if (device_str[strlen(device_str) - 1] == '/') {
-                popup_and_OK("You left the device nearly blank!");
-                b_res = NULL;
-            }
-            if (size_of_specific_device_in_mountlist(mountlist, device_str) >= 0) {
-                popup_and_OK("Can't add this - you've got one already!");
-                b_res = NULL;
-            }
-        }
-    }
-    newtFormDestroy(myForm);
-    newtPopHelpLine();
-    newtPopWindow();
-    if (b_res == bCancel) {
-        return;
-    }
-    mr_asprintf(drive_to_add, "%s", device_str);
-    for (i = strlen(drive_to_add); isdigit(drive_to_add[i - 1]); i--);
-    mr_free(drive_to_add);
-
-    currline = mountlist->entries;
-    strcpy(mountlist->el[currline].device, device_str);
-    strcpy(mountlist->el[currline].mountpoint, mountpoint_str);
-    mr_free(mountpoint_str);
-
-    strcpy(mountlist->el[currline].format, format_str);
-    mr_free(format_str);
-
-    mountlist->el[currline].size = atol(size_str) * 1024L;
-    mr_free(size_str);
-
-    mountlist->entries++;
-    if (strstr(mountlist->el[currline].device, RAID_DEVICE_STUB)) {
-        initiate_new_raidlist_entry(raidlist, mountlist, currline, device_str);
-    }
-    mr_free(device_str);
-
-    redraw_mountlist(mountlist, keylist, listbox);
-}
 
 
@@ -289 +997 @@
 }
 #endif
+
+
+#ifndef __FreeBSD__
+/**
+ * Delete entry number @p lino in the additional RAID variables section of @p raidrec.
+ * @param raidrec The RAID device record containing the RAID variable to delete.
+ * @param lino The line number (starting from 0) of the variable to delete.
+ * @ingroup restoreGuiVarslist
+ */
+void delete_varslist_entry(struct raid_device_record *raidrec, int lino)
+{
+
+    /** buffers ************************************************************/
+    char *tmp = NULL;
+    int res = 0;
+
+    /** structures *********************************************************/
+    struct additional_raid_variables *av;
+
+    assert(raidrec != NULL);
+
+    av = &raidrec->additional_vars;
+    mr_asprintf(tmp, "Delete %s - are you sure?", av->el[lino].label);
+    res = ask_me_yes_or_no(tmp);
+    mr_free(tmp);
+
+    if (res) {
+        if (!strcmp(av->el[lino].label, "persistent-superblock")
+            || !strcmp(av->el[lino].label, "chunk-size")) {
+            mr_asprintf(tmp, "%s must not be deleted. It would be bad.", av->el[lino].label);
+            popup_and_OK(tmp);
+            mr_free(tmp);
+        } else {
+            memcpy((void *) &av->el[lino], (void *) &av->el[av->entries--],
+                   sizeof(struct raid_var_line));
+        }
+    }
+}
+#endif
+
+
+
+#ifndef __FreeBSD__
+/**
+ * Edit the additional RAID variables in @p raidrec.
+ * @param raidrec The RAID device record to edit the RAID variables in.
+ * @ingroup restoreGuiVarslist
+ */
+void edit_raidrec_additional_vars(struct raid_device_record *raidrec)
+{
+
+    /** structure *********************************************************/
+    struct raid_device_record bkp_raidrec;
+
+    /** newt **************************************************************/
+    newtComponent myForm;
+    newtComponent bAdd;
+    newtComponent bEdit;
+    newtComponent bDelete;
+    newtComponent bOK;
+    newtComponent bCancel;
+    newtComponent b_res;
+    newtComponent varsListbox;
+    newtComponent headerMsg;
+
+    /** ?? ***************************************************************/
+    void *keylist[ARBITRARY_MAXIMUM], *curr_choice;
+
+    /** buffers **********************************************************/
+    char title_of_window[MAX_STR_LEN];
+
+    /** int **************************************************************/
+    int i = 0;
+    int currline = 0;
+
+
+    assert(raidrec != NULL);
+
+    memcpy((void *) &bkp_raidrec, (void *) raidrec,
+           sizeof(struct raid_device_record));
+    sprintf(title_of_window, "Additional variables");
+    newtPushHelpLine
+        ("  Edit the additional fields to your heart's content, then click OK or Cancel.");
+    headerMsg = newtLabel(1, 1, "Label                            Value");
+    varsListbox =
+        newtListbox(1, 2, 6, NEWT_FLAG_SCROLL | NEWT_FLAG_RETURNEXIT);
+    i = 1;
+    bAdd = newtCompactButton(i, 9, " Add ");
+    bEdit = newtCompactButton(i += 8, 9, " Edit ");
+    bDelete = newtCompactButton(i += 9, 9, "Delete");
+    bOK = newtCompactButton(i += 9, 9, "  OK  ");
+    bCancel = newtCompactButton(i += 9, 9, "Cancel");
+    newtOpenWindow(17, 7, 46, 10, title_of_window);
+    myForm = newtForm(NULL, NULL, 0);
+    newtFormAddComponents(myForm, headerMsg, varsListbox, bAdd, bEdit,
+                          bDelete, bOK, bCancel, NULL);
+    insert_essential_additionalvars(raidrec);
+    redraw_varslist(&raidrec->additional_vars, keylist, varsListbox);
+    for (b_res = NULL; b_res != bOK && b_res != bCancel;) {
+        b_res = newtRunForm(myForm);
+        curr_choice = newtListboxGetCurrent(varsListbox);
+        for (currline = 0;
+             currline < raidrec->additional_vars.entries
+             && keylist[currline] != curr_choice; currline++);
+        if (currline == raidrec->additional_vars.entries
+            && raidrec->additional_vars.entries > 0) {
+            log_it("Warning - I don't know what this button does");
+        }
+        if (b_res == bOK) {     /* do nothing */
+        } else if (b_res == bCancel) {  /* do nothing */
+        } else if (b_res == bAdd) {
+            add_varslist_entry(raidrec);
+        } else if (b_res == bDelete) {
+            delete_varslist_entry(raidrec, currline);
+        } else {
+            edit_varslist_entry(raidrec, currline);
+        }
+        redraw_varslist(&raidrec->additional_vars, keylist, varsListbox);
+    }
+    remove_essential_additionalvars(raidrec);
+    newtFormDestroy(myForm);
+    newtPopWindow();
+    newtPopHelpLine();
+    if (b_res == bCancel) {
+        memcpy((void *) raidrec, (void *) &bkp_raidrec,
+               sizeof(struct raid_device_record));
+    }
+    return;
+}
+#endif
+
 
 /**
@@ -445 +1284 @@
 
 /**
- * Choose the RAID level for the RAID device record in @p raidrec.
- * @param raidrec The RAID device record to set the RAID level of.
+ * Edit the entry for @p raidrec in @p raidlist.
+ * @param mountlist The mountlist to get some information from.
+ * @param raidlist The raidlist containing information about RAID devices.
+ * @param raidrec The RAID device record for this partition.
+ * @param currline The line number (starting from 0) in the mountlist of the RAID device.
  * @ingroup restoreGuiMountlist
  */
+void edit_raidlist_entry(struct mountlist_itself *mountlist,
+                    struct raidlist_itself *raidlist,
+                    struct OSSWAP (raid_device_record,
+                                   vinum_volume) * raidrec, int currline)
+{
+
+#ifdef __FreeBSD__
+    /** structures ********************************************************/
+    struct vinum_volume bkp_raidrec;
+
+
+    /** buffers ***********************************************************/
+    char title_of_editraidForm_window[MAX_STR_LEN];
+
+    /** newt **************************************************************/
+    newtComponent editraidForm;
+    newtComponent bOK;
+    newtComponent bCancel;
+    newtComponent bEdit;
+    newtComponent bAdd;
+    newtComponent bDelete;
+    newtComponent b_res;
+    newtComponent plexesListbox;
+    newtComponent plexesHeader;
+
+    void *keylist[10];
+    void *curr_choice;
+    char *raidlevel = NULL;
+    char *chunksize = NULL;
+    char *msg = NULL;
+
+    int currline2 = 0;
+    int res = 0;
+
+    log_it("Started edit_raidlist_entry");
+    memcpy((void *) &bkp_raidrec, (void *) raidrec,
+           sizeof(struct vinum_volume));
+    sprintf(title_of_editraidForm_window, "Plexes on %s",
+            raidrec->volname);
+    newtPushHelpLine("   Please select a plex to edit");
+    newtOpenWindow(13, 5, 54, 15, title_of_editraidForm_window);
+    for (;;) {
+        int i;
+        char *headerstr = NULL;
+        mr_asprintf(headerstr, "%-14s %-8s  %11s  %8s", "Plex", "Level", "Stripe Size", "Subdisks");
+
+        bOK = newtCompactButton(2, 13, "  OK  ");
+        bCancel = newtCompactButton(12, 13, "Cancel");
+        bAdd = newtCompactButton(22, 13, " Add ");
+        bEdit = newtCompactButton(32, 13, " Edit ");
+        bDelete = newtCompactButton(42, 13, "Delete");
+
+        plexesListbox =
+            newtListbox(2, 3, 9, NEWT_FLAG_SCROLL | NEWT_FLAG_RETURNEXIT);
+        plexesHeader = newtLabel(2, 2, headerstr);
+        mr_free(headerstr);
+        editraidForm = newtForm(NULL, NULL, 0);
+
+        newtListboxClear(plexesListbox);
+        for (i = 0; i < 10; ++i) {
+            keylist[i] = (void *) i;
+            if (i < raidrec->plexes) {
+                char *pname;
+                char *entry;
+                switch (raidrec->plex[i].raidlevel) {
+                case -1:
+                    mr_asprintf(raidlevel, "concat");
+                    break;
+                case 0:
+                    mr_asprintf(raidlevel, "striped");
+                    break;
+                case 5:
+                    mr_asprintf(raidlevel, "raid5");
+                    break;
+                default:
+                    mr_asprintf(raidlevel, "raid%i", raidrec->plex[i].raidlevel);
+                    break;
+                }
+
+                if (raidrec->plex[i].raidlevel == -1) {
+                    mr_asprintf(chunksize, "N/A");
+                } else {
+                    mr_asprintf(chunksize, "%dk", raidrec->plex[i].stripesize);
+                }
+                mr_asprintf(pname, "%s.p%i", raidrec->volname, i);
+                mr_asprintf(entry, "%-14s %-8s  %11s  %8d", pname, raidlevel, chunksize, raidrec->plex[i].subdisks);
+                mr_free(pname);
+                mr_free(raidlevel);
+                mr_free(chunksize);
+
+                newtListboxAppendEntry(plexesListbox, entry, keylist[i]);
+                mr_free(entry);
+            }
+        }
+
+        newtFormAddComponents(editraidForm, bOK, bCancel, bAdd, bEdit,
+                              bDelete, plexesListbox, plexesHeader, NULL);
+
+        b_res = newtRunForm(editraidForm);
+        if (b_res == bOK || b_res == bCancel) {
+            break;
+        }
+
+        curr_choice = newtListboxGetCurrent(plexesListbox);
+        for (currline2 = 0; currline2 < raidrec->plexes; ++currline2) {
+            if (currline2 > 9)
+                break;
+            if (keylist[currline2] == curr_choice)
+                break;
+        }
+
+        if (b_res == bDelete) {
+            mr_asprintf(msg, "Are you sure you want to delete %s.p%i?", raidrec->volname, currline2);
+            res = ask_me_yes_or_no(msg);
+            mr_free(msg);
+
+            if (res) {
+                log_it("Deleting RAID plex");
+                memcpy((void *) &raidrec->plex[currline2],
+                       (void *) &raidrec->plex[raidrec->plexes - 1],
+                       sizeof(struct vinum_plex));
+                raidrec->plexes--;
+            }
+            continue;
+        }
+        if (b_res == bAdd) {
+            raidrec->plex[raidrec->plexes].raidlevel = 0;
+            raidrec->plex[raidrec->plexes].stripesize = 279;
+            raidrec->plex[raidrec->plexes].subdisks = 0;
+            currline2 = raidrec->plexes++;
+        }
+        edit_raidlist_plex(mountlist, raidlist, &raidrec->plex[currline2],
+                           currline, currline2);
+        newtFormDestroy(editraidForm);
+    }
+    if (b_res == bCancel) {
+        memcpy((void *) raidrec, (void *) &bkp_raidrec,
+               sizeof(struct vinum_volume));
+    }
+    newtPopHelpLine();
+    newtPopWindow();
+    mountlist->el[currline].size =
+        calculate_raid_device_size(mountlist, raidlist, raidrec->volname);
+#else
+    /** structures ********************************************************/
+    struct raid_device_record *bkp_raidrec;
+
+
+    /** buffers ***********************************************************/
+    char *title_of_editraidForm_window;
+    char *sz_raid_level = NULL;
+    char *sz_data_disks = NULL;
+    char *sz_spare_disks = NULL;
+    char *sz_parity_disks = NULL;
+    char *sz_failed_disks = NULL;
+
+    /** newt **************************************************************/
+    newtComponent editraidForm;
+    newtComponent bOK;
+    newtComponent bCancel;
+    newtComponent bAdditional;
+    newtComponent bChangeRaid;
+    newtComponent bSelectData;
+    newtComponent bSelectSpare;
+    newtComponent bSelectParity;
+    newtComponent bSelectFailed;
+    newtComponent b_res;
+
+    assert(mountlist != NULL);
+    assert(raidlist != NULL);
+    assert(raidrec != NULL);
+
+    bkp_raidrec = mr_malloc(sizeof(struct raid_device_record));
+    log_it("Started edit_raidlist_entry");
+
+    memcpy((void *) bkp_raidrec, (void *) raidrec, sizeof(struct raid_device_record));
+    mr_asprintf(title_of_editraidForm_window, "%s", raidrec->raid_device);
+    log_msg(2, "Opening newt window");
+    newtOpenWindow(20, 5, 40, 14, title_of_editraidForm_window);
+    for (;;) {
+        log_msg(2, "Main loop");
+        mr_free(title_of_editraidForm_window);
+        mr_asprintf(title_of_editraidForm_window, "Edit %s", raidrec->raid_device);
+        sz_raid_level = turn_raid_level_number_to_string(raidrec->raid_level);
+        sz_data_disks = number_of_disks_as_string(raidrec->data_disks.entries, "data");
+        sz_spare_disks = number_of_disks_as_string(raidrec->spare_disks.entries, "spare");
+        sz_parity_disks = number_of_disks_as_string(raidrec->parity_disks.entries, "parity");
+        sz_failed_disks = number_of_disks_as_string(raidrec->failed_disks.entries, "failed");
+        bSelectData = newtButton(1, 1, sz_data_disks);
+        bSelectSpare = newtButton(20, 1, sz_spare_disks);
+        bSelectParity = newtButton(1, 5, sz_parity_disks);
+        bSelectFailed = newtButton(20, 5, sz_failed_disks);
+        bChangeRaid = newtButton(1, 9, sz_raid_level);
+        bOK = newtButton(16 + (raidrec->raid_level == -1), 9, "  OK  ");
+        bCancel = newtButton(28, 9, "Cancel");
+        bAdditional =
+            newtCompactButton(1, 13,
+                              "Additional settings and information");
+        newtPushHelpLine
+            ("  Edit the RAID device's settings to your heart's content, then hit OK/Cancel.");
+        editraidForm = newtForm(NULL, NULL, 0);
+        newtFormAddComponents(editraidForm, bSelectData, bSelectParity,
+                              bChangeRaid, bSelectSpare, bSelectFailed,
+                              bOK, bCancel, bAdditional);
+        b_res = newtRunForm(editraidForm);
+        if (b_res == bChangeRaid) {
+            choose_raid_level(raidrec);
+        } else if (b_res == bSelectData) {
+            select_raid_disks(mountlist, raidlist, raidrec, "data", &raidrec->data_disks);
+        } else if (b_res == bSelectSpare) {
+            select_raid_disks(mountlist, raidlist, raidrec, "spare", &raidrec->spare_disks);
+        } else if (b_res == bSelectParity) {
+            select_raid_disks(mountlist, raidlist, raidrec, "parity", &raidrec->parity_disks);
+        } else if (b_res == bSelectFailed) {
+            select_raid_disks(mountlist, raidlist, raidrec, "failed", &raidrec->failed_disks);
+        } else if (b_res == bAdditional) {
+            edit_raidrec_additional_vars(raidrec);
+        }
+        newtFormDestroy(editraidForm);
+        if (b_res == bOK || b_res == bCancel) {
+            break;
+        }
+        mr_free(sz_data_disks);
+        mr_free(sz_spare_disks);
+        mr_free(sz_parity_disks);
+        mr_free(sz_failed_disks);
+    }
+    if (b_res == bCancel) {
+        memcpy((void *) raidrec, (void *) bkp_raidrec, sizeof(struct raid_device_record));
+    }
+    newtPopHelpLine();
+    newtPopWindow();
+    mountlist->el[currline].size = calculate_raid_device_size(mountlist, raidlist, raidrec->raid_device);
+    mr_free(title_of_editraidForm_window);
+    mr_free(sz_raid_level);
+    paranoid_free(bkp_raidrec);
+#endif
+}
+
+
+/**
+ * Create a new raidtab entry for @p device in @p raidlist.
+ * @param raidlist The raidlist to add the device to.
+ * @param mountlist The mountlist containing information about the user's partitions.
+ * @param currline The selected line in the mountlist.
+ * @param device The RAID device (e.g. /dev/md0) to use.
+ * @ingroup restoreGuiMountlist
+ */
 void
-choose_raid_level(struct OSSWAP (raid_device_record, vinum_plex) * raidrec)
-{
-
+initiate_new_raidlist_entry(struct raidlist_itself *raidlist,
+                            struct mountlist_itself *mountlist,
+                            int currline, char *device)
+{
+
+    /** structure *********************************************************/
+    struct OSSWAP (raid_device_record, vinum_volume) * raidrec;
+
+    /** int ***************************************************************/
+    int pos_in_raidlist = 0;
+
+    assert(raidlist != NULL);
+    assert(mountlist != NULL);
+    assert_string_is_neither_NULL_nor_zerolength(device);
+
+    pos_in_raidlist =
+        find_raid_device_in_raidlist(raidlist,
+                                     mountlist->el[currline].device);
+    if (pos_in_raidlist >= 0) {
+        fatal_error("Sorry, that RAID device already exists. Weird.");
+    }
+    pos_in_raidlist = raidlist->entries++;
+    raidrec = &raidlist->el[pos_in_raidlist];
+    initialize_raidrec(raidrec);
+    strcpy(raidrec->OSSWAP(raid_device, volname), OSSWAP(device, basename(device)));
+#ifndef __FreeBSD__
+    choose_raid_level(raidrec);
+    select_raid_disks(mountlist, raidlist, raidrec, "data",
+                      &raidrec->data_disks);
+#endif
+    edit_raidlist_entry(mountlist, raidlist, raidrec, currline);
+}
+
+
+/**
+ * Redraw the mountlist.
+ * @param mountlist The mountlist to read from.
+ * @param keylist The list of keys for @p listbox.
+ * @param listbox The Newt listbox component to redraw.
+ * @ingroup restoreGuiMountlist
+ */
+void
+redraw_mountlist(struct mountlist_itself *mountlist,
+                 void *keylist[ARBITRARY_MAXIMUM], newtComponent listbox)
+{
+
+    /** long **************************************************************/
+    long i = 0;
+    char * tmp = NULL;
+
+    assert(mountlist != NULL);
+    assert(keylist != NULL);
+    assert(listbox != NULL);
+
+    newtListboxClear(listbox);
+//  sort_mountlist_by_device (mountlist);
+    for (i = 0; i < ARBITRARY_MAXIMUM; i++) {
+        keylist[i] = (void *) i;
+    }
+    for (i = 0; i < mountlist->entries; i++) {
+        tmp = mountlist_entry_to_string(mountlist, i);
+        newtListboxAppendEntry(listbox, tmp, keylist[i]);
+        mr_free(tmp);
+    }
+}
+
+
+
+
+/**
+ * Add an entry to @p mountlist.
+ * @param mountlist The mountlist to add an entry to.
+ * @param raidlist The raidlist that accompanies @p mountlist.
+ * @param listbox The listbox component in the mountlist editor.
+ * @param currline The line selected in @p listbox.
+ * @param keylist The list of keys for @p listbox.
+ * @ingroup restoreGuiMountlist
+ */
+void
+add_mountlist_entry(struct mountlist_itself *mountlist,
+                    struct raidlist_itself *raidlist,
+                    newtComponent listbox, int currline, void *keylist[])
+{
+
+    /** int **************************************************************/
+    int i = 0;
+
+    /** newt *************************************************************/
+    newtComponent myForm;
+    newtComponent bOK;
+    newtComponent bCancel;
+    newtComponent b_res;
+    newtComponent mountpointComp;
+    newtComponent label0;
+    newtComponent label1;
+    newtComponent label2;
+    newtComponent label3;
+    newtComponent sizeComp;
+    newtComponent deviceComp;
+    newtComponent formatComp;
+
+    /** buffers **********************************************************/
+    char *drive_to_add = NULL;
+    char *mountpoint_str = NULL;
+    char *size_str = NULL;
+    char *device_str = NULL;
+    char *format_str = NULL;
+
+    /** pointers *********************************************************/
+    char *mountpoint_here;
+    char *size_here;
+    char *device_here;
+    char *format_here;
+
+    assert(mountlist != NULL);
+    assert(raidlist != NULL);
+    assert(listbox != NULL);
+    assert(keylist != NULL);
+
+    mr_asprintf(device_str, "/dev/");
+    mr_asprintf(mountpoint_str, "/");
+    mr_asprintf(size_str, "");
 #ifdef __FreeBSD__
-
-    /** int ***************************************************************/
-    int res = 0;
-    int out = 0;
-
-    /** buffers ***********************************************************/
-    char tmp[MAX_STR_LEN];
-    char *prompt = NULL;
-    char sz[MAX_STR_LEN];
-
-    mr_asprintf(prompt, "Please enter the RAID level you want. (concat, striped, raid5)");
-    if (raidrec->raidlevel == -1) {
-        strcpy(tmp, "concat");
-    } else if (raidrec->raidlevel == 0) {
-        strcpy(tmp, "striped");
-    } else {
-        sprintf(tmp, "raid%i", raidrec->raidlevel);
-    }
-    for (out = 999; out == 999;) {
-        res = popup_and_get_string("Specify RAID level", prompt, tmp, 10);
-        if (!res) {
-            mr_free(prompt);
-            return;
-        }
-        strip_spaces(tmp);
-        if (tmp[0] == '[' && tmp[strlen(tmp) - 1] == ']') {
-            strcpy(sz, tmp);
-            strncpy(tmp, sz + 1, strlen(sz) - 2);
-            tmp[strlen(sz) - 2] = '\0';
-        }
-        if (!strcmp(tmp, "concat")) {
-            out = -1;
-        } else if (!strcmp(tmp, "striped")) {
-            out = 0;
-        } else if (!strcmp(tmp, "raid5")) {
-            out = 5;
-        }
-        log_it(tmp);
-        if (is_this_raid_personality_registered(out)) {
-            log_it("Groovy. You've picked a RAID personality which is registered.");
-        } else {
-            if (ask_me_yes_or_no("You have chosen a RAID personality which is not registered with the kernel. Make another selection?"))
-            {
-                out = 999;
+    mr_asprintf(format_str, "ufs");
+#else
+    mr_asprintf(format_str, "ext3");
+#endif
+    newtOpenWindow(20, 5, 48, 10, "Add entry");
+    label0 = newtLabel(2, 1, "Device:    ");
+    label1 = newtLabel(2, 2, "Mountpoint:");
+    label2 = newtLabel(2, 3, "Size (MB): ");
+    label3 = newtLabel(2, 4, "Format:    ");
+    deviceComp = newtEntry(14, 1, device_str, 30, (void *) &device_here, 0);
+    mountpointComp = newtEntry(14, 2, mountpoint_str, 30, (void *) &mountpoint_here, 0);
+    formatComp = newtEntry(14, 4, format_str, 15, (void *) &format_here, 0);
+    sizeComp = newtEntry(14, 3, size_str, 10, (void *) &size_here, 0);
+    bOK = newtButton(5, 6, "  OK  ");
+    bCancel = newtButton(17, 6, "Cancel");
+    newtPushHelpLine
+        ("To add an entry to the mountlist, please fill in these fields and then hit 'OK'");
+    myForm = newtForm(NULL, NULL, 0);
+    newtFormAddComponents(myForm, deviceComp, mountpointComp, sizeComp,
+                          formatComp, label0, label1, label2, label3, bOK,
+                          bCancel, NULL);
+    for (b_res = NULL; b_res != bOK && b_res != bCancel;) {
+        b_res = newtRunForm(myForm);
+        mr_free(device_str);
+        device_str = mr_strip_spaces(device_here);
+
+        mr_free(mountpoint_str);
+        mountpoint_str = mr_strip_spaces(mountpoint_here);
+
+        mr_free(format_str);
+        format_str = mr_strip_spaces(format_here);
+
+        mr_free(size_str);
+        size_str = mr_strip_spaces(size_here);
+
+        if (b_res == bOK) {
+            if (device_str[strlen(device_str) - 1] == '/') {
+                popup_and_OK("You left the device nearly blank!");
+                b_res = NULL;
             }
-        }
-    }
-    mr_free(prompt);
-
-    raidrec->raidlevel = out;
-#else
-    /** buffers ***********************************************************/
-    char tmp[MAX_STR_LEN];
-    char *personalities = NULL;
-    char *prompt = NULL;
-    char sz[MAX_STR_LEN];
-    int out = 0;
-    int res = 0;
-
-
-    assert(raidrec != NULL);
-    paranoid_system("grep Pers /proc/mdstat > /tmp/raid-personalities.txt 2> /dev/null");
-    mr_asprintf(personalities, "%s", last_line_of_file("/tmp/raid-personalities.txt"));
-    mr_asprintf(prompt, "Please enter the RAID level you want. %s", personalities);
-    mr_free(personalities);
-
-    if (raidrec->raid_level == -1) {
-        strcpy(tmp, "linear");
-    } else {
-        sprintf(tmp, "%d", raidrec->raid_level);
-    }
-    for (out = 999;
-         out != -1 && out != 0 && out != 1 && out != 4 && out != 5
-         && out != 10;) {
-        res = popup_and_get_string("Specify RAID level", prompt, tmp, 10);
-        if (!res) {
-            return;
-        }
-        strip_spaces(tmp);
-        if (tmp[0] == '[' && tmp[strlen(tmp) - 1] == ']') {
-            strcpy(sz, tmp);
-            strncpy(tmp, sz + 1, strlen(sz) - 2);
-            tmp[strlen(sz) - 2] = '\0';
-        }
-        if (!strcmp(tmp, "linear")) {
-            out = -1;
-        } else if (!strncmp(tmp, "raid", 4)) {
-            out = atoi(tmp + 4);
-        } else {
-            out = atoi(tmp);
-        }
-        log_it(tmp);
-        if (is_this_raid_personality_registered(out)) {
-            log_it("Groovy. You've picked a RAID personality which is registered.");
-        } else {
-            if (ask_me_yes_or_no("You have chosen a RAID personality which is not registered with the kernel. Make another selection?")) {
-                out = 999;
+            if (size_of_specific_device_in_mountlist(mountlist, device_str) >= 0) {
+                popup_and_OK("Can't add this - you've got one already!");
+                b_res = NULL;
             }
         }
     }
-    mr_free(prompt);
-
-    raidrec->raid_level = out;
-#endif
+    newtFormDestroy(myForm);
+    newtPopHelpLine();
+    newtPopWindow();
+    if (b_res == bCancel) {
+        return;
+    }
+    mr_asprintf(drive_to_add, "%s", device_str);
+    for (i = strlen(drive_to_add); isdigit(drive_to_add[i - 1]); i--);
+    mr_free(drive_to_add);
+
+    currline = mountlist->entries;
+    strcpy(mountlist->el[currline].device, device_str);
+    strcpy(mountlist->el[currline].mountpoint, mountpoint_str);
+    mr_free(mountpoint_str);
+
+    strcpy(mountlist->el[currline].format, format_str);
+    mr_free(format_str);
+
+    mountlist->el[currline].size = atol(size_str) * 1024L;
+    mr_free(size_str);
+
+    mountlist->entries++;
+    if (strstr(mountlist->el[currline].device, RAID_DEVICE_STUB)) {
+        initiate_new_raidlist_entry(raidlist, mountlist, currline, device_str);
+    }
+    mr_free(device_str);
+
+    redraw_mountlist(mountlist, keylist, listbox);
 }
 
@@ -601 +1780 @@
 
 
-
-/**
- * Delete entry number @p currline from @p disklist.
- * @param disklist The disklist to remove the entry from.
- * @param raid_device The RAID device containing the partition we're removing.
- * Used only in the popup "are you sure?" box.
- * @param currline The line number (starting from 0) of the item to delete.
- * @ingroup restoreGuiDisklist
- */
-void
-delete_disklist_entry(struct list_of_disks *disklist, char *raid_device,
-                      int currline)
-{
-
-    /** int ***************************************************************/
-    int pos = 0;
-    int res = 0;
-
-    /** buffers ***********************************************************/
-    char *tmp = NULL;
-
-    assert(disklist != NULL);
-    assert_string_is_neither_NULL_nor_zerolength(raid_device);
-
-    mr_asprintf(tmp, "Delete %s from RAID device %s - are you sure?", disklist->el[currline].device, raid_device);
-    res = ask_me_yes_or_no(tmp);
-    mr_free(tmp);
-
-    if (!res) {
-        return;
-    }
-    for (pos = currline; pos < disklist->entries - 1; pos++) {
-        strcpy(disklist->el[pos].device, disklist->el[pos + 1].device);
-    }
-    disklist->entries--;
-}
-
-
-
-/**
- * Delete entry number @p currline from @p mountlist.
- * @param mountlist The mountlist to delete the entry from.
- * @param raidlist The raidlist that goes with @p mountlist.
- * @param listbox The Newt listbox component in the mountlist editor.
- * @param currline The line number (starting from 0) of the item to delete.
- * @param keylist The list of keys for @p listbox.
- * @ingroup restoreGuiMountlist
- */
-void
-delete_mountlist_entry(struct mountlist_itself *mountlist,
-                       struct raidlist_itself *raidlist,
-                       newtComponent listbox, int currline,
-                       void *keylist[])
-{
-
-    /** int ***************************************************************/
-    int pos = 0;
-    int res = 0;
-
-    /** buffers ***********************************************************/
-    char *tmp = NULL;
-    char *device = NULL;
-
-
-    assert(mountlist != NULL);
-    assert(raidlist != NULL);
-    assert(listbox != NULL);
-    assert(keylist != NULL);
-
-    pos = which_raid_device_is_using_this_partition(raidlist, mountlist->el[currline].device);
-    if (pos >= 0) {
-        mr_asprintf(tmp, "Cannot delete %s: it is in use by RAID device %s", mountlist->el[currline].device, raidlist->el[pos].OSSWAP(raid_device, volname));
-        popup_and_OK(tmp);
-        mr_free(tmp);
-        return;
-    }
-    mr_asprintf(tmp, "Delete %s - are you sure?", mountlist->el[currline].device);
-    res = ask_me_yes_or_no(tmp);
-    mr_free(tmp);
-
-    if (!res) {
-        return;
-    }
-    if (strstr(mountlist->el[currline].device, RAID_DEVICE_STUB)) {
-        mr_asprintf(device, "%s", mountlist->el[currline].device);
-        delete_raidlist_entry(mountlist, raidlist, device);
-        for (currline = 0;
-             currline < mountlist->entries
-             && strcmp(mountlist->el[currline].device, device);
-             currline++);
-        mr_free(device);
-
-        if (currline == mountlist->entries) {
-            log_it("Dev is gone. I can't delete it. Ho-hum");
-            return;
-        }
-    }
-    memcpy((void *) &mountlist->el[currline],
-           (void *) &mountlist->el[mountlist->entries - 1],
-           sizeof(struct mountlist_line));
-    mountlist->entries--;
-    redraw_mountlist(mountlist, keylist, listbox);
-}
-
-
 /**
  * Delete @p device from @p raidlist.
@@ -713 +1787 @@
  * @ingroup restoreGuiMountlist
  */
-void
-delete_raidlist_entry(struct mountlist_itself *mountlist,
+void delete_raidlist_entry(struct mountlist_itself *mountlist,
                       struct raidlist_itself *raidlist, char *device)
 {
@@ -783 +1856 @@
 
 
-#ifndef __FreeBSD__
-/**
- * Delete entry number @p lino in the additional RAID variables section of @p raidrec.
- * @param raidrec The RAID device record containing the RAID variable to delete.
- * @param lino The line number (starting from 0) of the variable to delete.
- * @ingroup restoreGuiVarslist
- */
-void delete_varslist_entry(struct raid_device_record *raidrec, int lino)
-{
-
-    /** buffers ************************************************************/
+
+/**
+ * Delete entry number @p currline from @p mountlist.
+ * @param mountlist The mountlist to delete the entry from.
+ * @param raidlist The raidlist that goes with @p mountlist.
+ * @param listbox The Newt listbox component in the mountlist editor.
+ * @param currline The line number (starting from 0) of the item to delete.
+ * @param keylist The list of keys for @p listbox.
+ * @ingroup restoreGuiMountlist
+ */
+void
+delete_mountlist_entry(struct mountlist_itself *mountlist,
+                       struct raidlist_itself *raidlist,
+                       newtComponent listbox, int currline,
+                       void *keylist[])
+{
+
+    /** int ***************************************************************/
+    int pos = 0;
+    int res = 0;
+
+    /** buffers ***********************************************************/
     char *tmp = NULL;
-    int res = 0;
-
-    /** structures *********************************************************/
-    struct additional_raid_variables *av;
-
-    assert(raidrec != NULL);
-
-    av = &raidrec->additional_vars;
-    mr_asprintf(tmp, "Delete %s - are you sure?", av->el[lino].label);
+    char *device = NULL;
+
+
+    assert(mountlist != NULL);
+    assert(raidlist != NULL);
+    assert(listbox != NULL);
+    assert(keylist != NULL);
+
+    pos = which_raid_device_is_using_this_partition(raidlist, mountlist->el[currline].device);
+    if (pos >= 0) {
+        mr_asprintf(tmp, "Cannot delete %s: it is in use by RAID device %s", mountlist->el[currline].device, raidlist->el[pos].OSSWAP(raid_device, volname));
+        popup_and_OK(tmp);
+        mr_free(tmp);
+        return;
+    }
+    mr_asprintf(tmp, "Delete %s - are you sure?", mountlist->el[currline].device);
     res = ask_me_yes_or_no(tmp);
     mr_free(tmp);
 
-    if (res) {
-        if (!strcmp(av->el[lino].label, "persistent-superblock")
-            || !strcmp(av->el[lino].label, "chunk-size")) {
-            mr_asprintf(tmp, "%s must not be deleted. It would be bad.", av->el[lino].label);
-            popup_and_OK(tmp);
-            mr_free(tmp);
+    if (!res) {
+        return;
+    }
+    if (strstr(mountlist->el[currline].device, RAID_DEVICE_STUB)) {
+        mr_asprintf(device, "%s", mountlist->el[currline].device);
+        delete_raidlist_entry(mountlist, raidlist, device);
+        for (currline = 0;
+             currline < mountlist->entries
+             && strcmp(mountlist->el[currline].device, device);
+             currline++);
+        mr_free(device);
+
+        if (currline == mountlist->entries) {
+            log_it("Dev is gone. I can't delete it. Ho-hum");
+            return;
+        }
+    }
+    memcpy((void *) &mountlist->el[currline],
+           (void *) &mountlist->el[mountlist->entries - 1],
+           sizeof(struct mountlist_line));
+    mountlist->entries--;
+    redraw_mountlist(mountlist, keylist, listbox);
+}
+
+
+/**
+ * Strip a path to the bare minimum (^ pointing to the directory above, plus filename).
+ * @param tmp The path to strip.
+ * @return The stripped path.
+ * @author Conor Daly
+ * @ingroup restoreUtilityGroup
+ */
+char *strip_path(char *tmp)
+{
+
+    int i = 0, j = 0, slashcount = 0;
+    int slashloc = 0, lastslashloc = 0;
+
+    while (tmp[i] != '\0') {    /* Count the slashes in tmp
+                                   1 slash per dir */
+        if (tmp[i] == '/') {
+            slashcount++;
+            lastslashloc = slashloc;
+            slashloc = i;
+            if (tmp[i + 1] == '\0') {   /* if this slash is last char, back off */
+                slashcount--;
+                slashloc = lastslashloc;
+            }
+        }
+        i++;
+    }
+    if (slashcount > 0)
+        slashcount--;           /* Keep one slash 'cos Hugh does... */
+
+    for (i = 0; i < slashcount; i++) {  /* Replace each dir with a space char */
+        tmpnopath[i] = ' ';
+    }
+
+    i = slashloc;
+    j = slashcount;
+    while (tmp[i] != '\0') {    /* Now add what's left of tmp */
+        if ((tmpprevpath[j] == ' ' || tmpprevpath[j] == '^')
+            && tmp[i] == '/' && tmpnopath[j - 1] != '^' && j != 0) {    /* Add a pointer upwards if this is not in the same dir as line above */
+            tmpnopath[j - 1] = '^';
         } else {
-            memcpy((void *) &av->el[lino], (void *) &av->el[av->entries--],
-                   sizeof(struct raid_var_line));
-        }
-    }
-}
-#endif
+            tmpnopath[j++] = tmp[i++];
+        }
+    }
+    tmpnopath[j] = '\0';
+
+    strcpy(tmpprevpath, tmpnopath); /* Make a copy for next iteration */
+
+    return (tmpnopath);
+}
+
 
 
@@ -924 +2077 @@
         return (0);
     }
-}
-
-
-/**
- * Strip a path to the bare minimum (^ pointing to the directory above, plus filename).
- * @param tmp The path to strip.
- * @return The stripped path.
- * @author Conor Daly
- * @ingroup restoreUtilityGroup
- */
-char *strip_path(char *tmp)
-{
-
-    int i = 0, j = 0, slashcount = 0;
-    int slashloc = 0, lastslashloc = 0;
-
-    while (tmp[i] != '\0') {    /* Count the slashes in tmp
-                                   1 slash per dir */
-        if (tmp[i] == '/') {
-            slashcount++;
-            lastslashloc = slashloc;
-            slashloc = i;
-            if (tmp[i + 1] == '\0') {   /* if this slash is last char, back off */
-                slashcount--;
-                slashloc = lastslashloc;
-            }
-        }
-        i++;
-    }
-    if (slashcount > 0)
-        slashcount--;           /* Keep one slash 'cos Hugh does... */
-
-    for (i = 0; i < slashcount; i++) {  /* Replace each dir with a space char */
-        tmpnopath[i] = ' ';
-    }
-
-    i = slashloc;
-    j = slashcount;
-    while (tmp[i] != '\0') {    /* Now add what's left of tmp */
-        if ((tmpprevpath[j] == ' ' || tmpprevpath[j] == '^')
-            && tmp[i] == '/' && tmpnopath[j - 1] != '^' && j != 0) {    /* Add a pointer upwards if this is not in the same dir as line above */
-            tmpnopath[j - 1] = '^';
-        } else {
-            tmpnopath[j++] = tmp[i++];
-        }
-    }
-    tmpnopath[j] = '\0';
-
-    strcpy(tmpprevpath, tmpnopath); /* Make a copy for next iteration */
-
-    return (tmpnopath);
 }
 
@@ -1113 +2215 @@
 
 /**
+ * Change all RAID devices to use @p new_dev instead of @p old_dev.
+ * @param raidlist The raidlist to make the changes in.
+ * @param old_dev The old name of the device (what it used to be).
+ * @param new_dev The new name of the device (what it is now).
+ * @ingroup restoreGuiMountlist
+ */
+void rejig_partition_name_in_raidlist_if_necessary(struct raidlist_itself
+                                                   *raidlist,
+                                                   char *old_dev,
+                                                   char *new_dev)
+{
+    /** int ************************************************************/
+    int pos = 0;
+    int j = 0;
+
+    assert(raidlist != NULL);
+    assert_string_is_neither_NULL_nor_zerolength(old_dev);
+    assert_string_is_neither_NULL_nor_zerolength(new_dev);
+
+    pos = which_raid_device_is_using_this_partition(raidlist, old_dev);
+    if (pos < 0) {
+        log_it("No need to rejig %s in raidlist: it's not listed.", old_dev);
+    } else {
+        if ((j =
+             where_in_drivelist_is_drive(&raidlist->
+                                         OSSWAP(el[pos].data_disks, disks),
+                                         old_dev)) >= 0) {
+            strcpy(raidlist->OSSWAP(el[pos].data_disks, disks).el[j].device, new_dev);
+        } else
+            if ((j =
+                 where_in_drivelist_is_drive(&raidlist->
+                                             OSSWAP(el[pos].spare_disks,
+                                                    spares),
+                                             old_dev)) >= 0) {
+            strcpy(raidlist->OSSWAP(el[pos].spare_disks, spares).el[j].device, new_dev);
+        }
+#ifndef __FreeBSD__
+        else if ((j =
+                  where_in_drivelist_is_drive(&raidlist->el[pos].
+                                              parity_disks,
+                                              old_dev)) >= 0) {
+            strcpy(raidlist->el[pos].parity_disks.el[j].device, new_dev);
+        } else
+            if ((j =
+                 where_in_drivelist_is_drive(&raidlist->el[pos].
+                                             failed_disks,
+                                             old_dev)) >= 0) {
+            strcpy(raidlist->el[pos].failed_disks.el[j].device, new_dev);
+        }
+#endif
+        else {
+            log_it("%s is supposed to be listed in this raid dev but it's not...", old_dev);
+        }
+    }
+}
+
+
+/**
  * Edit an entry in @p mountlist.
  * @param mountlist The mountlist containing information about the user's partitions.
@@ -1380 +2540 @@
                    struct vinum_plex *raidrec, int currline,
                    int currline2);
-
-#endif
-
-
-/**
- * Edit the entry for @p raidrec in @p raidlist.
- * @param mountlist The mountlist to get some information from.
- * @param raidlist The raidlist containing information about RAID devices.
- * @param raidrec The RAID device record for this partition.
- * @param currline The line number (starting from 0) in the mountlist of the RAID device.
- * @ingroup restoreGuiMountlist
- */
-void
-edit_raidlist_entry(struct mountlist_itself *mountlist,
-                    struct raidlist_itself *raidlist,
-                    struct OSSWAP (raid_device_record,
-                                   vinum_volume) * raidrec, int currline)
-{
-
-#ifdef __FreeBSD__
-    /** structures ********************************************************/
-    struct vinum_volume bkp_raidrec;
-
-
-    /** buffers ***********************************************************/
-    char title_of_editraidForm_window[MAX_STR_LEN];
-
-    /** newt **************************************************************/
-    newtComponent editraidForm;
-    newtComponent bOK;
-    newtComponent bCancel;
-    newtComponent bEdit;
-    newtComponent bAdd;
-    newtComponent bDelete;
-    newtComponent b_res;
-    newtComponent plexesListbox;
-    newtComponent plexesHeader;
-
-    void *keylist[10];
-    void *curr_choice;
-    char *raidlevel = NULL;
-    char *chunksize = NULL;
-    char *msg = NULL;
-
-    int currline2 = 0;
-    int res = 0;
-
-    log_it("Started edit_raidlist_entry");
-    memcpy((void *) &bkp_raidrec, (void *) raidrec,
-           sizeof(struct vinum_volume));
-    sprintf(title_of_editraidForm_window, "Plexes on %s",
-            raidrec->volname);
-    newtPushHelpLine("   Please select a plex to edit");
-    newtOpenWindow(13, 5, 54, 15, title_of_editraidForm_window);
-    for (;;) {
-        int i;
-        char *headerstr = NULL;
-        mr_asprintf(headerstr, "%-14s %-8s  %11s  %8s", "Plex", "Level", "Stripe Size", "Subdisks");
-
-        bOK = newtCompactButton(2, 13, "  OK  ");
-        bCancel = newtCompactButton(12, 13, "Cancel");
-        bAdd = newtCompactButton(22, 13, " Add ");
-        bEdit = newtCompactButton(32, 13, " Edit ");
-        bDelete = newtCompactButton(42, 13, "Delete");
-
-        plexesListbox =
-            newtListbox(2, 3, 9, NEWT_FLAG_SCROLL | NEWT_FLAG_RETURNEXIT);
-        plexesHeader = newtLabel(2, 2, headerstr);
-        mr_free(headerstr);
-        editraidForm = newtForm(NULL, NULL, 0);
-
-        newtListboxClear(plexesListbox);
-        for (i = 0; i < 10; ++i) {
-            keylist[i] = (void *) i;
-            if (i < raidrec->plexes) {
-                char *pname;
-                char *entry;
-                switch (raidrec->plex[i].raidlevel) {
-                case -1:
-                    mr_asprintf(raidlevel, "concat");
-                    break;
-                case 0:
-                    mr_asprintf(raidlevel, "striped");
-                    break;
-                case 5:
-                    mr_asprintf(raidlevel, "raid5");
-                    break;
-                default:
-                    mr_asprintf(raidlevel, "raid%i", raidrec->plex[i].raidlevel);
-                    break;
-                }
-
-                if (raidrec->plex[i].raidlevel == -1) {
-                    mr_asprintf(chunksize, "N/A");
-                } else {
-                    mr_asprintf(chunksize, "%dk", raidrec->plex[i].stripesize);
-                }
-                mr_asprintf(pname, "%s.p%i", raidrec->volname, i);
-                mr_asprintf(entry, "%-14s %-8s  %11s  %8d", pname, raidlevel, chunksize, raidrec->plex[i].subdisks);
-                mr_free(pname);
-                mr_free(raidlevel);
-                mr_free(chunksize);
-
-                newtListboxAppendEntry(plexesListbox, entry, keylist[i]);
-                mr_free(entry);
-            }
-        }
-
-        newtFormAddComponents(editraidForm, bOK, bCancel, bAdd, bEdit,
-                              bDelete, plexesListbox, plexesHeader, NULL);
-
-        b_res = newtRunForm(editraidForm);
-        if (b_res == bOK || b_res == bCancel) {
-            break;
-        }
-
-        curr_choice = newtListboxGetCurrent(plexesListbox);
-        for (currline2 = 0; currline2 < raidrec->plexes; ++currline2) {
-            if (currline2 > 9)
-                break;
-            if (keylist[currline2] == curr_choice)
-                break;
-        }
-
-        if (b_res == bDelete) {
-            mr_asprintf(msg, "Are you sure you want to delete %s.p%i?", raidrec->volname, currline2);
-            res = ask_me_yes_or_no(msg);
-            mr_free(msg);
-
-            if (res) {
-                log_it("Deleting RAID plex");
-                memcpy((void *) &raidrec->plex[currline2],
-                       (void *) &raidrec->plex[raidrec->plexes - 1],
-                       sizeof(struct vinum_plex));
-                raidrec->plexes--;
-            }
-            continue;
-        }
-        if (b_res == bAdd) {
-            raidrec->plex[raidrec->plexes].raidlevel = 0;
-            raidrec->plex[raidrec->plexes].stripesize = 279;
-            raidrec->plex[raidrec->plexes].subdisks = 0;
-            currline2 = raidrec->plexes++;
-        }
-        edit_raidlist_plex(mountlist, raidlist, &raidrec->plex[currline2],
-                           currline, currline2);
-        newtFormDestroy(editraidForm);
-    }
-    if (b_res == bCancel) {
-        memcpy((void *) raidrec, (void *) &bkp_raidrec,
-               sizeof(struct vinum_volume));
-    }
-    newtPopHelpLine();
-    newtPopWindow();
-    mountlist->el[currline].size =
-        calculate_raid_device_size(mountlist, raidlist, raidrec->volname);
-#else
-    /** structures ********************************************************/
-    struct raid_device_record *bkp_raidrec;
-
-
-    /** buffers ***********************************************************/
-    char *title_of_editraidForm_window;
-    char *sz_raid_level = NULL;
-    char *sz_data_disks = NULL;
-    char *sz_spare_disks = NULL;
-    char *sz_parity_disks = NULL;
-    char *sz_failed_disks = NULL;
-
-    /** newt **************************************************************/
-    newtComponent editraidForm;
-    newtComponent bOK;
-    newtComponent bCancel;
-    newtComponent bAdditional;
-    newtComponent bChangeRaid;
-    newtComponent bSelectData;
-    newtComponent bSelectSpare;
-    newtComponent bSelectParity;
-    newtComponent bSelectFailed;
-    newtComponent b_res;
-
-    assert(mountlist != NULL);
-    assert(raidlist != NULL);
-    assert(raidrec != NULL);
-
-    bkp_raidrec = mr_malloc(sizeof(struct raid_device_record));
-    log_it("Started edit_raidlist_entry");
-
-    memcpy((void *) bkp_raidrec, (void *) raidrec, sizeof(struct raid_device_record));
-    mr_asprintf(title_of_editraidForm_window, "%s", raidrec->raid_device);
-    log_msg(2, "Opening newt window");
-    newtOpenWindow(20, 5, 40, 14, title_of_editraidForm_window);
-    for (;;) {
-        log_msg(2, "Main loop");
-        mr_free(title_of_editraidForm_window);
-        mr_asprintf(title_of_editraidForm_window, "Edit %s", raidrec->raid_device);
-        sz_raid_level = turn_raid_level_number_to_string(raidrec->raid_level);
-        sz_data_disks = number_of_disks_as_string(raidrec->data_disks.entries, "data");
-        sz_spare_disks = number_of_disks_as_string(raidrec->spare_disks.entries, "spare");
-        sz_parity_disks = number_of_disks_as_string(raidrec->parity_disks.entries, "parity");
-        sz_failed_disks = number_of_disks_as_string(raidrec->failed_disks.entries, "failed");
-        bSelectData = newtButton(1, 1, sz_data_disks);
-        bSelectSpare = newtButton(20, 1, sz_spare_disks);
-        bSelectParity = newtButton(1, 5, sz_parity_disks);
-        bSelectFailed = newtButton(20, 5, sz_failed_disks);
-        bChangeRaid = newtButton(1, 9, sz_raid_level);
-        bOK = newtButton(16 + (raidrec->raid_level == -1), 9, "  OK  ");
-        bCancel = newtButton(28, 9, "Cancel");
-        bAdditional =
-            newtCompactButton(1, 13,
-                              "Additional settings and information");
-        newtPushHelpLine
-            ("  Edit the RAID device's settings to your heart's content, then hit OK/Cancel.");
-        editraidForm = newtForm(NULL, NULL, 0);
-        newtFormAddComponents(editraidForm, bSelectData, bSelectParity,
-                              bChangeRaid, bSelectSpare, bSelectFailed,
-                              bOK, bCancel, bAdditional);
-        b_res = newtRunForm(editraidForm);
-        if (b_res == bChangeRaid) {
-            choose_raid_level(raidrec);
-        } else if (b_res == bSelectData) {
-            select_raid_disks(mountlist, raidlist, raidrec, "data", &raidrec->data_disks);
-        } else if (b_res == bSelectSpare) {
-            select_raid_disks(mountlist, raidlist, raidrec, "spare", &raidrec->spare_disks);
-        } else if (b_res == bSelectParity) {
-            select_raid_disks(mountlist, raidlist, raidrec, "parity", &raidrec->parity_disks);
-        } else if (b_res == bSelectFailed) {
-            select_raid_disks(mountlist, raidlist, raidrec, "failed", &raidrec->failed_disks);
-        } else if (b_res == bAdditional) {
-            edit_raidrec_additional_vars(raidrec);
-        }
-        newtFormDestroy(editraidForm);
-        if (b_res == bOK || b_res == bCancel) {
-            break;
-        }
-        mr_free(sz_data_disks);
-        mr_free(sz_spare_disks);
-        mr_free(sz_parity_disks);
-        mr_free(sz_failed_disks);
-    }
-    if (b_res == bCancel) {
-        memcpy((void *) raidrec, (void *) bkp_raidrec, sizeof(struct raid_device_record));
-    }
-    newtPopHelpLine();
-    newtPopWindow();
-    mountlist->el[currline].size = calculate_raid_device_size(mountlist, raidlist, raidrec->raid_device);
-    mr_free(title_of_editraidForm_window);
-    mr_free(sz_raid_level);
-    paranoid_free(bkp_raidrec);
-#endif
-}
-
-#ifdef __FreeBSD__
-
-/**
- * Edit the plex @p raidrec in @p raidlist.
- * @param mountlist The mountlist to get some of the information from.
- * @param raidlist The raidlist containing information about RAID devices.
- * @param raidrec The plex to edit.
- * @param currline The line number (starting from 0) of the RAID device in @p mountlist.
- * @param currline2 The line number (starting from 0) of the plex within the RAID device.
- * @author Joshua Oreman
- * @ingroup restoreGuiMountlist
- */
-void
-edit_raidlist_plex(struct mountlist_itself *mountlist,
-                   struct raidlist_itself *raidlist,
-                   struct vinum_plex *raidrec, int currline, int currline2)
-{
-
-    /** structures ********************************************************/
-    struct vinum_plex bkp_raidrec;
-
-
-    /** buffers ***********************************************************/
-    char *title_of_editraidForm_window = NULL;
-
-    /** newt **************************************************************/
-    newtComponent editraidForm;
-    newtComponent bOK;
-    newtComponent bCancel;
-    newtComponent bEdit;
-    newtComponent bAdd;
-    newtComponent bDelete;
-    newtComponent b_res;
-    newtComponent unallocListbox, allocListbox;
-    newtComponent bLevel, sLevel;
-    newtComponent bStripeSize, sStripeSize;
-    newtComponent bAlloc, bUnalloc;
-
-    void *keylist[ARBITRARY_MAXIMUM];
-    void *curr_choice_a, *curr_choice_u;
-    int currline_a, currline_u;
-
-    char *p = NULL;
-    char *tmp = NULL;
-    char *entry = NULL;
-
-    struct mountlist_itself *unallocparts;
-
-    unallocparts = malloc(sizeof(struct mountlist_itself));
-
-    log_it("Started edit_raidlist_entry");
-    memcpy((void *) &bkp_raidrec, (void *) raidrec,
-           sizeof(struct vinum_plex));
-    mr_asprintf(title_of_editraidForm_window, "%s.p%i", raidlist->el[currline].volname, currline2);
-    newtPushHelpLine
-        ("   Please select a subdisk to edit, or edit this plex's parameters");
-    newtOpenWindow(13, 3, 54, 18, title_of_editraidForm_window);
-    mr_free(title_of_editraidForm_window);
-
-    for (;;) {
-        int i;
-
-        switch (raidrec->raidlevel) {
-        case -1:
-            mr_asprintf(tmp, "concat");
-            break;
-        case 0:
-            mr_asprintf(tmp, "striped");
-            break;
-        case 5:
-            mr_asprintf(tmp, "raid5");
-            break;
-        default:
-            mr_asprintf(tmp, "unknown (%i)", raidrec->raidlevel);
-            break;
-        }
-        bLevel = newtCompactButton(2, 2, " RAID level ");
-        sLevel = newtLabel(19, 2, tmp);
-        mr_free(tmp);
-
-        if (raidrec->raidlevel >= 0) {
-            mr_asprintf(tmp, "%ik", raidrec->stripesize);
-            bStripeSize = newtCompactButton(2, 4, " Stripe size ");
-        } else {
-            mr_asprintf(tmp, "N/A");
-            bStripeSize = newtLabel(2, 4, "Stripe size:");
-        }
-        sStripeSize = newtLabel(19, 4, tmp);
-        mr_free(tmp);
-
-        bOK = newtCompactButton(2, 16, "  OK  ");
-        bCancel = newtCompactButton(12, 16, "Cancel");
-        bAdd = newtCompactButton(22, 16, " Add ");
-        bEdit = newtCompactButton(32, 16, " Edit ");
-        bDelete = newtCompactButton(42, 16, "Delete");
-
-
-        unallocListbox =
-            newtListbox(2, 7, 7, NEWT_FLAG_SCROLL | NEWT_FLAG_RETURNEXIT);
-        allocListbox =
-            newtListbox(33, 7, 7, NEWT_FLAG_SCROLL | NEWT_FLAG_RETURNEXIT);
-        bAlloc = newtButton(23, 7, " -> ");
-        bUnalloc = newtButton(23, 11, " <- ");
-
-        editraidForm = newtForm(NULL, NULL, 0);
-
-        newtListboxClear(allocListbox);
-        newtListboxClear(unallocListbox);
-        bzero(unallocparts, sizeof(struct mountlist_itself));
-        make_list_of_unallocated_raid_partitions(unallocparts, mountlist,
-                                                 raidlist);
-        for (i = 0; i < ARBITRARY_MAXIMUM; ++i) {
-            keylist[i] = (void *) i;
-            if (i < raidrec->subdisks) {
-                mr_asprintf(entry, "%-17s", find_dev_entry_for_raid_device_name(raidlist, raidrec->sd[i].which_device));
-                newtListboxAppendEntry(allocListbox, entry, keylist[i]);
-                mr_free(entry);
-            }
-            if (i < unallocparts->entries) {
-                mr_asprintf(entry, "%-17s", unallocparts->el[i].device);
-                newtListboxAppendEntry(unallocListbox, entry, keylist[i]);
-                mr_free(entry);
-            }
-        }
-
-#define COMP(x)  newtFormAddComponent (editraidForm, x)
-#define UCOMP(x) if (unallocparts->entries > 0) COMP(x)
-#define ACOMP(x) if (raidrec->subdisks > 0) COMP(x)
-        editraidForm = newtForm(NULL, NULL, 0);
-        UCOMP(unallocListbox);
-        UCOMP(bAlloc);
-        ACOMP(allocListbox);
-        ACOMP(bUnalloc);
-        COMP(bOK);
-        COMP(bCancel);
-        COMP(bLevel);
-        COMP(sLevel);
-        if (raidrec->raidlevel != -1) {
-            COMP(bStripeSize);
-            COMP(sStripeSize);
-        }
-#undef COMP
-#undef UCOMP
-#undef ACOMP
-
-        newtDrawForm(editraidForm);
-        newtRefresh();
-        b_res = newtRunForm(editraidForm);
-        if (b_res == bOK || b_res == bCancel) {
-            break;
-        }
-
-        curr_choice_a = (raidrec->subdisks > 0) ?
-            newtListboxGetCurrent(allocListbox) : (void *) 1234;
-        curr_choice_u = (unallocparts->entries > 0) ?
-            newtListboxGetCurrent(unallocListbox) : (void *) 1234;
-        for (currline_a = 0; currline_a < raidrec->subdisks; ++currline_a) {
-            if (currline_a > ARBITRARY_MAXIMUM)
-                break;
-            if (keylist[currline_a] == curr_choice_a)
-                break;
-        }
-        for (currline_u = 0; currline_u < unallocparts->entries;
-             ++currline_u) {
-            if (currline_u > ARBITRARY_MAXIMUM)
-                break;
-            if (keylist[currline_u] == curr_choice_u)
-                break;
-        }
-        if (b_res == bLevel) {
-            choose_raid_level(raidrec);
-        } else if (b_res == bStripeSize) {
-            char tmp1[64];
-            sprintf(tmp1, "%i", raidrec->stripesize);
-            if (popup_and_get_string
-                ("Stripe size",
-                 "Please enter the stripe size in kilobytes.", tmp1, 20)) {
-                raidrec->stripesize = atoi(tmp1);
-            }
-        } else if ((b_res == bAlloc) || (b_res == unallocListbox)) {
-            if (currline_u <= unallocparts->entries)
-                add_raid_subdisk(raidlist, raidrec,
-                                 unallocparts->el[currline_u].device);
-        } else if ((b_res == bUnalloc) || (b_res == allocListbox)) {
-            if (currline_a <= raidrec->subdisks) {
-                memcpy((void *) &raidrec->sd[currline_a],
-                       (void *) &raidrec->sd[raidrec->subdisks - 1],
-                       sizeof(struct vinum_subdisk));
-                raidrec->subdisks--;
-            }
-        }
-    newtFormDestroy(editraidForm);
-    newtRefresh();
-}
-
-if (b_res == bCancel) {
-    memcpy((void *) raidrec, (void *) &bkp_raidrec, sizeof(struct vinum_plex));
-}
-newtPopWindow();
-newtPopHelpLine();
-}
-#else
-/**
- * Edit additional RAID variable number @p lino.
- * @param raidrec The RAID device record to edit the variable in.
- * @param lino The line number (starting from 0) of the variable to edit.
- * @ingroup restoreGuiVarslist
- */
-void edit_varslist_entry(struct raid_device_record *raidrec, int lino)
-{
-
-    /** buffers ***********************************************************/
-    char *header = NULL;
-    char *comment = NULL;
-    char sz_out[MAX_STR_LEN];
-
-    assert(raidrec != 0);
-    assert(lino >= 0);
-
-    strcpy(sz_out, raidrec->additional_vars.el[lino].value);
-    mr_asprintf(header, "Edit %s", raidrec->additional_vars.el[lino].label);
-    mr_asprintf(comment, "Please set %s's value (currently '%s')", raidrec->additional_vars.el[lino].label, sz_out);
-    if (popup_and_get_string(header, comment, sz_out, MAX_STR_LEN)) {
-        strip_spaces(sz_out);
-        strcpy(raidrec->additional_vars.el[lino].value, sz_out);
-    }
-    mr_free(header);
-    mr_free(comment);
-}
 
 #endif
@@ -2048 +2727 @@
 }
 
-
-
-
-#ifndef __FreeBSD__
-/**
- * Edit the additional RAID variables in @p raidrec.
- * @param raidrec The RAID device record to edit the RAID variables in.
- * @ingroup restoreGuiVarslist
- */
-void edit_raidrec_additional_vars(struct raid_device_record *raidrec)
-{
-
-    /** structure *********************************************************/
-    struct raid_device_record bkp_raidrec;
-
-    /** newt **************************************************************/
-    newtComponent myForm;
-    newtComponent bAdd;
-    newtComponent bEdit;
-    newtComponent bDelete;
-    newtComponent bOK;
-    newtComponent bCancel;
-    newtComponent b_res;
-    newtComponent varsListbox;
-    newtComponent headerMsg;
-
-    /** ?? ***************************************************************/
-    void *keylist[ARBITRARY_MAXIMUM], *curr_choice;
-
-    /** buffers **********************************************************/
-    char title_of_window[MAX_STR_LEN];
-
-    /** int **************************************************************/
-    int i = 0;
-    int currline = 0;
-
-
-    assert(raidrec != NULL);
-
-    memcpy((void *) &bkp_raidrec, (void *) raidrec,
-           sizeof(struct raid_device_record));
-    sprintf(title_of_window, "Additional variables");
-    newtPushHelpLine
-        ("  Edit the additional fields to your heart's content, then click OK or Cancel.");
-    headerMsg = newtLabel(1, 1, "Label                            Value");
-    varsListbox =
-        newtListbox(1, 2, 6, NEWT_FLAG_SCROLL | NEWT_FLAG_RETURNEXIT);
-    i = 1;
-    bAdd = newtCompactButton(i, 9, " Add ");
-    bEdit = newtCompactButton(i += 8, 9, " Edit ");
-    bDelete = newtCompactButton(i += 9, 9, "Delete");
-    bOK = newtCompactButton(i += 9, 9, "  OK  ");
-    bCancel = newtCompactButton(i += 9, 9, "Cancel");
-    newtOpenWindow(17, 7, 46, 10, title_of_window);
-    myForm = newtForm(NULL, NULL, 0);
-    newtFormAddComponents(myForm, headerMsg, varsListbox, bAdd, bEdit,
-                          bDelete, bOK, bCancel, NULL);
-    insert_essential_additionalvars(raidrec);
-    redraw_varslist(&raidrec->additional_vars, keylist, varsListbox);
-    for (b_res = NULL; b_res != bOK && b_res != bCancel;) {
-        b_res = newtRunForm(myForm);
-        curr_choice = newtListboxGetCurrent(varsListbox);
-        for (currline = 0;
-             currline < raidrec->additional_vars.entries
-             && keylist[currline] != curr_choice; currline++);
-        if (currline == raidrec->additional_vars.entries
-            && raidrec->additional_vars.entries > 0) {
-            log_it("Warning - I don't know what this button does");
-        }
-        if (b_res == bOK) {     /* do nothing */
-        } else if (b_res == bCancel) {  /* do nothing */
-        } else if (b_res == bAdd) {
-            add_varslist_entry(raidrec);
-        } else if (b_res == bDelete) {
-            delete_varslist_entry(raidrec, currline);
-        } else {
-            edit_varslist_entry(raidrec, currline);
-        }
-        redraw_varslist(&raidrec->additional_vars, keylist, varsListbox);
-    }
-    remove_essential_additionalvars(raidrec);
-    newtFormDestroy(myForm);
-    newtPopWindow();
-    newtPopHelpLine();
-    if (b_res == bCancel) {
-        memcpy((void *) raidrec, (void *) &bkp_raidrec,
-               sizeof(struct raid_device_record));
-    }
-    return;
-}
-#endif
-
-
-/**
- * Find the next free location to place a disk in @p disklist.
- * @param disklist The disklist to operate on.
- * @return The next free location (starting from 0).
- * @ingroup restoreGuiDisklist
- */
-int find_next_free_index_in_disklist(struct list_of_disks *disklist)
-{
-
-    /** int ***************************************************************/
-    int index = -1;
-    int pos = 0;
-
-  /** bool **************************************************************/
-    bool done;
-
-    assert(disklist != NULL);
-
-    for (done = FALSE; !done;) {
-        for (pos = 0;
-             pos < disklist->entries && disklist->el[pos].index <= index;
-             pos++);
-        if (pos >= disklist->entries) {
-            done = TRUE;
-        } else {
-            index = disklist->el[pos].index;
-        }
-    }
-    return (index + 1);
-}
-
-
-
-/**
- * Locate @p device in @p raidlist.
- * @param raidlist The raidlist ot search in.
- * @param device The RAID device to search for.
- * @return The index of the device, or -1 if it could not be found.
- * @ingroup restoreGuiMountlist
- */
-int
-find_raid_device_in_raidlist(struct raidlist_itself *raidlist,
-                             char *device)
-{
-
-    /** int ***************************************************************/
-    int i = 0;
-#ifdef __FreeBSD__
-    char *vdev = NULL;
-    int res = 0;
-#else
-// Linux
-#endif
-
-    assert(raidlist != NULL);
-    assert_string_is_neither_NULL_nor_zerolength(device);
-
-#ifdef __FreeBSD__
-    for (i = 0; i < raidlist->entries; i++) {
-        mr_asprintf(vdev, "/dev/vinum/%s", raidlist->el[i].volname);
-        res = strcmp(device, vdev);
-        mr_free(vdev);
-
-        if (!res)
-            break;
-    }
-#else
-
-    for (i = 0;
-         strcmp(raidlist->el[i].raid_device, device)
-         && i < raidlist->entries; i++);
-#endif
-    if (i == raidlist->entries) {
-        return (-1);
-    } else {
-        return (i);
-    }
-}
-
-
-/**
- * Create a new raidtab entry for @p device in @p raidlist.
- * @param raidlist The raidlist to add the device to.
- * @param mountlist The mountlist containing information about the user's partitions.
- * @param currline The selected line in the mountlist.
- * @param device The RAID device (e.g. /dev/md0) to use.
- * @ingroup restoreGuiMountlist
- */
-void
-initiate_new_raidlist_entry(struct raidlist_itself *raidlist,
-                            struct mountlist_itself *mountlist,
-                            int currline, char *device)
-{
-
-    /** structure *********************************************************/
-    struct OSSWAP (raid_device_record, vinum_volume) * raidrec;
-
-    /** int ***************************************************************/
-    int pos_in_raidlist = 0;
-
-    assert(raidlist != NULL);
-    assert(mountlist != NULL);
-    assert_string_is_neither_NULL_nor_zerolength(device);
-
-    pos_in_raidlist =
-        find_raid_device_in_raidlist(raidlist,
-                                     mountlist->el[currline].device);
-    if (pos_in_raidlist >= 0) {
-        fatal_error("Sorry, that RAID device already exists. Weird.");
-    }
-    pos_in_raidlist = raidlist->entries++;
-    raidrec = &raidlist->el[pos_in_raidlist];
-    initialize_raidrec(raidrec);
-    strcpy(raidrec->OSSWAP(raid_device, volname), OSSWAP(device, basename(device)));
-#ifndef __FreeBSD__
-    choose_raid_level(raidrec);
-    select_raid_disks(mountlist, raidlist, raidrec, "data",
-                      &raidrec->data_disks);
-#endif
-    edit_raidlist_entry(mountlist, raidlist, raidrec, currline);
-}
-
-
-#ifndef __FreeBSD__
-/**
- * Insert the RAID variables not stored in the "additional RAID variables" list there too.
- * @param raidrec The RAID device record to operate on.
- * @ingroup restoreGuiVarslist
- */
-void insert_essential_additionalvars(struct raid_device_record *raidrec)
-{
-
-    /** int **************************************************************/
-    int items = 0;
-
-    assert(raidrec != NULL);
-
-    items = raidrec->additional_vars.entries;
-    write_variableINT_to_raid_var_line(raidrec, items++,
-                                       "persistent-superblock",
-                                       raidrec->persistent_superblock);
-    write_variableINT_to_raid_var_line(raidrec, items++, "chunk-size",
-                                       raidrec->chunk_size);
-    raidrec->additional_vars.entries = items;
-}
-
-#endif
-
 /**
  * Dummy function that proves that we can get to the point where Mondo is run.
@@ -2314 +2752 @@
     newtPopHelpLine();
 }
-
-
-
-/**
- * Redraw the disklist.
- * @param disklist The disklist to read from.
- * @param keylist The list of keys for @p listbox.
- * @param listbox The Newt listbox component to redraw.
- * @ingroup restoreGuiDisklist
- */
-void
-redraw_disklist(struct list_of_disks *disklist,
-                void *keylist[ARBITRARY_MAXIMUM], newtComponent listbox)
-{
-
-    /** long **************************************************************/
-    long i = 0;
-    char *tmp = NULL;
-
-    assert(disklist != NULL);
-    assert(keylist != NULL);
-    assert(listbox != NULL);
-
-    newtListboxClear(listbox);
-
-    for (i = 0; i < ARBITRARY_MAXIMUM; i++) {
-        keylist[i] = (void *) i;
-    }
-    for (i = 0; i < disklist->entries; i++) {
-        tmp = disklist_entry_to_string(disklist, i);
-        newtListboxAppendEntry(listbox, tmp, keylist[i]);
-        mr_free(tmp);
-    }
-}
-
-
-/**
- * Redraw the mountlist.
- * @param mountlist The mountlist to read from.
- * @param keylist The list of keys for @p listbox.
- * @param listbox The Newt listbox component to redraw.
- * @ingroup restoreGuiMountlist
- */
-void
-redraw_mountlist(struct mountlist_itself *mountlist,
-                 void *keylist[ARBITRARY_MAXIMUM], newtComponent listbox)
-{
-
-    /** long **************************************************************/
-    long i = 0;
-    char * tmp = NULL;
-
-    assert(mountlist != NULL);
-    assert(keylist != NULL);
-    assert(listbox != NULL);
-
-    newtListboxClear(listbox);
-//  sort_mountlist_by_device (mountlist);
-    for (i = 0; i < ARBITRARY_MAXIMUM; i++) {
-        keylist[i] = (void *) i;
-    }
-    for (i = 0; i < mountlist->entries; i++) {
-        tmp = mountlist_entry_to_string(mountlist, i);
-        newtListboxAppendEntry(listbox, tmp, keylist[i]);
-        mr_free(tmp);
-    }
-}
-
-
-
-
-/**
- * Redraw the list of unallocated RAID partitions.
- * @param unallocated_raid_partitions The mountlist containing unallocated RAID partitions.
- * @param keylist The list of keys for @p listbox.
- * @param listbox The Newt listbox component to redraw.
- * @ingroup restoreGuiDisklist
- */
-void redraw_unallocpartnslist(struct mountlist_itself
-                              *unallocated_raid_partitions,
-                              void *keylist[ARBITRARY_MAXIMUM],
-                              newtComponent listbox)
-{
-
-    /** long *************************************************************/
-    long i = 0;
-
-    /** buffers **********************************************************/
-    char tmp[MAX_STR_LEN];
-
-    assert(unallocated_raid_partitions != NULL);
-    assert(keylist != NULL);
-    assert(listbox != NULL);
-
-    newtListboxClear(listbox);
-    for (i = 0; i < ARBITRARY_MAXIMUM; i++) {
-        keylist[i] = (void *) i;
-    }
-    for (i = 0; i < unallocated_raid_partitions->entries; i++) {
-        sprintf(tmp, "%-22s %8lld",
-                unallocated_raid_partitions->el[i].device,
-                unallocated_raid_partitions->el[i].size / 1024L);
-        newtListboxAppendEntry(listbox, tmp, keylist[i]);
-    }
-}
-
-#ifndef __FreeBSD__
-/**
- * Redraw the list of additional RAID variables.
- * @param additional_vars The list of additional RAID varibals.
- * @param keylist The list of keys for @p listbox.
- * @param listbox The Newt listbox component to redraw.
- * @ingroup restoreGuiVarslist
- */
-void
-redraw_varslist(struct additional_raid_variables *additional_vars,
-                void *keylist[], newtComponent listbox)
-{
-    /** long ************************************************************/
-    long i = 0;
-
-    /** buffers *********************************************************/
-    char tmp[MAX_STR_LEN];
-
-    assert(additional_vars != NULL);
-    assert(keylist != NULL);
-    assert(listbox != NULL);
-
-    newtListboxClear(listbox);
-
-    for (i = 0; i < ARBITRARY_MAXIMUM; i++) {
-        keylist[i] = (void *) i;
-    }
-    for (i = 0; i < additional_vars->entries; i++) {
-        sprintf(tmp, "%-32s %-8s", additional_vars->el[i].label,
-                additional_vars->el[i].value);
-        newtListboxAppendEntry(listbox, tmp, keylist[i]);
-    }
-}
-
-
-/**
- * Remove variable @p label from the RAID variables list in @p raidrec.
- * @param raidrec The RAID device record to remove the variable from.
- * @param label The variable name to remove.
- * @return The value of the variable removed.
- * @ingroup restoreUtilityGroup
- */
-int
-read_variableINT_and_remove_from_raidvars(struct
-                                          OSSWAP (raid_device_record,
-                                                  vinum_volume) * raidrec,
-                                          char *label)
-{
-    /** int ***************************************************************/
-    int i = 0;
-    int res = 0;
-
-
-    assert(raidrec != NULL);
-    assert(label != NULL);
-
-    for (i = 0;
-         i < raidrec->additional_vars.entries
-         && strcmp(raidrec->additional_vars.el[i].label, label); i++);
-    if (i == raidrec->additional_vars.entries) {
-        res = -1;
-    } else {
-        res = atoi(raidrec->additional_vars.el[i].value);
-        for (i++; i < raidrec->additional_vars.entries; i++) {
-            memcpy((void *) &raidrec->additional_vars.el[i - 1],
-                   (void *) &raidrec->additional_vars.el[i],
-                   sizeof(struct raid_var_line));
-        }
-        raidrec->additional_vars.entries--;
-    }
-    return (res);
-}
-#endif
-
-/**
- * Change all RAID devices to use @p new_dev instead of @p old_dev.
- * @param raidlist The raidlist to make the changes in.
- * @param old_dev The old name of the device (what it used to be).
- * @param new_dev The new name of the device (what it is now).
- * @ingroup restoreGuiMountlist
- */
-void rejig_partition_name_in_raidlist_if_necessary(struct raidlist_itself
-                                                   *raidlist,
-                                                   char *old_dev,
-                                                   char *new_dev)
-{
-    /** int ************************************************************/
-    int pos = 0;
-    int j = 0;
-
-    assert(raidlist != NULL);
-    assert_string_is_neither_NULL_nor_zerolength(old_dev);
-    assert_string_is_neither_NULL_nor_zerolength(new_dev);
-
-    pos = which_raid_device_is_using_this_partition(raidlist, old_dev);
-    if (pos < 0) {
-        log_it("No need to rejig %s in raidlist: it's not listed.", old_dev);
-    } else {
-        if ((j =
-             where_in_drivelist_is_drive(&raidlist->
-                                         OSSWAP(el[pos].data_disks, disks),
-                                         old_dev)) >= 0) {
-            strcpy(raidlist->OSSWAP(el[pos].data_disks, disks).el[j].device, new_dev);
-        } else
-            if ((j =
-                 where_in_drivelist_is_drive(&raidlist->
-                                             OSSWAP(el[pos].spare_disks,
-                                                    spares),
-                                             old_dev)) >= 0) {
-            strcpy(raidlist->OSSWAP(el[pos].spare_disks, spares).el[j].device, new_dev);
-        }
-#ifndef __FreeBSD__
-        else if ((j =
-                  where_in_drivelist_is_drive(&raidlist->el[pos].
-                                              parity_disks,
-                                              old_dev)) >= 0) {
-            strcpy(raidlist->el[pos].parity_disks.el[j].device, new_dev);
-        } else
-            if ((j =
-                 where_in_drivelist_is_drive(&raidlist->el[pos].
-                                             failed_disks,
-                                             old_dev)) >= 0) {
-            strcpy(raidlist->el[pos].failed_disks.el[j].device, new_dev);
-        }
-#endif
-        else {
-            log_it("%s is supposed to be listed in this raid dev but it's not...", old_dev);
-        }
-    }
-}
-
-
-#ifndef __FreeBSD__
-/**
- * Remove the essential RAID variables from the "additional variables" section.
- * If they have been changed, set them in their normal locations too.
- * @param raidrec The RAID device record to operate on.
- * @ingroup restoreUtilityVarslist
- */
-void remove_essential_additionalvars(struct raid_device_record *raidrec)
-{
-
-    /** int **************************************************************/
-    int res = 0;
-
-    assert(raidrec != NULL);
-
-    res =
-        read_variableINT_and_remove_from_raidvars(raidrec,
-                                                  "persistent-superblock");
-    if (res > 0) {
-        raidrec->persistent_superblock = res;
-    }
-    res = read_variableINT_and_remove_from_raidvars(raidrec, "chunk-size");
-    if (res > 0) {
-        raidrec->chunk_size = res;
-    }
-    res = read_variableINT_and_remove_from_raidvars(raidrec, "block-size");
-}
-
-/**
- * Select the RAID disks to use in @p raidrec.
- * @param mountlist_dontedit The mountlist (will not be edited).
- * @param raidlist The raidlist to modify.
- * @param raidrec The RAID device record in @p raidlist to work on.
- * @param description_of_list The type of disks we're selecting (e.g. "data").
- * @param disklist The disklist to put the user-selected disks in.
- * @ingroup restoreGuiMountlist
- */
-void
-select_raid_disks(struct mountlist_itself *mountlist_dontedit,
-                  struct raidlist_itself *raidlist,
-                  struct raid_device_record *raidrec,
-                  char *description_of_list,
-                  struct list_of_disks *disklist)
-{
-    void *curr_choice;
-
-    /** ??? ***************************************************************/
-
-    /** structures ********************************************************/
-    struct raidlist_itself *bkp_raidlist;
-    struct raid_device_record *bkp_raidrec;
-    struct list_of_disks *bkp_disklist;
-    struct mountlist_itself *unallocated_raid_partitions;
-
-    /** newt **************************************************************/
-    newtComponent myForm = NULL;
-    newtComponent bAdd = NULL;
-    newtComponent bDelete = NULL;
-    newtComponent bOK = NULL;
-    newtComponent bCancel = NULL;
-    newtComponent b_res = NULL;
-    newtComponent partitionsListbox = NULL;
-    newtComponent headerMsg = NULL;
-
-    /** buffers **********************************************************/
-    void *keylist[ARBITRARY_MAXIMUM];
-    char *tmp = NULL;
-    char *help_text = NULL;
-    char *title_of_window = NULL;
-    char sz_res[MAX_STR_LEN];
-    char *header_text = NULL;
-
-  /** int **************************************************************/
-    int i = 0;
-    int currline = 0;
-
-    assert(mountlist_dontedit != NULL);
-    assert(raidlist != NULL);
-    assert(raidrec != NULL);
-    assert(description_of_list != NULL);
-    assert(disklist != NULL);
-
-    log_it("malloc'ing");
-    bkp_raidrec = mr_malloc(sizeof(struct raid_device_record));
-    bkp_disklist = mr_malloc(sizeof(struct list_of_disks));
-    bkp_raidlist = mr_malloc(sizeof(struct raidlist_itself));
-    unallocated_raid_partitions = mr_malloc(sizeof(struct mountlist_itself));
-
-    memcpy((void *) bkp_raidlist, (void *) raidlist, sizeof(struct raidlist_itself));
-    memcpy((void *) bkp_raidrec, (void *) raidrec, sizeof(struct raid_device_record));
-    memcpy((void *) bkp_disklist, (void *) disklist, sizeof(struct list_of_disks));
-
-    log_it("Post-malloc");
-    mr_asprintf(help_text, "   Edit this RAID device's list of partitions. Choose OK or Cancel when done.");
-    mr_asprintf(header_text, "%-24s    %s", "Device", "Index");
-    mr_asprintf(title_of_window, "%s contains...", raidrec->raid_device);
-    newtPushHelpLine(help_text);
-    for (b_res = (newtComponent) 12345; b_res != bOK && b_res != bCancel;) {
-        headerMsg = newtLabel(1, 1, header_text);
-        partitionsListbox =
-            newtListbox(1, 2, 6, NEWT_FLAG_SCROLL | NEWT_FLAG_RETURNEXIT);
-        redraw_disklist(disklist, keylist, partitionsListbox);
-        i = 1;
-        bAdd = newtCompactButton(i, 9, " Add ");
-        bDelete = newtCompactButton(i += 8, 9, "Delete");
-        bOK = newtCompactButton(i += 9, 9, "  OK  ");
-        bCancel = newtCompactButton(i += 9, 9, "Cancel");
-        newtOpenWindow(21, 7, 38, 10, title_of_window);
-        myForm = newtForm(NULL, NULL, 0);
-        if (disklist->entries == 0) {
-            newtFormAddComponents(myForm, headerMsg, bAdd, bDelete, bOK,
-                                  bCancel, NULL);
-        } else {
-            newtFormAddComponents(myForm, headerMsg, partitionsListbox,
-                                  bAdd, bDelete, bOK, bCancel, NULL);
-        }
-        b_res = newtRunForm(myForm);
-        if (b_res == bOK || b_res == bCancel) { /* do nothing */
-// That's OK. At the end of this subroutine (after this do/while loop),
-// we'll throw away the changes if Cancel was pushed.
-        } else {
-            curr_choice = newtListboxGetCurrent(partitionsListbox);
-            for (i = 0; i < disklist->entries && keylist[i] != curr_choice;
-                 i++);
-            if (i == disklist->entries && disklist->entries > 0) {
-                log_to_screen("I don't know what that button does!");
-            } else {
-                currline = i;
-                if (b_res == bAdd) {
-                    log_it("Making list of unallocated RAID slices");
-                    make_list_of_unallocated_raid_partitions
-                        (unallocated_raid_partitions, mountlist_dontedit,
-                         raidlist);
-                    if (unallocated_raid_partitions->entries <= 0) {
-                        popup_and_OK
-                            ("There are no unallocated partitions marked for RAID.");
-                    } else {
-                        log_it
-                            ("Done. The user may add one or more of the above to RAID device");
-                        add_disklist_entry(disklist, raidrec->raid_device,
-                                           unallocated_raid_partitions);
-                        log_it("I have finished adding a disklist entry.");
-                        redraw_disklist(disklist, keylist,
-                                        partitionsListbox);
-                    }
-                } else if (b_res == bDelete) {
-                    delete_disklist_entry(disklist, raidrec->raid_device,
-                                          currline);
-                    redraw_disklist(disklist, keylist, partitionsListbox);
-                } else {
-                    mr_asprintf(tmp, "%s's index is %d. What should it be?", raidrec->raid_device, disklist->el[currline].index);
-                    sprintf(sz_res, "%d", disklist->el[currline].index);
-                    if (popup_and_get_string("Set index", tmp, sz_res, 10)) {
-                        disklist->el[currline].index = atoi(sz_res);
-                    }
-                    mr_free(tmp);
-
-                    redraw_disklist(disklist, keylist, partitionsListbox);
-                }
-            }
-        }
-        newtFormDestroy(myForm);
-        newtPopWindow();
-    }
-    newtPopHelpLine();
-    mr_free(help_text);
-    mr_free(header_text);
-    mr_free(title_of_window);
-
-    if (b_res == bCancel) {
-        memcpy((void *) raidlist, (void *) bkp_raidlist, sizeof(struct raidlist_itself));
-        memcpy((void *) raidrec, (void *) bkp_raidrec, sizeof(struct raid_device_record));
-        memcpy((void *) disklist, (void *) bkp_disklist, sizeof(struct list_of_disks));
-    }
-    mr_free(bkp_raidrec);
-    mr_free(bkp_disklist);
-    mr_free(bkp_raidlist);
-    mr_free(unallocated_raid_partitions);
-}
-#endif
-
-
 
 /**