mirror of
https://github.com/sheumann/hush.git
synced 2024-08-26 12:29:04 +00:00
This change retains "or later" state! No licensing _changes_ here, only form is adjusted (article, space between "GPL" and "v2" and so on). Signed-off-by: Denys Vlasenko <vda.linux@googlemail.com>
887 lines
24 KiB
C
887 lines
24 KiB
C
/*
|
|
* Copyright (C) Andreas Neuper, Sep 1998.
|
|
*
|
|
* Licensed under GPLv2, see file LICENSE in this source tree.
|
|
*/
|
|
|
|
#if ENABLE_FEATURE_SGI_LABEL
|
|
|
|
#define SGI_DEBUG 0
|
|
|
|
#define SGI_VOLHDR 0x00
|
|
/* 1 and 2 were used for drive types no longer supported by SGI */
|
|
#define SGI_SWAP 0x03
|
|
/* 4 and 5 were for filesystem types SGI haven't ever supported on MIPS CPUs */
|
|
#define SGI_VOLUME 0x06
|
|
#define SGI_EFS 0x07
|
|
#define SGI_LVOL 0x08
|
|
#define SGI_RLVOL 0x09
|
|
#define SGI_XFS 0x0a
|
|
#define SGI_XFSLOG 0x0b
|
|
#define SGI_XLV 0x0c
|
|
#define SGI_XVM 0x0d
|
|
#define SGI_ENTIRE_DISK SGI_VOLUME
|
|
|
|
struct device_parameter { /* 48 bytes */
|
|
unsigned char skew;
|
|
unsigned char gap1;
|
|
unsigned char gap2;
|
|
unsigned char sparecyl;
|
|
unsigned short pcylcount;
|
|
unsigned short head_vol0;
|
|
unsigned short ntrks; /* tracks in cyl 0 or vol 0 */
|
|
unsigned char cmd_tag_queue_depth;
|
|
unsigned char unused0;
|
|
unsigned short unused1;
|
|
unsigned short nsect; /* sectors/tracks in cyl 0 or vol 0 */
|
|
unsigned short bytes;
|
|
unsigned short ilfact;
|
|
unsigned int flags; /* controller flags */
|
|
unsigned int datarate;
|
|
unsigned int retries_on_error;
|
|
unsigned int ms_per_word;
|
|
unsigned short xylogics_gap1;
|
|
unsigned short xylogics_syncdelay;
|
|
unsigned short xylogics_readdelay;
|
|
unsigned short xylogics_gap2;
|
|
unsigned short xylogics_readgate;
|
|
unsigned short xylogics_writecont;
|
|
};
|
|
|
|
/*
|
|
* controller flags
|
|
*/
|
|
#define SECTOR_SLIP 0x01
|
|
#define SECTOR_FWD 0x02
|
|
#define TRACK_FWD 0x04
|
|
#define TRACK_MULTIVOL 0x08
|
|
#define IGNORE_ERRORS 0x10
|
|
#define RESEEK 0x20
|
|
#define ENABLE_CMDTAGQ 0x40
|
|
|
|
typedef struct {
|
|
unsigned int magic; /* expect SGI_LABEL_MAGIC */
|
|
unsigned short boot_part; /* active boot partition */
|
|
unsigned short swap_part; /* active swap partition */
|
|
unsigned char boot_file[16]; /* name of the bootfile */
|
|
struct device_parameter devparam; /* 1 * 48 bytes */
|
|
struct volume_directory { /* 15 * 16 bytes */
|
|
unsigned char vol_file_name[8]; /* a character array */
|
|
unsigned int vol_file_start; /* number of logical block */
|
|
unsigned int vol_file_size; /* number of bytes */
|
|
} directory[15];
|
|
struct sgi_partinfo { /* 16 * 12 bytes */
|
|
unsigned int num_sectors; /* number of blocks */
|
|
unsigned int start_sector; /* must be cylinder aligned */
|
|
unsigned int id;
|
|
} partitions[16];
|
|
unsigned int csum;
|
|
unsigned int fillbytes;
|
|
} sgi_partition;
|
|
|
|
typedef struct {
|
|
unsigned int magic; /* looks like a magic number */
|
|
unsigned int a2;
|
|
unsigned int a3;
|
|
unsigned int a4;
|
|
unsigned int b1;
|
|
unsigned short b2;
|
|
unsigned short b3;
|
|
unsigned int c[16];
|
|
unsigned short d[3];
|
|
unsigned char scsi_string[50];
|
|
unsigned char serial[137];
|
|
unsigned short check1816;
|
|
unsigned char installer[225];
|
|
} sgiinfo;
|
|
|
|
#define SGI_LABEL_MAGIC 0x0be5a941
|
|
#define SGI_LABEL_MAGIC_SWAPPED 0x41a9e50b
|
|
#define SGI_INFO_MAGIC 0x00072959
|
|
#define SGI_INFO_MAGIC_SWAPPED 0x59290700
|
|
|
|
#define SGI_SSWAP16(x) (sgi_other_endian ? fdisk_swap16(x) : (uint16_t)(x))
|
|
#define SGI_SSWAP32(x) (sgi_other_endian ? fdisk_swap32(x) : (uint32_t)(x))
|
|
|
|
#define sgilabel ((sgi_partition *)MBRbuffer)
|
|
#define sgiparam (sgilabel->devparam)
|
|
|
|
/*
|
|
*
|
|
* fdisksgilabel.c
|
|
*
|
|
* Copyright (C) Andreas Neuper, Sep 1998.
|
|
* This file may be modified and redistributed under
|
|
* the terms of the GNU Public License.
|
|
*
|
|
* Sat Mar 20 EST 1999 Arnaldo Carvalho de Melo <acme@conectiva.com.br>
|
|
* Internationalization
|
|
*/
|
|
|
|
|
|
static smallint sgi_other_endian; /* bool */
|
|
static smallint sgi_volumes = 1; /* max 15 */
|
|
|
|
/*
|
|
* only dealing with free blocks here
|
|
*/
|
|
|
|
typedef struct {
|
|
unsigned int first;
|
|
unsigned int last;
|
|
} freeblocks;
|
|
static freeblocks freelist[17]; /* 16 partitions can produce 17 vacant slots */
|
|
|
|
static void
|
|
setfreelist(int i, unsigned int f, unsigned int l)
|
|
{
|
|
freelist[i].first = f;
|
|
freelist[i].last = l;
|
|
}
|
|
|
|
static void
|
|
add2freelist(unsigned int f, unsigned int l)
|
|
{
|
|
int i;
|
|
for (i = 0; i < 17; i++)
|
|
if (freelist[i].last == 0)
|
|
break;
|
|
setfreelist(i, f, l);
|
|
}
|
|
|
|
static void
|
|
clearfreelist(void)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < 17; i++)
|
|
setfreelist(i, 0, 0);
|
|
}
|
|
|
|
static unsigned int
|
|
isinfreelist(unsigned int b)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < 17; i++)
|
|
if (freelist[i].first <= b && freelist[i].last >= b)
|
|
return freelist[i].last;
|
|
return 0;
|
|
}
|
|
/* return last vacant block of this stride (never 0). */
|
|
/* the '>=' is not quite correct, but simplifies the code */
|
|
/*
|
|
* end of free blocks section
|
|
*/
|
|
|
|
static const char *const sgi_sys_types[] = {
|
|
/* SGI_VOLHDR */ "\x00" "SGI volhdr" ,
|
|
/* 0x01 */ "\x01" "SGI trkrepl" ,
|
|
/* 0x02 */ "\x02" "SGI secrepl" ,
|
|
/* SGI_SWAP */ "\x03" "SGI raw" ,
|
|
/* 0x04 */ "\x04" "SGI bsd" ,
|
|
/* 0x05 */ "\x05" "SGI sysv" ,
|
|
/* SGI_ENTIRE_DISK */ "\x06" "SGI volume" ,
|
|
/* SGI_EFS */ "\x07" "SGI efs" ,
|
|
/* 0x08 */ "\x08" "SGI lvol" ,
|
|
/* 0x09 */ "\x09" "SGI rlvol" ,
|
|
/* SGI_XFS */ "\x0a" "SGI xfs" ,
|
|
/* SGI_XFSLOG */ "\x0b" "SGI xfslog" ,
|
|
/* SGI_XLV */ "\x0c" "SGI xlv" ,
|
|
/* SGI_XVM */ "\x0d" "SGI xvm" ,
|
|
/* LINUX_SWAP */ "\x82" "Linux swap" ,
|
|
/* LINUX_NATIVE */ "\x83" "Linux native",
|
|
/* LINUX_LVM */ "\x8d" "Linux LVM" ,
|
|
/* LINUX_RAID */ "\xfd" "Linux RAID" ,
|
|
NULL
|
|
};
|
|
|
|
|
|
static int
|
|
sgi_get_nsect(void)
|
|
{
|
|
return SGI_SSWAP16(sgilabel->devparam.nsect);
|
|
}
|
|
|
|
static int
|
|
sgi_get_ntrks(void)
|
|
{
|
|
return SGI_SSWAP16(sgilabel->devparam.ntrks);
|
|
}
|
|
|
|
static unsigned int
|
|
two_s_complement_32bit_sum(unsigned int* base, int size /* in bytes */)
|
|
{
|
|
int i = 0;
|
|
unsigned int sum = 0;
|
|
|
|
size /= sizeof(unsigned int);
|
|
for (i = 0; i < size; i++)
|
|
sum -= SGI_SSWAP32(base[i]);
|
|
return sum;
|
|
}
|
|
|
|
void BUG_bad_sgi_partition_size(void);
|
|
|
|
static int
|
|
check_sgi_label(void)
|
|
{
|
|
if (sizeof(sgi_partition) > 512) {
|
|
/* According to MIPS Computer Systems, Inc the label
|
|
* must not contain more than 512 bytes */
|
|
BUG_bad_sgi_partition_size();
|
|
}
|
|
|
|
if (sgilabel->magic != SGI_LABEL_MAGIC
|
|
&& sgilabel->magic != SGI_LABEL_MAGIC_SWAPPED
|
|
) {
|
|
current_label_type = LABEL_DOS;
|
|
return 0;
|
|
}
|
|
|
|
sgi_other_endian = (sgilabel->magic == SGI_LABEL_MAGIC_SWAPPED);
|
|
/*
|
|
* test for correct checksum
|
|
*/
|
|
if (two_s_complement_32bit_sum((unsigned int*)sgilabel,
|
|
sizeof(*sgilabel))) {
|
|
printf("Detected sgi disklabel with wrong checksum\n");
|
|
}
|
|
update_units();
|
|
current_label_type = LABEL_SGI;
|
|
g_partitions = 16;
|
|
sgi_volumes = 15;
|
|
return 1;
|
|
}
|
|
|
|
static unsigned int
|
|
sgi_get_start_sector(int i)
|
|
{
|
|
return SGI_SSWAP32(sgilabel->partitions[i].start_sector);
|
|
}
|
|
|
|
static unsigned int
|
|
sgi_get_num_sectors(int i)
|
|
{
|
|
return SGI_SSWAP32(sgilabel->partitions[i].num_sectors);
|
|
}
|
|
|
|
static int
|
|
sgi_get_sysid(int i)
|
|
{
|
|
return SGI_SSWAP32(sgilabel->partitions[i].id);
|
|
}
|
|
|
|
static int
|
|
sgi_get_bootpartition(void)
|
|
{
|
|
return SGI_SSWAP16(sgilabel->boot_part);
|
|
}
|
|
|
|
static int
|
|
sgi_get_swappartition(void)
|
|
{
|
|
return SGI_SSWAP16(sgilabel->swap_part);
|
|
}
|
|
|
|
static void
|
|
sgi_list_table(int xtra)
|
|
{
|
|
int i, w, wd;
|
|
int kpi = 0; /* kernel partition ID */
|
|
|
|
if (xtra) {
|
|
printf("\nDisk %s (SGI disk label): %u heads, %u sectors\n"
|
|
"%u cylinders, %u physical cylinders\n"
|
|
"%u extra sects/cyl, interleave %u:1\n"
|
|
"%s\n"
|
|
"Units = %s of %u * 512 bytes\n\n",
|
|
disk_device, g_heads, g_sectors, g_cylinders,
|
|
SGI_SSWAP16(sgiparam.pcylcount),
|
|
SGI_SSWAP16(sgiparam.sparecyl),
|
|
SGI_SSWAP16(sgiparam.ilfact),
|
|
(char *)sgilabel,
|
|
str_units(PLURAL), units_per_sector);
|
|
} else {
|
|
printf("\nDisk %s (SGI disk label): "
|
|
"%u heads, %u sectors, %u cylinders\n"
|
|
"Units = %s of %u * 512 bytes\n\n",
|
|
disk_device, g_heads, g_sectors, g_cylinders,
|
|
str_units(PLURAL), units_per_sector );
|
|
}
|
|
|
|
w = strlen(disk_device);
|
|
wd = sizeof("Device") - 1;
|
|
if (w < wd)
|
|
w = wd;
|
|
|
|
printf("----- partitions -----\n"
|
|
"Pt# %*s Info Start End Sectors Id System\n",
|
|
w + 2, "Device");
|
|
for (i = 0; i < g_partitions; i++) {
|
|
if (sgi_get_num_sectors(i) || SGI_DEBUG) {
|
|
uint32_t start = sgi_get_start_sector(i);
|
|
uint32_t len = sgi_get_num_sectors(i);
|
|
kpi++; /* only count nonempty partitions */
|
|
printf(
|
|
"%2u: %s %4s %9lu %9lu %9lu %2x %s\n",
|
|
/* fdisk part number */ i+1,
|
|
/* device */ partname(disk_device, kpi, w+3),
|
|
/* flags */ (sgi_get_swappartition() == i) ? "swap" :
|
|
/* flags */ (sgi_get_bootpartition() == i) ? "boot" : " ",
|
|
/* start */ (long) scround(start),
|
|
/* end */ (long) scround(start+len)-1,
|
|
/* no odd flag on end */(long) len,
|
|
/* type id */ sgi_get_sysid(i),
|
|
/* type name */ partition_type(sgi_get_sysid(i)));
|
|
}
|
|
}
|
|
printf("----- Bootinfo -----\nBootfile: %s\n"
|
|
"----- Directory Entries -----\n",
|
|
sgilabel->boot_file);
|
|
for (i = 0; i < sgi_volumes; i++) {
|
|
if (sgilabel->directory[i].vol_file_size) {
|
|
uint32_t start = SGI_SSWAP32(sgilabel->directory[i].vol_file_start);
|
|
uint32_t len = SGI_SSWAP32(sgilabel->directory[i].vol_file_size);
|
|
unsigned char *name = sgilabel->directory[i].vol_file_name;
|
|
|
|
printf("%2u: %-10s sector%5u size%8u\n",
|
|
i, (char*)name, (unsigned int) start, (unsigned int) len);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
sgi_set_bootpartition(int i)
|
|
{
|
|
sgilabel->boot_part = SGI_SSWAP16(((short)i));
|
|
}
|
|
|
|
static unsigned int
|
|
sgi_get_lastblock(void)
|
|
{
|
|
return g_heads * g_sectors * g_cylinders;
|
|
}
|
|
|
|
static void
|
|
sgi_set_swappartition(int i)
|
|
{
|
|
sgilabel->swap_part = SGI_SSWAP16(((short)i));
|
|
}
|
|
|
|
static int
|
|
sgi_check_bootfile(const char* aFile)
|
|
{
|
|
if (strlen(aFile) < 3) /* "/a\n" is minimum */ {
|
|
printf("\nInvalid Bootfile!\n"
|
|
"\tThe bootfile must be an absolute non-zero pathname,\n"
|
|
"\te.g. \"/unix\" or \"/unix.save\".\n");
|
|
return 0;
|
|
}
|
|
if (strlen(aFile) > 16) {
|
|
printf("\nName of Bootfile too long (>16 bytes)\n");
|
|
return 0;
|
|
}
|
|
if (aFile[0] != '/') {
|
|
printf("\nBootfile must have a fully qualified pathname\n");
|
|
return 0;
|
|
}
|
|
if (strncmp(aFile, (char*)sgilabel->boot_file, 16)) {
|
|
printf("\nBe aware, that the bootfile is not checked for existence.\n"
|
|
"\tSGI's default is \"/unix\" and for backup \"/unix.save\".\n");
|
|
/* filename is correct and did change */
|
|
return 1;
|
|
}
|
|
return 0; /* filename did not change */
|
|
}
|
|
|
|
static const char *
|
|
sgi_get_bootfile(void)
|
|
{
|
|
return (char*)sgilabel->boot_file;
|
|
}
|
|
|
|
static void
|
|
sgi_set_bootfile(const char* aFile)
|
|
{
|
|
int i = 0;
|
|
|
|
if (sgi_check_bootfile(aFile)) {
|
|
while (i < 16) {
|
|
if ((aFile[i] != '\n') /* in principle caught again by next line */
|
|
&& (strlen(aFile) > i))
|
|
sgilabel->boot_file[i] = aFile[i];
|
|
else
|
|
sgilabel->boot_file[i] = 0;
|
|
i++;
|
|
}
|
|
printf("\n\tBootfile is changed to \"%s\"\n", sgilabel->boot_file);
|
|
}
|
|
}
|
|
|
|
static void
|
|
create_sgiinfo(void)
|
|
{
|
|
/* I keep SGI's habit to write the sgilabel to the second block */
|
|
sgilabel->directory[0].vol_file_start = SGI_SSWAP32(2);
|
|
sgilabel->directory[0].vol_file_size = SGI_SSWAP32(sizeof(sgiinfo));
|
|
strncpy((char*)sgilabel->directory[0].vol_file_name, "sgilabel", 8);
|
|
}
|
|
|
|
static sgiinfo *fill_sgiinfo(void);
|
|
|
|
static void
|
|
sgi_write_table(void)
|
|
{
|
|
sgilabel->csum = 0;
|
|
sgilabel->csum = SGI_SSWAP32(two_s_complement_32bit_sum(
|
|
(unsigned int*)sgilabel, sizeof(*sgilabel)));
|
|
assert(two_s_complement_32bit_sum(
|
|
(unsigned int*)sgilabel, sizeof(*sgilabel)) == 0);
|
|
|
|
write_sector(0, sgilabel);
|
|
if (!strncmp((char*)sgilabel->directory[0].vol_file_name, "sgilabel", 8)) {
|
|
/*
|
|
* keep this habit of first writing the "sgilabel".
|
|
* I never tested whether it works without (AN 981002).
|
|
*/
|
|
sgiinfo *info = fill_sgiinfo();
|
|
int infostartblock = SGI_SSWAP32(sgilabel->directory[0].vol_file_start);
|
|
write_sector(infostartblock, info);
|
|
free(info);
|
|
}
|
|
}
|
|
|
|
static int
|
|
compare_start(int *x, int *y)
|
|
{
|
|
/*
|
|
* sort according to start sectors
|
|
* and prefers largest partition:
|
|
* entry zero is entire disk entry
|
|
*/
|
|
unsigned int i = *x;
|
|
unsigned int j = *y;
|
|
unsigned int a = sgi_get_start_sector(i);
|
|
unsigned int b = sgi_get_start_sector(j);
|
|
unsigned int c = sgi_get_num_sectors(i);
|
|
unsigned int d = sgi_get_num_sectors(j);
|
|
|
|
if (a == b)
|
|
return (d > c) ? 1 : (d == c) ? 0 : -1;
|
|
return (a > b) ? 1 : -1;
|
|
}
|
|
|
|
|
|
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 %u\n",
|
|
sgi_get_start_sector(Index[0]));
|
|
if (SGI_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 %u diskblock large,\n"
|
|
"but the disk is %u 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 (SGI_DEBUG > 2)
|
|
printf("sysid=%u\tpartition=%u\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 (SGI_DEBUG) /* I do not understand how some disks fulfil it */
|
|
if (verbose)
|
|
printf("Partition %u does not start on cylinder boundary\n",
|
|
Index[i]+1);
|
|
}
|
|
if (sgi_get_num_sectors(Index[i]) % cylsize != 0) {
|
|
if (SGI_DEBUG) /* I do not understand how some disks fulfil it */
|
|
if (verbose)
|
|
printf("Partition %u 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 %u and %u overlap by %u 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 %u sectors - sectors %u-%u\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 (SGI_DEBUG > 1) {
|
|
if (verbose)
|
|
printf("%2u:%12u\t%12u\t%12u\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 %u sectors - sectors %u-%u\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_gaps(void)
|
|
{
|
|
/*
|
|
* returned value is:
|
|
* = 0 : disk is properly filled to the rim
|
|
* < 0 : there is an overlap
|
|
* > 0 : there is still some vacant space
|
|
*/
|
|
return verify_sgi(0);
|
|
}
|
|
|
|
static void
|
|
sgi_change_sysid(int i, int sys)
|
|
{
|
|
if (sgi_get_num_sectors(i) == 0) { /* caught already before, ... */
|
|
printf("Sorry you may change the Tag of non-empty partitions\n");
|
|
return;
|
|
}
|
|
if ((sys != SGI_ENTIRE_DISK) && (sys != SGI_VOLHDR)
|
|
&& (sgi_get_start_sector(i) < 1)
|
|
) {
|
|
read_maybe_empty(
|
|
"It is highly recommended that the partition at offset 0\n"
|
|
"is of type \"SGI volhdr\", the IRIX system will rely on it to\n"
|
|
"retrieve from its directory standalone tools like sash and fx.\n"
|
|
"Only the \"SGI volume\" entire disk section may violate this.\n"
|
|
"Type YES if you are sure about tagging this partition differently.\n");
|
|
if (strcmp(line_ptr, "YES\n") != 0)
|
|
return;
|
|
}
|
|
sgilabel->partitions[i].id = SGI_SSWAP32(sys);
|
|
}
|
|
|
|
/* returns partition index of first entry marked as entire disk */
|
|
static int
|
|
sgi_entire(void)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < 16; i++)
|
|
if (sgi_get_sysid(i) == SGI_VOLUME)
|
|
return i;
|
|
return -1;
|
|
}
|
|
|
|
static void
|
|
sgi_set_partition(int i, unsigned int start, unsigned int length, int sys)
|
|
{
|
|
sgilabel->partitions[i].id = SGI_SSWAP32(sys);
|
|
sgilabel->partitions[i].num_sectors = SGI_SSWAP32(length);
|
|
sgilabel->partitions[i].start_sector = SGI_SSWAP32(start);
|
|
set_changed(i);
|
|
if (sgi_gaps() < 0) /* rebuild freelist */
|
|
printf("Partition overlap detected\n");
|
|
}
|
|
|
|
static void
|
|
sgi_set_entire(void)
|
|
{
|
|
int n;
|
|
|
|
for (n = 10; n < g_partitions; n++) {
|
|
if (!sgi_get_num_sectors(n) ) {
|
|
sgi_set_partition(n, 0, sgi_get_lastblock(), SGI_VOLUME);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
sgi_set_volhdr(void)
|
|
{
|
|
int n;
|
|
|
|
for (n = 8; n < g_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 (g_heads * g_sectors * 5 < sgi_get_lastblock())
|
|
sgi_set_partition(n, 0, g_heads * g_sectors * 5, SGI_VOLHDR);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
sgi_delete_partition(int i)
|
|
{
|
|
sgi_set_partition(i, 0, 0, 0);
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
#if ENABLE_FEATURE_FDISK_ADVANCED
|
|
static void
|
|
create_sgilabel(void)
|
|
{
|
|
struct hd_geometry geometry;
|
|
struct {
|
|
unsigned int start;
|
|
unsigned int nsect;
|
|
int sysid;
|
|
} old[4];
|
|
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 */
|
|
|
|
printf(msg_building_new_label, "SGI disklabel");
|
|
|
|
sgi_other_endian = BB_LITTLE_ENDIAN;
|
|
res = ioctl(dev_fd, BLKGETSIZE, &longsectors);
|
|
if (!ioctl(dev_fd, HDIO_GETGEO, &geometry)) {
|
|
g_heads = geometry.heads;
|
|
g_sectors = geometry.sectors;
|
|
if (res == 0) {
|
|
/* the get device size ioctl was successful */
|
|
g_cylinders = longsectors / (g_heads * g_sectors);
|
|
g_cylinders /= sec_fac;
|
|
} else {
|
|
/* otherwise print error and use truncated version */
|
|
g_cylinders = geometry.cylinders;
|
|
printf(
|
|
"Warning: BLKGETSIZE ioctl failed on %s. Using geometry cylinder value of %u.\n"
|
|
"This value may be truncated for devices > 33.8 GB.\n", disk_device, g_cylinders);
|
|
}
|
|
}
|
|
for (i = 0; i < 4; i++) {
|
|
old[i].sysid = 0;
|
|
if (valid_part_table_flag(MBRbuffer)) {
|
|
if (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].nsect = get_nr_sects(get_part_table(i));
|
|
printf("Trying to keep parameters of partition %u\n", i);
|
|
if (SGI_DEBUG)
|
|
printf("ID=%02x\tSTART=%u\tLENGTH=%u\n",
|
|
old[i].sysid, old[i].start, old[i].nsect);
|
|
}
|
|
}
|
|
}
|
|
|
|
memset(MBRbuffer, 0, sizeof(MBRbuffer));
|
|
/* fields with '//' are already zeroed out by memset above */
|
|
|
|
sgilabel->magic = SGI_SSWAP32(SGI_LABEL_MAGIC);
|
|
//sgilabel->boot_part = SGI_SSWAP16(0);
|
|
sgilabel->swap_part = SGI_SSWAP16(1);
|
|
|
|
//memset(sgilabel->boot_file, 0, 16);
|
|
strcpy((char*)sgilabel->boot_file, "/unix"); /* sizeof(sgilabel->boot_file) == 16 > 6 */
|
|
|
|
//sgilabel->devparam.skew = (0);
|
|
//sgilabel->devparam.gap1 = (0);
|
|
//sgilabel->devparam.gap2 = (0);
|
|
//sgilabel->devparam.sparecyl = (0);
|
|
sgilabel->devparam.pcylcount = SGI_SSWAP16(geometry.cylinders);
|
|
//sgilabel->devparam.head_vol0 = SGI_SSWAP16(0);
|
|
/* tracks/cylinder (heads) */
|
|
sgilabel->devparam.ntrks = SGI_SSWAP16(geometry.heads);
|
|
//sgilabel->devparam.cmd_tag_queue_depth = (0);
|
|
//sgilabel->devparam.unused0 = (0);
|
|
//sgilabel->devparam.unused1 = SGI_SSWAP16(0);
|
|
/* sectors/track */
|
|
sgilabel->devparam.nsect = SGI_SSWAP16(geometry.sectors);
|
|
sgilabel->devparam.bytes = SGI_SSWAP16(512);
|
|
sgilabel->devparam.ilfact = SGI_SSWAP16(1);
|
|
sgilabel->devparam.flags = SGI_SSWAP32(TRACK_FWD|
|
|
IGNORE_ERRORS|RESEEK);
|
|
//sgilabel->devparam.datarate = SGI_SSWAP32(0);
|
|
sgilabel->devparam.retries_on_error = SGI_SSWAP32(1);
|
|
//sgilabel->devparam.ms_per_word = SGI_SSWAP32(0);
|
|
//sgilabel->devparam.xylogics_gap1 = SGI_SSWAP16(0);
|
|
//sgilabel->devparam.xylogics_syncdelay = SGI_SSWAP16(0);
|
|
//sgilabel->devparam.xylogics_readdelay = SGI_SSWAP16(0);
|
|
//sgilabel->devparam.xylogics_gap2 = SGI_SSWAP16(0);
|
|
//sgilabel->devparam.xylogics_readgate = SGI_SSWAP16(0);
|
|
//sgilabel->devparam.xylogics_writecont = SGI_SSWAP16(0);
|
|
//memset( &(sgilabel->directory), 0, sizeof(struct volume_directory)*15 );
|
|
//memset( &(sgilabel->partitions), 0, sizeof(struct sgi_partinfo)*16 );
|
|
current_label_type = LABEL_SGI;
|
|
g_partitions = 16;
|
|
sgi_volumes = 15;
|
|
sgi_set_entire();
|
|
sgi_set_volhdr();
|
|
for (i = 0; i < 4; i++) {
|
|
if (old[i].sysid) {
|
|
sgi_set_partition(i, old[i].start, old[i].nsect, old[i].sysid);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
sgi_set_xcyl(void)
|
|
{
|
|
/* do nothing in the beginning */
|
|
}
|
|
#endif /* FEATURE_FDISK_ADVANCED */
|
|
|
|
/* _____________________________________________________________
|
|
*/
|
|
|
|
static sgiinfo *
|
|
fill_sgiinfo(void)
|
|
{
|
|
sgiinfo *info = xzalloc(sizeof(sgiinfo));
|
|
|
|
info->magic = SGI_SSWAP32(SGI_INFO_MAGIC);
|
|
info->b1 = SGI_SSWAP32(-1);
|
|
info->b2 = SGI_SSWAP16(-1);
|
|
info->b3 = SGI_SSWAP16(1);
|
|
/* You may want to replace this string !!!!!!! */
|
|
strcpy( (char*)info->scsi_string, "IBM OEM 0662S12 3 30" );
|
|
strcpy( (char*)info->serial, "0000" );
|
|
info->check1816 = SGI_SSWAP16(18*256 +16 );
|
|
strcpy( (char*)info->installer, "Sfx version 5.3, Oct 18, 1994" );
|
|
return info;
|
|
}
|
|
#endif /* SGI_LABEL */
|