dfaggioli/qemu
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
bb6940dbad20a90515fd53f901b370251e7a25df
qemu/tests/functional/acpi-bits/bits-tests/smbios.py2
Thomas Huth 05caa06242 tests/functional: Convert the acpi-bits test into a standalone test 
Mostly a straight-forward conversion. Looks like we can simply drop
the avocado datadrainer stuff when not using the avocado framework
anymore.

Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Tested-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Message-ID: <20240830133841.142644-30-thuth@redhat.com>
Signed-off-by: Thomas Huth <thuth@redhat.com>
2024-09-04 11:14:33 +02:00

2435 lines
108 KiB
Plaintext
Raw Blame History

# Copyright (c) 2015, Intel Corporation
# All rights reserved.
#
# SPDX-License-Identifier: BSD-3-Clause
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# * Redistributions of source code must retain the above copyright notice,
# this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright notice,
# this list of conditions and the following disclaimer in the documentation
# and/or other materials provided with the distribution.
# * Neither the name of Intel Corporation nor the names of its contributors
# may be used to endorse or promote products derived from this software
# without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
# This script runs only from the biosbits VM.
"""SMBIOS/DMI module."""
import bits
import bitfields
import ctypes
import redirect
import struct
import uuid
import unpack
import ttypager
import sys
class SMBIOS(unpack.Struct):
def __new__(cls):
if sys.platform == "BITS-EFI":
import efi
sm_ptr = efi.system_table.ConfigurationTableDict.get(efi.SMBIOS_TABLE_GUID)
else:
address = 0xF0000
mem = bits.memory(0xF0000, 0x10000)
for offset in range(0, len(mem), 16):
signature = (ctypes.c_char * 4).from_address(address + offset).value
if signature == "_SM_":
entry_point_length = ctypes.c_ubyte.from_address(address + offset + 5).value
csum = sum(map(ord, mem[offset:offset + entry_point_length])) & 0xff
if csum == 0:
sm_ptr = address + offset
break
else:
return None
if not sm_ptr:
return None
sm = super(SMBIOS, cls).__new__(cls)
sm._header_memory = bits.memory(sm_ptr, 0x1f)
return sm
def __init__(self):
super(SMBIOS, self).__init__()
u = unpack.Unpackable(self._header_memory)
self.add_field('header', Header(u))
self._structure_memory = bits.memory(self.header.structure_table_address, self.header.structure_table_length)
u = unpack.Unpackable(self._structure_memory)
self.add_field('structures', unpack.unpack_all(u, _smbios_structures, self), unpack.format_each("\n\n{!r}"))
def structure_type(self, num):
'''Dumps structure of given Type if present'''
try:
types_present = [self.structures[x].smbios_structure_type for x in range(len(self.structures))]
matrix = dict()
for index in range(len(types_present)):
if types_present.count(types_present[index]) == 1:
matrix[types_present[index]] = self.structures[index]
else: # if multiple structures of the same type, return a list of structures for the type number
if matrix.has_key(types_present[index]):
matrix[types_present[index]].append(self.structures[index])
else:
matrix[types_present[index]] = [self.structures[index]]
return matrix[num]
except:
print "Failure: Type {} - not found".format(num)
class Header(unpack.Struct):
def __new__(cls, u):
return super(Header, cls).__new__(cls)
def __init__(self, u):
super(Header, self).__init__()
self.raw_data = u.unpack_rest()
u = unpack.Unpackable(self.raw_data)
self.add_field('anchor_string', u.unpack_one("4s"))
self.add_field('checksum', u.unpack_one("B"))
self.add_field('length', u.unpack_one("B"))
self.add_field('major_version', u.unpack_one("B"))
self.add_field('minor_version', u.unpack_one("B"))
self.add_field('max_structure_size', u.unpack_one("<H"))
self.add_field('entry_point_revision', u.unpack_one("B"))
self.add_field('formatted_area', u.unpack_one("5s"))
self.add_field('intermediate_anchor_string', u.unpack_one("5s"))
self.add_field('intermediate_checksum', u.unpack_one("B"))
self.add_field('structure_table_length', u.unpack_one("<H"))
self.add_field('structure_table_address', u.unpack_one("<I"))
self.add_field('number_structures', u.unpack_one("<H"))
self.add_field('bcd_revision', u.unpack_one("B"))
if not u.at_end():
self.add_field('data', u.unpack_rest())
class SmbiosBaseStructure(unpack.Struct):
def __new__(cls, u, sm):
t = u.unpack_peek_one("B")
if cls.smbios_structure_type is not None and t != cls.smbios_structure_type:
return None
return super(SmbiosBaseStructure, cls).__new__(cls)
def __init__(self, u, sm):
super(SmbiosBaseStructure, self).__init__()
self.start_offset = u.offset
length = u.unpack_peek_one("<xB")
self.raw_data = u.unpack_raw(length)
self.u = unpack.Unpackable(self.raw_data)
self.strings_offset = u.offset
def unpack_string():
return "".join(iter(lambda: u.unpack_one("c"), "\x00"))
strings = list(iter(unpack_string, ""))
if not strings:
u.skip(1)
self.strings_length = u.offset - self.strings_offset
self.raw_strings = str(bits.memory(sm.header.structure_table_address + self.strings_offset, self.strings_length))
if len(strings):
self.strings = strings
self.add_field('type', self.u.unpack_one("B"))
self.add_field('length', self.u.unpack_one("B"))
self.add_field('handle', self.u.unpack_one("<H"))
def fini(self):
if not self.u.at_end():
self.add_field('data', self.u.unpack_rest())
del self.u
def fmtstr(self, i):
"""Format the specified index and the associated string"""
return "{} '{}'".format(i, self.getstr(i))
def getstr(self, i):
"""Get the string associated with the given index"""
if i == 0:
return "(none)"
if not hasattr(self, "strings"):
return "(error: structure has no strings)"
if i > len(self.strings):
return "(error: string index out of range)"
return self.strings[i - 1]
class BIOSInformation(SmbiosBaseStructure):
smbios_structure_type = 0
def __init__(self, u, sm):
super(BIOSInformation, self).__init__(u, sm)
u = self.u
try:
self.add_field('vendor', u.unpack_one("B"), self.fmtstr)
self.add_field('version', u.unpack_one("B"), self.fmtstr)
self.add_field('starting_address_segment', u.unpack_one("<H"))
self.add_field('release_date', u.unpack_one("B"), self.fmtstr)
self.add_field('rom_size', u.unpack_one("B"))
self.add_field('characteristics', u.unpack_one("<Q"))
minor_version_str = str(sm.header.minor_version) # 34 is .34, 4 is .4, 41 is .41; compare ASCIIbetically to compare initial digits rather than numeric value
if (sm.header.major_version, minor_version_str) >= (2,"4"):
characteristic_bytes = 2
else:
characteristic_bytes = self.length - 0x12
self.add_field('characteristics_extensions', [u.unpack_one("B") for b in range(characteristic_bytes)])
if (sm.header.major_version, minor_version_str) >= (2,"4"):
self.add_field('major_release', u.unpack_one("B"))
self.add_field('minor_release', u.unpack_one("B"))
self.add_field('ec_major_release', u.unpack_one("B"))
self.add_field('ec_minor_release', u.unpack_one("B"))
except:
self.decode_failure = True
print "Error parsing BIOSInformation"
import traceback
traceback.print_exc()
self.fini()
class SystemInformation(SmbiosBaseStructure):
smbios_structure_type = 1
def __init__(self, u, sm):
super(SystemInformation, self).__init__(u, sm)
u = self.u
try:
self.add_field('manufacturer', u.unpack_one("B"), self.fmtstr)
self.add_field('product_name', u.unpack_one("B"), self.fmtstr)
self.add_field('version', u.unpack_one("B"), self.fmtstr)
self.add_field('serial_number', u.unpack_one("B"), self.fmtstr)
if self.length > 0x8:
self.add_field('uuid', uuid.UUID(bytes_le=u.unpack_one("16s")))
wakeup_types = {
0: 'Reserved',
1: 'Other',
2: 'Unknown',
3: 'APM Timer',
4: 'Modem Ring',
5: 'LAN Remote',
6: 'Power Switch',
7: 'PCI PME#',
8: 'AC Power Restored'
}
self.add_field('wakeup_type', u.unpack_one("B"), unpack.format_table("{}", wakeup_types))
if self.length > 0x19:
self.add_field('sku_number', u.unpack_one("B"), self.fmtstr)
self.add_field('family', u.unpack_one("B"), self.fmtstr)
except:
self.decode_failure = True
print "Error parsing SystemInformation"
import traceback
traceback.print_exc()
self.fini()
_board_types = {
1: 'Unknown',
2: 'Other',
3: 'Server Blade',
4: 'Connectivity Switch',
5: 'System Management Module',
6: 'Processor Module',
7: 'I/O Module',
8: 'Memory Module',
9: 'Daughter Board',
0xA: 'Motherboard',
0xB: 'Processor/Memory Module',
0xC: 'Processor/IO Module',
0xD: 'Interconnect Board'
}
class BaseboardInformation(SmbiosBaseStructure):
smbios_structure_type = 2
def __init__(self, u, sm):
super(BaseboardInformation, self).__init__(u, sm)
u = self.u
try:
self.add_field('manufacturer', u.unpack_one("B"), self.fmtstr)
self.add_field('product', u.unpack_one("B"), self.fmtstr)
self.add_field('version', u.unpack_one("B"), self.fmtstr)
self.add_field('serial_number', u.unpack_one("B"), self.fmtstr)
if self.length > 0x8:
self.add_field('asset_tag', u.unpack_one("B"), self.fmtstr)
if self.length > 0x9:
self.add_field('feature_flags', u.unpack_one("B"))
self.add_field('hosting_board', bool(bitfields.getbits(self.feature_flags, 0)), "feature_flags[0]={}")
self.add_field('requires_daughter_card', bool(bitfields.getbits(self.feature_flags, 1)), "feature_flags[1]={}")
self.add_field('removable', bool(bitfields.getbits(self.feature_flags, 2)), "feature_flags[2]={}")
self.add_field('replaceable', bool(bitfields.getbits(self.feature_flags, 3)), "feature_flags[3]={}")
self.add_field('hot_swappable', bool(bitfields.getbits(self.feature_flags, 4)), "feature_flags[4]={}")
if self.length > 0xA:
self.add_field('location', u.unpack_one("B"), self.fmtstr)
if self.length > 0xB:
self.add_field('chassis_handle', u.unpack_one("<H"))
if self.length > 0xD:
self.add_field('board_type', u.unpack_one("B"), unpack.format_table("{}", _board_types))
if self.length > 0xE:
self.add_field('handle_count', u.unpack_one("B"))
if self.handle_count > 0:
self.add_field('contained_object_handles', tuple(u.unpack_one("<H") for i in range(self.handle_count)))
except:
self.decode_failure = True
print "Error parsing BaseboardInformation"
import traceback
traceback.print_exc()
self.fini()
class SystemEnclosure(SmbiosBaseStructure):
smbios_structure_type = 3
def __init__(self, u, sm):
super(SystemEnclosure, self).__init__(u, sm)
u = self.u
try:
self.add_field('manufacturer', u.unpack_one("B"), self.fmtstr)
self.add_field('enumerated_type', u.unpack_one("B"))
self.add_field('chassis_lock_present', bool(bitfields.getbits(self.enumerated_type, 7)), "enumerated_type[7]={}")
board_types = {
0x01: 'Other',
0x02: 'Unknown',
0x03: 'Desktop',
0x04: 'Low Profile Desktop',
0x05: 'Pizza Box',
0x06: 'Mini Tower',
0x07: 'Tower',
0x08: 'Portable',
0x09: 'Laptop',
0x0A: 'Notebook',
0x0B: 'Hand Held',
0x0C: 'Docking Station',
0x0D: 'All in One',
0x0E: 'Sub Notebook',
0x0F: 'Space-saving',
0x10: 'Lunch Box',
0x11: 'Main Server Chassis',
0x12: 'Expansion Chassis',
0x13: 'SubChassis',
0x14: 'Bus Expansion Chassis',
0x15: 'Peripheral Chassis',
0x16: 'RAID Chassis',
0x17: 'Rack Mount Chassis',
0x18: 'Sealed-case PC',
0x19: 'Multi-system chassis W',
0x1A: 'Compact PCI',
0x1B: 'Advanced TCA',
0x1C: 'Blade',
0x1D: 'Blade Enclosure',
}
self.add_field('system_enclosure_type', bitfields.getbits(self.enumerated_type, 6, 0), unpack.format_table("enumerated_type[6:0]={}", board_types))
self.add_field('version', u.unpack_one("B"), self.fmtstr)
self.add_field('serial_number', u.unpack_one("B"), self.fmtstr)
self.add_field('asset_tag', u.unpack_one("B"), self.fmtstr)
minor_version_str = str(sm.header.minor_version) # 34 is .34, 4 is .4, 41 is .41; compare ASCIIbetically to compare initial digits rather than numeric value
if self.length > 9:
chassis_states = {
0x01: 'Other',
0x02: 'Unknown',
0x03: 'Safe',
0x04: 'Warning',
0x05: 'Critical',
0x06: 'Non-recoverable',
}
self.add_field('bootup_state', u.unpack_one("B"), unpack.format_table("{}", chassis_states))
self.add_field('power_supply_state', u.unpack_one("B"), unpack.format_table("{}", chassis_states))
self.add_field('thermal_state', u.unpack_one("B"), unpack.format_table("{}", chassis_states))
security_states = {
0x01: 'Other',
0x02: 'Unknown',
0x03: 'None',
0x04: 'External interface locked out',
0x05: 'External interface enabled',
}
self.add_field('security_status', u.unpack_one("B"), unpack.format_table("{}", security_states))
if self.length > 0xd:
self.add_field('oem_defined', u.unpack_one("<I"))
if self.length > 0x11:
self.add_field('height', u.unpack_one("B"))
self.add_field('num_power_cords', u.unpack_one("B"))
self.add_field('contained_element_count', u.unpack_one("B"))
self.add_field('contained_element_length', u.unpack_one("B"))
if getattr(self, 'contained_element_count', 0):
self.add_field('contained_elements', tuple(SystemEnclosureContainedElement(u, self.contained_element_length) for i in range(self.contained_element_count)))
if self.length > (0x15 + (getattr(self, 'contained_element_count', 0) * getattr(self, 'contained_element_length', 0))):
self.add_field('sku_number', u.unpack_one("B"), self.fmtstr)
except:
self.decode_failure = True
print "Error parsing SystemEnclosure"
import traceback
traceback.print_exc()
self.fini()
class SystemEnclosureContainedElement(unpack.Struct):
def __init__(self, u, length):
super(SystemEnclosureContainedElement, self).__init__()
self.start_offset = u.offset
self.raw_data = u.unpack_raw(length)
self.u = unpack.Unpackable(self.raw_data)
u = self.u
self.add_field('contained_element_type', u.unpack_one("B"))
type_selections = {
0: 'SMBIOS baseboard type enumeration',
1: 'SMBIOS structure type enumeration',
}
self.add_field('type_select', bitfields.getbits(self.contained_element_type, 7), unpack.format_table("contained_element_type[7]={}", type_selections))
self.add_field('type', bitfields.getbits(self.contained_element_type, 6, 0))
if self.type_select == 0:
self.add_field('smbios_board_type', self.type, unpack.format_table("{}", _board_types))
else:
self.add_field('smbios_structure_type', self.type)
self.add_field('minimum', u.unpack_one("B"))
self.add_field('maximum', u.unpack_one("B"))
if not u.at_end():
self.add_field('data', u.unpack_rest())
del self.u
class ProcessorInformation(SmbiosBaseStructure):
smbios_structure_type = 4
def __init__(self, u, sm):
super(ProcessorInformation, self).__init__(u, sm)
u = self.u
try:
self.add_field('socket_designation', u.unpack_one("B"), self.fmtstr)
processor_types = {
0x01: 'Other',
0x02: 'Unknown',
0x03: 'Central Processor',
0x04: 'Math Processor',
0x05: 'DSP Processor',
0x06: 'Video Processor',
}
self.add_field('processor_type', u.unpack_one("B"), unpack.format_table("{}", processor_types))
self.add_field('processor_family', u.unpack_one("B"))
self.add_field('processor_manufacturer', u.unpack_one("B"), self.fmtstr)
self.add_field('processor_id', u.unpack_one("<Q"))
self.add_field('processor_version', u.unpack_one("B"), self.fmtstr)
self.add_field('voltage', u.unpack_one("B"))
self.add_field('external_clock', u.unpack_one("<H"))
self.add_field('max_speed', u.unpack_one("<H"))
self.add_field('current_speed', u.unpack_one("<H"))
self.add_field('status', u.unpack_one("B"))
processor_upgrades = {
0x01: 'Other',
0x02: 'Unknown',
0x03: 'Daughter Board',
0x04: 'ZIF Socket',
0x05: 'Replaceable Piggy Back',
0x06: 'None',
0x07: 'LIF Socket',
0x08: 'Slot 1',
0x09: 'Slot 2',
0x0A: '370-pin socket',
0x0B: 'Slot A',
0x0C: 'Slot M',
0x0D: 'Socket 423',
0x0E: 'Socket A (Socket 462)',
0x0F: 'Socket 478',
0x10: 'Socket 754',
0x11: 'Socket 940',
0x12: 'Socket 939',
0x13: 'Socket mPGA604',
0x14: 'Socket LGA771',
0x15: 'Socket LGA775',
0x16: 'Socket S1',
0x17: 'Socket AM2',
0x18: 'Socket F (1207)',
0x19: 'Socket LGA1366',
0x1A: 'Socket G34',
0x1B: 'Socket AM3',
0x1C: 'Socket C32',
0x1D: 'Socket LGA1156',
0x1E: 'Socket LGA1567',
0x1F: 'Socket PGA988A',
0x20: 'Socket BGA1288',
0x21: 'Socket rPGA988B',
0x22: 'Socket BGA1023',
0x23: 'Socket BGA1224',
0x24: 'Socket BGA1155',
0x25: 'Socket LGA1356',
0x26: 'Socket LGA2011',
0x27: 'Socket FS1',
0x28: 'Socket FS2',
0x29: 'Socket FM1',
0x2A: 'Socket FM2',
}
self.add_field('processor_upgrade', u.unpack_one("B"), unpack.format_table("{}", processor_upgrades))
if self.length > 0x1A:
self.add_field('l1_cache_handle', u.unpack_one("<H"))
self.add_field('l2_cache_handle', u.unpack_one("<H"))
self.add_field('l3_cache_handle', u.unpack_one("<H"))
if self.length > 0x20:
self.add_field('serial_number', u.unpack_one("B"), self.fmtstr)
self.add_field('asset_tag', u.unpack_one("B"), self.fmtstr)
self.add_field('part_number', u.unpack_one("B"), self.fmtstr)
if self.length > 0x24:
self.add_field('core_count', u.unpack_one("B"))
self.add_field('core_enabled', u.unpack_one("B"))
self.add_field('thread_count', u.unpack_one("B"))
self.add_field('processor_characteristics', u.unpack_one("<H"))
if self.length > 0x28:
self.add_field('processor_family_2', u.unpack_one("<H"))
if self.length > 0x2A:
self.add_field('core_count2', u.unpack_one("<H"))
self.add_field('core_enabled2', u.unpack_one("<H"))
self.add_field('thread_count2', u.unpack_one("<H"))
except:
self.decode_failure = True
print "Error parsing Processor Information"
import traceback
traceback.print_exc()
self.fini()
class MemoryControllerInformation(SmbiosBaseStructure): #obsolete starting with v2.1
smbios_structure_type = 5
def __init__(self, u, sm):
super(MemoryControllerInformation, self).__init__(u, sm)
u = self.u
try:
_error_detecting_method = {
0x01: 'Other',
0x02: 'Unknown',
0x03: 'None',
0x04: '8-bit Parity',
0x05: '32-bit ECC',
0x06: '64-bit ECC',
0x07: '128-bit ECC',
0x08: 'CRC'
}
self.add_field('error_detecting_method', u.unpack_one("B"), unpack.format_table("{}", _error_detecting_method))
self.add_field('error_correcting_capability', u.unpack_one("B"))
_interleaves = {
0x01: 'Other',
0x02: 'Unknown',
0x03: 'One-Way Interleave',
0x04: 'Two-Way Interleave',
0x05: 'Four-Way Interleave',
0x06: 'Eight-Way Interleave',
0x07: 'Sixteen-Way Interleave'
}
self.add_field('supported_interleave', u.unpack_one("B"), unpack.format_table("{}", _interleaves))
self.add_field('current_interleave', u.unpack_one("B"), unpack.format_table("{}", _interleaves))
self.add_field('max_memory_module_size', u.unpack_one("B"), self.fmtstr)
self.add_field('supported_speeds', u.unpack_one("<H"))
self.add_field('supported_memory_types', u.unpack_one("<H"))
self.add_field('memory_module_voltage', u.unpack_one("B"))
self.add_field('req_voltage_b2', bitfields.getbits(self.memory_module_voltage, 2), "memory_module_voltage[2]={}")
self.add_field('req_voltage_b1', bitfields.getbits(self.memory_module_voltage, 1), "memory_module_voltage[1]={}")
self.add_field('req_voltage_b0', bitfields.getbits(self.memory_module_voltage, 0), "memory_module_voltage[0]={}")
self.add_field('num_associated_memory_slots', u.unpack_one("B"))
self.add_field('memory_module_configuration_handles', u.unpack_one("<(self.num_associated_memory_slots)H"))
self.add_field('enabled_error_correcting_capabilities', u.unpack_one("B"))
except:
self.decode_failure = True
print "Error parsing MemoryControllerInformation"
import traceback
traceback.print_exc()
self.fini()
class MemoryModuleInformation(SmbiosBaseStructure): #obsolete starting with v2.1
smbios_structure_type = 6
def __init__(self, u, sm):
super(MemoryModuleInformation, self).__init__(u, sm)
u = self.u
try:
self.add_field('socket_designation', u.unpack_one("B"), self.fmtstr)
self.add_field('bank_connections', u.unpack_one("B"))
self.add_field('current_speed', u.unpack_one("B"))
self.add_field('current_memory_type', u.unpack_one("<H"))
_mem_connection = {
0: 'single',
1: 'double-bank'
}
self.add_field('installed_mem', u.unpack_one("B"))
self.add_field('installed_size', bitfields.getbits(self.installed_mem, 6, 0), "installed_mem[6:0]={}")
self.add_field('installed_memory_module_connection', bitfields.getbits(self.installed_mem, 7), unpack.format_table("installed_mem[7]={}", _mem_connection))
self.add_field('enabled_mem', u.unpack_one("B"))
self.add_field('enabled_size', bitfields.getbits(self.installed_mem, 6, 0), "enabled_mem[6:0]={}")
self.add_field('enabled_memory_module_connection', bitfields.getbits(self.installed_mem, 7), unpack.format_table("enabled_mem[7]={}", _mem_connection))
self.add_field('error_status', u.unpack_one("B"))
self.add_field('error_status_info_obstained_from_event_log', bool(bitfields.getbits(self.error_status, 2)), unpack.format_table("error_status[2]={}", _mem_connection))
self.add_field('correctable_errors_received', bool(bitfields.getbits(self.error_status, 1)), unpack.format_table("error_status[1]={}", _mem_connection))
self.add_field('uncorrectable_errors_received', bool(bitfields.getbits(self.error_status, 0)), unpack.format_table("error_status[0]={}", _mem_connection))
except:
self.decode_failure = True
print "Error parsing MemoryModuleInformation"
import traceback
traceback.print_exc()
self.fini()
class CacheInformation(SmbiosBaseStructure):
smbios_structure_type = 7
def __init__(self, u, sm):
super(CacheInformation, self).__init__(u, sm)
u = self.u
try:
self.add_field('socket_designation', u.unpack_one("B"), self.fmtstr)
processor_types = {
0x01: 'Other',
0x02: 'Unknown',
0x03: 'Central Processor',
0x04: 'Math Processor',
0x05: 'DSP Processor',
0x06: 'Video Processor',
}
self.add_field('cache_configuration', u.unpack_one("<H"))
_operational_mode = {
0b00: 'Write Through',
0b01: 'Write Back',
0b10: 'Varies with Memory Address',
0b11: 'Unknown'
}
self.add_field('operational_mode', bitfields.getbits(self.cache_configuration, 9, 8), unpack.format_table("cache_configuration[9:8]={}", _operational_mode))
self.add_field('enabled_at_boot_time', bool(bitfields.getbits(self.cache_configuration, 7)), "cache_configuration[7]={}")
_location = {
0b00: 'Internal',
0b01: 'External',
0b10: 'Reserved',
0b11: 'Unknown'
}
self.add_field('location_relative_to_cpu_module', bitfields.getbits(self.cache_configuration, 6, 5), unpack.format_table("cache_configuration[6:5]={}", _location))
self.add_field('cache_socketed', bool(bitfields.getbits(self.cache_configuration, 3)), "cache_configuration[3]={}")
self.add_field('cache_level', bitfields.getbits(self.cache_configuration, 2, 0), "cache_configuration[2:0]={}")
self.add_field('max_cache_size', u.unpack_one("<H"))
_granularity = {
0: '1K granularity',
1: '64K granularity'
}
self.add_field('max_granularity', bitfields.getbits(self.cache_configuration, 15), unpack.format_table("max_cache_size[15]={}", _granularity))
self.add_field('max_size_in_granularity', bitfields.getbits(self.cache_configuration, 14, 0), "max_cache_size[14, 0]={}")
self.add_field('installed_size', u.unpack_one("<H"))
if self.installed_size != 0:
self.add_field('installed_granularity', bitfields.getbits(self.cache_configuration, 15), unpack.format_table("installed_size[15]={}", _granularity))
self.add_field('installed_size_in_granularity', bitfields.getbits(self.cache_configuration, 14, 0), "installed_size[14, 0]={}")
self.add_field('supported_sram_type', u.unpack_one("<H"))
self.add_field('current_sram_type', u.unpack_one("<H"))
if self.length > 0x0F:
self.add_field('cache_speed', u.unpack_one("B"))
if self.length > 0x10:
_error_correction = {
0x01: 'Other',
0x02: 'Unknown',
0x03: 'None',
0x04: 'Parity',
0x05: 'Single-bit ECC',
0x06: 'Multi-bit ECC'
}
self.add_field('error_correction', u.unpack_one("B"), unpack.format_table("{}", _error_correction))
if self.length > 0x10:
_system_cache_type = {
0x01: 'Other',
0x02: 'Unknown',
0x03: 'Instruction',
0x04: 'Data',
0x05: 'Unified'
}
self.add_field('system_cache_type', u.unpack_one("B"), unpack.format_table("{}", _system_cache_type))
if self.length > 0x12:
_associativity = {
0x01: 'Other',
0x02: 'Unknown',
0x03: 'Direct Mapped',
0x04: '2-way Set-Associative',
0x05: '4-way Set-Associative',
0x06: 'Fully Associative',
0x07: '8-way Set-Associative',
0x08: '16-way Set-Associative',
0x09: '12-way Set-Associative',
0x0A: '24-way Set-Associative',
0x0B: '32-way Set-Associative',
0x0C: '48-way Set-Associative',
0x0D: '64-way Set-Associative',
0x0E: '20-way Set-Associative'
}
self.add_field('associativity', u.unpack_one("B"), unpack.format_table("{}", _associativity))
except:
self.decode_failure = True
print "Error parsing CacheInformation"
import traceback
traceback.print_exc()
self.fini()
class PortConnectorInfo(SmbiosBaseStructure):
smbios_structure_type = 8
def __init__(self, u, sm):
super(PortConnectorInfo, self).__init__(u, sm)
u = self.u
try:
self.add_field('internal_reference_designator', u.unpack_one("B"), self.fmtstr)
connector_types = {
0x00: 'None',
0x01: 'Centronics',
0x02: 'Mini Centronics',
0x03: 'Proprietary',
0x04: 'DB-25 pin male',
0x05: 'DB-25 pin female',
0x06: 'DB-15 pin male',
0x07: 'DB-15 pin female',
0x08: 'DB-9 pin male',
0x09: 'DB-9 pin female',
0x0A: 'RJ-11',
0x0B: 'RJ-45',
0x0C: '50-pin MiniSCSI',
0x0D: 'Mini-DIN',
0x0E: 'Micro-DIN',
0x0F: 'PS/2',
0x10: 'Infrared',
0x11: 'HP-HIL',
0x12: 'Access Bus (USB)',
0x13: 'SSA SCSI',
0x14: 'Circular DIN-8 male',
0x15: 'Circular DIN-8 female',
0x16: 'On Board IDE',
0x17: 'On Board Floppy',
0x18: '9-pin Dual Inline (pin 10 cut)',
0x19: '25-pin Dual Inline (pin 26 cut)',
0x1A: '50-pin Dual Inline',
0x1B: '68-pin Dual Inline',
0x1C: 'On Board Sound Input from CD-ROM',
0x1D: 'Mini-Centronics Type-14',
0x1E: 'Mini-Centronics Type-26',
0x1F: 'Mini-jack (headphones)',
0x20: 'BNC',
0x21: '1394',
0x22: 'SAS/SATA Plug Receptacle',
0xA0: 'PC-98',
0xA1: 'PC-98Hireso',
0xA2: 'PC-H98',
0xA3: 'PC-98Note',
0xA4: 'PC-98Full',
0xFF: 'Other',
}
self.add_field('internal_connector_type', u.unpack_one("B"), unpack.format_table("{}", connector_types))
self.add_field('external_reference_designator', u.unpack_one("B"), self.fmtstr)
self.add_field('external_connector_type', u.unpack_one("B"), unpack.format_table("{}", connector_types))
port_types = {
0x00: 'None',
0x01: 'Parallel Port XT/AT Compatible',
0x02: 'Parallel Port PS/2',
0x03: 'Parallel Port ECP',
0x04: 'Parallel Port EPP',
0x05: 'Parallel Port ECP/EPP',
0x06: 'Serial Port XT/AT Compatible',
0x07: 'Serial Port 16450 Compatible',
0x08: 'Serial Port 16550 Compatible',
0x09: 'Serial Port 16550A Compatible',
0x0A: 'SCSI Port',
0x0B: 'MIDI Port',
0x0C: 'Joy Stick Port',
0x0D: 'Keyboard Port',
0x0E: 'Mouse Port',
0x0F: 'SSA SCSI',
0x10: 'USB',
0x11: 'FireWire (IEEE P1394)',
0x12: 'PCMCIA Type I2',
0x13: 'PCMCIA Type II',
0x14: 'PCMCIA Type III',
0x15: 'Cardbus',
0x16: 'Access Bus Port',
0x17: 'SCSI II',
0x18: 'SCSI Wide',
0x19: 'PC-98',
0x1A: 'PC-98-Hireso',
0x1B: 'PC-H98',
0x1C: 'Video Port',
0x1D: 'Audio Port',
0x1E: 'Modem Port',
0x1F: 'Network Port',
0x20: 'SATA',
0x21: 'SAS',
0xA0: '8251 Compatible',
0xA1: '8251 FIFO Compatible',
0xFF: 'Other',
}
self.add_field('port_type', u.unpack_one("B"), unpack.format_table("{}", port_types))
except:
self.decodeFailure = True
print "Error parsing PortConnectorInfo"
import traceback
traceback.print_exc()
self.fini()
class SystemSlots(SmbiosBaseStructure):
smbios_structure_type = 9
def __init__(self, u, sm):
super(SystemSlots, self).__init__(u, sm)
u = self.u
try:
self.add_field('designation', u.unpack_one("B"), self.fmtstr)
_slot_types = {
0x01: 'Other',
0x02: 'Unknown',
0x03: 'ISA',
0x04: 'MCA',
0x05: 'EISA',
0x06: 'PCI',
0x07: 'PC Card (PCMCIA)',
0x08: 'VL-VESA',
0x09: 'Proprietary',
0x0A: 'Processor Card Slot',
0x0B: 'Proprietary Memory Card Slot',
0x0C: 'I/O Riser Card Slot',
0x0D: 'NuBus',
0x0E: 'PCI 66MHz Capable',
0x0F: 'AGP',
0x10: 'AGP 2X',
0x11: 'AGP 4X',
0x12: 'PCI-X',
0x13: 'AGP 8X',
0xA0: 'PC-98/C20',
0xA1: 'PC-98/C24',
0xA2: 'PC-98/E',
0xA3: 'PC-98/Local Bus',
0xA4: 'PC-98/Card',
0xA5: 'PCI Express',
0xA6: 'PCI Express x1',
0xA7: 'PCI Express x2',
0xA8: 'PCI Express x4',
0xA9: 'PCI Express x8',
0xAA: 'PCI Express x16',
0xAB: 'PCI Express Gen 2',
0xAC: 'PCI Express Gen 2 x1',
0xAD: 'PCI Express Gen 2 x2',
0xAE: 'PCI Express Gen 2 x4',
0xAF: 'PCI Express Gen 2 x8',
0xB0: 'PCI Express Gen 2 x16',
0xB1: 'PCI Express Gen 3',
0xB2: 'PCI Express Gen 3 x1',
0xB3: 'PCI Express Gen 3 x2',
0xB4: 'PCI Express Gen 3 x4',
0xB5: 'PCI Express Gen 3 x8',
0xB6: 'PCI Express Gen 3 x16',
}
self.add_field('slot_type', u.unpack_one("B"), unpack.format_table("{}", _slot_types))
_slot_data_bus_widths = {
0x01: 'Other',
0x02: 'Unknown',
0x03: '8 bit',
0x04: '16 bit',
0x05: '32 bit',
0x06: '64 bit',
0x07: '128 bit',
0x08: '1x or x1',
0x09: '2x or x2',
0x0A: '4x or x4',
0x0B: '8x or x8',
0x0C: '12x or x12',
0x0D: '16x or x16',
0x0E: '32x or x32',
}
self.add_field('slot_data_bus_width', u.unpack_one('B'), unpack.format_table("{}", _slot_data_bus_widths))
_current_usages = {
0x01: 'Other',
0x02: 'Unknown',
0x03: 'Available',
0x04: 'In use',
}
self.add_field('current_usage', u.unpack_one('B'), unpack.format_table("{}", _current_usages))
_slot_lengths = {
0x01: 'Other',
0x02: 'Unknown',
0x03: 'Short Length',
0x04: 'Long Length',
}
self.add_field('slot_length', u.unpack_one('B'), unpack.format_table("{}", _slot_lengths))
self.add_field('slot_id', u.unpack_one('<H'))
self.add_field('characteristics1', u.unpack_one('B'))
self.add_field('characteristics_unknown', bool(bitfields.getbits(self.characteristics1, 0)), "characteristics1[0]={}")
self.add_field('provides_5_0_volts', bool(bitfields.getbits(self.characteristics1, 1)), "characteristics1[1]={}")
self.add_field('provides_3_3_volts', bool(bitfields.getbits(self.characteristics1, 2)), "characteristics1[2]={}")
self.add_field('shared_slot', bool(bitfields.getbits(self.characteristics1, 3)), "characteristics1[3]={}")
self.add_field('supports_pc_card_16', bool(bitfields.getbits(self.characteristics1, 4)), "characteristics1[4]={}")
self.add_field('supports_cardbus', bool(bitfields.getbits(self.characteristics1, 5)), "characteristics1[5]={}")
self.add_field('supports_zoom_video', bool(bitfields.getbits(self.characteristics1, 6)), "characteristics1[6]={}")
self.add_field('supports_modem_ring_resume', bool(bitfields.getbits(self.characteristics1, 7)), "characteristics1[7]={}")
if self.length > 0x0C:
self.add_field('characteristics2', u.unpack_one('B'))
self.add_field('supports_PME', bool(bitfields.getbits(self.characteristics2, 0)), "characteristics2[0]={}")
self.add_field('supports_hot_plug', bool(bitfields.getbits(self.characteristics2, 1)), "characteristics2[1]={}")
self.add_field('supports_smbus', bool(bitfields.getbits(self.characteristics2, 2)), "characteristics2[2]={}")
if self.length > 0x0D:
self.add_field('segment_group_number', u.unpack_one('<H'))
self.add_field('bus_number', u.unpack_one('B'))
self.add_field('device_function_number', u.unpack_one('B'))
self.add_field('device_number', bitfields.getbits(self.device_function_number, 7, 3), "device_function_number[7:3]={}")
self.add_field('function_number', bitfields.getbits(self.device_function_number, 2, 0), "device_function_number[2:0]={}")
except:
self.decodeFailure = True
print "Error parsing SystemSlots"
import traceback
traceback.print_exc()
self.fini()
class OnBoardDevicesInformation(SmbiosBaseStructure):
smbios_structure_type = 10
def __init__(self, u, sm):
super(OnBoardDevicesInformation, self).__init__(u, sm)
u = self.u
try:
self.add_field('device_type', u.unpack_one("B"))
self.add_field('device_enabled', bool(bitfields.getbits(self.device_type, 7)), "device_type[7]={}")
_device_types = {
0x01: 'Other',
0x02: 'Unknown',
0x03: 'Video',
0x04: 'SCSI Controller',
0x05: 'Ethernet',
0x06: 'Token Ring',
0x07: 'Sound',
0x08: 'PATA Controller',
0x09: 'SATA Controller',
0x0A: 'SAS Controller'
}
self.add_field('type_of_device', bitfields.getbits(self.device_type, 6, 0), unpack.format_table("device_type[6:0]={}", _device_types))
self.add_field('description_string', u.unpack_one("B"), self.fmtstr)
except:
self.decodeFailure = True
print "Error parsing OnBoardDevicesInformation"
import traceback
traceback.print_exc()
self.fini()
class OEMStrings(SmbiosBaseStructure):
smbios_structure_type = 11
def __init__(self, u, sm):
super(OEMStrings, self).__init__(u, sm)
u = self.u
try:
self.add_field('count', u.unpack_one("B"))
except:
self.decodeFailure = True
print "Error parsing OEMStrings"
import traceback
traceback.print_exc()
self.fini()
class SystemConfigOptions(SmbiosBaseStructure):
smbios_structure_type = 12
def __init__(self, u, sm):
super(SystemConfigOptions, self).__init__(u, sm)
u = self.u
try:
self.add_field('count', u.unpack_one("B"))
except:
self.decodeFailure = True
print "Error parsing SystemConfigOptions"
import traceback
traceback.print_exc()
self.fini()
class BIOSLanguageInformation(SmbiosBaseStructure):
smbios_structure_type = 13
def __init__(self, u, sm):
super(BIOSLanguageInformation, self).__init__(u, sm)
u = self.u
try:
self.add_field('installable_languages', u.unpack_one("B"))
if self.length > 0x05:
self.add_field('flags', u.unpack_one('B'))
self.add_field('abbreviated_format', bool(bitfields.getbits(self.flags, 0)), "flags[0]={}")
if self.length > 0x6:
u.skip(15)
self.add_field('current_language', u.unpack_one('B'), self.fmtstr)
except:
self.decodeFailure = True
print "Error parsing BIOSLanguageInformation"
import traceback
traceback.print_exc()
self.fini()
class GroupAssociations(SmbiosBaseStructure):
smbios_structure_type = 14
def __init__(self, u, sm):
super(GroupAssociations, self).__init__(u, sm)
u = self.u
try:
self.add_field('group_name', u.unpack_one("B"), self.fmtstr)
self.add_field('item_type', u.unpack_one('B'))
self.add_field('item_handle', u.unpack_one('<H'))
except:
self.decodeFailure = True
print "Error parsing GroupAssociations"
import traceback
traceback.print_exc()
self.fini()
class SystemEventLog(SmbiosBaseStructure):
smbios_structure_type = 15
def __init__(self, u, sm):
super(SystemEventLog, self).__init__(u, sm)
u = self.u
try:
self.add_field('log_area_length', u.unpack_one("<H"))
self.add_field('log_header_start_offset', u.unpack_one('<H'))
self.add_field('log_data_start_offset', u.unpack_one('<H'))
_access_method = {
0x00: 'Indexed I/O: 1 8-bit index port, 1 8-bit data port',
0x01: 'Indexed I/O: 2 8-bit index ports, 1 8-bit data port',
0x02: 'Indexed I/O: 1 16-bit index port, 1 8-bit data port',
0x03: 'Memory-mapped physical 32-bit address',
0x04: 'Available through General-Purpose NonVolatile Data functions',
xrange(0x05, 0x07F): 'Available for future assignment',
xrange(0x80, 0xFF): 'BIOS Vendor/OEM-specific'
}
self.add_field('access_method', u.unpack_one('B'), unpack.format_table("{}", _access_method))
self.add_field('log_status', u.unpack_one('B'))
self.add_field('log_area_full', bool(bitfields.getbits(self.log_status, 1)), "log_status[1]={}")
self.add_field('log_area_valid', bool(bitfields.getbits(self.log_status, 0)), "log_status[0]={}")
self.add_field('log_change_token', u.unpack_one('<I'))
self.add_field('access_method_address', u.unpack_one('<I'))
if self.length > 0x14:
_log_header_formats = {
0: 'No header',
1: 'Type 1 log header',
xrange(2, 0x7f): 'Available for future assignment',
xrange(0x80, 0xff): 'BIOS vendor or OEM-specific format'
}
self.add_field('log_header_format', u.unpack_one("B"), unpack.format_table("{}", _log_header_formats))
if self.length > 0x15:
self.add_field('num_supported_log_type_descriptors', u.unpack_one('B'))
if self.length > 0x16:
self.add_field('length_log_type_descriptor', u.unpack_one('B'))
if self.length != (0x17 + (self.num_supported_log_type_descriptors * self.length_log_type_descriptor)):
print "Error: structure length ({}) != 0x17 + (num_supported_log_type_descriptors ({}) * length_log_type_descriptor({}))".format(self.length, self.num_supported_log_type_descriptors, self.length_log_type_descriptor)
print "structure length = {}".format(self.length)
print "num_supported_log_type_descriptors = {}".format(self.num_supported_log_type_descriptors)
print "length_log_type_descriptor = {}".format(self.length_log_type_descriptor)
self.decodeFailure = True
self.add_field('descriptors', tuple(EventLogDescriptor.unpack(u) for i in range(self.num_supported_log_type_descriptors)), unpack.format_each("\n{!r}"))
except:
self.decodeFailure = True
print "Error parsing SystemEventLog"
import traceback
traceback.print_exc()
self.fini()
class EventLogDescriptor(unpack.Struct):
@staticmethod
def _unpack(u):
_event_log_type_descriptors = {
0x00: 'Reserved',
0x01: 'Single-bit ECC memory error',
0x02: 'Multi-bit ECC memory error',
0x03: 'Parity memory error',
0x04: 'Bus time-out',
0x05: 'I/O Channel Check',
0x06: 'Software NMI',
0x07: 'POST Memory Resize',
0x08: 'POST Error',
0x09: 'PCI Parity Error',
0x0A: 'PCI System Error',
0x0B: 'CPU Failure',
0x0C: 'EISA FailSafe Timer time-out',
0x0D: 'Correctable memory log disabled',
0x0E: 'Logging disabled for a specific Event Type - too many errors of the same type received in a short amount of time',
0x0F: 'Reserved',
0x10: 'System Limit Exceeded',
0x11: 'Asynchronous hardware timer expired and issued a system reset',
0x12: 'System configuration information',
0x13: 'Hard-disk information',
0x14: 'System reconfigured',
0x15: 'Uncorrectable CPU-complex error',
0x16: 'Log Area Reset/Cleared',
0x17: 'System boot',
xrange(0x18, 0x7F): 'Unused, available for assignment',
xrange(0x80, 0xFE): 'Available for system- and OEM-specific assignments',
0xFF: 'End of log'
}
yield 'log_type', u.unpack_one('B'), unpack.format_table("{}", _event_log_type_descriptors)
_event_log_format = {
0x00: 'None',
0x01: 'Handle',
0x02: 'Multiple-Event',
0x03: 'Multiple-Event Handle',
0x04: 'POST Results Bitmap',
0x05: 'System Management Type',
0x06: 'Multiple-Event System Management Type',
xrange(0x80, 0xFF): 'OEM assigned'
}
yield 'variable_data_format_type', u.unpack_one('B'), unpack.format_table("{}", _event_log_format)
class PhysicalMemoryArray(SmbiosBaseStructure):
smbios_structure_type = 16
def __init__(self, u, sm):
super(PhysicalMemoryArray, self).__init__(u, sm)
u = self.u
try:
if self.length > 0x4:
_location_field = {
0x01: "Other",
0x02: "Unknown",
0x03: "System board or motherboard",
0x04: "ISA add-on card",
0x05: "EISA add-on card",
0x06: "PCI add-on card",
0x07: "MCA add-on card",
0x08: "PCMCIA add-on card",
0x09: "Proprietary add-on card",
0x0A: "NuBus",
0xA0: "PC-98/C20 add-on card",
0xA1: "PC-98/C24 add-on card",
0xA2: "PC-98/E add-on card",
0xA3: "PC-98/Local bus add-on card"
}
self.add_field('location', u.unpack_one("B"), unpack.format_table("{}", _location_field))
if self.length > 0x05:
_use = {
0x01: "Other",
0x02: "Unknown",
0x03: "System memory",
0x04: "Video memory",
0x05: "Flash memory",
0x06: "Non-volatile RAM",
0x07: "Cache memory"
}
self.add_field('use', u.unpack_one('B'), unpack.format_table("{}", _use))
if self.length > 0x06:
_error_correction = {
0x01: "Other",
0x02: "Unknown",
0x03: "None",
0x04: "Parity",
0x05: "Single-bit ECC",
0x06: "Multi-bit ECC",
0x07: "CRC"
}
self.add_field('memory_error_correction', u.unpack_one('B'), unpack.format_table("{}", _error_correction))
if self.length > 0x07:
self.add_field('maximum_capacity', u.unpack_one('<I'))
if self.length > 0x0B:
self.add_field('memory_error_information_handle', u.unpack_one('<H'))
if self.length > 0x0D:
self.add_field('num_memory_devices', u.unpack_one('<H'))
if self.length > 0x0F:
self.add_field('extended_maximum_capacity', u.unpack_one('<Q'))
except:
self.decodeFailure = True
print "Error parsing PhysicalMemoryArray"
import traceback
traceback.print_exc()
self.fini()
class MemoryDevice(SmbiosBaseStructure):
smbios_structure_type = 17
def __init__(self, u, sm):
super(MemoryDevice, self).__init__(u, sm)
u = self.u
try:
if self.length > 0x4:
self.add_field('physical_memory_array_handle', u.unpack_one("<H"))
if self.length > 0x6:
self.add_field('memory_error_information_handle', u.unpack_one("<H"))
if self.length > 0x8:
self.add_field('total_width', u.unpack_one("<H"))
if self.length > 0xA:
self.add_field('data_width', u.unpack_one("<H"))
if self.length > 0xC:
self.add_field('size', u.unpack_one("<H"))
if self.length > 0xE:
_form_factors = {
0x01: 'Other',
0x02: 'Unknown',
0x03: 'SIMM',
0x04: 'SIP',
0x05: 'Chip',
0x06: 'DIP',
0x07: 'ZIP',
0x08: 'Proprietary Card',
0x09: 'DIMM',
0x0A: 'TSOP',
0x0B: 'Row of chips',
0x0C: 'RIMM',
0x0D: 'SODIMM',
0x0E: 'SRIMM',
0x0F: 'FB-DIMM'
}
self.add_field('form_factor', u.unpack_one("B"), unpack.format_table("{}", _form_factors))
if self.length > 0xF:
self.add_field('device_set', u.unpack_one("B"))
if self.length > 0x10:
self.add_field('device_locator', u.unpack_one("B"), self.fmtstr)
if self.length > 0x11:
self.add_field('bank_locator', u.unpack_one("B"), self.fmtstr)
if self.length > 0x12:
_memory_types = {
0x01: 'Other',
0x02: 'Unknown',
0x03: 'DRAM',
0x04: 'EDRAM',
0x05: 'VRAM',
0x06: 'SRAM',
0x07: 'RAM',
0x08: 'ROM',
0x09: 'FLASH',
0x0A: 'EEPROM',
0x0B: 'FEPROM',
0x0C: 'EPROM',
0x0D: 'CDRAM',
0x0E: '3DRAM',
0x0F: 'SDRAM',
0x10: 'SGRAM',
0x11: 'RDRAM',
0x12: 'DDR',
0x13: 'DDR2',
0x14: 'DDR2 FB-DIMM',
xrange(0x15, 0x17): 'Reserved',
0x18: 'DDR3',
0x19: 'FBD2'
}
self.add_field('memory_type', u.unpack_one("B"), unpack.format_table("{}", _memory_types))
if self.length > 0x13:
self.add_field('type_detail', u.unpack_one('<H'))
if self.length > 0x15:
self.add_field('speed', u.unpack_one("<H"))
if self.length > 0x17:
self.add_field('manufacturer', u.unpack_one("B"), self.fmtstr)
if self.length > 0x18:
self.add_field('serial_number', u.unpack_one("B"), self.fmtstr)
if self.length > 0x19:
self.add_field('asset_tag', u.unpack_one("B"), self.fmtstr)
if self.length > 0x1A:
self.add_field('part_number', u.unpack_one("B"), self.fmtstr)
if self.length > 0x1B:
self.add_field('attributes', u.unpack_one("B"))
self.add_field('rank', bitfields.getbits(self.attributes, 3, 0), "attributes[3:0]={}")
if self.length > 0x1C:
if self.size == 0x7FFF:
self.add_field('extended_size', u.unpack_one('<I'))
self.add_field('mem_size', bitfields.getbits(self.type_detail, 30, 0), "type_detail[30:0]={}")
else:
u.skip(4)
if self.length > 0x20:
self.add_field('configured_memory_clock_speed', u.unpack_one("<H"))
if self.length > 0x22:
self.add_field('minimum_voltage', u.unpack_one("<H"))
if self.length > 0x24:
self.add_field('maximum_voltage', u.unpack_one("<H"))
if self.length > 0x26:
self.add_field('configured_voltage', u.unpack_one("<H"))
except:
self.decodeFailure = True
print "Error parsing MemoryDevice"
import traceback
traceback.print_exc()
self.fini()
class MemoryErrorInfo32Bit(SmbiosBaseStructure):
smbios_structure_type = 18
def __init__(self, u, sm):
super(MemoryErrorInfo32Bit, self).__init__(u, sm)
u = self.u
try:
if self.length > 0x4:
_error_types = {
0x01: 'Other',
0x02: 'Unknown',
0x03: 'OK',
0x04: 'Bad read',
0x05: 'Parity error',
0x06: 'Single-bit error',
0x07: 'Double-bit error',
0x08: 'Multi-bit error',
0x09: 'Nibble error',
0x0A: 'Checksum error',
0x0B: 'CRC error',
0x0C: 'Corrected single-bit error',
0x0D: 'Corrected error',
0x0E: 'Uncorrectable error'
}
self.add_field('error_type', u.unpack_one("B"), unpack.format_table("{}", _error_types))
if self.length > 0x5:
_error_granularity_field = {
0x01: 'Other',
0x02: 'Unknown',
0x03: 'Device level',
0x04: 'Memory partition level'
}
self.add_field('error_granularity', u.unpack_one("B"), unpack.format_table("{}", _error_granularity_field))
if self.length > 0x6:
_error_operation_field = {
0x01: 'Other',
0x02: 'Unknown',
0x03: 'Read',
0x04: 'Write',
0x05: 'Partial write'
}
self.add_field('error_operation', u.unpack_one("B"), unpack.format_table("{}", _error_operation_field))
if self.length > 0x7:
self.add_field('vendor_syndrome', u.unpack_one("<I"))
if self.length > 0xB:
self.add_field('memory_array_error_address', u.unpack_one("<I"))
if self.length > 0xF:
self.add_field('device_error_address', u.unpack_one("<I"))
if self.length > 0x13:
self.add_field('error_resolution', u.unpack_one("<I"))
except:
self.decodeFailure = True
print "Error parsing MemoryErrorInfo32Bit"
import traceback
traceback.print_exc()
self.fini()
class MemoryArrayMappedAddress(SmbiosBaseStructure):
smbios_structure_type = 19
def __init__(self, u, sm):
super(MemoryArrayMappedAddress, self).__init__(u, sm)
u = self.u
try:
if self.length > 0x4:
self.add_field('starting_address', u.unpack_one("<I"))
# if FFFF FFFF: address stored in Extended Starting Address
if self.length > 0x8:
self.add_field('ending_address', u.unpack_one("<I"))
if self.length > 0xC:
self.add_field('memory_array_handle', u.unpack_one("<H"))
if self.length > 0xE:
self.add_field('partition_width', u.unpack_one("B"))
if self.length > 0xF:
# valid if starting_address = FFFF FFFF
if self.starting_address == 0xFFFFFFFF:
self.add_field('extended_starting_address', u.unpack_one("<Q"))
if self.length > 0x17:
self.add_field('extended_ending_address', u.unpack_one("<Q"))
else:
u.skip(16)
except:
self.decodeFailure = True
print "Error parsing MemoryArrayMappedAddress"
import traceback
traceback.print_exc()
self.fini()
class MemoryDeviceMappedAddress(SmbiosBaseStructure):
smbios_structure_type = 20
def __init__(self, u, sm):
super(MemoryDeviceMappedAddress, self).__init__(u, sm)
u = self.u
try:
if self.length > 0x4:
self.add_field('starting_address', u.unpack_one("<I"))
# if FFFF FFFF: address stored in Extended Starting Address
if self.length > 0x8:
self.add_field('ending_address', u.unpack_one("<I"))
if self.length > 0xC:
self.add_field('memory_device_handle', u.unpack_one("<H"))
if self.length > 0xE:
self.add_field('memory_array_mapped_address_handle', u.unpack_one("<H"))
if self.length > 0x10:
self.add_field('partition_row_position', u.unpack_one("B"))
if self.length > 0x11:
self.add_field('interleave_position', u.unpack_one("B"))
if self.length > 0x12:
self.add_field('interleave_data_depth', u.unpack_one("B"))
if self.length > 0x13:
# valid if starting_address = FFFF FFFF
if self.starting_address == 0xFFFFFFFF:
self.add_field('extended_starting_address', u.unpack_one("<Q"))
if self.length > 0x1B:
self.add_field('extended_ending_address', u.unpack_one("<Q"))
else:
u.skip(16)
except:
self.decodeFailure = True
print "Error parsing MemoryDeviceMappedAddress"
import traceback
traceback.print_exc()
self.fini()
class BuiltInPointingDevice(SmbiosBaseStructure):
smbios_structure_type = 21
def __init__(self, u, sm):
super(BuiltInPointingDevice, self).__init__(u, sm)
u = self.u
try:
if self.length > 0x4:
_pointing_device_types = {
0x01: 'Other',
0x02: 'Unknown',
0x03: 'Mouse',
0x04: 'Track Ball',
0x05: 'Track Point',
0x06: 'Glide Point',
0x07: 'Touch Pad',
0x08: 'Touch Screen',
0x09: 'Optical Sensor'
}
self.add_field('pointing_device_type', u.unpack_one("B"), unpack.format_table("{}", _pointing_device_types))
if self.length > 0x5:
_interfaces = {
0x01: 'Other',
0x02: 'Unknown',
0x03: 'Serial',
0x04: 'PS/2',
0x05: 'Infared',
0x06: 'HP-HIL',
0x07: 'Bus mouse',
0x08: 'ADB (Apple Desktop Bus)',
0x09: 'Bus mouse DB-9',
0x0A: 'Bus mouse micro-DIN',
0x0B: 'USB'
}
self.add_field('interface', u.unpack_one("B"), unpack.format_table("{}", _interfaces))
if self.length > 0x6:
self.add_field('num_buttons', u.unpack_one("B"))
except:
self.decodeFailure = True
print "Error parsing BuiltInPointingDevice"
import traceback
traceback.print_exc()
self.fini()
class PortableBattery(SmbiosBaseStructure):
smbios_structure_type = 22
def __init__(self, u, sm):
super(PortableBattery, self).__init__(u, sm)
u = self.u
try:
if self.length > 0x4:
self.add_field('location', u.unpack_one("B"), self.fmtstr)
if self.length > 0x5:
self.add_field('manufacturer', u.unpack_one("B"), self.fmtstr)
if self.length > 0x6:
self.add_field('manufacturer_date', u.unpack_one("B"), self.fmtstr)
if self.length > 0x7:
self.add_field('serial_number', u.unpack_one("B"), self.fmtstr)
if self.length > 0x8:
self.add_field('device_name', u.unpack_one("B"), self.fmtstr)
if self.length > 0x9:
_device_chemistry = {
0x01: 'Other',
0x02: 'Unknown',
0x03: 'Lead Acid',
0x04: 'Nickel Cadmium',
0x05: 'Nickel metal hydride',
0x06: 'Lithium-ion',
0x07: 'Zinc air',
0x08: 'Lithium Polymer'
}
self.add_field('device_chemistry', u.unpack_one("B"), unpack.format_table("{}", _device_chemistry))
if self.length > 0xA:
self.add_field('design_capacity', u.unpack_one("<H"))
if self.length > 0xC:
self.add_field('design_voltage', u.unpack_one("<H"))
if self.length > 0xE:
self.add_field('sbds_version_number', u.unpack_one("B"), self.fmtstr)
if self.length > 0xF:
self.add_field('max_error_battery_data', u.unpack_one("B"), self.fmtstr)
if self.length > 0x10:
if self.serial_number == 0:
self.add_field('sbds_serial_number', u.unpack_one("<H"))
else:
u.skip(2)
if self.length > 0x12:
if self.manufacturer_date == 0:
self.add_field('sbds_manufacture_date', u.unpack_one("<H"))
self.add_field('year_biased_by_1980', bitfields.getbits(self.sbds_manufacture_date, 15, 9), "sbds_manufacture_date[15:9]={}")
self.add_field('month', bitfields.getbits(self.sbds_manufacture_date, 8, 5), "sbds_manufacture_date[8:5]={}")
self.add_field('date', bitfields.getbits(self.sbds_manufacture_date, 4, 0), "sbds_manufacture_date[4:0]={}")
else:
u.skip(2)
if self.length > 0x14:
if self.device_chemistry == 0x02:
self.add_field('sbds_device_chemistry', u.unpack_one("B"), self.fmtstr)
else:
u.skip(1)
if self.length > 0x15:
self.add_field('design_capacity_multiplier', u.unpack_one("B"))
if self.length > 0x16:
self.add_field('oem_specific', u.unpack_one("<I"))
except:
self.decodeFailure = True
print "Error parsing PortableBattery"
import traceback
traceback.print_exc()
self.fini()
class SystemReset(SmbiosBaseStructure):
smbios_structure_type = 23
def __init__(self, u, sm):
super(SystemReset, self).__init__(u, sm)
u = self.u
try:
if self.length > 0x4:
self.add_field('capabilities', u.unpack_one("B"))
self.add_field('contains_watchdog_timer', bool(bitfields.getbits(self.capabilities, 5)), "capabilities[5]={}")
_boot_option = {
0b00: 'Reserved, do not use',
0b01: 'Operating System',
0b10: 'System utilities',
0b11: 'Do not reboot'
}
self.add_field('boot_option_on_limit', bitfields.getbits(self.capabilities, 4, 3), unpack.format_table("capabilities[4:3]={}", _boot_option))
self.add_field('boot_option_after_watchdog_reset', bitfields.getbits(self.capabilities, 2, 1), unpack.format_table("capabilities[2:1]={}", _boot_option))
self.add_field('system_reset_enabled_by_user', bool(bitfields.getbits(self.capabilities, 0)), "capabilities[0]={}")
if self.length > 0x5:
self.add_field('reset_count', u.unpack_one("<H"))
if self.length > 0x5:
self.add_field('reset_limit', u.unpack_one("<H"))
if self.length > 0x9:
self.add_field('timer_interval', u.unpack_one("<H"))
if self.length > 0xB:
self.add_field('timeout', u.unpack_one("<H"))
except:
self.decodeFailure = True
print "Error parsing SystemReset"
import traceback
traceback.print_exc()
self.fini()
class HardwareSecurity(SmbiosBaseStructure):
smbios_structure_type = 24
def __init__(self, u, sm):
super(HardwareSecurity, self).__init__(u, sm)
u = self.u
try:
if self.length > 0x4:
self.add_field('hardware_security_settings', u.unpack_one("B"))
_status = {
0x00: 'Disabled',
0x01: 'Enabled',
0x02: 'Not Implemented',
0x03: 'Unknown'
}
self.add_field('power_on_password_status', bitfields.getbits(self.hardware_security_settings, 7, 6), unpack.format_table("hardware_security_settings[7:6]={}", _status))
self.add_field('keyboard_password_status', bitfields.getbits(self.hardware_security_settings, 5, 4), unpack.format_table("hardware_security_settings[5:4]={}", _status))
self.add_field('admin_password_status', bitfields.getbits(self.hardware_security_settings, 3, 2), unpack.format_table("hardware_security_settings0[3:2]={}", _status))
self.add_field('front_panel_reset_status', bitfields.getbits(self.hardware_security_settings, 1, 0), unpack.format_table("hardware_security_settings[1:0]={}", _status))
except:
self.decodeFailure = True
print "Error parsing HardwareSecurity"
import traceback
traceback.print_exc()
self.fini()
class SystemPowerControls(SmbiosBaseStructure):
smbios_structure_type = 25
def __init__(self, u, sm):
super(SystemPowerControls, self).__init__(u, sm)
u = self.u
try:
if self.length > 0x4:
self.add_field('next_scheduled_poweron_month', u.unpack_one("B"))
self.add_field('next_scheduled_poweron_day_of_month', u.unpack_one("B"))
self.add_field('next_scheduled_poweron_hour', u.unpack_one("B"))
self.add_field('next_scheduled_poweron_minute', u.unpack_one("B"))
self.add_field('next_scheduled_poweron_second', u.unpack_one("B"))
except:
self.decodeFailure = True
print "Error parsing SystemPowerControls"
import traceback
traceback.print_exc()
self.fini()
class VoltageProbe(SmbiosBaseStructure):
smbios_structure_type = 26
def __init__(self, u, sm):
super(VoltageProbe, self).__init__(u, sm)
u = self.u
try:
if self.length > 0x4:
self.add_field('description', u.unpack_one("B"), self.fmtstr)
if self.length > 0x5:
self.add_field('location_and_status', u.unpack_one("B"))
_status = {
0b001: 'Other',
0b010: 'Unknown',
0b011: 'OK',
0b100: 'Non-critical',
0b101: 'Critical',
0b110: 'Non-recoverable'
}
_location = {
0b00001: 'Other',
0b00010: 'Unknown',
0b00011: 'Processor',
0b00100: 'Disk',
0b00101: 'Peripheral Bay',
0b00110: 'System Management Module',
0b00111: 'Motherboard',
0b01000: 'Memory Module',
0b01001: 'Processor Module',
0b01010: 'Power Unit',
0b01011: 'Add-in Card'
}
self.add_field('status', bitfields.getbits(self.location_and_status, 7, 5), unpack.format_table("location_and_status[7:5]={}", _status))
self.add_field('location', bitfields.getbits(self.location_and_status, 4, 0), unpack.format_table("location_and_status[4:0]={}", _location))
if self.length > 0x6:
self.add_field('max_value', u.unpack_one("<H"))
if self.length > 0x8:
self.add_field('min_value', u.unpack_one("<H"))
if self.length > 0xA:
self.add_field('resolution', u.unpack_one("<H"))
if self.length > 0xC:
self.add_field('tolerance', u.unpack_one("<H"))
if self.length > 0xE:
self.add_field('accuracy', u.unpack_one("<H"))
if self.length > 0x10:
self.add_field('oem_defined', u.unpack_one("<I"))
if self.length > 0x14:
self.add_field('nominal_value', u.unpack_one("<H"))
except:
self.decodeFailure = True
print "Error parsing VoltageProbe"
import traceback
traceback.print_exc()
self.fini()
class CoolingDevice(SmbiosBaseStructure):
smbios_structure_type = 27
def __init__(self, u, sm):
super(CoolingDevice, self).__init__(u, sm)
u = self.u
try:
if self.length > 0x4:
self.add_field('temperature_probe_handle', u.unpack_one("<H"))
if self.length > 0x6:
self.add_field('device_type_and_status', u.unpack_one("B"))
_status = {
0b001: 'Other',
0b010: 'Unknown',
0b011: 'OK',
0b100: 'Non-critical',
0b101: 'Critical',
0b110: 'Non-recoverable'
}
_type = {
0b00001: 'Other',
0b00010: 'Unknown',
0b00011: 'Fan',
0b00100: 'Centrifugal Blower',
0b00101: 'Chip Fan',
0b00110: 'Cabinet Fan',
0b00111: 'Power Supply Fan',
0b01000: 'Heat Pipe',
0b01001: 'Integrated Refrigeration',
0b10000: 'Active Cooling',
0b10001: 'Passive Cooling'
}
self.add_field('status', bitfields.getbits(self.device_type_and_status, 7, 5), unpack.format_table("device_type_and_status[7:5]={}", _status))
self.add_field('device_type', bitfields.getbits(self.device_type_and_status, 4, 0), unpack.format_table("device_type_and_status[4:0]={}", _type))
if self.length > 0x7:
self.add_field('cooling_unit_group', u.unpack_one("B"))
if self.length > 0x8:
self.add_field('OEM_defined', u.unpack_one("<I"))
if self.length > 0xC:
self.add_field('nominal_speed', u.unpack_one("<H"))
if self.length > 0xE:
self.add_field('description', u.unpack_one("B"), self.fmtstr)
except:
self.decodeFailure = True
print "Error parsing CoolingDevice"
import traceback
traceback.print_exc()
self.fini()
class TemperatureProbe(SmbiosBaseStructure):
smbios_structure_type = 28
def __init__(self, u, sm):
super(TemperatureProbe, self).__init__(u, sm)
u = self.u
try:
if self.length > 0x4:
self.add_field('description', u.unpack_one("B"), self.fmtstr)
if self.length > 0x5:
self.add_field('location_and_status', u.unpack_one("B"))
_status = {
0b001: 'Other',
0b010: 'Unknown',
0b011: 'OK',
0b100: 'Non-critical',
0b101: 'Critical',
0b110: 'Non-recoverable'
}
_location = {
0b00001: 'Other',
0b00010: 'Unknown',
0b00011: 'Processor',
0b00100: 'Disk',
0b00101: 'Peripheral Bay',
0b00110: 'System Management Module',
0b00111: 'Motherboard',
0b01000: 'Memory Module',
0b01001: 'Processor Module',
0b01010: 'Power Unit',
0b01011: 'Add-in Card',
0b01100: 'Front Panel Board',
0b01101: 'Back Panel Board',
0b01110: 'Power System Board',
0b01111: 'Drive Back Plane'
}
self.add_field('status', bitfields.getbits(self.location_and_status, 7, 5), unpack.format_table("location_and_status[7:5]={}", _status))
self.add_field('location', bitfields.getbits(self.location_and_status, 4, 0), unpack.format_table("location_and_status[4:0]={}", _location))
if self.length > 0x6:
self.add_field('maximum_value', u.unpack_one("<H"))
if self.length > 0x8:
self.add_field('minimum_value', u.unpack_one("<H"))
if self.length > 0xA:
self.add_field('resolution', u.unpack_one("<H"))
if self.length > 0xC:
self.add_field('tolerance', u.unpack_one("<H"))
if self.length > 0xE:
self.add_field('accuracy', u.unpack_one("<H"))
if self.length > 0x10:
self.add_field('OEM_defined', u.unpack_one("<I"))
if self.length > 0x14:
self.add_field('nominal_value', u.unpack_one("<H"))
except:
self.decodeFailure = True
print "Error parsing TemperatureProbe"
import traceback
traceback.print_exc()
self.fini()
class ElectricalCurrentProbe(SmbiosBaseStructure):
smbios_structure_type = 29
def __init__(self, u, sm):
super(ElectricalCurrentProbe, self).__init__(u, sm)
u = self.u
try:
if self.length > 0x4:
self.add_field('description', u.unpack_one("B"), self.fmtstr)
if self.length > 0x5:
self.add_field('location_and_status', u.unpack_one("B"))
_status = {
0b001: 'Other',
0b010: 'Unknown',
0b011: 'OK',
0b100: 'Non-critical',
0b101: 'Critical',
0b110: 'Non-recoverable'
}
_location = {
0b00001: 'Other',
0b00010: 'Unknown',
0b00011: 'Processor',
0b00100: 'Disk',
0b00101: 'Peripheral Bay',
0b00110: 'System Management Module',
0b00111: 'Motherboard',
0b01000: 'Memory Module',
0b01001: 'Processor Module',
0b01010: 'Power Unit',
0b01011: 'Add-in Card',
0b01100: 'Front Panel Board',
0b01101: 'Back Panel Board',
0b01110: 'Power System Board',
0b01111: 'Drive Back Plane'
}
self.add_field('status', bitfields.getbits(self.location_and_status, 7, 5), unpack.format_table("location_and_status[7:5]={}", _status))
self.add_field('location', bitfields.getbits(self.location_and_status, 4, 0), unpack.format_table("location_and_status[4:0]={}", _location))
if self.length > 0x6:
self.add_field('maximum_value', u.unpack_one("<H"))
if self.length > 0x8:
self.add_field('minimum_value', u.unpack_one("<H"))
if self.length > 0xA:
self.add_field('resolution', u.unpack_one("<H"))
if self.length > 0xC:
self.add_field('tolerance', u.unpack_one("<H"))
if self.length > 0xE:
self.add_field('accuracy', u.unpack_one("<H"))
if self.length > 0x10:
self.add_field('OEM_defined', u.unpack_one("<I"))
if self.length > 0x14:
self.add_field('nominal_value', u.unpack_one("<H"))
except:
self.decodeFailure = True
print "Error parsing ElectricalCurrentProbe"
import traceback
traceback.print_exc()
self.fini()
class OutOfBandRemoteAccess(SmbiosBaseStructure):
smbios_structure_type = 30
def __init__(self, u, sm):
super(OutOfBandRemoteAccess, self).__init__(u, sm)
u = self.u
try:
if self.length > 0x4:
self.add_field('manufacturer_name', u.unpack_one("B"), self.fmtstr)
if self.length > 0x5:
self.add_field('connections', u.unpack_one("B"))
self.add_field('outbound_connection_enabled', bool(bitfields.getbits(self.connections, 1)), "connections[1]={}")
self.add_field('inbound_connection_enabled', bool(bitfields.getbits(self.connections, 0)), "connections[0]={}")
except:
self.decodeFailure = True
print "Error parsing OutOfBandRemoteAccess"
import traceback
traceback.print_exc()
self.fini()
class BootIntegrityServicesEntryPoint(SmbiosBaseStructure):
smbios_structure_type = 31
class SystemBootInformation(SmbiosBaseStructure):
smbios_structure_type = 32
def __init__(self, u, sm):
super(SystemBootInformation, self).__init__(u, sm)
u = self.u
try:
if self.length > 0xA:
u.skip(6)
_boot_status = {
0: 'No errors detected',
1: 'No bootable media',
2: '"normal" operating system failed to load',
3: 'Firmware-detected hardware failure, including "unknown" failure types',
4: 'Operating system-detected hardware failure',
5: 'User-requested boot, usually through a keystroke',
6: 'System security violation',
7: 'Previously-requested image',
8: 'System watchdog timer expired, causing the system to reboot',
xrange(9,127): 'Reserved for future assignment',
xrange(128, 191): 'Vendor/OEM-specific implementations',
xrange(192, 255): 'Product-specific implementations'
}
self.add_field('boot_status', u.unpack_one("B"), unpack.format_table("{}", _boot_status))
except:
self.decodeFailure = True
print "Error parsing SystemBootInformation"
import traceback
traceback.print_exc()
self.fini()
class MemoryErrorInfo64Bit(SmbiosBaseStructure):
smbios_structure_type = 33
def __init__(self, u, sm):
super(MemoryErrorInfo64Bit, self).__init__(u, sm)
u = self.u
try:
if self.length > 0x4:
_error_types = {
0x01: 'Other',
0x02: 'Unknown',
0x03: 'OK',
0x04: 'Bad read',
0x05: 'Parity error',
0x06: 'Single-bit error',
0x07: 'Double-bit error',
0x08: 'Multi-bit error',
0x09: 'Nibble error',
0x0A: 'Checksum error',
0x0B: 'CRC error',
0x0C: 'Corrected single-bit error',
0x0D: 'Corrected error',
0x0E: 'Uncorrectable error'
}
self.add_field('error_type', u.unpack_one("B"), unpack.format_table("{}", _error_types))
if self.length > 0x5:
_error_granularity_field = {
0x01: 'Other',
0x02: 'Unknown',
0x03: 'Device level',
0x04: 'Memory partition level'
}
self.add_field('error_granularity', u.unpack_one("B"), unpack.format_table("{}", _error_granularity_field))
if self.length > 0x6:
_error_operation_field = {
0x01: 'Other',
0x02: 'Unknown',
0x03: 'Read',
0x04: 'Write',
0x05: 'Partial write'
}
self.add_field('error_operation', u.unpack_one("B"), unpack.format_table("{}", _error_operation_field))
if self.length > 0x7:
self.add_field('vendor_syndrome', u.unpack_one("<I"))
if self.length > 0xB:
self.add_field('memory_array_error_address', u.unpack_one("<Q"))
if self.length > 0xF:
self.add_field('device_error_address', u.unpack_one("<Q"))
if self.length > 0x13:
self.add_field('error_resolution', u.unpack_one("<Q"))
except:
self.decodeFailure = True
print "Error parsing MemoryErrorInfo64Bit"
import traceback
traceback.print_exc()
self.fini()
class ManagementDevice(SmbiosBaseStructure):
smbios_structure_type = 34
def __init__(self, u, sm):
super(ManagementDevice, self).__init__(u, sm)
u = self.u
try:
if self.length > 0x4:
self.add_field('description', u.unpack_one("B"), self.fmtstr)
if self.length > 0x5:
_type = {
0x01: 'Other',
0x02: 'Unknown',
0x03: 'National Semiconductor LM75',
0x04: 'National Semiconductor LM78',
0x05: 'National Semiconductor LM79',
0x06: 'National Semiconductor LM80',
0x07: 'National Semiconductor LM81',
0x08: 'Analog Devices ADM9240',
0x09: 'Dallas Semiconductor DS1780',
0x0A: 'Maxim 1617',
0x0B: 'Genesys GL518SM',
0x0C: 'Winbond W83781D',
0x0D: 'Holtek HT82H791'
}
self.add_field('device_type', u.unpack_one("B"), unpack.format_table("{}", _type))
if self.length > 0x6:
self.add_field('address', u.unpack_one("<I"))
if self.length > 0xA:
_address_type = {
0x01: 'Other',
0x02: 'Unknown',
0x03: 'I/O Port',
0x04: 'Memory',
0x05: 'SM Bus'
}
self.add_field('address_type', u.unpack_one("B"), unpack.format_table("{}", _address_type))
except:
self.decodeFailure = True
print "Error parsing ManagementDevice"
import traceback
traceback.print_exc()
self.fini()
class ManagementDeviceComponent(SmbiosBaseStructure):
smbios_structure_type = 35
def __init__(self, u, sm):
super(ManagementDeviceComponent, self).__init__(u, sm)
u = self.u
try:
if self.length > 0x4:
self.add_field('description', u.unpack_one("B"), self.fmtstr)
if self.length > 0x5:
self.add_field('management_device_handle', u.unpack_one("<H"))
if self.length > 0x7:
self.add_field('component_handle', u.unpack_one("<H"))
if self.length > 0x9:
self.add_field('threshold_handle', u.unpack_one("<H"))
except:
self.decodeFailure = True
print "Error parsing ManagementDeviceComponent"
import traceback
traceback.print_exc()
self.fini()
class ManagementDeviceThresholdData(SmbiosBaseStructure):
smbios_structure_type = 36
def __init__(self, u, sm):
super(ManagementDeviceThresholdData, self).__init__(u, sm)
u = self.u
try:
if self.length > 0x4:
self.add_field('lower_threshold_noncritical', u.unpack_one("<H"))
if self.length > 0x6:
self.add_field('upper_threshold_noncritical', u.unpack_one("<H"))
if self.length > 0x8:
self.add_field('lower_threshold_critical', u.unpack_one("<H"))
if self.length > 0xA:
self.add_field('upper_threshold_critical', u.unpack_one("<H"))
if self.length > 0xC:
self.add_field('lower_threshold_nonrecoverable', u.unpack_one("<H"))
if self.length > 0xE:
self.add_field('upper_threshold_nonrecoverable', u.unpack_one("<H"))
except:
self.decodeFailure = True
print "Error parsing ManagementDeviceThresholdData"
import traceback
traceback.print_exc()
self.fini()
class MemoryChannel(SmbiosBaseStructure):
smbios_structure_type = 37
def __init__(self, u, sm):
super(MemoryChannel, self).__init__(u, sm)
u = self.u
try:
if self.length > 0x4:
_channel_type = {
0x01: 'Other',
0x02: 'Unknown',
0x03: 'RamBus',
0x04: 'SyncLink'
}
self.add_field('channel_type', u.unpack_one("B"), unpack.format_table("{}", _channel_type))
if self.length > 0x6:
self.add_field('max_channel_load', u.unpack_one("B"))
if self.length > 0x8:
self.add_field('memory_device_count', u.unpack_one("B"))
if self.length > 0xA:
self.add_field('memory_device_load', u.unpack_one("B"))
if self.length > 0xC:
self.add_field('memory_device_handle', u.unpack_one("<H"))
except:
self.decodeFailure = True
print "Error parsing MemoryChannel"
import traceback
traceback.print_exc()
self.fini()
class IPMIDeviceInformation(SmbiosBaseStructure):
smbios_structure_type = 38
def __init__(self, u, sm):
super(IPMIDeviceInformation, self).__init__(u, sm)
u = self.u
try:
_interface_type = {
0x00: 'Unknown',
0x01: 'KCS: Keyboard Controller Style',
0x02: 'SMIC: Server Management Interface Chip',
0x03: 'BT: Block Transfer',
xrange(0x04, 0xFF): 'Reserved'
}
self.add_field('interface_type', u.unpack_one("B"), unpack.format_table("{}", _interface_type))
self.add_field('ipmi_specification_revision', u.unpack_one("B"))
self.add_field('msd_revision', bitfields.getbits(self.ipmi_specification_revision, 7, 4), "ipmi_specification_revision[7:4]={}")
self.add_field('lsd_revision', bitfields.getbits(self.ipmi_specification_revision, 3, 0), "ipmi_specification_revision[3:0]={}")
self.add_field('i2c_slave_address', u.unpack_one("B"))
self.add_field('nv_storage_device_address', u.unpack_one("B"))
self.add_field('base_address', u.unpack_one("<Q"))
# if lsb is 1, address is in IO space. otherwise, memory-mapped
self.add_field('base_address_modifier_interrupt_info', u.unpack_one("B"))
_reg_spacing = {
0b00: 'Interface registers are on successive byte boundaries',
0b01: 'Interface registers are on 32-bit boundaries',
0b10: 'Interface registers are on 16-byte boundaries',
0b11: 'Reserved'
}
self.add_field('register_spacing', bitfields.getbits(self.base_address_modifier_interrupt_info, 7, 6), unpack.format_table("base_address_modifier_interrupt_info[7:6]={}", _reg_spacing))
self.add_field('ls_bit_for_addresses', bitfields.getbits(self.base_address_modifier_interrupt_info, 4), "base_address_modifier_interrupt_info[4]={}")
self.add_field('interrupt_info_specified', bool(bitfields.getbits(self.base_address_modifier_interrupt_info, 3)), "base_address_modifier_interrupt_info[3]={}")
_polarity = {
0: 'active low',
1: 'active high'
}
self.add_field('interrupt_polarity', bitfields.getbits(self.base_address_modifier_interrupt_info, 1), unpack.format_table("base_address_modifier_interrupt_info[1]={}", _polarity))
_interrupt_trigger = {
0: 'edge',
1: 'level'
}
self.add_field('interrupt_trigger_mode', bitfields.getbits(self.base_address_modifier_interrupt_info, 0), unpack.format_table("base_address_modifier_interrupt_info[0]={}", _interrupt_trigger))
self.add_field('interrupt_number', u.unpack_one("B"))
except:
self.decodeFailure = True
print "Error parsing IPMIDeviceInformation"
import traceback
traceback.print_exc()
self.fini()
class SystemPowerSupply(SmbiosBaseStructure):
smbios_structure_type = 39
def __init__(self, u, sm):
super(SystemPowerSupply, self).__init__(u, sm)
u = self.u
try:
if self.length > 0x4:
self.add_field('power_unit_group', u.unpack_one("B"))
if self.length > 0x5:
self.add_field('location', u.unpack_one("B"), self.fmtstr)
if self.length > 0x6:
self.add_field('device_name', u.unpack_one("B"), self.fmtstr)
if self.length > 0x7:
self.add_field('manufacturer', u.unpack_one("B"), self.fmtstr)
if self.length > 0x8:
self.add_field('serial_number', u.unpack_one("B"), self.fmtstr)
if self.length > 0x9:
self.add_field('asset_tag', u.unpack_one("B"), self.fmtstr)
if self.length > 0xA:
self.add_field('model_part_number', u.unpack_one("B"), self.fmtstr)
if self.length > 0xB:
self.add_field('revision_level', u.unpack_one("B"), self.fmtstr)
if self.length > 0xC:
self.add_field('max_power_capacity', u.unpack_one("<H"))
if self.length > 0xE:
self.add_field('power_supply_characteristics', u.unpack_one("<H"))
_dmtf_power_supply_type = {
0b001: 'Other',
0b010: 'Unknown',
0b011: 'Linear',
0b100: 'Switching',
0b101: 'Battery',
0b110: 'UPS',
0b111: 'Converter',
0b1000: 'Regulator',
xrange(0b1001, 0b1111): 'Reserved'
}
self.add_field('dmtf_power_supply_type', bitfields.getbits(self.power_supply_characteristics, 13, 10), unpack.format_table("power_supply_characteristics[13:10]={}", _dmtf_power_supply_type))
_status = {
0b001: 'Other',
0b010: 'Unknown',
0b011: 'OK',
0b100: 'Non-critical',
0b101: 'Critical; power supply has failed and has been taken off-line'
}
self.add_field('status', bitfields.getbits(self.power_supply_characteristics, 9, 7), unpack.format_table("power_supply_characteristics[9:7]={}", _status))
_dmtf_input_voltage_range_switching = {
0b001: 'Other',
0b010: 'Unknown',
0b011: 'Manual',
0b100: 'Auto-switch',
0b101: 'Wide range',
0b110: 'Not applicable',
xrange(0b0111, 0b1111): 'Reserved'
}
self.add_field('dmtf_input_voltage_range_switching', bitfields.getbits(self.power_supply_characteristics, 6, 3), unpack.format_table("power_supply_characteristics[6:3]={}", _dmtf_input_voltage_range_switching))
self.add_field('power_supply_unplugged', bool(bitfields.getbits(self.power_supply_characteristics, 2)), "power_supply_characteristics[2]={}")
self.add_field('power_supply_present', bool(bitfields.getbits(self.power_supply_characteristics, 1)), "power_supply_characteristics[1]={}")
self.add_field('power_supply_hot_replaceable', bool(bitfields.getbits(self.power_supply_characteristics, 0)), "power_supply_characteristics[0]={}")
if self.length > 0x10:
self.add_field('input_voltage_probe_handle', u.unpack_one("<H"))
if self.length > 0x12:
self.add_field('cooling_device_handle', u.unpack_one("<H"))
if self.length > 0x14:
self.add_field('input_current_probe_handle', u.unpack_one("<H"))
except:
self.decodeFailure = True
print "Error parsing SystemPowerSupply"
import traceback
traceback.print_exc()
self.fini()
class AdditionalInformation(SmbiosBaseStructure):
smbios_structure_type = 40
def __init__(self, u, sm):
super(AdditionalInformation, self).__init__(u, sm)
u = self.u
try:
if self.length > 0x4:
self.add_field('num_additional_information_entries', u.unpack_one("B"))
if self.length > 0x5:
self.add_field('additional_information_entry_length', u.unpack_one("B"))
self.add_field('referenced_handle', u.unpack_one("<H"))
self.add_field('referenced_offset', u.unpack_one("B"))
self.add_field('string', u.unpack_one("B"), self.fmtstr)
self.add_field('value', u.unpack_rest())
except:
self.decodeFailure = True
print "Error parsing AdditionalInformation"
import traceback
traceback.print_exc()
self.fini()
class OnboardDevicesExtendedInformation(SmbiosBaseStructure):
smbios_structure_type = 41
def __init__(self, u, sm):
super(OnboardDevicesExtendedInformation, self).__init__(u, sm)
u = self.u
try:
if self.length > 0x4:
self.add_field('reference_designation', u.unpack_one("B"), self.fmtstr)
if self.length > 0x5:
self.add_field('device_type', u.unpack_one("B"))
self.add_field('device_enabled', bool(bitfields.getbits(self.device_type, 7)), "device_type[7]={}")
_device_types = {
0x01: 'Other',
0x02: 'Unknown',
0x03: 'Video',
0x04: 'SCSI Controller',
0x05: 'Ethernet',
0x06: 'Token Ring',
0x07: 'Sound',
0x08: 'PATA Controller',
0x09: 'SATA Controller',
0x0A: 'SAS Controller'
}
self.add_field('type_of_device', bitfields.getbits(self.device_type, 6, 0), unpack.format_table("device_type[6:0]={}", _device_types))
if self.length > 0x6:
self.add_field('device_type_instance', u.unpack_one("B"))
if self.length > 0x7:
self.add_field('segment_group_number', u.unpack_one("<H"))
if self.length > 0x9:
self.add_field('bus_number', u.unpack_one("B"), self.fmtstr)
if self.length > 0xA:
self.add_field('device_and_function_number', u.unpack_one("B"))
self.add_field('device_number', bitfields.getbits(self.device_type, 7, 3), "device_and_function_number[7:3]={}")
self.add_field('function_number', bitfields.getbits(self.device_type, 2, 0), "device_and_function_number[2:0]={}")
except:
self.decodeFailure = True
print "Error parsing OnboardDevicesExtendedInformation"
import traceback
traceback.print_exc()
self.fini()
class ManagementControllerHostInterface(SmbiosBaseStructure):
smbios_structure_type = 42
def __init__(self, u, sm):
super(ManagementControllerHostInterface, self).__init__(u, sm)
u = self.u
try:
if self.length > 0x4:
_interface_types = {
0x00: 'Reserved',
0x01: 'Reserved',
0x02: 'KCS: Keyboard Controller Style',
0x03: '8250 UART Register Compatible',
0x04: '16450 UART Register Compatible',
0x05: '16550/16550A UART Register Compatible',
0x06: '16650/16650A UART Register Compatible',
0x07: '16750/16750A UART Register Compatible',
0x08: '16850/16850A UART Register Compatible',
0xF0: 'OEM'
}
self.add_field('interface_type', u.unpack_one("B"), unpack.format_table("{}", _interface_types))
if self.length > 0x5:
self.add_field('mc_host_interface_data', u.unpack_rest(), self.fmtstr)
except:
self.decodeFailure = True
print "Error parsing ManagementControllerHostInterface"
import traceback
traceback.print_exc()
self.fini()
class Inactive(SmbiosBaseStructure):
smbios_structure_type = 126
def __init__(self, u, sm):
super(Inactive, self).__init__(u, sm)
self.fini()
class EndOfTable(SmbiosBaseStructure):
smbios_structure_type = 127
def __init__(self, u, sm):
super(EndOfTable, self).__init__(u, sm)
self.fini()
class SmbiosStructureUnknown(SmbiosBaseStructure):
smbios_structure_type = None
def __init__(self, u, sm):
super(SmbiosStructureUnknown, self).__init__(u, sm)
self.fini()
_smbios_structures = [
BIOSInformation,
SystemInformation,
BaseboardInformation,
SystemEnclosure,
ProcessorInformation,
MemoryControllerInformation,
MemoryModuleInformation,
CacheInformation,
PortConnectorInfo,
SystemSlots,
OnBoardDevicesInformation,
OEMStrings,
SystemConfigOptions,
BIOSLanguageInformation,
GroupAssociations,
SystemEventLog,
PhysicalMemoryArray,
MemoryDevice,
MemoryErrorInfo32Bit,
MemoryArrayMappedAddress,
MemoryDeviceMappedAddress,
BuiltInPointingDevice,
PortableBattery,
SystemReset,
HardwareSecurity,
SystemPowerControls,
VoltageProbe,
CoolingDevice,
TemperatureProbe,
ElectricalCurrentProbe,
OutOfBandRemoteAccess,
BootIntegrityServicesEntryPoint,
SystemBootInformation,
MemoryErrorInfo64Bit,
ManagementDevice,
ManagementDeviceComponent,
ManagementDeviceThresholdData,
MemoryChannel,
IPMIDeviceInformation,
SystemPowerSupply,
AdditionalInformation,
OnboardDevicesExtendedInformation,
ManagementControllerHostInterface,
Inactive,
EndOfTable,
SmbiosStructureUnknown, # Must always come last
]
def log_smbios_info():
with redirect.logonly():
try:
sm = SMBIOS()
print
if sm is None:
print "No SMBIOS structures found"
return
output = {}
known_types = (0, 1)
for sm_struct in sm.structures:
if sm_struct.type in known_types:
output.setdefault(sm_struct.type, []).append(sm_struct)
if len(output) == len(known_types):
break
print "SMBIOS information:"
for key in sorted(known_types):
for s in output.get(key, ["No structure of type {} found".format(key)]):
print ttypager._wrap("{}: {}".format(key, s))
except:
print "Error parsing SMBIOS information:"
import traceback
traceback.print_exc()
def dump_raw():
try:
sm = SMBIOS()
if sm:
s = "SMBIOS -- Raw bytes and structure decode.\n\n"
s += str(sm.header) + '\n'
s += bits.dumpmem(sm._header_memory) + '\n'
s += "Raw bytes for the SMBIOS structures\n"
s += bits.dumpmem(sm._structure_memory) + '\n'
for sm_struct in sm.structures:
s += str(sm_struct) + '\n'
s += bits.dumpmem(sm_struct.raw_data)
s += "Strings:\n"
for n in range(1, len(getattr(sm_struct, "strings", [])) + 1):
s += str(sm_struct.fmtstr(n)) + '\n'
s += bits.dumpmem(sm_struct.raw_strings) + '\n'
else:
s = "No SMBIOS structures found"
ttypager.ttypager_wrap(s, indent=False)
except:
print "Error parsing SMBIOS information:"
import traceback
traceback.print_exc()
def dump():
try:
sm = SMBIOS()
if sm:
s = str(sm)
else:
s = "No SMBIOS structures found"
ttypager.ttypager_wrap(s, indent=False)
except:
print "Error parsing SMBIOS information:"
import traceback
traceback.print_exc()
def annex_a_conformance():
try:
sm = SMBIOS()
# check: 1. The table anchor string "_SM_" is present in the address range 0xF0000 to 0xFFFFF on a 16-byte bound
def table_entry_point_verification():
''' Verify table entry-point'''
if (sm.header.length < 0x1F):
print "Failure: Table entry-point - The entry-point Length must be at least 0x1F"
if sm.header.checksum != 0:
print "Failure: Table entry-point - The entry-point checksum must evaluate to 0"
if ((sm.header.major_version < 2) and (sm.header.minor_version < 4)):
print "Failure: Table entry-point - SMBIOS version must be at least 2.4"
if (sm.header.intermediate_anchor_string == '_DMI_'):
print "Failure: Table entry-point - The Intermediate Anchor String must be '_DMI_'"
if (sm.header.intermediate_checksum != 0):
print "Failure: Table entry-point - The Intermediate checksum must evaluate to 0"
#check: 3. The structure-table is traversable and conforms to the entry-point specifications:
def req_structures():
'''Checks for required structures and corresponding data'''
types_present = [sm.structures[x].smbios_structure_type for x in range(len(sm.structures))]
required = [0, 1, 4, 7, 9, 16, 17, 19, 31, 32]
for s in required:
if s not in set(types_present):
print "Failure: Type {} required but not found".format(s)
else:
if s == 0:
if types_present.count(s) > 1:
print "Failure: Type {} - One and only one structure of this type must be present.".format(s)
if sm.structure_type(s).length < 0x18:
print "Failure: Type {} - The structure Length field must be at least 0x18".format(s)
if sm.structure_type(s).version is None:
print "Failure: Type {} - BIOS Version string must be present and non-null.".format(s)
if sm.structure_type(s).release_date is None:
print "Failure: Type {} - BIOS Release Date string must be present, non-null, and include a 4-digit year".format(s)
if bitfields.getbits(sm.structure_type(s).characteristics, 3, 0) != 0 or bitfields.getbits(sm.structure_type(s).characteristics, 31, 4) == 0:
print "Failure: Type {} - BIOS Characteristics: bits 3:0 must all be 0, and at least one of bits 31:4 must be set to 1.".format(s)
elif s == 1:
if types_present.count(s) > 1:
print "Failure: Type {} - One and only one structure of this type must be present.".format(s)
if sm.structure_type(s).length < 0x1B:
print "Failure: Type {} - The structure Length field must be at least 0x1B".format(s)
if sm.structure_type(s).manufacturer == None:
print "Failure: Type {} - Manufacturer string must be present and non-null.".format(s)
if sm.structure_type(s).product_name == None:
print "Failure: Type {} - Product Name string must be present and non-null".format(s)
if sm.structure_type(s).uuid == '00000000 00000000' and sm.structure_type(s).uuid == 'FFFFFFFF FFFFFFFF':
print "Failure: Type {} - UUID field must be neither 00000000 00000000 nor FFFFFFFF FFFFFFFF.".format(s)
if sm.structure_type(s).wakeup_type == 00 and sm.structure_type(s).wakeup_type == 0x02:
print "Failure: Type {} - Wake-up Type field must be neither 00h (Reserved) nor 02h (Unknown).".format(s)
# continue for remaining required types
# check remaining conformance guidelines
table_entry_point_verification()
req_structures()
except:
print "Error checking ANNEX A conformance guidelines"
import traceback
traceback.print_exc()
Reference in New Issue View Git Blame Copy Permalink