Automaticly generate psa_crypto_driver_wrappers_no_static.c

Signed-off-by: Xiaokang Qian <xiaokang.qian@arm.com>

library/Makefile

@@ -354,10 +354,13 @@ version_features.c:
 	echo "  Gen   $@"
 	$(PERL) ../scripts/generate_features.pl
 
-psa_crypto_driver_wrappers.c: $(gen_file_dep) ../scripts/generate_driver_wrappers.py
+GENERATED_WRAPPER_FILES = \
-psa_crypto_driver_wrappers.c: $(gen_file_dep) ../scripts/data_files/driver_templates/psa_crypto_driver_wrappers.c.jinja
+                    psa_crypto_driver_wrappers.c \
-psa_crypto_driver_wrappers.c:
+                    psa_crypto_driver_wrappers_no_static.c
-	echo "  Gen   $@"
+$(GENERATED_WRAPPER_FILES): ../scripts/generate_driver_wrappers.py
+$(GENERATED_WRAPPER_FILES): ../scripts/data_files/driver_templates/psa_crypto_driver_wrappers.c.jinja
+$(GENERATED_WRAPPER_FILES):
+	echo "  Gen   $(GENERATED_WRAPPER_FILES)"
 	$(PYTHON) ../scripts/generate_driver_wrappers.py
 
 clean:

scripts/data_files/driver_templates/psa_crypto_driver_wrappers_no_static.c.jinja

@@ -37,17 +37,18 @@
 #if defined(MBEDTLS_PSA_CRYPTO_C)
 
 /* BEGIN-driver headers */
-/* Headers for mbedtls_test opaque driver */
+{% for driver in drivers -%}
-#if defined(PSA_CRYPTO_DRIVER_TEST)
+/* Headers for {{driver.prefix}} {{driver.type}} driver */
-#include "test/drivers/test_driver.h"
+{% if driver['mbedtls/h_condition'] is defined -%}
-
+#if {{ driver['mbedtls/h_condition'] }}
+{% endif -%}
+{% for header in driver.headers -%}
+#include "{{ header }}"
+{% endfor %}
+{% if driver['mbedtls/h_condition'] is defined -%}
 #endif
-/* Headers for mbedtls_test transparent driver */
+{% endif -%}
-#if defined(PSA_CRYPTO_DRIVER_TEST)
+{% endfor %}
-#include "test/drivers/test_driver.h"
-
-#endif
-
 /* END-driver headers */
 
 /* Auto-generated values depending on which drivers are registered.
@@ -55,13 +56,19 @@
  * ID 1 is reserved for the Mbed TLS software driver. */
 /* BEGIN-driver id definition */
 #define PSA_CRYPTO_MBED_TLS_DRIVER_ID (1)
-#define MBEDTLS_TEST_OPAQUE_DRIVER_ID (2)
+{% for driver in drivers -%}
-#define MBEDTLS_TEST_TRANSPARENT_DRIVER_ID (3)
+#define {{(driver.prefix + "_" + driver.type + "_driver_id").upper()}} ({{ loop.index + 1 }})
-
+{% endfor %}
 /* END-driver id */
 
 /* BEGIN-Common Macro definitions */
-
+{% macro entry_point_name(capability, entry_point, driver) -%}
+    {% if capability.name is defined and entry_point in capability.names.keys() -%}
+    {{ capability.names[entry_point]}}
+    {% else -%}
+    {{driver.prefix}}_{{driver.type}}_{{entry_point}}
+    {% endif -%}
+{% endmacro %}
 /* END-Common Macro definitions */
 
 /* Support the 'old' SE interface when asked to */
@@ -74,88 +81,6 @@
 #include "psa_crypto_se.h"
 #endif
 
