automatic import of iSuladopeneuler24.03_LTS

1 files changed, 1254 insertions, 0 deletions

diff --git a/0066-cdi-support-modules-version-spec-spec_dirs-device.patch b/0066-cdi-support-modules-version-spec-spec_dirs-device.patch
new file mode 100644
index 0000000..6aff31b
--- /dev/null
+++ b/0066-cdi-support-modules-version-spec-spec_dirs-device.patch
@@ -0,0 +1,1254 @@
+From 684f0aa648061a13e777153e297a7064ba33ea17 Mon Sep 17 00:00:00 2001
+From: liuxu <liuxu156@huawei.com>
+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 <isula_libutils/log.h>
++#include <isula_libutils/auto_cleanup.h>
++
++#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 <stdlib.h>
++#include <isula_libutils/log.h>
++#include <isula_libutils/auto_cleanup.h>
++
++#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 <sys/stat.h>
++#include <isula_libutils/log.h>
++#include <isula_libutils/auto_cleanup.h>
++
++#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 <ctype.h>
++#include <isula_libutils/log.h>
++#include <isula_libutils/auto_cleanup.h>
++
++#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 <isula_libutils/auto_cleanup.h>
+ 
+ #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 <isula_libutils/log.h>
++
++#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 <stdbool.h>
++#include <stddef.h>
++#include <stdint.h>
++#include <sys/types.h>
++
++#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
+