/* * Read data about partitions from libfdisk and prepare output lines. */ static int lines_refresh(struct cfdisk *cf) { int rc; char *p; size_t i; assert(cf); DBG(FRONTEND, ul_debug("refreshing buffer")); free(cf->linesbuf); free(cf->lines); cf->linesbuf = NULL; cf->linesbufsz = 0; cf->lines = NULL; cf->nlines = 0; fdisk_unref_table(cf->table); cf->table = NULL; /* read partitions and free spaces into cf->table */ rc = fdisk_get_partitions(cf->cxt, &cf->table); if (!rc) rc = fdisk_get_freespaces(cf->cxt, &cf->table); if (rc) return rc; cf->linesbuf = table_to_string(cf, cf->table); if (!cf->linesbuf) return -ENOMEM; cf->linesbufsz = strlen(cf->linesbuf); cf->nlines = fdisk_table_get_nents(cf->table) + 1; /* 1 for header line */ cf->page_sz = 0; cf->wrong_order = fdisk_table_wrong_order(cf->table) ? 1 : 0; if (MENU_START_LINE - TABLE_START_LINE < cf->nlines) cf->page_sz = MENU_START_LINE - TABLE_START_LINE - 1; cf->lines = xcalloc(cf->nlines, sizeof(char *)); for (p = cf->linesbuf, i = 0; p && i < cf->nlines; i++) { cf->lines[i] = p; p = strchr(p, '\n'); if (p) { *p = '\0'; p++; } } return 0; }
void list_disklabel(struct fdisk_context *cxt) { struct fdisk_table *tb = NULL; struct fdisk_partition *pa = NULL; struct fdisk_iter *itr = NULL; struct fdisk_label *lb; struct libscols_table *out = NULL; const char *bold = NULL; int *ids = NULL; /* IDs of fdisk_fields */ size_t nids = 0, i; int post = 0; /* print label specific stuff by libfdisk FDISK_ASK_INFO API */ fdisk_list_disklabel(cxt); /* get partitions and generate output */ if (fdisk_get_partitions(cxt, &tb) || fdisk_table_get_nents(tb) <= 0) goto done; ids = init_fields(cxt, NULL, &nids); if (!ids) goto done; itr = fdisk_new_iter(FDISK_ITER_FORWARD); if (!itr) { fdisk_warn(cxt, _("faild to allocate iterator")); goto done; } out = scols_new_table(); if (!out) { fdisk_warn(cxt, _("faild to allocate output table")); goto done; } if (colors_wanted()) { scols_table_enable_colors(out, 1); bold = color_scheme_get_sequence("header", UL_COLOR_BOLD); } lb = fdisk_get_label(cxt, NULL); assert(lb); /* define output table columns */ for (i = 0; i < nids; i++) { int fl = 0; struct libscols_column *co; const struct fdisk_field *field = fdisk_label_get_field(lb, ids[i]); if (!field) continue; if (fdisk_field_is_number(field)) fl |= SCOLS_FL_RIGHT; if (fdisk_field_get_id(field) == FDISK_FIELD_TYPE) fl |= SCOLS_FL_TRUNC; co = scols_table_new_column(out, fdisk_field_get_name(field), fdisk_field_get_width(field), fl); if (!co) goto done; /* set colum header color */ if (bold) scols_cell_set_color(scols_column_get_header(co), bold); } /* fill-in output table */ while (fdisk_table_next_partition(tb, itr, &pa) == 0) { struct libscols_line *ln = scols_table_new_line(out, NULL); if (!ln) { fdisk_warn(cxt, _("faild to allocate output line")); goto done; } for (i = 0; i < nids; i++) { char *data = NULL; if (fdisk_partition_to_string(pa, cxt, ids[i], &data)) continue; scols_line_refer_data(ln, i, data); } } /* print */ if (!scols_table_is_empty(out)) { fputc('\n', stdout); scols_print_table(out); } /* print warnings */ fdisk_reset_iter(itr, FDISK_ITER_FORWARD); while (itr && fdisk_table_next_partition(tb, itr, &pa) == 0) { if (!fdisk_partition_has_start(pa)) continue; if (!fdisk_lba_is_phy_aligned(cxt, fdisk_partition_get_start(pa))) { if (!post) fputc('\n', stdout); fdisk_warnx(cxt, _("Partition %zu does not start on physical sector boundary."), fdisk_partition_get_partno(pa) + 1); post++; } } if (fdisk_table_wrong_order(tb)) { if (!post) fputc('\n', stdout); fdisk_info(cxt, _("Partition table entries are not in disk order.")); } done: scols_unref_table(out); fdisk_unref_table(tb); fdisk_free_iter(itr); }
/* * Uses template @tpl to recount start and size change of the partition @res. The * @tpl->size and @tpl->start are interpreted as relative to the current setting. */ static int recount_resize( struct fdisk_context *cxt, size_t partno, struct fdisk_partition *res, struct fdisk_partition *tpl) { fdisk_sector_t start, size; struct fdisk_partition *cur = NULL; struct fdisk_table *tb = NULL; int rc; DBG(PART, ul_debugobj(tpl, "resize requested")); FDISK_INIT_UNDEF(start); FDISK_INIT_UNDEF(size); rc = fdisk_get_partitions(cxt, &tb); if (!rc) rc = fdisk_get_freespaces(cxt, &tb); if (rc) return rc; cur = fdisk_table_get_partition_by_partno(tb, partno); if (!cur) { fdisk_unref_table(tb); return -EINVAL; } /* 1a) set new start - change relative to the current on-disk setting */ if (tpl->movestart && fdisk_partition_has_start(tpl)) { start = fdisk_partition_get_start(cur); if (tpl->movestart == FDISK_MOVE_DOWN) { if (fdisk_partition_get_start(tpl) > start) goto erange; start -= fdisk_partition_get_start(tpl); } else start += fdisk_partition_get_start(tpl); /* 1b) set new start - absolute number */ } else if (fdisk_partition_has_start(tpl)) start = fdisk_partition_get_start(tpl); /* 2) verify that start is within the current partition or any freespace area */ if (!FDISK_IS_UNDEF(start)) { struct fdisk_partition *area = resize_get_by_offset(tb, start); if (area == cur) DBG(PART, ul_debugobj(tpl, "resize: start points to the current partition")); else if (area && fdisk_partition_is_freespace(area)) DBG(PART, ul_debugobj(tpl, "resize: start points to freespace")); else if (!area && start >= cxt->first_lba && start < cxt->first_lba + (cxt->grain / cxt->sector_size)) DBG(PART, ul_debugobj(tpl, "resize: start points before first partition")); else goto erange; } else { /* no change, start points to the current partition */ start = fdisk_partition_get_start(cur); } /* 3a) set new size -- reduce */ if (tpl->resize == FDISK_RESIZE_REDUCE && fdisk_partition_has_size(tpl)) { DBG(PART, ul_debugobj(tpl, "resize: reduce")); size = fdisk_partition_get_size(cur); if (fdisk_partition_get_size(tpl) > size) goto erange; size -= fdisk_partition_get_size(tpl); /* 3b) set new size -- enlarge */ } else if (tpl->resize == FDISK_RESIZE_ENLARGE && fdisk_partition_has_size(tpl)) { DBG(PART, ul_debugobj(tpl, "resize: enlarge")); size = fdisk_partition_get_size(cur); size += fdisk_partition_get_size(tpl); /* 3c) set new size -- no size specified, enlarge to all freespace */ } else if (tpl->resize == FDISK_RESIZE_ENLARGE) { DBG(PART, ul_debugobj(tpl, "resize: enlarge to all possible")); if (resize_get_last_possible(tb, cur, start, &size)) goto erange; /* 3d) set new size -- absolute number */ } else if (fdisk_partition_has_size(tpl)) { DBG(PART, ul_debugobj(tpl, "resize: new absolute size")); size = fdisk_partition_get_size(tpl); } /* 4) verify that size is within the current partition or next free space */ if (!FDISK_IS_UNDEF(size)) { fdisk_sector_t maxsz; if (resize_get_last_possible(tb, cur, start, &maxsz)) goto erange; DBG(PART, ul_debugobj(tpl, "resize: size wanted=%ju, max=%ju", (uintmax_t) size, (uintmax_t) maxsz)); if (size > maxsz) goto erange; } DBG(PART, ul_debugobj(tpl, "resize: SUCCESS: start %ju->%ju; size %ju->%ju", (uintmax_t) fdisk_partition_get_start(cur), (uintmax_t) start, (uintmax_t) fdisk_partition_get_size(cur), (uintmax_t) size)); res->start = start; res->size = size; fdisk_unref_table(tb); return 0; erange: DBG(PART, ul_debugobj(tpl, "resize: FAILED")); fdisk_warnx(cxt, _("Failed to resize partition #%zu."), partno + 1); fdisk_unref_table(tb); return -ERANGE; }
void list_freespace(struct fdisk_context *cxt) { struct fdisk_table *tb = NULL; struct fdisk_partition *pa = NULL; struct fdisk_iter *itr = NULL; struct libscols_table *out = NULL; const char *bold = NULL; size_t i; uintmax_t sumsize = 0, bytes = 0; char *strsz; static const char *colnames[] = { N_("Start"), N_("End"), N_("Sectors"), N_("Size") }; static const int colids[] = { FDISK_FIELD_START, FDISK_FIELD_END, FDISK_FIELD_SECTORS, FDISK_FIELD_SIZE }; if (fdisk_get_freespaces(cxt, &tb)) goto done; itr = fdisk_new_iter(FDISK_ITER_FORWARD); if (!itr) { fdisk_warn(cxt, _("failed to allocate iterator")); goto done; } out = scols_new_table(); if (!out) { fdisk_warn(cxt, _("failed to allocate output table")); goto done; } if (colors_wanted()) { scols_table_enable_colors(out, 1); bold = color_scheme_get_sequence("header", UL_COLOR_BOLD); } for (i = 0; i < ARRAY_SIZE(colnames); i++) { struct libscols_column *co = scols_table_new_column(out, _(colnames[i]), 5, SCOLS_FL_RIGHT); if (!co) goto done; if (bold) scols_cell_set_color(scols_column_get_header(co), bold); } /* fill-in output table */ while (fdisk_table_next_partition(tb, itr, &pa) == 0) { struct libscols_line *ln = scols_table_new_line(out, NULL); char *data; if (!ln) { fdisk_warn(cxt, _("failed to allocate output line")); goto done; } for (i = 0; i < ARRAY_SIZE(colids); i++) { if (fdisk_partition_to_string(pa, cxt, colids[i], &data)) continue; scols_line_refer_data(ln, i, data); } if (fdisk_partition_has_size(pa)) sumsize += fdisk_partition_get_size(pa); } bytes = sumsize * fdisk_get_sector_size(cxt); strsz = size_to_human_string(SIZE_SUFFIX_SPACE | SIZE_SUFFIX_3LETTER, bytes); color_scheme_enable("header", UL_COLOR_BOLD); fdisk_info(cxt, _("Unpartitioned space %s: %s, %ju bytes, %ju sectors"), fdisk_get_devname(cxt), strsz, bytes, sumsize); color_disable(); free(strsz); fdisk_info(cxt, _("Units: %s of %d * %ld = %ld bytes"), fdisk_get_unit(cxt, FDISK_PLURAL), fdisk_get_units_per_sector(cxt), fdisk_get_sector_size(cxt), fdisk_get_units_per_sector(cxt) * fdisk_get_sector_size(cxt)); fdisk_info(cxt, _("Sector size (logical/physical): %lu bytes / %lu bytes"), fdisk_get_sector_size(cxt), fdisk_get_physector_size(cxt)); /* print */ if (!scols_table_is_empty(out)) { fdisk_info(cxt, ""); /* line break */ scols_print_table(out); } done: scols_unref_table(out); fdisk_unref_table(tb); fdisk_free_iter(itr); }