X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=src%2Frrd_update.c;h=9d7d251e3eccdd65e442d1d1de67f11b3d30244e;hb=7a942d263044e07b9e861472361b544d4133af71;hp=e4f9712fb08ee56191dba1a0e800d6ea366d8460;hpb=285da1fa16e80919db972b1d7021c0b4705bedb1;p=rrdtool.git diff --git a/src/rrd_update.c b/src/rrd_update.c index e4f9712..9d7d251 100644 --- a/src/rrd_update.c +++ b/src/rrd_update.c @@ -1,90 +1,204 @@ /***************************************************************************** - * RRDtool 1.1.x Copyright Tobias Oetiker, 1997 - 2002 + * RRDtool 1.2.15 Copyright by Tobi Oetiker, 1997-2006 ***************************************************************************** * rrd_update.c RRD Update Function ***************************************************************************** * $Id$ - * $Log$ - * Revision 1.6 2002/02/01 20:34:49 oetiker - * fixed version number and date/time - * - * Revision 1.5 2001/05/09 05:31:01 oetiker - * Bug fix: when update of multiple PDP/CDP RRAs coincided - * with interpolation of multiple PDPs an incorrect value was - * stored as the CDP. Especially evident for GAUGE data sources. - * Minor changes to rrdcreate.pod. -- Jake Brutlag - * - * Revision 1.4 2001/03/10 23:54:41 oetiker - * Support for COMPUTE data sources (CDEF data sources). Removes the RPN - * parser and calculator from rrd_graph and puts then in a new file, - * rrd_rpncalc.c. Changes to core files rrd_create and rrd_update. Some - * clean-up of aberrant behavior stuff, including a bug fix. - * Documentation update (rrdcreate.pod, rrdupdate.pod). Change xml format. - * -- Jake Brutlag - * - * Revision 1.3 2001/03/04 13:01:55 oetiker - * Aberrant Behavior Detection support. A brief overview added to rrdtool.pod. - * Major updates to rrd_update.c, rrd_create.c. Minor update to other core files. - * This is backwards compatible! But new files using the Aberrant stuff are not readable - * by old rrdtool versions. See http://cricket.sourceforge.net/aberrant/rrd_hw.htm - * -- Jake Brutlag - * - * Revision 1.2 2001/03/04 11:14:25 oetiker - * added at-style-time@value:value syntax to rrd_update - * -- Dave Bodenstab - * - * Revision 1.1.1.1 2001/02/25 22:25:06 oetiker - * checkin - * *****************************************************************************/ #include "rrd_tool.h" #include #include -#include "rrd_hw.h" -#include "rrd_rpncalc.h" +#ifdef HAVE_MMAP + #include +#endif -#ifdef WIN32 +#if defined(_WIN32) && !defined(__CYGWIN__) && !defined(__CYGWIN32__) #include #include #include #endif +#include "rrd_hw.h" +#include "rrd_rpncalc.h" + +#include "rrd_is_thread_safe.h" +#include "unused.h" + +#if defined(_WIN32) && !defined(__CYGWIN__) && !defined(__CYGWIN32__) +/* + * WIN32 does not have gettimeofday and struct timeval. This is a quick and dirty + * replacement. + */ +#include + +#ifndef __MINGW32__ +struct timeval { + time_t tv_sec; /* seconds */ + long tv_usec; /* microseconds */ +}; +#endif + +struct __timezone { + int tz_minuteswest; /* minutes W of Greenwich */ + int tz_dsttime; /* type of dst correction */ +}; + +static int gettimeofday(struct timeval *t, struct __timezone *tz) { + + struct _timeb current_time; + + _ftime(¤t_time); + + t->tv_sec = current_time.time; + t->tv_usec = current_time.millitm * 1000; + + return 0; +} + +#endif +/* + * normilize time as returned by gettimeofday. usec part must + * be always >= 0 + */ +static void normalize_time(struct timeval *t) +{ + if(t->tv_usec < 0) { + t->tv_sec--; + t->tv_usec += 1000000L; + } +} + /* Local prototypes */ int LockRRD(FILE *rrd_file); -void write_RRA_row (rrd_t *rrd, unsigned long rra_idx, unsigned long *rra_current, - unsigned short CDP_scratch_idx, FILE *rrd_file); - +#ifdef HAVE_MMAP +info_t *write_RRA_row (rrd_t *rrd, unsigned long rra_idx, + unsigned long *rra_current, + unsigned short CDP_scratch_idx, +#ifndef DEBUG +FILE UNUSED(*rrd_file), +#else +FILE *rrd_file, +#endif + info_t *pcdp_summary, time_t *rra_time, void *rrd_mmaped_file); +#else +info_t *write_RRA_row (rrd_t *rrd, unsigned long rra_idx, + unsigned long *rra_current, + unsigned short CDP_scratch_idx, FILE *rrd_file, + info_t *pcdp_summary, time_t *rra_time); +#endif +int rrd_update_r(char *filename, char *tmplt, int argc, char **argv); +int _rrd_update(char *filename, char *tmplt, int argc, char **argv, + info_t*); + #define IFDNAN(X,Y) (isnan(X) ? (Y) : (X)); -#ifdef STANDALONE -int -main(int argc, char **argv){ - rrd_update(argc,argv); - if (rrd_test_error()) { - printf("RRDtool 1.1.x Copyright 1997-2000 by Tobias Oetiker \n\n" - "Usage: rrdupdate filename\n" - "\t\t\t[--template|-t ds-name:ds-name:...]\n" - "\t\t\ttime|N:value[:value...]\n\n" - "\t\t\tat-time@value[:value...]\n\n" - "\t\t\t[ time:value[:value...] ..]\n\n"); - - printf("ERROR: %s\n",rrd_get_error()); - rrd_clear_error(); - return 1; - } - return 0; +info_t *rrd_update_v(int argc, char **argv) +{ + char *tmplt = NULL; + info_t *result = NULL; + infoval rc; + rc.u_int = -1; + optind = 0; opterr = 0; /* initialize getopt */ + + while (1) { + static struct option long_options[] = + { + {"template", required_argument, 0, 't'}, + {0,0,0,0} + }; + int option_index = 0; + int opt; + opt = getopt_long(argc, argv, "t:", + long_options, &option_index); + + if (opt == EOF) + break; + + switch(opt) { + case 't': + tmplt = optarg; + break; + + case '?': + rrd_set_error("unknown option '%s'",argv[optind-1]); + goto end_tag; + } + } + + /* need at least 2 arguments: filename, data. */ + if (argc-optind < 2) { + rrd_set_error("Not enough arguments"); + goto end_tag; + } + rc.u_int = 0; + result = info_push(NULL,sprintf_alloc("return_value"),RD_I_INT,rc); + rc.u_int = _rrd_update(argv[optind], tmplt, + argc - optind - 1, argv + optind + 1, result); + result->value.u_int = rc.u_int; +end_tag: + return result; } -#endif int rrd_update(int argc, char **argv) { + char *tmplt = NULL; + int rc; + optind = 0; opterr = 0; /* initialize getopt */ + + while (1) { + static struct option long_options[] = + { + {"template", required_argument, 0, 't'}, + {0,0,0,0} + }; + int option_index = 0; + int opt; + opt = getopt_long(argc, argv, "t:", + long_options, &option_index); + + if (opt == EOF) + break; + + switch(opt) { + case 't': + tmplt = optarg; + break; + + case '?': + rrd_set_error("unknown option '%s'",argv[optind-1]); + return(-1); + } + } + + /* need at least 2 arguments: filename, data. */ + if (argc-optind < 2) { + rrd_set_error("Not enough arguments"); + + return -1; + } + + rc = rrd_update_r(argv[optind], tmplt, + argc - optind - 1, argv + optind + 1); + return rc; +} + +int +rrd_update_r(char *filename, char *tmplt, int argc, char **argv) +{ + return _rrd_update(filename, tmplt, argc, argv, NULL); +} + +int +_rrd_update(char *filename, char *tmplt, int argc, char **argv, + info_t *pcdp_summary) +{ int arg_i = 2; short j; - long i,ii,iii=1; + unsigned long i,ii,iii=1; unsigned long rra_begin; /* byte pointer to the rra * area in the rrd file. this @@ -96,8 +210,8 @@ rrd_update(int argc, char **argv) unsigned long rra_current; /* byte pointer to the current write * spot in the rrd file. */ unsigned long rra_pos_tmp; /* temporary byte pointer. */ - unsigned long interval, - pre_int,post_int; /* interval between this and + double interval, + pre_int,post_int; /* interval between this and * the last run */ unsigned long proc_pdp_st; /* which pdp_st was the last * to be processed */ @@ -117,15 +231,18 @@ rrd_update(int argc, char **argv) * cdp values */ long *tmpl_idx; /* index representing the settings - transported by the template index */ - long tmpl_cnt = 2; /* time and data */ + transported by the tmplt index */ + unsigned long tmpl_cnt = 2; /* time and data */ FILE *rrd_file; rrd_t rrd; - time_t current_time = time(NULL); + time_t current_time = 0; + time_t rra_time = 0; /* time of update for a RRA */ + unsigned long current_time_usec=0;/* microseconds part of current time */ + struct timeval tmp_time; /* used for time conversion */ + char **updvals; int schedule_smooth = 0; - char *template = NULL; rrd_value_t *seasonal_coef = NULL, *last_seasonal_coef = NULL; /* a vector of future Holt-Winters seasonal coefs */ unsigned long elapsed_pdp_st; @@ -142,44 +259,38 @@ rrd_update(int argc, char **argv) enum cf_en current_cf; /* numeric id of the current consolidation function */ rpnstack_t rpnstack; /* used for COMPUTE DS */ + int version; /* rrd version */ + char *endptr; /* used in the conversion */ +#ifdef HAVE_MMAP + void *rrd_mmaped_file; + unsigned long rrd_filesize; +#endif rpnstack_init(&rpnstack); - while (1) { - static struct option long_options[] = - { - {"template", required_argument, 0, 't'}, - {0,0,0,0} - }; - int option_index = 0; - int opt; - opt = getopt_long(argc, argv, "t:", - long_options, &option_index); - - if (opt == EOF) - break; - - switch(opt) { - case 't': - template = optarg; - break; - - case '?': - rrd_set_error("unknown option '%s'",argv[optind-1]); - rrd_free(&rrd); - return(-1); - } - } - - /* need at least 2 arguments: filename, data. */ - if (argc-optind < 2) { + /* need at least 1 arguments: data. */ + if (argc < 1) { rrd_set_error("Not enough arguments"); return -1; } + + - if(rrd_open(argv[optind],&rrd_file,&rrd, RRD_READWRITE)==-1){ + if(rrd_open(filename,&rrd_file,&rrd, RRD_READWRITE)==-1){ return -1; } + /* initialize time */ + version = atoi(rrd.stat_head->version); + gettimeofday(&tmp_time, 0); + normalize_time(&tmp_time); + current_time = tmp_time.tv_sec; + if(version >= 3) { + current_time_usec = tmp_time.tv_usec; + } + else { + current_time_usec = 0; + } + rra_current = rra_start = rra_begin = ftell(rrd_file); /* This is defined in the ANSI C standard, section 7.9.5.3: @@ -190,7 +301,13 @@ rrd_update(int argc, char **argv) followed by output without an intervening call to a file positioning function, unless the input oepration encounters end-of-file. */ +#ifdef HAVE_MMAP + fseek(rrd_file, 0, SEEK_END); + rrd_filesize = ftell(rrd_file); + fseek(rrd_file, rra_current, SEEK_SET); +#else fseek(rrd_file, 0, SEEK_CUR); +#endif /* get exclusive lock to whole file. @@ -228,7 +345,7 @@ rrd_update(int argc, char **argv) fclose(rrd_file); return(-1); } - /* initialize template redirector */ + /* initialize tmplt redirector */ /* default config example (assume DS 1 is a CDEF DS) tmpl_idx[0] -> 0; (time) tmpl_idx[1] -> 1; (DS 0) @@ -242,17 +359,19 @@ rrd_update(int argc, char **argv) } tmpl_cnt= ii; - if (template) { + if (tmplt) { + /* we should work on a writeable copy here */ char *dsname; - int tmpl_len; - dsname = template; + unsigned int tmpl_len; + tmplt = strdup(tmplt); + dsname = tmplt; tmpl_cnt = 1; /* the first entry is the time */ - tmpl_len = strlen(template); + tmpl_len = strlen(tmplt); for(i=0;i<=tmpl_len ;i++) { - if (template[i] == ':' || template[i] == '\0') { - template[i] = '\0'; + if (tmplt[i] == ':' || tmplt[i] == '\0') { + tmplt[i] = '\0'; if (tmpl_cnt>rrd.stat_head->ds_cnt){ - rrd_set_error("Template contains more DS definitions than RRD"); + rrd_set_error("tmplt contains more DS definitions than RRD"); free(updvals); free(pdp_temp); free(tmpl_idx); rrd_free(&rrd); fclose(rrd_file); return(-1); @@ -260,21 +379,23 @@ rrd_update(int argc, char **argv) if ((tmpl_idx[tmpl_cnt++] = ds_match(&rrd,dsname)) == -1){ rrd_set_error("unknown DS name '%s'",dsname); free(updvals); free(pdp_temp); + free(tmplt); free(tmpl_idx); rrd_free(&rrd); fclose(rrd_file); return(-1); } else { /* the first element is always the time */ tmpl_idx[tmpl_cnt-1]++; - /* go to the next entry on the template */ - dsname = &template[i+1]; + /* go to the next entry on the tmplt */ + dsname = &tmplt[i+1]; /* fix the damage we did before */ if (ids_cnt))==NULL){ @@ -287,20 +408,40 @@ rrd_update(int argc, char **argv) return(-1); } +#ifdef HAVE_MMAP + rrd_mmaped_file = mmap(0, + rrd_filesize, + PROT_READ | PROT_WRITE, + MAP_SHARED, + fileno(rrd_file), + 0); + if (rrd_mmaped_file == MAP_FAILED) { + rrd_set_error("error mmapping file %s", filename); + free(updvals); + free(pdp_temp); + free(tmpl_idx); + rrd_free(&rrd); + fclose(rrd_file); + return(-1); + } +#endif /* loop through the arguments. */ - for(arg_i=optind+1; arg_ilast_up){ + if(current_time < rrd.live_head->last_up || + (current_time == rrd.live_head->last_up && + (long)current_time_usec <= (long)rrd.live_head->last_up_usec)) { rrd_set_error("illegal attempt to update using time %ld when " "last update time is %ld (minimum one second step)", current_time, rrd.live_head->last_up); @@ -379,11 +533,13 @@ rrd_update(int argc, char **argv) /* seek to the beginning of the rra's */ if (rra_current != rra_begin) { +#ifndef HAVE_MMAP if(fseek(rrd_file, rra_begin, SEEK_SET) != 0) { rrd_set_error("seek error in rrd"); free(step_start); break; } +#endif rra_current = rra_begin; } rra_start = rra_begin; @@ -395,14 +551,19 @@ rrd_update(int argc, char **argv) /* when did the last pdp_st occur */ occu_pdp_age = current_time % rrd.stat_head->pdp_step; occu_pdp_st = current_time - occu_pdp_age; - interval = current_time - rrd.live_head->last_up; - + + /* interval = current_time - rrd.live_head->last_up; */ + interval = (double)(current_time - rrd.live_head->last_up) + + (double)((long)current_time_usec - (long)rrd.live_head->last_up_usec)/1000000.0; + if (occu_pdp_st > proc_pdp_st){ /* OK we passed the pdp_st moment*/ - pre_int = occu_pdp_st - rrd.live_head->last_up; /* how much of the input data + pre_int = (long)occu_pdp_st - rrd.live_head->last_up; /* how much of the input data * occurred before the latest * pdp_st moment*/ + pre_int -= ((double)rrd.live_head->last_up_usec)/1000000.0; /* adjust usecs */ post_int = occu_pdp_age; /* how much after it */ + post_int += ((double)current_time_usec)/1000000.0; /* adjust usecs */ } else { pre_int = interval; post_int = 0; @@ -414,9 +575,9 @@ rrd_update(int argc, char **argv) "proc_pdp_st %lu\t" "occu_pfp_age %lu\t" "occu_pdp_st %lu\t" - "int %lu\t" - "pre_int %lu\t" - "post_int %lu\n", proc_pdp_age, proc_pdp_st, + "int %lf\t" + "pre_int %lf\t" + "post_int %lf\n", proc_pdp_age, proc_pdp_st, occu_pdp_age, occu_pdp_st, interval, pre_int, post_int); #endif @@ -426,15 +587,23 @@ rrd_update(int argc, char **argv) for(i=0;ids_cnt;i++){ enum dst_en dst_idx; dst_idx= dst_conv(rrd.ds_def[i].dst); - /* NOTE: DST_CDEF should never enter this if block, because - * updvals[i+1][0] is initialized to 'U'; unless the caller - * accidently specified a value for the DST_CDEF. To handle - * this case, an extra check is required. */ + + /* make sure we do not build diffs with old last_ds values */ + if(rrd.ds_def[i].par[DS_mrhb_cnt].u_cnt < interval + && ( dst_idx == DST_COUNTER || dst_idx == DST_DERIVE)){ + strncpy(rrd.pdp_prep[i].last_ds,"U",LAST_DS_LEN-1); + } + + /* NOTE: DST_CDEF should never enter this if block, because + * updvals[i+1][0] is initialized to 'U'; unless the caller + * accidently specified a value for the DST_CDEF. To handle + * this case, an extra check is required. */ + if((updvals[i+1][0] != 'U') && (dst_idx != DST_CDEF) && rrd.ds_def[i].par[DS_mrhb_cnt].u_cnt >= interval) { double rate = DNAN; - /* the data source type defines how to process the data */ + /* the data source type defines how to process the data */ /* pdp_new contains rate * time ... eg the bytes * transferred during the interval. Doing it this way saves * a lot of math operations */ @@ -444,9 +613,18 @@ rrd_update(int argc, char **argv) case DST_COUNTER: case DST_DERIVE: if(rrd.pdp_prep[i].last_ds[0] != 'U'){ + for(ii=0;updvals[i+1][ii] != '\0';ii++){ + if(updvals[i+1][ii] < '0' || updvals[i+1][ii] > '9' || (ii==0 && updvals[i+1][ii] == '-')){ + rrd_set_error("not a simple integer: '%s'",updvals[i+1]); + break; + } + } + if (rrd_test_error()){ + break; + } pdp_new[i]= rrd_diff(updvals[i+1],rrd.pdp_prep[i].last_ds); if(dst_idx == DST_COUNTER) { - /* simple overflow catcher sugestet by andres kroonmaa */ + /* simple overflow catcher suggested by Andres Kroonmaa */ /* this will fail terribly for non 32 or 64 bit counters ... */ /* are there any others in SNMP land ? */ if (pdp_new[i] < (double)0.0 ) @@ -461,11 +639,29 @@ rrd_update(int argc, char **argv) } break; case DST_ABSOLUTE: - pdp_new[i]= atof(updvals[i+1]); + errno = 0; + pdp_new[i] = strtod(updvals[i+1],&endptr); + if (errno > 0){ + rrd_set_error("converting '%s' to float: %s",updvals[i+1],rrd_strerror(errno)); + break; + }; + if (endptr[0] != '\0'){ + rrd_set_error("conversion of '%s' to float not complete: tail '%s'",updvals[i+1],endptr); + break; + } rate = pdp_new[i] / interval; break; case DST_GAUGE: - pdp_new[i] = atof(updvals[i+1]) * interval; + errno = 0; + pdp_new[i] = strtod(updvals[i+1],&endptr) * interval; + if (errno > 0){ + rrd_set_error("converting '%s' to float: %s",updvals[i+1],rrd_strerror(errno)); + break; + }; + if (endptr[0] != '\0'){ + rrd_set_error("conversion of '%s' to float not complete: tail '%s'",updvals[i+1],endptr); + break; + } rate = pdp_new[i] / interval; break; default: @@ -491,6 +687,7 @@ rrd_update(int argc, char **argv) /* no news is news all the same */ pdp_new[i] = DNAN; } + /* make a copy of the command line argument for the next run */ #ifdef DEBUG @@ -520,10 +717,18 @@ rrd_update(int argc, char **argv) /* no we have not passed a pdp_st moment. therefore update is simple */ for(i=0;ids_cnt;i++){ - if(isnan(pdp_new[i])) - rrd.pdp_prep[i].scratch[PDP_unkn_sec_cnt].u_cnt += interval; - else - rrd.pdp_prep[i].scratch[PDP_val].u_val+= pdp_new[i]; + if(isnan(pdp_new[i])) { + /* this is not realy accurate if we use subsecond data arival time + should have thought of it when going subsecond resolution ... + sorry next format change we will have it! */ + rrd.pdp_prep[i].scratch[PDP_unkn_sec_cnt].u_cnt += floor(interval); + } else { + if (isnan( rrd.pdp_prep[i].scratch[PDP_val].u_val )){ + rrd.pdp_prep[i].scratch[PDP_val].u_val= pdp_new[i]; + } else { + rrd.pdp_prep[i].scratch[PDP_val].u_val+= pdp_new[i]; + } + } #ifdef DEBUG fprintf(stderr, "NO PDP ds[%lu]\t" @@ -543,24 +748,38 @@ rrd_update(int argc, char **argv) pdp_temp[] will contain the rate for cdp */ for(i=0;ids_cnt;i++){ - /* update pdp_prep to the current pdp_st */ + /* update pdp_prep to the current pdp_st. */ + double pre_unknown = 0.0; if(isnan(pdp_new[i])) - rrd.pdp_prep[i].scratch[PDP_unkn_sec_cnt].u_cnt += pre_int; - else - rrd.pdp_prep[i].scratch[PDP_val].u_val += - pdp_new[i]/(double)interval*(double)pre_int; + /* a final bit of unkonwn to be added bevore calculation + * we use a tempaorary variable for this so that we + * don't have to turn integer lines before using the value */ + pre_unknown = pre_int; + else { + if (isnan( rrd.pdp_prep[i].scratch[PDP_val].u_val )){ + rrd.pdp_prep[i].scratch[PDP_val].u_val= pdp_new[i]/interval*pre_int; + } else { + rrd.pdp_prep[i].scratch[PDP_val].u_val+= pdp_new[i]/interval*pre_int; + } + } + /* if too much of the pdp_prep is unknown we dump it */ - if ((rrd.pdp_prep[i].scratch[PDP_unkn_sec_cnt].u_cnt - > rrd.ds_def[i].par[DS_mrhb_cnt].u_cnt) || + if ( + /* removed because this does not agree with the definition + a heart beat can be unknown */ + /* (rrd.pdp_prep[i].scratch[PDP_unkn_sec_cnt].u_cnt + > rrd.ds_def[i].par[DS_mrhb_cnt].u_cnt) || */ + /* if the interval is larger thatn mrhb we get NAN */ + (interval > rrd.ds_def[i].par[DS_mrhb_cnt].u_cnt) || (occu_pdp_st-proc_pdp_st <= rrd.pdp_prep[i].scratch[PDP_unkn_sec_cnt].u_cnt)) { pdp_temp[i] = DNAN; } else { pdp_temp[i] = rrd.pdp_prep[i].scratch[PDP_val].u_val - / (double)( occu_pdp_st - - proc_pdp_st - - rrd.pdp_prep[i].scratch[PDP_unkn_sec_cnt].u_cnt); + / ((double)(occu_pdp_st - proc_pdp_st + - rrd.pdp_prep[i].scratch[PDP_unkn_sec_cnt].u_cnt) + -pre_unknown); } /* process CDEF data sources; remember each CDEF DS can @@ -585,12 +804,15 @@ rrd_update(int argc, char **argv) /* make pdp_prep ready for the next run */ if(isnan(pdp_new[i])){ - rrd.pdp_prep[i].scratch[PDP_unkn_sec_cnt].u_cnt = post_int; - rrd.pdp_prep[i].scratch[PDP_val].u_val = 0.0; + /* this is not realy accurate if we use subsecond data arival time + should have thought of it when going subsecond resolution ... + sorry next format change we will have it! */ + rrd.pdp_prep[i].scratch[PDP_unkn_sec_cnt].u_cnt = floor(post_int); + rrd.pdp_prep[i].scratch[PDP_val].u_val = DNAN; } else { rrd.pdp_prep[i].scratch[PDP_unkn_sec_cnt].u_cnt = 0; rrd.pdp_prep[i].scratch[PDP_val].u_val = - pdp_new[i]/(double)interval*(double)post_int; + pdp_new[i]/interval*post_int; } #ifdef DEBUG @@ -987,10 +1209,12 @@ rrd_update(int argc, char **argv) rra_pos_tmp = rra_start + (rrd.stat_head->ds_cnt)*(rrd.rra_ptr[i].cur_row)*sizeof(rrd_value_t); if(rra_pos_tmp != rra_current) { +#ifndef HAVE_MMAP if(fseek(rrd_file, rra_pos_tmp, SEEK_SET) != 0){ rrd_set_error("seek error in rrd"); break; } +#endif rra_current = rra_pos_tmp; } @@ -998,15 +1222,26 @@ rrd_update(int argc, char **argv) fprintf(stderr," -- RRA Postseek %ld\n",ftell(rrd_file)); #endif scratch_idx = CDP_primary_val; - write_RRA_row(&rrd, i, &rra_current, scratch_idx, rrd_file); + if (pcdp_summary != NULL) + { + rra_time = (current_time - current_time + % (rrd.rra_def[i].pdp_cnt*rrd.stat_head->pdp_step)) + - ((rra_step_cnt[i]-1)*rrd.rra_def[i].pdp_cnt*rrd.stat_head->pdp_step); + } +#ifdef HAVE_MMAP + pcdp_summary = write_RRA_row(&rrd, i, &rra_current, scratch_idx, rrd_file, + pcdp_summary, &rra_time, rrd_mmaped_file); +#else + pcdp_summary = write_RRA_row(&rrd, i, &rra_current, scratch_idx, rrd_file, + pcdp_summary, &rra_time); +#endif if (rrd_test_error()) break; /* write other rows of the bulk update, if any */ scratch_idx = CDP_secondary_val; - for ( ; rra_step_cnt[i] > 1; - rra_step_cnt[i]--, rrd.rra_ptr[i].cur_row++) + for ( ; rra_step_cnt[i] > 1; rra_step_cnt[i]--) { - if (rrd.rra_ptr[i].cur_row == rrd.rra_def[i].row_cnt) + if (++rrd.rra_ptr[i].cur_row == rrd.rra_def[i].row_cnt) { #ifdef DEBUG fprintf(stderr,"Wraparound for RRA %s, %lu updates left\n", @@ -1025,7 +1260,19 @@ rrd_update(int argc, char **argv) #endif rra_current = rra_start; } - write_RRA_row(&rrd, i, &rra_current, scratch_idx, rrd_file); + if (pcdp_summary != NULL) + { + rra_time = (current_time - current_time + % (rrd.rra_def[i].pdp_cnt*rrd.stat_head->pdp_step)) + - ((rra_step_cnt[i]-2)*rrd.rra_def[i].pdp_cnt*rrd.stat_head->pdp_step); + } +#ifdef HAVE_MMAP + pcdp_summary = write_RRA_row(&rrd, i, &rra_current, scratch_idx, rrd_file, + pcdp_summary, &rra_time, rrd_mmaped_file); +#else + pcdp_summary = write_RRA_row(&rrd, i, &rra_current, scratch_idx, rrd_file, + pcdp_summary, &rra_time); +#endif } if (rrd_test_error()) @@ -1040,6 +1287,7 @@ rrd_update(int argc, char **argv) } /* endif a pdp_st has occurred */ rrd.live_head->last_up = current_time; + rrd.live_head->last_up_usec = current_time_usec; free(step_start); } /* function argument loop */ @@ -1048,6 +1296,11 @@ rrd_update(int argc, char **argv) if (rra_step_cnt != NULL) free(rra_step_cnt); rpnstack_free(&rpnstack); +#ifdef HAVE_MMAP + if (munmap(rrd_mmaped_file, rrd_filesize) == -1) { + rrd_set_error("error writing(unmapping) file: %s", filename); + } +#endif /* if we got here and if there is an error and if the file has not been * written to, then close things up and return. */ if (rrd_test_error()) { @@ -1077,17 +1330,33 @@ rrd_update(int argc, char **argv) return(-1); } - if(fwrite( rrd.live_head, - sizeof(live_head_t), 1, rrd_file) != 1){ - rrd_set_error("fwrite live_head to rrd"); - free(updvals); - rrd_free(&rrd); - free(tmpl_idx); - free(pdp_temp); - free(pdp_new); - fclose(rrd_file); - return(-1); + if(version >= 3) { + if(fwrite( rrd.live_head, + sizeof(live_head_t), 1, rrd_file) != 1){ + rrd_set_error("fwrite live_head to rrd"); + free(updvals); + rrd_free(&rrd); + free(tmpl_idx); + free(pdp_temp); + free(pdp_new); + fclose(rrd_file); + return(-1); + } } + else { + if(fwrite( &rrd.live_head->last_up, + sizeof(time_t), 1, rrd_file) != 1){ + rrd_set_error("fwrite live_head to rrd"); + free(updvals); + rrd_free(&rrd); + free(tmpl_idx); + free(pdp_temp); + free(pdp_new); + fclose(rrd_file); + return(-1); + } + } + if(fwrite( rrd.pdp_prep, sizeof(pdp_prep_t), @@ -1148,11 +1417,7 @@ rrd_update(int argc, char **argv) * critical except during the burning cycles. */ if (schedule_smooth) { -#ifndef WIN32 - rrd_file = fopen(argv[optind],"r+"); -#else - rrd_file = fopen(argv[optind],"rb+"); -#endif + rrd_file = fopen(filename,"rb+"); rra_start = rra_begin; for (i = 0; i < rrd.stat_head -> rra_cnt; ++i) { @@ -1189,40 +1454,54 @@ int LockRRD(FILE *rrdfile) { int rrd_fd; /* File descriptor for RRD */ - int stat; + int rcstat; rrd_fd = fileno(rrdfile); { -#ifndef WIN32 - struct flock lock; +#if defined(_WIN32) && !defined(__CYGWIN__) && !defined(__CYGWIN32__) + struct _stat st; + + if ( _fstat( rrd_fd, &st ) == 0 ) { + rcstat = _locking ( rrd_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 */ - stat = fcntl(rrd_fd, F_SETLK, &lock); -#else - struct _stat st; - - if ( _fstat( rrd_fd, &st ) == 0 ) { - stat = _locking ( rrd_fd, _LK_NBLCK, st.st_size ); - } else { - stat = -1; - } + rcstat = fcntl(rrd_fd, F_SETLK, &lock); #endif } - return(stat); + return(rcstat); } -void -write_RRA_row (rrd_t *rrd, unsigned long rra_idx, unsigned long *rra_current, - unsigned short CDP_scratch_idx, FILE *rrd_file) +#ifdef HAVE_MMAP +info_t +*write_RRA_row (rrd_t *rrd, unsigned long rra_idx, unsigned long *rra_current, + unsigned short CDP_scratch_idx, +#ifndef DEBUG +FILE UNUSED(*rrd_file), +#else +FILE *rrd_file, +#endif + info_t *pcdp_summary, time_t *rra_time, void *rrd_mmaped_file) +#else +info_t +*write_RRA_row (rrd_t *rrd, unsigned long rra_idx, unsigned long *rra_current, + unsigned short CDP_scratch_idx, FILE *rrd_file, + info_t *pcdp_summary, time_t *rra_time) +#endif { unsigned long ds_idx, cdp_idx; - + infoval iv; + for (ds_idx = 0; ds_idx < rrd -> stat_head -> ds_cnt; ds_idx++) { /* compute the cdp index */ @@ -1232,13 +1511,29 @@ write_RRA_row (rrd_t *rrd, unsigned long rra_idx, unsigned long *rra_current, rrd -> cdp_prep[cdp_idx].scratch[CDP_scratch_idx].u_val,ftell(rrd_file), rrd -> rra_def[rra_idx].cf_nam); #endif - + 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); + } +#ifdef HAVE_MMAP + memcpy((char *)rrd_mmaped_file + *rra_current, + &(rrd -> cdp_prep[cdp_idx].scratch[CDP_scratch_idx].u_val), + sizeof(rrd_value_t)); +#else if(fwrite(&(rrd -> cdp_prep[cdp_idx].scratch[CDP_scratch_idx].u_val), sizeof(rrd_value_t),1,rrd_file) != 1) { rrd_set_error("writing rrd"); - return; + return 0; } +#endif *rra_current += sizeof(rrd_value_t); } + return (pcdp_summary); }