gh0s7/mckernel
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add test programs for lage page

Browse Source 
Tests arm64 specific, contiguous bit based large pages as well.

Change-Id: I09edad8cfde6c23a259f1f32cfc97974d9cb63c3
This commit is contained in:
Masamichi Takagi
2018-12-07 19:28:51 +09:00
committed by Dominique Martinet
parent 100754f556
commit 9f7425c152
86 changed files with 5024 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

72
test/large_page/arm64/001_4K.c Normal file
View File

@@ -0,0 +1,72 @@
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/mman.h>
#include "../util.h"
#define PAGE_SHIFT_64K 16
#define PAGE_SIZE_64K (1UL << PAGE_SHIFT_64K)
#define PAGE_SHIFT_2M 21
#define PAGE_SIZE_2M (1UL << PAGE_SHIFT_2M)
#define PAGE_SHIFT_32M 25
#define PAGE_SIZE_32M (1UL << PAGE_SHIFT_32M)
#define PAGE_SHIFT_1G 30
#define PAGE_SIZE_1G (1UL << PAGE_SHIFT_1G)
int trial_num;
int mmap_thp(size_t page_size)
{
char *addr_mmap;
addr_mmap = mmap(0, page_size,
PROT_READ | PROT_WRITE,
MAP_ANONYMOUS | MAP_PRIVATE,
-1, 0);
NG(addr_mmap != (void *)-1, "mmap failed\n");
addr_mmap[0] = 'z';
NG(__atomic_load_n(addr_mmap, __ATOMIC_SEQ_CST) == 'z',
"memory access failed\n");
printf("large page request, trial#: %03d, addr: %016lx, size: %ld\n",
trial_num++, (unsigned long)addr_mmap, page_size);
munmap(addr_mmap, page_size);
return 0;
fn_fail:
return 1;
}
int main(int argc, char **argv)
{
int ret;
ret = mmap_thp(PAGE_SIZE_64K);
NG(ret == 0, "mmap_thp failed, size: %ld\n",
PAGE_SIZE_64K);
ret = mmap_thp(PAGE_SIZE_2M);
NG(ret == 0, "mmap_thp failed, size: %ld\n",
PAGE_SIZE_2M);
ret = mmap_thp(PAGE_SIZE_32M);
NG(ret == 0, "mmap_thp failed, size: %ld\n",
PAGE_SIZE_32M);
ret = mmap_thp(PAGE_SIZE_1G);
NG(ret == 0, "mmap_thp failed, size: %ld\n",
PAGE_SIZE_1G);
return 0;
fn_fail:
return 1;
}

56
test/large_page/arm64/001_64K.c Normal file
View File

@@ -0,0 +1,56 @@
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/mman.h>
#include "../util.h"
#define PAGE_SHIFT_2M 21
#define PAGE_SIZE_2M (1UL << PAGE_SHIFT_2M)
#define PAGE_SHIFT_512M 29
#define PAGE_SIZE_512M (1UL << PAGE_SHIFT_512M)
int trial_num;
int mmap_thp(size_t page_size)
{
char *addr_mmap;
addr_mmap = mmap(0, page_size,
PROT_READ | PROT_WRITE,
MAP_ANONYMOUS | MAP_PRIVATE,
-1, 0);
NG(addr_mmap != (void *)-1, "mmap failed\n");
addr_mmap[0] = 'z';
NG(__atomic_load_n(addr_mmap, __ATOMIC_SEQ_CST) == 'z',
"memory access failed\n");
printf("large page request, trial#: %03d, addr: %016lx, size: %ld\n",
trial_num++, (unsigned long)addr_mmap, page_size);
munmap(addr_mmap, page_size);
return 0;
fn_fail:
return 1;
}
int main(int argc, char **argv)
{
int ret;
ret = mmap_thp(PAGE_SIZE_2M);
NG(ret == 0, "mmap_thp failed, size: %ld\n",
PAGE_SIZE_2M);
ret = mmap_thp(PAGE_SIZE_512M);
NG(ret == 0, "mmap_thp failed, size: %ld\n",
PAGE_SIZE_512M);
return 0;
fn_fail:
return 1;
}

75
test/large_page/arm64/101_4K.c Normal file
View File

@@ -0,0 +1,75 @@
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/mman.h>
#include "../util.h"
#define PAGE_SHIFT_64K 16
#define PAGE_SIZE_64K (1UL << PAGE_SHIFT_64K)
#define PAGE_SHIFT_2M 21
#define PAGE_SIZE_2M (1UL << PAGE_SHIFT_2M)
#define PAGE_SHIFT_32M 25
#define PAGE_SIZE_32M (1UL << PAGE_SHIFT_32M)
#define PAGE_SHIFT_1G 30
#define PAGE_SIZE_1G (1UL << PAGE_SHIFT_1G)
#define MAP_HUGE_SHIFT 26
int trial_num;
int mmap_flag(size_t page_size, unsigned long page_shift)
{
char *addr_mmap;
addr_mmap = mmap(0, page_size,
PROT_READ | PROT_WRITE,
MAP_ANONYMOUS | MAP_PRIVATE |
MAP_HUGETLB | (page_shift << MAP_HUGE_SHIFT),
-1, 0);
NG(addr_mmap != (void *)-1, "mmap failed\n");
addr_mmap[0] = 'z';
NG(__atomic_load_n(addr_mmap, __ATOMIC_SEQ_CST) == 'z',
"memory access failed\n");
printf("large page request, trial#: %03d, addr: %016lx, size: %ld\n",
trial_num++, (unsigned long)addr_mmap, page_size);
munmap(addr_mmap, page_size);
return 0;
fn_fail:
return 1;
}
int main(int argc, char **argv)
{
int ret;
ret = mmap_flag(PAGE_SIZE_64K, PAGE_SHIFT_64K);
NG(ret == 0, "mmap_flag failed, size: %ld\n",
PAGE_SIZE_64K);
ret = mmap_flag(PAGE_SIZE_2M, PAGE_SHIFT_2M);
NG(ret == 0, "mmap_flag failed, size: %ld\n",
PAGE_SIZE_2M);
ret = mmap_flag(PAGE_SIZE_32M, PAGE_SHIFT_32M);
NG(ret == 0, "mmap_flag failed, size: %ld\n",
PAGE_SIZE_32M);
ret = mmap_flag(PAGE_SIZE_1G, PAGE_SHIFT_1G);
NG(ret == 0, "mmap_flag failed, size: %ld\n",
PAGE_SIZE_1G);
return 0;
fn_fail:
return 1;
}

59
test/large_page/arm64/101_64K.c Normal file
View File

@@ -0,0 +1,59 @@
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/mman.h>
#include "../util.h"
#define PAGE_SHIFT_2M 21
#define PAGE_SIZE_2M (1UL << PAGE_SHIFT_2M)
#define PAGE_SHIFT_512M 29
#define PAGE_SIZE_512M (1UL << PAGE_SHIFT_512M)
#define MAP_HUGE_SHIFT 26
int trial_num;
int mmap_flag(size_t page_size, unsigned long page_shift)
{
char *addr_mmap;
addr_mmap = mmap(0, page_size,
PROT_READ | PROT_WRITE,
MAP_ANONYMOUS | MAP_PRIVATE |
MAP_HUGETLB | (page_shift << MAP_HUGE_SHIFT),
-1, 0);
NG(addr_mmap != (void *)-1, "mmap failed\n");
addr_mmap[0] = 'z';
NG(__atomic_load_n(addr_mmap, __ATOMIC_SEQ_CST) == 'z',
"memory access failed\n");
printf("large page request, trial#: %03d, addr: %016lx, size: %ld\n",
trial_num++, (unsigned long)addr_mmap, page_size);
munmap(addr_mmap, page_size);
return 0;
fn_fail:
return 1;
}
int main(int argc, char **argv)
{
int ret;
ret = mmap_flag(PAGE_SIZE_2M, PAGE_SHIFT_2M);
NG(ret == 0, "mmap_flag failed, size: %ld\n",
PAGE_SIZE_2M);
ret = mmap_flag(PAGE_SIZE_512M, PAGE_SHIFT_512M);
NG(ret == 0, "mmap_flag failed, size: %ld\n",
PAGE_SIZE_512M);
return 0;
fn_fail:
return 1;
}

81
test/large_page/arm64/201_4K.c Normal file
View File

@@ -0,0 +1,81 @@
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include "../util.h"
#define PAGE_SHIFT_64K 16
#define PAGE_SIZE_64K (1UL << PAGE_SHIFT_64K)
#define PAGE_SHIFT_2M 21
#define PAGE_SIZE_2M (1UL << PAGE_SHIFT_2M)
#define PAGE_SHIFT_32M 25
#define PAGE_SIZE_32M (1UL << PAGE_SHIFT_32M)
#define PAGE_SHIFT_1G 30
#define PAGE_SIZE_1G (1UL << PAGE_SHIFT_1G)
int trial_num;
int shmat_thp(char **argv, size_t page_size)
{
int ret;
key_t key;
int shmid;
struct shmid_ds shmid_ds;
char *addr_shmget;
key = ftok(argv[0], 0);
shmid = shmget(key, page_size, IPC_CREAT | 0660);
NG(shmid != -1, "shmget failed\n");
addr_shmget = shmat(shmid, NULL, 0);
NG(addr_shmget != (void *)-1, "shmat failed\n");
addr_shmget[0] = 'z';
NG(__atomic_load_n(addr_shmget, __ATOMIC_SEQ_CST) == 'z',
"memory access failed\n");
printf("large page request, trial#: %03d, addr: %016lx, size: %ld\n",
trial_num++, (unsigned long)addr_shmget, page_size);
ret = shmdt(addr_shmget);
NG(ret != -1, "shmdt failed\n");
ret = shmctl(shmid, IPC_RMID, &shmid_ds);
NG(ret != -1, "shmctl failed\n");
return 0;
fn_fail:
return 1;
}
int main(int argc, char **argv)
{
int ret;
ret = shmat_thp(argv, PAGE_SIZE_64K);
NG(ret == 0, "shmat_thp failed, size: %ld\n",
PAGE_SIZE_64K);
ret = shmat_thp(argv, PAGE_SIZE_2M);
NG(ret == 0, "shmat_thp failed, size: %ld\n",
PAGE_SIZE_2M);
ret = shmat_thp(argv, PAGE_SIZE_32M);
NG(ret == 0, "shmat_thp failed, size: %ld\n",
PAGE_SIZE_32M);
ret = shmat_thp(argv, PAGE_SIZE_1G);
NG(ret == 0, "shmat_thp failed, size: %ld\n",
PAGE_SIZE_1G);
return 0;
fn_fail:
return 1;
}

66
test/large_page/arm64/201_64K.c Normal file
View File

@@ -0,0 +1,66 @@
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include "../util.h"
#define PAGE_SHIFT_2M 21
#define PAGE_SIZE_2M (1UL << PAGE_SHIFT_2M)
#define PAGE_SHIFT_512M 29
#define PAGE_SIZE_512M (1UL << PAGE_SHIFT_512M)
int trial_num;
int shmat_thp(char **argv, size_t page_size)
{
int ret;
key_t key;
int shmid;
struct shmid_ds shmid_ds;
char *addr_shmget;
key = ftok(argv[0], 0);
shmid = shmget(key, page_size, IPC_CREAT | 0660);
NG(shmid != -1, "shmget failed\n");
addr_shmget = shmat(shmid, NULL, 0);
NG(addr_shmget != (void *)-1, "shmat failed\n");
addr_shmget[0] = 'z';
NG(__atomic_load_n(addr_shmget, __ATOMIC_SEQ_CST) == 'z',
"memory access failed\n");
printf("large page request, trial#: %03d, addr: %016lx, size: %ld\n",
trial_num++, (unsigned long)addr_shmget, page_size);
ret = shmctl(shmid, IPC_RMID, &shmid_ds);
NG(ret != -1, "shmctl failed\n");
ret = shmdt(addr_shmget);
NG(ret != -1, "shmdt failed\n");
return 0;
fn_fail:
return 1;
}
int main(int argc, char **argv)
{
int ret;
ret = shmat_thp(argv, PAGE_SIZE_2M);
NG(ret == 0, "shmat_thp failed, size: %ld\n",
PAGE_SIZE_2M);
ret = shmat_thp(argv, PAGE_SIZE_512M);
NG(ret == 0, "shmat_thp failed, size: %ld\n",
PAGE_SIZE_512M);
return 0;
fn_fail:
return 1;
}

84
test/large_page/arm64/301_4K.c Normal file
View File

@@ -0,0 +1,84 @@
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include "../util.h"
#define PAGE_SHIFT_64K 16
#define PAGE_SIZE_64K (1UL << PAGE_SHIFT_64K)
#define PAGE_SHIFT_2M 21
#define PAGE_SIZE_2M (1UL << PAGE_SHIFT_2M)
#define PAGE_SHIFT_32M 25
#define PAGE_SIZE_32M (1UL << PAGE_SHIFT_32M)
#define PAGE_SHIFT_1G 30
#define PAGE_SIZE_1G (1UL << PAGE_SHIFT_1G)
#define SHM_HUGE_SHIFT 26
int trial_num;
int shmat_thp(char **argv, size_t page_size, unsigned long page_shift)
{
int ret;
key_t key;
int shmid;
struct shmid_ds shmid_ds;
char *addr_shmget;
key = ftok(argv[0], 0);
shmid = shmget(key, page_size, IPC_CREAT | 0660 |
SHM_HUGETLB | (page_shift << SHM_HUGE_SHIFT));
NG(shmid != -1, "shmget failed\n");
addr_shmget = shmat(shmid, NULL, 0);
NG(addr_shmget != (void *)-1, "shmat failed\n");
addr_shmget[0] = 'z';
NG(__atomic_load_n(addr_shmget, __ATOMIC_SEQ_CST) == 'z',
"memory access failed\n");
printf("large page request, trial#: %03d, addr: %016lx, size: %ld\n",
trial_num++, (unsigned long)addr_shmget, page_size);
ret = shmctl(shmid, IPC_RMID, &shmid_ds);
NG(ret != -1, "shmctl failed\n");
ret = shmdt(addr_shmget);
NG(ret != -1, "shmdt failed\n");
return 0;
fn_fail:
return 1;
}
int main(int argc, char **argv)
{
int ret;
ret = shmat_thp(argv, PAGE_SIZE_64K, PAGE_SHIFT_64K);
NG(ret == 0, "shmat_thp failed, size: %ld\n",
PAGE_SIZE_64K);
ret = shmat_thp(argv, PAGE_SIZE_2M, PAGE_SHIFT_2M);
NG(ret == 0, "shmat_thp failed, size: %ld\n",
PAGE_SIZE_2M);
ret = shmat_thp(argv, PAGE_SIZE_32M, PAGE_SHIFT_32M);
NG(ret == 0, "shmat_thp failed, size: %ld\n",
PAGE_SIZE_32M);
ret = shmat_thp(argv, PAGE_SIZE_1G, PAGE_SHIFT_1G);
NG(ret == 0, "shmat_thp failed, size: %ld\n",
PAGE_SIZE_1G);
return 0;
fn_fail:
return 1;
}

69
test/large_page/arm64/301_64K.c Normal file
View File

