Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause 2 : : * Copyright (C) 2015 Intel Corporation. 3 : : * All rights reserved. 4 : : */ 5 : : 6 : : #include "spdk/stdinc.h" 7 : : 8 : : #include "spdk/config.h" 9 : : #include "spdk/env.h" 10 : : #include "spdk/util.h" 11 : : #include "spdk_internal/cunit.h" 12 : : 13 : : #include "CUnit/Basic.h" 14 : : 15 : : #define __SPDK_ENV_NAME(path) (strrchr(#path, '/') + 1) 16 : : #define _SPDK_ENV_NAME(path) __SPDK_ENV_NAME(path) 17 : : #define SPDK_ENV_NAME _SPDK_ENV_NAME(SPDK_CONFIG_ENV) 18 : : 19 : : static void 20 : 20 : vtophys_malloc_test(void) 21 : : { 22 : 20 : void *p = NULL; 23 : : int i; 24 : 20 : unsigned int size = 1; 25 : : uint64_t paddr; 26 : : 27 : : /* Verify vtophys doesn't work on regular malloc memory */ 28 [ + + ]: 640 : for (i = 0; i < 31; i++) { 29 : 620 : p = malloc(size); 30 [ - + ]: 620 : if (p == NULL) { 31 : 0 : continue; 32 : : } 33 : : 34 : 620 : paddr = spdk_vtophys(p, NULL); 35 : 620 : CU_ASSERT(paddr == SPDK_VTOPHYS_ERROR); 36 : : 37 : 620 : free(p); 38 : 620 : size = size << 1; 39 : : } 40 : : 41 : : /* Test addresses that are not in the valid x86-64 usermode range */ 42 : 20 : paddr = spdk_vtophys((void *)0x0000800000000000ULL, NULL); 43 : 20 : CU_ASSERT(paddr == SPDK_VTOPHYS_ERROR); 44 : 20 : } 45 : : 46 : : static void 47 : 20 : vtophys_spdk_malloc_test(void) 48 : : { 49 : 20 : void *buf = NULL, *p = NULL; 50 : 20 : size_t buf_align = 512; 51 : : int i; 52 : 20 : unsigned int size = 1; 53 : 9 : uint64_t paddr, tmpsize; 54 : : 55 : : /* Test vtophys on memory allocated through SPDK */ 56 [ + + ]: 640 : for (i = 0; i < 31; i++) { 57 : 620 : buf = spdk_zmalloc(size, buf_align, NULL, SPDK_ENV_LCORE_ID_ANY, SPDK_MALLOC_DMA); 58 [ - + ]: 620 : if (buf == NULL) { 59 : 0 : continue; 60 : : } 61 : : 62 : : /* test vtophys translation with no length parameter */ 63 : 620 : paddr = spdk_vtophys(buf, NULL); 64 : 620 : CU_ASSERT(paddr != SPDK_VTOPHYS_ERROR); 65 : : 66 : : /* translate the entire buffer; it's not necessarily contiguous */ 67 : 620 : p = buf; 68 : 620 : tmpsize = size; 69 [ + + ]: 11786 : while (p < buf + size) { 70 : 11166 : paddr = spdk_vtophys(p, &tmpsize); 71 : 11166 : CU_ASSERT(paddr != SPDK_VTOPHYS_ERROR); 72 : 11166 : CU_ASSERT(tmpsize >= spdk_min(size, buf_align)); 73 : 11166 : p += tmpsize; 74 : 11166 : tmpsize = buf + size - p; 75 : : } 76 : 620 : CU_ASSERT(tmpsize == 0); 77 : : 78 : : /* translate a valid vaddr, but with length 0 */ 79 : 620 : p = buf; 80 : 620 : tmpsize = 0; 81 : 620 : paddr = spdk_vtophys(p, &tmpsize); 82 : 620 : CU_ASSERT(paddr != SPDK_VTOPHYS_ERROR); 83 : 620 : CU_ASSERT(tmpsize == 0); 84 : : 85 : : /* translate the first half of the buffer */ 86 : 620 : p = buf; 87 : 620 : tmpsize = size / 2; 88 [ + + ]: 6898 : while (p < buf + size / 2) { 89 : 6278 : paddr = spdk_vtophys(p, &tmpsize); 90 : 6278 : CU_ASSERT(paddr != SPDK_VTOPHYS_ERROR); 91 [ + + ]: 6278 : CU_ASSERT(tmpsize >= spdk_min(size / 2, buf_align)); 92 : 6278 : p += tmpsize; 93 : 6278 : tmpsize = buf + size / 2 - p; 94 : : } 95 : 620 : CU_ASSERT(tmpsize == 0); 96 : : 97 : : /* translate the second half of the buffer */ 98 : 620 : p = buf + size / 2; 99 : 620 : tmpsize = size / 2; 100 [ + + ]: 6056 : while (p < buf + size) { 101 : 5436 : paddr = spdk_vtophys(p, &tmpsize); 102 : 5436 : CU_ASSERT(paddr != SPDK_VTOPHYS_ERROR); 103 [ + + ]: 5436 : CU_ASSERT(tmpsize >= spdk_min(size / 2, buf_align)); 104 : 5436 : p += tmpsize; 105 : 5436 : tmpsize = buf + size - p; 106 : : } 107 : 620 : CU_ASSERT(tmpsize == 0); 108 : : 109 : : /* translate a region that's not entirely registered */ 110 : 620 : p = buf; 111 : 620 : tmpsize = UINT64_MAX; 112 [ + + ]: 11786 : while (p < buf + size) { 113 : 11166 : paddr = spdk_vtophys(p, &tmpsize); 114 : 11166 : CU_ASSERT(paddr != SPDK_VTOPHYS_ERROR); 115 : 11166 : CU_ASSERT(tmpsize >= buf_align); 116 : 11166 : p += tmpsize; 117 : : /* verify our region is really contiguous */ 118 : 11166 : CU_ASSERT(paddr + tmpsize - 1 == spdk_vtophys(p - 1, &tmpsize)); 119 : 11166 : tmpsize = UINT64_MAX; 120 : : } 121 : : 122 : 620 : spdk_free(buf); 123 : 620 : size = size << 1; 124 : : } 125 : 20 : } 126 : : 127 : : int 128 : 20 : main(int argc, char **argv) 129 : : { 130 : 9 : struct spdk_env_opts opts; 131 : 20 : CU_pSuite suite = NULL; 132 : : unsigned num_failures; 133 : : 134 : 20 : spdk_env_opts_init(&opts); 135 : 20 : opts.name = "vtophys"; 136 : 20 : opts.core_mask = "0x1"; 137 : : if (strcmp(SPDK_ENV_NAME, "env_dpdk") == 0) { 138 : 20 : opts.env_context = "--log-level=lib.eal:8"; 139 : : } 140 : : 141 [ - + ]: 20 : if (spdk_env_init(&opts) < 0) { 142 [ # # ]: 0 : printf("Err: Unable to initialize SPDK env\n"); 143 : 0 : return 1; 144 : : } 145 : : 146 [ - + ]: 20 : if (CU_initialize_registry() != CUE_SUCCESS) { 147 : 0 : return CU_get_error(); 148 : : } 149 : : 150 : 20 : suite = CU_add_suite("components_suite", NULL, NULL); 151 [ - + ]: 20 : if (suite == NULL) { 152 : 0 : CU_cleanup_registry(); 153 : 0 : return CU_get_error(); 154 : : } 155 : : 156 [ + - ]: 20 : if ( 157 [ - + ]: 40 : CU_add_test(suite, "vtophys_malloc_test", vtophys_malloc_test) == NULL || 158 : 20 : CU_add_test(suite, "vtophys_spdk_malloc_test", vtophys_spdk_malloc_test) == NULL 159 : : ) { 160 : 0 : CU_cleanup_registry(); 161 : 0 : return CU_get_error(); 162 : : } 163 : : 164 : 20 : num_failures = spdk_ut_run_tests(argc, argv, NULL); 165 : 20 : CU_cleanup_registry(); 166 : 20 : return num_failures; 167 : : }