-
-psa_status_t psa_driver_wrapper_export_public_key(
-    const psa_key_attributes_t *attributes,
-    const uint8_t *key_buffer, size_t key_buffer_size,
-    uint8_t *data, size_t data_size, size_t *data_length)
-
-{
-
-    psa_status_t status = PSA_ERROR_INVALID_ARGUMENT;
-    psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION(
-        psa_get_key_lifetime(attributes));
-
-    /* Try dynamically-registered SE interface first */
-#if defined(MBEDTLS_PSA_CRYPTO_SE_C)
-    const psa_drv_se_t *drv;
-    psa_drv_se_context_t *drv_context;
-
-    if (psa_get_se_driver(attributes->core.lifetime, &drv, &drv_context)) {
-        if ((drv->key_management == NULL) ||
-            (drv->key_management->p_export_public == NULL)) {
-            return PSA_ERROR_NOT_SUPPORTED;
-        }
-
-        return drv->key_management->p_export_public(
-            drv_context,
-            *((psa_key_slot_number_t *) key_buffer),
-            data, data_size, data_length);
-    }
-#endif /* MBEDTLS_PSA_CRYPTO_SE_C */
-
-    switch (location) {
-        case PSA_KEY_LOCATION_LOCAL_STORAGE:
-            /* Key is stored in the slot in export representation, so
-             * cycle through all known transparent accelerators */
-#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
-
-#if (defined(PSA_CRYPTO_DRIVER_TEST))
-            status = mbedtls_test_transparent_export_public_key(
-                attributes,
-                key_buffer,
-                key_buffer_size,
-                data,
-                data_size,
-                data_length);
-
-            if (status != PSA_ERROR_NOT_SUPPORTED) {
-                return status;
-            }
-#endif
-
-
-#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
-            /* Fell through, meaning no accelerator supports this operation */
-            return psa_export_public_key_internal(attributes,
-                                                  key_buffer,
-                                                  key_buffer_size,
-                                                  data,
-                                                  data_size,
-                                                  data_length);
-
-            /* Add cases for opaque driver here */
-#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
-
-#if (defined(PSA_CRYPTO_DRIVER_TEST))
-        case 0x7fffff:
-            return mbedtls_test_opaque_export_public_key(attributes,
-                                                         key_buffer,
-                                                         key_buffer_size,
-                                                         data,
-                                                         data_size,
-                                                         data_length);
-#endif
-
-
-#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
-        default:
-            /* Key is declared with a lifetime not known to us */
-            return status;
-    }
-
-}
-
 /** Get the key buffer size required to store the key material of a key
  *  associated with an opaque driver.
  *
@@ -171,71 +96,142 @@ psa_status_t psa_driver_wrapper_export_public_key(
  * \retval #PSA_ERROR_INVALID_ARGUMENT
  *         The key is declared with a lifetime not known to us.
  */
