Admin

name	type	size	perms	modified	actions
[parent directory]
configs/	dir	-	0755	2026-08-06 17:55:45
includes/	dir	-	0775	2026-05-15 12:30:20
storage/	dir	-	0755	2026-05-15 12:29:56
tests/	dir	-	0755	2026-08-06 17:56:33
webuzo/	dir	-	0755	2026-08-06 17:56:17
assettemplate	file	17,021 B	0755	2026-08-07 21:04:17	edit
benchmark	file	121,591 B	0755	2026-08-01 23:51:03	edit
check_for_self_update	file	3,165 B	0775	2026-05-31 16:07:50	edit
cpapi	file	5,955 B	0755	2026-08-06 17:52:32	edit
firstbootkvm	file	5,648 B	0755	2026-05-15 08:46:00	edit
fixsemgetapache	file	422 B	0755	2026-05-15 08:31:37	edit
quicksecurityscan	file	54,901 B	0755	2026-05-30 15:15:10	edit
randompass	file	756 B	0755	2026-05-16 13:43:03	edit
res	file	7,250 B	0755	2026-05-15 08:30:52	edit
resolvconf	file	1,751 B	0755	2026-05-15 08:31:45	edit
sshkeyme	file	1,636 B	0755	2026-05-15 08:50:47	edit
systemstats	file	4,312 B	0755	2026-06-11 16:53:27	edit
updateda	file	1,122 B	0755	2026-05-15 08:29:58	edit
upgradedebs	file	2,613 B	0755	2026-05-15 08:58:51	edit
upscripts	file	6,960 B	0775	2026-08-13 16:32:45	edit

editing: benchmark

#!/usr/bin/env bash

if [ "$COLORS" = "" ]; then
        blue=$(tput setaf 4)
        green=$(tput setaf 2)
        cyan=$(tput setaf 6)
        yellow=$(tput setaf 3)
        red=$(tput setaf 1)
        normal=$(tput sgr0)
fi

CPU_ERR_MCE_RE='mce: \[Hardware Error\]|Machine check events logged|Machine check:|MCA:|MC[0-9]+_STATUS|MCi_STATUS'
CPU_ERR_MEM_RE='(EDAC|ECC|DIMM|DRAM).*(Corrected|Uncorrected|UECC|CECC|error|[[:space:]](CE|UE)[[:space:]])'
CPU_ERR_PCIE_RE='(PCIe Bus Error|section_type:[[:space:]]*PCIe error|fru_text:[[:space:]]*PcieError|device_id:[[:space:]]*[0-9A-Fa-f]{4}:[0-9A-Fa-f]{2}:[0-9A-Fa-f]{2}\.[0-9]|AER: aer_status|aer_layer=|BadTLP|BadDLLP|NonFatalErr|FatalErr|Uncorrected|Corrected error received|Completion Timeout|Unsupported Request|Surprise Down|Replay Timer Timeout|Receiver Error)'

# Ignore common non-error boot/init noise that sometimes contains these keywords
CPU_ERR_IGNORE_RE='ACPI:.*MCEJ table|EDAC.*(Giving out device|Seeking for:|Ver:)|AER: enabled with IRQ|PME: Signaling with IRQ'
CPU_ERR_ANY_RE="${CPU_ERR_MCE_RE}|${CPU_ERR_MEM_RE}|${CPU_ERR_PCIE_RE}"

cpu_err_stream() {
    # Use one source to avoid double counting
    if command -v journalctl >/dev/null 2>&1; then
        journalctl -k --no-pager 2>/dev/null
    else
        dmesg 2>/dev/null
        [ -r /var/log/kern.log ] && cat /var/log/kern.log
        [ -r /var/log/messages ] && cat /var/log/messages
        [ -r /var/log/mcelog ] && cat /var/log/mcelog
    fi
}

cpu_err_lines_any() {
    cpu_err_stream \
        | sed -E \
            -e 's/^[A-Z][a-z]{2}[[:space:]]+[0-9]{1,2}[[:space:]]+[0-9:]{8}[[:space:]]+[^[:space:]]+[[:space:]]+kernel:[[:space:]]+//' \
            -e 's/^\[[[:space:]]*[0-9]+\.[0-9]+\][[:space:]]+//' \
        | grep -a -iE "$CPU_ERR_ANY_RE" \
        | grep -a -ivE "$CPU_ERR_IGNORE_RE"
}

cpu_err_uniq_count() {
    # count unique normalized lines
    sed '/^$/d' | awk 'NF && !seen[$0]++ {c++} END{print c+0}'
}

cpu_err_mce_lines()  { cpu_err_lines_any | grep -a -iE "$CPU_ERR_MCE_RE"; }
cpu_err_mem_lines()  { cpu_err_lines_any | grep -a -iE "$CPU_ERR_MEM_RE"; }
cpu_err_pcie_lines() { cpu_err_lines_any | grep -a -iE "$CPU_ERR_PCIE_RE"; }

pcie_err_device_list() {
    # Extract PCI BDFs from common formats:
    # - device_id: 0000:45:00.0
    # - pcieport 0000:c0:01.1:
    # - nvme 0000:45:00.0:
    cpu_err_pcie_lines \
        | sed -nE \
            -e 's/.*device_id:[[:space:]]*([0-9A-Fa-f]{4}:[0-9A-Fa-f]{2}:[0-9A-Fa-f]{2}\.[0-9]).*/\1/p' \
            -e 's/.*\b(pcieport|nvme)[[:space:]]+([0-9A-Fa-f]{4}:[0-9A-Fa-f]{2}:[0-9A-Fa-f]{2}\.[0-9]).*/\2/p' \
        | tr 'A-F' 'a-f' \
        | sort -u
}

pcie_err_device_count() {
    pcie_err_device_list | awk 'NF{c++} END{print c+0}'
}

pcie_err_keywords_for_device() {
    local dev="$1"
    cpu_err_pcie_lines \
        | grep -a -i "$dev" \
        | grep -a -oEi 'BadTLP|BadDLLP|Timeout|NonFatalErr|FatalErr|Uncorrected|Corrected error' \
        | sort -u \
        | tr '\n' ',' \
        | sed 's/,$//'
}

pcie_err_summary_lines() {
    local n=0 dev keys
    while read -r dev; do
        [ -n "$dev" ] || continue
        keys=$(pcie_err_keywords_for_device "$dev")
        [ -z "$keys" ] && keys="PCIe error"
        echo -e "\t- ${cyan}${dev}${normal} (${keys})"
        n=$((n+1))
        [ $n -ge 6 ] && break
    done < <(pcie_err_device_list)
}

pcie_err_has_severe() {
    cpu_err_pcie_lines | grep -a -qiE 'Uncorrected|FatalErr|NonFatalErr'
}

cpu_err_top_cpu() {
    # Only from MCE lines (avoids PCIe noise)
    cpu_err_mce_lines \
        | sed -nE 's/.*CPU[: ]+([0-9]+).*/\1/p' \
        | sort | uniq -c | sort -nr | head -1 | awk '{print $2}'
}

cpu_err_classify() {
    # Classification priority:
    # 1) If ANY MCE exists, classify from MCE content first (CPU-cache vs unknown),
    #    and allow memory to win only if memory keywords are present too.
    # 2) If no MCE, then memory, then PCIe, else unknown.

local mce mem pcie

mce="$(cpu_err_mce_lines)"
    mem="$(cpu_err_mem_lines)"
    pcie="$(cpu_err_pcie_lines)"

if [ -n "$mem" ]; then
        echo "memory"
        return
    fi

if [ -n "$pcie" ]; then
        echo "pcie"
        return
    fi

echo "unknown"
}

cpu_err_warn_any() {
    local class count topcpu extra

# If no matches at all, do nothing
    if ! cpu_err_lines_any | grep -q .; then
        return 0
    fi

class="$(cpu_err_classify)"

case "$class" in
        cpu-cache|cpu-mce)
            count="$(cpu_err_mce_lines | cpu_err_uniq_count)"
            topcpu="$(cpu_err_top_cpu)"
            extra=""
            [ -n "$topcpu" ] && extra=". Most events reference logical CPU ${topcpu}"
            ;;
        memory)
            count="$(cpu_err_mem_lines | cpu_err_uniq_count)"
            extra=""
            ;;
        pcie)
            # PCIe/AER logs can be extremely noisy. Count unique devices instead of lines.
            count="$(pcie_err_device_count)"
            extra=""
            ;;
        *)
            count="$(cpu_err_lines_any | cpu_err_uniq_count)"
            extra=""
            ;;
    esac

[[ "$count" =~ ^[0-9]+$ ]] || count=0
    (( count == 0 )) && return 0

case "$class" in
        cpu-cache|cpu-mce)
            echo -e "
	${yellow}WARNING${normal} CPU/MCE hardware errors found in kernel logs (${count} matches)${extra}"
            echo -e "	${yellow}ACTION${normal} Recommended next steps:"
            echo -e "	- Reseat CPU and cooler. Inspect pins and socket contact."
            echo -e "	- Replace CPU."
            echo -e "	- If errors persist after CPU replacement, replace motherboard."
            ;;
        memory)
            echo -e "
	${yellow}WARNING${normal} Memory/ECC hardware errors found in kernel logs (${count} matches)"
            echo -e "	${yellow}ACTION${normal} Recommended next steps:"
            echo -e "	- Reseat memory."
            echo -e "	- Run memtest86+ full pass."
            echo -e "	- Test one DIMM at a time. Swap slots and channels."
            echo -e "	- Replace the DIMM that errors follow."
            echo -e "	- If errors persist with known-good DIMMs across slots, replace CPU."
            echo -e "	- If errors persist after CPU replacement, replace motherboard."
            ;;
        pcie)
            if pcie_err_has_severe; then
                echo -e "
	${yellow}WARNING${normal} Uncorrected/Fatal PCIe/AER events detected in kernel logs (${count} device(s))"
            else
                echo -e "
	${yellow}WARNING${normal} Corrected PCIe/AER events detected in kernel logs (${count} device(s))"
            fi
            echo -e "	${yellow}DETAIL${normal} Devices with errors:"
            pcie_err_summary_lines
            echo -e "	${yellow}ACTION${normal} Recommended next steps:"
            echo -e "	- Reseat the device and any risers/adapters. Re-seat power if applicable."
            echo -e "	- Move the device to a different slot or bay."
            echo -e "	- If errors follow the device, replace the device."
            echo -e "	- If errors stay with the slot or bay, replace the riser/backplane."
            echo -e "	- If this is NVMe, try forcing PCIe link speed down one gen in BIOS (Gen4 or Gen3) to confirm link stability."
            echo -e "	- If still present across slots with known-good devices, replace motherboard."
            ;;
        *)
            echo -e "
	${yellow}WARNING${normal} Hardware errors found in kernel logs (${count} matches)"
            echo -e "	${yellow}ACTION${normal} Recommended next steps:"
            echo -e "	- Reseat CPU and memory."
            echo -e "	- Run memtest86+ full pass."
            echo -e "	- Replace CPU."
            echo -e "	- If errors persist after CPU replacement, replace motherboard."
            ;;
    esac

echo -e "
"
}

mount_efivarfs_if_needed() {
    [ -d /sys/firmware/efi/efivars ] || return 0
    grep -q " /sys/firmware/efi/efivars " /proc/mounts 2>/dev/null && return 0
    mount -t efivarfs efivarfs /sys/firmware/efi/efivars 2>/dev/null
}

efi_desc_short() {
    # Input: full efibootmgr Boot#### line
    # Output: "UEFI: PXE IP4 P0 Intel(R) I210 Gigabit Network Connection"
    printf '%s\n' "$1" \
      | sed -E 's/^Boot[0-9A-Fa-f]{4}\*?[[:space:]]*//' \
      | sed -E 's/[[:space:]]+(HD\(|PciRoot\(|VenMedia\(|BBS\().*$//' \
      | tr -s ' ' \
      | sed -E 's/[[:space:]]+$//'
}

efi_get_bootorder() {
    efibootmgr 2>/dev/null \
      | awk -F': ' '/^BootOrder:/ {gsub(/[[:space:]]/, "", $2); print toupper($2); exit}'
}

efi_find_pxe_ipv4_bootid() {
    # Returns best Boot#### id (4 hex chars) for PXE IPv4
    local model="$1" out="$2"

printf '%s\n' "$out" | awk -v model="$model" '
        BEGIN { IGNORECASE=1; best=""; bestscore=-1 }

function score(label, s) {
            # Detect IPv4 network boot by device path, not label text.
            # Labels vary: "UEFI: PXE IP4 ..." (ASRock Rack, HPE) vs
            # "UEFI: IP4 ..." (Supermicro X11/X12).
            # Every UEFI IPv4 PXE entry has /IPv4( in its device path.
            # HTTP boot also has /IPv4( but adds /Uri() -- reject those.
            if (label !~ /\/IPv4\(/) return -1
            if (label ~ /\/Uri\(/) return -1

s = 100

# General preferences
            if (label ~ /I210/)     s += 20
            if (label ~ /Broadcom/) s += 20
            if (label ~ /\bP0\b/)   s += 8
            if (label ~ /\bP1\b/)   s += 6
            if (label ~ /IP6/)      s -= 200

# Model-specific preference tweak
            if (model ~ /B650D4U-2L2T/) {
                # This platform usually wants Broadcom 10G P1
                if (label ~ /Broadcom/ && label ~ /\bP1\b/) s += 50
            } else {
                # Most ASRock Rack Ryzen boards want I210 P0
                if (label ~ /I210/ && label ~ /\bP0\b/) s += 30
            }

return s
        }

/^Boot[0-9A-Fa-f]{4}\*?/ {
            id = substr($1, 5, 4)
            line = $0
            sub(/^Boot[0-9A-Fa-f]{4}\*?[[:space:]]*/, "", line)

s = score(line)
            if (s > bestscore) { best=id; bestscore=s; bestline=line }
        }

END {
            if (bestscore >= 0) print toupper(best)
        }
    '
}

efi_build_new_bootorder() {
    local want="$1" current="$2"
    local new="" id u

want=$(printf '%s' "$want" | tr '[:lower:]' '[:upper:]')
    current=$(printf '%s' "$current" | tr -d ' ' | tr '[:lower:]' '[:upper:]')

new="$want"
    IFS=',' read -ra ids <<< "$current"
    for id in "${ids[@]}"; do
        u=$(printf '%s' "$id" | tr '[:lower:]' '[:upper:]')
        [ "$u" = "$want" ] && continue
        new="${new},${u}"
    done

printf '%s\n' "$new"
}

warn_uefi_pxe_first() {
    [ -d /sys/firmware/efi ] || return 0
    command -v efibootmgr >/dev/null 2>&1 || return 0

mount_efivarfs_if_needed

local model out bootorder first want_id want_line want_desc new_order

model=$(get_hw_model)
    out=$(efibootmgr 2>/dev/null) || return 0

bootorder=$(efi_get_bootorder)
    [ -n "$bootorder" ] || return 0

first=${bootorder%%,*}
    first=$(printf '%s' "$first" | tr '[:lower:]' '[:upper:]')

want_id=$(efi_find_pxe_ipv4_bootid "$model" "$out")

# No PXE IPv4 entry found at all
    if [ -z "$want_id" ]; then
        echo -e "\n\t${yellow}WARNING${normal} UEFI PXE IPv4 boot entry was not found."
        echo -e "\tModel: ${cyan}${model}${normal}"
        echo -e "\tCurrent BootOrder: ${cyan}${bootorder}${normal}"
        echo -e "\t${yellow}ACTION${normal} Enable PXE IPv4 for the NIC and set it first in BIOS (IPMI web UI)."
        echo
        return 0
    fi

# Already correct
    [ "$first" = "$want_id" ] && return 0

want_line=$(printf '%s\n' "$out" | grep -a -iE "^Boot${want_id}\*?" | head -n1)
    want_desc=$(efi_desc_short "$want_line")

echo -e "\n\t${yellow}WARNING${normal} UEFI boot order is not set to network first."
    echo -e "\tModel: ${cyan}${model}${normal}"
    echo -e "\tCurrent BootOrder: ${cyan}${bootorder}${normal}"
    [ -n "$want_desc" ] && echo -e "\tExpected first: ${cyan}${want_id}${normal} (${want_desc})"

new_order=$(efi_build_new_bootorder "$want_id" "$bootorder")
    if efibootmgr -o "$new_order" >/dev/null 2>&1; then
        echo -e "\t${green}FIXED${normal} BootOrder updated to: ${cyan}${new_order}${normal}"
    else
        echo -e "\t${red}FAILED${normal} Could not update BootOrder automatically."
        echo -e "\t${yellow}ACTION${normal} Set PXE IPv4 first in BIOS (IPMI web UI)."
    fi
    echo
}

warn_ipmi_operator_access() {
  command -v ipmitool >/dev/null 2>&1 || return 0

local ch=1 model id access enabled ipmi priv

model=$(get_hw_model)

# Find operator ID on the LAN channel
  id=$(ipmitool user list "$ch" 2>/dev/null | awk '$2=="operator"{print $1; exit}')

if [ -z "$id" ]; then
    echo -e "\n\t${yellow}WARNING${normal} IPMI user ${cyan}operator${normal} is missing."
    echo -e "\tModel: ${cyan}${model}${normal}"
    echo -e "\t${yellow}ACTION${normal} Log into the BMC web UI and create user ${cyan}operator${normal}."
    echo -e "\t- Enable the user"
    echo -e "\t- Set privilege to ${cyan}Operator${normal}"
    echo -e "\t- Confirm the user has ${cyan}KVM Access${normal} and ${cyan}VMedia Access${normal}"
    echo
    return 0
  fi

access=$(ipmitool channel getaccess "$ch" "$id" 2>/dev/null)

enabled=$(printf '%s\n' "$access" | awk -F': ' '/Enable Status/{print toupper($2); exit}')
  ipmi=$(printf '%s\n' "$access" | awk -F': ' '/IPMI Messaging/{print toupper($2); exit}')
  priv=$(printf '%s\n' "$access" | awk -F': ' '/Privilege Level/{print toupper($2); exit}')

# Treat OPERATOR/ADMIN/OEM as usable.
  # On Supermicro X11/X12 the BMC web GUI does not auto-enable per-user
  # "IPMI Messaging" -- but KVM/VMedia work via HTTPS regardless. Skip the
  # IPMI Messaging requirement on Supermicro to avoid false positives.
  local require_ipmi_msg=1
  if dmidecode -s system-manufacturer 2>/dev/null | grep -qi 'supermicro'; then
    require_ipmi_msg=0
  fi
  if [ "$enabled" != "ENABLED" ] \
     || { [ "$require_ipmi_msg" -eq 1 ] && [ "$ipmi" != "ENABLED" ]; } \
     || ! printf '%s\n' "$priv" | grep -qE '^(OPERATOR|ADMINISTRATOR|OEM)'; then
    echo -e "\n\t${yellow}WARNING${normal} IPMI user ${cyan}operator${normal} exists but is not usable."
    echo -e "\tModel: ${cyan}${model}${normal}"
    echo -e "\tEnable Status: ${cyan}${enabled:-UNKNOWN}${normal}, IPMI Messaging: ${cyan}${ipmi:-UNKNOWN}${normal}, Privilege: ${cyan}${priv:-UNKNOWN}${normal}"
    echo -e "\t${yellow}ACTION${normal} Log into the BMC web UI and edit user ${cyan}operator${normal}."
    echo -e "\t- Enable the user"
    echo -e "\t- Set privilege to ${cyan}Operator${normal}"
    echo -e "\t- Enable IPMI messaging for the user"
    echo -e "\t- Confirm ${cyan}KVM Access${normal} and ${cyan}VMedia Access${normal} are allowed"
    echo
    return 0
  fi
}

health_bar() {
    local pct="$1" color="$2"
    local total=20 filled empty

[ -z "$pct" ] && pct=0
    if [[ "$pct" =~ ^[0-9]+$ ]]; then
        pct=$((10#$pct))
    else
        pct=0
    fi
    (( pct > 100 )) && pct=100
    (( pct < 0 )) && pct=0

filled=$(( pct * total / 100 ))
    empty=$(( total - filled ))

printf "[%b" "$color"
    printf "%0.s#" $(seq 1 $filled 2>/dev/null)
    printf "%b" "$normal"
    printf "%0.s-" $(seq 1 $empty 2>/dev/null)
    printf "]"
}

hours_to_years() {
    local h="$1"
    if [[ "$h" =~ ^[0-9]+$ ]]; then
        awk -v h="$h" 'BEGIN{printf "%.1f", (h/24/365)}'
    else
        echo "N/A"
    fi
}

smart_human_to_tb_int() {
    # input like: "12.3 TB" or "500 GB" or "1.2 PB"
    local s="$1"
    echo "$s" | awk '
        {
          num=""; unit="";
          for(i=1;i<=NF;i++){
            if($i ~ /^[0-9.]+$/) num=$i;
            if($i ~ /^(TB|TiB|GB|GiB|PB|PiB)$/) unit=$i;
          }
          if(num==""){print ""; exit}
          tb=num;
          if(unit=="PB" || unit=="PiB") tb=num*1024;
          else if(unit=="GB" || unit=="GiB") tb=num/1024;
          else if(unit=="TB" || unit=="TiB") tb=num;
          printf "%.0f\n", tb;
        }'
}

expected_speed() {
    # returns MB/s
    local model="$1"
    local type="$2"
    local dev="$3"

case "$model" in
        *"WD_BLACK SN750"* ) echo 3400 ;;
        *"P3 Plus"* ) echo 5000 ;;
        *"P3 NVMe"*|*"P3 SSD"*|*"Crucial P3 "* ) echo 3500 ;;
        *"P310"* ) echo 7100 ;;
        *"9100 PRO"* ) echo 14800 ;;
        *"990 PRO"* ) echo 7450 ;;
        *"990 EVO Plus"* ) echo 7250 ;;
        *"970 EVO Plus"* ) echo 3500 ;;
        *"980 PRO"* ) echo 7000 ;;
        *"980"* ) echo 3500 ;;
        * )
            if [[ "$type" == "HDD" ]]; then
                echo 200
            elif [[ "$dev" =~ ^/dev/sd ]]; then
                echo 550
            else
                echo 3000
            fi
        ;;
    esac
}

