Ignore:
Timestamp:
Sep 25, 2013, 8:55:39 AM (11 years ago)
Author:
Bruno Cornec
Message:
  • Backport tons of dynamic memory management rewrite from 3.1 branch. Test is needed
File:
1 edited

Legend:

Unmodified
Added
Removed

  • branches/3.0/mondo/src/common/libmondo-raid.c

    r3185 r3188  
    335335#ifdef __FreeBSD__
    336336    int i, j;
     337    char *org = NULL;
    337338
    338339    fprintf(fout, "\nvolume %s\n", raidrec->volname);
    339340    for (i = 0; i < raidrec->plexes; ++i) {
    340         char org[24];
    341341        switch (raidrec->plex[i].raidlevel) {
    342342        case -1:
    343             strcpy(org, "concat");
     343            mr_asprintf(org, "concat");
    344344            break;
    345345        case 0:
    346             strcpy(org, "striped");
     346            mr_asprintf(org, "striped");
    347347            break;
    348348        case 5:
    349             strcpy(org, "raid5");
     349            mr_asprintf(org, "raid5");
    350350            break;
    351351        }
    352352        fprintf(fout, "  plex org %s", org);
     353        mr_free(org);
     354
    353355        if (raidrec->plex[i].raidlevel != -1) {
    354356            fprintf(fout, " %ik", raidrec->plex[i].stripesize);
    … …  
    357359
    358360        for (j = 0; j < raidrec->plex[i].subdisks; ++j) {
    359             fprintf(fout, "    sd drive %s size 0\n",
    360                     raidrec->plex[i].sd[j].which_device);
     361            fprintf(fout, "    sd drive %s size 0\n", raidrec->plex[i].sd[j].which_device);
    361362        }
    362363    }
    … …  
    427428int get_next_raidtab_line(FILE * fin, char *label, char *value)
    428429{
    429     char *incoming;
     430    char *incoming = NULL;
    430431    char *p;
    431     char *q;
    432 
    433     malloc_string(incoming);
     432
    434433    assert(fin != NULL);
    435434    assert(label != NULL);
    … …  
    438437    label[0] = value[0] = '\0';
    439438    if (feof(fin)) {
    440         paranoid_free(incoming);
    441439        return (1);
    442440    }
    443     for (q = fgets(incoming, MAX_STR_LEN - 1, fin); !feof(fin) && (q != NULL);
    444          q = fgets(incoming, MAX_STR_LEN - 1, fin)) {
    445         strip_spaces(incoming);
     441    for (mr_getline(incoming, fin); !feof(fin); mr_getline(incoming, fin)) {
     442        mr_strip_spaces(incoming);
    446443        p = strchr(incoming, ' ');
    447444        if (strlen(incoming) < 3 || incoming[0] == '#' || !p) {
     445            mr_free(incoming);
    448446            continue;
    449447        }
    … …  
    454452        strcpy(label, incoming);
    455453        strcpy(value, p);
    456         paranoid_free(incoming);
     454        mr_free(incoming);
    457455        return (0);
    458456    }
     457    mr_free(incoming);
    459458    return (1);
    460459}
    … …  
    473472{
    474473    FILE *fin;
    475     char *tmp1 = NULL;
    476474    int items;
    477475
    … …  
    504502
    505503            if (get_option_state(argc, argv, "hotspare")) {
    506                 strcpy(raidlist->spares.el[raidlist->spares.entries].name,
    507                        drivename);
    508                 strcpy(raidlist->spares.el[raidlist->spares.entries].
    509                        device, devname);
     504                strcpy(raidlist->spares.el[raidlist->spares.entries].name, drivename);
     505                strcpy(raidlist->spares.el[raidlist->spares.entries].  device, devname);
    510506                raidlist->spares.el[raidlist->spares.entries].index =
    511507                    raidlist->disks.entries;
    512508                raidlist->spares.entries++;
    513509            } else {
    514                 strcpy(raidlist->disks.el[raidlist->disks.entries].name,
    515                        drivename);
    516                 strcpy(raidlist->disks.el[raidlist->disks.entries].device,
    517                        devname);
     510                strcpy(raidlist->disks.el[raidlist->disks.entries].name, drivename);
     511                strcpy(raidlist->disks.el[raidlist->disks.entries].device, devname);
    518512                raidlist->disks.el[raidlist->disks.entries].index =
    519513                    raidlist->disks.entries;
    … …  
    587581    fclose(fin);
    588582    log_it("Raidtab loaded successfully.");
    589     mr_asprintf(tmp1, "%d RAID devices in raidtab", raidlist->entries);
    590     log_it(tmp1);
    591     mr_free(tmp1);
     583    log_it("%d RAID devices in raidtab", raidlist->entries);
    592584    return (0);
    593585}
    … …  
    596588#else
    597589
    598 int load_raidtab_into_raidlist(struct raidlist_itself *raidlist,
    599                                char *fname)
    600 {
    601     FILE *fin;
    602     char *label;
    603     char *value;
     590int load_raidtab_into_raidlist(struct raidlist_itself *raidlist, char *fname) {
     591
     592    FILE *fin = NULL;
     593    char *label = NULL;
     594    char *value = NULL;
    604595    int items;
    605596    int v;
    … …  
    680671
    681672    /*@ add mallocs * */
    682     char *tmp = NULL;
    683673    char *labelB;
    684674    char *valueB;
    … …  
    739729        }
    740730        if (!disklist) {
    741             mr_asprintf(tmp, "Ignoring '%s %s' pair of disk %s", labelB, valueB, label);
    742             log_it(tmp);
    743             mr_free(tmp);
     731            log_it("Ignoring '%s %s' pair of disk %s", labelB, valueB, label);
    744732        } else {
    745733            index = atoi(valueB);
    … …  
    811799    static char *argv[64];
    812800    char **ap;
    813     char *q;
    814     char *line = (char *) malloc(MAX_STR_LEN);
    815 
    816     if (!line)
    817         errx(1,
    818              "unable to allocate %i bytes of memory for `char *line' at %s:%i",
    819              MAX_STR_LEN, __FILE__, __LINE__);
    820     q = fgets(line, MAX_STR_LEN, f);
    821     if (feof(f) && (q != NULL)) {
     801    char *line = NULL;
     802
     803    mr_getline(line, f);
     804    if (feof(f)) {
    822805        log_it("[GNVCL] Uh... I reached the EOF.");
    823806        return 0;
    … …  
    830813            cnt++;
    831814        }
     815    mr_free(line);
    832816
    833817    if (strchr(argv[cnt - 1], '\n')) {
    … …  
    11191103            while((token = mr_strtok (string, delims, &lastpos))) {
    11201104                if ((pos = strstr(token, "("))) {
    1121                     type = *(pos+1);
     1105                    type = *(pos+1);
    11221106                } else {
    1123                     type = ' ';
     1107                    type = ' ';
    11241108                }
    11251109                pos = strstr(token, "[");
    … …  
    11271111                switch(type) {
    11281112                case ' ': // normal data disks
    1129                     raidlist->el[raidlist->entries].data_disks.el[raidlist->el[raidlist->entries].data_disks.entries].index = atoi(pos + 1);
    1130                     mr_asprintf(strtmp,"%s%s", device_prefix, token);
    1131                     strcpy(raidlist->el[raidlist->entries].data_disks.el[raidlist->el[raidlist->entries].data_disks.entries].device, strtmp);
    1132                     mr_free(strtmp);
    1133                     raidlist->el[raidlist->entries].data_disks.entries++;
    1134                     break;
     1113                    raidlist->el[raidlist->entries].data_disks.el[raidlist->el[raidlist->entries].data_disks.entries].index = atoi(pos + 1);
     1114                    mr_asprintf(strtmp,"%s%s", device_prefix, token);
     1115                    strcpy(raidlist->el[raidlist->entries].data_disks.el[raidlist->el[raidlist->entries].data_disks.entries].device, strtmp);
     1116                    mr_free(strtmp);
     1117                    raidlist->el[raidlist->entries].data_disks.entries++;
     1118                    break;
    11351119                case 'S': // spare disks
    1136                     raidlist->el[raidlist->entries].spare_disks.el[raidlist->el[raidlist->entries].spare_disks.entries].index = atoi(pos + 1);
    1137                     mr_asprintf(strtmp,"%s%s", device_prefix, token);
    1138                     strcpy(raidlist->el[raidlist->entries].spare_disks.el[raidlist->el[raidlist->entries].spare_disks.entries].device, strtmp);
    1139                     mr_free(strtmp);
    1140                     raidlist->el[raidlist->entries].spare_disks.entries++;
    1141                     break;
     1120                    raidlist->el[raidlist->entries].spare_disks.el[raidlist->el[raidlist->entries].spare_disks.entries].index = atoi(pos + 1);
     1121                    mr_asprintf(strtmp,"%s%s", device_prefix, token);
     1122                    strcpy(raidlist->el[raidlist->entries].spare_disks.el[raidlist->el[raidlist->entries].spare_disks.entries].device, strtmp);
     1123                    mr_free(strtmp);
     1124                    raidlist->el[raidlist->entries].spare_disks.entries++;
     1125                    break;
    11421126                case 'F': // failed disks
    1143                     raidlist->el[raidlist->entries].failed_disks.el[raidlist->el[raidlist->entries].failed_disks.entries].index = atoi(pos + 1);
    1144                     mr_asprintf(strtmp,"%s%s", device_prefix, token);
    1145                     strcpy(raidlist->el[raidlist->entries].failed_disks.el[raidlist->el[raidlist->entries].failed_disks.entries].device, strtmp);
    1146                     mr_free(strtmp);
    1147                     raidlist->el[raidlist->entries].failed_disks.entries++;
    1148                     log_it("At least one failed disk found in RAID array.\n");
    1149                     break;
     1127                    raidlist->el[raidlist->entries].failed_disks.el[raidlist->el[raidlist->entries].failed_disks.entries].index = atoi(pos + 1);
     1128                    mr_asprintf(strtmp,"%s%s", device_prefix, token);
     1129                    strcpy(raidlist->el[raidlist->entries].failed_disks.el[raidlist->el[raidlist->entries].failed_disks.entries].device, strtmp);
     1130                    mr_free(strtmp);
     1131                    raidlist->el[raidlist->entries].failed_disks.entries++;
     1132                    log_it("At least one failed disk found in RAID array.\n");
     1133                    break;
    11501134                default: // error
    1151                     log_msg(1, "Unknown device type '%c'\n", type);
    1152                     mr_free(string);
    1153                     mr_free(token);
    1154                     return 1;
    1155                     break;
     1135                    log_msg(1, "Unknown device type '%c'\n", type);
     1136                    mr_free(string);
     1137                    mr_free(token);
     1138                    return 1;
     1139                    break;
    11561140                }
    11571141                mr_free(token);
    … …  
    11621146            for (i=0; i<raidlist->el[raidlist->entries].data_disks.entries;i++) {
    11631147                if (raidlist->el[raidlist->entries].data_disks.el[i].index < index_min) {
    1164                     index_min = raidlist->el[raidlist->entries].data_disks.el[i].index;
     1148                    index_min = raidlist->el[raidlist->entries].data_disks.el[i].index;
    11651149                }
    11661150            }
    11671151            if (index_min > 0) {
    11681152                for (i=0; i<raidlist->el[raidlist->entries].data_disks.entries;i++) {
    1169                     raidlist->el[raidlist->entries].data_disks.el[i].index = raidlist->el[raidlist->entries].data_disks.el[i].index - index_min;   
     1153                    raidlist->el[raidlist->entries].data_disks.el[i].index = raidlist->el[raidlist->entries].data_disks.el[i].index - index_min;   
    11701154                }
    11711155            }
    … …  
    11731157            for (i=0; i<raidlist->el[raidlist->entries].spare_disks.entries;i++) {
    11741158                if (raidlist->el[raidlist->entries].spare_disks.el[i].index < index_min) {
    1175                     index_min = raidlist->el[raidlist->entries].spare_disks.el[i].index;
     1159                    index_min = raidlist->el[raidlist->entries].spare_disks.el[i].index;
    11761160                }
    11771161            }
    11781162            if (index_min > 0) {
    11791163                for (i=0; i<raidlist->el[raidlist->entries].spare_disks.entries;i++) {
    1180                     raidlist->el[raidlist->entries].spare_disks.el[i].index = raidlist->el[raidlist->entries].spare_disks.el[i].index - index_min; 
     1164                        raidlist->el[raidlist->entries].spare_disks.el[i].index = raidlist->el[raidlist->entries].spare_disks.el[i].index - index_min; 
    11811165                }
    11821166            }
    … …  
    11841168            for (i=0; i<raidlist->el[raidlist->entries].failed_disks.entries;i++) {
    11851169                if (raidlist->el[raidlist->entries].failed_disks.el[i].index < index_min) {
    1186                     index_min = raidlist->el[raidlist->entries].failed_disks.el[i].index;
     1170                    index_min = raidlist->el[raidlist->entries].failed_disks.el[i].index;
    11871171                }
    11881172            }
    11891173            if (index_min > 0) {
    11901174                for (i=0; i<raidlist->el[raidlist->entries].failed_disks.entries;i++) {
    1191                     raidlist->el[raidlist->entries].failed_disks.el[i].index = raidlist->el[raidlist->entries].failed_disks.el[i].index - index_min;   
     1175                        raidlist->el[raidlist->entries].failed_disks.el[i].index = raidlist->el[raidlist->entries].failed_disks.el[i].index - index_min;   
    11921176                }
    11931177            }
    … …  
    12051189            } else {
    12061190                while (*pos != ' ') {
    1207                     pos -= 1;
    1208                     if (pos < string) {
    1209                             log_it("String underflow!\n");
    1210                             mr_free(string);
    1211                             return 1;
    1212                     }
     1191                    pos -= 1;
     1192                    if (pos < string) {
     1193                        log_it("String underflow!\n");
     1194                        mr_free(string);
     1195                        return 1;
     1196                    }
    12131197                }
    12141198                raidlist->el[raidlist->entries].chunk_size = atoi(pos + 1);
    … …  
    12241208            if (!(pos = strchr(string, '\%'))) {
    12251209                if (strcasestr(string, "delayed")) {
    1226                     raidlist->el[raidlist->entries].progress = -1;  // delayed (therefore, stuck at 0%)
     1210                    raidlist->el[raidlist->entries].progress = -1;  // delayed (therefore, stuck at 0%)
    12271211                } else {
    1228                     raidlist->el[raidlist->entries].progress = 999; // not found
     1212                    raidlist->el[raidlist->entries].progress = 999; // not found
    12291213                }
    12301214            } else {
    12311215                while (*pos != ' ') {
    1232                     pos -= 1;
    1233                     if (pos < string) {
    1234                         printf("ERROR: String underflow!\n");
    1235                             mr_free(string);
    1236                             return 1;
    1237                     }
     1216                    pos -= 1;
     1217                    if (pos < string) {
     1218                        printf("ERROR: String underflow!\n");
     1219                        mr_free(string);
     1220                        return 1;
     1221                    }
    12381222                }
    12391223                raidlist->el[raidlist->entries].progress = atoi(pos);
    12401224            }
    12411225            break;
    1242         default: // error or IN PROGRESS
     1226        default: // error or IN PROGRESS
    12431227            if (raidlist->el[raidlist->entries].progress != -1 &&
    12441228                raidlist->el[raidlist->entries].progress != 999) {
    … …  
    12461230            }
    12471231            break;
    1248         }
    1249         row++;
     1232        }
     1233    row++;
    12501234    }
    12511235    // free string
Note: See TracChangeset for help on using the changeset viewer.