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