@@ -0,0 +1,69 @@
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include "../util.h"
#define PAGE_SHIFT_2M 21
#define PAGE_SIZE_2M (1UL << PAGE_SHIFT_2M)
#define PAGE_SHIFT_512M 29
#define PAGE_SIZE_512M (1UL << PAGE_SHIFT_512M)
#define SHM_HUGE_SHIFT 26
int trial_num;
int shmat_thp(char **argv, size_t page_size, unsigned long page_shift)
{
int ret;
key_t key;
int shmid;
struct shmid_ds shmid_ds;
char *addr_shmget;
key = ftok(argv[0], 0);
shmid = shmget(key, page_size, IPC_CREAT | 0660 |
SHM_HUGETLB | (page_shift << SHM_HUGE_SHIFT));
NG(shmid != -1, "shmget failed\n");
addr_shmget = shmat(shmid, NULL, 0);
NG(addr_shmget != (void *)-1, "shmat failed\n");
addr_shmget[0] = 'z';
NG(__atomic_load_n(addr_shmget, __ATOMIC_SEQ_CST) == 'z',
"memory access failed\n");
printf("large page request, trial#: %03d, addr: %016lx, size: %ld\n",
trial_num++, (unsigned long)addr_shmget, page_size);
ret = shmctl(shmid, IPC_RMID, &shmid_ds);
NG(ret != -1, "shmctl failed\n");
ret = shmdt(addr_shmget);
NG(ret != -1, "shmdt failed\n");
return 0;
fn_fail:
return 1;
}
int main(int argc, char **argv)
{
int ret;
ret = shmat_thp(argv, PAGE_SIZE_2M, PAGE_SHIFT_2M);
NG(ret == 0, "shmat_thp failed, size: %ld\n",
PAGE_SIZE_2M);
ret = shmat_thp(argv, PAGE_SIZE_512M, PAGE_SHIFT_512M);
NG(ret == 0, "shmat_thp failed, size: %ld\n",
PAGE_SIZE_512M);
return 0;
fn_fail:
return 1;
}

35
test/large_page/arm64/401_4K.c Normal file
View File

@@ -0,0 +1,35 @@
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/wait.h>
#include <sys/mman.h>
#include <sys/shm.h>
#include "../util.h"
#define TARGET_PAGE_SHIFT 16
#define TARGET_PAGE_SIZE (1UL << TARGET_PAGE_SHIFT)
int main(int argc, char **argv)
{
char *addr_brk;
int trial_num = 0;
/* Assuming heap size starts from zero and
* incremented by the amount specified with mcexec -h
*/
addr_brk = sbrk(TARGET_PAGE_SIZE);
NG(addr_brk != (void *)-1, "sbrk failed");
addr_brk[0] = 'z';
NG(__atomic_load_n(addr_brk, __ATOMIC_SEQ_CST) == 'z',
"memory access failed\n");
printf("large page request, trial#: %03d, addr: %016lx, size: %ld\n",
trial_num++, (unsigned long)addr_brk, TARGET_PAGE_SIZE);
return 0;
fn_fail:
return 1;
}

35
test/large_page/arm64/401_64K.c Normal file
View File

@@ -0,0 +1,35 @@
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/wait.h>
#include <sys/mman.h>
#include <sys/shm.h>
#include "../util.h"
#define TARGET_PAGE_SHIFT 21
#define TARGET_PAGE_SIZE (1UL << TARGET_PAGE_SHIFT)
int main(int argc, char **argv)
{
char *addr_brk;
int trial_num = 0;
/* Assuming heap size starts from zero and
* incremented by the amount specified with mcexec -h
*/
addr_brk = sbrk(TARGET_PAGE_SIZE);
NG(addr_brk != (void *)-1, "sbrk failed\n");
addr_brk[0] = 'z';
NG(__atomic_load_n(addr_brk, __ATOMIC_SEQ_CST) == 'z',
"memory access failed\n");
printf("large page request, trial#: %03d, addr: %016lx, size: %ld\n",
trial_num++, (unsigned long)addr_brk, TARGET_PAGE_SIZE);
return 0;
fn_fail:
return 1;
}

35
test/large_page/arm64/402_4K.c Normal file
View File

@@ -0,0 +1,35 @@
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/wait.h>
#include <sys/mman.h>
#include <sys/shm.h>
#include "../util.h"
#define TARGET_PAGE_SHIFT 21
#define TARGET_PAGE_SIZE (1UL << TARGET_PAGE_SHIFT)
int main(int argc, char **argv)
{
char *addr_brk;
int trial_num = 0;
/* Assuming heap size starts from zero and
* incremented by the amount specified with mcexec -h
*/
addr_brk = sbrk(TARGET_PAGE_SIZE);
NG(addr_brk != (void *)-1, "sbrk failed");
addr_brk[0] = 'z';
NG(__atomic_load_n(addr_brk, __ATOMIC_SEQ_CST) == 'z',
"memory access failed\n");
printf("large page request, trial#: %03d, addr: %016lx, size: %ld\n",
trial_num++, (unsigned long)addr_brk, TARGET_PAGE_SIZE);
return 0;
fn_fail:
return 1;
}

35
test/large_page/arm64/402_64K.c Normal file
View File

@@ -0,0 +1,35 @@
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/wait.h>
#include <sys/mman.h>
#include <sys/shm.h>
#include "../util.h"
#define TARGET_PAGE_SHIFT 29
#define TARGET_PAGE_SIZE (1UL << TARGET_PAGE_SHIFT)
int main(int argc, char **argv)
{
char *addr_brk;
int trial_num = 0;
/* Assuming heap size starts from zero and
* incremented by the amount specified with mcexec -h
*/
addr_brk = sbrk(TARGET_PAGE_SIZE);
NG(addr_brk != (void *)-1, "sbrk failed\n");
addr_brk[0] = 'z';
NG(__atomic_load_n(addr_brk, __ATOMIC_SEQ_CST) == 'z',
"memory access failed\n");
printf("large page request, trial#: %03d, addr: %016lx, size: %ld\n",
trial_num++, (unsigned long)addr_brk, TARGET_PAGE_SIZE);
return 0;
fn_fail:
return 1;
}

35
test/large_page/arm64/403_4K.c Normal file
View File

@@ -0,0 +1,35 @@
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/wait.h>
#include <sys/mman.h>
#include <sys/shm.h>
#include "../util.h"
#define TARGET_PAGE_SHIFT 25
#define TARGET_PAGE_SIZE (1UL << TARGET_PAGE_SHIFT)
int main(int argc, char **argv)
{
char *addr_brk;
int trial_num = 0;
/* Assuming heap size starts from zero and
* incremented by the amount specified with mcexec -h
*/
addr_brk = sbrk(TARGET_PAGE_SIZE);
NG(addr_brk != (void *)-1, "sbrk failed");
addr_brk[0] = 'z';
NG(__atomic_load_n(addr_brk, __ATOMIC_SEQ_CST) == 'z',
"memory access failed\n");
printf("large page request, trial#: %03d, addr: %016lx, size: %ld\n",
trial_num++, (unsigned long)addr_brk, TARGET_PAGE_SIZE);
return 0;
fn_fail:
return 1;
}

35
test/large_page/arm64/404_4K.c Normal file
View File

@@ -0,0 +1,35 @@
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/wait.h>
#include <sys/mman.h>
#include <sys/shm.h>
#include "../util.h"
#define TARGET_PAGE_SHIFT 30
#define TARGET_PAGE_SIZE (1UL << TARGET_PAGE_SHIFT)
int main(int argc, char **argv)
{
char *addr_brk;
int trial_num = 0;
/* Assuming heap size starts from zero and
* incremented by the amount specified with mcexec -h
*/
addr_brk = sbrk(TARGET_PAGE_SIZE);
NG(addr_brk != (void *)-1, "sbrk failed");
addr_brk[0] = 'z';
NG(__atomic_load_n(addr_brk, __ATOMIC_SEQ_CST) == 'z',
"memory access failed\n");
printf("large page request, trial#: %03d, addr: %016lx, size: %ld\n",
trial_num++, (unsigned long)addr_brk, TARGET_PAGE_SIZE);
return 0;
fn_fail:
return 1;
}

50
test/large_page/arm64/501_4K.c Normal file
View File

@@ -0,0 +1,50 @@
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/wait.h>
#include <sys/mman.h>
#include <sys/shm.h>
#include "../util.h"
#define TARGET_PAGE_SHIFT 16
#define TARGET_PAGE_SIZE (1UL << TARGET_PAGE_SHIFT)
/* .data */
char addr_data[TARGET_PAGE_SIZE] = { 1 };
/* .bss */
char addr_bss[TARGET_PAGE_SIZE];
int main(int argc, char **argv)
{
int trial_num = 0;
char addr_stack[TARGET_PAGE_SIZE]
__attribute__((aligned(TARGET_PAGE_SIZE)));
/* .data */
addr_data[0] = 'z';
NG(__atomic_load_n(addr_data, __ATOMIC_SEQ_CST) == 'z',
"memory access failed\n");
printf("large page request, trial#: %03d, addr: %016lx, size: %ld\n",
trial_num++, (unsigned long)addr_data, TARGET_PAGE_SIZE);
/* .bss */
addr_bss[0] = 'z';
NG(__atomic_load_n(addr_bss, __ATOMIC_SEQ_CST) == 'z',
"memory access failed\n");
printf("large page request, trial#: %03d, addr: %016lx, size: %ld\n",
trial_num++, (unsigned long)addr_bss, TARGET_PAGE_SIZE);
/* stack */
addr_stack[0] = 'z';
NG(__atomic_load_n(addr_stack, __ATOMIC_SEQ_CST) == 'z',
"memory access failed\n");
printf("large page request, trial#: %03d, addr: %016lx, size: %ld\n",
trial_num++, (unsigned long)addr_stack, TARGET_PAGE_SIZE);
return 0;
fn_fail:
return 1;
}

224
test/large_page/arm64/501_4K.lds Normal file
View File

@@ -0,0 +1,224 @@
/* Script for -z combreloc: combine and sort reloc sections */
/* Copyright (C) 2014-2016 Free Software Foundation, Inc.
Copying and distribution of this script, with or without modification,
are permitted in any medium without royalty provided the copyright
notice and this notice are preserved. */
OUTPUT_FORMAT("elf64-littleaarch64", "elf64-bigaarch64",
"elf64-littleaarch64")
OUTPUT_ARCH(aarch64)
ENTRY(_start)
SEARCH_DIR("=/usr/aarch64-redhat-linux/lib64"); SEARCH_DIR("=/usr/lib64"); SEARCH_DIR("=/usr/local/lib64"); SEARCH_DIR("=/lib64"); SEARCH_DIR("=/usr/aarch64-redhat-linux/lib"); SEARCH_DIR("=/usr/local/lib"); SEARCH_DIR("=/lib"); SEARCH_DIR("=/usr/lib");
SECTIONS
{
/* Read-only sections, merged into text segment: */
PROVIDE (__executable_start = SEGMENT_START("text-segment", 0x400000)); . = SEGMENT_START("text-segment", 0x400000) + SIZEOF_HEADERS;
.interp : { *(.interp) }
.note.gnu.build-id : { *(.note.gnu.build-id) }
.hash : { *(.hash) }
.gnu.hash : { *(.gnu.hash) }
.dynsym : { *(.dynsym) }
.dynstr : { *(.dynstr) }
.gnu.version : { *(.gnu.version) }
.gnu.version_d : { *(.gnu.version_d) }
.gnu.version_r : { *(.gnu.version_r) }
.rela.dyn :
{
*(.rela.init)
*(.rela.text .rela.text.* .rela.gnu.linkonce.t.*)
*(.rela.fini)
*(.rela.rodata .rela.rodata.* .rela.gnu.linkonce.r.*)
*(.rela.data .rela.data.* .rela.gnu.linkonce.d.*)
*(.rela.tdata .rela.tdata.* .rela.gnu.linkonce.td.*)
*(.rela.tbss .rela.tbss.* .rela.gnu.linkonce.tb.*)
*(.rela.ctors)
*(.rela.dtors)
*(.rela.got)
*(.rela.bss .rela.bss.* .rela.gnu.linkonce.b.*)
*(.rela.ifunc)
}
.rela.plt :
{
*(.rela.plt)
PROVIDE_HIDDEN (__rela_iplt_start = .);
*(.rela.iplt)
PROVIDE_HIDDEN (__rela_iplt_end = .);
}
.init :
{
KEEP (*(SORT_NONE(.init)))
} =0
.plt : ALIGN(16) { *(.plt) *(.iplt) }
.text :
{
*(.text.unlikely .text.*_unlikely .text.unlikely.*)
*(.text.exit .text.exit.*)
*(.text.startup .text.startup.*)
*(.text.hot .text.hot.*)
*(.text .stub .text.* .gnu.linkonce.t.*)
/* .gnu.warning sections are handled specially by elf32.em. */
*(.gnu.warning)
} =0
.fini :
{
KEEP (*(SORT_NONE(.fini)))
} =0
PROVIDE (__etext = .);
PROVIDE (_etext = .);
PROVIDE (etext = .);
.rodata : { *(.rodata .rodata.* .gnu.linkonce.r.*) }
.rodata1 : { *(.rodata1) }
.eh_frame_hdr : { *(.eh_frame_hdr) *(.eh_frame_entry .eh_frame_entry.*) }
.eh_frame : ONLY_IF_RO { KEEP (*(.eh_frame)) *(.eh_frame.*) }
.gcc_except_table : ONLY_IF_RO { *(.gcc_except_table
.gcc_except_table.*) }
.gnu_extab : ONLY_IF_RO { *(.gnu_extab*) }
/* These sections are generated by the Sun/Oracle C++ compiler. */
.exception_ranges : ONLY_IF_RO { *(.exception_ranges
.exception_ranges*) }
/* Adjust the address for the data segment. We want to adjust up to
the same address within the page on the next page up. */
. = DATA_SEGMENT_ALIGN (CONSTANT (MAXPAGESIZE), CONSTANT (COMMONPAGESIZE));
/* Exception handling */
.eh_frame : ONLY_IF_RW { KEEP (*(.eh_frame)) *(.eh_frame.*) }
.gnu_extab : ONLY_IF_RW { *(.gnu_extab) }
.gcc_except_table : ONLY_IF_RW { *(.gcc_except_table .gcc_except_table.*) }
.exception_ranges : ONLY_IF_RW { *(.exception_ranges .exception_ranges*) }
/* Thread Local Storage sections */
.tdata : { *(.tdata .tdata.* .gnu.linkonce.td.*) }
.tbss : { *(.tbss .tbss.* .gnu.linkonce.tb.*) *(.tcommon) }
.preinit_array :
{
PROVIDE_HIDDEN (__preinit_array_start = .);
KEEP (*(.preinit_array))
PROVIDE_HIDDEN (__preinit_array_end = .);
}
. = ALIGN(0x10000);
.init_array :
{
PROVIDE_HIDDEN (__init_array_start = .);
KEEP (*(SORT_BY_INIT_PRIORITY(.init_array.*) SORT_BY_INIT_PRIORITY(.ctors.*)))
KEEP (*(.init_array EXCLUDE_FILE (*crtbegin.o *crtbegin?.o *crtend.o *crtend?.o ) .ctors))
PROVIDE_HIDDEN (__init_array_end = .);
}
.fini_array :
{
PROVIDE_HIDDEN (__fini_array_start = .);
KEEP (*(SORT_BY_INIT_PRIORITY(.fini_array.*) SORT_BY_INIT_PRIORITY(.dtors.*)))
KEEP (*(.fini_array EXCLUDE_FILE (*crtbegin.o *crtbegin?.o *crtend.o *crtend?.o ) .dtors))
PROVIDE_HIDDEN (__fini_array_end = .);
}
.ctors :
{
/* gcc uses crtbegin.o to find the start of
the constructors, so we make sure it is
first. Because this is a wildcard, it
doesn't matter if the user does not
actually link against crtbegin.o; the
linker won't look for a file to match a
wildcard. The wildcard also means that it
doesn't matter which directory crtbegin.o
is in. */
KEEP (*crtbegin.o(.ctors))
KEEP (*crtbegin?.o(.ctors))
/* We don't want to include the .ctor section from
the crtend.o file until after the sorted ctors.
The .ctor section from the crtend file contains the
end of ctors marker and it must be last */
KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .ctors))
KEEP (*(SORT(.ctors.*)))
KEEP (*(.ctors))
}
.dtors :
{
KEEP (*crtbegin.o(.dtors))
KEEP (*crtbegin?.o(.dtors))
KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .dtors))
KEEP (*(SORT(.dtors.*)))
KEEP (*(.dtors))
}
.jcr : { KEEP (*(.jcr)) }
.data.rel.ro : { *(.data.rel.ro.local* .gnu.linkonce.d.rel.ro.local.*) *(.data.rel.ro .data.rel.ro.* .gnu.linkonce.d.rel.ro.*) }
.dynamic : { *(.dynamic) }
.got : { *(.got) *(.igot) }
. = DATA_SEGMENT_RELRO_END (24, .);
.got.plt : { *(.got.plt) *(.igot.plt) }
. = ALIGN(0x10000);
.data :
{
addr_data = .;
PROVIDE (__data_start = .);
*(.data .data.* .gnu.linkonce.d.*)
SORT(CONSTRUCTORS)
. = ALIGN(0x10000);
}
.data1 : { *(.data1) }
_edata = .; PROVIDE (edata = .);
. = .;
. = ALIGN(0x10000);
__bss_start = .;
__bss_start__ = .;
.bss :
{
addr_bss = .;
*(.dynbss)
*(.bss .bss.* .gnu.linkonce.b.*)
*(COMMON)
/* Align here to ensure that the .bss section occupies space up to
_end. Align after .bss to ensure correct alignment even if the
.bss section disappears because there are no input sections.
FIXME: Why do we need it? When there is no .bss section, we don't
pad the .data section. */
. = ALIGN(. != 0 ? 64 / 8 : 1);
. = ALIGN(0x10000);
}
_bss_end__ = . ; __bss_end__ = . ;
. = ALIGN(64 / 8);
. = SEGMENT_START("ldata-segment", .);
. = ALIGN(64 / 8);
__end__ = . ;
_end = .; PROVIDE (end = .);
. = DATA_SEGMENT_END (.);
/* Stabs debugging sections. */
.stab 0 : { *(.stab) }
.stabstr 0 : { *(.stabstr) }
.stab.excl 0 : { *(.stab.excl) }
.stab.exclstr 0 : { *(.stab.exclstr) }
.stab.index 0 : { *(.stab.index) }
.stab.indexstr 0 : { *(.stab.indexstr) }
.comment 0 : { *(.comment) }
/* DWARF debug sections.
Symbols in the DWARF debugging sections are relative to the beginning
of the section so we begin them at 0. */
/* DWARF 1 */
.debug 0 : { *(.debug) }
.line 0 : { *(.line) }
/* GNU DWARF 1 extensions */
.debug_srcinfo 0 : { *(.debug_srcinfo) }
.debug_sfnames 0 : { *(.debug_sfnames) }
/* DWARF 1.1 and DWARF 2 */
.debug_aranges 0 : { *(.debug_aranges) }
.debug_pubnames 0 : { *(.debug_pubnames) }
/* DWARF 2 */
.debug_info 0 : { *(.debug_info .gnu.linkonce.wi.*) }
.debug_abbrev 0 : { *(.debug_abbrev) }
.debug_line 0 : { *(.debug_line .debug_line.* .debug_line_end ) }
.debug_frame 0 : { *(.debug_frame) }
.debug_str 0 : { *(.debug_str) }
.debug_loc 0 : { *(.debug_loc) }
.debug_macinfo 0 : { *(.debug_macinfo) }
/* SGI/MIPS DWARF 2 extensions */
.debug_weaknames 0 : { *(.debug_weaknames) }
.debug_funcnames 0 : { *(.debug_funcnames) }
.debug_typenames 0 : { *(.debug_typenames) }
.debug_varnames 0 : { *(.debug_varnames) }
/* DWARF 3 */
.debug_pubtypes 0 : { *(.debug_pubtypes) }
.debug_ranges 0 : { *(.debug_ranges) }
/* DWARF Extension. */
.debug_macro 0 : { *(.debug_macro) }
.ARM.attributes 0 : { KEEP (*(.ARM.attributes)) KEEP (*(.gnu.attributes)) }
.note.gnu.arm.ident 0 : { KEEP (*(.note.gnu.arm.ident)) }
/DISCARD/ : { *(.note.GNU-stack) *(.gnu_debuglink) *(.gnu.lto_*) }
}

