test/memzone: fix memory leak

[dpdk.git] / test / test / test_memzone.c

diff --git a/test/test/test_memzone.c b/test/test/test_memzone.c
index 7ae31cf..1cf235a 100644 (file)
--- a/test/test/test_memzone.c
+++ b/test/test/test_memzone.c
@@ -78,7 +78,7 @@
 
 /* Test if memory overlaps: return 1 if true, or 0 if false. */
 static int
-is_memory_overlap(phys_addr_t ptr1, size_t len1, phys_addr_t ptr2, size_t len2)
+is_memory_overlap(rte_iova_t ptr1, size_t len1, rte_iova_t ptr2, size_t len2)
 {
        if (ptr2 >= ptr1 && (ptr2 - ptr1) < len1)
                return 1;
@@ -176,6 +176,10 @@ test_memzone_reserve_flags(void)
                        printf("hugepage_sz not equal 2M\n");
                        return -1;
                }
+               if (rte_memzone_free(mz)) {
+                       printf("Fail memzone free\n");
+                       return -1;
+               }
 
                mz = rte_memzone_reserve("flag_zone_2M_HINT", size, SOCKET_ID_ANY,
                                RTE_MEMZONE_2MB|RTE_MEMZONE_SIZE_HINT_ONLY);
@@ -187,6 +191,10 @@ test_memzone_reserve_flags(void)
                        printf("hugepage_sz not equal 2M\n");
                        return -1;
                }
