From 46b79c42c4235e597d3a5e9ce7329f510c3858ec Mon Sep 17 00:00:00 2001 From: Peter Schiffer Date: Thu, 23 May 2013 16:55:25 +0200 Subject: Hardware: Added Baseboard (Motherboard) Provider New Providers: * LMI_BaseboardProvider * LMI_BaseboardContainerProvider Other Changes: * Removed useless providers_SRCS from CMakeLists.txt * Better, human friendly chassis name if type is not avaiable --- src/hardware/CMakeLists.txt | 11 -- src/hardware/LMI_BaseboardContainerProvider.c | 270 ++++++++++++++++++++++++++ src/hardware/LMI_BaseboardProvider.c | 222 +++++++++++++++++++++ src/hardware/LMI_ChassisProvider.c | 10 +- src/hardware/LMI_Hardware.h | 1 + src/hardware/dmidecode.c | 155 ++++++++++++++- src/hardware/dmidecode.h | 22 +++ 7 files changed, 675 insertions(+), 16 deletions(-) create mode 100644 src/hardware/LMI_BaseboardContainerProvider.c create mode 100644 src/hardware/LMI_BaseboardProvider.c (limited to 'src/hardware') diff --git a/src/hardware/CMakeLists.txt b/src/hardware/CMakeLists.txt index 68e283d..a972682 100644 --- a/src/hardware/CMakeLists.txt +++ b/src/hardware/CMakeLists.txt @@ -8,17 +8,6 @@ set(provider_SRCS lscpu.c procfs.c sysfs.c - LMI_ProcessorProvider.c - LMI_ProcessorCapabilitiesProvider.c - LMI_ProcessorElementCapabilitiesProvider.c - LMI_ProcessorCacheMemoryProvider.c - LMI_AssociatedProcessorCacheMemoryProvider.c - LMI_ProcessorChipProvider.c - LMI_ProcessorChipRealizesProvider.c - LMI_MemoryProvider.c - LMI_PhysicalMemoryProvider.c - LMI_PhysicalMemoryRealizesProvider.c - LMI_ChassisProvider.c ) konkretcmpi_generate(${MOF} diff --git a/src/hardware/LMI_BaseboardContainerProvider.c b/src/hardware/LMI_BaseboardContainerProvider.c new file mode 100644 index 0000000..8a9aca1 --- /dev/null +++ b/src/hardware/LMI_BaseboardContainerProvider.c @@ -0,0 +1,270 @@ +/* + * Copyright (C) 2013 Red Hat, Inc. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + * Authors: Peter Schiffer + */ + +#include +#include "LMI_BaseboardContainer.h" +#include "LMI_Hardware.h" +#include "globals.h" +#include "dmidecode.h" + +static const CMPIBroker* _cb; + +static void LMI_BaseboardContainerInitialize() +{ +} + +static CMPIStatus LMI_BaseboardContainerCleanup( + CMPIInstanceMI* mi, + const CMPIContext* cc, + CMPIBoolean term) +{ + CMReturn(CMPI_RC_OK); +} + +static CMPIStatus LMI_BaseboardContainerEnumInstanceNames( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop) +{ + return KDefaultEnumerateInstanceNames( + _cb, mi, cc, cr, cop); +} + +static CMPIStatus LMI_BaseboardContainerEnumInstances( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char** properties) +{ + LMI_BaseboardContainer lmi_baseboard_container; + LMI_BaseboardRef lmi_baseboard; + LMI_ChassisRef lmi_chassis; + const char *ns = KNameSpace(cop); + DmiChassis dmi_chassis; + DmiBaseboard dmi_baseboard; + + if (dmi_get_chassis(&dmi_chassis) != 0) { + goto done; + } + if (dmi_get_baseboard(&dmi_baseboard) != 0) { + goto done; + } + + LMI_ChassisRef_Init(&lmi_chassis, _cb, ns); + LMI_ChassisRef_Set_CreationClassName(&lmi_chassis, + ORGID "_" CHASSIS_CLASS_NAME); + if (strcmp(dmi_chassis.serial_number, "Not Specified") == 0) { + LMI_ChassisRef_Set_Tag(&lmi_chassis, "0"); + } else { + LMI_ChassisRef_Set_Tag(&lmi_chassis, dmi_chassis.serial_number); + } + + LMI_BaseboardRef_Init(&lmi_baseboard, _cb, ns); + LMI_BaseboardRef_Set_CreationClassName(&lmi_baseboard, + ORGID "_" BASEBOARD_CLASS_NAME); + if (strcmp(dmi_baseboard.serial_number, "Not Specified") == 0) { + LMI_BaseboardRef_Set_Tag(&lmi_baseboard, "0"); + } else { + LMI_BaseboardRef_Set_Tag(&lmi_baseboard, dmi_baseboard.serial_number); + } + + LMI_BaseboardContainer_Init(&lmi_baseboard_container, _cb, ns); + + LMI_BaseboardContainer_Set_GroupComponent(&lmi_baseboard_container, + &lmi_chassis); + LMI_BaseboardContainer_Set_PartComponent(&lmi_baseboard_container, + &lmi_baseboard); + + KReturnInstance(cr, lmi_baseboard_container); + +done: + dmi_free_chassis(&dmi_chassis); + dmi_free_baseboard(&dmi_baseboard); + + CMReturn(CMPI_RC_OK); +} + +static CMPIStatus LMI_BaseboardContainerGetInstance( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char** properties) +{ + return KDefaultGetInstance( + _cb, mi, cc, cr, cop, properties); +} + +static CMPIStatus LMI_BaseboardContainerCreateInstance( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const CMPIInstance* ci) +{ + CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); +} + +static CMPIStatus LMI_BaseboardContainerModifyInstance( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const CMPIInstance* ci, + const char**properties) +{ + CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); +} + +static CMPIStatus LMI_BaseboardContainerDeleteInstance( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop) +{ + CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); +} + +static CMPIStatus LMI_BaseboardContainerExecQuery( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char* lang, + const char* query) +{ + CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); +} + +static CMPIStatus LMI_BaseboardContainerAssociationCleanup( + CMPIAssociationMI* mi, + const CMPIContext* cc, + CMPIBoolean term) +{ + CMReturn(CMPI_RC_OK); +} + +static CMPIStatus LMI_BaseboardContainerAssociators( + CMPIAssociationMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char* assocClass, + const char* resultClass, + const char* role, + const char* resultRole, + const char** properties) +{ + return KDefaultAssociators( + _cb, + mi, + cc, + cr, + cop, + LMI_BaseboardContainer_ClassName, + assocClass, + resultClass, + role, + resultRole, + properties); +} + +static CMPIStatus LMI_BaseboardContainerAssociatorNames( + CMPIAssociationMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char* assocClass, + const char* resultClass, + const char* role, + const char* resultRole) +{ + return KDefaultAssociatorNames( + _cb, + mi, + cc, + cr, + cop, + LMI_BaseboardContainer_ClassName, + assocClass, + resultClass, + role, + resultRole); +} + +static CMPIStatus LMI_BaseboardContainerReferences( + CMPIAssociationMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char* assocClass, + const char* role, + const char** properties) +{ + return KDefaultReferences( + _cb, + mi, + cc, + cr, + cop, + LMI_BaseboardContainer_ClassName, + assocClass, + role, + properties); +} + +static CMPIStatus LMI_BaseboardContainerReferenceNames( + CMPIAssociationMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char* assocClass, + const char* role) +{ + return KDefaultReferenceNames( + _cb, + mi, + cc, + cr, + cop, + LMI_BaseboardContainer_ClassName, + assocClass, + role); +} + +CMInstanceMIStub( + LMI_BaseboardContainer, + LMI_BaseboardContainer, + _cb, + LMI_BaseboardContainerInitialize()) + +CMAssociationMIStub( + LMI_BaseboardContainer, + LMI_BaseboardContainer, + _cb, + LMI_BaseboardContainerInitialize()) + +KONKRET_REGISTRATION( + "root/cimv2", + "LMI_BaseboardContainer", + "LMI_BaseboardContainer", + "instance association") diff --git a/src/hardware/LMI_BaseboardProvider.c b/src/hardware/LMI_BaseboardProvider.c new file mode 100644 index 0000000..f3a7690 --- /dev/null +++ b/src/hardware/LMI_BaseboardProvider.c @@ -0,0 +1,222 @@ +/* + * Copyright (C) 2013 Red Hat, Inc. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + * Authors: Peter Schiffer + */ + +#include +#include "LMI_Baseboard.h" +#include "LMI_Hardware.h" +#include "globals.h" +#include "dmidecode.h" + +static const CMPIBroker* _cb = NULL; + +static void LMI_BaseboardInitialize() +{ +} + +static CMPIStatus LMI_BaseboardCleanup( + CMPIInstanceMI* mi, + const CMPIContext* cc, + CMPIBoolean term) +{ + CMReturn(CMPI_RC_OK); +} + +static CMPIStatus LMI_BaseboardEnumInstanceNames( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop) +{ + return KDefaultEnumerateInstanceNames( + _cb, mi, cc, cr, cop); +} + +static CMPIStatus LMI_BaseboardEnumInstances( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char** properties) +{ + LMI_Baseboard lmi_baseboard; + const char *ns = KNameSpace(cop); + char instance_id[INSTANCE_ID_LEN]; + DmiBaseboard dmi_baseboard; + + if (dmi_get_baseboard(&dmi_baseboard) != 0) { + goto done; + } + + LMI_Baseboard_Init(&lmi_baseboard, _cb, ns); + + LMI_Baseboard_Set_CreationClassName(&lmi_baseboard, + ORGID "_" BASEBOARD_CLASS_NAME); + LMI_Baseboard_Set_PackageType(&lmi_baseboard, + LMI_Baseboard_PackageType_Cross_Connect_Backplane); + LMI_Baseboard_Set_Name(&lmi_baseboard, BASEBOARD_CLASS_NAME); + LMI_Baseboard_Set_ElementName(&lmi_baseboard, BASEBOARD_CLASS_NAME); + LMI_Baseboard_Set_HostingBoard(&lmi_baseboard, 1); + LMI_Baseboard_Set_Caption(&lmi_baseboard, BASEBOARD_CLASS_NAME); + LMI_Baseboard_Set_Description(&lmi_baseboard, + "This object represents baseboard of the system."); + + if (strcmp(dmi_baseboard.serial_number, "Not Specified") == 0) { + LMI_Baseboard_Set_Tag(&lmi_baseboard, "0"); + LMI_Baseboard_Set_InstanceID(&lmi_baseboard, + ORGID ":" ORGID "_" BASEBOARD_CLASS_NAME ":0"); + } else { + LMI_Baseboard_Set_Tag(&lmi_baseboard, dmi_baseboard.serial_number); + snprintf(instance_id, INSTANCE_ID_LEN, + ORGID ":" ORGID "_" BASEBOARD_CLASS_NAME ":%s", + dmi_baseboard.serial_number); + LMI_Baseboard_Set_InstanceID(&lmi_baseboard, instance_id); + } + LMI_Baseboard_Set_Manufacturer(&lmi_baseboard, dmi_baseboard.manufacturer); + LMI_Baseboard_Set_Model(&lmi_baseboard, dmi_baseboard.product_name); + LMI_Baseboard_Set_SerialNumber(&lmi_baseboard, dmi_baseboard.serial_number); + LMI_Baseboard_Set_Version(&lmi_baseboard, dmi_baseboard.version); + + KReturnInstance(cr, lmi_baseboard); + +done: + dmi_free_baseboard(&dmi_baseboard); + + CMReturn(CMPI_RC_OK); +} + +static CMPIStatus LMI_BaseboardGetInstance( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char** properties) +{ + return KDefaultGetInstance( + _cb, mi, cc, cr, cop, properties); +} + +static CMPIStatus LMI_BaseboardCreateInstance( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const CMPIInstance* ci) +{ + CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); +} + +static CMPIStatus LMI_BaseboardModifyInstance( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const CMPIInstance* ci, + const char** properties) +{ + CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); +} + +static CMPIStatus LMI_BaseboardDeleteInstance( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop) +{ + CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); +} + +static CMPIStatus LMI_BaseboardExecQuery( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char* lang, + const char* query) +{ + CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); +} + +CMInstanceMIStub( + LMI_Baseboard, + LMI_Baseboard, + _cb, + LMI_BaseboardInitialize()) + +static CMPIStatus LMI_BaseboardMethodCleanup( + CMPIMethodMI* mi, + const CMPIContext* cc, + CMPIBoolean term) +{ + CMReturn(CMPI_RC_OK); +} + +static CMPIStatus LMI_BaseboardInvokeMethod( + CMPIMethodMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char* meth, + const CMPIArgs* in, + CMPIArgs* out) +{ + return LMI_Baseboard_DispatchMethod( + _cb, mi, cc, cr, cop, meth, in, out); +} + +CMMethodMIStub( + LMI_Baseboard, + LMI_Baseboard, + _cb, + LMI_BaseboardInitialize()) + +KUint32 LMI_Baseboard_IsCompatible( + const CMPIBroker* cb, + CMPIMethodMI* mi, + const CMPIContext* context, + const LMI_BaseboardRef* self, + const KRef* ElementToCheck, + CMPIStatus* status) +{ + KUint32 result = KUINT32_INIT; + + KSetStatus(status, ERR_NOT_SUPPORTED); + return result; +} + +KUint32 LMI_Baseboard_ConnectorPower( + const CMPIBroker* cb, + CMPIMethodMI* mi, + const CMPIContext* context, + const LMI_BaseboardRef* self, + const KRef* Connector, + const KBoolean* PoweredOn, + CMPIStatus* status) +{ + KUint32 result = KUINT32_INIT; + + KSetStatus(status, ERR_NOT_SUPPORTED); + return result; +} + +KONKRET_REGISTRATION( + "root/cimv2", + "LMI_Baseboard", + "LMI_Baseboard", + "instance method") diff --git a/src/hardware/LMI_ChassisProvider.c b/src/hardware/LMI_ChassisProvider.c index 93345a4..2ef7342 100644 --- a/src/hardware/LMI_ChassisProvider.c +++ b/src/hardware/LMI_ChassisProvider.c @@ -87,10 +87,16 @@ static CMPIStatus LMI_ChassisEnumInstances( dmi_chassis.serial_number); LMI_Chassis_Set_InstanceID(&lmi_chassis, instance_id); } + if (strcmp(dmi_chassis.type, "Unknown") == 0 || + strcmp(dmi_chassis.type, "Other") == 0) { + LMI_Chassis_Set_Name(&lmi_chassis, "System Chassis"); + LMI_Chassis_Set_ElementName(&lmi_chassis, "System Chassis"); + } else { + LMI_Chassis_Set_Name(&lmi_chassis, dmi_chassis.type); + LMI_Chassis_Set_ElementName(&lmi_chassis, dmi_chassis.type); + } LMI_Chassis_Set_ChassisPackageType(&lmi_chassis, get_chassis_type(dmi_chassis.type)); - LMI_Chassis_Set_Name(&lmi_chassis, dmi_chassis.type); - LMI_Chassis_Set_ElementName(&lmi_chassis, dmi_chassis.type); LMI_Chassis_Set_Manufacturer(&lmi_chassis, dmi_chassis.manufacturer); LMI_Chassis_Set_SerialNumber(&lmi_chassis, dmi_chassis.serial_number); LMI_Chassis_Set_SKU(&lmi_chassis, dmi_chassis.sku_number); diff --git a/src/hardware/LMI_Hardware.h b/src/hardware/LMI_Hardware.h index 7e721d8..0c0714c 100644 --- a/src/hardware/LMI_Hardware.h +++ b/src/hardware/LMI_Hardware.h @@ -31,5 +31,6 @@ #define MEM_CLASS_NAME "Memory" #define PHYS_MEM_CLASS_NAME "PhysicalMemory" #define CHASSIS_CLASS_NAME "Chassis" +#define BASEBOARD_CLASS_NAME "Baseboard" #endif /* LMI_HARDWARE_H_ */ diff --git a/src/hardware/dmidecode.c b/src/hardware/dmidecode.c index d27c9dc..ab3b359 100644 --- a/src/hardware/dmidecode.c +++ b/src/hardware/dmidecode.c @@ -1107,7 +1107,6 @@ void dmi_free_memory(DmiMemory *memory) * DmiChassis */ - /* * Initialize DmiChassis attributes. * @param chassis @@ -1187,6 +1186,13 @@ short dmi_get_chassis(DmiChassis *chassis) goto done; } + /* empty output from dmidecode */ + if (buffer_size < 5) { + warn("Dmidecode has no information about chassis."); + ret = -3; + goto done; + } + /* parse information about chassis */ for (i = 0; i < buffer_size; i++) { /* Serial Number */ @@ -1217,7 +1223,7 @@ short dmi_get_chassis(DmiChassis *chassis) buf = NULL; continue; } - /* SKU Number */ + /* Version */ buf = copy_string_part_after_delim(buffer[i], "Version: "); if (buf) { chassis->version = buf; @@ -1248,7 +1254,7 @@ short dmi_get_chassis(DmiChassis *chassis) /* fill in default attributes if needed */ if (check_dmi_chassis_attributes(chassis) != 0) { - ret = -3; + ret = -4; goto done; } @@ -1278,3 +1284,146 @@ void dmi_free_chassis(DmiChassis *chassis) chassis->version = NULL; } + +/****************************************************************************** + * DmiBaseboard + */ + +/* + * Initialize DmiBaseboard attributes. + * @param baseboard + */ +void init_dmi_baseboard_struct(DmiBaseboard *baseboard) +{ + baseboard->serial_number = NULL; + baseboard->manufacturer = NULL; + baseboard->product_name = NULL; + baseboard->version = NULL; +} + +/* + * Check attributes of baseboard structure and fill in defaults if needed. + * @param baseboard + * @return 0 if success, negative value otherwise + */ +short check_dmi_baseboard_attributes(DmiBaseboard *baseboard) +{ + short ret = -1; + + if (!baseboard->serial_number) { + if (!(baseboard->serial_number = strdup("Not Specified"))) { + ret = -2; + goto done; + } + } + if (!baseboard->manufacturer) { + if (!(baseboard->manufacturer = strdup(""))) { + ret = -3; + goto done; + } + } + if (!baseboard->product_name) { + if (!(baseboard->product_name = strdup(""))) { + ret = -4; + goto done; + } + } + if (!baseboard->version) { + if (!(baseboard->version = strdup(""))) { + ret = -5; + goto done; + } + } + + ret = 0; + +done: + if (ret != 0) { + warn("Failed to allocate memory."); + } + + return ret; +} + +short dmi_get_baseboard(DmiBaseboard *baseboard) +{ + short ret = -1; + unsigned i, buffer_size = 0; + char **buffer = NULL, *buf; + + init_dmi_baseboard_struct(baseboard); + + /* get dmidecode output for baseboard */ + if (run_command("dmidecode -t 2", &buffer, &buffer_size) != 0) { + ret = -2; + goto done; + } + + /* empty output from dmidecode */ + if (buffer_size < 5) { + warn("Dmidecode has no information about baseboard."); + ret = -3; + goto done; + } + + /* parse information about baseboard */ + for (i = 0; i < buffer_size; i++) { + /* Serial Number */ + buf = copy_string_part_after_delim(buffer[i], "Serial Number: "); + if (buf) { + baseboard->serial_number = buf; + buf = NULL; + continue; + } + /* Manufacturer */ + buf = copy_string_part_after_delim(buffer[i], "Manufacturer: "); + if (buf) { + baseboard->manufacturer = buf; + buf = NULL; + continue; + } + /* Product Name */ + buf = copy_string_part_after_delim(buffer[i], "Product Name: "); + if (buf) { + baseboard->product_name = buf; + buf = NULL; + continue; + } + /* Version */ + buf = copy_string_part_after_delim(buffer[i], "Version: "); + if (buf) { + baseboard->version = buf; + buf = NULL; + continue; + } + } + + /* fill in default attributes if needed */ + if (check_dmi_baseboard_attributes(baseboard) != 0) { + ret = -4; + goto done; + } + + ret = 0; + +done: + free_2d_buffer(&buffer, &buffer_size); + + if (ret != 0) { + dmi_free_baseboard(baseboard); + } + + return ret; +} + +void dmi_free_baseboard(DmiBaseboard *baseboard) +{ + free(baseboard->serial_number); + baseboard->serial_number = NULL; + free(baseboard->manufacturer); + baseboard->manufacturer = NULL; + free(baseboard->product_name); + baseboard->product_name = NULL; + free(baseboard->version); + baseboard->version = NULL; +} diff --git a/src/hardware/dmidecode.h b/src/hardware/dmidecode.h index 0fe546c..140f492 100644 --- a/src/hardware/dmidecode.h +++ b/src/hardware/dmidecode.h @@ -102,6 +102,14 @@ typedef struct _DmiChassis { unsigned power_cords; /* Number of Power Cords */ } DmiChassis; +/* Baseboard from dmidecode. */ +typedef struct _DmiBaseboard { + char *serial_number; /* Serial number */ + char *manufacturer; /* Manufacturer */ + char *product_name; /* Product Name */ + char *version; /* Version */ +} DmiBaseboard; + /* * Get array of processors according to the dmidecode program. * @param cpu array of cpus, this function will allocate necessary memory, @@ -162,5 +170,19 @@ short dmi_get_chassis(DmiChassis *chassis); */ void dmi_free_chassis(DmiChassis *chassis); +/* + * Get baseboard structure according to the dmidecode program. + * @param baseboard structure, this function will allocate + * necessary memory, but caller is responsible for freeing it + * @return 0 if success, negative value otherwise + */ +short dmi_get_baseboard(DmiBaseboard *baseboard); + +/* + * Free baseboard structure. + * @param baseboard structure + */ +void dmi_free_baseboard(DmiBaseboard *baseboard); + #endif /* DMIDECODE_H_ */ -- cgit