static int set_partition(struct fdisk_context *cxt, size_t i,
unsigned int start, unsigned int length, int sys)
{
struct sgi_disklabel *sgilabel;
assert(cxt);
assert(cxt->label);
assert(fdisk_is_label(cxt, SGI));
sgilabel = self_disklabel(cxt);
sgilabel->partitions[i].type = cpu_to_be32(sys);
sgilabel->partitions[i].num_blocks = cpu_to_be32(length);
sgilabel->partitions[i].first_block = cpu_to_be32(start);
fdisk_label_set_changed(cxt->label, 1);
if (sgi_gaps(cxt) < 0) /* rebuild freelist */
fdisk_warnx(cxt, _("Partition overlap on the disk."));
if (length) {
struct fdisk_parttype *t =
fdisk_label_get_parttype_from_code(cxt->label, sys);
fdisk_info_new_partition(cxt, i + 1, start, start + length, t);
}
return 0;
}
static int sun_toggle_partition_flag(struct fdisk_context *cxt, size_t i, unsigned long flag)
{
struct sun_disklabel *sunlabel;
struct sun_info *p;
assert(cxt);
assert(cxt->label);
assert(fdisk_is_label(cxt, SUN));
if (i >= cxt->label->nparts_max)
return -EINVAL;
sunlabel = self_disklabel(cxt);
p = &sunlabel->vtoc.infos[i];
switch (flag) {
case SUN_FLAG_UNMNT:
p->flags ^= cpu_to_be16(SUN_FLAG_UNMNT);
fdisk_label_set_changed(cxt->label, 1);
break;
case SUN_FLAG_RONLY:
p->flags ^= cpu_to_be16(SUN_FLAG_RONLY);
fdisk_label_set_changed(cxt->label, 1);
break;
default:
return 1;
}
return 0;
}
static int sun_delete_partition(struct fdisk_context *cxt,
size_t partnum)
{
struct sun_disklabel *sunlabel;
struct sun_partition *part;
struct sun_info *info;
unsigned int nsec;
assert(cxt);
assert(cxt->label);
assert(fdisk_is_label(cxt, SUN));
sunlabel = self_disklabel(cxt);
part = &sunlabel->partitions[partnum];
info = &sunlabel->vtoc.infos[partnum];
if (partnum == 2 &&
be16_to_cpu(info->id) == SUN_TAG_WHOLEDISK &&
!part->start_cylinder &&
(nsec = be32_to_cpu(part->num_sectors))
== cxt->geom.heads * cxt->geom.sectors * cxt->geom.cylinders)
fdisk_info(cxt, _("If you want to maintain SunOS/Solaris compatibility, "
"consider leaving this "
"partition as Whole disk (5), starting at 0, with %u "
"sectors"), nsec);
info->id = cpu_to_be16(SUN_TAG_UNASSIGNED);
part->num_sectors = 0;
cxt->label->nparts_cur = count_used_partitions(cxt);
fdisk_label_set_changed(cxt->label, 1);
return 0;
}
static int sun_list_disklabel(struct fdisk_context *cxt)
{
struct sun_disklabel *sunlabel;
assert(cxt);
assert(cxt->label);
assert(fdisk_is_label(cxt, SUN));
sunlabel = self_disklabel(cxt);
if (fdisk_is_details(cxt)) {
fdisk_info(cxt,
_("Label geometry: %d rpm, %d alternate and %d physical cylinders,\n"
" %d extra sects/cyl, interleave %d:1"),
be16_to_cpu(sunlabel->rpm),
be16_to_cpu(sunlabel->acyl),
be16_to_cpu(sunlabel->pcyl),
be16_to_cpu(sunlabel->apc),
be16_to_cpu(sunlabel->intrlv));
fdisk_info(cxt, _("Label ID: %s"), sunlabel->label_id);
fdisk_info(cxt, _("Volume ID: %s"),
*sunlabel->vtoc.volume_id ? sunlabel->vtoc.volume_id : _("<none>"));
}
return 0;
}
static int sgi_probe_label(struct fdisk_context *cxt)
{
struct fdisk_sgi_label *sgi;
struct sgi_disklabel *sgilabel;
assert(cxt);
assert(cxt->label);
assert(fdisk_is_label(cxt, SGI));
assert(sizeof(struct sgi_disklabel) <= 512);
/* map first sector to header */
sgi = (struct fdisk_sgi_label *) cxt->label;
sgi->header = (struct sgi_disklabel *) cxt->firstsector;
sgilabel = sgi->header;
if (be32_to_cpu(sgilabel->magic) != SGI_LABEL_MAGIC) {
sgi->header = NULL;
return 0;
}
/*
* test for correct checksum
*/
if (sgi_pt_checksum(sgilabel) != 0)
fdisk_warnx(cxt, _("Detected an SGI disklabel with wrong checksum."));
clear_freelist(cxt);
cxt->label->nparts_max = SGI_MAXPARTITIONS;
cxt->label->nparts_cur = count_used_partitions(cxt);
return 1;
}
static int sgi_toggle_partition_flag(struct fdisk_context *cxt, size_t i, unsigned long flag)
{
struct sgi_disklabel *sgilabel;
assert(cxt);
assert(cxt->label);
assert(fdisk_is_label(cxt, SGI));
if (i >= cxt->label->nparts_max)
return -EINVAL;
sgilabel = self_disklabel(cxt);
switch (flag) {
case SGI_FLAG_BOOT:
sgilabel->root_part_num =
be16_to_cpu(sgilabel->root_part_num) == i ?
0 : cpu_to_be16(i);
fdisk_label_set_changed(cxt->label, 1);
break;
case SGI_FLAG_SWAP:
sgilabel->swap_part_num =
be16_to_cpu(sgilabel->swap_part_num) == i ?
0 : cpu_to_be16(i);
fdisk_label_set_changed(cxt->label, 1);
break;
default:
return 1;
}
return 0;
}
static int sun_write_disklabel(struct fdisk_context *cxt)
{
struct sun_disklabel *sunlabel;
unsigned short *ush;
unsigned short csum = 0;
const size_t sz = sizeof(struct sun_disklabel);
assert(cxt);
assert(cxt->label);
assert(fdisk_is_label(cxt, SUN));
sunlabel = self_disklabel(cxt);
/* Maybe geometry has been modified */
sunlabel->nhead = cpu_to_be16(cxt->geom.heads);
sunlabel->nsect = cpu_to_be16(cxt->geom.sectors);
if (cxt->geom.cylinders != be16_to_cpu(sunlabel->ncyl)) {
int a = cpu_to_be16(cxt->geom.cylinders);
int b = be16_to_cpu(sunlabel->acyl);
sunlabel->ncyl = a - b;
}
ush = (unsigned short *) sunlabel;
while(ush < (unsigned short *)(&sunlabel->csum))
csum ^= *ush++;
sunlabel->csum = csum;
if (lseek(cxt->dev_fd, 0, SEEK_SET) < 0)
return -errno;
if (write_all(cxt->dev_fd, sunlabel, sz) != 0)
return -errno;
return 0;
}
/* Returns a pointer buffer with on-disk data. */
static inline struct sgi_disklabel *self_disklabel(struct fdisk_context *cxt)
{
assert(cxt);
assert(cxt->label);
assert(fdisk_is_label(cxt, SGI));
return ((struct fdisk_sgi_label *) cxt->label)->header;
}
/* return in-memory sun fdisk data */
static inline struct fdisk_sun_label *self_label(struct fdisk_context *cxt)
{
assert(cxt);
assert(cxt->label);
assert(fdisk_is_label(cxt, SUN));
return (struct fdisk_sun_label *) cxt->label;
}
static int sgi_partition_is_used(
struct fdisk_context *cxt,
size_t i)
{
assert(cxt);
assert(fdisk_is_label(cxt, SGI));
if (i >= cxt->label->nparts_max)
return 0;
return sgi_get_num_sectors(cxt, i) ? 1 : 0;
}
static int sun_set_parttype(
struct fdisk_context *cxt,
size_t i,
struct fdisk_parttype *t)
{
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 || !t || 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 (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);
return 0;
}
static void fetch_sun(struct fdisk_context *cxt,
uint32_t *starts,
uint32_t *lens,
uint32_t *start,
uint32_t *stop)
{
struct sun_disklabel *sunlabel;
int continuous = 1;
size_t i;
assert(cxt);
assert(cxt);
assert(cxt->label);
assert(fdisk_is_label(cxt, SUN));
sunlabel = self_disklabel(cxt);
*start = 0;
*stop = cxt->geom.cylinders * cxt->geom.heads * cxt->geom.sectors;
for (i = 0; i < cxt->label->nparts_max; i++) {
struct sun_partition *part = &sunlabel->partitions[i];
struct sun_info *info = &sunlabel->vtoc.infos[i];
if (part->num_sectors &&
be16_to_cpu(info->id) != SUN_TAG_UNASSIGNED &&
be16_to_cpu(info->id) != SUN_TAG_WHOLEDISK) {
starts[i] = be32_to_cpu(part->start_cylinder) *
cxt->geom.heads * cxt->geom.sectors;
lens[i] = be32_to_cpu(part->num_sectors);
if (continuous) {
if (starts[i] == *start)
*start += lens[i];
else if (starts[i] + lens[i] >= *stop)
*stop = starts[i];
else
continuous = 0;
/* There will be probably more gaps
than one, so lets check afterwards */
}
} else {
starts[i] = 0;
lens[i] = 0;
}
}
}
static int sun_get_partition(struct fdisk_context *cxt, size_t n,
struct fdisk_partition *pa)
{
struct sun_disklabel *sunlabel;
struct sun_partition *part;
uint16_t flags;
uint32_t start, len;
assert(cxt);
assert(cxt->label);
assert(fdisk_is_label(cxt, SUN));
if (n >= cxt->label->nparts_max)
return -EINVAL;
sunlabel = self_disklabel(cxt);
part = &sunlabel->partitions[n];
pa->used = part->num_sectors ? 1 : 0;
if (!pa->used)
return 0;
flags = be16_to_cpu(sunlabel->vtoc.infos[n].flags);
start = be32_to_cpu(part->start_cylinder)
* cxt->geom.heads * cxt->geom.sectors;
len = be32_to_cpu(part->num_sectors);
pa->type = sun_get_parttype(cxt, n);
if (pa->type && pa->type->code == SUN_TAG_WHOLEDISK)
pa->wholedisk = 1;
if (flags & SUN_FLAG_UNMNT || flags & SUN_FLAG_RONLY) {
if (asprintf(&pa->attrs, "%c%c",
flags & SUN_FLAG_UNMNT ? 'u' : ' ',
flags & SUN_FLAG_RONLY ? 'r' : ' ') < 0)
return -ENOMEM;
}
pa->start = start;
pa->end = start + len - (len ? 1 : 0);
pa->size = len;
return 0;
}
static int sgi_get_disklabel_item(struct fdisk_context *cxt, struct fdisk_labelitem *item)
{
struct sgi_disklabel *sgilabel;
struct sgi_device_parameter *sgiparam;
int rc = 0;
assert(cxt);
assert(cxt->label);
assert(fdisk_is_label(cxt, SGI));
sgilabel = self_disklabel(cxt);
sgiparam = &sgilabel->devparam;
switch (item->id) {
case SGI_LABELITEM_PCYLCOUNT:
item->name = _("Physical cylinders");
item->type = 'j';
item->data.num64 = (uint64_t) be16_to_cpu(sgiparam->pcylcount);
break;
case SGI_LABELITEM_SPARECYL:
item->name = _("Extra sects/cyl");
item->type = 'j';
item->data.num64 = (uint64_t) sgiparam->sparecyl;
break;
case SGI_LABELITEM_ILFACT:
item->name = _("Interleave");
item->type = 'j';
item->data.num64 = (uint64_t) be16_to_cpu(sgiparam->ilfact);
break;
case SGI_LABELITEM_BOOTFILE:
item->name = _("Bootfile");
item->type = 's';
item->data.str = *sgilabel->boot_file ? strdup((char *) sgilabel->boot_file) : NULL;
break;
default:
if (item->id < __FDISK_NLABELITEMS)
rc = 1; /* unssupported generic item */
else
rc = 2; /* out of range */
break;
}
return rc;
}
static int sgi_write_disklabel(struct fdisk_context *cxt)
{
struct sgi_disklabel *sgilabel;
struct sgi_info *info = NULL;
assert(cxt);
assert(cxt->label);
assert(fdisk_is_label(cxt, SGI));
sgilabel = self_disklabel(cxt);
sgilabel->csum = 0;
sgilabel->csum = cpu_to_be32(sgi_pt_checksum(sgilabel));
assert(sgi_pt_checksum(sgilabel) == 0);
if (lseek(cxt->dev_fd, 0, SEEK_SET) < 0)
goto err;
if (write_all(cxt->dev_fd, sgilabel, DEFAULT_SECTOR_SIZE))
goto err;
if (!strncmp((char *) sgilabel->volume[0].name, "sgilabel", 8)) {
/*
* Keep this habit of first writing the "sgilabel".
* I never tested whether it works without. (AN 1998-10-02)
*/
int infostartblock
= be32_to_cpu(sgilabel->volume[0].block_num);
if (lseek(cxt->dev_fd, (off_t) infostartblock *
DEFAULT_SECTOR_SIZE, SEEK_SET) < 0)
goto err;
info = sgi_new_info();
if (!info)
goto err;
if (write_all(cxt->dev_fd, info, sizeof(*info)))
goto err;
}
sgi_free_info(info);
return 0;
err:
sgi_free_info(info);
return -errno;
}
static int verify_disklabel(struct fdisk_context *cxt, int verbose)
{
int Index[SGI_MAXPARTITIONS]; /* list of valid partitions */
int sortcount = 0; /* number of used partitions, i.e. non-zero lengths */
int entire = 0, i = 0;
unsigned int start = 0;
long long gap = 0; /* count unused blocks */
unsigned int lastblock = sgi_get_lastblock(cxt);
assert(cxt);
assert(cxt->label);
assert(fdisk_is_label(cxt, SGI));
clear_freelist(cxt);
memset(Index, 0, sizeof(Index));
for (i=0; i < SGI_MAXPARTITIONS; i++) {
if (sgi_get_num_sectors(cxt, i) != 0) {
Index[sortcount++] = i;
if (sgi_get_sysid(cxt, i) == SGI_TYPE_ENTIRE_DISK
&& entire++ == 1) {
if (verbose)
fdisk_info(cxt, _("More than one entire "
"disk entry present."));
}
}
}
if (sortcount == 0) {
if (verbose)
fdisk_info(cxt, _("No partitions defined."));
if (lastblock)
add_to_freelist(cxt, 0, lastblock);
return (lastblock > 0) ? 1 : (lastblock == 0) ? 0 : -1;
}
sort(Index, sortcount, sizeof(Index[0]), cxt, compare_start);
if (sgi_get_sysid(cxt, Index[0]) == SGI_TYPE_ENTIRE_DISK) {
if (verbose && Index[0] != 10)
fdisk_info(cxt, _("IRIX likes it when partition 11 "
"covers the entire disk."));
if (verbose && sgi_get_start_sector(cxt, Index[0]) != 0)
fdisk_info(cxt, _("The entire disk partition should "
"start at block 0, not at block %d."),
sgi_get_start_sector(cxt, Index[0]));
if (verbose && sgi_get_num_sectors(cxt, Index[0]) != lastblock)
DBG(LABEL, ul_debug(
"entire disk partition=%ds, but disk=%ds",
sgi_get_num_sectors(cxt, Index[0]),
lastblock));
lastblock = sgi_get_num_sectors(cxt, Index[0]);
} else if (verbose) {
fdisk_info(cxt, _("Partition 11 should cover the entire disk."));
DBG(LABEL, ul_debug("sysid=%d\tpartition=%d",
sgi_get_sysid(cxt, Index[0]), Index[0]+1));
}
for (i=1, start=0; i<sortcount; i++) {
int cylsize = sgi_get_nsect(cxt) * sgi_get_ntrks(cxt);
if (verbose && cylsize
&& (sgi_get_start_sector(cxt, Index[i]) % cylsize) != 0)
DBG(LABEL, ul_debug("partition %d does not start on "
"cylinder boundary.", Index[i]+1));
if (verbose && cylsize
&& sgi_get_num_sectors(cxt, Index[i]) % cylsize != 0)
DBG(LABEL, ul_debug("partition %d does not end on "
"cylinder boundary.", Index[i]+1));
/* We cannot handle several "entire disk" entries. */
if (sgi_get_sysid(cxt, Index[i]) == SGI_TYPE_ENTIRE_DISK)
continue;
if (start > sgi_get_start_sector(cxt, Index[i])) {
if (verbose)
fdisk_info(cxt,
P_("Partitions %d and %d overlap by %d sector.",
"Partitions %d and %d overlap by %d sectors.",
start - sgi_get_start_sector(cxt, Index[i])),
Index[i-1]+1, Index[i]+1,
start - sgi_get_start_sector(cxt, Index[i]));
if (gap > 0) gap = -gap;
if (gap == 0) gap = -1;
}
if (start < sgi_get_start_sector(cxt, Index[i])) {
if (verbose)
fdisk_info(cxt,
P_("Unused gap of %8u sector: sector %8u",
"Unused gap of %8u sectors: sectors %8u-%u",
sgi_get_start_sector(cxt, Index[i]) - start),
sgi_get_start_sector(cxt, Index[i]) - start,
start, sgi_get_start_sector(cxt, Index[i])-1);
gap += sgi_get_start_sector(cxt, Index[i]) - start;
add_to_freelist(cxt, start,
sgi_get_start_sector(cxt, Index[i]));
}
start = sgi_get_start_sector(cxt, Index[i])
+ sgi_get_num_sectors(cxt, Index[i]);
/* Align free space on cylinder boundary. */
if (cylsize && start % cylsize)
start += cylsize - (start % cylsize);
DBG(LABEL, ul_debug("%2d:%12d\t%12d\t%12d", Index[i],
sgi_get_start_sector(cxt, Index[i]),
sgi_get_num_sectors(cxt, Index[i]),
sgi_get_sysid(cxt, Index[i])));
}
if (start < lastblock) {
if (verbose)
fdisk_info(cxt, P_("Unused gap of %8u sector: sector %8u",
"Unused gap of %8u sectors: sectors %8u-%u",
lastblock - start),
lastblock - start, start, lastblock-1);
gap += lastblock - start;
add_to_freelist(cxt, start, lastblock);
}
/*
* Done with arithmetics. Go for details now.
*/
if (verbose) {
if (sgi_get_bootpartition(cxt) < 0
|| !sgi_get_num_sectors(cxt, sgi_get_bootpartition(cxt)))
fdisk_info(cxt, _("The boot partition does not exist."));
if (sgi_get_swappartition(cxt) < 0
|| !sgi_get_num_sectors(cxt, sgi_get_swappartition(cxt)))
fdisk_info(cxt, _("The swap partition does not exist."));
else if (sgi_get_sysid(cxt, sgi_get_swappartition(cxt)) != SGI_TYPE_SWAP
&& sgi_get_sysid(cxt, sgi_get_swappartition(cxt)) != MBR_LINUX_SWAP_PARTITION)
fdisk_info(cxt, _("The swap partition has no swap type."));
if (sgi_check_bootfile(cxt, "/unix"))
fdisk_info(cxt, _("You have chosen an unusual bootfile name."));
}
return (gap > 0) ? 1 : (gap == 0) ? 0 : -1;
}
static int sun_verify_disklabel(struct fdisk_context *cxt)
{
uint32_t starts[SUN_MAXPARTITIONS], lens[SUN_MAXPARTITIONS], start, stop;
uint32_t i,j,k,starto,endo;
#ifdef HAVE_QSORT_R
int array[SUN_MAXPARTITIONS];
unsigned int *verify_sun_starts;
#endif
assert(cxt);
assert(cxt->label);
assert(fdisk_is_label(cxt, SUN));
fetch_sun(cxt, starts, lens, &start, &stop);
for (k = 0; k < 7; k++) {
for (i = 0; i < SUN_MAXPARTITIONS; i++) {
if (k && (lens[i] % (cxt->geom.heads * cxt->geom.sectors)))
fdisk_warnx(cxt, _("Partition %u doesn't end on cylinder boundary."), i+1);
if (lens[i]) {
for (j = 0; j < i; j++)
if (lens[j]) {
if (starts[j] == starts[i]+lens[i]) {
starts[j] = starts[i]; lens[j] += lens[i];
lens[i] = 0;
} else if (starts[i] == starts[j]+lens[j]){
lens[j] += lens[i];
lens[i] = 0;
} else if (!k) {
if (starts[i] < starts[j]+lens[j] &&
starts[j] < starts[i]+lens[i]) {
starto = starts[i];
if (starts[j] > starto)
starto = starts[j];
endo = starts[i]+lens[i];
if (starts[j]+lens[j] < endo)
endo = starts[j]+lens[j];
fdisk_warnx(cxt, _("Partition %u overlaps with others in "
"sectors %u-%u."), i+1, starto, endo);
}
}
}
}
}
}
#ifdef HAVE_QSORT_R
for (i = 0; i < SUN_MAXPARTITIONS; i++) {
if (lens[i])
array[i] = i;
else
array[i] = -1;
}
verify_sun_starts = starts;
qsort_r(array,ARRAY_SIZE(array),sizeof(array[0]),
(int (*)(const void *,const void *,void *)) verify_sun_cmp,
verify_sun_starts);
if (array[0] == -1) {
fdisk_info(cxt, _("No partitions defined."));
return 0;
}
stop = cxt->geom.cylinders * cxt->geom.heads * cxt->geom.sectors;
if (starts[array[0]])
fdisk_warnx(cxt, _("Unused gap - sectors 0-%u."), starts[array[0]]);
for (i = 0; i < 7 && array[i+1] != -1; i++) {
fdisk_warnx(cxt, _("Unused gap - sectors %u-%u."),
(starts[array[i]] + lens[array[i]]),
starts[array[i+1]]);
}
start = (starts[array[i]] + lens[array[i]]);
if (start < stop)
fdisk_warnx(cxt, _("Unused gap - sectors %u-%u."), start, stop);
#endif
return 0;
}
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;
}
static int sun_create_disklabel(struct fdisk_context *cxt)
{
unsigned int ndiv;
struct fdisk_sun_label *sun; /* libfdisk sun handler */
struct sun_disklabel *sunlabel; /* on disk data */
int rc = 0;
assert(cxt);
assert(cxt->label);
assert(fdisk_is_label(cxt, SUN));
/* map first sector to header */
rc = fdisk_init_firstsector_buffer(cxt, 0, 0);
if (rc)
return rc;
sun = (struct fdisk_sun_label *) cxt->label;
sun->header = (struct sun_disklabel *) cxt->firstsector;
sunlabel = sun->header;
cxt->label->nparts_max = SUN_MAXPARTITIONS;
sunlabel->magic = cpu_to_be16(SUN_LABEL_MAGIC);
sunlabel->vtoc.version = cpu_to_be32(SUN_VTOC_VERSION);
sunlabel->vtoc.sanity = cpu_to_be32(SUN_VTOC_SANITY);
sunlabel->vtoc.nparts = cpu_to_be16(SUN_MAXPARTITIONS);
#ifdef HDIO_GETGEO
if (cxt->geom.heads && cxt->geom.sectors) {
fdisk_sector_t llsectors;
if (blkdev_get_sectors(cxt->dev_fd, (unsigned long long *) &llsectors) == 0) {
int sec_fac = cxt->sector_size / 512;
fdisk_sector_t llcyls;
llcyls = llsectors / (cxt->geom.heads * cxt->geom.sectors * sec_fac);
cxt->geom.cylinders = llcyls;
if (cxt->geom.cylinders != llcyls)
cxt->geom.cylinders = ~0;
} else {
fdisk_warnx(cxt,
_("BLKGETSIZE ioctl failed on %s. "
"Using geometry cylinder value of %llu. "
"This value may be truncated for devices "
"> 33.8 GB."),
cxt->dev_path, cxt->geom.cylinders);
}
} else
#endif
ask_geom(cxt);
sunlabel->acyl = cpu_to_be16(0);
sunlabel->pcyl = cpu_to_be16(cxt->geom.cylinders);
sunlabel->rpm = cpu_to_be16(5400);
sunlabel->intrlv = cpu_to_be16(1);
sunlabel->apc = cpu_to_be16(0);
sunlabel->nhead = cpu_to_be16(cxt->geom.heads);
sunlabel->nsect = cpu_to_be16(cxt->geom.sectors);
sunlabel->ncyl = cpu_to_be16(cxt->geom.cylinders);
snprintf((char *) sunlabel->label_id, sizeof(sunlabel->label_id),
"Linux cyl %ju alt %u hd %u sec %ju",
(uintmax_t) cxt->geom.cylinders,
be16_to_cpu(sunlabel->acyl),
cxt->geom.heads,
(uintmax_t) cxt->geom.sectors);
if (cxt->geom.cylinders * cxt->geom.heads * cxt->geom.sectors >= 150 * 2048) {
ndiv = cxt->geom.cylinders - (50 * 2048 / (cxt->geom.heads * cxt->geom.sectors)); /* 50M swap */
} else
ndiv = cxt->geom.cylinders * 2 / 3;
/* create the default layout only if no-script defined */
if (!cxt->script) {
set_partition(cxt, 0, 0, ndiv * cxt->geom.heads * cxt->geom.sectors,
SUN_TAG_LINUX_NATIVE);
set_partition(cxt, 1, ndiv * cxt->geom.heads * cxt->geom.sectors,
cxt->geom.cylinders * cxt->geom.heads * cxt->geom.sectors,
SUN_TAG_LINUX_SWAP);
sunlabel->vtoc.infos[1].flags |= cpu_to_be16(SUN_FLAG_UNMNT);
set_partition(cxt, 2, 0,
cxt->geom.cylinders * cxt->geom.heads * cxt->geom.sectors,
SUN_TAG_WHOLEDISK);
}
{
unsigned short *ush = (unsigned short *)sunlabel;
unsigned short csum = 0;
while(ush < (unsigned short *)(&sunlabel->csum))
csum ^= *ush++;
sunlabel->csum = csum;
}
fdisk_label_set_changed(cxt->label, 1);
cxt->label->nparts_cur = count_used_partitions(cxt);
fdisk_info(cxt, _("Created a new Sun disklabel."));
return 0;
}
static int sun_probe_label(struct fdisk_context *cxt)
{
struct fdisk_sun_label *sun;
struct sun_disklabel *sunlabel;
unsigned short *ush;
int csum;
int need_fixing = 0;
assert(cxt);
assert(cxt->label);
assert(fdisk_is_label(cxt, SUN));
/* map first sector to header */
sun = (struct fdisk_sun_label *) cxt->label;
sun->header = (struct sun_disklabel *) cxt->firstsector;
sunlabel = sun->header;
if (be16_to_cpu(sunlabel->magic) != SUN_LABEL_MAGIC) {
sun->header = NULL;
return 0; /* failed */
}
ush = ((unsigned short *) (sunlabel + 1)) - 1;
for (csum = 0; ush >= (unsigned short *)sunlabel;)
csum ^= *ush--;
if (csum) {
fdisk_warnx(cxt, _("Detected sun disklabel with wrong checksum. "
"Probably you'll have to set all the values, "
"e.g. heads, sectors, cylinders and partitions "
"or force a fresh label (s command in main menu)"));
return 1;
}
cxt->label->nparts_max = SUN_MAXPARTITIONS;
cxt->geom.heads = be16_to_cpu(sunlabel->nhead);
cxt->geom.cylinders = be16_to_cpu(sunlabel->ncyl);
cxt->geom.sectors = be16_to_cpu(sunlabel->nsect);
if (be32_to_cpu(sunlabel->vtoc.version) != SUN_VTOC_VERSION) {
fdisk_warnx(cxt, _("Detected sun disklabel with wrong version [%d]."),
be32_to_cpu(sunlabel->vtoc.version));
need_fixing = 1;
}
if (be32_to_cpu(sunlabel->vtoc.sanity) != SUN_VTOC_SANITY) {
fdisk_warnx(cxt, _("Detected sun disklabel with wrong vtoc.sanity [0x%08x]."),
be32_to_cpu(sunlabel->vtoc.sanity));
need_fixing = 1;
}
if (be16_to_cpu(sunlabel->vtoc.nparts) != SUN_MAXPARTITIONS) {
fdisk_warnx(cxt, _("Detected sun disklabel with wrong vtoc.nparts [%u]."),
be16_to_cpu(sunlabel->vtoc.nparts));
need_fixing = 1;
}
if (need_fixing) {
fdisk_warnx(cxt, _("Warning: Wrong values need to be fixed up and "
"will be corrected by w(rite)"));
sunlabel->vtoc.version = cpu_to_be32(SUN_VTOC_VERSION);
sunlabel->vtoc.sanity = cpu_to_be32(SUN_VTOC_SANITY);
sunlabel->vtoc.nparts = cpu_to_be16(SUN_MAXPARTITIONS);
ush = (unsigned short *)sunlabel;
csum = 0;
while(ush < (unsigned short *)(&sunlabel->csum))
csum ^= *ush++;
sunlabel->csum = csum;
fdisk_label_set_changed(cxt->label, 1);
}
cxt->label->nparts_cur = count_used_partitions(cxt);
return 1;
}
static int sgi_create_disklabel(struct fdisk_context *cxt)
{
struct fdisk_sgi_label *sgi;
struct sgi_disklabel *sgilabel;
int rc;
assert(cxt);
assert(cxt->label);
assert(fdisk_is_label(cxt, SGI));
#ifdef HDIO_GETGEO
if (cxt->geom.heads && cxt->geom.sectors) {
fdisk_sector_t llsectors;
if (blkdev_get_sectors(cxt->dev_fd, (unsigned long long *) &llsectors) == 0) {
/* the get device size ioctl was successful */
fdisk_sector_t llcyls;
int sec_fac = cxt->sector_size / 512;
llcyls = llsectors / (cxt->geom.heads * cxt->geom.sectors * sec_fac);
cxt->geom.cylinders = llcyls;
if (cxt->geom.cylinders != llcyls) /* truncated? */
cxt->geom.cylinders = ~0;
} else {
/* otherwise print error and use truncated version */
fdisk_warnx(cxt,
_("BLKGETSIZE ioctl failed on %s. "
"Using geometry cylinder value of %llu. "
"This value may be truncated for devices "
"> 33.8 GB."), cxt->dev_path, cxt->geom.cylinders);
}
}
#endif
rc = fdisk_init_firstsector_buffer(cxt, 0, 0);
if (rc)
return rc;
sgi = (struct fdisk_sgi_label *) cxt->label;
sgi->header = (struct sgi_disklabel *) cxt->firstsector;
sgilabel = sgi->header;
sgilabel->magic = cpu_to_be32(SGI_LABEL_MAGIC);
sgilabel->root_part_num = cpu_to_be16(0);
sgilabel->swap_part_num = cpu_to_be16(1);
/* sizeof(sgilabel->boot_file) = 16 > 6 */
memset(sgilabel->boot_file, 0, 16);
strcpy((char *) sgilabel->boot_file, "/unix");
sgilabel->devparam.skew = (0);
sgilabel->devparam.gap1 = (0);
sgilabel->devparam.gap2 = (0);
sgilabel->devparam.sparecyl = (0);
sgilabel->devparam.pcylcount = cpu_to_be16(cxt->geom.cylinders);
sgilabel->devparam.head_vol0 = cpu_to_be16(0);
sgilabel->devparam.ntrks = cpu_to_be16(cxt->geom.heads);
/* tracks/cylinder (heads) */
sgilabel->devparam.cmd_tag_queue_depth = (0);
sgilabel->devparam.unused0 = (0);
sgilabel->devparam.unused1 = cpu_to_be16(0);
sgilabel->devparam.nsect = cpu_to_be16(cxt->geom.sectors);
/* sectors/track */
sgilabel->devparam.bytes = cpu_to_be16(cxt->sector_size);
sgilabel->devparam.ilfact = cpu_to_be16(1);
sgilabel->devparam.flags = cpu_to_be32(
SGI_DEVPARAM_TRACK_FWD
| SGI_DEVPARAM_IGNORE_ERRORS
| SGI_DEVPARAM_RESEEK);
sgilabel->devparam.datarate = cpu_to_be32(0);
sgilabel->devparam.retries_on_error = cpu_to_be32(1);
sgilabel->devparam.ms_per_word = cpu_to_be32(0);
sgilabel->devparam.xylogics_gap1 = cpu_to_be16(0);
sgilabel->devparam.xylogics_syncdelay = cpu_to_be16(0);
sgilabel->devparam.xylogics_readdelay = cpu_to_be16(0);
sgilabel->devparam.xylogics_gap2 = cpu_to_be16(0);
sgilabel->devparam.xylogics_readgate = cpu_to_be16(0);
sgilabel->devparam.xylogics_writecont = cpu_to_be16(0);
memset(&(sgilabel->volume), 0,
sizeof(struct sgi_volume) * SGI_MAXVOLUMES);
memset(&(sgilabel->partitions), 0,
sizeof(struct sgi_partition) * SGI_MAXPARTITIONS);
cxt->label->nparts_max = SGI_MAXPARTITIONS;
/* don't create default layout when a script defined */
if (!cxt->script) {
sgi_set_entire(cxt);
sgi_set_volhdr(cxt);
}
cxt->label->nparts_cur = count_used_partitions(cxt);
fdisk_info(cxt, _("Created a new SGI disklabel."));
return 0;
}