tbw_limit_for_model() {
    # returns TBW limit in TB (same table you already use)
    local model="$1"
    local size="$2"

case "$model" in
        *"Samsung SSD 990 PRO"* )
            case "$size" in
                *"4TB"*) echo 2400 ;;
                *"2TB"*) echo 1200 ;;
                *"1TB"*) echo 600 ;;
                *) echo 1200 ;;
            esac
            return
        ;;
        *"Samsung SSD 990 EVO Plus"* )
            case "$size" in
                *"4TB"*) echo 800 ;;
                *"2TB"*) echo 600 ;;
                *"1TB"*) echo 300 ;;
                *) echo 600 ;;
            esac
            return
        ;;
        *"Samsung SSD 980 PRO"* )
            case "$size" in
                *"2TB"*) echo 1200 ;;
                *"1TB"*) echo 600 ;;
                *) echo 600 ;;
            esac
            return
        ;;
        *"Samsung SSD 9100 PRO"* )
            case "$size" in
                *"4TB"*) echo 9600 ;;
                *"2TB"*) echo 4800 ;;
                *"1TB"*) echo 4800 ;;
                *) echo 4800 ;;
            esac
            return
        ;;
        *"Crucial P3 Plus"* )
            case "$size" in
                *"4TB"*) echo 800 ;;
                *"2TB"*) echo 440 ;;
                *"1TB"*) echo 220 ;;
                *"500GB"*|*"512GB"*) echo 220 ;;
                *) echo 400 ;;
            esac
            return
        ;;
        *"Crucial P3 "*|*"Crucial P3 NVMe"* )
            case "$size" in
                *"4TB"*) echo 800 ;;
                *"2TB"*) echo 440 ;;
                *"1TB"*) echo 220 ;;
                *"500GB"*|*"512GB"*) echo 220 ;;
                *) echo 400 ;;
            esac
            return
        ;;
        *"Crucial P310"* )
            case "$size" in
                *"4TB"*) echo 800 ;;
                *"2TB"*) echo 600 ;;
                *"1TB"*) echo 400 ;;
                *) echo 800 ;;
            esac
            return
        ;;
        *"WD_BLACK SN750"* )
            case "$size" in
                *"2TB"*) echo 1200 ;;
                *"1TB"*) echo 600 ;;
                *"500GB"*|*"512GB"*) echo 300 ;;
                *) echo 600 ;;
            esac
            return
        ;;
        * )
            echo ""
            return
        ;;
    esac
}

fio_read_mb() {
    # Returns decimal MB/s (like 6736) from fio output, else blank.
    # This is time based, so it will ALWAYS take a few seconds if fio actually runs.
    local dev="$1" out rc mb

out=$(fio --name=readtest --filename="$dev" --direct=1 --ioengine=libaio \
              --rw=read --bs=1M --iodepth=32 --numjobs=1 --size=2G \
              --time_based --runtime=5 --group_reporting --eta=never 2>&1)
    rc=$?

# If fio failed, return blank so caller can print FAIL
    [ $rc -ne 0 ] && echo "" && return

# Grab the MB/s inside parentheses, e.g. "bw=6423MiB/s (6736MB/s)".
    # PORTABLE: uses only 2-arg match() + RSTART/RLENGTH/substr, so it works on
    # BOTH gawk (CentOS/AlmaLinux/CloudLinux default) and mawk (Debian/Ubuntu
    # default). The old 3-arg form  match($0, re, arr)  is a gawk-only extension
    # and made mawk abort with "syntax error at or near ," -> a false FAIL.
    mb=$(echo "$out" | awk '
        match($0, /$[0-9.]+(GB|MB)\/s$/) {
            tok  = substr($0, RSTART+1, RLENGTH-2)   # e.g. 6736MB/s
            unit = "MB"; if (tok ~ /GB\//) unit = "GB"
            sub(/(GB|MB)\/s$/, "", tok)              # e.g. 6736
            v = tok + 0
            if (unit == "GB") v = v * 1000
            printf "%.0f\n", v
            exit
        }')

# Fallback for fio builds that omit the parenthesised MB/s: derive it from
    # the MiB/s value (1 MiB/s = 1.048576 MB/s). Never runs on the working path,
    # so it cannot change current results -- only rescues an otherwise-blank one.
    if [ -z "$mb" ]; then
        mb=$(echo "$out" | awk '
            match($0, /[Bb][Ww]=[0-9.]+MiB\/s/) {
                s = substr($0, RSTART+3, RLENGTH-8)  # strip "bw=" and "MiB/s"
                printf "%.0f\n", (s + 0) * 1.048576
                exit
            }')
    fi

echo "$mb"
}

pcie_speed_to_gen() {
    # input: speed in GT/s (2.5, 5, 8, 16, 32)
    local s="$1"
    case "$s" in
        2.5) echo 1 ;;
        5|5.0) echo 2 ;;
        8|8.0) echo 3 ;;
        16|16.0) echo 4 ;;
        32|32.0) echo 5 ;;
        *) echo "" ;;
    esac
}

nvme_pcie_link() {
    # prints: "gen speed width pci" for /dev/nvmeXn1
    local dev="$1" base sys pci devdir speed width gen

base=$(basename "$dev")

sys=$(readlink -f "/sys/block/$base/device" 2>/dev/null) || return 1
    pci=$(printf '%s\n' "$sys" | grep -oE '[0-9a-f]{4}:[0-9a-f]{2}:[0-9a-f]{2}\.[0-7]' | tail -1)
    [ -z "$pci" ] && return 1

devdir="/sys/bus/pci/devices/$pci"
    [ -r "$devdir/current_link_speed" ] || return 1
    [ -r "$devdir/current_link_width" ] || return 1

# current_link_speed looks like: "8.0 GT/s"
    speed=$(awk '{print $1}' "$devdir/current_link_speed" 2>/dev/null)
    width=$(cat "$devdir/current_link_width" 2>/dev/null)

[ -z "$speed" ] && return 1
    gen=$(pcie_speed_to_gen "$speed")
    [ -z "$gen" ] && return 1

[ -z "$width" ] && width="?"
    printf "%s %s %s %s\n" "$gen" "$speed" "$width" "$pci"
}

# Firmware (BIOS/BMC) version warning for ASRockRack boards.
# Accepts prefixes like "L4.18" by checking "contains expected" instead of exact match.

expected_bios_for_model() {
    local model="$1"
    case "$model" in
        *B650D4U-2L2T*)              echo "20.07" ;;
        *W680M-ACE*|*Pro\ WS\ W680M-ACE\ SE*)    echo "4505" ;;
        *ProLiant*DL360*Gen10*)       echo "3.64" ;;
        *ROME8D-2T/BCM*)              echo "3.80" ;;
        *ROME8D-2T*)                  echo "4.10" ;;
        *B650D4U*)                   echo "20.05" ;;
        *X570D4U*)                   echo "1.57" ;;
        *X470D4U2-2T*|*X470D4U-2T*)  echo "4.18" ;;
        *X470D4U*)                   echo "4.29A" ;;
        *)                           echo "" ;;
    esac
}

expected_bmc_for_model() {
    local model="$1"
    case "$model" in
        *B650D4U-2L2T*)              echo "8.03" ;;
        *B650D4U*)                   echo "6.09" ;;
        *X570D4U*)                   echo "2.09" ;;
        *X470D4U2-2T*|*X470D4U-2T*)  echo "1.83" ;;
        *X470D4U*)                   echo "3.02" ;;
        *W680M-ACE*|*Pro\ WS\ W680M-ACE\ SE*) echo "1.1.21" ;;
        *ProLiant*DL360*Gen10*)       echo "3.20" ;;
        *ROME8D-2T/BCM*)              echo "2.02" ;;
        *ROME8D-2T*)                  echo "2.08" ;;
        *)                           echo "" ;;
    esac
}

recommended_bios_for_model() {
    local model="$1"
    case "$model" in
        *B650D4U-2L2T*)              echo "22.13" ;;
        *B650D4U*)                   echo "22.10" ;;
        *ProLiant*DL360*Gen10*)      echo "3.66" ;;
        *)                           echo "" ;;
    esac
}

recommended_bmc_for_model() {
    local model="$1"
    case "$model" in
        *B650D4U-2L2T*)              echo "09.05" ;;
        *B650D4U*)                   echo "7.02" ;;
        *ProLiant*DL360*Gen10*)      echo "3.20" ;;
        *)                           echo "" ;;
    esac
}

critical_bios_for_model() {
    local model="$1"
    case "$model" in
        *W680M-ACE*|*Pro\ WS\ W680M-ACE\ SE*) echo "4505" ;;
        *)                                      echo "" ;;
    esac
}

get_hw_model() {
    local m=""
    m=$(hostnamectl 2>/dev/null | awk -F': ' '/Hardware Model/ {print $2; exit}')
    [ -z "$m" ] && m=$(dmidecode -s baseboard-product-name 2>/dev/null | head -n1)
    echo "$m"
}

get_hw_vendor() {
    local v=""
    v=$(hostnamectl 2>/dev/null | awk -F': ' '/Hardware Vendor/ {print $2; exit}')
    [ -z "$v" ] && v=$(dmidecode -s system-manufacturer 2>/dev/null | head -n1)
    echo "$v"
}

is_hpe_system() {
    local model="${1:-$(get_hw_model)}" vendor="${2:-$(get_hw_vendor)}"
    [[ "$vendor" == *"HPE"* ]] || [[ "$vendor" == *"Hewlett"* ]] || [[ "$model" == *"ProLiant"* ]]
}

get_host_fw() {
    hostnamectl 2>/dev/null | awk -F': ' '/Firmware Version/ {print $2; exit}'
}

get_bios_fw() {
    local v="" model="" rev=""

model=$(get_hw_model)

# HPE ProLiant often reports a marketing BIOS version (e.g. U32) plus a numeric BIOS Revision.
    # Prefer BIOS Revision for comparisons and reporting.
    if is_hpe_system "$model"; then
        rev=$(dmidecode -t bios 2>/dev/null | awk -F': ' '/BIOS Revision:/ {print $2; exit}')
        if [ -n "$rev" ]; then
            echo "$rev"
            return 0
        fi
    fi

v=$(dmidecode -s bios-version 2>/dev/null | head -n1)
    [ -z "$v" ] && v=$(get_host_fw)
    echo "$v"
}

