View source for PDGuide - The Desktop Management Interface (DMI)

{{PDGuide}}

{{IBM-Reprint}}

This chapter provides background about the DMI, information about the relationship between DMI and VPD (vital product data) and coding examples. 

==DMI Overview==
The Desktop Management Interface (DMI) provides the means for software and hardware components to define VPD information. DMI also provides a standard function set that management applications can use to access that information.

The DMI consists of four elements:
* Format for describing information
* Format for data transfer
* Mechanism for data transfer
* Set of services for facilitating communication 

You define component descriptions in a language that is called the Management Information Format (MIF). Each component has a MIF file that describes the manageable characteristics of the component.

Component providers use the Component Interface (CI) to describe how to access management information and enable a component to be managed.

Applications use the Management Interface (MI) to manage components.

The CI and MI are data interfaces, as opposed to procedural interfaces.

The Service Layer (SL) is an active, resident code that runs on the system. The SL mediates between the MI and the CI and performs services on behalf of each.

The DMI is a local interface that is used within a single system. DMI does not replace existing network management protocols. DMI provides a consistent method for providing instrumentation to those protocols. The Service Layer is the broker of local instrumentation.

DMI provides the following:

* Independence of a specific computer, operating system, or management protocol
* An easily adopted interface for application developers
* Does not require a network
* Mapping to existing management protocols. 

The DMI does not address or specify a protocol for management over a network. 

==DMI Structure==
The DMI is a local interface for single-system use, regardless of being a standalone desktop system or part of a network. The interface consists of the following parts:

* Service Layer (SL): A local program that collects and manages product information in the MIF database. The Service Layer distributes requested information to management applications through the Management Interface (MI) and to manageable products through the Component Interface (CI).

* MIF database: The database containing the installed or attached manageable product information. MIF files contain the information, and the Service Layer manages the information.

* Management applications: Remote or local programs used to interrogate, track, control, and list the elements of a desktop system. A management application can be any of the following:
** a graphical user interface program
** a network management agent
** an installer program
** a diagnostics program
** a remote procedure call. 

* Manageable products: Components that are connected to or part of a desktop computer system or network server. Components can be part of the system code, or you can add them later. Each product has a MIF file in the MIF database that contains pertinent product management information. 

The following figure shows the DMI structure: 

DMIFunctionalDiagram 

[[Image:131_L2_DMIStructure_22.gif|DMIFunctionalDiagram ]]

==Enabling Manageable Products for DMI==
The product manufacturer needs to decide which attributes of the product are manageable. To enable a product for DMI you write a MIF file that contains descriptions of these manageable attributes. Group the attributes logically so you can write instrumentation code to provide attribute data.

Use the SystemView Agent Programmer's Guide in the Toolkit in the Problem Determination Tools folder as a reference for enabling products. This book defines requirements for products that communicate with the Service Layer. To develop such a product:
* Read the SystemView Agent Programmer's Guide to get an understanding of how components interface with the Service Layer and the supported commands.
* Define manageable attributes and specific features of your product. Look for existing MIF groups that may apply to your product.
* Begin with the ComponentID group and define MIF groups that are based on the features of your product. Use as many of the existing standard groups that apply to your product as is possible. Standard groups are available from the Desktop Management Task Force (DMTF). If needed, add proprietary groups for unique features of the product.
* Decide if the attributes are read-only, read-write, or write-only, and define MIF attributes for each group.
* Use the syntax that is defined in the SystemView Agent Programmer's Guide to create your MIF file.
* Determine whether to use run-time programs or the direct interface to provide component information to the Service Layer. Write your instrumentation code accordingly.
* Change the programs that install or delete MIF database file for your component.
* Decide which errors, exceptions, or problems are to be sent to the Service Layer as indications and the attribute information to include. Real-time, intelligent product management is made possible by using indications because the system immediately notifies management applications when a problem occurs. Add code to your product to send these indications to the Service Layer. The system uses the DmiIndicate command block to pass events to the Service Layer. See the SystemView Agent Programmer's Guide in the Problem Determination Tools folder on the system for information about the DmiIndicate command block.

===Designing MIF Files===
MIF files are the key to enabling your product to be managed by the desktop system. A well designed MIF file is important.

The DMI requires that the MIF file be an ASCII text file that contains the groups and attributes that you defined for your product. You must provide all meaningful information by using the MIF file. The text in the file must follow the defined syntax and grammar.

