1/*
  2 *
  3 * A test for the patch "Allow compaction of unevictable pages".
  4 * With this patch we should be able to allocate at least 1/4
  5 * of RAM in huge pages. Without the patch much less is
  6 * allocated.
  7 */
  8
  9#include <stdio.h>
 10#include <stdlib.h>
 11#include <sys/mman.h>
 12#include <sys/resource.h>
 13#include <fcntl.h>
 14#include <errno.h>
 15#include <unistd.h>
 16#include <string.h>
 17
 18#define MAP_SIZE 1048576
 19
 20struct map_list {
 21	void *map;
 22	struct map_list *next;
 23};
 24
 25int read_memory_info(unsigned long *memfree, unsigned long *hugepagesize)
 26{
 27	char  buffer[256] = {0};
 28	char *cmd = "cat /proc/meminfo | grep -i memfree | grep -o '[0-9]*'";
 29	FILE *cmdfile = popen(cmd, "r");
 30
 31	if (!(fgets(buffer, sizeof(buffer), cmdfile))) {
 32		perror("Failed to read meminfo\n");
 33		return -1;
 34	}
 35
 36	pclose(cmdfile);
 37
 38	*memfree = atoll(buffer);
 39	cmd = "cat /proc/meminfo | grep -i hugepagesize | grep -o '[0-9]*'";
 40	cmdfile = popen(cmd, "r");
 41
 42	if (!(fgets(buffer, sizeof(buffer), cmdfile))) {
 43		perror("Failed to read meminfo\n");
 44		return -1;
 45	}
 46
 47	pclose(cmdfile);
 48	*hugepagesize = atoll(buffer);
 49
 50	return 0;
 51}
 52
 53int prereq(void)
 54{
 55	char allowed;
 56	int fd;
 57
 58	fd = open("/proc/sys/vm/compact_unevictable_allowed",
 59		  O_RDONLY | O_NONBLOCK);
 60	if (fd < 0) {
 61		perror("Failed to open\n"
 62		       "/proc/sys/vm/compact_unevictable_allowed\n");
 63		return -1;
 64	}
 65
 66	if (read(fd, &allowed, sizeof(char)) != sizeof(char)) {
 67		perror("Failed to read from\n"
 68		       "/proc/sys/vm/compact_unevictable_allowed\n");
 69		close(fd);
 70		return -1;
 71	}
 72
 73	close(fd);
 74	if (allowed == '1')
 75		return 0;
 76
 77	return -1;
 78}
 79
 80int check_compaction(unsigned long mem_free, unsigned int hugepage_size)
 81{
 82	int fd;
 83	int compaction_index = 0;
 84	char initial_nr_hugepages[10] = {0};
 85	char nr_hugepages[10] = {0};
 86
 87	/* We want to test with 80% of available memory. Else, OOM killer comes
 88	   in to play */
 89	mem_free = mem_free * 0.8;
 90
 91	fd = open("/proc/sys/vm/nr_hugepages", O_RDWR | O_NONBLOCK);
 92	if (fd < 0) {
 93		perror("Failed to open /proc/sys/vm/nr_hugepages");
 94		return -1;
 95	}
 96
 97	if (read(fd, initial_nr_hugepages, sizeof(initial_nr_hugepages)) <= 0) {
 98		perror("Failed to read from /proc/sys/vm/nr_hugepages");
 99		goto close_fd;
100	}
101
102	/* Start with the initial condition of 0 huge pages*/
103	if (write(fd, "0", sizeof(char)) != sizeof(char)) {
104		perror("Failed to write 0 to /proc/sys/vm/nr_hugepages\n");
105		goto close_fd;
106	}
107
108	lseek(fd, 0, SEEK_SET);
109
110	/* Request a large number of huge pages. The Kernel will allocate
111	   as much as it can */
112	if (write(fd, "100000", (6*sizeof(char))) != (6*sizeof(char))) {
113		perror("Failed to write 100000 to /proc/sys/vm/nr_hugepages\n");
114		goto close_fd;
115	}
116
117	lseek(fd, 0, SEEK_SET);
118
119	if (read(fd, nr_hugepages, sizeof(nr_hugepages)) <= 0) {
120		perror("Failed to re-read from /proc/sys/vm/nr_hugepages\n");
121		goto close_fd;
122	}
123
124	/* We should have been able to request at least 1/3 rd of the memory in
125	   huge pages */
126	compaction_index = mem_free/(atoi(nr_hugepages) * hugepage_size);
127
128	if (compaction_index > 3) {
129		printf("No of huge pages allocated = %d\n",
130		       (atoi(nr_hugepages)));
131		fprintf(stderr, "ERROR: Less that 1/%d of memory is available\n"
132			"as huge pages\n", compaction_index);
133		goto close_fd;
134	}
135
136	printf("No of huge pages allocated = %d\n",
137	       (atoi(nr_hugepages)));
138
139	if (write(fd, initial_nr_hugepages, strlen(initial_nr_hugepages))
140	    != strlen(initial_nr_hugepages)) {
141		perror("Failed to write value to /proc/sys/vm/nr_hugepages\n");
142		goto close_fd;
143	}
144
145	close(fd);
146	return 0;
147
148 close_fd:
149	close(fd);
150	printf("Not OK. Compaction test failed.");
151	return -1;
152}
153
154
155int main(int argc, char **argv)
156{
157	struct rlimit lim;
158	struct map_list *list, *entry;
159	size_t page_size, i;
160	void *map = NULL;
161	unsigned long mem_free = 0;
162	unsigned long hugepage_size = 0;
163	unsigned long mem_fragmentable = 0;
164
165	if (prereq() != 0) {
166		printf("Either the sysctl compact_unevictable_allowed is not\n"
167		       "set to 1 or couldn't read the proc file.\n"
168		       "Skipping the test\n");
169		return 0;
170	}
171
172	lim.rlim_cur = RLIM_INFINITY;
173	lim.rlim_max = RLIM_INFINITY;
174	if (setrlimit(RLIMIT_MEMLOCK, &lim)) {
175		perror("Failed to set rlimit:\n");
176		return -1;
177	}
178
179	page_size = getpagesize();
180
181	list = NULL;
182
183	if (read_memory_info(&mem_free, &hugepage_size) != 0) {
184		printf("ERROR: Cannot read meminfo\n");
185		return -1;
186	}
187
188	mem_fragmentable = mem_free * 0.8 / 1024;
189
190	while (mem_fragmentable > 0) {
191		map = mmap(NULL, MAP_SIZE, PROT_READ | PROT_WRITE,
192			   MAP_ANONYMOUS | MAP_PRIVATE | MAP_LOCKED, -1, 0);
193		if (map == MAP_FAILED)
194			break;
195
196		entry = malloc(sizeof(struct map_list));
197		if (!entry) {
198			munmap(map, MAP_SIZE);
199			break;
200		}
201		entry->map = map;
202		entry->next = list;
203		list = entry;
204
205		/* Write something (in this case the address of the map) to
206		 * ensure that KSM can't merge the mapped pages
207		 */
208		for (i = 0; i < MAP_SIZE; i += page_size)
209			*(unsigned long *)(map + i) = (unsigned long)map + i;
210
211		mem_fragmentable--;
212	}
213
214	for (entry = list; entry != NULL; entry = entry->next) {
215		munmap(entry->map, MAP_SIZE);
216		if (!entry->next)
217			break;
218		entry = entry->next;
219	}
220
221	if (check_compaction(mem_free, hugepage_size) == 0)
222		return 0;
223
224	return -1;
225}