Changeset 59 in MondoRescue for trunk/mondo/mondo/mondorestore/mondo-prep.c

Timestamp:

Oct 11, 2005, 1:34:31 AM (19 years ago)

Author:

bcornec

Message:

Trunk: indent on all source files

File:

• trunk/mondo/mondo/mondorestore/mondo-prep.c (modified) (116 diffs)

trunk/mondo/mondo/mondorestore/mondo-prep.c

@@ -8 +8 @@
 edited by : by Stan Benoit 4/2002
 email     : troff@nakedsoul.org
-cvsid     : $Id: mondo-prep.c,v 1.14 2004/06/21 20:20:36 hugo Exp $
+cvsid     : $Id$
 ***************************************************************************/
 
@@ -181 +181 @@
 #define MONDO_WAS_HERE "MONDOWOZEREMONDOWOZEREMONDOWOZEREhahahaMOJOJOJO"
 
-//static char cvsid[] = "$Id: mondo-prep.c,v 1.14 2004/06/21 20:20:36 hugo Exp $";
+//static char cvsid[] = "$Id$";
 
 extern char *g_mountlist_fname;
@@ -188 +188 @@
 extern bool g_text_mode;
 
-extern void pause_for_N_seconds(int, char*);
-
-
-FILE *g_fprep=NULL;
-
-
-
-int g_partition_table_locked_up=0;
+extern void pause_for_N_seconds(int, char *);
+
+
+FILE *g_fprep = NULL;
+
+
+
+int g_partition_table_locked_up = 0;
 
 
@@ -208 +208 @@
 void wipe_MBRs_and_reboot_if_necessary(struct mountlist_itself *mountlist)
 {
-    char *command;
-    char *tmp;
-    int lino;
-    int i;
-    FILE*fout;
-    char *buf;
-    const int blocksize=512;        
-        struct list_of_disks *drivelist=NULL;
+    char *command;
+    char *tmp;
+    int lino;
+    int i;
+    FILE *fout;
+    char *buf;
+    const int blocksize = 512;
+    struct list_of_disks *drivelist = NULL;
 // If LVMs are present and a zero-and-reboot wasn't recently undertaken
 // then zero & insist on reboot.
-    malloc_string(command);
-    malloc_string(tmp);
-    buf = malloc(blocksize);
-        if (does_file_exist("/tmp/i-want-my-lvm")) // FIXME - cheating :)
-      {
-        drivelist = malloc(sizeof(struct list_of_disks));
-        make_list_of_drives_in_mountlist(mountlist, drivelist);
-        for (lino = 0; lino < drivelist->entries; lino++)
-          {
-            sprintf(command, "dd if=%s bs=512 count=1 2> /dev/null | grep \"%s\"", drivelist->el[lino].device, MONDO_WAS_HERE);
-            if (!run_program_and_log_output(command, 1))
-          {
-            log_msg(1, "Found MONDO_WAS_HERE marker on drive#%d (%s)", lino, drivelist->el[lino].device);
-            break;
-          }
-              }
-        
-        if (lino==drivelist->entries)
-          {
+    malloc_string(command);
+    malloc_string(tmp);
+    buf = malloc(blocksize);
+    if (does_file_exist("/tmp/i-want-my-lvm"))  // FIXME - cheating :)
+    {
+        drivelist = malloc(sizeof(struct list_of_disks));
+        make_list_of_drives_in_mountlist(mountlist, drivelist);
+        for (lino = 0; lino < drivelist->entries; lino++) {
+            sprintf(command,
+                    "dd if=%s bs=512 count=1 2> /dev/null | grep \"%s\"",
+                    drivelist->el[lino].device, MONDO_WAS_HERE);
+            if (!run_program_and_log_output(command, 1)) {
+                log_msg(1, "Found MONDO_WAS_HERE marker on drive#%d (%s)",
+                        lino, drivelist->el[lino].device);
+                break;
+            }
+        }
+
+        if (lino == drivelist->entries) {
 // zero & reboot
-            log_to_screen("I am sorry for the inconvenience but I must ask you to reboot.");
-        log_to_screen("I need to reset the Master Boot Record; in order to be");
-        log_to_screen("sure the kernel notices, I must reboot after doing it.");
-        log_to_screen("Please hit 'Enter' to reboot.");
-            for (lino = 0; lino < drivelist->entries; lino++)
-              {
-            for(i=0;i<blocksize; i++)
-              { buf[i] = 0; }
-            sprintf(buf, "%s\n", MONDO_WAS_HERE);
-            fout = fopen(drivelist->el[lino].device, "w+");
-            if (!fout)
-              {
-                log_msg(1, "Unable to open+wipe %s", drivelist->el[lino].device);
-              }
-            else
-              {
-                if (1!=fwrite(buf, blocksize, 1, fout))
-              {
-                log_msg(1, "Failed to wipe %s", drivelist->el[lino].device);
-              }
-            else
-              {
-                log_msg(1, "Successfully wiped %s", drivelist->el[lino].device);
-              }
-                fclose(fout);
-                  }
-          }
-                system("sync"); system("sync"); system("sync");
-        popup_and_OK("I must now reboot. Please leave the boot media in the drive and repeat your actions - e.g. type 'nuke' - and it should work fine.");
-                system("reboot"); 
-          }
-          }
-      
+            log_to_screen
+                ("I am sorry for the inconvenience but I must ask you to reboot.");
+            log_to_screen
+                ("I need to reset the Master Boot Record; in order to be");
+            log_to_screen
+                ("sure the kernel notices, I must reboot after doing it.");
+            log_to_screen("Please hit 'Enter' to reboot.");
+            for (lino = 0; lino < drivelist->entries; lino++) {
+                for (i = 0; i < blocksize; i++) {
+                    buf[i] = 0;
+                }
+                sprintf(buf, "%s\n", MONDO_WAS_HERE);
+                fout = fopen(drivelist->el[lino].device, "w+");
+                if (!fout) {
+                    log_msg(1, "Unable to open+wipe %s",
+                            drivelist->el[lino].device);
+                } else {
+                    if (1 != fwrite(buf, blocksize, 1, fout)) {
+                        log_msg(1, "Failed to wipe %s",
+                                drivelist->el[lino].device);
+                    } else {
+                        log_msg(1, "Successfully wiped %s",
+                                drivelist->el[lino].device);
+                    }
+                    fclose(fout);
+                }
+            }
+            system("sync");
+            system("sync");
+            system("sync");
+            popup_and_OK
+                ("I must now reboot. Please leave the boot media in the drive and repeat your actions - e.g. type 'nuke' - and it should work fine.");
+            system("reboot");
+        }
+    }
 // Still here? Cool!
-  paranoid_free(command);
-  paranoid_free(tmp);
-  log_msg(1, "Cool. I didn't have to wipe anything.");
+    paranoid_free(command);
+    paranoid_free(tmp);
+    log_msg(1, "Cool. I didn't have to wipe anything.");
 }
 
@@ -282 +284 @@
 
 
-int fput_string_one_char_at_a_time(FILE*fout, char*str)
+int fput_string_one_char_at_a_time(FILE * fout, char *str)
 {
-  int i, j;
-  FILE*fq;
-
-  if (ferror(fout))
-    {
-    return(-1);
-    }
-  log_msg(5, "Writing string '%s', one char at a time", str);
-  j = strlen(str);
-  for(i=0; i<j; i++)
-    {
-      log_msg(6, "Writing %d ('%c')", str[i], str[i]);
-      if ((fq = fopen(FDISK_LOG, "a+"))) { fputc(str[i], fq);fclose(fq); }
-      fputc(str[i], fout);
-      fflush(fout);
-      usleep(1000L*100L);
-      if (str[i]<32) { usleep(1000L*10L); }
-    }
-  log_msg(5, "Returning");
-   
-   return(i);
+    int i, j;
+    FILE *fq;
+
+    if (ferror(fout)) {
+        return (-1);
+    }
+    log_msg(5, "Writing string '%s', one char at a time", str);
+    j = strlen(str);
+    for (i = 0; i < j; i++) {
+        log_msg(6, "Writing %d ('%c')", str[i], str[i]);
+        if ((fq = fopen(FDISK_LOG, "a+"))) {
+            fputc(str[i], fq);
+            fclose(fq);
+        }
+        fputc(str[i], fout);
+        fflush(fout);
+        usleep(1000L * 100L);
+        if (str[i] < 32) {
+            usleep(1000L * 10L);
+        }
+    }
+    log_msg(5, "Returning");
+
+    return (i);
 }
 
@@ -325 +330 @@
  * @return The number of errors encountered (0 for success).
  */
