Signed-off-by: Oleg Vasilev <oleg.vasilev(a)virtuozzo.com&gt; --- src/logging/log_handler.c | 26 -------------------------- src/logging/log_handler.h | 31 ++++++++++++++++++++++++++++--- 2 files changed, 28 insertions(+), 29 deletions(-) diff --git a/src/logging/log_handler.c b/src/logging/log_handler.c index 7342404b00..8fc7e9b2a8 100644 --- a/src/logging/log_handler.c +++ b/src/logging/log_handler.c @@ -22,11 +22,9 @@ #include "log_handler.h" #include "virerror.h" -#include "virobject.h" #include "virfile.h" #include "viralloc.h" #include "virlog.h" -#include "virrotatingfile.h" #include "viruuid.h" #include "virutil.h" @@ -42,30 +40,6 @@ VIR_LOG_INIT("logging.log_handler"); #define DEFAULT_MODE 0600 -typedef struct _virLogHandlerLogFile virLogHandlerLogFile; -struct _virLogHandlerLogFile { - virRotatingFileWriter *file; - int watch; - int pipefd; /* Read from QEMU via this */ - bool drained; - - char *driver; - unsigned char domuuid[VIR_UUID_BUFLEN]; - char *domname; -}; - -struct _virLogHandler { - virObjectLockable parent; - - bool privileged; - virLogDaemonConfig *config; - - virLogHandlerLogFile **files; - size_t nfiles; - - virLogHandlerShutdownInhibitor inhibitor; - void *opaque; -}; static virClass *virLogHandlerClass; static void virLogHandlerDispose(void *obj); diff --git a/src/logging/log_handler.h b/src/logging/log_handler.h index c9af033cd3..d473a19fc6 100644 --- a/src/logging/log_handler.h +++ b/src/logging/log_handler.h @@ -23,13 +23,38 @@ #include "internal.h" #include "virjson.h" #include "log_daemon_config.h" - -typedef struct _virLogHandler virLogHandler; - +#include "virobject.h" +#include "virrotatingfile.h" typedef void (*virLogHandlerShutdownInhibitor)(bool inhibit, void *opaque); +typedef struct _virLogHandlerLogFile virLogHandlerLogFile; +struct _virLogHandlerLogFile { + virRotatingFileWriter *file; + int watch; + int pipefd; /* Read from QEMU via this */ + bool drained; + + char *driver; + unsigned char domuuid[VIR_UUID_BUFLEN]; + char *domname; +}; + +typedef struct _virLogHandler virLogHandler; +struct _virLogHandler { + virObjectLockable parent; + + bool privileged; + virLogDaemonConfig *config; + + virLogHandlerLogFile **files; + size_t nfiles; + + virLogHandlerShutdownInhibitor inhibitor; + void *opaque; +}; + virLogHandler *virLogHandlerNew(bool privileged, virLogDaemonConfig *config, virLogHandlerShutdownInhibitor inhibitor, -- 2.39.1

