Changeset 900 in MondoRescue for trunk/mondo/src/common/libmondo-raid.c


Ignore:
Timestamp:
Oct 24, 2006, 8:49:18 AM (18 years ago)
Author:
Bruno Cornec
Message:

Huge patch to introduce low level functions that will bw used everywhere (mr_free, mr_asprintf, ...)
Nearly linking now due to that.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/mondo/src/common/libmondo-raid.c

    r839 r900  
    99
    1010#include "my-stuff.h"
    11 #include "mr_string.h"
     11#include "mr_str.h"
    1212#include "mondostructures.h"
    1313#include "newt-specific-EXT.h"
    … …  
    1616#include "libmondo-string-EXT.h"
    1717#include "libmondo-raid.h"
    18 #include "mr_string.h"
     18#include "mr_mem.h"
    1919
    2020#ifdef __FreeBSD__
    … …  
    4949
    5050    if (raidno == -1) {
    51         asprintf(&command,
     51        mr_asprintf(&command,
    5252                 "grep \"linear\" /proc/mdstat > /dev/null 2> /dev/null");
    5353    } else {
    54         asprintf(&command,
     54        mr_asprintf(&command,
    5555                 "grep \"raid%d\" /proc/mdstat > /dev/null 2> /dev/null",
    5656                 raidno);
    … …  
    5858    log_it("Is raid %d registered? Command = '%s'", raidno, command);
    5959    res = system(command);
    60     paranoid_free(command);
     60    mr_free(command);
    6161    if (res) {
    6262        return (FALSE);
    … …  
    185185    assert(label != NULL);
    186186
    187     asprintf(&sz_value, "%d", value);
    188     asprintf(&sz_label,label);
     187    mr_asprintf(&sz_value, "%d", value);
     188    mr_asprintf(&sz_label,label);
    189189    raidrec->additional_vars.el[lino].value = sz_value;
    190190    raidrec->additional_vars.el[lino].label = sz_label;
    … …  
    320320        switch (raidrec->plex[i].raidlevel) {
    321321        case -1:
    322             asprintf(&org, "%s", "concat");
     322            mr_asprintf(&org, "%s", "concat");
    323323            break;
    324324        case 0:
    325             asprintf(&org, "%s", "striped");
     325            mr_asprintf(&org, "%s", "striped");
    326326            break;
    327327        case 5:
    328             asprintf(&org, "%s", "raid5");
     328            mr_asprintf(&org, "%s", "raid5");
    329329            break;
    330330        }
    331331        fprintf(fout, "  plex org %s", org);
    332         paranoid_free(org);
     332        mr_free(org);
    333333
    334334        if (raidrec->plex[i].raidlevel != -1) {
    … …  
    418418    }
    419419
    420     for (getline(&incoming, &n, fin); !feof(fin);
    421          getline(&incoming, &n, fin)) {
     420    for (mr_getline(&incoming, &n, fin); !feof(fin);
     421         mr_getline(&incoming, &n, fin)) {
    422422        strip_spaces(incoming);
    423423        p = strchr(incoming, ' ');
    … …  
    433433        return (0);
    434434    }
    435     paranoid_free(incoming);
     435    mr_free(incoming);
    436436    return (1);
    437437}
    … …  
    563563    fclose(fin);
    564564    log_it("Raidtab loaded successfully.");
    565     asprintf(&tmp1, "%d RAID devices in raidtab", raidlist->entries);
     565    mr_asprintf(&tmp1, "%d RAID devices in raidtab", raidlist->entries);
    566566    log_it(tmp1);
    567     paranoid_free(tmp1);
     567    mr_free(tmp1);
    568568    return (0);
    569569}
    … …  
    700700        }
    701701        if (!disklist) {
    702             asprintf(&tmp,
     702            mr_asprintf(&tmp,
    703703                     "Ignoring '%s %s' pair of disk %s", labelB, valueB,
    704704                     label);
    705705            log_it(tmp);
    706             paranoid_free(tmp);
     706            mr_free(tmp);
    707707        } else {
    708708            index = atoi(valueB);
    709709            add_disk_to_raid_device(disklist, value, index);
    710710        }
    711         paranoid_free(labelB);
    712         paranoid_free(valueB);
     711        mr_free(labelB);
     712        mr_free(valueB);
    713713    } else {
    714714        v = raidrec->additional_vars.entries;
    … …  
    773773    int lastpos = 0;
    774774
    775     getline(&line, &n, f);
     775    mr_getline(&line, &n, f);
    776776    if (feof(f)) {
    777777        log_it("[GNVCL] Uh... I reached the EOF.");
    … …  
    933933
    934934  FILE   *fin;
    935   int    res = 0, row, i, index_min;
     935  int    row, i, index_min;
    936936  int lastpos = 0;
    937937  size_t len = 0;
    … …  
    952952  row = 1;
    953953  // skip first output row - contains registered RAID levels
    954   res = getline(&string, &len, fin);
     954  mr_getline(&string, &len, fin);
    955955  // parse the rest
    956956  while ( !feof_unlocked(fin) ) {
    957     res = getline(&string, &len, fin);
    958     if (res <= 0) break;
     957    mr_getline(&string, &len, fin);
    959958    // trim leading spaces
    960959    pos = string;
    961960    while (*pos == ' ') pos++;
    962     asprintf(&strtmp, pos);
    963     paranoid_alloc(string,strtmp);
    964     paranoid_free(strtmp);
     961    mr_asprintf(&strtmp, pos);
     962    mr_allocstr(string,strtmp);
     963    mr_free(strtmp);
    965964    // if we have newline after only spaces, this is a blank line, update
    966965    // counters, otherwise do normal parsing
    … …  
    981980    token = mr_strtok (string, delims, &lastpos);
    982981    // get RAID device name
    983     asprintf(&strtmp,"%s%s", device_prefix, token);
     982    mr_asprintf(&strtmp,"%s%s", device_prefix, token);
    984983    raidlist->el[raidlist->entries].raid_device = strtmp;
    985     paranoid_free(token);
     984    mr_free(token);
    986985    // skip ':' and status
    987986    token = mr_strtok (string, delims, &lastpos);
    988     paranoid_free(token);
     987    mr_free(token);
    989988    token = mr_strtok (string, delims, &lastpos);
    990989    if (!strcmp(token, "inactive")) {
    991990      log_msg(1, "RAID device '%s' inactive.\n",
    992991         raidlist->el[raidlist->entries].raid_device);
    993       paranoid_free(string);
    994       paranoid_free(token);
     992      mr_free(string);
     993      mr_free(token);
    995994      return 1;
    996995    }
    997     paranoid_free(token);
     996    mr_free(token);
    998997
    999998    // get RAID level
    … …  
    10171016    } else {
    10181017      log_msg(1, "Unknown RAID level '%s'.\n", token);
    1019       paranoid_free(string);
    1020       paranoid_free(token);
     1018      mr_free(string);
     1019      mr_free(token);
    10211020      return 1;
    10221021    }
    1023     paranoid_free(token);
     1022    mr_free(token);
    10241023
    10251024    // get RAID devices (type, index, device)
    … …  
    10391038      case ' ': // normal data disks
    10401039        raidlist->el[raidlist->entries].data_disks.el[raidlist->el[raidlist->entries].data_disks.entries].index = atoi(pos + 1);
    1041         asprintf(&strtmp,"%s%s", device_prefix, token);
     1040        mr_asprintf(&strtmp,"%s%s", device_prefix, token);
    10421041        strcpy(raidlist->el[raidlist->entries].data_disks.el[raidlist->el[raidlist->entries].data_disks.entries].device, strtmp);
    1043         paranoid_free(strtmp);
     1042        mr_free(strtmp);
    10441043        raidlist->el[raidlist->entries].data_disks.entries++;
    10451044        break;
    10461045      case 'S': // spare disks
    10471046        raidlist->el[raidlist->entries].spare_disks.el[raidlist->el[raidlist->entries].spare_disks.entries].index = atoi(pos + 1);
    1048         asprintf(&strtmp,"%s%s", device_prefix, token);
     1047        mr_asprintf(&strtmp,"%s%s", device_prefix, token);
    10491048        strcpy(raidlist->el[raidlist->entries].spare_disks.el[raidlist->el[raidlist->entries].spare_disks.entries].device, strtmp);
    1050         paranoid_free(strtmp);
     1049        mr_free(strtmp);
    10511050        raidlist->el[raidlist->entries].spare_disks.entries++;
    10521051        break;
    10531052      case 'F': // failed disks
    10541053        raidlist->el[raidlist->entries].failed_disks.el[raidlist->el[raidlist->entries].failed_disks.entries].index = atoi(pos + 1);
    1055         asprintf(&strtmp,"%s%s", device_prefix, token);
     1054        mr_asprintf(&strtmp,"%s%s", device_prefix, token);
    10561055        strcpy(raidlist->el[raidlist->entries].failed_disks.el[raidlist->el[raidlist->entries].failed_disks.entries].device, strtmp);
    1057         paranoid_free(strtmp);
     1056        mr_free(strtmp);
    10581057        raidlist->el[raidlist->entries].failed_disks.entries++;
    10591058        log_it("At least one failed disk found in RAID array.\n");
    … …  
    10611060      default: // error
    10621061        log_msg(1, "Unknown device type '%c'\n", type);
    1063         paranoid_free(string);
    1064         paranoid_free(token);
     1062        mr_free(string);
     1063        mr_free(token);
    10651064        return 1;
    10661065        break;
    10671066      }
    1068       paranoid_free(token);
     1067      mr_free(token);
    10691068    }
    10701069
    … …  
    11191118        if (pos < string) {
    11201119          log_it("String underflow!\n");
    1121           paranoid_free(string);
     1120          mr_free(string);
    11221121          return 1;
    11231122        }
    … …  
    11441143        if (pos < string) {
    11451144          printf("ERROR: String underflow!\n");
    1146           paranoid_free(string);
     1145          mr_free(string);
    11471146          return 1;
    11481147        }
    … …  
    11611160  fclose(fin);
    11621161  // free string
    1163   paranoid_free(string);
     1162  mr_free(string);
    11641163  // return success
    11651164  return 0;
Note: See TracChangeset for help on using the changeset viewer.