get_bmc_fw() {
    local model="${1:-$(get_hw_model)}"

command -v ipmitool >/dev/null 2>&1 || { echo ""; return 0; }

local mcinfo fw aux_hex aux_dec major minor

mcinfo=$(ipmitool mc info 2>/dev/null)
    fw=$(printf '%s
' "$mcinfo" | awk -F': ' '/Firmware Revision/ {print $2; exit}')

# ASUS W680 boards: ipmitool shows "Firmware Revision: 1.01" and the patch is in Aux Firmware Rev Info (e.g. 0x15 -> 21).
    if [[ "$model" == *"W680M-ACE"* ]] || [[ "$model" == *"Pro WS W680M-ACE"* ]]; then
        aux_hex=$(printf '%s
' "$mcinfo" | awk '/Aux Firmware Rev Info/ {getline; gsub(/^[ 	]+/, "", $0); print $1; exit}')
        if [[ "$aux_hex" =~ ^0x[0-9A-Fa-f]+$ ]] && [[ "$fw" =~ ^[0-9]+\.[0-9]+$ ]]; then
            aux_dec=$((aux_hex))
            major="${fw%%.*}"
            minor="${fw#*.}"
            minor="${minor#0}"
            [ -z "$minor" ] && minor=0
            echo "${major}.${minor}.${aux_dec}"
            return 0
        fi
    fi

echo "$fw"
}

countdown_erase_10s() {
    local seconds=10 i old_trap
    old_trap=$(trap -p INT)
    trap '' INT

for ((i=seconds; i>=1; i--)); do
        printf "\r\033[K\t%s" "Waiting ${i}s."
        sleep 1
    done

printf "\r\033[K"

if [ -n "$old_trap" ]; then
        eval "$old_trap"
    else
        trap - INT
    fi
}

klog_current() {
    if command -v journalctl >/dev/null 2>&1; then
        journalctl -k -b --no-pager 2>/dev/null
    else
        dmesg 2>/dev/null
    fi
}

warn_ccp_broken_bios() {
    # CCP message is common on some Ryzen/PSP platforms and is usually harmless.
    # Do NOT treat this as "flash BIOS now" unless the platform is not on expected BIOS.

local model bios expected_bios rec_bios rec_bios_alt

if ! klog_current | grep -a -qiE 'ccp[[:space:]]+[0-9a-f:.]+:[[:space:]]+ccp:[[:space:]]+unable to access the device: you might be running a broken BIOS'; then
        return 0
    fi

model=$(get_hw_model)
    bios=$(get_bios_fw)
    expected_bios=$(expected_bios_for_model "$model")
    rec_bios=$(recommended_bios_for_model "$model")
    rec_bios_alt="${rec_bios#0}"

# If we know an expected BIOS and we are NOT on it (and also not on the newer
    # recommended version, if one is defined), warn (still no pause).
    if [ -n "$expected_bios" ] && [ -n "$bios" ] && [[ "$bios" != *"$expected_bios"* ]] \
       && { [ -z "$rec_bios" ] || ([[ "$bios" != *"$rec_bios"* ]] && [[ "$bios" != *"$rec_bios_alt"* ]]); }; then
        echo -e "\n\t${yellow}WARNING${normal} AMD CCP crypto device init failed. This is common and usually harmless, but BIOS is not on expected version."
        [ -n "$model" ] && echo -e "\tModel: ${cyan}${model}${normal}"
        echo -e "\tBIOS: ${cyan}${bios}${normal} (expected ${cyan}${expected_bios}${normal})"
        echo -e "\t${yellow}ACTION${normal} Only update BIOS if you are chasing a firmware-specific issue on this platform."
        echo
        return 0
    fi

# Otherwise: informational noise, keep moving
    echo -e "\n\t${cyan}INFO${normal} AMD CCP crypto device init failed (common on some Ryzen platforms, usually harmless)."
    [ -n "$model" ] && echo -e "\tModel: ${cyan}${model}${normal}"
    [ -n "$bios" ] && echo -e "\tBIOS: ${cyan}${bios}${normal}"
    echo
}

warn_firmware_versions() {
    local model bios expected_bios rec_bios bmc expected_bmc rec_bmc bios_bad=0 bmc_bad=0 bios_info=0 bmc_info=0

model=$(get_hw_model)
    bios=$(get_bios_fw)

[ -z "$model" ] && return 0

# Some platforms require a specific BIOS for safe operation.
    local critical_bios hostfw
    critical_bios=$(critical_bios_for_model "$model")

if [ -n "$critical_bios" ]; then
        hostfw=$(get_host_fw)
        if [ -z "$bios" ]; then
            echo -e "
	${red}CRITICAL${normal} STOP Unable to detect BIOS version on ${cyan}${model}${normal}. BIOS ${cyan}${critical_bios}${normal} is required for safe operation."
            [ -n "$hostfw" ] && echo -e "	${red}CRITICAL${normal} Host firmware reported as ${cyan}${hostfw}${normal}."
            echo -e "	${yellow}ACTION${normal} Update BIOS to ${cyan}${critical_bios}${normal} and rerun /admin/benchmark. Exiting."
            echo
            exit 1
        fi

if [[ "$bios" != *"$critical_bios"* ]]; then
            echo -e "
	${red}CRITICAL${normal} STOP BIOS ${cyan}${critical_bios}${normal} is required on ${cyan}${model}${normal} to avoid CPU damage. Detected BIOS ${cyan}${bios}${normal}."
            [ -n "$hostfw" ] && [ "$hostfw" != "$bios" ] && echo -e "	${red}CRITICAL${normal} Host firmware reported as ${cyan}${hostfw}${normal}."
            echo -e "	${yellow}ACTION${normal} Update BIOS to ${cyan}${critical_bios}${normal} before running benchmarks. Exiting."
            echo
            exit 1
        fi
    fi

expected_bios=$(expected_bios_for_model "$model")
    expected_bmc=$(expected_bmc_for_model "$model")
    rec_bios=$(recommended_bios_for_model "$model")
    rec_bmc=$(recommended_bmc_for_model "$model")
    rec_bios_alt="${rec_bios#0}"
    rec_bmc_alt="${rec_bmc#0}"
    bmc=$(get_bmc_fw "$model")

# "bad" means: not matching the minimum expected OR the recommended version (if present).
    if [ -n "$expected_bios" ] && [ -n "$bios" ] && [[ "$bios" != *"$expected_bios"* ]]; then
        if [ -z "$rec_bios" ] || ([[ "$bios" != *"$rec_bios"* ]] && [[ "$bios" != *"$rec_bios_alt"* ]]); then
            bios_bad=1
        fi
    fi

if [ -n "$expected_bmc" ] && [ -n "$bmc" ] && [[ "$bmc" != *"$expected_bmc"* ]]; then
        if [ -z "$rec_bmc" ] || ([[ "$bmc" != *"$rec_bmc"* ]] && [[ "$bmc" != *"$rec_bmc_alt"* ]]); then
            bmc_bad=1
        fi
    fi

# "info" means: minimum expected is met, but a newer recommended version exists.
    if [ -n "$rec_bios" ] && [ -n "$expected_bios" ] && [ -n "$bios" ] && [[ "$bios" == *"$expected_bios"* ]] && [[ "$bios" != *"$rec_bios"* ]] && [[ "$bios" != *"$rec_bios_alt"* ]]; then
        bios_info=1
    fi

if [ -n "$rec_bmc" ] && [ -n "$expected_bmc" ] && [ -n "$bmc" ] && [[ "$bmc" == *"$expected_bmc"* ]] && [[ "$bmc" != *"$rec_bmc"* ]] && [[ "$bmc" != *"$rec_bmc_alt"* ]]; then
        bmc_info=1
    fi

# Print INFO messages first (no delay)
    if [ $bios_info -eq 1 ] && [ $bmc_info -eq 1 ]; then
        echo -e "
	${cyan}INFO${normal} BIOS ${cyan}${rec_bios}${normal} and BMC ${cyan}${rec_bmc}${normal} are available. ${yellow}ACTION${normal} Consider updating."
        echo
    elif [ $bios_info -eq 1 ]; then
        echo -e "
	${cyan}INFO${normal} BIOS ${cyan}${rec_bios}${normal} is available. ${yellow}ACTION${normal} Consider updating."
        echo
    elif [ $bmc_info -eq 1 ]; then
        echo -e "
	${cyan}INFO${normal} BMC ${cyan}${rec_bmc}${normal} is available. ${yellow}ACTION${normal} Consider updating."
        echo
    fi

# Nothing to warn about
    [ $bios_bad -eq 0 ] && [ $bmc_bad -eq 0 ] && return 0

# Only add "(recommended X)" when it differs from the expected version,
    # otherwise a platform whose expected == recommended prints the redundant
    # "Expected BMC 3.20 (recommended 3.20)".
    local bios_note="" bmc_note=""
    [ -n "$rec_bios" ] && [ "$rec_bios" != "$expected_bios" ] && bios_note=" (recommended ${rec_bios})"
    [ -n "$rec_bmc" ]  && [ "$rec_bmc"  != "$expected_bmc" ]  && bmc_note=" (recommended ${rec_bmc})"

# Both wrong (combined)
    if [ $bios_bad -eq 1 ] && [ $bmc_bad -eq 1 ]; then
        echo -e "\n\t${yellow}WARNING${normal} BIOS version ${cyan}${bios}${normal} and BMC version ${cyan}${bmc}${normal} detected on ${cyan}${model}${normal}. Expected BIOS ${cyan}${expected_bios}${normal}${bios_note} and BMC ${cyan}${expected_bmc}${normal}${bmc_note}."
        echo -e "\t${yellow}ACTION${normal} Update BIOS and BMC before proceeding."
        countdown_erase_10s
        echo
        return 0
    fi

# BIOS only
    if [ $bios_bad -eq 1 ]; then
        echo -e "\n\t${yellow}WARNING${normal} BIOS version ${cyan}${bios}${normal} detected on ${cyan}${model}${normal}. Expected BIOS ${cyan}${expected_bios}${normal}${bios_note}."
        echo -e "\t${yellow}ACTION${normal} Update BIOS before proceeding."
        countdown_erase_10s
        echo
    fi

# BMC only
    if [ $bmc_bad -eq 1 ]; then
        echo -e "\n\t${yellow}WARNING${normal} BMC version ${cyan}${bmc}${normal} detected on ${cyan}${model}${normal}. Expected BMC ${cyan}${expected_bmc}${normal}${bmc_note}."
        echo -e "\t${yellow}ACTION${normal} Update BMC before proceeding."
        countdown_erase_10s
        echo
    fi
}

info_hpe_secondary_psu_no_power() {
    local model vendor

model=$(get_hw_model)
    vendor=$(get_hw_vendor)

is_hpe_system "$model" "$vendor" || return 0
    command -v ipmitool >/dev/null 2>&1 || return 0

local sdr ps2_line ps2_status ps2_msg ps2_present=0 in_line in_status in_read

sdr=$(ipmitool sdr elist 2>/dev/null) || return 0

# Detect whether PSU 2 is physically present
    ps2_line=$(printf '%s
' "$sdr" | awk -F'|' '$1 ~ /^Power Supply 2[[:space:]]*$/ {print $0; exit}')
    if [ -n "$ps2_line" ]; then
        ps2_status=$(printf '%s
' "$ps2_line" | awk -F'|' '{gsub(/^[ 	]+|[ 	]+$/, "", $3); print $3}')
        ps2_msg=$(printf '%s
' "$ps2_line" | awk -F'|' '{gsub(/^[ 	]+|[ 	]+$/, "", $5); print $5}')

# HPE presence sensors can still exist even when PSU bay is empty.
        # Treat PSU2 as present ONLY when the "Power Supply 2" reading explicitly indicates presence.
        ps2_msg=$(printf '%s' "$ps2_msg" | sed -e 's/^[[:space:]]*//' -e 's/[[:space:]]*$//')
        ps2_msg_l=$(printf '%s' "$ps2_msg" | tr '[:upper:]' '[:lower:]')

if [ -z "$ps2_msg" ]; then
            ps2_present=0
        elif [[ "$ps2_msg_l" =~ not[[:space:]]present|absent|not[[:space:]]installed|no[[:space:]]presence|n/a ]]; then
            ps2_present=0
        elif [[ "$ps2_msg_l" =~ presence[[:space:]]detected|present|in[[:space:]]use|good ]]; then
            ps2_present=1
        else
            ps2_present=0
        fi
    fi

[ $ps2_present -eq 0 ] && return 0

# Determine whether PSU 2 has input power
    in_line=$(printf '%s
' "$sdr" | awk -F'|' '$1 ~ /^(PS[[:space:]]+2[[:space:]]+Input|P\/S[[:space:]]+2[[:space:]]+Inlet)/ {print $0; exit}')
    if [ -z "$in_line" ]; then
        # Some HPE sensors include a numeric prefix like "40-P/S 2 Inlet"
        in_line=$(printf '%s
' "$sdr" | awk -F'|' '$1 ~ /P\/S[[:space:]]*2[[:space:]]*Inlet/ {print $0; exit}')
    fi

[ -z "$in_line" ] && return 0

in_status=$(printf '%s
' "$in_line" | awk -F'|' '{gsub(/^[ 	]+|[ 	]+$/, "", $3); print $3}')
    in_read=$(printf '%s
' "$in_line" | awk -F'|' '{gsub(/^[ 	]+|[ 	]+$/, "", $5); print $5}')

if [ "$in_status" != "ok" ] || [[ "$in_read" == *"Disabled"* ]]; then
        echo -e "
	${cyan}INFO${normal} PSU 2 is present but has no power."
        echo
    fi
}

warn_nvme_gen3_links() {
    local found=0 lines dev info gen speed width pci

lines=""

for b in /sys/block/nvme*n1; do
        [ -e "$b" ] || continue
        dev="/dev/$(basename "$b")"

info=$(nvme_pcie_link "$dev" 2>/dev/null) || continue
        gen=$(printf '%s\n' "$info" | awk '{print $1}')
        speed=$(printf '%s\n' "$info" | awk '{print $2}')
        width=$(printf '%s\n' "$info" | awk '{print $3}')
        pci=$(printf '%s\n' "$info" | awk '{print $4}')

[ "$gen" = "3" ] && found=1

lines+=$'\n'"\t- ${blue}${dev}${normal} PCIe Gen${gen} x${width} (${speed}GT/s) [${pci}]"
    done

if [ $found -eq 1 ]; then
        echo -e "\n\t${yellow}WARNING${normal} One or more NVMe drives are linked at PCIe Gen3. FIO read speed may be capped on this motherboard."
        echo -e "${lines}\n"
    fi
}

disk_scan_universal() {
    local scan lv_dev sg_dev id d

scan=$(smartctl --scan 2>/dev/null)

# strip comments, trim
    scan=$(printf '%s\n' "$scan" | sed -E 's/#.*$//' | sed -E 's/[[:space:]]+$//')

# normalize NVMe devices to /dev/nvmeXn1
    scan=$(printf '%s\n' "$scan" | sed -E 's@^(/dev/nvme[0-9]+)\b@\1n1@')

# Always add whole-disk /dev/sdX that exist but aren't in smartctl --scan
    for d in /dev/sd[a-z] /dev/sd[a-z][a-z]; do
        [ -b "$d" ] || continue
        if ! printf '%s\n' "$scan" | awk '{print $1}' | grep -qx "$d"; then
            scan+=$'\n'"$d   -d scsi"
        fi
    done

# remove partitions
    scan=$(printf '%s\n' "$scan" | awk '$1 !~ /^\/dev\/sd[a-z]+[0-9]+$/')

# Smart Array logical volume -> cciss,N probe
    if lspci | grep -qiE 'Smart Array|Adaptec Smart Storage'; then
        lv_dev=$(printf '%s\n' "$scan" | awk '$1 ~ /^\/dev\/sd[a-z]/ {print $1; exit}')
        if [ -n "$lv_dev" ]; then
            if smartctl -i "$lv_dev" -d scsi 2>/dev/null | grep -qi 'Logical Volume'; then
                sg_dev=$(basename "$(readlink -f /sys/block/$(basename "$lv_dev")/device/scsi_generic/* 2>/dev/null)")
                if [ -n "$sg_dev" ]; then
                    scan=$(printf '%s\n' "$scan" | awk '$1 !~ /^\/dev\/sd[a-z]/')
                    for id in $(seq 0 31); do
                        if smartctl -i -d cciss,$id "/dev/$sg_dev" &>/dev/null && \
                           smartctl -i -d cciss,$id "/dev/$sg_dev" | grep -qiE 'Device Model|Product'; then
                            scan+=$'\n'"$(printf "/dev/%s   -d cciss,%d" "$sg_dev" "$id")"
                        fi
                    done
                fi
            fi
        fi
    fi

printf '%s\n' "$scan" | sed '/^$/d' | awk '{ print $1, $3 }'
}

normalize_size() {
    # "2.00TB" -> "2TB", "1.00TB" -> "1TB", keep "3.84TB" as-is
    echo "$1" | tr -d ' ' | sed -E 's/\.00(TB|GB)$/\1/; s/([0-9]+)\.0+(TB|GB)$/\1\2/'
}

detect_dtype() {
    # Outputs one of: NVMe, SAS, SATA, HDD, SSD
    # dev = /dev/nvme0n1 or /dev/sda etc
    # smart_out = full smartctl output (smartctl -a)
    local dev="$1"
    local smart_out="$2"
    local base rot proto

# 1) NVMe devices are obvious
    if [[ "$dev" == /dev/nvme* ]]; then
        echo "NVMe"
        return
    fi

# 2) Use smartctl "Transport protocol" or "SATA Version"
    if echo "$smart_out" | grep -qi "Transport protocol:.*SAS"; then
        echo "SAS"
        return
    fi
    if echo "$smart_out" | grep -qi "^SATA Version is:"; then
        # SATA could be SSD or HDD, decide by rotational
        :
    fi

# 3) sysfs rotational flag distinguishes SSD vs HDD for sdX devices
    base=$(basename "$dev")
    rot=$(cat "/sys/block/$base/queue/rotational" 2>/dev/null)

if [[ "$rot" == "1" ]]; then
        echo "HDD"
        return
    fi

# 4) if not rotational, it's a solid-state device
    # If we already saw SAS transport, we returned SAS above.
    # If it was SATA, treat as SATA SSD.
    if echo "$smart_out" | grep -qi "^SATA Version is:"; then
        echo "SATA"
        return
    fi

# 5) fallback: non-rotational sdX but no SATA line, assume SSD
    echo "SSD"
}

disk_report() {
    # disk_report health   -> SMART/TBW/POH only
    # disk_report fio      -> SMART/TBW/POH + fio read + expected
    local mode="$1"
    local do_fio=0
    [ "$mode" = "fio" ] && do_fio=1

disk_scan_universal | while read -r dev driver; do
        [ -e "$dev" ] || continue

devbase=$(basename "$dev")

# Skip removable devices (USB sticks, card readers, etc)
        if [ -r "/sys/block/$devbase/removable" ] && [ "$(cat /sys/block/$devbase/removable)" -eq 1 ]; then
            continue
        fi

# Skip anything that is actually on USB
        if readlink -f "/sys/block/$devbase" 2>/dev/null | grep -q '/usb'; then
            continue
        fi

# smartctl --scan often reports SATA SSDs as "-d scsi" (SAT layer).
        # Using scsi hides the ATA SMART attributes like Percent_Lifetime_Remain and Total_LBAs_Written.
        if [[ "$dev" =~ ^/dev/sd[a-z]+$ ]] && [[ "$driver" == "scsi" ]]; then
            if smartctl -i "$dev" -d sat 2>/dev/null | grep -qiE 'ATA Version is:|SATA Version is:|Device Model:'; then
                driver="sat"
            fi
        fi

opts=""
        [ -n "$driver" ] && opts="-d $driver"
        smart_out=$(smartctl -a "$dev" $opts 2>/dev/null || true)
        [ -z "$smart_out" ] && continue

# Skip HBAs (LSI, etc)
        if smartctl -i "$dev" $opts 2>/dev/null | grep -qE '^Vendor:[[:space:]]*LSI'; then
            continue
        fi

raw_model=$(echo "$smart_out" | awk -F: '/Device Model|Model Number|Product/ {print $2; exit}' | xargs)
        [ -z "$raw_model" ] && raw_model="UNKNOWN"

serial=$(echo "$smart_out" | awk -F: '/[Ss]erial [Nn]umber/ {print $2; exit}' | xargs)
        [ -z "$serial" ] && serial="UNKNOWN"

size=$(echo "$smart_out" | awk -F'[][]' '/User Capacity:|Capacity:/{print $2; exit}' | tr -d ' ')
        [ -z "$size" ] && size=$(lsblk -dn -o SIZE "$dev" 2>/dev/null)
        size=$(normalize_size "$size")

dtype=$(detect_dtype "$dev" "$smart_out")

case "$raw_model" in
            CT2000T700SSD*|CT4000T700SSD*|CT1000T700SSD*) model="Crucial T700 ${size} Gen5 NVMe" ;;
            CT*P3PSSD*|*P3*Plus*)                         model="Crucial P3 Plus ${size} NVMe" ;;
            CT*P3SSD*|*P3*NVMe*|*P3*SSD*)                 model="Crucial P3 ${size} NVMe" ;;
            CT*P310*|*P310*NVMe*|*P310*SSD*)              model="Crucial P310 ${size} NVMe" ;;
            CT*|Crucial*)                                 model="Crucial ${size} ${dtype}" ;;
            Micron*1100*)                                 model="Micron 1100 ${size} ${dtype}" ;;
            Micron*5200*MTFDDAK3T8TDC*)                   model="Micron 5200 3.84TB SATA SSD" ;;
            Micron*)                                      model="Micron ${size} ${dtype}" ;;
            ST*)                                          model="Seagate ${size} HDD" ;;
            AREX3840S5xnFTRI*|AREA3840S5xnFTRI*|AREX3840S5xnNTRI*|AREA3840S5xnNTRI*|MZILS3T8HCJM/003*|P1633N38*EMC3840*|PA33N3T8*EMC3840*) model="Samsung PM1633 3.84TB SAS SSD" ;;
            SAMSUNG*MZQL23T8HCLS*)                        model="Samsung PM9A3 3.84TB NVMe U.2" ;;
            SAMSUNG*MZ7LM3T8HMLP*)                        model="Samsung PM863a 3.84TB SATA SSD" ;;
            SAMSUNG*MZ7LM1T9HMJP*)                        model="Samsung PM863a 1.92TB SATA SSD" ;;
            PX04SRB192*)                                  model="Dell 1.92TB MLC SAS SSD" ;;
            S610DC-1920*)                                 model="Micron S610DC 1.92TB MLC SAS SSD" ;;
            SAMSUNG*MZ7LH3T8HMLT*|SAMSUNG*MZ7LM3T8HCJM-0E003*) model="Samsung PM883 3.84TB SATA SSD" ;;
            MZILT3T8HALS0D3*|P043*EMC3840*|PA33N3T8*EMC3840*|ARFX3840S5xnNTRI*|X357_S16433T8ATE*|SLM5B-M3R8SS*) model="Samsung PM1643 3.84TB SAS SSD" ;;
            MZILT7T6HMLA*)                                model="Samsung PM1643 7.68TB SAS SSD" ;;
            AREA7680S5xnNTRI*|PA33N7T6*EMC7680*)          model="Samsung PM1633a 7.68TB SAS SSD" ;;
            MZILS15THMLS*)                                model="Samsung PM1633a 15.36TB SAS SSD" ;;
            MZXLR3T8HBLS-000H3*)                          model="Samsung PM1733 3.84TB U.3 NVMe" ;;
            WUSTVA138BSS200*|MZILS3T8HMLH0D3*)            model="Dell 3.84TB 12Gbps SAS SSD" ;;
            SDLL1MLR038TCDA1*)                            model="HGST Ultrastar SS200 3.84TB SAS SSD" ;;
            SLR5E-M3R8SS*)                                model="HGST Ultrastar SS300 3.84TB SAS SSD" ;;
            PX05SRB384Y*)                                 model="Dell Ent Plus 3.84TB SAS SSD" ;;
            KCD6XLUL7T68*)                                 model="Kioxia 7.68TB NVMe SSD" ;;
            KCD6XLUL15T3*)                                 model="Kioxia CD6-R 15.36TB NVMe SSD" ;;
            X357_TPM4V3T8AME*|X356_S163A3T8ATE*)          model="NetApp 3.84TB SAS SSD" ;;
            DOPM3840S5xnNMRI*)                            model="HP 3PAR 3.84TB SAS SSD" ;;
            WDC*)                                         model="Western Digital ${size} ${dtype}" ;;
            SAMSUNG*990*PRO*|*990*PRO*)                   model="Samsung SSD 990 PRO ${size}" ;;
            SAMSUNG*990*EVO*PLUS*|*990*EVO*Plus*)         model="Samsung SSD 990 EVO Plus ${size}" ;;
            SAMSUNG*980*PRO*|*980*PRO*)                   model="Samsung SSD 980 PRO ${size}" ;;
            SAMSUNG*970*EVO*PLUS*|*970*EVO*Plus*)         model="Samsung SSD 970 EVO Plus ${size}" ;;
            SAMSUNG*980*|*Samsung*SSD*980*)               model="Samsung SSD 980 ${size}" ;;
            *9100*PRO*)                                   model="Samsung SSD 9100 PRO ${size}" ;;
            *)                                            model="$raw_model" ;;
        esac

