Re: [PATCH 0/5] cacheinfo, powerpc: Move powerpc to generic cacheinfo

From: Shrikanth Hegde

Date: Thu Nov 19 2026 - 04:30:43 EST


+samir, Venkat


Tested the values compatibilty on Power11 Dedicated and Shared LPAR's.
All the values are same, except id and uevent which was not there
before. That should help rather than hurt any tool.

This may need more broader checks on different boards/configuration
to ensure it is same. Also DLPAR CPU add/remove is not tested yet.
Please test and report if your board/platform shows up any different
values in those cache entries.


Could you please help to run DLPAR and ensure the cache sysfs entries remain
same. Also if you have a P7/P8 it would be great if you validate there as well.

Please find the below script that i used to do the verification.
(Again, thanks to LLM)

---

#!/usr/bin/env bash
#
# Validate PowerPC cacheinfo before and after migration to generic cacheinfo.
#
# Usage:
# sudo ./validate-cacheinfo.sh capture before
#
# # Reboot into the patched kernel
#
# sudo ./validate-cacheinfo.sh capture after
# sudo ./validate-cacheinfo.sh compare before after
#
# Expected additions from generic cacheinfo:
# index*/id
# index*/uevent
#
# These attributes are excluded from the compatibility comparison.
#

set -euo pipefail

SYS_CPU=/sys/devices/system/cpu

die()
{
echo "ERROR: $*" >&2
exit 1
}

command_exists()
{
command -v "$1" >/dev/null 2>&1
}

capture_file()
{
local source=$1
local destination=$2

if [[ -r "$source" ]]; then
cat "$source" > "$destination"
else
printf '<unavailable>\n' > "$destination"
fi
}

