diff options
Diffstat (limited to 'tests/avocado/acpi-bits/bits-tests/smbios.py2')
| -rw-r--r-- | tests/avocado/acpi-bits/bits-tests/smbios.py2 | 2434 |
1 files changed, 0 insertions, 2434 deletions
diff --git a/tests/avocado/acpi-bits/bits-tests/smbios.py2 b/tests/avocado/acpi-bits/bits-tests/smbios.py2 deleted file mode 100644 index 5868a71..0000000 --- a/tests/avocado/acpi-bits/bits-tests/smbios.py2 +++ /dev/null @@ -1,2434 +0,0 @@ -# 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() |