int main(int argc, char **argv)
{
SaHpiSessionIdT sid = 0;
SaHpiPowerStateT pwrstate;
SaErrorT rc = SA_OK;
rc = saHpiSessionOpen(SAHPI_UNSPECIFIED_DOMAIN_ID, &sid, NULL);
if (rc != SA_OK) {
err("Failed to open session");
return -1;
}
rc = saHpiDiscover(sid);
if (rc != SA_OK) {
err("Failed to run discover");
return -1;
}
/* get the resource id of the chassis */
SaHpiResourceIdT resid = get_resid(sid, SAHPI_ENT_SYSTEM_CHASSIS);
if (resid == 0) {
err("Couldn't find the resource id of the chassis");
return -1;
}
rc = saHpiResourcePowerStateGet(sid, resid, &pwrstate);
if (rc != SA_OK) {
err("Couldn't get power state");
err("Error %s",oh_lookup_error(rc));
return -1;
}
return 0;
}
static ret_code_t power(void)
{
SaErrorT rv;
SaHpiResourceIdT resourceid;
SaHpiPowerStateT state;
int do_set = 1;
term_def_t *term;
ret_code_t ret;
ret = ask_rpt(&resourceid);
if (ret != HPI_SHELL_OK) return(ret);
term = get_next_term();
if (term == NULL) do_set = 0;
else if (!strcmp(term->term, "on")) {
state = SAHPI_POWER_ON;
} else if (!strcmp(term->term, "off")) {
state = SAHPI_POWER_OFF;
} else if (!strcmp(term->term, "cycle")) {
state = SAHPI_POWER_CYCLE;
} else {
return HPI_SHELL_PARM_ERROR;
}
if (do_set) {
rv = saHpiResourcePowerStateSet(Domain->sessionId, resourceid, state);
if (rv != SA_OK) {
printf("saHpiResourcePowerStateSet error %s\n",
oh_lookup_error(rv));
return HPI_SHELL_CMD_ERROR;
};
return HPI_SHELL_OK;
}
rv = saHpiResourcePowerStateGet(Domain->sessionId, resourceid, &state);
if (rv != SA_OK) {
printf("saHpiResourcePowerStateGet error %s\n", oh_lookup_error(rv));
return HPI_SHELL_CMD_ERROR;
}
if (state == SAHPI_POWER_ON) {
printf("Resource %d is power on now.\n",resourceid);
} else if (state == SAHPI_POWER_OFF) {
printf("Resource %d is power off now.\n",resourceid);
}
return HPI_SHELL_OK;
}
static int sa_power(int argc, char *argv[])
{
SaErrorT rv;
SaHpiResourceIdT resourceid;
SaHpiHsPowerStateT state;
resourceid = (SaHpiResourceIdT)atoi(argv[1]);
if (argc == 2) goto L1;
else if (!strcmp(argv[2], "on")) {
state = SAHPI_HS_POWER_ON;
} else if (!strcmp(argv[2], "off")) {
state = SAHPI_HS_POWER_OFF;
} else {
return HPI_SHELL_PARM_ERROR;
}
rv = saHpiResourcePowerStateSet(sessionid, resourceid, state);
if (rv != SA_OK) {
printf("saHpiResourcePowerStateSet error %d\n",rv);
return -1;
}
L1:
rv = saHpiResourcePowerStateGet(sessionid, resourceid, &state);
if (rv != SA_OK) {
printf("saHpiResourcePowerStateGet error %d\n",rv);
return -1;
}
if (state == SAHPI_HS_POWER_ON) {
printf("Resource %d is power on now.\n",resourceid);
} else if (state == SAHPI_HS_POWER_OFF) {
printf("Resource %d is power off now.\n",resourceid);
}
return SA_OK;
}
int main(int argc, char **argv)
{
SaHpiInt32T ComputerNumber; //0..n-1
SaHpiInt32T SelectedSystem; //0..n-1
SaHpiHsPowerStateT Action;
COMPUTER_DATA *ComputerPtr;
SaHpiBoolT BladeSelected;
SaHpiBoolT MultipleBlades;
SaHpiBoolT ActionSelected;
SaHpiBoolT PrintUsage;
SaHpiBoolT DebugPrints;
GSList* Computer;
GSList* ComputerListHead;
int option;
SaHpiSessionIdT SessionId;
SaErrorT Status, Clean_Up_Status;
SaHpiEntryIdT RptEntry, RptNextEntry;
SaHpiRptEntryT Report;
SaHpiInt32T Index, EntityElement;
SaHpiHsPowerStateT PowerState;
char PowerStateString[3][7]={"off\0","on\0","cycled\0"};
SaHpiVersionT HpiVersion;
/*
// Print out the Program name and Version
*/
PROGRAM_HEADER;
/* Set Program Defaults */
ComputerNumber = 0;
SelectedSystem = 0;
Action = 255; //set it out of range to stand for status
BladeSelected = FALSE;
MultipleBlades = FALSE;
ActionSelected = FALSE;
PrintUsage = FALSE;
DebugPrints = FALSE;
RptEntry = SAHPI_FIRST_ENTRY;
/* Parse out option instructions */
while (1)
{
option = getopt(argc, argv, "dpruxb:");
if ((option == EOF) || (PrintUsage == TRUE))
{
break; //break out of the while loop
}
switch (option)
{
case 'd':
Action = SAHPI_HS_POWER_OFF;
ActionSelected = TRUE;
break;
case 'p':
Action = SAHPI_HS_POWER_ON;
ActionSelected = TRUE;
break;
case 'r':
Action = SAHPI_HS_POWER_CYCLE;
ActionSelected = TRUE;
break;
case 'u':
BladeSelected = TRUE;
ActionSelected = TRUE;
break;
case 'x':
DebugPrints = TRUE;
break;
case 'b':
if (*optarg == 0)
{
PrintUsage = TRUE;
break; //no argument
}
SelectedSystem = atoi(optarg) - 1; //Normalizing to 0...n-1
if ((SelectedSystem > MAX_MANAGED_SYSTEMS) ||
(SelectedSystem < 0))
{
//Argument is out of Range
PrintUsage = TRUE;
}
BladeSelected = TRUE;
break;
default:
PrintUsage = TRUE;
break;
} //end of switch statement
} //end of argument parsing while loop
if (PrintUsage == TRUE)
{
UsageMessage(PrgName);
/*BUG: what is the exit code for bad argument?*/
exit(0); //When we exit here, there is nothing to clean up
}
/* Initialize the first of a list of computers */
HPI_POWER_DEBUG_PRINT("1.0 Initializing the List Structure for the computers\n");
Computer = g_slist_alloc();
ComputerListHead = Computer;
HPI_POWER_DEBUG_PRINT("1.1 Allocating space for the information on each computer\n");
ComputerPtr = (COMPUTER_DATA*)malloc(sizeof(COMPUTER_DATA));
Computer->data = (gpointer)ComputerPtr;
/* Initialize HPI domain and session */
HPI_POWER_DEBUG_PRINT("2.0 Initalizing HPI\n");
Status = saHpiInitialize(&HpiVersion);
if (Status == SA_OK)
{
HPI_POWER_DEBUG_PRINT("2.1 Initalizing HPI Session\n");
Status = saHpiSessionOpen(SAHPI_DEFAULT_DOMAIN_ID,
&SessionId,
NULL);
}
if (Status == SA_OK)
{
/* Find all of the individual systems */
// regenerate the Resource Presence Table(RPT)
HPI_POWER_DEBUG_PRINT("2.2 Hpi Discovery\n");
Status = saHpiResourcesDiscover(SessionId);
}
HPI_POWER_DEBUG_PRINT("3.0 Walking through all of the Report Tables\n");
while ((Status == SA_OK) && (RptEntry != SAHPI_LAST_ENTRY))
{
HPI_POWER_DEBUG_PRINT("@");
Status = saHpiRptEntryGet(SessionId,
RptEntry,
&RptNextEntry,
&Report);
RptEntry = RptNextEntry;
// Blades will have the first Element of the Entity Path set to SBC_BLADE
EntityElement = 0;
HPI_POWER_DEBUG_PRINT(".");
if (Report.ResourceEntity.Entry[EntityElement].EntityType ==
SAHPI_ENT_SBC_BLADE)
{
HPI_POWER_DEBUG_PRINT("#");
// We have found a Blade
ComputerPtr->ResID = Report.ResourceId;
/* enumerate this list as created */
ComputerPtr->number = ComputerNumber;
ComputerNumber++;
ComputerPtr->Instance =
Report.ResourceEntity.Entry[EntityElement].EntityLocation;
// find a Name string for this blade
sprintf(ComputerPtr->NameStr,
"%s %d",
(char*)Report.ResourceTag.Data,
(int) ComputerPtr->Instance);
// Create a new allocation for another system
ComputerPtr = (COMPUTER_DATA*)malloc(sizeof(COMPUTER_DATA));
// Add another member to the list
Computer = g_slist_append(Computer,(gpointer)ComputerPtr);
// set a flag that we are working with blades
MultipleBlades = TRUE;
}
}
HPI_POWER_DEBUG_PRINT("\n4.0 Generating Listing of options to choose from:\n");
/* If parsed option does not select blade and
more than one is found */
if ((MultipleBlades == TRUE) && (BladeSelected == FALSE) && (Status == SA_OK))
{
HPI_POWER_DEBUG_PRINT("4.1 Printing out a listing of all the blades\n");
for (Index = 0; Index < ComputerNumber; Index++)
{
HPI_POWER_DEBUG_PRINT("$");
// obtain the information for this computer
ComputerPtr = g_slist_nth_data(ComputerListHead, Index);
if (ComputerPtr == NULL)
{
printf("Call returned a NULL\n");
break;
}
// retrieve the power status for this computer
HPI_POWER_DEBUG_PRINT("%%");
PowerState = 0;
Status = saHpiResourcePowerStateGet(SessionId,
ComputerPtr->ResID,
&PowerState);
if (Status != SA_OK)
{
printf("%s does not support PowerStateGet",
ComputerPtr->NameStr);
}
/* Print out all of the systems */
printf("%2d) %20s - %s \n\r", (Index + 1),
ComputerPtr->NameStr,
PowerStateString[PowerState]);
}
/* Prompt user to select one */
while ((Index >= ComputerNumber) || (Index < 0))
{
printf("\nEnter the number for the desired blade: ");
scanf("%d",&Index);
Index--; //normalize to 0..n-1
printf("\n");
}
BladeSelected = TRUE;
SelectedSystem = Index;
}
HPI_POWER_DEBUG_PRINT("4.2 Generating Listing of Actions to choose from\n");
/* If action is not selected */
if ((ActionSelected == FALSE) && (Status == SA_OK))
{
/* prompt user to select an action */
printf("\nSelect Action: 0 - Off; 1 - On; 2 - Reset; 3 - Status \n\r");
printf("Enter a number 0 to 3: ");
scanf("%d", &Index);
switch (Index)
{
case 0:
Action = SAHPI_HS_POWER_OFF;
break;
case 1:
Action = SAHPI_HS_POWER_ON;
break;
case 2:
Action = SAHPI_HS_POWER_CYCLE;
break;
default:
Action = 255; //Out of Range for "Status"
break;
}
}
/* execute the command */
if (Status == SA_OK)
{
HPI_POWER_DEBUG_PRINT("5.0 Executing the command\n\r");
// obtain the information for this computer
ComputerPtr = g_slist_nth_data(ComputerListHead, SelectedSystem);
if (Action <= SAHPI_HS_POWER_CYCLE)
{
HPI_POWER_DEBUG_PRINT("5.1 Setting a New Power State\n\r");
// Set the new power status for this computer
Status = saHpiResourcePowerStateSet(SessionId,
ComputerPtr->ResID,
Action);
/* return status */
if (Status == SA_OK)
{
printf("\n%s -- %20s has been successfully powered %s\n",
PrgName,
ComputerPtr->NameStr,
PowerStateString[Action]);
}
}
else // Report Power status for the system
{
HPI_POWER_DEBUG_PRINT("5.2 Getting the Power Status\n\r");
// retrieve the power status for this computer
PowerState = 0;
Status = saHpiResourcePowerStateGet(SessionId,
ComputerPtr->ResID,
&PowerState);
if (Status != SA_OK)
{
printf("%s does not support PowerStateGet",
ComputerPtr->NameStr);
}
/* Print out Status for this system */
printf("%2d) %20s - %s \n\r", (ComputerPtr->number + 1),
ComputerPtr->NameStr,
PowerStateString[PowerState]);
}
}
HPI_POWER_DEBUG_PRINT("6.0 Clean up");
/* clean up */
Clean_Up_Status = saHpiSessionClose(SessionId);
Clean_Up_Status = saHpiFinalize();
//Free all of the Allocations for the Computer data
Computer = ComputerListHead;
while (Computer != NULL)
{
free(Computer->data);
Computer = g_slist_next(Computer);
}
//Free the whole List
g_slist_free(ComputerListHead);
/* return status code and exit */
if (Status != SA_OK)
{
HPI_POWER_DEBUG_PRINT("7.0 Reporting Bad Status");
AppHpiPrintError(Status, PrgName);
}
return(Status);
}
int main(int argc, char **argv)
{
SaHpiInt32T ComputerNumber = 0; //0..n-1
SaHpiInt32T SelectedSystem = 0; //0..n-1
SaHpiPowerStateT Action = 255; //set it out of range to stand for status;
COMPUTER_DATA *ComputerPtr;
SaHpiBoolT BladeSelected = FALSE;
SaHpiBoolT MultipleBlades = FALSE;
SaHpiBoolT ActionSelected = FALSE;
GSList* Computer;
GSList* ComputerListHead;
SaHpiSessionIdT SessionId;
SaErrorT Status;
SaHpiEntryIdT RptEntry = SAHPI_FIRST_ENTRY;
SaHpiEntryIdT RptNextEntry;
SaHpiRptEntryT Report;
SaHpiInt32T Index, EntityElement;
SaHpiPowerStateT PowerState;
char PowerStateString[3][7]= {"off\0","on\0","cycled\0"};
GOptionContext *context;
/* Print version strings */
oh_prog_version(argv[0]);
/* Parsing options */
static char usetext[]="- Exercise HPI Power Management APIs\n "
OH_SVN_REV;
OHC_PREPARE_REVISION(usetext);
context = g_option_context_new (usetext);
g_option_context_add_main_entries (context, my_options, NULL);
if (!ohc_option_parse(&argc, argv,
context, &copt,
OHC_ALL_OPTIONS
- OHC_ENTITY_PATH_OPTION //TODO: Feature 880127
- OHC_VERBOSE_OPTION )) { // no verbose mode implemented
g_option_context_free (context);
return 1;
}
g_option_context_free (context);
if (f_down) {
Action = SAHPI_POWER_OFF;
ActionSelected = TRUE;
}
if (f_up) {
Action = SAHPI_POWER_ON;
ActionSelected = TRUE;
}
if (f_reset) {
Action = SAHPI_POWER_CYCLE;
ActionSelected = TRUE;
}
if (f_unattended) {
BladeSelected = TRUE;
ActionSelected = TRUE;
}
if (f_blade > 0) {
BladeSelected = TRUE;
SelectedSystem = f_blade - 1; //Normalizing to 0...n-1
if ((SelectedSystem > MAX_MANAGED_SYSTEMS) ||
(SelectedSystem < 0)) {
CRIT("hpipower: blade number out of range");
return 1; //When we exit here, there is nothing to clean up
}
}
/* Initialize the first of a list of computers */
HPI_POWER_DEBUG_PRINT("Initializing the List Structure for the computers");
Computer = g_slist_alloc();
ComputerListHead = Computer;
HPI_POWER_DEBUG_PRINT("Allocating space for the information on each computer");
ComputerPtr = (COMPUTER_DATA*)malloc(sizeof(COMPUTER_DATA));
Computer->data = (gpointer)ComputerPtr;
/* Initialize HPI domain and session */
HPI_POWER_DEBUG_PRINT("Initalizing HPI Session");
Status = ohc_session_open_by_option ( &copt, &SessionId);
if (Status == SA_OK)
{
/* Find all of the individual systems */
// regenerate the Resource Presence Table(RPT)
HPI_POWER_DEBUG_PRINT("Hpi Discovery");
Status = saHpiDiscover(SessionId);
} else {
CRIT("Initalizing HPI Session FAILED, code %s", oh_lookup_error(Status));
return -1;
}
HPI_POWER_DEBUG_PRINT("Walking through all of the Report Tables");
while ((Status == SA_OK) && (RptEntry != SAHPI_LAST_ENTRY))
{
HPI_POWER_DEBUG_PRINT1("@");
Status = saHpiRptEntryGet(SessionId,
RptEntry,
&RptNextEntry,
&Report);
RptEntry = RptNextEntry;
// Blades will have the first Element of the Entity Path set to SBC_BLADE
EntityElement = 0;
HPI_POWER_DEBUG_PRINT1(".");
if (Report.ResourceCapabilities & SAHPI_CAPABILITY_POWER)
{
char tagbuf[SAHPI_MAX_TEXT_BUFFER_LENGTH + 1];
HPI_POWER_DEBUG_PRINT1("#");
// We have found a Blade
ComputerPtr->ResID = Report.ResourceId;
/* enumerate this list as created */
ComputerPtr->number = ComputerNumber;
ComputerNumber++;
ComputerPtr->Instance =
Report.ResourceEntity.Entry[EntityElement].EntityLocation;
// find a Name string for this blade
HpiTextBuffer2CString( &Report.ResourceTag, tagbuf );
snprintf(ComputerPtr->NameStr, sizeof(ComputerPtr->NameStr),
"%s %d",
tagbuf,
(int) ComputerPtr->Instance);
// Create a new allocation for another system
ComputerPtr = (COMPUTER_DATA*)malloc(sizeof(COMPUTER_DATA));
// Add another member to the list
Computer = g_slist_append(Computer,(gpointer)ComputerPtr);
// set a flag that we are working with blades
MultipleBlades = TRUE;
}
}
HPI_POWER_DEBUG_PRINT("Generating Listing of options to choose from:");
/* If parsed option does not select blade and
more than one is found */
if ((MultipleBlades == TRUE) && (BladeSelected == FALSE) && (Status == SA_OK))
{
HPI_POWER_DEBUG_PRINT("Printing out a listing of all the blades");
for (Index = 0; Index < ComputerNumber; Index++)
{
HPI_POWER_DEBUG_PRINT1("$");
// obtain the information for this computer
ComputerPtr = g_slist_nth_data(ComputerListHead, Index);
if (ComputerPtr == NULL)
{
printf("Call returned a NULL\n");
break;
}
// retrieve the power status for this computer
HPI_POWER_DEBUG_PRINT1("%%");
PowerState = 0;
Status = saHpiResourcePowerStateGet(SessionId,
ComputerPtr->ResID,
&PowerState);
if (Status != SA_OK)
{
printf("%s does not support PowerStateGet",
ComputerPtr->NameStr);
}
/* Print out all of the systems */
printf("%2d) %20s - %s \n\r", (Index + 1),
ComputerPtr->NameStr,
PowerStateString[PowerState]);
}
/* Prompt user to select one */
while ((Index >= ComputerNumber) || (Index < 0))
{
printf("\nEnter the number for the desired blade: ");
if (scanf("%d",&Index) == 0) {
printf("Incorrect number\n");
}
Index--; //normalize to 0..n-1
printf("\n");
}
BladeSelected = TRUE;
SelectedSystem = Index;
}
HPI_POWER_DEBUG_PRINT("Generating Listing of Actions to choose from");
/* If action is not selected */
if ((ActionSelected == FALSE) && (Status == SA_OK))
{
/* prompt user to select an action */
printf("\nSelect Action: 0 - Off; 1 - On; 2 - Reset; 3 - Status \n\r");
printf("Enter a number 0 to 3: ");
if (scanf("%d", &Index) == 0) {
Index = -1;
}
switch (Index)
{
case 0:
Action = SAHPI_POWER_OFF;
break;
case 1:
Action = SAHPI_POWER_ON;
break;
case 2:
Action = SAHPI_POWER_CYCLE;
break;
default:
Action = 255; //Out of Range for "Status"
break;
}
}
/* execute the command */
if (Status == SA_OK)
{
HPI_POWER_DEBUG_PRINT("Executing the command");
// obtain the information for this computer
ComputerPtr = g_slist_nth_data(ComputerListHead, SelectedSystem);
if (ComputerPtr == NULL)
{
printf("Error: Selected system %d was not found.\n", SelectedSystem);
return -1;
}
if (Action <= SAHPI_POWER_CYCLE)
{
HPI_POWER_DEBUG_PRINT("Setting a New Power State");
// Set the new power status for this computer
Status = saHpiResourcePowerStateSet(SessionId,
ComputerPtr->ResID,
Action);
/* return status */
if (Status == SA_OK)
{
printf("\n%s -- %20s has been successfully powered %s\n",
argv[0],
ComputerPtr->NameStr,
PowerStateString[Action]);
}
}
else // Report Power status for the system
{
HPI_POWER_DEBUG_PRINT("Getting the Power Status\r");
// retrieve the power status for this computer
PowerState = 0;
Status = saHpiResourcePowerStateGet(SessionId,
ComputerPtr->ResID,
&PowerState);
if (Status != SA_OK)
{
printf("%s does not support PowerStateGet",
ComputerPtr->NameStr);
}
/* Print out Status for this system */
printf("%2d) %20s - %s \n\r", (ComputerPtr->number + 1),
ComputerPtr->NameStr,
PowerStateString[PowerState]);
}
}
HPI_POWER_DEBUG_PRINT("Clean up");
/* clean up */
saHpiSessionClose(SessionId);
//Free all of the Allocations for the Computer data
Computer = ComputerListHead;
while (Computer != NULL)
{
free(Computer->data);
Computer = g_slist_next(Computer);
}
//Free the whole List
g_slist_free(ComputerListHead);
/* return status code and exit */
if (Status != SA_OK)
{
HPI_POWER_DEBUG_PRINT("Reporting Bad Status");
CRIT("Error: %s", oh_lookup_error(Status));
}
return(Status);
}
static int
saHpiHotSwapTable_modify_context (SaHpiRptEntryT * rpt_entry,
oid * rpt_oid, size_t rpt_oid_len,
saHpiHotSwapTable_context * ctx)
{
unsigned int update_entry = MIB_FALSE;
long hash = 0;
int rc;
SaHpiSessionIdT session_id;
SaHpiHsIndicatorStateT indication_state;
SaHpiHsPowerStateT power_state;
SaHpiResetActionT reset_action;
SaHpiHsStateT state;
// These are 64-bite
SaHpiTimeoutT insert_t;
SaHpiTimeoutT extract_t;
if (rpt_entry)
{
hash = calculate_hash_value (rpt_entry, sizeof (SaHpiRptEntryT)
- sizeof (SaHpiTextBufferT));
}
if (ctx)
{
if (ctx->hash != 0)
{
DEBUGMSGTL ((AGENT, "Updating HotSwap entry [%d, %d]\n",
ctx->domain_id, ctx->resource_id));
update_entry = MIB_TRUE;
}
if (hash == 0)
hash = 1;
ctx->hash = hash;
if (rpt_entry)
{
ctx->resource_id = rpt_entry->ResourceId;
ctx->domain_id = rpt_entry->DomainId;
ctx->saHpiHotSwapEventSeverity = rpt_entry->ResourceSeverity + 1;
}
// Get the seesion_id
rc = getSaHpiSession (&session_id);
if (rc != AGENT_ERR_NOERROR)
{
DEBUGMSGTL ((AGENT, "Call to getSaHpiSession failed with rc: %d\n",
rc));
return rc;
}
// Indicator
DEBUGMSGTL ((AGENT, "Calling saHpiHotSwapIndicatorStateGet with %d\n",
ctx->resource_id));
rc = saHpiHotSwapIndicatorStateGet (session_id,
ctx->resource_id,
&indication_state);
if (rc != SA_OK)
{
DEBUGMSGTL ((AGENT,
"Call to saHpiHotSwapIndicatorStateGet failed with rc: %s\n",
get_error_string (rc)));
}
else
ctx->saHpiHotSwapIndicator = indication_state + 1;
// PowerState
DEBUGMSGTL ((AGENT, "Calling saHpiResourcePowerStateGet with %d\n",
ctx->resource_id));
rc = saHpiResourcePowerStateGet (session_id,
ctx->resource_id, &power_state);
if (rc != SA_OK)
{
DEBUGMSGTL ((AGENT,
"Call to saHpiResourcePowerStateGet failed with %s\n",
get_error_string (rc)));
}
else
ctx->saHpiHotSwapPowerState = power_state + 1;
// ResetState
DEBUGMSGTL ((AGENT, "Calling saHpiResourceResetStateGet with %d\n",
ctx->resource_id));
rc = saHpiResourceResetStateGet (session_id,
ctx->resource_id, &reset_action);
if (rc != SA_OK)
{
DEBUGMSGTL ((AGENT,
"Call to saHpiResourceResetStateGet failed with %s\n",
get_error_string (rc)));
}
else
ctx->saHpiHotSwapResetState = reset_action + 1;
// State
DEBUGMSGTL ((AGENT, "Calling saHpiHotSwapStateGet with %d\n",
ctx->resource_id));
rc = saHpiHotSwapStateGet (session_id, ctx->resource_id, &state);
if (rc != SA_OK)
{
DEBUGMSGTL ((AGENT, "Call to saHpiHotSwapStateGet failed with %s\n",
get_error_string (rc)));
}
else
{
ctx->saHpiHotSwapState = state + 1;
// We don't know the previous state?
ctx->saHpiHotSwapPreviousState = 0;
}
// InsertTimeout
DEBUGMSGTL ((AGENT, "Calling saHpiAutoInsertTimeoutGet \n"));
rc = saHpiAutoInsertTimeoutGet (session_id, &insert_t);
if (rc != SA_OK)
{
DEBUGMSGTL ((AGENT,
"Call to saHpiAutoInsertTimeoutGet failed with %s\n",
get_error_string (rc)));
}
else
// IBM-KR: TODO, saHpiTimeT is 64bit, long is 32bit-
// Should we make it 64-bit? Endian
ctx->saHpiHotSwapInsertTimeout = insert_t;
// Extract timeout
DEBUGMSGTL ((AGENT, "Calling saHpiAutoExtractTimeoutGet with %d\n",
ctx->resource_id));
rc = saHpiAutoExtractTimeoutGet (session_id,
ctx->resource_id, &extract_t);
if (rc != SA_OK)
{
DEBUGMSGTL ((AGENT,
"Call to saHpiAutoExtractTimeoutGet failed with %s\n",
get_error_string (rc)));
}
else
{
// IBM-KR: TODO, saHpiTimeT is 64bit, long is 32bit-
// Should we make it 64-bit? Endian
//
ctx->saHpiHotSwapExtractTimeout = extract_t;
}
ctx->saHpiHotSwapActionRequest = 0;
// Copy the RPT OID.
if (rpt_oid) {
ctx->saHpiHotSwapRTP_len = rpt_oid_len * sizeof (oid);
memcpy (ctx->saHpiHotSwapRTP, rpt_oid, ctx->saHpiHotSwapRTP_len);
}
if (update_entry == MIB_TRUE)
return AGENT_ENTRY_EXIST;
return AGENT_NEW_ENTRY;
}
return AGENT_ERR_NULL_DATA;
}
int
set_hotswap_powerstate (saHpiHotSwapTable_context * ctx)
{
SaHpiSessionIdT session_id;
SaErrorT rc;
SaHpiHsPowerStateT power_state;
if (ctx)
{
power_state = ctx->saHpiHotSwapPowerState - 1;
// Get the seesion_id
rc = getSaHpiSession (&session_id);
if (rc != AGENT_ERR_NOERROR)
{
DEBUGMSGTL ((AGENT, "Call to getSaHpiSession failed with rc: %d\n",
rc));
return rc;
}
// Set the new value
DEBUGMSGTL ((AGENT, "Calling saHpiResourcePowerStateSet with %d\n",
ctx->resource_id));
rc =
saHpiResourcePowerStateSet (session_id, ctx->resource_id,
power_state);
if (rc != SA_OK)
{
snmp_log (LOG_ERR,
"Call to saHpiResourcePowerStateSet failed with return code: %s\n",
get_error_string (rc));
DEBUGMSGTL ((AGENT,
"Call to saHpiResourcePowerStateSet failed with return code: %s\n",
get_error_string (rc)));
return AGENT_ERR_OPERATION;
}
// Get the new value
DEBUGMSGTL ((AGENT, "Calling with saHpiResourcePowerStateGet %d\n",
ctx->resource_id));
rc = saHpiResourcePowerStateGet (session_id, ctx->resource_id,
&power_state);
if (rc != SA_OK)
{
snmp_log (LOG_ERR,
"Call to saHpiResourcePowerStateGet failed with rc: %s\n",
get_error_string (rc));
DEBUGMSGTL ((AGENT,
"Call to saHpiResourcePowerStateGet failed with rc: %s\n",
get_error_string (rc)));
return AGENT_ERR_OPERATION;
}
// Update the new value to ctx.
ctx->saHpiHotSwapPowerState = power_state - 1;
return AGENT_ERR_NOERROR;
}
return AGENT_ERR_NULL_DATA;
}
int
main(int argc, char **argv)
{
int c;
int is_state = 0;
int is_power = 0;
SaErrorT rv;
SaHpiSessionIdT sessionid;
SaHpiDomainInfoT domainInfo;
SaHpiRptEntryT rptentry;
SaHpiEntryIdT rptentryid;
SaHpiEntryIdT nextrptentryid;
SaHpiResourceIdT resourceid;
SaHpiPowerStateT in_state = 0;
SaHpiPowerStateT current_state;
printf("%s ver %s\n", argv[0],progver);
while ( (c = getopt( argc, argv,"udcx?")) != EOF )
switch(c) {
case 'u': /* power up */
in_state = SAHPI_POWER_ON;
is_state = 1;
break;
case 'd': /* power down */
in_state = SAHPI_POWER_OFF;
is_state = 1;
break;
case 'c': /* power cycle */
in_state = SAHPI_POWER_CYCLE;
is_state = 1;
break;
default:
usage(argv[0]);
exit(1);
}
if ( ! is_state) {
usage(argv[0]);
exit(1);
};
rv = saHpiSessionOpen(SAHPI_UNSPECIFIED_DOMAIN_ID, &sessionid, NULL);
if (rv != SA_OK) {
if (rv == SA_ERR_HPI_ERROR)
printf("saHpiSessionOpen: error %d, SpiLibd not running\n",rv);
else
printf("saHpiSessionOpen error %d\n",rv);
exit(-1);
}
rv = saHpiDiscover(sessionid);
if (rv != SA_OK)
printf("saHpiDiscover rv = %d\n",rv);
rv = saHpiDomainInfoGet(sessionid, &domainInfo);
if (rv != SA_OK)
printf("saHpiDomainInfoGet rv = %d\n",rv);
/* walk the RPT list */
rptentryid = SAHPI_FIRST_ENTRY;
while ((rv == SA_OK) && (rptentryid != SAHPI_LAST_ENTRY)) {
SaErrorT rv1;
rv = saHpiRptEntryGet(sessionid,rptentryid,&nextrptentryid,&rptentry);
if (rv != SA_OK) {
printf("RptEntryGet: rv = %d\n",rv);
break;
};
/* walk the RDR list for this RPT entry */
resourceid = rptentry.ResourceId;
rptentry.ResourceTag.Data[rptentry.ResourceTag.DataLength] = 0;
printf("rptentry[%d] resourceid=%d tag: %s\n",
rptentryid,resourceid, (char *)rptentry.ResourceTag.Data);
if (rptentry.ResourceCapabilities & SAHPI_CAPABILITY_POWER) {
is_power = 1;
/* read the current power state */
rv1 = saHpiResourcePowerStateGet(sessionid, resourceid,
¤t_state);
if (rv1 != SA_OK) {
printf("saHpiResourcePowerStateGet: error = %d\n", rv1);
rptentryid = nextrptentryid;
continue;
}
printf("Current power state:");
state2str(current_state);
/* set new power state */
switch (in_state) {
case SAHPI_POWER_OFF:
case SAHPI_POWER_ON:
printf("Setting power state to:");
state2str(in_state);
rv1 = saHpiResourcePowerStateSet(sessionid, resourceid, in_state);
if (rv1 != SA_OK)
printf("PowerStateSet status = %d\n",rv1);
sleep(2);
break;
case SAHPI_POWER_CYCLE:
printf("Cycling system power\n");
rv1 = saHpiResourcePowerStateSet(sessionid, resourceid, in_state);
if (rv1 != SA_OK)
printf("PowerStateSet status = %d\n",rv1);
printf("Cycling power, please wait a moment...\n");
sleep(8);
break;
}
/* check new state again */
rv1 = saHpiResourcePowerStateGet(sessionid, resourceid,
¤t_state);
if (rv1 != SA_OK) {
printf("saHpiResourcePowerStateGet: error = %d\n", rv1);
break;
} else {
printf("New power state:");
state2str(current_state);
}
}
rptentryid = nextrptentryid;
}
rv = saHpiSessionClose(sessionid);
if (is_power == 0)
printf("No resources with Power capability found\n");
return(0);
}
cOpenHpiDaemon::tResult
cOpenHpiDaemon::HandleMsg( cConnection *c,
const cMessageHeader &header, const void *data,
cMessageHeader &rh, void *&rd )
{
cHpiMarshal *hm = HpiMarshalFind( header.m_id );
// check for function and data length
if ( !hm || hm->m_request_len < header.m_len )
{
//MessageHeaderInit( &rh, eMhError, header.m_seq, 0, 0 );
//rd = 0;
fprintf( stderr, "wrong message length: id %d !\n", header.m_id );
return eResultError;
}
assert( hm->m_reply_len );
// init reply header
MessageHeaderInit( &rh, eMhReply, header.m_seq, header.m_id, hm->m_reply_len );
// alloc reply buffer
rd = calloc( 1, hm->m_reply_len );
SaErrorT ret;
switch( header.m_id )
{
case eFsaHpiSessionOpen:
{
SaHpiDomainIdT domain_id;
SaHpiSessionIdT session_id = 0;
HpiDemarshalRequest1( header.m_flags & dMhEndianBit, hm, data, (void *)&domain_id );
ret = saHpiSessionOpen( domain_id, &session_id, 0 );
DbgFunc( "saHpiSessionOpen( %x, %x ) = %d\n",
domain_id, session_id, ret );
if ( ret == SA_OK )
c->AddSession( session_id );
rh.m_len = HpiMarshalReply1( hm, rd, &ret, &session_id );
}
break;
case eFsaHpiSessionClose:
{
SaHpiSessionIdT session_id;
HpiDemarshalRequest1( header.m_flags & dMhEndianBit, hm, data, &session_id );
ret = saHpiSessionClose( session_id );
DbgFunc( "saHpiSessionClose( %x ) = %d\n", session_id, ret );
if ( ret == SA_OK )
c->RemSession( session_id );
rh.m_len = HpiMarshalReply0( hm, rd, &ret );
}
break;
case eFsaHpiResourcesDiscover:
{
SaHpiSessionIdT session_id;
HpiDemarshalRequest1( header.m_flags & dMhEndianBit, hm, data, &session_id );
ret = saHpiResourcesDiscover( session_id );
DbgFunc( "saHpiResourcesDiscover( %x ) = %d\n", session_id, ret );
rh.m_len = HpiMarshalReply0( hm, rd, &ret );
}
break;
case eFsaHpiRptInfoGet:
{
SaHpiSessionIdT session_id;
SaHpiRptInfoT rpt_info;
HpiDemarshalRequest1( header.m_flags & dMhEndianBit, hm, data, &session_id );
ret = saHpiRptInfoGet( session_id, &rpt_info );
DbgFunc( "saHpiRptInfoGet( %x ) = %d\n", session_id, ret );
rh.m_len = HpiMarshalReply1( hm, rd, &ret, &rpt_info );
}
break;
case eFsaHpiRptEntryGet:
{
SaHpiSessionIdT session_id;
SaHpiEntryIdT entry_id;
SaHpiEntryIdT next_entry_id;
SaHpiRptEntryT rpt_entry;
HpiDemarshalRequest2( header.m_flags & dMhEndianBit, hm, data,
&session_id, &entry_id );
ret = saHpiRptEntryGet( session_id, entry_id, &next_entry_id, &rpt_entry );
DbgFunc( "saHpiRptEntryGet( %x, %x, %x ) = %d\n",
session_id, entry_id, next_entry_id, ret );
rh.m_len = HpiMarshalReply2( hm, rd, &ret, &next_entry_id, &rpt_entry );
}
break;
case eFsaHpiRptEntryGetByResourceId:
{
SaHpiSessionIdT session_id;
SaHpiResourceIdT resource_id;
SaHpiRptEntryT rpt_entry;
HpiDemarshalRequest2( header.m_flags & dMhEndianBit, hm, data,
&session_id, &resource_id );
ret = saHpiRptEntryGetByResourceId( session_id, resource_id, &rpt_entry );
DbgFunc( "saHpiRptEntryGetByResourceId( %x, %x ) = %d\n",
session_id, resource_id, ret );
rh.m_len = HpiMarshalReply1( hm, rd, &ret, &rpt_entry );
}
break;
case eFsaHpiResourceSeveritySet:
{
SaHpiSessionIdT session_id;
SaHpiResourceIdT resource_id;
SaHpiSeverityT severity;
HpiDemarshalRequest3( header.m_flags & dMhEndianBit, hm, data,
&session_id, &resource_id, &severity );
ret = saHpiResourceSeveritySet( session_id,
resource_id, severity );
DbgFunc( "saHpiResourceSeveritySet( %x, %x ) = %d\n",
session_id, resource_id, ret );
rh.m_len = HpiMarshalReply0( hm, rd, &ret );
}
break;
case eFsaHpiResourceTagSet:
{
SaHpiSessionIdT session_id;
SaHpiResourceIdT resource_id;
SaHpiTextBufferT resource_tag;
HpiDemarshalRequest3( header.m_flags & dMhEndianBit, hm, data,
&session_id, &resource_id, &resource_tag );
ret = saHpiResourceTagSet( session_id, resource_id,
&resource_tag );
DbgFunc( "saHpiResourceTagSet( %x, %x ) = %d\n",
session_id, resource_id, ret );
rh.m_len = HpiMarshalReply0( hm, rd, &ret );
}
break;
case eFsaHpiResourceIdGet:
{
SaHpiSessionIdT session_id;
SaHpiResourceIdT resource_id = 0;
HpiDemarshalRequest1( header.m_flags & dMhEndianBit, hm, data,
&session_id );
ret = saHpiResourceIdGet( session_id, &resource_id );
DbgFunc( "saHpiResourceIdGet( %x ) = %d, %x\n",
session_id, ret, resource_id );
rh.m_len = HpiMarshalReply1( hm, rd, &ret, &resource_id );
}
break;
case eFsaHpiEntitySchemaGet:
{
SaHpiSessionIdT session_id;
SaHpiUint32T schema_id = 0;
HpiDemarshalRequest1( header.m_flags & dMhEndianBit, hm, data,
&session_id );
ret = saHpiEntitySchemaGet( session_id, &schema_id );
DbgFunc( "saHpiEntitySchemaGet( %x ) = %d, %x\n",
session_id, ret, schema_id );
rh.m_len = HpiMarshalReply1( hm, rd, &ret, &schema_id );
}
break;
case eFsaHpiEventLogInfoGet:
{
SaHpiSessionIdT session_id;
SaHpiResourceIdT resource_id;
SaHpiSelInfoT info;
HpiDemarshalRequest2( header.m_flags & dMhEndianBit, hm, data,
&session_id, &resource_id );
ret = saHpiEventLogInfoGet( session_id, resource_id, &info );
DbgFunc( "saHpiEventLogInfoGet( %x, %x ) = %d\n",
session_id, resource_id, ret );
rh.m_len = HpiMarshalReply1( hm, rd, &ret, &info );
}
break;
case eFsaHpiEventLogEntryGet:
{
SaHpiSessionIdT session_id;
SaHpiResourceIdT resource_id;
SaHpiSelEntryIdT entry_id;
SaHpiSelEntryIdT prev_entry_id = 0;
SaHpiSelEntryIdT next_entry_id = 0;
SaHpiSelEntryT event_log_entry;
SaHpiRdrT rdr;
SaHpiRptEntryT rpt_entry;
memset( &rdr, 0, sizeof( SaHpiRdrT ) );
memset( &rpt_entry, 0, sizeof( SaHpiRptEntryT ) );
HpiDemarshalRequest3( header.m_flags & dMhEndianBit, hm, data,
&session_id, &resource_id, &entry_id );
ret = saHpiEventLogEntryGet( session_id, resource_id, entry_id,
&prev_entry_id, &next_entry_id,
&event_log_entry, &rdr, &rpt_entry );
DbgFunc( "saHpiEventLogEntryGet( %x, %x, %x ) = %d\n",
session_id, resource_id, entry_id, ret );
rh.m_len = HpiMarshalReply5( hm, rd, &ret, &prev_entry_id, &next_entry_id,
&event_log_entry, &rdr, &rpt_entry );
}
break;
case eFsaHpiEventLogEntryAdd:
{
SaHpiSessionIdT session_id;
SaHpiResourceIdT resource_id;
SaHpiSelEntryT evt_entry;
HpiDemarshalRequest3( header.m_flags & dMhEndianBit, hm, data,
&session_id, &resource_id, &evt_entry );
ret = saHpiEventLogEntryAdd( session_id, resource_id,
&evt_entry );
DbgFunc( "saHpiEventLogEntryAdd( %x, %x ) = %d\n",
session_id, resource_id, ret );
rh.m_len = HpiMarshalReply0( hm, rd, &ret );
}
break;
case eFsaHpiEventLogEntryDelete:
{
SaHpiSessionIdT session_id;
SaHpiResourceIdT resource_id;
SaHpiSelEntryIdT entry_id;
HpiDemarshalRequest3( header.m_flags & dMhEndianBit, hm, data,
&session_id, &resource_id, &entry_id );
ret = saHpiEventLogEntryDelete( session_id, resource_id, entry_id );
DbgFunc( "saHpiEventLogEntryDelete( %x, %x, %x ) = %d\n",
session_id, resource_id, entry_id, ret );
rh.m_len = HpiMarshalReply0( hm, rd, &ret );
}
break;
case eFsaHpiEventLogClear:
{
SaHpiSessionIdT session_id;
SaHpiResourceIdT resource_id;
HpiDemarshalRequest2( header.m_flags & dMhEndianBit, hm, data,
&session_id, &resource_id );
ret = saHpiEventLogClear( session_id, resource_id );
DbgFunc( "saHpiEventLogClear( %x, %x ) = %d\n",
session_id, resource_id, ret );
rh.m_len = HpiMarshalReply0( hm, rd, &ret );
}
break;
case eFsaHpiEventLogTimeGet:
{
SaHpiSessionIdT session_id;
SaHpiResourceIdT resource_id;
SaHpiTimeT ti;
HpiDemarshalRequest2( header.m_flags & dMhEndianBit, hm, data,
&session_id, &resource_id );
ret = saHpiEventLogTimeGet( session_id, resource_id, &ti );
DbgFunc( "saHpiEventLogTimeGet( %x, %x ) = %d\n",
session_id, resource_id, ret );
rh.m_len = HpiMarshalReply1( hm, rd, &ret, &ti );
}
break;
case eFsaHpiEventLogTimeSet:
{
SaHpiSessionIdT session_id;
SaHpiResourceIdT resource_id;
SaHpiTimeT ti;
HpiDemarshalRequest3( header.m_flags & dMhEndianBit, hm, data,
&session_id, &resource_id , &ti );
ret = saHpiEventLogTimeSet( session_id, resource_id, ti );
DbgFunc( "saHpiEventLogTimeSet( %x, %x ) = %d\n",
session_id, resource_id, ret );
rh.m_len = HpiMarshalReply0( hm, rd, &ret );
}
break;
case eFsaHpiEventLogStateGet:
{
SaHpiSessionIdT session_id;
SaHpiResourceIdT resource_id;
SaHpiBoolT enable;
HpiDemarshalRequest2( header.m_flags & dMhEndianBit, hm, data,
&session_id, &resource_id );
ret = saHpiEventLogStateGet( session_id, resource_id, &enable );
DbgFunc( "saHpiEventLogStateGet( %x, %x ) = %d\n",
session_id, resource_id, ret );
rh.m_len = HpiMarshalReply1( hm, rd, &ret, &enable );
}
break;
case eFsaHpiEventLogStateSet:
{
SaHpiSessionIdT session_id;
SaHpiResourceIdT resource_id;
SaHpiBoolT enable;
HpiDemarshalRequest3( header.m_flags & dMhEndianBit, hm, data,
&session_id, &resource_id, &enable );
ret = saHpiEventLogStateSet( session_id, resource_id, enable );
DbgFunc( "saHpiEventLogStateSet( %x, %x, %s ) = %d\n",
session_id, resource_id, enable ? "true" : "false", ret );
rh.m_len = HpiMarshalReply0( hm, rd, &ret );
}
break;
case eFsaHpiSubscribe:
{
SaHpiSessionIdT session_id;
SaHpiBoolT provide_active_alarms;
HpiDemarshalRequest2( header.m_flags & dMhEndianBit, hm, data,
&session_id, &provide_active_alarms );
ret = saHpiSubscribe( session_id, provide_active_alarms );
DbgFunc( "saHpiSubscribe( %x, %s ) = %d\n",
session_id, provide_active_alarms ? "true" : "false",
ret );
rh.m_len = HpiMarshalReply0( hm, rd, &ret );
}
break;
case eFsaHpiUnsubscribe:
{
SaHpiSessionIdT session_id;
HpiDemarshalRequest1( header.m_flags & dMhEndianBit, hm, data,
&session_id );
ret = saHpiUnsubscribe( session_id );
DbgFunc( "saHpiUnsubscribe( %x ) = %d\n",
session_id, ret );
rh.m_len = HpiMarshalReply0( hm, rd, &ret );
}
break;
case eFsaHpiEventGet:
{
SaHpiSessionIdT session_id;
SaHpiTimeoutT timeout;
SaHpiEventT event;
SaHpiRdrT rdr;
SaHpiRptEntryT rpt_entry;
HpiDemarshalRequest2( header.m_flags & dMhEndianBit, hm, data,
&session_id, &timeout );
if ( timeout == 0 )
{
ret = saHpiEventGet( session_id, timeout, &event, &rdr, &rpt_entry );
DbgFunc( "saHpiEventGet( %x ) = %d\n",
session_id, ret );
rh.m_len = HpiMarshalReply3( hm, rd, &ret, &event, &rdr, &rpt_entry );
}
else
{
cSession *s = c->FindSession( session_id );
if ( s && !s->IsEventGet() )
{
s->EventGet( true );
SaHpiTimeT end;
gettimeofday1( &end );
if ( timeout == SAHPI_TIMEOUT_BLOCK )
end += (SaHpiTimeT)10000*1000000000; //set a long time
else
end += timeout;
s->Timeout() = end;
s->Seq() = header.m_seq;
DbgEvent( "saHpiEventGet( %x ): add to event listener.\n",
s->SessionId() );
return eResultOk;
}
// error
ret = SA_ERR_HPI_BUSY;
rh.m_len = HpiMarshalReply3( hm, rd, &ret, &event, &rdr, &rpt_entry );
}
}
break;
case eFsaHpiRdrGet:
{
SaHpiSessionIdT session_id;
SaHpiResourceIdT resource_id;
SaHpiEntryIdT entry_id;
SaHpiEntryIdT next_entry_id;
SaHpiRdrT rdr;
HpiDemarshalRequest3( header.m_flags & dMhEndianBit, hm, data,
&session_id, &resource_id, &entry_id );
ret = saHpiRdrGet( session_id, resource_id, entry_id,
&next_entry_id, &rdr );
DbgFunc( "saHpiRdrGet( %x, %x, %x ) = %d\n",
session_id, resource_id, entry_id, ret );
rh.m_len = HpiMarshalReply2( hm, rd, &ret, &next_entry_id, &rdr );
}
break;
case eFsaHpiSensorReadingGet:
{
SaHpiSessionIdT session_id;
SaHpiResourceIdT resource_id;
SaHpiSensorNumT sensor_num;
SaHpiSensorReadingT reading;
HpiDemarshalRequest3( header.m_flags & dMhEndianBit, hm, data,
&session_id, &resource_id, &sensor_num );
ret = saHpiSensorReadingGet( session_id, resource_id,
sensor_num, &reading );
DbgFunc( "saHpiSensorReadingGet( %x, %x, %x ) = %d\n",
session_id, resource_id, sensor_num, ret );
rh.m_len = HpiMarshalReply1( hm, rd, &ret, &reading );
}
break;
case eFsaHpiSensorReadingConvert:
{
SaHpiSessionIdT session_id;
SaHpiResourceIdT resource_id;
SaHpiSensorNumT sensor_num;
SaHpiSensorReadingT reading_input;
SaHpiSensorReadingT converted_reading;
HpiDemarshalRequest4( header.m_flags & dMhEndianBit, hm, data,
&session_id, &resource_id, &sensor_num,
&reading_input );
ret = saHpiSensorReadingConvert( session_id,
resource_id, sensor_num,
&reading_input,
&converted_reading );
DbgFunc( "saHpiSensorReadingConvert( %x, %x, %x ) = %d\n",
session_id, resource_id, sensor_num, ret );
rh.m_len = HpiMarshalReply1( hm, rd, &ret, &converted_reading );
}
break;
case eFsaHpiSensorThresholdsGet:
{
SaHpiSessionIdT session_id;
SaHpiResourceIdT resource_id;
SaHpiSensorNumT sensor_num;
SaHpiSensorThresholdsT sensor_thresholds;
HpiDemarshalRequest3( header.m_flags & dMhEndianBit, hm, data,
&session_id, &resource_id, &sensor_num );
ret = saHpiSensorThresholdsGet( session_id,
resource_id, sensor_num,
&sensor_thresholds);
DbgFunc( "saHpiSensorThresholdsGet( %x, %x, %x ) = %d\n",
session_id, resource_id, sensor_num, ret );
rh.m_len = HpiMarshalReply1( hm, rd, &ret, &sensor_thresholds );
}
break;
case eFsaHpiSensorThresholdsSet:
{
SaHpiSessionIdT session_id;
SaHpiResourceIdT resource_id;
SaHpiSensorNumT sensor_num;
SaHpiSensorThresholdsT sensor_thresholds;
HpiDemarshalRequest4( header.m_flags & dMhEndianBit, hm, data,
&session_id, &resource_id, &sensor_num,
&sensor_thresholds );
ret = saHpiSensorThresholdsSet( session_id, resource_id,
sensor_num,
&sensor_thresholds );
DbgFunc( "saHpiSensorThresholdsSet( %x, %x, %x ) = %d\n",
session_id, resource_id, sensor_num, ret );
rh.m_len = HpiMarshalReply0( hm, rd, &ret );
}
break;
case eFsaHpiSensorTypeGet:
{
SaHpiResourceIdT resource_id;
SaHpiSessionIdT session_id;
SaHpiSensorNumT sensor_num;
SaHpiSensorTypeT type;
SaHpiEventCategoryT category;
HpiDemarshalRequest3( header.m_flags & dMhEndianBit, hm, data,
&session_id, &resource_id, &sensor_num );
ret = saHpiSensorTypeGet( session_id, resource_id,
sensor_num, &type, &category );
DbgFunc( "saHpiSensorTypeGet( %x, %x, %x ) = %d\n",
session_id, resource_id, sensor_num, ret );
rh.m_len = HpiMarshalReply2( hm, rd, &ret, &type, &category );
}
break;
case eFsaHpiSensorEventEnablesGet:
{
SaHpiSessionIdT session_id;
SaHpiResourceIdT resource_id;
SaHpiSensorNumT sensor_num;
SaHpiSensorEvtEnablesT enables;
HpiDemarshalRequest3( header.m_flags & dMhEndianBit, hm, data,
&session_id, &resource_id, &sensor_num );
ret = saHpiSensorEventEnablesGet( session_id, resource_id,
sensor_num, &enables );
DbgFunc( "saHpiSensorEventEnablesGet( %x, %x, %x ) = %d\n",
session_id, resource_id, sensor_num, ret );
rh.m_len = HpiMarshalReply1( hm, rd, &ret, &enables );
}
break;
case eFsaHpiSensorEventEnablesSet:
{
SaHpiSessionIdT session_id;
SaHpiResourceIdT resource_id;
SaHpiSensorNumT sensor_num;
SaHpiSensorEvtEnablesT enables;
HpiDemarshalRequest4( header.m_flags & dMhEndianBit, hm, data,
&session_id, &resource_id, &sensor_num,
&enables );
ret = saHpiSensorEventEnablesSet( session_id, resource_id,
sensor_num, &enables );
DbgFunc( "saHpiSensorEventEnablesSet( %x, %x, %x ) = %d\n",
session_id, resource_id, sensor_num, ret );
rh.m_len = HpiMarshalReply0( hm, rd, &ret );
}
break;
case eFsaHpiControlTypeGet:
{
SaHpiSessionIdT session_id;
SaHpiResourceIdT resource_id;
SaHpiCtrlNumT ctrl_num;
SaHpiCtrlTypeT type;
HpiDemarshalRequest3( header.m_flags & dMhEndianBit, hm, data,
&session_id, &resource_id, &ctrl_num );
ret = saHpiControlTypeGet( session_id, resource_id, ctrl_num,
&type );
DbgFunc( "saHpiControlTypeGet( %x, %x, %x ) = %d\n",
session_id, resource_id, ctrl_num, ret );
rh.m_len = HpiMarshalReply1( hm, rd, &ret, &type );
}
break;
case eFsaHpiControlStateGet:
{
SaHpiSessionIdT session_id;
SaHpiResourceIdT resource_id;
SaHpiCtrlNumT ctrl_num;
SaHpiCtrlStateT ctrl_state;
HpiDemarshalRequest3( header.m_flags & dMhEndianBit, hm, data,
&session_id, &resource_id, &ctrl_num );
ret = saHpiControlStateGet( session_id, resource_id,
ctrl_num, &ctrl_state );
DbgFunc( "saHpiControlStateGet( %x, %x, %x ) = %d\n",
session_id, resource_id, ctrl_num, ret );
rh.m_len = HpiMarshalReply1( hm, rd, &ret, &ctrl_state );
}
break;
case eFsaHpiControlStateSet:
{
SaHpiSessionIdT session_id;
SaHpiResourceIdT resource_id;
SaHpiCtrlNumT ctrl_num;
SaHpiCtrlStateT ctrl_state;
HpiDemarshalRequest4( header.m_flags & dMhEndianBit, hm, data,
&session_id, &resource_id, &ctrl_num,
&ctrl_state );
ret = saHpiControlStateSet( session_id, resource_id,
ctrl_num, &ctrl_state );
DbgFunc( "saHpiControlStateSet( %x, %x, %x ) = %d\n",
session_id, resource_id, ctrl_num, ret );
rh.m_len = HpiMarshalReply0( hm, rd, &ret );
}
break;
case eFsaHpiEntityInventoryDataRead:
{
SaHpiSessionIdT session_id;
SaHpiResourceIdT resource_id;
SaHpiEirIdT eir_id;
SaHpiUint32T buffer_size;
unsigned char *buffer = 0;
SaHpiUint32T actual_size;
HpiDemarshalRequest4( header.m_flags & dMhEndianBit, hm, data,
&session_id, &resource_id, &eir_id, &buffer_size );
if ( buffer_size )
buffer = new unsigned char [buffer_size];
ret = saHpiEntityInventoryDataRead( session_id, resource_id, eir_id,
buffer_size, (SaHpiInventoryDataT *)(void *)buffer,
&actual_size );
DbgFunc( "saHpintityInventoryDataRead( %x, %x, %x, %d ) = %d\n",
session_id, resource_id, eir_id, buffer_size, ret );
const cMarshalType *reply[4];
reply[0] = &SaErrorType; // SA_OK
reply[1] = &SaHpiUint32Type; // actual size
const void *params[3];
params[0] = &ret;
params[1] = &actual_size;
if ( ret != SA_OK || buffer == 0 )
reply[2] = 0;
else
{
reply[2] = &SaHpiInventoryDataType, // inventory data
reply[3] = 0;
params[2] = buffer;
}
rh.m_len = MarshalArray( reply, params, rd );
if ( buffer )
delete [] buffer;
}
break;
case eFsaHpiEntityInventoryDataWrite:
{
SaHpiSessionIdT session_id;
SaHpiResourceIdT resource_id;
SaHpiEirIdT eir_id;
unsigned char buffer[10240];
HpiDemarshalRequest4( header.m_flags & dMhEndianBit, hm, data,
&session_id, &resource_id, &eir_id, buffer );
ret = saHpiEntityInventoryDataWrite( session_id, resource_id, eir_id,
(SaHpiInventoryDataT *)(void *)buffer );
DbgFunc( "saHpintityInventoryDataWrite( %x, %x, %x ) = %d\n",
session_id, resource_id, eir_id, ret );
rh.m_len = HpiMarshalReply0( hm, rd, &ret );
}
break;
case eFsaHpiWatchdogTimerGet:
{
SaHpiSessionIdT session_id;
SaHpiResourceIdT resource_id;
SaHpiWatchdogNumT watchdog_num;
SaHpiWatchdogT watchdog;
HpiDemarshalRequest3( header.m_flags & dMhEndianBit, hm, data,
&session_id, &resource_id, &watchdog_num );
ret = saHpiWatchdogTimerGet( session_id, resource_id,
watchdog_num, &watchdog );
DbgFunc( "saHpiWatchdogTimerGet( %x, %x, %x ) = %d\n",
session_id, resource_id, watchdog_num, ret );
rh.m_len = HpiMarshalReply1( hm, rd, &ret, &watchdog );
}
break;
case eFsaHpiWatchdogTimerSet:
{
SaHpiSessionIdT session_id;
SaHpiResourceIdT resource_id;
SaHpiWatchdogNumT watchdog_num;
SaHpiWatchdogT watchdog;
HpiDemarshalRequest4( header.m_flags & dMhEndianBit, hm, data,
&session_id, &resource_id, &watchdog_num,
&watchdog );
ret = saHpiWatchdogTimerSet( session_id, resource_id,
watchdog_num, &watchdog );
DbgFunc( "saHpiWatchdogTimerSet( %x, %x, %x ) = %d\n",
session_id, resource_id, watchdog_num, ret );
rh.m_len = HpiMarshalReply0( hm, rd, &ret );
}
break;
case eFsaHpiWatchdogTimerReset:
{
SaHpiSessionIdT session_id;
SaHpiResourceIdT resource_id;
SaHpiWatchdogNumT watchdog_num;
HpiDemarshalRequest3( header.m_flags & dMhEndianBit, hm, data,
&session_id, &resource_id, &watchdog_num );
ret = saHpiWatchdogTimerReset( session_id, resource_id,
watchdog_num );
DbgFunc( "eFsaHpiWatchdogTimerReset( %x, %x, %x ) = %d\n",
session_id, resource_id, watchdog_num, ret );
rh.m_len = HpiMarshalReply0( hm, rd, &ret );
}
break;
case eFsaHpiHotSwapControlRequest:
{
SaHpiSessionIdT session_id;
SaHpiResourceIdT resource_id;
HpiDemarshalRequest2( header.m_flags & dMhEndianBit, hm, data,
&session_id, &resource_id );
ret = saHpiHotSwapControlRequest( session_id, resource_id );
DbgFunc( "saHpiHotSwapControlRequest( %x, %x ) = %d\n",
session_id, resource_id , ret );
rh.m_len = HpiMarshalReply0( hm, rd, &ret );
}
break;
case eFsaHpiResourceActiveSet:
{
SaHpiSessionIdT session_id;
SaHpiResourceIdT resource_id;
HpiDemarshalRequest2( header.m_flags & dMhEndianBit, hm, data,
&session_id, &resource_id );
ret = saHpiResourceActiveSet( session_id, resource_id );
DbgFunc( "saHpiResourceActiveSet( %x, %x ) = %d\n",
session_id, resource_id , ret );
rh.m_len = HpiMarshalReply0( hm, rd, &ret );
}
break;
case eFsaHpiResourceInactiveSet:
{
SaHpiSessionIdT session_id;
SaHpiResourceIdT resource_id;
HpiDemarshalRequest2( header.m_flags & dMhEndianBit, hm, data,
&session_id, &resource_id );
ret = saHpiResourceInactiveSet( session_id, resource_id );
DbgFunc( "saHpiResourceInactiveSet( %x, %x ) = %d\n",
session_id, resource_id , ret );
rh.m_len = HpiMarshalReply0( hm, rd, &ret );
}
break;
case eFsaHpiAutoInsertTimeoutGet:
{
SaHpiSessionIdT session_id;
SaHpiTimeoutT timeout;
HpiDemarshalRequest1( header.m_flags & dMhEndianBit, hm, data,
&session_id );
ret = saHpiAutoInsertTimeoutGet( session_id, &timeout );
DbgFunc( "saHpiAutoInsertTimeoutGet( %x ) = %d\n",
session_id, ret );
rh.m_len = HpiMarshalReply1( hm, rd, &ret, &timeout );
}
break;
case eFsaHpiAutoInsertTimeoutSet:
{
SaHpiSessionIdT session_id;
SaHpiTimeoutT timeout;
HpiDemarshalRequest2( header.m_flags & dMhEndianBit, hm, data,
&session_id, &timeout );
ret = saHpiAutoInsertTimeoutSet( session_id, timeout );
DbgFunc( "saHpiAutoInsertTimeoutSet( %x ) = %d\n",
session_id, ret );
rh.m_len = HpiMarshalReply0( hm, rd, &ret );
}
break;
case eFsaHpiAutoExtractTimeoutGet:
{
SaHpiSessionIdT session_id;
SaHpiResourceIdT resource_id;
SaHpiTimeoutT timeout;
HpiDemarshalRequest2( header.m_flags & dMhEndianBit, hm, data,
&session_id, &resource_id );
ret = saHpiAutoExtractTimeoutGet( session_id, resource_id, &timeout );
DbgFunc( "saHpiAutoExtractTimeoutGet( %x, %x ) = %d\n",
session_id, resource_id, ret );
rh.m_len = HpiMarshalReply1( hm, rd, &ret, &timeout );
}
break;
case eFsaHpiAutoExtractTimeoutSet:
{
SaHpiSessionIdT session_id;
SaHpiResourceIdT resource_id;
SaHpiTimeoutT timeout;
HpiDemarshalRequest3( header.m_flags & dMhEndianBit, hm, data,
&session_id, &resource_id, &timeout );
ret = saHpiAutoExtractTimeoutSet( session_id, resource_id, timeout );
DbgFunc( "saHpiAutoExtractTimeoutSet( %x, %x ) = %d\n",
session_id, resource_id, ret );
rh.m_len = HpiMarshalReply0( hm, rd, &ret );
}
break;
case eFsaHpiHotSwapStateGet:
{
SaHpiSessionIdT session_id;
SaHpiResourceIdT resource_id;
SaHpiHsStateT state;
HpiDemarshalRequest2( header.m_flags & dMhEndianBit, hm, data,
&session_id, &resource_id );
ret = saHpiHotSwapStateGet( session_id, resource_id, &state );
DbgFunc( "saHpiHotSwapStateGet( %x, %x ) = %d\n",
session_id, resource_id, ret );
rh.m_len = HpiMarshalReply1( hm, rd, &ret, &state );
}
break;
case eFsaHpiHotSwapActionRequest:
{
SaHpiSessionIdT session_id;
SaHpiResourceIdT resource_id;
SaHpiHsActionT action;
HpiDemarshalRequest3( header.m_flags & dMhEndianBit, hm, data,
&session_id, &resource_id, &action );
ret = saHpiHotSwapActionRequest( session_id, resource_id, action );
DbgFunc( "saHpiHotSwapActionRequest( %x, %x ) = %d\n",
session_id, resource_id , ret );
rh.m_len = HpiMarshalReply0( hm, rd, &ret );
}
break;
case eFsaHpiResourcePowerStateGet:
{
SaHpiSessionIdT session_id;
SaHpiResourceIdT resource_id;
SaHpiHsPowerStateT state;
HpiDemarshalRequest2( header.m_flags & dMhEndianBit, hm, data,
&session_id, &resource_id );
ret = saHpiResourcePowerStateGet( session_id, resource_id, &state );
DbgFunc( "saHpiResourcePowerStateGet( %x, %x ) = %d\n",
session_id, resource_id, ret );
rh.m_len = HpiMarshalReply1( hm, rd, &ret, &state );
}
break;
case eFsaHpiResourcePowerStateSet:
{
SaHpiSessionIdT session_id;
SaHpiResourceIdT resource_id;
SaHpiHsPowerStateT state;
HpiDemarshalRequest3( header.m_flags & dMhEndianBit, hm, data,
&session_id, &resource_id, &state );
ret = saHpiResourcePowerStateSet( session_id, resource_id, state );
DbgFunc( "(saHpiResourcePowerStateSet %x, %x ) = %d\n",
session_id, resource_id , ret );
rh.m_len = HpiMarshalReply0( hm, rd, &ret );
}
break;
case eFsaHpiHotSwapIndicatorStateGet:
{
SaHpiSessionIdT session_id;
SaHpiResourceIdT resource_id;
SaHpiHsIndicatorStateT state;
HpiDemarshalRequest2( header.m_flags & dMhEndianBit, hm, data,
&session_id, &resource_id );
ret = saHpiHotSwapIndicatorStateGet( session_id, resource_id, &state );
DbgFunc( "saHpiHotSwapIndicatorStateGet( %x, %x ) = %d\n",
session_id, resource_id , ret );
rh.m_len = HpiMarshalReply1( hm, rd, &ret, &state );
}
break;
case eFsaHpiHotSwapIndicatorStateSet:
{
SaHpiSessionIdT session_id;
SaHpiResourceIdT resource_id;
SaHpiHsIndicatorStateT state;
HpiDemarshalRequest3( header.m_flags & dMhEndianBit, hm, data,
&session_id, &resource_id, &state );
ret = saHpiHotSwapIndicatorStateSet( session_id, resource_id, state );
DbgFunc( "saHpiHotSwapIndicatorStateSet( %x, %x ) = %d\n",
session_id, resource_id , ret );
rh.m_len = HpiMarshalReply0( hm, rd, &ret );
}
break;
case eFsaHpiParmControl:
{
SaHpiSessionIdT session_id;
SaHpiResourceIdT resource_id;
SaHpiParmActionT action;
HpiDemarshalRequest3( header.m_flags & dMhEndianBit, hm, data,
&session_id, &resource_id, &action );
ret = saHpiParmControl( session_id, resource_id, action );
DbgFunc( "saHpiParmControl( %x, %x ) = %d\n",
session_id, resource_id, ret );
rh.m_len = HpiMarshalReply0( hm, rd, &ret );
}
break;
case eFsaHpiResourceResetStateGet:
{
SaHpiSessionIdT session_id;
SaHpiResourceIdT resource_id;
SaHpiResetActionT reset_action;
HpiDemarshalRequest2( header.m_flags & dMhEndianBit, hm, data,
&session_id, &resource_id );
ret = saHpiResourceResetStateGet( session_id, resource_id,
&reset_action );
DbgFunc( "saHpiResourceResetStateGet( %x, %x ) = %d\n",
session_id, resource_id, ret );
rh.m_len = HpiMarshalReply1( hm, rd, &ret, &reset_action );
}
break;
case eFsaHpiResourceResetStateSet:
{
SaHpiSessionIdT session_id;
SaHpiResourceIdT resource_id;
SaHpiResetActionT reset_action;
HpiDemarshalRequest3( header.m_flags & dMhEndianBit, hm, data,
&session_id, &resource_id, &reset_action );
ret = saHpiResourceResetStateSet( session_id, resource_id, reset_action );
DbgFunc( "saHpiResourceResetStateSet( %x, %x ) = %d\n",
session_id, resource_id, ret );
rh.m_len = HpiMarshalReply0( hm, rd, &ret );
}
break;
default:
assert( 0 );
break;
}
assert( rh.m_len <= hm->m_reply_len );
return eResultReply;
}
int main(int argc, char **argv)
{
/* ************************
* Local variables
* ***********************/
int testfail = 0;
SaErrorT err;
SaErrorT expected_err;
SaHpiRptEntryT rptentry;
SaHpiResourceIdT id = 0;
SaHpiSessionIdT sessionid;
SaHpiPowerStateT state = 0;
struct oh_handler_state l_handle;
memset(&l_handle, 0, sizeof(struct oh_handler_state));
/* *************************************
* Find a resource with Power capability
* ************************************* */
err = tsetup(&sessionid);
if (err != SA_OK) {
printf("Error! Can not open session for test environment\n");
printf(" File=%s, Line=%d\n", __FILE__, __LINE__);
return -1;
}
err = tfind_resource(&sessionid, SAHPI_CAPABILITY_POWER, SAHPI_FIRST_ENTRY, &rptentry, SAHPI_TRUE);
if (err != SA_OK) {
printf("Can not find a Power resource for test environment\n");
printf(" File=%s, Line=%d\n", __FILE__, __LINE__);
err = tcleanup(&sessionid);
return SA_OK;
}
id = rptentry.ResourceId;
/**************************
* Test: Invalid nandle
**************************/
expected_err = SA_ERR_HPI_INVALID_PARAMS;
err = snmp_bc_get_power_state(NULL, id, &state);
checkstatus(err, expected_err, testfail);
/**************************
* Test :
* expected_err = SA_ERR_HPI_INVALID_PARAMS;
**************************/
err = snmp_bc_get_power_state(&l_handle, id, NULL);
checkstatus(err, expected_err, testfail);
/**************************
* Test :
**************************/
expected_err = SA_ERR_HPI_INVALID_RESOURCE;
err = saHpiResourcePowerStateGet(sessionid, 5000, &state);
checkstatus(err, expected_err, testfail);
/**************************&*
* Cleanup after all tests
***************************/
err = tcleanup(&sessionid);
return testfail;
}
static int
bladehpi_reset_req(StonithPlugin *s, int request, const char *host)
{
GList * node = NULL;
struct pluginDevice * dev = NULL;
struct blade_info * bi = NULL;
SaHpiPowerStateT ohcurstate, ohnewstate;
SaErrorT ohrc;
if (Debug) {
LOG(PIL_DEBUG, "%s: called, request=%d, host=%s"
, __FUNCTION__, request, host);
}
ERRIFWRONGDEV(s, S_OOPS);
if (host == NULL) {
LOG(PIL_CRIT, "Invalid host argument to %s", __FUNCTION__);
return S_OOPS;
}
dev = (struct pluginDevice *)s;
for (node = g_list_first(dev->hostlist)
; node != NULL
; node = g_list_next(node)) {
bi = ((struct blade_info *)node->data);
if (Debug) {
LOG(PIL_DEBUG, "Found host %s in hostlist", bi->name);
}
if (!strcasecmp(bi->name, host)) {
break;
}
}
if (!node || !bi) {
LOG(PIL_CRIT
, "Host %s is not configured in this STONITH module, "
"please check your configuration information", host);
return S_OOPS;
}
/* Make sure host has proper capabilities for get */
if (!(bi->resourceCaps & SAHPI_CAPABILITY_POWER)) {
LOG(PIL_CRIT
, "Host %s does not have power capability", host);
return S_OOPS;
}
ohrc = saHpiResourcePowerStateGet(dev->ohsession, bi->resourceId
, &ohcurstate);
if (ohrc != SA_OK) {
LOG(PIL_CRIT, "Unable to get host %s power state (%d)"
, host, ohrc);
return S_OOPS;
}
switch (request) {
case ST_POWERON:
if (ohcurstate == SAHPI_POWER_ON) {
LOG(PIL_INFO, "Host %s already on", host);
return S_OK;
}
ohnewstate = SAHPI_POWER_ON;
break;
case ST_POWEROFF:
if (ohcurstate == SAHPI_POWER_OFF) {
LOG(PIL_INFO, "Host %s already off", host);
return S_OK;
}
ohnewstate = SAHPI_POWER_OFF;
break;
case ST_GENERIC_RESET:
if (ohcurstate == SAHPI_POWER_OFF) {
ohnewstate = SAHPI_POWER_ON;
} else {
ohnewstate = SAHPI_POWER_CYCLE;
}
break;
default:
LOG(PIL_CRIT, "Invalid request argument to %s"
, __FUNCTION__);
return S_INVAL;
}
if (!dev->softreset && (ohnewstate == SAHPI_POWER_CYCLE)) {
int maxwait;
ohrc = saHpiResourcePowerStateSet(dev->ohsession
, bi->resourceId, SAHPI_POWER_OFF);
if (ohrc != SA_OK) {
LOG(PIL_CRIT, "Unable to set host %s power state to"
" OFF (%d)", host, ohrc);
return S_OOPS;
}
/*
* Must wait for power off here or subsequent power on request
* may take place while power is still on and thus ignored
*/
maxwait = MAX_POWEROFF_WAIT;
do {
maxwait--;
sleep(1);
ohrc = saHpiResourcePowerStateGet(dev->ohsession
, bi->resourceId, &ohcurstate);
} while ((ohrc == SA_OK)
&& (ohcurstate != SAHPI_POWER_OFF)
&& (maxwait > 0));
if (Debug) {
LOG(PIL_DEBUG, "Waited %d seconds for power off"
, MAX_POWEROFF_WAIT - maxwait);
}
ohrc = saHpiResourcePowerStateSet(dev->ohsession
, bi->resourceId, SAHPI_POWER_ON);
if (ohrc != SA_OK) {
LOG(PIL_CRIT, "Unable to set host %s power state to"
" ON (%d)", host, ohrc);
return S_OOPS;
}
} else {
/* Make sure host has proper capabilities to reset */
if ((ohnewstate == SAHPI_POWER_CYCLE) &&
(!(bi->resourceCaps & SAHPI_CAPABILITY_RESET))) {
LOG(PIL_CRIT
, "Host %s does not have reset capability"
, host);
return S_OOPS;
}
if ((ohrc = saHpiResourcePowerStateSet(dev->ohsession
, bi->resourceId, ohnewstate)) != SA_OK) {
LOG(PIL_CRIT, "Unable to set host %s power state (%d)"
, host, ohrc);
return S_OOPS;
}
}
#ifdef IBMBC_WAIT_FOR_OFF
if (ohnewstate == SAHPI_POWER_OFF) {
int maxwait = MAX_POWEROFF_WAIT;
do {
maxwait--;
sleep(1);
ohrc = saHpiResourcePowerStateGet(dev->ohsession
, bi->resourceId, &ohcurstate);
} while ((ohrc == SA_OK)
&& (ohcurstate != SAHPI_POWER_OFF)
&& (maxwait > 0));
if (Debug) {
LOG(PIL_DEBUG, "Waited %d seconds for power off"
, MAX_POWEROFF_WAIT - maxwait);
}
}
#endif
LOG(PIL_INFO, "Host %s %s %d.", host, __FUNCTION__, request);
return S_OK;
}