50
test/large_page/arm64/501_64K.c Normal file
View File

@@ -0,0 +1,50 @@
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/wait.h>
#include <sys/mman.h>
#include <sys/shm.h>
#include "../util.h"
#define TARGET_PAGE_SHIFT 21
#define TARGET_PAGE_SIZE (1UL << TARGET_PAGE_SHIFT)
/* .data */
char addr_data[TARGET_PAGE_SIZE] = { 1 };
/* .bss */
char addr_bss[TARGET_PAGE_SIZE];
int main(int argc, char **argv)
{
int trial_num = 0;
char addr_stack[TARGET_PAGE_SIZE]
__attribute__((aligned(TARGET_PAGE_SIZE)));
/* .data */
addr_data[0] = 'z';
NG(__atomic_load_n(addr_data, __ATOMIC_SEQ_CST) == 'z',
"memory access failed\n");
printf("large page request, trial#: %03d, addr: %016lx, size: %ld\n",
trial_num++, (unsigned long)addr_data, TARGET_PAGE_SIZE);
/* .bss */
addr_bss[0] = 'z';
NG(__atomic_load_n(addr_bss, __ATOMIC_SEQ_CST) == 'z',
"memory access failed\n");
printf("large page request, trial#: %03d, addr: %016lx, size: %ld\n",
trial_num++, (unsigned long)addr_bss, TARGET_PAGE_SIZE);
/* stack */
addr_stack[0] = 'z';
NG(__atomic_load_n(addr_stack, __ATOMIC_SEQ_CST) == 'z',
"memory access failed\n");
printf("large page request, trial#: %03d, addr: %016lx, size: %ld\n",
trial_num++, (unsigned long)addr_stack, TARGET_PAGE_SIZE);
return 0;
fn_fail:
return 1;
}

224
test/large_page/arm64/501_64K.lds Normal file
View File

@@ -0,0 +1,224 @@
/* Script for -z combreloc: combine and sort reloc sections */
/* Copyright (C) 2014-2016 Free Software Foundation, Inc.
Copying and distribution of this script, with or without modification,
are permitted in any medium without royalty provided the copyright
notice and this notice are preserved. */
OUTPUT_FORMAT("elf64-littleaarch64", "elf64-bigaarch64",
"elf64-littleaarch64")
OUTPUT_ARCH(aarch64)
ENTRY(_start)
SEARCH_DIR("=/usr/aarch64-redhat-linux/lib64"); SEARCH_DIR("=/usr/lib64"); SEARCH_DIR("=/usr/local/lib64"); SEARCH_DIR("=/lib64"); SEARCH_DIR("=/usr/aarch64-redhat-linux/lib"); SEARCH_DIR("=/usr/local/lib"); SEARCH_DIR("=/lib"); SEARCH_DIR("=/usr/lib");
SECTIONS
{
/* Read-only sections, merged into text segment: */
PROVIDE (__executable_start = SEGMENT_START("text-segment", 0x400000)); . = SEGMENT_START("text-segment", 0x400000) + SIZEOF_HEADERS;
.interp : { *(.interp) }
.note.gnu.build-id : { *(.note.gnu.build-id) }
.hash : { *(.hash) }
.gnu.hash : { *(.gnu.hash) }
.dynsym : { *(.dynsym) }
.dynstr : { *(.dynstr) }
.gnu.version : { *(.gnu.version) }
.gnu.version_d : { *(.gnu.version_d) }
.gnu.version_r : { *(.gnu.version_r) }
.rela.dyn :
{
*(.rela.init)
*(.rela.text .rela.text.* .rela.gnu.linkonce.t.*)
*(.rela.fini)
*(.rela.rodata .rela.rodata.* .rela.gnu.linkonce.r.*)
*(.rela.data .rela.data.* .rela.gnu.linkonce.d.*)
*(.rela.tdata .rela.tdata.* .rela.gnu.linkonce.td.*)
*(.rela.tbss .rela.tbss.* .rela.gnu.linkonce.tb.*)
*(.rela.ctors)
*(.rela.dtors)
*(.rela.got)
*(.rela.bss .rela.bss.* .rela.gnu.linkonce.b.*)
*(.rela.ifunc)
}
.rela.plt :
{
*(.rela.plt)
PROVIDE_HIDDEN (__rela_iplt_start = .);
*(.rela.iplt)
PROVIDE_HIDDEN (__rela_iplt_end = .);
}
.init :
{
KEEP (*(SORT_NONE(.init)))
} =0
.plt : ALIGN(16) { *(.plt) *(.iplt) }
.text :
{
*(.text.unlikely .text.*_unlikely .text.unlikely.*)
*(.text.exit .text.exit.*)
*(.text.startup .text.startup.*)
*(.text.hot .text.hot.*)
*(.text .stub .text.* .gnu.linkonce.t.*)
/* .gnu.warning sections are handled specially by elf32.em. */
*(.gnu.warning)
} =0
.fini :
{
KEEP (*(SORT_NONE(.fini)))
} =0
PROVIDE (__etext = .);
PROVIDE (_etext = .);
PROVIDE (etext = .);
.rodata : { *(.rodata .rodata.* .gnu.linkonce.r.*) }
.rodata1 : { *(.rodata1) }
.eh_frame_hdr : { *(.eh_frame_hdr) *(.eh_frame_entry .eh_frame_entry.*) }
.eh_frame : ONLY_IF_RO { KEEP (*(.eh_frame)) *(.eh_frame.*) }
.gcc_except_table : ONLY_IF_RO { *(.gcc_except_table
.gcc_except_table.*) }
.gnu_extab : ONLY_IF_RO { *(.gnu_extab*) }
/* These sections are generated by the Sun/Oracle C++ compiler. */
.exception_ranges : ONLY_IF_RO { *(.exception_ranges
.exception_ranges*) }
/* Adjust the address for the data segment. We want to adjust up to
the same address within the page on the next page up. */
. = DATA_SEGMENT_ALIGN (CONSTANT (MAXPAGESIZE), CONSTANT (COMMONPAGESIZE));
/* Exception handling */
.eh_frame : ONLY_IF_RW { KEEP (*(.eh_frame)) *(.eh_frame.*) }
.gnu_extab : ONLY_IF_RW { *(.gnu_extab) }
.gcc_except_table : ONLY_IF_RW { *(.gcc_except_table .gcc_except_table.*) }
.exception_ranges : ONLY_IF_RW { *(.exception_ranges .exception_ranges*) }
/* Thread Local Storage sections */
.tdata : { *(.tdata .tdata.* .gnu.linkonce.td.*) }
.tbss : { *(.tbss .tbss.* .gnu.linkonce.tb.*) *(.tcommon) }
.preinit_array :
{
PROVIDE_HIDDEN (__preinit_array_start = .);
KEEP (*(.preinit_array))
PROVIDE_HIDDEN (__preinit_array_end = .);
}
. = ALIGN(0x200000);
.init_array :
{
PROVIDE_HIDDEN (__init_array_start = .);
KEEP (*(SORT_BY_INIT_PRIORITY(.init_array.*) SORT_BY_INIT_PRIORITY(.ctors.*)))
KEEP (*(.init_array EXCLUDE_FILE (*crtbegin.o *crtbegin?.o *crtend.o *crtend?.o ) .ctors))
PROVIDE_HIDDEN (__init_array_end = .);
}
.fini_array :
{
PROVIDE_HIDDEN (__fini_array_start = .);
KEEP (*(SORT_BY_INIT_PRIORITY(.fini_array.*) SORT_BY_INIT_PRIORITY(.dtors.*)))
KEEP (*(.fini_array EXCLUDE_FILE (*crtbegin.o *crtbegin?.o *crtend.o *crtend?.o ) .dtors))
PROVIDE_HIDDEN (__fini_array_end = .);
}
.ctors :
{
/* gcc uses crtbegin.o to find the start of
the constructors, so we make sure it is
first. Because this is a wildcard, it
doesn't matter if the user does not
actually link against crtbegin.o; the
linker won't look for a file to match a
wildcard. The wildcard also means that it
doesn't matter which directory crtbegin.o
is in. */
KEEP (*crtbegin.o(.ctors))
KEEP (*crtbegin?.o(.ctors))
/* We don't want to include the .ctor section from
the crtend.o file until after the sorted ctors.
The .ctor section from the crtend file contains the
end of ctors marker and it must be last */
KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .ctors))
KEEP (*(SORT(.ctors.*)))
KEEP (*(.ctors))
}
.dtors :
{
KEEP (*crtbegin.o(.dtors))
KEEP (*crtbegin?.o(.dtors))
KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .dtors))
KEEP (*(SORT(.dtors.*)))
KEEP (*(.dtors))
}
.jcr : { KEEP (*(.jcr)) }
.data.rel.ro : { *(.data.rel.ro.local* .gnu.linkonce.d.rel.ro.local.*) *(.data.rel.ro .data.rel.ro.* .gnu.linkonce.d.rel.ro.*) }
.dynamic : { *(.dynamic) }
.got : { *(.got) *(.igot) }
. = DATA_SEGMENT_RELRO_END (24, .);
.got.plt : { *(.got.plt) *(.igot.plt) }
. = ALIGN(0x200000);
.data :
{
addr_data = .;
PROVIDE (__data_start = .);
*(.data .data.* .gnu.linkonce.d.*)
SORT(CONSTRUCTORS)
. = ALIGN(0x200000);
}
.data1 : { *(.data1) }
_edata = .; PROVIDE (edata = .);
. = .;
. = ALIGN(0x200000);
__bss_start = .;
__bss_start__ = .;
.bss :
{
addr_bss = .;
*(.dynbss)
*(.bss .bss.* .gnu.linkonce.b.*)
*(COMMON)
/* Align here to ensure that the .bss section occupies space up to
_end. Align after .bss to ensure correct alignment even if the
.bss section disappears because there are no input sections.
FIXME: Why do we need it? When there is no .bss section, we don't
pad the .data section. */
. = ALIGN(. != 0 ? 64 / 8 : 1);
. = ALIGN(0x200000);
}
_bss_end__ = . ; __bss_end__ = . ;
. = ALIGN(64 / 8);
. = SEGMENT_START("ldata-segment", .);
. = ALIGN(64 / 8);
__end__ = . ;
_end = .; PROVIDE (end = .);
. = DATA_SEGMENT_END (.);
/* Stabs debugging sections. */
.stab 0 : { *(.stab) }
.stabstr 0 : { *(.stabstr) }
.stab.excl 0 : { *(.stab.excl) }
.stab.exclstr 0 : { *(.stab.exclstr) }
.stab.index 0 : { *(.stab.index) }
.stab.indexstr 0 : { *(.stab.indexstr) }
.comment 0 : { *(.comment) }
/* DWARF debug sections.
Symbols in the DWARF debugging sections are relative to the beginning
of the section so we begin them at 0. */
/* DWARF 1 */
.debug 0 : { *(.debug) }
.line 0 : { *(.line) }
/* GNU DWARF 1 extensions */
.debug_srcinfo 0 : { *(.debug_srcinfo) }
.debug_sfnames 0 : { *(.debug_sfnames) }
/* DWARF 1.1 and DWARF 2 */
.debug_aranges 0 : { *(.debug_aranges) }
.debug_pubnames 0 : { *(.debug_pubnames) }
/* DWARF 2 */
.debug_info 0 : { *(.debug_info .gnu.linkonce.wi.*) }
.debug_abbrev 0 : { *(.debug_abbrev) }
.debug_line 0 : { *(.debug_line .debug_line.* .debug_line_end ) }
.debug_frame 0 : { *(.debug_frame) }
.debug_str 0 : { *(.debug_str) }
.debug_loc 0 : { *(.debug_loc) }
.debug_macinfo 0 : { *(.debug_macinfo) }
/* SGI/MIPS DWARF 2 extensions */
.debug_weaknames 0 : { *(.debug_weaknames) }
.debug_funcnames 0 : { *(.debug_funcnames) }
.debug_typenames 0 : { *(.debug_typenames) }
.debug_varnames 0 : { *(.debug_varnames) }
/* DWARF 3 */
.debug_pubtypes 0 : { *(.debug_pubtypes) }
.debug_ranges 0 : { *(.debug_ranges) }
/* DWARF Extension. */
.debug_macro 0 : { *(.debug_macro) }
.ARM.attributes 0 : { KEEP (*(.ARM.attributes)) KEEP (*(.gnu.attributes)) }
.note.gnu.arm.ident 0 : { KEEP (*(.note.gnu.arm.ident)) }
/DISCARD/ : { *(.note.GNU-stack) *(.gnu_debuglink) *(.gnu.lto_*) }
}

