static void sgi_set_entire(struct fdisk_context *cxt) { int n; for (n=10; n<partitions; n++) { if (!sgi_get_num_sectors(cxt, n)) { sgi_set_partition(cxt, n, 0, sgi_get_lastblock(cxt), SGI_VOLUME); break; } } }
static void sgi_set_entire(struct fdisk_context *cxt) { size_t n; for (n = 10; n < cxt->label->nparts_max; n++) { if (!sgi_get_num_sectors(cxt, n)) { sgi_set_partition(cxt, n, 0, sgi_get_lastblock(cxt), SGI_TYPE_ENTIRE_DISK); break; } } }
static void sgi_set_entire(void) { int n; for (n=10; n<partitions; n++) { if (!sgi_get_num_sectors(n)) { sgi_set_partition(n, 0, sgi_get_lastblock(), SGI_VOLUME); break; } } }
static void sgi_set_volhdr(struct fdisk_context *cxt) { size_t n; for (n = 8; n < cxt->label->nparts_max; n++) { if (!sgi_get_num_sectors(cxt, n)) { /* Choose same default volume header size as IRIX fx uses. */ if (4096 < sgi_get_lastblock(cxt)) sgi_set_partition(cxt, n, 0, 4096, SGI_TYPE_VOLHDR); break; } } }
static void sgi_set_volhdr(struct fdisk_context *cxt) { int n; for (n=8; n<partitions; n++) { if (!sgi_get_num_sectors(cxt, n)) { /* * Choose same default volume header size * as IRIX fx uses. */ if (4096 < sgi_get_lastblock(cxt)) sgi_set_partition(cxt, n, 0, 4096, SGI_VOLHDR); break; } } }
static void sgi_set_volhdr(void) { int n; for (n=8; n<partitions; n++) { if (!sgi_get_num_sectors(n)) { /* * Choose same default volume header size * as IRIX fx uses. */ if (4096 < sgi_get_lastblock()) sgi_set_partition(n, 0, 4096, SGI_VOLHDR); break; } } }
static void sgi_set_volhdr(void) { int n; for (n = 8; n < partitions; n++) { if (!sgi_get_num_sectors(n)) { /* * 5 cylinders is an arbitrary value I like * IRIX 5.3 stored files in the volume header * (like sash, symmon, fx, ide) with ca. 3200 * sectors. */ if (heads * sectors * 5 < sgi_get_lastblock()) sgi_set_partition(n, 0, heads * sectors * 5, SGI_VOLHDR); break; } } }
static void sgi_add_partition(int n, int sys) { char mesg[256]; unsigned int first = 0, last = 0; if (n == 10) { sys = SGI_VOLUME; } else if (n == 8) { sys = 0; } if (sgi_get_num_sectors(n)) { printf(msg_part_already_defined, n + 1); return; } if ((sgi_entire() == -1) && (sys != SGI_VOLUME)) { printf("Attempting to generate entire disk entry automatically\n"); sgi_set_entire(); sgi_set_volhdr(); } if ((sgi_gaps() == 0) && (sys != SGI_VOLUME)) { printf("The entire disk is already covered with partitions\n"); return; } if (sgi_gaps() < 0) { printf("You got a partition overlap on the disk. Fix it first!\n"); return; } snprintf(mesg, sizeof(mesg), "First %s", str_units(SINGULAR)); while (1) { if (sys == SGI_VOLUME) { last = sgi_get_lastblock(); first = read_int(0, 0, last-1, 0, mesg); if (first != 0) { printf("It is highly recommended that eleventh partition\n" "covers the entire disk and is of type 'SGI volume'\n"); } } else { first = freelist[0].first; last = freelist[0].last; first = read_int(scround(first), scround(first), scround(last)-1, 0, mesg); } if (display_in_cyl_units) first *= units_per_sector; else first = first; /* align to cylinder if you know how ... */ if (!last ) last = isinfreelist(first); if (last != 0) break; printf("You will get a partition overlap on the disk. " "Fix it first!\n"); } snprintf(mesg, sizeof(mesg), " Last %s", str_units(SINGULAR)); last = read_int(scround(first), scround(last)-1, scround(last)-1, scround(first), mesg)+1; if (display_in_cyl_units) last *= units_per_sector; else last = last; /* align to cylinder if You know how ... */ if ( (sys == SGI_VOLUME) && (first != 0 || last != sgi_get_lastblock() ) ) printf("It is highly recommended that eleventh partition\n" "covers the entire disk and is of type 'SGI volume'\n"); sgi_set_partition(n, first, last-first, sys); }
static int verify_sgi(int verbose) { int Index[16]; /* 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(); clearfreelist(); for (i = 0; i < 16; i++) { if (sgi_get_num_sectors(i) != 0) { Index[sortcount++] = i; if (sgi_get_sysid(i) == SGI_ENTIRE_DISK) { if (entire++ == 1) { if (verbose) printf("More than one entire disk entry present\n"); } } } } if (sortcount == 0) { if (verbose) printf("No partitions defined\n"); return (lastblock > 0) ? 1 : (lastblock == 0) ? 0 : -1; } qsort(Index, sortcount, sizeof(Index[0]), (void*)compare_start); if (sgi_get_sysid(Index[0]) == SGI_ENTIRE_DISK) { if ((Index[0] != 10) && verbose) printf("IRIX likes when Partition 11 covers the entire disk\n"); if ((sgi_get_start_sector(Index[0]) != 0) && verbose) printf("The entire disk partition should start " "at block 0,\n" "not at diskblock %d\n", sgi_get_start_sector(Index[0])); if (debug) /* I do not understand how some disks fulfil it */ if ((sgi_get_num_sectors(Index[0]) != lastblock) && verbose) printf("The entire disk partition is only %d diskblock large,\n" "but the disk is %d diskblocks long\n", sgi_get_num_sectors(Index[0]), lastblock); lastblock = sgi_get_num_sectors(Index[0]); } else { if (verbose) printf("One Partition (#11) should cover the entire disk\n"); if (debug > 2) printf("sysid=%d\tpartition=%d\n", sgi_get_sysid(Index[0]), Index[0]+1); } for (i = 1, start = 0; i < sortcount; i++) { int cylsize = sgi_get_nsect() * sgi_get_ntrks(); if ((sgi_get_start_sector(Index[i]) % cylsize) != 0) { if (debug) /* I do not understand how some disks fulfil it */ if (verbose) printf("Partition %d does not start on cylinder boundary\n", Index[i]+1); } if (sgi_get_num_sectors(Index[i]) % cylsize != 0) { if (debug) /* I do not understand how some disks fulfil it */ if (verbose) printf("Partition %d does not end on cylinder boundary\n", Index[i]+1); } /* We cannot handle several "entire disk" entries. */ if (sgi_get_sysid(Index[i]) == SGI_ENTIRE_DISK) continue; if (start > sgi_get_start_sector(Index[i])) { if (verbose) printf("Partitions %d and %d overlap by %d sectors\n", Index[i-1]+1, Index[i]+1, start - sgi_get_start_sector(Index[i])); if (gap > 0) gap = -gap; if (gap == 0) gap = -1; } if (start < sgi_get_start_sector(Index[i])) { if (verbose) printf("Unused gap of %8u sectors - sectors %8u-%8u\n", sgi_get_start_sector(Index[i]) - start, start, sgi_get_start_sector(Index[i])-1); gap += sgi_get_start_sector(Index[i]) - start; add2freelist(start, sgi_get_start_sector(Index[i])); } start = sgi_get_start_sector(Index[i]) + sgi_get_num_sectors(Index[i]); if (debug > 1) { if (verbose) printf("%2d:%12d\t%12d\t%12d\n", Index[i], sgi_get_start_sector(Index[i]), sgi_get_num_sectors(Index[i]), sgi_get_sysid(Index[i])); } } if (start < lastblock) { if (verbose) printf("Unused gap of %8u sectors - sectors %8u-%8u\n", lastblock - start, start, lastblock-1); gap += lastblock - start; add2freelist(start, lastblock); } /* * Done with arithmetics * Go for details now */ if (verbose) { if (!sgi_get_num_sectors(sgi_get_bootpartition())) { printf("\nThe boot partition does not exist\n"); } if (!sgi_get_num_sectors(sgi_get_swappartition())) { printf("\nThe swap partition does not exist\n"); } else { if ((sgi_get_sysid(sgi_get_swappartition()) != SGI_SWAP) && (sgi_get_sysid(sgi_get_swappartition()) != LINUX_SWAP)) printf("\nThe swap partition has no swap type\n"); } if (sgi_check_bootfile("/unix")) printf("\tYou have chosen an unusual boot file name\n"); } return (gap > 0) ? 1 : (gap == 0) ? 0 : -1; }
static int sgi_add_partition(struct fdisk_context *cxt, size_t n, struct fdisk_parttype *t) { struct fdisk_sgi_label *sgi; char mesg[256]; unsigned int first = 0, last = 0; struct fdisk_ask *ask; int sys = t ? t->type : SGI_TYPE_XFS; int rc; assert(cxt); assert(cxt->label); assert(fdisk_is_disklabel(cxt, SGI)); 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 %zd is already defined. Delete " "it before re-adding it."), n + 1); return -EINVAL; } if (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; } snprintf(mesg, sizeof(mesg), _("First %s"), fdisk_context_get_unit(cxt, 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 (sys == SGI_TYPE_ENTIRE_DISK) { last = sgi_get_lastblock(cxt); fdisk_ask_number_set_low(ask, 0); /* minimal */ fdisk_ask_number_set_default(ask, 0); /* default */ fdisk_ask_number_set_high(ask, last - 1); /* maximal */ } else { first = sgi->freelist[0].first; last = sgi->freelist[0].last; 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_free_ask(ask); if (rc) return rc; if (first && sys == SGI_TYPE_ENTIRE_DISK) fdisk_info(cxt, _("It is highly recommended that " "eleventh partition covers the entire " "disk and is of type `SGI volume'")); if (fdisk_context_use_cylinders(cxt)) first *= fdisk_context_get_units_per_sector(cxt); /*else first = first; * align to cylinder if you know how ... */ if (!last) last = is_in_freelist(cxt, first); if (last == 0) fdisk_warnx(cxt, _("You will get a partition overlap " "on the disk. Fix it first!")); else break; } snprintf(mesg, sizeof(mesg), _("Last %s or +%s or +size{K,M,G,T,P}"), fdisk_context_get_unit(cxt, SINGULAR), fdisk_context_get_unit(cxt, 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_context_use_cylinders(cxt)) fdisk_ask_number_set_unit(ask, cxt->sector_size * fdisk_context_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_free_ask(ask); if (rc) return rc; if (fdisk_context_use_cylinders(cxt)) last *= fdisk_context_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 eleventh " "partition covers the entire disk and is of type " "`SGI volume'")); sgi_set_partition(cxt, n, first, last - first, sys); cxt->label->nparts_cur = count_used_partitions(cxt); return 0; }
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_disklabel(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")); 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 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 diskblock %d."), sgi_get_start_sector(cxt, Index[0])); if (verbose && sgi_get_num_sectors(cxt, Index[0]) != lastblock) DBG(LABEL, dbgprint( "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, dbgprint("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, dbgprint("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, dbgprint("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, _("The Partition %d and %d overlap " "by %d sectors."), 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, _("Unused gap of %8u sectors " "- sectors %8u-%u"), 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, dbgprint("%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, _("Unused gap of %8u sectors - sectors %8u-%u"), 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 boot " "file name.")); } return (gap > 0) ? 1 : (gap == 0) ? 0 : -1; }
static int sgi_add_partition(struct fdisk_context *cxt, int n, struct fdisk_parttype *t) { char mesg[256]; unsigned int first=0, last=0; int sys = t ? t->type : SGI_XFS; if (n == 10) sys = SGI_VOLUME; else if (n == 8) sys = 0; if (sgi_get_num_sectors(cxt, n)) { printf(_("Partition %d is already defined. Delete " "it before re-adding it.\n"), n + 1); return -EINVAL; } if ((sgi_entire(cxt) == -1) && (sys != SGI_VOLUME)) { printf(_("Attempting to generate entire disk entry automatically.\n")); sgi_set_entire(cxt); sgi_set_volhdr(cxt); } if ((sgi_gaps(cxt) == 0) && (sys != SGI_VOLUME)) { printf(_("The entire disk is already covered with partitions.\n")); return -EINVAL; } if (sgi_gaps(cxt) < 0) { printf(_("You got a partition overlap on the disk. Fix it first!\n")); return -EINVAL; } snprintf(mesg, sizeof(mesg), _("First %s"), str_units(SINGULAR)); for (;;) { if (sys == SGI_VOLUME) { last = sgi_get_lastblock(cxt); first = read_int(cxt, 0, 0, last-1, 0, mesg); if (first != 0) { printf(_("It is highly recommended that eleventh partition\n" "covers the entire disk and is of type `SGI volume'\n")); } } else { first = freelist[0].first; last = freelist[0].last; first = read_int(cxt, scround(first), scround(first), scround(last)-1, 0, mesg); } if (display_in_cyl_units) first *= units_per_sector; /*else first = first; * align to cylinder if you know how ... */ if (!last) last = isinfreelist(first); if (last == 0) { printf(_("You will get a partition overlap on the disk. " "Fix it first!\n")); } else break; } snprintf(mesg, sizeof(mesg), _(" Last %s"), str_units(SINGULAR)); last = read_int(cxt, scround(first), scround(last)-1, scround(last)-1, scround(first), mesg)+1; if (display_in_cyl_units) last *= units_per_sector; /*else last = last; * align to cylinder if You know how ... */ if ((sys == SGI_VOLUME) && (first != 0 || last != sgi_get_lastblock(cxt))) printf(_("It is highly recommended that eleventh partition\n" "covers the entire disk and is of type `SGI volume'\n")); sgi_set_partition(cxt, n, first, last-first, sys); 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; }