- 
-
-int do_my_funky_lvm_stuff(bool just_erase_existing_volumes, bool vacuum_pack)
+
+
+int do_my_funky_lvm_stuff(bool just_erase_existing_volumes,
+                          bool vacuum_pack)
 {
     /**  buffers **********************************************/
@@ -340 +346 @@
     char *vgchange_sz;
     char *vgremove_sz;
-//  char *do_this_last;
+//  char *do_this_last;
 
     /** char **************************************************/
@@ -353 +359 @@
     long extents;
     fpos_t orig_pos;
-    
+
     /** pointers **********************************************/
     FILE *fin;
@@ -377 +383 @@
     malloc_string(vgchange_sz);
     malloc_string(vgremove_sz);
-//  malloc_string(do_this_last); // postpone lvcreate call if necessary
+//  malloc_string(do_this_last); // postpone lvcreate call if necessary
     command = malloc(512);
 
-//  do_this_last[0] = '\0';
-iamhere("STARTING");
+//  do_this_last[0] = '\0';
+    iamhere("STARTING");
     log_msg(1, "OK, opened i-want-my-lvm. Shutting down LVM volumes...");
-    if (find_home_of_exe("lvm")) // found it :) cool
-      {
-        strcpy(lvscan_sz,   "lvm lvscan");
-        strcpy(lvremove_sz, "lvm lvremove");
-        strcpy(vgscan_sz,   "lvm vgscan");
-        strcpy(pvscan_sz,   "lvm pvscan");
-        strcpy(vgcreate_sz, "lvm vgcreate");
-        strcpy(vgchange_sz, "lvm vgchange");
-        strcpy(vgremove_sz, "lvm vgremove");
-      }
-    else
-      {
-        strcpy(lvscan_sz,   "lvscan");
-        strcpy(lvremove_sz, "lvremove");
-        strcpy(vgscan_sz,   "vgscan");
-        strcpy(pvscan_sz,   "pvscan");
-        strcpy(vgcreate_sz, "vgcreate");
-        strcpy(vgchange_sz, "vgchange");
-        strcpy(vgremove_sz, "vgremove");
-      }
-    sprintf(command, "for i in `%s | cut -d\"'\" -f2 | sort -r` ; do echo \"Shutting down lv $i\" >> " MONDO_LOGFILE "; %s -f $i; done",
-                    lvscan_sz, lvremove_sz);
+    if (find_home_of_exe("lvm"))    // found it :) cool
+    {
+        strcpy(lvscan_sz, "lvm lvscan");
+        strcpy(lvremove_sz, "lvm lvremove");
+        strcpy(vgscan_sz, "lvm vgscan");
+        strcpy(pvscan_sz, "lvm pvscan");
+        strcpy(vgcreate_sz, "lvm vgcreate");
+        strcpy(vgchange_sz, "lvm vgchange");
+        strcpy(vgremove_sz, "lvm vgremove");
+    } else {
+        strcpy(lvscan_sz, "lvscan");
+        strcpy(lvremove_sz, "lvremove");
+        strcpy(vgscan_sz, "vgscan");
+        strcpy(pvscan_sz, "pvscan");
+        strcpy(vgcreate_sz, "vgcreate");
+        strcpy(vgchange_sz, "vgchange");
+        strcpy(vgremove_sz, "vgremove");
+    }
+    sprintf(command,
+            "for i in `%s | cut -d\"'\" -f2 | sort -r` ; do echo \"Shutting down lv $i\" >> "
+            MONDO_LOGFILE "; %s -f $i; done", lvscan_sz, lvremove_sz);
     run_program_and_log_output(command, 5);
     sleep(1);
-    sprintf(command, "for i in `%s | grep -i lvm | cut -d'\"' -f2` ; do %s -a n $i ; %s $i; echo \"Shutting down vg $i\" >> " MONDO_LOGFILE "; done; %s -a n", vgscan_sz, vgchange_sz, vgremove_sz, vgremove_sz);
+    sprintf(command,
+            "for i in `%s | grep -i lvm | cut -d'\"' -f2` ; do %s -a n $i ; %s $i; echo \"Shutting down vg $i\" >> "
+            MONDO_LOGFILE "; done; %s -a n", vgscan_sz, vgchange_sz,
+            vgremove_sz, vgremove_sz);
     run_program_and_log_output(command, 5);
     if (just_erase_existing_volumes) {
         paranoid_fclose(fin);
         log_msg(1, "Closed i-want-my-lvm. Finished erasing LVMs.");
-        retval=0;
+        retval = 0;
         goto end_of_i_want_my_lvm;
     }
@@ -423 +431 @@
             continue;
         }
-        if (res && strstr(command, "create") && vacuum_pack)
-          {
-            sleep(2);
-            system("sync"); system("sync"); system("sync");
-          }
-        if ((p=strstr(incoming, "vgcreate")))
-          {
+        if (res && strstr(command, "create") && vacuum_pack) {
+            sleep(2);
+            system("sync");
+            system("sync");
+            system("sync");
+        }
+        if ((p = strstr(incoming, "vgcreate"))) {
 // include next line(s) if they end in /dev (cos we've got a broken i-want-my-lvm)
-            for (fgets(tmp, 512, fin); !feof(fin); fgets(tmp, 512, fin)) {
-            if (tmp[0] == '#') {
-                fsetpos(fin, &orig_pos);
-                break;
-            } else {
-                fgetpos(fin, &orig_pos);
-                strcat(incoming, tmp);
-            }
-            }
-            for(q=incoming; *q!='\0'; q++)
-              {
-                if (*q<32) { *q=' '; }
-              }
-            strcpy(tmp, p+strlen("vgcreate")+1);
-            for(q=tmp; *q>32; q++);
-            *q = '\0';
-               log_msg(1, "Deleting old entries at /dev/%s", tmp);
-//             sprintf(command, "%s -f %s", vgremove_sz, tmp);
-//             run_program_and_log_output(command, 1);
-               sprintf(command, "rm -Rf /dev/%s", tmp);
-               run_program_and_log_output(command, 1);
-            run_program_and_log_output(vgscan_sz, 1);
-            run_program_and_log_output(pvscan_sz, 1);
-            log_msg(3, "After working around potentially broken i-want-my-lvm, incoming[] is now '%s'", incoming);
-          }
+            for (fgets(tmp, 512, fin); !feof(fin); fgets(tmp, 512, fin)) {
+                if (tmp[0] == '#') {
+                    fsetpos(fin, &orig_pos);
+                    break;
+                } else {
+                    fgetpos(fin, &orig_pos);
+                    strcat(incoming, tmp);
+                }
+            }
+            for (q = incoming; *q != '\0'; q++) {
+                if (*q < 32) {
+                    *q = ' ';
+                }
+            }
+            strcpy(tmp, p + strlen("vgcreate") + 1);
+            for (q = tmp; *q > 32; q++);
+            *q = '\0';
+            log_msg(1, "Deleting old entries at /dev/%s", tmp);
+//             sprintf(command, "%s -f %s", vgremove_sz, tmp);
+//             run_program_and_log_output(command, 1);
+            sprintf(command, "rm -Rf /dev/%s", tmp);
+            run_program_and_log_output(command, 1);
+            run_program_and_log_output(vgscan_sz, 1);
+            run_program_and_log_output(pvscan_sz, 1);
+            log_msg(3,
+                    "After working around potentially broken i-want-my-lvm, incoming[] is now '%s'",
+                    incoming);
+        }
         for (p = incoming + 1; *p == ' '; p++);
         strcpy(command, p);
@@ -462 +473 @@
         *p = '\0';
         res = run_program_and_log_output(command, 5);
-        if (res>0 && (p=strstr(command, "lvm ")))
-          {
-            *p = *(p+1) = *(p+2) = ' ';
-            res = run_program_and_log_output(command, 5);
-          }
+        if (res > 0 && (p = strstr(command, "lvm "))) {
+            *p = *(p + 1) = *(p + 2) = ' ';
+            res = run_program_and_log_output(command, 5);
+        }
         log_msg(0, "%s --> %d", command, res);