268
test/large_page/arm64/501_64K.org.lds Normal file
View File

@@ -0,0 +1,268 @@
GNU ld version 2.27-27.base.el7
Supported emulations:
aarch64linux
aarch64elf
aarch64elf32
aarch64elf32b
aarch64elfb
armelf
armelfb
aarch64linuxb
aarch64linux32
aarch64linux32b
armelfb_linux_eabi
armelf_linux_eabi
using internal linker script:
==================================================
/* Script for -z combreloc: combine and sort reloc sections */
/* Copyright (C) 2014-2016 Free Software Foundation, Inc.
Copying and distribution of this script, with or without modification,
are permitted in any medium without royalty provided the copyright
notice and this notice are preserved. */
OUTPUT_FORMAT("elf64-littleaarch64", "elf64-bigaarch64",
"elf64-littleaarch64")
OUTPUT_ARCH(aarch64)
ENTRY(_start)
SEARCH_DIR("=/usr/aarch64-redhat-linux/lib64"); SEARCH_DIR("=/usr/lib64"); SEARCH_DIR("=/usr/local/lib64"); SEARCH_DIR("=/lib64"); SEARCH_DIR("=/usr/aarch64-redhat-linux/lib"); SEARCH_DIR("=/usr/local/lib"); SEARCH_DIR("=/lib"); SEARCH_DIR("=/usr/lib");
SECTIONS
{
/* Read-only sections, merged into text segment: */
PROVIDE (__executable_start = SEGMENT_START("text-segment", 0x400000)); . = SEGMENT_START("text-segment", 0x400000) + SIZEOF_HEADERS;
.interp : { *(.interp) }
.note.gnu.build-id : { *(.note.gnu.build-id) }
.hash : { *(.hash) }
.gnu.hash : { *(.gnu.hash) }
.dynsym : { *(.dynsym) }
.dynstr : { *(.dynstr) }
.gnu.version : { *(.gnu.version) }
.gnu.version_d : { *(.gnu.version_d) }
.gnu.version_r : { *(.gnu.version_r) }
.rela.dyn :
{
*(.rela.init)
*(.rela.text .rela.text.* .rela.gnu.linkonce.t.*)
*(.rela.fini)
*(.rela.rodata .rela.rodata.* .rela.gnu.linkonce.r.*)
*(.rela.data .rela.data.* .rela.gnu.linkonce.d.*)
*(.rela.tdata .rela.tdata.* .rela.gnu.linkonce.td.*)
*(.rela.tbss .rela.tbss.* .rela.gnu.linkonce.tb.*)
*(.rela.ctors)
*(.rela.dtors)
*(.rela.got)
*(.rela.bss .rela.bss.* .rela.gnu.linkonce.b.*)
*(.rela.ifunc)
}
.rela.plt :
{
*(.rela.plt)
PROVIDE_HIDDEN (__rela_iplt_start = .);
*(.rela.iplt)
PROVIDE_HIDDEN (__rela_iplt_end = .);
}
.init :
{
KEEP (*(SORT_NONE(.init)))
} =0
.plt : ALIGN(16) { *(.plt) *(.iplt) }
.text :
{
*(.text.unlikely .text.*_unlikely .text.unlikely.*)
*(.text.exit .text.exit.*)
*(.text.startup .text.startup.*)
*(.text.hot .text.hot.*)
*(.text .stub .text.* .gnu.linkonce.t.*)
/* .gnu.warning sections are handled specially by elf32.em. */
*(.gnu.warning)
} =0
.fini :
{
KEEP (*(SORT_NONE(.fini)))
} =0
PROVIDE (__etext = .);
PROVIDE (_etext = .);
PROVIDE (etext = .);
.rodata : { *(.rodata .rodata.* .gnu.linkonce.r.*) }
.rodata1 : { *(.rodata1) }
.eh_frame_hdr : { *(.eh_frame_hdr) *(.eh_frame_entry .eh_frame_entry.*) }
.eh_frame : ONLY_IF_RO { KEEP (*(.eh_frame)) *(.eh_frame.*) }
.gcc_except_table : ONLY_IF_RO { *(.gcc_except_table
.gcc_except_table.*) }
.gnu_extab : ONLY_IF_RO { *(.gnu_extab*) }
/* These sections are generated by the Sun/Oracle C++ compiler. */
.exception_ranges : ONLY_IF_RO { *(.exception_ranges
.exception_ranges*) }
/* Adjust the address for the data segment. We want to adjust up to
the same address within the page on the next page up. */
. = DATA_SEGMENT_ALIGN (CONSTANT (MAXPAGESIZE), CONSTANT (COMMONPAGESIZE));
/* Exception handling */
.eh_frame : ONLY_IF_RW { KEEP (*(.eh_frame)) *(.eh_frame.*) }
.gnu_extab : ONLY_IF_RW { *(.gnu_extab) }
.gcc_except_table : ONLY_IF_RW { *(.gcc_except_table .gcc_except_table.*) }
.exception_ranges : ONLY_IF_RW { *(.exception_ranges .exception_ranges*) }
/* Thread Local Storage sections */
.tdata : { *(.tdata .tdata.* .gnu.linkonce.td.*) }
.tbss : { *(.tbss .tbss.* .gnu.linkonce.tb.*) *(.tcommon) }
.preinit_array :
{
PROVIDE_HIDDEN (__preinit_array_start = .);
KEEP (*(.preinit_array))
PROVIDE_HIDDEN (__preinit_array_end = .);
}
.init_array :
{
PROVIDE_HIDDEN (__init_array_start = .);
KEEP (*(SORT_BY_INIT_PRIORITY(.init_array.*) SORT_BY_INIT_PRIORITY(.ctors.*)))
KEEP (*(.init_array EXCLUDE_FILE (*crtbegin.o *crtbegin?.o *crtend.o *crtend?.o ) .ctors))
PROVIDE_HIDDEN (__init_array_end = .);
}
.fini_array :
{
PROVIDE_HIDDEN (__fini_array_start = .);
KEEP (*(SORT_BY_INIT_PRIORITY(.fini_array.*) SORT_BY_INIT_PRIORITY(.dtors.*)))
KEEP (*(.fini_array EXCLUDE_FILE (*crtbegin.o *crtbegin?.o *crtend.o *crtend?.o ) .dtors))
PROVIDE_HIDDEN (__fini_array_end = .);
}
.ctors :
{
/* gcc uses crtbegin.o to find the start of
the constructors, so we make sure it is
first. Because this is a wildcard, it
doesn't matter if the user does not
actually link against crtbegin.o; the
linker won't look for a file to match a
wildcard. The wildcard also means that it
doesn't matter which directory crtbegin.o
is in. */
KEEP (*crtbegin.o(.ctors))
KEEP (*crtbegin?.o(.ctors))
/* We don't want to include the .ctor section from
the crtend.o file until after the sorted ctors.
The .ctor section from the crtend file contains the
end of ctors marker and it must be last */
KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .ctors))
KEEP (*(SORT(.ctors.*)))
KEEP (*(.ctors))
}
.dtors :
{
KEEP (*crtbegin.o(.dtors))
KEEP (*crtbegin?.o(.dtors))
KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .dtors))
KEEP (*(SORT(.dtors.*)))
KEEP (*(.dtors))
}
.jcr : { KEEP (*(.jcr)) }
.data.rel.ro : { *(.data.rel.ro.local* .gnu.linkonce.d.rel.ro.local.*) *(.data.rel.ro .data.rel.ro.* .gnu.linkonce.d.rel.ro.*) }
.dynamic : { *(.dynamic) }
.got : { *(.got) *(.igot) }
. = DATA_SEGMENT_RELRO_END (24, .);
.got.plt : { *(.got.plt) *(.igot.plt) }
.data :
{
PROVIDE (__data_start = .);
*(.data .data.* .gnu.linkonce.d.*)
SORT(CONSTRUCTORS)
}
.data1 : { *(.data1) }
_edata = .; PROVIDE (edata = .);
. = .;
__bss_start = .;
__bss_start__ = .;
.bss :
{
*(.dynbss)
*(.bss .bss.* .gnu.linkonce.b.*)
*(COMMON)
/* Align here to ensure that the .bss section occupies space up to
_end. Align after .bss to ensure correct alignment even if the
.bss section disappears because there are no input sections.
FIXME: Why do we need it? When there is no .bss section, we don't
pad the .data section. */
. = ALIGN(. != 0 ? 64 / 8 : 1);
}
_bss_end__ = . ; __bss_end__ = . ;
. = ALIGN(64 / 8);
. = SEGMENT_START("ldata-segment", .);
. = ALIGN(64 / 8);
__end__ = . ;
_end = .; PROVIDE (end = .);
. = DATA_SEGMENT_END (.);
/* Stabs debugging sections. */
.stab 0 : { *(.stab) }
.stabstr 0 : { *(.stabstr) }
.stab.excl 0 : { *(.stab.excl) }
.stab.exclstr 0 : { *(.stab.exclstr) }
.stab.index 0 : { *(.stab.index) }
.stab.indexstr 0 : { *(.stab.indexstr) }
.comment 0 : { *(.comment) }
/* DWARF debug sections.
Symbols in the DWARF debugging sections are relative to the beginning
of the section so we begin them at 0. */
/* DWARF 1 */
.debug 0 : { *(.debug) }
.line 0 : { *(.line) }
/* GNU DWARF 1 extensions */
.debug_srcinfo 0 : { *(.debug_srcinfo) }
.debug_sfnames 0 : { *(.debug_sfnames) }
/* DWARF 1.1 and DWARF 2 */
.debug_aranges 0 : { *(.debug_aranges) }
.debug_pubnames 0 : { *(.debug_pubnames) }
/* DWARF 2 */
.debug_info 0 : { *(.debug_info .gnu.linkonce.wi.*) }
.debug_abbrev 0 : { *(.debug_abbrev) }
.debug_line 0 : { *(.debug_line .debug_line.* .debug_line_end ) }
.debug_frame 0 : { *(.debug_frame) }
.debug_str 0 : { *(.debug_str) }
.debug_loc 0 : { *(.debug_loc) }
.debug_macinfo 0 : { *(.debug_macinfo) }
/* SGI/MIPS DWARF 2 extensions */
.debug_weaknames 0 : { *(.debug_weaknames) }
.debug_funcnames 0 : { *(.debug_funcnames) }
.debug_typenames 0 : { *(.debug_typenames) }
.debug_varnames 0 : { *(.debug_varnames) }
/* DWARF 3 */
.debug_pubtypes 0 : { *(.debug_pubtypes) }
.debug_ranges 0 : { *(.debug_ranges) }
/* DWARF Extension. */
.debug_macro 0 : { *(.debug_macro) }
.ARM.attributes 0 : { KEEP (*(.ARM.attributes)) KEEP (*(.gnu.attributes)) }
.note.gnu.arm.ident 0 : { KEEP (*(.note.gnu.arm.ident)) }
/DISCARD/ : { *(.note.GNU-stack) *(.gnu_debuglink) *(.gnu.lto_*) }
}
==================================================
attempt to open /usr/lib/gcc/aarch64-redhat-linux/4.8.5/../../../../lib64/crt1.o succeeded
/usr/lib/gcc/aarch64-redhat-linux/4.8.5/../../../../lib64/crt1.o
attempt to open /usr/lib/gcc/aarch64-redhat-linux/4.8.5/../../../../lib64/crti.o succeeded
/usr/lib/gcc/aarch64-redhat-linux/4.8.5/../../../../lib64/crti.o
attempt to open /usr/lib/gcc/aarch64-redhat-linux/4.8.5/crtbegin.o succeeded
/usr/lib/gcc/aarch64-redhat-linux/4.8.5/crtbegin.o
attempt to open 501_64K.o succeeded
501_64K.o
attempt to open /usr/lib/gcc/aarch64-redhat-linux/4.8.5/libgcc.so failed
attempt to open /usr/lib/gcc/aarch64-redhat-linux/4.8.5/libgcc.a succeeded
attempt to open /usr/lib/gcc/aarch64-redhat-linux/4.8.5/libgcc_s.so succeeded
-lgcc_s (/usr/lib/gcc/aarch64-redhat-linux/4.8.5/libgcc_s.so)
attempt to open /usr/lib/gcc/aarch64-redhat-linux/4.8.5/libc.so failed
attempt to open /usr/lib/gcc/aarch64-redhat-linux/4.8.5/libc.a failed
attempt to open /usr/lib/gcc/aarch64-redhat-linux/4.8.5/../../../../lib64/libc.so succeeded
opened script file /usr/lib/gcc/aarch64-redhat-linux/4.8.5/../../../../lib64/libc.so
opened script file /usr/lib/gcc/aarch64-redhat-linux/4.8.5/../../../../lib64/libc.so
attempt to open /lib64/libc.so.6 succeeded
/lib64/libc.so.6
attempt to open /usr/lib64/libc_nonshared.a succeeded
(/usr/lib64/libc_nonshared.a)elf-init.oS
attempt to open /lib/ld-linux-aarch64.so.1 succeeded
/lib/ld-linux-aarch64.so.1
/lib/ld-linux-aarch64.so.1
attempt to open /usr/lib/gcc/aarch64-redhat-linux/4.8.5/libgcc.so failed
attempt to open /usr/lib/gcc/aarch64-redhat-linux/4.8.5/libgcc.a succeeded
attempt to open /usr/lib/gcc/aarch64-redhat-linux/4.8.5/libgcc_s.so succeeded
-lgcc_s (/usr/lib/gcc/aarch64-redhat-linux/4.8.5/libgcc_s.so)
attempt to open /usr/lib/gcc/aarch64-redhat-linux/4.8.5/crtend.o succeeded
/usr/lib/gcc/aarch64-redhat-linux/4.8.5/crtend.o
attempt to open /usr/lib/gcc/aarch64-redhat-linux/4.8.5/../../../../lib64/crtn.o succeeded
/usr/lib/gcc/aarch64-redhat-linux/4.8.5/../../../../lib64/crtn.o
ld-linux-aarch64.so.1 needed by /lib64/libc.so.6
found ld-linux-aarch64.so.1 at /lib/ld-linux-aarch64.so.1

50
test/large_page/arm64/502_4K.c Normal file
View File

