+objtool-args-$(CONFIG_CALL_PADDING) += --prefix=$(CONFIG_FUNCTION_PADDING_BYTES)

+ifdef CONFIG_CALL_PADDING

+objtool-args-$(CONFIG_CFI) += --cfi

+objtool-args-$(CONFIG_FINEIBT) += --fineibt

+endif

+def show_irq_desc(prec, chip_width, irq):

+ text += "%10u " % (count)

+ text += " %-*s" % (chip_width, name)

+def x86_show_irqstat(prec, pfx, idx, desc):

+ irq_stat = gdb.parse_and_eval("&irq_stat.counts[%d]" %idx)

+ text += "%10u " % (stat.dereference())

+ text += desc

+ info_type = gdb.lookup_type('struct irq_stat_info')

+ info = gdb.parse_and_eval('irq_stat_info')

+ bitmap = gdb.parse_and_eval('irq_stat_count_show')

+ bitsperlong = 8 * int(bitmap.type.target().sizeof)

+ text = ""

+ for idx in range(int(info.type.sizeof / info_type.sizeof)):

+ show = bitmap[int(idx / bitsperlong)]

+ if not show & 1 << int(idx % bitsperlong):

+ continue

+ pfx = info[idx]['symbol'].string()

+ desc = info[idx]['text'].string()

+ text += x86_show_irqstat(prec, pfx, idx, desc)

+ text += "%*s%u: " % (prec - 1, "IPI", ipi)

+ text += "%10u " % (cpus.per_cpu(desc['kstat_irqs'], cpu)['cnt'])

+ text += "%s" % (ipi_types[ipi].string())

+ # Does not work for ARM64 as "ipi_desc" is not available there

+ nr_irqs = gdb.parse_and_eval("total_nr_irqs")

+ constr = utils.gdb_eval_or_none('irq_proc_constraints')

+

+ if constr:

+ prec = int(constr['num_prec'])

+ chip_width = int(constr['chip_width'])

+ else:

+ prec = 4

+ j = 10000

+ while prec < 10 and j <= nr_irqs:

+ prec += 1

+ j *= 10

+ chip_width = 8

+ gdb.write(show_irq_desc(prec, chip_width, irq))

+# shellcheck disable=SC1090,SC2155,SC2164

+# This helps keep execution in pipes so pipefail+ERR trap can catch errors.

+unset DEBUG_CLONE DIFF_CHECKSUM SKIP_CLEANUP VERBOSE XTRACE

+OBJTOOL="$PWD/tools/objtool/objtool"

+CONFIG="$PWD/.config"

+TMP_DIR="$PWD/klp-tmp"

+ORIG_DIR="$TMP_DIR/1-orig"

+PATCHED_DIR="$TMP_DIR/2-patched"

+ORIG_CSUM_DIR="$TMP_DIR/3-checksum-orig"

+PATCHED_CSUM_DIR="$TMP_DIR/3-checksum-patched"

+DIFF_DIR="$TMP_DIR/4-diff"

+KMOD_DIR="$TMP_DIR/5-kmod"

+ local rel_file="${file#"$PWD"/}"

+ mv -f "$STASH_DIR/$file" "$PWD/$file" || warn "can't restore file: $file"

+ 1|orig Build original kernel (default)

+ 2|patched Build patched kernel

+ 3|checksum Generate checksums

+ 4|diff Diff objects

+ 5|kmod Build patch module

+ local patch

+ VERBOSE=1

+ 1 | orig) SHORT_CIRCUIT=1; ;;

+ 2 | patched) SHORT_CIRCUIT=2; ;;

+ 3 | checksum) SHORT_CIRCUIT=3; ;;

+ 4 | diff) SHORT_CIRCUIT=4; ;;

+ 5 | kmod) SHORT_CIRCUIT=5; ;;

+

+ for patch in "${PATCHES[@]}"; do

+ [[ -f "$patch" ]] || die "$patch doesn't exist"

+ done

+ [[ -x "$OBJTOOL" ]] && "$OBJTOOL" klp 2>&1 | command grep -q "not implemented" && \

+ die "objtool not built with KLP support; install xxhash-devel/libxxhash-dev (version >= 0.8) and recompile"

+

+ local file="$PWD/scripts/setlocalversion"

