Ins-10012 Setup Driver Initialization Failed

[Mrx Wylie]

OUIthrows one of the following errors:

1. Cause - An unexpected error occured while initializing the Installer. Action - Contact Oracle Support Services or refer logs Summary - [INS-10002] Inventory initialization failed

oraInstall_.err log shows:

2. SEVERE: [FATAL] [INS-10102] Installer initialization failed.

CAUSE: An unexpected error occured while initializing the Installer.

ACTION: Contact Oracle Support Services or refer logs

SUMMARY:

- [INS-21003] Installer has detected that an invalid inventory pointer location file was specified..

oraInstall_.err log shows:

In this Document

SymptomsChangesCauseSolutionReferences

My Oracle Support provides customers with access to over a million knowledge articles and a vibrant support community of peers and Oracle experts.

The NVM3 driver provides a way for an application to safely store and retrieve variable size objects in a page-based non-volatile memory (NVM). Objects are identified with 20-bit object identifiers denoted as keys.

The driver is designed to use pages in a sequential order to provide equal usage and wear. The driver is resilient to power loss or reset events, ensuring that objects retrieved from the driver are in a valid state. A valid object will always be the last successfully stored object. NVM3 can detect NVM defects and mark pages as unusable. NVM3 will continue to operate on good pages after defect pages are detected.

As the NVM fills up, it reaches a point where it can no longer store additional objects and a repacking operation is required to release out-of-date objects to free up NVM. Because both writing data and erasing pages takes a long time, the NVM3 driver does not trigger the process by itself unless free memory reaches a critical low level. As an alternative, the application can trigger the repacking process by calling the nvm3_repack() function. During the call, NVM3 will either move data to a new page or erase pages that can be reused. At most, the call will block for a period equal to a page erasure time or the time to write the largest size object (whatever is largest) plus a small execution overhead. Page erasure and flash write timing for the EFM32 or EFR32 parts can be found in the data sheet.

An NVM3 function that deletes or modifies a data or counter object will trigger an automatic repack operation when free memory is below the forced threshold. The check is done before the object is modified, not after.

The user can define the user threshold by entering a value in the repackHeadroom member of the nvm3_Init_t structure used by the nvm3_open() function. The repackHeadroom value defines the difference between the user and forced threshold. The forced threshold is the minimum low memory threshold defined by the page size and maximum object size and cannot be changed by the user. The default value for the repack headroom is 0, meaning that the forced and user thresholds are equal.

NVM3 includes an object location lookup cache to speed up object access, as searching through the entire NVM3 contents for an object could otherwise be slow. It is important to note that this cache only stores the location of the object and not the object data itself. To ensure that cache can hold all necessary information, it must be configured to a size equivalent to or larger than the number of objects stored in NVM including those deleted as long as they are not discarded by the repack function. If the cache is available, the driver will first look in the cache to find the position of the object in NVM. If the object position is not found in the cache, the object position will be found by searching the NVM. The search will start at the last stored object and search all the way to the oldest object. If the object is found, the cache is updated accordingly.

The application must allocate and support data for the cache. See the nvm3_open function for more details. The size of each cache element is one uint32_t and one pointer giving a total of 8 bytes (2 words) pr. entry for EFM32 and EFR32 devices.

The NVM3 library is using global variables to store intermediate data during open, read, write, increment, and delete calls. Because the actual memory configuration is not defined at the time the NVM3 library is built, but rather at the time the user application is built, the size of data structures must be determined by the application configuration. Also, the application must set the value of the nvm3_maxFragmentCount at run-time before any NVM3 functions are called.

NVM3 library function calls are nested several levels deep. The stack usage has been measured on some EFM32 and EFR32 targets with library builds for IAR and armgcc. The maximum stack usage measured was 420 bytes for IAR and 472 bytes for ARM GCC builds. The unit test used to validate the stack usage has a 10% margin and is using a stack limit at 462 bytes for IAR and 520 for ARM GCC. Please note that the actual stack usage is a little different on the Cortex M0 Plus, M3, M4 and M33 versions of the library.

