/** * acquire_cpu * * Acquire a new cpu for this partition from the hypervisor. * If drc_index is zero, look up an available index to use. * * @param drc_index * @returns pointer to cpu_info on success, NULL otherwise */ static int acquire_cpu(struct dr_node *cpu, struct dr_info *dr_info) { struct of_node *of_nodes; int rc; rc = acquire_drc(cpu->drc_index); if (rc) { say(DEBUG, "Could not acquire drc resources for %s\n", cpu->name); return rc; } of_nodes = configure_connector(cpu->drc_index); if (of_nodes == NULL) { say(ERROR, "Call to configure_connector failed for %s\n", cpu->name); release_drc(cpu->drc_index, CPU_DEV); return -1; } rc = add_device_tree_nodes(CPU_OFDT_BASE, of_nodes); free_of_node(of_nodes); if (rc) { say(ERROR, "Failure to add device tree nodes for %s\n", cpu->name); release_drc(cpu->drc_index, CPU_DEV); return rc; } update_cpu_node(cpu, NULL, dr_info); refresh_cache_info(dr_info); return 0; }
/** * add_lmbs * * Attempt to acquire and online the given number of LMBs. * This function calls itself recursively to simplify recovery * actions in case of an error. This is intended only for the case * where the user does not specify a drc-name. * * @param nr_lmbs number of lmbs to add * @param lmb_list list of lmbs on the partition * @returns 0 on success, !0 otherwise */ static int add_lmbs(struct lmb_list_head *lmb_list) { int rc = 0; struct dr_node *lmb_head = lmb_list->lmbs; struct dr_node *lmb; lmb_list->lmbs_modified = 0; while (lmb_list->lmbs_modified < usr_drc_count) { if (drmgr_timed_out()) break; lmb = get_available_lmb(lmb_head); if (lmb == NULL) return -1; /* Iterate only over the remaining LMBs */ lmb_head = lmb->next; rc = acquire_drc(lmb->drc_index); if (rc) { report_unknown_error(__FILE__, __LINE__); lmb->unusable = 1; continue; } rc = add_device_tree_lmb(lmb, lmb_list); if (rc) { report_unknown_error(__FILE__, __LINE__); release_drc(lmb->drc_index, MEM_DEV); lmb->unusable = 1; continue; } rc = set_lmb_state(lmb, ONLINE); if (rc) { report_unknown_error(__FILE__, __LINE__); remove_device_tree_lmb(lmb, lmb_list); release_drc(lmb->drc_index, MEM_DEV); lmb->unusable = 1; continue; } lmb_list->lmbs_modified++; } return rc; }
/** * acquire_phb * */ static int acquire_phb(char *drc_name, struct dr_node **phb) { struct dr_connector drc; struct of_node *of_nodes; char path[DR_PATH_MAX]; int rc; rc = get_drc_by_name(drc_name, &drc, path, OFDT_BASE); if (rc) { say(ERROR, "Could not find drc index for %s, unable to add the" "PHB.\n", drc_name); return rc; } rc = acquire_drc(drc.index); if (rc) return rc; of_nodes = configure_connector(drc.index); if (of_nodes == NULL) { release_drc(drc.index, PHB_DEV); return -1; } rc = add_device_tree_nodes(path, of_nodes); free_of_node(of_nodes); if (rc) { say(ERROR, "add_device_tree_nodes failed at %s\n", path); release_drc(drc.index, PHB_DEV); return -1; } /* Now that the node has been added to the device-tree, retrieve it. * This also acts as a sanity check that everything up to this * point has succeeded. */ *phb = get_node_by_name(drc_name, PHB_NODES); if (*phb == NULL) { say(ERROR, "Could not get find \"%s\"\n", drc_name); /* or should we call release_drc? but need device type */ release_drc(drc.index, PHB_DEV); return -1; } return 0; }
/** * remove_lmbs * * @param nr_lmbs * @param lmb_list * @return 0 on success, !0 otherwise */ static int remove_lmbs(struct lmb_list_head *lmb_list) { struct dr_node *lmb_head = lmb_list->lmbs; struct dr_node *lmb; int rc; while (lmb_list->lmbs_modified < usr_drc_count) { if (drmgr_timed_out()) break; lmb = get_available_lmb(lmb_head); if (!lmb) return -1; /* Iterate only over the remaining LMBs */ lmb_head = lmb->next; rc = set_lmb_state(lmb, OFFLINE); if (rc) { lmb->unusable = 1; continue; } rc = remove_device_tree_lmb(lmb, lmb_list); if (rc) { report_unknown_error(__FILE__, __LINE__); set_lmb_state(lmb, ONLINE); lmb->unusable = 1; continue; } while (lmb->lmb_mem_scns) { struct mem_scn *scn = lmb->lmb_mem_scns; lmb->lmb_mem_scns = scn->next; free(scn); } rc = release_drc(lmb->drc_index, 0); if (rc) { report_unknown_error(__FILE__, __LINE__); add_device_tree_lmb(lmb, lmb_list); set_lmb_state(lmb, ONLINE); lmb->unusable = 1; continue; } lmb->is_removable = 0; lmb_list->lmbs_modified++; } return 0; }
/** * release_phb * */ static int release_phb(struct dr_node *phb) { int rc; rc = remove_device_tree_nodes(phb->ofdt_path); if (rc) return rc; if (phb->phb_ic_ofdt_path[0] != '\0') { rc = remove_device_tree_nodes(phb->phb_ic_ofdt_path); if (rc) return rc; } rc = release_drc(phb->drc_index, PHB_DEV); return rc; }
/** * release_cpu * * Release a cpu back to the hypervisor, using the cpu's drc-index. * The cpu must have already been offlined. We remove the cpu from the * device tree only when the isolate and set_indicator have succeeded. * The caller must not use the value given for the cpu parameter after * this function has returned. * * @param cpu * @returns 0 on success, !0 otherwise */ int release_cpu(struct dr_node *cpu, struct dr_info *dr_info) { int release_file; int rc; release_file = open(CPU_RELEASE_FILE, O_WRONLY); if (release_file > 0) { /* DLPAR can be done in kernel */ char *path = cpu->ofdt_path + strlen(OFDT_BASE); int write_len = strlen(path); say(DEBUG, "Releasing cpu \"%s\"\n", path); rc = write(release_file, path, write_len); if (rc != write_len) say(ERROR, "Release failed! rc = %d\n", rc); else /* set rc to success */ rc = 0; close(release_file); } else { /* Must do DLPAR from user-space */ rc = offline_cpu(cpu); if (rc) { say(ERROR, "Could not offline cpu %s\n", cpu->drc_name); return rc; } rc = release_drc(cpu->drc_index, CPU_DEV); if (rc) { say(ERROR, "Could not release drc resources for %s\n", cpu->name); return rc; } rc = remove_device_tree_nodes(cpu->ofdt_path); if (rc) { struct of_node *of_nodes; say(ERROR, "Could not remove device tree nodes %s\n", cpu->name); of_nodes = configure_connector(cpu->drc_index); if (of_nodes == NULL) { say(ERROR, "Call to configure_connector failed " "for %s. The device tree\nmay contain " "invalid data for this cpu and a " "re-activation of the partition is " "needed to correct it.\n", cpu->name); } else { rc = add_device_tree_nodes(CPU_OFDT_BASE, of_nodes); free_of_node(of_nodes); } acquire_drc(cpu->drc_index); return rc; } release_caches(cpu, dr_info); } return rc; }
/** * add_device_tree_lmb * @brief Update the device tree for the lmb being added.. * * @param lmb lmb to acquire * @param lmb_list list of all lmbs * @returns 0 on success, !0 otherwise */ static int add_device_tree_lmb(struct dr_node *lmb, struct lmb_list_head *lmb_list) { int rc; lmb->lmb_of_node = configure_connector(lmb->drc_index); if (lmb->lmb_of_node == NULL) { release_drc(lmb->drc_index, MEM_DEV); return -1; } if (lmb_list->drconf_buf) { errno = 0; rc = update_drconf_node(lmb, lmb_list, ADD); if (errno == ENODEV) { /* Due to bug in pre 2.6.27 kernels, updating the * property in the device tree fails when the phandle * is processed as a signed int instead of unsigned * In this case we provide this little hack to allow * memory add to work on these kernels. */ say(DEBUG, "Assuming older kernel, trying to add " "node\n"); sprintf(lmb->ofdt_path, "%s/%s", OFDT_BASE, lmb->lmb_of_node->name); rc = add_device_tree_nodes(OFDT_BASE, lmb->lmb_of_node); } else { sprintf(lmb->ofdt_path, "%s/%s", OFDT_BASE, "/ibm,dynamic-reconfiguration-memory"); } } else { /* Add the new nodes to the device tree */ sprintf(lmb->ofdt_path, "%s/%s", OFDT_BASE, lmb->lmb_of_node->name); rc = add_device_tree_nodes(OFDT_BASE, lmb->lmb_of_node); } if (rc) return rc; if (! lmb_list->drconf_buf) { /* Find the physical address for this lmb. This is only * needed for non-drconf memory. The address for drconf * lmbs is correctly initialized when building the lmb list */ char *tmp = strrchr(lmb->ofdt_path, '@'); if (tmp == NULL) { say(DEBUG, "Could not determine physical address for " "%s\n", lmb->ofdt_path); remove_device_tree_nodes(lmb->ofdt_path); return -1; } lmb->lmb_address = strtoull(tmp + 1, NULL, 16); rc = get_lmb_size(lmb); if (rc) { remove_device_tree_nodes(lmb->ofdt_path); return rc; } } rc = get_mem_scns(lmb); if (rc) remove_device_tree_lmb(lmb, lmb_list); return rc; }