bffad73c75123ef1721f7e1403e968755b5fc16a
1 /*****************************************************************************
2 * RRDtool 1.3.5 Copyright by Tobi Oetiker, 1997-2008
3 *****************************************************************************
4 * rrd_create.c creates new rrds
5 *****************************************************************************/
7 #include <stdlib.h>
8 #include <time.h>
9 #include <locale.h>
11 #include "rrd_tool.h"
12 #include "rrd_rpncalc.h"
13 #include "rrd_hw.h"
15 #include "rrd_is_thread_safe.h"
17 #ifdef WIN32
18 #include <fcntl.h>
19 #include <process.h>
20 #endif
22 unsigned long FnvHash(
23 const char *str);
24 int create_hw_contingent_rras(
25 rrd_t *rrd,
26 unsigned short period,
27 unsigned long hashed_name);
28 void parseGENERIC_DS(
29 const char *def,
30 rrd_t *rrd,
31 int ds_idx);
32 long int rra_random_row(
33 rra_def_t *);
35 static void rrd_free2(
36 rrd_t *rrd); /* our onwn copy, immmune to mmap */
38 int rrd_create(
39 int argc,
40 char **argv)
41 {
42 struct option long_options[] = {
43 {"start", required_argument, 0, 'b'},
44 {"step", required_argument, 0, 's'},
45 {0, 0, 0, 0}
46 };
47 int option_index = 0;
48 int opt;
49 time_t last_up = time(NULL) - 10;
50 unsigned long pdp_step = 300;
51 rrd_time_value_t last_up_tv;
52 char *parsetime_error = NULL;
53 long long_tmp;
54 int rc;
56 optind = 0;
57 opterr = 0; /* initialize getopt */
59 while (1) {
60 opt = getopt_long(argc, argv, "b:s:", long_options, &option_index);
62 if (opt == EOF)
63 break;
65 switch (opt) {
66 case 'b':
67 if ((parsetime_error = rrd_parsetime(optarg, &last_up_tv))) {
68 rrd_set_error("start time: %s", parsetime_error);
69 return (-1);
70 }
71 if (last_up_tv.type == RELATIVE_TO_END_TIME ||
72 last_up_tv.type == RELATIVE_TO_START_TIME) {
73 rrd_set_error("specifying time relative to the 'start' "
74 "or 'end' makes no sense here");
75 return (-1);
76 }
78 last_up = mktime(&last_up_tv.tm) +last_up_tv.offset;
80 if (last_up < 3600 * 24 * 365 * 10) {
81 rrd_set_error
82 ("the first entry to the RRD should be after 1980");
83 return (-1);
84 }
85 break;
87 case 's':
88 long_tmp = atol(optarg);
89 if (long_tmp < 1) {
90 rrd_set_error("step size should be no less than one second");
91 return (-1);
92 }
93 pdp_step = long_tmp;
94 break;
96 case '?':
97 if (optopt != 0)
98 rrd_set_error("unknown option '%c'", optopt);
99 else
100 rrd_set_error("unknown option '%s'", argv[optind - 1]);
101 return (-1);
102 }
103 }
104 if (optind == argc) {
105 rrd_set_error("need name of an rrd file to create");
106 return -1;
107 }
108 rc = rrd_create_r(argv[optind],
109 pdp_step, last_up,
110 argc - optind - 1, (const char **) (argv + optind + 1));
112 return rc;
113 }
115 /* #define DEBUG */
116 int rrd_create_r(
117 const char *filename,
118 unsigned long pdp_step,
119 time_t last_up,
120 int argc,
121 const char **argv)
122 {
123 rrd_t rrd;
124 long i;
125 int offset;
126 char *token;
127 char dummychar1[2], dummychar2[2];
128 unsigned short token_idx, error_flag, period = 0;
129 unsigned long hashed_name;
131 /* init rrd clean */
132 rrd_init(&rrd);
133 /* static header */
134 if ((rrd.stat_head = (stat_head_t*)calloc(1, sizeof(stat_head_t))) == NULL) {
135 rrd_set_error("allocating rrd.stat_head");
136 rrd_free2(&rrd);
137 return (-1);
138 }
140 /* live header */
141 if ((rrd.live_head = (live_head_t*)calloc(1, sizeof(live_head_t))) == NULL) {
142 rrd_set_error("allocating rrd.live_head");
143 rrd_free2(&rrd);
144 return (-1);
145 }
147 /* set some defaults */
148 strcpy(rrd.stat_head->cookie, RRD_COOKIE);
149 strcpy(rrd.stat_head->version, RRD_VERSION3); /* by default we are still version 3 */
150 rrd.stat_head->float_cookie = FLOAT_COOKIE;
151 rrd.stat_head->ds_cnt = 0; /* this will be adjusted later */
152 rrd.stat_head->rra_cnt = 0; /* ditto */
153 rrd.stat_head->pdp_step = pdp_step; /* 5 minute default */
155 /* a default value */
156 rrd.ds_def = NULL;
157 rrd.rra_def = NULL;
159 rrd.live_head->last_up = last_up;
161 /* optind points to the first non-option command line arg,
162 * in this case, the file name. */
163 /* Compute the FNV hash value (used by SEASONAL and DEVSEASONAL
164 * arrays. */
165 hashed_name = FnvHash(filename);
166 for (i = 0; i < argc; i++) {
167 unsigned int ii;
169 if (strncmp(argv[i], "DS:", 3) == 0) {
170 size_t old_size = sizeof(ds_def_t) * (rrd.stat_head->ds_cnt);
172 if ((rrd.ds_def = (ds_def_t*)rrd_realloc(rrd.ds_def,
173 old_size + sizeof(ds_def_t))) ==
174 NULL) {
175 rrd_set_error("allocating rrd.ds_def");
176 rrd_free2(&rrd);
177 return (-1);
178 }
179 memset(&rrd.ds_def[rrd.stat_head->ds_cnt], 0, sizeof(ds_def_t));
180 /* extract the name and type */
181 switch (sscanf(&argv[i][3],
182 DS_NAM_FMT "%1[:]" DST_FMT "%1[:]%n",
183 rrd.ds_def[rrd.stat_head->ds_cnt].ds_nam,
184 dummychar1,
185 rrd.ds_def[rrd.stat_head->ds_cnt].dst,
186 dummychar2, &offset)) {
187 case 0:
188 case 1:
189 rrd_set_error("Invalid DS name");
190 break;
191 case 2:
192 case 3:
193 rrd_set_error("Invalid DS type");
194 break;
195 case 4: /* (%n may or may not be counted) */
196 case 5: /* check for duplicate datasource names */
197 for (ii = 0; ii < rrd.stat_head->ds_cnt; ii++)
198 if (strcmp(rrd.ds_def[rrd.stat_head->ds_cnt].ds_nam,
199 rrd.ds_def[ii].ds_nam) == 0)
200 rrd_set_error("Duplicate DS name: %s",
201 rrd.ds_def[ii].ds_nam);
202 /* DS_type may be valid or not. Checked later */
203 break;
204 default:
205 rrd_set_error("invalid DS format");
206 }
207 if (rrd_test_error()) {
208 rrd_free2(&rrd);
209 return -1;
210 }
212 /* parse the remainder of the arguments */
213 switch (dst_conv(rrd.ds_def[rrd.stat_head->ds_cnt].dst)) {
214 case DST_COUNTER:
215 case DST_ABSOLUTE:
216 case DST_GAUGE:
217 case DST_DERIVE:
218 parseGENERIC_DS(&argv[i][offset + 3], &rrd,
219 rrd.stat_head->ds_cnt);
220 break;
221 case DST_CDEF:
222 parseCDEF_DS(&argv[i][offset + 3], &rrd,
223 rrd.stat_head->ds_cnt);
224 break;
225 default:
226 rrd_set_error("invalid DS type specified");
227 break;
228 }
230 if (rrd_test_error()) {
231 rrd_free2(&rrd);
232 return -1;
233 }
234 rrd.stat_head->ds_cnt++;
235 } else if (strncmp(argv[i], "RRA:", 4) == 0) {
236 char *argvcopy;
237 char *tokptr;
238 size_t old_size = sizeof(rra_def_t) * (rrd.stat_head->rra_cnt);
239 int row_cnt;
241 if ((rrd.rra_def = (rra_def_t*)rrd_realloc(rrd.rra_def,
242 old_size + sizeof(rra_def_t))) ==
243 NULL) {
244 rrd_set_error("allocating rrd.rra_def");
245 rrd_free2(&rrd);
246 return (-1);
247 }
248 memset(&rrd.rra_def[rrd.stat_head->rra_cnt], 0,
249 sizeof(rra_def_t));
251 argvcopy = strdup(argv[i]);
252 token = strtok_r(&argvcopy[4], ":", &tokptr);
253 token_idx = error_flag = 0;
254 while (token != NULL) {
255 switch (token_idx) {
256 case 0:
257 if (sscanf(token, CF_NAM_FMT,
258 rrd.rra_def[rrd.stat_head->rra_cnt].cf_nam) !=
259 1)
260 rrd_set_error("Failed to parse CF name");
261 switch (cf_conv
262 (rrd.rra_def[rrd.stat_head->rra_cnt].cf_nam)) {
263 case CF_MHWPREDICT:
264 strcpy(rrd.stat_head->version, RRD_VERSION); /* MHWPREDICT causes Version 4 */
265 case CF_HWPREDICT:
266 /* initialize some parameters */
267 rrd.rra_def[rrd.stat_head->rra_cnt].par[RRA_hw_alpha].
268 u_val = 0.1;
269 rrd.rra_def[rrd.stat_head->rra_cnt].par[RRA_hw_beta].
270 u_val = 1.0 / 288;
271 rrd.rra_def[rrd.stat_head->rra_cnt].
272 par[RRA_dependent_rra_idx].u_cnt =
273 rrd.stat_head->rra_cnt;
274 break;
275 case CF_DEVSEASONAL:
276 case CF_SEASONAL:
277 /* initialize some parameters */
278 rrd.rra_def[rrd.stat_head->rra_cnt].
279 par[RRA_seasonal_gamma].u_val = 0.1;
280 rrd.rra_def[rrd.stat_head->rra_cnt].
281 par[RRA_seasonal_smoothing_window].u_val = 0.05;
282 /* fall through */
283 case CF_DEVPREDICT:
284 rrd.rra_def[rrd.stat_head->rra_cnt].
285 par[RRA_dependent_rra_idx].u_cnt = -1;
286 break;
287 case CF_FAILURES:
288 rrd.rra_def[rrd.stat_head->rra_cnt].
289 par[RRA_delta_pos].u_val = 2.0;
290 rrd.rra_def[rrd.stat_head->rra_cnt].
291 par[RRA_delta_neg].u_val = 2.0;
292 rrd.rra_def[rrd.stat_head->rra_cnt].
293 par[RRA_window_len].u_cnt = 3;
294 rrd.rra_def[rrd.stat_head->rra_cnt].
295 par[RRA_failure_threshold].u_cnt = 2;
296 rrd.rra_def[rrd.stat_head->rra_cnt].
297 par[RRA_dependent_rra_idx].u_cnt = -1;
298 break;
299 /* invalid consolidation function */
300 case -1:
301 rrd_set_error
302 ("Unrecognized consolidation function %s",
303 rrd.rra_def[rrd.stat_head->rra_cnt].cf_nam);
304 default:
305 break;
306 }
307 /* default: 1 pdp per cdp */
308 rrd.rra_def[rrd.stat_head->rra_cnt].pdp_cnt = 1;
309 break;
310 case 1:
311 switch (cf_conv
312 (rrd.rra_def[rrd.stat_head->rra_cnt].cf_nam)) {
313 case CF_HWPREDICT:
314 case CF_MHWPREDICT:
315 case CF_DEVSEASONAL:
316 case CF_SEASONAL:
317 case CF_DEVPREDICT:
318 case CF_FAILURES:
319 row_cnt = atoi(token);
320 if (row_cnt <= 0)
321 rrd_set_error("Invalid row count: %i", row_cnt);
322 rrd.rra_def[rrd.stat_head->rra_cnt].row_cnt = row_cnt;
323 break;
324 default:
325 rrd.rra_def[rrd.stat_head->rra_cnt].
326 par[RRA_cdp_xff_val].u_val = atof(token);
327 if (rrd.rra_def[rrd.stat_head->rra_cnt].
328 par[RRA_cdp_xff_val].u_val < 0.0
329 || rrd.rra_def[rrd.stat_head->rra_cnt].
330 par[RRA_cdp_xff_val].u_val >= 1.0)
331 rrd_set_error
332 ("Invalid xff: must be between 0 and 1");
333 break;
334 }
335 break;
336 case 2:
337 switch (cf_conv
338 (rrd.rra_def[rrd.stat_head->rra_cnt].cf_nam)) {
339 case CF_HWPREDICT:
340 case CF_MHWPREDICT:
341 rrd.rra_def[rrd.stat_head->rra_cnt].par[RRA_hw_alpha].
342 u_val = atof(token);
343 if (atof(token) <= 0.0 || atof(token) >= 1.0)
344 rrd_set_error
345 ("Invalid alpha: must be between 0 and 1");
346 break;
347 case CF_DEVSEASONAL:
348 case CF_SEASONAL:
349 rrd.rra_def[rrd.stat_head->rra_cnt].
350 par[RRA_seasonal_gamma].u_val = atof(token);
351 if (atof(token) <= 0.0 || atof(token) >= 1.0)
352 rrd_set_error
353 ("Invalid gamma: must be between 0 and 1");
354 rrd.rra_def[rrd.stat_head->rra_cnt].
355 par[RRA_seasonal_smooth_idx].u_cnt =
356 hashed_name %
357 rrd.rra_def[rrd.stat_head->rra_cnt].row_cnt;
358 break;
359 case CF_FAILURES:
360 /* specifies the # of violations that constitutes the failure threshold */
361 rrd.rra_def[rrd.stat_head->rra_cnt].
362 par[RRA_failure_threshold].u_cnt = atoi(token);
363 if (atoi(token) < 1
364 || atoi(token) > MAX_FAILURES_WINDOW_LEN)
365 rrd_set_error
366 ("Failure threshold is out of range %d, %d",
367 1, MAX_FAILURES_WINDOW_LEN);
368 break;
369 case CF_DEVPREDICT:
370 /* specifies the index (1-based) of CF_DEVSEASONAL array
371 * associated with this CF_DEVPREDICT array. */
372 rrd.rra_def[rrd.stat_head->rra_cnt].
373 par[RRA_dependent_rra_idx].u_cnt =
374 atoi(token) - 1;
375 break;
376 default:
377 rrd.rra_def[rrd.stat_head->rra_cnt].pdp_cnt =
378 atoi(token);
379 if (atoi(token) < 1)
380 rrd_set_error("Invalid step: must be >= 1");
381 break;
382 }
383 break;
384 case 3:
385 switch (cf_conv
386 (rrd.rra_def[rrd.stat_head->rra_cnt].cf_nam)) {
387 case CF_HWPREDICT:
388 case CF_MHWPREDICT:
389 rrd.rra_def[rrd.stat_head->rra_cnt].par[RRA_hw_beta].
390 u_val = atof(token);
391 if (atof(token) < 0.0 || atof(token) > 1.0)
392 rrd_set_error
393 ("Invalid beta: must be between 0 and 1");
394 break;
395 case CF_DEVSEASONAL:
396 case CF_SEASONAL:
397 /* specifies the index (1-based) of CF_HWPREDICT array
398 * associated with this CF_DEVSEASONAL or CF_SEASONAL array.
399 * */
400 rrd.rra_def[rrd.stat_head->rra_cnt].
401 par[RRA_dependent_rra_idx].u_cnt =
402 atoi(token) - 1;
403 break;
404 case CF_FAILURES:
405 /* specifies the window length */
406 rrd.rra_def[rrd.stat_head->rra_cnt].
407 par[RRA_window_len].u_cnt = atoi(token);
408 if (atoi(token) < 1
409 || atoi(token) > MAX_FAILURES_WINDOW_LEN)
410 rrd_set_error
411 ("Window length is out of range %d, %d", 1,
412 MAX_FAILURES_WINDOW_LEN);
413 /* verify that window length exceeds the failure threshold */
414 if (rrd.rra_def[rrd.stat_head->rra_cnt].
415 par[RRA_window_len].u_cnt <
416 rrd.rra_def[rrd.stat_head->rra_cnt].
417 par[RRA_failure_threshold].u_cnt)
418 rrd_set_error
419 ("Window length is shorter than the failure threshold");
420 break;
421 case CF_DEVPREDICT:
422 /* shouldn't be any more arguments */
423 rrd_set_error
424 ("Unexpected extra argument for consolidation function DEVPREDICT");
425 break;
426 default:
427 row_cnt = atoi(token);
428 if (row_cnt <= 0)
429 rrd_set_error("Invalid row count: %i", row_cnt);
430 rrd.rra_def[rrd.stat_head->rra_cnt].row_cnt = row_cnt;
431 break;
432 }
433 break;
434 case 4:
435 switch (cf_conv
436 (rrd.rra_def[rrd.stat_head->rra_cnt].cf_nam)) {
437 case CF_FAILURES:
438 /* specifies the index (1-based) of CF_DEVSEASONAL array
439 * associated with this CF_DEVFAILURES array. */
440 rrd.rra_def[rrd.stat_head->rra_cnt].
441 par[RRA_dependent_rra_idx].u_cnt =
442 atoi(token) - 1;
443 break;
444 case CF_DEVSEASONAL:
445 case CF_SEASONAL:
446 /* optional smoothing window */
447 if (sscanf(token, "smoothing-window=%lf",
448 &(rrd.rra_def[rrd.stat_head->rra_cnt].
449 par[RRA_seasonal_smoothing_window].
450 u_val))) {
451 strcpy(rrd.stat_head->version, RRD_VERSION); /* smoothing-window causes Version 4 */
452 if (rrd.rra_def[rrd.stat_head->rra_cnt].
453 par[RRA_seasonal_smoothing_window].u_val < 0.0
454 || rrd.rra_def[rrd.stat_head->rra_cnt].
455 par[RRA_seasonal_smoothing_window].u_val >
456 1.0) {
457 rrd_set_error
458 ("Invalid smoothing-window %f: must be between 0 and 1",
459 rrd.rra_def[rrd.stat_head->rra_cnt].
460 par[RRA_seasonal_smoothing_window].
461 u_val);
462 }
463 } else {
464 rrd_set_error("Invalid option %s", token);
465 }
466 break;
467 case CF_HWPREDICT:
468 case CF_MHWPREDICT:
469 /* length of the associated CF_SEASONAL and CF_DEVSEASONAL arrays. */
470 period = atoi(token);
471 if (period >
472 rrd.rra_def[rrd.stat_head->rra_cnt].row_cnt)
473 rrd_set_error
474 ("Length of seasonal cycle exceeds length of HW prediction array");
475 break;
476 default:
477 /* shouldn't be any more arguments */
478 rrd_set_error
479 ("Unexpected extra argument for consolidation function %s",
480 rrd.rra_def[rrd.stat_head->rra_cnt].cf_nam);
481 break;
482 }
483 break;
484 case 5:
485 /* If we are here, this must be a CF_HWPREDICT RRA.
486 * Specifies the index (1-based) of CF_SEASONAL array
487 * associated with this CF_HWPREDICT array. If this argument
488 * is missing, then the CF_SEASONAL, CF_DEVSEASONAL, CF_DEVPREDICT,
489 * CF_FAILURES.
490 * arrays are created automatically. */
491 rrd.rra_def[rrd.stat_head->rra_cnt].
492 par[RRA_dependent_rra_idx].u_cnt = atoi(token) - 1;
493 break;
494 default:
495 /* should never get here */
496 rrd_set_error("Unknown error");
497 break;
498 } /* end switch */
499 if (rrd_test_error()) {
500 /* all errors are unrecoverable */
501 free(argvcopy);
502 rrd_free2(&rrd);
503 return (-1);
504 }
505 token = strtok_r(NULL, ":", &tokptr);
506 token_idx++;
507 } /* end while */
508 free(argvcopy);
509 #ifdef DEBUG
510 fprintf(stderr,
511 "Creating RRA CF: %s, dep idx %lu, current idx %lu\n",
512 rrd.rra_def[rrd.stat_head->rra_cnt].cf_nam,
513 rrd.rra_def[rrd.stat_head->rra_cnt].
514 par[RRA_dependent_rra_idx].u_cnt, rrd.stat_head->rra_cnt);
515 #endif
516 /* should we create CF_SEASONAL, CF_DEVSEASONAL, and CF_DEVPREDICT? */
517 if ((cf_conv(rrd.rra_def[rrd.stat_head->rra_cnt].cf_nam) ==
518 CF_HWPREDICT
519 || cf_conv(rrd.rra_def[rrd.stat_head->rra_cnt].cf_nam) ==
520 CF_MHWPREDICT)
521 && rrd.rra_def[rrd.stat_head->rra_cnt].
522 par[RRA_dependent_rra_idx].u_cnt == rrd.stat_head->rra_cnt) {
523 #ifdef DEBUG
524 fprintf(stderr, "Creating HW contingent RRAs\n");
525 #endif
526 if (create_hw_contingent_rras(&rrd, period, hashed_name) ==
527 -1) {
528 rrd_set_error("creating contingent RRA");
529 rrd_free2(&rrd);
530 return -1;
531 }
532 }
533 rrd.stat_head->rra_cnt++;
534 } else {
535 rrd_set_error("can't parse argument '%s'", argv[i]);
536 rrd_free2(&rrd);
537 return -1;
538 }
539 }
542 if (rrd.stat_head->rra_cnt < 1) {
543 rrd_set_error("you must define at least one Round Robin Archive");
544 rrd_free2(&rrd);
545 return (-1);
546 }
548 if (rrd.stat_head->ds_cnt < 1) {
549 rrd_set_error("you must define at least one Data Source");
550 rrd_free2(&rrd);
551 return (-1);
552 }
553 return rrd_create_fn(filename, &rrd);
554 }
556 void parseGENERIC_DS(
557 const char *def,
558 rrd_t *rrd,
559 int ds_idx)
560 {
561 char minstr[DS_NAM_SIZE], maxstr[DS_NAM_SIZE];
562 char *old_locale;
564 /*
565 int temp;
567 temp = sscanf(def,"%lu:%18[^:]:%18[^:]",
568 &(rrd -> ds_def[ds_idx].par[DS_mrhb_cnt].u_cnt),
569 minstr,maxstr);
570 */
571 old_locale = setlocale(LC_NUMERIC, "C");
572 if (sscanf(def, "%lu:%18[^:]:%18[^:]",
573 &(rrd->ds_def[ds_idx].par[DS_mrhb_cnt].u_cnt),
574 minstr, maxstr) == 3) {
575 if (minstr[0] == 'U' && minstr[1] == 0)
576 rrd->ds_def[ds_idx].par[DS_min_val].u_val = DNAN;
577 else
578 rrd->ds_def[ds_idx].par[DS_min_val].u_val = atof(minstr);
580 if (maxstr[0] == 'U' && maxstr[1] == 0)
581 rrd->ds_def[ds_idx].par[DS_max_val].u_val = DNAN;
582 else
583 rrd->ds_def[ds_idx].par[DS_max_val].u_val = atof(maxstr);
585 if (!isnan(rrd->ds_def[ds_idx].par[DS_min_val].u_val) &&
586 !isnan(rrd->ds_def[ds_idx].par[DS_max_val].u_val) &&
587 rrd->ds_def[ds_idx].par[DS_min_val].u_val
588 >= rrd->ds_def[ds_idx].par[DS_max_val].u_val) {
589 rrd_set_error("min must be less than max in DS definition");
590 setlocale(LC_NUMERIC, old_locale);
591 return;
592 }
593 } else {
594 rrd_set_error("failed to parse data source %s", def);
595 }
596 setlocale(LC_NUMERIC, old_locale);
597 }
599 /* Create the CF_DEVPREDICT, CF_DEVSEASONAL, CF_SEASONAL, and CF_FAILURES RRAs
600 * associated with a CF_HWPREDICT RRA. */
601 int create_hw_contingent_rras(
602 rrd_t *rrd,
603 unsigned short period,
604 unsigned long hashed_name)
605 {
606 size_t old_size;
607 rra_def_t *current_rra;
609 /* save index to CF_HWPREDICT */
610 unsigned long hw_index = rrd->stat_head->rra_cnt;
612 /* advance the pointer */
613 (rrd->stat_head->rra_cnt)++;
614 /* allocate the memory for the 4 contingent RRAs */
615 old_size = sizeof(rra_def_t) * (rrd->stat_head->rra_cnt);
616 if ((rrd->rra_def = (rra_def_t*)rrd_realloc(rrd->rra_def,
617 old_size + 4 * sizeof(rra_def_t))) ==
618 NULL) {
619 rrd_free2(rrd);
620 rrd_set_error("allocating rrd.rra_def");
621 return (-1);
622 }
623 /* clear memory */
624 memset(&(rrd->rra_def[rrd->stat_head->rra_cnt]), 0,
625 4 * sizeof(rra_def_t));
627 /* create the CF_SEASONAL RRA */
628 current_rra = &(rrd->rra_def[rrd->stat_head->rra_cnt]);
629 strcpy(current_rra->cf_nam, "SEASONAL");
630 current_rra->row_cnt = period;
631 current_rra->par[RRA_seasonal_smooth_idx].u_cnt = hashed_name % period;
632 current_rra->pdp_cnt = 1;
633 current_rra->par[RRA_seasonal_gamma].u_val =
634 rrd->rra_def[hw_index].par[RRA_hw_alpha].u_val;
635 current_rra->par[RRA_dependent_rra_idx].u_cnt = hw_index;
636 rrd->rra_def[hw_index].par[RRA_dependent_rra_idx].u_cnt =
637 rrd->stat_head->rra_cnt;
639 /* create the CF_DEVSEASONAL RRA */
640 (rrd->stat_head->rra_cnt)++;
641 current_rra = &(rrd->rra_def[rrd->stat_head->rra_cnt]);
642 strcpy(current_rra->cf_nam, "DEVSEASONAL");
643 current_rra->row_cnt = period;
644 current_rra->par[RRA_seasonal_smooth_idx].u_cnt = hashed_name % period;
645 current_rra->pdp_cnt = 1;
646 current_rra->par[RRA_seasonal_gamma].u_val =
647 rrd->rra_def[hw_index].par[RRA_hw_alpha].u_val;
648 current_rra->par[RRA_dependent_rra_idx].u_cnt = hw_index;
650 /* create the CF_DEVPREDICT RRA */
651 (rrd->stat_head->rra_cnt)++;
652 current_rra = &(rrd->rra_def[rrd->stat_head->rra_cnt]);
653 strcpy(current_rra->cf_nam, "DEVPREDICT");
654 current_rra->row_cnt = (rrd->rra_def[hw_index]).row_cnt;
655 current_rra->pdp_cnt = 1;
656 current_rra->par[RRA_dependent_rra_idx].u_cnt = hw_index + 2; /* DEVSEASONAL */
658 /* create the CF_FAILURES RRA */
659 (rrd->stat_head->rra_cnt)++;
660 current_rra = &(rrd->rra_def[rrd->stat_head->rra_cnt]);
661 strcpy(current_rra->cf_nam, "FAILURES");
662 current_rra->row_cnt = period;
663 current_rra->pdp_cnt = 1;
664 current_rra->par[RRA_delta_pos].u_val = 2.0;
665 current_rra->par[RRA_delta_neg].u_val = 2.0;
666 current_rra->par[RRA_failure_threshold].u_cnt = 7;
667 current_rra->par[RRA_window_len].u_cnt = 9;
668 current_rra->par[RRA_dependent_rra_idx].u_cnt = hw_index + 2; /* DEVSEASONAL */
669 return 0;
670 }
672 /* create and empty rrd file according to the specs given */
674 int rrd_create_fn(
675 const char *file_name,
676 rrd_t *rrd)
677 {
678 unsigned long i, ii;
679 int rrd_file;
680 rrd_value_t *unknown;
681 int unkn_cnt;
682 rrd_file_t *rrd_file_dn;
683 rrd_t rrd_dn;
684 unsigned flags = O_WRONLY | O_CREAT | O_TRUNC;
686 #if defined(_WIN32) && !defined(__CYGWIN__) && !defined(__CYGWIN32__)
687 flags |= O_BINARY;
688 #endif
690 if ((rrd_file = open(file_name, flags, 0666)) < 0) {
691 rrd_set_error("creating '%s': %s", file_name, rrd_strerror(errno));
692 rrd_free2(rrd);
693 return (-1);
694 }
696 write(rrd_file, rrd->stat_head, sizeof(stat_head_t));
698 write(rrd_file, rrd->ds_def, sizeof(ds_def_t) * rrd->stat_head->ds_cnt);
700 write(rrd_file, rrd->rra_def,
701 sizeof(rra_def_t) * rrd->stat_head->rra_cnt);
703 write(rrd_file, rrd->live_head, sizeof(live_head_t));
705 if ((rrd->pdp_prep = (pdp_prep_t*)calloc(1, sizeof(pdp_prep_t))) == NULL) {
706 rrd_set_error("allocating pdp_prep");
707 rrd_free2(rrd);
708 close(rrd_file);
709 return (-1);
710 }
712 strcpy(rrd->pdp_prep->last_ds, "U");
714 rrd->pdp_prep->scratch[PDP_val].u_val = 0.0;
715 rrd->pdp_prep->scratch[PDP_unkn_sec_cnt].u_cnt =
716 rrd->live_head->last_up % rrd->stat_head->pdp_step;
718 for (i = 0; i < rrd->stat_head->ds_cnt; i++)
719 write(rrd_file, rrd->pdp_prep, sizeof(pdp_prep_t));
721 if ((rrd->cdp_prep = (cdp_prep_t*)calloc(1, sizeof(cdp_prep_t))) == NULL) {
722 rrd_set_error("allocating cdp_prep");
723 rrd_free2(rrd);
724 close(rrd_file);
725 return (-1);
726 }
729 for (i = 0; i < rrd->stat_head->rra_cnt; i++) {
730 switch (cf_conv(rrd->rra_def[i].cf_nam)) {
731 case CF_HWPREDICT:
732 case CF_MHWPREDICT:
733 init_hwpredict_cdp(rrd->cdp_prep);
734 break;
735 case CF_SEASONAL:
736 case CF_DEVSEASONAL:
737 init_seasonal_cdp(rrd->cdp_prep);
738 break;
739 case CF_FAILURES:
740 /* initialize violation history to 0 */
741 for (ii = 0; ii < MAX_CDP_PAR_EN; ii++) {
742 /* We can zero everything out, by setting u_val to the
743 * NULL address. Each array entry in scratch is 8 bytes
744 * (a double), but u_cnt only accessed 4 bytes (long) */
745 rrd->cdp_prep->scratch[ii].u_val = 0.0;
746 }
747 break;
748 default:
749 /* can not be zero because we don't know anything ... */
750 rrd->cdp_prep->scratch[CDP_val].u_val = DNAN;
751 /* startup missing pdp count */
752 rrd->cdp_prep->scratch[CDP_unkn_pdp_cnt].u_cnt =
753 ((rrd->live_head->last_up -
754 rrd->pdp_prep->scratch[PDP_unkn_sec_cnt].u_cnt)
755 % (rrd->stat_head->pdp_step
756 * rrd->rra_def[i].pdp_cnt)) / rrd->stat_head->pdp_step;
757 break;
758 }
760 for (ii = 0; ii < rrd->stat_head->ds_cnt; ii++) {
761 write(rrd_file, rrd->cdp_prep, sizeof(cdp_prep_t));
762 }
763 }
765 /* now, we must make sure that the rest of the rrd
766 struct is properly initialized */
768 if ((rrd->rra_ptr = (rra_ptr_t*)calloc(1, sizeof(rra_ptr_t))) == NULL) {
769 rrd_set_error("allocating rra_ptr");
770 rrd_free2(rrd);
771 close(rrd_file);
772 return (-1);
773 }
775 /* changed this initialization to be consistent with
776 * rrd_restore. With the old value (0), the first update
777 * would occur for cur_row = 1 because rrd_update increments
778 * the pointer a priori. */
779 for (i = 0; i < rrd->stat_head->rra_cnt; i++) {
780 rrd->rra_ptr->cur_row = rra_random_row(&rrd->rra_def[i]);
781 write(rrd_file, rrd->rra_ptr, sizeof(rra_ptr_t));
782 }
784 /* write the empty data area */
785 if ((unknown = (rrd_value_t *) malloc(512 * sizeof(rrd_value_t))) == NULL) {
786 rrd_set_error("allocating unknown");
787 rrd_free2(rrd);
788 close(rrd_file);
789 return (-1);
790 }
791 for (i = 0; i < 512; ++i)
792 unknown[i] = DNAN;
794 unkn_cnt = 0;
795 for (i = 0; i < rrd->stat_head->rra_cnt; i++)
796 unkn_cnt += rrd->stat_head->ds_cnt * rrd->rra_def[i].row_cnt;
798 while (unkn_cnt > 0) {
799 write(rrd_file, unknown, sizeof(rrd_value_t) * min(unkn_cnt, 512));
801 unkn_cnt -= 512;
802 }
803 free(unknown);
805 #ifndef WIN32
806 fdatasync(rrd_file);
807 #endif
809 rrd_free2(rrd);
810 if (close(rrd_file) == -1) {
811 rrd_set_error("creating rrd: %s", rrd_strerror(errno));
812 return -1;
813 }
814 /* flush all we don't need out of the cache */
815 rrd_file_dn = rrd_open(file_name, &rrd_dn, RRD_READONLY);
816 rrd_dontneed(rrd_file_dn, &rrd_dn);
817 rrd_free(&rrd_dn);
818 rrd_close(rrd_file_dn);
819 return (0);
820 }
823 static void rrd_free2(
824 rrd_t *rrd)
825 {
826 free(rrd->live_head);
827 free(rrd->stat_head);
828 free(rrd->ds_def);
829 free(rrd->rra_def);
830 free(rrd->rra_ptr);
831 free(rrd->pdp_prep);
832 free(rrd->cdp_prep);
833 free(rrd->rrd_value);
834 }
836 static int rand_init = 0;
838 long int rra_random_row(
839 rra_def_t *rra)
840 {
841 if (!rand_init) {
842 #ifdef WIN32
843 srand((unsigned int) time(NULL) + (unsigned int) getpid());
844 #else
845 srandom((unsigned int) time(NULL) + (unsigned int) getpid());
846 #endif
847 rand_init++;
848 }
850 #ifdef WIN32
851 return rand() % rra->row_cnt;
852 #else
853 return random() % rra->row_cnt;
854 #endif
855 }