-
 psa_status_t psa_driver_wrapper_get_key_buffer_size(
     const psa_key_attributes_t *attributes,
-    size_t *key_buffer_size)
+    size_t *key_buffer_size )
 {
-    psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION(attributes->core.lifetime);
+    psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION( attributes->core.lifetime );
     psa_key_type_t key_type = attributes->core.type;
     size_t key_bits = attributes->core.bits;
 
     *key_buffer_size = 0;
-    switch (location) {
+    switch( location )
+    {
 #if defined(PSA_CRYPTO_DRIVER_TEST)
         case PSA_CRYPTO_TEST_DRIVER_LOCATION:
 #if defined(MBEDTLS_PSA_CRYPTO_BUILTIN_KEYS)
             /* Emulate property 'builtin_key_size' */
-            if (psa_key_id_is_builtin(
+            if( psa_key_id_is_builtin(
                     MBEDTLS_SVC_KEY_ID_GET_KEY_ID(
-                        psa_get_key_id(attributes)))) {
+                        psa_get_key_id( attributes ) ) ) )
-                *key_buffer_size = sizeof(psa_drv_slot_number_t);
+            {
-                return PSA_SUCCESS;
+                *key_buffer_size = sizeof( psa_drv_slot_number_t );
+                return( PSA_SUCCESS );
             }
 #endif /* MBEDTLS_PSA_CRYPTO_BUILTIN_KEYS */
-            *key_buffer_size = mbedtls_test_opaque_size_function(key_type,
+            *key_buffer_size = mbedtls_test_opaque_size_function( key_type,
-                                                                 key_bits);
+                                                                  key_bits );
-            return (*key_buffer_size != 0) ?
+            return( ( *key_buffer_size != 0 ) ?
-                   PSA_SUCCESS : PSA_ERROR_NOT_SUPPORTED;
+                    PSA_SUCCESS : PSA_ERROR_NOT_SUPPORTED );
 #endif /* PSA_CRYPTO_DRIVER_TEST */
 
         default:
-            (void) key_type;
+            (void)key_type;
-            (void) key_bits;
+            (void)key_bits;
-            return PSA_ERROR_INVALID_ARGUMENT;
+            return( PSA_ERROR_INVALID_ARGUMENT );
     }
 }
 
+psa_status_t psa_driver_wrapper_export_public_key(
+    const psa_key_attributes_t *attributes,
+    const uint8_t *key_buffer, size_t key_buffer_size,
+    uint8_t *data, size_t data_size, size_t *data_length )
+
+{
+{% with entry_point = "export_public_key" -%}
+{% macro entry_point_param(driver) -%}
+attributes,
+key_buffer,
+key_buffer_size,
+data,
+data_size,
+data_length
+{% endmacro %}
+    psa_status_t status = PSA_ERROR_INVALID_ARGUMENT;
+    psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION(
+                                      psa_get_key_lifetime( attributes ) );
+
+    /* Try dynamically-registered SE interface first */
+#if defined(MBEDTLS_PSA_CRYPTO_SE_C)
+    const psa_drv_se_t *drv;
+    psa_drv_se_context_t *drv_context;
+
+    if( psa_get_se_driver( attributes->core.lifetime, &drv, &drv_context ) )
+    {
+        if( ( drv->key_management == NULL ) ||
+            ( drv->key_management->p_export_public == NULL ) )
+        {
+            return( PSA_ERROR_NOT_SUPPORTED );
+        }
+
+        return( drv->key_management->p_export_public(
+                    drv_context,
+                    *( (psa_key_slot_number_t *)key_buffer ),
+                    data, data_size, data_length ) );
+    }
+#endif /* MBEDTLS_PSA_CRYPTO_SE_C */
+
+    switch( location )
+    {
+        case PSA_KEY_LOCATION_LOCAL_STORAGE:
+            /* Key is stored in the slot in export representation, so
+             * cycle through all known transparent accelerators */
+#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
+{% with nest_indent=12 %}
+{% include "OS-template-transparent.jinja" -%}
+{% endwith -%}
+#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
+            /* Fell through, meaning no accelerator supports this operation */
+            return( psa_export_public_key_internal( attributes,
+                                                    key_buffer,
+                                                    key_buffer_size,
+                                                    data,
+                                                    data_size,
+                                                    data_length ) );
+
+        /* Add cases for opaque driver here */
+#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
+{% with nest_indent=8 %}
+{% include "OS-template-opaque.jinja" -%}
+{% endwith -%}
+#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
+        default:
+            /* Key is declared with a lifetime not known to us */
+            return( status );
+    }
+{% endwith %}
+}
+
 psa_status_t psa_driver_wrapper_get_builtin_key(
     psa_drv_slot_number_t slot_number,
     psa_key_attributes_t *attributes,
-    uint8_t *key_buffer, size_t key_buffer_size, size_t *key_buffer_length)
+    uint8_t *key_buffer, size_t key_buffer_size, size_t *key_buffer_length )
 {
-
+{% with entry_point = "get_builtin_key" -%}
-    psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION(attributes->core.lifetime);
+{% macro entry_point_param(driver) -%}
-    switch (location) {
+slot_number,
+attributes,
+key_buffer,
+key_buffer_size,
+key_buffer_length
+{% endmacro %}
+    psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION( attributes->core.lifetime );
+    switch( location )
+    {
 #if defined(PSA_CRYPTO_DRIVER_TEST)
-
+{% with nest_indent=8 %}
-#if (defined(PSA_CRYPTO_DRIVER_TEST))
+{% include "OS-template-opaque.jinja" -%}
-        case 0x7fffff:
+{% endwith -%}
-            return mbedtls_test_opaque_get_builtin_key(
-                slot_number,
-                attributes,
-                key_buffer,
-                key_buffer_size,
-                key_buffer_length);
-#endif
-
-
 #endif /* PSA_CRYPTO_DRIVER_TEST */
         default:
             (void) slot_number;
             (void) key_buffer;
             (void) key_buffer_size;
             (void) key_buffer_length;
-            return PSA_ERROR_DOES_NOT_EXIST;
+            return( PSA_ERROR_DOES_NOT_EXIST );
     }
-
+{% endwith %}
 }
 
+
 #endif /* MBEDTLS_PSA_CRYPTO_C */

scripts/generate_driver_wrappers.py

@@ -1,9 +1,10 @@
 #!/usr/bin/env python3
-"""Generate library/psa_crypto_driver_wrappers.c
+"""Generate library/psa_crypto_driver_wrappers.h
+            library/psa_crypto_driver_wrappers_no_static.c
 
    This module is invoked by the build scripts to auto generate the
-   psa_crypto_driver_wrappers.c based on template files in
+   psa_crypto_driver_wrappers.h and psa_crypto_driver_wrappers_no_static
-   script/data_files/driver_templates/.
+   based on template files in script/data_files/driver_templates/.
 """
 # Copyright The Mbed TLS Contributors
 # SPDX-License-Identifier: Apache-2.0
@@ -59,19 +60,19 @@ def render(template_path: str, driver_jsoncontext: list) -> str:
 
     return template.render(drivers=driver_jsoncontext)
 
-
 def generate_driver_wrapper_file(template_dir: str,
                                  output_dir: str,
+                                 template_file_name: str,
                                  driver_jsoncontext: list) -> None:
     """
     Generate the file psa_crypto_driver_wrapper.c.
     """
     driver_wrapper_template_filename = \
-        os.path.join(template_dir, "psa_crypto_driver_wrappers.c.jinja")
+        os.path.join(template_dir, template_file_name)
 
     result = render(driver_wrapper_template_filename, driver_jsoncontext)
 
-    with open(file=os.path.join(output_dir, "psa_crypto_driver_wrappers.c"),
+    with open(file=os.path.join(output_dir, template_file_name.rsplit(".", 1)[0]),
               mode='w',
               encoding='UTF-8') as out_file:
         out_file.write(result)
@@ -167,6 +168,9 @@ def trace_exception(e: Exception, file=sys.stderr) -> None:
     ), file)
 
 
+TEMPLATE_FILENAMES = ["psa_crypto_driver_wrappers.c.jinja",
+                      "psa_crypto_driver_wrappers_no_static.c.jinja"]
+
 def main() -> int:
     """
     Main with command line arguments.
@@ -207,7 +211,9 @@ def main() -> int:
     except DriverReaderException as e:
         trace_exception(e)
         return 1
-    generate_driver_wrapper_file(template_directory, output_directory, merged_driver_json)
+    for template_filename in TEMPLATE_FILENAMES:
+        generate_driver_wrapper_file(template_directory, output_directory,
+                                     template_filename, merged_driver_json)
     return 0