/* * Run the Remove Device Group dialog */ void remDevGrpDialog(CDKSCREEN *main_cdk_screen) { char dev_grp_name[MAX_SYSFS_ATTR_SIZE] = {0}, attr_path[MAX_SYSFS_PATH_SIZE] = {0}, attr_value[MAX_SYSFS_ATTR_SIZE] = {0}; char *error_msg = NULL, *confirm_msg = NULL; boolean confirm = FALSE; int temp_int = 0; /* Have the user choose a SCST device group */ getSCSTDevGrpChoice(main_cdk_screen, dev_grp_name); if (dev_grp_name[0] == '\0') return; /* Get a final confirmation from user before we delete */ SAFE_ASPRINTF(&confirm_msg, "Are you sure you want to delete SCST device group '%s?'", dev_grp_name); confirm = confirmDialog(main_cdk_screen, confirm_msg, NULL); FREE_NULL(confirm_msg); if (confirm) { /* Delete the specified SCST device group */ snprintf(attr_path, MAX_SYSFS_PATH_SIZE, "%s/device_groups/mgmt", SYSFS_SCST_TGT); snprintf(attr_value, MAX_SYSFS_ATTR_SIZE, "del %s", dev_grp_name); if ((temp_int = writeAttribute(attr_path, attr_value)) != 0) { SAFE_ASPRINTF(&error_msg, "Couldn't delete SCST (ALUA) device group: %s", strerror(temp_int)); errorDialog(main_cdk_screen, error_msg, NULL); FREE_NULL(error_msg); } } /* Done */ return; }
/* * Get MegaRAID logical drive information. */ MRLDRIVE *getMRLogicalDrive(int adapter_id, int ldrive_id) { MRLDRIVE *logical_drive = 0; FILE *megacli = NULL; char *command = NULL, *strtok_result = NULL; char line[MAX_MC_LINE] = {0}; int status = 0; logical_drive = (MRLDRIVE *) calloc(1, sizeof(MRLDRIVE)); if (logical_drive != NULL) { logical_drive->adapter_id = adapter_id; logical_drive->ldrive_id = ldrive_id; /* MegaCLI command */ SAFE_ASPRINTF(&command, "%s -LDInfo -L%d -a%d -NoLog 2>&1", MEGACLI_BIN, ldrive_id, adapter_id); megacli = popen(command, "r"); /* Loop over command output */ while (fgets(line, sizeof(line), megacli) != NULL) { if (strstr(line, "RAID Level :")) { strtok_result = strtok(line, ":"); strtok_result = strtok(NULL, ":"); strncpy(logical_drive->raid_lvl, strStrip(strtok_result), MAX_MR_ATTR_SIZE); } else if (strstr(line, "Size :")) { strtok_result = strtok(line, ":"); strtok_result = strtok(NULL, ":"); strncpy(logical_drive->size, strStrip(strtok_result), MAX_MR_ATTR_SIZE); } else if (strstr(line, "State :")) { strtok_result = strtok(line, ":"); strtok_result = strtok(NULL, ":"); strncpy(logical_drive->state, strStrip(strtok_result), MAX_MR_ATTR_SIZE); } else if (strstr(line, "Strip Size :")) { strtok_result = strtok(line, ":"); strtok_result = strtok(NULL, ":"); strncpy(logical_drive->strip_size, strStrip(strtok_result), MAX_MR_ATTR_SIZE); } else if (strstr(line, "Number Of Drives :")) { sscanf(line, "%*s %*s %*s %*s %d", &logical_drive->drive_cnt); } } /* Done with MegaCLI */ status = pclose(megacli); FREE_NULL(command); if (status != 0) { FREE_NULL(logical_drive); return NULL; } } /* Done */ return logical_drive; }
bool InitialiseMidi() { try { gMidiIn = new RtMidiIn(); } catch ( RtError &error ) { FREE_NULL(gMidiIn); error.printMessage(); return false; } try { gMidiOut = new RtMidiOut(); } catch ( RtError &error ) { FREE_NULL(gMidiOut); error.printMessage(); return false; } gMidiIn->setCallback( &MIDICallback ); gMidiIn->ignoreTypes( !ENABLE_SYSEX, !ENABLE_MIDICLOCK, !ENABLE_ACTIVE_SENSING ); return true; }
/* * Add MegaRAID logical drive. */ int addMRLogicalDrive(MRLDPROPS *ld_props, int num_disks, MRDISK *disks[], char raid_lvl[], char strip_size[]) { char *command = NULL, *temp_pstr = NULL; int status = 0, i = 0, ret_val = 0, pd_val_size = 0, pd_line_size = 0; char pd_list_line_buffer[MAX_MR_PD_LIST_BUFF] = {0}; /* Build the new LD command */ for (i = 0; i < num_disks; i++) { if (i == (num_disks - 1)) SAFE_ASPRINTF(&temp_pstr, "%d:%d", disks[i]->enclosure_id, disks[i]->slot_num); else SAFE_ASPRINTF(&temp_pstr, "%d:%d,", disks[i]->enclosure_id, disks[i]->slot_num); /* We add one extra for the null byte */ pd_val_size = strlen(temp_pstr) + 1; pd_line_size = pd_line_size + pd_val_size; if (pd_line_size >= MAX_MR_PD_LIST_BUFF) { FREE_NULL(temp_pstr); return -1; } else { strcat(pd_list_line_buffer, temp_pstr); FREE_NULL(temp_pstr); } } SAFE_ASPRINTF(&command, "%s -CfgLdAdd -r%s[%s] %s %s %s %s -strpsz%s -a%d " "-Silent -NoLog > /dev/null 2>&1", MEGACLI_BIN, raid_lvl, pd_list_line_buffer, ld_props->write_policy, ld_props->read_policy, ld_props->cache_policy, ld_props->bbu_cache_policy, strip_size, ld_props->adapter_id); /* Execute the command and check exit */ status = system(command); if (status == -1) { ret_val = -1; } else { if (WIFEXITED(status)) { if (WEXITSTATUS(status) == 254) { /* MegaCLI gives a exit status of 254 when using CfgLdAdd * and it successfully created the volume; it gives * an error about 'proc_add_new_ld: scandir failed' */ ret_val = 0; } else { ret_val = WEXITSTATUS(status); } } else { ret_val = -1; } } /* Done */ FREE_NULL(command); return ret_val; }
/* * Run the Remove Target from Group dialog */ void remTgtFromGrpDialog(CDKSCREEN *main_cdk_screen) { char dev_grp_name[MAX_SYSFS_ATTR_SIZE] = {0}, tgt_grp_name[MAX_SYSFS_ATTR_SIZE] = {0}, target_name[MAX_SYSFS_ATTR_SIZE] = {0}, attr_path[MAX_SYSFS_PATH_SIZE] = {0}, attr_value[MAX_SYSFS_ATTR_SIZE] = {0}; char *error_msg = NULL, *confirm_msg = NULL; boolean confirm = FALSE; int temp_int = 0; /* Have the user choose a SCST device group */ getSCSTDevGrpChoice(main_cdk_screen, dev_grp_name); if (dev_grp_name[0] == '\0') return; /* Get target group choice from user (based on previously * selected device group) */ getSCSTTgtGrpChoice(main_cdk_screen, dev_grp_name, tgt_grp_name); if (tgt_grp_name[0] == '\0') return; /* Get target group choice from user (based on previously * selected device group) */ getSCSTTgtGrpTgtChoice(main_cdk_screen, dev_grp_name, tgt_grp_name, target_name); if (target_name[0] == '\0') return; /* Get a final confirmation from user before we delete */ SAFE_ASPRINTF(&confirm_msg, "target '%s' from group '%s?'", target_name, tgt_grp_name); confirm = confirmDialog(main_cdk_screen, "Are you sure you want to remove SCST", confirm_msg); FREE_NULL(confirm_msg); if (confirm) { /* Remove the SCST target from the target group (ALUA) */ snprintf(attr_path, MAX_SYSFS_PATH_SIZE, "%s/device_groups/%s/target_groups/%s/mgmt", SYSFS_SCST_TGT, dev_grp_name, tgt_grp_name); snprintf(attr_value, MAX_SYSFS_ATTR_SIZE, "del %s", target_name); if ((temp_int = writeAttribute(attr_path, attr_value)) != 0) { SAFE_ASPRINTF(&error_msg, "Couldn't delete SCST (ALUA) target from target group: %s", strerror(temp_int)); errorDialog(main_cdk_screen, error_msg, NULL); FREE_NULL(error_msg); } } /* Done */ return; }
/* * Get enclosure/slot information for given logical drive ID. */ int getMRLDDisks(int adapter_id, int ldrive_id, int encl_ids[], int slots[]) { FILE *megacli = NULL; char *command = NULL, *strtok_result = NULL, *vdrive_line = NULL; char line[MAX_MC_LINE] = {0}; boolean ld_start = FALSE; int status = 0, ld_drv_cnt = 0, encl_count = 0, slot_count = 0; /* MegaCLI command */ SAFE_ASPRINTF(&command, "%s -LdPdInfo -a%d -NoLog 2>&1", MEGACLI_BIN, adapter_id); megacli = popen(command, "r"); /* Loop until LD is found -- then count PDs (and get data) */ SAFE_ASPRINTF(&vdrive_line, "Virtual Drive: %d", ldrive_id); while (fgets(line, sizeof (line), megacli) != NULL) { if ((ld_start == FALSE) && (strstr(line, vdrive_line) != NULL)) { ld_start = TRUE; FREE_NULL(vdrive_line); vdrive_line = NULL; } else if (ld_start && strstr(line, "Number Of Drives :") && ld_drv_cnt == 0) { strtok_result = strtok(line, ":"); strtok_result = strtok(NULL, ":"); sscanf(strtok_result, " %d", &ld_drv_cnt); } else if (ld_start && strstr(line, "Enclosure Device ID:") && encl_count < ld_drv_cnt) { strtok_result = strtok(line, ":"); strtok_result = strtok(NULL, ":"); sscanf(strtok_result, " %d", &encl_ids[encl_count]); encl_count++; } else if (ld_start && strstr(line, "Slot Number:") && slot_count < ld_drv_cnt) { strtok_result = strtok(line, ":"); strtok_result = strtok(NULL, ":"); sscanf(strtok_result, " %d", &slots[slot_count]); slot_count++; } } /* Done with MegaCLI */ status = pclose(megacli); FREE_NULL(command); if (status != 0) { return -1; } /* Done */ return ld_drv_cnt; }
/* * Get a count of the enclosures for the specified adapter. */ int getMREnclCount(int adapter_id) { FILE *megacli = NULL; char *command = NULL, *strtok_result = NULL; int status = 0, count = 0; char line[MAX_MC_LINE] = {0}; /* MegaCLI command */ SAFE_ASPRINTF(&command, "%s -EncInfo -a%d -NoLog 2>&1", MEGACLI_BIN, adapter_id); megacli = popen(command, "r"); /* Loop over command output */ while (fgets(line, sizeof(line), megacli) != NULL) { if (strstr(line, " Number of enclosures on adapter")) { strtok_result = strtok(line, "--"); strtok_result = strtok(NULL, "--"); sscanf(strtok_result, " %d", &count); } } /* Done with MegaCLI */ status = pclose(megacli); FREE_NULL(command); if (status != 0) { return -1; } /* Done */ return count; }
/* * Get number of adapters (RAID controllers). */ int getMRAdapterCount() { FILE *megacli = NULL; char *command = NULL, *mc_version = NULL; int count = 0; char line[MAX_MC_LINE] = {0}; /* A cheezy check to see if MegaCLI is "working" -- see comments below */ mc_version = getMegaCLIVersion(); if (!mc_version) { return -1; } /* MegaCLI command */ SAFE_ASPRINTF(&command, "%s -adpCount -NoLog 2>&1", MEGACLI_BIN); megacli = popen(command, "r"); /* Loop over command output */ while (fgets(line, sizeof (line), megacli) != NULL) { if (strstr(line, "Controller Count:")) sscanf(line, "%*s %*s %d", &count); } /* For this one we ignore the exit code -- when using the 'adpCount' option * with MegaCLI, it also returns the adapter count as the exit code */ pclose(megacli); /* Done */ FREE_NULL(command); return count; }
/* * Get count of MegaRAID logical (virtual) drives for given adapter. */ int getMRLDCount(int adapter_id) { FILE *megacli = NULL; char *command = NULL, *strtok_result = NULL, *mc_version = NULL; int count = 0; char line[MAX_MC_LINE] = {0}; /* A cheezy check to see if MegaCLI is "working" -- see comments below */ mc_version = getMegaCLIVersion(); if (!mc_version) { return -1; } /* MegaCLI command */ SAFE_ASPRINTF(&command, "%s -LDGetNum -a%d -NoLog 2>&1", MEGACLI_BIN, adapter_id); megacli = popen(command, "r"); /* Loop over command output */ while (fgets(line, sizeof(line), megacli) != NULL) { if (strstr(line, "Number of Virtual Drives Configured on Adapter")) { strtok_result = strtok(line, ":"); strtok_result = strtok(NULL, ":"); sscanf(strtok_result, " %d", &count); } } /* For this one we ignore the exit code -- when using the 'LDGetNum' option * with MegaCLI, it also returns the LD count as the exit code */ pclose(megacli); /* Done */ FREE_NULL(command); return count; }
/* * Run the Add Device to Group dialog */ void addDevToGrpDialog(CDKSCREEN *main_cdk_screen) { char device_name[MAX_SYSFS_ATTR_SIZE] = {0}, dev_handler[MAX_SYSFS_ATTR_SIZE] = {0}, dev_grp_name[MAX_SYSFS_ATTR_SIZE] = {0}, attr_path[MAX_SYSFS_PATH_SIZE] = {0}, attr_value[MAX_SYSFS_ATTR_SIZE] = {0}; char *error_msg = NULL; int temp_int = 0; /* Have the user choose a SCST device */ getSCSTDevChoice(main_cdk_screen, device_name, dev_handler); if (device_name[0] == '\0') return; /* Have the user choose a SCST device group (to add the device to) */ getSCSTDevGrpChoice(main_cdk_screen, dev_grp_name); if (dev_grp_name[0] == '\0') return; /* Add the SCST device to the device group (ALUA) */ snprintf(attr_path, MAX_SYSFS_PATH_SIZE, "%s/device_groups/%s/devices/mgmt", SYSFS_SCST_TGT, dev_grp_name); snprintf(attr_value, MAX_SYSFS_ATTR_SIZE, "add %s", device_name); if ((temp_int = writeAttribute(attr_path, attr_value)) != 0) { SAFE_ASPRINTF(&error_msg, "Couldn't add SCST (ALUA) device to device group: %s", strerror(temp_int)); errorDialog(main_cdk_screen, error_msg, NULL); FREE_NULL(error_msg); } /* Done */ return; }
/* * Get MegaCLI version -- just the actual number for now. */ char *getMegaCLIVersion() { FILE *megacli = NULL; char *command = NULL, *version_p = NULL; int status = 0; char line[MAX_MC_LINE] = {0}, version[20] = {0}; /* MegaCLI command */ SAFE_ASPRINTF(&command, "%s -help -NoLog 2>&1", MEGACLI_BIN); megacli = popen(command, "r"); /* Loop over command output */ while (fgets(line, sizeof (line), megacli) != NULL) { if (strstr(line, "MegaCLI SAS RAID Management Tool Ver")) { sscanf(line, "%*s %*s %*s %*s %*s %*s %s", version); } } status = pclose(megacli); FREE_NULL(command); if (status != 0) { return NULL; } /* Done */ version_p = version; return version_p; }
/* * Run the Add Device Group dialog */ void addDevGrpDialog(CDKSCREEN *main_cdk_screen) { CDKENTRY *dev_grp_name_entry = 0; char attr_path[MAX_SYSFS_PATH_SIZE] = {0}, attr_value[MAX_SYSFS_ATTR_SIZE] = {0}; char *dev_grp_name = NULL, *error_msg = NULL; int temp_int = 0; while (1) { /* Get new device group name (entry widget) */ dev_grp_name_entry = newCDKEntry(main_cdk_screen, CENTER, CENTER, "<C></31/B>Add New Device Group\n", "</B>New Group Name (no spaces): ", COLOR_DIALOG_SELECT, '_' | COLOR_DIALOG_INPUT, vMIXED, SCST_DEV_GRP_NAME_LEN, 0, SCST_DEV_GRP_NAME_LEN, TRUE, FALSE); if (!dev_grp_name_entry) { errorDialog(main_cdk_screen, ENTRY_ERR_MSG, NULL); break; } setCDKEntryBoxAttribute(dev_grp_name_entry, COLOR_DIALOG_BOX); setCDKEntryBackgroundAttrib(dev_grp_name_entry, COLOR_DIALOG_TEXT); /* Draw the entry widget */ curs_set(1); dev_grp_name = activateCDKEntry(dev_grp_name_entry, 0); /* Check exit from widget */ if (dev_grp_name_entry->exitType == vNORMAL) { /* Check group name for bad characters */ if (!checkInputStr(main_cdk_screen, NAME_CHARS, dev_grp_name)) break; /* Add the new device group */ snprintf(attr_path, MAX_SYSFS_PATH_SIZE, "%s/device_groups/mgmt", SYSFS_SCST_TGT); snprintf(attr_value, MAX_SYSFS_ATTR_SIZE, "create %s", dev_grp_name); if ((temp_int = writeAttribute(attr_path, attr_value)) != 0) { SAFE_ASPRINTF(&error_msg, "Couldn't add SCST (ALUA) device group: %s", strerror(temp_int)); errorDialog(main_cdk_screen, error_msg, NULL); FREE_NULL(error_msg); } } break; } /* Done */ destroyCDKEntry(dev_grp_name_entry); return; }
sem_t* sem_crear(int* shmid, key_t* shmkey, int contador_ftok){ sem_t* sem= NULL; //pid_t pid; /* fork pid */ //unsigned int n; /* fork count */ unsigned int value; /* semaphore value */ /* initialize a shared variable in shared memory */ char* sem_name = string_from_format("pSem_%d", contador_ftok); //shmkey = ftok("/dev/null", 5); /* valid directory name and a number */ *shmkey = ftok("/dev/null", contador_ftok); /* valid directory name and a number */ //printf("shmkey for p = %d\n", *shmkey); *shmid = shmget(*shmkey, sizeof(int), 0644 | IPC_CREAT); if (*shmid < 0) { /* shared memory error check */ perror("shmget\n"); exit(1); } /////////////////////////////////////////// value = 0; /* initialize semaphores for shared processes */ //sem = sem_open("pSem", O_CREAT | O_EXCL, 0644, value); //sem = sem_open("pSem", O_CREAT , 0644, value); sem = sem_open(sem_name, O_CREAT , 0644, value); if(sem==SEM_FAILED){ perror("sem_open___"); printf("***************************************************sdfadfasd\n"); _exit(1); } /* name of semaphore is "pSem", semaphore is reached using this name */ //sem_unlink("pSem"); sem_unlink(sem_name); /* unlink prevents the semaphore existing forever */ /* if a crash occurs during the execution */ //printf ("semaphores initialized.\n\n"); FREE_NULL(sem_name); return sem; }
/* * Get MegaRAID logical drive IDs. */ int getMRLDIDNums(int adapter_id, int ld_count, int ld_ids[]) { FILE *megacli = NULL; char *command = NULL; char line[MAX_MC_LINE] = {0}; int status = 0, ld_line_cnt = 0, ret_val = 0; /* MegaCLI command */ SAFE_ASPRINTF(&command, "%s -LDInfo -Lall -a%d -NoLog 2>&1", MEGACLI_BIN, adapter_id); megacli = popen(command, "r"); /* Loop over command output */ ld_line_cnt = 0; while (fgets(line, sizeof (line), megacli) != NULL) { if (strstr(line, "Virtual Drive:")) { sscanf(line, "%*s %*s %d", &ld_ids[ld_line_cnt]); ld_line_cnt++; } } /* Done with MegaCLI */ status = pclose(megacli); if (status == -1) { ret_val = -1; } else { if (WIFEXITED(status)) { ret_val = WEXITSTATUS(status); } else { ret_val = -1; } } /* Make sure we got the same number of IDs */ if (ld_count != ld_line_cnt) ret_val = -1; /* Done */ FREE_NULL(command); return ret_val; }
/* * Delete MegaRAID logical drive. */ int delMRLogicalDrive(int adapter_id, int ldrive_id) { char *command = NULL; int status = 0, ret_val = 0; /* The delete-logical-drive command */ SAFE_ASPRINTF(&command, "%s -CfgLdDel -L%d -a%d -Silent -NoLog > /dev/null 2>&1", MEGACLI_BIN, ldrive_id, adapter_id); /* Execute the command and check exit */ status = system(command); if (status == -1) { ret_val = -1; } else { if (WIFEXITED(status)) { ret_val = WEXITSTATUS(status); } else { ret_val = -1; } } /* Done */ FREE_NULL(command); return ret_val; }
/* * Set adapter properties via MegaCLI. */ int setMRAdapterProps(MRADPPROPS *adp_props) { char *command = NULL; int status = 0; /* Set CacheFlushInterval */ SAFE_ASPRINTF(&command, "%s -AdpSetProp CacheFlushInterval -%d -a%d " "-Silent -NoLog > /dev/null 2>&1", MEGACLI_BIN, adp_props->cache_flush, adp_props->adapter_id); status = system(command); FREE_NULL(command); if (status == -1) { return -1; } else { if (WIFEXITED(status)) { if (WEXITSTATUS(status) != 0) return WEXITSTATUS(status); } else { return -1; } } /* Set RebuildRate */ SAFE_ASPRINTF(&command, "%s -AdpSetProp RebuildRate -%d -a%d " "-Silent -NoLog > /dev/null 2>&1", MEGACLI_BIN, adp_props->rebuild_rate, adp_props->adapter_id); status = system(command); FREE_NULL(command); if (status == -1) { return -1; } else { if (WIFEXITED(status)) { if (WEXITSTATUS(status) != 0) return WEXITSTATUS(status); } else { return -1; } } /* Set ClusterEnable */ SAFE_ASPRINTF(&command, "%s -AdpSetProp ClusterEnable -%d -a%d " "-Silent -NoLog > /dev/null 2>&1", MEGACLI_BIN, (int) adp_props->cluster, adp_props->adapter_id); status = system(command); FREE_NULL(command); if (status == -1) { return -1; } else { if (WIFEXITED(status)) { if (WEXITSTATUS(status) != 0) return WEXITSTATUS(status); } else { return -1; } } /* Set NCQEnbl/NCQDsbl */ if (adp_props->ncq == TRUE) SAFE_ASPRINTF(&command, "%s -AdpSetProp NCQEnbl -a%d " "-Silent -NoLog > /dev/null 2>&1", MEGACLI_BIN, adp_props->adapter_id); else SAFE_ASPRINTF(&command, "%s -AdpSetProp NCQDsbl -a%d " "-Silent -NoLog > /dev/null 2>&1", MEGACLI_BIN, adp_props->adapter_id); status = system(command); FREE_NULL(command); if (status == -1) { return -1; } else { if (WIFEXITED(status)) { if (WEXITSTATUS(status) != 0) return WEXITSTATUS(status); } else { return -1; } } /* Done */ return 0; }
/* * Get adapter attributes from MegaCLI. */ MRADAPTER *getMRAdapter(int adapter_id) { MRADAPTER *adapter = 0; FILE *megacli = NULL; char *command = NULL, *strtok_result = NULL; char line[MAX_MC_LINE] = {0}; int status = 0; adapter = (MRADAPTER *) calloc(1, sizeof(MRADAPTER)); if (adapter != NULL) { adapter->adapter_id = adapter_id; /* MegaCLI command */ SAFE_ASPRINTF(&command, "%s -AdpAllInfo -a%d -NoLog 2>&1", MEGACLI_BIN, adapter_id); megacli = popen(command, "r"); /* Loop over command output */ while (fgets(line, sizeof(line), megacli) != NULL) { if (strstr(line, "Product Name :")) { strtok_result = strtok(line, ":"); strtok_result = strtok(NULL, ":"); strncpy(adapter->prod_name, strStrip(strtok_result), MAX_MR_ATTR_SIZE); } else if (strstr(line, "Serial No :")) { strtok_result = strtok(line, ":"); strtok_result = strtok(NULL, ":"); strncpy(adapter->serial, strStrip(strtok_result), MAX_MR_ATTR_SIZE); } else if (strstr(line, "FW Package Build:")) { strtok_result = strtok(line, ":"); strtok_result = strtok(NULL, ":"); strncpy(adapter->firmware, strStrip(strtok_result), MAX_MR_ATTR_SIZE); } else if (strstr(line, "BBU :")) { strtok_result = strtok(line, ":"); strtok_result = strtok(NULL, ":"); strncpy(adapter->bbu, strStrip(strtok_result), MAX_MR_ATTR_SIZE); } else if (strstr(line, "Memory Size :")) { strtok_result = strtok(line, ":"); strtok_result = strtok(NULL, ":"); strncpy(adapter->memory, strStrip(strtok_result), MAX_MR_ATTR_SIZE); } else if (strstr(line, "Host Interface :")) { strtok_result = strtok(line, ":"); strtok_result = strtok(NULL, ":"); strncpy(adapter->interface, strStrip(strtok_result), MAX_MR_ATTR_SIZE); } else if (strstr(line, "Virtual Drives :")) { sscanf(line, "%*s %*s %*s %d", &adapter->logical_drv_cnt); } else if (strstr(line, " Disks :")) { sscanf(line, "%*s %*s %d", &adapter->disk_cnt); } else if (strstr(line, "Cluster Permitted :")) { strtok_result = strtok(line, ":"); strtok_result = strtok(NULL, ":"); strncpy(adapter->cluster, strStrip(strtok_result), MAX_MR_ATTR_SIZE); } else if (strstr(line, "Cluster Active :")) { strtok_result = strtok(line, ":"); strtok_result = strtok(NULL, ":"); strncpy(adapter->cluster_on, strStrip(strtok_result), MAX_MR_ATTR_SIZE); } } /* Done with MegaCLI */ status = pclose(megacli); FREE_NULL(command); if (status != 0) { FREE_NULL(adapter); return NULL; } } /* Done */ return adapter; }
/* * Set logical drive properties. */ int setMRLDProps(MRLDPROPS *ld_props) { char *command = NULL; int status = 0; /* Set cache policy */ SAFE_ASPRINTF(&command, "%s -LDSetProp %s -L%d -a%d " "-Silent -NoLog > /dev/null 2>&1", MEGACLI_BIN, ld_props->cache_policy, ld_props->ldrive_id, ld_props->adapter_id); status = system(command); FREE_NULL(command); if (status == -1) { return -1; } else { if (WIFEXITED(status)) { if (WEXITSTATUS(status) != 0) return WEXITSTATUS(status); } else { return -1; } } /* Set write-cache policy */ SAFE_ASPRINTF(&command, "%s -LDSetProp %s -L%d -a%d " "-Silent -NoLog > /dev/null 2>&1", MEGACLI_BIN, ld_props->write_policy, ld_props->ldrive_id, ld_props->adapter_id); status = system(command); FREE_NULL(command); if (status == -1) { return -1; } else { if (WIFEXITED(status)) { if (WEXITSTATUS(status) != 0) return WEXITSTATUS(status); } else { return -1; } } /* Set read-cache policy */ SAFE_ASPRINTF(&command, "%s -LDSetProp %s -L%d -a%d " "-Silent -NoLog > /dev/null 2>&1", MEGACLI_BIN, ld_props->read_policy, ld_props->ldrive_id, ld_props->adapter_id); status = system(command); FREE_NULL(command); if (status == -1) { return -1; } else { if (WIFEXITED(status)) { if (WEXITSTATUS(status) != 0) return WEXITSTATUS(status); } else { return -1; } } /* Set BBU cache policy */ SAFE_ASPRINTF(&command, "%s -LDSetProp %s -L%d -a%d " "-Silent -NoLog > /dev/null 2>&1", MEGACLI_BIN, ld_props->bbu_cache_policy, ld_props->ldrive_id, ld_props->adapter_id); status = system(command); FREE_NULL(command); if (status == -1) { return -1; } else { if (WIFEXITED(status)) { if (WEXITSTATUS(status) != 0) return WEXITSTATUS(status); } else { return -1; } } /* Set LD name (if not empty) */ if (strlen(ld_props->name) != 0) { SAFE_ASPRINTF(&command, "%s -LDSetProp -Name %s -L%d -a%d " "-Silent -NoLog > /dev/null 2>&1", MEGACLI_BIN, ld_props->name, ld_props->ldrive_id, ld_props->adapter_id); status = system(command); FREE_NULL(command); if (status == -1) { return -1; } else { if (WIFEXITED(status)) { if (WEXITSTATUS(status) != 0) return WEXITSTATUS(status); } else { return -1; } } } /* Done */ return 0; }
/* * Get MegaRAID logical (virtual) drive properties. */ MRLDPROPS *getMRLDProps(int adapter_id, int ldrive_id) { MRLDPROPS *ld_props = 0; FILE *megacli = NULL; char *command = NULL, *strtok_result = NULL; char line[MAX_MC_LINE] = {0}, temp_str[MAX_MC_LINE] = {0}; int status = 0; ld_props = (MRLDPROPS *) calloc(1, sizeof(MRLDPROPS)); if (ld_props != NULL) { ld_props->adapter_id = adapter_id; ld_props->ldrive_id = ldrive_id; /* Get cache policies */ SAFE_ASPRINTF(&command, "%s -LDGetProp -Cache -L%d -a%d -NoLog 2>&1", MEGACLI_BIN, ldrive_id, adapter_id); megacli = popen(command, "r"); while (fgets(line, sizeof(line), megacli) != NULL) { if (strstr(line, "Cache Policy:")) { strtok_result = strtok(line, ":"); strtok_result = strtok(NULL, ":"); strtok_result = strtok(NULL, ":"); strtok_result = strtok(NULL, ":"); strcpy(temp_str, strtok_result); /* Write policy */ strtok_result = strtok(temp_str, ","); if (strstr(strStrip(strtok_result), "WriteThrough")) { strncpy(ld_props->write_policy, "WT", MAX_MR_ATTR_SIZE); } else if (strstr(strStrip(strtok_result), "WriteBack")) { strncpy(ld_props->write_policy, "WB", MAX_MR_ATTR_SIZE); } else { strncpy(ld_props->write_policy, "UNKNOWN", MAX_MR_ATTR_SIZE); } /* Read policy */ strtok_result = strtok(NULL, ","); if (strstr(strStrip(strtok_result), "ReadAheadNone")) { strncpy(ld_props->read_policy, "NORA", MAX_MR_ATTR_SIZE); } else if (strstr(strStrip(strtok_result), "ReadAhead")) { strncpy(ld_props->read_policy, "RA", MAX_MR_ATTR_SIZE); } else if (strstr(strStrip(strtok_result), "ReadAdaptive")) { strncpy(ld_props->read_policy, "ADRA", MAX_MR_ATTR_SIZE); } else { strncpy(ld_props->read_policy, "UNKNOWN", MAX_MR_ATTR_SIZE); } /* Cache policy */ strtok_result = strtok(NULL, ","); if (strstr(strStrip(strtok_result), "Direct")) { strncpy(ld_props->cache_policy, "Direct", MAX_MR_ATTR_SIZE); } else if (strstr(strStrip(strtok_result), "Cached")) { strncpy(ld_props->cache_policy, "Cached", MAX_MR_ATTR_SIZE); } else { strncpy(ld_props->cache_policy, "UNKNOWN", MAX_MR_ATTR_SIZE); } /* BBU cache policy */ strtok_result = strtok(NULL, ","); if (strstr(strStrip(strtok_result), "No Write Cache if bad BBU")) { strncpy(ld_props->bbu_cache_policy, "NoCachedBadBBU", MAX_MR_ATTR_SIZE); } else if (strstr(strStrip(strtok_result), "Write Cache OK if bad BBU")) { strncpy(ld_props->bbu_cache_policy, "CachedBadBBU", MAX_MR_ATTR_SIZE); } else { strncpy(ld_props->bbu_cache_policy, "UNKNOWN", MAX_MR_ATTR_SIZE); } } } status = pclose(megacli); FREE_NULL(command); if (status != 0) { return NULL; } /* Get Name */ SAFE_ASPRINTF(&command, "%s -LDGetProp -Name -L%d -a%d -NoLog 2>&1", MEGACLI_BIN, ldrive_id, adapter_id); megacli = popen(command, "r"); while (fgets(line, sizeof(line), megacli) != NULL) { if (strstr(line, "Name:")) { strtok_result = strtok(line, ":"); strtok_result = strtok(NULL, ":"); strtok_result = strtok(NULL, ":"); strtok_result = strtok(NULL, ":"); strncpy(ld_props->name, strStrip(strtok_result), MAX_MR_ATTR_SIZE); } } status = pclose(megacli); FREE_NULL(command); if (status != 0) { return NULL; } } /* Done */ return ld_props; }
/* * Run the Device/Target Group Layout dialog */ void devTgtGrpLayoutDialog(CDKSCREEN *main_cdk_screen) { CDKSWINDOW *alua_info = 0; char *swindow_info[MAX_ALUA_LAYOUT_LINES] = {NULL}; int i = 0, line_pos = 0; char dir_name[MAX_SYSFS_PATH_SIZE] = {0}, tmp_buff[MAX_SYSFS_ATTR_SIZE] = {0}; DIR *dev_grp_dir_stream = NULL, *tgt_grp_dir_stream = NULL, *tgt_dir_stream = NULL, *dev_dir_stream = NULL; struct dirent *dev_grp_dir_entry = NULL, *tgt_grp_dir_entry = NULL, *tgt_dir_entry = NULL, *dev_dir_entry = NULL; /* Setup scrolling window widget */ alua_info = newCDKSwindow(main_cdk_screen, CENTER, CENTER, (ALUA_LAYOUT_ROWS + 2), (ALUA_LAYOUT_COLS + 2), "<C></31/B>SCST ALUA Device/Target Group Layout\n", MAX_ALUA_LAYOUT_LINES, TRUE, FALSE); if (!alua_info) { errorDialog(main_cdk_screen, SWINDOW_ERR_MSG, NULL); return; } setCDKSwindowBackgroundAttrib(alua_info, COLOR_DIALOG_TEXT); setCDKSwindowBoxAttribute(alua_info, COLOR_DIALOG_BOX); line_pos = 0; while (1) { /* We'll start with the SCST device groups */ snprintf(dir_name, MAX_SYSFS_PATH_SIZE, "%s/device_groups", SYSFS_SCST_TGT); if ((dev_grp_dir_stream = opendir(dir_name)) == NULL) { if (line_pos < MAX_ALUA_LAYOUT_LINES) { SAFE_ASPRINTF(&swindow_info[line_pos], "opendir(): %s", strerror(errno)); line_pos++; } break; } while ((dev_grp_dir_entry = readdir(dev_grp_dir_stream)) != NULL) { /* The device group names are directories; skip '.' and '..' */ if ((dev_grp_dir_entry->d_type == DT_DIR) && (strcmp(dev_grp_dir_entry->d_name, ".") != 0) && (strcmp(dev_grp_dir_entry->d_name, "..") != 0)) { if (line_pos < MAX_ALUA_LAYOUT_LINES) { SAFE_ASPRINTF(&swindow_info[line_pos], "</B>Device Group:<!B> %s", dev_grp_dir_entry->d_name); line_pos++; } /* Now get all of the device names for this device group */ snprintf(dir_name, MAX_SYSFS_PATH_SIZE, "%s/device_groups/%s/devices", SYSFS_SCST_TGT, dev_grp_dir_entry->d_name); if ((dev_dir_stream = opendir(dir_name)) == NULL) { if (line_pos < MAX_ALUA_LAYOUT_LINES) { SAFE_ASPRINTF(&swindow_info[line_pos], "opendir(): %s", strerror(errno)); line_pos++; } break; } while ((dev_dir_entry = readdir(dev_dir_stream)) != NULL) { /* The device names are links */ if (dev_dir_entry->d_type == DT_LNK) { if (line_pos < MAX_ALUA_LAYOUT_LINES) { SAFE_ASPRINTF(&swindow_info[line_pos], "\t</B>Device:<!B> %s", dev_dir_entry->d_name); line_pos++; } } } closedir(dev_dir_stream); /* Now get all of the target groups for this device group */ snprintf(dir_name, MAX_SYSFS_PATH_SIZE, "%s/device_groups/%s/target_groups", SYSFS_SCST_TGT, dev_grp_dir_entry->d_name); if ((tgt_grp_dir_stream = opendir(dir_name)) == NULL) { if (line_pos < MAX_ALUA_LAYOUT_LINES) { SAFE_ASPRINTF(&swindow_info[line_pos], "opendir(): %s", strerror(errno)); line_pos++; } break; } while ((tgt_grp_dir_entry = readdir(tgt_grp_dir_stream)) != NULL) { /* The target group names are directories; * skip '.' and '..' */ if ((tgt_grp_dir_entry->d_type == DT_DIR) && (strcmp(tgt_grp_dir_entry->d_name, ".") != 0) && (strcmp(tgt_grp_dir_entry->d_name, "..") != 0)) { if (line_pos < MAX_ALUA_LAYOUT_LINES) { snprintf(dir_name, MAX_SYSFS_PATH_SIZE, "%s/device_groups/%s/target_groups/%s/group_id", SYSFS_SCST_TGT, dev_grp_dir_entry->d_name, tgt_grp_dir_entry->d_name); readAttribute(dir_name, tmp_buff); SAFE_ASPRINTF(&swindow_info[line_pos], "\t</B>Target Group:<!B> %s (Group ID: %s)", tgt_grp_dir_entry->d_name, tmp_buff); line_pos++; } /* Loop over each target name for the * current target group */ snprintf(dir_name, MAX_SYSFS_PATH_SIZE, "%s/device_groups/%s/target_groups/%s", SYSFS_SCST_TGT, dev_grp_dir_entry->d_name, tgt_grp_dir_entry->d_name); if ((tgt_dir_stream = opendir(dir_name)) == NULL) { if (line_pos < MAX_ALUA_LAYOUT_LINES) { SAFE_ASPRINTF(&swindow_info[line_pos], "opendir(): %s", strerror(errno)); line_pos++; } break; } while ((tgt_dir_entry = readdir(tgt_dir_stream)) != NULL) { /* The target names are links (if local), * or directories (if remote); skip '.' and '..' */ if (((tgt_dir_entry->d_type == DT_DIR) && (strcmp(tgt_dir_entry->d_name, ".") != 0) && (strcmp(tgt_dir_entry->d_name, "..") != 0)) || (tgt_dir_entry->d_type == DT_LNK)) { if (line_pos < MAX_ALUA_LAYOUT_LINES) { snprintf(dir_name, MAX_SYSFS_PATH_SIZE, "%s/device_groups/%s/" "target_groups/%s/%s/rel_tgt_id", SYSFS_SCST_TGT, dev_grp_dir_entry->d_name, tgt_grp_dir_entry->d_name, tgt_dir_entry->d_name); readAttribute(dir_name, tmp_buff); SAFE_ASPRINTF(&swindow_info[line_pos], "\t\t</B>Target:<!B> %s " "(Rel Tgt ID: %s)", tgt_dir_entry->d_name, tmp_buff); line_pos++; } } } closedir(tgt_dir_stream); } } closedir(tgt_grp_dir_stream); /* Print a blank line to separate targets */ if (line_pos < MAX_ALUA_LAYOUT_LINES) { SAFE_ASPRINTF(&swindow_info[line_pos], " "); line_pos++; } } } closedir(dev_grp_dir_stream); break; } /* Add a message to the bottom explaining how to close the dialog */ if (line_pos < MAX_ALUA_LAYOUT_LINES) { SAFE_ASPRINTF(&swindow_info[line_pos], " "); line_pos++; } if (line_pos < MAX_ALUA_LAYOUT_LINES) { SAFE_ASPRINTF(&swindow_info[line_pos], CONTINUE_MSG); line_pos++; } /* Set the scrolling window content */ setCDKSwindowContents(alua_info, swindow_info, line_pos); /* The 'g' makes the swindow widget scroll to the top, then activate */ injectCDKSwindow(alua_info, 'g'); activateCDKSwindow(alua_info, 0); /* We fell through -- the user exited the widget, but we don't care how */ destroyCDKSwindow(alua_info); /* Done */ for (i = 0; i < MAX_ALUA_LAYOUT_LINES; i++) FREE_NULL(swindow_info[i]); return; }
/* * Run the Add Target to Group dialog */ void addTgtToGrpDialog(CDKSCREEN *main_cdk_screen) { WINDOW *add_tgt_window = 0; CDKSCREEN *add_tgt_screen = 0; CDKLABEL *add_tgt_info = 0; CDKENTRY *tgt_name = 0; CDKSCALE *rel_tgt_id = 0; CDKBUTTON *ok_button = 0, *cancel_button = 0; tButtonCallback ok_cb = &okButtonCB, cancel_cb = &cancelButtonCB; char dev_grp_name[MAX_SYSFS_ATTR_SIZE] = {0}, tgt_grp_name[MAX_SYSFS_ATTR_SIZE] = {0}, attr_path[MAX_SYSFS_PATH_SIZE] = {0}, attr_value[MAX_SYSFS_ATTR_SIZE] = {0}; char *error_msg = NULL; char *add_tgt_info_msg[TGT_GRP_INFO_LINES] = {NULL}; int add_tgt_window_lines = 0, add_tgt_window_cols = 0, window_y = 0, window_x = 0, temp_int = 0, i = 0, traverse_ret = 0; /* Have the user choose a SCST device group */ getSCSTDevGrpChoice(main_cdk_screen, dev_grp_name); if (dev_grp_name[0] == '\0') return; /* Get target group choice from user (based on previously * selected device group) */ getSCSTTgtGrpChoice(main_cdk_screen, dev_grp_name, tgt_grp_name); if (tgt_grp_name[0] == '\0') return; /* New CDK screen */ add_tgt_window_lines = 11; add_tgt_window_cols = 55; window_y = ((LINES / 2) - (add_tgt_window_lines / 2)); window_x = ((COLS / 2) - (add_tgt_window_cols / 2)); add_tgt_window = newwin(add_tgt_window_lines, add_tgt_window_cols, window_y, window_x); if (add_tgt_window == NULL) { errorDialog(main_cdk_screen, NEWWIN_ERR_MSG, NULL); return; } add_tgt_screen = initCDKScreen(add_tgt_window); if (add_tgt_screen == NULL) { errorDialog(main_cdk_screen, CDK_SCR_ERR_MSG, NULL); return; } boxWindow(add_tgt_window, COLOR_DIALOG_BOX); wbkgd(add_tgt_window, COLOR_DIALOG_TEXT); wrefresh(add_tgt_window); while (1) { /* Information label */ SAFE_ASPRINTF(&add_tgt_info_msg[0], "</31/B>Adding SCST target to target group..."); SAFE_ASPRINTF(&add_tgt_info_msg[1], " "); SAFE_ASPRINTF(&add_tgt_info_msg[2], "</B>Device group:<!B>\t%s", dev_grp_name); SAFE_ASPRINTF(&add_tgt_info_msg[3], "</B>Target group:<!B>\t%s", tgt_grp_name); add_tgt_info = newCDKLabel(add_tgt_screen, (window_x + 1), (window_y + 1), add_tgt_info_msg, ADD_TGT_INFO_LINES, FALSE, FALSE); if (!add_tgt_info) { errorDialog(main_cdk_screen, LABEL_ERR_MSG, NULL); break; } setCDKLabelBackgroundAttrib(add_tgt_info, COLOR_DIALOG_TEXT); /* Target name (entry) */ tgt_name = newCDKEntry(add_tgt_screen, (window_x + 1), (window_y + 6), NULL, "</B>Target Name: ", COLOR_DIALOG_SELECT, '_' | COLOR_DIALOG_INPUT, vMIXED, 20, 0, SCST_TGT_NAME_LEN, FALSE, FALSE); if (!tgt_name) { errorDialog(main_cdk_screen, ENTRY_ERR_MSG, NULL); break; } setCDKEntryBoxAttribute(tgt_name, COLOR_DIALOG_INPUT); /* Relative target ID (scale) */ rel_tgt_id = newCDKScale(add_tgt_screen, (window_x + 1), (window_y + 7), NULL, "</B>Relative Target ID: ", COLOR_DIALOG_SELECT, 7, 0, MIN_SCST_REL_TGT_ID, MAX_SCST_REL_TGT_ID, 1, 100, FALSE, FALSE); if (!rel_tgt_id) { errorDialog(main_cdk_screen, SCALE_ERR_MSG, NULL); break; } setCDKScaleBackgroundAttrib(rel_tgt_id, COLOR_DIALOG_TEXT); /* Buttons */ ok_button = newCDKButton(add_tgt_screen, (window_x + 16), (window_y + 9), g_ok_cancel_msg[0], ok_cb, FALSE, FALSE); if (!ok_button) { errorDialog(main_cdk_screen, BUTTON_ERR_MSG, NULL); break; } setCDKButtonBackgroundAttrib(ok_button, COLOR_DIALOG_INPUT); cancel_button = newCDKButton(add_tgt_screen, (window_x + 26), (window_y + 9), g_ok_cancel_msg[1], cancel_cb, FALSE, FALSE); if (!cancel_button) { errorDialog(main_cdk_screen, BUTTON_ERR_MSG, NULL); break; } setCDKButtonBackgroundAttrib(cancel_button, COLOR_DIALOG_INPUT); /* Allow user to traverse the screen */ refreshCDKScreen(add_tgt_screen); traverse_ret = traverseCDKScreen(add_tgt_screen); /* User hit 'OK' button */ if (traverse_ret == 1) { /* Turn the cursor off (pretty) */ curs_set(0); /* Check the entry field for bad characters */ if (!checkInputStr(main_cdk_screen, INIT_CHARS, getCDKEntryValue(tgt_name))) break; /* Add the target to the target group */ snprintf(attr_path, MAX_SYSFS_PATH_SIZE, "%s/device_groups/%s/target_groups/%s/mgmt", SYSFS_SCST_TGT, dev_grp_name, tgt_grp_name); snprintf(attr_value, MAX_SYSFS_ATTR_SIZE, "add %s", getCDKEntryValue(tgt_name)); if ((temp_int = writeAttribute(attr_path, attr_value)) != 0) { SAFE_ASPRINTF(&error_msg, "Couldn't add SCST (ALUA) target to target group: %s", strerror(temp_int)); errorDialog(main_cdk_screen, error_msg, NULL); FREE_NULL(error_msg); break; } /* Set the relative target ID */ snprintf(attr_path, MAX_SYSFS_PATH_SIZE, "%s/device_groups/%s/target_groups/%s/%s/rel_tgt_id", SYSFS_SCST_TGT, dev_grp_name, tgt_grp_name, getCDKEntryValue(tgt_name)); snprintf(attr_value, MAX_SYSFS_ATTR_SIZE, "%d", getCDKScaleValue(rel_tgt_id)); if ((temp_int = writeAttribute(attr_path, attr_value)) != 0) { SAFE_ASPRINTF(&error_msg, SET_REL_TGT_ID_ERR, strerror(temp_int)); errorDialog(main_cdk_screen, error_msg, NULL); FREE_NULL(error_msg); break; } } break; } /* Done */ for (i = 0; i < ADD_TGT_INFO_LINES; i++) FREE_NULL(add_tgt_info_msg[i]); if (add_tgt_screen != NULL) { destroyCDKScreenObjects(add_tgt_screen); destroyCDKScreen(add_tgt_screen); delwin(add_tgt_window); } return; }
IGraphicsWin::~IGraphicsWin() { CloseWindow(); FREE_NULL(mCustomColorStorage); }
/* * Get "settable" adapter properties from MegaCLI. */ MRADPPROPS *getMRAdapterProps(int adapter_id) { MRADPPROPS *adp_props = 0; FILE *megacli = NULL; char *command = NULL, *strtok_result = NULL; char line[MAX_MC_LINE] = {0}; int status = 0; adp_props = (MRADPPROPS *) calloc(1, sizeof(MRADPPROPS)); if (adp_props != NULL) { adp_props->adapter_id = adapter_id; /* Get CacheFlushInterval */ SAFE_ASPRINTF(&command, "%s -AdpGetProp CacheFlushInterval -a%d -NoLog 2>&1", MEGACLI_BIN, adapter_id); megacli = popen(command, "r"); while (fgets(line, sizeof(line), megacli) != NULL) { if (strstr(line, "Cache Flush Interval")) { strtok_result = strtok(line, "="); strtok_result = strtok(NULL, "="); sscanf(strStrip(strtok_result), "%d", &adp_props->cache_flush); } } status = pclose(megacli); FREE_NULL(command); if (status != 0) { return NULL; } /* Get RebuildRate */ SAFE_ASPRINTF(&command, "%s -AdpGetProp RebuildRate -a%d -NoLog 2>&1", MEGACLI_BIN, adapter_id); megacli = popen(command, "r"); while (fgets(line, sizeof(line), megacli) != NULL) { if (strstr(line, "Rebuild Rate")) { strtok_result = strtok(line, "="); strtok_result = strtok(NULL, "="); sscanf(strStrip(strtok_result), "%d", &adp_props->rebuild_rate); } } status = pclose(megacli); FREE_NULL(command); if (status != 0) { return NULL; } /* Get ClusterEnable */ SAFE_ASPRINTF(&command, "%s -AdpGetProp ClusterEnable -a%d -NoLog 2>&1", MEGACLI_BIN, adapter_id); megacli = popen(command, "r"); while (fgets(line, sizeof(line), megacli) != NULL) { if (strstr(line, "Cluster :")) { strtok_result = strtok(line, ":"); strtok_result = strtok(NULL, ":"); strtok_result = strtok(NULL, ":"); if (strcmp(strStrip(strtok_result), "Enabled") == 0) { adp_props->cluster = TRUE; } else if (strcmp(strStrip(strtok_result), "Disabled") == 0) { adp_props->cluster = FALSE; } } } status = pclose(megacli); FREE_NULL(command); if (status != 0) { return NULL; } /* Get NCQDsply */ SAFE_ASPRINTF(&command, "%s -AdpGetProp NCQDsply -a%d -NoLog 2>&1", MEGACLI_BIN, adapter_id); megacli = popen(command, "r"); while (fgets(line, sizeof(line), megacli) != NULL) { if (strstr(line, "NCQ Status is")) { strtok_result = strtok(line, ":"); strtok_result = strtok(NULL, ":"); if (strcmp(strStrip(strtok_result), "NCQ Status is Enabled") == 0) { adp_props->ncq = TRUE; } else if (strcmp(strStrip(strtok_result), "NCQ Status is Disabled") == 0) { adp_props->ncq = FALSE; } } } status = pclose(megacli); FREE_NULL(command); if (status != 0) { FREE_NULL(adp_props); return NULL; } } /* Done */ return adp_props; }
/* * Get MegaRAID enclosure information; not happy about how this is * implemented -- if LSI could have just made all of the MegaCLI commands * uniform (eg, be able to specify an enclosure like you specify an adapter)! */ MRENCL *getMREnclosure(int adapter_id, int encl_id) { MRENCL *enclosure = 0; FILE *megacli = NULL; char *command = NULL, *strtok_result = NULL; char line[MAX_MC_LINE] = {0}; int status = 0; int counters[] = {0, 0, 0, 0, 0, 0, 0}; enclosure = (MRENCL *) calloc(1, sizeof(MRENCL)); if (enclosure != NULL) { enclosure->adapter_id = adapter_id; /* MegaCLI command */ SAFE_ASPRINTF(&command, "%s -EncInfo -a%d -NoLog 2>&1", MEGACLI_BIN, adapter_id); megacli = popen(command, "r"); /* Loop over command output */ while (fgets(line, sizeof(line), megacli) != NULL) { if (strstr(line, " Device ID :")) { strtok_result = strtok(line, ":"); strtok_result = strtok(NULL, ":"); if (counters[0] == encl_id) sscanf(strtok_result, " %d", &enclosure->device_id); counters[0]++; } else if (strstr(line, " Number of Slots :")) { strtok_result = strtok(line, ":"); strtok_result = strtok(NULL, ":"); if (counters[1] == encl_id) sscanf(strtok_result, " %d", &enclosure->slots); counters[1]++; } else if (strstr(line, " Number of Power Supplies :")) { strtok_result = strtok(line, ":"); strtok_result = strtok(NULL, ":"); if (counters[2] == encl_id) sscanf(strtok_result, " %d", &enclosure->power_supps); counters[2]++; } else if (strstr(line, " Number of Fans :")) { strtok_result = strtok(line, ":"); strtok_result = strtok(NULL, ":"); if (counters[3] == encl_id) sscanf(strtok_result, " %d", &enclosure->fans); counters[3]++; } else if (strstr(line, " Status :")) { strtok_result = strtok(line, ":"); strtok_result = strtok(NULL, ":"); if (counters[4] == encl_id) strncpy(enclosure->status, strStrip(strtok_result), MAX_MR_ATTR_SIZE); counters[4]++; } else if (strstr(line, " Vendor Identification :")) { strtok_result = strtok(line, ":"); strtok_result = strtok(NULL, ":"); if (counters[5] == encl_id) strncpy(enclosure->vendor, strStrip(strtok_result), MAX_MR_ATTR_SIZE); counters[5]++; } else if (strstr(line, " Product Identification :")) { strtok_result = strtok(line, ":"); strtok_result = strtok(NULL, ":"); if (counters[6] == encl_id) strncpy(enclosure->product, strStrip(strtok_result), MAX_MR_ATTR_SIZE); counters[6]++; } } /* Done with MegaCLI */ status = pclose(megacli); FREE_NULL(command); if (status != 0) { FREE_NULL(enclosure); return NULL; } } /* Done */ return enclosure; }
/* * Get MegaRAID disk information. */ MRDISK *getMRDisk(int adapter_id, int encl_id, int slot) { MRDISK *disk = 0; FILE *megacli = NULL; char *command = NULL, *strtok_result = NULL; char line[MAX_MC_LINE] = {0}; int status = 0; disk = (MRDISK *) calloc(1, sizeof(MRDISK)); if (disk != NULL) { disk->adapter_id = adapter_id; disk->present = TRUE; disk->part_of_ld = FALSE; /* MegaCLI command */ SAFE_ASPRINTF(&command, "%s -pdInfo -PhysDrv[%d:%d] -a%d -NoLog 2>&1", MEGACLI_BIN, encl_id, slot, adapter_id); megacli = popen(command, "r"); /* Loop over command output */ while (fgets(line, sizeof(line), megacli) != NULL) { if (strstr(line, "is not found.")) { /* A disk isn't present in the specified slot */ disk->present = FALSE; continue; } else if (strstr(line, "Enclosure Device ID:")) { sscanf(line, "%*s %*s %*s %d", &disk->enclosure_id); } else if (strstr(line, "Slot Number:")) { sscanf(line, "%*s %*s %d", &disk->slot_num); } else if (strstr(line, "PD Type:")) { strtok_result = strtok(line, ":"); strtok_result = strtok(NULL, ":"); strncpy(disk->pd_type, strStrip(strtok_result), MAX_MR_ATTR_SIZE); } else if (strstr(line, "Raw Size:")) { strtok_result = strtok(line, ":"); strtok_result = strtok(NULL, ":"); strncpy(disk->raw_size, strStrip(strtok_result), MAX_MR_ATTR_SIZE); } else if (strstr(line, "Firmware state:")) { strtok_result = strtok(line, ":"); strtok_result = strtok(NULL, ":"); strncpy(disk->state, strStrip(strtok_result), MAX_MR_ATTR_SIZE); } else if (strstr(line, "Inquiry Data:")) { strtok_result = strtok(line, ":"); strtok_result = strtok(NULL, ":"); strncpy(disk->inquiry, strStrip(strtok_result), MAX_MR_ATTR_SIZE); } else if (strstr(line, "Link Speed:")) { strtok_result = strtok(line, ":"); strtok_result = strtok(NULL, ":"); strncpy(disk->speed, strStrip(strtok_result), MAX_MR_ATTR_SIZE); } else if (strstr(line, "Drive's position:")) { /* If the PD entry contains the string above, then its * part of a logical drive (LD). */ disk->part_of_ld = TRUE; } } /* Done with MegaCLI */ status = pclose(megacli); FREE_NULL(command); if (status != 0) { FREE_NULL(disk); return NULL; } } /* Done */ return disk; }
IPopupMenu* IGraphicsWin::CreateIPopupMenu(IPopupMenu* pMenu, IRECT* pAreaRect) { ReleaseMouseCapture(); int numItems = pMenu->GetNItems(); POINT cPos; cPos.x = pAreaRect->L; cPos.y = pAreaRect->B; ClientToScreen(mPlugWnd, &cPos); HMENU hMenu = CreatePopupMenu(); int flags = 0; if(numItems && hMenu) { for(int i = 0; i< numItems;i++) { IPopupMenuItem* menuItem = pMenu->GetItem(i); if (menuItem->GetIsSeparator()) { AppendMenu (hMenu, MF_SEPARATOR, 0, 0); } else { const char* str = menuItem->GetText(); char* titleWithPrefixNumbers = 0; if (pMenu->GetPrefix()) { titleWithPrefixNumbers = (char*)malloc(strlen(str) + 50); switch (pMenu->GetPrefix()) { case 1: { sprintf(titleWithPrefixNumbers, "%1d: %s", i+1, str); break; } case 2: { sprintf(titleWithPrefixNumbers, "%02d: %s", i+1, str); break; } case 3: { sprintf(titleWithPrefixNumbers, "%03d: %s", i+1, str); break; } } } const char* entryText (titleWithPrefixNumbers ? titleWithPrefixNumbers : str); flags = MF_STRING; //if (nbEntries < 160 && _menu->getNbItemsPerColumn () > 0 && inc && !(inc % _menu->getNbItemsPerColumn ())) // flags |= MF_MENUBARBREAK; if (menuItem->GetSubmenu()) { // HMENU submenu = createMenu (item->getSubmenu (), offsetIdx); // if (submenu) // { // AppendMenu (menu, flags|MF_POPUP|MF_ENABLED, (UINT_PTR)submenu, (const TCHAR*)entryText); // } } else { if (menuItem->GetEnabled()) flags |= MF_ENABLED; else flags |= MF_GRAYED; if (menuItem->GetIsTitle()) flags |= MF_DISABLED; //if (multipleCheck && menuItem->GetChecked()) // flags |= MF_CHECKED; if (menuItem->GetChecked()) flags |= MF_CHECKED; else flags |= MF_UNCHECKED; //if (!(flags & MF_CHECKED)) // flags |= MF_UNCHECKED; AppendMenu(hMenu, flags, i+1, entryText); } if(titleWithPrefixNumbers) FREE_NULL(titleWithPrefixNumbers); } } int itemChosen = TrackPopupMenu(hMenu, TPM_LEFTALIGN/*|TPM_VCENTERALIGN*/|TPM_NONOTIFY|TPM_RETURNCMD, cPos.x, cPos.y, 0, mPlugWnd, 0); // IPopupMenu* chosenMenu; if (itemChosen > 0) { pMenu->SetChosenItemIdx(itemChosen - 1); DestroyMenu(hMenu); return pMenu; } else { DestroyMenu(hMenu); return 0; } } else return 0; }