capture_cache_sysfs()
{
local output=$1
local cpu_dir cache_dir index attr
local cpu index_name value

: > "$output"

for cpu_dir in "$SYS_CPU"/cpu[0-9]*; do
[[ -d "$cpu_dir" ]] || continue

cpu=${cpu_dir##*/cpu}
cache_dir="$cpu_dir/cache"

echo "Capturing CPU $cpu" >&2

if [[ ! -d "$cache_dir" ]]; then
printf '%s\t%s\t%s\t%s\n' \
"$cpu" \
"<none>" \
"<cache-directory>" \
"<absent>" \
>> "$output"
continue
fi

for index in "$cache_dir"/index*; do
[[ -d "$index" ]] || continue

index_name=${index##*/}

#
# Do not use find -type f. Sysfs attributes are virtual
# files and may not be classified consistently by all
# find implementations.
#
for attr in "$index"/*; do
[[ -e "$attr" || -L "$attr" ]] || continue
[[ ! -d "$attr" ]] || continue
[[ -r "$attr" ]] || continue

value=$(
tr '\n' ' ' < "$attr" |
sed 's/[[:space:]]*$//'
)

printf '%s\t%s\t%s\t%s\n' \
"$cpu" \
"$index_name" \
"${attr##*/}" \
"$value" \
>> "$output"
done
done
done

sort -t $'\t' \
-k1,1n \
-k2,2V \
-k3,3 \
"$output" -o "$output"
}

generate_compatibility_view()
{
local snapshot=$1

#
# The old PowerPC implementation did not expose id or uevent.
# Exclude both when checking whether existing ABI values changed.
#
awk -F $'\t' '
$3 != "id" && $3 != "uevent" {
print
}
' "$snapshot/cacheinfo.tsv" \
> "$snapshot/cacheinfo-compatible.tsv"
}

generate_id_view()
{
local snapshot=$1
local cpu index attribute value

: > "$snapshot/cache-ids.tsv"

while IFS=$'\t' read -r cpu index attribute value; do
if [[ "$attribute" == "id" ]]; then
printf '%s\t%s\t%s\n' \
"$cpu" "$index" "$value" \
>> "$snapshot/cache-ids.tsv"
fi
done < "$snapshot/cacheinfo.tsv"
}

generate_uevent_view()
{
local snapshot=$1
local cpu index attribute value

: > "$snapshot/cache-uevents.tsv"

while IFS=$'\t' read -r cpu index attribute value; do
if [[ "$attribute" == "uevent" ]]; then
printf '%s\t%s\t%s\n' \
"$cpu" "$index" "$value" \
>> "$snapshot/cache-uevents.tsv"
fi
done < "$snapshot/cacheinfo.tsv"
}

capture_snapshot()
{
local output=$1
local leaves ids uevents

[[ -n "$output" ]] || die "capture directory is required"
[[ ! -e "$output" ]] || die "$output already exists"

mkdir -p "$output"

uname -a > "$output/uname.txt"
capture_file /proc/version "$output/version.txt"
capture_file /proc/cmdline "$output/cmdline.txt"

capture_file "$SYS_CPU/online" "$output/cpus-online.txt"
capture_file "$SYS_CPU/offline" "$output/cpus-offline.txt"
capture_file "$SYS_CPU/possible" "$output/cpus-possible.txt"
capture_file "$SYS_CPU/present" "$output/cpus-present.txt"

capture_cache_sysfs "$output/cacheinfo.tsv"

generate_compatibility_view "$output"
generate_id_view "$output"
generate_uevent_view "$output"

if command_exists lscpu; then
timeout 60 lscpu \
> "$output/lscpu.txt" 2>&1 || true

timeout 60 lscpu -C \
> "$output/lscpu-cache.txt" 2>&1 || true

timeout 60 lscpu -e=CPU,CORE,SOCKET,NODE,CACHE \
> "$output/lscpu-extended.txt" 2>&1 || true

#
# Exclude CACHE from the automatically compared view because
# lscpu may switch from userspace-generated contiguous numbers
# to sparse kernel-provided cache IDs.
#
timeout 60 lscpu -e=CPU,CORE,SOCKET,NODE \
> "$output/lscpu-topology.txt" 2>&1 || true
fi

dmesg > "$output/dmesg.txt" 2>/dev/null || true

leaves=$(
awk -F $'\t' '
$3 == "level" {
count++
}
END {
print count + 0
}
' "$output/cacheinfo.tsv"
)

ids=$(wc -l < "$output/cache-ids.tsv")
uevents=$(wc -l < "$output/cache-uevents.tsv")

echo
echo "Captured snapshot: $output"
echo "Cache leaves: $leaves"
echo "Cache IDs: $ids"
echo "Cache uevents: $uevents"

if [[ "$ids" -eq 0 ]]; then
echo "No cache IDs found."
echo "This is expected for the old PowerPC cacheinfo implementation."
fi

if [[ "$uevents" -eq 0 ]]; then
echo "No cache uevent files found."
echo "This is expected for the old PowerPC cacheinfo implementation."
fi
}

expand_cpu_list()
{
local list=$1
local item first last cpu
local -a elements

IFS=',' read -r -a elements <<< "$list"

for item in "${elements[@]}"; do
if [[ "$item" == *-* ]]; then
first=${item%-*}
last=${item#*-}

for ((cpu = first; cpu <= last; cpu++)); do
echo "$cpu"
done
else
echo "$item"
fi
done
}

build_leaf_records()
{
local snapshot=$1
local output=$2

awk -F $'\t' '
{
key = $1 SUBSEP $2
value[key, $3] = $4
seen[key] = 1
}
END {
for (key in seen) {
split(key, part, SUBSEP)

if (part[2] == "<none>")
continue

printf "%s\t%s\t%s\t%s\t%s\t%s\n",
part[1],
part[2],
value[key, "level"],
value[key, "type"],
value[key, "id"],
value[key, "shared_cpu_list"]
}
}' "$snapshot/cacheinfo.tsv" |
sort -t $'\t' -k1,1n -k2,2V > "$output"
}

lookup_leaf_field()
{
local records=$1
local cpu=$2
local level=$3
local type=$4
local field=$5

awk -F $'\t' \
-v cpu="$cpu" \
-v level="$level" \
-v type="$type" \
-v field="$field" '
$1 == cpu && $3 == level && $4 == type {
if (field == "id")
print $5
else if (field == "shared")
print $6
exit
}
' "$records"
}

validate_new_ids()
{
local snapshot=$1
local records
local cpu index level type id shared
local sibling sibling_id sibling_shared
local failed=0

records=$(mktemp)
build_leaf_records "$snapshot" "$records"

echo
echo "Validating generic cache IDs..."

while IFS=$'\t' read -r cpu index level type id shared; do
if [[ -z "$id" ]]; then
echo "ERROR: cpu${cpu}/${index} has no id"
failed=1
continue
fi

if [[ -z "$shared" ]]; then
echo "ERROR: cpu${cpu}/${index} has no shared_cpu_list"
failed=1
continue
fi

#
# Every CPU in shared_cpu_list must report the same ID and
# shared CPU list for a leaf of the same level and type.
#
while IFS= read -r sibling; do
sibling_id=$(
lookup_leaf_field \
"$records" \
"$sibling" \
"$level" \
"$type" \
"id"
)

sibling_shared=$(
lookup_leaf_field \
"$records" \
"$sibling" \
"$level" \
"$type" \
"shared"
)

if [[ -z "$sibling_id" ]]; then
echo "ERROR: cpu${cpu}/${index}: CPU ${sibling}" \
"has no L${level} ${type} cache ID"
failed=1
elif [[ "$sibling_id" != "$id" ]]; then
echo "ERROR: cpu${cpu}/${index}: ID is ${id}," \
"but CPU ${sibling} has ID ${sibling_id}"
failed=1
fi

if [[ -z "$sibling_shared" ]]; then
echo "ERROR: cpu${cpu}/${index}: CPU ${sibling}" \
"has no L${level} ${type} shared_cpu_list"
failed=1
elif [[ "$sibling_shared" != "$shared" ]]; then
echo "ERROR: cpu${cpu}/${index}: shared list is" \
"${shared}, but CPU ${sibling} reports" \
"${sibling_shared}"
failed=1
fi
done < <(expand_cpu_list "$shared")
done < "$records"

rm -f "$records"

if (( failed )); then
echo "Cache ID validation: FAILED"
return 1
fi

echo "Cache ID validation: PASS"
}

compare_file()
{
local description=$1
local before=$2
local after=$3

echo
echo "Comparing $description..."

if diff -u "$before" "$after"; then
echo "$description: PASS"
return 0
fi

echo "$description: FAILED"
return 1
}

compare_snapshots()
{
local before=$1
local after=$2
local failed=0
local before_ids after_ids
local before_uevents after_uevents

[[ -f "$before/cacheinfo-compatible.tsv" ]] ||
die "$before is not a valid snapshot"

[[ -f "$after/cacheinfo-compatible.tsv" ]] ||
die "$after is not a valid snapshot"

if ! compare_file \
"cache sysfs values excluding id and uevent" \
"$before/cacheinfo-compatible.tsv" \
"$after/cacheinfo-compatible.tsv"; then
failed=1
fi

for mask in online offline possible present; do
if ! compare_file \
"CPU ${mask} mask" \
"$before/cpus-${mask}.txt" \
"$after/cpus-${mask}.txt"; then
failed=1
fi
done

if [[ -f "$before/lscpu-topology.txt" &&
-f "$after/lscpu-topology.txt" ]]; then
if ! compare_file \
"lscpu topology without cache IDs" \
"$before/lscpu-topology.txt" \
"$after/lscpu-topology.txt"; then
failed=1
fi
fi

before_ids=$(wc -l < "$before/cache-ids.tsv")
after_ids=$(wc -l < "$after/cache-ids.tsv")

before_uevents=$(wc -l < "$before/cache-uevents.tsv")
after_uevents=$(wc -l < "$after/cache-uevents.tsv")

echo
echo "Expected generic-cacheinfo additions:"
echo " Before IDs: $before_ids"
echo " After IDs: $after_ids"
echo " Before uevents: $before_uevents"
echo " After uevents: $after_uevents"

if [[ "$after_ids" -eq 0 ]]; then
echo "ERROR: patched kernel exposes no index*/id attributes"
failed=1
fi

if [[ "$after_uevents" -eq 0 ]]; then
echo "ERROR: patched kernel exposes no index*/uevent attributes"
failed=1
fi

echo
echo "Cache IDs exposed by generic cacheinfo:"

if [[ -s "$after/cache-ids.tsv" ]]; then
if command_exists column; then
{
printf 'CPU\tINDEX\tID\n'
cat "$after/cache-ids.tsv"
} | column -t -s $'\t'
else
cat "$after/cache-ids.tsv"
fi
fi

if ! validate_new_ids "$after"; then
failed=1
fi

echo
echo "Informational files for manual inspection:"
echo " $before/lscpu-cache.txt"
echo " $after/lscpu-cache.txt"
echo " $before/lscpu-extended.txt"
echo " $after/lscpu-extended.txt"
echo
echo "The lscpu CACHE column may legitimately change from contiguous"
echo "userspace-generated values to sparse kernel-provided cache IDs."
echo
echo "The new id and uevent files are treated as expected ABI additions"
echo "and are excluded from the compatibility diff."

if (( failed )); then
echo
echo "Overall result: FAILED"
return 1
fi

echo
echo "Overall result: PASS"
}

usage()
{
cat <<EOF
Usage:
$0 capture <directory>
$0 compare <before-directory> <after-directory>

Example:
sudo $0 capture before
# Reboot into the patched kernel
sudo $0 capture after
sudo $0 compare before after
EOF
}

[[ $# -ge 1 ]] || {
usage
exit 1
}

case "$1" in
capture)
[[ $# -eq 2 ]] ||
die "capture requires one output directory"

capture_snapshot "$2"
;;

compare)
[[ $# -eq 3 ]] ||
die "compare requires before and after directories"

compare_snapshots "$2" "$3"
;;

*)
usage
exit 1
;;
esac