add go bench client
This commit is contained in:
Gilles Soulier
381
backend/app/utils/lspci_parser.py
Normal file
381
backend/app/utils/lspci_parser.py
Normal file
@@ -0,0 +1,381 @@
|
||||
"""
|
||||
lspci output parser for PCI device detection and extraction.
|
||||
Parses output from 'lspci -v' and extracts individual device information.
|
||||
"""
|
||||
import re
|
||||
from typing import List, Dict, Any, Optional, Tuple
|
||||
|
||||
|
||||
def extract_brand_model(vendor_name: str, device_name: str, device_class: str) -> Tuple[str, str]:
|
||||
"""
|
||||
Extract brand (marque) and model (modele) from vendor and device names.
|
||||
|
||||
Args:
|
||||
vendor_name: Vendor name (e.g., "NVIDIA Corporation", "Micron/Crucial Technology")
|
||||
device_name: Device name (e.g., "GA106 [GeForce RTX 3060]")
|
||||
device_class: Device class for context (e.g., "VGA compatible controller")
|
||||
|
||||
Returns:
|
||||
Tuple of (brand, model)
|
||||
|
||||
Examples:
|
||||
("NVIDIA Corporation", "GA106 [GeForce RTX 3060 Lite Hash Rate]", "VGA")
|
||||
-> ("NVIDIA", "GeForce RTX 3060 Lite Hash Rate")
|
||||
|
||||
("Micron/Crucial Technology", "P2 [Nick P2] / P3 Plus NVMe", "Non-Volatile")
|
||||
-> ("Micron", "P2/P3 Plus NVMe PCIe SSD")
|
||||
"""
|
||||
# Extract brand from vendor name
|
||||
brand = vendor_name.split()[0] if vendor_name else ""
|
||||
# Handle cases like "Micron/Crucial" - take the first one
|
||||
if '/' in brand:
|
||||
brand = brand.split('/')[0]
|
||||
|
||||
# Extract model from device name
|
||||
model = device_name
|
||||
|
||||
# Extract content from brackets [...] as it often contains the commercial name
|
||||
bracket_match = re.search(r'\[([^\]]+)\]', device_name)
|
||||
if bracket_match:
|
||||
bracket_content = bracket_match.group(1)
|
||||
|
||||
# For GPUs, prefer the bracket content (e.g., "GeForce RTX 3060")
|
||||
if any(kw in device_class.lower() for kw in ['vga', 'graphics', '3d', 'display']):
|
||||
model = bracket_content
|
||||
# For storage, extract the commercial model name
|
||||
elif any(kw in device_class.lower() for kw in ['nvme', 'non-volatile', 'sata', 'storage']):
|
||||
# Pattern: "P2 [Nick P2] / P3 / P3 Plus NVMe PCIe SSD (DRAM-less)"
|
||||
# We want: "P2/P3/P3 Plus NVMe PCIe SSD"
|
||||
|
||||
# Remove content in brackets like [Nick P2]
|
||||
cleaned = re.sub(r'\[[^\]]*\]', '', device_name)
|
||||
# Clean up extra slashes and spaces
|
||||
cleaned = re.sub(r'\s*/\s*', '/', cleaned)
|
||||
cleaned = re.sub(r'\s+', ' ', cleaned)
|
||||
cleaned = re.sub(r'/+', '/', cleaned)
|
||||
# Remove leading/trailing slashes
|
||||
cleaned = cleaned.strip('/ ')
|
||||
model = cleaned
|
||||
|
||||
return brand, model.strip()
|
||||
|
||||
|
||||
def _split_vendor_device(description: str) -> Tuple[str, str]:
|
||||
"""
|
||||
Split description into vendor name and device name.
|
||||
|
||||
Args:
|
||||
description: Full device description from lspci
|
||||
|
||||
Returns:
|
||||
Tuple of (vendor_name, device_name)
|
||||
|
||||
Examples:
|
||||
"NVIDIA Corporation GA106 [GeForce RTX 3060]"
|
||||
-> ("NVIDIA Corporation", "GA106 [GeForce RTX 3060]")
|
||||
|
||||
"Micron/Crucial Technology P2 NVMe PCIe SSD"
|
||||
-> ("Micron/Crucial Technology", "P2 NVMe PCIe SSD")
|
||||
|
||||
"Realtek Semiconductor Co., Ltd. RTL8111/8168"
|
||||
-> ("Realtek Semiconductor Co., Ltd.", "RTL8111/8168")
|
||||
"""
|
||||
# Vendor suffix patterns (ordered by priority)
|
||||
vendor_suffixes = [
|
||||
# Multi-word patterns (must come first)
|
||||
r'\bCo\.,?\s*Ltd\.?',
|
||||
r'\bCo\.,?\s*Inc\.?',
|
||||
r'\bInc\.,?\s*Ltd\.?',
|
||||
r'\bTechnology\s+Co\.,?\s*Ltd\.?',
|
||||
r'\bSemiconductor\s+Co\.,?\s*Ltd\.?',
|
||||
# Single word patterns
|
||||
r'\bCorporation\b',
|
||||
r'\bTechnology\b',
|
||||
r'\bSemiconductor\b',
|
||||
r'\bInc\.?\b',
|
||||
r'\bLtd\.?\b',
|
||||
r'\bGmbH\b',
|
||||
r'\bAG\b',
|
||||
]
|
||||
|
||||
# Try each pattern
|
||||
for pattern in vendor_suffixes:
|
||||
match = re.search(pattern, description, re.IGNORECASE)
|
||||
if match:
|
||||
# Split at the end of the vendor suffix
|
||||
split_pos = match.end()
|
||||
vendor_name = description[:split_pos].strip()
|
||||
device_name = description[split_pos:].strip()
|
||||
return vendor_name, device_name
|
||||
|
||||
# No suffix found - fallback to first word
|
||||
parts = description.split(' ', 1)
|
||||
if len(parts) >= 2:
|
||||
return parts[0], parts[1]
|
||||
return description, ""
|
||||
|
||||
|
||||
def detect_pci_devices(lspci_output: str, exclude_system_devices: bool = True) -> List[Dict[str, str]]:
|
||||
"""
|
||||
Detect all PCI devices from lspci -v output.
|
||||
Returns a list of devices with their slot and basic info.
|
||||
|
||||
Args:
|
||||
lspci_output: Raw output from 'lspci -v' command
|
||||
exclude_system_devices: If True (default), exclude system infrastructure devices
|
||||
like PCI bridges, Host bridges, ISA bridges, SMBus, etc.
|
||||
|
||||
Returns:
|
||||
List of dicts with keys: slot, device_class, vendor_device_id, description
|
||||
|
||||
Example:
|
||||
[
|
||||
{
|
||||
"slot": "04:00.0",
|
||||
"device_class": "Ethernet controller",
|
||||
"vendor_device_id": "10ec:8168",
|
||||
"description": "Realtek Semiconductor Co., Ltd. RTL8111/8168/8211/8411..."
|
||||
},
|
||||
...
|
||||
]
|
||||
"""
|
||||
# System infrastructure device classes to exclude by default
|
||||
SYSTEM_DEVICE_CLASSES = [
|
||||
"Host bridge",
|
||||
"PCI bridge",
|
||||
"ISA bridge",
|
||||
"SMBus",
|
||||
"IOMMU",
|
||||
"Signal processing controller",
|
||||
"System peripheral",
|
||||
"RAM memory",
|
||||
"Non-Essential Instrumentation",
|
||||
]
|
||||
|
||||
devices = []
|
||||
lines = lspci_output.strip().split('\n')
|
||||
|
||||
for line in lines:
|
||||
line_stripped = line.strip()
|
||||
# Match lines starting with slot format "XX:XX.X"
|
||||
# Format: "04:00.0 Ethernet controller: Realtek Semiconductor Co., Ltd. ..."
|
||||
match = re.match(r'^([0-9a-fA-F]{2}:[0-9a-fA-F]{2}\.[0-9a-fA-F])\s+([^:]+):\s+(.+)$', line_stripped)
|
||||
if match:
|
||||
slot = match.group(1)
|
||||
device_class = match.group(2).strip()
|
||||
description = match.group(3).strip()
|
||||
|
||||
# Filter out system devices if requested
|
||||
if exclude_system_devices:
|
||||
# Check if device class matches any system device pattern
|
||||
is_system_device = any(
|
||||
sys_class.lower() in device_class.lower()
|
||||
for sys_class in SYSTEM_DEVICE_CLASSES
|
||||
)
|
||||
if is_system_device:
|
||||
continue # Skip this device
|
||||
|
||||
devices.append({
|
||||
"slot": slot,
|
||||
"device_class": device_class,
|
||||
"description": description
|
||||
})
|
||||
|
||||
return devices
|
||||
|
||||
|
||||
def extract_device_section(lspci_output: str, slot: str) -> Optional[str]:
|
||||
"""
|
||||
Extract the complete section for a specific device from lspci -v output.
|
||||
|
||||
Args:
|
||||
lspci_output: Raw output from 'lspci -v' command
|
||||
slot: PCI slot (e.g., "04:00.0")
|
||||
|
||||
Returns:
|
||||
Complete section for the device, from its slot line to the next slot line (or end)
|
||||
"""
|
||||
lines = lspci_output.strip().split('\n')
|
||||
|
||||
# Build the pattern to match the target device's slot line
|
||||
target_pattern = re.compile(rf'^{re.escape(slot)}\s+')
|
||||
|
||||
section_lines = []
|
||||
in_section = False
|
||||
|
||||
for line in lines:
|
||||
# Check if this is the start of our target device
|
||||
if target_pattern.match(line):
|
||||
in_section = True
|
||||
section_lines.append(line)
|
||||
continue
|
||||
|
||||
# If we're in the section
|
||||
if in_section:
|
||||
# Check if we've hit the next device (new slot line - starts with hex:hex.hex)
|
||||
if re.match(r'^[0-9a-fA-F]{2}:[0-9a-fA-F]{2}\.[0-9a-fA-F]\s+', line):
|
||||
# End of our section
|
||||
break
|
||||
|
||||
# Add the line to our section
|
||||
section_lines.append(line)
|
||||
|
||||
if section_lines:
|
||||
return '\n'.join(section_lines)
|
||||
|
||||
return None
|
||||
|
||||
|
||||
def parse_device_info(device_section: str) -> Dict[str, Any]:
|
||||
"""
|
||||
Parse detailed information from a PCI device section.
|
||||
|
||||
Args:
|
||||
device_section: The complete lspci output for a single device
|
||||
|
||||
Returns:
|
||||
Dictionary with parsed device information
|
||||
"""
|
||||
result = {
|
||||
"slot": None,
|
||||
"device_class": None,
|
||||
"vendor_name": None,
|
||||
"device_name": None,
|
||||
"subsystem": None,
|
||||
"subsystem_vendor": None,
|
||||
"subsystem_device": None,
|
||||
"driver": None,
|
||||
"modules": [],
|
||||
"vendor_device_id": None, # Will be extracted from other sources or databases
|
||||
"revision": None,
|
||||
"prog_if": None,
|
||||
"flags": [],
|
||||
"irq": None,
|
||||
"iommu_group": None,
|
||||
"memory_addresses": [],
|
||||
"io_ports": [],
|
||||
"capabilities": []
|
||||
}
|
||||
|
||||
lines = device_section.split('\n')
|
||||
|
||||
# Parse the first line (slot line)
|
||||
# Format: "04:00.0 Ethernet controller: Realtek Semiconductor Co., Ltd. RTL8111/8168/8211/8411..."
|
||||
first_line = lines[0] if lines else ""
|
||||
slot_match = re.match(r'^([0-9a-fA-F]{2}:[0-9a-fA-F]{2}\.[0-9a-fA-F])\s+([^:]+):\s+(.+)$', first_line)
|
||||
if slot_match:
|
||||
result["slot"] = slot_match.group(1)
|
||||
result["device_class"] = slot_match.group(2).strip()
|
||||
description = slot_match.group(3).strip()
|
||||
|
||||
# Try to extract vendor and device name from description
|
||||
# Common formats:
|
||||
# "NVIDIA Corporation GA106 [GeForce RTX 3060 Lite Hash Rate]"
|
||||
# "Micron/Crucial Technology P2 [Nick P2] / P3 / P3 Plus NVMe PCIe SSD"
|
||||
# "Realtek Semiconductor Co., Ltd. RTL8111/8168/8211/8411"
|
||||
# "Intel Corporation Device 1234"
|
||||
|
||||
# Strategy: Find vendor suffix markers (Corporation, Technology, Co., Ltd., etc.)
|
||||
# Then everything after is the device name
|
||||
vendor_name, device_name = _split_vendor_device(description)
|
||||
result["vendor_name"] = vendor_name
|
||||
result["device_name"] = device_name
|
||||
|
||||
# Extract revision if present
|
||||
rev_match = re.search(r'\(rev\s+([0-9a-fA-F]+)\)', description)
|
||||
if rev_match:
|
||||
result["revision"] = rev_match.group(1)
|
||||
# Clean revision from device_name
|
||||
result["device_name"] = re.sub(r'\s*\(rev\s+[0-9a-fA-F]+\)', '', result["device_name"])
|
||||
|
||||
# Extract prog-if if present
|
||||
progif_match = re.search(r'\(prog-if\s+([0-9a-fA-F]+)\s*\[([^\]]+)\]\)', description)
|
||||
if progif_match:
|
||||
result["prog_if"] = progif_match.group(1)
|
||||
# Clean prog-if from device_name
|
||||
result["device_name"] = re.sub(r'\s*\(prog-if\s+[0-9a-fA-F]+\s*\[[^\]]+\]\)', '', result["device_name"])
|
||||
|
||||
# Parse detailed fields
|
||||
for line in lines[1:]:
|
||||
line_stripped = line.strip()
|
||||
|
||||
# Subsystem
|
||||
subsystem_match = re.match(r'^Subsystem:\s+(.+)$', line_stripped)
|
||||
if subsystem_match:
|
||||
result["subsystem"] = subsystem_match.group(1).strip()
|
||||
|
||||
# DeviceName (sometimes present)
|
||||
devicename_match = re.match(r'^DeviceName:\s+(.+)$', line_stripped)
|
||||
if devicename_match:
|
||||
if not result["device_name"]:
|
||||
result["device_name"] = devicename_match.group(1).strip()
|
||||
|
||||
# Flags
|
||||
flags_match = re.match(r'^Flags:\s+(.+)$', line_stripped)
|
||||
if flags_match:
|
||||
flags_str = flags_match.group(1).strip()
|
||||
# Extract IOMMU group
|
||||
iommu_match = re.search(r'IOMMU group\s+(\d+)', flags_str)
|
||||
if iommu_match:
|
||||
result["iommu_group"] = iommu_match.group(1)
|
||||
# Extract IRQ
|
||||
irq_match = re.search(r'IRQ\s+(\d+)', flags_str)
|
||||
if irq_match:
|
||||
result["irq"] = irq_match.group(1)
|
||||
# Parse flags
|
||||
result["flags"] = [f.strip() for f in flags_str.split(',')]
|
||||
|
||||
# Memory addresses
|
||||
memory_match = re.match(r'^Memory at\s+([0-9a-fA-F]+)\s+\((.+?)\)\s+\[(.+?)\]', line_stripped)
|
||||
if memory_match:
|
||||
result["memory_addresses"].append({
|
||||
"address": memory_match.group(1),
|
||||
"type": memory_match.group(2),
|
||||
"info": memory_match.group(3)
|
||||
})
|
||||
|
||||
# I/O ports
|
||||
io_match = re.match(r'^I/O ports at\s+([0-9a-fA-F]+)\s+\[size=(\d+)\]', line_stripped)
|
||||
if io_match:
|
||||
result["io_ports"].append({
|
||||
"address": io_match.group(1),
|
||||
"size": io_match.group(2)
|
||||
})
|
||||
|
||||
# Kernel driver in use
|
||||
driver_match = re.match(r'^Kernel driver in use:\s+(.+)$', line_stripped)
|
||||
if driver_match:
|
||||
result["driver"] = driver_match.group(1).strip()
|
||||
|
||||
# Kernel modules
|
||||
modules_match = re.match(r'^Kernel modules:\s+(.+)$', line_stripped)
|
||||
if modules_match:
|
||||
modules_str = modules_match.group(1).strip()
|
||||
result["modules"] = [m.strip() for m in modules_str.split(',')]
|
||||
|
||||
# Capabilities (just capture the type for classification)
|
||||
cap_match = re.match(r'^Capabilities:\s+\[([0-9a-fA-F]+)\]\s+(.+)$', line_stripped)
|
||||
if cap_match:
|
||||
result["capabilities"].append({
|
||||
"offset": cap_match.group(1),
|
||||
"type": cap_match.group(2).strip()
|
||||
})
|
||||
|
||||
return result
|
||||
|
||||
|
||||
def get_pci_vendor_device_id(slot: str) -> Optional[str]:
|
||||
"""
|
||||
Get vendor:device ID for a PCI slot using lspci -n.
|
||||
This is a helper that would need to be called with subprocess.
|
||||
|
||||
Args:
|
||||
slot: PCI slot (e.g., "04:00.0")
|
||||
|
||||
Returns:
|
||||
Vendor:Device ID string (e.g., "10ec:8168") or None
|
||||
"""
|
||||
# This function would call: lspci -n -s {slot}
|
||||
# Output format: "04:00.0 0200: 10ec:8168 (rev 16)"
|
||||
# For now, this is a placeholder - implementation would use subprocess
|
||||
pass
|
||||
Reference in New Issue
Block a user