Changeset 561 in MondoRescue for trunk/mondo/mondo/mondorestore

Timestamp:

May 20, 2006, 5:51:21 PM (18 years ago)

Author:

bcornec

Message:

merge -r 542:560 $SVN_M/branches/stable

Location:

trunk/mondo/mondo/mondorestore

Files:

• mondo-prep.c (modified) (9 diffs)
• mondo-restore.c (modified) (5 diffs)
• mondo-rstr-tools.c (modified) (3 diffs)
• mondoprep.h (modified) (2 diffs)
• mr-externs.h (modified) (1 diff)

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

@@ -695 +695 @@
 
 /**
+ * Create @p RAID device using information from @p structure.
+ * This will create the specified RAID devive using information provided in
+ * raidlist by means of the mdadm tool.
+ * @param raidlist The structure containing all RAID information
+ * @param device The RAID device to create.
+ * @return 0 for success, nonzero for failure.
+ */
+int create_raid_device_via_mdadm(struct raidlist_itself *raidlist, char *device)
+{
+  /** int **************************************************************/
+  int i   = 0;
+  int j   = 0;
+  int res = 0;
+  
+  /** buffers ***********************************************************/
+  char *devices = NULL;
+  char *strtmp  = NULL;
+  char *level   = NULL;
+  char *program = NULL;
+  
+  // leave straight away if raidlist is initial or has no entries
+  if (!raidlist || raidlist->entries == 0) {
+    log_msg(1, "No RAID arrays found.");
+    return 1;
+  } else {
+    log_msg(1, "%d RAID arrays found.", raidlist->entries);
+  }
+  // find raidlist entry for requested device
+  for (i = 0; i < raidlist->entries; i++) {
+    if (!strcmp(raidlist->el[i].raid_device, device)) break;
+  }
+  // check whether RAID device was found in raidlist
+  if (i == raidlist->entries) {
+    log_msg(1, "RAID device %s not found in list.", device);
+    return 1;
+  }
+  // create device list from normal disks followed by spare ones
+  asprintf(&devices, raidlist->el[i].data_disks.el[0].device);
+  for (j = 1; j < raidlist->el[i].data_disks.entries; j++) {
+    asprintf(&strtmp, "%s", devices);
+    paranoid_free(devices);
+    asprintf(&devices, "%s %s", strtmp,
+         raidlist->el[i].data_disks.el[j].device);
+    paranoid_free(strtmp);
+  }
+  for (j = 0; j < raidlist->el[i].spare_disks.entries; j++) {
+    asprintf(&strtmp, "%s", devices);
+    paranoid_free(devices);
+    asprintf(&devices, "%s %s", strtmp,
+         raidlist->el[i].spare_disks.el[j].device);
+    paranoid_free(strtmp);
+  }
+  // translate RAID level
+  if (raidlist->el[i].raid_level == -2) {
+    asprintf(&level, "multipath");
+  } else if (raidlist->el[i].raid_level == -1) {
+    asprintf(&level, "linear");
+  } else {
+    asprintf(&level, "raid%d", raidlist->el[i].raid_level);
+  }
+  // create RAID device:
+  // - RAID device, number of devices and devices mandatory
+  // - parity algorithm, chunk size and spare devices optional
+  // - faulty devices ignored
+  // - persistent superblock always used as this is recommended
+  asprintf(&program,
+       "mdadm --create --force --run --auto=yes %s --level=%s --raid-devices=%d",
+       raidlist->el[i].raid_device, level,
+       raidlist->el[i].data_disks.entries);
+  if (raidlist->el[i].parity != -1) {
+    asprintf(&strtmp, "%s", program);
+    paranoid_free(program);
+    switch(raidlist->el[i].parity) {
+    case 0:
+      asprintf(&program, "%s --parity=%s", strtmp, "la");
+      break;
+    case 1:
+      asprintf(&program, "%s --parity=%s", strtmp, "ra");
+      break;
+    case 2:
+      asprintf(&program, "%s --parity=%s", strtmp, "ls");
+      break;
+    case 3:
+      asprintf(&program, "%s --parity=%s", strtmp, "rs");
+      break;
+    default:
+      fatal_error("Unknown RAID parity algorithm.");
+      break;
+    }
+    paranoid_free(strtmp);
+  }
+  if (raidlist->el[i].chunk_size != -1) {
+    asprintf(&strtmp, "%s", program);
+    paranoid_free(program);
+    asprintf(&program, "%s --chunk=%d", strtmp, raidlist->el[i].chunk_size);
+    paranoid_free(strtmp);
+  }
+  if (raidlist->el[i].spare_disks.entries > 0) {
+    asprintf(&strtmp, "%s", program);
+    paranoid_free(program);
+    asprintf(&program, "%s --spare-devices=%d", strtmp,
+         raidlist->el[i].spare_disks.entries);
+    paranoid_free(strtmp);
+  }
+  asprintf(&strtmp, "%s", program);
+  paranoid_free(program);
+  asprintf(&program, "%s %s", strtmp, devices);
+  paranoid_free(strtmp);
+  res = run_program_and_log_output(program, 1);
+  // free memory
+  paranoid_free(devices);
+  paranoid_free(level);
+  paranoid_free(program);
+  // return to calling instance
+  return res;
+}
+
+
+/**
  * Format @p device as a @p format filesystem.
  * This will use the format command returned by which_format_command_do_i_need().
@@ -704 +823 @@
  * @return 0 for success, nonzero for failure.
  */
