X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=src%2Frrd_open.c;h=8ae5fd8b61143853d2010d33c80de70b44b7e39a;hb=96ad6b9f7c010948131ba7a8d9c0eea2d448e8ee;hp=f6aae3b114f0bc1bafabc76ea2257b117db460b8;hpb=3c268443bb768669f3bd095b9e95a9a5ab4c5ef2;p=rrdtool.git diff --git a/src/rrd_open.c b/src/rrd_open.c index f6aae3b..8ae5fd8 100644 --- a/src/rrd_open.c +++ b/src/rrd_open.c @@ -1,5 +1,5 @@ /***************************************************************************** - * 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 ***************************************************************************** @@ -21,28 +21,47 @@ /* 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( @@ -50,27 +69,43 @@ 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); @@ -86,12 +121,18 @@ rrd_file_t *rrd_open( 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 { @@ -99,8 +140,8 @@ rrd_file_t *rrd_open( 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) { @@ -109,12 +150,15 @@ rrd_file_t *rrd_open( } 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)); @@ -152,8 +196,9 @@ rrd_file_t *rrd_open( } } */ + #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 */ @@ -226,13 +271,13 @@ rrd_file_t *rrd_open( 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 { @@ -253,11 +298,34 @@ rrd_file_t *rrd_open( rrd_file->header_len = offset; rrd_file->pos = offset; + + { + unsigned long row_cnt = 0; + unsigned long i; + + for (i=0; istat_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); @@ -310,18 +378,61 @@ void mincore_print( } #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 @@ -358,19 +469,29 @@ void rrd_dontneed( 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) { @@ -422,7 +543,7 @@ off_t rrd_seek( /* Get current position in rrd_file. */ -inline off_t rrd_tell( +off_t rrd_tell( rrd_file_t *rrd_file) { return rrd_file->pos; @@ -432,7 +553,7 @@ inline off_t rrd_tell( /* 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) @@ -470,16 +591,23 @@ inline ssize_t rrd_read( * 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 */ @@ -495,7 +623,7 @@ inline ssize_t rrd_write( /* 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) { @@ -528,8 +656,8 @@ void rrd_init( 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 @@ -556,64 +684,3 @@ void rrd_freemem( { 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; -}