After you decide which product attributes are manageable, define the attributes into standard groups as much as possible in the MIF file.

The DMI Specification describes attribute characteristics and options. All attributes must have these four items defined:

; Name : The name of the attribute 
; ID : The unique, sequential attribute ID within the group containing the attribute 
; Type : The attribute's data type. The type is either a specific data type that DMI supports or an enumerated list that provides flexibility in the attribute definitions 
; Value : The actual value (to be put into the database) or a pointer to the instrumentation that gets the value 

In addition, you can optionally define description, access, and storage attributes.

The description can be one or many lines. The description text should be as clear and informative as possible to provide management applications with complete information about the attribute. You need a good description at the component level and group level.

The system uses an access statement to determine whether the attribute's value is read-only, read-write, or write-only.

The storage statement provides a hint to management applications about whether to assist in optimizing storage requirements. Two options are available:

* ''common'' - you use this option to signify that the attribute value is typically limited to a small set of possibilities that you can be optimize.
* ''specific'' - you use this option to signify that the attribute value is not a good candidate for optimization because of the possibility of a large number of different values. 

You can find the MIF file requirements in the SystemView Agent Programmer's Guide in the Toolkit in the Problem Determination Tools folder. 

===MIF Attribute Storage===
The system stores product attribute information in a MIF file. The two ways to store this information are as follows:
* Hard coding the information in the MIF database.
* Keeping the information in your own storage location (for example, a database or in read-only memory (ROM)).

====Hard Coding Information into a MIF Database====
The simplest way to make product information known through DMI is by hard coding the information into the MIF database. Using this method requires no access code to be written, and DMI retrieves the product information from the DMI database.

Hard-coded information has a major limitation: the system cannot dynamically update the information yet maintain data integrity. If you set an attribute to read/write, anyone can update that value. Another restriction of hard-coded information is that you cannot add or delete rows in tables. The only way to update a read-only attribute is by deleting the old MIF file and installing a new MIF file with the updated values. 

====Storing Information in Your Own Storage Location====
Instrumentation is program code that the Service Layer starts. The code can be a run-time program that requests attribute values. The code could also be a direct interface program. The direct interface program runs on the system and is connected to the Service Layer.

Use run-time programs for products that provide transitory data or that are not associated with a device driver that is loaded in RAM. Use run-time programs for background tasks such as the system BIOS.

Use direct interface programs when the system requires persistent data for products that use device drivers or background programs.

All instrumentation code should include the header file DMIAPI.H.

Instrumentation code that the Service Layer starts must provide one value at a time. The code must be able to handle the following DMI commands that are accessed through the DmiCiInvoke call from the Service Layer:

* DmiGetAttributeCmd
* DmiSetAttributeCmd
* DmiGetRowCmd
* DmiGetFirstRowCmd
* DmiGetNextRowCmd 

Every command must call the pConfirmFunc function, including the set commands and the commands that generate errors. When you use the DmiGetRowCmd command, the Service Layer builds the DmiGetRowCnf structure prior to calling DmiCiInvoke. In addition, the GroupKeyData structures are allocated and the oGroupKeyList slot in the DmiGetRowCnf structure is filled in. Any instrumentation code you provide must change only the confirm buffer, not the DmiInvoke command buffer.

The DMI procedure library (DMIAPI) is part of the Toolkit and provides a simple method of handling these constraints. The Component Interface outline makes use of DMIAPI. If you use the outline program as the basis for your instrumentation program, you need only write the five outlined procedures. When you use the outline program, you do not need to consider any of the issues above. 

=====Dynamic Link Libraries (DLL)=====
The Component Interface outline lists five procedures that define the simplest method for you to write run-time instrumentation. When you complete the outline files, include them in the library and in your program.