+               if (rte_memzone_free(mz)) {
+                       printf("Fail memzone free\n");
+                       return -1;
+               }
 
                /* Check if 1GB huge pages are unavailable, that function fails unless
                 * HINT flag is indicated
@@ -202,6 +210,10 @@ test_memzone_reserve_flags(void)
                                printf("hugepage_sz not equal 2M\n");
                                return -1;
                        }
+                       if (rte_memzone_free(mz)) {
+                               printf("Fail memzone free\n");
+                               return -1;
+                       }
 
                        mz = rte_memzone_reserve("flag_zone_1G", size, SOCKET_ID_ANY,
                                        RTE_MEMZONE_1GB);
@@ -224,6 +236,10 @@ test_memzone_reserve_flags(void)
                        printf("hugepage_sz not equal 1G\n");
                        return -1;
                }
+               if (rte_memzone_free(mz)) {
+                       printf("Fail memzone free\n");
+                       return -1;
+               }
 
                mz = rte_memzone_reserve("flag_zone_1G_HINT", size, SOCKET_ID_ANY,
                                RTE_MEMZONE_1GB|RTE_MEMZONE_SIZE_HINT_ONLY);
@@ -235,6 +251,10 @@ test_memzone_reserve_flags(void)
                        printf("hugepage_sz not equal 1G\n");
                        return -1;
                }
+               if (rte_memzone_free(mz)) {
+                       printf("Fail memzone free\n");
+                       return -1;
+               }
 
                /* Check if 1GB huge pages are unavailable, that function fails unless
                 * HINT flag is indicated
@@ -250,12 +270,20 @@ test_memzone_reserve_flags(void)
                                printf("hugepage_sz not equal 1G\n");
                                return -1;
                        }
+                       if (rte_memzone_free(mz)) {
+                               printf("Fail memzone free\n");
+                               return -1;
+                       }
                        mz = rte_memzone_reserve("flag_zone_2M", size, SOCKET_ID_ANY,
                                        RTE_MEMZONE_2MB);
                        if (mz != NULL) {
                                printf("MEMZONE FLAG 2MB\n");
                                return -1;
                        }
+                       if (rte_memzone_free(mz)) {
+                               printf("Fail memzone free\n");
+                               return -1;
+                       }
                }
 
                if (hugepage_2MB_avail && hugepage_1GB_avail) {
@@ -285,6 +313,10 @@ test_memzone_reserve_flags(void)
                        printf("hugepage_sz not equal 16M\n");
                        return -1;
                }
+               if (rte_memzone_free(mz)) {
+                       printf("Fail memzone free\n");
+                       return -1;
+               }
 
                mz = rte_memzone_reserve("flag_zone_16M_HINT", size,
                SOCKET_ID_ANY, RTE_MEMZONE_16MB|RTE_MEMZONE_SIZE_HINT_ONLY);
@@ -296,6 +328,10 @@ test_memzone_reserve_flags(void)
                        printf("hugepage_sz not equal 16M\n");
                        return -1;
                }
+               if (rte_memzone_free(mz)) {
+                       printf("Fail memzone free\n");
+                       return -1;
+               }
 
                /* Check if 1GB huge pages are unavailable, that function fails
                 * unless HINT flag is indicated
@@ -312,6 +348,10 @@ test_memzone_reserve_flags(void)
                                printf("hugepage_sz not equal 16M\n");
                                return -1;
                        }
+                       if (rte_memzone_free(mz)) {
+                               printf("Fail memzone free\n");
+                               return -1;
+                       }
 
                        mz = rte_memzone_reserve("flag_zone_16G", size,
                                SOCKET_ID_ANY, RTE_MEMZONE_16GB);
@@ -333,6 +373,10 @@ test_memzone_reserve_flags(void)
                        printf("hugepage_sz not equal 16G\n");
                        return -1;
                }
+               if (rte_memzone_free(mz)) {
+                       printf("Fail memzone free\n");
+                       return -1;
+               }
 
                mz = rte_memzone_reserve("flag_zone_16G_HINT", size,
                SOCKET_ID_ANY, RTE_MEMZONE_16GB|RTE_MEMZONE_SIZE_HINT_ONLY);
@@ -344,6 +388,10 @@ test_memzone_reserve_flags(void)
                        printf("hugepage_sz not equal 16G\n");
                        return -1;
                }
+               if (rte_memzone_free(mz)) {
+                       printf("Fail memzone free\n");
+                       return -1;
+               }
 
                /* Check if 1GB huge pages are unavailable, that function fails
                 * unless HINT flag is indicated
@@ -360,6 +408,10 @@ test_memzone_reserve_flags(void)
                                printf("hugepage_sz not equal 16G\n");
                                return -1;
                        }
+                       if (rte_memzone_free(mz)) {
+                               printf("Fail memzone free\n");
+                               return -1;
+                       }
                        mz = rte_memzone_reserve("flag_zone_16M", size,
                                SOCKET_ID_ANY, RTE_MEMZONE_16MB);
                        if (mz != NULL) {
@@ -434,6 +486,12 @@ test_memzone_reserve_max(void)
                rte_memzone_dump(stdout);
                return -1;
        }
+
+       if (rte_memzone_free(mz)) {
+               printf("Fail memzone free\n");
+               return -1;
+       }
+
        return 0;
 }
 
@@ -473,6 +531,12 @@ test_memzone_reserve_max_aligned(void)
                rte_memzone_dump(stdout);
                return -1;
        }
+
+       if (rte_memzone_free(mz)) {
+               printf("Fail memzone free\n");
+               return -1;
+       }
+
        return 0;
 }
 
@@ -510,7 +574,7 @@ test_memzone_aligned(void)
                printf("Unable to reserve 64-byte aligned memzone!\n");
                return -1;
        }
-       if ((memzone_aligned_32->phys_addr & RTE_CACHE_LINE_MASK) != 0)
+       if ((memzone_aligned_32->iova & RTE_CACHE_LINE_MASK) != 0)
                return -1;
        if (((uintptr_t) memzone_aligned_32->addr & RTE_CACHE_LINE_MASK) != 0)
                return -1;
@@ -521,7 +585,7 @@ test_memzone_aligned(void)
                printf("Unable to reserve 128-byte aligned memzone!\n");
                return -1;
        }
-       if ((memzone_aligned_128->phys_addr & 127) != 0)
+       if ((memzone_aligned_128->iova & 127) != 0)
                return -1;
        if (((uintptr_t) memzone_aligned_128->addr & 127) != 0)
                return -1;
@@ -532,7 +596,7 @@ test_memzone_aligned(void)
                printf("Unable to reserve 256-byte aligned memzone!\n");
                return -1;
        }
-       if ((memzone_aligned_256->phys_addr & 255) != 0)
+       if ((memzone_aligned_256->iova & 255) != 0)
                return -1;
        if (((uintptr_t) memzone_aligned_256->addr & 255) != 0)
                return -1;
@@ -543,7 +607,7 @@ test_memzone_aligned(void)
                printf("Unable to reserve 512-byte aligned memzone!\n");
                return -1;
        }
-       if ((memzone_aligned_512->phys_addr & 511) != 0)
+       if ((memzone_aligned_512->iova & 511) != 0)
                return -1;
        if (((uintptr_t) memzone_aligned_512->addr & 511) != 0)
                return -1;
@@ -554,7 +618,7 @@ test_memzone_aligned(void)
                printf("Unable to reserve 1024-byte aligned memzone!\n");
                return -1;
        }
-       if ((memzone_aligned_1024->phys_addr & 1023) != 0)
+       if ((memzone_aligned_1024->iova & 1023) != 0)
                return -1;
        if (((uintptr_t) memzone_aligned_1024->addr & 1023) != 0)
                return -1;
@@ -563,36 +627,58 @@ test_memzone_aligned(void)
 
        /* check that zones don't overlap */
        printf("check overlapping\n");
