X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=src%2Futils_rrdcreate.c;h=220446a568a41551075f73451ec2392e173a9829;hb=3812f29af0b4ae25d1e0114ee0afc4a83880e913;hp=e6a2786033abd568c36cebfe1e303593f70f09c1;hpb=0356eb4e9284425d61c63ea0c2004b8a6e2f5d45;p=collectd.git diff --git a/src/utils_rrdcreate.c b/src/utils_rrdcreate.c index e6a27860..220446a5 100644 --- a/src/utils_rrdcreate.c +++ b/src/utils_rrdcreate.c @@ -2,18 +2,23 @@ * collectd - src/utils_rrdcreate.c * Copyright (C) 2006-2013 Florian octo Forster * - * This program is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License as published by the - * Free Software Foundation; only version 2 of the License is applicable. + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: * - * This program is distributed in the hope that it will be useful, but - * WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * General Public License for more details. + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. * - * You should have received a copy of the GNU General Public License along - * with this program; if not, write to the Free Software Foundation, Inc., - * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. * * Authors: * Florian octo Forster @@ -36,6 +41,14 @@ struct srrd_create_args_s }; typedef struct srrd_create_args_s srrd_create_args_t; +struct async_create_file_s; +typedef struct async_create_file_s async_create_file_t; +struct async_create_file_s +{ + char *filename; + async_create_file_t *next; +}; + /* * Private variables */ @@ -61,6 +74,9 @@ static int rra_types_num = STATIC_ARRAY_SIZE (rra_types); static pthread_mutex_t librrd_lock = PTHREAD_MUTEX_INITIALIZER; #endif +static async_create_file_t *async_creation_list = NULL; +static pthread_mutex_t async_creation_lock = PTHREAD_MUTEX_INITIALIZER; + /* * Private functions */ @@ -88,6 +104,7 @@ static void srrd_create_args_destroy (srrd_create_args_t *args) sfree (args->argv[i]); sfree (args->argv); } + sfree (args); } /* void srrd_create_args_destroy */ static srrd_create_args_t *srrd_create_args_create (const char *filename, @@ -434,24 +451,146 @@ static int srrd_create (const char *filename, /* {{{ */ } /* }}} int srrd_create */ #endif /* !HAVE_THREADSAFE_LIBRRD */ +static int lock_file (char const *filename) /* {{{ */ +{ + async_create_file_t *ptr; + struct stat sb; + int status; + + pthread_mutex_lock (&async_creation_lock); + + for (ptr = async_creation_list; ptr != NULL; ptr = ptr->next) + if (strcmp (filename, ptr->filename) == 0) + break; + + if (ptr != NULL) + { + pthread_mutex_unlock (&async_creation_lock); + return (EEXIST); + } + + status = stat (filename, &sb); + if ((status == 0) || (errno != ENOENT)) + { + pthread_mutex_unlock (&async_creation_lock); + return (EEXIST); + } + + ptr = malloc (sizeof (*ptr)); + if (ptr == NULL) + { + pthread_mutex_unlock (&async_creation_lock); + return (ENOMEM); + } + + ptr->filename = strdup (filename); + if (ptr->filename == NULL) + { + pthread_mutex_unlock (&async_creation_lock); + sfree (ptr); + return (ENOMEM); + } + + ptr->next = async_creation_list; + async_creation_list = ptr; + + pthread_mutex_unlock (&async_creation_lock); + + return (0); +} /* }}} int lock_file */ + +static int unlock_file (char const *filename) /* {{{ */ +{ + async_create_file_t *this; + async_create_file_t *prev; + + + pthread_mutex_lock (&async_creation_lock); + + prev = NULL; + for (this = async_creation_list; this != NULL; this = this->next) + { + if (strcmp (filename, this->filename) == 0) + break; + prev = this; + } + + if (this == NULL) + { + pthread_mutex_unlock (&async_creation_lock); + return (ENOENT); + } + + if (prev == NULL) + { + assert (this == async_creation_list); + async_creation_list = this->next; + } + else + { + assert (this == prev->next); + prev->next = this->next; + } + this->next = NULL; + + pthread_mutex_unlock (&async_creation_lock); + + sfree (this->filename); + sfree (this); + + return (0); +} /* }}} int unlock_file */ + static void *srrd_create_thread (void *targs) /* {{{ */ { srrd_create_args_t *args = targs; + char tmpfile[PATH_MAX]; int status; - status = srrd_create (args->filename, args->pdp_step, args->last_up, + status = lock_file (args->filename); + if (status != 0) + { + if (status == EEXIST) + NOTICE ("srrd_create_thread: File \"%s\" is already being created.", + args->filename); + else + ERROR ("srrd_create_thread: Unable to lock file \"%s\".", + args->filename); + srrd_create_args_destroy (args); + return (0); + } + + ssnprintf (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); + unlink (tmpfile); + unlock_file (args->filename); + srrd_create_args_destroy (args); + return (0); } - else + + status = rename (tmpfile, args->filename); + if (status != 0) { - DEBUG ("srrd_create_thread: Successfully created RRD file \"%s\".", - args->filename); + char errbuf[1024]; + ERROR ("srrd_create_thread: rename (\"%s\", \"%s\") failed: %s", + tmpfile, args->filename, + sstrerror (errno, errbuf, sizeof (errbuf))); + unlink (tmpfile); + unlock_file (args->filename); + srrd_create_args_destroy (args); + return (0); } + DEBUG ("srrd_create_thread: Successfully created RRD file \"%s\".", + args->filename); + + unlock_file (args->filename); srrd_create_args_destroy (args); return (0); @@ -466,6 +605,8 @@ static int srrd_create_async (const char *filename, /* {{{ */ pthread_attr_t attr; int status; + DEBUG ("srrd_create_async: Creating \"%s\" in the background.", filename); + args = srrd_create_args_create (filename, pdp_step, last_up, argc, argv); if (args == NULL) return (-1); @@ -568,18 +709,32 @@ int cu_rrd_create_file (const char *filename, /* {{{ */ } else /* synchronous */ { - status = srrd_create (filename, stepsize, last_up, - argc, (const char **) argv); - + status = lock_file (filename); if (status != 0) { - WARNING ("cu_rrd_create_file: srrd_create (%s) returned status %i.", - filename, status); + if (status == EEXIST) + NOTICE ("cu_rrd_create_file: File \"%s\" is already being created.", + filename); + else + ERROR ("cu_rrd_create_file: Unable to lock file \"%s\".", + filename); } else { - DEBUG ("cu_rrd_create_file: Successfully created RRD file \"%s\".", - filename); + 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); + } + else + { + DEBUG ("cu_rrd_create_file: Successfully created RRD file \"%s\".", + filename); + } + unlock_file (filename); } }