1#!/bin/bash 2# SPDX-License-Identifier: GPL-2.0 3# Please run as root 4 5# Kselftest framework requirement - SKIP code is 4. 6ksft_skip=4 7 8count_total=0 9count_pass=0 10count_fail=0 11count_skip=0 12exitcode=0 13 14usage() { 15 cat <<EOF 16usage: ${BASH_SOURCE[0]:-$0} [ options ] 17 18 -a: run all tests, including extra ones (other than destructive ones) 19 -t: specify specific categories to tests to run 20 -h: display this message 21 -n: disable TAP output 22 -d: run destructive tests 23 24The default behavior is to run required tests only. If -a is specified, 25will run all tests. 26 27Alternatively, specific groups tests can be run by passing a string 28to the -t argument containing one or more of the following categories 29separated by spaces: 30- mmap 31 tests for mmap(2) 32- gup_test 33 tests for gup 34- userfaultfd 35 tests for userfaultfd(2) 36- compaction 37 a test for the patch "Allow compaction of unevictable pages" 38- mlock 39 tests for mlock(2) 40- mremap 41 tests for mremap(2) 42- hugevm 43 tests for very large virtual address space 44- vmalloc 45 vmalloc smoke tests 46- hmm 47 hmm smoke tests 48- madv_guard 49 test madvise(2) MADV_GUARD_INSTALL and MADV_GUARD_REMOVE options 50- madv_populate 51 test memadvise(2) MADV_POPULATE_{READ,WRITE} options 52- memfd_secret 53 test memfd_secret(2) 54- process_mrelease 55 test process_mrelease(2) 56- ksm 57 ksm tests that do not require >=2 NUMA nodes 58- ksm_numa 59 ksm tests that require >=2 NUMA nodes 60- pkey 61 memory protection key tests 62- soft_dirty 63 test soft dirty page bit semantics 64- pagemap 65 test pagemap_scan IOCTL 66- pfnmap 67 tests for VM_PFNMAP handling 68- cow 69 test copy-on-write semantics 70- thp 71 test transparent huge pages 72- hugetlb 73 test hugetlbfs huge pages 74- migration 75 invoke move_pages(2) to exercise the migration entry code 76 paths in the kernel 77- mkdirty 78 test handling of code that might set PTE/PMD dirty in 79 read-only VMAs 80- mdwe 81 test prctl(PR_SET_MDWE, ...) 82- page_frag 83 test handling of page fragment allocation and freeing 84- vma_merge 85 test VMA merge cases behave as expected 86 87example: ./run_vmtests.sh -t "hmm mmap ksm" 88EOF 89 exit 0 90} 91 92RUN_ALL=false 93RUN_DESTRUCTIVE=false 94TAP_PREFIX="# " 95 96while getopts "aht:n" OPT; do 97 case ${OPT} in 98 "a") RUN_ALL=true ;; 99 "h") usage ;; 100 "t") VM_SELFTEST_ITEMS=${OPTARG} ;; 101 "n") TAP_PREFIX= ;; 102 "d") RUN_DESTRUCTIVE=true ;; 103 esac 104done 105shift $((OPTIND -1)) 106 107# default behavior: run all tests 108VM_SELFTEST_ITEMS=${VM_SELFTEST_ITEMS:-default} 109 110test_selected() { 111 if [ "$VM_SELFTEST_ITEMS" == "default" ]; then 112 # If no VM_SELFTEST_ITEMS are specified, run all tests 113 return 0 114 fi 115 # If test selected argument is one of the test items 116 if [[ " ${VM_SELFTEST_ITEMS[*]} " =~ " ${1} " ]]; then 117 return 0 118 else 119 return 1 120 fi 121} 122 123run_gup_matrix() { 124 # -t: thp=on, -T: thp=off, -H: hugetlb=on 125 local hugetlb_mb=$(( needmem_KB / 1024 )) 126 127 for huge in -t -T "-H -m $hugetlb_mb"; do 128 # -u: gup-fast, -U: gup-basic, -a: pin-fast, -b: pin-basic, -L: pin-longterm 129 for test_cmd in -u -U -a -b -L; do 130 # -w: write=1, -W: write=0 131 for write in -w -W; do 132 # -S: shared 133 for share in -S " "; do 134 # -n: How many pages to fetch together? 512 is special 135 # because it's default thp size (or 2M on x86), 123 to 136 # just test partial gup when hit a huge in whatever form 137 for num in "-n 1" "-n 512" "-n 123"; do 138 CATEGORY="gup_test" run_test ./gup_test \ 139 $huge $test_cmd $write $share $num 140 done 141 done 142 done 143 done 144 done 145} 146 147# get huge pagesize and freepages from /proc/meminfo 148while read -r name size unit; do 149 if [ "$name" = "HugePages_Free:" ]; then 150 freepgs="$size" 151 fi 152 if [ "$name" = "Hugepagesize:" ]; then 153 hpgsize_KB="$size" 154 fi 155done < /proc/meminfo 156 157# Simple hugetlbfs tests have a hardcoded minimum requirement of 158# huge pages totaling 256MB (262144KB) in size. The userfaultfd 159# hugetlb test requires a minimum of 2 * nr_cpus huge pages. Take 160# both of these requirements into account and attempt to increase 161# number of huge pages available. 162nr_cpus=$(nproc) 163uffd_min_KB=$((hpgsize_KB * nr_cpus * 2)) 164hugetlb_min_KB=$((256 * 1024)) 165if [[ $uffd_min_KB -gt $hugetlb_min_KB ]]; then 166 needmem_KB=$uffd_min_KB 167else 168 needmem_KB=$hugetlb_min_KB 169fi 170 171# set proper nr_hugepages 172if [ -n "$freepgs" ] && [ -n "$hpgsize_KB" ]; then 173 nr_hugepgs=$(cat /proc/sys/vm/nr_hugepages) 174 needpgs=$((needmem_KB / hpgsize_KB)) 175 tries=2 176 while [ "$tries" -gt 0 ] && [ "$freepgs" -lt "$needpgs" ]; do 177 lackpgs=$((needpgs - freepgs)) 178 echo 3 > /proc/sys/vm/drop_caches 179 if ! echo $((lackpgs + nr_hugepgs)) > /proc/sys/vm/nr_hugepages; then 180 echo "Please run this test as root" 181 exit $ksft_skip 182 fi 183 while read -r name size unit; do 184 if [ "$name" = "HugePages_Free:" ]; then 185 freepgs=$size 186 fi 187 done < /proc/meminfo 188 tries=$((tries - 1)) 189 done 190 if [ "$freepgs" -lt "$needpgs" ]; then 191 printf "Not enough huge pages available (%d < %d)\n" \ 192 "$freepgs" "$needpgs" 193 fi 194 HAVE_HUGEPAGES=1 195else 196 echo "no hugetlbfs support in kernel?" 197 HAVE_HUGEPAGES=0 198fi 199 200# filter 64bit architectures 201ARCH64STR="arm64 mips64 parisc64 ppc64 ppc64le riscv64 s390x sparc64 x86_64" 202if [ -z "$ARCH" ]; then 203 ARCH=$(uname -m 2>/dev/null | sed -e 's/aarch64.*/arm64/') 204fi 205VADDR64=0 206echo "$ARCH64STR" | grep "$ARCH" &>/dev/null && VADDR64=1 207 208tap_prefix() { 209 sed -e "s/^/${TAP_PREFIX}/" 210} 211 212tap_output() { 213 if [[ ! -z "$TAP_PREFIX" ]]; then 214 read str 215 echo $str 216 fi 217} 218 219pretty_name() { 220 echo "$*" | sed -e 's/^\(bash \)\?\.\///' 221} 222 223# Usage: run_test [test binary] [arbitrary test arguments...] 224run_test() { 225 if test_selected ${CATEGORY}; then 226 local skip=0 227 228 # On memory constrainted systems some tests can fail to allocate hugepages. 229 # perform some cleanup before the test for a higher success rate. 230 if [ ${CATEGORY} == "thp" -o ${CATEGORY} == "hugetlb" ]; then 231 if [ "${HAVE_HUGEPAGES}" = "1" ]; then 232 echo 3 > /proc/sys/vm/drop_caches 233 sleep 2 234 echo 1 > /proc/sys/vm/compact_memory 235 sleep 2 236 else 237 echo "hugepages not supported" | tap_prefix 238 skip=1 239 fi 240 fi 241 242 local test=$(pretty_name "$*") 243 local title="running $*" 244 local sep=$(echo -n "$title" | tr "[:graph:][:space:]" -) 245 printf "%s\n%s\n%s\n" "$sep" "$title" "$sep" | tap_prefix 246 247 if [ "${skip}" != "1" ]; then 248 ("$@" 2>&1) | tap_prefix 249 local ret=${PIPESTATUS[0]} 250 else 251 local ret=$ksft_skip 252 fi 253 count_total=$(( count_total + 1 )) 254 if [ $ret -eq 0 ]; then 255 count_pass=$(( count_pass + 1 )) 256 echo "[PASS]" | tap_prefix 257 echo "ok ${count_total} ${test}" | tap_output 258 elif [ $ret -eq $ksft_skip ]; then 259 count_skip=$(( count_skip + 1 )) 260 echo "[SKIP]" | tap_prefix 261 echo "ok ${count_total} ${test} # SKIP" | tap_output 262 exitcode=$ksft_skip 263 else 264 count_fail=$(( count_fail + 1 )) 265 echo "[FAIL]" | tap_prefix 266 echo "not ok ${count_total} ${test} # exit=$ret" | tap_output 267 exitcode=1 268 fi 269 fi # test_selected 270} 271 272echo "TAP version 13" | tap_output 273 274CATEGORY="hugetlb" run_test ./hugepage-mmap 275 276shmmax=$(cat /proc/sys/kernel/shmmax) 277shmall=$(cat /proc/sys/kernel/shmall) 278echo 268435456 > /proc/sys/kernel/shmmax 279echo 4194304 > /proc/sys/kernel/shmall 280CATEGORY="hugetlb" run_test ./hugepage-shm 281echo "$shmmax" > /proc/sys/kernel/shmmax 282echo "$shmall" > /proc/sys/kernel/shmall 283 284CATEGORY="hugetlb" run_test ./map_hugetlb 285CATEGORY="hugetlb" run_test ./hugepage-mremap 286CATEGORY="hugetlb" run_test ./hugepage-vmemmap 287CATEGORY="hugetlb" run_test ./hugetlb-madvise 288CATEGORY="hugetlb" run_test ./hugetlb_dio 289 290if [ "${HAVE_HUGEPAGES}" = "1" ]; then 291 nr_hugepages_tmp=$(cat /proc/sys/vm/nr_hugepages) 292 # For this test, we need one and just one huge page 293 echo 1 > /proc/sys/vm/nr_hugepages 294 CATEGORY="hugetlb" run_test ./hugetlb_fault_after_madv 295 CATEGORY="hugetlb" run_test ./hugetlb_madv_vs_map 296 # Restore the previous number of huge pages, since further tests rely on it 297 echo "$nr_hugepages_tmp" > /proc/sys/vm/nr_hugepages 298fi 299 300if test_selected "hugetlb"; then 301 echo "NOTE: These hugetlb tests provide minimal coverage. Use" | tap_prefix 302 echo " https://github.com/libhugetlbfs/libhugetlbfs.git for" | tap_prefix 303 echo " hugetlb regression testing." | tap_prefix 304fi 305 306CATEGORY="mmap" run_test ./map_fixed_noreplace 307 308if $RUN_ALL; then 309 run_gup_matrix 310else 311 # get_user_pages_fast() benchmark 312 CATEGORY="gup_test" run_test ./gup_test -u 313 # pin_user_pages_fast() benchmark 314 CATEGORY="gup_test" run_test ./gup_test -a 315fi 316# Dump pages 0, 19, and 4096, using pin_user_pages: 317CATEGORY="gup_test" run_test ./gup_test -ct -F 0x1 0 19 0x1000 318CATEGORY="gup_test" run_test ./gup_longterm 319 320CATEGORY="userfaultfd" run_test ./uffd-unit-tests 321uffd_stress_bin=./uffd-stress 322CATEGORY="userfaultfd" run_test ${uffd_stress_bin} anon 20 16 323# Hugetlb tests require source and destination huge pages. Pass in half 324# the size of the free pages we have, which is used for *each*. 325# uffd-stress expects a region expressed in MiB, so we adjust 326# half_ufd_size_MB accordingly. 327half_ufd_size_MB=$(((freepgs * hpgsize_KB) / 1024 / 2)) 328CATEGORY="userfaultfd" run_test ${uffd_stress_bin} hugetlb "$half_ufd_size_MB" 32 329CATEGORY="userfaultfd" run_test ${uffd_stress_bin} hugetlb-private "$half_ufd_size_MB" 32 330CATEGORY="userfaultfd" run_test ${uffd_stress_bin} shmem 20 16 331CATEGORY="userfaultfd" run_test ${uffd_stress_bin} shmem-private 20 16 332# uffd-wp-mremap requires at least one page of each size. 333have_all_size_hugepgs=true 334declare -A nr_size_hugepgs 335for f in /sys/kernel/mm/hugepages/**/nr_hugepages; do 336 old=$(cat $f) 337 nr_size_hugepgs["$f"]="$old" 338 if [ "$old" == 0 ]; then 339 echo 1 > "$f" 340 fi 341 if [ $(cat "$f") == 0 ]; then 342 have_all_size_hugepgs=false 343 break 344 fi 345done 346if $have_all_size_hugepgs; then 347 CATEGORY="userfaultfd" run_test ./uffd-wp-mremap 348else 349 echo "# SKIP ./uffd-wp-mremap" 350fi 351 352#cleanup 353for f in "${!nr_size_hugepgs[@]}"; do 354 echo "${nr_size_hugepgs["$f"]}" > "$f" 355done 356echo "$nr_hugepgs" > /proc/sys/vm/nr_hugepages 357 358CATEGORY="compaction" run_test ./compaction_test 359 360if command -v sudo &> /dev/null && sudo -u nobody ls ./on-fault-limit >/dev/null; 361then 362 CATEGORY="mlock" run_test sudo -u nobody ./on-fault-limit 363else 364 echo "# SKIP ./on-fault-limit" 365fi 366 367CATEGORY="mmap" run_test ./map_populate 368 369CATEGORY="mlock" run_test ./mlock-random-test 370 371CATEGORY="mlock" run_test ./mlock2-tests 372 373CATEGORY="process_mrelease" run_test ./mrelease_test 374 375CATEGORY="mremap" run_test ./mremap_test 376 377CATEGORY="hugetlb" run_test ./thuge-gen 378CATEGORY="hugetlb" run_test ./charge_reserved_hugetlb.sh -cgroup-v2 379CATEGORY="hugetlb" run_test ./hugetlb_reparenting_test.sh -cgroup-v2 380if $RUN_DESTRUCTIVE; then 381nr_hugepages_tmp=$(cat /proc/sys/vm/nr_hugepages) 382enable_soft_offline=$(cat /proc/sys/vm/enable_soft_offline) 383echo 8 > /proc/sys/vm/nr_hugepages 384CATEGORY="hugetlb" run_test ./hugetlb-soft-offline 385echo "$nr_hugepages_tmp" > /proc/sys/vm/nr_hugepages 386echo "$enable_soft_offline" > /proc/sys/vm/enable_soft_offline 387CATEGORY="hugetlb" run_test ./hugetlb-read-hwpoison 388fi 389 390if [ $VADDR64 -ne 0 ]; then 391 392 # set overcommit_policy as OVERCOMMIT_ALWAYS so that kernel 393 # allows high virtual address allocation requests independent 394 # of platform's physical memory. 395 396 if [ -x ./virtual_address_range ]; then 397 prev_policy=$(cat /proc/sys/vm/overcommit_memory) 398 echo 1 > /proc/sys/vm/overcommit_memory 399 CATEGORY="hugevm" run_test ./virtual_address_range 400 echo $prev_policy > /proc/sys/vm/overcommit_memory 401 fi 402 403 # va high address boundary switch test 404 ARCH_ARM64="arm64" 405 prev_nr_hugepages=$(cat /proc/sys/vm/nr_hugepages) 406 if [ "$ARCH" == "$ARCH_ARM64" ]; then 407 echo 6 > /proc/sys/vm/nr_hugepages 408 fi 409 CATEGORY="hugevm" run_test bash ./va_high_addr_switch.sh 410 if [ "$ARCH" == "$ARCH_ARM64" ]; then 411 echo $prev_nr_hugepages > /proc/sys/vm/nr_hugepages 412 fi 413fi # VADDR64 414 415# vmalloc stability smoke test 416CATEGORY="vmalloc" run_test bash ./test_vmalloc.sh smoke 417 418CATEGORY="mremap" run_test ./mremap_dontunmap 419 420CATEGORY="hmm" run_test bash ./test_hmm.sh smoke 421 422# MADV_GUARD_INSTALL and MADV_GUARD_REMOVE tests 423CATEGORY="madv_guard" run_test ./guard-regions 424 425# MADV_POPULATE_READ and MADV_POPULATE_WRITE tests 426CATEGORY="madv_populate" run_test ./madv_populate 427 428CATEGORY="vma_merge" run_test ./merge 429 430if [ -x ./memfd_secret ] 431then 432(echo 0 > /proc/sys/kernel/yama/ptrace_scope 2>&1) | tap_prefix 433CATEGORY="memfd_secret" run_test ./memfd_secret 434fi 435 436# KSM KSM_MERGE_TIME_HUGE_PAGES test with size of 100 437if [ "${HAVE_HUGEPAGES}" = "1" ]; then 438 CATEGORY="ksm" run_test ./ksm_tests -H -s 100 439fi 440# KSM KSM_MERGE_TIME test with size of 100 441CATEGORY="ksm" run_test ./ksm_tests -P -s 100 442# KSM MADV_MERGEABLE test with 10 identical pages 443CATEGORY="ksm" run_test ./ksm_tests -M -p 10 444# KSM unmerge test 445CATEGORY="ksm" run_test ./ksm_tests -U 446# KSM test with 10 zero pages and use_zero_pages = 0 447CATEGORY="ksm" run_test ./ksm_tests -Z -p 10 -z 0 448# KSM test with 10 zero pages and use_zero_pages = 1 449CATEGORY="ksm" run_test ./ksm_tests -Z -p 10 -z 1 450# KSM test with 2 NUMA nodes and merge_across_nodes = 1 451CATEGORY="ksm_numa" run_test ./ksm_tests -N -m 1 452# KSM test with 2 NUMA nodes and merge_across_nodes = 0 453CATEGORY="ksm_numa" run_test ./ksm_tests -N -m 0 454 455CATEGORY="ksm" run_test ./ksm_functional_tests 456 457# protection_keys tests 458nr_hugepgs=$(cat /proc/sys/vm/nr_hugepages) 459if [ -x ./protection_keys_32 ] 460then 461 CATEGORY="pkey" run_test ./protection_keys_32 462fi 463 464if [ -x ./protection_keys_64 ] 465then 466 CATEGORY="pkey" run_test ./protection_keys_64 467fi 468echo "$nr_hugepgs" > /proc/sys/vm/nr_hugepages 469 470if [ -x ./soft-dirty ] 471then 472 CATEGORY="soft_dirty" run_test ./soft-dirty 473fi 474 475CATEGORY="pagemap" run_test ./pagemap_ioctl 476 477CATEGORY="pfnmap" run_test ./pfnmap 478 479# COW tests 480CATEGORY="cow" run_test ./cow 481 482CATEGORY="thp" run_test ./khugepaged 483 484CATEGORY="thp" run_test ./khugepaged -s 2 485 486CATEGORY="thp" run_test ./transhuge-stress -d 20 487 488# Try to create XFS if not provided 489if [ -z "${SPLIT_HUGE_PAGE_TEST_XFS_PATH}" ]; then 490 if [ "${HAVE_HUGEPAGES}" = "1" ]; then 491 if test_selected "thp"; then 492 if grep xfs /proc/filesystems &>/dev/null; then 493 XFS_IMG=$(mktemp /tmp/xfs_img_XXXXXX) 494 SPLIT_HUGE_PAGE_TEST_XFS_PATH=$(mktemp -d /tmp/xfs_dir_XXXXXX) 495 truncate -s 314572800 ${XFS_IMG} 496 mkfs.xfs -q ${XFS_IMG} 497 mount -o loop ${XFS_IMG} ${SPLIT_HUGE_PAGE_TEST_XFS_PATH} 498 MOUNTED_XFS=1 499 fi 500 fi 501 fi 502fi 503 504CATEGORY="thp" run_test ./split_huge_page_test ${SPLIT_HUGE_PAGE_TEST_XFS_PATH} 505 506if [ -n "${MOUNTED_XFS}" ]; then 507 umount ${SPLIT_HUGE_PAGE_TEST_XFS_PATH} 508 rmdir ${SPLIT_HUGE_PAGE_TEST_XFS_PATH} 509 rm -f ${XFS_IMG} 510fi 511 512CATEGORY="migration" run_test ./migration 513 514CATEGORY="mkdirty" run_test ./mkdirty 515 516CATEGORY="mdwe" run_test ./mdwe_test 517 518CATEGORY="page_frag" run_test ./test_page_frag.sh smoke 519 520CATEGORY="page_frag" run_test ./test_page_frag.sh aligned 521 522CATEGORY="page_frag" run_test ./test_page_frag.sh nonaligned 523 524echo "SUMMARY: PASS=${count_pass} SKIP=${count_skip} FAIL=${count_fail}" | tap_prefix 525echo "1..${count_total}" | tap_output 526 527exit $exitcode 528