1*4882a593Smuzhiyun // SPDX-License-Identifier: GPL-2.0-only
2*4882a593Smuzhiyun /*
3*4882a593Smuzhiyun * Copyright 2017, Anshuman Khandual, IBM Corp.
4*4882a593Smuzhiyun *
5*4882a593Smuzhiyun * Works on architectures which support 128TB virtual
6*4882a593Smuzhiyun * address range and beyond.
7*4882a593Smuzhiyun */
8*4882a593Smuzhiyun #include <stdio.h>
9*4882a593Smuzhiyun #include <stdlib.h>
10*4882a593Smuzhiyun #include <string.h>
11*4882a593Smuzhiyun #include <unistd.h>
12*4882a593Smuzhiyun #include <errno.h>
13*4882a593Smuzhiyun #include <sys/mman.h>
14*4882a593Smuzhiyun #include <sys/time.h>
15*4882a593Smuzhiyun
16*4882a593Smuzhiyun /*
17*4882a593Smuzhiyun * Maximum address range mapped with a single mmap()
18*4882a593Smuzhiyun * call is little bit more than 16GB. Hence 16GB is
19*4882a593Smuzhiyun * chosen as the single chunk size for address space
20*4882a593Smuzhiyun * mapping.
21*4882a593Smuzhiyun */
22*4882a593Smuzhiyun #define MAP_CHUNK_SIZE 17179869184UL /* 16GB */
23*4882a593Smuzhiyun
24*4882a593Smuzhiyun /*
25*4882a593Smuzhiyun * Address space till 128TB is mapped without any hint
26*4882a593Smuzhiyun * and is enabled by default. Address space beyond 128TB
27*4882a593Smuzhiyun * till 512TB is obtained by passing hint address as the
28*4882a593Smuzhiyun * first argument into mmap() system call.
29*4882a593Smuzhiyun *
30*4882a593Smuzhiyun * The process heap address space is divided into two
31*4882a593Smuzhiyun * different areas one below 128TB and one above 128TB
32*4882a593Smuzhiyun * till it reaches 512TB. One with size 128TB and the
33*4882a593Smuzhiyun * other being 384TB.
34*4882a593Smuzhiyun *
35*4882a593Smuzhiyun * On Arm64 the address space is 256TB and no high mappings
36*4882a593Smuzhiyun * are supported so far.
37*4882a593Smuzhiyun */
38*4882a593Smuzhiyun
39*4882a593Smuzhiyun #define NR_CHUNKS_128TB 8192UL /* Number of 16GB chunks for 128TB */
40*4882a593Smuzhiyun #define NR_CHUNKS_256TB (NR_CHUNKS_128TB * 2UL)
41*4882a593Smuzhiyun #define NR_CHUNKS_384TB (NR_CHUNKS_128TB * 3UL)
42*4882a593Smuzhiyun
43*4882a593Smuzhiyun #define ADDR_MARK_128TB (1UL << 47) /* First address beyond 128TB */
44*4882a593Smuzhiyun #define ADDR_MARK_256TB (1UL << 48) /* First address beyond 256TB */
45*4882a593Smuzhiyun
46*4882a593Smuzhiyun #ifdef __aarch64__
47*4882a593Smuzhiyun #define HIGH_ADDR_MARK ADDR_MARK_256TB
48*4882a593Smuzhiyun #define HIGH_ADDR_SHIFT 49
49*4882a593Smuzhiyun #define NR_CHUNKS_LOW NR_CHUNKS_256TB
50*4882a593Smuzhiyun #define NR_CHUNKS_HIGH 0
51*4882a593Smuzhiyun #else
52*4882a593Smuzhiyun #define HIGH_ADDR_MARK ADDR_MARK_128TB
53*4882a593Smuzhiyun #define HIGH_ADDR_SHIFT 48
54*4882a593Smuzhiyun #define NR_CHUNKS_LOW NR_CHUNKS_128TB
55*4882a593Smuzhiyun #define NR_CHUNKS_HIGH NR_CHUNKS_384TB
56*4882a593Smuzhiyun #endif
57*4882a593Smuzhiyun
hind_addr(void)58*4882a593Smuzhiyun static char *hind_addr(void)
59*4882a593Smuzhiyun {
60*4882a593Smuzhiyun int bits = HIGH_ADDR_SHIFT + rand() % (63 - HIGH_ADDR_SHIFT);
61*4882a593Smuzhiyun
62*4882a593Smuzhiyun return (char *) (1UL << bits);
63*4882a593Smuzhiyun }
64*4882a593Smuzhiyun
validate_addr(char * ptr,int high_addr)65*4882a593Smuzhiyun static int validate_addr(char *ptr, int high_addr)
66*4882a593Smuzhiyun {
67*4882a593Smuzhiyun unsigned long addr = (unsigned long) ptr;
68*4882a593Smuzhiyun
69*4882a593Smuzhiyun if (high_addr) {
70*4882a593Smuzhiyun if (addr < HIGH_ADDR_MARK) {
71*4882a593Smuzhiyun printf("Bad address %lx\n", addr);
72*4882a593Smuzhiyun return 1;
73*4882a593Smuzhiyun }
74*4882a593Smuzhiyun return 0;
75*4882a593Smuzhiyun }
76*4882a593Smuzhiyun
77*4882a593Smuzhiyun if (addr > HIGH_ADDR_MARK) {
78*4882a593Smuzhiyun printf("Bad address %lx\n", addr);
79*4882a593Smuzhiyun return 1;
80*4882a593Smuzhiyun }
81*4882a593Smuzhiyun return 0;
82*4882a593Smuzhiyun }
83*4882a593Smuzhiyun
validate_lower_address_hint(void)84*4882a593Smuzhiyun static int validate_lower_address_hint(void)
85*4882a593Smuzhiyun {
86*4882a593Smuzhiyun char *ptr;
87*4882a593Smuzhiyun
88*4882a593Smuzhiyun ptr = mmap((void *) (1UL << 45), MAP_CHUNK_SIZE, PROT_READ |
89*4882a593Smuzhiyun PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
90*4882a593Smuzhiyun
91*4882a593Smuzhiyun if (ptr == MAP_FAILED)
92*4882a593Smuzhiyun return 0;
93*4882a593Smuzhiyun
94*4882a593Smuzhiyun return 1;
95*4882a593Smuzhiyun }
96*4882a593Smuzhiyun
main(int argc,char * argv[])97*4882a593Smuzhiyun int main(int argc, char *argv[])
98*4882a593Smuzhiyun {
99*4882a593Smuzhiyun char *ptr[NR_CHUNKS_LOW];
100*4882a593Smuzhiyun char *hptr[NR_CHUNKS_HIGH];
101*4882a593Smuzhiyun char *hint;
102*4882a593Smuzhiyun unsigned long i, lchunks, hchunks;
103*4882a593Smuzhiyun
104*4882a593Smuzhiyun for (i = 0; i < NR_CHUNKS_LOW; i++) {
105*4882a593Smuzhiyun ptr[i] = mmap(NULL, MAP_CHUNK_SIZE, PROT_READ | PROT_WRITE,
106*4882a593Smuzhiyun MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
107*4882a593Smuzhiyun
108*4882a593Smuzhiyun if (ptr[i] == MAP_FAILED) {
109*4882a593Smuzhiyun if (validate_lower_address_hint())
110*4882a593Smuzhiyun return 1;
111*4882a593Smuzhiyun break;
112*4882a593Smuzhiyun }
113*4882a593Smuzhiyun
114*4882a593Smuzhiyun if (validate_addr(ptr[i], 0))
115*4882a593Smuzhiyun return 1;
116*4882a593Smuzhiyun }
117*4882a593Smuzhiyun lchunks = i;
118*4882a593Smuzhiyun
119*4882a593Smuzhiyun for (i = 0; i < NR_CHUNKS_HIGH; i++) {
120*4882a593Smuzhiyun hint = hind_addr();
121*4882a593Smuzhiyun hptr[i] = mmap(hint, MAP_CHUNK_SIZE, PROT_READ | PROT_WRITE,
122*4882a593Smuzhiyun MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
123*4882a593Smuzhiyun
124*4882a593Smuzhiyun if (hptr[i] == MAP_FAILED)
125*4882a593Smuzhiyun break;
126*4882a593Smuzhiyun
127*4882a593Smuzhiyun if (validate_addr(hptr[i], 1))
128*4882a593Smuzhiyun return 1;
129*4882a593Smuzhiyun }
130*4882a593Smuzhiyun hchunks = i;
131*4882a593Smuzhiyun
132*4882a593Smuzhiyun for (i = 0; i < lchunks; i++)
133*4882a593Smuzhiyun munmap(ptr[i], MAP_CHUNK_SIZE);
134*4882a593Smuzhiyun
135*4882a593Smuzhiyun for (i = 0; i < hchunks; i++)
136*4882a593Smuzhiyun munmap(hptr[i], MAP_CHUNK_SIZE);
137*4882a593Smuzhiyun
138*4882a593Smuzhiyun return 0;
139*4882a593Smuzhiyun }
140