-                if (res>0) {res=1;}
-        if (res && strstr(command, "lvcreate") && vacuum_pack)
-          {
-            res=0;
-            if (strstr(command, "lvm lvcreate"))
-            lvmversion = 2;
-            log_it("%s... so I'll get creative.", tmp);
-            if (lvmversion == 2)
-              {
-                strcpy(tmp, call_program_and_get_last_line_of_output
-                    ("cat /var/log/mondo-archive.log | tail -n5 | grep Insufficient | tail -n1"));
-              }
-            else
-              {
-                strcpy(tmp, call_program_and_get_last_line_of_output
-                    ("cat /var/log/mondo-archive.log | tail -n5 | grep lvcreate | tail -n1"));
-              }
-            for(p=tmp; *p!='\0' && !isdigit(*p); p++);
-            extents = atol(p);
-            log_msg(5, "p='%s' --> extents=%ld", p, extents);
-            p = strstr(command, "-L");
-            if (!p)
-              {
-                log_msg(0, "Fiddlesticks. '%s' returned %d", command, res);
-              }
-            else
-              {
-            if (lvmversion == 2)
-              {
-                *p++ = '-'; *p++ = 'l'; *p++ = ' ';
-                for(q=p; *q!=' '; q++) { *q = ' '; }
-                sprintf(p, "%ld", extents);
-                i = strlen(p);
-                *(p+i) = ' ';
-              }
-            else
-              {
-                p++; p++; p++;
-                for(q=p; *q!=' '; q++) { *(q-1) = ' '; }
-                sprintf(p, "%ld%c", extents, 'm');
-                i = strlen(p);
-                *(p+i) = ' ';
-              }
-                log_msg(5, "Retrying with '%s'", command);
-                res = run_program_and_log_output(command, 5);
-            if (res>0) { res=1; }
-            if (g_fprep) { fprintf(g_fprep, "%s\n", command); }
-                log_msg(0, "%s --> %d", command, res);
-            if (!res)
-              {
-                log_msg(5, "YAY! This time, it succeeded.");
-              }
-              }
-          }
-        if (strstr(command, "vgcreate"))
-          {
-            log_msg(0, "In case you're interested...");
-            run_program_and_log_output(vgscan_sz, 1);
-            run_program_and_log_output(pvscan_sz, 1);
-          }
-                if (res!=0 && !strstr(command, "insmod")) {
-            retval ++;
+        if (res > 0) {
+            res = 1;
+        }
+        if (res && strstr(command, "lvcreate") && vacuum_pack) {
+            res = 0;
+            if (strstr(command, "lvm lvcreate"))
+                lvmversion = 2;
+            log_it("%s... so I'll get creative.", tmp);
+            if (lvmversion == 2) {
+                strcpy(tmp, call_program_and_get_last_line_of_output
+                       ("cat /var/log/mondo-archive.log | tail -n5 | grep Insufficient | tail -n1"));
+            } else {
+                strcpy(tmp, call_program_and_get_last_line_of_output
+                       ("cat /var/log/mondo-archive.log | tail -n5 | grep lvcreate | tail -n1"));
+            }
+            for (p = tmp; *p != '\0' && !isdigit(*p); p++);
+            extents = atol(p);
+            log_msg(5, "p='%s' --> extents=%ld", p, extents);
+            p = strstr(command, "-L");
+            if (!p) {
+                log_msg(0, "Fiddlesticks. '%s' returned %d", command, res);
+            } else {
+                if (lvmversion == 2) {
+                    *p++ = '-';
+                    *p++ = 'l';
+                    *p++ = ' ';
+                    for (q = p; *q != ' '; q++) {
+                        *q = ' ';
+                    }
+                    sprintf(p, "%ld", extents);
+                    i = strlen(p);
+                    *(p + i) = ' ';
+                } else {
+                    p++;
+                    p++;
+                    p++;
+                    for (q = p; *q != ' '; q++) {
+                        *(q - 1) = ' ';
+                    }
+                    sprintf(p, "%ld%c", extents, 'm');
+                    i = strlen(p);
+                    *(p + i) = ' ';
+                }
+                log_msg(5, "Retrying with '%s'", command);
+                res = run_program_and_log_output(command, 5);
+                if (res > 0) {
+                    res = 1;
+                }
+                if (g_fprep) {
+                    fprintf(g_fprep, "%s\n", command);
+                }
+                log_msg(0, "%s --> %d", command, res);
+                if (!res) {
+                    log_msg(5, "YAY! This time, it succeeded.");
+                }
+            }
+        }
+        if (strstr(command, "vgcreate")) {
+            log_msg(0, "In case you're interested...");
+            run_program_and_log_output(vgscan_sz, 1);
+            run_program_and_log_output(pvscan_sz, 1);
+        }
+        if (res != 0 && !strstr(command, "insmod")) {
+            retval++;
         }
         sprintf(tmp, "echo \"%s\" >> /tmp/out.sh", command);
@@ -537 +549 @@
     paranoid_fclose(fin);
     log_msg(1, "Closed i-want-my-lvm. Finished doing funky stuff.");
-end_of_i_want_my_lvm:
+  end_of_i_want_my_lvm:
     paranoid_free(tmp);
     paranoid_free(incoming);
@@ -548 +560 @@
     paranoid_free(vgchange_sz);
     paranoid_free(vgremove_sz);
-//  paranoid_free(do_this_last);
-    system("sync"); system("sync"); system("sync"); 
+//  paranoid_free(do_this_last);
+    system("sync");
+    system("sync");
+    system("sync");
     sleep(1);
-iamhere("ENDING");
-    if (retval>2)
-      {
-        log_msg(1, "%d errors. I'm reporting this.", retval);
-        return(retval);
-      }
-    else
-      {
-        log_msg(1, "Not many errors. Returning 0.");
-        return(0);
-      }
+    iamhere("ENDING");
+    if (retval > 2) {
+        log_msg(1, "%d errors. I'm reporting this.", retval);
+        return (retval);
+    } else {
+        log_msg(1, "Not many errors. Returning 0.");
+        return (0);
+    }
 }
 
@@ -574 +585 @@
  * @return 0 for success, nonzero for failure.
  */
-    int extrapolate_mountlist_to_include_raid_partitions(struct mountlist_itself
-                             *new_mountlist, struct mountlist_itself
-                             *old_mountlist)
+int extrapolate_mountlist_to_include_raid_partitions(struct mountlist_itself
+                                                     *new_mountlist, struct mountlist_itself
+                                                     *old_mountlist)
 {
     /** pointers *********************************************************/
@@ -603 +614 @@
 
 #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
 
@@ -611 +623 @@
         {
             if (!does_file_exist("/etc/raidtab")) {
-                log_to_screen("Cannot find /etc/raidtab - cannot extrapolate the fdisk entries");
+                log_to_screen
+                    ("Cannot find /etc/raidtab - cannot extrapolate the fdisk entries");
                 finish(1);
             }
@@ -619 +632 @@
             }
             for (fgets(incoming, MAX_STR_LEN - 1, fin); !feof(fin)
-                 && !strstr(incoming, old_mountlist->el[lino].device); fgets(incoming, MAX_STR_LEN - 1, fin));
+                 && !strstr(incoming, old_mountlist->el[lino].device);
+                 fgets(incoming, MAX_STR_LEN - 1, fin));
             if (!feof(fin)) {
-                sprintf(tmp, "Investigating %s", old_mountlist->el[lino].device);
+                sprintf(tmp, "Investigating %s",
+                        old_mountlist->el[lino].device);
                 log_it(tmp);
                 for (fgets(incoming, MAX_STR_LEN - 1, fin); !feof(fin)
-                     && !strstr(incoming, "raiddev"); fgets(incoming, MAX_STR_LEN - 1, fin)) {
+                     && !strstr(incoming, "raiddev");
+                     fgets(incoming, MAX_STR_LEN - 1, fin)) {
                     if (strstr(incoming, OSSWAP("device", "drive"))
-                        && !strchr(incoming, '#')) {
-                        for (p = incoming + strlen(incoming); *(p - 1) <= 32; p--);
+                        && !strchr(incoming, '#')) {
+                        for (p = incoming + strlen(incoming);
+                             *(p - 1) <= 32; p--);
                         *p = '\0';
                         for (p--; p > incoming && *(p - 1) > 32; p--);
                         sprintf(tmp, "Extrapolating %s", p);
                         log_it(tmp);
-                        for (j = 0; j < new_mountlist->entries && strcmp(new_mountlist->el[j].device, p);
-                             j++);
+                        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);
-                            strcpy(new_mountlist->el[new_mountlist->entries].mountpoint, "raid");
-                            strcpy(new_mountlist->el[new_mountlist->entries].format, "raid");
-                            new_mountlist->el[new_mountlist->entries].size =
-                                old_mountlist->el[lino].size;
+                            strcpy(new_mountlist->
+                                   el[new_mountlist->entries].device, p);
+                            strcpy(new_mountlist->
+                                   el[new_mountlist->entries].mountpoint,
+                                   "raid");
+                            strcpy(new_mountlist->
+                                   el[new_mountlist->entries].format,
+                                   "raid");
+                            new_mountlist->el[new_mountlist->entries].
+                                size = old_mountlist->el[lino].size;
                             new_mountlist->entries++;
                         } else {
-                            sprintf(tmp, "Not adding %s to mountlist: it's already there", p);
+                            sprintf(tmp,
+                                    "Not adding %s to mountlist: it's already there",
+                                    p);
                             log_it(tmp);
                         }
@@ -650 +676 @@
             paranoid_fclose(fin);
         } else {
-            strcpy(new_mountlist->el[new_mountlist->entries].device, old_mountlist->el[lino].device);
-            strcpy(new_mountlist->el[new_mountlist->entries].mountpoint, old_mountlist->el[lino].mountpoint);
-            strcpy(new_mountlist->el[new_mountlist->entries].format, old_mountlist->el[lino].format);
-            new_mountlist->el[new_mountlist->entries].size = old_mountlist->el[lino].size;
+            strcpy(new_mountlist->el[new_mountlist->entries].device,
+                   old_mountlist->el[lino].device);
+            strcpy(new_mountlist->el[new_mountlist->entries].mountpoint,
+                   old_mountlist->el[lino].mountpoint);
+            strcpy(new_mountlist->el[new_mountlist->entries].format,
+                   old_mountlist->el[lino].format);
+            new_mountlist->el[new_mountlist->entries].size =
+                old_mountlist->el[lino].size;
             new_mountlist->entries++;
         }