-       if (is_memory_overlap(memzone_aligned_32->phys_addr, memzone_aligned_32->len,
-                                       memzone_aligned_128->phys_addr, memzone_aligned_128->len))
+       if (is_memory_overlap(memzone_aligned_32->iova, memzone_aligned_32->len,
+                                       memzone_aligned_128->iova, memzone_aligned_128->len))
+               return -1;
+       if (is_memory_overlap(memzone_aligned_32->iova, memzone_aligned_32->len,
+                                       memzone_aligned_256->iova, memzone_aligned_256->len))
                return -1;
-       if (is_memory_overlap(memzone_aligned_32->phys_addr, memzone_aligned_32->len,
-                                       memzone_aligned_256->phys_addr, memzone_aligned_256->len))
+       if (is_memory_overlap(memzone_aligned_32->iova, memzone_aligned_32->len,
+                                       memzone_aligned_512->iova, memzone_aligned_512->len))
                return -1;
-       if (is_memory_overlap(memzone_aligned_32->phys_addr, memzone_aligned_32->len,
-                                       memzone_aligned_512->phys_addr, memzone_aligned_512->len))
+       if (is_memory_overlap(memzone_aligned_32->iova, memzone_aligned_32->len,
+                                       memzone_aligned_1024->iova, memzone_aligned_1024->len))
                return -1;
-       if (is_memory_overlap(memzone_aligned_32->phys_addr, memzone_aligned_32->len,
-                                       memzone_aligned_1024->phys_addr, memzone_aligned_1024->len))
+       if (is_memory_overlap(memzone_aligned_128->iova, memzone_aligned_128->len,
+                                       memzone_aligned_256->iova, memzone_aligned_256->len))
                return -1;
-       if (is_memory_overlap(memzone_aligned_128->phys_addr, memzone_aligned_128->len,
-                                       memzone_aligned_256->phys_addr, memzone_aligned_256->len))
+       if (is_memory_overlap(memzone_aligned_128->iova, memzone_aligned_128->len,
+                                       memzone_aligned_512->iova, memzone_aligned_512->len))
                return -1;
