tools/testing/selftests/mm/thuge-gen.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Test selecting other page sizes for mmap/shmget.
   3
   4    Before running this huge pages for each huge page size must have been
   5    reserved.
   6    For large pages beyond MAX_PAGE_ORDER (like 1GB on x86) boot options must
   7    be used. 1GB wouldn't be tested if it isn't available.
   8    Also shmmax must be increased.
   9    And you need to run as root to work around some weird permissions in shm.
  10    And nothing using huge pages should run in parallel.
  11    When the program aborts you may need to clean up the shm segments with
  12    ipcrm -m by hand, like this
  13    sudo ipcs | awk '$1 == "0x00000000" {print $2}' | xargs -n1 sudo ipcrm -m
  14    (warning this will remove all if someone else uses them) */
  15
  16 #define _GNU_SOURCE
  17 #include <sys/mman.h>
  18 #include <linux/mman.h>
  19 #include <stdlib.h>
  20 #include <stdio.h>
  21 #include <sys/ipc.h>
  22 #include <sys/shm.h>
  23 #include <sys/stat.h>
  24 #include <glob.h>
  25 #include <assert.h>
  26 #include <unistd.h>
  27 #include <stdarg.h>
  28 #include <string.h>
  29 #include "vm_util.h"
  30 #include "../kselftest.h"
  31
  32 #if !defined(MAP_HUGETLB)
  33 #define MAP_HUGETLB     0x40000
  34 #endif
  35
  36 #define SHM_HUGETLB     04000   /* segment will use huge TLB pages */
  37 #ifndef SHM_HUGE_SHIFT
  38 #define SHM_HUGE_SHIFT  26
  39 #endif
  40 #ifndef SHM_HUGE_MASK
  41 #define SHM_HUGE_MASK   0x3f
  42 #endif
  43 #ifndef SHM_HUGE_2MB
  44 #define SHM_HUGE_2MB    (21 << SHM_HUGE_SHIFT)
  45 #endif
  46 #ifndef SHM_HUGE_1GB
  47 #define SHM_HUGE_1GB    (30 << SHM_HUGE_SHIFT)
  48 #endif
  49
  50 #define NUM_PAGESIZES   5
  51 #define NUM_PAGES 4
  52
  53 unsigned long page_sizes[NUM_PAGESIZES];
  54 int num_page_sizes;
  55
  56 int ilog2(unsigned long v)
  57 {
  58         int l = 0;
  59         while ((1UL << l) < v)
  60                 l++;
  61         return l;
  62 }
  63
  64 void show(unsigned long ps)
  65 {
  66         char buf[100];
  67
  68         if (ps == getpagesize())
  69                 return;
  70
  71         ksft_print_msg("%luMB: ", ps >> 20);
  72
  73         fflush(stdout);
  74         snprintf(buf, sizeof buf,
  75                 "cat /sys/kernel/mm/hugepages/hugepages-%lukB/free_hugepages",
  76                 ps >> 10);
  77         system(buf);
  78 }
  79
  80 unsigned long read_sysfs(int warn, char *fmt, ...)
  81 {
  82         char *line = NULL;
  83         size_t linelen = 0;
  84         char buf[100];
  85         FILE *f;
  86         va_list ap;
  87         unsigned long val = 0;
  88
  89         va_start(ap, fmt);
  90         vsnprintf(buf, sizeof buf, fmt, ap);
  91         va_end(ap);
  92
  93         f = fopen(buf, "r");
  94         if (!f) {
  95                 if (warn)
  96                         ksft_print_msg("missing %s\n", buf);
  97                 return 0;
  98         }
  99         if (getline(&line, &linelen, f) > 0) {
 100                 sscanf(line, "%lu", &val);
 101         }
 102         fclose(f);
 103         free(line);
 104         return val;
 105 }
 106
 107 unsigned long read_free(unsigned long ps)
 108 {
 109         return read_sysfs(ps != getpagesize(),
 110                           "/sys/kernel/mm/hugepages/hugepages-%lukB/free_hugepages",
 111                           ps >> 10);
 112 }
 113
 114 void test_mmap(unsigned long size, unsigned flags)
 115 {
 116         char *map;
 117         unsigned long before, after;
 118
 119         before = read_free(size);
 120         map = mmap(NULL, size*NUM_PAGES, PROT_READ|PROT_WRITE,
 121                         MAP_PRIVATE|MAP_ANONYMOUS|MAP_HUGETLB|flags, -1, 0);
 122         if (map == MAP_FAILED)
 123                 ksft_exit_fail_msg("mmap: %s\n", strerror(errno));
 124
 125         memset(map, 0xff, size*NUM_PAGES);
 126         after = read_free(size);
 127
 128         show(size);
 129         ksft_test_result(size == getpagesize() || (before - after) == NUM_PAGES,
 130                          "%s mmap\n", __func__);
 131
 132         if (munmap(map, size * NUM_PAGES))
 133                 ksft_exit_fail_msg("%s: unmap %s\n", __func__, strerror(errno));
 134 }
 135
 136 void test_shmget(unsigned long size, unsigned flags)
 137 {
 138         int id;
 139         unsigned long before, after;
 140         struct shm_info i;
 141         char *map;
 142
 143         before = read_free(size);
 144         id = shmget(IPC_PRIVATE, size * NUM_PAGES, IPC_CREAT|0600|flags);
 145         if (id < 0) {
 146                 if (errno == EPERM) {
 147                         ksft_test_result_skip("shmget requires root privileges: %s\n",
 148                                               strerror(errno));
 149                         return;
 150                 }
 151                 ksft_exit_fail_msg("shmget: %s\n", strerror(errno));
 152         }
 153
 154         if (shmctl(id, SHM_INFO, (void *)&i) < 0)
 155                 ksft_exit_fail_msg("shmctl: %s\n", strerror(errno));
 156
 157         map = shmat(id, NULL, 0600);
 158         if (map == MAP_FAILED)
 159                 ksft_exit_fail_msg("shmat: %s\n", strerror(errno));
 160
 161         shmctl(id, IPC_RMID, NULL);
 162
 163         memset(map, 0xff, size*NUM_PAGES);
 164         after = read_free(size);
 165
 166         show(size);
 167         ksft_test_result(size == getpagesize() || (before - after) == NUM_PAGES,
 168                          "%s: mmap\n", __func__);
 169         if (shmdt(map))
 170                 ksft_exit_fail_msg("%s: shmdt: %s\n", __func__, strerror(errno));
 171 }
 172
 173 void find_pagesizes(void)
 174 {
 175         unsigned long largest = getpagesize();
 176         int i;
 177         glob_t g;
 178
 179         glob("/sys/kernel/mm/hugepages/hugepages-*kB", 0, NULL, &g);
 180         assert(g.gl_pathc <= NUM_PAGESIZES);
 181         for (i = 0; (i < g.gl_pathc) && (num_page_sizes < NUM_PAGESIZES); i++) {
 182                 sscanf(g.gl_pathv[i], "/sys/kernel/mm/hugepages/hugepages-%lukB",
 183                                 &page_sizes[num_page_sizes]);
 184                 page_sizes[num_page_sizes] <<= 10;
 185                 ksft_print_msg("Found %luMB\n", page_sizes[i] >> 20);
 186
 187                 if (page_sizes[num_page_sizes] > largest)
 188                         largest = page_sizes[i];
 189
 190                 if (read_free(page_sizes[num_page_sizes]) >= NUM_PAGES)
 191                         num_page_sizes++;
 192                 else
 193                         ksft_print_msg("SKIP for size %lu MB as not enough huge pages, need %u\n",
 194                                        page_sizes[num_page_sizes] >> 20, NUM_PAGES);
 195         }
 196         globfree(&g);
 197
 198         if (read_sysfs(0, "/proc/sys/kernel/shmmax") < NUM_PAGES * largest)
 199                 ksft_exit_fail_msg("Please do echo %lu > /proc/sys/kernel/shmmax",
 200                                    largest * NUM_PAGES);
 201
 202 #if defined(__x86_64__)
 203         if (largest != 1U<<30) {
 204                 ksft_exit_fail_msg("No GB pages available on x86-64\n"
 205                                    "Please boot with hugepagesz=1G hugepages=%d\n", NUM_PAGES);
 206         }
 207 #endif
 208 }
 209
 210 int main(void)
 211 {
 212         unsigned default_hps = default_huge_page_size();
 213         int i;
 214
 215         ksft_print_header();
 216
 217         find_pagesizes();
 218
 219         if (!num_page_sizes)
 220                 ksft_finished();
 221
 222         ksft_set_plan(2 * num_page_sizes + 3);
 223
 224         for (i = 0; i < num_page_sizes; i++) {
 225                 unsigned long ps = page_sizes[i];
 226                 int arg = ilog2(ps) << MAP_HUGE_SHIFT;
 227
 228                 ksft_print_msg("Testing %luMB mmap with shift %x\n", ps >> 20, arg);
 229                 test_mmap(ps, MAP_HUGETLB | arg);
 230         }
 231
 232         ksft_print_msg("Testing default huge mmap\n");
 233         test_mmap(default_hps, MAP_HUGETLB);
 234
 235         ksft_print_msg("Testing non-huge shmget\n");
 236         test_shmget(getpagesize(), 0);
 237
 238         for (i = 0; i < num_page_sizes; i++) {
 239                 unsigned long ps = page_sizes[i];
 240                 int arg = ilog2(ps) << SHM_HUGE_SHIFT;
 241                 ksft_print_msg("Testing %luMB shmget with shift %x\n", ps >> 20, arg);
 242                 test_shmget(ps, SHM_HUGETLB | arg);
 243         }
 244
 245         ksft_print_msg("default huge shmget\n");
 246         test_shmget(default_hps, SHM_HUGETLB);
 247
 248         ksft_finished();
 249 }