Quelle  test_cpuset_prs.sh   Sprache: Shell

#!/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 "
      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-8
# that will be used by this script for testing purpose. If not, some of
# the tests may fail incorrectly. Wait a bit and retry again just in case
# these isolated CPUs are leftover from previous run and have just been
# cleaned up earlier in this script.
#
# These pre-isolated CPUs should stay in an isolated state throughout the
# testing process for now.
#
BOOT_ISOLCPUS=$(cat $CGROUP2/cpuset.cpus.isolated)
[[ -n "$BOOT_ISOLCPUS" ]] && {
 sleep 0.5
 BOOT_ISOLCPUS=$(cat $CGROUP2/cpuset.cpus.isolated)
}
if [[ -n "$BOOT_ISOLCPUS" ]]
then
 [[ $(echo $BOOT_ISOLCPUS | sed -e "s/[,-].*//") -le 8 ]] &&
  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 test/A1 test/B1 test > /dev/null 2>&1
 rmdir rtest/p1/c11 rtest/p1/c12 rtest/p2/c21 \
       rtest/p2/c22 rtest/p1 rtest/p2 rtest > /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            B1
#  |
#  A2
#  |
#  A3
#
#  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
#  CX<l> = add cpu-list to both cpuset.cpus and cpuset.cpus.exclusive
#  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|XA2:2-3"
 "C0-3:P1:S+ C2-3:P1 . . C1-3 . . . 0 A1:1|A2:2-3|XA2:2-3"
 "C2-3:P1:S+ C3:P1 . . C3 . . . 0 A1:|A2:3|XA2: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"

 # 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-2|A2:1-2|XA2:3|XA3:3|A3:3|XA3:3 \
               A1:P0|A3:P2 3"
 " 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 0-1|1"

 # 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"

 # cpuset.cpus can contain CPUs that overlap a sibling cpuset with cpus.exclusive
 # but creating a local partition out of it is not allowed. Similarly and change
 # in cpuset.cpus of a local partition that overlaps sibling exclusive CPUs will
 # invalidate it.
 " CX1-4:S+ CX2-4:P2 . C5-6 . . . P1 0 A1:1|A2:2-4|B1:5-6|XB1:5-6 \
               A1:P0|A2:P2:B1:P1 2-4"
 " CX1-4:S+ CX2-4:P2 . C3-6 . . . P1 0 A1:1|A2:2-4|B1:5-6 \
               A1:P0|A2:P2:B1:P-1 2-4"
 " CX1-4:S+ CX2-4:P2 . C5-6 . . . P1:C3-6 0 A1:1|A2:2-4|B1:5-6 \
               A1:P0|A2:P2:B1:P-1 2-4"

 #  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"
)