-int format_device(char *device, char *format)
+int format_device(char *device, char *format, struct raidlist_itself *raidlist)
 {
     /** int **************************************************************/
@@ -836 +955 @@
 
         log_msg(1, "Making %s", device);
-        sprintf(program, "mkraid --really-force %s", device);
-        res = run_program_and_log_output(program, 1);
-        log_msg(1, "%s returned %d", program, res);
-        system("sync");
-        sleep(3);
-        start_raid_device(device);
-        if (g_fprep) {
-            fprintf(g_fprep, "%s\n", program);
+        // 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);
+            log_msg(1, "Creating RAID device %s via mdadm returned %d", device, res);
+        } else {
+            sprintf(program, "mkraid --really-force %s", device);
+            res = run_program_and_log_output(program, 1);
+            log_msg(1, "%s returned %d", program, res);
+            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);
@@ -853 +977 @@
 //      log_msg(1, "%s returned %d", program, res);
 //      system("sync"); sleep(1);
-        if (g_fprep) {
-            fprintf(g_fprep, "%s\n", program);
-        }
 #endif
         system("sync");
@@ -923 +1044 @@
  * @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,
+                          struct raidlist_itself *raidlist)
 {
     /** int **************************************************************/
@@ -983 +1104 @@
             if (do_it) {
                 // NB: format_device() also stops/starts RAID device if necessary
-                retval += format_device(me->device, me->format);
+                retval += format_device(me->device, me->format, raidlist);
             }
             g_current_progress += progress_step;
@@ -1000 +1121 @@
     log_msg(1, "Creating LVMs");
     if (does_file_exist("/tmp/i-want-my-lvm")) {
-        wait_until_software_raids_are_prepped("/proc/mdstat", 10);
+        wait_until_software_raids_are_prepped("/proc/mdstat", 100);
         log_to_screen(_("Configuring LVM"));
         if (!g_text_mode) {
@@ -1076 +1197 @@
 
             if (do_it)
-                retval += format_device(me->device, me->format);
+                retval += format_device(me->device, me->format, raidlist);
         }
 
@@ -2246 +2367 @@
     sprintf(program, "vinum stop -f %s", raid_device);
 #else
-    sprintf(program, "raidstop %s", raid_device);
-//      sprintf (program, "raidstop " RAID_DEVICE_STUB "*");
+    // 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);

trunk/mondo/mondo/mondorestore/mondo-restore.c

@@ -839 +839 @@
                     }
 
-                    fmt_errs = format_everything(mountlist, FALSE);
+                    fmt_errs = format_everything(mountlist, FALSE, raidlist);
                     if (!fmt_errs) {
                         log_to_screen
@@ -857 +857 @@
                 if (ask_me_yes_or_no
                     (_("Do you want to format your hard drives?"))) {
-                    fmt_errs = format_everything(mountlist, TRUE);
+                    fmt_errs = format_everything(mountlist, TRUE, raidlist);
                     if (!fmt_errs) {
                         done = TRUE;
@@ -1164 +1164 @@
                 system("sync");
                 log_to_screen(_("Please wait. This may take a few minutes."));
-                res += format_everything(mountlist, FALSE);
+                res += format_everything(mountlist, FALSE, raidlist);
             }
             paranoid_fclose(g_fprep);
@@ -3425 +3425 @@
     }
 
-    if (argc == 4 && strcmp(argv[1], "--mdconv") == 0) {
-        finish(create_raidtab_from_mdstat(argv[2], argv[3]));
+    if (argc == 3 && strcmp(argv[1], "--mdconv") == 0) {
+        finish(create_raidtab_from_mdstat(argv[2]));
     }
 
@@ -3525 +3525 @@
             strcpy(g_mountlist_fname, "/tmp/mountlist.txt");
             load_mountlist(mountlist, g_mountlist_fname);
-            res = format_everything(mountlist, FALSE);
+            res = format_everything(mountlist, FALSE, raidlist);
             finish(res);
         }

trunk/mondo/mondo/mondorestore/mondo-rstr-tools.c

@@ -1 @@
-/***************************************************************************
-mondo-rstr-tools.c  -  description
------------------
-
-begin: Sun Sep 21 16:40:35 EDT 2003
-copyright : (C) 2002 Mondo  Hugo Rabson
-email     : Hugo Rabson <hugorabson@msn.com>
-edited by : by Stan Benoit ?/2003
-email     : troff@nakedsoul.org
-cvsid     : $Id: mondo-rstr-tools.c
-***************************************************************************/
-
-/***************************************************************************
- *                                                                         *
- *   This program is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU General Public License as published by  *
- *   the Free Software Foundation; either version 2 of the License, or     *
- *   (at your option) any later version.                                   *
- *                                                                         *
- ***************************************************************************/
-/* mondo-rstr-tools.c               Hugo Rabson
-
-
-07/27
-- if the user is foolish enough to use /dev/md0 as boot device,
-  call lilo -M /dev/hda to make sure lilo does its job properly
-- better NFS+nuke support
-
-07/20
-- use backup's i-want-my-lvm file
-- be sure to use archives' raidtab when restoring
-
-07/18
-- use /tmp/isodir for NFS if DR mode
-- better support of users who boot from LVM CD and nuke-restore non-LVM backups
-
-07/12
-- bugfix to allow user to burn ISOs to CDs and restore from CDs (not original src)
-
-06/29
-- mount ext3 partitions as ext2, just in case :)
-
-06/26
-- delete make_relevant_partition_bootable()
-
-06/19
-- futzed with the call to mount floppy, to stop it from locking up on my AMD64 system
-
-06/14
-- shell out to /mnt/RESTORING chroot in order to let user install GRUB
-  manually if automatic GRUB installation fails
-
-06/15
-- Added check for different 'isodir' chosen by user than stored in the archive
-  Conor Daly <conor.daly@met.ie>
-
-04/17
-- replaced INTERNAL_TAPE_BLK_SIZE with bkpinfo->internal_tape_block_size
-
-04/09
-- don't try to mount CD if tape bkp
-
-04/03
-- trying to copy tmp/mondo-restore.cfg to itself - silly! - fixed
-
-04/02
-- when extracting cfg file and mountlist from all.tar.gz (tape copy),
-  use block size of INTERNAL_TAPE_BLK_SIZE, not TAPE_BLOCK_SIZE
-
-02/21
-- don't use 'mv -v' cos Busybox won't support it
-
-02/09
-- make hole for cfg file before moving it (line 2094 or so)
-
-02/03
-- changed a couple of refs to filelist.full, to filelist.full.gz
-
-01/16/2004
-- instead of copying filelist, use 'ln -sf' to link to original;
-  saves space
-
-11/20/2003
-- also retrieve /tmp/mountlist.txt if user wants
-
-11/16
-- fixed NFS path bug affecting the extractions of filelist/biggielist
-  during selective restore
-
-11/02
-- fixed mount_cdrom() to run properly w/ nfs restores
-- mount_device() returns 0 if swap mount fails cos swap isn't crucial
-
-10/17
-- run_grub() uses MNT_RESTORING instead of "/mnt/RESTORING"
-
-10/26
-- cleaned up run_grub()
-
-10/25
-- fixed mount_cdrom() to run properly w/ nfs restores
-
-10/21
-- mount_device() returns 0 if swap mount fails cos swap isn't crucial
-
-10/15
-- run_grub() now uses its initiative instead
-  of calling grub-install
-
-10/10
-- don't leave copies of filelist.full lying around, clogging up
-  the ramdisk, there's a good fellow :-)
-
-10/02
-- added 'dvd' to the range of media types I'll understand
-- fixed iso->cdr problem (thanks, Stan Benoit & Fred Beondo)
-
-09/24
-- try lots of tape devs if /dev/st0 fails
-
-09/23/2003
-- first incarnation
+/*
+ * $Id$
 */
 
@@ -2569 +2449 @@
                                            int wait_for_percentage)
 {
-    struct s_mdstat *mdstat;
+    struct raidlist_itself *raidlist;
     int unfinished_mdstat_devices = 9999, i;
     char *screen_message;
 
     malloc_string(screen_message);
-    mdstat = malloc(sizeof(struct s_mdstat));
+    raidlist = malloc(sizeof(struct raidlist_itself));
 
     assert(wait_for_percentage <= 100);
     iamhere("Help, my boat is sync'ing. (Get it? Urp! Urp!)");
     while (unfinished_mdstat_devices > 0) {
-        if (read_mdstat(mdstat, mdstat_file)) {
-            log_to_screen(_("Sorry, cannot read %s"), mdstat_file);
+        if (parse_mdstat(raidlist, "/dev/")) {
+            log_to_screen("Sorry, cannot read %s", MDSTAT_FILE);
+            log_msg(1,"Sorry, cannot read %s", MDSTAT_FILE);
             return;
         }
-        for (unfinished_mdstat_devices = i = 0; i < mdstat->entries; i++) {
-            if (mdstat->el[i].progress < wait_for_percentage) {
+        for (unfinished_mdstat_devices = i = 0; i <= raidlist->entries; i++) {
+            if (raidlist->el[i].progress < wait_for_percentage) {
                 unfinished_mdstat_devices++;
-                sprintf(screen_message, _("Sync'ing /dev/md%d"),
-                        mdstat->el[i].md);
+                log_msg(1,"Sync'ing %s (i=%d)", raidlist->el[i].raid_device, i);
+                sprintf(screen_message, "Sync'ing %s",
+                        raidlist->el[i].raid_device);
                 open_evalcall_form(screen_message);
-                if (mdstat->el[i].progress == -1)   // delayed while another partition inits
+                if (raidlist->el[i].progress == -1) // delayed while another partition inits
                 {
                     continue;
                 }
-                while (mdstat->el[i].progress < wait_for_percentage) {
-                    update_evalcall_form(mdstat->el[i].progress);
+                while (raidlist->el[i].progress < wait_for_percentage) {
+                    log_msg(1,"Percentage sync'ed: %d", raidlist->el[i].progress);
+                    update_evalcall_form(raidlist->el[i].progress);
                     sleep(2);
-                    if (read_mdstat(mdstat, mdstat_file)) {
+                    // FIXME: Prefix '/dev/' should really be dynamic!
+                    if (parse_mdstat(raidlist, "/dev/")) {
                         break;
                     }
@@ -2605 +2489 @@
     }
     paranoid_free(screen_message);
-    paranoid_free(mdstat);
-}
+    paranoid_free(raidlist);
+}

trunk/mondo/mondo/mondorestore/mondoprep.h

@@ -58 +58 @@
 int start_all_raid_devices(struct mountlist_itself *);
 int stop_all_raid_devices(struct mountlist_itself *);
-int format_everything(struct mountlist_itself *, bool);
+int format_everything(struct mountlist_itself *, bool, struct raidlist_itself *);
 int partition_device(FILE *, const char *, int, int, const char *,
                      long long);
@@ -65 +65 @@
 int partition_device_with_fdisk(FILE *, const char *, int, int,
                                 const char *, long long);
-int format_device(char *, char *);
+int format_device(char *, char *, struct raidlist_itself *);
 int partition_drive(struct mountlist_itself *, char *);
 int partition_everything(struct mountlist_itself *);

trunk/mondo/mondo/mondorestore/mr-externs.h

@@ -27 +27 @@
 extern int edit_mountlist(char *mountlist_fname, struct mountlist_itself *,
                           struct raidlist_itself *);
-extern int format_everything(struct mountlist_itself *, bool);
-extern int format_device(char *, char *);
+extern int format_everything(struct mountlist_itself *, bool, struct raidlist_itself *);
+extern int format_device(char *, char *, struct raidlist_itself *);
 extern void finish(int);
 extern void free_filelist(struct s_node *);