diff --git a/src/rrd_update.c b/src/rrd_update.c
index 561dc054547994022f7681bd2bcd103f57dc0c12..dbafa3b6f01e5c56f1bbcf4638ab54801caaf7b2 100644 (file)
--- a/src/rrd_update.c
+++ b/src/rrd_update.c
/*****************************************************************************
- * RRDtool 1.3rc5 Copyright by Tobi Oetiker, 1997-2008
+ * RRDtool 1.3.9 Copyright by Tobi Oetiker, 1997-2009
*****************************************************************************
* rrd_update.c RRD Update Function
*****************************************************************************
#include <locale.h>
+#ifdef WIN32
+#include <stdlib.h>
+#endif
+
#include "rrd_hw.h"
#include "rrd_rpncalc.h"
const char *tmplt,
int argc,
const char **argv,
- info_t *);
+ rrd_info_t *);
static int allocate_data_structures(
rrd_t *rrd,
rrd_t *rrd,
rrd_file_t *rrd_file,
unsigned long rra_begin,
- unsigned long *rra_current,
time_t *current_time,
unsigned long *current_time_usec,
rrd_value_t *pdp_temp,
char **updvals,
long *tmpl_idx,
unsigned long tmpl_cnt,
- info_t **pcdp_summary,
+ rrd_info_t ** pcdp_summary,
int version,
unsigned long *skip_update,
int *schedule_smooth);
rrd_value_t **last_seasonal_coef,
rrd_value_t **seasonal_coef,
rrd_value_t *pdp_temp,
- unsigned long *rra_current,
unsigned long *skip_update,
int *schedule_smooth);
rrd_t *rrd,
rrd_file_t *rrd_file,
unsigned long rra_begin,
- unsigned long *rra_current,
unsigned long elapsed_pdp_st,
rrd_value_t *pdp_temp,
rrd_value_t **seasonal_coef);
rrd_file_t *rrd_file,
unsigned long *rra_step_cnt,
unsigned long rra_begin,
- unsigned long *rra_current,
time_t current_time,
unsigned long *skip_update,
- info_t **pcdp_summary);
+ rrd_info_t ** pcdp_summary);
static int write_RRA_row(
rrd_file_t *rrd_file,
rrd_t *rrd,
unsigned long rra_idx,
- unsigned long *rra_current,
unsigned short CDP_scratch_idx,
- info_t **pcdp_summary,
+ rrd_info_t ** pcdp_summary,
time_t rra_time);
static int smooth_all_rras(
#define IFDNAN(X,Y) (isnan(X) ? (Y) : (X));
-info_t *rrd_update_v(
+rrd_info_t *rrd_update_v(
int argc,
char **argv)
{
char *tmplt = NULL;
- info_t *result = NULL;
- infoval rc;
+ rrd_info_t *result = NULL;
+ rrd_infoval_t rc;
struct option long_options[] = {
{"template", required_argument, 0, 't'},
{0, 0, 0, 0}
goto end_tag;
}
rc.u_int = 0;
- result = info_push(NULL, sprintf_alloc("return_value"), RD_I_INT, rc);
+ result = rrd_info_push(NULL, sprintf_alloc("return_value"), RD_I_INT, rc);
rc.u_int = _rrd_update(argv[optind], tmplt,
argc - optind - 1,
(const char **) (argv + optind + 1), result);
const char *tmplt,
int argc,
const char **argv,
- info_t *pcdp_summary)
+ rrd_info_t * pcdp_summary)
{
int arg_i = 2;
unsigned long rra_begin; /* byte pointer to the rra
* area in the rrd file. this
* pointer never changes value */
- unsigned long rra_current; /* byte pointer to the current write
- * spot in the rrd file. */
rrd_value_t *pdp_new; /* prepare the incoming data to be added
* to the existing entry */
rrd_value_t *pdp_temp; /* prepare the pdp values to be added
goto err_free;
}
/* We are now at the beginning of the rra's */
- rra_current = rra_begin = rrd_file->header_len;
+ rra_begin = rrd_file->header_len;
version = atoi(rrd.stat_head->version);
/* get exclusive lock to whole file.
* lock gets removed when we close the file.
*/
- if (LockRRD(rrd_file->fd) != 0) {
+ if (rrd_lock(rrd_file) != 0) {
rrd_set_error("could not lock RRD");
goto err_close;
}
rrd_set_error("failed duplication argv entry");
break;
}
- if (process_arg(arg_copy, &rrd, rrd_file, rra_begin, &rra_current,
+ if (process_arg(arg_copy, &rrd, rrd_file, rra_begin,
¤t_time, ¤t_time_usec, pdp_temp, pdp_new,
rra_step_cnt, updvals, tmpl_idx, tmpl_cnt,
&pcdp_summary, version, skip_update,
&schedule_smooth) == -1) {
+ if (rrd_test_error()) { /* Should have error string always here */
+ char *save_error;
+
+ /* Prepend file name to error message */
+ if ((save_error = strdup(rrd_get_error())) != NULL) {
+ rrd_set_error("%s: %s", filename, save_error);
+ free(save_error);
+ }
+ }
free(arg_copy);
break;
}
*
* returns 0 on success
*/
-int LockRRD(
- int in_file)
+int rrd_lock(
+ rrd_file_t *file)
{
int rcstat;
#if defined(_WIN32) && !defined(__CYGWIN__) && !defined(__CYGWIN32__)
struct _stat st;
- if (_fstat(in_file, &st) == 0) {
- rcstat = _locking(in_file, _LK_NBLCK, st.st_size);
+ if (_fstat(file->fd, &st) == 0) {
+ rcstat = _locking(file->fd, _LK_NBLCK, st.st_size);
} else {
rcstat = -1;
}
lock.l_start = 0; /* start of file */
lock.l_whence = SEEK_SET; /* end of file */
- rcstat = fcntl(in_file, F_SETLK, &lock);
+ rcstat = fcntl(file->fd, F_SETLK, &lock);
#endif
}
rrd_t *rrd,
rrd_file_t *rrd_file,
unsigned long rra_begin,
- unsigned long *rra_current,
time_t *current_time,
unsigned long *current_time_usec,
rrd_value_t *pdp_temp,
char **updvals,
long *tmpl_idx,
unsigned long tmpl_cnt,
- info_t **pcdp_summary,
+ rrd_info_t ** pcdp_summary,
int version,
unsigned long *skip_update,
int *schedule_smooth)
double interval, pre_int, post_int; /* interval between this and
* the last run */
unsigned long proc_pdp_cnt;
- unsigned long rra_start;
if (parse_ds(rrd, updvals, tmpl_idx, step_start, tmpl_cnt,
current_time, current_time_usec, version) == -1) {
return -1;
}
- /* seek to the beginning of the rra's */
- if (*rra_current != rra_begin) {
-#ifndef HAVE_MMAP
- if (rrd_seek(rrd_file, rra_begin, SEEK_SET) != 0) {
- rrd_set_error("seek error in rrd");
- return -1;
- }
-#endif
- *rra_current = rra_begin;
- }
- rra_start = rra_begin;
interval = (double) (*current_time - rrd->live_head->last_up)
+ (double) ((long) *current_time_usec -
proc_pdp_cnt,
&last_seasonal_coef,
&seasonal_coef,
- pdp_temp, rra_current,
+ pdp_temp,
skip_update, schedule_smooth) == -1) {
goto err_free_coefficients;
}
- if (update_aberrant_cdps(rrd, rrd_file, rra_begin, rra_current,
+ if (update_aberrant_cdps(rrd, rrd_file, rra_begin,
elapsed_pdp_st, pdp_temp,
&seasonal_coef) == -1) {
goto err_free_coefficients;
}
if (write_to_rras(rrd, rrd_file, rra_step_cnt, rra_begin,
- rra_current, *current_time, skip_update,
+ *current_time, skip_update,
pcdp_summary) == -1) {
goto err_free_coefficients;
}
rrd->live_head->last_up = *current_time;
rrd->live_head->last_up_usec = *current_time_usec;
- if ( version < 3 ){
+ if (version < 3) {
*rrd->legacy_last_up = rrd->live_head->last_up;
}
free(seasonal_coef);
double tmp;
char *parsetime_error = NULL;
char *old_locale;
- struct rrd_time_value ds_tv;
+ rrd_time_value_t ds_tv;
struct timeval tmp_time; /* used for time conversion */
/* get the time from the reading ... handle N */
if (timesyntax == '@') { /* at-style */
- if ((parsetime_error = parsetime(updvals[0], &ds_tv))) {
+ if ((parsetime_error = rrd_parsetime(updvals[0], &ds_tv))) {
rrd_set_error("ds time: %s: %s", updvals[0], parsetime_error);
return -1;
}
*current_time_usec = tmp_time.tv_usec;
} else {
old_locale = setlocale(LC_NUMERIC, "C");
+ errno = 0;
tmp = strtod(updvals[0], 0);
+ if (errno > 0) {
+ rrd_set_error("converting '%s' to float: %s",
+ updvals[0], rrd_strerror(errno));
+ return -1;
+ };
setlocale(LC_NUMERIC, old_locale);
+ if (tmp < 0.0){
+ gettimeofday(&tmp_time, 0);
+ tmp = (double)tmp_time.tv_sec + (double)tmp_time.tv_usec * 1e-6f + tmp;
+ }
+
*current_time = floor(tmp);
*current_time_usec = (long) ((tmp - (double) *current_time) * 1e6f);
}
old_locale = setlocale(LC_NUMERIC, "C");
errno = 0;
pdp_new[ds_idx] = strtod(updvals[ds_idx + 1], &endptr);
- setlocale(LC_NUMERIC, old_locale);
if (errno > 0) {
rrd_set_error("converting '%s' to float: %s",
updvals[ds_idx + 1], rrd_strerror(errno));
return -1;
};
+ setlocale(LC_NUMERIC, old_locale);
if (endptr[0] != '\0') {
rrd_set_error
("conversion of '%s' to float not complete: tail '%s'",
rate = pdp_new[ds_idx] / interval;
break;
case DST_GAUGE:
- errno = 0;
old_locale = setlocale(LC_NUMERIC, "C");
+ errno = 0;
pdp_new[ds_idx] =
strtod(updvals[ds_idx + 1], &endptr) * interval;
- setlocale(LC_NUMERIC, old_locale);
if (errno) {
rrd_set_error("converting '%s' to float: %s",
updvals[ds_idx + 1], rrd_strerror(errno));
return -1;
};
+ setlocale(LC_NUMERIC, old_locale);
if (endptr[0] != '\0') {
rrd_set_error
("conversion of '%s' to float not complete: tail '%s'",
rrd_value_t **last_seasonal_coef,
rrd_value_t **seasonal_coef,
rrd_value_t *pdp_temp,
- unsigned long *rra_current,
unsigned long *skip_update,
int *schedule_smooth)
{
#endif
*schedule_smooth = 1;
}
- *rra_current = rrd_tell(rrd_file);
}
if (rrd_test_error())
return -1;
if (elapsed_pdp_st > 2) {
reset_cdp(rrd, elapsed_pdp_st, pdp_temp, last_seasonal_coef,
seasonal_coef, rra_idx, ds_idx, cdp_idx,
- current_cf);
+ (enum cf_en)current_cf);
}
}
rrd_t *rrd,
rrd_file_t *rrd_file,
unsigned long rra_begin,
- unsigned long *rra_current,
unsigned long elapsed_pdp_st,
rrd_value_t *pdp_temp,
rrd_value_t **seasonal_coef)
lookup_seasonal(rrd, rra_idx, rra_start, rrd_file,
elapsed_pdp_st + 2, seasonal_coef);
}
- *rra_current = rrd_tell(rrd_file);
}
if (rrd_test_error())
return -1;
rrd_file_t *rrd_file,
unsigned long *rra_step_cnt,
unsigned long rra_begin,
- unsigned long *rra_current,
time_t current_time,
unsigned long *skip_update,
- info_t **pcdp_summary)
+ rrd_info_t ** pcdp_summary)
{
unsigned long rra_idx;
unsigned long rra_start;
- unsigned long rra_pos_tmp; /* temporary byte pointer. */
time_t rra_time = 0; /* time of update for a RRA */
+ unsigned long ds_cnt = rrd->stat_head->ds_cnt;
+
/* Ready to write to disk */
rra_start = rra_begin;
+
for (rra_idx = 0; rra_idx < rrd->stat_head->rra_cnt; rra_idx++) {
- /* skip unless there's something to write */
- if (rra_step_cnt[rra_idx]) {
- /* write the first row */
+ rra_def_t *rra_def = &rrd->rra_def[rra_idx];
+ rra_ptr_t *rra_ptr = &rrd->rra_ptr[rra_idx];
+
+ /* for cdp_prep */
+ unsigned short scratch_idx;
+ unsigned long step_subtract;
+
+ for (scratch_idx = CDP_primary_val,
+ step_subtract = 1;
+ rra_step_cnt[rra_idx] > 0;
+ rra_step_cnt[rra_idx]--,
+ scratch_idx = CDP_secondary_val,
+ step_subtract = 2) {
+
+ size_t rra_pos_new;
#ifdef DEBUG
fprintf(stderr, " -- RRA Preseek %ld\n", rrd_file->pos);
#endif
- rrd->rra_ptr[rra_idx].cur_row++;
- if (rrd->rra_ptr[rra_idx].cur_row >=
- rrd->rra_def[rra_idx].row_cnt)
- rrd->rra_ptr[rra_idx].cur_row = 0; /* wrap around */
- /* position on the first row */
- rra_pos_tmp = rra_start +
- (rrd->stat_head->ds_cnt) * (rrd->rra_ptr[rra_idx].cur_row) *
- sizeof(rrd_value_t);
- if (rra_pos_tmp != *rra_current) {
- if (rrd_seek(rrd_file, rra_pos_tmp, SEEK_SET) != 0) {
+ /* increment, with wrap-around */
+ if (++rra_ptr->cur_row >= rra_def->row_cnt)
+ rra_ptr->cur_row = 0;
+
+ /* we know what our position should be */
+ rra_pos_new = rra_start
+ + ds_cnt * rra_ptr->cur_row * sizeof(rrd_value_t);
+
+ /* re-seek if the position is wrong or we wrapped around */
+ if (rra_pos_new != rrd_file->pos) {
+ if (rrd_seek(rrd_file, rra_pos_new, SEEK_SET) != 0) {
rrd_set_error("seek error in rrd");
return -1;
}
- *rra_current = rra_pos_tmp;
}
#ifdef DEBUG
fprintf(stderr, " -- RRA Postseek %ld\n", rrd_file->pos);
#endif
- if (!skip_update[rra_idx]) {
- if (*pcdp_summary != NULL) {
- rra_time = (current_time - current_time
- % (rrd->rra_def[rra_idx].pdp_cnt *
- rrd->stat_head->pdp_step))
- -
- ((rra_step_cnt[rra_idx] -
- 1) * rrd->rra_def[rra_idx].pdp_cnt *
- rrd->stat_head->pdp_step);
- }
- if (write_RRA_row
- (rrd_file, rrd, rra_idx, rra_current, CDP_primary_val,
- pcdp_summary, rra_time) == -1)
- return -1;
- }
- /* write other rows of the bulk update, if any */
- for (; rra_step_cnt[rra_idx] > 1; rra_step_cnt[rra_idx]--) {
- if (++rrd->rra_ptr[rra_idx].cur_row ==
- rrd->rra_def[rra_idx].row_cnt) {
-#ifdef DEBUG
- fprintf(stderr,
- "Wraparound for RRA %s, %lu updates left\n",
- rrd->rra_def[rra_idx].cf_nam,
- rra_step_cnt[rra_idx] - 1);
-#endif
- /* wrap */
- rrd->rra_ptr[rra_idx].cur_row = 0;
- /* seek back to beginning of current rra */
- if (rrd_seek(rrd_file, rra_start, SEEK_SET) != 0) {
- rrd_set_error("seek error in rrd");
- return -1;
- }
-#ifdef DEBUG
- fprintf(stderr, " -- Wraparound Postseek %ld\n",
- rrd_file->pos);
-#endif
- *rra_current = rra_start;
- }
- if (!skip_update[rra_idx]) {
- if (*pcdp_summary != NULL) {
- rra_time = (current_time - current_time
- % (rrd->rra_def[rra_idx].pdp_cnt *
- rrd->stat_head->pdp_step))
- -
- ((rra_step_cnt[rra_idx] -
- 2) * rrd->rra_def[rra_idx].pdp_cnt *
- rrd->stat_head->pdp_step);
- }
- if (write_RRA_row(rrd_file, rrd, rra_idx, rra_current,
- CDP_secondary_val, pcdp_summary,
- rra_time) == -1)
- return -1;
- }
+ if (skip_update[rra_idx])
+ continue;
+
+ if (*pcdp_summary != NULL) {
+ unsigned long step_time = rra_def->pdp_cnt * rrd->stat_head->pdp_step;
+
+ rra_time = (current_time - current_time % step_time)
+ - ((rra_step_cnt[rra_idx] - step_subtract) * step_time);
}
+
+ if (write_RRA_row
+ (rrd_file, rrd, rra_idx, scratch_idx,
+ pcdp_summary, rra_time) == -1)
+ return -1;
}
- rra_start += rrd->rra_def[rra_idx].row_cnt * rrd->stat_head->ds_cnt *
- sizeof(rrd_value_t);
- } /* RRA LOOP */
+
+ rra_start += rra_def->row_cnt * ds_cnt * sizeof(rrd_value_t);
+ } /* RRA LOOP */
return 0;
}
rrd_file_t *rrd_file,
rrd_t *rrd,
unsigned long rra_idx,
- unsigned long *rra_current,
unsigned short CDP_scratch_idx,
- info_t **pcdp_summary,
+ rrd_info_t ** pcdp_summary,
time_t rra_time)
{
unsigned long ds_idx, cdp_idx;
- infoval iv;
+ rrd_infoval_t iv;
for (ds_idx = 0; ds_idx < rrd->stat_head->ds_cnt; ds_idx++) {
/* compute the cdp index */
if (*pcdp_summary != NULL) {
iv.u_val = rrd->cdp_prep[cdp_idx].scratch[CDP_scratch_idx].u_val;
/* append info to the return hash */
- *pcdp_summary = info_push(*pcdp_summary,
- sprintf_alloc("[%d]RRA[%s][%lu]DS[%s]",
- rra_time,
- rrd->rra_def[rra_idx].
- cf_nam,
- rrd->rra_def[rra_idx].
- pdp_cnt,
- rrd->ds_def[ds_idx].
- ds_nam), RD_I_VAL, iv);
+ *pcdp_summary = rrd_info_push(*pcdp_summary,
+ sprintf_alloc
+ ("[%lli]RRA[%s][%lu]DS[%s]", (long long)rra_time,
+ rrd->rra_def[rra_idx].cf_nam,
+ rrd->rra_def[rra_idx].pdp_cnt,
+ rrd->ds_def[ds_idx].ds_nam),
+ RD_I_VAL, iv);
}
+ errno = 0;
if (rrd_write(rrd_file,
&(rrd->cdp_prep[cdp_idx].scratch[CDP_scratch_idx].
u_val), sizeof(rrd_value_t)) != sizeof(rrd_value_t)) {
rrd_set_error("writing rrd: %s", rrd_strerror(errno));
return -1;
}
- *rra_current += sizeof(rrd_value_t);
}
return 0;
}