Add esp:partition_mmap/3

Signed-off-by: Paul Guyot <[email protected]>

Author: pguyot

src/platforms/esp32/components/avm_sys/include/esp32_sys.h

@@ -84,6 +84,7 @@ struct ESP32PlatformData
 #ifdef CONFIG_AVM_ENABLE_STORAGE_NIFS
     ErlNifResourceType *mounted_fs_resource_type;
 #endif
+    ErlNifResourceType *partition_mmap_resource_type;
 };
 
 extern QueueSetHandle_t event_set;

src/platforms/esp32/components/avm_sys/platform_nifs.c

@@ -25,6 +25,8 @@
 #include "atom.h"
 #include "defaultatoms.h"
 #include "esp32_sys.h"
+#include "erl_nif.h"
+#include "erl_nif_priv.h"
 #include "interop.h"
 #include "memory.h"
 #include "nifs.h"
@@ -270,7 +272,7 @@ static term nif_esp_partition_read(Context *ctx, int argc, term argv[])
         RAISE_ERROR(BADARG_ATOM);
     }
 
-    if (UNLIKELY(memory_ensure_free_opt(ctx, term_binary_data_size_in_terms(size) + BINARY_HEADER_SIZE, MEMORY_CAN_SHRINK) != MEMORY_GC_OK)) {
+    if (UNLIKELY(memory_ensure_free_opt(ctx, term_binary_data_size_in_terms(size) + BINARY_HEADER_SIZE + TUPLE_SIZE(2), MEMORY_CAN_SHRINK) != MEMORY_GC_OK)) {
         RAISE_ERROR(OUT_OF_MEMORY_ATOM);
     }
 
@@ -289,6 +291,52 @@ static term nif_esp_partition_read(Context *ctx, int argc, term argv[])
     return result;
 }
 
