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