package linux_generic import ( "sort" "strconv" "strings" "git.mchus.pro/mchus/logpile/internal/models" ) // inventory accumulates what the utility parsers find. The same component is // commonly reported by several files (full `lspci` plus per-device `lspci -vv` // excerpts, `nvme list` plus `smartctl`), so records are merged by a stable // key and the first non-empty value of each field wins. type inventory struct { board models.BoardInfo fru []models.FRUInfo firmware []models.FirmwareInfo cpus []models.CPU lscpu lscpuInfo dimms []*dimm psus []models.PSU pci map[string]*pciDevice drives []*drive } func newInventory() *inventory { return &inventory{pci: make(map[string]*pciDevice)} } // drive is one block device assembled from nvme-cli, smartctl and lsblk. type drive struct { name string // kernel block device name: nvme0n1, sda controller string // NVMe controller name: nvme0 model string serial string firmware string mediaType string // SSD | HDD busInterface string // NVMe | SATA | SAS | ... sizeBytes int64 // exact capacity, when a source reports bytes approxSizeGB int // capacity from the `nvme list` usage column (3 significant digits) roughSizeGB int // capacity from the lsblk SIZE column (binary units, 2 significant digits) logicalBlock int64 physicalBlock int64 metadataBytes int64 usedPct *int status string errorText string details map[string]any } func (d *drive) setDetail(key string, value any) { if d.details == nil { d.details = make(map[string]any) } if _, exists := d.details[key]; !exists { d.details[key] = value } } // markStatus keeps the most severe status reported for the drive. func (d *drive) markStatus(status, errorText string) { if statusRank(status) <= statusRank(d.status) { return } d.status = status d.errorText = errorText } func statusRank(status string) int { switch status { case "Critical": return 3 case "Warning": return 2 case "OK": return 1 } return 0 } // findDrive returns the record for a drive, matching by serial number first // and by kernel device / NVMe controller name second, creating it when the // drive was not seen yet. func (inv *inventory) findDrive(serial, name string) *drive { serial = strings.TrimSpace(serial) name = strings.TrimPrefix(strings.TrimSpace(name), "/dev/") controller := nvmeControllerName(name) if serial != "" { for _, d := range inv.drives { if d.serial == serial { return d.identify(serial, name, controller) } } } if name != "" { for _, d := range inv.drives { if d.serial != "" && serial != "" { continue } if d.name == name || (controller != "" && d.controller == controller) { return d.identify(serial, name, controller) } } } if serial == "" && name == "" { return nil } d := &drive{} inv.drives = append(inv.drives, d) return d.identify(serial, name, controller) } func (d *drive) identify(serial, name, controller string) *drive { if d.serial == "" { d.serial = serial } // A namespace device name (nvme0n1) is more specific than the bare // controller name (nvme0) a SMART log is keyed by. if name != "" && name != controller && (d.name == "" || d.name == d.controller) { d.name = name } if d.name == "" { d.name = name } if d.controller == "" { d.controller = controller } return d } // nvmeControllerName returns "nvme0" for "nvme0", "nvme0n1" and "nvme0n1p2". func nvmeControllerName(name string) string { if !strings.HasPrefix(name, "nvme") { return "" } end := len("nvme") for end < len(name) && name[end] >= '0' && name[end] <= '9' { end++ } if end == len("nvme") { return "" } return name[:end] } // hardware assembles the normalized hardware config from the merged records. func (inv *inventory) hardware() *models.HardwareConfig { hw := &models.HardwareConfig{ BoardInfo: inv.board, Firmware: inv.firmware, CPUs: inv.buildCPUs(), PowerSupply: inv.psus, } for _, d := range inv.dimms { hw.Memory = append(hw.Memory, d.MemoryDIMM) } hw.Storage = inv.buildStorage() inv.appendPCIDevices(hw) return hw } func (inv *inventory) buildStorage() []models.Storage { drives := make([]*drive, len(inv.drives)) copy(drives, inv.drives) sort.SliceStable(drives, func(i, j int) bool { return naturalLess(drives[i].name, drives[j].name) }) storage := make([]models.Storage, 0, len(drives)) for _, d := range drives { // Most precise source wins: exact bytes, then nvme list, then lsblk. sizeGB := d.roughSizeGB if d.approxSizeGB > 0 { sizeGB = d.approxSizeGB } if d.sizeBytes > 0 { sizeGB = bytesToGB(d.sizeBytes) } item := models.Storage{ Slot: firstNonEmpty(d.name, d.serial), Type: d.mediaType, Model: d.model, SizeGB: sizeGB, SerialNumber: d.serial, Firmware: d.firmware, Interface: d.busInterface, Present: true, LogicalBlockSizeBytes: d.logicalBlock, PhysicalBlockSizeBytes: d.physicalBlock, MetadataBytesPerBlock: d.metadataBytes, Status: d.status, ErrorDescription: d.errorText, Details: d.details, } if d.usedPct != nil { remaining := 100 - *d.usedPct if remaining < 0 { remaining = 0 } item.RemainingEndurancePct = &remaining } storage = append(storage, item) } return storage } // bytesToGB rounds a byte count to decimal gigabytes. func bytesToGB(size int64) int { return int((size + 500_000_000) / 1_000_000_000) } // naturalLess orders names with embedded numbers numerically // (nvme2n1 before nvme10n1). func naturalLess(a, b string) bool { for a != "" && b != "" { aDigits, bDigits := leadingDigits(a), leadingDigits(b) if aDigits > 0 && bDigits > 0 { an, _ := strconv.ParseUint(a[:aDigits], 10, 64) bn, _ := strconv.ParseUint(b[:bDigits], 10, 64) if an != bn { return an < bn } a, b = a[aDigits:], b[bDigits:] continue } if a[0] != b[0] { return a[0] < b[0] } a, b = a[1:], b[1:] } return len(a) < len(b) } func leadingDigits(s string) int { n := 0 for n < len(s) && s[n] >= '0' && s[n] <= '9' { n++ } return n } // parseSizeBytes parses a " " capacity. SI units are decimal // (nvme-cli, smartctl) and IEC units binary. func parseSizeBytes(number, unit string) (int64, bool) { value, err := strconv.ParseFloat(strings.ReplaceAll(strings.TrimSpace(number), ",", ""), 64) if err != nil || value < 0 { return 0, false } var multiplier float64 switch strings.ToUpper(strings.TrimSpace(unit)) { case "B", "BYTES": multiplier = 1 case "KB": multiplier = 1e3 case "MB": multiplier = 1e6 case "GB": multiplier = 1e9 case "TB": multiplier = 1e12 case "PB": multiplier = 1e15 case "KIB": multiplier = 1 << 10 case "MIB": multiplier = 1 << 20 case "GIB": multiplier = 1 << 30 case "TIB": multiplier = 1 << 40 case "PIB": multiplier = 1 << 50 default: return 0, false } return int64(value*multiplier + 0.5), true }