All of lore.kernel.org
 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 [PATCH 0/5] cacheinfo, powerpc: Move powerpc to generic cacheinfo 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 an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.