Before, logs from deleted machines have been piling up, since there were no garbage collection mechanism. Now, virtlogd can be configured to periodically scan the log folder for orphan logs with no recent modifications and delete it. A single chain of recent and rotated logs is deleted in a single transaction. Signed-off-by: Oleg Vasilev <oleg.vasilev(a)virtuozzo.com&gt; --- po/POTFILES | 1 + src/logging/log_cleaner.c | 268 ++++++++++++++++++++++++++++++++++++++ src/logging/log_cleaner.h | 29 +++++ src/logging/log_handler.h | 2 + src/logging/meson.build | 1 + 5 files changed, 301 insertions(+) create mode 100644 src/logging/log_cleaner.c create mode 100644 src/logging/log_cleaner.h diff --git a/po/POTFILES b/po/POTFILES index 169e2a41dc..2fb6d18e27 100644 --- a/po/POTFILES +++ b/po/POTFILES @@ -123,6 +123,7 @@ src/locking/lock_driver_lockd.c src/locking/lock_driver_sanlock.c src/locking/lock_manager.c src/locking/sanlock_helper.c +src/logging/log_cleaner.c src/logging/log_daemon.c src/logging/log_daemon_dispatch.c src/logging/log_handler.c diff --git a/src/logging/log_cleaner.c b/src/logging/log_cleaner.c new file mode 100644 index 0000000000..3de54d0795 --- /dev/null +++ b/src/logging/log_cleaner.c @@ -0,0 +1,268 @@ +/* + * log_cleaner.c: cleans obsolete log files + * + * Copyright (C) 2022 Virtuozzo International GmbH + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; If not, see + * <http://www.gnu.org/licenses/>;. + */ + +#include <config.h> + +#include "log_cleaner.h" +#include "log_handler.h" + +#include "virerror.h" +#include "virobject.h" +#include "virfile.h" +#include "viralloc.h" +#include "virlog.h" +#include "virrotatingfile.h" +#include "virstring.h" + +#define VIR_FROM_THIS VIR_FROM_LOGGING + +VIR_LOG_INIT("logging.log_cleaner"); + +/* Cleanup log root (/var/log/libvirt) and all subfolders (e.g. /var/log/libvirt/qemu) */ +#define CLEANER_LOG_DEPTH 1 +#define CLEANER_LOG_TIMEOUT_MS (24 * 3600 * 1000) /* One day */ +#define MAX_TIME ((time_t) G_MAXINT64) + +static GRegex *log_regex; + +typedef struct _virLogCleanerChain virLogCleanerChain; +struct _virLogCleanerChain { + int rotated_max_index; + time_t last_modified; +}; + +typedef struct _virLogCleanerData virLogCleanerData; +struct _virLogCleanerData { + virLogHandler *handler; + time_t oldest_to_keep; + GHashTable *chains; +}; + +static const char* +virLogCleanerParseFilename(const char *path, + int *rotated_index) +{ + g_autoptr(GMatchInfo) matchInfo = NULL; + g_autofree const char *rotated_index_str = NULL; + g_autofree const char *clear_path = NULL; + const char *chain_prefix = NULL; + + clear_path = realpath(path, NULL); + if (!clear_path) { + VIR_WARN("Failed to resolve path %s: %s", path, g_strerror(errno)); + return NULL; + } + + if (!g_regex_match(log_regex, path, 0, &matchInfo)) + return NULL; + + chain_prefix = g_match_info_fetch(matchInfo, 1); + if (!rotated_index) + return chain_prefix; + + *rotated_index = 0; + rotated_index_str = g_match_info_fetch(matchInfo, 3); + + if (!rotated_index_str) + return chain_prefix; + + if (virStrToLong_i(rotated_index_str, NULL, 10, rotated_index) < 0) { + virReportError(VIR_ERR_INTERNAL_ERROR, + _("Failed to parse rotated index from '%s'"), + rotated_index_str); + return NULL; + } + return chain_prefix; +} + +static void +virLogCleanerProcessFile(virLogCleanerData *data, + const char *path, + struct stat *sb) +{ + int rotated_index = 0; + g_autofree const char *chain_prefix = NULL; + virLogCleanerChain *chain; + + if (!S_ISREG(sb->st_mode)) + return; + + chain_prefix = virLogCleanerParseFilename(path, &rotated_index); + + if (!chain_prefix) + return; + + if (rotated_index > data->handler->config->max_backups) { + if (unlink(path) < 0) { + VIR_WARN("Unable to delete %s: %s", path, g_strerror(errno)); + } + return; + } + + chain = g_hash_table_lookup(data->chains, chain_prefix); + + if (!chain) { + chain = g_new0(virLogCleanerChain, 1); + g_hash_table_insert(data->chains, g_steal_pointer((gpointer*) &chain_prefix), chain); + } + + chain->last_modified = MAX(chain->last_modified, sb->st_mtime); + chain->rotated_max_index = MAX(chain->rotated_max_index, + rotated_index); +} + +static GHashTable* +virLogCleanerCreateTable(virLogHandler *handler) +{ + /* HashTable: (const char*) chain_prefix -> (virLogCleanerChain*) chain */ + GHashTable *chains = g_hash_table_new_full(g_str_hash, g_str_equal, + g_free, g_free); + size_t i; + virLogHandlerLogFile *file; + const char *chain_prefix; + virLogCleanerChain *chain; + VIR_LOCK_GUARD lock = virObjectLockGuard(handler); + + for (i = 0; i < handler->nfiles; i++) { + file = handler->files[i]; + chain_prefix = virLogCleanerParseFilename(virRotatingFileWriterGetPath(file->file), + NULL); + if (!chain_prefix) + continue; + + chain = g_new0(virLogCleanerChain, 1); + chain->last_modified = MAX_TIME; /* Here we set MAX_TIME to the currently + * opened files to prevent its deletion. */ + g_hash_table_insert(chains, (void *) chain_prefix, chain); + } + + return chains; +} + +static void +virLogCleanerProcessFolder(virLogCleanerData *data, + const char *path, + int depth_left) +{ + DIR *dir; + struct dirent *entry; + struct stat sb; + + if (virDirOpenIfExists(&dir, path) < 0) + return; + + while (virDirRead(dir, &entry, path) > 0) { + g_autofree char *newpath = NULL; + + newpath = g_strdup_printf("%s/%s", path, entry->d_name); + + if (stat(newpath, &sb) < 0) { + VIR_WARN("Unable to stat %s: %s", newpath, g_strerror(errno)); + continue; + } + + if (S_ISDIR(sb.st_mode)) { + if (depth_left > 0) + virLogCleanerProcessFolder(data, newpath, depth_left - 1); + continue; + } + + virLogCleanerProcessFile(data, newpath, &sb); + } + + virDirClose(dir); +} + +static void +virLogCleanerDeleteFile(char *path) +{ + int rc; + if ((rc = unlink(path)) < 0 && errno != ENOENT) + VIR_WARN("Unable to delete %s: %s", path, g_strerror(errno)); + VIR_FREE(path); +} + +static void +virLogCleanerChainCB(gpointer key, + gpointer value, + gpointer user_data) +{ + const char* chain_prefix = key; + virLogCleanerChain* chain = value; + virLogCleanerData* data = user_data; + size_t i; + + if (chain->last_modified > data->oldest_to_keep) + return; + + virLogCleanerDeleteFile(g_strdup_printf("%s.log", chain_prefix)); + + for (i = 0; i <= chain->rotated_max_index; i++) + virLogCleanerDeleteFile(g_strdup_printf("%s.log.%ld", chain_prefix, i)); +} + +static void +virLogCleanerTimer(int timer G_GNUC_UNUSED, void *opaque) +{ + virLogHandler *handler = opaque; + virLogCleanerData data = { + .handler = handler, + .oldest_to_keep = time(NULL) - 3600 * 24 * handler->config->max_age_days, + .chains = virLogCleanerCreateTable(handler), + }; + + /* First prepare the hashmap of chains to delete */ + virLogCleanerProcessFolder(&data, + handler->config->log_root, + CLEANER_LOG_DEPTH); + g_hash_table_foreach(data.chains, virLogCleanerChainCB, &data); + g_hash_table_destroy(data.chains); +} + +int +virLogCleanerInit(virLogHandler *handler) +{ + if (handler->config->max_age_days <= 0) + return 0; + + log_regex = g_regex_new("^(.*)\\.log(\\.(\\d+))?$", 0, 0, NULL); + if (!log_regex) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("Unable to compile regex")); + return -1; + } + + handler->cleanup_log_timer = virEventAddTimeout(CLEANER_LOG_TIMEOUT_MS, + virLogCleanerTimer, + handler, NULL); + return handler->cleanup_log_timer; +} + +void +virLogCleanerShutdown(virLogHandler *handler) +{ + if (handler->cleanup_log_timer != -1) { + virEventRemoveTimeout(handler->cleanup_log_timer); + handler->cleanup_log_timer = -1; + } + + g_regex_unref(log_regex); + log_regex = NULL; +} diff --git a/src/logging/log_cleaner.h b/src/logging/log_cleaner.h new file mode 100644 index 0000000000..1a9a94b68d --- /dev/null +++ b/src/logging/log_cleaner.h @@ -0,0 +1,29 @@ +/* + * log_cleaner.h: cleans obsolete log files + * + * Copyright (C) 2022 Virtuozzo International GmbH + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; If not, see + * <http://www.gnu.org/licenses/>;. + */ + +#pragma once + +#include "log_handler.h" + +int +virLogCleanerInit(virLogHandler *handler); + +void +virLogCleanerShutdown(virLogHandler *handler); diff --git a/src/logging/log_handler.h b/src/logging/log_handler.h index d473a19fc6..97dad27eda 100644 --- a/src/logging/log_handler.h +++ b/src/logging/log_handler.h @@ -48,6 +48,8 @@ struct _virLogHandler { bool privileged; virLogDaemonConfig *config; + int cleanup_log_timer; + virLogHandlerLogFile **files; size_t nfiles; diff --git a/src/logging/meson.build b/src/logging/meson.build index 7066f16fad..fa6af50fa6 100644 --- a/src/logging/meson.build +++ b/src/logging/meson.build @@ -30,6 +30,7 @@ log_daemon_sources = files( 'log_daemon_config.c', 'log_daemon_dispatch.c', 'log_handler.c', + 'log_cleaner.c', ) if conf.has('WITH_REMOTE') -- 2.39.1

On 03.02.2023 19:45, Martin Kletzander wrote: Just to educate myself, why are these not const? These are only set and not changed. There is of course the issue with type erasure, which requires the cast, but that I consider the limitation of GHashTable API. Or should I never attempt to put a const value into a type-erased void*? Also, I see a number of tasks failed in a pipeline because of missing unlink definition. Probably I forgot #include <unistd.h>. Should have I tested the patch somehow else before submitting, apart from running test on the machine I had at hand, e.g., have my own GitLab pipeline setup? Thanks, Oleg

On Mon, Feb 06, 2023 at 01:26:09PM +0600, Oleg Vasilev wrote: They are allocated and free'd. It's definitely beneficial to test this. There are various ways, we have documented here: https://libvirt.org/testing.html I pushed it upstream.