1 /* fdisk.c -- Partition table manipulator for Linux.
3 * Copyright (C) 1992 A. V. Le Blanc (LeBlanc@mcc.ac.uk)
4 * Copyright (C) 2001,2002 Vladimir Oleynik <dzo@simtreas.ru> (initial bb port)
6 * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
9 /* Current changes have not compatibility with this version */
10 #define UTIL_LINUX_VERSION "2.12"
13 #define PROC_PARTITIONS "/proc/partitions"
16 #include <sys/types.h>
17 #include <sys/stat.h> /* stat */
26 #include <assert.h> /* assert */
29 #include <sys/ioctl.h>
30 #include <sys/param.h>
31 #include <sys/sysmacros.h> /* major */
33 #include <stdint.h> /* for uint32_t, uint16_t, uint8_t, int16_t, etc */
35 /* Copied from linux/major.h */
36 #define FLOPPY_MAJOR 2
38 #include <sys/utsname.h>
44 #define BLKRRPART _IO(0x12,95) /* re-read partition table */
45 #define BLKGETSIZE _IO(0x12,96) /* return device size */
46 #define BLKFLSBUF _IO(0x12,97) /* flush buffer cache */
47 #define BLKSSZGET _IO(0x12,104) /* get block device sector size */
49 /* Avoid conflicts with the 2.6 kernel headers, which define
50 * _IOR rather differently */
52 #define _IOR(type,nr,size) _IOC(_IOC_READ,(type),(nr),sizeof(size))
53 #define BLKGETSIZE64 _IOR(0x12,114,uint64_t)
59 #define DEFAULT_SECTOR_SIZE 512
60 #define MAX_SECTOR_SIZE 2048
61 #define SECTOR_SIZE 512 /* still used in BSD code */
62 #define MAXIMUM_PARTS 60
64 #define ACTIVE_FLAG 0x80
67 #define WIN98_EXTENDED 0x0f
68 #define LINUX_PARTITION 0x81
69 #define LINUX_SWAP 0x82
70 #define LINUX_NATIVE 0x83
71 #define LINUX_EXTENDED 0x85
72 #define LINUX_LVM 0x8e
73 #define LINUX_RAID 0xfd
78 #define IS_EXTENDED(i) \
79 ((i) == EXTENDED || (i) == WIN98_EXTENDED || (i) == LINUX_EXTENDED)
81 #define SIZE(a) (sizeof(a)/sizeof((a)[0]))
83 #define cround(n) (display_in_cyl_units ? ((n)/units_per_sector)+1 : (n))
84 #define scround(x) (((x)+units_per_sector-1)/units_per_sector)
86 #ifdef CONFIG_FEATURE_SUN_LABEL
87 #define SCSI_IOCTL_GET_IDLUN 0x5382
91 /* including <linux/hdreg.h> also fails */
94 unsigned char sectors;
95 unsigned short cylinders;
99 #define HDIO_GETGEO 0x0301 /* get device geometry */
106 static uint sector_size = DEFAULT_SECTOR_SIZE;
107 static uint user_set_sector_size;
108 static uint sector_offset = 1;
111 * Raw disk label. For DOS-type partition tables the MBR,
112 * with descriptions of the primary partitions.
114 #if (MAX_SECTOR_SIZE) > (BUFSIZ+1)
115 static char MBRbuffer[MAX_SECTOR_SIZE];
117 # define MBRbuffer bb_common_bufsiz1
120 #ifdef CONFIG_FEATURE_OSF_LABEL
121 static int possibly_osf_label;
124 static uint heads, sectors, cylinders;
125 static void update_units(void);
129 * return partition name - uses static storage unless buf is supplied
132 partname(const char *dev, int pno, int lth)
134 static char buffer[80];
141 bufsiz = sizeof(buffer);
146 if (isdigit(dev[w-1]))
149 /* devfs kludge - note: fdisk partition names are not supposed
150 to equal kernel names, so there is no reason to do this */
151 if (strcmp(dev + w - 4, "disc") == 0) {
159 snprintf(bufp, bufsiz, "%*.*s%s%-2u",
160 lth-wp-2, w, dev, p, pno);
162 snprintf(bufp, bufsiz, "%.*s%s%-2u", w, dev, p, pno);
168 unsigned char boot_ind; /* 0x80 - active */
169 unsigned char head; /* starting head */
170 unsigned char sector; /* starting sector */
171 unsigned char cyl; /* starting cylinder */
172 unsigned char sys_ind; /* What partition type */
173 unsigned char end_head; /* end head */
174 unsigned char end_sector; /* end sector */
175 unsigned char end_cyl; /* end cylinder */
176 unsigned char start4[4]; /* starting sector counting from 0 */
177 unsigned char size4[4]; /* nr of sectors in partition */
181 ioctl_error, unable_to_open, unable_to_read, unable_to_seek,
186 label_dos, label_sun, label_sgi, label_aix, label_osf
189 enum action { fdisk, require, try_only, create_empty_dos, create_empty_sun };
191 static enum label_type current_label_type;
193 static const char *disk_device;
194 static int fd; /* the disk */
195 static int partitions = 4; /* maximum partition + 1 */
196 static uint display_in_cyl_units = 1;
197 static uint units_per_sector = 1;
198 #ifdef CONFIG_FEATURE_FDISK_WRITABLE
199 static char *line_ptr;
200 static void change_units(void);
201 static void reread_partition_table(int leave);
202 static void delete_partition(int i);
203 static int get_partition(int warn, int max);
204 static void list_types(const struct systypes *sys);
205 static uint read_int(uint low, uint dflt, uint high, uint base, char *mesg);
207 static const char *partition_type(unsigned char type);
208 static void fdisk_fatal(enum failure why) ATTRIBUTE_NORETURN;
209 static void get_geometry(void);
210 static int get_boot(enum action what);
215 #define hex_val(c) ({ \
217 isdigit(_c) ? _c - '0' : \
218 tolower(_c) + 10 - 'a'; \
222 #define LINE_LENGTH 800
223 #define pt_offset(b, n) ((struct partition *)((b) + 0x1be + \
224 (n) * sizeof(struct partition)))
225 #define sector(s) ((s) & 0x3f)
226 #define cylinder(s, c) ((c) | (((s) & 0xc0) << 2))
228 #define hsc2sector(h,s,c) (sector(s) - 1 + sectors * \
229 ((h) + heads * cylinder(s,c)))
230 #define set_hsc(h,s,c,sector) { \
231 s = sector % sectors + 1; \
233 h = sector % heads; \
236 s |= (sector >> 2) & 0xc0; \
240 static int32_t get_start_sect(const struct partition *p);
241 static int32_t get_nr_sects(const struct partition *p);
244 * per partition table entry data
246 * The four primary partitions have the same sectorbuffer (MBRbuffer)
247 * and have NULL ext_pointer.
248 * Each logical partition table entry has two pointers, one for the
249 * partition and one link to the next one.
252 struct partition *part_table; /* points into sectorbuffer */
253 struct partition *ext_pointer; /* points into sectorbuffer */
254 #ifdef CONFIG_FEATURE_FDISK_WRITABLE
255 char changed; /* boolean */
257 off_t offset; /* disk sector number */
258 char *sectorbuffer; /* disk sector contents */
259 } ptes[MAXIMUM_PARTS];
262 #ifdef CONFIG_FEATURE_FDISK_WRITABLE
264 set_all_unchanged(void)
268 for (i = 0; i < MAXIMUM_PARTS; i++)
277 #endif /* CONFIG_FEATURE_FDISK_WRITABLE */
279 #if defined(CONFIG_FEATURE_SGI_LABEL) || defined(CONFIG_FEATURE_OSF_LABEL)
280 static struct partition *
281 get_part_table(int i)
283 return ptes[i].part_table;
289 { /* n==1: use singular */
291 return display_in_cyl_units ? _("cylinder") : _("sector");
293 return display_in_cyl_units ? _("cylinders") : _("sectors");
297 valid_part_table_flag(const char *mbuffer) {
298 const unsigned char *b = (const unsigned char *)mbuffer;
299 return (b[510] == 0x55 && b[511] == 0xaa);
302 #ifdef CONFIG_FEATURE_FDISK_WRITABLE
303 static char line_buffer[LINE_LENGTH];
305 /* read line; return 0 or first char */
309 static int got_eof = 0;
311 fflush (stdout); /* requested by niles@scyld.com */
312 line_ptr = line_buffer;
313 if (!fgets(line_buffer, LINE_LENGTH, stdin)) {
315 got_eof++; /* user typed ^D ? */
317 fprintf(stderr, _("\ngot EOF thrice - exiting..\n"));
322 while (*line_ptr && !isgraph(*line_ptr))
328 read_char(const char *mesg)
332 } while (!read_line());
337 read_chars(const char *mesg)
348 read_hex(const struct systypes *sys)
353 read_char(_("Hex code (type L to list codes): "));
354 if (*line_ptr == 'l' || *line_ptr == 'L')
356 else if (isxdigit (*line_ptr)) {
359 hex = hex << 4 | hex_val(*line_ptr++);
360 while (isxdigit(*line_ptr));
365 #endif /* CONFIG_FEATURE_FDISK_WRITABLE */
367 #ifdef CONFIG_FEATURE_AIX_LABEL
369 * Copyright (C) Andreas Neuper, Sep 1998.
370 * This file may be redistributed under
371 * the terms of the GNU Public License.
375 unsigned int magic; /* expect AIX_LABEL_MAGIC */
376 unsigned int fillbytes1[124];
377 unsigned int physical_volume_id;
378 unsigned int fillbytes2[124];
381 #define AIX_LABEL_MAGIC 0xc9c2d4c1
382 #define AIX_LABEL_MAGIC_SWAPPED 0xc1d4c2c9
383 #define AIX_INFO_MAGIC 0x00072959
384 #define AIX_INFO_MAGIC_SWAPPED 0x59290700
386 #define aixlabel ((aix_partition *)MBRbuffer)
391 * 1999-03-20 Arnaldo Carvalho de Melo <acme@conectiva.com.br>
392 * Internationalization
394 * 2003-03-20 Phillip Kesling <pkesling@sgi.com>
398 static int aix_other_endian;
399 static short aix_volumes = 1;
402 * only dealing with free blocks here
409 _("\n\tThere is a valid AIX label on this disk.\n"
410 "\tUnfortunately Linux cannot handle these\n"
411 "\tdisks at the moment. Nevertheless some\n"
413 "\t1. fdisk will destroy its contents on write.\n"
414 "\t2. Be sure that this disk is NOT a still vital\n"
415 "\t part of a volume group. (Otherwise you may\n"
416 "\t erase the other disks as well, if unmirrored.)\n"
417 "\t3. Before deleting this physical volume be sure\n"
418 "\t to remove the disk logically from your AIX\n"
419 "\t machine. (Otherwise you become an AIXpert).")
424 check_aix_label(void)
426 if (aixlabel->magic != AIX_LABEL_MAGIC &&
427 aixlabel->magic != AIX_LABEL_MAGIC_SWAPPED) {
428 current_label_type = 0;
429 aix_other_endian = 0;
432 aix_other_endian = (aixlabel->magic == AIX_LABEL_MAGIC_SWAPPED);
434 current_label_type = label_aix;
438 /*aix_nolabel();*/ /* %% */
439 /*aix_label = 1;*/ /* %% */
442 #endif /* AIX_LABEL */
444 #ifdef CONFIG_FEATURE_OSF_LABEL
446 * Copyright (c) 1987, 1988 Regents of the University of California.
447 * All rights reserved.
449 * Redistribution and use in source and binary forms, with or without
450 * modification, are permitted provided that the following conditions
452 * 1. Redistributions of source code must retain the above copyright
453 * notice, this list of conditions and the following disclaimer.
454 * 2. Redistributions in binary form must reproduce the above copyright
455 * notice, this list of conditions and the following disclaimer in the
456 * documentation and/or other materials provided with the distribution.
457 * 3. All advertising materials mentioning features or use of this software
458 * must display the following acknowledgment:
459 * This product includes software developed by the University of
460 * California, Berkeley and its contributors.
461 * 4. Neither the name of the University nor the names of its contributors
462 * may be used to endorse or promote products derived from this software
463 * without specific prior written permission.
465 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
466 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
467 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
468 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
469 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
470 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
471 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
472 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
473 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
474 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
479 #ifndef BSD_DISKMAGIC
480 #define BSD_DISKMAGIC ((uint32_t) 0x82564557)
483 #ifndef BSD_MAXPARTITIONS
484 #define BSD_MAXPARTITIONS 16
487 #define BSD_LINUX_BOOTDIR "/usr/ucb/mdec"
489 #if defined (i386) || defined (__sparc__) || defined (__arm__) || defined (__mips__) || defined (__s390__) || defined (__sh__) || defined(__x86_64__)
490 #define BSD_LABELSECTOR 1
491 #define BSD_LABELOFFSET 0
492 #elif defined (__alpha__) || defined (__powerpc__) || defined (__ia64__) || defined (__hppa__)
493 #define BSD_LABELSECTOR 0
494 #define BSD_LABELOFFSET 64
495 #elif defined (__s390__) || defined (__s390x__)
496 #define BSD_LABELSECTOR 1
497 #define BSD_LABELOFFSET 0
499 #error unknown architecture
502 #define BSD_BBSIZE 8192 /* size of boot area, with label */
503 #define BSD_SBSIZE 8192 /* max size of fs superblock */
505 struct xbsd_disklabel {
506 uint32_t d_magic; /* the magic number */
507 int16_t d_type; /* drive type */
508 int16_t d_subtype; /* controller/d_type specific */
509 char d_typename[16]; /* type name, e.g. "eagle" */
510 char d_packname[16]; /* pack identifier */
512 uint32_t d_secsize; /* # of bytes per sector */
513 uint32_t d_nsectors; /* # of data sectors per track */
514 uint32_t d_ntracks; /* # of tracks per cylinder */
515 uint32_t d_ncylinders; /* # of data cylinders per unit */
516 uint32_t d_secpercyl; /* # of data sectors per cylinder */
517 uint32_t d_secperunit; /* # of data sectors per unit */
519 * Spares (bad sector replacements) below
520 * are not counted in d_nsectors or d_secpercyl.
521 * Spare sectors are assumed to be physical sectors
522 * which occupy space at the end of each track and/or cylinder.
524 uint16_t d_sparespertrack; /* # of spare sectors per track */
525 uint16_t d_sparespercyl; /* # of spare sectors per cylinder */
527 * Alternate cylinders include maintenance, replacement,
528 * configuration description areas, etc.
530 uint32_t d_acylinders; /* # of alt. cylinders per unit */
532 /* hardware characteristics: */
534 * d_interleave, d_trackskew and d_cylskew describe perturbations
535 * in the media format used to compensate for a slow controller.
536 * Interleave is physical sector interleave, set up by the formatter
537 * or controller when formatting. When interleaving is in use,
538 * logically adjacent sectors are not physically contiguous,
539 * but instead are separated by some number of sectors.
540 * It is specified as the ratio of physical sectors traversed
541 * per logical sector. Thus an interleave of 1:1 implies contiguous
542 * layout, while 2:1 implies that logical sector 0 is separated
543 * by one sector from logical sector 1.
544 * d_trackskew is the offset of sector 0 on track N
545 * relative to sector 0 on track N-1 on the same cylinder.
546 * Finally, d_cylskew is the offset of sector 0 on cylinder N
547 * relative to sector 0 on cylinder N-1.
549 uint16_t d_rpm; /* rotational speed */
550 uint16_t d_interleave; /* hardware sector interleave */
551 uint16_t d_trackskew; /* sector 0 skew, per track */
552 uint16_t d_cylskew; /* sector 0 skew, per cylinder */
553 uint32_t d_headswitch; /* head switch time, usec */
554 uint32_t d_trkseek; /* track-to-track seek, usec */
555 uint32_t d_flags; /* generic flags */
557 uint32_t d_drivedata[NDDATA]; /* drive-type specific information */
559 uint32_t d_spare[NSPARE]; /* reserved for future use */
560 uint32_t d_magic2; /* the magic number (again) */
561 uint16_t d_checksum; /* xor of data incl. partitions */
562 /* filesystem and partition information: */
563 uint16_t d_npartitions; /* number of partitions in following */
564 uint32_t d_bbsize; /* size of boot area at sn0, bytes */
565 uint32_t d_sbsize; /* max size of fs superblock, bytes */
566 struct xbsd_partition { /* the partition table */
567 uint32_t p_size; /* number of sectors in partition */
568 uint32_t p_offset; /* starting sector */
569 uint32_t p_fsize; /* filesystem basic fragment size */
570 uint8_t p_fstype; /* filesystem type, see below */
571 uint8_t p_frag; /* filesystem fragments per block */
572 uint16_t p_cpg; /* filesystem cylinders per group */
573 } d_partitions[BSD_MAXPARTITIONS]; /* actually may be more */
577 #define BSD_DTYPE_SMD 1 /* SMD, XSMD; VAX hp/up */
578 #define BSD_DTYPE_MSCP 2 /* MSCP */
579 #define BSD_DTYPE_DEC 3 /* other DEC (rk, rl) */
580 #define BSD_DTYPE_SCSI 4 /* SCSI */
581 #define BSD_DTYPE_ESDI 5 /* ESDI interface */
582 #define BSD_DTYPE_ST506 6 /* ST506 etc. */
583 #define BSD_DTYPE_HPIB 7 /* CS/80 on HP-IB */
584 #define BSD_DTYPE_HPFL 8 /* HP Fiber-link */
585 #define BSD_DTYPE_FLOPPY 10 /* floppy */
587 /* d_subtype values: */
588 #define BSD_DSTYPE_INDOSPART 0x8 /* is inside dos partition */
589 #define BSD_DSTYPE_DOSPART(s) ((s) & 3) /* dos partition number */
590 #define BSD_DSTYPE_GEOMETRY 0x10 /* drive params in label */
593 static const char * const xbsd_dktypenames[] = {
607 #define BSD_DKMAXTYPES (sizeof(xbsd_dktypenames) / sizeof(xbsd_dktypenames[0]) - 1)
611 * Filesystem type and version.
612 * Used to interpret other filesystem-specific
613 * per-partition information.
615 #define BSD_FS_UNUSED 0 /* unused */
616 #define BSD_FS_SWAP 1 /* swap */
617 #define BSD_FS_V6 2 /* Sixth Edition */
618 #define BSD_FS_V7 3 /* Seventh Edition */
619 #define BSD_FS_SYSV 4 /* System V */
620 #define BSD_FS_V71K 5 /* V7 with 1K blocks (4.1, 2.9) */
621 #define BSD_FS_V8 6 /* Eighth Edition, 4K blocks */
622 #define BSD_FS_BSDFFS 7 /* 4.2BSD fast file system */
623 #define BSD_FS_BSDLFS 9 /* 4.4BSD log-structured file system */
624 #define BSD_FS_OTHER 10 /* in use, but unknown/unsupported */
625 #define BSD_FS_HPFS 11 /* OS/2 high-performance file system */
626 #define BSD_FS_ISO9660 12 /* ISO-9660 filesystem (cdrom) */
627 #define BSD_FS_ISOFS BSD_FS_ISO9660
628 #define BSD_FS_BOOT 13 /* partition contains bootstrap */
629 #define BSD_FS_ADOS 14 /* AmigaDOS fast file system */
630 #define BSD_FS_HFS 15 /* Macintosh HFS */
631 #define BSD_FS_ADVFS 16 /* Digital Unix AdvFS */
633 /* this is annoying, but it's also the way it is :-( */
635 #define BSD_FS_EXT2 8 /* ext2 file system */
637 #define BSD_FS_MSDOS 8 /* MS-DOS file system */
641 static const struct systypes xbsd_fstypes[] = {
642 { "\x00" "unused" }, /* BSD_FS_UNUSED */
643 { "\x01" "swap" }, /* BSD_FS_SWAP */
644 { "\x02" "Version 6" }, /* BSD_FS_V6 */
645 { "\x03" "Version 7" }, /* BSD_FS_V7 */
646 { "\x04" "System V" }, /* BSD_FS_SYSV */
647 { "\x05" "4.1BSD" }, /* BSD_FS_V71K */
648 { "\x06" "Eighth Edition" }, /* BSD_FS_V8 */
649 { "\x07" "4.2BSD" }, /* BSD_FS_BSDFFS */
651 { "\x08" "ext2" }, /* BSD_FS_EXT2 */
653 { "\x08" "MS-DOS" }, /* BSD_FS_MSDOS */
655 { "\x09" "4.4LFS" }, /* BSD_FS_BSDLFS */
656 { "\x0a" "unknown" }, /* BSD_FS_OTHER */
657 { "\x0b" "HPFS" }, /* BSD_FS_HPFS */
658 { "\x0c" "ISO-9660" }, /* BSD_FS_ISO9660 */
659 { "\x0d" "boot" }, /* BSD_FS_BOOT */
660 { "\x0e" "ADOS" }, /* BSD_FS_ADOS */
661 { "\x0f" "HFS" }, /* BSD_FS_HFS */
662 { "\x10" "AdvFS" }, /* BSD_FS_ADVFS */
665 #define BSD_FSMAXTYPES (SIZE(xbsd_fstypes)-1)
670 * flags shared by various drives:
672 #define BSD_D_REMOVABLE 0x01 /* removable media */
673 #define BSD_D_ECC 0x02 /* supports ECC */
674 #define BSD_D_BADSECT 0x04 /* supports bad sector forw. */
675 #define BSD_D_RAMDISK 0x08 /* disk emulator */
676 #define BSD_D_CHAIN 0x10 /* can do back-back transfers */
677 #define BSD_D_DOSPART 0x20 /* within MSDOS partition */
679 #endif /* OSF_LABEL */
682 * Copyright (C) Andreas Neuper, Sep 1998.
683 * This file may be modified and redistributed under
684 * the terms of the GNU Public License.
687 struct device_parameter { /* 48 bytes */
691 unsigned char sparecyl;
692 unsigned short pcylcount;
693 unsigned short head_vol0;
694 unsigned short ntrks; /* tracks in cyl 0 or vol 0 */
695 unsigned char cmd_tag_queue_depth;
696 unsigned char unused0;
697 unsigned short unused1;
698 unsigned short nsect; /* sectors/tracks in cyl 0 or vol 0 */
699 unsigned short bytes;
700 unsigned short ilfact;
701 unsigned int flags; /* controller flags */
702 unsigned int datarate;
703 unsigned int retries_on_error;
704 unsigned int ms_per_word;
705 unsigned short xylogics_gap1;
706 unsigned short xylogics_syncdelay;
707 unsigned short xylogics_readdelay;
708 unsigned short xylogics_gap2;
709 unsigned short xylogics_readgate;
710 unsigned short xylogics_writecont;
713 #define SGI_VOLHDR 0x00
714 /* 1 and 2 were used for drive types no longer supported by SGI */
715 #define SGI_SWAP 0x03
716 /* 4 and 5 were for filesystem types SGI haven't ever supported on MIPS CPUs */
717 #define SGI_VOLUME 0x06
719 #define SGI_LVOL 0x08
720 #define SGI_RLVOL 0x09
722 #define SGI_XFSLOG 0x0b
725 #define ENTIRE_DISK SGI_VOLUME
729 #define SECTOR_SLIP 0x01
730 #define SECTOR_FWD 0x02
731 #define TRACK_FWD 0x04
732 #define TRACK_MULTIVOL 0x08
733 #define IGNORE_ERRORS 0x10
735 #define ENABLE_CMDTAGQ 0x40
738 unsigned int magic; /* expect SGI_LABEL_MAGIC */
739 unsigned short boot_part; /* active boot partition */
740 unsigned short swap_part; /* active swap partition */
741 unsigned char boot_file[16]; /* name of the bootfile */
742 struct device_parameter devparam; /* 1 * 48 bytes */
743 struct volume_directory { /* 15 * 16 bytes */
744 unsigned char vol_file_name[8]; /* a character array */
745 unsigned int vol_file_start; /* number of logical block */
746 unsigned int vol_file_size; /* number of bytes */
748 struct sgi_partition { /* 16 * 12 bytes */
749 unsigned int num_sectors; /* number of blocks */
750 unsigned int start_sector; /* must be cylinder aligned */
754 unsigned int fillbytes;
758 unsigned int magic; /* looks like a magic number */
767 unsigned char scsi_string[50];
768 unsigned char serial[137];
769 unsigned short check1816;
770 unsigned char installer[225];
773 #define SGI_LABEL_MAGIC 0x0be5a941
774 #define SGI_LABEL_MAGIC_SWAPPED 0x41a9e50b
775 #define SGI_INFO_MAGIC 0x00072959
776 #define SGI_INFO_MAGIC_SWAPPED 0x59290700
777 #define SGI_SSWAP16(x) (sgi_other_endian ? __swap16(x) \
779 #define SGI_SSWAP32(x) (sgi_other_endian ? __swap32(x) \
782 #define sgilabel ((sgi_partition *)MBRbuffer)
783 #define sgiparam (sgilabel->devparam)
786 unsigned char info[128]; /* Informative text string */
787 unsigned char spare0[14];
789 unsigned char spare1;
791 unsigned char spare2;
794 unsigned char spare1[246]; /* Boot information etc. */
795 unsigned short rspeed; /* Disk rotational speed */
796 unsigned short pcylcount; /* Physical cylinder count */
797 unsigned short sparecyl; /* extra sects per cylinder */
798 unsigned char spare2[4]; /* More magic... */
799 unsigned short ilfact; /* Interleave factor */
800 unsigned short ncyl; /* Data cylinder count */
801 unsigned short nacyl; /* Alt. cylinder count */
802 unsigned short ntrks; /* Tracks per cylinder */
803 unsigned short nsect; /* Sectors per track */
804 unsigned char spare3[4]; /* Even more magic... */
805 struct sun_partition {
806 uint32_t start_cylinder;
807 uint32_t num_sectors;
809 unsigned short magic; /* Magic number */
810 unsigned short csum; /* Label xor'd checksum */
814 #define SUN_LABEL_MAGIC 0xDABE
815 #define SUN_LABEL_MAGIC_SWAPPED 0xBEDA
816 #define sunlabel ((sun_partition *)MBRbuffer)
817 #define SUN_SSWAP16(x) (sun_other_endian ? __swap16(x) \
819 #define SUN_SSWAP32(x) (sun_other_endian ? __swap32(x) \
823 #ifdef CONFIG_FEATURE_OSF_LABEL
826 19990319 - Arnaldo Carvalho de Melo <acme@conectiva.com.br> - i18n/nls
828 20000101 - David Huggins-Daines <dhuggins@linuxcare.com> - Better
829 support for OSF/1 disklabels on Alpha.
830 Also fixed unaligned accesses in alpha_bootblock_checksum()
833 #define FREEBSD_PARTITION 0xa5
834 #define NETBSD_PARTITION 0xa9
836 static void xbsd_delete_part(void);
837 static void xbsd_new_part(void);
838 static void xbsd_write_disklabel(void);
839 static int xbsd_create_disklabel(void);
840 static void xbsd_edit_disklabel(void);
841 static void xbsd_write_bootstrap(void);
842 static void xbsd_change_fstype(void);
843 static int xbsd_get_part_index(int max);
844 static int xbsd_check_new_partition(int *i);
845 static void xbsd_list_types(void);
846 static u_short xbsd_dkcksum(struct xbsd_disklabel *lp);
847 static int xbsd_initlabel(struct partition *p, struct xbsd_disklabel *d);
848 static int xbsd_readlabel(struct partition *p, struct xbsd_disklabel *d);
849 static int xbsd_writelabel(struct partition *p, struct xbsd_disklabel *d);
851 #if defined (__alpha__)
852 static void alpha_bootblock_checksum(char *boot);
855 #if !defined (__alpha__)
856 static int xbsd_translate_fstype(int linux_type);
857 static void xbsd_link_part(void);
858 static struct partition *xbsd_part;
859 static int xbsd_part_index;
862 #if defined (__alpha__)
863 /* We access this through a uint64_t * when checksumming */
864 static char disklabelbuffer[BSD_BBSIZE] ATTRIBUTE_ALIGNED(8);
866 static char disklabelbuffer[BSD_BBSIZE];
869 static struct xbsd_disklabel xbsd_dlabel;
871 #define bsd_cround(n) \
872 (display_in_cyl_units ? ((n)/xbsd_dlabel.d_secpercyl) + 1 : (n))
875 * Test whether the whole disk has BSD disk label magic.
877 * Note: often reformatting with DOS-type label leaves the BSD magic,
878 * so this does not mean that there is a BSD disk label.
881 check_osf_label(void)
883 if (xbsd_readlabel(NULL, &xbsd_dlabel) == 0)
888 static void xbsd_print_disklabel(int);
891 btrydev(const char * dev)
893 if (xbsd_readlabel (NULL, &xbsd_dlabel) == 0)
895 printf(_("\nBSD label for device: %s\n"), dev);
896 xbsd_print_disklabel (0);
903 puts (_("Command action"));
904 puts (_("\td\tdelete a BSD partition"));
905 puts (_("\te\tedit drive data"));
906 puts (_("\ti\tinstall bootstrap"));
907 puts (_("\tl\tlist known filesystem types"));
908 puts (_("\tm\tprint this menu"));
909 puts (_("\tn\tadd a new BSD partition"));
910 puts (_("\tp\tprint BSD partition table"));
911 puts (_("\tq\tquit without saving changes"));
912 puts (_("\tr\treturn to main menu"));
913 puts (_("\ts\tshow complete disklabel"));
914 puts (_("\tt\tchange a partition's filesystem id"));
915 puts (_("\tu\tchange units (cylinders/sectors)"));
916 puts (_("\tw\twrite disklabel to disk"));
917 #if !defined (__alpha__)
918 puts (_("\tx\tlink BSD partition to non-BSD partition"));
922 #if !defined (__alpha__)
930 is_bsd_partition_type(int type)
932 return (type == FREEBSD_PARTITION ||
933 type == hidden(FREEBSD_PARTITION) ||
934 type == NETBSD_PARTITION ||
935 type == hidden(NETBSD_PARTITION));
942 #if !defined (__alpha__)
946 for (t = 0; t < 4; t++) {
947 p = get_part_table(t);
948 if (p && is_bsd_partition_type(p->sys_ind)) {
951 ss = get_start_sect(xbsd_part);
953 fprintf(stderr, _("Partition %s has invalid starting sector 0.\n"),
954 partname(disk_device, t+1, 0));
957 printf(_("Reading disklabel of %s at sector %d.\n"),
958 partname(disk_device, t+1, 0), ss + BSD_LABELSECTOR);
959 if (xbsd_readlabel(xbsd_part, &xbsd_dlabel) == 0)
960 if (xbsd_create_disklabel() == 0)
967 printf(_("There is no *BSD partition on %s.\n"), disk_device);
971 #elif defined (__alpha__)
973 if (xbsd_readlabel(NULL, &xbsd_dlabel) == 0)
974 if (xbsd_create_disklabel() == 0)
981 switch (tolower(read_char(_("BSD disklabel command (m for help): ")))) {
986 xbsd_edit_disklabel();
989 xbsd_write_bootstrap();
998 xbsd_print_disklabel(0);
1006 xbsd_print_disklabel(1);
1009 xbsd_change_fstype();
1015 xbsd_write_disklabel();
1017 #if !defined (__alpha__)
1030 xbsd_delete_part(void)
1034 i = xbsd_get_part_index(xbsd_dlabel.d_npartitions);
1035 xbsd_dlabel.d_partitions[i].p_size = 0;
1036 xbsd_dlabel.d_partitions[i].p_offset = 0;
1037 xbsd_dlabel.d_partitions[i].p_fstype = BSD_FS_UNUSED;
1038 if (xbsd_dlabel.d_npartitions == i + 1)
1039 while (xbsd_dlabel.d_partitions[xbsd_dlabel.d_npartitions-1].p_size == 0)
1040 xbsd_dlabel.d_npartitions--;
1050 if (!xbsd_check_new_partition(&i))
1053 #if !defined (__alpha__) && !defined (__powerpc__) && !defined (__hppa__)
1054 begin = get_start_sect(xbsd_part);
1055 end = begin + get_nr_sects(xbsd_part) - 1;
1058 end = xbsd_dlabel.d_secperunit - 1;
1061 snprintf(mesg, sizeof(mesg), _("First %s"), str_units(SINGULAR));
1062 begin = read_int(bsd_cround(begin), bsd_cround(begin), bsd_cround(end),
1065 if (display_in_cyl_units)
1066 begin = (begin - 1) * xbsd_dlabel.d_secpercyl;
1068 snprintf(mesg, sizeof(mesg), _("Last %s or +size or +sizeM or +sizeK"),
1069 str_units(SINGULAR));
1070 end = read_int(bsd_cround (begin), bsd_cround (end), bsd_cround (end),
1071 bsd_cround (begin), mesg);
1073 if (display_in_cyl_units)
1074 end = end * xbsd_dlabel.d_secpercyl - 1;
1076 xbsd_dlabel.d_partitions[i].p_size = end - begin + 1;
1077 xbsd_dlabel.d_partitions[i].p_offset = begin;
1078 xbsd_dlabel.d_partitions[i].p_fstype = BSD_FS_UNUSED;
1082 xbsd_print_disklabel(int show_all)
1084 struct xbsd_disklabel *lp = &xbsd_dlabel;
1085 struct xbsd_partition *pp;
1089 #if defined (__alpha__)
1090 printf("# %s:\n", disk_device);
1092 printf("# %s:\n", partname(disk_device, xbsd_part_index+1, 0));
1094 if ((unsigned) lp->d_type < BSD_DKMAXTYPES)
1095 printf(_("type: %s\n"), xbsd_dktypenames[lp->d_type]);
1097 printf(_("type: %d\n"), lp->d_type);
1098 printf(_("disk: %.*s\n"), (int) sizeof(lp->d_typename), lp->d_typename);
1099 printf(_("label: %.*s\n"), (int) sizeof(lp->d_packname), lp->d_packname);
1100 printf(_("flags:"));
1101 if (lp->d_flags & BSD_D_REMOVABLE)
1102 printf(_(" removable"));
1103 if (lp->d_flags & BSD_D_ECC)
1105 if (lp->d_flags & BSD_D_BADSECT)
1106 printf(_(" badsect"));
1108 /* On various machines the fields of *lp are short/int/long */
1109 /* In order to avoid problems, we cast them all to long. */
1110 printf(_("bytes/sector: %ld\n"), (long) lp->d_secsize);
1111 printf(_("sectors/track: %ld\n"), (long) lp->d_nsectors);
1112 printf(_("tracks/cylinder: %ld\n"), (long) lp->d_ntracks);
1113 printf(_("sectors/cylinder: %ld\n"), (long) lp->d_secpercyl);
1114 printf(_("cylinders: %ld\n"), (long) lp->d_ncylinders);
1115 printf(_("rpm: %d\n"), lp->d_rpm);
1116 printf(_("interleave: %d\n"), lp->d_interleave);
1117 printf(_("trackskew: %d\n"), lp->d_trackskew);
1118 printf(_("cylinderskew: %d\n"), lp->d_cylskew);
1119 printf(_("headswitch: %ld\t\t# milliseconds\n"),
1120 (long) lp->d_headswitch);
1121 printf(_("track-to-track seek: %ld\t# milliseconds\n"),
1122 (long) lp->d_trkseek);
1123 printf(_("drivedata: "));
1124 for (i = NDDATA - 1; i >= 0; i--)
1125 if (lp->d_drivedata[i])
1129 for (j = 0; j <= i; j++)
1130 printf("%ld ", (long) lp->d_drivedata[j]);
1132 printf(_("\n%d partitions:\n"), lp->d_npartitions);
1133 printf(_("# start end size fstype [fsize bsize cpg]\n"));
1134 pp = lp->d_partitions;
1135 for (i = 0; i < lp->d_npartitions; i++, pp++) {
1137 if (display_in_cyl_units && lp->d_secpercyl) {
1138 printf(" %c: %8ld%c %8ld%c %8ld%c ",
1140 (long) pp->p_offset / lp->d_secpercyl + 1,
1141 (pp->p_offset % lp->d_secpercyl) ? '*' : ' ',
1142 (long) (pp->p_offset + pp->p_size + lp->d_secpercyl - 1) / lp->d_secpercyl,
1143 ((pp->p_offset + pp->p_size) % lp->d_secpercyl) ? '*' : ' ',
1144 (long) pp->p_size / lp->d_secpercyl,
1145 (pp->p_size % lp->d_secpercyl) ? '*' : ' '
1148 printf(" %c: %8ld %8ld %8ld ",
1150 (long) pp->p_offset,
1151 (long) pp->p_offset + pp->p_size - 1,
1156 if ((unsigned) pp->p_fstype < BSD_FSMAXTYPES)
1157 printf("%8.8s", xbsd_fstypes[pp->p_fstype].name);
1159 printf("%8x", pp->p_fstype);
1161 switch (pp->p_fstype) {
1163 printf(" %5ld %5ld %5.5s ",
1164 (long) pp->p_fsize, (long) pp->p_fsize * pp->p_frag, "");
1167 printf(" %5ld %5ld %5d ",
1168 (long) pp->p_fsize, (long) pp->p_fsize * pp->p_frag, pp->p_cpg);
1171 printf("%22.22s", "");
1180 xbsd_write_disklabel(void)
1182 #if defined (__alpha__)
1183 printf(_("Writing disklabel to %s.\n"), disk_device);
1184 xbsd_writelabel(NULL, &xbsd_dlabel);
1186 printf(_("Writing disklabel to %s.\n"),
1187 partname(disk_device, xbsd_part_index + 1, 0));
1188 xbsd_writelabel(xbsd_part, &xbsd_dlabel);
1190 reread_partition_table(0); /* no exit yet */
1194 xbsd_create_disklabel(void)
1198 #if defined (__alpha__)
1199 fprintf(stderr, _("%s contains no disklabel.\n"), disk_device);
1201 fprintf(stderr, _("%s contains no disklabel.\n"),
1202 partname(disk_device, xbsd_part_index + 1, 0));
1206 c = read_char(_("Do you want to create a disklabel? (y/n) "));
1207 if (c == 'y' || c == 'Y') {
1209 #if defined (__alpha__) || defined (__powerpc__) || defined (__hppa__) || \
1210 defined (__s390__) || defined (__s390x__)
1213 xbsd_part, &xbsd_dlabel/* not used, xbsd_part_index*/
1216 xbsd_print_disklabel (1);
1220 } else if (c == 'n')
1226 edit_int(int def, char *mesg)
1229 fputs(mesg, stdout);
1230 printf(" (%d): ", def);
1234 while (!isdigit(*line_ptr)); /* FIXME: ?!! */
1235 return atoi(line_ptr);
1239 xbsd_edit_disklabel(void)
1241 struct xbsd_disklabel *d;
1245 #if defined (__alpha__) || defined (__ia64__)
1246 d->d_secsize = (u_long) edit_int((u_long) d->d_secsize ,_("bytes/sector"));
1247 d->d_nsectors = (u_long) edit_int((u_long) d->d_nsectors ,_("sectors/track"));
1248 d->d_ntracks = (u_long) edit_int((u_long) d->d_ntracks ,_("tracks/cylinder"));
1249 d->d_ncylinders = (u_long) edit_int((u_long) d->d_ncylinders ,_("cylinders"));
1252 /* d->d_secpercyl can be != d->d_nsectors * d->d_ntracks */
1254 d->d_secpercyl = (u_long) edit_int((u_long) d->d_nsectors * d->d_ntracks,
1255 _("sectors/cylinder"));
1256 if (d->d_secpercyl <= d->d_nsectors * d->d_ntracks)
1259 printf(_("Must be <= sectors/track * tracks/cylinder (default).\n"));
1261 d->d_rpm = (u_short) edit_int((u_short) d->d_rpm ,_("rpm"));
1262 d->d_interleave = (u_short) edit_int((u_short) d->d_interleave,_("interleave"));
1263 d->d_trackskew = (u_short) edit_int((u_short) d->d_trackskew ,_("trackskew"));
1264 d->d_cylskew = (u_short) edit_int((u_short) d->d_cylskew ,_("cylinderskew"));
1265 d->d_headswitch = (u_long) edit_int((u_long) d->d_headswitch ,_("headswitch"));
1266 d->d_trkseek = (u_long) edit_int((u_long) d->d_trkseek ,_("track-to-track seek"));
1268 d->d_secperunit = d->d_secpercyl * d->d_ncylinders;
1272 xbsd_get_bootstrap (char *path, void *ptr, int size)
1276 if ((fdb = open (path, O_RDONLY)) < 0) {
1280 if (read(fdb, ptr, size) < 0) {
1285 printf(" ... %s\n", path);
1293 printf(_("\nSyncing disks.\n"));
1295 sleep(4); /* What? */
1299 xbsd_write_bootstrap(void)
1301 char *bootdir = BSD_LINUX_BOOTDIR;
1302 char path[MAXPATHLEN];
1304 struct xbsd_disklabel dl;
1308 if (xbsd_dlabel.d_type == BSD_DTYPE_SCSI)
1313 printf(_("Bootstrap: %sboot -> boot%s (%s): "),
1314 dkbasename, dkbasename, dkbasename);
1316 line_ptr[strlen(line_ptr)-1] = '\0';
1317 dkbasename = line_ptr;
1319 snprintf(path, sizeof(path), "%s/%sboot", bootdir, dkbasename);
1320 if (!xbsd_get_bootstrap(path, disklabelbuffer, (int) xbsd_dlabel.d_secsize))
1323 /* We need a backup of the disklabel (xbsd_dlabel might have changed). */
1324 d = &disklabelbuffer[BSD_LABELSECTOR * SECTOR_SIZE];
1325 memmove(&dl, d, sizeof(struct xbsd_disklabel));
1327 /* The disklabel will be overwritten by 0's from bootxx anyway */
1328 memset(d, 0, sizeof(struct xbsd_disklabel));
1330 snprintf(path, sizeof(path), "%s/boot%s", bootdir, dkbasename);
1331 if (!xbsd_get_bootstrap (path, &disklabelbuffer[xbsd_dlabel.d_secsize],
1332 (int) xbsd_dlabel.d_bbsize - xbsd_dlabel.d_secsize))
1335 e = d + sizeof(struct xbsd_disklabel);
1336 for (p = d; p < e; p++)
1338 fprintf(stderr, _("Bootstrap overlaps with disk label!\n"));
1342 memmove(d, &dl, sizeof(struct xbsd_disklabel));
1344 #if defined (__powerpc__) || defined (__hppa__)
1346 #elif defined (__alpha__)
1348 alpha_bootblock_checksum(disklabelbuffer);
1350 sector = get_start_sect(xbsd_part);
1353 if (lseek(fd, sector * SECTOR_SIZE, SEEK_SET) == -1)
1354 fdisk_fatal(unable_to_seek);
1355 if (BSD_BBSIZE != write(fd, disklabelbuffer, BSD_BBSIZE))
1356 fdisk_fatal(unable_to_write);
1358 #if defined (__alpha__)
1359 printf(_("Bootstrap installed on %s.\n"), disk_device);
1361 printf(_("Bootstrap installed on %s.\n"),
1362 partname (disk_device, xbsd_part_index+1, 0));
1369 xbsd_change_fstype(void)
1373 i = xbsd_get_part_index(xbsd_dlabel.d_npartitions);
1374 xbsd_dlabel.d_partitions[i].p_fstype = read_hex(xbsd_fstypes);
1378 xbsd_get_part_index(int max)
1383 snprintf(prompt, sizeof(prompt), _("Partition (a-%c): "), 'a' + max - 1);
1385 l = tolower(read_char(prompt));
1386 while (l < 'a' || l > 'a' + max - 1);
1391 xbsd_check_new_partition(int *i)
1393 /* room for more? various BSD flavours have different maxima */
1394 if (xbsd_dlabel.d_npartitions == BSD_MAXPARTITIONS) {
1397 for (t = 0; t < BSD_MAXPARTITIONS; t++)
1398 if (xbsd_dlabel.d_partitions[t].p_size == 0)
1401 if (t == BSD_MAXPARTITIONS) {
1402 fprintf(stderr, _("The maximum number of partitions "
1403 "has been created\n"));
1408 *i = xbsd_get_part_index (BSD_MAXPARTITIONS);
1410 if (*i >= xbsd_dlabel.d_npartitions)
1411 xbsd_dlabel.d_npartitions = (*i) + 1;
1413 if (xbsd_dlabel.d_partitions[*i].p_size != 0) {
1414 fprintf(stderr, _("This partition already exists.\n"));
1422 xbsd_list_types(void)
1424 list_types(xbsd_fstypes);
1428 xbsd_dkcksum(struct xbsd_disklabel *lp)
1430 u_short *start, *end;
1433 start = (u_short *) lp;
1434 end = (u_short *) &lp->d_partitions[lp->d_npartitions];
1441 xbsd_initlabel(struct partition *p, struct xbsd_disklabel *d)
1443 struct xbsd_partition *pp;
1446 memset(d, 0, sizeof(struct xbsd_disklabel));
1448 d->d_magic = BSD_DISKMAGIC;
1450 if (strncmp(disk_device, "/dev/sd", 7) == 0)
1451 d->d_type = BSD_DTYPE_SCSI;
1453 d->d_type = BSD_DTYPE_ST506;
1455 #if 0 /* not used (at least not written to disk) by NetBSD/i386 1.0 */
1456 d->d_subtype = BSD_DSTYPE_INDOSPART & pindex;
1459 #if !defined (__alpha__)
1460 d->d_flags = BSD_D_DOSPART;
1464 d->d_secsize = SECTOR_SIZE; /* bytes/sector */
1465 d->d_nsectors = sectors; /* sectors/track */
1466 d->d_ntracks = heads; /* tracks/cylinder (heads) */
1467 d->d_ncylinders = cylinders;
1468 d->d_secpercyl = sectors * heads;/* sectors/cylinder */
1469 if (d->d_secpercyl == 0)
1470 d->d_secpercyl = 1; /* avoid segfaults */
1471 d->d_secperunit = d->d_secpercyl * d->d_ncylinders;
1474 d->d_interleave = 1;
1477 d->d_headswitch = 0;
1480 d->d_magic2 = BSD_DISKMAGIC;
1481 d->d_bbsize = BSD_BBSIZE;
1482 d->d_sbsize = BSD_SBSIZE;
1484 #if !defined (__alpha__)
1485 d->d_npartitions = 4;
1486 pp = &d->d_partitions[2]; /* Partition C should be
1487 the NetBSD partition */
1488 pp->p_offset = get_start_sect(p);
1489 pp->p_size = get_nr_sects(p);
1490 pp->p_fstype = BSD_FS_UNUSED;
1491 pp = &d->d_partitions[3]; /* Partition D should be
1494 pp->p_size = d->d_secperunit;
1495 pp->p_fstype = BSD_FS_UNUSED;
1496 #elif defined (__alpha__)
1497 d->d_npartitions = 3;
1498 pp = &d->d_partitions[2]; /* Partition C should be
1501 pp->p_size = d->d_secperunit;
1502 pp->p_fstype = BSD_FS_UNUSED;
1509 * Read a xbsd_disklabel from sector 0 or from the starting sector of p.
1510 * If it has the right magic, return 1.
1513 xbsd_readlabel (struct partition *p, struct xbsd_disklabel *d)
1517 /* p is used only to get the starting sector */
1518 #if !defined (__alpha__)
1519 sector = (p ? get_start_sect(p) : 0);
1520 #elif defined (__alpha__)
1524 if (lseek(fd, sector * SECTOR_SIZE, SEEK_SET) == -1)
1525 fdisk_fatal(unable_to_seek);
1526 if (BSD_BBSIZE != read(fd, disklabelbuffer, BSD_BBSIZE))
1527 fdisk_fatal(unable_to_read);
1529 memmove(d, &disklabelbuffer[BSD_LABELSECTOR * SECTOR_SIZE + BSD_LABELOFFSET],
1530 sizeof(struct xbsd_disklabel));
1532 if (d->d_magic != BSD_DISKMAGIC || d->d_magic2 != BSD_DISKMAGIC)
1535 for (t = d->d_npartitions; t < BSD_MAXPARTITIONS; t++) {
1536 d->d_partitions[t].p_size = 0;
1537 d->d_partitions[t].p_offset = 0;
1538 d->d_partitions[t].p_fstype = BSD_FS_UNUSED;
1541 if (d->d_npartitions > BSD_MAXPARTITIONS)
1542 fprintf(stderr, _("Warning: too many partitions "
1543 "(%d, maximum is %d).\n"),
1544 d->d_npartitions, BSD_MAXPARTITIONS);
1549 xbsd_writelabel (struct partition *p, struct xbsd_disklabel *d)
1551 unsigned int sector;
1553 #if !defined (__alpha__) && !defined (__powerpc__) && !defined (__hppa__)
1554 sector = get_start_sect(p) + BSD_LABELSECTOR;
1556 sector = BSD_LABELSECTOR;
1560 d->d_checksum = xbsd_dkcksum (d);
1562 /* This is necessary if we want to write the bootstrap later,
1563 otherwise we'd write the old disklabel with the bootstrap.
1565 memmove(&disklabelbuffer[BSD_LABELSECTOR * SECTOR_SIZE + BSD_LABELOFFSET],
1566 d, sizeof(struct xbsd_disklabel));
1568 #if defined (__alpha__) && BSD_LABELSECTOR == 0
1569 alpha_bootblock_checksum (disklabelbuffer);
1570 if (lseek(fd, 0, SEEK_SET) == -1)
1571 fdisk_fatal(unable_to_seek);
1572 if (BSD_BBSIZE != write(fd, disklabelbuffer, BSD_BBSIZE))
1573 fdisk_fatal(unable_to_write);
1575 if (lseek(fd, sector * SECTOR_SIZE + BSD_LABELOFFSET, SEEK_SET) == -1)
1576 fdisk_fatal(unable_to_seek);
1577 if (sizeof(struct xbsd_disklabel) != write(fd, d, sizeof(struct xbsd_disklabel)))
1578 fdisk_fatal(unable_to_write);
1585 #if !defined (__alpha__)
1587 xbsd_translate_fstype(int linux_type)
1589 switch (linux_type) {
1590 case 0x01: /* DOS 12-bit FAT */
1591 case 0x04: /* DOS 16-bit <32M */
1592 case 0x06: /* DOS 16-bit >=32M */
1593 case 0xe1: /* DOS access */
1594 case 0xe3: /* DOS R/O */
1595 case 0xf2: /* DOS secondary */
1596 return BSD_FS_MSDOS;
1597 case 0x07: /* OS/2 HPFS */
1600 return BSD_FS_OTHER;
1605 xbsd_link_part(void)
1608 struct partition *p;
1610 k = get_partition(1, partitions);
1612 if (!xbsd_check_new_partition(&i))
1615 p = get_part_table(k);
1617 xbsd_dlabel.d_partitions[i].p_size = get_nr_sects(p);
1618 xbsd_dlabel.d_partitions[i].p_offset = get_start_sect(p);
1619 xbsd_dlabel.d_partitions[i].p_fstype = xbsd_translate_fstype(p->sys_ind);
1623 #if defined (__alpha__)
1625 #if !defined(__GLIBC__)
1626 typedef unsigned long long uint64_t;
1630 alpha_bootblock_checksum(char *boot)
1635 dp = (uint64_t *)boot;
1637 for (i = 0; i < 63; i++)
1641 #endif /* __alpha__ */
1643 #endif /* OSF_LABEL */
1645 #if defined(CONFIG_FEATURE_SGI_LABEL) || defined(CONFIG_FEATURE_SUN_LABEL)
1646 static inline unsigned short
1647 __swap16(unsigned short x)
1649 return (((uint16_t)(x) & 0xFF) << 8) | (((uint16_t)(x) & 0xFF00) >> 8);
1652 static inline uint32_t
1653 __swap32(uint32_t x)
1655 return (((x & 0xFF) << 24) |
1656 ((x & 0xFF00) << 8) |
1657 ((x & 0xFF0000) >> 8) |
1658 ((x & 0xFF000000) >> 24));
1662 #ifdef CONFIG_FEATURE_SGI_LABEL
1667 * Copyright (C) Andreas Neuper, Sep 1998.
1668 * This file may be modified and redistributed under
1669 * the terms of the GNU Public License.
1671 * Sat Mar 20 EST 1999 Arnaldo Carvalho de Melo <acme@conectiva.com.br>
1672 * Internationalization
1676 static int sgi_other_endian;
1678 static short sgi_volumes = 1;
1681 * only dealing with free blocks here
1688 static freeblocks freelist[17]; /* 16 partitions can produce 17 vacant slots */
1691 setfreelist(int i, unsigned int f, unsigned int l)
1693 freelist[i].first = f;
1694 freelist[i].last = l;
1698 add2freelist(unsigned int f, unsigned int l)
1701 for (i = 0; i < 17 ; i++)
1702 if (freelist[i].last == 0)
1704 setfreelist(i, f, l);
1712 for (i = 0; i < 17 ; i++)
1713 setfreelist(i, 0, 0);
1717 isinfreelist(unsigned int b)
1721 for (i = 0; i < 17 ; i++)
1722 if (freelist[i].first <= b && freelist[i].last >= b)
1723 return freelist[i].last;
1726 /* return last vacant block of this stride (never 0). */
1727 /* the '>=' is not quite correct, but simplifies the code */
1729 * end of free blocks section
1732 static const struct systypes sgi_sys_types[] = {
1733 /* SGI_VOLHDR */ { "\x00" "SGI volhdr" },
1734 /* 0x01 */ { "\x01" "SGI trkrepl" },
1735 /* 0x02 */ { "\x02" "SGI secrepl" },
1736 /* SGI_SWAP */ { "\x03" "SGI raw" },
1737 /* 0x04 */ { "\x04" "SGI bsd" },
1738 /* 0x05 */ { "\x05" "SGI sysv" },
1739 /* ENTIRE_DISK */ { "\x06" "SGI volume" },
1740 /* SGI_EFS */ { "\x07" "SGI efs" },
1741 /* 0x08 */ { "\x08" "SGI lvol" },
1742 /* 0x09 */ { "\x09" "SGI rlvol" },
1743 /* SGI_XFS */ { "\x0a" "SGI xfs" },
1744 /* SGI_XFSLOG */ { "\x0b" "SGI xfslog" },
1745 /* SGI_XLV */ { "\x0c" "SGI xlv" },
1746 /* SGI_XVM */ { "\x0d" "SGI xvm" },
1747 /* LINUX_SWAP */ { "\x82" "Linux swap" },
1748 /* LINUX_NATIVE */ { "\x83" "Linux native" },
1749 /* LINUX_LVM */ { "\x8d" "Linux LVM" },
1750 /* LINUX_RAID */ { "\xfd" "Linux RAID" },
1758 return SGI_SSWAP16(sgilabel->devparam.nsect);
1764 return SGI_SSWAP16(sgilabel->devparam.ntrks);
1768 two_s_complement_32bit_sum(unsigned int* base, int size /* in bytes */)
1771 unsigned int sum = 0;
1773 size /= sizeof(unsigned int);
1774 for (i = 0; i < size; i++)
1775 sum -= SGI_SSWAP32(base[i]);
1780 check_sgi_label(void)
1782 if (sizeof(sgilabel) > 512) {
1784 _("According to MIPS Computer Systems, Inc the "
1785 "Label must not contain more than 512 bytes\n"));
1789 if (sgilabel->magic != SGI_LABEL_MAGIC
1790 && sgilabel->magic != SGI_LABEL_MAGIC_SWAPPED) {
1791 current_label_type = label_dos;
1795 sgi_other_endian = (sgilabel->magic == SGI_LABEL_MAGIC_SWAPPED);
1797 * test for correct checksum
1799 if (two_s_complement_32bit_sum((unsigned int*)sgilabel,
1800 sizeof(*sgilabel))) {
1802 _("Detected sgi disklabel with wrong checksum.\n"));
1805 current_label_type = label_sgi;
1812 sgi_get_start_sector(int i)
1814 return SGI_SSWAP32(sgilabel->partitions[i].start_sector);
1818 sgi_get_num_sectors(int i)
1820 return SGI_SSWAP32(sgilabel->partitions[i].num_sectors);
1824 sgi_get_sysid(int i)
1826 return SGI_SSWAP32(sgilabel->partitions[i].id);
1830 sgi_get_bootpartition(void)
1832 return SGI_SSWAP16(sgilabel->boot_part);
1836 sgi_get_swappartition(void)
1838 return SGI_SSWAP16(sgilabel->swap_part);
1842 sgi_list_table(int xtra)
1845 int kpi = 0; /* kernel partition ID */
1848 printf(_("\nDisk %s (SGI disk label): %d heads, %d sectors\n"
1849 "%d cylinders, %d physical cylinders\n"
1850 "%d extra sects/cyl, interleave %d:1\n"
1852 "Units = %s of %d * 512 bytes\n\n"),
1853 disk_device, heads, sectors, cylinders,
1854 SGI_SSWAP16(sgiparam.pcylcount),
1855 SGI_SSWAP16(sgiparam.sparecyl),
1856 SGI_SSWAP16(sgiparam.ilfact),
1858 str_units(PLURAL), units_per_sector);
1860 printf( _("\nDisk %s (SGI disk label): "
1861 "%d heads, %d sectors, %d cylinders\n"
1862 "Units = %s of %d * 512 bytes\n\n"),
1863 disk_device, heads, sectors, cylinders,
1864 str_units(PLURAL), units_per_sector );
1867 w = strlen(disk_device);
1868 wd = strlen(_("Device"));
1872 printf(_("----- partitions -----\n"
1873 "Pt# %*s Info Start End Sectors Id System\n"),
1874 w + 2, _("Device"));
1875 for (i = 0 ; i < partitions; i++) {
1876 if( sgi_get_num_sectors(i) || debug ) {
1877 uint32_t start = sgi_get_start_sector(i);
1878 uint32_t len = sgi_get_num_sectors(i);
1879 kpi++; /* only count nonempty partitions */
1881 "%2d: %s %4s %9ld %9ld %9ld %2x %s\n",
1882 /* fdisk part number */ i+1,
1883 /* device */ partname(disk_device, kpi, w+3),
1884 /* flags */ (sgi_get_swappartition() == i) ? "swap" :
1885 /* flags */ (sgi_get_bootpartition() == i) ? "boot" : " ",
1886 /* start */ (long) scround(start),
1887 /* end */ (long) scround(start+len)-1,
1888 /* no odd flag on end */(long) len,
1889 /* type id */ sgi_get_sysid(i),
1890 /* type name */ partition_type(sgi_get_sysid(i)));
1893 printf(_("----- Bootinfo -----\nBootfile: %s\n"
1894 "----- Directory Entries -----\n"),
1895 sgilabel->boot_file);
1896 for (i = 0 ; i < sgi_volumes; i++) {
1897 if (sgilabel->directory[i].vol_file_size) {
1898 uint32_t start = SGI_SSWAP32(sgilabel->directory[i].vol_file_start);
1899 uint32_t len = SGI_SSWAP32(sgilabel->directory[i].vol_file_size);
1900 unsigned char *name = sgilabel->directory[i].vol_file_name;
1902 printf(_("%2d: %-10s sector%5u size%8u\n"),
1903 i, (char*)name, (unsigned int) start, (unsigned int) len);
1909 sgi_set_bootpartition(int i)
1911 sgilabel->boot_part = SGI_SSWAP16(((short)i));
1915 sgi_get_lastblock(void)
1917 return heads * sectors * cylinders;
1921 sgi_set_swappartition(int i)
1923 sgilabel->swap_part = SGI_SSWAP16(((short)i));
1927 sgi_check_bootfile(const char* aFile)
1929 if (strlen(aFile) < 3) /* "/a\n" is minimum */ {
1930 printf(_("\nInvalid Bootfile!\n"
1931 "\tThe bootfile must be an absolute non-zero pathname,\n"
1932 "\te.g. \"/unix\" or \"/unix.save\".\n"));
1935 if (strlen(aFile) > 16) {
1936 printf(_("\n\tName of Bootfile too long: "
1937 "16 bytes maximum.\n"));
1940 if (aFile[0] != '/') {
1941 printf(_("\n\tBootfile must have a "
1942 "fully qualified pathname.\n"));
1947 if (strncmp(aFile, (char*)sgilabel->boot_file, 16)) {
1948 printf(_("\n\tBe aware, that the bootfile is not checked for existence.\n\t"
1949 "SGI's default is \"/unix\" and for backup \"/unix.save\".\n"));
1950 /* filename is correct and did change */
1953 return 0; /* filename did not change */
1957 sgi_get_bootfile(void)
1959 return (char*)sgilabel->boot_file;
1963 sgi_set_bootfile(const char* aFile)
1967 if (sgi_check_bootfile(aFile)) {
1969 if ((aFile[i] != '\n') /* in principle caught again by next line */
1970 && (strlen(aFile) > i))
1971 sgilabel->boot_file[i] = aFile[i];
1973 sgilabel->boot_file[i] = 0;
1976 printf(_("\n\tBootfile is changed to \"%s\".\n"), sgilabel->boot_file);
1981 create_sgiinfo(void)
1983 /* I keep SGI's habit to write the sgilabel to the second block */
1984 sgilabel->directory[0].vol_file_start = SGI_SSWAP32(2);
1985 sgilabel->directory[0].vol_file_size = SGI_SSWAP32(sizeof(sgiinfo));
1986 strncpy((char*)sgilabel->directory[0].vol_file_name, "sgilabel", 8);
1989 static sgiinfo *fill_sgiinfo(void);
1992 sgi_write_table(void)
1995 sgilabel->csum = SGI_SSWAP32(two_s_complement_32bit_sum(
1996 (unsigned int*)sgilabel, sizeof(*sgilabel)));
1997 assert(two_s_complement_32bit_sum(
1998 (unsigned int*)sgilabel, sizeof(*sgilabel)) == 0);
2000 if (lseek(fd, 0, SEEK_SET) < 0)
2001 fdisk_fatal(unable_to_seek);
2002 if (write(fd, sgilabel, SECTOR_SIZE) != SECTOR_SIZE)
2003 fdisk_fatal(unable_to_write);
2004 if (!strncmp((char*)sgilabel->directory[0].vol_file_name, "sgilabel", 8)) {
2006 * keep this habit of first writing the "sgilabel".
2007 * I never tested whether it works without (AN 981002).
2009 sgiinfo *info = fill_sgiinfo();
2010 int infostartblock = SGI_SSWAP32(sgilabel->directory[0].vol_file_start);
2011 if (lseek(fd, infostartblock*SECTOR_SIZE, SEEK_SET) < 0)
2012 fdisk_fatal(unable_to_seek);
2013 if (write(fd, info, SECTOR_SIZE) != SECTOR_SIZE)
2014 fdisk_fatal(unable_to_write);
2020 compare_start(int *x, int *y)
2023 * sort according to start sectors
2024 * and prefers largest partition:
2025 * entry zero is entire disk entry
2027 unsigned int i = *x;
2028 unsigned int j = *y;
2029 unsigned int a = sgi_get_start_sector(i);
2030 unsigned int b = sgi_get_start_sector(j);
2031 unsigned int c = sgi_get_num_sectors(i);
2032 unsigned int d = sgi_get_num_sectors(j);
2035 return (d > c) ? 1 : (d == c) ? 0 : -1;
2036 return (a > b) ? 1 : -1;
2041 verify_sgi(int verbose)
2043 int Index[16]; /* list of valid partitions */
2044 int sortcount = 0; /* number of used partitions, i.e. non-zero lengths */
2045 int entire = 0, i = 0;
2046 unsigned int start = 0;
2047 long long gap = 0; /* count unused blocks */
2048 unsigned int lastblock = sgi_get_lastblock();
2051 for (i = 0; i < 16; i++) {
2052 if (sgi_get_num_sectors(i) != 0) {
2053 Index[sortcount++] = i;
2054 if (sgi_get_sysid(i) == ENTIRE_DISK) {
2055 if (entire++ == 1) {
2057 printf(_("More than one entire disk entry present.\n"));
2062 if (sortcount == 0) {
2064 printf(_("No partitions defined\n"));
2065 return (lastblock > 0) ? 1 : (lastblock == 0) ? 0 : -1;
2067 qsort(Index, sortcount, sizeof(Index[0]), (void*)compare_start);
2068 if (sgi_get_sysid(Index[0]) == ENTIRE_DISK) {
2069 if ((Index[0] != 10) && verbose)
2070 printf(_("IRIX likes when Partition 11 covers the entire disk.\n"));
2071 if ((sgi_get_start_sector(Index[0]) != 0) && verbose)
2072 printf(_("The entire disk partition should start "
2074 "not at diskblock %d.\n"),
2075 sgi_get_start_sector(Index[0]));
2076 if (debug) /* I do not understand how some disks fulfil it */
2077 if ((sgi_get_num_sectors(Index[0]) != lastblock) && verbose)
2078 printf(_("The entire disk partition is only %d diskblock large,\n"
2079 "but the disk is %d diskblocks long.\n"),
2080 sgi_get_num_sectors(Index[0]), lastblock);
2081 lastblock = sgi_get_num_sectors(Index[0]);
2084 printf(_("One Partition (#11) should cover the entire disk.\n"));
2086 printf("sysid=%d\tpartition=%d\n",
2087 sgi_get_sysid(Index[0]), Index[0]+1);
2089 for (i = 1, start = 0; i < sortcount; i++) {
2090 int cylsize = sgi_get_nsect() * sgi_get_ntrks();
2092 if ((sgi_get_start_sector(Index[i]) % cylsize) != 0) {
2093 if (debug) /* I do not understand how some disks fulfil it */
2095 printf(_("Partition %d does not start on cylinder boundary.\n"),
2098 if (sgi_get_num_sectors(Index[i]) % cylsize != 0) {
2099 if (debug) /* I do not understand how some disks fulfil it */
2101 printf(_("Partition %d does not end on cylinder boundary.\n"),
2104 /* We cannot handle several "entire disk" entries. */
2105 if (sgi_get_sysid(Index[i]) == ENTIRE_DISK) continue;
2106 if (start > sgi_get_start_sector(Index[i])) {
2108 printf(_("The Partition %d and %d overlap by %d sectors.\n"),
2109 Index[i-1]+1, Index[i]+1,
2110 start - sgi_get_start_sector(Index[i]));
2111 if (gap > 0) gap = -gap;
2112 if (gap == 0) gap = -1;
2114 if (start < sgi_get_start_sector(Index[i])) {
2116 printf(_("Unused gap of %8u sectors - sectors %8u-%u\n"),
2117 sgi_get_start_sector(Index[i]) - start,
2118 start, sgi_get_start_sector(Index[i])-1);
2119 gap += sgi_get_start_sector(Index[i]) - start;
2120 add2freelist(start, sgi_get_start_sector(Index[i]));
2122 start = sgi_get_start_sector(Index[i])
2123 + sgi_get_num_sectors(Index[i]);
2126 printf("%2d:%12d\t%12d\t%12d\n", Index[i],
2127 sgi_get_start_sector(Index[i]),
2128 sgi_get_num_sectors(Index[i]),
2129 sgi_get_sysid(Index[i]));
2132 if (start < lastblock) {
2134 printf(_("Unused gap of %8u sectors - sectors %8u-%u\n"),
2135 lastblock - start, start, lastblock-1);
2136 gap += lastblock - start;
2137 add2freelist(start, lastblock);
2140 * Done with arithmetics
2141 * Go for details now
2144 if (!sgi_get_num_sectors(sgi_get_bootpartition())) {
2145 printf(_("\nThe boot partition does not exist.\n"));
2147 if (!sgi_get_num_sectors(sgi_get_swappartition())) {
2148 printf(_("\nThe swap partition does not exist.\n"));
2150 if ((sgi_get_sysid(sgi_get_swappartition()) != SGI_SWAP)
2151 && (sgi_get_sysid(sgi_get_swappartition()) != LINUX_SWAP))
2152 printf(_("\nThe swap partition has no swap type.\n"));
2154 if (sgi_check_bootfile("/unix"))
2155 printf(_("\tYou have chosen an unusual boot file name.\n"));
2157 return (gap > 0) ? 1 : (gap == 0) ? 0 : -1;
2164 * returned value is:
2165 * = 0 : disk is properly filled to the rim
2166 * < 0 : there is an overlap
2167 * > 0 : there is still some vacant space
2169 return verify_sgi(0);
2173 sgi_change_sysid(int i, int sys)
2175 if( sgi_get_num_sectors(i) == 0 ) { /* caught already before, ... */
2176 printf(_("Sorry You may change the Tag of non-empty partitions.\n"));
2179 if (((sys != ENTIRE_DISK ) && (sys != SGI_VOLHDR))
2180 && (sgi_get_start_sector(i) < 1) ) {
2182 _("It is highly recommended that the partition at offset 0\n"
2183 "is of type \"SGI volhdr\", the IRIX system will rely on it to\n"
2184 "retrieve from its directory standalone tools like sash and fx.\n"
2185 "Only the \"SGI volume\" entire disk section may violate this.\n"
2186 "Type YES if you are sure about tagging this partition differently.\n"));
2187 if (strcmp(line_ptr, _("YES\n")))
2190 sgilabel->partitions[i].id = SGI_SSWAP32(sys);
2193 /* returns partition index of first entry marked as entire disk */
2199 for (i = 0; i < 16; i++)
2200 if (sgi_get_sysid(i) == SGI_VOLUME)
2206 sgi_set_partition(int i, unsigned int start, unsigned int length, int sys)
2208 sgilabel->partitions[i].id = SGI_SSWAP32(sys);
2209 sgilabel->partitions[i].num_sectors = SGI_SSWAP32(length);
2210 sgilabel->partitions[i].start_sector = SGI_SSWAP32(start);
2212 if (sgi_gaps() < 0) /* rebuild freelist */
2213 printf(_("Do You know, You got a partition overlap on the disk?\n"));
2217 sgi_set_entire(void)
2221 for (n = 10; n < partitions; n++) {
2222 if(!sgi_get_num_sectors(n) ) {
2223 sgi_set_partition(n, 0, sgi_get_lastblock(), SGI_VOLUME);
2230 sgi_set_volhdr(void)
2234 for (n = 8; n < partitions; n++) {
2235 if (!sgi_get_num_sectors(n)) {
2237 * 5 cylinders is an arbitrary value I like
2238 * IRIX 5.3 stored files in the volume header
2239 * (like sash, symmon, fx, ide) with ca. 3200
2242 if (heads * sectors * 5 < sgi_get_lastblock())
2243 sgi_set_partition(n, 0, heads * sectors * 5, SGI_VOLHDR);
2250 sgi_delete_partition(int i)
2252 sgi_set_partition(i, 0, 0, 0);
2256 sgi_add_partition(int n, int sys)
2259 unsigned int first = 0, last = 0;
2263 } else if (n == 8) {
2266 if(sgi_get_num_sectors(n)) {
2267 printf(_("Partition %d is already defined. Delete "
2268 "it before re-adding it.\n"), n + 1);
2271 if ((sgi_entire() == -1) && (sys != SGI_VOLUME)) {
2272 printf(_("Attempting to generate entire disk entry automatically.\n"));
2276 if ((sgi_gaps() == 0) && (sys != SGI_VOLUME)) {
2277 printf(_("The entire disk is already covered with partitions.\n"));
2280 if (sgi_gaps() < 0) {
2281 printf(_("You got a partition overlap on the disk. Fix it first!\n"));
2284 snprintf(mesg, sizeof(mesg), _("First %s"), str_units(SINGULAR));
2286 if(sys == SGI_VOLUME) {
2287 last = sgi_get_lastblock();
2288 first = read_int(0, 0, last-1, 0, mesg);
2290 printf(_("It is highly recommended that eleventh partition\n"
2291 "covers the entire disk and is of type `SGI volume'\n"));
2294 first = freelist[0].first;
2295 last = freelist[0].last;
2296 first = read_int(scround(first), scround(first), scround(last)-1,
2299 if (display_in_cyl_units)
2300 first *= units_per_sector;
2302 first = first; /* align to cylinder if you know how ... */
2304 last = isinfreelist(first);
2306 printf(_("You will get a partition overlap on the disk. "
2307 "Fix it first!\n"));
2311 snprintf(mesg, sizeof(mesg), _(" Last %s"), str_units(SINGULAR));
2312 last = read_int(scround(first), scround(last)-1, scround(last)-1,
2313 scround(first), mesg)+1;
2314 if (display_in_cyl_units)
2315 last *= units_per_sector;
2317 last = last; /* align to cylinder if You know how ... */
2318 if ( (sys == SGI_VOLUME) && (first != 0 || last != sgi_get_lastblock() ) )
2319 printf(_("It is highly recommended that eleventh partition\n"
2320 "covers the entire disk and is of type `SGI volume'\n"));
2321 sgi_set_partition(n, first, last-first, sys);
2324 #ifdef CONFIG_FEATURE_FDISK_ADVANCED
2326 create_sgilabel(void)
2328 struct hd_geometry geometry;
2335 long longsectors; /* the number of sectors on the device */
2336 int res; /* the result from the ioctl */
2337 int sec_fac; /* the sector factor */
2339 sec_fac = sector_size / 512; /* determine the sector factor */
2342 _("Building a new SGI disklabel. Changes will remain in memory only,\n"
2343 "until you decide to write them. After that, of course, the previous\n"
2344 "content will be unrecoverably lost.\n\n"));
2346 sgi_other_endian = (BB_LITTLE_ENDIAN);
2347 res = ioctl(fd, BLKGETSIZE, &longsectors);
2348 if (!ioctl(fd, HDIO_GETGEO, &geometry)) {
2349 heads = geometry.heads;
2350 sectors = geometry.sectors;
2352 /* the get device size ioctl was successful */
2353 cylinders = longsectors / (heads * sectors);
2354 cylinders /= sec_fac;
2356 /* otherwise print error and use truncated version */
2357 cylinders = geometry.cylinders;
2359 _("Warning: BLKGETSIZE ioctl failed on %s. "
2360 "Using geometry cylinder value of %d.\n"
2361 "This value may be truncated for devices"
2362 " > 33.8 GB.\n"), disk_device, cylinders);
2365 for (i = 0; i < 4; i++) {
2367 if (valid_part_table_flag(MBRbuffer)) {
2368 if(get_part_table(i)->sys_ind) {
2369 old[i].sysid = get_part_table(i)->sys_ind;
2370 old[i].start = get_start_sect(get_part_table(i));
2371 old[i].nsect = get_nr_sects(get_part_table(i));
2372 printf(_("Trying to keep parameters of partition %d.\n"), i);
2374 printf(_("ID=%02x\tSTART=%d\tLENGTH=%d\n"),
2375 old[i].sysid, old[i].start, old[i].nsect);
2380 memset(MBRbuffer, 0, sizeof(MBRbuffer));
2381 sgilabel->magic = SGI_SSWAP32(SGI_LABEL_MAGIC);
2382 sgilabel->boot_part = SGI_SSWAP16(0);
2383 sgilabel->swap_part = SGI_SSWAP16(1);
2385 /* sizeof(sgilabel->boot_file) = 16 > 6 */
2386 memset(sgilabel->boot_file, 0, 16);
2387 strcpy((char*)sgilabel->boot_file, "/unix");
2389 sgilabel->devparam.skew = (0);
2390 sgilabel->devparam.gap1 = (0);
2391 sgilabel->devparam.gap2 = (0);
2392 sgilabel->devparam.sparecyl = (0);
2393 sgilabel->devparam.pcylcount = SGI_SSWAP16(geometry.cylinders);
2394 sgilabel->devparam.head_vol0 = SGI_SSWAP16(0);
2395 sgilabel->devparam.ntrks = SGI_SSWAP16(geometry.heads);
2396 /* tracks/cylinder (heads) */
2397 sgilabel->devparam.cmd_tag_queue_depth = (0);
2398 sgilabel->devparam.unused0 = (0);
2399 sgilabel->devparam.unused1 = SGI_SSWAP16(0);
2400 sgilabel->devparam.nsect = SGI_SSWAP16(geometry.sectors);
2402 sgilabel->devparam.bytes = SGI_SSWAP16(512);
2403 sgilabel->devparam.ilfact = SGI_SSWAP16(1);
2404 sgilabel->devparam.flags = SGI_SSWAP32(TRACK_FWD|
2405 IGNORE_ERRORS|RESEEK);
2406 sgilabel->devparam.datarate = SGI_SSWAP32(0);
2407 sgilabel->devparam.retries_on_error = SGI_SSWAP32(1);
2408 sgilabel->devparam.ms_per_word = SGI_SSWAP32(0);
2409 sgilabel->devparam.xylogics_gap1 = SGI_SSWAP16(0);
2410 sgilabel->devparam.xylogics_syncdelay = SGI_SSWAP16(0);
2411 sgilabel->devparam.xylogics_readdelay = SGI_SSWAP16(0);
2412 sgilabel->devparam.xylogics_gap2 = SGI_SSWAP16(0);
2413 sgilabel->devparam.xylogics_readgate = SGI_SSWAP16(0);
2414 sgilabel->devparam.xylogics_writecont = SGI_SSWAP16(0);
2415 memset( &(sgilabel->directory), 0, sizeof(struct volume_directory)*15 );
2416 memset( &(sgilabel->partitions), 0, sizeof(struct sgi_partition)*16 );
2417 current_label_type = label_sgi;
2422 for (i = 0; i < 4; i++) {
2424 sgi_set_partition(i, old[i].start, old[i].nsect, old[i].sysid);
2432 /* do nothing in the beginning */
2434 #endif /* CONFIG_FEATURE_FDISK_ADVANCED */
2436 /* _____________________________________________________________
2442 sgiinfo *info = calloc(1, sizeof(sgiinfo));
2444 info->magic = SGI_SSWAP32(SGI_INFO_MAGIC);
2445 info->b1 = SGI_SSWAP32(-1);
2446 info->b2 = SGI_SSWAP16(-1);
2447 info->b3 = SGI_SSWAP16(1);
2448 /* You may want to replace this string !!!!!!! */
2449 strcpy( (char*)info->scsi_string, "IBM OEM 0662S12 3 30" );
2450 strcpy( (char*)info->serial, "0000" );
2451 info->check1816 = SGI_SSWAP16(18*256 +16 );
2452 strcpy( (char*)info->installer, "Sfx version 5.3, Oct 18, 1994" );
2455 #endif /* SGI_LABEL */
2458 #ifdef CONFIG_FEATURE_SUN_LABEL
2462 * I think this is mostly, or entirely, due to
2463 * Jakub Jelinek (jj@sunsite.mff.cuni.cz), July 1996
2465 * Merged with fdisk for other architectures, aeb, June 1998.
2467 * Sat Mar 20 EST 1999 Arnaldo Carvalho de Melo <acme@conectiva.com.br>
2468 * Internationalization
2472 static int sun_other_endian;
2473 static int scsi_disk;
2477 #define IDE0_MAJOR 3
2480 #define IDE1_MAJOR 22
2484 guess_device_type(void)
2486 struct stat bootstat;
2488 if (fstat(fd, &bootstat) < 0) {
2491 } else if (S_ISBLK(bootstat.st_mode)
2492 && (major(bootstat.st_rdev) == IDE0_MAJOR ||
2493 major(bootstat.st_rdev) == IDE1_MAJOR)) {
2496 } else if (S_ISBLK(bootstat.st_mode)
2497 && major(bootstat.st_rdev) == FLOPPY_MAJOR) {
2506 static const struct systypes sun_sys_types[] = {
2507 { "\x00" "Empty" }, /* 0 */
2508 { "\x01" "Boot" }, /* 1 */
2509 { "\x02" "SunOS root" }, /* 2 */
2510 { "\x03" "SunOS swap" }, /* SUNOS_SWAP */
2511 { "\x04" "SunOS usr" }, /* 4 */
2512 { "\x05" "Whole disk" }, /* WHOLE_DISK */
2513 { "\x06" "SunOS stand" }, /* 6 */
2514 { "\x07" "SunOS var" }, /* 7 */
2515 { "\x08" "SunOS home" }, /* 8 */
2516 { "\x82" "Linux swap" }, /* LINUX_SWAP */
2517 { "\x83" "Linux native" }, /* LINUX_NATIVE */
2518 { "\x8e" "Linux LVM" }, /* 0x8e */
2519 /* New (2.2.x) raid partition with autodetect using persistent superblock */
2520 { "\xfd" "Linux raid autodetect" }, /* 0xfd */
2526 set_sun_partition(int i, uint start, uint stop, int sysid)
2528 sunlabel->infos[i].id = sysid;
2529 sunlabel->partitions[i].start_cylinder =
2530 SUN_SSWAP32(start / (heads * sectors));
2531 sunlabel->partitions[i].num_sectors =
2532 SUN_SSWAP32(stop - start);
2537 check_sun_label(void)
2539 unsigned short *ush;
2542 if (sunlabel->magic != SUN_LABEL_MAGIC
2543 && sunlabel->magic != SUN_LABEL_MAGIC_SWAPPED) {
2544 current_label_type = label_dos;
2545 sun_other_endian = 0;
2548 sun_other_endian = (sunlabel->magic == SUN_LABEL_MAGIC_SWAPPED);
2549 ush = ((unsigned short *) (sunlabel + 1)) - 1;
2550 for (csum = 0; ush >= (unsigned short *)sunlabel;) csum ^= *ush--;
2552 fprintf(stderr,_("Detected sun disklabel with wrong checksum.\n"
2553 "Probably you'll have to set all the values,\n"
2554 "e.g. heads, sectors, cylinders and partitions\n"
2555 "or force a fresh label (s command in main menu)\n"));
2557 heads = SUN_SSWAP16(sunlabel->ntrks);
2558 cylinders = SUN_SSWAP16(sunlabel->ncyl);
2559 sectors = SUN_SSWAP16(sunlabel->nsect);
2562 current_label_type = label_sun;
2567 static const struct sun_predefined_drives {
2570 unsigned short sparecyl;
2571 unsigned short ncyl;
2572 unsigned short nacyl;
2573 unsigned short pcylcount;
2574 unsigned short ntrks;
2575 unsigned short nsect;
2576 unsigned short rspeed;
2578 { "Quantum","ProDrive 80S",1,832,2,834,6,34,3662},
2579 { "Quantum","ProDrive 105S",1,974,2,1019,6,35,3662},
2580 { "CDC","Wren IV 94171-344",3,1545,2,1549,9,46,3600},
2581 { "IBM","DPES-31080",0,4901,2,4903,4,108,5400},
2582 { "IBM","DORS-32160",0,1015,2,1017,67,62,5400},
2583 { "IBM","DNES-318350",0,11199,2,11474,10,320,7200},
2584 { "SEAGATE","ST34371",0,3880,2,3882,16,135,7228},
2585 { "","SUN0104",1,974,2,1019,6,35,3662},
2586 { "","SUN0207",4,1254,2,1272,9,36,3600},
2587 { "","SUN0327",3,1545,2,1549,9,46,3600},
2588 { "","SUN0340",0,1538,2,1544,6,72,4200},
2589 { "","SUN0424",2,1151,2,2500,9,80,4400},
2590 { "","SUN0535",0,1866,2,2500,7,80,5400},
2591 { "","SUN0669",5,1614,2,1632,15,54,3600},
2592 { "","SUN1.0G",5,1703,2,1931,15,80,3597},
2593 { "","SUN1.05",0,2036,2,2038,14,72,5400},
2594 { "","SUN1.3G",6,1965,2,3500,17,80,5400},
2595 { "","SUN2.1G",0,2733,2,3500,19,80,5400},
2596 { "IOMEGA","Jaz",0,1019,2,1021,64,32,5394},
2599 static const struct sun_predefined_drives *
2600 sun_autoconfigure_scsi(void)
2602 const struct sun_predefined_drives *p = NULL;
2604 #ifdef SCSI_IOCTL_GET_IDLUN
2614 if (!ioctl(fd, SCSI_IOCTL_GET_IDLUN, &id)) {
2616 "Host: scsi%d Channel: %02d Id: %02d Lun: %02d\n",
2618 ((id[0]>>24)&0xff)-/*PROC_SCSI_SCSI+PROC_SCSI_FILE*/33,
2620 /* This is very wrong (works only if you have one HBA),
2621 but I haven't found a way how to get hostno
2622 from the current kernel */
2629 pfd = fopen("/proc/scsi/scsi","r");
2631 while (fgets(buffer2, 2048, pfd)) {
2632 if (!strcmp(buffer, buffer2)) {
2633 if (fgets(buffer2,2048,pfd)) {
2634 q = strstr(buffer2,"Vendor: ");
2639 *q++ = 0; /* truncate vendor name */
2640 q = strstr(q,"Model: ");
2645 q = strstr(q," Rev: ");
2648 for (i = 0; i < SIZE(sun_drives); i++) {
2649 if (*sun_drives[i].vendor && strcasecmp(sun_drives[i].vendor, vendor))
2651 if (!strstr(model, sun_drives[i].model))
2653 printf(_("Autoconfigure found a %s%s%s\n"),sun_drives[i].vendor,(*sun_drives[i].vendor) ? " " : "",sun_drives[i].model);
2672 create_sunlabel(void)
2674 struct hd_geometry geometry;
2678 const struct sun_predefined_drives *p = NULL;
2681 _("Building a new sun disklabel. Changes will remain in memory only,\n"
2682 "until you decide to write them. After that, of course, the previous\n"
2683 "content won't be recoverable.\n\n"));
2684 sun_other_endian = BB_LITTLE_ENDIAN;
2685 memset(MBRbuffer, 0, sizeof(MBRbuffer));
2686 sunlabel->magic = SUN_SSWAP16(SUN_LABEL_MAGIC);
2688 puts(_("Drive type\n"
2689 " ? auto configure\n"
2690 " 0 custom (with hardware detected defaults)"));
2691 for (i = 0; i < SIZE(sun_drives); i++) {
2692 printf(" %c %s%s%s\n",
2693 i + 'a', sun_drives[i].vendor,
2694 (*sun_drives[i].vendor) ? " " : "",
2695 sun_drives[i].model);
2698 c = read_char(_("Select type (? for auto, 0 for custom): "));
2699 if (c >= 'a' && c < 'a' + SIZE(sun_drives)) {
2700 p = sun_drives + c - 'a';
2702 } else if (c >= 'A' && c < 'A' + SIZE(sun_drives)) {
2703 p = sun_drives + c - 'A';
2705 } else if (c == '0') {
2707 } else if (c == '?' && scsi_disk) {
2708 p = sun_autoconfigure_scsi();
2710 printf(_("Autoconfigure failed.\n"));
2717 if (!ioctl(fd, HDIO_GETGEO, &geometry)) {
2718 heads = geometry.heads;
2719 sectors = geometry.sectors;
2720 cylinders = geometry.cylinders;
2727 sunlabel->nacyl = 0;
2728 sunlabel->pcylcount = SUN_SSWAP16(cylinders);
2729 sunlabel->rspeed = SUN_SSWAP16(300);
2730 sunlabel->ilfact = SUN_SSWAP16(1);
2731 sunlabel->sparecyl = 0;
2733 heads = read_int(1,heads,1024,0,_("Heads"));
2734 sectors = read_int(1,sectors,1024,0,_("Sectors/track"));
2736 cylinders = read_int(1,cylinders-2,65535,0,_("Cylinders"));
2738 cylinders = read_int(1,0,65535,0,_("Cylinders"));
2739 sunlabel->nacyl = SUN_SSWAP16(read_int(0,2,65535,0, _("Alternate cylinders")));
2740 sunlabel->pcylcount = SUN_SSWAP16(read_int(0,cylinders+SUN_SSWAP16(sunlabel->nacyl), 65535,0, _("Physical cylinders")));
2741 sunlabel->rspeed = SUN_SSWAP16(read_int(1,5400,100000,0, _("Rotation speed (rpm)")));
2742 sunlabel->ilfact = SUN_SSWAP16(read_int(1,1,32,0, _("Interleave factor")));
2743 sunlabel->sparecyl = SUN_SSWAP16(read_int(0,0,sectors,0, _("Extra sectors per cylinder")));
2746 sunlabel->sparecyl = SUN_SSWAP16(p->sparecyl);
2747 sunlabel->ncyl = SUN_SSWAP16(p->ncyl);
2748 sunlabel->nacyl = SUN_SSWAP16(p->nacyl);
2749 sunlabel->pcylcount = SUN_SSWAP16(p->pcylcount);
2750 sunlabel->ntrks = SUN_SSWAP16(p->ntrks);
2751 sunlabel->nsect = SUN_SSWAP16(p->nsect);
2752 sunlabel->rspeed = SUN_SSWAP16(p->rspeed);
2753 sunlabel->ilfact = SUN_SSWAP16(1);
2754 cylinders = p->ncyl;
2757 puts(_("You may change all the disk params from the x menu"));
2760 snprintf((char *)(sunlabel->info), sizeof(sunlabel->info),
2761 "%s%s%s cyl %d alt %d hd %d sec %d",
2762 p ? p->vendor : "", (p && *p->vendor) ? " " : "",
2763 p ? p->model : (floppy ? _("3,5\" floppy") : _("Linux custom")),
2764 cylinders, SUN_SSWAP16(sunlabel->nacyl), heads, sectors);
2766 sunlabel->ntrks = SUN_SSWAP16(heads);
2767 sunlabel->nsect = SUN_SSWAP16(sectors);
2768 sunlabel->ncyl = SUN_SSWAP16(cylinders);
2770 set_sun_partition(0, 0, cylinders * heads * sectors, LINUX_NATIVE);
2772 if (cylinders * heads * sectors >= 150 * 2048) {
2773 ndiv = cylinders - (50 * 2048 / (heads * sectors)); /* 50M swap */
2775 ndiv = cylinders * 2 / 3;
2776 set_sun_partition(0, 0, ndiv * heads * sectors, LINUX_NATIVE);
2777 set_sun_partition(1, ndiv * heads * sectors, cylinders * heads * sectors, LINUX_SWAP);
2778 sunlabel->infos[1].flags |= 0x01; /* Not mountable */
2780 set_sun_partition(2, 0, cylinders * heads * sectors, WHOLE_DISK);
2782 unsigned short *ush = (unsigned short *)sunlabel;
2783 unsigned short csum = 0;
2784 while (ush < (unsigned short *)(&sunlabel->csum))
2786 sunlabel->csum = csum;
2789 set_all_unchanged();
2791 get_boot(create_empty_sun);
2795 toggle_sunflags(int i, unsigned char mask)
2797 if (sunlabel->infos[i].flags & mask)
2798 sunlabel->infos[i].flags &= ~mask;
2800 sunlabel->infos[i].flags |= mask;
2805 fetch_sun(uint *starts, uint *lens, uint *start, uint *stop)
2807 int i, continuous = 1;
2810 *stop = cylinders * heads * sectors;
2811 for (i = 0; i < partitions; i++) {
2812 if (sunlabel->partitions[i].num_sectors
2813 && sunlabel->infos[i].id
2814 && sunlabel->infos[i].id != WHOLE_DISK) {
2815 starts[i] = SUN_SSWAP32(sunlabel->partitions[i].start_cylinder) * heads * sectors;
2816 lens[i] = SUN_SSWAP32(sunlabel->partitions[i].num_sectors);
2818 if (starts[i] == *start)
2820 else if (starts[i] + lens[i] >= *stop)
2824 /* There will be probably more gaps
2825 than one, so lets check afterwards */
2834 static uint *verify_sun_starts;
2837 verify_sun_cmp(int *a, int *b)
2839 if (*a == -1) return 1;
2840 if (*b == -1) return -1;
2841 if (verify_sun_starts[*a] > verify_sun_starts[*b]) return 1;
2848 uint starts[8], lens[8], start, stop;
2849 int i,j,k,starto,endo;
2852 verify_sun_starts = starts;
2853 fetch_sun(starts,lens,&start,&stop);
2854 for (k = 0; k < 7; k++) {
2855 for (i = 0; i < 8; i++) {
2856 if (k && (lens[i] % (heads * sectors))) {
2857 printf(_("Partition %d doesn't end on cylinder boundary\n"), i+1);
2860 for (j = 0; j < i; j++)
2862 if (starts[j] == starts[i]+lens[i]) {
2863 starts[j] = starts[i]; lens[j] += lens[i];
2865 } else if (starts[i] == starts[j]+lens[j]){
2869 if (starts[i] < starts[j]+lens[j]
2870 && starts[j] < starts[i]+lens[i]) {
2872 if (starts[j] > starto)
2874 endo = starts[i]+lens[i];
2875 if (starts[j]+lens[j] < endo)
2876 endo = starts[j]+lens[j];
2877 printf(_("Partition %d overlaps with others in "
2878 "sectors %d-%d\n"), i+1, starto, endo);
2885 for (i = 0; i < 8; i++) {
2891 qsort(array,SIZE(array),sizeof(array[0]),
2892 (int (*)(const void *,const void *)) verify_sun_cmp);
2893 if (array[0] == -1) {
2894 printf(_("No partitions defined\n"));
2897 stop = cylinders * heads * sectors;
2898 if (starts[array[0]])
2899 printf(_("Unused gap - sectors 0-%d\n"),starts[array[0]]);
2900 for (i = 0; i < 7 && array[i+1] != -1; i++) {
2901 printf(_("Unused gap - sectors %d-%d\n"),starts[array[i]]+lens[array[i]],starts[array[i+1]]);
2903 start = starts[array[i]] + lens[array[i]];
2905 printf(_("Unused gap - sectors %d-%d\n"),start,stop);
2909 add_sun_partition(int n, int sys)
2911 uint start, stop, stop2;
2912 uint starts[8], lens[8];
2918 if (sunlabel->partitions[n].num_sectors && sunlabel->infos[n].id) {
2919 printf(_("Partition %d is already defined. Delete "
2920 "it before re-adding it.\n"), n + 1);
2924 fetch_sun(starts,lens,&start,&stop);
2925 if (stop <= start) {
2929 printf(_("Other partitions already cover the whole disk.\nDelete "
2930 "some/shrink them before retry.\n"));
2934 snprintf(mesg, sizeof(mesg), _("First %s"), str_units(SINGULAR));
2937 first = read_int(0, 0, 0, 0, mesg);
2939 first = read_int(scround(start), scround(stop)+1,
2940 scround(stop), 0, mesg);
2941 if (display_in_cyl_units)
2942 first *= units_per_sector;
2944 /* Starting sector has to be properly aligned */
2945 first = (first + heads * sectors - 1) / (heads * sectors);
2946 if (n == 2 && first != 0)
2948 It is highly recommended that the third partition covers the whole disk\n\
2949 and is of type `Whole disk'\n");
2950 /* ewt asks to add: "don't start a partition at cyl 0"
2951 However, edmundo@rano.demon.co.uk writes:
2952 "In addition to having a Sun partition table, to be able to
2953 boot from the disc, the first partition, /dev/sdX1, must
2954 start at cylinder 0. This means that /dev/sdX1 contains
2955 the partition table and the boot block, as these are the
2956 first two sectors of the disc. Therefore you must be
2957 careful what you use /dev/sdX1 for. In particular, you must
2958 not use a partition starting at cylinder 0 for Linux swap,
2959 as that would overwrite the partition table and the boot
2960 block. You may, however, use such a partition for a UFS
2961 or EXT2 file system, as these file systems leave the first
2962 1024 bytes undisturbed. */
2963 /* On the other hand, one should not use partitions
2964 starting at block 0 in an md, or the label will
2966 for (i = 0; i < partitions; i++)
2967 if (lens[i] && starts[i] <= first && starts[i] + lens[i] > first)
2969 if (i < partitions && !whole_disk) {
2970 if (n == 2 && !first) {
2974 printf(_("Sector %d is already allocated\n"), first);
2978 stop = cylinders * heads * sectors;
2980 for (i = 0; i < partitions; i++) {
2981 if (starts[i] > first && starts[i] < stop)
2984 snprintf(mesg, sizeof(mesg),
2985 _("Last %s or +size or +sizeM or +sizeK"),
2986 str_units(SINGULAR));
2988 last = read_int(scround(stop2), scround(stop2), scround(stop2),
2990 else if (n == 2 && !first)
2991 last = read_int(scround(first), scround(stop2), scround(stop2),
2992 scround(first), mesg);
2994 last = read_int(scround(first), scround(stop), scround(stop),
2995 scround(first), mesg);
2996 if (display_in_cyl_units)
2997 last *= units_per_sector;
2998 if (n == 2 && !first) {
2999 if (last >= stop2) {
3002 } else if (last > stop) {
3003 printf(_("You haven't covered the whole disk with "
3004 "the 3rd partition, but your value\n"
3005 "%d %s covers some other partition. "
3006 "Your entry has been changed\n"
3008 scround(last), str_units(SINGULAR),
3009 scround(stop), str_units(SINGULAR));
3012 } else if (!whole_disk && last > stop)
3017 set_sun_partition(n, first, last, sys);
3021 sun_delete_partition(int i)
3026 && sunlabel->infos[i].id == WHOLE_DISK
3027 && !sunlabel->partitions[i].start_cylinder
3028 && (nsec = SUN_SSWAP32(sunlabel->partitions[i].num_sectors)) == heads * sectors * cylinders)
3029 printf(_("If you want to maintain SunOS/Solaris compatibility, "
3030 "consider leaving this\n"
3031 "partition as Whole disk (5), starting at 0, with %u "
3032 "sectors\n"), nsec);
3033 sunlabel->infos[i].id = 0;
3034 sunlabel->partitions[i].num_sectors = 0;
3038 sun_change_sysid(int i, int sys)
3040 if (sys == LINUX_SWAP && !sunlabel->partitions[i].start_cylinder) {
3042 _("It is highly recommended that the partition at offset 0\n"
3043 "is UFS, EXT2FS filesystem or SunOS swap. Putting Linux swap\n"
3044 "there may destroy your partition table and bootblock.\n"
3045 "Type YES if you're very sure you would like that partition\n"
3046 "tagged with 82 (Linux swap): "));
3047 if (strcmp (line_ptr, _("YES\n")))
3053 /* swaps are not mountable by default */
3054 sunlabel->infos[i].flags |= 0x01;
3057 /* assume other types are mountable;
3058 user can change it anyway */
3059 sunlabel->infos[i].flags &= ~0x01;
3062 sunlabel->infos[i].id = sys;
3066 sun_list_table(int xtra)
3070 w = strlen(disk_device);
3073 _("\nDisk %s (Sun disk label): %d heads, %d sectors, %d rpm\n"
3074 "%d cylinders, %d alternate cylinders, %d physical cylinders\n"
3075 "%d extra sects/cyl, interleave %d:1\n"
3077 "Units = %s of %d * 512 bytes\n\n"),
3078 disk_device, heads, sectors, SUN_SSWAP16(sunlabel->rspeed),
3079 cylinders, SUN_SSWAP16(sunlabel->nacyl),
3080 SUN_SSWAP16(sunlabel->pcylcount),
3081 SUN_SSWAP16(sunlabel->sparecyl),
3082 SUN_SSWAP16(sunlabel->ilfact),
3084 str_units(PLURAL), units_per_sector);
3087 _("\nDisk %s (Sun disk label): %d heads, %d sectors, %d cylinders\n"
3088 "Units = %s of %d * 512 bytes\n\n"),
3089 disk_device, heads, sectors, cylinders,
3090 str_units(PLURAL), units_per_sector);
3092 printf(_("%*s Flag Start End Blocks Id System\n"),
3093 w + 1, _("Device"));
3094 for (i = 0 ; i < partitions; i++) {
3095 if (sunlabel->partitions[i].num_sectors) {
3096 uint32_t start = SUN_SSWAP32(sunlabel->partitions[i].start_cylinder) * heads * sectors;
3097 uint32_t len = SUN_SSWAP32(sunlabel->partitions[i].num_sectors);
3098 printf("%s %c%c %9ld %9ld %9ld%c %2x %s\n",
3099 partname(disk_device, i+1, w), /* device */
3100 (sunlabel->infos[i].flags & 0x01) ? 'u' : ' ', /* flags */
3101 (sunlabel->infos[i].flags & 0x10) ? 'r' : ' ',
3102 (long) scround(start), /* start */
3103 (long) scround(start+len), /* end */
3104 (long) len / 2, len & 1 ? '+' : ' ', /* odd flag on end */
3105 sunlabel->infos[i].id, /* type id */
3106 partition_type(sunlabel->infos[i].id)); /* type name */
3111 #ifdef CONFIG_FEATURE_FDISK_ADVANCED
3114 sun_set_alt_cyl(void)
3117 SUN_SSWAP16(read_int(0,SUN_SSWAP16(sunlabel->nacyl), 65535, 0,
3118 _("Number of alternate cylinders")));
3122 sun_set_ncyl(int cyl)
3124 sunlabel->ncyl = SUN_SSWAP16(cyl);
3130 sunlabel->sparecyl =
3131 SUN_SSWAP16(read_int(0, SUN_SSWAP16(sunlabel->sparecyl), sectors, 0,
3132 _("Extra sectors per cylinder")));
3136 sun_set_ilfact(void)
3139 SUN_SSWAP16(read_int(1, SUN_SSWAP16(sunlabel->ilfact), 32, 0,
3140 _("Interleave factor")));
3144 sun_set_rspeed(void)
3147 SUN_SSWAP16(read_int(1, SUN_SSWAP16(sunlabel->rspeed), 100000, 0,
3148 _("Rotation speed (rpm)")));
3152 sun_set_pcylcount(void)
3154 sunlabel->pcylcount =
3155 SUN_SSWAP16(read_int(0, SUN_SSWAP16(sunlabel->pcylcount), 65535, 0,
3156 _("Number of physical cylinders")));
3158 #endif /* CONFIG_FEATURE_FDISK_ADVANCED */
3161 sun_write_table(void)
3163 unsigned short *ush = (unsigned short *)sunlabel;
3164 unsigned short csum = 0;
3166 while (ush < (unsigned short *)(&sunlabel->csum))
3168 sunlabel->csum = csum;
3169 if (lseek(fd, 0, SEEK_SET) < 0)
3170 fdisk_fatal(unable_to_seek);
3171 if (write(fd, sunlabel, SECTOR_SIZE) != SECTOR_SIZE)
3172 fdisk_fatal(unable_to_write);
3174 #endif /* SUN_LABEL */
3176 /* DOS partition types */
3178 static const struct systypes i386_sys_types[] = {
3181 { "\x04" "FAT16 <32M" },
3182 { "\x05" "Extended" }, /* DOS 3.3+ extended partition */
3183 { "\x06" "FAT16" }, /* DOS 16-bit >=32M */
3184 { "\x07" "HPFS/NTFS" }, /* OS/2 IFS, eg, HPFS or NTFS or QNX */
3185 { "\x0a" "OS/2 Boot Manager" },/* OS/2 Boot Manager */
3186 { "\x0b" "Win95 FAT32" },
3187 { "\x0c" "Win95 FAT32 (LBA)" },/* LBA really is `Extended Int 13h' */
3188 { "\x0e" "Win95 FAT16 (LBA)" },
3189 { "\x0f" "Win95 Ext'd (LBA)" },
3190 { "\x11" "Hidden FAT12" },
3191 { "\x12" "Compaq diagnostics" },
3192 { "\x14" "Hidden FAT16 <32M" },
3193 { "\x16" "Hidden FAT16" },
3194 { "\x17" "Hidden HPFS/NTFS" },
3195 { "\x1b" "Hidden Win95 FAT32" },
3196 { "\x1c" "Hidden Win95 FAT32 (LBA)" },
3197 { "\x1e" "Hidden Win95 FAT16 (LBA)" },
3198 { "\x3c" "PartitionMagic recovery" },
3199 { "\x41" "PPC PReP Boot" },
3201 { "\x63" "GNU HURD or SysV" }, /* GNU HURD or Mach or Sys V/386 (such as ISC UNIX) */
3202 { "\x80" "Old Minix" }, /* Minix 1.4a and earlier */
3203 { "\x81" "Minix / old Linux" },/* Minix 1.4b and later */
3204 { "\x82" "Linux swap" }, /* also Solaris */
3206 { "\x84" "OS/2 hidden C: drive" },
3207 { "\x85" "Linux extended" },
3208 { "\x86" "NTFS volume set" },
3209 { "\x87" "NTFS volume set" },
3210 { "\x8e" "Linux LVM" },
3211 { "\x9f" "BSD/OS" }, /* BSDI */
3212 { "\xa0" "IBM Thinkpad hibernation" },
3213 { "\xa5" "FreeBSD" }, /* various BSD flavours */
3214 { "\xa6" "OpenBSD" },
3215 { "\xa8" "Darwin UFS" },
3216 { "\xa9" "NetBSD" },
3217 { "\xab" "Darwin boot" },
3218 { "\xb7" "BSDI fs" },
3219 { "\xb8" "BSDI swap" },
3220 { "\xbe" "Solaris boot" },
3221 { "\xeb" "BeOS fs" },
3222 { "\xee" "EFI GPT" }, /* Intel EFI GUID Partition Table */
3223 { "\xef" "EFI (FAT-12/16/32)" },/* Intel EFI System Partition */
3224 { "\xf0" "Linux/PA-RISC boot" },/* Linux/PA-RISC boot loader */
3225 { "\xf2" "DOS secondary" }, /* DOS 3.3+ secondary */
3226 { "\xfd" "Linux raid autodetect" },/* New (2.2.x) raid partition with
3227 autodetect using persistent
3229 #ifdef CONFIG_WEIRD_PARTITION_TYPES
3230 { "\x02" "XENIX root" },
3231 { "\x03" "XENIX usr" },
3232 { "\x08" "AIX" }, /* AIX boot (AIX -- PS/2 port) or SplitDrive */
3233 { "\x09" "AIX bootable" }, /* AIX data or Coherent */
3235 { "\x18" "AST SmartSleep" },
3236 { "\x24" "NEC DOS" },
3237 { "\x39" "Plan 9" },
3238 { "\x40" "Venix 80286" },
3239 { "\x4d" "QNX4.x" },
3240 { "\x4e" "QNX4.x 2nd part" },
3241 { "\x4f" "QNX4.x 3rd part" },
3242 { "\x50" "OnTrack DM" },
3243 { "\x51" "OnTrack DM6 Aux1" }, /* (or Novell) */
3244 { "\x52" "CP/M" }, /* CP/M or Microport SysV/AT */
3245 { "\x53" "OnTrack DM6 Aux3" },
3246 { "\x54" "OnTrackDM6" },
3247 { "\x55" "EZ-Drive" },
3248 { "\x56" "Golden Bow" },
3249 { "\x5c" "Priam Edisk" },
3250 { "\x61" "SpeedStor" },
3251 { "\x64" "Novell Netware 286" },
3252 { "\x65" "Novell Netware 386" },
3253 { "\x70" "DiskSecure Multi-Boot" },
3255 { "\x93" "Amoeba" },
3256 { "\x94" "Amoeba BBT" }, /* (bad block table) */
3257 { "\xa7" "NeXTSTEP" },
3258 { "\xbb" "Boot Wizard hidden" },
3259 { "\xc1" "DRDOS/sec (FAT-12)" },
3260 { "\xc4" "DRDOS/sec (FAT-16 < 32M)" },
3261 { "\xc6" "DRDOS/sec (FAT-16)" },
3262 { "\xc7" "Syrinx" },
3263 { "\xda" "Non-FS data" },
3264 { "\xdb" "CP/M / CTOS / ..." },/* CP/M or Concurrent CP/M or
3265 Concurrent DOS or CTOS */
3266 { "\xde" "Dell Utility" }, /* Dell PowerEdge Server utilities */
3267 { "\xdf" "BootIt" }, /* BootIt EMBRM */
3268 { "\xe1" "DOS access" }, /* DOS access or SpeedStor 12-bit FAT
3269 extended partition */
3270 { "\xe3" "DOS R/O" }, /* DOS R/O or SpeedStor */
3271 { "\xe4" "SpeedStor" }, /* SpeedStor 16-bit FAT extended
3272 partition < 1024 cyl. */
3273 { "\xf1" "SpeedStor" },
3274 { "\xf4" "SpeedStor" }, /* SpeedStor large partition */
3275 { "\xfe" "LANstep" }, /* SpeedStor >1024 cyl. or LANstep */
3276 { "\xff" "BBT" }, /* Xenix Bad Block Table */
3283 /* A valid partition table sector ends in 0x55 0xaa */
3285 part_table_flag(const char *b)
3287 return ((uint) b[510]) + (((uint) b[511]) << 8);
3291 #ifdef CONFIG_FEATURE_FDISK_WRITABLE
3293 write_part_table_flag(char *b)
3299 /* start_sect and nr_sects are stored little endian on all machines */
3300 /* moreover, they are not aligned correctly */
3302 store4_little_endian(unsigned char *cp, unsigned int val)
3304 cp[0] = (val & 0xff);
3305 cp[1] = ((val >> 8) & 0xff);
3306 cp[2] = ((val >> 16) & 0xff);
3307 cp[3] = ((val >> 24) & 0xff);
3309 #endif /* CONFIG_FEATURE_FDISK_WRITABLE */
3312 read4_little_endian(const unsigned char *cp)
3314 return (uint)(cp[0]) + ((uint)(cp[1]) << 8)
3315 + ((uint)(cp[2]) << 16) + ((uint)(cp[3]) << 24);
3318 #ifdef CONFIG_FEATURE_FDISK_WRITABLE
3320 set_start_sect(struct partition *p, unsigned int start_sect)
3322 store4_little_endian(p->start4, start_sect);
3327 get_start_sect(const struct partition *p)
3329 return read4_little_endian(p->start4);
3332 #ifdef CONFIG_FEATURE_FDISK_WRITABLE
3334 set_nr_sects(struct partition *p, int32_t nr_sects)
3336 store4_little_endian(p->size4, nr_sects);
3341 get_nr_sects(const struct partition *p)
3343 return read4_little_endian(p->size4);
3346 /* normally O_RDWR, -l option gives O_RDONLY */
3347 static int type_open = O_RDWR;
3350 static int ext_index; /* the prime extended partition */
3351 static int listing; /* no aborts for fdisk -l */
3352 static int dos_compatible_flag = ~0;
3353 #ifdef CONFIG_FEATURE_FDISK_WRITABLE
3354 static int dos_changed;
3355 static int nowarn; /* no warnings for fdisk -l/-s */
3360 static uint user_cylinders, user_heads, user_sectors;
3361 static uint pt_heads, pt_sectors;
3362 static uint kern_heads, kern_sectors;
3364 static off_t extended_offset; /* offset of link pointers */
3366 static unsigned long long total_number_of_sectors;
3369 static jmp_buf listingbuf;
3371 static void fdisk_fatal(enum failure why)
3373 const char *message;
3377 longjmp(listingbuf, 1);
3381 case unable_to_open:
3382 message = "Unable to open %s\n";
3384 case unable_to_read:
3385 message = "Unable to read %s\n";
3387 case unable_to_seek:
3388 message = "Unable to seek on %s\n";
3390 case unable_to_write:
3391 message = "Unable to write %s\n";
3394 message = "BLKGETSIZE ioctl failed on %s\n";
3397 message = "Fatal error\n";
3400 fputc('\n', stderr);
3401 fprintf(stderr, message, disk_device);
3406 seek_sector(off_t secno)
3408 off_t offset = secno * sector_size;
3409 if (lseek(fd, offset, SEEK_SET) == (off_t) -1)
3410 fdisk_fatal(unable_to_seek);
3413 #ifdef CONFIG_FEATURE_FDISK_WRITABLE
3415 write_sector(off_t secno, char *buf)
3418 if (write(fd, buf, sector_size) != sector_size)
3419 fdisk_fatal(unable_to_write);
3423 /* Allocate a buffer and read a partition table sector */
3425 read_pte(struct pte *pe, off_t offset)
3427 pe->offset = offset;
3428 pe->sectorbuffer = (char *) xmalloc(sector_size);
3429 seek_sector(offset);
3430 if (read(fd, pe->sectorbuffer, sector_size) != sector_size)
3431 fdisk_fatal(unable_to_read);
3432 #ifdef CONFIG_FEATURE_FDISK_WRITABLE
3435 pe->part_table = pe->ext_pointer = NULL;
3439 get_partition_start(const struct pte *pe)
3441 return pe->offset + get_start_sect(pe->part_table);
3444 #ifdef CONFIG_FEATURE_FDISK_WRITABLE
3446 * Avoid warning about DOS partitions when no DOS partition was changed.
3447 * Here a heuristic "is probably dos partition".
3448 * We might also do the opposite and warn in all cases except
3449 * for "is probably nondos partition".
3452 is_dos_partition(int t)
3454 return (t == 1 || t == 4 || t == 6 ||
3455 t == 0x0b || t == 0x0c || t == 0x0e ||
3456 t == 0x11 || t == 0x12 || t == 0x14 || t == 0x16 ||
3457 t == 0x1b || t == 0x1c || t == 0x1e || t == 0x24 ||
3458 t == 0xc1 || t == 0xc4 || t == 0xc6);
3464 #ifdef CONFIG_FEATURE_SUN_LABEL
3465 if (label_sun == current_label_type) {
3466 puts(_("Command action"));
3467 puts(_("\ta\ttoggle a read only flag")); /* sun */
3468 puts(_("\tb\tedit bsd disklabel"));
3469 puts(_("\tc\ttoggle the mountable flag")); /* sun */
3470 puts(_("\td\tdelete a partition"));
3471 puts(_("\tl\tlist known partition types"));
3472 puts(_("\tm\tprint this menu"));
3473 puts(_("\tn\tadd a new partition"));
3474 puts(_("\to\tcreate a new empty DOS partition table"));
3475 puts(_("\tp\tprint the partition table"));
3476 puts(_("\tq\tquit without saving changes"));
3477 puts(_("\ts\tcreate a new empty Sun disklabel")); /* sun */
3478 puts(_("\tt\tchange a partition's system id"));
3479 puts(_("\tu\tchange display/entry units"));
3480 puts(_("\tv\tverify the partition table"));
3481 puts(_("\tw\twrite table to disk and exit"));
3482 #ifdef CONFIG_FEATURE_FDISK_ADVANCED
3483 puts(_("\tx\textra functionality (experts only)"));
3487 #ifdef CONFIG_FEATURE_SGI_LABEL
3488 if (label_sgi == current_label_type) {
3489 puts(_("Command action"));
3490 puts(_("\ta\tselect bootable partition")); /* sgi flavour */
3491 puts(_("\tb\tedit bootfile entry")); /* sgi */
3492 puts(_("\tc\tselect sgi swap partition")); /* sgi flavour */
3493 puts(_("\td\tdelete a partition"));
3494 puts(_("\tl\tlist known partition types"));
3495 puts(_("\tm\tprint this menu"));
3496 puts(_("\tn\tadd a new partition"));
3497 puts(_("\to\tcreate a new empty DOS partition table"));
3498 puts(_("\tp\tprint the partition table"));
3499 puts(_("\tq\tquit without saving changes"));
3500 puts(_("\ts\tcreate a new empty Sun disklabel")); /* sun */
3501 puts(_("\tt\tchange a partition's system id"));
3502 puts(_("\tu\tchange display/entry units"));
3503 puts(_("\tv\tverify the partition table"));
3504 puts(_("\tw\twrite table to disk and exit"));
3507 #ifdef CONFIG_FEATURE_AIX_LABEL
3508 if (label_aix == current_label_type) {
3509 puts(_("Command action"));
3510 puts(_("\tm\tprint this menu"));
3511 puts(_("\to\tcreate a new empty DOS partition table"));
3512 puts(_("\tq\tquit without saving changes"));
3513 puts(_("\ts\tcreate a new empty Sun disklabel")); /* sun */
3517 puts(_("Command action"));
3518 puts(_("\ta\ttoggle a bootable flag"));
3519 puts(_("\tb\tedit bsd disklabel"));
3520 puts(_("\tc\ttoggle the dos compatibility flag"));
3521 puts(_("\td\tdelete a partition"));
3522 puts(_("\tl\tlist known partition types"));
3523 puts(_("\tm\tprint this menu"));
3524 puts(_("\tn\tadd a new partition"));
3525 puts(_("\to\tcreate a new empty DOS partition table"));
3526 puts(_("\tp\tprint the partition table"));
3527 puts(_("\tq\tquit without saving changes"));
3528 puts(_("\ts\tcreate a new empty Sun disklabel")); /* sun */
3529 puts(_("\tt\tchange a partition's system id"));
3530 puts(_("\tu\tchange display/entry units"));
3531 puts(_("\tv\tverify the partition table"));
3532 puts(_("\tw\twrite table to disk and exit"));
3533 #ifdef CONFIG_FEATURE_FDISK_ADVANCED
3534 puts(_("\tx\textra functionality (experts only)"));
3538 #endif /* CONFIG_FEATURE_FDISK_WRITABLE */
3541 #ifdef CONFIG_FEATURE_FDISK_ADVANCED
3545 #ifdef CONFIG_FEATURE_SUN_LABEL
3546 if (label_sun == current_label_type) {
3547 puts(_("Command action"));
3548 puts(_("\ta\tchange number of alternate cylinders")); /*sun*/
3549 puts(_("\tc\tchange number of cylinders"));
3550 puts(_("\td\tprint the raw data in the partition table"));
3551 puts(_("\te\tchange number of extra sectors per cylinder"));/*sun*/
3552 puts(_("\th\tchange number of heads"));
3553 puts(_("\ti\tchange interleave factor")); /*sun*/
3554 puts(_("\to\tchange rotation speed (rpm)")); /*sun*/
3555 puts(_("\tm\tprint this menu"));
3556 puts(_("\tp\tprint the partition table"));
3557 puts(_("\tq\tquit without saving changes"));
3558 puts(_("\tr\treturn to main menu"));
3559 puts(_("\ts\tchange number of sectors/track"));
3560 puts(_("\tv\tverify the partition table"));
3561 puts(_("\tw\twrite table to disk and exit"));
3562 puts(_("\ty\tchange number of physical cylinders")); /*sun*/
3565 #ifdef CONFIG_FEATURE_SGI_LABEL
3566 if (label_sgi == current_label_type) {
3567 puts(_("Command action"));
3568 puts(_("\tb\tmove beginning of data in a partition")); /* !sun */
3569 puts(_("\tc\tchange number of cylinders"));
3570 puts(_("\td\tprint the raw data in the partition table"));
3571 puts(_("\te\tlist extended partitions")); /* !sun */
3572 puts(_("\tg\tcreate an IRIX (SGI) partition table"));/* sgi */
3573 puts(_("\th\tchange number of heads"));
3574 puts(_("\tm\tprint this menu"));
3575 puts(_("\tp\tprint the partition table"));
3576 puts(_("\tq\tquit without saving changes"));
3577 puts(_("\tr\treturn to main menu"));
3578 puts(_("\ts\tchange number of sectors/track"));
3579 puts(_("\tv\tverify the partition table"));
3580 puts(_("\tw\twrite table to disk and exit"));
3583 #ifdef CONFIG_FEATURE_AIX_LABEL
3584 if (label_aix == current_label_type) {
3585 puts(_("Command action"));
3586 puts(_("\tb\tmove beginning of data in a partition")); /* !sun */
3587 puts(_("\tc\tchange number of cylinders"));
3588 puts(_("\td\tprint the raw data in the partition table"));
3589 puts(_("\te\tlist extended partitions")); /* !sun */
3590 puts(_("\tg\tcreate an IRIX (SGI) partition table"));/* sgi */
3591 puts(_("\th\tchange number of heads"));
3592 puts(_("\tm\tprint this menu"));
3593 puts(_("\tp\tprint the partition table"));
3594 puts(_("\tq\tquit without saving changes"));
3595 puts(_("\tr\treturn to main menu"));
3596 puts(_("\ts\tchange number of sectors/track"));
3597 puts(_("\tv\tverify the partition table"));
3598 puts(_("\tw\twrite table to disk and exit"));
3602 puts(_("Command action"));
3603 puts(_("\tb\tmove beginning of data in a partition")); /* !sun */
3604 puts(_("\tc\tchange number of cylinders"));
3605 puts(_("\td\tprint the raw data in the partition table"));
3606 puts(_("\te\tlist extended partitions")); /* !sun */
3607 puts(_("\tf\tfix partition order")); /* !sun, !aix, !sgi */
3608 #ifdef CONFIG_FEATURE_SGI_LABEL
3609 puts(_("\tg\tcreate an IRIX (SGI) partition table"));/* sgi */
3611 puts(_("\th\tchange number of heads"));
3612 puts(_("\tm\tprint this menu"));
3613 puts(_("\tp\tprint the partition table"));
3614 puts(_("\tq\tquit without saving changes"));
3615 puts(_("\tr\treturn to main menu"));
3616 puts(_("\ts\tchange number of sectors/track"));
3617 puts(_("\tv\tverify the partition table"));
3618 puts(_("\tw\twrite table to disk and exit"));
3621 #endif /* ADVANCED mode */
3623 #ifdef CONFIG_FEATURE_FDISK_WRITABLE
3624 static const struct systypes *
3628 #ifdef CONFIG_FEATURE_SUN_LABEL
3629 label_sun == current_label_type ? sun_sys_types :
3631 #ifdef CONFIG_FEATURE_SGI_LABEL
3632 label_sgi == current_label_type ? sgi_sys_types :
3637 #define get_sys_types() i386_sys_types
3638 #endif /* CONFIG_FEATURE_FDISK_WRITABLE */
3640 static const char *partition_type(unsigned char type)
3643 const struct systypes *types = get_sys_types();
3645 for (i = 0; types[i].name; i++)
3646 if ((unsigned char )types[i].name[0] == type)
3647 return types[i].name + 1;
3649 return _("Unknown");
3653 #ifdef CONFIG_FEATURE_FDISK_WRITABLE
3658 #ifdef CONFIG_FEATURE_SUN_LABEL
3659 label_sun == current_label_type ? sunlabel->infos[i].id :
3661 #ifdef CONFIG_FEATURE_SGI_LABEL
3662 label_sgi == current_label_type ? sgi_get_sysid(i) :
3664 ptes[i].part_table->sys_ind);
3667 void list_types(const struct systypes *sys)
3669 uint last[4], done = 0, next = 0, size;
3672 for (i = 0; sys[i].name; i++);
3675 for (i = 3; i >= 0; i--)
3676 last[3 - i] = done += (size + i - done) / (i + 1);
3680 printf("%c%2x %-15.15s", i ? ' ' : '\n',
3681 (unsigned char)sys[next].name[0],
3682 partition_type((unsigned char)sys[next].name[0]));
3683 next = last[i++] + done;
3684 if (i > 3 || next >= last[i]) {
3688 } while (done < last[0]);
3691 #endif /* CONFIG_FEATURE_FDISK_WRITABLE */
3694 is_cleared_partition(const struct partition *p)
3696 return !(!p || p->boot_ind || p->head || p->sector || p->cyl ||
3697 p->sys_ind || p->end_head || p->end_sector || p->end_cyl ||
3698 get_start_sect(p) || get_nr_sects(p));
3702 clear_partition(struct partition *p)
3706 memset(p, 0, sizeof(struct partition));
3709 #ifdef CONFIG_FEATURE_FDISK_WRITABLE
3711 set_partition(int i, int doext, off_t start, off_t stop, int sysid)
3713 struct partition *p;
3717 p = ptes[i].ext_pointer;
3718 offset = extended_offset;
3720 p = ptes[i].part_table;
3721 offset = ptes[i].offset;
3725 set_start_sect(p, start - offset);
3726 set_nr_sects(p, stop - start + 1);
3727 if (dos_compatible_flag && (start/(sectors*heads) > 1023))
3728 start = heads*sectors*1024 - 1;
3729 set_hsc(p->head, p->sector, p->cyl, start);
3730 if (dos_compatible_flag && (stop/(sectors*heads) > 1023))
3731 stop = heads*sectors*1024 - 1;
3732 set_hsc(p->end_head, p->end_sector, p->end_cyl, stop);
3733 ptes[i].changed = 1;
3738 test_c(const char **m, const char *mesg)
3742 fprintf(stderr, _("You must set"));
3744 fprintf(stderr, " %s", *m);
3754 const char *m = NULL;
3758 prev = test_c(&m, _("heads"));
3760 prev = test_c(&m, _("sectors"));
3762 prev = test_c(&m, _("cylinders"));
3766 fprintf(stderr, "%s%s.\n"
3767 #ifdef CONFIG_FEATURE_FDISK_WRITABLE
3768 "You can do this from the extra functions menu.\n"
3770 , prev ? _(" and ") : " ", m);
3775 static void update_units(void)
3777 int cyl_units = heads * sectors;
3779 if (display_in_cyl_units && cyl_units)
3780 units_per_sector = cyl_units;
3782 units_per_sector = 1; /* in sectors */
3785 #ifdef CONFIG_FEATURE_FDISK_WRITABLE
3787 warn_cylinders(void)
3789 if (label_dos == current_label_type && cylinders > 1024 && !nowarn)
3790 fprintf(stderr, _("\n"
3791 "The number of cylinders for this disk is set to %d.\n"
3792 "There is nothing wrong with that, but this is larger than 1024,\n"
3793 "and could in certain setups cause problems with:\n"
3794 "1) software that runs at boot time (e.g., old versions of LILO)\n"
3795 "2) booting and partitioning software from other OSs\n"
3796 " (e.g., DOS FDISK, OS/2 FDISK)\n"),
3802 read_extended(int ext)
3806 struct partition *p, *q;
3810 pex->ext_pointer = pex->part_table;
3812 p = pex->part_table;
3813 if (!get_start_sect(p)) {
3815 _("Bad offset in primary extended partition\n"));
3819 while (IS_EXTENDED(p->sys_ind)) {
3820 struct pte *pe = &ptes[partitions];
3822 if (partitions >= MAXIMUM_PARTS) {
3823 /* This is not a Linux restriction, but
3824 this program uses arrays of size MAXIMUM_PARTS.
3825 Do not try to `improve' this test. */
3826 struct pte *pre = &ptes[partitions-1];
3827 #ifdef CONFIG_FEATURE_FDISK_WRITABLE
3829 _("Warning: deleting partitions after %d\n"),
3833 clear_partition(pre->ext_pointer);
3837 read_pte(pe, extended_offset + get_start_sect(p));
3839 if (!extended_offset)
3840 extended_offset = get_start_sect(p);
3842 q = p = pt_offset(pe->sectorbuffer, 0);
3843 for (i = 0; i < 4; i++, p++) if (get_nr_sects(p)) {
3844 if (IS_EXTENDED(p->sys_ind)) {
3845 if (pe->ext_pointer)
3847 _("Warning: extra link "
3848 "pointer in partition table"
3849 " %d\n"), partitions + 1);
3851 pe->ext_pointer = p;
3852 } else if (p->sys_ind) {
3855 _("Warning: ignoring extra "
3856 "data in partition table"
3857 " %d\n"), partitions + 1);
3863 /* very strange code here... */
3864 if (!pe->part_table) {
3865 if (q != pe->ext_pointer)
3868 pe->part_table = q + 1;
3870 if (!pe->ext_pointer) {
3871 if (q != pe->part_table)
3872 pe->ext_pointer = q;
3874 pe->ext_pointer = q + 1;
3877 p = pe->ext_pointer;
3881 #ifdef CONFIG_FEATURE_FDISK_WRITABLE
3882 /* remove empty links */
3884 for (i = 4; i < partitions; i++) {
3885 struct pte *pe = &ptes[i];
3887 if (!get_nr_sects(pe->part_table) &&
3888 (partitions > 5 || ptes[4].part_table->sys_ind)) {
3889 printf("omitting empty partition (%d)\n", i+1);
3890 delete_partition(i);
3891 goto remove; /* numbering changed */
3897 #ifdef CONFIG_FEATURE_FDISK_WRITABLE
3899 create_doslabel(void)
3904 _("Building a new DOS disklabel. Changes will remain in memory only,\n"
3905 "until you decide to write them. After that, of course, the previous\n"
3906 "content won't be recoverable.\n\n"));
3908 current_label_type = label_dos;
3910 #ifdef CONFIG_FEATURE_OSF_LABEL
3911 possibly_osf_label = 0;
3915 for (i = 510-64; i < 510; i++)
3917 write_part_table_flag(MBRbuffer);
3918 extended_offset = 0;
3919 set_all_unchanged();
3921 get_boot(create_empty_dos);
3923 #endif /* CONFIG_FEATURE_FDISK_WRITABLE */
3926 get_sectorsize(void)
3928 if (!user_set_sector_size) {
3930 if (ioctl(fd, BLKSSZGET, &arg) == 0)
3932 if (sector_size != DEFAULT_SECTOR_SIZE)
3933 printf(_("Note: sector size is %d (not %d)\n"),
3934 sector_size, DEFAULT_SECTOR_SIZE);
3939 get_kernel_geometry(void)
3941 struct hd_geometry geometry;
3943 if (!ioctl(fd, HDIO_GETGEO, &geometry)) {
3944 kern_heads = geometry.heads;
3945 kern_sectors = geometry.sectors;
3946 /* never use geometry.cylinders - it is truncated */
3951 get_partition_table_geometry(void)
3953 const unsigned char *bufp = (const unsigned char *)MBRbuffer;
3954 struct partition *p;
3955 int i, h, s, hh, ss;
3959 if (!(valid_part_table_flag((char*)bufp)))
3963 for (i = 0; i < 4; i++) {
3964 p = pt_offset(bufp, i);
3965 if (p->sys_ind != 0) {
3966 h = p->end_head + 1;
3967 s = (p->end_sector & 077);
3972 } else if (hh != h || ss != s)
3977 if (!first && !bad) {
3987 unsigned long long bytes; /* really u64 */
3990 sec_fac = sector_size / 512;
3991 #ifdef CONFIG_FEATURE_SUN_LABEL
3992 guess_device_type();
3994 heads = cylinders = sectors = 0;
3995 kern_heads = kern_sectors = 0;
3996 pt_heads = pt_sectors = 0;
3998 get_kernel_geometry();
3999 get_partition_table_geometry();
4001 heads = user_heads ? user_heads :
4002 pt_heads ? pt_heads :
4003 kern_heads ? kern_heads : 255;
4004 sectors = user_sectors ? user_sectors :
4005 pt_sectors ? pt_sectors :
4006 kern_sectors ? kern_sectors : 63;
4007 if (ioctl(fd, BLKGETSIZE64, &bytes) == 0) {
4010 unsigned long longsectors;
4012 if (ioctl(fd, BLKGETSIZE, &longsectors))
4014 bytes = ((unsigned long long) longsectors) << 9;
4017 total_number_of_sectors = (bytes >> 9);
4020 if (dos_compatible_flag)
4021 sector_offset = sectors;
4023 cylinders = total_number_of_sectors / (heads * sectors * sec_fac);
4025 cylinders = user_cylinders;
4029 * Read MBR. Returns:
4030 * -1: no 0xaa55 flag present (possibly entire disk BSD)
4031 * 0: found or created label
4035 get_boot(enum action what)
4041 for (i = 0; i < 4; i++) {
4042 struct pte *pe = &ptes[i];
4044 pe->part_table = pt_offset(MBRbuffer, i);
4045 pe->ext_pointer = NULL;
4047 pe->sectorbuffer = MBRbuffer;
4048 #ifdef CONFIG_FEATURE_FDISK_WRITABLE
4049 pe->changed = (what == create_empty_dos);
4053 #ifdef CONFIG_FEATURE_SUN_LABEL
4054 if (what == create_empty_sun && check_sun_label())
4058 memset(MBRbuffer, 0, 512);
4060 #ifdef CONFIG_FEATURE_FDISK_WRITABLE
4061 if (what == create_empty_dos)
4062 goto got_dos_table; /* skip reading disk */
4064 if ((fd = open(disk_device, type_open)) < 0) {
4065 if ((fd = open(disk_device, O_RDONLY)) < 0) {
4066 if (what == try_only)
4068 fdisk_fatal(unable_to_open);
4070 printf(_("You will not be able to write "
4071 "the partition table.\n"));
4074 if (512 != read(fd, MBRbuffer, 512)) {
4075 if (what == try_only)
4077 fdisk_fatal(unable_to_read);
4080 if ((fd = open(disk_device, O_RDONLY)) < 0)
4082 if (512 != read(fd, MBRbuffer, 512))
4090 #ifdef CONFIG_FEATURE_SUN_LABEL
4091 if (check_sun_label())
4095 #ifdef CONFIG_FEATURE_SGI_LABEL
4096 if (check_sgi_label())
4100 #ifdef CONFIG_FEATURE_AIX_LABEL
4101 if (check_aix_label())
4105 #ifdef CONFIG_FEATURE_OSF_LABEL
4106 if (check_osf_label()) {
4107 possibly_osf_label = 1;
4108 if (!valid_part_table_flag(MBRbuffer)) {
4109 current_label_type = label_osf;
4112 printf(_("This disk has both DOS and BSD magic.\n"
4113 "Give the 'b' command to go to BSD mode.\n"));
4117 #ifdef CONFIG_FEATURE_FDISK_WRITABLE
4121 if (!valid_part_table_flag(MBRbuffer)) {
4122 #ifndef CONFIG_FEATURE_FDISK_WRITABLE
4128 _("Device contains neither a valid DOS "
4129 "partition table, nor Sun, SGI or OSF "
4132 #ifdef CONFIG_FEATURE_SUN_LABEL
4141 case create_empty_dos:
4142 #ifdef CONFIG_FEATURE_SUN_LABEL
4143 case create_empty_sun:
4147 fprintf(stderr, _("Internal error\n"));
4150 #endif /* CONFIG_FEATURE_FDISK_WRITABLE */
4153 #ifdef CONFIG_FEATURE_FDISK_WRITABLE
4158 for (i = 0; i < 4; i++) {
4159 struct pte *pe = &ptes[i];
4161 if (IS_EXTENDED(pe->part_table->sys_ind)) {
4162 if (partitions != 4)
4163 fprintf(stderr, _("Ignoring extra extended "
4164 "partition %d\n"), i + 1);
4170 for (i = 3; i < partitions; i++) {
4171 struct pte *pe = &ptes[i];
4173 if (!valid_part_table_flag(pe->sectorbuffer)) {
4175 _("Warning: invalid flag 0x%04x of partition "
4176 "table %d will be corrected by w(rite)\n"),
4177 part_table_flag(pe->sectorbuffer), i + 1);
4178 #ifdef CONFIG_FEATURE_FDISK_WRITABLE
4187 #ifdef CONFIG_FEATURE_FDISK_WRITABLE
4189 * Print the message MESG, then read an integer between LOW and HIGH (inclusive).
4190 * If the user hits Enter, DFLT is returned.
4191 * Answers like +10 are interpreted as offsets from BASE.
4193 * There is no default if DFLT is not between LOW and HIGH.
4196 read_int(uint low, uint dflt, uint high, uint base, char *mesg)
4200 static char *ms = NULL;
4201 static int mslen = 0;
4203 if (!ms || strlen(mesg)+100 > mslen) {
4204 mslen = strlen(mesg)+200;
4205 ms = xrealloc(ms,mslen);
4208 if (dflt < low || dflt > high)
4212 snprintf(ms, mslen, _("%s (%u-%u, default %u): "),
4213 mesg, low, high, dflt);
4215 snprintf(ms, mslen, "%s (%u-%u): ", mesg, low, high);
4218 int use_default = default_ok;
4220 /* ask question and read answer */
4221 while (read_chars(ms) != '\n' && !isdigit(*line_ptr)
4222 && *line_ptr != '-' && *line_ptr != '+')
4225 if (*line_ptr == '+' || *line_ptr == '-') {
4226 int minus = (*line_ptr == '-');
4229 i = atoi(line_ptr+1);
4231 while (isdigit(*++line_ptr))
4234 switch (*line_ptr) {
4237 if (!display_in_cyl_units)
4238 i *= heads * sectors;
4252 absolute = 1000000000;
4258 unsigned long long bytes;
4261 bytes = (unsigned long long) i * absolute;
4262 unit = sector_size * units_per_sector;
4263 bytes += unit/2; /* round */
4272 while (isdigit(*line_ptr)) {
4278 printf(_("Using default value %u\n"), i = dflt);
4279 if (i >= low && i <= high)
4282 printf(_("Value out of range.\n"));
4288 get_partition(int warn, int max)
4293 i = read_int(1, 0, max, 0, _("Partition number")) - 1;
4299 label_sun != current_label_type &&
4300 label_sgi != current_label_type &&
4301 !pe->part_table->sys_ind
4303 #ifdef CONFIG_FEATURE_SUN_LABEL
4305 label_sun == current_label_type &&
4307 !sunlabel->partitions[i].num_sectors
4308 || !sunlabel->infos[i].id
4312 #ifdef CONFIG_FEATURE_SGI_LABEL
4314 label_sgi == current_label_type &&
4315 !sgi_get_num_sectors(i)
4320 _("Warning: partition %d has empty type\n"),
4329 get_existing_partition(int warn, int max)
4334 for (i = 0; i < max; i++) {
4335 struct pte *pe = &ptes[i];
4336 struct partition *p = pe->part_table;
4338 if (p && !is_cleared_partition(p)) {
4345 printf(_("Selected partition %d\n"), pno+1);
4348 printf(_("No partition is defined yet!\n"));
4352 return get_partition(warn, max);
4356 get_nonexisting_partition(int warn, int max)
4361 for (i = 0; i < max; i++) {
4362 struct pte *pe = &ptes[i];
4363 struct partition *p = pe->part_table;
4365 if (p && is_cleared_partition(p)) {
4372 printf(_("Selected partition %d\n"), pno+1);
4375 printf(_("All primary partitions have been defined already!\n"));
4379 return get_partition(warn, max);
4383 void change_units(void)
4385 display_in_cyl_units = !display_in_cyl_units;
4387 printf(_("Changing display/entry units to %s\n"),
4392 toggle_active(int i)
4394 struct pte *pe = &ptes[i];
4395 struct partition *p = pe->part_table;
4397 if (IS_EXTENDED(p->sys_ind) && !p->boot_ind)
4399 _("WARNING: Partition %d is an extended partition\n"),
4401 p->boot_ind = (p->boot_ind ? 0 : ACTIVE_FLAG);
4406 toggle_dos_compatibility_flag(void)
4408 dos_compatible_flag = ~dos_compatible_flag;
4409 if (dos_compatible_flag) {
4410 sector_offset = sectors;
4411 printf(_("DOS Compatibility flag is set\n"));
4415 printf(_("DOS Compatibility flag is not set\n"));
4420 delete_partition(int i)
4422 struct pte *pe = &ptes[i];
4423 struct partition *p = pe->part_table;
4424 struct partition *q = pe->ext_pointer;
4426 /* Note that for the fifth partition (i == 4) we don't actually
4427 * decrement partitions.
4430 if (warn_geometry())
4431 return; /* C/H/S not set */
4434 #ifdef CONFIG_FEATURE_SUN_LABEL
4435 if (label_sun == current_label_type) {
4436 sun_delete_partition(i);
4440 #ifdef CONFIG_FEATURE_SGI_LABEL
4441 if (label_sgi == current_label_type) {
4442 sgi_delete_partition(i);
4448 if (IS_EXTENDED(p->sys_ind) && i == ext_index) {
4450 ptes[ext_index].ext_pointer = NULL;
4451 extended_offset = 0;
4457 if (!q->sys_ind && i > 4) {
4458 /* the last one in the chain - just delete */
4461 clear_partition(ptes[i].ext_pointer);
4462 ptes[i].changed = 1;
4464 /* not the last one - further ones will be moved down */
4466 /* delete this link in the chain */
4467 p = ptes[i-1].ext_pointer;
4469 set_start_sect(p, get_start_sect(q));
4470 set_nr_sects(p, get_nr_sects(q));
4471 ptes[i-1].changed = 1;
4472 } else if (partitions > 5) { /* 5 will be moved to 4 */
4473 /* the first logical in a longer chain */
4476 if (pe->part_table) /* prevent SEGFAULT */
4477 set_start_sect(pe->part_table,
4478 get_partition_start(pe) -
4480 pe->offset = extended_offset;
4484 if (partitions > 5) {
4486 while (i < partitions) {
4487 ptes[i] = ptes[i+1];
4491 /* the only logical: clear only */
4492 clear_partition(ptes[i].part_table);
4499 int i, sys, origsys;
4500 struct partition *p;
4502 #ifdef CONFIG_FEATURE_SGI_LABEL
4503 /* If sgi_label then don't use get_existing_partition,
4504 let the user select a partition, since get_existing_partition()
4505 only works for Linux like partition tables. */
4506 if (label_sgi != current_label_type) {
4507 i = get_existing_partition(0, partitions);
4509 i = get_partition(0, partitions);
4512 i = get_existing_partition(0, partitions);
4516 p = ptes[i].part_table;
4517 origsys = sys = get_sysid(i);
4519 /* if changing types T to 0 is allowed, then
4520 the reverse change must be allowed, too */
4521 if (!sys && label_sgi != current_label_type &&
4522 label_sun != current_label_type && !get_nr_sects(p))
4524 printf(_("Partition %d does not exist yet!\n"), i + 1);
4527 sys = read_hex (get_sys_types());
4529 if (!sys && label_sgi != current_label_type &&
4530 label_sun != current_label_type)
4532 printf(_("Type 0 means free space to many systems\n"
4533 "(but not to Linux). Having partitions of\n"
4534 "type 0 is probably unwise. You can delete\n"
4535 "a partition using the `d' command.\n"));
4539 if (label_sun != current_label_type && label_sgi != current_label_type) {
4540 if (IS_EXTENDED(sys) != IS_EXTENDED(p->sys_ind)) {
4541 printf(_("You cannot change a partition into"
4542 " an extended one or vice versa\n"
4543 "Delete it first.\n"));
4549 #ifdef CONFIG_FEATURE_SUN_LABEL
4550 if (label_sun == current_label_type && i == 2 && sys != WHOLE_DISK)
4551 printf(_("Consider leaving partition 3 "
4552 "as Whole disk (5),\n"
4553 "as SunOS/Solaris expects it and "
4554 "even Linux likes it.\n\n"));
4556 #ifdef CONFIG_FEATURE_SGI_LABEL
4557 if (label_sgi == current_label_type &&
4559 (i == 10 && sys != ENTIRE_DISK) ||
4560 (i == 8 && sys != 0)
4563 printf(_("Consider leaving partition 9 "
4564 "as volume header (0),\nand "
4565 "partition 11 as entire volume (6)"
4566 "as IRIX expects it.\n\n"));
4571 #ifdef CONFIG_FEATURE_SUN_LABEL
4572 if (label_sun == current_label_type) {
4573 sun_change_sysid(i, sys);
4576 #ifdef CONFIG_FEATURE_SGI_LABEL
4577 if (label_sgi == current_label_type) {
4578 sgi_change_sysid(i, sys);
4583 printf(_("Changed system type of partition %d "
4584 "to %x (%s)\n"), i + 1, sys,
4585 partition_type(sys));
4586 ptes[i].changed = 1;
4587 if (is_dos_partition(origsys) ||
4588 is_dos_partition(sys))
4595 #endif /* CONFIG_FEATURE_FDISK_WRITABLE */
4598 /* check_consistency() and long2chs() added Sat Mar 6 12:28:16 1993,
4599 * faith@cs.unc.edu, based on code fragments from pfdisk by Gordon W. Ross,
4600 * Jan. 1990 (version 1.2.1 by Gordon W. Ross Aug. 1990; Modified by S.
4601 * Lubkin Oct. 1991). */
4604 long2chs(ulong ls, uint *c, uint *h, uint *s)
4606 int spc = heads * sectors;
4611 *s = ls % sectors + 1; /* sectors count from 1 */
4615 check_consistency(const struct partition *p, int partition)
4617 uint pbc, pbh, pbs; /* physical beginning c, h, s */
4618 uint pec, peh, pes; /* physical ending c, h, s */
4619 uint lbc, lbh, lbs; /* logical beginning c, h, s */
4620 uint lec, leh, les; /* logical ending c, h, s */
4622 if (!heads || !sectors || (partition >= 4))
4623 return; /* do not check extended partitions */
4625 /* physical beginning c, h, s */
4626 pbc = (p->cyl & 0xff) | ((p->sector << 2) & 0x300);
4628 pbs = p->sector & 0x3f;
4630 /* physical ending c, h, s */
4631 pec = (p->end_cyl & 0xff) | ((p->end_sector << 2) & 0x300);
4633 pes = p->end_sector & 0x3f;
4635 /* compute logical beginning (c, h, s) */
4636 long2chs(get_start_sect(p), &lbc, &lbh, &lbs);
4638 /* compute logical ending (c, h, s) */
4639 long2chs(get_start_sect(p) + get_nr_sects(p) - 1, &lec, &leh, &les);
4641 /* Same physical / logical beginning? */
4642 if (cylinders <= 1024 && (pbc != lbc || pbh != lbh || pbs != lbs)) {
4643 printf(_("Partition %d has different physical/logical "
4644 "beginnings (non-Linux?):\n"), partition + 1);
4645 printf(_(" phys=(%d, %d, %d) "), pbc, pbh, pbs);
4646 printf(_("logical=(%d, %d, %d)\n"),lbc, lbh, lbs);
4649 /* Same physical / logical ending? */
4650 if (cylinders <= 1024 && (pec != lec || peh != leh || pes != les)) {
4651 printf(_("Partition %d has different physical/logical "
4652 "endings:\n"), partition + 1);
4653 printf(_(" phys=(%d, %d, %d) "), pec, peh, pes);
4654 printf(_("logical=(%d, %d, %d)\n"),lec, leh, les);
4658 /* Beginning on cylinder boundary? */
4659 if (pbh != !pbc || pbs != 1) {
4660 printf(_("Partition %i does not start on cylinder "
4661 "boundary:\n"), partition + 1);
4662 printf(_(" phys=(%d, %d, %d) "), pbc, pbh, pbs);
4663 printf(_("should be (%d, %d, 1)\n"), pbc, !pbc);
4667 /* Ending on cylinder boundary? */
4668 if (peh != (heads - 1) || pes != sectors) {
4669 printf(_("Partition %i does not end on cylinder boundary.\n"),
4672 printf(_(" phys=(%d, %d, %d) "), pec, peh, pes);
4673 printf(_("should be (%d, %d, %d)\n"),
4674 pec, heads - 1, sectors);
4680 list_disk_geometry(void)
4682 long long bytes = (total_number_of_sectors << 9);
4683 long megabytes = bytes/1000000;
4685 if (megabytes < 10000)
4686 printf(_("\nDisk %s: %ld MB, %lld bytes\n"),
4687 disk_device, megabytes, bytes);
4689 printf(_("\nDisk %s: %ld.%ld GB, %lld bytes\n"),
4690 disk_device, megabytes/1000, (megabytes/100)%10, bytes);
4691 printf(_("%d heads, %d sectors/track, %d cylinders"),
4692 heads, sectors, cylinders);
4693 if (units_per_sector == 1)
4694 printf(_(", total %llu sectors"),
4695 total_number_of_sectors / (sector_size/512));
4696 printf(_("\nUnits = %s of %d * %d = %d bytes\n\n"),
4698 units_per_sector, sector_size, units_per_sector * sector_size);
4702 * Check whether partition entries are ordered by their starting positions.
4703 * Return 0 if OK. Return i if partition i should have been earlier.
4704 * Two separate checks: primary and logical partitions.
4707 wrong_p_order(int *prev)
4709 const struct pte *pe;
4710 const struct partition *p;
4711 off_t last_p_start_pos = 0, p_start_pos;
4714 for (i = 0 ; i < partitions; i++) {
4717 last_p_start_pos = 0;
4720 if ((p = pe->part_table)->sys_ind) {
4721 p_start_pos = get_partition_start(pe);
4723 if (last_p_start_pos > p_start_pos) {
4729 last_p_start_pos = p_start_pos;
4736 #ifdef CONFIG_FEATURE_FDISK_ADVANCED
4738 * Fix the chain of logicals.
4739 * extended_offset is unchanged, the set of sectors used is unchanged
4740 * The chain is sorted so that sectors increase, and so that
4741 * starting sectors increase.
4743 * After this it may still be that cfdisk doesnt like the table.
4744 * (This is because cfdisk considers expanded parts, from link to
4745 * end of partition, and these may still overlap.)
4747 * sfdisk /dev/hda > ohda; sfdisk /dev/hda < ohda
4751 fix_chain_of_logicals(void)
4753 int j, oj, ojj, sj, sjj;
4754 struct partition *pj,*pjj,tmp;
4756 /* Stage 1: sort sectors but leave sector of part 4 */
4757 /* (Its sector is the global extended_offset.) */
4759 for (j = 5; j < partitions-1; j++) {
4760 oj = ptes[j].offset;
4761 ojj = ptes[j+1].offset;
4763 ptes[j].offset = ojj;
4764 ptes[j+1].offset = oj;
4765 pj = ptes[j].part_table;
4766 set_start_sect(pj, get_start_sect(pj)+oj-ojj);
4767 pjj = ptes[j+1].part_table;
4768 set_start_sect(pjj, get_start_sect(pjj)+ojj-oj);
4769 set_start_sect(ptes[j-1].ext_pointer,
4770 ojj-extended_offset);
4771 set_start_sect(ptes[j].ext_pointer,
4772 oj-extended_offset);
4777 /* Stage 2: sort starting sectors */
4779 for (j = 4; j < partitions-1; j++) {
4780 pj = ptes[j].part_table;
4781 pjj = ptes[j+1].part_table;
4782 sj = get_start_sect(pj);
4783 sjj = get_start_sect(pjj);
4784 oj = ptes[j].offset;
4785 ojj = ptes[j+1].offset;
4786 if (oj+sj > ojj+sjj) {
4790 set_start_sect(pj, ojj+sjj-oj);
4791 set_start_sect(pjj, oj+sj-ojj);
4796 /* Probably something was changed */
4797 for (j = 4; j < partitions; j++)
4798 ptes[j].changed = 1;
4803 fix_partition_table_order(void)
4805 struct pte *pei, *pek;
4808 if (!wrong_p_order(NULL)) {
4809 printf(_("Nothing to do. Ordering is correct already.\n\n"));
4813 while ((i = wrong_p_order(&k)) != 0 && i < 4) {
4814 /* partition i should have come earlier, move it */
4815 /* We have to move data in the MBR */
4816 struct partition *pi, *pk, *pe, pbuf;
4820 pe = pei->ext_pointer;
4821 pei->ext_pointer = pek->ext_pointer;
4822 pek->ext_pointer = pe;
4824 pi = pei->part_table;
4825 pk = pek->part_table;
4827 memmove(&pbuf, pi, sizeof(struct partition));
4828 memmove(pi, pk, sizeof(struct partition));
4829 memmove(pk, &pbuf, sizeof(struct partition));
4831 pei->changed = pek->changed = 1;
4835 fix_chain_of_logicals();
4843 list_table(int xtra)
4845 const struct partition *p;
4848 #ifdef CONFIG_FEATURE_SUN_LABEL
4849 if (label_sun == current_label_type) {
4850 sun_list_table(xtra);
4855 #ifdef CONFIG_FEATURE_SGI_LABEL
4856 if (label_sgi == current_label_type) {
4857 sgi_list_table(xtra);
4862 list_disk_geometry();
4864 #ifdef CONFIG_FEATURE_OSF_LABEL
4865 if (label_osf == current_label_type) {
4866 xbsd_print_disklabel(xtra);
4871 /* Heuristic: we list partition 3 of /dev/foo as /dev/foo3,
4872 but if the device name ends in a digit, say /dev/foo1,
4873 then the partition is called /dev/foo1p3. */
4874 w = strlen(disk_device);
4875 if (w && isdigit(disk_device[w-1]))
4880 printf(_("%*s Boot Start End Blocks Id System\n"),
4883 for (i = 0; i < partitions; i++) {
4884 const struct pte *pe = &ptes[i];
4887 if (p && !is_cleared_partition(p)) {
4888 off_t psects = get_nr_sects(p);
4889 off_t pblocks = psects;
4890 unsigned int podd = 0;
4892 if (sector_size < 1024) {
4893 pblocks /= (1024 / sector_size);
4894 podd = psects % (1024 / sector_size);
4896 if (sector_size > 1024)
4897 pblocks *= (sector_size / 1024);
4899 "%s %c %11llu %11llu %11llu%c %2x %s\n",
4900 partname(disk_device, i+1, w+2),
4901 /* boot flag */ !p->boot_ind ? ' ' : p->boot_ind == ACTIVE_FLAG
4903 /* start */ (unsigned long long) cround(get_partition_start(pe)),
4904 /* end */ (unsigned long long) cround(get_partition_start(pe) + psects
4905 - (psects ? 1 : 0)),
4906 /* odd flag on end */ (unsigned long long) pblocks, podd ? '+' : ' ',
4907 /* type id */ p->sys_ind,
4908 /* type name */ partition_type(p->sys_ind));
4909 check_consistency(p, i);
4913 /* Is partition table in disk order? It need not be, but... */
4914 /* partition table entries are not checked for correct order if this
4915 is a sgi, sun or aix labeled disk... */
4916 if (label_dos == current_label_type && wrong_p_order(NULL)) {
4918 printf(_("\nPartition table entries are not in disk order\n"));
4922 #ifdef CONFIG_FEATURE_FDISK_ADVANCED
4924 x_list_table(int extend)
4926 const struct pte *pe;
4927 const struct partition *p;
4930 printf(_("\nDisk %s: %d heads, %d sectors, %d cylinders\n\n"),
4931 disk_device, heads, sectors, cylinders);
4932 printf(_("Nr AF Hd Sec Cyl Hd Sec Cyl Start Size ID\n"));
4933 for (i = 0 ; i < partitions; i++) {
4935 p = (extend ? pe->ext_pointer : pe->part_table);
4937 printf("%2d %02x%4d%4d%5d%4d%4d%5d%11u%11u %02x\n",
4938 i + 1, p->boot_ind, p->head,
4940 cylinder(p->sector, p->cyl), p->end_head,
4941 sector(p->end_sector),
4942 cylinder(p->end_sector, p->end_cyl),
4943 get_start_sect(p), get_nr_sects(p), p->sys_ind);
4945 check_consistency(p, i);
4951 #ifdef CONFIG_FEATURE_FDISK_WRITABLE
4953 fill_bounds(off_t *first, off_t *last)
4956 const struct pte *pe = &ptes[0];
4957 const struct partition *p;
4959 for (i = 0; i < partitions; pe++,i++) {
4961 if (!p->sys_ind || IS_EXTENDED(p->sys_ind)) {
4962 first[i] = 0xffffffff;
4965 first[i] = get_partition_start(pe);
4966 last[i] = first[i] + get_nr_sects(p) - 1;
4972 check(int n, uint h, uint s, uint c, off_t start)
4974 off_t total, real_s, real_c;
4976 real_s = sector(s) - 1;
4977 real_c = cylinder(s, c);
4978 total = (real_c * sectors + real_s) * heads + h;
4980 fprintf(stderr, _("Warning: partition %d contains sector 0\n"), n);
4983 _("Partition %d: head %d greater than maximum %d\n"),
4985 if (real_s >= sectors)
4986 fprintf(stderr, _("Partition %d: sector %d greater than "
4987 "maximum %d\n"), n, s, sectors);
4988 if (real_c >= cylinders)
4989 fprintf(stderr, _("Partitions %d: cylinder %llu greater than "
4990 "maximum %d\n"), n, (unsigned long long)real_c + 1, cylinders);
4991 if (cylinders <= 1024 && start != total)
4993 _("Partition %d: previous sectors %llu disagrees with "
4994 "total %llu\n"), n, (unsigned long long)start, (unsigned long long)total);
5002 off_t first[partitions], last[partitions];
5003 struct partition *p;
5005 if (warn_geometry())
5008 #ifdef CONFIG_FEATURE_SUN_LABEL
5009 if (label_sun == current_label_type) {
5014 #ifdef CONFIG_FEATURE_SGI_LABEL
5015 if (label_sgi == current_label_type) {
5021 fill_bounds(first, last);
5022 for (i = 0; i < partitions; i++) {
5023 struct pte *pe = &ptes[i];
5026 if (p->sys_ind && !IS_EXTENDED(p->sys_ind)) {
5027 check_consistency(p, i);
5028 if (get_partition_start(pe) < first[i])
5029 printf(_("Warning: bad start-of-data in "
5030 "partition %d\n"), i + 1);
5031 check(i + 1, p->end_head, p->end_sector, p->end_cyl,
5033 total += last[i] + 1 - first[i];
5034 for (j = 0; j < i; j++)
5035 if ((first[i] >= first[j] && first[i] <= last[j])
5036 || ((last[i] <= last[j] && last[i] >= first[j]))) {
5037 printf(_("Warning: partition %d overlaps "
5038 "partition %d.\n"), j + 1, i + 1);
5039 total += first[i] >= first[j] ?
5040 first[i] : first[j];
5041 total -= last[i] <= last[j] ?
5047 if (extended_offset) {
5048 struct pte *pex = &ptes[ext_index];
5049 off_t e_last = get_start_sect(pex->part_table) +
5050 get_nr_sects(pex->part_table) - 1;
5052 for (i = 4; i < partitions; i++) {
5054 p = ptes[i].part_table;
5056 if (i != 4 || i + 1 < partitions)
5057 printf(_("Warning: partition %d "
5058 "is empty\n"), i + 1);
5060 else if (first[i] < extended_offset ||
5062 printf(_("Logical partition %d not entirely in "
5063 "partition %d\n"), i + 1, ext_index + 1);
5067 if (total > heads * sectors * cylinders)
5068 printf(_("Total allocated sectors %d greater than the maximum "
5069 "%d\n"), total, heads * sectors * cylinders);
5070 else if ((total = heads * sectors * cylinders - total) != 0)
5071 printf(_("%d unallocated sectors\n"), total);
5075 add_partition(int n, int sys)
5077 char mesg[256]; /* 48 does not suffice in Japanese */
5079 struct partition *p = ptes[n].part_table;
5080 struct partition *q = ptes[ext_index].part_table;
5082 off_t start, stop = 0, limit, temp,
5083 first[partitions], last[partitions];
5085 if (p && p->sys_ind) {
5086 printf(_("Partition %d is already defined. Delete "
5087 "it before re-adding it.\n"), n + 1);
5090 fill_bounds(first, last);
5092 start = sector_offset;
5093 if (display_in_cyl_units || !total_number_of_sectors)
5094 llimit = heads * sectors * cylinders - 1;
5096 llimit = total_number_of_sectors - 1;
5098 if (limit != llimit)
5100 if (extended_offset) {
5101 first[ext_index] = extended_offset;
5102 last[ext_index] = get_start_sect(q) +
5103 get_nr_sects(q) - 1;
5106 start = extended_offset + sector_offset;
5107 limit = get_start_sect(q) + get_nr_sects(q) - 1;
5109 if (display_in_cyl_units)
5110 for (i = 0; i < partitions; i++)
5111 first[i] = (cround(first[i]) - 1) * units_per_sector;
5113 snprintf(mesg, sizeof(mesg), _("First %s"), str_units(SINGULAR));
5116 for (i = 0; i < partitions; i++) {
5119 if (start == ptes[i].offset)
5120 start += sector_offset;
5121 lastplusoff = last[i] + ((n < 4) ? 0 : sector_offset);
5122 if (start >= first[i] && start <= lastplusoff)
5123 start = lastplusoff + 1;
5127 if (start >= temp+units_per_sector && readed) {
5128 printf(_("Sector %llu is already allocated\n"), (unsigned long long)temp);
5132 if (!readed && start == temp) {
5135 saved_start = start;
5136 start = read_int(cround(saved_start), cround(saved_start), cround(limit),
5138 if (display_in_cyl_units) {
5139 start = (start - 1) * units_per_sector;
5140 if (start < saved_start) start = saved_start;
5144 } while (start != temp || !readed);
5145 if (n > 4) { /* NOT for fifth partition */
5146 struct pte *pe = &ptes[n];
5148 pe->offset = start - sector_offset;
5149 if (pe->offset == extended_offset) { /* must be corrected */
5151 if (sector_offset == 1)
5156 for (i = 0; i < partitions; i++) {
5157 struct pte *pe = &ptes[i];
5159 if (start < pe->offset && limit >= pe->offset)
5160 limit = pe->offset - 1;
5161 if (start < first[i] && limit >= first[i])
5162 limit = first[i] - 1;
5164 if (start > limit) {
5165 printf(_("No free sectors available\n"));
5170 if (cround(start) == cround(limit)) {
5173 snprintf(mesg, sizeof(mesg),
5174 _("Last %s or +size or +sizeM or +sizeK"),
5175 str_units(SINGULAR));
5176 stop = read_int(cround(start), cround(limit), cround(limit),
5177 cround(start), mesg);
5178 if (display_in_cyl_units) {
5179 stop = stop * units_per_sector - 1;
5185 set_partition(n, 0, start, stop, sys);
5187 set_partition(n - 1, 1, ptes[n].offset, stop, EXTENDED);
5189 if (IS_EXTENDED(sys)) {
5190 struct pte *pe4 = &ptes[4];
5191 struct pte *pen = &ptes[n];
5194 pen->ext_pointer = p;
5195 pe4->offset = extended_offset = start;
5196 pe4->sectorbuffer = xcalloc(1, sector_size);
5197 pe4->part_table = pt_offset(pe4->sectorbuffer, 0);
5198 pe4->ext_pointer = pe4->part_table + 1;
5207 if (partitions > 5 || ptes[4].part_table->sys_ind) {
5208 struct pte *pe = &ptes[partitions];
5210 pe->sectorbuffer = xcalloc(1, sector_size);
5211 pe->part_table = pt_offset(pe->sectorbuffer, 0);
5212 pe->ext_pointer = pe->part_table + 1;
5217 add_partition(partitions - 1, LINUX_NATIVE);
5223 int i, free_primary = 0;
5225 if (warn_geometry())
5228 #ifdef CONFIG_FEATURE_SUN_LABEL
5229 if (label_sun == current_label_type) {
5230 add_sun_partition(get_partition(0, partitions), LINUX_NATIVE);
5234 #ifdef CONFIG_FEATURE_SGI_LABEL
5235 if (label_sgi == current_label_type) {
5236 sgi_add_partition(get_partition(0, partitions), LINUX_NATIVE);
5240 #ifdef CONFIG_FEATURE_AIX_LABEL
5241 if (label_aix == current_label_type) {
5242 printf(_("\tSorry - this fdisk cannot handle AIX disk labels."
5243 "\n\tIf you want to add DOS-type partitions, create"
5244 "\n\ta new empty DOS partition table first. (Use o.)"
5246 "This will destroy the present disk contents.\n"));
5251 for (i = 0; i < 4; i++)
5252 free_primary += !ptes[i].part_table->sys_ind;
5254 if (!free_primary && partitions >= MAXIMUM_PARTS) {
5255 printf(_("The maximum number of partitions has been created\n"));
5259 if (!free_primary) {
5260 if (extended_offset)
5263 printf(_("You must delete some partition and add "
5264 "an extended partition first\n"));
5266 char c, line[LINE_LENGTH];
5267 snprintf(line, sizeof(line), "%s\n %s\n p primary "
5268 "partition (1-4)\n",
5269 "Command action", (extended_offset ?
5270 "l logical (5 or over)" : "e extended"));
5272 if ((c = read_char(line)) == 'p' || c == 'P') {
5273 i = get_nonexisting_partition(0, 4);
5275 add_partition(i, LINUX_NATIVE);
5278 else if (c == 'l' && extended_offset) {
5282 else if (c == 'e' && !extended_offset) {
5283 i = get_nonexisting_partition(0, 4);
5285 add_partition(i, EXTENDED);
5289 printf(_("Invalid partition number "
5290 "for type `%c'\n"), c);
5300 if (label_dos == current_label_type) {
5301 for (i = 0; i < 3; i++)
5302 if (ptes[i].changed)
5303 ptes[3].changed = 1;
5304 for (i = 3; i < partitions; i++) {
5305 struct pte *pe = &ptes[i];
5308 write_part_table_flag(pe->sectorbuffer);
5309 write_sector(pe->offset, pe->sectorbuffer);
5313 #ifdef CONFIG_FEATURE_SGI_LABEL
5314 else if (label_sgi == current_label_type) {
5315 /* no test on change? the printf below might be mistaken */
5319 #ifdef CONFIG_FEATURE_SUN_LABEL
5320 else if (label_sun == current_label_type) {
5323 for (i = 0; i < 8; i++)
5324 if (ptes[i].changed)
5331 printf(_("The partition table has been altered!\n\n"));
5332 reread_partition_table(1);
5336 reread_partition_table(int leave)
5341 printf(_("Calling ioctl() to re-read partition table.\n"));
5344 if ((i = ioctl(fd, BLKRRPART)) != 0) {
5347 /* some kernel versions (1.2.x) seem to have trouble
5348 rereading the partition table, but if asked to do it
5349 twice, the second time works. - biro@yggdrasil.com */
5352 if ((i = ioctl(fd, BLKRRPART)) != 0)
5357 printf(_("\nWARNING: Re-reading the partition table "
5358 "failed with error %d: %s.\n"
5359 "The kernel still uses the old table.\n"
5360 "The new table will be used "
5361 "at the next reboot.\n"),
5362 error, strerror(error));
5367 _("\nWARNING: If you have created or modified any DOS 6.x\n"
5368 "partitions, please see the fdisk manual page for additional\n"
5374 printf(_("Syncing disks.\n"));
5376 sleep(4); /* for sync() */
5380 #endif /* CONFIG_FEATURE_FDISK_WRITABLE */
5382 #ifdef CONFIG_FEATURE_FDISK_ADVANCED
5383 #define MAX_PER_LINE 16
5385 print_buffer(char *pbuffer)
5389 for (i = 0, l = 0; i < sector_size; i++, l++) {
5391 printf("0x%03X:", i);
5392 printf(" %02X", (unsigned char) pbuffer[i]);
5393 if (l == MAX_PER_LINE - 1) {
5409 printf(_("Device: %s\n"), disk_device);
5410 #if defined(CONFIG_FEATURE_SGI_LABEL) || defined(CONFIG_FEATURE_SUN_LABEL)
5411 if (label_sun == current_label_type || label_sgi == current_label_type)
5412 print_buffer(MBRbuffer);
5415 for (i = 3; i < partitions; i++)
5416 print_buffer(ptes[i].sectorbuffer);
5422 struct pte *pe = &ptes[i];
5423 struct partition *p = pe->part_table;
5426 if (warn_geometry())
5428 if (!p->sys_ind || !get_nr_sects(p) || IS_EXTENDED(p->sys_ind)) {
5429 printf(_("Partition %d has no data area\n"), i + 1);
5432 first = get_partition_start(pe);
5433 new = read_int(first, first, first + get_nr_sects(p) - 1, first,
5434 _("New beginning of data")) - pe->offset;
5436 if (new != get_nr_sects(p)) {
5437 first = get_nr_sects(p) + get_start_sect(p) - new;
5438 set_nr_sects(p, first);
5439 set_start_sect(p, new);
5451 c = tolower(read_char(_("Expert command (m for help): ")));
5454 #ifdef CONFIG_FEATURE_SUN_LABEL
5455 if (label_sun == current_label_type)
5460 if (label_dos == current_label_type)
5461 move_begin(get_partition(0, partitions));
5464 user_cylinders = cylinders =
5465 read_int(1, cylinders, 1048576, 0,
5466 _("Number of cylinders"));
5467 #ifdef CONFIG_FEATURE_SUN_LABEL
5468 if (label_sun == current_label_type)
5469 sun_set_ncyl(cylinders);
5471 if (label_dos == current_label_type)
5478 #ifdef CONFIG_FEATURE_SGI_LABEL
5479 if (label_sgi == current_label_type)
5483 #ifdef CONFIG_FEATURE_SUN_LABEL
5484 if (label_sun == current_label_type)
5488 if (label_dos == current_label_type)
5492 if (label_dos == current_label_type)
5493 fix_partition_table_order();
5496 #ifdef CONFIG_FEATURE_SGI_LABEL
5501 user_heads = heads = read_int(1, heads, 256, 0,
5502 _("Number of heads"));
5506 #ifdef CONFIG_FEATURE_SUN_LABEL
5507 if (label_sun == current_label_type)
5512 #ifdef CONFIG_FEATURE_SUN_LABEL
5513 if (label_sun == current_label_type)
5518 #ifdef CONFIG_FEATURE_SUN_LABEL
5519 if (label_sun == current_label_type)
5532 user_sectors = sectors = read_int(1, sectors, 63, 0,
5533 _("Number of sectors"));
5534 if (dos_compatible_flag) {
5535 sector_offset = sectors;
5536 fprintf(stderr, _("Warning: setting "
5537 "sector offset for DOS "
5546 write_table(); /* does not return */
5549 #ifdef CONFIG_FEATURE_SUN_LABEL
5550 if (label_sun == current_label_type)
5551 sun_set_pcylcount();
5559 #endif /* ADVANCED mode */
5562 is_ide_cdrom_or_tape(const char *device)
5566 struct stat statbuf;
5569 /* No device was given explicitly, and we are trying some
5570 likely things. But opening /dev/hdc may produce errors like
5571 "hdc: tray open or drive not ready"
5572 if it happens to be a CD-ROM drive. It even happens that
5573 the process hangs on the attempt to read a music CD.
5574 So try to be careful. This only works since 2.1.73. */
5576 if (strncmp("/dev/hd", device, 7))
5579 snprintf(buf, sizeof(buf), "/proc/ide/%s/media", device+5);
5580 procf = fopen(buf, "r");
5581 if (procf != NULL && fgets(buf, sizeof(buf), procf))
5582 is_ide = (!strncmp(buf, "cdrom", 5) ||
5583 !strncmp(buf, "tape", 4));
5585 /* Now when this proc file does not exist, skip the
5586 device when it is read-only. */
5587 if (stat(device, &statbuf) == 0)
5588 is_ide = ((statbuf.st_mode & 0222) == 0);
5597 try(const char *device, int user_specified)
5601 disk_device = device;
5602 if (setjmp(listingbuf))
5604 if (!user_specified)
5605 if (is_ide_cdrom_or_tape(device))
5607 if ((fd = open(disk_device, type_open)) >= 0) {
5608 gb = get_boot(try_only);
5609 if (gb > 0) { /* I/O error */
5611 } else if (gb < 0) { /* no DOS signature */
5612 list_disk_geometry();
5613 if (label_aix == current_label_type){
5616 #ifdef CONFIG_FEATURE_OSF_LABEL
5617 if (btrydev(device) < 0)
5620 _("Disk %s doesn't contain a valid "
5621 "partition table\n"), device);
5626 #ifdef CONFIG_FEATURE_FDISK_WRITABLE
5627 if (label_sun != current_label_type && partitions > 4){
5628 delete_partition(ext_index);
5633 /* Ignore other errors, since we try IDE
5634 and SCSI hard disks which may not be
5635 installed on the system. */
5636 if (errno == EACCES) {
5637 fprintf(stderr, _("Cannot open %s\n"), device);
5643 /* for fdisk -l: try all things in /proc/partitions
5644 that look like a partition name (do not end in a digit) */
5649 char line[100], ptname[100], devname[120], *s;
5652 procpt = bb_wfopen(PROC_PARTITIONS, "r");
5654 while (fgets(line, sizeof(line), procpt)) {
5655 if (sscanf(line, " %d %d %d %[^\n ]",
5656 &ma, &mi, &sz, ptname) != 4)
5658 for (s = ptname; *s; s++);
5661 sprintf(devname, "/dev/%s", ptname);
5664 #ifdef CONFIG_FEATURE_CLEAN_UP
5669 #ifdef CONFIG_FEATURE_FDISK_WRITABLE
5671 unknown_command(int c)
5673 printf(_("%c: unknown command\n"), c);
5677 int fdisk_main(int argc, char **argv)
5680 #ifdef CONFIG_FEATURE_FDISK_WRITABLE
5683 #ifdef CONFIG_FEATURE_FDISK_BLKSIZE
5689 * fdisk -l [-b sectorsize] [-u] device ...
5690 * fdisk -s [partition] ...
5691 * fdisk [-b sectorsize] [-u] device
5693 * Options -C, -H, -S set the geometry.
5696 while ((c = getopt(argc, argv, "b:C:H:lS:uvV"
5697 #ifdef CONFIG_FEATURE_FDISK_BLKSIZE
5703 /* Ugly: this sector size is really per device,
5704 so cannot be combined with multiple disks,
5705 and te same goes for the C/H/S options.
5707 sector_size = atoi(optarg);
5708 if (sector_size != 512 && sector_size != 1024 &&
5709 sector_size != 2048)
5712 user_set_sector_size = 1;
5715 user_cylinders = atoi(optarg);
5718 user_heads = atoi(optarg);
5719 if (user_heads <= 0 || user_heads >= 256)
5723 user_sectors = atoi(optarg);
5724 if (user_sectors <= 0 || user_sectors >= 64)
5728 #ifdef CONFIG_FEATURE_FDISK_WRITABLE
5732 #ifdef CONFIG_FEATURE_FDISK_BLKSIZE
5738 display_in_cyl_units = 0;
5742 printf("fdisk v" UTIL_LINUX_VERSION "\n");
5750 printf(_("This kernel finds the sector size itself - "
5751 "-b option ignored\n"));
5753 if (user_set_sector_size && argc-optind != 1)
5754 printf(_("Warning: the -b (set sector size) option should"
5755 " be used with one specified device\n"));
5758 #ifdef CONFIG_FEATURE_FDISK_WRITABLE
5762 type_open = O_RDONLY;
5763 if (argc > optind) {
5766 /* avoid gcc warning:
5767 variable `k' might be clobbered by `longjmp' */
5771 for (k = optind; k < argc; k++)
5774 /* we no longer have default device names */
5775 /* but, we can use /proc/partitions instead */
5779 #ifdef CONFIG_FEATURE_FDISK_WRITABLE
5783 #ifdef CONFIG_FEATURE_FDISK_BLKSIZE
5789 type_open = O_RDONLY;
5791 opts = argc - optind;
5795 for (j = optind; j < argc; j++) {
5796 disk_device = argv[j];
5797 if ((fd = open(disk_device, type_open)) < 0)
5798 fdisk_fatal(unable_to_open);
5799 if (ioctl(fd, BLKGETSIZE, &size))
5800 fdisk_fatal(ioctl_error);
5803 printf("%ld\n", size/2);
5805 printf("%s: %ld\n", argv[j], size/2);
5811 #ifdef CONFIG_FEATURE_FDISK_WRITABLE
5812 if (argc-optind == 1)
5813 disk_device = argv[optind];
5819 #ifdef CONFIG_FEATURE_OSF_LABEL
5820 if (label_osf == current_label_type) {
5821 /* OSF label, and no DOS label */
5822 printf(_("Detected an OSF/1 disklabel on %s, entering "
5823 "disklabel mode.\n"),
5826 /*Why do we do this? It seems to be counter-intuitive*/
5827 current_label_type = label_dos;
5828 /* If we return we may want to make an empty DOS label? */
5834 c = tolower(read_char(_("Command (m for help): ")));
5837 if (label_dos == current_label_type)
5838 toggle_active(get_partition(1, partitions));
5839 #ifdef CONFIG_FEATURE_SUN_LABEL
5840 else if (label_sun == current_label_type)
5841 toggle_sunflags(get_partition(1, partitions),
5844 #ifdef CONFIG_FEATURE_SGI_LABEL
5845 else if (label_sgi == current_label_type)
5846 sgi_set_bootpartition(
5847 get_partition(1, partitions));
5853 #ifdef CONFIG_FEATURE_SGI_LABEL
5854 if (label_sgi == current_label_type) {
5855 printf(_("\nThe current boot file is: %s\n"),
5856 sgi_get_bootfile());
5857 if (read_chars(_("Please enter the name of the "
5858 "new boot file: ")) == '\n')
5859 printf(_("Boot file unchanged\n"));
5861 sgi_set_bootfile(line_ptr);
5864 #ifdef CONFIG_FEATURE_OSF_LABEL
5869 if (label_dos == current_label_type)
5870 toggle_dos_compatibility_flag();
5871 #ifdef CONFIG_FEATURE_SUN_LABEL
5872 else if (label_sun == current_label_type)
5873 toggle_sunflags(get_partition(1, partitions),
5876 #ifdef CONFIG_FEATURE_SGI_LABEL
5877 else if (label_sgi == current_label_type)
5878 sgi_set_swappartition(
5879 get_partition(1, partitions));
5887 #ifdef CONFIG_FEATURE_SGI_LABEL
5888 /* If sgi_label then don't use get_existing_partition,
5889 let the user select a partition, since
5890 get_existing_partition() only works for Linux-like
5892 if (label_sgi != current_label_type) {
5893 j = get_existing_partition(1, partitions);
5895 j = get_partition(1, partitions);
5898 j = get_existing_partition(1, partitions);
5901 delete_partition(j);
5905 #ifdef CONFIG_FEATURE_SGI_LABEL
5906 if (label_sgi == current_label_type)
5912 list_types(get_sys_types());
5931 #ifdef CONFIG_FEATURE_SUN_LABEL
5945 write_table(); /* does not return */
5947 #ifdef CONFIG_FEATURE_FDISK_ADVANCED
5949 #ifdef CONFIG_FEATURE_SGI_LABEL
5950 if (label_sgi == current_label_type) {
5952 _("\n\tSorry, no experts menu for SGI "
5953 "partition tables available.\n\n"));
5966 #endif /* CONFIG_FEATURE_FDISK_WRITABLE */