@@ -697 +727 @@
         sprintf(tmp, "Not formatting %s (it is a RAID disk)", device);
         log_it(tmp);
-        paranoid_free(program); paranoid_free(tmp);
+        paranoid_free(program);
+        paranoid_free(tmp);
         return (0);
     }
@@ -703 +734 @@
     if (strcmp(format, "swap") == 0) {
         log_it("Not formatting %s - it's swap", device);
-        paranoid_free(program); paranoid_free(tmp);
+        paranoid_free(program);
+        paranoid_free(tmp);
         return (0);
     }
@@ -709 +741 @@
     if (strlen(format) <= 2) {
         sprintf(tmp,
-            "%s has a really small format type ('%s') - this is probably a hexadecimal string, which would suggest the partition is an image --- I shouldn't format it",
-            device, format);
+                "%s has a really small format type ('%s') - this is probably a hexadecimal string, which would suggest the partition is an image --- I shouldn't format it",
+                device, format);
         log_it(tmp);
-        paranoid_free(program); paranoid_free(tmp);
+        paranoid_free(program);
+        paranoid_free(tmp);
         return (0);
     }
@@ -718 +751 @@
         sprintf(tmp, "%s is mounted - cannot format it       ", device);
         log_to_screen(tmp);
-        paranoid_free(program); paranoid_free(tmp);
+        paranoid_free(program);
+        paranoid_free(tmp);
         return (1);
     }
@@ -726 +760 @@
         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.");
+                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);
+                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.");
+                        ("`vinum create /tmp/raidconf.txt' returned errors. Please fix them and re-run mondorestore.");
                     finish(1);
                 }
@@ -742 +779 @@
             FILE *fin;
             char line[MAX_STR_LEN];
-            sprintf(tmp, "Initializing Vinum device %s (this may take a *long* time)", device);
+            sprintf(tmp,
+                    "Initializing Vinum device %s (this may take a *long* time)",
+                    device);
             log_to_screen(tmp);
             /* format raid partition */
             //      sprintf (program, "mkraid --really-force %s", device); --- disabled -- BB, 02/12/2003
             sprintf(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));
+                    "for plex in `vinum lv -r %s | grep '^P' | tr '\t' ' ' | tr -s ' ' | cut -d' ' -f2`; do echo $plex; done > /tmp/plexes",
+                    basename(device));
             system(program);
-            if (g_fprep) { fprintf(g_fprep, "%s\n", program); }
+            if (g_fprep) {
+                fprintf(g_fprep, "%s\n", program);
+            }
             fin = fopen("/tmp/plexes", "r");
             while (fgets(line, MAX_STR_LEN - 1, fin)) {
@@ -762 +803 @@
                 while (1) {
                     sprintf(tmp,
-                        "vinum lp -r %s | grep '^S' | head -1 | tr -s ' ' | cut -d: -f2 | cut -f1 | sed 's/^ //' | sed 's/I //' | sed 's/%%//'",
-                        line);
+                            "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");
                     char status[MAX_STR_LEN / 4];
@@ -788 +829 @@
         log_to_screen("Stopping %s", device);
         stop_raid_device(device);
-        system("sync"); sleep(1);
-        if (g_fprep) { fprintf(g_fprep, "%s\n", program); }
+        system("sync");
+        sleep(1);
+        if (g_fprep) {
+            fprintf(g_fprep, "%s\n", program);
+        }
 
         log_msg(1, "Making %s", device);
@@ -795 +839 @@
         res = run_program_and_log_output(program, 1);
         log_msg(1, "%s returned %d", program, res);
-        system("sync"); sleep(3);
+        system("sync");
+        sleep(3);
         start_raid_device(device);
-        if (g_fprep) { fprintf(g_fprep, "%s\n", program); }
-        system("sync"); sleep(2);
-        
-//      log_to_screen("Starting %s", device);
-//      sprintf(program, "raidstart %s", device);
-//      res = run_program_and_log_output(program, 1);
-//      log_msg(1, "%s returned %d", program, res);
-//      system("sync"); sleep(1);
-        if (g_fprep) { fprintf(g_fprep, "%s\n", program); }
-
-#endif
-        system("sync"); sleep(1);
+        if (g_fprep) {
+            fprintf(g_fprep, "%s\n", program);
+        }
+        system("sync");
+        sleep(2);
+
+//      log_to_screen("Starting %s", device);
+//      sprintf(program, "raidstart %s", device);
+//      res = run_program_and_log_output(program, 1);
+//      log_msg(1, "%s returned %d", program, res);
+//      system("sync"); sleep(1);
+        if (g_fprep) {
+            fprintf(g_fprep, "%s\n", program);
+        }
+#endif
+        system("sync");
+        sleep(1);
         newtResume();
     }
@@ -814 +864 @@
 //#endif
 
-    if (!strcmp(format, "lvm"))
-      {
-        log_msg(1, "Don't format %s - it's part of an lvm volume", device);
-        paranoid_free(program); paranoid_free(tmp);
-        return(0);
-      }
+    if (!strcmp(format, "lvm")) {
+        log_msg(1, "Don't format %s - it's part of an lvm volume", device);
+        paranoid_free(program);
+        paranoid_free(tmp);
+        return (0);
+    }
     res = which_format_command_do_i_need(format, program);
     sprintf(tmp, "%s %s", program, device);
@@ -830 +880 @@
     res = run_program_and_log_output(program, FALSE);
     if (res && strstr(program, "kludge")) {
-        sprintf(tmp, "Kludge failed; using regular mkfs.%s to format %s", format, device);
+        sprintf(tmp, "Kludge failed; using regular mkfs.%s to format %s",
+                format, device);
 #ifdef __FreeBSD__
         sprintf(program, "newfs_msdos -F 32 %s", device);
@@ -837 +888 @@
 #endif
         res = run_program_and_log_output(program, FALSE);
-        if (g_fprep) { fprintf(g_fprep, "%s\n", program); }
+        if (g_fprep) {
+            fprintf(g_fprep, "%s\n", program);
+        }
     }
     retval += res;
@@ -847 +900 @@
 
     log_to_screen(tmp);
-    paranoid_free(program); paranoid_free(tmp);
-    system("sync"); sleep(1);
+    paranoid_free(program);
+    paranoid_free(tmp);
+    system("sync");
+    sleep(1);
     return (retval);
 }
@@ -862 +917 @@
  * @return The number of errors encountered (0 for success).
  */
-int format_everything(struct mountlist_itself *mountlist, bool interactively)
+int format_everything(struct mountlist_itself *mountlist,
+                      bool interactively)
 {
     /** int **************************************************************/
@@ -868 +924 @@
     int lino;
     int res;
-//  int i;
-//  struct list_of_disks *drivelist;
+//  int i;
+//  struct list_of_disks *drivelist;
 
     /** long *************************************************************/
@@ -884 +940 @@
     /** end **************************************************************/
 
-    assert(mountlist!=NULL);
+    assert(mountlist != NULL);
     malloc_string(tmp);
-    sprintf(tmp, "format_everything (mountlist, interactively = %s", (interactively) ? "true" : "false");
+    sprintf(tmp, "format_everything (mountlist, interactively = %s",
+            (interactively) ? "true" : "false");
     log_it(tmp);
     mvaddstr_and_log_it(g_currentY, 0, "Formatting partitions     ");
-    open_progress_form("Formatting partitions", "I am now formatting your hard disk partitions.",
-               "This may take up to five minutes.", "", mountlist->entries + 1);
-
-    progress_step = (mountlist->entries > 0) ? g_maximum_progress / mountlist->entries : 1;
+    open_progress_form("Formatting partitions",
+                       "I am now formatting your hard disk partitions.",
+                       "This may take up to five minutes.", "",
+                       mountlist->entries + 1);
+
+    progress_step =
+        (mountlist->entries >
+         0) ? g_maximum_progress / mountlist->entries : 1;
 // start soft-raids now (because LVM might depend on them)
 // ...and for simplicity's sake, let's format them at the same time :)
     log_msg(1, "Stopping all RAID devices");
     stop_all_raid_devices(mountlist);
-    system("sync"); system("sync"); system("sync"); 
+    system("sync");
+    system("sync");
+    system("sync");
     sleep(2);
-    log_msg(1, "Prepare soft-RAIDs"); // prep and format too
+    log_msg(1, "Prepare soft-RAIDs");   // prep and format too
     for (lino = 0; lino < mountlist->entries; lino++) {
         me = &mountlist->el[lino];  // the current mountlist entry
@@ -906 +969 @@
             if (interactively) {
                 // ask user if we should format the current device
-                sprintf(tmp, "Shall I format %s (%s) ?", me->device, me->mountpoint);
+                sprintf(tmp, "Shall I format %s (%s) ?", me->device,
+                        me->mountpoint);
                 do_it = ask_me_yes_or_no(tmp);
             } else {
@@ -912 +976 @@
             }
             if (do_it) {
-            // NB: format_device() also stops/starts RAID device if necessary
+                // NB: format_device() also stops/starts RAID device if necessary
                 retval += format_device(me->device, me->format);
             }
@@ -918 +982 @@
         }
     }
