selftests: add a test program for variable huge page sizes in mmap/shmget
authorAndi Kleen <ak@linux.intel.com>
Wed, 12 Dec 2012 00:01:36 +0000 (16:01 -0800)
committerLinus Torvalds <torvalds@linux-foundation.org>
Wed, 12 Dec 2012 01:22:25 +0000 (17:22 -0800)
Also remove -Wextra because gcc-4.6 emits lots of irritating
signed/unsigned comparison warnings.

Signed-off-by: Andi Kleen <ak@linux.intel.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
tools/testing/selftests/vm/Makefile
tools/testing/selftests/vm/thuge-gen.c [new file with mode: 0644]

index b336b24..7300d07 100644 (file)
@@ -1,9 +1,9 @@
 # Makefile for vm selftests
 
 CC = $(CROSS_COMPILE)gcc
-CFLAGS = -Wall -Wextra
+CFLAGS = -Wall
 
-all: hugepage-mmap hugepage-shm  map_hugetlb
+all: hugepage-mmap hugepage-shm  map_hugetlb thuge-gen
 %: %.c
        $(CC) $(CFLAGS) -o $@ $^
 
diff --git a/tools/testing/selftests/vm/thuge-gen.c b/tools/testing/selftests/vm/thuge-gen.c
new file mode 100644 (file)
index 0000000..c879572
--- /dev/null
@@ -0,0 +1,254 @@
+/* Test selecting other page sizes for mmap/shmget.
+
+   Before running this huge pages for each huge page size must have been
+   reserved.
+   For large pages beyond MAX_ORDER (like 1GB on x86) boot options must be used.
+   Also shmmax must be increased.
+   And you need to run as root to work around some weird permissions in shm.
+   And nothing using huge pages should run in parallel.
+   When the program aborts you may need to clean up the shm segments with
+   ipcrm -m by hand, like this
+   sudo ipcs | awk '$1 == "0x00000000" {print $2}' | xargs -n1 sudo ipcrm -m
+   (warning this will remove all if someone else uses them) */
+
+#define _GNU_SOURCE 1
+#include <sys/mman.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <sys/ipc.h>
+#include <sys/shm.h>
+#include <sys/stat.h>
+#include <glob.h>
+#include <assert.h>
+#include <unistd.h>
+#include <stdarg.h>
+#include <string.h>
+
+#define err(x) perror(x), exit(1)
+
+#define MAP_HUGE_2MB    (21 << MAP_HUGE_SHIFT)
+#define MAP_HUGE_1GB    (30 << MAP_HUGE_SHIFT)
+#define MAP_HUGE_SHIFT  26
+#define MAP_HUGE_MASK   0x3f
+#define MAP_HUGETLB    0x40000
+
+#define SHM_HUGETLB     04000   /* segment will use huge TLB pages */
+#define SHM_HUGE_SHIFT  26
+#define SHM_HUGE_MASK   0x3f
+#define SHM_HUGE_2MB    (21 << SHM_HUGE_SHIFT)
+#define SHM_HUGE_1GB    (30 << SHM_HUGE_SHIFT)
+
+#define NUM_PAGESIZES   5
+
+#define NUM_PAGES 4
+
+#define Dprintf(fmt...) // printf(fmt)
+
+unsigned long page_sizes[NUM_PAGESIZES];
+int num_page_sizes;
+
+int ilog2(unsigned long v)
+{
+       int l = 0;
+       while ((1UL << l) < v)
+               l++;
+       return l;
+}
+
+void find_pagesizes(void)
+{
+       glob_t g;
+       int i;
+       glob("/sys/kernel/mm/hugepages/hugepages-*kB", 0, NULL, &g);
+       assert(g.gl_pathc <= NUM_PAGESIZES);
+       for (i = 0; i < g.gl_pathc; i++) {
+               sscanf(g.gl_pathv[i], "/sys/kernel/mm/hugepages/hugepages-%lukB",
+                               &page_sizes[i]);
+               page_sizes[i] <<= 10;
+               printf("Found %luMB\n", page_sizes[i] >> 20);
+       }
+       num_page_sizes = g.gl_pathc;
+       globfree(&g);
+}
+
+unsigned long default_huge_page_size(void)
+{
+       unsigned long hps = 0;
+       char *line = NULL;
+       size_t linelen = 0;
+       FILE *f = fopen("/proc/meminfo", "r");
+       if (!f)
+               return 0;
+       while (getline(&line, &linelen, f) > 0) {
+               if (sscanf(line, "Hugepagesize:       %lu kB", &hps) == 1) {
+                       hps <<= 10;
+                       break;
+               }
+       }
+       free(line);
+       return hps;
+}
+
+void show(unsigned long ps)
+{
+       char buf[100];
+       if (ps == getpagesize())
+               return;
+       printf("%luMB: ", ps >> 20);
+       fflush(stdout);
+       snprintf(buf, sizeof buf,
+               "cat /sys/kernel/mm/hugepages/hugepages-%lukB/free_hugepages",
+               ps >> 10);
+       system(buf);
+}
+
+unsigned long read_sysfs(int warn, char *fmt, ...)
+{
+       char *line = NULL;
+       size_t linelen = 0;
+       char buf[100];
+       FILE *f;
+       va_list ap;
+       unsigned long val = 0;
+
+       va_start(ap, fmt);
+       vsnprintf(buf, sizeof buf, fmt, ap);
+       va_end(ap);
+
+       f = fopen(buf, "r");
+       if (!f) {
+               if (warn)
+                       printf("missing %s\n", buf);
+               return 0;
+       }
+       if (getline(&line, &linelen, f) > 0) {
+               sscanf(line, "%lu", &val);
+       }
+       fclose(f);
+       free(line);
+       return val;
+}
+
+unsigned long read_free(unsigned long ps)
+{
+       return read_sysfs(ps != getpagesize(),
+                       "/sys/kernel/mm/hugepages/hugepages-%lukB/free_hugepages",
+                       ps >> 10);
+}
+
+void test_mmap(unsigned long size, unsigned flags)
+{
+       char *map;
+       unsigned long before, after;
+       int err;
+
+       before = read_free(size);
+       map = mmap(NULL, size*NUM_PAGES, PROT_READ|PROT_WRITE,
+                       MAP_PRIVATE|MAP_ANONYMOUS|MAP_HUGETLB|flags, 0, 0);
+
+       if (map == (char *)-1) err("mmap");
+       memset(map, 0xff, size*NUM_PAGES);
+       after = read_free(size);
+       Dprintf("before %lu after %lu diff %ld size %lu\n",
+               before, after, before - after, size);
+       assert(size == getpagesize() || (before - after) == NUM_PAGES);
+       show(size);
+       err = munmap(map, size);
+       assert(!err);
+}
+
+void test_shmget(unsigned long size, unsigned flags)
+{
+       int id;
+       unsigned long before, after;
+       int err;
+
+       before = read_free(size);
+       id = shmget(IPC_PRIVATE, size * NUM_PAGES, IPC_CREAT|0600|flags);
+       if (id < 0) err("shmget");
+
+       struct shm_info i;
+       if (shmctl(id, SHM_INFO, (void *)&i) < 0) err("shmctl");
+       Dprintf("alloc %lu res %lu\n", i.shm_tot, i.shm_rss);
+
+
+       Dprintf("id %d\n", id);
+       char *map = shmat(id, NULL, 0600);
+       if (map == (char*)-1) err("shmat");
+
+       shmctl(id, IPC_RMID, NULL);
+
+       memset(map, 0xff, size*NUM_PAGES);
+       after = read_free(size);
+
+       Dprintf("before %lu after %lu diff %ld size %lu\n",
+               before, after, before - after, size);
+       assert(size == getpagesize() || (before - after) == NUM_PAGES);
+       show(size);
+       err = shmdt(map);
+       assert(!err);
+}
+
+void sanity_checks(void)
+{
+       int i;
+       unsigned long largest = getpagesize();
+
+       for (i = 0; i < num_page_sizes; i++) {
+               if (page_sizes[i] > largest)
+                       largest = page_sizes[i];
+
+               if (read_free(page_sizes[i]) < NUM_PAGES) {
+                       printf("Not enough huge pages for page size %lu MB, need %u\n",
+                               page_sizes[i] >> 20,
+                               NUM_PAGES);
+                       exit(0);
+               }
+       }
+
+       if (read_sysfs(0, "/proc/sys/kernel/shmmax") < NUM_PAGES * largest) {
+               printf("Please do echo %lu > /proc/sys/kernel/shmmax", largest * NUM_PAGES);
+               exit(0);
+       }
+
+#if defined(__x86_64__)
+       if (largest != 1U<<30) {
+               printf("No GB pages available on x86-64\n"
+                      "Please boot with hugepagesz=1G hugepages=%d\n", NUM_PAGES);
+               exit(0);
+       }
+#endif
+}
+
+int main(void)
+{
+       int i;
+       unsigned default_hps = default_huge_page_size();
+
+       find_pagesizes();
+
+       sanity_checks();
+
+       for (i = 0; i < num_page_sizes; i++) {
+               unsigned long ps = page_sizes[i];
+               int arg = ilog2(ps) << MAP_HUGE_SHIFT;
+               printf("Testing %luMB mmap with shift %x\n", ps >> 20, arg);
+               test_mmap(ps, MAP_HUGETLB | arg);
+       }
+       printf("Testing default huge mmap\n");
+       test_mmap(default_hps, SHM_HUGETLB);
+
+       puts("Testing non-huge shmget");
+       test_shmget(getpagesize(), 0);
+
+       for (i = 0; i < num_page_sizes; i++) {
+               unsigned long ps = page_sizes[i];
+               int arg = ilog2(ps) << SHM_HUGE_SHIFT;
+               printf("Testing %luMB shmget with shift %x\n", ps >> 20, arg);
+               test_shmget(ps, SHM_HUGETLB | arg);
+       }
+       puts("default huge shmget");
+       test_shmget(default_hps, SHM_HUGETLB);
+
+       return 0;
+}