From 684f0aa648061a13e777153e297a7064ba33ea17 Mon Sep 17 00:00:00 2001 From: liuxu Date: Thu, 11 Apr 2024 11:00:44 +0800 Subject: [PATCH 66/69] cdi:support modules version/spec/spec_dirs/device --- .../modules/device/cdi/behavior/cdi_device.c | 100 +++++++- .../modules/device/cdi/behavior/cdi_device.h | 12 +- .../modules/device/cdi/behavior/cdi_spec.c | 220 ++++++++++++++++-- .../modules/device/cdi/behavior/cdi_spec.h | 16 +- .../device/cdi/behavior/cdi_spec_dirs.c | 80 +++++++ .../device/cdi/behavior/cdi_spec_dirs.h | 2 +- .../modules/device/cdi/behavior/cdi_version.c | 173 ++++++++++++-- .../modules/device/cdi/behavior/cdi_version.h | 1 - src/daemon/modules/device/cdi/cdi_cache.c | 37 +-- src/daemon/modules/device/cdi/cdi_cache.h | 1 + .../network/cni_operator/libcni/libcni_api.c | 98 +------- src/utils/cutils/utils_version.c | 147 ++++++++++++ src/utils/cutils/utils_version.h | 36 +++ 13 files changed, 748 insertions(+), 175 deletions(-) create mode 100644 src/utils/cutils/utils_version.c create mode 100644 src/utils/cutils/utils_version.h diff --git a/src/daemon/modules/device/cdi/behavior/cdi_device.c b/src/daemon/modules/device/cdi/behavior/cdi_device.c index 0fef8f42..aec3d7c0 100644 --- a/src/daemon/modules/device/cdi/behavior/cdi_device.c +++ b/src/daemon/modules/device/cdi/behavior/cdi_device.c @@ -14,27 +14,109 @@ ******************************************************************************/ #include "cdi_device.h" +#include +#include + +#include "error.h" +#include "cdi_parser.h" +#include "cdi_spec.h" + +static int cdi_device_validate(struct cdi_cache_device *d); + void free_cdi_cache_device(struct cdi_cache_device *d) { - (void)d; + if (d == NULL) { + return; + } + + /* + * free_cdi_cache_device should not be recursively free raw_device. + * Otherwise, the function conflicts with the raw_spec free raw_device + * when cdi_cache_spec free raw_spec, triggering double free. + */ + d->raw_device = NULL; + + /* + * free_cdi_cache_device should not be recursively free cache_spec. + * Otherwise, the function conflicts with the cache free specs, + * triggering double free. + */ + d->cache_spec = NULL; + + free(d); +} + +struct cdi_cache_device *cdi_device_new_device(struct cdi_cache_spec *spec, cdi_device *d) +{ + struct cdi_cache_device *dev = NULL; + + if (spec == NULL || d == NULL) { + ERROR("Invalid params"); + return NULL; + } + + dev = util_common_calloc_s(sizeof(*dev)); + if (dev == NULL) { + ERROR("Out of memory"); + return NULL; + } + dev->raw_device = d; + dev->cache_spec = spec; + + if (cdi_device_validate(dev) != 0) { + free_cdi_cache_device(dev); + return NULL; + } + return dev; } -struct cdi_cache_device *cdi_device_new_device(struct cdi_cache_spec *spec, cdi_device *d, char **error) +const struct cdi_cache_spec *cdi_device_get_spec(const struct cdi_cache_device *d) { - return NULL; + if (d == NULL) { + ERROR("Invalid params"); + return NULL; + } + return d->cache_spec; } -struct cdi_cache_spec *cdi_device_get_spec(struct cdi_cache_device *d) +char *cdi_device_get_qualified_name(const struct cdi_cache_device *d) { - return NULL; + if (d == NULL || d->raw_device == NULL) { + ERROR("Invalid params"); + return NULL; + } + return cdi_parser_qualified_name(cdi_spec_get_vendor(d->cache_spec), + cdi_spec_get_class(d->cache_spec), d->raw_device->name); } -char *cdi_device_get_qualified_name(struct cdi_cache_device *d) +cdi_container_edits *cdi_device_get_edits(const struct cdi_cache_device *d) { - return NULL; + if (d == NULL || d->raw_device == NULL) { + ERROR("Invalid params"); + return NULL; + } + return d->raw_device->container_edits; } -cdi_container_edits *cdi_device_get_edits(struct cdi_cache_device *d) +static int cdi_device_validate(struct cdi_cache_device *d) { - return NULL; + cdi_container_edits *edits = NULL; + + if (cdi_parser_validate_device_name(d->raw_device->name) != 0) { + ERROR("Failed to validate device name"); + return -1; + } + + // ignore validate annotations + + edits = cdi_device_get_edits(d); + if (cdi_container_edits_is_empty(edits)) { + ERROR("Invalid device, empty device edits"); + return -1; + } + if (cdi_container_edits_validate(edits) != 0) { + ERROR("Invalid device %s", d->raw_device->name); + return -1; + } + return 0; } diff --git a/src/daemon/modules/device/cdi/behavior/cdi_device.h b/src/daemon/modules/device/cdi/behavior/cdi_device.h index 5d63a576..9b0a5eab 100644 --- a/src/daemon/modules/device/cdi/behavior/cdi_device.h +++ b/src/daemon/modules/device/cdi/behavior/cdi_device.h @@ -28,16 +28,16 @@ extern "C" { struct cdi_cache_spec; struct cdi_cache_device { - cdi_device *raw_device; - struct cdi_cache_spec *cache_spec; + const cdi_device *raw_device; + const struct cdi_cache_spec *cache_spec; }; void free_cdi_cache_device(struct cdi_cache_device *d); -struct cdi_cache_device *cdi_device_new_device(struct cdi_cache_spec *spec, cdi_device *d, char **error); -struct cdi_cache_spec *cdi_device_get_spec(struct cdi_cache_device *d); -char *cdi_device_get_qualified_name(struct cdi_cache_device *d); -cdi_container_edits *cdi_device_get_edits(struct cdi_cache_device *d); +struct cdi_cache_device *cdi_device_new_device(struct cdi_cache_spec *spec, cdi_device *d); +const struct cdi_cache_spec *cdi_device_get_spec(const struct cdi_cache_device *d); +char *cdi_device_get_qualified_name(const struct cdi_cache_device *d); +cdi_container_edits *cdi_device_get_edits(const struct cdi_cache_device *d); #ifdef __cplusplus } diff --git a/src/daemon/modules/device/cdi/behavior/cdi_spec.c b/src/daemon/modules/device/cdi/behavior/cdi_spec.c index f79b5a44..235b1863 100644 --- a/src/daemon/modules/device/cdi/behavior/cdi_spec.c +++ b/src/daemon/modules/device/cdi/behavior/cdi_spec.c @@ -14,47 +14,235 @@ ******************************************************************************/ #include "cdi_spec.h" +#include +#include +#include + +#include "utils.h" +#include "utils_version.h" +#include "error.h" +#include "path.h" +#include "cdi_version.h" +#include "cdi_parser.h" +#include "cdi_device.h" + +static int cdi_spec_init(struct cdi_cache_spec *s); + void free_cdi_cache_spec(struct cdi_cache_spec *s) { - (void)s; + if (s == NULL) { + return; + } + + free_cdi_spec(s->raw_spec); + s->raw_spec = NULL; + free(s->vendor); + s->vendor = NULL; + free(s->class); + s->class = NULL; + free(s->path); + s->path = NULL; + map_free(s->devices); + s->devices = NULL; + + free(s); } -struct cdi_cache_spec *cdi_spec_read_spec(const char *path, int priority, char **error) +struct cdi_cache_spec *cdi_spec_read_spec(const char *path, int priority) { - return NULL; + cdi_spec *raw_spec = NULL; + __isula_auto_free parser_error err = NULL; + char cleanpath[PATH_MAX] = { 0 }; + + if (util_clean_path(path, cleanpath, sizeof(cleanpath)) == NULL) { + ERROR("Failed to get clean path %s", path); + return NULL; + } + + raw_spec = cdi_spec_parse_file(cleanpath, NULL, &err); + if (raw_spec == NULL) { + ERROR("Failed to read CDI Spec %s: %s", cleanpath, err); + return NULL; + } + DEBUG("Read cdi spec %s", cleanpath); + + return cdi_spec_new_spec(raw_spec, cleanpath, priority); } -struct cdi_cache_spec *cdi_spec_new_spec(cdi_spec *raw, const char *path, int priority, char **error) +struct cdi_cache_spec *cdi_spec_new_spec(cdi_spec *raw, const char *path, int priority) { + struct cdi_cache_spec *spec = NULL; + __isula_auto_free char *checked_path = NULL; + + if (raw == NULL) { + ERROR("Invalid param"); + return NULL; + } + + if (!util_has_suffix(path, ".json")) { + checked_path = util_string_append(path, CDI_DEFAULT_SPEC_EXT); + if (checked_path == NULL) { + ERROR("Failed to append %s to path %s", CDI_DEFAULT_SPEC_EXT, path); + return NULL; + } + } else { + checked_path = util_strdup_s(path); + } + spec = util_common_calloc_s(sizeof(*spec)); + if (spec == NULL) { + ERROR("Out of memory"); + return NULL; + } + spec->raw_spec = raw; + spec->path = checked_path; + checked_path = NULL; + spec->priority = priority; + + if (cdi_parser_parse_qualifier(raw->kind, &spec->vendor, &spec->class) != 0) { + ERROR("Failed to parse kind %s", raw->kind); + goto error_out; + } + if (cdi_spec_init(spec) != 0) { + ERROR("Invalid CDI Spec"); + goto error_out; + } + + return spec; + +error_out: + free_cdi_cache_spec(spec); return NULL; } -const char *cdi_spec_get_vendor(struct cdi_cache_spec *s) +const char *cdi_spec_get_vendor(const struct cdi_cache_spec *s) { - return NULL; + if (s == NULL) { + ERROR("Invalid params"); + return NULL; + } + return s->vendor; } -const char *cdi_spec_get_class(struct cdi_cache_spec *s) +const char *cdi_spec_get_class(const struct cdi_cache_spec *s) { - return NULL; + if (s == NULL) { + ERROR("Invalid params"); + return NULL; + } + return s->class; } -struct cdi_cache_device *cdi_spec_get_cache_device(struct cdi_cache_spec *s, const char *name) +struct cdi_cache_device *cdi_spec_get_cache_device(const struct cdi_cache_spec *s, const char *name) { - return NULL; + if (s == NULL) { + ERROR("Invalid params"); + return NULL; + } + return map_search(s->devices, (void *)name);; } -const char *cdi_spec_get_path(struct cdi_cache_spec *s) +const char *cdi_spec_get_path(const struct cdi_cache_spec *s) { - return NULL; + if (s == NULL) { + ERROR("Invalid params"); + return NULL; + } + return s->path; } -int cdi_spec_get_priority(struct cdi_cache_spec *s) +int cdi_spec_get_priority(const struct cdi_cache_spec *s) { - return 0; + if (s == NULL) { + ERROR("Invalid params"); + return -1; + } + return s->priority; } -cdi_container_edits *cdi_spec_get_edits(struct cdi_cache_spec *s) +cdi_container_edits *cdi_spec_get_edits(const struct cdi_cache_spec *s) { - return NULL; + if (s == NULL || s->raw_spec == NULL) { + ERROR("Invalid params"); + return NULL; + } + return s->raw_spec->container_edits; +} + +static void map_cdi_cache_device_kvfree(void *key, void *value) +{ + free(key); + free_cdi_cache_device((struct cdi_cache_device *)value); +} + +static int cdi_spec_init(struct cdi_cache_spec *s) +{ + const char *min_version = NULL; + __isula_auto_free char *spec_version = NULL; + cdi_container_edits *edits = NULL; + struct cdi_cache_device *dev = NULL; + cdi_device *d = NULL; + size_t i; + bool version_result = true; + + if (!cdi_is_valid_version(s->raw_spec->cdi_version)) { + ERROR("Failed to validate cdi spec version: %s", s->raw_spec->cdi_version); + return -1; + } + + min_version = cdi_minimum_required_version(s->raw_spec); + if (min_version == NULL) { + ERROR("Could not determine minimum required version"); + return -1; + } + if (util_version_greater_than(min_version, s->raw_spec->cdi_version, &version_result) != 0) { + ERROR("Failed to compare version %s and %s", min_version, s->raw_spec->cdi_version); + return -1; + } + if (version_result) { + ERROR("The spec version must be at least v%s", min_version); + return -1; + } + + if (cdi_parser_validate_vendor_name(s->vendor) != 0) { + return -1; + } + if (cdi_parser_validate_class_name(s->class) != 0) { + return -1; + } + + // ignore validate annotations + + edits = cdi_spec_get_edits(s); + if (cdi_container_edits_validate(edits) != 0) { + return -1; + } + + s->devices = map_new(MAP_STR_PTR, MAP_DEFAULT_CMP_FUNC, map_cdi_cache_device_kvfree); + if (s->devices == NULL) { + ERROR("Out of memory"); + return -1; + } + for (i = 0; i < s->raw_spec->devices_len; i++) { + d = s->raw_spec->devices[i]; + dev = cdi_device_new_device(s, d); + if (dev == NULL) { + ERROR("Could not determine minimum required version"); + goto error_out; + } + if (map_search(s->devices, (void *)d->name) != NULL) { + ERROR("Invalid spec, multiple device %s", d->name); + goto error_out; + } + if (!map_insert(s->devices, (void *)d->name, dev)) { + ERROR("Failed to insert device %s", d->name); + goto error_out; + } + } + + return 0; + +error_out: + map_free(s->devices); + s->devices = NULL; + return -1; } diff --git a/src/daemon/modules/device/cdi/behavior/cdi_spec.h b/src/daemon/modules/device/cdi/behavior/cdi_spec.h index 87248041..ca7b2cfa 100644 --- a/src/daemon/modules/device/cdi/behavior/cdi_spec.h +++ b/src/daemon/modules/device/cdi/behavior/cdi_spec.h @@ -40,14 +40,14 @@ struct cdi_cache_spec { void free_cdi_cache_spec(struct cdi_cache_spec *s); -struct cdi_cache_spec *cdi_spec_read_spec(const char *path, int priority, char **error); -struct cdi_cache_spec *cdi_spec_new_spec(cdi_spec *raw, const char *path, int priority, char **error); -const char *cdi_spec_get_vendor(struct cdi_cache_spec *s); -const char *cdi_spec_get_class(struct cdi_cache_spec *s); -struct cdi_cache_device *cdi_spec_get_cache_device(struct cdi_cache_spec *s, const char *name); -const char *cdi_spec_get_path(struct cdi_cache_spec *s); -int cdi_spec_get_priority(struct cdi_cache_spec *s); -cdi_container_edits *cdi_spec_get_edits(struct cdi_cache_spec *s); +struct cdi_cache_spec *cdi_spec_read_spec(const char *path, int priority); +struct cdi_cache_spec *cdi_spec_new_spec(cdi_spec *raw, const char *path, int priority); +const char *cdi_spec_get_vendor(const struct cdi_cache_spec *s); +const char *cdi_spec_get_class(const struct cdi_cache_spec *s); +struct cdi_cache_device *cdi_spec_get_cache_device(const struct cdi_cache_spec *s, const char *name); +const char *cdi_spec_get_path(const struct cdi_cache_spec *s); +int cdi_spec_get_priority(const struct cdi_cache_spec *s); +cdi_container_edits *cdi_spec_get_edits(const struct cdi_cache_spec *s); #ifdef __cplusplus } diff --git a/src/daemon/modules/device/cdi/behavior/cdi_spec_dirs.c b/src/daemon/modules/device/cdi/behavior/cdi_spec_dirs.c index e340abc0..cafb52b8 100644 --- a/src/daemon/modules/device/cdi/behavior/cdi_spec_dirs.c +++ b/src/daemon/modules/device/cdi/behavior/cdi_spec_dirs.c @@ -14,6 +14,17 @@ ******************************************************************************/ #include "cdi_spec_dirs.h" +#include +#include +#include + +#include "utils.h" +#include "path.h" +#include "error.h" +#include "utils_file.h" +#include "utils_array.h" +#include "cdi_spec.h" + #define DEFAULT_SPEC_DIRS_LEN 2 static char *default_spec_dirs_items[DEFAULT_SPEC_DIRS_LEN] = {CDI_DEFAULT_STATIC_DIR, CDI_DEFAULT_DYNAMIC_DIR}; @@ -23,7 +34,76 @@ string_array g_default_spec_dirs = { .cap = DEFAULT_SPEC_DIRS_LEN, }; +struct scan_spec_dir_cb_args { + struct cdi_scan_fn_maps *scan_fn_maps; + cdi_scan_spec_func scan_fn; + int priority; +}; + +static bool scan_spec_dir_cb(const char *dir, const struct dirent *pdirent, void *context) +{ + struct scan_spec_dir_cb_args *args = (struct scan_spec_dir_cb_args *)context; + struct cdi_scan_fn_maps *scan_fn_maps = args->scan_fn_maps; + cdi_scan_spec_func scan_fn = args->scan_fn; + int priority = args->priority; + struct stat st = { 0 }; + __isula_auto_free char *file_path = NULL; + struct cdi_cache_spec *cache_spec = NULL; + + file_path = util_path_join(dir, pdirent->d_name); + if (file_path == NULL) { + ERROR("Failed to get path %s/%s", dir, pdirent->d_name); + goto error_out; + } + + if (lstat(file_path, &st) != 0) { + ERROR("Failed to lstat %s", file_path); + goto error_out; + } + if (S_ISDIR(st.st_mode)) { + DEBUG("Skip dir %s", file_path); + return true; + } + + if (!util_has_suffix(file_path, ".json")) { + DEBUG("Skip file %s", file_path); + return true; + } + + cache_spec = cdi_spec_read_spec(file_path, priority); + if (cache_spec == NULL) { + ERROR("Failed to read spec %s", file_path); + goto error_out; + } + scan_fn(scan_fn_maps, file_path, priority, cache_spec); + return true; + +error_out: + *(scan_fn_maps->refresh_error_flag) = true; + return true; +} + int cdi_scan_spec_dirs(string_array *dirs, struct cdi_scan_fn_maps *scan_fn_maps, cdi_scan_spec_func scan_fn) { + size_t i; + int nret = 0; + + for (i = 0; i < dirs->len; i++) { + struct scan_spec_dir_cb_args args = { + .scan_fn_maps = scan_fn_maps, + .scan_fn = scan_fn, + .priority = i, + }; + if (!util_dir_exists(dirs->items[i])) { + WARN("Cdi dir %s not exists", dirs->items[i]); + continue; + } + nret = util_scan_subdirs(dirs->items[i], scan_spec_dir_cb, &args); + if (nret != 0) { + ERROR("Failed to scan dir %s", dirs->items[i]); + return -1; + } + } + return 0; } diff --git a/src/daemon/modules/device/cdi/behavior/cdi_spec_dirs.h b/src/daemon/modules/device/cdi/behavior/cdi_spec_dirs.h index eedcabad..b17a0cd8 100644 --- a/src/daemon/modules/device/cdi/behavior/cdi_spec_dirs.h +++ b/src/daemon/modules/device/cdi/behavior/cdi_spec_dirs.h @@ -35,7 +35,7 @@ struct cdi_scan_fn_maps { bool *refresh_error_flag; }; typedef void(*cdi_scan_spec_func)(struct cdi_scan_fn_maps *scan_fn_maps, const char *path, int priority, - struct cdi_cache_spec *spec, char *error); + struct cdi_cache_spec *spec); int cdi_scan_spec_dirs(string_array *dirs, struct cdi_scan_fn_maps *scan_fn_maps, cdi_scan_spec_func scan_fn); diff --git a/src/daemon/modules/device/cdi/behavior/cdi_version.c b/src/daemon/modules/device/cdi/behavior/cdi_version.c index 3e87c111..882a965e 100644 --- a/src/daemon/modules/device/cdi/behavior/cdi_version.c +++ b/src/daemon/modules/device/cdi/behavior/cdi_version.c @@ -14,27 +14,174 @@ ******************************************************************************/ #include "cdi_version.h" -#define CDI_V_CURRENT_VERSION "v"##CDI_CURRENT_VERSION - -#define CDI_V010 "v0.1.0" -#define CDI_V020 "v0.2.0" -#define CDI_V030 "v0.3.0" -#define CDI_V040 "v0.4.0" -#define CDI_V050 "v0.5.0" -#define CDI_V060 "v0.6.0" +#include +#include +#include + +#include "error.h" +#include "utils_version.h" +#include "utils_string.h" +#include "cdi_container_edits.h" +#include "cdi_parser.h" + +#define CDI_V010 "0.1.0" +#define CDI_V020 "0.2.0" +#define CDI_V030 "0.3.0" +#define CDI_V040 "0.4.0" +#define CDI_V050 "0.5.0" +#define CDI_V060 "0.6.0" #define CDI_V_EARLIEST CDI_V030 -const char *cdi_minimum_required_version(cdi_spec *spec) +typedef bool (*required_version_cb)(cdi_spec *spec); + +struct required_version_map { + char *version; + required_version_cb cb; +}; + +static bool requires_v060(cdi_spec *spec) +{ + size_t i; + int ret = 0; + __isula_auto_free char *vendor = NULL; + __isula_auto_free char *class = NULL; + + // The 0.6.0 spec allows annotations to be specified at a spec level + if (spec->annotations != NULL) { + return true; + } + + // The 0.6.0 spec allows annotations to be specified at a device level + if (spec->devices != NULL) { + for (i = 0; i < spec->devices_len; i++) { + if (spec->devices[i]->annotations != NULL) { + return true; + } + } + } + + // The 0.6.0 spec allows dots "." in Kind name label (class) + ret = cdi_parser_parse_qualifier(spec->kind, &vendor, &class); + if (ret == 0 && vendor != NULL) { + if (util_strings_count(class, '.') > 0) { + return true; + } + } + return false; +} + +static bool check_host_path(cdi_container_edits *e) { - return NULL; + size_t i; + + if (e == NULL) { + return false; + } + for (i = 0; i < e->device_nodes_len; i++) { + // The HostPath field was added in 0.5.0 + if (e->device_nodes[i]->host_path != NULL) { + return true; + } + } + return false; } -bool cdi_is_greater_than_version(const char *v, const char *o) +static bool requires_v050(cdi_spec *spec) { - return true; + size_t i; + + for (i = 0; i < spec->devices_len; i++) { + // The 0.5.0 spec allowed device names to start with a digit instead of requiring a letter + if (spec->devices[i]->name != NULL && strlen(spec->devices[i]->name) > 0 && + !isalpha(spec->devices[i]->name[0])) { + return true; + } + if (check_host_path(spec->devices[i]->container_edits)) { + return true; + } + } + + return check_host_path(spec->container_edits); +} + +static bool check_mount_type(cdi_container_edits *e) +{ + size_t i; + + if (e == NULL) { + return false; + } + for (i = 0; i < e->mounts_len; i++) { + // The Type field was added in 0.4.0 + if (e->mounts[i]->type != NULL) { + return true; + } + } + return false; +} + +static bool requires_v040(cdi_spec *spec) +{ + size_t i; + + for (i = 0; i < spec->devices_len; i++) { + if (check_mount_type(spec->devices[i]->container_edits)) { + return true; + } + } + + return check_mount_type(spec->container_edits); +} + +#define VALID_SPEC_VERSIONS_LEN 6 +static struct required_version_map g_valid_spec_versions[VALID_SPEC_VERSIONS_LEN] = { + {CDI_V010, NULL}, + {CDI_V020, NULL}, + {CDI_V030, NULL}, + {CDI_V040, requires_v060}, + {CDI_V050, requires_v050}, + {CDI_V060, requires_v040} +}; + +const char *cdi_minimum_required_version(cdi_spec *spec) +{ + const char *min_version = CDI_V_EARLIEST; + int i; + bool result = true; + + if (spec == NULL) { + return NULL; + } + + for (i = 0; i < VALID_SPEC_VERSIONS_LEN; i++) { + if (g_valid_spec_versions[i].cb == NULL) { + continue; + } + if (g_valid_spec_versions[i].cb(spec)) { + if (util_version_greater_than(g_valid_spec_versions[i].version, min_version, &result) != 0) { + ERROR("Failed to compare version %s and %s", g_valid_spec_versions[i].version, min_version); + return NULL; + } + if (result) { + min_version = g_valid_spec_versions[i].version; + } + } + if (strcmp(min_version, CDI_CURRENT_VERSION)) { + break; + } + } + + return min_version; } bool cdi_is_valid_version(const char *spec_version) { - return true; + int i; + + for (i = 0; i < VALID_SPEC_VERSIONS_LEN; i++) { + if (strcmp(g_valid_spec_versions[i].version, spec_version) == 0) { + return true; + } + } + return false; } diff --git a/src/daemon/modules/device/cdi/behavior/cdi_version.h b/src/daemon/modules/device/cdi/behavior/cdi_version.h index 99b7e692..6bd86340 100644 --- a/src/daemon/modules/device/cdi/behavior/cdi_version.h +++ b/src/daemon/modules/device/cdi/behavior/cdi_version.h @@ -24,7 +24,6 @@ extern "C" { #define CDI_CURRENT_VERSION "0.6.0" const char *cdi_minimum_required_version(cdi_spec *spec); -bool cdi_is_greater_than_version(const char *v, const char *o); bool cdi_is_valid_version(const char *spec_version); #ifdef __cplusplus diff --git a/src/daemon/modules/device/cdi/cdi_cache.c b/src/daemon/modules/device/cdi/cdi_cache.c index 37767855..e637f7cd 100644 --- a/src/daemon/modules/device/cdi/cdi_cache.c +++ b/src/daemon/modules/device/cdi/cdi_cache.c @@ -206,13 +206,12 @@ static void map_cdi_cache_specs_kvfree(void *key, void *value) static void map_cdi_cache_device_kvfree(void *key, void *value) { free(key); - free_cdi_cache_device((struct cdi_cache_device *)value); -} - -static void set_refresh_error_flag(bool *refresh_error_flag, const char *error, const char *path) -{ - *refresh_error_flag = true; - ERROR("Cdi refresh error: %s, spec %s", error, path); + /* + * map_cdi_cache_device_kvfree should not be recursively free cdi_cache_device. + * Otherwise, the function conflicts with the cdi_cache_specs free devices, + * triggering double free. + */ + (void)value; } static bool resolve_conflict(struct cdi_scan_fn_maps *scan_fn_maps, const char *name, @@ -220,8 +219,8 @@ static bool resolve_conflict(struct cdi_scan_fn_maps *scan_fn_maps, const char * { map_t *conflicts = scan_fn_maps->conflicts; bool *refresh_error_flag = scan_fn_maps->refresh_error_flag; - struct cdi_cache_spec *dev_spec = NULL; - struct cdi_cache_spec *old_spec = NULL; + const struct cdi_cache_spec *dev_spec = NULL; + const struct cdi_cache_spec *old_spec = NULL; int dev_prio; int old_prio; bool val = true; @@ -251,7 +250,7 @@ static bool resolve_conflict(struct cdi_scan_fn_maps *scan_fn_maps, const char * } static void refresh_scan_spec_func(struct cdi_scan_fn_maps *scan_fn_maps, const char *path, - int priority, struct cdi_cache_spec *spec, char *error) + int priority, struct cdi_cache_spec *spec) { map_t *specs = scan_fn_maps->specs; map_t *devices = scan_fn_maps->devices; @@ -267,12 +266,6 @@ static void refresh_scan_spec_func(struct cdi_scan_fn_maps *scan_fn_maps, const if (util_clean_path(path, clean_path, sizeof(clean_path)) == NULL) { ERROR("Failed to get clean path %s", path); - format_errorf(&tmp_error, "Failed to get clean path %s", path); - return; - } - if (error != NULL) { - ERROR("Failed to load CDI Spec %s", error); - format_errorf(&tmp_error, "Failed to load CDI Spec %s", error); goto error_out; } @@ -282,18 +275,15 @@ static void refresh_scan_spec_func(struct cdi_scan_fn_maps *scan_fn_maps, const spec_array = util_common_array_new(1, (free_common_array_item_cb)free_cdi_cache_spec, util_clone_ptr); if (spec_array == NULL) { ERROR("Out of memory"); - tmp_error = util_strdup_s("Out of memory"); goto error_out; } if (!map_insert(specs, (void *)vendor, spec_array)) { ERROR("Failed to insert spec array to specs"); - tmp_error = util_strdup_s("Failed to insert spec array to specs"); goto error_out; } } if (util_append_common_array(spec_array, spec) != 0) { ERROR("Failed to append spec"); - tmp_error = util_strdup_s("Failed to append spec"); goto error_out; } spec_array = NULL; @@ -301,7 +291,6 @@ static void refresh_scan_spec_func(struct cdi_scan_fn_maps *scan_fn_maps, const itor = map_itor_new(spec->devices); if (itor == NULL) { ERROR("Out of memory, create new map itor failed"); - tmp_error = util_strdup_s("Out of memory, create new map itor failed"); goto error_out; } for (; map_itor_valid(itor); map_itor_next(itor)) { @@ -315,7 +304,6 @@ static void refresh_scan_spec_func(struct cdi_scan_fn_maps *scan_fn_maps, const } if (!map_replace(devices, (void *)qualified, dev)) { ERROR("Failed to insert device to devices by name %s", qualified); - format_errorf(&tmp_error, "Failed to insert device to devices by name %s", qualified); goto error_out; } free(qualified); @@ -324,7 +312,7 @@ static void refresh_scan_spec_func(struct cdi_scan_fn_maps *scan_fn_maps, const goto out; error_out: - set_refresh_error_flag(refresh_error_flag, tmp_error, path); + *refresh_error_flag = true; out: map_itor_free(itor); return; @@ -333,7 +321,6 @@ out: static int refresh(struct cdi_cache *c) { int ret = 0; - __isula_auto_free char *error = NULL; map_t *specs = NULL; map_t *devices = NULL; map_t *conflicts = NULL; @@ -559,8 +546,6 @@ error_out: static void watch_setup(struct cdi_watch *w, string_array *dirs) { - __isula_auto_free char *error = NULL; - if (w == NULL || dirs == NULL || dirs->len == 0) { ERROR("Invalid param"); return; @@ -735,7 +720,6 @@ static void update_add_watch_dir(struct cdi_watch *w, const char *dir, bool *upd { int wd = -1; bool tmp_value = true; - __isula_auto_free char *error = NULL; wd = inotify_add_watch(w->watcher_fd, dir, CDI_WATCH_EVENTS); if (wd < 0) { @@ -770,7 +754,6 @@ static bool watch_update(struct cdi_watch *w, const char *removed, int wd) bool *ok = NULL; bool update = false; map_itor *itor = NULL; - __isula_auto_free char *error = NULL; itor = map_itor_new(w->tracked); if (itor == NULL) { diff --git a/src/daemon/modules/device/cdi/cdi_cache.h b/src/daemon/modules/device/cdi/cdi_cache.h index da315de2..638e954e 100644 --- a/src/daemon/modules/device/cdi/cdi_cache.h +++ b/src/daemon/modules/device/cdi/cdi_cache.h @@ -52,6 +52,7 @@ struct cdi_cache { pthread_mutex_t mutex; string_array *spec_dirs; // cdi-spec-dirs will scan for CDI Spec files map_t *specs; // MAP_STR_PTR specs[vendor] = common_array of cdi_cache_spec* + // This map holding the reference to cdi device, the devices will not released when the map is freed. map_t *devices; // MAP_STR_PTR devices[cdi_device.name] = cdi_cache_device* bool refresh_error_flag; bool auto_refresh; diff --git a/src/daemon/modules/network/cni_operator/libcni/libcni_api.c b/src/daemon/modules/network/cni_operator/libcni/libcni_api.c index 068881be..7ba983af 100644 --- a/src/daemon/modules/network/cni_operator/libcni/libcni_api.c +++ b/src/daemon/modules/network/cni_operator/libcni/libcni_api.c @@ -28,6 +28,7 @@ #include #include "utils.h" +#include "utils_version.h" #include "utils_network.h" #include "libcni_cached.h" #include "libcni_conf.h" @@ -544,97 +545,6 @@ free_out: return ret; } -struct parse_version { - int major; - int minor; - int micro; -}; - -static bool do_parse_version(const char **splits, size_t splits_len, struct parse_version *ret) -{ - if (util_safe_int(splits[0], &ret->major) != 0) { - ERROR("failed to convert major version part: %s", splits[0]); - return false; - } - - if (splits_len >= 2 && util_safe_int(splits[1], &ret->minor) != 0) { - ERROR("failed to convert minor version part: %s", splits[1]); - return false; - } - - if (splits_len >= 3 && util_safe_int(splits[2], &ret->micro) != 0) { - ERROR("failed to convert micro version part: %s", splits[2]); - return false; - } - - return true; -} - -static bool parse_version_from_str(const char *src_version, struct parse_version *result) -{ - char **splits = NULL; - const size_t max_len = 4; - size_t tlen = 0; - bool ret = false; - - splits = util_string_split(src_version, '.'); - if (splits == NULL) { - ERROR("Split version: \"%s\" failed", src_version); - return false; - } - tlen = util_array_len((const char **)splits); - if (tlen < 1 || tlen >= max_len) { - ERROR("Invalid version: \"%s\"", src_version); - goto out; - } - - ret = do_parse_version((const char **)splits, tlen, result); - -out: - util_free_array(splits); - return ret; -} - -static bool do_compare_version(const struct parse_version *p_first, const struct parse_version *p_second) -{ - bool ret = false; - - if (p_first->major > p_second->major) { - ret = true; - } else if (p_first->major == p_second->major) { - if (p_first->minor > p_second->minor) { - ret = true; - } else if (p_first->minor == p_second->minor && p_first->micro >= p_second->micro) { - ret = true; - } - } - - return ret; -} - -static int version_greater_than_or_equal_to(const char *first, const char *second, bool *result) -{ - struct parse_version first_parsed = { 0 }; - struct parse_version second_parsed = { 0 }; - - if (result == NULL) { - ERROR("Invalid argument"); - return -1; - } - - if (!parse_version_from_str(first, &first_parsed)) { - return -1; - } - - if (!parse_version_from_str(second, &second_parsed)) { - return -1; - } - - *result = do_compare_version(&first_parsed, &second_parsed); - - return 0; -} - static inline bool check_add_network_args(const cni_net_conf *net, const struct runtime_conf *rc) { return (net == NULL || rc == NULL); @@ -690,7 +600,7 @@ int cni_add_network_list(const struct cni_network_list_conf *list, const struct } if (*pret != NULL && - version_greater_than_or_equal_to((*pret)->cniversion, SUPPORT_CACHE_AND_CHECK_VERSION, &greater) != 0) { + util_version_greater_than_or_equal_to((*pret)->cniversion, SUPPORT_CACHE_AND_CHECK_VERSION, &greater) != 0) { return 0; } @@ -741,7 +651,7 @@ int cni_del_network_list(const struct cni_network_list_conf *list, const struct return -1; } - if (version_greater_than_or_equal_to(list->list->cni_version, SUPPORT_CACHE_AND_CHECK_VERSION, &greater) != 0) { + if (util_version_greater_than_or_equal_to(list->list->cni_version, SUPPORT_CACHE_AND_CHECK_VERSION, &greater) != 0) { return -1; } @@ -807,7 +717,7 @@ int cni_check_network_list(const struct cni_network_list_conf *list, const struc return -1; } - if (version_greater_than_or_equal_to(list->list->cni_version, SUPPORT_CACHE_AND_CHECK_VERSION, &greater) != 0) { + if (util_version_greater_than_or_equal_to(list->list->cni_version, SUPPORT_CACHE_AND_CHECK_VERSION, &greater) != 0) { return -1; } diff --git a/src/utils/cutils/utils_version.c b/src/utils/cutils/utils_version.c new file mode 100644 index 00000000..9dea5b09 --- /dev/null +++ b/src/utils/cutils/utils_version.c @@ -0,0 +1,147 @@ +/****************************************************************************** + * Copyright (c) Huawei Technologies Co., Ltd. 2018-2022. All rights reserved. + * iSulad licensed under the Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * http://license.coscl.org.cn/MulanPSL2 + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR + * PURPOSE. + * See the Mulan PSL v2 for more details. + * Author: liuxu + * Create: 2024-4-7 + * Description: provide version functions + ********************************************************************************/ + +#define _GNU_SOURCE +#include "utils_version.h" + +#include + +#include "utils.h" +#include "utils_string.h" + +struct parse_version { + int major; + int minor; + int micro; +}; + +static bool do_parse_version(const char **splits, size_t splits_len, struct parse_version *ret) +{ + if (util_safe_int(splits[0], &ret->major) != 0) { + ERROR("Failed to convert major version part: %s", splits[0]); + return false; + } + + if (splits_len >= 2 && util_safe_int(splits[1], &ret->minor) != 0) { + ERROR("Failed to convert minor version part: %s", splits[1]); + return false; + } + + if (splits_len >= 3 && util_safe_int(splits[2], &ret->micro) != 0) { + ERROR("Failed to convert micro version part: %s", splits[2]); + return false; + } + + return true; +} + +static bool parse_version_from_str(const char *src_version, struct parse_version *result) +{ + __isula_auto_array_t char **splits = NULL; + const size_t max_len = 4; + size_t tlen = 0; + bool ret = false; + + splits = util_string_split(src_version, '.'); + if (splits == NULL) { + ERROR("Split version: \"%s\" failed", src_version); + return false; + } + tlen = util_array_len((const char **)splits); + if (tlen < 1 || tlen >= max_len) { + ERROR("Invalid version: \"%s\"", src_version); + return false; + } + + ret = do_parse_version((const char **)splits, tlen, result); + + return ret; +} + +static int do_compare_version(const struct parse_version *p_first, const struct parse_version *p_second) +{ + if (p_first->major != p_second->major) { + return p_first->major - p_second->major; + } + if (p_first->minor != p_second->minor) { + return p_first->minor - p_second->minor; + } + if (p_first->micro != p_second->micro) { + return p_first->micro - p_second->micro; + } + + return 0; +} + +int util_version_compare(const char *first, const char *second, int *diff_value) +{ + struct parse_version first_parsed = { 0 }; + struct parse_version second_parsed = { 0 }; + + if (first == NULL || second == NULL || diff_value == NULL) { + ERROR("Invalid argument"); + return -1; + } + + if (!parse_version_from_str(first, &first_parsed)) { + return -1; + } + + if (!parse_version_from_str(second, &second_parsed)) { + return -1; + } + + *diff_value = do_compare_version(&first_parsed, &second_parsed); + + return 0; +} + +int util_version_greater_than(const char *first, const char *second, bool *result) +{ + int ret; + int diff_value = 0; + + if (result == NULL) { + ERROR("Invalid argument"); + return -1; + } + + ret = util_version_compare(first, second, &diff_value); + if (ret != 0) { + return ret; + } + + *result = (diff_value > 0); + return ret; +} + +int util_version_greater_than_or_equal_to(const char *first, const char *second, bool *result) +{ + int ret; + int diff_value = 0; + + if (result == NULL) { + ERROR("Invalid argument"); + return -1; + } + + ret = util_version_compare(first, second, &diff_value); + if (ret != 0) { + return ret; + } + + *result = (diff_value >= 0); + return ret; +} diff --git a/src/utils/cutils/utils_version.h b/src/utils/cutils/utils_version.h new file mode 100644 index 00000000..f9b543b8 --- /dev/null +++ b/src/utils/cutils/utils_version.h @@ -0,0 +1,36 @@ +/****************************************************************************** + * Copyright (c) Huawei Technologies Co., Ltd. 2018-2022. All rights reserved. + * iSulad licensed under the Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * http://license.coscl.org.cn/MulanPSL2 + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR + * PURPOSE. + * See the Mulan PSL v2 for more details. + * Author: liuxu + * Create: 2024-4-7 + * Description: provide version functions + ********************************************************************************/ + +#ifndef UTILS_CUTILS_UTILS_VERSION_H +#define UTILS_CUTILS_UTILS_VERSION_H + +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +int util_version_compare(const char *first, const char *second, int *diff_value); +int util_version_greater_than(const char *first, const char *second, bool *result); +int util_version_greater_than_or_equal_to(const char *first, const char *second, bool *result); + +#ifdef __cplusplus +} +#endif + +#endif // UTILS_CUTILS_UTILS_VERSION_H \ No newline at end of file -- 2.34.1