X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=src%2Frrd_open.c;h=c29741ce495777d746237c2cb1aee8a4e8f8feb1;hb=818549a636c390fb4a8390a7e2195a52293cd56b;hp=98a52e001b6322c28b6768bf400b9d60eefbdf0d;hpb=dc963c8dec77b23f68dc91dc857c463f1c13e420;p=rrdtool.git

diff --git a/src/rrd_open.c b/src/rrd_open.c
index 98a52e0..c29741c 100644
--- a/src/rrd_open.c
+++ b/src/rrd_open.c
@@ -1,5 +1,5 @@
 /*****************************************************************************
- * RRDtool 1.2.0  Copyright by Tobi Oetiker, 1997-2005
+ * RRDtool 1.2.23  Copyright by Tobi Oetiker, 1997-2007
  *****************************************************************************
  * rrd_open.c  Open an RRD File
  *****************************************************************************
@@ -63,102 +63,252 @@
  *****************************************************************************/
 
 #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 */
 
-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)
 {
-
-    
-    char *mode = NULL;
-    int version;
-    
-    rrd_init(rrd);
-    if (rdwr == RRD_READONLY) {
-#if defined(WIN32)
-	mode = "rb";
-#else
-	mode = "r";
+	int flags = 0;
+	mode_t mode = S_IRUSR;
+	int version, prot = PROT_READ;
+	off_t offset = 0;
+	char *data;
+	struct stat statb;
+	rrd_file_t *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));
+	rrd_init(rrd);
+	if (rdwr == RRD_READWRITE) {
+		mode |= S_IWUSR;
+		prot |= PROT_WRITE;
+	} else if (rdwr == RRD_CREAT) {
+		mode |= S_IWUSR;
+		prot |= PROT_WRITE;
+		flags |= (O_CREAT|O_TRUNC);
+	}
+#ifdef O_NONBLOCK
+	flags |= O_NONBLOCK;
 #endif
-    } else {
-#if defined(WIN32)
-	mode = "rb+";
-#else
-	mode = "r+";
+
+	if ((rrd_file->fd = open(file_name, flags, mode)) < 0 ){
+		rrd_set_error("opening '%s': %s",file_name, rrd_strerror(errno));
+		return NULL;
+	}
+
+	/* ???: length = lseek(rrd_file->fd, 0, SEEK_END); */
+	/* ??? locking the whole area of the file may overdo it a bit, does it? */
+	if ((fstat(rrd_file->fd, &statb)) < 0) {
+		rrd_set_error("fstat '%s': %s",file_name, rrd_strerror(errno));
+		goto out_close;
+	}
+	rrd_file->file_len = statb.st_size;
+
+#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 (((*in_file) = fopen(file_name,mode)) == NULL ){
-	rrd_set_error("opening '%s': %s",file_name, rrd_strerror(errno));
-	return (-1);
-    }
+
 /*
-	if (rdwr == RRD_READWRITE)
-	{
-	   if (setvbuf((*in_file),NULL,_IONBF,2)) {
-		  rrd_set_error("failed to disable the stream buffer\n");
-		  return (-1);
-	   }
-	}
+        if (rdwr == RRD_READWRITE)
+        {
+           if (setvbuf((rrd_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); 
-
-
-    MYFREAD(rrd->stat_head, stat_head_t,  1)
-    version = atoi(rrd->stat_head->version);
-
-	/* 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);
-	    fclose(*in_file);
-	    return(-1);}
-
-        if (version > atoi(RRD_VERSION)){
-	    rrd_set_error("can't handle RRD file version %s",
-			rrd->stat_head->version);
-	    free(rrd->stat_head);
-	    fclose(*in_file);
-	    return(-1);}
+	data = mmap(0, rrd_file->file_len, prot, MAP_SHARED,
+		rrd_file->fd, offset);
+
+	/* lets see if the first read worked */
+	if (data == MAP_FAILED) {
+		rrd_set_error("error mmaping file '%s'",file_name);
+		goto out_close;
+	}
+	rrd_file->file_start = data;
+#ifdef USE_MADVISE
+	if (rrd == NULL) { /*XXX: currently not used! */
+		/* We will read everything in a moment (copying) */
+		madvise(data, rrd_file->file_len, MADV_WILLNEED|MADV_SEQUENTIAL);
+		goto out_done;
+	}
+	/* We do not need to read anything in for the moment */
+	madvise(data, rrd_file->file_len, MADV_DONTNEED);
+#endif
+
+#ifdef USE_MADVISE
+	/* the stat_head will be needed soonish, so hint accordingly */
+	madvise(data+offset, sizeof(stat_head_t), MADV_WILLNEED);
+#endif
+
+	rrd->stat_head = (stat_head_t*)(data + offset);
+	offset += sizeof(stat_head_t);
+
+        /* 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 other architecture");
-	    free(rrd->stat_head);
-	    fclose(*in_file);
-	    return(-1);}
+		rrd_set_error("This RRD was created on other 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;
+	}
+
+#ifdef USE_MADVISE
+	/* the ds_def will be needed soonish, so hint accordingly */
+	madvise(data+offset, sizeof(ds_def_t)*rrd->stat_head->ds_cnt, MADV_WILLNEED);
+#endif
+	rrd->ds_def = (ds_def_t*)(data + offset);
+	offset += sizeof(ds_def_t) * rrd->stat_head->ds_cnt;
+
+#ifdef USE_MADVISE
+	/* the rra_def will be needed soonish, so hint accordingly */
+	madvise(data+offset, sizeof(rra_def_t)*rrd->stat_head->rra_cnt, MADV_WILLNEED);
+#endif
+	rrd->rra_def = (rra_def_t*)(data + offset);
+	offset += sizeof(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);
-	    }
-		fread(&rrd->live_head->last_up, sizeof(long), 1, *in_file); 
+	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;
+            }
+		memmove(&rrd->live_head->last_up, data+offset, sizeof(long));
 		rrd->live_head->last_up_usec = 0;