-    system("sync"); system("sync"); system("sync"); 
+    system("sync");
+    system("sync");
+    system("sync");
     sleep(2);
 // This last step is probably necessary
-//  log_to_screen("Re-starting software RAIDs...");
-//  start_all_raid_devices(mountlist);
-//  system("sync"); system("sync"); system("sync"); 
-//  sleep(5);
+//  log_to_screen("Re-starting software RAIDs...");
+//  start_all_raid_devices(mountlist);
+//  system("sync"); system("sync"); system("sync"); 
+//  sleep(5);
 // do LVMs now
     log_msg(1, "Creating LVMs");
@@ -930 +996 @@
         wait_until_software_raids_are_prepped("/proc/mdstat", 10);
         log_to_screen("Configuring LVM");
-                if (!g_text_mode) { newtSuspend(); }
+        if (!g_text_mode) {
+            newtSuspend();
+        }
 /*
         for(i=0; i<3; i++)
@@ -943 +1011 @@
             log_msg(1, "Vacuum-packing...");
 */
-            res = do_my_funky_lvm_stuff(FALSE, TRUE);
+        res = do_my_funky_lvm_stuff(FALSE, TRUE);
 /*
         }
 */
-                if (!g_text_mode) { newtResume(); }
-        if (!res) { log_to_screen("LVM initialized OK"); }
-        else { log_to_screen("Failed to initialize LVM"); }
+        if (!g_text_mode) {
+            newtResume();
+        }
+        if (!res) {
+            log_to_screen("LVM initialized OK");
+        } else {
+            log_to_screen("Failed to initialize LVM");
+        }
         // retval += res;
         if (res) {
-            retval ++;
-        }
-        sleep(3);
-    }
-
+            retval++;
+        }
+        sleep(3);
+    }
 // do regulars at last
-    sleep(2); // woo!
-        log_msg(1, "Formatting regulars");
+    sleep(2);                   // woo!
+    log_msg(1, "Formatting regulars");
     for (lino = 0; lino < mountlist->entries; lino++) {
         me = &mountlist->el[lino];  // the current mountlist entry
@@ -966 +1038 @@
             log_it(tmp);
         } else if (!strcmp(me->format, "raid")) {
-            sprintf(tmp, "Not formatting %s - it's a raid-let", me->device);
+            sprintf(tmp, "Not formatting %s - it's a raid-let",
+                    me->device);
             log_it(tmp);
             continue;
@@ -974 +1047 @@
             continue;
         } else if (!strncmp(me->device, "/dev/md", 7)) {
-            sprintf(tmp, "Already formatted %s - it's a soft-RAID dev", me->device);
+            sprintf(tmp, "Already formatted %s - it's a soft-RAID dev",
+                    me->device);
             log_it(tmp);
             continue;
         } else if (!does_file_exist(me->device)
-                    && strncmp(me->device, "/dev/hd", 7)
-                    && strncmp(me->device, "/dev/sd", 7)) {
-            sprintf(tmp, "Not formatting %s yet - doesn't exist - probably an LVM", me->device);
+                   && strncmp(me->device, "/dev/hd", 7)
+                   && strncmp(me->device, "/dev/sd", 7)) {
+            sprintf(tmp,
+                    "Not formatting %s yet - doesn't exist - probably an LVM",
+                    me->device);
             log_it(tmp);
             continue;
@@ -986 +1062 @@
             if (interactively) {
                 // ask user if we should format the current device
-                sprintf(tmp, "Shall I format %s (%s) ?", me->device, me->mountpoint);
+                sprintf(tmp, "Shall I format %s (%s) ?", me->device,
+                        me->mountpoint);
                 do_it = ask_me_yes_or_no(tmp);
             } else {
@@ -1010 +1087 @@
     if (retval) {
         mvaddstr_and_log_it(g_currentY++, 74, "Failed.");
-        log_to_screen("Errors occurred during the formatting of your hard drives.");
+        log_to_screen
+            ("Errors occurred during the formatting of your hard drives.");
     } else {
         mvaddstr_and_log_it(g_currentY++, 74, "Done.");
     }
 
-    sprintf(tmp, "format_everything () - %s", (retval) ? "failed!" : "finished successfully");
+    sprintf(tmp, "format_everything () - %s",
+            (retval) ? "failed!" : "finished successfully");
     log_it(tmp);
 
-    if (g_partition_table_locked_up > 0)
-      {
-        if (retval > 0 && !interactively)
-              {
+    if (g_partition_table_locked_up > 0) {
+        if (retval > 0 && !interactively) {
 //123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 
-                log_to_screen(
-  "Partition table locked up %d times. At least one 'mkfs' (format) command", g_partition_table_locked_up);
-                log_to_screen(
-  "failed. I think these two events are related. Sometimes, fdisk's ioctl() call");
-                log_to_screen(
-  "to refresh its copy of the partition table causes the kernel to lock the ");
-                log_to_screen(
-  "partition table. I believe this has just happened.");
-                if (ask_me_yes_or_no("Please choose 'yes' to reboot and try again; or 'no' to ignore this warning and continue."))
-                  {
-            system("sync");
-            system("sync");
-            system("sync");
-            system("reboot"); 
-          }
-          }
-        else
-          {
-            log_to_screen(
-"Partition table locked up %d time%c. However, disk formatting succeeded.", g_partition_table_locked_up, (g_partition_table_locked_up==1)?'.':'s');
-          }
-      }
-        newtSuspend();
+            log_to_screen
+                ("Partition table locked up %d times. At least one 'mkfs' (format) command",
+                 g_partition_table_locked_up);
+            log_to_screen
+                ("failed. I think these two events are related. Sometimes, fdisk's ioctl() call");
+            log_to_screen
+                ("to refresh its copy of the partition table causes the kernel to lock the ");
+            log_to_screen
+                ("partition table. I believe this has just happened.");
+            if (ask_me_yes_or_no
+                ("Please choose 'yes' to reboot and try again; or 'no' to ignore this warning and continue."))
+            {
+                system("sync");
+                system("sync");
+                system("sync");
+                system("reboot");
+            }
+        } else {
+            log_to_screen
+                ("Partition table locked up %d time%c. However, disk formatting succeeded.",
+                 g_partition_table_locked_up,
+                 (g_partition_table_locked_up == 1) ? '.' : 's');
+        }
+    }
+    newtSuspend();
     system("clear");
     newtResume();
@@ -1061 +1140 @@
  * @return The number of errors encountered (0 for success).
  */
-int make_dummy_partitions(FILE*pout_to_fdisk, char *drivename, int devno_we_must_allow_for)
+int make_dummy_partitions(FILE * pout_to_fdisk, char *drivename,
+                          int devno_we_must_allow_for)
 {
     /** int **************************************************************/
@@ -1081 +1161 @@
         log_it(tmp);
         g_maximum_progress++;
-        res = partition_device(pout_to_fdisk,drivename, 1, 0, "ext2", 32000);
+        res =
+            partition_device(pout_to_fdisk, drivename, 1, 0, "ext2",
+                             32000);
         retval += res;
         previous_devno = 1;
@@ -1090 +1172 @@
     }
     for (; current_devno < devno_we_must_allow_for; current_devno++) {
-        sprintf(tmp, "Creating dummy partition %s%d", drivename, current_devno);
+        sprintf(tmp, "Creating dummy partition %s%d", drivename,
+                current_devno);
         log_it(tmp);
         g_maximum_progress++;
-        res = partition_device(pout_to_fdisk,drivename, current_devno, previous_devno, OSSWAP("ext2", "ufs"), 32000);
+        res =
+            partition_device(pout_to_fdisk, drivename, current_devno,
+                             previous_devno, OSSWAP("ext2", "ufs"), 32000);
         retval += res;
         previous_devno = current_devno;
@@ -1141 +1226 @@
     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, "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)
@@ -1161 +1248 @@
     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, "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--)
@@ -1172 +1261 @@
         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");
+    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);
+            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]);
@@ -1184 +1275 @@
 
             case FS_UNUSED: /* XXX */
-                fprintf(f, "    %5lu %5lu %5.5s ", (u_long) pp->p_fsize, (u_long) (pp->p_fsize * pp->p_frag), "");
+                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);
+                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);
+                fprintf(f, "    %5lu %5lu %5d", (u_long) pp->p_fsize,
+                        (u_long) (pp->p_fsize * pp->p_frag), pp->p_cpg);
                 break;
 
@@ -1201 +1293 @@
                 break;
             }
-            fprintf(f, "\t# (Cyl. %4lu", (u_long) (pp->p_offset / lp->d_secpercyl));
+            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));
+            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);
@@ -1232 +1328 @@
     /* New world order */
     if ((ioctl(f, DIOCGMEDIASIZE, &mediasize) != 0)
-        || (ioctl(f, DIOCGSECTORSIZE, &secsize) != 0)) {
+        || (ioctl(f, DIOCGSECTORSIZE, &secsize) != 0)) {
         close(f);
         return (NULL);
@@ -1276 +1372 @@
     return (&loclab);
 }