@@ -0,0 +1,50 @@
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/wait.h>
#include <sys/mman.h>
#include <sys/shm.h>
#include "../util.h"
#define TARGET_PAGE_SHIFT 21
#define TARGET_PAGE_SIZE (1UL << TARGET_PAGE_SHIFT)
/* .data */
char addr_data[TARGET_PAGE_SIZE] = { 1 };
/* .bss */
char addr_bss[TARGET_PAGE_SIZE];
int main(int argc, char **argv)
{
int trial_num = 0;
char addr_stack[TARGET_PAGE_SIZE]
__attribute__((aligned(TARGET_PAGE_SIZE)));
/* .data */
addr_data[0] = 'z';
NG(__atomic_load_n(addr_data, __ATOMIC_SEQ_CST) == 'z',
"memory access failed\n");
printf("large page request, trial#: %03d, addr: %016lx, size: %ld\n",
trial_num++, (unsigned long)addr_data, TARGET_PAGE_SIZE);
/* .bss */
addr_bss[0] = 'z';
NG(__atomic_load_n(addr_bss, __ATOMIC_SEQ_CST) == 'z',
"memory access failed\n");
printf("large page request, trial#: %03d, addr: %016lx, size: %ld\n",
trial_num++, (unsigned long)addr_bss, TARGET_PAGE_SIZE);
/* stack */
addr_stack[0] = 'z';
NG(__atomic_load_n(addr_stack, __ATOMIC_SEQ_CST) == 'z',
"memory access failed\n");
printf("large page request, trial#: %03d, addr: %016lx, size: %ld\n",
trial_num++, (unsigned long)addr_stack, TARGET_PAGE_SIZE);
return 0;
fn_fail:
return 1;
}

224
test/large_page/arm64/502_4K.lds Normal file
View File

@@ -0,0 +1,224 @@
/* Script for -z combreloc: combine and sort reloc sections */
/* Copyright (C) 2014-2016 Free Software Foundation, Inc.
Copying and distribution of this script, with or without modification,
are permitted in any medium without royalty provided the copyright
notice and this notice are preserved. */
OUTPUT_FORMAT("elf64-littleaarch64", "elf64-bigaarch64",
"elf64-littleaarch64")
OUTPUT_ARCH(aarch64)
ENTRY(_start)
SEARCH_DIR("=/usr/aarch64-redhat-linux/lib64"); SEARCH_DIR("=/usr/lib64"); SEARCH_DIR("=/usr/local/lib64"); SEARCH_DIR("=/lib64"); SEARCH_DIR("=/usr/aarch64-redhat-linux/lib"); SEARCH_DIR("=/usr/local/lib"); SEARCH_DIR("=/lib"); SEARCH_DIR("=/usr/lib");
SECTIONS
{
/* Read-only sections, merged into text segment: */
PROVIDE (__executable_start = SEGMENT_START("text-segment", 0x400000)); . = SEGMENT_START("text-segment", 0x400000) + SIZEOF_HEADERS;
.interp : { *(.interp) }
.note.gnu.build-id : { *(.note.gnu.build-id) }
.hash : { *(.hash) }
.gnu.hash : { *(.gnu.hash) }
.dynsym : { *(.dynsym) }
.dynstr : { *(.dynstr) }
.gnu.version : { *(.gnu.version) }
.gnu.version_d : { *(.gnu.version_d) }
.gnu.version_r : { *(.gnu.version_r) }
.rela.dyn :
{
*(.rela.init)
*(.rela.text .rela.text.* .rela.gnu.linkonce.t.*)
*(.rela.fini)
*(.rela.rodata .rela.rodata.* .rela.gnu.linkonce.r.*)
*(.rela.data .rela.data.* .rela.gnu.linkonce.d.*)
*(.rela.tdata .rela.tdata.* .rela.gnu.linkonce.td.*)
*(.rela.tbss .rela.tbss.* .rela.gnu.linkonce.tb.*)
*(.rela.ctors)
*(.rela.dtors)
*(.rela.got)
*(.rela.bss .rela.bss.* .rela.gnu.linkonce.b.*)
*(.rela.ifunc)
}
.rela.plt :
{
*(.rela.plt)
PROVIDE_HIDDEN (__rela_iplt_start = .);
*(.rela.iplt)
PROVIDE_HIDDEN (__rela_iplt_end = .);
}
.init :
{
KEEP (*(SORT_NONE(.init)))
} =0
.plt : ALIGN(16) { *(.plt) *(.iplt) }
.text :
{
*(.text.unlikely .text.*_unlikely .text.unlikely.*)
*(.text.exit .text.exit.*)
*(.text.startup .text.startup.*)
*(.text.hot .text.hot.*)
*(.text .stub .text.* .gnu.linkonce.t.*)
/* .gnu.warning sections are handled specially by elf32.em. */
*(.gnu.warning)
} =0
.fini :
{
KEEP (*(SORT_NONE(.fini)))
} =0
PROVIDE (__etext = .);
PROVIDE (_etext = .);
PROVIDE (etext = .);
.rodata : { *(.rodata .rodata.* .gnu.linkonce.r.*) }
.rodata1 : { *(.rodata1) }
.eh_frame_hdr : { *(.eh_frame_hdr) *(.eh_frame_entry .eh_frame_entry.*) }
.eh_frame : ONLY_IF_RO { KEEP (*(.eh_frame)) *(.eh_frame.*) }
.gcc_except_table : ONLY_IF_RO { *(.gcc_except_table
.gcc_except_table.*) }
.gnu_extab : ONLY_IF_RO { *(.gnu_extab*) }
/* These sections are generated by the Sun/Oracle C++ compiler. */
.exception_ranges : ONLY_IF_RO { *(.exception_ranges
.exception_ranges*) }
/* Adjust the address for the data segment. We want to adjust up to
the same address within the page on the next page up. */
. = DATA_SEGMENT_ALIGN (CONSTANT (MAXPAGESIZE), CONSTANT (COMMONPAGESIZE));
/* Exception handling */
.eh_frame : ONLY_IF_RW { KEEP (*(.eh_frame)) *(.eh_frame.*) }
.gnu_extab : ONLY_IF_RW { *(.gnu_extab) }
.gcc_except_table : ONLY_IF_RW { *(.gcc_except_table .gcc_except_table.*) }
.exception_ranges : ONLY_IF_RW { *(.exception_ranges .exception_ranges*) }
/* Thread Local Storage sections */
.tdata : { *(.tdata .tdata.* .gnu.linkonce.td.*) }
.tbss : { *(.tbss .tbss.* .gnu.linkonce.tb.*) *(.tcommon) }
.preinit_array :
{
PROVIDE_HIDDEN (__preinit_array_start = .);
KEEP (*(.preinit_array))
PROVIDE_HIDDEN (__preinit_array_end = .);
}
. = ALIGN(0x200000);
.init_array :
{
PROVIDE_HIDDEN (__init_array_start = .);
KEEP (*(SORT_BY_INIT_PRIORITY(.init_array.*) SORT_BY_INIT_PRIORITY(.ctors.*)))
KEEP (*(.init_array EXCLUDE_FILE (*crtbegin.o *crtbegin?.o *crtend.o *crtend?.o ) .ctors))
PROVIDE_HIDDEN (__init_array_end = .);
}
.fini_array :
{
PROVIDE_HIDDEN (__fini_array_start = .);
KEEP (*(SORT_BY_INIT_PRIORITY(.fini_array.*) SORT_BY_INIT_PRIORITY(.dtors.*)))
KEEP (*(.fini_array EXCLUDE_FILE (*crtbegin.o *crtbegin?.o *crtend.o *crtend?.o ) .dtors))
PROVIDE_HIDDEN (__fini_array_end = .);
}
.ctors :
{
/* gcc uses crtbegin.o to find the start of
the constructors, so we make sure it is
first. Because this is a wildcard, it
doesn't matter if the user does not
actually link against crtbegin.o; the
linker won't look for a file to match a
wildcard. The wildcard also means that it
doesn't matter which directory crtbegin.o
is in. */
KEEP (*crtbegin.o(.ctors))
KEEP (*crtbegin?.o(.ctors))
/* We don't want to include the .ctor section from
the crtend.o file until after the sorted ctors.
The .ctor section from the crtend file contains the
end of ctors marker and it must be last */
KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .ctors))
KEEP (*(SORT(.ctors.*)))
KEEP (*(.ctors))
}
.dtors :
{
KEEP (*crtbegin.o(.dtors))
KEEP (*crtbegin?.o(.dtors))
KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .dtors))
KEEP (*(SORT(.dtors.*)))
KEEP (*(.dtors))
}
.jcr : { KEEP (*(.jcr)) }
.data.rel.ro : { *(.data.rel.ro.local* .gnu.linkonce.d.rel.ro.local.*) *(.data.rel.ro .data.rel.ro.* .gnu.linkonce.d.rel.ro.*) }
.dynamic : { *(.dynamic) }
.got : { *(.got) *(.igot) }
. = DATA_SEGMENT_RELRO_END (24, .);
.got.plt : { *(.got.plt) *(.igot.plt) }
. = ALIGN(0x200000);
.data :
{
addr_data = .;
PROVIDE (__data_start = .);
*(.data .data.* .gnu.linkonce.d.*)
SORT(CONSTRUCTORS)
. = ALIGN(0x200000);
}
.data1 : { *(.data1) }
_edata = .; PROVIDE (edata = .);
. = .;
. = ALIGN(0x200000);
__bss_start = .;
__bss_start__ = .;
.bss :
{
addr_bss = .;
*(.dynbss)
*(.bss .bss.* .gnu.linkonce.b.*)
*(COMMON)
/* Align here to ensure that the .bss section occupies space up to
_end. Align after .bss to ensure correct alignment even if the
.bss section disappears because there are no input sections.
FIXME: Why do we need it? When there is no .bss section, we don't
pad the .data section. */
. = ALIGN(. != 0 ? 64 / 8 : 1);
. = ALIGN(0x200000);
}
_bss_end__ = . ; __bss_end__ = . ;
. = ALIGN(64 / 8);
. = SEGMENT_START("ldata-segment", .);
. = ALIGN(64 / 8);
__end__ = . ;
_end = .; PROVIDE (end = .);
. = DATA_SEGMENT_END (.);
/* Stabs debugging sections. */
.stab 0 : { *(.stab) }
.stabstr 0 : { *(.stabstr) }
.stab.excl 0 : { *(.stab.excl) }
.stab.exclstr 0 : { *(.stab.exclstr) }
.stab.index 0 : { *(.stab.index) }
.stab.indexstr 0 : { *(.stab.indexstr) }
.comment 0 : { *(.comment) }
/* DWARF debug sections.
Symbols in the DWARF debugging sections are relative to the beginning
of the section so we begin them at 0. */
/* DWARF 1 */
.debug 0 : { *(.debug) }
.line 0 : { *(.line) }
/* GNU DWARF 1 extensions */
.debug_srcinfo 0 : { *(.debug_srcinfo) }
.debug_sfnames 0 : { *(.debug_sfnames) }
/* DWARF 1.1 and DWARF 2 */
.debug_aranges 0 : { *(.debug_aranges) }
.debug_pubnames 0 : { *(.debug_pubnames) }
/* DWARF 2 */
.debug_info 0 : { *(.debug_info .gnu.linkonce.wi.*) }
.debug_abbrev 0 : { *(.debug_abbrev) }
.debug_line 0 : { *(.debug_line .debug_line.* .debug_line_end ) }
.debug_frame 0 : { *(.debug_frame) }
.debug_str 0 : { *(.debug_str) }
.debug_loc 0 : { *(.debug_loc) }
.debug_macinfo 0 : { *(.debug_macinfo) }
/* SGI/MIPS DWARF 2 extensions */
.debug_weaknames 0 : { *(.debug_weaknames) }
.debug_funcnames 0 : { *(.debug_funcnames) }
.debug_typenames 0 : { *(.debug_typenames) }
.debug_varnames 0 : { *(.debug_varnames) }
/* DWARF 3 */
.debug_pubtypes 0 : { *(.debug_pubtypes) }
.debug_ranges 0 : { *(.debug_ranges) }
/* DWARF Extension. */
.debug_macro 0 : { *(.debug_macro) }
.ARM.attributes 0 : { KEEP (*(.ARM.attributes)) KEEP (*(.gnu.attributes)) }
.note.gnu.arm.ident 0 : { KEEP (*(.note.gnu.arm.ident)) }
/DISCARD/ : { *(.note.GNU-stack) *(.gnu_debuglink) *(.gnu.lto_*) }
}

41
test/large_page/arm64/502_64K.c Normal file
View File

@@ -0,0 +1,41 @@
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/wait.h>
#include <sys/mman.h>
#include <sys/shm.h>
#include "../util.h"
#define TARGET_PAGE_SHIFT 29
#define TARGET_PAGE_SIZE (1UL << TARGET_PAGE_SHIFT)
/* .data */
char addr_data[TARGET_PAGE_SIZE] = { 1 };
/* .bss */
char addr_bss[TARGET_PAGE_SIZE];
int main(int argc, char **argv)
{
int trial_num = 0;
/* .data */
addr_data[0] = 'z';
NG(__atomic_load_n(addr_data, __ATOMIC_SEQ_CST) == 'z',
"memory access failed\n");
printf("large page request, trial#: %03d, addr: %016lx, size: %ld\n",
trial_num++, (unsigned long)addr_data, TARGET_PAGE_SIZE);
/* .bss */
addr_bss[0] = 'z';
NG(__atomic_load_n(addr_bss, __ATOMIC_SEQ_CST) == 'z',
"memory access failed\n");
printf("large page request, trial#: %03d, addr: %016lx, size: %ld\n",
trial_num++, (unsigned long)addr_bss, TARGET_PAGE_SIZE);
return 0;
fn_fail:
return 1;
}

224
test/large_page/arm64/502_64K.lds Normal file
View File

