static pthread_mutex_t librrd_lock = PTHREAD_MUTEX_INITIALIZER;
#endif
-static async_create_file_t *async_creation_list = NULL;
+static async_create_file_t *async_creation_list;
static pthread_mutex_t async_creation_lock = PTHREAD_MUTEX_INITIALIZER;
/*
args = calloc(1, sizeof(*args));
if (args == NULL) {
- ERROR("srrd_create_args_create: calloc failed.");
- return (NULL);
+ P_ERROR("srrd_create_args_create: calloc failed.");
+ return NULL;
}
args->filename = NULL;
args->pdp_step = pdp_step;
args->filename = strdup(filename);
if (args->filename == NULL) {
- ERROR("srrd_create_args_create: strdup failed.");
+ P_ERROR("srrd_create_args_create: strdup failed.");
srrd_create_args_destroy(args);
- return (NULL);
+ return NULL;
}
args->argv = calloc((size_t)(argc + 1), sizeof(*args->argv));
if (args->argv == NULL) {
- ERROR("srrd_create_args_create: calloc failed.");
+ P_ERROR("srrd_create_args_create: calloc failed.");
srrd_create_args_destroy(args);
- return (NULL);
+ return NULL;
}
for (args->argc = 0; args->argc < argc; args->argc++) {
args->argv[args->argc] = strdup(argv[args->argc]);
if (args->argv[args->argc] == NULL) {
- ERROR("srrd_create_args_create: strdup failed.");
+ P_ERROR("srrd_create_args_create: strdup failed.");
srrd_create_args_destroy(args);
- return (NULL);
+ return NULL;
}
}
assert(args->argc == argc);
args->argv[args->argc] = NULL;
- return (args);
+ return args;
} /* srrd_create_args_t *srrd_create_args_create */
/* * * * * * * * * *
if (cfg->rrarows <= 0) {
*ret = NULL;
- return (-1);
+ return -1;
}
if ((cfg->xff < 0) || (cfg->xff >= 1.0)) {
*ret = NULL;
- return (-1);
+ return -1;
}
if (cfg->stepsize > 0)
ss = (int)CDTIME_T_TO_TIME_T(vl->interval);
if (ss <= 0) {
*ret = NULL;
- return (-1);
+ return -1;
}
/* Use the configured timespans or fall back to the built-in defaults */
assert(rra_max > 0);
if ((rra_def = calloc(rra_max + 1, sizeof(*rra_def))) == NULL)
- return (-1);
+ return -1;
rra_num = 0;
cdp_len = 0;
if (rra_num >= rra_max)
break;
- status = ssnprintf(buffer, sizeof(buffer), "RRA:%s:%.10f:%u:%u",
- rra_types[j], cfg->xff, cdp_len, cdp_num);
+ status = snprintf(buffer, sizeof(buffer), "RRA:%s:%.10f:%u:%u",
+ rra_types[j], cfg->xff, cdp_len, cdp_num);
if ((status < 0) || ((size_t)status >= sizeof(buffer))) {
- ERROR("rra_get: Buffer would have been truncated.");
+ P_ERROR("rra_get: Buffer would have been truncated.");
continue;
}
if (rra_num <= 0) {
sfree(rra_def);
- return (0);
+ return 0;
}
*ret = rra_def;
- return (rra_num);
+ return rra_num;
} /* }}} int rra_get */
static void ds_free(int ds_num, char **ds_def) /* {{{ */
ds_def = calloc(ds->ds_num, sizeof(*ds_def));
if (ds_def == NULL) {
- char errbuf[1024];
- ERROR("rrdtool plugin: calloc failed: %s",
- sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ P_ERROR("ds_get: calloc failed: %s", STRERRNO);
+ return -1;
}
for (ds_num = 0; ds_num < ds->ds_num; ds_num++) {
else if (d->type == DS_TYPE_ABSOLUTE)
type = "ABSOLUTE";
else {
- ERROR("rrdtool plugin: Unknown DS type: %i", d->type);
+ P_ERROR("ds_get: Unknown DS type: %i", d->type);
break;
}
if (isnan(d->min)) {
sstrncpy(min, "U", sizeof(min));
} else
- ssnprintf(min, sizeof(min), "%f", d->min);
+ snprintf(min, sizeof(min), "%f", d->min);
if (isnan(d->max)) {
sstrncpy(max, "U", sizeof(max));
} else
- ssnprintf(max, sizeof(max), "%f", d->max);
+ snprintf(max, sizeof(max), "%f", d->max);
- status = ssnprintf(buffer, sizeof(buffer), "DS:%s:%s:%i:%s:%s", d->name,
- type, (cfg->heartbeat > 0)
- ? cfg->heartbeat
- : (int)CDTIME_T_TO_TIME_T(2 * vl->interval),
- min, max);
+ status = snprintf(
+ buffer, sizeof(buffer), "DS:%s:%s:%i:%s:%s", d->name, type,
+ (cfg->heartbeat > 0) ? cfg->heartbeat
+ : (int)CDTIME_T_TO_TIME_T(2 * vl->interval),
+ min, max);
if ((status < 1) || ((size_t)status >= sizeof(buffer)))
break;
if (ds_num != ds->ds_num) {
ds_free(ds_num, ds_def);
- return (-1);
+ return -1;
}
if (ds_num == 0) {
sfree(ds_def);
- return (0);
+ return 0;
}
*ret = ds_def;
- return (ds_num);
+ return ds_num;
} /* }}} int ds_get */
#if HAVE_THREADSAFE_LIBRRD
char *filename_copy;
if ((filename == NULL) || (argv == NULL))
- return (-EINVAL);
+ return -EINVAL;
/* Some versions of librrd don't have the `const' qualifier for the first
* argument, so we have to copy the pointer here to avoid warnings. It sucks,
filename_copy = strdup(filename);
if (filename_copy == NULL) {
ERROR("srrd_create: strdup failed.");
- return (-ENOMEM);
+ return -ENOMEM;
}
optind = 0; /* bug in librrd? */
status = rrd_create_r(filename_copy, pdp_step, last_up, argc, (void *)argv);
if (status != 0) {
- WARNING("rrdtool plugin: rrd_create_r (%s) failed: %s", filename,
- rrd_get_error());
+ P_WARNING("srrd_create: rrd_create_r (%s) failed: %s", filename,
+ rrd_get_error());
}
sfree(filename_copy);
- return (status);
+ return status;
} /* }}} int srrd_create */
/* #endif HAVE_THREADSAFE_LIBRRD */
new_argc = 6 + argc;
new_argv = malloc((new_argc + 1) * sizeof(*new_argv));
if (new_argv == NULL) {
- ERROR("rrdtool plugin: malloc failed.");
- return (-1);
+ P_ERROR("srrd_create: malloc failed.");
+ return -1;
}
if (last_up == 0)
last_up = time(NULL) - 10;
- ssnprintf(pdp_step_str, sizeof(pdp_step_str), "%lu", pdp_step);
- ssnprintf(last_up_str, sizeof(last_up_str), "%lu", (unsigned long)last_up);
+ snprintf(pdp_step_str, sizeof(pdp_step_str), "%lu", pdp_step);
+ snprintf(last_up_str, sizeof(last_up_str), "%lu", (unsigned long)last_up);
new_argv[0] = "create";
new_argv[1] = (void *)filename;
pthread_mutex_unlock(&librrd_lock);
if (status != 0) {
- WARNING("rrdtool plugin: rrd_create (%s) failed: %s", filename,
- rrd_get_error());
+ P_WARNING("srrd_create: rrd_create (%s) failed: %s", filename,
+ rrd_get_error());
}
sfree(new_argv);
- return (status);
+ return status;
} /* }}} int srrd_create */
#endif /* !HAVE_THREADSAFE_LIBRRD */
if (ptr != NULL) {
pthread_mutex_unlock(&async_creation_lock);
- return (EEXIST);
+ return EEXIST;
}
status = stat(filename, &sb);
if ((status == 0) || (errno != ENOENT)) {
pthread_mutex_unlock(&async_creation_lock);
- return (EEXIST);
+ return EEXIST;
}
ptr = malloc(sizeof(*ptr));
if (ptr == NULL) {
pthread_mutex_unlock(&async_creation_lock);
- return (ENOMEM);
+ return ENOMEM;
}
ptr->filename = strdup(filename);
if (ptr->filename == NULL) {
pthread_mutex_unlock(&async_creation_lock);
sfree(ptr);
- return (ENOMEM);
+ return ENOMEM;
}
ptr->next = async_creation_list;
pthread_mutex_unlock(&async_creation_lock);
- return (0);
+ return 0;
} /* }}} int lock_file */
static int unlock_file(char const *filename) /* {{{ */
if (this == NULL) {
pthread_mutex_unlock(&async_creation_lock);
- return (ENOENT);
+ return ENOENT;
}
if (prev == NULL) {
sfree(this->filename);
sfree(this);
- return (0);
+ return 0;
} /* }}} int unlock_file */
static void *srrd_create_thread(void *targs) /* {{{ */
status = lock_file(args->filename);
if (status != 0) {
if (status == EEXIST)
- NOTICE("srrd_create_thread: File \"%s\" is already being created.",
- args->filename);
+ P_NOTICE("srrd_create_thread: File \"%s\" is already being created.",
+ args->filename);
else
- ERROR("srrd_create_thread: Unable to lock file \"%s\".", args->filename);
+ P_ERROR("srrd_create_thread: Unable to lock file \"%s\".",
+ args->filename);
srrd_create_args_destroy(args);
- return (0);
+ return 0;
}
- ssnprintf(tmpfile, sizeof(tmpfile), "%s.async", args->filename);
+ snprintf(tmpfile, sizeof(tmpfile), "%s.async", args->filename);
status = srrd_create(tmpfile, args->pdp_step, args->last_up, args->argc,
(void *)args->argv);
if (status != 0) {
- WARNING("srrd_create_thread: srrd_create (%s) returned status %i.",
- args->filename, status);
+ P_WARNING("srrd_create_thread: srrd_create (%s) returned status %i.",
+ args->filename, status);
unlink(tmpfile);
unlock_file(args->filename);
srrd_create_args_destroy(args);
- return (0);
+ return 0;
}
status = rename(tmpfile, args->filename);
if (status != 0) {
- char errbuf[1024];
- ERROR("srrd_create_thread: rename (\"%s\", \"%s\") failed: %s", tmpfile,
- args->filename, sstrerror(errno, errbuf, sizeof(errbuf)));
+ P_ERROR("srrd_create_thread: rename (\"%s\", \"%s\") failed: %s", tmpfile,
+ args->filename, STRERRNO);
unlink(tmpfile);
unlock_file(args->filename);
srrd_create_args_destroy(args);
- return (0);
+ return 0;
}
DEBUG("srrd_create_thread: Successfully created RRD file \"%s\".",
unlock_file(args->filename);
srrd_create_args_destroy(args);
- return (0);
+ return 0;
} /* }}} void *srrd_create_thread */
static int srrd_create_async(const char *filename, /* {{{ */
args = srrd_create_args_create(filename, pdp_step, last_up, argc, argv);
if (args == NULL)
- return (-1);
+ return -1;
status = pthread_attr_init(&attr);
if (status != 0) {
srrd_create_args_destroy(args);
- return (-1);
+ return -1;
}
status = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
if (status != 0) {
pthread_attr_destroy(&attr);
srrd_create_args_destroy(args);
- return (-1);
+ return -1;
}
status = pthread_create(&thread, &attr, srrd_create_thread, args);
if (status != 0) {
- char errbuf[1024];
- ERROR("srrd_create_async: pthread_create failed: %s",
- sstrerror(status, errbuf, sizeof(errbuf)));
+ P_ERROR("srrd_create_async: pthread_create failed: %s", STRERROR(status));
pthread_attr_destroy(&attr);
srrd_create_args_destroy(args);
- return (status);
+ return status;
}
pthread_attr_destroy(&attr);
/* args is freed in srrd_create_thread(). */
- return (0);
+ return 0;
} /* }}} int srrd_create_async */
/*
unsigned long stepsize;
if (check_create_dir(filename))
- return (-1);
+ return -1;
if ((rra_num = rra_get(&rra_def, vl, cfg)) < 1) {
- ERROR("cu_rrd_create_file failed: Could not calculate RRAs");
- return (-1);
+ P_ERROR("cu_rrd_create_file failed: Could not calculate RRAs");
+ return -1;
}
if ((ds_num = ds_get(&ds_def, ds, vl, cfg)) < 1) {
- ERROR("cu_rrd_create_file failed: Could not calculate DSes");
+ P_ERROR("cu_rrd_create_file failed: Could not calculate DSes");
rra_free(rra_num, rra_def);
- return (-1);
+ return -1;
}
argc = ds_num + rra_num;
if ((argv = malloc(sizeof(*argv) * (argc + 1))) == NULL) {
- char errbuf[1024];
- ERROR("cu_rrd_create_file failed: %s",
- sstrerror(errno, errbuf, sizeof(errbuf)));
+ P_ERROR("cu_rrd_create_file failed: %s", STRERRNO);
rra_free(rra_num, rra_def);
ds_free(ds_num, ds_def);
- return (-1);
+ return -1;
}
memcpy(argv, ds_def, ds_num * sizeof(char *));
status = srrd_create_async(filename, stepsize, last_up, argc,
(const char **)argv);
if (status != 0)
- WARNING("cu_rrd_create_file: srrd_create_async (%s) "
- "returned status %i.",
- filename, status);
+ P_WARNING("cu_rrd_create_file: srrd_create_async (%s) "
+ "returned status %i.",
+ filename, status);
} else /* synchronous */
{
status = lock_file(filename);
if (status != 0) {
if (status == EEXIST)
- NOTICE("cu_rrd_create_file: File \"%s\" is already being created.",
- filename);
+ P_NOTICE("cu_rrd_create_file: File \"%s\" is already being created.",
+ filename);
else
- ERROR("cu_rrd_create_file: Unable to lock file \"%s\".", filename);
+ P_ERROR("cu_rrd_create_file: Unable to lock file \"%s\".", filename);
} else {
status =
srrd_create(filename, stepsize, last_up, argc, (const char **)argv);
if (status != 0) {
- WARNING("cu_rrd_create_file: srrd_create (%s) returned status %i.",
- filename, status);
+ P_WARNING("cu_rrd_create_file: srrd_create (%s) returned status %i.",
+ filename, status);
} else {
DEBUG("cu_rrd_create_file: Successfully created RRD file \"%s\".",
filename);
ds_free(ds_num, ds_def);
rra_free(rra_num, rra_def);
- return (status);
+ return status;
} /* }}} int cu_rrd_create_file */
projects / collectd.git / blobdiff