#
# Cpuset controller remote partition test matrix.
#
# Cgroup test hierarchy
#
#       root
#         |
#       rtest (cpuset.cpus.exclusive=1-7)
#         |
#  +------+------+
#  |             |
#  p1            p2
#     +--+--+       +--+--+
#     |     |       |     |
#    c11   c12     c21   c22
#
# REMOTE_TEST_MATRIX uses the same notational convention as TEST_MATRIX.
# Only CPUs 1-7 should be used.
#
REMOTE_TEST_MATRIX=(
 #  old-p1 old-p2 old-c11 old-c12 old-c21 old-c22
 #  new-p1 new-p2 new-c11 new-c12 new-c21 new-c22 ECPUs Pstate ISOLCPUS
 #  ------ ------ ------- ------- ------- ------- ----- ------ --------
 " X1-3:S+ X4-6:S+ X1-2 X3 X4-5 X6 \
       .      .     P2      P2      P2      P2    c11:1-2|c12:3|c21:4-5|c22:6 \
        c11:P2|c12:P2|c21:P2|c22:P2 1-6"
 " CX1-4:S+ . X1-2:P2 C3 . . \
       .      .     .      C3-4     .       .     p1:3-4|c11:1-2|c12:3-4 \
        p1:P0|c11:P2|c12:P0 1-2"
 " CX1-4:S+ . X1-2:P2 . . . \
     X2-4     .     .       .       .       .     p1:1,3-4|c11:2 \
        p1:P0|c11:P2 2"
 " CX1-5:S+ . X1-2:P2 X3-5:P1 . . \
     X2-4     .     .       .       .       .     p1:1,5|c11:2|c12:3-4 \
        p1:P0|c11:P2|c12:P1 2"
 " CX1-4:S+ . X1-2:P2 X3-4:P1 . . \
       .      .     X2      .       .       .     p1:1|c11:2|c12:3-4 \
        p1:P0|c11:P2|c12:P1 2"
 # p1 as member, will get its effective CPUs from its parent rtest
 " CX1-4:S+ . X1-2:P2 X3-4:P1 . . \
       .      .     X1     CX2-4    .       .     p1:5-7|c11:1|c12:2-4 \
        p1:P0|c11:P2|c12:P1 1"
 " CX1-4:S+ X5-6:P1:S+ . . . . \
       .      .   X1-2:P2  X4-5:P1  .     X1-7:P2 p1:3|c11:1-2|c12:4:c22:5-6 \
        p1:P0|p2:P1|c11:P2|c12:P1|c22:P2 \
        1-2,4-6|1-2,5-6"
)

#
# 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
  case $CMD in
      S*) PREFIX=${CMD#?}
   COMM="echo ${PREFIX}${CTRL} > $SFILE"
   eval $COMM $REDIRECT
   ;;
      X*)
   CPUS=${CMD#?}
   COMM="echo $CPUS > $XFILE"
   eval $COMM $REDIRECT
   ;;
      CX*)
   CPUS=${CMD#??}
   COMM="echo $CPUS > $CFILE; echo $CPUS > $XFILE"
   eval $COMM $REDIRECT
   ;;
      C*) CPUS=${CMD#?}
   COMM="echo $CPUS > $CFILE"
   eval $COMM $REDIRECT
   ;;
      P*) 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
   ;;
      O*) VAL=${CMD#?}
   write_cpu_online $VAL
   ;;
      T*) COMM="echo 0 > $TFILE"
   eval $COMM $REDIRECT
   ;;
      *)  echo "Unknown command: $CMD"
          exit 1
   ;;
  esac
  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
 }
}

#
# Remove all the test cgroup directories
#
reset_cgroup_states()
{
 echo 0 > $CGROUP2/cgroup.procs
 online_cpus
 rmdir $RESET_LIST > /dev/null 2>&1
}

dump_states()
{
 for DIR in $CGROUP_LIST
 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
}

#
# Set the actual cgroup directory into $CGRP_DIR
# $1 - cgroup name
#
set_cgroup_dir()
{
 CGRP_DIR=$1
 [[ $CGRP_DIR = A2  ]] && CGRP_DIR=A1/A2
 [[ $CGRP_DIR = A3  ]] && CGRP_DIR=A1/A2/A3
 [[ $CGRP_DIR = c11 ]] && CGRP_DIR=p1/c11
 [[ $CGRP_DIR = c12 ]] && CGRP_DIR=p1/c12
 [[ $CGRP_DIR = c21 ]] && CGRP_DIR=p2/c21
 [[ $CGRP_DIR = c22 ]] && CGRP_DIR=p2/c22
}

