Update a few memory functions to log their inputs and outputs. To avoid
the use of 'goto', etc. the functions are turned into stubs, calling a
separate function to do the actual operation.

Add a few tests.

Signed-off-by: Simon Glass <s...@chromium.org>
---

(no changes since v1)

 include/efi_log.h           | 147 ++++++++++++++++++++++++++++
 lib/efi_loader/efi_log.c    | 189 ++++++++++++++++++++++++++++++++++++
 lib/efi_loader/efi_memory.c |  66 +++++++++++--
 test/lib/efi_log.c          |  44 +++++++++
 4 files changed, 439 insertions(+), 7 deletions(-)

diff --git a/include/efi_log.h b/include/efi_log.h
index 1988e5f9df0..a4b707e57c5 100644
--- a/include/efi_log.h
+++ b/include/efi_log.h
@@ -16,6 +16,11 @@
  * enum efil_tag - Types of logging records which can be created
  */
 enum efil_tag {
+       EFILT_ALLOCATE_PAGES,
+       EFILT_FREE_PAGES,
+       EFILT_ALLOCATE_POOL,
+       EFILT_FREE_POOL,
+
        EFILT_TESTING,
 
        EFILT_COUNT,
@@ -80,6 +85,28 @@ struct efil_allocate_pages {
        u64 e_memory;
 };
 
+/** struct efil_free_pages - holds info from efi_free_pages() call */
+struct efil_free_pages {
+       u64 memory;
+       efi_uintn_t pages;
+};
+
+/** struct efil_allocate_pool - holds info from efi_allocate_pool() call
+ *
+ * @e_buffer: Contains the value of *@buffer on return from the EFI function
+ */
+struct efil_allocate_pool {
+       enum efi_memory_type pool_type;
+       efi_uintn_t size;
+       void **buffer;
+       void *e_buffer;
+};
+
+/** struct efil_free_pool - holds log-info from efi_free_pool() call */
+struct efil_free_pool {
+       void *buffer;
+};
+
 /*
  * The functions below are in pairs, with a 'start' and 'end' call for each EFI
  * function. The 'start' function (efi_logs_...) is called when the function is
@@ -123,8 +150,128 @@ int efi_logs_testing(enum efil_test_t enum_val, 
efi_uintn_t int_value,
  */
 int efi_loge_testing(int ofs, efi_status_t efi_ret);
 
+/**
+ * efi_logs_allocate_pages() - Record a call to efi_allocate_pages()
+ *
+ * @type:              type of allocation to be performed
+ * @memory_type:       usage type of the allocated memory
+ * @pages:             number of pages to be allocated
+ * @memory:            place to write address of allocated memory
+ * Return:             log-offset of this new record, or -ve error code
+ */
+int efi_logs_allocate_pages(enum efi_allocate_type type,
+                           enum efi_memory_type memory_type, efi_uintn_t pages,
+                           u64 *memory);
+
+/**
+ * efi_loge_allocate_pages() - Record a return from efi_allocate_pages()
+ *
+ * This stores the value of the memory pointer also
+ *
+ * ofs: Offset of the record to end
+ * efi_ret: status code to record
+ */
+int efi_loge_allocate_pages(int ofs, efi_status_t efi_ret);
+
+/**
+ * efi_logs_free_pages() - Record a call to efi_free_pages()
+ *
+ * @memory:    start of the memory area to be freed
+ * @pages:     number of pages to be freed
+ * Return:     log-offset of this new record, or -ve error code
+ */
+int efi_logs_free_pages(u64 memory, efi_uintn_t pages);
+
+/**
+ * efi_loge_free_pages() - Record a return from efi_free_pages()
+ *
+ * ofs: Offset of the record to end
+ * efi_ret: status code to record
+ */
+int efi_loge_free_pages(int ofs, efi_status_t efi_ret);
+
+/**
+ * efi_logs_allocate_pool() - Record a call to efi_allocate_pool()
+ *
+ * @pool_type: type of the pool from which memory is to be allocated
+ * @size:      number of bytes to be allocated
+ * @buffer:    place to hold pointer to allocated memory
+ * Return:     log-offset of this new record, or -ve error code
+ */
+int efi_logs_allocate_pool(enum efi_memory_type pool_type, efi_uintn_t size,
+                          void **buffer);
+
+/**
+ * efi_loge_allocate_pool() - Record a return from efi_allocate_pool()
+ *
+ * This stores the value of the buffer pointer also
+ *
+ * ofs: Offset of the record to end
+ * efi_ret: status code to record
+ */
+int efi_loge_allocate_pool(int ofs, efi_status_t efi_ret);
+
+/**
+ * efi_logs_free_pool() - Record a call to efi_free_pool()
+ *
+ * @buffer:    start of memory to be freed
+ * Return:     log-offset of this new record, or -ve error code
+ */
+int efi_logs_free_pool(void *buffer);
+
+/**
+ * efi_loge_free_pool() - Record a return from efi_free_pool()
+ *
+ * ofs: Offset of the record to end
+ * efi_ret: status code to record
+ */
+int efi_loge_free_pool(int ofs, efi_status_t efi_ret);
+
 #else /* !EFI_LOG */
 
+static inline int efi_logs_allocate_pages(enum efi_allocate_type type,
+                                         enum efi_memory_type memory_type,
+                                         efi_uintn_t pages, u64 *memory)
+{
+       return -ENOSYS;
+}
+
+static inline int efi_loge_allocate_pages(int ofs, efi_status_t efi_ret)
+{
+       return -ENOSYS;
+}
+
+static inline int efi_logs_free_pages(u64 memory, efi_uintn_t pages)
+{
+       return -ENOSYS;
+}
+
+static inline int efi_loge_free_pages(int ofs, efi_status_t efi_ret)
+{
+       return -ENOSYS;
+}
+
+static inline int efi_logs_allocate_pool(enum efi_memory_type pool_type,
+                                        efi_uintn_t size, void **buffer)
+{
+       return -ENOSYS;
+}
+
+static inline int efi_loge_allocate_pool(int ofs, efi_status_t efi_ret)
+{
+       return -ENOSYS;
+}
+
+static inline int efi_logs_free_pool(void *buffer)
+{
+       return -ENOSYS;
+}
+
+static inline int efi_loge_free_pool(int ofs, efi_status_t efi_ret)
+{
+       return -ENOSYS;
+}
+
 static inline int efi_logs_testing(enum efil_test_t enum_val,
                                   efi_uintn_t int_value, void *buffer,
                                   u64 *memory)
diff --git a/lib/efi_loader/efi_log.c b/lib/efi_loader/efi_log.c
index 780860d8b2f..4b9c6727fe7 100644
--- a/lib/efi_loader/efi_log.c
+++ b/lib/efi_loader/efi_log.c
@@ -15,9 +15,41 @@
 
 /* names for enum efil_tag (abbreviated to keep output to a single line) */
 static const char *tag_name[EFILT_COUNT] = {
+       "alloc_pages",
+       "free_pages",
+       "alloc_pool",
+       "free_pool",
+
        "testing",
 };
 
+/* names for enum efi_allocate_type  */
+static const char *allocate_type_name[EFI_MAX_ALLOCATE_TYPE] = {
+       "any-pages",
+       "max-addr",
+       "alloc-addr",
+};
+
+/* names for enum efi_memory_type */
+static const char *memory_type_name[EFI_MAX_MEMORY_TYPE] = {
+       "reserved",
+       "ldr-code",
+       "ldr-data",
+       "bt-code",
+       "bt-data",
+       "rt-code",
+       "rt-data",
+       "convent",
+       "unusable",
+       "acpi-rec",
+       "acpi-nvs",
+       "mmap-io",
+       "mmap-iop",
+       "pal-code",
+       "persist",
+       "unaccept",
+};
+
 /* names for error codes, trying to keep them short */
 static const char *error_name[EFI_ERROR_COUNT] = {
        "OK",
@@ -152,6 +184,119 @@ int efi_loge_testing(int ofs, efi_status_t efi_ret)
        return 0;
 }
 
+int efi_logs_allocate_pages(enum efi_allocate_type type,
+                           enum efi_memory_type memory_type, efi_uintn_t pages,
+                           u64 *memory)
+{
+       struct efil_allocate_pages *rec;
+       int ret;
+
+       ret = prep_rec(EFILT_ALLOCATE_PAGES, sizeof(*rec), (void **)&rec);
+       if (ret < 0)
+               return ret;
+
+       rec->type = type;
+       rec->memory_type = memory_type;
+       rec->pages = pages;
+       rec->memory = memory;
+       rec->e_memory = 0;
+
+       return ret;
+}
+
+int efi_loge_allocate_pages(int ofs, efi_status_t efi_ret)
+{
+       struct efil_allocate_pages *rec;
+
+       rec = finish_rec(ofs, efi_ret);
+       if (!rec)
+               return -ENOSPC;
+       rec->e_memory = *rec->memory;
+
+       return 0;
+}
+
+int efi_logs_free_pages(u64 memory, efi_uintn_t pages)
+{
+       struct efil_free_pages *rec;
+       int ret;
+
+       ret = prep_rec(EFILT_FREE_PAGES, sizeof(*rec), (void **)&rec);
+       if (ret < 0)
+               return ret;
+
+       rec->memory = memory;
+       rec->pages = pages;
+
+       return ret;
+}
+
+int efi_loge_free_pages(int ofs, efi_status_t efi_ret)
+{
+       struct efil_allocate_pages *rec;
+
+       rec = finish_rec(ofs, efi_ret);
+       if (!rec)
+               return -ENOSPC;
+
+       return 0;
+}
+
+int efi_logs_allocate_pool(enum efi_memory_type pool_type, efi_uintn_t size,
+                          void **buffer)
+{
+       struct efil_allocate_pool *rec;
+       int ret;
+
+       ret = prep_rec(EFILT_ALLOCATE_POOL, sizeof(*rec), (void **)&rec);
+       if (ret < 0)
+               return ret;
+
+       rec->pool_type = pool_type;
+       rec->size = size;
+       rec->buffer = buffer;
+       rec->e_buffer = NULL;
+
+       return ret;
+}
+
+int efi_loge_allocate_pool(int ofs, efi_status_t efi_ret)
+{
+       struct efil_allocate_pool *rec;
+
+       rec = finish_rec(ofs, efi_ret);
+       if (!rec)
+               return -ENOSPC;
+       rec->e_buffer = *rec->buffer;
+
+       return 0;
+}
+
+int efi_logs_free_pool(void *buffer)
+{
+       struct efil_free_pool *rec;
+       int ret;
+
+       ret = prep_rec(EFILT_FREE_POOL, sizeof(*rec), (void **)&rec);
+       if (ret < 0)
+               return ret;
+
+       rec->buffer = buffer;
+
+       return ret;
+}
+
+int efi_loge_free_pool(int ofs, efi_status_t efi_ret)
+{
+       struct efil_free_pool *rec;
+
+       rec = finish_rec(ofs, efi_ret);
+       if (!rec)
+               return -ENOSPC;
+
+       return 0;
+}
+
 static void show_enum(const char *type_name[], int type)
 {
        printf("%s ", type_name[type]);
@@ -187,6 +332,50 @@ void show_rec(int seq, struct efil_rec_hdr *rec_hdr)
 
        printf("%3d %12s ", seq, tag_name[rec_hdr->tag]);
        switch (rec_hdr->tag) {
+       case EFILT_ALLOCATE_PAGES: {
+               struct efil_allocate_pages *rec = start;
+
+               show_enum(allocate_type_name, rec->type);
+               show_enum(memory_type_name, rec->memory_type);
+               show_ulong("pgs", (ulong)rec->pages);
+               show_addr("mem", (ulong)rec->memory);
+               if (rec_hdr->ended) {
+                       show_addr("*mem",
+                                 (ulong)map_to_sysmem((void *)rec->e_memory));
+                       show_ret(rec_hdr->e_ret);
+               }
+               break;
+       }
+       case EFILT_FREE_PAGES: {
+               struct efil_free_pages *rec = start;
+
+               show_addr("mem", map_to_sysmem((void *)rec->memory));
+               show_ulong("pag", (ulong)rec->pages);
+               if (rec_hdr->ended)
+                       show_ret(rec_hdr->e_ret);
+               break;
+       }
+       case EFILT_ALLOCATE_POOL: {
+               struct efil_allocate_pool *rec = start;
+
+               show_enum(memory_type_name, rec->pool_type);
+               show_ulong("size", (ulong)rec->size);
+               show_addr("buf", (ulong)rec->buffer);
+               if (rec_hdr->ended) {
+                       show_addr("*buf",
+                                 (ulong)map_to_sysmem((void *)rec->e_buffer));
+                       show_ret(rec_hdr->e_ret);
+               }
+               break;
+       }
+       case EFILT_FREE_POOL: {
+               struct efil_free_pool *rec = start;
+
+               show_addr("buf", map_to_sysmem(rec->buffer));
+               if (rec_hdr->ended)
+                       show_ret(rec_hdr->e_ret);
+               break;
+       }
        case EFILT_TESTING: {
                struct efil_testing *rec = start;
 
diff --git a/lib/efi_loader/efi_memory.c b/lib/efi_loader/efi_memory.c
index 5a6794652d1..d77243e54b2 100644
--- a/lib/efi_loader/efi_memory.c
+++ b/lib/efi_loader/efi_memory.c
@@ -8,6 +8,7 @@
 #define LOG_CATEGORY LOGC_EFI
 
 #include <efi_loader.h>
+#include <efi_log.h>
 #include <init.h>
 #include <lmb.h>
 #include <log.h>
@@ -429,9 +430,9 @@ static efi_status_t efi_check_allocated(u64 addr, bool 
must_be_allocated)
        return EFI_NOT_FOUND;
 }
 
-efi_status_t efi_allocate_pages(enum efi_allocate_type type,
-                               enum efi_memory_type mem_type,
-                               efi_uintn_t pages, uint64_t *memoryp)
+static efi_status_t efi_allocate_pages_(enum efi_allocate_type type,
+                                       enum efi_memory_type mem_type,
+                                       efi_uintn_t pages, uint64_t *memoryp)
 {
        u64 len;
        uint flags;
@@ -491,7 +492,21 @@ efi_status_t efi_allocate_pages(enum efi_allocate_type 
type,
        return EFI_SUCCESS;
 }
 
-efi_status_t efi_free_pages(uint64_t memory, efi_uintn_t pages)
+efi_status_t efi_allocate_pages(enum efi_allocate_type type,
+                               enum efi_memory_type memory_type,
+                               efi_uintn_t pages, uint64_t *memory)
+{
+       efi_status_t ret;
+       int ofs;
+
+       ofs = efi_logs_allocate_pages(type, memory_type, pages, memory);
+       ret = efi_allocate_pages_(type, memory_type, pages, memory);
+       efi_loge_allocate_pages(ofs, ret);
+
+       return ret;
+}
+
+static efi_status_t efi_free_pages_(uint64_t memory, efi_uintn_t pages)
 {
        u64 len;
        long status;
@@ -516,6 +531,18 @@ efi_status_t efi_free_pages(uint64_t memory, efi_uintn_t 
pages)
        return ret;
 }
 
+efi_status_t efi_free_pages(u64 memory, efi_uintn_t pages)
+{
+       efi_status_t ret;
+       int ofs;
+
+       ofs = efi_logs_free_pages(memory, pages);
+       ret = efi_free_pages_(memory, pages);
+       efi_loge_free_pages(ofs, ret);
+
+       return ret;
+}
+
 void *efi_alloc_aligned_pages(u64 len, enum efi_memory_type mem_type,
                              size_t align)
 {
@@ -561,8 +588,8 @@ void *efi_alloc_aligned_pages(u64 len, enum efi_memory_type 
mem_type,
        return map_sysmem(aligned_mem, len);
 }
 
-efi_status_t efi_allocate_pool(enum efi_memory_type mem_type, efi_uintn_t size,
-                              void **buffer)
+static efi_status_t efi_allocate_pool_(enum efi_memory_type mem_type,
+                                      efi_uintn_t size, void **buffer)
 {
        efi_status_t r;
        u64 addr;
@@ -590,6 +617,19 @@ efi_status_t efi_allocate_pool(enum efi_memory_type 
mem_type, efi_uintn_t size,
        return r;
 }
 
+efi_status_t efi_allocate_pool(enum efi_memory_type pool_type, efi_uintn_t 
size,
+                              void **buffer)
+{
+       efi_status_t ret;
+       int ofs;
+
+       ofs = efi_logs_allocate_pool(pool_type, size, buffer);
+       ret = efi_allocate_pool_(pool_type, size, buffer);
+       efi_loge_allocate_pool(ofs, ret);
+
+       return ret;
+}
+
 void *efi_alloc(size_t size)
 {
        void *buf;
@@ -604,7 +644,7 @@ void *efi_alloc(size_t size)
        return buf;
 }
 
-efi_status_t efi_free_pool(void *buffer)
+static efi_status_t efi_free_pool_(void *buffer)
 {
        efi_status_t ret;
        struct efi_pool_allocation *alloc;
@@ -632,6 +672,18 @@ efi_status_t efi_free_pool(void *buffer)
        return ret;
 }
 
+efi_status_t efi_free_pool(void *buffer)
+{
+       efi_status_t ret;
+       int ofs;
+
+       ofs = efi_logs_free_pool(buffer);
+       ret = efi_free_pool_(buffer);
+       efi_loge_free_pool(ofs, ret);
+
+       return ret;
+}
+
 /**
  * efi_get_memory_map() - get map describing memory usage.
  *
diff --git a/test/lib/efi_log.c b/test/lib/efi_log.c
index 414b7081bd9..7c8f1cbcd06 100644
--- a/test/lib/efi_log.c
+++ b/test/lib/efi_log.c
@@ -47,3 +47,47 @@ static int lib_test_efi_log_base(struct unit_test_state *uts)
        return 0;
 }
 LIB_TEST(lib_test_efi_log_base, UTF_CONSOLE);
+
+/* test the memory-function logging */
+static int lib_test_efi_log_mem(struct unit_test_state *uts)
+{
+       void **buf = map_sysmem(0x1000, 0);
+       u64 *addr = map_sysmem(0x1010, 0);
+       int ofs1, ofs2;
+
+       ut_assertok(efi_log_reset());
+
+       ofs1 = efi_logs_allocate_pool(EFI_BOOT_SERVICES_DATA, 100, buf);
+       ofs2 = efi_logs_allocate_pages(EFI_ALLOCATE_ANY_PAGES,
+                                      EFI_BOOT_SERVICES_CODE, 10, addr);
+       ut_assertok(efi_loge_allocate_pages(ofs2, EFI_LOAD_ERROR));
+       ut_assertok(efi_loge_allocate_pool(ofs1, 0));
+
+       ofs1 = efi_logs_free_pool(*buf);
+       ut_assertok(efi_loge_free_pool(ofs1, EFI_INVALID_PARAMETER));
+
+       ofs2 = efi_logs_free_pages(*addr, 0);
+       ut_assertok(efi_loge_free_pool(ofs2, 0));
+
+       ut_assertok(efi_log_show());
+
+       ut_assert_nextline("EFI log (size c0)");
+
+       /*
+        * We end up with internal sandbox-addresses here since EFI_LOADER
+        * doesn't handle map_sysmem() correctly. So for now, only part of the
+        * string is matched.
+        */
+       ut_assert_nextlinen("  0   alloc_pool bt-data size 64/100 buf 10002000 
*buf");
+       ut_assert_nextlinen("  1  alloc_pages any-pages bt-code pgs a/10 mem 
10002010 *mem");
+       ut_assert_nextlinen("  2    free_pool buf");
+       ut_assert_nextlinen("  3   free_pages mem");
+
+       ut_assert_nextline("4 records");
+
+       unmap_sysmem(buf);
+       unmap_sysmem(addr);
+
+       return 0;
+}
+LIB_TEST(lib_test_efi_log_mem, UTF_CONSOLE);
-- 
2.34.1

Reply via email to