+ rrd_file = 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));
+
+#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
+ if (rdwr & RRD_READONLY) {
+ flags |= O_RDONLY;
+#ifdef HAVE_MMAP
+ mm_flags = MAP_PRIVATE;
+# ifdef MAP_NORESERVE
+ mm_flags |= MAP_NORESERVE; /* readonly, so no swap backing needed */
+# endif
+#endif
+ } else {
+ if (rdwr & RRD_READWRITE) {
+ mode |= S_IWUSR;
+ flags |= O_RDWR;
+#ifdef HAVE_MMAP
+ mm_flags = MAP_SHARED;
+ mm_prot |= PROT_WRITE;
+#endif
+ }
+ if (rdwr & RRD_CREAT) {
+ flags |= (O_CREAT | O_TRUNC);
+ }
+ }
+ if (rdwr & RRD_READAHEAD) {
+#ifdef MAP_POPULATE
+ mm_flags |= MAP_POPULATE; /* populate ptes and data */
+#endif
+#if defined MAP_NONBLOCK
+ mm_flags |= MAP_NONBLOCK; /* just populate ptes */
+#endif
+#ifdef USE_DIRECT_IO
+ } else {
+ flags |= O_DIRECT;
+#endif
+ }
+#ifdef O_NONBLOCK
+ flags |= O_NONBLOCK;
+#endif
+
+ if ((rrd_file->fd = open(file_name, flags, mode)) < 0) {
+ rrd_set_error("opening '%s': %s", file_name, rrd_strerror(errno));
+ goto out_free;
+ }
+
+ /* 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_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_file->fd, newfile_size - 1, SEEK_SET);
+ write(rrd_file->fd, "\0", 1); /* poke */
+ lseek(rrd_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(rrd_file->fd, 0, 0, POSIX_FADV_RANDOM)) {
+ rrd_set_error("setting POSIX_FADV_RANDOM on '%s': %s", file_name,
+ rrd_strerror(errno));
+ goto out_close;
+ }
+#endif
+
+/*
+ if (rdwr & RRD_READWRITE)
+ {
+ if (setvbuf((rrd_file->fd),NULL,_IONBF,2)) {
+ rrd_set_error("failed to disable the stream buffer\n");
+ return (-1);
+ }
+ }
+*/
+#ifdef HAVE_MMAP
+ data = mmap(0, rrd_file->file_len, mm_prot, mm_flags,
+ rrd_file->fd, offset);
+
+ /* lets see if the first read worked */
+ if (data == MAP_FAILED) {
+ rrd_set_error("mmaping file '%s': %s", file_name,
+ rrd_strerror(errno));
+ goto out_close;
+ }
+ rrd_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 | MADV_SEQUENTIAL);
+ } else {
+# ifndef ONE_PAGE
+ /* We do not need to read anything in for the moment */
+ _madvise(data, rrd_file->file_len, MADV_DONTNEED);
+ /* the stat_head will be needed soonish, so hint accordingly */
+ _madvise(data + PAGE_ALIGN_DOWN(offset),
+ PAGE_ALIGN(sizeof(stat_head_t)),
+ MADV_WILLNEED | MADV_RANDOM);
+
+# else
+/* alternatively: keep 1 page worth of data, likely headers,
+ * don't need the rest. */
+ _madvise(data, _page_size, MADV_WILLNEED | MADV_SEQUENTIAL);
+ _madvise(data + _page_size, (rrd_file->file_len >= _page_size)
+ ? rrd_file->file_len - _page_size : 0, MADV_DONTNEED);
+# endif
+ }
+#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);
+ goto out_nullify_head;
+ }
+#if defined USE_MADVISE && !defined ONE_PAGE
+ /* the ds_def will be needed soonish, so hint accordingly */
+ _madvise(data + PAGE_ALIGN_DOWN(offset),
+ PAGE_ALIGN(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 && !defined ONE_PAGE
+ /* the rra_def will be needed soonish, so hint accordingly */
+ _madvise(data + PAGE_ALIGN_DOWN(offset),
+ PAGE_ALIGN(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);
+
+ /* 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");
+ goto out_close;
+ }
+#ifdef HAVE_MMAP
+ memmove(&rrd->live_head->last_up, data + offset, sizeof(long));
+ offset += sizeof(long);