lib: expose the number of usable memory regions through the API

The rule that turns the MRRM region count into a number of usable memory
regions was implemented twice, once in the library and once in the
utility, because the internal accessor has hidden visibility and the
utility can only call exported symbols.

Export pqos_get_num_mem_regions() so that the rule has a single
implementation. It is a locked wrapper around the internal accessor, and
the utility helper is reduced to reporting the failure to the user.

Any application that configures region aware MBA needs this value, and
deriving it from the public struct requires knowing that
max_memory_regions_supported has to be limited by PQOS_MAX_MEM_REGIONS -
the assumption whose absence this series is fixing. Providing the answer
keeps that detail inside the library.

Signed-off-by: Raghavan Kanagaraj <raghavan.kanagaraj@intel.com>

Author: rkanagar

lib/cap.c

@@ -1225,6 +1225,28 @@ pqos_sysconfig_get(const struct pqos_sysconfig **sysconf)
         return PQOS_RETVAL_OK;
 }
 
+int
+pqos_get_num_mem_regions(unsigned *num_mem_regions)
+{
+        int ret;
+
+        if (num_mem_regions == NULL)
+                return PQOS_RETVAL_PARAM;
+
+        lock_get();
+
+        ret = _pqos_check_init(1);
+        if (ret != PQOS_RETVAL_OK) {
+                lock_release();
+                return ret;
+        }
+
+        ret = mmio_get_num_mem_regions(num_mem_regions);
+
+        lock_release();
+        return ret;
+}
+
 void
 _pqos_cap_l3cdp_change(const enum pqos_cdp_config cdp)
 {

lib/pqos.h

@@ -893,6 +893,26 @@ int pqos_cap_get(const struct pqos_cap **cap, const struct pqos_cpuinfo **cpu);
  */
 int pqos_sysconfig_get(const struct pqos_sysconfig **sysconf);
 
+/**
+ * @brief Retrieves the number of memory regions usable on the platform
+ *
+ * The number of memory regions the platform implements is reported by the MRRM
+ * ACPI table and can be larger than the PQOS_MAX_MEM_REGIONS regions the
+ * interfaces can address. This function returns the smaller of the two, so
+ * valid memory region numbers are 0 to *num_mem_regions - 1.
+ *
+ * Only supported on the MMIO interface.
+ *
+ * @param [out] num_mem_regions Location to store the number of memory regions
+ *
+ * @return Operations status
+ * @retval PQOS_RETVAL_OK on success
+ * @retval PQOS_RETVAL_PARAM if num_mem_regions is NULL
+ * @retval PQOS_RETVAL_INIT if the library is not initialized
+ * @retval PQOS_RETVAL_RESOURCE if memory region information is not available
+ */
+int pqos_get_num_mem_regions(unsigned *num_mem_regions);
+
 /*
  * @brief Retrieves PQoS interface
  *

pqos/common.c

@@ -47,27 +47,12 @@
 int
 pqos_platform_mem_regions(unsigned *num_mem_regions)
 {
-        const struct pqos_sysconfig *sys = NULL;
-
-        if (num_mem_regions == NULL)
-                return -1;
-
-        if (pqos_sysconfig_get(&sys) != PQOS_RETVAL_OK || sys == NULL ||
-            sys->mrrm == NULL || sys->mrrm->max_memory_regions_supported == 0) {
+        if (pqos_get_num_mem_regions(num_mem_regions) != PQOS_RETVAL_OK) {
                 fprintf(stderr, "Memory region information is not "
                                 "available!\n");
                 return -1;
         }
 
-        /**
-         * MRRM reports what the platform implements, which can be more than the
-         * PQOS_MAX_MEM_REGIONS sized arrays of the interface can carry.
-         */
-        *num_mem_regions =
-            (sys->mrrm->max_memory_regions_supported < PQOS_MAX_MEM_REGIONS)
-                ? sys->mrrm->max_memory_regions_supported
-                : PQOS_MAX_MEM_REGIONS;
-
         return 0;
 }
 

pqos/common.h

@@ -142,10 +142,9 @@ int pqos_parse_mem_regions(const char *arg, int *regions, unsigned max_regions);
 /**
  * @brief Retrieves the number of memory regions supported by the platform
  *
- * The value comes from the MRRM table through the library, limited to the
- * PQOS_MAX_MEM_REGIONS regions the interface can address, so it is only
- * available after the library has been initialized. Valid memory region
- * numbers are 0 to *num_mem_regions - 1.
+ * Wrapper around pqos_get_num_mem_regions() that reports the failure to the
+ * user, so it is only usable after the library has been initialized. Valid
+ * memory region numbers are 0 to *num_mem_regions - 1.
  *
  * @param [out] num_mem_regions number of supported memory regions
  *

unit-test/lib/test_cap.c

@@ -380,6 +380,23 @@ test_pqos_fini(void **state __attribute__((unused)))
         assert_int_equal(ret, PQOS_RETVAL_OK);
 }
 
+/* ======== pqos_get_num_mem_regions ======== */
+
+static void
+test_pqos_get_num_mem_regions_before_init(void **state __attribute__((unused)))
+{
+        unsigned num_mem_regions = 0;
+        int ret;
+
+        ret = pqos_get_num_mem_regions(NULL);
+        assert_int_equal(ret, PQOS_RETVAL_PARAM);
+
+        expect_function_call(__wrap_lock_get);
+        expect_function_call(__wrap_lock_release);
+        ret = pqos_get_num_mem_regions(&num_mem_regions);
+        assert_int_equal(ret, PQOS_RETVAL_INIT);
+}
+
 /* ======== pqos_cap_get ======== */
 
 static void
@@ -578,6 +595,7 @@ main(void)
             cmocka_unit_test(test__pqos_get_cap_before_init),
             cmocka_unit_test(test__pqos_get_cpu_before_init),
             cmocka_unit_test(test_pqos_cap_get_before_init),
+            cmocka_unit_test(test_pqos_get_num_mem_regions_before_init),
             cmocka_unit_test(test_pqos_init),
             cmocka_unit_test(test_pqos_cap_get_after_init),
             cmocka_unit_test(test__pqos_get_cap_after_init),