packages/iSulad
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
iSulad/0061-cdi-support-modules-operate-registry-annotations.patch
liuxu 02ceb7b87c upgrade from upstream
2024-04-20 14:26:09 +08:00

517 lines
15 KiB
Diff
Raw Permalink Blame History

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
Reference in New Issue View Git Blame Copy Permalink