emo/busybox
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

last_patch100 from vidz updating fdisk to 2.12pre

Browse Source
This commit is contained in:
Eric Andersen 2003-07-30 08:40:37 +00:00
parent 08804ceaf1
commit 040f440262
1 changed files with 330 additions and 317 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

437
util-linux/fdisk.c
View File

@ -7,19 +7,10 @@
* published by the Free Software Foundation: either version 1 or * published by the Free Software Foundation: either version 1 or
* (at your option) any later version. * (at your option) any later version.
* *
* For detailed old history, see older versions.
* Contributions before 2001 by faith@cs.unc.edu, Michael Bischoff,
* LeBlanc@mcc.ac.uk, martin@cs.unc.edu, leisner@sdsp.mc.xerox.com,
* esr@snark.thyrsus.com, aeb@cwi.nl, quinlan@yggdrasil.com,
* fasten@cs.bonn.edu, orschaer@cip.informatik.uni-erlangen.de,
* jj@sunsite.mff.cuni.cz, fasten@shw.com, ANeuper@GUUG.de,
* kgw@suse.de, kalium@gmx.de, dhuggins@linuxcare.com,
* michal@ellpspace.math.ualberta.ca and probably others.
*
* Vladimir Oleynik <dzo@simtreas.ru> 2001,2002 Busybox port * Vladimir Oleynik <dzo@simtreas.ru> 2001,2002 Busybox port
*/ */
#define UTIL_LINUX_VERSION "2.11z" #define UTIL_LINUX_VERSION "2.12pre"
#define PROC_PARTITIONS "/proc/partitions" #define PROC_PARTITIONS "/proc/partitions"
@ -43,6 +34,7 @@
#include <sys/ioctl.h> #include <sys/ioctl.h>
#include <sys/param.h> #include <sys/param.h>
#include <sys/sysmacros.h> /* major */
#include <stdint.h> /* for uint32_t, uint16_t, uint8_t, int16_t, etc */ #include <stdint.h> /* for uint32_t, uint16_t, uint8_t, int16_t, etc */
@ -63,7 +55,7 @@
#define BLKGETSIZE _IO(0x12,96) /* return device size */ #define BLKGETSIZE _IO(0x12,96) /* return device size */
#define BLKFLSBUF _IO(0x12,97) /* flush buffer cache */ #define BLKFLSBUF _IO(0x12,97) /* flush buffer cache */
#define BLKSSZGET _IO(0x12,104) /* get block device sector size */ #define BLKSSZGET _IO(0x12,104) /* get block device sector size */
#define BLKGETSIZE64 _IOR(0x12,114,8) /* 8 = sizeof(u64) */
/* /*
fdisk.h fdisk.h
@ -117,6 +109,9 @@ struct systypes {
const unsigned char *name; const unsigned char *name;
}; };
static uint sector_size = DEFAULT_SECTOR_SIZE,
user_set_sector_size,
sector_offset = 1;
/* /*
* Raw disk label. For DOS-type partition tables the MBR, * Raw disk label. For DOS-type partition tables the MBR,
@ -405,8 +400,11 @@ typedef struct {
/* /*
Changes: Changes:
Sat Mar 20 09:51:38 EST 1999 Arnaldo Carvalho de Melo <acme@conectiva.com.br> * 1999-03-20 Arnaldo Carvalho de Melo <acme@conectiva.com.br>
Internationalization * Internationalization
*
* 2003-03-20 Phillip Kesling <pkesling@sgi.com>
* Some fixes
*/ */
static int aix_other_endian; static int aix_other_endian;
@ -515,6 +513,9 @@ check_aix_label( void )
#elif defined (__alpha__) || defined (__powerpc__) || defined (__ia64__) || defined (__hppa__) #elif defined (__alpha__) || defined (__powerpc__) || defined (__ia64__) || defined (__hppa__)
#define BSD_LABELSECTOR 0 #define BSD_LABELSECTOR 0
#define BSD_LABELOFFSET 64 #define BSD_LABELOFFSET 64
#elif defined (__s390__) || defined (__s390x__)
#define BSD_LABELSECTOR 1
#define BSD_LABELOFFSET 0
#else #else
#error unknown architecture #error unknown architecture
#endif #endif
@ -830,6 +831,7 @@ typedef struct {
unsigned short csum; /* Label xor'd checksum */ unsigned short csum; /* Label xor'd checksum */
} sun_partition; } sun_partition;
#define SUN_LABEL_MAGIC 0xDABE #define SUN_LABEL_MAGIC 0xDABE
#define SUN_LABEL_MAGIC_SWAPPED 0xBEDA #define SUN_LABEL_MAGIC_SWAPPED 0xBEDA
#define sunlabel ((sun_partition *)MBRbuffer) #define sunlabel ((sun_partition *)MBRbuffer)
@ -1216,7 +1218,8 @@ xbsd_create_disklabel (void) {
c = read_char (_("Do you want to create a disklabel? (y/n) ")); c = read_char (_("Do you want to create a disklabel? (y/n) "));
if (c == 'y' || c == 'Y') { if (c == 'y' || c == 'Y') {
if (xbsd_initlabel ( if (xbsd_initlabel (
#if defined (__alpha__) || defined (__powerpc__) || defined (__hppa__) #if defined (__alpha__) || defined (__powerpc__) || defined (__hppa__) || \
defined (__s390__) || defined (__s390x__)
NULL, &xbsd_dlabel, 0 NULL, &xbsd_dlabel, 0
#else #else
xbsd_part, &xbsd_dlabel, xbsd_part_index xbsd_part, &xbsd_dlabel, xbsd_part_index
@ -1557,7 +1560,7 @@ xbsd_readlabel (struct partition *p, struct xbsd_disklabel *d)
static int static int
xbsd_writelabel (struct partition *p, struct xbsd_disklabel *d) xbsd_writelabel (struct partition *p, struct xbsd_disklabel *d)
{ {
int sector; unsigned int sector;
#if !defined (__alpha__) && !defined (__powerpc__) && !defined (__hppa__) #if !defined (__alpha__) && !defined (__powerpc__) && !defined (__hppa__)
sector = get_start_sect(p) + BSD_LABELSECTOR; sector = get_start_sect(p) + BSD_LABELSECTOR;
@ -1663,7 +1666,10 @@ __swap16(unsigned short x) {
static inline uint32_t static inline uint32_t
__swap32(uint32_t x) { __swap32(uint32_t x) {
return (((uint32_t)(x) & 0xFF) << 24) | (((uint32_t)(x) & 0xFF00) << 8) | (((uint32_t)(x) & 0xFF0000) >> 8) | (((uint32_t)(x) & 0xFF000000) >> 24); return (((x & 0xFF) << 24) |
((x & 0xFF00) << 8) |
((x & 0xFF0000) >> 8) |
((x & 0xFF000000) >> 24));
} }
#endif #endif
@ -1689,40 +1695,39 @@ static short sgi_volumes=1;
* only dealing with free blocks here * only dealing with free blocks here
*/ */
typedef struct { int first; int last; } freeblocks; typedef struct { unsigned int first; unsigned int last; } freeblocks;
static freeblocks freelist[17]; /* 16 partitions can produce 17 vacant slots */ static freeblocks freelist[17]; /* 16 partitions can produce 17 vacant slots */
static void static void
setfreelist( int i, int f, int l ) { setfreelist(int i, unsigned int f, unsigned int l) {
freelist[i].first = f; freelist[i].first = f;
freelist[i].last = l; freelist[i].last = l;
} }
static void static void
add2freelist( int f, int l ) { add2freelist(unsigned int f, unsigned int l) {
int i = 0; int i = 0;
for( ; i<17 ; i++ ) { for ( ; i < 17 ; i++)
if(freelist[i].last==0) break; if (freelist[i].last == 0)
} break;
setfreelist(i, f, l); setfreelist(i, f, l);
} }
static void static void
clearfreelist(void) { clearfreelist(void) {
int i = 0; int i;
for( ; i<17 ; i++ ) {
for (i = 0; i < 17 ; i++)
setfreelist(i, 0, 0); setfreelist(i, 0, 0);
} }
}
static int static unsigned int
isinfreelist( int b ) { isinfreelist(unsigned int b) {
int i = 0; int i;
for( ; i<17 ; i++ ) {
if (freelist[i].first <= b && freelist[i].last >= b) { for (i = 0; i < 17 ; i++)
if (freelist[i].first <= b && freelist[i].last >= b)
return freelist[i].last; return freelist[i].last;
}
}
return 0; return 0;
} }
/* return last vacant block of this stride (never 0). */ /* return last vacant block of this stride (never 0). */
@ -1764,11 +1769,6 @@ sgi_get_ntrks(void) {
return SGI_SSWAP16(sgilabel->devparam.ntrks); return SGI_SSWAP16(sgilabel->devparam.ntrks);
} }
static int
sgi_get_pcylcount(void) {
return SGI_SSWAP16(sgilabel->devparam.pcylcount);
}
static void static void
sgi_nolabel(void) { sgi_nolabel(void) {
sgilabel->magic = 0; sgilabel->magic = 0;
@ -1781,9 +1781,9 @@ two_s_complement_32bit_sum(unsigned int* base, int size /* in bytes */ ) {
int i=0; int i=0;
unsigned int sum=0; unsigned int sum=0;
size = size / sizeof( unsigned int ); size /= sizeof(unsigned int);
for (i = 0; i < size; i++) for (i = 0; i < size; i++)
sum = sum - SGI_SSWAP32(base[i]); sum -= SGI_SSWAP32(base[i]);
return sum; return sum;
} }
@ -1808,14 +1808,9 @@ check_sgi_label(void) {
* test for correct checksum * test for correct checksum
*/ */
if (two_s_complement_32bit_sum((unsigned int*)sgilabel, if (two_s_complement_32bit_sum((unsigned int*)sgilabel,
sizeof(*sgilabel) ) ) sizeof(*sgilabel))) {
{ fprintf(stderr,
fprintf( stderr, _("Detected sgi disklabel with wrong checksum.\n")); _("Detected sgi disklabel with wrong checksum.\n"));
} else
{
heads = sgi_get_ntrks();
cylinders = sgi_get_pcylcount();
sectors = sgi_get_nsect();
} }
update_units(); update_units();
sgi_label = 1; sgi_label = 1;
@ -1824,12 +1819,12 @@ check_sgi_label(void) {
return 1; return 1;
} }
static int static unsigned int
sgi_get_start_sector(int i) { sgi_get_start_sector(int i) {
return SGI_SSWAP32(sgilabel->partitions[i].start_sector); return SGI_SSWAP32(sgilabel->partitions[i].start_sector);
} }
static int static unsigned int
sgi_get_num_sectors(int i) { sgi_get_num_sectors(int i) {
return SGI_SSWAP32(sgilabel->partitions[i].num_sectors); return SGI_SSWAP32(sgilabel->partitions[i].num_sectors);
} }
@ -1902,13 +1897,12 @@ sgi_list_table( int xtra ) {
printf(_("----- Bootinfo -----\nBootfile: %s\n" printf(_("----- Bootinfo -----\nBootfile: %s\n"
"----- Directory Entries -----\n"), "----- Directory Entries -----\n"),
sgilabel->boot_file); sgilabel->boot_file);
for (i = 0 ; i < sgi_volumes; i++) for (i = 0 ; i < sgi_volumes; i++) {
{ if (sgilabel->directory[i].vol_file_size) {
if (sgilabel->directory[i].vol_file_size)
{
uint32_t start = SGI_SSWAP32(sgilabel->directory[i].vol_file_start); uint32_t start = SGI_SSWAP32(sgilabel->directory[i].vol_file_start);
uint32_t len = SGI_SSWAP32(sgilabel->directory[i].vol_file_size); uint32_t len = SGI_SSWAP32(sgilabel->directory[i].vol_file_size);
char*name = sgilabel->directory[i].vol_file_name; char*name = sgilabel->directory[i].vol_file_name;
printf(_("%2d: %-10s sector%5u size%8u\n"), printf(_("%2d: %-10s sector%5u size%8u\n"),
i, name, (unsigned int) start, (unsigned int) len); i, name, (unsigned int) start, (unsigned int) len);
} }
@ -1921,7 +1915,7 @@ sgi_set_bootpartition( int i )
sgilabel->boot_part = SGI_SSWAP16(((short)i)); sgilabel->boot_part = SGI_SSWAP16(((short)i));
} }
static int static unsigned int
sgi_get_lastblock(void) { sgi_get_lastblock(void) {
return heads * sectors * cylinders; return heads * sectors * cylinders;
} }
@ -1933,25 +1927,26 @@ sgi_set_swappartition( int i ) {
static int static int
sgi_check_bootfile(const char* aFile) { sgi_check_bootfile(const char* aFile) {
if( strlen( aFile ) < 3 ) /* "/a\n" is minimum */
{ if (strlen(aFile) < 3) /* "/a\n" is minimum */ {
printf(_("\nInvalid Bootfile!\n" printf(_("\nInvalid Bootfile!\n"
"\tThe bootfile must be an absolute non-zero pathname,\n" "\tThe bootfile must be an absolute non-zero pathname,\n"
"\te.g. \"/unix\" or \"/unix.save\".\n")); "\te.g. \"/unix\" or \"/unix.save\".\n"));
return 0; return 0;
} else } else {
if( strlen( aFile ) > 16 ) if (strlen(aFile) > 16) {
{ printf(_("\n\tName of Bootfile too long: "
printf( _("\n\tName of Bootfile too long: 16 bytes maximum.\n") ); "16 bytes maximum.\n"));
return 0; return 0;
} else } else {
if( aFile[0] != '/' ) if (aFile[0] != '/') {
{ printf(_("\n\tBootfile must have a "
printf( _("\n\tBootfile must have a fully qualified pathname.\n") ); "fully qualified pathname.\n"));
return 0; return 0;
} }
if( strncmp( aFile, sgilabel->boot_file, 16 ) ) }
{ }
if (strncmp(aFile, sgilabel->boot_file, 16)) {
printf(_("\n\tBe aware, that the bootfile is not checked for existence.\n\t" printf(_("\n\tBe aware, that the bootfile is not checked for existence.\n\t"
"SGI's default is \"/unix\" and for backup \"/unix.save\".\n")); "SGI's default is \"/unix\" and for backup \"/unix.save\".\n"));
/* filename is correct and did change */ /* filename is correct and did change */
@ -1966,13 +1961,11 @@ sgi_get_bootfile(void) {
} }
static void static void
sgi_set_bootfile( const char* aFile ) sgi_set_bootfile(const char* aFile) {
{
int i = 0; int i = 0;
if( sgi_check_bootfile( aFile ) )
{ if (sgi_check_bootfile(aFile)) {
while( i<16 ) while (i < 16) {
{
if ((aFile[i] != '\n') /* in principle caught again by next line */ if ((aFile[i] != '\n') /* in principle caught again by next line */
&& (strlen(aFile) > i)) && (strlen(aFile) > i))
sgilabel->boot_file[i] = aFile[i]; sgilabel->boot_file[i] = aFile[i];
@ -1996,8 +1989,7 @@ create_sgiinfo(void)
static sgiinfo *fill_sgiinfo(void); static sgiinfo *fill_sgiinfo(void);
static void static void
sgi_write_table(void) sgi_write_table(void) {
{
sgilabel->csum = 0; sgilabel->csum = 0;
sgilabel->csum = SGI_SSWAP32(two_s_complement_32bit_sum( sgilabel->csum = SGI_SSWAP32(two_s_complement_32bit_sum(
(unsigned int*)sgilabel, (unsigned int*)sgilabel,
@ -2008,15 +2000,14 @@ sgi_write_table(void)
fdisk_fatal(unable_to_seek); fdisk_fatal(unable_to_seek);
if (write(fd, sgilabel, SECTOR_SIZE) != SECTOR_SIZE) if (write(fd, sgilabel, SECTOR_SIZE) != SECTOR_SIZE)
fdisk_fatal(unable_to_write); fdisk_fatal(unable_to_write);
if( ! strncmp( sgilabel->directory[0].vol_file_name, "sgilabel",8 ) ) if (! strncmp(sgilabel->directory[0].vol_file_name, "sgilabel", 8)) {
{
/* /*
* keep this habbit of first writing the "sgilabel". * keep this habit of first writing the "sgilabel".
* I never tested whether it works without (AN 981002). * I never tested whether it works without (AN 981002).
*/ */
sgiinfo*info = fill_sgiinfo(); /* fills the block appropriately */ sgiinfo *info = fill_sgiinfo();
int infostartblock = SGI_SSWAP32(sgilabel->directory[0].vol_file_start); int infostartblock = SGI_SSWAP32(sgilabel->directory[0].vol_file_start);
if( lseek(fd, (ext2_loff_t)infostartblock* if (lseek(fd, (long long)infostartblock*
SECTOR_SIZE, SEEK_SET) < 0) SECTOR_SIZE, SEEK_SET) < 0)
fdisk_fatal(unable_to_seek); fdisk_fatal(unable_to_seek);
if (write(fd, info, SECTOR_SIZE) != SECTOR_SIZE) if (write(fd, info, SECTOR_SIZE) != SECTOR_SIZE)
@ -2032,17 +2023,16 @@ compare_start( int *x, int *y ) {
* and prefers largest partition: * and prefers largest partition:
* entry zero is entire disk entry * entry zero is entire disk entry
*/ */
int i = *x; unsigned int i = *x;
int j = *y; unsigned int j = *y;
int a = sgi_get_start_sector(i); unsigned int a = sgi_get_start_sector(i);
int b = sgi_get_start_sector(j); unsigned int b = sgi_get_start_sector(j);
int c = sgi_get_num_sectors(i); unsigned int c = sgi_get_num_sectors(i);
int d = sgi_get_num_sectors(j); unsigned int d = sgi_get_num_sectors(j);
if (a == b) if (a == b)
{ return (d > c) ? 1 : (d == c) ? 0 : -1;
return( d - c ); return (a > b) ? 1 : -1;
}
return( a - b );
} }
@ -2051,68 +2041,60 @@ verify_sgi( int verbose )
{ {
int Index[16]; /* list of valid partitions */ int Index[16]; /* list of valid partitions */
int sortcount = 0; /* number of used partitions, i.e. non-zero lengths */ int sortcount = 0; /* number of used partitions, i.e. non-zero lengths */
int entire = 0, i = 0; /* local counters */ int entire = 0, i = 0;
int start = 0; unsigned int start = 0;
int gap = 0; /* count unused blocks */ long long gap = 0; /* count unused blocks */
int lastblock = sgi_get_lastblock(); unsigned int lastblock = sgi_get_lastblock();
/*
*/
clearfreelist(); clearfreelist();
for( i=0; i<16; i++ ) for (i=0; i<16; i++) {
{ if (sgi_get_num_sectors(i) != 0) {
if( sgi_get_num_sectors(i)!=0 )
{
Index[sortcount++]=i; Index[sortcount++]=i;
if( sgi_get_sysid(i) == ENTIRE_DISK ) if (sgi_get_sysid(i) == ENTIRE_DISK) {
{ if (entire++ == 1) {
if( entire++ == 1 )
{
if (verbose) if (verbose)
printf(_("More than one entire disk entry present.\n")); printf(_("More than one entire disk entry present.\n"));
} }
} }
} }
} }
if( sortcount == 0 ) if (sortcount == 0) {
{
if (verbose) if (verbose)
printf(_("No partitions defined\n")); printf(_("No partitions defined\n"));
return lastblock; return (lastblock > 0) ? 1 : (lastblock == 0) ? 0 : -1;
} }
qsort(Index, sortcount, sizeof(Index[0]), (void*)compare_start); qsort(Index, sortcount, sizeof(Index[0]), (void*)compare_start);
if( sgi_get_sysid( Index[0] ) == ENTIRE_DISK ) if (sgi_get_sysid(Index[0]) == ENTIRE_DISK) {
{
if ((Index[0] != 10) && verbose) if ((Index[0] != 10) && verbose)
printf(_("IRIX likes when Partition 11 covers the entire disk.\n")); printf(_("IRIX likes when Partition 11 covers the entire disk.\n"));
if ((sgi_get_start_sector(Index[0]) != 0) && verbose) if ((sgi_get_start_sector(Index[0]) != 0) && verbose)
printf( _("The entire disk partition should start at block 0,\nnot " printf(_("The entire disk partition should start "
"at diskblock %d.\n"), sgi_get_start_sector(Index[0] ) ); "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 (debug) /* I do not understand how some disks fulfil it */
if ((sgi_get_num_sectors(Index[0]) != lastblock) && verbose) if ((sgi_get_num_sectors(Index[0]) != lastblock) && verbose)
printf(_("The entire disk partition is only %d diskblock large,\n" printf(_("The entire disk partition is only %d diskblock large,\n"
"but the disk is %d diskblocks long.\n"), "but the disk is %d diskblocks long.\n"),
sgi_get_num_sectors(Index[0]), lastblock); sgi_get_num_sectors(Index[0]), lastblock);
lastblock = sgi_get_num_sectors(Index[0]); lastblock = sgi_get_num_sectors(Index[0]);
} else } else {
{
if (verbose) if (verbose)
printf(_("One Partition (#11) should cover the entire disk.\n")); printf(_("One Partition (#11) should cover the entire disk.\n"));
if (debug>2) if (debug>2)
printf("sysid=%d\tpartition=%d\n", printf("sysid=%d\tpartition=%d\n",
sgi_get_sysid(Index[0]), Index[0]+1); sgi_get_sysid(Index[0]), Index[0]+1);
} }
for( i=1, start=0; i<sortcount; i++ ) for (i=1, start=0; i<sortcount; i++) {
{
int cylsize = sgi_get_nsect() * sgi_get_ntrks(); int cylsize = sgi_get_nsect() * sgi_get_ntrks();
if( (sgi_get_start_sector( Index[i] ) % cylsize) != 0 )
{ if ((sgi_get_start_sector(Index[i]) % cylsize) != 0) {
if (debug) /* I do not understand how some disks fulfil it */ if (debug) /* I do not understand how some disks fulfil it */
if (verbose) if (verbose)
printf(_("Partition %d does not start on cylinder boundary.\n"), printf(_("Partition %d does not start on cylinder boundary.\n"),
Index[i]+1); Index[i]+1);
} }
if( sgi_get_num_sectors( Index[i] ) % cylsize != 0 ) if (sgi_get_num_sectors(Index[i]) % cylsize != 0) {
{
if (debug) /* I do not understand how some disks fulfil it */ if (debug) /* I do not understand how some disks fulfil it */
if (verbose) if (verbose)
printf(_("Partition %d does not end on cylinder boundary.\n"), printf(_("Partition %d does not end on cylinder boundary.\n"),
@ -2120,8 +2102,7 @@ verify_sgi( int verbose )
} }
/* We cannot handle several "entire disk" entries. */ /* We cannot handle several "entire disk" entries. */
if (sgi_get_sysid(Index[i]) == ENTIRE_DISK) continue; if (sgi_get_sysid(Index[i]) == ENTIRE_DISK) continue;
if( start > sgi_get_start_sector( Index[i] ) ) if (start > sgi_get_start_sector(Index[i])) {
{
if (verbose) if (verbose)
printf(_("The Partition %d and %d overlap by %d sectors.\n"), printf(_("The Partition %d and %d overlap by %d sectors.\n"),
Index[i-1]+1, Index[i]+1, Index[i-1]+1, Index[i]+1,
@ -2129,10 +2110,9 @@ verify_sgi( int verbose )
if (gap > 0) gap = -gap; if (gap > 0) gap = -gap;
if (gap == 0) gap = -1; if (gap == 0) gap = -1;
} }
if( start < sgi_get_start_sector( Index[i] ) ) if (start < sgi_get_start_sector(Index[i])) {
{
if (verbose) if (verbose)
printf( _("Unused gap of %8d sectors - sectors %8d-%d\n"), printf(_("Unused gap of %8u sectors - sectors %8u-%u\n"),
sgi_get_start_sector(Index[i]) - start, sgi_get_start_sector(Index[i]) - start,
start, sgi_get_start_sector(Index[i])-1); start, sgi_get_start_sector(Index[i])-1);
gap += sgi_get_start_sector(Index[i]) - start; gap += sgi_get_start_sector(Index[i]) - start;
@ -2140,8 +2120,7 @@ verify_sgi( int verbose )
} }
start = sgi_get_start_sector(Index[i]) start = sgi_get_start_sector(Index[i])
+ sgi_get_num_sectors(Index[i]); + sgi_get_num_sectors(Index[i]);
if(debug>1) if (debug > 1) {
{
if (verbose) if (verbose)
printf("%2d:%12d\t%12d\t%12d\n", Index[i], printf("%2d:%12d\t%12d\t%12d\n", Index[i],
sgi_get_start_sector(Index[i]), sgi_get_start_sector(Index[i]),
@ -2149,10 +2128,9 @@ verify_sgi( int verbose )
sgi_get_sysid(Index[i])); sgi_get_sysid(Index[i]));
} }
} }
if( ( start < lastblock ) ) if (start < lastblock) {
{
if (verbose) if (verbose)
printf( _("Unused gap of %8d sectors - sectors %8d-%d\n"), printf(_("Unused gap of %8u sectors - sectors %8u-%u\n"),
lastblock - start, start, lastblock-1); lastblock - start, start, lastblock-1);
gap += lastblock - start; gap += lastblock - start;
add2freelist(start, lastblock); add2freelist(start, lastblock);
@ -2161,27 +2139,21 @@ verify_sgi( int verbose )
* Done with arithmetics * Done with arithmetics
* Go for details now * Go for details now
*/ */
if( verbose ) if (verbose) {
{ if (!sgi_get_num_sectors(sgi_get_bootpartition())) {
if( !sgi_get_num_sectors( sgi_get_bootpartition() ) )
{
printf(_("\nThe boot partition does not exist.\n")); printf(_("\nThe boot partition does not exist.\n"));
} }
if( !sgi_get_num_sectors( sgi_get_swappartition() ) ) if (!sgi_get_num_sectors(sgi_get_swappartition())) {
{
printf(_("\nThe swap partition does not exist.\n")); printf(_("\nThe swap partition does not exist.\n"));
} else } else {
if ((sgi_get_sysid(sgi_get_swappartition()) != SGI_SWAP) if ((sgi_get_sysid(sgi_get_swappartition()) != SGI_SWAP)
&& (sgi_get_sysid(sgi_get_swappartition()) != LINUX_SWAP)) && (sgi_get_sysid(sgi_get_swappartition()) != LINUX_SWAP))
{
printf(_("\nThe swap partition has no swap type.\n")); printf(_("\nThe swap partition has no swap type.\n"));
} }
if (sgi_check_bootfile("/unix")) if (sgi_check_bootfile("/unix"))
{
printf(_("\tYou have chosen an unusual boot file name.\n")); printf(_("\tYou have chosen an unusual boot file name.\n"));
} }
} return (gap > 0) ? 1 : (gap == 0) ? 0 : -1;
return gap;
} }
static int static int
@ -2221,7 +2193,8 @@ sgi_change_sysid( int i, int sys )
/* returns partition index of first entry marked as entire disk */ /* returns partition index of first entry marked as entire disk */
static int static int
sgi_entire(void) { sgi_entire(void) {
int i=0; int i;
for(i=0; i<16; i++) for(i=0; i<16; i++)
if(sgi_get_sysid(i) == SGI_VOLUME) if(sgi_get_sysid(i) == SGI_VOLUME)
return i; return i;
@ -2229,13 +2202,11 @@ sgi_entire(void) {
} }
static void static void
sgi_set_partition( int i, uint start, uint length, int sys ) { sgi_set_partition(int i, unsigned int start, unsigned int length, int sys) {
sgilabel->partitions[i].id =
SGI_SSWAP32( sys ); sgilabel->partitions[i].id = SGI_SSWAP32(sys);
sgilabel->partitions[i].num_sectors = sgilabel->partitions[i].num_sectors = SGI_SSWAP32(length);
SGI_SSWAP32( length ); sgilabel->partitions[i].start_sector = SGI_SSWAP32(start);
sgilabel->partitions[i].start_sector =
SGI_SSWAP32( start );
set_changed(i); set_changed(i);
if (sgi_gaps() < 0) /* rebuild freelist */ if (sgi_gaps() < 0) /* rebuild freelist */
printf(_("Do You know, You got a partition overlap on the disk?\n")); printf(_("Do You know, You got a partition overlap on the disk?\n"));
@ -2244,6 +2215,7 @@ sgi_set_partition( int i, uint start, uint length, int sys ) {
static void static void
sgi_set_entire(void) { sgi_set_entire(void) {
int n; int n;
for(n=10; n < partitions; n++) { for(n=10; n < partitions; n++) {
if(!sgi_get_num_sectors(n) ) { if(!sgi_get_num_sectors(n) ) {
sgi_set_partition(n, 0, sgi_get_lastblock(), SGI_VOLUME); sgi_set_partition(n, 0, sgi_get_lastblock(), SGI_VOLUME);
@ -2283,34 +2255,28 @@ static void
sgi_add_partition( int n, int sys ) sgi_add_partition( int n, int sys )
{ {
char mesg[256]; char mesg[256];
int first=0, last=0; unsigned int first=0, last=0;
if( n == 10 ) { if( n == 10 ) {
sys = SGI_VOLUME; sys = SGI_VOLUME;
} else if ( n == 8 ) { } else if ( n == 8 ) {
sys = 0; sys = 0;
} }
if( sgi_get_num_sectors(n) ) if(sgi_get_num_sectors(n)) {
{
printf(_("Partition %d is already defined. Delete " printf(_("Partition %d is already defined. Delete "
"it before re-adding it.\n"), n + 1); "it before re-adding it.\n"), n + 1);
return; return;
} }
if( (sgi_entire() == -1) if( (sgi_entire() == -1) && (sys != SGI_VOLUME) ) {
&& (sys != SGI_VOLUME) )
{
printf(_("Attempting to generate entire disk entry automatically.\n")); printf(_("Attempting to generate entire disk entry automatically.\n"));
sgi_set_entire(); sgi_set_entire();
sgi_set_volhdr(); sgi_set_volhdr();
} }
if( (sgi_gaps() == 0) if( (sgi_gaps() == 0) && (sys != SGI_VOLUME) ) {
&& (sys != SGI_VOLUME) )
{
printf(_("The entire disk is already covered with partitions.\n")); printf(_("The entire disk is already covered with partitions.\n"));
return; return;
} }
if( sgi_gaps() < 0 ) if(sgi_gaps() < 0) {
{
printf(_("You got a partition overlap on the disk. Fix it first!\n")); printf(_("You got a partition overlap on the disk. Fix it first!\n"));
return; return;
} }
@ -2354,38 +2320,51 @@ sgi_add_partition( int n, int sys )
sgi_set_partition( n, first, last-first, sys ); sgi_set_partition( n, first, last-first, sys );
} }
#ifdef CONFIG_FEATURE_FDISK_ADVANCED
static void static void
create_sgilabel(void) create_sgilabel(void)
{ {
struct hd_geometry geometry; struct hd_geometry geometry;
struct { int start; struct {
int nsect; unsigned int start;
int sysid; } old[4]; unsigned int nsect;
int sysid;
} old[4];
int i=0; int i=0;
long longsectors; /* the number of sectors on the device */
int res; /* the result from the ioctl */
int sec_fac; /* the sector factor */
sec_fac = sector_size / 512; /* determine the sector factor */
fprintf( stderr, fprintf( stderr,
_("Building a new SGI disklabel. Changes will remain in memory only,\n" _("Building a new SGI disklabel. Changes will remain in memory only,\n"
"until you decide to write them. After that, of course, the previous\n" "until you decide to write them. After that, of course, the previous\n"
"content will be unrecoverably lost.\n\n")); "content will be unrecoverably lost.\n\n"));
sgi_other_endian = (BYTE_ORDER == LITTLE_ENDIAN); sgi_other_endian = (BYTE_ORDER == LITTLE_ENDIAN);
res = ioctl(fd, BLKGETSIZE, &longsectors);
#ifdef HDIO_REQ if (!ioctl(fd, HDIO_GETGEO, &geometry)) {
if (!ioctl(fd, HDIO_REQ, &geometry))
#else
if (!ioctl(fd, HDIO_GETGEO, &geometry))
#endif
{
heads = geometry.heads; heads = geometry.heads;
sectors = geometry.sectors; sectors = geometry.sectors;
if (res == 0) {
/* the get device size ioctl was successful */
cylinders = longsectors / (heads * sectors);
cylinders /= sec_fac;
} else {
/* otherwise print error and use truncated version */
cylinders = geometry.cylinders; cylinders = geometry.cylinders;
fprintf(stderr,
_("Warning: BLKGETSIZE ioctl failed on %s. "
"Using geometry cylinder value of %d.\n"
"This value may be truncated for devices"
" > 33.8 GB.\n"), disk_device, cylinders);
} }
for (i = 0; i < 4; i++) }
{ for (i = 0; i < 4; i++) {
old[i].sysid = 0; old[i].sysid = 0;
if( valid_part_table_flag(MBRbuffer) ) if(valid_part_table_flag(MBRbuffer)) {
{ if(get_part_table(i)->sys_ind) {
if( get_part_table(i)->sys_ind )
{
old[i].sysid = get_part_table(i)->sys_ind; old[i].sysid = get_part_table(i)->sys_ind;
old[i].start = get_start_sect(get_part_table(i)); old[i].start = get_start_sect(get_part_table(i));
old[i].nsect = get_nr_sects(get_part_table(i)); old[i].nsect = get_nr_sects(get_part_table(i));
@ -2396,6 +2375,7 @@ create_sgilabel(void)
} }
} }
} }
memset(MBRbuffer, 0, sizeof(MBRbuffer)); memset(MBRbuffer, 0, sizeof(MBRbuffer));
sgilabel->magic = SGI_SSWAP32(SGI_LABEL_MAGIC); sgilabel->magic = SGI_SSWAP32(SGI_LABEL_MAGIC);
sgilabel->boot_part = SGI_SSWAP16(0); sgilabel->boot_part = SGI_SSWAP16(0);
@ -2438,10 +2418,8 @@ create_sgilabel(void)
sgi_volumes = 15; sgi_volumes = 15;
sgi_set_entire(); sgi_set_entire();
sgi_set_volhdr(); sgi_set_volhdr();
for (i = 0; i < 4; i++) for (i = 0; i < 4; i++) {
{ if(old[i].sysid) {
if( old[i].sysid )
{
sgi_set_partition(i, old[i].start, old[i].nsect, old[i].sysid); sgi_set_partition(i, old[i].start, old[i].nsect, old[i].sysid);
} }
} }
@ -2452,6 +2430,7 @@ sgi_set_xcyl(void)
{ {
/* do nothing in the beginning */ /* do nothing in the beginning */
} }
#endif /* CONFIG_FEATURE_FDISK_ADVANCED */
/* _____________________________________________________________ /* _____________________________________________________________
*/ */
@ -2460,6 +2439,7 @@ static sgiinfo*
fill_sgiinfo(void) fill_sgiinfo(void)
{ {
sgiinfo *info = calloc(1, sizeof(sgiinfo)); sgiinfo *info = calloc(1, sizeof(sgiinfo));
info->magic=SGI_SSWAP32(SGI_INFO_MAGIC); info->magic=SGI_SSWAP32(SGI_INFO_MAGIC);
info->b1=SGI_SSWAP32(-1); info->b1=SGI_SSWAP32(-1);
info->b2=SGI_SSWAP16(-1); info->b2=SGI_SSWAP16(-1);
@ -2498,6 +2478,7 @@ static int floppy;
#ifndef IDE1_MAJOR #ifndef IDE1_MAJOR
#define IDE1_MAJOR 22 #define IDE1_MAJOR 22
#endif #endif
static void guess_device_type(void) { static void guess_device_type(void) {
struct stat bootstat; struct stat bootstat;
@ -2505,12 +2486,12 @@ static void guess_device_type(void) {
scsi_disk = 0; scsi_disk = 0;
floppy = 0; floppy = 0;
} else if (S_ISBLK(bootstat.st_mode) } else if (S_ISBLK(bootstat.st_mode)
&& ((bootstat.st_rdev >> 8) == IDE0_MAJOR || && (major(bootstat.st_rdev) == IDE0_MAJOR ||
(bootstat.st_rdev >> 8) == IDE1_MAJOR)) { major(bootstat.st_rdev) == IDE1_MAJOR)) {
scsi_disk = 0; scsi_disk = 0;
floppy = 0; floppy = 0;
} else if (S_ISBLK(bootstat.st_mode) } else if (S_ISBLK(bootstat.st_mode)
&& (bootstat.st_rdev >> 8) == FLOPPY_MAJOR) { && major(bootstat.st_rdev) == FLOPPY_MAJOR) {
scsi_disk = 0; scsi_disk = 0;
floppy = 1; floppy = 1;
} else { } else {
@ -2736,11 +2717,7 @@ static void create_sunlabel(void)
} }
} }
if (!p || floppy) { if (!p || floppy) {
#ifdef HDIO_REQ
if (!ioctl(fd, HDIO_REQ, &geometry)) {
#else
if (!ioctl(fd, HDIO_GETGEO, &geometry)) { if (!ioctl(fd, HDIO_GETGEO, &geometry)) {
#endif
heads = geometry.heads; heads = geometry.heads;
sectors = geometry.sectors; sectors = geometry.sectors;
cylinders = geometry.cylinders; cylinders = geometry.cylinders;
@ -3046,15 +3023,16 @@ and is of type `Whole disk'\n");
static void static void
sun_delete_partition(int i) { sun_delete_partition(int i) {
unsigned int nsec;
if (i == 2 && sunlabel->infos[i].id == WHOLE_DISK && if (i == 2 && sunlabel->infos[i].id == WHOLE_DISK &&
!sunlabel->partitions[i].start_cylinder && !sunlabel->partitions[i].start_cylinder &&
SUN_SSWAP32(sunlabel->partitions[i].num_sectors) (nsec = SUN_SSWAP32(sunlabel->partitions[i].num_sectors))
== heads * sectors * cylinders) == heads * sectors * cylinders)
printf(_("If you want to maintain SunOS/Solaris compatibility, " printf(_("If you want to maintain SunOS/Solaris compatibility, "
"consider leaving this\n" "consider leaving this\n"
"partition as Whole disk (5), starting at 0, with %u " "partition as Whole disk (5), starting at 0, with %u "
"sectors\n"), "sectors\n"), nsec);
(uint) SUN_SSWAP32(sunlabel->partitions[i].num_sectors));
sunlabel->infos[i].id = 0; sunlabel->infos[i].id = 0;
sunlabel->partitions[i].num_sectors = 0; sunlabel->partitions[i].num_sectors = 0;
} }
@ -3132,6 +3110,8 @@ sun_list_table(int xtra) {
} }
} }
#ifdef CONFIG_FEATURE_FDISK_ADVANCED
static void static void
sun_set_alt_cyl(void) { sun_set_alt_cyl(void) {
sunlabel->nacyl = sunlabel->nacyl =
@ -3171,6 +3151,7 @@ sun_set_pcylcount(void) {
SUN_SSWAP16(read_int(0, SUN_SSWAP16(sunlabel->pcylcount), 65535, 0, SUN_SSWAP16(read_int(0, SUN_SSWAP16(sunlabel->pcylcount), 65535, 0,
_("Number of physical cylinders"))); _("Number of physical cylinders")));
} }
#endif /* CONFIG_FEATURE_FDISK_ADVANCED */
static void static void
sun_write_table(void) { sun_write_table(void) {
@ -3368,11 +3349,8 @@ static uint pt_heads, pt_sectors;
static uint kern_heads, kern_sectors; static uint kern_heads, kern_sectors;
static uint extended_offset; /* offset of link pointers */ static uint extended_offset; /* offset of link pointers */
static uint sector_size = DEFAULT_SECTOR_SIZE,
user_set_sector_size,
sector_offset = 1;
static unsigned long total_number_of_sectors; static unsigned long long total_number_of_sectors;
static jmp_buf listingbuf; static jmp_buf listingbuf;
@ -3979,7 +3957,7 @@ get_partition_table_geometry(void) {
void void
get_geometry(void) { get_geometry(void) {
int sec_fac; int sec_fac;
unsigned long longsectors; unsigned long long bytes; /* really u64 */
get_sectorsize(); get_sectorsize();
sec_fac = sector_size / 512; sec_fac = sector_size / 512;
@ -3999,20 +3977,25 @@ get_geometry(void) {
sectors = user_sectors ? user_sectors : sectors = user_sectors ? user_sectors :
pt_sectors ? pt_sectors : pt_sectors ? pt_sectors :
kern_sectors ? kern_sectors : 63; kern_sectors ? kern_sectors : 63;
if (ioctl(fd, BLKGETSIZE64, &bytes) == 0) {
/* got bytes */
} else {
unsigned long longsectors;
if (ioctl(fd, BLKGETSIZE, &longsectors)) if (ioctl(fd, BLKGETSIZE, &longsectors))
longsectors = 0; longsectors = 0;
bytes = ((unsigned long long) longsectors) << 9;
}
total_number_of_sectors = (bytes >> 9);
sector_offset = 1; sector_offset = 1;
if (dos_compatible_flag) if (dos_compatible_flag)
sector_offset = sectors; sector_offset = sectors;
cylinders = longsectors / (heads * sectors); cylinders = total_number_of_sectors / (heads * sectors * sec_fac);
cylinders /= sec_fac;
if (!cylinders) if (!cylinders)
cylinders = user_cylinders; cylinders = user_cylinders;
total_number_of_sectors = longsectors;
} }
/* /*
@ -4198,10 +4181,10 @@ read_int(uint low, uint dflt, uint high, uint base, char *mesg)
default_ok = 0; default_ok = 0;
if (default_ok) if (default_ok)
snprintf(ms, mslen, _("%s (%d-%d, default %d): "), snprintf(ms, mslen, _("%s (%u-%u, default %u): "),
mesg, low, high, dflt); mesg, low, high, dflt);
else else
snprintf(ms, mslen, "%s (%d-%d): ", snprintf(ms, mslen, "%s (%u-%u): ",
mesg, low, high); mesg, low, high);
while (1) { while (1) {
@ -4227,8 +4210,10 @@ read_int(uint low, uint dflt, uint high, uint base, char *mesg)
if (!display_in_cyl_units) if (!display_in_cyl_units)
i *= heads * sectors; i *= heads * sectors;
break; break;
case 'k':
case 'K': case 'K':
absolute = 1024;
break;
case 'k':
absolute = 1000; absolute = 1000;
break; break;
case 'm': case 'm':
@ -4263,7 +4248,7 @@ read_int(uint low, uint dflt, uint high, uint base, char *mesg)
} }
} }
if (use_default) if (use_default)
printf(_("Using default value %d\n"), i = dflt); printf(_("Using default value %u\n"), i = dflt);
if (i >= low && i <= high) if (i >= low && i <= high)
break; break;
else else
@ -4466,7 +4451,18 @@ change_sysid(void) {
int i, sys, origsys; int i, sys, origsys;
struct partition *p; struct partition *p;
#ifdef CONFIG_FEATURE_SGI_LABEL
/* If sgi_label then don't use get_existing_partition,
let the user select a partition, since get_existing_partition()
only works for Linux like partition tables. */
if (!sgi_label) {
i = get_existing_partition(0, partitions); i = get_existing_partition(0, partitions);
} else {
i = get_partition(0, partitions);
}
#else
i = get_existing_partition(0, partitions);
#endif
if (i == -1) if (i == -1)
return; return;
p = ptes[i].part_table; p = ptes[i].part_table;
@ -4618,7 +4614,7 @@ static void check_consistency(const struct partition *p, int partition) {
static void static void
list_disk_geometry(void) { list_disk_geometry(void) {
long long bytes = (long long) total_number_of_sectors * 512; long long bytes = (total_number_of_sectors << 9);
long megabytes = bytes/1000000; long megabytes = bytes/1000000;
if (megabytes < 10000) if (megabytes < 10000)
@ -4630,7 +4626,7 @@ list_disk_geometry(void) {
printf(_("%d heads, %d sectors/track, %d cylinders"), printf(_("%d heads, %d sectors/track, %d cylinders"),
heads, sectors, cylinders); heads, sectors, cylinders);
if (units_per_sector == 1) if (units_per_sector == 1)
printf(_(", total %lu sectors"), printf(_(", total %llu sectors"),
total_number_of_sectors / (sector_size/512)); total_number_of_sectors / (sector_size/512));
printf(_("\nUnits = %s of %d * %d = %d bytes\n\n"), printf(_("\nUnits = %s of %d * %d = %d bytes\n\n"),
str_units(PLURAL), str_units(PLURAL),
@ -4831,14 +4827,14 @@ list_table(int xtra) {
if (sector_size > 1024) if (sector_size > 1024)
pblocks *= (sector_size / 1024); pblocks *= (sector_size / 1024);
printf( printf(
"%s %c %9ld %9ld %9ld%c %2x %s\n", "%s %c %11lu %11lu %11lu%c %2x %s\n",
partname(disk_device, i+1, w+2), partname(disk_device, i+1, w+2),
/* boot flag */ !p->boot_ind ? ' ' : p->boot_ind == ACTIVE_FLAG /* boot flag */ !p->boot_ind ? ' ' : p->boot_ind == ACTIVE_FLAG
? '*' : '?', ? '*' : '?',
/* start */ (long) cround(get_partition_start(pe)), /* start */ (unsigned long) cround(get_partition_start(pe)),
/* end */ (long) cround(get_partition_start(pe) + psects /* end */ (unsigned long) cround(get_partition_start(pe) + psects
- (psects ? 1 : 0)), - (psects ? 1 : 0)),
/* odd flag on end */ (long) pblocks, podd ? '+' : ' ', /* odd flag on end */ (unsigned long) pblocks, podd ? '+' : ' ',
/* type id */ p->sys_ind, /* type id */ p->sys_ind,
/* type name */ partition_type(p->sys_ind)); /* type name */ partition_type(p->sys_ind));
check_consistency(p, i); check_consistency(p, i);
@ -4867,7 +4863,7 @@ x_list_table(int extend) {
pe = &ptes[i]; pe = &ptes[i];
p = (extend ? pe->ext_pointer : pe->part_table); p = (extend ? pe->ext_pointer : pe->part_table);
if (p != NULL) { if (p != NULL) {
printf("%2d %02x%4d%4d%5d%4d%4d%5d%9d%9d %02x\n", printf("%2d %02x%4d%4d%5d%4d%4d%5d%11u%11u %02x\n",
i + 1, p->boot_ind, p->head, i + 1, p->boot_ind, p->head,
sector(p->sector), sector(p->sector),
cylinder(p->sector, p->cyl), p->end_head, cylinder(p->sector, p->cyl), p->end_head,
@ -5007,6 +5003,7 @@ add_partition(int n, int sys) {
int i, readed = 0; int i, readed = 0;
struct partition *p = ptes[n].part_table; struct partition *p = ptes[n].part_table;
struct partition *q = ptes[ext_index].part_table; struct partition *q = ptes[ext_index].part_table;
long long llimit;
uint start, stop = 0, limit, temp, uint start, stop = 0, limit, temp,
first[partitions], last[partitions]; first[partitions], last[partitions];
@ -5018,10 +5015,13 @@ add_partition(int n, int sys) {
fill_bounds(first, last); fill_bounds(first, last);
if (n < 4) { if (n < 4) {
start = sector_offset; start = sector_offset;
if (display_in_cyl_units) if (display_in_cyl_units || !total_number_of_sectors)
limit = heads * sectors * cylinders - 1; llimit = heads * sectors * cylinders - 1;
else else
limit = total_number_of_sectors - 1; llimit = total_number_of_sectors - 1;
limit = llimit;
if (limit != llimit)
limit = 0x7fffffff;
if (extended_offset) { if (extended_offset) {
first[ext_index] = extended_offset; first[ext_index] = extended_offset;
last[ext_index] = get_start_sect(q) + last[ext_index] = get_start_sect(q) +
@ -5792,7 +5792,20 @@ int fdisk_main(int argc, char **argv) {
break; break;
case 'd': case 'd':
{ {
int j = get_existing_partition(1, partitions); int j;
#ifdef CONFIG_FEATURE_SGI_LABEL
/* If sgi_label then don't use get_existing_partition,
let the user select a partition, since
get_existing_partition() only works for Linux-like
partition tables */
if (!sgi_label) {
j = get_existing_partition(1, partitions);
} else {
j = get_partition(1, partitions);
}
#else
j = get_existing_partition(1, partitions);
#endif
if (j >= 0) if (j >= 0)
delete_partition(j); delete_partition(j);
} }