/*****************************************************************************
- * RRDtool 1.3rc6 Copyright by Tobi Oetiker, 1997-2008
+ * RRDtool 1.3.2 Copyright by Tobi Oetiker, 1997-2008
*****************************************************************************
* rrd_open.c Open an RRD File
*****************************************************************************
/* 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) \
+#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 += sizeof(dst_t) * (cnt)
+ offset += wanted; \
+ }
#else
-#define __rrd_read(dst, dst_t, cnt) \
- if ((dst = malloc(sizeof(dst_t)*(cnt))) == NULL) { \
+#define __rrd_read(dst, dst_t, cnt) { \
+ size_t wanted = sizeof(dst_t)*(cnt); \
+ size_t got; \
+ if ((dst = malloc(wanted)) == NULL) { \
rrd_set_error(#dst " malloc"); \
goto out_nullify_head; \
} \
- offset += read (rrd_file->fd, dst, sizeof(dst_t)*(cnt))
+ got = read (rrd_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
*/
rrd_file_t *rrd_open(
rrd_t *rrd,
unsigned rdwr)
{
+ int i;
int flags = 0;
mode_t mode = S_IRUSR;
int version;
#ifdef HAVE_MMAP
ssize_t _page_size = sysconf(_SC_PAGESIZE);
- int mm_prot = PROT_READ, mm_flags = 0;
- char *data;
+ char *data = MAP_FAILED;
#endif
off_t offset = 0;
struct stat statb;
rrd_file_t *rrd_file = NULL;
off_t newfile_size = 0;
-
- if (rdwr & RRD_CREAT) {
- /* yes bad inline signaling alert, we are using the
- floatcookie to pass the size in ... only used in resize */
- newfile_size = (off_t) rrd->stat_head->float_cookie;
- free(rrd->stat_head);
+ off_t header_len, value_cnt, data_len;
+
+ /* Are we creating a new file? */
+ if((rdwr & RRD_CREAT) && (rrd->stat_head != NULL))
+ {
+ header_len = \
+ sizeof(stat_head_t) + \
+ sizeof(ds_def_t) * rrd->stat_head->ds_cnt + \
+ sizeof(rra_def_t) * rrd->stat_head->rra_cnt + \
+ sizeof(time_t) + \
+ sizeof(live_head_t) + \
+ sizeof(pdp_prep_t) * rrd->stat_head->ds_cnt + \
+ sizeof(cdp_prep_t) * rrd->stat_head->ds_cnt * rrd->stat_head->rra_cnt + \
+ sizeof(rra_ptr_t) * rrd->stat_head->rra_cnt;
+
+ value_cnt = 0;
+ for (i = 0; i < rrd->stat_head->rra_cnt; i++)
+ value_cnt += rrd->stat_head->ds_cnt * rrd->rra_def[i].row_cnt;
+
+ data_len = sizeof(rrd_value_t) * value_cnt;
+
+ newfile_size = header_len + data_len;
}
- rrd_init(rrd);
+
rrd_file = malloc(sizeof(rrd_file_t));
if (rrd_file == NULL) {
rrd_set_error("allocating rrd_file descriptor for '%s'", file_name);
exit(-1);
}
#endif
+
+#ifdef HAVE_MMAP
+ rrd_file->mm_prot = PROT_READ;
+ rrd_file->mm_flags = 0;
+#endif
+
if (rdwr & RRD_READONLY) {
flags |= O_RDONLY;
#ifdef HAVE_MMAP
- mm_flags = MAP_PRIVATE;
+ rrd_file->mm_flags = MAP_PRIVATE;
# ifdef MAP_NORESERVE
- mm_flags |= MAP_NORESERVE; /* readonly, so no swap backing needed */
+ rrd_file->mm_flags |= MAP_NORESERVE; /* readonly, so no swap backing needed */
# endif
#endif
} else {
mode |= S_IWUSR;
flags |= O_RDWR;
#ifdef HAVE_MMAP
- mm_flags = MAP_SHARED;
- mm_prot |= PROT_WRITE;
+ rrd_file->mm_flags = MAP_SHARED;
+ rrd_file->mm_prot |= PROT_WRITE;
#endif
}
if (rdwr & RRD_CREAT) {
}
if (rdwr & RRD_READAHEAD) {
#ifdef MAP_POPULATE
- mm_flags |= MAP_POPULATE; /* populate ptes and data */
+ rrd_file->mm_flags |= MAP_POPULATE; /* populate ptes and data */
#endif
#if defined MAP_NONBLOCK
- mm_flags |= MAP_NONBLOCK; /* just populate ptes */
+ rrd_file->mm_flags |= MAP_NONBLOCK; /* just populate ptes */
#endif
}
+#if defined(_WIN32) && !defined(__CYGWIN__) && !defined(__CYGWIN32__)
+ flags |= O_BINARY;
+#endif
if ((rrd_file->fd = open(file_name, flags, mode)) < 0) {
rrd_set_error("opening '%s': %s", file_name, rrd_strerror(errno));
}
}
*/
+
#ifdef HAVE_MMAP
- data = mmap(0, rrd_file->file_len, mm_prot, mm_flags,
+ data = mmap(0, rrd_file->file_len, rrd_file->mm_prot, rrd_file->mm_flags,
rrd_file->fd, offset);
/* lets see if the first read worked */
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);
+ 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 {
rrd_file->header_len = offset;
rrd_file->pos = offset;
+
+ {
+ unsigned long row_cnt = 0;
+ unsigned long i;
+
+ for (i=0; i<rrd->stat_head->rra_cnt; i++)
+ row_cnt += rrd->rra_def[i].row_cnt;
+
+ off_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_file->fd);
out_free:
free(rrd_file);
}
#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 *file)
+{
+ int rcstat;
+
+ {
+#if defined(_WIN32) && !defined(__CYGWIN__) && !defined(__CYGWIN32__)
+ struct _stat st;
+
+ if (_fstat(file->fd, &st) == 0) {
+ rcstat = _locking(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(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)
{
- unsigned long dontneed_start;
- unsigned long rra_start;
- unsigned long active_block;
+#if defined USE_MADVISE || defined HAVE_POSIX_FADVISE
+ off_t dontneed_start;
+ off_t rra_start;
+ off_t active_block;
unsigned long 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
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_file->file_start + dontneed_start,
- rrd_file->file_len - dontneed_start, MADV_DONTNEED);
+ madvise(rrd_file->file_start + dontneed_start,
+ rrd_file->file_len - dontneed_start, MADV_DONTNEED);
#endif
#ifdef HAVE_POSIX_FADVISE
- posix_fadvise(rrd_file->fd, dontneed_start,
- rrd_file->file_len - dontneed_start, POSIX_FADV_DONTNEED);
+ posix_fadvise(rrd_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 ist does not make much sense todo anything */
}
+
+
+
+
int rrd_close(
rrd_file_t *rrd_file)
{
/* Get current position in rrd_file. */
-inline off_t rrd_tell(
+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. */
-inline ssize_t rrd_read(
+ssize_t rrd_read(
rrd_file_t *rrd_file,
void *buf,
size_t count)
* rrd_file->pos of rrd_file->fd.
* Returns the number of bytes written or <0 on error. */
-inline ssize_t rrd_write(
+ssize_t rrd_write(
rrd_file_t *rrd_file,
const void *buf,
size_t count)
{
#ifdef HAVE_MMAP
+ int 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;
+ }
memcpy(rrd_file->file_start + rrd_file->pos, buf, count);
rrd_file->pos += count;
return count; /* mimmic write() semantics */
/* flush all data pending to be written to FD. */
-inline void rrd_flush(
+void rrd_flush(
rrd_file_t *rrd_file)
{
if (fdatasync(rrd_file->fd) != 0) {
void rrd_free(
rrd_t *rrd)
{
- if (rrd->legacy_last_up){ /* this gets set for version < 3 only */
- free(rrd->live_head);
+ if (rrd->legacy_last_up) { /* this gets set for version < 3 only */
+ free(rrd->live_head);
}
}
#else
{
free(mem);
}
-
-
-/* XXX: FIXME: missing documentation. */
-/*XXX: FIXME should be renamed to rrd_readfile or _rrd_readfile */
-
-int /*_rrd_*/ 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;
-}