diff --git a/src/rrd_open.c b/src/rrd_open.c
index 1aa5227057504d9567b1c6d989cfc042d1c03190..03cc5b9a1bdf09299d71f60bea509e62da68a97b 100644 (file)
--- a/src/rrd_open.c
+++ b/src/rrd_open.c
/*****************************************************************************
- * RRDtool 1.2.28 Copyright by Tobi Oetiker, 1997-2008
+ * RRDtool 1.3.2 Copyright by Tobi Oetiker, 1997-2008
*****************************************************************************
* rrd_open.c Open an RRD File
*****************************************************************************
- * $Id: rrd_open.c 1450 2008-07-23 13:45:41Z oetiker $
- * $Log$
- * Revision 1.10 2004/05/26 22:11:12 oetiker
- * reduce compiler warnings. Many small fixes. -- Mike Slifcak <slif@bellsouth.net>
- *
- * Revision 1.9 2003/04/29 21:56:49 oetiker
- * readline in rrd_open.c reads the file in 8 KB blocks, and calls realloc for
- * each block. realloc is very slow in Mac OS X for huge blocks, e.g. when
- * restoring databases from huge xml files. This patch finds the size of the
- * file, and starts out with malloc'ing the full size.
- * -- Peter Speck <speck@ruc.dk>
- *
- * Revision 1.8 2003/04/11 19:43:44 oetiker
- * New special value COUNT which allows calculations based on the position of a
- * value within a data set. Bug fix in rrd_rpncalc.c. PREV returned erroneus
- * value for the second value. Bug fix in rrd_restore.c. Bug causing seek error
- * when accesing an RRD restored from an xml that holds an RRD version <3.
- * -- Ruben Justo <ruben@ainek.com>
- *
- * Revision 1.7 2003/03/31 21:22:12 oetiker
- * enables RRDtool updates with microsecond or in case of windows millisecond
- * precision. This is needed to reduce time measurement error when archive step
- * is small. (<30s) -- Sasha Mikheev <sasha@avalon-net.co.il>
- *
- * Revision 1.6 2003/02/13 07:05:27 oetiker
- * Find attached the patch I promised to send to you. Please note that there
- * are three new source files (src/rrd_is_thread_safe.h, src/rrd_thread_safe.c
- * and src/rrd_not_thread_safe.c) and the introduction of librrd_th. This
- * library is identical to librrd, but it contains support code for per-thread
- * global variables currently used for error information only. This is similar
- * to how errno per-thread variables are implemented. librrd_th must be linked
- * alongside of libpthred
- *
- * There is also a new file "THREADS", holding some documentation.
- *
- * -- Peter Stamfest <peter@stamfest.at>
- *
- * Revision 1.5 2002/06/20 00:21:03 jake
- * More Win32 build changes; thanks to Kerry Calvert.
- *
- * Revision 1.4 2002/02/01 20:34:49 oetiker
- * fixed version number and date/time
- *
- * Revision 1.3 2001/03/04 13:01:55 oetiker
- * Aberrant Behavior Detection support. A brief overview added to rrdtool.pod.
- * Major updates to rrd_update.c, rrd_create.c. Minor update to other core files.
- * This is backwards compatible! But new files using the Aberrant stuff are not readable
- * by old rrdtool versions. See http://cricket.sourceforge.net/aberrant/rrd_hw.htm
- * -- Jake Brutlag <jakeb@corp.webtv.net>
- *
- * Revision 1.2 2001/03/04 10:29:20 oetiker
- * fixed filedescriptor leak
- * -- Mike Franusich <mike@franusich.com>
- *
- * Revision 1.1.1.1 2001/02/25 22:25:05 oetiker
- * checkin
- *
+ * $Id$
*****************************************************************************/
+#ifdef WIN32
+#include <stdlib.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#endif
+
+#ifdef HAVE_BROKEN_MS_ASYNC
+#include <sys/types.h>
+#include <utime.h>
+#endif
+
#include "rrd_tool.h"
+#include "unused.h"
#define MEMBLK 8192
-/* open a database file, return its header and a open filehandle */
-/* positioned to the first cdp in the first rra */
+#ifdef WIN32
+#define _LK_UNLCK 0 /* Unlock */
+#define _LK_LOCK 1 /* Lock */
+#define _LK_NBLCK 2 /* Non-blocking lock */
+#define _LK_RLCK 3 /* Lock for read only */
+#define _LK_NBRLCK 4 /* Non-blocking lock for read only */
+
+
+#define LK_UNLCK _LK_UNLCK
+#define LK_LOCK _LK_LOCK
+#define LK_NBLCK _LK_NBLCK
+#define LK_RLCK _LK_RLCK
+#define LK_NBRLCK _LK_NBRLCK
+#endif
+
+/* DEBUG 2 prints information obtained via mincore(2) */
+#define DEBUG 1
+/* do not calculate exact madvise hints but assume 1 page for headers and
+ * set DONTNEED for the rest, which is assumed to be data */
+/* Avoid calling madvise on areas that were already hinted. May be benefical if
+ * your syscalls are very slow */
+
+#ifdef HAVE_MMAP
+/* the cast to void* is there to avoid this warning seen on ia64 with certain
+ versions of gcc: 'cast increases required alignment of target type'
+*/
+#define __rrd_read(dst, dst_t, cnt) { \
+ size_t wanted = sizeof(dst_t)*(cnt); \
+ if (offset + wanted > rrd_file->file_len) { \
+ rrd_set_error("reached EOF while loading header " #dst); \
+ goto out_nullify_head; \
+ } \
+ (dst) = (dst_t*)(void*) (data + offset); \
+ offset += wanted; \
+ }
+#else
+#define __rrd_read(dst, dst_t, cnt) { \
+ size_t wanted = sizeof(dst_t)*(cnt); \
+ size_t got; \
+ if ((dst = (dst_t*)malloc(wanted)) == NULL) { \
+ rrd_set_error(#dst " malloc"); \
+ goto out_nullify_head; \
+ } \
+ got = read (rrd_simple_file->fd, dst, wanted); \
+ if (got != wanted) { \
+ rrd_set_error("short read while reading header " #dst); \
+ goto out_nullify_head; \
+ } \
+ offset += got; \
+ }
+#endif
+
+/* get the address of the start of this page */
+#if defined USE_MADVISE || defined HAVE_POSIX_FADVISE
+#ifndef PAGE_START
+#define PAGE_START(addr) ((addr)&(~(_page_size-1)))
+#endif
+#endif
+
+/* Open a database file, return its header and an open filehandle,
+ * positioned to the first cdp in the first rra.
+ * In the error path of rrd_open, only rrd_free(&rrd) has to be called
+ * before returning an error. Do not call rrd_close upon failure of rrd_open.
+ * If creating a new file, the parameter rrd must be initialised with
+ * details of the file content.
+ * If opening an existing file, then use rrd must be initialised by
+ * rrd_init(rrd) prior to invoking rrd_open
+ */
-int
-rrd_open(const char *file_name, FILE **in_file, rrd_t *rrd, int rdwr)
+rrd_file_t *rrd_open(
+ const char *const file_name,
+ rrd_t *rrd,
+ unsigned rdwr)
{
+ unsigned long ui;
+ int flags = 0;
+ int version;
+#ifdef HAVE_MMAP
+ ssize_t _page_size = sysconf(_SC_PAGESIZE);
+ char *data = MAP_FAILED;
+#endif
+ off_t offset = 0;
+ struct stat statb;
+ rrd_file_t *rrd_file = NULL;
+ rrd_simple_file_t *rrd_simple_file = NULL;
+ size_t newfile_size = 0;
+ size_t header_len, value_cnt, data_len;
+
+ /* Are we creating a new file? */
+ if((rdwr & RRD_CREAT) && (rrd->stat_head != NULL))
+ {
+ header_len = rrd_get_header_size(rrd);
+
+ value_cnt = 0;
+ for (ui = 0; ui < rrd->stat_head->rra_cnt; ui++)
+ value_cnt += rrd->stat_head->ds_cnt * rrd->rra_def[ui].row_cnt;
+
+ data_len = sizeof(rrd_value_t) * value_cnt;
+
+ newfile_size = header_len + data_len;
+ }
- char *mode = NULL;
- int version;
-
- rrd_init(rrd);
- if (rdwr == RRD_READONLY) {
- mode = "rb";
+ rrd_file = (rrd_file_t*)malloc(sizeof(rrd_file_t));
+ if (rrd_file == NULL) {
+ rrd_set_error("allocating rrd_file descriptor for '%s'", file_name);
+ return NULL;
+ }
+ memset(rrd_file, 0, sizeof(rrd_file_t));
+
+ rrd_file->pvt = malloc(sizeof(rrd_simple_file_t));
+ if(rrd_file->pvt == NULL) {
+ rrd_set_error("allocating rrd_simple_file for '%s'", file_name);
+ return NULL;
+ }
+ memset(rrd_file->pvt, 0, sizeof(rrd_simple_file_t));
+ rrd_simple_file = (rrd_simple_file_t *)rrd_file->pvt;
+
+#ifdef DEBUG
+ if ((rdwr & (RRD_READONLY | RRD_READWRITE)) ==
+ (RRD_READONLY | RRD_READWRITE)) {
+ /* Both READONLY and READWRITE were given, which is invalid. */
+ rrd_set_error("in read/write request mask");
+ exit(-1);
+ }
+#endif
+
+#ifdef HAVE_MMAP
+ rrd_simple_file->mm_prot = PROT_READ;
+ rrd_simple_file->mm_flags = 0;
+#endif
+
+ if (rdwr & RRD_READONLY) {
+ flags |= O_RDONLY;
+#ifdef HAVE_MMAP
+ rrd_simple_file->mm_flags = MAP_PRIVATE;
+# ifdef MAP_NORESERVE
+ rrd_simple_file->mm_flags |= MAP_NORESERVE; /* readonly, so no swap backing needed */
+# endif
+#endif
} else {
- mode = "rb+";
+ if (rdwr & RRD_READWRITE) {
+ flags |= O_RDWR;
+#ifdef HAVE_MMAP
+ rrd_simple_file->mm_flags = MAP_SHARED;
+ rrd_simple_file->mm_prot |= PROT_WRITE;
+#endif
+ }
+ if (rdwr & RRD_CREAT) {
+ flags |= (O_CREAT | O_TRUNC);
+ }
}
-
- if (((*in_file) = fopen(file_name,mode)) == NULL ){
- rrd_set_error("opening '%s': %s",file_name, rrd_strerror(errno));
- return (-1);
+ if (rdwr & RRD_READAHEAD) {
+#ifdef MAP_POPULATE
+ rrd_simple_file->mm_flags |= MAP_POPULATE; /* populate ptes and data */
+#endif
+#if defined MAP_NONBLOCK
+ rrd_simple_file->mm_flags |= MAP_NONBLOCK; /* just populate ptes */
+#endif
+ }
+#if defined(_WIN32) && !defined(__CYGWIN__) && !defined(__CYGWIN32__)
+ flags |= O_BINARY;
+#endif
+
+ if ((rrd_simple_file->fd = open(file_name, flags, 0666)) < 0) {
+ rrd_set_error("opening '%s': %s", file_name, rrd_strerror(errno));
+ goto out_free;
}
+#ifdef HAVE_MMAP
+#ifdef HAVE_BROKEN_MS_ASYNC
+ if (rdwr & RRD_READWRITE) {
+ /* some unices, the files mtime does not get update
+ on msync MS_ASYNC, in order to help them,
+ we update the the timestamp at this point.
+ The thing happens pretty 'close' to the open
+ call so the chances of a race should be minimal.
+
+ Maybe ask your vendor to fix your OS ... */
+ utime(file_name,NULL);
+ }
+#endif
+#endif
+
+ /* Better try to avoid seeks as much as possible. stat may be heavy but
+ * many concurrent seeks are even worse. */
+ if (newfile_size == 0 && ((fstat(rrd_simple_file->fd, &statb)) < 0)) {
+ rrd_set_error("fstat '%s': %s", file_name, rrd_strerror(errno));
+ goto out_close;
+ }
+ if (newfile_size == 0) {
+ rrd_file->file_len = statb.st_size;
+ } else {
+ rrd_file->file_len = newfile_size;
+ lseek(rrd_simple_file->fd, newfile_size - 1, SEEK_SET);
+ if ( write(rrd_simple_file->fd, "\0", 1) == -1){ /* poke */
+ rrd_set_error("write '%s': %s", file_name, rrd_strerror(errno));
+ goto out_close;
+ }
+ lseek(rrd_simple_file->fd, 0, SEEK_SET);
+ }
#ifdef HAVE_POSIX_FADVISE
/* In general we need no read-ahead when dealing with rrd_files.
When we stop reading, it is highly unlikely that we start up again.
In this manner we actually save time and diskaccess (and buffer cache).
- Thanks to Dave Plonka for the Idea of using POSIX_FADV_RANDOM here. */
- /* if (0 != posix_fadvise(fileno(*in_file), 0, 0, POSIX_FADV_RANDOM)) {
- rrd_set_error("setting POSIX_FADV_RANDOM on '%s': %s",file_name, rrd_strerror(errno));
- fclose(*in_file);
- return(-1); */
-
- /* if it does not work, then this is sad, but we should not quit */
- posix_fadvise(fileno(*in_file), 0, 0, POSIX_FADV_RANDOM);
-
- /* } */
+ Thanks to Dave Plonka for the Idea of using POSIX_FADV_RANDOM here. */
+ posix_fadvise(rrd_simple_file->fd, 0, 0, POSIX_FADV_RANDOM);
#endif
/*
- if (rdwr == RRD_READWRITE)
+ if (rdwr & RRD_READWRITE)
{
- if (setvbuf((*in_file),NULL,_IONBF,2)) {
+ if (setvbuf((rrd_simple_file->fd),NULL,_IONBF,2)) {
rrd_set_error("failed to disable the stream buffer\n");
return (-1);
}
}
*/
-
-#define MYFREAD(MYVAR,MYVART,MYCNT) \
- if ((MYVAR = malloc(sizeof(MYVART) * MYCNT)) == NULL) {\
- rrd_set_error("" #MYVAR " malloc"); \
- fclose(*in_file); \
- return (-1); } \
- fread(MYVAR,sizeof(MYVART),MYCNT, *in_file);
+#ifdef HAVE_MMAP
+ data = mmap(0, rrd_file->file_len,
+ rrd_simple_file->mm_prot, rrd_simple_file->mm_flags,
+ rrd_simple_file->fd, offset);
- MYFREAD(rrd->stat_head, stat_head_t, 1)
/* lets see if the first read worked */
- if (ferror( *in_file ) || feof(*in_file)) {
- rrd_set_error("reading the cookie off %s faild",file_name);
- fclose(*in_file);
- return(-1);
- }
-
- /* lets do some test if we are on track ... */
- if (strncmp(rrd->stat_head->cookie,RRD_COOKIE,4) != 0){
- rrd_set_error("'%s' is not an RRD file",file_name);
- free(rrd->stat_head);
- rrd->stat_head = NULL;
- fclose(*in_file);
- return(-1);}
-
- if (rrd->stat_head->float_cookie != FLOAT_COOKIE){
- rrd_set_error("This RRD was created on other architecture");
- free(rrd->stat_head);
- rrd->stat_head = NULL;
- fclose(*in_file);
- return(-1);}
+ if (data == MAP_FAILED) {
+ rrd_set_error("mmaping file '%s': %s", file_name,
+ rrd_strerror(errno));
+ goto out_close;
+ }
+ rrd_simple_file->file_start = data;
+ if (rdwr & RRD_CREAT) {
+ memset(data, DNAN, newfile_size - 1);
+ goto out_done;
+ }
+#endif
+ if (rdwr & RRD_CREAT)
+ goto out_done;
+#ifdef USE_MADVISE
+ if (rdwr & RRD_COPY) {
+ /* We will read everything in a moment (copying) */
+ madvise(data, rrd_file->file_len, MADV_WILLNEED );
+ madvise(data, rrd_file->file_len, MADV_SEQUENTIAL );
+ } else {
+ /* We do not need to read anything in for the moment */
+ madvise(data, rrd_file->file_len, MADV_RANDOM);
+ /* the stat_head will be needed soonish, so hint accordingly */
+ madvise(data, sizeof(stat_head_t), MADV_WILLNEED);
+ madvise(data, sizeof(stat_head_t), MADV_RANDOM);
+ }
+#endif
+
+ __rrd_read(rrd->stat_head, stat_head_t,
+ 1);
+
+ /* lets do some test if we are on track ... */
+ if (memcmp(rrd->stat_head->cookie, RRD_COOKIE, sizeof(RRD_COOKIE)) != 0) {
+ rrd_set_error("'%s' is not an RRD file", file_name);
+ goto out_nullify_head;
+ }
+
+ if (rrd->stat_head->float_cookie != FLOAT_COOKIE) {
+ rrd_set_error("This RRD was created on another architecture");
+ goto out_nullify_head;
+ }
version = atoi(rrd->stat_head->version);
- if (version > atoi(RRD_VERSION)){
- rrd_set_error("can't handle RRD file version %s",
- rrd->stat_head->version);
- free(rrd->stat_head);
- rrd->stat_head = NULL;
- fclose(*in_file);
- return(-1);}
+ if (version > atoi(RRD_VERSION)) {
+ rrd_set_error("can't handle RRD file version %s",
+ rrd->stat_head->version);
+ goto out_nullify_head;
+ }
+#if defined USE_MADVISE
+ /* the ds_def will be needed soonish, so hint accordingly */
+ madvise(data + PAGE_START(offset),
+ sizeof(ds_def_t) * rrd->stat_head->ds_cnt, MADV_WILLNEED);
+#endif
+ __rrd_read(rrd->ds_def, ds_def_t,
+ rrd->stat_head->ds_cnt);
+#if defined USE_MADVISE
+ /* the rra_def will be needed soonish, so hint accordingly */
+ madvise(data + PAGE_START(offset),
+ sizeof(rra_def_t) * rrd->stat_head->rra_cnt, MADV_WILLNEED);
+#endif
+ __rrd_read(rrd->rra_def, rra_def_t,
+ rrd->stat_head->rra_cnt);
- MYFREAD(rrd->ds_def, ds_def_t, rrd->stat_head->ds_cnt)
- MYFREAD(rrd->rra_def, rra_def_t, rrd->stat_head->rra_cnt)
/* handle different format for the live_head */
- if(version < 3) {
- rrd->live_head = (live_head_t *)malloc(sizeof(live_head_t));
- if(rrd->live_head == NULL) {
- rrd_set_error("live_head_t malloc");
- fclose(*in_file);
- return (-1);
+ if (version < 3) {
+ rrd->live_head = (live_head_t *) malloc(sizeof(live_head_t));
+ if (rrd->live_head == NULL) {
+ rrd_set_error("live_head_t malloc");
+ goto out_close;
+ }
+#if defined USE_MADVISE
+ /* the live_head will be needed soonish, so hint accordingly */
+ madvise(data + PAGE_START(offset), sizeof(time_t), MADV_WILLNEED);
+#endif
+ __rrd_read(rrd->legacy_last_up, time_t,
+ 1);
+
+ rrd->live_head->last_up = *rrd->legacy_last_up;
+ rrd->live_head->last_up_usec = 0;
+ } else {
+#if defined USE_MADVISE
+ /* the live_head will be needed soonish, so hint accordingly */
+ madvise(data + PAGE_START(offset),
+ sizeof(live_head_t), MADV_WILLNEED);
+#endif
+ __rrd_read(rrd->live_head, live_head_t,
+ 1);
+ }
+ __rrd_read(rrd->pdp_prep, pdp_prep_t,
+ rrd->stat_head->ds_cnt);
+ __rrd_read(rrd->cdp_prep, cdp_prep_t,
+ rrd->stat_head->rra_cnt * rrd->stat_head->ds_cnt);
+ __rrd_read(rrd->rra_ptr, rra_ptr_t,
+ rrd->stat_head->rra_cnt);
+
+ rrd_file->header_len = offset;
+ rrd_file->pos = offset;
+
+ {
+ unsigned long row_cnt = 0;
+
+ for (ui=0; ui<rrd->stat_head->rra_cnt; ui++)
+ row_cnt += rrd->rra_def[ui].row_cnt;
+
+ size_t correct_len = rrd_file->header_len +
+ sizeof(rrd_value_t) * row_cnt * rrd->stat_head->ds_cnt;
+
+ if (correct_len > rrd_file->file_len)
+ {
+ rrd_set_error("'%s' is too small (should be %ld bytes)",
+ file_name, (long long) correct_len);
+ goto out_nullify_head;
+ }
+ }
+
+ out_done:
+ return (rrd_file);
+ out_nullify_head:
+ rrd->stat_head = NULL;
+ out_close:
+#ifdef HAVE_MMAP
+ if (data != MAP_FAILED)
+ munmap(data, rrd_file->file_len);
+#endif
+
+ close(rrd_simple_file->fd);
+ out_free:
+ free(rrd_file->pvt);
+ free(rrd_file);
+ return NULL;
+}
+
+
+#if defined DEBUG && DEBUG > 1
+/* Print list of in-core pages of a the current rrd_file. */
+static
+void mincore_print(
+ rrd_file_t *rrd_file,
+ char *mark)
+{
+ rrd_simple_file_t *rrd_simple_file;
+ rrd_simple_file = (rrd_simple_file_t *)rrd_file->pvt;
+#ifdef HAVE_MMAP
+ /* pretty print blocks in core */
+ size_t off;
+ unsigned char *vec;
+ ssize_t _page_size = sysconf(_SC_PAGESIZE);
+
+ off = rrd_file->file_len +
+ ((rrd_file->file_len + _page_size - 1) / _page_size);
+ vec = malloc(off);
+ if (vec != NULL) {
+ memset(vec, 0, off);
+ if (mincore(rrd_simple_file->file_start, rrd_file->file_len, vec) == 0) {
+ int prev;
+ unsigned is_in = 0, was_in = 0;
+
+ for (off = 0, prev = 0; off < rrd_file->file_len; ++off) {
+ is_in = vec[off] & 1; /* if lsb set then is core resident */
+ if (off == 0)
+ was_in = is_in;
+ if (was_in != is_in) {
+ fprintf(stderr, "%s: %sin core: %p len %ld\n", mark,
+ was_in ? "" : "not ", vec + prev, off - prev);
+ was_in = is_in;
+ prev = off;
+ }
}
- fread(&rrd->live_head->last_up, sizeof(long), 1, *in_file);
- rrd->live_head->last_up_usec = 0;
+ fprintf(stderr,
+ "%s: %sin core: %p len %ld\n", mark,
+ was_in ? "" : "not ", vec + prev, off - prev);
+ } else
+ fprintf(stderr, "mincore: %s", rrd_strerror(errno));
}
- else {
- MYFREAD(rrd->live_head, live_head_t, 1)
+#else
+ fprintf(stderr, "sorry mincore only works with mmap");
+#endif
+}
+#endif /* defined DEBUG && DEBUG > 1 */
+
+/*
+ * get exclusive lock to whole file.
+ * lock gets removed when we close the file
+ *
+ * returns 0 on success
+ */
+int rrd_lock(
+ rrd_file_t *rrd_file)
+{
+ int rcstat;
+ rrd_simple_file_t *rrd_simple_file;
+ rrd_simple_file = (rrd_simple_file_t *)rrd_file->pvt;
+
+ {
+#if defined(_WIN32) && !defined(__CYGWIN__) && !defined(__CYGWIN32__)
+ struct _stat st;
+
+ if (_fstat(rrd_simple_file->fd, &st) == 0) {
+ rcstat = _locking(rrd_simple_file->fd, _LK_NBLCK, st.st_size);
+ } else {
+ rcstat = -1;
+ }
+#else
+ struct flock lock;
+
+ lock.l_type = F_WRLCK; /* exclusive write lock */
+ lock.l_len = 0; /* whole file */
+ lock.l_start = 0; /* start of file */
+ lock.l_whence = SEEK_SET; /* end of file */
+
+ rcstat = fcntl(rrd_simple_file->fd, F_SETLK, &lock);
+#endif
+ }
+
+ return (rcstat);
+}
+
+
+/* drop cache except for the header and the active pages */
+void rrd_dontneed(
+ rrd_file_t *rrd_file,
+ rrd_t *rrd)
+{
+ rrd_simple_file_t *rrd_simple_file = (rrd_simple_file_t *)rrd_file->pvt;
+#if defined USE_MADVISE || defined HAVE_POSIX_FADVISE
+ size_t dontneed_start;
+ size_t rra_start;
+ size_t active_block;
+ size_t i;
+ ssize_t _page_size = sysconf(_SC_PAGESIZE);
+
+ if (rrd_file == NULL) {
+#if defined DEBUG && DEBUG
+ fprintf (stderr, "rrd_dontneed: Argument 'rrd_file' is NULL.\n");
+#endif
+ return;
+ }
+
+#if defined DEBUG && DEBUG > 1
+ mincore_print(rrd_file, "before");
+#endif
+
+ /* ignoring errors from RRDs that are smaller then the file_len+rounding */
+ rra_start = rrd_file->header_len;
+ dontneed_start = PAGE_START(rra_start) + _page_size;
+ for (i = 0; i < rrd->stat_head->rra_cnt; ++i) {
+ active_block =
+ PAGE_START(rra_start
+ + rrd->rra_ptr[i].cur_row
+ * rrd->stat_head->ds_cnt * sizeof(rrd_value_t));
+ if (active_block > dontneed_start) {
+#ifdef USE_MADVISE
+ madvise(rrd_simple_file->file_start + dontneed_start,
+ active_block - dontneed_start - 1, MADV_DONTNEED);
+#endif
+/* in linux at least only fadvise DONTNEED seems to purge pages from cache */
+#ifdef HAVE_POSIX_FADVISE
+ posix_fadvise(rrd_simple_file->fd, dontneed_start,
+ active_block - dontneed_start - 1,
+ POSIX_FADV_DONTNEED);
+#endif
+ }
+ dontneed_start = active_block;
+ /* do not release 'hot' block if update for this RAA will occur
+ * within 10 minutes */
+ if (rrd->stat_head->pdp_step * rrd->rra_def[i].pdp_cnt -
+ rrd->live_head->last_up % (rrd->stat_head->pdp_step *
+ rrd->rra_def[i].pdp_cnt) < 10 * 60) {
+ dontneed_start += _page_size;
+ }
+ rra_start +=
+ rrd->rra_def[i].row_cnt * rrd->stat_head->ds_cnt *
+ sizeof(rrd_value_t);
+ }
+
+ if (dontneed_start < rrd_file->file_len) {
+#ifdef USE_MADVISE
+ madvise(rrd_simple_file->file_start + dontneed_start,
+ rrd_file->file_len - dontneed_start, MADV_DONTNEED);
+#endif
+#ifdef HAVE_POSIX_FADVISE
+ posix_fadvise(rrd_simple_file->fd, dontneed_start,
+ rrd_file->file_len - dontneed_start,
+ POSIX_FADV_DONTNEED);
+#endif
+ }
+
+#if defined DEBUG && DEBUG > 1
+ mincore_print(rrd_file, "after");
+#endif
+#endif /* without madvise and posix_fadvise it does not make much sense todo anything */
+}
+
+
+
+
+
+int rrd_close(
+ rrd_file_t *rrd_file)
+{
+ rrd_simple_file_t *rrd_simple_file;
+ rrd_simple_file = (rrd_simple_file_t *)rrd_file->pvt;
+ int ret;
+
+#ifdef HAVE_MMAP
+ ret = msync(rrd_simple_file->file_start, rrd_file->file_len, MS_ASYNC);
+ if (ret != 0)
+ rrd_set_error("msync rrd_file: %s", rrd_strerror(errno));
+ ret = munmap(rrd_simple_file->file_start, rrd_file->file_len);
+ if (ret != 0)
+ rrd_set_error("munmap rrd_file: %s", rrd_strerror(errno));
+#endif
+ ret = close(rrd_simple_file->fd);
+ if (ret != 0)
+ rrd_set_error("closing file: %s", rrd_strerror(errno));
+ free(rrd_file->pvt);
+ free(rrd_file);
+ rrd_file = NULL;
+ return ret;
+}
+
+
+/* Set position of rrd_file. */
+
+off_t rrd_seek(
+ rrd_file_t *rrd_file,
+ off_t off,
+ int whence)
+{
+ off_t ret = 0;
+ rrd_simple_file_t *rrd_simple_file;
+ rrd_simple_file = (rrd_simple_file_t *)rrd_file->pvt;
+
+#ifdef HAVE_MMAP
+ if (whence == SEEK_SET)
+ rrd_file->pos = off;
+ else if (whence == SEEK_CUR)
+ rrd_file->pos += off;
+ else if (whence == SEEK_END)
+ rrd_file->pos = rrd_file->file_len + off;
+#else
+ ret = lseek(rrd_simple_file->fd, off, whence);
+ if (ret < 0)
+ rrd_set_error("lseek: %s", rrd_strerror(errno));
+ rrd_file->pos = ret;
+#endif
+ /* mimic fseek, which returns 0 upon success */
+ return ret < 0; /*XXX: or just ret to mimic lseek */
+}
+
+
+/* Get current position in rrd_file. */
+
+off_t rrd_tell(
+ rrd_file_t *rrd_file)
+{
+ return rrd_file->pos;
+}
+
+
+/* Read count bytes into buffer buf, starting at rrd_file->pos.
+ * Returns the number of bytes read or <0 on error. */
+
+ssize_t rrd_read(
+ rrd_file_t *rrd_file,
+ void *buf,
+ size_t count)
+{
+ rrd_simple_file_t *rrd_simple_file = (rrd_simple_file_t *)rrd_file->pvt;
+#ifdef HAVE_MMAP
+ size_t _cnt = count;
+ ssize_t _surplus;
+
+ if (rrd_file->pos > rrd_file->file_len || _cnt == 0) /* EOF */
+ return 0;
+ if (buf == NULL)
+ return -1; /* EINVAL */
+ _surplus = rrd_file->pos + _cnt - rrd_file->file_len;
+ if (_surplus > 0) { /* short read */
+ _cnt -= _surplus;
+ }
+ if (_cnt == 0)
+ return 0; /* EOF */
+ buf = memcpy(buf, rrd_simple_file->file_start + rrd_file->pos, _cnt);
+
+ rrd_file->pos += _cnt; /* mimmic read() semantics */
+ return _cnt;
+#else
+ ssize_t ret;
+
+ ret = read(rrd_simple_file->fd, buf, count);
+ if (ret > 0)
+ rrd_file->pos += ret; /* mimmic read() semantics */
+ return ret;
+#endif
+}
+
+
+/* Write count bytes from buffer buf to the current position
+ * rrd_file->pos of rrd_simple_file->fd.
+ * Returns the number of bytes written or <0 on error. */
+
+ssize_t rrd_write(
+ rrd_file_t *rrd_file,
+ const void *buf,
+ size_t count)
+{
+ rrd_simple_file_t *rrd_simple_file = (rrd_simple_file_t *)rrd_file->pvt;
+#ifdef HAVE_MMAP
+ size_t old_size = rrd_file->file_len;
+ if (count == 0)
+ return 0;
+ if (buf == NULL)
+ return -1; /* EINVAL */
+
+ if((rrd_file->pos + count) > old_size)
+ {
+ rrd_set_error("attempting to write beyond end of file");
+ return -1;
}
- MYFREAD(rrd->pdp_prep, pdp_prep_t, rrd->stat_head->ds_cnt)
- MYFREAD(rrd->cdp_prep, cdp_prep_t, (rrd->stat_head->rra_cnt
- * rrd->stat_head->ds_cnt))
- MYFREAD(rrd->rra_ptr, rra_ptr_t, rrd->stat_head->rra_cnt)
-#undef MYFREAD
+ memcpy(rrd_simple_file->file_start + rrd_file->pos, buf, count);
+ rrd_file->pos += count;
+ return count; /* mimmic write() semantics */
+#else
+ ssize_t _sz = write(rrd_simple_file->fd, buf, count);
+
+ if (_sz > 0)
+ rrd_file->pos += _sz;
+ return _sz;
+#endif
+}
- return(0);
+
+/* this is a leftover from the old days, it serves no purpose
+ and is therefore turned into a no-op */
+void rrd_flush(
+ rrd_file_t *rrd_file __attribute__((unused)))
+{
}
-void rrd_init(rrd_t *rrd)
+/* Initialize RRD header. */
+
+void rrd_init(
+ rrd_t *rrd)
{
rrd->stat_head = NULL;
rrd->ds_def = NULL;
rrd->rra_def = NULL;
rrd->live_head = NULL;
+ rrd->legacy_last_up = NULL;
rrd->rra_ptr = NULL;
rrd->pdp_prep = NULL;
rrd->cdp_prep = NULL;
rrd->rrd_value = NULL;
}
-void rrd_free(rrd_t *rrd)
+
+/* free RRD header data. */
+
+#ifdef HAVE_MMAP
+void rrd_free(
+ rrd_t *rrd)
{
- if (rrd->stat_head) free(rrd->stat_head);
- if (rrd->ds_def) free(rrd->ds_def);
- if (rrd->rra_def) free(rrd->rra_def);
- if (rrd->live_head) free(rrd->live_head);
- if (rrd->rra_ptr) free(rrd->rra_ptr);
- if (rrd->pdp_prep) free(rrd->pdp_prep);
- if (rrd->cdp_prep) free(rrd->cdp_prep);
- if (rrd->rrd_value) free(rrd->rrd_value);
+ if (rrd->legacy_last_up) { /* this gets set for version < 3 only */
+ free(rrd->live_head);
+ }
+}
+#else
+void rrd_free(
+ rrd_t *rrd)
+{
+ free(rrd->live_head);
+ free(rrd->stat_head);
+ free(rrd->ds_def);
+ free(rrd->rra_def);
+ free(rrd->rra_ptr);
+ free(rrd->pdp_prep);
+ free(rrd->cdp_prep);
+ free(rrd->rrd_value);
}
+#endif
+
/* routine used by external libraries to free memory allocated by
* rrd library */
-void rrd_freemem(void *mem)
-{
- if (mem) free(mem);
+void rrd_freemem(
+ void *mem)
+{
+ free(mem);
}
-int readfile(const char *file_name, char **buffer, int skipfirst){
- long writecnt=0,totalcnt = MEMBLK;
- long offset = 0;
- FILE *input=NULL;
- char c ;
- if ((strcmp("-",file_name) == 0)) { input = stdin; }
- else {
- if ((input = fopen(file_name,"rb")) == NULL ){
- rrd_set_error("opening '%s': %s",file_name,rrd_strerror(errno));
- return (-1);
- }
- }
- if (skipfirst){
- do { c = getc(input); offset++; } while (c != '\n' && ! feof(input));
- }
- if (strcmp("-",file_name)) {
- fseek(input, 0, SEEK_END);
- /* have extra space for detecting EOF without realloc */
- totalcnt = (ftell(input) + 1) / sizeof(char) - offset;
- if (totalcnt < MEMBLK)
- totalcnt = MEMBLK; /* sanitize */
- fseek(input, offset * sizeof(char), SEEK_SET);
- }
- if (((*buffer) = (char *) malloc((totalcnt+4) * sizeof(char))) == NULL) {
- perror("Allocate Buffer:");
- exit(1);
- };
- do{
- writecnt += fread((*buffer)+writecnt, 1, (totalcnt - writecnt) * sizeof(char),input);
- if (writecnt >= totalcnt){
- totalcnt += MEMBLK;
- if (((*buffer)=rrd_realloc((*buffer), (totalcnt+4) * sizeof(char)))==NULL){
- perror("Realloc Buffer:");
- exit(1);
- };
- }
- } while (! feof(input));
- (*buffer)[writecnt] = '\0';
- if (strcmp("-",file_name) != 0) {fclose(input);};
- return writecnt;
+/*
+ * rra_update informs us about the RRAs being updated
+ * The low level storage API may use this information for
+ * aligning RRAs within stripes, or other performance enhancements
+ */
+void rrd_notify_row(
+ rrd_file_t *rrd_file __attribute__((unused)),
+ int rra_idx __attribute__((unused)),
+ unsigned long rra_row __attribute__((unused)),
+ time_t rra_time __attribute__((unused)))
+{
}
-
+/*
+ * This function is called when creating a new RRD
+ * The storage implementation can use this opportunity to select
+ * a sensible starting row within the file.
+ * The default implementation is random, to ensure that all RRAs
+ * don't change to a new disk block at the same time
+ */
+unsigned long rrd_select_initial_row(
+ rrd_file_t *rrd_file __attribute__((unused)),
+ int rra_idx __attribute__((unused)),
+ rra_def_t *rra
+ )
+{
+ return rrd_random() % rra->row_cnt;
+}