@@ -0,0 +1,224 @@
/* Script for -z combreloc: combine and sort reloc sections */
/* Copyright (C) 2014-2016 Free Software Foundation, Inc.
Copying and distribution of this script, with or without modification,
are permitted in any medium without royalty provided the copyright
notice and this notice are preserved. */
OUTPUT_FORMAT("elf64-littleaarch64", "elf64-bigaarch64",
"elf64-littleaarch64")
OUTPUT_ARCH(aarch64)
ENTRY(_start)
SEARCH_DIR("=/usr/aarch64-redhat-linux/lib64"); SEARCH_DIR("=/usr/lib64"); SEARCH_DIR("=/usr/local/lib64"); SEARCH_DIR("=/lib64"); SEARCH_DIR("=/usr/aarch64-redhat-linux/lib"); SEARCH_DIR("=/usr/local/lib"); SEARCH_DIR("=/lib"); SEARCH_DIR("=/usr/lib");
SECTIONS
{
/* Read-only sections, merged into text segment: */
PROVIDE (__executable_start = SEGMENT_START("text-segment", 0x400000)); . = SEGMENT_START("text-segment", 0x400000) + SIZEOF_HEADERS;
.interp : { *(.interp) }
.note.gnu.build-id : { *(.note.gnu.build-id) }
.hash : { *(.hash) }
.gnu.hash : { *(.gnu.hash) }
.dynsym : { *(.dynsym) }
.dynstr : { *(.dynstr) }
.gnu.version : { *(.gnu.version) }
.gnu.version_d : { *(.gnu.version_d) }
.gnu.version_r : { *(.gnu.version_r) }
.rela.dyn :
{
*(.rela.init)
*(.rela.text .rela.text.* .rela.gnu.linkonce.t.*)
*(.rela.fini)
*(.rela.rodata .rela.rodata.* .rela.gnu.linkonce.r.*)
*(.rela.data .rela.data.* .rela.gnu.linkonce.d.*)
*(.rela.tdata .rela.tdata.* .rela.gnu.linkonce.td.*)
*(.rela.tbss .rela.tbss.* .rela.gnu.linkonce.tb.*)
*(.rela.ctors)
*(.rela.dtors)
*(.rela.got)
*(.rela.bss .rela.bss.* .rela.gnu.linkonce.b.*)
*(.rela.ifunc)
}
.rela.plt :
{
*(.rela.plt)
PROVIDE_HIDDEN (__rela_iplt_start = .);
*(.rela.iplt)
PROVIDE_HIDDEN (__rela_iplt_end = .);
}
.init :
{
KEEP (*(SORT_NONE(.init)))
} =0
.plt : ALIGN(16) { *(.plt) *(.iplt) }
.text :
{
*(.text.unlikely .text.*_unlikely .text.unlikely.*)
*(.text.exit .text.exit.*)
*(.text.startup .text.startup.*)
*(.text.hot .text.hot.*)
*(.text .stub .text.* .gnu.linkonce.t.*)
/* .gnu.warning sections are handled specially by elf32.em. */
*(.gnu.warning)
} =0
.fini :
{
KEEP (*(SORT_NONE(.fini)))
} =0
PROVIDE (__etext = .);
PROVIDE (_etext = .);
PROVIDE (etext = .);
.rodata : { *(.rodata .rodata.* .gnu.linkonce.r.*) }
.rodata1 : { *(.rodata1) }
.eh_frame_hdr : { *(.eh_frame_hdr) *(.eh_frame_entry .eh_frame_entry.*) }
.eh_frame : ONLY_IF_RO { KEEP (*(.eh_frame)) *(.eh_frame.*) }
.gcc_except_table : ONLY_IF_RO { *(.gcc_except_table
.gcc_except_table.*) }
.gnu_extab : ONLY_IF_RO { *(.gnu_extab*) }
/* These sections are generated by the Sun/Oracle C++ compiler. */
.exception_ranges : ONLY_IF_RO { *(.exception_ranges
.exception_ranges*) }
/* Adjust the address for the data segment. We want to adjust up to
the same address within the page on the next page up. */
. = DATA_SEGMENT_ALIGN (CONSTANT (MAXPAGESIZE), CONSTANT (COMMONPAGESIZE));
/* Exception handling */
.eh_frame : ONLY_IF_RW { KEEP (*(.eh_frame)) *(.eh_frame.*) }
.gnu_extab : ONLY_IF_RW { *(.gnu_extab) }
.gcc_except_table : ONLY_IF_RW { *(.gcc_except_table .gcc_except_table.*) }
.exception_ranges : ONLY_IF_RW { *(.exception_ranges .exception_ranges*) }
/* Thread Local Storage sections */
.tdata : { *(.tdata .tdata.* .gnu.linkonce.td.*) }
.tbss : { *(.tbss .tbss.* .gnu.linkonce.tb.*) *(.tcommon) }
.preinit_array :
{
PROVIDE_HIDDEN (__preinit_array_start = .);
KEEP (*(.preinit_array))
PROVIDE_HIDDEN (__preinit_array_end = .);
}
. = ALIGN(0x20000000);
.init_array :
{
PROVIDE_HIDDEN (__init_array_start = .);
KEEP (*(SORT_BY_INIT_PRIORITY(.init_array.*) SORT_BY_INIT_PRIORITY(.ctors.*)))
KEEP (*(.init_array EXCLUDE_FILE (*crtbegin.o *crtbegin?.o *crtend.o *crtend?.o ) .ctors))
PROVIDE_HIDDEN (__init_array_end = .);
}
.fini_array :
{
PROVIDE_HIDDEN (__fini_array_start = .);
KEEP (*(SORT_BY_INIT_PRIORITY(.fini_array.*) SORT_BY_INIT_PRIORITY(.dtors.*)))
KEEP (*(.fini_array EXCLUDE_FILE (*crtbegin.o *crtbegin?.o *crtend.o *crtend?.o ) .dtors))
PROVIDE_HIDDEN (__fini_array_end = .);
}
.ctors :
{
/* gcc uses crtbegin.o to find the start of
the constructors, so we make sure it is
first. Because this is a wildcard, it
doesn't matter if the user does not
actually link against crtbegin.o; the
linker won't look for a file to match a
wildcard. The wildcard also means that it
doesn't matter which directory crtbegin.o
is in. */
KEEP (*crtbegin.o(.ctors))
KEEP (*crtbegin?.o(.ctors))
/* We don't want to include the .ctor section from
the crtend.o file until after the sorted ctors.
The .ctor section from the crtend file contains the
end of ctors marker and it must be last */
KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .ctors))
KEEP (*(SORT(.ctors.*)))
KEEP (*(.ctors))
}
.dtors :
{
KEEP (*crtbegin.o(.dtors))
KEEP (*crtbegin?.o(.dtors))
KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .dtors))
KEEP (*(SORT(.dtors.*)))
KEEP (*(.dtors))
}
.jcr : { KEEP (*(.jcr)) }
.data.rel.ro : { *(.data.rel.ro.local* .gnu.linkonce.d.rel.ro.local.*) *(.data.rel.ro .data.rel.ro.* .gnu.linkonce.d.rel.ro.*) }
.dynamic : { *(.dynamic) }
.got : { *(.got) *(.igot) }
. = DATA_SEGMENT_RELRO_END (24, .);
.got.plt : { *(.got.plt) *(.igot.plt) }
. = ALIGN(0x20000000);
.data :
{
addr_data = .;
PROVIDE (__data_start = .);
*(.data .data.* .gnu.linkonce.d.*)
SORT(CONSTRUCTORS)
. = ALIGN(0x20000000);
}
.data1 : { *(.data1) }
_edata = .; PROVIDE (edata = .);
. = .;
. = ALIGN(0x20000000);
__bss_start = .;
__bss_start__ = .;
.bss :
{
addr_bss = .;
*(.dynbss)
*(.bss .bss.* .gnu.linkonce.b.*)
*(COMMON)
/* Align here to ensure that the .bss section occupies space up to
_end. Align after .bss to ensure correct alignment even if the
.bss section disappears because there are no input sections.
FIXME: Why do we need it? When there is no .bss section, we don't
pad the .data section. */
. = ALIGN(. != 0 ? 64 / 8 : 1);
. = ALIGN(0x20000000);
}
_bss_end__ = . ; __bss_end__ = . ;
. = ALIGN(64 / 8);
. = SEGMENT_START("ldata-segment", .);
. = ALIGN(64 / 8);
__end__ = . ;
_end = .; PROVIDE (end = .);
. = DATA_SEGMENT_END (.);
/* Stabs debugging sections. */
.stab 0 : { *(.stab) }
.stabstr 0 : { *(.stabstr) }
.stab.excl 0 : { *(.stab.excl) }
.stab.exclstr 0 : { *(.stab.exclstr) }
.stab.index 0 : { *(.stab.index) }
.stab.indexstr 0 : { *(.stab.indexstr) }
.comment 0 : { *(.comment) }
/* DWARF debug sections.
Symbols in the DWARF debugging sections are relative to the beginning
of the section so we begin them at 0. */
/* DWARF 1 */
.debug 0 : { *(.debug) }
.line 0 : { *(.line) }
/* GNU DWARF 1 extensions */
.debug_srcinfo 0 : { *(.debug_srcinfo) }
.debug_sfnames 0 : { *(.debug_sfnames) }
/* DWARF 1.1 and DWARF 2 */
.debug_aranges 0 : { *(.debug_aranges) }
.debug_pubnames 0 : { *(.debug_pubnames) }
/* DWARF 2 */
.debug_info 0 : { *(.debug_info .gnu.linkonce.wi.*) }
.debug_abbrev 0 : { *(.debug_abbrev) }
.debug_line 0 : { *(.debug_line .debug_line.* .debug_line_end ) }
.debug_frame 0 : { *(.debug_frame) }
.debug_str 0 : { *(.debug_str) }
.debug_loc 0 : { *(.debug_loc) }
.debug_macinfo 0 : { *(.debug_macinfo) }
/* SGI/MIPS DWARF 2 extensions */
.debug_weaknames 0 : { *(.debug_weaknames) }
.debug_funcnames 0 : { *(.debug_funcnames) }
.debug_typenames 0 : { *(.debug_typenames) }
.debug_varnames 0 : { *(.debug_varnames) }
/* DWARF 3 */
.debug_pubtypes 0 : { *(.debug_pubtypes) }
.debug_ranges 0 : { *(.debug_ranges) }
/* DWARF Extension. */
.debug_macro 0 : { *(.debug_macro) }
.ARM.attributes 0 : { KEEP (*(.ARM.attributes)) KEEP (*(.gnu.attributes)) }
.note.gnu.arm.ident 0 : { KEEP (*(.note.gnu.arm.ident)) }
/DISCARD/ : { *(.note.GNU-stack) *(.gnu_debuglink) *(.gnu.lto_*) }
}

50
test/large_page/arm64/503_4K.c Normal file
View File

@@ -0,0 +1,50 @@
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/wait.h>
#include <sys/mman.h>
#include <sys/shm.h>
#include "../util.h"
#define TARGET_PAGE_SHIFT 25
#define TARGET_PAGE_SIZE (1UL << TARGET_PAGE_SHIFT)
/* .data */
char addr_data[TARGET_PAGE_SIZE] = { 1 };
/* .bss */
char addr_bss[TARGET_PAGE_SIZE];
int main(int argc, char **argv)
{
int trial_num = 0;
char addr_stack[TARGET_PAGE_SIZE]
__attribute__((aligned(TARGET_PAGE_SIZE)));
/* .data */
addr_data[0] = 'z';
NG(__atomic_load_n(addr_data, __ATOMIC_SEQ_CST) == 'z',
"memory access failed\n");
printf("large page request, trial#: %03d, addr: %016lx, size: %ld\n",
trial_num++, (unsigned long)addr_data, TARGET_PAGE_SIZE);
/* .bss */
addr_bss[0] = 'z';
NG(__atomic_load_n(addr_bss, __ATOMIC_SEQ_CST) == 'z',
"memory access failed\n");
printf("large page request, trial#: %03d, addr: %016lx, size: %ld\n",
trial_num++, (unsigned long)addr_bss, TARGET_PAGE_SIZE);
/* stack */
addr_stack[0] = 'z';
NG(__atomic_load_n(addr_stack, __ATOMIC_SEQ_CST) == 'z',
"memory access failed\n");
printf("large page request, trial#: %03d, addr: %016lx, size: %ld\n",
trial_num++, (unsigned long)addr_stack, TARGET_PAGE_SIZE);
return 0;
fn_fail:
return 1;
}

224
test/large_page/arm64/503_4K.lds Normal file
View File

@@ -0,0 +1,224 @@
/* Script for -z combreloc: combine and sort reloc sections */
/* Copyright (C) 2014-2016 Free Software Foundation, Inc.
Copying and distribution of this script, with or without modification,
are permitted in any medium without royalty provided the copyright
notice and this notice are preserved. */
OUTPUT_FORMAT("elf64-littleaarch64", "elf64-bigaarch64",
"elf64-littleaarch64")
OUTPUT_ARCH(aarch64)
ENTRY(_start)
SEARCH_DIR("=/usr/aarch64-redhat-linux/lib64"); SEARCH_DIR("=/usr/lib64"); SEARCH_DIR("=/usr/local/lib64"); SEARCH_DIR("=/lib64"); SEARCH_DIR("=/usr/aarch64-redhat-linux/lib"); SEARCH_DIR("=/usr/local/lib"); SEARCH_DIR("=/lib"); SEARCH_DIR("=/usr/lib");
SECTIONS
{
/* Read-only sections, merged into text segment: */
PROVIDE (__executable_start = SEGMENT_START("text-segment", 0x400000)); . = SEGMENT_START("text-segment", 0x400000) + SIZEOF_HEADERS;
.interp : { *(.interp) }
.note.gnu.build-id : { *(.note.gnu.build-id) }
.hash : { *(.hash) }
.gnu.hash : { *(.gnu.hash) }
.dynsym : { *(.dynsym) }
.dynstr : { *(.dynstr) }
.gnu.version : { *(.gnu.version) }
.gnu.version_d : { *(.gnu.version_d) }
.gnu.version_r : { *(.gnu.version_r) }
.rela.dyn :
{
*(.rela.init)
*(.rela.text .rela.text.* .rela.gnu.linkonce.t.*)
*(.rela.fini)
*(.rela.rodata .rela.rodata.* .rela.gnu.linkonce.r.*)
*(.rela.data .rela.data.* .rela.gnu.linkonce.d.*)
*(.rela.tdata .rela.tdata.* .rela.gnu.linkonce.td.*)
*(.rela.tbss .rela.tbss.* .rela.gnu.linkonce.tb.*)
*(.rela.ctors)
*(.rela.dtors)
*(.rela.got)
*(.rela.bss .rela.bss.* .rela.gnu.linkonce.b.*)
*(.rela.ifunc)
}
.rela.plt :
{
*(.rela.plt)
PROVIDE_HIDDEN (__rela_iplt_start = .);
*(.rela.iplt)
PROVIDE_HIDDEN (__rela_iplt_end = .);
}
.init :
{
KEEP (*(SORT_NONE(.init)))
} =0
.plt : ALIGN(16) { *(.plt) *(.iplt) }
.text :
{
*(.text.unlikely .text.*_unlikely .text.unlikely.*)
*(.text.exit .text.exit.*)
*(.text.startup .text.startup.*)
*(.text.hot .text.hot.*)
*(.text .stub .text.* .gnu.linkonce.t.*)
/* .gnu.warning sections are handled specially by elf32.em. */
*(.gnu.warning)
} =0
.fini :
{
KEEP (*(SORT_NONE(.fini)))
} =0
PROVIDE (__etext = .);
PROVIDE (_etext = .);
PROVIDE (etext = .);
.rodata : { *(.rodata .rodata.* .gnu.linkonce.r.*) }
.rodata1 : { *(.rodata1) }
.eh_frame_hdr : { *(.eh_frame_hdr) *(.eh_frame_entry .eh_frame_entry.*) }
.eh_frame : ONLY_IF_RO { KEEP (*(.eh_frame)) *(.eh_frame.*) }
.gcc_except_table : ONLY_IF_RO { *(.gcc_except_table
.gcc_except_table.*) }
.gnu_extab : ONLY_IF_RO { *(.gnu_extab*) }
/* These sections are generated by the Sun/Oracle C++ compiler. */
.exception_ranges : ONLY_IF_RO { *(.exception_ranges
.exception_ranges*) }
/* Adjust the address for the data segment. We want to adjust up to
the same address within the page on the next page up. */
. = DATA_SEGMENT_ALIGN (CONSTANT (MAXPAGESIZE), CONSTANT (COMMONPAGESIZE));
/* Exception handling */
.eh_frame : ONLY_IF_RW { KEEP (*(.eh_frame)) *(.eh_frame.*) }
.gnu_extab : ONLY_IF_RW { *(.gnu_extab) }
.gcc_except_table : ONLY_IF_RW { *(.gcc_except_table .gcc_except_table.*) }
.exception_ranges : ONLY_IF_RW { *(.exception_ranges .exception_ranges*) }
/* Thread Local Storage sections */
.tdata : { *(.tdata .tdata.* .gnu.linkonce.td.*) }
.tbss : { *(.tbss .tbss.* .gnu.linkonce.tb.*) *(.tcommon) }
.preinit_array :
{
PROVIDE_HIDDEN (__preinit_array_start = .);
KEEP (*(.preinit_array))
PROVIDE_HIDDEN (__preinit_array_end = .);
}
. = ALIGN(0x2000000);
.init_array :
{
PROVIDE_HIDDEN (__init_array_start = .);
KEEP (*(SORT_BY_INIT_PRIORITY(.init_array.*) SORT_BY_INIT_PRIORITY(.ctors.*)))
KEEP (*(.init_array EXCLUDE_FILE (*crtbegin.o *crtbegin?.o *crtend.o *crtend?.o ) .ctors))
PROVIDE_HIDDEN (__init_array_end = .);
}
.fini_array :
{
PROVIDE_HIDDEN (__fini_array_start = .);
KEEP (*(SORT_BY_INIT_PRIORITY(.fini_array.*) SORT_BY_INIT_PRIORITY(.dtors.*)))
KEEP (*(.fini_array EXCLUDE_FILE (*crtbegin.o *crtbegin?.o *crtend.o *crtend?.o ) .dtors))
PROVIDE_HIDDEN (__fini_array_end = .);
}
.ctors :
{
/* gcc uses crtbegin.o to find the start of
the constructors, so we make sure it is
first. Because this is a wildcard, it
doesn't matter if the user does not
actually link against crtbegin.o; the
linker won't look for a file to match a
wildcard. The wildcard also means that it
doesn't matter which directory crtbegin.o
is in. */
KEEP (*crtbegin.o(.ctors))
KEEP (*crtbegin?.o(.ctors))
/* We don't want to include the .ctor section from
the crtend.o file until after the sorted ctors.
The .ctor section from the crtend file contains the
end of ctors marker and it must be last */
KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .ctors))
KEEP (*(SORT(.ctors.*)))
KEEP (*(.ctors))
}
.dtors :
{
KEEP (*crtbegin.o(.dtors))
KEEP (*crtbegin?.o(.dtors))
KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .dtors))
KEEP (*(SORT(.dtors.*)))
KEEP (*(.dtors))
}
.jcr : { KEEP (*(.jcr)) }
.data.rel.ro : { *(.data.rel.ro.local* .gnu.linkonce.d.rel.ro.local.*) *(.data.rel.ro .data.rel.ro.* .gnu.linkonce.d.rel.ro.*) }
.dynamic : { *(.dynamic) }
.got : { *(.got) *(.igot) }
. = DATA_SEGMENT_RELRO_END (24, .);
.got.plt : { *(.got.plt) *(.igot.plt) }
. = ALIGN(0x2000000);
.data :
{
addr_data = .;
PROVIDE (__data_start = .);
*(.data .data.* .gnu.linkonce.d.*)
SORT(CONSTRUCTORS)
. = ALIGN(0x2000000);
}
.data1 : { *(.data1) }
_edata = .; PROVIDE (edata = .);
. = .;
. = ALIGN(0x2000000);
__bss_start = .;
__bss_start__ = .;
.bss :
{
addr_bss = .;
*(.dynbss)
*(.bss .bss.* .gnu.linkonce.b.*)
*(COMMON)
/* Align here to ensure that the .bss section occupies space up to
_end. Align after .bss to ensure correct alignment even if the
.bss section disappears because there are no input sections.
FIXME: Why do we need it? When there is no .bss section, we don't
pad the .data section. */
. = ALIGN(. != 0 ? 64 / 8 : 1);
. = ALIGN(0x2000000);
}
_bss_end__ = . ; __bss_end__ = . ;
. = ALIGN(64 / 8);
. = SEGMENT_START("ldata-segment", .);
. = ALIGN(64 / 8);
__end__ = . ;
_end = .; PROVIDE (end = .);
. = DATA_SEGMENT_END (.);
/* Stabs debugging sections. */
.stab 0 : { *(.stab) }
.stabstr 0 : { *(.stabstr) }
.stab.excl 0 : { *(.stab.excl) }
.stab.exclstr 0 : { *(.stab.exclstr) }
.stab.index 0 : { *(.stab.index) }
.stab.indexstr 0 : { *(.stab.indexstr) }
.comment 0 : { *(.comment) }
/* DWARF debug sections.
Symbols in the DWARF debugging sections are relative to the beginning
of the section so we begin them at 0. */
/* DWARF 1 */
.debug 0 : { *(.debug) }
.line 0 : { *(.line) }
/* GNU DWARF 1 extensions */
.debug_srcinfo 0 : { *(.debug_srcinfo) }
.debug_sfnames 0 : { *(.debug_sfnames) }
/* DWARF 1.1 and DWARF 2 */
.debug_aranges 0 : { *(.debug_aranges) }
.debug_pubnames 0 : { *(.debug_pubnames) }
/* DWARF 2 */
.debug_info 0 : { *(.debug_info .gnu.linkonce.wi.*) }
.debug_abbrev 0 : { *(.debug_abbrev) }
.debug_line 0 : { *(.debug_line .debug_line.* .debug_line_end ) }
.debug_frame 0 : { *(.debug_frame) }
.debug_str 0 : { *(.debug_str) }
.debug_loc 0 : { *(.debug_loc) }
.debug_macinfo 0 : { *(.debug_macinfo) }
/* SGI/MIPS DWARF 2 extensions */
.debug_weaknames 0 : { *(.debug_weaknames) }
.debug_funcnames 0 : { *(.debug_funcnames) }
.debug_typenames 0 : { *(.debug_typenames) }
.debug_varnames 0 : { *(.debug_varnames) }
/* DWARF 3 */
.debug_pubtypes 0 : { *(.debug_pubtypes) }
.debug_ranges 0 : { *(.debug_ranges) }
/* DWARF Extension. */
.debug_macro 0 : { *(.debug_macro) }
.ARM.attributes 0 : { KEEP (*(.ARM.attributes)) KEEP (*(.gnu.attributes)) }
.note.gnu.arm.ident 0 : { KEEP (*(.note.gnu.arm.ident)) }
/DISCARD/ : { *(.note.GNU-stack) *(.gnu_debuglink) *(.gnu.lto_*) }
}