This section contains brief descriptions of NVM3 functions. For more information about parameters and return values see the Function Documentation section. Most functions return an Ecode_t that has the value ECODE_NVM3_OK on success or see nvm3.h for other values.

nvm3_getObjectInfo() , nvm3_enumObjects() , nvm3_deleteObject() and nvm3_countObjects()

These functions work on all objects. nvm3_enumObjects() gets a list of keys to valid objects in the NVM. The search can also be constrained by the function parameters. nvm3_countObjects() can be useful at startup to distinguish between a first startup without any valid objects present and later reboots with valid objects persistently stored in NVM.

The minimum required NVM size is dependent on both the NVM page size and the NVM3_MAX_OBJECT_SIZE value. For a device with 2 kB page size and some typical values for NVM3_MAX_OBJECT_SIZE, the following is the minimum required number of pages:

NVM3_DEFINE_SECTION_STATIC_DATA() and NVM3_DEFINE_SECTION_INIT_DATA() macros are provided to support the creation of the NVM area and initialization data. A linker section called 'name'_section is defined by NVM3_DEFINE_SECTION_STATIC_DATA() . The NVM area is placed within the linker section. The application linker script must place the section according to the requirements above. An error is returned by nvm3_open() on alignment or size violation.

NVM3 has been designed to detect page erase and write errors during normal operation and mark failing pages as BAD. If a write operation fails, all objects that have been written to the page prior to the write error are copied to the next free page before the page is marked as BAD and the write operation resumes. If the recover operation is successful, the operation is regarded as complete and the function will return ECODE_NVM3_OK status.

The behavior and return values for most functions, such as nvm3_readData , nvm3_writeData , and so on should be self explanatory, while the nvm3_open is slightly different. nvm3_open will always try to recover from the previous state and continue without an error, if possible. In other words, if a valid NVM3 instance is established, nvm3_open will recover from brown outs and power cycles at any time in any operation and bring the system to a valid state where all pages and objects are in a known state and return success whenever possible. From this state, normal operation can resume. If nvm3_open returns an error, it's an indication of either a design or coding error, or that many of the NVM pages have been marked as BAD leaving insufficient space in the NVM to progress. Operation may not resume if nvm3_open returns an error.

NVM3 has support for writing and reading objects in internal i.e., memory mapped Flash memory through the nvm3_hal_flash.c "driver". nvm3_hal_flash.c is using EMLIB functions to write and erase data, while using regular memory functions to read data from Flash.

Basic storage is defined as the size of on instance of all objects including any overhead stored with the data. For NVM3 the maximum amount of data you can store is dependent on the number of flash pages used for storage and the max object size used for NVM3. The following table shows the maximum allowed basic storage for a varying number of 2 kB or 8 kB flash pages ,and the minimum (208 bytes), default (254 bytes), high (1900 bytes) and maximum (4096 bytes) max object size. Note that this is a theoretical limit and if the basic storage is at this limit, no space is left for wear-levelling and page erases will be forced for every object write. The NVM3 instance should therefore be configured with enough flash pages to put the maximum allowed basic storage significantly higher than the actual basic storage.

Several NVM3 instances can be created on a device and live independently of each other, but to save memory it is usually desirable to use only one NVM3 instance as each instance adds some overhead. For this reason a default instance exists that is used by all Silicon Labs wireless stacks. The API to initialize the default instance and the handles to use with the regular NVM3 API is described in NVM3 Default Instance .

Simplicity Commander is a single, all-purpose tool to be used in a production environment. It is invoked using a simple CLI (Command Line Interface) that is also scriptable. Simplicity Commander supports reading out the NVM3 data area from a device and parsing the NVM3 data to extract stored values. This can be useful in a debugging scenario where you may need to find out the stored state of an application that has been running for some time.

The primary factor when doing updates is that data must be written to flash. Writing to flash is relatively slow, and timing information for the particular device is available in the data sheet and can be used to calculate the approximately minimum execution time. Note that NVM3 will in addition to the user data write object headers and the software will of course add some overhead. The relative overhead will be larger for smaller compared to larger objects.

3a8082e126