+
 /* End stolen from /usr/src/sbin/disklabel/disklabel.c. */
 
@@ -1295 +1392 @@
  * @return The number of errors encountered (0 for success).
  */
-int label_drive_or_slice(struct mountlist_itself *mountlist, char *drivename, struct disklabel *ret)
+int label_drive_or_slice(struct mountlist_itself *mountlist,
+                         char *drivename, struct disklabel *ret)
 {
     char subdev_str[MAX_STR_LEN];
@@ -1319 +1417 @@
             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")) {
+                || !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;
@@ -1326 +1424 @@
                 lp->d_partitions[c - 'a'].p_cpg = 64;
             } else if (!strcasecmp(mountlist->el[idx].format, "raid")
-                   || !strcasecmp(mountlist->el[idx].format, "vinum")) {
+                       || !strcasecmp(mountlist->el[idx].format, "vinum")) {
                 lp->d_partitions[c - 'a'].p_fstype = FS_VINUM;
             } else if (!strcmp(mountlist->el[idx].format, "swap")) {
@@ -1347 +1445 @@
         for (lastone = i - 1; lastone >= 0; lastone--) {
             if ((lp->d_partitions[lastone].p_size)
-                && (lastone != RAW_PART))
+                && (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;
+        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;
     }
 
@@ -1361 +1463 @@
     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));
+    sprintf(command, "disklabel -R %s /tmp/disklabel",
+            canonical_name(drivename));
     retval += run_program_and_log_output(command, TRUE);
     if (ret)
@@ -1384 +1487 @@
     int retval = 0;
     int i;
-    FILE*pout_to_fdisk=NULL;
-    
+    FILE *pout_to_fdisk = NULL;
+
 #ifdef __FreeBSD__
     bool fbsd_part = FALSE;
@@ -1407 +1510 @@
     malloc_string(format);
     malloc_string(tmp);
-    
+
     sprintf(tmp, "Partitioning drive %s", drivename);
     log_it(tmp);
 
-#if __FreeBSD__ 
-        log_it("(Not opening fdisk now; that's the Linux guy's job)");
+#if __FreeBSD__
+    log_it("(Not opening fdisk now; that's the Linux guy's job)");
     pout_to_fdisk = NULL;
 #else
     make_hole_for_file(FDISK_LOG);
 #ifdef __IA64__
-    sprintf(tmp, "parted2fdisk %s >> %s 2>> %s", drivename, FDISK_LOG, FDISK_LOG);
+    sprintf(tmp, "parted2fdisk %s >> %s 2>> %s", drivename, FDISK_LOG,
+            FDISK_LOG);
 #else
     sprintf(tmp, "fdisk %s >> %s 2>> %s", drivename, FDISK_LOG, FDISK_LOG);
 #endif
     pout_to_fdisk = popen(tmp, "w");
-    if (!pout_to_fdisk) { 
-        log_to_screen("Cannot call fdisk to configure %s", drivename); 
+    if (!pout_to_fdisk) {
+        log_to_screen("Cannot call fdisk to configure %s", drivename);
         paranoid_free(device_str);
         paranoid_free(format);
         paranoid_free(tmp);
-        return(1); 
+        return (1);
     }
 #endif
@@ -1445 +1549 @@
                 for (c = 'a'; c <= 'z'; c++) {
                     sprintf(subdev_str, "%s%c", drivename, c);
-                    if (find_device_in_mountlist(mountlist, subdev_str) > 0) {
+                    if (find_device_in_mountlist(mountlist, subdev_str) >
+                        0) {
                         fbsd_part = TRUE;
                     }
@@ -1451 +1556 @@
                 if (fbsd_part) {
                     int r = label_drive_or_slice(mountlist,
-                                     drivename,
-                                     0);
+                                                 drivename,
+                                                 0);
                     char command[MAX_STR_LEN];
-                    sprintf(command, "disklabel -B %s", basename(drivename));
+                    sprintf(command, "disklabel -B %s",
+                            basename(drivename));
                     if (system(command)) {
-                        log_to_screen("Warning! Unable to make the drive bootable.");
+                        log_to_screen
+                            ("Warning! Unable to make the drive bootable.");
                     }
                     paranoid_free(device_str);
@@ -1501 +1608 @@
 #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)) {
+//          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) {
-                sprintf(tmp, "Warning - unable to open %s for wiping it's partition table", drivename);
+                sprintf(tmp,
+                        "Warning - unable to open %s for wiping it's partition table",
+                        drivename);
                 log_to_screen(tmp);
             }
 
-            for (i=0; i<512; i++) {
-                if ( !write(file, "\0", 1) ) {
-                    sprintf(tmp, "Warning - unable to write to %s", 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);
                 }
@@ -1518 +1628 @@
 #else
             iamhere("New, kernel-friendly partition remover");
-            for(i=20;i>0;i--)
-              {
-                fprintf(pout_to_fdisk, "d\n%d\n", i);
-                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  
+            for (i = 20; i > 0; i--) {
+                fprintf(pout_to_fdisk, "d\n%d\n", i);
+                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);
+                previous_devno =
+                    make_dummy_partitions(pout_to_fdisk, drivename,
+                                          current_devno);
             }
         }
@@ -1534 +1645 @@
 #endif
 
-        strcpy(format, mountlist->el[lino].format);
-        partsize = mountlist->el[lino].size;
+            strcpy(format, mountlist->el[lino].format);
+            partsize = mountlist->el[lino].size;
 
 #ifdef __FreeBSD__
@@ -1542 +1653 @@
 
         if (current_devno == 5 && previous_devno == 4) {
-            log_to_screen("You must leave at least one partition spare as the Extended partition.");
+            log_to_screen
+                ("You must leave at least one partition spare as the Extended partition.");
             paranoid_free(device_str);
             paranoid_free(format);
@@ -1549 +1661 @@
         }
 
-        retval += partition_device(pout_to_fdisk, drivename, current_devno, previous_devno, format, partsize);
+        retval +=
+            partition_device(pout_to_fdisk, drivename, current_devno,
+                             previous_devno, format, partsize);
 
 #ifdef __FreeBSD__
@@ -1556 +1670 @@
             retval += label_drive_or_slice(mountlist, device_str, 0);
             if (system(tmp)) {
-                log_to_screen("Warning! Unable to make the slice bootable.");
+                log_to_screen
+                    ("Warning! Unable to make the slice bootable.");
             }
         }
@@ -1564 +1679 @@
     }
 
-    if (pout_to_fdisk)
-    {
+    if (pout_to_fdisk) {
 // mark relevant partition as bootable
-        sprintf(tmp, "a\n%s\n", call_program_and_get_last_line_of_output("make-me-bootable /tmp/mountlist.txt dummy"));
+        sprintf(tmp, "a\n%s\n",
+                call_program_and_get_last_line_of_output
+                ("make-me-bootable /tmp/mountlist.txt dummy"));
         fput_string_one_char_at_a_time(pout_to_fdisk, tmp);
 // close fdisk
         fput_string_one_char_at_a_time(pout_to_fdisk, "w\n");
         system("sync");
-        paranoid_pclose(pout_to_fdisk); 
-        log_msg(0, "------------------- fdisk.log looks like this ------------------");
+        paranoid_pclose(pout_to_fdisk);
+        log_msg(0,
+                "------------------- fdisk.log looks like this ------------------");
         sprintf(tmp, "cat %s >> %s", FDISK_LOG, MONDO_LOGFILE);
         system(tmp);
-        log_msg(0, "------------------- end of fdisk.log... word! ------------------");
+        log_msg(0,
+                "------------------- end of fdisk.log... word! ------------------");
         sprintf(tmp, "tail -n6 %s | fgrep \"16: \"", FDISK_LOG);
-        if (!run_program_and_log_output(tmp, 5))
-          {
-            g_partition_table_locked_up++;
-            log_to_screen("A flaw in the Linux kernel has locked the partition table.");
-          }
+        if (!run_program_and_log_output(tmp, 5)) {
+            g_partition_table_locked_up++;
+            log_to_screen
+                ("A flaw in the Linux kernel has locked the partition table.");
+        }
     }
     paranoid_free(device_str);
@@ -1599 +1717 @@
  * @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 partition_device(FILE * pout_to_fdisk, const char *drive, int partno,
+                     int prev_partno, const char *format,
+                     long long partsize)
 {
     /** int **************************************************************/
@@ -1624 +1744 @@
     malloc_string(logfile);
     malloc_string(output);
-    
+
     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);
+    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))) {
@@ -1644 +1765 @@
         sprintf(tmp, "Partitioning device %s (max size)", partition_name);
     } else {
-        sprintf(tmp, "Partitioning device %s (%lld MB)", partition_name, (long long) partsize / 1024);
+        sprintf(tmp, "Partitioning device %s (%lld MB)", partition_name,
+                (long long) partsize / 1024);
     }
     update_progress_form(tmp);