-       if (is_memory_overlap(memzone_aligned_128->phys_addr, memzone_aligned_128->len,
-                                       memzone_aligned_512->phys_addr, memzone_aligned_512->len))
+       if (is_memory_overlap(memzone_aligned_128->iova, memzone_aligned_128->len,
+                                       memzone_aligned_1024->iova, memzone_aligned_1024->len))
                return -1;
-       if (is_memory_overlap(memzone_aligned_128->phys_addr, memzone_aligned_128->len,
-                                       memzone_aligned_1024->phys_addr, memzone_aligned_1024->len))
+       if (is_memory_overlap(memzone_aligned_256->iova, memzone_aligned_256->len,
+                                       memzone_aligned_512->iova, memzone_aligned_512->len))
                return -1;
-       if (is_memory_overlap(memzone_aligned_256->phys_addr, memzone_aligned_256->len,
-                                       memzone_aligned_512->phys_addr, memzone_aligned_512->len))
+       if (is_memory_overlap(memzone_aligned_256->iova, memzone_aligned_256->len,
+                                       memzone_aligned_1024->iova, memzone_aligned_1024->len))
                return -1;
-       if (is_memory_overlap(memzone_aligned_256->phys_addr, memzone_aligned_256->len,
-                                       memzone_aligned_1024->phys_addr, memzone_aligned_1024->len))
+       if (is_memory_overlap(memzone_aligned_512->iova, memzone_aligned_512->len,
+                                       memzone_aligned_1024->iova, memzone_aligned_1024->len))
                return -1;
-       if (is_memory_overlap(memzone_aligned_512->phys_addr, memzone_aligned_512->len,
-                                       memzone_aligned_1024->phys_addr, memzone_aligned_1024->len))
+
+       /* free all used zones */
+       if (rte_memzone_free(memzone_aligned_32)) {
+               printf("Fail memzone free\n");
                return -1;
+       }
+       if (rte_memzone_free(memzone_aligned_128)) {
+               printf("Fail memzone free\n");
+               return -1;
+       }
+       if (rte_memzone_free(memzone_aligned_256)) {
+               printf("Fail memzone free\n");
+               return -1;
+       }
+       if (rte_memzone_free(memzone_aligned_512)) {
+               printf("Fail memzone free\n");
+               return -1;
+       }
+       if (rte_memzone_free(memzone_aligned_1024)) {
+               printf("Fail memzone free\n");
+               return -1;
+       }
        return 0;
 }
 
