201 lines
4.9 KiB
Bash
Executable File
201 lines
4.9 KiB
Bash
Executable File
#!/bin/bash
|
|
# SPDX-License-Identifier: GPL-2.0
|
|
#please run as root
|
|
|
|
# Kselftest framework requirement - SKIP code is 4.
|
|
ksft_skip=4
|
|
|
|
mnt=./huge
|
|
exitcode=0
|
|
|
|
#get huge pagesize and freepages from /proc/meminfo
|
|
while read -r name size unit; do
|
|
if [ "$name" = "HugePages_Free:" ]; then
|
|
freepgs="$size"
|
|
fi
|
|
if [ "$name" = "Hugepagesize:" ]; then
|
|
hpgsize_KB="$size"
|
|
fi
|
|
done < /proc/meminfo
|
|
|
|
# Simple hugetlbfs tests have a hardcoded minimum requirement of
|
|
# huge pages totaling 256MB (262144KB) in size. The userfaultfd
|
|
# hugetlb test requires a minimum of 2 * nr_cpus huge pages. Take
|
|
# both of these requirements into account and attempt to increase
|
|
# number of huge pages available.
|
|
nr_cpus=$(nproc)
|
|
hpgsize_MB=$((hpgsize_KB / 1024))
|
|
half_ufd_size_MB=$((((nr_cpus * hpgsize_MB + 127) / 128) * 128))
|
|
needmem_KB=$((half_ufd_size_MB * 2 * 1024))
|
|
|
|
#set proper nr_hugepages
|
|
if [ -n "$freepgs" ] && [ -n "$hpgsize_KB" ]; then
|
|
nr_hugepgs=$(cat /proc/sys/vm/nr_hugepages)
|
|
needpgs=$((needmem_KB / hpgsize_KB))
|
|
tries=2
|
|
while [ "$tries" -gt 0 ] && [ "$freepgs" -lt "$needpgs" ]; do
|
|
lackpgs=$((needpgs - freepgs))
|
|
echo 3 > /proc/sys/vm/drop_caches
|
|
if ! echo $((lackpgs + nr_hugepgs)) > /proc/sys/vm/nr_hugepages; then
|
|
echo "Please run this test as root"
|
|
exit $ksft_skip
|
|
fi
|
|
while read -r name size unit; do
|
|
if [ "$name" = "HugePages_Free:" ]; then
|
|
freepgs=$size
|
|
fi
|
|
done < /proc/meminfo
|
|
tries=$((tries - 1))
|
|
done
|
|
if [ "$freepgs" -lt "$needpgs" ]; then
|
|
printf "Not enough huge pages available (%d < %d)\n" \
|
|
"$freepgs" "$needpgs"
|
|
exit 1
|
|
fi
|
|
else
|
|
echo "no hugetlbfs support in kernel?"
|
|
exit 1
|
|
fi
|
|
|
|
#filter 64bit architectures
|
|
ARCH64STR="arm64 ia64 mips64 parisc64 ppc64 ppc64le riscv64 s390x sh64 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" && VADDR64=1
|
|
|
|
# Usage: run_test [test binary] [arbitrary test arguments...]
|
|
run_test() {
|
|
local title="running $*"
|
|
local sep=$(echo -n "$title" | tr "[:graph:][:space:]" -)
|
|
printf "%s\n%s\n%s\n" "$sep" "$title" "$sep"
|
|
|
|
"$@"
|
|
local ret=$?
|
|
if [ $ret -eq 0 ]; then
|
|
echo "[PASS]"
|
|
elif [ $ret -eq $ksft_skip ]; then
|
|
echo "[SKIP]"
|
|
exitcode=$ksft_skip
|
|
else
|
|
echo "[FAIL]"
|
|
exitcode=1
|
|
fi
|
|
}
|
|
|
|
mkdir "$mnt"
|
|
mount -t hugetlbfs none "$mnt"
|
|
|
|
run_test ./hugepage-mmap
|
|
|
|
shmmax=$(cat /proc/sys/kernel/shmmax)
|
|
shmall=$(cat /proc/sys/kernel/shmall)
|
|
echo 268435456 > /proc/sys/kernel/shmmax
|
|
echo 4194304 > /proc/sys/kernel/shmall
|
|
run_test ./hugepage-shm
|
|
echo "$shmmax" > /proc/sys/kernel/shmmax
|
|
echo "$shmall" > /proc/sys/kernel/shmall
|
|
|
|
run_test ./map_hugetlb
|
|
|
|
run_test ./hugepage-mremap "$mnt"/huge_mremap
|
|
rm -f "$mnt"/huge_mremap
|
|
|
|
run_test ./hugepage-vmemmap
|
|
|
|
run_test ./hugetlb-madvise "$mnt"/madvise-test
|
|
rm -f "$mnt"/madvise-test
|
|
|
|
echo "NOTE: The above hugetlb tests provide minimal coverage. Use"
|
|
echo " https://github.com/libhugetlbfs/libhugetlbfs.git for"
|
|
echo " hugetlb regression testing."
|
|
|
|
run_test ./map_fixed_noreplace
|
|
|
|
# get_user_pages_fast() benchmark
|
|
run_test ./gup_test -u
|
|
# pin_user_pages_fast() benchmark
|
|
run_test ./gup_test -a
|
|
# Dump pages 0, 19, and 4096, using pin_user_pages:
|
|
run_test ./gup_test -ct -F 0x1 0 19 0x1000
|
|
|
|
uffd_mods=("" ":dev")
|
|
for mod in "${uffd_mods[@]}"; do
|
|
run_test ./userfaultfd anon${mod} 20 16
|
|
# Hugetlb tests require source and destination huge pages. Pass in half
|
|
# the size ($half_ufd_size_MB), which is used for *each*.
|
|
run_test ./userfaultfd hugetlb${mod} "$half_ufd_size_MB" 32
|
|
run_test ./userfaultfd hugetlb_shared${mod} "$half_ufd_size_MB" 32 "$mnt"/uffd-test
|
|
rm -f "$mnt"/uffd-test
|
|
run_test ./userfaultfd shmem${mod} 20 16
|
|
done
|
|
|
|
#cleanup
|
|
umount "$mnt"
|
|
rm -rf "$mnt"
|
|
echo "$nr_hugepgs" > /proc/sys/vm/nr_hugepages
|
|
|
|
run_test ./compaction_test
|
|
|
|
run_test sudo -u nobody ./on-fault-limit
|
|
|
|
run_test ./map_populate
|
|
|
|
run_test ./mlock-random-test
|
|
|
|
run_test ./mlock2-tests
|
|
|
|
run_test ./mrelease_test
|
|
|
|
run_test ./mremap_test
|
|
|
|
run_test ./thuge-gen
|
|
|
|
if [ $VADDR64 -ne 0 ]; then
|
|
run_test ./virtual_address_range
|
|
|
|
# virtual address 128TB switch test
|
|
run_test ./va_128TBswitch.sh
|
|
fi # VADDR64
|
|
|
|
# vmalloc stability smoke test
|
|
run_test ./test_vmalloc.sh smoke
|
|
|
|
run_test ./mremap_dontunmap
|
|
|
|
run_test ./test_hmm.sh smoke
|
|
|
|
# MADV_POPULATE_READ and MADV_POPULATE_WRITE tests
|
|
run_test ./madv_populate
|
|
|
|
run_test ./memfd_secret
|
|
|
|
# KSM MADV_MERGEABLE test with 10 identical pages
|
|
run_test ./ksm_tests -M -p 10
|
|
# KSM unmerge test
|
|
run_test ./ksm_tests -U
|
|
# KSM test with 10 zero pages and use_zero_pages = 0
|
|
run_test ./ksm_tests -Z -p 10 -z 0
|
|
# KSM test with 10 zero pages and use_zero_pages = 1
|
|
run_test ./ksm_tests -Z -p 10 -z 1
|
|
# KSM test with 2 NUMA nodes and merge_across_nodes = 1
|
|
run_test ./ksm_tests -N -m 1
|
|
# KSM test with 2 NUMA nodes and merge_across_nodes = 0
|
|
run_test ./ksm_tests -N -m 0
|
|
|
|
# protection_keys tests
|
|
if [ -x ./protection_keys_32 ]
|
|
then
|
|
run_test ./protection_keys_32
|
|
fi
|
|
|
|
if [ -x ./protection_keys_64 ]
|
|
then
|
|
run_test ./protection_keys_64
|
|
fi
|
|
|
|
run_test ./soft-dirty
|
|
|
|
exit $exitcode
|