/*
* Execute an extrinsic method
*/
wbem::framework::UINT32 wbem::pmem_config::PersistentMemoryCapabilitiesFactory::executeMethod(
wbem::framework::UINT32 &wbemRc,
const std::string method,
wbem::framework::ObjectPath &object,
wbem::framework::attributes_t &inParms,
wbem::framework::attributes_t &outParms)
{
framework::UINT32 httpRc = framework::MOF_ERR_SUCCESS;
wbemRc = framework::MOF_ERR_SUCCESS;
struct pool *pPool = NULL;
COMMON_LOG_ENTRY_PARAMS("methodName: %s, number of in params: %d", method.c_str(), (int)(inParms.size()));
try
{
if (method == PMCAP_GETBLOCKSIZES)
{
// get the supported block sizes for this pool
wbem::framework::UINT64_LIST blockSizes;
pPool = getPool(object);
// if pool is block capable, then retrieve supported block sizes, else empty
if (pPool->type == POOL_TYPE_PERSISTENT)
{
// get system supported block sizes
getSupportedBlockSizes(blockSizes);
}
// return in outParams
outParms[PMCAP_BLOCKSIZES_PARAMNAME] = framework::Attribute(blockSizes, false);
}
else
{
httpRc = framework::CIM_ERR_METHOD_NOT_AVAILABLE;
}
}
catch (framework::ExceptionBadParameter &)
{
wbemRc = PMCAP_ERR_INVALID_PARAMETER;
}
catch(exception::NvmExceptionLibError &e)
{
wbemRc = getReturnCodeFromLibException(e);
}
catch(framework::Exception &)
{
wbemRc = PMCAP_ERR_UNKNOWN;
}
if (pPool)
{
delete pPool;
}
COMMON_LOG_EXIT_RETURN("httpRc: %u, wbemRc: %u", httpRc, wbemRc);
return httpRc;
}
/*
* entry point for CIMOM to execute an extrinsic method
*/
wbem::framework::UINT32 wbem::software::NVDIMMSoftwareInstallationServiceFactory::executeMethod(
wbem::framework::UINT32& wbemRc, const std::string method,
wbem::framework::ObjectPath& object,
wbem::framework::attributes_t& inParms,
wbem::framework::attributes_t& outParms)
{
LogEnterExit logging(__FUNCTION__, __FILE__, __LINE__);
wbem::framework::UINT32 httpRc = framework::MOF_ERR_SUCCESS;
wbemRc = framework::MOF_ERR_SUCCESS;
// valid InstallOptions for InstallFromURI
const NVM_UINT16 DEFER = 2;
const NVM_UINT16 FORCE = 3;
const NVM_UINT16 REBOOT = 7;
const NVM_UINT16 EXAMINE = 32768;
if (method == NVDIMMSOFTWAREINSTALLATIONSERVICE_INSTALLFROMURI)
{
/*
* uint32 InstallFromURI(CIM_ConcreateJob REF Job, string URI,
* CIM_ManagedElement REF Target, uint16 InstallOptions[],
* string InstallOptionsValues[])
*
* Returns one of:
* 0 - Job Completed with No Error
* 2 - Unspecified Error
* 4 - Failed
* 5 - Invalid Parameter
* 4097 - Unsupported Target Type
* 4099 - Downgrade/reinstall not supported
* 4100 - Not enough memory
* 4107 - URI not accessible
*
*/
std::string uri = inParms[NVDIMMSOFTWAREINSTALLATIONSERVICE_INSTALLFROMURI_PARAM_URI].stringValue();
std::string target = inParms[NVDIMMSOFTWAREINSTALLATIONSERVICE_INSTALLFROMURI_PARAM_TARGET].stringValue();
framework::UINT16_LIST installOptions = inParms[NVDIMMSOFTWAREINSTALLATIONSERVICE_INSTALLFROMURI_INSTALLOPTIONS].uint16ListValue();
// get valid install options
bool rebootOption =
std::find(installOptions.begin(), installOptions.end(), REBOOT) != installOptions.end();
bool deferOption =
std::find(installOptions.begin(), installOptions.end(), DEFER) != installOptions.end();
bool forceOption =
std::find(installOptions.begin(), installOptions.end(), FORCE) != installOptions.end();
bool examineOption =
std::find(installOptions.begin(), installOptions.end(), EXAMINE) != installOptions.end();
// count invalid install options
int invalidOptions = 0;
for (size_t i = 0; i < installOptions.size(); i++)
{
if (!(installOptions[i] == DEFER ||
installOptions[i] == REBOOT ||
installOptions[i] == FORCE ||
installOptions[i] == EXAMINE))
{
invalidOptions++;
}
}
try
{
COMMON_PATH absPath;
if (uri.empty())
{
httpRc = framework::CIM_ERR_INVALID_PARAMETER;
COMMON_LOG_ERROR("URI parameter was missing");
}
else if (target.empty())
{
httpRc = framework::CIM_ERR_INVALID_PARAMETER;
COMMON_LOG_ERROR("Target parameter was missing");
}
else if (get_absolute_path(uri.c_str(), uri.length() + 1, absPath) != COMMON_SUCCESS)
{
httpRc = framework::CIM_ERR_INVALID_PARAMETER;
COMMON_LOG_ERROR("URI parameter is not valid");
}
else if (invalidOptions > 0)
{
httpRc = framework::CIM_ERR_INVALID_PARAMETER;
COMMON_LOG_ERROR_F("Only %d, %d, %d and/or %d are valid InstallOptions",
DEFER, REBOOT, FORCE, EXAMINE);
}
else if (rebootOption && deferOption)
{
httpRc = framework::CIM_ERR_INVALID_PARAMETER;
COMMON_LOG_ERROR_F("%d and %d cannot be used together as InstallOptions",
DEFER, REBOOT);
}
else
{
framework::ObjectPathBuilder targetBuilder(target);
framework::ObjectPath targetObject;
targetBuilder.Build(&targetObject);
if (targetObject.getClass() == NVDIMMCOLLECTION_CREATIONCLASSNAME)
{
// all devices on system
if (examineOption)
{
std::string version;
framework::return_codes rc = examineFwImage(absPath, version);
if (rc == framework::REQUIRES_FORCE)
{
wbemRc = SWINSTALLSERVICE_ERR_DOWNGRADE_NOT_SUPPORTED;
}
else if (rc != framework::SUCCESS)
{
wbemRc = SWINSTALLSERVICE_ERR_NOT_APPLICABLE_TO_TARGET;
}
}
else
{
installFromPath(absPath, rebootOption, forceOption);
}
}
else if (targetObject.getClass() == physical_asset::NVDIMM_CREATIONCLASSNAME)
{
// single device
if (examineOption)
{
std::string version;
framework::return_codes rc = examineFwImage(
targetObject.getKeyValue(TAG_KEY).stringValue(),
absPath, version);
if (rc == framework::REQUIRES_FORCE)
{
wbemRc = SWINSTALLSERVICE_ERR_DOWNGRADE_NOT_SUPPORTED;
}
else if (rc != framework::SUCCESS)
{
wbemRc = SWINSTALLSERVICE_ERR_NOT_APPLICABLE_TO_TARGET;
}
}
else
{
installFromPath(targetObject.getKeyValue(TAG_KEY).stringValue(),
absPath, rebootOption, forceOption);
}
}
else
{
httpRc = framework::CIM_ERR_INVALID_PARAMETER;
}
}
}
catch (wbem::framework::ExceptionBadParameter &)
{
wbemRc = SWINSTALLSERVICE_ERR_INVALID_PARAMETER;
}
catch (wbem::exception::NvmExceptionLibError &e)
{
wbemRc = getReturnCodeFromLibException(e);
}
catch (wbem::framework::ExceptionNoMemory &)
{
wbemRc = SWINSTALLSERVICE_ERR_NOT_ENOUGH_MEMORY;
}
catch (wbem::framework::ExceptionNotSupported &)
{
wbemRc = SWINSTALLSERVICE_ERR_FAILED;
}
catch (wbem::framework::Exception &)
{
wbemRc = SWINSTALLSERVICE_ERR_FAILED;
}
}
else
{
httpRc = framework::CIM_ERR_METHOD_NOT_AVAILABLE;
}
return httpRc;
}
wbem::framework::UINT32 wbem::erasure::ErasureServiceFactory::executeMethod(
wbem::framework::UINT32 &wbemRc,
const std::string method,
wbem::framework::ObjectPath &object,
wbem::framework::attributes_t &inParms,
wbem::framework::attributes_t &outParms)
{
LogEnterExit logging(__FUNCTION__, __FILE__, __LINE__);
framework::UINT32 httpRc = framework::MOF_ERR_SUCCESS;
wbemRc = framework::MOF_ERR_SUCCESS;
if (method == ERASURESERVICE_ERASEDEVICE)
{
// uint32 EraseDevice(CIM_Job REF Job, CIM_ManagedElement REF Element,
// string ErasureMethod, string Password)
// get parameters from inParms
std::string elementObjectString = inParms[ERASURESERVICE_ERASEDEVICE_ELEMENT].stringValue();
std::string erasureMethod = inParms[ERASURESERVICE_ERASEDEVICE_ERASUREMETHOD].stringValue();
std::string password = inParms[ERASURESERVICE_ERASEDEVICE_PASSWORD].stringValue();
enum eraseType eraseType = getEraseType(erasureMethod);
if (elementObjectString.empty())
{
COMMON_LOG_ERROR_F("%s is required.", ERASURESERVICE_ERASEDEVICE_ELEMENT.c_str());
httpRc = framework::CIM_ERR_INVALID_PARAMETER;
}
else if (erasureMethod.empty())
{
COMMON_LOG_ERROR_F("%s is required.", ERASURESERVICE_ERASEDEVICE_ERASUREMETHOD.c_str());
httpRc = framework::CIM_ERR_INVALID_PARAMETER;
}
else if (eraseType == ERASETYPE_UNKNOWN)
{
COMMON_LOG_ERROR_F("Erasure Method %s is not supported", erasureMethod.c_str());
httpRc = framework::CIM_ERR_INVALID_PARAMETER;
}
// Note: Password will get checked by eraseDevice
else
{
// Build the object path from the attribute
framework::ObjectPathBuilder builder(elementObjectString);
framework::ObjectPath elementObject;
builder.Build(&elementObject);
try
{
if (elementObject.getClass() == physical_asset::NVDIMM_CREATIONCLASSNAME)
{
std::string deviceUidStr = elementObject.getKeyValue(TAG_KEY).stringValue();
if (deviceUidStr.length() != NVM_MAX_UID_LEN - 1)
{
throw framework::ExceptionBadParameter("Tag");
}
NVM_UID deviceUid;
uid_copy(deviceUidStr.c_str(), deviceUid);
eraseDevice(deviceUidStr, password);
}
else if (elementObject.getClass() == software::NVDIMMCOLLECTION_CREATIONCLASSNAME)
{
eraseDevice(password);
}
}
catch (wbem::exception::NvmExceptionLibError &e)
{
wbemRc = getReturnCodeFromLibException(e);
}
catch (wbem::framework::ExceptionBadParameter &)
{
httpRc = framework::CIM_ERR_INVALID_PARAMETER;
}
}
}
else if (method == ERASURESERVICE_ERASE)
{
// specific "Erase()" return code for "Not Supported"
// don't use httpRc here because it's a valid method,
// just not supported by our implementation
wbemRc = ERASURESERVICE_ERR_NOT_SUPPORTED;
}
else
{
// all others are unsupported, including "Erase"
httpRc = framework::CIM_ERR_METHOD_NOT_AVAILABLE;
}
return httpRc;
}