health_pct=100
        used=$(echo "$smart_out" | awk -F: 'BEGIN{IGNORECASE=1} /Percentage Used/ {print $2; exit}' | tr -dc '0-9')
        if [[ "$used" =~ ^[0-9]+$ ]]; then
            health_pct=$(( 100 - 10#$used ))
        fi

# SATA/SAS SSDs: prefer lifetime remaining indicators if present
        sata_life=$(echo "$smart_out" | awk '
            $2=="Wear_Leveling_Count" {
                # VALUE column can be padded like 079, force numeric
                if ($4 ~ /^[0-9]+$/) { print ($4+0); exit }
            }
            $2=="Media_Wearout_Indicator" || $2=="Percent_Lifetime_Remain" || $2=="SSD_Life_Left" || $2=="Life_Left" {
                # RAW_VALUE is usually the last numeric field
                for (i=NF; i>=1; i--) if ($i ~ /^[0-9]+$/) { print ($i+0); exit }
            }' | xargs)

if [[ "$dtype" != "NVMe" ]] && [[ "$sata_life" =~ ^[0-9]+$ ]]; then
            health_pct=$((10#$sata_life))
        fi

sata_life=$(echo "$smart_out" | awk '
            $2=="Media_Wearout_Indicator" || $2=="Percent_Lifetime_Remain" || $2=="SSD_Life_Left" || $2=="Life_Left" {
                # RAW_VALUE is usually the last numeric field
                for (i=NF; i>=1; i--) {
                    if ($i ~ /^[0-9]+$/) { print $i; exit }
                }
            }' | xargs)

if [[ "$dtype" != "NVMe" ]] && [[ -n "$sata_life" ]]; then
            health_pct="$sata_life"
        fi

bad_count=$(echo "$smart_out" | grep -iE 'Reallocate|Uncorrectable|Pending_Sector|Media and Data Integrity Errors' \
  | awk '{print $NF}' | awk 'BEGIN{s=0} $1 ~ /^[0-9]+$/ {s+=$1} END{print s+0}')
        bad_count=${bad_count:-0}

# Power on hours (POH)
        # SATA/NVMe: "Power On Hours: 1234" or SMART attr "Power_On_Hours"
        # SAS/SCSI: "Accumulated power on time, hours:minutes  1234:56"
        poh=$(echo "$smart_out" | awk -F: 'BEGIN{IGNORECASE=1} /Power On Hours/ {print $2; exit}' | xargs)
        [ -z "$poh" ] && poh=$(echo "$smart_out" | awk '/Power_On_Hours/ {print $(NF); exit}' | xargs)
        [ -z "$poh" ] && poh=$(echo "$smart_out" | awk 'BEGIN{IGNORECASE=1} /Accumulated power on time/ {for (i=1;i<=NF;i++) if ($i ~ /^[0-9]+:[0-9]+$/) {split($i,a,":"); print a[1]; exit}}' | xargs)

# normalize (handles commas and stray text)
        poh=$(echo "$poh" | tr -cd '0-9')
        [ -z "$poh" ] && poh="N/A"
        poh_years=$(hours_to_years "$poh")

temp=$(echo "$smart_out" | awk -F: '/Temperature:/ {print $2; exit}' | xargs | awk '{print $1}')
        [ -z "$temp" ] && temp=$(echo "$smart_out" | awk '/Temperature_Celsius/ {print $(NF); exit}')
        [ -z "$temp" ] && temp="N/A"

# NVMe TBW
        written_human=$(echo "$smart_out" | awk -F'[][]' '/Data Units Written/ {print $2; exit}')
        written_tb_int=""
        if [ -n "$written_human" ]; then
            written_tb_int=$(smart_human_to_tb_int "$written_human")
        fi

# SATA TBW fallback
        if [ -z "$written_tb_int" ]; then
            lbas_written=$(echo "$smart_out" | awk '/Total_LBAs_Written/ {print $(NF); exit}')
            if [[ "$lbas_written" =~ ^[0-9]+$ ]]; then
                written_tb_int=$(awk -v l="$lbas_written" 'BEGIN{printf "%.0f", (l*512/1000000000000)}')
            fi
        fi

size_bucket="$size"
        case "$size" in
            1.9*TB|1.92TB) size_bucket="2TB" ;;
            3.8*TB|3.84TB|3.9*TB) size_bucket="4TB" ;;
            7.6*TB|7.68TB) size_bucket="8TB" ;;
        esac

tbw_limit=$(tbw_limit_for_model "$model" "$size_bucket")
        [ -z "$tbw_limit" ] && tbw_limit=$(tbw_limit_for_model "$raw_model" "$size_bucket")

tbw_str="N/A"
        score="$health_pct"

# Make sure health_pct is treated as base-10 (protect against 079, etc)
        if [[ "$score" =~ ^[0-9]+$ ]]; then
            score=$((10#$score))
        else
            score=0
        fi

if [ -n "$tbw_limit" ] && [ -n "$written_tb_int" ]; then
            tbw_used_pct=$(( written_tb_int * 100 / tbw_limit ))
            (( tbw_used_pct > 999 )) && tbw_used_pct=999

tbw_remain_pct=$(( 100 - tbw_used_pct ))
            (( tbw_remain_pct < 0 )) && tbw_remain_pct=0

tbw_str="${written_tb_int}TB/${tbw_limit}TB (${tbw_used_pct}%)"

# Combine SMART remaining + TBW remaining instead of taking the minimum
            # Option A: simple average
            # score=$(( (score + tbw_remain_pct) / 2 ))

# Option B: weighted average (SMART matters more than guessed TBW tables)
            smart_w=70
            tbw_w=30
            score=$(( (score*smart_w + tbw_remain_pct*tbw_w + 50) / 100 ))
        fi

status="OK"
        color="$green"
        if (( bad_count > 0 )) || (( score < 25 )); then
            status="WARN"
            color="$yellow"
        elif (( score < 50 )); then
            status="WARN"
            color="$yellow"
        fi

bar=$(health_bar "$score" "$color")

sn_short="$serial"
        if [ ${#serial} -ge 3 ]; then
            sn_short="${serial: -3}"
        fi

speed_str="N/A"
        speed_pct=""
        speed_status="N/A"
        speed_color="$normal"
        if [ $do_fio -eq 1 ]; then
            read_mb=$(fio_read_mb "$dev")
            exp_mb=$(expected_speed "$model" "$dtype" "$dev")
            if [ -n "$read_mb" ]; then
                speed_str="${read_mb}MB/s"
                if [[ "$exp_mb" =~ ^[0-9]+$ ]] && (( exp_mb > 0 )); then
                    speed_pct=$(awk -v a="$read_mb" -v e="$exp_mb" 'BEGIN{printf "%.0f", (a*100/e)}')
                    if (( speed_pct < 60 )); then
                        speed_status="BAD";  speed_color="$red"
                    elif (( speed_pct < 80 )); then
                        speed_status="WARN"; speed_color="$yellow"
                    else
                        speed_status="OK";   speed_color="$green"
                    fi
                fi
            else
                speed_str="FAIL"
                speed_status="BAD"
                speed_color="$red"
            fi
        fi

# Build optional "(90%)" string once
        # Build optional "(90%)" string once
        pct_part=""
        [ -n "$speed_pct" ] && pct_part=" (${speed_pct}%)"
        if [ $do_fio -eq 1 ]; then
            echo -e "${blue}${dev}${normal}  Read: ${cyan}${speed_str}${normal}  ${speed_color}[${speed_status}]${normal}${pct_part}"
        else
            # Health section: short line like you asked
            # TBW percent only (13%)
            tbw_pct_only=$(echo "$tbw_str" | awk -F'[()]' '{gsub(/%/,"",$2); print $2}' | xargs)

tbw_disp="N/A"
            if [[ "$tbw_pct_only" =~ ^[0-9]+$ ]]; then
                tbw_disp="${tbw_pct_only}%"
            fi

echo -e "${blue}${dev}${normal}  ${color}[${status}]${normal} ${color}${score}%${normal} $bar  SN: ${sn_short}  TBW: ${tbw_disp}  POH: (${poh_years}y)"
        fi

done
}

# Check options
if [ "$1" = "check" ] || [ "$1" = "checklist" ]; then
    # Run checklist
    echo -e "\n${cyan}Running final checklist...${normal}"
    printf "%-26s\n" "-" | sed 's/\s/-/g'
    printf 'Hyperthreading: %-8s%s'; sed -e s/1/${green}ENABLED${normal}/ -e s/0/${red}DISABLED${normal}/ /sys/devices/system/cpu/smt/active
    printf 'Virtualization: %-8s%s'; if [ ! -e /dev/kvm ]; then echo "${red}DISABLED${normal}"; else echo "${green}ENABLED${normal}"; fi
    if [ "$(sensors | grep Package)" ]; then
        printf 'CPU temperature: %-7s%s'; sensors | grep Package | awk '{print $4}' | tr -d "+" | head -1 | cut -c1-2 | awk '{ if ($1 >= 75 && $1 < 94) printf ("%s%s%s\n", "'"$red"'", "'"HOT"'", "'"$normal"'"); else if ($1 > 93) printf ("%s%s%s\n","'"$red"'", "'"VERY HOT"'", "'"$normal"'"); else printf ("%s%s%s\n", "'"$green"'", "'"GOOD"'", "'"$normal"'"); }';
    fi
    if [ -x "$(command -v getenforce)" ]; then
    printf 'SELinux: %-15s%s'; getenforce | sed -e s/Disabled/${red}DISABLED${normal}/ -e s/Enforcing/${green}ENFORCING${normal}/ -e s/Permissive/${yellow}PERMISSIVE${normal}/
    fi
    printf 'IPv6: %-18s%s'; sed -e s/0/${green}ENABLED${normal}/ -e s/1/${red}DISABLED${normal}/ /sys/module/ipv6/parameters/disable
    if [ -x /bin/ping ]; then
        for site in "Cloudflare:1.1.1.1" "Google:8.8.8.8" "Level3:4.2.2.2" "Mirror:mirror.trouble-free.net"; do
            name=$(echo "$site" | cut -d: -f1)
            addr=$(echo "$site" | cut -d: -f2)
            if ping "$addr" -c 2 > /dev/null 2>&1; then
                status="${green}GOOD${normal}"
            else
                status="${red}oh nooooo${normal}"
            fi
            printf "%-23s %s\n" "${name} PING:" "$status"
        done
    else
        echo 'Missing /bin/ping'
    fi
    echo -e "\n\n"
exit;
fi

if [ "$1" = "cpu" ] || [ "$1" = "-c" ]; then
    # ===== flags =====
    verbose=0
    duration=8
    for arg in "$@"; do
        case "$arg" in
            -v|--verbose) verbose=1 ;;
            -q|--quick)   duration=4 ;;
            -l|--long)    duration=20 ;;
        esac
    done

# ===== package install (per-distro) =====
    if [[ "$(cat /etc/os-release | grep PRETTY_NAME | grep -o '".*"' | sed 's/"//g')" =~ ^CentOS.* ]]; then
        yum -y install bc smartmontools p7zip lshw lm_sensors util-linux > /dev/null 2>&1
    elif [[ "$(cat /etc/os-release | grep PRETTY_NAME | grep -o '".*"' | sed 's/"//g')" =~ ^Stream.* ]]; then
        yum -y install bc smartmontools lshw lm_sensors util-linux > /dev/null 2>&1
        dnf -y install epel-release > /dev/null 2>&1
        dnf -y install p7zip p7zip-plugins > /dev/null 2>&1
    elif [[ "$(cat /etc/os-release | grep PRETTY_NAME | grep -o '".*"' | sed 's/"//g')" =~ ^AlmaLinux.* ]]; then
        yum -y install bc smartmontools lshw lm_sensors util-linux > /dev/null 2>&1
        dnf -y install epel-release > /dev/null 2>&1
        dnf -y install p7zip p7zip-plugins > /dev/null 2>&1
    elif [[ "$(cat /etc/os-release | grep PRETTY_NAME | grep -o '".*"' | sed 's/"//g')" =~ ^CloudLinux.* ]]; then
        yum -y install bc smartmontools p7zip lshw lm_sensors util-linux > /dev/null 2>&1
    elif [[ "$(cat /etc/os-release | grep PRETTY_NAME | grep -o '".*"' | sed 's/"//g')" =~ ^Ubuntu.* ]]; then
        apt -y install bc smartmontools p7zip-full lshw lm-sensors util-linux > /dev/null 2>&1
    elif [[ "$(cat /etc/os-release | grep PRETTY_NAME | grep -o '".*"' | sed 's/"//g')" =~ ^Debian.* ]]; then
        apt -y install bc smartmontools p7zip-full lshw lm-sensors util-linux > /dev/null 2>&1
    elif [[ "$(cat /etc/os-release | grep PRETTY_NAME | grep -o '".*"' | sed 's/"//g')" =~ ^FreeBSD.* ]]; then
        echo "Sorry, FreeBSD not supported.... yet :)"; exit
    fi

# ===== helpers =====
    _cpu_hr() { printf '%s──────────────────────────────────────────────────────────────%s\n' "$cyan" "$normal"; }

_cpu_read_temp_c() {
        # Highest CPU-relevant temperature, integer °C.
        if command -v sensors >/dev/null 2>&1; then
            sensors -u 2>/dev/null | awk '
                /^(k10temp|coretemp|zenpower|cpu_thermal|x86_pkg_temp)-/ { cpu=1; next }
                /^[a-z0-9_-]+-(pci|isa|virtual|acpi|platform)/           { cpu=0; next }
                cpu && /_input:[[:space:]]+[0-9]/ {
                    v=$2+0
                    if (v>max) max=v
                }
                END { if (max>0) printf "%.0f", max }
            '
        else
            local maxc=0 c
            for f in /sys/class/thermal/thermal_zone*/temp; do
                [ -r "$f" ] || continue
                c=$(cat "$f"); c=$((c/1000))
                [ "$c" -gt "$maxc" ] && maxc=$c
            done
            echo "$maxc"
        fi
    }

_cpu_read_pkg_power_w() {
        # Instantaneous package power, integer W, via RAPL.
        local f e1 e2 t1 t2
        for f in /sys/class/powercap/intel-rapl:0/energy_uj \
                 /sys/class/powercap/intel-rapl-mmio:0/energy_uj; do
            [ -r "$f" ] || continue
            e1=$(cat "$f" 2>/dev/null) || continue
            t1=$(date +%s%N)
            sleep 0.2
            e2=$(cat "$f" 2>/dev/null) || continue
            t2=$(date +%s%N)
            awk -v e1="$e1" -v e2="$e2" -v t1="$t1" -v t2="$t2" \
                'BEGIN { d=(e2-e1)/1000000; dt=(t2-t1)/1000000000; if (dt>0) printf "%.0f", d/dt }'
            return
        done
        # AMD fallback: any CPU-adapter power1_average sensor
        if command -v sensors >/dev/null 2>&1; then
            local p
            p=$(sensors -u 2>/dev/null | awk '
                /^(k10temp|zenpower|amd_energy)-/                       { cpu=1; next }
                /^[a-z0-9_-]+-(pci|isa|virtual|acpi|platform)/          { cpu=0; next }
                cpu && /^[[:space:]]+(power|PPT)[0-9_]*_(input|average):[[:space:]]+[0-9]/ {
                    v=$2+0
                    if (v>0) { print v; exit }
                }
            ')
            [ -n "$p" ] && awk -v v="$p" 'BEGIN { printf "%.0f", v }'
        fi
    }

_cpu_freq_avg() {
        # Avg current freq across online CPUs, MHz. Prefer cpufreq sysfs;
        # fall back to /proc/cpuinfo "cpu MHz" lines on systems where the BIOS
        # owns P-states and exposes no cpufreq driver (e.g. HPE Static High Perf).
        local v
        if compgen -G "/sys/devices/system/cpu/cpu[0-9]*/cpufreq/scaling_cur_freq" >/dev/null; then
            v=$(awk 'BEGIN {n=0; s=0}
                { s += $1/1000; n++ }
                END { if (n>0) printf "%d", s/n }' /sys/devices/system/cpu/cpu[0-9]*/cpufreq/scaling_cur_freq 2>/dev/null)
            [ -n "$v" ] && [ "$v" -gt 0 ] && { echo "$v"; return; }
        fi
        awk -F: '/^cpu MHz/ { gsub(/[ \t]/, "", $2); s += $2; n++ }
                END { if (n>0) printf "%d", s/n }' /proc/cpuinfo
    }

_cpu_freq_max_seen() {
        local v
        if compgen -G "/sys/devices/system/cpu/cpu[0-9]*/cpufreq/scaling_cur_freq" >/dev/null; then
            v=$(awk 'BEGIN {m=0}
                { c=$1/1000; if (c>m) m=c }
                END { printf "%d", m }' /sys/devices/system/cpu/cpu[0-9]*/cpufreq/scaling_cur_freq 2>/dev/null)
            [ -n "$v" ] && [ "$v" -gt 0 ] && { echo "$v"; return; }
        fi
        awk -F: 'BEGIN{m=0} /^cpu MHz/ { gsub(/[ \t]/, "", $2); c=$2+0; if (c>m) m=c }
                 END { printf "%d", m }' /proc/cpuinfo
    }

_cpu_freq_of_core() {
        # Return current MHz of one specific CPU (used for single-thread probe so we
        # don't catch transient turbo on idle high-bin cores that wake during /proc/cpuinfo reads).
        local cpu="$1" v
        if [ -r "/sys/devices/system/cpu/cpu${cpu}/cpufreq/scaling_cur_freq" ]; then
            v=$(cat "/sys/devices/system/cpu/cpu${cpu}/cpufreq/scaling_cur_freq" 2>/dev/null)
            [ -n "$v" ] && [ "$v" -gt 0 ] && { echo $((v/1000)); return; }
        fi
        awk -v c="$cpu" -F: '
            /^processor/ { gsub(/[ \t]/, "", $2); loaded = ($2+0 == c) ? 1 : 0 }
            loaded && /^cpu MHz/ { gsub(/[ \t]/, "", $2); print int($2); exit }
        ' /proc/cpuinfo
    }

_cpu_throttle_count() {
        local sum=0 c v
        for c in /sys/devices/system/cpu/cpu[0-9]*/thermal_throttle/core_throttle_count \
                 /sys/devices/system/cpu/cpu[0-9]*/thermal_throttle/package_throttle_count; do
            [ -r "$c" ] || continue
            v=$(cat "$c" 2>/dev/null)
            [ -n "$v" ] && sum=$((sum + v))
        done
        echo "$sum"
    }

_cpu_count_online() {
        local n=0 c
        for c in /sys/devices/system/cpu/cpu[0-9]*; do
            [ -d "$c" ] || continue
            if [ -e "$c/online" ]; then
                [ "$(cat "$c/online" 2>/dev/null)" = "1" ] && n=$((n+1))
            else
                n=$((n+1))
            fi
        done
        echo "$n"
    }

_cpu_count_total() {
        ls -d /sys/devices/system/cpu/cpu[0-9]* 2>/dev/null | wc -l
    }

# ===== baseline =====
    cpu_model=$(awk -F: '/model name/{sub(/^[ \t]+/,"",$2); print $2; exit}' /proc/cpuinfo)
    # Strip redundant "N-Core Processor" / "Processor" suffix from the model string
    cpu_model=$(echo "$cpu_model" | sed -E 's/[[:space:]]+[0-9]+-Core Processor//; s/[[:space:]]+Processor$//; s/[[:space:]]+CPU @[[:space:]]+[0-9.]+GHz//')
    [ -z "$cpu_model" ] && cpu_model="Unknown CPU"
    cores_phys=$(awk -F: '/^cpu cores/{print $2+0; exit}' /proc/cpuinfo)
    [ -z "$cores_phys" ] && cores_phys="?"
    total_cpus=$(_cpu_count_total)
    online_cpus=$(_cpu_count_online)
    offline_cpus=$((total_cpus - online_cpus))
    # cpu_max_mhz resolution chain (some platforms hide cpufreq entirely):
    #   1) cpufreq sysfs cpuinfo_max_freq
    #   2) lscpu "CPU max MHz"
    #   3) dmidecode -t processor "Max Speed" (HPE/Dell with BIOS-owned P-states)
    #   4) highest observed /proc/cpuinfo "cpu MHz" sample (last resort)
    cpu_max_khz=$(cat /sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq 2>/dev/null)
    cpu_max_mhz=$(( ${cpu_max_khz:-0} / 1000 ))
    if [ "$cpu_max_mhz" -le 100 ]; then
        cpu_max_mhz=$(lscpu 2>/dev/null | awk -F: '/CPU max MHz/ { gsub(/[ \t]/, "", $2); print int($2); exit }')
    fi
    if [ -z "$cpu_max_mhz" ] || [ "$cpu_max_mhz" -le 100 ]; then
        cpu_max_mhz=$(dmidecode -t processor 2>/dev/null | awk -F: '/Max Speed/ { gsub(/[^0-9]/, "", $2); if ($2+0 > 0) { print $2; exit } }')
    fi
    if [ -z "$cpu_max_mhz" ] || [ "$cpu_max_mhz" -le 100 ]; then
        cpu_max_mhz=$(awk -F: 'BEGIN{m=0} /^cpu MHz/ { gsub(/[ \t]/, "", $2); v=$2+0; if (v>m) m=v } END { printf "%d", m }' /proc/cpuinfo)
    fi
    [ -z "$cpu_max_mhz" ] && cpu_max_mhz=0
    governor=$(cat /sys/devices/system/cpu/cpu0/cpufreq/scaling_governor 2>/dev/null)
    throttle_before=$(_cpu_throttle_count)
    idle_temp=$(_cpu_read_temp_c); idle_temp=${idle_temp:-0}
    idle_freq=$(_cpu_freq_avg)
    idle_pwr=$(_cpu_read_pkg_power_w)

# ===== header =====
    echo
    _cpu_hr
    printf '  %sCPU Health Check%s — %s · %s cores / %s threads\n' \
        "$cyan" "$normal" "$cpu_model" "$cores_phys" "$total_cpus"
    _cpu_hr
    echo

# ===== single-thread boost probe (2s) =====
    # Pin one yes process to one core; sample peak freq.
    st_peak_freq=0
    if command -v taskset >/dev/null 2>&1; then
        taskset -c 0 sh -c 'yes > /dev/null' &
        st_pid=$!
    else
        ( yes > /dev/null ) &
        st_pid=$!
    fi
    sleep 1
    # Sample only the loaded core's freq to get true single-thread peak.
    # Reading the max across all CPUs catches transient wake-ups on idle high-bin cores
    # which can inflate the reading by 200-400 MHz on multi-core Xeons.
    for ((s=0; s<4; s++)); do
        mf=$(_cpu_freq_of_core 0)
        [ -z "$mf" ] && mf=0
        [ "$mf" -gt "$st_peak_freq" ] && st_peak_freq=$mf
        sleep 0.25
    done
    kill "$st_pid" 2>/dev/null
    wait 2>/dev/null

# ===== all-core stress =====
    printf '  %sBurning all cores for %ss...%s\n' "$yellow" "$duration" "$normal"
    stress_pids=()
    for ((i=0; i<online_cpus; i++)); do
        ( yes > /dev/null ) &
        stress_pids+=($!)
    done
    sleep 2  # ramp

samples=$((duration - 2))
    [ "$samples" -lt 1 ] && samples=1
    sum_freq=0
    max_freq_seen=0
    sum_temp=0
    max_temp_seen=0
    sum_pwr=0
    pwr_samples=0
    sample_count=0
    for ((s=0; s<samples; s++)); do
        sleep 1
        f=$(_cpu_freq_avg)
        mf=$(_cpu_freq_max_seen)
        t=$(_cpu_read_temp_c); t=${t:-0}
        p=$(_cpu_read_pkg_power_w)
        [ -z "$f" ] && f=0
        [ -z "$mf" ] && mf=0
        sum_freq=$((sum_freq + f))
        [ "$mf" -gt "$max_freq_seen" ] && max_freq_seen=$mf
        sum_temp=$((sum_temp + t))
        [ "$t" -gt "$max_temp_seen" ] && max_temp_seen=$t
        if [[ "$p" =~ ^[0-9]+$ ]]; then
            sum_pwr=$((sum_pwr + p))
            pwr_samples=$((pwr_samples + 1))
        fi
        sample_count=$((sample_count + 1))
        # progress line
        printf '\r\033[K  %sBurn %d/%ds%s  freq:%5d MHz  temp:%2d °C' \
            "$yellow" "$((s+1))" "$samples" "$normal" "$f" "$t"
    done

# stop stress
    for pid in "${stress_pids[@]}"; do kill "$pid" 2>/dev/null; done
    wait 2>/dev/null
    printf '\r\033[K'

# ===== aggregate =====
    [ "$sample_count" -lt 1 ] && sample_count=1
    avg_freq=$((sum_freq / sample_count))
    avg_temp=$((sum_temp / sample_count))
    avg_pwr=""
    [ "$pwr_samples" -gt 0 ] && avg_pwr=$((sum_pwr / pwr_samples))
    throttle_after=$(_cpu_throttle_count)
    throttle_delta=$((throttle_after - throttle_before))

boost_min=$(( cpu_max_mhz * 90 / 100 ))
    sustain_min=$(( cpu_max_mhz * 60 / 100 ))
    sustain_floor=$(( cpu_max_mhz * 40 / 100 ))

issues=0
    warns=0

# ----- verdicts -----
    if [ "$offline_cpus" -gt 0 ]; then
        cores_v="${red}✗ ${offline_cpus} OFFLINE${normal}  only ${online_cpus} of ${total_cpus} cores online"
        issues=$((issues+1))
    else
        cores_v="${green}✓ ALL ON${normal}     ${online_cpus} of ${total_cpus} cores online"
    fi

if [ "$max_temp_seen" -ge 95 ]; then
        temp_v="${red}✗ CRITICAL${normal}   peaked ${max_temp_seen}°C under load — cooling is failing"
        issues=$((issues+1))
    elif [ "$max_temp_seen" -ge 85 ]; then
        temp_v="${yellow}⚠ HOT${normal}        peaked ${max_temp_seen}°C — running warm, check airflow"
        warns=$((warns+1))
    elif [ "$max_temp_seen" -ge 70 ]; then
        temp_v="${green}✓ OK${normal}         peaked ${max_temp_seen}°C — warm but fine"
    elif [ "$max_temp_seen" -gt 0 ]; then
        temp_v="${green}✓ COOL${normal}       peaked ${max_temp_seen}°C under full load"
    else
        temp_v="${yellow}? NO SENSORS${normal} couldn't read CPU temperature (lm-sensors / sensors-detect)"
        warns=$((warns+1))
    fi

if [ "$throttle_delta" -gt 0 ]; then
        throttle_v="${red}✗ THROTTLING${normal} ${throttle_delta} throttle events during test"
        issues=$((issues+1))
    else
        throttle_v="${green}✓ NONE${normal}       no throttle events recorded"
    fi

if [ "$cpu_max_mhz" -le 0 ]; then
        boost_v="${yellow}? UNKNOWN${normal}     can't read cpuinfo_max_freq"
        sustain_v="${yellow}? UNKNOWN${normal}     can't compare to max"
        warns=$((warns+2))
    else
        # Boost verdict uses the single-thread peak (all-core boost is always lower by design)
        if [ "$st_peak_freq" -ge "$boost_min" ]; then
            boost_v="${green}✓ HITS BOOST${normal} single-thread reached ${st_peak_freq} of ${cpu_max_mhz} MHz"
        elif [ "$st_peak_freq" -ge "$sustain_min" ]; then
            boost_v="${yellow}⚠ LIMITED${normal}    single-thread only ${st_peak_freq} of ${cpu_max_mhz} MHz — boost capped (BIOS/power)"
            warns=$((warns+1))
        else
            boost_v="${red}✗ STUCK LOW${normal}  single-thread only ${st_peak_freq} of ${cpu_max_mhz} MHz — heavily throttled"
            issues=$((issues+1))
        fi

if [ "$avg_freq" -ge "$sustain_min" ]; then
            sustain_v="${green}✓ STRONG${normal}     sustained ${avg_freq} MHz average under all-core load"
        elif [ "$avg_freq" -ge "$sustain_floor" ]; then
            sustain_v="${yellow}⚠ WEAK${normal}       sustained only ${avg_freq} MHz — thermal or power limited"
            warns=$((warns+1))
        else
            sustain_v="${red}✗ COLLAPSING${normal} sustained only ${avg_freq} MHz under load"
            issues=$((issues+1))
        fi
    fi

pwr_v=""
    if [ -n "$avg_pwr" ]; then
        if [ "$avg_pwr" -ge 60 ]; then
            pwr_v="${green}✓ NORMAL${normal}     drawing ${avg_pwr} W under load"
        elif [ "$avg_pwr" -ge 25 ]; then
            pwr_v="${yellow}⚠ LOW${normal}        only ${avg_pwr} W under load — possible power cap"
            warns=$((warns+1))
        else
            pwr_v="${red}✗ STARVED${normal}    only ${avg_pwr} W — power delivery failing"
            issues=$((issues+1))
        fi
    fi

# ===== display =====
    printf '   %-13s %s\n' "Cores"        "$cores_v"
    printf '   %-13s %s\n' "Temperature"  "$temp_v"
    printf '   %-13s %s\n' "Throttling"   "$throttle_v"
    printf '   %-13s %s\n' "Boost"        "$boost_v"
    printf '   %-13s %s\n' "Sustained"    "$sustain_v"
    [ -n "$pwr_v" ] && printf '   %-13s %s\n' "Power" "$pwr_v"

echo
    _cpu_hr
    if [ "$issues" -gt 0 ]; then
        printf '  %s✗ ISSUES DETECTED%s — %d problem(s), %d warning(s)\n' "$red" "$normal" "$issues" "$warns"
    elif [ "$warns" -gt 0 ]; then
        printf '  %s⚠ ATTENTION%s — %d warning(s), no hard failures\n' "$yellow" "$normal" "$warns"
    else
        printf '  %s✓ HEALTHY%s — no issues detected\n' "$green" "$normal"
    fi
    _cpu_hr
    echo

# ===== verbose details =====
    if [ "$verbose" -eq 1 ]; then
        printf '  %sDetails:%s\n' "$cyan" "$normal"
        printf '    governor              %s\n' "${governor:-?}"
        printf '    cpuinfo_max_freq      %s MHz\n' "$cpu_max_mhz"
        printf '    freq idle → load avg  %s → %s MHz\n' "${idle_freq:-?}" "$avg_freq"
        printf '    single-thread peak    %s MHz (cpuinfo_max = %s MHz)\n' "$st_peak_freq" "$cpu_max_mhz"
        printf '    all-core peak         %s MHz\n' "$max_freq_seen"
        printf '    temp idle → peak      %s → %s °C  (avg under load %s °C)\n' "$idle_temp" "$max_temp_seen" "$avg_temp"
        [ -n "$avg_pwr" ] && printf '    pkg power idle/load   %s / %s W\n' "${idle_pwr:-?}" "$avg_pwr"
        printf '    throttle events       %s\n' "$throttle_delta"
        printf '    samples taken         %s (1s intervals)\n' "$sample_count"
        echo
    fi

# ===== existing hardware-error scan =====
    cpu_err_warn_any
exit;
fi

if [ "$1" = "gpu" ] || [ "$1" = "-g" ]; then
    verbose=0
    show_igpu=0
    for arg in "$@"; do
        case "$arg" in
            -v|--verbose) verbose=1 ;;
            -a|--all)     show_igpu=1 ;;
        esac
    done

# Force UTF-8 locale so ${#str} counts characters (not bytes) for padding math.
    # Pick the first available UTF-8 locale on this system.
    for _loc in C.UTF-8 C.utf8 en_US.UTF-8 en_US.utf8; do
        if locale -a 2>/dev/null | grep -qx "$_loc"; then
            export LC_ALL="$_loc"
            break
        fi
    done

# ===== helpers =====
    _gpu_hr() { printf '%s──────────────────────────────────────────────────────────────%s\n' "$cyan" "$normal"; }

# Pad a colored string to a fixed visible width (strip ANSI for length calc)
    _gpu_align() {
        local s="$1" w="$2" plain pad
        # Strip both SGR codes (\x1b[...m/K) AND charset-selection codes (\x1b(B etc.)
        # tput sgr0 on many terminals emits \x1b(B\x1b[m — the (B part must be removed
        # before counting characters, or every reset adds 3 phantom bytes to the width.
        plain=$(printf '%s' "$s" | sed -E $'s/\x1b\\[[0-9;]*[mK]//g; s/\x1b[()][@-~]//g')
        pad=$(( w - ${#plain} ))
        [ "$pad" -lt 0 ] && pad=0
        printf '%s%*s' "$s" "$pad" ""
    }
    # Print a verdict line where $2 is "${col}status${normal}    detail".
    # Pads the colored status to 15 visible chars so all explanations align.
    _gpu_pv() {
        local field="$1" raw="$2"
        # Split on the first 4-space gap
        local status detail
        if [[ "$raw" =~ ^(.+[^[:space:]])[[:space:]]{4,}(.*)$ ]]; then
            status="${BASH_REMATCH[1]}"
            detail="${BASH_REMATCH[2]}"
        else
            status="$raw"
            detail=""
        fi
        printf '   %-13s %s  %s\n' "$field" "$(_gpu_align "$status" 15)" "$detail"
    }

_gpu_speed_to_gen() {
        case "$1" in
            2.5)     echo 1 ;;
            5|5.0)   echo 2 ;;
            8|8.0)   echo 3 ;;
            16|16.0) echo 4 ;;
            32|32.0) echo 5 ;;
            64|64.0) echo 6 ;;
            *)       echo "?" ;;
        esac
    }

_gpu_pcie_link() {
        # echoes "cur_gen|cur_width|max_gen|max_width"
        local bdf="$1" sysfs="/sys/bus/pci/devices/$bdf"
        local cs cw ms mw cg mg
        cs=$(awk '{print $1}' "$sysfs/current_link_speed" 2>/dev/null)
        cw=$(cat "$sysfs/current_link_width" 2>/dev/null)
        ms=$(awk '{print $1}' "$sysfs/max_link_speed" 2>/dev/null)
        mw=$(cat "$sysfs/max_link_width" 2>/dev/null)
        cg=$(_gpu_speed_to_gen "$cs")
        mg=$(_gpu_speed_to_gen "$ms")
        echo "${cg}|${cw}|${mg}|${mw}"
    }

_gpu_read_temp_c() {
        # Highest temperature reading from any hwmon under the device
        local sysfs="$1" maxt=0 v
        for f in "$sysfs"/hwmon/hwmon*/temp*_input; do
            [ -r "$f" ] || continue
            v=$(awk '{print int($1/1000)}' "$f")
            [ -n "$v" ] && [ "$v" -gt "$maxt" ] && maxt=$v
        done
        echo "$maxt"
    }

_gpu_driver_for_bdf() {
        local d="/sys/bus/pci/devices/$1/driver"
        [ -L "$d" ] && basename "$(readlink -f "$d")"
    }

_gpu_dmesg_errors_for() {
        # Count recent kernel-log errors mentioning the BDF or driver
        local bdf="$1" drv="$2"
        if command -v journalctl >/dev/null 2>&1; then
            journalctl -k --no-pager --since "1 hour ago" 2>/dev/null
        else
            dmesg 2>/dev/null
        fi | grep -aiE "$bdf|nvrm|nouveau|amdgpu|drm:" 2>/dev/null \
           | grep -aE '\b(error|errors|errored|fail|failed|failing|fault|faulted|timeout|hang|hung|reset|XID)\b' \
           | grep -aivE 'no error|no fault|TMZ|trusted memory zone|recovery success' \
           | wc -l
    }

_gpu_os_pretty() {
        # Same OS-detection convention used by the other subcommands in this script
        cat /etc/os-release 2>/dev/null | grep PRETTY_NAME | grep -o '".*"' | sed 's/"//g'
    }

_gpu_sysrescue_nvidia_install() {
        # Automatic NVIDIA driver install for SystemRescue live boots.
        # The live-booted kernel is frozen at whatever the ISO shipped while the
        # rolling Arch repos move on, so DKMS only works if the headers package
        # matches the running kernel exactly — both flavor (-lts/-zen/-hardened)
        # and version. If the repo has moved past the ISO kernel, pull the exact
        # version from the Arch Linux Archive instead.
        local krel kpkg hpkg kver repo_ver letter archive_url b v d nv_bound

krel=$(uname -r)
        case "$krel" in
            *-lts)      kpkg="linux-lts";      hpkg="linux-lts-headers";      kver="${krel%-lts}" ;;
            *-zen)      kpkg="linux-zen";      hpkg="linux-zen-headers";      kver="${krel%-zen}" ;;
            *-hardened) kpkg="linux-hardened"; hpkg="linux-hardened-headers"; kver="${krel%-hardened}" ;;
            *)          kpkg="linux";          hpkg="linux-headers";          kver="$krel" ;;
        esac
        # pacman package versions use a dot before the arch/zen/hardened tag where
        # uname -r uses a dash (6.11.6-arch1-1 -> 6.11.6.arch1-1)
        kver=$(printf '%s' "$kver" | sed -E 's/-(arch|zen|hardened)/.\1/')

printf '  %sSystemRescue:%s NVIDIA card has no driver bound — attempting automatic driver install\n' "$cyan" "$normal"
        printf '    running kernel %s%s%s  (%s + %s)\n' "$cyan" "$krel" "$normal" "$kpkg" "$hpkg"

if ! command -v pacman >/dev/null 2>&1; then
            printf '    %s✗ pacman not found — cannot auto-install%s\n' "$red" "$normal"
            return 1
        fi

# Same repo prep the disk subcommand does on SystemRescue
        timedatectl set-ntp true >/dev/null 2>&1
        sed -i 's/^SigLevel.*/SigLevel = Never TrustAll/' /etc/pacman.conf >/dev/null 2>&1

printf '    syncing pacman databases ... '
        if pacman -Sy --noconfirm --noprogressbar >/dev/null 2>&1; then
            printf '%sok%s\n' "$green" "$normal"
        else
            printf '%sfailed%s  (network or mirror problem?)\n' "$red" "$normal"
            return 1
        fi

repo_ver=$(pacman -Si "$hpkg" 2>/dev/null | awk '/^Version/{print $3; exit}')
        if [ -z "$repo_ver" ]; then
            printf '    %s✗ %s not found in repos%s\n' "$red" "$hpkg" "$normal"
            return 1
        fi

if [ "$repo_ver" = "$kver" ]; then
            printf '    repo %s %s matches running kernel — installing ... ' "$hpkg" "$repo_ver"
            if pacman -S --noconfirm --noprogressbar --needed "$kpkg" "$hpkg" >/dev/null 2>&1; then
                printf '%sok%s\n' "$green" "$normal"
            else
                printf '%sfailed%s\n' "$red" "$normal"
                return 1
            fi
        else
            # Repo kernel has moved past (or behind) the frozen ISO kernel — a
            # mismatched headers package never satisfies DKMS. Pin the exact
            # version from the Arch Linux Archive instead.
            printf '    repo %s is %s%s%s but running kernel needs %s%s%s\n' "$hpkg" "$yellow" "$repo_ver" "$normal" "$yellow" "$kver" "$normal"
            letter="${hpkg:0:1}"
            archive_url="https://archive.archlinux.org/packages/${letter}/${hpkg}/${hpkg}-${kver}-x86_64.pkg.tar.zst"
            printf '    installing exact-match headers from Arch Linux Archive ... '
            if pacman -U --noconfirm --noprogressbar "$archive_url" >/dev/null 2>&1; then
                printf '%sok%s\n' "$green" "$normal"
            else
                printf '%sfailed%s\n      %s\n' "$red" "$normal" "$archive_url"
                return 1
            fi
        fi

printf '    installing dkms + nvidia-open-dkms ... '
        if pacman -S --noconfirm --noprogressbar --needed dkms nvidia-open-dkms >/dev/null 2>&1; then
            printf '%sok%s\n' "$green" "$normal"
        else
            printf '%sfailed%s\n' "$red" "$normal"
            return 1
        fi

printf '    building nvidia module for %s (dkms autoinstall — may take a minute) ... ' "$krel"
        if dkms autoinstall >/dev/null 2>&1; then
            printf '%sok%s\n' "$green" "$normal"
        else
            printf '%sfailed%s  (check dkms status / journalctl -k)\n' "$red" "$normal"
            return 1
        fi

printf '    loading nvidia module ... '
        if modprobe nvidia >/dev/null 2>&1; then
            printf '%sok%s\n' "$green" "$normal"
        else
            printf '%sfailed%s\n' "$red" "$normal"
            return 1
        fi

# Verify the driver actually bound to at least one NVIDIA card
        nv_bound=0
        while IFS='|' read -r b v d; do
            [ -n "$b" ] || continue
            case "$v" in *NVIDIA*) ;; *) continue ;; esac
            [ -n "$(_gpu_driver_for_bdf "$b")" ] && nv_bound=1
        done <<< "$gpu_list"
        if [ "$nv_bound" -eq 1 ] || nvidia-smi >/dev/null 2>&1; then
            printf '    %s✓ nvidia driver installed and bound%s\n' "$green" "$normal"
            return 0
        fi
        printf '    %s✗ nvidia module loaded but no driver bound to the card%s\n' "$red" "$normal"
        return 1
    }

# ===== enumerate GPUs (skip BMC/ASPEED) =====
    gpu_list=$(lspci -mm 2>/dev/null | awk -F'"' '
        /VGA compatible|3D controller|Display controller/ {
            bdf=$1; gsub(/ /, "", bdf)
            vendor=$4; device=$6
            if (vendor ~ /ASPEED|Matrox/) next
            print "0000:" bdf "|" vendor "|" device
        }
    ')

# Count discrete (non-iGPU) and total
    gpu_total=$(printf '%s\n' "$gpu_list" | grep -c .)
    gpu_discrete=$(printf '%s\n' "$gpu_list" | awk -F'|' '
        NF && $3 !~ /Granite Ridge|Raphael|Phoenix|Rembrandt|Cezanne|Renoir|Picasso|HD Graphics|UHD Graphics|Iris|Arc Graphics/ {n++}
        END {print n+0}')
    if [ "$show_igpu" = "1" ]; then
        gpu_count=$gpu_total
    else
        gpu_count=$gpu_discrete
    fi

echo
    _gpu_hr
    if [ "$gpu_count" -eq 0 ]; then
        if [ "$gpu_total" -gt 0 ] && [ "$show_igpu" = "0" ]; then
            printf '  %sGPU Health Check%s — no discrete GPUs detected (use --all to include integrated)\n' "$cyan" "$normal"
        else
            printf '  %sGPU Health Check%s — no GPUs detected\n' "$cyan" "$normal"
        fi
        _gpu_hr
        echo
        exit
    fi
    printf '  %sGPU Health Check%s — %d GPU(s) detected\n' "$cyan" "$normal" "$gpu_count"
    _gpu_hr

# ===== SystemRescue auto-fix pre-pass (NVIDIA with no driver bound) =====
    # Runs once, before the per-GPU checks below, so a successful install is
    # picked up naturally by the normal driver-detection logic in the main loop.
    nv_fix_attempted=0
    if [[ "$(_gpu_os_pretty)" =~ ^SystemRescue.* ]]; then
        nv_unbound=0
        while IFS='|' read -r bdf vendor device; do
            [ -n "$bdf" ] || continue
            case "$vendor" in *NVIDIA*) ;; *) continue ;; esac
            [ -z "$(_gpu_driver_for_bdf "$bdf")" ] && nv_unbound=1
        done <<< "$gpu_list"
        if [ "$nv_unbound" -eq 1 ]; then
            echo
            nv_fix_attempted=1
            _gpu_sysrescue_nvidia_install \
                || printf '  %s✗ automatic driver install failed%s — continuing with normal checks\n' "$red" "$normal"
        fi
    fi

issues=0
    warns=0
    nouveau_seen=0

while IFS='|' read -r bdf vendor device; do
        [ -n "$bdf" ] || continue

# ----- vendor / device cleanup -----
        short_vendor="Unknown"
        case "$vendor" in
            *NVIDIA*)             short_vendor="NVIDIA" ;;
            *AMD*|*ATI*|*Advanced*) short_vendor="AMD" ;;
            *Intel*)              short_vendor="Intel" ;;
        esac
        short_device=$(echo "$device" | sed -E 's/^[[:space:]]+//; s/[[:space:]]+$//')

# ----- iGPU detection -----
        is_igpu="no"
        case "$short_device" in
            *"Granite Ridge"*|*"Raphael"*|*"Phoenix"*|*"Rembrandt"*|*"Cezanne"*|*"Renoir"*|*"Picasso"*)
                is_igpu="yes" ;;
            *"HD Graphics"*|*"UHD Graphics"*|*"Iris"*|*"Arc Graphics"*)
                # Intel iGPU heuristics — most non-discrete Intel parts
                is_igpu="yes" ;;
        esac
        # Skip iGPUs unless --all is set (we typically only care about discrete GPUs)
        if [ "$is_igpu" = "yes" ] && [ "$show_igpu" = "0" ]; then
            continue
        fi

echo
        if [ "$is_igpu" = "yes" ]; then
            printf '%s▌ %s %s%s  %s(integrated)%s\n' "$cyan" "$short_vendor" "$short_device" "$normal" "$yellow" "$normal"
        else
            printf '%s▌ %s %s%s\n' "$cyan" "$short_vendor" "$short_device" "$normal"
        fi
        printf '   %-13s %s\n' "Location" "PCIe $bdf"

# ----- Driver -----
        driver=$(_gpu_driver_for_bdf "$bdf")
        case "$short_vendor:$driver" in
            "NVIDIA:nvidia")
                drv_v="${green}✓ PROPRIETARY${normal}    nvidia driver loaded"
                ;;
            "NVIDIA:nouveau")
                drv_v="${red}✗ NOUVEAU${normal}    proprietary nvidia driver not loaded — workstation card will not perform"
                issues=$((issues+1))
                nouveau_seen=1
                ;;
            "AMD:amdgpu")
                drv_v="${green}✓ AMDGPU${normal}    open driver loaded"
                ;;
            "AMD:radeon")
                drv_v="${yellow}⚠ RADEON${normal}    legacy driver — amdgpu preferred"
                warns=$((warns+1))
                ;;
            "Intel:i915"|"Intel:xe")
                drv_v="${green}✓ ${driver^^}${normal}    intel driver loaded"
                ;;
            *:)
                drv_v="${red}✗ NONE${normal}    no kernel driver bound to this device"
                issues=$((issues+1))
                # For an NVIDIA card with no bound driver, recommend installing proprietary driver
                [ "$short_vendor" = "NVIDIA" ] && nouveau_seen=1
                ;;
            *)
                drv_v="${yellow}? ${driver}${normal}    unrecognized driver"
                warns=$((warns+1))
                ;;
        esac
        _gpu_pv "Driver" "$drv_v"