To use run-time programs, use an instrument to specify the attribute value of the MIF Path block name. The block name should contain the run-time program file name or path name. (See the ''SystemView Agent Programmer's Guide'' on the system for details about using the Path block in the MIF file.) This program runs when the Service Layer needs to access the attribute values.

If the file name in the path block does not have a complete path, the Service Layer uses the library path to find the DLL. 

=====Direct Interface (DI) Programs=====
Your component must register with the Service Layer before it can use the direct interface. You specify the keyword DIRECT-INTERFACE in the Path block of the MIF file. If the direct interface program is not running, the system returns an error when the Service Layer attempts to access attributes.

Direct interface components register with the Service Layer using the DmiRegisterCiCmd command. When an attribute value needs to be accessed, the Service Layer passes control to the direct interface program. A direct interface program must use the DmiUnregisterCiCmd to unregister with the Service Layer before the system unloads the program.

===Indications===
Component instrumentation sends unsolicited messages, to the Service Layer to signal some particular situation. The messages are known as ''events''. When the messages reach a management application, they are known as ''indications''. The indication ID identifies indications. The IDs start at the number 1. Events are often a sign of a catastrophic occurrence or other activity that the system should know about immediately. The event identification is specific to a given component and appears as an unsolicited "get." You specify event structures as groups in the component's MIF file.

In DMI, all commands are specified by using data blocks. Component instrumentation uses the function call DmiIndicate() to send the indication block and any following blocks to the Service Layer for processing. The C language prototype call is as follows:
 unsigned long  DmiIndicate(PTR command)
where <tt>command</tt> is the complete command block. The system returns a 32-bit status value to indicate success or failure.

The Service Layer immediately returns control to the component instrumentation while it processes the indication. The component instrumentation is free to issue additional indications, but it cannot reuse the original indication block buffer until the Service Layer processing is complete. Simultaneous indications from a component instrumentation must use different indication blocks. When the Service Layer has completed processing the indication, it calls the function pResponseFunc() identified in the original indication block. At that point, the component instrumentation can reuse the block.

===Installing MIF Files===
When you install your product on a system, the installation process is responsible for putting the component MIF file into the existing MIF database. If the Service Layer is not running, the system stores the component MIF file in the MIF subdirectory.

Install programs use the DmiCiInstallCmd function to install the MIF file in the MIF database.

To accommodate DMI, your installation process must provide an ASCII text MIF file. When you create the MIF file, follow the format that is found in the ''SystemView Agent Programmer's Guide'' on the system.

If the Service Layer is not running when you install the MIF, you can copy the MIF file to the <boot-drive>OS2\SYSTEM\RAS\MIFS directory. The next time the system starts the DMI Service Layer, the system installs the MIF file in the MIF database. Then system copies the file to the <boot-drive>OS2\SYSTEM\RAS\BACKUP directory, and deletes the file from the MIFS directory.

===Removing MIF Files===
To produce a complete DMI-enabled component, you include an uninstall program as well as an install program.

Uninstall programs use the DmiCiUninstallCmd function to remove the MIF file from the MIF database.

===Accessing DMI Information===
Management applications use the DMI Get, Set, and List commands to request information about manageable products on a local system. Each management application that manages system components must register with the Service Layer to issue commands and to receive notifications of indications.

To register with the Service Layer, an application uses the DmiRegisterMgmtCmd command. To unregister, applications use the DmiUnregisterMgmtCmd command.

===Component Information===
A DMI component is a hardware or software product that is installed in or attached to a computer system. The system stores information about the component in a MIF file. Use the following List commands to view the information in the MIF database:
* DmiListComponentCmd
* DmiListFirstComponentCmd
* DmiListNextComponentCmd
* DmiListComponentDescCmd

===Group Information===
DMI organizes attributes into groups that are related to components. DMI requires some groups for all products while requiring other groups for only certain products, such as printers. Other groups may be proprietary and relate only to a specific product. You can view the information that is defined in the MIF database by using the following List commands:
* DmiListGroupCmd
* DmiListFirstGroupCmd
* DmiListNextGroupCmd
* DmiListGroupDescCmd

===Attribute Information===
An attribute can describe a single characteristic, a component, or a product. Attributes are key parts of a component MIF file. Attributes for groups vary according to the type of product. To view the information that is defined in the MIF database, use the following List commands:
* DmiListAttributeCmd
* DmiListFirstAttributeCmd
* DmiListNextAttributeCmd
* DmiListAttributeDescCmd 
Management applications must provide code to deal appropriately with the status codes that the Service Layer returns. The following table lists the error codes that the Service Layer returns. The table contains the return code, the #define used in the VPD, and a list of probable causes for the return code. The list of probable causes is in sequence from most likely to occur to least likely to occur.
<pre>
  ┌──────────────────────────────────────────────────────────────────────────────┐
  │ Table 1. DMI Return Code Table                                               │ 
  ├─────────────────────────┬────────────────────────────────────────────────────┤
  │ RETURN CODE             │ #define DESCRIPTION                                │
  ├─────────────────────────┴────────────────────────────────────────────────────┤
  │                           NON-ERROR CONDITION CODES                          │
  ├─────────────────────────┬────────────────────────────────────────────────────┤
  │ 0x00000000              │ SLERR_NO_ERROR                                     │ 
  │                         │                                                    │
  │                         │ o   Good return code; no errors found              │
  ├─────────────────────────┼────────────────────────────────────────────────────┤
  │ 0x00000001              │ SLERR_NO_ERROR_MORE_DATA                           │ 
  │                         │                                                    │
  │                         │ o   Good return code; no errors found, but more    │
  │                         │     data is available                              │
  ├─────────────────────────┴────────────────────────────────────────────────────┤
  │                                DATABASE ERRORS                               │ 
  ├─────────────────────────┬────────────────────────────────────────────────────┤
  │ 0x00000100              │ DBERR_ATTRIBUTE_NOT_FOUND                          │
  │                         │                                                    │
  │                         │ o   An invalid attribute ID was specified on the   │ 
  │                         │     command being executed                         │ 
  │                         │                                                    │
  │                         │ o   An invalid component or group ID was specified │ 
  │                         │     on the command being executed                  │
  │                         │                                                    │
  │                         │ o   Component instrumentation has been specified,  │
  │                         │     but it is not available                        │
  ├─────────────────────────┼────────────────────────────────────────────────────┤
  │ 0x00000101              │ DBERR_VALUE_EXCEEDS_MAXSIZE                        │
  │                         │                                                    │
  │                         │ o   A string is too large (> 508 bytes)            │
  ├─────────────────────────┼────────────────────────────────────────────────────┤
  │ 0x00000102              │ DBERR_COMPONENT_NOT_FOUND                          │
  │                         │                                                    │
  │                         │ o   An invalid component ID was specified on the   │ 
  │                         │     command being executed                         │ 
  ├─────────────────────────┼────────────────────────────────────────────────────┤
  │ 0x00000103              │ DBERR_ENUM_ERROR                                   │ 
  │                         │                                                    │
  │                         │ o   Specifying a value for an enumeration that is  │
  │                         │     not defined in the component                   │ 
  ├─────────────────────────┼────────────────────────────────────────────────────┤
  │ 0x00000104              │ DBERR_GROUP_NOT_FOUND                              │
  │                         │                                                    │
  │                         │ o   An invalid group ID was specified on the       │ 
  │                         │     command being executed                         │ 
  │                         │                                                    │
  │                         │ o   An invalid component ID was specified on the   │ 
  │                         │     command being executed                         │ 
  ├─────────────────────────┼────────────────────────────────────────────────────┤
  │ 0x00000105              │ DBERR_ILLEGAL_KEYS                                 │ 
  │                         │                                                    │
  │                         │ o   Invalid keys specified                         │ 
  │                         │                                                    │
  │                         │ o   Invalid key count specified                    │
  │                         │                                                    │
  │                         │ o   An invalid component or group ID was specified │ 
  │                         │     on the command being executed                  │
  ├─────────────────────────┼────────────────────────────────────────────────────┤
  │ 0x00000106              │ DBERR_ILLEGAL_TO_SET                               │ 
  │                         │                                                    │
  │                         │ o   The attribute access is read only, so the      │
  │                         │     attribute cannot be set                        │
  ├─────────────────────────┼────────────────────────────────────────────────────┤
  │ 0x00000107              │ DBERR_OVERLAY_NAME_NOT_FOUND                       │ 
  │                         │                                                    │
  │                         │ o   Currently not in use                           │ 
  ├─────────────────────────┼────────────────────────────────────────────────────┤
  │ 0x00000108              │ DBERR_ILLEGAL_TO_GET                               │ 
  │                         │                                                    │
  │                         │ o   The attribute access is write-only, so the     │ 
  │                         │     attribute cannot be read                       │ 
  └─────────────────────────┴────────────────────────────────────────────────────┘
  ┌──────────────────────────────────────────────────────────────────────────────┐
  │ Table 1. DMI Return Code Table                                               │ 
  ├─────────────────────────┬────────────────────────────────────────────────────┤
  │ RETURN CODE             │ #define DESCRIPTION                                │
  ├─────────────────────────┼────────────────────────────────────────────────────┤
  │ 0x00000109              │ DBERR_NO_DESCRIPTION                               │ 
  │                         │                                                    │
  │                         │ o   There is no description for the requested com- │ 
  │                         │     ponent, group, or attribute                    │
  │                         │                                                    │
  │                         │ o   If a component description is being requested, │ 
  │                         │     the component ID specified on the command      │
  │                         │     could be invalid                               │ 
  │                         │                                                    │
  │                         │ o   If a group description is being requested, the │ 
  │                         │     group or component ID specified on the command │ 
  │                         │     could be invalid                               │ 
  │                         │                                                    │
  │                         │ o   If an attribute description is being           │ 
  │                         │     requested, the attribute, group, or component  │
  │                         │     ID specified on the command could be invalid   │ 
  ├─────────────────────────┼────────────────────────────────────────────────────┤
  │ 0x0000010A              │ DBERR_ROW_NOT_FOUND                                │
  │                         │                                                    │
  │                         │ o   For the keys specified, the table row cannot   │ 
  │                         │     be found                                       │ 
  │                         │                                                    │
  │                         │ o   Invalid keys specified                         │ 
  │                         │                                                    │
  │                         │ o   Invalid key count specified                    │
  │                         │                                                    │
  │                         │ o   An invalid component or group ID was specified │ 
  │                         │     on the command being executed                  │
  ├─────────────────────────┼────────────────────────────────────────────────────┤
  │ 0x0000010B              │ DBERR_DIRECT_INTERFACE_NOT_REGISTERED              │
  │                         │                                                    │
  │                         │ o   A direct interface is indicated but not regis- │ 
  │                         │     tered with the service layer                   │ 
  ├─────────────────────────┼────────────────────────────────────────────────────┤
  │ 0x0000010C              │ DBERR_DATABASE_CORRUPT                             │ 
  │                         │                                                    │
  │                         │ o   Currently not in use                           │ 
  ├─────────────────────────┼────────────────────────────────────────────────────┤
  │ 0x0000010D              │ DBERR_ATTRIBUTE_NOT_SUPPORTED                      │
  │                         │                                                    │
  │                         │ o   Attribute marked as not supported              │
  ├─────────────────────────┼────────────────────────────────────────────────────┤
  │ 0x0000010E              │ DBERR_LIMITS_EXCEEDED                              │
  │                         │                                                    │
  │                         │ o   More than the maximum number of elements       │ 
  │                         │     allowed in the database (for example, the      │
  │                         │     current limit for components is 256)           │ 
  ├─────────────────────────┴────────────────────────────────────────────────────┤
  │                             SERVICE LAYER ERRORS                             │ 
  ├─────────────────────────┬────────────────────────────────────────────────────┤
  │ 0x00000200              │ SLERR_BUFFER_FULL                                  │
  │                         │                                                    │
  │                         │ o   Response buffer is full                        │
  ├─────────────────────────┼────────────────────────────────────────────────────┤
  │ 0x00000201              │ SLERR_ILL_FORMED_COMMAND                           │ 
  │                         │                                                    │
  │                         │ o   Confirm buffer length too large                │
  │                         │                                                    │
  │                         │ o   Keys for a table (group) not in order          │
  │                         │                                                    │
  │                         │ o   listcomponent command with group keys but not  │
  │                         │     a class string                                 │ 
  │                         │                                                    │
  │                         │ o   An offset in the command points to beyond the  │
  │                         │     end of the command buffer                      │
  │                         │                                                    │
  │                         │ o   Confirm buffer length < 512                    │
  ├─────────────────────────┼────────────────────────────────────────────────────┤
  │ 0x00000202              │ SLERR_ILLEGAL_COMMAND                              │
  │                         │                                                    │
  │                         │ o   Not one of the valid DMI commands              │
  ├─────────────────────────┼────────────────────────────────────────────────────┤
  │ 0x00000203              │ SLERR_ILLEGAL_HANDLE                               │ 
  │                         │                                                    │
  │                         │ o   Invalid management handle                      │
  ├─────────────────────────┼────────────────────────────────────────────────────┤
  │ 0x00000204              │ SLERR_OUT_OF_MEMORY                                │
  │                         │                                                    │
  │                         │ o   A memory allocation failed.  Check this pos-   │ 
  │                         │     sible cause:                                   │ 
  │                         │                                                    │
  │                         │     -   A buffer length set too large              │
  └─────────────────────────┴────────────────────────────────────────────────────┘
  ┌──────────────────────────────────────────────────────────────────────────────┐
  │ Table 1. DMI Return Code Table                                               │ 
  ├─────────────────────────┬────────────────────────────────────────────────────┤
  │ RETURN CODE             │ #define DESCRIPTION                                │
  ├─────────────────────────┼────────────────────────────────────────────────────┤
  │ 0x00000205              │ SLERR_NULL_COMPLETION_FUNCTION                     │ 
  │                         │                                                    │
  │                         │ o   There was no callback function specified on    │
  │                         │     the register, and a command has been executed  │
  │                         │     that will require a callback function          │
  │                         │                                                    │
  │                         │ o   There was no callback or indication functions  │
  │                         │     specified on the register                      │
  ├─────────────────────────┼────────────────────────────────────────────────────┤
  │ 0x00000206              │ SLERR_NULL_RESPONSE_BUFFER                         │ 
  │                         │                                                    │
  │                         │ o   On a command that requires a response buffer,  │
  │                         │     one has not been specified                     │ 
  ├─────────────────────────┼────────────────────────────────────────────────────┤
  │ 0x00000207              │ SLERR_CMD_HANDLE_IN_USE                            │
  │                         │                                                    │
  │                         │ o   Currently not in use                           │ 
  ├─────────────────────────┼────────────────────────────────────────────────────┤
  │ 0x00000208              │ SLERR_ILLEGAL_DMI_LEVEL                            │
  │                         │                                                    │
  │                         │ o   The iLevelCheck field on the command is not    │
  │                         │     the same as the level of the DMI service layer │ 
  ├─────────────────────────┼────────────────────────────────────────────────────┤
  │ 0x00000209              │ SLERR_UNKNOWN_CI_REGISTRY                          │
  │                         │                                                    │
  │                         │ o   The component instrumentation handle           │ 
  │                         │     (iCiHandle) is not valid                       │ 
  ├─────────────────────────┼────────────────────────────────────────────────────┤
  │ 0x0000020A              │ SLERR_COMMAND_CANCELED                             │ 
  │                         │                                                    │
  │                         │ o   Currently not in use                           │ 
  ├─────────────────────────┼────────────────────────────────────────────────────┤
  │ 0x0000020B              │ SLERR_INSUFFICIENT_PRIVILEGES                      │
  │                         │                                                    │
  │                         │ o   Currently not in use                           │ 
  ├─────────────────────────┼────────────────────────────────────────────────────┤
  │ 0x0000020C              │ SLERR_NULL_ACCESS_FUNCTION                         │ 
  │                         │                                                    │
  │                         │ o   Entry point to the component instrumentation   │ 
  │                         │     is null                                        │
  ├─────────────────────────┼────────────────────────────────────────────────────┤
  │ 0x0000020D              │ SLERR_FILE_ERROR                                   │ 
  │                         │                                                    │
  │                         │ o   Could not delete a component from the MIF      │
  │                         │     database                                       │ 
  ├─────────────────────────┼────────────────────────────────────────────────────┤
  │ 0x0000020E              │ SLERR_EXEC_FAILURE                                 │ 
  │                         │                                                    │
  │                         │ o   Currently not in use                           │ 
  ├─────────────────────────┼────────────────────────────────────────────────────┤
  │ 0x0000020F              │ SLERR_BAD_MIF_FILE                                 │ 
  │                         │                                                    │
  │                         │ o   The MIF database cannot be opened              │
  │                         │                                                    │
  │                         │ o   There is an error in the MIF file that is      │
  │                         │     being installed                                │
  ├─────────────────────────┼────────────────────────────────────────────────────┤
  │ 0x00000210              │ SLERR_INVALID_FILE_TYPE                            │
  │                         │                                                    │
  │                         │ o   A MIF file that is being installed has an      │
  │                         │     invalid file type                              │
  ├─────────────────────────┼────────────────────────────────────────────────────┤
  │ 0x00000211              │ SLERR_SL_INACTIVE                                  │
  │                         │                                                    │
  │                         │ o   The service layer cannot be contacted and is   │ 
  │                         │     probably not running                           │ 
  ├─────────────────────────┼────────────────────────────────────────────────────┤
  │ 0x00000212              │ SLERR_UNICODE_NOT_SUPPORTED                        │
  │                         │                                                    │
  │                         │ o   Currently not in use                           │ 
  ├─────────────────────────┼────────────────────────────────────────────────────┤
  │ 0x00000213              │ SLERR_CANT_UNINSTALL_SL_COMPONENT                  │
  │                         │                                                    │
  │                         │ o   Currently not in use                           │ 
  ├─────────────────────────┼────────────────────────────────────────────────────┤
  │ 0x00000214              │ SLERR_NULL_CANCEL_FUNCTION                         │ 
  │                         │                                                    │
  │                         │ o   Entry point to the cancel function of the com- │ 
  │                         │     ponent instrumentation is null                 │ 
  └─────────────────────────┴────────────────────────────────────────────────────┘
  ┌──────────────────────────────────────────────────────────────────────────────┐
  │ Table 1. DMI Return Code Table                                               │ 
  ├─────────────────────────┬────────────────────────────────────────────────────┤
  │ RETURN CODE             │ #define DESCRIPTION                                │
  ├─────────────────────────┼────────────────────────────────────────────────────┤
  │ 0x00003000              │ SLERR_NOT_INITIALIZED                              │
  │                         │                                                    │
  │                         │ o   Service layer is not initialized and is not    │
  │                         │     running                                        │
  ├─────────────────────────┼────────────────────────────────────────────────────┤
  │ 0x00003001              │ SLERR_IPC_CREATE_ERROR                             │ 
  │                         │                                                    │
  │                         │ o   Could not communicate or establish communi-    │
  │                         │     cations with the service layer                 │ 
  │                         │                                                    │
  │                         │ o   On a synchronous invoke, could not get exclu-  │
  │                         │     sive use of the synchronous interface          │
  ├─────────────────────────┼────────────────────────────────────────────────────┤
  │ 0x00003002              │ SLERR_THREAD_CREATE_ERROR                          │
  │                         │                                                    │
  │                         │ o   A thread in the service layer cannot be        │
  │                         │     created                                        │
  ├─────────────────────────┼────────────────────────────────────────────────────┤
  │ 0x00003003              │ SLERR_QUEUE_CREATE_ERROR                           │ 
  │                         │                                                    │
  │                         │ o   Cannot create the queue for the tasker         │ 
  ├─────────────────────────┼────────────────────────────────────────────────────┤
  │ 0x00003004              │ SLERR_SL_TERMINATED                                │
  │                         │                                                    │
  │                         │ o   Currently not in use                           │ 
  ├─────────────────────────┼────────────────────────────────────────────────────┤
  │ 0x00003005              │ SLERR_CMD_EXCEPTION                                │
  │                         │                                                    │
  │                         │ o   A trap occurred in the service layer, probably │ 
  │                         │     due to an invalid command                      │
  ├─────────────────────────┼────────────────────────────────────────────────────┤
  │ 0x00003006              │ SLERR_SYNC_SETUP_ERROR                             │ 
  │                         │                                                    │
  │                         │ o   Cannot create the event semaphore used on the  │
  │                         │     synchronous dmiinvoke call                     │ 
  ├─────────────────────────┼────────────────────────────────────────────────────┤
  │ 0x00003007              │ SLERR_SL_DLL_MISMATCH                              │
  │                         │                                                    │
  │                         │ o   The versions of the Service Layer (SL) and the │ 
  │                         │     DMIAPI.DLL are incompatible                    │
  ├─────────────────────────┼────────────────────────────────────────────────────┤
  │ 0x00003008              │ SLERR_IPC_ERROR                                    │
  │                         │                                                    │
  │                         │ o   Cannot set up the shared memory with the       │ 
  │                         │     Service Layer                                  │
  └─────────────────────────┴────────────────────────────────────────────────────┘  
</pre>
The ''SystemView Agent Programmer's Guide'' on the system has details of the DmiRegisterMgmtCmd command. The Guide also describes the Get, Set, and List commands available to management applications as well as the list of status codes. 

===DMI Browser===
The DMI browser is a desktop tool for managing hardware and software products that conform to the DMI standard. You can use the browser to do the following:
* View hardware or software product information about the components, groups, and attributes
* Install product MIF files in the database
* Remove product MIF files from the database
* Dynamically register and unregister products with the DMI service layer
* View events that the service layer issues
* Display version information
You can use the DMI browser as a test tool during product development. If the browser displays error messages if it detects problems during the installation of MIF files or registration of products.

[[Category:PDGuide]]