+static term nif_esp_partition_mmap(Context *ctx, int argc, term argv[])
+{
+    UNUSED(argc);
+
+    bool valid_partition_string;
+    const esp_partition_t *partition = get_partition(argv[0], &valid_partition_string);
+    if (UNLIKELY(!valid_partition_string)) {
+        RAISE_ERROR(BADARG_ATOM);
+    }
+    if (IS_NULL_PTR(partition)) {
+        return ERROR_ATOM;
+    }
+
+    VALIDATE_VALUE(argv[1], term_is_integer);
+    avm_int_t offset = term_to_int(argv[1]);
+
+    VALIDATE_VALUE(argv[2], term_is_integer);
+    avm_int_t size = term_to_int(argv[2]);
+    if (UNLIKELY(size < 0)) {
+        RAISE_ERROR(BADARG_ATOM);
+    }
+
+    struct ESP32PlatformData *platform = ctx->global->platform_data;
+    esp_partition_mmap_handle_t *handle = enif_alloc_resource(platform->partition_mmap_resource_type, sizeof(esp_partition_mmap_handle_t));
+    const void *mmap_ptr;
+    esp_err_t res = esp_partition_mmap(partition, offset, size, ESP_PARTITION_MMAP_DATA, &mmap_ptr, handle);
+    if (UNLIKELY(res != ESP_OK)) {
+        enif_release_resource(handle);
+        return ERROR_ATOM;
+    }
+
+    ErlNifEnv *env = erl_nif_env_from_context(ctx);
+    ERL_NIF_TERM binary = enif_make_resource_binary(env, handle, mmap_ptr, size);
+    enif_release_resource(handle);
+
+    if (UNLIKELY(memory_ensure_free_with_roots(ctx, TUPLE_SIZE(2), 1, &binary, MEMORY_CAN_SHRINK) != MEMORY_GC_OK)) {
+        RAISE_ERROR(OUT_OF_MEMORY_ATOM);
+    }
+
+    term result = term_alloc_tuple(2, &ctx->heap);
+    term_put_tuple_element(result, 0, OK_ATOM);
+    term_put_tuple_element(result, 1, binary);
+
+    return result;
+}
+
 static term nif_esp_partition_write(Context *ctx, int argc, term argv[])
 {
     UNUSED(argc);
@@ -881,6 +929,10 @@ static const struct Nif esp_partition_read_nif = {
     .base.type = NIFFunctionType,
     .nif_ptr = nif_esp_partition_read
 };
+static const struct Nif esp_partition_mmap_nif = {
+    .base.type = NIFFunctionType,
+    .nif_ptr = nif_esp_partition_mmap
+};
 static const struct Nif esp_partition_write_nif =
 {
     .base.type = NIFFunctionType,
@@ -1029,6 +1081,10 @@ const struct Nif *platform_nifs_get_nif(const char *nifname)
         TRACE("Resolved platform nif %s ...\n", nifname);
         return &esp_partition_read_nif;
     }
+    if (strcmp("esp:partition_mmap/3", nifname) == 0) {
+        TRACE("Resolved platform nif %s ...\n", nifname);
+        return &esp_partition_mmap_nif;
+    }
     if (strcmp("esp:partition_write/3", nifname) == 0) {
         TRACE("Resolved platform nif %s ...\n", nifname);
         return &esp_partition_write_nif;

src/platforms/esp32/components/avm_sys/sys.c

@@ -23,6 +23,8 @@
 
 #include "avmpack.h"
 #include "defaultatoms.h"
+#include "erl_nif.h"
+#include "erl_nif_priv.h"
 #include "globalcontext.h"
 #include "otp_socket.h"
 #include "scheduler.h"
@@ -206,6 +208,18 @@ uint64_t sys_monotonic_time_u64_to_ms(uint64_t t)
     return t / 1000;
 }
 
+static void partition_mmap_dtor(ErlNifEnv *caller_env, void *obj)
+{
+    UNUSED(caller_env);
+    esp_partition_mmap_handle_t *handle = (esp_partition_mmap_handle_t *) obj;
+    esp_partition_munmap(*handle);
+}
+
+const ErlNifResourceTypeInit partition_mmap_resource_type_init = {
+    .members = 1,
+    .dtor = partition_mmap_dtor,
+};
+
 void sys_init_platform(GlobalContext *glb)
 {
     struct ESP32PlatformData *platform = malloc(sizeof(struct ESP32PlatformData));
@@ -270,6 +284,17 @@ void sys_init_platform(GlobalContext *glb)
 
     platform->entropy_is_initialized = false;
     platform->random_is_initialized = false;
+
+    ErlNifResourceFlags flags;
+    ErlNifEnv env;
+    erl_nif_env_partial_init_from_globalcontext(&env, glb);
+    platform->partition_mmap_resource_type = enif_init_resource_type(&env, "partition_mmap", &partition_mmap_resource_type_init, ERL_NIF_RT_CREATE, &flags);
+    if (UNLIKELY(flags != ERL_NIF_RT_CREATE)) {
+        AVM_ABORT();
+    }
+    if (IS_NULL_PTR(platform->partition_mmap_resource_type)) {
+        AVM_ABORT();
+    }
 }
 
 void sys_free_platform(GlobalContext *glb)
@@ -360,6 +385,13 @@ enum OpenAVMResult sys_open_avm_from_file(GlobalContext *global, const char *pat
         spi_flash_mmap_handle_t part_handle;
         int size;
         const char *part_name = path + parts_by_name_len;
+        const esp_partition_t *partition = esp_partition_find_first(ESP_PARTITION_TYPE_DATA, ESP_PARTITION_SUBTYPE_ANY, part_name);
+        if (!partition) {
+            ESP_LOGW(TAG, "AVM partition not found for %s", part_name);
+            return AVM_OPEN_CANNOT_OPEN;
+        }
+        size = partition->size;
+
         const void *part_data = esp32_sys_mmap_partition(part_name, &part_handle, &size);
         if (IS_NULL_PTR(part_data)) {
             return AVM_OPEN_CANNOT_OPEN;

src/platforms/esp32/test/main/test_erl_sources/test_esp_partition.erl

@@ -27,6 +27,15 @@ start() ->
         {<<"phy_init">>, 1, 1, 16#f000, 16#1000, []},
         {<<"factory">>, 0, 0, 16#10000, 16#2C0000, []},
         {<<"lib.avm">>, 1, 1, 16#2D0000, 16#40000, []},
-        {<<"main.avm">>, 1, 1, 16#310000, 16#40000, []}
+        {<<"main.avm">>, 1, 1, 16#310000, 16#40000, []},
+        {<<"data">>, 1, 1, 16#350000, 16#10000, []}
     ] = esp:partition_list(),
+    ok = esp:partition_erase_range(<<"data">>, 0),
+    ok = esp:partition_write(<<"data">>, 0, <<"hello">>),
+    {ok, <<"hello">>} = esp:partition_read(<<"data">>, 0, 5),
+    {ok, <<"hello">>} = esp:partition_mmap(<<"data">>, 0, 5),
+    ok = esp:partition_erase_range(<<"data">>, 0, 4096),
+    ok = esp:partition_write(<<"data">>, 0, <<"world">>),
+    {ok, <<"world">>} = esp:partition_read(<<"data">>, 0, 5),
+    {ok, <<"world">>} = esp:partition_mmap(<<"data">>, 0, 5),
     0.

src/platforms/esp32/test/partitions.csv

@@ -12,4 +12,5 @@ nvs,      data, nvs,       0x9000,     0x6000,
 phy_init, data, phy,       0xf000,     0x1000,
 factory,  app,  factory,  0x10000,   0x2C0000,
 lib.avm,  data, phy,     0x2D0000,    0x40000,
-main.avm, data, phy,     0x310000,    0x40000
+main.avm, data, phy,     0x310000,    0x40000,
+data,     data, phy,     0x350000,    0x10000