intel_pmu: address PR comments
[collectd.git] / src / utils_rrdcreate.c
1 /**
2  * collectd - src/utils_rrdcreate.c
3  * Copyright (C) 2006-2013  Florian octo Forster
4  *
5  * Permission is hereby granted, free of charge, to any person obtaining a
6  * copy of this software and associated documentation files (the "Software"),
7  * to deal in the Software without restriction, including without limitation
8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9  * and/or sell copies of the Software, and to permit persons to whom the
10  * Software is furnished to do so, subject to the following conditions:
11  *
12  * The above copyright notice and this permission notice shall be included in
13  * all copies or substantial portions of the Software.
14  *
15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21  * DEALINGS IN THE SOFTWARE.
22  *
23  * Authors:
24  *   Florian octo Forster <octo at collectd.org>
25  **/
26
27 #include "collectd.h"
28
29 #include "common.h"
30 #include "utils_rrdcreate.h"
31
32 #include <pthread.h>
33 #include <rrd.h>
34
35 struct srrd_create_args_s {
36   char *filename;
37   unsigned long pdp_step;
38   time_t last_up;
39   int argc;
40   char **argv;
41 };
42 typedef struct srrd_create_args_s srrd_create_args_t;
43
44 struct async_create_file_s;
45 typedef struct async_create_file_s async_create_file_t;
46 struct async_create_file_s {
47   char *filename;
48   async_create_file_t *next;
49 };
50
51 /*
52  * Private variables
53  */
54 static int rra_timespans[] = {3600, 86400, 604800, 2678400, 31622400};
55 static int rra_timespans_num = STATIC_ARRAY_SIZE(rra_timespans);
56
57 static const char *const rra_types[] = {"AVERAGE", "MIN", "MAX"};
58 static int rra_types_num = STATIC_ARRAY_SIZE(rra_types);
59
60 #if !defined(HAVE_THREADSAFE_LIBRRD)
61 static pthread_mutex_t librrd_lock = PTHREAD_MUTEX_INITIALIZER;
62 #endif
63
64 static async_create_file_t *async_creation_list = NULL;
65 static pthread_mutex_t async_creation_lock = PTHREAD_MUTEX_INITIALIZER;
66
67 /*
68  * Private functions
69  */
70 static void rra_free(int rra_num, char **rra_def) /* {{{ */
71 {
72   for (int i = 0; i < rra_num; i++) {
73     sfree(rra_def[i]);
74   }
75   sfree(rra_def);
76 } /* }}} void rra_free */
77
78 static void srrd_create_args_destroy(srrd_create_args_t *args) {
79   if (args == NULL)
80     return;
81
82   sfree(args->filename);
83   if (args->argv != NULL) {
84     for (int i = 0; i < args->argc; i++)
85       sfree(args->argv[i]);
86     sfree(args->argv);
87   }
88   sfree(args);
89 } /* void srrd_create_args_destroy */
90
91 static srrd_create_args_t *srrd_create_args_create(const char *filename,
92                                                    unsigned long pdp_step,
93                                                    time_t last_up, int argc,
94                                                    const char **argv) {
95   srrd_create_args_t *args;
96
97   args = calloc(1, sizeof(*args));
98   if (args == NULL) {
99     ERROR("srrd_create_args_create: calloc failed.");
100     return NULL;
101   }
102   args->filename = NULL;
103   args->pdp_step = pdp_step;
104   args->last_up = last_up;
105   args->argv = NULL;
106
107   args->filename = strdup(filename);
108   if (args->filename == NULL) {
109     ERROR("srrd_create_args_create: strdup failed.");
110     srrd_create_args_destroy(args);
111     return NULL;
112   }
113
114   args->argv = calloc((size_t)(argc + 1), sizeof(*args->argv));
115   if (args->argv == NULL) {
116     ERROR("srrd_create_args_create: calloc failed.");
117     srrd_create_args_destroy(args);
118     return NULL;
119   }
120
121   for (args->argc = 0; args->argc < argc; args->argc++) {
122     args->argv[args->argc] = strdup(argv[args->argc]);
123     if (args->argv[args->argc] == NULL) {
124       ERROR("srrd_create_args_create: strdup failed.");
125       srrd_create_args_destroy(args);
126       return NULL;
127     }
128   }
129   assert(args->argc == argc);
130   args->argv[args->argc] = NULL;
131
132   return args;
133 } /* srrd_create_args_t *srrd_create_args_create */
134
135 /* * * * * * * * * *
136  * WARNING:  Magic *
137  * * * * * * * * * */
138 static int rra_get(char ***ret, const value_list_t *vl, /* {{{ */
139                    const rrdcreate_config_t *cfg) {
140   char **rra_def;
141   int rra_num;
142
143   int *rts;
144   int rts_num;
145
146   int rra_max;
147
148   int cdp_num;
149   int cdp_len;
150
151   /* The stepsize we use here: If it is user-set, use it. If not, use the
152    * interval of the value-list. */
153   int ss;
154
155   if (cfg->rrarows <= 0) {
156     *ret = NULL;
157     return -1;
158   }
159
160   if ((cfg->xff < 0) || (cfg->xff >= 1.0)) {
161     *ret = NULL;
162     return -1;
163   }
164
165   if (cfg->stepsize > 0)
166     ss = cfg->stepsize;
167   else
168     ss = (int)CDTIME_T_TO_TIME_T(vl->interval);
169   if (ss <= 0) {
170     *ret = NULL;
171     return -1;
172   }
173
174   /* Use the configured timespans or fall back to the built-in defaults */
175   if (cfg->timespans_num != 0) {
176     rts = cfg->timespans;
177     rts_num = cfg->timespans_num;
178   } else {
179     rts = rra_timespans;
180     rts_num = rra_timespans_num;
181   }
182
183   rra_max = rts_num * rra_types_num;
184   assert(rra_max > 0);
185
186   if ((rra_def = calloc(rra_max + 1, sizeof(*rra_def))) == NULL)
187     return -1;
188   rra_num = 0;
189
190   cdp_len = 0;
191   for (int i = 0; i < rts_num; i++) {
192     int span = rts[i];
193
194     if ((span / ss) < cfg->rrarows)
195       span = ss * cfg->rrarows;
196
197     if (cdp_len == 0)
198       cdp_len = 1;
199     else
200       cdp_len = (int)floor(((double)span) / ((double)(cfg->rrarows * ss)));
201
202     cdp_num = (int)ceil(((double)span) / ((double)(cdp_len * ss)));
203
204     for (int j = 0; j < rra_types_num; j++) {
205       char buffer[128];
206       int status;
207
208       if (rra_num >= rra_max)
209         break;
210
211       status = snprintf(buffer, sizeof(buffer), "RRA:%s:%.10f:%u:%u",
212                         rra_types[j], cfg->xff, cdp_len, cdp_num);
213
214       if ((status < 0) || ((size_t)status >= sizeof(buffer))) {
215         ERROR("rra_get: Buffer would have been truncated.");
216         continue;
217       }
218
219       rra_def[rra_num++] = sstrdup(buffer);
220     }
221   }
222
223   if (rra_num <= 0) {
224     sfree(rra_def);
225     return 0;
226   }
227
228   *ret = rra_def;
229   return rra_num;
230 } /* }}} int rra_get */
231
232 static void ds_free(int ds_num, char **ds_def) /* {{{ */
233 {
234   for (int i = 0; i < ds_num; i++)
235     if (ds_def[i] != NULL)
236       free(ds_def[i]);
237   free(ds_def);
238 } /* }}} void ds_free */
239
240 static int ds_get(char ***ret, /* {{{ */
241                   const data_set_t *ds, const value_list_t *vl,
242                   const rrdcreate_config_t *cfg) {
243   char **ds_def;
244   size_t ds_num;
245
246   char min[32];
247   char max[32];
248   char buffer[128];
249
250   assert(ds->ds_num > 0);
251
252   ds_def = calloc(ds->ds_num, sizeof(*ds_def));
253   if (ds_def == NULL) {
254     char errbuf[1024];
255     ERROR("rrdtool plugin: calloc failed: %s",
256           sstrerror(errno, errbuf, sizeof(errbuf)));
257     return -1;
258   }
259
260   for (ds_num = 0; ds_num < ds->ds_num; ds_num++) {
261     data_source_t *d = ds->ds + ds_num;
262     const char *type;
263     int status;
264
265     ds_def[ds_num] = NULL;
266
267     if (d->type == DS_TYPE_COUNTER)
268       type = "COUNTER";
269     else if (d->type == DS_TYPE_GAUGE)
270       type = "GAUGE";
271     else if (d->type == DS_TYPE_DERIVE)
272       type = "DERIVE";
273     else if (d->type == DS_TYPE_ABSOLUTE)
274       type = "ABSOLUTE";
275     else {
276       ERROR("rrdtool plugin: Unknown DS type: %i", d->type);
277       break;
278     }
279
280     if (isnan(d->min)) {
281       sstrncpy(min, "U", sizeof(min));
282     } else
283       snprintf(min, sizeof(min), "%f", d->min);
284
285     if (isnan(d->max)) {
286       sstrncpy(max, "U", sizeof(max));
287     } else
288       snprintf(max, sizeof(max), "%f", d->max);
289
290     status = snprintf(
291         buffer, sizeof(buffer), "DS:%s:%s:%i:%s:%s", d->name, type,
292         (cfg->heartbeat > 0) ? cfg->heartbeat
293                              : (int)CDTIME_T_TO_TIME_T(2 * vl->interval),
294         min, max);
295     if ((status < 1) || ((size_t)status >= sizeof(buffer)))
296       break;
297
298     ds_def[ds_num] = sstrdup(buffer);
299   } /* for ds_num = 0 .. ds->ds_num */
300
301   if (ds_num != ds->ds_num) {
302     ds_free(ds_num, ds_def);
303     return -1;
304   }
305
306   if (ds_num == 0) {
307     sfree(ds_def);
308     return 0;
309   }
310
311   *ret = ds_def;
312   return ds_num;
313 } /* }}} int ds_get */
314
315 #if HAVE_THREADSAFE_LIBRRD
316 static int srrd_create(const char *filename, /* {{{ */
317                        unsigned long pdp_step, time_t last_up, int argc,
318                        const char **argv) {
319   int status;
320   char *filename_copy;
321
322   if ((filename == NULL) || (argv == NULL))
323     return -EINVAL;
324
325   /* Some versions of librrd don't have the `const' qualifier for the first
326    * argument, so we have to copy the pointer here to avoid warnings. It sucks,
327    * but what else can we do? :(  -octo */
328   filename_copy = strdup(filename);
329   if (filename_copy == NULL) {
330     ERROR("srrd_create: strdup failed.");
331     return -ENOMEM;
332   }
333
334   optind = 0; /* bug in librrd? */
335   rrd_clear_error();
336
337   status = rrd_create_r(filename_copy, pdp_step, last_up, argc, (void *)argv);
338
339   if (status != 0) {
340     WARNING("rrdtool plugin: rrd_create_r (%s) failed: %s", filename,
341             rrd_get_error());
342   }
343
344   sfree(filename_copy);
345
346   return status;
347 } /* }}} int srrd_create */
348 /* #endif HAVE_THREADSAFE_LIBRRD */
349
350 #else  /* !HAVE_THREADSAFE_LIBRRD */
351 static int srrd_create(const char *filename, /* {{{ */
352                        unsigned long pdp_step, time_t last_up, int argc,
353                        const char **argv) {
354   int status;
355
356   int new_argc;
357   char **new_argv;
358
359   char pdp_step_str[16];
360   char last_up_str[16];
361
362   new_argc = 6 + argc;
363   new_argv = malloc((new_argc + 1) * sizeof(*new_argv));
364   if (new_argv == NULL) {
365     ERROR("rrdtool plugin: malloc failed.");
366     return -1;
367   }
368
369   if (last_up == 0)
370     last_up = time(NULL) - 10;
371
372   snprintf(pdp_step_str, sizeof(pdp_step_str), "%lu", pdp_step);
373   snprintf(last_up_str, sizeof(last_up_str), "%lu", (unsigned long)last_up);
374
375   new_argv[0] = "create";
376   new_argv[1] = (void *)filename;
377   new_argv[2] = "-s";
378   new_argv[3] = pdp_step_str;
379   new_argv[4] = "-b";
380   new_argv[5] = last_up_str;
381
382   memcpy(new_argv + 6, argv, argc * sizeof(char *));
383   new_argv[new_argc] = NULL;
384
385   pthread_mutex_lock(&librrd_lock);
386   optind = 0; /* bug in librrd? */
387   rrd_clear_error();
388
389   status = rrd_create(new_argc, new_argv);
390   pthread_mutex_unlock(&librrd_lock);
391
392   if (status != 0) {
393     WARNING("rrdtool plugin: rrd_create (%s) failed: %s", filename,
394             rrd_get_error());
395   }
396
397   sfree(new_argv);
398
399   return status;
400 } /* }}} int srrd_create */
401 #endif /* !HAVE_THREADSAFE_LIBRRD */
402
403 static int lock_file(char const *filename) /* {{{ */
404 {
405   async_create_file_t *ptr;
406   struct stat sb;
407   int status;
408
409   pthread_mutex_lock(&async_creation_lock);
410
411   for (ptr = async_creation_list; ptr != NULL; ptr = ptr->next)
412     if (strcmp(filename, ptr->filename) == 0)
413       break;
414
415   if (ptr != NULL) {
416     pthread_mutex_unlock(&async_creation_lock);
417     return EEXIST;
418   }
419
420   status = stat(filename, &sb);
421   if ((status == 0) || (errno != ENOENT)) {
422     pthread_mutex_unlock(&async_creation_lock);
423     return EEXIST;
424   }
425
426   ptr = malloc(sizeof(*ptr));
427   if (ptr == NULL) {
428     pthread_mutex_unlock(&async_creation_lock);
429     return ENOMEM;
430   }
431
432   ptr->filename = strdup(filename);
433   if (ptr->filename == NULL) {
434     pthread_mutex_unlock(&async_creation_lock);
435     sfree(ptr);
436     return ENOMEM;
437   }
438
439   ptr->next = async_creation_list;
440   async_creation_list = ptr;
441
442   pthread_mutex_unlock(&async_creation_lock);
443
444   return 0;
445 } /* }}} int lock_file */
446
447 static int unlock_file(char const *filename) /* {{{ */
448 {
449   async_create_file_t *this;
450   async_create_file_t *prev;
451
452   pthread_mutex_lock(&async_creation_lock);
453
454   prev = NULL;
455   for (this = async_creation_list; this != NULL; this = this->next) {
456     if (strcmp(filename, this->filename) == 0)
457       break;
458     prev = this;
459   }
460
461   if (this == NULL) {
462     pthread_mutex_unlock(&async_creation_lock);
463     return ENOENT;
464   }
465
466   if (prev == NULL) {
467     assert(this == async_creation_list);
468     async_creation_list = this->next;
469   } else {
470     assert(this == prev->next);
471     prev->next = this->next;
472   }
473   this->next = NULL;
474
475   pthread_mutex_unlock(&async_creation_lock);
476
477   sfree(this->filename);
478   sfree(this);
479
480   return 0;
481 } /* }}} int unlock_file */
482
483 static void *srrd_create_thread(void *targs) /* {{{ */
484 {
485   srrd_create_args_t *args = targs;
486   char tmpfile[PATH_MAX];
487   int status;
488
489   status = lock_file(args->filename);
490   if (status != 0) {
491     if (status == EEXIST)
492       NOTICE("srrd_create_thread: File \"%s\" is already being created.",
493              args->filename);
494     else
495       ERROR("srrd_create_thread: Unable to lock file \"%s\".", args->filename);
496     srrd_create_args_destroy(args);
497     return 0;
498   }
499
500   snprintf(tmpfile, sizeof(tmpfile), "%s.async", args->filename);
501
502   status = srrd_create(tmpfile, args->pdp_step, args->last_up, args->argc,
503                        (void *)args->argv);
504   if (status != 0) {
505     WARNING("srrd_create_thread: srrd_create (%s) returned status %i.",
506             args->filename, status);
507     unlink(tmpfile);
508     unlock_file(args->filename);
509     srrd_create_args_destroy(args);
510     return 0;
511   }
512
513   status = rename(tmpfile, args->filename);
514   if (status != 0) {
515     char errbuf[1024];
516     ERROR("srrd_create_thread: rename (\"%s\", \"%s\") failed: %s", tmpfile,
517           args->filename, sstrerror(errno, errbuf, sizeof(errbuf)));
518     unlink(tmpfile);
519     unlock_file(args->filename);
520     srrd_create_args_destroy(args);
521     return 0;
522   }
523
524   DEBUG("srrd_create_thread: Successfully created RRD file \"%s\".",
525         args->filename);
526
527   unlock_file(args->filename);
528   srrd_create_args_destroy(args);
529
530   return 0;
531 } /* }}} void *srrd_create_thread */
532
533 static int srrd_create_async(const char *filename, /* {{{ */
534                              unsigned long pdp_step, time_t last_up, int argc,
535                              const char **argv) {
536   srrd_create_args_t *args;
537   pthread_t thread;
538   pthread_attr_t attr;
539   int status;
540
541   DEBUG("srrd_create_async: Creating \"%s\" in the background.", filename);
542
543   args = srrd_create_args_create(filename, pdp_step, last_up, argc, argv);
544   if (args == NULL)
545     return -1;
546
547   status = pthread_attr_init(&attr);
548   if (status != 0) {
549     srrd_create_args_destroy(args);
550     return -1;
551   }
552
553   status = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
554   if (status != 0) {
555     pthread_attr_destroy(&attr);
556     srrd_create_args_destroy(args);
557     return -1;
558   }
559
560   status = pthread_create(&thread, &attr, srrd_create_thread, args);
561   if (status != 0) {
562     char errbuf[1024];
563     ERROR("srrd_create_async: pthread_create failed: %s",
564           sstrerror(status, errbuf, sizeof(errbuf)));
565     pthread_attr_destroy(&attr);
566     srrd_create_args_destroy(args);
567     return status;
568   }
569
570   pthread_attr_destroy(&attr);
571   /* args is freed in srrd_create_thread(). */
572   return 0;
573 } /* }}} int srrd_create_async */
574
575 /*
576  * Public functions
577  */
578 int cu_rrd_create_file(const char *filename, /* {{{ */
579                        const data_set_t *ds, const value_list_t *vl,
580                        const rrdcreate_config_t *cfg) {
581   char **argv;
582   int argc;
583   char **rra_def = NULL;
584   int rra_num;
585   char **ds_def = NULL;
586   int ds_num;
587   int status = 0;
588   time_t last_up;
589   unsigned long stepsize;
590
591   if (check_create_dir(filename))
592     return -1;
593
594   if ((rra_num = rra_get(&rra_def, vl, cfg)) < 1) {
595     ERROR("cu_rrd_create_file failed: Could not calculate RRAs");
596     return -1;
597   }
598
599   if ((ds_num = ds_get(&ds_def, ds, vl, cfg)) < 1) {
600     ERROR("cu_rrd_create_file failed: Could not calculate DSes");
601     rra_free(rra_num, rra_def);
602     return -1;
603   }
604
605   argc = ds_num + rra_num;
606
607   if ((argv = malloc(sizeof(*argv) * (argc + 1))) == NULL) {
608     char errbuf[1024];
609     ERROR("cu_rrd_create_file failed: %s",
610           sstrerror(errno, errbuf, sizeof(errbuf)));
611     rra_free(rra_num, rra_def);
612     ds_free(ds_num, ds_def);
613     return -1;
614   }
615
616   memcpy(argv, ds_def, ds_num * sizeof(char *));
617   memcpy(argv + ds_num, rra_def, rra_num * sizeof(char *));
618   argv[ds_num + rra_num] = NULL;
619
620   last_up = CDTIME_T_TO_TIME_T(vl->time);
621   if (last_up <= 0)
622     last_up = time(NULL);
623   last_up -= 1;
624
625   if (cfg->stepsize > 0)
626     stepsize = cfg->stepsize;
627   else
628     stepsize = (unsigned long)CDTIME_T_TO_TIME_T(vl->interval);
629
630   if (cfg->async) {
631     status = srrd_create_async(filename, stepsize, last_up, argc,
632                                (const char **)argv);
633     if (status != 0)
634       WARNING("cu_rrd_create_file: srrd_create_async (%s) "
635               "returned status %i.",
636               filename, status);
637   } else /* synchronous */
638   {
639     status = lock_file(filename);
640     if (status != 0) {
641       if (status == EEXIST)
642         NOTICE("cu_rrd_create_file: File \"%s\" is already being created.",
643                filename);
644       else
645         ERROR("cu_rrd_create_file: Unable to lock file \"%s\".", filename);
646     } else {
647       status =
648           srrd_create(filename, stepsize, last_up, argc, (const char **)argv);
649
650       if (status != 0) {
651         WARNING("cu_rrd_create_file: srrd_create (%s) returned status %i.",
652                 filename, status);
653       } else {
654         DEBUG("cu_rrd_create_file: Successfully created RRD file \"%s\".",
655               filename);
656       }
657       unlock_file(filename);
658     }
659   }
660
661   free(argv);
662   ds_free(ds_num, ds_def);
663   rra_free(rra_num, rra_def);
664
665   return status;
666 } /* }}} int cu_rrd_create_file */