+ if [[ -n "$(make -s listnewconfig 2>/dev/null)" ]]; then

+ die ".config mismatch, check your .config or run 'make olddefconfig'"

+ fi

+ make syncconfig &>/dev/null || die "make syncconfig failed"

+

+ kernelrelease="$(make -s kernelrelease)"

+ lib/*|*/vdso/*|*/realmode/rm/*|*.S)

+ output=$(patch -p1 --dry-run --no-backup-if-mismatch -r /dev/null "${extra_args[@]}" < "$patch" 2>&1) || status=$?

+ [[ -v VERBOSE ]] && echo "$output" >&2

+ patch -p1 --no-backup-if-mismatch -r /dev/null "${extra_args[@]}" --silent < "$patch"

+ patch -p1 -R --force --no-backup-if-mismatch -r /dev/null &> /dev/null < "$patch" || true

+ [[ ! "$PWD" -ef "$SCRIPT_DIR/../.." ]] && die "please run from the kernel root directory"

+

+ if (( SHORT_CIRCUIT >= 2 )); then

+ [[ -f "$ORIG_DIR/.complete" ]] || die "-S $SHORT_CIRCUIT requires completed $ORIG_DIR"

+ fi

+ if (( SHORT_CIRCUIT >= 3 )); then

+ [[ -f "$PATCHED_DIR/.complete" ]] || die "-S $SHORT_CIRCUIT requires completed $PATCHED_DIR"

+ fi

+ if (( SHORT_CIRCUIT >= 4 )); then

+ [[ -f "$ORIG_CSUM_DIR/.complete" ]] || die "-S $SHORT_CIRCUIT requires completed $ORIG_CSUM_DIR"

+ [[ -f "$PATCHED_CSUM_DIR/.complete" ]] || die "-S $SHORT_CIRCUIT requires completed $PATCHED_CSUM_DIR"

+ fi

+ if (( SHORT_CIRCUIT >= 5 )); then

+ [[ -f "$DIFF_DIR/.complete" ]] || die "-S $SHORT_CIRCUIT requires completed $DIFF_DIR"

+ fi

+ echo "${input_files[@]}" | xargs cp --parents --target-directory="$tmpdir/a"

+ echo "${output_files[@]}" | xargs cp --parents --target-directory="$tmpdir/b"

+ "${cmd[@]}"

+ if [[ -v VERBOSE ]]; then

+ cmd+=("V=1")

+ else

+ cmd+=("-s")

+ fi

+ "${cmd[@]}" \

+ 1> >(tee -a "$log") \

+ 2> >(tee -a "$log" | grep0 -v "modpost.*undefined!" >&2) \

+ || die "$build kernel build failed"

+ find "$PWD" \( -path "$TMP_DIR" -o -path "$PWD/.git" -o -regex "$PWD/[^/][^/]*\.ko" \) -prune -o \

+ \( -name "*.ko" -o -path "$PWD/vmlinux.o" \) \

+ xtrace_save "copying original objects"

+ local file="$PWD/$rel_file"

+ touch "$ORIG_DIR/.complete"

+ local file="$PWD/$rel_file"

+ touch "$PATCHED_DIR/.complete"

+}

+

+# Copy .o files to a separate directory and run "objtool klp checksum" on each

+# copy. The checksums are written to a .discard.sym_checksum section.

+#

+# If match_dir is given, only process files which also exist there.

+generate_checksums() {

+ local src_dir="$1"

+ local dest_dir="$2"

+ local match_dir="${3:-}"

+ local files=()

+ local file

+

+ rm -rf "$dest_dir"

+ mkdir -p "$dest_dir"

+

+ find "$src_dir" -type f -name "*.o" | mapfile -t files

+ for file in "${files[@]}"; do

+ local rel="${file#"$src_dir"/}"

+ local dest="$dest_dir/$rel"

+

+ [[ -n "$match_dir" && ! -f "$match_dir/$rel" ]] && continue

+

+ mkdir -p "$(dirname "$dest")"

+ cp -f "$file" "$dest"

+ "$OBJTOOL" klp checksum "$dest"

+ done

+

+ touch "$dest_dir/.complete"

+ find "$PATCHED_CSUM_DIR" -type f -name "*.o" | mapfile -t files

+ local rel_file="${file#"$PATCHED_CSUM_DIR"/}"

+ local patched_file="$PATCHED_CSUM_DIR/$rel_file"

+ cmd=("$OBJTOOL")

+ cd "$ORIG_CSUM_DIR"

+ [[ -v VERBOSE ]] && echo "cd $ORIG_CSUM_DIR && ${cmd[*]}"

+

+ touch "$DIFF_DIR/.complete"

+# For each changed object, run "objtool klp checksum" with --debug-checksum to

+# get the per-instruction checksums, and then diff those to find the first

+# changed instruction for each function.

+ cmd=("$OBJTOOL")

+ cmd+=("klp" "checksum")

+ ( cat "$orig_log" >&2; die "objtool klp checksum failed" )

+ ( cat "$patched_log" >&2; die "objtool klp checksum failed" )

+ local -a orig patched

+ paste <(grep0 -E "^DEBUG: .*checksum: $func " "$orig_log") \

+ <(grep0 -E "^DEBUG: .*checksum: $func " "$patched_log") |

+ while IFS= read -r line; do

+ read -ra orig <<< "${line%%$'\t'*}"

+ read -ra patched <<< "${line#*$'\t'}"

+

+ if [[ ${#patched[@]} -eq 0 ]]; then

+ printf "%s: %s: %s (removed)\n" "${orig[1]%:}" "${orig[3]}" "${orig[-2]}"

+ break

+ elif [[ ${#orig[@]} -eq 0 ]]; then

+ printf "%s: %s: %s (added)\n" "${patched[1]%:}" "${patched[3]}" "${patched[-2]}"

+ break

+ fi

+

+ [[ "${orig[-1]}" == "${patched[-1]}" ]] && continue

+

+ printf "%s: %s: %s" "${orig[1]%:}" "${orig[3]}" "${orig[-2]}"

+ [[ "${orig[-2]}" != "${patched[-2]}" ]] && \

+ printf " (patched: %s)" "${patched[-2]}"

+ printf "\n"

+ break

+ done || true

+ cp -f "$SCRIPT_DIR/init.c" "$KMOD_DIR"

+ if [[ -v VERBOSE ]]; then

+ cmd+=("V=1")

+ else

+ cmd+=("-s")

+ fi

+ "${cmd[@]}" \

+ 1> >(tee -a "$log") \

+ 2> >(tee -a "$log" >&2)

+ "$OBJTOOL" klp post-link "$kmod_file" || die "objtool klp post-link failed"

+ status "Generating original checksums"

+ generate_checksums "$ORIG_DIR" "$ORIG_CSUM_DIR" "$PATCHED_DIR"

+ status "Generating patched checksums"

+ generate_checksums "$PATCHED_DIR" "$PATCHED_CSUM_DIR"

+fi

+

+if (( SHORT_CIRCUIT <= 4 )); then

+if (( SHORT_CIRCUIT <= 5 )); then

+#!/usr/bin/env python3

+# SPDX-License-Identifier: GPL-2.0

+

+"""

+Draw the timer migration tree.

+

+1) Boot with trace_event==tmigr_connect_cpu_parent,tmigr_connect_child_parent

+2) ./timer_migration_tree.py < /sys/kernel/tracing/trace

+"""

+

+import re, sys

+from ete3 import Tree

+

+class Node:

+ def __init__(self, group):

+ self.group = group

+ self.children = []

+ self.parent = None

+ self.num_children = 0

+ self.groupmask = 0

+ self.lvl = -1

+

+ def set_groupmask(self, groupmask):

+ self.groupmask = groupmask

+

+ def set_parent(self, parent):

+ self.parent = parent

+

+ def add_child(self, child):

+ self.children.append(child)

+

+ def set_lvl(self, lvl):

+ self.lvl = lvl

+

+ def set_numa(self, numa):

+ self.numa = numa

+

+ def set_num_children(self, num_children):

+ self.num_children = num_children

+

+ def __repr__(self):

+ if self.parent:

+ parent_grp = self.parent.group

+ else:

+ parent_grp = "-"

+ return "Group: %s mask: %s parent: %s lvl: %d numa: %d num_children: %d" % (self.group, self.groupmask, parent_grp, self.lvl, self.numa, self.num_children)

+

+hierarchies = { }

+

+def get_hierarchy(capacity):

+ if capacity not in hierarchies:

+ hierarchies[capacity] = {}

+ return hierarchies[capacity]

+

+def get_node(capacity, group):

+ hier = get_hierarchy(capacity)

+ if group in hier:

+ return hier[group]

+ else:

+ n = Node(group)

+ hier[group] = n

+ return n

+

+def tmigr_connect_cpu_parent(ts, line):

+ s = re.search("tmigr_connect_cpu_parent: cpu=([0-9]+) groupmask=([0-9a-zA-Z]+) parent=([0-9a-zA-Z]+) lvl=([0-9]+) numa=([-]?[0-9]+) capacity=([-]?[0-9]+) num_children=([0-9]+)", line)

+ if s is None:

+ return False

+ (cpu, groupmask, parent, lvl, numa, capacity, num_children) = (int(s.group(1)), s.group(2), s.group(3), int(s.group(4)), int(s.group(5)), int(s.group(6)), int(s.group(7)))

+ n = get_node(capacity, cpu)

+ p = get_node(capacity, parent)

+ n.set_parent(p)

+ n.set_groupmask(groupmask)

+ n.set_lvl(-1)

+ p.set_lvl(lvl)

+ p.set_numa(numa)

+ n.set_numa(numa)

+ p.set_num_children(num_children)

+ p.add_child(n)

+

+def tmigr_connect_child_parent(ts, line):

+ s = re.search("tmigr_connect_child_parent: group=([0-9a-zA-Z]+) groupmask=([0-9a-zA-Z]+) parent=([0-9a-zA-Z]+) lvl=([0-9]+) numa=([-]?[0-9]+) capacity=([-]?[0-9]+) num_children=([0-9]+)", line)

+ if s is None:

+ return False

+ (group, groupmask, parent, lvl, numa, capacity, num_children) = (s.group(1), s.group(2), s.group(3), int(s.group(4)), int(s.group(5)), int(s.group(6)), int(s.group(7)))

+ n = get_node(capacity, group)

+ p = get_node(capacity, parent)

+ n.set_parent(p)

+ n.set_groupmask(groupmask)

+ p.set_lvl(lvl)

+ p.set_numa(numa)

+ p.set_num_children(num_children)

+ p.add_child(n)

+

+def populate(enode, node):

+ enode = enode.add_child(name = node.group)

+ enode.add_feature("groupmask", "m:%s" % node.groupmask)

+ enode.add_feature("lvl", "lvl:%d" % node.lvl)

+ enode.add_feature("numa", "node %d" % node.numa)

+ enode.add_feature("num_children", "c=%d" % node.num_children)

+ for child in node.children:

+ populate(enode, child)

+

+if __name__ == "__main__":

+ for line in sys.stdin:

+ s = re.search("([0-9]+[.][0-9]{6}): (.+?)$", line, re.S)

+ if s is not None:

+ if tmigr_connect_cpu_parent(float(s.group(1)), s.group(2)):

+ continue

+ if tmigr_connect_child_parent(float(s.group(1)), s.group(2)):

+ continue

+

+ for cap in hierarchies:

+ h = hierarchies[cap]

+ print("Tree for capacity %d" % cap)

+ for k in h:

+ n = h[k]

+ while n.parent != None:

+ n = n.parent

+ root = Tree()

+ populate(root, n)

+ print(root.get_ascii(show_internal=True, attributes=["name", "numa", "lvl"]))

+ break

+#!/usr/bin/env python3

+# SPDX-License-Identifier: GPL-2.0

+import argparse

+import re

+import shutil

+import subprocess

+import sys

+import os

+

+script = os.path.relpath(__file__)

+

+DESCRIPTION = f"""

+For Intel CPUs, update the microcode revisions that determine

+X86_BUG_OLD_MICROCODE.

+

+This script is intended to be run in response to releases of the

+official Intel microcode GitHub repository:

+https://github.com/intel/Intel-Linux-Processor-Microcode-Data-Files.git

+

+It takes the Intel microcode files as input and uses iucode-tool to

+extract the revision information. It prints the output in the format

+expected by intel-ucode-defs.h.

+

+Usage:

+ ./{script} /path/to/microcode/files > /path/to/intel-ucode-defs.h

+

+Typically, someone at Intel would see a new public release, wait for at

+least three months to ensure the update is stable, run this script to

+refresh the intel-ucode-defs.h file, and send a patch upstream to update

+the mainline and stable versions.

+

+Any exception to this process should be supported with an appropriate

+justification.

+"""

+

+SIG_RE = re.compile(r'sig (0x[0-9a-fA-F]+)')

+PFM_RE = re.compile(r'pf_mask (0x[0-9a-fA-F]+)')

+REV_RE = re.compile(r'rev (0x[0-9a-fA-F]+)')

+

+# Functions to extract family, model, and stepping

+def bits(val, bottom, top):

+ mask = (1 << (top + 1 - bottom)) - 1

+ return (val >> bottom) & mask

+

+def family(sig):

+ if bits(sig, 8, 11) == 0xf:

+ return bits(sig, 8, 11) + bits(sig, 20, 27)

+ return bits(sig, 8, 11)

+

+def model(sig):

+ return bits(sig, 4, 7) | (bits(sig, 16, 19) << 4)

+

+def step(sig):

+ return bits(sig, 0, 3)

+

+class Ucode:

+ def __init__(self, sig, pfm, rev):

+ self.family = family(sig)

+ self.model = model(sig)

+ self.steppings = 1 << step(sig)

+ self.platforms = pfm

+ self.rev = rev

+

+ self.key = (self.family, self.model, self.steppings, self.platforms)

+

+ def __eq__(self, other):

+ return self.key == other.key

+

+ def __hash__(self):

+ return hash(self.key)

+

+ def __str__(self):

+ return "{ .flags = X86_CPU_ID_FLAG_ENTRY_VALID, .vendor = X86_VENDOR_INTEL, .family = 0x%x, .model = 0x%02x, .steppings = 0x%04x, .platform_mask = 0x%02x, .driver_data = 0x%x }," % \

+ (self.family, self.model, self.steppings, self.platforms, self.rev)

+

+def main():

+ parser = argparse.ArgumentParser(description=DESCRIPTION,

+ formatter_class=argparse.RawDescriptionHelpFormatter)

+ parser.add_argument('ucode_files', nargs='+', help='Path(s) to the microcode files')

+

+ args = parser.parse_args()

+

+ # Process the microcode files using iucode-tool

+ iucode_tool = shutil.which("iucode-tool") or shutil.which("iucode_tool")

+ if iucode_tool is None:

+ print("Error: iucode-tool not found, please install it", file=sys.stderr)

+ sys.exit(1)

+

+ cmd = [iucode_tool, '--list-all'] + args.ucode_files

+

+ result = subprocess.run(cmd, capture_output=True, text=True)

+ if result.returncode != 0:

+ print("Error: iucode-tool ran into an error, exiting", file=sys.stderr)

+ if result.stderr:

+ print(result.stderr, file=sys.stderr, end='')

+ sys.exit(1)

+

+ ucodes = set()

+

+ # Parse the output of iucode-tool

+ for line in result.stdout.splitlines():

+ sig_match = SIG_RE.search(line)

+ pfm_match = PFM_RE.search(line)

+ rev_match = REV_RE.search(line)

+

+ if not (sig_match and pfm_match and rev_match):

+ continue

+

+ sig = int(sig_match.group(1), 16)

+ pfm = int(pfm_match.group(1), 16)

+ rev = int(rev_match.group(1), 16)

+ debug_rev = bits(rev, 31, 31)

+ if debug_rev != 0:

+ print("Error: Debug ucode file found, exiting", file=sys.stderr)

+ sys.exit(1)

+

+ ucodes.add(Ucode(sig, pfm, rev))

+

+ if not ucodes:

+ print("Error: No valid microcode files found, exiting", file=sys.stderr)

+ sys.exit(1)

+

+ # Sort and print the microcode entries

+ print("/* SPDX-License-Identifier: GPL-2.0 */")

+ print("/* Auto-generated by scripts/update-intel-ucode-defs.py */")

+ for u in sorted(ucodes, key=lambda x: x.key):

+ print(u)

+

+if __name__ == "__main__":

+ main()