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 "../kselftest.h" |
16 | |
17 | /* |
18 | * Maximum address range mapped with a single mmap() |
19 | * call is little bit more than 1GB. Hence 1GB is |
20 | * chosen as the single chunk size for address space |
21 | * mapping. |
22 | */ |
23 | |
24 | #define SZ_1GB (1024 * 1024 * 1024UL) |
25 | #define SZ_1TB (1024 * 1024 * 1024 * 1024UL) |
26 | |
27 | #define MAP_CHUNK_SIZE SZ_1GB |
28 | |
29 | /* |
30 | * Address space till 128TB is mapped without any hint |
31 | * and is enabled by default. Address space beyond 128TB |
32 | * till 512TB is obtained by passing hint address as the |
33 | * first argument into mmap() system call. |
34 | * |
35 | * The process heap address space is divided into two |
36 | * different areas one below 128TB and one above 128TB |
37 | * till it reaches 512TB. One with size 128TB and the |
38 | * other being 384TB. |
39 | * |
40 | * On Arm64 the address space is 256TB and support for |
41 | * high mappings up to 4PB virtual address space has |
42 | * been added. |
43 | */ |
44 | |
45 | #define NR_CHUNKS_128TB ((128 * SZ_1TB) / MAP_CHUNK_SIZE) /* Number of chunks for 128TB */ |
46 | #define NR_CHUNKS_256TB (NR_CHUNKS_128TB * 2UL) |
47 | #define NR_CHUNKS_384TB (NR_CHUNKS_128TB * 3UL) |
48 | #define NR_CHUNKS_3840TB (NR_CHUNKS_128TB * 30UL) |
49 | |
50 | #define ADDR_MARK_128TB (1UL << 47) /* First address beyond 128TB */ |
51 | #define ADDR_MARK_256TB (1UL << 48) /* First address beyond 256TB */ |
52 | |
53 | #ifdef __aarch64__ |
54 | #define HIGH_ADDR_MARK ADDR_MARK_256TB |
55 | #define HIGH_ADDR_SHIFT 49 |
56 | #define NR_CHUNKS_LOW NR_CHUNKS_256TB |
57 | #define NR_CHUNKS_HIGH NR_CHUNKS_3840TB |
58 | #else |
59 | #define HIGH_ADDR_MARK ADDR_MARK_128TB |
60 | #define HIGH_ADDR_SHIFT 48 |
61 | #define NR_CHUNKS_LOW NR_CHUNKS_128TB |
62 | #define NR_CHUNKS_HIGH NR_CHUNKS_384TB |
63 | #endif |
64 | |
65 | static char *hind_addr(void) |
66 | { |
67 | int bits = HIGH_ADDR_SHIFT + rand() % (63 - HIGH_ADDR_SHIFT); |
68 | |
69 | return (char *) (1UL << bits); |
70 | } |
71 | |
72 | static void validate_addr(char *ptr, int high_addr) |
73 | { |
74 | unsigned long addr = (unsigned long) ptr; |
75 | |
76 | if (high_addr && addr < HIGH_ADDR_MARK) |
77 | ksft_exit_fail_msg(msg: "Bad address %lx\n" , addr); |
78 | |
79 | if (addr > HIGH_ADDR_MARK) |
80 | ksft_exit_fail_msg(msg: "Bad address %lx\n" , addr); |
81 | } |
82 | |
83 | static int validate_lower_address_hint(void) |
84 | { |
85 | char *ptr; |
86 | |
87 | ptr = mmap((void *) (1UL << 45), MAP_CHUNK_SIZE, PROT_READ | |
88 | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); |
89 | |
90 | if (ptr == MAP_FAILED) |
91 | return 0; |
92 | |
93 | return 1; |
94 | } |
95 | |
96 | int main(int argc, char *argv[]) |
97 | { |
98 | char *ptr[NR_CHUNKS_LOW]; |
99 | char **hptr; |
100 | char *hint; |
101 | unsigned long i, lchunks, hchunks; |
102 | |
103 | ksft_print_header(); |
104 | ksft_set_plan(plan: 1); |
105 | |
106 | for (i = 0; i < NR_CHUNKS_LOW; i++) { |
107 | ptr[i] = mmap(NULL, MAP_CHUNK_SIZE, PROT_READ | PROT_WRITE, |
108 | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); |
109 | |
110 | if (ptr[i] == MAP_FAILED) { |
111 | if (validate_lower_address_hint()) { |
112 | ksft_test_result_skip(msg: "Memory constraint not fulfilled\n" ); |
113 | ksft_finished(); |
114 | } |
115 | break; |
116 | } |
117 | |
118 | validate_addr(ptr: ptr[i], high_addr: 0); |
119 | } |
120 | lchunks = i; |
121 | hptr = (char **) calloc(NR_CHUNKS_HIGH, sizeof(char *)); |
122 | if (hptr == NULL) { |
123 | ksft_test_result_skip(msg: "Memory constraint not fulfilled\n" ); |
124 | ksft_finished(); |
125 | } |
126 | |
127 | for (i = 0; i < NR_CHUNKS_HIGH; i++) { |
128 | hint = hind_addr(); |
129 | hptr[i] = mmap(hint, MAP_CHUNK_SIZE, PROT_READ | PROT_WRITE, |
130 | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); |
131 | |
132 | if (hptr[i] == MAP_FAILED) |
133 | break; |
134 | |
135 | validate_addr(ptr: hptr[i], high_addr: 1); |
136 | } |
137 | hchunks = i; |
138 | |
139 | for (i = 0; i < lchunks; i++) |
140 | munmap(ptr[i], MAP_CHUNK_SIZE); |
141 | |
142 | for (i = 0; i < hchunks; i++) |
143 | munmap(hptr[i], MAP_CHUNK_SIZE); |
144 | |
145 | free(hptr); |
146 | |
147 | ksft_test_result_pass(msg: "Test\n" ); |
148 | ksft_finished(); |
149 | } |
150 | |