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; }