# ----- PCIe link -----
        # NVIDIA cards drop sysfs current_link_speed to Gen1 under ASPM at idle —
        # use nvidia-smi when proprietary driver is loaded; width never lies regardless.
        cg=""; cw=""; mg=""; mw=""
        if [ "$short_vendor" = "NVIDIA" ] && [ "$driver" = "nvidia" ] && command -v nvidia-smi >/dev/null 2>&1; then
            link_csv=$(nvidia-smi --query-gpu=pcie.link.gen.gpucurrent,pcie.link.gen.max,pcie.link.width.current,pcie.link.width.max --format=csv,noheader,nounits -i "$bdf" 2>/dev/null | head -1)
            cg=$(echo "$link_csv" | awk -F, '{gsub(/ /,"",$1); print $1}')
            mg=$(echo "$link_csv" | awk -F, '{gsub(/ /,"",$2); print $2}')
            cw=$(echo "$link_csv" | awk -F, '{gsub(/ /,"",$3); print $3}')
            mw=$(echo "$link_csv" | awk -F, '{gsub(/ /,"",$4); print $4}')
        fi
        if [ -z "$cg" ] || [ -z "$mg" ]; then
            IFS='|' read -r cg cw mg mw <<< "$(_gpu_pcie_link "$bdf")"
        fi
        if [ -n "$cg" ] && [ -n "$mg" ] && [ "$cg" != "?" ]; then
            if [ "$cw" -lt "$mw" ] 2>/dev/null; then
                # Width downtrain is a real issue regardless of Gen (ASPM doesn't change width)
                link_v="${yellow}⚠ Gen${cg} x${cw}${normal}    physical wiring or BIOS limit — expected Gen${mg} x${mw}"
                warns=$((warns+1))
            elif [ "$cg" -lt "$mg" ] 2>/dev/null; then
                # Gen lower than max but width is full = usually just ASPM at idle, not a fault
                link_v="${green}✓ Gen${mg} x${cw}${normal}    capable of Gen${mg} x${mw}  (currently Gen${cg} — ASPM idle)"
            else
                link_v="${green}✓ Gen${cg} x${cw}${normal}    at full negotiated speed"
            fi
        else
            link_v="${yellow}? UNKNOWN${normal}     can't read link state"
            warns=$((warns+1))
        fi
        _gpu_pv "PCIe link" "$link_v"

