Changeset 3287 in MondoRescue

Timestamp:

May 3, 2014, 10:13:14 AM (10 years ago)

Author:

Bruno Cornec

Message:

• mondo-prep is now better wrt memory management (fgets part not done yet)

File:

• branches/3.2/mondo/src/mondorestore/mondo-prep.c (modified) (28 diffs)

branches/3.2/mondo/src/mondorestore/mondo-prep.c

@@ -182 +182 @@
 
 #ifdef __FreeBSD__
-    return (0);
+return (0);
 #endif
 
@@ -419 +419 @@
 
 #ifdef __FreeBSD__
-    log_to_screen("I don't know how to extrapolate the mountlist on FreeBSD. Sorry.");
-    return (1);
+log_to_screen("I don't know how to extrapolate the mountlist on FreeBSD. Sorry.");
+return (1);
 #endif
 
@@ -439 +439 @@
              q = fgets(incoming, MAX_STR_LEN - 1, fin));
         if (!feof(fin)) {
-            log_it(tmp, "Investigating %s", old_mountlist->el[lino].device);
-            for (q = fgets(incoming, MAX_STR_LEN - 1, fin); !feof(fin) && (q != NULL)
-                 && !strstr(incoming, "raiddev");
-                 q = fgets(incoming, MAX_STR_LEN - 1, fin)) {
-                if (strstr(incoming, OSSWAP("device", "drive"))
-                    && !strchr(incoming, '#')) {
+            log_it("Investigating %s", old_mountlist->el[lino].device);
+            for (q = fgets(incoming, MAX_STR_LEN - 1, fin); !feof(fin) && (q != NULL) && !strstr(incoming, "raiddev"); q = fgets(incoming, MAX_STR_LEN - 1, fin)) {
+                if (strstr(incoming, OSSWAP("device", "drive")) && !strchr(incoming, '#')) {
                     for (p = incoming + strlen(incoming);
                          *(p - 1) <= 32; p--);
                     *p = '\0';
                     for (p--; p > incoming && *(p - 1) > 32; p--);
-                    log_it(tmp, "Extrapolating %s", p);
-                    for (j = 0;
-                         j < new_mountlist->entries
-                         && strcmp(new_mountlist->el[j].device, p);
-                         j++);
+                    log_it("Extrapolating %s", p);
+                    for (j = 0; j < new_mountlist->entries && strcmp(new_mountlist->el[j].device, p); j++);
                     if (j >= new_mountlist->entries) {
                         strcpy(new_mountlist-> el[new_mountlist->entries].device, p);
@@ -461 +455 @@
                         new_mountlist->entries++;
                     } else {
-                        log_it(tmp, "Not adding %s to mountlist: it's already there", p);
+                        log_it("Not adding %s to mountlist: it's already there", p);
                     }
                 }
@@ -639 +633 @@
 /** int **************************************************************/
 #ifdef __FreeBSD__
-    static bool vinum_started_yet = FALSE;
+static bool vinum_started_yet = FALSE;
 #endif
 
@@ -658 +652 @@
 }
 #ifdef __FreeBSD__
-    if (strcmp(format, "swap") == 0) {
-        log_it("Not formatting %s - it's swap", device);
-        return (0);
-    }
+if (strcmp(format, "swap") == 0) {
+    log_it("Not formatting %s - it's swap", device);
+    return (0);
+}
 #endif
 if (strlen(format) <= 2) {
@@ -675 +669 @@
     newtSuspend();
 #ifdef __FreeBSD__
-    if (!vinum_started_yet) {
-        if (!does_file_exist("/tmp/raidconf.txt")) {
-            log_to_screen("/tmp/raidconf.txt does not exist. I therefore cannot start Vinum.");
-        } else {
-            int res;
-            res = run_program_and_log_output("vinum create /tmp/raidconf.txt", TRUE);
-            if (res) {
-                log_to_screen("`vinum create /tmp/raidconf.txt' returned errors. Please fix them and re-run mondorestore.");
-                finish(1);
+if (!vinum_started_yet) {
+    if (!does_file_exist("/tmp/raidconf.txt")) {
+        log_to_screen("/tmp/raidconf.txt does not exist. I therefore cannot start Vinum.");
+    } else {
+        int res;
+        res = run_program_and_log_output("vinum create /tmp/raidconf.txt", TRUE);
+        if (res) {
+            log_to_screen("`vinum create /tmp/raidconf.txt' returned errors. Please fix them and re-run mondorestore.");
+            finish(1);
+        }
+        vinum_started_yet = TRUE;
+    }
+}
+
+if (vinum_started_yet) {
+    FILE *fin;
+    char line[MAX_STR_LEN];
+
+    log_to_screen(tmp, "Initializing Vinum device %s (this may take a *long* time)", device);
+
+    /* format raid partition */
+    mr_asprintf(program, "for plex in `vinum lv -r %s | grep '^P' | tr '\t' ' ' | tr -s ' ' | cut -d' ' -f2`; do echo $plex; done > /tmp/plexes", basename(device));
+    paranoid_system(program);
+    if (g_fprep) {
+        fprintf(g_fprep, "%s\n", program);
+    }
+    fin = fopen("/tmp/plexes", "r");
+    while (fgets(line, MAX_STR_LEN - 1, fin)) {
+        if (strchr(line, '\n'))
+            *(strchr(line, '\n')) = '\0';   // get rid of the \n on the end
+
+        mr_asprintf(tmp, "Initializing plex: %s", line);
+        open_evalcall_form(tmp);
+        mr_free(tmp);
+
+        mr_asprintf(tmp, "vinum init %s", line);
+        paranoid_system(tmp);
+        mr_free(tmp);
+
+        while (1) {
+            mr_asprintf(tmp, "vinum lp -r %s | grep '^S' | head -1 | tr -s ' ' | cut -d: -f2 | cut -f1 | sed 's/^ //' | sed 's/I //' | sed 's/%%//'", line);
+            FILE *pin = popen(tmp, "r");
+            mr_free(tmp);
+
+            char status[MAX_STR_LEN / 4];
+            if (fgets(status, MAX_STR_LEN / 4 - 1, pin)) {
+                // FIXME
             }
-            vinum_started_yet = TRUE;
-        }
-    }
-
-    if (vinum_started_yet) {
-        FILE *fin;
-        char line[MAX_STR_LEN];
-
-        log_to_screen(tmp, "Initializing Vinum device %s (this may take a *long* time)", device);
-
-        /* format raid partition */
-        mr_asprintf(program, "for plex in `vinum lv -r %s | grep '^P' | tr '\t' ' ' | tr -s ' ' | cut -d' ' -f2`; do echo $plex; done > /tmp/plexes", basename(device));
-        paranoid_system(program);
-        if (g_fprep) {
-            fprintf(g_fprep, "%s\n", program);
-        }
-        fin = fopen("/tmp/plexes", "r");
-        while (fgets(line, MAX_STR_LEN - 1, fin)) {
-            if (strchr(line, '\n'))
-                *(strchr(line, '\n')) = '\0';   // get rid of the \n on the end
-
-            mr_asprintf(tmp, "Initializing plex: %s", line);
-            open_evalcall_form(tmp);
-            mr_free(tmp);
-
-            mr_asprintf(tmp, "vinum init %s", line);
-            paranoid_system(tmp);
-            mr_free(tmp);
-
-            while (1) {
-                mr_asprintf(tmp, "vinum lp -r %s | grep '^S' | head -1 | tr -s ' ' | cut -d: -f2 | cut -f1 | sed 's/^ //' | sed 's/I //' | sed 's/%%//'", line);
-                FILE *pin = popen(tmp, "r");
-                mr_free(tmp);
-
-                char status[MAX_STR_LEN / 4];
-                if (fgets(status, MAX_STR_LEN / 4 - 1, pin)) {
-                    // FIXME
-                }
-                pclose(pin);
-
-                if (!strcmp(status, "up")) {
-                    break;  /* it's done */
-                }
-                update_evalcall_form(atoi(status));
-                usleep(250000);
+            pclose(pin);
+
+            if (!strcmp(status, "up")) {
+                break;  /* it's done */
             }
-            close_evalcall_form();
-        }
-        fclose(fin);
-        unlink("/tmp/plexes");
-    }
+            update_evalcall_form(atoi(status));
+            usleep(250000);
+        }
+        close_evalcall_form();
+    }
+    fclose(fin);
+    unlink("/tmp/plexes");
+}
 #else
-    log_to_screen("Initializing RAID device %s", device);
-
-    // Shouldn't be necessary.
-    log_to_screen("Stopping %s", device);
-    stop_raid_device(device);
+log_to_screen("Initializing RAID device %s", device);
+
+// Shouldn't be necessary.
+log_to_screen("Stopping %s", device);
+stop_raid_device(device);
+paranoid_system("sync");
+sleep(1);
+
+log_msg(1, "Making %s", device);
+// use mkraid if it exists, otherwise use mdadm
+if (run_program_and_log_output("which mkraid", FALSE)) {
+    res = create_raid_device_via_mdadm(raidlist, device, TRUE);
+    log_msg(1, "Creating RAID device %s via mdadm returned %d", device, res);
+} else {
+    mr_asprintf(program, "mkraid --really-force %s", device);
+    res = run_program_and_log_output(program, 1);
+    log_msg(1, "%s returned %d", program, res);
     paranoid_system("sync");
-    sleep(1);
-
-    log_msg(1, "Making %s", device);
-    // use mkraid if it exists, otherwise use mdadm
-    if (run_program_and_log_output("which mkraid", FALSE)) {
-        res = create_raid_device_via_mdadm(raidlist, device, TRUE);
-        log_msg(1, "Creating RAID device %s via mdadm returned %d", device, res);
-    } else {
-        mr_asprintf(program, "mkraid --really-force %s", device);
-        res = run_program_and_log_output(program, 1);
-        log_msg(1, "%s returned %d", program, res);
-        paranoid_system("sync");
-        sleep(3);
-        start_raid_device(device);
-        if (g_fprep) {
-            fprintf(g_fprep, "%s\n", program);
-        }
-    }
-    paranoid_system("sync");
-    sleep(2);
-#endif
-    paranoid_system("sync");
-    sleep(1);
-    newtResume();
+    sleep(3);
+    start_raid_device(device);
+    if (g_fprep) {
+        fprintf(g_fprep, "%s\n", program);
+    }
+}
+paranoid_system("sync");
+sleep(2);
+#endif
+paranoid_system("sync");
+sleep(1);
+newtResume();
 }
 
@@ -800 +794 @@
     mr_free(program);
 #ifdef __FreeBSD__
-        mr_asprintf(program, "newfs_msdos -F 32 %s", device);
+    mr_asprintf(program, "newfs_msdos -F 32 %s", device);
 #else
 #ifdef __IA64__
-        /* For EFI partitions take fat16 
-         * as we want to make small ones */
-        mr_asprintf(program, "mkfs -t %s -F 16 %s", format, device);
+    /* For EFI partitions take fat16 
+     * as we want to make small ones */
+    mr_asprintf(program, "mkfs -t %s -F 16 %s", format, device);
 #else
-        mr_asprintf(program, "mkfs -t %s -F 32 %s", format, device);
+    mr_asprintf(program, "mkfs -t %s -F 32 %s", format, device);
 #endif
 #endif
@@ -1007 +1001 @@
  */
 int make_dummy_partitions(FILE * pout_to_fdisk, char *drivename, int devno_we_must_allow_for) {
-    /** int **************************************************************/
-    int current_devno;
-    int previous_devno;
-    int retval = 0;
-    int res;
-
-    /** buffers **********************************************************/
-    char *tmp;
-
-    /** end **************************************************************/
-
-    malloc_string(tmp);
-    assert_string_is_neither_NULL_nor_zerolength(drivename);
-
-    if (devno_we_must_allow_for >= 5) {
-        sprintf(tmp, "Making dummy primary 1 on %s", drivename);
-        log_it(tmp);
-        g_maximum_progress++;
-        res =
-            partition_device(pout_to_fdisk, drivename, 1, 0, "ext2",
-                             32000);
-        retval += res;
-        previous_devno = 1;
-        current_devno = 5;
-    } else {
-        previous_devno = 0;
-        current_devno = 1;
-    }
-    for (; current_devno < devno_we_must_allow_for; current_devno++) {
-        sprintf(tmp, "Creating dummy partition %d on %s", current_devno, drivename);
-        log_it(tmp);
-        g_maximum_progress++;
-        res =
-            partition_device(pout_to_fdisk, drivename, current_devno,
-                             previous_devno, OSSWAP("ext2", "ufs"), 32000);
-        retval += res;
-        previous_devno = current_devno;
-    }
-    paranoid_free(tmp);
-    return (previous_devno);
+
+/** int **************************************************************/
+int current_devno;
+int previous_devno;
+int retval = 0;
+int res;
+
+assert_string_is_neither_NULL_nor_zerolength(drivename);
+
+if (devno_we_must_allow_for >= 5) {
+    log_it("Making dummy primary 1 on %s", drivename);
+    g_maximum_progress++;
+    res = partition_device(pout_to_fdisk, drivename, 1, 0, "ext2", 32000);
+    retval += res;
+    previous_devno = 1;
+    current_devno = 5;
+} else {
+    previous_devno = 0;
+    current_devno = 1;
+}
+for (; current_devno < devno_we_must_allow_for; current_devno++) {
+    log_it("Creating dummy partition %d on %s", current_devno, drivename);
+    g_maximum_progress++;
+    res = partition_device(pout_to_fdisk, drivename, current_devno, previous_devno, OSSWAP("ext2", "ufs"), 32000);
+    retval += res;
+    previous_devno = current_devno;
+}
+return (previous_devno);
 }
 
@@ -1055 +1037 @@
  * @return TRUE if it does, FALSE if it doesn't.
  */
-bool mountlist_contains_raid_devices(struct mountlist_itself * mountlist)
-{
-    /** int *************************************************************/
-    int i;
-    int matching = 0;
-
-    /** end **************************************************************/
-
-    assert(mountlist != NULL);
-
-    for (i = 0; i < mountlist->entries; i++) {
-        if (strstr(mountlist->el[i].device, RAID_DEVICE_STUB)) {
-            matching++;
-        }
-    }
-    if (matching) {
-        return (TRUE);
-    } else {
-        return (FALSE);
-    }
+bool mountlist_contains_raid_devices(struct mountlist_itself * mountlist) {
+
+/** int *************************************************************/
+int i;
+int matching = 0;
+
+/** end **************************************************************/
+
+assert(mountlist != NULL);
+
+for (i = 0; i < mountlist->entries; i++) {
+    if (strstr(mountlist->el[i].device, RAID_DEVICE_STUB)) {
+        matching++;
+    }
+}
+if (matching) {
+    return (TRUE);
+} else {
+    return (FALSE);
+}
 }
 
 /* The following 2 functions are stolen from /usr/src/sbin/disklabel/disklabel.c */
 #ifdef __FreeBSD__
-static void display_disklabel(FILE * f, const struct disklabel *lp)
-{
-    int i, j;
-    const struct partition *pp;
-
-    fprintf(f, "# %s\n", "Generated by Mondo Rescue");
-    if (lp->d_type < DKMAXTYPES)
-        fprintf(f, "type: %s\n", dktypenames[lp->d_type]);
-    else
-        fprintf(f, "type: %u\n", lp->d_type);
-    fprintf(f, "disk: %.*s\n", (int) sizeof(lp->d_typename),
-            lp->d_typename);
-    fprintf(f, "label: %.*s\n", (int) sizeof(lp->d_packname),
-            lp->d_packname);
-    fprintf(f, "flags:");
-    if (lp->d_flags & D_REMOVABLE)
-        fprintf(f, " removeable");
-    if (lp->d_flags & D_ECC)
-        fprintf(f, " ecc");
-    if (lp->d_flags & D_BADSECT)
-        fprintf(f, " badsect");
-    fprintf(f, "\n");
-    fprintf(f, "bytes/sector: %lu\n", (u_long) lp->d_secsize);
-    fprintf(f, "sectors/track: %lu\n", (u_long) lp->d_nsectors);
-    fprintf(f, "tracks/cylinder: %lu\n", (u_long) lp->d_ntracks);
-    fprintf(f, "sectors/cylinder: %lu\n", (u_long) lp->d_secpercyl);
-    fprintf(f, "cylinders: %lu\n", (u_long) lp->d_ncylinders);
-    fprintf(f, "sectors/unit: %lu\n", (u_long) lp->d_secperunit);
-    fprintf(f, "rpm: %u\n", lp->d_rpm);
-    fprintf(f, "interleave: %u\n", lp->d_interleave);
-    fprintf(f, "trackskew: %u\n", lp->d_trackskew);
-    fprintf(f, "cylinderskew: %u\n", lp->d_cylskew);
-    fprintf(f, "headswitch: %lu\t\t# milliseconds\n",
-            (u_long) lp->d_headswitch);
-    fprintf(f, "track-to-track seek: %ld\t# milliseconds\n",
-            (u_long) lp->d_trkseek);
-    fprintf(f, "drivedata: ");
-    for (i = NDDATA - 1; i >= 0; i--)
-        if (lp->d_drivedata[i])
+static void display_disklabel(FILE * f, const struct disklabel *lp) {
+
+int i, j;
+const struct partition *pp;
+
+fprintf(f, "# %s\n", "Generated by Mondo Rescue");
+if (lp->d_type < DKMAXTYPES)
+    fprintf(f, "type: %s\n", dktypenames[lp->d_type]);
+else
+    fprintf(f, "type: %u\n", lp->d_type);
+fprintf(f, "disk: %.*s\n", (int) sizeof(lp->d_typename), lp->d_typename);
+fprintf(f, "label: %.*s\n", (int) sizeof(lp->d_packname), lp->d_packname);
+fprintf(f, "flags:");
+if (lp->d_flags & D_REMOVABLE)
+    fprintf(f, " removeable");
+if (lp->d_flags & D_ECC)
+    fprintf(f, " ecc");
+if (lp->d_flags & D_BADSECT)
+    fprintf(f, " badsect");
+fprintf(f, "\n");
+fprintf(f, "bytes/sector: %lu\n", (u_long) lp->d_secsize);
+fprintf(f, "sectors/track: %lu\n", (u_long) lp->d_nsectors);
+fprintf(f, "tracks/cylinder: %lu\n", (u_long) lp->d_ntracks);
+fprintf(f, "sectors/cylinder: %lu\n", (u_long) lp->d_secpercyl);
+fprintf(f, "cylinders: %lu\n", (u_long) lp->d_ncylinders);
+fprintf(f, "sectors/unit: %lu\n", (u_long) lp->d_secperunit);
+fprintf(f, "rpm: %u\n", lp->d_rpm);
+fprintf(f, "interleave: %u\n", lp->d_interleave);
+fprintf(f, "trackskew: %u\n", lp->d_trackskew);
+fprintf(f, "cylinderskew: %u\n", lp->d_cylskew);
+fprintf(f, "headswitch: %lu\t\t# milliseconds\n", (u_long) lp->d_headswitch);
+fprintf(f, "track-to-track seek: %ld\t# milliseconds\n", (u_long) lp->d_trkseek);
+fprintf(f, "drivedata: ");
+for (i = NDDATA - 1; i >= 0; i--)
+    if (lp->d_drivedata[i])
+        break;
+if (i < 0)
+    i = 0;
+for (j = 0; j <= i; j++)
+    fprintf(f, "%lu ", (u_long) lp->d_drivedata[j]);
+fprintf(f, "\n\n%u partitions:\n", lp->d_npartitions);
+fprintf(f, "#         size   offset    fstype   [fsize bsize bps/cpg]\n");
+pp = lp->d_partitions;
+for (i = 0; i < lp->d_npartitions; i++, pp++) {
+    if (pp->p_size) {
+        fprintf(f, "    %c: %8lu %8lu  ", 'a' + i, (u_long) pp->p_size, (u_long) pp->p_offset);
+        if (pp->p_fstype < FSMAXTYPES)
+            fprintf(f, "%8.8s", fstypenames[pp->p_fstype]);
+        else
+            fprintf(f, "%8d", pp->p_fstype);
+        switch (pp->p_fstype) {
+
+        case FS_UNUSED: /* XXX */
+            fprintf(f, "      %5lu %5lu %5.5s ", (u_long) pp->p_fsize, (u_long) (pp->p_fsize * pp->p_frag), "");
             break;
-    if (i < 0)
-        i = 0;
-    for (j = 0; j <= i; j++)
-        fprintf(f, "%lu ", (u_long) lp->d_drivedata[j]);
-    fprintf(f, "\n\n%u partitions:\n", lp->d_npartitions);
-    fprintf(f,
-            "#        size   offset    fstype   [fsize bsize bps/cpg]\n");
-    pp = lp->d_partitions;
-    for (i = 0; i < lp->d_npartitions; i++, pp++) {
-        if (pp->p_size) {
-            fprintf(f, "    %c: %8lu %8lu  ", 'a' + i, (u_long) pp->p_size,
-                    (u_long) pp->p_offset);
-            if (pp->p_fstype < FSMAXTYPES)
-                fprintf(f, "%8.8s", fstypenames[pp->p_fstype]);
-            else
-                fprintf(f, "%8d", pp->p_fstype);
-            switch (pp->p_fstype) {
-
-            case FS_UNUSED: /* XXX */
-                fprintf(f, "      %5lu %5lu %5.5s ", (u_long) pp->p_fsize,
-                        (u_long) (pp->p_fsize * pp->p_frag), "");
-                break;
-
-            case FS_BSDFFS:
-                fprintf(f, "      %5lu %5lu %5u ", (u_long) pp->p_fsize,
-                        (u_long) (pp->p_fsize * pp->p_frag), pp->p_cpg);
-                break;
-
-            case FS_BSDLFS:
-                fprintf(f, "      %5lu %5lu %5d", (u_long) pp->p_fsize,
-                        (u_long) (pp->p_fsize * pp->p_frag), pp->p_cpg);
-                break;
-
-            default:
-                fprintf(f, "%20.20s", "");
-                break;
-            }
-            fprintf(f, "\t# (Cyl. %4lu",
-                    (u_long) (pp->p_offset / lp->d_secpercyl));
-            if (pp->p_offset % lp->d_secpercyl)
-                putc('*', f);
-            else
-                putc(' ', f);
-            fprintf(f, "- %lu",
-                    (u_long) ((pp->p_offset + pp->p_size +
-                                 lp->d_secpercyl - 1) / lp->d_secpercyl -
-                                1));
-            if (pp->p_size % lp->d_secpercyl)
-                putc('*', f);
-            fprintf(f, ")\n");
-        }
-    }
-    fflush(f);
-}
-
-static struct disklabel *get_virgin_disklabel(char *dkname)
-{
-    static struct disklabel loclab;
-    struct partition *dp;
-    char lnamebuf[BBSIZE];
-    int f;
-    u_int secsize, u;
-    off_t mediasize;
-
-    (void) snprintf(lnamebuf, BBSIZE, "%s", dkname);
-    if ((f = open(lnamebuf, O_RDONLY)) == -1) {
-        warn("cannot open %s", lnamebuf);
-        return (NULL);
-    }
-
-    /* New world order */
-    if ((ioctl(f, DIOCGMEDIASIZE, &mediasize) != 0)
-        || (ioctl(f, DIOCGSECTORSIZE, &secsize) != 0)) {
-        close(f);
-        return (NULL);
-    }
-    memset(&loclab, 0, sizeof loclab);
-    loclab.d_magic = DISKMAGIC;
-    loclab.d_magic2 = DISKMAGIC;
-    loclab.d_secsize = secsize;
-    loclab.d_secperunit = mediasize / secsize;
-
-    /*
-     * Nobody in these enligthened days uses the CHS geometry for
-     * anything, but nontheless try to get it right.    If we fail
-     * to get any good ideas from the device, construct something
-     * which is IBM-PC friendly.
-     */
-    if (ioctl(f, DIOCGFWSECTORS, &u) == 0)
-        loclab.d_nsectors = u;
-    else
-        loclab.d_nsectors = 63;
-    if (ioctl(f, DIOCGFWHEADS, &u) == 0)
-        loclab.d_ntracks = u;
-    else if (loclab.d_secperunit <= 63 * 1 * 1024)
-        loclab.d_ntracks = 1;
-    else if (loclab.d_secperunit <= 63 * 16 * 1024)
-        loclab.d_ntracks = 16;
-    else
-        loclab.d_ntracks = 255;
-    loclab.d_secpercyl = loclab.d_ntracks * loclab.d_nsectors;
-    loclab.d_ncylinders = loclab.d_secperunit / loclab.d_secpercyl;
-    loclab.d_npartitions = MAXPARTITIONS;
-
-    /* Various (unneeded) compat stuff */
-    loclab.d_rpm = 3600;
-    loclab.d_bbsize = BBSIZE;
-    loclab.d_interleave = 1;;
-    strncpy(loclab.d_typename, "amnesiac", sizeof(loclab.d_typename));
+
+        case FS_BSDFFS:
+            fprintf(f, "      %5lu %5lu %5u ", (u_long) pp->p_fsize, (u_long) (pp->p_fsize * pp->p_frag), pp->p_cpg);
+            break;
+
+        case FS_BSDLFS:
+            fprintf(f, "      %5lu %5lu %5d", (u_long) pp->p_fsize, (u_long) (pp->p_fsize * pp->p_frag), pp->p_cpg);
+            break;
+
+        default:
+            fprintf(f, "%20.20s", "");
+            break;
+        }
+        fprintf(f, "\t# (Cyl. %4lu", (u_long) (pp->p_offset / lp->d_secpercyl));
+        if (pp->p_offset % lp->d_secpercyl)
+            putc('*', f);
+        else
+            putc(' ', f);
+        fprintf(f, "- %lu", (u_long) ((pp->p_offset + pp->p_size + lp->d_secpercyl - 1) / lp->d_secpercyl - 1));
+        if (pp->p_size % lp->d_secpercyl)
+            putc('*', f);
+        fprintf(f, ")\n");
+    }
+}
+fflush(f);
+}
+
+static struct disklabel *get_virgin_disklabel(char *dkname) {
+
+static struct disklabel loclab;
+struct partition *dp;
+char *lnamebuf = NULL;
+int f;
+u_int secsize, u;
+off_t mediasize;
+
+mr_asprintf(lnamebuf, "%s", dkname);
+if ((f = open(lnamebuf, O_RDONLY)) == -1) {
+    warn("cannot open %s", lnamebuf);
+    mr_free(lnamebuf);
+    return (NULL);
+}
+mr_free(lnamebuf);
+
+/* New world order */
+if ((ioctl(f, DIOCGMEDIASIZE, &mediasize) != 0)
+    || (ioctl(f, DIOCGSECTORSIZE, &secsize) != 0)) {
+    close(f);
+    return (NULL);
+}
+memset(&loclab, 0, sizeof loclab);
+loclab.d_magic = DISKMAGIC;
+loclab.d_magic2 = DISKMAGIC;
+loclab.d_secsize = secsize;
+loclab.d_secperunit = mediasize / secsize;
+
+/*
+ * Nobody in these enligthened days uses the CHS geometry for
+ * anything, but nontheless try to get it right.    If we fail
+ * to get any good ideas from the device, construct something
+ * which is IBM-PC friendly.
+ */
+if (ioctl(f, DIOCGFWSECTORS, &u) == 0)
+    loclab.d_nsectors = u;
+else
+    loclab.d_nsectors = 63;
+
+if (ioctl(f, DIOCGFWHEADS, &u) == 0)
+    loclab.d_ntracks = u;
+else if (loclab.d_secperunit <= 63 * 1 * 1024)
+    loclab.d_ntracks = 1;
+else if (loclab.d_secperunit <= 63 * 16 * 1024)
+    loclab.d_ntracks = 16;
+else
+    loclab.d_ntracks = 255;
+loclab.d_secpercyl = loclab.d_ntracks * loclab.d_nsectors;
+loclab.d_ncylinders = loclab.d_secperunit / loclab.d_secpercyl;
+loclab.d_npartitions = MAXPARTITIONS;
+
+/* Various (unneeded) compat stuff */
+loclab.d_rpm = 3600;
+loclab.d_bbsize = BBSIZE;
+loclab.d_interleave = 1;;
+strncpy(loclab.d_typename, "amnesiac", sizeof(loclab.d_typename));
 
     dp = &loclab.d_partitions[RAW_PART];
-    dp->p_size = loclab.d_secperunit;
-    loclab.d_checksum = dkcksum(&loclab);
-    close(f);
-    return (&loclab);
+dp->p_size = loclab.d_secperunit;
+loclab.d_checksum = dkcksum(&loclab);
+close(f);
+return (&loclab);
 }
 
 /* End stolen from /usr/src/sbin/disklabel/disklabel.c. */
 
-char *canonical_name(char *drivename)
-{
-    if (drivename) {
-        if (strncmp(drivename, "/dev/", 5) == 0) {
-            return drivename + 5;
-        }
-    }
-    return drivename;
+char *canonical_name(char *drivename) {
+
+if (drivename) {
+    if (strncmp(drivename, "/dev/", 5) == 0) {
+        return drivename + 5;
+    }
+}
+return drivename;
 }
 
@@ -1255 +1227 @@
  * @return The number of errors encountered (0 for success).
  */
-int label_drive_or_slice(struct mountlist_itself *mountlist,
-                         char *drivename, struct disklabel *ret)
-{
-    char subdev_str[MAX_STR_LEN];
-    char command[MAX_STR_LEN];
-    struct disklabel *lp;
-    int i, lo = 0;
-    int retval = 0;
-    char c;
-    FILE *ftmp;
-
-    lp = get_virgin_disklabel(drivename);
-    for (c = 'a'; c <= 'z'; ++c) {
-        int idx;
-        sprintf(subdev_str, "%s%c", drivename, c);
-        if ((idx = find_device_in_mountlist(mountlist, subdev_str)) < 0) {
-            lp->d_partitions[c - 'a'].p_size = 0;
-            lp->d_partitions[c - 'a'].p_fstype = FS_UNUSED;
-        } else {
-            lo = c - 'a';
-            lp->d_partitions[c - 'a'].p_size = mountlist->el[idx].size * 2;
-            lp->d_partitions[c - 'a'].p_fsize = 0;
-            lp->d_partitions[c - 'a'].p_frag = 0;
-            lp->d_partitions[c - 'a'].p_cpg = 0;
-            if (!strcmp(mountlist->el[idx].format, "ufs")
-                || !strcmp(mountlist->el[idx].format, "ffs")
-                || !strcmp(mountlist->el[idx].format, "4.2BSD")) {
-                lp->d_partitions[c - 'a'].p_fstype = FS_BSDFFS;
-                lp->d_partitions[c - 'a'].p_fsize = 2048;
-                lp->d_partitions[c - 'a'].p_frag = 8;
-                lp->d_partitions[c - 'a'].p_cpg = 64;
-            } else if (!strcasecmp(mountlist->el[idx].format, "raid")
-                         || !strcasecmp(mountlist->el[idx].format, "vinum")) {
-                lp->d_partitions[c - 'a'].p_fstype = FS_VINUM;
-            } else if (!strcmp(mountlist->el[idx].format, "swap")) {
-                lp->d_partitions[c - 'a'].p_fstype = FS_SWAP;
-            } else
-                lp->d_partitions[c - 'a'].p_fstype = FS_OTHER;
-        }
-    }
-
-    // fix up the offsets
-    lp->d_partitions[0].p_offset = 0;
-    lp->d_partitions[RAW_PART].p_offset = 0;
-    lp->d_partitions[RAW_PART].p_size = lp->d_secperunit;
-    lp->d_partitions[RAW_PART].p_fstype = FS_UNUSED;
-
-    for (i = 1; i < lp->d_npartitions; ++i) {
-        int lastone;
-        if ((i == RAW_PART) || (lp->d_partitions[i].p_size == 0))
-            continue;
-        for (lastone = i - 1; lastone >= 0; lastone--) {
-            if ((lp->d_partitions[lastone].p_size)
-                && (lastone != RAW_PART))
-                break;
-        }
-        lp->d_partitions[i].p_offset =
-            lp->d_partitions[lastone].p_offset +
-            lp->d_partitions[lastone].p_size;
-    }
-    if (lp->d_partitions[lo].p_offset + lp->d_partitions[lo].p_size >
-        lp->d_secperunit) {
-        lp->d_partitions[lo].p_size =
-            lp->d_secperunit - lp->d_partitions[lo].p_offset;
-    }
-
-    ftmp = fopen("/tmp/disklabel", "w");
-    display_disklabel(ftmp, lp);
-    fclose(ftmp);
-    sprintf(command, "disklabel -wr %s auto", canonical_name(drivename));
-    retval += run_program_and_log_output(command, TRUE);
-    sprintf(command, "disklabel -R %s /tmp/disklabel",
-            canonical_name(drivename));
-    retval += run_program_and_log_output(command, TRUE);
-    if (ret)
-        *ret = *lp;
-    return retval;
+int label_drive_or_slice(struct mountlist_itself *mountlist, char *drivename, struct disklabel *ret) {
+
+char *subdev_str = NULL;
+char *command = NULL;
+struct disklabel *lp;
+int i, lo = 0;
+int retval = 0;
+char c;
+FILE *ftmp;
+
+lp = get_virgin_disklabel(drivename);
+for (c = 'a'; c <= 'z'; ++c) {
+    int idx;
+    mr_asprintf(subdev_str, "%s%c", drivename, c);
+    if ((idx = find_device_in_mountlist(mountlist, subdev_str)) < 0) {
+        lp->d_partitions[c - 'a'].p_size = 0;
+        lp->d_partitions[c - 'a'].p_fstype = FS_UNUSED;
+    } else {
+        lo = c - 'a';
+        lp->d_partitions[c - 'a'].p_size = mountlist->el[idx].size * 2;
+        lp->d_partitions[c - 'a'].p_fsize = 0;
+        lp->d_partitions[c - 'a'].p_frag = 0;
+        lp->d_partitions[c - 'a'].p_cpg = 0;
+        if (!strcmp(mountlist->el[idx].format, "ufs") || !strcmp(mountlist->el[idx].format, "ffs") || !strcmp(mountlist->el[idx].format, "4.2BSD")) {
+            lp->d_partitions[c - 'a'].p_fstype = FS_BSDFFS;
+            lp->d_partitions[c - 'a'].p_fsize = 2048;
+            lp->d_partitions[c - 'a'].p_frag = 8;
+            lp->d_partitions[c - 'a'].p_cpg = 64;
+        } else if (!strcasecmp(mountlist->el[idx].format, "raid") || !strcasecmp(mountlist->el[idx].format, "vinum")) {
+            lp->d_partitions[c - 'a'].p_fstype = FS_VINUM;
+        } else if (!strcmp(mountlist->el[idx].format, "swap")) {
+            lp->d_partitions[c - 'a'].p_fstype = FS_SWAP;
+        } else
+            lp->d_partitions[c - 'a'].p_fstype = FS_OTHER;
+    }
+    mr_free(subdev_str);
+}
+
+// fix up the offsets
+lp->d_partitions[0].p_offset = 0;
+lp->d_partitions[RAW_PART].p_offset = 0;
+lp->d_partitions[RAW_PART].p_size = lp->d_secperunit;
+lp->d_partitions[RAW_PART].p_fstype = FS_UNUSED;
+
+for (i = 1; i < lp->d_npartitions; ++i) {
+    int lastone;
+    if ((i == RAW_PART) || (lp->d_partitions[i].p_size == 0))
+        continue;
+    for (lastone = i - 1; lastone >= 0; lastone--) {
+        if ((lp->d_partitions[lastone].p_size) && (lastone != RAW_PART))
+            break;
+    }
+    lp->d_partitions[i].p_offset = lp->d_partitions[lastone].p_offset + lp->d_partitions[lastone].p_size;
+}
+if (lp->d_partitions[lo].p_offset + lp->d_partitions[lo].p_size > lp->d_secperunit) {
+    lp->d_partitions[lo].p_size = lp->d_secperunit - lp->d_partitions[lo].p_offset;
+}
+
+ftmp = fopen("/tmp/disklabel", "w");
+display_disklabel(ftmp, lp);
+fclose(ftmp);
+mr_asprintf(command, "disklabel -wr %s auto", canonical_name(drivename));
+retval += run_program_and_log_output(command, TRUE);
+mr_free(command);
+
+mr_asprintf(command, "disklabel -R %s /tmp/disklabel", canonical_name(drivename));
+retval += run_program_and_log_output(command, TRUE);
+mr_free(command);
+
+if (ret)
+    *ret = *lp;
+return retval;
 }
 #endif
@@ -1342 +1309 @@
  * @return 0 for success, nonzero for failure.
  */
-int partition_drive(struct mountlist_itself *mountlist, char *drivename)
-{
-    /** int *************************************************************/
-    int current_devno;
-    int previous_devno = 0;
-    int lino;
-    int retval = 0;
-    int i;
-    FILE *pout_to_fdisk = NULL;
+int partition_drive(struct mountlist_itself *mountlist, char *drivename) {
+
+/** int *************************************************************/
+int current_devno;
+int previous_devno = 0;
+int lino;
+int retval = 0;
+int i;
+FILE *pout_to_fdisk = NULL;
 
 #ifdef __FreeBSD__
-    bool fbsd_part = FALSE;
-    char subdev_str[MAX_STR_LEN];
-#endif
-
-    /** long long *******************************************************/
-    long long partsize;
-
-    /** buffers *********************************************************/
-    char *device_str;
-    char *format;
-    char *tmp;
-    char *tmp1 = NULL;
-
-    /** end *************************************************************/
-
-    assert(mountlist != NULL);
-    assert_string_is_neither_NULL_nor_zerolength(drivename);
-
-    malloc_string(device_str);
-    malloc_string(format);
-    malloc_string(tmp);
-
-    sprintf(tmp, "Partitioning drive %s", drivename);
-    log_it(tmp);
+bool fbsd_part = FALSE;
+char *subdev_str = NULL;
+#endif
+
+/** long long *******************************************************/
+long long partsize;
+
+/** buffers *********************************************************/
+char *device_str;
+char *format = NULL;
+char *tmp = NULL;
+char *tmp1 = NULL;
+
+/** end *************************************************************/
+
+assert(mountlist != NULL);
+assert_string_is_neither_NULL_nor_zerolength(drivename);
+
+
+log_it("Partitioning drive %s", drivename);
 
 #if __FreeBSD__
@@ -1382 +1345 @@
     pout_to_fdisk = NULL;
 #else
-    make_hole_for_file(FDISK_LOG);
-    sprintf(tmp, "parted2fdisk %s >> %s 2>> %s", drivename, FDISK_LOG, FDISK_LOG);
-    pout_to_fdisk = popen(tmp, "w");
-    if (!pout_to_fdisk) {
-        log_to_screen("Cannot call parted2fdisk to configure %s", drivename);
-        paranoid_free(device_str);
-        paranoid_free(format);
-        paranoid_free(tmp);
-        return (1);
-    }
-#endif
-    for (current_devno = 1; current_devno < 99; current_devno++) {
-        build_partition_name(device_str, drivename, current_devno);
-        lino = find_device_in_mountlist(mountlist, device_str);
-
-        if (lino < 0) {
-            // device not found in mountlist
+make_hole_for_file(FDISK_LOG);
+mr_asprintf(tmp, "parted2fdisk %s >> %s 2>> %s", drivename, FDISK_LOG, FDISK_LOG);
+pout_to_fdisk = popen(tmp, "w");
+if (!pout_to_fdisk) {
+    log_to_screen("Cannot call parted2fdisk to configure %s", drivename);
+    mr_free(tmp);
+    return (1);
+}
+mr_free(tmp);
+#endif
+
+malloc_string(device_str);
+
+for (current_devno = 1; current_devno < 99; current_devno++) {
+    build_partition_name(device_str, drivename, current_devno);
+    lino = find_device_in_mountlist(mountlist, device_str);
+
+    if (lino < 0) {
+        // device not found in mountlist
 #if __FreeBSD__
             // If this is the first partition (just as a sentinel value),
@@ -1407 +1372 @@
                 // try DangerouslyDedicated mode
                 for (c = 'a'; c <= 'z'; c++) {
-                    sprintf(subdev_str, "%s%c", drivename, c);
-                    if (find_device_in_mountlist(mountlist, subdev_str) >
-                        0) {
+                    mr_asprintf(subdev_str, "%s%c", drivename, c);
+                    if (find_device_in_mountlist(mountlist, subdev_str) > 0) {
                         fbsd_part = TRUE;
                     }
+                    mr_free(subdev_str);
                 }
                 if (fbsd_part) {
@@ -1425 +1390 @@
                     }
                     paranoid_free(device_str);
-                    paranoid_free(format);
-                    paranoid_free(tmp);
                     return r;
                 }
             }
             for (c = 'a'; c <= 'z'; c++) {
-                sprintf(subdev_str, "%s%c", device_str, c);
+                mr_assprintf(subdev_str, "%s%c", device_str, c);
                 if (find_device_in_mountlist(mountlist, subdev_str) > 0) {
                     fbsd_part = TRUE;
                 }
+                mr_free(subdev_str);
             }
             // Now we check the subpartitions of the current partition.
@@ -1440 +1404 @@
                 int i, line;
 
-                strcpy(format, "ufs");
+                mr_asprintf(format, "ufs");
                 partsize = 0;
                 for (i = 'a'; i < 'z'; ++i) {
-                    sprintf(subdev_str, "%s%c", device_str, i);
+                    mr_asprintf(subdev_str, "%s%c", device_str, i);
                     line = find_device_in_mountlist(mountlist, subdev_str);
+                    mr_free(subdev_str);
+
                     if (line > 0) {
                         // We found one! Add its size to the total size.
@@ -1456 +1422 @@
             continue;
 #endif
-        }
-
-        /* OK, we've found partition /dev/hdxN in mountlist; let's prep it */
-        /* For FreeBSD, that is     /dev/adXsY */
-
-        log_it("Found partition %s in mountlist", device_str);
-        if (!previous_devno) {
-
-            log_it("Wiping %s's partition table", drivename);
+    }
+
+    /* OK, we've found partition /dev/hdxN in mountlist; let's prep it */
+    /* For FreeBSD, that is     /dev/adXsY */
+
+    log_it("Found partition %s in mountlist", device_str);
+    if (!previous_devno) {
+
+        log_it("Wiping %s's partition table", drivename);
 #if __FreeBSD__
             // FreeBSD doesn't let you write to blk devices in <512byte chunks.
-//          sprintf(tmp, "dd if=/dev/zero of=%s count=1 bs=512", drivename);
-//          if (run_program_and_log_output(tmp, TRUE)) {
             file = open(drivename, O_WRONLY);
             if (file != -1) {
-                sprintf(tmp,
-                        "Warning - unable to open %s for wiping it's partition table",
-                        drivename);
-                log_to_screen(tmp);
+                log_to_screnn("Warning - unable to open %s for wiping it's partition table", drivename);
             }
 
             for (i = 0; i < 512; i++) {
                 if (!write(file, "\0", 1)) {
-                    sprintf(tmp, "Warning - unable to write to %s",
-                            drivename);
-                    log_to_screen(tmp);
+                    log_to_screen("Warning - unable to write to %s", drivename);
                 }
             }
@@ -1491 +1450 @@
                 fflush(pout_to_fdisk);
             }
-//          sprintf(tmp, "dd if=/dev/zero of=%s count=1 bs=512", drivename);
-//          run_program_and_log_output(tmp, 1);
-#endif
-            if (current_devno > 1) {
-                previous_devno =
-                    make_dummy_partitions(pout_to_fdisk, drivename,
-                                            current_devno);
-            }
-        }
+#endif
+        if (current_devno > 1) {
+            previous_devno = make_dummy_partitions(pout_to_fdisk, drivename, current_devno);
+        }
+    }
 #ifdef __FreeBSD__
-        if (!fbsd_part) {
-#endif
-
-            strcpy(format, mountlist->el[lino].format);
-            partsize = mountlist->el[lino].size;
+    if (!fbsd_part) {
+        mr_free(format);
+#endif
+
+        mr_asprintf(format, "%s", mountlist->el[lino].format);
+        partsize = mountlist->el[lino].size;
 
 #ifdef __FreeBSD__
-        }
+    }
 #endif
 
 #ifndef __IA64__
-        if (current_devno == 5 && previous_devno == 4) {
-            log_to_screen
-                ("You must leave at least one partition spare as the Extended partition.");
-            paranoid_free(device_str);
-            paranoid_free(format);
-            paranoid_free(tmp);
-            return (1);
-        }
-#endif
-
-        retval +=
-            partition_device(pout_to_fdisk, drivename, current_devno,
-                             previous_devno, format, partsize);
+    if (current_devno == 5 && previous_devno == 4) {
+        log_to_screen("You must leave at least one partition spare as the Extended partition.");
+        paranoid_free(device_str);
+        mr_free(format);
+        return (1);
+    }
+#endif
+
+    retval += partition_device(pout_to_fdisk, drivename, current_devno, previous_devno, format, partsize);
+    mr_free(format);
 
 #ifdef __FreeBSD__
-        if ((current_devno <= 4) && fbsd_part) {
-            sprintf(tmp, "disklabel -B %s", basename(device_str));
-            retval += label_drive_or_slice(mountlist, device_str, 0);
-            if (system(tmp)) {
-                log_to_screen
-                    ("Warning! Unable to make the slice bootable.");
-            }
-        }
-#endif
-
-        previous_devno = current_devno;
-    }
-
-    if (pout_to_fdisk) {
-        // close fdisk
-        fput_string_one_char_at_a_time(pout_to_fdisk, "p\n");
-        fput_string_one_char_at_a_time(pout_to_fdisk, "w\n");
-        paranoid_pclose(pout_to_fdisk);
-        paranoid_system("sync");
-        log_msg(0,"------------------- fdisk.log looks like this ------------------");
-        sprintf(tmp, "cat %s >> %s", FDISK_LOG, MONDO_LOGFILE);
-        paranoid_system(tmp);
-        // mark relevant partition as bootable
-        mr_asprintf(tmp1,"make-me-bootable /tmp/mountlist.txt %s",drivename);
-        call_program_and_get_last_line_of_output(tmp1);
-        mr_free(tmp1);
-        log_msg(0,"------------------- end of fdisk.log...       ------------------");
-        paranoid_system("sync");
-        sprintf(tmp, "tail -n6 %s | grep -F \"16: \"", FDISK_LOG);
-        if (!run_program_and_log_output(tmp, 5)) {
-            g_partition_table_locked_up++;
-        }
-        sprintf(tmp, "partprobe %s", drivename);
-        if (!run_program_and_log_output(tmp, 5)) {
-            g_partition_table_locked_up--;
-        }
-        if (g_partition_table_locked_up > 0) {
-            log_to_screen
-                ("A flaw in the Linux kernel has locked the partition table. Even calling partprobe did not suceed :-(");
-        }
-    }
-    paranoid_free(device_str);
-    paranoid_free(format);
-    paranoid_free(tmp);
-    return (retval);
+    if ((current_devno <= 4) && fbsd_part) {
+        mr_asprintf(tmp, "disklabel -B %s", basename(device_str));
+        retval += label_drive_or_slice(mountlist, device_str, 0);
+        if (system(tmp)) {
+            log_to_screen("Warning! Unable to make the slice bootable.");
+        }
+        mr_free(tmp);
+    }
+#endif
+
+    previous_devno = current_devno;
+}
+
+if (pout_to_fdisk) {
+    // close fdisk
+    fput_string_one_char_at_a_time(pout_to_fdisk, "p\n");
+    fput_string_one_char_at_a_time(pout_to_fdisk, "w\n");
+    paranoid_pclose(pout_to_fdisk);
+    paranoid_system("sync");
+    log_msg(0,"------------------- fdisk.log looks like this ------------------");
+    mr_asprintf(tmp, "cat %s >> %s", FDISK_LOG, MONDO_LOGFILE);
+    paranoid_system(tmp);
+    mr_free(tmp);
+
+    // mark relevant partition as bootable
+    mr_asprintf(tmp1,"make-me-bootable /tmp/mountlist.txt %s",drivename);
+    call_program_and_get_last_line_of_output(tmp1);
+    mr_free(tmp1);
+
+    log_msg(0,"------------------- end of fdisk.log...       ------------------");
+    paranoid_system("sync");
+    mr_asprintf(tmp, "tail -n6 %s | grep -F \"16: \"", FDISK_LOG);
+    if (!run_program_and_log_output(tmp, 5)) {
+        g_partition_table_locked_up++;
+    }
+    mr_free(tmp);
+
+    mr_asprintf(tmp, "partprobe %s", drivename);
+    if (!run_program_and_log_output(tmp, 5)) {
+        g_partition_table_locked_up--;
+    }
+    mr_free(tmp);
+
+    if (g_partition_table_locked_up > 0) {
+        log_to_screen("A flaw in the Linux kernel has locked the partition table. Even calling partprobe did not suceed :-(");
+    }
+}
+paranoid_free(device_str);
+return (retval);
 }
 
@@ -1583 +1540 @@
  * @return 0 for success, nonzero for failure.
  */
-int partition_device(FILE * pout_to_fdisk, const char *drive, int partno,
-                     int prev_partno, const char *format,
-                     long long partsize)
-{
-    /** int **************************************************************/
-    int retval = 0;
-    int res = 0;
-
-    /** buffers **********************************************************/
-    char *program;
-    char *partition_name;
-    char *tmp;
-    char *logfile;
-    char *output = NULL;
-
-    /** pointers **********************************************************/
-    char *p;
-    char *part_table_fmt = NULL;
-    FILE *fout;
-
-    /** end ***************************************************************/
-
-    malloc_string(program);
-    malloc_string(partition_name);
-    malloc_string(tmp);
-    malloc_string(logfile);
-
-    assert_string_is_neither_NULL_nor_zerolength(drive);
-    assert(format != NULL);
-
-    log_it("partition_device('%s', %d, %d, '%s', %lld) --- starting",
-             drive, partno, prev_partno, format, partsize);
-
-    if (!strncmp(drive, RAID_DEVICE_STUB, strlen(RAID_DEVICE_STUB))) {
-        sprintf(tmp, "Not partitioning %s - it is a virtual drive", drive);
-        log_it(tmp);
-        paranoid_free(program);
-        paranoid_free(partition_name);
-        paranoid_free(tmp);
-        paranoid_free(logfile);
-        return (0);
-    }
-    build_partition_name(partition_name, drive, partno);
-    if (partsize <= 0) {
-        sprintf(tmp, "Partitioning device %s (max size)", partition_name);
+int partition_device(FILE * pout_to_fdisk, const char *drive, int partno, int prev_partno, const char *format, long long partsize) {
+
+/** int **************************************************************/
+int retval = 0;
+int res = 0;
+
+/** buffers **********************************************************/
+char *program = NULL;
+char *partition_name;
+char *tmp = NULL;
+char *output = NULL;
+
+/** pointers **********************************************************/
+char *part_table_fmt = NULL;
+FILE *fout;
+
+/** end ***************************************************************/
+
+assert_string_is_neither_NULL_nor_zerolength(drive);
+assert(format != NULL);
+
+log_it("partition_device('%s', %d, %d, '%s', %lld) --- starting", drive, partno, prev_partno, format, partsize);
+
+if (!strncmp(drive, RAID_DEVICE_STUB, strlen(RAID_DEVICE_STUB))) {
+    log_it("Not partitioning %s - it is a virtual drive", drive);
+    return (0);
+}
+
+malloc_string(partition_name);
+build_partition_name(partition_name, drive, partno);
+if (partsize <= 0) {
+    mr_asprintf(tmp, "Partitioning device %s (max size)", partition_name);
+} else {
+    mr_asprintf(tmp, "Partitioning device %s (%lld MB)", partition_name, (long long) partsize / 1024);
+}
+update_progress_form(tmp);
+log_it(tmp);
+mr_free(tmp);
+
+if (is_this_device_mounted(partition_name)) {
+    log_to_screen("%s is mounted, and should not be partitioned", partition_name);
+    paranoid_free(partition_name);
+    return (1);
+}
+
+
+mr_asprintf(program, "parted2fdisk %s >> %s 2>> %s", drive, MONDO_LOGFILE, MONDO_LOGFILE);
+
+/* BERLIOS: should not be called each time */
+part_table_fmt = which_partition_format(drive);
+mr_asprintf(output, "");
+
+/* make it a primary/extended/logical */
+if (partno <= 4) {
+    mr_strcat(output, "n\np\n%d\n", partno);
+} else {
+    /* MBR needs an extended partition if more than 4 partitions */
+    if (strcmp(part_table_fmt, "MBR") == 0) {
+        if (partno == 5) {
+            if (prev_partno >= 4) {
+                log_to_screen("You need to leave at least one partition free, for 'extended/logical'");
+                paranoid_free(partition_name);
+                paranoid_free(output);
+                return (1);
+            } else {
+                mr_strcat(output, "n\ne\n%d\n\n\n", prev_partno + 1);
+            }
+        }
+        mr_strcat(output, "n\nl\n");
     } else {
-        sprintf(tmp, "Partitioning device %s (%lld MB)", partition_name,
-                (long long) partsize / 1024);
-    }
-    update_progress_form(tmp);
-    log_it(tmp);
-
-    if (is_this_device_mounted(partition_name)) {
-        sprintf(tmp, "%s is mounted, and should not be partitioned",
-                partition_name);
-        log_to_screen(tmp);
-        paranoid_free(program);
-        paranoid_free(partition_name);
-        paranoid_free(tmp);
-        paranoid_free(logfile);
-        return (1);
-/*
-    } else if (does_partition_exist(drive, partno)) {
-        sprintf(tmp, "%s already has a partition", partition_name);
-        log_to_screen(tmp);
-        return (1);
-*/
-    }
-
-
-    /*  sprintf(tmp,"Partitioning %s  ",partition_name); */
-    /*  mvaddstr_and_log_it(g_currentY+1,30,tmp); */
-    p = (char *) strrchr(partition_name, '/');
-    sprintf(logfile, "/tmp/fdisk.log.%s", ++p);
-    sprintf(program, "parted2fdisk %s >> %s 2>> %s", drive, MONDO_LOGFILE,
-            MONDO_LOGFILE);
-
-    /* BERLIOS: should not be called each time */
-    part_table_fmt = which_partition_format(drive);
-    mr_asprintf(output, "");
-    /* make it a primary/extended/logical */
-    if (partno <= 4) {
+        /* GPT allows more than 4 primary partitions */
         mr_strcat(output, "n\np\n%d\n", partno);
-    } else {
-        /* MBR needs an extended partition if more than 4 partitions */
-        if (strcmp(part_table_fmt, "MBR") == 0) {
-            if (partno == 5) {
-                if (prev_partno >= 4) {
-                    log_to_screen
-                        ("You need to leave at least one partition free, for 'extended/logical'");
-                    paranoid_free(program);
-                    paranoid_free(partition_name);
-                    paranoid_free(tmp);
-                    paranoid_free(logfile);
-                    paranoid_free(output);
-                    return (1);
-                } else {
-                    mr_strcat(output, "n\ne\n%d\n\n\n", prev_partno + 1);
-                }
-            }
-            mr_strcat(output, "n\nl\n");
-        } else {
-            /* GPT allows more than 4 primary partitions */
-            mr_strcat(output, "n\np\n%d\n", partno);
-        }
-    }
-    mr_free(part_table_fmt);
-
-    mr_strcat(output, "\n");    /*start block (ENTER for next free blk */
-    if (partsize > 0) {
-        if (!strcmp(format, "7")) {
-            log_msg(1, "Adding 512K, just in case");
-            partsize += 512;
-        }
-        mr_strcat(output, "+%lldK", (long long) (partsize));
-    }
-    mr_strcat(output, "\n");
+    }
+}
+mr_free(part_table_fmt);
+
+mr_strcat(output, "\n");    /*start block (ENTER for next free blk */
+if (partsize > 0) {
+    if (!strcmp(format, "7")) {
+        log_msg(1, "Adding 512K, just in case");
+        partsize += 512;
+    }
+    mr_strcat(output, "+%lldK", (long long) (partsize));
+}
+mr_strcat(output, "\n");
 #if 0
 /*
 #endif
-    sprintf(tmp,"PARTSIZE = +%ld",(long)partsize);
-    log_it(tmp);
-    log_it("---fdisk command---");
-    log_it(output);
-    log_it("---end of fdisk---");
+log_it("PARTSIZE = +%ld",(long)partsize);
+log_it("---fdisk command---");
+log_it(output);
+log_it("---end of fdisk---");
 #if 0
 */
@@ -1713 +1637 @@
 
 
-    if (pout_to_fdisk) {
-        log_msg(1, "Doing the new all-in-one fdisk thing");
-        log_msg(1, "output = '%s'", output);
-        fput_string_one_char_at_a_time(pout_to_fdisk, output);
-        fput_string_one_char_at_a_time(pout_to_fdisk, "\n\np\n");
-        strcpy(tmp, last_line_of_file(FDISK_LOG));
-        if (strstr(tmp, " (m ")) {
-            log_msg(1, "Successfully created partition %d on %s", partno, drive);
+if (pout_to_fdisk) {
+    log_msg(1, "Doing the new all-in-one fdisk thing");
+    log_msg(1, "output = '%s'", output);
+    fput_string_one_char_at_a_time(pout_to_fdisk, output);
+    fput_string_one_char_at_a_time(pout_to_fdisk, "\n\np\n");
+    mr_asprintf(tmp, "%s", last_line_of_file(FDISK_LOG));
+    if (strstr(tmp, " (m ")) {
+        log_msg(1, "Successfully created partition %d on %s", partno, drive);
+    } else {
+        log_msg(1, "last line = %s", tmp);
+        log_msg(1, "Failed to create partition %d on %s; sending 'Enter'...", partno, drive);
+    }
+    mr_free(tmp);
+
+    if (!retval) {
+        log_msg(1, "Trying to set partition %d type now on %s", partno, drive);
+        retval = set_partition_type(pout_to_fdisk, drive, partno, format, partsize);
+        if (retval) {
+            log_msg(1, "Failed. Trying again...");
+            retval = set_partition_type(pout_to_fdisk, drive, partno, format, partsize);
+        }
+    }
+    if (retval) {
+        log_msg(1, "...but failed to set type");
+    }
+} else {
+    mr_strcat(output, "w\n\n");
+    if (g_fprep) {
+        fprintf(g_fprep, "echo \"%s\" | %s\n", output, program);
+    }
+    /* write to disk; close fdisk's stream */
+    if (!(fout = popen(program, "w"))) {
+        log_OS_error("can't popen-out to program");
+    } else {
+        fputs(output, fout);
+        paranoid_pclose(fout);
+    }
+
+    if (!does_partition_exist(drive, partno) && partsize > 0) {
+        log_it("Vaccum-packing");
+        g_current_progress--;
+        res = partition_device(pout_to_fdisk, drive, partno, prev_partno, format, -1);
+        if (res) {
+            log_it("Failed to vacuum-pack %s", partition_name);
+            retval++;
         } else {
-            log_msg(1, "last line = %s", tmp);
-            log_msg(1, "Failed to create partition %d on %s; sending 'Enter'...", partno, drive);
-        }
-        if (!retval) {
-            log_msg(1, "Trying to set partition %d type now on %s", partno, drive);
-            retval =
-                set_partition_type(pout_to_fdisk, drive, partno, format,
-                                     partsize);
-            if (retval) {
-                log_msg(1, "Failed. Trying again...");
-                retval =
-                    set_partition_type(pout_to_fdisk, drive, partno,
-                                         format, partsize);
+            retval = 0;
+        }
+    }
+    if (does_partition_exist(drive, partno)) {
+        retval = set_partition_type(pout_to_fdisk, drive, partno, format, partsize);
+        if (retval) {
+            log_it("Partitioned %s but failed to set its type", partition_name);
+        } else {
+            if (partsize > 0) {
+                log_to_screen("Partition %s created+configured OK", partition_name);
+            } else {
+                log_it("Returning from a successful vacuum-pack");
             }
         }
-        if (retval) {
-            log_msg(1, "...but failed to set type");
-        }
     } else {
-        mr_strcat(output, "w\n\n");
-        if (g_fprep) {
-            fprintf(g_fprep, "echo \"%s\" | %s\n", output, program);
-        }
-        /* write to disk; close fdisk's stream */
-        if (!(fout = popen(program, "w"))) {
-            log_OS_error("can't popen-out to program");
+        mr_asprintf(tmp, "Failed to partition %s", partition_name);
+        if (partsize > 0) {
+            log_to_screen(tmp);
         } else {
-            fputs(output, fout);
-            paranoid_pclose(fout);
-        }
-        if (!does_partition_exist(drive, partno) && partsize > 0) {
-            log_it("Vaccum-packing");
-            g_current_progress--;
-            res =
-                partition_device(pout_to_fdisk, drive, partno, prev_partno,
-                                 format, -1);
-            if (res) {
-                sprintf(tmp, "Failed to vacuum-pack %s", partition_name);
-                log_it(tmp);
-                retval++;
-            } else {
-                retval = 0;
-            }
-        }
-        if (does_partition_exist(drive, partno)) {
-            retval =
-                set_partition_type(pout_to_fdisk, drive, partno, format,
-                                     partsize);
-            if (retval) {
-                sprintf(tmp, "Partitioned %s but failed to set its type",
-                        partition_name);
-                log_it(tmp);
-            } else {
-                if (partsize > 0) {
-                    sprintf(tmp, "Partition %s created+configured OK",
-                            partition_name);
-                    log_to_screen(tmp);
-                } else {
-                    log_it("Returning from a successful vacuum-pack");
-                }
-            }
-        } else {
-            sprintf(tmp, "Failed to partition %s", partition_name);
-            if (partsize > 0) {
-                log_to_screen(tmp);
-            } else {
-                log_it(tmp);
-            }
-            retval++;
-        }
-    }
-    paranoid_free(output);
-
-    g_current_progress++;
-    log_it("partition_device() --- leaving");
-    paranoid_free(program);
-    paranoid_free(partition_name);
-    paranoid_free(tmp);
-    paranoid_free(logfile);
-    return (retval);
+            log_it(tmp);
+        }
+        mr_free(tmp);
+        retval++;
+    }
+}
+mr_free(program);
+paranoid_free(output);
+
+g_current_progress++;
+log_it("partition_device() --- leaving");
+paranoid_free(partition_name);
+return (retval);
 }
 
@@ -1813 +1726 @@
  * Use format_everything() for that.
  */
-int partition_everything(struct mountlist_itself *mountlist)
-{
-    /** int ************************************************************/
-    int lino;
-    int retval = 0;
-    int i;
-    int res;
-
-    /** buffer *********************************************************/
-    struct list_of_disks *drivelist;
-    /*  struct mountlist_itself new_mtlist, *mountlist; */
-
-    /** end ************************************************************/
-
-    drivelist = malloc(sizeof(struct list_of_disks));
-    assert(mountlist != NULL);
-
-    log_it("partition_everything() --- starting");
-    mvaddstr_and_log_it(g_currentY, 0, "Partitioning hard drives        ");
-    /*  mountlist=orig_mtlist; */
-    if (mountlist_contains_raid_devices(mountlist)) {
-        /*      mountlist=&new_mtlist; */
-        /*      extrapolate_mountlist_to_include_raid_partitions(mountlist,orig_mtlist); */
-        log_msg(0,
-                "Mountlist, including the partitions incorporated in RAID devices:-");
-        for (i = 0; i < mountlist->entries; i++) {
-            log_it(mountlist->el[i].device);
-        }
-        log_msg(0, "End of mountlist.");
-    }
-    log_msg(0, "Stopping all LVMs, just in case");
-    if (!g_text_mode) {
-        newtSuspend();
-    }
-    do_my_funky_lvm_stuff(TRUE, FALSE); // just remove old partitions
-    if (!g_text_mode) {
-        newtResume();
-    }
-    log_msg(0, "Stopping all software RAID devices, just in case");
-    stop_all_raid_devices(mountlist);
-    log_msg(0, "Done.");
-
-/*  
-    if (does_file_exist("/tmp/i-want-my-lvm"))
-        {
-          wipe_MBRs_and_reboot_if_necessary(mountlist); // i.e. if it wasn't done recently
-        }
-*/
-
-    open_progress_form("Partitioning devices",
-                         "I am now going to partition all your drives.",
-                         "This should not take more than five minutes.", "",
-                         mountlist->entries);
-
-    make_list_of_drives_in_mountlist(mountlist, drivelist);
-
-    /* partition each drive */
-    for (lino = 0; lino < drivelist->entries; lino++) {
-        res = partition_drive(mountlist, drivelist->el[lino].device);
-        retval += res;
-    }
-    close_progress_form();
-    if (retval) {
-        mvaddstr_and_log_it(g_currentY++, 74, "Failed.");
-        log_to_screen
-            ("Errors occurred during the partitioning of your hard drives.");
-    } else {
-        mvaddstr_and_log_it(g_currentY++, 74, "Done.");
-        paranoid_system("rm -f /tmp/fdisk*.log 2> /dev/null");
-    }
+int partition_everything(struct mountlist_itself *mountlist) {
+
+/** int ************************************************************/
+int lino;
+int retval = 0;
+int i;
+int res;
+
+/** buffer *********************************************************/
+struct list_of_disks *drivelist;
+
+/** end ************************************************************/
+
+drivelist = malloc(sizeof(struct list_of_disks));
+assert(mountlist != NULL);
+
+log_it("partition_everything() --- starting");
+mvaddstr_and_log_it(g_currentY, 0, "Partitioning hard drives        ");
+
+if (mountlist_contains_raid_devices(mountlist)) {
+    log_msg(0, "Mountlist, including the partitions incorporated in RAID devices:-");
+    for (i = 0; i < mountlist->entries; i++) {
+        log_it(mountlist->el[i].device);
+    }
+    log_msg(0, "End of mountlist.");
+}
+log_msg(0, "Stopping all LVMs, just in case");
+if (!g_text_mode) {
     newtSuspend();
-    paranoid_system("clear");
+}
+do_my_funky_lvm_stuff(TRUE, FALSE); // just remove old partitions
+if (!g_text_mode) {
     newtResume();
-    paranoid_free(drivelist);
-    return (retval);
-}
-
-
-
+}
+log_msg(0, "Stopping all software RAID devices, just in case");
+stop_all_raid_devices(mountlist);
+log_msg(0, "Done.");
+
+open_progress_form("Partitioning devices", "I am now going to partition all your drives.", "This should not take more than five minutes.", "", mountlist->entries);
+
+make_list_of_drives_in_mountlist(mountlist, drivelist);
+
+/* partition each drive */
+for (lino = 0; lino < drivelist->entries; lino++) {
+    res = partition_drive(mountlist, drivelist->el[lino].device);
+    retval += res;
+}
+close_progress_form();
+if (retval) {
+    mvaddstr_and_log_it(g_currentY++, 74, "Failed.");
+    log_to_screen("Errors occurred during the partitioning of your hard drives.");
+} else {
+    mvaddstr_and_log_it(g_currentY++, 74, "Done.");
+    paranoid_system("rm -f /tmp/fdisk*.log 2> /dev/null");
+}
+newtSuspend();
+paranoid_system("clear");
+newtResume();
+paranoid_free(drivelist);
+return (retval);
+}
 
 
@@ -1904 +1799 @@
  * @return 0 for success, nonzero for failure.
  */
-int set_partition_type(FILE * pout_to_fdisk, const char *drive, int partno,
-                         const char *format, long long partsize)
-{
-    /** buffers *********************************************************/
-    char *partition;
-    char *command;
-    char *output = NULL;
-    char *tmp;
-    char *partcode;
-    char *logfile;
-
-    /** pointers *********************************************************/
-    char *p;
-    FILE *fout;
-
-    /** int **************************************************************/
-    int res = 0;
-
-    /** end **************************************************************/
-
-    assert_string_is_neither_NULL_nor_zerolength(drive);
-    assert(format != NULL);
-
-    malloc_string(partition);
-    malloc_string(command);
-    malloc_string(tmp);
-    malloc_string(partcode);
-    malloc_string(logfile);
-
-    build_partition_name(partition, drive, partno);
-    p = (char *) strrchr(partition, '/');
-    sprintf(logfile, "/tmp/fdisk-set-type.%s.log", ++p);
-    if (strcmp(format, "swap") == 0) {
-        strcpy(partcode, "82");
-    } else if (strcmp(format, "vfat") == 0) {
-        if (partsize / 1024 > 8192) {
-            strcpy(partcode, "c");
+int set_partition_type(FILE * pout_to_fdisk, const char *drive, int partno, const char *format, long long partsize) {
+
+/** buffers *********************************************************/
+char *partition;
+char *command = NULL;
+char *output = NULL;
+char *tmp = NULL;
+char *partcode = NULL;
+
+/** pointers *********************************************************/
+FILE *fout;
+
+/** int **************************************************************/
+int res = 0;
+
+/** end **************************************************************/
+
+assert_string_is_neither_NULL_nor_zerolength(drive);
+assert(format != NULL);
+
+malloc_string(partition);
+
+build_partition_name(partition, drive, partno);
+if (strcmp(format, "swap") == 0) {
+    mr_asprintf(partcode, "82");
+} else if (strcmp(format, "vfat") == 0) {
+    if (partsize / 1024 > 8192) {
+        mr_asprintf(partcode, "c");
+    } else {
+        mr_asprintf(partcode, "b");
+    }
+} else if (strcmp(format, "ext2") == 0
+             || strcmp(format, "reiserfs") == 0
+             || strcmp(format, "ext3") == 0 
+             || strcmp(format, "ext4") == 0 
+             || strcmp(format, "xfs") == 0
+             || strcmp(format, "jfs") == 0
+                 || strcmp(format, "btrfs") == 0) {
+    mr_asprintf(partcode, "83");
+} else if (strcmp(format, "minix") == 0) {
+    mr_asprintf(partcode, "81");
+} else if (strcmp(format, "vmfs3") == 0) {
+    mr_asprintf(partcode, "fb");
+} else if (strcmp(format, "vmkcore") == 0) {
+    mr_asprintf(partcode, "fc");
+} else if (strcmp(format, "raid") == 0) {
+    mr_asprintf(partcode, "fd");
+} else if (strcmp(format, "ntfs") == 0) {
+    mr_asprintf(partcode, "7");
+} else if ((strcmp(format, "ufs") == 0)
+             || (strcmp(format, "ffs") == 0)) { /* raid autodetect */
+    mr_asprintf(partcode, "a5");
+} else if (strcmp(format, "lvm") == 0) {
+    mr_asprintf(partcode, "8e");
+} else if (format[0] == '\0') { /* LVM physical partition */
+    mr_asprintf(partcode, "");
+} else if (strlen(format) >= 1 && strlen(format) <= 2) {
+    mr_asprintf(partcode, format);
+} else {
+    /* probably an image */
+    mr_asprintf(tmp, "Unknown format ('%s') - using supplied string anyway", format);
+    mvaddstr_and_log_it(g_currentY++, 0, tmp);
+    mr_free(tmp);
+
+#ifdef __FreeBSD__
+    mr_asprintf(partcode, format);  // was a5
+#else
+    mr_asprintf(partcode, format);  // was 83
+#endif
+}
+log_msg(1, "Setting %s's type to %s (%s)", partition, format, partcode);
+if ((strcmp(partcode,"") != 0) && strcmp(partcode, "83")) { /* no need to set type if 83: 83 is default */
+
+    if (pout_to_fdisk) {
+        res = 0;
+        fput_string_one_char_at_a_time(pout_to_fdisk, "t\n");
+        if (partno > 1
+            || strstr(last_line_of_file(FDISK_LOG), " (1-4)")) {
+            log_msg(5, "Specifying partno (%d) - yay", partno);
+            mr_asprintf(tmp, "%d\n", partno);
+            fput_string_one_char_at_a_time(pout_to_fdisk, tmp);
+            log_msg(5, "A - last line = '%s'", last_line_of_file(FDISK_LOG));
+            mr_free(tmp);
+        }
+
+        mr_asprintf(tmp, "%s\n", partcode);
+        fput_string_one_char_at_a_time(pout_to_fdisk, tmp);
+        mr_free(tmp);
+
+        log_msg(5, "B - last line = '%s'",
+                last_line_of_file(FDISK_LOG));
+        fput_string_one_char_at_a_time(pout_to_fdisk, "\n");
+        log_msg(5, "C - last line = '%s'",
+                last_line_of_file(FDISK_LOG));
+
+        mr_asprintf(tmp, "%s", last_line_of_file(FDISK_LOG));
+        if (!strstr(tmp, " (m ")) {
+            log_msg(1, "last line = '%s'; part type set failed", tmp);
+            res++;
+            fput_string_one_char_at_a_time(pout_to_fdisk, "\n");
+        }
+        mr_free(tmp);
+
+        fput_string_one_char_at_a_time(pout_to_fdisk, "p\n");
+    } else {
+        mr_asprintf(output, "t\n%d\n%s\nw\n", partno, partcode);
+        mr_asprintf(command, "parted2fdisk %s >> %s 2>> %s", drive, MONDO_LOGFILE, MONDO_LOGFILE);
+        log_msg(5, "output = '%s'", output);
+        log_msg(5, "partno=%d; partcode=%s", partno, partcode);
+        log_msg(5, "command = '%s'", command);
+        fout = popen(command, "w");
+        if (!fout) {
+            log_OS_error(command);
+            res = 1;
         } else {
-            strcpy(partcode, "b");
-        }
-    } else if (strcmp(format, "ext2") == 0
-                 || strcmp(format, "reiserfs") == 0
-                 || strcmp(format, "ext3") == 0 
-                 || strcmp(format, "ext4") == 0 
-                 || strcmp(format, "xfs") == 0
-                 || strcmp(format, "jfs") == 0
-                     || strcmp(format, "btrfs") == 0) {
-        strcpy(partcode, "83");
-    } else if (strcmp(format, "minix") == 0) {
-        strcpy(partcode, "81");
-    } else if (strcmp(format, "vmfs3") == 0) {
-        strcpy(partcode, "fb");
-    } else if (strcmp(format, "vmkcore") == 0) {
-        strcpy(partcode, "fc");
-    } else if (strcmp(format, "raid") == 0) {
-        strcpy(partcode, "fd");
-    } else if (strcmp(format, "ntfs") == 0) {
-        strcpy(partcode, "7");
-    } else if ((strcmp(format, "ufs") == 0)
-                 || (strcmp(format, "ffs") == 0)) { /* raid autodetect */
-        strcpy(partcode, "a5");
-    } else if (strcmp(format, "lvm") == 0) {
-        strcpy(partcode, "8e");
-    } else if (format[0] == '\0') { /* LVM physical partition */
-        partcode[0] = '\0';
-    } else if (strlen(format) >= 1 && strlen(format) <= 2) {
-        strcpy(partcode, format);
-    } else {
-        /* probably an image */
-        sprintf(tmp,
-                "Unknown format ('%s') - using supplied string anyway",
-                format);
-        mvaddstr_and_log_it(g_currentY++, 0, tmp);
+            res = 0;
+            fprintf(fout, "%s", output);
+            paranoid_pclose(fout);
+        }
+        mr_free(command);
+        paranoid_free(output);
+    }
+}
+mr_free(partcode);
+
+paranoid_free(partition);
+
+return (res);
+}
+
+
+int start_raid_device(char *raid_device) {
+
+/** int *************************************************************/
+int res;
+int retval = 0;
+
+/** buffers *********************************************************/
+char *program = NULL;
+
+/** end *************************************************************/
+
+assert_string_is_neither_NULL_nor_zerolength(raid_device);
+
 #ifdef __FreeBSD__
-        strcpy(partcode, format);   // was a5
+if (is_this_device_mounted(raid_device)) {
+    log_it("Can't start %s when it's mounted!", raid_device);
+    return 1;
+}
+mr_asprintf(program, "vinum start -f %s", raid_device);
 #else
-        strcpy(partcode, format);   // was 83
-#endif
-    }
-    sprintf(tmp, "Setting %s's type to %s (%s)", partition, format,
-            partcode);
-    log_msg(1, tmp);
-    if (partcode[0] != '\0' && strcmp(partcode, "83")) {    /* no need to set type if 83: 83 is default */
-
-        if (pout_to_fdisk) {
-            res = 0;
-            fput_string_one_char_at_a_time(pout_to_fdisk, "t\n");
-            if (partno > 1
-                || strstr(last_line_of_file(FDISK_LOG), " (1-4)")) {
-                log_msg(5, "Specifying partno (%d) - yay", partno);
-                sprintf(tmp, "%d\n", partno);
-                fput_string_one_char_at_a_time(pout_to_fdisk, tmp);
-                log_msg(5, "A - last line = '%s'",
-                        last_line_of_file(FDISK_LOG));
-            }
-
-            sprintf(tmp, "%s\n", partcode);
-            fput_string_one_char_at_a_time(pout_to_fdisk, tmp);
-            log_msg(5, "B - last line = '%s'",
-                    last_line_of_file(FDISK_LOG));
-            fput_string_one_char_at_a_time(pout_to_fdisk, "\n");
-            log_msg(5, "C - last line = '%s'",
-                    last_line_of_file(FDISK_LOG));
-
-            strcpy(tmp, last_line_of_file(FDISK_LOG));
-            if (!strstr(tmp, " (m ")) {
-                log_msg(1, "last line = '%s'; part type set failed", tmp);
-                res++;
-                fput_string_one_char_at_a_time(pout_to_fdisk, "\n");
-            }
-            fput_string_one_char_at_a_time(pout_to_fdisk, "p\n");
-        } else {
-            mr_asprintf(output, "t\n%d\n%s\nw\n", partno, partcode);
-            sprintf(command, "parted2fdisk %s >> %s 2>> %s", drive,
-                    MONDO_LOGFILE, MONDO_LOGFILE);
-            log_msg(5, "output = '%s'", output);
-            log_msg(5, "partno=%d; partcode=%s", partno, partcode);
-            log_msg(5, "command = '%s'", command);
-            fout = popen(command, "w");
-            if (!fout) {
-                log_OS_error(command);
-                res = 1;
-            } else {
-                res = 0;
-                fprintf(fout, "%s", output);
-                paranoid_pclose(fout);
-            }
-            paranoid_free(output);
-        }
-        if (res) {
-            log_OS_error(command);
-        }
-    }
-
-    paranoid_free(partition);
-    paranoid_free(command);
-    paranoid_free(tmp);
-    paranoid_free(partcode);
-    paranoid_free(logfile);
-
-    return (res);
-}
-
-
-int start_raid_device(char *raid_device)
-{
-    /** int *************************************************************/
-    int res;
-    int retval = 0;
-
-    /** buffers *********************************************************/
-    char *program;
-
-    /** end *************************************************************/
-
-    assert_string_is_neither_NULL_nor_zerolength(raid_device);
-    malloc_string(program);
-
-#ifdef __FreeBSD__
-    if (is_this_device_mounted(raid_device)) {
-        log_it("Can't start %s when it's mounted!", raid_device);
-        return 1;
-    }
-    sprintf(program, "vinum start -f %s", raid_device);
-#else
-    sprintf(program, "raidstart %s", raid_device);
-#endif
-    log_msg(1, "program = %s", program);
-    res = run_program_and_log_output(program, 1);
-    if (g_fprep) {
-        fprintf(g_fprep, "%s\n", program);
-    }
-    if (res) {
-        log_msg(1, "Warning - failed to start RAID device %s",
-                raid_device);
-    }
-    retval += res;
-    sleep(1);
-    return (retval);
+mr_asprintf(program, "raidstart %s", raid_device);
+#endif
+log_msg(1, "program = %s", program);
+res = run_program_and_log_output(program, 1);
+if (g_fprep) {
+    fprintf(g_fprep, "%s\n", program);
+}
+mr_free(program);
+
+if (res) {
+    log_msg(1, "Warning - failed to start RAID device %s", raid_device);
+}
+retval += res;
+sleep(1);
+return (retval);
 }
 
@@ -2092 +1974 @@
  * @return 0 for success, nonzero for failure.
  */
-int stop_raid_device(char *raid_device)
-{
-    /** int *************************************************************/
-    int res;
-    int retval = 0;
-
-    /** buffers *********************************************************/
-    char *program;
-
-    /** end *************************************************************/
-
-    assert_string_is_neither_NULL_nor_zerolength(raid_device);
-    malloc_string(program);
+int stop_raid_device(char *raid_device) {
+
+/** int *************************************************************/
+int res;
+int retval = 0;
+
+/** buffers *********************************************************/
+char *program = NULL;
+
+/** end *************************************************************/
+
+assert_string_is_neither_NULL_nor_zerolength(raid_device);
 
 #ifdef __FreeBSD__
-    if (is_this_device_mounted(raid_device)) {
-        log_it("Can't stop %s when it's mounted!", raid_device);
-        return 1;
-    }
-    sprintf(program, "vinum stop -f %s", raid_device);
+if (is_this_device_mounted(raid_device)) {
+    log_it("Can't stop %s when it's mounted!", raid_device);
+    return 1;
+}
+mr_asprintf(program, "vinum stop -f %s", raid_device);
 #else
-        // use raidstop if it exists, otherwise use mdadm
-        if (run_program_and_log_output("which raidstop", FALSE)) {
-        sprintf(program, "mdadm -S %s", raid_device);
-    } else {
-        sprintf(program, "raidstop %s", raid_device);
-    }
-#endif
-    log_msg(1, "program = %s", program);
-    res = run_program_and_log_output(program, 1);
-    if (g_fprep) {
-        fprintf(g_fprep, "%s\n", program);
-    }
-    if (res) {
-        log_msg(1, "Warning - failed to stop RAID device %s", raid_device);
-    }
-    retval += res;
-    return (retval);
-}
-
-
-int start_all_raid_devices(struct mountlist_itself *mountlist)
-{
-    int i;
-    int retval = 0;
-    int res;
-
-    for (i = 0; i < mountlist->entries; i++) {
-        if (!strncmp
-            (mountlist->el[i].device, RAID_DEVICE_STUB,
-             strlen(RAID_DEVICE_STUB))) {
-            log_msg(1, "Starting %s", mountlist->el[i].device);
-            res = start_raid_device(mountlist->el[i].device);
-            retval += res;
-        }
-    }
-    if (retval) {
-        log_msg(1, "Started all s/w raid devices OK");
-    } else {
-        log_msg(1, "Failed to start some/all s/w raid devices");
-    }
-    return (retval);
+// use raidstop if it exists, otherwise use mdadm
+if (run_program_and_log_output("which raidstop", FALSE)) {
+    mr_asprintf(program, "mdadm -S %s", raid_device);
+} else {
+    mr_asprintf(program, "raidstop %s", raid_device);
+}
+#endif
+log_msg(1, "program = %s", program);
+res = run_program_and_log_output(program, 1);
+if (g_fprep) {
+    fprintf(g_fprep, "%s\n", program);
+}
+mr_free(program);
+
+if (res) {
+    log_msg(1, "Warning - failed to stop RAID device %s", raid_device);
+}
+retval += res;
+return (retval);
+}
+
+
+int start_all_raid_devices(struct mountlist_itself *mountlist) {
+
+int i;
+int retval = 0;
+int res;
+
+for (i = 0; i < mountlist->entries; i++) {
+    if (!strncmp(mountlist->el[i].device, RAID_DEVICE_STUB, strlen(RAID_DEVICE_STUB))) {
+        log_msg(1, "Starting %s", mountlist->el[i].device);
+        res = start_raid_device(mountlist->el[i].device);
+        retval += res;
+    }
+}
+if (retval) {
+    log_msg(1, "Started all s/w raid devices OK");
+} else {
+    log_msg(1, "Failed to start some/all s/w raid devices");
+}
+return (retval);
 }
 
@@ -2162 +2043 @@
  * @bug @p mountlist is not used.
  */
-int stop_all_raid_devices(struct mountlist_itself *mountlist)
-{
-    /** int *************************************************************/
-    int retval = 0;
-
-    /** char ************************************************************/
-    char *incoming;
+int stop_all_raid_devices(struct mountlist_itself *mountlist) {
+
+/** int *************************************************************/
+int retval = 0;
+
+/** char ************************************************************/
+char *incoming;
 #ifndef __FreeBSD__
-    char *dev;
-#endif
-    /** pointers ********************************************************/
+char *dev;
+#endif
+/** pointers ********************************************************/
 #ifndef __FreeBSD__
-    char *p;
-#endif
-    FILE *fin;
-    char *q;
-    int i;
-
-    /** end ****************************************************************/
-
-    malloc_string(dev);
-    malloc_string(incoming);
-    assert(mountlist != NULL);
-
-    for (i = 0; i < 3; i++) {
+char *p;
+#endif
+FILE *fin;
+char *q;
+int i;
+
+/** end ****************************************************************/
+
+malloc_string(incoming);
+assert(mountlist != NULL);
+
+for (i = 0; i < 3; i++) {
 #ifdef __FreeBSD__
-        fin =
-            popen
-            ("vinum list | grep '^[PVS]' | sed 's/S/1/;s/P/2/;s/V/3/' | sort | cut -d' ' -f2",
-             "r");
-        if (!fin) {
+    fin = popen("vinum list | grep '^[PVS]' | sed 's/S/1/;s/P/2/;s/V/3/' | sort | cut -d' ' -f2", "r");
+    if (!fin) {
+        paranoid_free(incoming);
+        return (1);
+    }
+    for (q = fgets(incoming, MAX_STR_LEN - 1, fin); !feof(fin) && (q != NULL); q = fgets(incoming, MAX_STR_LEN - 1, fin)) {
+        retval += stop_raid_device(incoming);
+    }
+#else
+    fin = fopen("/proc/mdstat", "r");
+    if (!fin) {
+        log_OS_error("/proc/mdstat");
+        paranoid_free(incoming);
+        return (1);
+    }
+    for (q = fgets(incoming, MAX_STR_LEN - 1, fin); !feof(fin) && (q != NULL); q = fgets(incoming, MAX_STR_LEN - 1, fin)) {
+        for (p = incoming; *p != '\0' && (*p != 'm' || *(p + 1) != 'd' || !isdigit(*(p + 2))); p++);
+        if (*p != '\0') {
+            malloc_string(dev);
+            sprintf(dev, "/dev/%s", p);
+            for (p = dev; *p > 32; p++);
+            *p = '\0';
+            retval += stop_raid_device(dev);
             paranoid_free(dev);
-            paranoid_free(incoming);
-            return (1);
-        }
-        for (q = fgets(incoming, MAX_STR_LEN - 1, fin); !feof(fin) && (q != NULL);
-             q = fgets(incoming, MAX_STR_LEN - 1, fin)) {
-            retval += stop_raid_device(incoming);
-        }
-#else
-        fin = fopen("/proc/mdstat", "r");
-        if (!fin) {
-            log_OS_error("/proc/mdstat");
-            paranoid_free(dev);
-            paranoid_free(incoming);
-            return (1);
-        }
-        for (q = fgets(incoming, MAX_STR_LEN - 1, fin); !feof(fin) && (q != NULL);
-             q = fgets(incoming, MAX_STR_LEN - 1, fin)) {
-            for (p = incoming;
-                 *p != '\0' && (*p != 'm' || *(p + 1) != 'd'
-                                || !isdigit(*(p + 2))); p++);
-            if (*p != '\0') {
-                sprintf(dev, "/dev/%s", p);
-                for (p = dev; *p > 32; p++);
-                *p = '\0';
-                retval += stop_raid_device(dev);
-            }
-        }
-#endif
-    }
-    paranoid_fclose(fin);
-    if (retval) {
-        log_msg(1, "Warning - unable to stop some RAID devices");
-    }
-    paranoid_free(dev);
-    paranoid_free(incoming);
-    paranoid_system("sync");
-    paranoid_system("sync");
-    paranoid_system("sync");
-    sleep(1);
-    return (retval);
+        }
+    }
+#endif
+}
+paranoid_fclose(fin);
+if (retval) {
+    log_msg(1, "Warning - unable to stop some RAID devices");
+}
+paranoid_free(incoming);
+paranoid_system("sync");
+paranoid_system("sync");
+paranoid_system("sync");
+sleep(1);
+return (retval);
 }
 
@@ -2244 +2116 @@
  * @return 0 for success, nonzero for failure.
  */
-int which_format_command_do_i_need(char *format, char *program)
-{
-    /** int *************************************************************/
-    int res = 0;
-
-    /** buffers *********************************************************/
-    char *tmp;
-
-    /** end ***************************************************************/
-
-    malloc_string(tmp);
-    assert_string_is_neither_NULL_nor_zerolength(format);
-    assert(program != NULL);
-
-    if (strcmp(format, "swap") == 0) {
+int which_format_command_do_i_need(char *format, char *program) {
+
+/** int *************************************************************/
+int res = 0;
+
+/** buffers *********************************************************/
+
+/** end ***************************************************************/
+
+assert_string_is_neither_NULL_nor_zerolength(format);
+assert(program != NULL);
+
+if (strcmp(format, "swap") == 0) {
 #ifdef __FreeBSD__
-        strcpy(program, "true");
+    strcpy(program, "true");
 #else
-        strcpy(program, "mkswap");
-#endif
-    } else if (strcmp(format, "vfat") == 0) {
-        strcpy(program, "format-and-kludge-vfat");
+    strcpy(program, "mkswap");
+#endif
+} else if (strcmp(format, "vfat") == 0) {
+    strcpy(program, "format-and-kludge-vfat");
 #ifndef __FreeBSD__
-    } else if (strcmp(format, "reiserfs") == 0) {
-        strcpy(program, "mkreiserfs -ff");
-    } else if (strcmp(format, "xfs") == 0) {
-        strcpy(program, "mkfs.xfs -f -q");
-    } else if (strcmp(format, "jfs") == 0) {
-        strcpy(program, "mkfs.jfs");
-    } else if (strcmp(format, "ext3") == 0) {
-        strcpy(program, "mkfs -t ext3 -F -q");
-    } else if (strcmp(format, "ext4") == 0) {
-        strcpy(program, "mkfs -t ext4 -F -q");
-    } else if (strcmp(format, "btrfs") == 0) {
-              strcpy(program, "mkfs.btrfs");
-    } else if (strcmp(format, "minix") == 0) {
-        strcpy(program, "mkfs.minix");
-    } else if (strcmp(format, "vmfs") == 0) {
-        strcpy(program, "mkfs -t vmfs");
-    } else if (strcmp(format, "ntfs") == 0) { 
-        /* 
-         * mkfs.ntfs treats the '-c' switch as 'specify cluster size' 
-         * so the default "mkfs -t %s -c" command structure fails 
-         */ 
-        strcpy(program, "mkfs -t ntfs");
-    } else if (strcmp(format, "ocfs2") == 0) {
-        /*
-         * For existing OCFS2 volumes, mkfs.ocfs2 ensures the volume is not mounted on any node in the cluster before formatting. For that to work, mkfs.ocfs2 expects the O2CB cluster service to be running. Specify this option to disable this check.
-         *
-         */
-        strcpy(program, "mkfs -t ocfs2 -F");
-#endif
-    } else if (strcmp(format, "ext2") == 0) {
-        strcpy(program, "mke2fs -F -q");
-    } else {
+} else if (strcmp(format, "reiserfs") == 0) {
+    strcpy(program, "mkreiserfs -ff");
+} else if (strcmp(format, "xfs") == 0) {
+    strcpy(program, "mkfs.xfs -f -q");
+} else if (strcmp(format, "jfs") == 0) {
+    strcpy(program, "mkfs.jfs");
+} else if (strcmp(format, "ext3") == 0) {
+    strcpy(program, "mkfs -t ext3 -F -q");
+} else if (strcmp(format, "ext4") == 0) {
+    strcpy(program, "mkfs -t ext4 -F -q");
+} else if (strcmp(format, "btrfs") == 0) {
+    strcpy(program, "mkfs.btrfs");
+} else if (strcmp(format, "minix") == 0) {
+    strcpy(program, "mkfs.minix");
+} else if (strcmp(format, "vmfs") == 0) {
+    strcpy(program, "mkfs -t vmfs");
+} else if (strcmp(format, "ntfs") == 0) { 
+    /* 
+     * mkfs.ntfs treats the '-c' switch as 'specify cluster size' 
+     * so the default "mkfs -t %s -c" command structure fails 
+     */ 
+    strcpy(program, "mkfs -t ntfs");
+} else if (strcmp(format, "ocfs2") == 0) {
+    /*
+     * For existing OCFS2 volumes, mkfs.ocfs2 ensures the volume is not mounted on any node in the cluster before formatting. For that to work, mkfs.ocfs2 expects the O2CB cluster service to be running. Specify this option to disable this check.
+     *
+     */
+    strcpy(program, "mkfs -t ocfs2 -F");
+#endif
+} else if (strcmp(format, "ext2") == 0) {
+    strcpy(program, "mke2fs -F -q");
+} else {
 #ifdef __FreeBSD__
-        sprintf(program, "newfs_%s", format);
+    sprintf(program, "newfs_%s", format);
 #else
-        sprintf(program, "mkfs -t %s -c", format);  // -c checks for bad blocks
-#endif
-        sprintf(tmp, "Unknown format (%s) - assuming '%s' will do", format,
-                program);
-        log_it(tmp);
-        res = 0;
-    }
-    paranoid_free(tmp);
-    return (res);
+    sprintf(program, "mkfs -t %s -c", format);  // -c checks for bad blocks
+#endif
+    log_it("Unknown format (%s) - assuming '%s' will do", format, program);
+    res = 0;
+}
+return (res);
 }
 
@@ -2325 +2192 @@
  * @param drive_name The drive to resize.
  */
-void resize_drive_proportionately_to_suit_new_drives(struct mountlist_itself
-                                                     *mountlist,
-                                                     char *drive_name)
-{
-    /**buffers **********************************************************/
-    char *tmp;
-
-    /** int *************************************************************/
-    int partno, lastpart;
-
-    /** float ***********************************************************/
-    float factor;
-    long long new_size;
-
-    /** long *************************************************************/
-    long long newsizL = 0LL;
-    long long totalsizL = 0LL;
-    long long current_size_of_drive = 0LL;  /* use KB interally for precision */
-    long long original_size_of_drive = 0LL; /* use KB interally for precision */
-    struct mountlist_reference *drivemntlist;
-
-    /** structures *******************************************************/
-
-    /** end **************************************************************/
-
-    assert(mountlist != NULL);
-    assert_string_is_neither_NULL_nor_zerolength(drive_name);
-
-    if (strlen(drive_name) >= strlen(RAID_DEVICE_STUB)) {
-        if (strncmp(drive_name, RAID_DEVICE_STUB, strlen(RAID_DEVICE_STUB))
-            == 0) {
-            return;
-        }
-    }
-
-    current_size_of_drive = (long long) get_phys_size_of_drive(drive_name) * 1024LL;
-
-    if (current_size_of_drive <= 0LL) {
-        log_it("Not resizing to match %s - can't find drive", drive_name);
+void resize_drive_proportionately_to_suit_new_drives(struct mountlist_itself *mountlist, char *drive_name) {
+
+/**buffers **********************************************************/
+char *tmp = NULL;
+
+/** int *************************************************************/
+int partno, lastpart;
+
+/** float ***********************************************************/
+float factor;
+long long new_size;
+
+/** long *************************************************************/
+long long newsizL = 0LL;
+long long totalsizL = 0LL;
+long long current_size_of_drive = 0LL;  /* use KB interally for precision */
+long long original_size_of_drive = 0LL; /* use KB interally for precision */
+struct mountlist_reference *drivemntlist;
+
+/** structures *******************************************************/
+
+/** end **************************************************************/
+
+assert(mountlist != NULL);
+assert_string_is_neither_NULL_nor_zerolength(drive_name);
+
+if (strlen(drive_name) >= strlen(RAID_DEVICE_STUB)) {
+    if (strncmp(drive_name, RAID_DEVICE_STUB, strlen(RAID_DEVICE_STUB))
+        == 0) {
         return;
     }
-    mr_asprintf(tmp, "Expanding entries to suit drive %s (%lld MB)", drive_name, current_size_of_drive / 1024);
-    log_to_screen(tmp);
-    mr_free(tmp);
-
-    drivemntlist = malloc(sizeof(struct mountlist_reference));
-    drivemntlist->el = malloc(sizeof(struct mountlist_line *) * MAX_MOUNTLIST_ENTRIES);
-
-    if (!drivemntlist) {
-        fatal_error("Cannot malloc temporary mountlist\n");
-    }
-    create_mountlist_for_drive(mountlist, drive_name, drivemntlist);
-
-    for (partno = 0; partno < drivemntlist->entries; partno++) {
-        if (drivemntlist->el[partno]->size > 0LL) {
-            /* Keep KB here */
-            original_size_of_drive += drivemntlist->el[partno]->size;
-        }
-    }
-
-    if (original_size_of_drive <= 0LL) {
-        mr_asprintf(tmp, "Cannot resize %s's entries. Drive not found.", drive_name);
-        log_to_screen(tmp);
-        mr_free(tmp);
-        return;
-    }
-    factor = ((float)current_size_of_drive/(float)original_size_of_drive);
-    mr_asprintf(tmp, "Disk %s was %lld MB; is now %lld MB; Proportionally resizing partitions (factor ~= %.5f)",
-            drive_name, original_size_of_drive/1024, current_size_of_drive/1024, factor);
-    log_to_screen(tmp);
-    mr_free(tmp);
-
-    lastpart = drivemntlist->entries - 1;
-    for (partno = 0; partno < drivemntlist->entries; partno++) {
-        /* the 'atoi' thing is to make sure we don't try to resize _images_, whose formats will be numeric */
-        if (!atoi(drivemntlist->el[partno]->format)) {
-            new_size = (long long)((drivemntlist->el[partno]->size) * factor);
-        } else {
-            new_size = drivemntlist->el[partno]->size;
-        }
-
-        if (!strcmp(drivemntlist->el[partno]->mountpoint, "image")) {
-            log_msg(1, "Skipping %s (%s) because it's an image",
-                    drivemntlist->el[partno]->device,
-                    drivemntlist->el[partno]->mountpoint);
-        }
-        newsizL = new_size;
-
-        /* Do not apply the factor if partition was of negative size */
-        if (newsizL < 0LL) {
-            newsizL = drivemntlist->el[partno]->size;
-        }
-        totalsizL += newsizL;
-
-        mr_asprintf(tmp, "Changing %s from %lld KB to %lld KB", drivemntlist->el[partno]->device, drivemntlist->el[partno]->size, newsizL);
-        log_to_screen(tmp);
-        mr_free(tmp);
-        drivemntlist->el[partno]->size = newsizL;
-    }
-    // Ensures over-allocation alert and prompt for interactive mode does not happen
-    if (totalsizL > current_size_of_drive) {
-        mr_asprintf(tmp, "Last partition size calculated would be over-allocated, reducing %s from %lld KB to %lld KB.", drivemntlist->el[lastpart]->device, drivemntlist->el[lastpart]->size, drivemntlist->el[lastpart]->size - (totalsizL - current_size_of_drive));
-        drivemntlist->el[drivemntlist->entries-1]->size -= (totalsizL - current_size_of_drive);
-    } else if (totalsizL < current_size_of_drive) {
-        mr_asprintf(tmp, "Last partition size calculated would be under-allocated, increasing %s from %lld KB to %lld KB.",drivemntlist->el[lastpart]->device, drivemntlist->el[lastpart]->size, drivemntlist->el[lastpart]->size + (current_size_of_drive - totalsizL));
-        drivemntlist->el[drivemntlist->entries-1]->size += (current_size_of_drive - totalsizL);
-    }
-    log_to_screen(tmp);
-    mr_free(tmp);
-    mr_asprintf(tmp, "final_size = %lld MB", current_size_of_drive / 1024);
-    log_to_screen(tmp);
-    mr_free(tmp);
+}
+
+current_size_of_drive = (long long) get_phys_size_of_drive(drive_name) * 1024LL;
+
+if (current_size_of_drive <= 0LL) {
+    log_it("Not resizing to match %s - can't find drive", drive_name);
+    return;
+}
+log_to_screen("Expanding entries to suit drive %s (%lld MB)", drive_name, current_size_of_drive / 1024);
+
+drivemntlist = malloc(sizeof(struct mountlist_reference));
+drivemntlist->el = malloc(sizeof(struct mountlist_line *) * MAX_MOUNTLIST_ENTRIES);
+
+if (!drivemntlist) {
+    fatal_error("Cannot malloc temporary mountlist\n");
+}
+create_mountlist_for_drive(mountlist, drive_name, drivemntlist);
+
+for (partno = 0; partno < drivemntlist->entries; partno++) {
+    if (drivemntlist->el[partno]->size > 0LL) {
+        /* Keep KB here */
+        original_size_of_drive += drivemntlist->el[partno]->size;
+    }
+}
+
+if (original_size_of_drive <= 0LL) {
+    log_to_screen("Cannot resize %s's entries. Drive not found.", drive_name);
+    return;
+}
+factor = ((float)current_size_of_drive/(float)original_size_of_drive);
+log_to_screen("Disk %s was %lld MB; is now %lld MB; Proportionally resizing partitions (factor ~= %.5f)", drive_name, original_size_of_drive/1024, current_size_of_drive/1024, factor);
+
+lastpart = drivemntlist->entries - 1;
+for (partno = 0; partno < drivemntlist->entries; partno++) {
+    /* the 'atoi' thing is to make sure we don't try to resize _images_, whose formats will be numeric */
+    if (!atoi(drivemntlist->el[partno]->format)) {
+        new_size = (long long)((drivemntlist->el[partno]->size) * factor);
+    } else {
+        new_size = drivemntlist->el[partno]->size;
+    }
+
+    if (!strcmp(drivemntlist->el[partno]->mountpoint, "image")) {
+        log_msg(1, "Skipping %s (%s) because it's an image",
+                drivemntlist->el[partno]->device,
+                drivemntlist->el[partno]->mountpoint);
+    }
+    newsizL = new_size;
+
+    /* Do not apply the factor if partition was of negative size */
+    if (newsizL < 0LL) {
+        newsizL = drivemntlist->el[partno]->size;
+    }
+    totalsizL += newsizL;
+
+    log_to_screen("Changing %s from %lld KB to %lld KB", drivemntlist->el[partno]->device, drivemntlist->el[partno]->size, newsizL);
+    drivemntlist->el[partno]->size = newsizL;
+}
+// Ensures over-allocation alert and prompt for interactive mode does not happen
+if (totalsizL > current_size_of_drive) {
+    mr_asprintf(tmp, "Last partition size calculated would be over-allocated, reducing %s from %lld KB to %lld KB.", drivemntlist->el[lastpart]->device, drivemntlist->el[lastpart]->size, drivemntlist->el[lastpart]->size - (totalsizL - current_size_of_drive));
+    drivemntlist->el[drivemntlist->entries-1]->size -= (totalsizL - current_size_of_drive);
+} else if (totalsizL < current_size_of_drive) {
+    mr_asprintf(tmp, "Last partition size calculated would be under-allocated, increasing %s from %lld KB to %lld KB.",drivemntlist->el[lastpart]->device, drivemntlist->el[lastpart]->size, drivemntlist->el[lastpart]->size + (current_size_of_drive - totalsizL));
+    drivemntlist->el[drivemntlist->entries-1]->size += (current_size_of_drive - totalsizL);
+}
+log_to_screen(tmp);
+mr_free(tmp);
+log_to_screen("final_size = %lld MB", current_size_of_drive / 1024);
 }
 
@@ -2446 +2300 @@
  * @param mountlist The mountlist to resize the drives in.
  */
-void resize_mountlist_proportionately_to_suit_new_drives(struct mountlist_itself
-                                                         *mountlist)
-{
-    /** buffers *********************************************************/
-    struct list_of_disks *drivelist;
-
-    /** int *************************************************************/
-    int driveno;
-
-    /** end *************************************************************/
-
-    drivelist = malloc(sizeof(struct list_of_disks));
-    assert(mountlist != NULL);
-
-    if (g_mountlist_fname[0] == '\0') {
-        log_it("resize_mountlist_prop...() - warning - mountlist fname is blank");
-        log_it("That does NOT affect the functioning of this subroutine.");
-        log_it("--- Hugo, 2002/11/20");
-    }
-    log_it("Resizing mountlist");
-    make_list_of_drives_in_mountlist(mountlist, drivelist);
-    log_it("Back from MLoDiM");
-    for (driveno = 0; driveno < drivelist->entries; driveno++) {
-        resize_drive_proportionately_to_suit_new_drives(mountlist, drivelist->el[driveno].device);
-    }
-    log_to_screen("Mountlist adjusted to suit current hard drive(s)");
-    paranoid_free(drivelist);
+void resize_mountlist_proportionately_to_suit_new_drives(struct mountlist_itself *mountlist) {
+
+/** buffers *********************************************************/
+struct list_of_disks *drivelist;
+
+/** int *************************************************************/
+int driveno;
+
+/** end *************************************************************/
+
+drivelist = malloc(sizeof(struct list_of_disks));
+assert(mountlist != NULL);
+
+if (g_mountlist_fname[0] == '\0') {
+    log_it("resize_mountlist_prop...() - warning - mountlist fname is blank");
+    log_it("That does NOT affect the functioning of this subroutine.");
+    log_it("--- Hugo, 2002/11/20");
+}
+log_it("Resizing mountlist");
+make_list_of_drives_in_mountlist(mountlist, drivelist);
+log_it("Back from MLoDiM");
+for (driveno = 0; driveno < drivelist->entries; driveno++) {
+    resize_drive_proportionately_to_suit_new_drives(mountlist, drivelist->el[driveno].device);
+}
+log_to_screen("Mountlist adjusted to suit current hard drive(s)");
+paranoid_free(drivelist);
 }
 
@@ -2483 +2336 @@
  * @author Ralph Grewe
  */
-void create_mountlist_for_drive(struct mountlist_itself *mountlist,
-                                char *drive_name,
-                                struct mountlist_reference *drivemntlist)
-{
-    int partno;
-    char *tmp_drive_name, *c;
-
-    assert(mountlist != NULL);
-    assert(drive_name != NULL);
-    assert(drivemntlist != NULL);
-
-    log_msg(1, "Creating list of partitions for drive %s", drive_name);
-
-    tmp_drive_name = strdup(drive_name);
-    if (!tmp_drive_name)
-        fatal_error("Out of memory");
-
-    /* devfs devices? */
-    c = strrchr(tmp_drive_name, '/');
-    if (c && strncmp(c, "/disc", 5) == 0) {
-        /* yup its devfs, change the "disc" to "part" so the existing code works */
-        strcpy(c + 1, "part");
-    }
-    drivemntlist->entries = 0;
-    for (partno = 0; partno < mountlist->entries; partno++) {
-        if (strncmp
-            (mountlist->el[partno].device, tmp_drive_name,
-             strlen(tmp_drive_name)) == 0) {
-            drivemntlist->el[drivemntlist->entries] =
-                &mountlist->el[partno];
-            drivemntlist->entries++;
-        }
-    }
-    if (tmp_drive_name)
-        free(tmp_drive_name);
+void create_mountlist_for_drive(struct mountlist_itself *mountlist, char *drive_name, struct mountlist_reference *drivemntlist) {
+
+int partno;
+char *tmp_drive_name, *c;
+
+assert(mountlist != NULL);
+assert(drive_name != NULL);
+assert(drivemntlist != NULL);
+
+log_msg(1, "Creating list of partitions for drive %s", drive_name);
+
+tmp_drive_name = strdup(drive_name);
+if (!tmp_drive_name)
+    fatal_error("Out of memory");
+
+/* devfs devices? */
+c = strrchr(tmp_drive_name, '/');
+if (c && strncmp(c, "/disc", 5) == 0) {
+    /* yup its devfs, change the "disc" to "part" so the existing code works */
+    strcpy(c + 1, "part");
+}
+drivemntlist->entries = 0;
+for (partno = 0; partno < mountlist->entries; partno++) {
+    if (strncmp(mountlist->el[partno].device, tmp_drive_name, strlen(tmp_drive_name)) == 0) {
+        drivemntlist->el[drivemntlist->entries] = &mountlist->el[partno];
+        drivemntlist->entries++;
+    }
+}
+if (tmp_drive_name)
+    free(tmp_drive_name);
 }