-    }
-    else {
-	    MYFREAD(rrd->live_head, live_head_t, 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
+	} else {
+#ifdef USE_MADVISE
+		/* the live_head will be needed soonish, so hint accordingly */
+		madvise(data+offset, sizeof(live_head_t), MADV_WILLNEED);
+#endif
+		rrd->live_head = (live_head_t*)(data + offset);
+		offset += sizeof(live_head_t);
+	}
+// This doesn't look like it needs madvise
+	rrd->pdp_prep = (pdp_prep_t*)(data + offset);
+	offset += sizeof(pdp_prep_t) * rrd->stat_head->ds_cnt;
+
+// This could benefit from madvise()ing
+	rrd->cdp_prep = (cdp_prep_t*)(data + offset);
+	offset += sizeof(cdp_prep_t) *
+				(rrd->stat_head->rra_cnt * rrd->stat_head->ds_cnt);
+
+// This could benefit from madvise()ing
+	rrd->rra_ptr = (rra_ptr_t*)(data + offset);
+	offset += sizeof(rra_ptr_t) * rrd->stat_head->rra_cnt;
+#ifdef USE_MADVISE
+out_done:
+#endif
+	rrd_file->header_len = offset;
+	rrd_file->pos = offset;
+/* we could close(rrd_file->fd); here, the mapping is still valid anyway */
+	return (rrd_file);
+out_nullify_head:
+	rrd->stat_head = NULL;
+out_close:
+	close(rrd_file->fd);
+	return NULL;
+}
+
+/* Close a reference to an rrd_file.  */
+int rrd_close(rrd_file_t* rrd_file) {
+	int ret = 0;
+#ifdef HAVE_MMAP
+	ret = munmap(rrd_file->file_start, rrd_file->file_len);
+//	if (ret != 0)
+//		rrd_set_error("munmap rrd_file");
+#endif
+	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;
+#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_file->fd, off, whence);
+	if (ret < 0)
+		rrd_set_error("lseek: %s", rrd_strerror(errno));
+	rrd_file->pos = ret;
+#endif
+//XXX: mimic fseek, which returns 0 upon success
+	return ret == -1; //XXX: or just ret to mimic lseek
+}
 
-    return(0);
+/* 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.  */
+ssize_t rrd_read(rrd_file_t* rrd_file, void*buf, size_t count) {
+#ifdef HAVE_MMAP
+	char* pos = rrd_file->file_start + rrd_file->pos;
+	buf = memmove(buf, pos, count);
+	return count;
+#else
+	ssize_t ret;
+	ret = read(rrd_file->fd, buf, count);
+	//XXX: eventually add generic rrd_set_error(""); here
+	return ret;
+#endif
+}
+
+/* write count bytes from buffer buf to the current position
+ * rrd_file->pos of rrd_file->fd.  */
+ssize_t rrd_write(rrd_file_t * rrd_file, const void*buf, size_t count) {
+	ssize_t ret = count;
+#ifdef HAVE_MMAP
+	char *off, *new_pos;
+	off = rrd_file->file_start + rrd_file->pos;
+	new_pos = memmove(rrd_file->file_start + rrd_file->pos, buf, count);
+	ret = new_pos - off;
+#else
+	ret = write(rrd_file->fd, buf, count)
+#endif
+	return ret;
+}
+
+/* flush all data pending to be written to FD.  */
+void rrd_flush(rrd_file_t* rrd_file)
+{
+	if (fdatasync(rrd_file->fd) != 0) {
+		rrd_set_error("flushing fd %d: %s", rrd_file->fd,
+			rrd_strerror(errno));
+	}
 }
 
 void rrd_init(rrd_t *rrd)
@@ -173,24 +323,26 @@ void rrd_init(rrd_t *rrd)
     rrd->rrd_value = NULL;
 }
 
-void rrd_free(rrd_t *rrd)
+void rrd_free(rrd_t UNUSED(*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);
+#ifndef HAVE_MMAP
+    if (atoi(rrd->stat_head->version) < 3)
+	    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);
+	free(mem);
 }
 
 int readfile(const char *file_name, char **buffer, int skipfirst){
@@ -201,8 +353,8 @@ int readfile(const char *file_name, char **buffer, int skipfirst){
     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);
+        rrd_set_error("opening '%s': %s",file_name,rrd_strerror(errno));
+        return (-1);
       }
     }
     if (skipfirst){
@@ -213,21 +365,21 @@ int readfile(const char *file_name, char **buffer, int skipfirst){
       /* have extra space for detecting EOF without realloc */
       totalcnt = (ftell(input) + 1) / sizeof(char) - offset;
       if (totalcnt < MEMBLK)
-	totalcnt = MEMBLK; /* sanitize */
+        totalcnt = MEMBLK; /* sanitize */
       fseek(input, offset * sizeof(char), SEEK_SET);
     }
     if (((*buffer) = (char *) malloc((totalcnt+4) * sizeof(char))) == NULL) {
-	perror("Allocate Buffer:");
-	exit(1);
+        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);
-	};
+        totalcnt += MEMBLK;
+        if (((*buffer)=rrd_realloc((*buffer), (totalcnt+4) * sizeof(char)))==NULL){
+            perror("Realloc Buffer:");
+            exit(1);
+        };
       }
     } while (! feof(input));
     (*buffer)[writecnt] = '\0';
@@ -235,4 +387,3 @@ int readfile(const char *file_name, char **buffer, int skipfirst){
     return writecnt;
 }
 
-