src/rrd_open.c

   1 /*****************************************************************************
   2  * RRDtool 1.2.23  Copyright by Tobi Oetiker, 1997-2007
   3  *****************************************************************************
   4  * rrd_open.c  Open an RRD File
   5  *****************************************************************************
   6  * $Id$
   7  * $Log$
   8  * Revision 1.10  2004/05/26 22:11:12  oetiker
   9  * reduce compiler warnings. Many small fixes. -- Mike Slifcak <slif@bellsouth.net>
  10  *
  11  * Revision 1.9  2003/04/29 21:56:49  oetiker
  12  * readline in rrd_open.c reads the file in 8 KB blocks, and calls realloc for
  13  * each block. realloc is very slow in Mac OS X for huge blocks, e.g. when
  14  * restoring databases from huge xml files. This patch finds the size of the
  15  * file, and starts out with malloc'ing the full size.
  16  * -- Peter Speck <speck@ruc.dk>
  17  *
  18  * Revision 1.8  2003/04/11 19:43:44  oetiker
  19  * New special value COUNT which allows calculations based on the position of a
  20  * value within a data set. Bug fix in rrd_rpncalc.c. PREV returned erroneus
  21  * value for the second value. Bug fix in rrd_restore.c. Bug causing seek error
  22  * when accesing an RRD restored from an xml that holds an RRD version <3.
  23  * --  Ruben Justo <ruben@ainek.com>
  24  *
  25  * Revision 1.7  2003/03/31 21:22:12  oetiker
  26  * enables RRDtool updates with microsecond or in case of windows millisecond
  27  * precision. This is needed to reduce time measurement error when archive step
  28  * is small. (<30s) --  Sasha Mikheev <sasha@avalon-net.co.il>
  29  *
  30  * Revision 1.6  2003/02/13 07:05:27  oetiker
  31  * Find attached the patch I promised to send to you. Please note that there
  32  * are three new source files (src/rrd_is_thread_safe.h, src/rrd_thread_safe.c
  33  * and src/rrd_not_thread_safe.c) and the introduction of librrd_th. This
  34  * library is identical to librrd, but it contains support code for per-thread
  35  * global variables currently used for error information only. This is similar
  36  * to how errno per-thread variables are implemented.  librrd_th must be linked
  37  * alongside of libpthred
  38  *
  39  * There is also a new file "THREADS", holding some documentation.
  40  *
  41  * -- Peter Stamfest <peter@stamfest.at>
  42  *
  43  * Revision 1.5  2002/06/20 00:21:03  jake
  44  * More Win32 build changes; thanks to Kerry Calvert.
  45  *
  46  * Revision 1.4  2002/02/01 20:34:49  oetiker
  47  * fixed version number and date/time
  48  *
  49  * Revision 1.3  2001/03/04 13:01:55  oetiker
  50  * Aberrant Behavior Detection support. A brief overview added to rrdtool.pod.
  51  * Major updates to rrd_update.c, rrd_create.c. Minor update to other core files.
  52  * This is backwards compatible! But new files using the Aberrant stuff are not readable
  53  * by old rrdtool versions. See http://cricket.sourceforge.net/aberrant/rrd_hw.htm
  54  * -- Jake Brutlag <jakeb@corp.webtv.net>
  55  *
  56  * Revision 1.2  2001/03/04 10:29:20  oetiker
  57  * fixed filedescriptor leak
  58  * -- Mike Franusich <mike@franusich.com>
  59  *
  60  * Revision 1.1.1.1  2001/02/25 22:25:05  oetiker
  61  * checkin
  62  *
  63  *****************************************************************************/
  64
  65 #include "rrd_tool.h"
  66 #include "unused.h"
  67 #define MEMBLK 8192
  68
  69 /* DEBUG 2 prints information obtained via mincore(2) */
  70 // #define DEBUG 2
  71 /* do not calculate exact madvise hints but assume 1 page for headers and
  72  * set DONTNEED for the rest, which is assumed to be data */
  73 //#define ONE_PAGE 1
  74 /* Avoid calling madvise on areas that were already hinted. May be benefical if
  75  * your syscalls are very slow */
  76 //#define CHECK_MADVISE_OVERLAPS 1
  77
  78 #ifdef HAVE_MMAP
  79 #define __rrd_read(dst, dst_t, cnt) \
  80         (dst) = (dst_t*) (data + offset); \
  81         offset += sizeof(dst_t) * (cnt)
  82 #else
  83 #define __rrd_read(dst, dst_t, cnt) \
  84         if ((dst = malloc(sizeof(dst_t)*(cnt))) == NULL) { \
  85                 rrd_set_error(#dst " malloc"); \
  86                 goto out_nullify_head; \
  87         } \
  88         offset += read (rrd_file->fd, dst, sizeof(dst_t)*(cnt))
  89 #endif
  90
  91 /* next page-aligned (i.e. page-align up) */
  92 #ifndef PAGE_ALIGN
  93 #define PAGE_ALIGN(addr) (((addr)+_page_size-1)&(~(_page_size-1)))
  94 #endif
  95 /* previous page-aligned (i.e. page-align down) */
  96 #ifndef PAGE_ALIGN_DOWN
  97 #define PAGE_ALIGN_DOWN(addr) (((addr)+_page_size-1)&(~(_page_size-1)))
  98 #endif
  99
 100 #ifdef HAVE_MMAP
 101 /* vector of last madvise hint */
 102 typedef struct _madvise_vec_t {
 103     void     *start;
 104     ssize_t   length;
 105 } _madvise_vec_t;
 106 _madvise_vec_t _madv_vec = { NULL, 0 };
 107 #endif
 108
 109 #if defined CHECK_MADVISE_OVERLAPS
 110 #define _madvise(_start, _off, _hint) \
 111     if ((_start) != _madv_vec.start && (ssize_t)(_off) != _madv_vec.length) { \
 112         _madv_vec.start = (_start) ; _madv_vec.length = (_off); \
 113         madvise((_start), (_off), (_hint)); \
 114     }
 115 #else
 116 #define _madvise(_start, _off, _hint) \
 117     madvise((_start), (_off), (_hint))
 118 #endif
 119
 120 /* Open a database file, return its header and an open filehandle,
 121  * positioned to the first cdp in the first rra.
 122  * In the error path of rrd_open, only rrd_free(&rrd) has to be called
 123  * before returning an error. Do not call rrd_close upon failure of rrd_open.
 124  */
 125
 126 rrd_file_t *rrd_open(
 127     const char *const file_name,
 128     rrd_t *rrd,
 129     unsigned rdwr)
 130 {
 131     int       flags = 0;
 132     mode_t    mode = S_IRUSR;
 133     int       version;
 134
 135 #ifdef HAVE_MMAP
 136     ssize_t   _page_size = sysconf(_SC_PAGESIZE);
 137     int       mm_prot = PROT_READ, mm_flags = 0;
 138     char     *data;
 139 #endif
 140     off_t     offset = 0;
 141     struct stat statb;
 142     rrd_file_t *rrd_file = NULL;
 143
 144     rrd_init(rrd);
 145     rrd_file = malloc(sizeof(rrd_file_t));
 146     if (rrd_file == NULL) {
 147         rrd_set_error("allocating rrd_file descriptor for '%s'", file_name);
 148         return NULL;
 149     }
 150     memset(rrd_file, 0, sizeof(rrd_file_t));
 151
 152 #ifdef DEBUG
 153     if ((rdwr & (RRD_READONLY | RRD_READWRITE)) ==
 154         (RRD_READONLY | RRD_READWRITE)) {
 155         /* Both READONLY and READWRITE were given, which is invalid.  */
 156         rrd_set_error("in read/write request mask");
 157         exit(-1);
 158     }
 159 #endif
 160     if (rdwr & RRD_READONLY) {
 161         flags |= O_RDONLY;
 162 #ifdef HAVE_MMAP
 163         mm_flags = MAP_PRIVATE;
 164 # ifdef MAP_NORESERVE
 165         mm_flags |= MAP_NORESERVE;  /* readonly, so no swap backing needed */
 166 # endif
 167 #endif
 168     } else {
 169         if (rdwr & RRD_READWRITE) {
 170             mode |= S_IWUSR;
 171             flags |= O_RDWR;
 172 #ifdef HAVE_MMAP
 173             mm_flags = MAP_SHARED;
 174             mm_prot |= PROT_WRITE;
 175 #endif
 176         }
 177         if (rdwr & RRD_CREAT) {
 178             flags |= (O_CREAT | O_TRUNC);
 179         }
 180     }
 181     if (rdwr & RRD_READAHEAD) {
 182 #ifdef MAP_POPULATE
 183         mm_flags |= MAP_POPULATE;   /* populate ptes and data */
 184 #endif
 185 #if defined MAP_NONBLOCK
 186         mm_flags |= MAP_NONBLOCK;   /* just populate ptes */
 187 #endif
 188 #ifdef USE_DIRECT_IO
 189     } else {
 190         flags |= O_DIRECT;
 191 #endif
 192     }
 193 #ifdef O_NONBLOCK
 194     flags |= O_NONBLOCK;
 195 #endif
 196
 197     if ((rrd_file->fd = open(file_name, flags, mode)) < 0) {
 198         rrd_set_error("opening '%s': %s", file_name, rrd_strerror(errno));
 199         return NULL;
 200     }
 201
 202     /* Better try to avoid seeks as much as possible. stat may be heavy but
 203      * many concurrent seeks are even worse.  */
 204     if ((fstat(rrd_file->fd, &statb)) < 0) {
 205         rrd_set_error("fstat '%s': %s", file_name, rrd_strerror(errno));
 206         goto out_close;
 207     }
 208     rrd_file->file_len = statb.st_size;
 209
 210 #ifdef HAVE_POSIX_FADVISE
 211     /* In general we need no read-ahead when dealing with rrd_files.
 212        When we stop reading, it is highly unlikely that we start up again.
 213        In this manner we actually save time and diskaccess (and buffer cache).
 214        Thanks to Dave Plonka for the Idea of using POSIX_FADV_RANDOM here. */
 215     if (0 != posix_fadvise(rrd_file->fd, 0, 0, POSIX_FADV_RANDOM)) {
 216         rrd_set_error("setting POSIX_FADV_RANDOM on '%s': %s", file_name,
 217                       rrd_strerror(errno));
 218         goto out_close;
 219     }
 220 #endif
 221
 222 /*
 223         if (rdwr & RRD_READWRITE)
 224         {
 225            if (setvbuf((rrd_file->fd),NULL,_IONBF,2)) {
 226                   rrd_set_error("failed to disable the stream buffer\n");
 227                   return (-1);
 228            }
 229         }
 230 */
 231 #ifdef HAVE_MMAP
 232     data = mmap(0, rrd_file->file_len, mm_prot, mm_flags,
 233                 rrd_file->fd, offset);
 234
 235     /* lets see if the first read worked */
 236     if (data == MAP_FAILED) {
 237         rrd_set_error("error mmaping file '%s': %s", file_name,
 238                       rrd_strerror(errno));
 239         goto out_close;
 240     }
 241     rrd_file->file_start = data;
 242 #endif
 243 #ifdef USE_MADVISE
 244     if (rdwr & RRD_COPY) {
 245         /* We will read everything in a moment (copying) */
 246         _madvise(data, rrd_file->file_len, MADV_WILLNEED | MADV_SEQUENTIAL);
 247         goto out_done;
 248     }
 249     /* We do not need to read anything in for the moment */
 250 #ifndef ONE_PAGE
 251     _madvise(data, rrd_file->file_len, MADV_DONTNEED);
 252 //    _madvise(data, rrd_file->file_len, MADV_RANDOM);
 253 #else
 254 /* alternatively: keep 2 pages worth of data, likely headers,
 255  * don't need the rest.  */
 256     _madvise(data, _page_size, MADV_WILLNEED | MADV_SEQUENTIAL);
 257     _madvise(data + _page_size, (rrd_file->file_len >= _page_size)
 258              ? rrd_file->file_len - _page_size : 0, MADV_DONTNEED);
 259 #endif
 260 #endif
 261
 262 #if defined USE_MADVISE && !defined ONE_PAGE
 263     /* the stat_head will be needed soonish, so hint accordingly */
 264 // too finegrained to calc the individual sizes, just keep 2 pages worth of hdr
 265     _madvise(data + PAGE_ALIGN_DOWN(offset), PAGE_ALIGN(sizeof(stat_head_t)),
 266              MADV_WILLNEED);
 267
 268 #endif
 269
 270     __rrd_read(rrd->stat_head, stat_head_t,
 271                1);
 272
 273     /* lets do some test if we are on track ... */
 274     if (memcmp(rrd->stat_head->cookie, RRD_COOKIE, sizeof(RRD_COOKIE)) != 0) {
 275         rrd_set_error("'%s' is not an RRD file", file_name);
 276         goto out_nullify_head;
 277     }
 278
 279     if (rrd->stat_head->float_cookie != FLOAT_COOKIE) {
 280         rrd_set_error("This RRD was created on other architecture");
 281         goto out_nullify_head;
 282     }
 283
 284     version = atoi(rrd->stat_head->version);
 285
 286     if (version > atoi(RRD_VERSION)) {
 287         rrd_set_error("can't handle RRD file version %s",
 288                       rrd->stat_head->version);
 289         goto out_nullify_head;
 290     }
 291 #if defined USE_MADVISE && !defined ONE_PAGE
 292     /* the ds_def will be needed soonish, so hint accordingly */
 293     _madvise(data + PAGE_ALIGN_DOWN(offset),
 294              PAGE_ALIGN(sizeof(ds_def_t) * rrd->stat_head->ds_cnt),
 295              MADV_WILLNEED);
 296 #endif
 297     __rrd_read(rrd->ds_def, ds_def_t,
 298                rrd->stat_head->ds_cnt);
 299
 300 #if defined USE_MADVISE && !defined ONE_PAGE
 301     /* the rra_def will be needed soonish, so hint accordingly */
 302     _madvise(data + PAGE_ALIGN_DOWN(offset),
 303              PAGE_ALIGN(sizeof(rra_def_t) * rrd->stat_head->rra_cnt),
 304              MADV_WILLNEED);
 305 #endif
 306     __rrd_read(rrd->rra_def, rra_def_t,
 307                rrd->stat_head->rra_cnt);
 308
 309     /* handle different format for the live_head */
 310     if (version < 3) {
 311         rrd->live_head = (live_head_t *) malloc(sizeof(live_head_t));
 312         if (rrd->live_head == NULL) {
 313             rrd_set_error("live_head_t malloc");
 314             goto out_close;
 315         }
 316 #ifdef HAVE_MMAP
 317         memmove(&rrd->live_head->last_up, data + offset, sizeof(long));
 318         offset += sizeof(long);
 319 #else
 320         offset += read(rrd_file->fd, &rrd->live_head->last_up, sizeof(long));
 321 #endif
 322         rrd->live_head->last_up_usec = 0;
 323     } else {
 324 #if defined USE_MADVISE && !defined ONE_PAGE
 325         /* the live_head will be needed soonish, so hint accordingly */
 326         _madvise(data + PAGE_ALIGN_DOWN(offset),
 327                  PAGE_ALIGN(sizeof(live_head_t)), MADV_WILLNEED);
 328 #endif
 329         __rrd_read(rrd->live_head, live_head_t,
 330                    1);
 331     }
 332 //XXX: This doesn't look like it needs madvise
 333     __rrd_read(rrd->pdp_prep, pdp_prep_t,
 334                rrd->stat_head->ds_cnt);
 335
 336 //XXX: This could benefit from madvise()ing
 337     __rrd_read(rrd->cdp_prep, cdp_prep_t,
 338                rrd->stat_head->rra_cnt * rrd->stat_head->ds_cnt);
 339
 340 //XXX: This could benefit from madvise()ing
 341     __rrd_read(rrd->rra_ptr, rra_ptr_t,
 342                rrd->stat_head->rra_cnt);
 343
 344 #ifdef USE_MADVISE
 345   out_done:
 346 #endif
 347     rrd_file->header_len = offset;
 348     rrd_file->pos = offset;
 349
 350     return (rrd_file);
 351   out_nullify_head:
 352     rrd->stat_head = NULL;
 353   out_close:
 354     close(rrd_file->fd);
 355     return NULL;
 356 }
 357
 358
 359 /* Close a reference to an rrd_file.  */
 360
 361 int rrd_close(
 362     rrd_file_t *rrd_file)
 363 {
 364     int       ret;
 365
 366 #if defined HAVE_MMAP || defined DEBUG
 367     ssize_t   _page_size = sysconf(_SC_PAGESIZE);
 368 #endif
 369 #if defined DEBUG && DEBUG > 1
 370     /* pretty print blocks in core */
 371     off_t     off;
 372     unsigned char *vec;
 373
 374     off = rrd_file->file_len +
 375         ((rrd_file->file_len + _page_size - 1) / _page_size);
 376     vec = malloc(off);
 377     if (vec != NULL) {
 378         memset(vec, 0, off);
 379         if (mincore(rrd_file->file_start, rrd_file->file_len, vec) == 0) {
 380             int       prev;
 381             unsigned  is_in = 0, was_in = 0;
 382
 383             for (off = 0, prev = 0; off < rrd_file->file_len; ++off) {
 384                 is_in = vec[off] & 1;   /* if lsb set then is core resident */
 385                 if (off == 0)
 386                     was_in = is_in;
 387                 if (was_in != is_in) {
 388                     fprintf(stderr, "%sin core: %p len %ld\n",
 389                             was_in ? "" : "not ", vec + prev, off - prev);
 390                     was_in = is_in;
 391                     prev = off;
 392                 }
 393             }
 394             fprintf(stderr,
 395                     "%sin core: %p len %ld\n",
 396                     was_in ? "" : "not ", vec + prev, off - prev);
 397         } else
 398             fprintf(stderr, "mincore: %s", rrd_strerror(errno));
 399     }
 400 #endif                          /* DEBUG */
 401
 402 #ifdef USE_MADVISE
 403 #ifdef ONE_PAGE
 404     /* Keep headers around, round up to next page boundary.  */
 405     ret =
 406         PAGE_ALIGN(rrd_file->header_len % _page_size + rrd_file->header_len);
 407     if (rrd_file->file_len > ret)
 408         _madvise(rrd_file->file_start + ret,
 409                  rrd_file->file_len - ret, MADV_DONTNEED);
 410 #else
 411     /* ignoring errors from RRDs that are smaller then the file_len+rounding */
 412     _madvise(rrd_file->file_start + PAGE_ALIGN_DOWN(rrd_file->header_len),
 413              rrd_file->file_len - PAGE_ALIGN(rrd_file->header_len),
 414              MADV_DONTNEED);
 415 #endif
 416 #endif
 417 #ifdef HAVE_MMAP
 418     ret = munmap(rrd_file->file_start, rrd_file->file_len);
 419     if (ret != 0)
 420         rrd_set_error("munmap rrd_file: %s", rrd_strerror(errno));
 421 #endif
 422     ret = close(rrd_file->fd);
 423     if (ret != 0)
 424         rrd_set_error("closing file: %s", rrd_strerror(errno));
 425     free(rrd_file);
 426     rrd_file = NULL;
 427     return ret;
 428 }
 429
 430
 431 /* Set position of rrd_file.  */
 432
 433 off_t rrd_seek(
 434     rrd_file_t *rrd_file,
 435     off_t off,
 436     int whence)
 437 {
 438     off_t     ret = 0;
 439
 440 #ifdef HAVE_MMAP
 441     if (whence == SEEK_SET)
 442         rrd_file->pos = off;
 443     else if (whence == SEEK_CUR)
 444         rrd_file->pos += off;
 445     else if (whence == SEEK_END)
 446         rrd_file->pos = rrd_file->file_len + off;
 447 #else
 448     ret = lseek(rrd_file->fd, off, whence);
 449     if (ret < 0)
 450         rrd_set_error("lseek: %s", rrd_strerror(errno));
 451     rrd_file->pos = ret;
 452 #endif
 453 //XXX: mimic fseek, which returns 0 upon success
 454     return ret == -1;   //XXX: or just ret to mimic lseek
 455 }
 456
 457
 458 /* Get current position in rrd_file.  */
 459
 460 inline off_t rrd_tell(rrd_file_t *rrd_file)
 461 {
 462     return rrd_file->pos;
 463 }
 464
 465
 466 /* read count bytes into buffer buf, starting at rrd_file->pos.
 467  * Returns the number of bytes read.  */
 468
 469 ssize_t rrd_read(
 470     rrd_file_t *rrd_file,
 471     void *buf,
 472     size_t count)
 473 {
 474 #ifdef HAVE_MMAP
 475     buf = memmove(buf, rrd_file->file_start + rrd_file->pos, count);
 476     rrd_file->pos += count; /* mimmic read() semantics */
 477     return count;
 478 #else
 479     ssize_t   ret;
 480
 481     ret = read(rrd_file->fd, buf, count);
 482     //XXX: eventually add generic rrd_set_error(""); here
 483     rrd_file->pos += count; /* mimmic read() semantics */
 484     return ret;
 485 #endif
 486 }
 487
 488
 489 /* write count bytes from buffer buf to the current position
 490  * rrd_file->pos of rrd_file->fd.
 491  * Returns the number of bytes written.  */
 492
 493 ssize_t rrd_write(
 494     rrd_file_t *rrd_file,
 495     const void *buf,
 496     size_t count)
 497 {
 498 #ifdef HAVE_MMAP
 499     memmove(rrd_file->file_start + rrd_file->pos, buf, count);
 500     return count;       /* mimmic write() semantics */
 501 #else
 502     return write(rrd_file->fd, buf, count);
 503 #endif
 504 }
 505
 506
 507 /* flush all data pending to be written to FD.  */
 508
 509 inline void rrd_flush(
 510     rrd_file_t *rrd_file)
 511 {
 512     if (fdatasync(rrd_file->fd) != 0) {
 513         rrd_set_error("flushing fd %d: %s", rrd_file->fd,
 514                       rrd_strerror(errno));
 515     }
 516 }
 517
 518
 519 /* Initialize RRD header.  */
 520
 521 void rrd_init(
 522     rrd_t *rrd)
 523 {
 524     rrd->stat_head = NULL;
 525     rrd->ds_def = NULL;
 526     rrd->rra_def = NULL;
 527     rrd->live_head = NULL;
 528     rrd->rra_ptr = NULL;
 529     rrd->pdp_prep = NULL;
 530     rrd->cdp_prep = NULL;
 531     rrd->rrd_value = NULL;
 532 }
 533
 534
 535 /* free RRD header data.  */
 536
 537 #ifdef HAVE_MMAP
 538 inline void rrd_free(
 539     rrd_t UNUSED(*rrd)) {}
 540 #else
 541 void rrd_free(
 542     rrd_t *rrd)
 543 {
 544     if (atoi(rrd->stat_head->version) < 3)
 545         free(rrd->live_head);
 546     free(rrd->stat_head);
 547     free(rrd->ds_def);
 548     free(rrd->rra_def);
 549     free(rrd->rra_ptr);
 550     free(rrd->pdp_prep);
 551     free(rrd->cdp_prep);
 552     free(rrd->rrd_value);
 553 }
 554 #endif
 555
 556
 557 /* routine used by external libraries to free memory allocated by
 558  * rrd library */
 559
 560 void rrd_freemem(
 561     void *mem)
 562 {
 563     free(mem);
 564 }
 565
 566
 567 /* XXX: FIXME: missing documentation.  */
 568 /*XXX: FIXME should be renamed to rrd_readfile or _rrd_readfile */
 569
 570 int /*_rrd_*/ readfile(
 571     const char *file_name,
 572     char **buffer,
 573     int skipfirst)
 574 {
 575     long      writecnt = 0, totalcnt = MEMBLK;
 576     long      offset = 0;
 577     FILE     *input = NULL;
 578     char      c;
 579
 580     if ((strcmp("-", file_name) == 0)) {
 581         input = stdin;
 582     } else {
 583         if ((input = fopen(file_name, "rb")) == NULL) {
 584             rrd_set_error("opening '%s': %s", file_name, rrd_strerror(errno));
 585             return (-1);
 586         }
 587     }
 588     if (skipfirst) {
 589         do {
 590             c = getc(input);
 591             offset++;
 592         } while (c != '\n' && !feof(input));
 593     }
 594     if (strcmp("-", file_name)) {
 595         fseek(input, 0, SEEK_END);
 596         /* have extra space for detecting EOF without realloc */
 597         totalcnt = (ftell(input) + 1) / sizeof(char) - offset;
 598         if (totalcnt < MEMBLK)
 599             totalcnt = MEMBLK;  /* sanitize */
 600         fseek(input, offset * sizeof(char), SEEK_SET);
 601     }
 602     if (((*buffer) = (char *) malloc((totalcnt + 4) * sizeof(char))) == NULL) {
 603         perror("Allocate Buffer:");
 604         exit(1);
 605     };
 606     do {
 607         writecnt +=
 608             fread((*buffer) + writecnt, 1,
 609                   (totalcnt - writecnt) * sizeof(char), input);
 610         if (writecnt >= totalcnt) {
 611             totalcnt += MEMBLK;
 612             if (((*buffer) =
 613                  rrd_realloc((*buffer),
 614                              (totalcnt + 4) * sizeof(char))) == NULL) {
 615                 perror("Realloc Buffer:");
 616                 exit(1);
 617             };
 618         }
 619     } while (!feof(input));
 620     (*buffer)[writecnt] = '\0';
 621     if (strcmp("-", file_name) != 0) {
 622         fclose(input);
 623     };
 624     return writecnt;
 625 }