Changeset 1081 in MondoRescue for trunk/mondo/src/mondorestore


Ignore:
Timestamp:
Jan 28, 2007, 11:20:07 PM (18 years ago)
Author:
Bruno Cornec
Message:

merge -r1078:1080 $SVN_M/branches/stable

Location:
trunk/mondo/src/mondorestore
Files:
5 edited

Legend:

Unmodified
Added
Removed

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

    r900 r1081  
    11/***************************************************************************
    2  * $Id
    3 **/
     2 * $Id$
     3*/
    44
    55/**
    … …  
    6161    if (does_file_exist("/tmp/i-want-my-lvm"))  // FIXME - cheating :)
    6262    {
    63         drivelist = malloc(sizeof(struct list_of_disks));
     63        drivelist = mr_malloc(sizeof(struct list_of_disks));
    6464        make_list_of_drives_in_mountlist(mountlist, drivelist);
    6565        for (lino = 0; lino < drivelist->entries; lino++) {
    … …  
    522522        }
    523523    }
    524 
    525524    return (0);
    526525}
    … …  
    544543
    545544  /** buffers ***********************************************************/
    546     char *devices = NULL;
    547     char *strtmp = NULL;
    548     char *level = NULL;
    549     char *program = NULL;
    550 
    551     // leave straight away if raidlist is initial or has no entries
    552     if (!raidlist || raidlist->entries == 0) {
    553         log_msg(1, "No RAID arrays found.");
    554         return 1;
    555     } else {
    556         log_msg(1, "%d RAID arrays found.", raidlist->entries);
    557     }
    558     // find raidlist entry for requested device
    559     for (i = 0; i < raidlist->entries; i++) {
    560         if (!strcmp(raidlist->el[i].raid_device, device))
    561             break;
    562     }
    563     // check whether RAID device was found in raidlist
    564     if (i == raidlist->entries) {
    565         log_msg(1, "RAID device %s not found in list.", device);
    566         return 1;
    567     }
    568     // create device list from normal disks followed by spare ones
    569     mr_asprintf(&devices, raidlist->el[i].data_disks.el[0].device);
    570     for (j = 1; j < raidlist->el[i].data_disks.entries; j++) {
    571         mr_asprintf(&strtmp, "%s", devices);
    572         mr_free(devices);
    573         mr_asprintf(&devices, "%s %s", strtmp,
    574                  raidlist->el[i].data_disks.el[j].device);
    575         mr_free(strtmp);
    576     }
    577     for (j = 0; j < raidlist->el[i].spare_disks.entries; j++) {
    578         mr_asprintf(&strtmp, "%s", devices);
    579         mr_free(devices);
    580         mr_asprintf(&devices, "%s %s", strtmp,
    581                  raidlist->el[i].spare_disks.el[j].device);
    582         mr_free(strtmp);
    583     }
    584     // translate RAID level
    585     if (raidlist->el[i].raid_level == -2) {
    586         mr_asprintf(&level, "multipath");
    587     } else if (raidlist->el[i].raid_level == -1) {
    588         mr_asprintf(&level, "linear");
    589     } else {
    590         mr_asprintf(&level, "raid%d", raidlist->el[i].raid_level);
    591     }
    592     // create RAID device:
    593     // - RAID device, number of devices and devices mandatory
    594     // - parity algorithm, chunk size and spare devices optional
    595     // - faulty devices ignored
    596     // - persistent superblock always used as this is recommended
    597     mr_asprintf(&program,
    598              "mdadm --create --force --run --auto=yes %s --level=%s --raid-devices=%d",
    599              raidlist->el[i].raid_device, level,
    600              raidlist->el[i].data_disks.entries);
    601     if (raidlist->el[i].parity != -1) {
    602         mr_asprintf(&strtmp, "%s", program);
    603         mr_free(program);
    604         switch (raidlist->el[i].parity) {
    605         case 0:
    606             mr_asprintf(&program, "%s --parity=%s", strtmp, "la");
    607             break;
    608         case 1:
    609             mr_asprintf(&program, "%s --parity=%s", strtmp, "ra");
    610             break;
    611         case 2:
    612             mr_asprintf(&program, "%s --parity=%s", strtmp, "ls");
    613             break;
    614         case 3:
    615             mr_asprintf(&program, "%s --parity=%s", strtmp, "rs");
    616             break;
    617         default:
    618             fatal_error("Unknown RAID parity algorithm.");
    619             break;
    620         }
    621         mr_free(strtmp);
    622     }
    623     if (raidlist->el[i].chunk_size != -1) {
    624         mr_asprintf(&strtmp, "%s", program);
    625         mr_free(program);
    626         mr_asprintf(&program, "%s --chunk=%d", strtmp,
    627                  raidlist->el[i].chunk_size);
    628         mr_free(strtmp);
    629     }
    630     if (raidlist->el[i].spare_disks.entries > 0) {
    631         mr_asprintf(&strtmp, "%s", program);
    632         mr_free(program);
    633         mr_asprintf(&program, "%s --spare-devices=%d", strtmp,
    634                  raidlist->el[i].spare_disks.entries);
    635         mr_free(strtmp);
    636     }
    637     mr_asprintf(&strtmp, "%s", program);
    638     mr_free(program);
    639     mr_asprintf(&program, "%s %s", strtmp, devices);
    640     mr_free(strtmp);
    641     res = run_program_and_log_output(program, 1);
    642     // free memory
    643     mr_free(devices);
    644     mr_free(level);
    645     mr_free(program);
    646     // return to calling instance
    647     return res;
     545  char *devices = NULL;
     546  char *strtmp  = NULL;
     547  char *level   = NULL;
     548  char *program = NULL;
     549 
     550  // leave straight away if raidlist is initial or has no entries
     551  if (!raidlist || raidlist->entries == 0) {
     552    log_msg(1, "No RAID arrays found.");
     553    return 1;
     554  } else {
     555    log_msg(1, "%d RAID arrays found.", raidlist->entries);
     556  }
     557  // find raidlist entry for requested device
     558  for (i = 0; i < raidlist->entries; i++) {
     559    if (!strcmp(raidlist->el[i].raid_device, device)) break;
     560  }
     561  // check whether RAID device was found in raidlist
     562  if (i == raidlist->entries) {
     563    log_msg(1, "RAID device %s not found in list.", device);
     564    return 1;
     565  }
     566  // create device list from normal disks followed by spare ones
     567  mr_asprintf(&devices, raidlist->el[i].data_disks.el[0].device);
     568  for (j = 1; j < raidlist->el[i].data_disks.entries; j++) {
     569    mr_asprintf(&strtmp, "%s", devices);
     570    mr_free(devices);
     571    mr_asprintf(&devices, "%s %s", strtmp,
     572         raidlist->el[i].data_disks.el[j].device);
     573    mr_free(strtmp);
     574  }
     575  for (j = 0; j < raidlist->el[i].spare_disks.entries; j++) {
     576    mr_asprintf(&strtmp, "%s", devices);
     577    mr_free(devices);
     578    mr_asprintf(&devices, "%s %s", strtmp,
     579         raidlist->el[i].spare_disks.el[j].device);
     580    mr_free(strtmp);
     581  }
     582  // translate RAID level
     583  if (raidlist->el[i].raid_level == -2) {
     584    mr_asprintf(&level, "multipath");
     585  } else if (raidlist->el[i].raid_level == -1) {
     586    mr_asprintf(&level, "linear");
     587  } else {
     588    mr_asprintf(&level, "raid%d", raidlist->el[i].raid_level);
     589  }
     590  // create RAID device:
     591  // - RAID device, number of devices and devices mandatory
     592  // - parity algorithm, chunk size and spare devices optional
     593  // - faulty devices ignored
     594  // - persistent superblock always used as this is recommended
     595  mr_asprintf(&program,
     596       "mdadm --create --force --run --auto=yes %s --level=%s --raid-devices=%d",
     597       raidlist->el[i].raid_device, level,
     598       raidlist->el[i].data_disks.entries);
     599  if (raidlist->el[i].parity != -1) {
     600    asprintf(&strtmp, "%s", program);
     601    mr_free(program);
     602    switch(raidlist->el[i].parity) {
     603    case 0:
     604      mr_asprintf(&program, "%s --parity=%s", strtmp, "la");
     605      break;
     606    case 1:
     607      mr_asprintf(&program, "%s --parity=%s", strtmp, "ra");
     608      break;
     609    case 2:
     610      mr_asprintf(&program, "%s --parity=%s", strtmp, "ls");
     611      break;
     612    case 3:
     613      mr_asprintf(&program, "%s --parity=%s", strtmp, "rs");
     614      break;
     615    default:
     616      fatal_error("Unknown RAID parity algorithm.");
     617      break;
     618    }
     619    mr_free(strtmp);
     620  }
     621  if (raidlist->el[i].chunk_size != -1) {
     622    mr_asprintf(&strtmp, "%s", program);
     623    mr_free(program);
     624    mr_asprintf(&program, "%s --chunk=%d", strtmp, raidlist->el[i].chunk_size);
     625    mr_free(strtmp);
     626  }
     627  if (raidlist->el[i].spare_disks.entries > 0) {
     628    mr_asprintf(&strtmp, "%s", program);
     629    mr_free(program);
     630    mr_asprintf(&program, "%s --spare-devices=%d", strtmp,
     631         raidlist->el[i].spare_disks.entries);
     632    mr_free(strtmp);
     633  }
     634  mr_asprintf(&strtmp, "%s", program);
     635  mr_free(program);
     636  mr_asprintf(&program, "%s %s", strtmp, devices);
     637  mr_free(strtmp);
     638  res = run_program_and_log_output(program, 1);
     639  // free memory
     640  mr_free(devices);
     641  mr_free(level);
     642  mr_free(program);
     643  // return to calling instance
     644  return res;
    648645}
    649646
    … …  
    15511548                    mr_free(command);
    15521549                    mr_free(device_str);
    1553 
    15541550                    return r;
    15551551                }
    … …  
    16431639            mr_free(device_str);
    16441640            mr_free(format);
    1645 
    16461641            return (1);
    16471642        }
    … …  
    19551950    /** end ************************************************************/
    19561951
    1957     drivelist = malloc(sizeof(struct list_of_disks));
     1952    drivelist = mr_malloc(sizeof(struct list_of_disks));
    19581953    assert(mountlist != NULL);
    19591954
    … …  
    21682163    mr_free(partcode);
    21692164
    2170 
    21712165    return (res);
    21722166}
    … …  
    25182512    mr_free(tmp);
    25192513
    2520     drivemntlist = malloc(sizeof(struct mountlist_reference));
     2514    drivemntlist = mr_malloc(sizeof(struct mountlist_reference));
    25212515    drivemntlist->el =
    2522         malloc(sizeof(struct mountlist_line *) * MAX_TAPECATALOG_ENTRIES);
    2523 
    2524     if (!drivemntlist) {
    2525         fatal_error("Cannot malloc temporary mountlist\n");
    2526     }
     2516        mr_malloc(sizeof(struct mountlist_line *) * MAX_TAPECATALOG_ENTRIES);
     2517
    25272518    create_mountlist_for_drive(mountlist, drive_name, drivemntlist);
    25282519
    … …  
    25952586    /** end *************************************************************/
    25962587
    2597     drivelist = malloc(sizeof(struct list_of_disks));
    2598     assert(mountlist != NULL);
     2588    drivelist = mr_malloc(sizeof(struct list_of_disks));
    25992589
    26002590    if (g_mountlist_fname == NULL) {

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

    r1079 r1081  
    11/***************************************************************************
    2 $Id$
    3 restores mondoarchive data
     2* restores mondoarchive data
     3* $Id$
    44***************************************************************************/
    55
    … …  
    910910    assert(bkpinfo != NULL);
    911911
    912     mountlist = malloc(sizeof(struct mountlist_itself));
    913     raidlist = malloc(sizeof(struct raidlist_itself));
    914 
    915     if (!mountlist || !raidlist) {
    916         fatal_error("Cannot malloc() mountlist and/or raidlist");
    917     }
     912    mountlist = mr_malloc(sizeof(struct mountlist_itself));
     913    raidlist = mr_malloc(sizeof(struct raidlist_itself));
    918914
    919915    mr_allocstr(bkpinfo->restore_path, "/");
    … …  
    964960        eject_device(bkpinfo->media_device);
    965961    }
    966     free(mountlist);
    967     free(raidlist);
     962    mr_free(mountlist);
     963    mr_free(raidlist);
    968964    return (retval);
    969965}
    … …  
    10291025    assert(bkpinfo != NULL);
    10301026
    1031     if (!(bigblk = malloc(TAPE_BLOCK_SIZE))) {
    1032         fatal_error("Cannot malloc bigblk");
    1033     }
     1027    bigblk = mr_malloc(TAPE_BLOCK_SIZE);
    10341028
    10351029    tmp = slice_fname(bigfileno, 0, ARCHIVES_PATH, "");
    … …  
    17511745    mr_free(acl_fname);
    17521746    mr_free(temp_log);
    1753 
    17541747    log_msg(5, "Leaving");
    17551748    return (retval);
    … …  
    28762869    mr_free(tmp);
    28772870
    2878     if (!
    2879         (bkpinfo = g_bkpinfo_DONTUSETHIS =
    2880          malloc(sizeof(struct s_bkpinfo)))) {
    2881         fatal_error("Cannot malloc bkpinfo");
    2882     }
    2883     if (!(mountlist = malloc(sizeof(struct mountlist_itself)))) {
    2884         fatal_error("Cannot malloc mountlist");
    2885     }
    2886     if (!(raidlist = malloc(sizeof(struct raidlist_itself)))) {
    2887         fatal_error("Cannot malloc raidlist");
    2888     }
     2871    bkpinfo = g_bkpinfo_DONTUSETHIS = mr_malloc(sizeof(struct s_bkpinfo));
     2872    mountlist = mr_malloc(sizeof(struct mountlist_itself));
     2873    raidlist = mr_malloc(sizeof(struct raidlist_itself));
    28892874
    28902875    malloc_libmondo_global_strings();

  • trunk/mondo/src/mondorestore/mondo-rstr-compare.c

    r1043 r1081  
    11/***************************************************************************
    2  * $Id$ - compares mondoarchive data
    3 **/
    4 
     2* compares mondoarchive data
     3* $Id$
     4*/
    55
    66#include "my-stuff.h"

  • trunk/mondo/src/mondorestore/mondo-rstr-newt.c

    r900 r1081  
    11/***************************************************************************
    22 * $Id$
    3 **/
    4 
     3*/
    54
    65/**
    … …  
    16521651    assert(raidrec != NULL);
    16531652
    1654     if (!(bkp_raidrec = malloc(sizeof(struct raid_device_record)))) {
    1655         fatal_error("Cannot malloc space for raidrec");
    1656     }
     1653    bkp_raidrec = mr_malloc(sizeof(struct raid_device_record));
    16571654
    16581655    log_it("Started edit_raidlist_entry");
    … …  
    17361733        calculate_raid_device_size(mountlist, raidlist,
    17371734                                   raidrec->raid_device);
     1735<<<<<<< .courant
    17381736    mr_free(bkp_raidrec);
     1737=======
     1738    mr_free(title_of_editraidForm_window);
     1739    mr_free(sz_raid_level);
     1740    mr_free(sz_data_disks);
     1741    mr_free(sz_spare_disks);
     1742    mr_free(sz_parity_disks);
     1743    mr_free(sz_failed_disks);
     1744    mr_free(bkp_raidrec);
     1745>>>>>>> .fusion-droit.r1080
    17391746#endif
    17401747}
    … …  
    17871794    struct mountlist_itself *unallocparts = NULL;
    17881795
     1796<<<<<<< .courant
    17891797    /* BERLIOS: Check return value */
    17901798    unallocparts = malloc(sizeof(struct mountlist_itself));
     1799=======
     1800    unallocparts = mr_malloc(sizeof(struct mountlist_itself));
     1801>>>>>>> .fusion-droit.r1080
    17911802
    17921803    log_it("Started edit_raidlist_entry");
    … …  
    28112822
    28122823    iamhere("malloc'ing");
    2813     if (!(bkp_raidrec = malloc(sizeof(struct raid_device_record)))) {
    2814         fatal_error("Cannot malloc space for raidrec");
    2815     }
    2816     if (!(bkp_disklist = malloc(sizeof(struct list_of_disks)))) {
    2817         fatal_error("Cannot malloc space for disklist");
    2818     }
    2819     if (!(bkp_raidlist = malloc(sizeof(struct raidlist_itself)))) {
    2820         fatal_error("Cannot malloc space for raidlist");
    2821     }
    2822     if (!
    2823         (unallocated_raid_partitions =
    2824          malloc(sizeof(struct mountlist_itself)))) {
    2825         fatal_error("Cannot malloc space for unallocated_raid_partitions");
    2826     }
     2824    bkp_raidrec = mr_malloc(sizeof(struct raid_device_record));
     2825    bkp_disklist = mr_malloc(sizeof(struct list_of_disks));
     2826    bkp_raidlist = mr_malloc(sizeof(struct raidlist_itself));
     2827    unallocated_raid_partitions = mr_malloc(sizeof(struct mountlist_itself));
    28272828
    28282829    memcpy((void *) bkp_raidlist, (void *) raidlist,
    … …  
    29262927               sizeof(struct list_of_disks));
    29272928    }
     2929<<<<<<< .courant
    29282930    mr_free(bkp_raidrec);
    29292931    mr_free(bkp_disklist);
    29302932    mr_free(bkp_raidlist);
    29312933    mr_free(unallocated_raid_partitions);
     2934=======
     2935    mr_free(tmp);
     2936    mr_free(help_text);
     2937    mr_free(title_of_window);
     2938    mr_free(sz_res);
     2939    mr_free(header_text);
     2940    mr_free(bkp_raidrec);
     2941    mr_free(bkp_disklist);
     2942    mr_free(bkp_raidlist);
     2943    mr_free(unallocated_raid_partitions);
     2944>>>>>>> .fusion-droit.r1080
    29322945}
    29332946#endif

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

    r1043 r1081  
    1 /*
     1/***************************************************************************
    22 * $Id$
    3 **/
     3*/
     4
    45
    56#include <unistd.h>
    6 
    77#include "my-stuff.h"
    88#include "../common/mondostructures.h"
    … …  
    6767    mr_free(g_isodir_device);
    6868    mr_free(g_isodir_format);
    69 
    7069}
    7170
    … …  
    201200        retval = 0;
    202201    }
     202<<<<<<< .courant
    203203    mr_free(orig_fname);
     204=======
     205    mr_free(mountpt);
     206    mr_free(command);
     207    mr_free(orig_fname);
     208>>>>>>> .fusion-droit.r1080
    204209    return (retval);
    205210}
    … …  
    265270
    266271    res = run_program_and_log_output(command, FALSE);
    267     mr_free(command);
     272<<<<<<< .courant
     273    mr_free(command);
     274=======
     275    mr_free(command);
     276    mr_free(file);
     277    mr_free(tmp);
     278>>>>>>> .fusion-droit.r1080
    268279    if (res) {
    269280        return (FALSE);
    … …  
    363374    log_msg(2, "%ld: bkpinfo->isodir is now %s", __LINE__,
    364375            bkpinfo->isodir);
     376<<<<<<< .courant
     377=======
     378    mr_free(mount_isodir_command);
     379    mr_free(tmp);
     380    mr_free(command);
     381>>>>>>> .fusion-droit.r1080
    365382    return (retval);
    366383}
    … …  
    419436        return (0);
    420437    }
     438<<<<<<< .courant
    421439    if (!strcmp(mountpoint, "image")) {
    422440        mr_free(mountpoint);
    423441        return (0);
     442=======
     443    if (!does_file_exist(rclocal_fname)) {
     444        mr_free(rclocal_fname);
     445        mr_free(newfile_fname);
     446        mr_free(tmp);
     447        return (1);
     448>>>>>>> .fusion-droit.r1080
    424449    }
    425450    mr_asprintf(&tmp, "Mounting device %s   ", device);
    … …  
    431456        mr_asprintf(&p1, "-o ro");
    432457    }
     458<<<<<<< .courant
    433459    tmp = find_home_of_exe("setfattr");
    434460    if (tmp) {
    … …  
    438464    }
    439465    mr_free(tmp);
     466=======
     467    sprintf(tmp, "echo -en \"#!/bin/sh\
     468\\n\
     469\\n\
     470grep -v mondorescue %s > %s\\n\
     471rm -f /var/lock/subsys/*xfs*\\n\
     472rm -f /var/run/xfs.*\\n\
     473killall xfs\\n\
     474service xfs start\\n\
     475yes | rm -f %s\\n\
     476\" > %s", rclocal_fname, rclocal_fname, newfile_fname, newfile_fname);
     477    sprintf(tmp, "chmod +x \"%s\"", newfile_fname);
     478    run_program_and_log_output(tmp, FALSE);
     479    mr_free(rclocal_fname);
     480    mr_free(newfile_fname);
     481    mr_free(tmp);
     482    return (0);
     483}
     484>>>>>>> .fusion-droit.r1080
    440485
    441486    tmp = find_home_of_exe("setfacl");
    … …  
    538583
    539584    assert(p_external_copy_of_mountlist != NULL);
    540     mountlist = malloc(sizeof(struct mountlist_itself));
     585    mountlist = mr_malloc(sizeof(struct mountlist_itself));
    541586    memcpy((void *) mountlist, (void *) p_external_copy_of_mountlist,
    542587           sizeof(struct mountlist_itself));
    … …  
    621666    }
    622667    run_program_and_log_output("df -m", 3);
     668<<<<<<< .courant
    623669    mr_free(mountlist);
     670=======
     671    mr_free(mountlist);
     672    mr_free(tmp);
     673    mr_free(format);
     674    mr_free(these_failed);
     675>>>>>>> .fusion-droit.r1080
    624676    return (retval);
    625677}
    … …  
    651703        || bkpinfo->backup_media_type == udev) {
    652704        log_msg(8, "Tape/udev. Therefore, no need to mount CDROM.");
     705<<<<<<< .courant
     706=======
     707        mr_free(mount_cmd);
     708>>>>>>> .fusion-droit.r1080
    653709        return 0;
    654710    }
    … …  
    656712    if (!run_program_and_log_output("mount | grep -F " MNT_CDROM, FALSE)) {
    657713        log_msg(2, "mount_cdrom() - CD already mounted. Fair enough.");
     714<<<<<<< .courant
     715=======
     716        mr_free(mount_cmd);
     717>>>>>>> .fusion-droit.r1080
    658718        return (0);
    659719    }
    … …  
    747807        log_msg(2, "Mounted CD-ROM drive OK");
    748808    }
     809<<<<<<< .courant
     810=======
     811    mr_free(mount_cmd);
     812>>>>>>> .fusion-droit.r1080
    749813    return (res);
    750814}
    … …  
    755819
    756820/**
     821<<<<<<< .courant
     822=======
     823 * Mount @p device at @p mpt as @p format.
     824 * @param device The device (/dev entry) to mount.
     825 * @param mpt The directory to mount it on.
     826 * @param format The filesystem type of @p device.
     827 * @param writeable If TRUE, mount read-write; if FALSE, mount read-only.
     828 * @return 0 for success, nonzero for failure.
     829 */
     830int mount_device(char *device, char *mpt, char *format, bool writeable)
     831{
     832    int res = 0;
     833
     834  /** malloc **/
     835    char *tmp, *command, *mountdir, *mountpoint, *additional_parameters;
     836
     837    assert_string_is_neither_NULL_nor_zerolength(device);
     838    assert_string_is_neither_NULL_nor_zerolength(mpt);
     839    assert(format != NULL);
     840    malloc_string(tmp);
     841    malloc_string(command);
     842    malloc_string(mountdir);
     843    malloc_string(mountpoint);
     844    malloc_string(additional_parameters);
     845
     846    if (!strcmp(mpt, "/1")) {
     847        strcpy(mountpoint, "/");
     848        log_msg(3, "Mommm! SME is being a dildo!");
     849    } else {
     850        strcpy(mountpoint, mpt);
     851    }
     852
     853    if (!strcmp(mountpoint, "lvm")) {
     854        return (0);
     855    }
     856    if (!strcmp(mountpoint, "image")) {
     857        return (0);
     858    }
     859    sprintf(tmp, "Mounting device %s   ", device);
     860    log_msg(1, tmp);
     861    if (writeable) {
     862        strcpy(additional_parameters, "-o rw");
     863    } else {
     864        strcpy(additional_parameters, "-o ro");
     865    }
     866    if (find_home_of_exe("setfattr")) {
     867        strcat(additional_parameters, ",user_xattr");
     868    }
     869    if (find_home_of_exe("setfacl")) {
     870        strcat(additional_parameters, ",acl");
     871    }
     872
     873    if (!strcmp(mountpoint, "swap")) {
     874        sprintf(command, "swapon %s", device);
     875    } else {
     876        if (!strcmp(mountpoint, "/")) {
     877            strcpy(mountdir, MNT_RESTORING);
     878        } else {
     879            sprintf(mountdir, "%s%s", MNT_RESTORING, mountpoint);
     880        }
     881        sprintf(command, "mkdir -p %s", mountdir);
     882        run_program_and_log_output(command, FALSE);
     883        sprintf(command, "mount -t %s %s %s %s 2>> %s", format, device,
     884                additional_parameters, mountdir, MONDO_LOGFILE);
     885        log_msg(2, "command='%s'", command);
     886    }
     887    res = run_program_and_log_output(command, TRUE);
     888    if (res && (strstr(command, "xattr") || strstr(command, "acl"))) {
     889        log_msg(1, "Re-trying without the fancy extra parameters");
     890        sprintf(command, "mount -t %s %s %s 2>> %s", format, device,
     891                mountdir, MONDO_LOGFILE);
     892        res = run_program_and_log_output(command, TRUE);
     893    }
     894    if (res) {
     895        log_msg(1, "Unable to mount device %s (type %s) at %s", device,
     896                format, mountdir);
     897        log_msg(1, "command was '%s'", command);
     898        if (!strcmp(mountpoint, "swap")) {
     899            log_to_screen(tmp);
     900        } else {
     901            log_msg(2, "Retrying w/o the '-t' switch");
     902            sprintf(command, "mount %s %s 2>> %s", device, mountdir,
     903                    MONDO_LOGFILE);
     904            log_msg(2, "2nd command = '%s'", command);
     905            res = run_program_and_log_output(command, TRUE);
     906            if (res == 0) {
     907                log_msg(1,
     908                        "That's OK. I called mount w/o a filesystem type and it worked fine in the end.");
     909            } else {
     910                log_to_screen(tmp);
     911            }
     912        }
     913    }
     914    if (res && !strcmp(mountpoint, "swap")) {
     915        log_msg(2, "That's ok. It's just a swap partition.");
     916        log_msg(2, "Non-fatal error. Returning 0.");
     917        res = 0;
     918    }
     919
     920    mr_free(tmp);
     921    mr_free(command);
     922    mr_free(mountdir);
     923    mr_free(mountpoint);
     924    mr_free(additional_parameters);
     925
     926    return (res);
     927}
     928
     929/**************************************************************************
     930 *END_MOUNT_DEVICE                                                        *
     931 **************************************************************************/
     932
     933
     934
     935/**
     936>>>>>>> .fusion-droit.r1080
    757937 * Fix some miscellaneous things in the filesystem so the system will come
    758938 * up correctly on the first boot.
    … …  
    9201100    read_cfg_var(cfg_file, "acl", value);
    9211101    if (strstr(value, "TRUE")) {
    922         asprintf(&g_getfacl,"setfacl");
     1102        mr_asprintf(&g_getfacl,"setfacl");
    9231103        log_msg(1, "We will restore ACLs");
    9241104        if (! find_home_of_exe("setfacl")) {
    … …  
    9281108    read_cfg_var(cfg_file, "xattr", value);
    9291109    if (strstr(value, "TRUE")) {
    930         asprintf(&g_getfattr,"setfattr");
     1110        mr_asprintf(&g_getfattr,"setfattr");
    9311111        log_msg(1, "We will restore XATTRs");
    9321112        if (! find_home_of_exe("setfattr")) {
    … …  
    11291309    }
    11301310    g_backup_media_type = bkpinfo->backup_media_type;
     1311<<<<<<< .courant
    11311312    bkpinfo->backup_media_string = bkptype_to_string(bkpinfo->backup_media_type);
    11321313    g_backup_media_string = bkpinfo->backup_media_string;
     1314=======
     1315    mr_free(value);
     1316    mr_free(tmp);
     1317    mr_free(command);
     1318    mr_free(iso_mnt);
     1319    mr_free(iso_path);
     1320    mr_free(old_isodir);
     1321>>>>>>> .fusion-droit.r1080
    11331322    return (0);
    11341323}
    … …  
    13201509                                      TRUE);
    13211510    }
     1511<<<<<<< .courant
     1512=======
     1513
     1514    mr_free(command);
     1515    mr_free(tmp);
     1516>>>>>>> .fusion-droit.r1080
    13221517    return (filelist);
    13231518}
    … …  
    13441539    mr_asprintf(&command, "cp -f %s/%s %s/%s.pristine", path_root, filename,path_root, filename);
    13451540    res = run_program_and_log_output(command, 5);
    1346     mr_free(command);
     1541<<<<<<< .courant
     1542    mr_free(command);
     1543=======
     1544    mr_free(tmp);
     1545    mr_free(command);
     1546>>>>>>> .fusion-droit.r1080
    13471547    return (res);
    13481548}
    … …  
    14271627        log_to_screen(_("Your boot loader ran OK"));
    14281628    }
     1629<<<<<<< .courant
     1630=======
     1631    mr_free(device);
     1632    mr_free(tmp);
     1633    mr_free(name);
     1634>>>>>>> .fusion-droit.r1080
    14291635    return (retval);
    14301636}
    … …  
    15791785        mvaddstr_and_log_it(g_currentY++, 74, _("Done."));
    15801786    }
     1787<<<<<<< .courant
     1788=======
     1789    mr_free(rootdev);
     1790    mr_free(rootdrive);
     1791    mr_free(conffile);
     1792    mr_free(command);
     1793    mr_free(boot_device);
     1794    mr_free(tmp);
     1795    mr_free(editor);
     1796
     1797>>>>>>> .fusion-droit.r1080
    15811798    return (res);
    15821799}
    … …  
    16491866        res = TRUE;
    16501867    }
     1868<<<<<<< .courant
     1869=======
     1870    mr_free(command);
     1871    mr_free(tmp);
     1872    mr_free(editor);
     1873>>>>>>> .fusion-droit.r1080
    16511874    return (res);
    16521875}
    … …  
    17621985                                   " lilo -M /dev/sda", 3);
    17631986    }
     1987<<<<<<< .courant
     1988=======
     1989    mr_free(command);
     1990    mr_free(tmp);
     1991    mr_free(editor);
     1992>>>>>>> .fusion-droit.r1080
    17641993    return (res);
    17651994}
    … …  
    18422071        mvaddstr_and_log_it(g_currentY++, 74, _("Done."));
    18432072    }
     2073<<<<<<< .courant
     2074=======
     2075    mr_free(command);
     2076    mr_free(boot_device);
     2077    mr_free(tmp);
     2078    mr_free(editor);
     2079>>>>>>> .fusion-droit.r1080
    18442080    return (res);
    18452081}
    … …  
    19422178    paranoid_fclose(fout);
    19432179    paranoid_fclose(fin);
     2180<<<<<<< .courant
     2181=======
     2182    mr_free(incoming);
     2183>>>>>>> .fusion-droit.r1080
    19442184}
    19452185/**************************************************************************
    … …  
    19882228    }
    19892229    close_progress_form();
     2230<<<<<<< .courant
     2231=======
     2232    mr_free(tmp);
     2233>>>>>>> .fusion-droit.r1080
    19902234}
    19912235/**************************************************************************
    … …  
    20282272    assert(p_external_copy_of_mountlist != NULL);
    20292273
    2030     mountlist = malloc(sizeof(struct mountlist_itself));
     2274    mountlist = mr_malloc(sizeof(struct mountlist_itself));
    20312275    memcpy((void *) mountlist, (void *) p_external_copy_of_mountlist,
    20322276           sizeof(struct mountlist_itself));
    … …  
    21212365        log_to_screen(_("All partitions were unmounted OK."));
    21222366    }
     2367<<<<<<< .courant
    21232368    free(mountlist);
     2369=======
     2370    mr_free(mountlist);
     2371    mr_free(command);
     2372    mr_free(tmp);
     2373>>>>>>> .fusion-droit.r1080
    21242374    return (retval);
    21252375}
    … …  
    21572407        res = 0;
    21582408    }
     2409<<<<<<< .courant
     2410=======
     2411    mr_free(command);
     2412>>>>>>> .fusion-droit.r1080
    21592413    return (res);
    21602414}
    … …  
    24252679
    24262680    g_backup_media_type = bkpinfo->backup_media_type;
     2681<<<<<<< .courant
    24272682    bkpinfo->backup_media_string = bkptype_to_string(bkpinfo->backup_media_type);
    24282683    g_backup_media_string = bkpinfo->backup_media_string;
     2684=======
     2685    mr_free(device);
     2686    mr_free(command);
     2687    mr_free(tmp);
     2688    mr_free(cfg_file);
     2689    mr_free(mounted_cfgf_path);
     2690    mr_free(mountpt);
     2691    mr_free(ramdisk_fname);
     2692    mr_free(mountlist_file);
     2693>>>>>>> .fusion-droit.r1080
    24292694    return (retval);
    24302695}
    … …  
    24422707    char *screen_message = NULL;
    24432708
    2444     raidlist = malloc(sizeof(struct raidlist_itself));
     2709    raidlist = mr_malloc(sizeof(struct raidlist_itself));
    24452710
    24462711    assert(wait_for_percentage <= 100);
    … …  
    24802745        }
    24812746    }
     2747<<<<<<< .courant
    24822748    mr_free(raidlist);
    2483 }
     2749=======
     2750    mr_free(screen_message);
     2751    mr_free(raidlist);
     2752>>>>>>> .fusion-droit.r1080
     2753}
Note: See TracChangeset for help on using the changeset viewer.