intelrdt: add support for generic schemata update

This patch enhances Intel RDT management by enabling updates
to the generic `schemata` file within a resctrl group.

Closes: #1746

Signed-off-by: Giuseppe Scrivano <[email protected]>

Author: giuseppe

src/libcrun/container.c

@@ -4688,7 +4688,7 @@ libcrun_container_update_intel_rdt (libcrun_context_t *context, const char *id,
   if (UNLIKELY (container == NULL))
     return -1;
 
-  return libcrun_update_intel_rdt (id, container, update->l3_cache_schema, update->mem_bw_schema, err);
+  return libcrun_update_intel_rdt (id, container, update->l3_cache_schema, update->mem_bw_schema, update->schemata, err);
 }
 
 static int

src/libcrun/container.h

@@ -271,6 +271,7 @@ struct libcrun_intel_rdt_update
 {
   const char *l3_cache_schema;
   const char *mem_bw_schema;
+  char *const *schemata;
 };
 
 LIBCRUN_PUBLIC int libcrun_container_update_intel_rdt (libcrun_context_t *context, const char *id,

src/libcrun/intelrdt.c

@@ -26,6 +26,8 @@
 #include <sched.h>
 #include <fcntl.h>
 #include <sys/vfs.h>
+#include <unistd.h>
+#include <errno.h>
 
 #define INTEL_RDT_MOUNT_POINT "/sys/fs/resctrl"
 #define SCHEMATA_FILE "schemata"
@@ -45,10 +47,21 @@ is_rdt_mounted (libcrun_error_t *err)
   return sfs.f_type == RDTGROUP_SUPER_MAGIC;
 }
 
-static int
-get_rdt_value (char **out, const char *l3_cache_schema, const char *mem_bw_schema)
+int
+get_rdt_value (char **out, const char *l3_cache_schema, const char *mem_bw_schema, char *const *schemata)
 {
-  return xasprintf (out, "%s%s%s\n", l3_cache_schema ?: "", (l3_cache_schema && mem_bw_schema) ? "\n" : "", mem_bw_schema ?: "");
+  cleanup_free char *schemata_joined = NULL;
+  size_t schemata_size = 0;
+
+  while (schemata && schemata[schemata_size])
+    schemata_size++;
+
+  if (schemata_size > 0)
+    schemata_joined = str_join_array (0, schemata_size, schemata, "\n");
+
+  return xasprintf (out, "%s%s%s%s%s\n", l3_cache_schema ?: "",
+                    (l3_cache_schema && mem_bw_schema) ? "\n" : "", mem_bw_schema ?: "",
+                    ((l3_cache_schema || mem_bw_schema) && schemata_joined) ? "\n" : "", schemata_joined ?: "");
 }
 
 struct key_value
@@ -189,12 +202,12 @@ validate_rdt_configuration (const char *name, const char *l3_cache_schema, const
 }
 
 static int