@@ -1650 +1772 @@
 
     if (is_this_device_mounted(partition_name)) {
-        sprintf(tmp, "%s is mounted, and should not be partitioned", partition_name);
+        sprintf(tmp, "%s is mounted, and should not be partitioned",
+                partition_name);
         log_to_screen(tmp);
         paranoid_free(program);
@@ -1671 +1794 @@
     p = (char *) strrchr(partition_name, '/');
     sprintf(logfile, "/tmp/fdisk.log.%s", ++p);
-    sprintf(program, "parted2fdisk %s >> %s 2>> %s", drive, MONDO_LOGFILE, MONDO_LOGFILE);
+    sprintf(program, "parted2fdisk %s >> %s 2>> %s", drive, MONDO_LOGFILE,
+            MONDO_LOGFILE);
 
     output[0] = '\0';
@@ -1681 +1805 @@
             part_table_fmt = which_partition_format(drive);
             /* GPT allows more than 4 primary partitions */
-            if ((prev_partno >= 4) && (strcmp(part_table_fmt,"MBR") == 0)) {
-                log_to_screen("You need to leave at least one partition free, for 'extended/logical'");
+            if ((prev_partno >= 4) && (strcmp(part_table_fmt, "MBR") == 0)) {
+                log_to_screen
+                    ("You need to leave at least one partition free, for 'extended/logical'");
                 paranoid_free(program);
                 paranoid_free(partition_name);
@@ -1690 +1815 @@
                 return (1);
             } else {
-                sprintf(output + strlen(output), "n\ne\n%d\n\n\n", prev_partno + 1);
+                sprintf(output + strlen(output), "n\ne\n%d\n\n\n",
+                        prev_partno + 1);
             }
         }
@@ -1697 +1823 @@
     strcat(output + strlen(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; }
+        if (!strcmp(format, "7")) {
+            log_msg(1, "Adding 512K, just in case");
+            partsize += 512;
+        }
         sprintf(output + strlen(output), "+%lldK", (long long) (partsize));
     }
@@ -1714 +1843 @@
 
 
-    if (pout_to_fdisk)
-    {
+    if (pout_to_fdisk) {
         log_msg(1, "Doing the new all-in-one fdisk thing");
         log_msg(1, "output = '%s'", output);
@@ -1721 +1849 @@
         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 "))
-        {
+        if (strstr(tmp, " (m ")) {
             log_msg(1, "Successfully created %s%d", drive, partno);
-        }
-        else
-        {
+        } else {
             log_msg(1, "last line = %s", tmp);
-            log_msg(1, "Failed to create %s%d; sending 'Enter'...", drive, partno);
-        }
-        if (!retval)
-        {
-            log_msg(1, "Trying to set %s%d's partition type now", drive, partno);
-            retval = set_partition_type(pout_to_fdisk, drive, partno, format, partsize);
-            if (retval)
-            {
+            log_msg(1, "Failed to create %s%d; sending 'Enter'...", drive,
+                    partno);
+        }
+        if (!retval) {
+            log_msg(1, "Trying to set %s%d's partition type now", drive,
+                    partno);
+            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
-    {
+                retval =
+                    set_partition_type(pout_to_fdisk, drive, partno,
+                                       format, partsize);
+            }
+        }
+        if (retval) {
+            log_msg(1, "...but failed to set type");
+        }
+    } else {
         strcat(output, "w\n\n");
-            if (g_fprep) { fprintf(g_fprep, "echo \"%s\" | %s\n", output, program); }
+        if (g_fprep) {
+            fprintf(g_fprep, "echo \"%s\" | %s\n", output, program);
+        }
         /* write to disk; close fdisk's stream */
         if (!(fout = popen(program, "w"))) {
@@ -1756 +1887 @@
             log_it("Vaccum-packing");
             g_current_progress--;
-            res = partition_device(pout_to_fdisk, drive, partno, prev_partno, format, -1);
+            res =
+                partition_device(pout_to_fdisk, drive, partno, prev_partno,
+                                 format, -1);
             if (res) {
                 sprintf(tmp, "Failed to vacuum-pack %s", partition_name);
@@ -1766 +1899 @@
         }
         if (does_partition_exist(drive, partno)) {
-            retval = set_partition_type(pout_to_fdisk, drive, partno, format, partsize);
+            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);
+                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);
+                    sprintf(tmp, "Partition %s created+configured OK",
+                            partition_name);
                     log_to_screen(tmp);
                 } else {
@@ -1778 +1915 @@
                 }
             }
-            } else {
+        } else {
             sprintf(tmp, "Failed to partition %s", partition_name);
             if (partsize > 0) {
@@ -1830 +1967 @@
         /*      mountlist=&new_mtlist; */
         /*      extrapolate_mountlist_to_include_raid_partitions(mountlist,orig_mtlist); */
-        log_msg(0,"Mountlist, including the partitions incorporated in RAID devices:-");
+        log_msg(0,
+                "Mountlist, including the partitions incorporated in RAID devices:-");
         for (i = 0; i < mountlist->entries; i++) {
             log_it(mountlist->el[i].device);
@@ -1837 +1975 @@
     }
     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(); }
+    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"))
@@ -1851 +1993 @@
 */
 
-    open_progress_form("Partitioning devices", "I am now going to partition all your drives.",
-               "This should not take more than five minutes.", "", mountlist->entries);
+    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);
@@ -1864 +2008 @@
     if (retval) {
         mvaddstr_and_log_it(g_currentY++, 74, "Failed.");
-        log_to_screen("Errors occurred during the partitioning of your hard drives.");
+        log_to_screen
+            ("Errors occurred during the partitioning of your hard drives.");
     } else {
         mvaddstr_and_log_it(g_currentY++, 74, "Done.");
@@ -1890 +2035 @@
  * @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)
+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;
-  char *tmp;
-  char *partcode;
-  char *logfile;
+    char *partition;
+    char *command;
+    char *output;
+    char *tmp;
+    char *partcode;
+    char *logfile;
 
     /** pointers *********************************************************/
@@ -1912 +2058 @@
     assert(format != NULL);
 
-  malloc_string(partition);
-  malloc_string(command);
-  malloc_string(output);
-  malloc_string(tmp);
-  malloc_string(partcode);
-  malloc_string(logfile);
+    malloc_string(partition);
+    malloc_string(command);
+    malloc_string(output);
+    malloc_string(tmp);
+    malloc_string(partcode);
+    malloc_string(logfile);
 
     build_partition_name(partition, drive, partno);
@@ -1930 +2076 @@
             strcpy(partcode, "b");
         }
-    } else if (strcmp(format, "ext2") == 0 || strcmp(format, "reiserfs") == 0 || strcmp(format, "ext3") == 0
-           || strcmp(format, "xfs") == 0 || strcmp(format, "jfs") == 0) {
+    } else if (strcmp(format, "ext2") == 0
+               || strcmp(format, "reiserfs") == 0
+               || strcmp(format, "ext3") == 0 || strcmp(format, "xfs") == 0
+               || strcmp(format, "jfs") == 0) {
         strcpy(partcode, "83");
     } else if (strcmp(format, "minix") == 0) {
@@ -1938 +2086 @@
         strcpy(partcode, "fd");
     } else if ((strcmp(format, "ufs") == 0)
-           || (strcmp(format, "ffs") == 0)) {   /* raid autodetect */
+               || (strcmp(format, "ffs") == 0)) {   /* raid autodetect */
         strcpy(partcode, "a5");
     } else if (strcmp(format, "lvm") == 0) {
@@ -1948 +2096 @@
     } else {
         /* probably an image */
-        sprintf(tmp, "Unknown format ('%s') - using supplied string anyway", format);
+        sprintf(tmp,
+                "Unknown format ('%s') - using supplied string anyway",
+                format);
         mvaddstr_and_log_it(g_currentY++, 0, tmp);
 #ifdef __FreeBSD__
-        strcpy(partcode, format); // was a5
+        strcpy(partcode, format);   // was a5
 #else
-        strcpy(partcode, format); // was 83
-#endif
-    }
-    sprintf(tmp, "Setting %s's type to %s (%s)", partition, format, partcode);
+        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)
-        {
+
+        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)"))
-            {
+            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));
-            }
-            
+                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));
+            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));
-            
+            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
-        {
+            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 {
             sprintf(output, "t\n%d\n%s\n", partno, partcode);
             strcat(output, "w\n");
-            sprintf(command, "parted2fdisk %s >> %s 2>> %s", drive, MONDO_LOGFILE, MONDO_LOGFILE);
+            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);
@@ -2005 +2156 @@
             }
         }
-    if (res)
-      {
-        log_OS_error(command);
-      } 
-    }
-
-  paranoid_free(partition);
-  paranoid_free(command);
-  paranoid_free(output);
-  paranoid_free(tmp);
-  paranoid_free(partcode);
-  paranoid_free(logfile);
-
-  return (res);
+        if (res) {
+            log_OS_error(command);
+        }
+    }
+
+    paranoid_free(partition);
+    paranoid_free(command);
+    paranoid_free(output);
+    paranoid_free(tmp);
+    paranoid_free(partcode);
+    paranoid_free(logfile);
+
+    return (res);
 }
 
