static int check_part_gpt(disk_t *disk, const int verbose,partition_t *partition, const int saveheader) { int ret=0; unsigned int old_levels; old_levels=log_set_levels(0); if(guid_cmp(partition->part_type_gpt, GPT_ENT_TYPE_MS_BASIC_DATA)==0 || guid_cmp(partition->part_type_gpt, GPT_ENT_TYPE_MS_RESERVED)==0) { ret=check_FAT(disk,partition,verbose); if(ret!=0) ret=check_EXFAT(disk, partition); if(ret!=0) ret=check_NTFS(disk,partition,verbose,0); if(ret!=0) ret=check_ReFS(disk, partition); if(ret!=0) ret=check_linux(disk, partition, verbose); if(ret!=0) screen_buffer_add("No FAT, NTFS, ext2, JFS, Reiser, cramfs or XFS marker\n"); } else if(guid_cmp(partition->part_type_gpt, GPT_ENT_TYPE_LINUX_RAID)==0) { ret=check_MD(disk, partition, verbose); if(ret!=0) screen_buffer_add("Invalid RAID superblock\n"); } else if(guid_cmp(partition->part_type_gpt, GPT_ENT_TYPE_LINUX_LVM)==0) { ret=check_LVM(disk, partition, verbose); if(ret!=0) ret=check_LVM2(disk, partition, verbose); if(ret!=0) screen_buffer_add("No LVM or LVM2 structure\n"); } else if(guid_cmp(partition->part_type_gpt, GPT_ENT_TYPE_MAC_HFS)==0) { ret=check_HFS(disk, partition, verbose); if(ret!=0) ret=check_HFSP(disk, partition, verbose); if(ret!=0) screen_buffer_add("No HFS or HFS+ structure\n"); } log_set_levels(old_levels); if(ret!=0) { log_error("check_part_gpt failed for partition\n"); log_partition(disk, partition); aff_part_buffer(AFF_PART_ORDER|AFF_PART_STATUS,disk,partition); if(saveheader>0) { save_header(disk, partition, verbose); } } return ret; }
int interface_superblock(disk_t *disk_car,list_part_t *list_part, char**current_cmd) { const list_part_t *parts; const partition_t *old_part=NULL; #ifdef HAVE_NCURSES struct MenuItem menuSuperblock[]= { { 'P', "Previous",""}, { 'N', "Next","" }, { 'Q',"Quit","Return to Advanced menu"}, { 0, NULL, NULL } }; #endif screen_buffer_reset(); #ifdef HAVE_NCURSES aff_copy(stdscr); wmove(stdscr,4,0); wprintw(stdscr,"%s",disk_car->description(disk_car)); wmove(stdscr,5,0); mvwaddstr(stdscr,6,0,msg_PART_HEADER_LONG); #endif for(parts=list_part;parts!=NULL;parts=parts->next) { const partition_t *partition=parts->part; if(old_part==NULL || old_part->part_offset!=partition->part_offset || old_part->part_size!=partition->part_size || guid_cmp(old_part->part_type_gpt, partition->part_type_gpt)!=0 || old_part->part_type_i386!=partition->part_type_i386 || old_part->part_type_sun!=partition->part_type_sun || old_part->part_type_mac!=partition->part_type_mac || old_part->upart_type!=partition->upart_type) { aff_part_buffer(AFF_PART_BASE, disk_car, partition); old_part=partition; } if(partition->blocksize!=0) screen_buffer_add("superblock %lu, blocksize=%u [%s]\n", (long unsigned)(partition->sb_offset/partition->blocksize), partition->blocksize, partition->fsname); } if(list_part!=NULL) { const partition_t *partition=list_part->part; screen_buffer_add("\n"); screen_buffer_add("To repair the filesystem using alternate superblock, run\n"); screen_buffer_add("fsck.ext%u -p -b superblock -B blocksize device\n", (partition->upart_type==UP_EXT2?2: (partition->upart_type==UP_EXT3?3:4))); } screen_buffer_to_log(); if(*current_cmd==NULL) { log_flush(); #ifdef HAVE_NCURSES screen_buffer_display(stdscr,"",menuSuperblock); #endif } return 0; }
/* * Clear existing diagnostic results for the specified diagnostic * and optionally for the specified device. */ void diag_clear_results(const enum diagnostic_test type, const NVM_BOOL clear_specific_device, const NVM_GUID device_guid) { int event_count; PersistentStore *p_store = get_lib_store(); if (p_store) { db_get_event_count_by_event_type_type(p_store, type, &event_count); struct db_event events[event_count]; db_get_events_by_event_type_type(p_store, type, events, event_count); for (int i = 0; i < event_count; i++) { NVM_BOOL matched = 1; // check for a matching guid is requested if (clear_specific_device) { COMMON_GUID guid; str_to_guid(events[i].guid, guid); if (guid_cmp(guid, device_guid) != 1) { matched = 0; } } if (matched) { db_delete_event_by_id(p_store, events[i].id); } } } }
void RpcServiceResponseTimeDialog::addDceRpcProgramVersion(_dcerpc_uuid_key *key) { if (guid_cmp(&(dce_name_to_uuid_key_[program_combo_->currentText()]->uuid), &(key->uuid))) return; versions_ << key->ver; std::sort(versions_.begin(), versions_.end()); }
static const char *get_gpt_typename(const efi_guid_t part_type_gpt) { int i; for(i=0; gpt_sys_types[i].name!=NULL; i++) if(guid_cmp(gpt_sys_types[i].part_type, part_type_gpt)==0) return gpt_sys_types[i].name; return NULL; }
static list_part_t *init_part_order_gpt(const disk_t *disk_car, list_part_t *list_part) { list_part_t *element; unsigned int order=1; for(element=list_part;element!=NULL;element=element->next) { if(element->part->part_size>0 && guid_cmp(element->part->part_type_gpt, GPT_ENT_TYPE_UNUSED)!=0) element->part->order=order++; } return list_part; }
static void partition_generate_gpt_entry(struct gpt_ent* gpt_entry, const partition_t *partition, const disk_t *disk_car) { guid_cpy(&gpt_entry->ent_type, &partition->part_type_gpt); gpt_entry->ent_lba_start=le64(partition->part_offset / disk_car->sector_size); gpt_entry->ent_lba_end=le64((partition->part_offset + partition->part_size - 1) / disk_car->sector_size); str2UCSle((uint16_t *)&gpt_entry->ent_name, partition->partname, sizeof(gpt_entry->ent_name)/2); if(guid_cmp(partition->part_uuid, GPT_ENT_TYPE_UNUSED)!=0) guid_cpy(&gpt_entry->ent_uuid, &partition->part_uuid); else efi_generate_uuid(&gpt_entry->ent_uuid); gpt_entry->ent_attr=le64(0); /* May need fixing */ }
static int is_part_hfsp(const partition_t *partition) { switch(partition->part_type_i386) { case P_HFSP: return 1; } switch(partition->part_type_mac) { case PMAC_HFS: return 1; } if(guid_cmp(partition->part_type_gpt,GPT_ENT_TYPE_MAC_HFS)==0) return 1; return 0; }
NVM_UINT16 wbem::logic::PostLayoutAddressDecoderLimitCheck::getSocketIdForDimm(NVM_GUID &guid) { LogEnterExit logging(__FUNCTION__, __FILE__, __LINE__); NVM_UINT16 socketId = 0; for (std::vector<struct device_discovery>::const_iterator iter = m_devices.begin(); iter != m_devices.end(); iter++) { if (guid_cmp(iter->guid, guid)) { socketId = iter->socket_id; break; } } return socketId; }
void RpcServiceResponseTimeDialog::setDceRpcUuidAndVersion(_e_guid_t *uuid, int version) { bool found = false; for (int pi = 0; pi < program_combo_->count(); pi++) { if (guid_cmp(uuid, &(dce_name_to_uuid_key_[program_combo_->itemText(pi)]->uuid)) == 0) { program_combo_->setCurrentIndex(pi); for (int vi = 0; vi < version_combo_->count(); vi++) { if (version == (int) version_combo_->itemData(vi).toUInt()) { version_combo_->setCurrentIndex(vi); found = true; break; } } break; } } if (found) fillTree(); }
static int is_part_known_gpt(const partition_t *partition) { return (guid_cmp(partition->part_type_gpt, GPT_ENT_TYPE_UNUSED)!=0); }
list_part_t *add_partition_gpt_cli(disk_t *disk_car,list_part_t *list_part, char **current_cmd) { partition_t *new_partition=partition_new(&arch_gpt); new_partition->part_offset=disk_car->sector_size; new_partition->part_size=disk_car->disk_size-new_partition->part_offset; while(*current_cmd[0]==',') (*current_cmd)++; while(1) { if(strncmp(*current_cmd,"s,",2)==0) { uint64_t part_offset; (*current_cmd)+=2; part_offset=new_partition->part_offset; new_partition->part_offset=(uint64_t)ask_number_cli( current_cmd, new_partition->part_offset/disk_car->sector_size, 1, (disk_car->disk_size-1)/disk_car->sector_size, "Enter the starting sector ") * (uint64_t)disk_car->sector_size; new_partition->part_size=new_partition->part_size + part_offset - new_partition->part_offset; } else if(strncmp(*current_cmd,"S,",2)==0) { (*current_cmd)+=2; new_partition->part_size=(uint64_t)ask_number_cli( current_cmd, (new_partition->part_offset+new_partition->part_size-1)/disk_car->sector_size, new_partition->part_offset/disk_car->sector_size, (disk_car->disk_size-1)/disk_car->sector_size, "Enter the ending sector ") * (uint64_t)disk_car->sector_size + disk_car->sector_size - new_partition->part_offset; } else if(strncmp(*current_cmd,"T,",2)==0) { (*current_cmd)+=2; change_part_type_cli(disk_car,new_partition,current_cmd); } else if(new_partition->part_size>0 && guid_cmp(new_partition->part_type_gpt, GPT_ENT_TYPE_UNUSED)!=0) { int insert_error=0; list_part_t *new_list_part=insert_new_partition(list_part, new_partition, 0, &insert_error); if(insert_error>0) { free(new_partition); return new_list_part; } new_partition->status=STATUS_PRIM; if(test_structure_gpt(list_part)!=0) new_partition->status=STATUS_DELETED; return new_list_part; } else { free(new_partition); return list_part; } } }
list_part_t *read_part_gpt(disk_t *disk_car, const int verbose, const int saveheader) { struct gpt_hdr *gpt; struct gpt_ent* gpt_entries; list_part_t *new_list_part=NULL; unsigned int i; uint32_t gpt_entries_size; uint64_t gpt_entries_offset; gpt=(struct gpt_hdr*)MALLOC(disk_car->sector_size); screen_buffer_reset(); if((unsigned)disk_car->pread(disk_car, gpt, disk_car->sector_size, disk_car->sector_size) != disk_car->sector_size) { free(gpt); return NULL; } if(memcmp(gpt->hdr_sig, GPT_HDR_SIG, 8)!=0) { screen_buffer_add("Bad GPT partition, invalid signature.\n"); free(gpt); return NULL; } if(verbose>0) { log_info("hdr_size=%llu\n", (long long unsigned)le32(gpt->hdr_size)); log_info("hdr_lba_self=%llu\n", (long long unsigned)le64(gpt->hdr_lba_self)); log_info("hdr_lba_alt=%llu (expected %llu)\n", (long long unsigned)le64(gpt->hdr_lba_alt), (long long unsigned)((disk_car->disk_size-1)/disk_car->sector_size)); log_info("hdr_lba_start=%llu\n", (long long unsigned)le64(gpt->hdr_lba_start)); log_info("hdr_lba_end=%llu\n", (long long unsigned)le64(gpt->hdr_lba_end)); log_info("hdr_lba_table=%llu\n", (long long unsigned)le64(gpt->hdr_lba_table)); log_info("hdr_entries=%llu\n", (long long unsigned)le32(gpt->hdr_entries)); log_info("hdr_entsz=%llu\n", (long long unsigned)le32(gpt->hdr_entsz)); } /* Check header size */ if(le32(gpt->hdr_size)<92 || le32(gpt->hdr_size) > disk_car->sector_size) { screen_buffer_add("GPT: invalid header size.\n"); free(gpt); return NULL; } { /* CRC check */ uint32_t crc; uint32_t origcrc; origcrc=le32(gpt->hdr_crc_self); gpt->hdr_crc_self=le32(0); crc=get_crc32(gpt, le32(gpt->hdr_size), 0xFFFFFFFF)^0xFFFFFFFF; if(crc!=origcrc) { screen_buffer_add("Bad GPT partition, invalid header checksum.\n"); free(gpt); return NULL; } gpt->hdr_crc_self=le32(origcrc); } if(le64(gpt->hdr_lba_self)!=1) { screen_buffer_add("Bad GPT partition, invalid LBA self location.\n"); free(gpt); return NULL; } if(le64(gpt->hdr_lba_start) >= le64(gpt->hdr_lba_end)) { screen_buffer_add("Bad GPT partition, invalid LBA start/end location.\n"); free(gpt); return NULL; } if(le32(gpt->hdr_revision)!=GPT_HDR_REVISION) { screen_buffer_add("GPT: Warning - not revision 1.0\n"); } if(le32(gpt->__reserved)!=0) { screen_buffer_add("GPT: Warning - __reserved!=0\n"); } if(le32(gpt->hdr_entries)==0 || le32(gpt->hdr_entries)>4096) { screen_buffer_add("GPT: invalid number (%u) of partition entries.\n", (unsigned int)le32(gpt->hdr_entries)); free(gpt); return NULL; } /* le32(gpt->hdr_entsz)==128 */ if(le32(gpt->hdr_entsz)%8!=0 || le32(gpt->hdr_entsz)<128 || le32(gpt->hdr_entsz)>4096) { screen_buffer_add("GPT: invalid partition entry size.\n"); free(gpt); return NULL; } gpt_entries_size=le32(gpt->hdr_entries) * le32(gpt->hdr_entsz); if(gpt_entries_size<16384) { screen_buffer_add("GPT: A minimum of 16,384 bytes of space must be reserved for the GUID Partition Entry array.\n"); free(gpt); return NULL; } gpt_entries_offset=(uint64_t)le64(gpt->hdr_lba_table) * disk_car->sector_size; if((uint64_t) le64(gpt->hdr_lba_self) + le32(gpt->hdr_size) - 1 >= gpt_entries_offset || gpt_entries_offset >= le64(gpt->hdr_lba_start) * disk_car->sector_size) { screen_buffer_add( "GPT: The primary GUID Partition Entry array must be located after the primary GUID Partition Table Header and end before the FirstUsableLBA.\n"); free(gpt); return NULL; } gpt_entries=(struct gpt_ent*)MALLOC(gpt_entries_size); if((unsigned)disk_car->pread(disk_car, gpt_entries, gpt_entries_size, gpt_entries_offset) != gpt_entries_size) { free(gpt_entries); free(gpt); return new_list_part; } { /* CRC check */ uint32_t crc; crc=get_crc32(gpt_entries, gpt_entries_size, 0xFFFFFFFF)^0xFFFFFFFF; if(crc!=le32(gpt->hdr_crc_table)) { screen_buffer_add("Bad GPT partition entries, invalid checksum.\n"); free(gpt_entries); free(gpt); return NULL; } } for(i=0;i<le32(gpt->hdr_entries);i++) { const struct gpt_ent* gpt_entry; gpt_entry=(const struct gpt_ent*)((const char*)gpt_entries + (unsigned long)i*le32(gpt->hdr_entsz)); if(guid_cmp(gpt_entry->ent_type, GPT_ENT_TYPE_UNUSED)!=0 && le64(gpt_entry->ent_lba_start) < le64(gpt_entry->ent_lba_end)) { int insert_error=0; partition_t *new_partition=partition_new(&arch_gpt); new_partition->order=i+1; guid_cpy(&new_partition->part_uuid, &gpt_entry->ent_uuid); guid_cpy(&new_partition->part_type_gpt, &gpt_entry->ent_type); new_partition->part_offset=(uint64_t)le64(gpt_entry->ent_lba_start)*disk_car->sector_size; new_partition->part_size=(uint64_t)(le64(gpt_entry->ent_lba_end) - le64(gpt_entry->ent_lba_start)+1) * disk_car->sector_size; new_partition->status=STATUS_PRIM; UCSle2str(new_partition->partname, (const uint16_t *)&gpt_entry->ent_name, sizeof(gpt_entry->ent_name)/2); new_partition->arch->check_part(disk_car,verbose,new_partition,saveheader); /* log_debug("%u ent_attr %08llx\n", new_partition->order, (long long unsigned)le64(gpt_entry->ent_attr)); */ aff_part_buffer(AFF_PART_ORDER|AFF_PART_STATUS,disk_car,new_partition); new_list_part=insert_new_partition(new_list_part, new_partition, 0, &insert_error); if(insert_error>0) free(new_partition); } } /* TODO: The backup GUID Partition Entry array must be located after the LastUsableLBA and end before the backup GUID Partition Table Header. */ free(gpt_entries); free(gpt); return new_list_part; }
/*! * Helper method to convert library events into a vector of diagnostic result structures. * Used by the DiagnosticCompletionRecordFactory class as well. */ int wbem::support::DiagnosticLogFactory::gatherDiagnosticResults(diagnosticResults_t *pResults) throw (framework::Exception) { int count = 0; // get all diagnostic events struct event_filter filter; memset(&filter, 0, sizeof (struct event_filter)); filter.filter_mask = NVM_FILTER_ON_TYPE; filter.type = EVENT_TYPE_DIAG; int total_count = nvm_get_event_count(&filter); if (total_count < 0) { throw exception::NvmExceptionLibError(total_count); } if (total_count > 0) { struct event events[total_count]; total_count = nvm_get_events(&filter, events, total_count); if (total_count < 0) { throw exception::NvmExceptionLibError(total_count); } for (int i = 0; i < total_count; i++) { bool matched = false; // only add a new structure if the test is unique to the type and guid // else another message and update the result for (diagnosticResults_t::iterator iter = pResults->begin(); iter != pResults->end(); iter++) { if ((*iter).type == events[i].type) { // matched existing result - update data but do not count if (guid_cmp((*iter).device_guid, events[i].guid)) { matched = true; // update id (if necessary) if (events[i].event_id < (*iter).id) { (*iter).id = events[i].event_id; } // update overall result (if necessary) if (events[i].diag_result > (*iter).result) { (*iter).result = events[i].diag_result; } // update time (if necessary) if (events[i].time < (*iter).time) { (*iter).time = events[i].time; } // add message (*iter).messages.push_back(buildDiagnosticResultMessage(&events[i])); break; } } } // add new result if (!matched) { count++; // copy the event information into the diagnostic result struct struct diagnosticResult diag; diag.id = events[i].event_id; diag.time = events[i].time; diag.type = events[i].type; memmove(diag.device_guid, events[i].guid, NVM_GUID_LEN); diag.result = events[i].diag_result; diag.messages.push_back(buildDiagnosticResultMessage(&events[i])); pResults->push_back(diag); } } // end for } // end if events return count; }
static void gpt_change_part_type(const disk_t *disk_car, partition_t *partition) { unsigned int offset=0; unsigned int i,j; unsigned int current_element_num=0; log_info("gpt_change_part_type\n"); aff_copy(stdscr); wmove(stdscr,4,0); aff_part(stdscr, AFF_PART_ORDER|AFF_PART_STATUS, disk_car, partition); wmove(stdscr,INTER_CHGTYPE_Y, INTER_CHGTYPE_X); wattrset(stdscr, A_REVERSE); wprintw(stdscr, "[ Proceed ]"); wattroff(stdscr, A_REVERSE); /* By default, select the current type */ for(i=0;gpt_sys_types[i].name!=NULL;i++) { if(guid_cmp(partition->part_type_gpt, gpt_sys_types[i].part_type)==0) { current_element_num=i; while(current_element_num >= offset+3*INTER_CHGTYPE) offset++; } } while(1) { wmove(stdscr,5,0); wprintw(stdscr, "Please choose the partition type, press Enter when done."); wmove(stdscr,5+1,1); wclrtoeol(stdscr); if(offset>0) wprintw(stdscr, "Previous"); for(i=offset;gpt_sys_types[i].name!=NULL && (i-offset)<3*INTER_CHGTYPE;i++) { if(i-offset<INTER_CHGTYPE) wmove(stdscr,5+2+i-offset,0); else if(i-offset<2*INTER_CHGTYPE) wmove(stdscr,5+2+i-offset-INTER_CHGTYPE,26); else wmove(stdscr,5+2+i-offset-2*INTER_CHGTYPE,52); wclrtoeol(stdscr); /* before addstr for BSD compatibility */ if(i==current_element_num) { wattrset(stdscr, A_REVERSE); wprintw(stdscr,">%s", gpt_sys_types[i].name); wattroff(stdscr, A_REVERSE); } else { wprintw(stdscr," %s", gpt_sys_types[i].name); } } if(i-offset<INTER_CHGTYPE) wmove(stdscr,5+2+i-offset,1); else if(i-offset<2*INTER_CHGTYPE) wmove(stdscr,5+2+i-offset-INTER_CHGTYPE,27); else wmove(stdscr,5+2+i-offset-2*INTER_CHGTYPE,53); wclrtoeol(stdscr); if(gpt_sys_types[i].name!=NULL) wprintw(stdscr, "Next"); switch(wgetch(stdscr)) { case 'p': case 'P': case KEY_UP: if(current_element_num>0) current_element_num--; break; case 'n': case 'N': case KEY_DOWN: if(gpt_sys_types[current_element_num].name!=NULL && gpt_sys_types[current_element_num+1].name!=NULL) current_element_num++; break; case KEY_LEFT: if(current_element_num > INTER_CHGTYPE) current_element_num-=INTER_CHGTYPE; else current_element_num=0; break; case KEY_PPAGE: if(current_element_num > 3*INTER_CHGTYPE-1) current_element_num-=3*INTER_CHGTYPE-1; else current_element_num=0; break; case KEY_RIGHT: for(j=0;j<INTER_CHGTYPE;j++) { if(gpt_sys_types[current_element_num].name!=NULL && gpt_sys_types[current_element_num+1].name!=NULL) current_element_num++; } break; case KEY_NPAGE: for(j=0;j<3*INTER_CHGTYPE;j++) { if(gpt_sys_types[current_element_num].name!=NULL && gpt_sys_types[current_element_num+1].name!=NULL) current_element_num++; } break; case 'Q': case 'q': case key_CR: #ifdef PADENTER case PADENTER: #endif guid_cpy(&partition->part_type_gpt, &gpt_sys_types[current_element_num].part_type); return; } if(current_element_num<offset) offset=current_element_num; if(current_element_num >= offset+3*INTER_CHGTYPE) offset=current_element_num-3*INTER_CHGTYPE+1; } }
list_part_t *add_partition_gpt_ncurses(disk_t *disk_car,list_part_t *list_part, char **current_cmd) { int position=0; int done = FALSE; partition_t *new_partition=partition_new(&arch_gpt); new_partition->part_offset=disk_car->sector_size; new_partition->part_size=disk_car->disk_size-disk_car->sector_size; while (done==FALSE) { int command; static struct MenuItem menuGeometry[]= { { 's', "Sector", "Change starting sector" }, { 'S', "Sector", "Change ending sector" }, { 'T' ,"Type", "Change partition type"}, { 'd', "Done", "" }, { 0, NULL, NULL } }; aff_copy(stdscr); wmove(stdscr,4,0); wprintw(stdscr,"%s",disk_car->description(disk_car)); wmove(stdscr,10, 0); wclrtoeol(stdscr); aff_part(stdscr, AFF_PART_BASE, disk_car, new_partition); wmove(stdscr,INTER_GEOM_Y, INTER_GEOM_X); wclrtoeol(stdscr); wrefresh(stdscr); command=wmenuSimple(stdscr,menuGeometry, position); switch (command) { case 's': { uint64_t part_offset; part_offset=new_partition->part_offset; wmove(stdscr, INTER_GEOM_Y, INTER_GEOM_X); new_partition->part_offset=(uint64_t)ask_number( new_partition->part_offset/disk_car->sector_size, 1, (disk_car->disk_size-1)/disk_car->sector_size, "Enter the starting sector ") * (uint64_t)disk_car->sector_size; new_partition->part_size=new_partition->part_size + part_offset - new_partition->part_offset; position=1; } break; case 'S': wmove(stdscr, INTER_GEOM_Y, INTER_GEOM_X); new_partition->part_size=(uint64_t)ask_number( (new_partition->part_offset+new_partition->part_size-1)/disk_car->sector_size, new_partition->part_offset/disk_car->sector_size, (disk_car->disk_size-1)/disk_car->sector_size, "Enter the ending sector ") * (uint64_t)disk_car->sector_size + disk_car->sector_size - new_partition->part_offset; position=2; break; case 'T': case 't': change_part_type(disk_car,new_partition, current_cmd); position=3; break; case key_ESC: case 'd': case 'D': case 'q': case 'Q': done = TRUE; break; } } if(new_partition->part_size>0 && guid_cmp(new_partition->part_type_gpt, GPT_ENT_TYPE_UNUSED)!=0) { int insert_error=0; list_part_t *new_list_part=insert_new_partition(list_part, new_partition, 0, &insert_error); if(insert_error>0) { free(new_partition); return new_list_part; } new_partition->status=STATUS_PRIM; if(arch_gpt.test_structure(list_part)!=0) new_partition->status=STATUS_DELETED; return new_list_part; } free(new_partition); return list_part; }