LXR linux/tools/testing/selftests/vm/va

   1/*
   2 *
   3 * Authors: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
   4 * Authors: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
   5 *
   6 * This program is free software; you can redistribute it and/or modify
   7 * it under the terms of the GNU General Public License, version 2, as
   8 * published by the Free Software Foundation.
   9
  10 * This program is distributed in the hope that it would be useful, but
  11 * WITHOUT ANY WARRANTY; without even the implied warranty of
  12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  13 *
  14 */
  15
  16#include <stdio.h>
  17#include <sys/mman.h>
  18#include <string.h>
  19
  20#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
  21
  22#ifdef __powerpc64__
  23#define PAGE_SIZE       (64 << 10)
  24/*
  25 * This will work with 16M and 2M hugepage size
  26 */
  27#define HUGETLB_SIZE    (16 << 20)
  28#else
  29#define PAGE_SIZE       (4 << 10)
  30#define HUGETLB_SIZE    (2 << 20)
  31#endif
  32
  33/*
  34 * >= 128TB is the hint addr value we used to select
  35 * large address space.
  36 */
  37#define ADDR_SWITCH_HINT (1UL << 47)
  38#define LOW_ADDR        ((void *) (1UL << 30))
  39#define HIGH_ADDR       ((void *) (1UL << 48))
  40
  41struct testcase {
  42        void *addr;
  43        unsigned long size;
  44        unsigned long flags;
  45        const char *msg;
  46        unsigned int low_addr_required:1;
  47        unsigned int keep_mapped:1;
  48};
  49
  50static struct testcase testcases[] = {
  51        {
  52                /*
  53                 * If stack is moved, we could possibly allocate
  54                 * this at the requested address.
  55                 */
  56                .addr = ((void *)(ADDR_SWITCH_HINT - PAGE_SIZE)),
  57                .size = PAGE_SIZE,
  58                .flags = MAP_PRIVATE | MAP_ANONYMOUS,
  59                .msg = "mmap(ADDR_SWITCH_HINT - PAGE_SIZE, PAGE_SIZE)",
  60                .low_addr_required = 1,
  61        },
  62        {
  63                /*
  64                 * We should never allocate at the requested address or above it
  65                 * The len cross the 128TB boundary. Without MAP_FIXED
  66                 * we will always search in the lower address space.
  67                 */
  68                .addr = ((void *)(ADDR_SWITCH_HINT - PAGE_SIZE)),
  69                .size = 2 * PAGE_SIZE,
  70                .flags = MAP_PRIVATE | MAP_ANONYMOUS,
  71                .msg = "mmap(ADDR_SWITCH_HINT - PAGE_SIZE, (2 * PAGE_SIZE))",
  72                .low_addr_required = 1,
  73        },
  74        {
  75                /*
  76                 * Exact mapping at 128TB, the area is free we should get that
  77                 * even without MAP_FIXED.
  78                 */
  79                .addr = ((void *)(ADDR_SWITCH_HINT)),
  80                .size = PAGE_SIZE,
  81                .flags = MAP_PRIVATE | MAP_ANONYMOUS,
  82                .msg = "mmap(ADDR_SWITCH_HINT, PAGE_SIZE)",
  83                .keep_mapped = 1,
  84        },
  85        {
  86                .addr = (void *)(ADDR_SWITCH_HINT),
  87                .size = 2 * PAGE_SIZE,
  88                .flags = MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED,
  89                .msg = "mmap(ADDR_SWITCH_HINT, 2 * PAGE_SIZE, MAP_FIXED)",
  90        },
  91        {
  92                .addr = NULL,
  93                .size = 2 * PAGE_SIZE,
  94                .flags = MAP_PRIVATE | MAP_ANONYMOUS,
  95                .msg = "mmap(NULL)",
  96                .low_addr_required = 1,
  97        },
  98        {
  99                .addr = LOW_ADDR,
 100                .size = 2 * PAGE_SIZE,
 101                .flags = MAP_PRIVATE | MAP_ANONYMOUS,
 102                .msg = "mmap(LOW_ADDR)",
 103                .low_addr_required = 1,
 104        },
 105        {
 106                .addr = HIGH_ADDR,
 107                .size = 2 * PAGE_SIZE,
 108                .flags = MAP_PRIVATE | MAP_ANONYMOUS,
 109                .msg = "mmap(HIGH_ADDR)",
 110                .keep_mapped = 1,
 111        },
 112        {
 113                .addr = HIGH_ADDR,
 114                .size = 2 * PAGE_SIZE,
 115                .flags = MAP_PRIVATE | MAP_ANONYMOUS,
 116                .msg = "mmap(HIGH_ADDR) again",
 117                .keep_mapped = 1,
 118        },
 119        {
 120                .addr = HIGH_ADDR,
 121                .size = 2 * PAGE_SIZE,
 122                .flags = MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED,
 123                .msg = "mmap(HIGH_ADDR, MAP_FIXED)",
 124        },
 125        {
 126                .addr = (void *) -1,
 127                .size = 2 * PAGE_SIZE,
 128                .flags = MAP_PRIVATE | MAP_ANONYMOUS,
 129                .msg = "mmap(-1)",
 130                .keep_mapped = 1,
 131        },
 132        {
 133                .addr = (void *) -1,
 134                .size = 2 * PAGE_SIZE,
 135                .flags = MAP_PRIVATE | MAP_ANONYMOUS,
 136                .msg = "mmap(-1) again",
 137        },
 138        {
 139                .addr = ((void *)(ADDR_SWITCH_HINT - PAGE_SIZE)),
 140                .size = PAGE_SIZE,
 141                .flags = MAP_PRIVATE | MAP_ANONYMOUS,
 142                .msg = "mmap(ADDR_SWITCH_HINT - PAGE_SIZE, PAGE_SIZE)",
 143                .low_addr_required = 1,
 144        },
 145        {
 146                .addr = (void *)(ADDR_SWITCH_HINT - PAGE_SIZE),
 147                .size = 2 * PAGE_SIZE,
 148                .flags = MAP_PRIVATE | MAP_ANONYMOUS,
 149                .msg = "mmap(ADDR_SWITCH_HINT - PAGE_SIZE, 2 * PAGE_SIZE)",
 150                .low_addr_required = 1,
 151                .keep_mapped = 1,
 152        },
 153        {
 154                .addr = (void *)(ADDR_SWITCH_HINT - PAGE_SIZE / 2),
 155                .size = 2 * PAGE_SIZE,
 156                .flags = MAP_PRIVATE | MAP_ANONYMOUS,
 157                .msg = "mmap(ADDR_SWITCH_HINT - PAGE_SIZE/2 , 2 * PAGE_SIZE)",
 158                .low_addr_required = 1,
 159                .keep_mapped = 1,
 160        },
 161        {
 162                .addr = ((void *)(ADDR_SWITCH_HINT)),
 163                .size = PAGE_SIZE,
 164                .flags = MAP_PRIVATE | MAP_ANONYMOUS,
 165                .msg = "mmap(ADDR_SWITCH_HINT, PAGE_SIZE)",
 166        },
 167        {
 168                .addr = (void *)(ADDR_SWITCH_HINT),
 169                .size = 2 * PAGE_SIZE,
 170                .flags = MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED,
 171                .msg = "mmap(ADDR_SWITCH_HINT, 2 * PAGE_SIZE, MAP_FIXED)",
 172        },
 173};
 174
 175static struct testcase hugetlb_testcases[] = {
 176        {
 177                .addr = NULL,
 178                .size = HUGETLB_SIZE,
 179                .flags = MAP_HUGETLB | MAP_PRIVATE | MAP_ANONYMOUS,
 180                .msg = "mmap(NULL, MAP_HUGETLB)",
 181                .low_addr_required = 1,
 182        },
 183        {
 184                .addr = LOW_ADDR,
 185                .size = HUGETLB_SIZE,
 186                .flags = MAP_HUGETLB | MAP_PRIVATE | MAP_ANONYMOUS,
 187                .msg = "mmap(LOW_ADDR, MAP_HUGETLB)",
 188                .low_addr_required = 1,
 189        },
 190        {
 191                .addr = HIGH_ADDR,
 192                .size = HUGETLB_SIZE,
 193                .flags = MAP_HUGETLB | MAP_PRIVATE | MAP_ANONYMOUS,
 194                .msg = "mmap(HIGH_ADDR, MAP_HUGETLB)",
 195                .keep_mapped = 1,
 196        },
 197        {
 198                .addr = HIGH_ADDR,
 199                .size = HUGETLB_SIZE,
 200                .flags = MAP_HUGETLB | MAP_PRIVATE | MAP_ANONYMOUS,
 201                .msg = "mmap(HIGH_ADDR, MAP_HUGETLB) again",
 202                .keep_mapped = 1,
 203        },
 204        {
 205                .addr = HIGH_ADDR,
 206                .size = HUGETLB_SIZE,
 207                .flags = MAP_HUGETLB | MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED,
 208                .msg = "mmap(HIGH_ADDR, MAP_FIXED | MAP_HUGETLB)",
 209        },
 210        {
 211                .addr = (void *) -1,
 212                .size = HUGETLB_SIZE,
 213                .flags = MAP_HUGETLB | MAP_PRIVATE | MAP_ANONYMOUS,
 214                .msg = "mmap(-1, MAP_HUGETLB)",
 215                .keep_mapped = 1,
 216        },
 217        {
 218                .addr = (void *) -1,
 219                .size = HUGETLB_SIZE,
 220                .flags = MAP_HUGETLB | MAP_PRIVATE | MAP_ANONYMOUS,
 221                .msg = "mmap(-1, MAP_HUGETLB) again",
 222        },
 223        {
 224                .addr = (void *)(ADDR_SWITCH_HINT - PAGE_SIZE),
 225                .size = 2 * HUGETLB_SIZE,
 226                .flags = MAP_HUGETLB | MAP_PRIVATE | MAP_ANONYMOUS,
 227                .msg = "mmap(ADDR_SWITCH_HINT - PAGE_SIZE, 2*HUGETLB_SIZE, MAP_HUGETLB)",
 228                .low_addr_required = 1,
 229                .keep_mapped = 1,
 230        },
 231        {
 232                .addr = (void *)(ADDR_SWITCH_HINT),
 233                .size = 2 * HUGETLB_SIZE,
 234                .flags = MAP_HUGETLB | MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED,
 235                .msg = "mmap(ADDR_SWITCH_HINT , 2*HUGETLB_SIZE, MAP_FIXED | MAP_HUGETLB)",
 236        },
 237};
 238
 239static int run_test(struct testcase *test, int count)
 240{
 241        void *p;
 242        int i, ret = 0;
 243
 244        for (i = 0; i < count; i++) {
 245                struct testcase *t = test + i;
 246
 247                p = mmap(t->addr, t->size, PROT_READ | PROT_WRITE, t->flags, -1, 0);
 248
 249                printf("%s: %p - ", t->msg, p);
 250
 251                if (p == MAP_FAILED) {
 252                        printf("FAILED\n");
 253                        ret = 1;
 254                        continue;
 255                }
 256
 257                if (t->low_addr_required && p >= (void *)(ADDR_SWITCH_HINT)) {
 258                        printf("FAILED\n");
 259                        ret = 1;
 260                } else {
 261                        /*
 262                         * Do a dereference of the address returned so that we catch
 263                         * bugs in page fault handling
 264                         */
 265                        memset(p, 0, t->size);
 266                        printf("OK\n");
 267                }
 268                if (!t->keep_mapped)
 269                        munmap(p, t->size);
 270        }
 271
 272        return ret;
 273}
 274
 275static int supported_arch(void)
 276{
 277#if defined(__powerpc64__)
 278        return 1;
 279#elif defined(__x86_64__)
 280        return 1;
 281#else
 282        return 0;
 283#endif
 284}
 285
 286int main(int argc, char **argv)
 287{
 288        int ret;
 289
 290        if (!supported_arch())
 291                return 0;
 292
 293        ret = run_test(testcases, ARRAY_SIZE(testcases));
 294        if (argc == 2 && !strcmp(argv[1], "--run-hugetlb"))
 295                ret = run_test(hugetlb_testcases, ARRAY_SIZE(hugetlb_testcases));
 296        return ret;
 297}
 298