41
test/large_page/arm64/504_4K.c Normal file
View File

@@ -0,0 +1,41 @@
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/wait.h>
#include <sys/mman.h>
#include <sys/shm.h>
#include "../util.h"
#define TARGET_PAGE_SHIFT 30
#define TARGET_PAGE_SIZE (1UL << TARGET_PAGE_SHIFT)
/* .data */
char addr_data[TARGET_PAGE_SIZE] = { 1 };
/* .bss */
char addr_bss[TARGET_PAGE_SIZE];
int main(int argc, char **argv)
{
int trial_num = 0;
/* .data */
addr_data[0] = 'z';
NG(__atomic_load_n(addr_data, __ATOMIC_SEQ_CST) == 'z',
"memory access failed\n");
printf("large page request, trial#: %03d, addr: %016lx, size: %ld\n",
trial_num++, (unsigned long)addr_data, TARGET_PAGE_SIZE);
/* .bss */
addr_bss[0] = 'z';
NG(__atomic_load_n(addr_bss, __ATOMIC_SEQ_CST) == 'z',
"memory access failed\n");
printf("large page request, trial#: %03d, addr: %016lx, size: %ld\n",
trial_num++, (unsigned long)addr_bss, TARGET_PAGE_SIZE);
return 0;
fn_fail:
return 1;
}

224
test/large_page/arm64/504_4K.lds Normal file
View File

@@ -0,0 +1,224 @@
/* Script for -z combreloc: combine and sort reloc sections */
/* Copyright (C) 2014-2016 Free Software Foundation, Inc.
Copying and distribution of this script, with or without modification,
are permitted in any medium without royalty provided the copyright
notice and this notice are preserved. */
OUTPUT_FORMAT("elf64-littleaarch64", "elf64-bigaarch64",
"elf64-littleaarch64")
OUTPUT_ARCH(aarch64)
ENTRY(_start)
SEARCH_DIR("=/usr/aarch64-redhat-linux/lib64"); SEARCH_DIR("=/usr/lib64"); SEARCH_DIR("=/usr/local/lib64"); SEARCH_DIR("=/lib64"); SEARCH_DIR("=/usr/aarch64-redhat-linux/lib"); SEARCH_DIR("=/usr/local/lib"); SEARCH_DIR("=/lib"); SEARCH_DIR("=/usr/lib");
SECTIONS
{
/* Read-only sections, merged into text segment: */
PROVIDE (__executable_start = SEGMENT_START("text-segment", 0x400000)); . = SEGMENT_START("text-segment", 0x400000) + SIZEOF_HEADERS;
.interp : { *(.interp) }
.note.gnu.build-id : { *(.note.gnu.build-id) }
.hash : { *(.hash) }
.gnu.hash : { *(.gnu.hash) }
.dynsym : { *(.dynsym) }
.dynstr : { *(.dynstr) }
.gnu.version : { *(.gnu.version) }
.gnu.version_d : { *(.gnu.version_d) }
.gnu.version_r : { *(.gnu.version_r) }
.rela.dyn :
{
*(.rela.init)
*(.rela.text .rela.text.* .rela.gnu.linkonce.t.*)
*(.rela.fini)
*(.rela.rodata .rela.rodata.* .rela.gnu.linkonce.r.*)
*(.rela.data .rela.data.* .rela.gnu.linkonce.d.*)
*(.rela.tdata .rela.tdata.* .rela.gnu.linkonce.td.*)
*(.rela.tbss .rela.tbss.* .rela.gnu.linkonce.tb.*)
*(.rela.ctors)
*(.rela.dtors)
*(.rela.got)
*(.rela.bss .rela.bss.* .rela.gnu.linkonce.b.*)
*(.rela.ifunc)
}
.rela.plt :
{
*(.rela.plt)
PROVIDE_HIDDEN (__rela_iplt_start = .);
*(.rela.iplt)
PROVIDE_HIDDEN (__rela_iplt_end = .);
}
.init :
{
KEEP (*(SORT_NONE(.init)))
} =0
.plt : ALIGN(16) { *(.plt) *(.iplt) }
.text :
{
*(.text.unlikely .text.*_unlikely .text.unlikely.*)
*(.text.exit .text.exit.*)
*(.text.startup .text.startup.*)
*(.text.hot .text.hot.*)
*(.text .stub .text.* .gnu.linkonce.t.*)
/* .gnu.warning sections are handled specially by elf32.em. */
*(.gnu.warning)
} =0
.fini :
{
KEEP (*(SORT_NONE(.fini)))
} =0
PROVIDE (__etext = .);
PROVIDE (_etext = .);
PROVIDE (etext = .);
.rodata : { *(.rodata .rodata.* .gnu.linkonce.r.*) }
.rodata1 : { *(.rodata1) }
.eh_frame_hdr : { *(.eh_frame_hdr) *(.eh_frame_entry .eh_frame_entry.*) }
.eh_frame : ONLY_IF_RO { KEEP (*(.eh_frame)) *(.eh_frame.*) }
.gcc_except_table : ONLY_IF_RO { *(.gcc_except_table
.gcc_except_table.*) }
.gnu_extab : ONLY_IF_RO { *(.gnu_extab*) }
/* These sections are generated by the Sun/Oracle C++ compiler. */
.exception_ranges : ONLY_IF_RO { *(.exception_ranges
.exception_ranges*) }
/* Adjust the address for the data segment. We want to adjust up to
the same address within the page on the next page up. */
. = DATA_SEGMENT_ALIGN (CONSTANT (MAXPAGESIZE), CONSTANT (COMMONPAGESIZE));
/* Exception handling */
.eh_frame : ONLY_IF_RW { KEEP (*(.eh_frame)) *(.eh_frame.*) }
.gnu_extab : ONLY_IF_RW { *(.gnu_extab) }
.gcc_except_table : ONLY_IF_RW { *(.gcc_except_table .gcc_except_table.*) }
.exception_ranges : ONLY_IF_RW { *(.exception_ranges .exception_ranges*) }
/* Thread Local Storage sections */
.tdata : { *(.tdata .tdata.* .gnu.linkonce.td.*) }
.tbss : { *(.tbss .tbss.* .gnu.linkonce.tb.*) *(.tcommon) }
.preinit_array :
{
PROVIDE_HIDDEN (__preinit_array_start = .);
KEEP (*(.preinit_array))
PROVIDE_HIDDEN (__preinit_array_end = .);
}
. = ALIGN(0x40000000);
.init_array :
{
PROVIDE_HIDDEN (__init_array_start = .);
KEEP (*(SORT_BY_INIT_PRIORITY(.init_array.*) SORT_BY_INIT_PRIORITY(.ctors.*)))
KEEP (*(.init_array EXCLUDE_FILE (*crtbegin.o *crtbegin?.o *crtend.o *crtend?.o ) .ctors))
PROVIDE_HIDDEN (__init_array_end = .);
}
.fini_array :
{
PROVIDE_HIDDEN (__fini_array_start = .);
KEEP (*(SORT_BY_INIT_PRIORITY(.fini_array.*) SORT_BY_INIT_PRIORITY(.dtors.*)))
KEEP (*(.fini_array EXCLUDE_FILE (*crtbegin.o *crtbegin?.o *crtend.o *crtend?.o ) .dtors))
PROVIDE_HIDDEN (__fini_array_end = .);
}
.ctors :
{
/* gcc uses crtbegin.o to find the start of
the constructors, so we make sure it is
first. Because this is a wildcard, it
doesn't matter if the user does not
actually link against crtbegin.o; the
linker won't look for a file to match a
wildcard. The wildcard also means that it
doesn't matter which directory crtbegin.o
is in. */
KEEP (*crtbegin.o(.ctors))
KEEP (*crtbegin?.o(.ctors))
/* We don't want to include the .ctor section from
the crtend.o file until after the sorted ctors.
The .ctor section from the crtend file contains the
end of ctors marker and it must be last */
KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .ctors))
KEEP (*(SORT(.ctors.*)))
KEEP (*(.ctors))
}
.dtors :
{
KEEP (*crtbegin.o(.dtors))
KEEP (*crtbegin?.o(.dtors))
KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .dtors))
KEEP (*(SORT(.dtors.*)))
KEEP (*(.dtors))
}
.jcr : { KEEP (*(.jcr)) }
.data.rel.ro : { *(.data.rel.ro.local* .gnu.linkonce.d.rel.ro.local.*) *(.data.rel.ro .data.rel.ro.* .gnu.linkonce.d.rel.ro.*) }
.dynamic : { *(.dynamic) }
.got : { *(.got) *(.igot) }
. = DATA_SEGMENT_RELRO_END (24, .);
.got.plt : { *(.got.plt) *(.igot.plt) }
. = ALIGN(0x40000000);
.data :
{
addr_data = .;
PROVIDE (__data_start = .);
*(.data .data.* .gnu.linkonce.d.*)
SORT(CONSTRUCTORS)
. = ALIGN(0x40000000);
}
.data1 : { *(.data1) }
_edata = .; PROVIDE (edata = .);
. = .;
. = ALIGN(0x40000000);
__bss_start = .;
__bss_start__ = .;
.bss :
{
addr_bss = .;
*(.dynbss)
*(.bss .bss.* .gnu.linkonce.b.*)
*(COMMON)
/* Align here to ensure that the .bss section occupies space up to
_end. Align after .bss to ensure correct alignment even if the
.bss section disappears because there are no input sections.
FIXME: Why do we need it? When there is no .bss section, we don't
pad the .data section. */
. = ALIGN(. != 0 ? 64 / 8 : 1);
. = ALIGN(0x40000000);
}
_bss_end__ = . ; __bss_end__ = . ;
. = ALIGN(64 / 8);
. = SEGMENT_START("ldata-segment", .);
. = ALIGN(64 / 8);
__end__ = . ;
_end = .; PROVIDE (end = .);
. = DATA_SEGMENT_END (.);
/* Stabs debugging sections. */
.stab 0 : { *(.stab) }
.stabstr 0 : { *(.stabstr) }
.stab.excl 0 : { *(.stab.excl) }
.stab.exclstr 0 : { *(.stab.exclstr) }
.stab.index 0 : { *(.stab.index) }
.stab.indexstr 0 : { *(.stab.indexstr) }
.comment 0 : { *(.comment) }
/* DWARF debug sections.
Symbols in the DWARF debugging sections are relative to the beginning
of the section so we begin them at 0. */
/* DWARF 1 */
.debug 0 : { *(.debug) }
.line 0 : { *(.line) }
/* GNU DWARF 1 extensions */
.debug_srcinfo 0 : { *(.debug_srcinfo) }
.debug_sfnames 0 : { *(.debug_sfnames) }
/* DWARF 1.1 and DWARF 2 */
.debug_aranges 0 : { *(.debug_aranges) }
.debug_pubnames 0 : { *(.debug_pubnames) }
/* DWARF 2 */
.debug_info 0 : { *(.debug_info .gnu.linkonce.wi.*) }
.debug_abbrev 0 : { *(.debug_abbrev) }
.debug_line 0 : { *(.debug_line .debug_line.* .debug_line_end ) }
.debug_frame 0 : { *(.debug_frame) }
.debug_str 0 : { *(.debug_str) }
.debug_loc 0 : { *(.debug_loc) }
.debug_macinfo 0 : { *(.debug_macinfo) }
/* SGI/MIPS DWARF 2 extensions */
.debug_weaknames 0 : { *(.debug_weaknames) }
.debug_funcnames 0 : { *(.debug_funcnames) }
.debug_typenames 0 : { *(.debug_typenames) }
.debug_varnames 0 : { *(.debug_varnames) }
/* DWARF 3 */
.debug_pubtypes 0 : { *(.debug_pubtypes) }
.debug_ranges 0 : { *(.debug_ranges) }
/* DWARF Extension. */
.debug_macro 0 : { *(.debug_macro) }
.ARM.attributes 0 : { KEEP (*(.ARM.attributes)) KEEP (*(.gnu.attributes)) }
.note.gnu.arm.ident 0 : { KEEP (*(.note.gnu.arm.ident)) }
/DISCARD/ : { *(.note.GNU-stack) *(.gnu_debuglink) *(.gnu.lto_*) }
}