# ----- Temperature -----
        sysfs="/sys/bus/pci/devices/$bdf"
        gpu_temp=$(_gpu_read_temp_c "$sysfs")
        # If hwmon didn't expose temp (e.g. nvidia driver), fall back to nvidia-smi
        if [ "$gpu_temp" -le 0 ] && [ "$short_vendor" = "NVIDIA" ] && [ "$driver" = "nvidia" ] && command -v nvidia-smi >/dev/null 2>&1; then
            gpu_temp=$(nvidia-smi --query-gpu=temperature.gpu --format=csv,noheader,nounits -i "$bdf" 2>/dev/null | head -1 | tr -d ' ')
        fi
        if [ "$gpu_temp" -gt 0 ] 2>/dev/null; then
            if [ "$gpu_temp" -ge 90 ]; then
                temp_v="${red}✗ HOT${normal}        ${gpu_temp}°C"
                issues=$((issues+1))
            elif [ "$gpu_temp" -ge 75 ]; then
                temp_v="${yellow}⚠ WARM${normal}       ${gpu_temp}°C"
                warns=$((warns+1))
            else
                temp_v="${green}✓ COOL${normal}       ${gpu_temp}°C  (idle reading)"
            fi
        else
            temp_v="${yellow}? NO SENSOR${normal}   no hwmon temp exposed by ${driver:-driver}"
            # Don't count as warn for nouveau (limited driver), already flagged
            [ "$driver" != "nouveau" ] && warns=$((warns+1))
        fi
        _gpu_pv "Temperature" "$temp_v"

