#!/bin/bash #============================================================================== # Drive Atlas - Server Drive Mapping Tool # Maps physical drive bays to logical device names using PCI paths #============================================================================== # Shell safety options: # -o pipefail: Exit status of pipe is rightmost non-zero exit code # Note: Not using -e (errexit) to allow graceful degradation when tools fail # Note: Not using -u (nounset) as script uses ${var:-default} patterns set -o pipefail # Require bash 4.2+ for declare -g -A (global associative arrays) if ((BASH_VERSINFO[0] < 4 || (BASH_VERSINFO[0] == 4 && BASH_VERSINFO[1] < 2))); then echo "ERROR: This script requires Bash 4.2 or higher (current: $BASH_VERSION)" >&2 exit 1 fi VERSION="1.1.0" #------------------------------------------------------------------------------ # Cleanup Trap # Ensures temporary directories are removed on exit or interruption #------------------------------------------------------------------------------ cleanup() { if [[ -n "${SMART_CACHE_DIR:-}" && -d "$SMART_CACHE_DIR" ]]; then rm -rf "$SMART_CACHE_DIR" fi } trap cleanup EXIT INT TERM #------------------------------------------------------------------------------ # Path Constants # Centralized path definitions to avoid hardcoding throughout the script #------------------------------------------------------------------------------ readonly DISK_BY_PATH="/dev/disk/by-path" #------------------------------------------------------------------------------ # maybe_sudo # # Runs a privileged command. When already root (e.g. PBS/minimal Debian, which # may not even have sudo installed), runs it directly; otherwise prefixes sudo. # Args: the command and its arguments. #------------------------------------------------------------------------------ maybe_sudo() { if [[ $EUID -eq 0 ]]; then "$@" elif command -v sudo &>/dev/null; then sudo "$@" else "$@" fi } #------------------------------------------------------------------------------ # smart_collect DEVICE OUTFILE # # Runs smartctl and writes the raw output to OUTFILE, auto-selecting a device # type. USB-attached drives (e.g. NVMe behind a JMicron/Realtek/ASMedia bridge, # as on the NUC-based pbs) are not readable with a plain call and need an # explicit -d; try common bridge types and keep the first that yields a real # identity/health line so we don't mislabel the drive (wrong type / false ✗). #------------------------------------------------------------------------------ smart_collect() { local dev="$1" out="$2" local tran raw d local -a dtypes=("") tran="$(lsblk -dn -o TRAN "/dev/$dev" 2>/dev/null | tr -d '[:space:]')" if [[ "$tran" == "usb" ]]; then dtypes+=("sntjmicron" "sntrealtek" "sntasmedia" "sat") fi for d in "${dtypes[@]}"; do if [[ -z "$d" ]]; then raw="$(maybe_sudo smartctl -A -i -H "/dev/$dev" 2>/dev/null)" else raw="$(maybe_sudo smartctl -d "$d" -A -i -H "/dev/$dev" 2>/dev/null)" fi if printf '%s' "$raw" | grep -qiE 'Serial Number:|Device Model:|Model Number:|SMART overall-health'; then printf '%s\n' "$raw" > "$out" return 0 fi done printf '%s\n' "${raw:-}" > "$out" } #------------------------------------------------------------------------------ # show_usage # # Displays help message with usage information and available options. #------------------------------------------------------------------------------ show_usage() { cat << EOF Drive Atlas v${VERSION} - Server Drive Mapping Tool Maps physical drive bays to logical device names using PCI paths. Displays visual chassis layouts and comprehensive drive information. USAGE: $(basename "$0") [OPTIONS] OPTIONS: -h, --help Show this help message and exit -v, --version Show version information -d, --debug Enable debug output (show drive mappings) -s, --skip-smart Skip SMART data collection (faster) -c, --color Enable colored output --verbose Show detailed error messages and warnings --no-ceph Skip Ceph OSD information --show-pci Show PCI paths in output --diagnose Show all PCI paths and block devices (for mapping new servers) EXAMPLES: $(basename "$0") # Normal run with all features $(basename "$0") --skip-smart # Fast run without SMART data $(basename "$0") --color # Run with colored output $(basename "$0") --verbose # Show all errors and warnings $(basename "$0") --debug # Show mapping debug info $(basename "$0") --diagnose # Gather PCI paths for new server setup ENVIRONMENT VARIABLES: DEBUG=1 Same as --debug flag For more information, see: https://code.lotusguild.org/LotusGuild/driveAtlas EOF } #------------------------------------------------------------------------------ # Command Line Argument Parsing #------------------------------------------------------------------------------ SKIP_SMART=false SKIP_CEPH=false SHOW_PCI=false USE_COLOR=false VERBOSE=false RUN_DIAGNOSE=false while [[ $# -gt 0 ]]; do case "$1" in -h|--help) show_usage exit 0 ;; -v|--version) echo "Drive Atlas v${VERSION}" exit 0 ;; -d|--debug) DEBUG=1 shift ;; -s|--skip-smart) SKIP_SMART=true shift ;; --no-ceph) SKIP_CEPH=true shift ;; --show-pci) SHOW_PCI=true shift ;; -c|--color) USE_COLOR=true shift ;; --verbose) VERBOSE=true shift ;; --diagnose) RUN_DIAGNOSE=true shift ;; *) echo "Unknown option: $1" >&2 echo "Use --help for usage information." >&2 exit 1 ;; esac done #------------------------------------------------------------------------------ # Color Definitions # ANSI escape codes for terminal colors #------------------------------------------------------------------------------ if [[ "$USE_COLOR" == true ]]; then COLOR_RESET='\033[0m' COLOR_RED='\033[0;31m' COLOR_GREEN='\033[0;32m' COLOR_YELLOW='\033[0;33m' COLOR_BLUE='\033[0;34m' COLOR_CYAN='\033[0;36m' COLOR_BOLD='\033[1m' else COLOR_RESET='' COLOR_RED='' COLOR_GREEN='' COLOR_YELLOW='' COLOR_BLUE='' COLOR_CYAN='' COLOR_BOLD='' fi #------------------------------------------------------------------------------ # colorize_health # # Returns health indicator with appropriate color # Args: $1 - health status (✓ or ✗) #------------------------------------------------------------------------------ colorize_health() { local health="$1" if [[ "$USE_COLOR" == true ]]; then if [[ "$health" == "✓" ]]; then printf '%b%s%b' "$COLOR_GREEN" "$health" "$COLOR_RESET" else printf '%b%s%b' "$COLOR_RED" "$health" "$COLOR_RESET" fi else printf '%s' "$health" fi } #------------------------------------------------------------------------------ # colorize_temp # # Returns temperature with color based on value # Args: $1 - temperature string (e.g., "45°C") #------------------------------------------------------------------------------ colorize_temp() { local temp_str="$1" local temp_val if [[ "$USE_COLOR" != true || "$temp_str" == "-" ]]; then echo "$temp_str" return fi # Extract numeric value temp_val="${temp_str%°C}" if [[ "$temp_val" =~ ^[0-9]+$ ]]; then if [[ "$temp_val" -ge 60 ]]; then printf '%b%s%b' "$COLOR_RED" "$temp_str" "$COLOR_RESET" elif [[ "$temp_val" -ge 50 ]]; then printf '%b%s%b' "$COLOR_YELLOW" "$temp_str" "$COLOR_RESET" else printf '%b%s%b' "$COLOR_GREEN" "$temp_str" "$COLOR_RESET" fi else printf '%s' "$temp_str" fi } #------------------------------------------------------------------------------ # colorize_header # # Returns header text in blue/bold # Args: $1 - header text #------------------------------------------------------------------------------ colorize_header() { if [[ "$USE_COLOR" == true ]]; then printf '%b%b%s%b\n' "$COLOR_BLUE" "$COLOR_BOLD" "$1" "$COLOR_RESET" else printf '%s\n' "$1" fi } #------------------------------------------------------------------------------ # log_error # # Logs an error message to stderr. Always shown regardless of verbose mode. # Args: $1 - error message #------------------------------------------------------------------------------ log_error() { if [[ "$USE_COLOR" == true ]]; then printf '%bERROR:%b %s\n' "$COLOR_RED" "$COLOR_RESET" "$1" >&2 else printf 'ERROR: %s\n' "$1" >&2 fi } #------------------------------------------------------------------------------ # log_warn # # Logs a warning message to stderr. Only shown in verbose mode. # Args: $1 - warning message #------------------------------------------------------------------------------ log_warn() { if [[ "$VERBOSE" == true ]]; then if [[ "$USE_COLOR" == true ]]; then printf '%bWARN:%b %s\n' "$COLOR_YELLOW" "$COLOR_RESET" "$1" >&2 else printf 'WARN: %s\n' "$1" >&2 fi fi } #------------------------------------------------------------------------------ # log_info # # Logs an informational message to stderr. Only shown in verbose mode. # Args: $1 - info message #------------------------------------------------------------------------------ log_info() { if [[ "$VERBOSE" == true ]]; then if [[ "$USE_COLOR" == true ]]; then printf '%bINFO:%b %s\n' "$COLOR_CYAN" "$COLOR_RESET" "$1" >&2 else printf 'INFO: %s\n' "$1" >&2 fi fi } #------------------------------------------------------------------------------ # Dependency Checks # Verifies required commands are available before running #------------------------------------------------------------------------------ # Required dependencies (script will not function without these) REQUIRED_DEPS=(lsblk lspci readlink hostname) # Optional dependencies (enhanced functionality) OPTIONAL_DEPS=(smartctl ceph ceph-volume bc nvme) FRESH_START_URL="http://10.10.10.63:3000/LotusGuild/freshStartScript/raw/branch/main/freshStart.sh" #------------------------------------------------------------------------------ # check_dependencies # # Verifies required and optional commands are available. # Exits with error if required dependencies are missing. # Warns about missing optional dependencies. #------------------------------------------------------------------------------ check_dependencies() { local missing_required=() local missing_optional=() # Check required dependencies for cmd in "${REQUIRED_DEPS[@]}"; do if ! command -v "$cmd" &>/dev/null; then missing_required+=("$cmd") fi done # Check optional dependencies for cmd in "${OPTIONAL_DEPS[@]}"; do if ! command -v "$cmd" &>/dev/null; then missing_optional+=("$cmd") fi done # Report missing required dependencies and exit if [[ ${#missing_required[@]} -gt 0 ]]; then echo "ERROR: Missing required dependencies: ${missing_required[*]}" >&2 echo "" >&2 echo "Please install the missing packages or run the fresh start script:" >&2 echo " curl -s $FRESH_START_URL | bash" >&2 echo "" >&2 exit 1 fi # Warn about missing optional dependencies if [[ ${#missing_optional[@]} -gt 0 ]]; then echo "Note: Some optional features unavailable. Missing: ${missing_optional[*]}" >&2 echo " Install them or run: curl -s $FRESH_START_URL | bash" >&2 echo "" >&2 fi # Check for sudo access (needed for smartctl) if command -v smartctl &>/dev/null && [[ $EUID -ne 0 ]] && ! sudo -n true 2>/dev/null; then echo "Note: SMART data requires root. Run with sudo (or as root) for full functionality." >&2 fi } # Run dependency check at script start check_dependencies #------------------------------------------------------------------------------ # run_diagnose # # Displays all PCI disk paths, storage controllers, and block devices. # Used to gather information needed when mapping a new server. #------------------------------------------------------------------------------ run_diagnose() { local hostname hostname="$(hostname)" echo "=== Server Information ===" echo "Hostname: $hostname" echo "Date: $(date)" echo "" echo "=== Storage Controllers ===" lspci 2>/dev/null | grep -iE "SAS|SATA|RAID|Mass storage|NVMe" echo "" echo "=== All /dev/disk/by-path/ entries (whole disks only) ===" for path in "${DISK_BY_PATH}"/*; do [[ -L "$path" ]] || continue # Skip partitions [[ "$path" =~ -part[0-9]+$ ]] && continue local basename_path target device size serial model basename_path="$(basename "$path")" target="$(readlink -f "$path")" device="$(basename "$target")" size="$(lsblk -d -n -o SIZE "$target" 2>/dev/null | xargs)" printf " %-55s -> %-10s %s\n" "$basename_path" "$device" "${size:+($size)}" done echo "" echo "=== Block Devices ===" lsblk -d -o NAME,SIZE,TYPE,TRAN 2>/dev/null | grep -v "rbd\|loop" echo "" # Check if this server has a mapping local sanitized sanitized="$(echo "$hostname" | tr -cd '[:alnum:]-_.')" if [[ -n "${SERVER_MAPPINGS[$sanitized]:-}" ]]; then echo "=== Current Mapping for $sanitized ===" echo "${SERVER_MAPPINGS[$sanitized]}" | while read -r pci_path bay; do [[ -z "$pci_path" || -z "$bay" ]] && continue if [[ -L "${DISK_BY_PATH}/$pci_path" ]]; then local dev dev="$(readlink -f "${DISK_BY_PATH}/$pci_path" | sed 's/.*\///')" printf " Bay %-5s %-55s -> %s\n" "$bay" "$pci_path" "$dev" else printf " Bay %-5s %-55s -> (not connected)\n" "$bay" "$pci_path" fi done else echo "NOTE: No mapping exists yet for '$sanitized'." echo "Use the PCI paths above to create a SERVER_MAPPINGS entry." fi exit 0 } #------------------------------------------------------------------------------ # Chassis Layout Generator Functions # These define the physical layout and display formatting for each chassis type #------------------------------------------------------------------------------ #------------------------------------------------------------------------------ # generate_10bay_layout # # Generates ASCII art representation of a 10-bay hot-swap chassis (Sliger CX4712). # Shows storage controllers, M.2 NVMe slot, and 10 front hot-swap bays. # # Args: # $1 - Hostname to display in the layout header # # Side effects: Calls build_drive_map() to populate DRIVE_MAP #------------------------------------------------------------------------------ generate_10bay_layout() { local hostname="$1" build_drive_map # Box interior width = 136 (determined by 10 bay boxes: 4 + 10*13 + 2) # Total box width = 138 (136 interior + 2 for │ borders) # Main chassis section printf "┌────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐\n" printf "│ %-132s │\n" "$hostname - Sliger CX4712 (10x 3.5\" Hot-swap)" printf "│%-136s│\n" "" # Show storage controllers printf "│ %-134s│\n" "Storage Controllers:" while IFS= read -r ctrl; do [[ -n "$ctrl" ]] && printf "│ %-134.134s│\n" "$ctrl" done < <(get_storage_controllers) printf "│%-136s│\n" "" # M.2 NVMe slot if present if [[ -n "${DRIVE_MAP[m2-1]}" ]]; then printf "│ %-134s│\n" " M.2 NVMe: ${DRIVE_MAP[m2-1]}" printf "│%-136s│\n" "" fi # Internal (non-bay) drives if present local int_keys int_keys="$(printf '%s\n' "${!DRIVE_MAP[@]}" | grep -E '^int-' | sort)" if [[ -n "$int_keys" ]]; then while IFS= read -r int_key; do printf "│ %-134s│\n" " Internal (non-bay): ${DRIVE_MAP[$int_key]}" done <<< "$int_keys" printf "│%-136s│\n" "" fi printf "│ %-134s│\n" " Front Hot-swap Bays:" printf "│%-136s│\n" "" # Bay top borders printf "│ " for bay in {1..10}; do printf "┌──────────┐ " done printf " │\n" # Bay contents printf "│ " for bay in {1..10}; do printf "│%-2d:%-7s│ " "$bay" "${DRIVE_MAP[$bay]:-EMPTY}" done printf " │\n" # Bay bottom borders printf "│ " for bay in {1..10}; do printf "└──────────┘ " done printf " │\n" printf "└────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘\n" } #------------------------------------------------------------------------------ # generate_micro_layout # # Generates ASCII art representation of a micro SBC (e.g., ZimaBoard). # Shows storage controllers, onboard eMMC (if present), and 2 SATA ports. # # Args: # $1 - Hostname to display in the layout header # # Side effects: Calls build_drive_map() to populate DRIVE_MAP #------------------------------------------------------------------------------ generate_micro_layout() { local hostname="$1" build_drive_map # Check for eMMC storage local emmc_device="" if [[ -b /dev/mmcblk0 ]]; then emmc_device="mmcblk0" fi printf "┌─────────────────────────────────────────────────────────────┐\n" printf "│ %-57s │\n" "$hostname - Micro SBC" printf "│ │\n" printf "│ Storage Controllers: │\n" while IFS= read -r ctrl; do [[ -n "$ctrl" ]] && printf "│ %-57.57s│\n" "$ctrl" done < <(get_storage_controllers) printf "│ │\n" # Show eMMC if present if [[ -n "$emmc_device" ]]; then local emmc_size emmc_size=$(lsblk -d -n -o SIZE "/dev/$emmc_device" 2>/dev/null | xargs) printf "│ ┌─────────────────────────────────────────────────────┐ │\n" printf "│ │ Onboard eMMC: %-10s (%s) │ │\n" "$emmc_device" "$emmc_size" printf "│ └─────────────────────────────────────────────────────┘ │\n" printf "│ │\n" fi printf "│ SATA Ports (rear): │\n" printf "│ ┌──────────────┐ ┌──────────────┐ │\n" printf "│ │ 1: %-9s │ │ 2: %-9s │ │\n" "${DRIVE_MAP[1]:-EMPTY}" "${DRIVE_MAP[2]:-EMPTY}" printf "│ └──────────────┘ └──────────────┘ │\n" printf "└─────────────────────────────────────────────────────────────┘\n" } #------------------------------------------------------------------------------ # generate_nuc_layout # # Generates ASCII art for an Intel NUC (e.g., pbs = NUC5i5RYB): one internal # 2.5"/M.2 SATA drive plus two rear USB 3.0 ports (stacked top/bottom), used # here for USB-attached NVMe. Bays: int-os, usb-top, usb-bot. # # Args: # $1 - Hostname to display in the layout header # # Side effects: Calls build_drive_map() to populate DRIVE_MAP #------------------------------------------------------------------------------ # ══ driveAtlas :: color + glyph helpers ═══════════════════════════════════════ # da_repeat GLYPH N -- print GLYPH N times (multibyte-safe) da_repeat() { local out='' i for ((i = 0; i < $2; i++)); do out+="$1"; done printf '%s' "$out" } # da_color_init -- set the driveAtlas "hardware schematic" palette globals. # Structure is steel grey; color encodes STATE only (green=ok, amber/yellow, # red=hot, blue=cool). All vars are empty strings when color is off, so # rendering is byte-identical to pure monochrome. # USE_COLOR=true force on (depth still auto-picked) # USE_COLOR=false force off # unset/auto auto: off if NO_COLOR set, stdout not a tty, # or terminal reports < 256 colors # Depth: truecolor only when COLORTERM=truecolor/24bit, else 256, else 16. da_color_init() { DA_ST='' DA_HL='' DA_DIM='' DA_OK='' DA_YEL='' DA_HOT='' DA_BLU='' DA_CYN='' DA_SR='' DA_RST='' local mode="${USE_COLOR:-auto}" ncolors ncolors="$(tput colors 2>/dev/null)"; ncolors="${ncolors:-0}" case "$mode" in false) return 0 ;; auto) [ -n "${NO_COLOR-}" ] && return 0 [ ! -t 1 ] && return 0 [ "$ncolors" -lt 256 ] 2>/dev/null && return 0 ;; esac if [ "${COLORTERM-}" = "truecolor" ] || [ "${COLORTERM-}" = "24bit" ]; then DA_ST=$'\033[38;2;138;144;151m' # steel mid #8a9097 DA_HL=$'\033[38;2;200;205;211m' # steel bright #c8cdd3 DA_DIM=$'\033[38;2;86;93;102m' # steel shadow #565d66 DA_OK=$'\033[38;2;51;209;122m' # LED green #33d17a DA_YEL=$'\033[38;2;246;196;69m' # LED amber #f6c445 DA_HOT=$'\033[38;2;255;77;77m' # LED red #ff4d4d DA_BLU=$'\033[38;2;77;184;255m' # cool blue #4db8ff DA_CYN=$'\033[38;2;77;216;230m' # cyan accent #4dd8e6 elif [ "$ncolors" -ge 256 ] 2>/dev/null; then DA_ST=$'\033[38;5;245m' DA_HL=$'\033[38;5;252m' DA_DIM=$'\033[38;5;238m' DA_OK=$'\033[38;5;40m' DA_YEL=$'\033[38;5;214m' DA_HOT=$'\033[38;5;196m' DA_BLU=$'\033[38;5;39m' DA_CYN=$'\033[38;5;51m' else DA_ST=$'\033[37m' DA_HL=$'\033[1;37m' DA_DIM=$'\033[90m' DA_OK=$'\033[32m' DA_YEL=$'\033[33m' DA_HOT=$'\033[31m' DA_BLU=$'\033[34m' DA_CYN=$'\033[36m' fi DA_RST=$'\033[0m' DA_SR="${DA_RST}${DA_ST}" # "return to structure": reset attrs, steel mid } # da_gauge PCT WIDTH -- smooth eighth-block capacity gauge over a dim track, # e.g. "da_gauge 62 15" -> "████████▋░░░░░░". Color it by level at call site # (DA_OK < 70, DA_YEL < 90, DA_HOT >= 90); pad-then-color as usual. da_gauge() { local pct="${1:-0}" w="${2:-10}" full rem cells out='' i local eighth=('' '▏' '▎' '▍' '▌' '▋' '▊' '▉') [ "$pct" -lt 0 ] 2>/dev/null && pct=0 [ "$pct" -gt 100 ] 2>/dev/null && pct=100 full=$(( pct * w / 100 )); rem=$(( (pct * w * 8 / 100) % 8 )); cells=$full for ((i = 0; i < full; i++)); do out+='█'; done if [ "$rem" -gt 0 ] && [ "$full" -lt "$w" ]; then out+="${eighth[rem]}"; cells=$((cells + 1)) fi for ((i = cells; i < w; i++)); do out+='░'; done printf '%s' "$out" } # ══ driveAtlas :: NUC5i5RYB/RYH chassis + drive-slot map ══════════════════════ # 88-col cabinet-projection rendering with live device names from the global # associative array DRIVE_MAP (keys: int-os usb-fl usb-fr usb-rt usb-rb). # Occupied ports: solid light boxes, green LED bar + device. EMPTY ports: # dashed ghost boxes, dim. Alignment: every variable field is padded to its # final width BEFORE color codes wrap it; borders are literal strings. # # The art printfs embed our own ANSI colour vars (DA_*) and literal box-drawing # in the format string by design; they contain no '%' and no user data (device # names are passed as %s args), so SC2059 does not apply here. # shellcheck disable=SC2059 generate_nuc_layout() { build_drive_map local host="${1:-unknown}" local model="" if command -v maybe_sudo >/dev/null 2>&1; then model="$(maybe_sudo dmidecode -s baseboard-product-name 2>/dev/null | head -n1)" fi [ -n "$model" ] || model="NUC5i5RYB/RYH" da_color_init # fixed-width header fields (pad/truncate so the frame never moves) local hostp modelp printf -v hostp '%-22.22s' "$host" printf -v modelp '%-14.14s' "$model" # per-USB-slot pieces: device field (6 cols: LED bar + 5-char name), # box side glyph, label color, border dash -- ghost styling for EMPTY local fl fr rt rb io fls frs rts rbs flc frc rtc rbc fld frd rtd rbd local flt frt flb frb rtt rbb local pre key col v p for pre in fl:usb-fl:B fr:usb-fr:Y rt:usb-rt:B rb:usb-rb:B; do key="${pre#*:}"; key="${key%:*}"; col="${pre##*:}"; pre="${pre%%:*}" v="${DRIVE_MAP[$key]:-EMPTY}" if [ "$v" = "EMPTY" ]; then printf -v p ' %-5.5s' "$v" printf -v "$pre" '%s' "${DA_DIM}${p}${DA_SR}" printf -v "${pre}s" '%s' "${DA_DIM}╎${DA_SR}" printf -v "${pre}c" '%s' "${DA_DIM}" printf -v "${pre}d" '%s' '╌' else printf -v p '%-5.5s' "$v" printf -v "$pre" '%s' "${DA_OK}▌${p}${DA_SR}" printf -v "${pre}s" '%s' '│' [ "$col" = "Y" ] && printf -v "${pre}c" '%s' "${DA_YEL}" \ || printf -v "${pre}c" '%s' "${DA_BLU}" printf -v "${pre}d" '%s' '─' fi done # box edges (11 cols; front tops carry the callout stem junction) flt="$(da_repeat "$fld" 5)┴$(da_repeat "$fld" 5)" frt="┴$(da_repeat "$frd" 10)" flb="$(da_repeat "$fld" 11)"; frb="$(da_repeat "$frd" 11)" rtt="$(da_repeat "$rtd" 11)"; rbb="$(da_repeat "$rbd" 11)" [ "$fld" = '╌' ] && { flt="${DA_DIM}${flt}${DA_SR}"; flb="${DA_DIM}${flb}${DA_SR}"; } [ "$frd" = '╌' ] && { frt="${DA_DIM}${frt}${DA_SR}"; frb="${DA_DIM}${frb}${DA_SR}"; } [ "$rtd" = '╌' ] && rtt="${DA_DIM}${rtt}${DA_SR}" [ "$rbd" = '╌' ] && rbb="${DA_DIM}${rbb}${DA_SR}" # internal 2.5" SATA (int-os) v="${DRIVE_MAP[int-os]:-EMPTY}" if [ "$v" = "EMPTY" ]; then printf -v p ' %-5.5s' "$v"; io="${DA_DIM}${p}${DA_SR}" else printf -v p '%-5.5s' "$v"; io="${DA_OK}▌${p}${DA_SR}" fi printf "${DA_ST}${DA_HL}┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓${DA_SR}${DA_RST}\n" printf "${DA_ST}${DA_HL}┃${DA_SR} ${DA_CYN}driveAtlas${DA_SR} :: ${DA_HL}%s${DA_SR} %s - 115x111x49 mm - tall (RYH) kit ${DA_HL}┃${DA_SR}${DA_RST}\n" "$hostp" "$modelp" printf "${DA_ST}${DA_HL}┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛${DA_SR}${DA_RST}\n" printf " \n" printf "${DA_ST} FRONT 3/4 ── cool intake side REAR ── hot exhaust side ${DA_RST}\n" printf " \n" printf "${DA_ST} ${DA_DIM}▄▄▄▄▄▄ ▄▄▄▄▄▄${DA_SR} < CPU fan vents ${DA_RST}\n" printf "${DA_ST} ${DA_HOT} v v v hot air${DA_SR} ${DA_RST}\n" printf "${DA_ST} ${DA_HL}┌──────────────────────────┐${DA_SR} ${DA_HL}╭────────────────────────────────╮${DA_SR} ${DA_RST}\n" printf "${DA_ST} ${DA_HL}╱${DA_SR}${DA_DIM}░░░─░░░░░░░─░░░░░░░░─░░░░░${DA_SR}${DA_HL}╱│${DA_SR} ${DA_HL}│${DA_SR} ┌%s┐ ${DA_HL}│${DA_SR} ${DA_RST}\n" "$rtt" printf "${DA_ST} ${DA_HL}╱${DA_SR}${DA_DIM}░${DA_SR}${DA_OK}(o)${DA_SR} pwr ${DA_DIM}░░─░░░░░─░░░░░░░─${DA_SR}${DA_HL}╱${DA_SR}${DA_DIM}▒${DA_SR}${DA_HL}│${DA_SR} ${DA_HL}│${DA_SR} (o) ▐═▌ ▐╬▌ %s %s3-4 BLUE${DA_SR} %s ▐▄▌ ${DA_HL}│${DA_SR} ${DA_RST}\n" "$rts" "$rtc" "$rts" printf "${DA_ST} ${DA_HL}┌──────────────────────────┐${DA_SR}${DA_DIM}▒▒${DA_SR}${DA_HL}│${DA_SR} ${DA_HL}│${DA_SR} DC mDP GbE %s %s %smHDMI${DA_HL}│${DA_SR} ${DA_RST}\n" "$rts" "$rt" "$rts" printf "${DA_ST} ${DA_HL}│${DA_SR} ╌ brushed aluminum band ╌${DA_HL}│${DA_SR}${DA_DIM}▒${DA_SR}${DA_HL}╱${DA_SR} ${DA_HL}│${DA_SR} ├───────────┤ ${DA_HL}│${DA_SR} ${DA_RST}\n" printf "${DA_ST} ${DA_HL}│${DA_SR} ${DA_BLU}▐███▌${DA_SR} ${DA_YEL}▐███▌${DA_SR} (o) . ${DA_HL}│╱${DA_SR} ${DA_HL}│${DA_SR} %s %s3-3 BLUE${DA_SR} %s ${DA_HL}│${DA_SR}${DA_HOT}< bakes in${DA_SR} ${DA_RST}\n" "$rbs" "$rbc" "$rbs" printf "${DA_ST} ${DA_HL}└────┬───────┬─────────────┘${DA_SR} ${DA_HL}│${DA_SR} %s %s %s ${DA_HL}│${DA_SR}${DA_HOT} CPU exhaust${DA_SR}${DA_RST}\n" "$rbs" "$rb" "$rbs" printf "${DA_ST} │ │ audio IR ${DA_HL}│${DA_SR} └%s┘ ${DA_HL}│${DA_SR} ${DA_RST}\n" "$rbb" printf "${DA_ST} ┌%s┐┌%s┐ ${DA_HL}╰────────────────────────────────╯${DA_SR} ${DA_RST}\n" "$flt" "$frt" printf "${DA_ST} %s %s3-2 BLUE${DA_SR} %s%s%s3-1? YELLOW${DA_SR}%s ${DA_DIM}▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀${DA_SR} ${DA_RST}\n" "$fls" "$flc" "$fls" "$frs" "$frc" "$frs" printf "${DA_ST} %s %s %s%s %s %s ${DA_RST}\n" "$fls" "$fl" "$fls" "$frs" "$fr" "$frs" printf "${DA_ST} %s USB3 data %s%s charging %s ${DA_RST}\n" "$fls" "$fls" "$frs" "$frs" printf "${DA_ST} └%s┘└%s┘ ${DA_RST}\n" "$flb" "$frb" printf " \n" printf "${DA_ST} ${DA_HL}UNDERSIDE / INSIDE${DA_SR} ${DA_HL}NOTES${DA_SR} ${DA_RST}\n" printf "${DA_ST} ┌──────────────────────────────────┐ ${DA_RST}\n" printf "${DA_ST} │ internal 2.5\" SATA ── mounted │ - all 4 USB3 jacks hang off ONE xHCI ${DA_RST}\n" printf "${DA_ST} │ INVERTED in the bottom lid │ controller ── one shared kernel bus ${DA_RST}\n" printf "${DA_ST} │ %s < int-os - OS / boot │ - M.2 2280 slot ── flat on mainboard ${DA_RST}\n" "$io" printf "${DA_ST} │${DA_DIM} ╌╌╌╌╌ flex cable to mainboard ╌╌ ${DA_SR}│ - \"?\" = port 3-1 id inferred (unverified) ${DA_RST}\n" printf "${DA_ST} └──────────────────────────────────┘ ${DA_RST}\n" printf "${DA_ST} ${DA_DIM}o feet o────── VESA ──────o feet o${DA_SR} ${DA_RST}\n" # optional flourish: controller inventory from the existing helper if command -v get_storage_controllers >/dev/null 2>&1; then printf '\n %sSTORAGE CONTROLLERS%s\n' "${DA_HL}" "${DA_RST}" get_storage_controllers 2>/dev/null | sed "s/^/ /" fi } #------------------------------------------------------------------------------ # generate_large1_layout # # Generates ASCII art representation of a large1 chassis (Rosewill RSV-L4500U). # Shows storage controllers, 2 M.2 NVMe slots, and 15 front bays in 3x5 grid. # # Args: # $1 - Hostname to display in the layout header # # Side effects: Calls build_drive_map() to populate DRIVE_MAP #------------------------------------------------------------------------------ generate_large1_layout() { local hostname="$1" build_drive_map # large1 has 3 stacks of 5 bays at front (15 total) + 2 M.2 slots # Physical bay mapping TBD - current mapping is by controller order printf "┌─────────────────────────────────────────────────────────────────────────┐\n" printf "│ %-69s │\n" "$hostname - Rosewill RSV-L4500U (15x 3.5\" Bays)" printf "│ │\n" printf "│ Storage Controllers: │\n" while IFS= read -r ctrl; do [[ -n "$ctrl" ]] && printf "│ %-69.69s│\n" "$ctrl" done < <(get_storage_controllers) printf "│ │\n" printf "│ M.2 NVMe: M1: %-10s M2: %-10s │\n" "${DRIVE_MAP[m2-1]:-EMPTY}" "${DRIVE_MAP[m2-2]:-EMPTY}" printf "│ │\n" printf "│ Front Bays (3 stacks x 5 rows): [slot 5 of each stack MUST stay empty] │\n" printf "│ Stack A Stack B Stack C │\n" printf "│ ┌──────────┐ ┌──────────┐ ┌──────────┐ │\n" printf "│ │1:%-8s│ │2:%-8s│ │3:%-8s│ │\n" "${DRIVE_MAP[1]:-EMPTY}" "${DRIVE_MAP[2]:-EMPTY}" "${DRIVE_MAP[3]:-EMPTY}" printf "│ ├──────────┤ ├──────────┤ ├──────────┤ │\n" printf "│ │4:%-8s│ │5:%-8s│ │6:%-8s│ │\n" "${DRIVE_MAP[4]:-EMPTY}" "${DRIVE_MAP[5]:-EMPTY}" "${DRIVE_MAP[6]:-EMPTY}" printf "│ ├──────────┤ ├──────────┤ ├──────────┤ │\n" printf "│ │7:%-8s│ │8:%-8s│ │9:%-8s│ │\n" "${DRIVE_MAP[7]:-EMPTY}" "${DRIVE_MAP[8]:-EMPTY}" "${DRIVE_MAP[9]:-EMPTY}" printf "│ ├──────────┤ ├──────────┤ ├──────────┤ │\n" printf "│ │10:%-7s│ │11:%-7s│ │12:%-7s│ │\n" "${DRIVE_MAP[10]:-EMPTY}" "${DRIVE_MAP[11]:-EMPTY}" "${DRIVE_MAP[12]:-EMPTY}" printf "│ ├──────────┤ ├──────────┤ ├──────────┤ │\n" printf "│ │13:%-7s│ │14:%-7s│ │15:%-7s│ │\n" "${DRIVE_MAP[13]:-EMPTY}" "${DRIVE_MAP[14]:-EMPTY}" "${DRIVE_MAP[15]:-EMPTY}" printf "│ └──────────┘ └──────────┘ └──────────┘ │\n" printf "└─────────────────────────────────────────────────────────────────────────┘\n" } #------------------------------------------------------------------------------ # Server-Specific Drive Mappings # Maps PCI paths to physical bay numbers for each server # Format: "pci-path bay-number" #------------------------------------------------------------------------------ declare -A SERVER_MAPPINGS=( # compute-storage-01 (formerly medium2) # Motherboard: B650D4U3-2Q/BCM with AMD SATA controller # HBA: LSI SAS3008 at 01:00.0 (mini-SAS HD ports) # Cable mapping from user notes: # - Mobo SATA: top-right=bay1, bottom-right=bay2, bottom-left=bay3, top-left=bay4 # - HBA bottom mini-SAS: bays 5,6,7,8 # - HBA top mini-SAS: bays 9,10 ["compute-storage-01"]=" pci-0000:0d:00.0-ata-2 1 pci-0000:0d:00.0-ata-1 2 pci-0000:0d:00.0-ata-3 3 pci-0000:0d:00.0-ata-4 4 pci-0000:01:00.0-sas-phy6-lun-0 5 pci-0000:01:00.0-sas-phy7-lun-0 6 pci-0000:01:00.0-sas-phy5-lun-0 7 pci-0000:01:00.0-sas-phy2-lun-0 8 pci-0000:01:00.0-sas-phy4-lun-0 9 pci-0000:01:00.0-sas-phy3-lun-0 10 pci-0000:0e:00.0-nvme-1 m2-1 " # compute-storage-gpu-01 # Motherboard: ASUS PRIME B550-PLUS with AMD SATA controller at 05:00.1 # SATA ports run in reverse order for hot-swap bays (ata-5=bay2 .. ata-2=bay5) # ata-1 is the boot SSD sitting loose inside the chassis (not in a hot-swap bay) # sdf is USB/card reader - not mapped ["compute-storage-gpu-01"]=" pci-0000:05:00.1-ata-4 2 pci-0000:05:00.1-ata-5 3 pci-0000:05:00.1-ata-3 4 pci-0000:05:00.1-ata-2 5 pci-0000:05:00.1-ata-1 int-1 pci-0000:0c:00.0-nvme-1 m2-1 " # storage-01 # Motherboard: ASRock A320M-HDV R4.0 # AMD SATA controller at 02:00.1 (bays 1-4) # Mobo SATA physical layout: # top-left=bay 1, bottom-left=bay 2, top-right=bay 3, bottom-right=bay 4 # HBA: LSI SAS3416 at 01:00.0 (4x Mini-SAS HD ports, top=C0 to bottom=C3) # C0 (top): 4x SATA breakout → bays 5-8 # C1: 4x SATA breakout → bays 9-10 (2 of 4 ports used) # C2: U.2 NVMe (serial ends in 0d66) → u2-1 # C3: U.2 NVMe (serial ends in 0d4f) → u2-2 # C0: phy9=bay5 verified; phy11 present (23.6T, bay TBD) # C1: phy13=bay7 verified; bays 6,8,9,10 PHY mapping TBD # C2: U.2 NVMe (serial ends in 0d66) → u2-1 (needs FW update) # C3: U.2 NVMe (serial ends in 0d4f) → u2-2 (needs FW update) # Also present: 09:00.0 AMD FCH SATA Controller [AHCI mode] ["storage-01"]=" pci-0000:02:00.1-ata-1 1 pci-0000:02:00.1-ata-2 2 pci-0000:02:00.1-ata-5 3 pci-0000:02:00.1-ata-6 4 pci-0000:01:00.0-sas-phy9-lun-0 5 pci-0000:01:00.0-sas-phy13-lun-0 7 " # large1 # 3 stacks (A/B/C left-to-right) x 5 slots (1-5 top-to-bottom) = 15 bays # Bay numbering: A1=1, B1=2, C1=3, A2=4, B2=5, C2=6, A3=7, B3=8, C3=9, ... # # *** SLOT 5 IN ALL STACKS MUST REMAIN EMPTY *** # *** Drives are near-impossible to remove once inserted in slot 5 *** # *** B5 (bay 14) already has a permanently stuck drive (WD-CA19PTMK) *** # *** C5 (bay 15) has a permanently stuck but unplugged drive (unknown type) *** # # HBA: LSI SAS2008 at 10:00.0 -- 2x Slim-SAS to 4-port SATA breakout cables # Slim-SAS #0 (BLUE cables, connector closest to bracket/mounting edge): # Port 1 (phy3) -> C Slot 1 (bay 3) Port 2 (phy2) -> unconnected # Port 3 (phy1) -> A Slot 1 (bay 1) Port 4 (phy0) -> A Slot 2 (bay 4) # Slim-SAS #1 (SILVER cables, connector furthest from bracket): # Port 1 (phy7) -> B Slot 2 (bay 5) -- cable present, no drive yet # Port 2 (phy6) -> B Slot 5 (bay 14) -- STUCK, cannot remove # Port 3 (phy5) -> B Slot 4 (bay 11) # Port 4 (phy4) -> A Slot 3 (bay 7) # # Motherboard SATA (ORANGE cables) -- 6 ports in 3-column x 2-row cluster: # ASMedia 25:00.0 (2 ports): # ata-1 -> C Slot 3 (bay 9) [top-left orange port] # ata-2 -> B Slot 1 (bay 2) [bottom-left orange port] -- cable present, no drive # AMD 16:00.1 (3 of 8 ports connected to bays): # ata-3 -> C Slot 4 (bay 12) [bottom-right orange port] # ata-7 -> B Slot 3 (bay 8) [bottom-middle orange port] -- cable present, drive removed (was WD-CA2144YK) # ata-8 -> C Slot 2 (bay 6) [top-middle orange port] -- cable present, drive removed (was WD-CA28XYHK) # AMD FCH 31:00.0 / 31:00.1: no cables attached, ports unused ["large1"]=" pci-0000:10:00.0-sas-phy1-lun-0 1 pci-0000:25:00.0-ata-2 2 pci-0000:10:00.0-sas-phy3-lun-0 3 pci-0000:10:00.0-sas-phy0-lun-0 4 pci-0000:10:00.0-sas-phy7-lun-0 5 pci-0000:16:00.1-ata-8 6 pci-0000:10:00.0-sas-phy4-lun-0 7 pci-0000:16:00.1-ata-7 8 pci-0000:25:00.0-ata-1 9 pci-0000:10:00.0-sas-phy5-lun-0 11 pci-0000:16:00.1-ata-3 12 pci-0000:10:00.0-sas-phy6-lun-0 14 pci-0000:2a:00.0-nvme-1 m2-1 pci-0000:26:00.0-nvme-1 m2-2 " # micro1 / monitor-02 - ZimaBoard 832 (Apollo Lake N3450), physical layout # confirmed on-unit 2026-07-20: # FRONT face : video-out (mDP) left, then 2x USB 3.0 (blue), then DC barrel; # the 2x GbE sit on an UPPER tier directly ABOVE the two USB ports. # LEFT side : open-ended PCIe 2.0 x4 slot (expansion path; no M.2/mSATA). # REAR edge : 2x SATA-III (ata1/ata2 via AHCI 00:12.0) with the single # mini-4-pin SATA power header in the CENTER between them # (2 drives need a Y power cable). # Onboard : 32G eMMC (mmcblk0) = OS/boot, soldered (no by-path). ["micro1"]=" pci-0000:00:12.0-ata-1 sata-1 pci-0000:00:12.0-ata-2 sata-2 " ["monitor-02"]=" pci-0000:00:12.0-ata-1 sata-1 pci-0000:00:12.0-ata-2 sata-2 " # pbs # Intel NUC5i5RYB - Proxmox Backup Server # int-os : internal 2.5\" SATA SSD (Samsung MZNLN128) - OS/boot, controller 00:1f.2 # usb-fl : FRONT-LEFT USB 3.0 (blue) NVMe (Patriot P300 / JMicron bridge) - halfTbNVMeMirror # usb-fr : FRONT-RIGHT USB 3.0 (yellow, always-on charging) - normally empty # usb-rt : REAR-TOP USB 3.0 (blue) - now empty # usb-rb : REAR-BOTTOM USB 3.0 (blue) NVMe (Patriot P300 / JMicron bridge) - halfTbNVMeMirror # # The two USB bridges report an IDENTICAL serial, so these drives are keyed by USB # *port path* (usb-0:N = kernel bus3 port N), NOT by-id/serial. # Port jacks (LED-blink verified 2026-07-15; front-left re-verified 2026-07-18): # REAR-TOP jack = port 3-4 (usb-0:4) [blue] # REAR-BOTTOM jack = port 3-3 (usb-0:3) [blue] = fw serial P300WCBA24090617536 # FRONT-LEFT jack = port 3-2 (usb-0:2) [blue] = fw serial P300WCBA24090617615 # FRONT-RIGHT jack = port 3-1 (usb-0:1) [yellow] (port # unverified - jack empty) # # 2026-07-18: after a power outage the ...615 drive dropped to 0B / hardware-error in the # hot stacked REAR-TOP bay; moving it to FRONT-LEFT (3-2) revived it. Root cause was # thermal - the two NVMe USB bridges sat flush against each other in the rear stack. ["pbs"]=" pci-0000:00:1f.2-ata-4 int-os pci-0000:00:14.0-usb-0:2:1.0-scsi-0:0:0:0 usb-fl pci-0000:00:14.0-usb-0:1:1.0-scsi-0:0:0:0 usb-fr pci-0000:00:14.0-usb-0:4:1.0-scsi-0:0:0:0 usb-rt pci-0000:00:14.0-usb-0:3:1.0-scsi-0:0:0:0 usb-rb " ) declare -A CHASSIS_TYPES=( ["compute-storage-01"]="10bay" ["compute-storage-gpu-01"]="10bay" ["storage-01"]="10bay" ["large1"]="large1" ["micro1"]="zimaboard" # ZimaBoard 832 ["monitor-02"]="zimaboard" # ZimaBoard 832 ["pbs"]="nuc" # Intel NUC5i5RYB (1 internal SATA + 2 rear USB-NVMe) ) #------------------------------------------------------------------------------ # Core Functions #------------------------------------------------------------------------------ # Cache for lspci output (populated on first call) LSPCI_CACHE="" #------------------------------------------------------------------------------ # get_storage_controllers # # Returns a formatted list of storage controllers found via lspci. # Uses cached output if available to avoid redundant lspci calls. # # Output Format: " PCI_ADDR: DESCRIPTION" (one per line) #------------------------------------------------------------------------------ get_storage_controllers() { # Cache lspci output on first call if [[ -z "$LSPCI_CACHE" ]]; then LSPCI_CACHE="$(lspci 2>/dev/null | grep -iE "SAS|SATA|RAID|Mass storage|NVMe")" fi # Format and return cached output echo "$LSPCI_CACHE" | while read -r line; do [[ -z "$line" ]] && continue pci_addr="$(echo "$line" | awk '{print $1}')" # Get short description (strip PCI address) desc="${line#*[0-9a-f:.] }" echo " $pci_addr: $desc" done } #------------------------------------------------------------------------------ # build_drive_map # # Builds a global associative array mapping physical bay numbers to device names. # Uses PCI paths from SERVER_MAPPINGS to resolve current device assignments. # # Sets: # DRIVE_MAP (global associative array) # Keys: Bay identifiers (1, 2, ..., m2-1, m2-2, etc.) # Values: Device names (sda, nvme0n1, etc.) # BAY_TO_PCI_PATH (global associative array) # Keys: Bay identifiers # Values: PCI path strings (for --show-pci option) #------------------------------------------------------------------------------ build_drive_map() { local host host="$(hostname | tr -cd '[:alnum:]-_.')" local mapping="${SERVER_MAPPINGS[$host]}" # Declare global arrays directly declare -g -A DRIVE_MAP=() declare -g -A BAY_TO_PCI_PATH=() if [[ -z "$mapping" ]]; then log_warn "No drive mapping found for host '$host'. Run with --diagnose to gather PCI path info." return fi local mapped_count=0 local empty_count=0 while read -r path slot; do [[ -z "$path" || -z "$slot" ]] && continue BAY_TO_PCI_PATH[$slot]="$path" if [[ -L "${DISK_BY_PATH}/$path" ]]; then local drive drive="$(readlink -f "${DISK_BY_PATH}/$path" | sed 's/.*\///')" DRIVE_MAP[$slot]="$drive" ((mapped_count++)) else log_info "Bay $slot: No device at PCI path $path" ((empty_count++)) fi done <<< "$mapping" log_info "Mapped $mapped_count drives, $empty_count empty bays" } #------------------------------------------------------------------------------ # build_ceph_cache # # Queries Ceph once and builds lookup tables for OSD information. # This is much more efficient than querying ceph-volume per device. # # Sets global associative arrays: # CEPH_DEVICE_TO_OSD - Maps device names to OSD IDs (e.g., sda -> osd.5) # CEPH_OSD_STATUS - Maps OSD numbers to up/down status # CEPH_OSD_IN - Maps OSD numbers to in/out status #------------------------------------------------------------------------------ build_ceph_cache() { declare -g -A CEPH_DEVICE_TO_OSD=() declare -g -A CEPH_OSD_STATUS=() declare -g -A CEPH_OSD_IN=() # Skip if ceph-volume is not available if ! command -v ceph-volume &>/dev/null; then log_info "ceph-volume not found, skipping Ceph OSD detection" return fi log_info "Querying Ceph OSD information..." # Parse ceph-volume lvm list output # Format: blocks starting with "====== osd.X =======" followed by device info local current_osd="" local osd_count=0 while IFS= read -r line; do # Match OSD header: "====== osd.5 =======" or "====== osd.19 ======" # Number of trailing equals varies based on OSD number length if [[ "$line" =~ ======[[:space:]]+osd\.([0-9]+)[[:space:]]+====== ]]; then current_osd="osd.${BASH_REMATCH[1]}" # Match "devices" line which has the actual physical device: " devices /dev/sda" # This is more reliable than "block device" which may show LVM paths elif [[ -n "$current_osd" && "$line" =~ devices[[:space:]]+/dev/(sd[a-z]+|nvme[0-9]+n[0-9]+) ]]; then local dev_name="${BASH_REMATCH[1]}" CEPH_DEVICE_TO_OSD["$dev_name"]="$current_osd" ((osd_count++)) log_info "Found $current_osd on $dev_name" current_osd="" # Reset to avoid duplicate matches fi done < <(ceph-volume lvm list 2>/dev/null) log_info "Cached $osd_count Ceph OSDs" # Skip if ceph command is not available if ! command -v ceph &>/dev/null; then log_info "ceph CLI not found, skipping OSD status detection" return fi log_info "Querying Ceph OSD status..." # Parse ceph osd tree for status # Format: ID CLASS WEIGHT TYPE NAME STATUS REWEIGHT while IFS= read -r line; do # Match OSD lines: " 5 hdd 3.63660 osd.5 up 1.00000" if [[ "$line" =~ ^[[:space:]]*([0-9]+)[[:space:]]+.*osd\.([0-9]+)[[:space:]]+(up|down)[[:space:]]+([0-9.]+) ]]; then local osd_num="${BASH_REMATCH[1]}" local status="${BASH_REMATCH[3]}" local reweight="${BASH_REMATCH[4]}" CEPH_OSD_STATUS[$osd_num]="$status" # Determine in/out based on reweight if awk "BEGIN {exit !($reweight > 0)}"; then CEPH_OSD_IN[$osd_num]="in" else CEPH_OSD_IN[$osd_num]="out" fi fi done < <(ceph osd tree 2>/dev/null) } # SMART warning thresholds readonly SMART_TEMP_WARN=50 # Temperature warning threshold (°C) readonly SMART_TEMP_CRIT=60 # Temperature critical threshold (°C) readonly SMART_REALLOCATED_WARN=1 # Reallocated sectors warning threshold readonly SMART_PENDING_WARN=1 # Pending sectors warning threshold readonly SMART_CRC_ERROR_WARN=100 # UDMA CRC error warning threshold readonly SMART_POWER_ON_HOURS_WARN=43800 # ~5 years of continuous use #------------------------------------------------------------------------------ # parse_smart_data # # Parses raw SMART data and returns formatted info string. # # Args: # $1 - Device name (e.g., sda, nvme0n1) # $2 - Raw smartctl output string # # Returns: Pipe-delimited string: TYPE|TEMP|HEALTH|MODEL|SERIAL|WARNINGS #------------------------------------------------------------------------------ parse_smart_data() { local device="$1" local smart_info="$2" local temp="-" local type="HDD" local health="✗" local model="-" local serial="-" local warnings="" if [[ -z "$smart_info" ]]; then echo "HDD|-|✗|-|-|" return fi # Temperature parsing - handles multiple formats: # - SATA: "194 Temperature_Celsius ... 26 (0 14 0 0 0)" (value before parenthetical) # - SATA: "Temperature: 42 Celsius" # - SATA: "Current Temperature: 35 Celsius" # - SAS: "Current Drive Temperature: 35 C" # - NVMe: "Temperature: 42 Celsius" if echo "$smart_info" | grep -q "Temperature_Celsius"; then # Strip parenthetical data like "(0 14 0 0 0)" before finding last number temp="$(echo "$smart_info" | grep "Temperature_Celsius" | head -1 | sed 's/([^)]*)//g' | awk '{for(i=NF;i>0;i--) if($i ~ /^[0-9]+$/) {print $i; exit}}')" elif echo "$smart_info" | grep -qE "Current Drive Temperature:"; then # SAS drives: "Current Drive Temperature: 35 C" temp="$(echo "$smart_info" | grep -E "Current Drive Temperature:" | head -1 | awk '{for(i=1;i<=NF;i++) if($i ~ /^[0-9]+$/) {print $i; exit}}')" elif echo "$smart_info" | grep -qE "(Current )?Temperature:"; then # SATA/NVMe: "Temperature: 42 Celsius" (may have leading whitespace) temp="$(echo "$smart_info" | grep -E "(Current )?Temperature:" | head -1 | awk '{for(i=1;i<=NF;i++) if($i ~ /^[0-9]+$/) {print $i; exit}}')" fi # Device type detection - handles SSD, HDD, and NVMe # Priority: 1) NVMe by name, 2) Rotation Rate field, 3) Model name hints, 4) Default HDD if [[ "$device" == nvme* ]]; then type="NVMe" elif echo "$smart_info" | grep -qiE "NVMe Version:|Number of Namespaces:"; then # NVMe behind a USB bridge (device is sdX, but smartctl reports NVMe info) type="NVMe" elif echo "$smart_info" | grep -qE "Rotation Rate:"; then # Check the Rotation Rate field value (may have leading whitespace) local rotation_rate rotation_rate="$(echo "$smart_info" | grep -E "Rotation Rate:" | head -1)" if echo "$rotation_rate" | grep -qiE "solid state"; then type="SSD" elif echo "$rotation_rate" | grep -qE "[0-9]+ rpm"; then # Has actual RPM value (e.g., "7200 rpm") - it's an HDD type="HDD" else # Unknown rotation rate, default to HDD type="HDD" fi elif echo "$smart_info" | grep -qE "Device Model:.*SSD|Model Number:.*SSD"; then # Match SSD in the model name field type="SSD" else # Default to HDD for spinning rust type="HDD" fi # Health status (basic SMART check) if echo "$smart_info" | grep -q "SMART overall-health.*PASSED"; then health="✓" elif echo "$smart_info" | grep -q "SMART Health Status.*OK"; then # NVMe format health="✓" fi # Model - try multiple field names model="$(echo "$smart_info" | grep -E "^(Device Model|Model Number|Product):" | head -1 | cut -d: -f2 | xargs)" [[ -z "$model" ]] && model="-" # Serial number - capture everything after the colon to handle spaces serial="$(echo "$smart_info" | grep -E "^Serial [Nn]umber:" | head -1 | cut -d: -f2 | xargs)" [[ -z "$serial" ]] && serial="-" # SMART threshold warnings - check for concerning values local warn_list=() # Temperature thresholds if [[ -n "$temp" && "$temp" =~ ^[0-9]+$ ]]; then if [[ "$temp" -ge "$SMART_TEMP_CRIT" ]]; then warn_list+=("TEMP_CRIT") elif [[ "$temp" -ge "$SMART_TEMP_WARN" ]]; then warn_list+=("TEMP_WARN") fi fi # Reallocated sectors (SMART attribute 5) local reallocated reallocated="$(echo "$smart_info" | grep -E "^\s*5\s+Reallocated_Sector" | awk '{print $NF}')" if [[ -n "$reallocated" && "$reallocated" =~ ^[0-9]+$ && "$reallocated" -ge "$SMART_REALLOCATED_WARN" ]]; then warn_list+=("REALLOC:$reallocated") fi # Current pending sectors (SMART attribute 197) local pending pending="$(echo "$smart_info" | grep -E "^\s*197\s+Current_Pending" | awk '{print $NF}')" if [[ -n "$pending" && "$pending" =~ ^[0-9]+$ && "$pending" -ge "$SMART_PENDING_WARN" ]]; then warn_list+=("PENDING:$pending") fi # UDMA CRC errors (SMART attribute 199) local crc_errors crc_errors="$(echo "$smart_info" | grep -E "^\s*199\s+UDMA_CRC_Error" | awk '{print $NF}')" if [[ -n "$crc_errors" && "$crc_errors" =~ ^[0-9]+$ && "$crc_errors" -ge "$SMART_CRC_ERROR_WARN" ]]; then warn_list+=("CRC:$crc_errors") fi # Power-on hours (SMART attribute 9) local power_hours power_hours="$(echo "$smart_info" | grep -E "^\s*9\s+Power_On_Hours" | awk '{print $NF}')" if [[ -n "$power_hours" && "$power_hours" =~ ^[0-9]+$ && "$power_hours" -ge "$SMART_POWER_ON_HOURS_WARN" ]]; then warn_list+=("HOURS:$power_hours") fi # Join warnings if [[ ${#warn_list[@]} -gt 0 ]]; then warnings="$(IFS=','; echo "${warn_list[*]}")" # Change health indicator to warning if SMART passed but has warnings if [[ "$health" == "✓" ]]; then health="⚠" fi fi # Format temperature with unit if we have a value local temp_display if [[ -n "$temp" && "$temp" != "-" ]]; then temp_display="${temp}°C" else temp_display="-" fi echo "${type}|${temp_display}|${health}|${model}|${serial}|${warnings}" } #------------------------------------------------------------------------------ # get_drive_smart_info # # Retrieves SMART data for a given device (fetches and parses). # # Args: # $1 - Device name (e.g., sda, nvme0n1) # # Returns: Pipe-delimited string: TYPE|TEMP|HEALTH|MODEL|SERIAL|WARNINGS #------------------------------------------------------------------------------ get_drive_smart_info() { local device="$1" local smart_info smart_info="$(maybe_sudo smartctl -A -i -H "/dev/$device" 2>/dev/null)" parse_smart_data "$device" "$smart_info" } #------------------------------------------------------------------------------ # Main Display Logic #------------------------------------------------------------------------------ # Run diagnose mode if requested (exits after printing) if [[ "$RUN_DIAGNOSE" == true ]]; then run_diagnose fi #------------------------------------------------------------------------------ # generate_zimaboard_layout # # ASCII art for a ZimaBoard 832 (micro1 / monitor-02): fanless x86 SBC (Celeron # N3450) whose entire lid is a finned aluminium heatsink. Physical layout # confirmed against the actual unit: # TOP : corrugated heatsink fins, rectangular notch at the FRONT-LEFT, # logo badge inset into the front bevel. # FRONT face : two tiers - 2x GbE sit directly ABOVE the 2x USB 3.0; the # Mini-DisplayPort is LEFT of that block, DC 12V barrel is RIGHT. # LEFT side : open-ended PCIe 2.0 x4 card edge protruding out the side. # REAR edge : 2x SATA data with the single SATA power header in the CENTRE # (SATA | PWR | SATA); no drive bay - drives cable out and lie # beside the board, and two drives need a Y power cable. # Onboard : 32G eMMC (mmcblk0) = OS/boot, soldered (never in DRIVE_MAP). # Bays: sata-1, sata-2 (+ a direct /dev/mmcblk0 probe for the eMMC). # # Renders onto a fixed 66-column glyph/colour-key canvas and emits with # run-length colour, so every line is exactly the same display width in both # monochrome and colour. Only SAFE width-1 glyphs (box-drawing + block elements). # # Args: # $1 - Hostname to display in the layout header # # Side effects: Calls build_drive_map() to populate DRIVE_MAP #------------------------------------------------------------------------------ # shellcheck disable=SC2059 generate_zimaboard_layout() { local host="${1:-$(hostname 2>/dev/null || echo host)}" # Contract order: build the drive map first, then init colours. build_drive_map 2>/dev/null || true da_color_init # --- storage discovery ------------------------------------------------- # eMMC (OS/boot) is soldered and never in DRIVE_MAP -> probe it directly. local emmc_dev='' emmc_size='' emmc_on=0 if [ -b /dev/mmcblk0 ]; then emmc_on=1; emmc_dev='mmcblk0' emmc_size="$(lsblk -dno SIZE /dev/mmcblk0 2>/dev/null | tr -d ' ')" [ -n "$emmc_size" ] || emmc_size='?' fi # Rear SATA ports come from DRIVE_MAP (guard set -u / never-built map). local sata1='EMPTY' sata2='EMPTY' if declare -p DRIVE_MAP >/dev/null 2>&1; then sata1="${DRIVE_MAP[sata-1]:-EMPTY}" sata2="${DRIVE_MAP[sata-2]:-EMPTY}" fi # --- canvas + geometry ------------------------------------------------- local WIDTH=66 local S=5 Wi=44 FL=16 # oblique depth, front interior width, front-left col local BL=$((FL-S)) FR=$((FL+Wi+1)) local BR=$((FR-S)) # NB: separate statement; FR is not visible in its own `local` local R0=2 HC=5 FE FB LEG HEIGHT FE=$((R0+S)); FB=$((FE+HC+1)); LEG=$((FB+3)); HEIGHT=$((LEG+6)) # dual grid: Gc = glyphs, Gk = per-cell colour key ('.' = default) local -a Gc Gk local r c t blank kblank printf -v blank '%*s' "$WIDTH" '' printf -v kblank '%*s' "$WIDTH" ''; kblank=${kblank// /.} for ((r=0;r/dev/null 2>&1; then da_repeat "$1" "$2" else local g=$1 n=$2 o=''; while ((n-->0)); do o+="$g"; done; printf '%s' "$o"; fi } # heatsink fin ramp: period-4 ridge, lit from upper-left _zfin() { case $(( (($1%4)+4)%4 )) in 0) _zp "$2" "$3" '█' H ;; 1) _zp "$2" "$3" '▓' H ;; 2) _zp "$2" "$3" '▒' S ;; 3) _zp "$2" "$3" '░' S ;; esac } local dashW; dashW="$(_zrep '─' "$Wi")" # --- header ------------------------------------------------------------ _zp 0 0 'driveAtlas' H _zp 0 11 ":: ${host}" S _zp 0 $((WIDTH-13)) 'ZimaBoard 832' D # --- left side face (shadow) + corrugated finned top ------------------- for ((r=1;r/dev/null || true } HOSTNAME=$(hostname | tr -cd '[:alnum:]-_.') CHASSIS_TYPE=${CHASSIS_TYPES[$HOSTNAME]:-"unknown"} # Display chassis layout case "$CHASSIS_TYPE" in "10bay") generate_10bay_layout "$HOSTNAME" ;; "large1") generate_large1_layout "$HOSTNAME" ;; "micro") generate_micro_layout "$HOSTNAME" ;; "zimaboard") generate_zimaboard_layout "$HOSTNAME" ;; "nuc") generate_nuc_layout "$HOSTNAME" ;; *) echo "┌─────────────────────────────────────────────────────────┐" echo "│ Unknown server: $HOSTNAME" echo "│ No chassis mapping defined yet" echo "│ Run with --diagnose to gather PCI path information" echo "└─────────────────────────────────────────────────────────┘" ;; esac #------------------------------------------------------------------------------ # Drive Details Section #------------------------------------------------------------------------------ # Build Ceph OSD cache (single query instead of per-device) if [[ "$SKIP_CEPH" != true ]]; then build_ceph_cache fi printf "\n" colorize_header '=== Drive Details with SMART Status (by Bay Position) ===' if [[ "$SHOW_PCI" == true ]]; then printf "%-5s %-15s %-10s %-8s %-8s %-8s %-30s %-20s %-12s %-10s %-10s %-30s %-40s\n" "BAY" "DEVICE" "SIZE" "TYPE" "TEMP" "HEALTH" "MODEL" "SERIAL" "CEPH OSD" "STATUS" "USAGE" "WARNINGS" "PCI PATH" echo "----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------" else printf "%-5s %-15s %-10s %-8s %-8s %-8s %-30s %-20s %-12s %-10s %-10s %-30s\n" "BAY" "DEVICE" "SIZE" "TYPE" "TEMP" "HEALTH" "MODEL" "SERIAL" "CEPH OSD" "STATUS" "USAGE" "WARNINGS" echo "----------------------------------------------------------------------------------------------------------------------------------------------------------------------" fi # Build reverse map: device -> bay declare -A DEVICE_TO_BAY for bay in "${!DRIVE_MAP[@]}"; do device="${DRIVE_MAP[$bay]}" if [[ -n "$device" && "$device" != "EMPTY" ]]; then DEVICE_TO_BAY["$device"]="$bay" fi done # Sort drives by bay position (numeric bays first, then m2 slots) # Combine numeric bays (sorted numerically) with m2 slots (sorted alphanumerically) all_bays="$(printf '%s\n' "${!DRIVE_MAP[@]}" | grep -E '^[0-9]+$' | sort -n; printf '%s\n' "${!DRIVE_MAP[@]}" | grep -E '^m2-' | sort; printf '%s\n' "${!DRIVE_MAP[@]}" | grep -E '^int-' | sort; printf '%s\n' "${!DRIVE_MAP[@]}" | grep -E '^usb' | sort)" # Cache lsblk data to reduce redundant calls # Get device sizes (whole disk only) declare -A LSBLK_SIZE=() declare -A LSBLK_MOUNTS=() log_info "Caching block device information..." # Get sizes for whole disks only while read -r name size; do [[ -z "$name" ]] && continue LSBLK_SIZE["$name"]="$size" done < <(lsblk -dn -o NAME,SIZE 2>/dev/null) # Get mount points (including partitions) and map back to parent device while read -r name mounts; do [[ -z "$name" || -z "$mounts" ]] && continue # Strip partition suffix (sda1 -> sda, nvme0n1p1 -> nvme0n1) if [[ "$name" =~ ^(nvme[0-9]+n[0-9]+)p[0-9]+$ ]]; then parent="${BASH_REMATCH[1]}" elif [[ "$name" =~ ^([a-z]+)[0-9]+$ ]]; then parent="${BASH_REMATCH[1]}" else parent="$name" fi if [[ -n "${LSBLK_MOUNTS[$parent]:-}" ]]; then LSBLK_MOUNTS["$parent"]+=",${mounts}" else LSBLK_MOUNTS["$parent"]="$mounts" fi done < <(lsblk -rn -o NAME,MOUNTPOINT 2>/dev/null | grep -v '^ ') # Parallel SMART data collection for faster execution # Collect raw smartctl output in background jobs, parse later if [[ "$SKIP_SMART" != true ]]; then SMART_CACHE_DIR="$(mktemp -d)" log_info "Collecting SMART data in parallel..." max_parallel_jobs=10 job_count=0 for bay in $all_bays; do device="${DRIVE_MAP[$bay]}" if [[ -n "$device" && "$device" != "EMPTY" && -b "/dev/$device" ]]; then # Launch background job to collect raw smartctl data (auto-picks -d for USB) smart_collect "$device" "$SMART_CACHE_DIR/${device}.raw" & ((job_count++)) if ((job_count >= max_parallel_jobs)); then wait -n 2>/dev/null || wait # wait -n requires bash 4.3+, fall back to wait ((job_count--)) fi fi done # Wait for all remaining background SMART queries to complete wait log_info "SMART data collection complete" fi for bay in $all_bays; do device="${DRIVE_MAP[$bay]}" if [[ -n "$device" && "$device" != "EMPTY" && -b "/dev/$device" ]]; then # Use cached lsblk data size="${LSBLK_SIZE[$device]:-}" # Get SMART info from cache (or defaults if skipped) if [[ "$SKIP_SMART" == true ]]; then type="-" temp="-" health="-" model="-" serial="-" warnings="" else # Read from cached raw SMART data and parse it raw_smart="" if [[ -f "$SMART_CACHE_DIR/${device}.raw" ]]; then raw_smart="$(cat "$SMART_CACHE_DIR/${device}.raw")" fi # Parse the raw data using get_drive_smart_info logic inline if [[ -n "$raw_smart" ]]; then smart_info="$(parse_smart_data "$device" "$raw_smart")" IFS='|' read -r type temp health model serial warnings <<< "$smart_info" else type="-" temp="-" health="-" model="-" serial="-" warnings="" fi fi # Check for Ceph OSD using cached data osd_id="-" ceph_status="-" if [[ "$SKIP_CEPH" != true ]]; then osd_id="${CEPH_DEVICE_TO_OSD[$device]:-}" if [[ -n "$osd_id" ]]; then # Get status from cached OSD tree data osd_num="${osd_id#osd.}" up_status="${CEPH_OSD_STATUS[$osd_num]:-unknown}" in_status="${CEPH_OSD_IN[$osd_num]:-out}" ceph_status="${up_status}/${in_status}" else osd_id="-" fi fi # Check mount points using cached lsblk data # This includes both whole-device mounts and partition mounts usage="-" mount_points="${LSBLK_MOUNTS[$device]:-}" # Limit to first 3 mount points for display mount_points="$(echo "$mount_points" | tr ',' '\n' | head -3 | tr '\n' ',' | sed 's/,$//')" if [[ -n "$mount_points" ]]; then if [[ "$mount_points" == *"/"* && ! "$mount_points" == *"/boot"* && ! "$mount_points" == *"/home"* ]]; then # Root filesystem mounted (but not just /boot or /home) if echo "$mount_points" | grep -qE '^/,|^/$|,/$'; then usage="BOOT" else usage="$mount_points" fi else usage="$mount_points" fi fi # Apply colors if enabled colored_temp="$(colorize_temp "$temp")" colored_health="$(colorize_health "$health")" # Colorize warnings if present colored_warnings="${warnings:--}" if [[ "$USE_COLOR" == true && -n "$warnings" ]]; then colored_warnings="${COLOR_YELLOW}${warnings}${COLOR_RESET}" fi if [[ "$SHOW_PCI" == true ]]; then pci_path="${BAY_TO_PCI_PATH[$bay]:-}" printf "%-5s %-15s %-10s %-8s %-8b %-8b %-30s %-20s %-12s %-10s %-10s %-30b %-40s\n" "$bay" "/dev/$device" "$size" "$type" "$colored_temp" "$colored_health" "$model" "$serial" "$osd_id" "$ceph_status" "$usage" "$colored_warnings" "$pci_path" else printf "%-5s %-15s %-10s %-8s %-8b %-8b %-30s %-20s %-12s %-10s %-10s %-30b\n" "$bay" "/dev/$device" "$size" "$type" "$colored_temp" "$colored_health" "$model" "$serial" "$osd_id" "$ceph_status" "$usage" "$colored_warnings" fi fi done # NVMe drives (only show unmapped ones - mapped NVMe drives appear in main table) nvme_devices=$(lsblk -d -n -o NAME,SIZE | grep "^nvme" 2>/dev/null) if [[ -n "$nvme_devices" ]]; then # Filter out already-mapped NVMe devices unmapped_nvme="" while read -r name size; do if [[ -z "${DEVICE_TO_BAY[$name]:-}" ]]; then unmapped_nvme+="$name $size"$'\n' fi done <<< "$nvme_devices" if [[ -n "$unmapped_nvme" ]]; then printf "\n" colorize_header '=== Unmapped NVMe Drives ===' printf "%-15s %-10s %-10s %-40s %-25s\n" "DEVICE" "SIZE" "TYPE" "MODEL" "SERIAL" echo "------------------------------------------------------------------------------------------------------" echo "$unmapped_nvme" | while read -r name size; do [[ -z "$name" ]] && continue device="/dev/$name" # Get model and serial from smartctl for accuracy smart_info="$(maybe_sudo smartctl -i "$device" 2>/dev/null)" model="$(echo "$smart_info" | grep "Model Number" | cut -d: -f2 | xargs)" serial="$(echo "$smart_info" | grep "Serial Number" | cut -d: -f2 | xargs)" [[ -z "$model" ]] && model="-" [[ -z "$serial" ]] && serial="-" printf "%-15s %-10s %-10s %-40s %-25s\n" "$device" "$size" "NVMe" "$model" "$serial" done fi fi #------------------------------------------------------------------------------ # Optional sections #------------------------------------------------------------------------------ # Ceph RBD Devices rbd_devices=$(lsblk -d -n -o NAME,SIZE,TYPE 2>/dev/null | grep "rbd" | sort -V) if [ -n "$rbd_devices" ]; then printf "\n" colorize_header '=== Ceph RBD Devices ===' printf "%-15s %-10s %-10s %-30s\n" "DEVICE" "SIZE" "TYPE" "MOUNTPOINT" echo "------------------------------------------------------------" echo "$rbd_devices" | while read -r name size type; do # Get mountpoint if any mountpoint=$(lsblk -n -o MOUNTPOINT "/dev/$name" 2>/dev/null | head -1) [[ -z "$mountpoint" ]] && mountpoint="-" printf "%-15s %-10s %-10s %-30s\n" "/dev/$name" "$size" "$type" "$mountpoint" done fi # Show mapping diagnostic info if DEBUG is set if [[ -n "$DEBUG" ]]; then printf "\n" colorize_header '=== DEBUG: Drive Mappings ===' for key in "${!DRIVE_MAP[@]}"; do echo "Bay $key: ${DRIVE_MAP[$key]}" done | sort -n fi