selftests/vm/hugetlb_reparenting_test.sh

0001 #!/bin/bash
0002 # SPDX-License-Identifier: GPL-2.0
0003
0004 # Kselftest framework requirement - SKIP code is 4.
0005 ksft_skip=4
0006
0007 set -e
0008
0009 if [[ $(id -u) -ne 0 ]]; then
0010   echo "This test must be run as root. Skipping..."
0011   exit $ksft_skip
0012 fi
0013
0014 usage_file=usage_in_bytes
0015
0016 if [[ "$1" == "-cgroup-v2" ]]; then
0017   cgroup2=1
0018   usage_file=current
0019 fi
0020
0021
0022 if [[ $cgroup2 ]]; then
0023   CGROUP_ROOT=$(mount -t cgroup2 | head -1 | awk -e '{print $3}')
0024   if [[ -z "$CGROUP_ROOT" ]]; then
0025     CGROUP_ROOT=/dev/cgroup/memory
0026     mount -t cgroup2 none $CGROUP_ROOT
0027     do_umount=1
0028   fi
0029   echo "+hugetlb +memory" >$CGROUP_ROOT/cgroup.subtree_control
0030 else
0031   CGROUP_ROOT=$(mount -t cgroup | grep ",hugetlb" | awk -e '{print $3}')
0032   if [[ -z "$CGROUP_ROOT" ]]; then
0033     CGROUP_ROOT=/dev/cgroup/memory
0034     mount -t cgroup memory,hugetlb $CGROUP_ROOT
0035     do_umount=1
0036   fi
0037 fi
0038 MNT='/mnt/huge/'
0039
0040 function get_machine_hugepage_size() {
0041   hpz=$(grep -i hugepagesize /proc/meminfo)
0042   kb=${hpz:14:-3}
0043   mb=$(($kb / 1024))
0044   echo $mb
0045 }
0046
0047 MB=$(get_machine_hugepage_size)
0048
0049 function cleanup() {
0050   echo cleanup
0051   set +e
0052   rm -rf "$MNT"/* 2>/dev/null
0053   umount "$MNT" 2>/dev/null
0054   rmdir "$MNT" 2>/dev/null
0055   rmdir "$CGROUP_ROOT"/a/b 2>/dev/null
0056   rmdir "$CGROUP_ROOT"/a 2>/dev/null
0057   rmdir "$CGROUP_ROOT"/test1 2>/dev/null
0058   echo 0 >/proc/sys/vm/nr_hugepages
0059   set -e
0060 }
0061
0062 function assert_state() {
0063   local expected_a="$1"
0064   local expected_a_hugetlb="$2"
0065   local expected_b=""
0066   local expected_b_hugetlb=""
0067
0068   if [ ! -z ${3:-} ] && [ ! -z ${4:-} ]; then
0069     expected_b="$3"
0070     expected_b_hugetlb="$4"
0071   fi
0072   local tolerance=$((5 * 1024 * 1024))
0073
0074   local actual_a
0075   actual_a="$(cat "$CGROUP_ROOT"/a/memory.$usage_file)"
0076   if [[ $actual_a -lt $(($expected_a - $tolerance)) ]] ||
0077     [[ $actual_a -gt $(($expected_a + $tolerance)) ]]; then
0078     echo actual a = $((${actual_a%% *} / 1024 / 1024)) MB
0079     echo expected a = $((${expected_a%% *} / 1024 / 1024)) MB
0080     echo fail
0081
0082     cleanup
0083     exit 1
0084   fi
0085
0086   local actual_a_hugetlb
0087   actual_a_hugetlb="$(cat "$CGROUP_ROOT"/a/hugetlb.${MB}MB.$usage_file)"
0088   if [[ $actual_a_hugetlb -lt $(($expected_a_hugetlb - $tolerance)) ]] ||
0089     [[ $actual_a_hugetlb -gt $(($expected_a_hugetlb + $tolerance)) ]]; then
0090     echo actual a hugetlb = $((${actual_a_hugetlb%% *} / 1024 / 1024)) MB
0091     echo expected a hugetlb = $((${expected_a_hugetlb%% *} / 1024 / 1024)) MB
0092     echo fail
0093
0094     cleanup
0095     exit 1
0096   fi
0097
0098   if [[ -z "$expected_b" || -z "$expected_b_hugetlb" ]]; then
0099     return
0100   fi
0101
0102   local actual_b
0103   actual_b="$(cat "$CGROUP_ROOT"/a/b/memory.$usage_file)"
0104   if [[ $actual_b -lt $(($expected_b - $tolerance)) ]] ||
0105     [[ $actual_b -gt $(($expected_b + $tolerance)) ]]; then
0106     echo actual b = $((${actual_b%% *} / 1024 / 1024)) MB
0107     echo expected b = $((${expected_b%% *} / 1024 / 1024)) MB
0108     echo fail
0109
0110     cleanup
0111     exit 1
0112   fi
0113
0114   local actual_b_hugetlb
0115   actual_b_hugetlb="$(cat "$CGROUP_ROOT"/a/b/hugetlb.${MB}MB.$usage_file)"
0116   if [[ $actual_b_hugetlb -lt $(($expected_b_hugetlb - $tolerance)) ]] ||
0117     [[ $actual_b_hugetlb -gt $(($expected_b_hugetlb + $tolerance)) ]]; then
0118     echo actual b hugetlb = $((${actual_b_hugetlb%% *} / 1024 / 1024)) MB
0119     echo expected b hugetlb = $((${expected_b_hugetlb%% *} / 1024 / 1024)) MB
0120     echo fail
0121
0122     cleanup
0123     exit 1
0124   fi
0125 }
0126
0127 function setup() {
0128   echo 100 >/proc/sys/vm/nr_hugepages
0129   mkdir "$CGROUP_ROOT"/a
0130   sleep 1
0131   if [[ $cgroup2 ]]; then
0132     echo "+hugetlb +memory" >$CGROUP_ROOT/a/cgroup.subtree_control
0133   else
0134     echo 0 >$CGROUP_ROOT/a/cpuset.mems
0135     echo 0 >$CGROUP_ROOT/a/cpuset.cpus
0136   fi
0137
0138   mkdir "$CGROUP_ROOT"/a/b
0139
0140   if [[ ! $cgroup2 ]]; then
0141     echo 0 >$CGROUP_ROOT/a/b/cpuset.mems
0142     echo 0 >$CGROUP_ROOT/a/b/cpuset.cpus
0143   fi
0144
0145   mkdir -p "$MNT"
0146   mount -t hugetlbfs none "$MNT"
0147 }
0148
0149 write_hugetlbfs() {
0150   local cgroup="$1"
0151   local path="$2"
0152   local size="$3"
0153
0154   if [[ $cgroup2 ]]; then
0155     echo $$ >$CGROUP_ROOT/$cgroup/cgroup.procs
0156   else
0157     echo 0 >$CGROUP_ROOT/$cgroup/cpuset.mems
0158     echo 0 >$CGROUP_ROOT/$cgroup/cpuset.cpus
0159     echo $$ >"$CGROUP_ROOT/$cgroup/tasks"
0160   fi
0161   ./write_to_hugetlbfs -p "$path" -s "$size" -m 0 -o
0162   if [[ $cgroup2 ]]; then
0163     echo $$ >$CGROUP_ROOT/cgroup.procs
0164   else
0165     echo $$ >"$CGROUP_ROOT/tasks"
0166   fi
0167   echo
0168 }
0169
0170 set -e
0171
0172 size=$((${MB} * 1024 * 1024 * 25)) # 50MB = 25 * 2MB hugepages.
0173
0174 cleanup
0175
0176 echo
0177 echo
0178 echo Test charge, rmdir, uncharge
0179 setup
0180 echo mkdir
0181 mkdir $CGROUP_ROOT/test1
0182
0183 echo write
0184 write_hugetlbfs test1 "$MNT"/test $size
0185
0186 echo rmdir
0187 rmdir $CGROUP_ROOT/test1
0188 mkdir $CGROUP_ROOT/test1
0189
0190 echo uncharge
0191 rm -rf /mnt/huge/*
0192
0193 cleanup
0194
0195 echo done
0196 echo
0197 echo
0198 if [[ ! $cgroup2 ]]; then
0199   echo "Test parent and child hugetlb usage"
0200   setup
0201
0202   echo write
0203   write_hugetlbfs a "$MNT"/test $size
0204
0205   echo Assert memory charged correctly for parent use.
0206   assert_state 0 $size 0 0
0207
0208   write_hugetlbfs a/b "$MNT"/test2 $size
0209
0210   echo Assert memory charged correctly for child use.
0211   assert_state 0 $(($size * 2)) 0 $size
0212
0213   rmdir "$CGROUP_ROOT"/a/b
0214   sleep 5
0215   echo Assert memory reparent correctly.
0216   assert_state 0 $(($size * 2))
0217
0218   rm -rf "$MNT"/*
0219   umount "$MNT"
0220   echo Assert memory uncharged correctly.
0221   assert_state 0 0
0222
0223   cleanup
0224 fi
0225
0226 echo
0227 echo
0228 echo "Test child only hugetlb usage"
0229 echo setup
0230 setup
0231
0232 echo write
0233 write_hugetlbfs a/b "$MNT"/test2 $size
0234
0235 echo Assert memory charged correctly for child only use.
0236 assert_state 0 $(($size)) 0 $size
0237
0238 rmdir "$CGROUP_ROOT"/a/b
0239 echo Assert memory reparent correctly.
0240 assert_state 0 $size
0241
0242 rm -rf "$MNT"/*
0243 umount "$MNT"
0244 echo Assert memory uncharged correctly.
0245 assert_state 0 0
0246
0247 cleanup
0248
0249 echo ALL PASS
0250
0251 umount $CGROUP_ROOT
0252 rm -rf $CGROUP_ROOT