| #!/bin/bash | |
| # SPDX-License-Identifier: GPL-2.0 | |
| # Please run as root | |
| # IMPORTANT: If you add a new test CATEGORY please add a simple wrapper | |
| # script so kunit knows to run it, and add it to the list below. | |
| # If you do not YOUR TESTS WILL NOT RUN IN THE CI. | |
| # Kselftest framework requirement - SKIP code is 4. | |
| ksft_skip=4 | |
| count_total=0 | |
| count_pass=0 | |
| count_fail=0 | |
| count_skip=0 | |
| exitcode=0 | |
| usage() { | |
| cat <<EOF | |
| usage: ${BASH_SOURCE[0]:-$0} [ options ] | |
| -a: run all tests, including extra ones (other than destructive ones) | |
| -t: specify specific categories to tests to run | |
| -h: display this message | |
| -n: disable TAP output | |
| -d: run destructive tests | |
| The default behavior is to run required tests only. If -a is specified, | |
| will run all tests. | |
| Alternatively, specific groups tests can be run by passing a string | |
| to the -t argument containing one or more of the following categories | |
| separated by spaces: | |
| - mmap | |
| tests for mmap(2) | |
| - gup_test | |
| tests for gup | |
| - userfaultfd | |
| tests for userfaultfd(2) | |
| - compaction | |
| a test for the patch "Allow compaction of unevictable pages" | |
| - mlock | |
| tests for mlock(2) | |
| - mremap | |
| tests for mremap(2) | |
| - hugevm | |
| tests for very large virtual address space | |
| - vmalloc | |
| vmalloc smoke tests | |
| - hmm | |
| hmm smoke tests | |
| - madv_guard | |
| test madvise(2) MADV_GUARD_INSTALL and MADV_GUARD_REMOVE options | |
| - madv_populate | |
| test memadvise(2) MADV_POPULATE_{READ,WRITE} options | |
| - memfd_secret | |
| test memfd_secret(2) | |
| - process_mrelease | |
| test process_mrelease(2) | |
| - ksm | |
| ksm tests that do not require >=2 NUMA nodes | |
| - ksm_numa | |
| ksm tests that require >=2 NUMA nodes | |
| - pkey | |
| memory protection key tests | |
| - soft_dirty | |
| test soft dirty page bit semantics | |
| - pagemap | |
| test pagemap_scan IOCTL | |
| - pfnmap | |
| tests for VM_PFNMAP handling | |
| - process_madv | |
| test for process_madv | |
| - cow | |
| test copy-on-write semantics | |
| - thp | |
| test transparent huge pages | |
| - hugetlb | |
| test hugetlbfs huge pages | |
| - migration | |
| invoke move_pages(2) to exercise the migration entry code | |
| paths in the kernel | |
| - mkdirty | |
| test handling of code that might set PTE/PMD dirty in | |
| read-only VMAs | |
| - mdwe | |
| test prctl(PR_SET_MDWE, ...) | |
| - page_frag | |
| test handling of page fragment allocation and freeing | |
| - vma_merge | |
| test VMA merge cases behave as expected | |
| - rmap | |
| test rmap behaves as expected | |
| - memory-failure | |
| test memory-failure behaves as expected | |
| example: ./run_vmtests.sh -t "hmm mmap ksm" | |
| EOF | |
| exit 0 | |
| } | |
| RUN_ALL=false | |
| RUN_DESTRUCTIVE=false | |
| TAP_PREFIX="# " | |
| while getopts "aht:nd" OPT; do | |
| case ${OPT} in | |
| "a") RUN_ALL=true ;; | |
| "h") usage ;; | |
| "t") VM_SELFTEST_ITEMS=${OPTARG} ;; | |
| "n") TAP_PREFIX= ;; | |
| "d") RUN_DESTRUCTIVE=true ;; | |
| esac | |
| done | |
| shift $((OPTIND -1)) | |
| # default behavior: run all tests | |
| VM_SELFTEST_ITEMS=${VM_SELFTEST_ITEMS:-default} | |
| test_selected() { | |
| if [ "$VM_SELFTEST_ITEMS" == "default" ]; then | |
| # If no VM_SELFTEST_ITEMS are specified, run all tests | |
| return 0 | |
| fi | |
| # If test selected argument is one of the test items | |
| if [[ " ${VM_SELFTEST_ITEMS[*]} " =~ " ${1} " ]]; then | |
| return 0 | |
| else | |
| return 1 | |
| fi | |
| } | |
| run_gup_matrix() { | |
| # -t: thp=on, -T: thp=off, -H: hugetlb=on | |
| local hugetlb_mb=256 | |
| for huge in -t -T "-H -m $hugetlb_mb"; do | |
| # -u: gup-fast, -U: gup-basic, -a: pin-fast, -b: pin-basic, -L: pin-longterm | |
| for test_cmd in -u -U -a -b -L; do | |
| # -w: write=1, -W: write=0 | |
| for write in -w -W; do | |
| # -S: shared | |
| for share in -S " "; do | |
| # -n: How many pages to fetch together? 512 is special | |
| # because it's default thp size (or 2M on x86), 123 to | |
| # just test partial gup when hit a huge in whatever form | |
| for num in "-n 1" "-n 512" "-n 123" "-n -1"; do | |
| CATEGORY="gup_test" run_test ./gup_test \ | |
| $huge $test_cmd $write $share $num | |
| done | |
| done | |
| done | |
| done | |
| done | |
| } | |
| # filter 64bit architectures | |
| ARCH64STR="arm64 mips64 parisc64 ppc64 ppc64le riscv64 s390x sparc64 x86_64" | |
| if [ -z "$ARCH" ]; then | |
| ARCH=$(uname -m 2>/dev/null | sed -e 's/aarch64.*/arm64/') | |
| fi | |
| VADDR64=0 | |
| echo "$ARCH64STR" | grep "$ARCH" &>/dev/null && VADDR64=1 | |
| tap_prefix() { | |
| sed -e "s/^/${TAP_PREFIX}/" | |
| } | |
| tap_output() { | |
| if [[ ! -z "$TAP_PREFIX" ]]; then | |
| read str | |
| echo $str | |
| fi | |
| } | |
| pretty_name() { | |
| echo "$*" | sed -e 's/^\(bash \)\?\.\///' | |
| } | |
| # Usage: run_test [test binary] [arbitrary test arguments...] | |
| run_test() { | |
| if test_selected ${CATEGORY}; then | |
| local skip=0 | |
| local LOADED_HWPOISON_INJECT_MOD=0 | |
| # On memory constrainted systems some tests can fail to allocate hugepages. | |
| # perform some cleanup before the test for a higher success rate. | |
| if [ ${CATEGORY} == "thp" -o ${CATEGORY} == "hugetlb" ]; then | |
| mem_kb=$(awk '/MemAvailable/ {print $2}' /proc/meminfo) | |
| mem_Mb=$((mem_kb / 1024)) | |
| if (( $mem_Mb < 256 )); then | |
| echo 3 > /proc/sys/vm/drop_caches | |
| sleep 2 | |
| echo 1 > /proc/sys/vm/compact_memory | |
| sleep 2 | |
| fi | |
| fi | |
| # Ensure hwpoison_inject is available for memory-failure tests | |
| if [ "${CATEGORY}" = "memory-failure" ]; then | |
| # Try to load hwpoison_inject if not present. | |
| HWPOISON_DIR=/sys/kernel/debug/hwpoison/ | |
| if [ ! -d "$HWPOISON_DIR" ]; then | |
| if ! modprobe -n hwpoison_inject > /dev/null 2>&1; then | |
| echo "Module hwpoison_inject not found, skipping..." \ | |
| | tap_prefix | |
| skip=1 | |
| else | |
| modprobe hwpoison_inject > /dev/null 2>&1 | |
| LOADED_HWPOISON_INJECT_MOD=1 | |
| if [ ! -d "$HWPOISON_DIR" ]; then | |
| echo "hwpoison debugfs interface not present" \ | |
| | tap_prefix | |
| skip=1 | |
| fi | |
| fi | |
| fi | |
| fi | |
| local test=$(pretty_name "$*") | |
| local title="running $*" | |
| local sep=$(echo -n "$title" | tr "[:graph:][:space:]" -) | |
| printf "%s\n%s\n%s\n" "$sep" "$title" "$sep" | tap_prefix | |
| if [ $skip -eq 1 ]; then | |
| local ret=$ksft_skip | |
| else | |
| ("$@" 2>&1) | tap_prefix | |
| local ret=${PIPESTATUS[0]} | |
| fi | |
| # Unload hwpoison_inject if we loaded it | |
| if [ "${LOADED_HWPOISON_INJECT_MOD}" = "1" ]; then | |
| modprobe -r hwpoison_inject > /dev/null 2>&1 | |
| fi | |
| count_total=$(( count_total + 1 )) | |
| if [ $ret -eq 0 ]; then | |
| count_pass=$(( count_pass + 1 )) | |
| echo "[PASS]" | tap_prefix | |
| echo "ok ${count_total} ${test}" | tap_output | |
| elif [ $ret -eq $ksft_skip ]; then | |
| count_skip=$(( count_skip + 1 )) | |
| echo "[SKIP]" | tap_prefix | |
| echo "ok ${count_total} ${test} # SKIP" | tap_output | |
| if [ $exitcode -eq 0 ]; then | |
| exitcode=$ksft_skip | |
| fi | |
| else | |
| count_fail=$(( count_fail + 1 )) | |
| echo "[FAIL]" | tap_prefix | |
| echo "not ok ${count_total} ${test} # exit=$ret" | tap_output | |
| exitcode=1 | |
| fi | |
| fi # test_selected | |
| } | |
| echo "TAP version 13" | tap_output | |
| CATEGORY="hugetlb" run_test ./hugetlb-mmap | |
| CATEGORY="hugetlb" run_test ./hugetlb-shm | |
| CATEGORY="hugetlb" run_test ./hugetlb-mremap | |
| CATEGORY="hugetlb" run_test ./hugetlb-madvise | |
| CATEGORY="hugetlb" run_test ./hugetlb_dio | |
| CATEGORY="hugetlb" run_test ./hugetlb_fault_after_madv | |
| CATEGORY="hugetlb" run_test ./hugetlb_madv_vs_map | |
| if test_selected "hugetlb"; then | |
| echo "NOTE: These hugetlb tests provide minimal coverage. Use" | tap_prefix | |
| echo " https://github.com/libhugetlbfs/libhugetlbfs.git for" | tap_prefix | |
| echo " hugetlb regression testing." | tap_prefix | |
| fi | |
| CATEGORY="mmap" run_test ./map_fixed_noreplace | |
| if $RUN_ALL; then | |
| run_gup_matrix | |
| else | |
| # get_user_pages_fast() benchmark | |
| CATEGORY="gup_test" run_test ./gup_test -u -n 1 | |
| CATEGORY="gup_test" run_test ./gup_test -u -n -1 | |
| # pin_user_pages_fast() benchmark | |
| CATEGORY="gup_test" run_test ./gup_test -a -n 1 | |
| CATEGORY="gup_test" run_test ./gup_test -a -n -1 | |
| fi | |
| # Dump pages 0, 19, and 4096, using pin_user_pages: | |
| CATEGORY="gup_test" run_test ./gup_test -ct -F 0x1 0 19 0x1000 | |
| CATEGORY="gup_test" run_test ./gup_longterm | |
| CATEGORY="userfaultfd" run_test ./uffd-unit-tests | |
| uffd_stress_bin=./uffd-stress | |
| CATEGORY="userfaultfd" run_test ${uffd_stress_bin} anon 20 16 | |
| CATEGORY="userfaultfd" run_test ${uffd_stress_bin} hugetlb 128 32 | |
| CATEGORY="userfaultfd" run_test ${uffd_stress_bin} hugetlb-private 128 32 | |
| CATEGORY="userfaultfd" run_test ${uffd_stress_bin} shmem 20 16 | |
| CATEGORY="userfaultfd" run_test ${uffd_stress_bin} shmem-private 20 16 | |
| CATEGORY="userfaultfd" run_test ./uffd-wp-mremap | |
| CATEGORY="compaction" run_test ./compaction_test | |
| if command -v sudo &> /dev/null && sudo -u nobody ls ./on-fault-limit >/dev/null; | |
| then | |
| CATEGORY="mlock" run_test sudo -u nobody sh -c ./on-fault-limit | |
| else | |
| echo "# SKIP ./on-fault-limit" | |
| fi | |
| CATEGORY="mmap" run_test ./map_populate | |
| CATEGORY="mmap" run_test ./droppable | |
| CATEGORY="mlock" run_test ./mlock-random-test | |
| CATEGORY="mlock" run_test ./mlock2-tests | |
| CATEGORY="process_mrelease" run_test ./mrelease_test | |
| CATEGORY="mremap" run_test ./mremap_test | |
| CATEGORY="hugetlb" run_test ./thuge-gen | |
| CATEGORY="hugetlb" run_test ./charge_reserved_hugetlb.sh -cgroup-v2 | |
| CATEGORY="hugetlb" run_test ./hugetlb_reparenting_test.sh -cgroup-v2 | |
| if $RUN_DESTRUCTIVE; then | |
| enable_soft_offline=$(cat /proc/sys/vm/enable_soft_offline) | |
| CATEGORY="hugetlb" run_test ./hugetlb-soft-offline | |
| echo "$enable_soft_offline" > /proc/sys/vm/enable_soft_offline | |
| CATEGORY="hugetlb" run_test ./hugetlb-read-hwpoison | |
| fi | |
| if [ $VADDR64 -ne 0 ]; then | |
| # va high address boundary switch test | |
| CATEGORY="hugevm" run_test bash ./va_high_addr_switch.sh | |
| fi # VADDR64 | |
| # vmalloc stability smoke test | |
| CATEGORY="vmalloc" run_test bash ./test_vmalloc.sh smoke | |
| CATEGORY="mremap" run_test ./mremap_dontunmap | |
| CATEGORY="hmm" run_test bash ./test_hmm.sh smoke | |
| # MADV_GUARD_INSTALL and MADV_GUARD_REMOVE tests | |
| CATEGORY="madv_guard" run_test ./guard-regions | |
| # MADV_POPULATE_READ and MADV_POPULATE_WRITE tests | |
| CATEGORY="madv_populate" run_test ./madv_populate | |
| # PROCESS_MADV test | |
| CATEGORY="process_madv" run_test ./process_madv | |
| CATEGORY="vma_merge" run_test ./merge | |
| if [ -x ./memfd_secret ] | |
| then | |
| if [ -f /proc/sys/kernel/yama/ptrace_scope ]; then | |
| (echo 0 > /proc/sys/kernel/yama/ptrace_scope 2>&1) | tap_prefix | |
| fi | |
| CATEGORY="memfd_secret" run_test ./memfd_secret | |
| fi | |
| # KSM KSM_MERGE_TIME_HUGE_PAGES test with size of 100 | |
| CATEGORY="ksm" run_test ./ksm_tests -H -s 100 | |
| # KSM KSM_MERGE_TIME test with size of 100 | |
| CATEGORY="ksm" run_test ./ksm_tests -P -s 100 | |
| # KSM MADV_MERGEABLE test with 10 identical pages | |
| CATEGORY="ksm" run_test ./ksm_tests -M -p 10 | |
| # KSM unmerge test | |
| CATEGORY="ksm" run_test ./ksm_tests -U | |
| # KSM test with 10 zero pages and use_zero_pages = 0 | |
| CATEGORY="ksm" run_test ./ksm_tests -Z -p 10 -z 0 | |
| # KSM test with 10 zero pages and use_zero_pages = 1 | |
| CATEGORY="ksm" run_test ./ksm_tests -Z -p 10 -z 1 | |
| # KSM test with 2 NUMA nodes and merge_across_nodes = 1 | |
| CATEGORY="ksm_numa" run_test ./ksm_tests -N -m 1 | |
| # KSM test with 2 NUMA nodes and merge_across_nodes = 0 | |
| CATEGORY="ksm_numa" run_test ./ksm_tests -N -m 0 | |
| CATEGORY="ksm" run_test ./ksm_functional_tests | |
| # protection_keys tests | |
| if [ -x ./protection_keys_32 ] | |
| then | |
| CATEGORY="pkey" run_test ./protection_keys_32 | |
| fi | |
| if [ -x ./protection_keys_64 ] | |
| then | |
| CATEGORY="pkey" run_test ./protection_keys_64 | |
| fi | |
| if [ -x ./soft-dirty ] | |
| then | |
| CATEGORY="soft_dirty" run_test ./soft-dirty | |
| fi | |
| CATEGORY="pagemap" run_test ./pagemap_ioctl | |
| CATEGORY="pfnmap" run_test ./pfnmap | |
| # COW tests | |
| CATEGORY="cow" run_test ./cow | |
| CATEGORY="thp" run_test ./khugepaged | |
| CATEGORY="thp" run_test ./khugepaged -s 2 | |
| CATEGORY="thp" run_test ./khugepaged all:shmem | |
| CATEGORY="thp" run_test ./khugepaged -s 4 all:shmem | |
| CATEGORY="thp" run_test ./khugepaged -c 4 mthp_khugepaged:anon | |
| # Try to create XFS if not provided | |
| if [ -z "${SPLIT_HUGE_PAGE_TEST_XFS_PATH}" ]; then | |
| if test_selected "thp"; then | |
| if grep xfs /proc/filesystems &>/dev/null; then | |
| XFS_IMG=$(mktemp /tmp/xfs_img_XXXXXX) | |
| SPLIT_HUGE_PAGE_TEST_XFS_PATH=$(mktemp -d /tmp/xfs_dir_XXXXXX) | |
| truncate -s 314572800 ${XFS_IMG} | |
| mkfs.xfs -q ${XFS_IMG} | |
| mount -o loop ${XFS_IMG} ${SPLIT_HUGE_PAGE_TEST_XFS_PATH} | |
| MOUNTED_XFS=1 | |
| fi | |
| fi | |
| fi | |
| if [ -n "${SPLIT_HUGE_PAGE_TEST_XFS_PATH}" ]; then | |
| CATEGORY="thp" run_test ./khugepaged all:file ${SPLIT_HUGE_PAGE_TEST_XFS_PATH} | |
| elif test_selected thp; then | |
| count_total=$(( count_total + 1 )) | |
| count_skip=$(( count_skip + 1 )) | |
| echo "[SKIP] ./khugepaged all:file" | tap_prefix | |
| fi | |
| CATEGORY="thp" run_test ./split_huge_page_test ${SPLIT_HUGE_PAGE_TEST_XFS_PATH} | |
| if [ -n "${MOUNTED_XFS}" ]; then | |
| umount ${SPLIT_HUGE_PAGE_TEST_XFS_PATH} | |
| rmdir ${SPLIT_HUGE_PAGE_TEST_XFS_PATH} | |
| rm -f ${XFS_IMG} | |
| fi | |
| CATEGORY="thp" run_test ./transhuge-stress -d 20 | |
| CATEGORY="thp" run_test ./folio_split_race_test | |
| CATEGORY="migration" run_test ./migration | |
| CATEGORY="mkdirty" run_test ./mkdirty | |
| CATEGORY="mdwe" run_test ./mdwe_test | |
| CATEGORY="page_frag" run_test ./test_page_frag.sh smoke | |
| CATEGORY="page_frag" run_test ./test_page_frag.sh aligned | |
| CATEGORY="page_frag" run_test ./test_page_frag.sh nonaligned | |
| CATEGORY="rmap" run_test ./rmap | |
| CATEGORY="memory-failure" run_test ./memory-failure | |
| echo "SUMMARY: PASS=${count_pass} SKIP=${count_skip} FAIL=${count_fail}" | tap_prefix | |
| echo "1..${count_total}" | tap_output | |
| exit $exitcode |