-write_intelrdt_string (int fd, const char *file, const char *l3_cache_schema, const char *mem_bw_schema, libcrun_error_t *err)
+write_intelrdt_string (int fd, const char *file, const char *l3_cache_schema, const char *mem_bw_schema, char *const *schemata, libcrun_error_t *err)
 {
   cleanup_free char *formatted = NULL;
   int len, ret;
 
-  len = get_rdt_value (&formatted, l3_cache_schema, mem_bw_schema);
+  len = get_rdt_value (&formatted, l3_cache_schema, mem_bw_schema, schemata);
   if (len < 0)
     return crun_make_error (err, errno, "internal error get_rdt_value");
 
@@ -237,6 +250,8 @@ resctl_create (const char *name, bool explicit_clos_id, bool *created, const cha
   int exist;
   int ret;
 
+  *created = false;
+
   ret = is_rdt_mounted (err);
   if (UNLIKELY (ret < 0))
     return ret;
@@ -269,9 +284,12 @@ resctl_create (const char *name, bool explicit_clos_id, bool *created, const cha
     return validate_rdt_configuration (name, l3_cache_schema, mem_bw_schema, err);
 
   /* At this point, assume it was created.  */
+  ret = crun_ensure_directory (path, 0755, true, err);
+  if (UNLIKELY (ret < 0))
+    return ret;
   *created = true;
 
-  return crun_ensure_directory (path, 0755, true, err);
+  return 0;
 }
 
 int
@@ -292,33 +310,34 @@ resctl_move_task_to (const char *name, pid_t pid, libcrun_error_t *err)
 }
 
 int
-resctl_update (const char *name, const char *l3_cache_schema, const char *mem_bw_schema, libcrun_error_t *err)
+resctl_update (const char *name, const char *l3_cache_schema, const char *mem_bw_schema,
+               char *const *schemata, libcrun_error_t *err)
 {
+  const char *actual_l3_cache_schema = l3_cache_schema;
   cleanup_free char *cleaned_l3_cache_schema = NULL;
   cleanup_free char *path = NULL;
   cleanup_close int fd = -1;
   int ret;
 
   /* Nothing to do.  */
-  if (l3_cache_schema == NULL && mem_bw_schema == NULL)
+  if (l3_cache_schema == NULL && mem_bw_schema == NULL && schemata == NULL)
     return 0;
 
   ret = append_paths (&path, err, INTEL_RDT_MOUNT_POINT, name, SCHEMATA_FILE, NULL);
   if (UNLIKELY (ret < 0))
     return ret;
 
   if (l3_cache_schema && strstr (l3_cache_schema, "MB:"))
-    l3_cache_schema = cleaned_l3_cache_schema = intelrdt_clean_l3_cache_schema (l3_cache_schema);
+    {
+      cleaned_l3_cache_schema = intelrdt_clean_l3_cache_schema (l3_cache_schema);
+      actual_l3_cache_schema = cleaned_l3_cache_schema;
+    }
 
   fd = open (path, O_WRONLY | O_CLOEXEC);
   if (UNLIKELY (fd < 0))
-    return crun_make_error (err, errno, "open `%s`", path);
+    return crun_make_error (err, errno, "open `%s` for writing", path);
 
-  ret = write_intelrdt_string (fd, path, l3_cache_schema, mem_bw_schema, err);
-  if (UNLIKELY (ret < 0))
-    return ret;
-
-  return 0;
+  return write_intelrdt_string (fd, path, actual_l3_cache_schema, mem_bw_schema, schemata, err);
 }
 
 int

src/libcrun/intelrdt.h

@@ -26,7 +26,7 @@
 
 int resctl_create (const char *name, bool explicit_clos_id, bool *created, const char *l3_cache_schema, const char *mem_bw_schema, libcrun_error_t *err);
 int resctl_move_task_to (const char *name, pid_t pid, libcrun_error_t *err);
-int resctl_update (const char *name, const char *l3_cache_schema, const char *mem_bw_schema, libcrun_error_t *err);
+int resctl_update (const char *name, const char *l3_cache_schema, const char *mem_bw_schema, char *const *schemata, libcrun_error_t *err);
 int resctl_destroy (const char *name, libcrun_error_t *err);
 
 #endif

src/libcrun/linux.c

@@ -5784,7 +5784,7 @@ libcrun_apply_intelrdt (const char *ctr_name, libcrun_container_t *container, pi
 
   if (actions & LIBCRUN_INTELRDT_UPDATE)
     {
-      ret = resctl_update (name, def->linux->intel_rdt->l3cache_schema, def->linux->intel_rdt->mem_bw_schema, err);
+      ret = resctl_update (name, def->linux->intel_rdt->l3cache_schema, def->linux->intel_rdt->mem_bw_schema, def->linux->intel_rdt->schemata, err);
       if (UNLIKELY (ret < 0))
         goto fail;
     }
@@ -5819,13 +5819,13 @@ libcrun_destroy_intelrdt (const char *name, libcrun_error_t *err)
 }
 
 int
-libcrun_update_intel_rdt (const char *ctr_name, libcrun_container_t *container, const char *l3_cache_schema, const char *mem_bw_schema, libcrun_error_t *err)
+libcrun_update_intel_rdt (const char *ctr_name, libcrun_container_t *container, const char *l3_cache_schema, const char *mem_bw_schema, char *const *schemata, libcrun_error_t *err)
 {
   const char *name;
 
   name = libcrun_get_intelrdt_name (ctr_name, container, NULL);
 
-  return resctl_update (name, l3_cache_schema, mem_bw_schema, err);
+  return resctl_update (name, l3_cache_schema, mem_bw_schema, schemata, err);
 }
 
 /* Change the current directory and make sure the current working

src/libcrun/linux.h

@@ -143,7 +143,7 @@ int libcrun_apply_intelrdt (const char *ctr_name, libcrun_container_t *container
 
 int libcrun_destroy_intelrdt (const char *name, libcrun_error_t *err);
 
-int libcrun_update_intel_rdt (const char *ctr_name, libcrun_container_t *container, const char *l3_cache_schema, const char *mem_bw_schema, libcrun_error_t *err);
+int libcrun_update_intel_rdt (const char *ctr_name, libcrun_container_t *container, const char *l3_cache_schema, const char *mem_bw_schema, char *const *schemata, libcrun_error_t *err);
 
 int libcrun_safe_chdir (const char *path, libcrun_error_t *err);
 

tests/tests_libcrun_intelrdt.c

@@ -26,6 +26,7 @@ typedef int (*test) ();
 
 extern int compare_rdt_configurations (const char *a, const char *b);
 extern char *intelrdt_clean_l3_cache_schema (const char *l3_cache_schema);
+extern int get_rdt_value (char **out, const char *l3_cache_schema, const char *mem_bw_schema, char *const *schemata);
 
 static int
 test_compare_rdt_configurations ()
@@ -75,6 +76,56 @@ test_intelrdt_clean_l3_cache_schema ()
   return 0;
 }
 
+static int
+test_get_rdt_value ()
+{
+#define COMPARE(L3, MB, SCHEMATA, EXPECTED)              \
+  do                                                     \
+    {                                                    \
+      char *result = NULL;                               \
+      int r = get_rdt_value (&result, L3, MB, SCHEMATA); \
+      int cmp = strcmp (result, EXPECTED);               \
+      free (result);                                     \
+      if (cmp != 0)                                      \
+        return 1;                                        \
+  } while (0)
+
+  COMPARE (NULL, NULL, NULL, "\n");
+
+  COMPARE ("L3=foo", NULL, NULL, "L3=foo\n");
+  COMPARE (NULL, "MB=bar", NULL, "MB=bar\n");
+  COMPARE ("L3=foo", "MB=bar", NULL, "L3=foo\nMB=bar\n");
+
+  {
+    char *schemata1[] = { "S1", "S2", NULL };
+    COMPARE (NULL, NULL, schemata1, "S1\nS2\n");
+  }
+
+  {
+    char *schemata2[] = { "S1", "S2", NULL };
+    COMPARE ("L3=foo", NULL, schemata2, "L3=foo\nS1\nS2\n");
+  }
+
+  {
+    char *schemata3[] = { "S1", "S2", NULL };
+    COMPARE (NULL, "MB=bar", schemata3, "MB=bar\nS1\nS2\n");
+  }
+
+  {
+    char *schemata4[] = { "S1", "S2", NULL };
+    COMPARE ("L3=foo", "MB=bar", schemata4, "L3=foo\nMB=bar\nS1\nS2\n");
+  }
+
+  {
+    char *schemata5[] = { NULL };
+    COMPARE (NULL, NULL, schemata5, "\n");
+  }
+
+#undef COMPARE
+
+  return 0;
+}
+
 static void
 run_and_print_test_result (const char *name, int id, test t)
 {
@@ -97,8 +148,9 @@ int
 main ()
 {
   int id = 1;
-  printf ("1..2\n");
+  printf ("1..3\n");
   RUN_TEST (test_compare_rdt_configurations);
   RUN_TEST (test_intelrdt_clean_l3_cache_schema);
+  RUN_TEST (test_get_rdt_value);
   return 0;
 }