@@ -2035 +2185 @@
     assert_string_is_neither_NULL_nor_zerolength(raid_device);
     malloc_string(program);
-    
+
 #ifdef __FreeBSD__
     if (is_this_device_mounted(raid_device)) {
@@ -2048 +2198 @@
     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); }
+    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);
@@ -2075 +2230 @@
     assert_string_is_neither_NULL_nor_zerolength(raid_device);
     malloc_string(program);
-    
+
 #ifdef __FreeBSD__
     if (is_this_device_mounted(raid_device)) {
@@ -2088 +2243 @@
     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); }
+    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);
@@ -2098 +2257 @@
 {
     int i;
-    int retval=0;
+    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);
+
+    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);
 }
 
@@ -2149 +2311 @@
     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");
+        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(dev);
@@ -2155 +2320 @@
             return (1);
         }
-        for (fgets(incoming, MAX_STR_LEN - 1, fin); !feof(fin); fgets(incoming, MAX_STR_LEN - 1, fin)) {
+        for (fgets(incoming, MAX_STR_LEN - 1, fin); !feof(fin);
+             fgets(incoming, MAX_STR_LEN - 1, fin)) {
             retval += stop_raid_device(incoming);
         }
@@ -2166 +2332 @@
             return (1);
         }
-        for (fgets(incoming, MAX_STR_LEN - 1, fin); !feof(fin); fgets(incoming, MAX_STR_LEN - 1, fin)) {
-            for (p = incoming; *p != '\0' && (*p != 'm' || *(p + 1) != 'd' || !isdigit(*(p + 2))); p++);
+        for (fgets(incoming, MAX_STR_LEN - 1, fin); !feof(fin);
+             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);
@@ -2178 +2347 @@
     }
     paranoid_fclose(fin);
-    if (retval) { log_msg(1, "Warning - unable to stop some RAID devices"); }
+    if (retval) {
+        log_msg(1, "Warning - unable to stop some RAID devices");
+    }
     paranoid_free(dev);
     paranoid_free(incoming);
-    system("sync"); system("sync"); system("sync"); 
+    system("sync");
+    system("sync");
+    system("sync");
     sleep(1);
     return (retval);
@@ -2236 +2409 @@
         sprintf(program, "mkfs -t %s -c", format);  // -c checks for bad blocks
 #endif
-        sprintf(tmp, "Unknown format (%s) - assuming '%s' will do", format, program);
+        sprintf(tmp, "Unknown format (%s) - assuming '%s' will do", format,
+                program);
         log_it(tmp);
         res = 0;
@@ -2253 +2427 @@
  */
 long calc_orig_size_of_drive_from_mountlist(struct mountlist_itself
-                        *mountlist, char *drive_name)
+                                            *mountlist, char *drive_name)
 {
     /** long ************************************************************/
@@ -2270 +2444 @@
     assert_string_is_neither_NULL_nor_zerolength(drive_name);
 
-    for (original_size_of_drive = 0, partno = 0; partno < mountlist->entries; partno++) {
-        if (strncmp(mountlist->el[partno].device, drive_name, strlen(drive_name)) == 0) {
+    for (original_size_of_drive = 0, partno = 0;
+         partno < mountlist->entries; partno++) {
+        if (strncmp
+            (mountlist->el[partno].device, drive_name,
+             strlen(drive_name)) == 0) {
             original_size_of_drive += mountlist->el[partno].size;
         } else {
@@ -2296 +2473 @@
  */
 void resize_drive_proportionately_to_suit_new_drives(struct mountlist_itself
-                             *mountlist, char *drive_name)
+                                                     *mountlist,
+                                                     char *drive_name)
 {
     /**buffers **********************************************************/
@@ -2303 +2481 @@
     /** int *************************************************************/
     int partno, lastpart;
-               /** remove driveno, noof_drives stan benoit apr 2002**/
+               /** remove driveno, noof_drives stan benoit apr 2002**/
 
     /** float ***********************************************************/
     float factor;
     float new_size;
-//  float newcylinderno;
+//  float newcylinderno;
 
     /** long *************************************************************/
@@ -2314 +2492 @@
     long current_size_of_drive = 0;
     long original_size_of_drive = 0;
-    long final_size;    /* all in Megabytes */
+    long final_size;            /* all in Megabytes */
     struct mountlist_reference *drivemntlist;
 
@@ -2326 +2504 @@
 
     if (strlen(drive_name) >= strlen(RAID_DEVICE_STUB)) {
-        if (strncmp(drive_name, RAID_DEVICE_STUB, strlen(RAID_DEVICE_STUB)) == 0) {
+        if (strncmp(drive_name, RAID_DEVICE_STUB, strlen(RAID_DEVICE_STUB))
+            == 0) {
             paranoid_free(tmp);
             return;
@@ -2338 +2517 @@
 
     current_size_of_drive = get_phys_size_of_drive(drive_name);
-    
+
     if (current_size_of_drive <= 0) {
         log_it("Not resizing to match %s - can't find drive", drive_name);
@@ -2344 +2523 @@
         return;
     }
-    sprintf(tmp, "Expanding entries to suit drive %s (%ld MB)", drive_name, current_size_of_drive);
+    sprintf(tmp, "Expanding entries to suit drive %s (%ld MB)", drive_name,
+            current_size_of_drive);
     log_to_screen(tmp);
 
-    drivemntlist = malloc(sizeof (struct mountlist_reference));
-    drivemntlist->el = malloc(sizeof(struct mountlist_line *) * MAX_TAPECATALOG_ENTRIES);
+    drivemntlist = malloc(sizeof(struct mountlist_reference));
+    drivemntlist->el =
+        malloc(sizeof(struct mountlist_line *) * MAX_TAPECATALOG_ENTRIES);
 
     if (!drivemntlist) {
@@ -2361 +2542 @@
 
     if (original_size_of_drive <= 0) {
-        sprintf(tmp, "Cannot resize %s's entries. Drive not found.", drive_name);
+        sprintf(tmp, "Cannot resize %s's entries. Drive not found.",
+                drive_name);
         log_to_screen(tmp);
         paranoid_free(tmp);
         return;
     }
-    factor = (float) (current_size_of_drive) / (float) (original_size_of_drive);
-    sprintf(tmp, "Disk %s was %ld MB; is now %ld MB; factor = %f", drive_name, original_size_of_drive, current_size_of_drive,
-        factor);
+    factor =
+        (float) (current_size_of_drive) / (float) (original_size_of_drive);
+    sprintf(tmp, "Disk %s was %ld MB; is now %ld MB; factor = %f",
+            drive_name, original_size_of_drive, current_size_of_drive,
+            factor);
     log_to_screen(tmp);
 
-    lastpart = drivemntlist->entries-1;
+    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) ) {
+        if (!atoi(drivemntlist->el[partno]->format)) {
             new_size = (float) (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 = (long) new_size; // It looks wrong but it's not
+                    drivemntlist->el[partno]->device,
+                    drivemntlist->el[partno]->mountpoint);
+            newsizL = (long) new_size;  // It looks wrong but it's not
         } else {
             newsizL = (long) new_size;
         }
-        sprintf(tmp, "Changing %s from %lld KB to %ld KB", drivemntlist->el[partno]->device, drivemntlist->el[partno]->size,newsizL);
+        sprintf(tmp, "Changing %s from %lld KB to %ld KB",
+                drivemntlist->el[partno]->device,
+                drivemntlist->el[partno]->size, newsizL);
         log_to_screen(tmp);
         drivemntlist->el[partno]->size = newsizL;
@@ -2406 +2592 @@
  */
 void resize_mountlist_proportionately_to_suit_new_drives(struct mountlist_itself
-                             *mountlist)
+                                                         *mountlist)
 {
     /** buffers *********************************************************/
@@ -2420 +2606 @@
 
     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
+            ("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");
     }
     iamhere("Resizing mountlist");
@@ -2428 +2615 @@
     iamhere("Back from MLoDiM");
     for (driveno = 0; driveno < drivelist->entries; driveno++) {
-        resize_drive_proportionately_to_suit_new_drives(mountlist, drivelist->el[driveno].device);
+        resize_drive_proportionately_to_suit_new_drives(mountlist,
+                                                        drivelist->
+                                                        el[driveno].
+                                                        device);
     }
     log_to_screen("Mountlist adjusted to suit current hard drive(s)");
@@ -2442 +2632 @@
  * @author Ralph Grewe
  */
-void create_mountlist_for_drive(struct mountlist_itself *mountlist, char *drive_name, struct mountlist_reference *drivemntlist) {
+void create_mountlist_for_drive(struct mountlist_itself *mountlist,
+                                char *drive_name,
+                                struct mountlist_reference *drivemntlist)
+{
     int partno;
     char *tmp_drive_name, *c;
@@ -2450 +2643 @@
     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");
-    
+    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;
+    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];
+        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);
+        free(tmp_drive_name);
 }