#
# 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
  EXPECTED_CPUS=$2
  ACTUAL_CPUS=
  if [[ $CGRP = X* ]]
  then
   CGRP=${CGRP#X}
   FILE=cpuset.cpus.exclusive.effective
  else
   FILE=cpuset.cpus.effective
  fi
  set_cgroup_dir $CGRP
  [[ -e $CGRP_DIR/$FILE ]] || return 1
  ACTUAL_CPUS=$(cat $CGRP_DIR/$FILE)
  [[ $EXPECTED_CPUS = $ACTUAL_CPUS ]] || 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
  EXPECTED_STATE=$2
  FILE=
  EVAL=$(expr substr $EXPECTED_STATE 2 2)

  set_cgroup_dir $CGRP
  case $EXPECTED_STATE in
   P*) FILE=$CGRP_DIR/cpuset.cpus.partition
       ;;
   *)  echo "Unknown state: $EXPECTED_STATE!"
       exit 1
       ;;
  esac
  ACTUAL_STATE=$(cat $FILE)

  case "$ACTUAL_STATE" 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_DIR] 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()
{
 EXPECTED_ISOLCPUS=$1
 ISCPUS=${CGROUP2}/cpuset.cpus.isolated
 ISOLCPUS=$(cat $ISCPUS)
 LASTISOLCPU=
 SCHED_DOMAINS=/sys/kernel/debug/sched/domains
 if [[ $EXPECTED_ISOLCPUS = . ]]
 then
  EXPECTED_ISOLCPUS=
  EXPECTED_SDOMAIN=
 elif [[ $(expr $EXPECTED_ISOLCPUS : ".*|.*") > 0 ]]
 then
  set -- $(echo $EXPECTED_ISOLCPUS | sed -e "s/|/ /g")
  EXPECTED_ISOLCPUS=$2
  EXPECTED_SDOMAIN=$1
 else
  EXPECTED_SDOMAIN=$EXPECTED_ISOLCPUS
 fi

 #
 # Appending pre-isolated CPUs
 # Even though CPU #8 isn't used for testing, it can't be pre-isolated
 # to make appending those CPUs easier.
 #
 [[ -n "$BOOT_ISOLCPUS" ]] && {
  EXPECTED_ISOLCPUS=${EXPECTED_ISOLCPUS:+${EXPECTED_ISOLCPUS},}${BOOT_ISOLCPUS}
  EXPECTED_SDOMAIN=${EXPECTED_SDOMAIN:+${EXPECTED_SDOMAIN},}${BOOT_ISOLCPUS}
 }

 #
 # Check cpuset.cpus.isolated cpumask
 #
 [[ "$EXPECTED_ISOLCPUS" != "$ISOLCPUS" ]] && {
  # Take a 50ms pause and try again
  pause 0.05
  ISOLCPUS=$(cat $ISCPUS)
 }
 [[ "$EXPECTED_ISOLCPUS" != "$ISOLCPUS" ]] && return 1
 ISOLCPUS=
 EXPECTED_ISOLCPUS=$EXPECTED_SDOMAIN

 #
 # 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

 [[ "$EXPECTED_SDOMAIN" = "$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
}

#
# Check state transition test result
#  $1 - Test number
#  $2 - Expected effective CPU values
#  $3 - Expected partition states
#  $4 - Expected isolated CPUs
#
check_test_results()
{
 _NR=$1
 _ECPUS="$2"
 _PSTATES="$3"
 _ISOLCPUS="$4"

 [[ -n "$_ECPUS" && "$_ECPUS" != . ]] && {
  check_effective_cpus $_ECPUS
  [[ $? -ne 0 ]] && test_fail $_NR "effective CPU" \
    "Cgroup $CGRP: expected $EXPECTED_CPUS, got $ACTUAL_CPUS"
 }

 [[ -n "$_PSTATES" && "$_PSTATES" != . ]] && {
  check_cgroup_states $_PSTATES
  [[ $? -ne 0 ]] && test_fail $_NR states \
   "Cgroup $CGRP: expected $EXPECTED_STATE, got $ACTUAL_STATE"
 }

 # Compare the expected isolated CPUs with the actual ones,
 # if available
 [[ -n "$_ISOLCPUS" ]] && {
  check_isolcpus $_ISOLCPUS
  [[ $? -ne 0 ]] && {
   [[ -n "$BOOT_ISOLCPUS" ]] && _ISOLCPUS=${_ISOLCPUS},${BOOT_ISOLCPUS}
   test_fail $_NR "isolated CPU" \
    "Expect $_ISOLCPUS, get $ISOLCPUS instead"
  }
 }
 reset_cgroup_states
 #
 # Check to see if effective cpu list changes
 #
 _NEWLIST=$(cat $CGROUP2/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 $CGROUP2/cpuset.cpus.effective)
 done
 [[ $_NEWLIST != $CPULIST ]] && {
  echo "Effective cpus changed to $_NEWLIST after test $_NR!"
  exit 1
 }
 null_isolcpus_check
 [[ $VERBOSE -gt 0 ]] && echo "Test $I done."
}

#
# 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
 CGROUP_LIST=". A1 A1/A2 A1/A2/A3 B1"
 RESET_LIST="A1/A2/A3 A1/A2 A1 B1"
 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 A1       $OLD_A1
  set_ctrl_state_noerr A1/A2    $OLD_A2
  set_ctrl_state_noerr A1/A2/A3 $OLD_A3
  set_ctrl_state_noerr B1       $OLD_B1

  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

  check_test_results $I "$ECPUS" "$STATES" "$ICPUS"
  ((I++))
 done
 echo "All $I tests of $TEST PASSED."
}

#
# Run cpuset remote partition state transition test
#  $1 - test matrix name
#
run_remote_state_test()
{
 TEST=$1
 CONTROLLER=cpuset
 [[ -d rtest ]] || mkdir rtest
 cd rtest
 echo +cpuset > cgroup.subtree_control
 echo "1-7" > cpuset.cpus
 echo "1-7" > cpuset.cpus.exclusive
 CGROUP_LIST=".. . p1 p2 p1/c11 p1/c12 p2/c21 p2/c22"
 RESET_LIST="p1/c11 p1/c12 p2/c21 p2/c22 p1 p2"
 I=0
 eval CNT="\${#$TEST[@]}"

 reset_cgroup_states
 console_msg "Running remote partition 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_p1=$1
  OLD_p2=$2
  OLD_c11=$3
  OLD_c12=$4
  OLD_c21=$5
  OLD_c22=$6
  NEW_p1=$7
  NEW_p2=$8
  NEW_c11=$9
  NEW_c12=${10}
  NEW_c21=${11}
  NEW_c22=${12}
  ECPUS=${13}
  STATES=${14}
  ICPUS=${15}

  set_ctrl_state_noerr p1     $OLD_p1
  set_ctrl_state_noerr p2     $OLD_p2
  set_ctrl_state_noerr p1/c11 $OLD_c11
  set_ctrl_state_noerr p1/c12 $OLD_c12
  set_ctrl_state_noerr p2/c21 $OLD_c21
  set_ctrl_state_noerr p2/c22 $OLD_c22

  RETVAL=0
  set_ctrl_state p1     $NEW_p1 ; ((RETVAL += $?))
  set_ctrl_state p2     $NEW_p2 ; ((RETVAL += $?))
  set_ctrl_state p1/c11 $NEW_c11; ((RETVAL += $?))
  set_ctrl_state p1/c12 $NEW_c12; ((RETVAL += $?))
  set_ctrl_state p2/c21 $NEW_c21; ((RETVAL += $?))
  set_ctrl_state p2/c22 $NEW_c22; ((RETVAL += $?))

  [[ $RETVAL -ne 0 ]] && test_fail $I result

  check_test_results $I "$ECPUS" "$STATES" "$ICPUS"
  ((I++))
 done
 cd ..
 rmdir rtest
 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
 pause 0.05
}

#
# 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
 echo member > cpuset.cpus.partition
 echo "" > cpuset.cpus
}

trap cleanup 0 2 3 6
run_state_test TEST_MATRIX
run_remote_state_test REMOTE_TEST_MATRIX
test_isolated
test_inotify
echo "All tests PASSED."