77
test/large_page/arm64/601_4K.c Normal file
View File

@@ -0,0 +1,77 @@
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/mman.h>
#include "../util.h"
#define PAGE_SHIFT_64K 16
#define PAGE_SIZE_64K (1UL << PAGE_SHIFT_64K)
char fn_64K[] = "/mnt/hugetlbfs-64K/tmp";
#define PAGE_SHIFT_2M 21
#define PAGE_SIZE_2M (1UL << PAGE_SHIFT_2M)
char fn_2M[] = "/mnt/hugetlbfs-2M/tmp";
#define PAGE_SHIFT_32M 25
#define PAGE_SIZE_32M (1UL << PAGE_SHIFT_32M)
char fn_32M[] = "/mnt/hugetlbfs-32M/tmp";
#define PAGE_SHIFT_1G 30
#define PAGE_SIZE_1G (1UL << PAGE_SHIFT_1G)
char fn_1G[] = "/mnt/hugetlbfs-1G/tmp";
int trial_num;
int mmap_hugetlbfs(char *fn, size_t page_size)
{
int fd;
char *addr_mmap;
fd = open(fn, O_CREAT | O_RDWR, 0755);
NG(fd != -1, "open failed, fn: %s\n", fn);
addr_mmap = mmap(0, page_size,
PROT_READ | PROT_WRITE,
MAP_SHARED,
fd, 0);
NG(addr_mmap != (void *)-1, "mmap failed\n");
addr_mmap[0] = 'z';
NG(__atomic_load_n(addr_mmap, __ATOMIC_SEQ_CST) == 'z',
"memory access failed\n");
printf("large page request, trial#: %03d, addr: %016lx, size: %ld\n",
trial_num++, (unsigned long)addr_mmap, page_size);
munmap(addr_mmap, page_size);
close(fd);
unlink(fn);
return 0;
fn_fail:
return 1;
}
int main(int argc, char **argv)
{
int ret;
ret = mmap_hugetlbfs(fn_64K, PAGE_SIZE_64K);
NG(ret == 0, "mmap_hugetlbfs failed, fn: %s", fn_64K);
ret = mmap_hugetlbfs(fn_2M, PAGE_SIZE_2M);
NG(ret == 0, "mmap_hugetlbfs failed, fn: %s", fn_2M);
ret = mmap_hugetlbfs(fn_32M, PAGE_SIZE_32M);
NG(ret == 0, "mmap_hugetlbfs failed, fn: %s", fn_32M);
ret = mmap_hugetlbfs(fn_1G, PAGE_SIZE_1G);
NG(ret == 0, "mmap_hugetlbfs failed, fn: %s", fn_1G);
return 0;
fn_fail:
return 1;
}

63
test/large_page/arm64/601_64K.c Normal file
View File

@@ -0,0 +1,63 @@
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/mman.h>
#include "../util.h"
#define PAGE_SHIFT_2M 21
#define PAGE_SIZE_2M (1UL << PAGE_SHIFT_2M)
char fn_2M[] = "/mnt/hugetlbfs-2M/tmp";
#define PAGE_SHIFT_512M 29
#define PAGE_SIZE_512M (1UL << PAGE_SHIFT_512M)
char fn_512M[] = "/mnt/hugetlbfs-512M/tmp";
int trial_num;
int mmap_hugetlbfs(char *fn, size_t page_size)
{
int fd;
char *addr_mmap;
fd = open(fn, O_CREAT | O_RDWR, 0755);
NG(fd != -1, "open failed, fn: %s\n", fn);
addr_mmap = mmap(0, page_size,
PROT_READ | PROT_WRITE,
MAP_SHARED,
fd, 0);
NG(addr_mmap != (void *)-1, "mmap failed\n");
addr_mmap[0] = 'z';
NG(__atomic_load_n(addr_mmap, __ATOMIC_SEQ_CST) == 'z',
"memory access failed\n");
printf("large page request, trial#: %03d, addr: %016lx, size: %ld\n",
trial_num++, (unsigned long)addr_mmap, page_size);
munmap(addr_mmap, page_size);
close(fd);
unlink(fn);
return 0;
fn_fail:
return 1;
}
int main(int argc, char **argv)
{
int ret;
ret = mmap_hugetlbfs(fn_2M, PAGE_SIZE_2M);
NG(ret == 0, "mmap_hugetlbfs failed, fn: %s", fn_2M);
ret = mmap_hugetlbfs(fn_512M, PAGE_SIZE_512M);
NG(ret == 0, "mmap_hugetlbfs failed, fn: %s", fn_512M);
return 0;
fn_fail:
return 1;
}

46
test/large_page/arm64/Makefile Normal file
View File

@@ -0,0 +1,46 @@
include $(HOME)/.mck_test_config.mk
CC = gcc
CPPFLAGS =
CFLAGS = -Wall -Werror -g
LDFLAGS =
PAGESIZE = $(shell getconf PAGESIZE)
ifeq ($(PAGESIZE),65536)
SRCS = $(shell ls *_64K.c)
endif
ifeq ($(PAGESIZE),4096)
SRCS = $(shell ls *_4K.c)
endif
EXES = $(SRCS:.c=)
OBJS = $(SRCS:.c=.o)
all: $(EXES)
test:: $(EXES)
../driver.sh $(TESTSET)
501_64K: 501_64K.o 501_64K.lds
$(CC) -o $@ $< $(LDFLAGS) -T 501_64K.lds
502_64K: 502_64K.o 502_64K.lds
$(CC) -o $@ $< $(LDFLAGS) -T 502_64K.lds
501_4K: 501_4K.o 501_4K.lds
$(CC) -o $@ $< $(LDFLAGS) -T 501_4K.lds
502_4K: 502_4K.o 502_4K.lds
$(CC) -o $@ $< $(LDFLAGS) -T 502_4K.lds
503_4K: 503_4K.o 503_4K.lds
$(CC) -o $@ $< $(LDFLAGS) -T 503_4K.lds
504_4K: 504_4K.o 504_4K.lds
$(CC) -o $@ $< $(LDFLAGS) -T 504_4K.lds
clean:
rm -f core $(EXES) $(OBJS)

4
test/large_page/arm64/fini/601_4K.fini Normal file
View File

@@ -0,0 +1,4 @@
sudo umount /mnt/hugetlbfs-64K
sudo umount /mnt/hugetlbfs-2M
sudo umount /mnt/hugetlbfs-32M
sudo umount /mnt/hugetlbfs-1G

2
test/large_page/arm64/fini/601_64K.fini Normal file
View File

@@ -0,0 +1,2 @@
sudo umount /mnt/hugetlbfs-2M
sudo umount /mnt/hugetlbfs-512M

2
test/large_page/arm64/init/001_4K.init Normal file
View File

@@ -0,0 +1,2 @@
BOOTPARAM="-c 1-7 -m 16G -r 1-7:0"
MCEXECOPT="-s 4K,16G"

1
test/large_page/arm64/init/001_64K.init Normal file
View File

@@ -0,0 +1 @@
BOOTPARAM="-c 1-7 -m 16G -r 1-7:0"

2
test/large_page/arm64/init/101_4K.init Normal file
View File

@@ -0,0 +1,2 @@
BOOTPARAM="-c 1-7 -m 16G -r 1-7:0"
MCEXECOPT="-s 4K,16G"

1
test/large_page/arm64/init/101_64K.init Normal file
View File

@@ -0,0 +1 @@
BOOTPARAM="-c 1-7 -m 16G -r 1-7:0"

2
test/large_page/arm64/init/201_4K.init Normal file
View File

@@ -0,0 +1,2 @@
BOOTPARAM="-c 1-7 -m 16G -r 1-7:0"
MCEXECOPT="-s 4K,16G"

1
test/large_page/arm64/init/201_64K.init Normal file
View File

@@ -0,0 +1 @@
BOOTPARAM="-c 1-7 -m 16G -r 1-7:0"

2
test/large_page/arm64/init/301_4K.init Normal file
View File

@@ -0,0 +1,2 @@
BOOTPARAM="-c 1-7 -m 16G -r 1-7:0"
MCEXECOPT="-s 4K,16G"

1
test/large_page/arm64/init/301_64K.init Normal file
View File

@@ -0,0 +1 @@
BOOTPARAM="-c 1-7 -m 16G -r 1-7:0"

2
test/large_page/arm64/init/401_4K.init Normal file
View File

@@ -0,0 +1,2 @@
BOOTPARAM="-c 1-7 -m 16G -r 1-7:0"
MCEXECOPT="-s 4K,16G -h 64K"

2
test/large_page/arm64/init/401_64K.init Normal file
View File

@@ -0,0 +1,2 @@
BOOTPARAM="-c 1-7 -m 16G -r 1-7:0"
MCEXECOPT="-h 2M"

2
test/large_page/arm64/init/402_4K.init Normal file
View File

@@ -0,0 +1,2 @@
BOOTPARAM="-c 1-7 -m 16G -r 1-7:0"
MCEXECOPT="-s 4K,16G -h 2M"

2
test/large_page/arm64/init/402_64K.init Normal file
View File

@@ -0,0 +1,2 @@
BOOTPARAM="-c 1-7 -m 16G -r 1-7:0"
MCEXECOPT="-h 512M"

2
test/large_page/arm64/init/403_4K.init Normal file
View File

@@ -0,0 +1,2 @@
BOOTPARAM="-c 1-7 -m 16G -r 1-7:0"
MCEXECOPT="-s 4K,16G -h 32M"

2
test/large_page/arm64/init/404_4K.init Normal file
View File

@@ -0,0 +1,2 @@
BOOTPARAM="-c 1-7 -m 16G -r 1-7:0"
MCEXECOPT="-s 4K,16G -h 1G"

2
test/large_page/arm64/init/501_4K.init Normal file
View File

@@ -0,0 +1,2 @@
BOOTPARAM="-c 1-7 -m 16G -r 1-7:0"
MCEXECOPT="-s 64K,16G"

2
test/large_page/arm64/init/501_64K.init Normal file
View File

@@ -0,0 +1,2 @@
BOOTPARAM="-c 1-7 -m 16G -r 1-7:0"
MCEXECOPT="-s 2M,16G"

2
test/large_page/arm64/init/502_4K.init Normal file
View File

@@ -0,0 +1,2 @@
BOOTPARAM="-c 1-7 -m 16G -r 1-7:0"
MCEXECOPT="-s 2M,16G"

2
test/large_page/arm64/init/502_64K.init Normal file
View File

@@ -0,0 +1,2 @@
BOOTPARAM="-c 1-7 -m 16G -r 1-7:0"
MCEXECOPT="-s 512M,16G"

2
test/large_page/arm64/init/503_4K.init Normal file
View File

@@ -0,0 +1,2 @@
BOOTPARAM="-c 1-7 -m 16G -r 1-7:0"
MCEXECOPT="-s 32M,16G"

2
test/large_page/arm64/init/504_4K.init Normal file
View File

@@ -0,0 +1,2 @@
BOOTPARAM="-c 1-7 -m 16G -r 1-7:0"
MCEXECOPT="-s 1G,16G"

14
test/large_page/arm64/init/601_4K.init Normal file
View File

@@ -0,0 +1,14 @@
BOOTPARAM="-c 1-7 -m 16G -r 1-7:0"
MCEXECOPT="-s 4K,16G"
sudo mkdir -p /mnt/hugetlbfs-64K
sudo mount -t hugetlbfs -o mode=777,pagesize=64k none /mnt/hugetlbfs-64K
sudo mkdir -p /mnt/hugetlbfs-2M
sudo mount -t hugetlbfs -o mode=777,pagesize=2m none /mnt/hugetlbfs-2M
sudo mkdir -p /mnt/hugetlbfs-32M
sudo mount -t hugetlbfs -o mode=777,pagesize=32m none /mnt/hugetlbfs-32M
sudo mkdir -p /mnt/hugetlbfs-1G
sudo mount -t hugetlbfs -o mode=777,pagesize=1g none /mnt/hugetlbfs-1G

7
test/large_page/arm64/init/601_64K.init Normal file
View File

@@ -0,0 +1,7 @@
BOOTPARAM="-c 1-7 -m 16G -r 1-7:0"
sudo mkdir -p /mnt/hugetlbfs-2M
sudo mount -t hugetlbfs -o mode=777,pagesize=2m none /mnt/hugetlbfs-2M
sudo mkdir -p /mnt/hugetlbfs-512M
sudo mount -t hugetlbfs -o mode=777,pagesize=512m none /mnt/hugetlbfs-512M

57
test/large_page/arm64/test_set.conf Normal file
View File

@@ -0,0 +1,57 @@
pagesize=$(getconf PAGESIZE)
case $pagesize in
65536)
# mmap + THP: 2MB, 512MB
test_set="${test_set} 001"
# shget + THP: 2MB, 512MB
test_set="${test_set} 101"
# mmap + flag: 2MB, 512MB
test_set="${test_set} 201"
# shmget + flag: 2MB, 512MB
test_set="${test_set} 301"
# brk: 2MB, 512MB
test_set="${test_set} 401 402"
# .data, .bss, .stack: 2MB
test_set="${test_set} 501"
# .data, .bss: 512M
test_set="${test_set} 502"
# hugetlbfs: 2MB, 512MB
test_set="${test_set} 601"
;;
4096)
# mmap + THP: 64KB, 2MB, 32MB, 1GB
test_set="${test_set} 001"
# shget + THP: 64KB, 2MB, 32MB, 1GB
test_set="${test_set} 101"
# mmap + flag: 64KB, 2MB, 32MB, 1GB
test_set="${test_set} 201"
# shmget + flag: 64KB, 2MB, 32MB, 1GB
test_set="${test_set} 301"
# brk: 64KB, 2MB, 32MB. 1GB
test_set="${test_set} 401 402 403 404"
# .data, .bss, .stack: 64KB, 2MB, 32MB
test_set="${test_set} 501 502 503"
# .data, .bss: 1GB
test_set="${test_set} 504"
# hugetlbfs: 64KB, 2MB, 32MB, 1GB
test_set="${test_set} 601"
;;
*) echo "Error: Unknown page size: $pagesize"
exit 1
;;
esac