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