diff options
Diffstat (limited to '0061-cdi-support-modules-operate-registry-annotations.patch')
| -rw-r--r-- | 0061-cdi-support-modules-operate-registry-annotations.patch | 516 |
1 files changed, 516 insertions, 0 deletions
diff --git a/0061-cdi-support-modules-operate-registry-annotations.patch b/0061-cdi-support-modules-operate-registry-annotations.patch new file mode 100644 index 0000000..aa26ca2 --- /dev/null +++ b/0061-cdi-support-modules-operate-registry-annotations.patch @@ -0,0 +1,516 @@ +From 4527dc8b6f7ab438742a8f7403b24420f646236d Mon Sep 17 00:00:00 2001 +From: liuxu <liuxu156@huawei.com> +Date: Mon, 8 Apr 2024 11:57:16 +0800 +Subject: [PATCH 61/69] cdi:support modules operate/registry/annotations + +--- + .../modules/device/cdi/cdi_annotations.c | 72 +++++++ + src/daemon/modules/device/cdi/cdi_registry.c | 14 +- + src/daemon/modules/device/cdi_operate.c | 53 +++++- + src/utils/cutils/utils.c | 11 ++ + src/utils/cutils/utils.h | 2 + + src/utils/cutils/utils_array.c | 175 +++++++++++++++++- + src/utils/cutils/utils_array.h | 31 ++++ + 7 files changed, 350 insertions(+), 8 deletions(-) + +diff --git a/src/daemon/modules/device/cdi/cdi_annotations.c b/src/daemon/modules/device/cdi/cdi_annotations.c +index cfe6e099..020816d7 100644 +--- a/src/daemon/modules/device/cdi/cdi_annotations.c ++++ b/src/daemon/modules/device/cdi/cdi_annotations.c +@@ -21,12 +21,84 @@ + + #include "error.h" + #include "utils.h" ++#include "utils_array.h" + #include "cdi_parser.h" + + #define CDI_ANNOTATIONS_PREFIX "cdi.k8s.io/" + ++static int parse_devices(string_array *devices, const char *value, char **error) ++{ ++ __isula_auto_array_t char **parts = NULL; ++ char **pos; ++ ++ parts = util_string_split(value, ','); ++ if (parts == NULL) { ++ ERROR("Invalid CDI device value %s", value); ++ format_errorf(error, "Invalid CDI device value %s", value); ++ return -1; ++ } ++ for (pos = parts; pos != NULL && *pos != NULL; pos++) { ++ if (!cdi_parser_is_qualified_name(*pos)) { ++ ERROR("Invalid CDI device name %s", *pos); ++ format_errorf(error, "Invalid CDI device name %s", *pos); ++ return -1; ++ } ++ if (util_append_string_array(devices, *pos) != 0) { ++ ERROR("Out of memory"); ++ *error = util_strdup_s("Out of memory"); ++ return -1; ++ } ++ } ++ ++ return 0; ++} ++ + int cdi_parse_annotations(json_map_string_string *annotations, string_array **keys, + string_array **devices, char **error) + { ++ char *key = NULL; ++ char *value = NULL; ++ size_t i; ++ __isula_auto_string_array_t string_array *keys_array = NULL; ++ __isula_auto_string_array_t string_array *devices_array = NULL; ++ ++ if (annotations == NULL || keys == NULL || devices == NULL || error == NULL) { ++ ERROR("Invalid argument"); ++ return -1; ++ } ++ ++ keys_array = util_common_calloc_s(sizeof(*keys_array)); ++ if (keys_array == NULL) { ++ ERROR("Out of memory"); ++ *error = util_strdup_s("Out of memory"); ++ return -1; ++ } ++ devices_array = util_common_calloc_s(sizeof(*devices_array)); ++ if (devices_array == NULL) { ++ ERROR("Out of memory"); ++ *error = util_strdup_s("Out of memory"); ++ return -1; ++ } ++ ++ for (i = 0; i < annotations->len; i++) { ++ key = annotations->keys[i]; ++ value = annotations->values[i]; ++ if (!util_has_prefix(key, CDI_ANNOTATIONS_PREFIX)) { ++ continue; ++ } ++ if (parse_devices(devices_array, value, error) != 0) { ++ return -1; ++ } ++ if (util_append_string_array(keys_array, key) != 0) { ++ ERROR("Out of memory"); ++ *error = util_strdup_s("Out of memory"); ++ return -1; ++ } ++ } ++ ++ *keys = keys_array; ++ keys_array = NULL; ++ *devices = devices_array; ++ devices_array = NULL; + return 0; + } +diff --git a/src/daemon/modules/device/cdi/cdi_registry.c b/src/daemon/modules/device/cdi/cdi_registry.c +index 68767a5f..be381132 100644 +--- a/src/daemon/modules/device/cdi/cdi_registry.c ++++ b/src/daemon/modules/device/cdi/cdi_registry.c +@@ -14,12 +14,24 @@ + ******************************************************************************/ + #include "cdi_registry.h" + ++#include <util_atomic.h> ++#include <isula_libutils/auto_cleanup.h> ++ ++static struct cdi_registry g_cdi_reg = { 0 }; ++ + int cdi_registry_init(string_array *spec_dirs) + { ++ // isulad will use default dirs when spec_dirs == NULL ++ g_cdi_reg.cdi_cache = cdi_new_cache(spec_dirs); ++ if (g_cdi_reg.cdi_cache == NULL) { ++ ERROR("Failed to init registry"); ++ return -1; ++ } ++ g_cdi_reg.ops = cdi_get_cache_ops(); + return 0; + } + + struct cdi_registry *cdi_get_registry(void) + { +- return NULL; ++ return &g_cdi_reg; + } +diff --git a/src/daemon/modules/device/cdi_operate.c b/src/daemon/modules/device/cdi_operate.c +index c5187ab1..f99bb7e4 100644 +--- a/src/daemon/modules/device/cdi_operate.c ++++ b/src/daemon/modules/device/cdi_operate.c +@@ -14,23 +14,66 @@ + ******************************************************************************/ + #include "cdi_operate_api.h" + ++#include <isula_libutils/log.h> ++ ++#include "utils.h" ++#include "error.h" ++#include "cdi_registry.h" ++#include "cdi_annotations.h" ++#include "cdi_spec_dirs.h" ++ + int cdi_operate_registry_init(char **specs_dirs, size_t specs_dirs_len) + { +- return 0; ++ string_array spec_dirs_array = { ++ .items = specs_dirs, ++ .len = specs_dirs_len, ++ .cap = specs_dirs_len, ++ }; ++ ++ return cdi_registry_init(&spec_dirs_array); + } + + int cdi_operate_refresh(void) + { +- return 0; ++ struct cdi_registry *registry = cdi_get_registry(); ++ if (registry == NULL || registry->ops == NULL || registry->ops->refresh == NULL) { ++ ERROR("Failed to get registry"); ++ return -1; ++ } ++ ++ return registry->ops->refresh(registry->cdi_cache); + } + + int cdi_operate_inject_devices(oci_runtime_spec *spec, string_array *devices) + { +- return 0; ++ struct cdi_registry *registry = NULL; ++ ++ if (spec == NULL || devices == NULL) { ++ ERROR("Invalid params"); ++ return -1; ++ } ++ ++ registry = cdi_get_registry(); ++ if (registry == NULL || registry->ops == NULL || registry->ops->inject_devices == NULL) { ++ ERROR("Failed to get registry"); ++ return -1; ++ } ++ ++ return registry->ops->inject_devices(registry->cdi_cache, spec, devices); + } + + int cdi_operate_parse_annotations(json_map_string_string *annotations, string_array **keys, + string_array **devices, char **error) + { +- return 0; +-} +\ No newline at end of file ++ if (error == NULL) { ++ ERROR("Invalid argument"); ++ return -1; ++ } ++ if (annotations == NULL || keys == NULL || devices == NULL) { ++ ERROR("Invalid params"); ++ *error = util_strdup_s("Invalid params"); ++ return -1; ++ } ++ ++ return cdi_parse_annotations(annotations, keys, devices, error); ++} +diff --git a/src/utils/cutils/utils.c b/src/utils/cutils/utils.c +index 8da2cc60..9a33f935 100644 +--- a/src/utils/cutils/utils.c ++++ b/src/utils/cutils/utils.c +@@ -59,6 +59,17 @@ int malloc_trim(size_t pad) + } + #endif + ++void util_swap_ptr(void **p1, void **p2) ++{ ++ void *tmp; ++ if (p1 == NULL || p2 == NULL) { ++ return; ++ } ++ tmp = *p1; ++ *p1 = *p2; ++ *p2 = tmp; ++} ++ + int util_mem_realloc(void **newptr, size_t newsize, void *oldptr, size_t oldsize) + { + void *tmp = NULL; +diff --git a/src/utils/cutils/utils.h b/src/utils/cutils/utils.h +index 3acf0698..3671272a 100644 +--- a/src/utils/cutils/utils.h ++++ b/src/utils/cutils/utils.h +@@ -320,6 +320,8 @@ struct signame { + } \ + } while (0) + ++void util_swap_ptr(void **p1, void **p2); ++ + int util_mem_realloc(void **newptr, size_t newsize, void *oldptr, size_t oldsize); + + int util_check_inherited(bool closeall, int fd_to_ignore); +diff --git a/src/utils/cutils/utils_array.c b/src/utils/cutils/utils_array.c +index 25f19b8b..72294005 100644 +--- a/src/utils/cutils/utils_array.c ++++ b/src/utils/cutils/utils_array.c +@@ -86,6 +86,27 @@ void util_free_sensitive_array(char **array) + free(array); + } + ++char **util_copy_array_by_len(char **array, size_t len) ++{ ++ char **new_array = NULL; ++ size_t i; ++ ++ if (array == NULL || len == 0) { ++ return NULL; ++ } ++ ++ new_array = util_smart_calloc_s(sizeof(char *), len); ++ if (new_array == NULL) { ++ ERROR("Out of memory"); ++ return NULL; ++ } ++ ++ for (i = 0; i < len; i++) { ++ new_array[i] = util_strdup_s(array[i]); ++ } ++ return new_array; ++} ++ + int util_array_append(char ***array, const char *element) + { + size_t len; +@@ -166,7 +187,7 @@ bool util_array_contain(const char **array, const char *element) + return false; + } + +-static size_t get_string_array_scale_size(size_t old_size) ++static size_t get_array_scale_size(size_t old_size) + { + #define DOUBLE_THRESHOLD 1024 + const size_t max_threshold = MAX_MEMORY_SIZE / sizeof(char *); +@@ -188,7 +209,7 @@ static size_t get_string_array_scale_size(size_t old_size) + + static bool do_expand_array(string_array *array) + { +- size_t new_size = get_string_array_scale_size(array->cap); ++ size_t new_size = get_array_scale_size(array->cap); + char **new_items = NULL; + + // array capability sure less than MAX_MEMORY_SIZE +@@ -237,6 +258,29 @@ out: + return 0; + } + ++string_array *util_copy_string_array(string_array *sarr) ++{ ++ string_array *ptr = NULL; ++ size_t i; ++ ++ if (sarr == NULL) { ++ ERROR("Invalid string array"); ++ return NULL; ++ } ++ ++ ptr = util_string_array_new(sarr->cap); ++ if (ptr == NULL) { ++ ERROR("Out of memory"); ++ return NULL; ++ } ++ for (i = 0; i < sarr->len; i++) { ++ ptr->items[i] = util_strdup_s(sarr->items[i]); ++ ptr->len += 1; ++ } ++ ++ return ptr; ++} ++ + bool util_string_array_contain(const string_array *sarr, const char *elem) + { + size_t i; +@@ -339,3 +383,130 @@ int util_common_array_append_pointer(void ***array, void *element) + + return 0; + } ++ ++void *util_clone_ptr(void *item) ++{ ++ return item; ++} ++ ++common_array *util_common_array_new(size_t len, free_common_array_item_cb free_item_cb, ++ clone_common_array_item_cb clone_item_cb) ++{ ++ common_array *ptr = NULL; ++ ++ if (len == 0 || free_item_cb == NULL || clone_item_cb == NULL) { ++ return NULL; ++ } ++ ++ ptr = (common_array *)util_common_calloc_s(sizeof(common_array)); ++ if (ptr == NULL) { ++ ERROR("Out of memory"); ++ return NULL; ++ } ++ ++ ptr->items = (void **)util_smart_calloc_s(sizeof(void *), len); ++ if (ptr->items == NULL) { ++ ERROR("Out of memory"); ++ free(ptr); ++ return NULL; ++ } ++ ++ ptr->len = 0; ++ ptr->cap = len; ++ ptr->free_item_cb = free_item_cb; ++ ptr->clone_item_cb = clone_item_cb; ++ ++ return ptr; ++} ++ ++void util_free_common_array(common_array *ptr) ++{ ++ size_t i; ++ ++ if (ptr == NULL || ptr->free_item_cb == NULL) { ++ return; ++ } ++ ++ for (i = 0; i < ptr->len; i++) { ++ ptr->free_item_cb(ptr->items[i]); ++ ptr->items[i] = NULL; ++ } ++ free(ptr->items); ++ ptr->items = NULL; ++ ptr->len = 0; ++ ptr->cap = 0; ++ ptr->free_item_cb = NULL; ++ ptr->clone_item_cb = NULL; ++ ++ free(ptr); ++} ++ ++static bool do_expand_common_array(common_array *array) ++{ ++ size_t new_size = get_array_scale_size(array->cap); ++ void **new_items = NULL; ++ ++ // array capability sure less than MAX_MEMORY_SIZE ++ // so we need to check Overflow: ++ if (new_size == array->cap) { ++ ERROR("Too large common array, overflow memory"); ++ return false; ++ } ++ ++ // new_size * sizeof(*new_items) and list->len * sizeof(*list->items) ++ if (util_mem_realloc((void **)&new_items, new_size * sizeof(void *), (void *)array->items, ++ array->len * sizeof(void *)) != 0) { ++ ERROR("Out of memory"); ++ return false; ++ } ++ array->items = new_items; ++ array->cap = new_size; ++ ++ return true; ++} ++ ++int util_append_common_array(common_array *arr, void *val) ++{ ++ if (arr == NULL || arr->clone_item_cb == NULL) { ++ ERROR("Invalid common array"); ++ return -1; ++ } ++ ++ if (val == NULL) { ++ DEBUG("Empty new item, just ignore it"); ++ return 0; ++ } ++ ++ if (arr->len < arr->cap) { ++ goto out; ++ } ++ ++ // expand common array ++ if (!do_expand_common_array(arr)) { ++ return -1; ++ } ++ ++out: ++ arr->items[arr->len] = arr->clone_item_cb(val); ++ arr->len += 1; ++ return 0; ++} ++ ++int util_merge_common_array(common_array *dest_arr, common_array *src_arr) ++{ ++ size_t i; ++ ++ if (dest_arr == NULL || dest_arr->clone_item_cb == NULL || ++ src_arr == NULL || src_arr->clone_item_cb == NULL) { ++ ERROR("Invalid common array"); ++ return -1; ++ } ++ ++ for (i = 0; i < src_arr->len; i++) { ++ if (util_append_common_array(dest_arr, src_arr->items[i]) != 0) { ++ ERROR("Failed to append element"); ++ return -1; ++ } ++ } ++ return 0; ++} +diff --git a/src/utils/cutils/utils_array.h b/src/utils/cutils/utils_array.h +index 1c084595..0c4fd217 100644 +--- a/src/utils/cutils/utils_array.h ++++ b/src/utils/cutils/utils_array.h +@@ -30,6 +30,8 @@ void util_free_array_by_len(char **array, size_t len); + + void util_free_array(char **array); + ++char **util_copy_array_by_len(char **array, size_t len); ++ + int util_grow_array(char ***orig_array, size_t *orig_capacity, size_t size, + size_t increment); + +@@ -52,6 +54,8 @@ void util_free_string_array(string_array *ptr); + + int util_append_string_array(string_array *sarr, const char *val); + ++string_array *util_copy_string_array(string_array *sarr); ++ + bool util_string_array_contain(const string_array *sarr, const char *elem); + + void util_free_sensitive_array(char **array); +@@ -63,6 +67,33 @@ define_auto_cleanup_callback(util_free_array, char *); + // define auto free macro for char * + #define __isula_auto_array_t auto_cleanup_tag(util_free_array) + ++define_auto_cleanup_callback(util_free_string_array, string_array); ++#define __isula_auto_string_array_t auto_cleanup_tag(util_free_string_array) ++ ++typedef void (*free_common_array_item_cb)(void *item); ++typedef void *(*clone_common_array_item_cb)(void *item); ++typedef struct common_array_t { ++ void **items; ++ size_t len; ++ size_t cap; ++ free_common_array_item_cb free_item_cb; ++ clone_common_array_item_cb clone_item_cb; ++} common_array; ++ ++void *util_clone_ptr(void *item); ++ ++common_array *util_common_array_new(size_t len, free_common_array_item_cb free_item_cb, ++ clone_common_array_item_cb clone_item_cb); ++ ++void util_free_common_array(common_array *ptr); ++ ++int util_append_common_array(common_array *arr, void *val); ++ ++int util_merge_common_array(common_array *dest_arr, common_array *src_arr); ++ ++define_auto_cleanup_callback(util_free_common_array, common_array); ++#define __isula_auto_common_array_t auto_cleanup_tag(util_free_common_array) ++ + #ifdef __cplusplus + } + #endif +-- +2.34.1 + |