e1aeba03f
Denys Vlasenko
2026-09-27
Subject
fdisk: remove SUN and SGI labels support - obsolete (20+ years)
Binary
No binary (build failed)
Architecture & Compiler Flags
—
Build Log
(log yok)
Commit Diff GitHub →
util-linux/fdisk.c+75 -377
| @@ -44,23 +44,6 @@ | |
| //config: Enabling this option allows you to create or change AIX disklabels. | |
| //config: Most people can safely leave this option disabled. | |
| //config: | |
| - | //config:config FEATURE_SGI_LABEL |
| - | //config: bool "Support SGI disklabels" |
| - | //config: default n |
| - | //config: depends on FDISK && FEATURE_FDISK_WRITABLE |
| - | //config: help |
| - | //config: Enabling this option allows you to create or change SGI disklabels. |
| - | //config: Most people can safely leave this option disabled. |
| - | //config: |
| - | //config:config FEATURE_SUN_LABEL |
| - | //config: bool "Support SUN disklabels" |
| - | //config: default n |
| - | //config: depends on FDISK && FEATURE_FDISK_WRITABLE |
| - | //config: help |
| - | //config: Enabling this option allows you to create or change SUN disklabels. |
| - | //config: Most people can safely leave this option disabled. |
| - | //config: |
| - | //TODO: retain only support for GPT and maybe OSF (BSD), the rest is dead for 20+ years. |
| //config:config FEATURE_OSF_LABEL | |
| //config: bool "Support BSD disklabels" | |
| //config: default n | |
| @@ -68,6 +51,7 @@ | |
| //config: help | |
| //config: Enabling this option allows you to create or change BSD disklabels | |
| //config: and define and edit BSD disk slices. | |
| + | //config: Most people can safely leave this option disabled. |
| //config: | |
| //config:config FEATURE_GPT_LABEL | |
| //config: bool "Support GPT disklabels" | |
| @@ -95,16 +79,16 @@ | |
| //usage: "[-ul" IF_FEATURE_FDISK_BLKSIZE("s") "] " | |
| //usage: "[-C CYLINDERS] [-H HEADS] [-S SECTORS] [-b SSZ] [-t PARTTYPE] DISK" | |
| //usage:#define fdisk_full_usage "\n\n" | |
| - | //usage: "Change partition table\n" |
| + | //usage: IF_FEATURE_FDISK_WRITABLE("Change")IF_NOT_FEATURE_FDISK_WRITABLE("Show")" partition table\n" |
| //usage: "\n -u Start and End are in sectors (instead of cylinders)" | |
| - | //usage: "\n -l Show partition table for each DISK, then exit" |
| + | //usage: "\n -l Show partition table for each DISK and exit" |
| //usage: IF_FEATURE_FDISK_BLKSIZE( | |
| - | //usage: "\n -s Show sizes in kb for each DISK, then exit" |
| + | //usage: "\n -s Show size in kb for each DISK and exit" |
| //NB: util-linux 2.41.1 says: "-s,--getsz: display device size in 512-byte sectors" | |
| //but in fact, util-linux 2.41.1 shows the size in KILOBYTES! | |
| //usage: ) | |
| //usage: "\n -b 2048 (for certain MO disks) use 2048-byte sectors" | |
| - | //usage: "\n -T PARTTYPE Force 'dos' partition if 'gpt' also present" |
| + | //usage: "\n -t PARTTYPE Force 'dos' partition if 'gpt' also present" |
| //usage: "\n -C CYLINDERS Set number of cylinders/heads/sectors" | |
| //usage: "\n -H HEADS Typically 255" | |
| //usage: "\n -S SECTORS Typically 63" | |
| @@ -197,9 +181,7 @@ enum { | |
| /* TODO: just #if ENABLE_FEATURE_FDISK_WRITABLE */ | |
| /* (currently fdisk_sun/sgi.c do not have proper WRITABLE #ifs) */ | |
| - | #if ENABLE_FEATURE_FDISK_WRITABLE \ |
| - | || ENABLE_FEATURE_SGI_LABEL \ |
| - | || ENABLE_FEATURE_SUN_LABEL |
| + | #if ENABLE_FEATURE_FDISK_WRITABLE |
| static const char msg_building_new_label[] ALIGN1 = | |
| "Building a new %s. Changes will remain in memory only,\n" | |
| "until you decide to write them. After that the previous content\n" | |
| @@ -211,7 +193,6 @@ static const char msg_part_already_defined[] ALIGN1 = | |
| #define SUPPORT_DISKLABELS (0 \ | |
| | ENABLE_FEATURE_AIX_LABEL \ | |
| - | | ENABLE_FEATURE_SGI_LABEL \ |
| | ENABLE_FEATURE_OSF_LABEL \ | |
| | ENABLE_FEATURE_GPT_LABEL \ | |
| ) | |
| @@ -252,27 +233,11 @@ struct pte { | |
| #define unable_to_seek "can't seek '%s'" | |
| enum label_type { | |
| - | LABEL_DOS, LABEL_SUN, LABEL_SGI, LABEL_AIX, LABEL_OSF, LABEL_GPT |
| + | LABEL_DOS, LABEL_AIX, LABEL_OSF, LABEL_GPT |
| }; | |
| #define LABEL_IS_DOS (LABEL_DOS == current_label_type) | |
| - | #if ENABLE_FEATURE_SUN_LABEL |
| - | #define LABEL_IS_SUN (LABEL_SUN == current_label_type) |
| - | #define STATIC_SUN static |
| - | #else |
| - | #define LABEL_IS_SUN 0 |
| - | #define STATIC_SUN extern |
| - | #endif |
| - | |
| - | #if ENABLE_FEATURE_SGI_LABEL |
| - | #define LABEL_IS_SGI (LABEL_SGI == current_label_type) |
| - | #define STATIC_SGI static |
| - | #else |
| - | #define LABEL_IS_SGI 0 |
| - | #define STATIC_SGI extern |
| - | #endif |
| - | |
| #if ENABLE_FEATURE_AIX_LABEL | |
| #define LABEL_IS_AIX (LABEL_AIX == current_label_type) | |
| #define STATIC_AIX static | |
| @@ -297,7 +262,7 @@ enum label_type { | |
| #define STATIC_GPT extern | |
| #endif | |
| - | enum action { OPEN_MAIN, TRY_ONLY, CREATE_EMPTY_DOS, CREATE_EMPTY_SUN }; |
| + | enum action { OPEN_MAIN, TRY_ONLY, CREATE_EMPTY_DOS }; |
| static void update_units(void); | |
| #if ENABLE_FEATURE_FDISK_WRITABLE | |
| @@ -311,7 +276,7 @@ static sector_t read_int(sector_t low, sector_t dflt, sector_t high, sector_t ba | |
| static const char *partition_type(unsigned char type); | |
| static void get_geometry(void); | |
| static void read_pte(struct pte *pe, sector_t offset); | |
| - | #if ENABLE_FEATURE_SUN_LABEL || ENABLE_FEATURE_FDISK_WRITABLE |
| + | #if ENABLE_FEATURE_FDISK_WRITABLE |
| static int get_boot(enum action what); | |
| #else | |
| static int get_boot(void); | |
| @@ -448,11 +413,6 @@ struct globals { | |
| #endif | |
| smallint dos_compatible_flag; // = 1; | |
| - | #if ENABLE_FEATURE_SUN_LABEL |
| - | smallint sun_other_endian; |
| - | smallint sun_scsi_disk; |
| - | smallint sun_floppy; |
| - | #endif |
| #if ENABLE_FEATURE_OSF_LABEL | |
| # if !defined(__alpha__) | |
| struct partition *xbsd_part; | |
| @@ -646,7 +606,7 @@ partname(const char *dev, int pno, int lth) | |
| return bufp; | |
| } | |
| - | #if ENABLE_FEATURE_SGI_LABEL || ENABLE_FEATURE_OSF_LABEL |
| + | #if ENABLE_FEATURE_OSF_LABEL |
| static ALWAYS_INLINE struct partition * | |
| get_part_table(int i) | |
| { | |
| @@ -818,61 +778,6 @@ STATIC_OSF void xbsd_print_disklabel(int); | |
| STATIC_GPT void gpt_list_table(int xtra); | |
| #include "fdisk_gpt.c" | |
| - | #if ENABLE_FEATURE_SGI_LABEL || ENABLE_FEATURE_SUN_LABEL |
| - | static uint16_t |
| - | fdisk_swap16(uint16_t x) |
| - | { |
| - | return (x << 8) | (x >> 8); |
| - | } |
| - | |
| - | static uint32_t |
| - | fdisk_swap32(uint32_t x) |
| - | { |
| - | return (x << 24) | |
| - | ((x & 0xFF00) << 8) | |
| - | ((x & 0xFF0000) >> 8) | |
| - | (x >> 24); |
| - | } |
| - | #endif |
| - | |
| - | STATIC_SGI const char *const sgi_sys_types[]; |
| - | STATIC_SGI unsigned sgi_get_num_sectors(int i); |
| - | STATIC_SGI int sgi_get_sysid(int i); |
| - | STATIC_SGI void sgi_delete_partition(int i); |
| - | STATIC_SGI void sgi_change_sysid(int i, int sys); |
| - | STATIC_SGI void sgi_list_table(int xtra); |
| - | #if ENABLE_FEATURE_FDISK_ADVANCED |
| - | STATIC_SGI void sgi_set_xcyl(void); |
| - | #endif |
| - | STATIC_SGI int verify_sgi(int verbose); |
| - | STATIC_SGI void sgi_add_partition(int n, int sys); |
| - | STATIC_SGI void sgi_set_swappartition(int i); |
| - | STATIC_SGI const char *sgi_get_bootfile(void); |
| - | STATIC_SGI void sgi_set_bootfile(const char* aFile); |
| - | STATIC_SGI void create_sgiinfo(void); |
| - | STATIC_SGI void sgi_write_table(void); |
| - | STATIC_SGI void sgi_set_bootpartition(int i); |
| - | #include "fdisk_sgi.c" |
| - | |
| - | STATIC_SUN const char *const sun_sys_types[]; |
| - | STATIC_SUN void sun_delete_partition(int i); |
| - | STATIC_SUN void sun_change_sysid(int i, int sys); |
| - | STATIC_SUN void sun_list_table(int xtra); |
| - | STATIC_SUN void add_sun_partition(int n, int sys); |
| - | #if ENABLE_FEATURE_FDISK_ADVANCED |
| - | STATIC_SUN void sun_set_alt_cyl(void); |
| - | STATIC_SUN void sun_set_ncyl(int cyl); |
| - | STATIC_SUN void sun_set_xcyl(void); |
| - | STATIC_SUN void sun_set_ilfact(void); |
| - | STATIC_SUN void sun_set_rspeed(void); |
| - | STATIC_SUN void sun_set_pcylcount(void); |
| - | #endif |
| - | STATIC_SUN void toggle_sunflags(int i, unsigned char mask); |
| - | STATIC_SUN void verify_sun(void); |
| - | STATIC_SUN void sun_write_table(void); |
| - | #include "fdisk_sun.c" |
| - | |
| - | |
| static inline_if_little_endian unsigned | |
| read4_little_endian(const unsigned char *cp) | |
| { | |
| @@ -943,40 +848,7 @@ static void | |
| menu(void) | |
| { | |
| puts("Command Action"); | |
| - | if (LABEL_IS_SUN) { |
| - | puts("a\ttoggle a read only flag"); /* sun */ |
| - | puts("b\tedit bsd disklabel"); |
| - | puts("c\ttoggle the mountable flag"); /* sun */ |
| - | puts("d\tdelete a partition"); |
| - | puts("l\tlist known partition types"); |
| - | puts("n\tadd a new partition"); |
| - | puts("o\tcreate a new empty DOS partition table"); |
| - | puts("p\tprint the partition table"); |
| - | puts("q\tquit without saving changes"); |
| - | puts("s\tcreate a new empty Sun disklabel"); /* sun */ |
| - | puts("t\tchange a partition's system id"); |
| - | puts("u\tchange display/entry units"); |
| - | puts("v\tverify the partition table"); |
| - | puts("w\twrite table to disk and exit"); |
| - | #if ENABLE_FEATURE_FDISK_ADVANCED |
| - | puts("x\textra functionality (experts only)"); |
| - | #endif |
| - | } else if (LABEL_IS_SGI) { |
| - | puts("a\tselect bootable partition"); /* sgi flavour */ |
| - | puts("b\tedit bootfile entry"); /* sgi */ |
| - | puts("c\tselect sgi swap partition"); /* sgi flavour */ |
| - | puts("d\tdelete a partition"); |
| - | puts("l\tlist known partition types"); |
| - | puts("n\tadd a new partition"); |
| - | puts("o\tcreate a new empty DOS partition table"); |
| - | puts("p\tprint the partition table"); |
| - | puts("q\tquit without saving changes"); |
| - | puts("s\tcreate a new empty Sun disklabel"); /* sun */ |
| - | puts("t\tchange a partition's system id"); |
| - | puts("u\tchange display/entry units"); |
| - | puts("v\tverify the partition table"); |
| - | puts("w\twrite table to disk and exit"); |
| - | } else if (LABEL_IS_AIX) { |
| + | if (LABEL_IS_AIX) { |
| puts("o\tcreate a new empty DOS partition table"); | |
| puts("q\tquit without saving changes"); | |
| puts("s\tcreate a new empty Sun disklabel"); /* sun */ | |
| @@ -1015,29 +887,13 @@ xmenu(void) | |
| puts("c\tchange number of cylinders"); | |
| puts("h\tchange number of heads"); | |
| puts("s\tchange number of sectors/track"); | |
| - | if (LABEL_IS_SUN) { |
| - | puts("a\tchange number of alternate cylinders"); /*sun*/ |
| - | puts("y\tchange number of physical cylinders"); /*sun*/ |
| - | puts("e\tchange number of extra sectors per cylinder");/*sun*/ |
| - | puts("i\tchange interleave factor"); /*sun*/ |
| - | puts("o\tchange rotation speed (rpm)"); /*sun*/ |
| - | } else if (LABEL_IS_SGI) { |
| - | puts("b\tmove beginning of data in a partition"); /* !sun */ |
| - | puts("g\tcreate an IRIX (SGI) partition table");/* sgi */ |
| - | puts("e\tlist extended partitions"); /* !sun */ |
| - | } else if (LABEL_IS_AIX) { |
| - | puts("b\tmove beginning of data in a partition"); /* !sun */ |
| - | # if ENABLE_FEATURE_SGI_LABEL |
| - | puts("g\tcreate an IRIX (SGI) partition table"); |
| - | # endif |
| - | puts("e\tlist extended partitions"); /* !sun */ |
| + | if (LABEL_IS_AIX) { |
| + | puts("b\tmove beginning of data in a partition"); |
| + | puts("e\tlist extended partitions"); |
| } else { | |
| - | puts("f\tfix partition order"); /* !sun, !aix, !sgi */ |
| - | puts("b\tmove beginning of data in a partition"); /* !sun */ |
| - | # if ENABLE_FEATURE_SGI_LABEL |
| - | puts("g\tcreate an IRIX (SGI) partition table"); |
| - | # endif |
| - | puts("e\tlist extended partitions"); /* !sun */ |
| + | puts("f\tfix partition order"); /* !aix */ |
| + | puts("b\tmove beginning of data in a partition"); |
| + | puts("e\tlist extended partitions"); |
| } | |
| puts("d\tprint the raw data in the partition table"); | |
| puts("p\tprint the partition table"); | |
| @@ -1052,10 +908,7 @@ xmenu(void) | |
| static const char *const * | |
| get_sys_types(void) | |
| { | |
| - | return ( |
| - | LABEL_IS_SUN ? sun_sys_types : |
| - | LABEL_IS_SGI ? sgi_sys_types : |
| - | i386_sys_types); |
| + | return i386_sys_types; |
| } | |
| #else | |
| #define get_sys_types() i386_sys_types | |
| @@ -1097,9 +950,7 @@ clear_partition(struct partition *p) | |
| static int | |
| get_sysid(int i) | |
| { | |
| - | return LABEL_IS_SUN ? sunlabel->infos[i].id : |
| - | (LABEL_IS_SGI ? sgi_get_sysid(i) : |
| - | ptes[i].part_table->sys_ind); |
| + | return ptes[i].part_table->sys_ind; |
| } | |
| static void | |
| @@ -1402,9 +1253,7 @@ static void | |
| get_geometry(void) | |
| { | |
| get_sectorsize(); | |
| - | #if ENABLE_FEATURE_SUN_LABEL |
| - | sun_guess_device_type(); |
| - | #endif |
| + | |
| g_heads = g_cylinders = g_sectors = 0; | |
| kern_heads = kern_sectors = 0; | |
| pt_heads = pt_sectors = 0; | |
| @@ -1449,7 +1298,7 @@ get_geometry(void) | |
| * 0: found or created label | |
| * 1: I/O error | |
| */ | |
| - | #if ENABLE_FEATURE_SUN_LABEL || ENABLE_FEATURE_FDISK_WRITABLE |
| + | #if ENABLE_FEATURE_FDISK_WRITABLE |
| static int get_boot(enum action what) | |
| #else | |
| static int get_boot(void) | |
| @@ -1474,10 +1323,9 @@ static int get_boot(void) | |
| // ALERT! highly idiotic design! | |
| // We end up here when we call get_boot() recursively | |
| // via get_boot() [table is bad] -> create_doslabel() -> get_boot(CREATE_EMPTY_DOS). | |
| - | // or get_boot() [table is bad] -> create_sunlabel() -> get_boot(CREATE_EMPTY_SUN). |
| // (just factor out re-init of ptes[0,1,2,3] in a separate fn instead?) | |
| // So skip opening device _again_... | |
| - | if (what == CREATE_EMPTY_DOS IF_FEATURE_SUN_LABEL(|| what == CREATE_EMPTY_SUN)) |
| + | if (what == CREATE_EMPTY_DOS) |
| goto created_table; | |
| fd = open(disk_device, (option_mask32 & OPT_l) ? O_RDONLY : O_RDWR); | |
| @@ -1513,14 +1361,6 @@ static int get_boot(void) | |
| get_geometry(); | |
| update_units(); | |
| - | #if ENABLE_FEATURE_SUN_LABEL |
| - | if (check_sun_label()) |
| - | return 0; |
| - | #endif |
| - | #if ENABLE_FEATURE_SGI_LABEL |
| - | if (check_sgi_label()) |
| - | return 0; |
| - | #endif |
| #if ENABLE_FEATURE_AIX_LABEL | |
| if (check_aix_label()) | |
| return 0; | |
| @@ -1547,22 +1387,15 @@ static int get_boot(void) | |
| #else | |
| if (!valid_part_table_flag(MBRbuffer)) { | |
| if (what == OPEN_MAIN) { | |
| - | puts("Device has no valid DOS partition table" |
| + | puts("Device has no valid DOS" |
| #if SUPPORT_DISKLABELS | |
| - | ", nor " |
| - | IF_FEATURE_SUN_LABEL("Sun, ") |
| - | IF_FEATURE_SGI_LABEL("SGI, ") |
| - | IF_FEATURE_OSF_LABEL("OSF, ") |
| - | IF_FEATURE_AIX_LABEL("AIX, ") |
| - | IF_FEATURE_GPT_LABEL("GPT ") |
| - | "disklabel." |
| - | #else |
| - | "." |
| + | IF_FEATURE_OSF_LABEL(", OSF") |
| + | IF_FEATURE_AIX_LABEL(", AIX") |
| + | IF_FEATURE_GPT_LABEL(", GPT") |
| #endif | |
| + | " partition table." |
| ); | |
| - | #ifdef __sparc__ |
| - | IF_FEATURE_SUN_LABEL(create_sunlabel();) |
| - | #else |
| + | #ifndef __sparc__ |
| create_doslabel(); | |
| #endif | |
| return 0; | |
| @@ -1728,11 +1561,8 @@ get_partition(int warn, unsigned max) | |
| pe = &ptes[i]; | |
| if (warn) { | |
| - | if ((!LABEL_IS_SUN && !LABEL_IS_SGI && !pe->part_table->sys_ind) |
| - | || (LABEL_IS_SUN && (!sunlabel->partitions[i].num_sectors || !sunlabel->infos[i].id)) |
| - | || (LABEL_IS_SGI && !sgi_get_num_sectors(i)) |
| - | ) { |
| - | printf("Warning: partition %u has empty type\n", i+1); |
| + | if (pe->part_table->sys_ind == 0) { |
| + | printf("Warning: partition %u has type 0\n", i+1); |
| } | |
| } | |
| return i; | |
| @@ -1843,15 +1673,6 @@ delete_partition(int i) | |
| return; /* C/H/S not set */ | |
| pe->changed = 1; | |
| - | if (LABEL_IS_SUN) { |
| - | sun_delete_partition(i); |
| - | return; |
| - | } |
| - | if (LABEL_IS_SGI) { |
| - | sgi_delete_partition(i); |
| - | return; |
| - | } |
| - | |
| if (i < 4) { | |
| if (IS_EXTENDED(p->sys_ind) && i == ext_index) { | |
| g_partitions = 4; | |
| @@ -1908,14 +1729,7 @@ change_sysid(void) | |
| int i, sys, origsys; | |
| struct partition *p; | |
| - | /* 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 (!LABEL_IS_SGI) { |
| - | i = get_existing_partition(0, g_partitions); |
| - | } else { |
| - | i = get_partition(0, g_partitions); |
| - | } |
| + | i = get_existing_partition(0, g_partitions); |
| if (i == -1) | |
| return; | |
| p = ptes[i].part_table; | |
| @@ -1923,57 +1737,30 @@ change_sysid(void) | |
| /* if changing types T to 0 is allowed, then | |
| the reverse change must be allowed, too */ | |
| - | if (!sys && !LABEL_IS_SGI && !LABEL_IS_SUN && !get_nr_sects(p)) { |
| - | printf("Partition %u does not exist yet!\n", i + 1); |
| + | if (sys == 0 && !get_nr_sects(p)) { |
| + | printf("Partition %u does not exist yet\n", i + 1); |
| return; | |
| } | |
| while (1) { | |
| sys = read_hex(get_sys_types()); | |
| - | if (!sys && !LABEL_IS_SGI && !LABEL_IS_SUN) { |
| + | if (sys == 0) { |
| puts("Type 0 means free space to many systems\n" | |
| "(but not to Linux). Having partitions of\n" | |
| - | "type 0 is probably unwise."); |
| + | "type 0 is unwise."); |
| /* break; */ | |
| } | |
| - | if (!LABEL_IS_SUN && !LABEL_IS_SGI) { |
| - | if (IS_EXTENDED(sys) != IS_EXTENDED(p->sys_ind)) { |
| - | puts("You cannot change a partition into" |
| - | " an extended one or vice versa"); |
| - | break; |
| - | } |
| + | if (IS_EXTENDED(sys) != IS_EXTENDED(p->sys_ind)) { |
| + | puts("You cannot change a partition into" |
| + | " an extended one or vice versa"); |
| + | break; |
| } | |
| if (sys < 256) { | |
| - | #if ENABLE_FEATURE_SUN_LABEL |
| - | if (LABEL_IS_SUN && i == 2 && sys != SUN_WHOLE_DISK) |
| - | puts("Consider leaving partition 3 " |
| - | "as Whole disk (5),\n" |
| - | "as SunOS/Solaris expects it and " |
| - | "even Linux likes it\n"); |
| - | #endif |
| - | #if ENABLE_FEATURE_SGI_LABEL |
| - | if (LABEL_IS_SGI && |
| - | ( |
| - | (i == 10 && sys != SGI_ENTIRE_DISK) || |
| - | (i == 8 && sys != 0) |
| - | ) |
| - | ) { |
| - | puts("Consider leaving partition 9 " |
| - | "as volume header (0),\nand " |
| - | "partition 11 as entire volume (6)" |
| - | "as IRIX expects it\n"); |
| - | } |
| - | #endif |
| if (sys == origsys) | |
| break; | |
| - | if (LABEL_IS_SUN) { |
| - | sun_change_sysid(i, sys); |
| - | } else if (LABEL_IS_SGI) { |
| - | sgi_change_sysid(i, sys); |
| - | } else |
| - | p->sys_ind = sys; |
| + | p->sys_ind = sys; |
| printf("Changed system type of partition %u " | |
| "to %x (%s)\n", i + 1, sys, | |
| @@ -2233,14 +2020,6 @@ list_table(int xtra) | |
| { | |
| int i, w; | |
| - | if (LABEL_IS_SUN) { |
| - | sun_list_table(xtra); |
| - | return; |
| - | } |
| - | if (LABEL_IS_SGI) { |
| - | sgi_list_table(xtra); |
| - | return; |
| - | } |
| if (LABEL_IS_GPT) { | |
| gpt_list_table(xtra); | |
| return; | |
| @@ -2412,15 +2191,6 @@ verify(void) | |
| if (warn_geometry()) | |
| return; | |
| - | if (LABEL_IS_SUN) { |
| - | verify_sun(); |
| - | return; |
| - | } |
| - | if (LABEL_IS_SGI) { |
| - | verify_sgi(1); |
| - | return; |
| - | } |
| - | |
| fill_bounds(first, last); | |
| for (i = 0; i < g_partitions; i++) { | |
| struct pte *pe = &ptes[i]; | |
| @@ -2630,14 +2400,6 @@ new_partition(void) | |
| if (warn_geometry()) | |
| return; | |
| - | if (LABEL_IS_SUN) { |
| - | add_sun_partition(get_partition(0, g_partitions), LINUX_NATIVE); |
| - | return; |
| - | } |
| - | if (LABEL_IS_SGI) { |
| - | sgi_add_partition(get_partition(0, g_partitions), LINUX_NATIVE); |
| - | return; |
| - | } |
| if (LABEL_IS_AIX) { | |
| puts("Sorry - this fdisk cannot handle AIX disk labels.\n" | |
| "If you want to add DOS-type partitions, create a new empty DOS partition\n" | |
| @@ -2738,18 +2500,6 @@ write_table(void) | |
| } | |
| } | |
| } | |
| - | else if (LABEL_IS_SGI) { |
| - | /* no test on change? the "altered" msg below might be mistaken */ |
| - | sgi_write_table(); |
| - | } |
| - | else if (LABEL_IS_SUN) { |
| - | for (i = 0; i < 8; i++) { |
| - | if (ptes[i].changed) { |
| - | sun_write_table(); |
| - | break; |
| - | } |
| - | } |
| - | } |
| puts("The partition table has been altered."); | |
| reread_partition_table(1); | |
| @@ -2783,12 +2533,8 @@ print_raw(void) | |
| int i; | |
| printf("Device: %s\n", disk_device); | |
| - | if (LABEL_IS_SGI || LABEL_IS_SUN) |
| - | print_buffer(MBRbuffer); |
| - | else { |
| - | for (i = 3; i < g_partitions; i++) |
| - | print_buffer(ptes[i].sectorbuffer); |
| - | } |
| + | for (i = 3; i < g_partitions; i++) |
| + | print_buffer(ptes[i].sectorbuffer); |
| } | |
| static void | |
| @@ -2828,10 +2574,10 @@ xselect(void) | |
| bb_putchar('\n'); | |
| c = 0x20 | read_nonempty("Expert command (m for help): "); | |
| switch (c) { | |
| - | case 'a': |
| - | if (LABEL_IS_SUN) |
| - | sun_set_alt_cyl(); |
| - | break; |
| + | //deleted: |
| + | //case 'a': |
| + | // if (LABEL_IS_SUN) sun_set_alt_cyl(); |
| + | // break; |
| case 'b': | |
| if (LABEL_IS_DOS) | |
| move_begin(get_partition(0, g_partitions)); | |
| @@ -2840,8 +2586,6 @@ xselect(void) | |
| user_cylinders = g_cylinders = | |
| read_int(1, g_cylinders, 1048576, 0, | |
| "Number of cylinders"); | |
| - | if (LABEL_IS_SUN) |
| - | sun_set_ncyl(g_cylinders); |
| if (LABEL_IS_DOS) | |
| warn_cylinders(); | |
| break; | |
| @@ -2849,39 +2593,30 @@ xselect(void) | |
| print_raw(); | |
| break; | |
| case 'e': | |
| - | if (LABEL_IS_SGI) |
| - | sgi_set_xcyl(); |
| - | else if (LABEL_IS_SUN) |
| - | sun_set_xcyl(); |
| - | else if (LABEL_IS_DOS) |
| + | if (LABEL_IS_DOS) |
| x_list_table(1); | |
| break; | |
| case 'f': | |
| if (LABEL_IS_DOS) | |
| fix_partition_table_order(); | |
| break; | |
| - | case 'g': |
| - | #if ENABLE_FEATURE_SGI_LABEL |
| - | create_sgilabel(); |
| - | #endif |
| - | break; |
| + | //SGI_LABEL code deleted: |
| + | //case 'g': |
| + | // create_sgilabel(); |
| + | // break; |
| case 'h': | |
| user_heads = g_heads = read_int(1, g_heads, 256, 0, "Number of heads"); | |
| update_units(); | |
| break; | |
| - | case 'i': |
| - | if (LABEL_IS_SUN) |
| - | sun_set_ilfact(); |
| - | break; |
| - | case 'o': |
| - | if (LABEL_IS_SUN) |
| - | sun_set_rspeed(); |
| - | break; |
| + | //deleted: |
| + | //case 'i': |
| + | // if (LABEL_IS_SUN) sun_set_ilfact(); |
| + | // break; |
| + | //case 'o': |
| + | // if (LABEL_IS_SUN) sun_set_rspeed(); |
| + | // break; |
| case 'p': | |
| - | if (LABEL_IS_SUN) |
| - | list_table(1); |
| - | else |
| - | x_list_table(0); |
| + | x_list_table(0); |
| break; | |
| case 'q': | |
| if (ENABLE_FEATURE_CLEAN_UP) | |
| @@ -2905,10 +2640,10 @@ xselect(void) | |
| case 'w': | |
| write_table(); /* does not return */ | |
| break; | |
| - | case 'y': |
| - | if (LABEL_IS_SUN) |
| - | sun_set_pcylcount(); |
| - | break; |
| + | //deleted: |
| + | //case 'y': |
| + | // if (LABEL_IS_SUN) sun_set_pcylcount(); |
| + | // break; |
| default: | |
| xmenu(); | |
| } | |
| @@ -2987,7 +2722,7 @@ open_list_and_close(const char *device, int user_specified) | |
| } else { | |
| list_table(0); | |
| #if ENABLE_FEATURE_FDISK_WRITABLE | |
| - | if (!LABEL_IS_SUN && g_partitions > 4) { |
| + | if (g_partitions > 4) { |
| delete_partition(ext_index); | |
| } | |
| #endif | |
| @@ -3161,63 +2896,31 @@ int fdisk_main(int argc UNUSED_PARAM, char **argv) | |
| case 'a': | |
| if (LABEL_IS_DOS) | |
| toggle_active(get_partition(1, g_partitions)); | |
| - | else if (LABEL_IS_SUN) |
| - | toggle_sunflags(get_partition(1, g_partitions), |
| - | 0x01); |
| - | else if (LABEL_IS_SGI) |
| - | sgi_set_bootpartition( |
| - | get_partition(1, g_partitions)); |
| else | |
| unknown_command(c); | |
| break; | |
| case 'b': | |
| - | if (LABEL_IS_SGI) { |
| - | printf("\nThe current boot file is: %s\n", |
| - | sgi_get_bootfile()); |
| - | if (read_maybe_empty("Please enter the name of the " |
| - | "new boot file: ") == '\n') |
| - | puts("Boot file unchanged"); |
| - | else |
| - | sgi_set_bootfile(line_ptr); |
| - | } |
| # if ENABLE_FEATURE_OSF_LABEL | |
| - | else |
| - | bsd_select(); |
| + | bsd_select(); |
| # endif | |
| break; | |
| case 'c': | |
| if (LABEL_IS_DOS) | |
| toggle_dos_compatibility_flag(); | |
| - | else if (LABEL_IS_SUN) |
| - | toggle_sunflags(get_partition(1, g_partitions), |
| - | 0x10); |
| - | else if (LABEL_IS_SGI) |
| - | sgi_set_swappartition( |
| - | get_partition(1, g_partitions)); |
| else | |
| unknown_command(c); | |
| break; | |
| case 'd': | |
| { | |
| - | int j; |
| - | /* 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 (!LABEL_IS_SGI) { |
| - | j = get_existing_partition(1, g_partitions); |
| - | } else { |
| - | j = get_partition(1, g_partitions); |
| - | } |
| + | int j = get_existing_partition(1, g_partitions); |
| if (j >= 0) | |
| delete_partition(j); | |
| } | |
| break; | |
| - | case 'i': |
| - | if (LABEL_IS_SGI) |
| - | create_sgiinfo(); |
| - | else |
| - | unknown_command(c); |
| + | //deleted: |
| + | //case 'i': |
| + | // if (LABEL_IS_SGI) create_sgiinfo(); else |
| + | // unknown_command(c); |
| case 'l': | |
| list_types(get_sys_types()); | |
| break; | |
| @@ -3238,11 +2941,10 @@ int fdisk_main(int argc UNUSED_PARAM, char **argv) | |
| close_dev_fd(); | |
| bb_putchar('\n'); | |
| return 0; | |
| - | case 's': |
| - | # if ENABLE_FEATURE_SUN_LABEL |
| - | create_sunlabel(); |
| - | # endif |
| - | break; |
| + | //SUN_LABEL code deleted: |
| + | //case 's': |
| + | // create_sunlabel(); |
| + | // break; |
| case 't': | |
| change_sysid(); | |
| break; | |
| @@ -3257,11 +2959,7 @@ int fdisk_main(int argc UNUSED_PARAM, char **argv) | |
| break; | |
| # if ENABLE_FEATURE_FDISK_ADVANCED | |
| case 'x': | |
| - | if (LABEL_IS_SGI) { |
| - | puts("\n\tSorry, no experts menu for SGI " |
| - | "partition tables available\n"); |
| - | } else |
| - | xselect(); |
| + | xselect(); |
| break; | |
| # endif | |
| default: | |
util-linux/fdisk_sgi.c+0 -889
| @@ -1,889 +0,0 @@ | |
| - | /* |
| - | * 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 <[email protected]> |
| - | * 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[] ALIGN_PTR = { |
| - | /* 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 = %ss 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(), units_per_sector); |
| - | } else { |
| - | printf("\nDisk %s (SGI disk label): " |
| - | "%u heads, %u sectors, %u cylinders\n" |
| - | "Units = %ss of %u * 512 bytes\n\n", |
| - | disk_device, g_heads, g_sectors, g_cylinders, |
| - | str_units(), 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)); |
| - | memcpy((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 (is_prefixed_with((char*)sgilabel->directory[0].vol_file_name, "sgilabel")) { |
| - | /* |
| - | * 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") != 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()); |
| - | 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()); |
| - | 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 */ |
util-linux/fdisk_sun.c+0 -739
| @@ -1,739 +0,0 @@ | |
| - | /* |
| - | * fdisk_sun.c |
| - | * |
| - | * I think this is mostly, or entirely, due to |
| - | * Jakub Jelinek ([email protected]), July 1996 |
| - | * |
| - | * Merged with fdisk for other architectures, aeb, June 1998. |
| - | * |
| - | * Sat Mar 20 EST 1999 Arnaldo Carvalho de Melo <[email protected]> |
| - | * Internationalization |
| - | * |
| - | * Licensed under GPLv2, see file LICENSE in this source tree. |
| - | */ |
| - | |
| - | #if ENABLE_FEATURE_SUN_LABEL |
| - | |
| - | #define SUNOS_SWAP 3 |
| - | #define SUN_WHOLE_DISK 5 |
| - | |
| - | #define SUN_LABEL_MAGIC 0xDABE |
| - | #define SUN_LABEL_MAGIC_SWAPPED 0xBEDA |
| - | #define SUN_SSWAP16(x) (G.sun_other_endian ? fdisk_swap16(x) : (uint16_t)(x)) |
| - | #define SUN_SSWAP32(x) (G.sun_other_endian ? fdisk_swap32(x) : (uint32_t)(x)) |
| - | |
| - | /* Copied from linux/major.h */ |
| - | #define FLOPPY_MAJOR 2 |
| - | |
| - | #define SCSI_IOCTL_GET_IDLUN 0x5382 |
| - | |
| - | #ifndef IDE0_MAJOR |
| - | #define IDE0_MAJOR 3 |
| - | #endif |
| - | #ifndef IDE1_MAJOR |
| - | #define IDE1_MAJOR 22 |
| - | #endif |
| - | |
| - | static void |
| - | sun_guess_device_type(void) |
| - | { |
| - | struct stat bootstat; |
| - | |
| - | G.sun_scsi_disk = 0; |
| - | G.sun_floppy = 0; |
| - | if (fstat(dev_fd, &bootstat) < 0) |
| - | return; |
| - | if (S_ISBLK(bootstat.st_mode)) { |
| - | //if (major(bootstat.st_rdev) == IDE0_MAJOR |
| - | // || major(bootstat.st_rdev) == IDE1_MAJOR |
| - | //) { |
| - | // G.sun_scsi_disk = 0; |
| - | // G.sun_floppy = 0; |
| - | //} |
| - | if (major(bootstat.st_rdev) == FLOPPY_MAJOR) { |
| - | //G.sun_scsi_disk = 0; |
| - | G.sun_floppy = 1; |
| - | } |
| - | } else { |
| - | G.sun_scsi_disk = 1; |
| - | //G.sun_floppy = 0; |
| - | } |
| - | } |
| - | |
| - | static const char *const sun_sys_types[] ALIGN_PTR = { |
| - | "\x00" "Empty" , /* 0 */ |
| - | "\x01" "Boot" , /* 1 */ |
| - | "\x02" "SunOS root" , /* 2 */ |
| - | "\x03" "SunOS swap" , /* SUNOS_SWAP */ |
| - | "\x04" "SunOS usr" , /* 4 */ |
| - | "\x05" "Whole disk" , /* SUN_WHOLE_DISK */ |
| - | "\x06" "SunOS stand" , /* 6 */ |
| - | "\x07" "SunOS var" , /* 7 */ |
| - | "\x08" "SunOS home" , /* 8 */ |
| - | "\x82" "Linux swap" , /* LINUX_SWAP */ |
| - | "\x83" "Linux native", /* LINUX_NATIVE */ |
| - | "\x8e" "Linux LVM" , /* 0x8e */ |
| - | /* New (2.2.x) raid partition with autodetect using persistent superblock */ |
| - | "\xfd" "Linux raid autodetect", /* 0xfd */ |
| - | NULL |
| - | }; |
| - | |
| - | |
| - | static void |
| - | set_sun_partition(int i, unsigned start, unsigned stop, int sysid) |
| - | { |
| - | sunlabel->infos[i].id = sysid; |
| - | sunlabel->partitions[i].start_cylinder = |
| - | SUN_SSWAP32(start / (g_heads * g_sectors)); |
| - | sunlabel->partitions[i].num_sectors = |
| - | SUN_SSWAP32(stop - start); |
| - | set_changed(i); |
| - | } |
| - | |
| - | static int |
| - | check_sun_label(void) |
| - | { |
| - | unsigned short *ush; |
| - | int csum; |
| - | |
| - | if (sunlabel->magic != SUN_LABEL_MAGIC |
| - | && sunlabel->magic != SUN_LABEL_MAGIC_SWAPPED |
| - | ) { |
| - | current_label_type = LABEL_DOS; |
| - | G.sun_other_endian = 0; |
| - | return 0; |
| - | } |
| - | G.sun_other_endian = (sunlabel->magic == SUN_LABEL_MAGIC_SWAPPED); |
| - | ush = ((unsigned short *) (sunlabel + 1)) - 1; |
| - | for (csum = 0; ush >= (unsigned short *)sunlabel;) |
| - | csum ^= *ush--; |
| - | if (csum) { |
| - | printf("Detected sun disklabel with wrong checksum.\n" |
| - | "Probably you'll have to set all the values,\n" |
| - | "e.g. heads, sectors, cylinders and partitions\n" |
| - | "or force a fresh label (s command in main menu)\n"); |
| - | } else { |
| - | g_heads = SUN_SSWAP16(sunlabel->ntrks); |
| - | g_cylinders = SUN_SSWAP16(sunlabel->ncyl); |
| - | g_sectors = SUN_SSWAP16(sunlabel->nsect); |
| - | } |
| - | update_units(); |
| - | current_label_type = LABEL_SUN; |
| - | g_partitions = 8; |
| - | return 1; |
| - | } |
| - | |
| - | static const struct sun_predefined_drives { |
| - | const char *vendor; |
| - | const char *model; |
| - | unsigned short sparecyl; |
| - | unsigned short ncyl; |
| - | unsigned short nacyl; |
| - | unsigned short pcylcount; |
| - | unsigned short ntrks; |
| - | unsigned short nsect; |
| - | unsigned short rspeed; |
| - | } sun_drives[] ALIGN_PTR = { |
| - | { "Quantum","ProDrive 80S",1,832,2,834,6,34,3662}, |
| - | { "Quantum","ProDrive 105S",1,974,2,1019,6,35,3662}, |
| - | { "CDC","Wren IV 94171-344",3,1545,2,1549,9,46,3600}, |
| - | { "IBM","DPES-31080",0,4901,2,4903,4,108,5400}, |
| - | { "IBM","DORS-32160",0,1015,2,1017,67,62,5400}, |
| - | { "IBM","DNES-318350",0,11199,2,11474,10,320,7200}, |
| - | { "SEAGATE","ST34371",0,3880,2,3882,16,135,7228}, |
| - | { "","SUN0104",1,974,2,1019,6,35,3662}, |
| - | { "","SUN0207",4,1254,2,1272,9,36,3600}, |
| - | { "","SUN0327",3,1545,2,1549,9,46,3600}, |
| - | { "","SUN0340",0,1538,2,1544,6,72,4200}, |
| - | { "","SUN0424",2,1151,2,2500,9,80,4400}, |
| - | { "","SUN0535",0,1866,2,2500,7,80,5400}, |
| - | { "","SUN0669",5,1614,2,1632,15,54,3600}, |
| - | { "","SUN1.0G",5,1703,2,1931,15,80,3597}, |
| - | { "","SUN1.05",0,2036,2,2038,14,72,5400}, |
| - | { "","SUN1.3G",6,1965,2,3500,17,80,5400}, |
| - | { "","SUN2.1G",0,2733,2,3500,19,80,5400}, |
| - | { "IOMEGA","Jaz",0,1019,2,1021,64,32,5394}, |
| - | }; |
| - | |
| - | static const struct sun_predefined_drives * |
| - | sun_autoconfigure_scsi(void) |
| - | { |
| - | const struct sun_predefined_drives *p = NULL; |
| - | |
| - | #ifdef SCSI_IOCTL_GET_IDLUN |
| - | unsigned int id[2]; |
| - | char buffer[2048]; |
| - | char buffer2[2048]; |
| - | FILE *pfd; |
| - | char *vendor; |
| - | char *model; |
| - | char *q; |
| - | int i; |
| - | |
| - | if (ioctl(dev_fd, SCSI_IOCTL_GET_IDLUN, &id)) |
| - | return NULL; |
| - | |
| - | sprintf(buffer, |
| - | "Host: scsi%u Channel: %02u Id: %02u Lun: %02u\n", |
| - | /* This is very wrong (works only if you have one HBA), |
| - | but I haven't found a way how to get hostno |
| - | from the current kernel */ |
| - | 0, |
| - | (id[0]>>16) & 0xff, |
| - | id[0] & 0xff, |
| - | (id[0]>>8) & 0xff |
| - | ); |
| - | pfd = fopen_for_read("/proc/scsi/scsi"); |
| - | if (!pfd) { |
| - | return NULL; |
| - | } |
| - | while (fgets(buffer2, 2048, pfd)) { |
| - | if (strcmp(buffer, buffer2)) |
| - | continue; |
| - | if (!fgets(buffer2, 2048, pfd)) |
| - | break; |
| - | q = strstr(buffer2, "Vendor: "); |
| - | if (!q) |
| - | break; |
| - | q += 8; |
| - | vendor = q; |
| - | q = strstr(q, " "); |
| - | *q++ = '\0'; /* truncate vendor name */ |
| - | q = strstr(q, "Model: "); |
| - | if (!q) |
| - | break; |
| - | *q = '\0'; |
| - | q += 7; |
| - | model = q; |
| - | q = strstr(q, " Rev: "); |
| - | if (!q) |
| - | break; |
| - | *q = '\0'; |
| - | for (i = 0; i < ARRAY_SIZE(sun_drives); i++) { |
| - | if (*sun_drives[i].vendor && strcasecmp(sun_drives[i].vendor, vendor)) |
| - | continue; |
| - | if (!strstr(model, sun_drives[i].model)) |
| - | continue; |
| - | printf("Autoconfigure found a %s%s%s\n", |
| - | sun_drives[i].vendor, |
| - | (*sun_drives[i].vendor) ? " " : "", |
| - | sun_drives[i].model); |
| - | p = sun_drives + i; |
| - | break; |
| - | } |
| - | break; |
| - | } |
| - | fclose(pfd); |
| - | #endif |
| - | return p; |
| - | } |
| - | |
| - | static void |
| - | create_sunlabel(void) |
| - | { |
| - | struct hd_geometry geometry; |
| - | unsigned ndiv; |
| - | unsigned char c; |
| - | const struct sun_predefined_drives *p = NULL; |
| - | |
| - | printf(msg_building_new_label, "sun disklabel"); |
| - | |
| - | G.sun_other_endian = BB_LITTLE_ENDIAN; |
| - | memset(MBRbuffer, 0, sizeof(MBRbuffer)); |
| - | sunlabel->magic = SUN_SSWAP16(SUN_LABEL_MAGIC); |
| - | if (!G.sun_floppy) { |
| - | unsigned i; |
| - | puts("Drive type\n" |
| - | " ? auto configure\n" |
| - | " 0 custom (with hardware detected defaults)"); |
| - | for (i = 0; i < ARRAY_SIZE(sun_drives); i++) { |
| - | printf(" %c %s%s%s\n", |
| - | i + 'a', sun_drives[i].vendor, |
| - | (*sun_drives[i].vendor) ? " " : "", |
| - | sun_drives[i].model); |
| - | } |
| - | while (1) { |
| - | c = read_nonempty("Select type (? for auto, 0 for custom): "); |
| - | if (c == '0') { |
| - | break; |
| - | } |
| - | if (c >= 'a' && c < 'a' + ARRAY_SIZE(sun_drives)) { |
| - | p = sun_drives + c - 'a'; |
| - | break; |
| - | } |
| - | if (c >= 'A' && c < 'A' + ARRAY_SIZE(sun_drives)) { |
| - | p = sun_drives + c - 'A'; |
| - | break; |
| - | } |
| - | if (c == '?' && G.sun_scsi_disk) { |
| - | p = sun_autoconfigure_scsi(); |
| - | if (p) |
| - | break; |
| - | printf("Autoconfigure failed\n"); |
| - | } |
| - | } |
| - | } |
| - | if (!p || G.sun_floppy) { |
| - | if (!ioctl(dev_fd, HDIO_GETGEO, &geometry)) { |
| - | g_heads = geometry.heads; |
| - | g_sectors = geometry.sectors; |
| - | g_cylinders = geometry.cylinders; |
| - | } else { |
| - | g_heads = 0; |
| - | g_sectors = 0; |
| - | g_cylinders = 0; |
| - | } |
| - | if (G.sun_floppy) { |
| - | sunlabel->nacyl = 0; |
| - | sunlabel->pcylcount = SUN_SSWAP16(g_cylinders); |
| - | sunlabel->rspeed = SUN_SSWAP16(300); |
| - | sunlabel->ilfact = SUN_SSWAP16(1); |
| - | sunlabel->sparecyl = 0; |
| - | } else { |
| - | g_heads = read_int(1, g_heads, 1024, 0, "Heads"); |
| - | g_sectors = read_int(1, g_sectors, 1024, 0, "Sectors/track"); |
| - | if (g_cylinders) |
| - | g_cylinders = read_int(1, g_cylinders - 2, 65535, 0, "Cylinders"); |
| - | else |
| - | g_cylinders = read_int(1, 0, 65535, 0, "Cylinders"); |
| - | sunlabel->nacyl = SUN_SSWAP16(read_int(0, 2, 65535, 0, "Alternate cylinders")); |
| - | sunlabel->pcylcount = SUN_SSWAP16(read_int(0, g_cylinders + SUN_SSWAP16(sunlabel->nacyl), 65535, 0, "Physical cylinders")); |
| - | sunlabel->rspeed = SUN_SSWAP16(read_int(1, 5400, 100000, 0, "Rotation speed (rpm)")); |
| - | sunlabel->ilfact = SUN_SSWAP16(read_int(1, 1, 32, 0, "Interleave factor")); |
| - | sunlabel->sparecyl = SUN_SSWAP16(read_int(0, 0, g_sectors, 0, "Extra sectors per cylinder")); |
| - | } |
| - | } else { |
| - | sunlabel->sparecyl = SUN_SSWAP16(p->sparecyl); |
| - | sunlabel->ncyl = SUN_SSWAP16(p->ncyl); |
| - | sunlabel->nacyl = SUN_SSWAP16(p->nacyl); |
| - | sunlabel->pcylcount = SUN_SSWAP16(p->pcylcount); |
| - | sunlabel->ntrks = SUN_SSWAP16(p->ntrks); |
| - | sunlabel->nsect = SUN_SSWAP16(p->nsect); |
| - | sunlabel->rspeed = SUN_SSWAP16(p->rspeed); |
| - | sunlabel->ilfact = SUN_SSWAP16(1); |
| - | g_cylinders = p->ncyl; |
| - | g_heads = p->ntrks; |
| - | g_sectors = p->nsect; |
| - | puts("You may change all the disk params from the x menu"); |
| - | } |
| - | |
| - | snprintf((char *)(sunlabel->info), sizeof(sunlabel->info), |
| - | "%s%s%s cyl %u alt %u hd %u sec %u", |
| - | p ? p->vendor : "", (p && *p->vendor) ? " " : "", |
| - | p ? p->model : (G.sun_floppy ? "3,5\" floppy" : "Linux custom"), |
| - | g_cylinders, SUN_SSWAP16(sunlabel->nacyl), g_heads, g_sectors); |
| - | |
| - | sunlabel->ntrks = SUN_SSWAP16(g_heads); |
| - | sunlabel->nsect = SUN_SSWAP16(g_sectors); |
| - | sunlabel->ncyl = SUN_SSWAP16(g_cylinders); |
| - | if (G.sun_floppy) |
| - | set_sun_partition(0, 0, g_cylinders * g_heads * g_sectors, LINUX_NATIVE); |
| - | else { |
| - | if (g_cylinders * g_heads * g_sectors >= 150 * 2048) { |
| - | ndiv = g_cylinders - (50 * 2048 / (g_heads * g_sectors)); /* 50M swap */ |
| - | } else |
| - | ndiv = g_cylinders * 2 / 3; |
| - | set_sun_partition(0, 0, ndiv * g_heads * g_sectors, LINUX_NATIVE); |
| - | set_sun_partition(1, ndiv * g_heads * g_sectors, g_cylinders * g_heads * g_sectors, LINUX_SWAP); |
| - | sunlabel->infos[1].flags |= 0x01; /* Not mountable */ |
| - | } |
| - | set_sun_partition(2, 0, g_cylinders * g_heads * g_sectors, SUN_WHOLE_DISK); |
| - | { |
| - | unsigned short *ush = (unsigned short *)sunlabel; |
| - | unsigned short csum = 0; |
| - | while (ush < (unsigned short *)(&sunlabel->csum)) |
| - | csum ^= *ush++; |
| - | sunlabel->csum = csum; |
| - | } |
| - | |
| - | set_all_unchanged(); |
| - | set_changed(0); |
| - | check_sun_label(); |
| - | get_boot(CREATE_EMPTY_SUN); |
| - | } |
| - | |
| - | static void |
| - | toggle_sunflags(int i, unsigned char mask) |
| - | { |
| - | if (sunlabel->infos[i].flags & mask) |
| - | sunlabel->infos[i].flags &= ~mask; |
| - | else |
| - | sunlabel->infos[i].flags |= mask; |
| - | set_changed(i); |
| - | } |
| - | |
| - | typedef struct start_and_len { |
| - | unsigned start; |
| - | unsigned len; |
| - | } start_and_len_t; |
| - | |
| - | static void |
| - | fetch_sun(start_and_len_t *sl, unsigned *start, unsigned *stop) |
| - | { |
| - | int i, continuous = 1; |
| - | |
| - | *start = 0; |
| - | *stop = g_cylinders * g_heads * g_sectors; |
| - | for (i = 0; i < g_partitions; i++) { |
| - | sl[i].start = 0; |
| - | sl[i].len = 0; |
| - | if (sunlabel->partitions[i].num_sectors != 0 |
| - | && sunlabel->infos[i].id != 0 |
| - | && sunlabel->infos[i].id != SUN_WHOLE_DISK |
| - | ) { |
| - | sl[i].start = SUN_SSWAP32(sunlabel->partitions[i].start_cylinder) * g_heads * g_sectors; |
| - | sl[i].len = SUN_SSWAP32(sunlabel->partitions[i].num_sectors); |
| - | if (continuous) { |
| - | if (sl[i].start == *start) |
| - | *start += sl[i].len; |
| - | else if (sl[i].start + sl[i].len >= *stop) |
| - | *stop = sl[i].start; |
| - | else |
| - | continuous = 0; |
| - | /* There will be probably more gaps |
| - | than one, so lets check afterwards */ |
| - | } |
| - | } |
| - | } |
| - | } |
| - | |
| - | static int |
| - | verify_sun_cmp(const void *aa, const void *bb) |
| - | { |
| - | const start_and_len_t *a = aa; |
| - | const start_and_len_t *b = bb; |
| - | if (a->len == 0) return 1; |
| - | if (b->len == 0) return -1; |
| - | if (a->start > b->start) |
| - | return 1; |
| - | return -1; |
| - | } |
| - | |
| - | static NOINLINE void |
| - | verify_sun(void) |
| - | { |
| - | start_and_len_t sl[8]; |
| - | unsigned start, stop; |
| - | int i, j, k; |
| - | |
| - | fetch_sun(sl, &start, &stop); |
| - | for (k = 0; k < 7; k++) { |
| - | for (i = 0; i < 8; i++) { |
| - | if (k != 0 |
| - | && (sl[i].len % (g_heads * g_sectors)) != 0 |
| - | ) { |
| - | printf("Partition %u doesn't end on cylinder boundary\n", i+1); |
| - | } |
| - | if (sl[i].len == 0) |
| - | continue; |
| - | for (j = 0; j < i; j++) { |
| - | if (sl[j].len == 0) |
| - | continue; |
| - | if (sl[j].start == sl[i].start + sl[i].len) { |
| - | sl[j].start = sl[i].start; |
| - | sl[j].len += sl[i].len; |
| - | sl[i].len = 0; |
| - | } else if (sl[i].start == sl[j].start + sl[j].len) { |
| - | sl[j].len += sl[i].len; |
| - | sl[i].len = 0; |
| - | } else if (k == 0 |
| - | && sl[i].start < sl[j].start + sl[j].len |
| - | && sl[j].start < sl[i].start + sl[i].len |
| - | ) { |
| - | unsigned starto, endo; |
| - | starto = sl[i].start; |
| - | if (sl[j].start > starto) |
| - | starto = sl[j].start; |
| - | endo = sl[i].start + sl[i].len; |
| - | if (sl[j].start + sl[j].len < endo) |
| - | endo = sl[j].start + sl[j].len; |
| - | printf("Partition %u overlaps with others in " |
| - | "sectors %u-%u\n", i+1, starto, endo); |
| - | } |
| - | } |
| - | } |
| - | } |
| - | qsort(sl, ARRAY_SIZE(sl), sizeof(sl[0]), verify_sun_cmp); |
| - | |
| - | if (sl[0].len == 0) { |
| - | printf("No partitions defined\n"); |
| - | return; |
| - | } |
| - | if (sl[0].start != 0) |
| - | printf("Unused gap - sectors %u-%u\n", 0, sl[0].start); |
| - | for (i = 0; i < 7 && sl[i+1].len != 0; i++) { |
| - | if (sl[i].start + sl[i].len < sl[i+1].start) |
| - | printf("Unused gap - sectors %u-%u\n", |
| - | sl[i].start + sl[i].len, sl[i+1].start); |
| - | } |
| - | start = sl[i].start + sl[i].len; |
| - | stop = g_cylinders * g_heads * g_sectors; |
| - | if (start < stop) |
| - | printf("Unused gap - sectors %u-%u\n", start, stop); |
| - | } |
| - | |
| - | static void |
| - | add_sun_partition(int n, int sys) |
| - | { |
| - | unsigned start, stop, stop2; |
| - | start_and_len_t sl[8]; |
| - | int whole_disk = 0; |
| - | |
| - | char mesg[256]; |
| - | int i, first, last; |
| - | |
| - | if (sunlabel->partitions[n].num_sectors && sunlabel->infos[n].id) { |
| - | printf(msg_part_already_defined, n + 1); |
| - | return; |
| - | } |
| - | |
| - | fetch_sun(sl, &start, &stop); |
| - | if (stop <= start) { |
| - | if (n == 2) |
| - | whole_disk = 1; |
| - | else { |
| - | printf("Other partitions already cover the whole disk.\n" |
| - | "Delete/shrink them before retry.\n"); |
| - | return; |
| - | } |
| - | } |
| - | snprintf(mesg, sizeof(mesg), "First %s", str_units()); |
| - | while (1) { |
| - | if (whole_disk) |
| - | first = read_int(0, 0, 0, 0, mesg); |
| - | else |
| - | first = read_int(scround(start), scround(stop)+1, |
| - | scround(stop), 0, mesg); |
| - | if (DISPLAY_IN_CYL_UNITS) { |
| - | first *= units_per_sector; |
| - | } else { |
| - | /* Starting sector has to be properly aligned */ |
| - | first = (first + g_heads * g_sectors - 1) / |
| - | (g_heads * g_sectors); |
| - | first *= g_heads * g_sectors; |
| - | } |
| - | if (n == 2 && first != 0) |
| - | printf("\ |
| - | It is highly recommended that the third partition covers the whole disk\n\ |
| - | and is of type 'Whole disk'\n"); |
| - | /* ewt asks to add: "don't start a partition at cyl 0" |
| - | However, [email protected] writes: |
| - | "In addition to having a Sun partition table, to be able to |
| - | boot from the disc, the first partition, /dev/sdX1, must |
| - | start at cylinder 0. This means that /dev/sdX1 contains |
| - | the partition table and the boot block, as these are the |
| - | first two sectors of the disc. Therefore you must be |
| - | careful what you use /dev/sdX1 for. In particular, you must |
| - | not use a partition starting at cylinder 0 for Linux swap, |
| - | as that would overwrite the partition table and the boot |
| - | block. You may, however, use such a partition for a UFS |
| - | or EXT2 file system, as these file systems leave the first |
| - | 1024 bytes undisturbed. */ |
| - | /* On the other hand, one should not use partitions |
| - | starting at block 0 in an md, or the label will |
| - | be trashed. */ |
| - | for (i = 0; i < g_partitions; i++) |
| - | if (sl[i].len && sl[i].start <= first && sl[i].start + sl[i].len > first) |
| - | break; |
| - | if (i < g_partitions && !whole_disk) { |
| - | if (n == 2 && !first) { |
| - | whole_disk = 1; |
| - | break; |
| - | } |
| - | printf("Sector %u is already allocated\n", first); |
| - | } else |
| - | break; |
| - | } |
| - | stop = g_cylinders * g_heads * g_sectors; |
| - | stop2 = stop; |
| - | for (i = 0; i < g_partitions; i++) { |
| - | if (sl[i].start > first && sl[i].start < stop) |
| - | stop = sl[i].start; |
| - | } |
| - | snprintf(mesg, sizeof(mesg), |
| - | "Last %s or +size or +sizeM or +sizeK", |
| - | str_units()); |
| - | if (whole_disk) |
| - | last = read_int(scround(stop2), scround(stop2), scround(stop2), |
| - | 0, mesg); |
| - | else if (n == 2 && !first) |
| - | last = read_int(scround(first), scround(stop2), scround(stop2), |
| - | scround(first), mesg); |
| - | else |
| - | last = read_int(scround(first), scround(stop), scround(stop), |
| - | scround(first), mesg); |
| - | if (DISPLAY_IN_CYL_UNITS) |
| - | last *= units_per_sector; |
| - | if (n == 2 && !first) { |
| - | if (last >= stop2) { |
| - | whole_disk = 1; |
| - | last = stop2; |
| - | } else if (last > stop) { |
| - | printf( |
| - | "You haven't covered the whole disk with the 3rd partition,\n" |
| - | "but your value %u %s covers some other partition.\n" |
| - | "Your entry has been changed to %u %s\n", |
| - | scround(last), str_units(), |
| - | scround(stop), str_units()); |
| - | last = stop; |
| - | } |
| - | } else if (!whole_disk && last > stop) |
| - | last = stop; |
| - | |
| - | if (whole_disk) |
| - | sys = SUN_WHOLE_DISK; |
| - | set_sun_partition(n, first, last, sys); |
| - | } |
| - | |
| - | static void |
| - | sun_delete_partition(int i) |
| - | { |
| - | unsigned int nsec; |
| - | |
| - | if (i == 2 |
| - | && sunlabel->infos[i].id == SUN_WHOLE_DISK |
| - | && !sunlabel->partitions[i].start_cylinder |
| - | && (nsec = SUN_SSWAP32(sunlabel->partitions[i].num_sectors)) == g_heads * g_sectors * g_cylinders) |
| - | printf("If you want to maintain SunOS/Solaris compatibility, " |
| - | "consider leaving this\n" |
| - | "partition as Whole disk (5), starting at 0, with %u " |
| - | "sectors\n", nsec); |
| - | sunlabel->infos[i].id = 0; |
| - | sunlabel->partitions[i].num_sectors = 0; |
| - | } |
| - | |
| - | static void |
| - | sun_change_sysid(int i, int sys) |
| - | { |
| - | if (sys == LINUX_SWAP && !sunlabel->partitions[i].start_cylinder) { |
| - | read_maybe_empty( |
| - | "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" |
| - | "Type YES if you're very sure you would like that partition\n" |
| - | "tagged with 82 (Linux swap): "); |
| - | if (strcmp(line_ptr, "YES") != 0) |
| - | return; |
| - | } |
| - | switch (sys) { |
| - | case SUNOS_SWAP: |
| - | case LINUX_SWAP: |
| - | /* swaps are not mountable by default */ |
| - | sunlabel->infos[i].flags |= 0x01; |
| - | break; |
| - | default: |
| - | /* assume other types are mountable; |
| - | user can change it anyway */ |
| - | sunlabel->infos[i].flags &= ~0x01; |
| - | break; |
| - | } |
| - | sunlabel->infos[i].id = sys; |
| - | } |
| - | |
| - | static void |
| - | sun_list_table(int xtra) |
| - | { |
| - | int i, w; |
| - | |
| - | w = strlen(disk_device); |
| - | if (xtra) |
| - | printf( |
| - | "\nDisk %s (Sun disk label): %u heads, %u sectors, %u rpm\n" |
| - | "%u cylinders, %u alternate cylinders, %u physical cylinders\n" |
| - | "%u extra sects/cyl, interleave %u:1\n" |
| - | "%s\n" |
| - | "Units = %ss of %u * 512 bytes\n\n", |
| - | disk_device, g_heads, g_sectors, SUN_SSWAP16(sunlabel->rspeed), |
| - | g_cylinders, SUN_SSWAP16(sunlabel->nacyl), |
| - | SUN_SSWAP16(sunlabel->pcylcount), |
| - | SUN_SSWAP16(sunlabel->sparecyl), |
| - | SUN_SSWAP16(sunlabel->ilfact), |
| - | (char *)sunlabel, |
| - | str_units(), units_per_sector); |
| - | else |
| - | printf( |
| - | "\nDisk %s (Sun disk label): %u heads, %u sectors, %u cylinders\n" |
| - | "Units = %ss of %u * 512 bytes\n\n", |
| - | disk_device, g_heads, g_sectors, g_cylinders, |
| - | str_units(), units_per_sector); |
| - | |
| - | printf("%*s Flag Start End Blocks Id System\n", |
| - | w + 1, "Device"); |
| - | for (i = 0; i < g_partitions; i++) { |
| - | if (sunlabel->partitions[i].num_sectors) { |
| - | uint32_t start = SUN_SSWAP32(sunlabel->partitions[i].start_cylinder) * g_heads * g_sectors; |
| - | uint32_t len = SUN_SSWAP32(sunlabel->partitions[i].num_sectors); |
| - | printf("%s %c%c %9lu %9lu %9lu%c %2x %s\n", |
| - | partname(disk_device, i+1, w), /* device */ |
| - | (sunlabel->infos[i].flags & 0x01) ? 'u' : ' ', /* flags */ |
| - | (sunlabel->infos[i].flags & 0x10) ? 'r' : ' ', |
| - | (long) scround(start), /* start */ |
| - | (long) scround(start+len), /* end */ |
| - | (long) len / 2, len & 1 ? '+' : ' ', /* odd flag on end */ |
| - | sunlabel->infos[i].id, /* type id */ |
| - | partition_type(sunlabel->infos[i].id)); /* type name */ |
| - | } |
| - | } |
| - | } |
| - | |
| - | #if ENABLE_FEATURE_FDISK_ADVANCED |
| - | |
| - | static void |
| - | sun_set_alt_cyl(void) |
| - | { |
| - | sunlabel->nacyl = |
| - | SUN_SSWAP16(read_int(0, SUN_SSWAP16(sunlabel->nacyl), 65535, 0, |
| - | "Number of alternate cylinders")); |
| - | } |
| - | |
| - | static void |
| - | sun_set_ncyl(int cyl) |
| - | { |
| - | sunlabel->ncyl = SUN_SSWAP16(cyl); |
| - | } |
| - | |
| - | static void |
| - | sun_set_xcyl(void) |
| - | { |
| - | sunlabel->sparecyl = |
| - | SUN_SSWAP16(read_int(0, SUN_SSWAP16(sunlabel->sparecyl), g_sectors, 0, |
| - | "Extra sectors per cylinder")); |
| - | } |
| - | |
| - | static void |
| - | sun_set_ilfact(void) |
| - | { |
| - | sunlabel->ilfact = |
| - | SUN_SSWAP16(read_int(1, SUN_SSWAP16(sunlabel->ilfact), 32, 0, |
| - | "Interleave factor")); |
| - | } |
| - | |
| - | static void |
| - | sun_set_rspeed(void) |
| - | { |
| - | sunlabel->rspeed = |
| - | SUN_SSWAP16(read_int(1, SUN_SSWAP16(sunlabel->rspeed), 100000, 0, |
| - | "Rotation speed (rpm)")); |
| - | } |
| - | |
| - | static void |
| - | sun_set_pcylcount(void) |
| - | { |
| - | sunlabel->pcylcount = |
| - | SUN_SSWAP16(read_int(0, SUN_SSWAP16(sunlabel->pcylcount), 65535, 0, |
| - | "Number of physical cylinders")); |
| - | } |
| - | #endif /* FEATURE_FDISK_ADVANCED */ |
| - | |
| - | static void |
| - | sun_write_table(void) |
| - | { |
| - | unsigned short *ush = (unsigned short *)sunlabel; |
| - | unsigned short csum = 0; |
| - | |
| - | while (ush < (unsigned short *)(&sunlabel->csum)) |
| - | csum ^= *ush++; |
| - | sunlabel->csum = csum; |
| - | write_sector(0, sunlabel); |
| - | } |
| - | #endif /* SUN_LABEL */ |