@@ -601,9 +687,9 @@ check_memzone_bounded(const char *name, uint32_t len,  uint32_t align,
        uint32_t bound)
 {
        const struct rte_memzone *mz;
-       phys_addr_t bmask;
+       rte_iova_t bmask;
 
-       bmask = ~((phys_addr_t)bound - 1);
+       bmask = ~((rte_iova_t)bound - 1);
 
        if ((mz = rte_memzone_reserve_bounded(name, len, SOCKET_ID_ANY, 0,
                        align, bound)) == NULL) {
@@ -612,7 +698,7 @@ check_memzone_bounded(const char *name, uint32_t len,  uint32_t align,
                return -1;
        }
 
-       if ((mz->phys_addr & ((phys_addr_t)align - 1)) != 0) {
+       if ((mz->iova & ((rte_iova_t)align - 1)) != 0) {
                printf("%s(%s): invalid phys addr alignment\n",
                        __func__, mz->name);
                return -1;
@@ -631,13 +717,18 @@ check_memzone_bounded(const char *name, uint32_t len,  uint32_t align,
                return -1;
        }
 
-       if ((mz->phys_addr & bmask) !=
-                       ((mz->phys_addr + mz->len - 1) & bmask)) {
+       if ((mz->iova & bmask) !=
+                       ((mz->iova + mz->len - 1) & bmask)) {
                printf("%s(%s): invalid memzone boundary %u crossed\n",
                        __func__, mz->name, bound);
                return -1;
        }
 
+       if (rte_memzone_free(mz)) {
+               printf("Fail memzone free\n");
+               return -1;
+       }
+
        return 0;
 }
 
@@ -758,7 +849,7 @@ test_memzone_free(void)
 }
 
 static int
-test_memzone(void)
+test_memzone_basic(void)
 {
        const struct rte_memzone *memzone1;
        const struct rte_memzone *memzone2;
@@ -787,11 +878,11 @@ test_memzone(void)
        /* check cache-line alignments */
        printf("check alignments and lengths\n");
 
-       if ((memzone1->phys_addr & RTE_CACHE_LINE_MASK) != 0)
+       if ((memzone1->iova & RTE_CACHE_LINE_MASK) != 0)
                return -1;
-       if ((memzone2->phys_addr & RTE_CACHE_LINE_MASK) != 0)
+       if ((memzone2->iova & RTE_CACHE_LINE_MASK) != 0)
                return -1;
-       if (memzone3 != NULL && (memzone3->phys_addr & RTE_CACHE_LINE_MASK) != 0)
+       if (memzone3 != NULL && (memzone3->iova & RTE_CACHE_LINE_MASK) != 0)
                return -1;
        if ((memzone1->len & RTE_CACHE_LINE_MASK) != 0 || memzone1->len == 0)
                return -1;
@@ -806,16 +897,16 @@ test_memzone(void)
        /* check that zones don't overlap */
        printf("check overlapping\n");
 
-       if (is_memory_overlap(memzone1->phys_addr, memzone1->len,
-                       memzone2->phys_addr, memzone2->len))
+       if (is_memory_overlap(memzone1->iova, memzone1->len,
+                       memzone2->iova, memzone2->len))
                return -1;
        if (memzone3 != NULL &&
-                       is_memory_overlap(memzone1->phys_addr, memzone1->len,
-                                       memzone3->phys_addr, memzone3->len))
+                       is_memory_overlap(memzone1->iova, memzone1->len,
+                                       memzone3->iova, memzone3->len))
                return -1;
        if (memzone3 != NULL &&
-                       is_memory_overlap(memzone2->phys_addr, memzone2->len,
-                                       memzone3->phys_addr, memzone3->len))
+                       is_memory_overlap(memzone2->iova, memzone2->len,
+                                       memzone3->iova, memzone3->len))
                return -1;
 
        printf("check socket ID\n");
@@ -837,6 +928,40 @@ test_memzone(void)
        if (mz != NULL)
                return -1;
 
+       if (rte_memzone_free(memzone1)) {
+               printf("Fail memzone free - memzone1\n");
+               return -1;
+       }
+       if (rte_memzone_free(memzone2)) {
+               printf("Fail memzone free - memzone2\n");
+               return -1;
+       }
+       if (memzone3 && rte_memzone_free(memzone3)) {
+               printf("Fail memzone free - memzone3\n");
+               return -1;
+       }
+       if (rte_memzone_free(memzone4)) {
+               printf("Fail memzone free - memzone4\n");
+               return -1;
+       }
+
+       return 0;
+}
+
+static int memzone_calk_called;
+static void memzone_walk_clb(const struct rte_memzone *mz __rte_unused,
+                            void *arg __rte_unused)
+{
+       memzone_calk_called = 1;
+}
+
+static int
+test_memzone(void)
+{
+       printf("test basic memzone API\n");
+       if (test_memzone_basic() < 0)
+               return -1;
+
        printf("test free memzone\n");
        if (test_memzone_free() < 0)
                return -1;
@@ -869,6 +994,14 @@ test_memzone(void)
        if (test_memzone_reserve_max_aligned() < 0)
                return -1;
 
+       printf("check memzone cleanup\n");
+       rte_memzone_walk(memzone_walk_clb, NULL);
+       if (memzone_calk_called) {
+               printf("there are some memzones left after test\n");
+               rte_memzone_dump(stdout);
+               return -1;
+       }
+
        return 0;
 }