# ----- VRAM -----
        vram_str=""
        if [ -r "$sysfs/mem_info_vram_total" ]; then
            total_b=$(cat "$sysfs/mem_info_vram_total")
            used_b=$(cat "$sysfs/mem_info_vram_used" 2>/dev/null || echo 0)
            total_mb=$((total_b / 1024 / 1024))
            used_mb=$((used_b / 1024 / 1024))
            if [ "$total_mb" -ge 1024 ]; then
                total_str="$((total_mb / 1024)) GB"
            else
                total_str="${total_mb} MB"
            fi
            vram_str="${green}✓ ${total_str}${normal}      ${used_mb} MB in use"
        elif [ "$short_vendor" = "NVIDIA" ] && [ "$driver" = "nvidia" ] && command -v nvidia-smi >/dev/null 2>&1; then
            total_mb=$(nvidia-smi --query-gpu=memory.total --format=csv,noheader,nounits -i "${bdf}" 2>/dev/null | head -1 | tr -d ' ')
            used_mb=$(nvidia-smi --query-gpu=memory.used --format=csv,noheader,nounits -i "${bdf}" 2>/dev/null | head -1 | tr -d ' ')
            if [ -n "$total_mb" ]; then
                if [ "$total_mb" -ge 1024 ]; then
                    total_str="$((total_mb / 1024)) GB"
                else
                    total_str="${total_mb} MB"
                fi
                vram_str="${green}✓ ${total_str}${normal}     ${used_mb} MB in use"
            fi
        elif [ "$short_vendor" = "NVIDIA" ] && [ "$driver" = "nouveau" ]; then
            vram_str="${yellow}? UNAVAILABLE${normal}    install proprietary driver to read VRAM"
        fi
        [ -n "$vram_str" ] && _gpu_pv "VRAM" "$vram_str"

# ----- Errors in kernel log -----
        err_count=$(_gpu_dmesg_errors_for "${bdf#0000:}" "$driver")
        if [ "$err_count" -gt 0 ]; then
            _gpu_pv "Kernel log" "${yellow}⚠ ${err_count} GPU-related errors${normal}    (run with -v for details)"
            warns=$((warns+1))
        else
            _gpu_pv "Kernel log" "${green}✓ CLEAN${normal}    no GPU errors in recent kernel log"
        fi

# ----- under-load probe (only when proper driver) -----
        if [ "$short_vendor" = "NVIDIA" ] && [ "$driver" = "nvidia" ] && command -v nvidia-smi >/dev/null 2>&1; then
            pstate=$(nvidia-smi --query-gpu=pstate --format=csv,noheader -i "$bdf" 2>/dev/null | head -1 | tr -d ' ')
            pwr=$(nvidia-smi --query-gpu=power.draw --format=csv,noheader,nounits -i "$bdf" 2>/dev/null | head -1 | awk '{printf "%.0f", $1}')
            util=$(nvidia-smi --query-gpu=utilization.gpu --format=csv,noheader,nounits -i "$bdf" 2>/dev/null | head -1 | tr -d ' ')
            [ -n "$pstate" ] && _gpu_pv "Power state" "${cyan}${pstate}${normal}    ${pwr} W  · ${util}% util"
        fi

done <<< "$gpu_list"

echo
    _gpu_hr
    if [ "$issues" -gt 0 ]; then
        printf '  %s✗ ISSUES DETECTED%s — %d problem(s), %d warning(s)\n' "$red" "$normal" "$issues" "$warns"
        if [ "$nouveau_seen" -eq 1 ]; then
            echo
            if [ "$nv_fix_attempted" -eq 1 ]; then
                printf '  %sAction:%s NVIDIA card still has no working driver — automatic install was already\n' "$yellow" "$normal"
                printf '          attempted above and did not bind one. Review the install output, then check\n'
                printf '          %sdkms status%s and %sjournalctl -k%s before re-running %s/admin/benchmark gpu%s.\n' "$cyan" "$normal" "$cyan" "$normal" "$cyan" "$normal"
            else
                printf '  %sAction:%s NVIDIA card has no working driver. Install the proprietary driver:\n' "$yellow" "$normal"
                if [[ "$(_gpu_os_pretty)" =~ ^CentOS.* ]]; then
                    printf "          %sdnf install nvidia-driver akmod-nvidia%s\n" "$cyan" "$normal"
                    printf '          Reboot, then re-run %s/admin/benchmark gpu%s.\n' "$cyan" "$normal"
                elif [[ "$(_gpu_os_pretty)" =~ ^Stream.* ]]; then
                    printf "          %sdnf install nvidia-driver akmod-nvidia%s\n" "$cyan" "$normal"
                    printf '          Reboot, then re-run %s/admin/benchmark gpu%s.\n' "$cyan" "$normal"
                elif [[ "$(_gpu_os_pretty)" =~ ^AlmaLinux.* ]]; then
                    printf "          %sdnf install nvidia-driver akmod-nvidia%s\n" "$cyan" "$normal"
                    printf '          Reboot, then re-run %s/admin/benchmark gpu%s.\n' "$cyan" "$normal"
                elif [[ "$(_gpu_os_pretty)" =~ ^CloudLinux.* ]]; then
                    printf "          %sdnf install nvidia-driver akmod-nvidia%s\n" "$cyan" "$normal"
                    printf '          Reboot, then re-run %s/admin/benchmark gpu%s.\n' "$cyan" "$normal"
                elif [[ "$(_gpu_os_pretty)" =~ ^Ubuntu.* ]]; then
                    printf "          %sapt install nvidia-driver-open-XXX%s\n" "$cyan" "$normal"
                    printf '          Reboot, then re-run %s/admin/benchmark gpu%s.\n' "$cyan" "$normal"
                elif [[ "$(_gpu_os_pretty)" =~ ^Debian.* ]]; then
                    printf "          %sapt install nvidia-driver-open-XXX%s\n" "$cyan" "$normal"
                    printf '          Reboot, then re-run %s/admin/benchmark gpu%s.\n' "$cyan" "$normal"
                elif [[ "$(_gpu_os_pretty)" =~ ^SystemRescue.* ]]; then
                    printf "          %smodprobe -r nouveau%s   (nouveau is holding the card)\n" "$cyan" "$normal"
                    printf "          %spacman -Sy --noconfirm dkms nvidia-open-dkms%s   (plus headers matching uname -r)\n" "$cyan" "$normal"
                    printf '          Then re-run %s/admin/benchmark gpu%s — no reboot on a live system.\n' "$cyan" "$normal"
                else
                    printf "          %spacman -Sy --noconfirm nvidia-open-dkms%s   (SystemRescue / Arch)\n" "$cyan" "$normal"
                    printf "          %sapt install nvidia-driver-open-XXX%s        (Debian/Ubuntu)\n" "$cyan" "$normal"
                    printf "          %sdnf install nvidia-driver akmod-nvidia%s    (RHEL/Fedora)\n" "$cyan" "$normal"
                    printf '          Reboot, then re-run %s/admin/benchmark gpu%s.\n' "$cyan" "$normal"
                fi
            fi
        fi
    elif [ "$warns" -gt 0 ]; then
        printf '  %s⚠ ATTENTION%s — %d warning(s), no hard failures\n' "$yellow" "$normal" "$warns"
    else
        printf '  %s✓ HEALTHY%s — no issues detected\n' "$green" "$normal"
    fi
    _gpu_hr
    echo

# ===== verbose appendix =====
    if [ "$verbose" -eq 1 ]; then
        printf '  %sDetails:%s\n' "$cyan" "$normal"
        # full lspci -vv per GPU plus dmesg snippets
        while IFS='|' read -r bdf vendor device; do
            [ -n "$bdf" ] || continue
            short_bdf="${bdf#0000:}"
            echo
            printf '  %s%s %s%s\n' "$cyan" "$bdf" "$device" "$normal"
            lspci -vv -s "$short_bdf" 2>/dev/null | grep -E 'LnkCap|LnkSta|Kernel driver|Kernel modules|Subsystem' | sed 's/^/    /'
            errs=$( (command -v journalctl >/dev/null 2>&1 && journalctl -k --no-pager --since "1 hour ago" || dmesg) 2>/dev/null \
                | grep -aiE "$short_bdf|nvrm|nouveau|amdgpu|drm:" \
                | grep -aE '\b(error|errors|errored|fail|failed|failing|fault|faulted|timeout|hang|hung|reset|XID)\b' \
                | grep -aivE 'no error|no fault|TMZ|trusted memory zone|recovery success' \
                | tail -5 )
            if [ -n "$errs" ]; then
                echo
                printf '    %srecent kernel-log errors:%s\n' "$yellow" "$normal"
                echo "$errs" | sed 's/^/      /'
            fi
        done <<< "$gpu_list"
        echo
    fi
exit;
fi

if [ "$1" = "memory" ] || [ "$1" = "-m" ]; then
    # ----- summary fields -----
    max_capacity=$(dmidecode -t memory 2>/dev/null | awk -F': ' '/Maximum Capacity/{gsub(/^[ \t]+/,"",$2); print $2; exit}')
    motherboard_model=$(dmidecode -s baseboard-product-name 2>/dev/null | tail -1)

# ----- parse all Memory Devices into a table:  label | size | disp_type | speed | group -----
    # Fields are separated by US (0x1f) rather than tab; see note in flush().
    SEP=$'\037'
    # This single awk pass scopes each field to its own Handle and stops at the next Handle,
    # which avoids the "grep -A20 overruns into next section" bug on empty DIMMs.
    mem_table=$(dmidecode -t 17 2>/dev/null | awk '
        BEGIN { OFS="\037"; have=0; n=0 }
        /^Handle / {
            if (have) stash()
            bank=""; loc=""; size=""; type=""; detail=""; speed=""
            have=1
            next
        }
        /^$/ {
            if (have) { stash(); have=0 }
            next
        }
        {
            line=$0
            sub(/^[ \t]+/, "", line)
            key=line; sub(/:.*/, "", key)
            val=line; sub(/^[^:]+:[ \t]*/, "", val); sub(/[ \t]+$/, "", val)
            if      (key=="Bank Locator")            bank=val
            else if (key=="Locator")                 loc=val
            else if (key=="Size")                    size=val
            else if (key=="Type")                    type=val
            else if (key=="Type Detail")             detail=val
            else if (key=="Configured Memory Speed") speed=val
        }
        END { if (have) stash(); flush() }

# Buffer each Memory Device instead of printing immediately, so that
        # flush() can compare Locator vs Bank Locator across ALL slots before
        # choosing which one to display.
        function stash() {
            n++
            r_loc[n]=loc; r_bank[n]=bank; r_size[n]=size
            r_type[n]=type; r_detail[n]=detail; r_speed[n]=speed
        }

for (i=1; i<=n; i++) {
                label = (usebank && r_bank[i] != "") ? r_bank[i] : r_loc[i]

spd=r_speed[i]
                sub(/ MT\/s.*/, "", spd); sub(/ MHz.*/, "", spd)
                if (spd=="Unknown" || spd=="") spd=""
                else spd=spd "MHz"

# Type Detail is an SMBIOS bitfield: a real LRDIMM sets BOTH the
                # Registered and LRDIMM bits ("Synchronous Registered (Buffered)
                # LRDIMM"), so LRDIMM must be tested FIRST or it can never win.
                mod=""
                if      (r_detail[i] ~ /LRDIMM/)     mod="LRDIMM"
                else if (r_detail[i] ~ /Registered/) mod="RDIMM"
                else if (r_detail[i] ~ /Unbuffered/) mod="UDIMM"

grp=group_of(label, r_loc[i])

# Fields are separated by US (0x1f), NOT tab. Tab is an IFS
                # *whitespace* character, so bash read collapses runs of tabs
                # into one delimiter and every field after an empty one shifts
                # left -- which silently moved Speed into the Type column on any
                # row with a blank Type. US is non-whitespace, so empty fields
                # survive intact.
                if (r_size[i]=="No Module Installed") {
                    printf "%s\037Empty\037\037N/A\037%s\n", label, grp
                } else {
                    disp=(r_type[i]=="Other" || r_type[i]=="") ? "" : r_type[i]
                    if (mod!="") disp=(disp=="" ? mod : disp " " mod)
                    printf "%s\037%s\037%s\037%s\037%s\n", label, r_size[i], disp, spd, grp
                }
            }
        }

# Socket/processor grouping key, derived where both fields are visible.
        function group_of(label, loc_,   t) {
            if (match(label, /P[0-9]+/))                 return substr(label, RSTART, RLENGTH)
            if (match(loc_,  /^PROC[ _-]*[0-9]+/))       { t=substr(loc_, RSTART, RLENGTH); gsub(/[^0-9]/, "", t); return "P" t }
            if (match(loc_,  /^DIMM[_-]?[A-Za-z]/))      return substr(loc_, RLENGTH, 1)
            return ""
        }
    ')

