From 2c830a0bafaa573f005246195071076dac468ccd Mon Sep 17 00:00:00 2001 From: Radek Novacek Date: Tue, 31 Jul 2012 10:56:04 +0200 Subject: Replace all Linux_ prefixes with Cura_ prefixes. --- src/fan/CMakeLists.txt | 4 +- src/fan/Cura_FanAssociatedSensorProvider.c | 240 +++++++++++++ src/fan/Cura_FanProvider.c | 393 +++++++++++++++++++++ src/fan/Cura_FanSensorProvider.c | 383 ++++++++++++++++++++ src/fan/Linux_FanAssociatedSensorProvider.c | 240 ------------- src/fan/Linux_FanProvider.c | 393 --------------------- src/fan/Linux_FanSensorProvider.c | 383 -------------------- src/fan/fan.c | 8 +- src/fan/fan.h | 8 +- src/power/CMakeLists.txt | 2 +- ...Cura_AssociatedPowerManagementServiceProvider.c | 269 ++++++++++++++ src/power/Cura_ConcreteJobProvider.c | 205 +++++++++++ src/power/Cura_ElementCapabilitiesProvider.c | 224 ++++++++++++ src/power/Cura_HostedServiceProvider.c | 229 ++++++++++++ .../Cura_PowerManagementCapabilitiesProvider.c | 162 +++++++++ src/power/Cura_PowerManagementServiceProvider.c | 268 ++++++++++++++ ...inux_AssociatedPowerManagementServiceProvider.c | 269 -------------- src/power/Linux_ConcreteJobProvider.c | 205 ----------- src/power/Linux_ElementCapabilitiesProvider.c | 224 ------------ src/power/Linux_HostedServiceProvider.c | 229 ------------ .../Linux_PowerManagementCapabilitiesProvider.c | 162 --------- src/power/Linux_PowerManagementServiceProvider.c | 268 -------------- src/power/power.c | 96 ++--- src/service/CMakeLists.txt | 2 +- src/service/Cura_ServiceProvider.c | 336 ++++++++++++++++++ src/service/Linux_ServiceProvider.c | 336 ------------------ 26 files changed, 2769 insertions(+), 2769 deletions(-) create mode 100644 src/fan/Cura_FanAssociatedSensorProvider.c create mode 100644 src/fan/Cura_FanProvider.c create mode 100644 src/fan/Cura_FanSensorProvider.c delete mode 100644 src/fan/Linux_FanAssociatedSensorProvider.c delete mode 100644 src/fan/Linux_FanProvider.c delete mode 100644 src/fan/Linux_FanSensorProvider.c create mode 100644 src/power/Cura_AssociatedPowerManagementServiceProvider.c create mode 100644 src/power/Cura_ConcreteJobProvider.c create mode 100644 src/power/Cura_ElementCapabilitiesProvider.c create mode 100644 src/power/Cura_HostedServiceProvider.c create mode 100644 src/power/Cura_PowerManagementCapabilitiesProvider.c create mode 100644 src/power/Cura_PowerManagementServiceProvider.c delete mode 100644 src/power/Linux_AssociatedPowerManagementServiceProvider.c delete mode 100644 src/power/Linux_ConcreteJobProvider.c delete mode 100644 src/power/Linux_ElementCapabilitiesProvider.c delete mode 100644 src/power/Linux_HostedServiceProvider.c delete mode 100644 src/power/Linux_PowerManagementCapabilitiesProvider.c delete mode 100644 src/power/Linux_PowerManagementServiceProvider.c create mode 100644 src/service/Cura_ServiceProvider.c delete mode 100644 src/service/Linux_ServiceProvider.c (limited to 'src') diff --git a/src/fan/CMakeLists.txt b/src/fan/CMakeLists.txt index 405c6ef..16b3115 100644 --- a/src/fan/CMakeLists.txt +++ b/src/fan/CMakeLists.txt @@ -1,11 +1,11 @@ set(PROVIDER_NAME Fan) set(LIBRARY_NAME cmpi${PROVIDER_NAME}) -set(MOF Linux_Fan.mof) +set(MOF Cura_Fan.mof) set(provider_SRCS fan.c - Linux_FanProvider.c + Cura_FanProvider.c ) konkretcmpi_generate(${MOF} diff --git a/src/fan/Cura_FanAssociatedSensorProvider.c b/src/fan/Cura_FanAssociatedSensorProvider.c new file mode 100644 index 0000000..185518a --- /dev/null +++ b/src/fan/Cura_FanAssociatedSensorProvider.c @@ -0,0 +1,240 @@ +#include +#include "Cura_FanAssociatedSensor.h" +#include "fan.h" +#include + +static const CMPIBroker* _cb; + +static void Cura_FanAssociatedSensorInitialize() +{ + init_linux_fan_module(); +} + +static CMPIStatus Cura_FanAssociatedSensorCleanup( + CMPIInstanceMI* mi, + const CMPIContext* cc, + CMPIBoolean term) +{ + CMReturn(CMPI_RC_OK); +} + +static CMPIStatus Cura_FanAssociatedSensorEnumInstanceNames( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop) +{ + return KDefaultEnumerateInstanceNames( + _cb, mi, cc, cr, cop); +} + +static CMPIStatus Cura_FanAssociatedSensorEnumInstances( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char** properties) +{ + const char *ns = KNameSpace(cop); + + struct cim_fan *sptr = NULL; + struct fanlist *lptr = NULL, *fans = NULL; + if (enum_all_fans(&fans) != 0 ) { + KReturn2(_cb, ERR_FAILED, "Could not list get fan list."); + } + + lptr = fans; + // iterate fan list + while (lptr) { + sptr = lptr->f; + Cura_FanAssociatedSensor w; + Cura_FanAssociatedSensor_Init(&w, _cb, ns); + + Cura_FanRef fan; + Cura_FanRef_Init(&fan, _cb, ns); + Cura_FanRef_Set_CreationClassName(&fan, "Cura_Fan"); + Cura_FanRef_Set_DeviceID(&fan, sptr->device_id); + Cura_FanRef_Set_SystemCreationClassName(&fan, get_system_creation_class_name()); + Cura_FanRef_Set_SystemName(&fan, get_system_name()); + + Cura_FanSensorRef fanSensor; + Cura_FanSensorRef_Init(&fanSensor, _cb, ns); + Cura_FanSensorRef_Set_CreationClassName(&fanSensor, "Cura_FanSensor"); + Cura_FanSensorRef_Set_DeviceID(&fanSensor, sptr->device_id); + Cura_FanSensorRef_Set_SystemCreationClassName(&fanSensor, get_system_creation_class_name()); + Cura_FanSensorRef_Set_SystemName(&fanSensor, get_system_name()); + + Cura_FanAssociatedSensor_Set_Antecedent(&w, &fanSensor); + Cura_FanAssociatedSensor_Set_Dependent(&w, &fan); + + KReturnInstance(cr, w); + lptr = lptr->next; + } + CMReturn(CMPI_RC_OK); +} + +static CMPIStatus Cura_FanAssociatedSensorGetInstance( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char** properties) +{ + return KDefaultGetInstance( + _cb, mi, cc, cr, cop, properties); +} + +static CMPIStatus Cura_FanAssociatedSensorCreateInstance( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const CMPIInstance* ci) +{ + CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); +} + +static CMPIStatus Cura_FanAssociatedSensorModifyInstance( + 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 Cura_FanAssociatedSensorDeleteInstance( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop) +{ + CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); +} + +static CMPIStatus Cura_FanAssociatedSensorExecQuery( + 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 Cura_FanAssociatedSensorAssociationCleanup( + CMPIAssociationMI* mi, + const CMPIContext* cc, + CMPIBoolean term) +{ + CMReturn(CMPI_RC_OK); +} + +static CMPIStatus Cura_FanAssociatedSensorAssociators( + 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, + Cura_FanAssociatedSensor_ClassName, + assocClass, + resultClass, + role, + resultRole, + properties); +} + +static CMPIStatus Cura_FanAssociatedSensorAssociatorNames( + 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, + Cura_FanAssociatedSensor_ClassName, + assocClass, + resultClass, + role, + resultRole); +} + +static CMPIStatus Cura_FanAssociatedSensorReferences( + 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, + Cura_FanAssociatedSensor_ClassName, + assocClass, + role, + properties); +} + +static CMPIStatus Cura_FanAssociatedSensorReferenceNames( + CMPIAssociationMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char* assocClass, + const char* role) +{ + return KDefaultReferenceNames( + _cb, + mi, + cc, + cr, + cop, + Cura_FanAssociatedSensor_ClassName, + assocClass, + role); +} + +CMInstanceMIStub( + Cura_FanAssociatedSensor, + Cura_FanAssociatedSensor, + _cb, + Cura_FanAssociatedSensorInitialize()) + +CMAssociationMIStub( + Cura_FanAssociatedSensor, + Cura_FanAssociatedSensor, + _cb, + Cura_FanAssociatedSensorInitialize()) + +KONKRET_REGISTRATION( + "root/cimv2", + "Cura_FanAssociatedSensor", + "Cura_FanAssociatedSensor", + "instance association") diff --git a/src/fan/Cura_FanProvider.c b/src/fan/Cura_FanProvider.c new file mode 100644 index 0000000..4538b98 --- /dev/null +++ b/src/fan/Cura_FanProvider.c @@ -0,0 +1,393 @@ +#include +#include +#include "Cura_Fan.h" +#include "globals.h" +#include "fan.h" +static const CMPIBroker* _cb = NULL; + +#include +#include +#include + +void print_backtrace(int signal) +{ + fprintf(stderr, "BackTrace\n"); + int ppid = getpid(); + int pid = fork(); + if (pid == 0) { + // Child process + char *strpid; + asprintf(&strpid, "%d", ppid); + execl("/usr/bin/gdb", "/usr/bin/gdb", "-p", strpid, NULL); + } else { + int status; + waitpid(pid, &status, 0); + system("/usr/bin/pkill -9 sfcbd"); + } +} + +static void Cura_FanInitialize() +{ + init_linux_fan_module(); + signal(SIGSEGV, print_backtrace); +} + +static CMPIStatus Cura_FanCleanup( + CMPIInstanceMI* mi, + const CMPIContext* cc, + CMPIBoolean term) +{ + CMReturn(CMPI_RC_OK); +} + +static CMPIStatus Cura_FanEnumInstanceNames( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop) +{ + return KDefaultEnumerateInstanceNames( + _cb, mi, cc, cr, cop); +} + +static CMPIStatus Cura_FanEnumInstances( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char** properties) +{ + const char *ns = KNameSpace(cop); + + char buf[200]; + struct fanlist *lptr = NULL; + struct fanlist *fans = NULL; + struct cim_fan *sptr; + + if (enum_all_fans(&fans)) { + KReturn2(_cb, ERR_FAILED, "Could not list fans."); + } + + // iterate fan list + lptr = fans; + while (lptr != NULL) { + sptr = lptr->f; + Cura_Fan w; + Cura_Fan_Init(&w, _cb, ns); + Cura_Fan_Set_CreationClassName(&w, "Cura_Fan"); + Cura_Fan_Set_SystemCreationClassName(&w, get_system_creation_class_name()); + Cura_Fan_Set_SystemName(&w, get_system_name()); + Cura_Fan_Set_DeviceID(&w, sptr->device_id); + + Cura_Fan_Set_Caption(&w, "Computer's fan"); + Cura_Fan_Set_Description(&w,"Computer's fan."); + snprintf(buf, 200, "Fan \"%s\" on chip \"%s\"", sptr->name, sptr->chip_name); + Cura_Fan_Set_ElementName(&w, buf); + + // ManagedSystemElement + Cura_Fan_Set_Name(&w, sptr->name); + Cura_Fan_Init_OperationalStatus(&w, 2); + Cura_Fan_Set_OperationalStatus(&w, 0, sptr->fault ? + Cura_Fan_OperationalStatus_Error : + Cura_Fan_OperationalStatus_OK); + if (sptr->alarm || sptr->alarm_min || sptr->alarm_max) { + Cura_Fan_Set_OperationalStatus(&w, 1, Cura_Fan_OperationalStatus_Stressed); + } + + Cura_Fan_Init_StatusDescriptions(&w, 2); + Cura_Fan_Set_StatusDescriptions(&w, 0, sptr->fault ? + "Chip indicates, that fan is in fault state." + " Possible causes are open diodes, unconnected fan etc." + " Thus the measurement for this channel should not be trusted." + : "Fan seems to be functioning correctly."); + if (sptr->alarm || sptr->alarm_min || sptr->alarm_max) { + snprintf(buf, 200, "These alarm flags are set by the fan's chip:" + " alarm=%s, min_alarm=%s, max_alarm=%s", + sptr->alarm ? "1":"0", + sptr->alarm_min ? "1":"0", + sptr->alarm_max ? "1":"0"); + Cura_Fan_Set_StatusDescriptions(&w, 1, buf); + } + + + Cura_Fan_Set_HealthState(&w, sptr->fault ? + Cura_Fan_HealthState_Major_failure : + Cura_Fan_HealthState_OK); + + Cura_Fan_Set_OperatingStatus(&w, sptr->fault ? + Cura_Fan_OperatingStatus_Stopped : + Cura_Fan_OperatingStatus_In_Service); + + Cura_Fan_Set_PrimaryStatus(&w, sptr->fault ? + Cura_Fan_PrimaryStatus_Error : + Cura_Fan_PrimaryStatus_OK); + + // EnabledLogicalElement + Cura_Fan_Init_OtherIdentifyingInfo(&w, 2); + Cura_Fan_Set_OtherIdentifyingInfo(&w, 0, sptr->chip_name); + Cura_Fan_Set_OtherIdentifyingInfo(&w, 1, sptr->sys_path); + + Cura_Fan_Init_IdentifyingDescriptions(&w, 2); + Cura_Fan_Set_IdentifyingDescriptions(&w, 0, "ChipName - name of fan's chip."); + Cura_Fan_Set_IdentifyingDescriptions(&w, 1, "SysPath - system path of fan's chip."); + + Cura_Fan_Set_ActiveCooling(&w, true); + + uint32_t i = 1; + int index = 0; + debug("accessible_features: %d", sptr->accessible_features); + Cura_Fan_Init_AccessibleFeatures(&w, 8); + while (i <= CIM_FAN_AF_FEATURE_MAX) { + if (i & sptr->accessible_features) { + Cura_Fan_Set_AccessibleFeatures(&w, index++, i); + } + i = i << 1; + } + if (sptr->accessible_features & CIM_FAN_AF_MIN_SPEED) { + Cura_Fan_Set_MinSpeed(&w, (uint64_t) sptr->min_speed); + } + if (sptr->accessible_features & CIM_FAN_AF_MAX_SPEED) { + Cura_Fan_Set_MaxSpeed(&w, (uint64_t) sptr->max_speed); + } + if (sptr->accessible_features & CIM_FAN_AF_DIV) { + Cura_Fan_Set_Divisor(&w, sptr->divisor); + } + if (sptr->accessible_features & CIM_FAN_AF_PULSES) { + Cura_Fan_Set_Pulses(&w, sptr->pulses); + } + if (sptr->accessible_features & CIM_FAN_AF_BEEP) { + Cura_Fan_Set_Beep(&w, sptr->beep); + } + if (sptr->accessible_features & CIM_FAN_AF_ALARM) { + Cura_Fan_Set_Alarm(&w, sptr->alarm); + } + if (sptr->accessible_features & CIM_FAN_AF_ALARM_MIN) { + Cura_Fan_Set_MinAlarm(&w, sptr->alarm_min); + } + if (sptr->accessible_features & CIM_FAN_AF_ALARM_MAX) { + Cura_Fan_Set_MaxAlarm(&w, sptr->alarm_max); + } + + KReturnInstance(cr, w); + lptr = lptr->next; + } + free_fanlist(fans); + KReturn(OK); +} + +static CMPIStatus Cura_FanGetInstance( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char** properties) +{ + return KDefaultGetInstance( + _cb, mi, cc, cr, cop, properties); +} + +static CMPIStatus Cura_FanCreateInstance( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const CMPIInstance* ci) +{ + CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); +} + +static CMPIStatus Cura_FanModifyInstance( + 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 Cura_FanDeleteInstance( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop) +{ + CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); +} + +static CMPIStatus Cura_FanExecQuery( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char* lang, + const char* query) +{ + CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); +} + +CMInstanceMIStub( + Cura_Fan, + Cura_Fan, + _cb, + Cura_FanInitialize()) + +static CMPIStatus Cura_FanMethodCleanup( + CMPIMethodMI* mi, + const CMPIContext* cc, + CMPIBoolean term) +{ + CMReturn(CMPI_RC_OK); +} + +static CMPIStatus Cura_FanInvokeMethod( + CMPIMethodMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char* meth, + const CMPIArgs* in, + CMPIArgs* out) +{ + return Cura_Fan_DispatchMethod( + _cb, mi, cc, cr, cop, meth, in, out); +} + +CMMethodMIStub( + Cura_Fan, + Cura_Fan, + _cb, + Cura_FanInitialize()) + +KUint32 Cura_Fan_RequestStateChange( + const CMPIBroker* cb, + CMPIMethodMI* mi, + const CMPIContext* context, + const Cura_FanRef* self, + const KUint16* RequestedState, + KRef* Job, + const KDateTime* TimeoutPeriod, + CMPIStatus* status) +{ + KUint32 result = KUINT32_INIT; + + KSetStatus(status, ERR_NOT_SUPPORTED); + return result; +} + +KUint32 Cura_Fan_SetPowerState( + const CMPIBroker* cb, + CMPIMethodMI* mi, + const CMPIContext* context, + const Cura_FanRef* self, + const KUint16* PowerState, + const KDateTime* Time, + CMPIStatus* status) +{ + KUint32 result = KUINT32_INIT; + + KSetStatus(status, ERR_NOT_SUPPORTED); + return result; +} + +KUint32 Cura_Fan_Reset( + const CMPIBroker* cb, + CMPIMethodMI* mi, + const CMPIContext* context, + const Cura_FanRef* self, + CMPIStatus* status) +{ + KUint32 result = KUINT32_INIT; + + KSetStatus(status, ERR_NOT_SUPPORTED); + return result; +} + +KUint32 Cura_Fan_EnableDevice( + const CMPIBroker* cb, + CMPIMethodMI* mi, + const CMPIContext* context, + const Cura_FanRef* self, + const KBoolean* Enabled, + CMPIStatus* status) +{ + KUint32 result = KUINT32_INIT; + + KSetStatus(status, ERR_NOT_SUPPORTED); + return result; +} + +KUint32 Cura_Fan_OnlineDevice( + const CMPIBroker* cb, + CMPIMethodMI* mi, + const CMPIContext* context, + const Cura_FanRef* self, + const KBoolean* Online, + CMPIStatus* status) +{ + KUint32 result = KUINT32_INIT; + + KSetStatus(status, ERR_NOT_SUPPORTED); + return result; +} + +KUint32 Cura_Fan_QuiesceDevice( + const CMPIBroker* cb, + CMPIMethodMI* mi, + const CMPIContext* context, + const Cura_FanRef* self, + const KBoolean* Quiesce, + CMPIStatus* status) +{ + KUint32 result = KUINT32_INIT; + + KSetStatus(status, ERR_NOT_SUPPORTED); + return result; +} + +KUint32 Cura_Fan_SaveProperties( + const CMPIBroker* cb, + CMPIMethodMI* mi, + const CMPIContext* context, + const Cura_FanRef* self, + CMPIStatus* status) +{ + KUint32 result = KUINT32_INIT; + + KSetStatus(status, ERR_NOT_SUPPORTED); + return result; +} + +KUint32 Cura_Fan_RestoreProperties( + const CMPIBroker* cb, + CMPIMethodMI* mi, + const CMPIContext* context, + const Cura_FanRef* self, + CMPIStatus* status) +{ + KUint32 result = KUINT32_INIT; + + KSetStatus(status, ERR_NOT_SUPPORTED); + return result; +} + +KUint32 Cura_Fan_SetSpeed( + const CMPIBroker* cb, + CMPIMethodMI* mi, + const CMPIContext* context, + const Cura_FanRef* self, + const KUint64* DesiredSpeed, + CMPIStatus* status) +{ + KUint32 result = KUINT32_INIT; + + KSetStatus(status, ERR_NOT_SUPPORTED); + return result; +} + +KONKRET_REGISTRATION( + "root/cimv2", + "Cura_Fan", + "Cura_Fan", + "instance method") diff --git a/src/fan/Cura_FanSensorProvider.c b/src/fan/Cura_FanSensorProvider.c new file mode 100644 index 0000000..efbc1a5 --- /dev/null +++ b/src/fan/Cura_FanSensorProvider.c @@ -0,0 +1,383 @@ +#include +#include "Cura_FanSensor.h" +#include "fan.h" +#include + +static const CMPIBroker* _cb = NULL; + +static void Cura_FanSensorInitialize() +{ + init_linux_fan_module(); +} + +static CMPIStatus Cura_FanSensorCleanup( + CMPIInstanceMI* mi, + const CMPIContext* cc, + CMPIBoolean term) +{ + CMReturn(CMPI_RC_OK); +} + +static CMPIStatus Cura_FanSensorEnumInstanceNames( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop) +{ + return KDefaultEnumerateInstanceNames( + _cb, mi, cc, cr, cop); +} + +static CMPIStatus Cura_FanSensorEnumInstances( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char** properties) +{ + char buf[200]; + struct cim_fan *sptr = NULL; + struct fanlist *lptr = NULL, *fans = NULL; + if (enum_all_fans(&fans) != 0 ) { + KReturn2(_cb, ERR_FAILED, "Could not list get fan list."); + } + + lptr = fans; + // iterate fan list + while (lptr) { + sptr = lptr->f; + Cura_FanSensor w; + Cura_FanSensor_Init(&w, _cb, KNameSpace(cop)); + Cura_FanSensor_Set_CreationClassName(&w, "Cura_FanSensor"); + Cura_FanSensor_Set_SystemCreationClassName(&w, get_system_creation_class_name()); + Cura_FanSensor_Set_SystemName(&w, get_system_name()); + Cura_FanSensor_Set_DeviceID(&w, sptr->device_id); + + Cura_FanSensor_Set_Caption(&w, "Computer's fan"); + Cura_FanSensor_Set_Description(&w,"Computer's fan."); + snprintf(buf, 200, "Fan \"%s\" on chip \"%s\"", sptr->name, sptr->chip_name); + Cura_FanSensor_Set_ElementName(&w, buf); + + // ManagedSystemElement + Cura_FanSensor_Set_Name(&w, sptr->name); + + Cura_FanSensor_Init_OperationalStatus(&w, 2); + Cura_FanSensor_Set_OperationalStatus(&w, 0, sptr->fault ? + Cura_FanSensor_OperationalStatus_Error : + Cura_FanSensor_OperationalStatus_OK); + if (sptr->alarm || sptr->alarm_min || sptr->alarm_max) { + Cura_FanSensor_Set_OperationalStatus(&w, 1, Cura_FanSensor_OperationalStatus_Stressed); + } + + Cura_FanSensor_Init_StatusDescriptions(&w, 2); + Cura_FanSensor_Set_StatusDescriptions(&w, 0, sptr->fault ? + "Chip indicates, that fan is in fault state." + " Possible causes are open diodes, unconnected fan etc." + " Thus the measurement for this channel should not be trusted." + : "Fan seems to be functioning correctly."); + if (sptr->alarm || sptr->alarm_min || sptr->alarm_max) { + snprintf(buf, 200, "These alarm flags are set by the fan's chip:" + " alarm=%s, min_alarm=%s, max_alarm=%s", + sptr->alarm ? "1":"0", + sptr->alarm_min ? "1":"0", + sptr->alarm_max ? "1":"0"); + Cura_FanSensor_Set_StatusDescriptions(&w, 1, buf); + } + + Cura_FanSensor_Set_HealthState(&w, sptr->fault ? + Cura_FanSensor_HealthState_Major_failure : + Cura_FanSensor_HealthState_OK); + + Cura_FanSensor_Set_OperatingStatus(&w, sptr->fault ? + Cura_FanSensor_OperatingStatus_Stopped : + Cura_FanSensor_OperatingStatus_In_Service); + + Cura_FanSensor_Set_PrimaryStatus(&w, sptr->fault ? + Cura_FanSensor_PrimaryStatus_Error : + Cura_FanSensor_PrimaryStatus_OK); + + // EnabledLogicalElement + Cura_FanSensor_Init_OtherIdentifyingInfo(&w, 2); + Cura_FanSensor_Set_OtherIdentifyingInfo(&w, 0, sptr->chip_name); + Cura_FanSensor_Set_OtherIdentifyingInfo(&w, 1, sptr->sys_path); + + Cura_FanSensor_Init_IdentifyingDescriptions(&w, 2); + Cura_FanSensor_Set_IdentifyingDescriptions(&w, 0, "ChipName - name of fan's chip."); + Cura_FanSensor_Set_IdentifyingDescriptions(&w, 1, "SysPath - system path of fan's chip."); + + // ManagedElement + Cura_FanSensor_Set_Caption(&w, "Fan's tachometer"); + Cura_FanSensor_Set_Description(&w,"Associated sensor of fan. Giving information about its speed."); + + snprintf(buf, 200, "Tachometer of fan \"%s\" on chip \"%s\"", sptr->name, sptr->chip_name); + Cura_FanSensor_Set_ElementName(&w, buf); + + // Sensor + Cura_FanSensor_Set_SensorType(&w, Cura_FanSensor_SensorType_Tachometer); + Cura_FanSensor_Set_CurrentState(&w, fan_get_current_state(sptr)); + + Cura_FanSensor_Init_PossibleStates(&w, 5); + int index = 0; + if (sptr->accessible_features & CIM_FAN_AF_MIN_SPEED) { + Cura_FanSensor_Set_PossibleStates(&w, index++, "Below Minimum"); + Cura_FanSensor_Set_PossibleStates(&w, index++, "At Minimum"); + } + Cura_FanSensor_Set_PossibleStates(&w, index++, "Normal"); + if (sptr->accessible_features & CIM_FAN_AF_MAX_SPEED) { + Cura_FanSensor_Set_PossibleStates(&w, index++, "At Maximum"); + Cura_FanSensor_Set_PossibleStates(&w, index++, "Above Maximum"); + } + + // NumericSensor + Cura_FanSensor_Set_BaseUnits(&w, Cura_FanSensor_BaseUnits_Revolutions); + Cura_FanSensor_Set_UnitModifier(&w, 0); + Cura_FanSensor_Set_RateUnits(&w, Cura_FanSensor_RateUnits_Per_Minute); + Cura_FanSensor_Set_CurrentReading(&w, sptr->speed); + if (sptr->accessible_features & CIM_FAN_AF_MAX_SPEED) { + Cura_FanSensor_Set_NormalMax(&w, sptr->max_speed); + } + if (sptr->accessible_features & CIM_FAN_AF_MIN_SPEED) { + Cura_FanSensor_Set_NormalMin(&w, sptr->min_speed); + } + Cura_FanSensor_Set_MinReadable(&w, 0); + Cura_FanSensor_Set_IsLinear(&w, true); + + KReturnInstance(cr, w); + lptr = lptr->next; + } + CMReturn(CMPI_RC_OK); +} + +static CMPIStatus Cura_FanSensorGetInstance( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char** properties) +{ + return KDefaultGetInstance( + _cb, mi, cc, cr, cop, properties); +} + +static CMPIStatus Cura_FanSensorCreateInstance( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const CMPIInstance* ci) +{ + CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); +} + +static CMPIStatus Cura_FanSensorModifyInstance( + 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 Cura_FanSensorDeleteInstance( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop) +{ + CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); +} + +static CMPIStatus Cura_FanSensorExecQuery( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char* lang, + const char* query) +{ + CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); +} + +CMInstanceMIStub( + Cura_FanSensor, + Cura_FanSensor, + _cb, + Cura_FanSensorInitialize()) + +static CMPIStatus Cura_FanSensorMethodCleanup( + CMPIMethodMI* mi, + const CMPIContext* cc, + CMPIBoolean term) +{ + CMReturn(CMPI_RC_OK); +} + +static CMPIStatus Cura_FanSensorInvokeMethod( + CMPIMethodMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char* meth, + const CMPIArgs* in, + CMPIArgs* out) +{ + return Cura_FanSensor_DispatchMethod( + _cb, mi, cc, cr, cop, meth, in, out); +} + +CMMethodMIStub( + Cura_FanSensor, + Cura_FanSensor, + _cb, + Cura_FanSensorInitialize()) + +KUint32 Cura_FanSensor_RequestStateChange( + const CMPIBroker* cb, + CMPIMethodMI* mi, + const CMPIContext* context, + const Cura_FanSensorRef* self, + const KUint16* RequestedState, + KRef* Job, + const KDateTime* TimeoutPeriod, + CMPIStatus* status) +{ + KUint32 result = KUINT32_INIT; + + KSetStatus(status, ERR_NOT_SUPPORTED); + return result; +} + +KUint32 Cura_FanSensor_SetPowerState( + const CMPIBroker* cb, + CMPIMethodMI* mi, + const CMPIContext* context, + const Cura_FanSensorRef* self, + const KUint16* PowerState, + const KDateTime* Time, + CMPIStatus* status) +{ + KUint32 result = KUINT32_INIT; + + KSetStatus(status, ERR_NOT_SUPPORTED); + return result; +} + +KUint32 Cura_FanSensor_Reset( + const CMPIBroker* cb, + CMPIMethodMI* mi, + const CMPIContext* context, + const Cura_FanSensorRef* self, + CMPIStatus* status) +{ + KUint32 result = KUINT32_INIT; + + KSetStatus(status, ERR_NOT_SUPPORTED); + return result; +} + +KUint32 Cura_FanSensor_EnableDevice( + const CMPIBroker* cb, + CMPIMethodMI* mi, + const CMPIContext* context, + const Cura_FanSensorRef* self, + const KBoolean* Enabled, + CMPIStatus* status) +{ + KUint32 result = KUINT32_INIT; + + KSetStatus(status, ERR_NOT_SUPPORTED); + return result; +} + +KUint32 Cura_FanSensor_OnlineDevice( + const CMPIBroker* cb, + CMPIMethodMI* mi, + const CMPIContext* context, + const Cura_FanSensorRef* self, + const KBoolean* Online, + CMPIStatus* status) +{ + KUint32 result = KUINT32_INIT; + + KSetStatus(status, ERR_NOT_SUPPORTED); + return result; +} + +KUint32 Cura_FanSensor_QuiesceDevice( + const CMPIBroker* cb, + CMPIMethodMI* mi, + const CMPIContext* context, + const Cura_FanSensorRef* self, + const KBoolean* Quiesce, + CMPIStatus* status) +{ + KUint32 result = KUINT32_INIT; + + KSetStatus(status, ERR_NOT_SUPPORTED); + return result; +} + +KUint32 Cura_FanSensor_SaveProperties( + const CMPIBroker* cb, + CMPIMethodMI* mi, + const CMPIContext* context, + const Cura_FanSensorRef* self, + CMPIStatus* status) +{ + KUint32 result = KUINT32_INIT; + + KSetStatus(status, ERR_NOT_SUPPORTED); + return result; +} + +KUint32 Cura_FanSensor_RestoreProperties( + const CMPIBroker* cb, + CMPIMethodMI* mi, + const CMPIContext* context, + const Cura_FanSensorRef* self, + CMPIStatus* status) +{ + KUint32 result = KUINT32_INIT; + + KSetStatus(status, ERR_NOT_SUPPORTED); + return result; +} + +KUint32 Cura_FanSensor_RestoreDefaultThresholds( + const CMPIBroker* cb, + CMPIMethodMI* mi, + const CMPIContext* context, + const Cura_FanSensorRef* self, + CMPIStatus* status) +{ + KUint32 result = KUINT32_INIT; + + KSetStatus(status, ERR_NOT_SUPPORTED); + return result; +} + +KUint32 Cura_FanSensor_GetNonLinearFactors( + const CMPIBroker* cb, + CMPIMethodMI* mi, + const CMPIContext* context, + const Cura_FanSensorRef* self, + const KSint32* SensorReading, + KSint32* Accuracy, + KUint32* Resolution, + KSint32* Tolerance, + KUint32* Hysteresis, + CMPIStatus* status) +{ + KUint32 result = KUINT32_INIT; + + KSetStatus(status, ERR_NOT_SUPPORTED); + return result; +} + +KONKRET_REGISTRATION( + "root/cimv2", + "Cura_FanSensor", + "Cura_FanSensor", + "instance method") diff --git a/src/fan/Linux_FanAssociatedSensorProvider.c b/src/fan/Linux_FanAssociatedSensorProvider.c deleted file mode 100644 index ddb55c1..0000000 --- a/src/fan/Linux_FanAssociatedSensorProvider.c +++ /dev/null @@ -1,240 +0,0 @@ -#include -#include "Linux_FanAssociatedSensor.h" -#include "fan.h" -#include - -static const CMPIBroker* _cb; - -static void Linux_FanAssociatedSensorInitialize() -{ - init_linux_fan_module(); -} - -static CMPIStatus Linux_FanAssociatedSensorCleanup( - CMPIInstanceMI* mi, - const CMPIContext* cc, - CMPIBoolean term) -{ - CMReturn(CMPI_RC_OK); -} - -static CMPIStatus Linux_FanAssociatedSensorEnumInstanceNames( - CMPIInstanceMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop) -{ - return KDefaultEnumerateInstanceNames( - _cb, mi, cc, cr, cop); -} - -static CMPIStatus Linux_FanAssociatedSensorEnumInstances( - CMPIInstanceMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop, - const char** properties) -{ - const char *ns = KNameSpace(cop); - - struct cim_fan *sptr = NULL; - struct fanlist *lptr = NULL, *fans = NULL; - if (enum_all_fans(&fans) != 0 ) { - KReturn2(_cb, ERR_FAILED, "Could not list get fan list."); - } - - lptr = fans; - // iterate fan list - while (lptr) { - sptr = lptr->f; - Linux_FanAssociatedSensor w; - Linux_FanAssociatedSensor_Init(&w, _cb, ns); - - Linux_FanRef fan; - Linux_FanRef_Init(&fan, _cb, ns); - Linux_FanRef_Set_CreationClassName(&fan, "Linux_Fan"); - Linux_FanRef_Set_DeviceID(&fan, sptr->device_id); - Linux_FanRef_Set_SystemCreationClassName(&fan, get_system_creation_class_name()); - Linux_FanRef_Set_SystemName(&fan, get_system_name()); - - Linux_FanSensorRef fanSensor; - Linux_FanSensorRef_Init(&fanSensor, _cb, ns); - Linux_FanSensorRef_Set_CreationClassName(&fanSensor, "Linux_FanSensor"); - Linux_FanSensorRef_Set_DeviceID(&fanSensor, sptr->device_id); - Linux_FanSensorRef_Set_SystemCreationClassName(&fanSensor, get_system_creation_class_name()); - Linux_FanSensorRef_Set_SystemName(&fanSensor, get_system_name()); - - Linux_FanAssociatedSensor_Set_Antecedent(&w, &fanSensor); - Linux_FanAssociatedSensor_Set_Dependent(&w, &fan); - - KReturnInstance(cr, w); - lptr = lptr->next; - } - CMReturn(CMPI_RC_OK); -} - -static CMPIStatus Linux_FanAssociatedSensorGetInstance( - CMPIInstanceMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop, - const char** properties) -{ - return KDefaultGetInstance( - _cb, mi, cc, cr, cop, properties); -} - -static CMPIStatus Linux_FanAssociatedSensorCreateInstance( - CMPIInstanceMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop, - const CMPIInstance* ci) -{ - CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); -} - -static CMPIStatus Linux_FanAssociatedSensorModifyInstance( - 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 Linux_FanAssociatedSensorDeleteInstance( - CMPIInstanceMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop) -{ - CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); -} - -static CMPIStatus Linux_FanAssociatedSensorExecQuery( - 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 Linux_FanAssociatedSensorAssociationCleanup( - CMPIAssociationMI* mi, - const CMPIContext* cc, - CMPIBoolean term) -{ - CMReturn(CMPI_RC_OK); -} - -static CMPIStatus Linux_FanAssociatedSensorAssociators( - 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, - Linux_FanAssociatedSensor_ClassName, - assocClass, - resultClass, - role, - resultRole, - properties); -} - -static CMPIStatus Linux_FanAssociatedSensorAssociatorNames( - 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, - Linux_FanAssociatedSensor_ClassName, - assocClass, - resultClass, - role, - resultRole); -} - -static CMPIStatus Linux_FanAssociatedSensorReferences( - 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, - Linux_FanAssociatedSensor_ClassName, - assocClass, - role, - properties); -} - -static CMPIStatus Linux_FanAssociatedSensorReferenceNames( - CMPIAssociationMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop, - const char* assocClass, - const char* role) -{ - return KDefaultReferenceNames( - _cb, - mi, - cc, - cr, - cop, - Linux_FanAssociatedSensor_ClassName, - assocClass, - role); -} - -CMInstanceMIStub( - Linux_FanAssociatedSensor, - Linux_FanAssociatedSensor, - _cb, - Linux_FanAssociatedSensorInitialize()) - -CMAssociationMIStub( - Linux_FanAssociatedSensor, - Linux_FanAssociatedSensor, - _cb, - Linux_FanAssociatedSensorInitialize()) - -KONKRET_REGISTRATION( - "root/cimv2", - "Linux_FanAssociatedSensor", - "Linux_FanAssociatedSensor", - "instance association") diff --git a/src/fan/Linux_FanProvider.c b/src/fan/Linux_FanProvider.c deleted file mode 100644 index fe7a0fa..0000000 --- a/src/fan/Linux_FanProvider.c +++ /dev/null @@ -1,393 +0,0 @@ -#include -#include -#include "Linux_Fan.h" -#include "globals.h" -#include "fan.h" -static const CMPIBroker* _cb = NULL; - -#include -#include -#include - -void print_backtrace(int signal) -{ - fprintf(stderr, "BackTrace\n"); - int ppid = getpid(); - int pid = fork(); - if (pid == 0) { - // Child process - char *strpid; - asprintf(&strpid, "%d", ppid); - execl("/usr/bin/gdb", "/usr/bin/gdb", "-p", strpid, NULL); - } else { - int status; - waitpid(pid, &status, 0); - system("/usr/bin/pkill -9 sfcbd"); - } -} - -static void Linux_FanInitialize() -{ - init_linux_fan_module(); - signal(SIGSEGV, print_backtrace); -} - -static CMPIStatus Linux_FanCleanup( - CMPIInstanceMI* mi, - const CMPIContext* cc, - CMPIBoolean term) -{ - CMReturn(CMPI_RC_OK); -} - -static CMPIStatus Linux_FanEnumInstanceNames( - CMPIInstanceMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop) -{ - return KDefaultEnumerateInstanceNames( - _cb, mi, cc, cr, cop); -} - -static CMPIStatus Linux_FanEnumInstances( - CMPIInstanceMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop, - const char** properties) -{ - const char *ns = KNameSpace(cop); - - char buf[200]; - struct fanlist *lptr = NULL; - struct fanlist *fans = NULL; - struct cim_fan *sptr; - - if (enum_all_fans(&fans)) { - KReturn2(_cb, ERR_FAILED, "Could not list fans."); - } - - // iterate fan list - lptr = fans; - while (lptr != NULL) { - sptr = lptr->f; - Linux_Fan w; - Linux_Fan_Init(&w, _cb, ns); - Linux_Fan_Set_CreationClassName(&w, "Linux_Fan"); - Linux_Fan_Set_SystemCreationClassName(&w, get_system_creation_class_name()); - Linux_Fan_Set_SystemName(&w, get_system_name()); - Linux_Fan_Set_DeviceID(&w, sptr->device_id); - - Linux_Fan_Set_Caption(&w, "Computer's fan"); - Linux_Fan_Set_Description(&w,"Computer's fan."); - snprintf(buf, 200, "Fan \"%s\" on chip \"%s\"", sptr->name, sptr->chip_name); - Linux_Fan_Set_ElementName(&w, buf); - - // ManagedSystemElement - Linux_Fan_Set_Name(&w, sptr->name); - Linux_Fan_Init_OperationalStatus(&w, 2); - Linux_Fan_Set_OperationalStatus(&w, 0, sptr->fault ? - Linux_Fan_OperationalStatus_Error : - Linux_Fan_OperationalStatus_OK); - if (sptr->alarm || sptr->alarm_min || sptr->alarm_max) { - Linux_Fan_Set_OperationalStatus(&w, 1, Linux_Fan_OperationalStatus_Stressed); - } - - Linux_Fan_Init_StatusDescriptions(&w, 2); - Linux_Fan_Set_StatusDescriptions(&w, 0, sptr->fault ? - "Chip indicates, that fan is in fault state." - " Possible causes are open diodes, unconnected fan etc." - " Thus the measurement for this channel should not be trusted." - : "Fan seems to be functioning correctly."); - if (sptr->alarm || sptr->alarm_min || sptr->alarm_max) { - snprintf(buf, 200, "These alarm flags are set by the fan's chip:" - " alarm=%s, min_alarm=%s, max_alarm=%s", - sptr->alarm ? "1":"0", - sptr->alarm_min ? "1":"0", - sptr->alarm_max ? "1":"0"); - Linux_Fan_Set_StatusDescriptions(&w, 1, buf); - } - - - Linux_Fan_Set_HealthState(&w, sptr->fault ? - Linux_Fan_HealthState_Major_failure : - Linux_Fan_HealthState_OK); - - Linux_Fan_Set_OperatingStatus(&w, sptr->fault ? - Linux_Fan_OperatingStatus_Stopped : - Linux_Fan_OperatingStatus_In_Service); - - Linux_Fan_Set_PrimaryStatus(&w, sptr->fault ? - Linux_Fan_PrimaryStatus_Error : - Linux_Fan_PrimaryStatus_OK); - - // EnabledLogicalElement - Linux_Fan_Init_OtherIdentifyingInfo(&w, 2); - Linux_Fan_Set_OtherIdentifyingInfo(&w, 0, sptr->chip_name); - Linux_Fan_Set_OtherIdentifyingInfo(&w, 1, sptr->sys_path); - - Linux_Fan_Init_IdentifyingDescriptions(&w, 2); - Linux_Fan_Set_IdentifyingDescriptions(&w, 0, "ChipName - name of fan's chip."); - Linux_Fan_Set_IdentifyingDescriptions(&w, 1, "SysPath - system path of fan's chip."); - - Linux_Fan_Set_ActiveCooling(&w, true); - - uint32_t i = 1; - int index = 0; - debug("accessible_features: %d", sptr->accessible_features); - Linux_Fan_Init_AccessibleFeatures(&w, 8); - while (i <= CIM_FAN_AF_FEATURE_MAX) { - if (i & sptr->accessible_features) { - Linux_Fan_Set_AccessibleFeatures(&w, index++, i); - } - i = i << 1; - } - if (sptr->accessible_features & CIM_FAN_AF_MIN_SPEED) { - Linux_Fan_Set_MinSpeed(&w, (uint64_t) sptr->min_speed); - } - if (sptr->accessible_features & CIM_FAN_AF_MAX_SPEED) { - Linux_Fan_Set_MaxSpeed(&w, (uint64_t) sptr->max_speed); - } - if (sptr->accessible_features & CIM_FAN_AF_DIV) { - Linux_Fan_Set_Divisor(&w, sptr->divisor); - } - if (sptr->accessible_features & CIM_FAN_AF_PULSES) { - Linux_Fan_Set_Pulses(&w, sptr->pulses); - } - if (sptr->accessible_features & CIM_FAN_AF_BEEP) { - Linux_Fan_Set_Beep(&w, sptr->beep); - } - if (sptr->accessible_features & CIM_FAN_AF_ALARM) { - Linux_Fan_Set_Alarm(&w, sptr->alarm); - } - if (sptr->accessible_features & CIM_FAN_AF_ALARM_MIN) { - Linux_Fan_Set_MinAlarm(&w, sptr->alarm_min); - } - if (sptr->accessible_features & CIM_FAN_AF_ALARM_MAX) { - Linux_Fan_Set_MaxAlarm(&w, sptr->alarm_max); - } - - KReturnInstance(cr, w); - lptr = lptr->next; - } - free_fanlist(fans); - KReturn(OK); -} - -static CMPIStatus Linux_FanGetInstance( - CMPIInstanceMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop, - const char** properties) -{ - return KDefaultGetInstance( - _cb, mi, cc, cr, cop, properties); -} - -static CMPIStatus Linux_FanCreateInstance( - CMPIInstanceMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop, - const CMPIInstance* ci) -{ - CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); -} - -static CMPIStatus Linux_FanModifyInstance( - 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 Linux_FanDeleteInstance( - CMPIInstanceMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop) -{ - CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); -} - -static CMPIStatus Linux_FanExecQuery( - CMPIInstanceMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop, - const char* lang, - const char* query) -{ - CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); -} - -CMInstanceMIStub( - Linux_Fan, - Linux_Fan, - _cb, - Linux_FanInitialize()) - -static CMPIStatus Linux_FanMethodCleanup( - CMPIMethodMI* mi, - const CMPIContext* cc, - CMPIBoolean term) -{ - CMReturn(CMPI_RC_OK); -} - -static CMPIStatus Linux_FanInvokeMethod( - CMPIMethodMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop, - const char* meth, - const CMPIArgs* in, - CMPIArgs* out) -{ - return Linux_Fan_DispatchMethod( - _cb, mi, cc, cr, cop, meth, in, out); -} - -CMMethodMIStub( - Linux_Fan, - Linux_Fan, - _cb, - Linux_FanInitialize()) - -KUint32 Linux_Fan_RequestStateChange( - const CMPIBroker* cb, - CMPIMethodMI* mi, - const CMPIContext* context, - const Linux_FanRef* self, - const KUint16* RequestedState, - KRef* Job, - const KDateTime* TimeoutPeriod, - CMPIStatus* status) -{ - KUint32 result = KUINT32_INIT; - - KSetStatus(status, ERR_NOT_SUPPORTED); - return result; -} - -KUint32 Linux_Fan_SetPowerState( - const CMPIBroker* cb, - CMPIMethodMI* mi, - const CMPIContext* context, - const Linux_FanRef* self, - const KUint16* PowerState, - const KDateTime* Time, - CMPIStatus* status) -{ - KUint32 result = KUINT32_INIT; - - KSetStatus(status, ERR_NOT_SUPPORTED); - return result; -} - -KUint32 Linux_Fan_Reset( - const CMPIBroker* cb, - CMPIMethodMI* mi, - const CMPIContext* context, - const Linux_FanRef* self, - CMPIStatus* status) -{ - KUint32 result = KUINT32_INIT; - - KSetStatus(status, ERR_NOT_SUPPORTED); - return result; -} - -KUint32 Linux_Fan_EnableDevice( - const CMPIBroker* cb, - CMPIMethodMI* mi, - const CMPIContext* context, - const Linux_FanRef* self, - const KBoolean* Enabled, - CMPIStatus* status) -{ - KUint32 result = KUINT32_INIT; - - KSetStatus(status, ERR_NOT_SUPPORTED); - return result; -} - -KUint32 Linux_Fan_OnlineDevice( - const CMPIBroker* cb, - CMPIMethodMI* mi, - const CMPIContext* context, - const Linux_FanRef* self, - const KBoolean* Online, - CMPIStatus* status) -{ - KUint32 result = KUINT32_INIT; - - KSetStatus(status, ERR_NOT_SUPPORTED); - return result; -} - -KUint32 Linux_Fan_QuiesceDevice( - const CMPIBroker* cb, - CMPIMethodMI* mi, - const CMPIContext* context, - const Linux_FanRef* self, - const KBoolean* Quiesce, - CMPIStatus* status) -{ - KUint32 result = KUINT32_INIT; - - KSetStatus(status, ERR_NOT_SUPPORTED); - return result; -} - -KUint32 Linux_Fan_SaveProperties( - const CMPIBroker* cb, - CMPIMethodMI* mi, - const CMPIContext* context, - const Linux_FanRef* self, - CMPIStatus* status) -{ - KUint32 result = KUINT32_INIT; - - KSetStatus(status, ERR_NOT_SUPPORTED); - return result; -} - -KUint32 Linux_Fan_RestoreProperties( - const CMPIBroker* cb, - CMPIMethodMI* mi, - const CMPIContext* context, - const Linux_FanRef* self, - CMPIStatus* status) -{ - KUint32 result = KUINT32_INIT; - - KSetStatus(status, ERR_NOT_SUPPORTED); - return result; -} - -KUint32 Linux_Fan_SetSpeed( - const CMPIBroker* cb, - CMPIMethodMI* mi, - const CMPIContext* context, - const Linux_FanRef* self, - const KUint64* DesiredSpeed, - CMPIStatus* status) -{ - KUint32 result = KUINT32_INIT; - - KSetStatus(status, ERR_NOT_SUPPORTED); - return result; -} - -KONKRET_REGISTRATION( - "root/cimv2", - "Linux_Fan", - "Linux_Fan", - "instance method") diff --git a/src/fan/Linux_FanSensorProvider.c b/src/fan/Linux_FanSensorProvider.c deleted file mode 100644 index 390e5cf..0000000 --- a/src/fan/Linux_FanSensorProvider.c +++ /dev/null @@ -1,383 +0,0 @@ -#include -#include "Linux_FanSensor.h" -#include "fan.h" -#include - -static const CMPIBroker* _cb = NULL; - -static void Linux_FanSensorInitialize() -{ - init_linux_fan_module(); -} - -static CMPIStatus Linux_FanSensorCleanup( - CMPIInstanceMI* mi, - const CMPIContext* cc, - CMPIBoolean term) -{ - CMReturn(CMPI_RC_OK); -} - -static CMPIStatus Linux_FanSensorEnumInstanceNames( - CMPIInstanceMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop) -{ - return KDefaultEnumerateInstanceNames( - _cb, mi, cc, cr, cop); -} - -static CMPIStatus Linux_FanSensorEnumInstances( - CMPIInstanceMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop, - const char** properties) -{ - char buf[200]; - struct cim_fan *sptr = NULL; - struct fanlist *lptr = NULL, *fans = NULL; - if (enum_all_fans(&fans) != 0 ) { - KReturn2(_cb, ERR_FAILED, "Could not list get fan list."); - } - - lptr = fans; - // iterate fan list - while (lptr) { - sptr = lptr->f; - Linux_FanSensor w; - Linux_FanSensor_Init(&w, _cb, KNameSpace(cop)); - Linux_FanSensor_Set_CreationClassName(&w, "Linux_FanSensor"); - Linux_FanSensor_Set_SystemCreationClassName(&w, get_system_creation_class_name()); - Linux_FanSensor_Set_SystemName(&w, get_system_name()); - Linux_FanSensor_Set_DeviceID(&w, sptr->device_id); - - Linux_FanSensor_Set_Caption(&w, "Computer's fan"); - Linux_FanSensor_Set_Description(&w,"Computer's fan."); - snprintf(buf, 200, "Fan \"%s\" on chip \"%s\"", sptr->name, sptr->chip_name); - Linux_FanSensor_Set_ElementName(&w, buf); - - // ManagedSystemElement - Linux_FanSensor_Set_Name(&w, sptr->name); - - Linux_FanSensor_Init_OperationalStatus(&w, 2); - Linux_FanSensor_Set_OperationalStatus(&w, 0, sptr->fault ? - Linux_FanSensor_OperationalStatus_Error : - Linux_FanSensor_OperationalStatus_OK); - if (sptr->alarm || sptr->alarm_min || sptr->alarm_max) { - Linux_FanSensor_Set_OperationalStatus(&w, 1, Linux_FanSensor_OperationalStatus_Stressed); - } - - Linux_FanSensor_Init_StatusDescriptions(&w, 2); - Linux_FanSensor_Set_StatusDescriptions(&w, 0, sptr->fault ? - "Chip indicates, that fan is in fault state." - " Possible causes are open diodes, unconnected fan etc." - " Thus the measurement for this channel should not be trusted." - : "Fan seems to be functioning correctly."); - if (sptr->alarm || sptr->alarm_min || sptr->alarm_max) { - snprintf(buf, 200, "These alarm flags are set by the fan's chip:" - " alarm=%s, min_alarm=%s, max_alarm=%s", - sptr->alarm ? "1":"0", - sptr->alarm_min ? "1":"0", - sptr->alarm_max ? "1":"0"); - Linux_FanSensor_Set_StatusDescriptions(&w, 1, buf); - } - - Linux_FanSensor_Set_HealthState(&w, sptr->fault ? - Linux_FanSensor_HealthState_Major_failure : - Linux_FanSensor_HealthState_OK); - - Linux_FanSensor_Set_OperatingStatus(&w, sptr->fault ? - Linux_FanSensor_OperatingStatus_Stopped : - Linux_FanSensor_OperatingStatus_In_Service); - - Linux_FanSensor_Set_PrimaryStatus(&w, sptr->fault ? - Linux_FanSensor_PrimaryStatus_Error : - Linux_FanSensor_PrimaryStatus_OK); - - // EnabledLogicalElement - Linux_FanSensor_Init_OtherIdentifyingInfo(&w, 2); - Linux_FanSensor_Set_OtherIdentifyingInfo(&w, 0, sptr->chip_name); - Linux_FanSensor_Set_OtherIdentifyingInfo(&w, 1, sptr->sys_path); - - Linux_FanSensor_Init_IdentifyingDescriptions(&w, 2); - Linux_FanSensor_Set_IdentifyingDescriptions(&w, 0, "ChipName - name of fan's chip."); - Linux_FanSensor_Set_IdentifyingDescriptions(&w, 1, "SysPath - system path of fan's chip."); - - // ManagedElement - Linux_FanSensor_Set_Caption(&w, "Fan's tachometer"); - Linux_FanSensor_Set_Description(&w,"Associated sensor of fan. Giving information about its speed."); - - snprintf(buf, 200, "Tachometer of fan \"%s\" on chip \"%s\"", sptr->name, sptr->chip_name); - Linux_FanSensor_Set_ElementName(&w, buf); - - // Sensor - Linux_FanSensor_Set_SensorType(&w, Linux_FanSensor_SensorType_Tachometer); - Linux_FanSensor_Set_CurrentState(&w, fan_get_current_state(sptr)); - - Linux_FanSensor_Init_PossibleStates(&w, 5); - int index = 0; - if (sptr->accessible_features & CIM_FAN_AF_MIN_SPEED) { - Linux_FanSensor_Set_PossibleStates(&w, index++, "Below Minimum"); - Linux_FanSensor_Set_PossibleStates(&w, index++, "At Minimum"); - } - Linux_FanSensor_Set_PossibleStates(&w, index++, "Normal"); - if (sptr->accessible_features & CIM_FAN_AF_MAX_SPEED) { - Linux_FanSensor_Set_PossibleStates(&w, index++, "At Maximum"); - Linux_FanSensor_Set_PossibleStates(&w, index++, "Above Maximum"); - } - - // NumericSensor - Linux_FanSensor_Set_BaseUnits(&w, Linux_FanSensor_BaseUnits_Revolutions); - Linux_FanSensor_Set_UnitModifier(&w, 0); - Linux_FanSensor_Set_RateUnits(&w, Linux_FanSensor_RateUnits_Per_Minute); - Linux_FanSensor_Set_CurrentReading(&w, sptr->speed); - if (sptr->accessible_features & CIM_FAN_AF_MAX_SPEED) { - Linux_FanSensor_Set_NormalMax(&w, sptr->max_speed); - } - if (sptr->accessible_features & CIM_FAN_AF_MIN_SPEED) { - Linux_FanSensor_Set_NormalMin(&w, sptr->min_speed); - } - Linux_FanSensor_Set_MinReadable(&w, 0); - Linux_FanSensor_Set_IsLinear(&w, true); - - KReturnInstance(cr, w); - lptr = lptr->next; - } - CMReturn(CMPI_RC_OK); -} - -static CMPIStatus Linux_FanSensorGetInstance( - CMPIInstanceMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop, - const char** properties) -{ - return KDefaultGetInstance( - _cb, mi, cc, cr, cop, properties); -} - -static CMPIStatus Linux_FanSensorCreateInstance( - CMPIInstanceMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop, - const CMPIInstance* ci) -{ - CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); -} - -static CMPIStatus Linux_FanSensorModifyInstance( - 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 Linux_FanSensorDeleteInstance( - CMPIInstanceMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop) -{ - CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); -} - -static CMPIStatus Linux_FanSensorExecQuery( - CMPIInstanceMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop, - const char* lang, - const char* query) -{ - CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); -} - -CMInstanceMIStub( - Linux_FanSensor, - Linux_FanSensor, - _cb, - Linux_FanSensorInitialize()) - -static CMPIStatus Linux_FanSensorMethodCleanup( - CMPIMethodMI* mi, - const CMPIContext* cc, - CMPIBoolean term) -{ - CMReturn(CMPI_RC_OK); -} - -static CMPIStatus Linux_FanSensorInvokeMethod( - CMPIMethodMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop, - const char* meth, - const CMPIArgs* in, - CMPIArgs* out) -{ - return Linux_FanSensor_DispatchMethod( - _cb, mi, cc, cr, cop, meth, in, out); -} - -CMMethodMIStub( - Linux_FanSensor, - Linux_FanSensor, - _cb, - Linux_FanSensorInitialize()) - -KUint32 Linux_FanSensor_RequestStateChange( - const CMPIBroker* cb, - CMPIMethodMI* mi, - const CMPIContext* context, - const Linux_FanSensorRef* self, - const KUint16* RequestedState, - KRef* Job, - const KDateTime* TimeoutPeriod, - CMPIStatus* status) -{ - KUint32 result = KUINT32_INIT; - - KSetStatus(status, ERR_NOT_SUPPORTED); - return result; -} - -KUint32 Linux_FanSensor_SetPowerState( - const CMPIBroker* cb, - CMPIMethodMI* mi, - const CMPIContext* context, - const Linux_FanSensorRef* self, - const KUint16* PowerState, - const KDateTime* Time, - CMPIStatus* status) -{ - KUint32 result = KUINT32_INIT; - - KSetStatus(status, ERR_NOT_SUPPORTED); - return result; -} - -KUint32 Linux_FanSensor_Reset( - const CMPIBroker* cb, - CMPIMethodMI* mi, - const CMPIContext* context, - const Linux_FanSensorRef* self, - CMPIStatus* status) -{ - KUint32 result = KUINT32_INIT; - - KSetStatus(status, ERR_NOT_SUPPORTED); - return result; -} - -KUint32 Linux_FanSensor_EnableDevice( - const CMPIBroker* cb, - CMPIMethodMI* mi, - const CMPIContext* context, - const Linux_FanSensorRef* self, - const KBoolean* Enabled, - CMPIStatus* status) -{ - KUint32 result = KUINT32_INIT; - - KSetStatus(status, ERR_NOT_SUPPORTED); - return result; -} - -KUint32 Linux_FanSensor_OnlineDevice( - const CMPIBroker* cb, - CMPIMethodMI* mi, - const CMPIContext* context, - const Linux_FanSensorRef* self, - const KBoolean* Online, - CMPIStatus* status) -{ - KUint32 result = KUINT32_INIT; - - KSetStatus(status, ERR_NOT_SUPPORTED); - return result; -} - -KUint32 Linux_FanSensor_QuiesceDevice( - const CMPIBroker* cb, - CMPIMethodMI* mi, - const CMPIContext* context, - const Linux_FanSensorRef* self, - const KBoolean* Quiesce, - CMPIStatus* status) -{ - KUint32 result = KUINT32_INIT; - - KSetStatus(status, ERR_NOT_SUPPORTED); - return result; -} - -KUint32 Linux_FanSensor_SaveProperties( - const CMPIBroker* cb, - CMPIMethodMI* mi, - const CMPIContext* context, - const Linux_FanSensorRef* self, - CMPIStatus* status) -{ - KUint32 result = KUINT32_INIT; - - KSetStatus(status, ERR_NOT_SUPPORTED); - return result; -} - -KUint32 Linux_FanSensor_RestoreProperties( - const CMPIBroker* cb, - CMPIMethodMI* mi, - const CMPIContext* context, - const Linux_FanSensorRef* self, - CMPIStatus* status) -{ - KUint32 result = KUINT32_INIT; - - KSetStatus(status, ERR_NOT_SUPPORTED); - return result; -} - -KUint32 Linux_FanSensor_RestoreDefaultThresholds( - const CMPIBroker* cb, - CMPIMethodMI* mi, - const CMPIContext* context, - const Linux_FanSensorRef* self, - CMPIStatus* status) -{ - KUint32 result = KUINT32_INIT; - - KSetStatus(status, ERR_NOT_SUPPORTED); - return result; -} - -KUint32 Linux_FanSensor_GetNonLinearFactors( - const CMPIBroker* cb, - CMPIMethodMI* mi, - const CMPIContext* context, - const Linux_FanSensorRef* self, - const KSint32* SensorReading, - KSint32* Accuracy, - KUint32* Resolution, - KSint32* Tolerance, - KUint32* Hysteresis, - CMPIStatus* status) -{ - KUint32 result = KUINT32_INIT; - - KSetStatus(status, ERR_NOT_SUPPORTED); - return result; -} - -KONKRET_REGISTRATION( - "root/cimv2", - "Linux_FanSensor", - "Linux_FanSensor", - "instance method") diff --git a/src/fan/fan.c b/src/fan/fan.c index e8e9559..4ce9495 100644 --- a/src/fan/fan.c +++ b/src/fan/fan.c @@ -1,17 +1,17 @@ -/* This file is part of cmpiLinux_FanProvider. +/* This file is part of cmpiCura_FanProvider. * - * cmpiLinux_FanProvider is free software: you can redistribute it and/or + * cmpiCura_FanProvider is free software: you can redistribute it and/or * modify it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * - * cmpiLinux_FanProvider is distributed in the hope that it will be useful, + * cmpiCura_FanProvider 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 General Public License for more details. * * You should have received a copy of the GNU General Public License - * along with cmpiLinux_FanProvider. If not, see + * along with cmpiCura_FanProvider. If not, see * . */ #include diff --git a/src/fan/fan.h b/src/fan/fan.h index f376ea6..a2da25c 100644 --- a/src/fan/fan.h +++ b/src/fan/fan.h @@ -1,17 +1,17 @@ -/* This file is part of cmpiLinux_FanProvider. +/* This file is part of cmpiCura_FanProvider. * - * cmpiLinux_FanProvider is free software: you can redistribute it and/or + * cmpiCura_FanProvider is free software: you can redistribute it and/or * modify it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * - * cmpiLinux_FanProvider is distributed in the hope that it will be useful, + * cmpiCura_FanProvider 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 General Public License for more details. * * You should have received a copy of the GNU General Public License - * along with cmpiLinux_FanProvider. If not, see + * along with cmpiCura_FanProvider. If not, see * . */ #ifndef LINUX_FAN_H_ diff --git a/src/power/CMakeLists.txt b/src/power/CMakeLists.txt index f30cb87..a129b98 100644 --- a/src/power/CMakeLists.txt +++ b/src/power/CMakeLists.txt @@ -1,7 +1,7 @@ set(PROVIDER_NAME PowerManagement) set(LIBRARY_NAME cmpi${PROVIDER_NAME}) -set(MOF Linux_PowerManagement.mof) +set(MOF Cura_PowerManagement.mof) set(provider_SRCS power.c diff --git a/src/power/Cura_AssociatedPowerManagementServiceProvider.c b/src/power/Cura_AssociatedPowerManagementServiceProvider.c new file mode 100644 index 0000000..82c9ea5 --- /dev/null +++ b/src/power/Cura_AssociatedPowerManagementServiceProvider.c @@ -0,0 +1,269 @@ + +#include "Cura_AssociatedPowerManagementService.h" +#include "Cura_PowerManagementService.h" +#include "CIM_ComputerSystem.h" + +#include "power.h" + +#include "globals.h" + +static const CMPIBroker* _cb; + +static void Cura_AssociatedPowerManagementServiceInitialize(CMPIInstanceMI *mi) +{ + mi->hdl = power_ref(_cb); +} + +static void Cura_AssociatedPowerManagementServiceAssociationInitialize(CMPIAssociationMI *mi) +{ + mi->hdl = power_ref(_cb); +} + +static CMPIStatus Cura_AssociatedPowerManagementServiceCleanup( + CMPIInstanceMI* mi, + const CMPIContext* cc, + CMPIBoolean term) +{ + power_unref(mi->hdl); + mi->hdl = NULL; + CMReturn(CMPI_RC_OK); +} + +static CMPIStatus Cura_AssociatedPowerManagementServiceEnumInstanceNames( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop) +{ + return KDefaultEnumerateInstanceNames( + _cb, mi, cc, cr, cop); +} + +static CMPIStatus Cura_AssociatedPowerManagementServiceEnumInstances( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char** properties) +{ + CMPIStatus rc; + const char *ns = KNameSpace(cop); + + Cura_AssociatedPowerManagementService w; + Cura_AssociatedPowerManagementService_Init(&w, _cb, ns); + + CIM_ComputerSystemRef computerSystemRef; + CIM_ComputerSystemRef_Init(&computerSystemRef, _cb, ns); + CIM_ComputerSystemRef_Set_Name(&computerSystemRef, get_system_name()); + CIM_ComputerSystemRef_Set_CreationClassName(&computerSystemRef, get_system_creation_class_name()); + CMPIObjectPath *computerSystemOP = CIM_ComputerSystemRef_ToObjectPath(&computerSystemRef, &rc); + computerSystemOP->ft->setClassName(computerSystemOP, get_system_creation_class_name()); + Cura_AssociatedPowerManagementService_SetObjectPath_UserOfService(&w, computerSystemOP); + + Cura_PowerManagementServiceRef powerManagementServiceRef; + Cura_PowerManagementServiceRef_Init(&powerManagementServiceRef, _cb, ns); + Cura_PowerManagementServiceRef_Set_Name(&powerManagementServiceRef, get_system_name()); + Cura_PowerManagementServiceRef_Set_SystemName(&powerManagementServiceRef, get_system_name()); + Cura_PowerManagementServiceRef_Set_CreationClassName(&powerManagementServiceRef, "Cura_PowerManagementService"); + Cura_PowerManagementServiceRef_Set_SystemCreationClassName(&powerManagementServiceRef, get_system_creation_class_name()); + Cura_AssociatedPowerManagementService_Set_ServiceProvided(&w, &powerManagementServiceRef); + + int count; + unsigned short *list = power_available_requested_power_states(mi->hdl, &count); + Cura_AssociatedPowerManagementService_Init_AvailableRequestedPowerStates(&w, count); + for (int i = 0; i < count; i++) { + Cura_AssociatedPowerManagementService_Set_AvailableRequestedPowerStates(&w, i, list[i]); + } + + Cura_AssociatedPowerManagementService_Set_TransitioningToPowerState(&w, power_transitioning_to_power_state(mi->hdl)); + Cura_AssociatedPowerManagementService_Set_PowerState(&w, 2); + Cura_AssociatedPowerManagementService_Set_RequestedPowerState(&w, power_requested_power_state(mi->hdl)); + + KReturnInstance(cr, w); + CMReturn(CMPI_RC_OK); +} + +static CMPIStatus Cura_AssociatedPowerManagementServiceGetInstance( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char** properties) +{ + return KDefaultGetInstance( + _cb, mi, cc, cr, cop, properties); +} + +static CMPIStatus Cura_AssociatedPowerManagementServiceCreateInstance( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const CMPIInstance* ci) +{ + CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); +} + +static CMPIStatus Cura_AssociatedPowerManagementServiceModifyInstance( + 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 Cura_AssociatedPowerManagementServiceDeleteInstance( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop) +{ + CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); +} + +static CMPIStatus Cura_AssociatedPowerManagementServiceExecQuery( + 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 Cura_AssociatedPowerManagementServiceAssociationCleanup( + CMPIAssociationMI* mi, + const CMPIContext* cc, + CMPIBoolean term) +{ + power_unref(mi->hdl); + mi->hdl = NULL; + + CMReturn(CMPI_RC_OK); +} + +static CMPIStatus Cura_AssociatedPowerManagementServiceAssociators( + 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) +{ + if (!assocClass) { + assocClass = "Cura_AssociatedPowerManagementService"; + } + + return KDefaultAssociators( + _cb, + mi, + cc, + cr, + cop, + Cura_AssociatedPowerManagementService_ClassName, + assocClass, + resultClass, + role, + resultRole, + properties); +} + +static CMPIStatus Cura_AssociatedPowerManagementServiceAssociatorNames( + CMPIAssociationMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char* assocClass, + const char* resultClass, + const char* role, + const char* resultRole) +{ + if (!assocClass) { + assocClass = "Cura_AssociatedPowerManagementService"; + } + + return KDefaultAssociatorNames( + _cb, + mi, + cc, + cr, + cop, + Cura_AssociatedPowerManagementService_ClassName, + assocClass, + resultClass, + role, + resultRole); +} + +static CMPIStatus Cura_AssociatedPowerManagementServiceReferences( + CMPIAssociationMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char* assocClass, + const char* role, + const char** properties) +{ + if (!assocClass) { + assocClass = "Cura_AssociatedPowerManagementService"; + } + + return KDefaultReferences( + _cb, + mi, + cc, + cr, + cop, + Cura_AssociatedPowerManagementService_ClassName, + assocClass, + role, + properties); +} + +static CMPIStatus Cura_AssociatedPowerManagementServiceReferenceNames( + CMPIAssociationMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char* assocClass, + const char* role) +{ + if (!assocClass) { + assocClass = "Cura_AssociatedPowerManagementService"; + } + + return KDefaultReferenceNames( + _cb, + mi, + cc, + cr, + cop, + Cura_AssociatedPowerManagementService_ClassName, + assocClass, + role); +} + +CMInstanceMIStub( + Cura_AssociatedPowerManagementService, + Cura_AssociatedPowerManagementService, + _cb, + Cura_AssociatedPowerManagementServiceInitialize(&mi)) + +CMAssociationMIStub( + Cura_AssociatedPowerManagementService, + Cura_AssociatedPowerManagementService, + _cb, + Cura_AssociatedPowerManagementServiceAssociationInitialize(&mi)) + +KONKRET_REGISTRATION( + "root/cimv2", + "Cura_AssociatedPowerManagementService", + "Cura_AssociatedPowerManagementService", + "instance association") diff --git a/src/power/Cura_ConcreteJobProvider.c b/src/power/Cura_ConcreteJobProvider.c new file mode 100644 index 0000000..cf919d4 --- /dev/null +++ b/src/power/Cura_ConcreteJobProvider.c @@ -0,0 +1,205 @@ +#include +#include +#include "Cura_ConcreteJob.h" +#include "globals.h" + +static const CMPIBroker* _cb = NULL; + +#include "power.h" + +static void Cura_ConcreteJobInitializeInstance(CMPIInstanceMI *mi) +{ + mi->hdl = power_ref(_cb); +} + +static void Cura_ConcreteJobInitializeMethod(CMPIMethodMI *mi) +{ + mi->hdl = power_ref(_cb); +} + +static CMPIStatus Cura_ConcreteJobCleanup( + CMPIInstanceMI* mi, + const CMPIContext* cc, + CMPIBoolean term) +{ + if (power_get_jobs(mi->hdl) != NULL) { + // We have jobs running -> do not unload + CMReturn(CMPI_RC_DO_NOT_UNLOAD); + } + power_unref(mi->hdl); + CMReturn(CMPI_RC_OK); +} + +static CMPIStatus Cura_ConcreteJobEnumInstanceNames( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop) +{ + return KDefaultEnumerateInstanceNames( + _cb, mi, cc, cr, cop); +} + +static CMPIStatus Cura_ConcreteJobEnumInstances( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char** properties) +{ + CMPIStatus status; + const char *ns = KNameSpace(cop); + + PowerStateChangeJob *powerStateChangeJob; + GList *plist = power_get_jobs(mi->hdl); + + while (plist) { + powerStateChangeJob = plist->data; + Cura_ConcreteJob concreteJob; + Cura_ConcreteJob_Init(&concreteJob, _cb, ns); + Cura_ConcreteJob_Set_InstanceID(&concreteJob, "Cura_PowerStateChange_ConcreteJob:123"); // TODO: unique ID + Cura_ConcreteJob_Set_JobState(&concreteJob, job_state(powerStateChangeJob)); + Cura_ConcreteJob_Set_TimeOfLastStateChange(&concreteJob, CMNewDateTimeFromBinary(_cb, ((uint64_t) job_timeOfLastChange(powerStateChangeJob)) * 1000000, 0, &status)); + //Cura_ConcreteJob_Set_ + KReturnInstance(cr, concreteJob); + plist = g_list_next(plist); + } + + CMReturn(CMPI_RC_OK); +} + +static CMPIStatus Cura_ConcreteJobGetInstance( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char** properties) +{ + return KDefaultGetInstance( + _cb, mi, cc, cr, cop, properties); +} + +static CMPIStatus Cura_ConcreteJobCreateInstance( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const CMPIInstance* ci) +{ + + CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); +} + +static CMPIStatus Cura_ConcreteJobModifyInstance( + 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 Cura_ConcreteJobDeleteInstance( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop) +{ + CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); +} + +static CMPIStatus Cura_ConcreteJobExecQuery( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char* lang, + const char* query) +{ + CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); +} + +CMInstanceMIStub( + Cura_ConcreteJob, + Cura_ConcreteJob, + _cb, + Cura_ConcreteJobInitializeInstance(&mi)) + +static CMPIStatus Cura_ConcreteJobMethodCleanup( + CMPIMethodMI* mi, + const CMPIContext* cc, + CMPIBoolean term) +{ + power_unref(mi->hdl); + CMReturn(CMPI_RC_OK); +} + +static CMPIStatus Cura_ConcreteJobInvokeMethod( + CMPIMethodMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char* meth, + const CMPIArgs* in, + CMPIArgs* out) +{ + return Cura_ConcreteJob_DispatchMethod( + _cb, mi, cc, cr, cop, meth, in, out); +} + +CMMethodMIStub( + Cura_ConcreteJob, + Cura_ConcreteJob, + _cb, + Cura_ConcreteJobInitializeMethod(&mi)) + +KUint32 Cura_ConcreteJob_KillJob( + const CMPIBroker* cb, + CMPIMethodMI* mi, + const CMPIContext* context, + const Cura_ConcreteJobRef* self, + const KBoolean* DeleteOnKill, + CMPIStatus* status) +{ + KUint32 result = KUINT32_INIT; + + KSetStatus(status, ERR_NOT_SUPPORTED); + return result; +} + +KUint32 Cura_ConcreteJob_RequestStateChange( + const CMPIBroker* cb, + CMPIMethodMI* mi, + const CMPIContext* context, + const Cura_ConcreteJobRef* self, + const KUint16* RequestedState, + const KDateTime* TimeoutPeriod, + CMPIStatus* status) +{ + KUint32 result = KUINT32_INIT; + + KSetStatus(status, ERR_NOT_SUPPORTED); + return result; +} + +KUint32 Cura_ConcreteJob_GetError( + const CMPIBroker* cb, + CMPIMethodMI* mi, + const CMPIContext* context, + const Cura_ConcreteJobRef* self, + KString* Error, + CMPIStatus* status) +{ + KUint32 result = KUINT32_INIT; + + KSetStatus(status, ERR_NOT_SUPPORTED); + return result; +} + +KONKRET_REGISTRATION( + "root/cimv2", + "Cura_ConcreteJob", + "Cura_ConcreteJob", + "instance method") diff --git a/src/power/Cura_ElementCapabilitiesProvider.c b/src/power/Cura_ElementCapabilitiesProvider.c new file mode 100644 index 0000000..0208630 --- /dev/null +++ b/src/power/Cura_ElementCapabilitiesProvider.c @@ -0,0 +1,224 @@ +#include +#include "Cura_ElementCapabilities.h" +#include "globals.h" + +static const CMPIBroker* _cb; + +static void Cura_ElementCapabilitiesInitialize() +{ +} + +static CMPIStatus Cura_ElementCapabilitiesCleanup( + CMPIInstanceMI* mi, + const CMPIContext* cc, + CMPIBoolean term) +{ + CMReturn(CMPI_RC_OK); +} + +static CMPIStatus Cura_ElementCapabilitiesEnumInstanceNames( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop) +{ + return KDefaultEnumerateInstanceNames( + _cb, mi, cc, cr, cop); +} + +static CMPIStatus Cura_ElementCapabilitiesEnumInstances( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char** properties) +{ + const char *ns = KNameSpace(cop); + + Cura_ElementCapabilities w; + Cura_ElementCapabilities_Init(&w, _cb, ns); + + Cura_PowerManagementServiceRef powerManagementServiceRef; + Cura_PowerManagementServiceRef_Init(&powerManagementServiceRef, _cb, ns); + Cura_PowerManagementServiceRef_Set_Name(&powerManagementServiceRef, get_system_name()); + Cura_PowerManagementServiceRef_Set_SystemName(&powerManagementServiceRef, get_system_name()); + Cura_PowerManagementServiceRef_Set_CreationClassName(&powerManagementServiceRef, "Cura_PowerManagementService"); + Cura_PowerManagementServiceRef_Set_SystemCreationClassName(&powerManagementServiceRef, get_system_creation_class_name()); + + Cura_ElementCapabilities_Set_ManagedElement(&w, &powerManagementServiceRef); + + Cura_PowerManagementCapabilitiesRef powerManagementCapabilitiesRef; + Cura_PowerManagementCapabilitiesRef_Init(&powerManagementCapabilitiesRef, _cb, ns); + Cura_PowerManagementCapabilitiesRef_Set_InstanceID(&powerManagementCapabilitiesRef, "RedHat:PowerManagementCapabilities"); + + Cura_ElementCapabilities_Set_Capabilities(&w, &powerManagementCapabilitiesRef); + + KReturnInstance(cr, w); + CMReturn(CMPI_RC_OK); +} + +static CMPIStatus Cura_ElementCapabilitiesGetInstance( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char** properties) +{ + return KDefaultGetInstance( + _cb, mi, cc, cr, cop, properties); +} + +static CMPIStatus Cura_ElementCapabilitiesCreateInstance( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const CMPIInstance* ci) +{ + CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); +} + +static CMPIStatus Cura_ElementCapabilitiesModifyInstance( + 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 Cura_ElementCapabilitiesDeleteInstance( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop) +{ + CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); +} + +static CMPIStatus Cura_ElementCapabilitiesExecQuery( + 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 Cura_ElementCapabilitiesAssociationCleanup( + CMPIAssociationMI* mi, + const CMPIContext* cc, + CMPIBoolean term) +{ + CMReturn(CMPI_RC_OK); +} + +static CMPIStatus Cura_ElementCapabilitiesAssociators( + 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, + Cura_ElementCapabilities_ClassName, + assocClass, + resultClass, + role, + resultRole, + properties); +} + +static CMPIStatus Cura_ElementCapabilitiesAssociatorNames( + 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, + Cura_ElementCapabilities_ClassName, + assocClass, + resultClass, + role, + resultRole); +} + +static CMPIStatus Cura_ElementCapabilitiesReferences( + 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, + Cura_ElementCapabilities_ClassName, + assocClass, + role, + properties); +} + +static CMPIStatus Cura_ElementCapabilitiesReferenceNames( + CMPIAssociationMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char* assocClass, + const char* role) +{ + return KDefaultReferenceNames( + _cb, + mi, + cc, + cr, + cop, + Cura_ElementCapabilities_ClassName, + assocClass, + role); +} + +CMInstanceMIStub( + Cura_ElementCapabilities, + Cura_ElementCapabilities, + _cb, + Cura_ElementCapabilitiesInitialize()) + +CMAssociationMIStub( + Cura_ElementCapabilities, + Cura_ElementCapabilities, + _cb, + Cura_ElementCapabilitiesInitialize()) + +KONKRET_REGISTRATION( + "root/cimv2", + "Cura_ElementCapabilities", + "Cura_ElementCapabilities", + "instance association") diff --git a/src/power/Cura_HostedServiceProvider.c b/src/power/Cura_HostedServiceProvider.c new file mode 100644 index 0000000..d2023e9 --- /dev/null +++ b/src/power/Cura_HostedServiceProvider.c @@ -0,0 +1,229 @@ + +#include +#include +#include "Cura_HostedService.h" + +#include "globals.h" + +static const CMPIBroker* _cb; + +static void Cura_HostedServiceInitialize() +{ +} + +static CMPIStatus Cura_HostedServiceCleanup( + CMPIInstanceMI* mi, + const CMPIContext* cc, + CMPIBoolean term) +{ + CMReturn(CMPI_RC_OK); +} + +static CMPIStatus Cura_HostedServiceEnumInstanceNames( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop) +{ + return KDefaultEnumerateInstanceNames( + _cb, mi, cc, cr, cop); +} + +static CMPIStatus Cura_HostedServiceEnumInstances( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char** properties) +{ + CMPIStatus rc; + const char *ns = KNameSpace(cop); + + Cura_HostedService w; + Cura_HostedService_Init(&w, _cb, ns); + + CIM_ComputerSystemRef computerSystemRef; + CIM_ComputerSystemRef_Init(&computerSystemRef, _cb, ns); + CIM_ComputerSystemRef_Set_Name(&computerSystemRef, get_system_name()); + CIM_ComputerSystemRef_Set_CreationClassName(&computerSystemRef, get_system_creation_class_name()); + CMPIObjectPath *computerSystemOP = CIM_ComputerSystemRef_ToObjectPath(&computerSystemRef, &rc); + computerSystemOP->ft->setClassName(computerSystemOP, get_system_creation_class_name()); + Cura_HostedService_SetObjectPath_Antecedent(&w, computerSystemOP); + + Cura_PowerManagementServiceRef powerManagementServiceRef; + Cura_PowerManagementServiceRef_Init(&powerManagementServiceRef, _cb, ns); + Cura_PowerManagementServiceRef_Set_Name(&powerManagementServiceRef, get_system_name()); + Cura_PowerManagementServiceRef_Set_SystemName(&powerManagementServiceRef, get_system_name()); + Cura_PowerManagementServiceRef_Set_CreationClassName(&powerManagementServiceRef, "Cura_PowerManagementService"); + Cura_PowerManagementServiceRef_Set_SystemCreationClassName(&powerManagementServiceRef, get_system_creation_class_name()); + Cura_HostedService_Set_Dependent(&w, &powerManagementServiceRef); + + KReturnInstance(cr, w); + CMReturn(CMPI_RC_OK); +} + +static CMPIStatus Cura_HostedServiceGetInstance( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char** properties) +{ + return KDefaultGetInstance( + _cb, mi, cc, cr, cop, properties); +} + +static CMPIStatus Cura_HostedServiceCreateInstance( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const CMPIInstance* ci) +{ + CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); +} + +static CMPIStatus Cura_HostedServiceModifyInstance( + 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 Cura_HostedServiceDeleteInstance( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop) +{ + CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); +} + +static CMPIStatus Cura_HostedServiceExecQuery( + 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 Cura_HostedServiceAssociationCleanup( + CMPIAssociationMI* mi, + const CMPIContext* cc, + CMPIBoolean term) +{ + CMReturn(CMPI_RC_OK); +} + +static CMPIStatus Cura_HostedServiceAssociators( + 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, + Cura_HostedService_ClassName, + assocClass, + resultClass, + role, + resultRole, + properties); +} + +static CMPIStatus Cura_HostedServiceAssociatorNames( + 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, + Cura_HostedService_ClassName, + assocClass, + resultClass, + role, + resultRole); +} + +static CMPIStatus Cura_HostedServiceReferences( + 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, + Cura_HostedService_ClassName, + assocClass, + role, + properties); +} + +static CMPIStatus Cura_HostedServiceReferenceNames( + CMPIAssociationMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char* assocClass, + const char* role) +{ + return KDefaultReferenceNames( + _cb, + mi, + cc, + cr, + cop, + Cura_HostedService_ClassName, + assocClass, + role); +} + +CMInstanceMIStub( + Cura_HostedService, + Cura_HostedService, + _cb, + Cura_HostedServiceInitialize()) + +CMAssociationMIStub( + Cura_HostedService, + Cura_HostedService, + _cb, + Cura_HostedServiceInitialize()) + +KONKRET_REGISTRATION( + "root/cimv2", + "Cura_HostedService", + "Cura_HostedService", + "instance association") diff --git a/src/power/Cura_PowerManagementCapabilitiesProvider.c b/src/power/Cura_PowerManagementCapabilitiesProvider.c new file mode 100644 index 0000000..5e7f4fc --- /dev/null +++ b/src/power/Cura_PowerManagementCapabilitiesProvider.c @@ -0,0 +1,162 @@ +#include +#include "Cura_PowerManagementCapabilities.h" + +#include "power.h" + +static const CMPIBroker* _cb = NULL; + +static void Cura_PowerManagementCapabilitiesInitialize(CMPIInstanceMI *mi) +{ + mi->hdl = power_ref(_cb); +} + +static void Cura_PowerManagementCapabilitiesInitializeMethod(CMPIMethodMI *mi) +{ + mi->hdl = power_ref(_cb); +} + +static CMPIStatus Cura_PowerManagementCapabilitiesCleanup( + CMPIInstanceMI* mi, + const CMPIContext* cc, + CMPIBoolean term) +{ + power_unref(mi->hdl); + mi->hdl = NULL; + CMReturn(CMPI_RC_OK); +} + +static CMPIStatus Cura_PowerManagementCapabilitiesEnumInstanceNames( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop) +{ + return KDefaultEnumerateInstanceNames( + _cb, mi, cc, cr, cop); +} + +static CMPIStatus Cura_PowerManagementCapabilitiesEnumInstances( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char** properties) +{ + const char *ns = KNameSpace(cop); + + Cura_PowerManagementCapabilities w; + Cura_PowerManagementCapabilities_Init(&w, _cb, ns); + // TODO: make it unique + Cura_PowerManagementCapabilities_Set_InstanceID(&w, "Linux:PowerManagementCapabilities"); + Cura_PowerManagementCapabilities_Set_ElementName(&w, "Linux:PowerManagementCapabilities"); + Cura_PowerManagementCapabilities_Set_Caption(&w, "Linux:PowerManagementCapabilities"); + + int count; + unsigned short *list = power_available_requested_power_states(mi->hdl, &count); + Cura_PowerManagementCapabilities_Init_PowerStatesSupported(&w, count); + for (int i = 0; i < count; i++) { + Cura_PowerManagementCapabilities_Set_PowerStatesSupported(&w, i, list[i]); + } + + // TODO: get this list dynamically from PowerStatesSupported (see SMASH) + Cura_PowerManagementCapabilities_Init_PowerChangeCapabilities(&w, 3); + Cura_PowerManagementCapabilities_Set_PowerChangeCapabilities(&w, 0, Cura_PowerManagementCapabilities_PowerChangeCapabilities_Power_State_Settable); + Cura_PowerManagementCapabilities_Set_PowerChangeCapabilities(&w, 1, Cura_PowerManagementCapabilities_PowerChangeCapabilities_Power_Cycling_Supported); + Cura_PowerManagementCapabilities_Set_PowerChangeCapabilities(&w, 2, Cura_PowerManagementCapabilities_PowerChangeCapabilities_Graceful_Shutdown_Supported); + KReturnInstance(cr, w); + CMReturn(CMPI_RC_OK); +} + +static CMPIStatus Cura_PowerManagementCapabilitiesGetInstance( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char** properties) +{ + return KDefaultGetInstance( + _cb, mi, cc, cr, cop, properties); +} + +static CMPIStatus Cura_PowerManagementCapabilitiesCreateInstance( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const CMPIInstance* ci) +{ + CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); +} + +static CMPIStatus Cura_PowerManagementCapabilitiesModifyInstance( + 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 Cura_PowerManagementCapabilitiesDeleteInstance( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop) +{ + CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); +} + +static CMPIStatus Cura_PowerManagementCapabilitiesExecQuery( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char* lang, + const char* query) +{ + CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); +} + +CMInstanceMIStub( + Cura_PowerManagementCapabilities, + Cura_PowerManagementCapabilities, + _cb, + Cura_PowerManagementCapabilitiesInitialize(&mi)) + +static CMPIStatus Cura_PowerManagementCapabilitiesMethodCleanup( + CMPIMethodMI* mi, + const CMPIContext* cc, + CMPIBoolean term) +{ + power_unref(mi->hdl); + mi->hdl = NULL; + + CMReturn(CMPI_RC_OK); +} + +static CMPIStatus Cura_PowerManagementCapabilitiesInvokeMethod( + CMPIMethodMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char* meth, + const CMPIArgs* in, + CMPIArgs* out) +{ + return Cura_PowerManagementCapabilities_DispatchMethod( + _cb, mi, cc, cr, cop, meth, in, out); +} + +CMMethodMIStub( + Cura_PowerManagementCapabilities, + Cura_PowerManagementCapabilities, + _cb, + Cura_PowerManagementCapabilitiesInitializeMethod(&mi)) + +KONKRET_REGISTRATION( + "root/cimv2", + "Cura_PowerManagementCapabilities", + "Cura_PowerManagementCapabilities", + "instance method") diff --git a/src/power/Cura_PowerManagementServiceProvider.c b/src/power/Cura_PowerManagementServiceProvider.c new file mode 100644 index 0000000..dcdb2bc --- /dev/null +++ b/src/power/Cura_PowerManagementServiceProvider.c @@ -0,0 +1,268 @@ + +#include "Cura_PowerManagementService.h" + +#include "power.h" +#include "globals.h" + +static const CMPIBroker* _cb = NULL; + +static void Cura_PowerManagementServiceInitialize(CMPIInstanceMI *mi) +{ + mi->hdl = power_ref(_cb); +} + +static void Cura_PowerManagementServiceMethodInitialize(CMPIMethodMI *mi) +{ + mi->hdl = power_ref(_cb); +} + + +static CMPIStatus Cura_PowerManagementServiceCleanup( + CMPIInstanceMI* mi, + const CMPIContext* cc, + CMPIBoolean term) +{ + power_unref(mi->hdl); + mi->hdl = NULL; + CMReturn(CMPI_RC_OK); +} + +static CMPIStatus Cura_PowerManagementServiceEnumInstanceNames( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop) +{ + return KDefaultEnumerateInstanceNames( + _cb, mi, cc, cr, cop); +} + +static CMPIStatus Cura_PowerManagementServiceEnumInstances( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char** properties) +{ + Cura_PowerManagementService w; + + Cura_PowerManagementService_Init(&w, _cb, KNameSpace(cop)); + Cura_PowerManagementService_Set_CreationClassName(&w, "Cura_PowerManagementService"); + Cura_PowerManagementService_Set_Name(&w, get_system_name()); + Cura_PowerManagementService_Set_SystemCreationClassName(&w, get_system_creation_class_name()); + Cura_PowerManagementService_Set_SystemName(&w, get_system_name()); + + /* EnabledState is an integer enumeration that indicates the enabled + * and disabled states of an element. It can also indicate the transitions + * between these requested states. + */ + Cura_PowerManagementService_Set_EnabledState(&w, Cura_PowerManagementService_EnabledDefault_Enabled); + + + /* RequestedState is an integer enumeration that indicates the last + * requested or desired state for the element, irrespective of the mechanism + * through which it was requested. The actual state of the element is + * represented by EnabledState. This property is provided to compare the + * last requested and current enabled or disabled states. + */ + Cura_PowerManagementService_Set_RequestedState(&w, Cura_PowerManagementService_RequestedState_No_Change); + + Cura_PowerManagementService_Init_AvailableRequestedStates(&w, 2); + Cura_PowerManagementService_Set_AvailableRequestedStates(&w, 0, 2); // Enabled + Cura_PowerManagementService_Set_AvailableRequestedStates(&w, 1, 3); // Disabled + + + Cura_PowerManagementService_Print(&w, stderr); + + KReturnInstance(cr, w); + CMReturn(CMPI_RC_OK); +} + +static CMPIStatus Cura_PowerManagementServiceGetInstance( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char** properties) +{ + return KDefaultGetInstance( + _cb, mi, cc, cr, cop, properties); +} + +static CMPIStatus Cura_PowerManagementServiceCreateInstance( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const CMPIInstance* ci) +{ + CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); +} + +static CMPIStatus Cura_PowerManagementServiceModifyInstance( + 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 Cura_PowerManagementServiceDeleteInstance( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop) +{ + CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); +} + +static CMPIStatus Cura_PowerManagementServiceExecQuery( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char* lang, + const char* query) +{ + CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); +} + +CMInstanceMIStub( + Cura_PowerManagementService, + Cura_PowerManagementService, + _cb, + Cura_PowerManagementServiceInitialize(&mi)) + +static CMPIStatus Cura_PowerManagementServiceMethodCleanup( + CMPIMethodMI* mi, + const CMPIContext* cc, + CMPIBoolean term) +{ + power_unref(mi->hdl); + mi->hdl = NULL; + CMReturn(CMPI_RC_OK); +} + +static CMPIStatus Cura_PowerManagementServiceInvokeMethod( + CMPIMethodMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char* meth, + const CMPIArgs* in, + CMPIArgs* out) +{ + return Cura_PowerManagementService_DispatchMethod( + _cb, mi, cc, cr, cop, meth, in, out); +} + +CMMethodMIStub( + Cura_PowerManagementService, + Cura_PowerManagementService, + _cb, + Cura_PowerManagementServiceMethodInitialize(&mi)) + +KUint32 Cura_PowerManagementService_RequestStateChange( + const CMPIBroker* cb, + CMPIMethodMI* mi, + const CMPIContext* context, + const Cura_PowerManagementServiceRef* self, + const KUint16* RequestedState, + KRef* Job, + const KDateTime* TimeoutPeriod, + CMPIStatus* status) +{ + KUint32 result = KUINT32_INIT; + + KSetStatus(status, ERR_NOT_SUPPORTED); + return result; + +} + +KUint32 Cura_PowerManagementService_StartService( + const CMPIBroker* cb, + CMPIMethodMI* mi, + const CMPIContext* context, + const Cura_PowerManagementServiceRef* self, + CMPIStatus* status) +{ + KUint32 result = KUINT32_INIT; + + KSetStatus(status, ERR_NOT_SUPPORTED); + return result; +} + +KUint32 Cura_PowerManagementService_StopService( + const CMPIBroker* cb, + CMPIMethodMI* mi, + const CMPIContext* context, + const Cura_PowerManagementServiceRef* self, + CMPIStatus* status) +{ + KUint32 result = KUINT32_INIT; + + KSetStatus(status, ERR_NOT_SUPPORTED); + return result; +} + +KUint32 Cura_PowerManagementService_SetPowerState( + const CMPIBroker* cb, + CMPIMethodMI* mi, + const CMPIContext* context, + const Cura_PowerManagementServiceRef* self, + const KUint16* PowerState, + const KRef* ManagedElement, + const KDateTime* Time, + CMPIStatus* status) +{ + KUint32 result = KUINT32_INIT; + + KSetStatus(status, ERR_NOT_SUPPORTED); + return result; +} + +KUint32 Cura_PowerManagementService_RequestPowerStateChange( + const CMPIBroker* cb, + CMPIMethodMI* mi, + const CMPIContext* context, + const Cura_PowerManagementServiceRef* self, + const KUint16* PowerState, + const KRef* ManagedElement, + const KDateTime* Time, + KRef* Job, + const KDateTime* TimeoutPeriod, + CMPIStatus* status) +{ + KUint32 result = KUINT32_INIT; + + if (Time->exists && Time->null && TimeoutPeriod->exists && TimeoutPeriod->null) { + /* SMASH says: The TimeoutPeriod and Time parameters shall not be + * supported for the same invocation of the RequestPowerStateChange( ) + * method. When the TimeoutPeriod and Time parameters are specified + * for the same method invocation, the method shall return a value of 2. + */ + KUint32_Set(&result, 2); + return result; + } + + // Time argument is not handled because we don't support powering on systems + + if (!PowerState->exists || PowerState->null) { + KSetStatus2(_cb, status, ERR_INVALID_PARAMETER, "PowerState argument is missing"); + return result; + } + power_request_power_state(mi->hdl, PowerState->value); + + KSetStatus(status, OK); + KUint32_Set(&result, 4096); + return result; +} + +KONKRET_REGISTRATION( + "root/cimv2", + "Cura_PowerManagementService", + "Cura_PowerManagementService", + "instance method") diff --git a/src/power/Linux_AssociatedPowerManagementServiceProvider.c b/src/power/Linux_AssociatedPowerManagementServiceProvider.c deleted file mode 100644 index d6d6454..0000000 --- a/src/power/Linux_AssociatedPowerManagementServiceProvider.c +++ /dev/null @@ -1,269 +0,0 @@ - -#include "Linux_AssociatedPowerManagementService.h" -#include "Linux_PowerManagementService.h" -#include "CIM_ComputerSystem.h" - -#include "power.h" - -#include "globals.h" - -static const CMPIBroker* _cb; - -static void Linux_AssociatedPowerManagementServiceInitialize(CMPIInstanceMI *mi) -{ - mi->hdl = power_ref(_cb); -} - -static void Linux_AssociatedPowerManagementServiceAssociationInitialize(CMPIAssociationMI *mi) -{ - mi->hdl = power_ref(_cb); -} - -static CMPIStatus Linux_AssociatedPowerManagementServiceCleanup( - CMPIInstanceMI* mi, - const CMPIContext* cc, - CMPIBoolean term) -{ - power_unref(mi->hdl); - mi->hdl = NULL; - CMReturn(CMPI_RC_OK); -} - -static CMPIStatus Linux_AssociatedPowerManagementServiceEnumInstanceNames( - CMPIInstanceMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop) -{ - return KDefaultEnumerateInstanceNames( - _cb, mi, cc, cr, cop); -} - -static CMPIStatus Linux_AssociatedPowerManagementServiceEnumInstances( - CMPIInstanceMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop, - const char** properties) -{ - CMPIStatus rc; - const char *ns = KNameSpace(cop); - - Linux_AssociatedPowerManagementService w; - Linux_AssociatedPowerManagementService_Init(&w, _cb, ns); - - CIM_ComputerSystemRef computerSystemRef; - CIM_ComputerSystemRef_Init(&computerSystemRef, _cb, ns); - CIM_ComputerSystemRef_Set_Name(&computerSystemRef, get_system_name()); - CIM_ComputerSystemRef_Set_CreationClassName(&computerSystemRef, get_system_creation_class_name()); - CMPIObjectPath *computerSystemOP = CIM_ComputerSystemRef_ToObjectPath(&computerSystemRef, &rc); - computerSystemOP->ft->setClassName(computerSystemOP, get_system_creation_class_name()); - Linux_AssociatedPowerManagementService_SetObjectPath_UserOfService(&w, computerSystemOP); - - Linux_PowerManagementServiceRef powerManagementServiceRef; - Linux_PowerManagementServiceRef_Init(&powerManagementServiceRef, _cb, ns); - Linux_PowerManagementServiceRef_Set_Name(&powerManagementServiceRef, get_system_name()); - Linux_PowerManagementServiceRef_Set_SystemName(&powerManagementServiceRef, get_system_name()); - Linux_PowerManagementServiceRef_Set_CreationClassName(&powerManagementServiceRef, "Linux_PowerManagementService"); - Linux_PowerManagementServiceRef_Set_SystemCreationClassName(&powerManagementServiceRef, get_system_creation_class_name()); - Linux_AssociatedPowerManagementService_Set_ServiceProvided(&w, &powerManagementServiceRef); - - int count; - unsigned short *list = power_available_requested_power_states(mi->hdl, &count); - Linux_AssociatedPowerManagementService_Init_AvailableRequestedPowerStates(&w, count); - for (int i = 0; i < count; i++) { - Linux_AssociatedPowerManagementService_Set_AvailableRequestedPowerStates(&w, i, list[i]); - } - - Linux_AssociatedPowerManagementService_Set_TransitioningToPowerState(&w, power_transitioning_to_power_state(mi->hdl)); - Linux_AssociatedPowerManagementService_Set_PowerState(&w, 2); - Linux_AssociatedPowerManagementService_Set_RequestedPowerState(&w, power_requested_power_state(mi->hdl)); - - KReturnInstance(cr, w); - CMReturn(CMPI_RC_OK); -} - -static CMPIStatus Linux_AssociatedPowerManagementServiceGetInstance( - CMPIInstanceMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop, - const char** properties) -{ - return KDefaultGetInstance( - _cb, mi, cc, cr, cop, properties); -} - -static CMPIStatus Linux_AssociatedPowerManagementServiceCreateInstance( - CMPIInstanceMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop, - const CMPIInstance* ci) -{ - CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); -} - -static CMPIStatus Linux_AssociatedPowerManagementServiceModifyInstance( - 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 Linux_AssociatedPowerManagementServiceDeleteInstance( - CMPIInstanceMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop) -{ - CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); -} - -static CMPIStatus Linux_AssociatedPowerManagementServiceExecQuery( - 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 Linux_AssociatedPowerManagementServiceAssociationCleanup( - CMPIAssociationMI* mi, - const CMPIContext* cc, - CMPIBoolean term) -{ - power_unref(mi->hdl); - mi->hdl = NULL; - - CMReturn(CMPI_RC_OK); -} - -static CMPIStatus Linux_AssociatedPowerManagementServiceAssociators( - 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) -{ - if (!assocClass) { - assocClass = "Linux_AssociatedPowerManagementService"; - } - - return KDefaultAssociators( - _cb, - mi, - cc, - cr, - cop, - Linux_AssociatedPowerManagementService_ClassName, - assocClass, - resultClass, - role, - resultRole, - properties); -} - -static CMPIStatus Linux_AssociatedPowerManagementServiceAssociatorNames( - CMPIAssociationMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop, - const char* assocClass, - const char* resultClass, - const char* role, - const char* resultRole) -{ - if (!assocClass) { - assocClass = "Linux_AssociatedPowerManagementService"; - } - - return KDefaultAssociatorNames( - _cb, - mi, - cc, - cr, - cop, - Linux_AssociatedPowerManagementService_ClassName, - assocClass, - resultClass, - role, - resultRole); -} - -static CMPIStatus Linux_AssociatedPowerManagementServiceReferences( - CMPIAssociationMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop, - const char* assocClass, - const char* role, - const char** properties) -{ - if (!assocClass) { - assocClass = "Linux_AssociatedPowerManagementService"; - } - - return KDefaultReferences( - _cb, - mi, - cc, - cr, - cop, - Linux_AssociatedPowerManagementService_ClassName, - assocClass, - role, - properties); -} - -static CMPIStatus Linux_AssociatedPowerManagementServiceReferenceNames( - CMPIAssociationMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop, - const char* assocClass, - const char* role) -{ - if (!assocClass) { - assocClass = "Linux_AssociatedPowerManagementService"; - } - - return KDefaultReferenceNames( - _cb, - mi, - cc, - cr, - cop, - Linux_AssociatedPowerManagementService_ClassName, - assocClass, - role); -} - -CMInstanceMIStub( - Linux_AssociatedPowerManagementService, - Linux_AssociatedPowerManagementService, - _cb, - Linux_AssociatedPowerManagementServiceInitialize(&mi)) - -CMAssociationMIStub( - Linux_AssociatedPowerManagementService, - Linux_AssociatedPowerManagementService, - _cb, - Linux_AssociatedPowerManagementServiceAssociationInitialize(&mi)) - -KONKRET_REGISTRATION( - "root/cimv2", - "Linux_AssociatedPowerManagementService", - "Linux_AssociatedPowerManagementService", - "instance association") diff --git a/src/power/Linux_ConcreteJobProvider.c b/src/power/Linux_ConcreteJobProvider.c deleted file mode 100644 index 96176fa..0000000 --- a/src/power/Linux_ConcreteJobProvider.c +++ /dev/null @@ -1,205 +0,0 @@ -#include -#include -#include "Linux_ConcreteJob.h" -#include "globals.h" - -static const CMPIBroker* _cb = NULL; - -#include "power.h" - -static void Linux_ConcreteJobInitializeInstance(CMPIInstanceMI *mi) -{ - mi->hdl = power_ref(_cb); -} - -static void Linux_ConcreteJobInitializeMethod(CMPIMethodMI *mi) -{ - mi->hdl = power_ref(_cb); -} - -static CMPIStatus Linux_ConcreteJobCleanup( - CMPIInstanceMI* mi, - const CMPIContext* cc, - CMPIBoolean term) -{ - if (power_get_jobs(mi->hdl) != NULL) { - // We have jobs running -> do not unload - CMReturn(CMPI_RC_DO_NOT_UNLOAD); - } - power_unref(mi->hdl); - CMReturn(CMPI_RC_OK); -} - -static CMPIStatus Linux_ConcreteJobEnumInstanceNames( - CMPIInstanceMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop) -{ - return KDefaultEnumerateInstanceNames( - _cb, mi, cc, cr, cop); -} - -static CMPIStatus Linux_ConcreteJobEnumInstances( - CMPIInstanceMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop, - const char** properties) -{ - CMPIStatus status; - const char *ns = KNameSpace(cop); - - PowerStateChangeJob *powerStateChangeJob; - GList *plist = power_get_jobs(mi->hdl); - - while (plist) { - powerStateChangeJob = plist->data; - Linux_ConcreteJob concreteJob; - Linux_ConcreteJob_Init(&concreteJob, _cb, ns); - Linux_ConcreteJob_Set_InstanceID(&concreteJob, "Linux_PowerStateChange_ConcreteJob:123"); // TODO: unique ID - Linux_ConcreteJob_Set_JobState(&concreteJob, job_state(powerStateChangeJob)); - Linux_ConcreteJob_Set_TimeOfLastStateChange(&concreteJob, CMNewDateTimeFromBinary(_cb, ((uint64_t) job_timeOfLastChange(powerStateChangeJob)) * 1000000, 0, &status)); - //Linux_ConcreteJob_Set_ - KReturnInstance(cr, concreteJob); - plist = g_list_next(plist); - } - - CMReturn(CMPI_RC_OK); -} - -static CMPIStatus Linux_ConcreteJobGetInstance( - CMPIInstanceMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop, - const char** properties) -{ - return KDefaultGetInstance( - _cb, mi, cc, cr, cop, properties); -} - -static CMPIStatus Linux_ConcreteJobCreateInstance( - CMPIInstanceMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop, - const CMPIInstance* ci) -{ - - CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); -} - -static CMPIStatus Linux_ConcreteJobModifyInstance( - 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 Linux_ConcreteJobDeleteInstance( - CMPIInstanceMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop) -{ - CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); -} - -static CMPIStatus Linux_ConcreteJobExecQuery( - CMPIInstanceMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop, - const char* lang, - const char* query) -{ - CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); -} - -CMInstanceMIStub( - Linux_ConcreteJob, - Linux_ConcreteJob, - _cb, - Linux_ConcreteJobInitializeInstance(&mi)) - -static CMPIStatus Linux_ConcreteJobMethodCleanup( - CMPIMethodMI* mi, - const CMPIContext* cc, - CMPIBoolean term) -{ - power_unref(mi->hdl); - CMReturn(CMPI_RC_OK); -} - -static CMPIStatus Linux_ConcreteJobInvokeMethod( - CMPIMethodMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop, - const char* meth, - const CMPIArgs* in, - CMPIArgs* out) -{ - return Linux_ConcreteJob_DispatchMethod( - _cb, mi, cc, cr, cop, meth, in, out); -} - -CMMethodMIStub( - Linux_ConcreteJob, - Linux_ConcreteJob, - _cb, - Linux_ConcreteJobInitializeMethod(&mi)) - -KUint32 Linux_ConcreteJob_KillJob( - const CMPIBroker* cb, - CMPIMethodMI* mi, - const CMPIContext* context, - const Linux_ConcreteJobRef* self, - const KBoolean* DeleteOnKill, - CMPIStatus* status) -{ - KUint32 result = KUINT32_INIT; - - KSetStatus(status, ERR_NOT_SUPPORTED); - return result; -} - -KUint32 Linux_ConcreteJob_RequestStateChange( - const CMPIBroker* cb, - CMPIMethodMI* mi, - const CMPIContext* context, - const Linux_ConcreteJobRef* self, - const KUint16* RequestedState, - const KDateTime* TimeoutPeriod, - CMPIStatus* status) -{ - KUint32 result = KUINT32_INIT; - - KSetStatus(status, ERR_NOT_SUPPORTED); - return result; -} - -KUint32 Linux_ConcreteJob_GetError( - const CMPIBroker* cb, - CMPIMethodMI* mi, - const CMPIContext* context, - const Linux_ConcreteJobRef* self, - KString* Error, - CMPIStatus* status) -{ - KUint32 result = KUINT32_INIT; - - KSetStatus(status, ERR_NOT_SUPPORTED); - return result; -} - -KONKRET_REGISTRATION( - "root/cimv2", - "Linux_ConcreteJob", - "Linux_ConcreteJob", - "instance method") diff --git a/src/power/Linux_ElementCapabilitiesProvider.c b/src/power/Linux_ElementCapabilitiesProvider.c deleted file mode 100644 index ee09969..0000000 --- a/src/power/Linux_ElementCapabilitiesProvider.c +++ /dev/null @@ -1,224 +0,0 @@ -#include -#include "Linux_ElementCapabilities.h" -#include "globals.h" - -static const CMPIBroker* _cb; - -static void Linux_ElementCapabilitiesInitialize() -{ -} - -static CMPIStatus Linux_ElementCapabilitiesCleanup( - CMPIInstanceMI* mi, - const CMPIContext* cc, - CMPIBoolean term) -{ - CMReturn(CMPI_RC_OK); -} - -static CMPIStatus Linux_ElementCapabilitiesEnumInstanceNames( - CMPIInstanceMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop) -{ - return KDefaultEnumerateInstanceNames( - _cb, mi, cc, cr, cop); -} - -static CMPIStatus Linux_ElementCapabilitiesEnumInstances( - CMPIInstanceMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop, - const char** properties) -{ - const char *ns = KNameSpace(cop); - - Linux_ElementCapabilities w; - Linux_ElementCapabilities_Init(&w, _cb, ns); - - Linux_PowerManagementServiceRef powerManagementServiceRef; - Linux_PowerManagementServiceRef_Init(&powerManagementServiceRef, _cb, ns); - Linux_PowerManagementServiceRef_Set_Name(&powerManagementServiceRef, get_system_name()); - Linux_PowerManagementServiceRef_Set_SystemName(&powerManagementServiceRef, get_system_name()); - Linux_PowerManagementServiceRef_Set_CreationClassName(&powerManagementServiceRef, "Linux_PowerManagementService"); - Linux_PowerManagementServiceRef_Set_SystemCreationClassName(&powerManagementServiceRef, get_system_creation_class_name()); - - Linux_ElementCapabilities_Set_ManagedElement(&w, &powerManagementServiceRef); - - Linux_PowerManagementCapabilitiesRef powerManagementCapabilitiesRef; - Linux_PowerManagementCapabilitiesRef_Init(&powerManagementCapabilitiesRef, _cb, ns); - Linux_PowerManagementCapabilitiesRef_Set_InstanceID(&powerManagementCapabilitiesRef, "RedHat:PowerManagementCapabilities"); - - Linux_ElementCapabilities_Set_Capabilities(&w, &powerManagementCapabilitiesRef); - - KReturnInstance(cr, w); - CMReturn(CMPI_RC_OK); -} - -static CMPIStatus Linux_ElementCapabilitiesGetInstance( - CMPIInstanceMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop, - const char** properties) -{ - return KDefaultGetInstance( - _cb, mi, cc, cr, cop, properties); -} - -static CMPIStatus Linux_ElementCapabilitiesCreateInstance( - CMPIInstanceMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop, - const CMPIInstance* ci) -{ - CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); -} - -static CMPIStatus Linux_ElementCapabilitiesModifyInstance( - 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 Linux_ElementCapabilitiesDeleteInstance( - CMPIInstanceMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop) -{ - CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); -} - -static CMPIStatus Linux_ElementCapabilitiesExecQuery( - 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 Linux_ElementCapabilitiesAssociationCleanup( - CMPIAssociationMI* mi, - const CMPIContext* cc, - CMPIBoolean term) -{ - CMReturn(CMPI_RC_OK); -} - -static CMPIStatus Linux_ElementCapabilitiesAssociators( - 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, - Linux_ElementCapabilities_ClassName, - assocClass, - resultClass, - role, - resultRole, - properties); -} - -static CMPIStatus Linux_ElementCapabilitiesAssociatorNames( - 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, - Linux_ElementCapabilities_ClassName, - assocClass, - resultClass, - role, - resultRole); -} - -static CMPIStatus Linux_ElementCapabilitiesReferences( - 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, - Linux_ElementCapabilities_ClassName, - assocClass, - role, - properties); -} - -static CMPIStatus Linux_ElementCapabilitiesReferenceNames( - CMPIAssociationMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop, - const char* assocClass, - const char* role) -{ - return KDefaultReferenceNames( - _cb, - mi, - cc, - cr, - cop, - Linux_ElementCapabilities_ClassName, - assocClass, - role); -} - -CMInstanceMIStub( - Linux_ElementCapabilities, - Linux_ElementCapabilities, - _cb, - Linux_ElementCapabilitiesInitialize()) - -CMAssociationMIStub( - Linux_ElementCapabilities, - Linux_ElementCapabilities, - _cb, - Linux_ElementCapabilitiesInitialize()) - -KONKRET_REGISTRATION( - "root/cimv2", - "Linux_ElementCapabilities", - "Linux_ElementCapabilities", - "instance association") diff --git a/src/power/Linux_HostedServiceProvider.c b/src/power/Linux_HostedServiceProvider.c deleted file mode 100644 index 7b50150..0000000 --- a/src/power/Linux_HostedServiceProvider.c +++ /dev/null @@ -1,229 +0,0 @@ - -#include -#include -#include "Linux_HostedService.h" - -#include "globals.h" - -static const CMPIBroker* _cb; - -static void Linux_HostedServiceInitialize() -{ -} - -static CMPIStatus Linux_HostedServiceCleanup( - CMPIInstanceMI* mi, - const CMPIContext* cc, - CMPIBoolean term) -{ - CMReturn(CMPI_RC_OK); -} - -static CMPIStatus Linux_HostedServiceEnumInstanceNames( - CMPIInstanceMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop) -{ - return KDefaultEnumerateInstanceNames( - _cb, mi, cc, cr, cop); -} - -static CMPIStatus Linux_HostedServiceEnumInstances( - CMPIInstanceMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop, - const char** properties) -{ - CMPIStatus rc; - const char *ns = KNameSpace(cop); - - Linux_HostedService w; - Linux_HostedService_Init(&w, _cb, ns); - - CIM_ComputerSystemRef computerSystemRef; - CIM_ComputerSystemRef_Init(&computerSystemRef, _cb, ns); - CIM_ComputerSystemRef_Set_Name(&computerSystemRef, get_system_name()); - CIM_ComputerSystemRef_Set_CreationClassName(&computerSystemRef, get_system_creation_class_name()); - CMPIObjectPath *computerSystemOP = CIM_ComputerSystemRef_ToObjectPath(&computerSystemRef, &rc); - computerSystemOP->ft->setClassName(computerSystemOP, get_system_creation_class_name()); - Linux_HostedService_SetObjectPath_Antecedent(&w, computerSystemOP); - - Linux_PowerManagementServiceRef powerManagementServiceRef; - Linux_PowerManagementServiceRef_Init(&powerManagementServiceRef, _cb, ns); - Linux_PowerManagementServiceRef_Set_Name(&powerManagementServiceRef, get_system_name()); - Linux_PowerManagementServiceRef_Set_SystemName(&powerManagementServiceRef, get_system_name()); - Linux_PowerManagementServiceRef_Set_CreationClassName(&powerManagementServiceRef, "Linux_PowerManagementService"); - Linux_PowerManagementServiceRef_Set_SystemCreationClassName(&powerManagementServiceRef, get_system_creation_class_name()); - Linux_HostedService_Set_Dependent(&w, &powerManagementServiceRef); - - KReturnInstance(cr, w); - CMReturn(CMPI_RC_OK); -} - -static CMPIStatus Linux_HostedServiceGetInstance( - CMPIInstanceMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop, - const char** properties) -{ - return KDefaultGetInstance( - _cb, mi, cc, cr, cop, properties); -} - -static CMPIStatus Linux_HostedServiceCreateInstance( - CMPIInstanceMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop, - const CMPIInstance* ci) -{ - CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); -} - -static CMPIStatus Linux_HostedServiceModifyInstance( - 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 Linux_HostedServiceDeleteInstance( - CMPIInstanceMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop) -{ - CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); -} - -static CMPIStatus Linux_HostedServiceExecQuery( - 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 Linux_HostedServiceAssociationCleanup( - CMPIAssociationMI* mi, - const CMPIContext* cc, - CMPIBoolean term) -{ - CMReturn(CMPI_RC_OK); -} - -static CMPIStatus Linux_HostedServiceAssociators( - 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, - Linux_HostedService_ClassName, - assocClass, - resultClass, - role, - resultRole, - properties); -} - -static CMPIStatus Linux_HostedServiceAssociatorNames( - 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, - Linux_HostedService_ClassName, - assocClass, - resultClass, - role, - resultRole); -} - -static CMPIStatus Linux_HostedServiceReferences( - 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, - Linux_HostedService_ClassName, - assocClass, - role, - properties); -} - -static CMPIStatus Linux_HostedServiceReferenceNames( - CMPIAssociationMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop, - const char* assocClass, - const char* role) -{ - return KDefaultReferenceNames( - _cb, - mi, - cc, - cr, - cop, - Linux_HostedService_ClassName, - assocClass, - role); -} - -CMInstanceMIStub( - Linux_HostedService, - Linux_HostedService, - _cb, - Linux_HostedServiceInitialize()) - -CMAssociationMIStub( - Linux_HostedService, - Linux_HostedService, - _cb, - Linux_HostedServiceInitialize()) - -KONKRET_REGISTRATION( - "root/cimv2", - "Linux_HostedService", - "Linux_HostedService", - "instance association") diff --git a/src/power/Linux_PowerManagementCapabilitiesProvider.c b/src/power/Linux_PowerManagementCapabilitiesProvider.c deleted file mode 100644 index bb74e34..0000000 --- a/src/power/Linux_PowerManagementCapabilitiesProvider.c +++ /dev/null @@ -1,162 +0,0 @@ -#include -#include "Linux_PowerManagementCapabilities.h" - -#include "power.h" - -static const CMPIBroker* _cb = NULL; - -static void Linux_PowerManagementCapabilitiesInitialize(CMPIInstanceMI *mi) -{ - mi->hdl = power_ref(_cb); -} - -static void Linux_PowerManagementCapabilitiesInitializeMethod(CMPIMethodMI *mi) -{ - mi->hdl = power_ref(_cb); -} - -static CMPIStatus Linux_PowerManagementCapabilitiesCleanup( - CMPIInstanceMI* mi, - const CMPIContext* cc, - CMPIBoolean term) -{ - power_unref(mi->hdl); - mi->hdl = NULL; - CMReturn(CMPI_RC_OK); -} - -static CMPIStatus Linux_PowerManagementCapabilitiesEnumInstanceNames( - CMPIInstanceMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop) -{ - return KDefaultEnumerateInstanceNames( - _cb, mi, cc, cr, cop); -} - -static CMPIStatus Linux_PowerManagementCapabilitiesEnumInstances( - CMPIInstanceMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop, - const char** properties) -{ - const char *ns = KNameSpace(cop); - - Linux_PowerManagementCapabilities w; - Linux_PowerManagementCapabilities_Init(&w, _cb, ns); - // TODO: make it unique - Linux_PowerManagementCapabilities_Set_InstanceID(&w, "Linux:PowerManagementCapabilities"); - Linux_PowerManagementCapabilities_Set_ElementName(&w, "Linux:PowerManagementCapabilities"); - Linux_PowerManagementCapabilities_Set_Caption(&w, "Linux:PowerManagementCapabilities"); - - int count; - unsigned short *list = power_available_requested_power_states(mi->hdl, &count); - Linux_PowerManagementCapabilities_Init_PowerStatesSupported(&w, count); - for (int i = 0; i < count; i++) { - Linux_PowerManagementCapabilities_Set_PowerStatesSupported(&w, i, list[i]); - } - - // TODO: get this list dynamically from PowerStatesSupported (see SMASH) - Linux_PowerManagementCapabilities_Init_PowerChangeCapabilities(&w, 3); - Linux_PowerManagementCapabilities_Set_PowerChangeCapabilities(&w, 0, Linux_PowerManagementCapabilities_PowerChangeCapabilities_Power_State_Settable); - Linux_PowerManagementCapabilities_Set_PowerChangeCapabilities(&w, 1, Linux_PowerManagementCapabilities_PowerChangeCapabilities_Power_Cycling_Supported); - Linux_PowerManagementCapabilities_Set_PowerChangeCapabilities(&w, 2, Linux_PowerManagementCapabilities_PowerChangeCapabilities_Graceful_Shutdown_Supported); - KReturnInstance(cr, w); - CMReturn(CMPI_RC_OK); -} - -static CMPIStatus Linux_PowerManagementCapabilitiesGetInstance( - CMPIInstanceMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop, - const char** properties) -{ - return KDefaultGetInstance( - _cb, mi, cc, cr, cop, properties); -} - -static CMPIStatus Linux_PowerManagementCapabilitiesCreateInstance( - CMPIInstanceMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop, - const CMPIInstance* ci) -{ - CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); -} - -static CMPIStatus Linux_PowerManagementCapabilitiesModifyInstance( - 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 Linux_PowerManagementCapabilitiesDeleteInstance( - CMPIInstanceMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop) -{ - CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); -} - -static CMPIStatus Linux_PowerManagementCapabilitiesExecQuery( - CMPIInstanceMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop, - const char* lang, - const char* query) -{ - CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); -} - -CMInstanceMIStub( - Linux_PowerManagementCapabilities, - Linux_PowerManagementCapabilities, - _cb, - Linux_PowerManagementCapabilitiesInitialize(&mi)) - -static CMPIStatus Linux_PowerManagementCapabilitiesMethodCleanup( - CMPIMethodMI* mi, - const CMPIContext* cc, - CMPIBoolean term) -{ - power_unref(mi->hdl); - mi->hdl = NULL; - - CMReturn(CMPI_RC_OK); -} - -static CMPIStatus Linux_PowerManagementCapabilitiesInvokeMethod( - CMPIMethodMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop, - const char* meth, - const CMPIArgs* in, - CMPIArgs* out) -{ - return Linux_PowerManagementCapabilities_DispatchMethod( - _cb, mi, cc, cr, cop, meth, in, out); -} - -CMMethodMIStub( - Linux_PowerManagementCapabilities, - Linux_PowerManagementCapabilities, - _cb, - Linux_PowerManagementCapabilitiesInitializeMethod(&mi)) - -KONKRET_REGISTRATION( - "root/cimv2", - "Linux_PowerManagementCapabilities", - "Linux_PowerManagementCapabilities", - "instance method") diff --git a/src/power/Linux_PowerManagementServiceProvider.c b/src/power/Linux_PowerManagementServiceProvider.c deleted file mode 100644 index 053c602..0000000 --- a/src/power/Linux_PowerManagementServiceProvider.c +++ /dev/null @@ -1,268 +0,0 @@ - -#include "Linux_PowerManagementService.h" - -#include "power.h" -#include "globals.h" - -static const CMPIBroker* _cb = NULL; - -static void Linux_PowerManagementServiceInitialize(CMPIInstanceMI *mi) -{ - mi->hdl = power_ref(_cb); -} - -static void Linux_PowerManagementServiceMethodInitialize(CMPIMethodMI *mi) -{ - mi->hdl = power_ref(_cb); -} - - -static CMPIStatus Linux_PowerManagementServiceCleanup( - CMPIInstanceMI* mi, - const CMPIContext* cc, - CMPIBoolean term) -{ - power_unref(mi->hdl); - mi->hdl = NULL; - CMReturn(CMPI_RC_OK); -} - -static CMPIStatus Linux_PowerManagementServiceEnumInstanceNames( - CMPIInstanceMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop) -{ - return KDefaultEnumerateInstanceNames( - _cb, mi, cc, cr, cop); -} - -static CMPIStatus Linux_PowerManagementServiceEnumInstances( - CMPIInstanceMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop, - const char** properties) -{ - Linux_PowerManagementService w; - - Linux_PowerManagementService_Init(&w, _cb, KNameSpace(cop)); - Linux_PowerManagementService_Set_CreationClassName(&w, "Linux_PowerManagementService"); - Linux_PowerManagementService_Set_Name(&w, get_system_name()); - Linux_PowerManagementService_Set_SystemCreationClassName(&w, get_system_creation_class_name()); - Linux_PowerManagementService_Set_SystemName(&w, get_system_name()); - - /* EnabledState is an integer enumeration that indicates the enabled - * and disabled states of an element. It can also indicate the transitions - * between these requested states. - */ - Linux_PowerManagementService_Set_EnabledState(&w, Linux_PowerManagementService_EnabledDefault_Enabled); - - - /* RequestedState is an integer enumeration that indicates the last - * requested or desired state for the element, irrespective of the mechanism - * through which it was requested. The actual state of the element is - * represented by EnabledState. This property is provided to compare the - * last requested and current enabled or disabled states. - */ - Linux_PowerManagementService_Set_RequestedState(&w, Linux_PowerManagementService_RequestedState_No_Change); - - Linux_PowerManagementService_Init_AvailableRequestedStates(&w, 2); - Linux_PowerManagementService_Set_AvailableRequestedStates(&w, 0, 2); // Enabled - Linux_PowerManagementService_Set_AvailableRequestedStates(&w, 1, 3); // Disabled - - - Linux_PowerManagementService_Print(&w, stderr); - - KReturnInstance(cr, w); - CMReturn(CMPI_RC_OK); -} - -static CMPIStatus Linux_PowerManagementServiceGetInstance( - CMPIInstanceMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop, - const char** properties) -{ - return KDefaultGetInstance( - _cb, mi, cc, cr, cop, properties); -} - -static CMPIStatus Linux_PowerManagementServiceCreateInstance( - CMPIInstanceMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop, - const CMPIInstance* ci) -{ - CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); -} - -static CMPIStatus Linux_PowerManagementServiceModifyInstance( - 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 Linux_PowerManagementServiceDeleteInstance( - CMPIInstanceMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop) -{ - CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); -} - -static CMPIStatus Linux_PowerManagementServiceExecQuery( - CMPIInstanceMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop, - const char* lang, - const char* query) -{ - CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); -} - -CMInstanceMIStub( - Linux_PowerManagementService, - Linux_PowerManagementService, - _cb, - Linux_PowerManagementServiceInitialize(&mi)) - -static CMPIStatus Linux_PowerManagementServiceMethodCleanup( - CMPIMethodMI* mi, - const CMPIContext* cc, - CMPIBoolean term) -{ - power_unref(mi->hdl); - mi->hdl = NULL; - CMReturn(CMPI_RC_OK); -} - -static CMPIStatus Linux_PowerManagementServiceInvokeMethod( - CMPIMethodMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop, - const char* meth, - const CMPIArgs* in, - CMPIArgs* out) -{ - return Linux_PowerManagementService_DispatchMethod( - _cb, mi, cc, cr, cop, meth, in, out); -} - -CMMethodMIStub( - Linux_PowerManagementService, - Linux_PowerManagementService, - _cb, - Linux_PowerManagementServiceMethodInitialize(&mi)) - -KUint32 Linux_PowerManagementService_RequestStateChange( - const CMPIBroker* cb, - CMPIMethodMI* mi, - const CMPIContext* context, - const Linux_PowerManagementServiceRef* self, - const KUint16* RequestedState, - KRef* Job, - const KDateTime* TimeoutPeriod, - CMPIStatus* status) -{ - KUint32 result = KUINT32_INIT; - - KSetStatus(status, ERR_NOT_SUPPORTED); - return result; - -} - -KUint32 Linux_PowerManagementService_StartService( - const CMPIBroker* cb, - CMPIMethodMI* mi, - const CMPIContext* context, - const Linux_PowerManagementServiceRef* self, - CMPIStatus* status) -{ - KUint32 result = KUINT32_INIT; - - KSetStatus(status, ERR_NOT_SUPPORTED); - return result; -} - -KUint32 Linux_PowerManagementService_StopService( - const CMPIBroker* cb, - CMPIMethodMI* mi, - const CMPIContext* context, - const Linux_PowerManagementServiceRef* self, - CMPIStatus* status) -{ - KUint32 result = KUINT32_INIT; - - KSetStatus(status, ERR_NOT_SUPPORTED); - return result; -} - -KUint32 Linux_PowerManagementService_SetPowerState( - const CMPIBroker* cb, - CMPIMethodMI* mi, - const CMPIContext* context, - const Linux_PowerManagementServiceRef* self, - const KUint16* PowerState, - const KRef* ManagedElement, - const KDateTime* Time, - CMPIStatus* status) -{ - KUint32 result = KUINT32_INIT; - - KSetStatus(status, ERR_NOT_SUPPORTED); - return result; -} - -KUint32 Linux_PowerManagementService_RequestPowerStateChange( - const CMPIBroker* cb, - CMPIMethodMI* mi, - const CMPIContext* context, - const Linux_PowerManagementServiceRef* self, - const KUint16* PowerState, - const KRef* ManagedElement, - const KDateTime* Time, - KRef* Job, - const KDateTime* TimeoutPeriod, - CMPIStatus* status) -{ - KUint32 result = KUINT32_INIT; - - if (Time->exists && Time->null && TimeoutPeriod->exists && TimeoutPeriod->null) { - /* SMASH says: The TimeoutPeriod and Time parameters shall not be - * supported for the same invocation of the RequestPowerStateChange( ) - * method. When the TimeoutPeriod and Time parameters are specified - * for the same method invocation, the method shall return a value of 2. - */ - KUint32_Set(&result, 2); - return result; - } - - // Time argument is not handled because we don't support powering on systems - - if (!PowerState->exists || PowerState->null) { - KSetStatus2(_cb, status, ERR_INVALID_PARAMETER, "PowerState argument is missing"); - return result; - } - power_request_power_state(mi->hdl, PowerState->value); - - KSetStatus(status, OK); - KUint32_Set(&result, 4096); - return result; -} - -KONKRET_REGISTRATION( - "root/cimv2", - "Linux_PowerManagementService", - "Linux_PowerManagementService", - "instance method") diff --git a/src/power/power.c b/src/power/power.c index 3210a37..4042f4a 100644 --- a/src/power/power.c +++ b/src/power/power.c @@ -5,8 +5,8 @@ #include -#include "Linux_AssociatedPowerManagementService.h" -#include "Linux_ConcreteJob.h" +#include "Cura_AssociatedPowerManagementService.h" +#include "Cura_ConcreteJob.h" #ifdef HAS_UPOWER #include @@ -70,8 +70,8 @@ Power *power_new(const CMPIBroker *_cb) Power *power = malloc(sizeof(Power)); power->broker = _cb; power->instances = 0; - power->requestedPowerState = Linux_AssociatedPowerManagementService_RequestedPowerState_Unknown; - power->transitioningToPowerState = Linux_AssociatedPowerManagementService_TransitioningToPowerState_No_Change; + power->requestedPowerState = Cura_AssociatedPowerManagementService_RequestedPowerState_Unknown; + power->transitioningToPowerState = Cura_AssociatedPowerManagementService_TransitioningToPowerState_No_Change; power->mutex = _cb->xft->newMutex(0); power->jobs = NULL; #ifdef HAS_UPOWER @@ -125,7 +125,7 @@ void *state_change_thread(void *data) { PowerStateChangeJob *powerStateChangeJob = data; MUTEX_LOCK(powerStateChangeJob); - powerStateChangeJob->jobState = Linux_ConcreteJob_JobState_Running; + powerStateChangeJob->jobState = Cura_ConcreteJob_JobState_Running; powerStateChangeJob->timeOfLastChange = time(NULL); MUTEX_UNLOCK(powerStateChangeJob); @@ -133,14 +133,14 @@ void *state_change_thread(void *data) // Check if the job was cancelled if (powerStateChangeJob->cancelled) { MUTEX_LOCK(powerStateChangeJob); - powerStateChangeJob->jobState = Linux_ConcreteJob_JobState_Terminated; + powerStateChangeJob->jobState = Cura_ConcreteJob_JobState_Terminated; powerStateChangeJob->timeOfLastChange = time(NULL); MUTEX_UNLOCK(powerStateChangeJob); if (!powerStateChangeJob->superseded) { // There is no job that replaced this job MUTEX_LOCK(powerStateChangeJob->power); - powerStateChangeJob->power->transitioningToPowerState = Linux_AssociatedPowerManagementService_TransitioningToPowerState_No_Change; + powerStateChangeJob->power->transitioningToPowerState = Cura_AssociatedPowerManagementService_TransitioningToPowerState_No_Change; MUTEX_UNLOCK(powerStateChangeJob->power); } @@ -155,7 +155,7 @@ void *state_change_thread(void *data) int succeeded = 0; switch (powerStateChangeJob->requestedPowerState) { - case Linux_AssociatedPowerManagementService_PowerState_Sleep__Deep: + case Cura_AssociatedPowerManagementService_PowerState_Sleep__Deep: // Sleep #ifdef HAS_UPOWER succeeded = up_client_suspend_sync(powerStateChangeJob->power->up, NULL, &error); @@ -163,7 +163,7 @@ void *state_change_thread(void *data) succeeded = system("pm-suspend") == 0; #endif break; - case Linux_AssociatedPowerManagementService_PowerState_Power_Cycle_Off___Soft: + case Cura_AssociatedPowerManagementService_PowerState_Power_Cycle_Off___Soft: // Reboot (without shutting down programs) #ifdef HAS_SYSTEMCTL succeeded = system("systemctl --force reboot &") == 0; @@ -171,7 +171,7 @@ void *state_change_thread(void *data) succeeded = system("reboot --force &") == 0; #endif break; - case Linux_AssociatedPowerManagementService_PowerState_Hibernate_Off___Soft: + case Cura_AssociatedPowerManagementService_PowerState_Hibernate_Off___Soft: // Hibernate #ifdef HAS_UPOWER succeeded = up_client_hibernate_sync(powerStateChangeJob->power->up, NULL, &error); @@ -179,7 +179,7 @@ void *state_change_thread(void *data) succeeded = system("pm-hibernate") == 0; #endif break; - case Linux_AssociatedPowerManagementService_PowerState_Off___Soft: + case Cura_AssociatedPowerManagementService_PowerState_Off___Soft: // Poweroff (without shutting down programs) #ifdef HAS_SYSTEMCTL succeeded = system("systemctl --force poweroff &") == 0; @@ -187,7 +187,7 @@ void *state_change_thread(void *data) succeeded = system("shutdown --halt now &") == 0; #endif break; - case Linux_AssociatedPowerManagementService_PowerState_Off___Soft_Graceful: + case Cura_AssociatedPowerManagementService_PowerState_Off___Soft_Graceful: // Poweroff (shut down programs first) #ifdef HAS_SYSTEMCTL succeeded = system("systemctl poweroff &") == 0; @@ -195,7 +195,7 @@ void *state_change_thread(void *data) succeeded = system("shutdown --poweroff now &") == 0; #endif break; - case Linux_AssociatedPowerManagementService_PowerState_Power_Cycle_Off___Soft_Graceful: + case Cura_AssociatedPowerManagementService_PowerState_Power_Cycle_Off___Soft_Graceful: // Reboot (shut down programs first) #ifdef HAS_SYSTEMCTL succeeded = system("systemctl reboot &") == 0; @@ -206,14 +206,14 @@ void *state_change_thread(void *data) } MUTEX_LOCK(powerStateChangeJob->power); - powerStateChangeJob->power->transitioningToPowerState = Linux_AssociatedPowerManagementService_TransitioningToPowerState_No_Change; + powerStateChangeJob->power->transitioningToPowerState = Cura_AssociatedPowerManagementService_TransitioningToPowerState_No_Change; MUTEX_UNLOCK(powerStateChangeJob->power); MUTEX_LOCK(powerStateChangeJob); if (succeeded) { - powerStateChangeJob->jobState = Linux_ConcreteJob_JobState_Completed; + powerStateChangeJob->jobState = Cura_ConcreteJob_JobState_Completed; } else { - powerStateChangeJob->jobState = Linux_ConcreteJob_JobState_Exception; + powerStateChangeJob->jobState = Cura_ConcreteJob_JobState_Exception; #ifdef HAS_UPOWER if (error != NULL) { powerStateChangeJob->error = error->message; @@ -250,7 +250,7 @@ int power_request_power_state(Power *power, unsigned short state) powerStateChangeJob->power = power; powerStateChangeJob->mutex = power->broker->xft->newMutex(0); powerStateChangeJob->requestedPowerState = state; - powerStateChangeJob->jobState = Linux_ConcreteJob_JobState_New; + powerStateChangeJob->jobState = Cura_ConcreteJob_JobState_New; powerStateChangeJob->cancelled = 0; powerStateChangeJob->superseded = 0; powerStateChangeJob->timeOfLastChange = time(NULL); @@ -266,13 +266,13 @@ int power_request_power_state(Power *power, unsigned short state) while (plist) { job = plist->data; MUTEX_LOCK(job); - if (job->jobState != Linux_ConcreteJob_JobState_Suspended && - job->jobState != Linux_ConcreteJob_JobState_Killed && - job->jobState != Linux_ConcreteJob_JobState_Terminated) { + if (job->jobState != Cura_ConcreteJob_JobState_Suspended && + job->jobState != Cura_ConcreteJob_JobState_Killed && + job->jobState != Cura_ConcreteJob_JobState_Terminated) { job->cancelled = 1; job->superseded = 1; - job->jobState = Linux_ConcreteJob_JobState_Shutting_Down; + job->jobState = Cura_ConcreteJob_JobState_Shutting_Down; job->timeOfLastChange = time(NULL); } MUTEX_UNLOCK(job); @@ -292,7 +292,7 @@ unsigned short *power_available_requested_power_states(Power *power, int *count) int i = 0; /* 1 Other - * Linux_AssociatedPowerManagementService_PowerState_Other + * Cura_AssociatedPowerManagementService_PowerState_Other */ /* 2 On @@ -300,7 +300,7 @@ unsigned short *power_available_requested_power_states(Power *power, int *count) * * Bring system to full On from any state (Sleep, Hibernate, Off) * - * Linux_AssociatedPowerManagementService_PowerState_On + * Cura_AssociatedPowerManagementService_PowerState_On */ // not supported @@ -309,7 +309,7 @@ unsigned short *power_available_requested_power_states(Power *power, int *count) * * Standby * - * Linux_AssociatedPowerManagementService_PowerState_Sleep___Light + * Cura_AssociatedPowerManagementService_PowerState_Sleep___Light */ // not supported @@ -318,16 +318,16 @@ unsigned short *power_available_requested_power_states(Power *power, int *count) * * Suspend * - * Linux_AssociatedPowerManagementService_PowerState_Sleep__Deep + * Cura_AssociatedPowerManagementService_PowerState_Sleep__Deep */ // Sleep #ifdef HAS_UPOWER if (up_client_get_can_suspend(power->up)) { - list[i++] = Linux_AssociatedPowerManagementService_PowerState_Sleep__Deep; + list[i++] = Cura_AssociatedPowerManagementService_PowerState_Sleep__Deep; } #else if (system("pm-is-supported --suspend") == 0) { - list[i++] = Linux_AssociatedPowerManagementService_PowerState_Sleep__Deep; + list[i++] = Cura_AssociatedPowerManagementService_PowerState_Sleep__Deep; } #endif @@ -337,10 +337,10 @@ unsigned short *power_available_requested_power_states(Power *power, int *count) * * Reset system without removing power * - * Linux_AssociatedPowerManagementService_PowerState_Power_Cycle_Off___Soft + * Cura_AssociatedPowerManagementService_PowerState_Power_Cycle_Off___Soft */ // Reboot (without shutting down programs) - list[i++] = Linux_AssociatedPowerManagementService_PowerState_Power_Cycle_Off___Soft; + list[i++] = Cura_AssociatedPowerManagementService_PowerState_Power_Cycle_Off___Soft; /* 6 Off - Hard * corresponding to ACPI state G3, S5, or D3. @@ -348,7 +348,7 @@ unsigned short *power_available_requested_power_states(Power *power, int *count) * Power Off performed through mechanical means like unplugging * power cable or UPS On * - * Linux_AssociatedPowerManagementService_PowerState_Off___Hard + * Cura_AssociatedPowerManagementService_PowerState_Off___Hard */ /* 7 Hibernate (Off - Soft) @@ -358,16 +358,16 @@ unsigned short *power_available_requested_power_states(Power *power, int *count) * System context and OS image written to non-volatile storage; * system and devices powered off * - * Linux_AssociatedPowerManagementService_PowerState_Hibernate_Off___Soft + * Cura_AssociatedPowerManagementService_PowerState_Hibernate_Off___Soft */ // Hibernate #ifdef HAS_UPOWER if (up_client_get_can_hibernate(power->up)) { - list[i++] = Linux_AssociatedPowerManagementService_PowerState_Hibernate_Off___Soft; + list[i++] = Cura_AssociatedPowerManagementService_PowerState_Hibernate_Off___Soft; } #else if (system("pm-is-supported --hibernate") == 0) { - list[i++] = Linux_AssociatedPowerManagementService_PowerState_Hibernate_Off___Soft; + list[i++] = Cura_AssociatedPowerManagementService_PowerState_Hibernate_Off___Soft; } #endif @@ -376,10 +376,10 @@ unsigned short *power_available_requested_power_states(Power *power, int *count) * * System power off but auxiliary or flea power may be available * - * Linux_AssociatedPowerManagementService_PowerState_Off___Soft + * Cura_AssociatedPowerManagementService_PowerState_Off___Soft */ // Poweroff (without shutting down programs) - list[i++] = Linux_AssociatedPowerManagementService_PowerState_Off___Soft; + list[i++] = Cura_AssociatedPowerManagementService_PowerState_Off___Soft; /* 9 Power Cycle (Off-Hard) * corresponds to the managed element reaching the ACPI state G3 @@ -387,7 +387,7 @@ unsigned short *power_available_requested_power_states(Power *power, int *count) * * Equivalent to Off–Hard followed by On * - * Linux_AssociatedPowerManagementService_PowerState_Power_Cycle_Off_Hard + * Cura_AssociatedPowerManagementService_PowerState_Power_Cycle_Off_Hard */ // not implemented @@ -397,7 +397,7 @@ unsigned short *power_available_requested_power_states(Power *power, int *count) * * Hardware reset * - * Linux_AssociatedPowerManagementService_PowerState_Master_Bus_Reset + * Cura_AssociatedPowerManagementService_PowerState_Master_Bus_Reset */ // not implemented @@ -407,7 +407,7 @@ unsigned short *power_available_requested_power_states(Power *power, int *count) * * Hardware reset * - * Linux_AssociatedPowerManagementService_PowerState_Diagnostic_Interrupt_NMI + * Cura_AssociatedPowerManagementService_PowerState_Diagnostic_Interrupt_NMI */ // not implemented @@ -418,10 +418,10 @@ unsigned short *power_available_requested_power_states(Power *power, int *count) * System power off but auxiliary or flea power may be available but preceded * by a request to the managed element to perform an orderly shutdown. * - * Linux_AssociatedPowerManagementService_PowerState_Off___Soft_Graceful + * Cura_AssociatedPowerManagementService_PowerState_Off___Soft_Graceful */ // Poweroff (shut down programs first) - list[i++] = Linux_AssociatedPowerManagementService_PowerState_Off___Soft_Graceful; + list[i++] = Cura_AssociatedPowerManagementService_PowerState_Off___Soft_Graceful; /* 13 Off - Hard Graceful * equivalent to Off Hard but preceded by a request to the managed element @@ -431,7 +431,7 @@ unsigned short *power_available_requested_power_states(Power *power, int *count) * or UPS On but preceded by a request to the managed element to perform * an orderly shutdown. * - * Linux_AssociatedPowerManagementService_PowerState_Off___Hard_Graceful + * Cura_AssociatedPowerManagementService_PowerState_Off___Hard_Graceful */ // not implemented @@ -442,7 +442,7 @@ unsigned short *power_available_requested_power_states(Power *power, int *count) * Hardware reset but preceded by a request to the managed element * to perform an orderly shutdown. * - * Linux_AssociatedPowerManagementService_PowerState_Master_Bus_Reset_Graceful + * Cura_AssociatedPowerManagementService_PowerState_Master_Bus_Reset_Graceful */ // not implemented @@ -453,10 +453,10 @@ unsigned short *power_available_requested_power_states(Power *power, int *count) * Reset system without removing power but preceded by a request * to the managed element to perform an orderly shutdown. * - * Linux_AssociatedPowerManagementService_PowerState_Power_Cycle_Off___Soft_Graceful + * Cura_AssociatedPowerManagementService_PowerState_Power_Cycle_Off___Soft_Graceful */ // Reboot (shut down programs first) - list[i++] = Linux_AssociatedPowerManagementService_PowerState_Power_Cycle_Off___Soft_Graceful; + list[i++] = Cura_AssociatedPowerManagementService_PowerState_Power_Cycle_Off___Soft_Graceful; /* 16 Power Cycle (Off - Hard Graceful) * equivalent to Power Cycle (Off - Hard) but preceded by a request @@ -465,7 +465,7 @@ unsigned short *power_available_requested_power_states(Power *power, int *count) * Equivalent to Off–Hard followed by On but preceded by a request * to the managed element to perform an orderly shutdown. * - * Linux_AssociatedPowerManagementService_PowerState_Power_Cycle_Off___Hard_Graceful + * Cura_AssociatedPowerManagementService_PowerState_Power_Cycle_Off___Hard_Graceful */ // not implemented @@ -485,9 +485,9 @@ GList *power_get_jobs(Power *power) while (plist) { powerStateChangeJob = plist->data; MUTEX_LOCK(powerStateChangeJob); - if ((powerStateChangeJob->jobState == Linux_ConcreteJob_JobState_Completed || - powerStateChangeJob->jobState == Linux_ConcreteJob_JobState_Killed || - powerStateChangeJob->jobState == Linux_ConcreteJob_JobState_Terminated) && + if ((powerStateChangeJob->jobState == Cura_ConcreteJob_JobState_Completed || + powerStateChangeJob->jobState == Cura_ConcreteJob_JobState_Killed || + powerStateChangeJob->jobState == Cura_ConcreteJob_JobState_Terminated) && time(NULL) - powerStateChangeJob->timeOfLastChange > powerStateChangeJob->timeBeforeRemoval) { MUTEX_LOCK(power); diff --git a/src/service/CMakeLists.txt b/src/service/CMakeLists.txt index 2ee6a2c..44077fb 100644 --- a/src/service/CMakeLists.txt +++ b/src/service/CMakeLists.txt @@ -1,7 +1,7 @@ set(PROVIDER_NAME Service) set(LIBRARY_NAME cmpi${PROVIDER_NAME}) -set(MOF Linux_Service.mof) +set(MOF Cura_Service.mof) set(provider_SRCS util/serviceutil.c diff --git a/src/service/Cura_ServiceProvider.c b/src/service/Cura_ServiceProvider.c new file mode 100644 index 0000000..3d2084c --- /dev/null +++ b/src/service/Cura_ServiceProvider.c @@ -0,0 +1,336 @@ +#include +#include +#include "Cura_Service.h" +#include "util/serviceutil.h" +#include "globals.h" + +static const CMPIBroker* _cb = NULL; + +static void Cura_ServiceInitialize() +{ +} + +static CMPIStatus Cura_ServiceCleanup( + CMPIInstanceMI* mi, + const CMPIContext* cc, + CMPIBoolean term) +{ + CMReturn(CMPI_RC_OK); +} + +static CMPIStatus Cura_ServiceEnumInstanceNames( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop) +{ + const char *ns = KNameSpace(cop); + SList *slist = NULL; + + slist = Service_Find_All(); + for (int i = 0; i < slist->cnt; i++) { + Cura_ServiceRef w; + Cura_ServiceRef_Init(&w, _cb, ns); + Cura_ServiceRef_Set_CreationClassName(&w, "Cura_Service"); + Cura_ServiceRef_Set_SystemCreationClassName(&w, get_system_creation_class_name()); + Cura_ServiceRef_Set_SystemName(&w, get_system_name()); + Cura_ServiceRef_Set_Name(&w, slist->name[i]); + + KReturnObjectPath(cr, w); + } + Service_Free_SList(slist); + + CMReturn(CMPI_RC_OK); +} + +static CMPIStatus Cura_ServiceEnumInstances( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char** properties) +{ + CMPIStatus st; + CMPIEnumeration* e; + if (!(e = _cb->bft->enumerateInstanceNames(_cb, cc, cop, &st))) { + KReturn2(_cb, ERR_FAILED, "Unable to enumerate instances of Cura_Service"); + } + CMPIData cd; + while (CMHasNext(e, &st)) { + + cd = CMGetNext(e, &st); + if (st.rc || cd.type != CMPI_ref) { + KReturn2(_cb, ERR_FAILED, "Enumerate instances didn't returned list of references"); + } + CMPIInstance *in = _cb->bft->getInstance(_cb, cc, cd.value.ref, properties, &st); + if (st.rc) { + KReturn2(_cb, ERR_FAILED, "Unable to get instance of Cura_Service"); + } + cr->ft->returnInstance(cr, in); + } + KReturn(OK); +} + +static CMPIStatus Cura_ServiceGetInstance( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char** properties) +{ + Cura_Service w; + Cura_Service_InitFromObjectPath(&w, _cb, cop); + + void *enumhdl = Service_Begin_Enum(w.Name.chars); + Service servicebuf; + if (Service_Next_Enum(enumhdl, &servicebuf, w.Name.chars)) { + Cura_Service_Set_Status(&w, servicebuf.svStatus); + Cura_Service_Set_Started(&w, servicebuf.svStarted); + + switch (servicebuf.svEnabledDefault) { + case ENABLED: + Cura_Service_Set_EnabledDefault(&w, Cura_Service_EnabledDefault_Enabled); + break; + case DISABLED: + Cura_Service_Set_EnabledDefault(&w, Cura_Service_EnabledDefault_Disabled); + break; + default: + Cura_Service_Set_EnabledDefault(&w, Cura_Service_EnabledDefault_Not_Applicable); + break; + } + + KReturnInstance(cr, w); + Service_End_Enum(enumhdl); + KReturn(OK); + } else { + KReturn(ERR_NOT_FOUND); + } +} + +static CMPIStatus Cura_ServiceCreateInstance( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const CMPIInstance* ci) +{ + CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); +} + +static CMPIStatus Cura_ServiceModifyInstance( + 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 Cura_ServiceDeleteInstance( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop) +{ + CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); +} + +static CMPIStatus Cura_ServiceExecQuery( + CMPIInstanceMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char* lang, + const char* query) +{ + CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); +} + +CMInstanceMIStub( + Cura_Service, + Cura_Service, + _cb, + Cura_ServiceInitialize()) + +static CMPIStatus Cura_ServiceMethodCleanup( + CMPIMethodMI* mi, + const CMPIContext* cc, + CMPIBoolean term) +{ + CMReturn(CMPI_RC_OK); +} + +static CMPIStatus Cura_ServiceInvokeMethod( + CMPIMethodMI* mi, + const CMPIContext* cc, + const CMPIResult* cr, + const CMPIObjectPath* cop, + const char* meth, + const CMPIArgs* in, + CMPIArgs* out) +{ + return Cura_Service_DispatchMethod( + _cb, mi, cc, cr, cop, meth, in, out); +} + +CMMethodMIStub( + Cura_Service, + Cura_Service, + _cb, + Cura_ServiceInitialize()) + +KUint32 Cura_Service_RequestStateChange( + const CMPIBroker* cb, + CMPIMethodMI* mi, + const CMPIContext* context, + const Cura_ServiceRef* self, + const KUint16* RequestedState, + KRef* Job, + const KDateTime* TimeoutPeriod, + CMPIStatus* status) +{ + KUint32 result = KUINT32_INIT; + + KSetStatus(status, ERR_NOT_SUPPORTED); + return result; +} + +unsigned int Service_RunOperation(const char *service, const char *operation, CMPIStatus *status) +{ + char output[1024]; + int res = Service_Operation(service, operation, output, sizeof(output)); + if (res == 0) { + KSetStatus2(_cb, status, OK, output); + } else { + KSetStatus2(_cb, status, ERR_FAILED, output); + } + return res; +} + +KUint32 Cura_Service_StartService( + const CMPIBroker* cb, + CMPIMethodMI* mi, + const CMPIContext* context, + const Cura_ServiceRef* self, + CMPIStatus* status) +{ + KUint32 result = KUINT32_INIT; + KUint32_Set(&result, Service_RunOperation(self->Name.chars, "start", status)); + return result; +} + +KUint32 Cura_Service_StopService( + const CMPIBroker* cb, + CMPIMethodMI* mi, + const CMPIContext* context, + const Cura_ServiceRef* self, + CMPIStatus* status) +{ + KUint32 result = KUINT32_INIT; + KUint32_Set(&result, Service_RunOperation(self->Name.chars, "stop", status)); + return result; +} + +KUint32 Cura_Service_ReloadService( + const CMPIBroker* cb, + CMPIMethodMI* mi, + const CMPIContext* context, + const Cura_ServiceRef* self, + CMPIStatus* status) +{ + KUint32 result = KUINT32_INIT; + KUint32_Set(&result, Service_RunOperation(self->Name.chars, "reload", status)); + return result; +} + +KUint32 Cura_Service_RestartService( + const CMPIBroker* cb, + CMPIMethodMI* mi, + const CMPIContext* context, + const Cura_ServiceRef* self, + CMPIStatus* status) +{ + KUint32 result = KUINT32_INIT; + KUint32_Set(&result, Service_RunOperation(self->Name.chars, "restart", status)); + return result; +} + +KUint32 Cura_Service_TryRestartService( + const CMPIBroker* cb, + CMPIMethodMI* mi, + const CMPIContext* context, + const Cura_ServiceRef* self, + CMPIStatus* status) +{ + KUint32 result = KUINT32_INIT; + KUint32_Set(&result, Service_RunOperation(self->Name.chars, "try-restart", status)); + return result; +} + +KUint32 Cura_Service_CondRestartService( + const CMPIBroker* cb, + CMPIMethodMI* mi, + const CMPIContext* context, + const Cura_ServiceRef* self, + CMPIStatus* status) +{ + KUint32 result = KUINT32_INIT; + KUint32_Set(&result, Service_RunOperation(self->Name.chars, "condrestart", status)); + return result; +} + +KUint32 Cura_Service_ReloadOrRestartService( + const CMPIBroker* cb, + CMPIMethodMI* mi, + const CMPIContext* context, + const Cura_ServiceRef* self, + CMPIStatus* status) +{ + KUint32 result = KUINT32_INIT; + KUint32_Set(&result, Service_RunOperation(self->Name.chars, "reload-or-restart", status)); + return result; +} + +KUint32 Cura_Service_ReloadOrTryRestartService( + const CMPIBroker* cb, + CMPIMethodMI* mi, + const CMPIContext* context, + const Cura_ServiceRef* self, + CMPIStatus* status) +{ + KUint32 result = KUINT32_INIT; + KUint32_Set(&result, Service_RunOperation(self->Name.chars, "reload-or-try-restart", status)); + return result; +} + +KUint32 Cura_Service_TurnServiceOn( + const CMPIBroker* cb, + CMPIMethodMI* mi, + const CMPIContext* context, + const Cura_ServiceRef* self, + CMPIStatus* status) +{ + KUint32 result = KUINT32_INIT; + KUint32_Set(&result, Service_RunOperation(self->Name.chars, "enable", status)); + return result; +} + +KUint32 Cura_Service_TurnServiceOff( + const CMPIBroker* cb, + CMPIMethodMI* mi, + const CMPIContext* context, + const Cura_ServiceRef* self, + CMPIStatus* status) +{ + KUint32 result = KUINT32_INIT; + KUint32_Set(&result, Service_RunOperation(self->Name.chars, "disable", status)); + return result; +} + +KONKRET_REGISTRATION( + "root/cimv2", + "Cura_Service", + "Cura_Service", + "instance method") diff --git a/src/service/Linux_ServiceProvider.c b/src/service/Linux_ServiceProvider.c deleted file mode 100644 index cbfb4f6..0000000 --- a/src/service/Linux_ServiceProvider.c +++ /dev/null @@ -1,336 +0,0 @@ -#include -#include -#include "Linux_Service.h" -#include "util/serviceutil.h" -#include "globals.h" - -static const CMPIBroker* _cb = NULL; - -static void Linux_ServiceInitialize() -{ -} - -static CMPIStatus Linux_ServiceCleanup( - CMPIInstanceMI* mi, - const CMPIContext* cc, - CMPIBoolean term) -{ - CMReturn(CMPI_RC_OK); -} - -static CMPIStatus Linux_ServiceEnumInstanceNames( - CMPIInstanceMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop) -{ - const char *ns = KNameSpace(cop); - SList *slist = NULL; - - slist = Service_Find_All(); - for (int i = 0; i < slist->cnt; i++) { - Linux_ServiceRef w; - Linux_ServiceRef_Init(&w, _cb, ns); - Linux_ServiceRef_Set_CreationClassName(&w, "Linux_Service"); - Linux_ServiceRef_Set_SystemCreationClassName(&w, get_system_creation_class_name()); - Linux_ServiceRef_Set_SystemName(&w, get_system_name()); - Linux_ServiceRef_Set_Name(&w, slist->name[i]); - - KReturnObjectPath(cr, w); - } - Service_Free_SList(slist); - - CMReturn(CMPI_RC_OK); -} - -static CMPIStatus Linux_ServiceEnumInstances( - CMPIInstanceMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop, - const char** properties) -{ - CMPIStatus st; - CMPIEnumeration* e; - if (!(e = _cb->bft->enumerateInstanceNames(_cb, cc, cop, &st))) { - KReturn2(_cb, ERR_FAILED, "Unable to enumerate instances of Linux_Service"); - } - CMPIData cd; - while (CMHasNext(e, &st)) { - - cd = CMGetNext(e, &st); - if (st.rc || cd.type != CMPI_ref) { - KReturn2(_cb, ERR_FAILED, "Enumerate instances didn't returned list of references"); - } - CMPIInstance *in = _cb->bft->getInstance(_cb, cc, cd.value.ref, properties, &st); - if (st.rc) { - KReturn2(_cb, ERR_FAILED, "Unable to get instance of Linux_Service"); - } - cr->ft->returnInstance(cr, in); - } - KReturn(OK); -} - -static CMPIStatus Linux_ServiceGetInstance( - CMPIInstanceMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop, - const char** properties) -{ - Linux_Service w; - Linux_Service_InitFromObjectPath(&w, _cb, cop); - - void *enumhdl = Service_Begin_Enum(w.Name.chars); - Service servicebuf; - if (Service_Next_Enum(enumhdl, &servicebuf, w.Name.chars)) { - Linux_Service_Set_Status(&w, servicebuf.svStatus); - Linux_Service_Set_Started(&w, servicebuf.svStarted); - - switch (servicebuf.svEnabledDefault) { - case ENABLED: - Linux_Service_Set_EnabledDefault(&w, Linux_Service_EnabledDefault_Enabled); - break; - case DISABLED: - Linux_Service_Set_EnabledDefault(&w, Linux_Service_EnabledDefault_Disabled); - break; - default: - Linux_Service_Set_EnabledDefault(&w, Linux_Service_EnabledDefault_Not_Applicable); - break; - } - - KReturnInstance(cr, w); - Service_End_Enum(enumhdl); - KReturn(OK); - } else { - KReturn(ERR_NOT_FOUND); - } -} - -static CMPIStatus Linux_ServiceCreateInstance( - CMPIInstanceMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop, - const CMPIInstance* ci) -{ - CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); -} - -static CMPIStatus Linux_ServiceModifyInstance( - 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 Linux_ServiceDeleteInstance( - CMPIInstanceMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop) -{ - CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); -} - -static CMPIStatus Linux_ServiceExecQuery( - CMPIInstanceMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop, - const char* lang, - const char* query) -{ - CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); -} - -CMInstanceMIStub( - Linux_Service, - Linux_Service, - _cb, - Linux_ServiceInitialize()) - -static CMPIStatus Linux_ServiceMethodCleanup( - CMPIMethodMI* mi, - const CMPIContext* cc, - CMPIBoolean term) -{ - CMReturn(CMPI_RC_OK); -} - -static CMPIStatus Linux_ServiceInvokeMethod( - CMPIMethodMI* mi, - const CMPIContext* cc, - const CMPIResult* cr, - const CMPIObjectPath* cop, - const char* meth, - const CMPIArgs* in, - CMPIArgs* out) -{ - return Linux_Service_DispatchMethod( - _cb, mi, cc, cr, cop, meth, in, out); -} - -CMMethodMIStub( - Linux_Service, - Linux_Service, - _cb, - Linux_ServiceInitialize()) - -KUint32 Linux_Service_RequestStateChange( - const CMPIBroker* cb, - CMPIMethodMI* mi, - const CMPIContext* context, - const Linux_ServiceRef* self, - const KUint16* RequestedState, - KRef* Job, - const KDateTime* TimeoutPeriod, - CMPIStatus* status) -{ - KUint32 result = KUINT32_INIT; - - KSetStatus(status, ERR_NOT_SUPPORTED); - return result; -} - -unsigned int Service_RunOperation(const char *service, const char *operation, CMPIStatus *status) -{ - char output[1024]; - int res = Service_Operation(service, operation, output, sizeof(output)); - if (res == 0) { - KSetStatus2(_cb, status, OK, output); - } else { - KSetStatus2(_cb, status, ERR_FAILED, output); - } - return res; -} - -KUint32 Linux_Service_StartService( - const CMPIBroker* cb, - CMPIMethodMI* mi, - const CMPIContext* context, - const Linux_ServiceRef* self, - CMPIStatus* status) -{ - KUint32 result = KUINT32_INIT; - KUint32_Set(&result, Service_RunOperation(self->Name.chars, "start", status)); - return result; -} - -KUint32 Linux_Service_StopService( - const CMPIBroker* cb, - CMPIMethodMI* mi, - const CMPIContext* context, - const Linux_ServiceRef* self, - CMPIStatus* status) -{ - KUint32 result = KUINT32_INIT; - KUint32_Set(&result, Service_RunOperation(self->Name.chars, "stop", status)); - return result; -} - -KUint32 Linux_Service_ReloadService( - const CMPIBroker* cb, - CMPIMethodMI* mi, - const CMPIContext* context, - const Linux_ServiceRef* self, - CMPIStatus* status) -{ - KUint32 result = KUINT32_INIT; - KUint32_Set(&result, Service_RunOperation(self->Name.chars, "reload", status)); - return result; -} - -KUint32 Linux_Service_RestartService( - const CMPIBroker* cb, - CMPIMethodMI* mi, - const CMPIContext* context, - const Linux_ServiceRef* self, - CMPIStatus* status) -{ - KUint32 result = KUINT32_INIT; - KUint32_Set(&result, Service_RunOperation(self->Name.chars, "restart", status)); - return result; -} - -KUint32 Linux_Service_TryRestartService( - const CMPIBroker* cb, - CMPIMethodMI* mi, - const CMPIContext* context, - const Linux_ServiceRef* self, - CMPIStatus* status) -{ - KUint32 result = KUINT32_INIT; - KUint32_Set(&result, Service_RunOperation(self->Name.chars, "try-restart", status)); - return result; -} - -KUint32 Linux_Service_CondRestartService( - const CMPIBroker* cb, - CMPIMethodMI* mi, - const CMPIContext* context, - const Linux_ServiceRef* self, - CMPIStatus* status) -{ - KUint32 result = KUINT32_INIT; - KUint32_Set(&result, Service_RunOperation(self->Name.chars, "condrestart", status)); - return result; -} - -KUint32 Linux_Service_ReloadOrRestartService( - const CMPIBroker* cb, - CMPIMethodMI* mi, - const CMPIContext* context, - const Linux_ServiceRef* self, - CMPIStatus* status) -{ - KUint32 result = KUINT32_INIT; - KUint32_Set(&result, Service_RunOperation(self->Name.chars, "reload-or-restart", status)); - return result; -} - -KUint32 Linux_Service_ReloadOrTryRestartService( - const CMPIBroker* cb, - CMPIMethodMI* mi, - const CMPIContext* context, - const Linux_ServiceRef* self, - CMPIStatus* status) -{ - KUint32 result = KUINT32_INIT; - KUint32_Set(&result, Service_RunOperation(self->Name.chars, "reload-or-try-restart", status)); - return result; -} - -KUint32 Linux_Service_TurnServiceOn( - const CMPIBroker* cb, - CMPIMethodMI* mi, - const CMPIContext* context, - const Linux_ServiceRef* self, - CMPIStatus* status) -{ - KUint32 result = KUINT32_INIT; - KUint32_Set(&result, Service_RunOperation(self->Name.chars, "enable", status)); - return result; -} - -KUint32 Linux_Service_TurnServiceOff( - const CMPIBroker* cb, - CMPIMethodMI* mi, - const CMPIContext* context, - const Linux_ServiceRef* self, - CMPIStatus* status) -{ - KUint32 result = KUINT32_INIT; - KUint32_Set(&result, Service_RunOperation(self->Name.chars, "disable", status)); - return result; -} - -KONKRET_REGISTRATION( - "root/cimv2", - "Linux_Service", - "Linux_Service", - "instance method") -- cgit