mirror of https://lore.kernel.org/lkml/
 help / color / mirror / Atom feed
From: Shrikanth Hegde <sshegde@linux.ibm.com>
To: linuxppc-dev@lists.ozlabs.org, linux-kernel@vger.kernel.org,
	driver-core@lists.linux.dev, Samir M <samir@linux.ibm.com>,
	Venkat Rao Bagalkote <venkat88@linux.ibm.com>
Cc: christophe.leroy@csgroup.eu, maddy@linux.ibm.com,
	gregkh@linuxfoundation.org, rafael@kernel.org, dakr@kernel.org,
	johan@kernel.org, sudeep.holla@kernel.org, ritesh.list@gmail.com,
	tim.c.chen@linux.intel.com, yu.c.chen@intel.com,
	Srikar Dronamraju <srikar@linux.ibm.com>
Subject: Re: [PATCH 0/5] cacheinfo, powerpc: Move powerpc to generic cacheinfo
Date: Thu, 19 Nov 2026 15:00:13 +0530	[thread overview]
Message-ID: <d76a72b5-e489-47fe-81bd-a3bf5935c209@linux.ibm.com> (raw)
In-Reply-To: <20261118163639.890546-1-sshegde@linux.ibm.com>

+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


      parent reply	other threads:[~2026-11-19  9:30 UTC|newest]

Thread overview: 13+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-11-18 16:36 Shrikanth Hegde
2026-11-18 16:36 ` [PATCH 1/5] cacheinfo: Allow architectures to provide custom cache IDs Shrikanth Hegde
2026-11-19  6:36   ` Srikar Dronamraju
2026-11-19  9:21     ` Shrikanth Hegde
2026-11-18 16:36 ` [PATCH 2/5] cacheinfo: Support unified caches described by d-cache properties Shrikanth Hegde
2026-11-19  6:44   ` Srikar Dronamraju
2026-11-19  9:22     ` Shrikanth Hegde
2026-11-18 16:36 ` [PATCH 3/5] cacheinfo: Add teardown and rebuild helpers Shrikanth Hegde
2026-11-18 16:36 ` [PATCH 4/5] powerpc/cacheinfo: Move to generic cacheinfo Shrikanth Hegde
2026-11-19  8:24   ` Srikar Dronamraju
2026-11-19  9:25     ` Shrikanth Hegde
2026-11-18 16:36 ` [PATCH 5/5] sched/topology: Remove stale comment around llc_bytes on powerpc Shrikanth Hegde
2026-11-19  9:30 ` Shrikanth Hegde [this message]

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=d76a72b5-e489-47fe-81bd-a3bf5935c209@linux.ibm.com \
    --to=sshegde@linux.ibm.com \
    --cc=christophe.leroy@csgroup.eu \
    --cc=dakr@kernel.org \
    --cc=driver-core@lists.linux.dev \
    --cc=gregkh@linuxfoundation.org \
    --cc=johan@kernel.org \
    --cc=linux-kernel@vger.kernel.org \
    --cc=linuxppc-dev@lists.ozlabs.org \
    --cc=maddy@linux.ibm.com \
    --cc=rafael@kernel.org \
    --cc=ritesh.list@gmail.com \
    --cc=samir@linux.ibm.com \
    --cc=srikar@linux.ibm.com \
    --cc=sudeep.holla@kernel.org \
    --cc=tim.c.chen@linux.intel.com \
    --cc=venkat88@linux.ibm.com \
    --cc=yu.c.chen@intel.com \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox

all inboxes | Powered by JetHome®