# ----- compute installed memory total (GB) -----
    memory_size=$(printf '%s\n' "$mem_table" | awk -F'\037' '
        $2 != "Empty" && $2 != "" {
            v=$2
            if (v ~ /MB/)      { gsub(/[^0-9.]/, "", v); s += v/1024 }
            else if (v ~ /GB/) { gsub(/[^0-9.]/, "", v); s += v }
        }
        END { printf "%d", s }
    ')
    [ -z "$memory_size" ] && memory_size=0
    [ -z "$max_capacity" ] && max_capacity="Unknown"

# ----- box layout -----
    # Table inner width = "%-18s %-9s %-18s %-9s" = 18+1+9+1+18+1+9 = 57 chars
    # Box outer width   = "║ " + 57 + " ║" = 61 chars
    # Header content width must therefore be at least 57.
    inner=57
    motherboard_length=${#motherboard_model}
    # 21 = len("Motherboard Model:   "), same idea for the other rows
    h1=$((motherboard_length + 21))
    h2=$(( ${#max_capacity} + 21 ))
    h3=$(( ${#memory_size} + 24 ))
    [ "$h1" -gt "$inner" ] && inner=$h1
    [ "$h2" -gt "$inner" ] && inner=$h2
    [ "$h3" -gt "$inner" ] && inner=$h3
    line=$(printf '═%.0s' $(seq 1 $((inner + 2))))
    dash=$(printf '─%.0s' $(seq 1 $((inner + 2))))

printf "╔%s╗\n" "$line"
    printf "║ ${cyan}%-${inner}s${normal} ║\n" "Motherboard Model:   $motherboard_model"
    printf "║ ${yellow}%-${inner}s${normal} ║\n" "Maximum Capacity:    $max_capacity"
    printf "║ ${yellow}%-${inner}s${normal} ║\n" "Installed Memory:    $memory_size GB"
    printf "╠%s╣\n" "$line"

# ----- table column header (width must match inner) -----
    # Compute padding so table reaches the inner width
    pad=$((inner - 57))
    [ "$pad" -lt 0 ] && pad=0
    pad_str=$(printf '%*s' "$pad" "")
    printf "║ ${cyan}%-18s %-9s %-18s %-9s%s${normal} ║\n" "Locator" "Size" "Type" "Speed" "$pad_str"
    printf "╟%s╢\n" "$dash"

# ----- table rows (with per-processor separator) -----
    prev_processor=""
    while IFS="$SEP" read -r loc size type speed processor; do
        [ -z "$loc" ] && continue

# Processor grouping key is computed in the awk pass above, where both
        # Locator and Bank Locator are still visible.

if [ -n "$prev_processor" ] && [ "$prev_processor" != "$processor" ]; then
            printf "╟%s╢\n" "$dash"
        fi

# Empty slots in default color, populated in green
        if [ "$size" = "Empty" ]; then
            printf "║ %-18s %-9s %-18s %-9s%s ║\n" "$loc" "Empty" "" "N/A" "$pad_str"
        else
            printf "║ ${green}%-18s %-9s %-18s %-9s%s${normal} ║\n" "$loc" "$size" "$type" "$speed" "$pad_str"
        fi

prev_processor="$processor"
    done <<< "$mem_table"

printf "╚%s╝\n" "$line"
    exit;
fi

if [ "$1" = "disk" ] || [ "$1" = "-d" ]; then

# Check to see if the required packages are installed.
        # Install packages based on operating system
        if [[ "$(cat /etc/os-release | grep PRETTY_NAME |  grep -o '".*"' | sed 's/"//g')" =~ ^CentOS.* ]]; then
            yum -y install bc iperf3 smartmontools fio p7zip lshw lm_sensors curl > /dev/null 2>&1;
        elif [[ "$(cat /etc/os-release | grep PRETTY_NAME |  grep -o '".*"' | sed 's/"//g')" =~ ^Stream.* ]]; then
            yum -y install bc iperf3 smartmontools fio lshw lm_sensors curl > /dev/null 2>&1;
            dnf -y install epel-release > /dev/null 2>&1;
            dnf -y install p7zip p7zip-plugins > /dev/null 2>&1;
        elif [[ "$(cat /etc/os-release | grep PRETTY_NAME |  grep -o '".*"' | sed 's/"//g')" =~ ^AlmaLinux.* ]]; then
            yum -y install bc iperf3 smartmontools fio lshw lm_sensors curl > /dev/null 2>&1;
            dnf -y install epel-release > /dev/null 2>&1;
            dnf -y install p7zip p7zip-plugins > /dev/null 2>&1;
        elif [[ "$(cat /etc/os-release | grep PRETTY_NAME |  grep -o '".*"' | sed 's/"//g')" =~ ^CloudLinux.* ]]; then
            yum -y install bc iperf3 smartmontools fio p7zip lshw lm_sensors curl > /dev/null 2>&1;
        elif [[ "$(cat /etc/os-release | grep PRETTY_NAME |  grep -o '".*"' | sed 's/"//g')" =~ ^Ubuntu.* ]]; then
            apt -y install bc iperf3 smartmontools memtester fio p7zip-full lshw lm-sensors curl > /dev/null 2>&1;
        elif [[ "$(cat /etc/os-release | grep PRETTY_NAME |  grep -o '".*"' | sed 's/"//g')" =~ ^Debian.* ]]; then
            apt -y install bc iperf3 smartmontools memtester fio p7zip-full lshw lm-sensors curl > /dev/null 2>&1;
        elif [[ "$(cat /etc/os-release | grep PRETTY_NAME |  grep -o '".*"' | sed 's/"//g')" =~ ^SystemRescue.* ]]; then
            update-pciids >/dev/null 2>&1 ; \
            timedatectl set-ntp true >/dev/null 2>&1 ; \
            sed -i 's/^SigLevel.*/SigLevel = Never TrustAll/' /etc/pacman.conf >/dev/null 2>&1 ; \
            pacman -Sy --noconfirm --noprogressbar ipcalc fio memtester cpupower s-tui stress >/dev/null 2>&1 ; \
            cpupower frequency-set -g performance >/dev/null 2>&1
        elif [[ "$(cat /etc/os-release | grep PRETTY_NAME |  grep -o '".*"' | sed 's/"//g')" =~ ^FreeBSD.* ]]; then
            echo "Sorry, FreeBSD not supported.... yet :)";
            exit;
        fi
    disk_report fio
    exit
fi

#######################################################
#     _____      _ _                  _       _       #
#    |  ___|   _| | |   ___  ___ _ __(_)_ __ | |_     #
#    | |_ | | | | | |  / __|/ __| '__| | '_ \| __|    #
#    |  _|| |_| | | |  \__ \ (__| |  | | |_) | |_     #
#    |_|   \__,_|_|_|  |___/\___|_|  |_| .__/ \__|    #
#                                      |_|            #
#######################################################

# check if user int or installer exists, and ask the user if they can be removed
# if they can be removed, remove them
# if they can't be removed, exit

# check if users int and installer exist
for user in int installer; do
    if [ -d /home/"$user" ]; then
        while true; do
            read -p "The user ${cyan}${user}${normal} has been detected. ${green}Remove it?${normal} (y/n) " removeuser
            case $removeuser in
                [Yy]* )
                    userdel "$user"
                    cd /home && rm -rf "$user"
                    break;;
                [Nn]* )
                    echo -e "\n\t${yellow}WARNING${normal} user ${cyan}${user}${normal} has not been removed\n"
                    break;;
                * ) echo "Please answer yes or no.";;
            esac
        done
    fi
done

if [ ! -d /home/int ] && [ ! -d /home/installer ]; then
    echo -e "\n${green}No extra users detected${normal}"
fi

# check if permitrootlogin is set to prohibit-password in /etc/ssh/sshd_config
# if it is, ask the user if they want to change it to yes
if grep -q "#PermitRootLogin prohibit-password" /etc/ssh/sshd_config; then
    while true; do
        read -p "${cyan}SSH${normal} root access is ${yellow}restricted${normal}. ${green}Enable?${normal} (y/n) " changepermitrootlogin
        case $changepermitrootlogin in
            [Yy]* )
            sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin yes/g' /etc/ssh/sshd_config;
            service sshd restart;
            service ssh restart;
            echo -e "\n"
            break;;
            [Nn]* ) echo -e "\n\t${yellow}WARNING${normal} root access is ${yellow}restricted${normal}\n"; break;;
            * ) echo "Please answer yes or no.";;
        esac
    done
else
    echo -e "${green}SSH root access is enabled${normal}\n"
fi

# Warn if mdadm needs to be updated
for mdconf in /etc/mdadm/mdadm.conf /etc/mdadm.conf; do
    if [ -f "$mdconf" ]; then
        mdadmcheck=$(grep ^MAILADDR "$mdconf" | awk '{print $2}')
        if [ "$mdadmcheck" = "root" ]; then
            while true; do
                read -p "mdadm ${cyan}MAILADDR${normal} is set to ${cyan}root${normal} in ${cyan}${mdconf}${normal}. ${green}Update${normal} to ${cyan}hardware@interserver.net${normal}? (y/n) " correct
                case $correct in
                    [Yy]* ) sed -i 's/MAILADDR root/MAILADDR hardware@interserver.net/g' "$mdconf"; echo ""; break;;
                    [Nn]* ) echo -e "\n\t${yellow}WARNING${normal} ${mdconf} exists with ${cyan}MAILADDR${normal} set to ${cyan}root${normal}\n"; break;;
                    * ) echo "Please answer yes or no.";;
                esac
            done
        fi
    fi
done

# Check to see if the required packages are installed.
# Install packages based on operating system
# If not, prompt the user to install them
if [ ! -x "$(command -v bc)" ] || [ ! -x "$(command -v fio)" ] || [ ! -x "$(command -v iperf3)" ] || [ ! -x "$(command -v smartctl)" ] || [ ! -x "$(command -v 7za)" ] || [ ! -x "$(command -v sensors)" ] || [ ! -x "$(command -v ipcalc)" ]; then
    while true; do
        read -p "The required packages for this script are not installed. Would you like to install them? (y/n) " correct
        case $correct in
            [Yy]* )
            if [[ "$(cat /etc/os-release | grep PRETTY_NAME |  grep -o '".*"' | sed 's/"//g')" =~ ^CentOS.* ]]; then
                yum -y update;
                yum -y install bc iperf3 smartmontools fio p7zip ethtool pciutils lm_sensors curl ipcalc ipmitool> /dev/null 2>&1;
                echo;
            elif [[ "$(cat /etc/os-release | grep PRETTY_NAME |  grep -o '".*"' | sed 's/"//g')" =~ ^Stream.* ]]; then
                yum -y update;
                yum -y install bc iperf3 smartmontools fio ethtool pciutils lm_sensors curl ipcalc ipmitool> /dev/null 2>&1;
                dnf -y install epel-release > /dev/null 2>&1;
                dnf -y install p7zip p7zip-plugins > /dev/null 2>&1;
                echo;
            elif [[ "$(cat /etc/os-release | grep PRETTY_NAME |  grep -o '".*"' | sed 's/"//g')" =~ ^AlmaLinux.* ]]; then
                yum -y update;
                yum -y install bc iperf3 smartmontools fio ethtool pciutils lm_sensors curl ipcalc ipmitool> /dev/null 2>&1;
                dnf -y install epel-release > /dev/null 2>&1;
                dnf -y install p7zip p7zip-plugins > /dev/null 2>&1;
                echo;
            elif [[ "$(cat /etc/os-release | grep PRETTY_NAME |  grep -o '".*"' | sed 's/"//g')" =~ ^CloudLinux.* ]]; then
                yum -y update;
                yum -y install bc iperf3 smartmontools fio p7zip ethtool pciutils lm_sensors curl ipcalc ipmitool> /dev/null 2>&1;
                echo;
            elif [[ "$(cat /etc/os-release | grep PRETTY_NAME |  grep -o '".*"' | sed 's/"//g')" =~ ^Ubuntu.* ]]; then
                apt update;
                apt -y install bc iperf3 smartmontools memtester fio p7zip-full ethtool pciutils lm-sensors curl ipcalc ipmitool> /dev/null 2>&1;
                echo;
            elif [[ "$(cat /etc/os-release | grep PRETTY_NAME |  grep -o '".*"' | sed 's/"//g')" =~ ^Debian.* ]]; then
                apt update;
                apt -y install bc iperf3 smartmontools memtester fio p7zip-full ethtool pciutils lm-sensors curl ipcalc ipmitool> /dev/null 2>&1;
                echo;
            elif [[ "$(cat /etc/os-release | grep PRETTY_NAME |  grep -o '".*"' | sed 's/"//g')" =~ ^FreeBSD.* ]]; then
                echo "Sorry, FreeBSD not supported.... yet :)";
                exit;
            fi
            break;;
            [Nn]* ) exit;;
            * ) echo "Please answer yes or no.";;
        esac
    done
fi

# run /admin/assettemplate, and before proceeding, ask the user "Does this look correct?"
# if it does, proceed, if not, exit
echo "${cyan}System Information:${normal}"
printf "%-19s\n" "-" | sed 's/\s/-/g'
/admin/assettemplate
warn_firmware_versions
info_hpe_secondary_psu_no_power
warn_ccp_broken_bios
warn_ipmi_operator_access
warn_uefi_pxe_first

while true; do
    read -p "Does this look ${green}correct?${normal} (y/n) " correct
    case $correct in
        [Yy]* ) echo ""; break;;
        [Nn]* ) echo -e "\nfix it.\n"; exit;;
        * ) echo "Please answer yes or no.";;
    esac
done

# get system stats
echo -e "\n\n${cyan}System Stats:${normal}"
printf "%-13s\n" "-" | sed 's/\s/-/g'

sysout=$(/admin/systemstats)

# metrics
echo "$sysout" | grep -iE "CPU Usage %|Mem Usage %|Disk Usage %|Load Average" | awk '{print $1 ":\t\t\t" $NF}'

# warnings (keep colors, add a blank line between multiples)
warn=$(printf '%s\n' "$sysout" | grep -a -iE '(WARNING|CRITICAL)')
if [[ -n "$warn" ]]; then
  echo
  printf '%s\n' "$warn" | awk 'NR>1{print ""} {print}'
fi

echo -e "\n\n"

# run an iperf3 network speed test
echo "${cyan}iperf3 Network Speed Tests (IPv4):${normal}"
mainip=$(ip addr | grep inet | grep / | grep global | awk '{print $2}' | cut -d/ -f1 | head -n 1;)
printf "%-34s\n" "-" | sed 's/\s/-/g'

servers="dfw lax nyc"
best_server=""; best_port=""; best_mbps=0
printf "Finding best server..."

# find best server+port by quick reverse test
for i in $servers; do
  printf "\r\033[KFinding best server... %s:scanning" "$i"
  found_port=0
  for port in {5201..5210}; do
    test_output=$(timeout 2 iperf3 -t 1 -4 -f m -c $i.speedtest.is.cc -p $port -R 2>&1)
    rc=$?
    if [[ $rc -eq 124 ]]; then
      continue
    elif echo "$test_output" | grep -qi "server is busy"; then
      continue
    elif [[ $rc -ne 0 ]]; then
      continue
    else
      mbps=$(echo "$test_output" | awk '/receiver/{print $7; exit}')
      mbps_int=${mbps%.*}
      printf "\r\033[KFinding best server... %s:%s %s Mbit/s" "$i" "$port" "${mbps_int:-0}"
      if [[ -n "$mbps_int" && "$mbps_int" -gt "$best_mbps" ]]; then
        best_mbps="$mbps_int"
        best_server="$i.speedtest.is.cc"
        best_port="$port"
      fi
      found_port=1
      break
    fi
  done
  if [[ $found_port -eq 0 ]]; then
    printf "\r\033[KFinding best server... %s:no ports" "$i"
  fi
done

speedtest_server="${best_server:-speedtest.is.cc}"
open_port="$best_port"

if [[ -n "$open_port" ]]; then
  printf "\r\033[KUsing %s port %s" "$speedtest_server" "$open_port";  printf "\r\033[K"
else
  printf "\r\033[KUsing %s (fallback)"; printf "\r\033[K"
fi

printf "\r\033[K"

if [[ -z "$open_port" ]]; then
  # fallback: original open-port scanner on chosen host
  for port in {5201..5210}; do
    test_output=$(timeout 2 iperf3 -t 1 -4 -f m -c "$speedtest_server" -p "$port" -R 2>&1)
    rc=$?
    if [[ $rc -eq 124 ]]; then
      continue
    elif echo "$test_output" | grep -qi "server is busy"; then
      continue
    elif [[ $rc -ne 0 ]]; then
      continue
    else
      open_port=$port
      break
    fi
  done
fi

download=$(iperf3 -t 1 -4 -f m -c $speedtest_server -p $open_port -R)
upload=$(iperf3 -t 1 -4 -f m -c $speedtest_server -p $open_port)
echo "$upload" | grep sender | awk '{print "Upload: \t\t" $7" "$8}'
echo "$download" | grep receiver | awk '{print "Download: \t\t" $7" "$8}'
echo -e "\n"

echo -e "\n${cyan}Disk Health:${normal}"
printf "%-30s\n" "-" | sed 's/\s/-/g'
disk_report health
echo -e "\n"

echo -e "\n${cyan}FIO Sequential Read Test (1M):${normal}"
printf "%-30s\n" "-" | sed 's/\s/-/g'
disk_report fio
warn_nvme_gen3_links
echo -e "\n"

# run 7zip benchmark test
echo -e "\n${cyan}Running 7zip benchmark test...${normal}"
printf "%-30s\n" "-" | sed 's/\s/-/g'
if [ -x "$(command -v 7za)" ]; then
    command=7za
elif [ -x "$(command -v 7zr)" ]; then
    command=7zr
else
    command=7zip
fi
result=$($command b | tail -2)
compressing=$(echo "$result" | awk '{print $4}' | head -1)
decompressing=$(echo "$result" | awk '{print $8}' | head -1)
total=$(echo "$result" | awk '{print $4}' | tail -1)
printf "%-24s%s\n" "Compressing:" "${cyan}$compressing${normal}"
printf "%-24s%s\n" "Decompressing:" "${cyan}$decompressing${normal}"

# Calculate the difference between compressing and decompressing values
diff=$((decompressing - compressing))
percent_diff=$((100 * diff / decompressing))

if [ "$percent_diff" -gt 25 ]; then
  # Change the color of total value to green
  printf "%-24s%s\n" "Total:" "${yellow}$total${normal}"
else
  printf "%-24s%s\n" "Total:" "${green}$total${normal}"
fi

echo -e "\n"
cpu_err_warn_any

# Adding delay and "CPU cooling down..." message
for i in $(seq 1 3); do
  printf "\r${cyan}CPU cooling down${normal}"
  for j in $(seq 1 $i); do
    printf "."
  done
  sleep 1
done
printf "\r%s" "                                   "

# Run final checklist
echo -e "\n${cyan}Running final checklist...${normal}"
printf "%-26s\n" "-" | sed 's/\s/-/g'
printf 'Hyperthreading: %-8s%s'; sed -e s/1/${green}ENABLED${normal}/ -e s/0/${red}DISABLED${normal}/ /sys/devices/system/cpu/smt/active
printf 'Virtualization: %-8s%s'; if [ ! -e /dev/kvm ]; then echo "${red}DISABLED${normal}"; else echo "${green}ENABLED${normal}"; fi
if [ "$(sensors | grep Package)" ]; then
    printf 'CPU temperature: %-7s%s'; sensors | grep Package | awk '{print $4}' | tr -d "+" | head -1 | cut -c1-2 | awk '{ if ($1 >= 75 && $1 < 94) printf ("%s%s%s\n", "'"$red"'", "'"HOT"'", "'"$normal"'"); else if ($1 > 93) printf ("%s%s%s\n","'"$red"'", "'"VERY HOT"'", "'"$normal"'"); else printf ("%s%s%s\n", "'"$green"'", "'"GOOD"'", "'"$normal"'"); }';
fi
if [ -x "$(command -v getenforce)" ]; then
printf 'SELinux: %-15s%s'; getenforce | sed -e s/Disabled/${red}DISABLED${normal}/ -e s/Enforcing/${green}ENFORCING${normal}/ -e s/Permissive/${yellow}PERMISSIVE${normal}/
fi
printf 'IPv6: %-18s%s'; sed -e s/0/${green}ENABLED${normal}/ -e s/1/${red}DISABLED${normal}/ /sys/module/ipv6/parameters/disable
if [ -x /bin/ping ]; then
    for site in "Cloudflare:1.1.1.1" "Google:8.8.8.8" "Level3:4.2.2.2" "Mirror:mirror.trouble-free.net"; do
        name=$(echo "$site" | cut -d: -f1)
        addr=$(echo "$site" | cut -d: -f2)
        if ping "$addr" -c 2 > /dev/null 2>&1; then
            status="${green}GOOD${normal}"
        else
            status="${red}oh nooooo${normal}"
        fi
        printf "%-23s %s\n" "${name} PING:" "$status"
    done
else
    echo 'Missing /bin/ping'
fi
echo -e "\n\n"

# install and run memtester if available
if command -v memtester >/dev/null 2>&1 || {
    if command -v apt >/dev/null 2>&1; then
        apt update && apt -y install memtester > /dev/null 2>&1
    elif command -v yum >/dev/null 2>&1; then
        yum -y install memtester > /dev/null 2>&1
    elif command -v pacman >/dev/null 2>&1; then
        pacman -Sy --noconfirm memtester > /dev/null 2>&1
    else
        false
    fi
    command -v memtester >/dev/null 2>&1
}; then
    echo -e "${cyan}Running memtester quick test...${normal}"
    printf "%-31s\n" "-" | sed 's/\s/-/g'
    memtester 1G 1 | grep -A18 "Stuck Address"
else
    exit 1
fi

cancel