Ignore:
Timestamp:
Feb 8, 2007, 12:09:34 AM (12 years ago)
Author:
bruno
Message:

log_msg => mr_msg for common files

File:
1 edited

Legend:

Unmodified
Added
Removed
  • branches/stable/mondo/src/common/libmondo-devices.c

    r1080 r1107  
    108108    strcpy(tmp, where_is_root_mounted());
    109109    sprintf(comment, "root is mounted at %s\n", tmp);
    110     log_msg(0, comment);
    111     log_msg(0,
     110    mr_msg(0, comment);
     111    mr_msg(0,
    112112            "No, Schlomo, that doesn't mean %s is the root partition. It's just a debugging message. Relax. It's part of am_I_in_disaster_recovery_mode().",
    113113            tmp);
     
    141141    mr_free(tmp);
    142142    mr_free(comment);
    143     log_msg(1, "Is this a ramdisk? result = %d", is_this_a_ramdisk);
     143    mr_msg(1, "Is this a ramdisk? result = %d", is_this_a_ramdisk);
    144144    return (is_this_a_ramdisk);
    145145}
     
    226226#endif
    227227
    228     log_msg(3, "Ejecting %s", dev);
     228    mr_msg(3, "Ejecting %s", dev);
    229229    res2 = run_program_and_log_output(command, 1);
    230230    mr_free(command);
     
    483483    }
    484484    if (res) {
    485         log_msg(1, "mount failed");
    486     } else {
    487         log_msg(1, "mount succeeded with %s", dev);
     485        mr_msg(1, "mount failed");
     486    } else {
     487        mr_msg(1, "mount succeeded with %s", dev);
    488488    }
    489489    mr_free(dev);
     
    521521    if (g_cdrw_drive_is_here[0]) {
    522522        strcpy(cdrw_device, g_cdrw_drive_is_here);
    523         log_msg(3, "Been there, done that. Returning %s", cdrw_device);
     523        mr_msg(3, "Been there, done that. Returning %s", cdrw_device);
    524524        mr_free(comment);
    525525        mr_free(tmp);
     
    529529    }
    530530    if (g_backup_media_type == dvd) {
    531         log_msg(1,
     531        mr_msg(1,
    532532                "This is dumb. You're calling find_cdrw_device() but you're backing up to DVD. WTF?");
    533533        mr_free(comment);
     
    621621    if (g_cdrom_drive_is_here[0] && !isdigit(g_cdrom_drive_is_here[0])) {
    622622        strcpy(output, g_cdrom_drive_is_here);
    623         log_msg(3, "Been there, done that. Returning %s", output);
     623        mr_msg(3, "Been there, done that. Returning %s", output);
    624624        retval = 0;
    625625        goto end_of_find_cdrom_device;
     
    627627    if (the_last_place_i_found_it[0] != '\0' && !try_to_mount) {
    628628        strcpy(output, the_last_place_i_found_it);
    629         log_msg(3,
     629        mr_msg(3,
    630630                "find_cdrom_device() --- returning last found location - '%s'",
    631631                output);
     
    645645    if (!find_home_of_exe(cdr_exe)) {
    646646        strcpy(output, "/dev/cdrom");
    647         log_msg(4, "Can't find cdrecord; assuming %s", output);
     647        mr_msg(4, "Can't find cdrecord; assuming %s", output);
    648648        if (!does_device_exist(output)) {
    649             log_msg(4, "That didn't work. Sorry.");
     649            mr_msg(4, "That didn't work. Sorry.");
    650650            retval = 1;
    651651            goto end_of_find_cdrom_device;
     
    659659    fin = popen(command, "r");
    660660    if (!fin) {
    661         log_msg(4, "command=%s", command);
     661        mr_msg(4, "command=%s", command);
    662662        log_OS_error("Cannot popen command");
    663663        return (1);
     
    690690#ifndef __FreeBSD__
    691691    if (strlen(phrase_two) == 0) {
    692         log_msg(4, "Not running phase two. String is empty.");
     692        mr_msg(4, "Not running phase two. String is empty.");
    693693    } else {
    694694        sprintf(command, "dmesg | grep \"%s\" 2> /dev/null", phrase_two);
    695695        fin = popen(command, "r");
    696696        if (!fin) {
    697             log_msg(4, "Cannot run 2nd command - non-fatal, fortunately");
     697            mr_msg(4, "Cannot run 2nd command - non-fatal, fortunately");
    698698        } else {
    699699            for (fgets(tmp, MAX_STR_LEN, fin); !feof(fin);
    700700                 fgets(tmp, MAX_STR_LEN, fin)) {
    701                 log_msg(5, "--> '%s'", tmp);
     701                mr_msg(5, "--> '%s'", tmp);
    702702                if (tmp[0] != ' ' && tmp[1] != ' ') {
    703703                    p = strchr(tmp, ':');
     
    706706                        if (strstr(tmp, "DVD")) {
    707707                            sprintf(dvd_last_resort, "/dev/%s", tmp);
    708                             log_msg(4,
     708                            mr_msg(4,
    709709                                    "Ignoring '%s' because it's a DVD drive",
    710710                                    tmp);
     
    723723#ifdef __FreeBSD__
    724724    if (!found_it) {
    725         log_msg(4, "OK, approach 2");
     725        mr_msg(4, "OK, approach 2");
    726726        if (!(found_it = set_dev_to_this_if_rx_OK(output, "/dev/cdrom"))) {
    727727            if (!
     
    759759#else
    760760    if (!found_it && strlen(dvd_last_resort) > 0) {
    761         log_msg(4, "Well, I'll use the DVD - %s - as a last resort",
     761        mr_msg(4, "Well, I'll use the DVD - %s - as a last resort",
    762762                dvd_last_resort);
    763763        strcpy(output, dvd_last_resort);
     
    768768                strrchr(output, '/') + 1);
    769769        if (system(tmp) == 0) {
    770             log_msg(4,
     770            mr_msg(4,
    771771                    "%s is not right. It's being SCSI-emulated. Continuing.",
    772772                    output);
     
    777777
    778778    if (found_it) {
    779         log_msg(4, "(find_cdrom_device) --> '%s'", output);
     779        mr_msg(4, "(find_cdrom_device) --> '%s'", output);
    780780        if (!does_device_exist(output)) {
    781781            found_it = FALSE;
    782             log_msg(4, "OK, I was wrong, I haven't found it... yet.");
     782            mr_msg(4, "OK, I was wrong, I haven't found it... yet.");
    783783        }
    784784    }
    785785
    786786    if (!found_it) {
    787         log_msg(4, "OK, approach 2");
     787        mr_msg(4, "OK, approach 2");
    788788        if (!(found_it = set_dev_to_this_if_rx_OK(output, "/dev/scd0"))) {
    789789            if (!(found_it = set_dev_to_this_if_rx_OK(output, "/dev/sr0"))) {
     
    828828    if (found_it && try_to_mount) {
    829829        if (mount_CDROM_here(output, mountpoint)) {
    830             log_msg(4, "[Cardigans] I've changed my mind");
     830            mr_msg(4, "[Cardigans] I've changed my mind");
    831831            found_it = FALSE;
    832832        } else {
    833833            sprintf(tmp, "%s/archives", mountpoint);
    834834            if (!does_file_exist(tmp)) {
    835                 log_msg(4, "[Cardigans] I'll take it back");
     835                mr_msg(4, "[Cardigans] I'll take it back");
    836836                found_it = FALSE;
    837837            } else {
    838838                sprintf(command, "umount %s", output);
    839839                paranoid_system(command);
    840                 log_msg(4, "I'm confident the Mondo CD is in %s", output);
     840                mr_msg(4, "I'm confident the Mondo CD is in %s", output);
    841841            }
    842842        }
     
    846846    if (found_it) {
    847847        if (!does_file_exist(output)) {
    848             log_msg(3, "I still haven't found it.");
     848            mr_msg(3, "I still haven't found it.");
    849849            return (1);
    850850        }
    851         log_msg(3, "(find_cdrom_device) --> '%s'", output);
     851        mr_msg(3, "(find_cdrom_device) --> '%s'", output);
    852852        strcpy(the_last_place_i_found_it, output);
    853853        strcpy(g_cdrom_drive_is_here, output);
     
    859859            "%s -scanbus | grep \"[0-9],[0-9],[0-9]\" | grep \"[D|C][V|D]\" | grep -n \"\" | grep \"%s\" | cut -d':' -f2",
    860860            cdr_exe, g_cdrw_drive_is_here);
    861     log_msg(1, "command=%s", command);
     861    mr_msg(1, "command=%s", command);
    862862    strcpy(tmp, call_program_and_get_last_line_of_output(command));
    863863    if (tmp[0]) {
    864864        strcpy(output, tmp);
    865         log_msg(4, "Finally found it at %s", output);
     865        mr_msg(4, "Finally found it at %s", output);
    866866        retval = 0;
    867867        goto end_of_find_cdrom_device;
    868868    } else {
    869         log_msg(4, "Still couldn't find it.");
     869        mr_msg(4, "Still couldn't find it.");
    870870        retval = 1;
    871871        goto end_of_find_cdrom_device;
     
    897897    if (g_dvd_drive_is_here[0]) {
    898898        strcpy(output, g_dvd_drive_is_here);
    899         log_msg(3, "Been there, done that. Returning %s", output);
     899        mr_msg(3, "Been there, done that. Returning %s", output);
    900900        return (0);
    901901    }
     
    904904            ("dvdrecord -scanbus 2> /dev/null | grep \") '\" | grep -n \"\" | grep DVD | cut -d':' -f1")
    905905        );
    906     log_msg(5, "tmp = '%s'", tmp);
     906    mr_msg(5, "tmp = '%s'", tmp);
    907907    if (!tmp[0])
    908908        sprintf(tmp, call_program_and_get_last_line_of_output
     
    916916        sprintf(output, "/dev/scd%d", devno);
    917917        strcpy(g_dvd_drive_is_here, output);
    918         log_msg(2, "I think DVD is at %s", output);
    919     } else {
    920         log_msg(2, "I cannot find DVD");
     918        mr_msg(2, "I think DVD is at %s", output);
     919    } else {
     920        mr_msg(2, "I cannot find DVD");
    921921        retval = 1;
    922922    }
    923923
    924924    if (try_to_mount) {
    925         log_msg(1, "Ignoring the fact that try_to_mount==TRUE");
     925        mr_msg(1, "Ignoring the fact that try_to_mount==TRUE");
    926926    }
    927927    return (retval);
     
    988988
    989989    if (outvalB <= 0) {
    990         log_msg(1, "Error getting size of %s: %s", drive, strerror(errno));
     990        mr_msg(1, "Error getting size of %s: %s", drive, strerror(errno));
    991991#if linux
    992992        fileid = open(drive, O_RDONLY);
     
    997997                    cylindersize = hdgeo.heads * hdgeo.sectors / 2;
    998998                    outvalA = cylindersize * cylinders / 1024;
    999                     log_msg(2, "Got Harddisk geometry, C:%d, H:%d, S:%d",
     999                    mr_msg(2, "Got Harddisk geometry, C:%d, H:%d, S:%d",
    10001000                            hdgeo.cylinders, hdgeo.heads, hdgeo.sectors);
    10011001                    gotgeo = 1;
    10021002                } else {
    1003                     log_msg(1, "Harddisk geometry wrong");
     1003                    mr_msg(1, "Harddisk geometry wrong");
    10041004                }
    10051005            } else {
    1006                 log_msg(1,
     1006                mr_msg(1,
    10071007                        "Error in ioctl() getting new hard disk geometry (%s), resizing in unsafe mode",
    10081008                        strerror(errno));
     
    10101010            close(fileid);
    10111011        } else {
    1012             log_msg(1, "Failed to open %s for reading: %s", drive,
     1012            mr_msg(1, "Failed to open %s for reading: %s", drive,
    10131013                    strerror(errno));
    10141014        }
    10151015        if (!gotgeo) {
    1016             log_msg(1, "Failed to get harddisk geometry, using old mode");
     1016            mr_msg(1, "Failed to get harddisk geometry, using old mode");
    10171017        }
    10181018/* 
     
    10201020      if (ioctl (fd, HDIO_GETGEO, &hdgeo) != -1)  {
    10211021      close (fd);
    1022       log_msg (2, "Geometry of drive %s is C:%d, H:%d, S%d, its size is %d MB", drive, hdgeo.cylinders, hdgeo.heads, hdgeo.sectors, (hdgeo.cylinders * hdgeo.heads * hdgeo.sectors / 2 / 1024));
     1022      mr_msg (2, "Geometry of drive %s is C:%d, H:%d, S%d, its size is %d MB", drive, hdgeo.cylinders, hdgeo.heads, hdgeo.sectors, (hdgeo.cylinders * hdgeo.heads * hdgeo.sectors / 2 / 1024));
    10231023      if ( hdgeo.cylinders && hdgeo.heads && hdgeo.sectors ) {
    10241024          outvalB = ((long) (hdgeo.cylinders * hdgeo.heads * hdgeo.sectors / 2 / 1024));
     
    10341034    outvalC = (outvalA > outvalB) ? outvalA : outvalB;
    10351035
    1036 //  log_msg (5, "drive = %s, error = %s", drive, strerror (errno));
     1036//  mr_msg (5, "drive = %s, error = %s", drive, strerror (errno));
    10371037//  fatal_error ("GPSOD: Unable to get size of drive");
    1038     log_msg(1, "%s --> %ld or %ld --> %ld", drive, outvalA, outvalB,
     1038    mr_msg(1, "%s --> %ld or %ld --> %ld", drive, outvalA, outvalB,
    10391039            outvalC);
    10401040
     
    10771077        close(fd);
    10781078    }
    1079     log_msg(4, "drive = %s, error = %s", drive, strerror(errno));
     1079    mr_msg(4, "drive = %s, error = %s", drive, strerror(errno));
    10801080    fatal_error("GPSOD: Unable to get size of drive");
    10811081#else
     
    10871087        if (ioctl(fd, HDIO_GETGEO, &hdgeo) != -1) {
    10881088            close(fd);
    1089             log_msg(2,
     1089            mr_msg(2,
    10901090                    "Geometry of drive %s is C:%d, H:%d, S%d, its size is %d MB",
    10911091                    drive, hdgeo.cylinders, hdgeo.heads, hdgeo.sectors,
     
    11611161    }
    11621162    if (!(p = strstr(tmp, "GB")) && !(p = strstr(tmp, "MB"))) {
    1163         log_msg(3, "Cannot find %s's size: dmesg isn't helping either.",
     1163        mr_msg(3, "Cannot find %s's size: dmesg isn't helping either.",
    11641164                drive);
    11651165        mr_free(tmp);
     
    12801280//  assert_string_is_neither_NULL_nor_zerolength(device_raw);
    12811281    if (device_raw[0] != '/' && !strstr(device_raw, ":/")) {
    1282         log_msg(1, "%s needs to have a '/' prefixed - I'll do it",
     1282        mr_msg(1, "%s needs to have a '/' prefixed - I'll do it",
    12831283                device_raw);
    12841284        sprintf(tmp, "/%s", device_raw);
     
    12861286        strcpy(tmp, device_raw);
    12871287    }
    1288     log_msg(1, "Is %s mounted?", tmp);
     1288    mr_msg(1, "Is %s mounted?", tmp);
    12891289    if (!strcmp(tmp, "/proc") || !strcmp(tmp, "proc")) {
    1290         log_msg(1,
     1290        mr_msg(1,
    12911291                "I don't know how the heck /proc made it into the mountlist. I'll ignore it.");
    12921292        return (0);
     
    13121312    sprintf(tmp, "%s | grep -E \"^%s\" > /dev/null 2> /dev/null",
    13131313            SWAPLIST_COMMAND, device_with_space);
    1314     log_msg(4, "tmp (command) = '%s'", tmp);
     1314    mr_msg(4, "tmp (command) = '%s'", tmp);
    13151315    if (!system(tmp)) {
    13161316        retval = 1;
     
    14341434
    14351435    }
    1436     log_msg(4, "(mount_CDROM_here --- device=%s, mountpoint=%s", device,
     1436    mr_msg(4, "(mount_CDROM_here --- device=%s, mountpoint=%s", device,
    14371437            mountpoint);
    14381438    /*@ end vars *************************************************** */
     
    14471447#endif
    14481448
    1449     log_msg(4, command);
     1449    mr_msg(4, command);
    14501450    if (strncmp(device, "/dev/", 5) == 0) {
    14511451        retract_CD_tray_and_defeat_autorun();
    14521452    }
    14531453    retval = system(command);
    1454     log_msg(1, "system(%s) returned %d", command, retval);
     1454    mr_msg(1, "system(%s) returned %d", command, retval);
    14551455
    14561456    mr_free(command);
     
    14911491    assert(cd_number_i_want > 0);
    14921492
    1493 //  log_msg(3, "Insisting on CD number %d", cd_number_i_want);
     1493//  mr_msg(3, "Insisting on CD number %d", cd_number_i_want);
    14941494
    14951495    if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
    1496         log_msg(3,
     1496        mr_msg(3,
    14971497                "No need to insist_on_this_cd_number when the backup type isn't CD-R(W) or NFS or ISO");
    14981498        return;
     
    15041504    if (g_ISO_restore_mode || bkpinfo->backup_media_type == iso
    15051505        || bkpinfo->backup_media_type == nfs) {
    1506         log_msg(3, "Remounting CD");
     1506        mr_msg(3, "Remounting CD");
    15071507        g_ISO_restore_mode = TRUE;
    15081508// FIXME --- I'm tempted to do something about this...
     
    15201520                    cd_number_i_want);
    15211521            if (does_file_exist(tmp)) {
    1522                 log_msg(1,
     1522                mr_msg(1,
    15231523                        "FIXME - hacking bkpinfo->isodir from '%s' to /tmp/isodir",
    15241524                        bkpinfo->isodir);
     
    15261526            }
    15271527        }
    1528         log_msg(3, "Mounting %s at %s", tmp, MNT_CDROM);
     1528        mr_msg(3, "Mounting %s at %s", tmp, MNT_CDROM);
    15291529        if (mount_CDROM_here(tmp, MNT_CDROM)) {
    15301530            fatal_error("Mommy!");
     
    15341534    }
    15351535    if ((res = what_number_cd_is_this(bkpinfo)) != cd_number_i_want) {
    1536         log_msg(3, "Currently, we hold %d but we want %d", res,
     1536        mr_msg(3, "Currently, we hold %d but we want %d", res,
    15371537                cd_number_i_want);
    15381538        sprintf(tmp, "Insisting on %s #%d",
     
    15421542                media_descriptor_string(bkpinfo->backup_media_type),
    15431543                cd_number_i_want);
    1544         log_msg(3, tmp);
     1544        mr_msg(3, tmp);
    15451545        while (what_number_cd_is_this(bkpinfo) != cd_number_i_want) {
    15461546            paranoid_system("sync");
     
    15681568            paranoid_system("sync");
    15691569        }
    1570         log_msg(1, "Thankyou. Proceeding...");
     1570        mr_msg(1, "Thankyou. Proceeding...");
    15711571        g_current_media_number = cd_number_i_want;
    15721572    }
     
    16271627        popup_and_OK("Please remove CD/floppy from drive(s)");
    16281628    }
    1629     log_msg(3, "media type = %s",
     1629    mr_msg(3, "media type = %s",
    16301630            bkptype_to_string(bkpinfo->backup_media_type));
    16311631    if (archiving_to_media) {
     
    16641664                strcpy(tmp, "1");
    16651665                sprintf(sz_size, "%d", DEFAULT_DVD_DISK_SIZE);  // 4.7 salesman's GB = 4.482 real GB = 4582 MB
    1666                 log_msg(1, "Setting to DVD defaults");
     1666                mr_msg(1, "Setting to DVD defaults");
    16671667            } else if (bkpinfo->backup_media_type == usb) {
    16681668                strcpy(bkpinfo->media_device, VANILLA_USB_DEVICE);
     
    16721672                strcpy(tmp, "4");
    16731673                strcpy(sz_size, "650");
    1674                 log_msg(1, "Setting to CD defaults");
     1674                mr_msg(1, "Setting to CD defaults");
    16751675            }
    16761676            if ((bkpinfo->backup_media_type != dvd) && (bkpinfo->backup_media_type != usb)) {
     
    16991699        if (bkpinfo->disaster_recovery) {
    17001700            strcpy(bkpinfo->media_device, "/dev/cdrom");
    1701             log_msg(2, "CD-ROM device assumed to be at %s",
     1701            mr_msg(2, "CD-ROM device assumed to be at %s",
    17021702                    bkpinfo->media_device);
    17031703        } else if (bkpinfo->restore_data
     
    17061706                strcpy(bkpinfo->media_device, "/dev/cdrom");
    17071707            }                   // just for the heck of it :)
    1708             log_msg(1, "bkpinfo->media_device = %s",
     1708            mr_msg(1, "bkpinfo->media_device = %s",
    17091709                    bkpinfo->media_device);
    17101710            if (bkpinfo->backup_media_type == dvd
    17111711                || find_cdrom_device(bkpinfo->media_device, FALSE)) {
    1712                 log_msg(1, "bkpinfo->media_device = %s",
     1712                mr_msg(1, "bkpinfo->media_device = %s",
    17131713                        bkpinfo->media_device);
    17141714                sprintf(comment,
     
    17231723                }
    17241724            }
    1725             log_msg(2, "%s device found at %s",
     1725            mr_msg(2, "%s device found at %s",
    17261726                    media_descriptor_string(bkpinfo->backup_media_type),
    17271727                    bkpinfo->media_device);
     
    17731773
    17741774        if (find_tape_device_and_size(bkpinfo->media_device, sz_size)) {
    1775             log_msg(3, "Ok, using vanilla scsi tape.");
     1775            mr_msg(3, "Ok, using vanilla scsi tape.");
    17761776            strcpy(bkpinfo->media_device, VANILLA_SCSI_TAPE);
    17771777            if ((fin = fopen(bkpinfo->media_device, "r"))) {
     
    18161816            finish(1);
    18171817        }
    1818         log_msg(4, "sz_size = %s", sz_size);
     1818        mr_msg(4, "sz_size = %s", sz_size);
    18191819        sz_size[0] = '\0';
    18201820/*
     
    18311831                friendly_sizestr_to_sizelong(sz_size) / 2 - 50;
    18321832        }
    1833         log_msg(4, "media_size[0] = %ld", bkpinfo->media_size[0]);
     1833        mr_msg(4, "media_size[0] = %ld", bkpinfo->media_size[0]);
    18341834        if (bkpinfo->media_size[0] <= 0) {
    18351835            bkpinfo->media_size[0] = 0;
     
    19591959            finish(1);
    19601960        }
    1961         log_msg(3, "prefix set to %s", bkpinfo->prefix);
     1961        mr_msg(3, "prefix set to %s", bkpinfo->prefix);
    19621962
    19631963        for (i = 0; i <= MAX_NOOF_MEDIA; i++) {
    19641964            bkpinfo->media_size[i] = 650;
    19651965        }
    1966         log_msg(3, "Just set nfs_remote_dir to %s",
     1966        mr_msg(3, "Just set nfs_remote_dir to %s",
    19671967                bkpinfo->nfs_remote_dir);
    1968         log_msg(3, "isodir is still %s", bkpinfo->isodir);
     1968        mr_msg(3, "isodir is still %s", bkpinfo->isodir);
    19691969        break;
    19701970
     
    20072007            finish(1);
    20082008        }
    2009         log_msg(3, "prefix set to %s", bkpinfo->prefix);
     2009        mr_msg(3, "prefix set to %s", bkpinfo->prefix);
    20102010        break;
    20112011    default:
     
    21462146                bkpinfo->nfs_mount);
    21472147//      strcpy(bkpinfo->isodir, call_program_and_get_last_line_of_output(tmp));
    2148         log_msg(3, "I think the NFS mount is mounted at %s",
     2148        mr_msg(3, "I think the NFS mount is mounted at %s",
    21492149                bkpinfo->isodir);
    21502150    }
     
    21692169            fatal_error("Media size is less than zero.");
    21702170        } else {
    2171             log_msg(2, "Warning - media size is less than zero.");
     2171            mr_msg(2, "Warning - media size is less than zero.");
    21722172            bkpinfo->media_size[0] = 0;
    21732173        }
     
    23542354    }
    23552355//  assert_string_is_neither_NULL_nor_zerolength(dev);
    2356     log_msg(10, "Injecting %s", dev);
     2356    mr_msg(10, "Injecting %s", dev);
    23572357    inject_device(dev);
    23582358    if (!does_file_exist(dev)) {
    2359         log_msg(10, "%s doesn't exist. Returning FALSE.", dev);
     2359        mr_msg(10, "%s doesn't exist. Returning FALSE.", dev);
    23602360        return (FALSE);
    23612361    }
     
    23652365        && !run_program_and_log_output(command, FALSE)) {
    23662366        strcpy(output, dev);
    2367         log_msg(4, "Found it - %s", dev);
     2367        mr_msg(4, "Found it - %s", dev);
    23682368        return (TRUE);
    23692369    } else {
    23702370        output[0] = '\0';
    2371         log_msg(4, "It's not %s", dev);
     2371        mr_msg(4, "It's not %s", dev);
    23722372        return (FALSE);
    23732373    }
     
    26462646        lstat(curr_fname, &statbuf);
    26472647        while (S_ISLNK(statbuf.st_mode)) {
    2648             log_msg(1, "curr_fname = %s", curr_fname);
     2648            mr_msg(1, "curr_fname = %s", curr_fname);
    26492649            sprintf(command, "file %s", curr_fname);
    26502650            strcpy(tmp, call_program_and_get_last_line_of_output(command));
     
    26552655            for (p = scratch; *p != '\0' && *p != '\''; p++);
    26562656            *p = '\0';
    2657             log_msg(0, "curr_fname %s --> '%s' --> %s", curr_fname, tmp,
     2657            mr_msg(0, "curr_fname %s --> '%s' --> %s", curr_fname, tmp,
    26582658                    scratch);
    26592659            if (scratch[0] == '/') {
     
    26982698    malloc_string(command);
    26992699    malloc_string(fdisk);
    2700     log_msg(0, "Looking for partition table format type");
     2700    mr_msg(0, "Looking for partition table format type");
    27012701    sprintf(fdisk, "/sbin/parted2fdisk");
    2702     log_msg(1, "Using %s", fdisk);
     2702    mr_msg(1, "Using %s", fdisk);
    27032703    sprintf(command, "%s -l %s | grep 'EFI GPT'", fdisk, drive);
    27042704    strcpy(tmp, call_program_and_get_last_line_of_output(command));
     
    27082708        strcpy(output, "GPT");
    27092709    }
    2710     log_msg(0, "Found %s partition table format type", output);
     2710    mr_msg(0, "Found %s partition table format type", output);
    27112711    mr_free(command);
    27122712    mr_free(tmp);
Note: See TracChangeset for help on using the changeset viewer.