| #!/bin/bash |
| # SPDX-License-Identifier: GPL-2.0 |
| # |
| # Test for cpuset v2 partition root state (PRS) |
| # |
| # The sched verbose flag can be optionally set so that the console log |
| # can be examined for the correct setting of scheduling domain. |
| # |
| |
| skip_test() { |
| echo "$1" |
| echo "Test SKIPPED" |
| exit 4 # ksft_skip |
| } |
| |
| [[ $(id -u) -eq 0 ]] || skip_test "Test must be run as root!" |
| |
| |
| # Get wait_inotify location |
| WAIT_INOTIFY=$(cd $(dirname $0); pwd)/wait_inotify |
| |
| # Find cgroup v2 mount point |
| CGROUP2=$(mount -t cgroup2 | head -1 | awk -e '{print $3}') |
| [[ -n "$CGROUP2" ]] || skip_test "Cgroup v2 mount point not found!" |
| SUBPARTS_CPUS=$CGROUP2/.__DEBUG__.cpuset.cpus.subpartitions |
| CPULIST=$(cat $CGROUP2/cpuset.cpus.effective) |
| |
| NR_CPUS=$(lscpu | grep "^CPU(s):" | sed -e "s/.*:[[:space:]]*//") |
| [[ $NR_CPUS -lt 8 ]] && skip_test "Test needs at least 8 cpus available!" |
| |
| # Check to see if /dev/console exists and is writable |
| if [[ -c /dev/console && -w /dev/console ]] |
| then |
| CONSOLE=/dev/console |
| else |
| CONSOLE=/dev/null |
| fi |
| |
| # Set verbose flag and delay factor |
| PROG=$1 |
| VERBOSE=0 |
| DELAY_FACTOR=1 |
| SCHED_DEBUG= |
| while [[ "$1" = -* ]] |
| do |
| case "$1" in |
| -v) ((VERBOSE++)) |
| # Enable sched/verbose can slow thing down |
| [[ $DELAY_FACTOR -eq 1 ]] && |
| DELAY_FACTOR=2 |
| ;; |
| -d) DELAY_FACTOR=$2 |
| shift |
| ;; |
| *) echo "Usage: $PROG [-v] [-d <delay-factor>" |
| exit |
| ;; |
| esac |
| shift |
| done |
| |
| # Set sched verbose flag if available when "-v" option is specified |
| if [[ $VERBOSE -gt 0 && -d /sys/kernel/debug/sched ]] |
| then |
| # Used to restore the original setting during cleanup |
| SCHED_DEBUG=$(cat /sys/kernel/debug/sched/verbose) |
| echo Y > /sys/kernel/debug/sched/verbose |
| fi |
| |
| cd $CGROUP2 |
| echo +cpuset > cgroup.subtree_control |
| |
| # |
| # If cpuset has been set up and used in child cgroups, we may not be able to |
| # create partition under root cgroup because of the CPU exclusivity rule. |
| # So we are going to skip the test if this is the case. |
| # |
| [[ -d test ]] || mkdir test |
| echo 0-6 > test/cpuset.cpus |
| echo root > test/cpuset.cpus.partition |
| cat test/cpuset.cpus.partition | grep -q invalid |
| RESULT=$? |
| echo member > test/cpuset.cpus.partition |
| echo "" > test/cpuset.cpus |
| [[ $RESULT -eq 0 ]] && skip_test "Child cgroups are using cpuset!" |
| |
| # |
| # If isolated CPUs have been reserved at boot time (as shown in |
| # cpuset.cpus.isolated), these isolated CPUs should be outside of CPUs 0-7 |
| # that will be used by this script for testing purpose. If not, some of |
| # the tests may fail incorrectly. These isolated CPUs will also be removed |
| # before being compared with the expected results. |
| # |
| BOOT_ISOLCPUS=$(cat $CGROUP2/cpuset.cpus.isolated) |
| if [[ -n "$BOOT_ISOLCPUS" ]] |
| then |
| [[ $(echo $BOOT_ISOLCPUS | sed -e "s/[,-].*//") -le 7 ]] && |
| skip_test "Pre-isolated CPUs ($BOOT_ISOLCPUS) overlap CPUs to be tested" |
| echo "Pre-isolated CPUs: $BOOT_ISOLCPUS" |
| fi |
| cleanup() |
| { |
| online_cpus |
| cd $CGROUP2 |
| rmdir A1/A2/A3 A1/A2 A1 B1 > /dev/null 2>&1 |
| rmdir test > /dev/null 2>&1 |
| [[ -n "$SCHED_DEBUG" ]] && |
| echo "$SCHED_DEBUG" > /sys/kernel/debug/sched/verbose |
| } |
| |
| # Pause in ms |
| pause() |
| { |
| DELAY=$1 |
| LOOP=0 |
| while [[ $LOOP -lt $DELAY_FACTOR ]] |
| do |
| sleep $DELAY |
| ((LOOP++)) |
| done |
| return 0 |
| } |
| |
| console_msg() |
| { |
| MSG=$1 |
| echo "$MSG" |
| echo "" > $CONSOLE |
| echo "$MSG" > $CONSOLE |
| pause 0.01 |
| } |
| |
| test_partition() |
| { |
| EXPECTED_VAL=$1 |
| echo $EXPECTED_VAL > cpuset.cpus.partition |
| [[ $? -eq 0 ]] || exit 1 |
| ACTUAL_VAL=$(cat cpuset.cpus.partition) |
| [[ $ACTUAL_VAL != $EXPECTED_VAL ]] && { |
| echo "cpuset.cpus.partition: expect $EXPECTED_VAL, found $ACTUAL_VAL" |
| echo "Test FAILED" |
| exit 1 |
| } |
| } |
| |
| test_effective_cpus() |
| { |
| EXPECTED_VAL=$1 |
| ACTUAL_VAL=$(cat cpuset.cpus.effective) |
| [[ "$ACTUAL_VAL" != "$EXPECTED_VAL" ]] && { |
| echo "cpuset.cpus.effective: expect '$EXPECTED_VAL', found '$ACTUAL_VAL'" |
| echo "Test FAILED" |
| exit 1 |
| } |
| } |
| |
| # Adding current process to cgroup.procs as a test |
| test_add_proc() |
| { |
| OUTSTR="$1" |
| ERRMSG=$((echo $$ > cgroup.procs) |& cat) |
| echo $ERRMSG | grep -q "$OUTSTR" |
| [[ $? -ne 0 ]] && { |
| echo "cgroup.procs: expect '$OUTSTR', got '$ERRMSG'" |
| echo "Test FAILED" |
| exit 1 |
| } |
| echo $$ > $CGROUP2/cgroup.procs # Move out the task |
| } |
| |
| # |
| # Cpuset controller state transition test matrix. |
| # |
| # Cgroup test hierarchy |
| # |
| # root -- A1 -- A2 -- A3 |
| # +- B1 |
| # |
| # P<v> = set cpus.partition (0:member, 1:root, 2:isolated) |
| # C<l> = add cpu-list to cpuset.cpus |
| # X<l> = add cpu-list to cpuset.cpus.exclusive |
| # S<p> = use prefix in subtree_control |
| # T = put a task into cgroup |
| # O<c>=<v> = Write <v> to CPU online file of <c> |
| # |
| # ECPUs - effective CPUs of cpusets |
| # Pstate - partition root state |
| # ISOLCPUS - isolated CPUs (<icpus>[,<icpus2>]) |
| # |
| # Note that if there are 2 fields in ISOLCPUS, the first one is for |
| # sched-debug matching which includes offline CPUs and single-CPU partitions |
| # while the second one is for matching cpuset.cpus.isolated. |
| # |
| SETUP_A123_PARTITIONS="C1-3:P1:S+ C2-3:P1:S+ C3:P1" |
| TEST_MATRIX=( |
| # old-A1 old-A2 old-A3 old-B1 new-A1 new-A2 new-A3 new-B1 fail ECPUs Pstate ISOLCPUS |
| # ------ ------ ------ ------ ------ ------ ------ ------ ---- ----- ------ -------- |
| " C0-1 . . C2-3 S+ C4-5 . . 0 A2:0-1" |
| " C0-1 . . C2-3 P1 . . . 0 " |
| " C0-1 . . C2-3 P1:S+ C0-1:P1 . . 0 " |
| " C0-1 . . C2-3 P1:S+ C1:P1 . . 0 " |
| " C0-1:S+ . . C2-3 . . . P1 0 " |
| " C0-1:P1 . . C2-3 S+ C1 . . 0 " |
| " C0-1:P1 . . C2-3 S+ C1:P1 . . 0 " |
| " C0-1:P1 . . C2-3 S+ C1:P1 . P1 0 " |
| " C0-1:P1 . . C2-3 C4-5 . . . 0 A1:4-5" |
| " C0-1:P1 . . C2-3 S+:C4-5 . . . 0 A1:4-5" |
| " C0-1 . . C2-3:P1 . . . C2 0 " |
| " C0-1 . . C2-3:P1 . . . C4-5 0 B1:4-5" |
| "C0-3:P1:S+ C2-3:P1 . . . . . . 0 A1:0-1,A2:2-3" |
| "C0-3:P1:S+ C2-3:P1 . . C1-3 . . . 0 A1:1,A2:2-3" |
| "C2-3:P1:S+ C3:P1 . . C3 . . . 0 A1:,A2:3 A1:P1,A2:P1" |
| "C2-3:P1:S+ C3:P1 . . C3 P0 . . 0 A1:3,A2:3 A1:P1,A2:P0" |
| "C2-3:P1:S+ C2:P1 . . C2-4 . . . 0 A1:3-4,A2:2" |
| "C2-3:P1:S+ C3:P1 . . C3 . . C0-2 0 A1:,B1:0-2 A1:P1,A2:P1" |
| "$SETUP_A123_PARTITIONS . C2-3 . . . 0 A1:,A2:2,A3:3 A1:P1,A2:P1,A3:P1" |
| |
| # CPU offlining cases: |
| " C0-1 . . C2-3 S+ C4-5 . O2=0 0 A1:0-1,B1:3" |
| "C0-3:P1:S+ C2-3:P1 . . O2=0 . . . 0 A1:0-1,A2:3" |
| "C0-3:P1:S+ C2-3:P1 . . O2=0 O2=1 . . 0 A1:0-1,A2:2-3" |
| "C0-3:P1:S+ C2-3:P1 . . O1=0 . . . 0 A1:0,A2:2-3" |
| "C0-3:P1:S+ C2-3:P1 . . O1=0 O1=1 . . 0 A1:0-1,A2:2-3" |
| "C2-3:P1:S+ C3:P1 . . O3=0 O3=1 . . 0 A1:2,A2:3 A1:P1,A2:P1" |
| "C2-3:P1:S+ C3:P2 . . O3=0 O3=1 . . 0 A1:2,A2:3 A1:P1,A2:P2" |
| "C2-3:P1:S+ C3:P1 . . O2=0 O2=1 . . 0 A1:2,A2:3 A1:P1,A2:P1" |
| "C2-3:P1:S+ C3:P2 . . O2=0 O2=1 . . 0 A1:2,A2:3 A1:P1,A2:P2" |
| "C2-3:P1:S+ C3:P1 . . O2=0 . . . 0 A1:,A2:3 A1:P1,A2:P1" |
| "C2-3:P1:S+ C3:P1 . . O3=0 . . . 0 A1:2,A2: A1:P1,A2:P1" |
| "C2-3:P1:S+ C3:P1 . . T:O2=0 . . . 0 A1:3,A2:3 A1:P1,A2:P-1" |
| "C2-3:P1:S+ C3:P1 . . . T:O3=0 . . 0 A1:2,A2:2 A1:P1,A2:P-1" |
| "$SETUP_A123_PARTITIONS . O1=0 . . . 0 A1:,A2:2,A3:3 A1:P1,A2:P1,A3:P1" |
| "$SETUP_A123_PARTITIONS . O2=0 . . . 0 A1:1,A2:,A3:3 A1:P1,A2:P1,A3:P1" |
| "$SETUP_A123_PARTITIONS . O3=0 . . . 0 A1:1,A2:2,A3: A1:P1,A2:P1,A3:P1" |
| "$SETUP_A123_PARTITIONS . T:O1=0 . . . 0 A1:2-3,A2:2-3,A3:3 A1:P1,A2:P-1,A3:P-1" |
| "$SETUP_A123_PARTITIONS . . T:O2=0 . . 0 A1:1,A2:3,A3:3 A1:P1,A2:P1,A3:P-1" |
| "$SETUP_A123_PARTITIONS . . . T:O3=0 . 0 A1:1,A2:2,A3:2 A1:P1,A2:P1,A3:P-1" |
| "$SETUP_A123_PARTITIONS . T:O1=0 O1=1 . . 0 A1:1,A2:2,A3:3 A1:P1,A2:P1,A3:P1" |
| "$SETUP_A123_PARTITIONS . . T:O2=0 O2=1 . 0 A1:1,A2:2,A3:3 A1:P1,A2:P1,A3:P1" |
| "$SETUP_A123_PARTITIONS . . . T:O3=0 O3=1 0 A1:1,A2:2,A3:3 A1:P1,A2:P1,A3:P1" |
| "$SETUP_A123_PARTITIONS . T:O1=0 O2=0 O1=1 . 0 A1:1,A2:,A3:3 A1:P1,A2:P1,A3:P1" |
| "$SETUP_A123_PARTITIONS . T:O1=0 O2=0 O2=1 . 0 A1:2-3,A2:2-3,A3:3 A1:P1,A2:P-1,A3:P-1" |
| |
| # old-A1 old-A2 old-A3 old-B1 new-A1 new-A2 new-A3 new-B1 fail ECPUs Pstate ISOLCPUS |
| # ------ ------ ------ ------ ------ ------ ------ ------ ---- ----- ------ -------- |
| # |
| # Remote partition and cpuset.cpus.exclusive tests |
| # |
| " C0-3:S+ C1-3:S+ C2-3 . X2-3 . . . 0 A1:0-3,A2:1-3,A3:2-3,XA1:2-3" |
| " C0-3:S+ C1-3:S+ C2-3 . X2-3 X2-3:P2 . . 0 A1:0-1,A2:2-3,A3:2-3 A1:P0,A2:P2 2-3" |
| " C0-3:S+ C1-3:S+ C2-3 . X2-3 X3:P2 . . 0 A1:0-2,A2:3,A3:3 A1:P0,A2:P2 3" |
| " C0-3:S+ C1-3:S+ C2-3 . X2-3 X2-3 X2-3:P2 . 0 A1:0-1,A2:1,A3:2-3 A1:P0,A3:P2 2-3" |
| " C0-3:S+ C1-3:S+ C2-3 . X2-3 X2-3 X2-3:P2:C3 . 0 A1:0-1,A2:1,A3:2-3 A1:P0,A3:P2 2-3" |
| " C0-3:S+ C1-3:S+ C2-3 C2-3 . . . P2 0 A1:0-3,A2:1-3,A3:2-3,B1:2-3 A1:P0,A3:P0,B1:P-2" |
| " C0-3:S+ C1-3:S+ C2-3 C4-5 . . . P2 0 B1:4-5 B1:P2 4-5" |
| " C0-3:S+ C1-3:S+ C2-3 C4 X2-3 X2-3 X2-3:P2 P2 0 A3:2-3,B1:4 A3:P2,B1:P2 2-4" |
| " C0-3:S+ C1-3:S+ C2-3 C4 X2-3 X2-3 X2-3:P2:C1-3 P2 0 A3:2-3,B1:4 A3:P2,B1:P2 2-4" |
| " C0-3:S+ C1-3:S+ C2-3 C4 X1-3 X1-3:P2 P2 . 0 A2:1,A3:2-3 A2:P2,A3:P2 1-3" |
| " C0-3:S+ C1-3:S+ C2-3 C4 X2-3 X2-3 X2-3:P2 P2:C4-5 0 A3:2-3,B1:4-5 A3:P2,B1:P2 2-5" |
| " C4:X0-3:S+ X1-3:S+ X2-3 . . P2 . . 0 A1:4,A2:1-3,A3:1-3 A2:P2 1-3" |
| " C4:X0-3:S+ X1-3:S+ X2-3 . . . P2 . 0 A1:4,A2:4,A3:2-3 A3:P2 2-3" |
| |
| # Nested remote/local partition tests |
| " C0-3:S+ C1-3:S+ C2-3 C4-5 X2-3 X2-3:P1 P2 P1 0 A1:0-1,A2:,A3:2-3,B1:4-5 \ |
| A1:P0,A2:P1,A3:P2,B1:P1 2-3" |
| " C0-3:S+ C1-3:S+ C2-3 C4 X2-3 X2-3:P1 P2 P1 0 A1:0-1,A2:,A3:2-3,B1:4 \ |
| A1:P0,A2:P1,A3:P2,B1:P1 2-4,2-3" |
| " C0-3:S+ C1-3:S+ C2-3 C4 X2-3 X2-3:P1 . P1 0 A1:0-1,A2:2-3,A3:2-3,B1:4 \ |
| A1:P0,A2:P1,A3:P0,B1:P1" |
| " C0-3:S+ C1-3:S+ C3 C4 X2-3 X2-3:P1 P2 P1 0 A1:0-1,A2:2,A3:3,B1:4 \ |
| A1:P0,A2:P1,A3:P2,B1:P1 2-4,3" |
| " C0-4:S+ C1-4:S+ C2-4 . X2-4 X2-4:P2 X4:P1 . 0 A1:0-1,A2:2-3,A3:4 \ |
| A1:P0,A2:P2,A3:P1 2-4,2-3" |
| " C0-4:S+ C1-4:S+ C2-4 . X2-4 X2-4:P2 X3-4:P1 . 0 A1:0-1,A2:2,A3:3-4 \ |
| A1:P0,A2:P2,A3:P1 2" |
| " C0-4:X2-4:S+ C1-4:X2-4:S+:P2 C2-4:X4:P1 \ |
| . . X5 . . 0 A1:0-4,A2:1-4,A3:2-4 \ |
| A1:P0,A2:P-2,A3:P-1" |
| " C0-4:X2-4:S+ C1-4:X2-4:S+:P2 C2-4:X4:P1 \ |
| . . . X1 . 0 A1:0-1,A2:2-4,A3:2-4 \ |
| A1:P0,A2:P2,A3:P-1 2-4" |
| |
| # Remote partition offline tests |
| " C0-3:S+ C1-3:S+ C2-3 . X2-3 X2-3 X2-3:P2:O2=0 . 0 A1:0-1,A2:1,A3:3 A1:P0,A3:P2 2-3" |
| " C0-3:S+ C1-3:S+ C2-3 . X2-3 X2-3 X2-3:P2:O2=0 O2=1 0 A1:0-1,A2:1,A3:2-3 A1:P0,A3:P2 2-3" |
| " C0-3:S+ C1-3:S+ C3 . X2-3 X2-3 P2:O3=0 . 0 A1:0-2,A2:1-2,A3: A1:P0,A3:P2 3" |
| " C0-3:S+ C1-3:S+ C3 . X2-3 X2-3 T:P2:O3=0 . 0 A1:0-2,A2:1-2,A3:1-2 A1:P0,A3:P-2 3," |
| |
| # An invalidated remote partition cannot self-recover from hotplug |
| " C0-3:S+ C1-3:S+ C2 . X2-3 X2-3 T:P2:O2=0 O2=1 0 A1:0-3,A2:1-3,A3:2 A1:P0,A3:P-2" |
| |
| # cpus.exclusive.effective clearing test |
| " C0-3:S+ C1-3:S+ C2 . X2-3:X . . . 0 A1:0-3,A2:1-3,A3:2,XA1:" |
| |
| # Invalid to valid remote partition transition test |
| " C0-3:S+ C1-3 . . . X3:P2 . . 0 A1:0-3,A2:1-3,XA2: A2:P-2" |
| " C0-3:S+ C1-3:X3:P2 |
| . . X2-3 P2 . . 0 A1:0-2,A2:3,XA2:3 A2:P2 3" |
| |
| # Invalid to valid local partition direct transition tests |
| " C1-3:S+:P2 X4:P2 . . . . . . 0 A1:1-3,XA1:1-3,A2:1-3:XA2: A1:P2,A2:P-2 1-3" |
| " C1-3:S+:P2 X4:P2 . . . X3:P2 . . 0 A1:1-2,XA1:1-3,A2:3:XA2:3 A1:P2,A2:P2 1-3" |
| " C0-3:P2 . . C4-6 C0-4 . . . 0 A1:0-4,B1:4-6 A1:P-2,B1:P0" |
| " C0-3:P2 . . C4-6 C0-4:C0-3 . . . 0 A1:0-3,B1:4-6 A1:P2,B1:P0 0-3" |
| " C0-3:P2 . . C3-5:C4-5 . . . . 0 A1:0-3,B1:4-5 A1:P2,B1:P0 0-3" |
| |
| # Local partition invalidation tests |
| " C0-3:X1-3:S+:P2 C1-3:X2-3:S+:P2 C2-3:X3:P2 \ |
| . . . . . 0 A1:1,A2:2,A3:3 A1:P2,A2:P2,A3:P2 1-3" |
| " C0-3:X1-3:S+:P2 C1-3:X2-3:S+:P2 C2-3:X3:P2 \ |
| . . X4 . . 0 A1:1-3,A2:1-3,A3:2-3,XA2:,XA3: A1:P2,A2:P-2,A3:P-2 1-3" |
| " C0-3:X1-3:S+:P2 C1-3:X2-3:S+:P2 C2-3:X3:P2 \ |
| . . C4:X . . 0 A1:1-3,A2:1-3,A3:2-3,XA2:,XA3: A1:P2,A2:P-2,A3:P-2 1-3" |
| # Local partition CPU change tests |
| " C0-5:S+:P2 C4-5:S+:P1 . . . C3-5 . . 0 A1:0-2,A2:3-5 A1:P2,A2:P1 0-2" |
| " C0-5:S+:P2 C4-5:S+:P1 . . C1-5 . . . 0 A1:1-3,A2:4-5 A1:P2,A2:P1 1-3" |
| |
| # cpus_allowed/exclusive_cpus update tests |
| " C0-3:X2-3:S+ C1-3:X2-3:S+ C2-3:X2-3 \ |
| . X:C4 . P2 . 0 A1:4,A2:4,XA2:,XA3:,A3:4 \ |
| A1:P0,A3:P-2" |
| " C0-3:X2-3:S+ C1-3:X2-3:S+ C2-3:X2-3 \ |
| . X1 . P2 . 0 A1:0-3,A2:1-3,XA1:1,XA2:,XA3:,A3:2-3 \ |
| A1:P0,A3:P-2" |
| " C0-3:X2-3:S+ C1-3:X2-3:S+ C2-3:X2-3 \ |
| . . X3 P2 . 0 A1:0-2,A2:1-2,XA2:3,XA3:3,A3:3 \ |
| A1:P0,A3:P2 3" |
| " C0-3:X2-3:S+ C1-3:X2-3:S+ C2-3:X2-3:P2 \ |
| . . X3 . . 0 A1:0-3,A2:1-3,XA2:3,XA3:3,A3:2-3 \ |
| A1:P0,A3:P-2" |
| " C0-3:X2-3:S+ C1-3:X2-3:S+ C2-3:X2-3:P2 \ |
| . X4 . . . 0 A1:0-3,A2:1-3,A3:2-3,XA1:4,XA2:,XA3 \ |
| A1:P0,A3:P-2" |
| |
| # old-A1 old-A2 old-A3 old-B1 new-A1 new-A2 new-A3 new-B1 fail ECPUs Pstate ISOLCPUS |
| # ------ ------ ------ ------ ------ ------ ------ ------ ---- ----- ------ -------- |
| # |
| # Incorrect change to cpuset.cpus[.exclusive] invalidates partition root |
| # |
| # Adding CPUs to partition root that are not in parent's |
| # cpuset.cpus is allowed, but those extra CPUs are ignored. |
| "C2-3:P1:S+ C3:P1 . . . C2-4 . . 0 A1:,A2:2-3 A1:P1,A2:P1" |
| |
| # Taking away all CPUs from parent or itself if there are tasks |
| # will make the partition invalid. |
| "C2-3:P1:S+ C3:P1 . . T C2-3 . . 0 A1:2-3,A2:2-3 A1:P1,A2:P-1" |
| " C3:P1:S+ C3 . . T P1 . . 0 A1:3,A2:3 A1:P1,A2:P-1" |
| "$SETUP_A123_PARTITIONS . T:C2-3 . . . 0 A1:2-3,A2:2-3,A3:3 A1:P1,A2:P-1,A3:P-1" |
| "$SETUP_A123_PARTITIONS . T:C2-3:C1-3 . . . 0 A1:1,A2:2,A3:3 A1:P1,A2:P1,A3:P1" |
| |
| # Changing a partition root to member makes child partitions invalid |
| "C2-3:P1:S+ C3:P1 . . P0 . . . 0 A1:2-3,A2:3 A1:P0,A2:P-1" |
| "$SETUP_A123_PARTITIONS . C2-3 P0 . . 0 A1:2-3,A2:2-3,A3:3 A1:P1,A2:P0,A3:P-1" |
| |
| # cpuset.cpus can contains cpus not in parent's cpuset.cpus as long |
| # as they overlap. |
| "C2-3:P1:S+ . . . . C3-4:P1 . . 0 A1:2,A2:3 A1:P1,A2:P1" |
| |
| # Deletion of CPUs distributed to child cgroup is allowed. |
| "C0-1:P1:S+ C1 . C2-3 C4-5 . . . 0 A1:4-5,A2:4-5" |
| |
| # To become a valid partition root, cpuset.cpus must overlap parent's |
| # cpuset.cpus. |
| " C0-1:P1 . . C2-3 S+ C4-5:P1 . . 0 A1:0-1,A2:0-1 A1:P1,A2:P-1" |
| |
| # Enabling partition with child cpusets is allowed |
| " C0-1:S+ C1 . C2-3 P1 . . . 0 A1:0-1,A2:1 A1:P1" |
| |
| # A partition root with non-partition root parent is invalid, but it |
| # can be made valid if its parent becomes a partition root too. |
| " C0-1:S+ C1 . C2-3 . P2 . . 0 A1:0-1,A2:1 A1:P0,A2:P-2" |
| " C0-1:S+ C1:P2 . C2-3 P1 . . . 0 A1:0,A2:1 A1:P1,A2:P2" |
| |
| # A non-exclusive cpuset.cpus change will invalidate partition and its siblings |
| " C0-1:P1 . . C2-3 C0-2 . . . 0 A1:0-2,B1:2-3 A1:P-1,B1:P0" |
| " C0-1:P1 . . P1:C2-3 C0-2 . . . 0 A1:0-2,B1:2-3 A1:P-1,B1:P-1" |
| " C0-1 . . P1:C2-3 C0-2 . . . 0 A1:0-2,B1:2-3 A1:P0,B1:P-1" |
| |
| # cpuset.cpus can overlap with sibling cpuset.cpus.exclusive but not subsumed by it |
| " C0-3 . . C4-5 X5 . . . 0 A1:0-3,B1:4-5" |
| |
| # Child partition root that try to take all CPUs from parent partition |
| # with tasks will remain invalid. |
| " C1-4:P1:S+ P1 . . . . . . 0 A1:1-4,A2:1-4 A1:P1,A2:P-1" |
| " C1-4:P1:S+ P1 . . . C1-4 . . 0 A1,A2:1-4 A1:P1,A2:P1" |
| " C1-4:P1:S+ P1 . . T C1-4 . . 0 A1:1-4,A2:1-4 A1:P1,A2:P-1" |
| |
| # Clearing of cpuset.cpus with a preset cpuset.cpus.exclusive shouldn't |
| # affect cpuset.cpus.exclusive.effective. |
| " C1-4:X3:S+ C1:X3 . . . C . . 0 A2:1-4,XA2:3" |
| |
| # old-A1 old-A2 old-A3 old-B1 new-A1 new-A2 new-A3 new-B1 fail ECPUs Pstate ISOLCPUS |
| # ------ ------ ------ ------ ------ ------ ------ ------ ---- ----- ------ -------- |
| # Failure cases: |
| |
| # A task cannot be added to a partition with no cpu |
| "C2-3:P1:S+ C3:P1 . . O2=0:T . . . 1 A1:,A2:3 A1:P1,A2:P1" |
| |
| # Changes to cpuset.cpus.exclusive that violate exclusivity rule is rejected |
| " C0-3 . . C4-5 X0-3 . . X3-5 1 A1:0-3,B1:4-5" |
| |
| # cpuset.cpus cannot be a subset of sibling cpuset.cpus.exclusive |
| " C0-3 . . C4-5 X3-5 . . . 1 A1:0-3,B1:4-5" |
| ) |
| |
| # |
| # Write to the cpu online file |
| # $1 - <c>=<v> where <c> = cpu number, <v> value to be written |
| # |
| write_cpu_online() |
| { |
| CPU=${1%=*} |
| VAL=${1#*=} |
| CPUFILE=//sys/devices/system/cpu/cpu${CPU}/online |
| if [[ $VAL -eq 0 ]] |
| then |
| OFFLINE_CPUS="$OFFLINE_CPUS $CPU" |
| else |
| [[ -n "$OFFLINE_CPUS" ]] && { |
| OFFLINE_CPUS=$(echo $CPU $CPU $OFFLINE_CPUS | fmt -1 |\ |
| sort | uniq -u) |
| } |
| fi |
| echo $VAL > $CPUFILE |
| pause 0.05 |
| } |
| |
| # |
| # Set controller state |
| # $1 - cgroup directory |
| # $2 - state |
| # $3 - showerr |
| # |
| # The presence of ":" in state means transition from one to the next. |
| # |
| set_ctrl_state() |
| { |
| TMPMSG=/tmp/.msg_$$ |
| CGRP=$1 |
| STATE=$2 |
| SHOWERR=${3} |
| CTRL=${CTRL:=$CONTROLLER} |
| HASERR=0 |
| REDIRECT="2> $TMPMSG" |
| [[ -z "$STATE" || "$STATE" = '.' ]] && return 0 |
| [[ $VERBOSE -gt 0 ]] && SHOWERR=1 |
| |
| rm -f $TMPMSG |
| for CMD in $(echo $STATE | sed -e "s/:/ /g") |
| do |
| TFILE=$CGRP/cgroup.procs |
| SFILE=$CGRP/cgroup.subtree_control |
| PFILE=$CGRP/cpuset.cpus.partition |
| CFILE=$CGRP/cpuset.cpus |
| XFILE=$CGRP/cpuset.cpus.exclusive |
| S=$(expr substr $CMD 1 1) |
| if [[ $S = S ]] |
| then |
| PREFIX=${CMD#?} |
| COMM="echo ${PREFIX}${CTRL} > $SFILE" |
| eval $COMM $REDIRECT |
| elif [[ $S = X ]] |
| then |
| CPUS=${CMD#?} |
| COMM="echo $CPUS > $XFILE" |
| eval $COMM $REDIRECT |
| elif [[ $S = C ]] |
| then |
| CPUS=${CMD#?} |
| COMM="echo $CPUS > $CFILE" |
| eval $COMM $REDIRECT |
| elif [[ $S = P ]] |
| then |
| VAL=${CMD#?} |
| case $VAL in |
| 0) VAL=member |
| ;; |
| 1) VAL=root |
| ;; |
| 2) VAL=isolated |
| ;; |
| *) |
| echo "Invalid partition state - $VAL" |
| exit 1 |
| ;; |
| esac |
| COMM="echo $VAL > $PFILE" |
| eval $COMM $REDIRECT |
| elif [[ $S = O ]] |
| then |
| VAL=${CMD#?} |
| write_cpu_online $VAL |
| elif [[ $S = T ]] |
| then |
| COMM="echo 0 > $TFILE" |
| eval $COMM $REDIRECT |
| fi |
| RET=$? |
| [[ $RET -ne 0 ]] && { |
| [[ -n "$SHOWERR" ]] && { |
| echo "$COMM" |
| cat $TMPMSG |
| } |
| HASERR=1 |
| } |
| pause 0.01 |
| rm -f $TMPMSG |
| done |
| return $HASERR |
| } |
| |
| set_ctrl_state_noerr() |
| { |
| CGRP=$1 |
| STATE=$2 |
| [[ -d $CGRP ]] || mkdir $CGRP |
| set_ctrl_state $CGRP $STATE 1 |
| [[ $? -ne 0 ]] && { |
| echo "ERROR: Failed to set $2 to cgroup $1!" |
| exit 1 |
| } |
| } |
| |
| online_cpus() |
| { |
| [[ -n "OFFLINE_CPUS" ]] && { |
| for C in $OFFLINE_CPUS |
| do |
| write_cpu_online ${C}=1 |
| done |
| } |
| } |
| |
| # |
| # Return 1 if the list of effective cpus isn't the same as the initial list. |
| # |
| reset_cgroup_states() |
| { |
| echo 0 > $CGROUP2/cgroup.procs |
| online_cpus |
| rmdir A1/A2/A3 A1/A2 A1 B1 > /dev/null 2>&1 |
| pause 0.02 |
| set_ctrl_state . R- |
| pause 0.01 |
| } |
| |
| dump_states() |
| { |
| for DIR in . A1 A1/A2 A1/A2/A3 B1 |
| do |
| CPUS=$DIR/cpuset.cpus |
| ECPUS=$DIR/cpuset.cpus.effective |
| XCPUS=$DIR/cpuset.cpus.exclusive |
| XECPUS=$DIR/cpuset.cpus.exclusive.effective |
| PRS=$DIR/cpuset.cpus.partition |
| PCPUS=$DIR/.__DEBUG__.cpuset.cpus.subpartitions |
| ISCPUS=$DIR/cpuset.cpus.isolated |
| [[ -e $CPUS ]] && echo "$CPUS: $(cat $CPUS)" |
| [[ -e $XCPUS ]] && echo "$XCPUS: $(cat $XCPUS)" |
| [[ -e $ECPUS ]] && echo "$ECPUS: $(cat $ECPUS)" |
| [[ -e $XECPUS ]] && echo "$XECPUS: $(cat $XECPUS)" |
| [[ -e $PRS ]] && echo "$PRS: $(cat $PRS)" |
| [[ -e $PCPUS ]] && echo "$PCPUS: $(cat $PCPUS)" |
| [[ -e $ISCPUS ]] && echo "$ISCPUS: $(cat $ISCPUS)" |
| done |
| } |
| |
| # |
| # Check effective cpus |
| # $1 - check string, format: <cgroup>:<cpu-list>[,<cgroup>:<cpu-list>]* |
| # |
| check_effective_cpus() |
| { |
| CHK_STR=$1 |
| for CHK in $(echo $CHK_STR | sed -e "s/,/ /g") |
| do |
| set -- $(echo $CHK | sed -e "s/:/ /g") |
| CGRP=$1 |
| CPUS=$2 |
| if [[ $CGRP = X* ]] |
| then |
| CGRP=${CGRP#X} |
| FILE=cpuset.cpus.exclusive.effective |
| else |
| FILE=cpuset.cpus.effective |
| fi |
| [[ $CGRP = A2 ]] && CGRP=A1/A2 |
| [[ $CGRP = A3 ]] && CGRP=A1/A2/A3 |
| [[ -e $CGRP/$FILE ]] || return 1 |
| [[ $CPUS = $(cat $CGRP/$FILE) ]] || return 1 |
| done |
| } |
| |
| # |
| # Check cgroup states |
| # $1 - check string, format: <cgroup>:<state>[,<cgroup>:<state>]* |
| # |
| check_cgroup_states() |
| { |
| CHK_STR=$1 |
| for CHK in $(echo $CHK_STR | sed -e "s/,/ /g") |
| do |
| set -- $(echo $CHK | sed -e "s/:/ /g") |
| CGRP=$1 |
| CGRP_DIR=$CGRP |
| STATE=$2 |
| FILE= |
| EVAL=$(expr substr $STATE 2 2) |
| [[ $CGRP = A2 ]] && CGRP_DIR=A1/A2 |
| [[ $CGRP = A3 ]] && CGRP_DIR=A1/A2/A3 |
| |
| case $STATE in |
| P*) FILE=$CGRP_DIR/cpuset.cpus.partition |
| ;; |
| *) echo "Unknown state: $STATE!" |
| exit 1 |
| ;; |
| esac |
| VAL=$(cat $FILE) |
| |
| case "$VAL" in |
| member) VAL=0 |
| ;; |
| root) VAL=1 |
| ;; |
| isolated) |
| VAL=2 |
| ;; |
| "root invalid"*) |
| VAL=-1 |
| ;; |
| "isolated invalid"*) |
| VAL=-2 |
| ;; |
| esac |
| [[ $EVAL != $VAL ]] && return 1 |
| |
| # |
| # For root partition, dump sched-domains info to console if |
| # verbose mode set for manual comparison with sched debug info. |
| # |
| [[ $VAL -eq 1 && $VERBOSE -gt 0 ]] && { |
| DOMS=$(cat $CGRP_DIR/cpuset.cpus.effective) |
| [[ -n "$DOMS" ]] && |
| echo " [$CGRP] sched-domain: $DOMS" > $CONSOLE |
| } |
| done |
| return 0 |
| } |
| |
| # |
| # Get isolated (including offline) CPUs by looking at |
| # /sys/kernel/debug/sched/domains and cpuset.cpus.isolated control file, |
| # if available, and compare that with the expected value. |
| # |
| # Note that isolated CPUs from the sched/domains context include offline |
| # CPUs as well as CPUs in non-isolated 1-CPU partition. Those CPUs may |
| # not be included in the cpuset.cpus.isolated control file which contains |
| # only CPUs in isolated partitions as well as those that are isolated at |
| # boot time. |
| # |
| # $1 - expected isolated cpu list(s) <isolcpus1>{,<isolcpus2>} |
| # <isolcpus1> - expected sched/domains value |
| # <isolcpus2> - cpuset.cpus.isolated value = <isolcpus1> if not defined |
| # |
| check_isolcpus() |
| { |
| EXPECT_VAL=$1 |
| ISOLCPUS= |
| LASTISOLCPU= |
| SCHED_DOMAINS=/sys/kernel/debug/sched/domains |
| ISCPUS=${CGROUP2}/cpuset.cpus.isolated |
| if [[ $EXPECT_VAL = . ]] |
| then |
| EXPECT_VAL= |
| EXPECT_VAL2= |
| elif [[ $(expr $EXPECT_VAL : ".*,.*") > 0 ]] |
| then |
| set -- $(echo $EXPECT_VAL | sed -e "s/,/ /g") |
| EXPECT_VAL=$1 |
| EXPECT_VAL2=$2 |
| else |
| EXPECT_VAL2=$EXPECT_VAL |
| fi |
| |
| # |
| # Check cpuset.cpus.isolated cpumask |
| # |
| if [[ -z "$BOOT_ISOLCPUS" ]] |
| then |
| ISOLCPUS=$(cat $ISCPUS) |
| else |
| ISOLCPUS=$(cat $ISCPUS | sed -e "s/,*$BOOT_ISOLCPUS//") |
| fi |
| [[ "$EXPECT_VAL2" != "$ISOLCPUS" ]] && { |
| # Take a 50ms pause and try again |
| pause 0.05 |
| ISOLCPUS=$(cat $ISCPUS) |
| } |
| [[ "$EXPECT_VAL2" != "$ISOLCPUS" ]] && return 1 |
| ISOLCPUS= |
| |
| # |
| # Use the sched domain in debugfs to check isolated CPUs, if available |
| # |
| [[ -d $SCHED_DOMAINS ]] || return 0 |
| |
| for ((CPU=0; CPU < $NR_CPUS; CPU++)) |
| do |
| [[ -n "$(ls ${SCHED_DOMAINS}/cpu$CPU)" ]] && continue |
| |
| if [[ -z "$LASTISOLCPU" ]] |
| then |
| ISOLCPUS=$CPU |
| LASTISOLCPU=$CPU |
| elif [[ "$LASTISOLCPU" -eq $((CPU - 1)) ]] |
| then |
| echo $ISOLCPUS | grep -q "\<$LASTISOLCPU\$" |
| if [[ $? -eq 0 ]] |
| then |
| ISOLCPUS=${ISOLCPUS}- |
| fi |
| LASTISOLCPU=$CPU |
| else |
| if [[ $ISOLCPUS = *- ]] |
| then |
| ISOLCPUS=${ISOLCPUS}$LASTISOLCPU |
| fi |
| ISOLCPUS=${ISOLCPUS},$CPU |
| LASTISOLCPU=$CPU |
| fi |
| done |
| [[ "$ISOLCPUS" = *- ]] && ISOLCPUS=${ISOLCPUS}$LASTISOLCPU |
| [[ -n "BOOT_ISOLCPUS" ]] && |
| ISOLCPUS=$(echo $ISOLCPUS | sed -e "s/,*$BOOT_ISOLCPUS//") |
| |
| [[ "$EXPECT_VAL" = "$ISOLCPUS" ]] |
| } |
| |
| test_fail() |
| { |
| TESTNUM=$1 |
| TESTTYPE=$2 |
| ADDINFO=$3 |
| echo "Test $TEST[$TESTNUM] failed $TESTTYPE check!" |
| [[ -n "$ADDINFO" ]] && echo "*** $ADDINFO ***" |
| eval echo \${$TEST[$I]} |
| echo |
| dump_states |
| exit 1 |
| } |
| |
| # |
| # Check to see if there are unexpected isolated CPUs left beyond the boot |
| # time isolated ones. |
| # |
| null_isolcpus_check() |
| { |
| [[ $VERBOSE -gt 0 ]] || return 0 |
| # Retry a few times before printing error |
| RETRY=0 |
| while [[ $RETRY -lt 8 ]] |
| do |
| pause 0.02 |
| check_isolcpus "." |
| [[ $? -eq 0 ]] && return 0 |
| ((RETRY++)) |
| done |
| echo "Unexpected isolated CPUs: $ISOLCPUS" |
| dump_states |
| exit 1 |
| } |
| |
| # |
| # Run cpuset state transition test |
| # $1 - test matrix name |
| # |
| # This test is somewhat fragile as delays (sleep x) are added in various |
| # places to make sure state changes are fully propagated before the next |
| # action. These delays may need to be adjusted if running in a slower machine. |
| # |
| run_state_test() |
| { |
| TEST=$1 |
| CONTROLLER=cpuset |
| I=0 |
| eval CNT="\${#$TEST[@]}" |
| |
| reset_cgroup_states |
| console_msg "Running state transition test ..." |
| |
| while [[ $I -lt $CNT ]] |
| do |
| echo "Running test $I ..." > $CONSOLE |
| [[ $VERBOSE -gt 1 ]] && { |
| echo "" |
| eval echo \${$TEST[$I]} |
| } |
| eval set -- "\${$TEST[$I]}" |
| OLD_A1=$1 |
| OLD_A2=$2 |
| OLD_A3=$3 |
| OLD_B1=$4 |
| NEW_A1=$5 |
| NEW_A2=$6 |
| NEW_A3=$7 |
| NEW_B1=$8 |
| RESULT=$9 |
| ECPUS=${10} |
| STATES=${11} |
| ICPUS=${12} |
| |
| set_ctrl_state_noerr B1 $OLD_B1 |
| set_ctrl_state_noerr A1 $OLD_A1 |
| set_ctrl_state_noerr A1/A2 $OLD_A2 |
| set_ctrl_state_noerr A1/A2/A3 $OLD_A3 |
| RETVAL=0 |
| set_ctrl_state A1 $NEW_A1; ((RETVAL += $?)) |
| set_ctrl_state A1/A2 $NEW_A2; ((RETVAL += $?)) |
| set_ctrl_state A1/A2/A3 $NEW_A3; ((RETVAL += $?)) |
| set_ctrl_state B1 $NEW_B1; ((RETVAL += $?)) |
| |
| [[ $RETVAL -ne $RESULT ]] && test_fail $I result |
| |
| [[ -n "$ECPUS" && "$ECPUS" != . ]] && { |
| check_effective_cpus $ECPUS |
| [[ $? -ne 0 ]] && test_fail $I "effective CPU" |
| } |
| |
| [[ -n "$STATES" && "$STATES" != . ]] && { |
| check_cgroup_states $STATES |
| [[ $? -ne 0 ]] && test_fail $I states |
| } |
| |
| # Compare the expected isolated CPUs with the actual ones, |
| # if available |
| [[ -n "$ICPUS" ]] && { |
| check_isolcpus $ICPUS |
| [[ $? -ne 0 ]] && test_fail $I "isolated CPU" \ |
| "Expect $ICPUS, get $ISOLCPUS instead" |
| } |
| reset_cgroup_states |
| # |
| # Check to see if effective cpu list changes |
| # |
| NEWLIST=$(cat cpuset.cpus.effective) |
| RETRY=0 |
| while [[ $NEWLIST != $CPULIST && $RETRY -lt 8 ]] |
| do |
| # Wait a bit longer & recheck a few times |
| pause 0.02 |
| ((RETRY++)) |
| NEWLIST=$(cat cpuset.cpus.effective) |
| done |
| [[ $NEWLIST != $CPULIST ]] && { |
| echo "Effective cpus changed to $NEWLIST after test $I!" |
| exit 1 |
| } |
| null_isolcpus_check |
| [[ $VERBOSE -gt 0 ]] && echo "Test $I done." |
| ((I++)) |
| done |
| echo "All $I tests of $TEST PASSED." |
| } |
| |
| # |
| # Testing the new "isolated" partition root type |
| # |
| test_isolated() |
| { |
| cd $CGROUP2/test |
| echo 2-3 > cpuset.cpus |
| TYPE=$(cat cpuset.cpus.partition) |
| [[ $TYPE = member ]] || echo member > cpuset.cpus.partition |
| |
| console_msg "Change from member to root" |
| test_partition root |
| |
| console_msg "Change from root to isolated" |
| test_partition isolated |
| |
| console_msg "Change from isolated to member" |
| test_partition member |
| |
| console_msg "Change from member to isolated" |
| test_partition isolated |
| |
| console_msg "Change from isolated to root" |
| test_partition root |
| |
| console_msg "Change from root to member" |
| test_partition member |
| |
| # |
| # Testing partition root with no cpu |
| # |
| console_msg "Distribute all cpus to child partition" |
| echo +cpuset > cgroup.subtree_control |
| test_partition root |
| |
| mkdir A1 |
| cd A1 |
| echo 2-3 > cpuset.cpus |
| test_partition root |
| test_effective_cpus 2-3 |
| cd .. |
| test_effective_cpus "" |
| |
| console_msg "Moving task to partition test" |
| test_add_proc "No space left" |
| cd A1 |
| test_add_proc "" |
| cd .. |
| |
| console_msg "Shrink and expand child partition" |
| cd A1 |
| echo 2 > cpuset.cpus |
| cd .. |
| test_effective_cpus 3 |
| cd A1 |
| echo 2-3 > cpuset.cpus |
| cd .. |
| test_effective_cpus "" |
| |
| # Cleaning up |
| console_msg "Cleaning up" |
| echo $$ > $CGROUP2/cgroup.procs |
| [[ -d A1 ]] && rmdir A1 |
| null_isolcpus_check |
| } |
| |
| # |
| # Wait for inotify event for the given file and read it |
| # $1: cgroup file to wait for |
| # $2: file to store the read result |
| # |
| wait_inotify() |
| { |
| CGROUP_FILE=$1 |
| OUTPUT_FILE=$2 |
| |
| $WAIT_INOTIFY $CGROUP_FILE |
| cat $CGROUP_FILE > $OUTPUT_FILE |
| } |
| |
| # |
| # Test if inotify events are properly generated when going into and out of |
| # invalid partition state. |
| # |
| test_inotify() |
| { |
| ERR=0 |
| PRS=/tmp/.prs_$$ |
| cd $CGROUP2/test |
| [[ -f $WAIT_INOTIFY ]] || { |
| echo "wait_inotify not found, inotify test SKIPPED." |
| return |
| } |
| |
| pause 0.01 |
| echo 1 > cpuset.cpus |
| echo 0 > cgroup.procs |
| echo root > cpuset.cpus.partition |
| pause 0.01 |
| rm -f $PRS |
| wait_inotify $PWD/cpuset.cpus.partition $PRS & |
| pause 0.01 |
| set_ctrl_state . "O1=0" |
| pause 0.01 |
| check_cgroup_states ".:P-1" |
| if [[ $? -ne 0 ]] |
| then |
| echo "FAILED: Inotify test - partition not invalid" |
| ERR=1 |
| elif [[ ! -f $PRS ]] |
| then |
| echo "FAILED: Inotify test - event not generated" |
| ERR=1 |
| kill %1 |
| elif [[ $(cat $PRS) != "root invalid"* ]] |
| then |
| echo "FAILED: Inotify test - incorrect state" |
| cat $PRS |
| ERR=1 |
| fi |
| online_cpus |
| echo member > cpuset.cpus.partition |
| echo 0 > ../cgroup.procs |
| if [[ $ERR -ne 0 ]] |
| then |
| exit 1 |
| else |
| echo "Inotify test PASSED" |
| fi |
| } |
| |
| trap cleanup 0 2 3 6 |
| run_state_test TEST_MATRIX |
| test_isolated |
| test_inotify |
| echo "All tests PASSED." |
