1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright 2017, Anshuman Khandual, IBM Corp. 4 * 5 * Works on architectures which support 128TB virtual 6 * address range and beyond. 7 */ 8 #include <stdio.h> 9 #include <stdlib.h> 10 #include <string.h> 11 #include <unistd.h> 12 #include <errno.h> 13 #include <sys/mman.h> 14 #include <sys/time.h> 15 #include <fcntl.h> 16 17 #include "../kselftest.h" 18 19 /* 20 * Maximum address range mapped with a single mmap() 21 * call is little bit more than 1GB. Hence 1GB is 22 * chosen as the single chunk size for address space 23 * mapping. 24 */ 25 26 #define SZ_1GB (1024 * 1024 * 1024UL) 27 #define SZ_1TB (1024 * 1024 * 1024 * 1024UL) 28 29 #define MAP_CHUNK_SIZE SZ_1GB 30 31 /* 32 * Address space till 128TB is mapped without any hint 33 * and is enabled by default. Address space beyond 128TB 34 * till 512TB is obtained by passing hint address as the 35 * first argument into mmap() system call. 36 * 37 * The process heap address space is divided into two 38 * different areas one below 128TB and one above 128TB 39 * till it reaches 512TB. One with size 128TB and the 40 * other being 384TB. 41 * 42 * On Arm64 the address space is 256TB and support for 43 * high mappings up to 4PB virtual address space has 44 * been added. 45 */ 46 47 #define NR_CHUNKS_128TB ((128 * SZ_1TB) / MAP_CHUNK_SIZE) /* Number of chunks for 128TB */ 48 #define NR_CHUNKS_256TB (NR_CHUNKS_128TB * 2UL) 49 #define NR_CHUNKS_384TB (NR_CHUNKS_128TB * 3UL) 50 #define NR_CHUNKS_3840TB (NR_CHUNKS_128TB * 30UL) 51 52 #define ADDR_MARK_128TB (1UL << 47) /* First address beyond 128TB */ 53 #define ADDR_MARK_256TB (1UL << 48) /* First address beyond 256TB */ 54 55 #ifdef __aarch64__ 56 #define HIGH_ADDR_MARK ADDR_MARK_256TB 57 #define HIGH_ADDR_SHIFT 49 58 #define NR_CHUNKS_LOW NR_CHUNKS_256TB 59 #define NR_CHUNKS_HIGH NR_CHUNKS_3840TB 60 #else 61 #define HIGH_ADDR_MARK ADDR_MARK_128TB 62 #define HIGH_ADDR_SHIFT 48 63 #define NR_CHUNKS_LOW NR_CHUNKS_128TB 64 #define NR_CHUNKS_HIGH NR_CHUNKS_384TB 65 #endif 66 67 static char *hind_addr(void) 68 { 69 int bits = HIGH_ADDR_SHIFT + rand() % (63 - HIGH_ADDR_SHIFT); 70 71 return (char *) (1UL << bits); 72 } 73 74 static void validate_addr(char *ptr, int high_addr) 75 { 76 unsigned long addr = (unsigned long) ptr; 77 78 if (high_addr && addr < HIGH_ADDR_MARK) 79 ksft_exit_fail_msg("Bad address %lx\n", addr); 80 81 if (addr > HIGH_ADDR_MARK) 82 ksft_exit_fail_msg("Bad address %lx\n", addr); 83 } 84 85 static int validate_lower_address_hint(void) 86 { 87 char *ptr; 88 89 ptr = mmap((void *) (1UL << 45), MAP_CHUNK_SIZE, PROT_READ | 90 PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); 91 92 if (ptr == MAP_FAILED) 93 return 0; 94 95 return 1; 96 } 97 98 static int validate_complete_va_space(void) 99 { 100 unsigned long start_addr, end_addr, prev_end_addr; 101 char line[400]; 102 char prot[6]; 103 FILE *file; 104 int fd; 105 106 fd = open("va_dump", O_CREAT | O_WRONLY, 0600); 107 unlink("va_dump"); 108 if (fd < 0) { 109 ksft_test_result_skip("cannot create or open dump file\n"); 110 ksft_finished(); 111 } 112 113 file = fopen("/proc/self/maps", "r"); 114 if (file == NULL) 115 ksft_exit_fail_msg("cannot open /proc/self/maps\n"); 116 117 prev_end_addr = 0; 118 while (fgets(line, sizeof(line), file)) { 119 unsigned long hop; 120 121 if (sscanf(line, "%lx-%lx %s[rwxp-]", 122 &start_addr, &end_addr, prot) != 3) 123 ksft_exit_fail_msg("cannot parse /proc/self/maps\n"); 124 125 /* end of userspace mappings; ignore vsyscall mapping */ 126 if (start_addr & (1UL << 63)) 127 return 0; 128 129 /* /proc/self/maps must have gaps less than MAP_CHUNK_SIZE */ 130 if (start_addr - prev_end_addr >= MAP_CHUNK_SIZE) 131 return 1; 132 133 prev_end_addr = end_addr; 134 135 if (prot[0] != 'r') 136 continue; 137 138 /* 139 * Confirm whether MAP_CHUNK_SIZE chunk can be found or not. 140 * If write succeeds, no need to check MAP_CHUNK_SIZE - 1 141 * addresses after that. If the address was not held by this 142 * process, write would fail with errno set to EFAULT. 143 * Anyways, if write returns anything apart from 1, exit the 144 * program since that would mean a bug in /proc/self/maps. 145 */ 146 hop = 0; 147 while (start_addr + hop < end_addr) { 148 if (write(fd, (void *)(start_addr + hop), 1) != 1) 149 return 1; 150 lseek(fd, 0, SEEK_SET); 151 152 hop += MAP_CHUNK_SIZE; 153 } 154 } 155 return 0; 156 } 157 158 int main(int argc, char *argv[]) 159 { 160 char *ptr[NR_CHUNKS_LOW]; 161 char **hptr; 162 char *hint; 163 unsigned long i, lchunks, hchunks; 164 165 ksft_print_header(); 166 ksft_set_plan(1); 167 168 for (i = 0; i < NR_CHUNKS_LOW; i++) { 169 ptr[i] = mmap(NULL, MAP_CHUNK_SIZE, PROT_READ | PROT_WRITE, 170 MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); 171 172 if (ptr[i] == MAP_FAILED) { 173 if (validate_lower_address_hint()) 174 ksft_exit_fail_msg("mmap unexpectedly succeeded with hint\n"); 175 break; 176 } 177 178 validate_addr(ptr[i], 0); 179 } 180 lchunks = i; 181 hptr = (char **) calloc(NR_CHUNKS_HIGH, sizeof(char *)); 182 if (hptr == NULL) { 183 ksft_test_result_skip("Memory constraint not fulfilled\n"); 184 ksft_finished(); 185 } 186 187 for (i = 0; i < NR_CHUNKS_HIGH; i++) { 188 hint = hind_addr(); 189 hptr[i] = mmap(hint, MAP_CHUNK_SIZE, PROT_READ | PROT_WRITE, 190 MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); 191 192 if (hptr[i] == MAP_FAILED) 193 break; 194 195 validate_addr(hptr[i], 1); 196 } 197 hchunks = i; 198 if (validate_complete_va_space()) { 199 ksft_test_result_fail("BUG in mmap() or /proc/self/maps\n"); 200 ksft_finished(); 201 } 202 203 for (i = 0; i < lchunks; i++) 204 munmap(ptr[i], MAP_CHUNK_SIZE); 205 206 for (i = 0; i < hchunks; i++) 207 munmap(hptr[i], MAP_CHUNK_SIZE); 208 209 free(hptr); 210 211 ksft_test_result_pass("Test\n"); 212 ksft_finished(); 213 } 214