1/*
 2 * Example of using hugepage memory in a user application using the mmap
 3 * system call with MAP_HUGETLB flag.  Before running this program make
 4 * sure the administrator has allocated enough default sized huge pages
 5 * to cover the 256 MB allocation.
 6 *
 7 * For ia64 architecture, Linux kernel reserves Region number 4 for hugepages.
 8 * That means the addresses starting with 0x800000... will need to be
 9 * specified.  Specifying a fixed address is not required on ppc64, i386
10 * or x86_64.
11 */
12#include <stdlib.h>
13#include <stdio.h>
14#include <unistd.h>
15#include <sys/mman.h>
16#include <fcntl.h>
17
18#define LENGTH (256UL*1024*1024)
19#define PROTECTION (PROT_READ | PROT_WRITE)
20
21#ifndef MAP_HUGETLB
22#define MAP_HUGETLB 0x40000 /* arch specific */
23#endif
24
 
 
 
 
 
 
 
 
25/* Only ia64 requires this */
26#ifdef __ia64__
27#define ADDR (void *)(0x8000000000000000UL)
28#define FLAGS (MAP_PRIVATE | MAP_ANONYMOUS | MAP_HUGETLB | MAP_FIXED)
29#else
30#define ADDR (void *)(0x0UL)
31#define FLAGS (MAP_PRIVATE | MAP_ANONYMOUS | MAP_HUGETLB)
32#endif
33
34static void check_bytes(char *addr)
35{
36	printf("First hex is %x\n", *((unsigned int *)addr));
37}
38
39static void write_bytes(char *addr)
40{
41	unsigned long i;
42
43	for (i = 0; i < LENGTH; i++)
44		*(addr + i) = (char)i;
45}
46
47static int read_bytes(char *addr)
48{
49	unsigned long i;
50
51	check_bytes(addr);
52	for (i = 0; i < LENGTH; i++)
53		if (*(addr + i) != (char)i) {
54			printf("Mismatch at %lu\n", i);
55			return 1;
56		}
57	return 0;
58}
59
60int main(void)
61{
62	void *addr;
63	int ret;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
64
65	addr = mmap(ADDR, LENGTH, PROTECTION, FLAGS, 0, 0);
66	if (addr == MAP_FAILED) {
67		perror("mmap");
68		exit(1);
69	}
70
71	printf("Returned address is %p\n", addr);
72	check_bytes(addr);
73	write_bytes(addr);
74	ret = read_bytes(addr);
75
76	/* munmap() length of MAP_HUGETLB memory must be hugepage aligned */
77	if (munmap(addr, LENGTH)) {
78		perror("munmap");
79		exit(1);
80	}
81
82	return ret;
83}

  1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * Example of using hugepage memory in a user application using the mmap
  4 * system call with MAP_HUGETLB flag.  Before running this program make
  5 * sure the administrator has allocated enough default sized huge pages
  6 * to cover the 256 MB allocation.
  7 *
  8 * For ia64 architecture, Linux kernel reserves Region number 4 for hugepages.
  9 * That means the addresses starting with 0x800000... will need to be
 10 * specified.  Specifying a fixed address is not required on ppc64, i386
 11 * or x86_64.
 12 */
 13#include <stdlib.h>
 14#include <stdio.h>
 15#include <unistd.h>
 16#include <sys/mman.h>
 17#include <fcntl.h>
 18
 19#define LENGTH (256UL*1024*1024)
 20#define PROTECTION (PROT_READ | PROT_WRITE)
 21
 22#ifndef MAP_HUGETLB
 23#define MAP_HUGETLB 0x40000 /* arch specific */
 24#endif
 25
 26#ifndef MAP_HUGE_SHIFT
 27#define MAP_HUGE_SHIFT 26
 28#endif
 29
 30#ifndef MAP_HUGE_MASK
 31#define MAP_HUGE_MASK 0x3f
 32#endif
 33
 34/* Only ia64 requires this */
 35#ifdef __ia64__
 36#define ADDR (void *)(0x8000000000000000UL)
 37#define FLAGS (MAP_PRIVATE | MAP_ANONYMOUS | MAP_HUGETLB | MAP_FIXED)
 38#else
 39#define ADDR (void *)(0x0UL)
 40#define FLAGS (MAP_PRIVATE | MAP_ANONYMOUS | MAP_HUGETLB)
 41#endif
 42
 43static void check_bytes(char *addr)
 44{
 45	printf("First hex is %x\n", *((unsigned int *)addr));
 46}
 47
 48static void write_bytes(char *addr, size_t length)
 49{
 50	unsigned long i;
 51
 52	for (i = 0; i < length; i++)
 53		*(addr + i) = (char)i;
 54}
 55
 56static int read_bytes(char *addr, size_t length)
 57{
 58	unsigned long i;
 59
 60	check_bytes(addr);
 61	for (i = 0; i < length; i++)
 62		if (*(addr + i) != (char)i) {
 63			printf("Mismatch at %lu\n", i);
 64			return 1;
 65		}
 66	return 0;
 67}
 68
 69int main(int argc, char **argv)
 70{
 71	void *addr;
 72	int ret;
 73	size_t length = LENGTH;
 74	int flags = FLAGS;
 75	int shift = 0;
 76
 77	if (argc > 1)
 78		length = atol(argv[1]) << 20;
 79	if (argc > 2) {
 80		shift = atoi(argv[2]);
 81		if (shift)
 82			flags |= (shift & MAP_HUGE_MASK) << MAP_HUGE_SHIFT;
 83	}
 84
 85	if (shift)
 86		printf("%u kB hugepages\n", 1 << (shift - 10));
 87	else
 88		printf("Default size hugepages\n");
 89	printf("Mapping %lu Mbytes\n", (unsigned long)length >> 20);
 90
 91	addr = mmap(ADDR, length, PROTECTION, flags, -1, 0);
 92	if (addr == MAP_FAILED) {
 93		perror("mmap");
 94		exit(1);
 95	}
 96
 97	printf("Returned address is %p\n", addr);
 98	check_bytes(addr);
 99	write_bytes(addr, length);
100	ret = read_bytes(addr, length);
101
102	/* munmap() length of MAP_HUGETLB memory must be hugepage aligned */
103	if (munmap(addr, length)) {
104		perror("munmap");
105		exit(1);
106	}
107
108	return ret;
109}