/**
* fdisk_set_partition:
* @cxt: context
* @partno: partition number (0 is the first partition)
* @pa: new partition setting
*
* Modifies disklabel according to setting with in @pa.
*
* Returns: 0 on success, <0 on error.
*/
int fdisk_set_partition(struct fdisk_context *cxt, size_t partno,
struct fdisk_partition *pa)
{
struct fdisk_partition *xpa = pa;
int rc;
if (!cxt || !cxt->label || !pa)
return -EINVAL;
if (!cxt->label->op->set_part)
return -ENOSYS;
if (pa->resize || fdisk_partition_has_start(pa) || fdisk_partition_has_size(pa)) {
xpa = __copy_partition(pa);
xpa->movestart = 0;
xpa->resize = 0;
FDISK_INIT_UNDEF(xpa->size);
FDISK_INIT_UNDEF(xpa->start);
rc = recount_resize(cxt, partno, xpa, pa);
if (rc)
goto done;
}
DBG(CXT, ul_debugobj(cxt, "setting partition %zu %p (start=%ju, end=%ju, size=%ju)",
partno, xpa,
(uintmax_t) fdisk_partition_get_start(xpa),
(uintmax_t) fdisk_partition_get_end(xpa),
(uintmax_t) fdisk_partition_get_size(xpa)));
rc = cxt->label->op->set_part(cxt, partno, xpa);
done:
if (xpa != pa)
fdisk_unref_partition(xpa);
return rc;
}
static int sgi_set_partition(struct fdisk_context *cxt,
size_t i,
struct fdisk_partition *pa)
{
struct sgi_disklabel *sgilabel;
if (i >= cxt->label->nparts_max)
return -EINVAL;
sgilabel = self_disklabel(cxt);
if (pa->type) {
struct fdisk_parttype *t = pa->type;
if (sgi_get_num_sectors(cxt, i) == 0) /* caught already before, ... */ {
fdisk_warnx(cxt, _("Sorry, only for non-empty partitions you can change the tag."));
return -EINVAL;
}
if ((i == 10 && t->code != SGI_TYPE_ENTIRE_DISK)
|| (i == 8 && t->code != 0))
fdisk_info(cxt, _("Consider leaving partition 9 as volume header (0), "
"and partition 11 as entire volume (6), "
"as IRIX expects it."));
if (cxt->script == NULL
&& ((t->code != SGI_TYPE_ENTIRE_DISK) && (t->code != SGI_TYPE_VOLHDR))
&& (sgi_get_start_sector(cxt, i) < 1)) {
int yes = 0;
fdisk_ask_yesno(cxt,
_("It is highly recommended that the partition at offset 0 "
"is of type \"SGI volhdr\", the IRIX system will rely on it to "
"retrieve from its directory standalone tools like sash and fx. "
"Only the \"SGI volume\" entire disk section may violate this. "
"Are you sure about tagging this partition differently?"), &yes);
if (!yes)
return 1;
}
sgilabel->partitions[i].type = cpu_to_be32(t->code);
}
if (fdisk_partition_has_start(pa))
sgilabel->partitions[i].first_block = cpu_to_be32(pa->start);
if (fdisk_partition_has_size(pa))
sgilabel->partitions[i].num_blocks = cpu_to_be32(pa->size);
fdisk_label_set_changed(cxt->label, 1);
return 0;
}
static struct fdisk_partition *resize_get_by_offset(
struct fdisk_table *tb, fdisk_sector_t off)
{
struct fdisk_partition *pa = NULL;
struct fdisk_iter itr;
fdisk_reset_iter(&itr, FDISK_ITER_FORWARD);
while (fdisk_table_next_partition(tb, &itr, &pa) == 0) {
if (!fdisk_partition_has_start(pa) || !fdisk_partition_has_size(pa))
continue;
if (off >= pa->start && off < pa->start + pa->size)
return pa;
}
return NULL;
}
/*
* Verify that area addressed by @start is freespace or the @cur[rent]
* partition and continue to the next table entries until it's freespace, and
* counts size of all this space.
*
* This is core of the partition start offset move operation. We can move the
* start within the current partition of to the another free space. It's
* forbidden to move start of the partition to another already defined
* partition.
*/
static int resize_get_last_possible(
struct fdisk_table *tb,
struct fdisk_partition *cur,
fdisk_sector_t start,
fdisk_sector_t *maxsz)
{
struct fdisk_partition *pa = NULL, *last = NULL;
struct fdisk_iter itr;
fdisk_reset_iter(&itr, FDISK_ITER_FORWARD);
*maxsz = 0;
while (fdisk_table_next_partition(tb, &itr, &pa) == 0) {
if (!fdisk_partition_has_start(pa) ||
!fdisk_partition_has_size(pa) ||
fdisk_partition_is_container(pa))
continue;
if (!last) {
if (start >= pa->start && start < pa->start + pa->size) {
if (fdisk_partition_is_freespace(pa) || pa == cur)
last = pa;
else
break;
*maxsz = pa->size - (pa->start - start);
}
} else if (!fdisk_partition_is_freespace(pa) && pa != cur) {
break;
} else {
last = pa;
*maxsz += pa->size;
}
}
if (last)
DBG(PART, ul_debugobj(cur, "resize: max size=%ju", (uintmax_t) *maxsz));
return last ? 0 : -1;
}
static int sun_set_partition(
struct fdisk_context *cxt,
size_t i,
struct fdisk_partition *pa)
{
struct sun_disklabel *sunlabel;
struct sun_partition *part;
struct sun_info *info;
assert(cxt);
assert(cxt->label);
assert(fdisk_is_label(cxt, SUN));
sunlabel = self_disklabel(cxt);
if (i >= cxt->label->nparts_max)
return -EINVAL;
if (pa->type) {
struct fdisk_parttype *t = pa->type;
if (t->code > UINT16_MAX)
return -EINVAL;
if (i == 2 && t->code != SUN_TAG_WHOLEDISK)
fdisk_info(cxt, _("Consider leaving partition 3 as Whole disk (5),\n"
"as SunOS/Solaris expects it and even Linux likes it.\n"));
part = &sunlabel->partitions[i];
info = &sunlabel->vtoc.infos[i];
if (cxt->script == NULL &&
t->code == SUN_TAG_LINUX_SWAP && !part->start_cylinder) {
int yes, rc;
rc = fdisk_ask_yesno(cxt,
_("It is highly recommended that the partition at offset 0\n"
"is UFS, EXT2FS filesystem or SunOS swap. Putting Linux swap\n"
"there may destroy your partition table and bootblock.\n"
"Are you sure you want to tag the partition as Linux swap?"), &yes);
if (rc)
return rc;
if (!yes)
return 1;
}
switch (t->code) {
case SUN_TAG_SWAP:
case SUN_TAG_LINUX_SWAP:
/* swaps are not mountable by default */
info->flags |= cpu_to_be16(SUN_FLAG_UNMNT);
break;
default:
/* assume other types are mountable;
user can change it anyway */
info->flags &= ~cpu_to_be16(SUN_FLAG_UNMNT);
break;
}
info->id = cpu_to_be16(t->code);
}
if (fdisk_partition_has_start(pa))
sunlabel->partitions[i].start_cylinder =
cpu_to_be32(pa->start / (cxt->geom.heads * cxt->geom.sectors));
if (fdisk_partition_has_size(pa))
sunlabel->partitions[i].num_sectors = cpu_to_be32(pa->size);
fdisk_label_set_changed(cxt->label, 1);
return 0;
}
static int sun_add_partition(
struct fdisk_context *cxt,
struct fdisk_partition *pa,
size_t *partno)
{
struct sun_disklabel *sunlabel = self_disklabel(cxt);
uint32_t starts[SUN_MAXPARTITIONS], lens[SUN_MAXPARTITIONS];
struct sun_partition *part;
struct sun_info *info;
uint32_t start, stop, stop2;
int whole_disk = 0;
int sys = pa && pa->type ? pa->type->code : SUN_TAG_LINUX_NATIVE;
int rc;
size_t n;
char mesg[256];
size_t i;
unsigned int first, last;
rc = fdisk_partition_next_partno(pa, cxt, &n);
if (rc)
return rc;
part = &sunlabel->partitions[n];
info = &sunlabel->vtoc.infos[n];
if (part->num_sectors && be16_to_cpu(info->id) != SUN_TAG_UNASSIGNED) {
fdisk_info(cxt, _("Partition %zu is already defined. Delete "
"it before re-adding it."), n + 1);
return -EINVAL;
}
fetch_sun(cxt, starts, lens, &start, &stop);
if (stop <= start) {
if (n == 2)
whole_disk = 1;
else {
fdisk_info(cxt, _("Other partitions already cover the "
"whole disk. Delete some/shrink them before retry."));
return -EINVAL;
}
}
if (pa && pa->start_follow_default)
first = start;
else if (pa && fdisk_partition_has_start(pa)) {
first = pa->start;
if (!whole_disk && !is_free_sector(cxt, first, starts, lens))
return -ERANGE;
} else {
struct fdisk_ask *ask;
snprintf(mesg, sizeof(mesg), _("First %s"),
fdisk_get_unit(cxt, FDISK_SINGULAR));
for (;;) {
ask = fdisk_new_ask();
if (!ask)
return -ENOMEM;
fdisk_ask_set_query(ask, mesg);
fdisk_ask_set_type(ask, FDISK_ASKTYPE_NUMBER);
if (whole_disk) {
fdisk_ask_number_set_low(ask, 0); /* minimal */
fdisk_ask_number_set_default(ask, 0); /* default */
fdisk_ask_number_set_high(ask, 0); /* maximal */
} else {
fdisk_ask_number_set_low(ask, fdisk_scround(cxt, start)); /* minimal */
fdisk_ask_number_set_default(ask, fdisk_scround(cxt, start)); /* default */
fdisk_ask_number_set_high(ask, fdisk_scround(cxt, stop)); /* maximal */
}
rc = fdisk_do_ask(cxt, ask);
first = fdisk_ask_number_get_result(ask);
fdisk_unref_ask(ask);
if (rc)
return rc;
if (fdisk_use_cylinders(cxt))
first *= fdisk_get_units_per_sector(cxt);
/* ewt asks to add: "don't start a partition at cyl 0"
However, [email protected] writes:
"In addition to having a Sun partition table, to be able to
boot from the disc, the first partition, /dev/sdX1, must
start at cylinder 0. This means that /dev/sdX1 contains
the partition table and the boot block, as these are the
first two sectors of the disc. Therefore you must be
careful what you use /dev/sdX1 for. In particular, you must
not use a partition starting at cylinder 0 for Linux swap,
as that would overwrite the partition table and the boot
block. You may, however, use such a partition for a UFS
or EXT2 file system, as these file systems leave the first
1024 bytes undisturbed. */
/* On the other hand, one should not use partitions
starting at block 0 in an md, or the label will
be trashed. */
if (!is_free_sector(cxt, first, starts, lens) && !whole_disk) {
if (n == 2 && !first) {
whole_disk = 1;
break;
}
fdisk_warnx(cxt, _("Sector %d is already allocated"), first);
} else
break;
}
}
if (n == 2 && first != 0)
fdisk_warnx(cxt, _("It is highly recommended that the "
"third partition covers the whole disk "
"and is of type `Whole disk'"));
if (!fdisk_use_cylinders(cxt)) {
/* Starting sector has to be properly aligned */
int cs = cxt->geom.heads * cxt->geom.sectors;
int x = first % cs;
if (x) {
fdisk_info(cxt, _("Aligning the first sector from %u to %u "
"to be on cylinder boundary."),
first, first + cs - x);
first += cs - x;
}
}
stop = cxt->geom.cylinders * cxt->geom.heads * cxt->geom.sectors; /* ancient */
stop2 = stop;
for (i = 0; i < cxt->label->nparts_max; i++) {
if (starts[i] > first && starts[i] < stop)
stop = starts[i];
}
/* last */
if (pa && pa->end_follow_default)
last = whole_disk || (n == 2 && !first) ? stop2 : stop;
else if (pa && fdisk_partition_has_size(pa)) {
last = first + pa->size - 1ULL;
if (!whole_disk && last > stop)
return -ERANGE;
} else {
struct fdisk_ask *ask = fdisk_new_ask();
if (!ask)
return -ENOMEM;
snprintf(mesg, sizeof(mesg),
_("Last %s or +%s or +size{K,M,G,T,P}"),
fdisk_get_unit(cxt, FDISK_SINGULAR),
fdisk_get_unit(cxt, FDISK_PLURAL));
fdisk_ask_set_query(ask, mesg);
fdisk_ask_set_type(ask, FDISK_ASKTYPE_OFFSET);
if (whole_disk) {
fdisk_ask_number_set_low(ask, fdisk_scround(cxt, stop2)); /* minimal */
fdisk_ask_number_set_default(ask, fdisk_scround(cxt, stop2)); /* default */
fdisk_ask_number_set_high(ask, fdisk_scround(cxt, stop2)); /* maximal */
fdisk_ask_number_set_base(ask, 0);
} else if (n == 2 && !first) {
fdisk_ask_number_set_low(ask, fdisk_scround(cxt, first)); /* minimal */
fdisk_ask_number_set_default(ask, fdisk_scround(cxt, stop2)); /* default */
fdisk_ask_number_set_high(ask, fdisk_scround(cxt, stop2)); /* maximal */
fdisk_ask_number_set_base(ask, fdisk_scround(cxt, first));
} else {
fdisk_ask_number_set_low(ask, fdisk_scround(cxt, first)); /* minimal */
fdisk_ask_number_set_default(ask, fdisk_scround(cxt, stop)); /* default */
fdisk_ask_number_set_high(ask, fdisk_scround(cxt, stop)); /* maximal */
fdisk_ask_number_set_base(ask, fdisk_scround(cxt, first));
}
if (fdisk_use_cylinders(cxt))
fdisk_ask_number_set_unit(ask,
cxt->sector_size *
fdisk_get_units_per_sector(cxt));
else
fdisk_ask_number_set_unit(ask, cxt->sector_size);
rc = fdisk_do_ask(cxt, ask);
last = fdisk_ask_number_get_result(ask);
fdisk_unref_ask(ask);
if (rc)
return rc;
if (fdisk_use_cylinders(cxt))
last *= fdisk_get_units_per_sector(cxt);
}
if (n == 2 && !first) {
if (last >= stop2) {
whole_disk = 1;
last = stop2;
} else if (last > stop) {
fdisk_warnx(cxt,
_("You haven't covered the whole disk with the 3rd partition, but your value\n"
"%lu %s covers some other partition. Your entry has been changed\n"
"to %lu %s"),
(unsigned long) fdisk_scround(cxt, last), fdisk_get_unit(cxt, FDISK_SINGULAR),
(unsigned long) fdisk_scround(cxt, stop), fdisk_get_unit(cxt, FDISK_SINGULAR));
last = stop;
}
} else if (!whole_disk && last > stop)
last = stop;
if (whole_disk)
sys = SUN_TAG_WHOLEDISK;
set_partition(cxt, n, first, last, sys);
cxt->label->nparts_cur = count_used_partitions(cxt);
if (partno)
*partno = n;
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;
}
/**
* fdisk_partition_to_string:
* @pa: partition
* @cxt: context
* @id: field (FDISK_FIELD_*)
* @data: returns string with allocated data
*
* Returns info about partition converted to printable string.
*
* For example
* <informalexample>
* <programlisting>
* struct fdisk_parition *pa;
*
* fdisk_get_partition(cxt, 0, &pa);
* fdisk_partition_to_string(pa, FDISK_FIELD_UUID, &data);
* printf("first partition uuid: %s\n", data);
* free(data);
* fdisk_unref_partition(pa);
* </programlisting>
* </informalexample>
*
* returns UUID for the first partition.
*
* Returns: 0 on success, otherwise, a corresponding error.
*/
int fdisk_partition_to_string(struct fdisk_partition *pa,
struct fdisk_context *cxt,
int id,
char **data)
{
char *p = NULL;
int rc = 0;
uint64_t x;
if (!pa || !cxt || !data)
return -EINVAL;
switch (id) {
case FDISK_FIELD_DEVICE:
if (pa->freespace)
p = strdup(_("Free space"));
else if (fdisk_partition_has_partno(pa) && cxt->dev_path) {
if (cxt->label->flags & FDISK_LABEL_FL_INCHARS_PARTNO)
rc = asprintf(&p, "%c", (int) pa->partno + 'a');
else
p = fdisk_partname(cxt->dev_path, pa->partno + 1);
}
break;
case FDISK_FIELD_BOOT:
p = fdisk_partition_is_bootable(pa) ? strdup("*") : NULL;
break;
case FDISK_FIELD_START:
if (fdisk_partition_has_start(pa)) {
x = fdisk_cround(cxt, pa->start);
rc = pa->start_post ?
asprintf(&p, "%ju%c", x, pa->start_post) :
asprintf(&p, "%ju", x);
}
break;
case FDISK_FIELD_END:
if (fdisk_partition_has_end(pa)) {
x = fdisk_cround(cxt, fdisk_partition_get_end(pa));
rc = pa->end_post ?
asprintf(&p, "%ju%c", x, pa->end_post) :
asprintf(&p, "%ju", x);
}
break;
case FDISK_FIELD_SIZE:
if (fdisk_partition_has_size(pa)) {
uint64_t sz = pa->size * cxt->sector_size;
switch (cxt->sizeunit) {
case FDISK_SIZEUNIT_BYTES:
rc = asprintf(&p, "%ju", sz);
break;
case FDISK_SIZEUNIT_HUMAN:
if (fdisk_is_details(cxt))
rc = pa->size_post ?
asprintf(&p, "%ju%c", sz, pa->size_post) :
asprintf(&p, "%ju", sz);
else {
p = size_to_human_string(SIZE_SUFFIX_1LETTER, sz);
if (!p)
rc = -ENOMEM;
}
break;
}
}
break;
case FDISK_FIELD_CYLINDERS:
rc = asprintf(&p, "%ju", (uintmax_t)
fdisk_cround(cxt, fdisk_partition_has_size(pa) ? pa->size : 0));
break;
case FDISK_FIELD_SECTORS:
rc = asprintf(&p, "%ju",
fdisk_partition_has_size(pa) ? (uintmax_t) pa->size : 0);
break;
case FDISK_FIELD_BSIZE:
rc = asprintf(&p, "%ju", pa->bsize);
break;
case FDISK_FIELD_FSIZE:
rc = asprintf(&p, "%ju", pa->fsize);
break;
case FDISK_FIELD_CPG:
rc = asprintf(&p, "%ju", pa->cpg);
break;
case FDISK_FIELD_TYPE:
p = pa->type && pa->type->name ? strdup(_(pa->type->name)) : NULL;
break;
case FDISK_FIELD_TYPEID:
if (pa->type && fdisk_parttype_get_string(pa->type))
rc = asprintf(&p, "%s", fdisk_parttype_get_string(pa->type));
else if (pa->type)
rc = asprintf(&p, "%x", fdisk_parttype_get_code(pa->type));
break;
case FDISK_FIELD_UUID:
p = pa->uuid && *pa->uuid? strdup(pa->uuid) : NULL;
break;
case FDISK_FIELD_NAME:
p = pa->name && *pa->name ? strdup(pa->name) : NULL;
break;
case FDISK_FIELD_ATTR:
p = pa->attrs && *pa->attrs ? strdup(pa->attrs) : NULL;
break;
case FDISK_FIELD_SADDR:
p = pa->start_chs && *pa->start_chs ? strdup(pa->start_chs) : NULL;
break;
case FDISK_FIELD_EADDR:
p = pa->end_chs && *pa->end_chs? strdup(pa->end_chs) : NULL;
break;
default:
return -EINVAL;
}
if (rc < 0) {
rc = -ENOMEM;
free(p);
p = NULL;
} else if (rc > 0)
rc = 0;
*data = p;
return rc;
}
static int sgi_add_partition(struct fdisk_context *cxt,
struct fdisk_partition *pa,
size_t *partno)
{
struct fdisk_sgi_label *sgi;
char mesg[256];
unsigned int first = 0, last = 0;
struct fdisk_ask *ask;
int sys = pa && pa->type ? pa->type->code : SGI_TYPE_XFS;
int rc;
size_t n;
assert(cxt);
assert(cxt->label);
assert(fdisk_is_label(cxt, SGI));
rc = fdisk_partition_next_partno(pa, cxt, &n);
if (rc)
return rc;
if (n == 10)
sys = SGI_TYPE_ENTIRE_DISK;
else if (n == 8)
sys = 0;
sgi = self_label(cxt);
if (sgi_get_num_sectors(cxt, n)) {
fdisk_warnx(cxt, _("Partition %zu is already defined. "
"Delete it before re-adding it."), n + 1);
return -EINVAL;
}
if (!cxt->script && sgi_entire(cxt) == -1 && sys != SGI_TYPE_ENTIRE_DISK) {
fdisk_info(cxt, _("Attempting to generate entire disk entry automatically."));
sgi_set_entire(cxt);
sgi_set_volhdr(cxt);
}
if (sgi_gaps(cxt) == 0 && sys != SGI_TYPE_ENTIRE_DISK) {
fdisk_warnx(cxt, _("The entire disk is already covered with partitions."));
return -EINVAL;
}
if (sgi_gaps(cxt) < 0) {
fdisk_warnx(cxt, _("You got a partition overlap on the disk. Fix it first!"));
return -EINVAL;
}
if (sys == SGI_TYPE_ENTIRE_DISK) {
first = 0;
last = sgi_get_lastblock(cxt);
} else {
first = sgi->freelist[0].first;
last = sgi->freelist[0].last;
}
/* first sector */
if (pa && pa->start_follow_default)
;
else if (pa && fdisk_partition_has_start(pa)) {
first = pa->start;
last = is_in_freelist(cxt, first);
if (sys != SGI_TYPE_ENTIRE_DISK && !last)
return -ERANGE;
} else {
snprintf(mesg, sizeof(mesg), _("First %s"),
fdisk_get_unit(cxt, FDISK_SINGULAR));
ask = fdisk_new_ask();
if (!ask)
return -ENOMEM;
fdisk_ask_set_query(ask, mesg);
fdisk_ask_set_type(ask, FDISK_ASKTYPE_NUMBER);
fdisk_ask_number_set_low(ask, fdisk_scround(cxt, first)); /* minimal */
fdisk_ask_number_set_default(ask, fdisk_scround(cxt, first)); /* default */
fdisk_ask_number_set_high(ask, fdisk_scround(cxt, last) - 1); /* maximal */
rc = fdisk_do_ask(cxt, ask);
first = fdisk_ask_number_get_result(ask);
fdisk_unref_ask(ask);
if (rc)
return rc;
if (fdisk_use_cylinders(cxt))
first *= fdisk_get_units_per_sector(cxt);
}
if (first && sys == SGI_TYPE_ENTIRE_DISK)
fdisk_info(cxt, _("It is highly recommended that the "
"eleventh partition covers the entire "
"disk and is of type 'SGI volume'."));
if (!last)
last = is_in_freelist(cxt, first);
/* last sector */
if (pa && pa->end_follow_default)
last -= 1ULL;
else if (pa && fdisk_partition_has_size(pa)) {
if (first + pa->size - 1ULL > last)
return -ERANGE;
last = first + pa->size - 1ULL;
} else {
snprintf(mesg, sizeof(mesg),
_("Last %s or +%s or +size{K,M,G,T,P}"),
fdisk_get_unit(cxt, FDISK_SINGULAR),
fdisk_get_unit(cxt, FDISK_PLURAL));
ask = fdisk_new_ask();
if (!ask)
return -ENOMEM;
fdisk_ask_set_query(ask, mesg);
fdisk_ask_set_type(ask, FDISK_ASKTYPE_OFFSET);
fdisk_ask_number_set_low(ask, fdisk_scround(cxt, first)); /* minimal */
fdisk_ask_number_set_default(ask, fdisk_scround(cxt, last) - 1);/* default */
fdisk_ask_number_set_high(ask, fdisk_scround(cxt, last) - 1);/* maximal */
fdisk_ask_number_set_base(ask, fdisk_scround(cxt, first));
if (fdisk_use_cylinders(cxt))
fdisk_ask_number_set_unit(ask,
cxt->sector_size *
fdisk_get_units_per_sector(cxt));
else
fdisk_ask_number_set_unit(ask,cxt->sector_size);
rc = fdisk_do_ask(cxt, ask);
last = fdisk_ask_number_get_result(ask) + 1;
fdisk_unref_ask(ask);
if (rc)
return rc;
if (fdisk_use_cylinders(cxt))
last *= fdisk_get_units_per_sector(cxt);
}
if (sys == SGI_TYPE_ENTIRE_DISK
&& (first != 0 || last != sgi_get_lastblock(cxt)))
fdisk_info(cxt, _("It is highly recommended that the "
"eleventh partition covers the entire "
"disk and is of type 'SGI volume'."));
set_partition(cxt, n, first, last - first, sys);
cxt->label->nparts_cur = count_used_partitions(cxt);
if (partno)
*partno = n;
return 0;
}