program/src/rrd_resize.c

   1 /*****************************************************************************
   2  * RRDtool 1.3.8  Copyright by Tobi Oetiker, 1997-2009
   3  *****************************************************************************
   4  * rrd_resize.c Alters size of an RRA
   5  *****************************************************************************
   6  * Initial version by Alex van den Bogaerdt
   7  *****************************************************************************/
   8
   9 #include "rrd_tool.h"
  10
  11 #ifdef WIN32
  12 #include <stdlib.h>
  13 #endif
  14
  15 int rrd_resize(
  16     int argc,
  17     char **argv)
  18 {
  19     char     *infilename, outfilename[11] = "resize.rrd";
  20     rrd_t     rrdold, rrdnew;
  21     rrd_value_t buffer;
  22     int       version;
  23     unsigned long l, rra;
  24     long      modify;
  25     unsigned long target_rra;
  26     int       grow = 0, shrink = 0;
  27     char     *endptr;
  28     rrd_file_t *rrd_file, *rrd_out_file;
  29
  30     infilename = argv[1];
  31     if (!strcmp(infilename, "resize.rrd")) {
  32         rrd_set_error("resize.rrd is a reserved name");
  33         return (-1);
  34     }
  35     if (argc != 5) {
  36         rrd_set_error("wrong number of parameters");
  37         return (-1);
  38     }
  39
  40     target_rra = strtol(argv[2], &endptr, 0);
  41
  42     if (!strcmp(argv[3], "GROW"))
  43         grow = 1;
  44     else if (!strcmp(argv[3], "SHRINK"))
  45         shrink = 1;
  46     else {
  47         rrd_set_error("I can only GROW or SHRINK");
  48         return (-1);
  49     }
  50
  51     modify = strtol(argv[4], &endptr, 0);
  52
  53     if ((modify < 1)) {
  54         rrd_set_error("Please grow or shrink with at least 1 row");
  55         return (-1);
  56     }
  57
  58     if (shrink)
  59         modify = -modify;
  60
  61
  62     rrd_file = rrd_open(infilename, &rrdold, RRD_READWRITE | RRD_COPY);
  63     if (rrd_file == NULL) {
  64         rrd_free(&rrdold);
  65         return (-1);
  66     }
  67
  68     if (rrd_lock(rrd_file) != 0) {
  69         rrd_set_error("could not lock original RRD");
  70         rrd_free(&rrdold);
  71         rrd_close(rrd_file);
  72         return (-1);
  73     }
  74
  75
  76     if (target_rra >= rrdold.stat_head->rra_cnt) {
  77         rrd_set_error("no such RRA in this RRD");
  78         rrd_free(&rrdold);
  79         rrd_close(rrd_file);
  80         return (-1);
  81     }
  82
  83     if (modify < 0)
  84         if ((long) rrdold.rra_def[target_rra].row_cnt <= -modify) {
  85             rrd_set_error("This RRA is not that big");
  86             rrd_free(&rrdold);
  87             rrd_close(rrd_file);
  88             return (-1);
  89         }
  90     /* the size of the new file */
  91     /* yes we are abusing the float cookie for this, aargh */
  92     if ((rrdnew.stat_head = (stat_head_t*)calloc(1, sizeof(stat_head_t))) == NULL) {
  93         rrd_set_error("allocating stat_head for new RRD");
  94         rrd_free(&rrdold);
  95         rrd_close(rrd_file);
  96         return (-1);
  97     }
  98     rrdnew.stat_head->float_cookie = rrd_file->file_len +
  99         (rrdold.stat_head->ds_cnt * sizeof(rrd_value_t) * modify);
 100     rrd_out_file = rrd_open(outfilename, &rrdnew, RRD_READWRITE | RRD_CREAT);
 101     if (rrd_out_file == NULL) {
 102         rrd_set_error("Can't create '%s': %s", outfilename,
 103                       rrd_strerror(errno));
 104         rrd_free(&rrdnew);
 105         rrd_free(&rrdold);
 106         rrd_close(rrd_file);
 107         rrd_close(rrd_out_file);
 108         return (-1);
 109     }
 110     if (rrd_lock(rrd_out_file) != 0) {
 111         rrd_set_error("could not lock new RRD");
 112         rrd_free(&rrdnew);
 113         rrd_free(&rrdold);
 114         rrd_close(rrd_file);
 115         rrd_close(rrd_out_file);
 116         return (-1);
 117     }
 118 /*XXX: do one write for those parts of header that are unchanged */
 119     if ((rrdnew.stat_head = (stat_head_t*)malloc(sizeof(stat_head_t))) == NULL) {
 120         rrd_set_error("allocating stat_head for new RRD");
 121         rrd_free(&rrdnew);
 122         rrd_free(&rrdold);
 123         rrd_close(rrd_file);
 124         rrd_close(rrd_out_file);
 125         return (-1);
 126     }
 127
 128     if ((rrdnew.rra_ptr = (rra_ptr_t*)malloc(sizeof(rra_ptr_t) * rrdold.stat_head->rra_cnt)) == NULL) {
 129         rrd_set_error("allocating rra_ptr for new RRD");
 130         rrd_free(&rrdnew);
 131         rrd_free(&rrdold);
 132         rrd_close(rrd_file);
 133         rrd_close(rrd_out_file);
 134         return (-1);
 135     }
 136
 137     if ((rrdnew.rra_def = (rra_def_t*)malloc(sizeof(rra_def_t) * rrdold.stat_head->rra_cnt)) == NULL) {
 138         rrd_set_error("allocating rra_def for new RRD");
 139         rrd_free(&rrdnew);
 140         rrd_free(&rrdold);
 141         rrd_close(rrd_file);
 142         rrd_close(rrd_out_file);
 143         return (-1);
 144     }
 145
 146     memcpy(rrdnew.stat_head,rrdold.stat_head,sizeof(stat_head_t));
 147     rrdnew.ds_def = rrdold.ds_def;
 148
 149     /* we are going to free rrdold later on, so make sure its not still pointing to the new stuff */
 150     rrdold.live_head = NULL;
 151     memcpy(rrdnew.rra_def,rrdold.rra_def,sizeof(rra_def_t) * rrdold.stat_head->rra_cnt);
 152     rrdnew.live_head = rrdold.live_head;
 153     rrdold.live_head = NULL;
 154     rrdnew.pdp_prep = rrdold.pdp_prep;
 155     rrdold.pdp_prep = NULL;
 156     rrdnew.cdp_prep = rrdold.cdp_prep;
 157     rrdold.cdp_prep = NULL;
 158     memcpy(rrdnew.rra_ptr,rrdold.rra_ptr,sizeof(rra_ptr_t) * rrdold.stat_head->rra_cnt);
 159
 160     version = atoi(rrdold.stat_head->version);
 161     switch (version) {
 162     case 4:
 163         break;
 164     case 3:
 165         break;
 166     case 1:
 167         rrdnew.stat_head->version[3] = '3';
 168         break;
 169     default:
 170         rrd_set_error("Do not know how to handle RRD version %s",
 171                       rrdold.stat_head->version);
 172         rrd_free(&rrdnew);
 173         rrd_free(&rrdold);
 174         rrd_close(rrd_file);
 175         rrd_close(rrd_out_file);
 176         return (-1);
 177         break;
 178     }
 179
 180 /* XXX: Error checking? */
 181     rrd_write(rrd_out_file, rrdnew.stat_head, sizeof(stat_head_t) * 1);
 182     rrd_write(rrd_out_file, rrdnew.ds_def,
 183               sizeof(ds_def_t) * rrdnew.stat_head->ds_cnt);
 184     rrd_write(rrd_out_file, rrdnew.rra_def,
 185               sizeof(rra_def_t) * rrdnew.stat_head->rra_cnt);
 186     rrd_write(rrd_out_file, rrdnew.live_head, sizeof(live_head_t) * 1);
 187     rrd_write(rrd_out_file, rrdnew.pdp_prep,
 188               sizeof(pdp_prep_t) * rrdnew.stat_head->ds_cnt);
 189     rrd_write(rrd_out_file, rrdnew.cdp_prep,
 190               sizeof(cdp_prep_t) * rrdnew.stat_head->ds_cnt *
 191               rrdnew.stat_head->rra_cnt);
 192     rrd_write(rrd_out_file, rrdnew.rra_ptr,
 193               sizeof(rra_ptr_t) * rrdnew.stat_head->rra_cnt);
 194
 195     /* Move the CDPs from the old to the new database.
 196      ** This can be made (much) faster but isn't worth the effort. Clarity
 197      ** is much more important.
 198      */
 199
 200     /* Move data in unmodified RRAs
 201      */
 202     l = 0;
 203     for (rra = 0; rra < target_rra; rra++) {
 204         l += rrdnew.stat_head->ds_cnt * rrdnew.rra_def[rra].row_cnt;
 205     }
 206     while (l > 0) {
 207         rrd_read(rrd_file, &buffer, sizeof(rrd_value_t) * 1);
 208         rrd_write(rrd_out_file, &buffer, sizeof(rrd_value_t) * 1);
 209         l--;
 210     }
 211     /* Move data in this RRA, either removing or adding some rows
 212      */
 213     if (modify > 0) {
 214         /* Adding extra rows; insert unknown values just after the
 215          ** current row number.
 216          */
 217         l = rrdnew.stat_head->ds_cnt *
 218             (rrdnew.rra_ptr[target_rra].cur_row + 1);
 219         while (l > 0) {
 220             rrd_read(rrd_file, &buffer, sizeof(rrd_value_t) * 1);
 221             rrd_write(rrd_out_file, &buffer, sizeof(rrd_value_t) * 1);
 222             l--;
 223         }
 224         buffer = DNAN;
 225         l = rrdnew.stat_head->ds_cnt * modify;
 226         while (l > 0) {
 227             rrd_write(rrd_out_file, &buffer, sizeof(rrd_value_t) * 1);
 228             l--;
 229         }
 230     } else {
 231         /* Removing rows. Normally this would be just after the cursor
 232          ** however this may also mean that we wrap to the beginning of
 233          ** the array.
 234          */
 235         signed long int remove_end = 0;
 236
 237         remove_end =
 238             (rrdnew.rra_ptr[target_rra].cur_row -
 239              modify) % rrdnew.rra_def[target_rra].row_cnt;
 240         if (remove_end <=
 241             (signed long int) rrdnew.rra_ptr[target_rra].cur_row) {
 242             while (remove_end >= 0) {
 243                 rrd_seek(rrd_file,
 244                          sizeof(rrd_value_t) * rrdnew.stat_head->ds_cnt,
 245                          SEEK_CUR);
 246                 rrdnew.rra_ptr[target_rra].cur_row--;
 247                 rrdnew.rra_def[target_rra].row_cnt--;
 248                 remove_end--;
 249                 modify++;
 250             }
 251             remove_end = rrdnew.rra_def[target_rra].row_cnt - 1;
 252         }
 253         for (l = 0; l <= rrdnew.rra_ptr[target_rra].cur_row; l++) {
 254             unsigned int tmp;
 255
 256             for (tmp = 0; tmp < rrdnew.stat_head->ds_cnt; tmp++) {
 257                 rrd_read(rrd_file, &buffer, sizeof(rrd_value_t) * 1);
 258                 rrd_write(rrd_out_file, &buffer, sizeof(rrd_value_t) * 1);
 259             }
 260         }
 261         while (modify < 0) {
 262             rrd_seek(rrd_file,
 263                      sizeof(rrd_value_t) * rrdnew.stat_head->ds_cnt,
 264                      SEEK_CUR);
 265             rrdnew.rra_def[target_rra].row_cnt--;
 266             modify++;
 267         }
 268     }
 269     /* Move the rest of the CDPs
 270      */
 271     while (1) {
 272         if (rrd_read(rrd_file, &buffer, sizeof(rrd_value_t) * 1) <= 0)
 273             break;
 274         rrd_write(rrd_out_file, &buffer, sizeof(rrd_value_t) * 1);
 275     }
 276     rrdnew.rra_def[target_rra].row_cnt += modify;
 277     rrd_seek(rrd_out_file,
 278              sizeof(stat_head_t) +
 279              sizeof(ds_def_t) * rrdnew.stat_head->ds_cnt, SEEK_SET);
 280     rrd_write(rrd_out_file, rrdnew.rra_def,
 281               sizeof(rra_def_t) * rrdnew.stat_head->rra_cnt);
 282     rrd_seek(rrd_out_file, sizeof(live_head_t), SEEK_CUR);
 283     rrd_seek(rrd_out_file, sizeof(pdp_prep_t) * rrdnew.stat_head->ds_cnt,
 284              SEEK_CUR);
 285     rrd_seek(rrd_out_file,
 286              sizeof(cdp_prep_t) * rrdnew.stat_head->ds_cnt *
 287              rrdnew.stat_head->rra_cnt, SEEK_CUR);
 288     rrd_write(rrd_out_file, rrdnew.rra_ptr,
 289               sizeof(rra_ptr_t) * rrdnew.stat_head->rra_cnt);
 290     rrd_close(rrd_file);
 291     rrd_close(rrd_out_file);
 292     rrd_free(&rrdold);
 293     rrd_free(&rrdnew);
 294     return (0);
 295 }