xlat_tables_v2: get unmap action type with helper function.

This patch introduces helper function 'xlat_tables_unmap_region_action'
to get the required action type from given arguments when unmapping the
specified region.
it reduces cyclomatic code complexity in xlat_tables_unmap_region function.

Cyclomatic complexity calculated using 'Coverity'

fixes arm-software/tf-issues#673

Signed-off-by: David Pu <dpu@nvidia.com>

diff --git a/lib/xlat_tables_v2/xlat_tables_core.c b/lib/xlat_tables_v2/xlat_tables_core.c
index d7d8c220ac2f931553d9ad42ba3dced83e22443e..a39dfc93abaf1597719da785bcea0bde7b6a8ed3 100644 (file)
--- a/lib/xlat_tables_v2/xlat_tables_core.c
+++ b/lib/xlat_tables_v2/xlat_tables_core.c
@@ -233,6 +233,67 @@ typedef enum {
 
 #if PLAT_XLAT_TABLES_DYNAMIC
 
+/*
+ * From the given arguments, it decides which action to take when unmapping the
+ * specified region.
+ */
+static action_t xlat_tables_unmap_region_action(const mmap_region_t *mm,
+               const uintptr_t table_idx_va, const uintptr_t table_idx_end_va,
+               const unsigned int level, const uint64_t desc_type)
+{
+       action_t action;
+       uintptr_t region_end_va = mm->base_va + mm->size - 1U;
+
+       if ((mm->base_va <= table_idx_va) &&
+           (region_end_va >= table_idx_end_va)) {
+               /* Region covers all block */
+
+               if (level == 3U) {
+                       /*
+                        * Last level, only page descriptors allowed,
+                        * erase it.
+                        */
+                       assert(desc_type == PAGE_DESC);
+
+                       action = ACTION_WRITE_BLOCK_ENTRY;
+               } else {
+                       /*
+                        * Other levels can have table descriptors. If
+                        * so, recurse into it and erase descriptors
+                        * inside it as needed. If there is a block
+                        * descriptor, just erase it. If an invalid
+                        * descriptor is found, this table isn't
+                        * actually mapped, which shouldn't happen.
+                        */
+                       if (desc_type == TABLE_DESC) {
+                               action = ACTION_RECURSE_INTO_TABLE;
+                       } else {
+                               assert(desc_type == BLOCK_DESC);
+                               action = ACTION_WRITE_BLOCK_ENTRY;
+                       }
+               }
+
+       } else if ((mm->base_va <= table_idx_end_va) ||
+                  (region_end_va >= table_idx_va)) {
+               /*
+                * Region partially covers block.
+                *
+                * It can't happen in level 3.
+                *
+                * There must be a table descriptor here, if not there
+                * was a problem when mapping the region.
+                */
+               assert(level < 3U);
+               assert(desc_type == TABLE_DESC);
+
+               action = ACTION_RECURSE_INTO_TABLE;
+       } else {
+               /* The region doesn't cover the block at all */
+               action = ACTION_NONE;
+       }
+
+       return action;
+}
 /*
  * Recursive function that writes to the translation tables and unmaps the
  * specified region.
@@ -276,55 +337,9 @@ static void xlat_tables_unmap_region(xlat_ctx_t *ctx, mmap_region_t *mm,
                desc = table_base[table_idx];
                uint64_t desc_type = desc & DESC_MASK;
 
-               action_t action;
-
-               if ((mm->base_va <= table_idx_va) &&
-                   (region_end_va >= table_idx_end_va)) {
-                       /* Region covers all block */
-
-                       if (level == 3U) {
-                               /*
-                                * Last level, only page descriptors allowed,
-                                * erase it.
-                                */
-                               assert(desc_type == PAGE_DESC);
-
-                               action = ACTION_WRITE_BLOCK_ENTRY;
-                       } else {
-                               /*
-                                * Other levels can have table descriptors. If
-                                * so, recurse into it and erase descriptors
-                                * inside it as needed. If there is a block
-                                * descriptor, just erase it. If an invalid
-                                * descriptor is found, this table isn't
-                                * actually mapped, which shouldn't happen.
-                                */
-                               if (desc_type == TABLE_DESC) {
-                                       action = ACTION_RECURSE_INTO_TABLE;
-                               } else {
-                                       assert(desc_type == BLOCK_DESC);
-                                       action = ACTION_WRITE_BLOCK_ENTRY;
-                               }
-                       }
-
-               } else if ((mm->base_va <= table_idx_end_va) ||
-                          (region_end_va >= table_idx_va)) {
-                       /*
-                        * Region partially covers block.
-                        *
-                        * It can't happen in level 3.
-                        *
-                        * There must be a table descriptor here, if not there
-                        * was a problem when mapping the region.
-                        */
-                       assert(level < 3U);
-                       assert(desc_type == TABLE_DESC);
-
-                       action = ACTION_RECURSE_INTO_TABLE;
-               } else {
-                       /* The region doesn't cover the block at all */
-                       action = ACTION_NONE;
-               }
+               action_t action = xlat_tables_unmap_region_action(mm,
+                               table_idx_va, table_idx_end_va, level,
+                               desc_type);
 
                if (action == ACTION_WRITE_BLOCK_ENTRY) {